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