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