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