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 //===----------------------------------------------------------------------===//
11 #include "InputInfo.h"
12 #include "ToolChains.h"
13 #include "clang/Basic/ObjCRuntime.h"
14 #include "clang/Basic/Version.h"
15 #include "clang/Driver/Action.h"
16 #include "clang/Driver/Compilation.h"
17 #include "clang/Driver/Driver.h"
18 #include "clang/Driver/DriverDiagnostic.h"
19 #include "clang/Driver/Job.h"
20 #include "clang/Driver/Options.h"
21 #include "clang/Driver/SanitizerArgs.h"
22 #include "clang/Driver/ToolChain.h"
23 #include "clang/Driver/Util.h"
24 #include "clang/Sema/SemaDiagnostic.h"
25 #include "llvm/ADT/SmallString.h"
26 #include "llvm/ADT/StringExtras.h"
27 #include "llvm/ADT/StringSwitch.h"
28 #include "llvm/ADT/Twine.h"
29 #include "llvm/Option/Arg.h"
30 #include "llvm/Option/ArgList.h"
31 #include "llvm/Option/Option.h"
32 #include "llvm/Support/ErrorHandling.h"
33 #include "llvm/Support/FileSystem.h"
34 #include "llvm/Support/Format.h"
35 #include "llvm/Support/Host.h"
36 #include "llvm/Support/Path.h"
37 #include "llvm/Support/Program.h"
38 #include "llvm/Support/Process.h"
39 #include "llvm/Support/raw_ostream.h"
42 using namespace clang::driver;
43 using namespace clang::driver::tools;
44 using namespace clang;
45 using namespace llvm::opt;
47 /// CheckPreprocessingOptions - Perform some validation of preprocessing
48 /// arguments that is shared with gcc.
49 static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
50 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
51 if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP())
52 D.Diag(diag::err_drv_argument_only_allowed_with)
53 << A->getAsString(Args) << "-E";
56 /// CheckCodeGenerationOptions - Perform some validation of code generation
57 /// arguments that is shared with gcc.
58 static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
59 // In gcc, only ARM checks this, but it seems reasonable to check universally.
60 if (Args.hasArg(options::OPT_static))
61 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
62 options::OPT_mdynamic_no_pic))
63 D.Diag(diag::err_drv_argument_not_allowed_with)
64 << A->getAsString(Args) << "-static";
67 // Quote target names for inclusion in GNU Make dependency files.
68 // Only the characters '$', '#', ' ', '\t' are quoted.
69 static void QuoteTarget(StringRef Target,
70 SmallVectorImpl<char> &Res) {
71 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
75 // Escape the preceding backslashes
76 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
79 // Escape the space/tab
92 Res.push_back(Target[i]);
96 static void addDirectoryList(const ArgList &Args,
97 ArgStringList &CmdArgs,
100 const char *DirList = ::getenv(EnvVar);
101 bool CombinedArg = false;
104 return; // Nothing to do.
106 StringRef Name(ArgName);
107 if (Name.equals("-I") || Name.equals("-L"))
110 StringRef Dirs(DirList);
111 if (Dirs.empty()) // Empty string should not add '.'.
114 StringRef::size_type Delim;
115 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
116 if (Delim == 0) { // Leading colon.
118 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
120 CmdArgs.push_back(ArgName);
121 CmdArgs.push_back(".");
125 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
127 CmdArgs.push_back(ArgName);
128 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
131 Dirs = Dirs.substr(Delim + 1);
134 if (Dirs.empty()) { // Trailing colon.
136 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
138 CmdArgs.push_back(ArgName);
139 CmdArgs.push_back(".");
141 } else { // Add the last path.
143 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
145 CmdArgs.push_back(ArgName);
146 CmdArgs.push_back(Args.MakeArgString(Dirs));
151 static void AddLinkerInputs(const ToolChain &TC,
152 const InputInfoList &Inputs, const ArgList &Args,
153 ArgStringList &CmdArgs) {
154 const Driver &D = TC.getDriver();
156 // Add extra linker input arguments which are not treated as inputs
157 // (constructed via -Xarch_).
158 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
160 for (InputInfoList::const_iterator
161 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
162 const InputInfo &II = *it;
164 if (!TC.HasNativeLLVMSupport()) {
165 // Don't try to pass LLVM inputs unless we have native support.
166 if (II.getType() == types::TY_LLVM_IR ||
167 II.getType() == types::TY_LTO_IR ||
168 II.getType() == types::TY_LLVM_BC ||
169 II.getType() == types::TY_LTO_BC)
170 D.Diag(diag::err_drv_no_linker_llvm_support)
171 << TC.getTripleString();
174 // Add filenames immediately.
175 if (II.isFilename()) {
176 CmdArgs.push_back(II.getFilename());
180 // Otherwise, this is a linker input argument.
181 const Arg &A = II.getInputArg();
183 // Handle reserved library options.
184 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
185 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
186 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
187 TC.AddCCKextLibArgs(Args, CmdArgs);
189 A.renderAsInput(Args, CmdArgs);
192 // LIBRARY_PATH - included following the user specified library paths.
193 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
196 /// \brief Determine whether Objective-C automated reference counting is
198 static bool isObjCAutoRefCount(const ArgList &Args) {
199 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
202 /// \brief Determine whether we are linking the ObjC runtime.
203 static bool isObjCRuntimeLinked(const ArgList &Args) {
204 if (isObjCAutoRefCount(Args)) {
205 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
208 return Args.hasArg(options::OPT_fobjc_link_runtime);
211 static void addProfileRT(const ToolChain &TC, const ArgList &Args,
212 ArgStringList &CmdArgs,
213 llvm::Triple Triple) {
214 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
215 Args.hasArg(options::OPT_fprofile_generate) ||
216 Args.hasArg(options::OPT_fcreate_profile) ||
217 Args.hasArg(options::OPT_coverage)))
220 // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to
221 // the link line. We cannot do the same thing because unlike gcov there is a
222 // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is
223 // not supported by old linkers.
224 std::string ProfileRT =
225 std::string(TC.getDriver().Dir) + "/../lib/libprofile_rt.a";
227 CmdArgs.push_back(Args.MakeArgString(ProfileRT));
230 static bool forwardToGCC(const Option &O) {
231 // Don't forward inputs from the original command line. They are added from
233 return O.getKind() != Option::InputClass &&
234 !O.hasFlag(options::DriverOption) &&
235 !O.hasFlag(options::LinkerInput);
238 void Clang::AddPreprocessingOptions(Compilation &C,
242 ArgStringList &CmdArgs,
243 const InputInfo &Output,
244 const InputInfoList &Inputs) const {
247 CheckPreprocessingOptions(D, Args);
249 Args.AddLastArg(CmdArgs, options::OPT_C);
250 Args.AddLastArg(CmdArgs, options::OPT_CC);
252 // Handle dependency file generation.
253 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
254 (A = Args.getLastArg(options::OPT_MD)) ||
255 (A = Args.getLastArg(options::OPT_MMD))) {
256 // Determine the output location.
258 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
259 DepFile = MF->getValue();
260 C.addFailureResultFile(DepFile, &JA);
261 } else if (Output.getType() == types::TY_Dependencies) {
262 DepFile = Output.getFilename();
263 } else if (A->getOption().matches(options::OPT_M) ||
264 A->getOption().matches(options::OPT_MM)) {
267 DepFile = getDependencyFileName(Args, Inputs);
268 C.addFailureResultFile(DepFile, &JA);
270 CmdArgs.push_back("-dependency-file");
271 CmdArgs.push_back(DepFile);
273 // Add a default target if one wasn't specified.
274 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
275 const char *DepTarget;
277 // If user provided -o, that is the dependency target, except
278 // when we are only generating a dependency file.
279 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
280 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
281 DepTarget = OutputOpt->getValue();
283 // Otherwise derive from the base input.
285 // FIXME: This should use the computed output file location.
286 SmallString<128> P(Inputs[0].getBaseInput());
287 llvm::sys::path::replace_extension(P, "o");
288 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
291 CmdArgs.push_back("-MT");
292 SmallString<128> Quoted;
293 QuoteTarget(DepTarget, Quoted);
294 CmdArgs.push_back(Args.MakeArgString(Quoted));
297 if (A->getOption().matches(options::OPT_M) ||
298 A->getOption().matches(options::OPT_MD))
299 CmdArgs.push_back("-sys-header-deps");
302 if (Args.hasArg(options::OPT_MG)) {
303 if (!A || A->getOption().matches(options::OPT_MD) ||
304 A->getOption().matches(options::OPT_MMD))
305 D.Diag(diag::err_drv_mg_requires_m_or_mm);
306 CmdArgs.push_back("-MG");
309 Args.AddLastArg(CmdArgs, options::OPT_MP);
311 // Convert all -MQ <target> args to -MT <quoted target>
312 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
314 ie = Args.filtered_end(); it != ie; ++it) {
318 if (A->getOption().matches(options::OPT_MQ)) {
319 CmdArgs.push_back("-MT");
320 SmallString<128> Quoted;
321 QuoteTarget(A->getValue(), Quoted);
322 CmdArgs.push_back(Args.MakeArgString(Quoted));
324 // -MT flag - no change
326 A->render(Args, CmdArgs);
330 // Add -i* options, and automatically translate to
331 // -include-pch/-include-pth for transparent PCH support. It's
332 // wonky, but we include looking for .gch so we can support seamless
333 // replacement into a build system already set up to be generating
335 bool RenderedImplicitInclude = false;
336 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
337 ie = Args.filtered_end(); it != ie; ++it) {
340 if (A->getOption().matches(options::OPT_include)) {
341 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
342 RenderedImplicitInclude = true;
344 // Use PCH if the user requested it.
345 bool UsePCH = D.CCCUsePCH;
347 bool FoundPTH = false;
348 bool FoundPCH = false;
349 SmallString<128> P(A->getValue());
350 // We want the files to have a name like foo.h.pch. Add a dummy extension
351 // so that replace_extension does the right thing.
354 llvm::sys::path::replace_extension(P, "pch");
355 if (llvm::sys::fs::exists(P.str()))
360 llvm::sys::path::replace_extension(P, "pth");
361 if (llvm::sys::fs::exists(P.str()))
365 if (!FoundPCH && !FoundPTH) {
366 llvm::sys::path::replace_extension(P, "gch");
367 if (llvm::sys::fs::exists(P.str())) {
373 if (FoundPCH || FoundPTH) {
374 if (IsFirstImplicitInclude) {
377 CmdArgs.push_back("-include-pch");
379 CmdArgs.push_back("-include-pth");
380 CmdArgs.push_back(Args.MakeArgString(P.str()));
383 // Ignore the PCH if not first on command line and emit warning.
384 D.Diag(diag::warn_drv_pch_not_first_include)
385 << P.str() << A->getAsString(Args);
390 // Not translated, render as usual.
392 A->render(Args, CmdArgs);
395 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
396 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
397 options::OPT_index_header_map);
399 // Add -Wp, and -Xassembler if using the preprocessor.
401 // FIXME: There is a very unfortunate problem here, some troubled
402 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
403 // really support that we would have to parse and then translate
405 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
406 options::OPT_Xpreprocessor);
408 // -I- is a deprecated GCC feature, reject it.
409 if (Arg *A = Args.getLastArg(options::OPT_I_))
410 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
412 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
413 // -isysroot to the CC1 invocation.
414 StringRef sysroot = C.getSysRoot();
416 if (!Args.hasArg(options::OPT_isysroot)) {
417 CmdArgs.push_back("-isysroot");
418 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
422 // Parse additional include paths from environment variables.
423 // FIXME: We should probably sink the logic for handling these from the
424 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
425 // CPATH - included following the user specified includes (but prior to
426 // builtin and standard includes).
427 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
428 // C_INCLUDE_PATH - system includes enabled when compiling C.
429 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
430 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
431 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
432 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
433 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
434 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
435 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
437 // Add C++ include arguments, if needed.
438 if (types::isCXX(Inputs[0].getType()))
439 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
441 // Add system include arguments.
442 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
445 /// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
448 // FIXME: This is redundant with -mcpu, why does LLVM use this.
449 // FIXME: tblgen this, or kill it!
450 static const char *getLLVMArchSuffixForARM(StringRef CPU) {
451 return llvm::StringSwitch<const char *>(CPU)
452 .Case("strongarm", "v4")
453 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
454 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
455 .Cases("arm920", "arm920t", "arm922t", "v4t")
456 .Cases("arm940t", "ep9312","v4t")
457 .Cases("arm10tdmi", "arm1020t", "v5")
458 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
459 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
460 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
461 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
462 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
463 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
464 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "v7")
465 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "v7")
466 .Cases("cortex-r4", "cortex-r5", "v7r")
467 .Case("cortex-m0", "v6m")
468 .Case("cortex-m3", "v7m")
469 .Case("cortex-m4", "v7em")
470 .Case("cortex-a9-mp", "v7f")
471 .Case("swift", "v7s")
472 .Cases("cortex-a53", "cortex-a57", "v8")
476 /// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
478 // FIXME: tblgen this.
479 static std::string getARMTargetCPU(const ArgList &Args,
480 const llvm::Triple &Triple) {
481 // FIXME: Warn on inconsistent use of -mcpu and -march.
483 // If we have -mcpu=, use that.
484 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
485 StringRef MCPU = A->getValue();
486 // Handle -mcpu=native.
487 if (MCPU == "native")
488 return llvm::sys::getHostCPUName();
494 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
495 // Otherwise, if we have -march= choose the base CPU for that arch.
496 MArch = A->getValue();
498 // Otherwise, use the Arch from the triple.
499 MArch = Triple.getArchName();
502 if (Triple.getOS() == llvm::Triple::NetBSD) {
503 if (MArch == "armv6")
504 return "arm1176jzf-s";
507 // Handle -march=native.
508 std::string NativeMArch;
509 if (MArch == "native") {
510 std::string CPU = llvm::sys::getHostCPUName();
511 if (CPU != "generic") {
512 // Translate the native cpu into the architecture. The switch below will
513 // then chose the minimum cpu for that arch.
514 NativeMArch = std::string("arm") + getLLVMArchSuffixForARM(CPU);
519 return llvm::StringSwitch<const char *>(MArch)
520 .Cases("armv2", "armv2a","arm2")
521 .Case("armv3", "arm6")
522 .Case("armv3m", "arm7m")
523 .Case("armv4", "strongarm")
524 .Case("armv4t", "arm7tdmi")
525 .Cases("armv5", "armv5t", "arm10tdmi")
526 .Cases("armv5e", "armv5te", "arm1022e")
527 .Case("armv5tej", "arm926ej-s")
528 .Cases("armv6", "armv6k", "arm1136jf-s")
529 .Case("armv6j", "arm1136j-s")
530 .Cases("armv6z", "armv6zk", "arm1176jzf-s")
531 .Case("armv6t2", "arm1156t2-s")
532 .Cases("armv6m", "armv6-m", "cortex-m0")
533 .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
534 .Cases("armv7em", "armv7e-m", "cortex-m4")
535 .Cases("armv7f", "armv7-f", "cortex-a9-mp")
536 .Cases("armv7s", "armv7-s", "swift")
537 .Cases("armv7r", "armv7-r", "cortex-r4")
538 .Cases("armv7m", "armv7-m", "cortex-m3")
539 .Cases("armv8", "armv8a", "armv8-a", "cortex-a53")
540 .Case("ep9312", "ep9312")
541 .Case("iwmmxt", "iwmmxt")
542 .Case("xscale", "xscale")
543 // If all else failed, return the most base CPU with thumb interworking
544 // supported by LLVM.
545 .Default("arm7tdmi");
548 /// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are targeting.
550 // FIXME: tblgen this.
551 static std::string getAArch64TargetCPU(const ArgList &Args,
552 const llvm::Triple &Triple) {
553 // FIXME: Warn on inconsistent use of -mcpu and -march.
555 // If we have -mcpu=, use that.
556 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
557 StringRef MCPU = A->getValue();
558 // Handle -mcpu=native.
559 if (MCPU == "native")
560 return llvm::sys::getHostCPUName();
568 // FIXME: Move to target hook.
569 static bool isSignedCharDefault(const llvm::Triple &Triple) {
570 switch (Triple.getArch()) {
574 case llvm::Triple::aarch64:
575 case llvm::Triple::arm:
576 case llvm::Triple::ppc:
577 case llvm::Triple::ppc64:
578 if (Triple.isOSDarwin())
582 case llvm::Triple::ppc64le:
583 case llvm::Triple::systemz:
584 case llvm::Triple::xcore:
589 static bool isNoCommonDefault(const llvm::Triple &Triple) {
590 switch (Triple.getArch()) {
594 case llvm::Triple::xcore:
601 // FIXME: Centralize feature selection, defaulting shouldn't be also in the
603 static void getAArch64FPUFeatures(const Driver &D, const Arg *A,
605 std::vector<const char *> &Features) {
606 StringRef FPU = A->getValue();
607 if (FPU == "fp-armv8") {
608 Features.push_back("+fp-armv8");
609 } else if (FPU == "neon-fp-armv8") {
610 Features.push_back("+fp-armv8");
611 Features.push_back("+neon");
612 } else if (FPU == "crypto-neon-fp-armv8") {
613 Features.push_back("+fp-armv8");
614 Features.push_back("+neon");
615 Features.push_back("+crypto");
616 } else if (FPU == "neon") {
617 Features.push_back("+neon");
618 } else if (FPU == "none") {
619 Features.push_back("-fp-armv8");
620 Features.push_back("-crypto");
621 Features.push_back("-neon");
623 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
627 static void getARMHWDivFeatures(const Driver &D, const Arg *A,
629 std::vector<const char *> &Features) {
630 StringRef HWDiv = A->getValue();
631 if (HWDiv == "arm") {
632 Features.push_back("+hwdiv-arm");
633 Features.push_back("-hwdiv");
634 } else if (HWDiv == "thumb") {
635 Features.push_back("-hwdiv-arm");
636 Features.push_back("+hwdiv");
637 } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
638 Features.push_back("+hwdiv-arm");
639 Features.push_back("+hwdiv");
640 } else if (HWDiv == "none") {
641 Features.push_back("-hwdiv-arm");
642 Features.push_back("-hwdiv");
644 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
649 // FIXME: Centralize feature selection, defaulting shouldn't be also in the
651 static void getARMFPUFeatures(const Driver &D, const Arg *A,
653 std::vector<const char *> &Features) {
654 StringRef FPU = A->getValue();
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 Features.push_back("-vfp2");
660 Features.push_back("-vfp3");
661 Features.push_back("-neon");
662 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
663 Features.push_back("+vfp3");
664 Features.push_back("+d16");
665 Features.push_back("-neon");
666 } else if (FPU == "vfp") {
667 Features.push_back("+vfp2");
668 Features.push_back("-neon");
669 } else if (FPU == "vfp3" || FPU == "vfpv3") {
670 Features.push_back("+vfp3");
671 Features.push_back("-neon");
672 } else if (FPU == "fp-armv8") {
673 Features.push_back("+fp-armv8");
674 Features.push_back("-neon");
675 Features.push_back("-crypto");
676 } else if (FPU == "neon-fp-armv8") {
677 Features.push_back("+fp-armv8");
678 Features.push_back("+neon");
679 Features.push_back("-crypto");
680 } else if (FPU == "crypto-neon-fp-armv8") {
681 Features.push_back("+fp-armv8");
682 Features.push_back("+neon");
683 Features.push_back("+crypto");
684 } else if (FPU == "neon") {
685 Features.push_back("+neon");
686 } else if (FPU == "none") {
687 Features.push_back("-vfp2");
688 Features.push_back("-vfp3");
689 Features.push_back("-vfp4");
690 Features.push_back("-fp-armv8");
691 Features.push_back("-crypto");
692 Features.push_back("-neon");
694 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
697 // Select the float ABI as determined by -msoft-float, -mhard-float, and
699 static StringRef getARMFloatABI(const Driver &D,
701 const llvm::Triple &Triple) {
703 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
704 options::OPT_mhard_float,
705 options::OPT_mfloat_abi_EQ)) {
706 if (A->getOption().matches(options::OPT_msoft_float))
708 else if (A->getOption().matches(options::OPT_mhard_float))
711 FloatABI = A->getValue();
712 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
713 D.Diag(diag::err_drv_invalid_mfloat_abi)
714 << A->getAsString(Args);
720 // If unspecified, choose the default based on the platform.
721 if (FloatABI.empty()) {
722 switch (Triple.getOS()) {
723 case llvm::Triple::Darwin:
724 case llvm::Triple::MacOSX:
725 case llvm::Triple::IOS: {
726 // Darwin defaults to "softfp" for v6 and v7.
728 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
729 std::string ArchName =
730 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
731 if (StringRef(ArchName).startswith("v6") ||
732 StringRef(ArchName).startswith("v7"))
739 case llvm::Triple::FreeBSD:
740 // FreeBSD defaults to soft float
745 switch(Triple.getEnvironment()) {
746 case llvm::Triple::GNUEABIHF:
749 case llvm::Triple::GNUEABI:
752 case llvm::Triple::EABI:
753 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
756 case llvm::Triple::Android: {
757 std::string ArchName =
758 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
759 if (StringRef(ArchName).startswith("v7"))
766 // Assume "soft", but warn the user we are guessing.
768 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
777 static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
779 std::vector<const char *> &Features) {
780 StringRef FloatABI = getARMFloatABI(D, Args, Triple);
781 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
782 // yet (it uses the -mfloat-abi and -msoft-float options), and it is
783 // stripped out by the ARM target.
784 // Use software floating point operations?
785 if (FloatABI == "soft")
786 Features.push_back("+soft-float");
788 // Use software floating point argument passing?
789 if (FloatABI != "hard")
790 Features.push_back("+soft-float-abi");
793 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
794 getARMFPUFeatures(D, A, Args, Features);
795 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
796 getARMHWDivFeatures(D, A, Args, Features);
798 // Setting -msoft-float effectively disables NEON because of the GCC
799 // implementation, although the same isn't true of VFP or VFP3.
800 if (FloatABI == "soft")
801 Features.push_back("-neon");
804 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
805 options::OPT_mnocrc)) {
806 if (A->getOption().matches(options::OPT_mcrc))
807 Features.push_back("+crc");
809 Features.push_back("-crc");
813 void Clang::AddARMTargetArgs(const ArgList &Args,
814 ArgStringList &CmdArgs,
815 bool KernelOrKext) const {
816 const Driver &D = getToolChain().getDriver();
817 // Get the effective triple, which takes into account the deployment target.
818 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
819 llvm::Triple Triple(TripleStr);
820 std::string CPUName = getARMTargetCPU(Args, Triple);
822 // Select the ABI to use.
824 // FIXME: Support -meabi.
825 const char *ABIName = 0;
826 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
827 ABIName = A->getValue();
828 } else if (Triple.isOSDarwin()) {
829 // The backend is hardwired to assume AAPCS for M-class processors, ensure
830 // the frontend matches that.
831 if (Triple.getEnvironment() == llvm::Triple::EABI ||
832 StringRef(CPUName).startswith("cortex-m")) {
835 ABIName = "apcs-gnu";
838 // Select the default based on the platform.
839 switch(Triple.getEnvironment()) {
840 case llvm::Triple::Android:
841 case llvm::Triple::GNUEABI:
842 case llvm::Triple::GNUEABIHF:
843 ABIName = "aapcs-linux";
845 case llvm::Triple::EABI:
849 ABIName = "apcs-gnu";
852 CmdArgs.push_back("-target-abi");
853 CmdArgs.push_back(ABIName);
855 // Determine floating point ABI from the options & target defaults.
856 StringRef FloatABI = getARMFloatABI(D, Args, Triple);
857 if (FloatABI == "soft") {
858 // Floating point operations and argument passing are soft.
860 // FIXME: This changes CPP defines, we need -target-soft-float.
861 CmdArgs.push_back("-msoft-float");
862 CmdArgs.push_back("-mfloat-abi");
863 CmdArgs.push_back("soft");
864 } else if (FloatABI == "softfp") {
865 // Floating point operations are hard, but argument passing is soft.
866 CmdArgs.push_back("-mfloat-abi");
867 CmdArgs.push_back("soft");
869 // Floating point operations and argument passing are hard.
870 assert(FloatABI == "hard" && "Invalid float abi!");
871 CmdArgs.push_back("-mfloat-abi");
872 CmdArgs.push_back("hard");
875 // Kernel code has more strict alignment requirements.
877 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
878 CmdArgs.push_back("-backend-option");
879 CmdArgs.push_back("-arm-long-calls");
882 CmdArgs.push_back("-backend-option");
883 CmdArgs.push_back("-arm-strict-align");
885 // The kext linker doesn't know how to deal with movw/movt.
886 CmdArgs.push_back("-backend-option");
887 CmdArgs.push_back("-arm-use-movt=0");
890 // Setting -mno-global-merge disables the codegen global merge pass. Setting
891 // -mglobal-merge has no effect as the pass is enabled by default.
892 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
893 options::OPT_mno_global_merge)) {
894 if (A->getOption().matches(options::OPT_mno_global_merge))
895 CmdArgs.push_back("-mno-global-merge");
898 if (!Args.hasFlag(options::OPT_mimplicit_float,
899 options::OPT_mno_implicit_float,
901 CmdArgs.push_back("-no-implicit-float");
903 // llvm does not support reserving registers in general. There is support
904 // for reserving r9 on ARM though (defined as a platform-specific register
906 if (Args.hasArg(options::OPT_ffixed_r9)) {
907 CmdArgs.push_back("-backend-option");
908 CmdArgs.push_back("-arm-reserve-r9");
912 // Get CPU and ABI names. They are not independent
913 // so we have to calculate them together.
914 static void getMipsCPUAndABI(const ArgList &Args,
915 const llvm::Triple &Triple,
917 StringRef &ABIName) {
918 const char *DefMips32CPU = "mips32";
919 const char *DefMips64CPU = "mips64";
921 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
922 options::OPT_mcpu_EQ))
923 CPUName = A->getValue();
925 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
926 ABIName = A->getValue();
927 // Convert a GNU style Mips ABI name to the name
928 // accepted by LLVM Mips backend.
929 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
935 // Setup default CPU and ABI names.
936 if (CPUName.empty() && ABIName.empty()) {
937 switch (Triple.getArch()) {
939 llvm_unreachable("Unexpected triple arch name");
940 case llvm::Triple::mips:
941 case llvm::Triple::mipsel:
942 CPUName = DefMips32CPU;
944 case llvm::Triple::mips64:
945 case llvm::Triple::mips64el:
946 CPUName = DefMips64CPU;
951 if (!ABIName.empty()) {
952 // Deduce CPU name from ABI name.
953 CPUName = llvm::StringSwitch<const char *>(ABIName)
954 .Cases("32", "o32", "eabi", DefMips32CPU)
955 .Cases("n32", "n64", "64", DefMips64CPU)
958 else if (!CPUName.empty()) {
959 // Deduce ABI name from CPU name.
960 ABIName = llvm::StringSwitch<const char *>(CPUName)
961 .Cases("mips32", "mips32r2", "o32")
962 .Cases("mips64", "mips64r2", "n64")
966 // FIXME: Warn on inconsistent cpu and abi usage.
969 // Convert ABI name to the GNU tools acceptable variant.
970 static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
971 return llvm::StringSwitch<llvm::StringRef>(ABI)
977 // Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
979 static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
981 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
982 options::OPT_mhard_float,
983 options::OPT_mfloat_abi_EQ)) {
984 if (A->getOption().matches(options::OPT_msoft_float))
986 else if (A->getOption().matches(options::OPT_mhard_float))
989 FloatABI = A->getValue();
990 if (FloatABI != "soft" && FloatABI != "hard") {
991 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
997 // If unspecified, choose the default based on the platform.
998 if (FloatABI.empty()) {
999 // Assume "hard", because it's a default value used by gcc.
1000 // When we start to recognize specific target MIPS processors,
1001 // we will be able to select the default more correctly.
1008 static void AddTargetFeature(const ArgList &Args,
1009 std::vector<const char *> &Features,
1010 OptSpecifier OnOpt, OptSpecifier OffOpt,
1011 StringRef FeatureName) {
1012 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
1013 if (A->getOption().matches(OnOpt))
1014 Features.push_back(Args.MakeArgString("+" + FeatureName));
1016 Features.push_back(Args.MakeArgString("-" + FeatureName));
1020 static void getMIPSTargetFeatures(const Driver &D, const ArgList &Args,
1021 std::vector<const char *> &Features) {
1022 StringRef FloatABI = getMipsFloatABI(D, Args);
1023 bool IsMips16 = Args.getLastArg(options::OPT_mips16) != NULL;
1024 if (FloatABI == "soft" || (FloatABI == "hard" && IsMips16)) {
1025 // FIXME: Note, this is a hack. We need to pass the selected float
1026 // mode to the MipsTargetInfoBase to define appropriate macros there.
1027 // Now it is the only method.
1028 Features.push_back("+soft-float");
1031 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
1032 if (StringRef(A->getValue()) == "2008")
1033 Features.push_back("+nan2008");
1036 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1037 options::OPT_mdouble_float, "single-float");
1038 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1040 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1041 options::OPT_mno_micromips, "micromips");
1042 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1044 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1046 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1048 AddTargetFeature(Args, Features, options::OPT_mfp64, options::OPT_mfp32,
1052 void Clang::AddMIPSTargetArgs(const ArgList &Args,
1053 ArgStringList &CmdArgs) const {
1054 const Driver &D = getToolChain().getDriver();
1057 const llvm::Triple &Triple = getToolChain().getTriple();
1058 getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
1060 CmdArgs.push_back("-target-abi");
1061 CmdArgs.push_back(ABIName.data());
1063 StringRef FloatABI = getMipsFloatABI(D, Args);
1065 bool IsMips16 = Args.getLastArg(options::OPT_mips16) != NULL;
1067 if (FloatABI == "soft" || (FloatABI == "hard" && IsMips16)) {
1068 // Floating point operations and argument passing are soft.
1069 CmdArgs.push_back("-msoft-float");
1070 CmdArgs.push_back("-mfloat-abi");
1071 CmdArgs.push_back("soft");
1073 if (FloatABI == "hard" && IsMips16) {
1074 CmdArgs.push_back("-mllvm");
1075 CmdArgs.push_back("-mips16-hard-float");
1079 // Floating point operations and argument passing are hard.
1080 assert(FloatABI == "hard" && "Invalid float abi!");
1081 CmdArgs.push_back("-mfloat-abi");
1082 CmdArgs.push_back("hard");
1085 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1086 if (A->getOption().matches(options::OPT_mxgot)) {
1087 CmdArgs.push_back("-mllvm");
1088 CmdArgs.push_back("-mxgot");
1092 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1093 options::OPT_mno_ldc1_sdc1)) {
1094 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1095 CmdArgs.push_back("-mllvm");
1096 CmdArgs.push_back("-mno-ldc1-sdc1");
1100 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1101 options::OPT_mno_check_zero_division)) {
1102 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1103 CmdArgs.push_back("-mllvm");
1104 CmdArgs.push_back("-mno-check-zero-division");
1108 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1109 StringRef v = A->getValue();
1110 CmdArgs.push_back("-mllvm");
1111 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1116 /// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1117 static std::string getPPCTargetCPU(const ArgList &Args) {
1118 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1119 StringRef CPUName = A->getValue();
1121 if (CPUName == "native") {
1122 std::string CPU = llvm::sys::getHostCPUName();
1123 if (!CPU.empty() && CPU != "generic")
1129 return llvm::StringSwitch<const char *>(CPUName)
1130 .Case("common", "generic")
1132 .Case("440fp", "440")
1137 .Case("603e", "603e")
1138 .Case("603ev", "603ev")
1140 .Case("604e", "604e")
1142 .Case("630", "pwr3")
1144 .Case("7400", "7400")
1146 .Case("7450", "7450")
1153 .Case("e500mc", "e500mc")
1154 .Case("e5500", "e5500")
1155 .Case("power3", "pwr3")
1156 .Case("power4", "pwr4")
1157 .Case("power5", "pwr5")
1158 .Case("power5x", "pwr5x")
1159 .Case("power6", "pwr6")
1160 .Case("power6x", "pwr6x")
1161 .Case("power7", "pwr7")
1162 .Case("pwr3", "pwr3")
1163 .Case("pwr4", "pwr4")
1164 .Case("pwr5", "pwr5")
1165 .Case("pwr5x", "pwr5x")
1166 .Case("pwr6", "pwr6")
1167 .Case("pwr6x", "pwr6x")
1168 .Case("pwr7", "pwr7")
1169 .Case("powerpc", "ppc")
1170 .Case("powerpc64", "ppc64")
1171 .Case("powerpc64le", "ppc64le")
1178 static void getPPCTargetFeatures(const ArgList &Args,
1179 std::vector<const char *> &Features) {
1180 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1181 ie = Args.filtered_end();
1183 StringRef Name = (*it)->getOption().getName();
1187 assert(Name.startswith("m") && "Invalid feature name.");
1188 Name = Name.substr(1);
1190 bool IsNegative = Name.startswith("no-");
1192 Name = Name.substr(3);
1194 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1195 // pass the correct option to the backend while calling the frontend
1197 // TODO: Change the LLVM backend option maybe?
1198 if (Name == "mfcrf")
1201 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1204 // Altivec is a bit weird, allow overriding of the Altivec feature here.
1205 AddTargetFeature(Args, Features, options::OPT_faltivec,
1206 options::OPT_fno_altivec, "altivec");
1209 /// Get the (LLVM) name of the R600 gpu we are targeting.
1210 static std::string getR600TargetGPU(const ArgList &Args) {
1211 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1212 const char *GPUName = A->getValue();
1213 return llvm::StringSwitch<const char *>(GPUName)
1214 .Cases("rv630", "rv635", "r600")
1215 .Cases("rv610", "rv620", "rs780", "rs880")
1216 .Case("rv740", "rv770")
1217 .Case("palm", "cedar")
1218 .Cases("sumo", "sumo2", "sumo")
1219 .Case("hemlock", "cypress")
1220 .Case("aruba", "cayman")
1226 static void getSparcTargetFeatures(const ArgList &Args,
1227 std::vector<const char *> Features) {
1228 bool SoftFloatABI = true;
1230 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1231 if (A->getOption().matches(options::OPT_mhard_float))
1232 SoftFloatABI = false;
1235 Features.push_back("+soft-float");
1238 void Clang::AddSparcTargetArgs(const ArgList &Args,
1239 ArgStringList &CmdArgs) const {
1240 const Driver &D = getToolChain().getDriver();
1242 // Select the float ABI as determined by -msoft-float, -mhard-float, and
1244 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1245 options::OPT_mhard_float)) {
1246 if (A->getOption().matches(options::OPT_msoft_float))
1248 else if (A->getOption().matches(options::OPT_mhard_float))
1252 // If unspecified, choose the default based on the platform.
1253 if (FloatABI.empty()) {
1254 // Assume "soft", but warn the user we are guessing.
1256 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
1259 if (FloatABI == "soft") {
1260 // Floating point operations and argument passing are soft.
1262 // FIXME: This changes CPP defines, we need -target-soft-float.
1263 CmdArgs.push_back("-msoft-float");
1265 assert(FloatABI == "hard" && "Invalid float abi!");
1266 CmdArgs.push_back("-mhard-float");
1270 static const char *getSystemZTargetCPU(const ArgList &Args) {
1271 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1272 return A->getValue();
1276 static const char *getX86TargetCPU(const ArgList &Args,
1277 const llvm::Triple &Triple) {
1278 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1279 if (StringRef(A->getValue()) != "native") {
1280 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
1283 return A->getValue();
1286 // FIXME: Reject attempts to use -march=native unless the target matches
1289 // FIXME: We should also incorporate the detected target features for use
1291 std::string CPU = llvm::sys::getHostCPUName();
1292 if (!CPU.empty() && CPU != "generic")
1293 return Args.MakeArgString(CPU);
1296 // Select the default CPU if none was given (or detection failed).
1298 if (Triple.getArch() != llvm::Triple::x86_64 &&
1299 Triple.getArch() != llvm::Triple::x86)
1300 return 0; // This routine is only handling x86 targets.
1302 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1304 // FIXME: Need target hooks.
1305 if (Triple.isOSDarwin()) {
1306 if (Triple.getArchName() == "x86_64h")
1308 return Is64Bit ? "core2" : "yonah";
1311 // All x86 devices running Android have core2 as their common
1312 // denominator. This makes a better choice than pentium4.
1313 if (Triple.getEnvironment() == llvm::Triple::Android)
1316 // Everything else goes to x86-64 in 64-bit mode.
1320 switch (Triple.getOS()) {
1321 case llvm::Triple::FreeBSD:
1322 case llvm::Triple::NetBSD:
1323 case llvm::Triple::OpenBSD:
1325 case llvm::Triple::Haiku:
1327 case llvm::Triple::Bitrig:
1335 static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1336 switch(T.getArch()) {
1340 case llvm::Triple::aarch64:
1341 return getAArch64TargetCPU(Args, T);
1343 case llvm::Triple::arm:
1344 case llvm::Triple::thumb:
1345 return getARMTargetCPU(Args, T);
1347 case llvm::Triple::mips:
1348 case llvm::Triple::mipsel:
1349 case llvm::Triple::mips64:
1350 case llvm::Triple::mips64el: {
1353 getMipsCPUAndABI(Args, T, CPUName, ABIName);
1357 case llvm::Triple::ppc:
1358 case llvm::Triple::ppc64:
1359 case llvm::Triple::ppc64le: {
1360 std::string TargetCPUName = getPPCTargetCPU(Args);
1361 // LLVM may default to generating code for the native CPU,
1362 // but, like gcc, we default to a more generic option for
1363 // each architecture. (except on Darwin)
1364 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1365 if (T.getArch() == llvm::Triple::ppc64)
1366 TargetCPUName = "ppc64";
1367 else if (T.getArch() == llvm::Triple::ppc64le)
1368 TargetCPUName = "ppc64le";
1370 TargetCPUName = "ppc";
1372 return TargetCPUName;
1375 case llvm::Triple::sparc:
1376 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1377 return A->getValue();
1380 case llvm::Triple::x86:
1381 case llvm::Triple::x86_64:
1382 return getX86TargetCPU(Args, T);
1384 case llvm::Triple::hexagon:
1385 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1387 case llvm::Triple::systemz:
1388 return getSystemZTargetCPU(Args);
1390 case llvm::Triple::r600:
1391 return getR600TargetGPU(Args);
1395 static void getX86TargetFeatures(const llvm::Triple &Triple,
1396 const ArgList &Args,
1397 std::vector<const char *> &Features) {
1398 if (Triple.getArchName() == "x86_64h") {
1399 // x86_64h implies quite a few of the more modern subtarget features
1400 // for Haswell class CPUs, but not all of them. Opt-out of a few.
1401 Features.push_back("-rdrnd");
1402 Features.push_back("-aes");
1403 Features.push_back("-pclmul");
1404 Features.push_back("-rtm");
1405 Features.push_back("-hle");
1406 Features.push_back("-fsgsbase");
1409 // Now add any that the user explicitly requested on the command line,
1410 // which may override the defaults.
1411 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1412 ie = Args.filtered_end();
1414 StringRef Name = (*it)->getOption().getName();
1418 assert(Name.startswith("m") && "Invalid feature name.");
1419 Name = Name.substr(1);
1421 bool IsNegative = Name.startswith("no-");
1423 Name = Name.substr(3);
1425 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1429 void Clang::AddX86TargetArgs(const ArgList &Args,
1430 ArgStringList &CmdArgs) const {
1431 if (!Args.hasFlag(options::OPT_mred_zone,
1432 options::OPT_mno_red_zone,
1434 Args.hasArg(options::OPT_mkernel) ||
1435 Args.hasArg(options::OPT_fapple_kext))
1436 CmdArgs.push_back("-disable-red-zone");
1438 // Default to avoid implicit floating-point for kernel/kext code, but allow
1439 // that to be overridden with -mno-soft-float.
1440 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1441 Args.hasArg(options::OPT_fapple_kext));
1442 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1443 options::OPT_mno_soft_float,
1444 options::OPT_mimplicit_float,
1445 options::OPT_mno_implicit_float)) {
1446 const Option &O = A->getOption();
1447 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1448 O.matches(options::OPT_msoft_float));
1450 if (NoImplicitFloat)
1451 CmdArgs.push_back("-no-implicit-float");
1454 static inline bool HasPICArg(const ArgList &Args) {
1455 return Args.hasArg(options::OPT_fPIC)
1456 || Args.hasArg(options::OPT_fpic);
1459 static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1460 return Args.getLastArg(options::OPT_G,
1462 options::OPT_msmall_data_threshold_EQ);
1465 static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1467 if (HasPICArg(Args))
1469 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1470 value = A->getValue();
1476 void Clang::AddHexagonTargetArgs(const ArgList &Args,
1477 ArgStringList &CmdArgs) const {
1478 CmdArgs.push_back("-fno-signed-char");
1479 CmdArgs.push_back("-mqdsp6-compat");
1480 CmdArgs.push_back("-Wreturn-type");
1482 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1483 if (!SmallDataThreshold.empty()) {
1484 CmdArgs.push_back ("-mllvm");
1485 CmdArgs.push_back(Args.MakeArgString(
1486 "-hexagon-small-data-threshold=" + SmallDataThreshold));
1489 if (!Args.hasArg(options::OPT_fno_short_enums))
1490 CmdArgs.push_back("-fshort-enums");
1491 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1492 CmdArgs.push_back ("-mllvm");
1493 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1495 CmdArgs.push_back ("-mllvm");
1496 CmdArgs.push_back ("-machine-sink-split=0");
1499 static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1500 std::vector<const char *> &Features) {
1502 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
1503 getAArch64FPUFeatures(D, A, Args, Features);
1506 static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1507 const ArgList &Args, ArgStringList &CmdArgs) {
1508 std::vector<const char *> Features;
1509 switch (Triple.getArch()) {
1512 case llvm::Triple::mips:
1513 case llvm::Triple::mipsel:
1514 case llvm::Triple::mips64:
1515 case llvm::Triple::mips64el:
1516 getMIPSTargetFeatures(D, Args, Features);
1519 case llvm::Triple::arm:
1520 case llvm::Triple::thumb:
1521 getARMTargetFeatures(D, Triple, Args, Features);
1524 case llvm::Triple::ppc:
1525 case llvm::Triple::ppc64:
1526 case llvm::Triple::ppc64le:
1527 getPPCTargetFeatures(Args, Features);
1529 case llvm::Triple::sparc:
1530 getSparcTargetFeatures(Args, Features);
1532 case llvm::Triple::aarch64:
1533 getAArch64TargetFeatures(D, Args, Features);
1535 case llvm::Triple::x86:
1536 case llvm::Triple::x86_64:
1537 getX86TargetFeatures(Triple, Args, Features);
1541 // Find the last of each feature.
1542 llvm::StringMap<unsigned> LastOpt;
1543 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1544 const char *Name = Features[I];
1545 assert(Name[0] == '-' || Name[0] == '+');
1546 LastOpt[Name + 1] = I;
1549 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1550 // If this feature was overridden, ignore it.
1551 const char *Name = Features[I];
1552 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1553 assert(LastI != LastOpt.end());
1554 unsigned Last = LastI->second;
1558 CmdArgs.push_back("-target-feature");
1559 CmdArgs.push_back(Name);
1564 shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
1565 const llvm::Triple &Triple) {
1566 // We use the zero-cost exception tables for Objective-C if the non-fragile
1567 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1569 if (runtime.isNonFragile())
1572 if (!Triple.isOSDarwin())
1575 return (!Triple.isMacOSXVersionLT(10,5) &&
1576 (Triple.getArch() == llvm::Triple::x86_64 ||
1577 Triple.getArch() == llvm::Triple::arm));
1580 /// addExceptionArgs - Adds exception related arguments to the driver command
1581 /// arguments. There's a master flag, -fexceptions and also language specific
1582 /// flags to enable/disable C++ and Objective-C exceptions.
1583 /// This makes it possible to for example disable C++ exceptions but enable
1584 /// Objective-C exceptions.
1585 static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1586 const llvm::Triple &Triple,
1588 const ObjCRuntime &objcRuntime,
1589 ArgStringList &CmdArgs) {
1591 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1592 // arguments now to avoid warnings about unused arguments.
1593 Args.ClaimAllArgs(options::OPT_fexceptions);
1594 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1595 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1596 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1597 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1598 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
1602 // Exceptions are enabled by default.
1603 bool ExceptionsEnabled = true;
1605 // This keeps track of whether exceptions were explicitly turned on or off.
1606 bool DidHaveExplicitExceptionFlag = false;
1608 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1609 options::OPT_fno_exceptions)) {
1610 if (A->getOption().matches(options::OPT_fexceptions))
1611 ExceptionsEnabled = true;
1613 ExceptionsEnabled = false;
1615 DidHaveExplicitExceptionFlag = true;
1618 bool ShouldUseExceptionTables = false;
1620 // Exception tables and cleanups can be enabled with -fexceptions even if the
1621 // language itself doesn't support exceptions.
1622 if (ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1623 ShouldUseExceptionTables = true;
1625 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1626 // is not necessarily sensible, but follows GCC.
1627 if (types::isObjC(InputType) &&
1628 Args.hasFlag(options::OPT_fobjc_exceptions,
1629 options::OPT_fno_objc_exceptions,
1631 CmdArgs.push_back("-fobjc-exceptions");
1633 ShouldUseExceptionTables |=
1634 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
1637 if (types::isCXX(InputType)) {
1638 bool CXXExceptionsEnabled = ExceptionsEnabled;
1640 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1641 options::OPT_fno_cxx_exceptions,
1642 options::OPT_fexceptions,
1643 options::OPT_fno_exceptions)) {
1644 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1645 CXXExceptionsEnabled = true;
1646 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
1647 CXXExceptionsEnabled = false;
1650 if (CXXExceptionsEnabled) {
1651 CmdArgs.push_back("-fcxx-exceptions");
1653 ShouldUseExceptionTables = true;
1657 if (ShouldUseExceptionTables)
1658 CmdArgs.push_back("-fexceptions");
1661 static bool ShouldDisableAutolink(const ArgList &Args,
1662 const ToolChain &TC) {
1663 bool Default = true;
1664 if (TC.getTriple().isOSDarwin()) {
1665 // The native darwin assembler doesn't support the linker_option directives,
1666 // so we disable them if we think the .s file will be passed to it.
1667 Default = TC.useIntegratedAs();
1669 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1673 static bool ShouldDisableCFI(const ArgList &Args,
1674 const ToolChain &TC) {
1675 bool Default = true;
1676 if (TC.getTriple().isOSDarwin()) {
1677 // The native darwin assembler doesn't support cfi directives, so
1678 // we disable them if we think the .s file will be passed to it.
1679 Default = TC.useIntegratedAs();
1681 return !Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
1682 options::OPT_fno_dwarf2_cfi_asm,
1686 static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1687 const ToolChain &TC) {
1688 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1689 options::OPT_fno_dwarf_directory_asm,
1690 TC.useIntegratedAs());
1691 return !UseDwarfDirectory;
1694 /// \brief Check whether the given input tree contains any compilation actions.
1695 static bool ContainsCompileAction(const Action *A) {
1696 if (isa<CompileJobAction>(A))
1699 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1700 if (ContainsCompileAction(*it))
1706 /// \brief Check if -relax-all should be passed to the internal assembler.
1707 /// This is done by default when compiling non-assembler source with -O0.
1708 static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1709 bool RelaxDefault = true;
1711 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1712 RelaxDefault = A->getOption().matches(options::OPT_O0);
1715 RelaxDefault = false;
1716 for (ActionList::const_iterator it = C.getActions().begin(),
1717 ie = C.getActions().end(); it != ie; ++it) {
1718 if (ContainsCompileAction(*it)) {
1719 RelaxDefault = true;
1725 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1729 static void CollectArgsForIntegratedAssembler(Compilation &C,
1730 const ArgList &Args,
1731 ArgStringList &CmdArgs,
1733 if (UseRelaxAll(C, Args))
1734 CmdArgs.push_back("-mrelax-all");
1736 // When passing -I arguments to the assembler we sometimes need to
1737 // unconditionally take the next argument. For example, when parsing
1738 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
1739 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
1740 // arg after parsing the '-I' arg.
1741 bool TakeNextArg = false;
1743 // When using an integrated assembler, translate -Wa, and -Xassembler
1745 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1746 options::OPT_Xassembler),
1747 ie = Args.filtered_end(); it != ie; ++it) {
1751 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1752 StringRef Value = A->getValue(i);
1754 CmdArgs.push_back(Value.data());
1755 TakeNextArg = false;
1759 if (Value == "-force_cpusubtype_ALL") {
1760 // Do nothing, this is the default and we don't support anything else.
1761 } else if (Value == "-L") {
1762 CmdArgs.push_back("-msave-temp-labels");
1763 } else if (Value == "--fatal-warnings") {
1764 CmdArgs.push_back("-mllvm");
1765 CmdArgs.push_back("-fatal-assembler-warnings");
1766 } else if (Value == "--noexecstack") {
1767 CmdArgs.push_back("-mnoexecstack");
1768 } else if (Value.startswith("-I")) {
1769 CmdArgs.push_back(Value.data());
1770 // We need to consume the next argument if the current arg is a plain
1771 // -I. The next arg will be the include directory.
1775 D.Diag(diag::err_drv_unsupported_option_argument)
1776 << A->getOption().getName() << Value;
1782 static void addProfileRTLinux(
1783 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
1784 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
1785 Args.hasArg(options::OPT_fprofile_generate) ||
1786 Args.hasArg(options::OPT_fcreate_profile) ||
1787 Args.hasArg(options::OPT_coverage)))
1790 // The profile runtime is located in the Linux library directory and has name
1791 // "libclang_rt.profile-<ArchName>.a".
1792 SmallString<128> LibProfile(TC.getDriver().ResourceDir);
1793 llvm::sys::path::append(
1794 LibProfile, "lib", "linux",
1795 Twine("libclang_rt.profile-") + TC.getArchName() + ".a");
1797 CmdArgs.push_back(Args.MakeArgString(LibProfile));
1800 static void addSanitizerRTLinkFlagsLinux(
1801 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs,
1802 const StringRef Sanitizer, bool BeforeLibStdCXX,
1803 bool ExportSymbols = true) {
1804 // Sanitizer runtime is located in the Linux library directory and
1805 // has name "libclang_rt.<Sanitizer>-<ArchName>.a".
1806 SmallString<128> LibSanitizer(TC.getDriver().ResourceDir);
1807 llvm::sys::path::append(
1808 LibSanitizer, "lib", "linux",
1809 (Twine("libclang_rt.") + Sanitizer + "-" + TC.getArchName() + ".a"));
1811 // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
1812 // etc.) so that the linker picks custom versions of the global 'operator
1813 // new' and 'operator delete' symbols. We take the extreme (but simple)
1814 // strategy of inserting it at the front of the link command. It also
1815 // needs to be forced to end up in the executable, so wrap it in
1817 SmallVector<const char *, 3> LibSanitizerArgs;
1818 LibSanitizerArgs.push_back("-whole-archive");
1819 LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer));
1820 LibSanitizerArgs.push_back("-no-whole-archive");
1822 CmdArgs.insert(BeforeLibStdCXX ? CmdArgs.begin() : CmdArgs.end(),
1823 LibSanitizerArgs.begin(), LibSanitizerArgs.end());
1825 CmdArgs.push_back("-lpthread");
1826 CmdArgs.push_back("-lrt");
1827 CmdArgs.push_back("-ldl");
1828 CmdArgs.push_back("-lm");
1830 // If possible, use a dynamic symbols file to export the symbols from the
1831 // runtime library. If we can't do so, use -export-dynamic instead to export
1832 // all symbols from the binary.
1833 if (ExportSymbols) {
1834 if (llvm::sys::fs::exists(LibSanitizer + ".syms"))
1836 Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
1838 CmdArgs.push_back("-export-dynamic");
1842 /// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1843 /// This needs to be called before we add the C run-time (malloc, etc).
1844 static void addAsanRTLinux(const ToolChain &TC, const ArgList &Args,
1845 ArgStringList &CmdArgs) {
1846 if (TC.getTriple().getEnvironment() == llvm::Triple::Android) {
1847 SmallString<128> LibAsan(TC.getDriver().ResourceDir);
1848 llvm::sys::path::append(LibAsan, "lib", "linux",
1849 (Twine("libclang_rt.asan-") +
1850 TC.getArchName() + "-android.so"));
1851 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibAsan));
1853 if (!Args.hasArg(options::OPT_shared))
1854 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "asan", true);
1858 /// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
1859 /// This needs to be called before we add the C run-time (malloc, etc).
1860 static void addTsanRTLinux(const ToolChain &TC, const ArgList &Args,
1861 ArgStringList &CmdArgs) {
1862 if (!Args.hasArg(options::OPT_shared))
1863 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "tsan", true);
1866 /// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
1867 /// This needs to be called before we add the C run-time (malloc, etc).
1868 static void addMsanRTLinux(const ToolChain &TC, const ArgList &Args,
1869 ArgStringList &CmdArgs) {
1870 if (!Args.hasArg(options::OPT_shared))
1871 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "msan", true);
1874 /// If LeakSanitizer is enabled, add appropriate linker flags (Linux).
1875 /// This needs to be called before we add the C run-time (malloc, etc).
1876 static void addLsanRTLinux(const ToolChain &TC, const ArgList &Args,
1877 ArgStringList &CmdArgs) {
1878 if (!Args.hasArg(options::OPT_shared))
1879 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "lsan", true);
1882 /// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
1884 static void addUbsanRTLinux(const ToolChain &TC, const ArgList &Args,
1885 ArgStringList &CmdArgs, bool IsCXX,
1886 bool HasOtherSanitizerRt) {
1887 // Need a copy of sanitizer_common. This could come from another sanitizer
1888 // runtime; if we're not including one, include our own copy.
1889 if (!HasOtherSanitizerRt)
1890 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "san", true, false);
1892 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "ubsan", false);
1894 // Only include the bits of the runtime which need a C++ ABI library if
1895 // we're linking in C++ mode.
1897 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "ubsan_cxx", false);
1900 static void addDfsanRTLinux(const ToolChain &TC, const ArgList &Args,
1901 ArgStringList &CmdArgs) {
1902 if (!Args.hasArg(options::OPT_shared))
1903 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "dfsan", true);
1906 static bool shouldUseFramePointerForTarget(const ArgList &Args,
1907 const llvm::Triple &Triple) {
1908 switch (Triple.getArch()) {
1909 // Don't use a frame pointer on linux if optimizing for certain targets.
1910 case llvm::Triple::mips64:
1911 case llvm::Triple::mips64el:
1912 case llvm::Triple::mips:
1913 case llvm::Triple::mipsel:
1914 case llvm::Triple::systemz:
1915 case llvm::Triple::x86:
1916 case llvm::Triple::x86_64:
1917 if (Triple.isOSLinux())
1918 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1919 if (!A->getOption().matches(options::OPT_O0))
1922 case llvm::Triple::xcore:
1929 static bool shouldUseFramePointer(const ArgList &Args,
1930 const llvm::Triple &Triple) {
1931 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
1932 options::OPT_fomit_frame_pointer))
1933 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
1935 return shouldUseFramePointerForTarget(Args, Triple);
1938 static bool shouldUseLeafFramePointer(const ArgList &Args,
1939 const llvm::Triple &Triple) {
1940 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
1941 options::OPT_momit_leaf_frame_pointer))
1942 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
1944 return shouldUseFramePointerForTarget(Args, Triple);
1947 /// Add a CC1 option to specify the debug compilation directory.
1948 static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
1949 SmallString<128> cwd;
1950 if (!llvm::sys::fs::current_path(cwd)) {
1951 CmdArgs.push_back("-fdebug-compilation-dir");
1952 CmdArgs.push_back(Args.MakeArgString(cwd));
1956 static const char *SplitDebugName(const ArgList &Args,
1957 const InputInfoList &Inputs) {
1958 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
1959 if (FinalOutput && Args.hasArg(options::OPT_c)) {
1960 SmallString<128> T(FinalOutput->getValue());
1961 llvm::sys::path::replace_extension(T, "dwo");
1962 return Args.MakeArgString(T);
1964 // Use the compilation dir.
1965 SmallString<128> T(Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
1966 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
1967 llvm::sys::path::replace_extension(F, "dwo");
1969 return Args.MakeArgString(F);
1973 static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
1974 const Tool &T, const JobAction &JA,
1975 const ArgList &Args, const InputInfo &Output,
1976 const char *OutFile) {
1977 ArgStringList ExtractArgs;
1978 ExtractArgs.push_back("--extract-dwo");
1980 ArgStringList StripArgs;
1981 StripArgs.push_back("--strip-dwo");
1983 // Grabbing the output of the earlier compile step.
1984 StripArgs.push_back(Output.getFilename());
1985 ExtractArgs.push_back(Output.getFilename());
1986 ExtractArgs.push_back(OutFile);
1989 Args.MakeArgString(TC.GetProgramPath("objcopy"));
1991 // First extract the dwo sections.
1992 C.addCommand(new Command(JA, T, Exec, ExtractArgs));
1994 // Then remove them from the original .o file.
1995 C.addCommand(new Command(JA, T, Exec, StripArgs));
1998 static bool isOptimizationLevelFast(const ArgList &Args) {
1999 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2000 if (A->getOption().matches(options::OPT_Ofast))
2005 /// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
2006 static bool shouldEnableVectorizerAtOLevel(const ArgList &Args) {
2007 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2008 if (A->getOption().matches(options::OPT_O4) ||
2009 A->getOption().matches(options::OPT_Ofast))
2012 if (A->getOption().matches(options::OPT_O0))
2015 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2018 StringRef S(A->getValue());
2022 // Don't vectorize -Oz.
2026 unsigned OptLevel = 0;
2027 if (S.getAsInteger(10, OptLevel))
2030 return OptLevel > 1;
2036 void Clang::ConstructJob(Compilation &C, const JobAction &JA,
2037 const InputInfo &Output,
2038 const InputInfoList &Inputs,
2039 const ArgList &Args,
2040 const char *LinkingOutput) const {
2041 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2042 options::OPT_fapple_kext);
2043 const Driver &D = getToolChain().getDriver();
2044 ArgStringList CmdArgs;
2046 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2048 // Invoke ourselves in -cc1 mode.
2050 // FIXME: Implement custom jobs for internal actions.
2051 CmdArgs.push_back("-cc1");
2053 // Add the "effective" target triple.
2054 CmdArgs.push_back("-triple");
2055 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2056 CmdArgs.push_back(Args.MakeArgString(TripleStr));
2058 // Select the appropriate action.
2059 RewriteKind rewriteKind = RK_None;
2061 if (isa<AnalyzeJobAction>(JA)) {
2062 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2063 CmdArgs.push_back("-analyze");
2064 } else if (isa<MigrateJobAction>(JA)) {
2065 CmdArgs.push_back("-migrate");
2066 } else if (isa<PreprocessJobAction>(JA)) {
2067 if (Output.getType() == types::TY_Dependencies)
2068 CmdArgs.push_back("-Eonly");
2070 CmdArgs.push_back("-E");
2071 if (Args.hasArg(options::OPT_rewrite_objc) &&
2072 !Args.hasArg(options::OPT_g_Group))
2073 CmdArgs.push_back("-P");
2075 } else if (isa<AssembleJobAction>(JA)) {
2076 CmdArgs.push_back("-emit-obj");
2078 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
2080 // Also ignore explicit -force_cpusubtype_ALL option.
2081 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
2082 } else if (isa<PrecompileJobAction>(JA)) {
2083 // Use PCH if the user requested it.
2084 bool UsePCH = D.CCCUsePCH;
2086 if (JA.getType() == types::TY_Nothing)
2087 CmdArgs.push_back("-fsyntax-only");
2089 CmdArgs.push_back("-emit-pch");
2091 CmdArgs.push_back("-emit-pth");
2093 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
2095 if (JA.getType() == types::TY_Nothing) {
2096 CmdArgs.push_back("-fsyntax-only");
2097 } else if (JA.getType() == types::TY_LLVM_IR ||
2098 JA.getType() == types::TY_LTO_IR) {
2099 CmdArgs.push_back("-emit-llvm");
2100 } else if (JA.getType() == types::TY_LLVM_BC ||
2101 JA.getType() == types::TY_LTO_BC) {
2102 CmdArgs.push_back("-emit-llvm-bc");
2103 } else if (JA.getType() == types::TY_PP_Asm) {
2104 CmdArgs.push_back("-S");
2105 } else if (JA.getType() == types::TY_AST) {
2106 CmdArgs.push_back("-emit-pch");
2107 } else if (JA.getType() == types::TY_ModuleFile) {
2108 CmdArgs.push_back("-module-file-info");
2109 } else if (JA.getType() == types::TY_RewrittenObjC) {
2110 CmdArgs.push_back("-rewrite-objc");
2111 rewriteKind = RK_NonFragile;
2112 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2113 CmdArgs.push_back("-rewrite-objc");
2114 rewriteKind = RK_Fragile;
2116 assert(JA.getType() == types::TY_PP_Asm &&
2117 "Unexpected output type!");
2121 // The make clang go fast button.
2122 CmdArgs.push_back("-disable-free");
2124 // Disable the verification pass in -asserts builds.
2126 CmdArgs.push_back("-disable-llvm-verifier");
2129 // Set the main file name, so that debug info works even with
2131 CmdArgs.push_back("-main-file-name");
2132 CmdArgs.push_back(getBaseInputName(Args, Inputs));
2134 // Some flags which affect the language (via preprocessor
2136 if (Args.hasArg(options::OPT_static))
2137 CmdArgs.push_back("-static-define");
2139 if (isa<AnalyzeJobAction>(JA)) {
2140 // Enable region store model by default.
2141 CmdArgs.push_back("-analyzer-store=region");
2143 // Treat blocks as analysis entry points.
2144 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2146 CmdArgs.push_back("-analyzer-eagerly-assume");
2148 // Add default argument set.
2149 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
2150 CmdArgs.push_back("-analyzer-checker=core");
2152 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
2153 CmdArgs.push_back("-analyzer-checker=unix");
2155 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
2156 CmdArgs.push_back("-analyzer-checker=osx");
2158 CmdArgs.push_back("-analyzer-checker=deadcode");
2160 if (types::isCXX(Inputs[0].getType()))
2161 CmdArgs.push_back("-analyzer-checker=cplusplus");
2163 // Enable the following experimental checkers for testing.
2164 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn");
2165 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2166 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2167 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2168 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2169 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
2172 // Set the output format. The default is plist, for (lame) historical
2174 CmdArgs.push_back("-analyzer-output");
2175 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
2176 CmdArgs.push_back(A->getValue());
2178 CmdArgs.push_back("plist");
2180 // Disable the presentation of standard compiler warnings when
2181 // using --analyze. We only want to show static analyzer diagnostics
2182 // or frontend errors.
2183 CmdArgs.push_back("-w");
2185 // Add -Xanalyzer arguments when running as analyzer.
2186 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
2189 CheckCodeGenerationOptions(D, Args);
2191 bool PIE = getToolChain().isPIEDefault();
2192 bool PIC = PIE || getToolChain().isPICDefault();
2193 bool IsPICLevelTwo = PIC;
2195 // For the PIC and PIE flag options, this logic is different from the
2196 // legacy logic in very old versions of GCC, as that logic was just
2197 // a bug no one had ever fixed. This logic is both more rational and
2198 // consistent with GCC's new logic now that the bugs are fixed. The last
2199 // argument relating to either PIC or PIE wins, and no other argument is
2200 // used. If the last argument is any flavor of the '-fno-...' arguments,
2201 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2202 // at the same level.
2203 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2204 options::OPT_fpic, options::OPT_fno_pic,
2205 options::OPT_fPIE, options::OPT_fno_PIE,
2206 options::OPT_fpie, options::OPT_fno_pie);
2207 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2208 // is forced, then neither PIC nor PIE flags will have no effect.
2209 if (!getToolChain().isPICDefaultForced()) {
2211 Option O = LastPICArg->getOption();
2212 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2213 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2214 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2215 PIC = PIE || O.matches(options::OPT_fPIC) ||
2216 O.matches(options::OPT_fpic);
2217 IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2218 O.matches(options::OPT_fPIC);
2225 // Introduce a Darwin-specific hack. If the default is PIC but the flags
2226 // specified while enabling PIC enabled level 1 PIC, just force it back to
2227 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2228 // informal testing).
2229 if (PIC && getToolChain().getTriple().isOSDarwin())
2230 IsPICLevelTwo |= getToolChain().isPICDefault();
2232 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2233 // PIC or PIE options above, if these show up, PIC is disabled.
2234 llvm::Triple Triple(TripleStr);
2236 (!Triple.isiOS() || Triple.isOSVersionLT(6)))
2238 if (Args.hasArg(options::OPT_static))
2241 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2242 // This is a very special mode. It trumps the other modes, almost no one
2243 // uses it, and it isn't even valid on any OS but Darwin.
2244 if (!getToolChain().getTriple().isOSDarwin())
2245 D.Diag(diag::err_drv_unsupported_opt_for_target)
2246 << A->getSpelling() << getToolChain().getTriple().str();
2248 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2250 CmdArgs.push_back("-mrelocation-model");
2251 CmdArgs.push_back("dynamic-no-pic");
2253 // Only a forced PIC mode can cause the actual compile to have PIC defines
2254 // etc., no flags are sufficient. This behavior was selected to closely
2255 // match that of llvm-gcc and Apple GCC before that.
2256 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2257 CmdArgs.push_back("-pic-level");
2258 CmdArgs.push_back("2");
2261 // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2262 // handled in Clang's IRGen by the -pie-level flag.
2263 CmdArgs.push_back("-mrelocation-model");
2264 CmdArgs.push_back(PIC ? "pic" : "static");
2267 CmdArgs.push_back("-pic-level");
2268 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2270 CmdArgs.push_back("-pie-level");
2271 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2276 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2277 options::OPT_fno_merge_all_constants))
2278 CmdArgs.push_back("-fno-merge-all-constants");
2280 // LLVM Code Generator Options.
2282 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2283 CmdArgs.push_back("-mregparm");
2284 CmdArgs.push_back(A->getValue());
2287 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2288 options::OPT_freg_struct_return)) {
2289 if (getToolChain().getArch() != llvm::Triple::x86) {
2290 D.Diag(diag::err_drv_unsupported_opt_for_target)
2291 << A->getSpelling() << getToolChain().getTriple().str();
2292 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2293 CmdArgs.push_back("-fpcc-struct-return");
2295 assert(A->getOption().matches(options::OPT_freg_struct_return));
2296 CmdArgs.push_back("-freg-struct-return");
2300 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2301 CmdArgs.push_back("-mrtd");
2303 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
2304 CmdArgs.push_back("-mdisable-fp-elim");
2305 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2306 options::OPT_fno_zero_initialized_in_bss))
2307 CmdArgs.push_back("-mno-zero-initialized-in-bss");
2309 bool OFastEnabled = isOptimizationLevelFast(Args);
2310 // If -Ofast is the optimization level, then -fstrict-aliasing should be
2311 // enabled. This alias option is being used to simplify the hasFlag logic.
2312 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2313 options::OPT_fstrict_aliasing;
2314 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
2315 options::OPT_fno_strict_aliasing, true))
2316 CmdArgs.push_back("-relaxed-aliasing");
2317 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2318 options::OPT_fno_struct_path_tbaa))
2319 CmdArgs.push_back("-no-struct-path-tbaa");
2320 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2322 CmdArgs.push_back("-fstrict-enums");
2323 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2324 options::OPT_fno_optimize_sibling_calls))
2325 CmdArgs.push_back("-mdisable-tail-calls");
2327 // Handle segmented stacks.
2328 if (Args.hasArg(options::OPT_fsplit_stack))
2329 CmdArgs.push_back("-split-stacks");
2331 // If -Ofast is the optimization level, then -ffast-math should be enabled.
2332 // This alias option is being used to simplify the getLastArg logic.
2333 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2334 options::OPT_ffast_math;
2336 // Handle various floating point optimization flags, mapping them to the
2337 // appropriate LLVM code generation flags. The pattern for all of these is to
2338 // default off the codegen optimizations, and if any flag enables them and no
2339 // flag disables them after the flag enabling them, enable the codegen
2340 // optimization. This is complicated by several "umbrella" flags.
2341 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2342 options::OPT_fno_fast_math,
2343 options::OPT_ffinite_math_only,
2344 options::OPT_fno_finite_math_only,
2345 options::OPT_fhonor_infinities,
2346 options::OPT_fno_honor_infinities))
2347 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2348 A->getOption().getID() != options::OPT_fno_finite_math_only &&
2349 A->getOption().getID() != options::OPT_fhonor_infinities)
2350 CmdArgs.push_back("-menable-no-infs");
2351 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2352 options::OPT_fno_fast_math,
2353 options::OPT_ffinite_math_only,
2354 options::OPT_fno_finite_math_only,
2355 options::OPT_fhonor_nans,
2356 options::OPT_fno_honor_nans))
2357 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2358 A->getOption().getID() != options::OPT_fno_finite_math_only &&
2359 A->getOption().getID() != options::OPT_fhonor_nans)
2360 CmdArgs.push_back("-menable-no-nans");
2362 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2363 bool MathErrno = getToolChain().IsMathErrnoDefault();
2364 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2365 options::OPT_fno_fast_math,
2366 options::OPT_fmath_errno,
2367 options::OPT_fno_math_errno)) {
2368 // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2369 // However, turning *off* -ffast_math merely restores the toolchain default
2370 // (which may be false).
2371 if (A->getOption().getID() == options::OPT_fno_math_errno ||
2372 A->getOption().getID() == options::OPT_ffast_math ||
2373 A->getOption().getID() == options::OPT_Ofast)
2375 else if (A->getOption().getID() == options::OPT_fmath_errno)
2379 CmdArgs.push_back("-fmath-errno");
2381 // There are several flags which require disabling very specific
2382 // optimizations. Any of these being disabled forces us to turn off the
2383 // entire set of LLVM optimizations, so collect them through all the flag
2385 bool AssociativeMath = false;
2386 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2387 options::OPT_fno_fast_math,
2388 options::OPT_funsafe_math_optimizations,
2389 options::OPT_fno_unsafe_math_optimizations,
2390 options::OPT_fassociative_math,
2391 options::OPT_fno_associative_math))
2392 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2393 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2394 A->getOption().getID() != options::OPT_fno_associative_math)
2395 AssociativeMath = true;
2396 bool ReciprocalMath = false;
2397 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2398 options::OPT_fno_fast_math,
2399 options::OPT_funsafe_math_optimizations,
2400 options::OPT_fno_unsafe_math_optimizations,
2401 options::OPT_freciprocal_math,
2402 options::OPT_fno_reciprocal_math))
2403 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2404 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2405 A->getOption().getID() != options::OPT_fno_reciprocal_math)
2406 ReciprocalMath = true;
2407 bool SignedZeros = true;
2408 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2409 options::OPT_fno_fast_math,
2410 options::OPT_funsafe_math_optimizations,
2411 options::OPT_fno_unsafe_math_optimizations,
2412 options::OPT_fsigned_zeros,
2413 options::OPT_fno_signed_zeros))
2414 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2415 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2416 A->getOption().getID() != options::OPT_fsigned_zeros)
2417 SignedZeros = false;
2418 bool TrappingMath = true;
2419 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2420 options::OPT_fno_fast_math,
2421 options::OPT_funsafe_math_optimizations,
2422 options::OPT_fno_unsafe_math_optimizations,
2423 options::OPT_ftrapping_math,
2424 options::OPT_fno_trapping_math))
2425 if (A->getOption().getID() != options::OPT_fno_fast_math &&
2426 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2427 A->getOption().getID() != options::OPT_ftrapping_math)
2428 TrappingMath = false;
2429 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2431 CmdArgs.push_back("-menable-unsafe-fp-math");
2434 // Validate and pass through -fp-contract option.
2435 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2436 options::OPT_fno_fast_math,
2437 options::OPT_ffp_contract)) {
2438 if (A->getOption().getID() == options::OPT_ffp_contract) {
2439 StringRef Val = A->getValue();
2440 if (Val == "fast" || Val == "on" || Val == "off") {
2441 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2443 D.Diag(diag::err_drv_unsupported_option_argument)
2444 << A->getOption().getName() << Val;
2446 } else if (A->getOption().matches(options::OPT_ffast_math) ||
2447 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
2448 // If fast-math is set then set the fp-contract mode to fast.
2449 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2453 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2454 // and if we find them, tell the frontend to provide the appropriate
2455 // preprocessor macros. This is distinct from enabling any optimizations as
2456 // these options induce language changes which must survive serialization
2457 // and deserialization, etc.
2458 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2459 options::OPT_fno_fast_math))
2460 if (!A->getOption().matches(options::OPT_fno_fast_math))
2461 CmdArgs.push_back("-ffast-math");
2462 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only, options::OPT_fno_fast_math))
2463 if (A->getOption().matches(options::OPT_ffinite_math_only))
2464 CmdArgs.push_back("-ffinite-math-only");
2466 // Decide whether to use verbose asm. Verbose assembly is the default on
2467 // toolchains which have the integrated assembler on by default.
2468 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
2469 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
2470 IsVerboseAsmDefault) ||
2471 Args.hasArg(options::OPT_dA))
2472 CmdArgs.push_back("-masm-verbose");
2474 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2475 CmdArgs.push_back("-mdebug-pass");
2476 CmdArgs.push_back("Structure");
2478 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2479 CmdArgs.push_back("-mdebug-pass");
2480 CmdArgs.push_back("Arguments");
2483 // Enable -mconstructor-aliases except on darwin, where we have to
2484 // work around a linker bug; see <rdar://problem/7651567>.
2485 if (!getToolChain().getTriple().isOSDarwin())
2486 CmdArgs.push_back("-mconstructor-aliases");
2488 // Darwin's kernel doesn't support guard variables; just die if we
2490 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
2491 CmdArgs.push_back("-fforbid-guard-variables");
2493 if (Args.hasArg(options::OPT_mms_bitfields)) {
2494 CmdArgs.push_back("-mms-bitfields");
2497 // This is a coarse approximation of what llvm-gcc actually does, both
2498 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2499 // complicated ways.
2500 bool AsynchronousUnwindTables =
2501 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2502 options::OPT_fno_asynchronous_unwind_tables,
2503 getToolChain().IsUnwindTablesDefault() &&
2505 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2506 AsynchronousUnwindTables))
2507 CmdArgs.push_back("-munwind-tables");
2509 getToolChain().addClangTargetOptions(Args, CmdArgs);
2511 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2512 CmdArgs.push_back("-mlimit-float-precision");
2513 CmdArgs.push_back(A->getValue());
2516 // FIXME: Handle -mtune=.
2517 (void) Args.hasArg(options::OPT_mtune_EQ);
2519 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
2520 CmdArgs.push_back("-mcode-model");
2521 CmdArgs.push_back(A->getValue());
2524 // Add the target cpu
2525 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2526 llvm::Triple ETriple(ETripleStr);
2527 std::string CPU = getCPUName(Args, ETriple);
2529 CmdArgs.push_back("-target-cpu");
2530 CmdArgs.push_back(Args.MakeArgString(CPU));
2533 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2534 CmdArgs.push_back("-mfpmath");
2535 CmdArgs.push_back(A->getValue());
2538 // Add the target features
2539 getTargetFeatures(D, ETriple, Args, CmdArgs);
2541 // Add target specific flags.
2542 switch(getToolChain().getArch()) {
2546 case llvm::Triple::arm:
2547 case llvm::Triple::thumb:
2548 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
2551 case llvm::Triple::mips:
2552 case llvm::Triple::mipsel:
2553 case llvm::Triple::mips64:
2554 case llvm::Triple::mips64el:
2555 AddMIPSTargetArgs(Args, CmdArgs);
2558 case llvm::Triple::sparc:
2559 AddSparcTargetArgs(Args, CmdArgs);
2562 case llvm::Triple::x86:
2563 case llvm::Triple::x86_64:
2564 AddX86TargetArgs(Args, CmdArgs);
2567 case llvm::Triple::hexagon:
2568 AddHexagonTargetArgs(Args, CmdArgs);
2572 // Add clang-cl arguments.
2573 if (getToolChain().getDriver().IsCLMode())
2574 AddClangCLArgs(Args, CmdArgs);
2576 // Pass the linker version in use.
2577 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2578 CmdArgs.push_back("-target-linker-version");
2579 CmdArgs.push_back(A->getValue());
2582 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
2583 CmdArgs.push_back("-momit-leaf-frame-pointer");
2585 // Explicitly error on some things we know we don't support and can't just
2587 types::ID InputType = Inputs[0].getType();
2588 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2590 if (types::isCXX(InputType) &&
2591 getToolChain().getTriple().isOSDarwin() &&
2592 getToolChain().getArch() == llvm::Triple::x86) {
2593 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2594 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
2595 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
2596 << Unsupported->getOption().getName();
2600 Args.AddAllArgs(CmdArgs, options::OPT_v);
2601 Args.AddLastArg(CmdArgs, options::OPT_H);
2602 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
2603 CmdArgs.push_back("-header-include-file");
2604 CmdArgs.push_back(D.CCPrintHeadersFilename ?
2605 D.CCPrintHeadersFilename : "-");
2607 Args.AddLastArg(CmdArgs, options::OPT_P);
2608 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
2610 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
2611 CmdArgs.push_back("-diagnostic-log-file");
2612 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2613 D.CCLogDiagnosticsFilename : "-");
2616 // Use the last option from "-g" group. "-gline-tables-only"
2617 // is preserved, all other debug options are substituted with "-g".
2618 Args.ClaimAllArgs(options::OPT_g_Group);
2619 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
2620 if (A->getOption().matches(options::OPT_gline_tables_only))
2621 CmdArgs.push_back("-gline-tables-only");
2622 else if (A->getOption().matches(options::OPT_gdwarf_2))
2623 CmdArgs.push_back("-gdwarf-2");
2624 else if (A->getOption().matches(options::OPT_gdwarf_3))
2625 CmdArgs.push_back("-gdwarf-3");
2626 else if (A->getOption().matches(options::OPT_gdwarf_4))
2627 CmdArgs.push_back("-gdwarf-4");
2628 else if (!A->getOption().matches(options::OPT_g0) &&
2629 !A->getOption().matches(options::OPT_ggdb0)) {
2630 // Default is dwarf-2 for darwin.
2631 if (getToolChain().getTriple().isOSDarwin())
2632 CmdArgs.push_back("-gdwarf-2");
2634 CmdArgs.push_back("-g");
2638 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2639 Args.ClaimAllArgs(options::OPT_g_flags_Group);
2640 if (Args.hasArg(options::OPT_gcolumn_info))
2641 CmdArgs.push_back("-dwarf-column-info");
2643 // FIXME: Move backend command line options to the module.
2644 // -gsplit-dwarf should turn on -g and enable the backend dwarf
2645 // splitting and extraction.
2646 // FIXME: Currently only works on Linux.
2647 if (getToolChain().getTriple().isOSLinux() &&
2648 Args.hasArg(options::OPT_gsplit_dwarf)) {
2649 CmdArgs.push_back("-g");
2650 CmdArgs.push_back("-backend-option");
2651 CmdArgs.push_back("-split-dwarf=Enable");
2654 // -ggnu-pubnames turns on gnu style pubnames in the backend.
2655 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
2656 CmdArgs.push_back("-backend-option");
2657 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
2660 Args.AddAllArgs(CmdArgs, options::OPT_fdebug_types_section);
2662 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
2663 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
2665 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2667 if (Args.hasArg(options::OPT_ftest_coverage) ||
2668 Args.hasArg(options::OPT_coverage))
2669 CmdArgs.push_back("-femit-coverage-notes");
2670 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2671 Args.hasArg(options::OPT_coverage))
2672 CmdArgs.push_back("-femit-coverage-data");
2674 if (C.getArgs().hasArg(options::OPT_c) ||
2675 C.getArgs().hasArg(options::OPT_S)) {
2676 if (Output.isFilename()) {
2677 CmdArgs.push_back("-coverage-file");
2678 SmallString<128> CoverageFilename(Output.getFilename());
2679 if (llvm::sys::path::is_relative(CoverageFilename.str())) {
2680 SmallString<128> Pwd;
2681 if (!llvm::sys::fs::current_path(Pwd)) {
2682 llvm::sys::path::append(Pwd, CoverageFilename.str());
2683 CoverageFilename.swap(Pwd);
2686 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
2690 // Pass options for controlling the default header search paths.
2691 if (Args.hasArg(options::OPT_nostdinc)) {
2692 CmdArgs.push_back("-nostdsysteminc");
2693 CmdArgs.push_back("-nobuiltininc");
2695 if (Args.hasArg(options::OPT_nostdlibinc))
2696 CmdArgs.push_back("-nostdsysteminc");
2697 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2698 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2701 // Pass the path to compiler resource files.
2702 CmdArgs.push_back("-resource-dir");
2703 CmdArgs.push_back(D.ResourceDir.c_str());
2705 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2707 bool ARCMTEnabled = false;
2708 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
2709 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
2710 options::OPT_ccc_arcmt_modify,
2711 options::OPT_ccc_arcmt_migrate)) {
2712 ARCMTEnabled = true;
2713 switch (A->getOption().getID()) {
2715 llvm_unreachable("missed a case");
2716 case options::OPT_ccc_arcmt_check:
2717 CmdArgs.push_back("-arcmt-check");
2719 case options::OPT_ccc_arcmt_modify:
2720 CmdArgs.push_back("-arcmt-modify");
2722 case options::OPT_ccc_arcmt_migrate:
2723 CmdArgs.push_back("-arcmt-migrate");
2724 CmdArgs.push_back("-mt-migrate-directory");
2725 CmdArgs.push_back(A->getValue());
2727 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2728 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
2733 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
2734 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
2735 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
2738 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2740 D.Diag(diag::err_drv_argument_not_allowed_with)
2741 << A->getAsString(Args) << "-ccc-arcmt-migrate";
2743 CmdArgs.push_back("-mt-migrate-directory");
2744 CmdArgs.push_back(A->getValue());
2746 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
2747 options::OPT_objcmt_migrate_subscripting,
2748 options::OPT_objcmt_migrate_property)) {
2749 // None specified, means enable them all.
2750 CmdArgs.push_back("-objcmt-migrate-literals");
2751 CmdArgs.push_back("-objcmt-migrate-subscripting");
2752 CmdArgs.push_back("-objcmt-migrate-property");
2754 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2755 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2756 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2759 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2760 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2761 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2762 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
2763 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
2764 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
2765 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
2766 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
2767 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
2768 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
2769 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
2770 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
2771 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
2772 Args.AddLastArg(CmdArgs, options::OPT_objcmt_white_list_dir_path);
2775 // Add preprocessing options like -I, -D, etc. if we are using the
2778 // FIXME: Support -fpreprocessed
2779 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
2780 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
2782 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
2783 // that "The compiler can only warn and ignore the option if not recognized".
2784 // When building with ccache, it will pass -D options to clang even on
2785 // preprocessed inputs and configure concludes that -fPIC is not supported.
2786 Args.ClaimAllArgs(options::OPT_D);
2788 // Manually translate -O4 to -O3; let clang reject others.
2789 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2790 if (A->getOption().matches(options::OPT_O4)) {
2791 CmdArgs.push_back("-O3");
2792 D.Diag(diag::warn_O4_is_O3);
2794 A->render(Args, CmdArgs);
2798 // Don't warn about unused -flto. This can happen when we're preprocessing or
2800 Args.ClaimAllArgs(options::OPT_flto);
2802 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
2803 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
2804 CmdArgs.push_back("-pedantic");
2805 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
2806 Args.AddLastArg(CmdArgs, options::OPT_w);
2808 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
2809 // (-ansi is equivalent to -std=c89 or -std=c++98).
2811 // If a std is supplied, only add -trigraphs if it follows the
2813 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2814 if (Std->getOption().matches(options::OPT_ansi))
2815 if (types::isCXX(InputType))
2816 CmdArgs.push_back("-std=c++98");
2818 CmdArgs.push_back("-std=c89");
2820 Std->render(Args, CmdArgs);
2822 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
2823 options::OPT_trigraphs))
2825 A->render(Args, CmdArgs);
2827 // Honor -std-default.
2829 // FIXME: Clang doesn't correctly handle -std= when the input language
2830 // doesn't match. For the time being just ignore this for C++ inputs;
2831 // eventually we want to do all the standard defaulting here instead of
2832 // splitting it between the driver and clang -cc1.
2833 if (!types::isCXX(InputType))
2834 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2835 "-std=", /*Joined=*/true);
2836 else if (getToolChain().getTriple().getOS() == llvm::Triple::Win32)
2837 CmdArgs.push_back("-std=c++11");
2839 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
2842 // GCC's behavior for -Wwrite-strings is a bit strange:
2843 // * In C, this "warning flag" changes the types of string literals from
2844 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
2845 // for the discarded qualifier.
2846 // * In C++, this is just a normal warning flag.
2848 // Implementing this warning correctly in C is hard, so we follow GCC's
2849 // behavior for now. FIXME: Directly diagnose uses of a string literal as
2850 // a non-const char* in C, rather than using this crude hack.
2851 if (!types::isCXX(InputType)) {
2852 DiagnosticsEngine::Level DiagLevel = D.getDiags().getDiagnosticLevel(
2853 diag::warn_deprecated_string_literal_conversion_c, SourceLocation());
2854 if (DiagLevel > DiagnosticsEngine::Ignored)
2855 CmdArgs.push_back("-fconst-strings");
2858 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
2859 // during C++ compilation, which it is by default. GCC keeps this define even
2860 // in the presence of '-w', match this behavior bug-for-bug.
2861 if (types::isCXX(InputType) &&
2862 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
2864 CmdArgs.push_back("-fdeprecated-macro");
2867 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
2868 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
2869 if (Asm->getOption().matches(options::OPT_fasm))
2870 CmdArgs.push_back("-fgnu-keywords");
2872 CmdArgs.push_back("-fno-gnu-keywords");
2875 if (ShouldDisableCFI(Args, getToolChain()))
2876 CmdArgs.push_back("-fno-dwarf2-cfi-asm");
2878 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
2879 CmdArgs.push_back("-fno-dwarf-directory-asm");
2881 if (ShouldDisableAutolink(Args, getToolChain()))
2882 CmdArgs.push_back("-fno-autolink");
2884 // Add in -fdebug-compilation-dir if necessary.
2885 addDebugCompDirArg(Args, CmdArgs);
2887 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
2888 options::OPT_ftemplate_depth_EQ)) {
2889 CmdArgs.push_back("-ftemplate-depth");
2890 CmdArgs.push_back(A->getValue());
2893 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
2894 CmdArgs.push_back("-foperator-arrow-depth");
2895 CmdArgs.push_back(A->getValue());
2898 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
2899 CmdArgs.push_back("-fconstexpr-depth");
2900 CmdArgs.push_back(A->getValue());
2903 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
2904 CmdArgs.push_back("-fconstexpr-steps");
2905 CmdArgs.push_back(A->getValue());
2908 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
2909 CmdArgs.push_back("-fbracket-depth");
2910 CmdArgs.push_back(A->getValue());
2913 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
2914 options::OPT_Wlarge_by_value_copy_def)) {
2915 if (A->getNumValues()) {
2916 StringRef bytes = A->getValue();
2917 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
2919 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
2923 if (Args.hasArg(options::OPT_relocatable_pch))
2924 CmdArgs.push_back("-relocatable-pch");
2926 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
2927 CmdArgs.push_back("-fconstant-string-class");
2928 CmdArgs.push_back(A->getValue());
2931 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
2932 CmdArgs.push_back("-ftabstop");
2933 CmdArgs.push_back(A->getValue());
2936 CmdArgs.push_back("-ferror-limit");
2937 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
2938 CmdArgs.push_back(A->getValue());
2940 CmdArgs.push_back("19");
2942 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
2943 CmdArgs.push_back("-fmacro-backtrace-limit");
2944 CmdArgs.push_back(A->getValue());
2947 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
2948 CmdArgs.push_back("-ftemplate-backtrace-limit");
2949 CmdArgs.push_back(A->getValue());
2952 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
2953 CmdArgs.push_back("-fconstexpr-backtrace-limit");
2954 CmdArgs.push_back(A->getValue());
2957 // Pass -fmessage-length=.
2958 CmdArgs.push_back("-fmessage-length");
2959 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
2960 CmdArgs.push_back(A->getValue());
2962 // If -fmessage-length=N was not specified, determine whether this is a
2963 // terminal and, if so, implicitly define -fmessage-length appropriately.
2964 unsigned N = llvm::sys::Process::StandardErrColumns();
2965 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
2968 // -fvisibility= and -fvisibility-ms-compat are of a piece.
2969 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
2970 options::OPT_fvisibility_ms_compat)) {
2971 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
2972 CmdArgs.push_back("-fvisibility");
2973 CmdArgs.push_back(A->getValue());
2975 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
2976 CmdArgs.push_back("-fvisibility");
2977 CmdArgs.push_back("hidden");
2978 CmdArgs.push_back("-ftype-visibility");
2979 CmdArgs.push_back("default");
2983 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
2985 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
2987 // -fhosted is default.
2988 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
2990 CmdArgs.push_back("-ffreestanding");
2992 // Forward -f (flag) options which we can pass directly.
2993 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
2994 Args.AddLastArg(CmdArgs, options::OPT_fformat_extensions);
2995 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
2996 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
2997 Args.AddLastArg(CmdArgs, options::OPT_fno_limit_debug_info);
2998 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
2999 // AltiVec language extensions aren't relevant for assembling.
3000 if (!isa<PreprocessJobAction>(JA) ||
3001 Output.getType() != types::TY_PP_Asm)
3002 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
3003 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3004 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
3006 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3007 Sanitize.addArgs(Args, CmdArgs);
3009 if (!Args.hasFlag(options::OPT_fsanitize_recover,
3010 options::OPT_fno_sanitize_recover,
3012 CmdArgs.push_back("-fno-sanitize-recover");
3014 if (Args.hasArg(options::OPT_fcatch_undefined_behavior) ||
3015 Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
3016 options::OPT_fno_sanitize_undefined_trap_on_error, false))
3017 CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3019 // Report an error for -faltivec on anything other than PowerPC.
3020 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
3021 if (!(getToolChain().getArch() == llvm::Triple::ppc ||
3022 getToolChain().getArch() == llvm::Triple::ppc64 ||
3023 getToolChain().getArch() == llvm::Triple::ppc64le))
3024 D.Diag(diag::err_drv_argument_only_allowed_with)
3025 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
3027 if (getToolChain().SupportsProfiling())
3028 Args.AddLastArg(CmdArgs, options::OPT_pg);
3030 // -flax-vector-conversions is default.
3031 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3032 options::OPT_fno_lax_vector_conversions))
3033 CmdArgs.push_back("-fno-lax-vector-conversions");
3035 if (Args.getLastArg(options::OPT_fapple_kext))
3036 CmdArgs.push_back("-fapple-kext");
3038 if (Args.hasFlag(options::OPT_frewrite_includes,
3039 options::OPT_fno_rewrite_includes, false))
3040 CmdArgs.push_back("-frewrite-includes");
3042 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
3043 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
3044 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
3045 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3046 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
3048 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3049 CmdArgs.push_back("-ftrapv-handler");
3050 CmdArgs.push_back(A->getValue());
3053 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
3055 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3056 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3057 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3058 options::OPT_fno_wrapv)) {
3059 if (A->getOption().matches(options::OPT_fwrapv))
3060 CmdArgs.push_back("-fwrapv");
3061 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3062 options::OPT_fno_strict_overflow)) {
3063 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3064 CmdArgs.push_back("-fwrapv");
3067 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3068 options::OPT_fno_reroll_loops))
3069 if (A->getOption().matches(options::OPT_freroll_loops))
3070 CmdArgs.push_back("-freroll-loops");
3072 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
3073 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3074 options::OPT_fno_unroll_loops);
3076 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3079 // -stack-protector=0 is default.
3080 unsigned StackProtectorLevel = 0;
3081 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3082 options::OPT_fstack_protector_all,
3083 options::OPT_fstack_protector)) {
3084 if (A->getOption().matches(options::OPT_fstack_protector))
3085 StackProtectorLevel = 1;
3086 else if (A->getOption().matches(options::OPT_fstack_protector_all))
3087 StackProtectorLevel = 2;
3089 StackProtectorLevel =
3090 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3092 if (StackProtectorLevel) {
3093 CmdArgs.push_back("-stack-protector");
3094 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3097 // --param ssp-buffer-size=
3098 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3099 ie = Args.filtered_end(); it != ie; ++it) {
3100 StringRef Str((*it)->getValue());
3101 if (Str.startswith("ssp-buffer-size=")) {
3102 if (StackProtectorLevel) {
3103 CmdArgs.push_back("-stack-protector-buffer-size");
3104 // FIXME: Verify the argument is a valid integer.
3105 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3111 // Translate -mstackrealign
3112 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3114 CmdArgs.push_back("-backend-option");
3115 CmdArgs.push_back("-force-align-stack");
3117 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3119 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3122 if (Args.hasArg(options::OPT_mstack_alignment)) {
3123 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3124 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
3126 // -mkernel implies -mstrict-align; don't add the redundant option.
3127 if (!KernelOrKext) {
3128 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3129 options::OPT_munaligned_access)) {
3130 if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
3131 CmdArgs.push_back("-backend-option");
3132 CmdArgs.push_back("-arm-strict-align");
3134 CmdArgs.push_back("-backend-option");
3135 CmdArgs.push_back("-arm-no-strict-align");
3140 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3141 options::OPT_mno_restrict_it)) {
3142 if (A->getOption().matches(options::OPT_mrestrict_it)) {
3143 CmdArgs.push_back("-backend-option");
3144 CmdArgs.push_back("-arm-restrict-it");
3146 CmdArgs.push_back("-backend-option");
3147 CmdArgs.push_back("-arm-no-restrict-it");
3151 // Forward -f options with positive and negative forms; we translate
3153 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3154 StringRef fname = A->getValue();
3155 if (!llvm::sys::fs::exists(fname))
3156 D.Diag(diag::err_drv_no_such_file) << fname;
3158 A->render(Args, CmdArgs);
3161 if (Args.hasArg(options::OPT_mkernel)) {
3162 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
3163 CmdArgs.push_back("-fapple-kext");
3164 if (!Args.hasArg(options::OPT_fbuiltin))
3165 CmdArgs.push_back("-fno-builtin");
3166 Args.ClaimAllArgs(options::OPT_fno_builtin);
3168 // -fbuiltin is default.
3169 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
3170 CmdArgs.push_back("-fno-builtin");
3172 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3173 options::OPT_fno_assume_sane_operator_new))
3174 CmdArgs.push_back("-fno-assume-sane-operator-new");
3176 // -fblocks=0 is default.
3177 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
3178 getToolChain().IsBlocksDefault()) ||
3179 (Args.hasArg(options::OPT_fgnu_runtime) &&
3180 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3181 !Args.hasArg(options::OPT_fno_blocks))) {
3182 CmdArgs.push_back("-fblocks");
3184 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3185 !getToolChain().hasBlocksRuntime())
3186 CmdArgs.push_back("-fblocks-runtime-optional");
3189 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3190 // users must also pass -fcxx-modules. The latter flag will disappear once the
3191 // modules implementation is solid for C++/Objective-C++ programs as well.
3192 bool HaveModules = false;
3193 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3194 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3195 options::OPT_fno_cxx_modules,
3197 if (AllowedInCXX || !types::isCXX(InputType)) {
3198 CmdArgs.push_back("-fmodules");
3203 // -fmodule-maps enables module map processing (off by default) for header
3204 // checking. It is implied by -fmodules.
3205 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3207 CmdArgs.push_back("-fmodule-maps");
3210 // -fmodules-decluse checks that modules used are declared so (off by
3212 if (Args.hasFlag(options::OPT_fmodules_decluse,
3213 options::OPT_fno_modules_decluse,
3215 CmdArgs.push_back("-fmodules-decluse");
3218 // -fmodule-name specifies the module that is currently being built (or
3219 // used for header checking by -fmodule-maps).
3220 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name)) {
3222 A->render(Args, CmdArgs);
3225 // -fmodule-map-file can be used to specify a file containing module
3227 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file)) {
3229 A->render(Args, CmdArgs);
3232 // If a module path was provided, pass it along. Otherwise, use a temporary
3234 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) {
3237 A->render(Args, CmdArgs);
3239 } else if (HaveModules) {
3240 SmallString<128> DefaultModuleCache;
3241 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3242 DefaultModuleCache);
3243 llvm::sys::path::append(DefaultModuleCache, "org.llvm.clang");
3244 llvm::sys::path::append(DefaultModuleCache, "ModuleCache");
3245 const char Arg[] = "-fmodules-cache-path=";
3246 DefaultModuleCache.insert(DefaultModuleCache.begin(),
3247 Arg, Arg + strlen(Arg));
3248 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
3251 // Pass through all -fmodules-ignore-macro arguments.
3252 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
3253 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3254 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
3256 // -faccess-control is default.
3257 if (Args.hasFlag(options::OPT_fno_access_control,
3258 options::OPT_faccess_control,
3260 CmdArgs.push_back("-fno-access-control");
3262 // -felide-constructors is the default.
3263 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3264 options::OPT_felide_constructors,
3266 CmdArgs.push_back("-fno-elide-constructors");
3268 // -frtti is default.
3269 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
3271 CmdArgs.push_back("-fno-rtti");
3273 // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
3274 if (Sanitize.sanitizesVptr()) {
3275 std::string NoRttiArg =
3276 Args.getLastArg(options::OPT_mkernel,
3277 options::OPT_fapple_kext,
3278 options::OPT_fno_rtti)->getAsString(Args);
3279 D.Diag(diag::err_drv_argument_not_allowed_with)
3280 << "-fsanitize=vptr" << NoRttiArg;
3284 // -fshort-enums=0 is default for all architectures except Hexagon.
3285 if (Args.hasFlag(options::OPT_fshort_enums,
3286 options::OPT_fno_short_enums,
3287 getToolChain().getArch() ==
3288 llvm::Triple::hexagon))
3289 CmdArgs.push_back("-fshort-enums");
3291 // -fsigned-char is default.
3292 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
3293 isSignedCharDefault(getToolChain().getTriple())))
3294 CmdArgs.push_back("-fno-signed-char");
3296 // -fthreadsafe-static is default.
3297 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
3298 options::OPT_fno_threadsafe_statics))
3299 CmdArgs.push_back("-fno-threadsafe-statics");
3301 // -fuse-cxa-atexit is default.
3303 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
3304 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
3305 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
3306 getToolChain().getArch() != llvm::Triple::hexagon &&
3307 getToolChain().getArch() != llvm::Triple::xcore) ||
3309 CmdArgs.push_back("-fno-use-cxa-atexit");
3311 // -fms-extensions=0 is default.
3312 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3313 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
3314 CmdArgs.push_back("-fms-extensions");
3316 // -fms-compatibility=0 is default.
3317 if (Args.hasFlag(options::OPT_fms_compatibility,
3318 options::OPT_fno_ms_compatibility,
3319 (getToolChain().getTriple().getOS() == llvm::Triple::Win32 &&
3320 Args.hasFlag(options::OPT_fms_extensions,
3321 options::OPT_fno_ms_extensions,
3323 CmdArgs.push_back("-fms-compatibility");
3325 // -fmsc-version=1700 is default.
3326 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3327 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
3328 Args.hasArg(options::OPT_fmsc_version)) {
3329 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
3330 if (msc_ver.empty())
3331 CmdArgs.push_back("-fmsc-version=1700");
3333 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
3337 // -fno-borland-extensions is default.
3338 if (Args.hasFlag(options::OPT_fborland_extensions,
3339 options::OPT_fno_borland_extensions, false))
3340 CmdArgs.push_back("-fborland-extensions");
3342 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3344 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
3345 options::OPT_fno_delayed_template_parsing,
3346 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
3347 CmdArgs.push_back("-fdelayed-template-parsing");
3349 // -fgnu-keywords default varies depending on language; only pass if
3351 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
3352 options::OPT_fno_gnu_keywords))
3353 A->render(Args, CmdArgs);
3355 if (Args.hasFlag(options::OPT_fgnu89_inline,
3356 options::OPT_fno_gnu89_inline,
3358 CmdArgs.push_back("-fgnu89-inline");
3360 if (Args.hasArg(options::OPT_fno_inline))
3361 CmdArgs.push_back("-fno-inline");
3363 if (Args.hasArg(options::OPT_fno_inline_functions))
3364 CmdArgs.push_back("-fno-inline-functions");
3366 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
3368 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
3369 // legacy is the default. Next runtime is always legacy dispatch and
3370 // -fno-objc-legacy-dispatch gets ignored silently.
3371 if (objcRuntime.isNonFragile() && !objcRuntime.isNeXTFamily()) {
3372 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3373 options::OPT_fno_objc_legacy_dispatch,
3374 objcRuntime.isLegacyDispatchDefaultForArch(
3375 getToolChain().getArch()))) {
3376 if (getToolChain().UseObjCMixedDispatch())
3377 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3379 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3383 // When ObjectiveC legacy runtime is in effect on MacOSX,
3384 // turn on the option to do Array/Dictionary subscripting
3386 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
3387 getToolChain().getTriple().isMacOSX() &&
3388 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3389 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
3390 objcRuntime.isNeXTFamily())
3391 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3393 // -fencode-extended-block-signature=1 is default.
3394 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3395 CmdArgs.push_back("-fencode-extended-block-signature");
3398 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3399 // NOTE: This logic is duplicated in ToolChains.cpp.
3400 bool ARC = isObjCAutoRefCount(Args);
3402 getToolChain().CheckObjCARC();
3404 CmdArgs.push_back("-fobjc-arc");
3406 // FIXME: It seems like this entire block, and several around it should be
3407 // wrapped in isObjC, but for now we just use it here as this is where it
3408 // was being used previously.
3409 if (types::isCXX(InputType) && types::isObjC(InputType)) {
3410 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3411 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3413 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3416 // Allow the user to enable full exceptions code emission.
3417 // We define off for Objective-CC, on for Objective-C++.
3418 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3419 options::OPT_fno_objc_arc_exceptions,
3420 /*default*/ types::isCXX(InputType)))
3421 CmdArgs.push_back("-fobjc-arc-exceptions");
3424 // -fobjc-infer-related-result-type is the default, except in the Objective-C
3426 if (rewriteKind != RK_None)
3427 CmdArgs.push_back("-fno-objc-infer-related-result-type");
3429 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
3430 // takes precedence.
3431 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3433 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3436 D.Diag(diag::err_drv_objc_gc_arr)
3437 << GCArg->getAsString(Args);
3438 } else if (getToolChain().SupportsObjCGC()) {
3439 GCArg->render(Args, CmdArgs);
3441 // FIXME: We should move this to a hard error.
3442 D.Diag(diag::warn_drv_objc_gc_unsupported)
3443 << GCArg->getAsString(Args);
3447 // Add exception args.
3448 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
3449 KernelOrKext, objcRuntime, CmdArgs);
3451 if (getToolChain().UseSjLjExceptions())
3452 CmdArgs.push_back("-fsjlj-exceptions");
3454 // C++ "sane" operator new.
3455 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3456 options::OPT_fno_assume_sane_operator_new))
3457 CmdArgs.push_back("-fno-assume-sane-operator-new");
3459 // -fconstant-cfstrings is default, and may be subject to argument translation
3461 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3462 options::OPT_fno_constant_cfstrings) ||
3463 !Args.hasFlag(options::OPT_mconstant_cfstrings,
3464 options::OPT_mno_constant_cfstrings))
3465 CmdArgs.push_back("-fno-constant-cfstrings");
3467 // -fshort-wchar default varies depending on platform; only
3468 // pass if specified.
3469 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
3470 A->render(Args, CmdArgs);
3472 // -fno-pascal-strings is default, only pass non-default.
3473 if (Args.hasFlag(options::OPT_fpascal_strings,
3474 options::OPT_fno_pascal_strings,
3476 CmdArgs.push_back("-fpascal-strings");
3478 // Honor -fpack-struct= and -fpack-struct, if given. Note that
3479 // -fno-pack-struct doesn't apply to -fpack-struct=.
3480 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
3481 std::string PackStructStr = "-fpack-struct=";
3482 PackStructStr += A->getValue();
3483 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
3484 } else if (Args.hasFlag(options::OPT_fpack_struct,
3485 options::OPT_fno_pack_struct, false)) {
3486 CmdArgs.push_back("-fpack-struct=1");
3489 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
3490 if (!Args.hasArg(options::OPT_fcommon))
3491 CmdArgs.push_back("-fno-common");
3492 Args.ClaimAllArgs(options::OPT_fno_common);
3495 // -fcommon is default, only pass non-default.
3496 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
3497 CmdArgs.push_back("-fno-common");
3499 // -fsigned-bitfields is default, and clang doesn't yet support
3500 // -funsigned-bitfields.
3501 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
3502 options::OPT_funsigned_bitfields))
3503 D.Diag(diag::warn_drv_clang_unsupported)
3504 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3506 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
3507 if (!Args.hasFlag(options::OPT_ffor_scope,
3508 options::OPT_fno_for_scope))
3509 D.Diag(diag::err_drv_clang_unsupported)
3510 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3512 // -fcaret-diagnostics is default.
3513 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3514 options::OPT_fno_caret_diagnostics, true))
3515 CmdArgs.push_back("-fno-caret-diagnostics");
3517 // -fdiagnostics-fixit-info is default, only pass non-default.
3518 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
3519 options::OPT_fno_diagnostics_fixit_info))
3520 CmdArgs.push_back("-fno-diagnostics-fixit-info");
3522 // Enable -fdiagnostics-show-option by default.
3523 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
3524 options::OPT_fno_diagnostics_show_option))
3525 CmdArgs.push_back("-fdiagnostics-show-option");
3528 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3529 CmdArgs.push_back("-fdiagnostics-show-category");
3530 CmdArgs.push_back(A->getValue());
3534 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3535 CmdArgs.push_back("-fdiagnostics-format");
3536 CmdArgs.push_back(A->getValue());
3539 if (Arg *A = Args.getLastArg(
3540 options::OPT_fdiagnostics_show_note_include_stack,
3541 options::OPT_fno_diagnostics_show_note_include_stack)) {
3542 if (A->getOption().matches(
3543 options::OPT_fdiagnostics_show_note_include_stack))
3544 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3546 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3549 // Color diagnostics are the default, unless the terminal doesn't support
3551 // Support both clang's -f[no-]color-diagnostics and gcc's
3552 // -f[no-]diagnostics-colors[=never|always|auto].
3553 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
3554 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
3556 const Option &O = (*it)->getOption();
3557 if (!O.matches(options::OPT_fcolor_diagnostics) &&
3558 !O.matches(options::OPT_fdiagnostics_color) &&
3559 !O.matches(options::OPT_fno_color_diagnostics) &&
3560 !O.matches(options::OPT_fno_diagnostics_color) &&
3561 !O.matches(options::OPT_fdiagnostics_color_EQ))
3565 if (O.matches(options::OPT_fcolor_diagnostics) ||
3566 O.matches(options::OPT_fdiagnostics_color)) {
3567 ShowColors = Colors_On;
3568 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
3569 O.matches(options::OPT_fno_diagnostics_color)) {
3570 ShowColors = Colors_Off;
3572 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
3573 StringRef value((*it)->getValue());
3574 if (value == "always")
3575 ShowColors = Colors_On;
3576 else if (value == "never")
3577 ShowColors = Colors_Off;
3578 else if (value == "auto")
3579 ShowColors = Colors_Auto;
3581 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3582 << ("-fdiagnostics-color=" + value).str();
3585 if (ShowColors == Colors_On ||
3586 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
3587 CmdArgs.push_back("-fcolor-diagnostics");
3589 if (Args.hasArg(options::OPT_fansi_escape_codes))
3590 CmdArgs.push_back("-fansi-escape-codes");
3592 if (!Args.hasFlag(options::OPT_fshow_source_location,
3593 options::OPT_fno_show_source_location))
3594 CmdArgs.push_back("-fno-show-source-location");
3596 if (!Args.hasFlag(options::OPT_fshow_column,
3597 options::OPT_fno_show_column,
3599 CmdArgs.push_back("-fno-show-column");
3601 if (!Args.hasFlag(options::OPT_fspell_checking,
3602 options::OPT_fno_spell_checking))
3603 CmdArgs.push_back("-fno-spell-checking");
3606 // -fno-asm-blocks is default.
3607 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
3609 CmdArgs.push_back("-fasm-blocks");
3611 // Enable vectorization per default according to the optimization level
3612 // selected. For optimization levels that want vectorization we use the alias
3613 // option to simplify the hasFlag logic.
3614 bool EnableVec = shouldEnableVectorizerAtOLevel(Args);
3615 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
3616 options::OPT_fvectorize;
3617 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
3618 options::OPT_fno_vectorize, EnableVec))
3619 CmdArgs.push_back("-vectorize-loops");
3621 // -fslp-vectorize is default.
3622 if (Args.hasFlag(options::OPT_fslp_vectorize,
3623 options::OPT_fno_slp_vectorize, true))
3624 CmdArgs.push_back("-vectorize-slp");
3626 // -fno-slp-vectorize-aggressive is default.
3627 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
3628 options::OPT_fno_slp_vectorize_aggressive, false))
3629 CmdArgs.push_back("-vectorize-slp-aggressive");
3631 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
3632 A->render(Args, CmdArgs);
3634 // -fdollars-in-identifiers default varies depending on platform and
3635 // language; only pass if specified.
3636 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
3637 options::OPT_fno_dollars_in_identifiers)) {
3638 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
3639 CmdArgs.push_back("-fdollars-in-identifiers");
3641 CmdArgs.push_back("-fno-dollars-in-identifiers");
3644 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
3645 // practical purposes.
3646 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
3647 options::OPT_fno_unit_at_a_time)) {
3648 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
3649 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
3652 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
3653 options::OPT_fno_apple_pragma_pack, false))
3654 CmdArgs.push_back("-fapple-pragma-pack");
3656 // le32-specific flags:
3657 // -fno-math-builtin: clang should not convert math builtins to intrinsics
3659 if (getToolChain().getArch() == llvm::Triple::le32) {
3660 CmdArgs.push_back("-fno-math-builtin");
3663 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
3665 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
3667 if (getToolChain().getTriple().isOSDarwin() &&
3668 (getToolChain().getArch() == llvm::Triple::arm ||
3669 getToolChain().getArch() == llvm::Triple::thumb)) {
3670 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
3671 CmdArgs.push_back("-fno-builtin-strcat");
3672 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
3673 CmdArgs.push_back("-fno-builtin-strcpy");
3677 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
3678 if (Arg *A = Args.getLastArg(options::OPT_traditional,
3679 options::OPT_traditional_cpp)) {
3680 if (isa<PreprocessJobAction>(JA))
3681 CmdArgs.push_back("-traditional-cpp");
3683 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
3686 Args.AddLastArg(CmdArgs, options::OPT_dM);
3687 Args.AddLastArg(CmdArgs, options::OPT_dD);
3689 // Handle serialized diagnostics.
3690 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
3691 CmdArgs.push_back("-serialize-diagnostic-file");
3692 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
3695 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
3696 CmdArgs.push_back("-fretain-comments-from-system-headers");
3698 // Forward -fcomment-block-commands to -cc1.
3699 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
3700 // Forward -fparse-all-comments to -cc1.
3701 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
3703 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
3705 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
3706 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
3707 ie = Args.filtered_end(); it != ie; ++it) {
3710 // We translate this by hand to the -cc1 argument, since nightly test uses
3711 // it and developers have been trained to spell it with -mllvm.
3712 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
3713 CmdArgs.push_back("-disable-llvm-optzns");
3715 (*it)->render(Args, CmdArgs);
3718 if (Output.getType() == types::TY_Dependencies) {
3719 // Handled with other dependency code.
3720 } else if (Output.isFilename()) {
3721 CmdArgs.push_back("-o");
3722 CmdArgs.push_back(Output.getFilename());
3724 assert(Output.isNothing() && "Invalid output.");
3727 for (InputInfoList::const_iterator
3728 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3729 const InputInfo &II = *it;
3730 CmdArgs.push_back("-x");
3731 if (Args.hasArg(options::OPT_rewrite_objc))
3732 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
3734 CmdArgs.push_back(types::getTypeName(II.getType()));
3735 if (II.isFilename())
3736 CmdArgs.push_back(II.getFilename());
3738 II.getInputArg().renderAsInput(Args, CmdArgs);
3741 Args.AddAllArgs(CmdArgs, options::OPT_undef);
3743 const char *Exec = getToolChain().getDriver().getClangProgramPath();
3745 // Optionally embed the -cc1 level arguments into the debug info, for build
3747 if (getToolChain().UseDwarfDebugFlags()) {
3748 ArgStringList OriginalArgs;
3749 for (ArgList::const_iterator it = Args.begin(),
3750 ie = Args.end(); it != ie; ++it)
3751 (*it)->render(Args, OriginalArgs);
3753 SmallString<256> Flags;
3755 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
3757 Flags += OriginalArgs[i];
3759 CmdArgs.push_back("-dwarf-debug-flags");
3760 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3763 // Add the split debug info name to the command lines here so we
3764 // can propagate it to the backend.
3765 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
3766 getToolChain().getTriple().isOSLinux() &&
3767 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
3768 const char *SplitDwarfOut;
3770 CmdArgs.push_back("-split-dwarf-file");
3771 SplitDwarfOut = SplitDebugName(Args, Inputs);
3772 CmdArgs.push_back(SplitDwarfOut);
3775 // Finally add the compile command to the compilation.
3776 if (Args.hasArg(options::OPT__SLASH_fallback)) {
3777 tools::visualstudio::Compile CL(getToolChain());
3778 Command *CLCommand = CL.GetCommand(C, JA, Output, Inputs, Args,
3780 C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
3782 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3786 // Handle the debug info splitting at object creation time if we're
3787 // creating an object.
3788 // TODO: Currently only works on linux with newer objcopy.
3789 if (SplitDwarf && !isa<CompileJobAction>(JA))
3790 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
3792 if (Arg *A = Args.getLastArg(options::OPT_pg))
3793 if (Args.hasArg(options::OPT_fomit_frame_pointer))
3794 D.Diag(diag::err_drv_argument_not_allowed_with)
3795 << "-fomit-frame-pointer" << A->getAsString(Args);
3797 // Claim some arguments which clang supports automatically.
3799 // -fpch-preprocess is used with gcc to add a special marker in the output to
3800 // include the PCH file. Clang's PTH solution is completely transparent, so we
3801 // do not need to deal with it at all.
3802 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
3804 // Claim some arguments which clang doesn't support, but we don't
3805 // care to warn the user about.
3806 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
3807 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
3809 // Disable warnings for clang -E -emit-llvm foo.c
3810 Args.ClaimAllArgs(options::OPT_emit_llvm);
3813 /// Add options related to the Objective-C runtime/ABI.
3815 /// Returns true if the runtime is non-fragile.
3816 ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
3817 ArgStringList &cmdArgs,
3818 RewriteKind rewriteKind) const {
3819 // Look for the controlling runtime option.
3820 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
3821 options::OPT_fgnu_runtime,
3822 options::OPT_fobjc_runtime_EQ);
3824 // Just forward -fobjc-runtime= to the frontend. This supercedes
3825 // options about fragility.
3827 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
3828 ObjCRuntime runtime;
3829 StringRef value = runtimeArg->getValue();
3830 if (runtime.tryParse(value)) {
3831 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
3835 runtimeArg->render(args, cmdArgs);
3839 // Otherwise, we'll need the ABI "version". Version numbers are
3840 // slightly confusing for historical reasons:
3841 // 1 - Traditional "fragile" ABI
3842 // 2 - Non-fragile ABI, version 1
3843 // 3 - Non-fragile ABI, version 2
3844 unsigned objcABIVersion = 1;
3845 // If -fobjc-abi-version= is present, use that to set the version.
3846 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
3847 StringRef value = abiArg->getValue();
3850 else if (value == "2")
3852 else if (value == "3")
3855 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3858 // Otherwise, determine if we are using the non-fragile ABI.
3859 bool nonFragileABIIsDefault =
3860 (rewriteKind == RK_NonFragile ||
3861 (rewriteKind == RK_None &&
3862 getToolChain().IsObjCNonFragileABIDefault()));
3863 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
3864 options::OPT_fno_objc_nonfragile_abi,
3865 nonFragileABIIsDefault)) {
3866 // Determine the non-fragile ABI version to use.
3867 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
3868 unsigned nonFragileABIVersion = 1;
3870 unsigned nonFragileABIVersion = 2;
3873 if (Arg *abiArg = args.getLastArg(
3874 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
3875 StringRef value = abiArg->getValue();
3877 nonFragileABIVersion = 1;
3878 else if (value == "2")
3879 nonFragileABIVersion = 2;
3881 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3885 objcABIVersion = 1 + nonFragileABIVersion;
3891 // We don't actually care about the ABI version other than whether
3892 // it's non-fragile.
3893 bool isNonFragile = objcABIVersion != 1;
3895 // If we have no runtime argument, ask the toolchain for its default runtime.
3896 // However, the rewriter only really supports the Mac runtime, so assume that.
3897 ObjCRuntime runtime;
3899 switch (rewriteKind) {
3901 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3904 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
3907 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3912 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
3913 // On Darwin, make this use the default behavior for the toolchain.
3914 if (getToolChain().getTriple().isOSDarwin()) {
3915 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3917 // Otherwise, build for a generic macosx port.
3919 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3924 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
3925 // Legacy behaviour is to target the gnustep runtime if we are i
3926 // non-fragile mode or the GCC runtime in fragile mode.
3928 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
3930 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
3933 cmdArgs.push_back(args.MakeArgString(
3934 "-fobjc-runtime=" + runtime.getAsString()));
3938 void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
3939 unsigned RTOptionID = options::OPT__SLASH_MT;
3941 if (Args.hasArg(options::OPT__SLASH_LDd))
3942 // The /LDd option implies /MTd. The dependent lib part can be overridden,
3943 // but defining _DEBUG is sticky.
3944 RTOptionID = options::OPT__SLASH_MTd;
3946 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
3947 RTOptionID = A->getOption().getID();
3949 switch(RTOptionID) {
3950 case options::OPT__SLASH_MD:
3951 if (Args.hasArg(options::OPT__SLASH_LDd))
3952 CmdArgs.push_back("-D_DEBUG");
3953 CmdArgs.push_back("-D_MT");
3954 CmdArgs.push_back("-D_DLL");
3955 CmdArgs.push_back("--dependent-lib=msvcrt");
3957 case options::OPT__SLASH_MDd:
3958 CmdArgs.push_back("-D_DEBUG");
3959 CmdArgs.push_back("-D_MT");
3960 CmdArgs.push_back("-D_DLL");
3961 CmdArgs.push_back("--dependent-lib=msvcrtd");
3963 case options::OPT__SLASH_MT:
3964 if (Args.hasArg(options::OPT__SLASH_LDd))
3965 CmdArgs.push_back("-D_DEBUG");
3966 CmdArgs.push_back("-D_MT");
3967 CmdArgs.push_back("--dependent-lib=libcmt");
3969 case options::OPT__SLASH_MTd:
3970 CmdArgs.push_back("-D_DEBUG");
3971 CmdArgs.push_back("-D_MT");
3972 CmdArgs.push_back("--dependent-lib=libcmtd");
3975 llvm_unreachable("Unexpected option ID.");
3978 // This provides POSIX compatibility (maps 'open' to '_open'), which most
3979 // users want. The /Za flag to cl.exe turns this off, but it's not
3980 // implemented in clang.
3981 CmdArgs.push_back("--dependent-lib=oldnames");
3983 // FIXME: Make this default for the win32 triple.
3984 CmdArgs.push_back("-cxx-abi");
3985 CmdArgs.push_back("microsoft");
3987 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
3988 A->render(Args, CmdArgs);
3990 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
3991 CmdArgs.push_back("-fdiagnostics-format");
3992 if (Args.hasArg(options::OPT__SLASH_fallback))
3993 CmdArgs.push_back("msvc-fallback");
3995 CmdArgs.push_back("msvc");
3999 void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
4000 const InputInfo &Output,
4001 const InputInfoList &Inputs,
4002 const ArgList &Args,
4003 const char *LinkingOutput) const {
4004 ArgStringList CmdArgs;
4006 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4007 const InputInfo &Input = Inputs[0];
4009 // Don't warn about "clang -w -c foo.s"
4010 Args.ClaimAllArgs(options::OPT_w);
4011 // and "clang -emit-llvm -c foo.s"
4012 Args.ClaimAllArgs(options::OPT_emit_llvm);
4014 // Invoke ourselves in -cc1as mode.
4016 // FIXME: Implement custom jobs for internal actions.
4017 CmdArgs.push_back("-cc1as");
4019 // Add the "effective" target triple.
4020 CmdArgs.push_back("-triple");
4021 std::string TripleStr =
4022 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
4023 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4025 // Set the output mode, we currently only expect to be used as a real
4027 CmdArgs.push_back("-filetype");
4028 CmdArgs.push_back("obj");
4030 // Set the main file name, so that debug info works even with
4031 // -save-temps or preprocessed assembly.
4032 CmdArgs.push_back("-main-file-name");
4033 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4035 // Add the target cpu
4036 const llvm::Triple &Triple = getToolChain().getTriple();
4037 std::string CPU = getCPUName(Args, Triple);
4039 CmdArgs.push_back("-target-cpu");
4040 CmdArgs.push_back(Args.MakeArgString(CPU));
4043 // Add the target features
4044 const Driver &D = getToolChain().getDriver();
4045 getTargetFeatures(D, Triple, Args, CmdArgs);
4047 // Ignore explicit -force_cpusubtype_ALL option.
4048 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
4050 // Determine the original source input.
4051 const Action *SourceAction = &JA;
4052 while (SourceAction->getKind() != Action::InputClass) {
4053 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4054 SourceAction = SourceAction->getInputs()[0];
4057 // Forward -g and handle debug info related flags, assuming we are dealing
4058 // with an actual assembly file.
4059 if (SourceAction->getType() == types::TY_Asm ||
4060 SourceAction->getType() == types::TY_PP_Asm) {
4061 Args.ClaimAllArgs(options::OPT_g_Group);
4062 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4063 if (!A->getOption().matches(options::OPT_g0))
4064 CmdArgs.push_back("-g");
4066 // Add the -fdebug-compilation-dir flag if needed.
4067 addDebugCompDirArg(Args, CmdArgs);
4069 // Set the AT_producer to the clang version when using the integrated
4070 // assembler on assembly source files.
4071 CmdArgs.push_back("-dwarf-debug-producer");
4072 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
4075 // Optionally embed the -cc1as level arguments into the debug info, for build
4077 if (getToolChain().UseDwarfDebugFlags()) {
4078 ArgStringList OriginalArgs;
4079 for (ArgList::const_iterator it = Args.begin(),
4080 ie = Args.end(); it != ie; ++it)
4081 (*it)->render(Args, OriginalArgs);
4083 SmallString<256> Flags;
4084 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4086 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4088 Flags += OriginalArgs[i];
4090 CmdArgs.push_back("-dwarf-debug-flags");
4091 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4094 // FIXME: Add -static support, once we have it.
4096 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4097 getToolChain().getDriver());
4099 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
4101 assert(Output.isFilename() && "Unexpected lipo output.");
4102 CmdArgs.push_back("-o");
4103 CmdArgs.push_back(Output.getFilename());
4105 assert(Input.isFilename() && "Invalid input.");
4106 CmdArgs.push_back(Input.getFilename());
4108 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4109 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4111 // Handle the debug info splitting at object creation time if we're
4112 // creating an object.
4113 // TODO: Currently only works on linux with newer objcopy.
4114 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
4115 getToolChain().getTriple().isOSLinux())
4116 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4117 SplitDebugName(Args, Inputs));
4120 void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
4121 const InputInfo &Output,
4122 const InputInfoList &Inputs,
4123 const ArgList &Args,
4124 const char *LinkingOutput) const {
4125 const Driver &D = getToolChain().getDriver();
4126 ArgStringList CmdArgs;
4128 for (ArgList::const_iterator
4129 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
4131 if (forwardToGCC(A->getOption())) {
4132 // Don't forward any -g arguments to assembly steps.
4133 if (isa<AssembleJobAction>(JA) &&
4134 A->getOption().matches(options::OPT_g_Group))
4137 // Don't forward any -W arguments to assembly and link steps.
4138 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4139 A->getOption().matches(options::OPT_W_Group))
4142 // It is unfortunate that we have to claim here, as this means
4143 // we will basically never report anything interesting for
4144 // platforms using a generic gcc, even if we are just using gcc
4145 // to get to the assembler.
4147 A->render(Args, CmdArgs);
4151 RenderExtraToolArgs(JA, CmdArgs);
4153 // If using a driver driver, force the arch.
4154 llvm::Triple::ArchType Arch = getToolChain().getArch();
4155 if (getToolChain().getTriple().isOSDarwin()) {
4156 CmdArgs.push_back("-arch");
4158 // FIXME: Remove these special cases.
4159 if (Arch == llvm::Triple::ppc)
4160 CmdArgs.push_back("ppc");
4161 else if (Arch == llvm::Triple::ppc64)
4162 CmdArgs.push_back("ppc64");
4163 else if (Arch == llvm::Triple::ppc64le)
4164 CmdArgs.push_back("ppc64le");
4166 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
4169 // Try to force gcc to match the tool chain we want, if we recognize
4172 // FIXME: The triple class should directly provide the information we want
4174 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
4175 CmdArgs.push_back("-m32");
4176 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4177 Arch == llvm::Triple::ppc64le)
4178 CmdArgs.push_back("-m64");
4180 if (Output.isFilename()) {
4181 CmdArgs.push_back("-o");
4182 CmdArgs.push_back(Output.getFilename());
4184 assert(Output.isNothing() && "Unexpected output");
4185 CmdArgs.push_back("-fsyntax-only");
4188 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4189 options::OPT_Xassembler);
4191 // Only pass -x if gcc will understand it; otherwise hope gcc
4192 // understands the suffix correctly. The main use case this would go
4193 // wrong in is for linker inputs if they happened to have an odd
4194 // suffix; really the only way to get this to happen is a command
4195 // like '-x foobar a.c' which will treat a.c like a linker input.
4197 // FIXME: For the linker case specifically, can we safely convert
4198 // inputs into '-Wl,' options?
4199 for (InputInfoList::const_iterator
4200 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4201 const InputInfo &II = *it;
4203 // Don't try to pass LLVM or AST inputs to a generic gcc.
4204 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4205 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4206 D.Diag(diag::err_drv_no_linker_llvm_support)
4207 << getToolChain().getTripleString();
4208 else if (II.getType() == types::TY_AST)
4209 D.Diag(diag::err_drv_no_ast_support)
4210 << getToolChain().getTripleString();
4211 else if (II.getType() == types::TY_ModuleFile)
4212 D.Diag(diag::err_drv_no_module_support)
4213 << getToolChain().getTripleString();
4215 if (types::canTypeBeUserSpecified(II.getType())) {
4216 CmdArgs.push_back("-x");
4217 CmdArgs.push_back(types::getTypeName(II.getType()));
4220 if (II.isFilename())
4221 CmdArgs.push_back(II.getFilename());
4223 const Arg &A = II.getInputArg();
4225 // Reverse translate some rewritten options.
4226 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4227 CmdArgs.push_back("-lstdc++");
4231 // Don't render as input, we need gcc to do the translations.
4232 A.render(Args, CmdArgs);
4236 const std::string customGCCName = D.getCCCGenericGCCName();
4237 const char *GCCName;
4238 if (!customGCCName.empty())
4239 GCCName = customGCCName.c_str();
4240 else if (D.CCCIsCXX()) {
4246 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4247 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4250 void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4251 ArgStringList &CmdArgs) const {
4252 CmdArgs.push_back("-E");
4255 void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
4256 ArgStringList &CmdArgs) const {
4257 // The type is good enough.
4260 void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4261 ArgStringList &CmdArgs) const {
4262 const Driver &D = getToolChain().getDriver();
4264 // If -flto, etc. are present then make sure not to force assembly output.
4265 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4266 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
4267 CmdArgs.push_back("-c");
4269 if (JA.getType() != types::TY_PP_Asm)
4270 D.Diag(diag::err_drv_invalid_gcc_output_type)
4271 << getTypeName(JA.getType());
4273 CmdArgs.push_back("-S");
4277 void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
4278 ArgStringList &CmdArgs) const {
4279 CmdArgs.push_back("-c");
4282 void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4283 ArgStringList &CmdArgs) const {
4284 // The types are (hopefully) good enough.
4287 // Hexagon tools start.
4288 void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
4289 ArgStringList &CmdArgs) const {
4292 void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4293 const InputInfo &Output,
4294 const InputInfoList &Inputs,
4295 const ArgList &Args,
4296 const char *LinkingOutput) const {
4298 const Driver &D = getToolChain().getDriver();
4299 ArgStringList CmdArgs;
4301 std::string MarchString = "-march=";
4302 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
4303 CmdArgs.push_back(Args.MakeArgString(MarchString));
4305 RenderExtraToolArgs(JA, CmdArgs);
4307 if (Output.isFilename()) {
4308 CmdArgs.push_back("-o");
4309 CmdArgs.push_back(Output.getFilename());
4311 assert(Output.isNothing() && "Unexpected output");
4312 CmdArgs.push_back("-fsyntax-only");
4315 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4316 if (!SmallDataThreshold.empty())
4318 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4320 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4321 options::OPT_Xassembler);
4323 // Only pass -x if gcc will understand it; otherwise hope gcc
4324 // understands the suffix correctly. The main use case this would go
4325 // wrong in is for linker inputs if they happened to have an odd
4326 // suffix; really the only way to get this to happen is a command
4327 // like '-x foobar a.c' which will treat a.c like a linker input.
4329 // FIXME: For the linker case specifically, can we safely convert
4330 // inputs into '-Wl,' options?
4331 for (InputInfoList::const_iterator
4332 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4333 const InputInfo &II = *it;
4335 // Don't try to pass LLVM or AST inputs to a generic gcc.
4336 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4337 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4338 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
4339 << getToolChain().getTripleString();
4340 else if (II.getType() == types::TY_AST)
4341 D.Diag(clang::diag::err_drv_no_ast_support)
4342 << getToolChain().getTripleString();
4343 else if (II.getType() == types::TY_ModuleFile)
4344 D.Diag(diag::err_drv_no_module_support)
4345 << getToolChain().getTripleString();
4347 if (II.isFilename())
4348 CmdArgs.push_back(II.getFilename());
4350 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
4351 II.getInputArg().render(Args, CmdArgs);
4354 const char *GCCName = "hexagon-as";
4356 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4357 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4360 void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
4361 ArgStringList &CmdArgs) const {
4362 // The types are (hopefully) good enough.
4365 void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
4366 const InputInfo &Output,
4367 const InputInfoList &Inputs,
4368 const ArgList &Args,
4369 const char *LinkingOutput) const {
4371 const toolchains::Hexagon_TC& ToolChain =
4372 static_cast<const toolchains::Hexagon_TC&>(getToolChain());
4373 const Driver &D = ToolChain.getDriver();
4375 ArgStringList CmdArgs;
4377 //----------------------------------------------------------------------------
4379 //----------------------------------------------------------------------------
4380 bool hasStaticArg = Args.hasArg(options::OPT_static);
4381 bool buildingLib = Args.hasArg(options::OPT_shared);
4382 bool buildPIE = Args.hasArg(options::OPT_pie);
4383 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4384 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4385 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4386 bool useShared = buildingLib && !hasStaticArg;
4388 //----------------------------------------------------------------------------
4389 // Silence warnings for various options
4390 //----------------------------------------------------------------------------
4392 Args.ClaimAllArgs(options::OPT_g_Group);
4393 Args.ClaimAllArgs(options::OPT_emit_llvm);
4394 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
4395 // handled somewhere else.
4396 Args.ClaimAllArgs(options::OPT_static_libgcc);
4398 //----------------------------------------------------------------------------
4400 //----------------------------------------------------------------------------
4401 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
4402 e = ToolChain.ExtraOpts.end();
4404 CmdArgs.push_back(i->c_str());
4406 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
4407 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
4410 CmdArgs.push_back("-shared");
4411 CmdArgs.push_back("-call_shared"); // should be the default, but doing as
4416 CmdArgs.push_back("-static");
4418 if (buildPIE && !buildingLib)
4419 CmdArgs.push_back("-pie");
4421 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4422 if (!SmallDataThreshold.empty()) {
4424 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4427 //----------------------------------------------------------------------------
4429 //----------------------------------------------------------------------------
4430 CmdArgs.push_back("-o");
4431 CmdArgs.push_back(Output.getFilename());
4433 const std::string MarchSuffix = "/" + MarchString;
4434 const std::string G0Suffix = "/G0";
4435 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
4436 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
4438 const std::string StartFilesDir = RootDir
4441 ? MarchG0Suffix : MarchSuffix);
4443 //----------------------------------------------------------------------------
4445 //----------------------------------------------------------------------------
4446 std::vector<std::string> oslibs;
4447 bool hasStandalone= false;
4449 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
4450 ie = Args.filtered_end(); it != ie; ++it) {
4452 oslibs.push_back((*it)->getValue());
4453 hasStandalone = hasStandalone || (oslibs.back() == "standalone");
4455 if (oslibs.empty()) {
4456 oslibs.push_back("standalone");
4457 hasStandalone = true;
4460 //----------------------------------------------------------------------------
4462 //----------------------------------------------------------------------------
4463 if (incStdLib && incStartFiles) {
4466 if (hasStandalone) {
4468 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
4470 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
4472 std::string initObj = useShared ? "/initS.o" : "/init.o";
4473 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
4476 //----------------------------------------------------------------------------
4477 // Library Search Paths
4478 //----------------------------------------------------------------------------
4479 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
4480 for (ToolChain::path_list::const_iterator
4481 i = LibPaths.begin(),
4485 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
4487 //----------------------------------------------------------------------------
4489 //----------------------------------------------------------------------------
4490 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4491 Args.AddAllArgs(CmdArgs, options::OPT_e);
4492 Args.AddAllArgs(CmdArgs, options::OPT_s);
4493 Args.AddAllArgs(CmdArgs, options::OPT_t);
4494 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4496 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4498 //----------------------------------------------------------------------------
4500 //----------------------------------------------------------------------------
4501 if (incStdLib && incDefLibs) {
4503 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
4504 CmdArgs.push_back("-lm");
4507 CmdArgs.push_back("--start-group");
4510 for(std::vector<std::string>::iterator i = oslibs.begin(),
4511 e = oslibs.end(); i != e; ++i)
4512 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
4513 CmdArgs.push_back("-lc");
4515 CmdArgs.push_back("-lgcc");
4517 CmdArgs.push_back("--end-group");
4520 //----------------------------------------------------------------------------
4522 //----------------------------------------------------------------------------
4523 if (incStdLib && incStartFiles) {
4524 std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
4525 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
4528 std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
4529 C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
4531 // Hexagon tools end.
4533 llvm::Triple::ArchType darwin::getArchTypeForDarwinArchName(StringRef Str) {
4534 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
4535 // archs which Darwin doesn't use.
4537 // The matching this routine does is fairly pointless, since it is neither the
4538 // complete architecture list, nor a reasonable subset. The problem is that
4539 // historically the driver driver accepts this and also ties its -march=
4540 // handling to the architecture name, so we need to be careful before removing
4543 // This code must be kept in sync with Clang's Darwin specific argument
4546 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
4547 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
4548 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
4549 .Case("ppc64", llvm::Triple::ppc64)
4550 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
4551 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
4553 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
4554 // This is derived from the driver driver.
4555 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
4556 .Cases("armv7", "armv7em", "armv7f", "armv7k", "armv7m", llvm::Triple::arm)
4557 .Cases("armv7s", "xscale", llvm::Triple::arm)
4558 .Case("r600", llvm::Triple::r600)
4559 .Case("nvptx", llvm::Triple::nvptx)
4560 .Case("nvptx64", llvm::Triple::nvptx64)
4561 .Case("amdil", llvm::Triple::amdil)
4562 .Case("spir", llvm::Triple::spir)
4563 .Default(llvm::Triple::UnknownArch);
4566 const char *Clang::getBaseInputName(const ArgList &Args,
4567 const InputInfoList &Inputs) {
4568 return Args.MakeArgString(
4569 llvm::sys::path::filename(Inputs[0].getBaseInput()));
4572 const char *Clang::getBaseInputStem(const ArgList &Args,
4573 const InputInfoList &Inputs) {
4574 const char *Str = getBaseInputName(Args, Inputs);
4576 if (const char *End = strrchr(Str, '.'))
4577 return Args.MakeArgString(std::string(Str, End));
4582 const char *Clang::getDependencyFileName(const ArgList &Args,
4583 const InputInfoList &Inputs) {
4584 // FIXME: Think about this more.
4587 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
4588 std::string Str(OutputOpt->getValue());
4589 Res = Str.substr(0, Str.rfind('.'));
4591 Res = getBaseInputStem(Args, Inputs);
4593 return Args.MakeArgString(Res + ".d");
4596 void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4597 const InputInfo &Output,
4598 const InputInfoList &Inputs,
4599 const ArgList &Args,
4600 const char *LinkingOutput) const {
4601 ArgStringList CmdArgs;
4603 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4604 const InputInfo &Input = Inputs[0];
4606 // Determine the original source input.
4607 const Action *SourceAction = &JA;
4608 while (SourceAction->getKind() != Action::InputClass) {
4609 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4610 SourceAction = SourceAction->getInputs()[0];
4613 // If -no_integrated_as is used add -Q to the darwin assember driver to make
4614 // sure it runs its system assembler not clang's integrated assembler.
4615 if (Args.hasArg(options::OPT_no_integrated_as))
4616 CmdArgs.push_back("-Q");
4618 // Forward -g, assuming we are dealing with an actual assembly file.
4619 if (SourceAction->getType() == types::TY_Asm ||
4620 SourceAction->getType() == types::TY_PP_Asm) {
4621 if (Args.hasArg(options::OPT_gstabs))
4622 CmdArgs.push_back("--gstabs");
4623 else if (Args.hasArg(options::OPT_g_Group))
4624 CmdArgs.push_back("-g");
4627 // Derived from asm spec.
4628 AddDarwinArch(Args, CmdArgs);
4630 // Use -force_cpusubtype_ALL on x86 by default.
4631 if (getToolChain().getArch() == llvm::Triple::x86 ||
4632 getToolChain().getArch() == llvm::Triple::x86_64 ||
4633 Args.hasArg(options::OPT_force__cpusubtype__ALL))
4634 CmdArgs.push_back("-force_cpusubtype_ALL");
4636 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
4637 (((Args.hasArg(options::OPT_mkernel) ||
4638 Args.hasArg(options::OPT_fapple_kext)) &&
4639 (!getDarwinToolChain().isTargetIPhoneOS() ||
4640 getDarwinToolChain().isIPhoneOSVersionLT(6, 0))) ||
4641 Args.hasArg(options::OPT_static)))
4642 CmdArgs.push_back("-static");
4644 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4645 options::OPT_Xassembler);
4647 assert(Output.isFilename() && "Unexpected lipo output.");
4648 CmdArgs.push_back("-o");
4649 CmdArgs.push_back(Output.getFilename());
4651 assert(Input.isFilename() && "Invalid input.");
4652 CmdArgs.push_back(Input.getFilename());
4654 // asm_final spec is empty.
4657 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4658 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4661 void darwin::DarwinTool::anchor() {}
4663 void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
4664 ArgStringList &CmdArgs) const {
4665 StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
4667 // Derived from darwin_arch spec.
4668 CmdArgs.push_back("-arch");
4669 CmdArgs.push_back(Args.MakeArgString(ArchName));
4671 // FIXME: Is this needed anymore?
4672 if (ArchName == "arm")
4673 CmdArgs.push_back("-force_cpusubtype_ALL");
4676 bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
4677 // We only need to generate a temp path for LTO if we aren't compiling object
4678 // files. When compiling source files, we run 'dsymutil' after linking. We
4679 // don't run 'dsymutil' when compiling object files.
4680 for (InputInfoList::const_iterator
4681 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
4682 if (it->getType() != types::TY_Object)
4688 void darwin::Link::AddLinkArgs(Compilation &C,
4689 const ArgList &Args,
4690 ArgStringList &CmdArgs,
4691 const InputInfoList &Inputs) const {
4692 const Driver &D = getToolChain().getDriver();
4693 const toolchains::Darwin &DarwinTC = getDarwinToolChain();
4695 unsigned Version[3] = { 0, 0, 0 };
4696 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
4698 if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
4699 Version[1], Version[2], HadExtra) ||
4701 D.Diag(diag::err_drv_invalid_version_number)
4702 << A->getAsString(Args);
4705 // Newer linkers support -demangle, pass it if supported and not disabled by
4707 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) {
4708 // Don't pass -demangle to ld_classic.
4710 // FIXME: This is a temporary workaround, ld should be handling this.
4711 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
4712 Args.hasArg(options::OPT_static));
4713 if (getToolChain().getArch() == llvm::Triple::x86) {
4714 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
4715 options::OPT_Wl_COMMA),
4716 ie = Args.filtered_end(); it != ie; ++it) {
4718 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
4719 if (StringRef(A->getValue(i)) == "-kext")
4720 UsesLdClassic = true;
4724 CmdArgs.push_back("-demangle");
4727 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
4728 CmdArgs.push_back("-export_dynamic");
4730 // If we are using LTO, then automatically create a temporary file path for
4731 // the linker to use, so that it's lifetime will extend past a possible
4733 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
4734 const char *TmpPath = C.getArgs().MakeArgString(
4735 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
4736 C.addTempFile(TmpPath);
4737 CmdArgs.push_back("-object_path_lto");
4738 CmdArgs.push_back(TmpPath);
4741 // Derived from the "link" spec.
4742 Args.AddAllArgs(CmdArgs, options::OPT_static);
4743 if (!Args.hasArg(options::OPT_static))
4744 CmdArgs.push_back("-dynamic");
4745 if (Args.hasArg(options::OPT_fgnu_runtime)) {
4746 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
4747 // here. How do we wish to handle such things?
4750 if (!Args.hasArg(options::OPT_dynamiclib)) {
4751 AddDarwinArch(Args, CmdArgs);
4752 // FIXME: Why do this only on this path?
4753 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
4755 Args.AddLastArg(CmdArgs, options::OPT_bundle);
4756 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
4757 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
4760 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
4761 (A = Args.getLastArg(options::OPT_current__version)) ||
4762 (A = Args.getLastArg(options::OPT_install__name)))
4763 D.Diag(diag::err_drv_argument_only_allowed_with)
4764 << A->getAsString(Args) << "-dynamiclib";
4766 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
4767 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
4768 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
4770 CmdArgs.push_back("-dylib");
4773 if ((A = Args.getLastArg(options::OPT_bundle)) ||
4774 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
4775 (A = Args.getLastArg(options::OPT_client__name)) ||
4776 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
4777 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
4778 (A = Args.getLastArg(options::OPT_private__bundle)))
4779 D.Diag(diag::err_drv_argument_not_allowed_with)
4780 << A->getAsString(Args) << "-dynamiclib";
4782 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
4783 "-dylib_compatibility_version");
4784 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
4785 "-dylib_current_version");
4787 AddDarwinArch(Args, CmdArgs);
4789 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
4790 "-dylib_install_name");
4793 Args.AddLastArg(CmdArgs, options::OPT_all__load);
4794 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
4795 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
4796 if (DarwinTC.isTargetIPhoneOS())
4797 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
4798 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
4799 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
4800 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
4801 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
4802 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
4803 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
4804 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
4805 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
4806 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
4807 Args.AddAllArgs(CmdArgs, options::OPT_init);
4809 // Add the deployment target.
4810 VersionTuple TargetVersion = DarwinTC.getTargetVersion();
4812 // If we had an explicit -mios-simulator-version-min argument, honor that,
4813 // otherwise use the traditional deployment targets. We can't just check the
4814 // is-sim attribute because existing code follows this path, and the linker
4815 // may not handle the argument.
4817 // FIXME: We may be able to remove this, once we can verify no one depends on
4819 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
4820 CmdArgs.push_back("-ios_simulator_version_min");
4821 else if (DarwinTC.isTargetIPhoneOS())
4822 CmdArgs.push_back("-iphoneos_version_min");
4824 CmdArgs.push_back("-macosx_version_min");
4825 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
4827 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
4828 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
4829 Args.AddLastArg(CmdArgs, options::OPT_single__module);
4830 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
4831 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
4833 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
4834 options::OPT_fno_pie,
4835 options::OPT_fno_PIE)) {
4836 if (A->getOption().matches(options::OPT_fpie) ||
4837 A->getOption().matches(options::OPT_fPIE))
4838 CmdArgs.push_back("-pie");
4840 CmdArgs.push_back("-no_pie");
4843 Args.AddLastArg(CmdArgs, options::OPT_prebind);
4844 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
4845 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
4846 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
4847 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
4848 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
4849 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
4850 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
4851 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
4852 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
4853 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
4854 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
4855 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
4856 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
4857 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
4858 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
4860 // Give --sysroot= preference, over the Apple specific behavior to also use
4861 // --isysroot as the syslibroot.
4862 StringRef sysroot = C.getSysRoot();
4863 if (sysroot != "") {
4864 CmdArgs.push_back("-syslibroot");
4865 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
4866 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
4867 CmdArgs.push_back("-syslibroot");
4868 CmdArgs.push_back(A->getValue());
4871 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
4872 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
4873 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
4874 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
4875 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
4876 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
4877 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
4878 Args.AddAllArgs(CmdArgs, options::OPT_y);
4879 Args.AddLastArg(CmdArgs, options::OPT_w);
4880 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
4881 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
4882 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
4883 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
4884 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
4885 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
4886 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
4887 Args.AddLastArg(CmdArgs, options::OPT_whyload);
4888 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
4889 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
4890 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
4891 Args.AddLastArg(CmdArgs, options::OPT_Mach);
4894 void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
4895 const InputInfo &Output,
4896 const InputInfoList &Inputs,
4897 const ArgList &Args,
4898 const char *LinkingOutput) const {
4899 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
4901 // The logic here is derived from gcc's behavior; most of which
4902 // comes from specs (starting with link_command). Consult gcc for
4903 // more information.
4904 ArgStringList CmdArgs;
4906 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
4907 if (Args.hasArg(options::OPT_ccc_arcmt_check,
4908 options::OPT_ccc_arcmt_migrate)) {
4909 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
4912 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
4913 CmdArgs.push_back(Output.getFilename());
4914 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4918 // I'm not sure why this particular decomposition exists in gcc, but
4919 // we follow suite for ease of comparison.
4920 AddLinkArgs(C, Args, CmdArgs, Inputs);
4922 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
4923 Args.AddAllArgs(CmdArgs, options::OPT_s);
4924 Args.AddAllArgs(CmdArgs, options::OPT_t);
4925 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4926 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4927 Args.AddLastArg(CmdArgs, options::OPT_e);
4928 Args.AddAllArgs(CmdArgs, options::OPT_r);
4930 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
4931 // members of static archive libraries which implement Objective-C classes or
4933 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
4934 CmdArgs.push_back("-ObjC");
4936 CmdArgs.push_back("-o");
4937 CmdArgs.push_back(Output.getFilename());
4939 if (!Args.hasArg(options::OPT_nostdlib) &&
4940 !Args.hasArg(options::OPT_nostartfiles)) {
4941 // Derived from startfile spec.
4942 if (Args.hasArg(options::OPT_dynamiclib)) {
4943 // Derived from darwin_dylib1 spec.
4944 if (getDarwinToolChain().isTargetIOSSimulator()) {
4945 // The simulator doesn't have a versioned crt1 file.
4946 CmdArgs.push_back("-ldylib1.o");
4947 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
4948 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4949 CmdArgs.push_back("-ldylib1.o");
4951 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
4952 CmdArgs.push_back("-ldylib1.o");
4953 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4954 CmdArgs.push_back("-ldylib1.10.5.o");
4957 if (Args.hasArg(options::OPT_bundle)) {
4958 if (!Args.hasArg(options::OPT_static)) {
4959 // Derived from darwin_bundle1 spec.
4960 if (getDarwinToolChain().isTargetIOSSimulator()) {
4961 // The simulator doesn't have a versioned crt1 file.
4962 CmdArgs.push_back("-lbundle1.o");
4963 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
4964 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4965 CmdArgs.push_back("-lbundle1.o");
4967 if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4968 CmdArgs.push_back("-lbundle1.o");
4972 if (Args.hasArg(options::OPT_pg) &&
4973 getToolChain().SupportsProfiling()) {
4974 if (Args.hasArg(options::OPT_static) ||
4975 Args.hasArg(options::OPT_object) ||
4976 Args.hasArg(options::OPT_preload)) {
4977 CmdArgs.push_back("-lgcrt0.o");
4979 CmdArgs.push_back("-lgcrt1.o");
4981 // darwin_crt2 spec is empty.
4983 // By default on OS X 10.8 and later, we don't link with a crt1.o
4984 // file and the linker knows to use _main as the entry point. But,
4985 // when compiling with -pg, we need to link with the gcrt1.o file,
4986 // so pass the -no_new_main option to tell the linker to use the
4987 // "start" symbol as the entry point.
4988 if (getDarwinToolChain().isTargetMacOS() &&
4989 !getDarwinToolChain().isMacosxVersionLT(10, 8))
4990 CmdArgs.push_back("-no_new_main");
4992 if (Args.hasArg(options::OPT_static) ||
4993 Args.hasArg(options::OPT_object) ||
4994 Args.hasArg(options::OPT_preload)) {
4995 CmdArgs.push_back("-lcrt0.o");
4997 // Derived from darwin_crt1 spec.
4998 if (getDarwinToolChain().isTargetIOSSimulator()) {
4999 // The simulator doesn't have a versioned crt1 file.
5000 CmdArgs.push_back("-lcrt1.o");
5001 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
5002 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
5003 CmdArgs.push_back("-lcrt1.o");
5004 else if (getDarwinToolChain().isIPhoneOSVersionLT(6, 0))
5005 CmdArgs.push_back("-lcrt1.3.1.o");
5007 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
5008 CmdArgs.push_back("-lcrt1.o");
5009 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
5010 CmdArgs.push_back("-lcrt1.10.5.o");
5011 else if (getDarwinToolChain().isMacosxVersionLT(10, 8))
5012 CmdArgs.push_back("-lcrt1.10.6.o");
5014 // darwin_crt2 spec is empty.
5021 if (!getDarwinToolChain().isTargetIPhoneOS() &&
5022 Args.hasArg(options::OPT_shared_libgcc) &&
5023 getDarwinToolChain().isMacosxVersionLT(10, 5)) {
5025 Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
5026 CmdArgs.push_back(Str);
5030 Args.AddAllArgs(CmdArgs, options::OPT_L);
5032 if (Args.hasArg(options::OPT_fopenmp))
5033 // This is more complicated in gcc...
5034 CmdArgs.push_back("-lgomp");
5036 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5038 if (isObjCRuntimeLinked(Args) &&
5039 !Args.hasArg(options::OPT_nostdlib) &&
5040 !Args.hasArg(options::OPT_nodefaultlibs)) {
5041 // Avoid linking compatibility stubs on i386 mac.
5042 if (!getDarwinToolChain().isTargetMacOS() ||
5043 getDarwinToolChain().getArch() != llvm::Triple::x86) {
5044 // If we don't have ARC or subscripting runtime support, link in the
5045 // runtime stubs. We have to do this *before* adding any of the normal
5046 // linker inputs so that its initializer gets run first.
5047 ObjCRuntime runtime =
5048 getDarwinToolChain().getDefaultObjCRuntime(/*nonfragile*/ true);
5049 // We use arclite library for both ARC and subscripting support.
5050 if ((!runtime.hasNativeARC() && isObjCAutoRefCount(Args)) ||
5051 !runtime.hasSubscripting())
5052 getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs);
5054 CmdArgs.push_back("-framework");
5055 CmdArgs.push_back("Foundation");
5057 CmdArgs.push_back("-lobjc");
5060 if (LinkingOutput) {
5061 CmdArgs.push_back("-arch_multiple");
5062 CmdArgs.push_back("-final_output");
5063 CmdArgs.push_back(LinkingOutput);
5066 if (Args.hasArg(options::OPT_fnested_functions))
5067 CmdArgs.push_back("-allow_stack_execute");
5069 if (!Args.hasArg(options::OPT_nostdlib) &&
5070 !Args.hasArg(options::OPT_nodefaultlibs)) {
5071 if (getToolChain().getDriver().CCCIsCXX())
5072 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5074 // link_ssp spec is empty.
5076 // Let the tool chain choose which runtime library to link.
5077 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
5080 if (!Args.hasArg(options::OPT_nostdlib) &&
5081 !Args.hasArg(options::OPT_nostartfiles)) {
5082 // endfile_spec is empty.
5085 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5086 Args.AddAllArgs(CmdArgs, options::OPT_F);
5089 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5090 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5093 void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
5094 const InputInfo &Output,
5095 const InputInfoList &Inputs,
5096 const ArgList &Args,
5097 const char *LinkingOutput) const {
5098 ArgStringList CmdArgs;
5100 CmdArgs.push_back("-create");
5101 assert(Output.isFilename() && "Unexpected lipo output.");
5103 CmdArgs.push_back("-output");
5104 CmdArgs.push_back(Output.getFilename());
5106 for (InputInfoList::const_iterator
5107 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5108 const InputInfo &II = *it;
5109 assert(II.isFilename() && "Unexpected lipo input.");
5110 CmdArgs.push_back(II.getFilename());
5113 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
5114 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5117 void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
5118 const InputInfo &Output,
5119 const InputInfoList &Inputs,
5120 const ArgList &Args,
5121 const char *LinkingOutput) const {
5122 ArgStringList CmdArgs;
5124 CmdArgs.push_back("-o");
5125 CmdArgs.push_back(Output.getFilename());
5127 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5128 const InputInfo &Input = Inputs[0];
5129 assert(Input.isFilename() && "Unexpected dsymutil input.");
5130 CmdArgs.push_back(Input.getFilename());
5133 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
5134 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5137 void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
5138 const InputInfo &Output,
5139 const InputInfoList &Inputs,
5140 const ArgList &Args,
5141 const char *LinkingOutput) const {
5142 ArgStringList CmdArgs;
5143 CmdArgs.push_back("--verify");
5144 CmdArgs.push_back("--debug-info");
5145 CmdArgs.push_back("--eh-frame");
5146 CmdArgs.push_back("--quiet");
5148 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5149 const InputInfo &Input = Inputs[0];
5150 assert(Input.isFilename() && "Unexpected verify input");
5152 // Grabbing the output of the earlier dsymutil run.
5153 CmdArgs.push_back(Input.getFilename());
5156 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5157 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5160 void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5161 const InputInfo &Output,
5162 const InputInfoList &Inputs,
5163 const ArgList &Args,
5164 const char *LinkingOutput) const {
5165 ArgStringList CmdArgs;
5167 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5168 options::OPT_Xassembler);
5170 CmdArgs.push_back("-o");
5171 CmdArgs.push_back(Output.getFilename());
5173 for (InputInfoList::const_iterator
5174 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5175 const InputInfo &II = *it;
5176 CmdArgs.push_back(II.getFilename());
5180 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5181 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5185 void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5186 const InputInfo &Output,
5187 const InputInfoList &Inputs,
5188 const ArgList &Args,
5189 const char *LinkingOutput) const {
5190 // FIXME: Find a real GCC, don't hard-code versions here
5191 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5192 const llvm::Triple &T = getToolChain().getTriple();
5193 std::string LibPath = "/usr/lib/";
5194 llvm::Triple::ArchType Arch = T.getArch();
5196 case llvm::Triple::x86:
5198 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
5200 case llvm::Triple::x86_64:
5201 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
5202 GCCLibPath += "/4.5.2/amd64/";
5203 LibPath += "amd64/";
5206 llvm_unreachable("Unsupported architecture");
5209 ArgStringList CmdArgs;
5211 // Demangle C++ names in errors
5212 CmdArgs.push_back("-C");
5214 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5215 (!Args.hasArg(options::OPT_shared))) {
5216 CmdArgs.push_back("-e");
5217 CmdArgs.push_back("_start");
5220 if (Args.hasArg(options::OPT_static)) {
5221 CmdArgs.push_back("-Bstatic");
5222 CmdArgs.push_back("-dn");
5224 CmdArgs.push_back("-Bdynamic");
5225 if (Args.hasArg(options::OPT_shared)) {
5226 CmdArgs.push_back("-shared");
5228 CmdArgs.push_back("--dynamic-linker");
5229 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5233 if (Output.isFilename()) {
5234 CmdArgs.push_back("-o");
5235 CmdArgs.push_back(Output.getFilename());
5237 assert(Output.isNothing() && "Invalid output.");
5240 if (!Args.hasArg(options::OPT_nostdlib) &&
5241 !Args.hasArg(options::OPT_nostartfiles)) {
5242 if (!Args.hasArg(options::OPT_shared)) {
5243 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5244 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
5245 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5246 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5248 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
5249 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5250 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5252 if (getToolChain().getDriver().CCCIsCXX())
5253 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
5256 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5258 Args.AddAllArgs(CmdArgs, options::OPT_L);
5259 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5260 Args.AddAllArgs(CmdArgs, options::OPT_e);
5261 Args.AddAllArgs(CmdArgs, options::OPT_r);
5263 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5265 if (!Args.hasArg(options::OPT_nostdlib) &&
5266 !Args.hasArg(options::OPT_nodefaultlibs)) {
5267 if (getToolChain().getDriver().CCCIsCXX())
5268 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5269 CmdArgs.push_back("-lgcc_s");
5270 if (!Args.hasArg(options::OPT_shared)) {
5271 CmdArgs.push_back("-lgcc");
5272 CmdArgs.push_back("-lc");
5273 CmdArgs.push_back("-lm");
5277 if (!Args.hasArg(options::OPT_nostdlib) &&
5278 !Args.hasArg(options::OPT_nostartfiles)) {
5279 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
5281 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
5283 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5286 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5287 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5290 void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5291 const InputInfo &Output,
5292 const InputInfoList &Inputs,
5293 const ArgList &Args,
5294 const char *LinkingOutput) const {
5295 ArgStringList CmdArgs;
5297 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5298 options::OPT_Xassembler);
5300 CmdArgs.push_back("-o");
5301 CmdArgs.push_back(Output.getFilename());
5303 for (InputInfoList::const_iterator
5304 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5305 const InputInfo &II = *it;
5306 CmdArgs.push_back(II.getFilename());
5310 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
5311 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5314 void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
5315 const InputInfo &Output,
5316 const InputInfoList &Inputs,
5317 const ArgList &Args,
5318 const char *LinkingOutput) const {
5319 ArgStringList CmdArgs;
5321 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5322 (!Args.hasArg(options::OPT_shared))) {
5323 CmdArgs.push_back("-e");
5324 CmdArgs.push_back("_start");
5327 if (Args.hasArg(options::OPT_static)) {
5328 CmdArgs.push_back("-Bstatic");
5329 CmdArgs.push_back("-dn");
5331 // CmdArgs.push_back("--eh-frame-hdr");
5332 CmdArgs.push_back("-Bdynamic");
5333 if (Args.hasArg(options::OPT_shared)) {
5334 CmdArgs.push_back("-shared");
5336 CmdArgs.push_back("--dynamic-linker");
5337 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5341 if (Output.isFilename()) {
5342 CmdArgs.push_back("-o");
5343 CmdArgs.push_back(Output.getFilename());
5345 assert(Output.isNothing() && "Invalid output.");
5348 if (!Args.hasArg(options::OPT_nostdlib) &&
5349 !Args.hasArg(options::OPT_nostartfiles)) {
5350 if (!Args.hasArg(options::OPT_shared)) {
5351 CmdArgs.push_back(Args.MakeArgString(
5352 getToolChain().GetFilePath("crt1.o")));
5353 CmdArgs.push_back(Args.MakeArgString(
5354 getToolChain().GetFilePath("crti.o")));
5355 CmdArgs.push_back(Args.MakeArgString(
5356 getToolChain().GetFilePath("crtbegin.o")));
5358 CmdArgs.push_back(Args.MakeArgString(
5359 getToolChain().GetFilePath("crti.o")));
5361 CmdArgs.push_back(Args.MakeArgString(
5362 getToolChain().GetFilePath("crtn.o")));
5365 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5366 + getToolChain().getTripleString()
5369 Args.AddAllArgs(CmdArgs, options::OPT_L);
5370 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5371 Args.AddAllArgs(CmdArgs, options::OPT_e);
5373 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5375 if (!Args.hasArg(options::OPT_nostdlib) &&
5376 !Args.hasArg(options::OPT_nodefaultlibs)) {
5377 // FIXME: For some reason GCC passes -lgcc before adding
5378 // the default system libraries. Just mimic this for now.
5379 CmdArgs.push_back("-lgcc");
5381 if (Args.hasArg(options::OPT_pthread))
5382 CmdArgs.push_back("-pthread");
5383 if (!Args.hasArg(options::OPT_shared))
5384 CmdArgs.push_back("-lc");
5385 CmdArgs.push_back("-lgcc");
5388 if (!Args.hasArg(options::OPT_nostdlib) &&
5389 !Args.hasArg(options::OPT_nostartfiles)) {
5390 if (!Args.hasArg(options::OPT_shared))
5391 CmdArgs.push_back(Args.MakeArgString(
5392 getToolChain().GetFilePath("crtend.o")));
5395 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5398 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5399 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5402 void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5403 const InputInfo &Output,
5404 const InputInfoList &Inputs,
5405 const ArgList &Args,
5406 const char *LinkingOutput) const {
5407 ArgStringList CmdArgs;
5409 // When building 32-bit code on OpenBSD/amd64, we have to explicitly
5410 // instruct as in the base system to assemble 32-bit code.
5411 if (getToolChain().getArch() == llvm::Triple::x86)
5412 CmdArgs.push_back("--32");
5413 else if (getToolChain().getArch() == llvm::Triple::ppc) {
5414 CmdArgs.push_back("-mppc");
5415 CmdArgs.push_back("-many");
5416 } else if (getToolChain().getArch() == llvm::Triple::mips64 ||
5417 getToolChain().getArch() == llvm::Triple::mips64el) {
5420 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5422 CmdArgs.push_back("-mabi");
5423 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5425 if (getToolChain().getArch() == llvm::Triple::mips64)
5426 CmdArgs.push_back("-EB");
5428 CmdArgs.push_back("-EL");
5430 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5431 options::OPT_fpic, options::OPT_fno_pic,
5432 options::OPT_fPIE, options::OPT_fno_PIE,
5433 options::OPT_fpie, options::OPT_fno_pie);
5435 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5436 LastPICArg->getOption().matches(options::OPT_fpic) ||
5437 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5438 LastPICArg->getOption().matches(options::OPT_fpie))) {
5439 CmdArgs.push_back("-KPIC");
5443 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5444 options::OPT_Xassembler);
5446 CmdArgs.push_back("-o");
5447 CmdArgs.push_back(Output.getFilename());
5449 for (InputInfoList::const_iterator
5450 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5451 const InputInfo &II = *it;
5452 CmdArgs.push_back(II.getFilename());
5456 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5457 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5460 void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5461 const InputInfo &Output,
5462 const InputInfoList &Inputs,
5463 const ArgList &Args,
5464 const char *LinkingOutput) const {
5465 const Driver &D = getToolChain().getDriver();
5466 ArgStringList CmdArgs;
5468 // Silence warning for "clang -g foo.o -o foo"
5469 Args.ClaimAllArgs(options::OPT_g_Group);
5470 // and "clang -emit-llvm foo.o -o foo"
5471 Args.ClaimAllArgs(options::OPT_emit_llvm);
5472 // and for "clang -w foo.o -o foo". Other warning options are already
5473 // handled somewhere else.
5474 Args.ClaimAllArgs(options::OPT_w);
5476 if (getToolChain().getArch() == llvm::Triple::mips64)
5477 CmdArgs.push_back("-EB");
5478 else if (getToolChain().getArch() == llvm::Triple::mips64el)
5479 CmdArgs.push_back("-EL");
5481 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5482 (!Args.hasArg(options::OPT_shared))) {
5483 CmdArgs.push_back("-e");
5484 CmdArgs.push_back("__start");
5487 if (Args.hasArg(options::OPT_static)) {
5488 CmdArgs.push_back("-Bstatic");
5490 if (Args.hasArg(options::OPT_rdynamic))
5491 CmdArgs.push_back("-export-dynamic");
5492 CmdArgs.push_back("--eh-frame-hdr");
5493 CmdArgs.push_back("-Bdynamic");
5494 if (Args.hasArg(options::OPT_shared)) {
5495 CmdArgs.push_back("-shared");
5497 CmdArgs.push_back("-dynamic-linker");
5498 CmdArgs.push_back("/usr/libexec/ld.so");
5502 if (Args.hasArg(options::OPT_nopie))
5503 CmdArgs.push_back("-nopie");
5505 if (Output.isFilename()) {
5506 CmdArgs.push_back("-o");
5507 CmdArgs.push_back(Output.getFilename());
5509 assert(Output.isNothing() && "Invalid output.");
5512 if (!Args.hasArg(options::OPT_nostdlib) &&
5513 !Args.hasArg(options::OPT_nostartfiles)) {
5514 if (!Args.hasArg(options::OPT_shared)) {
5515 if (Args.hasArg(options::OPT_pg))
5516 CmdArgs.push_back(Args.MakeArgString(
5517 getToolChain().GetFilePath("gcrt0.o")));
5519 CmdArgs.push_back(Args.MakeArgString(
5520 getToolChain().GetFilePath("crt0.o")));
5521 CmdArgs.push_back(Args.MakeArgString(
5522 getToolChain().GetFilePath("crtbegin.o")));
5524 CmdArgs.push_back(Args.MakeArgString(
5525 getToolChain().GetFilePath("crtbeginS.o")));
5529 std::string Triple = getToolChain().getTripleString();
5530 if (Triple.substr(0, 6) == "x86_64")
5531 Triple.replace(0, 6, "amd64");
5532 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
5535 Args.AddAllArgs(CmdArgs, options::OPT_L);
5536 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5537 Args.AddAllArgs(CmdArgs, options::OPT_e);
5538 Args.AddAllArgs(CmdArgs, options::OPT_s);
5539 Args.AddAllArgs(CmdArgs, options::OPT_t);
5540 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5541 Args.AddAllArgs(CmdArgs, options::OPT_r);
5543 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5545 if (!Args.hasArg(options::OPT_nostdlib) &&
5546 !Args.hasArg(options::OPT_nodefaultlibs)) {
5548 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5549 if (Args.hasArg(options::OPT_pg))
5550 CmdArgs.push_back("-lm_p");
5552 CmdArgs.push_back("-lm");
5555 // FIXME: For some reason GCC passes -lgcc before adding
5556 // the default system libraries. Just mimic this for now.
5557 CmdArgs.push_back("-lgcc");
5559 if (Args.hasArg(options::OPT_pthread)) {
5560 if (!Args.hasArg(options::OPT_shared) &&
5561 Args.hasArg(options::OPT_pg))
5562 CmdArgs.push_back("-lpthread_p");
5564 CmdArgs.push_back("-lpthread");
5567 if (!Args.hasArg(options::OPT_shared)) {
5568 if (Args.hasArg(options::OPT_pg))
5569 CmdArgs.push_back("-lc_p");
5571 CmdArgs.push_back("-lc");
5574 CmdArgs.push_back("-lgcc");
5577 if (!Args.hasArg(options::OPT_nostdlib) &&
5578 !Args.hasArg(options::OPT_nostartfiles)) {
5579 if (!Args.hasArg(options::OPT_shared))
5580 CmdArgs.push_back(Args.MakeArgString(
5581 getToolChain().GetFilePath("crtend.o")));
5583 CmdArgs.push_back(Args.MakeArgString(
5584 getToolChain().GetFilePath("crtendS.o")));
5588 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5589 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5592 void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5593 const InputInfo &Output,
5594 const InputInfoList &Inputs,
5595 const ArgList &Args,
5596 const char *LinkingOutput) const {
5597 ArgStringList CmdArgs;
5599 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5600 options::OPT_Xassembler);
5602 CmdArgs.push_back("-o");
5603 CmdArgs.push_back(Output.getFilename());
5605 for (InputInfoList::const_iterator
5606 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5607 const InputInfo &II = *it;
5608 CmdArgs.push_back(II.getFilename());
5612 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5613 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5616 void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
5617 const InputInfo &Output,
5618 const InputInfoList &Inputs,
5619 const ArgList &Args,
5620 const char *LinkingOutput) const {
5621 const Driver &D = getToolChain().getDriver();
5622 ArgStringList CmdArgs;
5624 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5625 (!Args.hasArg(options::OPT_shared))) {
5626 CmdArgs.push_back("-e");
5627 CmdArgs.push_back("__start");
5630 if (Args.hasArg(options::OPT_static)) {
5631 CmdArgs.push_back("-Bstatic");
5633 if (Args.hasArg(options::OPT_rdynamic))
5634 CmdArgs.push_back("-export-dynamic");
5635 CmdArgs.push_back("--eh-frame-hdr");
5636 CmdArgs.push_back("-Bdynamic");
5637 if (Args.hasArg(options::OPT_shared)) {
5638 CmdArgs.push_back("-shared");
5640 CmdArgs.push_back("-dynamic-linker");
5641 CmdArgs.push_back("/usr/libexec/ld.so");
5645 if (Output.isFilename()) {
5646 CmdArgs.push_back("-o");
5647 CmdArgs.push_back(Output.getFilename());
5649 assert(Output.isNothing() && "Invalid output.");
5652 if (!Args.hasArg(options::OPT_nostdlib) &&
5653 !Args.hasArg(options::OPT_nostartfiles)) {
5654 if (!Args.hasArg(options::OPT_shared)) {
5655 if (Args.hasArg(options::OPT_pg))
5656 CmdArgs.push_back(Args.MakeArgString(
5657 getToolChain().GetFilePath("gcrt0.o")));
5659 CmdArgs.push_back(Args.MakeArgString(
5660 getToolChain().GetFilePath("crt0.o")));
5661 CmdArgs.push_back(Args.MakeArgString(
5662 getToolChain().GetFilePath("crtbegin.o")));
5664 CmdArgs.push_back(Args.MakeArgString(
5665 getToolChain().GetFilePath("crtbeginS.o")));
5669 Args.AddAllArgs(CmdArgs, options::OPT_L);
5670 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5671 Args.AddAllArgs(CmdArgs, options::OPT_e);
5673 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5675 if (!Args.hasArg(options::OPT_nostdlib) &&
5676 !Args.hasArg(options::OPT_nodefaultlibs)) {
5678 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5679 if (Args.hasArg(options::OPT_pg))
5680 CmdArgs.push_back("-lm_p");
5682 CmdArgs.push_back("-lm");
5685 if (Args.hasArg(options::OPT_pthread)) {
5686 if (!Args.hasArg(options::OPT_shared) &&
5687 Args.hasArg(options::OPT_pg))
5688 CmdArgs.push_back("-lpthread_p");
5690 CmdArgs.push_back("-lpthread");
5693 if (!Args.hasArg(options::OPT_shared)) {
5694 if (Args.hasArg(options::OPT_pg))
5695 CmdArgs.push_back("-lc_p");
5697 CmdArgs.push_back("-lc");
5701 switch (getToolChain().getTriple().getArch()) {
5702 case llvm::Triple::arm:
5705 case llvm::Triple::x86:
5708 case llvm::Triple::x86_64:
5712 llvm_unreachable("Unsupported architecture");
5714 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
5717 if (!Args.hasArg(options::OPT_nostdlib) &&
5718 !Args.hasArg(options::OPT_nostartfiles)) {
5719 if (!Args.hasArg(options::OPT_shared))
5720 CmdArgs.push_back(Args.MakeArgString(
5721 getToolChain().GetFilePath("crtend.o")));
5723 CmdArgs.push_back(Args.MakeArgString(
5724 getToolChain().GetFilePath("crtendS.o")));
5728 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5729 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5732 void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5733 const InputInfo &Output,
5734 const InputInfoList &Inputs,
5735 const ArgList &Args,
5736 const char *LinkingOutput) const {
5737 ArgStringList CmdArgs;
5739 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5740 // instruct as in the base system to assemble 32-bit code.
5741 if (getToolChain().getArch() == llvm::Triple::x86)
5742 CmdArgs.push_back("--32");
5743 else if (getToolChain().getArch() == llvm::Triple::ppc)
5744 CmdArgs.push_back("-a32");
5745 else if (getToolChain().getArch() == llvm::Triple::mips ||
5746 getToolChain().getArch() == llvm::Triple::mipsel ||
5747 getToolChain().getArch() == llvm::Triple::mips64 ||
5748 getToolChain().getArch() == llvm::Triple::mips64el) {
5751 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5753 CmdArgs.push_back("-march");
5754 CmdArgs.push_back(CPUName.data());
5756 CmdArgs.push_back("-mabi");
5757 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5759 if (getToolChain().getArch() == llvm::Triple::mips ||
5760 getToolChain().getArch() == llvm::Triple::mips64)
5761 CmdArgs.push_back("-EB");
5763 CmdArgs.push_back("-EL");
5765 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5766 options::OPT_fpic, options::OPT_fno_pic,
5767 options::OPT_fPIE, options::OPT_fno_PIE,
5768 options::OPT_fpie, options::OPT_fno_pie);
5770 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5771 LastPICArg->getOption().matches(options::OPT_fpic) ||
5772 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5773 LastPICArg->getOption().matches(options::OPT_fpie))) {
5774 CmdArgs.push_back("-KPIC");
5776 } else if (getToolChain().getArch() == llvm::Triple::arm ||
5777 getToolChain().getArch() == llvm::Triple::thumb) {
5778 CmdArgs.push_back("-mfpu=softvfp");
5779 switch(getToolChain().getTriple().getEnvironment()) {
5780 case llvm::Triple::GNUEABI:
5781 case llvm::Triple::EABI:
5782 CmdArgs.push_back("-meabi=5");
5786 CmdArgs.push_back("-matpcs");
5788 } else if (getToolChain().getArch() == llvm::Triple::sparc ||
5789 getToolChain().getArch() == llvm::Triple::sparcv9) {
5790 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5791 options::OPT_fpic, options::OPT_fno_pic,
5792 options::OPT_fPIE, options::OPT_fno_PIE,
5793 options::OPT_fpie, options::OPT_fno_pie);
5795 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5796 LastPICArg->getOption().matches(options::OPT_fpic) ||
5797 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5798 LastPICArg->getOption().matches(options::OPT_fpie))) {
5799 CmdArgs.push_back("-KPIC");
5803 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5804 options::OPT_Xassembler);
5806 CmdArgs.push_back("-o");
5807 CmdArgs.push_back(Output.getFilename());
5809 for (InputInfoList::const_iterator
5810 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5811 const InputInfo &II = *it;
5812 CmdArgs.push_back(II.getFilename());
5816 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5817 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5820 void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5821 const InputInfo &Output,
5822 const InputInfoList &Inputs,
5823 const ArgList &Args,
5824 const char *LinkingOutput) const {
5825 const toolchains::FreeBSD& ToolChain =
5826 static_cast<const toolchains::FreeBSD&>(getToolChain());
5827 const Driver &D = ToolChain.getDriver();
5828 ArgStringList CmdArgs;
5830 // Silence warning for "clang -g foo.o -o foo"
5831 Args.ClaimAllArgs(options::OPT_g_Group);
5832 // and "clang -emit-llvm foo.o -o foo"
5833 Args.ClaimAllArgs(options::OPT_emit_llvm);
5834 // and for "clang -w foo.o -o foo". Other warning options are already
5835 // handled somewhere else.
5836 Args.ClaimAllArgs(options::OPT_w);
5838 if (!D.SysRoot.empty())
5839 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5841 if (Args.hasArg(options::OPT_pie))
5842 CmdArgs.push_back("-pie");
5844 if (Args.hasArg(options::OPT_static)) {
5845 CmdArgs.push_back("-Bstatic");
5847 if (Args.hasArg(options::OPT_rdynamic))
5848 CmdArgs.push_back("-export-dynamic");
5849 CmdArgs.push_back("--eh-frame-hdr");
5850 if (Args.hasArg(options::OPT_shared)) {
5851 CmdArgs.push_back("-Bshareable");
5853 CmdArgs.push_back("-dynamic-linker");
5854 CmdArgs.push_back("/libexec/ld-elf.so.1");
5856 if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
5857 llvm::Triple::ArchType Arch = ToolChain.getArch();
5858 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
5859 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5860 CmdArgs.push_back("--hash-style=both");
5863 CmdArgs.push_back("--enable-new-dtags");
5866 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5867 // instruct ld in the base system to link 32-bit code.
5868 if (ToolChain.getArch() == llvm::Triple::x86) {
5869 CmdArgs.push_back("-m");
5870 CmdArgs.push_back("elf_i386_fbsd");
5873 if (ToolChain.getArch() == llvm::Triple::ppc) {
5874 CmdArgs.push_back("-m");
5875 CmdArgs.push_back("elf32ppc_fbsd");
5878 if (Output.isFilename()) {
5879 CmdArgs.push_back("-o");
5880 CmdArgs.push_back(Output.getFilename());
5882 assert(Output.isNothing() && "Invalid output.");
5885 if (!Args.hasArg(options::OPT_nostdlib) &&
5886 !Args.hasArg(options::OPT_nostartfiles)) {
5887 const char *crt1 = NULL;
5888 if (!Args.hasArg(options::OPT_shared)) {
5889 if (Args.hasArg(options::OPT_pg))
5891 else if (Args.hasArg(options::OPT_pie))
5897 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
5899 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
5901 const char *crtbegin = NULL;
5902 if (Args.hasArg(options::OPT_static))
5903 crtbegin = "crtbeginT.o";
5904 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
5905 crtbegin = "crtbeginS.o";
5907 crtbegin = "crtbegin.o";
5909 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
5912 Args.AddAllArgs(CmdArgs, options::OPT_L);
5913 const ToolChain::path_list Paths = ToolChain.getFilePaths();
5914 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
5916 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
5917 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5918 Args.AddAllArgs(CmdArgs, options::OPT_e);
5919 Args.AddAllArgs(CmdArgs, options::OPT_s);
5920 Args.AddAllArgs(CmdArgs, options::OPT_t);
5921 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5922 Args.AddAllArgs(CmdArgs, options::OPT_r);
5924 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
5925 // as gold requires -plugin to come before any -plugin-opt that -Wl might
5927 if (D.IsUsingLTO(Args)) {
5928 CmdArgs.push_back("-plugin");
5929 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
5930 CmdArgs.push_back(Args.MakeArgString(Plugin));
5932 // Try to pass driver level flags relevant to LTO code generation down to
5935 // Handle flags for selecting CPU variants.
5936 std::string CPU = getCPUName(Args, ToolChain.getTriple());
5939 Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
5944 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5946 if (!Args.hasArg(options::OPT_nostdlib) &&
5947 !Args.hasArg(options::OPT_nodefaultlibs)) {
5949 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5950 if (Args.hasArg(options::OPT_pg))
5951 CmdArgs.push_back("-lm_p");
5953 CmdArgs.push_back("-lm");
5955 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5956 // the default system libraries. Just mimic this for now.
5957 if (Args.hasArg(options::OPT_pg))
5958 CmdArgs.push_back("-lgcc_p");
5960 CmdArgs.push_back("-lgcc");
5961 if (Args.hasArg(options::OPT_static)) {
5962 CmdArgs.push_back("-lgcc_eh");
5963 } else if (Args.hasArg(options::OPT_pg)) {
5964 CmdArgs.push_back("-lgcc_eh_p");
5966 CmdArgs.push_back("--as-needed");
5967 CmdArgs.push_back("-lgcc_s");
5968 CmdArgs.push_back("--no-as-needed");
5971 if (Args.hasArg(options::OPT_pthread)) {
5972 if (Args.hasArg(options::OPT_pg))
5973 CmdArgs.push_back("-lpthread_p");
5975 CmdArgs.push_back("-lpthread");
5978 if (Args.hasArg(options::OPT_pg)) {
5979 if (Args.hasArg(options::OPT_shared))
5980 CmdArgs.push_back("-lc");
5982 CmdArgs.push_back("-lc_p");
5983 CmdArgs.push_back("-lgcc_p");
5985 CmdArgs.push_back("-lc");
5986 CmdArgs.push_back("-lgcc");
5989 if (Args.hasArg(options::OPT_static)) {
5990 CmdArgs.push_back("-lgcc_eh");
5991 } else if (Args.hasArg(options::OPT_pg)) {
5992 CmdArgs.push_back("-lgcc_eh_p");
5994 CmdArgs.push_back("--as-needed");
5995 CmdArgs.push_back("-lgcc_s");
5996 CmdArgs.push_back("--no-as-needed");
6000 if (!Args.hasArg(options::OPT_nostdlib) &&
6001 !Args.hasArg(options::OPT_nostartfiles)) {
6002 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
6003 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
6005 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
6006 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
6009 addProfileRT(ToolChain, Args, CmdArgs, ToolChain.getTriple());
6012 Args.MakeArgString(ToolChain.GetProgramPath("ld"));
6013 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6016 void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6017 const InputInfo &Output,
6018 const InputInfoList &Inputs,
6019 const ArgList &Args,
6020 const char *LinkingOutput) const {
6021 ArgStringList CmdArgs;
6023 // When building 32-bit code on NetBSD/amd64, we have to explicitly
6024 // instruct as in the base system to assemble 32-bit code.
6025 if (getToolChain().getArch() == llvm::Triple::x86)
6026 CmdArgs.push_back("--32");
6028 // Pass the target CPU to GNU as for ARM, since the source code might
6029 // not have the correct .cpu annotation.
6030 if (getToolChain().getArch() == llvm::Triple::arm) {
6031 std::string MArch(getARMTargetCPU(Args, getToolChain().getTriple()));
6032 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
6035 if (getToolChain().getArch() == llvm::Triple::mips ||
6036 getToolChain().getArch() == llvm::Triple::mipsel ||
6037 getToolChain().getArch() == llvm::Triple::mips64 ||
6038 getToolChain().getArch() == llvm::Triple::mips64el) {
6041 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6043 CmdArgs.push_back("-march");
6044 CmdArgs.push_back(CPUName.data());
6046 CmdArgs.push_back("-mabi");
6047 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6049 if (getToolChain().getArch() == llvm::Triple::mips ||
6050 getToolChain().getArch() == llvm::Triple::mips64)
6051 CmdArgs.push_back("-EB");
6053 CmdArgs.push_back("-EL");
6055 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
6056 options::OPT_fpic, options::OPT_fno_pic,
6057 options::OPT_fPIE, options::OPT_fno_PIE,
6058 options::OPT_fpie, options::OPT_fno_pie);
6060 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
6061 LastPICArg->getOption().matches(options::OPT_fpic) ||
6062 LastPICArg->getOption().matches(options::OPT_fPIE) ||
6063 LastPICArg->getOption().matches(options::OPT_fpie))) {
6064 CmdArgs.push_back("-KPIC");
6068 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6069 options::OPT_Xassembler);
6071 CmdArgs.push_back("-o");
6072 CmdArgs.push_back(Output.getFilename());
6074 for (InputInfoList::const_iterator
6075 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6076 const InputInfo &II = *it;
6077 CmdArgs.push_back(II.getFilename());
6080 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
6081 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6084 void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6085 const InputInfo &Output,
6086 const InputInfoList &Inputs,
6087 const ArgList &Args,
6088 const char *LinkingOutput) const {
6089 const Driver &D = getToolChain().getDriver();
6090 ArgStringList CmdArgs;
6092 if (!D.SysRoot.empty())
6093 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6095 if (Args.hasArg(options::OPT_static)) {
6096 CmdArgs.push_back("-Bstatic");
6098 if (Args.hasArg(options::OPT_rdynamic))
6099 CmdArgs.push_back("-export-dynamic");
6100 CmdArgs.push_back("--eh-frame-hdr");
6101 if (Args.hasArg(options::OPT_shared)) {
6102 CmdArgs.push_back("-Bshareable");
6104 CmdArgs.push_back("-dynamic-linker");
6105 CmdArgs.push_back("/libexec/ld.elf_so");
6109 // When building 32-bit code on NetBSD/amd64, we have to explicitly
6110 // instruct ld in the base system to link 32-bit code.
6111 if (getToolChain().getArch() == llvm::Triple::x86) {
6112 CmdArgs.push_back("-m");
6113 CmdArgs.push_back("elf_i386");
6116 if (Output.isFilename()) {
6117 CmdArgs.push_back("-o");
6118 CmdArgs.push_back(Output.getFilename());
6120 assert(Output.isNothing() && "Invalid output.");
6123 if (!Args.hasArg(options::OPT_nostdlib) &&
6124 !Args.hasArg(options::OPT_nostartfiles)) {
6125 if (!Args.hasArg(options::OPT_shared)) {
6126 CmdArgs.push_back(Args.MakeArgString(
6127 getToolChain().GetFilePath("crt0.o")));
6128 CmdArgs.push_back(Args.MakeArgString(
6129 getToolChain().GetFilePath("crti.o")));
6130 CmdArgs.push_back(Args.MakeArgString(
6131 getToolChain().GetFilePath("crtbegin.o")));
6133 CmdArgs.push_back(Args.MakeArgString(
6134 getToolChain().GetFilePath("crti.o")));
6135 CmdArgs.push_back(Args.MakeArgString(
6136 getToolChain().GetFilePath("crtbeginS.o")));
6140 Args.AddAllArgs(CmdArgs, options::OPT_L);
6141 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6142 Args.AddAllArgs(CmdArgs, options::OPT_e);
6143 Args.AddAllArgs(CmdArgs, options::OPT_s);
6144 Args.AddAllArgs(CmdArgs, options::OPT_t);
6145 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6146 Args.AddAllArgs(CmdArgs, options::OPT_r);
6148 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6150 unsigned Major, Minor, Micro;
6151 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6152 bool useLibgcc = true;
6153 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 23) || Major == 0) {
6154 if (getToolChain().getArch() == llvm::Triple::x86 ||
6155 getToolChain().getArch() == llvm::Triple::x86_64)
6159 if (!Args.hasArg(options::OPT_nostdlib) &&
6160 !Args.hasArg(options::OPT_nodefaultlibs)) {
6162 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6163 CmdArgs.push_back("-lm");
6165 if (Args.hasArg(options::OPT_pthread))
6166 CmdArgs.push_back("-lpthread");
6167 CmdArgs.push_back("-lc");
6170 if (Args.hasArg(options::OPT_static)) {
6171 // libgcc_eh depends on libc, so resolve as much as possible,
6172 // pull in any new requirements from libc and then get the rest
6174 CmdArgs.push_back("-lgcc_eh");
6175 CmdArgs.push_back("-lc");
6176 CmdArgs.push_back("-lgcc");
6178 CmdArgs.push_back("-lgcc");
6179 CmdArgs.push_back("--as-needed");
6180 CmdArgs.push_back("-lgcc_s");
6181 CmdArgs.push_back("--no-as-needed");
6186 if (!Args.hasArg(options::OPT_nostdlib) &&
6187 !Args.hasArg(options::OPT_nostartfiles)) {
6188 if (!Args.hasArg(options::OPT_shared))
6189 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6192 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6194 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6198 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6200 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
6201 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6204 void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6205 const InputInfo &Output,
6206 const InputInfoList &Inputs,
6207 const ArgList &Args,
6208 const char *LinkingOutput) const {
6209 ArgStringList CmdArgs;
6210 bool NeedsKPIC = false;
6212 // Add --32/--64 to make sure we get the format we want.
6213 // This is incomplete
6214 if (getToolChain().getArch() == llvm::Triple::x86) {
6215 CmdArgs.push_back("--32");
6216 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
6217 CmdArgs.push_back("--64");
6218 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6219 CmdArgs.push_back("-a32");
6220 CmdArgs.push_back("-mppc");
6221 CmdArgs.push_back("-many");
6222 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6223 CmdArgs.push_back("-a64");
6224 CmdArgs.push_back("-mppc64");
6225 CmdArgs.push_back("-many");
6226 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
6227 CmdArgs.push_back("-a64");
6228 CmdArgs.push_back("-mppc64le");
6229 CmdArgs.push_back("-many");
6230 } else if (getToolChain().getArch() == llvm::Triple::sparc) {
6231 CmdArgs.push_back("-32");
6232 CmdArgs.push_back("-Av8plusa");
6234 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
6235 CmdArgs.push_back("-64");
6236 CmdArgs.push_back("-Av9a");
6238 } else if (getToolChain().getArch() == llvm::Triple::arm) {
6239 StringRef MArch = getToolChain().getArchName();
6240 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
6241 CmdArgs.push_back("-mfpu=neon");
6242 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a")
6243 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
6245 StringRef ARMFloatABI = getARMFloatABI(getToolChain().getDriver(), Args,
6246 getToolChain().getTriple());
6247 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
6249 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
6250 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
6251 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
6252 } else if (getToolChain().getArch() == llvm::Triple::mips ||
6253 getToolChain().getArch() == llvm::Triple::mipsel ||
6254 getToolChain().getArch() == llvm::Triple::mips64 ||
6255 getToolChain().getArch() == llvm::Triple::mips64el) {
6258 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6260 CmdArgs.push_back("-march");
6261 CmdArgs.push_back(CPUName.data());
6263 CmdArgs.push_back("-mabi");
6264 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6266 if (getToolChain().getArch() == llvm::Triple::mips ||
6267 getToolChain().getArch() == llvm::Triple::mips64)
6268 CmdArgs.push_back("-EB");
6270 CmdArgs.push_back("-EL");
6272 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
6273 if (StringRef(A->getValue()) == "2008")
6274 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
6277 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfp64)) {
6278 if (A->getOption().matches(options::OPT_mfp32))
6279 CmdArgs.push_back(Args.MakeArgString("-mfp32"));
6281 CmdArgs.push_back(Args.MakeArgString("-mfp64"));
6284 Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16);
6285 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
6286 options::OPT_mno_micromips);
6287 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
6288 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
6290 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
6291 // Do not use AddLastArg because not all versions of MIPS assembler
6292 // support -mmsa / -mno-msa options.
6293 if (A->getOption().matches(options::OPT_mmsa))
6294 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
6298 } else if (getToolChain().getArch() == llvm::Triple::systemz) {
6299 // Always pass an -march option, since our default of z10 is later
6300 // than the GNU assembler's default.
6301 StringRef CPUName = getSystemZTargetCPU(Args);
6302 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
6306 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
6307 options::OPT_fpic, options::OPT_fno_pic,
6308 options::OPT_fPIE, options::OPT_fno_PIE,
6309 options::OPT_fpie, options::OPT_fno_pie);
6311 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
6312 LastPICArg->getOption().matches(options::OPT_fpic) ||
6313 LastPICArg->getOption().matches(options::OPT_fPIE) ||
6314 LastPICArg->getOption().matches(options::OPT_fpie))) {
6315 CmdArgs.push_back("-KPIC");
6319 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6320 options::OPT_Xassembler);
6322 CmdArgs.push_back("-o");
6323 CmdArgs.push_back(Output.getFilename());
6325 for (InputInfoList::const_iterator
6326 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6327 const InputInfo &II = *it;
6328 CmdArgs.push_back(II.getFilename());
6332 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6333 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6335 // Handle the debug info splitting at object creation time if we're
6336 // creating an object.
6337 // TODO: Currently only works on linux with newer objcopy.
6338 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
6339 getToolChain().getTriple().isOSLinux())
6340 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
6341 SplitDebugName(Args, Inputs));
6344 static void AddLibgcc(llvm::Triple Triple, const Driver &D,
6345 ArgStringList &CmdArgs, const ArgList &Args) {
6346 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
6347 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
6348 Args.hasArg(options::OPT_static);
6350 CmdArgs.push_back("-lgcc");
6352 if (StaticLibgcc || isAndroid) {
6354 CmdArgs.push_back("-lgcc");
6357 CmdArgs.push_back("--as-needed");
6358 CmdArgs.push_back("-lgcc_s");
6360 CmdArgs.push_back("--no-as-needed");
6363 if (StaticLibgcc && !isAndroid)
6364 CmdArgs.push_back("-lgcc_eh");
6365 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
6366 CmdArgs.push_back("-lgcc");
6368 // According to Android ABI, we have to link with libdl if we are
6369 // linking with non-static libgcc.
6371 // NOTE: This fixes a link error on Android MIPS as well. The non-static
6372 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
6373 if (isAndroid && !StaticLibgcc)
6374 CmdArgs.push_back("-ldl");
6377 static bool hasMipsN32ABIArg(const ArgList &Args) {
6378 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
6379 return A && (A->getValue() == StringRef("n32"));
6382 static StringRef getLinuxDynamicLinker(const ArgList &Args,
6383 const toolchains::Linux &ToolChain) {
6384 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android)
6385 return "/system/bin/linker";
6386 else if (ToolChain.getArch() == llvm::Triple::x86 ||
6387 ToolChain.getArch() == llvm::Triple::sparc)
6388 return "/lib/ld-linux.so.2";
6389 else if (ToolChain.getArch() == llvm::Triple::aarch64)
6390 return "/lib/ld-linux-aarch64.so.1";
6391 else if (ToolChain.getArch() == llvm::Triple::arm ||
6392 ToolChain.getArch() == llvm::Triple::thumb) {
6393 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
6394 return "/lib/ld-linux-armhf.so.3";
6396 return "/lib/ld-linux.so.3";
6397 } else if (ToolChain.getArch() == llvm::Triple::mips ||
6398 ToolChain.getArch() == llvm::Triple::mipsel)
6399 return "/lib/ld.so.1";
6400 else if (ToolChain.getArch() == llvm::Triple::mips64 ||
6401 ToolChain.getArch() == llvm::Triple::mips64el) {
6402 if (hasMipsN32ABIArg(Args))
6403 return "/lib32/ld.so.1";
6405 return "/lib64/ld.so.1";
6406 } else if (ToolChain.getArch() == llvm::Triple::ppc)
6407 return "/lib/ld.so.1";
6408 else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
6409 ToolChain.getArch() == llvm::Triple::ppc64le ||
6410 ToolChain.getArch() == llvm::Triple::systemz)
6411 return "/lib64/ld64.so.1";
6412 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6413 return "/lib64/ld-linux.so.2";
6415 return "/lib64/ld-linux-x86-64.so.2";
6418 void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
6419 const InputInfo &Output,
6420 const InputInfoList &Inputs,
6421 const ArgList &Args,
6422 const char *LinkingOutput) const {
6423 const toolchains::Linux& ToolChain =
6424 static_cast<const toolchains::Linux&>(getToolChain());
6425 const Driver &D = ToolChain.getDriver();
6426 const bool isAndroid =
6427 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
6428 const SanitizerArgs &Sanitize = ToolChain.getSanitizerArgs();
6430 !Args.hasArg(options::OPT_shared) &&
6431 (Args.hasArg(options::OPT_pie) || Sanitize.hasZeroBaseShadow());
6433 ArgStringList CmdArgs;
6435 // Silence warning for "clang -g foo.o -o foo"
6436 Args.ClaimAllArgs(options::OPT_g_Group);
6437 // and "clang -emit-llvm foo.o -o foo"
6438 Args.ClaimAllArgs(options::OPT_emit_llvm);
6439 // and for "clang -w foo.o -o foo". Other warning options are already
6440 // handled somewhere else.
6441 Args.ClaimAllArgs(options::OPT_w);
6443 if (!D.SysRoot.empty())
6444 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6447 CmdArgs.push_back("-pie");
6449 if (Args.hasArg(options::OPT_rdynamic))
6450 CmdArgs.push_back("-export-dynamic");
6452 if (Args.hasArg(options::OPT_s))
6453 CmdArgs.push_back("-s");
6455 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
6456 e = ToolChain.ExtraOpts.end();
6458 CmdArgs.push_back(i->c_str());
6460 if (!Args.hasArg(options::OPT_static)) {
6461 CmdArgs.push_back("--eh-frame-hdr");
6464 CmdArgs.push_back("-m");
6465 if (ToolChain.getArch() == llvm::Triple::x86)
6466 CmdArgs.push_back("elf_i386");
6467 else if (ToolChain.getArch() == llvm::Triple::aarch64)
6468 CmdArgs.push_back("aarch64linux");
6469 else if (ToolChain.getArch() == llvm::Triple::arm
6470 || ToolChain.getArch() == llvm::Triple::thumb)
6471 CmdArgs.push_back("armelf_linux_eabi");
6472 else if (ToolChain.getArch() == llvm::Triple::ppc)
6473 CmdArgs.push_back("elf32ppclinux");
6474 else if (ToolChain.getArch() == llvm::Triple::ppc64)
6475 CmdArgs.push_back("elf64ppc");
6476 else if (ToolChain.getArch() == llvm::Triple::sparc)
6477 CmdArgs.push_back("elf32_sparc");
6478 else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6479 CmdArgs.push_back("elf64_sparc");
6480 else if (ToolChain.getArch() == llvm::Triple::mips)
6481 CmdArgs.push_back("elf32btsmip");
6482 else if (ToolChain.getArch() == llvm::Triple::mipsel)
6483 CmdArgs.push_back("elf32ltsmip");
6484 else if (ToolChain.getArch() == llvm::Triple::mips64) {
6485 if (hasMipsN32ABIArg(Args))
6486 CmdArgs.push_back("elf32btsmipn32");
6488 CmdArgs.push_back("elf64btsmip");
6490 else if (ToolChain.getArch() == llvm::Triple::mips64el) {
6491 if (hasMipsN32ABIArg(Args))
6492 CmdArgs.push_back("elf32ltsmipn32");
6494 CmdArgs.push_back("elf64ltsmip");
6496 else if (ToolChain.getArch() == llvm::Triple::systemz)
6497 CmdArgs.push_back("elf64_s390");
6499 CmdArgs.push_back("elf_x86_64");
6501 if (Args.hasArg(options::OPT_static)) {
6502 if (ToolChain.getArch() == llvm::Triple::arm
6503 || ToolChain.getArch() == llvm::Triple::thumb)
6504 CmdArgs.push_back("-Bstatic");
6506 CmdArgs.push_back("-static");
6507 } else if (Args.hasArg(options::OPT_shared)) {
6508 CmdArgs.push_back("-shared");
6510 CmdArgs.push_back("-Bsymbolic");
6514 if (ToolChain.getArch() == llvm::Triple::arm ||
6515 ToolChain.getArch() == llvm::Triple::thumb ||
6516 (!Args.hasArg(options::OPT_static) &&
6517 !Args.hasArg(options::OPT_shared))) {
6518 CmdArgs.push_back("-dynamic-linker");
6519 CmdArgs.push_back(Args.MakeArgString(
6520 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
6523 CmdArgs.push_back("-o");
6524 CmdArgs.push_back(Output.getFilename());
6526 if (!Args.hasArg(options::OPT_nostdlib) &&
6527 !Args.hasArg(options::OPT_nostartfiles)) {
6529 const char *crt1 = NULL;
6530 if (!Args.hasArg(options::OPT_shared)){
6531 if (Args.hasArg(options::OPT_pg))
6539 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6541 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6544 const char *crtbegin;
6545 if (Args.hasArg(options::OPT_static))
6546 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
6547 else if (Args.hasArg(options::OPT_shared))
6548 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
6550 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
6552 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
6553 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
6555 // Add crtfastmath.o if available and fast math is enabled.
6556 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
6559 Args.AddAllArgs(CmdArgs, options::OPT_L);
6561 const ToolChain::path_list Paths = ToolChain.getFilePaths();
6563 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6565 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
6567 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
6568 // as gold requires -plugin to come before any -plugin-opt that -Wl might
6570 if (D.IsUsingLTO(Args)) {
6571 CmdArgs.push_back("-plugin");
6572 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
6573 CmdArgs.push_back(Args.MakeArgString(Plugin));
6575 // Try to pass driver level flags relevant to LTO code generation down to
6578 // Handle flags for selecting CPU variants.
6579 std::string CPU = getCPUName(Args, ToolChain.getTriple());
6582 Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
6588 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6589 CmdArgs.push_back("--no-demangle");
6591 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6593 // Call these before we add the C++ ABI library.
6594 if (Sanitize.needsUbsanRt())
6595 addUbsanRTLinux(getToolChain(), Args, CmdArgs, D.CCCIsCXX(),
6596 Sanitize.needsAsanRt() || Sanitize.needsTsanRt() ||
6597 Sanitize.needsMsanRt() || Sanitize.needsLsanRt());
6598 if (Sanitize.needsAsanRt())
6599 addAsanRTLinux(getToolChain(), Args, CmdArgs);
6600 if (Sanitize.needsTsanRt())
6601 addTsanRTLinux(getToolChain(), Args, CmdArgs);
6602 if (Sanitize.needsMsanRt())
6603 addMsanRTLinux(getToolChain(), Args, CmdArgs);
6604 if (Sanitize.needsLsanRt())
6605 addLsanRTLinux(getToolChain(), Args, CmdArgs);
6606 if (Sanitize.needsDfsanRt())
6607 addDfsanRTLinux(getToolChain(), Args, CmdArgs);
6609 // The profile runtime also needs access to system libraries.
6610 addProfileRTLinux(getToolChain(), Args, CmdArgs);
6613 !Args.hasArg(options::OPT_nostdlib) &&
6614 !Args.hasArg(options::OPT_nodefaultlibs)) {
6615 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
6616 !Args.hasArg(options::OPT_static);
6617 if (OnlyLibstdcxxStatic)
6618 CmdArgs.push_back("-Bstatic");
6619 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
6620 if (OnlyLibstdcxxStatic)
6621 CmdArgs.push_back("-Bdynamic");
6622 CmdArgs.push_back("-lm");
6625 if (!Args.hasArg(options::OPT_nostdlib)) {
6626 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
6627 if (Args.hasArg(options::OPT_static))
6628 CmdArgs.push_back("--start-group");
6630 bool OpenMP = Args.hasArg(options::OPT_fopenmp);
6632 CmdArgs.push_back("-lgomp");
6634 // FIXME: Exclude this for platforms whith libgomp that doesn't require
6635 // librt. Most modern Linux platfroms require it, but some may not.
6636 CmdArgs.push_back("-lrt");
6639 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
6641 if (Args.hasArg(options::OPT_pthread) ||
6642 Args.hasArg(options::OPT_pthreads) || OpenMP)
6643 CmdArgs.push_back("-lpthread");
6645 CmdArgs.push_back("-lc");
6647 if (Args.hasArg(options::OPT_static))
6648 CmdArgs.push_back("--end-group");
6650 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
6653 if (!Args.hasArg(options::OPT_nostartfiles)) {
6655 if (Args.hasArg(options::OPT_shared))
6656 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
6658 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
6660 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
6662 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
6664 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
6668 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
6671 void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6672 const InputInfo &Output,
6673 const InputInfoList &Inputs,
6674 const ArgList &Args,
6675 const char *LinkingOutput) const {
6676 ArgStringList CmdArgs;
6678 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6679 options::OPT_Xassembler);
6681 CmdArgs.push_back("-o");
6682 CmdArgs.push_back(Output.getFilename());
6684 for (InputInfoList::const_iterator
6685 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6686 const InputInfo &II = *it;
6687 CmdArgs.push_back(II.getFilename());
6691 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6692 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6695 void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
6696 const InputInfo &Output,
6697 const InputInfoList &Inputs,
6698 const ArgList &Args,
6699 const char *LinkingOutput) const {
6700 const Driver &D = getToolChain().getDriver();
6701 ArgStringList CmdArgs;
6703 if (Output.isFilename()) {
6704 CmdArgs.push_back("-o");
6705 CmdArgs.push_back(Output.getFilename());
6707 assert(Output.isNothing() && "Invalid output.");
6710 if (!Args.hasArg(options::OPT_nostdlib) &&
6711 !Args.hasArg(options::OPT_nostartfiles)) {
6712 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
6713 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
6714 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
6715 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
6718 Args.AddAllArgs(CmdArgs, options::OPT_L);
6719 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6720 Args.AddAllArgs(CmdArgs, options::OPT_e);
6722 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6724 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6726 if (!Args.hasArg(options::OPT_nostdlib) &&
6727 !Args.hasArg(options::OPT_nodefaultlibs)) {
6729 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6730 CmdArgs.push_back("-lm");
6734 if (!Args.hasArg(options::OPT_nostdlib) &&
6735 !Args.hasArg(options::OPT_nostartfiles)) {
6736 if (Args.hasArg(options::OPT_pthread))
6737 CmdArgs.push_back("-lpthread");
6738 CmdArgs.push_back("-lc");
6739 CmdArgs.push_back("-lCompilerRT-Generic");
6740 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
6742 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
6745 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
6746 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6751 // For now, DragonFly Assemble does just about the same as for
6752 // FreeBSD, but this may change soon.
6753 void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6754 const InputInfo &Output,
6755 const InputInfoList &Inputs,
6756 const ArgList &Args,
6757 const char *LinkingOutput) const {
6758 ArgStringList CmdArgs;
6760 // When building 32-bit code on DragonFly/pc64, we have to explicitly
6761 // instruct as in the base system to assemble 32-bit code.
6762 if (getToolChain().getArch() == llvm::Triple::x86)
6763 CmdArgs.push_back("--32");
6765 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6766 options::OPT_Xassembler);
6768 CmdArgs.push_back("-o");
6769 CmdArgs.push_back(Output.getFilename());
6771 for (InputInfoList::const_iterator
6772 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6773 const InputInfo &II = *it;
6774 CmdArgs.push_back(II.getFilename());
6778 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6779 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6782 void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
6783 const InputInfo &Output,
6784 const InputInfoList &Inputs,
6785 const ArgList &Args,
6786 const char *LinkingOutput) const {
6787 bool UseGCC47 = false;
6788 const Driver &D = getToolChain().getDriver();
6789 ArgStringList CmdArgs;
6791 if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
6794 if (!D.SysRoot.empty())
6795 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6797 CmdArgs.push_back("--eh-frame-hdr");
6798 if (Args.hasArg(options::OPT_static)) {
6799 CmdArgs.push_back("-Bstatic");
6801 if (Args.hasArg(options::OPT_rdynamic))
6802 CmdArgs.push_back("-export-dynamic");
6803 if (Args.hasArg(options::OPT_shared))
6804 CmdArgs.push_back("-Bshareable");
6806 CmdArgs.push_back("-dynamic-linker");
6807 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
6809 CmdArgs.push_back("--hash-style=both");
6812 // When building 32-bit code on DragonFly/pc64, we have to explicitly
6813 // instruct ld in the base system to link 32-bit code.
6814 if (getToolChain().getArch() == llvm::Triple::x86) {
6815 CmdArgs.push_back("-m");
6816 CmdArgs.push_back("elf_i386");
6819 if (Output.isFilename()) {
6820 CmdArgs.push_back("-o");
6821 CmdArgs.push_back(Output.getFilename());
6823 assert(Output.isNothing() && "Invalid output.");
6826 if (!Args.hasArg(options::OPT_nostdlib) &&
6827 !Args.hasArg(options::OPT_nostartfiles)) {
6828 if (!Args.hasArg(options::OPT_shared)) {
6829 if (Args.hasArg(options::OPT_pg))
6830 CmdArgs.push_back(Args.MakeArgString(
6831 getToolChain().GetFilePath("gcrt1.o")));
6833 if (Args.hasArg(options::OPT_pie))
6834 CmdArgs.push_back(Args.MakeArgString(
6835 getToolChain().GetFilePath("Scrt1.o")));
6837 CmdArgs.push_back(Args.MakeArgString(
6838 getToolChain().GetFilePath("crt1.o")));
6841 CmdArgs.push_back(Args.MakeArgString(
6842 getToolChain().GetFilePath("crti.o")));
6843 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
6844 CmdArgs.push_back(Args.MakeArgString(
6845 getToolChain().GetFilePath("crtbeginS.o")));
6847 CmdArgs.push_back(Args.MakeArgString(
6848 getToolChain().GetFilePath("crtbegin.o")));
6851 Args.AddAllArgs(CmdArgs, options::OPT_L);
6852 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6853 Args.AddAllArgs(CmdArgs, options::OPT_e);
6855 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6857 if (!Args.hasArg(options::OPT_nostdlib) &&
6858 !Args.hasArg(options::OPT_nodefaultlibs)) {
6859 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
6862 CmdArgs.push_back("-L/usr/lib/gcc47");
6864 CmdArgs.push_back("-L/usr/lib/gcc44");
6866 if (!Args.hasArg(options::OPT_static)) {
6868 CmdArgs.push_back("-rpath");
6869 CmdArgs.push_back("/usr/lib/gcc47");
6871 CmdArgs.push_back("-rpath");
6872 CmdArgs.push_back("/usr/lib/gcc44");
6877 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6878 CmdArgs.push_back("-lm");
6881 if (Args.hasArg(options::OPT_pthread))
6882 CmdArgs.push_back("-lpthread");
6884 if (!Args.hasArg(options::OPT_nolibc)) {
6885 CmdArgs.push_back("-lc");
6889 if (Args.hasArg(options::OPT_static) ||
6890 Args.hasArg(options::OPT_static_libgcc)) {
6891 CmdArgs.push_back("-lgcc");
6892 CmdArgs.push_back("-lgcc_eh");
6894 if (Args.hasArg(options::OPT_shared_libgcc)) {
6895 CmdArgs.push_back("-lgcc_pic");
6896 if (!Args.hasArg(options::OPT_shared))
6897 CmdArgs.push_back("-lgcc");
6899 CmdArgs.push_back("-lgcc");
6900 CmdArgs.push_back("--as-needed");
6901 CmdArgs.push_back("-lgcc_pic");
6902 CmdArgs.push_back("--no-as-needed");
6906 if (Args.hasArg(options::OPT_shared)) {
6907 CmdArgs.push_back("-lgcc_pic");
6909 CmdArgs.push_back("-lgcc");
6914 if (!Args.hasArg(options::OPT_nostdlib) &&
6915 !Args.hasArg(options::OPT_nostartfiles)) {
6916 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
6917 CmdArgs.push_back(Args.MakeArgString(
6918 getToolChain().GetFilePath("crtendS.o")));
6920 CmdArgs.push_back(Args.MakeArgString(
6921 getToolChain().GetFilePath("crtend.o")));
6922 CmdArgs.push_back(Args.MakeArgString(
6923 getToolChain().GetFilePath("crtn.o")));
6926 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6929 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
6930 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6933 void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
6934 const InputInfo &Output,
6935 const InputInfoList &Inputs,
6936 const ArgList &Args,
6937 const char *LinkingOutput) const {
6938 ArgStringList CmdArgs;
6940 if (Output.isFilename()) {
6941 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
6942 Output.getFilename()));
6944 assert(Output.isNothing() && "Invalid output.");
6947 if (!Args.hasArg(options::OPT_nostdlib) &&
6948 !Args.hasArg(options::OPT_nostartfiles) &&
6949 !C.getDriver().IsCLMode()) {
6950 CmdArgs.push_back("-defaultlib:libcmt");
6953 CmdArgs.push_back("-nologo");
6955 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
6958 CmdArgs.push_back(Args.MakeArgString("-dll"));
6960 SmallString<128> ImplibName(Output.getFilename());
6961 llvm::sys::path::replace_extension(ImplibName, "lib");
6962 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
6966 if (getToolChain().getSanitizerArgs().needsAsanRt()) {
6967 CmdArgs.push_back(Args.MakeArgString("-debug"));
6968 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
6969 SmallString<128> LibSanitizer(getToolChain().getDriver().ResourceDir);
6970 llvm::sys::path::append(LibSanitizer, "lib", "windows");
6972 llvm::sys::path::append(LibSanitizer, "clang_rt.asan_dll_thunk-i386.lib");
6974 llvm::sys::path::append(LibSanitizer, "clang_rt.asan-i386.lib");
6976 // FIXME: Handle 64-bit.
6977 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
6980 Args.AddAllArgValues(CmdArgs, options::OPT_l);
6981 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
6983 // Add filenames immediately.
6984 for (InputInfoList::const_iterator
6985 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6986 if (it->isFilename())
6987 CmdArgs.push_back(it->getFilename());
6989 it->getInputArg().renderAsInput(Args, CmdArgs);
6993 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
6994 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6997 void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
6998 const InputInfo &Output,
6999 const InputInfoList &Inputs,
7000 const ArgList &Args,
7001 const char *LinkingOutput) const {
7002 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7005 // Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7006 // If one cannot be found, return FallbackName.
7007 // We do this special search to prevent clang-cl from falling back onto itself
7008 // if it's available as cl.exe on the path.
7009 static std::string FindFallback(const char *FallbackName,
7010 const char *ClangProgramPath) {
7011 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7012 if (!OptPath.hasValue())
7013 return FallbackName;
7015 #ifdef LLVM_ON_WIN32
7016 const StringRef PathSeparators = ";";
7018 const StringRef PathSeparators = ":";
7021 SmallVector<StringRef, 8> PathSegments;
7022 llvm::SplitString(OptPath.getValue(), PathSegments, PathSeparators);
7024 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
7025 const StringRef &PathSegment = PathSegments[i];
7026 if (PathSegment.empty())
7029 SmallString<128> FilePath(PathSegment);
7030 llvm::sys::path::append(FilePath, FallbackName);
7031 if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7032 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7033 return FilePath.str();
7036 return FallbackName;
7039 Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
7040 const InputInfo &Output,
7041 const InputInfoList &Inputs,
7042 const ArgList &Args,
7043 const char *LinkingOutput) const {
7044 ArgStringList CmdArgs;
7045 CmdArgs.push_back("/nologo");
7046 CmdArgs.push_back("/c"); // Compile only.
7047 CmdArgs.push_back("/W0"); // No warnings.
7049 // The goal is to be able to invoke this tool correctly based on
7050 // any flag accepted by clang-cl.
7052 // These are spelled the same way in clang and cl.exe,.
7053 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7054 Args.AddAllArgs(CmdArgs, options::OPT_I);
7056 // Optimization level.
7057 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7058 if (A->getOption().getID() == options::OPT_O0) {
7059 CmdArgs.push_back("/Od");
7061 StringRef OptLevel = A->getValue();
7062 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7063 A->render(Args, CmdArgs);
7064 else if (OptLevel == "3")
7065 CmdArgs.push_back("/Ox");
7069 // Flags for which clang-cl have an alias.
7070 // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7072 if (Arg *A = Args.getLastArg(options::OPT_frtti, options::OPT_fno_rtti))
7073 CmdArgs.push_back(A->getOption().getID() == options::OPT_frtti ? "/GR"
7075 if (Args.hasArg(options::OPT_fsyntax_only))
7076 CmdArgs.push_back("/Zs");
7078 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
7079 for (size_t I = 0, E = Includes.size(); I != E; ++I)
7080 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Includes[I]));
7082 // Flags that can simply be passed through.
7083 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7084 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
7086 // The order of these flags is relevant, so pick the last one.
7087 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7088 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7089 A->render(Args, CmdArgs);
7093 assert(Inputs.size() == 1);
7094 const InputInfo &II = Inputs[0];
7095 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7096 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7097 if (II.isFilename())
7098 CmdArgs.push_back(II.getFilename());
7100 II.getInputArg().renderAsInput(Args, CmdArgs);
7103 assert(Output.getType() == types::TY_Object);
7104 const char *Fo = Args.MakeArgString(std::string("/Fo") +
7105 Output.getFilename());
7106 CmdArgs.push_back(Fo);
7108 const Driver &D = getToolChain().getDriver();
7109 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
7111 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
7116 // We pass assemble and link construction to the xcc tool.
7118 void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7119 const InputInfo &Output,
7120 const InputInfoList &Inputs,
7121 const ArgList &Args,
7122 const char *LinkingOutput) const {
7123 ArgStringList CmdArgs;
7125 CmdArgs.push_back("-o");
7126 CmdArgs.push_back(Output.getFilename());
7128 CmdArgs.push_back("-c");
7130 if (Args.hasArg(options::OPT_g_Group)) {
7131 CmdArgs.push_back("-g");
7134 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7135 options::OPT_Xassembler);
7137 for (InputInfoList::const_iterator
7138 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7139 const InputInfo &II = *it;
7140 CmdArgs.push_back(II.getFilename());
7144 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7145 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7148 void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
7149 const InputInfo &Output,
7150 const InputInfoList &Inputs,
7151 const ArgList &Args,
7152 const char *LinkingOutput) const {
7153 ArgStringList CmdArgs;
7155 if (Output.isFilename()) {
7156 CmdArgs.push_back("-o");
7157 CmdArgs.push_back(Output.getFilename());
7159 assert(Output.isNothing() && "Invalid output.");
7162 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7165 Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7166 C.addCommand(new Command(JA, *this, Exec, CmdArgs));