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