1//===--- Tools.cpp - Tools Implementations --------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "Tools.h"
11#include "InputInfo.h"
12#include "SanitizerArgs.h"
13#include "ToolChains.h"
14#include "clang/Basic/ObjCRuntime.h"
15#include "clang/Basic/Version.h"
16#include "clang/Driver/Action.h"
17#include "clang/Driver/Arg.h"
18#include "clang/Driver/ArgList.h"
19#include "clang/Driver/Compilation.h"
20#include "clang/Driver/Driver.h"
21#include "clang/Driver/DriverDiagnostic.h"
22#include "clang/Driver/Job.h"
23#include "clang/Driver/Option.h"
24#include "clang/Driver/Options.h"
25#include "clang/Driver/ToolChain.h"
26#include "clang/Driver/Util.h"
27#include "llvm/ADT/SmallString.h"
28#include "llvm/ADT/StringSwitch.h"
29#include "llvm/ADT/Twine.h"
30#include "llvm/Support/ErrorHandling.h"
31#include "llvm/Support/FileSystem.h"
32#include "llvm/Support/Format.h"
33#include "llvm/Support/Host.h"
34#include "llvm/Support/Process.h"
35#include "llvm/Support/raw_ostream.h"
36
37using namespace clang::driver;
38using namespace clang::driver::tools;
39using namespace clang;
40
41/// CheckPreprocessingOptions - Perform some validation of preprocessing
42/// arguments that is shared with gcc.
43static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
44  if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
45    if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP)
46      D.Diag(diag::err_drv_argument_only_allowed_with)
47        << A->getAsString(Args) << "-E";
48}
49
50/// CheckCodeGenerationOptions - Perform some validation of code generation
51/// arguments that is shared with gcc.
52static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
53  // In gcc, only ARM checks this, but it seems reasonable to check universally.
54  if (Args.hasArg(options::OPT_static))
55    if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
56                                       options::OPT_mdynamic_no_pic))
57      D.Diag(diag::err_drv_argument_not_allowed_with)
58        << A->getAsString(Args) << "-static";
59}
60
61// Quote target names for inclusion in GNU Make dependency files.
62// Only the characters '$', '#', ' ', '\t' are quoted.
63static void QuoteTarget(StringRef Target,
64                        SmallVectorImpl<char> &Res) {
65  for (unsigned i = 0, e = Target.size(); i != e; ++i) {
66    switch (Target[i]) {
67    case ' ':
68    case '\t':
69      // Escape the preceding backslashes
70      for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
71        Res.push_back('\\');
72
73      // Escape the space/tab
74      Res.push_back('\\');
75      break;
76    case '$':
77      Res.push_back('$');
78      break;
79    case '#':
80      Res.push_back('\\');
81      break;
82    default:
83      break;
84    }
85
86    Res.push_back(Target[i]);
87  }
88}
89
90static void addDirectoryList(const ArgList &Args,
91                             ArgStringList &CmdArgs,
92                             const char *ArgName,
93                             const char *EnvVar) {
94  const char *DirList = ::getenv(EnvVar);
95  bool CombinedArg = false;
96
97  if (!DirList)
98    return; // Nothing to do.
99
100  StringRef Name(ArgName);
101  if (Name.equals("-I") || Name.equals("-L"))
102    CombinedArg = true;
103
104  StringRef Dirs(DirList);
105  if (Dirs.empty()) // Empty string should not add '.'.
106    return;
107
108  StringRef::size_type Delim;
109  while ((Delim = Dirs.find(llvm::sys::PathSeparator)) != StringRef::npos) {
110    if (Delim == 0) { // Leading colon.
111      if (CombinedArg) {
112        CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
113      } else {
114        CmdArgs.push_back(ArgName);
115        CmdArgs.push_back(".");
116      }
117    } else {
118      if (CombinedArg) {
119        CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
120      } else {
121        CmdArgs.push_back(ArgName);
122        CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
123      }
124    }
125    Dirs = Dirs.substr(Delim + 1);
126  }
127
128  if (Dirs.empty()) { // Trailing colon.
129    if (CombinedArg) {
130      CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
131    } else {
132      CmdArgs.push_back(ArgName);
133      CmdArgs.push_back(".");
134    }
135  } else { // Add the last path.
136    if (CombinedArg) {
137      CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
138    } else {
139      CmdArgs.push_back(ArgName);
140      CmdArgs.push_back(Args.MakeArgString(Dirs));
141    }
142  }
143}
144
145static void AddLinkerInputs(const ToolChain &TC,
146                            const InputInfoList &Inputs, const ArgList &Args,
147                            ArgStringList &CmdArgs) {
148  const Driver &D = TC.getDriver();
149
150  // Add extra linker input arguments which are not treated as inputs
151  // (constructed via -Xarch_).
152  Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
153
154  for (InputInfoList::const_iterator
155         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
156    const InputInfo &II = *it;
157
158    if (!TC.HasNativeLLVMSupport()) {
159      // Don't try to pass LLVM inputs unless we have native support.
160      if (II.getType() == types::TY_LLVM_IR ||
161          II.getType() == types::TY_LTO_IR ||
162          II.getType() == types::TY_LLVM_BC ||
163          II.getType() == types::TY_LTO_BC)
164        D.Diag(diag::err_drv_no_linker_llvm_support)
165          << TC.getTripleString();
166    }
167
168    // Add filenames immediately.
169    if (II.isFilename()) {
170      CmdArgs.push_back(II.getFilename());
171      continue;
172    }
173
174    // Otherwise, this is a linker input argument.
175    const Arg &A = II.getInputArg();
176
177    // Handle reserved library options.
178    if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
179      TC.AddCXXStdlibLibArgs(Args, CmdArgs);
180    } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
181      TC.AddCCKextLibArgs(Args, CmdArgs);
182    } else
183      A.renderAsInput(Args, CmdArgs);
184  }
185
186  // LIBRARY_PATH - included following the user specified library paths.
187  addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
188}
189
190/// \brief Determine whether Objective-C automated reference counting is
191/// enabled.
192static bool isObjCAutoRefCount(const ArgList &Args) {
193  return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
194}
195
196/// \brief Determine whether we are linking the ObjC runtime.
197static bool isObjCRuntimeLinked(const ArgList &Args) {
198  if (isObjCAutoRefCount(Args)) {
199    Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
200    return true;
201  }
202  return Args.hasArg(options::OPT_fobjc_link_runtime);
203}
204
205static void addProfileRT(const ToolChain &TC, const ArgList &Args,
206                         ArgStringList &CmdArgs,
207                         llvm::Triple Triple) {
208  if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
209        Args.hasArg(options::OPT_fprofile_generate) ||
210        Args.hasArg(options::OPT_fcreate_profile) ||
211        Args.hasArg(options::OPT_coverage)))
212    return;
213
214  // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to
215  // the link line. We cannot do the same thing because unlike gcov there is a
216  // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is
217  // not supported by old linkers.
218  std::string ProfileRT =
219    std::string(TC.getDriver().Dir) + "/../lib/libprofile_rt.a";
220
221  CmdArgs.push_back(Args.MakeArgString(ProfileRT));
222}
223
224static bool forwardToGCC(const Option &O) {
225  return !O.hasFlag(options::NoForward) &&
226         !O.hasFlag(options::DriverOption) &&
227         !O.hasFlag(options::LinkerInput);
228}
229
230void Clang::AddPreprocessingOptions(Compilation &C,
231                                    const JobAction &JA,
232                                    const Driver &D,
233                                    const ArgList &Args,
234                                    ArgStringList &CmdArgs,
235                                    const InputInfo &Output,
236                                    const InputInfoList &Inputs) const {
237  Arg *A;
238
239  CheckPreprocessingOptions(D, Args);
240
241  Args.AddLastArg(CmdArgs, options::OPT_C);
242  Args.AddLastArg(CmdArgs, options::OPT_CC);
243
244  // Handle dependency file generation.
245  if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
246      (A = Args.getLastArg(options::OPT_MD)) ||
247      (A = Args.getLastArg(options::OPT_MMD))) {
248    // Determine the output location.
249    const char *DepFile;
250    if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
251      DepFile = MF->getValue();
252      C.addFailureResultFile(DepFile, &JA);
253    } else if (Output.getType() == types::TY_Dependencies) {
254      DepFile = Output.getFilename();
255    } else if (A->getOption().matches(options::OPT_M) ||
256               A->getOption().matches(options::OPT_MM)) {
257      DepFile = "-";
258    } else {
259      DepFile = getDependencyFileName(Args, Inputs);
260      C.addFailureResultFile(DepFile, &JA);
261    }
262    CmdArgs.push_back("-dependency-file");
263    CmdArgs.push_back(DepFile);
264
265    // Add a default target if one wasn't specified.
266    if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
267      const char *DepTarget;
268
269      // If user provided -o, that is the dependency target, except
270      // when we are only generating a dependency file.
271      Arg *OutputOpt = Args.getLastArg(options::OPT_o);
272      if (OutputOpt && Output.getType() != types::TY_Dependencies) {
273        DepTarget = OutputOpt->getValue();
274      } else {
275        // Otherwise derive from the base input.
276        //
277        // FIXME: This should use the computed output file location.
278        SmallString<128> P(Inputs[0].getBaseInput());
279        llvm::sys::path::replace_extension(P, "o");
280        DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
281      }
282
283      CmdArgs.push_back("-MT");
284      SmallString<128> Quoted;
285      QuoteTarget(DepTarget, Quoted);
286      CmdArgs.push_back(Args.MakeArgString(Quoted));
287    }
288
289    if (A->getOption().matches(options::OPT_M) ||
290        A->getOption().matches(options::OPT_MD))
291      CmdArgs.push_back("-sys-header-deps");
292  }
293
294  if (Args.hasArg(options::OPT_MG)) {
295    if (!A || A->getOption().matches(options::OPT_MD) ||
296              A->getOption().matches(options::OPT_MMD))
297      D.Diag(diag::err_drv_mg_requires_m_or_mm);
298    CmdArgs.push_back("-MG");
299  }
300
301  Args.AddLastArg(CmdArgs, options::OPT_MP);
302
303  // Convert all -MQ <target> args to -MT <quoted target>
304  for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
305                                             options::OPT_MQ),
306         ie = Args.filtered_end(); it != ie; ++it) {
307    const Arg *A = *it;
308    A->claim();
309
310    if (A->getOption().matches(options::OPT_MQ)) {
311      CmdArgs.push_back("-MT");
312      SmallString<128> Quoted;
313      QuoteTarget(A->getValue(), Quoted);
314      CmdArgs.push_back(Args.MakeArgString(Quoted));
315
316    // -MT flag - no change
317    } else {
318      A->render(Args, CmdArgs);
319    }
320  }
321
322  // Add -i* options, and automatically translate to
323  // -include-pch/-include-pth for transparent PCH support. It's
324  // wonky, but we include looking for .gch so we can support seamless
325  // replacement into a build system already set up to be generating
326  // .gch files.
327  bool RenderedImplicitInclude = false;
328  for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
329         ie = Args.filtered_end(); it != ie; ++it) {
330    const Arg *A = it;
331
332    if (A->getOption().matches(options::OPT_include)) {
333      bool IsFirstImplicitInclude = !RenderedImplicitInclude;
334      RenderedImplicitInclude = true;
335
336      // Use PCH if the user requested it.
337      bool UsePCH = D.CCCUsePCH;
338
339      bool FoundPTH = false;
340      bool FoundPCH = false;
341      llvm::sys::Path P(A->getValue());
342      bool Exists;
343      if (UsePCH) {
344        P.appendSuffix("pch");
345        if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
346          FoundPCH = true;
347        else
348          P.eraseSuffix();
349      }
350
351      if (!FoundPCH) {
352        P.appendSuffix("pth");
353        if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
354          FoundPTH = true;
355        else
356          P.eraseSuffix();
357      }
358
359      if (!FoundPCH && !FoundPTH) {
360        P.appendSuffix("gch");
361        if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
362          FoundPCH = UsePCH;
363          FoundPTH = !UsePCH;
364        }
365        else
366          P.eraseSuffix();
367      }
368
369      if (FoundPCH || FoundPTH) {
370        if (IsFirstImplicitInclude) {
371          A->claim();
372          if (UsePCH)
373            CmdArgs.push_back("-include-pch");
374          else
375            CmdArgs.push_back("-include-pth");
376          CmdArgs.push_back(Args.MakeArgString(P.str()));
377          continue;
378        } else {
379          // Ignore the PCH if not first on command line and emit warning.
380          D.Diag(diag::warn_drv_pch_not_first_include)
381              << P.str() << A->getAsString(Args);
382        }
383      }
384    }
385
386    // Not translated, render as usual.
387    A->claim();
388    A->render(Args, CmdArgs);
389  }
390
391  Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
392  Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
393                  options::OPT_index_header_map);
394
395  // Add -Wp, and -Xassembler if using the preprocessor.
396
397  // FIXME: There is a very unfortunate problem here, some troubled
398  // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
399  // really support that we would have to parse and then translate
400  // those options. :(
401  Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
402                       options::OPT_Xpreprocessor);
403
404  // -I- is a deprecated GCC feature, reject it.
405  if (Arg *A = Args.getLastArg(options::OPT_I_))
406    D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
407
408  // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
409  // -isysroot to the CC1 invocation.
410  StringRef sysroot = C.getSysRoot();
411  if (sysroot != "") {
412    if (!Args.hasArg(options::OPT_isysroot)) {
413      CmdArgs.push_back("-isysroot");
414      CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
415    }
416  }
417
418  // Parse additional include paths from environment variables.
419  // FIXME: We should probably sink the logic for handling these from the
420  // frontend into the driver. It will allow deleting 4 otherwise unused flags.
421  // CPATH - included following the user specified includes (but prior to
422  // builtin and standard includes).
423  addDirectoryList(Args, CmdArgs, "-I", "CPATH");
424  // C_INCLUDE_PATH - system includes enabled when compiling C.
425  addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
426  // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
427  addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
428  // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
429  addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
430  // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
431  addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
432
433  // Add C++ include arguments, if needed.
434  if (types::isCXX(Inputs[0].getType()))
435    getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
436
437  // Add system include arguments.
438  getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
439}
440
441/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
442/// CPU.
443//
444// FIXME: This is redundant with -mcpu, why does LLVM use this.
445// FIXME: tblgen this, or kill it!
446static const char *getLLVMArchSuffixForARM(StringRef CPU) {
447  return llvm::StringSwitch<const char *>(CPU)
448    .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
449    .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
450    .Cases("arm920", "arm920t", "arm922t", "v4t")
451    .Cases("arm940t", "ep9312","v4t")
452    .Cases("arm10tdmi",  "arm1020t", "v5")
453    .Cases("arm9e",  "arm926ej-s",  "arm946e-s", "v5e")
454    .Cases("arm966e-s",  "arm968e-s",  "arm10e", "v5e")
455    .Cases("arm1020e",  "arm1022e",  "xscale", "iwmmxt", "v5e")
456    .Cases("arm1136j-s",  "arm1136jf-s",  "arm1176jz-s", "v6")
457    .Cases("arm1176jzf-s",  "mpcorenovfp",  "mpcore", "v6")
458    .Cases("arm1156t2-s",  "arm1156t2f-s", "v6t2")
459    .Cases("cortex-a5", "cortex-a7", "cortex-a8", "v7")
460    .Cases("cortex-a9", "cortex-a15", "v7")
461    .Case("cortex-r5", "v7r")
462    .Case("cortex-m0", "v6m")
463    .Case("cortex-m3", "v7m")
464    .Case("cortex-m4", "v7em")
465    .Case("cortex-a9-mp", "v7f")
466    .Case("swift", "v7s")
467    .Default("");
468}
469
470/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
471//
472// FIXME: tblgen this.
473static std::string getARMTargetCPU(const ArgList &Args,
474                                   const llvm::Triple &Triple) {
475  // FIXME: Warn on inconsistent use of -mcpu and -march.
476
477  // If we have -mcpu=, use that.
478  if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
479    StringRef MCPU = A->getValue();
480    // Handle -mcpu=native.
481    if (MCPU == "native")
482      return llvm::sys::getHostCPUName();
483    else
484      return MCPU;
485  }
486
487  StringRef MArch;
488  if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
489    // Otherwise, if we have -march= choose the base CPU for that arch.
490    MArch = A->getValue();
491  } else {
492    // Otherwise, use the Arch from the triple.
493    MArch = Triple.getArchName();
494  }
495
496  // Handle -march=native.
497  std::string NativeMArch;
498  if (MArch == "native") {
499    std::string CPU = llvm::sys::getHostCPUName();
500    if (CPU != "generic") {
501      // Translate the native cpu into the architecture. The switch below will
502      // then chose the minimum cpu for that arch.
503      NativeMArch = std::string("arm") + getLLVMArchSuffixForARM(CPU);
504      MArch = NativeMArch;
505    }
506  }
507
508  return llvm::StringSwitch<const char *>(MArch)
509    .Cases("armv2", "armv2a","arm2")
510    .Case("armv3", "arm6")
511    .Case("armv3m", "arm7m")
512    .Cases("armv4", "armv4t", "arm7tdmi")
513    .Cases("armv5", "armv5t", "arm10tdmi")
514    .Cases("armv5e", "armv5te", "arm1022e")
515    .Case("armv5tej", "arm926ej-s")
516    .Cases("armv6", "armv6k", "arm1136jf-s")
517    .Case("armv6j", "arm1136j-s")
518    .Cases("armv6z", "armv6zk", "arm1176jzf-s")
519    .Case("armv6t2", "arm1156t2-s")
520    .Cases("armv6m", "armv6-m", "cortex-m0")
521    .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
522    .Cases("armv7em", "armv7e-m", "cortex-m4")
523    .Cases("armv7f", "armv7-f", "cortex-a9-mp")
524    .Cases("armv7s", "armv7-s", "swift")
525    .Cases("armv7r", "armv7-r", "cortex-r4")
526    .Cases("armv7m", "armv7-m", "cortex-m3")
527    .Case("ep9312", "ep9312")
528    .Case("iwmmxt", "iwmmxt")
529    .Case("xscale", "xscale")
530    // If all else failed, return the most base CPU LLVM supports.
531    .Default("arm7tdmi");
532}
533
534// FIXME: Move to target hook.
535static bool isSignedCharDefault(const llvm::Triple &Triple) {
536  switch (Triple.getArch()) {
537  default:
538    return true;
539
540  case llvm::Triple::aarch64:
541  case llvm::Triple::arm:
542  case llvm::Triple::ppc:
543  case llvm::Triple::ppc64:
544    if (Triple.isOSDarwin())
545      return true;
546    return false;
547  }
548}
549
550// Handle -mfpu=.
551//
552// FIXME: Centralize feature selection, defaulting shouldn't be also in the
553// frontend target.
554static void addFPUArgs(const Driver &D, const Arg *A, const ArgList &Args,
555                       ArgStringList &CmdArgs) {
556  StringRef FPU = A->getValue();
557
558  // Set the target features based on the FPU.
559  if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
560    // Disable any default FPU support.
561    CmdArgs.push_back("-target-feature");
562    CmdArgs.push_back("-vfp2");
563    CmdArgs.push_back("-target-feature");
564    CmdArgs.push_back("-vfp3");
565    CmdArgs.push_back("-target-feature");
566    CmdArgs.push_back("-neon");
567  } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
568    CmdArgs.push_back("-target-feature");
569    CmdArgs.push_back("+vfp3");
570    CmdArgs.push_back("-target-feature");
571    CmdArgs.push_back("+d16");
572    CmdArgs.push_back("-target-feature");
573    CmdArgs.push_back("-neon");
574  } else if (FPU == "vfp") {
575    CmdArgs.push_back("-target-feature");
576    CmdArgs.push_back("+vfp2");
577    CmdArgs.push_back("-target-feature");
578    CmdArgs.push_back("-neon");
579  } else if (FPU == "vfp3" || FPU == "vfpv3") {
580    CmdArgs.push_back("-target-feature");
581    CmdArgs.push_back("+vfp3");
582    CmdArgs.push_back("-target-feature");
583    CmdArgs.push_back("-neon");
584  } else if (FPU == "neon") {
585    CmdArgs.push_back("-target-feature");
586    CmdArgs.push_back("+neon");
587  } else
588    D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
589}
590
591// Handle -mfpmath=.
592static void addFPMathArgs(const Driver &D, const Arg *A, const ArgList &Args,
593                          ArgStringList &CmdArgs, StringRef CPU) {
594  StringRef FPMath = A->getValue();
595
596  // Set the target features based on the FPMath.
597  if (FPMath == "neon") {
598    CmdArgs.push_back("-target-feature");
599    CmdArgs.push_back("+neonfp");
600
601    if (CPU != "cortex-a5" && CPU != "cortex-a7" &&
602        CPU != "cortex-a8" && CPU != "cortex-a9" &&
603        CPU != "cortex-a9-mp" && CPU != "cortex-a15")
604      D.Diag(diag::err_drv_invalid_feature) << "-mfpmath=neon" << CPU;
605
606  } else if (FPMath == "vfp" || FPMath == "vfp2" || FPMath == "vfp3" ||
607             FPMath == "vfp4") {
608    CmdArgs.push_back("-target-feature");
609    CmdArgs.push_back("-neonfp");
610
611    // FIXME: Add warnings when disabling a feature not present for a given CPU.
612  } else
613    D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
614}
615
616// Select the float ABI as determined by -msoft-float, -mhard-float, and
617// -mfloat-abi=.
618static StringRef getARMFloatABI(const Driver &D,
619                                const ArgList &Args,
620                                const llvm::Triple &Triple) {
621  StringRef FloatABI;
622  if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
623                               options::OPT_mhard_float,
624                               options::OPT_mfloat_abi_EQ)) {
625    if (A->getOption().matches(options::OPT_msoft_float))
626      FloatABI = "soft";
627    else if (A->getOption().matches(options::OPT_mhard_float))
628      FloatABI = "hard";
629    else {
630      FloatABI = A->getValue();
631      if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
632        D.Diag(diag::err_drv_invalid_mfloat_abi)
633          << A->getAsString(Args);
634        FloatABI = "soft";
635      }
636    }
637  }
638
639  // If unspecified, choose the default based on the platform.
640  if (FloatABI.empty()) {
641    switch (Triple.getOS()) {
642    case llvm::Triple::Darwin:
643    case llvm::Triple::MacOSX:
644    case llvm::Triple::IOS: {
645      // Darwin defaults to "softfp" for v6 and v7.
646      //
647      // FIXME: Factor out an ARM class so we can cache the arch somewhere.
648      std::string ArchName =
649        getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
650      if (StringRef(ArchName).startswith("v6") ||
651          StringRef(ArchName).startswith("v7"))
652        FloatABI = "softfp";
653      else
654        FloatABI = "soft";
655      break;
656    }
657
658    case llvm::Triple::FreeBSD:
659      // FreeBSD defaults to soft float
660      FloatABI = "soft";
661      break;
662
663    default:
664      switch(Triple.getEnvironment()) {
665      case llvm::Triple::GNUEABIHF:
666        FloatABI = "hard";
667        break;
668      case llvm::Triple::GNUEABI:
669        FloatABI = "softfp";
670        break;
671      case llvm::Triple::EABI:
672        // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
673        FloatABI = "softfp";
674        break;
675      case llvm::Triple::Android: {
676        std::string ArchName =
677          getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
678        if (StringRef(ArchName).startswith("v7"))
679          FloatABI = "softfp";
680        else
681          FloatABI = "soft";
682        break;
683      }
684      default:
685        // Assume "soft", but warn the user we are guessing.
686        FloatABI = "soft";
687        D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
688        break;
689      }
690    }
691  }
692
693  return FloatABI;
694}
695
696
697void Clang::AddARMTargetArgs(const ArgList &Args,
698                             ArgStringList &CmdArgs,
699                             bool KernelOrKext) const {
700  const Driver &D = getToolChain().getDriver();
701  // Get the effective triple, which takes into account the deployment target.
702  std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
703  llvm::Triple Triple(TripleStr);
704  std::string CPUName = getARMTargetCPU(Args, Triple);
705
706  // Select the ABI to use.
707  //
708  // FIXME: Support -meabi.
709  const char *ABIName = 0;
710  if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
711    ABIName = A->getValue();
712  } else if (Triple.isOSDarwin()) {
713    // The backend is hardwired to assume AAPCS for M-class processors, ensure
714    // the frontend matches that.
715    if (StringRef(CPUName).startswith("cortex-m")) {
716      ABIName = "aapcs";
717    } else {
718      ABIName = "apcs-gnu";
719    }
720  } else {
721    // Select the default based on the platform.
722    switch(Triple.getEnvironment()) {
723    case llvm::Triple::Android:
724    case llvm::Triple::GNUEABI:
725    case llvm::Triple::GNUEABIHF:
726      ABIName = "aapcs-linux";
727      break;
728    case llvm::Triple::EABI:
729      ABIName = "aapcs";
730      break;
731    default:
732      ABIName = "apcs-gnu";
733    }
734  }
735  CmdArgs.push_back("-target-abi");
736  CmdArgs.push_back(ABIName);
737
738  // Set the CPU based on -march= and -mcpu=.
739  CmdArgs.push_back("-target-cpu");
740  CmdArgs.push_back(Args.MakeArgString(CPUName));
741
742  // Determine floating point ABI from the options & target defaults.
743  StringRef FloatABI = getARMFloatABI(D, Args, Triple);
744  if (FloatABI == "soft") {
745    // Floating point operations and argument passing are soft.
746    //
747    // FIXME: This changes CPP defines, we need -target-soft-float.
748    CmdArgs.push_back("-msoft-float");
749    CmdArgs.push_back("-mfloat-abi");
750    CmdArgs.push_back("soft");
751  } else if (FloatABI == "softfp") {
752    // Floating point operations are hard, but argument passing is soft.
753    CmdArgs.push_back("-mfloat-abi");
754    CmdArgs.push_back("soft");
755  } else {
756    // Floating point operations and argument passing are hard.
757    assert(FloatABI == "hard" && "Invalid float abi!");
758    CmdArgs.push_back("-mfloat-abi");
759    CmdArgs.push_back("hard");
760  }
761
762  // Set appropriate target features for floating point mode.
763  //
764  // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
765  // yet (it uses the -mfloat-abi and -msoft-float options above), and it is
766  // stripped out by the ARM target.
767
768  // Use software floating point operations?
769  if (FloatABI == "soft") {
770    CmdArgs.push_back("-target-feature");
771    CmdArgs.push_back("+soft-float");
772  }
773
774  // Use software floating point argument passing?
775  if (FloatABI != "hard") {
776    CmdArgs.push_back("-target-feature");
777    CmdArgs.push_back("+soft-float-abi");
778  }
779
780  // Honor -mfpu=.
781  if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
782    addFPUArgs(D, A, Args, CmdArgs);
783
784  // Honor -mfpmath=.
785  if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ))
786    addFPMathArgs(D, A, Args, CmdArgs, getARMTargetCPU(Args, Triple));
787
788  // Setting -msoft-float effectively disables NEON because of the GCC
789  // implementation, although the same isn't true of VFP or VFP3.
790  if (FloatABI == "soft") {
791    CmdArgs.push_back("-target-feature");
792    CmdArgs.push_back("-neon");
793  }
794
795  // Kernel code has more strict alignment requirements.
796  if (KernelOrKext) {
797    if (Triple.getOS() != llvm::Triple::IOS || Triple.isOSVersionLT(6)) {
798      CmdArgs.push_back("-backend-option");
799      CmdArgs.push_back("-arm-long-calls");
800    }
801
802    CmdArgs.push_back("-backend-option");
803    CmdArgs.push_back("-arm-strict-align");
804
805    // The kext linker doesn't know how to deal with movw/movt.
806    CmdArgs.push_back("-backend-option");
807    CmdArgs.push_back("-arm-darwin-use-movt=0");
808  }
809
810  // Setting -mno-global-merge disables the codegen global merge pass. Setting
811  // -mglobal-merge has no effect as the pass is enabled by default.
812  if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
813                               options::OPT_mno_global_merge)) {
814    if (A->getOption().matches(options::OPT_mno_global_merge))
815      CmdArgs.push_back("-mno-global-merge");
816  }
817
818  if (Args.hasArg(options::OPT_mno_implicit_float))
819    CmdArgs.push_back("-no-implicit-float");
820}
821
822// Translate MIPS CPU name alias option to CPU name.
823static StringRef getMipsCPUFromAlias(const Arg &A) {
824  if (A.getOption().matches(options::OPT_mips32))
825    return "mips32";
826  if (A.getOption().matches(options::OPT_mips32r2))
827    return "mips32r2";
828  if (A.getOption().matches(options::OPT_mips64))
829    return "mips64";
830  if (A.getOption().matches(options::OPT_mips64r2))
831    return "mips64r2";
832  llvm_unreachable("Unexpected option");
833  return "";
834}
835
836// Get CPU and ABI names. They are not independent
837// so we have to calculate them together.
838static void getMipsCPUAndABI(const ArgList &Args,
839                             const ToolChain &TC,
840                             StringRef &CPUName,
841                             StringRef &ABIName) {
842  const char *DefMips32CPU = "mips32";
843  const char *DefMips64CPU = "mips64";
844
845  if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
846                               options::OPT_mcpu_EQ,
847                               options::OPT_mips_CPUs_Group)) {
848    if (A->getOption().matches(options::OPT_mips_CPUs_Group))
849      CPUName = getMipsCPUFromAlias(*A);
850    else
851      CPUName = A->getValue();
852  }
853
854  if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
855    ABIName = A->getValue();
856
857  // Setup default CPU and ABI names.
858  if (CPUName.empty() && ABIName.empty()) {
859    switch (TC.getTriple().getArch()) {
860    default:
861      llvm_unreachable("Unexpected triple arch name");
862    case llvm::Triple::mips:
863    case llvm::Triple::mipsel:
864      CPUName = DefMips32CPU;
865      break;
866    case llvm::Triple::mips64:
867    case llvm::Triple::mips64el:
868      CPUName = DefMips64CPU;
869      break;
870    }
871  }
872
873  if (!ABIName.empty()) {
874    // Deduce CPU name from ABI name.
875    CPUName = llvm::StringSwitch<const char *>(ABIName)
876      .Cases("32", "o32", "eabi", DefMips32CPU)
877      .Cases("n32", "n64", "64", DefMips64CPU)
878      .Default("");
879  }
880  else if (!CPUName.empty()) {
881    // Deduce ABI name from CPU name.
882    ABIName = llvm::StringSwitch<const char *>(CPUName)
883      .Cases("mips32", "mips32r2", "o32")
884      .Cases("mips64", "mips64r2", "n64")
885      .Default("");
886  }
887
888  // FIXME: Warn on inconsistent cpu and abi usage.
889}
890
891// Convert ABI name to the GNU tools acceptable variant.
892static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
893  return llvm::StringSwitch<llvm::StringRef>(ABI)
894    .Case("o32", "32")
895    .Case("n64", "64")
896    .Default(ABI);
897}
898
899// Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
900// and -mfloat-abi=.
901static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
902  // Select the float ABI as determined by -msoft-float, -mhard-float,
903  // and -mfloat-abi=.
904  StringRef FloatABI;
905  if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
906                               options::OPT_mhard_float,
907                               options::OPT_mfloat_abi_EQ)) {
908    if (A->getOption().matches(options::OPT_msoft_float))
909      FloatABI = "soft";
910    else if (A->getOption().matches(options::OPT_mhard_float))
911      FloatABI = "hard";
912    else {
913      FloatABI = A->getValue();
914      if (FloatABI != "soft" && FloatABI != "single" && FloatABI != "hard") {
915        D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
916        FloatABI = "hard";
917      }
918    }
919  }
920
921  // If unspecified, choose the default based on the platform.
922  if (FloatABI.empty()) {
923    // Assume "hard", because it's a default value used by gcc.
924    // When we start to recognize specific target MIPS processors,
925    // we will be able to select the default more correctly.
926    FloatABI = "hard";
927  }
928
929  return FloatABI;
930}
931
932static void AddTargetFeature(const ArgList &Args,
933                             ArgStringList &CmdArgs,
934                             OptSpecifier OnOpt,
935                             OptSpecifier OffOpt,
936                             StringRef FeatureName) {
937  if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
938    CmdArgs.push_back("-target-feature");
939    if (A->getOption().matches(OnOpt))
940      CmdArgs.push_back(Args.MakeArgString("+" + FeatureName));
941    else
942      CmdArgs.push_back(Args.MakeArgString("-" + FeatureName));
943  }
944}
945
946void Clang::AddMIPSTargetArgs(const ArgList &Args,
947                             ArgStringList &CmdArgs) const {
948  const Driver &D = getToolChain().getDriver();
949  StringRef CPUName;
950  StringRef ABIName;
951  getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
952
953  CmdArgs.push_back("-target-cpu");
954  CmdArgs.push_back(CPUName.data());
955
956  CmdArgs.push_back("-target-abi");
957  CmdArgs.push_back(ABIName.data());
958
959  StringRef FloatABI = getMipsFloatABI(D, Args);
960
961  bool IsMips16 = Args.getLastArg(options::OPT_mips16) != NULL;
962
963  if (FloatABI == "soft" || (FloatABI == "hard" && IsMips16)) {
964    // Floating point operations and argument passing are soft.
965    CmdArgs.push_back("-msoft-float");
966    CmdArgs.push_back("-mfloat-abi");
967    CmdArgs.push_back("soft");
968
969    // FIXME: Note, this is a hack. We need to pass the selected float
970    // mode to the MipsTargetInfoBase to define appropriate macros there.
971    // Now it is the only method.
972    CmdArgs.push_back("-target-feature");
973    CmdArgs.push_back("+soft-float");
974
975    if (FloatABI == "hard" && IsMips16) {
976      CmdArgs.push_back("-mllvm");
977      CmdArgs.push_back("-mips16-hard-float");
978    }
979  }
980  else if (FloatABI == "single") {
981    // Restrict the use of hardware floating-point
982    // instructions to 32-bit operations.
983    CmdArgs.push_back("-target-feature");
984    CmdArgs.push_back("+single-float");
985  }
986  else {
987    // Floating point operations and argument passing are hard.
988    assert(FloatABI == "hard" && "Invalid float abi!");
989    CmdArgs.push_back("-mfloat-abi");
990    CmdArgs.push_back("hard");
991  }
992
993  AddTargetFeature(Args, CmdArgs,
994                   options::OPT_mips16, options::OPT_mno_mips16,
995                   "mips16");
996  AddTargetFeature(Args, CmdArgs,
997                   options::OPT_mdsp, options::OPT_mno_dsp,
998                   "dsp");
999  AddTargetFeature(Args, CmdArgs,
1000                   options::OPT_mdspr2, options::OPT_mno_dspr2,
1001                   "dspr2");
1002
1003  if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1004    if (A->getOption().matches(options::OPT_mxgot)) {
1005      CmdArgs.push_back("-mllvm");
1006      CmdArgs.push_back("-mxgot");
1007    }
1008  }
1009
1010  if (Arg *A = Args.getLastArg(options::OPT_G)) {
1011    StringRef v = A->getValue();
1012    CmdArgs.push_back("-mllvm");
1013    CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1014    A->claim();
1015  }
1016}
1017
1018/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1019static std::string getPPCTargetCPU(const ArgList &Args) {
1020  if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1021    StringRef CPUName = A->getValue();
1022
1023    if (CPUName == "native") {
1024      std::string CPU = llvm::sys::getHostCPUName();
1025      if (!CPU.empty() && CPU != "generic")
1026        return CPU;
1027      else
1028        return "";
1029    }
1030
1031    return llvm::StringSwitch<const char *>(CPUName)
1032      .Case("common", "generic")
1033      .Case("440", "440")
1034      .Case("440fp", "440")
1035      .Case("450", "450")
1036      .Case("601", "601")
1037      .Case("602", "602")
1038      .Case("603", "603")
1039      .Case("603e", "603e")
1040      .Case("603ev", "603ev")
1041      .Case("604", "604")
1042      .Case("604e", "604e")
1043      .Case("620", "620")
1044      .Case("630", "pwr3")
1045      .Case("G3", "g3")
1046      .Case("7400", "7400")
1047      .Case("G4", "g4")
1048      .Case("7450", "7450")
1049      .Case("G4+", "g4+")
1050      .Case("750", "750")
1051      .Case("970", "970")
1052      .Case("G5", "g5")
1053      .Case("a2", "a2")
1054      .Case("a2q", "a2q")
1055      .Case("e500mc", "e500mc")
1056      .Case("e5500", "e5500")
1057      .Case("power3", "pwr3")
1058      .Case("power4", "pwr4")
1059      .Case("power5", "pwr5")
1060      .Case("power5x", "pwr5x")
1061      .Case("power6", "pwr6")
1062      .Case("power6x", "pwr6x")
1063      .Case("power7", "pwr7")
1064      .Case("pwr3", "pwr3")
1065      .Case("pwr4", "pwr4")
1066      .Case("pwr5", "pwr5")
1067      .Case("pwr5x", "pwr5x")
1068      .Case("pwr6", "pwr6")
1069      .Case("pwr6x", "pwr6x")
1070      .Case("pwr7", "pwr7")
1071      .Case("powerpc", "ppc")
1072      .Case("powerpc64", "ppc64")
1073      .Default("");
1074  }
1075
1076  return "";
1077}
1078
1079void Clang::AddPPCTargetArgs(const ArgList &Args,
1080                             ArgStringList &CmdArgs) const {
1081  std::string TargetCPUName = getPPCTargetCPU(Args);
1082
1083  // LLVM may default to generating code for the native CPU,
1084  // but, like gcc, we default to a more generic option for
1085  // each architecture. (except on Darwin)
1086  llvm::Triple Triple = getToolChain().getTriple();
1087  if (TargetCPUName.empty() && !Triple.isOSDarwin()) {
1088    if (Triple.getArch() == llvm::Triple::ppc64)
1089      TargetCPUName = "ppc64";
1090    else
1091      TargetCPUName = "ppc";
1092  }
1093
1094  if (!TargetCPUName.empty()) {
1095    CmdArgs.push_back("-target-cpu");
1096    CmdArgs.push_back(Args.MakeArgString(TargetCPUName.c_str()));
1097  }
1098
1099  // Allow override of the Altivec feature.
1100  if (Args.hasFlag(options::OPT_fno_altivec, options::OPT_faltivec, false)) {
1101    CmdArgs.push_back("-target-feature");
1102    CmdArgs.push_back("-altivec");
1103  }
1104
1105  if (Args.hasFlag(options::OPT_mno_qpx, options::OPT_mqpx, false)) {
1106    CmdArgs.push_back("-target-feature");
1107    CmdArgs.push_back("-qpx");
1108  }
1109}
1110
1111void Clang::AddSparcTargetArgs(const ArgList &Args,
1112                             ArgStringList &CmdArgs) const {
1113  const Driver &D = getToolChain().getDriver();
1114
1115  if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1116    CmdArgs.push_back("-target-cpu");
1117    CmdArgs.push_back(A->getValue());
1118  }
1119
1120  // Select the float ABI as determined by -msoft-float, -mhard-float, and
1121  StringRef FloatABI;
1122  if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1123                               options::OPT_mhard_float)) {
1124    if (A->getOption().matches(options::OPT_msoft_float))
1125      FloatABI = "soft";
1126    else if (A->getOption().matches(options::OPT_mhard_float))
1127      FloatABI = "hard";
1128  }
1129
1130  // If unspecified, choose the default based on the platform.
1131  if (FloatABI.empty()) {
1132    switch (getToolChain().getTriple().getOS()) {
1133    default:
1134      // Assume "soft", but warn the user we are guessing.
1135      FloatABI = "soft";
1136      D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
1137      break;
1138    }
1139  }
1140
1141  if (FloatABI == "soft") {
1142    // Floating point operations and argument passing are soft.
1143    //
1144    // FIXME: This changes CPP defines, we need -target-soft-float.
1145    CmdArgs.push_back("-msoft-float");
1146    CmdArgs.push_back("-target-feature");
1147    CmdArgs.push_back("+soft-float");
1148  } else {
1149    assert(FloatABI == "hard" && "Invalid float abi!");
1150    CmdArgs.push_back("-mhard-float");
1151  }
1152}
1153
1154static const char *getX86TargetCPU(const ArgList &Args,
1155                                   const llvm::Triple &Triple) {
1156  if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1157    if (StringRef(A->getValue()) != "native")
1158      return A->getValue();
1159
1160    // FIXME: Reject attempts to use -march=native unless the target matches
1161    // the host.
1162    //
1163    // FIXME: We should also incorporate the detected target features for use
1164    // with -native.
1165    std::string CPU = llvm::sys::getHostCPUName();
1166    if (!CPU.empty() && CPU != "generic")
1167      return Args.MakeArgString(CPU);
1168  }
1169
1170  // Select the default CPU if none was given (or detection failed).
1171
1172  if (Triple.getArch() != llvm::Triple::x86_64 &&
1173      Triple.getArch() != llvm::Triple::x86)
1174    return 0; // This routine is only handling x86 targets.
1175
1176  bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1177
1178  // FIXME: Need target hooks.
1179  if (Triple.isOSDarwin())
1180    return Is64Bit ? "core2" : "yonah";
1181
1182  // Everything else goes to x86-64 in 64-bit mode.
1183  if (Is64Bit)
1184    return "x86-64";
1185
1186  if (Triple.getOSName().startswith("haiku"))
1187    return "i586";
1188  if (Triple.getOSName().startswith("openbsd"))
1189    return "i486";
1190  if (Triple.getOSName().startswith("bitrig"))
1191    return "i686";
1192  if (Triple.getOSName().startswith("freebsd"))
1193    return "i486";
1194  if (Triple.getOSName().startswith("netbsd"))
1195    return "i486";
1196  // All x86 devices running Android have core2 as their common
1197  // denominator. This makes a better choice than pentium4.
1198  if (Triple.getEnvironment() == llvm::Triple::Android)
1199    return "core2";
1200
1201  // Fallback to p4.
1202  return "pentium4";
1203}
1204
1205void Clang::AddX86TargetArgs(const ArgList &Args,
1206                             ArgStringList &CmdArgs) const {
1207  if (!Args.hasFlag(options::OPT_mred_zone,
1208                    options::OPT_mno_red_zone,
1209                    true) ||
1210      Args.hasArg(options::OPT_mkernel) ||
1211      Args.hasArg(options::OPT_fapple_kext))
1212    CmdArgs.push_back("-disable-red-zone");
1213
1214  // Default to avoid implicit floating-point for kernel/kext code, but allow
1215  // that to be overridden with -mno-soft-float.
1216  bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1217                          Args.hasArg(options::OPT_fapple_kext));
1218  if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1219                               options::OPT_mno_soft_float,
1220                               options::OPT_mno_implicit_float)) {
1221    const Option &O = A->getOption();
1222    NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1223                       O.matches(options::OPT_msoft_float));
1224  }
1225  if (NoImplicitFloat)
1226    CmdArgs.push_back("-no-implicit-float");
1227
1228  if (const char *CPUName = getX86TargetCPU(Args, getToolChain().getTriple())) {
1229    CmdArgs.push_back("-target-cpu");
1230    CmdArgs.push_back(CPUName);
1231  }
1232
1233  // The required algorithm here is slightly strange: the options are applied
1234  // in order (so -mno-sse -msse2 disables SSE3), but any option that gets
1235  // directly overridden later is ignored (so "-mno-sse -msse2 -mno-sse2 -msse"
1236  // is equivalent to "-mno-sse2 -msse"). The -cc1 handling deals with the
1237  // former correctly, but not the latter; handle directly-overridden
1238  // attributes here.
1239  llvm::StringMap<unsigned> PrevFeature;
1240  std::vector<const char*> Features;
1241  for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1242         ie = Args.filtered_end(); it != ie; ++it) {
1243    StringRef Name = (*it)->getOption().getName();
1244    (*it)->claim();
1245
1246    // Skip over "-m".
1247    assert(Name.startswith("m") && "Invalid feature name.");
1248    Name = Name.substr(1);
1249
1250    bool IsNegative = Name.startswith("no-");
1251    if (IsNegative)
1252      Name = Name.substr(3);
1253
1254    unsigned& Prev = PrevFeature[Name];
1255    if (Prev)
1256      Features[Prev - 1] = 0;
1257    Prev = Features.size() + 1;
1258    Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1259  }
1260  for (unsigned i = 0; i < Features.size(); i++) {
1261    if (Features[i]) {
1262      CmdArgs.push_back("-target-feature");
1263      CmdArgs.push_back(Features[i]);
1264    }
1265  }
1266}
1267
1268static inline bool HasPICArg(const ArgList &Args) {
1269  return Args.hasArg(options::OPT_fPIC)
1270    || Args.hasArg(options::OPT_fpic);
1271}
1272
1273static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1274  return Args.getLastArg(options::OPT_G,
1275                         options::OPT_G_EQ,
1276                         options::OPT_msmall_data_threshold_EQ);
1277}
1278
1279static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1280  std::string value;
1281  if (HasPICArg(Args))
1282    value = "0";
1283  else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1284    value = A->getValue();
1285    A->claim();
1286  }
1287  return value;
1288}
1289
1290void Clang::AddHexagonTargetArgs(const ArgList &Args,
1291                                 ArgStringList &CmdArgs) const {
1292  llvm::Triple Triple = getToolChain().getTriple();
1293
1294  CmdArgs.push_back("-target-cpu");
1295  CmdArgs.push_back(Args.MakeArgString(
1296                      "hexagon"
1297                      + toolchains::Hexagon_TC::GetTargetCPU(Args)));
1298  CmdArgs.push_back("-fno-signed-char");
1299  CmdArgs.push_back("-mqdsp6-compat");
1300  CmdArgs.push_back("-Wreturn-type");
1301
1302  std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1303  if (!SmallDataThreshold.empty()) {
1304    CmdArgs.push_back ("-mllvm");
1305    CmdArgs.push_back(Args.MakeArgString(
1306                        "-hexagon-small-data-threshold=" + SmallDataThreshold));
1307  }
1308
1309  if (!Args.hasArg(options::OPT_fno_short_enums))
1310    CmdArgs.push_back("-fshort-enums");
1311  if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1312    CmdArgs.push_back ("-mllvm");
1313    CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1314  }
1315  CmdArgs.push_back ("-mllvm");
1316  CmdArgs.push_back ("-machine-sink-split=0");
1317}
1318
1319static bool
1320shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
1321                                          const llvm::Triple &Triple) {
1322  // We use the zero-cost exception tables for Objective-C if the non-fragile
1323  // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1324  // later.
1325  if (runtime.isNonFragile())
1326    return true;
1327
1328  if (!Triple.isOSDarwin())
1329    return false;
1330
1331  return (!Triple.isMacOSXVersionLT(10,5) &&
1332          (Triple.getArch() == llvm::Triple::x86_64 ||
1333           Triple.getArch() == llvm::Triple::arm));
1334}
1335
1336/// addExceptionArgs - Adds exception related arguments to the driver command
1337/// arguments. There's a master flag, -fexceptions and also language specific
1338/// flags to enable/disable C++ and Objective-C exceptions.
1339/// This makes it possible to for example disable C++ exceptions but enable
1340/// Objective-C exceptions.
1341static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1342                             const llvm::Triple &Triple,
1343                             bool KernelOrKext,
1344                             const ObjCRuntime &objcRuntime,
1345                             ArgStringList &CmdArgs) {
1346  if (KernelOrKext) {
1347    // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1348    // arguments now to avoid warnings about unused arguments.
1349    Args.ClaimAllArgs(options::OPT_fexceptions);
1350    Args.ClaimAllArgs(options::OPT_fno_exceptions);
1351    Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1352    Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1353    Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1354    Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
1355    return;
1356  }
1357
1358  // Exceptions are enabled by default.
1359  bool ExceptionsEnabled = true;
1360
1361  // This keeps track of whether exceptions were explicitly turned on or off.
1362  bool DidHaveExplicitExceptionFlag = false;
1363
1364  if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1365                               options::OPT_fno_exceptions)) {
1366    if (A->getOption().matches(options::OPT_fexceptions))
1367      ExceptionsEnabled = true;
1368    else
1369      ExceptionsEnabled = false;
1370
1371    DidHaveExplicitExceptionFlag = true;
1372  }
1373
1374  bool ShouldUseExceptionTables = false;
1375
1376  // Exception tables and cleanups can be enabled with -fexceptions even if the
1377  // language itself doesn't support exceptions.
1378  if (ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1379    ShouldUseExceptionTables = true;
1380
1381  // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1382  // is not necessarily sensible, but follows GCC.
1383  if (types::isObjC(InputType) &&
1384      Args.hasFlag(options::OPT_fobjc_exceptions,
1385                   options::OPT_fno_objc_exceptions,
1386                   true)) {
1387    CmdArgs.push_back("-fobjc-exceptions");
1388
1389    ShouldUseExceptionTables |=
1390      shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
1391  }
1392
1393  if (types::isCXX(InputType)) {
1394    bool CXXExceptionsEnabled = ExceptionsEnabled;
1395
1396    if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1397                                 options::OPT_fno_cxx_exceptions,
1398                                 options::OPT_fexceptions,
1399                                 options::OPT_fno_exceptions)) {
1400      if (A->getOption().matches(options::OPT_fcxx_exceptions))
1401        CXXExceptionsEnabled = true;
1402      else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
1403        CXXExceptionsEnabled = false;
1404    }
1405
1406    if (CXXExceptionsEnabled) {
1407      CmdArgs.push_back("-fcxx-exceptions");
1408
1409      ShouldUseExceptionTables = true;
1410    }
1411  }
1412
1413  if (ShouldUseExceptionTables)
1414    CmdArgs.push_back("-fexceptions");
1415}
1416
1417static bool ShouldDisableCFI(const ArgList &Args,
1418                             const ToolChain &TC) {
1419  bool Default = true;
1420  if (TC.getTriple().isOSDarwin()) {
1421    // The native darwin assembler doesn't support cfi directives, so
1422    // we disable them if we think the .s file will be passed to it.
1423    Default = TC.useIntegratedAs();
1424  }
1425  return !Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
1426                       options::OPT_fno_dwarf2_cfi_asm,
1427                       Default);
1428}
1429
1430static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1431                                        const ToolChain &TC) {
1432  bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1433                                        options::OPT_fno_dwarf_directory_asm,
1434                                        TC.useIntegratedAs());
1435  return !UseDwarfDirectory;
1436}
1437
1438/// \brief Check whether the given input tree contains any compilation actions.
1439static bool ContainsCompileAction(const Action *A) {
1440  if (isa<CompileJobAction>(A))
1441    return true;
1442
1443  for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1444    if (ContainsCompileAction(*it))
1445      return true;
1446
1447  return false;
1448}
1449
1450/// \brief Check if -relax-all should be passed to the internal assembler.
1451/// This is done by default when compiling non-assembler source with -O0.
1452static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1453  bool RelaxDefault = true;
1454
1455  if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1456    RelaxDefault = A->getOption().matches(options::OPT_O0);
1457
1458  if (RelaxDefault) {
1459    RelaxDefault = false;
1460    for (ActionList::const_iterator it = C.getActions().begin(),
1461           ie = C.getActions().end(); it != ie; ++it) {
1462      if (ContainsCompileAction(*it)) {
1463        RelaxDefault = true;
1464        break;
1465      }
1466    }
1467  }
1468
1469  return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1470    RelaxDefault);
1471}
1472
1473SanitizerArgs::SanitizerArgs(const Driver &D, const ArgList &Args)
1474    : Kind(0), BlacklistFile(""), MsanTrackOrigins(false),
1475      AsanZeroBaseShadow(false) {
1476  unsigned AllKinds = 0;  // All kinds of sanitizers that were turned on
1477                          // at least once (possibly, disabled further).
1478  unsigned AllRemovedKinds = 0;  // All kinds of sanitizers that were explicitly
1479                                 // removed at least once.
1480  for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I) {
1481    unsigned Add, Remove;
1482    if (!parse(D, Args, *I, Add, Remove, true))
1483      continue;
1484    (*I)->claim();
1485    Kind |= Add;
1486    Kind &= ~Remove;
1487    AllKinds |= Add;
1488    AllRemovedKinds |= Remove;
1489  }
1490  // Assume -fsanitize=address implies -fsanitize=init-order, if the latter is
1491  // not disabled explicitly.
1492  if ((Kind & Address) != 0 && (AllRemovedKinds & InitOrder) == 0) {
1493    Kind |= InitOrder;
1494  }
1495
1496  UbsanTrapOnError =
1497    Args.hasArg(options::OPT_fcatch_undefined_behavior) ||
1498    Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
1499                 options::OPT_fno_sanitize_undefined_trap_on_error, false);
1500
1501  if (Args.hasArg(options::OPT_fcatch_undefined_behavior) &&
1502      !Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
1503                    options::OPT_fno_sanitize_undefined_trap_on_error, true)) {
1504    D.Diag(diag::err_drv_argument_not_allowed_with)
1505      << "-fcatch-undefined-behavior"
1506      << "-fno-sanitize-undefined-trap-on-error";
1507  }
1508
1509  // Warn about undefined sanitizer options that require runtime support.
1510  if (UbsanTrapOnError && notAllowedWithTrap()) {
1511    if (Args.hasArg(options::OPT_fcatch_undefined_behavior))
1512      D.Diag(diag::err_drv_argument_not_allowed_with)
1513        << lastArgumentForKind(D, Args, NotAllowedWithTrap)
1514        << "-fcatch-undefined-behavior";
1515    else if (Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
1516                          options::OPT_fno_sanitize_undefined_trap_on_error,
1517                          false))
1518      D.Diag(diag::err_drv_argument_not_allowed_with)
1519        << lastArgumentForKind(D, Args, NotAllowedWithTrap)
1520        << "-fsanitize-undefined-trap-on-error";
1521  }
1522
1523  // Only one runtime library can be used at once.
1524  bool NeedsAsan = needsAsanRt();
1525  bool NeedsTsan = needsTsanRt();
1526  bool NeedsMsan = needsMsanRt();
1527  if (NeedsAsan && NeedsTsan)
1528    D.Diag(diag::err_drv_argument_not_allowed_with)
1529      << lastArgumentForKind(D, Args, NeedsAsanRt)
1530      << lastArgumentForKind(D, Args, NeedsTsanRt);
1531  if (NeedsAsan && NeedsMsan)
1532    D.Diag(diag::err_drv_argument_not_allowed_with)
1533      << lastArgumentForKind(D, Args, NeedsAsanRt)
1534      << lastArgumentForKind(D, Args, NeedsMsanRt);
1535  if (NeedsTsan && NeedsMsan)
1536    D.Diag(diag::err_drv_argument_not_allowed_with)
1537      << lastArgumentForKind(D, Args, NeedsTsanRt)
1538      << lastArgumentForKind(D, Args, NeedsMsanRt);
1539
1540  // If -fsanitize contains extra features of ASan, it should also
1541  // explicitly contain -fsanitize=address (probably, turned off later in the
1542  // command line).
1543  if ((Kind & AddressFull) != 0 && (AllKinds & Address) == 0)
1544    D.Diag(diag::warn_drv_unused_sanitizer)
1545     << lastArgumentForKind(D, Args, AddressFull)
1546     << "-fsanitize=address";
1547
1548  // Parse -f(no-)sanitize-blacklist options.
1549  if (Arg *BLArg = Args.getLastArg(options::OPT_fsanitize_blacklist,
1550                                   options::OPT_fno_sanitize_blacklist)) {
1551    if (BLArg->getOption().matches(options::OPT_fsanitize_blacklist)) {
1552      std::string BLPath = BLArg->getValue();
1553      bool BLExists = false;
1554      if (!llvm::sys::fs::exists(BLPath, BLExists) && BLExists)
1555        BlacklistFile = BLPath;
1556      else
1557        D.Diag(diag::err_drv_no_such_file) << BLPath;
1558    }
1559  } else {
1560    // If no -fsanitize-blacklist option is specified, try to look up for
1561    // blacklist in the resource directory.
1562    std::string BLPath;
1563    bool BLExists = false;
1564    if (getDefaultBlacklistForKind(D, Kind, BLPath) &&
1565        !llvm::sys::fs::exists(BLPath, BLExists) && BLExists)
1566      BlacklistFile = BLPath;
1567  }
1568
1569  // Parse -f(no-)sanitize-memory-track-origins options.
1570  if (NeedsMsan)
1571    MsanTrackOrigins =
1572      Args.hasFlag(options::OPT_fsanitize_memory_track_origins,
1573                   options::OPT_fno_sanitize_memory_track_origins,
1574                   /* Default */false);
1575
1576  // Parse -f(no-)sanitize-address-zero-base-shadow options.
1577  if (NeedsAsan)
1578    AsanZeroBaseShadow =
1579      Args.hasFlag(options::OPT_fsanitize_address_zero_base_shadow,
1580                   options::OPT_fno_sanitize_address_zero_base_shadow,
1581                   /* Default */false);
1582}
1583
1584static void addSanitizerRTLinkFlagsLinux(
1585    const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs,
1586    const StringRef Sanitizer, bool BeforeLibStdCXX) {
1587  // Sanitizer runtime is located in the Linux library directory and
1588  // has name "libclang_rt.<Sanitizer>-<ArchName>.a".
1589  SmallString<128> LibSanitizer(TC.getDriver().ResourceDir);
1590  llvm::sys::path::append(
1591      LibSanitizer, "lib", "linux",
1592      (Twine("libclang_rt.") + Sanitizer + "-" + TC.getArchName() + ".a"));
1593  // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
1594  // etc.) so that the linker picks custom versions of the global 'operator
1595  // new' and 'operator delete' symbols. We take the extreme (but simple)
1596  // strategy of inserting it at the front of the link command. It also
1597  // needs to be forced to end up in the executable, so wrap it in
1598  // whole-archive.
1599  if (BeforeLibStdCXX) {
1600    SmallVector<const char *, 3> PrefixArgs;
1601    PrefixArgs.push_back("-whole-archive");
1602    PrefixArgs.push_back(Args.MakeArgString(LibSanitizer));
1603    PrefixArgs.push_back("-no-whole-archive");
1604    CmdArgs.insert(CmdArgs.begin(), PrefixArgs.begin(), PrefixArgs.end());
1605  } else {
1606    CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
1607  }
1608  CmdArgs.push_back("-lpthread");
1609  CmdArgs.push_back("-ldl");
1610  CmdArgs.push_back("-export-dynamic");
1611}
1612
1613/// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1614/// This needs to be called before we add the C run-time (malloc, etc).
1615static void addAsanRTLinux(const ToolChain &TC, const ArgList &Args,
1616                           ArgStringList &CmdArgs) {
1617  if(TC.getTriple().getEnvironment() == llvm::Triple::Android) {
1618    if (!Args.hasArg(options::OPT_shared)) {
1619      if (!Args.hasArg(options::OPT_pie))
1620        TC.getDriver().Diag(diag::err_drv_asan_android_requires_pie);
1621    }
1622
1623    SmallString<128> LibAsan(TC.getDriver().ResourceDir);
1624    llvm::sys::path::append(LibAsan, "lib", "linux",
1625        (Twine("libclang_rt.asan-") +
1626            TC.getArchName() + "-android.so"));
1627    CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibAsan));
1628  } else {
1629    if (!Args.hasArg(options::OPT_shared)) {
1630      bool ZeroBaseShadow = Args.hasFlag(
1631          options::OPT_fsanitize_address_zero_base_shadow,
1632          options::OPT_fno_sanitize_address_zero_base_shadow, false);
1633      if (ZeroBaseShadow && !Args.hasArg(options::OPT_pie)) {
1634        TC.getDriver().Diag(diag::err_drv_argument_only_allowed_with) <<
1635            "-fsanitize-address-zero-base-shadow" << "-pie";
1636      }
1637      addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "asan", true);
1638    }
1639  }
1640}
1641
1642/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
1643/// This needs to be called before we add the C run-time (malloc, etc).
1644static void addTsanRTLinux(const ToolChain &TC, const ArgList &Args,
1645                           ArgStringList &CmdArgs) {
1646  if (!Args.hasArg(options::OPT_shared)) {
1647    if (!Args.hasArg(options::OPT_pie))
1648      TC.getDriver().Diag(diag::err_drv_argument_only_allowed_with) <<
1649        "-fsanitize=thread" << "-pie";
1650    addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "tsan", true);
1651  }
1652}
1653
1654/// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
1655/// This needs to be called before we add the C run-time (malloc, etc).
1656static void addMsanRTLinux(const ToolChain &TC, const ArgList &Args,
1657                           ArgStringList &CmdArgs) {
1658  if (!Args.hasArg(options::OPT_shared)) {
1659    if (!Args.hasArg(options::OPT_pie))
1660      TC.getDriver().Diag(diag::err_drv_argument_only_allowed_with) <<
1661        "-fsanitize=memory" << "-pie";
1662    addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "msan", true);
1663  }
1664}
1665
1666/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
1667/// (Linux).
1668static void addUbsanRTLinux(const ToolChain &TC, const ArgList &Args,
1669                            ArgStringList &CmdArgs) {
1670  addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "ubsan", false);
1671}
1672
1673static bool shouldUseFramePointer(const ArgList &Args,
1674                                  const llvm::Triple &Triple) {
1675  if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
1676                               options::OPT_fomit_frame_pointer))
1677    return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
1678
1679  // Don't use a frame pointer on linux x86 and x86_64 if optimizing.
1680  if ((Triple.getArch() == llvm::Triple::x86_64 ||
1681       Triple.getArch() == llvm::Triple::x86) &&
1682      Triple.getOS() == llvm::Triple::Linux) {
1683    if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1684      if (!A->getOption().matches(options::OPT_O0))
1685        return false;
1686  }
1687
1688  return true;
1689}
1690
1691/// If the PWD environment variable is set, add a CC1 option to specify the
1692/// debug compilation directory.
1693static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
1694  if (const char *pwd = ::getenv("PWD")) {
1695    // GCC also verifies that stat(pwd) and stat(".") have the same inode
1696    // number. Not doing those because stats are slow, but we could.
1697    if (llvm::sys::path::is_absolute(pwd)) {
1698      std::string CompDir = pwd;
1699      CmdArgs.push_back("-fdebug-compilation-dir");
1700      CmdArgs.push_back(Args.MakeArgString(CompDir));
1701    }
1702  }
1703}
1704
1705static const char *SplitDebugName(const ArgList &Args,
1706                                  const InputInfoList &Inputs) {
1707  Arg *FinalOutput = Args.getLastArg(options::OPT_o);
1708  if (FinalOutput && Args.hasArg(options::OPT_c)) {
1709    SmallString<128> T(FinalOutput->getValue());
1710    llvm::sys::path::replace_extension(T, "dwo");
1711    return Args.MakeArgString(T);
1712  } else {
1713    // Use the compilation dir.
1714    SmallString<128> T(Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
1715    SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
1716    llvm::sys::path::replace_extension(F, "dwo");
1717    T += F;
1718    return Args.MakeArgString(F);
1719  }
1720}
1721
1722static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
1723                           const Tool &T, const JobAction &JA,
1724                           const ArgList &Args, const InputInfo &Output,
1725                           const char *OutFile) {
1726  ArgStringList ExtractArgs;
1727  ExtractArgs.push_back("--extract-dwo");
1728
1729  ArgStringList StripArgs;
1730  StripArgs.push_back("--strip-dwo");
1731
1732  // Grabbing the output of the earlier compile step.
1733  StripArgs.push_back(Output.getFilename());
1734  ExtractArgs.push_back(Output.getFilename());
1735  ExtractArgs.push_back(OutFile);
1736
1737  const char *Exec =
1738    Args.MakeArgString(TC.GetProgramPath("objcopy"));
1739
1740  // First extract the dwo sections.
1741  C.addCommand(new Command(JA, T, Exec, ExtractArgs));
1742
1743  // Then remove them from the original .o file.
1744  C.addCommand(new Command(JA, T, Exec, StripArgs));
1745}
1746
1747void Clang::ConstructJob(Compilation &C, const JobAction &JA,
1748                         const InputInfo &Output,
1749                         const InputInfoList &Inputs,
1750                         const ArgList &Args,
1751                         const char *LinkingOutput) const {
1752  bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
1753                                  options::OPT_fapple_kext);
1754  const Driver &D = getToolChain().getDriver();
1755  ArgStringList CmdArgs;
1756
1757  assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
1758
1759  // Invoke ourselves in -cc1 mode.
1760  //
1761  // FIXME: Implement custom jobs for internal actions.
1762  CmdArgs.push_back("-cc1");
1763
1764  // Add the "effective" target triple.
1765  CmdArgs.push_back("-triple");
1766  std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
1767  CmdArgs.push_back(Args.MakeArgString(TripleStr));
1768
1769  // Select the appropriate action.
1770  RewriteKind rewriteKind = RK_None;
1771
1772  if (isa<AnalyzeJobAction>(JA)) {
1773    assert(JA.getType() == types::TY_Plist && "Invalid output type.");
1774    CmdArgs.push_back("-analyze");
1775  } else if (isa<MigrateJobAction>(JA)) {
1776    CmdArgs.push_back("-migrate");
1777  } else if (isa<PreprocessJobAction>(JA)) {
1778    if (Output.getType() == types::TY_Dependencies)
1779      CmdArgs.push_back("-Eonly");
1780    else {
1781      CmdArgs.push_back("-E");
1782      if (Args.hasArg(options::OPT_rewrite_objc) &&
1783          !Args.hasArg(options::OPT_g_Group))
1784        CmdArgs.push_back("-P");
1785    }
1786  } else if (isa<AssembleJobAction>(JA)) {
1787    CmdArgs.push_back("-emit-obj");
1788
1789    if (UseRelaxAll(C, Args))
1790      CmdArgs.push_back("-mrelax-all");
1791
1792    // When using an integrated assembler, translate -Wa, and -Xassembler
1793    // options.
1794    for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1795                                               options::OPT_Xassembler),
1796           ie = Args.filtered_end(); it != ie; ++it) {
1797      const Arg *A = *it;
1798      A->claim();
1799
1800      for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1801        StringRef Value = A->getValue(i);
1802
1803        if (Value == "-force_cpusubtype_ALL") {
1804          // Do nothing, this is the default and we don't support anything else.
1805        } else if (Value == "-L") {
1806          CmdArgs.push_back("-msave-temp-labels");
1807        } else if (Value == "--fatal-warnings") {
1808          CmdArgs.push_back("-mllvm");
1809          CmdArgs.push_back("-fatal-assembler-warnings");
1810        } else if (Value == "--noexecstack") {
1811          CmdArgs.push_back("-mnoexecstack");
1812        } else {
1813          D.Diag(diag::err_drv_unsupported_option_argument)
1814            << A->getOption().getName() << Value;
1815        }
1816      }
1817    }
1818
1819    // Also ignore explicit -force_cpusubtype_ALL option.
1820    (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
1821  } else if (isa<PrecompileJobAction>(JA)) {
1822    // Use PCH if the user requested it.
1823    bool UsePCH = D.CCCUsePCH;
1824
1825    if (JA.getType() == types::TY_Nothing)
1826      CmdArgs.push_back("-fsyntax-only");
1827    else if (UsePCH)
1828      CmdArgs.push_back("-emit-pch");
1829    else
1830      CmdArgs.push_back("-emit-pth");
1831  } else {
1832    assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
1833
1834    if (JA.getType() == types::TY_Nothing) {
1835      CmdArgs.push_back("-fsyntax-only");
1836    } else if (JA.getType() == types::TY_LLVM_IR ||
1837               JA.getType() == types::TY_LTO_IR) {
1838      CmdArgs.push_back("-emit-llvm");
1839    } else if (JA.getType() == types::TY_LLVM_BC ||
1840               JA.getType() == types::TY_LTO_BC) {
1841      CmdArgs.push_back("-emit-llvm-bc");
1842    } else if (JA.getType() == types::TY_PP_Asm) {
1843      CmdArgs.push_back("-S");
1844    } else if (JA.getType() == types::TY_AST) {
1845      CmdArgs.push_back("-emit-pch");
1846    } else if (JA.getType() == types::TY_RewrittenObjC) {
1847      CmdArgs.push_back("-rewrite-objc");
1848      rewriteKind = RK_NonFragile;
1849    } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
1850      CmdArgs.push_back("-rewrite-objc");
1851      rewriteKind = RK_Fragile;
1852    } else {
1853      assert(JA.getType() == types::TY_PP_Asm &&
1854             "Unexpected output type!");
1855    }
1856  }
1857
1858  // The make clang go fast button.
1859  CmdArgs.push_back("-disable-free");
1860
1861  // Disable the verification pass in -asserts builds.
1862#ifdef NDEBUG
1863  CmdArgs.push_back("-disable-llvm-verifier");
1864#endif
1865
1866  // Set the main file name, so that debug info works even with
1867  // -save-temps.
1868  CmdArgs.push_back("-main-file-name");
1869  CmdArgs.push_back(getBaseInputName(Args, Inputs));
1870
1871  // Some flags which affect the language (via preprocessor
1872  // defines).
1873  if (Args.hasArg(options::OPT_static))
1874    CmdArgs.push_back("-static-define");
1875
1876  if (isa<AnalyzeJobAction>(JA)) {
1877    // Enable region store model by default.
1878    CmdArgs.push_back("-analyzer-store=region");
1879
1880    // Treat blocks as analysis entry points.
1881    CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
1882
1883    CmdArgs.push_back("-analyzer-eagerly-assume");
1884
1885    // Add default argument set.
1886    if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
1887      CmdArgs.push_back("-analyzer-checker=core");
1888
1889      if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
1890        CmdArgs.push_back("-analyzer-checker=unix");
1891
1892      if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
1893        CmdArgs.push_back("-analyzer-checker=osx");
1894
1895      CmdArgs.push_back("-analyzer-checker=deadcode");
1896
1897      // Enable the following experimental checkers for testing.
1898      CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn");
1899      CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
1900      CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
1901      CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
1902      CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
1903      CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
1904    }
1905
1906    // Set the output format. The default is plist, for (lame) historical
1907    // reasons.
1908    CmdArgs.push_back("-analyzer-output");
1909    if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
1910      CmdArgs.push_back(A->getValue());
1911    else
1912      CmdArgs.push_back("plist");
1913
1914    // Disable the presentation of standard compiler warnings when
1915    // using --analyze.  We only want to show static analyzer diagnostics
1916    // or frontend errors.
1917    CmdArgs.push_back("-w");
1918
1919    // Add -Xanalyzer arguments when running as analyzer.
1920    Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
1921  }
1922
1923  CheckCodeGenerationOptions(D, Args);
1924
1925  // For the PIC and PIE flag options, this logic is different from the legacy
1926  // logic in very old versions of GCC, as that logic was just a bug no one had
1927  // ever fixed. This logic is both more rational and consistent with GCC's new
1928  // logic now that the bugs are fixed. The last argument relating to either
1929  // PIC or PIE wins, and no other argument is used. If the last argument is
1930  // any flavor of the '-fno-...' arguments, both PIC and PIE are disabled. Any
1931  // PIE option implicitly enables PIC at the same level.
1932  bool PIE = false;
1933  bool PIC = getToolChain().isPICDefault();
1934  bool IsPICLevelTwo = PIC;
1935  if (Arg *A = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
1936                               options::OPT_fpic, options::OPT_fno_pic,
1937                               options::OPT_fPIE, options::OPT_fno_PIE,
1938                               options::OPT_fpie, options::OPT_fno_pie)) {
1939    Option O = A->getOption();
1940    if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
1941        O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
1942      PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
1943      PIC = PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic);
1944      IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
1945                      O.matches(options::OPT_fPIC);
1946    } else {
1947      PIE = PIC = false;
1948    }
1949  }
1950  // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
1951  // is forced, then neither PIC nor PIE flags will have no effect.
1952  if (getToolChain().isPICDefaultForced()) {
1953    PIE = false;
1954    PIC = getToolChain().isPICDefault();
1955    IsPICLevelTwo = PIC;
1956  }
1957
1958  // Inroduce a Darwin-specific hack. If the default is PIC but the flags
1959  // specified while enabling PIC enabled level 1 PIC, just force it back to
1960  // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
1961  // informal testing).
1962  if (PIC && getToolChain().getTriple().isOSDarwin())
1963    IsPICLevelTwo |= getToolChain().isPICDefault();
1964
1965  // Note that these flags are trump-cards. Regardless of the order w.r.t. the
1966  // PIC or PIE options above, if these show up, PIC is disabled.
1967  llvm::Triple Triple(TripleStr);
1968  if (KernelOrKext &&
1969      (Triple.getOS() != llvm::Triple::IOS ||
1970       Triple.isOSVersionLT(6)))
1971    PIC = PIE = false;
1972  if (Args.hasArg(options::OPT_static))
1973    PIC = PIE = false;
1974
1975  if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
1976    // This is a very special mode. It trumps the other modes, almost no one
1977    // uses it, and it isn't even valid on any OS but Darwin.
1978    if (!getToolChain().getTriple().isOSDarwin())
1979      D.Diag(diag::err_drv_unsupported_opt_for_target)
1980        << A->getSpelling() << getToolChain().getTriple().str();
1981
1982    // FIXME: Warn when this flag trumps some other PIC or PIE flag.
1983
1984    CmdArgs.push_back("-mrelocation-model");
1985    CmdArgs.push_back("dynamic-no-pic");
1986
1987    // Only a forced PIC mode can cause the actual compile to have PIC defines
1988    // etc., no flags are sufficient. This behavior was selected to closely
1989    // match that of llvm-gcc and Apple GCC before that.
1990    if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
1991      CmdArgs.push_back("-pic-level");
1992      CmdArgs.push_back("2");
1993    }
1994  } else {
1995    // Currently, LLVM only knows about PIC vs. static; the PIE differences are
1996    // handled in Clang's IRGen by the -pie-level flag.
1997    CmdArgs.push_back("-mrelocation-model");
1998    CmdArgs.push_back(PIC ? "pic" : "static");
1999
2000    if (PIC) {
2001      CmdArgs.push_back("-pic-level");
2002      CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2003      if (PIE) {
2004        CmdArgs.push_back("-pie-level");
2005        CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2006      }
2007    }
2008  }
2009
2010  if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2011                    options::OPT_fno_merge_all_constants))
2012    CmdArgs.push_back("-fno-merge-all-constants");
2013
2014  // LLVM Code Generator Options.
2015
2016  if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2017    CmdArgs.push_back("-mregparm");
2018    CmdArgs.push_back(A->getValue());
2019  }
2020
2021  if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2022    CmdArgs.push_back("-mrtd");
2023
2024  if (shouldUseFramePointer(Args, getToolChain().getTriple()))
2025    CmdArgs.push_back("-mdisable-fp-elim");
2026  if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2027                    options::OPT_fno_zero_initialized_in_bss))
2028    CmdArgs.push_back("-mno-zero-initialized-in-bss");
2029  if (!Args.hasFlag(options::OPT_fstrict_aliasing,
2030                    options::OPT_fno_strict_aliasing,
2031                    getToolChain().IsStrictAliasingDefault()))
2032    CmdArgs.push_back("-relaxed-aliasing");
2033  if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2034                   false))
2035    CmdArgs.push_back("-fstrict-enums");
2036  if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2037                    options::OPT_fno_optimize_sibling_calls))
2038    CmdArgs.push_back("-mdisable-tail-calls");
2039
2040  // Handle various floating point optimization flags, mapping them to the
2041  // appropriate LLVM code generation flags. The pattern for all of these is to
2042  // default off the codegen optimizations, and if any flag enables them and no
2043  // flag disables them after the flag enabling them, enable the codegen
2044  // optimization. This is complicated by several "umbrella" flags.
2045  if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
2046                               options::OPT_fno_fast_math,
2047                               options::OPT_ffinite_math_only,
2048                               options::OPT_fno_finite_math_only,
2049                               options::OPT_fhonor_infinities,
2050                               options::OPT_fno_honor_infinities))
2051    if (A->getOption().getID() != options::OPT_fno_fast_math &&
2052        A->getOption().getID() != options::OPT_fno_finite_math_only &&
2053        A->getOption().getID() != options::OPT_fhonor_infinities)
2054      CmdArgs.push_back("-menable-no-infs");
2055  if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
2056                               options::OPT_fno_fast_math,
2057                               options::OPT_ffinite_math_only,
2058                               options::OPT_fno_finite_math_only,
2059                               options::OPT_fhonor_nans,
2060                               options::OPT_fno_honor_nans))
2061    if (A->getOption().getID() != options::OPT_fno_fast_math &&
2062        A->getOption().getID() != options::OPT_fno_finite_math_only &&
2063        A->getOption().getID() != options::OPT_fhonor_nans)
2064      CmdArgs.push_back("-menable-no-nans");
2065
2066  // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2067  bool MathErrno = getToolChain().IsMathErrnoDefault();
2068  if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
2069                               options::OPT_fno_fast_math,
2070                               options::OPT_fmath_errno,
2071                               options::OPT_fno_math_errno))
2072    MathErrno = A->getOption().getID() == options::OPT_fmath_errno;
2073  if (MathErrno)
2074    CmdArgs.push_back("-fmath-errno");
2075
2076  // There are several flags which require disabling very specific
2077  // optimizations. Any of these being disabled forces us to turn off the
2078  // entire set of LLVM optimizations, so collect them through all the flag
2079  // madness.
2080  bool AssociativeMath = false;
2081  if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
2082                               options::OPT_fno_fast_math,
2083                               options::OPT_funsafe_math_optimizations,
2084                               options::OPT_fno_unsafe_math_optimizations,
2085                               options::OPT_fassociative_math,
2086                               options::OPT_fno_associative_math))
2087    if (A->getOption().getID() != options::OPT_fno_fast_math &&
2088        A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2089        A->getOption().getID() != options::OPT_fno_associative_math)
2090      AssociativeMath = true;
2091  bool ReciprocalMath = false;
2092  if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
2093                               options::OPT_fno_fast_math,
2094                               options::OPT_funsafe_math_optimizations,
2095                               options::OPT_fno_unsafe_math_optimizations,
2096                               options::OPT_freciprocal_math,
2097                               options::OPT_fno_reciprocal_math))
2098    if (A->getOption().getID() != options::OPT_fno_fast_math &&
2099        A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2100        A->getOption().getID() != options::OPT_fno_reciprocal_math)
2101      ReciprocalMath = true;
2102  bool SignedZeros = true;
2103  if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
2104                               options::OPT_fno_fast_math,
2105                               options::OPT_funsafe_math_optimizations,
2106                               options::OPT_fno_unsafe_math_optimizations,
2107                               options::OPT_fsigned_zeros,
2108                               options::OPT_fno_signed_zeros))
2109    if (A->getOption().getID() != options::OPT_fno_fast_math &&
2110        A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2111        A->getOption().getID() != options::OPT_fsigned_zeros)
2112      SignedZeros = false;
2113  bool TrappingMath = true;
2114  if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
2115                               options::OPT_fno_fast_math,
2116                               options::OPT_funsafe_math_optimizations,
2117                               options::OPT_fno_unsafe_math_optimizations,
2118                               options::OPT_ftrapping_math,
2119                               options::OPT_fno_trapping_math))
2120    if (A->getOption().getID() != options::OPT_fno_fast_math &&
2121        A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2122        A->getOption().getID() != options::OPT_ftrapping_math)
2123      TrappingMath = false;
2124  if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2125      !TrappingMath)
2126    CmdArgs.push_back("-menable-unsafe-fp-math");
2127
2128
2129  // Validate and pass through -fp-contract option.
2130  if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
2131                               options::OPT_fno_fast_math,
2132                               options::OPT_ffp_contract)) {
2133    if (A->getOption().getID() == options::OPT_ffp_contract) {
2134      StringRef Val = A->getValue();
2135      if (Val == "fast" || Val == "on" || Val == "off") {
2136        CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2137      } else {
2138        D.Diag(diag::err_drv_unsupported_option_argument)
2139          << A->getOption().getName() << Val;
2140      }
2141    } else if (A->getOption().getID() == options::OPT_ffast_math) {
2142      // If fast-math is set then set the fp-contract mode to fast.
2143      CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2144    }
2145  }
2146
2147  // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2148  // and if we find them, tell the frontend to provide the appropriate
2149  // preprocessor macros. This is distinct from enabling any optimizations as
2150  // these options induce language changes which must survive serialization
2151  // and deserialization, etc.
2152  if (Arg *A = Args.getLastArg(options::OPT_ffast_math, options::OPT_fno_fast_math))
2153    if (A->getOption().matches(options::OPT_ffast_math))
2154      CmdArgs.push_back("-ffast-math");
2155  if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only, options::OPT_fno_fast_math))
2156    if (A->getOption().matches(options::OPT_ffinite_math_only))
2157      CmdArgs.push_back("-ffinite-math-only");
2158
2159  // Decide whether to use verbose asm. Verbose assembly is the default on
2160  // toolchains which have the integrated assembler on by default.
2161  bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
2162  if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
2163                   IsVerboseAsmDefault) ||
2164      Args.hasArg(options::OPT_dA))
2165    CmdArgs.push_back("-masm-verbose");
2166
2167  if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2168    CmdArgs.push_back("-mdebug-pass");
2169    CmdArgs.push_back("Structure");
2170  }
2171  if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2172    CmdArgs.push_back("-mdebug-pass");
2173    CmdArgs.push_back("Arguments");
2174  }
2175
2176  // Enable -mconstructor-aliases except on darwin, where we have to
2177  // work around a linker bug;  see <rdar://problem/7651567>.
2178  if (!getToolChain().getTriple().isOSDarwin())
2179    CmdArgs.push_back("-mconstructor-aliases");
2180
2181  // Darwin's kernel doesn't support guard variables; just die if we
2182  // try to use them.
2183  if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
2184    CmdArgs.push_back("-fforbid-guard-variables");
2185
2186  if (Args.hasArg(options::OPT_mms_bitfields)) {
2187    CmdArgs.push_back("-mms-bitfields");
2188  }
2189
2190  // This is a coarse approximation of what llvm-gcc actually does, both
2191  // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2192  // complicated ways.
2193  bool AsynchronousUnwindTables =
2194    Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2195                 options::OPT_fno_asynchronous_unwind_tables,
2196                 getToolChain().IsUnwindTablesDefault() &&
2197                 !KernelOrKext);
2198  if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2199                   AsynchronousUnwindTables))
2200    CmdArgs.push_back("-munwind-tables");
2201
2202  getToolChain().addClangTargetOptions(Args, CmdArgs);
2203
2204  if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2205    CmdArgs.push_back("-mlimit-float-precision");
2206    CmdArgs.push_back(A->getValue());
2207  }
2208
2209  // FIXME: Handle -mtune=.
2210  (void) Args.hasArg(options::OPT_mtune_EQ);
2211
2212  if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
2213    CmdArgs.push_back("-mcode-model");
2214    CmdArgs.push_back(A->getValue());
2215  }
2216
2217  // Add target specific cpu and features flags.
2218  switch(getToolChain().getTriple().getArch()) {
2219  default:
2220    break;
2221
2222  case llvm::Triple::arm:
2223  case llvm::Triple::thumb:
2224    AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
2225    break;
2226
2227  case llvm::Triple::mips:
2228  case llvm::Triple::mipsel:
2229  case llvm::Triple::mips64:
2230  case llvm::Triple::mips64el:
2231    AddMIPSTargetArgs(Args, CmdArgs);
2232    break;
2233
2234  case llvm::Triple::ppc:
2235  case llvm::Triple::ppc64:
2236    AddPPCTargetArgs(Args, CmdArgs);
2237    break;
2238
2239  case llvm::Triple::sparc:
2240    AddSparcTargetArgs(Args, CmdArgs);
2241    break;
2242
2243  case llvm::Triple::x86:
2244  case llvm::Triple::x86_64:
2245    AddX86TargetArgs(Args, CmdArgs);
2246    break;
2247
2248  case llvm::Triple::hexagon:
2249    AddHexagonTargetArgs(Args, CmdArgs);
2250    break;
2251  }
2252
2253
2254
2255  // Pass the linker version in use.
2256  if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2257    CmdArgs.push_back("-target-linker-version");
2258    CmdArgs.push_back(A->getValue());
2259  }
2260
2261  // -mno-omit-leaf-frame-pointer is the default on Darwin.
2262  if (Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
2263                   options::OPT_mno_omit_leaf_frame_pointer,
2264                   !getToolChain().getTriple().isOSDarwin()))
2265    CmdArgs.push_back("-momit-leaf-frame-pointer");
2266
2267  // Explicitly error on some things we know we don't support and can't just
2268  // ignore.
2269  types::ID InputType = Inputs[0].getType();
2270  if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2271    Arg *Unsupported;
2272    if (types::isCXX(InputType) &&
2273        getToolChain().getTriple().isOSDarwin() &&
2274        getToolChain().getTriple().getArch() == llvm::Triple::x86) {
2275      if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2276          (Unsupported = Args.getLastArg(options::OPT_mkernel)))
2277        D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
2278          << Unsupported->getOption().getName();
2279    }
2280  }
2281
2282  Args.AddAllArgs(CmdArgs, options::OPT_v);
2283  Args.AddLastArg(CmdArgs, options::OPT_H);
2284  if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
2285    CmdArgs.push_back("-header-include-file");
2286    CmdArgs.push_back(D.CCPrintHeadersFilename ?
2287                      D.CCPrintHeadersFilename : "-");
2288  }
2289  Args.AddLastArg(CmdArgs, options::OPT_P);
2290  Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
2291
2292  if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
2293    CmdArgs.push_back("-diagnostic-log-file");
2294    CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2295                      D.CCLogDiagnosticsFilename : "-");
2296  }
2297
2298  // Use the last option from "-g" group. "-gline-tables-only"
2299  // is preserved, all other debug options are substituted with "-g".
2300  Args.ClaimAllArgs(options::OPT_g_Group);
2301  if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
2302    if (A->getOption().matches(options::OPT_gline_tables_only))
2303      CmdArgs.push_back("-gline-tables-only");
2304    else if (!A->getOption().matches(options::OPT_g0) &&
2305             !A->getOption().matches(options::OPT_ggdb0))
2306      CmdArgs.push_back("-g");
2307  }
2308
2309  // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2310  Args.ClaimAllArgs(options::OPT_g_flags_Group);
2311  if (Args.hasArg(options::OPT_gcolumn_info))
2312    CmdArgs.push_back("-dwarf-column-info");
2313
2314  // -gsplit-dwarf should turn on -g and enable the backend dwarf
2315  // splitting and extraction.
2316  // FIXME: Currently only works on Linux.
2317  if (getToolChain().getTriple().getOS() == llvm::Triple::Linux &&
2318      Args.hasArg(options::OPT_gsplit_dwarf)) {
2319    CmdArgs.push_back("-g");
2320    CmdArgs.push_back("-backend-option");
2321    CmdArgs.push_back("-split-dwarf=Enable");
2322  }
2323
2324  Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
2325  Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
2326
2327  Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2328
2329  if (Args.hasArg(options::OPT_ftest_coverage) ||
2330      Args.hasArg(options::OPT_coverage))
2331    CmdArgs.push_back("-femit-coverage-notes");
2332  if (Args.hasArg(options::OPT_fprofile_arcs) ||
2333      Args.hasArg(options::OPT_coverage))
2334    CmdArgs.push_back("-femit-coverage-data");
2335
2336  if (C.getArgs().hasArg(options::OPT_c) ||
2337      C.getArgs().hasArg(options::OPT_S)) {
2338    if (Output.isFilename()) {
2339      CmdArgs.push_back("-coverage-file");
2340      SmallString<128> CoverageFilename(Output.getFilename());
2341      if (llvm::sys::path::is_relative(CoverageFilename.str())) {
2342        if (const char *pwd = ::getenv("PWD")) {
2343          if (llvm::sys::path::is_absolute(pwd)) {
2344            SmallString<128> Pwd(pwd);
2345            llvm::sys::path::append(Pwd, CoverageFilename.str());
2346            CoverageFilename.swap(Pwd);
2347          }
2348        }
2349      }
2350      CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
2351    }
2352  }
2353
2354  // Pass options for controlling the default header search paths.
2355  if (Args.hasArg(options::OPT_nostdinc)) {
2356    CmdArgs.push_back("-nostdsysteminc");
2357    CmdArgs.push_back("-nobuiltininc");
2358  } else {
2359    if (Args.hasArg(options::OPT_nostdlibinc))
2360        CmdArgs.push_back("-nostdsysteminc");
2361    Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2362    Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2363  }
2364
2365  // Pass the path to compiler resource files.
2366  CmdArgs.push_back("-resource-dir");
2367  CmdArgs.push_back(D.ResourceDir.c_str());
2368
2369  Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2370
2371  bool ARCMTEnabled = false;
2372  if (!Args.hasArg(options::OPT_fno_objc_arc)) {
2373    if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
2374                                       options::OPT_ccc_arcmt_modify,
2375                                       options::OPT_ccc_arcmt_migrate)) {
2376      ARCMTEnabled = true;
2377      switch (A->getOption().getID()) {
2378      default:
2379        llvm_unreachable("missed a case");
2380      case options::OPT_ccc_arcmt_check:
2381        CmdArgs.push_back("-arcmt-check");
2382        break;
2383      case options::OPT_ccc_arcmt_modify:
2384        CmdArgs.push_back("-arcmt-modify");
2385        break;
2386      case options::OPT_ccc_arcmt_migrate:
2387        CmdArgs.push_back("-arcmt-migrate");
2388        CmdArgs.push_back("-mt-migrate-directory");
2389        CmdArgs.push_back(A->getValue());
2390
2391        Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2392        Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
2393        break;
2394      }
2395    }
2396  }
2397
2398  if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2399    if (ARCMTEnabled) {
2400      D.Diag(diag::err_drv_argument_not_allowed_with)
2401        << A->getAsString(Args) << "-ccc-arcmt-migrate";
2402    }
2403    CmdArgs.push_back("-mt-migrate-directory");
2404    CmdArgs.push_back(A->getValue());
2405
2406    if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
2407                     options::OPT_objcmt_migrate_subscripting)) {
2408      // None specified, means enable them all.
2409      CmdArgs.push_back("-objcmt-migrate-literals");
2410      CmdArgs.push_back("-objcmt-migrate-subscripting");
2411    } else {
2412      Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2413      Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2414    }
2415  }
2416
2417  // Add preprocessing options like -I, -D, etc. if we are using the
2418  // preprocessor.
2419  //
2420  // FIXME: Support -fpreprocessed
2421  if (types::getPreprocessedType(InputType) != types::TY_INVALID)
2422    AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
2423
2424  // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
2425  // that "The compiler can only warn and ignore the option if not recognized".
2426  // When building with ccache, it will pass -D options to clang even on
2427  // preprocessed inputs and configure concludes that -fPIC is not supported.
2428  Args.ClaimAllArgs(options::OPT_D);
2429
2430  // Manually translate -O to -O2 and -O4 to -O3; let clang reject
2431  // others.
2432  if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2433    if (A->getOption().matches(options::OPT_O4))
2434      CmdArgs.push_back("-O3");
2435    else if (A->getOption().matches(options::OPT_O) &&
2436             A->getValue()[0] == '\0')
2437      CmdArgs.push_back("-O2");
2438    else
2439      A->render(Args, CmdArgs);
2440  }
2441
2442  // Don't warn about unused -flto.  This can happen when we're preprocessing or
2443  // precompiling.
2444  Args.ClaimAllArgs(options::OPT_flto);
2445
2446  Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
2447  if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
2448    CmdArgs.push_back("-pedantic");
2449  Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
2450  Args.AddLastArg(CmdArgs, options::OPT_w);
2451
2452  // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
2453  // (-ansi is equivalent to -std=c89).
2454  //
2455  // If a std is supplied, only add -trigraphs if it follows the
2456  // option.
2457  if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2458    if (Std->getOption().matches(options::OPT_ansi))
2459      if (types::isCXX(InputType))
2460        CmdArgs.push_back("-std=c++98");
2461      else
2462        CmdArgs.push_back("-std=c89");
2463    else
2464      Std->render(Args, CmdArgs);
2465
2466    if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
2467                                 options::OPT_trigraphs))
2468      if (A != Std)
2469        A->render(Args, CmdArgs);
2470  } else {
2471    // Honor -std-default.
2472    //
2473    // FIXME: Clang doesn't correctly handle -std= when the input language
2474    // doesn't match. For the time being just ignore this for C++ inputs;
2475    // eventually we want to do all the standard defaulting here instead of
2476    // splitting it between the driver and clang -cc1.
2477    if (!types::isCXX(InputType))
2478      Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2479                                "-std=", /*Joined=*/true);
2480    else if (getToolChain().getTriple().getOS() == llvm::Triple::Win32)
2481      CmdArgs.push_back("-std=c++11");
2482
2483    Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
2484  }
2485
2486  // Map the bizarre '-Wwrite-strings' flag to a more sensible
2487  // '-fconst-strings'; this better indicates its actual behavior.
2488  if (Args.hasFlag(options::OPT_Wwrite_strings, options::OPT_Wno_write_strings,
2489                   false)) {
2490    // For perfect compatibility with GCC, we do this even in the presence of
2491    // '-w'. This flag names something other than a warning for GCC.
2492    CmdArgs.push_back("-fconst-strings");
2493  }
2494
2495  // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
2496  // during C++ compilation, which it is by default. GCC keeps this define even
2497  // in the presence of '-w', match this behavior bug-for-bug.
2498  if (types::isCXX(InputType) &&
2499      Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
2500                   true)) {
2501    CmdArgs.push_back("-fdeprecated-macro");
2502  }
2503
2504  // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
2505  if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
2506    if (Asm->getOption().matches(options::OPT_fasm))
2507      CmdArgs.push_back("-fgnu-keywords");
2508    else
2509      CmdArgs.push_back("-fno-gnu-keywords");
2510  }
2511
2512  if (ShouldDisableCFI(Args, getToolChain()))
2513    CmdArgs.push_back("-fno-dwarf2-cfi-asm");
2514
2515  if (ShouldDisableDwarfDirectory(Args, getToolChain()))
2516    CmdArgs.push_back("-fno-dwarf-directory-asm");
2517
2518  // Add in -fdebug-compilation-dir if necessary.
2519  addDebugCompDirArg(Args, CmdArgs);
2520
2521  if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
2522                               options::OPT_ftemplate_depth_EQ)) {
2523    CmdArgs.push_back("-ftemplate-depth");
2524    CmdArgs.push_back(A->getValue());
2525  }
2526
2527  if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
2528    CmdArgs.push_back("-fconstexpr-depth");
2529    CmdArgs.push_back(A->getValue());
2530  }
2531
2532  if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
2533    CmdArgs.push_back("-fbracket-depth");
2534    CmdArgs.push_back(A->getValue());
2535  }
2536
2537  if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
2538                               options::OPT_Wlarge_by_value_copy_def)) {
2539    if (A->getNumValues()) {
2540      StringRef bytes = A->getValue();
2541      CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
2542    } else
2543      CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
2544  }
2545
2546
2547  if (Args.hasArg(options::OPT_relocatable_pch))
2548    CmdArgs.push_back("-relocatable-pch");
2549
2550  if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
2551    CmdArgs.push_back("-fconstant-string-class");
2552    CmdArgs.push_back(A->getValue());
2553  }
2554
2555  if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
2556    CmdArgs.push_back("-ftabstop");
2557    CmdArgs.push_back(A->getValue());
2558  }
2559
2560  CmdArgs.push_back("-ferror-limit");
2561  if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
2562    CmdArgs.push_back(A->getValue());
2563  else
2564    CmdArgs.push_back("19");
2565
2566  if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
2567    CmdArgs.push_back("-fmacro-backtrace-limit");
2568    CmdArgs.push_back(A->getValue());
2569  }
2570
2571  if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
2572    CmdArgs.push_back("-ftemplate-backtrace-limit");
2573    CmdArgs.push_back(A->getValue());
2574  }
2575
2576  if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
2577    CmdArgs.push_back("-fconstexpr-backtrace-limit");
2578    CmdArgs.push_back(A->getValue());
2579  }
2580
2581  // Pass -fmessage-length=.
2582  CmdArgs.push_back("-fmessage-length");
2583  if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
2584    CmdArgs.push_back(A->getValue());
2585  } else {
2586    // If -fmessage-length=N was not specified, determine whether this is a
2587    // terminal and, if so, implicitly define -fmessage-length appropriately.
2588    unsigned N = llvm::sys::Process::StandardErrColumns();
2589    CmdArgs.push_back(Args.MakeArgString(Twine(N)));
2590  }
2591
2592  // -fvisibility= and -fvisibility-ms-compat are of a piece.
2593  if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
2594                                     options::OPT_fvisibility_ms_compat)) {
2595    if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
2596      CmdArgs.push_back("-fvisibility");
2597      CmdArgs.push_back(A->getValue());
2598    } else {
2599      assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
2600      CmdArgs.push_back("-fvisibility");
2601      CmdArgs.push_back("hidden");
2602      CmdArgs.push_back("-ftype-visibility");
2603      CmdArgs.push_back("default");
2604    }
2605  }
2606
2607  Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
2608
2609  Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
2610
2611  // -fhosted is default.
2612  if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
2613      KernelOrKext)
2614    CmdArgs.push_back("-ffreestanding");
2615
2616  // Forward -f (flag) options which we can pass directly.
2617  Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
2618  Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
2619  Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
2620  Args.AddLastArg(CmdArgs, options::OPT_fno_limit_debug_info);
2621  Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
2622  Args.AddLastArg(CmdArgs, options::OPT_faltivec);
2623  Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
2624  Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
2625
2626  SanitizerArgs Sanitize(D, Args);
2627  Sanitize.addArgs(Args, CmdArgs);
2628
2629  if (!Args.hasFlag(options::OPT_fsanitize_recover,
2630                    options::OPT_fno_sanitize_recover,
2631                    true))
2632    CmdArgs.push_back("-fno-sanitize-recover");
2633
2634  if (Args.hasArg(options::OPT_fcatch_undefined_behavior) ||
2635      Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
2636                   options::OPT_fno_sanitize_undefined_trap_on_error, false))
2637    CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
2638
2639  // Report an error for -faltivec on anything other than PowerPC.
2640  if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
2641    if (!(getToolChain().getTriple().getArch() == llvm::Triple::ppc ||
2642          getToolChain().getTriple().getArch() == llvm::Triple::ppc64))
2643      D.Diag(diag::err_drv_argument_only_allowed_with)
2644        << A->getAsString(Args) << "ppc/ppc64";
2645
2646  if (getToolChain().SupportsProfiling())
2647    Args.AddLastArg(CmdArgs, options::OPT_pg);
2648
2649  // -flax-vector-conversions is default.
2650  if (!Args.hasFlag(options::OPT_flax_vector_conversions,
2651                    options::OPT_fno_lax_vector_conversions))
2652    CmdArgs.push_back("-fno-lax-vector-conversions");
2653
2654  if (Args.getLastArg(options::OPT_fapple_kext))
2655    CmdArgs.push_back("-fapple-kext");
2656
2657  if (Args.hasFlag(options::OPT_frewrite_includes,
2658                   options::OPT_fno_rewrite_includes, false))
2659    CmdArgs.push_back("-frewrite-includes");
2660
2661  Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
2662  Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
2663  Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
2664  Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
2665  Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
2666
2667  if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
2668    CmdArgs.push_back("-ftrapv-handler");
2669    CmdArgs.push_back(A->getValue());
2670  }
2671
2672  Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
2673
2674  // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
2675  // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
2676  if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
2677                               options::OPT_fno_wrapv)) {
2678    if (A->getOption().matches(options::OPT_fwrapv))
2679      CmdArgs.push_back("-fwrapv");
2680  } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
2681                                      options::OPT_fno_strict_overflow)) {
2682    if (A->getOption().matches(options::OPT_fno_strict_overflow))
2683      CmdArgs.push_back("-fwrapv");
2684  }
2685  Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
2686  Args.AddLastArg(CmdArgs, options::OPT_funroll_loops);
2687
2688  Args.AddLastArg(CmdArgs, options::OPT_pthread);
2689
2690
2691  // -stack-protector=0 is default.
2692  unsigned StackProtectorLevel = 0;
2693  if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
2694                               options::OPT_fstack_protector_all,
2695                               options::OPT_fstack_protector)) {
2696    if (A->getOption().matches(options::OPT_fstack_protector))
2697      StackProtectorLevel = 1;
2698    else if (A->getOption().matches(options::OPT_fstack_protector_all))
2699      StackProtectorLevel = 2;
2700  } else {
2701    StackProtectorLevel =
2702      getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
2703  }
2704  if (StackProtectorLevel) {
2705    CmdArgs.push_back("-stack-protector");
2706    CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
2707  }
2708
2709  // --param ssp-buffer-size=
2710  for (arg_iterator it = Args.filtered_begin(options::OPT__param),
2711       ie = Args.filtered_end(); it != ie; ++it) {
2712    StringRef Str((*it)->getValue());
2713    if (Str.startswith("ssp-buffer-size=")) {
2714      if (StackProtectorLevel) {
2715        CmdArgs.push_back("-stack-protector-buffer-size");
2716        // FIXME: Verify the argument is a valid integer.
2717        CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
2718      }
2719      (*it)->claim();
2720    }
2721  }
2722
2723  // Translate -mstackrealign
2724  if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
2725                   false)) {
2726    CmdArgs.push_back("-backend-option");
2727    CmdArgs.push_back("-force-align-stack");
2728  }
2729  if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
2730                   false)) {
2731    CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
2732  }
2733
2734  if (Args.hasArg(options::OPT_mstack_alignment)) {
2735    StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
2736    CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
2737  }
2738  // -mkernel implies -mstrict-align; don't add the redundant option.
2739  if (Args.hasArg(options::OPT_mstrict_align) && !KernelOrKext) {
2740    CmdArgs.push_back("-backend-option");
2741    CmdArgs.push_back("-arm-strict-align");
2742  }
2743
2744  // Forward -f options with positive and negative forms; we translate
2745  // these by hand.
2746
2747  if (Args.hasArg(options::OPT_mkernel)) {
2748    if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
2749      CmdArgs.push_back("-fapple-kext");
2750    if (!Args.hasArg(options::OPT_fbuiltin))
2751      CmdArgs.push_back("-fno-builtin");
2752    Args.ClaimAllArgs(options::OPT_fno_builtin);
2753  }
2754  // -fbuiltin is default.
2755  else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
2756    CmdArgs.push_back("-fno-builtin");
2757
2758  if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
2759                    options::OPT_fno_assume_sane_operator_new))
2760    CmdArgs.push_back("-fno-assume-sane-operator-new");
2761
2762  // -fblocks=0 is default.
2763  if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
2764                   getToolChain().IsBlocksDefault()) ||
2765        (Args.hasArg(options::OPT_fgnu_runtime) &&
2766         Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
2767         !Args.hasArg(options::OPT_fno_blocks))) {
2768    CmdArgs.push_back("-fblocks");
2769
2770    if (!Args.hasArg(options::OPT_fgnu_runtime) &&
2771        !getToolChain().hasBlocksRuntime())
2772      CmdArgs.push_back("-fblocks-runtime-optional");
2773  }
2774
2775  // -fmodules enables modules (off by default). However, for C++/Objective-C++,
2776  // users must also pass -fcxx-modules. The latter flag will disappear once the
2777  // modules implementation is solid for C++/Objective-C++ programs as well.
2778  bool HaveModules = false;
2779  if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
2780    bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
2781                                     options::OPT_fno_cxx_modules,
2782                                     false);
2783    if (AllowedInCXX || !types::isCXX(InputType)) {
2784      CmdArgs.push_back("-fmodules");
2785      HaveModules = true;
2786    }
2787  }
2788
2789  // If a module path was provided, pass it along. Otherwise, use a temporary
2790  // directory.
2791  if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) {
2792    A->claim();
2793    if (HaveModules) {
2794      A->render(Args, CmdArgs);
2795    }
2796  } else if (HaveModules) {
2797    SmallString<128> DefaultModuleCache;
2798    llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
2799                                           DefaultModuleCache);
2800    llvm::sys::path::append(DefaultModuleCache, "clang-module-cache");
2801    const char Arg[] = "-fmodules-cache-path=";
2802    DefaultModuleCache.insert(DefaultModuleCache.begin(),
2803                              Arg, Arg + strlen(Arg));
2804    CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
2805  }
2806
2807  // Pass through all -fmodules-ignore-macro arguments.
2808  Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
2809
2810  // -fmodules-autolink (on by default when modules is enabled) automatically
2811  // links against libraries for imported modules.  This requires the
2812  // integrated assembler.
2813  if (HaveModules && getToolChain().useIntegratedAs() &&
2814      Args.hasFlag(options::OPT_fmodules_autolink,
2815                   options::OPT_fno_modules_autolink,
2816                   true)) {
2817    CmdArgs.push_back("-fmodules-autolink");
2818  }
2819
2820  // -faccess-control is default.
2821  if (Args.hasFlag(options::OPT_fno_access_control,
2822                   options::OPT_faccess_control,
2823                   false))
2824    CmdArgs.push_back("-fno-access-control");
2825
2826  // -felide-constructors is the default.
2827  if (Args.hasFlag(options::OPT_fno_elide_constructors,
2828                   options::OPT_felide_constructors,
2829                   false))
2830    CmdArgs.push_back("-fno-elide-constructors");
2831
2832  // -frtti is default.
2833  if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
2834      KernelOrKext) {
2835    CmdArgs.push_back("-fno-rtti");
2836
2837    // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
2838    if (Sanitize.sanitizesVptr()) {
2839      std::string NoRttiArg =
2840        Args.getLastArg(options::OPT_mkernel,
2841                        options::OPT_fapple_kext,
2842                        options::OPT_fno_rtti)->getAsString(Args);
2843      D.Diag(diag::err_drv_argument_not_allowed_with)
2844        << "-fsanitize=vptr" << NoRttiArg;
2845    }
2846  }
2847
2848  // -fshort-enums=0 is default for all architectures except Hexagon.
2849  if (Args.hasFlag(options::OPT_fshort_enums,
2850                   options::OPT_fno_short_enums,
2851                   getToolChain().getTriple().getArch() ==
2852                   llvm::Triple::hexagon))
2853    CmdArgs.push_back("-fshort-enums");
2854
2855  // -fsigned-char is default.
2856  if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
2857                    isSignedCharDefault(getToolChain().getTriple())))
2858    CmdArgs.push_back("-fno-signed-char");
2859
2860  // -fthreadsafe-static is default.
2861  if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
2862                    options::OPT_fno_threadsafe_statics))
2863    CmdArgs.push_back("-fno-threadsafe-statics");
2864
2865  // -fuse-cxa-atexit is default.
2866  if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
2867                    options::OPT_fno_use_cxa_atexit,
2868                   getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
2869                  getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
2870              getToolChain().getTriple().getArch() != llvm::Triple::hexagon) ||
2871      KernelOrKext)
2872    CmdArgs.push_back("-fno-use-cxa-atexit");
2873
2874  // -fms-extensions=0 is default.
2875  if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
2876                   getToolChain().getTriple().getOS() == llvm::Triple::Win32))
2877    CmdArgs.push_back("-fms-extensions");
2878
2879  // -fms-compatibility=0 is default.
2880  if (Args.hasFlag(options::OPT_fms_compatibility,
2881                   options::OPT_fno_ms_compatibility,
2882                   (getToolChain().getTriple().getOS() == llvm::Triple::Win32 &&
2883                    Args.hasFlag(options::OPT_fms_extensions,
2884                                 options::OPT_fno_ms_extensions,
2885                                 true))))
2886    CmdArgs.push_back("-fms-compatibility");
2887
2888  // -fmsc-version=1300 is default.
2889  if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
2890                   getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
2891      Args.hasArg(options::OPT_fmsc_version)) {
2892    StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
2893    if (msc_ver.empty())
2894      CmdArgs.push_back("-fmsc-version=1300");
2895    else
2896      CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
2897  }
2898
2899
2900  // -fno-borland-extensions is default.
2901  if (Args.hasFlag(options::OPT_fborland_extensions,
2902                   options::OPT_fno_borland_extensions, false))
2903    CmdArgs.push_back("-fborland-extensions");
2904
2905  // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
2906  // needs it.
2907  if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
2908                   options::OPT_fno_delayed_template_parsing,
2909                   getToolChain().getTriple().getOS() == llvm::Triple::Win32))
2910    CmdArgs.push_back("-fdelayed-template-parsing");
2911
2912  // -fgnu-keywords default varies depending on language; only pass if
2913  // specified.
2914  if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
2915                               options::OPT_fno_gnu_keywords))
2916    A->render(Args, CmdArgs);
2917
2918  if (Args.hasFlag(options::OPT_fgnu89_inline,
2919                   options::OPT_fno_gnu89_inline,
2920                   false))
2921    CmdArgs.push_back("-fgnu89-inline");
2922
2923  if (Args.hasArg(options::OPT_fno_inline))
2924    CmdArgs.push_back("-fno-inline");
2925
2926  if (Args.hasArg(options::OPT_fno_inline_functions))
2927    CmdArgs.push_back("-fno-inline-functions");
2928
2929  ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
2930
2931  // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
2932  // legacy is the default.
2933  if (objcRuntime.isNonFragile()) {
2934    if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
2935                      options::OPT_fno_objc_legacy_dispatch,
2936                      objcRuntime.isLegacyDispatchDefaultForArch(
2937                        getToolChain().getTriple().getArch()))) {
2938      if (getToolChain().UseObjCMixedDispatch())
2939        CmdArgs.push_back("-fobjc-dispatch-method=mixed");
2940      else
2941        CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
2942    }
2943  }
2944
2945  // -fobjc-default-synthesize-properties=1 is default. This only has an effect
2946  // if the nonfragile objc abi is used.
2947  if (getToolChain().IsObjCDefaultSynthPropertiesDefault()) {
2948    CmdArgs.push_back("-fobjc-default-synthesize-properties");
2949  }
2950
2951  // -fencode-extended-block-signature=1 is default.
2952  if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
2953    CmdArgs.push_back("-fencode-extended-block-signature");
2954  }
2955
2956  // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
2957  // NOTE: This logic is duplicated in ToolChains.cpp.
2958  bool ARC = isObjCAutoRefCount(Args);
2959  if (ARC) {
2960    getToolChain().CheckObjCARC();
2961
2962    CmdArgs.push_back("-fobjc-arc");
2963
2964    // FIXME: It seems like this entire block, and several around it should be
2965    // wrapped in isObjC, but for now we just use it here as this is where it
2966    // was being used previously.
2967    if (types::isCXX(InputType) && types::isObjC(InputType)) {
2968      if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
2969        CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
2970      else
2971        CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
2972    }
2973
2974    // Allow the user to enable full exceptions code emission.
2975    // We define off for Objective-CC, on for Objective-C++.
2976    if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
2977                     options::OPT_fno_objc_arc_exceptions,
2978                     /*default*/ types::isCXX(InputType)))
2979      CmdArgs.push_back("-fobjc-arc-exceptions");
2980  }
2981
2982  // -fobjc-infer-related-result-type is the default, except in the Objective-C
2983  // rewriter.
2984  if (rewriteKind != RK_None)
2985    CmdArgs.push_back("-fno-objc-infer-related-result-type");
2986
2987  // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
2988  // takes precedence.
2989  const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
2990  if (!GCArg)
2991    GCArg = Args.getLastArg(options::OPT_fobjc_gc);
2992  if (GCArg) {
2993    if (ARC) {
2994      D.Diag(diag::err_drv_objc_gc_arr)
2995        << GCArg->getAsString(Args);
2996    } else if (getToolChain().SupportsObjCGC()) {
2997      GCArg->render(Args, CmdArgs);
2998    } else {
2999      // FIXME: We should move this to a hard error.
3000      D.Diag(diag::warn_drv_objc_gc_unsupported)
3001        << GCArg->getAsString(Args);
3002    }
3003  }
3004
3005  // Add exception args.
3006  addExceptionArgs(Args, InputType, getToolChain().getTriple(),
3007                   KernelOrKext, objcRuntime, CmdArgs);
3008
3009  if (getToolChain().UseSjLjExceptions())
3010    CmdArgs.push_back("-fsjlj-exceptions");
3011
3012  // C++ "sane" operator new.
3013  if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3014                    options::OPT_fno_assume_sane_operator_new))
3015    CmdArgs.push_back("-fno-assume-sane-operator-new");
3016
3017  // -fconstant-cfstrings is default, and may be subject to argument translation
3018  // on Darwin.
3019  if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3020                    options::OPT_fno_constant_cfstrings) ||
3021      !Args.hasFlag(options::OPT_mconstant_cfstrings,
3022                    options::OPT_mno_constant_cfstrings))
3023    CmdArgs.push_back("-fno-constant-cfstrings");
3024
3025  // -fshort-wchar default varies depending on platform; only
3026  // pass if specified.
3027  if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
3028    A->render(Args, CmdArgs);
3029
3030  // -fno-pascal-strings is default, only pass non-default. If the tool chain
3031  // happened to translate to -mpascal-strings, we want to back translate here.
3032  //
3033  // FIXME: This is gross; that translation should be pulled from the
3034  // tool chain.
3035  if (Args.hasFlag(options::OPT_fpascal_strings,
3036                   options::OPT_fno_pascal_strings,
3037                   false) ||
3038      Args.hasFlag(options::OPT_mpascal_strings,
3039                   options::OPT_mno_pascal_strings,
3040                   false))
3041    CmdArgs.push_back("-fpascal-strings");
3042
3043  // Honor -fpack-struct= and -fpack-struct, if given. Note that
3044  // -fno-pack-struct doesn't apply to -fpack-struct=.
3045  if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
3046    std::string PackStructStr = "-fpack-struct=";
3047    PackStructStr += A->getValue();
3048    CmdArgs.push_back(Args.MakeArgString(PackStructStr));
3049  } else if (Args.hasFlag(options::OPT_fpack_struct,
3050                          options::OPT_fno_pack_struct, false)) {
3051    CmdArgs.push_back("-fpack-struct=1");
3052  }
3053
3054  if (KernelOrKext) {
3055    if (!Args.hasArg(options::OPT_fcommon))
3056      CmdArgs.push_back("-fno-common");
3057    Args.ClaimAllArgs(options::OPT_fno_common);
3058  }
3059
3060  // -fcommon is default, only pass non-default.
3061  else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
3062    CmdArgs.push_back("-fno-common");
3063
3064  // -fsigned-bitfields is default, and clang doesn't yet support
3065  // -funsigned-bitfields.
3066  if (!Args.hasFlag(options::OPT_fsigned_bitfields,
3067                    options::OPT_funsigned_bitfields))
3068    D.Diag(diag::warn_drv_clang_unsupported)
3069      << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3070
3071  // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
3072  if (!Args.hasFlag(options::OPT_ffor_scope,
3073                    options::OPT_fno_for_scope))
3074    D.Diag(diag::err_drv_clang_unsupported)
3075      << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3076
3077  // -fcaret-diagnostics is default.
3078  if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3079                    options::OPT_fno_caret_diagnostics, true))
3080    CmdArgs.push_back("-fno-caret-diagnostics");
3081
3082  // -fdiagnostics-fixit-info is default, only pass non-default.
3083  if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
3084                    options::OPT_fno_diagnostics_fixit_info))
3085    CmdArgs.push_back("-fno-diagnostics-fixit-info");
3086
3087  // Enable -fdiagnostics-show-option by default.
3088  if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
3089                   options::OPT_fno_diagnostics_show_option))
3090    CmdArgs.push_back("-fdiagnostics-show-option");
3091
3092  if (const Arg *A =
3093        Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3094    CmdArgs.push_back("-fdiagnostics-show-category");
3095    CmdArgs.push_back(A->getValue());
3096  }
3097
3098  if (const Arg *A =
3099        Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3100    CmdArgs.push_back("-fdiagnostics-format");
3101    CmdArgs.push_back(A->getValue());
3102  }
3103
3104  if (Arg *A = Args.getLastArg(
3105      options::OPT_fdiagnostics_show_note_include_stack,
3106      options::OPT_fno_diagnostics_show_note_include_stack)) {
3107    if (A->getOption().matches(
3108        options::OPT_fdiagnostics_show_note_include_stack))
3109      CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3110    else
3111      CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3112  }
3113
3114  // Color diagnostics are the default, unless the terminal doesn't support
3115  // them.
3116  if (Args.hasFlag(options::OPT_fcolor_diagnostics,
3117                   options::OPT_fno_color_diagnostics,
3118                   llvm::sys::Process::StandardErrHasColors()))
3119    CmdArgs.push_back("-fcolor-diagnostics");
3120
3121  if (!Args.hasFlag(options::OPT_fshow_source_location,
3122                    options::OPT_fno_show_source_location))
3123    CmdArgs.push_back("-fno-show-source-location");
3124
3125  if (!Args.hasFlag(options::OPT_fshow_column,
3126                    options::OPT_fno_show_column,
3127                    true))
3128    CmdArgs.push_back("-fno-show-column");
3129
3130  if (!Args.hasFlag(options::OPT_fspell_checking,
3131                    options::OPT_fno_spell_checking))
3132    CmdArgs.push_back("-fno-spell-checking");
3133
3134
3135  // -fno-asm-blocks is default.
3136  if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
3137                   false))
3138    CmdArgs.push_back("-fasm-blocks");
3139
3140  // -fvectorize is default.
3141  if (Args.hasFlag(options::OPT_fvectorize,
3142                   options::OPT_fno_vectorize, true)) {
3143    CmdArgs.push_back("-backend-option");
3144    CmdArgs.push_back("-vectorize-loops");
3145  }
3146
3147  // -fno-slp-vectorize is default.
3148  if (Args.hasFlag(options::OPT_fslp_vectorize,
3149                   options::OPT_fno_slp_vectorize, false)) {
3150    CmdArgs.push_back("-backend-option");
3151    CmdArgs.push_back("-vectorize");
3152  }
3153
3154  if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
3155    A->render(Args, CmdArgs);
3156
3157  // -fdollars-in-identifiers default varies depending on platform and
3158  // language; only pass if specified.
3159  if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
3160                               options::OPT_fno_dollars_in_identifiers)) {
3161    if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
3162      CmdArgs.push_back("-fdollars-in-identifiers");
3163    else
3164      CmdArgs.push_back("-fno-dollars-in-identifiers");
3165  }
3166
3167  // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
3168  // practical purposes.
3169  if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
3170                               options::OPT_fno_unit_at_a_time)) {
3171    if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
3172      D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
3173  }
3174
3175  if (Args.hasFlag(options::OPT_fapple_pragma_pack,
3176                   options::OPT_fno_apple_pragma_pack, false))
3177    CmdArgs.push_back("-fapple-pragma-pack");
3178
3179  // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
3180  //
3181  // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
3182#if 0
3183  if (getToolChain().getTriple().isOSDarwin() &&
3184      (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
3185       getToolChain().getTriple().getArch() == llvm::Triple::thumb)) {
3186    if (!Args.hasArg(options::OPT_fbuiltin_strcat))
3187      CmdArgs.push_back("-fno-builtin-strcat");
3188    if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
3189      CmdArgs.push_back("-fno-builtin-strcpy");
3190  }
3191#endif
3192
3193  // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
3194  if (Arg *A = Args.getLastArg(options::OPT_traditional,
3195                               options::OPT_traditional_cpp)) {
3196    if (isa<PreprocessJobAction>(JA))
3197      CmdArgs.push_back("-traditional-cpp");
3198    else
3199      D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
3200  }
3201
3202  Args.AddLastArg(CmdArgs, options::OPT_dM);
3203  Args.AddLastArg(CmdArgs, options::OPT_dD);
3204
3205  // Handle serialized diagnostics.
3206  if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
3207    CmdArgs.push_back("-serialize-diagnostic-file");
3208    CmdArgs.push_back(Args.MakeArgString(A->getValue()));
3209  }
3210
3211  if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
3212    CmdArgs.push_back("-fretain-comments-from-system-headers");
3213
3214  // Forward -fcomment-block-commands to -cc1.
3215  Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
3216
3217  // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
3218  // parser.
3219  Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
3220  for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
3221         ie = Args.filtered_end(); it != ie; ++it) {
3222    (*it)->claim();
3223
3224    // We translate this by hand to the -cc1 argument, since nightly test uses
3225    // it and developers have been trained to spell it with -mllvm.
3226    if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
3227      CmdArgs.push_back("-disable-llvm-optzns");
3228    else
3229      (*it)->render(Args, CmdArgs);
3230  }
3231
3232  if (Output.getType() == types::TY_Dependencies) {
3233    // Handled with other dependency code.
3234  } else if (Output.isFilename()) {
3235    CmdArgs.push_back("-o");
3236    CmdArgs.push_back(Output.getFilename());
3237  } else {
3238    assert(Output.isNothing() && "Invalid output.");
3239  }
3240
3241  for (InputInfoList::const_iterator
3242         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3243    const InputInfo &II = *it;
3244    CmdArgs.push_back("-x");
3245    if (Args.hasArg(options::OPT_rewrite_objc))
3246      CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
3247    else
3248      CmdArgs.push_back(types::getTypeName(II.getType()));
3249    if (II.isFilename())
3250      CmdArgs.push_back(II.getFilename());
3251    else
3252      II.getInputArg().renderAsInput(Args, CmdArgs);
3253  }
3254
3255  Args.AddAllArgs(CmdArgs, options::OPT_undef);
3256
3257  const char *Exec = getToolChain().getDriver().getClangProgramPath();
3258
3259  // Optionally embed the -cc1 level arguments into the debug info, for build
3260  // analysis.
3261  if (getToolChain().UseDwarfDebugFlags()) {
3262    ArgStringList OriginalArgs;
3263    for (ArgList::const_iterator it = Args.begin(),
3264           ie = Args.end(); it != ie; ++it)
3265      (*it)->render(Args, OriginalArgs);
3266
3267    SmallString<256> Flags;
3268    Flags += Exec;
3269    for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
3270      Flags += " ";
3271      Flags += OriginalArgs[i];
3272    }
3273    CmdArgs.push_back("-dwarf-debug-flags");
3274    CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3275  }
3276
3277  // Add the split debug info name to the command lines here so we
3278  // can propagate it to the backend.
3279  bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
3280    (getToolChain().getTriple().getOS() == llvm::Triple::Linux) &&
3281    (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
3282  const char *SplitDwarfOut;
3283  if (SplitDwarf) {
3284    CmdArgs.push_back("-split-dwarf-file");
3285    SplitDwarfOut = SplitDebugName(Args, Inputs);
3286    CmdArgs.push_back(SplitDwarfOut);
3287  }
3288
3289  // Finally add the compile command to the compilation.
3290  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3291
3292  // Handle the debug info splitting at object creation time if we're
3293  // creating an object.
3294  // TODO: Currently only works on linux with newer objcopy.
3295  if (SplitDwarf && !isa<CompileJobAction>(JA))
3296    SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
3297
3298  if (Arg *A = Args.getLastArg(options::OPT_pg))
3299    if (Args.hasArg(options::OPT_fomit_frame_pointer))
3300      D.Diag(diag::err_drv_argument_not_allowed_with)
3301        << "-fomit-frame-pointer" << A->getAsString(Args);
3302
3303  // Claim some arguments which clang supports automatically.
3304
3305  // -fpch-preprocess is used with gcc to add a special marker in the output to
3306  // include the PCH file. Clang's PTH solution is completely transparent, so we
3307  // do not need to deal with it at all.
3308  Args.ClaimAllArgs(options::OPT_fpch_preprocess);
3309
3310  // Claim some arguments which clang doesn't support, but we don't
3311  // care to warn the user about.
3312  Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
3313  Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
3314
3315  // Disable warnings for clang -E -use-gold-plugin -emit-llvm foo.c
3316  Args.ClaimAllArgs(options::OPT_use_gold_plugin);
3317  Args.ClaimAllArgs(options::OPT_emit_llvm);
3318}
3319
3320void ClangAs::AddARMTargetArgs(const ArgList &Args,
3321                               ArgStringList &CmdArgs) const {
3322  const Driver &D = getToolChain().getDriver();
3323  llvm::Triple Triple = getToolChain().getTriple();
3324
3325  // Set the CPU based on -march= and -mcpu=.
3326  CmdArgs.push_back("-target-cpu");
3327  CmdArgs.push_back(Args.MakeArgString(getARMTargetCPU(Args, Triple)));
3328
3329  // Honor -mfpu=.
3330  if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
3331    addFPUArgs(D, A, Args, CmdArgs);
3332
3333  // Honor -mfpmath=.
3334  if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ))
3335    addFPMathArgs(D, A, Args, CmdArgs, getARMTargetCPU(Args, Triple));
3336}
3337
3338void ClangAs::AddX86TargetArgs(const ArgList &Args,
3339                               ArgStringList &CmdArgs) const {
3340  // Set the CPU based on -march=.
3341  if (const char *CPUName = getX86TargetCPU(Args, getToolChain().getTriple())) {
3342    CmdArgs.push_back("-target-cpu");
3343    CmdArgs.push_back(CPUName);
3344  }
3345}
3346
3347/// Add options related to the Objective-C runtime/ABI.
3348///
3349/// Returns true if the runtime is non-fragile.
3350ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
3351                                      ArgStringList &cmdArgs,
3352                                      RewriteKind rewriteKind) const {
3353  // Look for the controlling runtime option.
3354  Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
3355                                    options::OPT_fgnu_runtime,
3356                                    options::OPT_fobjc_runtime_EQ);
3357
3358  // Just forward -fobjc-runtime= to the frontend.  This supercedes
3359  // options about fragility.
3360  if (runtimeArg &&
3361      runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
3362    ObjCRuntime runtime;
3363    StringRef value = runtimeArg->getValue();
3364    if (runtime.tryParse(value)) {
3365      getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
3366        << value;
3367    }
3368
3369    runtimeArg->render(args, cmdArgs);
3370    return runtime;
3371  }
3372
3373  // Otherwise, we'll need the ABI "version".  Version numbers are
3374  // slightly confusing for historical reasons:
3375  //   1 - Traditional "fragile" ABI
3376  //   2 - Non-fragile ABI, version 1
3377  //   3 - Non-fragile ABI, version 2
3378  unsigned objcABIVersion = 1;
3379  // If -fobjc-abi-version= is present, use that to set the version.
3380  if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
3381    StringRef value = abiArg->getValue();
3382    if (value == "1")
3383      objcABIVersion = 1;
3384    else if (value == "2")
3385      objcABIVersion = 2;
3386    else if (value == "3")
3387      objcABIVersion = 3;
3388    else
3389      getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3390        << value;
3391  } else {
3392    // Otherwise, determine if we are using the non-fragile ABI.
3393    bool nonFragileABIIsDefault =
3394      (rewriteKind == RK_NonFragile ||
3395       (rewriteKind == RK_None &&
3396        getToolChain().IsObjCNonFragileABIDefault()));
3397    if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
3398                     options::OPT_fno_objc_nonfragile_abi,
3399                     nonFragileABIIsDefault)) {
3400      // Determine the non-fragile ABI version to use.
3401#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
3402      unsigned nonFragileABIVersion = 1;
3403#else
3404      unsigned nonFragileABIVersion = 2;
3405#endif
3406
3407      if (Arg *abiArg = args.getLastArg(
3408            options::OPT_fobjc_nonfragile_abi_version_EQ)) {
3409        StringRef value = abiArg->getValue();
3410        if (value == "1")
3411          nonFragileABIVersion = 1;
3412        else if (value == "2")
3413          nonFragileABIVersion = 2;
3414        else
3415          getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3416            << value;
3417      }
3418
3419      objcABIVersion = 1 + nonFragileABIVersion;
3420    } else {
3421      objcABIVersion = 1;
3422    }
3423  }
3424
3425  // We don't actually care about the ABI version other than whether
3426  // it's non-fragile.
3427  bool isNonFragile = objcABIVersion != 1;
3428
3429  // If we have no runtime argument, ask the toolchain for its default runtime.
3430  // However, the rewriter only really supports the Mac runtime, so assume that.
3431  ObjCRuntime runtime;
3432  if (!runtimeArg) {
3433    switch (rewriteKind) {
3434    case RK_None:
3435      runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3436      break;
3437    case RK_Fragile:
3438      runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
3439      break;
3440    case RK_NonFragile:
3441      runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3442      break;
3443    }
3444
3445  // -fnext-runtime
3446  } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
3447    // On Darwin, make this use the default behavior for the toolchain.
3448    if (getToolChain().getTriple().isOSDarwin()) {
3449      runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3450
3451    // Otherwise, build for a generic macosx port.
3452    } else {
3453      runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3454    }
3455
3456  // -fgnu-runtime
3457  } else {
3458    assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
3459    // Legacy behaviour is to target the gnustep runtime if we are i
3460    // non-fragile mode or the GCC runtime in fragile mode.
3461    if (isNonFragile)
3462      runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
3463    else
3464      runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
3465  }
3466
3467  cmdArgs.push_back(args.MakeArgString(
3468                                 "-fobjc-runtime=" + runtime.getAsString()));
3469  return runtime;
3470}
3471
3472void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
3473                           const InputInfo &Output,
3474                           const InputInfoList &Inputs,
3475                           const ArgList &Args,
3476                           const char *LinkingOutput) const {
3477  ArgStringList CmdArgs;
3478
3479  assert(Inputs.size() == 1 && "Unexpected number of inputs.");
3480  const InputInfo &Input = Inputs[0];
3481
3482  // Don't warn about "clang -w -c foo.s"
3483  Args.ClaimAllArgs(options::OPT_w);
3484  // and "clang -emit-llvm -c foo.s"
3485  Args.ClaimAllArgs(options::OPT_emit_llvm);
3486  // and "clang -use-gold-plugin -c foo.s"
3487  Args.ClaimAllArgs(options::OPT_use_gold_plugin);
3488
3489  // Invoke ourselves in -cc1as mode.
3490  //
3491  // FIXME: Implement custom jobs for internal actions.
3492  CmdArgs.push_back("-cc1as");
3493
3494  // Add the "effective" target triple.
3495  CmdArgs.push_back("-triple");
3496  std::string TripleStr =
3497    getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
3498  CmdArgs.push_back(Args.MakeArgString(TripleStr));
3499
3500  // Set the output mode, we currently only expect to be used as a real
3501  // assembler.
3502  CmdArgs.push_back("-filetype");
3503  CmdArgs.push_back("obj");
3504
3505  // Set the main file name, so that debug info works even with
3506  // -save-temps or preprocessed assembly.
3507  CmdArgs.push_back("-main-file-name");
3508  CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
3509
3510  if (UseRelaxAll(C, Args))
3511    CmdArgs.push_back("-relax-all");
3512
3513  // Add target specific cpu and features flags.
3514  switch(getToolChain().getTriple().getArch()) {
3515  default:
3516    break;
3517
3518  case llvm::Triple::arm:
3519  case llvm::Triple::thumb:
3520    AddARMTargetArgs(Args, CmdArgs);
3521    break;
3522
3523  case llvm::Triple::x86:
3524  case llvm::Triple::x86_64:
3525    AddX86TargetArgs(Args, CmdArgs);
3526    break;
3527  }
3528
3529  // Ignore explicit -force_cpusubtype_ALL option.
3530  (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
3531
3532  // Determine the original source input.
3533  const Action *SourceAction = &JA;
3534  while (SourceAction->getKind() != Action::InputClass) {
3535    assert(!SourceAction->getInputs().empty() && "unexpected root action!");
3536    SourceAction = SourceAction->getInputs()[0];
3537  }
3538
3539  // Forward -g and handle debug info related flags, assuming we are dealing
3540  // with an actual assembly file.
3541  if (SourceAction->getType() == types::TY_Asm ||
3542      SourceAction->getType() == types::TY_PP_Asm) {
3543    Args.ClaimAllArgs(options::OPT_g_Group);
3544    if (Arg *A = Args.getLastArg(options::OPT_g_Group))
3545      if (!A->getOption().matches(options::OPT_g0))
3546        CmdArgs.push_back("-g");
3547
3548    // Add the -fdebug-compilation-dir flag if needed.
3549    addDebugCompDirArg(Args, CmdArgs);
3550
3551    // Set the AT_producer to the clang version when using the integrated
3552    // assembler on assembly source files.
3553    CmdArgs.push_back("-dwarf-debug-producer");
3554    CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
3555  }
3556
3557  // Optionally embed the -cc1as level arguments into the debug info, for build
3558  // analysis.
3559  if (getToolChain().UseDwarfDebugFlags()) {
3560    ArgStringList OriginalArgs;
3561    for (ArgList::const_iterator it = Args.begin(),
3562           ie = Args.end(); it != ie; ++it)
3563      (*it)->render(Args, OriginalArgs);
3564
3565    SmallString<256> Flags;
3566    const char *Exec = getToolChain().getDriver().getClangProgramPath();
3567    Flags += Exec;
3568    for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
3569      Flags += " ";
3570      Flags += OriginalArgs[i];
3571    }
3572    CmdArgs.push_back("-dwarf-debug-flags");
3573    CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3574  }
3575
3576  // FIXME: Add -static support, once we have it.
3577
3578  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3579                       options::OPT_Xassembler);
3580  Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
3581
3582  assert(Output.isFilename() && "Unexpected lipo output.");
3583  CmdArgs.push_back("-o");
3584  CmdArgs.push_back(Output.getFilename());
3585
3586  assert(Input.isFilename() && "Invalid input.");
3587  CmdArgs.push_back(Input.getFilename());
3588
3589  const char *Exec = getToolChain().getDriver().getClangProgramPath();
3590  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3591}
3592
3593void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
3594                               const InputInfo &Output,
3595                               const InputInfoList &Inputs,
3596                               const ArgList &Args,
3597                               const char *LinkingOutput) const {
3598  const Driver &D = getToolChain().getDriver();
3599  ArgStringList CmdArgs;
3600
3601  for (ArgList::const_iterator
3602         it = Args.begin(), ie = Args.end(); it != ie; ++it) {
3603    Arg *A = *it;
3604    if (forwardToGCC(A->getOption())) {
3605      // Don't forward any -g arguments to assembly steps.
3606      if (isa<AssembleJobAction>(JA) &&
3607          A->getOption().matches(options::OPT_g_Group))
3608        continue;
3609
3610      // It is unfortunate that we have to claim here, as this means
3611      // we will basically never report anything interesting for
3612      // platforms using a generic gcc, even if we are just using gcc
3613      // to get to the assembler.
3614      A->claim();
3615      A->render(Args, CmdArgs);
3616    }
3617  }
3618
3619  RenderExtraToolArgs(JA, CmdArgs);
3620
3621  // If using a driver driver, force the arch.
3622  llvm::Triple::ArchType Arch = getToolChain().getArch();
3623  if (getToolChain().getTriple().isOSDarwin()) {
3624    CmdArgs.push_back("-arch");
3625
3626    // FIXME: Remove these special cases.
3627    if (Arch == llvm::Triple::ppc)
3628      CmdArgs.push_back("ppc");
3629    else if (Arch == llvm::Triple::ppc64)
3630      CmdArgs.push_back("ppc64");
3631    else
3632      CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
3633  }
3634
3635  // Try to force gcc to match the tool chain we want, if we recognize
3636  // the arch.
3637  //
3638  // FIXME: The triple class should directly provide the information we want
3639  // here.
3640  if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
3641    CmdArgs.push_back("-m32");
3642  else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::x86_64)
3643    CmdArgs.push_back("-m64");
3644
3645  if (Output.isFilename()) {
3646    CmdArgs.push_back("-o");
3647    CmdArgs.push_back(Output.getFilename());
3648  } else {
3649    assert(Output.isNothing() && "Unexpected output");
3650    CmdArgs.push_back("-fsyntax-only");
3651  }
3652
3653  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3654                       options::OPT_Xassembler);
3655
3656  // Only pass -x if gcc will understand it; otherwise hope gcc
3657  // understands the suffix correctly. The main use case this would go
3658  // wrong in is for linker inputs if they happened to have an odd
3659  // suffix; really the only way to get this to happen is a command
3660  // like '-x foobar a.c' which will treat a.c like a linker input.
3661  //
3662  // FIXME: For the linker case specifically, can we safely convert
3663  // inputs into '-Wl,' options?
3664  for (InputInfoList::const_iterator
3665         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3666    const InputInfo &II = *it;
3667
3668    // Don't try to pass LLVM or AST inputs to a generic gcc.
3669    if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
3670        II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
3671      D.Diag(diag::err_drv_no_linker_llvm_support)
3672        << getToolChain().getTripleString();
3673    else if (II.getType() == types::TY_AST)
3674      D.Diag(diag::err_drv_no_ast_support)
3675        << getToolChain().getTripleString();
3676
3677    if (types::canTypeBeUserSpecified(II.getType())) {
3678      CmdArgs.push_back("-x");
3679      CmdArgs.push_back(types::getTypeName(II.getType()));
3680    }
3681
3682    if (II.isFilename())
3683      CmdArgs.push_back(II.getFilename());
3684    else {
3685      const Arg &A = II.getInputArg();
3686
3687      // Reverse translate some rewritten options.
3688      if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
3689        CmdArgs.push_back("-lstdc++");
3690        continue;
3691      }
3692
3693      // Don't render as input, we need gcc to do the translations.
3694      A.render(Args, CmdArgs);
3695    }
3696  }
3697
3698  const std::string customGCCName = D.getCCCGenericGCCName();
3699  const char *GCCName;
3700  if (!customGCCName.empty())
3701    GCCName = customGCCName.c_str();
3702  else if (D.CCCIsCXX) {
3703    GCCName = "g++";
3704  } else
3705    GCCName = "gcc";
3706
3707  const char *Exec =
3708    Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
3709  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3710}
3711
3712void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
3713                                          ArgStringList &CmdArgs) const {
3714  CmdArgs.push_back("-E");
3715}
3716
3717void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
3718                                          ArgStringList &CmdArgs) const {
3719  // The type is good enough.
3720}
3721
3722void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
3723                                       ArgStringList &CmdArgs) const {
3724  const Driver &D = getToolChain().getDriver();
3725
3726  // If -flto, etc. are present then make sure not to force assembly output.
3727  if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
3728      JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
3729    CmdArgs.push_back("-c");
3730  else {
3731    if (JA.getType() != types::TY_PP_Asm)
3732      D.Diag(diag::err_drv_invalid_gcc_output_type)
3733        << getTypeName(JA.getType());
3734
3735    CmdArgs.push_back("-S");
3736  }
3737}
3738
3739void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
3740                                        ArgStringList &CmdArgs) const {
3741  CmdArgs.push_back("-c");
3742}
3743
3744void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
3745                                    ArgStringList &CmdArgs) const {
3746  // The types are (hopefully) good enough.
3747}
3748
3749// Hexagon tools start.
3750void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
3751                                        ArgStringList &CmdArgs) const {
3752
3753}
3754void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3755                               const InputInfo &Output,
3756                               const InputInfoList &Inputs,
3757                               const ArgList &Args,
3758                               const char *LinkingOutput) const {
3759
3760  const Driver &D = getToolChain().getDriver();
3761  ArgStringList CmdArgs;
3762
3763  std::string MarchString = "-march=";
3764  MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
3765  CmdArgs.push_back(Args.MakeArgString(MarchString));
3766
3767  RenderExtraToolArgs(JA, CmdArgs);
3768
3769  if (Output.isFilename()) {
3770    CmdArgs.push_back("-o");
3771    CmdArgs.push_back(Output.getFilename());
3772  } else {
3773    assert(Output.isNothing() && "Unexpected output");
3774    CmdArgs.push_back("-fsyntax-only");
3775  }
3776
3777  std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
3778  if (!SmallDataThreshold.empty())
3779    CmdArgs.push_back(
3780      Args.MakeArgString(std::string("-G") + SmallDataThreshold));
3781
3782  Args.AddAllArgs(CmdArgs, options::OPT_g_Group);
3783  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3784                       options::OPT_Xassembler);
3785
3786  // Only pass -x if gcc will understand it; otherwise hope gcc
3787  // understands the suffix correctly. The main use case this would go
3788  // wrong in is for linker inputs if they happened to have an odd
3789  // suffix; really the only way to get this to happen is a command
3790  // like '-x foobar a.c' which will treat a.c like a linker input.
3791  //
3792  // FIXME: For the linker case specifically, can we safely convert
3793  // inputs into '-Wl,' options?
3794  for (InputInfoList::const_iterator
3795         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3796    const InputInfo &II = *it;
3797
3798    // Don't try to pass LLVM or AST inputs to a generic gcc.
3799    if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
3800        II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
3801      D.Diag(clang::diag::err_drv_no_linker_llvm_support)
3802        << getToolChain().getTripleString();
3803    else if (II.getType() == types::TY_AST)
3804      D.Diag(clang::diag::err_drv_no_ast_support)
3805        << getToolChain().getTripleString();
3806
3807    if (II.isFilename())
3808      CmdArgs.push_back(II.getFilename());
3809    else
3810      // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
3811      II.getInputArg().render(Args, CmdArgs);
3812  }
3813
3814  const char *GCCName = "hexagon-as";
3815  const char *Exec =
3816    Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
3817  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3818
3819}
3820void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
3821                                    ArgStringList &CmdArgs) const {
3822  // The types are (hopefully) good enough.
3823}
3824
3825void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
3826                               const InputInfo &Output,
3827                               const InputInfoList &Inputs,
3828                               const ArgList &Args,
3829                               const char *LinkingOutput) const {
3830
3831  const toolchains::Hexagon_TC& ToolChain =
3832    static_cast<const toolchains::Hexagon_TC&>(getToolChain());
3833  const Driver &D = ToolChain.getDriver();
3834
3835  ArgStringList CmdArgs;
3836
3837  //----------------------------------------------------------------------------
3838  //
3839  //----------------------------------------------------------------------------
3840  bool hasStaticArg = Args.hasArg(options::OPT_static);
3841  bool buildingLib = Args.hasArg(options::OPT_shared);
3842  bool buildPIE = Args.hasArg(options::OPT_pie);
3843  bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
3844  bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
3845  bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
3846  bool useShared = buildingLib && !hasStaticArg;
3847
3848  //----------------------------------------------------------------------------
3849  // Silence warnings for various options
3850  //----------------------------------------------------------------------------
3851
3852  Args.ClaimAllArgs(options::OPT_g_Group);
3853  Args.ClaimAllArgs(options::OPT_emit_llvm);
3854  Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
3855                                     // handled somewhere else.
3856  Args.ClaimAllArgs(options::OPT_static_libgcc);
3857
3858  //----------------------------------------------------------------------------
3859  //
3860  //----------------------------------------------------------------------------
3861  for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
3862         e = ToolChain.ExtraOpts.end();
3863       i != e; ++i)
3864    CmdArgs.push_back(i->c_str());
3865
3866  std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
3867  CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
3868
3869  if (buildingLib) {
3870    CmdArgs.push_back("-shared");
3871    CmdArgs.push_back("-call_shared"); // should be the default, but doing as
3872                                       // hexagon-gcc does
3873  }
3874
3875  if (hasStaticArg)
3876    CmdArgs.push_back("-static");
3877
3878  if (buildPIE && !buildingLib)
3879    CmdArgs.push_back("-pie");
3880
3881  std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
3882  if (!SmallDataThreshold.empty()) {
3883    CmdArgs.push_back(
3884      Args.MakeArgString(std::string("-G") + SmallDataThreshold));
3885  }
3886
3887  //----------------------------------------------------------------------------
3888  //
3889  //----------------------------------------------------------------------------
3890  CmdArgs.push_back("-o");
3891  CmdArgs.push_back(Output.getFilename());
3892
3893  const std::string MarchSuffix = "/" + MarchString;
3894  const std::string G0Suffix = "/G0";
3895  const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
3896  const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
3897                              + "/";
3898  const std::string StartFilesDir = RootDir
3899                                    + "hexagon/lib"
3900                                    + (buildingLib
3901                                       ? MarchG0Suffix : MarchSuffix);
3902
3903  //----------------------------------------------------------------------------
3904  // moslib
3905  //----------------------------------------------------------------------------
3906  std::vector<std::string> oslibs;
3907  bool hasStandalone= false;
3908
3909  for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
3910         ie = Args.filtered_end(); it != ie; ++it) {
3911    (*it)->claim();
3912    oslibs.push_back((*it)->getValue());
3913    hasStandalone = hasStandalone || (oslibs.back() == "standalone");
3914  }
3915  if (oslibs.empty()) {
3916    oslibs.push_back("standalone");
3917    hasStandalone = true;
3918  }
3919
3920  //----------------------------------------------------------------------------
3921  // Start Files
3922  //----------------------------------------------------------------------------
3923  if (incStdLib && incStartFiles) {
3924
3925    if (!buildingLib) {
3926      if (hasStandalone) {
3927        CmdArgs.push_back(
3928          Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
3929      }
3930      CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
3931    }
3932    std::string initObj = useShared ? "/initS.o" : "/init.o";
3933    CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
3934  }
3935
3936  //----------------------------------------------------------------------------
3937  // Library Search Paths
3938  //----------------------------------------------------------------------------
3939  const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
3940  for (ToolChain::path_list::const_iterator
3941         i = LibPaths.begin(),
3942         e = LibPaths.end();
3943       i != e;
3944       ++i)
3945    CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
3946
3947  //----------------------------------------------------------------------------
3948  //
3949  //----------------------------------------------------------------------------
3950  Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3951  Args.AddAllArgs(CmdArgs, options::OPT_e);
3952  Args.AddAllArgs(CmdArgs, options::OPT_s);
3953  Args.AddAllArgs(CmdArgs, options::OPT_t);
3954  Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
3955
3956  AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
3957
3958  //----------------------------------------------------------------------------
3959  // Libraries
3960  //----------------------------------------------------------------------------
3961  if (incStdLib && incDefLibs) {
3962    if (D.CCCIsCXX) {
3963      ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
3964      CmdArgs.push_back("-lm");
3965    }
3966
3967    CmdArgs.push_back("--start-group");
3968
3969    if (!buildingLib) {
3970      for(std::vector<std::string>::iterator i = oslibs.begin(),
3971            e = oslibs.end(); i != e; ++i)
3972        CmdArgs.push_back(Args.MakeArgString("-l" + *i));
3973      CmdArgs.push_back("-lc");
3974    }
3975    CmdArgs.push_back("-lgcc");
3976
3977    CmdArgs.push_back("--end-group");
3978  }
3979
3980  //----------------------------------------------------------------------------
3981  // End files
3982  //----------------------------------------------------------------------------
3983  if (incStdLib && incStartFiles) {
3984    std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
3985    CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
3986  }
3987
3988  std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
3989  C.addCommand(
3990    new Command(
3991      JA, *this,
3992      Args.MakeArgString(Linker), CmdArgs));
3993}
3994// Hexagon tools end.
3995
3996llvm::Triple::ArchType darwin::getArchTypeForDarwinArchName(StringRef Str) {
3997  // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
3998  // archs which Darwin doesn't use.
3999
4000  // The matching this routine does is fairly pointless, since it is neither the
4001  // complete architecture list, nor a reasonable subset. The problem is that
4002  // historically the driver driver accepts this and also ties its -march=
4003  // handling to the architecture name, so we need to be careful before removing
4004  // support for it.
4005
4006  // This code must be kept in sync with Clang's Darwin specific argument
4007  // translation.
4008
4009  return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
4010    .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
4011    .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
4012    .Case("ppc64", llvm::Triple::ppc64)
4013    .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
4014    .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
4015           llvm::Triple::x86)
4016    .Case("x86_64", llvm::Triple::x86_64)
4017    // This is derived from the driver driver.
4018    .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
4019    .Cases("armv7", "armv7em", "armv7f", "armv7k", "armv7m", llvm::Triple::arm)
4020    .Cases("armv7s", "xscale", llvm::Triple::arm)
4021    .Case("r600", llvm::Triple::r600)
4022    .Case("nvptx", llvm::Triple::nvptx)
4023    .Case("nvptx64", llvm::Triple::nvptx64)
4024    .Case("amdil", llvm::Triple::amdil)
4025    .Case("spir", llvm::Triple::spir)
4026    .Default(llvm::Triple::UnknownArch);
4027}
4028
4029const char *Clang::getBaseInputName(const ArgList &Args,
4030                                    const InputInfoList &Inputs) {
4031  return Args.MakeArgString(
4032    llvm::sys::path::filename(Inputs[0].getBaseInput()));
4033}
4034
4035const char *Clang::getBaseInputStem(const ArgList &Args,
4036                                    const InputInfoList &Inputs) {
4037  const char *Str = getBaseInputName(Args, Inputs);
4038
4039  if (const char *End = strrchr(Str, '.'))
4040    return Args.MakeArgString(std::string(Str, End));
4041
4042  return Str;
4043}
4044
4045const char *Clang::getDependencyFileName(const ArgList &Args,
4046                                         const InputInfoList &Inputs) {
4047  // FIXME: Think about this more.
4048  std::string Res;
4049
4050  if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
4051    std::string Str(OutputOpt->getValue());
4052    Res = Str.substr(0, Str.rfind('.'));
4053  } else {
4054    Res = getBaseInputStem(Args, Inputs);
4055  }
4056  return Args.MakeArgString(Res + ".d");
4057}
4058
4059void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4060                                    const InputInfo &Output,
4061                                    const InputInfoList &Inputs,
4062                                    const ArgList &Args,
4063                                    const char *LinkingOutput) const {
4064  ArgStringList CmdArgs;
4065
4066  assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4067  const InputInfo &Input = Inputs[0];
4068
4069  // Determine the original source input.
4070  const Action *SourceAction = &JA;
4071  while (SourceAction->getKind() != Action::InputClass) {
4072    assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4073    SourceAction = SourceAction->getInputs()[0];
4074  }
4075
4076  // Forward -g, assuming we are dealing with an actual assembly file.
4077  if (SourceAction->getType() == types::TY_Asm ||
4078      SourceAction->getType() == types::TY_PP_Asm) {
4079    if (Args.hasArg(options::OPT_gstabs))
4080      CmdArgs.push_back("--gstabs");
4081    else if (Args.hasArg(options::OPT_g_Group))
4082      CmdArgs.push_back("-g");
4083  }
4084
4085  // Derived from asm spec.
4086  AddDarwinArch(Args, CmdArgs);
4087
4088  // Use -force_cpusubtype_ALL on x86 by default.
4089  if (getToolChain().getTriple().getArch() == llvm::Triple::x86 ||
4090      getToolChain().getTriple().getArch() == llvm::Triple::x86_64 ||
4091      Args.hasArg(options::OPT_force__cpusubtype__ALL))
4092    CmdArgs.push_back("-force_cpusubtype_ALL");
4093
4094  if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 &&
4095      (((Args.hasArg(options::OPT_mkernel) ||
4096         Args.hasArg(options::OPT_fapple_kext)) &&
4097        (!getDarwinToolChain().isTargetIPhoneOS() ||
4098         getDarwinToolChain().isIPhoneOSVersionLT(6, 0))) ||
4099       Args.hasArg(options::OPT_static)))
4100    CmdArgs.push_back("-static");
4101
4102  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4103                       options::OPT_Xassembler);
4104
4105  assert(Output.isFilename() && "Unexpected lipo output.");
4106  CmdArgs.push_back("-o");
4107  CmdArgs.push_back(Output.getFilename());
4108
4109  assert(Input.isFilename() && "Invalid input.");
4110  CmdArgs.push_back(Input.getFilename());
4111
4112  // asm_final spec is empty.
4113
4114  const char *Exec =
4115    Args.MakeArgString(getToolChain().GetProgramPath("as"));
4116  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4117}
4118
4119void darwin::DarwinTool::anchor() {}
4120
4121void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
4122                                       ArgStringList &CmdArgs) const {
4123  StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
4124
4125  // Derived from darwin_arch spec.
4126  CmdArgs.push_back("-arch");
4127  CmdArgs.push_back(Args.MakeArgString(ArchName));
4128
4129  // FIXME: Is this needed anymore?
4130  if (ArchName == "arm")
4131    CmdArgs.push_back("-force_cpusubtype_ALL");
4132}
4133
4134bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
4135  // We only need to generate a temp path for LTO if we aren't compiling object
4136  // files. When compiling source files, we run 'dsymutil' after linking. We
4137  // don't run 'dsymutil' when compiling object files.
4138  for (InputInfoList::const_iterator
4139         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
4140    if (it->getType() != types::TY_Object)
4141      return true;
4142
4143  return false;
4144}
4145
4146void darwin::Link::AddLinkArgs(Compilation &C,
4147                               const ArgList &Args,
4148                               ArgStringList &CmdArgs,
4149                               const InputInfoList &Inputs) const {
4150  const Driver &D = getToolChain().getDriver();
4151  const toolchains::Darwin &DarwinTC = getDarwinToolChain();
4152
4153  unsigned Version[3] = { 0, 0, 0 };
4154  if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
4155    bool HadExtra;
4156    if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
4157                                   Version[1], Version[2], HadExtra) ||
4158        HadExtra)
4159      D.Diag(diag::err_drv_invalid_version_number)
4160        << A->getAsString(Args);
4161  }
4162
4163  // Newer linkers support -demangle, pass it if supported and not disabled by
4164  // the user.
4165  if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) {
4166    // Don't pass -demangle to ld_classic.
4167    //
4168    // FIXME: This is a temporary workaround, ld should be handling this.
4169    bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
4170                          Args.hasArg(options::OPT_static));
4171    if (getToolChain().getArch() == llvm::Triple::x86) {
4172      for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
4173                                                 options::OPT_Wl_COMMA),
4174             ie = Args.filtered_end(); it != ie; ++it) {
4175        const Arg *A = *it;
4176        for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
4177          if (StringRef(A->getValue(i)) == "-kext")
4178            UsesLdClassic = true;
4179      }
4180    }
4181    if (!UsesLdClassic)
4182      CmdArgs.push_back("-demangle");
4183  }
4184
4185  // If we are using LTO, then automatically create a temporary file path for
4186  // the linker to use, so that it's lifetime will extend past a possible
4187  // dsymutil step.
4188  if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
4189    const char *TmpPath = C.getArgs().MakeArgString(
4190      D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
4191    C.addTempFile(TmpPath);
4192    CmdArgs.push_back("-object_path_lto");
4193    CmdArgs.push_back(TmpPath);
4194  }
4195
4196  // Derived from the "link" spec.
4197  Args.AddAllArgs(CmdArgs, options::OPT_static);
4198  if (!Args.hasArg(options::OPT_static))
4199    CmdArgs.push_back("-dynamic");
4200  if (Args.hasArg(options::OPT_fgnu_runtime)) {
4201    // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
4202    // here. How do we wish to handle such things?
4203  }
4204
4205  if (!Args.hasArg(options::OPT_dynamiclib)) {
4206    AddDarwinArch(Args, CmdArgs);
4207    // FIXME: Why do this only on this path?
4208    Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
4209
4210    Args.AddLastArg(CmdArgs, options::OPT_bundle);
4211    Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
4212    Args.AddAllArgs(CmdArgs, options::OPT_client__name);
4213
4214    Arg *A;
4215    if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
4216        (A = Args.getLastArg(options::OPT_current__version)) ||
4217        (A = Args.getLastArg(options::OPT_install__name)))
4218      D.Diag(diag::err_drv_argument_only_allowed_with)
4219        << A->getAsString(Args) << "-dynamiclib";
4220
4221    Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
4222    Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
4223    Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
4224  } else {
4225    CmdArgs.push_back("-dylib");
4226
4227    Arg *A;
4228    if ((A = Args.getLastArg(options::OPT_bundle)) ||
4229        (A = Args.getLastArg(options::OPT_bundle__loader)) ||
4230        (A = Args.getLastArg(options::OPT_client__name)) ||
4231        (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
4232        (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
4233        (A = Args.getLastArg(options::OPT_private__bundle)))
4234      D.Diag(diag::err_drv_argument_not_allowed_with)
4235        << A->getAsString(Args) << "-dynamiclib";
4236
4237    Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
4238                              "-dylib_compatibility_version");
4239    Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
4240                              "-dylib_current_version");
4241
4242    AddDarwinArch(Args, CmdArgs);
4243
4244    Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
4245                              "-dylib_install_name");
4246  }
4247
4248  Args.AddLastArg(CmdArgs, options::OPT_all__load);
4249  Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
4250  Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
4251  if (DarwinTC.isTargetIPhoneOS())
4252    Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
4253  Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
4254  Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
4255  Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
4256  Args.AddLastArg(CmdArgs, options::OPT_dynamic);
4257  Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
4258  Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
4259  Args.AddAllArgs(CmdArgs, options::OPT_force__load);
4260  Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
4261  Args.AddAllArgs(CmdArgs, options::OPT_image__base);
4262  Args.AddAllArgs(CmdArgs, options::OPT_init);
4263
4264  // Add the deployment target.
4265  VersionTuple TargetVersion = DarwinTC.getTargetVersion();
4266
4267  // If we had an explicit -mios-simulator-version-min argument, honor that,
4268  // otherwise use the traditional deployment targets. We can't just check the
4269  // is-sim attribute because existing code follows this path, and the linker
4270  // may not handle the argument.
4271  //
4272  // FIXME: We may be able to remove this, once we can verify no one depends on
4273  // it.
4274  if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
4275    CmdArgs.push_back("-ios_simulator_version_min");
4276  else if (DarwinTC.isTargetIPhoneOS())
4277    CmdArgs.push_back("-iphoneos_version_min");
4278  else
4279    CmdArgs.push_back("-macosx_version_min");
4280  CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
4281
4282  Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
4283  Args.AddLastArg(CmdArgs, options::OPT_multi__module);
4284  Args.AddLastArg(CmdArgs, options::OPT_single__module);
4285  Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
4286  Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
4287
4288  if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
4289                                     options::OPT_fno_pie,
4290                                     options::OPT_fno_PIE)) {
4291    if (A->getOption().matches(options::OPT_fpie) ||
4292        A->getOption().matches(options::OPT_fPIE))
4293      CmdArgs.push_back("-pie");
4294    else
4295      CmdArgs.push_back("-no_pie");
4296  }
4297
4298  Args.AddLastArg(CmdArgs, options::OPT_prebind);
4299  Args.AddLastArg(CmdArgs, options::OPT_noprebind);
4300  Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
4301  Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
4302  Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
4303  Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
4304  Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
4305  Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
4306  Args.AddAllArgs(CmdArgs, options::OPT_segprot);
4307  Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
4308  Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
4309  Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
4310  Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
4311  Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
4312  Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
4313  Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
4314
4315  // Give --sysroot= preference, over the Apple specific behavior to also use
4316  // --isysroot as the syslibroot.
4317  StringRef sysroot = C.getSysRoot();
4318  if (sysroot != "") {
4319    CmdArgs.push_back("-syslibroot");
4320    CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
4321  } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
4322    CmdArgs.push_back("-syslibroot");
4323    CmdArgs.push_back(A->getValue());
4324  }
4325
4326  Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
4327  Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
4328  Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
4329  Args.AddAllArgs(CmdArgs, options::OPT_undefined);
4330  Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
4331  Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
4332  Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
4333  Args.AddAllArgs(CmdArgs, options::OPT_y);
4334  Args.AddLastArg(CmdArgs, options::OPT_w);
4335  Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
4336  Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
4337  Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
4338  Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
4339  Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
4340  Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
4341  Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
4342  Args.AddLastArg(CmdArgs, options::OPT_whyload);
4343  Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
4344  Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
4345  Args.AddLastArg(CmdArgs, options::OPT_dylinker);
4346  Args.AddLastArg(CmdArgs, options::OPT_Mach);
4347}
4348
4349void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
4350                                const InputInfo &Output,
4351                                const InputInfoList &Inputs,
4352                                const ArgList &Args,
4353                                const char *LinkingOutput) const {
4354  assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
4355
4356  // The logic here is derived from gcc's behavior; most of which
4357  // comes from specs (starting with link_command). Consult gcc for
4358  // more information.
4359  ArgStringList CmdArgs;
4360
4361  /// Hack(tm) to ignore linking errors when we are doing ARC migration.
4362  if (Args.hasArg(options::OPT_ccc_arcmt_check,
4363                  options::OPT_ccc_arcmt_migrate)) {
4364    for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
4365      (*I)->claim();
4366    const char *Exec =
4367      Args.MakeArgString(getToolChain().GetProgramPath("touch"));
4368    CmdArgs.push_back(Output.getFilename());
4369    C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4370    return;
4371  }
4372
4373  // I'm not sure why this particular decomposition exists in gcc, but
4374  // we follow suite for ease of comparison.
4375  AddLinkArgs(C, Args, CmdArgs, Inputs);
4376
4377  Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
4378  Args.AddAllArgs(CmdArgs, options::OPT_s);
4379  Args.AddAllArgs(CmdArgs, options::OPT_t);
4380  Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4381  Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4382  Args.AddLastArg(CmdArgs, options::OPT_e);
4383  Args.AddAllArgs(CmdArgs, options::OPT_m_Separate);
4384  Args.AddAllArgs(CmdArgs, options::OPT_r);
4385
4386  // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
4387  // members of static archive libraries which implement Objective-C classes or
4388  // categories.
4389  if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
4390    CmdArgs.push_back("-ObjC");
4391
4392  if (Args.hasArg(options::OPT_rdynamic))
4393    CmdArgs.push_back("-export_dynamic");
4394
4395  CmdArgs.push_back("-o");
4396  CmdArgs.push_back(Output.getFilename());
4397
4398  if (!Args.hasArg(options::OPT_nostdlib) &&
4399      !Args.hasArg(options::OPT_nostartfiles)) {
4400    // Derived from startfile spec.
4401    if (Args.hasArg(options::OPT_dynamiclib)) {
4402      // Derived from darwin_dylib1 spec.
4403      if (getDarwinToolChain().isTargetIOSSimulator()) {
4404        // The simulator doesn't have a versioned crt1 file.
4405        CmdArgs.push_back("-ldylib1.o");
4406      } else if (getDarwinToolChain().isTargetIPhoneOS()) {
4407        if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4408          CmdArgs.push_back("-ldylib1.o");
4409      } else {
4410        if (getDarwinToolChain().isMacosxVersionLT(10, 5))
4411          CmdArgs.push_back("-ldylib1.o");
4412        else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4413          CmdArgs.push_back("-ldylib1.10.5.o");
4414      }
4415    } else {
4416      if (Args.hasArg(options::OPT_bundle)) {
4417        if (!Args.hasArg(options::OPT_static)) {
4418          // Derived from darwin_bundle1 spec.
4419          if (getDarwinToolChain().isTargetIOSSimulator()) {
4420            // The simulator doesn't have a versioned crt1 file.
4421            CmdArgs.push_back("-lbundle1.o");
4422          } else if (getDarwinToolChain().isTargetIPhoneOS()) {
4423            if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4424              CmdArgs.push_back("-lbundle1.o");
4425          } else {
4426            if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4427              CmdArgs.push_back("-lbundle1.o");
4428          }
4429        }
4430      } else {
4431        if (Args.hasArg(options::OPT_pg) &&
4432            getToolChain().SupportsProfiling()) {
4433          if (Args.hasArg(options::OPT_static) ||
4434              Args.hasArg(options::OPT_object) ||
4435              Args.hasArg(options::OPT_preload)) {
4436            CmdArgs.push_back("-lgcrt0.o");
4437          } else {
4438            CmdArgs.push_back("-lgcrt1.o");
4439
4440            // darwin_crt2 spec is empty.
4441          }
4442          // By default on OS X 10.8 and later, we don't link with a crt1.o
4443          // file and the linker knows to use _main as the entry point.  But,
4444          // when compiling with -pg, we need to link with the gcrt1.o file,
4445          // so pass the -no_new_main option to tell the linker to use the
4446          // "start" symbol as the entry point.
4447          if (getDarwinToolChain().isTargetMacOS() &&
4448              !getDarwinToolChain().isMacosxVersionLT(10, 8))
4449            CmdArgs.push_back("-no_new_main");
4450        } else {
4451          if (Args.hasArg(options::OPT_static) ||
4452              Args.hasArg(options::OPT_object) ||
4453              Args.hasArg(options::OPT_preload)) {
4454            CmdArgs.push_back("-lcrt0.o");
4455          } else {
4456            // Derived from darwin_crt1 spec.
4457            if (getDarwinToolChain().isTargetIOSSimulator()) {
4458              // The simulator doesn't have a versioned crt1 file.
4459              CmdArgs.push_back("-lcrt1.o");
4460            } else if (getDarwinToolChain().isTargetIPhoneOS()) {
4461              if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4462                CmdArgs.push_back("-lcrt1.o");
4463              else if (getDarwinToolChain().isIPhoneOSVersionLT(6, 0))
4464                CmdArgs.push_back("-lcrt1.3.1.o");
4465            } else {
4466              if (getDarwinToolChain().isMacosxVersionLT(10, 5))
4467                CmdArgs.push_back("-lcrt1.o");
4468              else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4469                CmdArgs.push_back("-lcrt1.10.5.o");
4470              else if (getDarwinToolChain().isMacosxVersionLT(10, 8))
4471                CmdArgs.push_back("-lcrt1.10.6.o");
4472
4473              // darwin_crt2 spec is empty.
4474            }
4475          }
4476        }
4477      }
4478    }
4479
4480    if (!getDarwinToolChain().isTargetIPhoneOS() &&
4481        Args.hasArg(options::OPT_shared_libgcc) &&
4482        getDarwinToolChain().isMacosxVersionLT(10, 5)) {
4483      const char *Str =
4484        Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
4485      CmdArgs.push_back(Str);
4486    }
4487  }
4488
4489  Args.AddAllArgs(CmdArgs, options::OPT_L);
4490
4491  SanitizerArgs Sanitize(getToolChain().getDriver(), Args);
4492  // If we're building a dynamic lib with -fsanitize=address,
4493  // unresolved symbols may appear. Mark all
4494  // of them as dynamic_lookup. Linking executables is handled in
4495  // lib/Driver/ToolChains.cpp.
4496  if (Sanitize.needsAsanRt()) {
4497    if (Args.hasArg(options::OPT_dynamiclib) ||
4498        Args.hasArg(options::OPT_bundle)) {
4499      CmdArgs.push_back("-undefined");
4500      CmdArgs.push_back("dynamic_lookup");
4501    }
4502  }
4503
4504  if (Args.hasArg(options::OPT_fopenmp))
4505    // This is more complicated in gcc...
4506    CmdArgs.push_back("-lgomp");
4507
4508  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4509
4510  if (isObjCRuntimeLinked(Args) &&
4511      !Args.hasArg(options::OPT_nostdlib) &&
4512      !Args.hasArg(options::OPT_nodefaultlibs)) {
4513    // Avoid linking compatibility stubs on i386 mac.
4514    if (!getDarwinToolChain().isTargetMacOS() ||
4515        getDarwinToolChain().getArch() != llvm::Triple::x86) {
4516      // If we don't have ARC or subscripting runtime support, link in the
4517      // runtime stubs.  We have to do this *before* adding any of the normal
4518      // linker inputs so that its initializer gets run first.
4519      ObjCRuntime runtime =
4520        getDarwinToolChain().getDefaultObjCRuntime(/*nonfragile*/ true);
4521      // We use arclite library for both ARC and subscripting support.
4522      if ((!runtime.hasNativeARC() && isObjCAutoRefCount(Args)) ||
4523          !runtime.hasSubscripting())
4524        getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs);
4525    }
4526    CmdArgs.push_back("-framework");
4527    CmdArgs.push_back("Foundation");
4528    // Link libobj.
4529    CmdArgs.push_back("-lobjc");
4530  }
4531
4532  if (LinkingOutput) {
4533    CmdArgs.push_back("-arch_multiple");
4534    CmdArgs.push_back("-final_output");
4535    CmdArgs.push_back(LinkingOutput);
4536  }
4537
4538  if (Args.hasArg(options::OPT_fnested_functions))
4539    CmdArgs.push_back("-allow_stack_execute");
4540
4541  if (!Args.hasArg(options::OPT_nostdlib) &&
4542      !Args.hasArg(options::OPT_nodefaultlibs)) {
4543    if (getToolChain().getDriver().CCCIsCXX)
4544      getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
4545
4546    // link_ssp spec is empty.
4547
4548    // Let the tool chain choose which runtime library to link.
4549    getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
4550  }
4551
4552  if (!Args.hasArg(options::OPT_nostdlib) &&
4553      !Args.hasArg(options::OPT_nostartfiles)) {
4554    // endfile_spec is empty.
4555  }
4556
4557  Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4558  Args.AddAllArgs(CmdArgs, options::OPT_F);
4559
4560  const char *Exec =
4561    Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4562  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4563}
4564
4565void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
4566                                const InputInfo &Output,
4567                                const InputInfoList &Inputs,
4568                                const ArgList &Args,
4569                                const char *LinkingOutput) const {
4570  ArgStringList CmdArgs;
4571
4572  CmdArgs.push_back("-create");
4573  assert(Output.isFilename() && "Unexpected lipo output.");
4574
4575  CmdArgs.push_back("-output");
4576  CmdArgs.push_back(Output.getFilename());
4577
4578  for (InputInfoList::const_iterator
4579         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4580    const InputInfo &II = *it;
4581    assert(II.isFilename() && "Unexpected lipo input.");
4582    CmdArgs.push_back(II.getFilename());
4583  }
4584  const char *Exec =
4585    Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
4586  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4587}
4588
4589void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
4590                                    const InputInfo &Output,
4591                                    const InputInfoList &Inputs,
4592                                    const ArgList &Args,
4593                                    const char *LinkingOutput) const {
4594  ArgStringList CmdArgs;
4595
4596  CmdArgs.push_back("-o");
4597  CmdArgs.push_back(Output.getFilename());
4598
4599  assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
4600  const InputInfo &Input = Inputs[0];
4601  assert(Input.isFilename() && "Unexpected dsymutil input.");
4602  CmdArgs.push_back(Input.getFilename());
4603
4604  const char *Exec =
4605    Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
4606  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4607}
4608
4609void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
4610                                       const InputInfo &Output,
4611                                       const InputInfoList &Inputs,
4612                                       const ArgList &Args,
4613                                       const char *LinkingOutput) const {
4614  ArgStringList CmdArgs;
4615  CmdArgs.push_back("--verify");
4616  CmdArgs.push_back("--debug-info");
4617  CmdArgs.push_back("--eh-frame");
4618  CmdArgs.push_back("--quiet");
4619
4620  assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
4621  const InputInfo &Input = Inputs[0];
4622  assert(Input.isFilename() && "Unexpected verify input");
4623
4624  // Grabbing the output of the earlier dsymutil run.
4625  CmdArgs.push_back(Input.getFilename());
4626
4627  const char *Exec =
4628    Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
4629  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4630}
4631
4632void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4633                                      const InputInfo &Output,
4634                                      const InputInfoList &Inputs,
4635                                      const ArgList &Args,
4636                                      const char *LinkingOutput) const {
4637  ArgStringList CmdArgs;
4638
4639  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4640                       options::OPT_Xassembler);
4641
4642  CmdArgs.push_back("-o");
4643  CmdArgs.push_back(Output.getFilename());
4644
4645  for (InputInfoList::const_iterator
4646         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4647    const InputInfo &II = *it;
4648    CmdArgs.push_back(II.getFilename());
4649  }
4650
4651  const char *Exec =
4652    Args.MakeArgString(getToolChain().GetProgramPath("as"));
4653  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4654}
4655
4656
4657void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
4658                                  const InputInfo &Output,
4659                                  const InputInfoList &Inputs,
4660                                  const ArgList &Args,
4661                                  const char *LinkingOutput) const {
4662  // FIXME: Find a real GCC, don't hard-code versions here
4663  std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
4664  const llvm::Triple &T = getToolChain().getTriple();
4665  std::string LibPath = "/usr/lib/";
4666  llvm::Triple::ArchType Arch = T.getArch();
4667  switch (Arch) {
4668        case llvm::Triple::x86:
4669          GCCLibPath += ("i386-" + T.getVendorName() + "-" +
4670              T.getOSName()).str() + "/4.5.2/";
4671          break;
4672        case llvm::Triple::x86_64:
4673          GCCLibPath += ("i386-" + T.getVendorName() + "-" +
4674              T.getOSName()).str();
4675          GCCLibPath += "/4.5.2/amd64/";
4676          LibPath += "amd64/";
4677          break;
4678        default:
4679          assert(0 && "Unsupported architecture");
4680  }
4681
4682  ArgStringList CmdArgs;
4683
4684  // Demangle C++ names in errors
4685  CmdArgs.push_back("-C");
4686
4687  if ((!Args.hasArg(options::OPT_nostdlib)) &&
4688      (!Args.hasArg(options::OPT_shared))) {
4689    CmdArgs.push_back("-e");
4690    CmdArgs.push_back("_start");
4691  }
4692
4693  if (Args.hasArg(options::OPT_static)) {
4694    CmdArgs.push_back("-Bstatic");
4695    CmdArgs.push_back("-dn");
4696  } else {
4697    CmdArgs.push_back("-Bdynamic");
4698    if (Args.hasArg(options::OPT_shared)) {
4699      CmdArgs.push_back("-shared");
4700    } else {
4701      CmdArgs.push_back("--dynamic-linker");
4702      CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
4703    }
4704  }
4705
4706  if (Output.isFilename()) {
4707    CmdArgs.push_back("-o");
4708    CmdArgs.push_back(Output.getFilename());
4709  } else {
4710    assert(Output.isNothing() && "Invalid output.");
4711  }
4712
4713  if (!Args.hasArg(options::OPT_nostdlib) &&
4714      !Args.hasArg(options::OPT_nostartfiles)) {
4715    if (!Args.hasArg(options::OPT_shared)) {
4716      CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
4717      CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
4718      CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
4719      CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
4720    } else {
4721      CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
4722      CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
4723      CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
4724    }
4725    if (getToolChain().getDriver().CCCIsCXX)
4726      CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
4727  }
4728
4729  CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
4730
4731  Args.AddAllArgs(CmdArgs, options::OPT_L);
4732  Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4733  Args.AddAllArgs(CmdArgs, options::OPT_e);
4734  Args.AddAllArgs(CmdArgs, options::OPT_r);
4735
4736  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4737
4738  if (!Args.hasArg(options::OPT_nostdlib) &&
4739      !Args.hasArg(options::OPT_nodefaultlibs)) {
4740    if (getToolChain().getDriver().CCCIsCXX)
4741      getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
4742    CmdArgs.push_back("-lgcc_s");
4743    if (!Args.hasArg(options::OPT_shared)) {
4744      CmdArgs.push_back("-lgcc");
4745      CmdArgs.push_back("-lc");
4746      CmdArgs.push_back("-lm");
4747    }
4748  }
4749
4750  if (!Args.hasArg(options::OPT_nostdlib) &&
4751      !Args.hasArg(options::OPT_nostartfiles)) {
4752    CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
4753  }
4754  CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
4755
4756  addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4757
4758  const char *Exec =
4759    Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4760  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4761}
4762
4763void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4764                                      const InputInfo &Output,
4765                                      const InputInfoList &Inputs,
4766                                      const ArgList &Args,
4767                                      const char *LinkingOutput) const {
4768  ArgStringList CmdArgs;
4769
4770  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4771                       options::OPT_Xassembler);
4772
4773  CmdArgs.push_back("-o");
4774  CmdArgs.push_back(Output.getFilename());
4775
4776  for (InputInfoList::const_iterator
4777         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4778    const InputInfo &II = *it;
4779    CmdArgs.push_back(II.getFilename());
4780  }
4781
4782  const char *Exec =
4783    Args.MakeArgString(getToolChain().GetProgramPath("gas"));
4784  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4785}
4786
4787void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
4788                                  const InputInfo &Output,
4789                                  const InputInfoList &Inputs,
4790                                  const ArgList &Args,
4791                                  const char *LinkingOutput) const {
4792  ArgStringList CmdArgs;
4793
4794  if ((!Args.hasArg(options::OPT_nostdlib)) &&
4795      (!Args.hasArg(options::OPT_shared))) {
4796    CmdArgs.push_back("-e");
4797    CmdArgs.push_back("_start");
4798  }
4799
4800  if (Args.hasArg(options::OPT_static)) {
4801    CmdArgs.push_back("-Bstatic");
4802    CmdArgs.push_back("-dn");
4803  } else {
4804//    CmdArgs.push_back("--eh-frame-hdr");
4805    CmdArgs.push_back("-Bdynamic");
4806    if (Args.hasArg(options::OPT_shared)) {
4807      CmdArgs.push_back("-shared");
4808    } else {
4809      CmdArgs.push_back("--dynamic-linker");
4810      CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
4811    }
4812  }
4813
4814  if (Output.isFilename()) {
4815    CmdArgs.push_back("-o");
4816    CmdArgs.push_back(Output.getFilename());
4817  } else {
4818    assert(Output.isNothing() && "Invalid output.");
4819  }
4820
4821  if (!Args.hasArg(options::OPT_nostdlib) &&
4822      !Args.hasArg(options::OPT_nostartfiles)) {
4823    if (!Args.hasArg(options::OPT_shared)) {
4824      CmdArgs.push_back(Args.MakeArgString(
4825                                getToolChain().GetFilePath("crt1.o")));
4826      CmdArgs.push_back(Args.MakeArgString(
4827                                getToolChain().GetFilePath("crti.o")));
4828      CmdArgs.push_back(Args.MakeArgString(
4829                                getToolChain().GetFilePath("crtbegin.o")));
4830    } else {
4831      CmdArgs.push_back(Args.MakeArgString(
4832                                getToolChain().GetFilePath("crti.o")));
4833    }
4834    CmdArgs.push_back(Args.MakeArgString(
4835                                getToolChain().GetFilePath("crtn.o")));
4836  }
4837
4838  CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
4839                                       + getToolChain().getTripleString()
4840                                       + "/4.2.4"));
4841
4842  Args.AddAllArgs(CmdArgs, options::OPT_L);
4843  Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4844  Args.AddAllArgs(CmdArgs, options::OPT_e);
4845
4846  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4847
4848  if (!Args.hasArg(options::OPT_nostdlib) &&
4849      !Args.hasArg(options::OPT_nodefaultlibs)) {
4850    // FIXME: For some reason GCC passes -lgcc before adding
4851    // the default system libraries. Just mimic this for now.
4852    CmdArgs.push_back("-lgcc");
4853
4854    if (Args.hasArg(options::OPT_pthread))
4855      CmdArgs.push_back("-pthread");
4856    if (!Args.hasArg(options::OPT_shared))
4857      CmdArgs.push_back("-lc");
4858    CmdArgs.push_back("-lgcc");
4859  }
4860
4861  if (!Args.hasArg(options::OPT_nostdlib) &&
4862      !Args.hasArg(options::OPT_nostartfiles)) {
4863    if (!Args.hasArg(options::OPT_shared))
4864      CmdArgs.push_back(Args.MakeArgString(
4865                                getToolChain().GetFilePath("crtend.o")));
4866  }
4867
4868  addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4869
4870  const char *Exec =
4871    Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4872  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4873}
4874
4875void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4876                                     const InputInfo &Output,
4877                                     const InputInfoList &Inputs,
4878                                     const ArgList &Args,
4879                                     const char *LinkingOutput) const {
4880  ArgStringList CmdArgs;
4881
4882  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4883                       options::OPT_Xassembler);
4884
4885  CmdArgs.push_back("-o");
4886  CmdArgs.push_back(Output.getFilename());
4887
4888  for (InputInfoList::const_iterator
4889         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4890    const InputInfo &II = *it;
4891    CmdArgs.push_back(II.getFilename());
4892  }
4893
4894  const char *Exec =
4895    Args.MakeArgString(getToolChain().GetProgramPath("as"));
4896  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4897}
4898
4899void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
4900                                 const InputInfo &Output,
4901                                 const InputInfoList &Inputs,
4902                                 const ArgList &Args,
4903                                 const char *LinkingOutput) const {
4904  const Driver &D = getToolChain().getDriver();
4905  ArgStringList CmdArgs;
4906
4907  // Silence warning for "clang -g foo.o -o foo"
4908  Args.ClaimAllArgs(options::OPT_g_Group);
4909  // and "clang -emit-llvm foo.o -o foo"
4910  Args.ClaimAllArgs(options::OPT_emit_llvm);
4911  // and for "clang -w foo.o -o foo". Other warning options are already
4912  // handled somewhere else.
4913  Args.ClaimAllArgs(options::OPT_w);
4914
4915  if ((!Args.hasArg(options::OPT_nostdlib)) &&
4916      (!Args.hasArg(options::OPT_shared))) {
4917    CmdArgs.push_back("-e");
4918    CmdArgs.push_back("__start");
4919  }
4920
4921  if (Args.hasArg(options::OPT_static)) {
4922    CmdArgs.push_back("-Bstatic");
4923  } else {
4924    if (Args.hasArg(options::OPT_rdynamic))
4925      CmdArgs.push_back("-export-dynamic");
4926    CmdArgs.push_back("--eh-frame-hdr");
4927    CmdArgs.push_back("-Bdynamic");
4928    if (Args.hasArg(options::OPT_shared)) {
4929      CmdArgs.push_back("-shared");
4930    } else {
4931      CmdArgs.push_back("-dynamic-linker");
4932      CmdArgs.push_back("/usr/libexec/ld.so");
4933    }
4934  }
4935
4936  if (Output.isFilename()) {
4937    CmdArgs.push_back("-o");
4938    CmdArgs.push_back(Output.getFilename());
4939  } else {
4940    assert(Output.isNothing() && "Invalid output.");
4941  }
4942
4943  if (!Args.hasArg(options::OPT_nostdlib) &&
4944      !Args.hasArg(options::OPT_nostartfiles)) {
4945    if (!Args.hasArg(options::OPT_shared)) {
4946      if (Args.hasArg(options::OPT_pg))
4947        CmdArgs.push_back(Args.MakeArgString(
4948                                getToolChain().GetFilePath("gcrt0.o")));
4949      else
4950        CmdArgs.push_back(Args.MakeArgString(
4951                                getToolChain().GetFilePath("crt0.o")));
4952      CmdArgs.push_back(Args.MakeArgString(
4953                              getToolChain().GetFilePath("crtbegin.o")));
4954    } else {
4955      CmdArgs.push_back(Args.MakeArgString(
4956                              getToolChain().GetFilePath("crtbeginS.o")));
4957    }
4958  }
4959
4960  std::string Triple = getToolChain().getTripleString();
4961  if (Triple.substr(0, 6) == "x86_64")
4962    Triple.replace(0, 6, "amd64");
4963  CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
4964                                       "/4.2.1"));
4965
4966  Args.AddAllArgs(CmdArgs, options::OPT_L);
4967  Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4968  Args.AddAllArgs(CmdArgs, options::OPT_e);
4969  Args.AddAllArgs(CmdArgs, options::OPT_s);
4970  Args.AddAllArgs(CmdArgs, options::OPT_t);
4971  Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4972  Args.AddAllArgs(CmdArgs, options::OPT_r);
4973
4974  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4975
4976  if (!Args.hasArg(options::OPT_nostdlib) &&
4977      !Args.hasArg(options::OPT_nodefaultlibs)) {
4978    if (D.CCCIsCXX) {
4979      getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
4980      if (Args.hasArg(options::OPT_pg))
4981        CmdArgs.push_back("-lm_p");
4982      else
4983        CmdArgs.push_back("-lm");
4984    }
4985
4986    // FIXME: For some reason GCC passes -lgcc before adding
4987    // the default system libraries. Just mimic this for now.
4988    CmdArgs.push_back("-lgcc");
4989
4990    if (Args.hasArg(options::OPT_pthread)) {
4991      if (!Args.hasArg(options::OPT_shared) &&
4992          Args.hasArg(options::OPT_pg))
4993         CmdArgs.push_back("-lpthread_p");
4994      else
4995         CmdArgs.push_back("-lpthread");
4996    }
4997
4998    if (!Args.hasArg(options::OPT_shared)) {
4999      if (Args.hasArg(options::OPT_pg))
5000         CmdArgs.push_back("-lc_p");
5001      else
5002         CmdArgs.push_back("-lc");
5003    }
5004
5005    CmdArgs.push_back("-lgcc");
5006  }
5007
5008  if (!Args.hasArg(options::OPT_nostdlib) &&
5009      !Args.hasArg(options::OPT_nostartfiles)) {
5010    if (!Args.hasArg(options::OPT_shared))
5011      CmdArgs.push_back(Args.MakeArgString(
5012                              getToolChain().GetFilePath("crtend.o")));
5013    else
5014      CmdArgs.push_back(Args.MakeArgString(
5015                              getToolChain().GetFilePath("crtendS.o")));
5016  }
5017
5018  const char *Exec =
5019    Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5020  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5021}
5022
5023void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5024                                    const InputInfo &Output,
5025                                    const InputInfoList &Inputs,
5026                                    const ArgList &Args,
5027                                    const char *LinkingOutput) const {
5028  ArgStringList CmdArgs;
5029
5030  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5031                       options::OPT_Xassembler);
5032
5033  CmdArgs.push_back("-o");
5034  CmdArgs.push_back(Output.getFilename());
5035
5036  for (InputInfoList::const_iterator
5037         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5038    const InputInfo &II = *it;
5039    CmdArgs.push_back(II.getFilename());
5040  }
5041
5042  const char *Exec =
5043    Args.MakeArgString(getToolChain().GetProgramPath("as"));
5044  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5045}
5046
5047void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
5048                                const InputInfo &Output,
5049                                const InputInfoList &Inputs,
5050                                const ArgList &Args,
5051                                const char *LinkingOutput) const {
5052  const Driver &D = getToolChain().getDriver();
5053  ArgStringList CmdArgs;
5054
5055  if ((!Args.hasArg(options::OPT_nostdlib)) &&
5056      (!Args.hasArg(options::OPT_shared))) {
5057    CmdArgs.push_back("-e");
5058    CmdArgs.push_back("__start");
5059  }
5060
5061  if (Args.hasArg(options::OPT_static)) {
5062    CmdArgs.push_back("-Bstatic");
5063  } else {
5064    if (Args.hasArg(options::OPT_rdynamic))
5065      CmdArgs.push_back("-export-dynamic");
5066    CmdArgs.push_back("--eh-frame-hdr");
5067    CmdArgs.push_back("-Bdynamic");
5068    if (Args.hasArg(options::OPT_shared)) {
5069      CmdArgs.push_back("-shared");
5070    } else {
5071      CmdArgs.push_back("-dynamic-linker");
5072      CmdArgs.push_back("/usr/libexec/ld.so");
5073    }
5074  }
5075
5076  if (Output.isFilename()) {
5077    CmdArgs.push_back("-o");
5078    CmdArgs.push_back(Output.getFilename());
5079  } else {
5080    assert(Output.isNothing() && "Invalid output.");
5081  }
5082
5083  if (!Args.hasArg(options::OPT_nostdlib) &&
5084      !Args.hasArg(options::OPT_nostartfiles)) {
5085    if (!Args.hasArg(options::OPT_shared)) {
5086      if (Args.hasArg(options::OPT_pg))
5087        CmdArgs.push_back(Args.MakeArgString(
5088                                getToolChain().GetFilePath("gcrt0.o")));
5089      else
5090        CmdArgs.push_back(Args.MakeArgString(
5091                                getToolChain().GetFilePath("crt0.o")));
5092      CmdArgs.push_back(Args.MakeArgString(
5093                              getToolChain().GetFilePath("crtbegin.o")));
5094    } else {
5095      CmdArgs.push_back(Args.MakeArgString(
5096                              getToolChain().GetFilePath("crtbeginS.o")));
5097    }
5098  }
5099
5100  Args.AddAllArgs(CmdArgs, options::OPT_L);
5101  Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5102  Args.AddAllArgs(CmdArgs, options::OPT_e);
5103
5104  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5105
5106  if (!Args.hasArg(options::OPT_nostdlib) &&
5107      !Args.hasArg(options::OPT_nodefaultlibs)) {
5108    if (D.CCCIsCXX) {
5109      getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5110      if (Args.hasArg(options::OPT_pg))
5111        CmdArgs.push_back("-lm_p");
5112      else
5113        CmdArgs.push_back("-lm");
5114    }
5115
5116    if (Args.hasArg(options::OPT_pthread)) {
5117      if (!Args.hasArg(options::OPT_shared) &&
5118          Args.hasArg(options::OPT_pg))
5119        CmdArgs.push_back("-lpthread_p");
5120      else
5121        CmdArgs.push_back("-lpthread");
5122    }
5123
5124    if (!Args.hasArg(options::OPT_shared)) {
5125      if (Args.hasArg(options::OPT_pg))
5126        CmdArgs.push_back("-lc_p");
5127      else
5128        CmdArgs.push_back("-lc");
5129    }
5130
5131    std::string myarch = "-lclang_rt.";
5132    const llvm::Triple &T = getToolChain().getTriple();
5133    llvm::Triple::ArchType Arch = T.getArch();
5134    switch (Arch) {
5135          case llvm::Triple::arm:
5136            myarch += ("arm");
5137            break;
5138          case llvm::Triple::x86:
5139            myarch += ("i386");
5140            break;
5141          case llvm::Triple::x86_64:
5142            myarch += ("amd64");
5143            break;
5144          default:
5145            assert(0 && "Unsupported architecture");
5146     }
5147     CmdArgs.push_back(Args.MakeArgString(myarch));
5148  }
5149
5150  if (!Args.hasArg(options::OPT_nostdlib) &&
5151      !Args.hasArg(options::OPT_nostartfiles)) {
5152    if (!Args.hasArg(options::OPT_shared))
5153      CmdArgs.push_back(Args.MakeArgString(
5154                              getToolChain().GetFilePath("crtend.o")));
5155    else
5156      CmdArgs.push_back(Args.MakeArgString(
5157                              getToolChain().GetFilePath("crtendS.o")));
5158  }
5159
5160  const char *Exec =
5161    Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5162  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5163}
5164
5165void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5166                                     const InputInfo &Output,
5167                                     const InputInfoList &Inputs,
5168                                     const ArgList &Args,
5169                                     const char *LinkingOutput) const {
5170  ArgStringList CmdArgs;
5171
5172  // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5173  // instruct as in the base system to assemble 32-bit code.
5174  if (getToolChain().getArch() == llvm::Triple::x86)
5175    CmdArgs.push_back("--32");
5176  else if (getToolChain().getArch() == llvm::Triple::ppc)
5177    CmdArgs.push_back("-a32");
5178  else if (getToolChain().getArch() == llvm::Triple::mips ||
5179           getToolChain().getArch() == llvm::Triple::mipsel ||
5180           getToolChain().getArch() == llvm::Triple::mips64 ||
5181           getToolChain().getArch() == llvm::Triple::mips64el) {
5182    StringRef CPUName;
5183    StringRef ABIName;
5184    getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
5185
5186    CmdArgs.push_back("-march");
5187    CmdArgs.push_back(CPUName.data());
5188
5189    CmdArgs.push_back("-mabi");
5190    CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5191
5192    if (getToolChain().getArch() == llvm::Triple::mips ||
5193        getToolChain().getArch() == llvm::Triple::mips64)
5194      CmdArgs.push_back("-EB");
5195    else
5196      CmdArgs.push_back("-EL");
5197
5198    Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5199                                      options::OPT_fpic, options::OPT_fno_pic,
5200                                      options::OPT_fPIE, options::OPT_fno_PIE,
5201                                      options::OPT_fpie, options::OPT_fno_pie);
5202    if (LastPICArg &&
5203        (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5204         LastPICArg->getOption().matches(options::OPT_fpic) ||
5205         LastPICArg->getOption().matches(options::OPT_fPIE) ||
5206         LastPICArg->getOption().matches(options::OPT_fpie))) {
5207      CmdArgs.push_back("-KPIC");
5208    }
5209  } else if (getToolChain().getArch() == llvm::Triple::arm ||
5210             getToolChain().getArch() == llvm::Triple::thumb) {
5211    CmdArgs.push_back("-mfpu=softvfp");
5212    switch(getToolChain().getTriple().getEnvironment()) {
5213    case llvm::Triple::GNUEABI:
5214    case llvm::Triple::EABI:
5215      CmdArgs.push_back("-meabi=5");
5216      break;
5217
5218    default:
5219      CmdArgs.push_back("-matpcs");
5220    }
5221  }
5222
5223  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5224                       options::OPT_Xassembler);
5225
5226  CmdArgs.push_back("-o");
5227  CmdArgs.push_back(Output.getFilename());
5228
5229  for (InputInfoList::const_iterator
5230         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5231    const InputInfo &II = *it;
5232    CmdArgs.push_back(II.getFilename());
5233  }
5234
5235  const char *Exec =
5236    Args.MakeArgString(getToolChain().GetProgramPath("as"));
5237  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5238}
5239
5240void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5241                                 const InputInfo &Output,
5242                                 const InputInfoList &Inputs,
5243                                 const ArgList &Args,
5244                                 const char *LinkingOutput) const {
5245  const toolchains::FreeBSD& ToolChain =
5246    static_cast<const toolchains::FreeBSD&>(getToolChain());
5247  const Driver &D = ToolChain.getDriver();
5248  ArgStringList CmdArgs;
5249
5250  // Silence warning for "clang -g foo.o -o foo"
5251  Args.ClaimAllArgs(options::OPT_g_Group);
5252  // and "clang -emit-llvm foo.o -o foo"
5253  Args.ClaimAllArgs(options::OPT_emit_llvm);
5254  // and for "clang -w foo.o -o foo". Other warning options are already
5255  // handled somewhere else.
5256  Args.ClaimAllArgs(options::OPT_w);
5257
5258  if (!D.SysRoot.empty())
5259    CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5260
5261  if (Args.hasArg(options::OPT_pie))
5262    CmdArgs.push_back("-pie");
5263
5264  if (Args.hasArg(options::OPT_static)) {
5265    CmdArgs.push_back("-Bstatic");
5266  } else {
5267    if (Args.hasArg(options::OPT_rdynamic))
5268      CmdArgs.push_back("-export-dynamic");
5269    CmdArgs.push_back("--eh-frame-hdr");
5270    if (Args.hasArg(options::OPT_shared)) {
5271      CmdArgs.push_back("-Bshareable");
5272    } else {
5273      CmdArgs.push_back("-dynamic-linker");
5274      CmdArgs.push_back("/libexec/ld-elf.so.1");
5275    }
5276    if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
5277      llvm::Triple::ArchType Arch = ToolChain.getArch();
5278      if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
5279          Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5280        CmdArgs.push_back("--hash-style=both");
5281      }
5282    }
5283    CmdArgs.push_back("--enable-new-dtags");
5284  }
5285
5286  // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5287  // instruct ld in the base system to link 32-bit code.
5288  if (ToolChain.getArch() == llvm::Triple::x86) {
5289    CmdArgs.push_back("-m");
5290    CmdArgs.push_back("elf_i386_fbsd");
5291  }
5292
5293  if (ToolChain.getArch() == llvm::Triple::ppc) {
5294    CmdArgs.push_back("-m");
5295    CmdArgs.push_back("elf32ppc_fbsd");
5296  }
5297
5298  if (Output.isFilename()) {
5299    CmdArgs.push_back("-o");
5300    CmdArgs.push_back(Output.getFilename());
5301  } else {
5302    assert(Output.isNothing() && "Invalid output.");
5303  }
5304
5305  if (!Args.hasArg(options::OPT_nostdlib) &&
5306      !Args.hasArg(options::OPT_nostartfiles)) {
5307    const char *crt1 = NULL;
5308    if (!Args.hasArg(options::OPT_shared)) {
5309      if (Args.hasArg(options::OPT_pg))
5310        crt1 = "gcrt1.o";
5311      else if (Args.hasArg(options::OPT_pie))
5312        crt1 = "Scrt1.o";
5313      else
5314        crt1 = "crt1.o";
5315    }
5316    if (crt1)
5317      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
5318
5319    CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
5320
5321    const char *crtbegin = NULL;
5322    if (Args.hasArg(options::OPT_static))
5323      crtbegin = "crtbeginT.o";
5324    else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
5325      crtbegin = "crtbeginS.o";
5326    else
5327      crtbegin = "crtbegin.o";
5328
5329    CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
5330  }
5331
5332  Args.AddAllArgs(CmdArgs, options::OPT_L);
5333  const ToolChain::path_list Paths = ToolChain.getFilePaths();
5334  for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
5335       i != e; ++i)
5336    CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
5337  Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5338  Args.AddAllArgs(CmdArgs, options::OPT_e);
5339  Args.AddAllArgs(CmdArgs, options::OPT_s);
5340  Args.AddAllArgs(CmdArgs, options::OPT_t);
5341  Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5342  Args.AddAllArgs(CmdArgs, options::OPT_r);
5343
5344  AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5345
5346  if (!Args.hasArg(options::OPT_nostdlib) &&
5347      !Args.hasArg(options::OPT_nodefaultlibs)) {
5348    if (D.CCCIsCXX) {
5349      ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5350      if (Args.hasArg(options::OPT_pg))
5351        CmdArgs.push_back("-lm_p");
5352      else
5353        CmdArgs.push_back("-lm");
5354    }
5355    // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5356    // the default system libraries. Just mimic this for now.
5357    if (Args.hasArg(options::OPT_pg))
5358      CmdArgs.push_back("-lgcc_p");
5359    else
5360      CmdArgs.push_back("-lgcc");
5361    if (Args.hasArg(options::OPT_static)) {
5362      CmdArgs.push_back("-lgcc_eh");
5363    } else if (Args.hasArg(options::OPT_pg)) {
5364      CmdArgs.push_back("-lgcc_eh_p");
5365    } else {
5366      CmdArgs.push_back("--as-needed");
5367      CmdArgs.push_back("-lgcc_s");
5368      CmdArgs.push_back("--no-as-needed");
5369    }
5370
5371    if (Args.hasArg(options::OPT_pthread)) {
5372      if (Args.hasArg(options::OPT_pg))
5373        CmdArgs.push_back("-lpthread_p");
5374      else
5375        CmdArgs.push_back("-lpthread");
5376    }
5377
5378    if (Args.hasArg(options::OPT_pg)) {
5379      if (Args.hasArg(options::OPT_shared))
5380        CmdArgs.push_back("-lc");
5381      else
5382        CmdArgs.push_back("-lc_p");
5383      CmdArgs.push_back("-lgcc_p");
5384    } else {
5385      CmdArgs.push_back("-lc");
5386      CmdArgs.push_back("-lgcc");
5387    }
5388
5389    if (Args.hasArg(options::OPT_static)) {
5390      CmdArgs.push_back("-lgcc_eh");
5391    } else if (Args.hasArg(options::OPT_pg)) {
5392      CmdArgs.push_back("-lgcc_eh_p");
5393    } else {
5394      CmdArgs.push_back("--as-needed");
5395      CmdArgs.push_back("-lgcc_s");
5396      CmdArgs.push_back("--no-as-needed");
5397    }
5398  }
5399
5400  if (!Args.hasArg(options::OPT_nostdlib) &&
5401      !Args.hasArg(options::OPT_nostartfiles)) {
5402    if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
5403      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
5404    else
5405      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
5406    CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
5407  }
5408
5409  addProfileRT(ToolChain, Args, CmdArgs, ToolChain.getTriple());
5410
5411  const char *Exec =
5412    Args.MakeArgString(ToolChain.GetProgramPath("ld"));
5413  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5414}
5415
5416void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5417                                     const InputInfo &Output,
5418                                     const InputInfoList &Inputs,
5419                                     const ArgList &Args,
5420                                     const char *LinkingOutput) const {
5421  ArgStringList CmdArgs;
5422
5423  // When building 32-bit code on NetBSD/amd64, we have to explicitly
5424  // instruct as in the base system to assemble 32-bit code.
5425  if (getToolChain().getArch() == llvm::Triple::x86)
5426    CmdArgs.push_back("--32");
5427
5428  // Set byte order explicitly
5429  if (getToolChain().getArch() == llvm::Triple::mips)
5430    CmdArgs.push_back("-EB");
5431  else if (getToolChain().getArch() == llvm::Triple::mipsel)
5432    CmdArgs.push_back("-EL");
5433
5434  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5435                       options::OPT_Xassembler);
5436
5437  CmdArgs.push_back("-o");
5438  CmdArgs.push_back(Output.getFilename());
5439
5440  for (InputInfoList::const_iterator
5441         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5442    const InputInfo &II = *it;
5443    CmdArgs.push_back(II.getFilename());
5444  }
5445
5446  const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
5447  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5448}
5449
5450void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5451                                 const InputInfo &Output,
5452                                 const InputInfoList &Inputs,
5453                                 const ArgList &Args,
5454                                 const char *LinkingOutput) const {
5455  const Driver &D = getToolChain().getDriver();
5456  ArgStringList CmdArgs;
5457
5458  if (!D.SysRoot.empty())
5459    CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5460
5461  if (Args.hasArg(options::OPT_static)) {
5462    CmdArgs.push_back("-Bstatic");
5463  } else {
5464    if (Args.hasArg(options::OPT_rdynamic))
5465      CmdArgs.push_back("-export-dynamic");
5466    CmdArgs.push_back("--eh-frame-hdr");
5467    if (Args.hasArg(options::OPT_shared)) {
5468      CmdArgs.push_back("-Bshareable");
5469    } else {
5470      CmdArgs.push_back("-dynamic-linker");
5471      CmdArgs.push_back("/libexec/ld.elf_so");
5472    }
5473  }
5474
5475  // When building 32-bit code on NetBSD/amd64, we have to explicitly
5476  // instruct ld in the base system to link 32-bit code.
5477  if (getToolChain().getArch() == llvm::Triple::x86) {
5478    CmdArgs.push_back("-m");
5479    CmdArgs.push_back("elf_i386");
5480  }
5481
5482  if (Output.isFilename()) {
5483    CmdArgs.push_back("-o");
5484    CmdArgs.push_back(Output.getFilename());
5485  } else {
5486    assert(Output.isNothing() && "Invalid output.");
5487  }
5488
5489  if (!Args.hasArg(options::OPT_nostdlib) &&
5490      !Args.hasArg(options::OPT_nostartfiles)) {
5491    if (!Args.hasArg(options::OPT_shared)) {
5492      CmdArgs.push_back(Args.MakeArgString(
5493                              getToolChain().GetFilePath("crt0.o")));
5494      CmdArgs.push_back(Args.MakeArgString(
5495                              getToolChain().GetFilePath("crti.o")));
5496      CmdArgs.push_back(Args.MakeArgString(
5497                              getToolChain().GetFilePath("crtbegin.o")));
5498    } else {
5499      CmdArgs.push_back(Args.MakeArgString(
5500                              getToolChain().GetFilePath("crti.o")));
5501      CmdArgs.push_back(Args.MakeArgString(
5502                              getToolChain().GetFilePath("crtbeginS.o")));
5503    }
5504  }
5505
5506  Args.AddAllArgs(CmdArgs, options::OPT_L);
5507  Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5508  Args.AddAllArgs(CmdArgs, options::OPT_e);
5509  Args.AddAllArgs(CmdArgs, options::OPT_s);
5510  Args.AddAllArgs(CmdArgs, options::OPT_t);
5511  Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5512  Args.AddAllArgs(CmdArgs, options::OPT_r);
5513
5514  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5515
5516  if (!Args.hasArg(options::OPT_nostdlib) &&
5517      !Args.hasArg(options::OPT_nodefaultlibs)) {
5518    if (D.CCCIsCXX) {
5519      getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5520      CmdArgs.push_back("-lm");
5521    }
5522    // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5523    // the default system libraries. Just mimic this for now.
5524    if (Args.hasArg(options::OPT_static)) {
5525      CmdArgs.push_back("-lgcc_eh");
5526    } else {
5527      CmdArgs.push_back("--as-needed");
5528      CmdArgs.push_back("-lgcc_s");
5529      CmdArgs.push_back("--no-as-needed");
5530    }
5531    CmdArgs.push_back("-lgcc");
5532
5533    if (Args.hasArg(options::OPT_pthread))
5534      CmdArgs.push_back("-lpthread");
5535    CmdArgs.push_back("-lc");
5536
5537    CmdArgs.push_back("-lgcc");
5538    if (Args.hasArg(options::OPT_static)) {
5539      CmdArgs.push_back("-lgcc_eh");
5540    } else {
5541      CmdArgs.push_back("--as-needed");
5542      CmdArgs.push_back("-lgcc_s");
5543      CmdArgs.push_back("--no-as-needed");
5544    }
5545  }
5546
5547  if (!Args.hasArg(options::OPT_nostdlib) &&
5548      !Args.hasArg(options::OPT_nostartfiles)) {
5549    if (!Args.hasArg(options::OPT_shared))
5550      CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5551                                                                  "crtend.o")));
5552    else
5553      CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5554                                                                 "crtendS.o")));
5555    CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5556                                                                    "crtn.o")));
5557  }
5558
5559  addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5560
5561  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5562  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5563}
5564
5565void linuxtools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5566                                        const InputInfo &Output,
5567                                        const InputInfoList &Inputs,
5568                                        const ArgList &Args,
5569                                        const char *LinkingOutput) const {
5570  ArgStringList CmdArgs;
5571
5572  // Add --32/--64 to make sure we get the format we want.
5573  // This is incomplete
5574  if (getToolChain().getArch() == llvm::Triple::x86) {
5575    CmdArgs.push_back("--32");
5576  } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
5577    CmdArgs.push_back("--64");
5578  } else if (getToolChain().getArch() == llvm::Triple::ppc) {
5579    CmdArgs.push_back("-a32");
5580    CmdArgs.push_back("-mppc");
5581    CmdArgs.push_back("-many");
5582  } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
5583    CmdArgs.push_back("-a64");
5584    CmdArgs.push_back("-mppc64");
5585    CmdArgs.push_back("-many");
5586  } else if (getToolChain().getArch() == llvm::Triple::arm) {
5587    StringRef MArch = getToolChain().getArchName();
5588    if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
5589      CmdArgs.push_back("-mfpu=neon");
5590
5591    StringRef ARMFloatABI = getARMFloatABI(getToolChain().getDriver(), Args,
5592                                           getToolChain().getTriple());
5593    CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
5594
5595    Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
5596    Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
5597    Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
5598  } else if (getToolChain().getArch() == llvm::Triple::mips ||
5599             getToolChain().getArch() == llvm::Triple::mipsel ||
5600             getToolChain().getArch() == llvm::Triple::mips64 ||
5601             getToolChain().getArch() == llvm::Triple::mips64el) {
5602    StringRef CPUName;
5603    StringRef ABIName;
5604    getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
5605
5606    CmdArgs.push_back("-march");
5607    CmdArgs.push_back(CPUName.data());
5608
5609    CmdArgs.push_back("-mabi");
5610    CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5611
5612    if (getToolChain().getArch() == llvm::Triple::mips ||
5613        getToolChain().getArch() == llvm::Triple::mips64)
5614      CmdArgs.push_back("-EB");
5615    else
5616      CmdArgs.push_back("-EL");
5617
5618    Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5619                                      options::OPT_fpic, options::OPT_fno_pic,
5620                                      options::OPT_fPIE, options::OPT_fno_PIE,
5621                                      options::OPT_fpie, options::OPT_fno_pie);
5622    if (LastPICArg &&
5623        (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5624         LastPICArg->getOption().matches(options::OPT_fpic) ||
5625         LastPICArg->getOption().matches(options::OPT_fPIE) ||
5626         LastPICArg->getOption().matches(options::OPT_fpie))) {
5627      CmdArgs.push_back("-KPIC");
5628    }
5629  }
5630
5631  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5632                       options::OPT_Xassembler);
5633
5634  CmdArgs.push_back("-o");
5635  CmdArgs.push_back(Output.getFilename());
5636
5637  for (InputInfoList::const_iterator
5638         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5639    const InputInfo &II = *it;
5640    CmdArgs.push_back(II.getFilename());
5641  }
5642
5643  const char *Exec =
5644    Args.MakeArgString(getToolChain().GetProgramPath("as"));
5645  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5646}
5647
5648static void AddLibgcc(llvm::Triple Triple, const Driver &D,
5649                      ArgStringList &CmdArgs, const ArgList &Args) {
5650  bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
5651  bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
5652                      Args.hasArg(options::OPT_static);
5653  if (!D.CCCIsCXX)
5654    CmdArgs.push_back("-lgcc");
5655
5656  if (StaticLibgcc || isAndroid) {
5657    if (D.CCCIsCXX)
5658      CmdArgs.push_back("-lgcc");
5659  } else {
5660    if (!D.CCCIsCXX)
5661      CmdArgs.push_back("--as-needed");
5662    CmdArgs.push_back("-lgcc_s");
5663    if (!D.CCCIsCXX)
5664      CmdArgs.push_back("--no-as-needed");
5665  }
5666
5667  if (StaticLibgcc && !isAndroid)
5668    CmdArgs.push_back("-lgcc_eh");
5669  else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX)
5670    CmdArgs.push_back("-lgcc");
5671
5672  // According to Android ABI, we have to link with libdl if we are
5673  // linking with non-static libgcc.
5674  //
5675  // NOTE: This fixes a link error on Android MIPS as well.  The non-static
5676  // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
5677  if (isAndroid && !StaticLibgcc)
5678    CmdArgs.push_back("-ldl");
5679}
5680
5681static bool hasMipsN32ABIArg(const ArgList &Args) {
5682  Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5683  return A && (A->getValue() == StringRef("n32"));
5684}
5685
5686void linuxtools::Link::ConstructJob(Compilation &C, const JobAction &JA,
5687                                    const InputInfo &Output,
5688                                    const InputInfoList &Inputs,
5689                                    const ArgList &Args,
5690                                    const char *LinkingOutput) const {
5691  const toolchains::Linux& ToolChain =
5692    static_cast<const toolchains::Linux&>(getToolChain());
5693  const Driver &D = ToolChain.getDriver();
5694  const bool isAndroid =
5695    ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
5696
5697  ArgStringList CmdArgs;
5698
5699  // Silence warning for "clang -g foo.o -o foo"
5700  Args.ClaimAllArgs(options::OPT_g_Group);
5701  // and "clang -emit-llvm foo.o -o foo"
5702  Args.ClaimAllArgs(options::OPT_emit_llvm);
5703  // and for "clang -w foo.o -o foo". Other warning options are already
5704  // handled somewhere else.
5705  Args.ClaimAllArgs(options::OPT_w);
5706
5707  if (!D.SysRoot.empty())
5708    CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5709
5710  if (Args.hasArg(options::OPT_pie) && !Args.hasArg(options::OPT_shared))
5711    CmdArgs.push_back("-pie");
5712
5713  if (Args.hasArg(options::OPT_rdynamic))
5714    CmdArgs.push_back("-export-dynamic");
5715
5716  if (Args.hasArg(options::OPT_s))
5717    CmdArgs.push_back("-s");
5718
5719  for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
5720         e = ToolChain.ExtraOpts.end();
5721       i != e; ++i)
5722    CmdArgs.push_back(i->c_str());
5723
5724  if (!Args.hasArg(options::OPT_static)) {
5725    CmdArgs.push_back("--eh-frame-hdr");
5726  }
5727
5728  CmdArgs.push_back("-m");
5729  if (ToolChain.getArch() == llvm::Triple::x86)
5730    CmdArgs.push_back("elf_i386");
5731  else if (ToolChain.getArch() == llvm::Triple::aarch64)
5732    CmdArgs.push_back("aarch64linux");
5733  else if (ToolChain.getArch() == llvm::Triple::arm
5734           ||  ToolChain.getArch() == llvm::Triple::thumb)
5735    CmdArgs.push_back("armelf_linux_eabi");
5736  else if (ToolChain.getArch() == llvm::Triple::ppc)
5737    CmdArgs.push_back("elf32ppclinux");
5738  else if (ToolChain.getArch() == llvm::Triple::ppc64)
5739    CmdArgs.push_back("elf64ppc");
5740  else if (ToolChain.getArch() == llvm::Triple::mips)
5741    CmdArgs.push_back("elf32btsmip");
5742  else if (ToolChain.getArch() == llvm::Triple::mipsel)
5743    CmdArgs.push_back("elf32ltsmip");
5744  else if (ToolChain.getArch() == llvm::Triple::mips64) {
5745    if (hasMipsN32ABIArg(Args))
5746      CmdArgs.push_back("elf32btsmipn32");
5747    else
5748      CmdArgs.push_back("elf64btsmip");
5749  }
5750  else if (ToolChain.getArch() == llvm::Triple::mips64el) {
5751    if (hasMipsN32ABIArg(Args))
5752      CmdArgs.push_back("elf32ltsmipn32");
5753    else
5754      CmdArgs.push_back("elf64ltsmip");
5755  }
5756  else
5757    CmdArgs.push_back("elf_x86_64");
5758
5759  if (Args.hasArg(options::OPT_static)) {
5760    if (ToolChain.getArch() == llvm::Triple::arm
5761        || ToolChain.getArch() == llvm::Triple::thumb)
5762      CmdArgs.push_back("-Bstatic");
5763    else
5764      CmdArgs.push_back("-static");
5765  } else if (Args.hasArg(options::OPT_shared)) {
5766    CmdArgs.push_back("-shared");
5767    if (isAndroid) {
5768      CmdArgs.push_back("-Bsymbolic");
5769    }
5770  }
5771
5772  if (ToolChain.getArch() == llvm::Triple::arm ||
5773      ToolChain.getArch() == llvm::Triple::thumb ||
5774      (!Args.hasArg(options::OPT_static) &&
5775       !Args.hasArg(options::OPT_shared))) {
5776    CmdArgs.push_back("-dynamic-linker");
5777    if (isAndroid)
5778      CmdArgs.push_back("/system/bin/linker");
5779    else if (ToolChain.getArch() == llvm::Triple::x86)
5780      CmdArgs.push_back("/lib/ld-linux.so.2");
5781    else if (ToolChain.getArch() == llvm::Triple::aarch64)
5782      CmdArgs.push_back("/lib/ld-linux-aarch64.so.1");
5783    else if (ToolChain.getArch() == llvm::Triple::arm ||
5784             ToolChain.getArch() == llvm::Triple::thumb) {
5785      if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
5786        CmdArgs.push_back("/lib/ld-linux-armhf.so.3");
5787      else
5788        CmdArgs.push_back("/lib/ld-linux.so.3");
5789    }
5790    else if (ToolChain.getArch() == llvm::Triple::mips ||
5791             ToolChain.getArch() == llvm::Triple::mipsel)
5792      CmdArgs.push_back("/lib/ld.so.1");
5793    else if (ToolChain.getArch() == llvm::Triple::mips64 ||
5794             ToolChain.getArch() == llvm::Triple::mips64el) {
5795      if (hasMipsN32ABIArg(Args))
5796        CmdArgs.push_back("/lib32/ld.so.1");
5797      else
5798        CmdArgs.push_back("/lib64/ld.so.1");
5799    }
5800    else if (ToolChain.getArch() == llvm::Triple::ppc)
5801      CmdArgs.push_back("/lib/ld.so.1");
5802    else if (ToolChain.getArch() == llvm::Triple::ppc64)
5803      CmdArgs.push_back("/lib64/ld64.so.1");
5804    else
5805      CmdArgs.push_back("/lib64/ld-linux-x86-64.so.2");
5806  }
5807
5808  CmdArgs.push_back("-o");
5809  CmdArgs.push_back(Output.getFilename());
5810
5811  if (!Args.hasArg(options::OPT_nostdlib) &&
5812      !Args.hasArg(options::OPT_nostartfiles)) {
5813    if (!isAndroid) {
5814      const char *crt1 = NULL;
5815      if (!Args.hasArg(options::OPT_shared)){
5816        if (Args.hasArg(options::OPT_pie))
5817          crt1 = "Scrt1.o";
5818        else
5819          crt1 = "crt1.o";
5820      }
5821      if (crt1)
5822        CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
5823
5824      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
5825    }
5826
5827    const char *crtbegin;
5828    if (Args.hasArg(options::OPT_static))
5829      crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
5830    else if (Args.hasArg(options::OPT_shared))
5831      crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
5832    else if (Args.hasArg(options::OPT_pie))
5833      crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
5834    else
5835      crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
5836    CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
5837
5838    // Add crtfastmath.o if available and fast math is enabled.
5839    ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
5840  }
5841
5842  Args.AddAllArgs(CmdArgs, options::OPT_L);
5843
5844  const ToolChain::path_list Paths = ToolChain.getFilePaths();
5845
5846  for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
5847       i != e; ++i)
5848    CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
5849
5850  // Tell the linker to load the plugin. This has to come before AddLinkerInputs
5851  // as gold requires -plugin to come before any -plugin-opt that -Wl might
5852  // forward.
5853  if (D.IsUsingLTO(Args) || Args.hasArg(options::OPT_use_gold_plugin)) {
5854    CmdArgs.push_back("-plugin");
5855    std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
5856    CmdArgs.push_back(Args.MakeArgString(Plugin));
5857
5858    // Try to pass driver level flags relevant to LTO code generation down to
5859    // the plugin.
5860
5861    // Handle architecture-specific flags for selecting CPU variants.
5862    if (ToolChain.getArch() == llvm::Triple::x86 ||
5863        ToolChain.getArch() == llvm::Triple::x86_64)
5864      CmdArgs.push_back(
5865          Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
5866                             getX86TargetCPU(Args, ToolChain.getTriple())));
5867    else if (ToolChain.getArch() == llvm::Triple::arm ||
5868             ToolChain.getArch() == llvm::Triple::thumb)
5869      CmdArgs.push_back(
5870          Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
5871                             getARMTargetCPU(Args, ToolChain.getTriple())));
5872
5873    // FIXME: Factor out logic for MIPS, PPC, and other targets to support this
5874    // as well.
5875  }
5876
5877
5878  if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5879    CmdArgs.push_back("--no-demangle");
5880
5881  AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5882
5883  SanitizerArgs Sanitize(D, Args);
5884
5885  // Call these before we add the C++ ABI library.
5886  if (Sanitize.needsUbsanRt())
5887    addUbsanRTLinux(getToolChain(), Args, CmdArgs);
5888  if (Sanitize.needsAsanRt())
5889    addAsanRTLinux(getToolChain(), Args, CmdArgs);
5890  if (Sanitize.needsTsanRt())
5891    addTsanRTLinux(getToolChain(), Args, CmdArgs);
5892  if (Sanitize.needsMsanRt())
5893    addMsanRTLinux(getToolChain(), Args, CmdArgs);
5894
5895  if (D.CCCIsCXX &&
5896      !Args.hasArg(options::OPT_nostdlib) &&
5897      !Args.hasArg(options::OPT_nodefaultlibs)) {
5898    bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
5899      !Args.hasArg(options::OPT_static);
5900    if (OnlyLibstdcxxStatic)
5901      CmdArgs.push_back("-Bstatic");
5902    ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5903    if (OnlyLibstdcxxStatic)
5904      CmdArgs.push_back("-Bdynamic");
5905    CmdArgs.push_back("-lm");
5906  }
5907
5908  if (!Args.hasArg(options::OPT_nostdlib)) {
5909    if (!Args.hasArg(options::OPT_nodefaultlibs)) {
5910      if (Args.hasArg(options::OPT_static))
5911        CmdArgs.push_back("--start-group");
5912
5913      bool OpenMP = Args.hasArg(options::OPT_fopenmp);
5914      if (OpenMP) {
5915        CmdArgs.push_back("-lgomp");
5916
5917        // FIXME: Exclude this for platforms whith libgomp that doesn't require
5918        // librt. Most modern Linux platfroms require it, but some may not.
5919        CmdArgs.push_back("-lrt");
5920      }
5921
5922      AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
5923
5924      if (Args.hasArg(options::OPT_pthread) ||
5925          Args.hasArg(options::OPT_pthreads) || OpenMP)
5926        CmdArgs.push_back("-lpthread");
5927
5928      CmdArgs.push_back("-lc");
5929
5930      if (Args.hasArg(options::OPT_static))
5931        CmdArgs.push_back("--end-group");
5932      else
5933        AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
5934    }
5935
5936    if (!Args.hasArg(options::OPT_nostartfiles)) {
5937      const char *crtend;
5938      if (Args.hasArg(options::OPT_shared))
5939        crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
5940      else if (Args.hasArg(options::OPT_pie))
5941        crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
5942      else
5943        crtend = isAndroid ? "crtend_android.o" : "crtend.o";
5944
5945      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
5946      if (!isAndroid)
5947        CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
5948    }
5949  }
5950
5951  addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5952
5953  C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
5954}
5955
5956void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5957                                   const InputInfo &Output,
5958                                   const InputInfoList &Inputs,
5959                                   const ArgList &Args,
5960                                   const char *LinkingOutput) const {
5961  ArgStringList CmdArgs;
5962
5963  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5964                       options::OPT_Xassembler);
5965
5966  CmdArgs.push_back("-o");
5967  CmdArgs.push_back(Output.getFilename());
5968
5969  for (InputInfoList::const_iterator
5970         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5971    const InputInfo &II = *it;
5972    CmdArgs.push_back(II.getFilename());
5973  }
5974
5975  const char *Exec =
5976    Args.MakeArgString(getToolChain().GetProgramPath("as"));
5977  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5978}
5979
5980void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
5981                               const InputInfo &Output,
5982                               const InputInfoList &Inputs,
5983                               const ArgList &Args,
5984                               const char *LinkingOutput) const {
5985  const Driver &D = getToolChain().getDriver();
5986  ArgStringList CmdArgs;
5987
5988  if (Output.isFilename()) {
5989    CmdArgs.push_back("-o");
5990    CmdArgs.push_back(Output.getFilename());
5991  } else {
5992    assert(Output.isNothing() && "Invalid output.");
5993  }
5994
5995  if (!Args.hasArg(options::OPT_nostdlib) &&
5996      !Args.hasArg(options::OPT_nostartfiles)) {
5997      CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
5998      CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
5999      CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
6000      CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
6001  }
6002
6003  Args.AddAllArgs(CmdArgs, options::OPT_L);
6004  Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6005  Args.AddAllArgs(CmdArgs, options::OPT_e);
6006
6007  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6008
6009  addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6010
6011  if (!Args.hasArg(options::OPT_nostdlib) &&
6012      !Args.hasArg(options::OPT_nodefaultlibs)) {
6013    if (D.CCCIsCXX) {
6014      getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6015      CmdArgs.push_back("-lm");
6016    }
6017  }
6018
6019  if (!Args.hasArg(options::OPT_nostdlib) &&
6020      !Args.hasArg(options::OPT_nostartfiles)) {
6021    if (Args.hasArg(options::OPT_pthread))
6022      CmdArgs.push_back("-lpthread");
6023    CmdArgs.push_back("-lc");
6024    CmdArgs.push_back("-lCompilerRT-Generic");
6025    CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
6026    CmdArgs.push_back(
6027         Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
6028  }
6029
6030  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
6031  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6032}
6033
6034/// DragonFly Tools
6035
6036// For now, DragonFly Assemble does just about the same as for
6037// FreeBSD, but this may change soon.
6038void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6039                                       const InputInfo &Output,
6040                                       const InputInfoList &Inputs,
6041                                       const ArgList &Args,
6042                                       const char *LinkingOutput) const {
6043  ArgStringList CmdArgs;
6044
6045  // When building 32-bit code on DragonFly/pc64, we have to explicitly
6046  // instruct as in the base system to assemble 32-bit code.
6047  if (getToolChain().getArch() == llvm::Triple::x86)
6048    CmdArgs.push_back("--32");
6049
6050  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6051                       options::OPT_Xassembler);
6052
6053  CmdArgs.push_back("-o");
6054  CmdArgs.push_back(Output.getFilename());
6055
6056  for (InputInfoList::const_iterator
6057         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6058    const InputInfo &II = *it;
6059    CmdArgs.push_back(II.getFilename());
6060  }
6061
6062  const char *Exec =
6063    Args.MakeArgString(getToolChain().GetProgramPath("as"));
6064  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6065}
6066
6067void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
6068                                   const InputInfo &Output,
6069                                   const InputInfoList &Inputs,
6070                                   const ArgList &Args,
6071                                   const char *LinkingOutput) const {
6072  const Driver &D = getToolChain().getDriver();
6073  ArgStringList CmdArgs;
6074
6075  if (!D.SysRoot.empty())
6076    CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6077
6078  if (Args.hasArg(options::OPT_static)) {
6079    CmdArgs.push_back("-Bstatic");
6080  } else {
6081    if (Args.hasArg(options::OPT_shared))
6082      CmdArgs.push_back("-Bshareable");
6083    else {
6084      CmdArgs.push_back("-dynamic-linker");
6085      CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
6086    }
6087  }
6088
6089  // When building 32-bit code on DragonFly/pc64, we have to explicitly
6090  // instruct ld in the base system to link 32-bit code.
6091  if (getToolChain().getArch() == llvm::Triple::x86) {
6092    CmdArgs.push_back("-m");
6093    CmdArgs.push_back("elf_i386");
6094  }
6095
6096  if (Output.isFilename()) {
6097    CmdArgs.push_back("-o");
6098    CmdArgs.push_back(Output.getFilename());
6099  } else {
6100    assert(Output.isNothing() && "Invalid output.");
6101  }
6102
6103  if (!Args.hasArg(options::OPT_nostdlib) &&
6104      !Args.hasArg(options::OPT_nostartfiles)) {
6105    if (!Args.hasArg(options::OPT_shared)) {
6106      CmdArgs.push_back(
6107            Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
6108      CmdArgs.push_back(
6109            Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
6110      CmdArgs.push_back(
6111            Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
6112    } else {
6113      CmdArgs.push_back(
6114            Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
6115      CmdArgs.push_back(
6116            Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
6117    }
6118  }
6119
6120  Args.AddAllArgs(CmdArgs, options::OPT_L);
6121  Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6122  Args.AddAllArgs(CmdArgs, options::OPT_e);
6123
6124  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6125
6126  if (!Args.hasArg(options::OPT_nostdlib) &&
6127      !Args.hasArg(options::OPT_nodefaultlibs)) {
6128    // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
6129    //         rpaths
6130    CmdArgs.push_back("-L/usr/lib/gcc41");
6131
6132    if (!Args.hasArg(options::OPT_static)) {
6133      CmdArgs.push_back("-rpath");
6134      CmdArgs.push_back("/usr/lib/gcc41");
6135
6136      CmdArgs.push_back("-rpath-link");
6137      CmdArgs.push_back("/usr/lib/gcc41");
6138
6139      CmdArgs.push_back("-rpath");
6140      CmdArgs.push_back("/usr/lib");
6141
6142      CmdArgs.push_back("-rpath-link");
6143      CmdArgs.push_back("/usr/lib");
6144    }
6145
6146    if (D.CCCIsCXX) {
6147      getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6148      CmdArgs.push_back("-lm");
6149    }
6150
6151    if (Args.hasArg(options::OPT_shared)) {
6152      CmdArgs.push_back("-lgcc_pic");
6153    } else {
6154      CmdArgs.push_back("-lgcc");
6155    }
6156
6157
6158    if (Args.hasArg(options::OPT_pthread))
6159      CmdArgs.push_back("-lpthread");
6160
6161    if (!Args.hasArg(options::OPT_nolibc)) {
6162      CmdArgs.push_back("-lc");
6163    }
6164
6165    if (Args.hasArg(options::OPT_shared)) {
6166      CmdArgs.push_back("-lgcc_pic");
6167    } else {
6168      CmdArgs.push_back("-lgcc");
6169    }
6170  }
6171
6172  if (!Args.hasArg(options::OPT_nostdlib) &&
6173      !Args.hasArg(options::OPT_nostartfiles)) {
6174    if (!Args.hasArg(options::OPT_shared))
6175      CmdArgs.push_back(Args.MakeArgString(
6176                              getToolChain().GetFilePath("crtend.o")));
6177    else
6178      CmdArgs.push_back(Args.MakeArgString(
6179                              getToolChain().GetFilePath("crtendS.o")));
6180    CmdArgs.push_back(Args.MakeArgString(
6181                              getToolChain().GetFilePath("crtn.o")));
6182  }
6183
6184  addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6185
6186  const char *Exec =
6187    Args.MakeArgString(getToolChain().GetProgramPath("ld"));
6188  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6189}
6190
6191void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
6192                                      const InputInfo &Output,
6193                                      const InputInfoList &Inputs,
6194                                      const ArgList &Args,
6195                                      const char *LinkingOutput) const {
6196  ArgStringList CmdArgs;
6197
6198  if (Output.isFilename()) {
6199    CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
6200                                         Output.getFilename()));
6201  } else {
6202    assert(Output.isNothing() && "Invalid output.");
6203  }
6204
6205  if (!Args.hasArg(options::OPT_nostdlib) &&
6206    !Args.hasArg(options::OPT_nostartfiles)) {
6207    CmdArgs.push_back("-defaultlib:libcmt");
6208  }
6209
6210  CmdArgs.push_back("-nologo");
6211
6212  Args.AddAllArgValues(CmdArgs, options::OPT_l);
6213
6214  // Add filenames immediately.
6215  for (InputInfoList::const_iterator
6216       it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6217    if (it->isFilename())
6218      CmdArgs.push_back(it->getFilename());
6219  }
6220
6221  const char *Exec =
6222    Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
6223  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6224}
6225