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