lib/Driver/Driver.cpp

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