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