Driver.cpp revision d18c714ffe42a2cbc54b5db563baa9b035ffea96 
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#ifdef HAVE_CLANG_CONFIG_H
11# include "clang/Config/config.h"
12#endif
13
14#include "clang/Driver/Driver.h"
15
16#include "clang/Driver/Action.h"
17#include "clang/Driver/Arg.h"
18#include "clang/Driver/ArgList.h"
19#include "clang/Driver/Compilation.h"
20#include "clang/Driver/DriverDiagnostic.h"
21#include "clang/Driver/HostInfo.h"
22#include "clang/Driver/Job.h"
23#include "clang/Driver/OptTable.h"
24#include "clang/Driver/Option.h"
25#include "clang/Driver/Options.h"
26#include "clang/Driver/Tool.h"
27#include "clang/Driver/ToolChain.h"
28
29#include "clang/Basic/Version.h"
30
31#include "llvm/Config/config.h"
32#include "llvm/ADT/ArrayRef.h"
33#include "llvm/ADT/StringSet.h"
34#include "llvm/ADT/OwningPtr.h"
35#include "llvm/Support/ErrorHandling.h"
36#include "llvm/Support/PrettyStackTrace.h"
37#include "llvm/Support/raw_ostream.h"
38#include "llvm/Support/FileSystem.h"
39#include "llvm/Support/Path.h"
40#include "llvm/Support/Program.h"
41
42#include "InputInfo.h"
43
44#include <map>
45
46using namespace clang::driver;
47using namespace clang;
48
49Driver::Driver(StringRef ClangExecutable,
50               StringRef DefaultHostTriple,
51               StringRef DefaultImageName,
52               bool IsProduction,
53               DiagnosticsEngine &Diags)
54  : Opts(createDriverOptTable()), Diags(Diags),
55    ClangExecutable(ClangExecutable), UseStdLib(true),
56    DefaultHostTriple(DefaultHostTriple), DefaultImageName(DefaultImageName),
57    DriverTitle("clang \"gcc-compatible\" driver"),
58    Host(0),
59    CCPrintOptionsFilename(0), CCPrintHeadersFilename(0),
60    CCLogDiagnosticsFilename(0), CCCIsCXX(false),
61    CCCIsCPP(false),CCCEcho(false), CCCPrintBindings(false),
62    CCPrintOptions(false), CCPrintHeaders(false), CCLogDiagnostics(false),
63    CCGenDiagnostics(false), CCCGenericGCCName(""), CheckInputsExist(true),
64    CCCUseClang(true), CCCUseClangCXX(true), CCCUseClangCPP(true),
65    CCCUsePCH(true), SuppressMissingInputWarning(false) {
66  if (IsProduction) {
67    // In a "production" build, only use clang on architectures we expect to
68    // work, and don't use clang C++.
69    //
70    // During development its more convenient to always have the driver use
71    // clang, but we don't want users to be confused when things don't work, or
72    // to file bugs for things we don't support.
73    CCCClangArchs.insert(llvm::Triple::x86);
74    CCCClangArchs.insert(llvm::Triple::x86_64);
75    CCCClangArchs.insert(llvm::Triple::arm);
76  }
77
78  Name = llvm::sys::path::stem(ClangExecutable);
79  Dir  = llvm::sys::path::parent_path(ClangExecutable);
80
81  // Compute the path to the resource directory.
82  StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
83  llvm::SmallString<128> P(Dir);
84  if (ClangResourceDir != "")
85    llvm::sys::path::append(P, ClangResourceDir);
86  else
87    llvm::sys::path::append(P, "..", "lib", "clang", CLANG_VERSION_STRING);
88  ResourceDir = P.str();
89}
90
91Driver::~Driver() {
92  delete Opts;
93  delete Host;
94}
95
96InputArgList *Driver::ParseArgStrings(ArrayRef<const char *> ArgList) {
97  llvm::PrettyStackTraceString CrashInfo("Command line argument parsing");
98  unsigned MissingArgIndex, MissingArgCount;
99  InputArgList *Args = getOpts().ParseArgs(ArgList.begin(), ArgList.end(),
100                                           MissingArgIndex, MissingArgCount);
101
102  // Check for missing argument error.
103  if (MissingArgCount)
104    Diag(clang::diag::err_drv_missing_argument)
105      << Args->getArgString(MissingArgIndex) << MissingArgCount;
106
107  // Check for unsupported options.
108  for (ArgList::const_iterator it = Args->begin(), ie = Args->end();
109       it != ie; ++it) {
110    Arg *A = *it;
111    if (A->getOption().isUnsupported()) {
112      Diag(clang::diag::err_drv_unsupported_opt) << A->getAsString(*Args);
113      continue;
114    }
115  }
116
117  return Args;
118}
119
120// Determine which compilation mode we are in. We look for options which
121// affect the phase, starting with the earliest phases, and record which
122// option we used to determine the final phase.
123phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, Arg **FinalPhaseArg)
124const {
125  Arg *PhaseArg = 0;
126  phases::ID FinalPhase;
127
128  // -{E,M,MM} only run the preprocessor.
129  if (CCCIsCPP ||
130      (PhaseArg = DAL.getLastArg(options::OPT_E)) ||
131      (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM))) {
132    FinalPhase = phases::Preprocess;
133
134    // -{fsyntax-only,-analyze,emit-ast,S} only run up to the compiler.
135  } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) ||
136             (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) ||
137             (PhaseArg = DAL.getLastArg(options::OPT__analyze,
138                                              options::OPT__analyze_auto)) ||
139             (PhaseArg = DAL.getLastArg(options::OPT_emit_ast)) ||
140             (PhaseArg = DAL.getLastArg(options::OPT_S))) {
141    FinalPhase = phases::Compile;
142
143    // -c only runs up to the assembler.
144  } else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) {
145    FinalPhase = phases::Assemble;
146
147    // Otherwise do everything.
148  } else
149    FinalPhase = phases::Link;
150
151  if (FinalPhaseArg)
152    *FinalPhaseArg = PhaseArg;
153
154  return FinalPhase;
155}
156
157DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const {
158  DerivedArgList *DAL = new DerivedArgList(Args);
159
160  bool HasNostdlib = Args.hasArg(options::OPT_nostdlib);
161  for (ArgList::const_iterator it = Args.begin(),
162         ie = Args.end(); it != ie; ++it) {
163    const Arg *A = *it;
164
165    // Unfortunately, we have to parse some forwarding options (-Xassembler,
166    // -Xlinker, -Xpreprocessor) because we either integrate their functionality
167    // (assembler and preprocessor), or bypass a previous driver ('collect2').
168
169    // Rewrite linker options, to replace --no-demangle with a custom internal
170    // option.
171    if ((A->getOption().matches(options::OPT_Wl_COMMA) ||
172         A->getOption().matches(options::OPT_Xlinker)) &&
173        A->containsValue("--no-demangle")) {
174      // Add the rewritten no-demangle argument.
175      DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle));
176
177      // Add the remaining values as Xlinker arguments.
178      for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
179        if (StringRef(A->getValue(Args, i)) != "--no-demangle")
180          DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker),
181                              A->getValue(Args, i));
182
183      continue;
184    }
185
186    // Rewrite preprocessor options, to replace -Wp,-MD,FOO which is used by
187    // some build systems. We don't try to be complete here because we don't
188    // care to encourage this usage model.
189    if (A->getOption().matches(options::OPT_Wp_COMMA) &&
190        A->getNumValues() == 2 &&
191        (A->getValue(Args, 0) == StringRef("-MD") ||
192         A->getValue(Args, 0) == StringRef("-MMD"))) {
193      // Rewrite to -MD/-MMD along with -MF.
194      if (A->getValue(Args, 0) == StringRef("-MD"))
195        DAL->AddFlagArg(A, Opts->getOption(options::OPT_MD));
196      else
197        DAL->AddFlagArg(A, Opts->getOption(options::OPT_MMD));
198      DAL->AddSeparateArg(A, Opts->getOption(options::OPT_MF),
199                          A->getValue(Args, 1));
200      continue;
201    }
202
203    // Rewrite reserved library names.
204    if (A->getOption().matches(options::OPT_l)) {
205      StringRef Value = A->getValue(Args);
206
207      // Rewrite unless -nostdlib is present.
208      if (!HasNostdlib && Value == "stdc++") {
209        DAL->AddFlagArg(A, Opts->getOption(
210                              options::OPT_Z_reserved_lib_stdcxx));
211        continue;
212      }
213
214      // Rewrite unconditionally.
215      if (Value == "cc_kext") {
216        DAL->AddFlagArg(A, Opts->getOption(
217                              options::OPT_Z_reserved_lib_cckext));
218        continue;
219      }
220    }
221
222    DAL->append(*it);
223  }
224
225  // Add a default value of -mlinker-version=, if one was given and the user
226  // didn't specify one.
227#if defined(HOST_LINK_VERSION)
228  if (!Args.hasArg(options::OPT_mlinker_version_EQ)) {
229    DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ),
230                      HOST_LINK_VERSION);
231    DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim();
232  }
233#endif
234
235  return DAL;
236}
237
238Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
239  llvm::PrettyStackTraceString CrashInfo("Compilation construction");
240
241  // FIXME: Handle environment options which affect driver behavior, somewhere
242  // (client?). GCC_EXEC_PREFIX, LIBRARY_PATH, LPATH, CC_PRINT_OPTIONS.
243
244  if (char *env = ::getenv("COMPILER_PATH")) {
245    StringRef CompilerPath = env;
246    while (!CompilerPath.empty()) {
247      std::pair<StringRef, StringRef> Split = CompilerPath.split(':');
248      PrefixDirs.push_back(Split.first);
249      CompilerPath = Split.second;
250    }
251  }
252
253  // FIXME: What are we going to do with -V and -b?
254
255  // FIXME: This stuff needs to go into the Compilation, not the driver.
256  bool CCCPrintOptions = false, CCCPrintActions = false;
257
258  InputArgList *Args = ParseArgStrings(ArgList.slice(1));
259
260  // -no-canonical-prefixes is used very early in main.
261  Args->ClaimAllArgs(options::OPT_no_canonical_prefixes);
262
263  // Ignore -pipe.
264  Args->ClaimAllArgs(options::OPT_pipe);
265
266  // Extract -ccc args.
267  //
268  // FIXME: We need to figure out where this behavior should live. Most of it
269  // should be outside in the client; the parts that aren't should have proper
270  // options, either by introducing new ones or by overloading gcc ones like -V
271  // or -b.
272  CCCPrintOptions = Args->hasArg(options::OPT_ccc_print_options);
273  CCCPrintActions = Args->hasArg(options::OPT_ccc_print_phases);
274  CCCPrintBindings = Args->hasArg(options::OPT_ccc_print_bindings);
275  CCCIsCXX = Args->hasArg(options::OPT_ccc_cxx) || CCCIsCXX;
276  CCCEcho = Args->hasArg(options::OPT_ccc_echo);
277  if (const Arg *A = Args->getLastArg(options::OPT_ccc_gcc_name))
278    CCCGenericGCCName = A->getValue(*Args);
279  CCCUseClangCXX = Args->hasFlag(options::OPT_ccc_clang_cxx,
280                                 options::OPT_ccc_no_clang_cxx,
281                                 CCCUseClangCXX);
282  CCCUsePCH = Args->hasFlag(options::OPT_ccc_pch_is_pch,
283                            options::OPT_ccc_pch_is_pth);
284  CCCUseClang = !Args->hasArg(options::OPT_ccc_no_clang);
285  CCCUseClangCPP = !Args->hasArg(options::OPT_ccc_no_clang_cpp);
286  if (const Arg *A = Args->getLastArg(options::OPT_ccc_clang_archs)) {
287    StringRef Cur = A->getValue(*Args);
288
289    CCCClangArchs.clear();
290    while (!Cur.empty()) {
291      std::pair<StringRef, StringRef> Split = Cur.split(',');
292
293      if (!Split.first.empty()) {
294        llvm::Triple::ArchType Arch =
295          llvm::Triple(Split.first, "", "").getArch();
296
297        if (Arch == llvm::Triple::UnknownArch)
298          Diag(clang::diag::err_drv_invalid_arch_name) << Split.first;
299
300        CCCClangArchs.insert(Arch);
301      }
302
303      Cur = Split.second;
304    }
305  }
306  // FIXME: We shouldn't overwrite the default host triple here, but we have
307  // nowhere else to put this currently.
308  if (const Arg *A = Args->getLastArg(options::OPT_ccc_host_triple))
309    DefaultHostTriple = A->getValue(*Args);
310  if (const Arg *A = Args->getLastArg(options::OPT_ccc_install_dir))
311    Dir = InstalledDir = A->getValue(*Args);
312  for (arg_iterator it = Args->filtered_begin(options::OPT_B),
313         ie = Args->filtered_end(); it != ie; ++it) {
314    const Arg *A = *it;
315    A->claim();
316    PrefixDirs.push_back(A->getValue(*Args, 0));
317  }
318  if (const Arg *A = Args->getLastArg(options::OPT__sysroot_EQ))
319    SysRoot = A->getValue(*Args);
320  if (Args->hasArg(options::OPT_nostdlib))
321    UseStdLib = false;
322
323  Host = GetHostInfo(DefaultHostTriple.c_str());
324
325  // Perform the default argument translations.
326  DerivedArgList *TranslatedArgs = TranslateInputArgs(*Args);
327
328  // The compilation takes ownership of Args.
329  Compilation *C = new Compilation(*this, *Host->CreateToolChain(*Args), Args,
330                                   TranslatedArgs);
331
332  // FIXME: This behavior shouldn't be here.
333  if (CCCPrintOptions) {
334    PrintOptions(C->getInputArgs());
335    return C;
336  }
337
338  if (!HandleImmediateArgs(*C))
339    return C;
340
341  // Construct the list of inputs.
342  InputList Inputs;
343  BuildInputs(C->getDefaultToolChain(), C->getArgs(), Inputs);
344
345  // Construct the list of abstract actions to perform for this compilation.
346  if (Host->useDriverDriver())
347    BuildUniversalActions(C->getDefaultToolChain(), C->getArgs(),
348                          Inputs, C->getActions());
349  else
350    BuildActions(C->getDefaultToolChain(), C->getArgs(), Inputs,
351                 C->getActions());
352
353  if (CCCPrintActions) {
354    PrintActions(*C);
355    return C;
356  }
357
358  BuildJobs(*C);
359
360  return C;
361}
362
363// When clang crashes, produce diagnostic information including the fully
364// preprocessed source file(s).  Request that the developer attach the
365// diagnostic information to a bug report.
366void Driver::generateCompilationDiagnostics(Compilation &C,
367                                            const Command *FailingCommand) {
368  Diag(clang::diag::note_drv_command_failed_diag_msg)
369    << "Please submit a bug report to " BUG_REPORT_URL " and include command"
370    " line arguments and all diagnostic information.";
371
372  // Suppress driver output and emit preprocessor output to temp file.
373  CCCIsCPP = true;
374  CCGenDiagnostics = true;
375
376  // Save the original job command(s).
377  std::string Cmd;
378  llvm::raw_string_ostream OS(Cmd);
379  C.PrintJob(OS, C.getJobs(), "\n", false);
380  OS.flush();
381
382  // Clear stale state and suppress tool output.
383  C.initCompilationForDiagnostics();
384  Diags.Reset();
385
386  // Construct the list of inputs.
387  InputList Inputs;
388  BuildInputs(C.getDefaultToolChain(), C.getArgs(), Inputs);
389
390  for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) {
391    bool IgnoreInput = false;
392
393    // Ignore input from stdin or any inputs that cannot be preprocessed.
394    if (!strcmp(it->second->getValue(C.getArgs()), "-")) {
395      Diag(clang::diag::note_drv_command_failed_diag_msg)
396        << "Error generating preprocessed source(s) - ignoring input from stdin"
397        ".";
398      IgnoreInput = true;
399    } else if (types::getPreprocessedType(it->first) == types::TY_INVALID) {
400      IgnoreInput = true;
401    }
402
403    if (IgnoreInput) {
404      it = Inputs.erase(it);
405      ie = Inputs.end();
406    } else {
407      ++it;
408    }
409  }
410
411  // Don't attempt to generate preprocessed files if multiple -arch options are
412  // used.
413  int Archs = 0;
414  for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end();
415       it != ie; ++it) {
416    Arg *A = *it;
417    if (A->getOption().matches(options::OPT_arch)) {
418      Archs++;
419      if (Archs > 1) {
420        Diag(clang::diag::note_drv_command_failed_diag_msg)
421          << "Error generating preprocessed source(s) - cannot generate "
422          "preprocessed source with multiple -arch options.";
423        return;
424      }
425    }
426  }
427
428  if (Inputs.empty()) {
429    Diag(clang::diag::note_drv_command_failed_diag_msg)
430      << "Error generating preprocessed source(s) - no preprocessable inputs.";
431    return;
432  }
433
434  // Construct the list of abstract actions to perform for this compilation.
435  if (Host->useDriverDriver())
436    BuildUniversalActions(C.getDefaultToolChain(), C.getArgs(),
437                          Inputs, C.getActions());
438  else
439    BuildActions(C.getDefaultToolChain(), C.getArgs(), Inputs,
440                 C.getActions());
441
442  BuildJobs(C);
443
444  // If there were errors building the compilation, quit now.
445  if (Diags.hasErrorOccurred()) {
446    Diag(clang::diag::note_drv_command_failed_diag_msg)
447      << "Error generating preprocessed source(s).";
448    return;
449  }
450
451  // Generate preprocessed output.
452  FailingCommand = 0;
453  int Res = C.ExecuteJob(C.getJobs(), FailingCommand);
454
455  // If the command succeeded, we are done.
456  if (Res == 0) {
457    Diag(clang::diag::note_drv_command_failed_diag_msg)
458      << "Preprocessed source(s) and associated run script(s) are located at:";
459    ArgStringList Files = C.getTempFiles();
460    for (ArgStringList::const_iterator it = Files.begin(), ie = Files.end();
461         it != ie; ++it) {
462      Diag(clang::diag::note_drv_command_failed_diag_msg) << *it;
463
464      std::string Err;
465      std::string Script = StringRef(*it).rsplit('.').first;
466      Script += ".sh";
467      llvm::raw_fd_ostream ScriptOS(Script.c_str(), Err,
468                                    llvm::raw_fd_ostream::F_Excl |
469                                    llvm::raw_fd_ostream::F_Binary);
470      if (!Err.empty()) {
471        Diag(clang::diag::note_drv_command_failed_diag_msg)
472          << "Error generating run script: " + Script + " " + Err;
473      } else {
474        ScriptOS << Cmd;
475        Diag(clang::diag::note_drv_command_failed_diag_msg) << Script;
476      }
477    }
478  } else {
479    // Failure, remove preprocessed files.
480    if (!C.getArgs().hasArg(options::OPT_save_temps))
481      C.CleanupFileList(C.getTempFiles(), true);
482
483    Diag(clang::diag::note_drv_command_failed_diag_msg)
484      << "Error generating preprocessed source(s).";
485  }
486}
487
488int Driver::ExecuteCompilation(const Compilation &C,
489                               const Command *&FailingCommand) const {
490  // Just print if -### was present.
491  if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
492    C.PrintJob(llvm::errs(), C.getJobs(), "\n", true);
493    return 0;
494  }
495
496  // If there were errors building the compilation, quit now.
497  if (Diags.hasErrorOccurred())
498    return 1;
499
500  int Res = C.ExecuteJob(C.getJobs(), FailingCommand);
501
502  // Remove temp files.
503  C.CleanupFileList(C.getTempFiles());
504
505  // If the command succeeded, we are done.
506  if (Res == 0)
507    return Res;
508
509  // Otherwise, remove result files as well.
510  if (!C.getArgs().hasArg(options::OPT_save_temps))
511    C.CleanupFileList(C.getResultFiles(), true);
512
513  // Print extra information about abnormal failures, if possible.
514  //
515  // This is ad-hoc, but we don't want to be excessively noisy. If the result
516  // status was 1, assume the command failed normally. In particular, if it was
517  // the compiler then assume it gave a reasonable error code. Failures in other
518  // tools are less common, and they generally have worse diagnostics, so always
519  // print the diagnostic there.
520  const Tool &FailingTool = FailingCommand->getCreator();
521
522  if (!FailingCommand->getCreator().hasGoodDiagnostics() || Res != 1) {
523    // FIXME: See FIXME above regarding result code interpretation.
524    if (Res < 0)
525      Diag(clang::diag::err_drv_command_signalled)
526        << FailingTool.getShortName() << -Res;
527    else
528      Diag(clang::diag::err_drv_command_failed)
529        << FailingTool.getShortName() << Res;
530  }
531
532  return Res;
533}
534
535void Driver::PrintOptions(const ArgList &Args) const {
536  unsigned i = 0;
537  for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
538       it != ie; ++it, ++i) {
539    Arg *A = *it;
540    llvm::errs() << "Option " << i << " - "
541                 << "Name: \"" << A->getOption().getName() << "\", "
542                 << "Values: {";
543    for (unsigned j = 0; j < A->getNumValues(); ++j) {
544      if (j)
545        llvm::errs() << ", ";
546      llvm::errs() << '"' << A->getValue(Args, j) << '"';
547    }
548    llvm::errs() << "}\n";
549  }
550}
551
552void Driver::PrintHelp(bool ShowHidden) const {
553  getOpts().PrintHelp(llvm::outs(), Name.c_str(), DriverTitle.c_str(),
554                      ShowHidden);
555}
556
557void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const {
558  // FIXME: The following handlers should use a callback mechanism, we don't
559  // know what the client would like to do.
560  OS << getClangFullVersion() << '\n';
561  const ToolChain &TC = C.getDefaultToolChain();
562  OS << "Target: " << TC.getTripleString() << '\n';
563
564  // Print the threading model.
565  //
566  // FIXME: Implement correctly.
567  OS << "Thread model: " << "posix" << '\n';
568}
569
570/// PrintDiagnosticCategories - Implement the --print-diagnostic-categories
571/// option.
572static void PrintDiagnosticCategories(raw_ostream &OS) {
573  // Skip the empty category.
574  for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories();
575       i != max; ++i)
576    OS << i << ',' << DiagnosticIDs::getCategoryNameFromID(i) << '\n';
577}
578
579bool Driver::HandleImmediateArgs(const Compilation &C) {
580  // The order these options are handled in gcc is all over the place, but we
581  // don't expect inconsistencies w.r.t. that to matter in practice.
582
583  if (C.getArgs().hasArg(options::OPT_dumpmachine)) {
584    llvm::outs() << C.getDefaultToolChain().getTripleString() << '\n';
585    return false;
586  }
587
588  if (C.getArgs().hasArg(options::OPT_dumpversion)) {
589    // Since -dumpversion is only implemented for pedantic GCC compatibility, we
590    // return an answer which matches our definition of __VERSION__.
591    //
592    // If we want to return a more correct answer some day, then we should
593    // introduce a non-pedantically GCC compatible mode to Clang in which we
594    // provide sensible definitions for -dumpversion, __VERSION__, etc.
595    llvm::outs() << "4.2.1\n";
596    return false;
597  }
598
599  if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
600    PrintDiagnosticCategories(llvm::outs());
601    return false;
602  }
603
604  if (C.getArgs().hasArg(options::OPT__help) ||
605      C.getArgs().hasArg(options::OPT__help_hidden)) {
606    PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden));
607    return false;
608  }
609
610  if (C.getArgs().hasArg(options::OPT__version)) {
611    // Follow gcc behavior and use stdout for --version and stderr for -v.
612    PrintVersion(C, llvm::outs());
613    return false;
614  }
615
616  if (C.getArgs().hasArg(options::OPT_v) ||
617      C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
618    PrintVersion(C, llvm::errs());
619    SuppressMissingInputWarning = true;
620  }
621
622  const ToolChain &TC = C.getDefaultToolChain();
623  if (C.getArgs().hasArg(options::OPT_print_search_dirs)) {
624    llvm::outs() << "programs: =";
625    for (ToolChain::path_list::const_iterator it = TC.getProgramPaths().begin(),
626           ie = TC.getProgramPaths().end(); it != ie; ++it) {
627      if (it != TC.getProgramPaths().begin())
628        llvm::outs() << ':';
629      llvm::outs() << *it;
630    }
631    llvm::outs() << "\n";
632    llvm::outs() << "libraries: =" << ResourceDir;
633
634    std::string sysroot;
635    if (Arg *A = C.getArgs().getLastArg(options::OPT__sysroot_EQ))
636      sysroot = A->getValue(C.getArgs());
637
638    for (ToolChain::path_list::const_iterator it = TC.getFilePaths().begin(),
639           ie = TC.getFilePaths().end(); it != ie; ++it) {
640      llvm::outs() << ':';
641      const char *path = it->c_str();
642      if (path[0] == '=')
643        llvm::outs() << sysroot << path + 1;
644      else
645        llvm::outs() << path;
646    }
647    llvm::outs() << "\n";
648    return false;
649  }
650
651  // FIXME: The following handlers should use a callback mechanism, we don't
652  // know what the client would like to do.
653  if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
654    llvm::outs() << GetFilePath(A->getValue(C.getArgs()), TC) << "\n";
655    return false;
656  }
657
658  if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
659    llvm::outs() << GetProgramPath(A->getValue(C.getArgs()), TC) << "\n";
660    return false;
661  }
662
663  if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
664    llvm::outs() << GetFilePath("libgcc.a", TC) << "\n";
665    return false;
666  }
667
668  if (C.getArgs().hasArg(options::OPT_print_multi_lib)) {
669    // FIXME: We need tool chain support for this.
670    llvm::outs() << ".;\n";
671
672    switch (C.getDefaultToolChain().getTriple().getArch()) {
673    default:
674      break;
675
676    case llvm::Triple::x86_64:
677      llvm::outs() << "x86_64;@m64" << "\n";
678      break;
679
680    case llvm::Triple::ppc64:
681      llvm::outs() << "ppc64;@m64" << "\n";
682      break;
683    }
684    return false;
685  }
686
687  // FIXME: What is the difference between print-multi-directory and
688  // print-multi-os-directory?
689  if (C.getArgs().hasArg(options::OPT_print_multi_directory) ||
690      C.getArgs().hasArg(options::OPT_print_multi_os_directory)) {
691    switch (C.getDefaultToolChain().getTriple().getArch()) {
692    default:
693    case llvm::Triple::x86:
694    case llvm::Triple::ppc:
695      llvm::outs() << "." << "\n";
696      break;
697
698    case llvm::Triple::x86_64:
699      llvm::outs() << "x86_64" << "\n";
700      break;
701
702    case llvm::Triple::ppc64:
703      llvm::outs() << "ppc64" << "\n";
704      break;
705    }
706    return false;
707  }
708
709  return true;
710}
711
712static unsigned PrintActions1(const Compilation &C, Action *A,
713                              std::map<Action*, unsigned> &Ids) {
714  if (Ids.count(A))
715    return Ids[A];
716
717  std::string str;
718  llvm::raw_string_ostream os(str);
719
720  os << Action::getClassName(A->getKind()) << ", ";
721  if (InputAction *IA = dyn_cast<InputAction>(A)) {
722    os << "\"" << IA->getInputArg().getValue(C.getArgs()) << "\"";
723  } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) {
724    os << '"' << (BIA->getArchName() ? BIA->getArchName() :
725                  C.getDefaultToolChain().getArchName()) << '"'
726       << ", {" << PrintActions1(C, *BIA->begin(), Ids) << "}";
727  } else {
728    os << "{";
729    for (Action::iterator it = A->begin(), ie = A->end(); it != ie;) {
730      os << PrintActions1(C, *it, Ids);
731      ++it;
732      if (it != ie)
733        os << ", ";
734    }
735    os << "}";
736  }
737
738  unsigned Id = Ids.size();
739  Ids[A] = Id;
740  llvm::errs() << Id << ": " << os.str() << ", "
741               << types::getTypeName(A->getType()) << "\n";
742
743  return Id;
744}
745
746void Driver::PrintActions(const Compilation &C) const {
747  std::map<Action*, unsigned> Ids;
748  for (ActionList::const_iterator it = C.getActions().begin(),
749         ie = C.getActions().end(); it != ie; ++it)
750    PrintActions1(C, *it, Ids);
751}
752
753/// \brief Check whether the given input tree contains any compilation or
754/// assembly actions.
755static bool ContainsCompileOrAssembleAction(const Action *A) {
756  if (isa<CompileJobAction>(A) || isa<AssembleJobAction>(A))
757    return true;
758
759  for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
760    if (ContainsCompileOrAssembleAction(*it))
761      return true;
762
763  return false;
764}
765
766void Driver::BuildUniversalActions(const ToolChain &TC,
767                                   const DerivedArgList &Args,
768                                   const InputList &BAInputs,
769                                   ActionList &Actions) const {
770  llvm::PrettyStackTraceString CrashInfo("Building universal build actions");
771  // Collect the list of architectures. Duplicates are allowed, but should only
772  // be handled once (in the order seen).
773  llvm::StringSet<> ArchNames;
774  SmallVector<const char *, 4> Archs;
775  for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
776       it != ie; ++it) {
777    Arg *A = *it;
778
779    if (A->getOption().matches(options::OPT_arch)) {
780      // Validate the option here; we don't save the type here because its
781      // particular spelling may participate in other driver choices.
782      llvm::Triple::ArchType Arch =
783        llvm::Triple::getArchTypeForDarwinArchName(A->getValue(Args));
784      if (Arch == llvm::Triple::UnknownArch) {
785        Diag(clang::diag::err_drv_invalid_arch_name)
786          << A->getAsString(Args);
787        continue;
788      }
789
790      A->claim();
791      if (ArchNames.insert(A->getValue(Args)))
792        Archs.push_back(A->getValue(Args));
793    }
794  }
795
796  // When there is no explicit arch for this platform, make sure we still bind
797  // the architecture (to the default) so that -Xarch_ is handled correctly.
798  if (!Archs.size())
799    Archs.push_back(0);
800
801  // FIXME: We killed off some others but these aren't yet detected in a
802  // functional manner. If we added information to jobs about which "auxiliary"
803  // files they wrote then we could detect the conflict these cause downstream.
804  if (Archs.size() > 1) {
805    // No recovery needed, the point of this is just to prevent
806    // overwriting the same files.
807    if (const Arg *A = Args.getLastArg(options::OPT_save_temps))
808      Diag(clang::diag::err_drv_invalid_opt_with_multiple_archs)
809        << A->getAsString(Args);
810  }
811
812  ActionList SingleActions;
813  BuildActions(TC, Args, BAInputs, SingleActions);
814
815  // Add in arch bindings for every top level action, as well as lipo and
816  // dsymutil steps if needed.
817  for (unsigned i = 0, e = SingleActions.size(); i != e; ++i) {
818    Action *Act = SingleActions[i];
819
820    // Make sure we can lipo this kind of output. If not (and it is an actual
821    // output) then we disallow, since we can't create an output file with the
822    // right name without overwriting it. We could remove this oddity by just
823    // changing the output names to include the arch, which would also fix
824    // -save-temps. Compatibility wins for now.
825
826    if (Archs.size() > 1 && !types::canLipoType(Act->getType()))
827      Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
828        << types::getTypeName(Act->getType());
829
830    ActionList Inputs;
831    for (unsigned i = 0, e = Archs.size(); i != e; ++i) {
832      Inputs.push_back(new BindArchAction(Act, Archs[i]));
833      if (i != 0)
834        Inputs.back()->setOwnsInputs(false);
835    }
836
837    // Lipo if necessary, we do it this way because we need to set the arch flag
838    // so that -Xarch_ gets overwritten.
839    if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
840      Actions.append(Inputs.begin(), Inputs.end());
841    else
842      Actions.push_back(new LipoJobAction(Inputs, Act->getType()));
843
844    // Add a 'dsymutil' step if necessary, when debug info is enabled and we
845    // have a compile input. We need to run 'dsymutil' ourselves in such cases
846    // because the debug info will refer to a temporary object file which is
847    // will be removed at the end of the compilation process.
848    if (Act->getType() == types::TY_Image) {
849      Arg *A = Args.getLastArg(options::OPT_g_Group);
850      if (A && !A->getOption().matches(options::OPT_g0) &&
851          !A->getOption().matches(options::OPT_gstabs) &&
852          ContainsCompileOrAssembleAction(Actions.back())) {
853        ActionList Inputs;
854        Inputs.push_back(Actions.back());
855        Actions.pop_back();
856
857        Actions.push_back(new DsymutilJobAction(Inputs, types::TY_dSYM));
858
859	// Verify the debug output if we're in assert mode.
860	// TODO: The verifier is noisy by default so put this under an
861	// option for now.
862	#ifndef NDEBUG
863	if (Args.hasArg(options::OPT_verify)) {
864	  ActionList VerifyInputs;
865	  VerifyInputs.push_back(Actions.back());
866	  Actions.pop_back();
867	  Actions.push_back(new VerifyJobAction(VerifyInputs,
868						types::TY_Nothing));
869	}
870        #endif
871      }
872    }
873  }
874}
875
876// Construct a the list of inputs and their types.
877void Driver::BuildInputs(const ToolChain &TC, const DerivedArgList &Args,
878                         InputList &Inputs) const {
879  // Track the current user specified (-x) input. We also explicitly track the
880  // argument used to set the type; we only want to claim the type when we
881  // actually use it, so we warn about unused -x arguments.
882  types::ID InputType = types::TY_Nothing;
883  Arg *InputTypeArg = 0;
884
885  for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
886       it != ie; ++it) {
887    Arg *A = *it;
888
889    if (isa<InputOption>(A->getOption())) {
890      const char *Value = A->getValue(Args);
891      types::ID Ty = types::TY_INVALID;
892
893      // Infer the input type if necessary.
894      if (InputType == types::TY_Nothing) {
895        // If there was an explicit arg for this, claim it.
896        if (InputTypeArg)
897          InputTypeArg->claim();
898
899        // stdin must be handled specially.
900        if (memcmp(Value, "-", 2) == 0) {
901          // If running with -E, treat as a C input (this changes the builtin
902          // macros, for example). This may be overridden by -ObjC below.
903          //
904          // Otherwise emit an error but still use a valid type to avoid
905          // spurious errors (e.g., no inputs).
906          if (!Args.hasArgNoClaim(options::OPT_E) && !CCCIsCPP)
907            Diag(clang::diag::err_drv_unknown_stdin_type);
908          Ty = types::TY_C;
909        } else {
910          // Otherwise lookup by extension.
911          // Fallback is C if invoked as C preprocessor or Object otherwise.
912          // We use a host hook here because Darwin at least has its own
913          // idea of what .s is.
914          if (const char *Ext = strrchr(Value, '.'))
915            Ty = TC.LookupTypeForExtension(Ext + 1);
916
917          if (Ty == types::TY_INVALID) {
918            if (CCCIsCPP)
919              Ty = types::TY_C;
920            else
921              Ty = types::TY_Object;
922          }
923
924          // If the driver is invoked as C++ compiler (like clang++ or c++) it
925          // should autodetect some input files as C++ for g++ compatibility.
926          if (CCCIsCXX) {
927            types::ID OldTy = Ty;
928            Ty = types::lookupCXXTypeForCType(Ty);
929
930            if (Ty != OldTy)
931              Diag(clang::diag::warn_drv_treating_input_as_cxx)
932                << getTypeName(OldTy) << getTypeName(Ty);
933          }
934        }
935
936        // -ObjC and -ObjC++ override the default language, but only for "source
937        // files". We just treat everything that isn't a linker input as a
938        // source file.
939        //
940        // FIXME: Clean this up if we move the phase sequence into the type.
941        if (Ty != types::TY_Object) {
942          if (Args.hasArg(options::OPT_ObjC))
943            Ty = types::TY_ObjC;
944          else if (Args.hasArg(options::OPT_ObjCXX))
945            Ty = types::TY_ObjCXX;
946        }
947      } else {
948        assert(InputTypeArg && "InputType set w/o InputTypeArg");
949        InputTypeArg->claim();
950        Ty = InputType;
951      }
952
953      // Check that the file exists, if enabled.
954      if (CheckInputsExist && memcmp(Value, "-", 2) != 0) {
955        llvm::SmallString<64> Path(Value);
956        if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory))
957          if (llvm::sys::path::is_absolute(Path.str())) {
958            Path = WorkDir->getValue(Args);
959            llvm::sys::path::append(Path, Value);
960          }
961
962        bool exists = false;
963        if (/*error_code ec =*/llvm::sys::fs::exists(Value, exists) || !exists)
964          Diag(clang::diag::err_drv_no_such_file) << Path.str();
965        else
966          Inputs.push_back(std::make_pair(Ty, A));
967      } else
968        Inputs.push_back(std::make_pair(Ty, A));
969
970    } else if (A->getOption().isLinkerInput()) {
971      // Just treat as object type, we could make a special type for this if
972      // necessary.
973      Inputs.push_back(std::make_pair(types::TY_Object, A));
974
975    } else if (A->getOption().matches(options::OPT_x)) {
976      InputTypeArg = A;
977      InputType = types::lookupTypeForTypeSpecifier(A->getValue(Args));
978
979      // Follow gcc behavior and treat as linker input for invalid -x
980      // options. Its not clear why we shouldn't just revert to unknown; but
981      // this isn't very important, we might as well be bug compatible.
982      if (!InputType) {
983        Diag(clang::diag::err_drv_unknown_language) << A->getValue(Args);
984        InputType = types::TY_Object;
985      }
986    }
987  }
988  if (CCCIsCPP && Inputs.empty()) {
989    // If called as standalone preprocessor, stdin is processed
990    // if no other input is present.
991    unsigned Index = Args.getBaseArgs().MakeIndex("-");
992    Arg *A = Opts->ParseOneArg(Args, Index);
993    A->claim();
994    Inputs.push_back(std::make_pair(types::TY_C, A));
995  }
996}
997
998void Driver::BuildActions(const ToolChain &TC, const DerivedArgList &Args,
999                          const InputList &Inputs, ActionList &Actions) const {
1000  llvm::PrettyStackTraceString CrashInfo("Building compilation actions");
1001
1002  if (!SuppressMissingInputWarning && Inputs.empty()) {
1003    Diag(clang::diag::err_drv_no_input_files);
1004    return;
1005  }
1006
1007  Arg *FinalPhaseArg;
1008  phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg);
1009
1010  // Reject -Z* at the top level, these options should never have been exposed
1011  // by gcc.
1012  if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
1013    Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
1014
1015  // Construct the actions to perform.
1016  ActionList LinkerInputs;
1017  unsigned NumSteps = 0;
1018  for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
1019    types::ID InputType = Inputs[i].first;
1020    const Arg *InputArg = Inputs[i].second;
1021
1022    NumSteps = types::getNumCompilationPhases(InputType);
1023    assert(NumSteps && "Invalid number of steps!");
1024
1025    // If the first step comes after the final phase we are doing as part of
1026    // this compilation, warn the user about it.
1027    phases::ID InitialPhase = types::getCompilationPhase(InputType, 0);
1028    if (InitialPhase > FinalPhase) {
1029      // Claim here to avoid the more general unused warning.
1030      InputArg->claim();
1031
1032      // Suppress all unused style warnings with -Qunused-arguments
1033      if (Args.hasArg(options::OPT_Qunused_arguments))
1034        continue;
1035
1036      // Special case '-E' warning on a previously preprocessed file to make
1037      // more sense.
1038      if (InitialPhase == phases::Compile && FinalPhase == phases::Preprocess &&
1039          getPreprocessedType(InputType) == types::TY_INVALID)
1040        Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
1041          << InputArg->getAsString(Args)
1042          << FinalPhaseArg->getOption().getName();
1043      else
1044        Diag(clang::diag::warn_drv_input_file_unused)
1045          << InputArg->getAsString(Args)
1046          << getPhaseName(InitialPhase)
1047          << FinalPhaseArg->getOption().getName();
1048      continue;
1049    }
1050
1051    // Build the pipeline for this file.
1052    llvm::OwningPtr<Action> Current(new InputAction(*InputArg, InputType));
1053    for (unsigned i = 0; i != NumSteps; ++i) {
1054      phases::ID Phase = types::getCompilationPhase(InputType, i);
1055
1056      // We are done if this step is past what the user requested.
1057      if (Phase > FinalPhase)
1058        break;
1059
1060      // Queue linker inputs.
1061      if (Phase == phases::Link) {
1062        assert(i + 1 == NumSteps && "linking must be final compilation step.");
1063        LinkerInputs.push_back(Current.take());
1064        break;
1065      }
1066
1067      // Some types skip the assembler phase (e.g., llvm-bc), but we can't
1068      // encode this in the steps because the intermediate type depends on
1069      // arguments. Just special case here.
1070      if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm)
1071        continue;
1072
1073      // Otherwise construct the appropriate action.
1074      Current.reset(ConstructPhaseAction(Args, Phase, Current.take()));
1075      if (Current->getType() == types::TY_Nothing)
1076        break;
1077    }
1078
1079    // If we ended with something, add to the output list.
1080    if (Current)
1081      Actions.push_back(Current.take());
1082  }
1083
1084  // Add a link action if necessary.
1085  if (!LinkerInputs.empty())
1086    Actions.push_back(new LinkJobAction(LinkerInputs, types::TY_Image));
1087
1088  // If we are linking, claim any options which are obviously only used for
1089  // compilation.
1090  if (FinalPhase == phases::Link && (NumSteps == 1))
1091    Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
1092}
1093
1094Action *Driver::ConstructPhaseAction(const ArgList &Args, phases::ID Phase,
1095                                     Action *Input) const {
1096  llvm::PrettyStackTraceString CrashInfo("Constructing phase actions");
1097  // Build the appropriate action.
1098  switch (Phase) {
1099  case phases::Link: llvm_unreachable("link action invalid here.");
1100  case phases::Preprocess: {
1101    types::ID OutputTy;
1102    // -{M, MM} alter the output type.
1103    if (Args.hasArg(options::OPT_M, options::OPT_MM)) {
1104      OutputTy = types::TY_Dependencies;
1105    } else {
1106      OutputTy = types::getPreprocessedType(Input->getType());
1107      assert(OutputTy != types::TY_INVALID &&
1108             "Cannot preprocess this input type!");
1109    }
1110    return new PreprocessJobAction(Input, OutputTy);
1111  }
1112  case phases::Precompile:
1113    return new PrecompileJobAction(Input, types::TY_PCH);
1114  case phases::Compile: {
1115    if (Args.hasArg(options::OPT_fsyntax_only)) {
1116      return new CompileJobAction(Input, types::TY_Nothing);
1117    } else if (Args.hasArg(options::OPT_rewrite_objc)) {
1118      return new CompileJobAction(Input, types::TY_RewrittenObjC);
1119    } else if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto)) {
1120      return new AnalyzeJobAction(Input, types::TY_Plist);
1121    } else if (Args.hasArg(options::OPT_emit_ast)) {
1122      return new CompileJobAction(Input, types::TY_AST);
1123    } else if (IsUsingLTO(Args)) {
1124      types::ID Output =
1125        Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
1126      return new CompileJobAction(Input, Output);
1127    } else {
1128      return new CompileJobAction(Input, types::TY_PP_Asm);
1129    }
1130  }
1131  case phases::Assemble:
1132    return new AssembleJobAction(Input, types::TY_Object);
1133  }
1134
1135  llvm_unreachable("invalid phase in ConstructPhaseAction");
1136}
1137
1138bool Driver::IsUsingLTO(const ArgList &Args) const {
1139  // Check for -emit-llvm or -flto.
1140  if (Args.hasArg(options::OPT_emit_llvm) ||
1141      Args.hasFlag(options::OPT_flto, options::OPT_fno_lto, false))
1142    return true;
1143
1144  // Check for -O4.
1145  if (const Arg *A = Args.getLastArg(options::OPT_O_Group))
1146      return A->getOption().matches(options::OPT_O4);
1147
1148  return false;
1149}
1150
1151void Driver::BuildJobs(Compilation &C) const {
1152  llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
1153
1154  Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
1155
1156  // It is an error to provide a -o option if we are making multiple output
1157  // files.
1158  if (FinalOutput) {
1159    unsigned NumOutputs = 0;
1160    for (ActionList::const_iterator it = C.getActions().begin(),
1161           ie = C.getActions().end(); it != ie; ++it)
1162      if ((*it)->getType() != types::TY_Nothing)
1163        ++NumOutputs;
1164
1165    if (NumOutputs > 1) {
1166      Diag(clang::diag::err_drv_output_argument_with_multiple_files);
1167      FinalOutput = 0;
1168    }
1169  }
1170
1171  for (ActionList::const_iterator it = C.getActions().begin(),
1172         ie = C.getActions().end(); it != ie; ++it) {
1173    Action *A = *it;
1174
1175    // If we are linking an image for multiple archs then the linker wants
1176    // -arch_multiple and -final_output <final image name>. Unfortunately, this
1177    // doesn't fit in cleanly because we have to pass this information down.
1178    //
1179    // FIXME: This is a hack; find a cleaner way to integrate this into the
1180    // process.
1181    const char *LinkingOutput = 0;
1182    if (isa<LipoJobAction>(A)) {
1183      if (FinalOutput)
1184        LinkingOutput = FinalOutput->getValue(C.getArgs());
1185      else
1186        LinkingOutput = DefaultImageName.c_str();
1187    }
1188
1189    InputInfo II;
1190    BuildJobsForAction(C, A, &C.getDefaultToolChain(),
1191                       /*BoundArch*/0,
1192                       /*AtTopLevel*/ true,
1193                       /*LinkingOutput*/ LinkingOutput,
1194                       II);
1195  }
1196
1197  // If the user passed -Qunused-arguments or there were errors, don't warn
1198  // about any unused arguments.
1199  if (Diags.hasErrorOccurred() ||
1200      C.getArgs().hasArg(options::OPT_Qunused_arguments))
1201    return;
1202
1203  // Claim -### here.
1204  (void) C.getArgs().hasArg(options::OPT__HASH_HASH_HASH);
1205
1206  for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end();
1207       it != ie; ++it) {
1208    Arg *A = *it;
1209
1210    // FIXME: It would be nice to be able to send the argument to the
1211    // DiagnosticsEngine, so that extra values, position, and so on could be
1212    // printed.
1213    if (!A->isClaimed()) {
1214      if (A->getOption().hasNoArgumentUnused())
1215        continue;
1216
1217      // Suppress the warning automatically if this is just a flag, and it is an
1218      // instance of an argument we already claimed.
1219      const Option &Opt = A->getOption();
1220      if (isa<FlagOption>(Opt)) {
1221        bool DuplicateClaimed = false;
1222
1223        for (arg_iterator it = C.getArgs().filtered_begin(&Opt),
1224               ie = C.getArgs().filtered_end(); it != ie; ++it) {
1225          if ((*it)->isClaimed()) {
1226            DuplicateClaimed = true;
1227            break;
1228          }
1229        }
1230
1231        if (DuplicateClaimed)
1232          continue;
1233      }
1234
1235      Diag(clang::diag::warn_drv_unused_argument)
1236        << A->getAsString(C.getArgs());
1237    }
1238  }
1239}
1240
1241static const Tool &SelectToolForJob(Compilation &C, const ToolChain *TC,
1242                                    const JobAction *JA,
1243                                    const ActionList *&Inputs) {
1244  const Tool *ToolForJob = 0;
1245
1246  // See if we should look for a compiler with an integrated assembler. We match
1247  // bottom up, so what we are actually looking for is an assembler job with a
1248  // compiler input.
1249
1250  if (C.getArgs().hasFlag(options::OPT_integrated_as,
1251                          options::OPT_no_integrated_as,
1252                          TC->IsIntegratedAssemblerDefault()) &&
1253      !C.getArgs().hasArg(options::OPT_save_temps) &&
1254      isa<AssembleJobAction>(JA) &&
1255      Inputs->size() == 1 && isa<CompileJobAction>(*Inputs->begin())) {
1256    const Tool &Compiler = TC->SelectTool(
1257      C, cast<JobAction>(**Inputs->begin()), (*Inputs)[0]->getInputs());
1258    if (Compiler.hasIntegratedAssembler()) {
1259      Inputs = &(*Inputs)[0]->getInputs();
1260      ToolForJob = &Compiler;
1261    }
1262  }
1263
1264  // Otherwise use the tool for the current job.
1265  if (!ToolForJob)
1266    ToolForJob = &TC->SelectTool(C, *JA, *Inputs);
1267
1268  // See if we should use an integrated preprocessor. We do so when we have
1269  // exactly one input, since this is the only use case we care about
1270  // (irrelevant since we don't support combine yet).
1271  if (Inputs->size() == 1 && isa<PreprocessJobAction>(*Inputs->begin()) &&
1272      !C.getArgs().hasArg(options::OPT_no_integrated_cpp) &&
1273      !C.getArgs().hasArg(options::OPT_traditional_cpp) &&
1274      !C.getArgs().hasArg(options::OPT_save_temps) &&
1275      ToolForJob->hasIntegratedCPP())
1276    Inputs = &(*Inputs)[0]->getInputs();
1277
1278  return *ToolForJob;
1279}
1280
1281void Driver::BuildJobsForAction(Compilation &C,
1282                                const Action *A,
1283                                const ToolChain *TC,
1284                                const char *BoundArch,
1285                                bool AtTopLevel,
1286                                const char *LinkingOutput,
1287                                InputInfo &Result) const {
1288  llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
1289
1290  if (const InputAction *IA = dyn_cast<InputAction>(A)) {
1291    // FIXME: It would be nice to not claim this here; maybe the old scheme of
1292    // just using Args was better?
1293    const Arg &Input = IA->getInputArg();
1294    Input.claim();
1295    if (Input.getOption().matches(options::OPT_INPUT)) {
1296      const char *Name = Input.getValue(C.getArgs());
1297      Result = InputInfo(Name, A->getType(), Name);
1298    } else
1299      Result = InputInfo(&Input, A->getType(), "");
1300    return;
1301  }
1302
1303  if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) {
1304    const ToolChain *TC = &C.getDefaultToolChain();
1305
1306    std::string Arch;
1307    if (BAA->getArchName())
1308      TC = Host->CreateToolChain(C.getArgs(), BAA->getArchName());
1309
1310    BuildJobsForAction(C, *BAA->begin(), TC, BAA->getArchName(),
1311                       AtTopLevel, LinkingOutput, Result);
1312    return;
1313  }
1314
1315  const ActionList *Inputs = &A->getInputs();
1316
1317  const JobAction *JA = cast<JobAction>(A);
1318  const Tool &T = SelectToolForJob(C, TC, JA, Inputs);
1319
1320  // Only use pipes when there is exactly one input.
1321  InputInfoList InputInfos;
1322  for (ActionList::const_iterator it = Inputs->begin(), ie = Inputs->end();
1323       it != ie; ++it) {
1324    // Treat dsymutil sub-jobs as being at the top-level too, they shouldn't get
1325    // temporary output names.
1326    //
1327    // FIXME: Clean this up.
1328    bool SubJobAtTopLevel = false;
1329    if (AtTopLevel && isa<DsymutilJobAction>(A))
1330      SubJobAtTopLevel = true;
1331
1332    // Also treat verify sub-jobs as being at the top-level. They don't
1333    // produce any output and so don't need temporary output names.
1334    if (AtTopLevel && isa<VerifyJobAction>(A))
1335      SubJobAtTopLevel = true;
1336
1337    InputInfo II;
1338    BuildJobsForAction(C, *it, TC, BoundArch,
1339                       SubJobAtTopLevel, LinkingOutput, II);
1340    InputInfos.push_back(II);
1341  }
1342
1343  // Always use the first input as the base input.
1344  const char *BaseInput = InputInfos[0].getBaseInput();
1345
1346  // ... except dsymutil actions, which use their actual input as the base
1347  // input.
1348  if (JA->getType() == types::TY_dSYM)
1349    BaseInput = InputInfos[0].getFilename();
1350
1351  // Determine the place to write output to, if any.
1352  if (JA->getType() == types::TY_Nothing) {
1353    Result = InputInfo(A->getType(), BaseInput);
1354  } else {
1355    Result = InputInfo(GetNamedOutputPath(C, *JA, BaseInput, AtTopLevel),
1356                       A->getType(), BaseInput);
1357  }
1358
1359  if (CCCPrintBindings && !CCGenDiagnostics) {
1360    llvm::errs() << "# \"" << T.getToolChain().getTripleString() << '"'
1361                 << " - \"" << T.getName() << "\", inputs: [";
1362    for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
1363      llvm::errs() << InputInfos[i].getAsString();
1364      if (i + 1 != e)
1365        llvm::errs() << ", ";
1366    }
1367    llvm::errs() << "], output: " << Result.getAsString() << "\n";
1368  } else {
1369    T.ConstructJob(C, *JA, Result, InputInfos,
1370                   C.getArgsForToolChain(TC, BoundArch), LinkingOutput);
1371  }
1372}
1373
1374const char *Driver::GetNamedOutputPath(Compilation &C,
1375                                       const JobAction &JA,
1376                                       const char *BaseInput,
1377                                       bool AtTopLevel) const {
1378  llvm::PrettyStackTraceString CrashInfo("Computing output path");
1379  // Output to a user requested destination?
1380  if (AtTopLevel && !isa<DsymutilJobAction>(JA) &&
1381      !isa<VerifyJobAction>(JA)) {
1382    if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
1383      return C.addResultFile(FinalOutput->getValue(C.getArgs()));
1384  }
1385
1386  // Default to writing to stdout?
1387  if (AtTopLevel && isa<PreprocessJobAction>(JA) && !CCGenDiagnostics)
1388    return "-";
1389
1390  // Output to a temporary file?
1391  if ((!AtTopLevel && !C.getArgs().hasArg(options::OPT_save_temps)) ||
1392      CCGenDiagnostics) {
1393    StringRef Name = llvm::sys::path::filename(BaseInput);
1394    std::pair<StringRef, StringRef> Split = Name.split('.');
1395    std::string TmpName =
1396      GetTemporaryPath(Split.first, types::getTypeTempSuffix(JA.getType()));
1397    return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
1398  }
1399
1400  llvm::SmallString<128> BasePath(BaseInput);
1401  StringRef BaseName;
1402
1403  // Dsymutil actions should use the full path.
1404  if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA))
1405    BaseName = BasePath;
1406  else
1407    BaseName = llvm::sys::path::filename(BasePath);
1408
1409  // Determine what the derived output name should be.
1410  const char *NamedOutput;
1411  if (JA.getType() == types::TY_Image) {
1412    NamedOutput = DefaultImageName.c_str();
1413  } else {
1414    const char *Suffix = types::getTypeTempSuffix(JA.getType());
1415    assert(Suffix && "All types used for output should have a suffix.");
1416
1417    std::string::size_type End = std::string::npos;
1418    if (!types::appendSuffixForType(JA.getType()))
1419      End = BaseName.rfind('.');
1420    std::string Suffixed(BaseName.substr(0, End));
1421    Suffixed += '.';
1422    Suffixed += Suffix;
1423    NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str());
1424  }
1425
1426  // If we're saving temps and the temp filename conflicts with the input
1427  // filename, then avoid overwriting input file.
1428  if (!AtTopLevel && C.getArgs().hasArg(options::OPT_save_temps) &&
1429      NamedOutput == BaseName) {
1430    StringRef Name = llvm::sys::path::filename(BaseInput);
1431    std::pair<StringRef, StringRef> Split = Name.split('.');
1432    std::string TmpName =
1433      GetTemporaryPath(Split.first, types::getTypeTempSuffix(JA.getType()));
1434    return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
1435  }
1436
1437  // As an annoying special case, PCH generation doesn't strip the pathname.
1438  if (JA.getType() == types::TY_PCH) {
1439    llvm::sys::path::remove_filename(BasePath);
1440    if (BasePath.empty())
1441      BasePath = NamedOutput;
1442    else
1443      llvm::sys::path::append(BasePath, NamedOutput);
1444    return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str()));
1445  } else {
1446    return C.addResultFile(NamedOutput);
1447  }
1448}
1449
1450std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const {
1451  // Respect a limited subset of the '-Bprefix' functionality in GCC by
1452  // attempting to use this prefix when lokup up program paths.
1453  for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(),
1454       ie = PrefixDirs.end(); it != ie; ++it) {
1455    std::string Dir(*it);
1456    if (Dir.empty())
1457      continue;
1458    if (Dir[0] == '=')
1459      Dir = SysRoot + Dir.substr(1);
1460    llvm::sys::Path P(Dir);
1461    P.appendComponent(Name);
1462    bool Exists;
1463    if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
1464      return P.str();
1465  }
1466
1467  llvm::sys::Path P(ResourceDir);
1468  P.appendComponent(Name);
1469  bool Exists;
1470  if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
1471    return P.str();
1472
1473  const ToolChain::path_list &List = TC.getFilePaths();
1474  for (ToolChain::path_list::const_iterator
1475         it = List.begin(), ie = List.end(); it != ie; ++it) {
1476    std::string Dir(*it);
1477    if (Dir.empty())
1478      continue;
1479    if (Dir[0] == '=')
1480      Dir = SysRoot + Dir.substr(1);
1481    llvm::sys::Path P(Dir);
1482    P.appendComponent(Name);
1483    bool Exists;
1484    if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
1485      return P.str();
1486  }
1487
1488  return Name;
1489}
1490
1491static bool isPathExecutable(llvm::sys::Path &P, bool WantFile) {
1492    bool Exists;
1493    return (WantFile ? !llvm::sys::fs::exists(P.str(), Exists) && Exists
1494                 : P.canExecute());
1495}
1496
1497std::string Driver::GetProgramPath(const char *Name, const ToolChain &TC,
1498                                   bool WantFile) const {
1499  std::string TargetSpecificExecutable(DefaultHostTriple + "-" + Name);
1500  // Respect a limited subset of the '-Bprefix' functionality in GCC by
1501  // attempting to use this prefix when lokup up program paths.
1502  for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(),
1503       ie = PrefixDirs.end(); it != ie; ++it) {
1504    llvm::sys::Path P(*it);
1505    P.appendComponent(TargetSpecificExecutable);
1506    if (isPathExecutable(P, WantFile)) return P.str();
1507    P.eraseComponent();
1508    P.appendComponent(Name);
1509    if (isPathExecutable(P, WantFile)) return P.str();
1510  }
1511
1512  const ToolChain::path_list &List = TC.getProgramPaths();
1513  for (ToolChain::path_list::const_iterator
1514         it = List.begin(), ie = List.end(); it != ie; ++it) {
1515    llvm::sys::Path P(*it);
1516    P.appendComponent(TargetSpecificExecutable);
1517    if (isPathExecutable(P, WantFile)) return P.str();
1518    P.eraseComponent();
1519    P.appendComponent(Name);
1520    if (isPathExecutable(P, WantFile)) return P.str();
1521  }
1522
1523  // If all else failed, search the path.
1524  llvm::sys::Path
1525      P(llvm::sys::Program::FindProgramByName(TargetSpecificExecutable));
1526  if (!P.empty())
1527    return P.str();
1528
1529  P = llvm::sys::Path(llvm::sys::Program::FindProgramByName(Name));
1530  if (!P.empty())
1531    return P.str();
1532
1533  return Name;
1534}
1535
1536std::string Driver::GetTemporaryPath(StringRef Prefix, const char *Suffix)
1537  const {
1538  // FIXME: This is lame; sys::Path should provide this function (in particular,
1539  // it should know how to find the temporary files dir).
1540  std::string Error;
1541  const char *TmpDir = ::getenv("TMPDIR");
1542  if (!TmpDir)
1543    TmpDir = ::getenv("TEMP");
1544  if (!TmpDir)
1545    TmpDir = ::getenv("TMP");
1546  if (!TmpDir)
1547    TmpDir = "/tmp";
1548  llvm::sys::Path P(TmpDir);
1549  P.appendComponent(Prefix);
1550  if (P.makeUnique(false, &Error)) {
1551    Diag(clang::diag::err_drv_unable_to_make_temp) << Error;
1552    return "";
1553  }
1554
1555  // FIXME: Grumble, makeUnique sometimes leaves the file around!?  PR3837.
1556  P.eraseFromDisk(false, 0);
1557
1558  P.appendSuffix(Suffix);
1559  return P.str();
1560}
1561
1562const HostInfo *Driver::GetHostInfo(const char *TripleStr) const {
1563  llvm::PrettyStackTraceString CrashInfo("Constructing host");
1564  llvm::Triple Triple(llvm::Triple::normalize(TripleStr).c_str());
1565
1566  // TCE is an osless target
1567  if (Triple.getArchName() == "tce")
1568    return createTCEHostInfo(*this, Triple);
1569
1570  switch (Triple.getOS()) {
1571  case llvm::Triple::AuroraUX:
1572    return createAuroraUXHostInfo(*this, Triple);
1573  case llvm::Triple::Darwin:
1574  case llvm::Triple::MacOSX:
1575  case llvm::Triple::IOS:
1576    return createDarwinHostInfo(*this, Triple);
1577  case llvm::Triple::DragonFly:
1578    return createDragonFlyHostInfo(*this, Triple);
1579  case llvm::Triple::OpenBSD:
1580    return createOpenBSDHostInfo(*this, Triple);
1581  case llvm::Triple::NetBSD:
1582    return createNetBSDHostInfo(*this, Triple);
1583  case llvm::Triple::FreeBSD:
1584    return createFreeBSDHostInfo(*this, Triple);
1585  case llvm::Triple::Minix:
1586    return createMinixHostInfo(*this, Triple);
1587  case llvm::Triple::Linux:
1588    return createLinuxHostInfo(*this, Triple);
1589  case llvm::Triple::Win32:
1590    return createWindowsHostInfo(*this, Triple);
1591  case llvm::Triple::MinGW32:
1592    return createMinGWHostInfo(*this, Triple);
1593  default:
1594    return createUnknownHostInfo(*this, Triple);
1595  }
1596}
1597
1598bool Driver::ShouldUseClangCompiler(const Compilation &C, const JobAction &JA,
1599                                    const llvm::Triple &Triple) const {
1600  // Check if user requested no clang, or clang doesn't understand this type (we
1601  // only handle single inputs for now).
1602  if (!CCCUseClang || JA.size() != 1 ||
1603      !types::isAcceptedByClang((*JA.begin())->getType()))
1604    return false;
1605
1606  // Otherwise make sure this is an action clang understands.
1607  if (isa<PreprocessJobAction>(JA)) {
1608    if (!CCCUseClangCPP) {
1609      Diag(clang::diag::warn_drv_not_using_clang_cpp);
1610      return false;
1611    }
1612  } else if (!isa<PrecompileJobAction>(JA) && !isa<CompileJobAction>(JA))
1613    return false;
1614
1615  // Use clang for C++?
1616  if (!CCCUseClangCXX && types::isCXX((*JA.begin())->getType())) {
1617    Diag(clang::diag::warn_drv_not_using_clang_cxx);
1618    return false;
1619  }
1620
1621  // Always use clang for precompiling, AST generation, and rewriting,
1622  // regardless of archs.
1623  if (isa<PrecompileJobAction>(JA) ||
1624      types::isOnlyAcceptedByClang(JA.getType()))
1625    return true;
1626
1627  // Finally, don't use clang if this isn't one of the user specified archs to
1628  // build.
1629  if (!CCCClangArchs.empty() && !CCCClangArchs.count(Triple.getArch())) {
1630    Diag(clang::diag::warn_drv_not_using_clang_arch) << Triple.getArchName();
1631    return false;
1632  }
1633
1634  return true;
1635}
1636
1637/// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the
1638/// grouped values as integers. Numbers which are not provided are set to 0.
1639///
1640/// \return True if the entire string was parsed (9.2), or all groups were
1641/// parsed (10.3.5extrastuff).
1642bool Driver::GetReleaseVersion(const char *Str, unsigned &Major,
1643                               unsigned &Minor, unsigned &Micro,
1644                               bool &HadExtra) {
1645  HadExtra = false;
1646
1647  Major = Minor = Micro = 0;
1648  if (*Str == '\0')
1649    return true;
1650
1651  char *End;
1652  Major = (unsigned) strtol(Str, &End, 10);
1653  if (*Str != '\0' && *End == '\0')
1654    return true;
1655  if (*End != '.')
1656    return false;
1657
1658  Str = End+1;
1659  Minor = (unsigned) strtol(Str, &End, 10);
1660  if (*Str != '\0' && *End == '\0')
1661    return true;
1662  if (*End != '.')
1663    return false;
1664
1665  Str = End+1;
1666  Micro = (unsigned) strtol(Str, &End, 10);
1667  if (*Str != '\0' && *End == '\0')
1668    return true;
1669  if (Str == End)
1670    return false;
1671  HadExtra = true;
1672  return true;
1673}
1674