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/AST/ASTConsumer.h" 12 #include "clang/AST/ASTContext.h" 13 #include "clang/AST/Decl.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/Frontend/ChainedDiagnosticConsumer.h" 20 #include "clang/Frontend/FrontendAction.h" 21 #include "clang/Frontend/FrontendActions.h" 22 #include "clang/Frontend/FrontendDiagnostic.h" 23 #include "clang/Frontend/LogDiagnosticPrinter.h" 24 #include "clang/Frontend/SerializedDiagnosticPrinter.h" 25 #include "clang/Frontend/TextDiagnosticPrinter.h" 26 #include "clang/Frontend/Utils.h" 27 #include "clang/Frontend/VerifyDiagnosticConsumer.h" 28 #include "clang/Lex/HeaderSearch.h" 29 #include "clang/Lex/PTHManager.h" 30 #include "clang/Lex/Preprocessor.h" 31 #include "clang/Sema/CodeCompleteConsumer.h" 32 #include "clang/Sema/Sema.h" 33 #include "clang/Serialization/ASTReader.h" 34 #include "clang/Serialization/GlobalModuleIndex.h" 35 #include "llvm/ADT/Statistic.h" 36 #include "llvm/Config/config.h" 37 #include "llvm/Support/CrashRecoveryContext.h" 38 #include "llvm/Support/FileSystem.h" 39 #include "llvm/Support/Host.h" 40 #include "llvm/Support/LockFileManager.h" 41 #include "llvm/Support/MemoryBuffer.h" 42 #include "llvm/Support/Path.h" 43 #include "llvm/Support/Program.h" 44 #include "llvm/Support/Signals.h" 45 #include "llvm/Support/Timer.h" 46 #include "llvm/Support/raw_ostream.h" 47 #include "llvm/Support/system_error.h" 48 #include <sys/stat.h> 49 #include <time.h> 50 51 using namespace clang; 52 53 CompilerInstance::CompilerInstance(bool BuildingModule) 54 : ModuleLoader(BuildingModule), 55 Invocation(new CompilerInvocation()), ModuleManager(0), 56 BuildGlobalModuleIndex(false), HaveFullGlobalModuleIndex(false), 57 ModuleBuildFailed(false) { 58 } 59 60 CompilerInstance::~CompilerInstance() { 61 assert(OutputFiles.empty() && "Still output files in flight?"); 62 } 63 64 void CompilerInstance::setInvocation(CompilerInvocation *Value) { 65 Invocation = Value; 66 } 67 68 bool CompilerInstance::shouldBuildGlobalModuleIndex() const { 69 return (BuildGlobalModuleIndex || 70 (ModuleManager && ModuleManager->isGlobalIndexUnavailable() && 71 getFrontendOpts().GenerateGlobalModuleIndex)) && 72 !ModuleBuildFailed; 73 } 74 75 void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) { 76 Diagnostics = Value; 77 } 78 79 void CompilerInstance::setTarget(TargetInfo *Value) { 80 Target = Value; 81 } 82 83 void CompilerInstance::setFileManager(FileManager *Value) { 84 FileMgr = Value; 85 if (Value) 86 VirtualFileSystem = Value->getVirtualFileSystem(); 87 else 88 VirtualFileSystem.reset(); 89 } 90 91 void CompilerInstance::setSourceManager(SourceManager *Value) { 92 SourceMgr = Value; 93 } 94 95 void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; } 96 97 void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; } 98 99 void CompilerInstance::setSema(Sema *S) { 100 TheSema.reset(S); 101 } 102 103 void CompilerInstance::setASTConsumer(ASTConsumer *Value) { 104 Consumer.reset(Value); 105 } 106 107 void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) { 108 CompletionConsumer.reset(Value); 109 } 110 111 IntrusiveRefCntPtr<ASTReader> CompilerInstance::getModuleManager() const { 112 return ModuleManager; 113 } 114 void CompilerInstance::setModuleManager(IntrusiveRefCntPtr<ASTReader> Reader) { 115 ModuleManager = Reader; 116 } 117 118 // Diagnostics 119 static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts, 120 const CodeGenOptions *CodeGenOpts, 121 DiagnosticsEngine &Diags) { 122 std::string ErrorInfo; 123 bool OwnsStream = false; 124 raw_ostream *OS = &llvm::errs(); 125 if (DiagOpts->DiagnosticLogFile != "-") { 126 // Create the output stream. 127 llvm::raw_fd_ostream *FileOS(new llvm::raw_fd_ostream( 128 DiagOpts->DiagnosticLogFile.c_str(), ErrorInfo, 129 llvm::sys::fs::F_Append | llvm::sys::fs::F_Text)); 130 if (!ErrorInfo.empty()) { 131 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure) 132 << DiagOpts->DiagnosticLogFile << ErrorInfo; 133 } else { 134 FileOS->SetUnbuffered(); 135 FileOS->SetUseAtomicWrites(true); 136 OS = FileOS; 137 OwnsStream = true; 138 } 139 } 140 141 // Chain in the diagnostic client which will log the diagnostics. 142 LogDiagnosticPrinter *Logger = new LogDiagnosticPrinter(*OS, DiagOpts, 143 OwnsStream); 144 if (CodeGenOpts) 145 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags); 146 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger)); 147 } 148 149 static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts, 150 DiagnosticsEngine &Diags, 151 StringRef OutputFile) { 152 std::string ErrorInfo; 153 std::unique_ptr<llvm::raw_fd_ostream> OS; 154 OS.reset(new llvm::raw_fd_ostream(OutputFile.str().c_str(), ErrorInfo, 155 llvm::sys::fs::F_None)); 156 157 if (!ErrorInfo.empty()) { 158 Diags.Report(diag::warn_fe_serialized_diag_failure) 159 << OutputFile << ErrorInfo; 160 return; 161 } 162 163 DiagnosticConsumer *SerializedConsumer = 164 clang::serialized_diags::create(OS.release(), DiagOpts); 165 166 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), 167 SerializedConsumer)); 168 } 169 170 void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client, 171 bool ShouldOwnClient) { 172 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client, 173 ShouldOwnClient, &getCodeGenOpts()); 174 } 175 176 IntrusiveRefCntPtr<DiagnosticsEngine> 177 CompilerInstance::createDiagnostics(DiagnosticOptions *Opts, 178 DiagnosticConsumer *Client, 179 bool ShouldOwnClient, 180 const CodeGenOptions *CodeGenOpts) { 181 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); 182 IntrusiveRefCntPtr<DiagnosticsEngine> 183 Diags(new DiagnosticsEngine(DiagID, Opts)); 184 185 // Create the diagnostic client for reporting errors or for 186 // implementing -verify. 187 if (Client) { 188 Diags->setClient(Client, ShouldOwnClient); 189 } else 190 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts)); 191 192 // Chain in -verify checker, if requested. 193 if (Opts->VerifyDiagnostics) 194 Diags->setClient(new VerifyDiagnosticConsumer(*Diags)); 195 196 // Chain in -diagnostic-log-file dumper, if requested. 197 if (!Opts->DiagnosticLogFile.empty()) 198 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags); 199 200 if (!Opts->DiagnosticSerializationFile.empty()) 201 SetupSerializedDiagnostics(Opts, *Diags, 202 Opts->DiagnosticSerializationFile); 203 204 // Configure our handling of diagnostics. 205 ProcessWarningOptions(*Diags, *Opts); 206 207 return Diags; 208 } 209 210 // File Manager 211 212 void CompilerInstance::createFileManager() { 213 if (!hasVirtualFileSystem()) { 214 // TODO: choose the virtual file system based on the CompilerInvocation. 215 setVirtualFileSystem(vfs::getRealFileSystem()); 216 } 217 FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem); 218 } 219 220 // Source Manager 221 222 void CompilerInstance::createSourceManager(FileManager &FileMgr) { 223 SourceMgr = new SourceManager(getDiagnostics(), FileMgr); 224 } 225 226 // Preprocessor 227 228 void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) { 229 const PreprocessorOptions &PPOpts = getPreprocessorOpts(); 230 231 // Create a PTH manager if we are using some form of a token cache. 232 PTHManager *PTHMgr = 0; 233 if (!PPOpts.TokenCache.empty()) 234 PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics()); 235 236 // Create the Preprocessor. 237 HeaderSearch *HeaderInfo = new HeaderSearch(&getHeaderSearchOpts(), 238 getSourceManager(), 239 getDiagnostics(), 240 getLangOpts(), 241 &getTarget()); 242 PP = new Preprocessor(&getPreprocessorOpts(), 243 getDiagnostics(), getLangOpts(), &getTarget(), 244 getSourceManager(), *HeaderInfo, *this, PTHMgr, 245 /*OwnsHeaderSearch=*/true, 246 /*DelayInitialization=*/false, 247 /*IncrProcessing=*/false, 248 TUKind); 249 250 // Note that this is different then passing PTHMgr to Preprocessor's ctor. 251 // That argument is used as the IdentifierInfoLookup argument to 252 // IdentifierTable's ctor. 253 if (PTHMgr) { 254 PTHMgr->setPreprocessor(&*PP); 255 PP->setPTHManager(PTHMgr); 256 } 257 258 if (PPOpts.DetailedRecord) 259 PP->createPreprocessingRecord(); 260 261 InitializePreprocessor(*PP, PPOpts, getHeaderSearchOpts(), getFrontendOpts()); 262 263 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP); 264 265 // Set up the module path, including the hash for the 266 // module-creation options. 267 SmallString<256> SpecificModuleCache( 268 getHeaderSearchOpts().ModuleCachePath); 269 if (!getHeaderSearchOpts().DisableModuleHash) 270 llvm::sys::path::append(SpecificModuleCache, 271 getInvocation().getModuleHash()); 272 PP->getHeaderSearchInfo().setModuleCachePath(SpecificModuleCache); 273 274 // Handle generating dependencies, if requested. 275 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts(); 276 if (!DepOpts.OutputFile.empty()) 277 TheDependencyFileGenerator.reset( 278 DependencyFileGenerator::CreateAndAttachToPreprocessor(*PP, DepOpts)); 279 if (!DepOpts.DOTOutputFile.empty()) 280 AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile, 281 getHeaderSearchOpts().Sysroot); 282 283 284 // Handle generating header include information, if requested. 285 if (DepOpts.ShowHeaderIncludes) 286 AttachHeaderIncludeGen(*PP); 287 if (!DepOpts.HeaderIncludeOutputFile.empty()) { 288 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile; 289 if (OutputPath == "-") 290 OutputPath = ""; 291 AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath, 292 /*ShowDepth=*/false); 293 } 294 295 if (DepOpts.PrintShowIncludes) { 296 AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/false, /*OutputPath=*/"", 297 /*ShowDepth=*/true, /*MSStyle=*/true); 298 } 299 } 300 301 // ASTContext 302 303 void CompilerInstance::createASTContext() { 304 Preprocessor &PP = getPreprocessor(); 305 Context = new ASTContext(getLangOpts(), PP.getSourceManager(), 306 &getTarget(), PP.getIdentifierTable(), 307 PP.getSelectorTable(), PP.getBuiltinInfo(), 308 /*size_reserve=*/ 0); 309 } 310 311 // ExternalASTSource 312 313 void CompilerInstance::createPCHExternalASTSource(StringRef Path, 314 bool DisablePCHValidation, 315 bool AllowPCHWithCompilerErrors, 316 void *DeserializationListener){ 317 IntrusiveRefCntPtr<ExternalASTSource> Source; 318 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0; 319 Source = createPCHExternalASTSource(Path, getHeaderSearchOpts().Sysroot, 320 DisablePCHValidation, 321 AllowPCHWithCompilerErrors, 322 getPreprocessor(), getASTContext(), 323 DeserializationListener, 324 Preamble, 325 getFrontendOpts().UseGlobalModuleIndex); 326 ModuleManager = static_cast<ASTReader*>(Source.getPtr()); 327 getASTContext().setExternalSource(Source); 328 } 329 330 ExternalASTSource * 331 CompilerInstance::createPCHExternalASTSource(StringRef Path, 332 const std::string &Sysroot, 333 bool DisablePCHValidation, 334 bool AllowPCHWithCompilerErrors, 335 Preprocessor &PP, 336 ASTContext &Context, 337 void *DeserializationListener, 338 bool Preamble, 339 bool UseGlobalModuleIndex) { 340 HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts(); 341 342 std::unique_ptr<ASTReader> Reader; 343 Reader.reset(new ASTReader(PP, Context, 344 Sysroot.empty() ? "" : Sysroot.c_str(), 345 DisablePCHValidation, 346 AllowPCHWithCompilerErrors, 347 /*AllowConfigurationMismatch*/false, 348 HSOpts.ModulesValidateSystemHeaders, 349 UseGlobalModuleIndex)); 350 351 Reader->setDeserializationListener( 352 static_cast<ASTDeserializationListener *>(DeserializationListener)); 353 switch (Reader->ReadAST(Path, 354 Preamble ? serialization::MK_Preamble 355 : serialization::MK_PCH, 356 SourceLocation(), 357 ASTReader::ARR_None)) { 358 case ASTReader::Success: 359 // Set the predefines buffer as suggested by the PCH reader. Typically, the 360 // predefines buffer will be empty. 361 PP.setPredefines(Reader->getSuggestedPredefines()); 362 return Reader.release(); 363 364 case ASTReader::Failure: 365 // Unrecoverable failure: don't even try to process the input file. 366 break; 367 368 case ASTReader::Missing: 369 case ASTReader::OutOfDate: 370 case ASTReader::VersionMismatch: 371 case ASTReader::ConfigurationMismatch: 372 case ASTReader::HadErrors: 373 // No suitable PCH file could be found. Return an error. 374 break; 375 } 376 377 return 0; 378 } 379 380 // Code Completion 381 382 static bool EnableCodeCompletion(Preprocessor &PP, 383 const std::string &Filename, 384 unsigned Line, 385 unsigned Column) { 386 // Tell the source manager to chop off the given file at a specific 387 // line and column. 388 const FileEntry *Entry = PP.getFileManager().getFile(Filename); 389 if (!Entry) { 390 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file) 391 << Filename; 392 return true; 393 } 394 395 // Truncate the named file at the given line/column. 396 PP.SetCodeCompletionPoint(Entry, Line, Column); 397 return false; 398 } 399 400 void CompilerInstance::createCodeCompletionConsumer() { 401 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt; 402 if (!CompletionConsumer) { 403 setCodeCompletionConsumer( 404 createCodeCompletionConsumer(getPreprocessor(), 405 Loc.FileName, Loc.Line, Loc.Column, 406 getFrontendOpts().CodeCompleteOpts, 407 llvm::outs())); 408 if (!CompletionConsumer) 409 return; 410 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName, 411 Loc.Line, Loc.Column)) { 412 setCodeCompletionConsumer(0); 413 return; 414 } 415 416 if (CompletionConsumer->isOutputBinary() && 417 llvm::sys::ChangeStdoutToBinary()) { 418 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary); 419 setCodeCompletionConsumer(0); 420 } 421 } 422 423 void CompilerInstance::createFrontendTimer() { 424 FrontendTimer.reset(new llvm::Timer("Clang front-end timer")); 425 } 426 427 CodeCompleteConsumer * 428 CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP, 429 const std::string &Filename, 430 unsigned Line, 431 unsigned Column, 432 const CodeCompleteOptions &Opts, 433 raw_ostream &OS) { 434 if (EnableCodeCompletion(PP, Filename, Line, Column)) 435 return 0; 436 437 // Set up the creation routine for code-completion. 438 return new PrintingCodeCompleteConsumer(Opts, OS); 439 } 440 441 void CompilerInstance::createSema(TranslationUnitKind TUKind, 442 CodeCompleteConsumer *CompletionConsumer) { 443 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(), 444 TUKind, CompletionConsumer)); 445 } 446 447 // Output Files 448 449 void CompilerInstance::addOutputFile(const OutputFile &OutFile) { 450 assert(OutFile.OS && "Attempt to add empty stream to output list!"); 451 OutputFiles.push_back(OutFile); 452 } 453 454 void CompilerInstance::clearOutputFiles(bool EraseFiles) { 455 for (std::list<OutputFile>::iterator 456 it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) { 457 delete it->OS; 458 if (!it->TempFilename.empty()) { 459 if (EraseFiles) { 460 llvm::sys::fs::remove(it->TempFilename); 461 } else { 462 SmallString<128> NewOutFile(it->Filename); 463 464 // If '-working-directory' was passed, the output filename should be 465 // relative to that. 466 FileMgr->FixupRelativePath(NewOutFile); 467 if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename, 468 NewOutFile.str())) { 469 getDiagnostics().Report(diag::err_unable_to_rename_temp) 470 << it->TempFilename << it->Filename << ec.message(); 471 472 llvm::sys::fs::remove(it->TempFilename); 473 } 474 } 475 } else if (!it->Filename.empty() && EraseFiles) 476 llvm::sys::fs::remove(it->Filename); 477 478 } 479 OutputFiles.clear(); 480 } 481 482 llvm::raw_fd_ostream * 483 CompilerInstance::createDefaultOutputFile(bool Binary, 484 StringRef InFile, 485 StringRef Extension) { 486 return createOutputFile(getFrontendOpts().OutputFile, Binary, 487 /*RemoveFileOnSignal=*/true, InFile, Extension, 488 /*UseTemporary=*/true); 489 } 490 491 llvm::raw_fd_ostream * 492 CompilerInstance::createOutputFile(StringRef OutputPath, 493 bool Binary, bool RemoveFileOnSignal, 494 StringRef InFile, 495 StringRef Extension, 496 bool UseTemporary, 497 bool CreateMissingDirectories) { 498 std::string Error, OutputPathName, TempPathName; 499 llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary, 500 RemoveFileOnSignal, 501 InFile, Extension, 502 UseTemporary, 503 CreateMissingDirectories, 504 &OutputPathName, 505 &TempPathName); 506 if (!OS) { 507 getDiagnostics().Report(diag::err_fe_unable_to_open_output) 508 << OutputPath << Error; 509 return 0; 510 } 511 512 // Add the output file -- but don't try to remove "-", since this means we are 513 // using stdin. 514 addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "", 515 TempPathName, OS)); 516 517 return OS; 518 } 519 520 llvm::raw_fd_ostream * 521 CompilerInstance::createOutputFile(StringRef OutputPath, 522 std::string &Error, 523 bool Binary, 524 bool RemoveFileOnSignal, 525 StringRef InFile, 526 StringRef Extension, 527 bool UseTemporary, 528 bool CreateMissingDirectories, 529 std::string *ResultPathName, 530 std::string *TempPathName) { 531 assert((!CreateMissingDirectories || UseTemporary) && 532 "CreateMissingDirectories is only allowed when using temporary files"); 533 534 std::string OutFile, TempFile; 535 if (!OutputPath.empty()) { 536 OutFile = OutputPath; 537 } else if (InFile == "-") { 538 OutFile = "-"; 539 } else if (!Extension.empty()) { 540 SmallString<128> Path(InFile); 541 llvm::sys::path::replace_extension(Path, Extension); 542 OutFile = Path.str(); 543 } else { 544 OutFile = "-"; 545 } 546 547 std::unique_ptr<llvm::raw_fd_ostream> OS; 548 std::string OSFile; 549 550 if (UseTemporary) { 551 if (OutFile == "-") 552 UseTemporary = false; 553 else { 554 llvm::sys::fs::file_status Status; 555 llvm::sys::fs::status(OutputPath, Status); 556 if (llvm::sys::fs::exists(Status)) { 557 // Fail early if we can't write to the final destination. 558 if (!llvm::sys::fs::can_write(OutputPath)) 559 return 0; 560 561 // Don't use a temporary if the output is a special file. This handles 562 // things like '-o /dev/null' 563 if (!llvm::sys::fs::is_regular_file(Status)) 564 UseTemporary = false; 565 } 566 } 567 } 568 569 if (UseTemporary) { 570 // Create a temporary file. 571 SmallString<128> TempPath; 572 TempPath = OutFile; 573 TempPath += "-%%%%%%%%"; 574 int fd; 575 llvm::error_code EC = 576 llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath); 577 578 if (CreateMissingDirectories && 579 EC == llvm::errc::no_such_file_or_directory) { 580 StringRef Parent = llvm::sys::path::parent_path(OutputPath); 581 EC = llvm::sys::fs::create_directories(Parent); 582 if (!EC) { 583 EC = llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath); 584 } 585 } 586 587 if (!EC) { 588 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true)); 589 OSFile = TempFile = TempPath.str(); 590 } 591 // If we failed to create the temporary, fallback to writing to the file 592 // directly. This handles the corner case where we cannot write to the 593 // directory, but can write to the file. 594 } 595 596 if (!OS) { 597 OSFile = OutFile; 598 OS.reset(new llvm::raw_fd_ostream( 599 OSFile.c_str(), Error, 600 (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text))); 601 if (!Error.empty()) 602 return 0; 603 } 604 605 // Make sure the out stream file gets removed if we crash. 606 if (RemoveFileOnSignal) 607 llvm::sys::RemoveFileOnSignal(OSFile); 608 609 if (ResultPathName) 610 *ResultPathName = OutFile; 611 if (TempPathName) 612 *TempPathName = TempFile; 613 614 return OS.release(); 615 } 616 617 // Initialization Utilities 618 619 bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){ 620 return InitializeSourceManager(Input, getDiagnostics(), 621 getFileManager(), getSourceManager(), 622 getFrontendOpts()); 623 } 624 625 bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input, 626 DiagnosticsEngine &Diags, 627 FileManager &FileMgr, 628 SourceManager &SourceMgr, 629 const FrontendOptions &Opts) { 630 SrcMgr::CharacteristicKind 631 Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User; 632 633 if (Input.isBuffer()) { 634 SourceMgr.createMainFileIDForMemBuffer(Input.getBuffer(), Kind); 635 assert(!SourceMgr.getMainFileID().isInvalid() && 636 "Couldn't establish MainFileID!"); 637 return true; 638 } 639 640 StringRef InputFile = Input.getFile(); 641 642 // Figure out where to get and map in the main file. 643 if (InputFile != "-") { 644 const FileEntry *File = FileMgr.getFile(InputFile, /*OpenFile=*/true); 645 if (!File) { 646 Diags.Report(diag::err_fe_error_reading) << InputFile; 647 return false; 648 } 649 650 // The natural SourceManager infrastructure can't currently handle named 651 // pipes, but we would at least like to accept them for the main 652 // file. Detect them here, read them with the volatile flag so FileMgr will 653 // pick up the correct size, and simply override their contents as we do for 654 // STDIN. 655 if (File->isNamedPipe()) { 656 std::string ErrorStr; 657 if (llvm::MemoryBuffer *MB = 658 FileMgr.getBufferForFile(File, &ErrorStr, /*isVolatile=*/true)) { 659 // Create a new virtual file that will have the correct size. 660 File = FileMgr.getVirtualFile(InputFile, MB->getBufferSize(), 0); 661 SourceMgr.overrideFileContents(File, MB); 662 } else { 663 Diags.Report(diag::err_cannot_open_file) << InputFile << ErrorStr; 664 return false; 665 } 666 } 667 668 SourceMgr.createMainFileID(File, Kind); 669 } else { 670 std::unique_ptr<llvm::MemoryBuffer> SB; 671 if (llvm::error_code ec = llvm::MemoryBuffer::getSTDIN(SB)) { 672 Diags.Report(diag::err_fe_error_reading_stdin) << ec.message(); 673 return false; 674 } 675 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(), 676 SB->getBufferSize(), 0); 677 SourceMgr.createMainFileID(File, Kind); 678 SourceMgr.overrideFileContents(File, SB.release()); 679 } 680 681 assert(!SourceMgr.getMainFileID().isInvalid() && 682 "Couldn't establish MainFileID!"); 683 return true; 684 } 685 686 // High-Level Operations 687 688 bool CompilerInstance::ExecuteAction(FrontendAction &Act) { 689 assert(hasDiagnostics() && "Diagnostics engine is not initialized!"); 690 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!"); 691 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!"); 692 693 // FIXME: Take this as an argument, once all the APIs we used have moved to 694 // taking it as an input instead of hard-coding llvm::errs. 695 raw_ostream &OS = llvm::errs(); 696 697 // Create the target instance. 698 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), &getTargetOpts())); 699 if (!hasTarget()) 700 return false; 701 702 // Inform the target of the language options. 703 // 704 // FIXME: We shouldn't need to do this, the target should be immutable once 705 // created. This complexity should be lifted elsewhere. 706 getTarget().setForcedLangOptions(getLangOpts()); 707 708 // rewriter project will change target built-in bool type from its default. 709 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC) 710 getTarget().noSignedCharForObjCBool(); 711 712 // Validate/process some options. 713 if (getHeaderSearchOpts().Verbose) 714 OS << "clang -cc1 version " CLANG_VERSION_STRING 715 << " based upon " << PACKAGE_STRING 716 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n"; 717 718 if (getFrontendOpts().ShowTimers) 719 createFrontendTimer(); 720 721 if (getFrontendOpts().ShowStats) 722 llvm::EnableStatistics(); 723 724 for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) { 725 // Reset the ID tables if we are reusing the SourceManager. 726 if (hasSourceManager()) 727 getSourceManager().clearIDTables(); 728 729 if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) { 730 Act.Execute(); 731 Act.EndSourceFile(); 732 } 733 } 734 735 // Notify the diagnostic client that all files were processed. 736 getDiagnostics().getClient()->finish(); 737 738 if (getDiagnosticOpts().ShowCarets) { 739 // We can have multiple diagnostics sharing one diagnostic client. 740 // Get the total number of warnings/errors from the client. 741 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings(); 742 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors(); 743 744 if (NumWarnings) 745 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s"); 746 if (NumWarnings && NumErrors) 747 OS << " and "; 748 if (NumErrors) 749 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s"); 750 if (NumWarnings || NumErrors) 751 OS << " generated.\n"; 752 } 753 754 if (getFrontendOpts().ShowStats && hasFileManager()) { 755 getFileManager().PrintStats(); 756 OS << "\n"; 757 } 758 759 return !getDiagnostics().getClient()->getNumErrors(); 760 } 761 762 /// \brief Determine the appropriate source input kind based on language 763 /// options. 764 static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) { 765 if (LangOpts.OpenCL) 766 return IK_OpenCL; 767 if (LangOpts.CUDA) 768 return IK_CUDA; 769 if (LangOpts.ObjC1) 770 return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC; 771 return LangOpts.CPlusPlus? IK_CXX : IK_C; 772 } 773 774 /// \brief Compile a module file for the given module, using the options 775 /// provided by the importing compiler instance. 776 static void compileModuleImpl(CompilerInstance &ImportingInstance, 777 SourceLocation ImportLoc, 778 Module *Module, 779 StringRef ModuleFileName) { 780 ModuleMap &ModMap 781 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap(); 782 783 // Construct a compiler invocation for creating this module. 784 IntrusiveRefCntPtr<CompilerInvocation> Invocation 785 (new CompilerInvocation(ImportingInstance.getInvocation())); 786 787 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); 788 789 // For any options that aren't intended to affect how a module is built, 790 // reset them to their default values. 791 Invocation->getLangOpts()->resetNonModularOptions(); 792 PPOpts.resetNonModularOptions(); 793 794 // Remove any macro definitions that are explicitly ignored by the module. 795 // They aren't supposed to affect how the module is built anyway. 796 const HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts(); 797 PPOpts.Macros.erase( 798 std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(), 799 [&HSOpts](const std::pair<std::string, bool> &def) { 800 StringRef MacroDef = def.first; 801 return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0; 802 }), 803 PPOpts.Macros.end()); 804 805 // Note the name of the module we're building. 806 Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName(); 807 808 // Make sure that the failed-module structure has been allocated in 809 // the importing instance, and propagate the pointer to the newly-created 810 // instance. 811 PreprocessorOptions &ImportingPPOpts 812 = ImportingInstance.getInvocation().getPreprocessorOpts(); 813 if (!ImportingPPOpts.FailedModules) 814 ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet; 815 PPOpts.FailedModules = ImportingPPOpts.FailedModules; 816 817 // If there is a module map file, build the module using the module map. 818 // Set up the inputs/outputs so that we build the module from its umbrella 819 // header. 820 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts(); 821 FrontendOpts.OutputFile = ModuleFileName.str(); 822 FrontendOpts.DisableFree = false; 823 FrontendOpts.GenerateGlobalModuleIndex = false; 824 FrontendOpts.Inputs.clear(); 825 InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts()); 826 827 // Don't free the remapped file buffers; they are owned by our caller. 828 PPOpts.RetainRemappedFileBuffers = true; 829 830 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0; 831 assert(ImportingInstance.getInvocation().getModuleHash() == 832 Invocation->getModuleHash() && "Module hash mismatch!"); 833 834 // Construct a compiler instance that will be used to actually create the 835 // module. 836 CompilerInstance Instance(/*BuildingModule=*/true); 837 Instance.setInvocation(&*Invocation); 838 839 Instance.createDiagnostics(new ForwardingDiagnosticConsumer( 840 ImportingInstance.getDiagnosticClient()), 841 /*ShouldOwnClient=*/true); 842 843 Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem()); 844 845 // Note that this module is part of the module build stack, so that we 846 // can detect cycles in the module graph. 847 Instance.setFileManager(&ImportingInstance.getFileManager()); 848 Instance.createSourceManager(Instance.getFileManager()); 849 SourceManager &SourceMgr = Instance.getSourceManager(); 850 SourceMgr.setModuleBuildStack( 851 ImportingInstance.getSourceManager().getModuleBuildStack()); 852 SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(), 853 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager())); 854 855 // Get or create the module map that we'll use to build this module. 856 std::string InferredModuleMapContent; 857 if (const FileEntry *ModuleMapFile = 858 ModMap.getContainingModuleMapFile(Module)) { 859 // Use the module map where this module resides. 860 FrontendOpts.Inputs.push_back( 861 FrontendInputFile(ModuleMapFile->getName(), IK)); 862 } else { 863 llvm::raw_string_ostream OS(InferredModuleMapContent); 864 Module->print(OS); 865 OS.flush(); 866 FrontendOpts.Inputs.push_back( 867 FrontendInputFile("__inferred_module.map", IK)); 868 869 const llvm::MemoryBuffer *ModuleMapBuffer = 870 llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent); 871 ModuleMapFile = Instance.getFileManager().getVirtualFile( 872 "__inferred_module.map", InferredModuleMapContent.size(), 0); 873 SourceMgr.overrideFileContents(ModuleMapFile, ModuleMapBuffer); 874 } 875 876 // Construct a module-generating action. Passing through Module->ModuleMap is 877 // safe because the FileManager is shared between the compiler instances. 878 GenerateModuleAction CreateModuleAction(Module->ModuleMap, Module->IsSystem); 879 880 // Execute the action to actually build the module in-place. Use a separate 881 // thread so that we get a stack large enough. 882 const unsigned ThreadStackSize = 8 << 20; 883 llvm::CrashRecoveryContext CRC; 884 CRC.RunSafelyOnThread([&]() { Instance.ExecuteAction(CreateModuleAction); }, 885 ThreadStackSize); 886 887 // Delete the temporary module map file. 888 // FIXME: Even though we're executing under crash protection, it would still 889 // be nice to do this with RemoveFileOnSignal when we can. However, that 890 // doesn't make sense for all clients, so clean this up manually. 891 Instance.clearOutputFiles(/*EraseFiles=*/true); 892 893 // We've rebuilt a module. If we're allowed to generate or update the global 894 // module index, record that fact in the importing compiler instance. 895 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) { 896 ImportingInstance.setBuildGlobalModuleIndex(true); 897 } 898 } 899 900 static void compileModule(CompilerInstance &ImportingInstance, 901 SourceLocation ImportLoc, 902 Module *Module, 903 StringRef ModuleFileName) { 904 // FIXME: have LockFileManager return an error_code so that we can 905 // avoid the mkdir when the directory already exists. 906 StringRef Dir = llvm::sys::path::parent_path(ModuleFileName); 907 llvm::sys::fs::create_directories(Dir); 908 909 while (1) { 910 llvm::LockFileManager Locked(ModuleFileName); 911 switch (Locked) { 912 case llvm::LockFileManager::LFS_Error: 913 return; 914 915 case llvm::LockFileManager::LFS_Owned: 916 // We're responsible for building the module ourselves. Do so below. 917 break; 918 919 case llvm::LockFileManager::LFS_Shared: 920 // Someone else is responsible for building the module. Wait for them to 921 // finish. 922 if (Locked.waitForUnlock() == llvm::LockFileManager::Res_OwnerDied) 923 continue; // try again to get the lock. 924 return; 925 } 926 927 return compileModuleImpl(ImportingInstance, ImportLoc, Module, 928 ModuleFileName); 929 } 930 } 931 932 /// \brief Diagnose differences between the current definition of the given 933 /// configuration macro and the definition provided on the command line. 934 static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro, 935 Module *Mod, SourceLocation ImportLoc) { 936 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro); 937 SourceManager &SourceMgr = PP.getSourceManager(); 938 939 // If this identifier has never had a macro definition, then it could 940 // not have changed. 941 if (!Id->hadMacroDefinition()) 942 return; 943 944 // If this identifier does not currently have a macro definition, 945 // check whether it had one on the command line. 946 if (!Id->hasMacroDefinition()) { 947 MacroDirective::DefInfo LatestDef = 948 PP.getMacroDirectiveHistory(Id)->getDefinition(); 949 for (MacroDirective::DefInfo Def = LatestDef; Def; 950 Def = Def.getPreviousDefinition()) { 951 FileID FID = SourceMgr.getFileID(Def.getLocation()); 952 if (FID.isInvalid()) 953 continue; 954 955 // We only care about the predefines buffer. 956 if (FID != PP.getPredefinesFileID()) 957 continue; 958 959 // This macro was defined on the command line, then #undef'd later. 960 // Complain. 961 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) 962 << true << ConfigMacro << Mod->getFullModuleName(); 963 if (LatestDef.isUndefined()) 964 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here) 965 << true; 966 return; 967 } 968 969 // Okay: no definition in the predefines buffer. 970 return; 971 } 972 973 // This identifier has a macro definition. Check whether we had a definition 974 // on the command line. 975 MacroDirective::DefInfo LatestDef = 976 PP.getMacroDirectiveHistory(Id)->getDefinition(); 977 MacroDirective::DefInfo PredefinedDef; 978 for (MacroDirective::DefInfo Def = LatestDef; Def; 979 Def = Def.getPreviousDefinition()) { 980 FileID FID = SourceMgr.getFileID(Def.getLocation()); 981 if (FID.isInvalid()) 982 continue; 983 984 // We only care about the predefines buffer. 985 if (FID != PP.getPredefinesFileID()) 986 continue; 987 988 PredefinedDef = Def; 989 break; 990 } 991 992 // If there was no definition for this macro in the predefines buffer, 993 // complain. 994 if (!PredefinedDef || 995 (!PredefinedDef.getLocation().isValid() && 996 PredefinedDef.getUndefLocation().isValid())) { 997 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) 998 << false << ConfigMacro << Mod->getFullModuleName(); 999 PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here) 1000 << false; 1001 return; 1002 } 1003 1004 // If the current macro definition is the same as the predefined macro 1005 // definition, it's okay. 1006 if (LatestDef.getMacroInfo() == PredefinedDef.getMacroInfo() || 1007 LatestDef.getMacroInfo()->isIdenticalTo(*PredefinedDef.getMacroInfo(),PP, 1008 /*Syntactically=*/true)) 1009 return; 1010 1011 // The macro definitions differ. 1012 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) 1013 << false << ConfigMacro << Mod->getFullModuleName(); 1014 PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here) 1015 << false; 1016 } 1017 1018 /// \brief Write a new timestamp file with the given path. 1019 static void writeTimestampFile(StringRef TimestampFile) { 1020 std::string ErrorInfo; 1021 llvm::raw_fd_ostream Out(TimestampFile.str().c_str(), ErrorInfo, 1022 llvm::sys::fs::F_None); 1023 } 1024 1025 /// \brief Prune the module cache of modules that haven't been accessed in 1026 /// a long time. 1027 static void pruneModuleCache(const HeaderSearchOptions &HSOpts) { 1028 struct stat StatBuf; 1029 llvm::SmallString<128> TimestampFile; 1030 TimestampFile = HSOpts.ModuleCachePath; 1031 llvm::sys::path::append(TimestampFile, "modules.timestamp"); 1032 1033 // Try to stat() the timestamp file. 1034 if (::stat(TimestampFile.c_str(), &StatBuf)) { 1035 // If the timestamp file wasn't there, create one now. 1036 if (errno == ENOENT) { 1037 writeTimestampFile(TimestampFile); 1038 } 1039 return; 1040 } 1041 1042 // Check whether the time stamp is older than our pruning interval. 1043 // If not, do nothing. 1044 time_t TimeStampModTime = StatBuf.st_mtime; 1045 time_t CurrentTime = time(0); 1046 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval)) 1047 return; 1048 1049 // Write a new timestamp file so that nobody else attempts to prune. 1050 // There is a benign race condition here, if two Clang instances happen to 1051 // notice at the same time that the timestamp is out-of-date. 1052 writeTimestampFile(TimestampFile); 1053 1054 // Walk the entire module cache, looking for unused module files and module 1055 // indices. 1056 llvm::error_code EC; 1057 SmallString<128> ModuleCachePathNative; 1058 llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative); 1059 for (llvm::sys::fs::directory_iterator 1060 Dir(ModuleCachePathNative.str(), EC), DirEnd; 1061 Dir != DirEnd && !EC; Dir.increment(EC)) { 1062 // If we don't have a directory, there's nothing to look into. 1063 if (!llvm::sys::fs::is_directory(Dir->path())) 1064 continue; 1065 1066 // Walk all of the files within this directory. 1067 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd; 1068 File != FileEnd && !EC; File.increment(EC)) { 1069 // We only care about module and global module index files. 1070 StringRef Extension = llvm::sys::path::extension(File->path()); 1071 if (Extension != ".pcm" && Extension != ".timestamp" && 1072 llvm::sys::path::filename(File->path()) != "modules.idx") 1073 continue; 1074 1075 // Look at this file. If we can't stat it, there's nothing interesting 1076 // there. 1077 if (::stat(File->path().c_str(), &StatBuf)) 1078 continue; 1079 1080 // If the file has been used recently enough, leave it there. 1081 time_t FileAccessTime = StatBuf.st_atime; 1082 if (CurrentTime - FileAccessTime <= 1083 time_t(HSOpts.ModuleCachePruneAfter)) { 1084 continue; 1085 } 1086 1087 // Remove the file. 1088 llvm::sys::fs::remove(File->path()); 1089 1090 // Remove the timestamp file. 1091 std::string TimpestampFilename = File->path() + ".timestamp"; 1092 llvm::sys::fs::remove(TimpestampFilename); 1093 } 1094 1095 // If we removed all of the files in the directory, remove the directory 1096 // itself. 1097 if (llvm::sys::fs::directory_iterator(Dir->path(), EC) == 1098 llvm::sys::fs::directory_iterator() && !EC) 1099 llvm::sys::fs::remove(Dir->path()); 1100 } 1101 } 1102 1103 void CompilerInstance::createModuleManager() { 1104 if (!ModuleManager) { 1105 if (!hasASTContext()) 1106 createASTContext(); 1107 1108 // If we're not recursively building a module, check whether we 1109 // need to prune the module cache. 1110 if (getSourceManager().getModuleBuildStack().empty() && 1111 getHeaderSearchOpts().ModuleCachePruneInterval > 0 && 1112 getHeaderSearchOpts().ModuleCachePruneAfter > 0) { 1113 pruneModuleCache(getHeaderSearchOpts()); 1114 } 1115 1116 HeaderSearchOptions &HSOpts = getHeaderSearchOpts(); 1117 std::string Sysroot = HSOpts.Sysroot; 1118 const PreprocessorOptions &PPOpts = getPreprocessorOpts(); 1119 ModuleManager = new ASTReader(getPreprocessor(), *Context, 1120 Sysroot.empty() ? "" : Sysroot.c_str(), 1121 PPOpts.DisablePCHValidation, 1122 /*AllowASTWithCompilerErrors=*/false, 1123 /*AllowConfigurationMismatch=*/false, 1124 HSOpts.ModulesValidateSystemHeaders, 1125 getFrontendOpts().UseGlobalModuleIndex); 1126 if (hasASTConsumer()) { 1127 ModuleManager->setDeserializationListener( 1128 getASTConsumer().GetASTDeserializationListener()); 1129 getASTContext().setASTMutationListener( 1130 getASTConsumer().GetASTMutationListener()); 1131 } 1132 getASTContext().setExternalSource(ModuleManager); 1133 if (hasSema()) 1134 ModuleManager->InitializeSema(getSema()); 1135 if (hasASTConsumer()) 1136 ModuleManager->StartTranslationUnit(&getASTConsumer()); 1137 } 1138 } 1139 1140 ModuleLoadResult 1141 CompilerInstance::loadModule(SourceLocation ImportLoc, 1142 ModuleIdPath Path, 1143 Module::NameVisibilityKind Visibility, 1144 bool IsInclusionDirective) { 1145 // Determine what file we're searching from. 1146 StringRef ModuleName = Path[0].first->getName(); 1147 SourceLocation ModuleNameLoc = Path[0].second; 1148 1149 // If we've already handled this import, just return the cached result. 1150 // This one-element cache is important to eliminate redundant diagnostics 1151 // when both the preprocessor and parser see the same import declaration. 1152 if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) { 1153 // Make the named module visible. 1154 if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule) 1155 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility, 1156 ImportLoc, /*Complain=*/false); 1157 return LastModuleImportResult; 1158 } 1159 1160 clang::Module *Module = 0; 1161 1162 // If we don't already have information on this module, load the module now. 1163 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known 1164 = KnownModules.find(Path[0].first); 1165 if (Known != KnownModules.end()) { 1166 // Retrieve the cached top-level module. 1167 Module = Known->second; 1168 } else if (ModuleName == getLangOpts().CurrentModule) { 1169 // This is the module we're building. 1170 Module = PP->getHeaderSearchInfo().getModuleMap().findModule(ModuleName); 1171 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first; 1172 } else { 1173 // Search for a module with the given name. 1174 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName); 1175 if (!Module) { 1176 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found) 1177 << ModuleName 1178 << SourceRange(ImportLoc, ModuleNameLoc); 1179 ModuleBuildFailed = true; 1180 return ModuleLoadResult(); 1181 } 1182 1183 std::string ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module); 1184 1185 // If we don't already have an ASTReader, create one now. 1186 if (!ModuleManager) 1187 createModuleManager(); 1188 1189 if (TheDependencyFileGenerator) 1190 TheDependencyFileGenerator->AttachToASTReader(*ModuleManager); 1191 1192 // Try to load the module file. 1193 unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing; 1194 switch (ModuleManager->ReadAST(ModuleFileName, serialization::MK_Module, 1195 ImportLoc, ARRFlags)) { 1196 case ASTReader::Success: 1197 break; 1198 1199 case ASTReader::OutOfDate: 1200 case ASTReader::Missing: { 1201 // The module file is missing or out-of-date. Build it. 1202 assert(Module && "missing module file"); 1203 // Check whether there is a cycle in the module graph. 1204 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack(); 1205 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end(); 1206 for (; Pos != PosEnd; ++Pos) { 1207 if (Pos->first == ModuleName) 1208 break; 1209 } 1210 1211 if (Pos != PosEnd) { 1212 SmallString<256> CyclePath; 1213 for (; Pos != PosEnd; ++Pos) { 1214 CyclePath += Pos->first; 1215 CyclePath += " -> "; 1216 } 1217 CyclePath += ModuleName; 1218 1219 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle) 1220 << ModuleName << CyclePath; 1221 return ModuleLoadResult(); 1222 } 1223 1224 // Check whether we have already attempted to build this module (but 1225 // failed). 1226 if (getPreprocessorOpts().FailedModules && 1227 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) { 1228 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built) 1229 << ModuleName 1230 << SourceRange(ImportLoc, ModuleNameLoc); 1231 ModuleBuildFailed = true; 1232 return ModuleLoadResult(); 1233 } 1234 1235 // Try to compile the module. 1236 compileModule(*this, ModuleNameLoc, Module, ModuleFileName); 1237 1238 // Try to read the module file, now that we've compiled it. 1239 ASTReader::ASTReadResult ReadResult 1240 = ModuleManager->ReadAST(ModuleFileName, 1241 serialization::MK_Module, ImportLoc, 1242 ASTReader::ARR_Missing); 1243 if (ReadResult != ASTReader::Success) { 1244 if (ReadResult == ASTReader::Missing) { 1245 getDiagnostics().Report(ModuleNameLoc, 1246 Module? diag::err_module_not_built 1247 : diag::err_module_not_found) 1248 << ModuleName 1249 << SourceRange(ImportLoc, ModuleNameLoc); 1250 } 1251 1252 if (getPreprocessorOpts().FailedModules) 1253 getPreprocessorOpts().FailedModules->addFailed(ModuleName); 1254 KnownModules[Path[0].first] = 0; 1255 ModuleBuildFailed = true; 1256 return ModuleLoadResult(); 1257 } 1258 1259 // Okay, we've rebuilt and now loaded the module. 1260 break; 1261 } 1262 1263 case ASTReader::VersionMismatch: 1264 case ASTReader::ConfigurationMismatch: 1265 case ASTReader::HadErrors: 1266 ModuleLoader::HadFatalFailure = true; 1267 // FIXME: The ASTReader will already have complained, but can we showhorn 1268 // that diagnostic information into a more useful form? 1269 KnownModules[Path[0].first] = 0; 1270 return ModuleLoadResult(); 1271 1272 case ASTReader::Failure: 1273 ModuleLoader::HadFatalFailure = true; 1274 // Already complained, but note now that we failed. 1275 KnownModules[Path[0].first] = 0; 1276 ModuleBuildFailed = true; 1277 return ModuleLoadResult(); 1278 } 1279 1280 // Cache the result of this top-level module lookup for later. 1281 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first; 1282 } 1283 1284 // If we never found the module, fail. 1285 if (!Module) 1286 return ModuleLoadResult(); 1287 1288 // Verify that the rest of the module path actually corresponds to 1289 // a submodule. 1290 if (Path.size() > 1) { 1291 for (unsigned I = 1, N = Path.size(); I != N; ++I) { 1292 StringRef Name = Path[I].first->getName(); 1293 clang::Module *Sub = Module->findSubmodule(Name); 1294 1295 if (!Sub) { 1296 // Attempt to perform typo correction to find a module name that works. 1297 SmallVector<StringRef, 2> Best; 1298 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)(); 1299 1300 for (clang::Module::submodule_iterator J = Module->submodule_begin(), 1301 JEnd = Module->submodule_end(); 1302 J != JEnd; ++J) { 1303 unsigned ED = Name.edit_distance((*J)->Name, 1304 /*AllowReplacements=*/true, 1305 BestEditDistance); 1306 if (ED <= BestEditDistance) { 1307 if (ED < BestEditDistance) { 1308 Best.clear(); 1309 BestEditDistance = ED; 1310 } 1311 1312 Best.push_back((*J)->Name); 1313 } 1314 } 1315 1316 // If there was a clear winner, user it. 1317 if (Best.size() == 1) { 1318 getDiagnostics().Report(Path[I].second, 1319 diag::err_no_submodule_suggest) 1320 << Path[I].first << Module->getFullModuleName() << Best[0] 1321 << SourceRange(Path[0].second, Path[I-1].second) 1322 << FixItHint::CreateReplacement(SourceRange(Path[I].second), 1323 Best[0]); 1324 1325 Sub = Module->findSubmodule(Best[0]); 1326 } 1327 } 1328 1329 if (!Sub) { 1330 // No submodule by this name. Complain, and don't look for further 1331 // submodules. 1332 getDiagnostics().Report(Path[I].second, diag::err_no_submodule) 1333 << Path[I].first << Module->getFullModuleName() 1334 << SourceRange(Path[0].second, Path[I-1].second); 1335 break; 1336 } 1337 1338 Module = Sub; 1339 } 1340 } 1341 1342 // Make the named module visible, if it's not already part of the module 1343 // we are parsing. 1344 if (ModuleName != getLangOpts().CurrentModule) { 1345 if (!Module->IsFromModuleFile) { 1346 // We have an umbrella header or directory that doesn't actually include 1347 // all of the headers within the directory it covers. Complain about 1348 // this missing submodule and recover by forgetting that we ever saw 1349 // this submodule. 1350 // FIXME: Should we detect this at module load time? It seems fairly 1351 // expensive (and rare). 1352 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule) 1353 << Module->getFullModuleName() 1354 << SourceRange(Path.front().second, Path.back().second); 1355 1356 return ModuleLoadResult(0, true); 1357 } 1358 1359 // Check whether this module is available. 1360 clang::Module::Requirement Requirement; 1361 clang::Module::HeaderDirective MissingHeader; 1362 if (!Module->isAvailable(getLangOpts(), getTarget(), Requirement, 1363 MissingHeader)) { 1364 if (MissingHeader.FileNameLoc.isValid()) { 1365 getDiagnostics().Report(MissingHeader.FileNameLoc, 1366 diag::err_module_header_missing) 1367 << MissingHeader.IsUmbrella << MissingHeader.FileName; 1368 } else { 1369 getDiagnostics().Report(ImportLoc, diag::err_module_unavailable) 1370 << Module->getFullModuleName() 1371 << Requirement.second << Requirement.first 1372 << SourceRange(Path.front().second, Path.back().second); 1373 } 1374 LastModuleImportLoc = ImportLoc; 1375 LastModuleImportResult = ModuleLoadResult(); 1376 return ModuleLoadResult(); 1377 } 1378 1379 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc, 1380 /*Complain=*/true); 1381 } 1382 1383 // Check for any configuration macros that have changed. 1384 clang::Module *TopModule = Module->getTopLevelModule(); 1385 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) { 1386 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I], 1387 Module, ImportLoc); 1388 } 1389 1390 // If this module import was due to an inclusion directive, create an 1391 // implicit import declaration to capture it in the AST. 1392 if (IsInclusionDirective && hasASTContext()) { 1393 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl(); 1394 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU, 1395 ImportLoc, Module, 1396 Path.back().second); 1397 TU->addDecl(ImportD); 1398 if (Consumer) 1399 Consumer->HandleImplicitImportDecl(ImportD); 1400 } 1401 1402 LastModuleImportLoc = ImportLoc; 1403 LastModuleImportResult = ModuleLoadResult(Module, false); 1404 return LastModuleImportResult; 1405 } 1406 1407 void CompilerInstance::makeModuleVisible(Module *Mod, 1408 Module::NameVisibilityKind Visibility, 1409 SourceLocation ImportLoc, 1410 bool Complain){ 1411 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc, Complain); 1412 } 1413 1414 GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex( 1415 SourceLocation TriggerLoc) { 1416 if (!ModuleManager) 1417 createModuleManager(); 1418 // Can't do anything if we don't have the module manager. 1419 if (!ModuleManager) 1420 return 0; 1421 // Get an existing global index. This loads it if not already 1422 // loaded. 1423 ModuleManager->loadGlobalIndex(); 1424 GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex(); 1425 // If the global index doesn't exist, create it. 1426 if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() && 1427 hasPreprocessor()) { 1428 llvm::sys::fs::create_directories( 1429 getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); 1430 GlobalModuleIndex::writeIndex( 1431 getFileManager(), 1432 getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); 1433 ModuleManager->resetForReload(); 1434 ModuleManager->loadGlobalIndex(); 1435 GlobalIndex = ModuleManager->getGlobalIndex(); 1436 } 1437 // For finding modules needing to be imported for fixit messages, 1438 // we need to make the global index cover all modules, so we do that here. 1439 if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) { 1440 ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap(); 1441 bool RecreateIndex = false; 1442 for (ModuleMap::module_iterator I = MMap.module_begin(), 1443 E = MMap.module_end(); I != E; ++I) { 1444 Module *TheModule = I->second; 1445 const FileEntry *Entry = TheModule->getASTFile(); 1446 if (!Entry) { 1447 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path; 1448 Path.push_back(std::make_pair( 1449 getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc)); 1450 std::reverse(Path.begin(), Path.end()); 1451 // Load a module as hidden. This also adds it to the global index. 1452 loadModule(TheModule->DefinitionLoc, Path, 1453 Module::Hidden, false); 1454 RecreateIndex = true; 1455 } 1456 } 1457 if (RecreateIndex) { 1458 GlobalModuleIndex::writeIndex( 1459 getFileManager(), 1460 getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); 1461 ModuleManager->resetForReload(); 1462 ModuleManager->loadGlobalIndex(); 1463 GlobalIndex = ModuleManager->getGlobalIndex(); 1464 } 1465 HaveFullGlobalModuleIndex = true; 1466 } 1467 return GlobalIndex; 1468 } 1469 1470 // Check global module index for missing imports. 1471 bool 1472 CompilerInstance::lookupMissingImports(StringRef Name, 1473 SourceLocation TriggerLoc) { 1474 // Look for the symbol in non-imported modules, but only if an error 1475 // actually occurred. 1476 if (!buildingModule()) { 1477 // Load global module index, or retrieve a previously loaded one. 1478 GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex( 1479 TriggerLoc); 1480 1481 // Only if we have a global index. 1482 if (GlobalIndex) { 1483 GlobalModuleIndex::HitSet FoundModules; 1484 1485 // Find the modules that reference the identifier. 1486 // Note that this only finds top-level modules. 1487 // We'll let diagnoseTypo find the actual declaration module. 1488 if (GlobalIndex->lookupIdentifier(Name, FoundModules)) 1489 return true; 1490 } 1491 } 1492 1493 return false; 1494 } 1495