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