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