Tools.cpp revision eb1be3fea0e2f41f3bc6a708a8c38b00c0888739 
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
12#include "clang/Driver/Action.h"
13#include "clang/Driver/Arg.h"
14#include "clang/Driver/ArgList.h"
15#include "clang/Driver/Driver.h" // FIXME: Remove?
16#include "clang/Driver/DriverDiagnostic.h" // FIXME: Remove?
17#include "clang/Driver/Compilation.h"
18#include "clang/Driver/Job.h"
19#include "clang/Driver/HostInfo.h"
20#include "clang/Driver/Option.h"
21#include "clang/Driver/ToolChain.h"
22#include "clang/Driver/Util.h"
23
24#include "llvm/ADT/SmallVector.h"
25#include "llvm/Support/Format.h"
26#include "llvm/Support/raw_ostream.h"
27
28#include "InputInfo.h"
29#include "ToolChains.h"
30
31using namespace clang::driver;
32using namespace clang::driver::tools;
33
34void Clang::ConstructJob(Compilation &C, const JobAction &JA,
35                         Job &Dest,
36                         const InputInfo &Output,
37                         const InputInfoList &Inputs,
38                         const ArgList &Args,
39                         const char *LinkingOutput) const {
40  ArgStringList CmdArgs;
41
42  if (isa<AnalyzeJobAction>(JA)) {
43    assert(JA.getType() == types::TY_Plist && "Invalid output type.");
44    CmdArgs.push_back("-analyze");
45  } else if (isa<PreprocessJobAction>(JA)) {
46    CmdArgs.push_back("-E");
47  } else if (isa<PrecompileJobAction>(JA)) {
48    // No special option needed, driven by -x.
49    //
50    // FIXME: Don't drive this by -x, that is gross.
51  } else {
52    assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
53
54    if (JA.getType() == types::TY_Nothing) {
55      CmdArgs.push_back("-fsyntax-only");
56    } else if (JA.getType() == types::TY_LLVMAsm) {
57      CmdArgs.push_back("-emit-llvm");
58    } else if (JA.getType() == types::TY_LLVMBC) {
59      CmdArgs.push_back("-emit-llvm-bc");
60    } else if (JA.getType() == types::TY_PP_Asm) {
61      CmdArgs.push_back("-S");
62    }
63  }
64
65  // The make clang go fast button.
66  CmdArgs.push_back("-disable-free");
67
68  if (isa<AnalyzeJobAction>(JA)) {
69    // Add default argument set.
70    //
71    // FIXME: Move into clang?
72    CmdArgs.push_back("-warn-dead-stores");
73    CmdArgs.push_back("-checker-cfref");
74    CmdArgs.push_back("-analyzer-eagerly-assume");
75    CmdArgs.push_back("-warn-objc-methodsigs");
76    // Do not enable the missing -dealloc check.
77    // '-warn-objc-missing-dealloc',
78    CmdArgs.push_back("-warn-objc-unused-ivars");
79
80    CmdArgs.push_back("-analyzer-output=plist");
81
82    // Add -Xanalyzer arguments when running as analyzer.
83    Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
84  } else {
85    // Perform argument translation for LLVM backend. This
86    // takes some care in reconciling with llvm-gcc. The
87    // issue is that llvm-gcc translates these options based on
88    // the values in cc1, whereas we are processing based on
89    // the driver arguments.
90    //
91    // FIXME: This is currently broken for -f flags when -fno
92    // variants are present.
93
94    // This comes from the default translation the driver + cc1
95    // would do to enable flag_pic.
96    //
97    // FIXME: Centralize this code.
98    bool PICEnabled = (Args.hasArg(options::OPT_fPIC) ||
99                       Args.hasArg(options::OPT_fpic) ||
100                       Args.hasArg(options::OPT_fPIE) ||
101                       Args.hasArg(options::OPT_fpie));
102    bool PICDisabled = (Args.hasArg(options::OPT_mkernel) ||
103                        Args.hasArg(options::OPT_static));
104    const char *Model = getToolChain().GetForcedPicModel();
105    if (!Model) {
106      if (Args.hasArg(options::OPT_mdynamic_no_pic))
107        Model = "dynamic-no-pic";
108      else if (PICDisabled)
109        Model = "static";
110      else if (PICEnabled)
111        Model = "pic";
112      else
113        Model = getToolChain().GetDefaultRelocationModel();
114    }
115    CmdArgs.push_back("--relocation-model");
116    CmdArgs.push_back(Model);
117
118    if (Args.hasArg(options::OPT_ftime_report))
119      CmdArgs.push_back("--time-passes");
120    // FIXME: Set --enable-unsafe-fp-math.
121    if (!Args.hasArg(options::OPT_fomit_frame_pointer))
122      CmdArgs.push_back("--disable-fp-elim");
123    if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
124                      options::OPT_fno_zero_initialized_in_bss,
125                      true))
126      CmdArgs.push_back("--nozero-initialized-in-bss");
127    if (Args.hasArg(options::OPT_dA) || Args.hasArg(options::OPT_fverbose_asm))
128      CmdArgs.push_back("--asm-verbose");
129    if (Args.hasArg(options::OPT_fdebug_pass_structure))
130      CmdArgs.push_back("--debug-pass=Structure");
131    if (Args.hasArg(options::OPT_fdebug_pass_arguments))
132      CmdArgs.push_back("--debug-pass=Arguments");
133    // FIXME: set --inline-threshhold=50 if (optimize_size || optimize
134    // < 3)
135    if (Args.hasFlag(options::OPT_funwind_tables,
136                      options::OPT_fno_unwind_tables,
137                      getToolChain().IsUnwindTablesDefault()))
138      CmdArgs.push_back("--unwind-tables=1");
139    else
140      CmdArgs.push_back("--unwind-tables=0");
141    if (!Args.hasFlag(options::OPT_mred_zone,
142                       options::OPT_mno_red_zone,
143                       true))
144      CmdArgs.push_back("--disable-red-zone");
145    if (Args.hasFlag(options::OPT_msoft_float,
146                      options::OPT_mno_soft_float,
147                      false))
148      CmdArgs.push_back("--soft-float");
149
150    // FIXME: Need target hooks.
151    if (memcmp(getToolChain().getPlatform().c_str(), "darwin", 6) == 0) {
152      if (getToolChain().getArchName() == "x86_64")
153        CmdArgs.push_back("--mcpu=core2");
154      else if (getToolChain().getArchName() == "i386")
155        CmdArgs.push_back("--mcpu=yonah");
156    }
157
158    // FIXME: Ignores ordering. Also, we need to find a realistic
159    // solution for this.
160    static const struct {
161      options::ID Pos, Neg;
162      const char *Name;
163    } FeatureOptions[] = {
164      { options::OPT_mmmx, options::OPT_mno_mmx, "mmx" },
165      { options::OPT_msse, options::OPT_mno_sse, "sse" },
166      { options::OPT_msse2, options::OPT_mno_sse2, "sse2" },
167      { options::OPT_msse3, options::OPT_mno_sse3, "sse3" },
168      { options::OPT_mssse3, options::OPT_mno_ssse3, "ssse3" },
169      { options::OPT_msse41, options::OPT_mno_sse41, "sse41" },
170      { options::OPT_msse42, options::OPT_mno_sse42, "sse42" },
171      { options::OPT_msse4a, options::OPT_mno_sse4a, "sse4a" },
172      { options::OPT_m3dnow, options::OPT_mno_3dnow, "3dnow" },
173      { options::OPT_m3dnowa, options::OPT_mno_3dnowa, "3dnowa" }
174    };
175    const unsigned NumFeatureOptions =
176      sizeof(FeatureOptions)/sizeof(FeatureOptions[0]);
177
178    // FIXME: Avoid std::string
179    std::string Attrs;
180    for (unsigned i=0; i < NumFeatureOptions; ++i) {
181      if (Args.hasArg(FeatureOptions[i].Pos)) {
182        if (!Attrs.empty())
183          Attrs += ',';
184        Attrs += '+';
185        Attrs += FeatureOptions[i].Name;
186      } else if (Args.hasArg(FeatureOptions[i].Neg)) {
187        if (!Attrs.empty())
188          Attrs += ',';
189        Attrs += '-';
190        Attrs += FeatureOptions[i].Name;
191      }
192    }
193    if (!Attrs.empty()) {
194      CmdArgs.push_back("--mattr");
195      CmdArgs.push_back(Args.MakeArgString(Attrs.c_str()));
196    }
197
198    if (Args.hasFlag(options::OPT_fmath_errno,
199                      options::OPT_fno_math_errno,
200                      getToolChain().IsMathErrnoDefault()))
201      CmdArgs.push_back("--fmath-errno=1");
202    else
203      CmdArgs.push_back("--fmath-errno=0");
204
205    if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
206      CmdArgs.push_back("--limit-float-precision");
207      CmdArgs.push_back(A->getValue(Args));
208    }
209
210    // FIXME: Add --stack-protector-buffer-size=<xxx> on
211    // -fstack-protect.
212
213    Args.AddLastArg(CmdArgs, options::OPT_MD);
214    Args.AddLastArg(CmdArgs, options::OPT_MMD);
215    Args.AddAllArgs(CmdArgs, options::OPT_MF);
216    Args.AddLastArg(CmdArgs, options::OPT_MP);
217    Args.AddAllArgs(CmdArgs, options::OPT_MT);
218
219    Arg *Unsupported = Args.getLastArg(options::OPT_M);
220    if (!Unsupported)
221      Unsupported = Args.getLastArg(options::OPT_MM);
222    if (!Unsupported)
223      Unsupported = Args.getLastArg(options::OPT_MG);
224    if (!Unsupported)
225      Unsupported = Args.getLastArg(options::OPT_MQ);
226    if (Unsupported) {
227      const Driver &D = getToolChain().getHost().getDriver();
228      D.Diag(clang::diag::err_drv_unsupported_opt)
229        << Unsupported->getOption().getName();
230    }
231  }
232
233  Args.AddAllArgs(CmdArgs, options::OPT_v);
234  Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
235  Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F);
236  Args.AddLastArg(CmdArgs, options::OPT_P);
237  Args.AddAllArgs(CmdArgs, options::OPT_mmacosx_version_min_EQ);
238
239  // Special case debug options to only pass -g to clang. This is
240  // wrong.
241  if (Args.hasArg(options::OPT_g_Group))
242    CmdArgs.push_back("-g");
243
244  Args.AddLastArg(CmdArgs, options::OPT_nostdinc);
245
246  // FIXME: Clang isn't going to accept just anything here.
247  // FIXME: Use iterator.
248
249  // Add -i* options, and automatically translate to -include-pth for
250  // transparent PCH support. It's wonky, but we include looking for
251  // .gch so we can support seamless replacement into a build system
252  // already set up to be generating .gch files.
253  for (ArgList::const_iterator
254         it = Args.begin(), ie = Args.end(); it != ie; ++it) {
255    const Arg *A = *it;
256    if (!A->getOption().matches(options::OPT_i_Group))
257      continue;
258
259    if (A->getOption().matches(options::OPT_include)) {
260      bool FoundPTH = false;
261      llvm::sys::Path P(A->getValue(Args));
262      P.appendSuffix("pth");
263      if (P.exists()) {
264        FoundPTH = true;
265      } else {
266        P.eraseSuffix();
267        P.appendSuffix("gch");
268        if (P.exists())
269          FoundPTH = true;
270      }
271
272      if (FoundPTH) {
273        A->claim();
274        CmdArgs.push_back("-include-pth");
275        CmdArgs.push_back(Args.MakeArgString(P.c_str()));
276        continue;
277      }
278    }
279
280    // Not translated, render as usual.
281    A->claim();
282    A->render(Args, CmdArgs);
283  }
284
285  // Manually translate -O to -O1 and -O4 to -O3; let clang reject
286  // others.
287  if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
288    if (A->getOption().getId() == options::OPT_O4)
289      CmdArgs.push_back("-O3");
290    else if (A->getValue(Args)[0] == '\0')
291      CmdArgs.push_back("-O1");
292    else
293      A->render(Args, CmdArgs);
294  }
295
296  Args.AddAllArgs(CmdArgs, options::OPT_clang_W_Group,
297                  options::OPT_pedantic_Group);
298  Args.AddLastArg(CmdArgs, options::OPT_w);
299  Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
300                  options::OPT_trigraphs);
301
302  if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_)) {
303    CmdArgs.push_back("-ftemplate-depth");
304    CmdArgs.push_back(A->getValue(Args));
305  }
306
307  Args.AddAllArgs(CmdArgs, options::OPT_clang_f_Group);
308
309  Args.AddLastArg(CmdArgs, options::OPT_dM);
310
311  Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
312
313  // FIXME: Always pass the full triple once we aren't concerned with
314  // ccc compat.
315  CmdArgs.push_back("-arch");
316  CmdArgs.push_back(getToolChain().getArchName().c_str());
317
318  if (Output.isPipe()) {
319    CmdArgs.push_back("-o");
320    CmdArgs.push_back("-");
321  } else if (Output.isFilename()) {
322    CmdArgs.push_back("-o");
323    CmdArgs.push_back(Output.getFilename());
324  } else {
325    assert(Output.isNothing() && "Invalid output.");
326  }
327
328  for (InputInfoList::const_iterator
329         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
330    const InputInfo &II = *it;
331    CmdArgs.push_back("-x");
332    CmdArgs.push_back(types::getTypeName(II.getType()));
333    if (II.isPipe())
334      CmdArgs.push_back("-");
335    else if (II.isFilename())
336      CmdArgs.push_back(II.getFilename());
337    else
338      II.getInputArg().renderAsInput(Args, CmdArgs);
339  }
340
341  const char *Exec =
342    Args.MakeArgString(getToolChain().GetProgramPath(C, "clang-cc").c_str());
343  Dest.addCommand(new Command(Exec, CmdArgs));
344
345  // Claim some arguments which clang doesn't support, but we don't
346  // care to warn the user about.
347
348  // FIXME: Use iterator.
349  for (ArgList::const_iterator
350         it = Args.begin(), ie = Args.end(); it != ie; ++it) {
351    const Arg *A = *it;
352    if (A->getOption().matches(options::OPT_clang_ignored_W_Group) ||
353        A->getOption().matches(options::OPT_clang_ignored_f_Group))
354      A->claim();
355  }
356}
357
358void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
359                               Job &Dest,
360                               const InputInfo &Output,
361                               const InputInfoList &Inputs,
362                               const ArgList &Args,
363                               const char *LinkingOutput) const {
364  ArgStringList CmdArgs;
365
366  for (ArgList::const_iterator
367         it = Args.begin(), ie = Args.end(); it != ie; ++it) {
368    Arg *A = *it;
369    if (A->getOption().hasForwardToGCC()) {
370      // It is unfortunate that we have to claim here, as this means
371      // we will basically never report anything interesting for
372      // platforms using a generic gcc.
373      A->claim();
374      A->render(Args, CmdArgs);
375    }
376  }
377
378  RenderExtraToolArgs(CmdArgs);
379
380  // If using a driver driver, force the arch.
381  if (getToolChain().getHost().useDriverDriver()) {
382    CmdArgs.push_back("-arch");
383    CmdArgs.push_back(getToolChain().getArchName().c_str());
384  }
385
386  if (Output.isPipe()) {
387    CmdArgs.push_back("-o");
388    CmdArgs.push_back("-");
389  } else if (Output.isFilename()) {
390    CmdArgs.push_back("-o");
391    CmdArgs.push_back(Output.getFilename());
392  } else {
393    assert(Output.isNothing() && "Unexpected output");
394    CmdArgs.push_back("-fsyntax-only");
395  }
396
397
398  // Only pass -x if gcc will understand it; otherwise hope gcc
399  // understands the suffix correctly. The main use case this would go
400  // wrong in is for linker inputs if they happened to have an odd
401  // suffix; really the only way to get this to happen is a command
402  // like '-x foobar a.c' which will treat a.c like a linker input.
403  //
404  // FIXME: For the linker case specifically, can we safely convert
405  // inputs into '-Wl,' options?
406  for (InputInfoList::const_iterator
407         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
408    const InputInfo &II = *it;
409    if (types::canTypeBeUserSpecified(II.getType())) {
410      CmdArgs.push_back("-x");
411      CmdArgs.push_back(types::getTypeName(II.getType()));
412    }
413
414    if (II.isPipe())
415      CmdArgs.push_back("-");
416    else if (II.isFilename())
417      CmdArgs.push_back(II.getFilename());
418    else
419      // Don't render as input, we need gcc to do the translations.
420      II.getInputArg().render(Args, CmdArgs);
421  }
422
423  const char *Exec =
424    Args.MakeArgString(getToolChain().GetProgramPath(C, "gcc").c_str());
425  Dest.addCommand(new Command(Exec, CmdArgs));
426}
427
428void gcc::Preprocess::RenderExtraToolArgs(ArgStringList &CmdArgs) const {
429  CmdArgs.push_back("-E");
430}
431
432void gcc::Precompile::RenderExtraToolArgs(ArgStringList &CmdArgs) const {
433  // The type is good enough.
434}
435
436void gcc::Compile::RenderExtraToolArgs(ArgStringList &CmdArgs) const {
437  CmdArgs.push_back("-S");
438}
439
440void gcc::Assemble::RenderExtraToolArgs(ArgStringList &CmdArgs) const {
441  CmdArgs.push_back("-c");
442}
443
444void gcc::Link::RenderExtraToolArgs(ArgStringList &CmdArgs) const {
445  // The types are (hopefully) good enough.
446}
447
448void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
449                                    Job &Dest, const InputInfo &Output,
450                                    const InputInfoList &Inputs,
451                                    const ArgList &Args,
452                                    const char *LinkingOutput) const {
453  ArgStringList CmdArgs;
454
455  assert(Inputs.size() == 1 && "Unexpected number of inputs.");
456  const InputInfo &Input = Inputs[0];
457
458  // Bit of a hack, this is only used for original inputs.
459  if (Input.isFilename() &&
460      strcmp(Input.getFilename(), Input.getBaseInput()) == 0 &&
461      Args.hasArg(options::OPT_g_Group))
462    CmdArgs.push_back("--gstabs");
463
464  // Derived from asm spec.
465  CmdArgs.push_back("-arch");
466  CmdArgs.push_back(getToolChain().getArchName().c_str());
467
468  CmdArgs.push_back("-force_cpusubtype_ALL");
469  if ((Args.hasArg(options::OPT_mkernel) ||
470       Args.hasArg(options::OPT_static) ||
471       Args.hasArg(options::OPT_fapple_kext)) &&
472      !Args.hasArg(options::OPT_dynamic))
473      CmdArgs.push_back("-static");
474
475  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
476                       options::OPT_Xassembler);
477
478  assert(Output.isFilename() && "Unexpected lipo output.");
479  CmdArgs.push_back("-o");
480  CmdArgs.push_back(Output.getFilename());
481
482  if (Input.isPipe()) {
483    CmdArgs.push_back("-");
484  } else {
485    assert(Input.isFilename() && "Invalid input.");
486    CmdArgs.push_back(Input.getFilename());
487  }
488
489  // asm_final spec is empty.
490
491  const char *Exec =
492    Args.MakeArgString(getToolChain().GetProgramPath(C, "as").c_str());
493  Dest.addCommand(new Command(Exec, CmdArgs));
494}
495
496static const char *MakeFormattedString(const ArgList &Args,
497                                       const llvm::format_object_base &Fmt) {
498  std::string Str;
499  llvm::raw_string_ostream(Str) << Fmt;
500  return Args.MakeArgString(Str.c_str());
501}
502
503/// Helper routine for seeing if we should use dsymutil; this is a
504/// gcc compatible hack, we should remove it and use the input
505/// type information.
506static bool isSourceSuffix(const char *Str) {
507  // match: 'C', 'CPP', 'c', 'cc', 'cp', 'c++', 'cpp', 'cxx', 'm',
508  // 'mm'.
509  switch (strlen(Str)) {
510  default:
511    return false;
512  case 1:
513    return (memcmp(Str, "C", 1) == 0 ||
514            memcmp(Str, "c", 1) == 0 ||
515            memcmp(Str, "m", 1) == 0);
516  case 2:
517    return (memcmp(Str, "cc", 2) == 0 ||
518            memcmp(Str, "cp", 2) == 0 ||
519            memcmp(Str, "mm", 2) == 0);
520  case 3:
521    return (memcmp(Str, "CPP", 3) == 0 ||
522            memcmp(Str, "c++", 3) == 0 ||
523            memcmp(Str, "cpp", 3) == 0 ||
524            memcmp(Str, "cxx", 3) == 0);
525  }
526}
527
528static bool isMacosxVersionLT(unsigned (&A)[3], unsigned (&B)[3]) {
529  for (unsigned i=0; i < 3; ++i) {
530    if (A[i] > B[i]) return false;
531    if (A[i] < B[i]) return true;
532  }
533  return false;
534}
535
536static bool isMacosxVersionLT(unsigned (&A)[3],
537                              unsigned V0, unsigned V1=0, unsigned V2=0) {
538  unsigned B[3] = { V0, V1, V2 };
539  return isMacosxVersionLT(A, B);
540}
541
542static bool isMacosxVersionGTE(unsigned(&A)[3],
543                              unsigned V0, unsigned V1=0, unsigned V2=0) {
544  return !isMacosxVersionLT(A, V0, V1, V2);
545}
546
547const toolchains::Darwin_X86 &darwin::Link::getDarwinToolChain() const {
548  return reinterpret_cast<const toolchains::Darwin_X86&>(getToolChain());
549}
550
551void darwin::Link::AddDarwinArch(const ArgList &Args,
552                                 ArgStringList &CmdArgs) const {
553  // Derived from darwin_arch spec.
554  CmdArgs.push_back("-arch");
555  CmdArgs.push_back(getToolChain().getArchName().c_str());
556}
557
558void darwin::Link::AddDarwinSubArch(const ArgList &Args,
559                                    ArgStringList &CmdArgs) const {
560  // Derived from darwin_subarch spec, not sure what the distinction
561  // exists for but at least for this chain it is the same.
562  AddDarwinArch(Args, CmdArgs);
563}
564
565void darwin::Link::AddLinkArgs(const ArgList &Args,
566                               ArgStringList &CmdArgs) const {
567  const Driver &D = getToolChain().getHost().getDriver();
568
569  // Derived from the "link" spec.
570  Args.AddAllArgs(CmdArgs, options::OPT_static);
571  if (!Args.hasArg(options::OPT_static))
572    CmdArgs.push_back("-dynamic");
573  if (Args.hasArg(options::OPT_fgnu_runtime)) {
574    // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
575    // here. How do we wish to handle such things?
576  }
577
578  if (!Args.hasArg(options::OPT_dynamiclib)) {
579    if (Args.hasArg(options::OPT_force__cpusubtype__ALL)) {
580      AddDarwinArch(Args, CmdArgs);
581      CmdArgs.push_back("-force_cpusubtype_ALL");
582    } else
583      AddDarwinSubArch(Args, CmdArgs);
584
585    Args.AddLastArg(CmdArgs, options::OPT_bundle);
586    Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
587    Args.AddAllArgs(CmdArgs, options::OPT_client__name);
588
589    Arg *A;
590    if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
591        (A = Args.getLastArg(options::OPT_current__version)) ||
592        (A = Args.getLastArg(options::OPT_install__name)))
593      D.Diag(clang::diag::err_drv_argument_only_allowed_with)
594        << A->getAsString(Args) << "-dynamiclib";
595
596    Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
597    Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
598    Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
599  } else {
600    CmdArgs.push_back("-dylib");
601
602    Arg *A;
603    if ((A = Args.getLastArg(options::OPT_bundle)) ||
604        (A = Args.getLastArg(options::OPT_bundle__loader)) ||
605        (A = Args.getLastArg(options::OPT_client__name)) ||
606        (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
607        (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
608        (A = Args.getLastArg(options::OPT_private__bundle)))
609      D.Diag(clang::diag::err_drv_argument_not_allowed_with)
610        << A->getAsString(Args) << "-dynamiclib";
611
612    Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
613                              "-dylib_compatibility_version");
614    Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
615                              "-dylib_current_version");
616
617    if (Args.hasArg(options::OPT_force__cpusubtype__ALL)) {
618      AddDarwinArch(Args, CmdArgs);
619          // NOTE: We don't add -force_cpusubtype_ALL on this path. Ok.
620    } else
621      AddDarwinSubArch(Args, CmdArgs);
622
623    Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
624                              "-dylib_install_name");
625  }
626
627  Args.AddLastArg(CmdArgs, options::OPT_all__load);
628  Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
629  Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
630  Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
631  Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
632  Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
633  Args.AddLastArg(CmdArgs, options::OPT_dynamic);
634  Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
635  Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
636  Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
637  Args.AddAllArgs(CmdArgs, options::OPT_image__base);
638  Args.AddAllArgs(CmdArgs, options::OPT_init);
639
640  if (!Args.hasArg(options::OPT_mmacosx_version_min_EQ)) {
641    if (!Args.hasArg(options::OPT_miphoneos_version_min_EQ)) {
642        // FIXME: I don't understand what is going on here. This is
643        // supposed to come from darwin_ld_minversion, but gcc doesn't
644        // seem to be following that; it must be getting overridden
645        // somewhere.
646        CmdArgs.push_back("-macosx_version_min");
647        CmdArgs.push_back(getDarwinToolChain().getMacosxVersionStr());
648      }
649  } else {
650    // Adding all arguments doesn't make sense here but this is what
651    // gcc does.
652    Args.AddAllArgsTranslated(CmdArgs, options::OPT_mmacosx_version_min_EQ,
653                              "-macosx_version_min");
654  }
655
656  Args.AddAllArgsTranslated(CmdArgs, options::OPT_miphoneos_version_min_EQ,
657                            "-iphoneos_version_min");
658  Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
659  Args.AddLastArg(CmdArgs, options::OPT_multi__module);
660  Args.AddLastArg(CmdArgs, options::OPT_single__module);
661  Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
662  Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
663
664  if (Args.hasArg(options::OPT_fpie))
665    CmdArgs.push_back("-pie");
666
667  Args.AddLastArg(CmdArgs, options::OPT_prebind);
668  Args.AddLastArg(CmdArgs, options::OPT_noprebind);
669  Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
670  Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
671  Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
672  Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
673  Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
674  Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
675  Args.AddAllArgs(CmdArgs, options::OPT_segprot);
676  Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
677  Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
678  Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
679  Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
680  Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
681  Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
682  Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
683  Args.AddAllArgsTranslated(CmdArgs, options::OPT_isysroot, "-syslibroot");
684  Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
685  Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
686  Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
687  Args.AddAllArgs(CmdArgs, options::OPT_undefined);
688  Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
689  Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
690
691  if (!Args.hasArg(options::OPT_weak__reference__mismatches)) {
692    CmdArgs.push_back("-weak_reference_mismatches");
693    CmdArgs.push_back("non-weak");
694  }
695
696  Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
697  Args.AddAllArgs(CmdArgs, options::OPT_y);
698  Args.AddLastArg(CmdArgs, options::OPT_w);
699  Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
700  Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
701  Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
702  Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
703  Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
704  Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
705  Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
706  Args.AddLastArg(CmdArgs, options::OPT_whyload);
707  Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
708  Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
709  Args.AddLastArg(CmdArgs, options::OPT_dylinker);
710  Args.AddLastArg(CmdArgs, options::OPT_Mach);
711}
712
713void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
714                                Job &Dest, const InputInfo &Output,
715                                const InputInfoList &Inputs,
716                                const ArgList &Args,
717                                const char *LinkingOutput) const {
718  assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
719  // The logic here is derived from gcc's behavior; most of which
720  // comes from specs (starting with link_command). Consult gcc for
721  // more information.
722
723  // FIXME: The spec references -fdump= which seems to have
724  // disappeared?
725
726  ArgStringList CmdArgs;
727
728  // I'm not sure why this particular decomposition exists in gcc, but
729  // we follow suite for ease of comparison.
730  AddLinkArgs(Args, CmdArgs);
731
732  // FIXME: gcc has %{x} in here. How could this ever happen?  Cruft?
733  Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
734  Args.AddAllArgs(CmdArgs, options::OPT_s);
735  Args.AddAllArgs(CmdArgs, options::OPT_t);
736  Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
737  Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
738  Args.AddAllArgs(CmdArgs, options::OPT_A);
739  Args.AddLastArg(CmdArgs, options::OPT_e);
740  Args.AddAllArgs(CmdArgs, options::OPT_m_Separate);
741  Args.AddAllArgs(CmdArgs, options::OPT_r);
742
743  // FIXME: This is just being pedantically bug compatible, gcc
744  // doesn't *mean* to forward this, it just does (yay for pattern
745  // matching). It doesn't work, of course.
746  Args.AddAllArgs(CmdArgs, options::OPT_object);
747
748  CmdArgs.push_back("-o");
749  CmdArgs.push_back(Output.getFilename());
750
751  unsigned MacosxVersion[3];
752  if (Arg *A = Args.getLastArg(options::OPT_mmacosx_version_min_EQ)) {
753    bool HadExtra;
754    if (!Driver::GetReleaseVersion(A->getValue(Args), MacosxVersion[0],
755                                   MacosxVersion[1], MacosxVersion[2],
756                                   HadExtra) ||
757        HadExtra) {
758      const Driver &D = getToolChain().getHost().getDriver();
759      D.Diag(clang::diag::err_drv_invalid_version_number)
760        << A->getAsString(Args);
761    }
762  } else {
763    getDarwinToolChain().getMacosxVersion(MacosxVersion);
764  }
765
766  if (!Args.hasArg(options::OPT_A) &&
767      !Args.hasArg(options::OPT_nostdlib) &&
768      !Args.hasArg(options::OPT_nostartfiles)) {
769    // Derived from startfile spec.
770    if (Args.hasArg(options::OPT_dynamiclib)) {
771        // Derived from darwin_dylib1 spec.
772      if (Args.hasArg(options::OPT_miphoneos_version_min_EQ) ||
773          isMacosxVersionLT(MacosxVersion, 10, 5))
774        CmdArgs.push_back("-ldylib1.o");
775      else
776        CmdArgs.push_back("-ldylib1.10.5.o");
777    } else {
778      if (Args.hasArg(options::OPT_bundle)) {
779        if (!Args.hasArg(options::OPT_static))
780          CmdArgs.push_back("-lbundle1.o");
781      } else {
782        if (Args.hasArg(options::OPT_pg)) {
783          if (Args.hasArg(options::OPT_static) ||
784              Args.hasArg(options::OPT_object) ||
785              Args.hasArg(options::OPT_preload)) {
786            CmdArgs.push_back("-lgcrt0.o");
787          } else {
788            CmdArgs.push_back("-lgcrt1.o");
789
790            // darwin_crt2 spec is empty.
791          }
792        } else {
793          if (Args.hasArg(options::OPT_static) ||
794              Args.hasArg(options::OPT_object) ||
795              Args.hasArg(options::OPT_preload)) {
796            CmdArgs.push_back("-lcrt0.o");
797          } else {
798            // Derived from darwin_crt1 spec.
799            if (Args.hasArg(options::OPT_miphoneos_version_min_EQ) ||
800                isMacosxVersionLT(MacosxVersion, 10, 5)) {
801              CmdArgs.push_back("-lcrt1.o");
802            } else {
803              CmdArgs.push_back("-lcrt1.10.5.o");
804
805              // darwin_crt2 spec is empty.
806            }
807          }
808        }
809      }
810    }
811
812    if (Args.hasArg(options::OPT_shared_libgcc) &&
813        !Args.hasArg(options::OPT_miphoneos_version_min_EQ) &&
814        isMacosxVersionLT(MacosxVersion, 10, 5)) {
815      const char *Str = getToolChain().GetFilePath(C, "crt3.o").c_str();
816      CmdArgs.push_back(Args.MakeArgString(Str));
817    }
818  }
819
820  Args.AddAllArgs(CmdArgs, options::OPT_L);
821
822  if (Args.hasArg(options::OPT_fopenmp))
823    // This is more complicated in gcc...
824    CmdArgs.push_back("-lgomp");
825
826  // FIXME: Derive these correctly.
827  const char *TCDir = getDarwinToolChain().getToolChainDir().c_str();
828  if (getToolChain().getArchName() == "x86_64") {
829    CmdArgs.push_back(MakeFormattedString(Args,
830                              llvm::format("-L/usr/lib/gcc/%s/x86_64", TCDir)));
831    // Intentionally duplicated for (temporary) gcc bug compatibility.
832    CmdArgs.push_back(MakeFormattedString(Args,
833                              llvm::format("-L/usr/lib/gcc/%s/x86_64", TCDir)));
834  }
835  CmdArgs.push_back(MakeFormattedString(Args,
836                                        llvm::format("-L/usr/lib/%s", TCDir)));
837  CmdArgs.push_back(MakeFormattedString(Args,
838                                     llvm::format("-L/usr/lib/gcc/%s", TCDir)));
839  // Intentionally duplicated for (temporary) gcc bug compatibility.
840  CmdArgs.push_back(MakeFormattedString(Args,
841                                     llvm::format("-L/usr/lib/gcc/%s", TCDir)));
842  CmdArgs.push_back(MakeFormattedString(Args,
843                  llvm::format("-L/usr/lib/gcc/%s/../../../%s", TCDir, TCDir)));
844  CmdArgs.push_back(MakeFormattedString(Args,
845                            llvm::format("-L/usr/lib/gcc/%s/../../..", TCDir)));
846
847  for (InputInfoList::const_iterator
848         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
849    const InputInfo &II = *it;
850    if (II.isFilename())
851      CmdArgs.push_back(II.getFilename());
852    else
853      II.getInputArg().renderAsInput(Args, CmdArgs);
854  }
855
856  if (LinkingOutput) {
857    CmdArgs.push_back("-arch_multiple");
858    CmdArgs.push_back("-final_output");
859    CmdArgs.push_back(LinkingOutput);
860  }
861
862  if (Args.hasArg(options::OPT_fprofile_arcs) ||
863      Args.hasArg(options::OPT_fprofile_generate) ||
864      Args.hasArg(options::OPT_fcreate_profile) ||
865      Args.hasArg(options::OPT_coverage))
866    CmdArgs.push_back("-lgcov");
867
868  if (Args.hasArg(options::OPT_fnested_functions))
869    CmdArgs.push_back("-allow_stack_execute");
870
871  if (!Args.hasArg(options::OPT_nostdlib) &&
872      !Args.hasArg(options::OPT_nodefaultlibs)) {
873    // link_ssp spec is empty.
874
875    // Derived from libgcc spec.
876    if (Args.hasArg(options::OPT_static)) {
877      CmdArgs.push_back("-lgcc_static");
878    } else if (Args.hasArg(options::OPT_static_libgcc)) {
879      CmdArgs.push_back("-lgcc_eh");
880      CmdArgs.push_back("-lgcc");
881    } else if (Args.hasArg(options::OPT_miphoneos_version_min_EQ)) {
882      // Derived from darwin_iphoneos_libgcc spec.
883      CmdArgs.push_back("-lgcc_s.10.5");
884      CmdArgs.push_back("-lgcc");
885    } else if (Args.hasArg(options::OPT_shared_libgcc) ||
886               Args.hasArg(options::OPT_fexceptions) ||
887               Args.hasArg(options::OPT_fgnu_runtime)) {
888      if (isMacosxVersionLT(MacosxVersion, 10, 5))
889        CmdArgs.push_back("-lgcc_s.10.4");
890      else
891        CmdArgs.push_back("-lgcc_s.10.5");
892      CmdArgs.push_back("-lgcc");
893    } else {
894      if (isMacosxVersionLT(MacosxVersion, 10, 5) &&
895          isMacosxVersionGTE(MacosxVersion, 10, 3, 9))
896        CmdArgs.push_back("-lgcc_s.10.4");
897      if (isMacosxVersionGTE(MacosxVersion, 10, 5))
898        CmdArgs.push_back("-lgcc_s.10.5");
899      CmdArgs.push_back("-lgcc");
900    }
901
902    // Derived from lib spec.
903    if (!Args.hasArg(options::OPT_static))
904      CmdArgs.push_back("-lSystem");
905  }
906
907  if (!Args.hasArg(options::OPT_A) &&
908      !Args.hasArg(options::OPT_nostdlib) &&
909      !Args.hasArg(options::OPT_nostartfiles)) {
910    // endfile_spec is empty.
911  }
912
913  Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
914  Args.AddAllArgs(CmdArgs, options::OPT_F);
915
916  const char *Exec =
917    Args.MakeArgString(getToolChain().GetProgramPath(C, "collect2").c_str());
918  Dest.addCommand(new Command(Exec, CmdArgs));
919
920  if (Args.getLastArg(options::OPT_g_Group) &&
921      !Args.getLastArg(options::OPT_gstabs) &&
922      !Args.getLastArg(options::OPT_g0)) {
923    // FIXME: This is gross, but matches gcc. The test only considers
924    // the suffix (not the -x type), and then only of the first
925    // input. Awesome.
926    const char *Suffix = strchr(Inputs[0].getBaseInput(), '.');
927    if (Suffix && isSourceSuffix(Suffix + 1)) {
928      const char *Exec =
929       Args.MakeArgString(getToolChain().GetProgramPath(C, "dsymutil").c_str());
930      ArgStringList CmdArgs;
931      CmdArgs.push_back(Output.getFilename());
932      C.getJobs().addCommand(new Command(Exec, CmdArgs));
933    }
934  }
935}
936
937void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
938                                Job &Dest, const InputInfo &Output,
939                                const InputInfoList &Inputs,
940                                const ArgList &Args,
941                                const char *LinkingOutput) const {
942  ArgStringList CmdArgs;
943
944  CmdArgs.push_back("-create");
945  assert(Output.isFilename() && "Unexpected lipo output.");
946
947  CmdArgs.push_back("-output");
948  CmdArgs.push_back(Output.getFilename());
949
950  for (InputInfoList::const_iterator
951         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
952    const InputInfo &II = *it;
953    assert(II.isFilename() && "Unexpected lipo input.");
954    CmdArgs.push_back(II.getFilename());
955  }
956  const char *Exec =
957    Args.MakeArgString(getToolChain().GetProgramPath(C, "lipo").c_str());
958  Dest.addCommand(new Command(Exec, CmdArgs));
959}
960