1218893Sdim//===--- Driver.cpp - Clang GCC Compatible Driver -------------------------===// 2193326Sed// 3193326Sed// The LLVM Compiler Infrastructure 4193326Sed// 5193326Sed// This file is distributed under the University of Illinois Open Source 6193326Sed// License. See LICENSE.TXT for details. 7193326Sed// 8193326Sed//===----------------------------------------------------------------------===// 9193326Sed 10193326Sed#include "clang/Driver/Driver.h" 11249423Sdim#include "InputInfo.h" 12249423Sdim#include "ToolChains.h" 13249423Sdim#include "clang/Basic/Version.h" 14193326Sed#include "clang/Driver/Action.h" 15193326Sed#include "clang/Driver/Compilation.h" 16193326Sed#include "clang/Driver/DriverDiagnostic.h" 17193326Sed#include "clang/Driver/Job.h" 18193326Sed#include "clang/Driver/Options.h" 19193326Sed#include "clang/Driver/Tool.h" 20193326Sed#include "clang/Driver/ToolChain.h" 21221345Sdim#include "llvm/ADT/ArrayRef.h" 22249423Sdim#include "llvm/ADT/OwningPtr.h" 23263508Sdim#include "llvm/ADT/STLExtras.h" 24193326Sed#include "llvm/ADT/StringSet.h" 25263508Sdim#include "llvm/ADT/StringSwitch.h" 26263508Sdim#include "llvm/Option/Arg.h" 27263508Sdim#include "llvm/Option/ArgList.h" 28263508Sdim#include "llvm/Option/OptTable.h" 29263508Sdim#include "llvm/Option/Option.h" 30263508Sdim#include "llvm/Option/OptSpecifier.h" 31249423Sdim#include "llvm/Support/Debug.h" 32226633Sdim#include "llvm/Support/ErrorHandling.h" 33218893Sdim#include "llvm/Support/FileSystem.h" 34218893Sdim#include "llvm/Support/Path.h" 35249423Sdim#include "llvm/Support/PrettyStackTrace.h" 36218893Sdim#include "llvm/Support/Program.h" 37249423Sdim#include "llvm/Support/raw_ostream.h" 38193326Sed#include <map> 39193326Sed 40249423Sdim// FIXME: It would prevent us from including llvm-config.h 41249423Sdim// if config.h were included before system_error.h. 42234353Sdim#include "clang/Config/config.h" 43234353Sdim 44193326Sedusing namespace clang::driver; 45193326Sedusing namespace clang; 46263508Sdimusing namespace llvm::opt; 47193326Sed 48226633SdimDriver::Driver(StringRef ClangExecutable, 49234353Sdim StringRef DefaultTargetTriple, 50226633Sdim StringRef DefaultImageName, 51226633Sdim DiagnosticsEngine &Diags) 52263508Sdim : Opts(createDriverOptTable()), Diags(Diags), Mode(GCCMode), 53234982Sdim ClangExecutable(ClangExecutable), SysRoot(DEFAULT_SYSROOT), 54234982Sdim UseStdLib(true), DefaultTargetTriple(DefaultTargetTriple), 55234353Sdim DefaultImageName(DefaultImageName), 56243830Sdim DriverTitle("clang LLVM compiler"), 57221345Sdim CCPrintOptionsFilename(0), CCPrintHeadersFilename(0), 58263508Sdim CCLogDiagnosticsFilename(0), 59263508Sdim CCCPrintBindings(false), 60263508Sdim CCPrintHeaders(false), CCLogDiagnostics(false), 61226633Sdim CCGenDiagnostics(false), CCCGenericGCCName(""), CheckInputsExist(true), 62243830Sdim CCCUsePCH(true), SuppressMissingInputWarning(false) { 63202879Srdivacky 64218893Sdim Name = llvm::sys::path::stem(ClangExecutable); 65218893Sdim Dir = llvm::sys::path::parent_path(ClangExecutable); 66212904Sdim 67202879Srdivacky // Compute the path to the resource directory. 68226633Sdim StringRef ClangResourceDir(CLANG_RESOURCE_DIR); 69234353Sdim SmallString<128> P(Dir); 70218893Sdim if (ClangResourceDir != "") 71218893Sdim llvm::sys::path::append(P, ClangResourceDir); 72218893Sdim else 73218893Sdim llvm::sys::path::append(P, "..", "lib", "clang", CLANG_VERSION_STRING); 74202879Srdivacky ResourceDir = P.str(); 75193326Sed} 76193326Sed 77193326SedDriver::~Driver() { 78193326Sed delete Opts; 79234353Sdim 80234353Sdim for (llvm::StringMap<ToolChain *>::iterator I = ToolChains.begin(), 81234353Sdim E = ToolChains.end(); 82234353Sdim I != E; ++I) 83234353Sdim delete I->second; 84193326Sed} 85193326Sed 86263508Sdimvoid Driver::ParseDriverMode(ArrayRef<const char *> Args) { 87263508Sdim const std::string OptName = 88263508Sdim getOpts().getOption(options::OPT_driver_mode).getPrefixedName(); 89263508Sdim 90263508Sdim for (size_t I = 0, E = Args.size(); I != E; ++I) { 91263508Sdim const StringRef Arg = Args[I]; 92263508Sdim if (!Arg.startswith(OptName)) 93263508Sdim continue; 94263508Sdim 95263508Sdim const StringRef Value = Arg.drop_front(OptName.size()); 96263508Sdim const unsigned M = llvm::StringSwitch<unsigned>(Value) 97263508Sdim .Case("gcc", GCCMode) 98263508Sdim .Case("g++", GXXMode) 99263508Sdim .Case("cpp", CPPMode) 100263508Sdim .Case("cl", CLMode) 101263508Sdim .Default(~0U); 102263508Sdim 103263508Sdim if (M != ~0U) 104263508Sdim Mode = static_cast<DriverMode>(M); 105263508Sdim else 106263508Sdim Diag(diag::err_drv_unsupported_option_argument) << OptName << Value; 107263508Sdim } 108263508Sdim} 109263508Sdim 110226633SdimInputArgList *Driver::ParseArgStrings(ArrayRef<const char *> ArgList) { 111193326Sed llvm::PrettyStackTraceString CrashInfo("Command line argument parsing"); 112263508Sdim 113263508Sdim unsigned IncludedFlagsBitmask; 114263508Sdim unsigned ExcludedFlagsBitmask; 115263508Sdim llvm::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) = 116263508Sdim getIncludeExcludeOptionFlagMasks(); 117263508Sdim 118199512Srdivacky unsigned MissingArgIndex, MissingArgCount; 119221345Sdim InputArgList *Args = getOpts().ParseArgs(ArgList.begin(), ArgList.end(), 120263508Sdim MissingArgIndex, MissingArgCount, 121263508Sdim IncludedFlagsBitmask, 122263508Sdim ExcludedFlagsBitmask); 123198092Srdivacky 124199512Srdivacky // Check for missing argument error. 125199512Srdivacky if (MissingArgCount) 126199512Srdivacky Diag(clang::diag::err_drv_missing_argument) 127199512Srdivacky << Args->getArgString(MissingArgIndex) << MissingArgCount; 128193326Sed 129199512Srdivacky // Check for unsupported options. 130199512Srdivacky for (ArgList::const_iterator it = Args->begin(), ie = Args->end(); 131199512Srdivacky it != ie; ++it) { 132199512Srdivacky Arg *A = *it; 133243830Sdim if (A->getOption().hasFlag(options::Unsupported)) { 134193326Sed Diag(clang::diag::err_drv_unsupported_opt) << A->getAsString(*Args); 135193326Sed continue; 136193326Sed } 137234353Sdim 138234353Sdim // Warn about -mcpu= without an argument. 139239462Sdim if (A->getOption().matches(options::OPT_mcpu_EQ) && 140234353Sdim A->containsValue("")) { 141239462Sdim Diag(clang::diag::warn_drv_empty_joined_argument) << 142239462Sdim A->getAsString(*Args); 143234353Sdim } 144193326Sed } 145193326Sed 146263508Sdim for (arg_iterator it = Args->filtered_begin(options::OPT_UNKNOWN), 147263508Sdim ie = Args->filtered_end(); it != ie; ++it) { 148263508Sdim Diags.Report(diag::err_drv_unknown_argument) << (*it) ->getAsString(*Args); 149263508Sdim } 150263508Sdim 151193326Sed return Args; 152193326Sed} 153193326Sed 154226633Sdim// Determine which compilation mode we are in. We look for options which 155226633Sdim// affect the phase, starting with the earliest phases, and record which 156226633Sdim// option we used to determine the final phase. 157226633Sdimphases::ID Driver::getFinalPhase(const DerivedArgList &DAL, Arg **FinalPhaseArg) 158226633Sdimconst { 159226633Sdim Arg *PhaseArg = 0; 160226633Sdim phases::ID FinalPhase; 161226633Sdim 162226633Sdim // -{E,M,MM} only run the preprocessor. 163263508Sdim if (CCCIsCPP() || 164226633Sdim (PhaseArg = DAL.getLastArg(options::OPT_E)) || 165226633Sdim (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM))) { 166226633Sdim FinalPhase = phases::Preprocess; 167226633Sdim 168226633Sdim // -{fsyntax-only,-analyze,emit-ast,S} only run up to the compiler. 169226633Sdim } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) || 170249423Sdim (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) || 171226633Sdim (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) || 172234353Sdim (PhaseArg = DAL.getLastArg(options::OPT_rewrite_legacy_objc)) || 173234353Sdim (PhaseArg = DAL.getLastArg(options::OPT__migrate)) || 174226633Sdim (PhaseArg = DAL.getLastArg(options::OPT__analyze, 175234353Sdim options::OPT__analyze_auto)) || 176226633Sdim (PhaseArg = DAL.getLastArg(options::OPT_emit_ast)) || 177226633Sdim (PhaseArg = DAL.getLastArg(options::OPT_S))) { 178226633Sdim FinalPhase = phases::Compile; 179226633Sdim 180226633Sdim // -c only runs up to the assembler. 181226633Sdim } else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) { 182226633Sdim FinalPhase = phases::Assemble; 183226633Sdim 184226633Sdim // Otherwise do everything. 185226633Sdim } else 186226633Sdim FinalPhase = phases::Link; 187226633Sdim 188226633Sdim if (FinalPhaseArg) 189226633Sdim *FinalPhaseArg = PhaseArg; 190226633Sdim 191226633Sdim return FinalPhase; 192226633Sdim} 193226633Sdim 194263508Sdimstatic Arg* MakeInputArg(const DerivedArgList &Args, OptTable *Opts, 195263508Sdim StringRef Value) { 196263508Sdim Arg *A = new Arg(Opts->getOption(options::OPT_INPUT), Value, 197263508Sdim Args.getBaseArgs().MakeIndex(Value), Value.data()); 198263508Sdim A->claim(); 199263508Sdim return A; 200263508Sdim} 201263508Sdim 202210299SedDerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const { 203210299Sed DerivedArgList *DAL = new DerivedArgList(Args); 204210299Sed 205218893Sdim bool HasNostdlib = Args.hasArg(options::OPT_nostdlib); 206210299Sed for (ArgList::const_iterator it = Args.begin(), 207210299Sed ie = Args.end(); it != ie; ++it) { 208210299Sed const Arg *A = *it; 209210299Sed 210210299Sed // Unfortunately, we have to parse some forwarding options (-Xassembler, 211210299Sed // -Xlinker, -Xpreprocessor) because we either integrate their functionality 212210299Sed // (assembler and preprocessor), or bypass a previous driver ('collect2'). 213210299Sed 214210299Sed // Rewrite linker options, to replace --no-demangle with a custom internal 215210299Sed // option. 216210299Sed if ((A->getOption().matches(options::OPT_Wl_COMMA) || 217210299Sed A->getOption().matches(options::OPT_Xlinker)) && 218210299Sed A->containsValue("--no-demangle")) { 219210299Sed // Add the rewritten no-demangle argument. 220210299Sed DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle)); 221210299Sed 222210299Sed // Add the remaining values as Xlinker arguments. 223210299Sed for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) 224243830Sdim if (StringRef(A->getValue(i)) != "--no-demangle") 225210299Sed DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker), 226243830Sdim A->getValue(i)); 227210299Sed 228210299Sed continue; 229210299Sed } 230210299Sed 231210299Sed // Rewrite preprocessor options, to replace -Wp,-MD,FOO which is used by 232210299Sed // some build systems. We don't try to be complete here because we don't 233210299Sed // care to encourage this usage model. 234210299Sed if (A->getOption().matches(options::OPT_Wp_COMMA) && 235243830Sdim (A->getValue(0) == StringRef("-MD") || 236243830Sdim A->getValue(0) == StringRef("-MMD"))) { 237210299Sed // Rewrite to -MD/-MMD along with -MF. 238243830Sdim if (A->getValue(0) == StringRef("-MD")) 239210299Sed DAL->AddFlagArg(A, Opts->getOption(options::OPT_MD)); 240210299Sed else 241210299Sed DAL->AddFlagArg(A, Opts->getOption(options::OPT_MMD)); 242243830Sdim if (A->getNumValues() == 2) 243243830Sdim DAL->AddSeparateArg(A, Opts->getOption(options::OPT_MF), 244243830Sdim A->getValue(1)); 245210299Sed continue; 246210299Sed } 247210299Sed 248218893Sdim // Rewrite reserved library names. 249218893Sdim if (A->getOption().matches(options::OPT_l)) { 250243830Sdim StringRef Value = A->getValue(); 251218893Sdim 252218893Sdim // Rewrite unless -nostdlib is present. 253218893Sdim if (!HasNostdlib && Value == "stdc++") { 254218893Sdim DAL->AddFlagArg(A, Opts->getOption( 255218893Sdim options::OPT_Z_reserved_lib_stdcxx)); 256218893Sdim continue; 257218893Sdim } 258218893Sdim 259218893Sdim // Rewrite unconditionally. 260218893Sdim if (Value == "cc_kext") { 261218893Sdim DAL->AddFlagArg(A, Opts->getOption( 262218893Sdim options::OPT_Z_reserved_lib_cckext)); 263218893Sdim continue; 264218893Sdim } 265218893Sdim } 266218893Sdim 267263508Sdim // Pick up inputs via the -- option. 268263508Sdim if (A->getOption().matches(options::OPT__DASH_DASH)) { 269263508Sdim A->claim(); 270263508Sdim for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) 271263508Sdim DAL->append(MakeInputArg(*DAL, Opts, A->getValue(i))); 272263508Sdim continue; 273263508Sdim } 274263508Sdim 275210299Sed DAL->append(*it); 276210299Sed } 277210299Sed 278212904Sdim // Add a default value of -mlinker-version=, if one was given and the user 279212904Sdim // didn't specify one. 280212904Sdim#if defined(HOST_LINK_VERSION) 281212904Sdim if (!Args.hasArg(options::OPT_mlinker_version_EQ)) { 282212904Sdim DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ), 283212904Sdim HOST_LINK_VERSION); 284212904Sdim DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim(); 285212904Sdim } 286212904Sdim#endif 287212904Sdim 288210299Sed return DAL; 289210299Sed} 290210299Sed 291226633SdimCompilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) { 292193326Sed llvm::PrettyStackTraceString CrashInfo("Compilation construction"); 293193326Sed 294226633Sdim // FIXME: Handle environment options which affect driver behavior, somewhere 295234353Sdim // (client?). GCC_EXEC_PREFIX, LPATH, CC_PRINT_OPTIONS. 296193326Sed 297226633Sdim if (char *env = ::getenv("COMPILER_PATH")) { 298226633Sdim StringRef CompilerPath = env; 299226633Sdim while (!CompilerPath.empty()) { 300249423Sdim std::pair<StringRef, StringRef> Split 301263508Sdim = CompilerPath.split(llvm::sys::EnvPathSeparator); 302226633Sdim PrefixDirs.push_back(Split.first); 303226633Sdim CompilerPath = Split.second; 304226633Sdim } 305226633Sdim } 306226633Sdim 307263508Sdim // We look for the driver mode option early, because the mode can affect 308263508Sdim // how other options are parsed. 309263508Sdim ParseDriverMode(ArgList.slice(1)); 310263508Sdim 311193326Sed // FIXME: What are we going to do with -V and -b? 312193326Sed 313198092Srdivacky // FIXME: This stuff needs to go into the Compilation, not the driver. 314263508Sdim bool CCCPrintActions; 315193326Sed 316221345Sdim InputArgList *Args = ParseArgStrings(ArgList.slice(1)); 317193326Sed 318200583Srdivacky // -no-canonical-prefixes is used very early in main. 319200583Srdivacky Args->ClaimAllArgs(options::OPT_no_canonical_prefixes); 320200583Srdivacky 321212904Sdim // Ignore -pipe. 322212904Sdim Args->ClaimAllArgs(options::OPT_pipe); 323212904Sdim 324200583Srdivacky // Extract -ccc args. 325193326Sed // 326198092Srdivacky // FIXME: We need to figure out where this behavior should live. Most of it 327198092Srdivacky // should be outside in the client; the parts that aren't should have proper 328198092Srdivacky // options, either by introducing new ones or by overloading gcc ones like -V 329198092Srdivacky // or -b. 330200583Srdivacky CCCPrintActions = Args->hasArg(options::OPT_ccc_print_phases); 331200583Srdivacky CCCPrintBindings = Args->hasArg(options::OPT_ccc_print_bindings); 332200583Srdivacky if (const Arg *A = Args->getLastArg(options::OPT_ccc_gcc_name)) 333243830Sdim CCCGenericGCCName = A->getValue(); 334200583Srdivacky CCCUsePCH = Args->hasFlag(options::OPT_ccc_pch_is_pch, 335200583Srdivacky options::OPT_ccc_pch_is_pth); 336234353Sdim // FIXME: DefaultTargetTriple is used by the target-prefixed calls to as/ld 337234353Sdim // and getToolChain is const. 338263508Sdim if (IsCLMode()) { 339263508Sdim // clang-cl targets Win32. 340263508Sdim llvm::Triple T(DefaultTargetTriple); 341263508Sdim T.setOSName(llvm::Triple::getOSTypeName(llvm::Triple::Win32)); 342263508Sdim DefaultTargetTriple = T.str(); 343263508Sdim } 344234353Sdim if (const Arg *A = Args->getLastArg(options::OPT_target)) 345243830Sdim DefaultTargetTriple = A->getValue(); 346200583Srdivacky if (const Arg *A = Args->getLastArg(options::OPT_ccc_install_dir)) 347243830Sdim Dir = InstalledDir = A->getValue(); 348218893Sdim for (arg_iterator it = Args->filtered_begin(options::OPT_B), 349218893Sdim ie = Args->filtered_end(); it != ie; ++it) { 350218893Sdim const Arg *A = *it; 351218893Sdim A->claim(); 352243830Sdim PrefixDirs.push_back(A->getValue(0)); 353218893Sdim } 354221345Sdim if (const Arg *A = Args->getLastArg(options::OPT__sysroot_EQ)) 355243830Sdim SysRoot = A->getValue(); 356263508Sdim if (const Arg *A = Args->getLastArg(options::OPT__dyld_prefix_EQ)) 357263508Sdim DyldPrefix = A->getValue(); 358221345Sdim if (Args->hasArg(options::OPT_nostdlib)) 359221345Sdim UseStdLib = false; 360193326Sed 361249423Sdim if (const Arg *A = Args->getLastArg(options::OPT_resource_dir)) 362249423Sdim ResourceDir = A->getValue(); 363249423Sdim 364210299Sed // Perform the default argument translations. 365210299Sed DerivedArgList *TranslatedArgs = TranslateInputArgs(*Args); 366210299Sed 367234353Sdim // Owned by the host. 368234353Sdim const ToolChain &TC = getToolChain(*Args); 369234353Sdim 370193326Sed // The compilation takes ownership of Args. 371234353Sdim Compilation *C = new Compilation(*this, TC, Args, TranslatedArgs); 372193326Sed 373193326Sed if (!HandleImmediateArgs(*C)) 374193326Sed return C; 375193326Sed 376226633Sdim // Construct the list of inputs. 377226633Sdim InputList Inputs; 378263508Sdim BuildInputs(C->getDefaultToolChain(), *TranslatedArgs, Inputs); 379226633Sdim 380234353Sdim // Construct the list of abstract actions to perform for this compilation. On 381234353Sdim // Darwin target OSes this uses the driver-driver and universal actions. 382234353Sdim if (TC.getTriple().isOSDarwin()) 383212904Sdim BuildUniversalActions(C->getDefaultToolChain(), C->getArgs(), 384226633Sdim Inputs, C->getActions()); 385193326Sed else 386226633Sdim BuildActions(C->getDefaultToolChain(), C->getArgs(), Inputs, 387226633Sdim C->getActions()); 388193326Sed 389193326Sed if (CCCPrintActions) { 390193326Sed PrintActions(*C); 391193326Sed return C; 392193326Sed } 393193326Sed 394193326Sed BuildJobs(*C); 395193326Sed 396193326Sed return C; 397193326Sed} 398193326Sed 399226633Sdim// When clang crashes, produce diagnostic information including the fully 400226633Sdim// preprocessed source file(s). Request that the developer attach the 401226633Sdim// diagnostic information to a bug report. 402226633Sdimvoid Driver::generateCompilationDiagnostics(Compilation &C, 403226633Sdim const Command *FailingCommand) { 404234353Sdim if (C.getArgs().hasArg(options::OPT_fno_crash_diagnostics)) 405239462Sdim return; 406234353Sdim 407249423Sdim // Don't try to generate diagnostics for link or dsymutil jobs. 408249423Sdim if (FailingCommand && (FailingCommand->getCreator().isLinkJob() || 409249423Sdim FailingCommand->getCreator().isDsymutilJob())) 410234353Sdim return; 411234353Sdim 412239462Sdim // Print the version of the compiler. 413239462Sdim PrintVersion(C, llvm::errs()); 414239462Sdim 415226633Sdim Diag(clang::diag::note_drv_command_failed_diag_msg) 416239462Sdim << "PLEASE submit a bug report to " BUG_REPORT_URL " and include the " 417239462Sdim "crash backtrace, preprocessed source, and associated run script."; 418226633Sdim 419226633Sdim // Suppress driver output and emit preprocessor output to temp file. 420263508Sdim Mode = CPPMode; 421226633Sdim CCGenDiagnostics = true; 422239462Sdim C.getArgs().AddFlagArg(0, Opts->getOption(options::OPT_frewrite_includes)); 423226633Sdim 424234353Sdim // Save the original job command(s). 425234353Sdim std::string Cmd; 426234353Sdim llvm::raw_string_ostream OS(Cmd); 427239462Sdim if (FailingCommand) 428263508Sdim FailingCommand->Print(OS, "\n", /*Quote*/ false, /*CrashReport*/ true); 429239462Sdim else 430239462Sdim // Crash triggered by FORCE_CLANG_DIAGNOSTICS_CRASH, which doesn't have an 431239462Sdim // associated FailingCommand, so just pass all jobs. 432263508Sdim C.getJobs().Print(OS, "\n", /*Quote*/ false, /*CrashReport*/ true); 433234353Sdim OS.flush(); 434234353Sdim 435249423Sdim // Keep track of whether we produce any errors while trying to produce 436249423Sdim // preprocessed sources. 437249423Sdim DiagnosticErrorTrap Trap(Diags); 438249423Sdim 439249423Sdim // Suppress tool output. 440226633Sdim C.initCompilationForDiagnostics(); 441226633Sdim 442226633Sdim // Construct the list of inputs. 443226633Sdim InputList Inputs; 444226633Sdim BuildInputs(C.getDefaultToolChain(), C.getArgs(), Inputs); 445226633Sdim 446226633Sdim for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) { 447226633Sdim bool IgnoreInput = false; 448226633Sdim 449226633Sdim // Ignore input from stdin or any inputs that cannot be preprocessed. 450243830Sdim if (!strcmp(it->second->getValue(), "-")) { 451226633Sdim Diag(clang::diag::note_drv_command_failed_diag_msg) 452226633Sdim << "Error generating preprocessed source(s) - ignoring input from stdin" 453226633Sdim "."; 454226633Sdim IgnoreInput = true; 455226633Sdim } else if (types::getPreprocessedType(it->first) == types::TY_INVALID) { 456226633Sdim IgnoreInput = true; 457226633Sdim } 458226633Sdim 459226633Sdim if (IgnoreInput) { 460226633Sdim it = Inputs.erase(it); 461226633Sdim ie = Inputs.end(); 462226633Sdim } else { 463226633Sdim ++it; 464226633Sdim } 465226633Sdim } 466226633Sdim 467249423Sdim if (Inputs.empty()) { 468249423Sdim Diag(clang::diag::note_drv_command_failed_diag_msg) 469249423Sdim << "Error generating preprocessed source(s) - no preprocessable inputs."; 470249423Sdim return; 471249423Sdim } 472249423Sdim 473226633Sdim // Don't attempt to generate preprocessed files if multiple -arch options are 474234353Sdim // used, unless they're all duplicates. 475234353Sdim llvm::StringSet<> ArchNames; 476226633Sdim for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end(); 477226633Sdim it != ie; ++it) { 478226633Sdim Arg *A = *it; 479226633Sdim if (A->getOption().matches(options::OPT_arch)) { 480243830Sdim StringRef ArchName = A->getValue(); 481234353Sdim ArchNames.insert(ArchName); 482226633Sdim } 483226633Sdim } 484234353Sdim if (ArchNames.size() > 1) { 485234353Sdim Diag(clang::diag::note_drv_command_failed_diag_msg) 486234353Sdim << "Error generating preprocessed source(s) - cannot generate " 487234353Sdim "preprocessed source with multiple -arch options."; 488234353Sdim return; 489234353Sdim } 490226633Sdim 491234353Sdim // Construct the list of abstract actions to perform for this compilation. On 492234353Sdim // Darwin OSes this uses the driver-driver and builds universal actions. 493234353Sdim const ToolChain &TC = C.getDefaultToolChain(); 494234353Sdim if (TC.getTriple().isOSDarwin()) 495234353Sdim BuildUniversalActions(TC, C.getArgs(), Inputs, C.getActions()); 496226633Sdim else 497234353Sdim BuildActions(TC, C.getArgs(), Inputs, C.getActions()); 498226633Sdim 499226633Sdim BuildJobs(C); 500226633Sdim 501226633Sdim // If there were errors building the compilation, quit now. 502249423Sdim if (Trap.hasErrorOccurred()) { 503226633Sdim Diag(clang::diag::note_drv_command_failed_diag_msg) 504226633Sdim << "Error generating preprocessed source(s)."; 505226633Sdim return; 506226633Sdim } 507226633Sdim 508226633Sdim // Generate preprocessed output. 509249423Sdim SmallVector<std::pair<int, const Command *>, 4> FailingCommands; 510249423Sdim C.ExecuteJob(C.getJobs(), FailingCommands); 511226633Sdim 512226633Sdim // If the command succeeded, we are done. 513249423Sdim if (FailingCommands.empty()) { 514226633Sdim Diag(clang::diag::note_drv_command_failed_diag_msg) 515239462Sdim << "\n********************\n\n" 516239462Sdim "PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:\n" 517239462Sdim "Preprocessed source(s) and associated run script(s) are located at:"; 518226633Sdim ArgStringList Files = C.getTempFiles(); 519226633Sdim for (ArgStringList::const_iterator it = Files.begin(), ie = Files.end(); 520234353Sdim it != ie; ++it) { 521226633Sdim Diag(clang::diag::note_drv_command_failed_diag_msg) << *it; 522234353Sdim 523234353Sdim std::string Err; 524234353Sdim std::string Script = StringRef(*it).rsplit('.').first; 525234353Sdim Script += ".sh"; 526263508Sdim llvm::raw_fd_ostream ScriptOS( 527263508Sdim Script.c_str(), Err, llvm::sys::fs::F_Excl | llvm::sys::fs::F_Binary); 528234353Sdim if (!Err.empty()) { 529234353Sdim Diag(clang::diag::note_drv_command_failed_diag_msg) 530234353Sdim << "Error generating run script: " + Script + " " + Err; 531234353Sdim } else { 532239462Sdim // Append the new filename with correct preprocessed suffix. 533239462Sdim size_t I, E; 534239462Sdim I = Cmd.find("-main-file-name "); 535239462Sdim assert (I != std::string::npos && "Expected to find -main-file-name"); 536239462Sdim I += 16; 537239462Sdim E = Cmd.find(" ", I); 538239462Sdim assert (E != std::string::npos && "-main-file-name missing argument?"); 539239462Sdim StringRef OldFilename = StringRef(Cmd).slice(I, E); 540239462Sdim StringRef NewFilename = llvm::sys::path::filename(*it); 541239462Sdim I = StringRef(Cmd).rfind(OldFilename); 542239462Sdim E = I + OldFilename.size(); 543239462Sdim I = Cmd.rfind(" ", I) + 1; 544239462Sdim Cmd.replace(I, E - I, NewFilename.data(), NewFilename.size()); 545234353Sdim ScriptOS << Cmd; 546234353Sdim Diag(clang::diag::note_drv_command_failed_diag_msg) << Script; 547234353Sdim } 548234353Sdim } 549239462Sdim Diag(clang::diag::note_drv_command_failed_diag_msg) 550239462Sdim << "\n\n********************"; 551226633Sdim } else { 552226633Sdim // Failure, remove preprocessed files. 553251662Sdim if (!C.getArgs().hasArg(options::OPT_save_temps)) 554226633Sdim C.CleanupFileList(C.getTempFiles(), true); 555226633Sdim 556226633Sdim Diag(clang::diag::note_drv_command_failed_diag_msg) 557226633Sdim << "Error generating preprocessed source(s)."; 558226633Sdim } 559226633Sdim} 560226633Sdim 561226633Sdimint Driver::ExecuteCompilation(const Compilation &C, 562249423Sdim SmallVectorImpl< std::pair<int, const Command *> > &FailingCommands) const { 563195341Sed // Just print if -### was present. 564195341Sed if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) { 565263508Sdim C.getJobs().Print(llvm::errs(), "\n", true); 566195341Sed return 0; 567195341Sed } 568195341Sed 569195341Sed // If there were errors building the compilation, quit now. 570226633Sdim if (Diags.hasErrorOccurred()) 571195341Sed return 1; 572195341Sed 573249423Sdim C.ExecuteJob(C.getJobs(), FailingCommands); 574198092Srdivacky 575195341Sed // Remove temp files. 576195341Sed C.CleanupFileList(C.getTempFiles()); 577195341Sed 578208600Srdivacky // If the command succeeded, we are done. 579249423Sdim if (FailingCommands.empty()) 580249423Sdim return 0; 581208600Srdivacky 582249423Sdim // Otherwise, remove result files and print extra information about abnormal 583249423Sdim // failures. 584249423Sdim for (SmallVectorImpl< std::pair<int, const Command *> >::iterator it = 585249423Sdim FailingCommands.begin(), ie = FailingCommands.end(); it != ie; ++it) { 586249423Sdim int Res = it->first; 587249423Sdim const Command *FailingCommand = it->second; 588195341Sed 589249423Sdim // Remove result files if we're not saving temps. 590249423Sdim if (!C.getArgs().hasArg(options::OPT_save_temps)) { 591249423Sdim const JobAction *JA = cast<JobAction>(&FailingCommand->getSource()); 592249423Sdim C.CleanupFileMap(C.getResultFiles(), JA, true); 593234353Sdim 594249423Sdim // Failure result files are valid unless we crashed. 595249423Sdim if (Res < 0) 596249423Sdim C.CleanupFileMap(C.getFailureResultFiles(), JA, true); 597249423Sdim } 598195341Sed 599249423Sdim // Print extra information about abnormal failures, if possible. 600249423Sdim // 601249423Sdim // This is ad-hoc, but we don't want to be excessively noisy. If the result 602249423Sdim // status was 1, assume the command failed normally. In particular, if it 603249423Sdim // was the compiler then assume it gave a reasonable error code. Failures 604249423Sdim // in other tools are less common, and they generally have worse 605249423Sdim // diagnostics, so always print the diagnostic there. 606249423Sdim const Tool &FailingTool = FailingCommand->getCreator(); 607249423Sdim 608249423Sdim if (!FailingCommand->getCreator().hasGoodDiagnostics() || Res != 1) { 609249423Sdim // FIXME: See FIXME above regarding result code interpretation. 610249423Sdim if (Res < 0) 611249423Sdim Diag(clang::diag::err_drv_command_signalled) 612249423Sdim << FailingTool.getShortName(); 613249423Sdim else 614249423Sdim Diag(clang::diag::err_drv_command_failed) 615249423Sdim << FailingTool.getShortName() << Res; 616249423Sdim } 617195341Sed } 618249423Sdim return 0; 619195341Sed} 620195341Sed 621263508Sdimvoid Driver::PrintHelp(bool ShowHidden) const { 622263508Sdim unsigned IncludedFlagsBitmask; 623263508Sdim unsigned ExcludedFlagsBitmask; 624263508Sdim llvm::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) = 625263508Sdim getIncludeExcludeOptionFlagMasks(); 626193326Sed 627263508Sdim ExcludedFlagsBitmask |= options::NoDriverOption; 628263508Sdim if (!ShowHidden) 629263508Sdim ExcludedFlagsBitmask |= HelpHidden; 630263508Sdim 631204643Srdivacky getOpts().PrintHelp(llvm::outs(), Name.c_str(), DriverTitle.c_str(), 632263508Sdim IncludedFlagsBitmask, ExcludedFlagsBitmask); 633193326Sed} 634193326Sed 635226633Sdimvoid Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const { 636198092Srdivacky // FIXME: The following handlers should use a callback mechanism, we don't 637198092Srdivacky // know what the client would like to do. 638202879Srdivacky OS << getClangFullVersion() << '\n'; 639193326Sed const ToolChain &TC = C.getDefaultToolChain(); 640198092Srdivacky OS << "Target: " << TC.getTripleString() << '\n'; 641194613Sed 642194613Sed // Print the threading model. 643194613Sed // 644194613Sed // FIXME: Implement correctly. 645198092Srdivacky OS << "Thread model: " << "posix" << '\n'; 646193326Sed} 647193326Sed 648208600Srdivacky/// PrintDiagnosticCategories - Implement the --print-diagnostic-categories 649208600Srdivacky/// option. 650226633Sdimstatic void PrintDiagnosticCategories(raw_ostream &OS) { 651223017Sdim // Skip the empty category. 652223017Sdim for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories(); 653223017Sdim i != max; ++i) 654223017Sdim OS << i << ',' << DiagnosticIDs::getCategoryNameFromID(i) << '\n'; 655208600Srdivacky} 656208600Srdivacky 657193326Sedbool Driver::HandleImmediateArgs(const Compilation &C) { 658210299Sed // The order these options are handled in gcc is all over the place, but we 659198092Srdivacky // don't expect inconsistencies w.r.t. that to matter in practice. 660193326Sed 661218893Sdim if (C.getArgs().hasArg(options::OPT_dumpmachine)) { 662218893Sdim llvm::outs() << C.getDefaultToolChain().getTripleString() << '\n'; 663218893Sdim return false; 664218893Sdim } 665218893Sdim 666193326Sed if (C.getArgs().hasArg(options::OPT_dumpversion)) { 667218893Sdim // Since -dumpversion is only implemented for pedantic GCC compatibility, we 668218893Sdim // return an answer which matches our definition of __VERSION__. 669218893Sdim // 670218893Sdim // If we want to return a more correct answer some day, then we should 671218893Sdim // introduce a non-pedantically GCC compatible mode to Clang in which we 672218893Sdim // provide sensible definitions for -dumpversion, __VERSION__, etc. 673218893Sdim llvm::outs() << "4.2.1\n"; 674193326Sed return false; 675193326Sed } 676210299Sed 677208600Srdivacky if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) { 678208600Srdivacky PrintDiagnosticCategories(llvm::outs()); 679208600Srdivacky return false; 680208600Srdivacky } 681193326Sed 682239462Sdim if (C.getArgs().hasArg(options::OPT_help) || 683193326Sed C.getArgs().hasArg(options::OPT__help_hidden)) { 684193326Sed PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden)); 685193326Sed return false; 686193326Sed } 687193326Sed 688193326Sed if (C.getArgs().hasArg(options::OPT__version)) { 689198092Srdivacky // Follow gcc behavior and use stdout for --version and stderr for -v. 690198092Srdivacky PrintVersion(C, llvm::outs()); 691193326Sed return false; 692193326Sed } 693193326Sed 694198092Srdivacky if (C.getArgs().hasArg(options::OPT_v) || 695193326Sed C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) { 696198092Srdivacky PrintVersion(C, llvm::errs()); 697193326Sed SuppressMissingInputWarning = true; 698193326Sed } 699193326Sed 700193326Sed const ToolChain &TC = C.getDefaultToolChain(); 701263508Sdim 702263508Sdim if (C.getArgs().hasArg(options::OPT_v)) 703263508Sdim TC.printVerboseInfo(llvm::errs()); 704263508Sdim 705193326Sed if (C.getArgs().hasArg(options::OPT_print_search_dirs)) { 706193326Sed llvm::outs() << "programs: ="; 707193326Sed for (ToolChain::path_list::const_iterator it = TC.getProgramPaths().begin(), 708193326Sed ie = TC.getProgramPaths().end(); it != ie; ++it) { 709193326Sed if (it != TC.getProgramPaths().begin()) 710193326Sed llvm::outs() << ':'; 711193326Sed llvm::outs() << *it; 712193326Sed } 713193326Sed llvm::outs() << "\n"; 714226633Sdim llvm::outs() << "libraries: =" << ResourceDir; 715224145Sdim 716234982Sdim StringRef sysroot = C.getSysRoot(); 717224145Sdim 718198092Srdivacky for (ToolChain::path_list::const_iterator it = TC.getFilePaths().begin(), 719193326Sed ie = TC.getFilePaths().end(); it != ie; ++it) { 720226633Sdim llvm::outs() << ':'; 721224145Sdim const char *path = it->c_str(); 722224145Sdim if (path[0] == '=') 723224145Sdim llvm::outs() << sysroot << path + 1; 724224145Sdim else 725224145Sdim llvm::outs() << path; 726193326Sed } 727193326Sed llvm::outs() << "\n"; 728193326Sed return false; 729193326Sed } 730193326Sed 731198092Srdivacky // FIXME: The following handlers should use a callback mechanism, we don't 732198092Srdivacky // know what the client would like to do. 733193326Sed if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) { 734243830Sdim llvm::outs() << GetFilePath(A->getValue(), TC) << "\n"; 735193326Sed return false; 736193326Sed } 737193326Sed 738193326Sed if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) { 739243830Sdim llvm::outs() << GetProgramPath(A->getValue(), TC) << "\n"; 740193326Sed return false; 741193326Sed } 742193326Sed 743193326Sed if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) { 744198092Srdivacky llvm::outs() << GetFilePath("libgcc.a", TC) << "\n"; 745193326Sed return false; 746193326Sed } 747193326Sed 748194613Sed if (C.getArgs().hasArg(options::OPT_print_multi_lib)) { 749194613Sed // FIXME: We need tool chain support for this. 750194613Sed llvm::outs() << ".;\n"; 751194613Sed 752194613Sed switch (C.getDefaultToolChain().getTriple().getArch()) { 753194613Sed default: 754194613Sed break; 755198092Srdivacky 756194613Sed case llvm::Triple::x86_64: 757194613Sed llvm::outs() << "x86_64;@m64" << "\n"; 758194613Sed break; 759194613Sed 760194613Sed case llvm::Triple::ppc64: 761194613Sed llvm::outs() << "ppc64;@m64" << "\n"; 762194613Sed break; 763263508Sdim 764263508Sdim case llvm::Triple::ppc64le: 765263508Sdim llvm::outs() << "ppc64le;@m64" << "\n"; 766263508Sdim break; 767194613Sed } 768194613Sed return false; 769194613Sed } 770194613Sed 771194613Sed // FIXME: What is the difference between print-multi-directory and 772194613Sed // print-multi-os-directory? 773194613Sed if (C.getArgs().hasArg(options::OPT_print_multi_directory) || 774194613Sed C.getArgs().hasArg(options::OPT_print_multi_os_directory)) { 775194613Sed switch (C.getDefaultToolChain().getTriple().getArch()) { 776194613Sed default: 777194613Sed case llvm::Triple::x86: 778194613Sed case llvm::Triple::ppc: 779194613Sed llvm::outs() << "." << "\n"; 780194613Sed break; 781198092Srdivacky 782194613Sed case llvm::Triple::x86_64: 783213492Sdim llvm::outs() << "." << "\n"; 784194613Sed break; 785194613Sed 786194613Sed case llvm::Triple::ppc64: 787194613Sed llvm::outs() << "ppc64" << "\n"; 788194613Sed break; 789263508Sdim 790263508Sdim case llvm::Triple::ppc64le: 791263508Sdim llvm::outs() << "ppc64le" << "\n"; 792263508Sdim break; 793194613Sed } 794194613Sed return false; 795194613Sed } 796194613Sed 797193326Sed return true; 798193326Sed} 799193326Sed 800198092Srdivackystatic unsigned PrintActions1(const Compilation &C, Action *A, 801193326Sed std::map<Action*, unsigned> &Ids) { 802193326Sed if (Ids.count(A)) 803193326Sed return Ids[A]; 804198092Srdivacky 805193326Sed std::string str; 806193326Sed llvm::raw_string_ostream os(str); 807198092Srdivacky 808193326Sed os << Action::getClassName(A->getKind()) << ", "; 809198092Srdivacky if (InputAction *IA = dyn_cast<InputAction>(A)) { 810243830Sdim os << "\"" << IA->getInputArg().getValue() << "\""; 811193326Sed } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) { 812239462Sdim os << '"' << BIA->getArchName() << '"' 813193326Sed << ", {" << PrintActions1(C, *BIA->begin(), Ids) << "}"; 814193326Sed } else { 815193326Sed os << "{"; 816193326Sed for (Action::iterator it = A->begin(), ie = A->end(); it != ie;) { 817193326Sed os << PrintActions1(C, *it, Ids); 818193326Sed ++it; 819193326Sed if (it != ie) 820193326Sed os << ", "; 821193326Sed } 822193326Sed os << "}"; 823193326Sed } 824193326Sed 825193326Sed unsigned Id = Ids.size(); 826193326Sed Ids[A] = Id; 827198092Srdivacky llvm::errs() << Id << ": " << os.str() << ", " 828193326Sed << types::getTypeName(A->getType()) << "\n"; 829193326Sed 830193326Sed return Id; 831193326Sed} 832193326Sed 833193326Sedvoid Driver::PrintActions(const Compilation &C) const { 834193326Sed std::map<Action*, unsigned> Ids; 835198092Srdivacky for (ActionList::const_iterator it = C.getActions().begin(), 836193326Sed ie = C.getActions().end(); it != ie; ++it) 837193326Sed PrintActions1(C, *it, Ids); 838193326Sed} 839193326Sed 840223017Sdim/// \brief Check whether the given input tree contains any compilation or 841223017Sdim/// assembly actions. 842223017Sdimstatic bool ContainsCompileOrAssembleAction(const Action *A) { 843210299Sed if (isa<CompileJobAction>(A) || isa<AssembleJobAction>(A)) 844210299Sed return true; 845210299Sed 846210299Sed for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it) 847223017Sdim if (ContainsCompileOrAssembleAction(*it)) 848210299Sed return true; 849210299Sed 850210299Sed return false; 851210299Sed} 852210299Sed 853212904Sdimvoid Driver::BuildUniversalActions(const ToolChain &TC, 854263508Sdim DerivedArgList &Args, 855226633Sdim const InputList &BAInputs, 856193326Sed ActionList &Actions) const { 857198092Srdivacky llvm::PrettyStackTraceString CrashInfo("Building universal build actions"); 858198092Srdivacky // Collect the list of architectures. Duplicates are allowed, but should only 859198092Srdivacky // be handled once (in the order seen). 860193326Sed llvm::StringSet<> ArchNames; 861226633Sdim SmallVector<const char *, 4> Archs; 862198092Srdivacky for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); 863193326Sed it != ie; ++it) { 864193326Sed Arg *A = *it; 865193326Sed 866199512Srdivacky if (A->getOption().matches(options::OPT_arch)) { 867198092Srdivacky // Validate the option here; we don't save the type here because its 868198092Srdivacky // particular spelling may participate in other driver choices. 869198092Srdivacky llvm::Triple::ArchType Arch = 870243830Sdim tools::darwin::getArchTypeForDarwinArchName(A->getValue()); 871198092Srdivacky if (Arch == llvm::Triple::UnknownArch) { 872198092Srdivacky Diag(clang::diag::err_drv_invalid_arch_name) 873198092Srdivacky << A->getAsString(Args); 874198092Srdivacky continue; 875198092Srdivacky } 876193326Sed 877193326Sed A->claim(); 878243830Sdim if (ArchNames.insert(A->getValue())) 879243830Sdim Archs.push_back(A->getValue()); 880193326Sed } 881193326Sed } 882193326Sed 883198092Srdivacky // When there is no explicit arch for this platform, make sure we still bind 884198092Srdivacky // the architecture (to the default) so that -Xarch_ is handled correctly. 885193326Sed if (!Archs.size()) 886243830Sdim Archs.push_back(Args.MakeArgString(TC.getDefaultUniversalArchName())); 887193326Sed 888193326Sed ActionList SingleActions; 889226633Sdim BuildActions(TC, Args, BAInputs, SingleActions); 890193326Sed 891210299Sed // Add in arch bindings for every top level action, as well as lipo and 892210299Sed // dsymutil steps if needed. 893193326Sed for (unsigned i = 0, e = SingleActions.size(); i != e; ++i) { 894193326Sed Action *Act = SingleActions[i]; 895193326Sed 896198092Srdivacky // Make sure we can lipo this kind of output. If not (and it is an actual 897198092Srdivacky // output) then we disallow, since we can't create an output file with the 898198092Srdivacky // right name without overwriting it. We could remove this oddity by just 899198092Srdivacky // changing the output names to include the arch, which would also fix 900193326Sed // -save-temps. Compatibility wins for now. 901193326Sed 902193326Sed if (Archs.size() > 1 && !types::canLipoType(Act->getType())) 903193326Sed Diag(clang::diag::err_drv_invalid_output_with_multiple_archs) 904193326Sed << types::getTypeName(Act->getType()); 905193326Sed 906193326Sed ActionList Inputs; 907205219Srdivacky for (unsigned i = 0, e = Archs.size(); i != e; ++i) { 908193326Sed Inputs.push_back(new BindArchAction(Act, Archs[i])); 909205219Srdivacky if (i != 0) 910205219Srdivacky Inputs.back()->setOwnsInputs(false); 911205219Srdivacky } 912193326Sed 913198092Srdivacky // Lipo if necessary, we do it this way because we need to set the arch flag 914198092Srdivacky // so that -Xarch_ gets overwritten. 915193326Sed if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing) 916193326Sed Actions.append(Inputs.begin(), Inputs.end()); 917193326Sed else 918193326Sed Actions.push_back(new LipoJobAction(Inputs, Act->getType())); 919210299Sed 920234353Sdim // Handle debug info queries. 921234353Sdim Arg *A = Args.getLastArg(options::OPT_g_Group); 922234982Sdim if (A && !A->getOption().matches(options::OPT_g0) && 923234982Sdim !A->getOption().matches(options::OPT_gstabs) && 924234982Sdim ContainsCompileOrAssembleAction(Actions.back())) { 925239462Sdim 926234982Sdim // Add a 'dsymutil' step if necessary, when debug info is enabled and we 927234982Sdim // have a compile input. We need to run 'dsymutil' ourselves in such cases 928249423Sdim // because the debug info will refer to a temporary object file which 929234982Sdim // will be removed at the end of the compilation process. 930234982Sdim if (Act->getType() == types::TY_Image) { 931234982Sdim ActionList Inputs; 932234982Sdim Inputs.push_back(Actions.back()); 933234982Sdim Actions.pop_back(); 934234982Sdim Actions.push_back(new DsymutilJobAction(Inputs, types::TY_dSYM)); 935234982Sdim } 936210299Sed 937234982Sdim // Verify the output (debug information only) if we passed '-verify'. 938234982Sdim if (Args.hasArg(options::OPT_verify)) { 939234982Sdim ActionList VerifyInputs; 940234982Sdim VerifyInputs.push_back(Actions.back()); 941234982Sdim Actions.pop_back(); 942234982Sdim Actions.push_back(new VerifyJobAction(VerifyInputs, 943234982Sdim types::TY_Nothing)); 944210299Sed } 945234982Sdim } 946193326Sed } 947193326Sed} 948193326Sed 949263508Sdim/// \brief Check that the file referenced by Value exists. If it doesn't, 950263508Sdim/// issue a diagnostic and return false. 951263508Sdimstatic bool DiagnoseInputExistance(const Driver &D, const DerivedArgList &Args, 952263508Sdim StringRef Value) { 953263508Sdim if (!D.getCheckInputsExist()) 954263508Sdim return true; 955263508Sdim 956263508Sdim // stdin always exists. 957263508Sdim if (Value == "-") 958263508Sdim return true; 959263508Sdim 960263508Sdim SmallString<64> Path(Value); 961263508Sdim if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory)) { 962263508Sdim if (!llvm::sys::path::is_absolute(Path.str())) { 963263508Sdim SmallString<64> Directory(WorkDir->getValue()); 964263508Sdim llvm::sys::path::append(Directory, Value); 965263508Sdim Path.assign(Directory); 966263508Sdim } 967263508Sdim } 968263508Sdim 969263508Sdim if (llvm::sys::fs::exists(Twine(Path))) 970263508Sdim return true; 971263508Sdim 972263508Sdim D.Diag(clang::diag::err_drv_no_such_file) << Path.str(); 973263508Sdim return false; 974263508Sdim} 975263508Sdim 976226633Sdim// Construct a the list of inputs and their types. 977226633Sdimvoid Driver::BuildInputs(const ToolChain &TC, const DerivedArgList &Args, 978226633Sdim InputList &Inputs) const { 979198092Srdivacky // Track the current user specified (-x) input. We also explicitly track the 980198092Srdivacky // argument used to set the type; we only want to claim the type when we 981198092Srdivacky // actually use it, so we warn about unused -x arguments. 982193326Sed types::ID InputType = types::TY_Nothing; 983193326Sed Arg *InputTypeArg = 0; 984193326Sed 985263508Sdim // The last /TC or /TP option sets the input type to C or C++ globally. 986263508Sdim if (Arg *TCTP = Args.getLastArg(options::OPT__SLASH_TC, 987263508Sdim options::OPT__SLASH_TP)) { 988263508Sdim InputTypeArg = TCTP; 989263508Sdim InputType = TCTP->getOption().matches(options::OPT__SLASH_TC) 990263508Sdim ? types::TY_C : types::TY_CXX; 991263508Sdim 992263508Sdim arg_iterator it = Args.filtered_begin(options::OPT__SLASH_TC, 993263508Sdim options::OPT__SLASH_TP); 994263508Sdim const arg_iterator ie = Args.filtered_end(); 995263508Sdim Arg *Previous = *it++; 996263508Sdim bool ShowNote = false; 997263508Sdim while (it != ie) { 998263508Sdim Diag(clang::diag::warn_drv_overriding_flag_option) 999263508Sdim << Previous->getSpelling() << (*it)->getSpelling(); 1000263508Sdim Previous = *it++; 1001263508Sdim ShowNote = true; 1002263508Sdim } 1003263508Sdim if (ShowNote) 1004263508Sdim Diag(clang::diag::note_drv_t_option_is_global); 1005263508Sdim 1006263508Sdim // No driver mode exposes -x and /TC or /TP; we don't support mixing them. 1007263508Sdim assert(!Args.hasArg(options::OPT_x) && "-x and /TC or /TP is not allowed"); 1008263508Sdim } 1009263508Sdim 1010198092Srdivacky for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); 1011193326Sed it != ie; ++it) { 1012193326Sed Arg *A = *it; 1013193326Sed 1014243830Sdim if (A->getOption().getKind() == Option::InputClass) { 1015243830Sdim const char *Value = A->getValue(); 1016193326Sed types::ID Ty = types::TY_INVALID; 1017193326Sed 1018193326Sed // Infer the input type if necessary. 1019193326Sed if (InputType == types::TY_Nothing) { 1020193326Sed // If there was an explicit arg for this, claim it. 1021193326Sed if (InputTypeArg) 1022193326Sed InputTypeArg->claim(); 1023193326Sed 1024193326Sed // stdin must be handled specially. 1025193326Sed if (memcmp(Value, "-", 2) == 0) { 1026198092Srdivacky // If running with -E, treat as a C input (this changes the builtin 1027198092Srdivacky // macros, for example). This may be overridden by -ObjC below. 1028193326Sed // 1029198092Srdivacky // Otherwise emit an error but still use a valid type to avoid 1030198092Srdivacky // spurious errors (e.g., no inputs). 1031263508Sdim if (!Args.hasArgNoClaim(options::OPT_E) && !CCCIsCPP()) 1032193326Sed Diag(clang::diag::err_drv_unknown_stdin_type); 1033193326Sed Ty = types::TY_C; 1034193326Sed } else { 1035221345Sdim // Otherwise lookup by extension. 1036221345Sdim // Fallback is C if invoked as C preprocessor or Object otherwise. 1037221345Sdim // We use a host hook here because Darwin at least has its own 1038198092Srdivacky // idea of what .s is. 1039193326Sed if (const char *Ext = strrchr(Value, '.')) 1040212904Sdim Ty = TC.LookupTypeForExtension(Ext + 1); 1041193326Sed 1042221345Sdim if (Ty == types::TY_INVALID) { 1043263508Sdim if (CCCIsCPP()) 1044221345Sdim Ty = types::TY_C; 1045221345Sdim else 1046221345Sdim Ty = types::TY_Object; 1047221345Sdim } 1048204643Srdivacky 1049204643Srdivacky // If the driver is invoked as C++ compiler (like clang++ or c++) it 1050204643Srdivacky // should autodetect some input files as C++ for g++ compatibility. 1051263508Sdim if (CCCIsCXX()) { 1052204643Srdivacky types::ID OldTy = Ty; 1053204643Srdivacky Ty = types::lookupCXXTypeForCType(Ty); 1054204643Srdivacky 1055204643Srdivacky if (Ty != OldTy) 1056204643Srdivacky Diag(clang::diag::warn_drv_treating_input_as_cxx) 1057204643Srdivacky << getTypeName(OldTy) << getTypeName(Ty); 1058204643Srdivacky } 1059193326Sed } 1060193326Sed 1061193326Sed // -ObjC and -ObjC++ override the default language, but only for "source 1062193326Sed // files". We just treat everything that isn't a linker input as a 1063193326Sed // source file. 1064198092Srdivacky // 1065193326Sed // FIXME: Clean this up if we move the phase sequence into the type. 1066193326Sed if (Ty != types::TY_Object) { 1067193326Sed if (Args.hasArg(options::OPT_ObjC)) 1068193326Sed Ty = types::TY_ObjC; 1069193326Sed else if (Args.hasArg(options::OPT_ObjCXX)) 1070193326Sed Ty = types::TY_ObjCXX; 1071193326Sed } 1072193326Sed } else { 1073193326Sed assert(InputTypeArg && "InputType set w/o InputTypeArg"); 1074193326Sed InputTypeArg->claim(); 1075193326Sed Ty = InputType; 1076193326Sed } 1077193326Sed 1078263508Sdim if (DiagnoseInputExistance(*this, Args, Value)) 1079193326Sed Inputs.push_back(std::make_pair(Ty, A)); 1080193326Sed 1081263508Sdim } else if (A->getOption().matches(options::OPT__SLASH_Tc)) { 1082263508Sdim StringRef Value = A->getValue(); 1083263508Sdim if (DiagnoseInputExistance(*this, Args, Value)) { 1084263508Sdim Arg *InputArg = MakeInputArg(Args, Opts, A->getValue()); 1085263508Sdim Inputs.push_back(std::make_pair(types::TY_C, InputArg)); 1086263508Sdim } 1087263508Sdim A->claim(); 1088263508Sdim } else if (A->getOption().matches(options::OPT__SLASH_Tp)) { 1089263508Sdim StringRef Value = A->getValue(); 1090263508Sdim if (DiagnoseInputExistance(*this, Args, Value)) { 1091263508Sdim Arg *InputArg = MakeInputArg(Args, Opts, A->getValue()); 1092263508Sdim Inputs.push_back(std::make_pair(types::TY_CXX, InputArg)); 1093263508Sdim } 1094263508Sdim A->claim(); 1095243830Sdim } else if (A->getOption().hasFlag(options::LinkerInput)) { 1096198092Srdivacky // Just treat as object type, we could make a special type for this if 1097198092Srdivacky // necessary. 1098193326Sed Inputs.push_back(std::make_pair(types::TY_Object, A)); 1099193326Sed 1100199512Srdivacky } else if (A->getOption().matches(options::OPT_x)) { 1101198092Srdivacky InputTypeArg = A; 1102243830Sdim InputType = types::lookupTypeForTypeSpecifier(A->getValue()); 1103234353Sdim A->claim(); 1104193326Sed 1105193326Sed // Follow gcc behavior and treat as linker input for invalid -x 1106198092Srdivacky // options. Its not clear why we shouldn't just revert to unknown; but 1107218893Sdim // this isn't very important, we might as well be bug compatible. 1108193326Sed if (!InputType) { 1109243830Sdim Diag(clang::diag::err_drv_unknown_language) << A->getValue(); 1110193326Sed InputType = types::TY_Object; 1111193326Sed } 1112193326Sed } 1113193326Sed } 1114263508Sdim if (CCCIsCPP() && Inputs.empty()) { 1115221345Sdim // If called as standalone preprocessor, stdin is processed 1116221345Sdim // if no other input is present. 1117263508Sdim Arg *A = MakeInputArg(Args, Opts, "-"); 1118221345Sdim Inputs.push_back(std::make_pair(types::TY_C, A)); 1119221345Sdim } 1120226633Sdim} 1121221345Sdim 1122263508Sdimvoid Driver::BuildActions(const ToolChain &TC, DerivedArgList &Args, 1123226633Sdim const InputList &Inputs, ActionList &Actions) const { 1124226633Sdim llvm::PrettyStackTraceString CrashInfo("Building compilation actions"); 1125226633Sdim 1126193326Sed if (!SuppressMissingInputWarning && Inputs.empty()) { 1127193326Sed Diag(clang::diag::err_drv_no_input_files); 1128193326Sed return; 1129193326Sed } 1130193326Sed 1131226633Sdim Arg *FinalPhaseArg; 1132226633Sdim phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg); 1133193326Sed 1134263508Sdim if (FinalPhase == phases::Link && Args.hasArg(options::OPT_emit_llvm)) { 1135263508Sdim Diag(clang::diag::err_drv_emit_llvm_link); 1136263508Sdim } 1137263508Sdim 1138198092Srdivacky // Reject -Z* at the top level, these options should never have been exposed 1139198092Srdivacky // by gcc. 1140193326Sed if (Arg *A = Args.getLastArg(options::OPT_Z_Joined)) 1141193326Sed Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args); 1142193326Sed 1143263508Sdim // Diagnose misuse of /Fo. 1144263508Sdim if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fo)) { 1145263508Sdim StringRef V = A->getValue(); 1146263508Sdim if (V.empty()) { 1147263508Sdim // It has to have a value. 1148263508Sdim Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1; 1149263508Sdim Args.eraseArg(options::OPT__SLASH_Fo); 1150263508Sdim } else if (Inputs.size() > 1 && !llvm::sys::path::is_separator(V.back())) { 1151263508Sdim // Check whether /Fo tries to name an output file for multiple inputs. 1152263508Sdim Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources) 1153263508Sdim << A->getSpelling() << V; 1154263508Sdim Args.eraseArg(options::OPT__SLASH_Fo); 1155263508Sdim } 1156263508Sdim } 1157263508Sdim 1158263508Sdim // Diagnose misuse of /Fa. 1159263508Sdim if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fa)) { 1160263508Sdim StringRef V = A->getValue(); 1161263508Sdim if (Inputs.size() > 1 && !llvm::sys::path::is_separator(V.back())) { 1162263508Sdim // Check whether /Fa tries to name an asm file for multiple inputs. 1163263508Sdim Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources) 1164263508Sdim << A->getSpelling() << V; 1165263508Sdim Args.eraseArg(options::OPT__SLASH_Fa); 1166263508Sdim } 1167263508Sdim } 1168263508Sdim 1169263508Sdim // Diagnose misuse of /Fe. 1170263508Sdim if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fe)) { 1171263508Sdim if (A->getValue()[0] == '\0') { 1172263508Sdim // It has to have a value. 1173263508Sdim Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1; 1174263508Sdim Args.eraseArg(options::OPT__SLASH_Fe); 1175263508Sdim } 1176263508Sdim } 1177263508Sdim 1178193326Sed // Construct the actions to perform. 1179193326Sed ActionList LinkerInputs; 1180249423Sdim ActionList SplitInputs; 1181249423Sdim llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PL; 1182193326Sed for (unsigned i = 0, e = Inputs.size(); i != e; ++i) { 1183193326Sed types::ID InputType = Inputs[i].first; 1184193326Sed const Arg *InputArg = Inputs[i].second; 1185193326Sed 1186249423Sdim PL.clear(); 1187249423Sdim types::getCompilationPhases(InputType, PL); 1188193326Sed 1189198092Srdivacky // If the first step comes after the final phase we are doing as part of 1190198092Srdivacky // this compilation, warn the user about it. 1191249423Sdim phases::ID InitialPhase = PL[0]; 1192193326Sed if (InitialPhase > FinalPhase) { 1193193326Sed // Claim here to avoid the more general unused warning. 1194193326Sed InputArg->claim(); 1195198092Srdivacky 1196221345Sdim // Suppress all unused style warnings with -Qunused-arguments 1197221345Sdim if (Args.hasArg(options::OPT_Qunused_arguments)) 1198221345Sdim continue; 1199221345Sdim 1200239462Sdim // Special case when final phase determined by binary name, rather than 1201239462Sdim // by a command-line argument with a corresponding Arg. 1202263508Sdim if (CCCIsCPP()) 1203239462Sdim Diag(clang::diag::warn_drv_input_file_unused_by_cpp) 1204239462Sdim << InputArg->getAsString(Args) 1205239462Sdim << getPhaseName(InitialPhase); 1206198092Srdivacky // Special case '-E' warning on a previously preprocessed file to make 1207198092Srdivacky // more sense. 1208239462Sdim else if (InitialPhase == phases::Compile && 1209239462Sdim FinalPhase == phases::Preprocess && 1210239462Sdim getPreprocessedType(InputType) == types::TY_INVALID) 1211198092Srdivacky Diag(clang::diag::warn_drv_preprocessed_input_file_unused) 1212198092Srdivacky << InputArg->getAsString(Args) 1213239462Sdim << !!FinalPhaseArg 1214239462Sdim << FinalPhaseArg ? FinalPhaseArg->getOption().getName() : ""; 1215198092Srdivacky else 1216198092Srdivacky Diag(clang::diag::warn_drv_input_file_unused) 1217198092Srdivacky << InputArg->getAsString(Args) 1218198092Srdivacky << getPhaseName(InitialPhase) 1219239462Sdim << !!FinalPhaseArg 1220239462Sdim << FinalPhaseArg ? FinalPhaseArg->getOption().getName() : ""; 1221193326Sed continue; 1222193326Sed } 1223198092Srdivacky 1224193326Sed // Build the pipeline for this file. 1225234353Sdim OwningPtr<Action> Current(new InputAction(*InputArg, InputType)); 1226263508Sdim for (SmallVectorImpl<phases::ID>::iterator 1227249423Sdim i = PL.begin(), e = PL.end(); i != e; ++i) { 1228249423Sdim phases::ID Phase = *i; 1229193326Sed 1230193326Sed // We are done if this step is past what the user requested. 1231193326Sed if (Phase > FinalPhase) 1232193326Sed break; 1233193326Sed 1234193326Sed // Queue linker inputs. 1235193326Sed if (Phase == phases::Link) { 1236249423Sdim assert((i + 1) == e && "linking must be final compilation step."); 1237202879Srdivacky LinkerInputs.push_back(Current.take()); 1238193326Sed break; 1239193326Sed } 1240193326Sed 1241198092Srdivacky // Some types skip the assembler phase (e.g., llvm-bc), but we can't 1242198092Srdivacky // encode this in the steps because the intermediate type depends on 1243198092Srdivacky // arguments. Just special case here. 1244193326Sed if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm) 1245193326Sed continue; 1246193326Sed 1247193326Sed // Otherwise construct the appropriate action. 1248202879Srdivacky Current.reset(ConstructPhaseAction(Args, Phase, Current.take())); 1249193326Sed if (Current->getType() == types::TY_Nothing) 1250193326Sed break; 1251193326Sed } 1252193326Sed 1253193326Sed // If we ended with something, add to the output list. 1254193326Sed if (Current) 1255202879Srdivacky Actions.push_back(Current.take()); 1256193326Sed } 1257193326Sed 1258193326Sed // Add a link action if necessary. 1259193326Sed if (!LinkerInputs.empty()) 1260193326Sed Actions.push_back(new LinkJobAction(LinkerInputs, types::TY_Image)); 1261201361Srdivacky 1262201361Srdivacky // If we are linking, claim any options which are obviously only used for 1263201361Srdivacky // compilation. 1264263508Sdim if (FinalPhase == phases::Link && PL.size() == 1) { 1265201361Srdivacky Args.ClaimAllArgs(options::OPT_CompileOnly_Group); 1266263508Sdim Args.ClaimAllArgs(options::OPT_cl_compile_Group); 1267263508Sdim } 1268263508Sdim 1269263508Sdim // Claim ignored clang-cl options. 1270263508Sdim Args.ClaimAllArgs(options::OPT_cl_ignored_Group); 1271193326Sed} 1272193326Sed 1273193326SedAction *Driver::ConstructPhaseAction(const ArgList &Args, phases::ID Phase, 1274193326Sed Action *Input) const { 1275193326Sed llvm::PrettyStackTraceString CrashInfo("Constructing phase actions"); 1276193326Sed // Build the appropriate action. 1277193326Sed switch (Phase) { 1278226633Sdim case phases::Link: llvm_unreachable("link action invalid here."); 1279193326Sed case phases::Preprocess: { 1280193326Sed types::ID OutputTy; 1281193326Sed // -{M, MM} alter the output type. 1282218893Sdim if (Args.hasArg(options::OPT_M, options::OPT_MM)) { 1283193326Sed OutputTy = types::TY_Dependencies; 1284193326Sed } else { 1285239462Sdim OutputTy = Input->getType(); 1286239462Sdim if (!Args.hasFlag(options::OPT_frewrite_includes, 1287239462Sdim options::OPT_fno_rewrite_includes, false)) 1288239462Sdim OutputTy = types::getPreprocessedType(OutputTy); 1289193326Sed assert(OutputTy != types::TY_INVALID && 1290193326Sed "Cannot preprocess this input type!"); 1291193326Sed } 1292193326Sed return new PreprocessJobAction(Input, OutputTy); 1293193326Sed } 1294239462Sdim case phases::Precompile: { 1295239462Sdim types::ID OutputTy = types::TY_PCH; 1296239462Sdim if (Args.hasArg(options::OPT_fsyntax_only)) { 1297239462Sdim // Syntax checks should not emit a PCH file 1298239462Sdim OutputTy = types::TY_Nothing; 1299239462Sdim } 1300239462Sdim return new PrecompileJobAction(Input, OutputTy); 1301239462Sdim } 1302193326Sed case phases::Compile: { 1303193326Sed if (Args.hasArg(options::OPT_fsyntax_only)) { 1304193326Sed return new CompileJobAction(Input, types::TY_Nothing); 1305203955Srdivacky } else if (Args.hasArg(options::OPT_rewrite_objc)) { 1306203955Srdivacky return new CompileJobAction(Input, types::TY_RewrittenObjC); 1307234353Sdim } else if (Args.hasArg(options::OPT_rewrite_legacy_objc)) { 1308234353Sdim return new CompileJobAction(Input, types::TY_RewrittenLegacyObjC); 1309193326Sed } else if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto)) { 1310193326Sed return new AnalyzeJobAction(Input, types::TY_Plist); 1311234353Sdim } else if (Args.hasArg(options::OPT__migrate)) { 1312234353Sdim return new MigrateJobAction(Input, types::TY_Remap); 1313198092Srdivacky } else if (Args.hasArg(options::OPT_emit_ast)) { 1314198092Srdivacky return new CompileJobAction(Input, types::TY_AST); 1315249423Sdim } else if (Args.hasArg(options::OPT_module_file_info)) { 1316249423Sdim return new CompileJobAction(Input, types::TY_ModuleFile); 1317224145Sdim } else if (IsUsingLTO(Args)) { 1318198092Srdivacky types::ID Output = 1319210299Sed Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC; 1320193326Sed return new CompileJobAction(Input, Output); 1321263508Sdim } else if (Args.hasArg(options::OPT_emit_llvm)) { 1322263508Sdim types::ID Output = 1323263508Sdim Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC; 1324263508Sdim return new CompileJobAction(Input, Output); 1325193326Sed } else { 1326193326Sed return new CompileJobAction(Input, types::TY_PP_Asm); 1327193326Sed } 1328193326Sed } 1329193326Sed case phases::Assemble: 1330193326Sed return new AssembleJobAction(Input, types::TY_Object); 1331193326Sed } 1332193326Sed 1333226633Sdim llvm_unreachable("invalid phase in ConstructPhaseAction"); 1334193326Sed} 1335193326Sed 1336224145Sdimbool Driver::IsUsingLTO(const ArgList &Args) const { 1337263508Sdim if (Args.hasFlag(options::OPT_flto, options::OPT_fno_lto, false)) 1338224145Sdim return true; 1339224145Sdim 1340224145Sdim return false; 1341224145Sdim} 1342224145Sdim 1343193326Sedvoid Driver::BuildJobs(Compilation &C) const { 1344193326Sed llvm::PrettyStackTraceString CrashInfo("Building compilation jobs"); 1345193326Sed 1346193326Sed Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o); 1347193326Sed 1348198092Srdivacky // It is an error to provide a -o option if we are making multiple output 1349198092Srdivacky // files. 1350193326Sed if (FinalOutput) { 1351193326Sed unsigned NumOutputs = 0; 1352198092Srdivacky for (ActionList::const_iterator it = C.getActions().begin(), 1353193326Sed ie = C.getActions().end(); it != ie; ++it) 1354193326Sed if ((*it)->getType() != types::TY_Nothing) 1355193326Sed ++NumOutputs; 1356198092Srdivacky 1357193326Sed if (NumOutputs > 1) { 1358193326Sed Diag(clang::diag::err_drv_output_argument_with_multiple_files); 1359193326Sed FinalOutput = 0; 1360193326Sed } 1361193326Sed } 1362193326Sed 1363251662Sdim // Collect the list of architectures. 1364251662Sdim llvm::StringSet<> ArchNames; 1365251662Sdim if (C.getDefaultToolChain().getTriple().isOSDarwin()) { 1366251662Sdim for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end(); 1367251662Sdim it != ie; ++it) { 1368251662Sdim Arg *A = *it; 1369251662Sdim if (A->getOption().matches(options::OPT_arch)) 1370251662Sdim ArchNames.insert(A->getValue()); 1371251662Sdim } 1372251662Sdim } 1373251662Sdim 1374198092Srdivacky for (ActionList::const_iterator it = C.getActions().begin(), 1375193326Sed ie = C.getActions().end(); it != ie; ++it) { 1376193326Sed Action *A = *it; 1377193326Sed 1378198092Srdivacky // If we are linking an image for multiple archs then the linker wants 1379198092Srdivacky // -arch_multiple and -final_output <final image name>. Unfortunately, this 1380198092Srdivacky // doesn't fit in cleanly because we have to pass this information down. 1381193326Sed // 1382198092Srdivacky // FIXME: This is a hack; find a cleaner way to integrate this into the 1383198092Srdivacky // process. 1384193326Sed const char *LinkingOutput = 0; 1385193326Sed if (isa<LipoJobAction>(A)) { 1386193326Sed if (FinalOutput) 1387243830Sdim LinkingOutput = FinalOutput->getValue(); 1388193326Sed else 1389193326Sed LinkingOutput = DefaultImageName.c_str(); 1390193326Sed } 1391193326Sed 1392193326Sed InputInfo II; 1393198092Srdivacky BuildJobsForAction(C, A, &C.getDefaultToolChain(), 1394198092Srdivacky /*BoundArch*/0, 1395193326Sed /*AtTopLevel*/ true, 1396251662Sdim /*MultipleArchs*/ ArchNames.size() > 1, 1397193326Sed /*LinkingOutput*/ LinkingOutput, 1398193326Sed II); 1399193326Sed } 1400193326Sed 1401198092Srdivacky // If the user passed -Qunused-arguments or there were errors, don't warn 1402198092Srdivacky // about any unused arguments. 1403218893Sdim if (Diags.hasErrorOccurred() || 1404193326Sed C.getArgs().hasArg(options::OPT_Qunused_arguments)) 1405193326Sed return; 1406193326Sed 1407193326Sed // Claim -### here. 1408193326Sed (void) C.getArgs().hasArg(options::OPT__HASH_HASH_HASH); 1409198092Srdivacky 1410263508Sdim // Claim --driver-mode, it was handled earlier. 1411263508Sdim (void) C.getArgs().hasArg(options::OPT_driver_mode); 1412263508Sdim 1413193326Sed for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end(); 1414193326Sed it != ie; ++it) { 1415193326Sed Arg *A = *it; 1416198092Srdivacky 1417193326Sed // FIXME: It would be nice to be able to send the argument to the 1418226633Sdim // DiagnosticsEngine, so that extra values, position, and so on could be 1419226633Sdim // printed. 1420193326Sed if (!A->isClaimed()) { 1421243830Sdim if (A->getOption().hasFlag(options::NoArgumentUnused)) 1422193326Sed continue; 1423193326Sed 1424198092Srdivacky // Suppress the warning automatically if this is just a flag, and it is an 1425198092Srdivacky // instance of an argument we already claimed. 1426193326Sed const Option &Opt = A->getOption(); 1427243830Sdim if (Opt.getKind() == Option::FlagClass) { 1428193326Sed bool DuplicateClaimed = false; 1429193326Sed 1430199990Srdivacky for (arg_iterator it = C.getArgs().filtered_begin(&Opt), 1431199990Srdivacky ie = C.getArgs().filtered_end(); it != ie; ++it) { 1432199990Srdivacky if ((*it)->isClaimed()) { 1433193326Sed DuplicateClaimed = true; 1434193326Sed break; 1435193326Sed } 1436193326Sed } 1437193326Sed 1438193326Sed if (DuplicateClaimed) 1439193326Sed continue; 1440193326Sed } 1441193326Sed 1442198092Srdivacky Diag(clang::diag::warn_drv_unused_argument) 1443193326Sed << A->getAsString(C.getArgs()); 1444193326Sed } 1445193326Sed } 1446193326Sed} 1447193326Sed 1448249423Sdimstatic const Tool *SelectToolForJob(Compilation &C, const ToolChain *TC, 1449203955Srdivacky const JobAction *JA, 1450203955Srdivacky const ActionList *&Inputs) { 1451203955Srdivacky const Tool *ToolForJob = 0; 1452203955Srdivacky 1453203955Srdivacky // See if we should look for a compiler with an integrated assembler. We match 1454203955Srdivacky // bottom up, so what we are actually looking for is an assembler job with a 1455203955Srdivacky // compiler input. 1456208600Srdivacky 1457249423Sdim if (TC->useIntegratedAs() && 1458203955Srdivacky !C.getArgs().hasArg(options::OPT_save_temps) && 1459263508Sdim !C.getArgs().hasArg(options::OPT__SLASH_FA) && 1460263508Sdim !C.getArgs().hasArg(options::OPT__SLASH_Fa) && 1461203955Srdivacky isa<AssembleJobAction>(JA) && 1462203955Srdivacky Inputs->size() == 1 && isa<CompileJobAction>(*Inputs->begin())) { 1463249423Sdim const Tool *Compiler = 1464249423Sdim TC->SelectTool(cast<JobAction>(**Inputs->begin())); 1465249423Sdim if (!Compiler) 1466249423Sdim return NULL; 1467249423Sdim if (Compiler->hasIntegratedAssembler()) { 1468203955Srdivacky Inputs = &(*Inputs)[0]->getInputs(); 1469249423Sdim ToolForJob = Compiler; 1470203955Srdivacky } 1471203955Srdivacky } 1472203955Srdivacky 1473203955Srdivacky // Otherwise use the tool for the current job. 1474203955Srdivacky if (!ToolForJob) 1475249423Sdim ToolForJob = TC->SelectTool(*JA); 1476203955Srdivacky 1477203955Srdivacky // See if we should use an integrated preprocessor. We do so when we have 1478203955Srdivacky // exactly one input, since this is the only use case we care about 1479203955Srdivacky // (irrelevant since we don't support combine yet). 1480203955Srdivacky if (Inputs->size() == 1 && isa<PreprocessJobAction>(*Inputs->begin()) && 1481203955Srdivacky !C.getArgs().hasArg(options::OPT_no_integrated_cpp) && 1482203955Srdivacky !C.getArgs().hasArg(options::OPT_traditional_cpp) && 1483203955Srdivacky !C.getArgs().hasArg(options::OPT_save_temps) && 1484243830Sdim !C.getArgs().hasArg(options::OPT_rewrite_objc) && 1485203955Srdivacky ToolForJob->hasIntegratedCPP()) 1486203955Srdivacky Inputs = &(*Inputs)[0]->getInputs(); 1487203955Srdivacky 1488249423Sdim return ToolForJob; 1489203955Srdivacky} 1490203955Srdivacky 1491193326Sedvoid Driver::BuildJobsForAction(Compilation &C, 1492193326Sed const Action *A, 1493193326Sed const ToolChain *TC, 1494198092Srdivacky const char *BoundArch, 1495193326Sed bool AtTopLevel, 1496251662Sdim bool MultipleArchs, 1497193326Sed const char *LinkingOutput, 1498193326Sed InputInfo &Result) const { 1499198092Srdivacky llvm::PrettyStackTraceString CrashInfo("Building compilation jobs"); 1500193326Sed 1501193326Sed if (const InputAction *IA = dyn_cast<InputAction>(A)) { 1502198092Srdivacky // FIXME: It would be nice to not claim this here; maybe the old scheme of 1503198092Srdivacky // just using Args was better? 1504193326Sed const Arg &Input = IA->getInputArg(); 1505193326Sed Input.claim(); 1506210299Sed if (Input.getOption().matches(options::OPT_INPUT)) { 1507243830Sdim const char *Name = Input.getValue(); 1508193326Sed Result = InputInfo(Name, A->getType(), Name); 1509193326Sed } else 1510193326Sed Result = InputInfo(&Input, A->getType(), ""); 1511193326Sed return; 1512193326Sed } 1513193326Sed 1514193326Sed if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) { 1515239462Sdim const ToolChain *TC; 1516239462Sdim const char *ArchName = BAA->getArchName(); 1517198092Srdivacky 1518239462Sdim if (ArchName) 1519239462Sdim TC = &getToolChain(C.getArgs(), ArchName); 1520239462Sdim else 1521239462Sdim TC = &C.getDefaultToolChain(); 1522198092Srdivacky 1523198092Srdivacky BuildJobsForAction(C, *BAA->begin(), TC, BAA->getArchName(), 1524251662Sdim AtTopLevel, MultipleArchs, LinkingOutput, Result); 1525193326Sed return; 1526193326Sed } 1527193326Sed 1528203955Srdivacky const ActionList *Inputs = &A->getInputs(); 1529203955Srdivacky 1530193326Sed const JobAction *JA = cast<JobAction>(A); 1531249423Sdim const Tool *T = SelectToolForJob(C, TC, JA, Inputs); 1532249423Sdim if (!T) 1533249423Sdim return; 1534198092Srdivacky 1535193326Sed // Only use pipes when there is exactly one input. 1536193326Sed InputInfoList InputInfos; 1537193326Sed for (ActionList::const_iterator it = Inputs->begin(), ie = Inputs->end(); 1538193326Sed it != ie; ++it) { 1539249423Sdim // Treat dsymutil and verify sub-jobs as being at the top-level too, they 1540249423Sdim // shouldn't get temporary output names. 1541210299Sed // FIXME: Clean this up. 1542210299Sed bool SubJobAtTopLevel = false; 1543249423Sdim if (AtTopLevel && (isa<DsymutilJobAction>(A) || isa<VerifyJobAction>(A))) 1544210299Sed SubJobAtTopLevel = true; 1545210299Sed 1546193326Sed InputInfo II; 1547251662Sdim BuildJobsForAction(C, *it, TC, BoundArch, SubJobAtTopLevel, MultipleArchs, 1548251662Sdim LinkingOutput, II); 1549193326Sed InputInfos.push_back(II); 1550193326Sed } 1551193326Sed 1552193326Sed // Always use the first input as the base input. 1553193326Sed const char *BaseInput = InputInfos[0].getBaseInput(); 1554193326Sed 1555210299Sed // ... except dsymutil actions, which use their actual input as the base 1556210299Sed // input. 1557210299Sed if (JA->getType() == types::TY_dSYM) 1558210299Sed BaseInput = InputInfos[0].getFilename(); 1559210299Sed 1560212904Sdim // Determine the place to write output to, if any. 1561249423Sdim if (JA->getType() == types::TY_Nothing) 1562193326Sed Result = InputInfo(A->getType(), BaseInput); 1563249423Sdim else 1564251662Sdim Result = InputInfo(GetNamedOutputPath(C, *JA, BaseInput, BoundArch, 1565251662Sdim AtTopLevel, MultipleArchs), 1566193326Sed A->getType(), BaseInput); 1567193326Sed 1568226633Sdim if (CCCPrintBindings && !CCGenDiagnostics) { 1569249423Sdim llvm::errs() << "# \"" << T->getToolChain().getTripleString() << '"' 1570249423Sdim << " - \"" << T->getName() << "\", inputs: ["; 1571193326Sed for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) { 1572193326Sed llvm::errs() << InputInfos[i].getAsString(); 1573193326Sed if (i + 1 != e) 1574193326Sed llvm::errs() << ", "; 1575193326Sed } 1576193326Sed llvm::errs() << "], output: " << Result.getAsString() << "\n"; 1577193326Sed } else { 1578249423Sdim T->ConstructJob(C, *JA, Result, InputInfos, 1579249423Sdim C.getArgsForToolChain(TC, BoundArch), LinkingOutput); 1580193326Sed } 1581193326Sed} 1582193326Sed 1583263508Sdim/// \brief Create output filename based on ArgValue, which could either be a 1584263508Sdim/// full filename, filename without extension, or a directory. If ArgValue 1585263508Sdim/// does not provide a filename, then use BaseName, and use the extension 1586263508Sdim/// suitable for FileType. 1587263508Sdimstatic const char *MakeCLOutputFilename(const ArgList &Args, StringRef ArgValue, 1588263508Sdim StringRef BaseName, types::ID FileType) { 1589263508Sdim SmallString<128> Filename = ArgValue; 1590263508Sdim 1591263508Sdim if (ArgValue.empty()) { 1592263508Sdim // If the argument is empty, output to BaseName in the current dir. 1593263508Sdim Filename = BaseName; 1594263508Sdim } else if (llvm::sys::path::is_separator(Filename.back())) { 1595263508Sdim // If the argument is a directory, output to BaseName in that dir. 1596263508Sdim llvm::sys::path::append(Filename, BaseName); 1597263508Sdim } 1598263508Sdim 1599263508Sdim if (!llvm::sys::path::has_extension(ArgValue)) { 1600263508Sdim // If the argument didn't provide an extension, then set it. 1601263508Sdim const char *Extension = types::getTypeTempSuffix(FileType, true); 1602263508Sdim 1603263508Sdim if (FileType == types::TY_Image && 1604263508Sdim Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd)) { 1605263508Sdim // The output file is a dll. 1606263508Sdim Extension = "dll"; 1607263508Sdim } 1608263508Sdim 1609263508Sdim llvm::sys::path::replace_extension(Filename, Extension); 1610263508Sdim } 1611263508Sdim 1612263508Sdim return Args.MakeArgString(Filename.c_str()); 1613263508Sdim} 1614263508Sdim 1615198092Srdivackyconst char *Driver::GetNamedOutputPath(Compilation &C, 1616193326Sed const JobAction &JA, 1617193326Sed const char *BaseInput, 1618251662Sdim const char *BoundArch, 1619251662Sdim bool AtTopLevel, 1620251662Sdim bool MultipleArchs) const { 1621193326Sed llvm::PrettyStackTraceString CrashInfo("Computing output path"); 1622193326Sed // Output to a user requested destination? 1623226633Sdim if (AtTopLevel && !isa<DsymutilJobAction>(JA) && 1624226633Sdim !isa<VerifyJobAction>(JA)) { 1625193326Sed if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) 1626249423Sdim return C.addResultFile(FinalOutput->getValue(), &JA); 1627193326Sed } 1628193326Sed 1629212904Sdim // Default to writing to stdout? 1630249423Sdim if (AtTopLevel && !CCGenDiagnostics && 1631249423Sdim (isa<PreprocessJobAction>(JA) || JA.getType() == types::TY_ModuleFile)) 1632212904Sdim return "-"; 1633212904Sdim 1634263508Sdim // Is this the assembly listing for /FA? 1635263508Sdim if (JA.getType() == types::TY_PP_Asm && 1636263508Sdim (C.getArgs().hasArg(options::OPT__SLASH_FA) || 1637263508Sdim C.getArgs().hasArg(options::OPT__SLASH_Fa))) { 1638263508Sdim // Use /Fa and the input filename to determine the asm file name. 1639263508Sdim StringRef BaseName = llvm::sys::path::filename(BaseInput); 1640263508Sdim StringRef FaValue = C.getArgs().getLastArgValue(options::OPT__SLASH_Fa); 1641263508Sdim return C.addResultFile(MakeCLOutputFilename(C.getArgs(), FaValue, BaseName, 1642263508Sdim JA.getType()), &JA); 1643263508Sdim } 1644263508Sdim 1645193326Sed // Output to a temporary file? 1646263508Sdim if ((!AtTopLevel && !C.getArgs().hasArg(options::OPT_save_temps) && 1647263508Sdim !C.getArgs().hasArg(options::OPT__SLASH_Fo)) || 1648226633Sdim CCGenDiagnostics) { 1649226633Sdim StringRef Name = llvm::sys::path::filename(BaseInput); 1650226633Sdim std::pair<StringRef, StringRef> Split = Name.split('.'); 1651198092Srdivacky std::string TmpName = 1652263508Sdim GetTemporaryPath(Split.first, 1653263508Sdim types::getTypeTempSuffix(JA.getType(), IsCLMode())); 1654193326Sed return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str())); 1655193326Sed } 1656193326Sed 1657234353Sdim SmallString<128> BasePath(BaseInput); 1658226633Sdim StringRef BaseName; 1659193326Sed 1660221345Sdim // Dsymutil actions should use the full path. 1661226633Sdim if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA)) 1662221345Sdim BaseName = BasePath; 1663221345Sdim else 1664221345Sdim BaseName = llvm::sys::path::filename(BasePath); 1665221345Sdim 1666193326Sed // Determine what the derived output name should be. 1667193326Sed const char *NamedOutput; 1668263508Sdim 1669263508Sdim if (JA.getType() == types::TY_Object && 1670263508Sdim C.getArgs().hasArg(options::OPT__SLASH_Fo)) { 1671263508Sdim // The /Fo flag decides the object filename. 1672263508Sdim StringRef Val = C.getArgs().getLastArg(options::OPT__SLASH_Fo)->getValue(); 1673263508Sdim NamedOutput = MakeCLOutputFilename(C.getArgs(), Val, BaseName, 1674263508Sdim types::TY_Object); 1675263508Sdim } else if (JA.getType() == types::TY_Image && 1676263508Sdim C.getArgs().hasArg(options::OPT__SLASH_Fe)) { 1677263508Sdim // The /Fe flag names the linked file. 1678263508Sdim StringRef Val = C.getArgs().getLastArg(options::OPT__SLASH_Fe)->getValue(); 1679263508Sdim NamedOutput = MakeCLOutputFilename(C.getArgs(), Val, BaseName, 1680263508Sdim types::TY_Image); 1681263508Sdim } else if (JA.getType() == types::TY_Image) { 1682263508Sdim if (IsCLMode()) { 1683263508Sdim // clang-cl uses BaseName for the executable name. 1684263508Sdim NamedOutput = MakeCLOutputFilename(C.getArgs(), "", BaseName, 1685263508Sdim types::TY_Image); 1686263508Sdim } else if (MultipleArchs && BoundArch) { 1687251662Sdim SmallString<128> Output(DefaultImageName.c_str()); 1688251662Sdim Output += "-"; 1689251662Sdim Output.append(BoundArch); 1690251662Sdim NamedOutput = C.getArgs().MakeArgString(Output.c_str()); 1691251662Sdim } else 1692251662Sdim NamedOutput = DefaultImageName.c_str(); 1693193326Sed } else { 1694263508Sdim const char *Suffix = types::getTypeTempSuffix(JA.getType(), IsCLMode()); 1695193326Sed assert(Suffix && "All types used for output should have a suffix."); 1696193326Sed 1697193326Sed std::string::size_type End = std::string::npos; 1698193326Sed if (!types::appendSuffixForType(JA.getType())) 1699193326Sed End = BaseName.rfind('.'); 1700251662Sdim SmallString<128> Suffixed(BaseName.substr(0, End)); 1701251662Sdim if (MultipleArchs && BoundArch) { 1702251662Sdim Suffixed += "-"; 1703251662Sdim Suffixed.append(BoundArch); 1704251662Sdim } 1705193326Sed Suffixed += '.'; 1706193326Sed Suffixed += Suffix; 1707193326Sed NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str()); 1708193326Sed } 1709193326Sed 1710239462Sdim // If we're saving temps and the temp file conflicts with the input file, 1711239462Sdim // then avoid overwriting input file. 1712224145Sdim if (!AtTopLevel && C.getArgs().hasArg(options::OPT_save_temps) && 1713226633Sdim NamedOutput == BaseName) { 1714239462Sdim 1715239462Sdim bool SameFile = false; 1716239462Sdim SmallString<256> Result; 1717239462Sdim llvm::sys::fs::current_path(Result); 1718239462Sdim llvm::sys::path::append(Result, BaseName); 1719239462Sdim llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile); 1720239462Sdim // Must share the same path to conflict. 1721239462Sdim if (SameFile) { 1722239462Sdim StringRef Name = llvm::sys::path::filename(BaseInput); 1723239462Sdim std::pair<StringRef, StringRef> Split = Name.split('.'); 1724239462Sdim std::string TmpName = 1725263508Sdim GetTemporaryPath(Split.first, 1726263508Sdim types::getTypeTempSuffix(JA.getType(), IsCLMode())); 1727239462Sdim return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str())); 1728239462Sdim } 1729224145Sdim } 1730224145Sdim 1731198092Srdivacky // As an annoying special case, PCH generation doesn't strip the pathname. 1732193326Sed if (JA.getType() == types::TY_PCH) { 1733218893Sdim llvm::sys::path::remove_filename(BasePath); 1734218893Sdim if (BasePath.empty()) 1735193326Sed BasePath = NamedOutput; 1736193326Sed else 1737218893Sdim llvm::sys::path::append(BasePath, NamedOutput); 1738249423Sdim return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str()), &JA); 1739193326Sed } else { 1740249423Sdim return C.addResultFile(NamedOutput, &JA); 1741193326Sed } 1742193326Sed} 1743193326Sed 1744198092Srdivackystd::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const { 1745206084Srdivacky // Respect a limited subset of the '-Bprefix' functionality in GCC by 1746243830Sdim // attempting to use this prefix when looking for file paths. 1747218893Sdim for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(), 1748218893Sdim ie = PrefixDirs.end(); it != ie; ++it) { 1749221345Sdim std::string Dir(*it); 1750221345Sdim if (Dir.empty()) 1751221345Sdim continue; 1752221345Sdim if (Dir[0] == '=') 1753221345Sdim Dir = SysRoot + Dir.substr(1); 1754263508Sdim SmallString<128> P(Dir); 1755263508Sdim llvm::sys::path::append(P, Name); 1756263508Sdim if (llvm::sys::fs::exists(Twine(P))) 1757206084Srdivacky return P.str(); 1758206084Srdivacky } 1759206084Srdivacky 1760263508Sdim SmallString<128> P(ResourceDir); 1761263508Sdim llvm::sys::path::append(P, Name); 1762263508Sdim if (llvm::sys::fs::exists(Twine(P))) 1763226633Sdim return P.str(); 1764226633Sdim 1765193326Sed const ToolChain::path_list &List = TC.getFilePaths(); 1766198092Srdivacky for (ToolChain::path_list::const_iterator 1767193326Sed it = List.begin(), ie = List.end(); it != ie; ++it) { 1768221345Sdim std::string Dir(*it); 1769221345Sdim if (Dir.empty()) 1770221345Sdim continue; 1771221345Sdim if (Dir[0] == '=') 1772221345Sdim Dir = SysRoot + Dir.substr(1); 1773263508Sdim SmallString<128> P(Dir); 1774263508Sdim llvm::sys::path::append(P, Name); 1775263508Sdim if (llvm::sys::fs::exists(Twine(P))) 1776198092Srdivacky return P.str(); 1777193326Sed } 1778193326Sed 1779198092Srdivacky return Name; 1780193326Sed} 1781193326Sed 1782243830Sdimstd::string Driver::GetProgramPath(const char *Name, 1783243830Sdim const ToolChain &TC) const { 1784234353Sdim // FIXME: Needs a better variable than DefaultTargetTriple 1785234353Sdim std::string TargetSpecificExecutable(DefaultTargetTriple + "-" + Name); 1786206084Srdivacky // Respect a limited subset of the '-Bprefix' functionality in GCC by 1787243830Sdim // attempting to use this prefix when looking for program paths. 1788218893Sdim for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(), 1789218893Sdim ie = PrefixDirs.end(); it != ie; ++it) { 1790263508Sdim if (llvm::sys::fs::is_directory(*it)) { 1791263508Sdim SmallString<128> P(*it); 1792263508Sdim llvm::sys::path::append(P, TargetSpecificExecutable); 1793263508Sdim if (llvm::sys::fs::can_execute(Twine(P))) 1794263508Sdim return P.str(); 1795263508Sdim llvm::sys::path::remove_filename(P); 1796263508Sdim llvm::sys::path::append(P, Name); 1797263508Sdim if (llvm::sys::fs::can_execute(Twine(P))) 1798263508Sdim return P.str(); 1799243830Sdim } else { 1800263508Sdim SmallString<128> P(*it + Name); 1801263508Sdim if (llvm::sys::fs::can_execute(Twine(P))) 1802263508Sdim return P.str(); 1803243830Sdim } 1804206084Srdivacky } 1805206084Srdivacky 1806193326Sed const ToolChain::path_list &List = TC.getProgramPaths(); 1807198092Srdivacky for (ToolChain::path_list::const_iterator 1808193326Sed it = List.begin(), ie = List.end(); it != ie; ++it) { 1809263508Sdim SmallString<128> P(*it); 1810263508Sdim llvm::sys::path::append(P, TargetSpecificExecutable); 1811263508Sdim if (llvm::sys::fs::can_execute(Twine(P))) 1812263508Sdim return P.str(); 1813263508Sdim llvm::sys::path::remove_filename(P); 1814263508Sdim llvm::sys::path::append(P, Name); 1815263508Sdim if (llvm::sys::fs::can_execute(Twine(P))) 1816263508Sdim return P.str(); 1817193326Sed } 1818193326Sed 1819193326Sed // If all else failed, search the path. 1820263508Sdim std::string P(llvm::sys::FindProgramByName(TargetSpecificExecutable)); 1821193326Sed if (!P.empty()) 1822263508Sdim return P; 1823193326Sed 1824263508Sdim P = llvm::sys::FindProgramByName(Name); 1825226633Sdim if (!P.empty()) 1826263508Sdim return P; 1827226633Sdim 1828198092Srdivacky return Name; 1829193326Sed} 1830193326Sed 1831239462Sdimstd::string Driver::GetTemporaryPath(StringRef Prefix, const char *Suffix) 1832226633Sdim const { 1833263508Sdim SmallString<128> Path; 1834263508Sdim llvm::error_code EC = 1835263508Sdim llvm::sys::fs::createTemporaryFile(Prefix, Suffix, Path); 1836263508Sdim if (EC) { 1837263508Sdim Diag(clang::diag::err_unable_to_make_temp) << EC.message(); 1838193326Sed return ""; 1839193326Sed } 1840193326Sed 1841263508Sdim return Path.str(); 1842193326Sed} 1843193326Sed 1844234353Sdim/// \brief Compute target triple from args. 1845234353Sdim/// 1846234353Sdim/// This routine provides the logic to compute a target triple from various 1847234353Sdim/// args passed to the driver and the default triple string. 1848234353Sdimstatic llvm::Triple computeTargetTriple(StringRef DefaultTargetTriple, 1849234353Sdim const ArgList &Args, 1850234353Sdim StringRef DarwinArchName) { 1851234353Sdim // FIXME: Already done in Compilation *Driver::BuildCompilation 1852234353Sdim if (const Arg *A = Args.getLastArg(options::OPT_target)) 1853243830Sdim DefaultTargetTriple = A->getValue(); 1854193326Sed 1855234353Sdim llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple)); 1856204793Srdivacky 1857234353Sdim // Handle Darwin-specific options available here. 1858234353Sdim if (Target.isOSDarwin()) { 1859234353Sdim // If an explict Darwin arch name is given, that trumps all. 1860234353Sdim if (!DarwinArchName.empty()) { 1861234353Sdim Target.setArch( 1862243830Sdim tools::darwin::getArchTypeForDarwinArchName(DarwinArchName)); 1863234353Sdim return Target; 1864234353Sdim } 1865234353Sdim 1866234353Sdim // Handle the Darwin '-arch' flag. 1867234353Sdim if (Arg *A = Args.getLastArg(options::OPT_arch)) { 1868234353Sdim llvm::Triple::ArchType DarwinArch 1869243830Sdim = tools::darwin::getArchTypeForDarwinArchName(A->getValue()); 1870234353Sdim if (DarwinArch != llvm::Triple::UnknownArch) 1871234353Sdim Target.setArch(DarwinArch); 1872234353Sdim } 1873193326Sed } 1874234353Sdim 1875249423Sdim // Handle pseudo-target flags '-EL' and '-EB'. 1876249423Sdim if (Arg *A = Args.getLastArg(options::OPT_EL, options::OPT_EB)) { 1877249423Sdim if (A->getOption().matches(options::OPT_EL)) { 1878249423Sdim if (Target.getArch() == llvm::Triple::mips) 1879249423Sdim Target.setArch(llvm::Triple::mipsel); 1880249423Sdim else if (Target.getArch() == llvm::Triple::mips64) 1881249423Sdim Target.setArch(llvm::Triple::mips64el); 1882249423Sdim } else { 1883249423Sdim if (Target.getArch() == llvm::Triple::mipsel) 1884249423Sdim Target.setArch(llvm::Triple::mips); 1885249423Sdim else if (Target.getArch() == llvm::Triple::mips64el) 1886249423Sdim Target.setArch(llvm::Triple::mips64); 1887249423Sdim } 1888249423Sdim } 1889249423Sdim 1890234353Sdim // Skip further flag support on OSes which don't support '-m32' or '-m64'. 1891234353Sdim if (Target.getArchName() == "tce" || 1892234353Sdim Target.getOS() == llvm::Triple::AuroraUX || 1893234353Sdim Target.getOS() == llvm::Triple::Minix) 1894234353Sdim return Target; 1895234353Sdim 1896234353Sdim // Handle pseudo-target flags '-m32' and '-m64'. 1897234353Sdim // FIXME: Should this information be in llvm::Triple? 1898234353Sdim if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) { 1899234353Sdim if (A->getOption().matches(options::OPT_m32)) { 1900234353Sdim if (Target.getArch() == llvm::Triple::x86_64) 1901234353Sdim Target.setArch(llvm::Triple::x86); 1902234353Sdim if (Target.getArch() == llvm::Triple::ppc64) 1903234353Sdim Target.setArch(llvm::Triple::ppc); 1904234353Sdim } else { 1905234353Sdim if (Target.getArch() == llvm::Triple::x86) 1906234353Sdim Target.setArch(llvm::Triple::x86_64); 1907234353Sdim if (Target.getArch() == llvm::Triple::ppc) 1908234353Sdim Target.setArch(llvm::Triple::ppc64); 1909234353Sdim } 1910234353Sdim } 1911234353Sdim 1912234353Sdim return Target; 1913193326Sed} 1914193326Sed 1915234353Sdimconst ToolChain &Driver::getToolChain(const ArgList &Args, 1916234353Sdim StringRef DarwinArchName) const { 1917234353Sdim llvm::Triple Target = computeTargetTriple(DefaultTargetTriple, Args, 1918234353Sdim DarwinArchName); 1919234353Sdim 1920234353Sdim ToolChain *&TC = ToolChains[Target.str()]; 1921234353Sdim if (!TC) { 1922234353Sdim switch (Target.getOS()) { 1923234353Sdim case llvm::Triple::AuroraUX: 1924234353Sdim TC = new toolchains::AuroraUX(*this, Target, Args); 1925234353Sdim break; 1926234353Sdim case llvm::Triple::Darwin: 1927234353Sdim case llvm::Triple::MacOSX: 1928234353Sdim case llvm::Triple::IOS: 1929234353Sdim if (Target.getArch() == llvm::Triple::x86 || 1930234353Sdim Target.getArch() == llvm::Triple::x86_64 || 1931234353Sdim Target.getArch() == llvm::Triple::arm || 1932234353Sdim Target.getArch() == llvm::Triple::thumb) 1933249423Sdim TC = new toolchains::DarwinClang(*this, Target, Args); 1934234353Sdim else 1935234353Sdim TC = new toolchains::Darwin_Generic_GCC(*this, Target, Args); 1936234353Sdim break; 1937234353Sdim case llvm::Triple::DragonFly: 1938234353Sdim TC = new toolchains::DragonFly(*this, Target, Args); 1939234353Sdim break; 1940234353Sdim case llvm::Triple::OpenBSD: 1941234353Sdim TC = new toolchains::OpenBSD(*this, Target, Args); 1942234353Sdim break; 1943239462Sdim case llvm::Triple::Bitrig: 1944239462Sdim TC = new toolchains::Bitrig(*this, Target, Args); 1945239462Sdim break; 1946234353Sdim case llvm::Triple::NetBSD: 1947234353Sdim TC = new toolchains::NetBSD(*this, Target, Args); 1948234353Sdim break; 1949234353Sdim case llvm::Triple::FreeBSD: 1950234353Sdim TC = new toolchains::FreeBSD(*this, Target, Args); 1951234353Sdim break; 1952234353Sdim case llvm::Triple::Minix: 1953234353Sdim TC = new toolchains::Minix(*this, Target, Args); 1954234353Sdim break; 1955234353Sdim case llvm::Triple::Linux: 1956234353Sdim if (Target.getArch() == llvm::Triple::hexagon) 1957249423Sdim TC = new toolchains::Hexagon_TC(*this, Target, Args); 1958234353Sdim else 1959234353Sdim TC = new toolchains::Linux(*this, Target, Args); 1960234353Sdim break; 1961234353Sdim case llvm::Triple::Solaris: 1962234353Sdim TC = new toolchains::Solaris(*this, Target, Args); 1963234353Sdim break; 1964234353Sdim case llvm::Triple::Win32: 1965249423Sdim TC = new toolchains::Windows(*this, Target, Args); 1966234353Sdim break; 1967234353Sdim case llvm::Triple::MinGW32: 1968234353Sdim // FIXME: We need a MinGW toolchain. Fallthrough for now. 1969234353Sdim default: 1970234353Sdim // TCE is an OSless target 1971234353Sdim if (Target.getArchName() == "tce") { 1972249423Sdim TC = new toolchains::TCEToolChain(*this, Target, Args); 1973234353Sdim break; 1974234353Sdim } 1975249423Sdim // If Hexagon is configured as an OSless target 1976249423Sdim if (Target.getArch() == llvm::Triple::hexagon) { 1977249423Sdim TC = new toolchains::Hexagon_TC(*this, Target, Args); 1978249423Sdim break; 1979249423Sdim } 1980263508Sdim if (Target.getArch() == llvm::Triple::xcore) { 1981263508Sdim TC = new toolchains::XCore(*this, Target, Args); 1982263508Sdim break; 1983263508Sdim } 1984234353Sdim TC = new toolchains::Generic_GCC(*this, Target, Args); 1985234353Sdim break; 1986234353Sdim } 1987234353Sdim } 1988234353Sdim return *TC; 1989234353Sdim} 1990234353Sdim 1991249423Sdimbool Driver::ShouldUseClangCompiler(const JobAction &JA) const { 1992198092Srdivacky // Check if user requested no clang, or clang doesn't understand this type (we 1993198092Srdivacky // only handle single inputs for now). 1994243830Sdim if (JA.size() != 1 || 1995193326Sed !types::isAcceptedByClang((*JA.begin())->getType())) 1996193326Sed return false; 1997193326Sed 1998193326Sed // Otherwise make sure this is an action clang understands. 1999243830Sdim if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) && 2000243830Sdim !isa<CompileJobAction>(JA)) 2001193326Sed return false; 2002193326Sed 2003193326Sed return true; 2004193326Sed} 2005193326Sed 2006198092Srdivacky/// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the 2007198092Srdivacky/// grouped values as integers. Numbers which are not provided are set to 0. 2008193326Sed/// 2009198092Srdivacky/// \return True if the entire string was parsed (9.2), or all groups were 2010198092Srdivacky/// parsed (10.3.5extrastuff). 2011198092Srdivackybool Driver::GetReleaseVersion(const char *Str, unsigned &Major, 2012193326Sed unsigned &Minor, unsigned &Micro, 2013193326Sed bool &HadExtra) { 2014193326Sed HadExtra = false; 2015193326Sed 2016193326Sed Major = Minor = Micro = 0; 2017198092Srdivacky if (*Str == '\0') 2018193326Sed return true; 2019193326Sed 2020193326Sed char *End; 2021193326Sed Major = (unsigned) strtol(Str, &End, 10); 2022193326Sed if (*Str != '\0' && *End == '\0') 2023193326Sed return true; 2024193326Sed if (*End != '.') 2025193326Sed return false; 2026198092Srdivacky 2027193326Sed Str = End+1; 2028193326Sed Minor = (unsigned) strtol(Str, &End, 10); 2029193326Sed if (*Str != '\0' && *End == '\0') 2030193326Sed return true; 2031193326Sed if (*End != '.') 2032193326Sed return false; 2033193326Sed 2034193326Sed Str = End+1; 2035193326Sed Micro = (unsigned) strtol(Str, &End, 10); 2036193326Sed if (*Str != '\0' && *End == '\0') 2037193326Sed return true; 2038193326Sed if (Str == End) 2039193326Sed return false; 2040193326Sed HadExtra = true; 2041193326Sed return true; 2042193326Sed} 2043263508Sdim 2044263508Sdimstd::pair<unsigned, unsigned> Driver::getIncludeExcludeOptionFlagMasks() const { 2045263508Sdim unsigned IncludedFlagsBitmask = 0; 2046263508Sdim unsigned ExcludedFlagsBitmask = options::NoDriverOption; 2047263508Sdim 2048263508Sdim if (Mode == CLMode) { 2049263508Sdim // Include CL and Core options. 2050263508Sdim IncludedFlagsBitmask |= options::CLOption; 2051263508Sdim IncludedFlagsBitmask |= options::CoreOption; 2052263508Sdim } else { 2053263508Sdim ExcludedFlagsBitmask |= options::CLOption; 2054263508Sdim } 2055263508Sdim 2056263508Sdim return std::make_pair(IncludedFlagsBitmask, ExcludedFlagsBitmask); 2057263508Sdim} 2058266715Sdim 2059266715Sdimbool clang::driver::isOptimizationLevelFast(const llvm::opt::ArgList &Args) { 2060266715Sdim return Args.hasFlag(options::OPT_Ofast, options::OPT_O_Group, false); 2061266715Sdim} 2062