Driver.cpp revision 73052bf669d3fe4c202cff2792cfe215cf5727be 
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#include "InputInfo.h"
12#include "ToolChains.h"
13#include "clang/Basic/Version.h"
14#include "clang/Driver/Action.h"
15#include "clang/Driver/Compilation.h"
16#include "clang/Driver/DriverDiagnostic.h"
17#include "clang/Driver/Job.h"
18#include "clang/Driver/Options.h"
19#include "clang/Driver/Tool.h"
20#include "clang/Driver/ToolChain.h"
21#include "llvm/ADT/ArrayRef.h"
22#include "llvm/ADT/OwningPtr.h"
23#include "llvm/ADT/STLExtras.h"
24#include "llvm/ADT/StringSet.h"
25#include "llvm/ADT/StringSwitch.h"
26#include "llvm/Option/Arg.h"
27#include "llvm/Option/ArgList.h"
28#include "llvm/Option/OptTable.h"
29#include "llvm/Option/Option.h"
30#include "llvm/Option/OptSpecifier.h"
31#include "llvm/Support/Debug.h"
32#include "llvm/Support/ErrorHandling.h"
33#include "llvm/Support/FileSystem.h"
34#include "llvm/Support/Path.h"
35#include "llvm/Support/PrettyStackTrace.h"
36#include "llvm/Support/Program.h"
37#include "llvm/Support/raw_ostream.h"
38#include <map>
39
40// FIXME: It would prevent us from including llvm-config.h
41// if config.h were included before system_error.h.
42#include "clang/Config/config.h"
43
44using namespace clang::driver;
45using namespace clang;
46using namespace llvm::opt;
47
48Driver::Driver(StringRef ClangExecutable,
49               StringRef DefaultTargetTriple,
50               StringRef DefaultImageName,
51               DiagnosticsEngine &Diags)
52  : Opts(createDriverOptTable()), Diags(Diags), Mode(GCCMode),
53    ClangExecutable(ClangExecutable), SysRoot(DEFAULT_SYSROOT),
54    UseStdLib(true), DefaultTargetTriple(DefaultTargetTriple),
55    DefaultImageName(DefaultImageName),
56    DriverTitle("clang LLVM compiler"),
57    CCPrintOptionsFilename(0), CCPrintHeadersFilename(0),
58    CCLogDiagnosticsFilename(0),
59    CCCPrintBindings(false),
60    CCPrintOptions(false), CCPrintHeaders(false), CCLogDiagnostics(false),
61    CCGenDiagnostics(false), CCCGenericGCCName(""), CheckInputsExist(true),
62    CCCUsePCH(true), SuppressMissingInputWarning(false) {
63
64  Name = llvm::sys::path::stem(ClangExecutable);
65  Dir  = llvm::sys::path::parent_path(ClangExecutable);
66
67  // Compute the path to the resource directory.
68  StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
69  SmallString<128> P(Dir);
70  if (ClangResourceDir != "")
71    llvm::sys::path::append(P, ClangResourceDir);
72  else
73    llvm::sys::path::append(P, "..", "lib", "clang", CLANG_VERSION_STRING);
74  ResourceDir = P.str();
75}
76
77Driver::~Driver() {
78  delete Opts;
79
80  for (llvm::StringMap<ToolChain *>::iterator I = ToolChains.begin(),
81                                              E = ToolChains.end();
82       I != E; ++I)
83    delete I->second;
84}
85
86void Driver::ParseDriverMode(ArrayRef<const char *> Args) {
87  const std::string OptName =
88    getOpts().getOption(options::OPT_driver_mode).getPrefixedName();
89
90  for (size_t I = 0, E = Args.size(); I != E; ++I) {
91    const StringRef Arg = Args[I];
92    if (!Arg.startswith(OptName))
93      continue;
94
95    const StringRef Value = Arg.drop_front(OptName.size());
96    const unsigned M = llvm::StringSwitch<unsigned>(Value)
97        .Case("gcc", GCCMode)
98        .Case("g++", GXXMode)
99        .Case("cpp", CPPMode)
100        .Case("cl",  CLMode)
101        .Default(~0U);
102
103    if (M != ~0U)
104      Mode = static_cast<DriverMode>(M);
105    else
106      Diag(diag::err_drv_unsupported_option_argument) << OptName << Value;
107  }
108}
109
110InputArgList *Driver::ParseArgStrings(ArrayRef<const char *> ArgList) {
111  llvm::PrettyStackTraceString CrashInfo("Command line argument parsing");
112
113  unsigned IncludedFlagsBitmask;
114  unsigned ExcludedFlagsBitmask;
115  llvm::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
116    getIncludeExcludeOptionFlagMasks();
117
118  unsigned MissingArgIndex, MissingArgCount;
119  InputArgList *Args = getOpts().ParseArgs(ArgList.begin(), ArgList.end(),
120                                           MissingArgIndex, MissingArgCount,
121                                           IncludedFlagsBitmask,
122                                           ExcludedFlagsBitmask);
123
124  // Check for missing argument error.
125  if (MissingArgCount)
126    Diag(clang::diag::err_drv_missing_argument)
127      << Args->getArgString(MissingArgIndex) << MissingArgCount;
128
129  // Check for unsupported options.
130  for (ArgList::const_iterator it = Args->begin(), ie = Args->end();
131       it != ie; ++it) {
132    Arg *A = *it;
133    if (A->getOption().hasFlag(options::Unsupported)) {
134      Diag(clang::diag::err_drv_unsupported_opt) << A->getAsString(*Args);
135      continue;
136    }
137
138    // Warn about -mcpu= without an argument.
139    if (A->getOption().matches(options::OPT_mcpu_EQ) &&
140        A->containsValue("")) {
141      Diag(clang::diag::warn_drv_empty_joined_argument) <<
142        A->getAsString(*Args);
143    }
144  }
145
146  return Args;
147}
148
149// Determine which compilation mode we are in. We look for options which
150// affect the phase, starting with the earliest phases, and record which
151// option we used to determine the final phase.
152phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, Arg **FinalPhaseArg)
153const {
154  Arg *PhaseArg = 0;
155  phases::ID FinalPhase;
156
157  // -{E,M,MM} only run the preprocessor.
158  if (CCCIsCPP() ||
159      (PhaseArg = DAL.getLastArg(options::OPT_E)) ||
160      (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM))) {
161    FinalPhase = phases::Preprocess;
162
163    // -{fsyntax-only,-analyze,emit-ast,S} only run up to the compiler.
164  } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) ||
165             (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) ||
166             (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) ||
167             (PhaseArg = DAL.getLastArg(options::OPT_rewrite_legacy_objc)) ||
168             (PhaseArg = DAL.getLastArg(options::OPT__migrate)) ||
169             (PhaseArg = DAL.getLastArg(options::OPT__analyze,
170                                        options::OPT__analyze_auto)) ||
171             (PhaseArg = DAL.getLastArg(options::OPT_emit_ast)) ||
172             (PhaseArg = DAL.getLastArg(options::OPT_S))) {
173    FinalPhase = phases::Compile;
174
175    // -c only runs up to the assembler.
176  } else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) {
177    FinalPhase = phases::Assemble;
178
179    // Otherwise do everything.
180  } else
181    FinalPhase = phases::Link;
182
183  if (FinalPhaseArg)
184    *FinalPhaseArg = PhaseArg;
185
186  return FinalPhase;
187}
188
189static Arg* MakeInputArg(const DerivedArgList &Args, OptTable *Opts,
190                         StringRef Value) {
191  Arg *A = new Arg(Opts->getOption(options::OPT_INPUT), Value,
192                   Args.getBaseArgs().MakeIndex(Value), Value.data());
193  A->claim();
194  return A;
195}
196
197DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const {
198  DerivedArgList *DAL = new DerivedArgList(Args);
199
200  bool HasNostdlib = Args.hasArg(options::OPT_nostdlib);
201  for (ArgList::const_iterator it = Args.begin(),
202         ie = Args.end(); it != ie; ++it) {
203    const Arg *A = *it;
204
205    // Unfortunately, we have to parse some forwarding options (-Xassembler,
206    // -Xlinker, -Xpreprocessor) because we either integrate their functionality
207    // (assembler and preprocessor), or bypass a previous driver ('collect2').
208
209    // Rewrite linker options, to replace --no-demangle with a custom internal
210    // option.
211    if ((A->getOption().matches(options::OPT_Wl_COMMA) ||
212         A->getOption().matches(options::OPT_Xlinker)) &&
213        A->containsValue("--no-demangle")) {
214      // Add the rewritten no-demangle argument.
215      DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle));
216
217      // Add the remaining values as Xlinker arguments.
218      for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
219        if (StringRef(A->getValue(i)) != "--no-demangle")
220          DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker),
221                              A->getValue(i));
222
223      continue;
224    }
225
226    // Rewrite preprocessor options, to replace -Wp,-MD,FOO which is used by
227    // some build systems. We don't try to be complete here because we don't
228    // care to encourage this usage model.
229    if (A->getOption().matches(options::OPT_Wp_COMMA) &&
230        (A->getValue(0) == StringRef("-MD") ||
231         A->getValue(0) == StringRef("-MMD"))) {
232      // Rewrite to -MD/-MMD along with -MF.
233      if (A->getValue(0) == StringRef("-MD"))
234        DAL->AddFlagArg(A, Opts->getOption(options::OPT_MD));
235      else
236        DAL->AddFlagArg(A, Opts->getOption(options::OPT_MMD));
237      if (A->getNumValues() == 2)
238        DAL->AddSeparateArg(A, Opts->getOption(options::OPT_MF),
239                            A->getValue(1));
240      continue;
241    }
242
243    // Rewrite reserved library names.
244    if (A->getOption().matches(options::OPT_l)) {
245      StringRef Value = A->getValue();
246
247      // Rewrite unless -nostdlib is present.
248      if (!HasNostdlib && Value == "stdc++") {
249        DAL->AddFlagArg(A, Opts->getOption(
250                              options::OPT_Z_reserved_lib_stdcxx));
251        continue;
252      }
253
254      // Rewrite unconditionally.
255      if (Value == "cc_kext") {
256        DAL->AddFlagArg(A, Opts->getOption(
257                              options::OPT_Z_reserved_lib_cckext));
258        continue;
259      }
260    }
261
262    // Pick up inputs via the -- option.
263    if (A->getOption().matches(options::OPT__DASH_DASH)) {
264      A->claim();
265      for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
266        DAL->append(MakeInputArg(*DAL, Opts, A->getValue(i)));
267      continue;
268    }
269
270    DAL->append(*it);
271  }
272
273  // Add a default value of -mlinker-version=, if one was given and the user
274  // didn't specify one.
275#if defined(HOST_LINK_VERSION)
276  if (!Args.hasArg(options::OPT_mlinker_version_EQ)) {
277    DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ),
278                      HOST_LINK_VERSION);
279    DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim();
280  }
281#endif
282
283  return DAL;
284}
285
286/// \brief Check whether there are multiple instances of OptionID in Args, and
287/// if so, issue a diagnostics about it.
288static void DiagnoseOptionOverride(const Driver &D, const DerivedArgList &Args,
289                                   unsigned OptionID) {
290  assert(Args.hasArg(OptionID));
291
292  arg_iterator it = Args.filtered_begin(OptionID);
293  arg_iterator ie = Args.filtered_end();
294  Arg *Previous = *it;
295  ++it;
296
297  while (it != ie) {
298    D.Diag(clang::diag::warn_drv_overriding_joined_option)
299        << Previous->getSpelling() << Previous->getValue()
300        << (*it)->getSpelling() << (*it)->getValue();
301    Previous = *it;
302    ++it;
303  }
304}
305
306Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
307  llvm::PrettyStackTraceString CrashInfo("Compilation construction");
308
309  // FIXME: Handle environment options which affect driver behavior, somewhere
310  // (client?). GCC_EXEC_PREFIX, LPATH, CC_PRINT_OPTIONS.
311
312  if (char *env = ::getenv("COMPILER_PATH")) {
313    StringRef CompilerPath = env;
314    while (!CompilerPath.empty()) {
315      std::pair<StringRef, StringRef> Split
316        = CompilerPath.split(llvm::sys::EnvPathSeparator);
317      PrefixDirs.push_back(Split.first);
318      CompilerPath = Split.second;
319    }
320  }
321
322  // We look for the driver mode option early, because the mode can affect
323  // how other options are parsed.
324  ParseDriverMode(ArgList.slice(1));
325
326  // FIXME: What are we going to do with -V and -b?
327
328  // FIXME: This stuff needs to go into the Compilation, not the driver.
329  bool CCCPrintOptions, CCCPrintActions;
330
331  InputArgList *Args = ParseArgStrings(ArgList.slice(1));
332
333  // -no-canonical-prefixes is used very early in main.
334  Args->ClaimAllArgs(options::OPT_no_canonical_prefixes);
335
336  // Ignore -pipe.
337  Args->ClaimAllArgs(options::OPT_pipe);
338
339  // Extract -ccc args.
340  //
341  // FIXME: We need to figure out where this behavior should live. Most of it
342  // should be outside in the client; the parts that aren't should have proper
343  // options, either by introducing new ones or by overloading gcc ones like -V
344  // or -b.
345  CCCPrintOptions = Args->hasArg(options::OPT_ccc_print_options);
346  CCCPrintActions = Args->hasArg(options::OPT_ccc_print_phases);
347  CCCPrintBindings = Args->hasArg(options::OPT_ccc_print_bindings);
348  if (const Arg *A = Args->getLastArg(options::OPT_ccc_gcc_name))
349    CCCGenericGCCName = A->getValue();
350  CCCUsePCH = Args->hasFlag(options::OPT_ccc_pch_is_pch,
351                            options::OPT_ccc_pch_is_pth);
352  // FIXME: DefaultTargetTriple is used by the target-prefixed calls to as/ld
353  // and getToolChain is const.
354  if (const Arg *A = Args->getLastArg(options::OPT_target))
355    DefaultTargetTriple = A->getValue();
356  if (const Arg *A = Args->getLastArg(options::OPT_ccc_install_dir))
357    Dir = InstalledDir = A->getValue();
358  for (arg_iterator it = Args->filtered_begin(options::OPT_B),
359         ie = Args->filtered_end(); it != ie; ++it) {
360    const Arg *A = *it;
361    A->claim();
362    PrefixDirs.push_back(A->getValue(0));
363  }
364  if (const Arg *A = Args->getLastArg(options::OPT__sysroot_EQ))
365    SysRoot = A->getValue();
366  if (const Arg *A = Args->getLastArg(options::OPT__dyld_prefix_EQ))
367    DyldPrefix = A->getValue();
368  if (Args->hasArg(options::OPT_nostdlib))
369    UseStdLib = false;
370
371  if (const Arg *A = Args->getLastArg(options::OPT_resource_dir))
372    ResourceDir = A->getValue();
373
374  // Perform the default argument translations.
375  DerivedArgList *TranslatedArgs = TranslateInputArgs(*Args);
376
377  // Owned by the host.
378  const ToolChain &TC = getToolChain(*Args);
379
380  // The compilation takes ownership of Args.
381  Compilation *C = new Compilation(*this, TC, Args, TranslatedArgs);
382
383  // FIXME: This behavior shouldn't be here.
384  if (CCCPrintOptions) {
385    PrintOptions(C->getInputArgs());
386    return C;
387  }
388
389  if (!HandleImmediateArgs(*C))
390    return C;
391
392  // Construct the list of inputs.
393  InputList Inputs;
394  BuildInputs(C->getDefaultToolChain(), *TranslatedArgs, Inputs);
395
396  // Construct the list of abstract actions to perform for this compilation. On
397  // Darwin target OSes this uses the driver-driver and universal actions.
398  if (TC.getTriple().isOSDarwin())
399    BuildUniversalActions(C->getDefaultToolChain(), C->getArgs(),
400                          Inputs, C->getActions());
401  else
402    BuildActions(C->getDefaultToolChain(), C->getArgs(), Inputs,
403                 C->getActions());
404
405  if (CCCPrintActions) {
406    PrintActions(*C);
407    return C;
408  }
409
410  BuildJobs(*C);
411
412  return C;
413}
414
415// When clang crashes, produce diagnostic information including the fully
416// preprocessed source file(s).  Request that the developer attach the
417// diagnostic information to a bug report.
418void Driver::generateCompilationDiagnostics(Compilation &C,
419                                            const Command *FailingCommand) {
420  if (C.getArgs().hasArg(options::OPT_fno_crash_diagnostics))
421    return;
422
423  // Don't try to generate diagnostics for link or dsymutil jobs.
424  if (FailingCommand && (FailingCommand->getCreator().isLinkJob() ||
425                         FailingCommand->getCreator().isDsymutilJob()))
426    return;
427
428  // Print the version of the compiler.
429  PrintVersion(C, llvm::errs());
430
431  Diag(clang::diag::note_drv_command_failed_diag_msg)
432    << "PLEASE submit a bug report to " BUG_REPORT_URL " and include the "
433    "crash backtrace, preprocessed source, and associated run script.";
434
435  // Suppress driver output and emit preprocessor output to temp file.
436  Mode = CPPMode;
437  CCGenDiagnostics = true;
438  C.getArgs().AddFlagArg(0, Opts->getOption(options::OPT_frewrite_includes));
439
440  // Save the original job command(s).
441  std::string Cmd;
442  llvm::raw_string_ostream OS(Cmd);
443  if (FailingCommand)
444    C.PrintDiagnosticJob(OS, *FailingCommand);
445  else
446    // Crash triggered by FORCE_CLANG_DIAGNOSTICS_CRASH, which doesn't have an
447    // associated FailingCommand, so just pass all jobs.
448    C.PrintDiagnosticJob(OS, C.getJobs());
449  OS.flush();
450
451  // Keep track of whether we produce any errors while trying to produce
452  // preprocessed sources.
453  DiagnosticErrorTrap Trap(Diags);
454
455  // Suppress tool output.
456  C.initCompilationForDiagnostics();
457
458  // Construct the list of inputs.
459  InputList Inputs;
460  BuildInputs(C.getDefaultToolChain(), C.getArgs(), Inputs);
461
462  for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) {
463    bool IgnoreInput = false;
464
465    // Ignore input from stdin or any inputs that cannot be preprocessed.
466    if (!strcmp(it->second->getValue(), "-")) {
467      Diag(clang::diag::note_drv_command_failed_diag_msg)
468        << "Error generating preprocessed source(s) - ignoring input from stdin"
469        ".";
470      IgnoreInput = true;
471    } else if (types::getPreprocessedType(it->first) == types::TY_INVALID) {
472      IgnoreInput = true;
473    }
474
475    if (IgnoreInput) {
476      it = Inputs.erase(it);
477      ie = Inputs.end();
478    } else {
479      ++it;
480    }
481  }
482
483  if (Inputs.empty()) {
484    Diag(clang::diag::note_drv_command_failed_diag_msg)
485      << "Error generating preprocessed source(s) - no preprocessable inputs.";
486    return;
487  }
488
489  // Don't attempt to generate preprocessed files if multiple -arch options are
490  // used, unless they're all duplicates.
491  llvm::StringSet<> ArchNames;
492  for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end();
493       it != ie; ++it) {
494    Arg *A = *it;
495    if (A->getOption().matches(options::OPT_arch)) {
496      StringRef ArchName = A->getValue();
497      ArchNames.insert(ArchName);
498    }
499  }
500  if (ArchNames.size() > 1) {
501    Diag(clang::diag::note_drv_command_failed_diag_msg)
502      << "Error generating preprocessed source(s) - cannot generate "
503      "preprocessed source with multiple -arch options.";
504    return;
505  }
506
507  // Construct the list of abstract actions to perform for this compilation. On
508  // Darwin OSes this uses the driver-driver and builds universal actions.
509  const ToolChain &TC = C.getDefaultToolChain();
510  if (TC.getTriple().isOSDarwin())
511    BuildUniversalActions(TC, C.getArgs(), Inputs, C.getActions());
512  else
513    BuildActions(TC, C.getArgs(), Inputs, C.getActions());
514
515  BuildJobs(C);
516
517  // If there were errors building the compilation, quit now.
518  if (Trap.hasErrorOccurred()) {
519    Diag(clang::diag::note_drv_command_failed_diag_msg)
520      << "Error generating preprocessed source(s).";
521    return;
522  }
523
524  // Generate preprocessed output.
525  SmallVector<std::pair<int, const Command *>, 4> FailingCommands;
526  C.ExecuteJob(C.getJobs(), FailingCommands);
527
528  // If the command succeeded, we are done.
529  if (FailingCommands.empty()) {
530    Diag(clang::diag::note_drv_command_failed_diag_msg)
531      << "\n********************\n\n"
532      "PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:\n"
533      "Preprocessed source(s) and associated run script(s) are located at:";
534    ArgStringList Files = C.getTempFiles();
535    for (ArgStringList::const_iterator it = Files.begin(), ie = Files.end();
536         it != ie; ++it) {
537      Diag(clang::diag::note_drv_command_failed_diag_msg) << *it;
538
539      std::string Err;
540      std::string Script = StringRef(*it).rsplit('.').first;
541      Script += ".sh";
542      llvm::raw_fd_ostream ScriptOS(
543          Script.c_str(), Err, llvm::sys::fs::F_Excl | llvm::sys::fs::F_Binary);
544      if (!Err.empty()) {
545        Diag(clang::diag::note_drv_command_failed_diag_msg)
546          << "Error generating run script: " + Script + " " + Err;
547      } else {
548        // Append the new filename with correct preprocessed suffix.
549        size_t I, E;
550        I = Cmd.find("-main-file-name ");
551        assert (I != std::string::npos && "Expected to find -main-file-name");
552        I += 16;
553        E = Cmd.find(" ", I);
554        assert (E != std::string::npos && "-main-file-name missing argument?");
555        StringRef OldFilename = StringRef(Cmd).slice(I, E);
556        StringRef NewFilename = llvm::sys::path::filename(*it);
557        I = StringRef(Cmd).rfind(OldFilename);
558        E = I + OldFilename.size();
559        I = Cmd.rfind(" ", I) + 1;
560        Cmd.replace(I, E - I, NewFilename.data(), NewFilename.size());
561        ScriptOS << Cmd;
562        Diag(clang::diag::note_drv_command_failed_diag_msg) << Script;
563      }
564    }
565    Diag(clang::diag::note_drv_command_failed_diag_msg)
566      << "\n\n********************";
567  } else {
568    // Failure, remove preprocessed files.
569    if (!C.getArgs().hasArg(options::OPT_save_temps))
570      C.CleanupFileList(C.getTempFiles(), true);
571
572    Diag(clang::diag::note_drv_command_failed_diag_msg)
573      << "Error generating preprocessed source(s).";
574  }
575}
576
577int Driver::ExecuteCompilation(const Compilation &C,
578    SmallVectorImpl< std::pair<int, const Command *> > &FailingCommands) const {
579  // Just print if -### was present.
580  if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
581    C.PrintJob(llvm::errs(), C.getJobs(), "\n", true);
582    return 0;
583  }
584
585  // If there were errors building the compilation, quit now.
586  if (Diags.hasErrorOccurred())
587    return 1;
588
589  C.ExecuteJob(C.getJobs(), FailingCommands);
590
591  // Remove temp files.
592  C.CleanupFileList(C.getTempFiles());
593
594  // If the command succeeded, we are done.
595  if (FailingCommands.empty())
596    return 0;
597
598  // Otherwise, remove result files and print extra information about abnormal
599  // failures.
600  for (SmallVectorImpl< std::pair<int, const Command *> >::iterator it =
601         FailingCommands.begin(), ie = FailingCommands.end(); it != ie; ++it) {
602    int Res = it->first;
603    const Command *FailingCommand = it->second;
604
605    // Remove result files if we're not saving temps.
606    if (!C.getArgs().hasArg(options::OPT_save_temps)) {
607      const JobAction *JA = cast<JobAction>(&FailingCommand->getSource());
608      C.CleanupFileMap(C.getResultFiles(), JA, true);
609
610      // Failure result files are valid unless we crashed.
611      if (Res < 0)
612        C.CleanupFileMap(C.getFailureResultFiles(), JA, true);
613    }
614
615    // Print extra information about abnormal failures, if possible.
616    //
617    // This is ad-hoc, but we don't want to be excessively noisy. If the result
618    // status was 1, assume the command failed normally. In particular, if it
619    // was the compiler then assume it gave a reasonable error code. Failures
620    // in other tools are less common, and they generally have worse
621    // diagnostics, so always print the diagnostic there.
622    const Tool &FailingTool = FailingCommand->getCreator();
623
624    if (!FailingCommand->getCreator().hasGoodDiagnostics() || Res != 1) {
625      // FIXME: See FIXME above regarding result code interpretation.
626      if (Res < 0)
627        Diag(clang::diag::err_drv_command_signalled)
628          << FailingTool.getShortName();
629      else
630        Diag(clang::diag::err_drv_command_failed)
631          << FailingTool.getShortName() << Res;
632    }
633  }
634  return 0;
635}
636
637void Driver::PrintOptions(const ArgList &Args) const {
638  unsigned i = 0;
639  for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
640       it != ie; ++it, ++i) {
641    Arg *A = *it;
642    llvm::errs() << "Option " << i << " - "
643                 << "Name: \"" << A->getOption().getPrefixedName() << "\", "
644                 << "Values: {";
645    for (unsigned j = 0; j < A->getNumValues(); ++j) {
646      if (j)
647        llvm::errs() << ", ";
648      llvm::errs() << '"' << A->getValue(j) << '"';
649    }
650    llvm::errs() << "}\n";
651  }
652}
653
654void Driver::PrintHelp(bool ShowHidden) const {
655  unsigned IncludedFlagsBitmask;
656  unsigned ExcludedFlagsBitmask;
657  llvm::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
658    getIncludeExcludeOptionFlagMasks();
659
660  ExcludedFlagsBitmask |= options::NoDriverOption;
661  if (!ShowHidden)
662    ExcludedFlagsBitmask |= HelpHidden;
663
664  getOpts().PrintHelp(llvm::outs(), Name.c_str(), DriverTitle.c_str(),
665                      IncludedFlagsBitmask, ExcludedFlagsBitmask);
666}
667
668void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const {
669  // FIXME: The following handlers should use a callback mechanism, we don't
670  // know what the client would like to do.
671  OS << getClangFullVersion() << '\n';
672  const ToolChain &TC = C.getDefaultToolChain();
673  OS << "Target: " << TC.getTripleString() << '\n';
674
675  // Print the threading model.
676  //
677  // FIXME: Implement correctly.
678  OS << "Thread model: " << "posix" << '\n';
679}
680
681/// PrintDiagnosticCategories - Implement the --print-diagnostic-categories
682/// option.
683static void PrintDiagnosticCategories(raw_ostream &OS) {
684  // Skip the empty category.
685  for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories();
686       i != max; ++i)
687    OS << i << ',' << DiagnosticIDs::getCategoryNameFromID(i) << '\n';
688}
689
690bool Driver::HandleImmediateArgs(const Compilation &C) {
691  // The order these options are handled in gcc is all over the place, but we
692  // don't expect inconsistencies w.r.t. that to matter in practice.
693
694  if (C.getArgs().hasArg(options::OPT_dumpmachine)) {
695    llvm::outs() << C.getDefaultToolChain().getTripleString() << '\n';
696    return false;
697  }
698
699  if (C.getArgs().hasArg(options::OPT_dumpversion)) {
700    // Since -dumpversion is only implemented for pedantic GCC compatibility, we
701    // return an answer which matches our definition of __VERSION__.
702    //
703    // If we want to return a more correct answer some day, then we should
704    // introduce a non-pedantically GCC compatible mode to Clang in which we
705    // provide sensible definitions for -dumpversion, __VERSION__, etc.
706    llvm::outs() << "4.2.1\n";
707    return false;
708  }
709
710  if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
711    PrintDiagnosticCategories(llvm::outs());
712    return false;
713  }
714
715  if (C.getArgs().hasArg(options::OPT_help) ||
716      C.getArgs().hasArg(options::OPT__help_hidden)) {
717    PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden));
718    return false;
719  }
720
721  if (C.getArgs().hasArg(options::OPT__version)) {
722    // Follow gcc behavior and use stdout for --version and stderr for -v.
723    PrintVersion(C, llvm::outs());
724    return false;
725  }
726
727  if (C.getArgs().hasArg(options::OPT_v) ||
728      C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
729    PrintVersion(C, llvm::errs());
730    SuppressMissingInputWarning = true;
731  }
732
733  const ToolChain &TC = C.getDefaultToolChain();
734
735  if (C.getArgs().hasArg(options::OPT_v))
736    TC.printVerboseInfo(llvm::errs());
737
738  if (C.getArgs().hasArg(options::OPT_print_search_dirs)) {
739    llvm::outs() << "programs: =";
740    for (ToolChain::path_list::const_iterator it = TC.getProgramPaths().begin(),
741           ie = TC.getProgramPaths().end(); it != ie; ++it) {
742      if (it != TC.getProgramPaths().begin())
743        llvm::outs() << ':';
744      llvm::outs() << *it;
745    }
746    llvm::outs() << "\n";
747    llvm::outs() << "libraries: =" << ResourceDir;
748
749    StringRef sysroot = C.getSysRoot();
750
751    for (ToolChain::path_list::const_iterator it = TC.getFilePaths().begin(),
752           ie = TC.getFilePaths().end(); it != ie; ++it) {
753      llvm::outs() << ':';
754      const char *path = it->c_str();
755      if (path[0] == '=')
756        llvm::outs() << sysroot << path + 1;
757      else
758        llvm::outs() << path;
759    }
760    llvm::outs() << "\n";
761    return false;
762  }
763
764  // FIXME: The following handlers should use a callback mechanism, we don't
765  // know what the client would like to do.
766  if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
767    llvm::outs() << GetFilePath(A->getValue(), TC) << "\n";
768    return false;
769  }
770
771  if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
772    llvm::outs() << GetProgramPath(A->getValue(), TC) << "\n";
773    return false;
774  }
775
776  if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
777    llvm::outs() << GetFilePath("libgcc.a", TC) << "\n";
778    return false;
779  }
780
781  if (C.getArgs().hasArg(options::OPT_print_multi_lib)) {
782    // FIXME: We need tool chain support for this.
783    llvm::outs() << ".;\n";
784
785    switch (C.getDefaultToolChain().getTriple().getArch()) {
786    default:
787      break;
788
789    case llvm::Triple::x86_64:
790      llvm::outs() << "x86_64;@m64" << "\n";
791      break;
792
793    case llvm::Triple::ppc64:
794      llvm::outs() << "ppc64;@m64" << "\n";
795      break;
796
797    case llvm::Triple::ppc64le:
798      llvm::outs() << "ppc64le;@m64" << "\n";
799      break;
800    }
801    return false;
802  }
803
804  // FIXME: What is the difference between print-multi-directory and
805  // print-multi-os-directory?
806  if (C.getArgs().hasArg(options::OPT_print_multi_directory) ||
807      C.getArgs().hasArg(options::OPT_print_multi_os_directory)) {
808    switch (C.getDefaultToolChain().getTriple().getArch()) {
809    default:
810    case llvm::Triple::x86:
811    case llvm::Triple::ppc:
812      llvm::outs() << "." << "\n";
813      break;
814
815    case llvm::Triple::x86_64:
816      llvm::outs() << "x86_64" << "\n";
817      break;
818
819    case llvm::Triple::ppc64:
820      llvm::outs() << "ppc64" << "\n";
821      break;
822
823    case llvm::Triple::ppc64le:
824      llvm::outs() << "ppc64le" << "\n";
825      break;
826    }
827    return false;
828  }
829
830  return true;
831}
832
833static unsigned PrintActions1(const Compilation &C, Action *A,
834                              std::map<Action*, unsigned> &Ids) {
835  if (Ids.count(A))
836    return Ids[A];
837
838  std::string str;
839  llvm::raw_string_ostream os(str);
840
841  os << Action::getClassName(A->getKind()) << ", ";
842  if (InputAction *IA = dyn_cast<InputAction>(A)) {
843    os << "\"" << IA->getInputArg().getValue() << "\"";
844  } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) {
845    os << '"' << BIA->getArchName() << '"'
846       << ", {" << PrintActions1(C, *BIA->begin(), Ids) << "}";
847  } else {
848    os << "{";
849    for (Action::iterator it = A->begin(), ie = A->end(); it != ie;) {
850      os << PrintActions1(C, *it, Ids);
851      ++it;
852      if (it != ie)
853        os << ", ";
854    }
855    os << "}";
856  }
857
858  unsigned Id = Ids.size();
859  Ids[A] = Id;
860  llvm::errs() << Id << ": " << os.str() << ", "
861               << types::getTypeName(A->getType()) << "\n";
862
863  return Id;
864}
865
866void Driver::PrintActions(const Compilation &C) const {
867  std::map<Action*, unsigned> Ids;
868  for (ActionList::const_iterator it = C.getActions().begin(),
869         ie = C.getActions().end(); it != ie; ++it)
870    PrintActions1(C, *it, Ids);
871}
872
873/// \brief Check whether the given input tree contains any compilation or
874/// assembly actions.
875static bool ContainsCompileOrAssembleAction(const Action *A) {
876  if (isa<CompileJobAction>(A) || isa<AssembleJobAction>(A))
877    return true;
878
879  for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
880    if (ContainsCompileOrAssembleAction(*it))
881      return true;
882
883  return false;
884}
885
886void Driver::BuildUniversalActions(const ToolChain &TC,
887                                   DerivedArgList &Args,
888                                   const InputList &BAInputs,
889                                   ActionList &Actions) const {
890  llvm::PrettyStackTraceString CrashInfo("Building universal build actions");
891  // Collect the list of architectures. Duplicates are allowed, but should only
892  // be handled once (in the order seen).
893  llvm::StringSet<> ArchNames;
894  SmallVector<const char *, 4> Archs;
895  for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
896       it != ie; ++it) {
897    Arg *A = *it;
898
899    if (A->getOption().matches(options::OPT_arch)) {
900      // Validate the option here; we don't save the type here because its
901      // particular spelling may participate in other driver choices.
902      llvm::Triple::ArchType Arch =
903        tools::darwin::getArchTypeForDarwinArchName(A->getValue());
904      if (Arch == llvm::Triple::UnknownArch) {
905        Diag(clang::diag::err_drv_invalid_arch_name)
906          << A->getAsString(Args);
907        continue;
908      }
909
910      A->claim();
911      if (ArchNames.insert(A->getValue()))
912        Archs.push_back(A->getValue());
913    }
914  }
915
916  // When there is no explicit arch for this platform, make sure we still bind
917  // the architecture (to the default) so that -Xarch_ is handled correctly.
918  if (!Archs.size())
919    Archs.push_back(Args.MakeArgString(TC.getDefaultUniversalArchName()));
920
921  ActionList SingleActions;
922  BuildActions(TC, Args, BAInputs, SingleActions);
923
924  // Add in arch bindings for every top level action, as well as lipo and
925  // dsymutil steps if needed.
926  for (unsigned i = 0, e = SingleActions.size(); i != e; ++i) {
927    Action *Act = SingleActions[i];
928
929    // Make sure we can lipo this kind of output. If not (and it is an actual
930    // output) then we disallow, since we can't create an output file with the
931    // right name without overwriting it. We could remove this oddity by just
932    // changing the output names to include the arch, which would also fix
933    // -save-temps. Compatibility wins for now.
934
935    if (Archs.size() > 1 && !types::canLipoType(Act->getType()))
936      Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
937        << types::getTypeName(Act->getType());
938
939    ActionList Inputs;
940    for (unsigned i = 0, e = Archs.size(); i != e; ++i) {
941      Inputs.push_back(new BindArchAction(Act, Archs[i]));
942      if (i != 0)
943        Inputs.back()->setOwnsInputs(false);
944    }
945
946    // Lipo if necessary, we do it this way because we need to set the arch flag
947    // so that -Xarch_ gets overwritten.
948    if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
949      Actions.append(Inputs.begin(), Inputs.end());
950    else
951      Actions.push_back(new LipoJobAction(Inputs, Act->getType()));
952
953    // Handle debug info queries.
954    Arg *A = Args.getLastArg(options::OPT_g_Group);
955    if (A && !A->getOption().matches(options::OPT_g0) &&
956        !A->getOption().matches(options::OPT_gstabs) &&
957        ContainsCompileOrAssembleAction(Actions.back())) {
958
959      // Add a 'dsymutil' step if necessary, when debug info is enabled and we
960      // have a compile input. We need to run 'dsymutil' ourselves in such cases
961      // because the debug info will refer to a temporary object file which
962      // will be removed at the end of the compilation process.
963      if (Act->getType() == types::TY_Image) {
964        ActionList Inputs;
965        Inputs.push_back(Actions.back());
966        Actions.pop_back();
967        Actions.push_back(new DsymutilJobAction(Inputs, types::TY_dSYM));
968      }
969
970      // Verify the output (debug information only) if we passed '-verify'.
971      if (Args.hasArg(options::OPT_verify)) {
972        ActionList VerifyInputs;
973        VerifyInputs.push_back(Actions.back());
974        Actions.pop_back();
975        Actions.push_back(new VerifyJobAction(VerifyInputs,
976                                              types::TY_Nothing));
977      }
978    }
979  }
980}
981
982/// \brief Check that the file referenced by Value exists. If it doesn't,
983/// issue a diagnostic and return false.
984static bool DiagnoseInputExistance(const Driver &D, const DerivedArgList &Args,
985                                   StringRef Value) {
986  if (!D.getCheckInputsExist())
987    return true;
988
989  // stdin always exists.
990  if (Value == "-")
991    return true;
992
993  SmallString<64> Path(Value);
994  if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory)) {
995    if (!llvm::sys::path::is_absolute(Path.str())) {
996      SmallString<64> Directory(WorkDir->getValue());
997      llvm::sys::path::append(Directory, Value);
998      Path.assign(Directory);
999    }
1000  }
1001
1002  if (llvm::sys::fs::exists(Twine(Path)))
1003    return true;
1004
1005  D.Diag(clang::diag::err_drv_no_such_file) << Path.str();
1006  return false;
1007}
1008
1009// Construct a the list of inputs and their types.
1010void Driver::BuildInputs(const ToolChain &TC, const DerivedArgList &Args,
1011                         InputList &Inputs) const {
1012  // Track the current user specified (-x) input. We also explicitly track the
1013  // argument used to set the type; we only want to claim the type when we
1014  // actually use it, so we warn about unused -x arguments.
1015  types::ID InputType = types::TY_Nothing;
1016  Arg *InputTypeArg = 0;
1017
1018  // The last /TC or /TP option sets the input type to C or C++ globally.
1019  if (Arg *TCTP = Args.getLastArg(options::OPT__SLASH_TC,
1020                                  options::OPT__SLASH_TP)) {
1021    InputTypeArg = TCTP;
1022    InputType = TCTP->getOption().matches(options::OPT__SLASH_TC)
1023        ? types::TY_C : types::TY_CXX;
1024
1025    arg_iterator it = Args.filtered_begin(options::OPT__SLASH_TC,
1026                                          options::OPT__SLASH_TP);
1027    const arg_iterator ie = Args.filtered_end();
1028    Arg *Previous = *it++;
1029    bool ShowNote = false;
1030    while (it != ie) {
1031      Diag(clang::diag::warn_drv_overriding_t_option) << Previous->getSpelling()
1032          << (*it)->getSpelling();
1033      Previous = *it++;
1034      ShowNote = true;
1035    }
1036    if (ShowNote)
1037      Diag(clang::diag::note_drv_t_option_is_global);
1038
1039    // No driver mode exposes -x and /TC or /TP; we don't support mixing them.
1040    assert(!Args.hasArg(options::OPT_x) && "-x and /TC or /TP is not allowed");
1041  }
1042
1043  for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
1044       it != ie; ++it) {
1045    Arg *A = *it;
1046
1047    if (A->getOption().getKind() == Option::InputClass) {
1048      const char *Value = A->getValue();
1049      types::ID Ty = types::TY_INVALID;
1050
1051      // Infer the input type if necessary.
1052      if (InputType == types::TY_Nothing) {
1053        // If there was an explicit arg for this, claim it.
1054        if (InputTypeArg)
1055          InputTypeArg->claim();
1056
1057        // stdin must be handled specially.
1058        if (memcmp(Value, "-", 2) == 0) {
1059          // If running with -E, treat as a C input (this changes the builtin
1060          // macros, for example). This may be overridden by -ObjC below.
1061          //
1062          // Otherwise emit an error but still use a valid type to avoid
1063          // spurious errors (e.g., no inputs).
1064          if (!Args.hasArgNoClaim(options::OPT_E) && !CCCIsCPP())
1065            Diag(clang::diag::err_drv_unknown_stdin_type);
1066          Ty = types::TY_C;
1067        } else {
1068          // Otherwise lookup by extension.
1069          // Fallback is C if invoked as C preprocessor or Object otherwise.
1070          // We use a host hook here because Darwin at least has its own
1071          // idea of what .s is.
1072          if (const char *Ext = strrchr(Value, '.'))
1073            Ty = TC.LookupTypeForExtension(Ext + 1);
1074
1075          if (Ty == types::TY_INVALID) {
1076            if (CCCIsCPP())
1077              Ty = types::TY_C;
1078            else
1079              Ty = types::TY_Object;
1080          }
1081
1082          // If the driver is invoked as C++ compiler (like clang++ or c++) it
1083          // should autodetect some input files as C++ for g++ compatibility.
1084          if (CCCIsCXX()) {
1085            types::ID OldTy = Ty;
1086            Ty = types::lookupCXXTypeForCType(Ty);
1087
1088            if (Ty != OldTy)
1089              Diag(clang::diag::warn_drv_treating_input_as_cxx)
1090                << getTypeName(OldTy) << getTypeName(Ty);
1091          }
1092        }
1093
1094        // -ObjC and -ObjC++ override the default language, but only for "source
1095        // files". We just treat everything that isn't a linker input as a
1096        // source file.
1097        //
1098        // FIXME: Clean this up if we move the phase sequence into the type.
1099        if (Ty != types::TY_Object) {
1100          if (Args.hasArg(options::OPT_ObjC))
1101            Ty = types::TY_ObjC;
1102          else if (Args.hasArg(options::OPT_ObjCXX))
1103            Ty = types::TY_ObjCXX;
1104        }
1105      } else {
1106        assert(InputTypeArg && "InputType set w/o InputTypeArg");
1107        InputTypeArg->claim();
1108        Ty = InputType;
1109      }
1110
1111      if (DiagnoseInputExistance(*this, Args, Value))
1112        Inputs.push_back(std::make_pair(Ty, A));
1113
1114    } else if (A->getOption().matches(options::OPT__SLASH_Tc)) {
1115      StringRef Value = A->getValue();
1116      if (DiagnoseInputExistance(*this, Args, Value)) {
1117        Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
1118        Inputs.push_back(std::make_pair(types::TY_C, InputArg));
1119      }
1120      A->claim();
1121    } else if (A->getOption().matches(options::OPT__SLASH_Tp)) {
1122      StringRef Value = A->getValue();
1123      if (DiagnoseInputExistance(*this, Args, Value)) {
1124        Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
1125        Inputs.push_back(std::make_pair(types::TY_CXX, InputArg));
1126      }
1127      A->claim();
1128    } else if (A->getOption().hasFlag(options::LinkerInput)) {
1129      // Just treat as object type, we could make a special type for this if
1130      // necessary.
1131      Inputs.push_back(std::make_pair(types::TY_Object, A));
1132
1133    } else if (A->getOption().matches(options::OPT_x)) {
1134      InputTypeArg = A;
1135      InputType = types::lookupTypeForTypeSpecifier(A->getValue());
1136      A->claim();
1137
1138      // Follow gcc behavior and treat as linker input for invalid -x
1139      // options. Its not clear why we shouldn't just revert to unknown; but
1140      // this isn't very important, we might as well be bug compatible.
1141      if (!InputType) {
1142        Diag(clang::diag::err_drv_unknown_language) << A->getValue();
1143        InputType = types::TY_Object;
1144      }
1145    }
1146  }
1147  if (CCCIsCPP() && Inputs.empty()) {
1148    // If called as standalone preprocessor, stdin is processed
1149    // if no other input is present.
1150    Arg *A = MakeInputArg(Args, Opts, "-");
1151    Inputs.push_back(std::make_pair(types::TY_C, A));
1152  }
1153}
1154
1155void Driver::BuildActions(const ToolChain &TC, DerivedArgList &Args,
1156                          const InputList &Inputs, ActionList &Actions) const {
1157  llvm::PrettyStackTraceString CrashInfo("Building compilation actions");
1158
1159  if (!SuppressMissingInputWarning && Inputs.empty()) {
1160    Diag(clang::diag::err_drv_no_input_files);
1161    return;
1162  }
1163
1164  Arg *FinalPhaseArg;
1165  phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg);
1166
1167  // Reject -Z* at the top level, these options should never have been exposed
1168  // by gcc.
1169  if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
1170    Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
1171
1172  // Diagnose misuse of /Fo.
1173  if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fo)) {
1174    DiagnoseOptionOverride(*this, Args, options::OPT__SLASH_Fo);
1175    StringRef V = A->getValue();
1176    if (V.empty()) {
1177      // It has to have a value.
1178      Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1;
1179      Args.eraseArg(options::OPT__SLASH_Fo);
1180    } else if (Inputs.size() > 1 && !llvm::sys::path::is_separator(V.back())) {
1181      // Check whether /Fo tries to name an output file for multiple inputs.
1182      Diag(clang::diag::err_drv_obj_file_argument_with_multiple_sources)
1183        << A->getSpelling() << V;
1184      Args.eraseArg(options::OPT__SLASH_Fo);
1185    }
1186  }
1187
1188  // Diagnose misuse of /Fe.
1189  if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fe)) {
1190    DiagnoseOptionOverride(*this, Args, options::OPT__SLASH_Fe);
1191    if (A->getValue()[0] == '\0') {
1192      // It has to have a value.
1193      Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1;
1194      Args.eraseArg(options::OPT__SLASH_Fe);
1195    }
1196  }
1197
1198  // Construct the actions to perform.
1199  ActionList LinkerInputs;
1200  ActionList SplitInputs;
1201  llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PL;
1202  for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
1203    types::ID InputType = Inputs[i].first;
1204    const Arg *InputArg = Inputs[i].second;
1205
1206    PL.clear();
1207    types::getCompilationPhases(InputType, PL);
1208
1209    // If the first step comes after the final phase we are doing as part of
1210    // this compilation, warn the user about it.
1211    phases::ID InitialPhase = PL[0];
1212    if (InitialPhase > FinalPhase) {
1213      // Claim here to avoid the more general unused warning.
1214      InputArg->claim();
1215
1216      // Suppress all unused style warnings with -Qunused-arguments
1217      if (Args.hasArg(options::OPT_Qunused_arguments))
1218        continue;
1219
1220      // Special case when final phase determined by binary name, rather than
1221      // by a command-line argument with a corresponding Arg.
1222      if (CCCIsCPP())
1223        Diag(clang::diag::warn_drv_input_file_unused_by_cpp)
1224          << InputArg->getAsString(Args)
1225          << getPhaseName(InitialPhase);
1226      // Special case '-E' warning on a previously preprocessed file to make
1227      // more sense.
1228      else if (InitialPhase == phases::Compile &&
1229               FinalPhase == phases::Preprocess &&
1230               getPreprocessedType(InputType) == types::TY_INVALID)
1231        Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
1232          << InputArg->getAsString(Args)
1233          << !!FinalPhaseArg
1234          << FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "";
1235      else
1236        Diag(clang::diag::warn_drv_input_file_unused)
1237          << InputArg->getAsString(Args)
1238          << getPhaseName(InitialPhase)
1239          << !!FinalPhaseArg
1240          << FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "";
1241      continue;
1242    }
1243
1244    // Build the pipeline for this file.
1245    OwningPtr<Action> Current(new InputAction(*InputArg, InputType));
1246    for (SmallVectorImpl<phases::ID>::iterator
1247           i = PL.begin(), e = PL.end(); i != e; ++i) {
1248      phases::ID Phase = *i;
1249
1250      // We are done if this step is past what the user requested.
1251      if (Phase > FinalPhase)
1252        break;
1253
1254      // Queue linker inputs.
1255      if (Phase == phases::Link) {
1256        assert((i + 1) == e && "linking must be final compilation step.");
1257        LinkerInputs.push_back(Current.take());
1258        break;
1259      }
1260
1261      // Some types skip the assembler phase (e.g., llvm-bc), but we can't
1262      // encode this in the steps because the intermediate type depends on
1263      // arguments. Just special case here.
1264      if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm)
1265        continue;
1266
1267      // Otherwise construct the appropriate action.
1268      Current.reset(ConstructPhaseAction(Args, Phase, Current.take()));
1269      if (Current->getType() == types::TY_Nothing)
1270        break;
1271    }
1272
1273    // If we ended with something, add to the output list.
1274    if (Current)
1275      Actions.push_back(Current.take());
1276  }
1277
1278  // Add a link action if necessary.
1279  if (!LinkerInputs.empty())
1280    Actions.push_back(new LinkJobAction(LinkerInputs, types::TY_Image));
1281
1282  // If we are linking, claim any options which are obviously only used for
1283  // compilation.
1284  if (FinalPhase == phases::Link && PL.size() == 1)
1285    Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
1286}
1287
1288Action *Driver::ConstructPhaseAction(const ArgList &Args, phases::ID Phase,
1289                                     Action *Input) const {
1290  llvm::PrettyStackTraceString CrashInfo("Constructing phase actions");
1291  // Build the appropriate action.
1292  switch (Phase) {
1293  case phases::Link: llvm_unreachable("link action invalid here.");
1294  case phases::Preprocess: {
1295    types::ID OutputTy;
1296    // -{M, MM} alter the output type.
1297    if (Args.hasArg(options::OPT_M, options::OPT_MM)) {
1298      OutputTy = types::TY_Dependencies;
1299    } else {
1300      OutputTy = Input->getType();
1301      if (!Args.hasFlag(options::OPT_frewrite_includes,
1302                        options::OPT_fno_rewrite_includes, false))
1303        OutputTy = types::getPreprocessedType(OutputTy);
1304      assert(OutputTy != types::TY_INVALID &&
1305             "Cannot preprocess this input type!");
1306    }
1307    return new PreprocessJobAction(Input, OutputTy);
1308  }
1309  case phases::Precompile: {
1310    types::ID OutputTy = types::TY_PCH;
1311    if (Args.hasArg(options::OPT_fsyntax_only)) {
1312      // Syntax checks should not emit a PCH file
1313      OutputTy = types::TY_Nothing;
1314    }
1315    return new PrecompileJobAction(Input, OutputTy);
1316  }
1317  case phases::Compile: {
1318    if (Args.hasArg(options::OPT_fsyntax_only)) {
1319      return new CompileJobAction(Input, types::TY_Nothing);
1320    } else if (Args.hasArg(options::OPT_rewrite_objc)) {
1321      return new CompileJobAction(Input, types::TY_RewrittenObjC);
1322    } else if (Args.hasArg(options::OPT_rewrite_legacy_objc)) {
1323      return new CompileJobAction(Input, types::TY_RewrittenLegacyObjC);
1324    } else if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto)) {
1325      return new AnalyzeJobAction(Input, types::TY_Plist);
1326    } else if (Args.hasArg(options::OPT__migrate)) {
1327      return new MigrateJobAction(Input, types::TY_Remap);
1328    } else if (Args.hasArg(options::OPT_emit_ast)) {
1329      return new CompileJobAction(Input, types::TY_AST);
1330    } else if (Args.hasArg(options::OPT_module_file_info)) {
1331      return new CompileJobAction(Input, types::TY_ModuleFile);
1332    } else if (IsUsingLTO(Args)) {
1333      types::ID Output =
1334        Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
1335      return new CompileJobAction(Input, Output);
1336    } else {
1337      return new CompileJobAction(Input, types::TY_PP_Asm);
1338    }
1339  }
1340  case phases::Assemble:
1341    return new AssembleJobAction(Input, types::TY_Object);
1342  }
1343
1344  llvm_unreachable("invalid phase in ConstructPhaseAction");
1345}
1346
1347bool Driver::IsUsingLTO(const ArgList &Args) const {
1348  // Check for -emit-llvm or -flto.
1349  if (Args.hasArg(options::OPT_emit_llvm) ||
1350      Args.hasFlag(options::OPT_flto, options::OPT_fno_lto, false))
1351    return true;
1352
1353  // Check for -O4.
1354  if (const Arg *A = Args.getLastArg(options::OPT_O_Group))
1355      return A->getOption().matches(options::OPT_O4);
1356
1357  return false;
1358}
1359
1360void Driver::BuildJobs(Compilation &C) const {
1361  llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
1362
1363  Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
1364
1365  // It is an error to provide a -o option if we are making multiple output
1366  // files.
1367  if (FinalOutput) {
1368    unsigned NumOutputs = 0;
1369    for (ActionList::const_iterator it = C.getActions().begin(),
1370           ie = C.getActions().end(); it != ie; ++it)
1371      if ((*it)->getType() != types::TY_Nothing)
1372        ++NumOutputs;
1373
1374    if (NumOutputs > 1) {
1375      Diag(clang::diag::err_drv_output_argument_with_multiple_files);
1376      FinalOutput = 0;
1377    }
1378  }
1379
1380  // Collect the list of architectures.
1381  llvm::StringSet<> ArchNames;
1382  if (C.getDefaultToolChain().getTriple().isOSDarwin()) {
1383    for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end();
1384         it != ie; ++it) {
1385      Arg *A = *it;
1386      if (A->getOption().matches(options::OPT_arch))
1387        ArchNames.insert(A->getValue());
1388    }
1389  }
1390
1391  for (ActionList::const_iterator it = C.getActions().begin(),
1392         ie = C.getActions().end(); it != ie; ++it) {
1393    Action *A = *it;
1394
1395    // If we are linking an image for multiple archs then the linker wants
1396    // -arch_multiple and -final_output <final image name>. Unfortunately, this
1397    // doesn't fit in cleanly because we have to pass this information down.
1398    //
1399    // FIXME: This is a hack; find a cleaner way to integrate this into the
1400    // process.
1401    const char *LinkingOutput = 0;
1402    if (isa<LipoJobAction>(A)) {
1403      if (FinalOutput)
1404        LinkingOutput = FinalOutput->getValue();
1405      else
1406        LinkingOutput = DefaultImageName.c_str();
1407    }
1408
1409    InputInfo II;
1410    BuildJobsForAction(C, A, &C.getDefaultToolChain(),
1411                       /*BoundArch*/0,
1412                       /*AtTopLevel*/ true,
1413                       /*MultipleArchs*/ ArchNames.size() > 1,
1414                       /*LinkingOutput*/ LinkingOutput,
1415                       II);
1416  }
1417
1418  // If the user passed -Qunused-arguments or there were errors, don't warn
1419  // about any unused arguments.
1420  if (Diags.hasErrorOccurred() ||
1421      C.getArgs().hasArg(options::OPT_Qunused_arguments))
1422    return;
1423
1424  // Claim -### here.
1425  (void) C.getArgs().hasArg(options::OPT__HASH_HASH_HASH);
1426
1427  // Claim --driver-mode, it was handled earlier.
1428  (void) C.getArgs().hasArg(options::OPT_driver_mode);
1429
1430  for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end();
1431       it != ie; ++it) {
1432    Arg *A = *it;
1433
1434    // FIXME: It would be nice to be able to send the argument to the
1435    // DiagnosticsEngine, so that extra values, position, and so on could be
1436    // printed.
1437    if (!A->isClaimed()) {
1438      if (A->getOption().hasFlag(options::NoArgumentUnused))
1439        continue;
1440
1441      // Suppress the warning automatically if this is just a flag, and it is an
1442      // instance of an argument we already claimed.
1443      const Option &Opt = A->getOption();
1444      if (Opt.getKind() == Option::FlagClass) {
1445        bool DuplicateClaimed = false;
1446
1447        for (arg_iterator it = C.getArgs().filtered_begin(&Opt),
1448               ie = C.getArgs().filtered_end(); it != ie; ++it) {
1449          if ((*it)->isClaimed()) {
1450            DuplicateClaimed = true;
1451            break;
1452          }
1453        }
1454
1455        if (DuplicateClaimed)
1456          continue;
1457      }
1458
1459      Diag(clang::diag::warn_drv_unused_argument)
1460        << A->getAsString(C.getArgs());
1461    }
1462  }
1463}
1464
1465static const Tool *SelectToolForJob(Compilation &C, const ToolChain *TC,
1466                                    const JobAction *JA,
1467                                    const ActionList *&Inputs) {
1468  const Tool *ToolForJob = 0;
1469
1470  // See if we should look for a compiler with an integrated assembler. We match
1471  // bottom up, so what we are actually looking for is an assembler job with a
1472  // compiler input.
1473
1474  if (TC->useIntegratedAs() &&
1475      !C.getArgs().hasArg(options::OPT_save_temps) &&
1476      isa<AssembleJobAction>(JA) &&
1477      Inputs->size() == 1 && isa<CompileJobAction>(*Inputs->begin())) {
1478    const Tool *Compiler =
1479      TC->SelectTool(cast<JobAction>(**Inputs->begin()));
1480    if (!Compiler)
1481      return NULL;
1482    if (Compiler->hasIntegratedAssembler()) {
1483      Inputs = &(*Inputs)[0]->getInputs();
1484      ToolForJob = Compiler;
1485    }
1486  }
1487
1488  // Otherwise use the tool for the current job.
1489  if (!ToolForJob)
1490    ToolForJob = TC->SelectTool(*JA);
1491
1492  // See if we should use an integrated preprocessor. We do so when we have
1493  // exactly one input, since this is the only use case we care about
1494  // (irrelevant since we don't support combine yet).
1495  if (Inputs->size() == 1 && isa<PreprocessJobAction>(*Inputs->begin()) &&
1496      !C.getArgs().hasArg(options::OPT_no_integrated_cpp) &&
1497      !C.getArgs().hasArg(options::OPT_traditional_cpp) &&
1498      !C.getArgs().hasArg(options::OPT_save_temps) &&
1499      !C.getArgs().hasArg(options::OPT_rewrite_objc) &&
1500      ToolForJob->hasIntegratedCPP())
1501    Inputs = &(*Inputs)[0]->getInputs();
1502
1503  return ToolForJob;
1504}
1505
1506void Driver::BuildJobsForAction(Compilation &C,
1507                                const Action *A,
1508                                const ToolChain *TC,
1509                                const char *BoundArch,
1510                                bool AtTopLevel,
1511                                bool MultipleArchs,
1512                                const char *LinkingOutput,
1513                                InputInfo &Result) const {
1514  llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
1515
1516  if (const InputAction *IA = dyn_cast<InputAction>(A)) {
1517    // FIXME: It would be nice to not claim this here; maybe the old scheme of
1518    // just using Args was better?
1519    const Arg &Input = IA->getInputArg();
1520    Input.claim();
1521    if (Input.getOption().matches(options::OPT_INPUT)) {
1522      const char *Name = Input.getValue();
1523      Result = InputInfo(Name, A->getType(), Name);
1524    } else
1525      Result = InputInfo(&Input, A->getType(), "");
1526    return;
1527  }
1528
1529  if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) {
1530    const ToolChain *TC;
1531    const char *ArchName = BAA->getArchName();
1532
1533    if (ArchName)
1534      TC = &getToolChain(C.getArgs(), ArchName);
1535    else
1536      TC = &C.getDefaultToolChain();
1537
1538    BuildJobsForAction(C, *BAA->begin(), TC, BAA->getArchName(),
1539                       AtTopLevel, MultipleArchs, LinkingOutput, Result);
1540    return;
1541  }
1542
1543  const ActionList *Inputs = &A->getInputs();
1544
1545  const JobAction *JA = cast<JobAction>(A);
1546  const Tool *T = SelectToolForJob(C, TC, JA, Inputs);
1547  if (!T)
1548    return;
1549
1550  // Only use pipes when there is exactly one input.
1551  InputInfoList InputInfos;
1552  for (ActionList::const_iterator it = Inputs->begin(), ie = Inputs->end();
1553       it != ie; ++it) {
1554    // Treat dsymutil and verify sub-jobs as being at the top-level too, they
1555    // shouldn't get temporary output names.
1556    // FIXME: Clean this up.
1557    bool SubJobAtTopLevel = false;
1558    if (AtTopLevel && (isa<DsymutilJobAction>(A) || isa<VerifyJobAction>(A)))
1559      SubJobAtTopLevel = true;
1560
1561    InputInfo II;
1562    BuildJobsForAction(C, *it, TC, BoundArch, SubJobAtTopLevel, MultipleArchs,
1563                       LinkingOutput, II);
1564    InputInfos.push_back(II);
1565  }
1566
1567  // Always use the first input as the base input.
1568  const char *BaseInput = InputInfos[0].getBaseInput();
1569
1570  // ... except dsymutil actions, which use their actual input as the base
1571  // input.
1572  if (JA->getType() == types::TY_dSYM)
1573    BaseInput = InputInfos[0].getFilename();
1574
1575  // Determine the place to write output to, if any.
1576  if (JA->getType() == types::TY_Nothing)
1577    Result = InputInfo(A->getType(), BaseInput);
1578  else
1579    Result = InputInfo(GetNamedOutputPath(C, *JA, BaseInput, BoundArch,
1580                                          AtTopLevel, MultipleArchs),
1581                       A->getType(), BaseInput);
1582
1583  if (CCCPrintBindings && !CCGenDiagnostics) {
1584    llvm::errs() << "# \"" << T->getToolChain().getTripleString() << '"'
1585                 << " - \"" << T->getName() << "\", inputs: [";
1586    for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
1587      llvm::errs() << InputInfos[i].getAsString();
1588      if (i + 1 != e)
1589        llvm::errs() << ", ";
1590    }
1591    llvm::errs() << "], output: " << Result.getAsString() << "\n";
1592  } else {
1593    T->ConstructJob(C, *JA, Result, InputInfos,
1594                    C.getArgsForToolChain(TC, BoundArch), LinkingOutput);
1595  }
1596}
1597
1598/// \brief Create output filename based on ArgValue, which could either be a
1599/// full filename, filename without extension, or a directory.
1600static const char *MakeCLOutputFilename(const ArgList &Args, StringRef ArgValue,
1601                                        StringRef BaseName, types::ID FileType) {
1602  SmallString<128> Filename = ArgValue;
1603  assert(!ArgValue.empty() && "Output filename argument must not be empty.");
1604
1605  if (llvm::sys::path::is_separator(Filename.back())) {
1606    // If the argument is a directory, output to BaseName in that dir.
1607    llvm::sys::path::append(Filename, BaseName);
1608  }
1609
1610  if (!llvm::sys::path::has_extension(ArgValue)) {
1611    // If the argument didn't provide an extension, then set it.
1612    const char *Extension = types::getTypeTempSuffix(FileType, true);
1613    llvm::sys::path::replace_extension(Filename, Extension);
1614  }
1615
1616  return Args.MakeArgString(Filename.c_str());
1617}
1618
1619const char *Driver::GetNamedOutputPath(Compilation &C,
1620                                       const JobAction &JA,
1621                                       const char *BaseInput,
1622                                       const char *BoundArch,
1623                                       bool AtTopLevel,
1624                                       bool MultipleArchs) const {
1625  llvm::PrettyStackTraceString CrashInfo("Computing output path");
1626  // Output to a user requested destination?
1627  if (AtTopLevel && !isa<DsymutilJobAction>(JA) &&
1628      !isa<VerifyJobAction>(JA)) {
1629    if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
1630      return C.addResultFile(FinalOutput->getValue(), &JA);
1631  }
1632
1633  // Default to writing to stdout?
1634  if (AtTopLevel && !CCGenDiagnostics &&
1635      (isa<PreprocessJobAction>(JA) || JA.getType() == types::TY_ModuleFile))
1636    return "-";
1637
1638  // Output to a temporary file?
1639  if ((!AtTopLevel && !C.getArgs().hasArg(options::OPT_save_temps) &&
1640        !C.getArgs().hasArg(options::OPT__SLASH_Fo)) ||
1641      CCGenDiagnostics) {
1642    StringRef Name = llvm::sys::path::filename(BaseInput);
1643    std::pair<StringRef, StringRef> Split = Name.split('.');
1644    std::string TmpName =
1645      GetTemporaryPath(Split.first,
1646          types::getTypeTempSuffix(JA.getType(), IsCLMode()));
1647    return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
1648  }
1649
1650  SmallString<128> BasePath(BaseInput);
1651  StringRef BaseName;
1652
1653  // Dsymutil actions should use the full path.
1654  if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA))
1655    BaseName = BasePath;
1656  else
1657    BaseName = llvm::sys::path::filename(BasePath);
1658
1659  // Determine what the derived output name should be.
1660  const char *NamedOutput;
1661
1662  if (JA.getType() == types::TY_Object &&
1663      C.getArgs().hasArg(options::OPT__SLASH_Fo)) {
1664    // The /Fo flag decides the object filename.
1665    StringRef Val = C.getArgs().getLastArg(options::OPT__SLASH_Fo)->getValue();
1666    NamedOutput = MakeCLOutputFilename(C.getArgs(), Val, BaseName,
1667                                       types::TY_Object);
1668  } else if (JA.getType() == types::TY_Image &&
1669             C.getArgs().hasArg(options::OPT__SLASH_Fe)) {
1670    // The /Fe flag names the linked file.
1671    StringRef Val = C.getArgs().getLastArg(options::OPT__SLASH_Fe)->getValue();
1672    NamedOutput = MakeCLOutputFilename(C.getArgs(), Val, BaseName,
1673                                       types::TY_Image);
1674  } else if (JA.getType() == types::TY_Image) {
1675    if (IsCLMode()) {
1676      // clang-cl uses BaseName for the executable name.
1677      SmallString<128> Filename = BaseName;
1678      llvm::sys::path::replace_extension(Filename, "exe");
1679      NamedOutput = C.getArgs().MakeArgString(Filename.c_str());
1680    } else if (MultipleArchs && BoundArch) {
1681      SmallString<128> Output(DefaultImageName.c_str());
1682      Output += "-";
1683      Output.append(BoundArch);
1684      NamedOutput = C.getArgs().MakeArgString(Output.c_str());
1685    } else
1686      NamedOutput = DefaultImageName.c_str();
1687  } else {
1688    const char *Suffix = types::getTypeTempSuffix(JA.getType());
1689    assert(Suffix && "All types used for output should have a suffix.");
1690
1691    std::string::size_type End = std::string::npos;
1692    if (!types::appendSuffixForType(JA.getType()))
1693      End = BaseName.rfind('.');
1694    SmallString<128> Suffixed(BaseName.substr(0, End));
1695    if (MultipleArchs && BoundArch) {
1696      Suffixed += "-";
1697      Suffixed.append(BoundArch);
1698    }
1699    Suffixed += '.';
1700    Suffixed += Suffix;
1701    NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str());
1702  }
1703
1704  // If we're saving temps and the temp file conflicts with the input file,
1705  // then avoid overwriting input file.
1706  if (!AtTopLevel && C.getArgs().hasArg(options::OPT_save_temps) &&
1707      NamedOutput == BaseName) {
1708
1709    bool SameFile = false;
1710    SmallString<256> Result;
1711    llvm::sys::fs::current_path(Result);
1712    llvm::sys::path::append(Result, BaseName);
1713    llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile);
1714    // Must share the same path to conflict.
1715    if (SameFile) {
1716      StringRef Name = llvm::sys::path::filename(BaseInput);
1717      std::pair<StringRef, StringRef> Split = Name.split('.');
1718      std::string TmpName =
1719        GetTemporaryPath(Split.first,
1720            types::getTypeTempSuffix(JA.getType(), IsCLMode()));
1721      return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
1722    }
1723  }
1724
1725  // As an annoying special case, PCH generation doesn't strip the pathname.
1726  if (JA.getType() == types::TY_PCH) {
1727    llvm::sys::path::remove_filename(BasePath);
1728    if (BasePath.empty())
1729      BasePath = NamedOutput;
1730    else
1731      llvm::sys::path::append(BasePath, NamedOutput);
1732    return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str()), &JA);
1733  } else {
1734    return C.addResultFile(NamedOutput, &JA);
1735  }
1736}
1737
1738std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const {
1739  // Respect a limited subset of the '-Bprefix' functionality in GCC by
1740  // attempting to use this prefix when looking for file paths.
1741  for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(),
1742       ie = PrefixDirs.end(); it != ie; ++it) {
1743    std::string Dir(*it);
1744    if (Dir.empty())
1745      continue;
1746    if (Dir[0] == '=')
1747      Dir = SysRoot + Dir.substr(1);
1748    SmallString<128> P(Dir);
1749    llvm::sys::path::append(P, Name);
1750    if (llvm::sys::fs::exists(Twine(P)))
1751      return P.str();
1752  }
1753
1754  SmallString<128> P(ResourceDir);
1755  llvm::sys::path::append(P, Name);
1756  if (llvm::sys::fs::exists(Twine(P)))
1757    return P.str();
1758
1759  const ToolChain::path_list &List = TC.getFilePaths();
1760  for (ToolChain::path_list::const_iterator
1761         it = List.begin(), ie = List.end(); it != ie; ++it) {
1762    std::string Dir(*it);
1763    if (Dir.empty())
1764      continue;
1765    if (Dir[0] == '=')
1766      Dir = SysRoot + Dir.substr(1);
1767    SmallString<128> P(Dir);
1768    llvm::sys::path::append(P, Name);
1769    if (llvm::sys::fs::exists(Twine(P)))
1770      return P.str();
1771  }
1772
1773  return Name;
1774}
1775
1776std::string Driver::GetProgramPath(const char *Name,
1777                                   const ToolChain &TC) const {
1778  // FIXME: Needs a better variable than DefaultTargetTriple
1779  std::string TargetSpecificExecutable(DefaultTargetTriple + "-" + Name);
1780  // Respect a limited subset of the '-Bprefix' functionality in GCC by
1781  // attempting to use this prefix when looking for program paths.
1782  for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(),
1783       ie = PrefixDirs.end(); it != ie; ++it) {
1784    if (llvm::sys::fs::is_directory(*it)) {
1785      SmallString<128> P(*it);
1786      llvm::sys::path::append(P, TargetSpecificExecutable);
1787      if (llvm::sys::fs::can_execute(Twine(P)))
1788        return P.str();
1789      llvm::sys::path::remove_filename(P);
1790      llvm::sys::path::append(P, Name);
1791      if (llvm::sys::fs::can_execute(Twine(P)))
1792        return P.str();
1793    } else {
1794      SmallString<128> P(*it + Name);
1795      if (llvm::sys::fs::can_execute(Twine(P)))
1796        return P.str();
1797    }
1798  }
1799
1800  const ToolChain::path_list &List = TC.getProgramPaths();
1801  for (ToolChain::path_list::const_iterator
1802         it = List.begin(), ie = List.end(); it != ie; ++it) {
1803    SmallString<128> P(*it);
1804    llvm::sys::path::append(P, TargetSpecificExecutable);
1805    if (llvm::sys::fs::can_execute(Twine(P)))
1806      return P.str();
1807    llvm::sys::path::remove_filename(P);
1808    llvm::sys::path::append(P, Name);
1809    if (llvm::sys::fs::can_execute(Twine(P)))
1810      return P.str();
1811  }
1812
1813  // If all else failed, search the path.
1814  std::string P(llvm::sys::FindProgramByName(TargetSpecificExecutable));
1815  if (!P.empty())
1816    return P;
1817
1818  P = llvm::sys::FindProgramByName(Name);
1819  if (!P.empty())
1820    return P;
1821
1822  return Name;
1823}
1824
1825std::string Driver::GetTemporaryPath(StringRef Prefix, const char *Suffix)
1826  const {
1827  SmallString<128> Path;
1828  llvm::error_code EC =
1829      llvm::sys::fs::createTemporaryFile(Prefix, Suffix, Path);
1830  if (EC) {
1831    Diag(clang::diag::err_unable_to_make_temp) << EC.message();
1832    return "";
1833  }
1834
1835  return Path.str();
1836}
1837
1838/// \brief Compute target triple from args.
1839///
1840/// This routine provides the logic to compute a target triple from various
1841/// args passed to the driver and the default triple string.
1842static llvm::Triple computeTargetTriple(StringRef DefaultTargetTriple,
1843                                        const ArgList &Args,
1844                                        StringRef DarwinArchName) {
1845  // FIXME: Already done in Compilation *Driver::BuildCompilation
1846  if (const Arg *A = Args.getLastArg(options::OPT_target))
1847    DefaultTargetTriple = A->getValue();
1848
1849  llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple));
1850
1851  // Handle Darwin-specific options available here.
1852  if (Target.isOSDarwin()) {
1853    // If an explict Darwin arch name is given, that trumps all.
1854    if (!DarwinArchName.empty()) {
1855      Target.setArch(
1856        tools::darwin::getArchTypeForDarwinArchName(DarwinArchName));
1857      return Target;
1858    }
1859
1860    // Handle the Darwin '-arch' flag.
1861    if (Arg *A = Args.getLastArg(options::OPT_arch)) {
1862      llvm::Triple::ArchType DarwinArch
1863        = tools::darwin::getArchTypeForDarwinArchName(A->getValue());
1864      if (DarwinArch != llvm::Triple::UnknownArch)
1865        Target.setArch(DarwinArch);
1866    }
1867  }
1868
1869  // Handle pseudo-target flags '-EL' and '-EB'.
1870  if (Arg *A = Args.getLastArg(options::OPT_EL, options::OPT_EB)) {
1871    if (A->getOption().matches(options::OPT_EL)) {
1872      if (Target.getArch() == llvm::Triple::mips)
1873        Target.setArch(llvm::Triple::mipsel);
1874      else if (Target.getArch() == llvm::Triple::mips64)
1875        Target.setArch(llvm::Triple::mips64el);
1876    } else {
1877      if (Target.getArch() == llvm::Triple::mipsel)
1878        Target.setArch(llvm::Triple::mips);
1879      else if (Target.getArch() == llvm::Triple::mips64el)
1880        Target.setArch(llvm::Triple::mips64);
1881    }
1882  }
1883
1884  // Skip further flag support on OSes which don't support '-m32' or '-m64'.
1885  if (Target.getArchName() == "tce" ||
1886      Target.getOS() == llvm::Triple::AuroraUX ||
1887      Target.getOS() == llvm::Triple::Minix)
1888    return Target;
1889
1890  // Handle pseudo-target flags '-m32' and '-m64'.
1891  // FIXME: Should this information be in llvm::Triple?
1892  if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
1893    if (A->getOption().matches(options::OPT_m32)) {
1894      if (Target.getArch() == llvm::Triple::x86_64)
1895        Target.setArch(llvm::Triple::x86);
1896      if (Target.getArch() == llvm::Triple::ppc64)
1897        Target.setArch(llvm::Triple::ppc);
1898    } else {
1899      if (Target.getArch() == llvm::Triple::x86)
1900        Target.setArch(llvm::Triple::x86_64);
1901      if (Target.getArch() == llvm::Triple::ppc)
1902        Target.setArch(llvm::Triple::ppc64);
1903    }
1904  }
1905
1906  return Target;
1907}
1908
1909const ToolChain &Driver::getToolChain(const ArgList &Args,
1910                                      StringRef DarwinArchName) const {
1911  llvm::Triple Target = computeTargetTriple(DefaultTargetTriple, Args,
1912                                            DarwinArchName);
1913
1914  ToolChain *&TC = ToolChains[Target.str()];
1915  if (!TC) {
1916    switch (Target.getOS()) {
1917    case llvm::Triple::AuroraUX:
1918      TC = new toolchains::AuroraUX(*this, Target, Args);
1919      break;
1920    case llvm::Triple::Darwin:
1921    case llvm::Triple::MacOSX:
1922    case llvm::Triple::IOS:
1923      if (Target.getArch() == llvm::Triple::x86 ||
1924          Target.getArch() == llvm::Triple::x86_64 ||
1925          Target.getArch() == llvm::Triple::arm ||
1926          Target.getArch() == llvm::Triple::thumb)
1927        TC = new toolchains::DarwinClang(*this, Target, Args);
1928      else
1929        TC = new toolchains::Darwin_Generic_GCC(*this, Target, Args);
1930      break;
1931    case llvm::Triple::DragonFly:
1932      TC = new toolchains::DragonFly(*this, Target, Args);
1933      break;
1934    case llvm::Triple::OpenBSD:
1935      TC = new toolchains::OpenBSD(*this, Target, Args);
1936      break;
1937    case llvm::Triple::Bitrig:
1938      TC = new toolchains::Bitrig(*this, Target, Args);
1939      break;
1940    case llvm::Triple::NetBSD:
1941      TC = new toolchains::NetBSD(*this, Target, Args);
1942      break;
1943    case llvm::Triple::FreeBSD:
1944      TC = new toolchains::FreeBSD(*this, Target, Args);
1945      break;
1946    case llvm::Triple::Minix:
1947      TC = new toolchains::Minix(*this, Target, Args);
1948      break;
1949    case llvm::Triple::Linux:
1950      if (Target.getArch() == llvm::Triple::hexagon)
1951        TC = new toolchains::Hexagon_TC(*this, Target, Args);
1952      else
1953        TC = new toolchains::Linux(*this, Target, Args);
1954      break;
1955    case llvm::Triple::Solaris:
1956      TC = new toolchains::Solaris(*this, Target, Args);
1957      break;
1958    case llvm::Triple::Win32:
1959      TC = new toolchains::Windows(*this, Target, Args);
1960      break;
1961    case llvm::Triple::MinGW32:
1962      // FIXME: We need a MinGW toolchain. Fallthrough for now.
1963    default:
1964      // TCE is an OSless target
1965      if (Target.getArchName() == "tce") {
1966        TC = new toolchains::TCEToolChain(*this, Target, Args);
1967        break;
1968      }
1969      // If Hexagon is configured as an OSless target
1970      if (Target.getArch() == llvm::Triple::hexagon) {
1971        TC = new toolchains::Hexagon_TC(*this, Target, Args);
1972        break;
1973      }
1974      TC = new toolchains::Generic_GCC(*this, Target, Args);
1975      break;
1976    }
1977  }
1978  return *TC;
1979}
1980
1981bool Driver::ShouldUseClangCompiler(const JobAction &JA) const {
1982  // Check if user requested no clang, or clang doesn't understand this type (we
1983  // only handle single inputs for now).
1984  if (JA.size() != 1 ||
1985      !types::isAcceptedByClang((*JA.begin())->getType()))
1986    return false;
1987
1988  // Otherwise make sure this is an action clang understands.
1989  if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) &&
1990      !isa<CompileJobAction>(JA))
1991    return false;
1992
1993  return true;
1994}
1995
1996/// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the
1997/// grouped values as integers. Numbers which are not provided are set to 0.
1998///
1999/// \return True if the entire string was parsed (9.2), or all groups were
2000/// parsed (10.3.5extrastuff).
2001bool Driver::GetReleaseVersion(const char *Str, unsigned &Major,
2002                               unsigned &Minor, unsigned &Micro,
2003                               bool &HadExtra) {
2004  HadExtra = false;
2005
2006  Major = Minor = Micro = 0;
2007  if (*Str == '\0')
2008    return true;
2009
2010  char *End;
2011  Major = (unsigned) strtol(Str, &End, 10);
2012  if (*Str != '\0' && *End == '\0')
2013    return true;
2014  if (*End != '.')
2015    return false;
2016
2017  Str = End+1;
2018  Minor = (unsigned) strtol(Str, &End, 10);
2019  if (*Str != '\0' && *End == '\0')
2020    return true;
2021  if (*End != '.')
2022    return false;
2023
2024  Str = End+1;
2025  Micro = (unsigned) strtol(Str, &End, 10);
2026  if (*Str != '\0' && *End == '\0')
2027    return true;
2028  if (Str == End)
2029    return false;
2030  HadExtra = true;
2031  return true;
2032}
2033
2034std::pair<unsigned, unsigned> Driver::getIncludeExcludeOptionFlagMasks() const {
2035  unsigned IncludedFlagsBitmask = 0;
2036  unsigned ExcludedFlagsBitmask = 0;
2037
2038  if (Mode == CLMode) {
2039    // Include CL and Core options.
2040    IncludedFlagsBitmask |= options::CLOption;
2041    IncludedFlagsBitmask |= options::CoreOption;
2042  } else {
2043    ExcludedFlagsBitmask |= options::CLOption;
2044  }
2045
2046  return std::make_pair(IncludedFlagsBitmask, ExcludedFlagsBitmask);
2047}
2048