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