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