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