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 #ifdef HAVE_CLANG_CONFIG_H
     11 # include "clang/Config/config.h"
     12 #endif
     13 
     14 #include "clang/Driver/Driver.h"
     15 
     16 #include "clang/Driver/Action.h"
     17 #include "clang/Driver/Arg.h"
     18 #include "clang/Driver/ArgList.h"
     19 #include "clang/Driver/Compilation.h"
     20 #include "clang/Driver/DriverDiagnostic.h"
     21 #include "clang/Driver/HostInfo.h"
     22 #include "clang/Driver/Job.h"
     23 #include "clang/Driver/OptTable.h"
     24 #include "clang/Driver/Option.h"
     25 #include "clang/Driver/Options.h"
     26 #include "clang/Driver/Tool.h"
     27 #include "clang/Driver/ToolChain.h"
     28 #include "clang/Driver/Types.h"
     29 
     30 #include "clang/Basic/Version.h"
     31 
     32 #include "llvm/Config/config.h"
     33 #include "llvm/ADT/ArrayRef.h"
     34 #include "llvm/ADT/StringSet.h"
     35 #include "llvm/ADT/OwningPtr.h"
     36 #include "llvm/Support/PrettyStackTrace.h"
     37 #include "llvm/Support/raw_ostream.h"
     38 #include "llvm/Support/FileSystem.h"
     39 #include "llvm/Support/Path.h"
     40 #include "llvm/Support/Program.h"
     41 
     42 #include "InputInfo.h"
     43 
     44 #include <map>
     45 
     46 using namespace clang::driver;
     47 using namespace clang;
     48 
     49 Driver::Driver(llvm::StringRef ClangExecutable,
     50                llvm::StringRef DefaultHostTriple,
     51                llvm::StringRef DefaultImageName,
     52                bool IsProduction, bool CXXIsProduction,
     53                Diagnostic &Diags)
     54   : Opts(createDriverOptTable()), Diags(Diags),
     55     ClangExecutable(ClangExecutable), UseStdLib(true),
     56     DefaultHostTriple(DefaultHostTriple), DefaultImageName(DefaultImageName),
     57     DriverTitle("clang \"gcc-compatible\" driver"),
     58     Host(0),
     59     CCPrintOptionsFilename(0), CCPrintHeadersFilename(0),
     60     CCLogDiagnosticsFilename(0), CCCIsCXX(false),
     61     CCCIsCPP(false),CCCEcho(false), CCCPrintBindings(false),
     62     CCPrintOptions(false), CCPrintHeaders(false), CCLogDiagnostics(false),
     63     CCCGenericGCCName(""), CheckInputsExist(true), CCCUseClang(true),
     64     CCCUseClangCXX(true), CCCUseClangCPP(true), CCCUsePCH(true),
     65     SuppressMissingInputWarning(false) {
     66   if (IsProduction) {
     67     // In a "production" build, only use clang on architectures we expect to
     68     // work, and don't use clang C++.
     69     //
     70     // During development its more convenient to always have the driver use
     71     // clang, but we don't want users to be confused when things don't work, or
     72     // to file bugs for things we don't support.
     73     CCCClangArchs.insert(llvm::Triple::x86);
     74     CCCClangArchs.insert(llvm::Triple::x86_64);
     75     CCCClangArchs.insert(llvm::Triple::arm);
     76 
     77     if (!CXXIsProduction)
     78       CCCUseClangCXX = false;
     79   }
     80 
     81   Name = llvm::sys::path::stem(ClangExecutable);
     82   Dir  = llvm::sys::path::parent_path(ClangExecutable);
     83 
     84   // Compute the path to the resource directory.
     85   llvm::StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
     86   llvm::SmallString<128> P(Dir);
     87   if (ClangResourceDir != "")
     88     llvm::sys::path::append(P, ClangResourceDir);
     89   else
     90     llvm::sys::path::append(P, "..", "lib", "clang", CLANG_VERSION_STRING);
     91   ResourceDir = P.str();
     92 }
     93 
     94 Driver::~Driver() {
     95   delete Opts;
     96   delete Host;
     97 }
     98 
     99 InputArgList *Driver::ParseArgStrings(llvm::ArrayRef<const char *> ArgList) {
    100   llvm::PrettyStackTraceString CrashInfo("Command line argument parsing");
    101   unsigned MissingArgIndex, MissingArgCount;
    102   InputArgList *Args = getOpts().ParseArgs(ArgList.begin(), ArgList.end(),
    103                                            MissingArgIndex, MissingArgCount);
    104 
    105   // Check for missing argument error.
    106   if (MissingArgCount)
    107     Diag(clang::diag::err_drv_missing_argument)
    108       << Args->getArgString(MissingArgIndex) << MissingArgCount;
    109 
    110   // Check for unsupported options.
    111   for (ArgList::const_iterator it = Args->begin(), ie = Args->end();
    112        it != ie; ++it) {
    113     Arg *A = *it;
    114     if (A->getOption().isUnsupported()) {
    115       Diag(clang::diag::err_drv_unsupported_opt) << A->getAsString(*Args);
    116       continue;
    117     }
    118   }
    119 
    120   return Args;
    121 }
    122 
    123 DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const {
    124   DerivedArgList *DAL = new DerivedArgList(Args);
    125 
    126   bool HasNostdlib = Args.hasArg(options::OPT_nostdlib);
    127   for (ArgList::const_iterator it = Args.begin(),
    128          ie = Args.end(); it != ie; ++it) {
    129     const Arg *A = *it;
    130 
    131     // Unfortunately, we have to parse some forwarding options (-Xassembler,
    132     // -Xlinker, -Xpreprocessor) because we either integrate their functionality
    133     // (assembler and preprocessor), or bypass a previous driver ('collect2').
    134 
    135     // Rewrite linker options, to replace --no-demangle with a custom internal
    136     // option.
    137     if ((A->getOption().matches(options::OPT_Wl_COMMA) ||
    138          A->getOption().matches(options::OPT_Xlinker)) &&
    139         A->containsValue("--no-demangle")) {
    140       // Add the rewritten no-demangle argument.
    141       DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle));
    142 
    143       // Add the remaining values as Xlinker arguments.
    144       for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
    145         if (llvm::StringRef(A->getValue(Args, i)) != "--no-demangle")
    146           DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker),
    147                               A->getValue(Args, i));
    148 
    149       continue;
    150     }
    151 
    152     // Rewrite preprocessor options, to replace -Wp,-MD,FOO which is used by
    153     // some build systems. We don't try to be complete here because we don't
    154     // care to encourage this usage model.
    155     if (A->getOption().matches(options::OPT_Wp_COMMA) &&
    156         A->getNumValues() == 2 &&
    157         (A->getValue(Args, 0) == llvm::StringRef("-MD") ||
    158          A->getValue(Args, 0) == llvm::StringRef("-MMD"))) {
    159       // Rewrite to -MD/-MMD along with -MF.
    160       if (A->getValue(Args, 0) == llvm::StringRef("-MD"))
    161         DAL->AddFlagArg(A, Opts->getOption(options::OPT_MD));
    162       else
    163         DAL->AddFlagArg(A, Opts->getOption(options::OPT_MMD));
    164       DAL->AddSeparateArg(A, Opts->getOption(options::OPT_MF),
    165                           A->getValue(Args, 1));
    166       continue;
    167     }
    168 
    169     // Rewrite reserved library names.
    170     if (A->getOption().matches(options::OPT_l)) {
    171       llvm::StringRef Value = A->getValue(Args);
    172 
    173       // Rewrite unless -nostdlib is present.
    174       if (!HasNostdlib && Value == "stdc++") {
    175         DAL->AddFlagArg(A, Opts->getOption(
    176                               options::OPT_Z_reserved_lib_stdcxx));
    177         continue;
    178       }
    179 
    180       // Rewrite unconditionally.
    181       if (Value == "cc_kext") {
    182         DAL->AddFlagArg(A, Opts->getOption(
    183                               options::OPT_Z_reserved_lib_cckext));
    184         continue;
    185       }
    186     }
    187 
    188     DAL->append(*it);
    189   }
    190 
    191   // Add a default value of -mlinker-version=, if one was given and the user
    192   // didn't specify one.
    193 #if defined(HOST_LINK_VERSION)
    194   if (!Args.hasArg(options::OPT_mlinker_version_EQ)) {
    195     DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ),
    196                       HOST_LINK_VERSION);
    197     DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim();
    198   }
    199 #endif
    200 
    201   return DAL;
    202 }
    203 
    204 Compilation *Driver::BuildCompilation(llvm::ArrayRef<const char *> ArgList) {
    205   llvm::PrettyStackTraceString CrashInfo("Compilation construction");
    206 
    207   // FIXME: Handle environment options which effect driver behavior, somewhere
    208   // (client?). GCC_EXEC_PREFIX, COMPILER_PATH, LIBRARY_PATH, LPATH,
    209   // CC_PRINT_OPTIONS.
    210 
    211   // FIXME: What are we going to do with -V and -b?
    212 
    213   // FIXME: This stuff needs to go into the Compilation, not the driver.
    214   bool CCCPrintOptions = false, CCCPrintActions = false;
    215 
    216   InputArgList *Args = ParseArgStrings(ArgList.slice(1));
    217 
    218   // -no-canonical-prefixes is used very early in main.
    219   Args->ClaimAllArgs(options::OPT_no_canonical_prefixes);
    220 
    221   // Ignore -pipe.
    222   Args->ClaimAllArgs(options::OPT_pipe);
    223 
    224   // Extract -ccc args.
    225   //
    226   // FIXME: We need to figure out where this behavior should live. Most of it
    227   // should be outside in the client; the parts that aren't should have proper
    228   // options, either by introducing new ones or by overloading gcc ones like -V
    229   // or -b.
    230   CCCPrintOptions = Args->hasArg(options::OPT_ccc_print_options);
    231   CCCPrintActions = Args->hasArg(options::OPT_ccc_print_phases);
    232   CCCPrintBindings = Args->hasArg(options::OPT_ccc_print_bindings);
    233   CCCIsCXX = Args->hasArg(options::OPT_ccc_cxx) || CCCIsCXX;
    234   CCCEcho = Args->hasArg(options::OPT_ccc_echo);
    235   if (const Arg *A = Args->getLastArg(options::OPT_ccc_gcc_name))
    236     CCCGenericGCCName = A->getValue(*Args);
    237   CCCUseClangCXX = Args->hasFlag(options::OPT_ccc_clang_cxx,
    238                                  options::OPT_ccc_no_clang_cxx,
    239                                  CCCUseClangCXX);
    240   CCCUsePCH = Args->hasFlag(options::OPT_ccc_pch_is_pch,
    241                             options::OPT_ccc_pch_is_pth);
    242   CCCUseClang = !Args->hasArg(options::OPT_ccc_no_clang);
    243   CCCUseClangCPP = !Args->hasArg(options::OPT_ccc_no_clang_cpp);
    244   if (const Arg *A = Args->getLastArg(options::OPT_ccc_clang_archs)) {
    245     llvm::StringRef Cur = A->getValue(*Args);
    246 
    247     CCCClangArchs.clear();
    248     while (!Cur.empty()) {
    249       std::pair<llvm::StringRef, llvm::StringRef> Split = Cur.split(',');
    250 
    251       if (!Split.first.empty()) {
    252         llvm::Triple::ArchType Arch =
    253           llvm::Triple(Split.first, "", "").getArch();
    254 
    255         if (Arch == llvm::Triple::UnknownArch)
    256           Diag(clang::diag::err_drv_invalid_arch_name) << Split.first;
    257 
    258         CCCClangArchs.insert(Arch);
    259       }
    260 
    261       Cur = Split.second;
    262     }
    263   }
    264   // FIXME: We shouldn't overwrite the default host triple here, but we have
    265   // nowhere else to put this currently.
    266   if (const Arg *A = Args->getLastArg(options::OPT_ccc_host_triple))
    267     DefaultHostTriple = A->getValue(*Args);
    268   if (const Arg *A = Args->getLastArg(options::OPT_ccc_install_dir))
    269     Dir = InstalledDir = A->getValue(*Args);
    270   for (arg_iterator it = Args->filtered_begin(options::OPT_B),
    271          ie = Args->filtered_end(); it != ie; ++it) {
    272     const Arg *A = *it;
    273     A->claim();
    274     PrefixDirs.push_back(A->getValue(*Args, 0));
    275   }
    276   if (const Arg *A = Args->getLastArg(options::OPT__sysroot_EQ))
    277     SysRoot = A->getValue(*Args);
    278   if (Args->hasArg(options::OPT_nostdlib))
    279     UseStdLib = false;
    280 
    281   Host = GetHostInfo(DefaultHostTriple.c_str());
    282 
    283   // Perform the default argument translations.
    284   DerivedArgList *TranslatedArgs = TranslateInputArgs(*Args);
    285 
    286   // The compilation takes ownership of Args.
    287   Compilation *C = new Compilation(*this, *Host->CreateToolChain(*Args), Args,
    288                                    TranslatedArgs);
    289 
    290   // FIXME: This behavior shouldn't be here.
    291   if (CCCPrintOptions) {
    292     PrintOptions(C->getInputArgs());
    293     return C;
    294   }
    295 
    296   if (!HandleImmediateArgs(*C))
    297     return C;
    298 
    299   // Construct the list of abstract actions to perform for this compilation.
    300   if (Host->useDriverDriver())
    301     BuildUniversalActions(C->getDefaultToolChain(), C->getArgs(),
    302                           C->getActions());
    303   else
    304     BuildActions(C->getDefaultToolChain(), C->getArgs(), C->getActions());
    305 
    306   if (CCCPrintActions) {
    307     PrintActions(*C);
    308     return C;
    309   }
    310 
    311   BuildJobs(*C);
    312 
    313   return C;
    314 }
    315 
    316 int Driver::ExecuteCompilation(const Compilation &C) const {
    317   // Just print if -### was present.
    318   if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
    319     C.PrintJob(llvm::errs(), C.getJobs(), "\n", true);
    320     return 0;
    321   }
    322 
    323   // If there were errors building the compilation, quit now.
    324   if (getDiags().hasErrorOccurred())
    325     return 1;
    326 
    327   const Command *FailingCommand = 0;
    328   int Res = C.ExecuteJob(C.getJobs(), FailingCommand);
    329 
    330   // Remove temp files.
    331   C.CleanupFileList(C.getTempFiles());
    332 
    333   // If the command succeeded, we are done.
    334   if (Res == 0)
    335     return Res;
    336 
    337   // Otherwise, remove result files as well.
    338   if (!C.getArgs().hasArg(options::OPT_save_temps))
    339     C.CleanupFileList(C.getResultFiles(), true);
    340 
    341   // Print extra information about abnormal failures, if possible.
    342   //
    343   // This is ad-hoc, but we don't want to be excessively noisy. If the result
    344   // status was 1, assume the command failed normally. In particular, if it was
    345   // the compiler then assume it gave a reasonable error code. Failures in other
    346   // tools are less common, and they generally have worse diagnostics, so always
    347   // print the diagnostic there.
    348   const Tool &FailingTool = FailingCommand->getCreator();
    349 
    350   if (!FailingCommand->getCreator().hasGoodDiagnostics() || Res != 1) {
    351     // FIXME: See FIXME above regarding result code interpretation.
    352     if (Res < 0)
    353       Diag(clang::diag::err_drv_command_signalled)
    354         << FailingTool.getShortName() << -Res;
    355     else
    356       Diag(clang::diag::err_drv_command_failed)
    357         << FailingTool.getShortName() << Res;
    358   }
    359 
    360   return Res;
    361 }
    362 
    363 void Driver::PrintOptions(const ArgList &Args) const {
    364   unsigned i = 0;
    365   for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
    366        it != ie; ++it, ++i) {
    367     Arg *A = *it;
    368     llvm::errs() << "Option " << i << " - "
    369                  << "Name: \"" << A->getOption().getName() << "\", "
    370                  << "Values: {";
    371     for (unsigned j = 0; j < A->getNumValues(); ++j) {
    372       if (j)
    373         llvm::errs() << ", ";
    374       llvm::errs() << '"' << A->getValue(Args, j) << '"';
    375     }
    376     llvm::errs() << "}\n";
    377   }
    378 }
    379 
    380 void Driver::PrintHelp(bool ShowHidden) const {
    381   getOpts().PrintHelp(llvm::outs(), Name.c_str(), DriverTitle.c_str(),
    382                       ShowHidden);
    383 }
    384 
    385 void Driver::PrintVersion(const Compilation &C, llvm::raw_ostream &OS) const {
    386   // FIXME: The following handlers should use a callback mechanism, we don't
    387   // know what the client would like to do.
    388   OS << getClangFullVersion() << '\n';
    389   const ToolChain &TC = C.getDefaultToolChain();
    390   OS << "Target: " << TC.getTripleString() << '\n';
    391 
    392   // Print the threading model.
    393   //
    394   // FIXME: Implement correctly.
    395   OS << "Thread model: " << "posix" << '\n';
    396 }
    397 
    398 /// PrintDiagnosticCategories - Implement the --print-diagnostic-categories
    399 /// option.
    400 static void PrintDiagnosticCategories(llvm::raw_ostream &OS) {
    401   // Skip the empty category.
    402   for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories();
    403        i != max; ++i)
    404     OS << i << ',' << DiagnosticIDs::getCategoryNameFromID(i) << '\n';
    405 }
    406 
    407 bool Driver::HandleImmediateArgs(const Compilation &C) {
    408   // The order these options are handled in gcc is all over the place, but we
    409   // don't expect inconsistencies w.r.t. that to matter in practice.
    410 
    411   if (C.getArgs().hasArg(options::OPT_dumpmachine)) {
    412     llvm::outs() << C.getDefaultToolChain().getTripleString() << '\n';
    413     return false;
    414   }
    415 
    416   if (C.getArgs().hasArg(options::OPT_dumpversion)) {
    417     // Since -dumpversion is only implemented for pedantic GCC compatibility, we
    418     // return an answer which matches our definition of __VERSION__.
    419     //
    420     // If we want to return a more correct answer some day, then we should
    421     // introduce a non-pedantically GCC compatible mode to Clang in which we
    422     // provide sensible definitions for -dumpversion, __VERSION__, etc.
    423     llvm::outs() << "4.2.1\n";
    424     return false;
    425   }
    426 
    427   if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
    428     PrintDiagnosticCategories(llvm::outs());
    429     return false;
    430   }
    431 
    432   if (C.getArgs().hasArg(options::OPT__help) ||
    433       C.getArgs().hasArg(options::OPT__help_hidden)) {
    434     PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden));
    435     return false;
    436   }
    437 
    438   if (C.getArgs().hasArg(options::OPT__version)) {
    439     // Follow gcc behavior and use stdout for --version and stderr for -v.
    440     PrintVersion(C, llvm::outs());
    441     return false;
    442   }
    443 
    444   if (C.getArgs().hasArg(options::OPT_v) ||
    445       C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
    446     PrintVersion(C, llvm::errs());
    447     SuppressMissingInputWarning = true;
    448   }
    449 
    450   const ToolChain &TC = C.getDefaultToolChain();
    451   if (C.getArgs().hasArg(options::OPT_print_search_dirs)) {
    452     llvm::outs() << "programs: =";
    453     for (ToolChain::path_list::const_iterator it = TC.getProgramPaths().begin(),
    454            ie = TC.getProgramPaths().end(); it != ie; ++it) {
    455       if (it != TC.getProgramPaths().begin())
    456         llvm::outs() << ':';
    457       llvm::outs() << *it;
    458     }
    459     llvm::outs() << "\n";
    460     llvm::outs() << "libraries: =";
    461 
    462     std::string sysroot;
    463     if (Arg *A = C.getArgs().getLastArg(options::OPT__sysroot_EQ))
    464       sysroot = A->getValue(C.getArgs());
    465 
    466     for (ToolChain::path_list::const_iterator it = TC.getFilePaths().begin(),
    467            ie = TC.getFilePaths().end(); it != ie; ++it) {
    468       if (it != TC.getFilePaths().begin())
    469         llvm::outs() << ':';
    470       const char *path = it->c_str();
    471       if (path[0] == '=')
    472         llvm::outs() << sysroot << path + 1;
    473       else
    474         llvm::outs() << path;
    475     }
    476     llvm::outs() << "\n";
    477     return false;
    478   }
    479 
    480   // FIXME: The following handlers should use a callback mechanism, we don't
    481   // know what the client would like to do.
    482   if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
    483     llvm::outs() << GetFilePath(A->getValue(C.getArgs()), TC) << "\n";
    484     return false;
    485   }
    486 
    487   if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
    488     llvm::outs() << GetProgramPath(A->getValue(C.getArgs()), TC) << "\n";
    489     return false;
    490   }
    491 
    492   if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
    493     llvm::outs() << GetFilePath("libgcc.a", TC) << "\n";
    494     return false;
    495   }
    496 
    497   if (C.getArgs().hasArg(options::OPT_print_multi_lib)) {
    498     // FIXME: We need tool chain support for this.
    499     llvm::outs() << ".;\n";
    500 
    501     switch (C.getDefaultToolChain().getTriple().getArch()) {
    502     default:
    503       break;
    504 
    505     case llvm::Triple::x86_64:
    506       llvm::outs() << "x86_64;@m64" << "\n";
    507       break;
    508 
    509     case llvm::Triple::ppc64:
    510       llvm::outs() << "ppc64;@m64" << "\n";
    511       break;
    512     }
    513     return false;
    514   }
    515 
    516   // FIXME: What is the difference between print-multi-directory and
    517   // print-multi-os-directory?
    518   if (C.getArgs().hasArg(options::OPT_print_multi_directory) ||
    519       C.getArgs().hasArg(options::OPT_print_multi_os_directory)) {
    520     switch (C.getDefaultToolChain().getTriple().getArch()) {
    521     default:
    522     case llvm::Triple::x86:
    523     case llvm::Triple::ppc:
    524       llvm::outs() << "." << "\n";
    525       break;
    526 
    527     case llvm::Triple::x86_64:
    528       llvm::outs() << "x86_64" << "\n";
    529       break;
    530 
    531     case llvm::Triple::ppc64:
    532       llvm::outs() << "ppc64" << "\n";
    533       break;
    534     }
    535     return false;
    536   }
    537 
    538   return true;
    539 }
    540 
    541 static unsigned PrintActions1(const Compilation &C, Action *A,
    542                               std::map<Action*, unsigned> &Ids) {
    543   if (Ids.count(A))
    544     return Ids[A];
    545 
    546   std::string str;
    547   llvm::raw_string_ostream os(str);
    548 
    549   os << Action::getClassName(A->getKind()) << ", ";
    550   if (InputAction *IA = dyn_cast<InputAction>(A)) {
    551     os << "\"" << IA->getInputArg().getValue(C.getArgs()) << "\"";
    552   } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) {
    553     os << '"' << (BIA->getArchName() ? BIA->getArchName() :
    554                   C.getDefaultToolChain().getArchName()) << '"'
    555        << ", {" << PrintActions1(C, *BIA->begin(), Ids) << "}";
    556   } else {
    557     os << "{";
    558     for (Action::iterator it = A->begin(), ie = A->end(); it != ie;) {
    559       os << PrintActions1(C, *it, Ids);
    560       ++it;
    561       if (it != ie)
    562         os << ", ";
    563     }
    564     os << "}";
    565   }
    566 
    567   unsigned Id = Ids.size();
    568   Ids[A] = Id;
    569   llvm::errs() << Id << ": " << os.str() << ", "
    570                << types::getTypeName(A->getType()) << "\n";
    571 
    572   return Id;
    573 }
    574 
    575 void Driver::PrintActions(const Compilation &C) const {
    576   std::map<Action*, unsigned> Ids;
    577   for (ActionList::const_iterator it = C.getActions().begin(),
    578          ie = C.getActions().end(); it != ie; ++it)
    579     PrintActions1(C, *it, Ids);
    580 }
    581 
    582 /// \brief Check whether the given input tree contains any compilation or
    583 /// assembly actions.
    584 static bool ContainsCompileOrAssembleAction(const Action *A) {
    585   if (isa<CompileJobAction>(A) || isa<AssembleJobAction>(A))
    586     return true;
    587 
    588   for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
    589     if (ContainsCompileOrAssembleAction(*it))
    590       return true;
    591 
    592   return false;
    593 }
    594 
    595 void Driver::BuildUniversalActions(const ToolChain &TC,
    596                                    const DerivedArgList &Args,
    597                                    ActionList &Actions) const {
    598   llvm::PrettyStackTraceString CrashInfo("Building universal build actions");
    599   // Collect the list of architectures. Duplicates are allowed, but should only
    600   // be handled once (in the order seen).
    601   llvm::StringSet<> ArchNames;
    602   llvm::SmallVector<const char *, 4> Archs;
    603   for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
    604        it != ie; ++it) {
    605     Arg *A = *it;
    606 
    607     if (A->getOption().matches(options::OPT_arch)) {
    608       // Validate the option here; we don't save the type here because its
    609       // particular spelling may participate in other driver choices.
    610       llvm::Triple::ArchType Arch =
    611         llvm::Triple::getArchTypeForDarwinArchName(A->getValue(Args));
    612       if (Arch == llvm::Triple::UnknownArch) {
    613         Diag(clang::diag::err_drv_invalid_arch_name)
    614           << A->getAsString(Args);
    615         continue;
    616       }
    617 
    618       A->claim();
    619       if (ArchNames.insert(A->getValue(Args)))
    620         Archs.push_back(A->getValue(Args));
    621     }
    622   }
    623 
    624   // When there is no explicit arch for this platform, make sure we still bind
    625   // the architecture (to the default) so that -Xarch_ is handled correctly.
    626   if (!Archs.size())
    627     Archs.push_back(0);
    628 
    629   // FIXME: We killed off some others but these aren't yet detected in a
    630   // functional manner. If we added information to jobs about which "auxiliary"
    631   // files they wrote then we could detect the conflict these cause downstream.
    632   if (Archs.size() > 1) {
    633     // No recovery needed, the point of this is just to prevent
    634     // overwriting the same files.
    635     if (const Arg *A = Args.getLastArg(options::OPT_save_temps))
    636       Diag(clang::diag::err_drv_invalid_opt_with_multiple_archs)
    637         << A->getAsString(Args);
    638   }
    639 
    640   ActionList SingleActions;
    641   BuildActions(TC, Args, SingleActions);
    642 
    643   // Add in arch bindings for every top level action, as well as lipo and
    644   // dsymutil steps if needed.
    645   for (unsigned i = 0, e = SingleActions.size(); i != e; ++i) {
    646     Action *Act = SingleActions[i];
    647 
    648     // Make sure we can lipo this kind of output. If not (and it is an actual
    649     // output) then we disallow, since we can't create an output file with the
    650     // right name without overwriting it. We could remove this oddity by just
    651     // changing the output names to include the arch, which would also fix
    652     // -save-temps. Compatibility wins for now.
    653 
    654     if (Archs.size() > 1 && !types::canLipoType(Act->getType()))
    655       Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
    656         << types::getTypeName(Act->getType());
    657 
    658     ActionList Inputs;
    659     for (unsigned i = 0, e = Archs.size(); i != e; ++i) {
    660       Inputs.push_back(new BindArchAction(Act, Archs[i]));
    661       if (i != 0)
    662         Inputs.back()->setOwnsInputs(false);
    663     }
    664 
    665     // Lipo if necessary, we do it this way because we need to set the arch flag
    666     // so that -Xarch_ gets overwritten.
    667     if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
    668       Actions.append(Inputs.begin(), Inputs.end());
    669     else
    670       Actions.push_back(new LipoJobAction(Inputs, Act->getType()));
    671 
    672     // Add a 'dsymutil' step if necessary, when debug info is enabled and we
    673     // have a compile input. We need to run 'dsymutil' ourselves in such cases
    674     // because the debug info will refer to a temporary object file which is
    675     // will be removed at the end of the compilation process.
    676     if (Act->getType() == types::TY_Image) {
    677       Arg *A = Args.getLastArg(options::OPT_g_Group);
    678       if (A && !A->getOption().matches(options::OPT_g0) &&
    679           !A->getOption().matches(options::OPT_gstabs) &&
    680           ContainsCompileOrAssembleAction(Actions.back())) {
    681         ActionList Inputs;
    682         Inputs.push_back(Actions.back());
    683         Actions.pop_back();
    684 
    685         Actions.push_back(new DsymutilJobAction(Inputs, types::TY_dSYM));
    686       }
    687     }
    688   }
    689 }
    690 
    691 void Driver::BuildActions(const ToolChain &TC, const DerivedArgList &Args,
    692                           ActionList &Actions) const {
    693   llvm::PrettyStackTraceString CrashInfo("Building compilation actions");
    694   // Start by constructing the list of inputs and their types.
    695 
    696   // Track the current user specified (-x) input. We also explicitly track the
    697   // argument used to set the type; we only want to claim the type when we
    698   // actually use it, so we warn about unused -x arguments.
    699   types::ID InputType = types::TY_Nothing;
    700   Arg *InputTypeArg = 0;
    701 
    702   llvm::SmallVector<std::pair<types::ID, const Arg*>, 16> Inputs;
    703   for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
    704        it != ie; ++it) {
    705     Arg *A = *it;
    706 
    707     if (isa<InputOption>(A->getOption())) {
    708       const char *Value = A->getValue(Args);
    709       types::ID Ty = types::TY_INVALID;
    710 
    711       // Infer the input type if necessary.
    712       if (InputType == types::TY_Nothing) {
    713         // If there was an explicit arg for this, claim it.
    714         if (InputTypeArg)
    715           InputTypeArg->claim();
    716 
    717         // stdin must be handled specially.
    718         if (memcmp(Value, "-", 2) == 0) {
    719           // If running with -E, treat as a C input (this changes the builtin
    720           // macros, for example). This may be overridden by -ObjC below.
    721           //
    722           // Otherwise emit an error but still use a valid type to avoid
    723           // spurious errors (e.g., no inputs).
    724           if (!Args.hasArgNoClaim(options::OPT_E) && !CCCIsCPP)
    725             Diag(clang::diag::err_drv_unknown_stdin_type);
    726           Ty = types::TY_C;
    727         } else {
    728           // Otherwise lookup by extension.
    729           // Fallback is C if invoked as C preprocessor or Object otherwise.
    730           // We use a host hook here because Darwin at least has its own
    731           // idea of what .s is.
    732           if (const char *Ext = strrchr(Value, '.'))
    733             Ty = TC.LookupTypeForExtension(Ext + 1);
    734 
    735           if (Ty == types::TY_INVALID) {
    736             if (CCCIsCPP)
    737               Ty = types::TY_C;
    738             else
    739               Ty = types::TY_Object;
    740           }
    741 
    742           // If the driver is invoked as C++ compiler (like clang++ or c++) it
    743           // should autodetect some input files as C++ for g++ compatibility.
    744           if (CCCIsCXX) {
    745             types::ID OldTy = Ty;
    746             Ty = types::lookupCXXTypeForCType(Ty);
    747 
    748             if (Ty != OldTy)
    749               Diag(clang::diag::warn_drv_treating_input_as_cxx)
    750                 << getTypeName(OldTy) << getTypeName(Ty);
    751           }
    752         }
    753 
    754         // -ObjC and -ObjC++ override the default language, but only for "source
    755         // files". We just treat everything that isn't a linker input as a
    756         // source file.
    757         //
    758         // FIXME: Clean this up if we move the phase sequence into the type.
    759         if (Ty != types::TY_Object) {
    760           if (Args.hasArg(options::OPT_ObjC))
    761             Ty = types::TY_ObjC;
    762           else if (Args.hasArg(options::OPT_ObjCXX))
    763             Ty = types::TY_ObjCXX;
    764         }
    765       } else {
    766         assert(InputTypeArg && "InputType set w/o InputTypeArg");
    767         InputTypeArg->claim();
    768         Ty = InputType;
    769       }
    770 
    771       // Check that the file exists, if enabled.
    772       if (CheckInputsExist && memcmp(Value, "-", 2) != 0) {
    773         llvm::SmallString<64> Path(Value);
    774         if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory))
    775           if (llvm::sys::path::is_absolute(Path.str())) {
    776             Path = WorkDir->getValue(Args);
    777             llvm::sys::path::append(Path, Value);
    778           }
    779 
    780         bool exists = false;
    781         if (/*error_code ec =*/llvm::sys::fs::exists(Value, exists) || !exists)
    782           Diag(clang::diag::err_drv_no_such_file) << Path.str();
    783         else
    784           Inputs.push_back(std::make_pair(Ty, A));
    785       } else
    786         Inputs.push_back(std::make_pair(Ty, A));
    787 
    788     } else if (A->getOption().isLinkerInput()) {
    789       // Just treat as object type, we could make a special type for this if
    790       // necessary.
    791       Inputs.push_back(std::make_pair(types::TY_Object, A));
    792 
    793     } else if (A->getOption().matches(options::OPT_x)) {
    794       InputTypeArg = A;
    795       InputType = types::lookupTypeForTypeSpecifier(A->getValue(Args));
    796 
    797       // Follow gcc behavior and treat as linker input for invalid -x
    798       // options. Its not clear why we shouldn't just revert to unknown; but
    799       // this isn't very important, we might as well be bug compatible.
    800       if (!InputType) {
    801         Diag(clang::diag::err_drv_unknown_language) << A->getValue(Args);
    802         InputType = types::TY_Object;
    803       }
    804     }
    805   }
    806 
    807   if (CCCIsCPP && Inputs.empty()) {
    808     // If called as standalone preprocessor, stdin is processed
    809     // if no other input is present.
    810     unsigned Index = Args.getBaseArgs().MakeIndex("-");
    811     Arg *A = Opts->ParseOneArg(Args, Index);
    812     A->claim();
    813     Inputs.push_back(std::make_pair(types::TY_C, A));
    814   }
    815 
    816   if (!SuppressMissingInputWarning && Inputs.empty()) {
    817     Diag(clang::diag::err_drv_no_input_files);
    818     return;
    819   }
    820 
    821   // Determine which compilation mode we are in. We look for options which
    822   // affect the phase, starting with the earliest phases, and record which
    823   // option we used to determine the final phase.
    824   Arg *FinalPhaseArg = 0;
    825   phases::ID FinalPhase;
    826 
    827   // -{E,M,MM} only run the preprocessor.
    828   if (CCCIsCPP ||
    829       (FinalPhaseArg = Args.getLastArg(options::OPT_E)) ||
    830       (FinalPhaseArg = Args.getLastArg(options::OPT_M, options::OPT_MM))) {
    831     FinalPhase = phases::Preprocess;
    832 
    833     // -{fsyntax-only,-analyze,emit-ast,S} only run up to the compiler.
    834   } else if ((FinalPhaseArg = Args.getLastArg(options::OPT_fsyntax_only)) ||
    835              (FinalPhaseArg = Args.getLastArg(options::OPT_rewrite_objc)) ||
    836              (FinalPhaseArg = Args.getLastArg(options::OPT__analyze,
    837                                               options::OPT__analyze_auto)) ||
    838              (FinalPhaseArg = Args.getLastArg(options::OPT_emit_ast)) ||
    839              (FinalPhaseArg = Args.getLastArg(options::OPT_S))) {
    840     FinalPhase = phases::Compile;
    841 
    842     // -c only runs up to the assembler.
    843   } else if ((FinalPhaseArg = Args.getLastArg(options::OPT_c))) {
    844     FinalPhase = phases::Assemble;
    845 
    846     // Otherwise do everything.
    847   } else
    848     FinalPhase = phases::Link;
    849 
    850   // Reject -Z* at the top level, these options should never have been exposed
    851   // by gcc.
    852   if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
    853     Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
    854 
    855   // Construct the actions to perform.
    856   ActionList LinkerInputs;
    857   for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
    858     types::ID InputType = Inputs[i].first;
    859     const Arg *InputArg = Inputs[i].second;
    860 
    861     unsigned NumSteps = types::getNumCompilationPhases(InputType);
    862     assert(NumSteps && "Invalid number of steps!");
    863 
    864     // If the first step comes after the final phase we are doing as part of
    865     // this compilation, warn the user about it.
    866     phases::ID InitialPhase = types::getCompilationPhase(InputType, 0);
    867     if (InitialPhase > FinalPhase) {
    868       // Claim here to avoid the more general unused warning.
    869       InputArg->claim();
    870 
    871       // Suppress all unused style warnings with -Qunused-arguments
    872       if (Args.hasArg(options::OPT_Qunused_arguments))
    873         continue;
    874 
    875       // Special case '-E' warning on a previously preprocessed file to make
    876       // more sense.
    877       if (InitialPhase == phases::Compile && FinalPhase == phases::Preprocess &&
    878           getPreprocessedType(InputType) == types::TY_INVALID)
    879         Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
    880           << InputArg->getAsString(Args)
    881           << FinalPhaseArg->getOption().getName();
    882       else
    883         Diag(clang::diag::warn_drv_input_file_unused)
    884           << InputArg->getAsString(Args)
    885           << getPhaseName(InitialPhase)
    886           << FinalPhaseArg->getOption().getName();
    887       continue;
    888     }
    889 
    890     // Build the pipeline for this file.
    891     llvm::OwningPtr<Action> Current(new InputAction(*InputArg, InputType));
    892     for (unsigned i = 0; i != NumSteps; ++i) {
    893       phases::ID Phase = types::getCompilationPhase(InputType, i);
    894 
    895       // We are done if this step is past what the user requested.
    896       if (Phase > FinalPhase)
    897         break;
    898 
    899       // Queue linker inputs.
    900       if (Phase == phases::Link) {
    901         assert(i + 1 == NumSteps && "linking must be final compilation step.");
    902         LinkerInputs.push_back(Current.take());
    903         break;
    904       }
    905 
    906       // Some types skip the assembler phase (e.g., llvm-bc), but we can't
    907       // encode this in the steps because the intermediate type depends on
    908       // arguments. Just special case here.
    909       if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm)
    910         continue;
    911 
    912       // Otherwise construct the appropriate action.
    913       Current.reset(ConstructPhaseAction(Args, Phase, Current.take()));
    914       if (Current->getType() == types::TY_Nothing)
    915         break;
    916     }
    917 
    918     // If we ended with something, add to the output list.
    919     if (Current)
    920       Actions.push_back(Current.take());
    921   }
    922 
    923   // Add a link action if necessary.
    924   if (!LinkerInputs.empty())
    925     Actions.push_back(new LinkJobAction(LinkerInputs, types::TY_Image));
    926 
    927   // If we are linking, claim any options which are obviously only used for
    928   // compilation.
    929   if (FinalPhase == phases::Link)
    930     Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
    931 }
    932 
    933 Action *Driver::ConstructPhaseAction(const ArgList &Args, phases::ID Phase,
    934                                      Action *Input) const {
    935   llvm::PrettyStackTraceString CrashInfo("Constructing phase actions");
    936   // Build the appropriate action.
    937   switch (Phase) {
    938   case phases::Link: assert(0 && "link action invalid here.");
    939   case phases::Preprocess: {
    940     types::ID OutputTy;
    941     // -{M, MM} alter the output type.
    942     if (Args.hasArg(options::OPT_M, options::OPT_MM)) {
    943       OutputTy = types::TY_Dependencies;
    944     } else {
    945       OutputTy = types::getPreprocessedType(Input->getType());
    946       assert(OutputTy != types::TY_INVALID &&
    947              "Cannot preprocess this input type!");
    948     }
    949     return new PreprocessJobAction(Input, OutputTy);
    950   }
    951   case phases::Precompile:
    952     return new PrecompileJobAction(Input, types::TY_PCH);
    953   case phases::Compile: {
    954     if (Args.hasArg(options::OPT_fsyntax_only)) {
    955       return new CompileJobAction(Input, types::TY_Nothing);
    956     } else if (Args.hasArg(options::OPT_rewrite_objc)) {
    957       return new CompileJobAction(Input, types::TY_RewrittenObjC);
    958     } else if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto)) {
    959       return new AnalyzeJobAction(Input, types::TY_Plist);
    960     } else if (Args.hasArg(options::OPT_emit_ast)) {
    961       return new CompileJobAction(Input, types::TY_AST);
    962     } else if (IsUsingLTO(Args)) {
    963       types::ID Output =
    964         Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
    965       return new CompileJobAction(Input, Output);
    966     } else {
    967       return new CompileJobAction(Input, types::TY_PP_Asm);
    968     }
    969   }
    970   case phases::Assemble:
    971     return new AssembleJobAction(Input, types::TY_Object);
    972   }
    973 
    974   assert(0 && "invalid phase in ConstructPhaseAction");
    975   return 0;
    976 }
    977 
    978 bool Driver::IsUsingLTO(const ArgList &Args) const {
    979   // Check for -emit-llvm or -flto.
    980   if (Args.hasArg(options::OPT_emit_llvm) ||
    981       Args.hasFlag(options::OPT_flto, options::OPT_fno_lto, false))
    982     return true;
    983 
    984   // Check for -O4.
    985   if (const Arg *A = Args.getLastArg(options::OPT_O_Group))
    986       return A->getOption().matches(options::OPT_O4);
    987 
    988   return false;
    989 }
    990 
    991 void Driver::BuildJobs(Compilation &C) const {
    992   llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
    993 
    994   Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
    995 
    996   // It is an error to provide a -o option if we are making multiple output
    997   // files.
    998   if (FinalOutput) {
    999     unsigned NumOutputs = 0;
   1000     for (ActionList::const_iterator it = C.getActions().begin(),
   1001            ie = C.getActions().end(); it != ie; ++it)
   1002       if ((*it)->getType() != types::TY_Nothing)
   1003         ++NumOutputs;
   1004 
   1005     if (NumOutputs > 1) {
   1006       Diag(clang::diag::err_drv_output_argument_with_multiple_files);
   1007       FinalOutput = 0;
   1008     }
   1009   }
   1010 
   1011   for (ActionList::const_iterator it = C.getActions().begin(),
   1012          ie = C.getActions().end(); it != ie; ++it) {
   1013     Action *A = *it;
   1014 
   1015     // If we are linking an image for multiple archs then the linker wants
   1016     // -arch_multiple and -final_output <final image name>. Unfortunately, this
   1017     // doesn't fit in cleanly because we have to pass this information down.
   1018     //
   1019     // FIXME: This is a hack; find a cleaner way to integrate this into the
   1020     // process.
   1021     const char *LinkingOutput = 0;
   1022     if (isa<LipoJobAction>(A)) {
   1023       if (FinalOutput)
   1024         LinkingOutput = FinalOutput->getValue(C.getArgs());
   1025       else
   1026         LinkingOutput = DefaultImageName.c_str();
   1027     }
   1028 
   1029     InputInfo II;
   1030     BuildJobsForAction(C, A, &C.getDefaultToolChain(),
   1031                        /*BoundArch*/0,
   1032                        /*AtTopLevel*/ true,
   1033                        /*LinkingOutput*/ LinkingOutput,
   1034                        II);
   1035   }
   1036 
   1037   // If the user passed -Qunused-arguments or there were errors, don't warn
   1038   // about any unused arguments.
   1039   if (Diags.hasErrorOccurred() ||
   1040       C.getArgs().hasArg(options::OPT_Qunused_arguments))
   1041     return;
   1042 
   1043   // Claim -### here.
   1044   (void) C.getArgs().hasArg(options::OPT__HASH_HASH_HASH);
   1045 
   1046   for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end();
   1047        it != ie; ++it) {
   1048     Arg *A = *it;
   1049 
   1050     // FIXME: It would be nice to be able to send the argument to the
   1051     // Diagnostic, so that extra values, position, and so on could be printed.
   1052     if (!A->isClaimed()) {
   1053       if (A->getOption().hasNoArgumentUnused())
   1054         continue;
   1055 
   1056       // Suppress the warning automatically if this is just a flag, and it is an
   1057       // instance of an argument we already claimed.
   1058       const Option &Opt = A->getOption();
   1059       if (isa<FlagOption>(Opt)) {
   1060         bool DuplicateClaimed = false;
   1061 
   1062         for (arg_iterator it = C.getArgs().filtered_begin(&Opt),
   1063                ie = C.getArgs().filtered_end(); it != ie; ++it) {
   1064           if ((*it)->isClaimed()) {
   1065             DuplicateClaimed = true;
   1066             break;
   1067           }
   1068         }
   1069 
   1070         if (DuplicateClaimed)
   1071           continue;
   1072       }
   1073 
   1074       Diag(clang::diag::warn_drv_unused_argument)
   1075         << A->getAsString(C.getArgs());
   1076     }
   1077   }
   1078 }
   1079 
   1080 static const Tool &SelectToolForJob(Compilation &C, const ToolChain *TC,
   1081                                     const JobAction *JA,
   1082                                     const ActionList *&Inputs) {
   1083   const Tool *ToolForJob = 0;
   1084 
   1085   // See if we should look for a compiler with an integrated assembler. We match
   1086   // bottom up, so what we are actually looking for is an assembler job with a
   1087   // compiler input.
   1088 
   1089   // FIXME: This doesn't belong here, but ideally we will support static soon
   1090   // anyway.
   1091   bool HasStatic = (C.getArgs().hasArg(options::OPT_mkernel) ||
   1092                     C.getArgs().hasArg(options::OPT_static) ||
   1093                     C.getArgs().hasArg(options::OPT_fapple_kext));
   1094   bool IsDarwin = TC->getTriple().getOS() == llvm::Triple::Darwin;
   1095   bool IsIADefault = TC->IsIntegratedAssemblerDefault() &&
   1096     !(HasStatic && IsDarwin);
   1097   if (C.getArgs().hasFlag(options::OPT_integrated_as,
   1098                          options::OPT_no_integrated_as,
   1099                          IsIADefault) &&
   1100       !C.getArgs().hasArg(options::OPT_save_temps) &&
   1101       isa<AssembleJobAction>(JA) &&
   1102       Inputs->size() == 1 && isa<CompileJobAction>(*Inputs->begin())) {
   1103     const Tool &Compiler = TC->SelectTool(
   1104       C, cast<JobAction>(**Inputs->begin()), (*Inputs)[0]->getInputs());
   1105     if (Compiler.hasIntegratedAssembler()) {
   1106       Inputs = &(*Inputs)[0]->getInputs();
   1107       ToolForJob = &Compiler;
   1108     }
   1109   }
   1110 
   1111   // Otherwise use the tool for the current job.
   1112   if (!ToolForJob)
   1113     ToolForJob = &TC->SelectTool(C, *JA, *Inputs);
   1114 
   1115   // See if we should use an integrated preprocessor. We do so when we have
   1116   // exactly one input, since this is the only use case we care about
   1117   // (irrelevant since we don't support combine yet).
   1118   if (Inputs->size() == 1 && isa<PreprocessJobAction>(*Inputs->begin()) &&
   1119       !C.getArgs().hasArg(options::OPT_no_integrated_cpp) &&
   1120       !C.getArgs().hasArg(options::OPT_traditional_cpp) &&
   1121       !C.getArgs().hasArg(options::OPT_save_temps) &&
   1122       ToolForJob->hasIntegratedCPP())
   1123     Inputs = &(*Inputs)[0]->getInputs();
   1124 
   1125   return *ToolForJob;
   1126 }
   1127 
   1128 void Driver::BuildJobsForAction(Compilation &C,
   1129                                 const Action *A,
   1130                                 const ToolChain *TC,
   1131                                 const char *BoundArch,
   1132                                 bool AtTopLevel,
   1133                                 const char *LinkingOutput,
   1134                                 InputInfo &Result) const {
   1135   llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
   1136 
   1137   if (const InputAction *IA = dyn_cast<InputAction>(A)) {
   1138     // FIXME: It would be nice to not claim this here; maybe the old scheme of
   1139     // just using Args was better?
   1140     const Arg &Input = IA->getInputArg();
   1141     Input.claim();
   1142     if (Input.getOption().matches(options::OPT_INPUT)) {
   1143       const char *Name = Input.getValue(C.getArgs());
   1144       Result = InputInfo(Name, A->getType(), Name);
   1145     } else
   1146       Result = InputInfo(&Input, A->getType(), "");
   1147     return;
   1148   }
   1149 
   1150   if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) {
   1151     const ToolChain *TC = &C.getDefaultToolChain();
   1152 
   1153     std::string Arch;
   1154     if (BAA->getArchName())
   1155       TC = Host->CreateToolChain(C.getArgs(), BAA->getArchName());
   1156 
   1157     BuildJobsForAction(C, *BAA->begin(), TC, BAA->getArchName(),
   1158                        AtTopLevel, LinkingOutput, Result);
   1159     return;
   1160   }
   1161 
   1162   const ActionList *Inputs = &A->getInputs();
   1163 
   1164   const JobAction *JA = cast<JobAction>(A);
   1165   const Tool &T = SelectToolForJob(C, TC, JA, Inputs);
   1166 
   1167   // Only use pipes when there is exactly one input.
   1168   InputInfoList InputInfos;
   1169   for (ActionList::const_iterator it = Inputs->begin(), ie = Inputs->end();
   1170        it != ie; ++it) {
   1171     // Treat dsymutil sub-jobs as being at the top-level too, they shouldn't get
   1172     // temporary output names.
   1173     //
   1174     // FIXME: Clean this up.
   1175     bool SubJobAtTopLevel = false;
   1176     if (AtTopLevel && isa<DsymutilJobAction>(A))
   1177       SubJobAtTopLevel = true;
   1178 
   1179     InputInfo II;
   1180     BuildJobsForAction(C, *it, TC, BoundArch,
   1181                        SubJobAtTopLevel, LinkingOutput, II);
   1182     InputInfos.push_back(II);
   1183   }
   1184 
   1185   // Always use the first input as the base input.
   1186   const char *BaseInput = InputInfos[0].getBaseInput();
   1187 
   1188   // ... except dsymutil actions, which use their actual input as the base
   1189   // input.
   1190   if (JA->getType() == types::TY_dSYM)
   1191     BaseInput = InputInfos[0].getFilename();
   1192 
   1193   // Determine the place to write output to, if any.
   1194   if (JA->getType() == types::TY_Nothing) {
   1195     Result = InputInfo(A->getType(), BaseInput);
   1196   } else {
   1197     Result = InputInfo(GetNamedOutputPath(C, *JA, BaseInput, AtTopLevel),
   1198                        A->getType(), BaseInput);
   1199   }
   1200 
   1201   if (CCCPrintBindings) {
   1202     llvm::errs() << "# \"" << T.getToolChain().getTripleString() << '"'
   1203                  << " - \"" << T.getName() << "\", inputs: [";
   1204     for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
   1205       llvm::errs() << InputInfos[i].getAsString();
   1206       if (i + 1 != e)
   1207         llvm::errs() << ", ";
   1208     }
   1209     llvm::errs() << "], output: " << Result.getAsString() << "\n";
   1210   } else {
   1211     T.ConstructJob(C, *JA, Result, InputInfos,
   1212                    C.getArgsForToolChain(TC, BoundArch), LinkingOutput);
   1213   }
   1214 }
   1215 
   1216 const char *Driver::GetNamedOutputPath(Compilation &C,
   1217                                        const JobAction &JA,
   1218                                        const char *BaseInput,
   1219                                        bool AtTopLevel) const {
   1220   llvm::PrettyStackTraceString CrashInfo("Computing output path");
   1221   // Output to a user requested destination?
   1222   if (AtTopLevel && !isa<DsymutilJobAction>(JA)) {
   1223     if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
   1224       return C.addResultFile(FinalOutput->getValue(C.getArgs()));
   1225   }
   1226 
   1227   // Default to writing to stdout?
   1228   if (AtTopLevel && isa<PreprocessJobAction>(JA))
   1229     return "-";
   1230 
   1231   // Output to a temporary file?
   1232   if (!AtTopLevel && !C.getArgs().hasArg(options::OPT_save_temps)) {
   1233     std::string TmpName =
   1234       GetTemporaryPath(types::getTypeTempSuffix(JA.getType()));
   1235     return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
   1236   }
   1237 
   1238   llvm::SmallString<128> BasePath(BaseInput);
   1239   llvm::StringRef BaseName;
   1240 
   1241   // Dsymutil actions should use the full path.
   1242   if (isa<DsymutilJobAction>(JA))
   1243     BaseName = BasePath;
   1244   else
   1245     BaseName = llvm::sys::path::filename(BasePath);
   1246 
   1247   // Determine what the derived output name should be.
   1248   const char *NamedOutput;
   1249   if (JA.getType() == types::TY_Image) {
   1250     NamedOutput = DefaultImageName.c_str();
   1251   } else {
   1252     const char *Suffix = types::getTypeTempSuffix(JA.getType());
   1253     assert(Suffix && "All types used for output should have a suffix.");
   1254 
   1255     std::string::size_type End = std::string::npos;
   1256     if (!types::appendSuffixForType(JA.getType()))
   1257       End = BaseName.rfind('.');
   1258     std::string Suffixed(BaseName.substr(0, End));
   1259     Suffixed += '.';
   1260     Suffixed += Suffix;
   1261     NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str());
   1262   }
   1263 
   1264   // If we're saving temps and the temp filename conflicts with the input
   1265   // filename, then avoid overwriting input file.
   1266   if (!AtTopLevel && C.getArgs().hasArg(options::OPT_save_temps) &&
   1267     NamedOutput == BaseName) {
   1268     std::string TmpName =
   1269       GetTemporaryPath(types::getTypeTempSuffix(JA.getType()));
   1270     return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
   1271   }
   1272 
   1273   // As an annoying special case, PCH generation doesn't strip the pathname.
   1274   if (JA.getType() == types::TY_PCH) {
   1275     llvm::sys::path::remove_filename(BasePath);
   1276     if (BasePath.empty())
   1277       BasePath = NamedOutput;
   1278     else
   1279       llvm::sys::path::append(BasePath, NamedOutput);
   1280     return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str()));
   1281   } else {
   1282     return C.addResultFile(NamedOutput);
   1283   }
   1284 }
   1285 
   1286 std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const {
   1287   // Respect a limited subset of the '-Bprefix' functionality in GCC by
   1288   // attempting to use this prefix when lokup up program paths.
   1289   for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(),
   1290        ie = PrefixDirs.end(); it != ie; ++it) {
   1291     std::string Dir(*it);
   1292     if (Dir.empty())
   1293       continue;
   1294     if (Dir[0] == '=')
   1295       Dir = SysRoot + Dir.substr(1);
   1296     llvm::sys::Path P(Dir);
   1297     P.appendComponent(Name);
   1298     bool Exists;
   1299     if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
   1300       return P.str();
   1301   }
   1302 
   1303   const ToolChain::path_list &List = TC.getFilePaths();
   1304   for (ToolChain::path_list::const_iterator
   1305          it = List.begin(), ie = List.end(); it != ie; ++it) {
   1306     std::string Dir(*it);
   1307     if (Dir.empty())
   1308       continue;
   1309     if (Dir[0] == '=')
   1310       Dir = SysRoot + Dir.substr(1);
   1311     llvm::sys::Path P(Dir);
   1312     P.appendComponent(Name);
   1313     bool Exists;
   1314     if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
   1315       return P.str();
   1316   }
   1317 
   1318   return Name;
   1319 }
   1320 
   1321 std::string Driver::GetProgramPath(const char *Name, const ToolChain &TC,
   1322                                    bool WantFile) const {
   1323   // Respect a limited subset of the '-Bprefix' functionality in GCC by
   1324   // attempting to use this prefix when lokup up program paths.
   1325   for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(),
   1326        ie = PrefixDirs.end(); it != ie; ++it) {
   1327     llvm::sys::Path P(*it);
   1328     P.appendComponent(Name);
   1329     bool Exists;
   1330     if (WantFile ? !llvm::sys::fs::exists(P.str(), Exists) && Exists
   1331                  : P.canExecute())
   1332       return P.str();
   1333   }
   1334 
   1335   const ToolChain::path_list &List = TC.getProgramPaths();
   1336   for (ToolChain::path_list::const_iterator
   1337          it = List.begin(), ie = List.end(); it != ie; ++it) {
   1338     llvm::sys::Path P(*it);
   1339     P.appendComponent(Name);
   1340     bool Exists;
   1341     if (WantFile ? !llvm::sys::fs::exists(P.str(), Exists) && Exists
   1342                  : P.canExecute())
   1343       return P.str();
   1344   }
   1345 
   1346   // If all else failed, search the path.
   1347   llvm::sys::Path P(llvm::sys::Program::FindProgramByName(Name));
   1348   if (!P.empty())
   1349     return P.str();
   1350 
   1351   return Name;
   1352 }
   1353 
   1354 std::string Driver::GetTemporaryPath(const char *Suffix) const {
   1355   // FIXME: This is lame; sys::Path should provide this function (in particular,
   1356   // it should know how to find the temporary files dir).
   1357   std::string Error;
   1358   const char *TmpDir = ::getenv("TMPDIR");
   1359   if (!TmpDir)
   1360     TmpDir = ::getenv("TEMP");
   1361   if (!TmpDir)
   1362     TmpDir = ::getenv("TMP");
   1363   if (!TmpDir)
   1364     TmpDir = "/tmp";
   1365   llvm::sys::Path P(TmpDir);
   1366   P.appendComponent("cc");
   1367   if (P.makeUnique(false, &Error)) {
   1368     Diag(clang::diag::err_drv_unable_to_make_temp) << Error;
   1369     return "";
   1370   }
   1371 
   1372   // FIXME: Grumble, makeUnique sometimes leaves the file around!?  PR3837.
   1373   P.eraseFromDisk(false, 0);
   1374 
   1375   P.appendSuffix(Suffix);
   1376   return P.str();
   1377 }
   1378 
   1379 const HostInfo *Driver::GetHostInfo(const char *TripleStr) const {
   1380   llvm::PrettyStackTraceString CrashInfo("Constructing host");
   1381   llvm::Triple Triple(llvm::Triple::normalize(TripleStr).c_str());
   1382 
   1383   // TCE is an osless target
   1384   if (Triple.getArchName() == "tce")
   1385     return createTCEHostInfo(*this, Triple);
   1386 
   1387   switch (Triple.getOS()) {
   1388   case llvm::Triple::AuroraUX:
   1389     return createAuroraUXHostInfo(*this, Triple);
   1390   case llvm::Triple::Darwin:
   1391     return createDarwinHostInfo(*this, Triple);
   1392   case llvm::Triple::DragonFly:
   1393     return createDragonFlyHostInfo(*this, Triple);
   1394   case llvm::Triple::OpenBSD:
   1395     return createOpenBSDHostInfo(*this, Triple);
   1396   case llvm::Triple::NetBSD:
   1397     return createNetBSDHostInfo(*this, Triple);
   1398   case llvm::Triple::FreeBSD:
   1399     return createFreeBSDHostInfo(*this, Triple);
   1400   case llvm::Triple::Minix:
   1401     return createMinixHostInfo(*this, Triple);
   1402   case llvm::Triple::Linux:
   1403     return createLinuxHostInfo(*this, Triple);
   1404   case llvm::Triple::Win32:
   1405     return createWindowsHostInfo(*this, Triple);
   1406   case llvm::Triple::MinGW32:
   1407     return createMinGWHostInfo(*this, Triple);
   1408   default:
   1409     return createUnknownHostInfo(*this, Triple);
   1410   }
   1411 }
   1412 
   1413 bool Driver::ShouldUseClangCompiler(const Compilation &C, const JobAction &JA,
   1414                                     const llvm::Triple &Triple) const {
   1415   // Check if user requested no clang, or clang doesn't understand this type (we
   1416   // only handle single inputs for now).
   1417   if (!CCCUseClang || JA.size() != 1 ||
   1418       !types::isAcceptedByClang((*JA.begin())->getType()))
   1419     return false;
   1420 
   1421   // Otherwise make sure this is an action clang understands.
   1422   if (isa<PreprocessJobAction>(JA)) {
   1423     if (!CCCUseClangCPP) {
   1424       Diag(clang::diag::warn_drv_not_using_clang_cpp);
   1425       return false;
   1426     }
   1427   } else if (!isa<PrecompileJobAction>(JA) && !isa<CompileJobAction>(JA))
   1428     return false;
   1429 
   1430   // Use clang for C++?
   1431   if (!CCCUseClangCXX && types::isCXX((*JA.begin())->getType())) {
   1432     Diag(clang::diag::warn_drv_not_using_clang_cxx);
   1433     return false;
   1434   }
   1435 
   1436   // Always use clang for precompiling, AST generation, and rewriting,
   1437   // regardless of archs.
   1438   if (isa<PrecompileJobAction>(JA) ||
   1439       types::isOnlyAcceptedByClang(JA.getType()))
   1440     return true;
   1441 
   1442   // Finally, don't use clang if this isn't one of the user specified archs to
   1443   // build.
   1444   if (!CCCClangArchs.empty() && !CCCClangArchs.count(Triple.getArch())) {
   1445     Diag(clang::diag::warn_drv_not_using_clang_arch) << Triple.getArchName();
   1446     return false;
   1447   }
   1448 
   1449   return true;
   1450 }
   1451 
   1452 /// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the
   1453 /// grouped values as integers. Numbers which are not provided are set to 0.
   1454 ///
   1455 /// \return True if the entire string was parsed (9.2), or all groups were
   1456 /// parsed (10.3.5extrastuff).
   1457 bool Driver::GetReleaseVersion(const char *Str, unsigned &Major,
   1458                                unsigned &Minor, unsigned &Micro,
   1459                                bool &HadExtra) {
   1460   HadExtra = false;
   1461 
   1462   Major = Minor = Micro = 0;
   1463   if (*Str == '\0')
   1464     return true;
   1465 
   1466   char *End;
   1467   Major = (unsigned) strtol(Str, &End, 10);
   1468   if (*Str != '\0' && *End == '\0')
   1469     return true;
   1470   if (*End != '.')
   1471     return false;
   1472 
   1473   Str = End+1;
   1474   Minor = (unsigned) strtol(Str, &End, 10);
   1475   if (*Str != '\0' && *End == '\0')
   1476     return true;
   1477   if (*End != '.')
   1478     return false;
   1479 
   1480   Str = End+1;
   1481   Micro = (unsigned) strtol(Str, &End, 10);
   1482   if (*Str != '\0' && *End == '\0')
   1483     return true;
   1484   if (Str == End)
   1485     return false;
   1486   HadExtra = true;
   1487   return true;
   1488 }
   1489