Driver.cpp revision e82ec0bead14ae262cddbe958b77767a3f6aebcd 
1//===--- Driver.cpp - Clang GCC Compatible Driver -----------------------*-===//
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 "clang/Driver/Driver.h"
11
12#include "clang/Driver/Action.h"
13#include "clang/Driver/Arg.h"
14#include "clang/Driver/ArgList.h"
15#include "clang/Driver/Compilation.h"
16#include "clang/Driver/DriverDiagnostic.h"
17#include "clang/Driver/HostInfo.h"
18#include "clang/Driver/Job.h"
19#include "clang/Driver/OptTable.h"
20#include "clang/Driver/Option.h"
21#include "clang/Driver/Options.h"
22#include "clang/Driver/Tool.h"
23#include "clang/Driver/ToolChain.h"
24#include "clang/Driver/Types.h"
25
26#include "clang/Basic/Version.h"
27
28#include "llvm/ADT/StringSet.h"
29#include "llvm/ADT/OwningPtr.h"
30#include "llvm/Support/PrettyStackTrace.h"
31#include "llvm/Support/raw_ostream.h"
32#include "llvm/System/Path.h"
33#include "llvm/System/Program.h"
34
35#include "InputInfo.h"
36
37#include <map>
38
39using namespace clang::driver;
40using namespace clang;
41
42// Used to set values for "production" clang, for releases.
43// #define USE_PRODUCTION_CLANG
44
45Driver::Driver(llvm::StringRef _Name, llvm::StringRef _Dir,
46               llvm::StringRef _DefaultHostTriple,
47               llvm::StringRef _DefaultImageName,
48               bool IsProduction, bool CXXIsProduction,
49               Diagnostic &_Diags)
50  : Opts(createDriverOptTable()), Diags(_Diags),
51    Name(_Name), Dir(_Dir), DefaultHostTriple(_DefaultHostTriple),
52    DefaultImageName(_DefaultImageName),
53    DriverTitle("clang \"gcc-compatible\" driver"),
54    Host(0),
55    CCCGenericGCCName("gcc"), CCPrintOptionsFilename(0), CCCIsCXX(false),
56    CCCEcho(false), CCCPrintBindings(false), CCPrintOptions(false),
57    CheckInputsExist(true), CCCUseClang(true), CCCUseClangCXX(true),
58    CCCUseClangCPP(true), CCCUsePCH(true), SuppressMissingInputWarning(false) {
59  if (IsProduction) {
60    // In a "production" build, only use clang on architectures we expect to
61    // work, and don't use clang C++.
62    //
63    // During development its more convenient to always have the driver use
64    // clang, but we don't want users to be confused when things don't work, or
65    // to file bugs for things we don't support.
66    CCCClangArchs.insert(llvm::Triple::x86);
67    CCCClangArchs.insert(llvm::Triple::x86_64);
68    CCCClangArchs.insert(llvm::Triple::arm);
69
70    if (!CXXIsProduction)
71      CCCUseClangCXX = false;
72  }
73
74  // Compute the path to the resource directory.
75  llvm::sys::Path P(Dir);
76  P.eraseComponent(); // Remove /bin from foo/bin
77  P.appendComponent("lib");
78  P.appendComponent("clang");
79  P.appendComponent(CLANG_VERSION_STRING);
80  ResourceDir = P.str();
81}
82
83Driver::~Driver() {
84  delete Opts;
85  delete Host;
86}
87
88InputArgList *Driver::ParseArgStrings(const char **ArgBegin,
89                                      const char **ArgEnd) {
90  llvm::PrettyStackTraceString CrashInfo("Command line argument parsing");
91  unsigned MissingArgIndex, MissingArgCount;
92  InputArgList *Args = getOpts().ParseArgs(ArgBegin, ArgEnd,
93                                           MissingArgIndex, MissingArgCount);
94
95  // Check for missing argument error.
96  if (MissingArgCount)
97    Diag(clang::diag::err_drv_missing_argument)
98      << Args->getArgString(MissingArgIndex) << MissingArgCount;
99
100  // Check for unsupported options.
101  for (ArgList::const_iterator it = Args->begin(), ie = Args->end();
102       it != ie; ++it) {
103    Arg *A = *it;
104    if (A->getOption().isUnsupported()) {
105      Diag(clang::diag::err_drv_unsupported_opt) << A->getAsString(*Args);
106      continue;
107    }
108  }
109
110  return Args;
111}
112
113Compilation *Driver::BuildCompilation(int argc, const char **argv) {
114  llvm::PrettyStackTraceString CrashInfo("Compilation construction");
115
116  // FIXME: Handle environment options which effect driver behavior, somewhere
117  // (client?). GCC_EXEC_PREFIX, COMPILER_PATH, LIBRARY_PATH, LPATH,
118  // CC_PRINT_OPTIONS.
119
120  // FIXME: What are we going to do with -V and -b?
121
122  // FIXME: This stuff needs to go into the Compilation, not the driver.
123  bool CCCPrintOptions = false, CCCPrintActions = false;
124
125  const char **Start = argv + 1, **End = argv + argc;
126  const char *HostTriple = DefaultHostTriple.c_str();
127
128  InputArgList *Args = ParseArgStrings(Start, End);
129
130  // -no-canonical-prefixes is used very early in main.
131  Args->ClaimAllArgs(options::OPT_no_canonical_prefixes);
132
133  // Extract -ccc args.
134  //
135  // FIXME: We need to figure out where this behavior should live. Most of it
136  // should be outside in the client; the parts that aren't should have proper
137  // options, either by introducing new ones or by overloading gcc ones like -V
138  // or -b.
139  CCCPrintOptions = Args->hasArg(options::OPT_ccc_print_options);
140  CCCPrintActions = Args->hasArg(options::OPT_ccc_print_phases);
141  CCCPrintBindings = Args->hasArg(options::OPT_ccc_print_bindings);
142  CCCIsCXX = Args->hasArg(options::OPT_ccc_cxx) || CCCIsCXX;
143  CCCEcho = Args->hasArg(options::OPT_ccc_echo);
144  if (const Arg *A = Args->getLastArg(options::OPT_ccc_gcc_name))
145    CCCGenericGCCName = A->getValue(*Args);
146  CCCUseClangCXX = Args->hasFlag(options::OPT_ccc_clang_cxx,
147                                 options::OPT_ccc_no_clang_cxx,
148                                 CCCUseClangCXX);
149  CCCUsePCH = Args->hasFlag(options::OPT_ccc_pch_is_pch,
150                            options::OPT_ccc_pch_is_pth);
151  CCCUseClang = !Args->hasArg(options::OPT_ccc_no_clang);
152  CCCUseClangCPP = !Args->hasArg(options::OPT_ccc_no_clang_cpp);
153  if (const Arg *A = Args->getLastArg(options::OPT_ccc_clang_archs)) {
154    llvm::StringRef Cur = A->getValue(*Args);
155
156    CCCClangArchs.clear();
157    while (!Cur.empty()) {
158      std::pair<llvm::StringRef, llvm::StringRef> Split = Cur.split(',');
159
160      if (!Split.first.empty()) {
161        llvm::Triple::ArchType Arch =
162          llvm::Triple(Split.first, "", "").getArch();
163
164        if (Arch == llvm::Triple::UnknownArch)
165          Diag(clang::diag::err_drv_invalid_arch_name) << Split.first;
166
167        CCCClangArchs.insert(Arch);
168      }
169
170      Cur = Split.second;
171    }
172  }
173  if (const Arg *A = Args->getLastArg(options::OPT_ccc_host_triple))
174    HostTriple = A->getValue(*Args);
175  if (const Arg *A = Args->getLastArg(options::OPT_ccc_install_dir))
176    Dir = A->getValue(*Args);
177  if (const Arg *A = Args->getLastArg(options::OPT_B))
178    PrefixDir = A->getValue(*Args);
179
180  Host = GetHostInfo(HostTriple);
181
182  // The compilation takes ownership of Args.
183  Compilation *C = new Compilation(*this, *Host->CreateToolChain(*Args), Args);
184
185  // FIXME: This behavior shouldn't be here.
186  if (CCCPrintOptions) {
187    PrintOptions(C->getArgs());
188    return C;
189  }
190
191  if (!HandleImmediateArgs(*C))
192    return C;
193
194  // Construct the list of abstract actions to perform for this compilation. We
195  // avoid passing a Compilation here simply to enforce the abstraction that
196  // pipelining is not host or toolchain dependent (other than the driver driver
197  // test).
198  if (Host->useDriverDriver())
199    BuildUniversalActions(C->getArgs(), C->getActions());
200  else
201    BuildActions(C->getArgs(), C->getActions());
202
203  if (CCCPrintActions) {
204    PrintActions(*C);
205    return C;
206  }
207
208  BuildJobs(*C);
209
210  return C;
211}
212
213int Driver::ExecuteCompilation(const Compilation &C) const {
214  // Just print if -### was present.
215  if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
216    C.PrintJob(llvm::errs(), C.getJobs(), "\n", true);
217    return 0;
218  }
219
220  // If there were errors building the compilation, quit now.
221  if (getDiags().getNumErrors())
222    return 1;
223
224  const Command *FailingCommand = 0;
225  int Res = C.ExecuteJob(C.getJobs(), FailingCommand);
226
227  // Remove temp files.
228  C.CleanupFileList(C.getTempFiles());
229
230  // If the command succeeded, we are done.
231  if (Res == 0)
232    return Res;
233
234  // Otherwise, remove result files as well.
235  if (!C.getArgs().hasArg(options::OPT_save_temps))
236    C.CleanupFileList(C.getResultFiles(), true);
237
238  // Print extra information about abnormal failures, if possible.
239  //
240  // This is ad-hoc, but we don't want to be excessively noisy. If the result
241  // status was 1, assume the command failed normally. In particular, if it was
242  // the compiler then assume it gave a reasonable error code. Failures in other
243  // tools are less common, and they generally have worse diagnostics, so always
244  // print the diagnostic there.
245  const Tool &FailingTool = FailingCommand->getCreator();
246
247  if (!FailingCommand->getCreator().hasGoodDiagnostics() || Res != 1) {
248    // FIXME: See FIXME above regarding result code interpretation.
249    if (Res < 0)
250      Diag(clang::diag::err_drv_command_signalled)
251        << FailingTool.getShortName() << -Res;
252    else
253      Diag(clang::diag::err_drv_command_failed)
254        << FailingTool.getShortName() << Res;
255  }
256
257  return Res;
258}
259
260void Driver::PrintOptions(const ArgList &Args) const {
261  unsigned i = 0;
262  for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
263       it != ie; ++it, ++i) {
264    Arg *A = *it;
265    llvm::errs() << "Option " << i << " - "
266                 << "Name: \"" << A->getOption().getName() << "\", "
267                 << "Values: {";
268    for (unsigned j = 0; j < A->getNumValues(); ++j) {
269      if (j)
270        llvm::errs() << ", ";
271      llvm::errs() << '"' << A->getValue(Args, j) << '"';
272    }
273    llvm::errs() << "}\n";
274  }
275}
276
277void Driver::PrintHelp(bool ShowHidden) const {
278  getOpts().PrintHelp(llvm::outs(), Name.c_str(), DriverTitle.c_str(),
279                      ShowHidden);
280}
281
282void Driver::PrintVersion(const Compilation &C, llvm::raw_ostream &OS) const {
283  // FIXME: The following handlers should use a callback mechanism, we don't
284  // know what the client would like to do.
285  OS << getClangFullVersion() << '\n';
286  const ToolChain &TC = C.getDefaultToolChain();
287  OS << "Target: " << TC.getTripleString() << '\n';
288
289  // Print the threading model.
290  //
291  // FIXME: Implement correctly.
292  OS << "Thread model: " << "posix" << '\n';
293}
294
295/// PrintDiagnosticCategories - Implement the --print-diagnostic-categories
296/// option.
297static void PrintDiagnosticCategories(llvm::raw_ostream &OS) {
298  for (unsigned i = 1; // Skip the empty category.
299       const char *CategoryName = Diagnostic::getCategoryNameFromID(i); ++i)
300    OS << i << ',' << CategoryName << '\n';
301}
302
303bool Driver::HandleImmediateArgs(const Compilation &C) {
304  // The order these options are handled in gcc is all over the place, but we
305  // don't expect inconsistencies w.r.t. that to matter in practice.
306
307  if (C.getArgs().hasArg(options::OPT_dumpversion)) {
308    llvm::outs() << CLANG_VERSION_STRING "\n";
309    return false;
310  }
311
312  if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
313    PrintDiagnosticCategories(llvm::outs());
314    return false;
315  }
316
317  if (C.getArgs().hasArg(options::OPT__help) ||
318      C.getArgs().hasArg(options::OPT__help_hidden)) {
319    PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden));
320    return false;
321  }
322
323  if (C.getArgs().hasArg(options::OPT__version)) {
324    // Follow gcc behavior and use stdout for --version and stderr for -v.
325    PrintVersion(C, llvm::outs());
326    return false;
327  }
328
329  if (C.getArgs().hasArg(options::OPT_v) ||
330      C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
331    PrintVersion(C, llvm::errs());
332    SuppressMissingInputWarning = true;
333  }
334
335  const ToolChain &TC = C.getDefaultToolChain();
336  if (C.getArgs().hasArg(options::OPT_print_search_dirs)) {
337    llvm::outs() << "programs: =";
338    for (ToolChain::path_list::const_iterator it = TC.getProgramPaths().begin(),
339           ie = TC.getProgramPaths().end(); it != ie; ++it) {
340      if (it != TC.getProgramPaths().begin())
341        llvm::outs() << ':';
342      llvm::outs() << *it;
343    }
344    llvm::outs() << "\n";
345    llvm::outs() << "libraries: =";
346    for (ToolChain::path_list::const_iterator it = TC.getFilePaths().begin(),
347           ie = TC.getFilePaths().end(); it != ie; ++it) {
348      if (it != TC.getFilePaths().begin())
349        llvm::outs() << ':';
350      llvm::outs() << *it;
351    }
352    llvm::outs() << "\n";
353    return false;
354  }
355
356  // FIXME: The following handlers should use a callback mechanism, we don't
357  // know what the client would like to do.
358  if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
359    llvm::outs() << GetFilePath(A->getValue(C.getArgs()), TC) << "\n";
360    return false;
361  }
362
363  if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
364    llvm::outs() << GetProgramPath(A->getValue(C.getArgs()), TC) << "\n";
365    return false;
366  }
367
368  if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
369    llvm::outs() << GetFilePath("libgcc.a", TC) << "\n";
370    return false;
371  }
372
373  if (C.getArgs().hasArg(options::OPT_print_multi_lib)) {
374    // FIXME: We need tool chain support for this.
375    llvm::outs() << ".;\n";
376
377    switch (C.getDefaultToolChain().getTriple().getArch()) {
378    default:
379      break;
380
381    case llvm::Triple::x86_64:
382      llvm::outs() << "x86_64;@m64" << "\n";
383      break;
384
385    case llvm::Triple::ppc64:
386      llvm::outs() << "ppc64;@m64" << "\n";
387      break;
388    }
389    return false;
390  }
391
392  // FIXME: What is the difference between print-multi-directory and
393  // print-multi-os-directory?
394  if (C.getArgs().hasArg(options::OPT_print_multi_directory) ||
395      C.getArgs().hasArg(options::OPT_print_multi_os_directory)) {
396    switch (C.getDefaultToolChain().getTriple().getArch()) {
397    default:
398    case llvm::Triple::x86:
399    case llvm::Triple::ppc:
400      llvm::outs() << "." << "\n";
401      break;
402
403    case llvm::Triple::x86_64:
404      llvm::outs() << "x86_64" << "\n";
405      break;
406
407    case llvm::Triple::ppc64:
408      llvm::outs() << "ppc64" << "\n";
409      break;
410    }
411    return false;
412  }
413
414  return true;
415}
416
417static unsigned PrintActions1(const Compilation &C, Action *A,
418                              std::map<Action*, unsigned> &Ids) {
419  if (Ids.count(A))
420    return Ids[A];
421
422  std::string str;
423  llvm::raw_string_ostream os(str);
424
425  os << Action::getClassName(A->getKind()) << ", ";
426  if (InputAction *IA = dyn_cast<InputAction>(A)) {
427    os << "\"" << IA->getInputArg().getValue(C.getArgs()) << "\"";
428  } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) {
429    os << '"' << (BIA->getArchName() ? BIA->getArchName() :
430                  C.getDefaultToolChain().getArchName()) << '"'
431       << ", {" << PrintActions1(C, *BIA->begin(), Ids) << "}";
432  } else {
433    os << "{";
434    for (Action::iterator it = A->begin(), ie = A->end(); it != ie;) {
435      os << PrintActions1(C, *it, Ids);
436      ++it;
437      if (it != ie)
438        os << ", ";
439    }
440    os << "}";
441  }
442
443  unsigned Id = Ids.size();
444  Ids[A] = Id;
445  llvm::errs() << Id << ": " << os.str() << ", "
446               << types::getTypeName(A->getType()) << "\n";
447
448  return Id;
449}
450
451void Driver::PrintActions(const Compilation &C) const {
452  std::map<Action*, unsigned> Ids;
453  for (ActionList::const_iterator it = C.getActions().begin(),
454         ie = C.getActions().end(); it != ie; ++it)
455    PrintActions1(C, *it, Ids);
456}
457
458void Driver::BuildUniversalActions(const ArgList &Args,
459                                   ActionList &Actions) const {
460  llvm::PrettyStackTraceString CrashInfo("Building universal build actions");
461  // Collect the list of architectures. Duplicates are allowed, but should only
462  // be handled once (in the order seen).
463  llvm::StringSet<> ArchNames;
464  llvm::SmallVector<const char *, 4> Archs;
465  for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
466       it != ie; ++it) {
467    Arg *A = *it;
468
469    if (A->getOption().matches(options::OPT_arch)) {
470      // Validate the option here; we don't save the type here because its
471      // particular spelling may participate in other driver choices.
472      llvm::Triple::ArchType Arch =
473        llvm::Triple::getArchTypeForDarwinArchName(A->getValue(Args));
474      if (Arch == llvm::Triple::UnknownArch) {
475        Diag(clang::diag::err_drv_invalid_arch_name)
476          << A->getAsString(Args);
477        continue;
478      }
479
480      A->claim();
481      if (ArchNames.insert(A->getValue(Args)))
482        Archs.push_back(A->getValue(Args));
483    }
484  }
485
486  // When there is no explicit arch for this platform, make sure we still bind
487  // the architecture (to the default) so that -Xarch_ is handled correctly.
488  if (!Archs.size())
489    Archs.push_back(0);
490
491  // FIXME: We killed off some others but these aren't yet detected in a
492  // functional manner. If we added information to jobs about which "auxiliary"
493  // files they wrote then we could detect the conflict these cause downstream.
494  if (Archs.size() > 1) {
495    // No recovery needed, the point of this is just to prevent
496    // overwriting the same files.
497    if (const Arg *A = Args.getLastArg(options::OPT_save_temps))
498      Diag(clang::diag::err_drv_invalid_opt_with_multiple_archs)
499        << A->getAsString(Args);
500  }
501
502  ActionList SingleActions;
503  BuildActions(Args, SingleActions);
504
505  // Add in arch bindings for every top level action, as well as lipo and
506  // dsymutil steps if needed.
507  for (unsigned i = 0, e = SingleActions.size(); i != e; ++i) {
508    Action *Act = SingleActions[i];
509
510    // Make sure we can lipo this kind of output. If not (and it is an actual
511    // output) then we disallow, since we can't create an output file with the
512    // right name without overwriting it. We could remove this oddity by just
513    // changing the output names to include the arch, which would also fix
514    // -save-temps. Compatibility wins for now.
515
516    if (Archs.size() > 1 && !types::canLipoType(Act->getType()))
517      Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
518        << types::getTypeName(Act->getType());
519
520    ActionList Inputs;
521    for (unsigned i = 0, e = Archs.size(); i != e; ++i) {
522      Inputs.push_back(new BindArchAction(Act, Archs[i]));
523      if (i != 0)
524        Inputs.back()->setOwnsInputs(false);
525    }
526
527    // Lipo if necessary, we do it this way because we need to set the arch flag
528    // so that -Xarch_ gets overwritten.
529    if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
530      Actions.append(Inputs.begin(), Inputs.end());
531    else
532      Actions.push_back(new LipoJobAction(Inputs, Act->getType()));
533
534    // Add a 'dsymutil' step if necessary.
535    if (Act->getType() == types::TY_Image) {
536      Arg *A = Args.getLastArg(options::OPT_g_Group);
537      if (A && !A->getOption().matches(options::OPT_g0) &&
538          !A->getOption().matches(options::OPT_gstabs)) {
539        ActionList Inputs;
540        Inputs.push_back(Actions.back());
541        Actions.pop_back();
542
543        Actions.push_back(new DsymutilJobAction(Inputs, types::TY_dSYM));
544      }
545    }
546  }
547}
548
549void Driver::BuildActions(const ArgList &Args, ActionList &Actions) const {
550  llvm::PrettyStackTraceString CrashInfo("Building compilation actions");
551  // Start by constructing the list of inputs and their types.
552
553  // Track the current user specified (-x) input. We also explicitly track the
554  // argument used to set the type; we only want to claim the type when we
555  // actually use it, so we warn about unused -x arguments.
556  types::ID InputType = types::TY_Nothing;
557  Arg *InputTypeArg = 0;
558
559  llvm::SmallVector<std::pair<types::ID, const Arg*>, 16> Inputs;
560  for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
561       it != ie; ++it) {
562    Arg *A = *it;
563
564    if (isa<InputOption>(A->getOption())) {
565      const char *Value = A->getValue(Args);
566      types::ID Ty = types::TY_INVALID;
567
568      // Infer the input type if necessary.
569      if (InputType == types::TY_Nothing) {
570        // If there was an explicit arg for this, claim it.
571        if (InputTypeArg)
572          InputTypeArg->claim();
573
574        // stdin must be handled specially.
575        if (memcmp(Value, "-", 2) == 0) {
576          // If running with -E, treat as a C input (this changes the builtin
577          // macros, for example). This may be overridden by -ObjC below.
578          //
579          // Otherwise emit an error but still use a valid type to avoid
580          // spurious errors (e.g., no inputs).
581          if (!Args.hasArgNoClaim(options::OPT_E))
582            Diag(clang::diag::err_drv_unknown_stdin_type);
583          Ty = types::TY_C;
584        } else {
585          // Otherwise lookup by extension, and fallback to ObjectType if not
586          // found. We use a host hook here because Darwin at least has its own
587          // idea of what .s is.
588          if (const char *Ext = strrchr(Value, '.'))
589            Ty = Host->lookupTypeForExtension(Ext + 1);
590
591          if (Ty == types::TY_INVALID)
592            Ty = types::TY_Object;
593
594          // If the driver is invoked as C++ compiler (like clang++ or c++) it
595          // should autodetect some input files as C++ for g++ compatibility.
596          if (CCCIsCXX) {
597            types::ID OldTy = Ty;
598            Ty = types::lookupCXXTypeForCType(Ty);
599
600            if (Ty != OldTy)
601              Diag(clang::diag::warn_drv_treating_input_as_cxx)
602                << getTypeName(OldTy) << getTypeName(Ty);
603          }
604        }
605
606        // -ObjC and -ObjC++ override the default language, but only for "source
607        // files". We just treat everything that isn't a linker input as a
608        // source file.
609        //
610        // FIXME: Clean this up if we move the phase sequence into the type.
611        if (Ty != types::TY_Object) {
612          if (Args.hasArg(options::OPT_ObjC))
613            Ty = types::TY_ObjC;
614          else if (Args.hasArg(options::OPT_ObjCXX))
615            Ty = types::TY_ObjCXX;
616        }
617      } else {
618        assert(InputTypeArg && "InputType set w/o InputTypeArg");
619        InputTypeArg->claim();
620        Ty = InputType;
621      }
622
623      // Check that the file exists, if enabled.
624      if (CheckInputsExist && memcmp(Value, "-", 2) != 0 &&
625          !llvm::sys::Path(Value).exists())
626        Diag(clang::diag::err_drv_no_such_file) << A->getValue(Args);
627      else
628        Inputs.push_back(std::make_pair(Ty, A));
629
630    } else if (A->getOption().isLinkerInput()) {
631      // Just treat as object type, we could make a special type for this if
632      // necessary.
633      Inputs.push_back(std::make_pair(types::TY_Object, A));
634
635    } else if (A->getOption().matches(options::OPT_x)) {
636      InputTypeArg = A;
637      InputType = types::lookupTypeForTypeSpecifier(A->getValue(Args));
638
639      // Follow gcc behavior and treat as linker input for invalid -x
640      // options. Its not clear why we shouldn't just revert to unknown; but
641      // this isn't very important, we might as well be bug comatible.
642      if (!InputType) {
643        Diag(clang::diag::err_drv_unknown_language) << A->getValue(Args);
644        InputType = types::TY_Object;
645      }
646    }
647  }
648
649  if (!SuppressMissingInputWarning && Inputs.empty()) {
650    Diag(clang::diag::err_drv_no_input_files);
651    return;
652  }
653
654  // Determine which compilation mode we are in. We look for options which
655  // affect the phase, starting with the earliest phases, and record which
656  // option we used to determine the final phase.
657  Arg *FinalPhaseArg = 0;
658  phases::ID FinalPhase;
659
660  // -{E,M,MM} only run the preprocessor.
661  if ((FinalPhaseArg = Args.getLastArg(options::OPT_E)) ||
662      (FinalPhaseArg = Args.getLastArg(options::OPT_M)) ||
663      (FinalPhaseArg = Args.getLastArg(options::OPT_MM))) {
664    FinalPhase = phases::Preprocess;
665
666    // -{fsyntax-only,-analyze,emit-ast,S} only run up to the compiler.
667  } else if ((FinalPhaseArg = Args.getLastArg(options::OPT_fsyntax_only)) ||
668             (FinalPhaseArg = Args.getLastArg(options::OPT_rewrite_objc)) ||
669             (FinalPhaseArg = Args.getLastArg(options::OPT__analyze,
670                                              options::OPT__analyze_auto)) ||
671             (FinalPhaseArg = Args.getLastArg(options::OPT_emit_ast)) ||
672             (FinalPhaseArg = Args.getLastArg(options::OPT_S))) {
673    FinalPhase = phases::Compile;
674
675    // -c only runs up to the assembler.
676  } else if ((FinalPhaseArg = Args.getLastArg(options::OPT_c))) {
677    FinalPhase = phases::Assemble;
678
679    // Otherwise do everything.
680  } else
681    FinalPhase = phases::Link;
682
683  // Reject -Z* at the top level, these options should never have been exposed
684  // by gcc.
685  if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
686    Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
687
688  // Construct the actions to perform.
689  ActionList LinkerInputs;
690  for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
691    types::ID InputType = Inputs[i].first;
692    const Arg *InputArg = Inputs[i].second;
693
694    unsigned NumSteps = types::getNumCompilationPhases(InputType);
695    assert(NumSteps && "Invalid number of steps!");
696
697    // If the first step comes after the final phase we are doing as part of
698    // this compilation, warn the user about it.
699    phases::ID InitialPhase = types::getCompilationPhase(InputType, 0);
700    if (InitialPhase > FinalPhase) {
701      // Claim here to avoid the more general unused warning.
702      InputArg->claim();
703
704      // Special case '-E' warning on a previously preprocessed file to make
705      // more sense.
706      if (InitialPhase == phases::Compile && FinalPhase == phases::Preprocess &&
707          getPreprocessedType(InputType) == types::TY_INVALID)
708        Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
709          << InputArg->getAsString(Args)
710          << FinalPhaseArg->getOption().getName();
711      else
712        Diag(clang::diag::warn_drv_input_file_unused)
713          << InputArg->getAsString(Args)
714          << getPhaseName(InitialPhase)
715          << FinalPhaseArg->getOption().getName();
716      continue;
717    }
718
719    // Build the pipeline for this file.
720    llvm::OwningPtr<Action> Current(new InputAction(*InputArg, InputType));
721    for (unsigned i = 0; i != NumSteps; ++i) {
722      phases::ID Phase = types::getCompilationPhase(InputType, i);
723
724      // We are done if this step is past what the user requested.
725      if (Phase > FinalPhase)
726        break;
727
728      // Queue linker inputs.
729      if (Phase == phases::Link) {
730        assert(i + 1 == NumSteps && "linking must be final compilation step.");
731        LinkerInputs.push_back(Current.take());
732        break;
733      }
734
735      // Some types skip the assembler phase (e.g., llvm-bc), but we can't
736      // encode this in the steps because the intermediate type depends on
737      // arguments. Just special case here.
738      if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm)
739        continue;
740
741      // Otherwise construct the appropriate action.
742      Current.reset(ConstructPhaseAction(Args, Phase, Current.take()));
743      if (Current->getType() == types::TY_Nothing)
744        break;
745    }
746
747    // If we ended with something, add to the output list.
748    if (Current)
749      Actions.push_back(Current.take());
750  }
751
752  // Add a link action if necessary.
753  if (!LinkerInputs.empty())
754    Actions.push_back(new LinkJobAction(LinkerInputs, types::TY_Image));
755
756  // If we are linking, claim any options which are obviously only used for
757  // compilation.
758  if (FinalPhase == phases::Link)
759    Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
760}
761
762Action *Driver::ConstructPhaseAction(const ArgList &Args, phases::ID Phase,
763                                     Action *Input) const {
764  llvm::PrettyStackTraceString CrashInfo("Constructing phase actions");
765  // Build the appropriate action.
766  switch (Phase) {
767  case phases::Link: assert(0 && "link action invalid here.");
768  case phases::Preprocess: {
769    types::ID OutputTy;
770    // -{M, MM} alter the output type.
771    if (Args.hasArg(options::OPT_M) || Args.hasArg(options::OPT_MM)) {
772      OutputTy = types::TY_Dependencies;
773    } else {
774      OutputTy = types::getPreprocessedType(Input->getType());
775      assert(OutputTy != types::TY_INVALID &&
776             "Cannot preprocess this input type!");
777    }
778    return new PreprocessJobAction(Input, OutputTy);
779  }
780  case phases::Precompile:
781    return new PrecompileJobAction(Input, types::TY_PCH);
782  case phases::Compile: {
783    bool HasO4 = false;
784    if (const Arg *A = Args.getLastArg(options::OPT_O_Group))
785      HasO4 = A->getOption().matches(options::OPT_O4);
786
787    if (Args.hasArg(options::OPT_fsyntax_only)) {
788      return new CompileJobAction(Input, types::TY_Nothing);
789    } else if (Args.hasArg(options::OPT_rewrite_objc)) {
790      return new CompileJobAction(Input, types::TY_RewrittenObjC);
791    } else if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto)) {
792      return new AnalyzeJobAction(Input, types::TY_Plist);
793    } else if (Args.hasArg(options::OPT_emit_ast)) {
794      return new CompileJobAction(Input, types::TY_AST);
795    } else if (Args.hasArg(options::OPT_emit_llvm) ||
796               Args.hasArg(options::OPT_flto) || HasO4) {
797      types::ID Output =
798        Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
799      return new CompileJobAction(Input, Output);
800    } else {
801      return new CompileJobAction(Input, types::TY_PP_Asm);
802    }
803  }
804  case phases::Assemble:
805    return new AssembleJobAction(Input, types::TY_Object);
806  }
807
808  assert(0 && "invalid phase in ConstructPhaseAction");
809  return 0;
810}
811
812void Driver::BuildJobs(Compilation &C) const {
813  llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
814  bool SaveTemps = C.getArgs().hasArg(options::OPT_save_temps);
815  bool UsePipes = C.getArgs().hasArg(options::OPT_pipe);
816
817  // FIXME: Pipes are forcibly disabled until we support executing them.
818  if (!CCCPrintBindings)
819    UsePipes = false;
820
821  // -save-temps inhibits pipes.
822  if (SaveTemps && UsePipes)
823    Diag(clang::diag::warn_drv_pipe_ignored_with_save_temps);
824
825  Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
826
827  // It is an error to provide a -o option if we are making multiple output
828  // files.
829  if (FinalOutput) {
830    unsigned NumOutputs = 0;
831    for (ActionList::const_iterator it = C.getActions().begin(),
832           ie = C.getActions().end(); it != ie; ++it)
833      if ((*it)->getType() != types::TY_Nothing)
834        ++NumOutputs;
835
836    if (NumOutputs > 1) {
837      Diag(clang::diag::err_drv_output_argument_with_multiple_files);
838      FinalOutput = 0;
839    }
840  }
841
842  for (ActionList::const_iterator it = C.getActions().begin(),
843         ie = C.getActions().end(); it != ie; ++it) {
844    Action *A = *it;
845
846    // If we are linking an image for multiple archs then the linker wants
847    // -arch_multiple and -final_output <final image name>. Unfortunately, this
848    // doesn't fit in cleanly because we have to pass this information down.
849    //
850    // FIXME: This is a hack; find a cleaner way to integrate this into the
851    // process.
852    const char *LinkingOutput = 0;
853    if (isa<LipoJobAction>(A)) {
854      if (FinalOutput)
855        LinkingOutput = FinalOutput->getValue(C.getArgs());
856      else
857        LinkingOutput = DefaultImageName.c_str();
858    }
859
860    InputInfo II;
861    BuildJobsForAction(C, A, &C.getDefaultToolChain(),
862                       /*BoundArch*/0,
863                       /*CanAcceptPipe*/ true,
864                       /*AtTopLevel*/ true,
865                       /*LinkingOutput*/ LinkingOutput,
866                       II);
867  }
868
869  // If the user passed -Qunused-arguments or there were errors, don't warn
870  // about any unused arguments.
871  if (Diags.getNumErrors() ||
872      C.getArgs().hasArg(options::OPT_Qunused_arguments))
873    return;
874
875  // Claim -### here.
876  (void) C.getArgs().hasArg(options::OPT__HASH_HASH_HASH);
877
878  for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end();
879       it != ie; ++it) {
880    Arg *A = *it;
881
882    // FIXME: It would be nice to be able to send the argument to the
883    // Diagnostic, so that extra values, position, and so on could be printed.
884    if (!A->isClaimed()) {
885      if (A->getOption().hasNoArgumentUnused())
886        continue;
887
888      // Suppress the warning automatically if this is just a flag, and it is an
889      // instance of an argument we already claimed.
890      const Option &Opt = A->getOption();
891      if (isa<FlagOption>(Opt)) {
892        bool DuplicateClaimed = false;
893
894        for (arg_iterator it = C.getArgs().filtered_begin(&Opt),
895               ie = C.getArgs().filtered_end(); it != ie; ++it) {
896          if ((*it)->isClaimed()) {
897            DuplicateClaimed = true;
898            break;
899          }
900        }
901
902        if (DuplicateClaimed)
903          continue;
904      }
905
906      Diag(clang::diag::warn_drv_unused_argument)
907        << A->getAsString(C.getArgs());
908    }
909  }
910}
911
912static const Tool &SelectToolForJob(Compilation &C, const ToolChain *TC,
913                                    const JobAction *JA,
914                                    const ActionList *&Inputs) {
915  const Tool *ToolForJob = 0;
916
917  // See if we should look for a compiler with an integrated assembler. We match
918  // bottom up, so what we are actually looking for is an assembler job with a
919  // compiler input.
920
921  // FIXME: This doesn't belong here, but ideally we will support static soon
922  // anyway.
923  bool HasStatic = (C.getArgs().hasArg(options::OPT_mkernel) ||
924                    C.getArgs().hasArg(options::OPT_static) ||
925                    C.getArgs().hasArg(options::OPT_fapple_kext));
926  bool IsIADefault = (TC->IsIntegratedAssemblerDefault() && !HasStatic);
927  if (C.getArgs().hasFlag(options::OPT_integrated_as,
928                         options::OPT_no_integrated_as,
929                         IsIADefault) &&
930      !C.getArgs().hasArg(options::OPT_save_temps) &&
931      isa<AssembleJobAction>(JA) &&
932      Inputs->size() == 1 && isa<CompileJobAction>(*Inputs->begin())) {
933    const Tool &Compiler = TC->SelectTool(C,cast<JobAction>(**Inputs->begin()));
934    if (Compiler.hasIntegratedAssembler()) {
935      Inputs = &(*Inputs)[0]->getInputs();
936      ToolForJob = &Compiler;
937    }
938  }
939
940  // Otherwise use the tool for the current job.
941  if (!ToolForJob)
942    ToolForJob = &TC->SelectTool(C, *JA);
943
944  // See if we should use an integrated preprocessor. We do so when we have
945  // exactly one input, since this is the only use case we care about
946  // (irrelevant since we don't support combine yet).
947  if (Inputs->size() == 1 && isa<PreprocessJobAction>(*Inputs->begin()) &&
948      !C.getArgs().hasArg(options::OPT_no_integrated_cpp) &&
949      !C.getArgs().hasArg(options::OPT_traditional_cpp) &&
950      !C.getArgs().hasArg(options::OPT_save_temps) &&
951      ToolForJob->hasIntegratedCPP())
952    Inputs = &(*Inputs)[0]->getInputs();
953
954  return *ToolForJob;
955}
956
957void Driver::BuildJobsForAction(Compilation &C,
958                                const Action *A,
959                                const ToolChain *TC,
960                                const char *BoundArch,
961                                bool CanAcceptPipe,
962                                bool AtTopLevel,
963                                const char *LinkingOutput,
964                                InputInfo &Result) const {
965  llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
966
967  bool UsePipes = C.getArgs().hasArg(options::OPT_pipe);
968  // FIXME: Pipes are forcibly disabled until we support executing them.
969  if (!CCCPrintBindings)
970    UsePipes = false;
971
972  if (const InputAction *IA = dyn_cast<InputAction>(A)) {
973    // FIXME: It would be nice to not claim this here; maybe the old scheme of
974    // just using Args was better?
975    const Arg &Input = IA->getInputArg();
976    Input.claim();
977    if (Input.getOption().matches(options::OPT_INPUT)) {
978      const char *Name = Input.getValue(C.getArgs());
979      Result = InputInfo(Name, A->getType(), Name);
980    } else
981      Result = InputInfo(&Input, A->getType(), "");
982    return;
983  }
984
985  if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) {
986    const ToolChain *TC = &C.getDefaultToolChain();
987
988    std::string Arch;
989    if (BAA->getArchName())
990      TC = Host->CreateToolChain(C.getArgs(), BAA->getArchName());
991
992    BuildJobsForAction(C, *BAA->begin(), TC, BAA->getArchName(),
993                       CanAcceptPipe, AtTopLevel, LinkingOutput, Result);
994    return;
995  }
996
997  const ActionList *Inputs = &A->getInputs();
998
999  const JobAction *JA = cast<JobAction>(A);
1000  const Tool &T = SelectToolForJob(C, TC, JA, Inputs);
1001
1002  // Only use pipes when there is exactly one input.
1003  bool TryToUsePipeInput = Inputs->size() == 1 && T.acceptsPipedInput();
1004  InputInfoList InputInfos;
1005  for (ActionList::const_iterator it = Inputs->begin(), ie = Inputs->end();
1006       it != ie; ++it) {
1007    // Treat dsymutil sub-jobs as being at the top-level too, they shouldn't get
1008    // temporary output names.
1009    //
1010    // FIXME: Clean this up.
1011    bool SubJobAtTopLevel = false;
1012    if (AtTopLevel && isa<DsymutilJobAction>(A))
1013      SubJobAtTopLevel = true;
1014
1015    InputInfo II;
1016    BuildJobsForAction(C, *it, TC, BoundArch, TryToUsePipeInput,
1017                       SubJobAtTopLevel, LinkingOutput, II);
1018    InputInfos.push_back(II);
1019  }
1020
1021  // Determine if we should output to a pipe.
1022  bool OutputToPipe = false;
1023  if (CanAcceptPipe && T.canPipeOutput()) {
1024    // Some actions default to writing to a pipe if they are the top level phase
1025    // and there was no user override.
1026    //
1027    // FIXME: Is there a better way to handle this?
1028    if (AtTopLevel) {
1029      if (isa<PreprocessJobAction>(A) && !C.getArgs().hasArg(options::OPT_o))
1030        OutputToPipe = true;
1031    } else if (UsePipes)
1032      OutputToPipe = true;
1033  }
1034
1035  // Figure out where to put the job (pipes).
1036  Job *Dest = &C.getJobs();
1037  if (InputInfos[0].isPipe()) {
1038    assert(TryToUsePipeInput && "Unrequested pipe!");
1039    assert(InputInfos.size() == 1 && "Unexpected pipe with multiple inputs.");
1040    Dest = &InputInfos[0].getPipe();
1041  }
1042
1043  // Always use the first input as the base input.
1044  const char *BaseInput = InputInfos[0].getBaseInput();
1045
1046  // ... except dsymutil actions, which use their actual input as the base
1047  // input.
1048  if (JA->getType() == types::TY_dSYM)
1049    BaseInput = InputInfos[0].getFilename();
1050
1051  // Determine the place to write output to (nothing, pipe, or filename) and
1052  // where to put the new job.
1053  if (JA->getType() == types::TY_Nothing) {
1054    Result = InputInfo(A->getType(), BaseInput);
1055  } else if (OutputToPipe) {
1056    // Append to current piped job or create a new one as appropriate.
1057    PipedJob *PJ = dyn_cast<PipedJob>(Dest);
1058    if (!PJ) {
1059      PJ = new PipedJob();
1060      // FIXME: Temporary hack so that -ccc-print-bindings work until we have
1061      // pipe support. Please remove later.
1062      if (!CCCPrintBindings)
1063        cast<JobList>(Dest)->addJob(PJ);
1064      Dest = PJ;
1065    }
1066    Result = InputInfo(PJ, A->getType(), BaseInput);
1067  } else {
1068    Result = InputInfo(GetNamedOutputPath(C, *JA, BaseInput, AtTopLevel),
1069                       A->getType(), BaseInput);
1070  }
1071
1072  if (CCCPrintBindings) {
1073    llvm::errs() << "# \"" << T.getToolChain().getTripleString() << '"'
1074                 << " - \"" << T.getName() << "\", inputs: [";
1075    for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
1076      llvm::errs() << InputInfos[i].getAsString();
1077      if (i + 1 != e)
1078        llvm::errs() << ", ";
1079    }
1080    llvm::errs() << "], output: " << Result.getAsString() << "\n";
1081  } else {
1082    T.ConstructJob(C, *JA, *Dest, Result, InputInfos,
1083                   C.getArgsForToolChain(TC, BoundArch), LinkingOutput);
1084  }
1085}
1086
1087const char *Driver::GetNamedOutputPath(Compilation &C,
1088                                       const JobAction &JA,
1089                                       const char *BaseInput,
1090                                       bool AtTopLevel) const {
1091  llvm::PrettyStackTraceString CrashInfo("Computing output path");
1092  // Output to a user requested destination?
1093  if (AtTopLevel && !isa<DsymutilJobAction>(JA)) {
1094    if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
1095      return C.addResultFile(FinalOutput->getValue(C.getArgs()));
1096  }
1097
1098  // Output to a temporary file?
1099  if (!AtTopLevel && !C.getArgs().hasArg(options::OPT_save_temps)) {
1100    std::string TmpName =
1101      GetTemporaryPath(types::getTypeTempSuffix(JA.getType()));
1102    return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
1103  }
1104
1105  llvm::sys::Path BasePath(BaseInput);
1106  std::string BaseName(BasePath.getLast());
1107
1108  // Determine what the derived output name should be.
1109  const char *NamedOutput;
1110  if (JA.getType() == types::TY_Image) {
1111    NamedOutput = DefaultImageName.c_str();
1112  } else {
1113    const char *Suffix = types::getTypeTempSuffix(JA.getType());
1114    assert(Suffix && "All types used for output should have a suffix.");
1115
1116    std::string::size_type End = std::string::npos;
1117    if (!types::appendSuffixForType(JA.getType()))
1118      End = BaseName.rfind('.');
1119    std::string Suffixed(BaseName.substr(0, End));
1120    Suffixed += '.';
1121    Suffixed += Suffix;
1122    NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str());
1123  }
1124
1125  // As an annoying special case, PCH generation doesn't strip the pathname.
1126  if (JA.getType() == types::TY_PCH) {
1127    BasePath.eraseComponent();
1128    if (BasePath.isEmpty())
1129      BasePath = NamedOutput;
1130    else
1131      BasePath.appendComponent(NamedOutput);
1132    return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str()));
1133  } else {
1134    return C.addResultFile(NamedOutput);
1135  }
1136}
1137
1138std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const {
1139  // Respect a limited subset of the '-Bprefix' functionality in GCC by
1140  // attempting to use this prefix when lokup up program paths.
1141  if (!PrefixDir.empty()) {
1142    llvm::sys::Path P(PrefixDir);
1143    P.appendComponent(Name);
1144    if (P.exists())
1145      return P.str();
1146  }
1147
1148  const ToolChain::path_list &List = TC.getFilePaths();
1149  for (ToolChain::path_list::const_iterator
1150         it = List.begin(), ie = List.end(); it != ie; ++it) {
1151    llvm::sys::Path P(*it);
1152    P.appendComponent(Name);
1153    if (P.exists())
1154      return P.str();
1155  }
1156
1157  return Name;
1158}
1159
1160std::string Driver::GetProgramPath(const char *Name, const ToolChain &TC,
1161                                   bool WantFile) const {
1162  // Respect a limited subset of the '-Bprefix' functionality in GCC by
1163  // attempting to use this prefix when lokup up program paths.
1164  if (!PrefixDir.empty()) {
1165    llvm::sys::Path P(PrefixDir);
1166    P.appendComponent(Name);
1167    if (WantFile ? P.exists() : P.canExecute())
1168      return P.str();
1169  }
1170
1171  const ToolChain::path_list &List = TC.getProgramPaths();
1172  for (ToolChain::path_list::const_iterator
1173         it = List.begin(), ie = List.end(); it != ie; ++it) {
1174    llvm::sys::Path P(*it);
1175    P.appendComponent(Name);
1176    if (WantFile ? P.exists() : P.canExecute())
1177      return P.str();
1178  }
1179
1180  // If all else failed, search the path.
1181  llvm::sys::Path P(llvm::sys::Program::FindProgramByName(Name));
1182  if (!P.empty())
1183    return P.str();
1184
1185  return Name;
1186}
1187
1188std::string Driver::GetTemporaryPath(const char *Suffix) const {
1189  // FIXME: This is lame; sys::Path should provide this function (in particular,
1190  // it should know how to find the temporary files dir).
1191  std::string Error;
1192  const char *TmpDir = ::getenv("TMPDIR");
1193  if (!TmpDir)
1194    TmpDir = ::getenv("TEMP");
1195  if (!TmpDir)
1196    TmpDir = ::getenv("TMP");
1197  if (!TmpDir)
1198    TmpDir = "/tmp";
1199  llvm::sys::Path P(TmpDir);
1200  P.appendComponent("cc");
1201  if (P.makeUnique(false, &Error)) {
1202    Diag(clang::diag::err_drv_unable_to_make_temp) << Error;
1203    return "";
1204  }
1205
1206  // FIXME: Grumble, makeUnique sometimes leaves the file around!?  PR3837.
1207  P.eraseFromDisk(false, 0);
1208
1209  P.appendSuffix(Suffix);
1210  return P.str();
1211}
1212
1213const HostInfo *Driver::GetHostInfo(const char *TripleStr) const {
1214  llvm::PrettyStackTraceString CrashInfo("Constructing host");
1215  llvm::Triple Triple(TripleStr);
1216
1217  // TCE is an osless target
1218  if (Triple.getArchName() == "tce")
1219    return createTCEHostInfo(*this, Triple);
1220
1221  switch (Triple.getOS()) {
1222  case llvm::Triple::AuroraUX:
1223    return createAuroraUXHostInfo(*this, Triple);
1224  case llvm::Triple::Darwin:
1225    return createDarwinHostInfo(*this, Triple);
1226  case llvm::Triple::DragonFly:
1227    return createDragonFlyHostInfo(*this, Triple);
1228  case llvm::Triple::OpenBSD:
1229    return createOpenBSDHostInfo(*this, Triple);
1230  case llvm::Triple::FreeBSD:
1231    return createFreeBSDHostInfo(*this, Triple);
1232  case llvm::Triple::Linux:
1233    return createLinuxHostInfo(*this, Triple);
1234  default:
1235    return createUnknownHostInfo(*this, Triple);
1236  }
1237}
1238
1239bool Driver::ShouldUseClangCompiler(const Compilation &C, const JobAction &JA,
1240                                    const llvm::Triple &Triple) const {
1241  // Check if user requested no clang, or clang doesn't understand this type (we
1242  // only handle single inputs for now).
1243  if (!CCCUseClang || JA.size() != 1 ||
1244      !types::isAcceptedByClang((*JA.begin())->getType()))
1245    return false;
1246
1247  // Otherwise make sure this is an action clang understands.
1248  if (isa<PreprocessJobAction>(JA)) {
1249    if (!CCCUseClangCPP) {
1250      Diag(clang::diag::warn_drv_not_using_clang_cpp);
1251      return false;
1252    }
1253  } else if (!isa<PrecompileJobAction>(JA) && !isa<CompileJobAction>(JA))
1254    return false;
1255
1256  // Use clang for C++?
1257  if (!CCCUseClangCXX && types::isCXX((*JA.begin())->getType())) {
1258    Diag(clang::diag::warn_drv_not_using_clang_cxx);
1259    return false;
1260  }
1261
1262  // Always use clang for precompiling, AST generation, and rewriting,
1263  // regardless of archs.
1264  if (isa<PrecompileJobAction>(JA) ||
1265      types::isOnlyAcceptedByClang(JA.getType()))
1266    return true;
1267
1268  // Finally, don't use clang if this isn't one of the user specified archs to
1269  // build.
1270  if (!CCCClangArchs.empty() && !CCCClangArchs.count(Triple.getArch())) {
1271    Diag(clang::diag::warn_drv_not_using_clang_arch) << Triple.getArchName();
1272    return false;
1273  }
1274
1275  return true;
1276}
1277
1278/// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the
1279/// grouped values as integers. Numbers which are not provided are set to 0.
1280///
1281/// \return True if the entire string was parsed (9.2), or all groups were
1282/// parsed (10.3.5extrastuff).
1283bool Driver::GetReleaseVersion(const char *Str, unsigned &Major,
1284                               unsigned &Minor, unsigned &Micro,
1285                               bool &HadExtra) {
1286  HadExtra = false;
1287
1288  Major = Minor = Micro = 0;
1289  if (*Str == '\0')
1290    return true;
1291
1292  char *End;
1293  Major = (unsigned) strtol(Str, &End, 10);
1294  if (*Str != '\0' && *End == '\0')
1295    return true;
1296  if (*End != '.')
1297    return false;
1298
1299  Str = End+1;
1300  Minor = (unsigned) strtol(Str, &End, 10);
1301  if (*Str != '\0' && *End == '\0')
1302    return true;
1303  if (*End != '.')
1304    return false;
1305
1306  Str = End+1;
1307  Micro = (unsigned) strtol(Str, &End, 10);
1308  if (*Str != '\0' && *End == '\0')
1309    return true;
1310  if (Str == End)
1311    return false;
1312  HadExtra = true;
1313  return true;
1314}
1315