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