1 //===--- CompilerInstance.cpp ---------------------------------------------===// 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/Frontend/CompilerInstance.h" 11 #include "clang/Sema/Sema.h" 12 #include "clang/AST/ASTConsumer.h" 13 #include "clang/AST/ASTContext.h" 14 #include "clang/Basic/Diagnostic.h" 15 #include "clang/Basic/FileManager.h" 16 #include "clang/Basic/SourceManager.h" 17 #include "clang/Basic/TargetInfo.h" 18 #include "clang/Basic/Version.h" 19 #include "clang/Lex/HeaderSearch.h" 20 #include "clang/Lex/Preprocessor.h" 21 #include "clang/Lex/PTHManager.h" 22 #include "clang/Frontend/ChainedDiagnosticConsumer.h" 23 #include "clang/Frontend/FrontendAction.h" 24 #include "clang/Frontend/FrontendActions.h" 25 #include "clang/Frontend/FrontendDiagnostic.h" 26 #include "clang/Frontend/LogDiagnosticPrinter.h" 27 #include "clang/Frontend/TextDiagnosticPrinter.h" 28 #include "clang/Frontend/VerifyDiagnosticConsumer.h" 29 #include "clang/Frontend/Utils.h" 30 #include "clang/Serialization/ASTReader.h" 31 #include "clang/Sema/CodeCompleteConsumer.h" 32 #include "llvm/Support/FileSystem.h" 33 #include "llvm/Support/MemoryBuffer.h" 34 #include "llvm/Support/raw_ostream.h" 35 #include "llvm/ADT/Statistic.h" 36 #include "llvm/Support/Timer.h" 37 #include "llvm/Support/Host.h" 38 #include "llvm/Support/Path.h" 39 #include "llvm/Support/Program.h" 40 #include "llvm/Support/Signals.h" 41 #include "llvm/Support/system_error.h" 42 #include "llvm/Support/CrashRecoveryContext.h" 43 #include "llvm/Config/config.h" 44 45 // Support for FileLockManager 46 #include <fstream> 47 #include <sys/types.h> 48 #include <sys/stat.h> 49 50 #if LLVM_ON_WIN32 51 #include <windows.h> 52 #endif 53 #if LLVM_ON_UNIX 54 #include <unistd.h> 55 #endif 56 57 using namespace clang; 58 59 CompilerInstance::CompilerInstance() 60 : Invocation(new CompilerInvocation()), ModuleManager(0) { 61 } 62 63 CompilerInstance::~CompilerInstance() { 64 } 65 66 void CompilerInstance::setInvocation(CompilerInvocation *Value) { 67 Invocation = Value; 68 } 69 70 void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) { 71 Diagnostics = Value; 72 } 73 74 void CompilerInstance::setTarget(TargetInfo *Value) { 75 Target = Value; 76 } 77 78 void CompilerInstance::setFileManager(FileManager *Value) { 79 FileMgr = Value; 80 } 81 82 void CompilerInstance::setSourceManager(SourceManager *Value) { 83 SourceMgr = Value; 84 } 85 86 void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; } 87 88 void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; } 89 90 void CompilerInstance::setSema(Sema *S) { 91 TheSema.reset(S); 92 } 93 94 void CompilerInstance::setASTConsumer(ASTConsumer *Value) { 95 Consumer.reset(Value); 96 } 97 98 void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) { 99 CompletionConsumer.reset(Value); 100 } 101 102 // Diagnostics 103 static void SetUpBuildDumpLog(const DiagnosticOptions &DiagOpts, 104 unsigned argc, const char* const *argv, 105 DiagnosticsEngine &Diags) { 106 std::string ErrorInfo; 107 llvm::OwningPtr<raw_ostream> OS( 108 new llvm::raw_fd_ostream(DiagOpts.DumpBuildInformation.c_str(), ErrorInfo)); 109 if (!ErrorInfo.empty()) { 110 Diags.Report(diag::err_fe_unable_to_open_logfile) 111 << DiagOpts.DumpBuildInformation << ErrorInfo; 112 return; 113 } 114 115 (*OS) << "clang -cc1 command line arguments: "; 116 for (unsigned i = 0; i != argc; ++i) 117 (*OS) << argv[i] << ' '; 118 (*OS) << '\n'; 119 120 // Chain in a diagnostic client which will log the diagnostics. 121 DiagnosticConsumer *Logger = 122 new TextDiagnosticPrinter(*OS.take(), DiagOpts, /*OwnsOutputStream=*/true); 123 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger)); 124 } 125 126 static void SetUpDiagnosticLog(const DiagnosticOptions &DiagOpts, 127 const CodeGenOptions *CodeGenOpts, 128 DiagnosticsEngine &Diags) { 129 std::string ErrorInfo; 130 bool OwnsStream = false; 131 raw_ostream *OS = &llvm::errs(); 132 if (DiagOpts.DiagnosticLogFile != "-") { 133 // Create the output stream. 134 llvm::raw_fd_ostream *FileOS( 135 new llvm::raw_fd_ostream(DiagOpts.DiagnosticLogFile.c_str(), 136 ErrorInfo, llvm::raw_fd_ostream::F_Append)); 137 if (!ErrorInfo.empty()) { 138 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure) 139 << DiagOpts.DumpBuildInformation << ErrorInfo; 140 } else { 141 FileOS->SetUnbuffered(); 142 FileOS->SetUseAtomicWrites(true); 143 OS = FileOS; 144 OwnsStream = true; 145 } 146 } 147 148 // Chain in the diagnostic client which will log the diagnostics. 149 LogDiagnosticPrinter *Logger = new LogDiagnosticPrinter(*OS, DiagOpts, 150 OwnsStream); 151 if (CodeGenOpts) 152 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags); 153 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger)); 154 } 155 156 void CompilerInstance::createDiagnostics(int Argc, const char* const *Argv, 157 DiagnosticConsumer *Client, 158 bool ShouldOwnClient, 159 bool ShouldCloneClient) { 160 Diagnostics = createDiagnostics(getDiagnosticOpts(), Argc, Argv, Client, 161 ShouldOwnClient, ShouldCloneClient, 162 &getCodeGenOpts()); 163 } 164 165 llvm::IntrusiveRefCntPtr<DiagnosticsEngine> 166 CompilerInstance::createDiagnostics(const DiagnosticOptions &Opts, 167 int Argc, const char* const *Argv, 168 DiagnosticConsumer *Client, 169 bool ShouldOwnClient, 170 bool ShouldCloneClient, 171 const CodeGenOptions *CodeGenOpts) { 172 llvm::IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); 173 llvm::IntrusiveRefCntPtr<DiagnosticsEngine> 174 Diags(new DiagnosticsEngine(DiagID)); 175 176 // Create the diagnostic client for reporting errors or for 177 // implementing -verify. 178 if (Client) { 179 if (ShouldCloneClient) 180 Diags->setClient(Client->clone(*Diags), ShouldOwnClient); 181 else 182 Diags->setClient(Client, ShouldOwnClient); 183 } else 184 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts)); 185 186 // Chain in -verify checker, if requested. 187 if (Opts.VerifyDiagnostics) 188 Diags->setClient(new VerifyDiagnosticConsumer(*Diags)); 189 190 // Chain in -diagnostic-log-file dumper, if requested. 191 if (!Opts.DiagnosticLogFile.empty()) 192 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags); 193 194 if (!Opts.DumpBuildInformation.empty()) 195 SetUpBuildDumpLog(Opts, Argc, Argv, *Diags); 196 197 // Configure our handling of diagnostics. 198 ProcessWarningOptions(*Diags, Opts); 199 200 return Diags; 201 } 202 203 // File Manager 204 205 void CompilerInstance::createFileManager() { 206 FileMgr = new FileManager(getFileSystemOpts()); 207 } 208 209 // Source Manager 210 211 void CompilerInstance::createSourceManager(FileManager &FileMgr) { 212 SourceMgr = new SourceManager(getDiagnostics(), FileMgr); 213 } 214 215 // Preprocessor 216 217 void CompilerInstance::createPreprocessor() { 218 const PreprocessorOptions &PPOpts = getPreprocessorOpts(); 219 220 // Create a PTH manager if we are using some form of a token cache. 221 PTHManager *PTHMgr = 0; 222 if (!PPOpts.TokenCache.empty()) 223 PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics()); 224 225 // Create the Preprocessor. 226 HeaderSearch *HeaderInfo = new HeaderSearch(getFileManager()); 227 PP = new Preprocessor(getDiagnostics(), getLangOpts(), &getTarget(), 228 getSourceManager(), *HeaderInfo, *this, PTHMgr, 229 /*OwnsHeaderSearch=*/true); 230 231 // Note that this is different then passing PTHMgr to Preprocessor's ctor. 232 // That argument is used as the IdentifierInfoLookup argument to 233 // IdentifierTable's ctor. 234 if (PTHMgr) { 235 PTHMgr->setPreprocessor(&*PP); 236 PP->setPTHManager(PTHMgr); 237 } 238 239 if (PPOpts.DetailedRecord) 240 PP->createPreprocessingRecord( 241 PPOpts.DetailedRecordIncludesNestedMacroExpansions); 242 243 InitializePreprocessor(*PP, PPOpts, getHeaderSearchOpts(), getFrontendOpts()); 244 245 // Set up the module path, including the hash for the 246 // module-creation options. 247 llvm::SmallString<256> SpecificModuleCache( 248 getHeaderSearchOpts().ModuleCachePath); 249 if (!getHeaderSearchOpts().DisableModuleHash) 250 llvm::sys::path::append(SpecificModuleCache, 251 getInvocation().getModuleHash()); 252 PP->getHeaderSearchInfo().configureModules(SpecificModuleCache, 253 getPreprocessorOpts().ModuleBuildPath.empty() 254 ? std::string() 255 : getPreprocessorOpts().ModuleBuildPath.back()); 256 257 // Handle generating dependencies, if requested. 258 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts(); 259 if (!DepOpts.OutputFile.empty()) 260 AttachDependencyFileGen(*PP, DepOpts); 261 262 // Handle generating header include information, if requested. 263 if (DepOpts.ShowHeaderIncludes) 264 AttachHeaderIncludeGen(*PP); 265 if (!DepOpts.HeaderIncludeOutputFile.empty()) { 266 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile; 267 if (OutputPath == "-") 268 OutputPath = ""; 269 AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath, 270 /*ShowDepth=*/false); 271 } 272 } 273 274 // ASTContext 275 276 void CompilerInstance::createASTContext() { 277 Preprocessor &PP = getPreprocessor(); 278 Context = new ASTContext(getLangOpts(), PP.getSourceManager(), 279 &getTarget(), PP.getIdentifierTable(), 280 PP.getSelectorTable(), PP.getBuiltinInfo(), 281 /*size_reserve=*/ 0); 282 } 283 284 // ExternalASTSource 285 286 void CompilerInstance::createPCHExternalASTSource(StringRef Path, 287 bool DisablePCHValidation, 288 bool DisableStatCache, 289 void *DeserializationListener){ 290 llvm::OwningPtr<ExternalASTSource> Source; 291 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0; 292 Source.reset(createPCHExternalASTSource(Path, getHeaderSearchOpts().Sysroot, 293 DisablePCHValidation, 294 DisableStatCache, 295 getPreprocessor(), getASTContext(), 296 DeserializationListener, 297 Preamble)); 298 ModuleManager = static_cast<ASTReader*>(Source.get()); 299 getASTContext().setExternalSource(Source); 300 } 301 302 ExternalASTSource * 303 CompilerInstance::createPCHExternalASTSource(StringRef Path, 304 const std::string &Sysroot, 305 bool DisablePCHValidation, 306 bool DisableStatCache, 307 Preprocessor &PP, 308 ASTContext &Context, 309 void *DeserializationListener, 310 bool Preamble) { 311 llvm::OwningPtr<ASTReader> Reader; 312 Reader.reset(new ASTReader(PP, Context, 313 Sysroot.empty() ? "" : Sysroot.c_str(), 314 DisablePCHValidation, DisableStatCache)); 315 316 Reader->setDeserializationListener( 317 static_cast<ASTDeserializationListener *>(DeserializationListener)); 318 switch (Reader->ReadAST(Path, 319 Preamble ? serialization::MK_Preamble 320 : serialization::MK_PCH)) { 321 case ASTReader::Success: 322 // Set the predefines buffer as suggested by the PCH reader. Typically, the 323 // predefines buffer will be empty. 324 PP.setPredefines(Reader->getSuggestedPredefines()); 325 return Reader.take(); 326 327 case ASTReader::Failure: 328 // Unrecoverable failure: don't even try to process the input file. 329 break; 330 331 case ASTReader::IgnorePCH: 332 // No suitable PCH file could be found. Return an error. 333 break; 334 } 335 336 return 0; 337 } 338 339 // Code Completion 340 341 static bool EnableCodeCompletion(Preprocessor &PP, 342 const std::string &Filename, 343 unsigned Line, 344 unsigned Column) { 345 // Tell the source manager to chop off the given file at a specific 346 // line and column. 347 const FileEntry *Entry = PP.getFileManager().getFile(Filename); 348 if (!Entry) { 349 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file) 350 << Filename; 351 return true; 352 } 353 354 // Truncate the named file at the given line/column. 355 PP.SetCodeCompletionPoint(Entry, Line, Column); 356 return false; 357 } 358 359 void CompilerInstance::createCodeCompletionConsumer() { 360 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt; 361 if (!CompletionConsumer) { 362 CompletionConsumer.reset( 363 createCodeCompletionConsumer(getPreprocessor(), 364 Loc.FileName, Loc.Line, Loc.Column, 365 getFrontendOpts().ShowMacrosInCodeCompletion, 366 getFrontendOpts().ShowCodePatternsInCodeCompletion, 367 getFrontendOpts().ShowGlobalSymbolsInCodeCompletion, 368 llvm::outs())); 369 if (!CompletionConsumer) 370 return; 371 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName, 372 Loc.Line, Loc.Column)) { 373 CompletionConsumer.reset(); 374 return; 375 } 376 377 if (CompletionConsumer->isOutputBinary() && 378 llvm::sys::Program::ChangeStdoutToBinary()) { 379 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary); 380 CompletionConsumer.reset(); 381 } 382 } 383 384 void CompilerInstance::createFrontendTimer() { 385 FrontendTimer.reset(new llvm::Timer("Clang front-end timer")); 386 } 387 388 CodeCompleteConsumer * 389 CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP, 390 const std::string &Filename, 391 unsigned Line, 392 unsigned Column, 393 bool ShowMacros, 394 bool ShowCodePatterns, 395 bool ShowGlobals, 396 raw_ostream &OS) { 397 if (EnableCodeCompletion(PP, Filename, Line, Column)) 398 return 0; 399 400 // Set up the creation routine for code-completion. 401 return new PrintingCodeCompleteConsumer(ShowMacros, ShowCodePatterns, 402 ShowGlobals, OS); 403 } 404 405 void CompilerInstance::createSema(TranslationUnitKind TUKind, 406 CodeCompleteConsumer *CompletionConsumer) { 407 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(), 408 TUKind, CompletionConsumer)); 409 } 410 411 // Output Files 412 413 void CompilerInstance::addOutputFile(const OutputFile &OutFile) { 414 assert(OutFile.OS && "Attempt to add empty stream to output list!"); 415 OutputFiles.push_back(OutFile); 416 } 417 418 void CompilerInstance::clearOutputFiles(bool EraseFiles) { 419 for (std::list<OutputFile>::iterator 420 it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) { 421 delete it->OS; 422 if (!it->TempFilename.empty()) { 423 if (EraseFiles) { 424 bool existed; 425 llvm::sys::fs::remove(it->TempFilename, existed); 426 } else { 427 llvm::SmallString<128> NewOutFile(it->Filename); 428 429 // If '-working-directory' was passed, the output filename should be 430 // relative to that. 431 FileMgr->FixupRelativePath(NewOutFile); 432 if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename, 433 NewOutFile.str())) { 434 getDiagnostics().Report(diag::err_fe_unable_to_rename_temp) 435 << it->TempFilename << it->Filename << ec.message(); 436 437 bool existed; 438 llvm::sys::fs::remove(it->TempFilename, existed); 439 } 440 } 441 } else if (!it->Filename.empty() && EraseFiles) 442 llvm::sys::Path(it->Filename).eraseFromDisk(); 443 444 } 445 OutputFiles.clear(); 446 } 447 448 llvm::raw_fd_ostream * 449 CompilerInstance::createDefaultOutputFile(bool Binary, 450 StringRef InFile, 451 StringRef Extension) { 452 return createOutputFile(getFrontendOpts().OutputFile, Binary, 453 /*RemoveFileOnSignal=*/true, InFile, Extension); 454 } 455 456 llvm::raw_fd_ostream * 457 CompilerInstance::createOutputFile(StringRef OutputPath, 458 bool Binary, bool RemoveFileOnSignal, 459 StringRef InFile, 460 StringRef Extension, 461 bool UseTemporary) { 462 std::string Error, OutputPathName, TempPathName; 463 llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary, 464 RemoveFileOnSignal, 465 InFile, Extension, 466 UseTemporary, 467 &OutputPathName, 468 &TempPathName); 469 if (!OS) { 470 getDiagnostics().Report(diag::err_fe_unable_to_open_output) 471 << OutputPath << Error; 472 return 0; 473 } 474 475 // Add the output file -- but don't try to remove "-", since this means we are 476 // using stdin. 477 addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "", 478 TempPathName, OS)); 479 480 return OS; 481 } 482 483 llvm::raw_fd_ostream * 484 CompilerInstance::createOutputFile(StringRef OutputPath, 485 std::string &Error, 486 bool Binary, 487 bool RemoveFileOnSignal, 488 StringRef InFile, 489 StringRef Extension, 490 bool UseTemporary, 491 std::string *ResultPathName, 492 std::string *TempPathName) { 493 std::string OutFile, TempFile; 494 if (!OutputPath.empty()) { 495 OutFile = OutputPath; 496 } else if (InFile == "-") { 497 OutFile = "-"; 498 } else if (!Extension.empty()) { 499 llvm::sys::Path Path(InFile); 500 Path.eraseSuffix(); 501 Path.appendSuffix(Extension); 502 OutFile = Path.str(); 503 } else { 504 OutFile = "-"; 505 } 506 507 llvm::OwningPtr<llvm::raw_fd_ostream> OS; 508 std::string OSFile; 509 510 if (UseTemporary && OutFile != "-") { 511 llvm::sys::Path OutPath(OutFile); 512 // Only create the temporary if we can actually write to OutPath, otherwise 513 // we want to fail early. 514 bool Exists; 515 if ((llvm::sys::fs::exists(OutPath.str(), Exists) || !Exists) || 516 (OutPath.isRegularFile() && OutPath.canWrite())) { 517 // Create a temporary file. 518 llvm::SmallString<128> TempPath; 519 TempPath = OutFile; 520 TempPath += "-%%%%%%%%"; 521 int fd; 522 if (llvm::sys::fs::unique_file(TempPath.str(), fd, TempPath, 523 /*makeAbsolute=*/false) == llvm::errc::success) { 524 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true)); 525 OSFile = TempFile = TempPath.str(); 526 } 527 } 528 } 529 530 if (!OS) { 531 OSFile = OutFile; 532 OS.reset( 533 new llvm::raw_fd_ostream(OSFile.c_str(), Error, 534 (Binary ? llvm::raw_fd_ostream::F_Binary : 0))); 535 if (!Error.empty()) 536 return 0; 537 } 538 539 // Make sure the out stream file gets removed if we crash. 540 if (RemoveFileOnSignal) 541 llvm::sys::RemoveFileOnSignal(llvm::sys::Path(OSFile)); 542 543 if (ResultPathName) 544 *ResultPathName = OutFile; 545 if (TempPathName) 546 *TempPathName = TempFile; 547 548 return OS.take(); 549 } 550 551 // Initialization Utilities 552 553 bool CompilerInstance::InitializeSourceManager(StringRef InputFile) { 554 return InitializeSourceManager(InputFile, getDiagnostics(), getFileManager(), 555 getSourceManager(), getFrontendOpts()); 556 } 557 558 bool CompilerInstance::InitializeSourceManager(StringRef InputFile, 559 DiagnosticsEngine &Diags, 560 FileManager &FileMgr, 561 SourceManager &SourceMgr, 562 const FrontendOptions &Opts) { 563 // Figure out where to get and map in the main file. 564 if (InputFile != "-") { 565 const FileEntry *File = FileMgr.getFile(InputFile); 566 if (!File) { 567 Diags.Report(diag::err_fe_error_reading) << InputFile; 568 return false; 569 } 570 SourceMgr.createMainFileID(File); 571 } else { 572 llvm::OwningPtr<llvm::MemoryBuffer> SB; 573 if (llvm::MemoryBuffer::getSTDIN(SB)) { 574 // FIXME: Give ec.message() in this diag. 575 Diags.Report(diag::err_fe_error_reading_stdin); 576 return false; 577 } 578 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(), 579 SB->getBufferSize(), 0); 580 SourceMgr.createMainFileID(File); 581 SourceMgr.overrideFileContents(File, SB.take()); 582 } 583 584 assert(!SourceMgr.getMainFileID().isInvalid() && 585 "Couldn't establish MainFileID!"); 586 return true; 587 } 588 589 // High-Level Operations 590 591 bool CompilerInstance::ExecuteAction(FrontendAction &Act) { 592 assert(hasDiagnostics() && "Diagnostics engine is not initialized!"); 593 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!"); 594 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!"); 595 596 // FIXME: Take this as an argument, once all the APIs we used have moved to 597 // taking it as an input instead of hard-coding llvm::errs. 598 raw_ostream &OS = llvm::errs(); 599 600 // Create the target instance. 601 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), getTargetOpts())); 602 if (!hasTarget()) 603 return false; 604 605 // Inform the target of the language options. 606 // 607 // FIXME: We shouldn't need to do this, the target should be immutable once 608 // created. This complexity should be lifted elsewhere. 609 getTarget().setForcedLangOptions(getLangOpts()); 610 611 // Validate/process some options. 612 if (getHeaderSearchOpts().Verbose) 613 OS << "clang -cc1 version " CLANG_VERSION_STRING 614 << " based upon " << PACKAGE_STRING 615 << " hosted on " << llvm::sys::getHostTriple() << "\n"; 616 617 if (getFrontendOpts().ShowTimers) 618 createFrontendTimer(); 619 620 if (getFrontendOpts().ShowStats) 621 llvm::EnableStatistics(); 622 623 for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) { 624 const std::string &InFile = getFrontendOpts().Inputs[i].second; 625 626 // Reset the ID tables if we are reusing the SourceManager. 627 if (hasSourceManager()) 628 getSourceManager().clearIDTables(); 629 630 if (Act.BeginSourceFile(*this, InFile, getFrontendOpts().Inputs[i].first)) { 631 Act.Execute(); 632 Act.EndSourceFile(); 633 } 634 } 635 636 if (getDiagnosticOpts().ShowCarets) { 637 // We can have multiple diagnostics sharing one diagnostic client. 638 // Get the total number of warnings/errors from the client. 639 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings(); 640 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors(); 641 642 if (NumWarnings) 643 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s"); 644 if (NumWarnings && NumErrors) 645 OS << " and "; 646 if (NumErrors) 647 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s"); 648 if (NumWarnings || NumErrors) 649 OS << " generated.\n"; 650 } 651 652 if (getFrontendOpts().ShowStats && hasFileManager()) { 653 getFileManager().PrintStats(); 654 OS << "\n"; 655 } 656 657 return !getDiagnostics().getClient()->getNumErrors(); 658 } 659 660 /// \brief Determine the appropriate source input kind based on language 661 /// options. 662 static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) { 663 if (LangOpts.OpenCL) 664 return IK_OpenCL; 665 if (LangOpts.CUDA) 666 return IK_CUDA; 667 if (LangOpts.ObjC1) 668 return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC; 669 return LangOpts.CPlusPlus? IK_CXX : IK_C; 670 } 671 672 namespace { 673 struct CompileModuleData { 674 CompilerInstance &Instance; 675 GeneratePCHAction &CreateModuleAction; 676 }; 677 } 678 679 /// \brief Helper function that executes the module-generating action under 680 /// a crash recovery context. 681 static void doCompileModule(void *UserData) { 682 CompileModuleData &Data = *reinterpret_cast<CompileModuleData *>(UserData); 683 Data.Instance.ExecuteAction(Data.CreateModuleAction); 684 } 685 686 namespace { 687 /// \brief Class that manages the creation of a lock file to aid 688 /// implicit coordination between different processes. 689 /// 690 /// The implicit coordination works by creating a ".lock" file alongside 691 /// the file that we're coordinating for, using the atomicity of the file 692 /// system to ensure that only a single process can create that ".lock" file. 693 /// When the lock file is removed, the owning process has finished the 694 /// operation. 695 class LockFileManager { 696 public: 697 /// \brief Describes the state of a lock file. 698 enum LockFileState { 699 /// \brief The lock file has been created and is owned by this instance 700 /// of the object. 701 LFS_Owned, 702 /// \brief The lock file already exists and is owned by some other 703 /// instance. 704 LFS_Shared, 705 /// \brief An error occurred while trying to create or find the lock 706 /// file. 707 LFS_Error 708 }; 709 710 private: 711 llvm::SmallString<128> LockFileName; 712 llvm::SmallString<128> UniqueLockFileName; 713 714 llvm::Optional<std::pair<std::string, int> > Owner; 715 llvm::Optional<llvm::error_code> Error; 716 717 LockFileManager(const LockFileManager &); 718 LockFileManager &operator=(const LockFileManager &); 719 720 static llvm::Optional<std::pair<std::string, int> > 721 readLockFile(StringRef LockFileName); 722 723 static bool processStillExecuting(StringRef Hostname, int PID); 724 725 public: 726 727 LockFileManager(StringRef FileName); 728 ~LockFileManager(); 729 730 /// \brief Determine the state of the lock file. 731 LockFileState getState() const; 732 733 operator LockFileState() const { return getState(); } 734 735 /// \brief For a shared lock, wait until the owner releases the lock. 736 void waitForUnlock(); 737 }; 738 } 739 740 /// \brief Attempt to read the lock file with the given name, if it exists. 741 /// 742 /// \param LockFileName The name of the lock file to read. 743 /// 744 /// \returns The process ID of the process that owns this lock file 745 llvm::Optional<std::pair<std::string, int> > 746 LockFileManager::readLockFile(StringRef LockFileName) { 747 // Check whether the lock file exists. If not, clearly there's nothing 748 // to read, so we just return. 749 bool Exists = false; 750 if (llvm::sys::fs::exists(LockFileName, Exists) || !Exists) 751 return llvm::Optional<std::pair<std::string, int> >(); 752 753 // Read the owning host and PID out of the lock file. If it appears that the 754 // owning process is dead, the lock file is invalid. 755 int PID = 0; 756 std::string Hostname; 757 std::ifstream Input(LockFileName.str().c_str()); 758 if (Input >> Hostname >> PID && PID > 0 && 759 processStillExecuting(Hostname, PID)) 760 return std::make_pair(Hostname, PID); 761 762 // Delete the lock file. It's invalid anyway. 763 bool Existed; 764 llvm::sys::fs::remove(LockFileName, Existed); 765 return llvm::Optional<std::pair<std::string, int> >(); 766 } 767 768 bool LockFileManager::processStillExecuting(StringRef Hostname, int PID) { 769 #if LLVM_ON_UNIX 770 char MyHostname[256]; 771 MyHostname[255] = 0; 772 MyHostname[0] = 0; 773 gethostname(MyHostname, 255); 774 // Check whether the process is dead. If so, we're done. 775 if (MyHostname == Hostname && getsid(PID) == -1 && errno == ESRCH) 776 return false; 777 #endif 778 779 return true; 780 } 781 782 LockFileManager::LockFileManager(StringRef FileName) 783 { 784 LockFileName = FileName; 785 LockFileName += ".lock"; 786 787 // If the lock file already exists, don't bother to try to create our own 788 // lock file; it won't work anyway. Just figure out who owns this lock file. 789 if ((Owner = readLockFile(LockFileName))) 790 return; 791 792 // Create a lock file that is unique to this instance. 793 UniqueLockFileName = LockFileName; 794 UniqueLockFileName += "-%%%%%%%%"; 795 int UniqueLockFileID; 796 if (llvm::error_code EC 797 = llvm::sys::fs::unique_file(UniqueLockFileName.str(), 798 UniqueLockFileID, 799 UniqueLockFileName, 800 /*makeAbsolute=*/false)) { 801 Error = EC; 802 return; 803 } 804 805 // Write our process ID to our unique lock file. 806 { 807 llvm::raw_fd_ostream Out(UniqueLockFileID, /*shouldClose=*/true); 808 809 #if LLVM_ON_UNIX 810 // FIXME: move getpid() call into LLVM 811 char hostname[256]; 812 hostname[255] = 0; 813 hostname[0] = 0; 814 gethostname(hostname, 255); 815 Out << hostname << ' ' << getpid(); 816 #else 817 Out << "localhost 1"; 818 #endif 819 Out.close(); 820 821 if (Out.has_error()) { 822 // We failed to write out PID, so make up an excuse, remove the 823 // unique lock file, and fail. 824 Error = llvm::make_error_code(llvm::errc::no_space_on_device); 825 bool Existed; 826 llvm::sys::fs::remove(UniqueLockFileName.c_str(), Existed); 827 return; 828 } 829 } 830 831 // Create a hard link from the lock file name. If this succeeds, we're done. 832 llvm::error_code EC 833 = llvm::sys::fs::create_hard_link(UniqueLockFileName.str(), 834 LockFileName.str()); 835 if (EC == llvm::errc::success) 836 return; 837 838 // Creating the hard link failed. 839 840 #ifdef LLVM_ON_UNIX 841 // The creation of the hard link may appear to fail, but if stat'ing the 842 // unique file returns a link count of 2, then we can still declare success. 843 struct stat StatBuf; 844 if (stat(UniqueLockFileName.c_str(), &StatBuf) == 0 && 845 StatBuf.st_nlink == 2) 846 return; 847 #endif 848 849 // Someone else managed to create the lock file first. Wipe out our unique 850 // lock file (it's useless now) and read the process ID from the lock file. 851 bool Existed; 852 llvm::sys::fs::remove(UniqueLockFileName.str(), Existed); 853 if ((Owner = readLockFile(LockFileName))) 854 return; 855 856 // There is a lock file that nobody owns; try to clean it up and report 857 // an error. 858 llvm::sys::fs::remove(LockFileName.str(), Existed); 859 Error = EC; 860 } 861 862 LockFileManager::LockFileState LockFileManager::getState() const { 863 if (Owner) 864 return LFS_Shared; 865 866 if (Error) 867 return LFS_Error; 868 869 return LFS_Owned; 870 } 871 872 LockFileManager::~LockFileManager() { 873 if (getState() != LFS_Owned) 874 return; 875 876 // Since we own the lock, remove the lock file and our own unique lock file. 877 bool Existed; 878 llvm::sys::fs::remove(LockFileName.str(), Existed); 879 llvm::sys::fs::remove(UniqueLockFileName.str(), Existed); 880 } 881 882 void LockFileManager::waitForUnlock() { 883 if (getState() != LFS_Shared) 884 return; 885 886 #if LLVM_ON_WIN32 887 unsigned long Interval = 1; 888 #else 889 struct timespec Interval; 890 Interval.tv_sec = 0; 891 Interval.tv_nsec = 1000000; 892 #endif 893 // Don't wait more than an hour for the file to appear. 894 const unsigned MaxSeconds = 3600; 895 do { 896 // Sleep for the designated interval, to allow the owning process time to 897 // finish up and 898 // FIXME: Should we hook in to system APIs to get a notification when the 899 // lock file is deleted? 900 #if LLVM_ON_WIN32 901 Sleep(Interval); 902 #else 903 nanosleep(&Interval, NULL); 904 #endif 905 // If the file no longer exists, we're done. 906 bool Exists = false; 907 if (!llvm::sys::fs::exists(LockFileName.str(), Exists) && !Exists) 908 return; 909 910 if (!processStillExecuting((*Owner).first, (*Owner).second)) 911 return; 912 913 // Exponentially increase the time we wait for the lock to be removed. 914 #if LLVM_ON_WIN32 915 Interval *= 2; 916 #else 917 Interval.tv_sec *= 2; 918 Interval.tv_nsec *= 2; 919 if (Interval.tv_nsec >= 1000000000) { 920 ++Interval.tv_sec; 921 Interval.tv_nsec -= 1000000000; 922 } 923 #endif 924 } while ( 925 #if LLVM_ON_WIN32 926 Interval < MaxSeconds * 1000 927 #else 928 Interval.tv_sec < (time_t)MaxSeconds 929 #endif 930 ); 931 932 // Give up. 933 } 934 935 /// \brief Compile a module file for the given module name with the given 936 /// umbrella header, using the options provided by the importing compiler 937 /// instance. 938 static void compileModule(CompilerInstance &ImportingInstance, 939 StringRef ModuleName, 940 StringRef ModuleFileName, 941 StringRef UmbrellaHeader) { 942 LockFileManager Locked(ModuleFileName); 943 switch (Locked) { 944 case LockFileManager::LFS_Error: 945 return; 946 947 case LockFileManager::LFS_Owned: 948 // We're responsible for building the module ourselves. Do so below. 949 break; 950 951 case LockFileManager::LFS_Shared: 952 // Someone else is responsible for building the module. Wait for them to 953 // finish. 954 Locked.waitForUnlock(); 955 break; 956 } 957 958 // Construct a compiler invocation for creating this module. 959 llvm::IntrusiveRefCntPtr<CompilerInvocation> Invocation 960 (new CompilerInvocation(ImportingInstance.getInvocation())); 961 962 // For any options that aren't intended to affect how a module is built, 963 // reset them to their default values. 964 Invocation->getLangOpts().resetNonModularOptions(); 965 Invocation->getPreprocessorOpts().resetNonModularOptions(); 966 967 // Note that this module is part of the module build path, so that we 968 // can detect cycles in the module graph. 969 Invocation->getPreprocessorOpts().ModuleBuildPath.push_back(ModuleName); 970 971 // Set up the inputs/outputs so that we build the module from its umbrella 972 // header. 973 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts(); 974 FrontendOpts.OutputFile = ModuleFileName.str(); 975 FrontendOpts.DisableFree = false; 976 FrontendOpts.Inputs.clear(); 977 FrontendOpts.Inputs.push_back( 978 std::make_pair(getSourceInputKindFromOptions(Invocation->getLangOpts()), 979 UmbrellaHeader)); 980 981 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0; 982 983 984 assert(ImportingInstance.getInvocation().getModuleHash() == 985 Invocation->getModuleHash() && "Module hash mismatch!"); 986 987 // Construct a compiler instance that will be used to actually create the 988 // module. 989 CompilerInstance Instance; 990 Instance.setInvocation(&*Invocation); 991 Instance.createDiagnostics(/*argc=*/0, /*argv=*/0, 992 &ImportingInstance.getDiagnosticClient(), 993 /*ShouldOwnClient=*/true, 994 /*ShouldCloneClient=*/true); 995 996 // Construct a module-generating action. 997 GeneratePCHAction CreateModuleAction(true); 998 999 // Execute the action to actually build the module in-place. Use a separate 1000 // thread so that we get a stack large enough. 1001 const unsigned ThreadStackSize = 8 << 20; 1002 llvm::CrashRecoveryContext CRC; 1003 CompileModuleData Data = { Instance, CreateModuleAction }; 1004 CRC.RunSafelyOnThread(&doCompileModule, &Data, ThreadStackSize); 1005 } 1006 1007 ModuleKey CompilerInstance::loadModule(SourceLocation ImportLoc, 1008 IdentifierInfo &ModuleName, 1009 SourceLocation ModuleNameLoc) { 1010 // Determine what file we're searching from. 1011 SourceManager &SourceMgr = getSourceManager(); 1012 SourceLocation ExpandedImportLoc = SourceMgr.getExpansionLoc(ImportLoc); 1013 const FileEntry *CurFile 1014 = SourceMgr.getFileEntryForID(SourceMgr.getFileID(ExpandedImportLoc)); 1015 if (!CurFile) 1016 CurFile = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID()); 1017 1018 // Search for a module with the given name. 1019 std::string UmbrellaHeader; 1020 std::string ModuleFileName; 1021 const FileEntry *ModuleFile 1022 = PP->getHeaderSearchInfo().lookupModule(ModuleName.getName(), 1023 &ModuleFileName, 1024 &UmbrellaHeader); 1025 1026 bool BuildingModule = false; 1027 if (!ModuleFile && !UmbrellaHeader.empty()) { 1028 // We didn't find the module, but there is an umbrella header that 1029 // can be used to create the module file. Create a separate compilation 1030 // module to do so. 1031 1032 // Check whether there is a cycle in the module graph. 1033 SmallVectorImpl<std::string> &ModuleBuildPath 1034 = getPreprocessorOpts().ModuleBuildPath; 1035 SmallVectorImpl<std::string>::iterator Pos 1036 = std::find(ModuleBuildPath.begin(), ModuleBuildPath.end(), 1037 ModuleName.getName()); 1038 if (Pos != ModuleBuildPath.end()) { 1039 llvm::SmallString<256> CyclePath; 1040 for (; Pos != ModuleBuildPath.end(); ++Pos) { 1041 CyclePath += *Pos; 1042 CyclePath += " -> "; 1043 } 1044 CyclePath += ModuleName.getName(); 1045 1046 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle) 1047 << ModuleName.getName() << CyclePath; 1048 return 0; 1049 } 1050 1051 getDiagnostics().Report(ModuleNameLoc, diag::warn_module_build) 1052 << ModuleName.getName(); 1053 BuildingModule = true; 1054 compileModule(*this, ModuleName.getName(), ModuleFileName, UmbrellaHeader); 1055 ModuleFile = PP->getHeaderSearchInfo().lookupModule(ModuleName.getName()); 1056 } 1057 1058 if (!ModuleFile) { 1059 getDiagnostics().Report(ModuleNameLoc, 1060 BuildingModule? diag::err_module_not_built 1061 : diag::err_module_not_found) 1062 << ModuleName.getName() 1063 << SourceRange(ImportLoc, ModuleNameLoc); 1064 return 0; 1065 } 1066 1067 // If we don't already have an ASTReader, create one now. 1068 if (!ModuleManager) { 1069 if (!hasASTContext()) 1070 createASTContext(); 1071 1072 std::string Sysroot = getHeaderSearchOpts().Sysroot; 1073 const PreprocessorOptions &PPOpts = getPreprocessorOpts(); 1074 ModuleManager = new ASTReader(getPreprocessor(), *Context, 1075 Sysroot.empty() ? "" : Sysroot.c_str(), 1076 PPOpts.DisablePCHValidation, 1077 PPOpts.DisableStatCache); 1078 if (hasASTConsumer()) { 1079 ModuleManager->setDeserializationListener( 1080 getASTConsumer().GetASTDeserializationListener()); 1081 getASTContext().setASTMutationListener( 1082 getASTConsumer().GetASTMutationListener()); 1083 } 1084 llvm::OwningPtr<ExternalASTSource> Source; 1085 Source.reset(ModuleManager); 1086 getASTContext().setExternalSource(Source); 1087 if (hasSema()) 1088 ModuleManager->InitializeSema(getSema()); 1089 if (hasASTConsumer()) 1090 ModuleManager->StartTranslationUnit(&getASTConsumer()); 1091 } 1092 1093 // Try to load the module we found. 1094 switch (ModuleManager->ReadAST(ModuleFile->getName(), 1095 serialization::MK_Module)) { 1096 case ASTReader::Success: 1097 break; 1098 1099 case ASTReader::IgnorePCH: 1100 // FIXME: The ASTReader will already have complained, but can we showhorn 1101 // that diagnostic information into a more useful form? 1102 return 0; 1103 1104 case ASTReader::Failure: 1105 // Already complained. 1106 return 0; 1107 } 1108 1109 // FIXME: The module file's FileEntry makes a poor key indeed! 1110 return (ModuleKey)ModuleFile; 1111 } 1112 1113