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