contrib/llvm/tools/clang/lib/Driver/Driver.cpp

   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
  44 using namespace clang::driver;
  45 using namespace clang;
  46 using namespace llvm::opt;
  47
  48 Driver::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
  76 Driver::~Driver() {
  77   delete Opts;
  78
  79   llvm::DeleteContainerSeconds(ToolChains);
  80 }
  81
  82 void 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
 109 InputArgList *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.
 154 phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, Arg **FinalPhaseArg)
 155 const {
 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
 197 static 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
 206 DerivedArgList *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
 292 Compilation *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.
 411 void 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
 569 void 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
 592 int 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
 655 void 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
 669 void 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.
 688 static 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
 695 bool 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
 821 static 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
 854 void 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.
 863 static 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
 876 void 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.
 971 static 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::path::is_absolute(Twine(Path)) &&
 993       llvm::sys::Process::FindInEnvPath("LIB", Value))
 994     return true;
 995
 996   D.Diag(clang::diag::err_drv_no_such_file) << Path;
 997   return false;
 998 }
 999
1000 // Construct a the list of inputs and their types.
1001 void Driver::BuildInputs(const ToolChain &TC, DerivedArgList &Args,
1002                          InputList &Inputs) const {
1003   // Track the current user specified (-x) input. We also explicitly track the
1004   // argument used to set the type; we only want to claim the type when we
1005   // actually use it, so we warn about unused -x arguments.
1006   types::ID InputType = types::TY_Nothing;
1007   Arg *InputTypeArg = nullptr;
1008
1009   // The last /TC or /TP option sets the input type to C or C++ globally.
1010   if (Arg *TCTP = Args.getLastArgNoClaim(options::OPT__SLASH_TC,
1011                                          options::OPT__SLASH_TP)) {
1012     InputTypeArg = TCTP;
1013     InputType = TCTP->getOption().matches(options::OPT__SLASH_TC)
1014         ? types::TY_C : types::TY_CXX;
1015
1016     arg_iterator it = Args.filtered_begin(options::OPT__SLASH_TC,
1017                                           options::OPT__SLASH_TP);
1018     const arg_iterator ie = Args.filtered_end();
1019     Arg *Previous = *it++;
1020     bool ShowNote = false;
1021     while (it != ie) {
1022       Diag(clang::diag::warn_drv_overriding_flag_option)
1023           << Previous->getSpelling() << (*it)->getSpelling();
1024       Previous = *it++;
1025       ShowNote = true;
1026     }
1027     if (ShowNote)
1028       Diag(clang::diag::note_drv_t_option_is_global);
1029
1030     // No driver mode exposes -x and /TC or /TP; we don't support mixing them.
1031     assert(!Args.hasArg(options::OPT_x) && "-x and /TC or /TP is not allowed");
1032   }
1033
1034   for (Arg *A : Args) {
1035     if (A->getOption().getKind() == Option::InputClass) {
1036       const char *Value = A->getValue();
1037       types::ID Ty = types::TY_INVALID;
1038
1039       // Infer the input type if necessary.
1040       if (InputType == types::TY_Nothing) {
1041         // If there was an explicit arg for this, claim it.
1042         if (InputTypeArg)
1043           InputTypeArg->claim();
1044
1045         // stdin must be handled specially.
1046         if (memcmp(Value, "-", 2) == 0) {
1047           // If running with -E, treat as a C input (this changes the builtin
1048           // macros, for example). This may be overridden by -ObjC below.
1049           //
1050           // Otherwise emit an error but still use a valid type to avoid
1051           // spurious errors (e.g., no inputs).
1052           if (!Args.hasArgNoClaim(options::OPT_E) && !CCCIsCPP())
1053             Diag(IsCLMode() ? clang::diag::err_drv_unknown_stdin_type_clang_cl
1054                             : clang::diag::err_drv_unknown_stdin_type);
1055           Ty = types::TY_C;
1056         } else {
1057           // Otherwise lookup by extension.
1058           // Fallback is C if invoked as C preprocessor or Object otherwise.
1059           // We use a host hook here because Darwin at least has its own
1060           // idea of what .s is.
1061           if (const char *Ext = strrchr(Value, '.'))
1062             Ty = TC.LookupTypeForExtension(Ext + 1);
1063
1064           if (Ty == types::TY_INVALID) {
1065             if (CCCIsCPP())
1066               Ty = types::TY_C;
1067             else
1068               Ty = types::TY_Object;
1069           }
1070
1071           // If the driver is invoked as C++ compiler (like clang++ or c++) it
1072           // should autodetect some input files as C++ for g++ compatibility.
1073           if (CCCIsCXX()) {
1074             types::ID OldTy = Ty;
1075             Ty = types::lookupCXXTypeForCType(Ty);
1076
1077             if (Ty != OldTy)
1078               Diag(clang::diag::warn_drv_treating_input_as_cxx)
1079                 << getTypeName(OldTy) << getTypeName(Ty);
1080           }
1081         }
1082
1083         // -ObjC and -ObjC++ override the default language, but only for "source
1084         // files". We just treat everything that isn't a linker input as a
1085         // source file.
1086         //
1087         // FIXME: Clean this up if we move the phase sequence into the type.
1088         if (Ty != types::TY_Object) {
1089           if (Args.hasArg(options::OPT_ObjC))
1090             Ty = types::TY_ObjC;
1091           else if (Args.hasArg(options::OPT_ObjCXX))
1092             Ty = types::TY_ObjCXX;
1093         }
1094       } else {
1095         assert(InputTypeArg && "InputType set w/o InputTypeArg");
1096         if (!InputTypeArg->getOption().matches(options::OPT_x)) {
1097           // If emulating cl.exe, make sure that /TC and /TP don't affect input
1098           // object files.
1099           const char *Ext = strrchr(Value, '.');
1100           if (Ext && TC.LookupTypeForExtension(Ext + 1) == types::TY_Object)
1101             Ty = types::TY_Object;
1102         }
1103         if (Ty == types::TY_INVALID) {
1104           Ty = InputType;
1105           InputTypeArg->claim();
1106         }
1107       }
1108
1109       if (DiagnoseInputExistence(*this, Args, Value))
1110         Inputs.push_back(std::make_pair(Ty, A));
1111
1112     } else if (A->getOption().matches(options::OPT__SLASH_Tc)) {
1113       StringRef Value = A->getValue();
1114       if (DiagnoseInputExistence(*this, Args, Value)) {
1115         Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
1116         Inputs.push_back(std::make_pair(types::TY_C, InputArg));
1117       }
1118       A->claim();
1119     } else if (A->getOption().matches(options::OPT__SLASH_Tp)) {
1120       StringRef Value = A->getValue();
1121       if (DiagnoseInputExistence(*this, Args, Value)) {
1122         Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
1123         Inputs.push_back(std::make_pair(types::TY_CXX, InputArg));
1124       }
1125       A->claim();
1126     } else if (A->getOption().hasFlag(options::LinkerInput)) {
1127       // Just treat as object type, we could make a special type for this if
1128       // necessary.
1129       Inputs.push_back(std::make_pair(types::TY_Object, A));
1130
1131     } else if (A->getOption().matches(options::OPT_x)) {
1132       InputTypeArg = A;
1133       InputType = types::lookupTypeForTypeSpecifier(A->getValue());
1134       A->claim();
1135
1136       // Follow gcc behavior and treat as linker input for invalid -x
1137       // options. Its not clear why we shouldn't just revert to unknown; but
1138       // this isn't very important, we might as well be bug compatible.
1139       if (!InputType) {
1140         Diag(clang::diag::err_drv_unknown_language) << A->getValue();
1141         InputType = types::TY_Object;
1142       }
1143     }
1144   }
1145   if (CCCIsCPP() && Inputs.empty()) {
1146     // If called as standalone preprocessor, stdin is processed
1147     // if no other input is present.
1148     Arg *A = MakeInputArg(Args, Opts, "-");
1149     Inputs.push_back(std::make_pair(types::TY_C, A));
1150   }
1151 }
1152
1153 void Driver::BuildActions(const ToolChain &TC, DerivedArgList &Args,
1154                           const InputList &Inputs, ActionList &Actions) const {
1155   llvm::PrettyStackTraceString CrashInfo("Building compilation actions");
1156
1157   if (!SuppressMissingInputWarning && Inputs.empty()) {
1158     Diag(clang::diag::err_drv_no_input_files);
1159     return;
1160   }
1161
1162   Arg *FinalPhaseArg;
1163   phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg);
1164
1165   if (FinalPhase == phases::Link && Args.hasArg(options::OPT_emit_llvm)) {
1166     Diag(clang::diag::err_drv_emit_llvm_link);
1167   }
1168
1169   // Reject -Z* at the top level, these options should never have been exposed
1170   // by gcc.
1171   if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
1172     Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
1173
1174   // Diagnose misuse of /Fo.
1175   if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fo)) {
1176     StringRef V = A->getValue();
1177     if (Inputs.size() > 1 && !V.empty() &&
1178         !llvm::sys::path::is_separator(V.back())) {
1179       // Check whether /Fo tries to name an output file for multiple inputs.
1180       Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
1181         << A->getSpelling() << V;
1182       Args.eraseArg(options::OPT__SLASH_Fo);
1183     }
1184   }
1185
1186   // Diagnose misuse of /Fa.
1187   if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fa)) {
1188     StringRef V = A->getValue();
1189     if (Inputs.size() > 1 && !V.empty() &&
1190         !llvm::sys::path::is_separator(V.back())) {
1191       // Check whether /Fa tries to name an asm file for multiple inputs.
1192       Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
1193         << A->getSpelling() << V;
1194       Args.eraseArg(options::OPT__SLASH_Fa);
1195     }
1196   }
1197
1198   // Diagnose misuse of /o.
1199   if (Arg *A = Args.getLastArg(options::OPT__SLASH_o)) {
1200     if (A->getValue()[0] == '\0') {
1201       // It has to have a value.
1202       Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1;
1203       Args.eraseArg(options::OPT__SLASH_o);
1204     }
1205   }
1206
1207   // Construct the actions to perform.
1208   ActionList LinkerInputs;
1209
1210   llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PL;
1211   for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
1212     types::ID InputType = Inputs[i].first;
1213     const Arg *InputArg = Inputs[i].second;
1214
1215     PL.clear();
1216     types::getCompilationPhases(InputType, PL);
1217
1218     // If the first step comes after the final phase we are doing as part of
1219     // this compilation, warn the user about it.
1220     phases::ID InitialPhase = PL[0];
1221     if (InitialPhase > FinalPhase) {
1222       // Claim here to avoid the more general unused warning.
1223       InputArg->claim();
1224
1225       // Suppress all unused style warnings with -Qunused-arguments
1226       if (Args.hasArg(options::OPT_Qunused_arguments))
1227         continue;
1228
1229       // Special case when final phase determined by binary name, rather than
1230       // by a command-line argument with a corresponding Arg.
1231       if (CCCIsCPP())
1232         Diag(clang::diag::warn_drv_input_file_unused_by_cpp)
1233           << InputArg->getAsString(Args)
1234           << getPhaseName(InitialPhase);
1235       // Special case '-E' warning on a previously preprocessed file to make
1236       // more sense.
1237       else if (InitialPhase == phases::Compile &&
1238                FinalPhase == phases::Preprocess &&
1239                getPreprocessedType(InputType) == types::TY_INVALID)
1240         Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
1241           << InputArg->getAsString(Args)
1242           << !!FinalPhaseArg
1243           << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "");
1244       else
1245         Diag(clang::diag::warn_drv_input_file_unused)
1246           << InputArg->getAsString(Args)
1247           << getPhaseName(InitialPhase)
1248           << !!FinalPhaseArg
1249           << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "");
1250       continue;
1251     }
1252
1253     // Build the pipeline for this file.
1254     std::unique_ptr<Action> Current(new InputAction(*InputArg, InputType));
1255     for (SmallVectorImpl<phases::ID>::iterator
1256            i = PL.begin(), e = PL.end(); i != e; ++i) {
1257       phases::ID Phase = *i;
1258
1259       // We are done if this step is past what the user requested.
1260       if (Phase > FinalPhase)
1261         break;
1262
1263       // Queue linker inputs.
1264       if (Phase == phases::Link) {
1265         assert((i + 1) == e && "linking must be final compilation step.");
1266         LinkerInputs.push_back(Current.release());
1267         break;
1268       }
1269
1270       // Some types skip the assembler phase (e.g., llvm-bc), but we can't
1271       // encode this in the steps because the intermediate type depends on
1272       // arguments. Just special case here.
1273       if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm)
1274         continue;
1275
1276       // Otherwise construct the appropriate action.
1277       Current = ConstructPhaseAction(TC, Args, Phase, std::move(Current));
1278       if (Current->getType() == types::TY_Nothing)
1279         break;
1280     }
1281
1282     // If we ended with something, add to the output list.
1283     if (Current)
1284       Actions.push_back(Current.release());
1285   }
1286
1287   // Add a link action if necessary.
1288   if (!LinkerInputs.empty())
1289     Actions.push_back(new LinkJobAction(LinkerInputs, types::TY_Image));
1290
1291   // If we are linking, claim any options which are obviously only used for
1292   // compilation.
1293   if (FinalPhase == phases::Link && PL.size() == 1) {
1294     Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
1295     Args.ClaimAllArgs(options::OPT_cl_compile_Group);
1296   }
1297
1298   // Claim ignored clang-cl options.
1299   Args.ClaimAllArgs(options::OPT_cl_ignored_Group);
1300 }
1301
1302 std::unique_ptr<Action>
1303 Driver::ConstructPhaseAction(const ToolChain &TC, const ArgList &Args,
1304                              phases::ID Phase,
1305                              std::unique_ptr<Action> Input) const {
1306   llvm::PrettyStackTraceString CrashInfo("Constructing phase actions");
1307   // Build the appropriate action.
1308   switch (Phase) {
1309   case phases::Link: llvm_unreachable("link action invalid here.");
1310   case phases::Preprocess: {
1311     types::ID OutputTy;
1312     // -{M, MM} alter the output type.
1313     if (Args.hasArg(options::OPT_M, options::OPT_MM)) {
1314       OutputTy = types::TY_Dependencies;
1315     } else {
1316       OutputTy = Input->getType();
1317       if (!Args.hasFlag(options::OPT_frewrite_includes,
1318                         options::OPT_fno_rewrite_includes, false) &&
1319           !CCGenDiagnostics)
1320         OutputTy = types::getPreprocessedType(OutputTy);
1321       assert(OutputTy != types::TY_INVALID &&
1322              "Cannot preprocess this input type!");
1323     }
1324     return llvm::make_unique<PreprocessJobAction>(std::move(Input), OutputTy);
1325   }
1326   case phases::Precompile: {
1327     types::ID OutputTy = types::TY_PCH;
1328     if (Args.hasArg(options::OPT_fsyntax_only)) {
1329       // Syntax checks should not emit a PCH file
1330       OutputTy = types::TY_Nothing;
1331     }
1332     return llvm::make_unique<PrecompileJobAction>(std::move(Input), OutputTy);
1333   }
1334   case phases::Compile: {
1335     if (Args.hasArg(options::OPT_fsyntax_only))
1336       return llvm::make_unique<CompileJobAction>(std::move(Input),
1337                                                  types::TY_Nothing);
1338     if (Args.hasArg(options::OPT_rewrite_objc))
1339       return llvm::make_unique<CompileJobAction>(std::move(Input),
1340                                                  types::TY_RewrittenObjC);
1341     if (Args.hasArg(options::OPT_rewrite_legacy_objc))
1342       return llvm::make_unique<CompileJobAction>(std::move(Input),
1343                                                  types::TY_RewrittenLegacyObjC);
1344     if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto))
1345       return llvm::make_unique<AnalyzeJobAction>(std::move(Input),
1346                                                  types::TY_Plist);
1347     if (Args.hasArg(options::OPT__migrate))
1348       return llvm::make_unique<MigrateJobAction>(std::move(Input),
1349                                                  types::TY_Remap);
1350     if (Args.hasArg(options::OPT_emit_ast))
1351       return llvm::make_unique<CompileJobAction>(std::move(Input),
1352                                                  types::TY_AST);
1353     if (Args.hasArg(options::OPT_module_file_info))
1354       return llvm::make_unique<CompileJobAction>(std::move(Input),
1355                                                  types::TY_ModuleFile);
1356     if (Args.hasArg(options::OPT_verify_pch))
1357       return llvm::make_unique<VerifyPCHJobAction>(std::move(Input),
1358                                                    types::TY_Nothing);
1359     return llvm::make_unique<CompileJobAction>(std::move(Input),
1360                                                types::TY_LLVM_BC);
1361   }
1362   case phases::Backend: {
1363     if (IsUsingLTO(TC, Args)) {
1364       types::ID Output =
1365         Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
1366       return llvm::make_unique<BackendJobAction>(std::move(Input), Output);
1367     }
1368     if (Args.hasArg(options::OPT_emit_llvm)) {
1369       types::ID Output =
1370         Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC;
1371       return llvm::make_unique<BackendJobAction>(std::move(Input), Output);
1372     }
1373     return llvm::make_unique<BackendJobAction>(std::move(Input),
1374                                                types::TY_PP_Asm);
1375   }
1376   case phases::Assemble:
1377     return llvm::make_unique<AssembleJobAction>(std::move(Input),
1378                                                 types::TY_Object);
1379   }
1380
1381   llvm_unreachable("invalid phase in ConstructPhaseAction");
1382 }
1383
1384 bool Driver::IsUsingLTO(const ToolChain &TC, const ArgList &Args) const {
1385   if (TC.getSanitizerArgs().needsLTO())
1386     return true;
1387
1388   if (Args.hasFlag(options::OPT_flto, options::OPT_fno_lto, false))
1389     return true;
1390
1391   return false;
1392 }
1393
1394 void Driver::BuildJobs(Compilation &C) const {
1395   llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
1396
1397   Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
1398
1399   // It is an error to provide a -o option if we are making multiple output
1400   // files.
1401   if (FinalOutput) {
1402     unsigned NumOutputs = 0;
1403     for (const Action *A : C.getActions())
1404       if (A->getType() != types::TY_Nothing)
1405         ++NumOutputs;
1406
1407     if (NumOutputs > 1) {
1408       Diag(clang::diag::err_drv_output_argument_with_multiple_files);
1409       FinalOutput = nullptr;
1410     }
1411   }
1412
1413   // Collect the list of architectures.
1414   llvm::StringSet<> ArchNames;
1415   if (C.getDefaultToolChain().getTriple().isOSBinFormatMachO())
1416     for (const Arg *A : C.getArgs())
1417       if (A->getOption().matches(options::OPT_arch))
1418         ArchNames.insert(A->getValue());
1419
1420   for (Action *A : C.getActions()) {
1421     // If we are linking an image for multiple archs then the linker wants
1422     // -arch_multiple and -final_output <final image name>. Unfortunately, this
1423     // doesn't fit in cleanly because we have to pass this information down.
1424     //
1425     // FIXME: This is a hack; find a cleaner way to integrate this into the
1426     // process.
1427     const char *LinkingOutput = nullptr;
1428     if (isa<LipoJobAction>(A)) {
1429       if (FinalOutput)
1430         LinkingOutput = FinalOutput->getValue();
1431       else
1432         LinkingOutput = getDefaultImageName();
1433     }
1434
1435     InputInfo II;
1436     BuildJobsForAction(C, A, &C.getDefaultToolChain(),
1437                        /*BoundArch*/nullptr,
1438                        /*AtTopLevel*/ true,
1439                        /*MultipleArchs*/ ArchNames.size() > 1,
1440                        /*LinkingOutput*/ LinkingOutput,
1441                        II);
1442   }
1443
1444   // If the user passed -Qunused-arguments or there were errors, don't warn
1445   // about any unused arguments.
1446   if (Diags.hasErrorOccurred() ||
1447       C.getArgs().hasArg(options::OPT_Qunused_arguments))
1448     return;
1449
1450   // Claim -### here.
1451   (void) C.getArgs().hasArg(options::OPT__HASH_HASH_HASH);
1452
1453   // Claim --driver-mode, it was handled earlier.
1454   (void) C.getArgs().hasArg(options::OPT_driver_mode);
1455
1456   for (Arg *A : C.getArgs()) {
1457     // FIXME: It would be nice to be able to send the argument to the
1458     // DiagnosticsEngine, so that extra values, position, and so on could be
1459     // printed.
1460     if (!A->isClaimed()) {
1461       if (A->getOption().hasFlag(options::NoArgumentUnused))
1462         continue;
1463
1464       // Suppress the warning automatically if this is just a flag, and it is an
1465       // instance of an argument we already claimed.
1466       const Option &Opt = A->getOption();
1467       if (Opt.getKind() == Option::FlagClass) {
1468         bool DuplicateClaimed = false;
1469
1470         for (arg_iterator it = C.getArgs().filtered_begin(&Opt),
1471                ie = C.getArgs().filtered_end(); it != ie; ++it) {
1472           if ((*it)->isClaimed()) {
1473             DuplicateClaimed = true;
1474             break;
1475           }
1476         }
1477
1478         if (DuplicateClaimed)
1479           continue;
1480       }
1481
1482       Diag(clang::diag::warn_drv_unused_argument)
1483         << A->getAsString(C.getArgs());
1484     }
1485   }
1486 }
1487
1488 static const Tool *SelectToolForJob(Compilation &C, bool SaveTemps,
1489                                     const ToolChain *TC, const JobAction *JA,
1490                                     const ActionList *&Inputs) {
1491   const Tool *ToolForJob = nullptr;
1492
1493   // See if we should look for a compiler with an integrated assembler. We match
1494   // bottom up, so what we are actually looking for is an assembler job with a
1495   // compiler input.
1496
1497   if (TC->useIntegratedAs() &&
1498       !SaveTemps &&
1499       !C.getArgs().hasArg(options::OPT_via_file_asm) &&
1500       !C.getArgs().hasArg(options::OPT__SLASH_FA) &&
1501       !C.getArgs().hasArg(options::OPT__SLASH_Fa) &&
1502       isa<AssembleJobAction>(JA) &&
1503       Inputs->size() == 1 && isa<BackendJobAction>(*Inputs->begin())) {
1504     // A BackendJob is always preceded by a CompileJob, and without
1505     // -save-temps they will always get combined together, so instead of
1506     // checking the backend tool, check if the tool for the CompileJob
1507     // has an integrated assembler.
1508     const ActionList *BackendInputs = &(*Inputs)[0]->getInputs();
1509     JobAction *CompileJA = cast<CompileJobAction>(*BackendInputs->begin());
1510     const Tool *Compiler = TC->SelectTool(*CompileJA);
1511     if (!Compiler)
1512       return nullptr;
1513     if (Compiler->hasIntegratedAssembler()) {
1514       Inputs = &(*BackendInputs)[0]->getInputs();
1515       ToolForJob = Compiler;
1516     }
1517   }
1518
1519   // A backend job should always be combined with the preceding compile job
1520   // unless OPT_save_temps is enabled and the compiler is capable of emitting
1521   // LLVM IR as an intermediate output.
1522   if (isa<BackendJobAction>(JA)) {
1523     // Check if the compiler supports emitting LLVM IR.
1524     assert(Inputs->size() == 1);
1525     JobAction *CompileJA = cast<CompileJobAction>(*Inputs->begin());
1526     const Tool *Compiler = TC->SelectTool(*CompileJA);
1527     if (!Compiler)
1528       return nullptr;
1529     if (!Compiler->canEmitIR() || !SaveTemps) {
1530       Inputs = &(*Inputs)[0]->getInputs();
1531       ToolForJob = Compiler;
1532     }
1533   }
1534
1535   // Otherwise use the tool for the current job.
1536   if (!ToolForJob)
1537     ToolForJob = TC->SelectTool(*JA);
1538
1539   // See if we should use an integrated preprocessor. We do so when we have
1540   // exactly one input, since this is the only use case we care about
1541   // (irrelevant since we don't support combine yet).
1542   if (Inputs->size() == 1 && isa<PreprocessJobAction>(*Inputs->begin()) &&
1543       !C.getArgs().hasArg(options::OPT_no_integrated_cpp) &&
1544       !C.getArgs().hasArg(options::OPT_traditional_cpp) &&
1545       !SaveTemps &&
1546       !C.getArgs().hasArg(options::OPT_rewrite_objc) &&
1547       ToolForJob->hasIntegratedCPP())
1548     Inputs = &(*Inputs)[0]->getInputs();
1549
1550   return ToolForJob;
1551 }
1552
1553 void Driver::BuildJobsForAction(Compilation &C,
1554                                 const Action *A,
1555                                 const ToolChain *TC,
1556                                 const char *BoundArch,
1557                                 bool AtTopLevel,
1558                                 bool MultipleArchs,
1559                                 const char *LinkingOutput,
1560                                 InputInfo &Result) const {
1561   llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
1562
1563   if (const InputAction *IA = dyn_cast<InputAction>(A)) {
1564     // FIXME: It would be nice to not claim this here; maybe the old scheme of
1565     // just using Args was better?
1566     const Arg &Input = IA->getInputArg();
1567     Input.claim();
1568     if (Input.getOption().matches(options::OPT_INPUT)) {
1569       const char *Name = Input.getValue();
1570       Result = InputInfo(Name, A->getType(), Name);
1571     } else
1572       Result = InputInfo(&Input, A->getType(), "");
1573     return;
1574   }
1575
1576   if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) {
1577     const ToolChain *TC;
1578     const char *ArchName = BAA->getArchName();
1579
1580     if (ArchName)
1581       TC = &getToolChain(C.getArgs(), ArchName);
1582     else
1583       TC = &C.getDefaultToolChain();
1584
1585     BuildJobsForAction(C, *BAA->begin(), TC, BAA->getArchName(),
1586                        AtTopLevel, MultipleArchs, LinkingOutput, Result);
1587     return;
1588   }
1589
1590   const ActionList *Inputs = &A->getInputs();
1591
1592   const JobAction *JA = cast<JobAction>(A);
1593   const Tool *T = SelectToolForJob(C, isSaveTempsEnabled(), TC, JA, Inputs);
1594   if (!T)
1595     return;
1596
1597   // Only use pipes when there is exactly one input.
1598   InputInfoList InputInfos;
1599   for (const Action *Input : *Inputs) {
1600     // Treat dsymutil and verify sub-jobs as being at the top-level too, they
1601     // shouldn't get temporary output names.
1602     // FIXME: Clean this up.
1603     bool SubJobAtTopLevel = false;
1604     if (AtTopLevel && (isa<DsymutilJobAction>(A) || isa<VerifyJobAction>(A)))
1605       SubJobAtTopLevel = true;
1606
1607     InputInfo II;
1608     BuildJobsForAction(C, Input, TC, BoundArch, SubJobAtTopLevel, MultipleArchs,
1609                        LinkingOutput, II);
1610     InputInfos.push_back(II);
1611   }
1612
1613   // Always use the first input as the base input.
1614   const char *BaseInput = InputInfos[0].getBaseInput();
1615
1616   // ... except dsymutil actions, which use their actual input as the base
1617   // input.
1618   if (JA->getType() == types::TY_dSYM)
1619     BaseInput = InputInfos[0].getFilename();
1620
1621   // Determine the place to write output to, if any.
1622   if (JA->getType() == types::TY_Nothing)
1623     Result = InputInfo(A->getType(), BaseInput);
1624   else
1625     Result = InputInfo(GetNamedOutputPath(C, *JA, BaseInput, BoundArch,
1626                                           AtTopLevel, MultipleArchs),
1627                        A->getType(), BaseInput);
1628
1629   if (CCCPrintBindings && !CCGenDiagnostics) {
1630     llvm::errs() << "# \"" << T->getToolChain().getTripleString() << '"'
1631                  << " - \"" << T->getName() << "\", inputs: [";
1632     for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
1633       llvm::errs() << InputInfos[i].getAsString();
1634       if (i + 1 != e)
1635         llvm::errs() << ", ";
1636     }
1637     llvm::errs() << "], output: " << Result.getAsString() << "\n";
1638   } else {
1639     T->ConstructJob(C, *JA, Result, InputInfos,
1640                     C.getArgsForToolChain(TC, BoundArch), LinkingOutput);
1641   }
1642 }
1643
1644 const char *Driver::getDefaultImageName() const {
1645   llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple));
1646   return Target.isOSWindows() ? "a.exe" : "a.out";
1647 }
1648
1649 /// \brief Create output filename based on ArgValue, which could either be a
1650 /// full filename, filename without extension, or a directory. If ArgValue
1651 /// does not provide a filename, then use BaseName, and use the extension
1652 /// suitable for FileType.
1653 static const char *MakeCLOutputFilename(const ArgList &Args, StringRef ArgValue,
1654                                         StringRef BaseName, types::ID FileType) {
1655   SmallString<128> Filename = ArgValue;
1656
1657   if (ArgValue.empty()) {
1658     // If the argument is empty, output to BaseName in the current dir.
1659     Filename = BaseName;
1660   } else if (llvm::sys::path::is_separator(Filename.back())) {
1661     // If the argument is a directory, output to BaseName in that dir.
1662     llvm::sys::path::append(Filename, BaseName);
1663   }
1664
1665   if (!llvm::sys::path::has_extension(ArgValue)) {
1666     // If the argument didn't provide an extension, then set it.
1667     const char *Extension = types::getTypeTempSuffix(FileType, true);
1668
1669     if (FileType == types::TY_Image &&
1670         Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd)) {
1671       // The output file is a dll.
1672       Extension = "dll";
1673     }
1674
1675     llvm::sys::path::replace_extension(Filename, Extension);
1676   }
1677
1678   return Args.MakeArgString(Filename.c_str());
1679 }
1680
1681 const char *Driver::GetNamedOutputPath(Compilation &C,
1682                                        const JobAction &JA,
1683                                        const char *BaseInput,
1684                                        const char *BoundArch,
1685                                        bool AtTopLevel,
1686                                        bool MultipleArchs) const {
1687   llvm::PrettyStackTraceString CrashInfo("Computing output path");
1688   // Output to a user requested destination?
1689   if (AtTopLevel && !isa<DsymutilJobAction>(JA) &&
1690       !isa<VerifyJobAction>(JA)) {
1691     if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
1692       return C.addResultFile(FinalOutput->getValue(), &JA);
1693   }
1694
1695   // For /P, preprocess to file named after BaseInput.
1696   if (C.getArgs().hasArg(options::OPT__SLASH_P)) {
1697     assert(AtTopLevel && isa<PreprocessJobAction>(JA));
1698     StringRef BaseName = llvm::sys::path::filename(BaseInput);
1699     StringRef NameArg;
1700     if (Arg *A = C.getArgs().getLastArg(options::OPT__SLASH_Fi,
1701                                         options::OPT__SLASH_o))
1702       NameArg = A->getValue();
1703     return C.addResultFile(MakeCLOutputFilename(C.getArgs(), NameArg, BaseName,
1704                                                 types::TY_PP_C), &JA);
1705   }
1706
1707   // Default to writing to stdout?
1708   if (AtTopLevel && !CCGenDiagnostics &&
1709       (isa<PreprocessJobAction>(JA) || JA.getType() == types::TY_ModuleFile))
1710     return "-";
1711
1712   // Is this the assembly listing for /FA?
1713   if (JA.getType() == types::TY_PP_Asm &&
1714       (C.getArgs().hasArg(options::OPT__SLASH_FA) ||
1715        C.getArgs().hasArg(options::OPT__SLASH_Fa))) {
1716     // Use /Fa and the input filename to determine the asm file name.
1717     StringRef BaseName = llvm::sys::path::filename(BaseInput);
1718     StringRef FaValue = C.getArgs().getLastArgValue(options::OPT__SLASH_Fa);
1719     return C.addResultFile(MakeCLOutputFilename(C.getArgs(), FaValue, BaseName,
1720                                                 JA.getType()), &JA);
1721   }
1722
1723   // Output to a temporary file?
1724   if ((!AtTopLevel && !isSaveTempsEnabled() &&
1725         !C.getArgs().hasArg(options::OPT__SLASH_Fo)) ||
1726       CCGenDiagnostics) {
1727     StringRef Name = llvm::sys::path::filename(BaseInput);
1728     std::pair<StringRef, StringRef> Split = Name.split('.');
1729     std::string TmpName =
1730       GetTemporaryPath(Split.first,
1731           types::getTypeTempSuffix(JA.getType(), IsCLMode()));
1732     return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
1733   }
1734
1735   SmallString<128> BasePath(BaseInput);
1736   StringRef BaseName;
1737
1738   // Dsymutil actions should use the full path.
1739   if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA))
1740     BaseName = BasePath;
1741   else
1742     BaseName = llvm::sys::path::filename(BasePath);
1743
1744   // Determine what the derived output name should be.
1745   const char *NamedOutput;
1746
1747   if (JA.getType() == types::TY_Object &&
1748       C.getArgs().hasArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)) {
1749     // The /Fo or /o flag decides the object filename.
1750     StringRef Val = C.getArgs().getLastArg(options::OPT__SLASH_Fo,
1751                                            options::OPT__SLASH_o)->getValue();
1752     NamedOutput = MakeCLOutputFilename(C.getArgs(), Val, BaseName,
1753                                        types::TY_Object);
1754   } else if (JA.getType() == types::TY_Image &&
1755              C.getArgs().hasArg(options::OPT__SLASH_Fe, options::OPT__SLASH_o)) {
1756     // The /Fe or /o flag names the linked file.
1757     StringRef Val = C.getArgs().getLastArg(options::OPT__SLASH_Fe,
1758                                            options::OPT__SLASH_o)->getValue();
1759     NamedOutput = MakeCLOutputFilename(C.getArgs(), Val, BaseName,
1760                                        types::TY_Image);
1761   } else if (JA.getType() == types::TY_Image) {
1762     if (IsCLMode()) {
1763       // clang-cl uses BaseName for the executable name.
1764       NamedOutput = MakeCLOutputFilename(C.getArgs(), "", BaseName,
1765                                          types::TY_Image);
1766     } else if (MultipleArchs && BoundArch) {
1767       SmallString<128> Output(getDefaultImageName());
1768       Output += "-";
1769       Output.append(BoundArch);
1770       NamedOutput = C.getArgs().MakeArgString(Output.c_str());
1771     } else
1772       NamedOutput = getDefaultImageName();
1773   } else {
1774     const char *Suffix = types::getTypeTempSuffix(JA.getType(), IsCLMode());
1775     assert(Suffix && "All types used for output should have a suffix.");
1776
1777     std::string::size_type End = std::string::npos;
1778     if (!types::appendSuffixForType(JA.getType()))
1779       End = BaseName.rfind('.');
1780     SmallString<128> Suffixed(BaseName.substr(0, End));
1781     if (MultipleArchs && BoundArch) {
1782       Suffixed += "-";
1783       Suffixed.append(BoundArch);
1784     }
1785     // When using both -save-temps and -emit-llvm, use a ".tmp.bc" suffix for
1786     // the unoptimized bitcode so that it does not get overwritten by the ".bc"
1787     // optimized bitcode output.
1788     if (!AtTopLevel && C.getArgs().hasArg(options::OPT_emit_llvm) &&
1789         JA.getType() == types::TY_LLVM_BC)
1790       Suffixed += ".tmp";
1791     Suffixed += '.';
1792     Suffixed += Suffix;
1793     NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str());
1794   }
1795
1796   // Prepend object file path if -save-temps=obj
1797   if (!AtTopLevel && isSaveTempsObj() && C.getArgs().hasArg(options::OPT_o) &&
1798       JA.getType() != types::TY_PCH) {
1799     Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
1800     SmallString<128> TempPath(FinalOutput->getValue());
1801     llvm::sys::path::remove_filename(TempPath);
1802     StringRef OutputFileName = llvm::sys::path::filename(NamedOutput);
1803     llvm::sys::path::append(TempPath, OutputFileName);
1804     NamedOutput = C.getArgs().MakeArgString(TempPath.c_str());
1805   }
1806
1807   // If we're saving temps and the temp file conflicts with the input file,
1808   // then avoid overwriting input file.
1809   if (!AtTopLevel && isSaveTempsEnabled() && NamedOutput == BaseName) {
1810     bool SameFile = false;
1811     SmallString<256> Result;
1812     llvm::sys::fs::current_path(Result);
1813     llvm::sys::path::append(Result, BaseName);
1814     llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile);
1815     // Must share the same path to conflict.
1816     if (SameFile) {
1817       StringRef Name = llvm::sys::path::filename(BaseInput);
1818       std::pair<StringRef, StringRef> Split = Name.split('.');
1819       std::string TmpName =
1820         GetTemporaryPath(Split.first,
1821             types::getTypeTempSuffix(JA.getType(), IsCLMode()));
1822       return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
1823     }
1824   }
1825
1826   // As an annoying special case, PCH generation doesn't strip the pathname.
1827   if (JA.getType() == types::TY_PCH) {
1828     llvm::sys::path::remove_filename(BasePath);
1829     if (BasePath.empty())
1830       BasePath = NamedOutput;
1831     else
1832       llvm::sys::path::append(BasePath, NamedOutput);
1833     return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str()), &JA);
1834   } else {
1835     return C.addResultFile(NamedOutput, &JA);
1836   }
1837 }
1838
1839 std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const {
1840   // Respect a limited subset of the '-Bprefix' functionality in GCC by
1841   // attempting to use this prefix when looking for file paths.
1842   for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(),
1843        ie = PrefixDirs.end(); it != ie; ++it) {
1844     std::string Dir(*it);
1845     if (Dir.empty())
1846       continue;
1847     if (Dir[0] == '=')
1848       Dir = SysRoot + Dir.substr(1);
1849     SmallString<128> P(Dir);
1850     llvm::sys::path::append(P, Name);
1851     if (llvm::sys::fs::exists(Twine(P)))
1852       return P.str();
1853   }
1854
1855   SmallString<128> P(ResourceDir);
1856   llvm::sys::path::append(P, Name);
1857   if (llvm::sys::fs::exists(Twine(P)))
1858     return P.str();
1859
1860   const ToolChain::path_list &List = TC.getFilePaths();
1861   for (ToolChain::path_list::const_iterator
1862          it = List.begin(), ie = List.end(); it != ie; ++it) {
1863     std::string Dir(*it);
1864     if (Dir.empty())
1865       continue;
1866     if (Dir[0] == '=')
1867       Dir = SysRoot + Dir.substr(1);
1868     SmallString<128> P(Dir);
1869     llvm::sys::path::append(P, Name);
1870     if (llvm::sys::fs::exists(Twine(P)))
1871       return P.str();
1872   }
1873
1874   return Name;
1875 }
1876
1877 void
1878 Driver::generatePrefixedToolNames(const char *Tool, const ToolChain &TC,
1879                                   SmallVectorImpl<std::string> &Names) const {
1880   // FIXME: Needs a better variable than DefaultTargetTriple
1881   Names.push_back(DefaultTargetTriple + "-" + Tool);
1882   Names.push_back(Tool);
1883 }
1884
1885 static bool ScanDirForExecutable(SmallString<128> &Dir,
1886                                  ArrayRef<std::string> Names) {
1887   for (const auto &Name : Names) {
1888     llvm::sys::path::append(Dir, Name);
1889     if (llvm::sys::fs::can_execute(Twine(Dir)))
1890       return true;
1891     llvm::sys::path::remove_filename(Dir);
1892   }
1893   return false;
1894 }
1895
1896 std::string Driver::GetProgramPath(const char *Name,
1897                                    const ToolChain &TC) const {
1898   SmallVector<std::string, 2> TargetSpecificExecutables;
1899   generatePrefixedToolNames(Name, TC, TargetSpecificExecutables);
1900
1901   // Respect a limited subset of the '-Bprefix' functionality in GCC by
1902   // attempting to use this prefix when looking for program paths.
1903   for (const auto &PrefixDir : PrefixDirs) {
1904     if (llvm::sys::fs::is_directory(PrefixDir)) {
1905       SmallString<128> P(PrefixDir);
1906       if (ScanDirForExecutable(P, TargetSpecificExecutables))
1907         return P.str();
1908     } else {
1909       SmallString<128> P(PrefixDir + Name);
1910       if (llvm::sys::fs::can_execute(Twine(P)))
1911         return P.str();
1912     }
1913   }
1914
1915   const ToolChain::path_list &List = TC.getProgramPaths();
1916   for (const auto &Path : List) {
1917     SmallString<128> P(Path);
1918     if (ScanDirForExecutable(P, TargetSpecificExecutables))
1919       return P.str();
1920   }
1921
1922   // If all else failed, search the path.
1923   for (const auto &TargetSpecificExecutable : TargetSpecificExecutables)
1924     if (llvm::ErrorOr<std::string> P =
1925             llvm::sys::findProgramByName(TargetSpecificExecutable))
1926       return *P;
1927
1928   return Name;
1929 }
1930
1931 std::string Driver::GetTemporaryPath(StringRef Prefix, const char *Suffix)
1932   const {
1933   SmallString<128> Path;
1934   std::error_code EC = llvm::sys::fs::createTemporaryFile(Prefix, Suffix, Path);
1935   if (EC) {
1936     Diag(clang::diag::err_unable_to_make_temp) << EC.message();
1937     return "";
1938   }
1939
1940   return Path.str();
1941 }
1942
1943 /// \brief Compute target triple from args.
1944 ///
1945 /// This routine provides the logic to compute a target triple from various
1946 /// args passed to the driver and the default triple string.
1947 static llvm::Triple computeTargetTriple(StringRef DefaultTargetTriple,
1948                                         const ArgList &Args,
1949                                         StringRef DarwinArchName) {
1950   // FIXME: Already done in Compilation *Driver::BuildCompilation
1951   if (const Arg *A = Args.getLastArg(options::OPT_target))
1952     DefaultTargetTriple = A->getValue();
1953
1954   llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple));
1955
1956   // Handle Apple-specific options available here.
1957   if (Target.isOSBinFormatMachO()) {
1958     // If an explict Darwin arch name is given, that trumps all.
1959     if (!DarwinArchName.empty()) {
1960       tools::darwin::setTripleTypeForMachOArchName(Target, DarwinArchName);
1961       return Target;
1962     }
1963
1964     // Handle the Darwin '-arch' flag.
1965     if (Arg *A = Args.getLastArg(options::OPT_arch)) {
1966       StringRef ArchName = A->getValue();
1967       tools::darwin::setTripleTypeForMachOArchName(Target, ArchName);
1968     }
1969   }
1970
1971   // Handle pseudo-target flags '-mlittle-endian'/'-EL' and
1972   // '-mbig-endian'/'-EB'.
1973   if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
1974                                options::OPT_mbig_endian)) {
1975     if (A->getOption().matches(options::OPT_mlittle_endian)) {
1976       if (Target.getArch() == llvm::Triple::mips)
1977         Target.setArch(llvm::Triple::mipsel);
1978       else if (Target.getArch() == llvm::Triple::mips64)
1979         Target.setArch(llvm::Triple::mips64el);
1980       else if (Target.getArch() == llvm::Triple::aarch64_be)
1981         Target.setArch(llvm::Triple::aarch64);
1982     } else {
1983       if (Target.getArch() == llvm::Triple::mipsel)
1984         Target.setArch(llvm::Triple::mips);
1985       else if (Target.getArch() == llvm::Triple::mips64el)
1986         Target.setArch(llvm::Triple::mips64);
1987       else if (Target.getArch() == llvm::Triple::aarch64)
1988         Target.setArch(llvm::Triple::aarch64_be);
1989     }
1990   }
1991
1992   // Skip further flag support on OSes which don't support '-m32' or '-m64'.
1993   if (Target.getArchName() == "tce" || Target.getOS() == llvm::Triple::Minix)
1994     return Target;
1995
1996   // Handle pseudo-target flags '-m64', '-mx32', '-m32' and '-m16'.
1997   if (Arg *A = Args.getLastArg(options::OPT_m64, options::OPT_mx32,
1998                                options::OPT_m32, options::OPT_m16)) {
1999     llvm::Triple::ArchType AT = llvm::Triple::UnknownArch;
2000
2001     if (A->getOption().matches(options::OPT_m64)) {
2002       AT = Target.get64BitArchVariant().getArch();
2003       if (Target.getEnvironment() == llvm::Triple::GNUX32)
2004         Target.setEnvironment(llvm::Triple::GNU);
2005     } else if (A->getOption().matches(options::OPT_mx32) &&
2006              Target.get64BitArchVariant().getArch() == llvm::Triple::x86_64) {
2007       AT = llvm::Triple::x86_64;
2008       Target.setEnvironment(llvm::Triple::GNUX32);
2009     } else if (A->getOption().matches(options::OPT_m32)) {
2010       AT = Target.get32BitArchVariant().getArch();
2011       if (Target.getEnvironment() == llvm::Triple::GNUX32)
2012         Target.setEnvironment(llvm::Triple::GNU);
2013     } else if (A->getOption().matches(options::OPT_m16) &&
2014              Target.get32BitArchVariant().getArch() == llvm::Triple::x86) {
2015       AT = llvm::Triple::x86;
2016       Target.setEnvironment(llvm::Triple::CODE16);
2017     }
2018
2019     if (AT != llvm::Triple::UnknownArch && AT != Target.getArch())
2020       Target.setArch(AT);
2021   }
2022
2023   return Target;
2024 }
2025
2026 const ToolChain &Driver::getToolChain(const ArgList &Args,
2027                                       StringRef DarwinArchName) const {
2028   llvm::Triple Target =
2029       computeTargetTriple(DefaultTargetTriple, Args, DarwinArchName);
2030
2031   ToolChain *&TC = ToolChains[Target.str()];
2032   if (!TC) {
2033     switch (Target.getOS()) {
2034     case llvm::Triple::CloudABI:
2035       TC = new toolchains::CloudABI(*this, Target, Args);
2036       break;
2037     case llvm::Triple::Darwin:
2038     case llvm::Triple::MacOSX:
2039     case llvm::Triple::IOS:
2040       TC = new toolchains::DarwinClang(*this, Target, Args);
2041       break;
2042     case llvm::Triple::DragonFly:
2043       TC = new toolchains::DragonFly(*this, Target, Args);
2044       break;
2045     case llvm::Triple::OpenBSD:
2046       TC = new toolchains::OpenBSD(*this, Target, Args);
2047       break;
2048     case llvm::Triple::Bitrig:
2049       TC = new toolchains::Bitrig(*this, Target, Args);
2050       break;
2051     case llvm::Triple::NetBSD:
2052       TC = new toolchains::NetBSD(*this, Target, Args);
2053       break;
2054     case llvm::Triple::FreeBSD:
2055       TC = new toolchains::FreeBSD(*this, Target, Args);
2056       break;
2057     case llvm::Triple::Minix:
2058       TC = new toolchains::Minix(*this, Target, Args);
2059       break;
2060     case llvm::Triple::Linux:
2061       if (Target.getArch() == llvm::Triple::hexagon)
2062         TC = new toolchains::Hexagon_TC(*this, Target, Args);
2063       else
2064         TC = new toolchains::Linux(*this, Target, Args);
2065       break;
2066     case llvm::Triple::NaCl:
2067       TC = new toolchains::NaCl_TC(*this, Target, Args);
2068       break;
2069     case llvm::Triple::Solaris:
2070       TC = new toolchains::Solaris(*this, Target, Args);
2071       break;
2072     case llvm::Triple::Win32:
2073       switch (Target.getEnvironment()) {
2074       default:
2075         if (Target.isOSBinFormatELF())
2076           TC = new toolchains::Generic_ELF(*this, Target, Args);
2077         else if (Target.isOSBinFormatMachO())
2078           TC = new toolchains::MachO(*this, Target, Args);
2079         else
2080           TC = new toolchains::Generic_GCC(*this, Target, Args);
2081         break;
2082       case llvm::Triple::GNU:
2083         // FIXME: We need a MinGW toolchain.  Use the default Generic_GCC
2084         // toolchain for now as the default case would below otherwise.
2085         if (Target.isOSBinFormatELF())
2086           TC = new toolchains::Generic_ELF(*this, Target, Args);
2087         else
2088           TC = new toolchains::Generic_GCC(*this, Target, Args);
2089         break;
2090       case llvm::Triple::Itanium:
2091         TC = new toolchains::CrossWindowsToolChain(*this, Target, Args);
2092         break;
2093       case llvm::Triple::MSVC:
2094       case llvm::Triple::UnknownEnvironment:
2095         TC = new toolchains::MSVCToolChain(*this, Target, Args);
2096         break;
2097       }
2098       break;
2099     default:
2100       // Of these targets, Hexagon is the only one that might have
2101       // an OS of Linux, in which case it got handled above already.
2102       if (Target.getArchName() == "tce")
2103         TC = new toolchains::TCEToolChain(*this, Target, Args);
2104       else if (Target.getArch() == llvm::Triple::hexagon)
2105         TC = new toolchains::Hexagon_TC(*this, Target, Args);
2106       else if (Target.getArch() == llvm::Triple::xcore)
2107         TC = new toolchains::XCore(*this, Target, Args);
2108       else if (Target.isOSBinFormatELF())
2109         TC = new toolchains::Generic_ELF(*this, Target, Args);
2110       else if (Target.isOSBinFormatMachO())
2111         TC = new toolchains::MachO(*this, Target, Args);
2112       else
2113         TC = new toolchains::Generic_GCC(*this, Target, Args);
2114       break;
2115     }
2116   }
2117   return *TC;
2118 }
2119
2120 bool Driver::ShouldUseClangCompiler(const JobAction &JA) const {
2121   // Check if user requested no clang, or clang doesn't understand this type (we
2122   // only handle single inputs for now).
2123   if (JA.size() != 1 ||
2124       !types::isAcceptedByClang((*JA.begin())->getType()))
2125     return false;
2126
2127   // Otherwise make sure this is an action clang understands.
2128   if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) &&
2129       !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
2130     return false;
2131
2132   return true;
2133 }
2134
2135 /// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the
2136 /// grouped values as integers. Numbers which are not provided are set to 0.
2137 ///
2138 /// \return True if the entire string was parsed (9.2), or all groups were
2139 /// parsed (10.3.5extrastuff).
2140 bool Driver::GetReleaseVersion(const char *Str, unsigned &Major,
2141                                unsigned &Minor, unsigned &Micro,
2142                                bool &HadExtra) {
2143   HadExtra = false;
2144
2145   Major = Minor = Micro = 0;
2146   if (*Str == '\0')
2147     return false;
2148
2149   char *End;
2150   Major = (unsigned) strtol(Str, &End, 10);
2151   if (*Str != '\0' && *End == '\0')
2152     return true;
2153   if (*End != '.')
2154     return false;
2155
2156   Str = End+1;
2157   Minor = (unsigned) strtol(Str, &End, 10);
2158   if (*Str != '\0' && *End == '\0')
2159     return true;
2160   if (*End != '.')
2161     return false;
2162
2163   Str = End+1;
2164   Micro = (unsigned) strtol(Str, &End, 10);
2165   if (*Str != '\0' && *End == '\0')
2166     return true;
2167   if (Str == End)
2168     return false;
2169   HadExtra = true;
2170   return true;
2171 }
2172
2173 std::pair<unsigned, unsigned> Driver::getIncludeExcludeOptionFlagMasks() const {
2174   unsigned IncludedFlagsBitmask = 0;
2175   unsigned ExcludedFlagsBitmask = options::NoDriverOption;
2176
2177   if (Mode == CLMode) {
2178     // Include CL and Core options.
2179     IncludedFlagsBitmask |= options::CLOption;
2180     IncludedFlagsBitmask |= options::CoreOption;
2181   } else {
2182     ExcludedFlagsBitmask |= options::CLOption;
2183   }
2184
2185   return std::make_pair(IncludedFlagsBitmask, ExcludedFlagsBitmask);
2186 }
2187
2188 bool clang::driver::isOptimizationLevelFast(const llvm::opt::ArgList &Args) {
2189   return Args.hasFlag(options::OPT_Ofast, options::OPT_O_Group, false);
2190 }