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