1 //===--- CompilerInstance.cpp ---------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "clang/Frontend/CompilerInstance.h" 10 #include "clang/AST/ASTConsumer.h" 11 #include "clang/AST/ASTContext.h" 12 #include "clang/AST/Decl.h" 13 #include "clang/Basic/CharInfo.h" 14 #include "clang/Basic/Diagnostic.h" 15 #include "clang/Basic/DiagnosticOptions.h" 16 #include "clang/Basic/FileManager.h" 17 #include "clang/Basic/LangStandard.h" 18 #include "clang/Basic/SourceManager.h" 19 #include "clang/Basic/Stack.h" 20 #include "clang/Basic/TargetInfo.h" 21 #include "clang/Basic/Version.h" 22 #include "clang/Config/config.h" 23 #include "clang/Frontend/ChainedDiagnosticConsumer.h" 24 #include "clang/Frontend/FrontendAction.h" 25 #include "clang/Frontend/FrontendActions.h" 26 #include "clang/Frontend/FrontendDiagnostic.h" 27 #include "clang/Frontend/FrontendPluginRegistry.h" 28 #include "clang/Frontend/LogDiagnosticPrinter.h" 29 #include "clang/Frontend/SARIFDiagnosticPrinter.h" 30 #include "clang/Frontend/SerializedDiagnosticPrinter.h" 31 #include "clang/Frontend/TextDiagnosticPrinter.h" 32 #include "clang/Frontend/Utils.h" 33 #include "clang/Frontend/VerifyDiagnosticConsumer.h" 34 #include "clang/Lex/HeaderSearch.h" 35 #include "clang/Lex/Preprocessor.h" 36 #include "clang/Lex/PreprocessorOptions.h" 37 #include "clang/Sema/CodeCompleteConsumer.h" 38 #include "clang/Sema/Sema.h" 39 #include "clang/Serialization/ASTReader.h" 40 #include "clang/Serialization/GlobalModuleIndex.h" 41 #include "clang/Serialization/InMemoryModuleCache.h" 42 #include "llvm/ADT/STLExtras.h" 43 #include "llvm/ADT/ScopeExit.h" 44 #include "llvm/ADT/Statistic.h" 45 #include "llvm/Config/llvm-config.h" 46 #include "llvm/Support/BuryPointer.h" 47 #include "llvm/Support/CrashRecoveryContext.h" 48 #include "llvm/Support/Errc.h" 49 #include "llvm/Support/FileSystem.h" 50 #include "llvm/Support/LockFileManager.h" 51 #include "llvm/Support/MemoryBuffer.h" 52 #include "llvm/Support/Path.h" 53 #include "llvm/Support/Program.h" 54 #include "llvm/Support/Signals.h" 55 #include "llvm/Support/TimeProfiler.h" 56 #include "llvm/Support/Timer.h" 57 #include "llvm/Support/raw_ostream.h" 58 #include "llvm/TargetParser/Host.h" 59 #include <optional> 60 #include <time.h> 61 #include <utility> 62 63 using namespace clang; 64 65 CompilerInstance::CompilerInstance( 66 std::shared_ptr<PCHContainerOperations> PCHContainerOps, 67 InMemoryModuleCache *SharedModuleCache) 68 : ModuleLoader(/* BuildingModule = */ SharedModuleCache), 69 Invocation(new CompilerInvocation()), 70 ModuleCache(SharedModuleCache ? SharedModuleCache 71 : new InMemoryModuleCache), 72 ThePCHContainerOperations(std::move(PCHContainerOps)) {} 73 74 CompilerInstance::~CompilerInstance() { 75 assert(OutputFiles.empty() && "Still output files in flight?"); 76 } 77 78 void CompilerInstance::setInvocation( 79 std::shared_ptr<CompilerInvocation> Value) { 80 Invocation = std::move(Value); 81 } 82 83 bool CompilerInstance::shouldBuildGlobalModuleIndex() const { 84 return (BuildGlobalModuleIndex || 85 (TheASTReader && TheASTReader->isGlobalIndexUnavailable() && 86 getFrontendOpts().GenerateGlobalModuleIndex)) && 87 !DisableGeneratingGlobalModuleIndex; 88 } 89 90 void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) { 91 Diagnostics = Value; 92 } 93 94 void CompilerInstance::setVerboseOutputStream(raw_ostream &Value) { 95 OwnedVerboseOutputStream.reset(); 96 VerboseOutputStream = &Value; 97 } 98 99 void CompilerInstance::setVerboseOutputStream(std::unique_ptr<raw_ostream> Value) { 100 OwnedVerboseOutputStream.swap(Value); 101 VerboseOutputStream = OwnedVerboseOutputStream.get(); 102 } 103 104 void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; } 105 void CompilerInstance::setAuxTarget(TargetInfo *Value) { AuxTarget = Value; } 106 107 bool CompilerInstance::createTarget() { 108 // Create the target instance. 109 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), 110 getInvocation().TargetOpts)); 111 if (!hasTarget()) 112 return false; 113 114 // Check whether AuxTarget exists, if not, then create TargetInfo for the 115 // other side of CUDA/OpenMP/SYCL compilation. 116 if (!getAuxTarget() && 117 (getLangOpts().CUDA || getLangOpts().OpenMPIsTargetDevice || 118 getLangOpts().SYCLIsDevice) && 119 !getFrontendOpts().AuxTriple.empty()) { 120 auto TO = std::make_shared<TargetOptions>(); 121 TO->Triple = llvm::Triple::normalize(getFrontendOpts().AuxTriple); 122 if (getFrontendOpts().AuxTargetCPU) 123 TO->CPU = *getFrontendOpts().AuxTargetCPU; 124 if (getFrontendOpts().AuxTargetFeatures) 125 TO->FeaturesAsWritten = *getFrontendOpts().AuxTargetFeatures; 126 TO->HostTriple = getTarget().getTriple().str(); 127 setAuxTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), TO)); 128 } 129 130 if (!getTarget().hasStrictFP() && !getLangOpts().ExpStrictFP) { 131 if (getLangOpts().RoundingMath) { 132 getDiagnostics().Report(diag::warn_fe_backend_unsupported_fp_rounding); 133 getLangOpts().RoundingMath = false; 134 } 135 auto FPExc = getLangOpts().getFPExceptionMode(); 136 if (FPExc != LangOptions::FPE_Default && FPExc != LangOptions::FPE_Ignore) { 137 getDiagnostics().Report(diag::warn_fe_backend_unsupported_fp_exceptions); 138 getLangOpts().setFPExceptionMode(LangOptions::FPE_Ignore); 139 } 140 // FIXME: can we disable FEnvAccess? 141 } 142 143 // We should do it here because target knows nothing about 144 // language options when it's being created. 145 if (getLangOpts().OpenCL && 146 !getTarget().validateOpenCLTarget(getLangOpts(), getDiagnostics())) 147 return false; 148 149 // Inform the target of the language options. 150 // FIXME: We shouldn't need to do this, the target should be immutable once 151 // created. This complexity should be lifted elsewhere. 152 getTarget().adjust(getDiagnostics(), getLangOpts()); 153 154 if (auto *Aux = getAuxTarget()) 155 getTarget().setAuxTarget(Aux); 156 157 return true; 158 } 159 160 llvm::vfs::FileSystem &CompilerInstance::getVirtualFileSystem() const { 161 return getFileManager().getVirtualFileSystem(); 162 } 163 164 void CompilerInstance::setFileManager(FileManager *Value) { 165 FileMgr = Value; 166 } 167 168 void CompilerInstance::setSourceManager(SourceManager *Value) { 169 SourceMgr = Value; 170 } 171 172 void CompilerInstance::setPreprocessor(std::shared_ptr<Preprocessor> Value) { 173 PP = std::move(Value); 174 } 175 176 void CompilerInstance::setASTContext(ASTContext *Value) { 177 Context = Value; 178 179 if (Context && Consumer) 180 getASTConsumer().Initialize(getASTContext()); 181 } 182 183 void CompilerInstance::setSema(Sema *S) { 184 TheSema.reset(S); 185 } 186 187 void CompilerInstance::setASTConsumer(std::unique_ptr<ASTConsumer> Value) { 188 Consumer = std::move(Value); 189 190 if (Context && Consumer) 191 getASTConsumer().Initialize(getASTContext()); 192 } 193 194 void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) { 195 CompletionConsumer.reset(Value); 196 } 197 198 std::unique_ptr<Sema> CompilerInstance::takeSema() { 199 return std::move(TheSema); 200 } 201 202 IntrusiveRefCntPtr<ASTReader> CompilerInstance::getASTReader() const { 203 return TheASTReader; 204 } 205 void CompilerInstance::setASTReader(IntrusiveRefCntPtr<ASTReader> Reader) { 206 assert(ModuleCache.get() == &Reader->getModuleManager().getModuleCache() && 207 "Expected ASTReader to use the same PCM cache"); 208 TheASTReader = std::move(Reader); 209 } 210 211 std::shared_ptr<ModuleDependencyCollector> 212 CompilerInstance::getModuleDepCollector() const { 213 return ModuleDepCollector; 214 } 215 216 void CompilerInstance::setModuleDepCollector( 217 std::shared_ptr<ModuleDependencyCollector> Collector) { 218 ModuleDepCollector = std::move(Collector); 219 } 220 221 static void collectHeaderMaps(const HeaderSearch &HS, 222 std::shared_ptr<ModuleDependencyCollector> MDC) { 223 SmallVector<std::string, 4> HeaderMapFileNames; 224 HS.getHeaderMapFileNames(HeaderMapFileNames); 225 for (auto &Name : HeaderMapFileNames) 226 MDC->addFile(Name); 227 } 228 229 static void collectIncludePCH(CompilerInstance &CI, 230 std::shared_ptr<ModuleDependencyCollector> MDC) { 231 const PreprocessorOptions &PPOpts = CI.getPreprocessorOpts(); 232 if (PPOpts.ImplicitPCHInclude.empty()) 233 return; 234 235 StringRef PCHInclude = PPOpts.ImplicitPCHInclude; 236 FileManager &FileMgr = CI.getFileManager(); 237 auto PCHDir = FileMgr.getOptionalDirectoryRef(PCHInclude); 238 if (!PCHDir) { 239 MDC->addFile(PCHInclude); 240 return; 241 } 242 243 std::error_code EC; 244 SmallString<128> DirNative; 245 llvm::sys::path::native(PCHDir->getName(), DirNative); 246 llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem(); 247 SimpleASTReaderListener Validator(CI.getPreprocessor()); 248 for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), DirEnd; 249 Dir != DirEnd && !EC; Dir.increment(EC)) { 250 // Check whether this is an AST file. ASTReader::isAcceptableASTFile is not 251 // used here since we're not interested in validating the PCH at this time, 252 // but only to check whether this is a file containing an AST. 253 if (!ASTReader::readASTFileControlBlock( 254 Dir->path(), FileMgr, CI.getModuleCache(), 255 CI.getPCHContainerReader(), 256 /*FindModuleFileExtensions=*/false, Validator, 257 /*ValidateDiagnosticOptions=*/false)) 258 MDC->addFile(Dir->path()); 259 } 260 } 261 262 static void collectVFSEntries(CompilerInstance &CI, 263 std::shared_ptr<ModuleDependencyCollector> MDC) { 264 if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty()) 265 return; 266 267 // Collect all VFS found. 268 SmallVector<llvm::vfs::YAMLVFSEntry, 16> VFSEntries; 269 for (const std::string &VFSFile : CI.getHeaderSearchOpts().VFSOverlayFiles) { 270 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer = 271 llvm::MemoryBuffer::getFile(VFSFile); 272 if (!Buffer) 273 return; 274 llvm::vfs::collectVFSFromYAML(std::move(Buffer.get()), 275 /*DiagHandler*/ nullptr, VFSFile, VFSEntries); 276 } 277 278 for (auto &E : VFSEntries) 279 MDC->addFile(E.VPath, E.RPath); 280 } 281 282 // Diagnostics 283 static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts, 284 const CodeGenOptions *CodeGenOpts, 285 DiagnosticsEngine &Diags) { 286 std::error_code EC; 287 std::unique_ptr<raw_ostream> StreamOwner; 288 raw_ostream *OS = &llvm::errs(); 289 if (DiagOpts->DiagnosticLogFile != "-") { 290 // Create the output stream. 291 auto FileOS = std::make_unique<llvm::raw_fd_ostream>( 292 DiagOpts->DiagnosticLogFile, EC, 293 llvm::sys::fs::OF_Append | llvm::sys::fs::OF_TextWithCRLF); 294 if (EC) { 295 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure) 296 << DiagOpts->DiagnosticLogFile << EC.message(); 297 } else { 298 FileOS->SetUnbuffered(); 299 OS = FileOS.get(); 300 StreamOwner = std::move(FileOS); 301 } 302 } 303 304 // Chain in the diagnostic client which will log the diagnostics. 305 auto Logger = std::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts, 306 std::move(StreamOwner)); 307 if (CodeGenOpts) 308 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags); 309 if (Diags.ownsClient()) { 310 Diags.setClient( 311 new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger))); 312 } else { 313 Diags.setClient( 314 new ChainedDiagnosticConsumer(Diags.getClient(), std::move(Logger))); 315 } 316 } 317 318 static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts, 319 DiagnosticsEngine &Diags, 320 StringRef OutputFile) { 321 auto SerializedConsumer = 322 clang::serialized_diags::create(OutputFile, DiagOpts); 323 324 if (Diags.ownsClient()) { 325 Diags.setClient(new ChainedDiagnosticConsumer( 326 Diags.takeClient(), std::move(SerializedConsumer))); 327 } else { 328 Diags.setClient(new ChainedDiagnosticConsumer( 329 Diags.getClient(), std::move(SerializedConsumer))); 330 } 331 } 332 333 void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client, 334 bool ShouldOwnClient) { 335 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client, 336 ShouldOwnClient, &getCodeGenOpts()); 337 } 338 339 IntrusiveRefCntPtr<DiagnosticsEngine> 340 CompilerInstance::createDiagnostics(DiagnosticOptions *Opts, 341 DiagnosticConsumer *Client, 342 bool ShouldOwnClient, 343 const CodeGenOptions *CodeGenOpts) { 344 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); 345 IntrusiveRefCntPtr<DiagnosticsEngine> 346 Diags(new DiagnosticsEngine(DiagID, Opts)); 347 348 // Create the diagnostic client for reporting errors or for 349 // implementing -verify. 350 if (Client) { 351 Diags->setClient(Client, ShouldOwnClient); 352 } else if (Opts->getFormat() == DiagnosticOptions::SARIF) { 353 Diags->setClient(new SARIFDiagnosticPrinter(llvm::errs(), Opts)); 354 } else 355 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts)); 356 357 // Chain in -verify checker, if requested. 358 if (Opts->VerifyDiagnostics) 359 Diags->setClient(new VerifyDiagnosticConsumer(*Diags)); 360 361 // Chain in -diagnostic-log-file dumper, if requested. 362 if (!Opts->DiagnosticLogFile.empty()) 363 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags); 364 365 if (!Opts->DiagnosticSerializationFile.empty()) 366 SetupSerializedDiagnostics(Opts, *Diags, 367 Opts->DiagnosticSerializationFile); 368 369 // Configure our handling of diagnostics. 370 ProcessWarningOptions(*Diags, *Opts); 371 372 return Diags; 373 } 374 375 // File Manager 376 377 FileManager *CompilerInstance::createFileManager( 378 IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) { 379 if (!VFS) 380 VFS = FileMgr ? &FileMgr->getVirtualFileSystem() 381 : createVFSFromCompilerInvocation(getInvocation(), 382 getDiagnostics()); 383 assert(VFS && "FileManager has no VFS?"); 384 FileMgr = new FileManager(getFileSystemOpts(), std::move(VFS)); 385 return FileMgr.get(); 386 } 387 388 // Source Manager 389 390 void CompilerInstance::createSourceManager(FileManager &FileMgr) { 391 SourceMgr = new SourceManager(getDiagnostics(), FileMgr); 392 } 393 394 // Initialize the remapping of files to alternative contents, e.g., 395 // those specified through other files. 396 static void InitializeFileRemapping(DiagnosticsEngine &Diags, 397 SourceManager &SourceMgr, 398 FileManager &FileMgr, 399 const PreprocessorOptions &InitOpts) { 400 // Remap files in the source manager (with buffers). 401 for (const auto &RB : InitOpts.RemappedFileBuffers) { 402 // Create the file entry for the file that we're mapping from. 403 FileEntryRef FromFile = 404 FileMgr.getVirtualFileRef(RB.first, RB.second->getBufferSize(), 0); 405 406 // Override the contents of the "from" file with the contents of the 407 // "to" file. If the caller owns the buffers, then pass a MemoryBufferRef; 408 // otherwise, pass as a std::unique_ptr<MemoryBuffer> to transfer ownership 409 // to the SourceManager. 410 if (InitOpts.RetainRemappedFileBuffers) 411 SourceMgr.overrideFileContents(FromFile, RB.second->getMemBufferRef()); 412 else 413 SourceMgr.overrideFileContents( 414 FromFile, std::unique_ptr<llvm::MemoryBuffer>( 415 const_cast<llvm::MemoryBuffer *>(RB.second))); 416 } 417 418 // Remap files in the source manager (with other files). 419 for (const auto &RF : InitOpts.RemappedFiles) { 420 // Find the file that we're mapping to. 421 OptionalFileEntryRef ToFile = FileMgr.getOptionalFileRef(RF.second); 422 if (!ToFile) { 423 Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second; 424 continue; 425 } 426 427 // Create the file entry for the file that we're mapping from. 428 const FileEntry *FromFile = 429 FileMgr.getVirtualFile(RF.first, ToFile->getSize(), 0); 430 if (!FromFile) { 431 Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first; 432 continue; 433 } 434 435 // Override the contents of the "from" file with the contents of 436 // the "to" file. 437 SourceMgr.overrideFileContents(FromFile, *ToFile); 438 } 439 440 SourceMgr.setOverridenFilesKeepOriginalName( 441 InitOpts.RemappedFilesKeepOriginalName); 442 } 443 444 // Preprocessor 445 446 void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) { 447 const PreprocessorOptions &PPOpts = getPreprocessorOpts(); 448 449 // The AST reader holds a reference to the old preprocessor (if any). 450 TheASTReader.reset(); 451 452 // Create the Preprocessor. 453 HeaderSearch *HeaderInfo = 454 new HeaderSearch(getHeaderSearchOptsPtr(), getSourceManager(), 455 getDiagnostics(), getLangOpts(), &getTarget()); 456 PP = std::make_shared<Preprocessor>(Invocation->getPreprocessorOptsPtr(), 457 getDiagnostics(), getLangOpts(), 458 getSourceManager(), *HeaderInfo, *this, 459 /*IdentifierInfoLookup=*/nullptr, 460 /*OwnsHeaderSearch=*/true, TUKind); 461 getTarget().adjust(getDiagnostics(), getLangOpts()); 462 PP->Initialize(getTarget(), getAuxTarget()); 463 464 if (PPOpts.DetailedRecord) 465 PP->createPreprocessingRecord(); 466 467 // Apply remappings to the source manager. 468 InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(), 469 PP->getFileManager(), PPOpts); 470 471 // Predefine macros and configure the preprocessor. 472 InitializePreprocessor(*PP, PPOpts, getPCHContainerReader(), 473 getFrontendOpts(), getCodeGenOpts()); 474 475 // Initialize the header search object. In CUDA compilations, we use the aux 476 // triple (the host triple) to initialize our header search, since we need to 477 // find the host headers in order to compile the CUDA code. 478 const llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple(); 479 if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA && 480 PP->getAuxTargetInfo()) 481 HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple(); 482 483 ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(), 484 PP->getLangOpts(), *HeaderSearchTriple); 485 486 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP); 487 488 if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules) { 489 std::string ModuleHash = getInvocation().getModuleHash(); 490 PP->getHeaderSearchInfo().setModuleHash(ModuleHash); 491 PP->getHeaderSearchInfo().setModuleCachePath( 492 getSpecificModuleCachePath(ModuleHash)); 493 } 494 495 // Handle generating dependencies, if requested. 496 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts(); 497 if (!DepOpts.OutputFile.empty()) 498 addDependencyCollector(std::make_shared<DependencyFileGenerator>(DepOpts)); 499 if (!DepOpts.DOTOutputFile.empty()) 500 AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile, 501 getHeaderSearchOpts().Sysroot); 502 503 // If we don't have a collector, but we are collecting module dependencies, 504 // then we're the top level compiler instance and need to create one. 505 if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty()) { 506 ModuleDepCollector = std::make_shared<ModuleDependencyCollector>( 507 DepOpts.ModuleDependencyOutputDir); 508 } 509 510 // If there is a module dep collector, register with other dep collectors 511 // and also (a) collect header maps and (b) TODO: input vfs overlay files. 512 if (ModuleDepCollector) { 513 addDependencyCollector(ModuleDepCollector); 514 collectHeaderMaps(PP->getHeaderSearchInfo(), ModuleDepCollector); 515 collectIncludePCH(*this, ModuleDepCollector); 516 collectVFSEntries(*this, ModuleDepCollector); 517 } 518 519 for (auto &Listener : DependencyCollectors) 520 Listener->attachToPreprocessor(*PP); 521 522 // Handle generating header include information, if requested. 523 if (DepOpts.ShowHeaderIncludes) 524 AttachHeaderIncludeGen(*PP, DepOpts); 525 if (!DepOpts.HeaderIncludeOutputFile.empty()) { 526 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile; 527 if (OutputPath == "-") 528 OutputPath = ""; 529 AttachHeaderIncludeGen(*PP, DepOpts, 530 /*ShowAllHeaders=*/true, OutputPath, 531 /*ShowDepth=*/false); 532 } 533 534 if (DepOpts.ShowIncludesDest != ShowIncludesDestination::None) { 535 AttachHeaderIncludeGen(*PP, DepOpts, 536 /*ShowAllHeaders=*/true, /*OutputPath=*/"", 537 /*ShowDepth=*/true, /*MSStyle=*/true); 538 } 539 } 540 541 std::string CompilerInstance::getSpecificModuleCachePath(StringRef ModuleHash) { 542 // Set up the module path, including the hash for the module-creation options. 543 SmallString<256> SpecificModuleCache(getHeaderSearchOpts().ModuleCachePath); 544 if (!SpecificModuleCache.empty() && !getHeaderSearchOpts().DisableModuleHash) 545 llvm::sys::path::append(SpecificModuleCache, ModuleHash); 546 return std::string(SpecificModuleCache); 547 } 548 549 // ASTContext 550 551 void CompilerInstance::createASTContext() { 552 Preprocessor &PP = getPreprocessor(); 553 auto *Context = new ASTContext(getLangOpts(), PP.getSourceManager(), 554 PP.getIdentifierTable(), PP.getSelectorTable(), 555 PP.getBuiltinInfo(), PP.TUKind); 556 Context->InitBuiltinTypes(getTarget(), getAuxTarget()); 557 setASTContext(Context); 558 } 559 560 // ExternalASTSource 561 562 namespace { 563 // Helper to recursively read the module names for all modules we're adding. 564 // We mark these as known and redirect any attempt to load that module to 565 // the files we were handed. 566 struct ReadModuleNames : ASTReaderListener { 567 Preprocessor &PP; 568 llvm::SmallVector<std::string, 8> LoadedModules; 569 570 ReadModuleNames(Preprocessor &PP) : PP(PP) {} 571 572 void ReadModuleName(StringRef ModuleName) override { 573 // Keep the module name as a string for now. It's not safe to create a new 574 // IdentifierInfo from an ASTReader callback. 575 LoadedModules.push_back(ModuleName.str()); 576 } 577 578 void registerAll() { 579 ModuleMap &MM = PP.getHeaderSearchInfo().getModuleMap(); 580 for (const std::string &LoadedModule : LoadedModules) 581 MM.cacheModuleLoad(*PP.getIdentifierInfo(LoadedModule), 582 MM.findModule(LoadedModule)); 583 LoadedModules.clear(); 584 } 585 586 void markAllUnavailable() { 587 for (const std::string &LoadedModule : LoadedModules) { 588 if (Module *M = PP.getHeaderSearchInfo().getModuleMap().findModule( 589 LoadedModule)) { 590 M->HasIncompatibleModuleFile = true; 591 592 // Mark module as available if the only reason it was unavailable 593 // was missing headers. 594 SmallVector<Module *, 2> Stack; 595 Stack.push_back(M); 596 while (!Stack.empty()) { 597 Module *Current = Stack.pop_back_val(); 598 if (Current->IsUnimportable) continue; 599 Current->IsAvailable = true; 600 auto SubmodulesRange = Current->submodules(); 601 Stack.insert(Stack.end(), SubmodulesRange.begin(), 602 SubmodulesRange.end()); 603 } 604 } 605 } 606 LoadedModules.clear(); 607 } 608 }; 609 } // namespace 610 611 void CompilerInstance::createPCHExternalASTSource( 612 StringRef Path, DisableValidationForModuleKind DisableValidation, 613 bool AllowPCHWithCompilerErrors, void *DeserializationListener, 614 bool OwnDeserializationListener) { 615 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0; 616 TheASTReader = createPCHExternalASTSource( 617 Path, getHeaderSearchOpts().Sysroot, DisableValidation, 618 AllowPCHWithCompilerErrors, getPreprocessor(), getModuleCache(), 619 getASTContext(), getPCHContainerReader(), 620 getFrontendOpts().ModuleFileExtensions, DependencyCollectors, 621 DeserializationListener, OwnDeserializationListener, Preamble, 622 getFrontendOpts().UseGlobalModuleIndex); 623 } 624 625 IntrusiveRefCntPtr<ASTReader> CompilerInstance::createPCHExternalASTSource( 626 StringRef Path, StringRef Sysroot, 627 DisableValidationForModuleKind DisableValidation, 628 bool AllowPCHWithCompilerErrors, Preprocessor &PP, 629 InMemoryModuleCache &ModuleCache, ASTContext &Context, 630 const PCHContainerReader &PCHContainerRdr, 631 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions, 632 ArrayRef<std::shared_ptr<DependencyCollector>> DependencyCollectors, 633 void *DeserializationListener, bool OwnDeserializationListener, 634 bool Preamble, bool UseGlobalModuleIndex) { 635 HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts(); 636 637 IntrusiveRefCntPtr<ASTReader> Reader(new ASTReader( 638 PP, ModuleCache, &Context, PCHContainerRdr, Extensions, 639 Sysroot.empty() ? "" : Sysroot.data(), DisableValidation, 640 AllowPCHWithCompilerErrors, /*AllowConfigurationMismatch*/ false, 641 HSOpts.ModulesValidateSystemHeaders, HSOpts.ValidateASTInputFilesContent, 642 UseGlobalModuleIndex)); 643 644 // We need the external source to be set up before we read the AST, because 645 // eagerly-deserialized declarations may use it. 646 Context.setExternalSource(Reader.get()); 647 648 Reader->setDeserializationListener( 649 static_cast<ASTDeserializationListener *>(DeserializationListener), 650 /*TakeOwnership=*/OwnDeserializationListener); 651 652 for (auto &Listener : DependencyCollectors) 653 Listener->attachToASTReader(*Reader); 654 655 auto Listener = std::make_unique<ReadModuleNames>(PP); 656 auto &ListenerRef = *Listener; 657 ASTReader::ListenerScope ReadModuleNamesListener(*Reader, 658 std::move(Listener)); 659 660 switch (Reader->ReadAST(Path, 661 Preamble ? serialization::MK_Preamble 662 : serialization::MK_PCH, 663 SourceLocation(), 664 ASTReader::ARR_None)) { 665 case ASTReader::Success: 666 // Set the predefines buffer as suggested by the PCH reader. Typically, the 667 // predefines buffer will be empty. 668 PP.setPredefines(Reader->getSuggestedPredefines()); 669 ListenerRef.registerAll(); 670 return Reader; 671 672 case ASTReader::Failure: 673 // Unrecoverable failure: don't even try to process the input file. 674 break; 675 676 case ASTReader::Missing: 677 case ASTReader::OutOfDate: 678 case ASTReader::VersionMismatch: 679 case ASTReader::ConfigurationMismatch: 680 case ASTReader::HadErrors: 681 // No suitable PCH file could be found. Return an error. 682 break; 683 } 684 685 ListenerRef.markAllUnavailable(); 686 Context.setExternalSource(nullptr); 687 return nullptr; 688 } 689 690 // Code Completion 691 692 static bool EnableCodeCompletion(Preprocessor &PP, 693 StringRef Filename, 694 unsigned Line, 695 unsigned Column) { 696 // Tell the source manager to chop off the given file at a specific 697 // line and column. 698 auto Entry = PP.getFileManager().getOptionalFileRef(Filename); 699 if (!Entry) { 700 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file) 701 << Filename; 702 return true; 703 } 704 705 // Truncate the named file at the given line/column. 706 PP.SetCodeCompletionPoint(*Entry, Line, Column); 707 return false; 708 } 709 710 void CompilerInstance::createCodeCompletionConsumer() { 711 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt; 712 if (!CompletionConsumer) { 713 setCodeCompletionConsumer(createCodeCompletionConsumer( 714 getPreprocessor(), Loc.FileName, Loc.Line, Loc.Column, 715 getFrontendOpts().CodeCompleteOpts, llvm::outs())); 716 return; 717 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName, 718 Loc.Line, Loc.Column)) { 719 setCodeCompletionConsumer(nullptr); 720 return; 721 } 722 } 723 724 void CompilerInstance::createFrontendTimer() { 725 FrontendTimerGroup.reset( 726 new llvm::TimerGroup("frontend", "Clang front-end time report")); 727 FrontendTimer.reset( 728 new llvm::Timer("frontend", "Clang front-end timer", 729 *FrontendTimerGroup)); 730 } 731 732 CodeCompleteConsumer * 733 CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP, 734 StringRef Filename, 735 unsigned Line, 736 unsigned Column, 737 const CodeCompleteOptions &Opts, 738 raw_ostream &OS) { 739 if (EnableCodeCompletion(PP, Filename, Line, Column)) 740 return nullptr; 741 742 // Set up the creation routine for code-completion. 743 return new PrintingCodeCompleteConsumer(Opts, OS); 744 } 745 746 void CompilerInstance::createSema(TranslationUnitKind TUKind, 747 CodeCompleteConsumer *CompletionConsumer) { 748 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(), 749 TUKind, CompletionConsumer)); 750 751 // Set up API notes. 752 TheSema->APINotes.setSwiftVersion(getAPINotesOpts().SwiftVersion); 753 754 // Attach the external sema source if there is any. 755 if (ExternalSemaSrc) { 756 TheSema->addExternalSource(ExternalSemaSrc.get()); 757 ExternalSemaSrc->InitializeSema(*TheSema); 758 } 759 760 // If we're building a module and are supposed to load API notes, 761 // notify the API notes manager. 762 if (auto *currentModule = getPreprocessor().getCurrentModule()) { 763 (void)TheSema->APINotes.loadCurrentModuleAPINotes( 764 currentModule, getLangOpts().APINotesModules, 765 getAPINotesOpts().ModuleSearchPaths); 766 } 767 } 768 769 // Output Files 770 771 void CompilerInstance::clearOutputFiles(bool EraseFiles) { 772 // The ASTConsumer can own streams that write to the output files. 773 assert(!hasASTConsumer() && "ASTConsumer should be reset"); 774 // Ignore errors that occur when trying to discard the temp file. 775 for (OutputFile &OF : OutputFiles) { 776 if (EraseFiles) { 777 if (OF.File) 778 consumeError(OF.File->discard()); 779 if (!OF.Filename.empty()) 780 llvm::sys::fs::remove(OF.Filename); 781 continue; 782 } 783 784 if (!OF.File) 785 continue; 786 787 if (OF.File->TmpName.empty()) { 788 consumeError(OF.File->discard()); 789 continue; 790 } 791 792 llvm::Error E = OF.File->keep(OF.Filename); 793 if (!E) 794 continue; 795 796 getDiagnostics().Report(diag::err_unable_to_rename_temp) 797 << OF.File->TmpName << OF.Filename << std::move(E); 798 799 llvm::sys::fs::remove(OF.File->TmpName); 800 } 801 OutputFiles.clear(); 802 if (DeleteBuiltModules) { 803 for (auto &Module : BuiltModules) 804 llvm::sys::fs::remove(Module.second); 805 BuiltModules.clear(); 806 } 807 } 808 809 std::unique_ptr<raw_pwrite_stream> CompilerInstance::createDefaultOutputFile( 810 bool Binary, StringRef InFile, StringRef Extension, bool RemoveFileOnSignal, 811 bool CreateMissingDirectories, bool ForceUseTemporary) { 812 StringRef OutputPath = getFrontendOpts().OutputFile; 813 std::optional<SmallString<128>> PathStorage; 814 if (OutputPath.empty()) { 815 if (InFile == "-" || Extension.empty()) { 816 OutputPath = "-"; 817 } else { 818 PathStorage.emplace(InFile); 819 llvm::sys::path::replace_extension(*PathStorage, Extension); 820 OutputPath = *PathStorage; 821 } 822 } 823 824 return createOutputFile(OutputPath, Binary, RemoveFileOnSignal, 825 getFrontendOpts().UseTemporary || ForceUseTemporary, 826 CreateMissingDirectories); 827 } 828 829 std::unique_ptr<raw_pwrite_stream> CompilerInstance::createNullOutputFile() { 830 return std::make_unique<llvm::raw_null_ostream>(); 831 } 832 833 std::unique_ptr<raw_pwrite_stream> 834 CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary, 835 bool RemoveFileOnSignal, bool UseTemporary, 836 bool CreateMissingDirectories) { 837 Expected<std::unique_ptr<raw_pwrite_stream>> OS = 838 createOutputFileImpl(OutputPath, Binary, RemoveFileOnSignal, UseTemporary, 839 CreateMissingDirectories); 840 if (OS) 841 return std::move(*OS); 842 getDiagnostics().Report(diag::err_fe_unable_to_open_output) 843 << OutputPath << errorToErrorCode(OS.takeError()).message(); 844 return nullptr; 845 } 846 847 Expected<std::unique_ptr<llvm::raw_pwrite_stream>> 848 CompilerInstance::createOutputFileImpl(StringRef OutputPath, bool Binary, 849 bool RemoveFileOnSignal, 850 bool UseTemporary, 851 bool CreateMissingDirectories) { 852 assert((!CreateMissingDirectories || UseTemporary) && 853 "CreateMissingDirectories is only allowed when using temporary files"); 854 855 // If '-working-directory' was passed, the output filename should be 856 // relative to that. 857 std::optional<SmallString<128>> AbsPath; 858 if (OutputPath != "-" && !llvm::sys::path::is_absolute(OutputPath)) { 859 assert(hasFileManager() && 860 "File Manager is required to fix up relative path.\n"); 861 862 AbsPath.emplace(OutputPath); 863 FileMgr->FixupRelativePath(*AbsPath); 864 OutputPath = *AbsPath; 865 } 866 867 std::unique_ptr<llvm::raw_fd_ostream> OS; 868 std::optional<StringRef> OSFile; 869 870 if (UseTemporary) { 871 if (OutputPath == "-") 872 UseTemporary = false; 873 else { 874 llvm::sys::fs::file_status Status; 875 llvm::sys::fs::status(OutputPath, Status); 876 if (llvm::sys::fs::exists(Status)) { 877 // Fail early if we can't write to the final destination. 878 if (!llvm::sys::fs::can_write(OutputPath)) 879 return llvm::errorCodeToError( 880 make_error_code(llvm::errc::operation_not_permitted)); 881 882 // Don't use a temporary if the output is a special file. This handles 883 // things like '-o /dev/null' 884 if (!llvm::sys::fs::is_regular_file(Status)) 885 UseTemporary = false; 886 } 887 } 888 } 889 890 std::optional<llvm::sys::fs::TempFile> Temp; 891 if (UseTemporary) { 892 // Create a temporary file. 893 // Insert -%%%%%%%% before the extension (if any), and because some tools 894 // (noticeable, clang's own GlobalModuleIndex.cpp) glob for build 895 // artifacts, also append .tmp. 896 StringRef OutputExtension = llvm::sys::path::extension(OutputPath); 897 SmallString<128> TempPath = 898 StringRef(OutputPath).drop_back(OutputExtension.size()); 899 TempPath += "-%%%%%%%%"; 900 TempPath += OutputExtension; 901 TempPath += ".tmp"; 902 llvm::sys::fs::OpenFlags BinaryFlags = 903 Binary ? llvm::sys::fs::OF_None : llvm::sys::fs::OF_Text; 904 Expected<llvm::sys::fs::TempFile> ExpectedFile = 905 llvm::sys::fs::TempFile::create( 906 TempPath, llvm::sys::fs::all_read | llvm::sys::fs::all_write, 907 BinaryFlags); 908 909 llvm::Error E = handleErrors( 910 ExpectedFile.takeError(), [&](const llvm::ECError &E) -> llvm::Error { 911 std::error_code EC = E.convertToErrorCode(); 912 if (CreateMissingDirectories && 913 EC == llvm::errc::no_such_file_or_directory) { 914 StringRef Parent = llvm::sys::path::parent_path(OutputPath); 915 EC = llvm::sys::fs::create_directories(Parent); 916 if (!EC) { 917 ExpectedFile = llvm::sys::fs::TempFile::create( 918 TempPath, llvm::sys::fs::all_read | llvm::sys::fs::all_write, 919 BinaryFlags); 920 if (!ExpectedFile) 921 return llvm::errorCodeToError( 922 llvm::errc::no_such_file_or_directory); 923 } 924 } 925 return llvm::errorCodeToError(EC); 926 }); 927 928 if (E) { 929 consumeError(std::move(E)); 930 } else { 931 Temp = std::move(ExpectedFile.get()); 932 OS.reset(new llvm::raw_fd_ostream(Temp->FD, /*shouldClose=*/false)); 933 OSFile = Temp->TmpName; 934 } 935 // If we failed to create the temporary, fallback to writing to the file 936 // directly. This handles the corner case where we cannot write to the 937 // directory, but can write to the file. 938 } 939 940 if (!OS) { 941 OSFile = OutputPath; 942 std::error_code EC; 943 OS.reset(new llvm::raw_fd_ostream( 944 *OSFile, EC, 945 (Binary ? llvm::sys::fs::OF_None : llvm::sys::fs::OF_TextWithCRLF))); 946 if (EC) 947 return llvm::errorCodeToError(EC); 948 } 949 950 // Add the output file -- but don't try to remove "-", since this means we are 951 // using stdin. 952 OutputFiles.emplace_back(((OutputPath != "-") ? OutputPath : "").str(), 953 std::move(Temp)); 954 955 if (!Binary || OS->supportsSeeking()) 956 return std::move(OS); 957 958 return std::make_unique<llvm::buffer_unique_ostream>(std::move(OS)); 959 } 960 961 // Initialization Utilities 962 963 bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){ 964 return InitializeSourceManager(Input, getDiagnostics(), getFileManager(), 965 getSourceManager()); 966 } 967 968 // static 969 bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input, 970 DiagnosticsEngine &Diags, 971 FileManager &FileMgr, 972 SourceManager &SourceMgr) { 973 SrcMgr::CharacteristicKind Kind = 974 Input.getKind().getFormat() == InputKind::ModuleMap 975 ? Input.isSystem() ? SrcMgr::C_System_ModuleMap 976 : SrcMgr::C_User_ModuleMap 977 : Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User; 978 979 if (Input.isBuffer()) { 980 SourceMgr.setMainFileID(SourceMgr.createFileID(Input.getBuffer(), Kind)); 981 assert(SourceMgr.getMainFileID().isValid() && 982 "Couldn't establish MainFileID!"); 983 return true; 984 } 985 986 StringRef InputFile = Input.getFile(); 987 988 // Figure out where to get and map in the main file. 989 auto FileOrErr = InputFile == "-" 990 ? FileMgr.getSTDIN() 991 : FileMgr.getFileRef(InputFile, /*OpenFile=*/true); 992 if (!FileOrErr) { 993 auto EC = llvm::errorToErrorCode(FileOrErr.takeError()); 994 if (InputFile != "-") 995 Diags.Report(diag::err_fe_error_reading) << InputFile << EC.message(); 996 else 997 Diags.Report(diag::err_fe_error_reading_stdin) << EC.message(); 998 return false; 999 } 1000 1001 SourceMgr.setMainFileID( 1002 SourceMgr.createFileID(*FileOrErr, SourceLocation(), Kind)); 1003 1004 assert(SourceMgr.getMainFileID().isValid() && 1005 "Couldn't establish MainFileID!"); 1006 return true; 1007 } 1008 1009 // High-Level Operations 1010 1011 bool CompilerInstance::ExecuteAction(FrontendAction &Act) { 1012 assert(hasDiagnostics() && "Diagnostics engine is not initialized!"); 1013 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!"); 1014 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!"); 1015 1016 // Mark this point as the bottom of the stack if we don't have somewhere 1017 // better. We generally expect frontend actions to be invoked with (nearly) 1018 // DesiredStackSpace available. 1019 noteBottomOfStack(); 1020 1021 auto FinishDiagnosticClient = llvm::make_scope_exit([&]() { 1022 // Notify the diagnostic client that all files were processed. 1023 getDiagnosticClient().finish(); 1024 }); 1025 1026 raw_ostream &OS = getVerboseOutputStream(); 1027 1028 if (!Act.PrepareToExecute(*this)) 1029 return false; 1030 1031 if (!createTarget()) 1032 return false; 1033 1034 // rewriter project will change target built-in bool type from its default. 1035 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC) 1036 getTarget().noSignedCharForObjCBool(); 1037 1038 // Validate/process some options. 1039 if (getHeaderSearchOpts().Verbose) 1040 OS << "clang -cc1 version " CLANG_VERSION_STRING << " based upon LLVM " 1041 << LLVM_VERSION_STRING << " default target " 1042 << llvm::sys::getDefaultTargetTriple() << "\n"; 1043 1044 if (getCodeGenOpts().TimePasses) 1045 createFrontendTimer(); 1046 1047 if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty()) 1048 llvm::EnableStatistics(false); 1049 1050 for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) { 1051 // Reset the ID tables if we are reusing the SourceManager and parsing 1052 // regular files. 1053 if (hasSourceManager() && !Act.isModelParsingAction()) 1054 getSourceManager().clearIDTables(); 1055 1056 if (Act.BeginSourceFile(*this, FIF)) { 1057 if (llvm::Error Err = Act.Execute()) { 1058 consumeError(std::move(Err)); // FIXME this drops errors on the floor. 1059 } 1060 Act.EndSourceFile(); 1061 } 1062 } 1063 1064 if (getDiagnosticOpts().ShowCarets) { 1065 // We can have multiple diagnostics sharing one diagnostic client. 1066 // Get the total number of warnings/errors from the client. 1067 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings(); 1068 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors(); 1069 1070 if (NumWarnings) 1071 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s"); 1072 if (NumWarnings && NumErrors) 1073 OS << " and "; 1074 if (NumErrors) 1075 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s"); 1076 if (NumWarnings || NumErrors) { 1077 OS << " generated"; 1078 if (getLangOpts().CUDA) { 1079 if (!getLangOpts().CUDAIsDevice) { 1080 OS << " when compiling for host"; 1081 } else { 1082 OS << " when compiling for " << getTargetOpts().CPU; 1083 } 1084 } 1085 OS << ".\n"; 1086 } 1087 } 1088 1089 if (getFrontendOpts().ShowStats) { 1090 if (hasFileManager()) { 1091 getFileManager().PrintStats(); 1092 OS << '\n'; 1093 } 1094 llvm::PrintStatistics(OS); 1095 } 1096 StringRef StatsFile = getFrontendOpts().StatsFile; 1097 if (!StatsFile.empty()) { 1098 llvm::sys::fs::OpenFlags FileFlags = llvm::sys::fs::OF_TextWithCRLF; 1099 if (getFrontendOpts().AppendStats) 1100 FileFlags |= llvm::sys::fs::OF_Append; 1101 std::error_code EC; 1102 auto StatS = 1103 std::make_unique<llvm::raw_fd_ostream>(StatsFile, EC, FileFlags); 1104 if (EC) { 1105 getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file) 1106 << StatsFile << EC.message(); 1107 } else { 1108 llvm::PrintStatisticsJSON(*StatS); 1109 } 1110 } 1111 1112 return !getDiagnostics().getClient()->getNumErrors(); 1113 } 1114 1115 void CompilerInstance::LoadRequestedPlugins() { 1116 // Load any requested plugins. 1117 for (const std::string &Path : getFrontendOpts().Plugins) { 1118 std::string Error; 1119 if (llvm::sys::DynamicLibrary::LoadLibraryPermanently(Path.c_str(), &Error)) 1120 getDiagnostics().Report(diag::err_fe_unable_to_load_plugin) 1121 << Path << Error; 1122 } 1123 1124 // Check if any of the loaded plugins replaces the main AST action 1125 for (const FrontendPluginRegistry::entry &Plugin : 1126 FrontendPluginRegistry::entries()) { 1127 std::unique_ptr<PluginASTAction> P(Plugin.instantiate()); 1128 if (P->getActionType() == PluginASTAction::ReplaceAction) { 1129 getFrontendOpts().ProgramAction = clang::frontend::PluginAction; 1130 getFrontendOpts().ActionName = Plugin.getName().str(); 1131 break; 1132 } 1133 } 1134 } 1135 1136 /// Determine the appropriate source input kind based on language 1137 /// options. 1138 static Language getLanguageFromOptions(const LangOptions &LangOpts) { 1139 if (LangOpts.OpenCL) 1140 return Language::OpenCL; 1141 if (LangOpts.CUDA) 1142 return Language::CUDA; 1143 if (LangOpts.ObjC) 1144 return LangOpts.CPlusPlus ? Language::ObjCXX : Language::ObjC; 1145 return LangOpts.CPlusPlus ? Language::CXX : Language::C; 1146 } 1147 1148 /// Compile a module file for the given module, using the options 1149 /// provided by the importing compiler instance. Returns true if the module 1150 /// was built without errors. 1151 static bool 1152 compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, 1153 StringRef ModuleName, FrontendInputFile Input, 1154 StringRef OriginalModuleMapFile, StringRef ModuleFileName, 1155 llvm::function_ref<void(CompilerInstance &)> PreBuildStep = 1156 [](CompilerInstance &) {}, 1157 llvm::function_ref<void(CompilerInstance &)> PostBuildStep = 1158 [](CompilerInstance &) {}) { 1159 llvm::TimeTraceScope TimeScope("Module Compile", ModuleName); 1160 1161 // Never compile a module that's already finalized - this would cause the 1162 // existing module to be freed, causing crashes if it is later referenced 1163 if (ImportingInstance.getModuleCache().isPCMFinal(ModuleFileName)) { 1164 ImportingInstance.getDiagnostics().Report( 1165 ImportLoc, diag::err_module_rebuild_finalized) 1166 << ModuleName; 1167 return false; 1168 } 1169 1170 // Construct a compiler invocation for creating this module. 1171 auto Invocation = 1172 std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation()); 1173 1174 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); 1175 1176 // For any options that aren't intended to affect how a module is built, 1177 // reset them to their default values. 1178 Invocation->resetNonModularOptions(); 1179 1180 // Remove any macro definitions that are explicitly ignored by the module. 1181 // They aren't supposed to affect how the module is built anyway. 1182 HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts(); 1183 llvm::erase_if(PPOpts.Macros, 1184 [&HSOpts](const std::pair<std::string, bool> &def) { 1185 StringRef MacroDef = def.first; 1186 return HSOpts.ModulesIgnoreMacros.contains( 1187 llvm::CachedHashString(MacroDef.split('=').first)); 1188 }); 1189 1190 // If the original compiler invocation had -fmodule-name, pass it through. 1191 Invocation->getLangOpts().ModuleName = 1192 ImportingInstance.getInvocation().getLangOpts().ModuleName; 1193 1194 // Note the name of the module we're building. 1195 Invocation->getLangOpts().CurrentModule = std::string(ModuleName); 1196 1197 // Make sure that the failed-module structure has been allocated in 1198 // the importing instance, and propagate the pointer to the newly-created 1199 // instance. 1200 PreprocessorOptions &ImportingPPOpts 1201 = ImportingInstance.getInvocation().getPreprocessorOpts(); 1202 if (!ImportingPPOpts.FailedModules) 1203 ImportingPPOpts.FailedModules = 1204 std::make_shared<PreprocessorOptions::FailedModulesSet>(); 1205 PPOpts.FailedModules = ImportingPPOpts.FailedModules; 1206 1207 // If there is a module map file, build the module using the module map. 1208 // Set up the inputs/outputs so that we build the module from its umbrella 1209 // header. 1210 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts(); 1211 FrontendOpts.OutputFile = ModuleFileName.str(); 1212 FrontendOpts.DisableFree = false; 1213 FrontendOpts.GenerateGlobalModuleIndex = false; 1214 FrontendOpts.BuildingImplicitModule = true; 1215 FrontendOpts.OriginalModuleMap = std::string(OriginalModuleMapFile); 1216 // Force implicitly-built modules to hash the content of the module file. 1217 HSOpts.ModulesHashContent = true; 1218 FrontendOpts.Inputs = {Input}; 1219 1220 // Don't free the remapped file buffers; they are owned by our caller. 1221 PPOpts.RetainRemappedFileBuffers = true; 1222 1223 DiagnosticOptions &DiagOpts = Invocation->getDiagnosticOpts(); 1224 1225 DiagOpts.VerifyDiagnostics = 0; 1226 assert(ImportingInstance.getInvocation().getModuleHash() == 1227 Invocation->getModuleHash() && "Module hash mismatch!"); 1228 1229 // Construct a compiler instance that will be used to actually create the 1230 // module. Since we're sharing an in-memory module cache, 1231 // CompilerInstance::CompilerInstance is responsible for finalizing the 1232 // buffers to prevent use-after-frees. 1233 CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(), 1234 &ImportingInstance.getModuleCache()); 1235 auto &Inv = *Invocation; 1236 Instance.setInvocation(std::move(Invocation)); 1237 1238 Instance.createDiagnostics(new ForwardingDiagnosticConsumer( 1239 ImportingInstance.getDiagnosticClient()), 1240 /*ShouldOwnClient=*/true); 1241 1242 if (llvm::is_contained(DiagOpts.SystemHeaderWarningsModules, ModuleName)) 1243 Instance.getDiagnostics().setSuppressSystemWarnings(false); 1244 1245 if (FrontendOpts.ModulesShareFileManager) { 1246 Instance.setFileManager(&ImportingInstance.getFileManager()); 1247 } else { 1248 Instance.createFileManager(&ImportingInstance.getVirtualFileSystem()); 1249 } 1250 Instance.createSourceManager(Instance.getFileManager()); 1251 SourceManager &SourceMgr = Instance.getSourceManager(); 1252 1253 // Note that this module is part of the module build stack, so that we 1254 // can detect cycles in the module graph. 1255 SourceMgr.setModuleBuildStack( 1256 ImportingInstance.getSourceManager().getModuleBuildStack()); 1257 SourceMgr.pushModuleBuildStack(ModuleName, 1258 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager())); 1259 1260 // If we're collecting module dependencies, we need to share a collector 1261 // between all of the module CompilerInstances. Other than that, we don't 1262 // want to produce any dependency output from the module build. 1263 Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector()); 1264 Inv.getDependencyOutputOpts() = DependencyOutputOptions(); 1265 1266 ImportingInstance.getDiagnostics().Report(ImportLoc, 1267 diag::remark_module_build) 1268 << ModuleName << ModuleFileName; 1269 1270 PreBuildStep(Instance); 1271 1272 // Execute the action to actually build the module in-place. Use a separate 1273 // thread so that we get a stack large enough. 1274 bool Crashed = !llvm::CrashRecoveryContext().RunSafelyOnThread( 1275 [&]() { 1276 GenerateModuleFromModuleMapAction Action; 1277 Instance.ExecuteAction(Action); 1278 }, 1279 DesiredStackSize); 1280 1281 PostBuildStep(Instance); 1282 1283 ImportingInstance.getDiagnostics().Report(ImportLoc, 1284 diag::remark_module_build_done) 1285 << ModuleName; 1286 1287 if (Crashed) { 1288 // Clear the ASTConsumer if it hasn't been already, in case it owns streams 1289 // that must be closed before clearing output files. 1290 Instance.setSema(nullptr); 1291 Instance.setASTConsumer(nullptr); 1292 1293 // Delete any remaining temporary files related to Instance. 1294 Instance.clearOutputFiles(/*EraseFiles=*/true); 1295 } 1296 1297 // If \p AllowPCMWithCompilerErrors is set return 'success' even if errors 1298 // occurred. 1299 return !Instance.getDiagnostics().hasErrorOccurred() || 1300 Instance.getFrontendOpts().AllowPCMWithCompilerErrors; 1301 } 1302 1303 static OptionalFileEntryRef getPublicModuleMap(FileEntryRef File, 1304 FileManager &FileMgr) { 1305 StringRef Filename = llvm::sys::path::filename(File.getName()); 1306 SmallString<128> PublicFilename(File.getDir().getName()); 1307 if (Filename == "module_private.map") 1308 llvm::sys::path::append(PublicFilename, "module.map"); 1309 else if (Filename == "module.private.modulemap") 1310 llvm::sys::path::append(PublicFilename, "module.modulemap"); 1311 else 1312 return std::nullopt; 1313 return FileMgr.getOptionalFileRef(PublicFilename); 1314 } 1315 1316 /// Compile a module file for the given module in a separate compiler instance, 1317 /// using the options provided by the importing compiler instance. Returns true 1318 /// if the module was built without errors. 1319 static bool compileModule(CompilerInstance &ImportingInstance, 1320 SourceLocation ImportLoc, Module *Module, 1321 StringRef ModuleFileName) { 1322 InputKind IK(getLanguageFromOptions(ImportingInstance.getLangOpts()), 1323 InputKind::ModuleMap); 1324 1325 // Get or create the module map that we'll use to build this module. 1326 ModuleMap &ModMap 1327 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap(); 1328 bool Result; 1329 if (OptionalFileEntryRef ModuleMapFile = 1330 ModMap.getContainingModuleMapFile(Module)) { 1331 // Canonicalize compilation to start with the public module map. This is 1332 // vital for submodules declarations in the private module maps to be 1333 // correctly parsed when depending on a top level module in the public one. 1334 if (OptionalFileEntryRef PublicMMFile = getPublicModuleMap( 1335 *ModuleMapFile, ImportingInstance.getFileManager())) 1336 ModuleMapFile = PublicMMFile; 1337 1338 StringRef ModuleMapFilePath = ModuleMapFile->getNameAsRequested(); 1339 1340 // Use the module map where this module resides. 1341 Result = compileModuleImpl( 1342 ImportingInstance, ImportLoc, Module->getTopLevelModuleName(), 1343 FrontendInputFile(ModuleMapFilePath, IK, +Module->IsSystem), 1344 ModMap.getModuleMapFileForUniquing(Module)->getName(), ModuleFileName); 1345 } else { 1346 // FIXME: We only need to fake up an input file here as a way of 1347 // transporting the module's directory to the module map parser. We should 1348 // be able to do that more directly, and parse from a memory buffer without 1349 // inventing this file. 1350 SmallString<128> FakeModuleMapFile(Module->Directory->getName()); 1351 llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map"); 1352 1353 std::string InferredModuleMapContent; 1354 llvm::raw_string_ostream OS(InferredModuleMapContent); 1355 Module->print(OS); 1356 OS.flush(); 1357 1358 Result = compileModuleImpl( 1359 ImportingInstance, ImportLoc, Module->getTopLevelModuleName(), 1360 FrontendInputFile(FakeModuleMapFile, IK, +Module->IsSystem), 1361 ModMap.getModuleMapFileForUniquing(Module)->getName(), 1362 ModuleFileName, 1363 [&](CompilerInstance &Instance) { 1364 std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer = 1365 llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent); 1366 FileEntryRef ModuleMapFile = Instance.getFileManager().getVirtualFileRef( 1367 FakeModuleMapFile, InferredModuleMapContent.size(), 0); 1368 Instance.getSourceManager().overrideFileContents( 1369 ModuleMapFile, std::move(ModuleMapBuffer)); 1370 }); 1371 } 1372 1373 // We've rebuilt a module. If we're allowed to generate or update the global 1374 // module index, record that fact in the importing compiler instance. 1375 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) { 1376 ImportingInstance.setBuildGlobalModuleIndex(true); 1377 } 1378 1379 return Result; 1380 } 1381 1382 /// Read the AST right after compiling the module. 1383 static bool readASTAfterCompileModule(CompilerInstance &ImportingInstance, 1384 SourceLocation ImportLoc, 1385 SourceLocation ModuleNameLoc, 1386 Module *Module, StringRef ModuleFileName, 1387 bool *OutOfDate) { 1388 DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics(); 1389 1390 unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing; 1391 if (OutOfDate) 1392 ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate; 1393 1394 // Try to read the module file, now that we've compiled it. 1395 ASTReader::ASTReadResult ReadResult = 1396 ImportingInstance.getASTReader()->ReadAST( 1397 ModuleFileName, serialization::MK_ImplicitModule, ImportLoc, 1398 ModuleLoadCapabilities); 1399 if (ReadResult == ASTReader::Success) 1400 return true; 1401 1402 // The caller wants to handle out-of-date failures. 1403 if (OutOfDate && ReadResult == ASTReader::OutOfDate) { 1404 *OutOfDate = true; 1405 return false; 1406 } 1407 1408 // The ASTReader didn't diagnose the error, so conservatively report it. 1409 if (ReadResult == ASTReader::Missing || !Diags.hasErrorOccurred()) 1410 Diags.Report(ModuleNameLoc, diag::err_module_not_built) 1411 << Module->Name << SourceRange(ImportLoc, ModuleNameLoc); 1412 1413 return false; 1414 } 1415 1416 /// Compile a module in a separate compiler instance and read the AST, 1417 /// returning true if the module compiles without errors. 1418 static bool compileModuleAndReadASTImpl(CompilerInstance &ImportingInstance, 1419 SourceLocation ImportLoc, 1420 SourceLocation ModuleNameLoc, 1421 Module *Module, 1422 StringRef ModuleFileName) { 1423 if (!compileModule(ImportingInstance, ModuleNameLoc, Module, 1424 ModuleFileName)) { 1425 ImportingInstance.getDiagnostics().Report(ModuleNameLoc, 1426 diag::err_module_not_built) 1427 << Module->Name << SourceRange(ImportLoc, ModuleNameLoc); 1428 return false; 1429 } 1430 1431 return readASTAfterCompileModule(ImportingInstance, ImportLoc, ModuleNameLoc, 1432 Module, ModuleFileName, 1433 /*OutOfDate=*/nullptr); 1434 } 1435 1436 /// Compile a module in a separate compiler instance and read the AST, 1437 /// returning true if the module compiles without errors, using a lock manager 1438 /// to avoid building the same module in multiple compiler instances. 1439 /// 1440 /// Uses a lock file manager and exponential backoff to reduce the chances that 1441 /// multiple instances will compete to create the same module. On timeout, 1442 /// deletes the lock file in order to avoid deadlock from crashing processes or 1443 /// bugs in the lock file manager. 1444 static bool compileModuleAndReadASTBehindLock( 1445 CompilerInstance &ImportingInstance, SourceLocation ImportLoc, 1446 SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName) { 1447 DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics(); 1448 1449 Diags.Report(ModuleNameLoc, diag::remark_module_lock) 1450 << ModuleFileName << Module->Name; 1451 1452 // FIXME: have LockFileManager return an error_code so that we can 1453 // avoid the mkdir when the directory already exists. 1454 StringRef Dir = llvm::sys::path::parent_path(ModuleFileName); 1455 llvm::sys::fs::create_directories(Dir); 1456 1457 while (true) { 1458 llvm::LockFileManager Locked(ModuleFileName); 1459 switch (Locked) { 1460 case llvm::LockFileManager::LFS_Error: 1461 // ModuleCache takes care of correctness and locks are only necessary for 1462 // performance. Fallback to building the module in case of any lock 1463 // related errors. 1464 Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure) 1465 << Module->Name << Locked.getErrorMessage(); 1466 // Clear out any potential leftover. 1467 Locked.unsafeRemoveLockFile(); 1468 [[fallthrough]]; 1469 case llvm::LockFileManager::LFS_Owned: 1470 // We're responsible for building the module ourselves. 1471 return compileModuleAndReadASTImpl(ImportingInstance, ImportLoc, 1472 ModuleNameLoc, Module, ModuleFileName); 1473 1474 case llvm::LockFileManager::LFS_Shared: 1475 break; // The interesting case. 1476 } 1477 1478 // Someone else is responsible for building the module. Wait for them to 1479 // finish. 1480 switch (Locked.waitForUnlock()) { 1481 case llvm::LockFileManager::Res_Success: 1482 break; // The interesting case. 1483 case llvm::LockFileManager::Res_OwnerDied: 1484 continue; // try again to get the lock. 1485 case llvm::LockFileManager::Res_Timeout: 1486 // Since ModuleCache takes care of correctness, we try waiting for 1487 // another process to complete the build so clang does not do it done 1488 // twice. If case of timeout, build it ourselves. 1489 Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout) 1490 << Module->Name; 1491 // Clear the lock file so that future invocations can make progress. 1492 Locked.unsafeRemoveLockFile(); 1493 continue; 1494 } 1495 1496 // Read the module that was just written by someone else. 1497 bool OutOfDate = false; 1498 if (readASTAfterCompileModule(ImportingInstance, ImportLoc, ModuleNameLoc, 1499 Module, ModuleFileName, &OutOfDate)) 1500 return true; 1501 if (!OutOfDate) 1502 return false; 1503 1504 // The module may be out of date in the presence of file system races, 1505 // or if one of its imports depends on header search paths that are not 1506 // consistent with this ImportingInstance. Try again... 1507 } 1508 } 1509 1510 /// Compile a module in a separate compiler instance and read the AST, 1511 /// returning true if the module compiles without errors, potentially using a 1512 /// lock manager to avoid building the same module in multiple compiler 1513 /// instances. 1514 static bool compileModuleAndReadAST(CompilerInstance &ImportingInstance, 1515 SourceLocation ImportLoc, 1516 SourceLocation ModuleNameLoc, 1517 Module *Module, StringRef ModuleFileName) { 1518 return ImportingInstance.getInvocation() 1519 .getFrontendOpts() 1520 .BuildingImplicitModuleUsesLock 1521 ? compileModuleAndReadASTBehindLock(ImportingInstance, ImportLoc, 1522 ModuleNameLoc, Module, 1523 ModuleFileName) 1524 : compileModuleAndReadASTImpl(ImportingInstance, ImportLoc, 1525 ModuleNameLoc, Module, 1526 ModuleFileName); 1527 } 1528 1529 /// Diagnose differences between the current definition of the given 1530 /// configuration macro and the definition provided on the command line. 1531 static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro, 1532 Module *Mod, SourceLocation ImportLoc) { 1533 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro); 1534 SourceManager &SourceMgr = PP.getSourceManager(); 1535 1536 // If this identifier has never had a macro definition, then it could 1537 // not have changed. 1538 if (!Id->hadMacroDefinition()) 1539 return; 1540 auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id); 1541 1542 // Find the macro definition from the command line. 1543 MacroInfo *CmdLineDefinition = nullptr; 1544 for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) { 1545 // We only care about the predefines buffer. 1546 FileID FID = SourceMgr.getFileID(MD->getLocation()); 1547 if (FID.isInvalid() || FID != PP.getPredefinesFileID()) 1548 continue; 1549 if (auto *DMD = dyn_cast<DefMacroDirective>(MD)) 1550 CmdLineDefinition = DMD->getMacroInfo(); 1551 break; 1552 } 1553 1554 auto *CurrentDefinition = PP.getMacroInfo(Id); 1555 if (CurrentDefinition == CmdLineDefinition) { 1556 // Macro matches. Nothing to do. 1557 } else if (!CurrentDefinition) { 1558 // This macro was defined on the command line, then #undef'd later. 1559 // Complain. 1560 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) 1561 << true << ConfigMacro << Mod->getFullModuleName(); 1562 auto LatestDef = LatestLocalMD->getDefinition(); 1563 assert(LatestDef.isUndefined() && 1564 "predefined macro went away with no #undef?"); 1565 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here) 1566 << true; 1567 return; 1568 } else if (!CmdLineDefinition) { 1569 // There was no definition for this macro in the predefines buffer, 1570 // but there was a local definition. Complain. 1571 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) 1572 << false << ConfigMacro << Mod->getFullModuleName(); 1573 PP.Diag(CurrentDefinition->getDefinitionLoc(), 1574 diag::note_module_def_undef_here) 1575 << false; 1576 } else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP, 1577 /*Syntactically=*/true)) { 1578 // The macro definitions differ. 1579 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef) 1580 << false << ConfigMacro << Mod->getFullModuleName(); 1581 PP.Diag(CurrentDefinition->getDefinitionLoc(), 1582 diag::note_module_def_undef_here) 1583 << false; 1584 } 1585 } 1586 1587 /// Write a new timestamp file with the given path. 1588 static void writeTimestampFile(StringRef TimestampFile) { 1589 std::error_code EC; 1590 llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::OF_None); 1591 } 1592 1593 /// Prune the module cache of modules that haven't been accessed in 1594 /// a long time. 1595 static void pruneModuleCache(const HeaderSearchOptions &HSOpts) { 1596 llvm::sys::fs::file_status StatBuf; 1597 llvm::SmallString<128> TimestampFile; 1598 TimestampFile = HSOpts.ModuleCachePath; 1599 assert(!TimestampFile.empty()); 1600 llvm::sys::path::append(TimestampFile, "modules.timestamp"); 1601 1602 // Try to stat() the timestamp file. 1603 if (std::error_code EC = llvm::sys::fs::status(TimestampFile, StatBuf)) { 1604 // If the timestamp file wasn't there, create one now. 1605 if (EC == std::errc::no_such_file_or_directory) { 1606 writeTimestampFile(TimestampFile); 1607 } 1608 return; 1609 } 1610 1611 // Check whether the time stamp is older than our pruning interval. 1612 // If not, do nothing. 1613 time_t TimeStampModTime = 1614 llvm::sys::toTimeT(StatBuf.getLastModificationTime()); 1615 time_t CurrentTime = time(nullptr); 1616 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval)) 1617 return; 1618 1619 // Write a new timestamp file so that nobody else attempts to prune. 1620 // There is a benign race condition here, if two Clang instances happen to 1621 // notice at the same time that the timestamp is out-of-date. 1622 writeTimestampFile(TimestampFile); 1623 1624 // Walk the entire module cache, looking for unused module files and module 1625 // indices. 1626 std::error_code EC; 1627 SmallString<128> ModuleCachePathNative; 1628 llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative); 1629 for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd; 1630 Dir != DirEnd && !EC; Dir.increment(EC)) { 1631 // If we don't have a directory, there's nothing to look into. 1632 if (!llvm::sys::fs::is_directory(Dir->path())) 1633 continue; 1634 1635 // Walk all of the files within this directory. 1636 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd; 1637 File != FileEnd && !EC; File.increment(EC)) { 1638 // We only care about module and global module index files. 1639 StringRef Extension = llvm::sys::path::extension(File->path()); 1640 if (Extension != ".pcm" && Extension != ".timestamp" && 1641 llvm::sys::path::filename(File->path()) != "modules.idx") 1642 continue; 1643 1644 // Look at this file. If we can't stat it, there's nothing interesting 1645 // there. 1646 if (llvm::sys::fs::status(File->path(), StatBuf)) 1647 continue; 1648 1649 // If the file has been used recently enough, leave it there. 1650 time_t FileAccessTime = llvm::sys::toTimeT(StatBuf.getLastAccessedTime()); 1651 if (CurrentTime - FileAccessTime <= 1652 time_t(HSOpts.ModuleCachePruneAfter)) { 1653 continue; 1654 } 1655 1656 // Remove the file. 1657 llvm::sys::fs::remove(File->path()); 1658 1659 // Remove the timestamp file. 1660 std::string TimpestampFilename = File->path() + ".timestamp"; 1661 llvm::sys::fs::remove(TimpestampFilename); 1662 } 1663 1664 // If we removed all of the files in the directory, remove the directory 1665 // itself. 1666 if (llvm::sys::fs::directory_iterator(Dir->path(), EC) == 1667 llvm::sys::fs::directory_iterator() && !EC) 1668 llvm::sys::fs::remove(Dir->path()); 1669 } 1670 } 1671 1672 void CompilerInstance::createASTReader() { 1673 if (TheASTReader) 1674 return; 1675 1676 if (!hasASTContext()) 1677 createASTContext(); 1678 1679 // If we're implicitly building modules but not currently recursively 1680 // building a module, check whether we need to prune the module cache. 1681 if (getSourceManager().getModuleBuildStack().empty() && 1682 !getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty() && 1683 getHeaderSearchOpts().ModuleCachePruneInterval > 0 && 1684 getHeaderSearchOpts().ModuleCachePruneAfter > 0) { 1685 pruneModuleCache(getHeaderSearchOpts()); 1686 } 1687 1688 HeaderSearchOptions &HSOpts = getHeaderSearchOpts(); 1689 std::string Sysroot = HSOpts.Sysroot; 1690 const PreprocessorOptions &PPOpts = getPreprocessorOpts(); 1691 const FrontendOptions &FEOpts = getFrontendOpts(); 1692 std::unique_ptr<llvm::Timer> ReadTimer; 1693 1694 if (FrontendTimerGroup) 1695 ReadTimer = std::make_unique<llvm::Timer>("reading_modules", 1696 "Reading modules", 1697 *FrontendTimerGroup); 1698 TheASTReader = new ASTReader( 1699 getPreprocessor(), getModuleCache(), &getASTContext(), 1700 getPCHContainerReader(), getFrontendOpts().ModuleFileExtensions, 1701 Sysroot.empty() ? "" : Sysroot.c_str(), 1702 PPOpts.DisablePCHOrModuleValidation, 1703 /*AllowASTWithCompilerErrors=*/FEOpts.AllowPCMWithCompilerErrors, 1704 /*AllowConfigurationMismatch=*/false, HSOpts.ModulesValidateSystemHeaders, 1705 HSOpts.ValidateASTInputFilesContent, 1706 getFrontendOpts().UseGlobalModuleIndex, std::move(ReadTimer)); 1707 if (hasASTConsumer()) { 1708 TheASTReader->setDeserializationListener( 1709 getASTConsumer().GetASTDeserializationListener()); 1710 getASTContext().setASTMutationListener( 1711 getASTConsumer().GetASTMutationListener()); 1712 } 1713 getASTContext().setExternalSource(TheASTReader); 1714 if (hasSema()) 1715 TheASTReader->InitializeSema(getSema()); 1716 if (hasASTConsumer()) 1717 TheASTReader->StartTranslationUnit(&getASTConsumer()); 1718 1719 for (auto &Listener : DependencyCollectors) 1720 Listener->attachToASTReader(*TheASTReader); 1721 } 1722 1723 bool CompilerInstance::loadModuleFile( 1724 StringRef FileName, serialization::ModuleFile *&LoadedModuleFile) { 1725 llvm::Timer Timer; 1726 if (FrontendTimerGroup) 1727 Timer.init("preloading." + FileName.str(), "Preloading " + FileName.str(), 1728 *FrontendTimerGroup); 1729 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr); 1730 1731 // If we don't already have an ASTReader, create one now. 1732 if (!TheASTReader) 1733 createASTReader(); 1734 1735 // If -Wmodule-file-config-mismatch is mapped as an error or worse, allow the 1736 // ASTReader to diagnose it, since it can produce better errors that we can. 1737 bool ConfigMismatchIsRecoverable = 1738 getDiagnostics().getDiagnosticLevel(diag::warn_module_config_mismatch, 1739 SourceLocation()) 1740 <= DiagnosticsEngine::Warning; 1741 1742 auto Listener = std::make_unique<ReadModuleNames>(*PP); 1743 auto &ListenerRef = *Listener; 1744 ASTReader::ListenerScope ReadModuleNamesListener(*TheASTReader, 1745 std::move(Listener)); 1746 1747 // Try to load the module file. 1748 switch (TheASTReader->ReadAST( 1749 FileName, serialization::MK_ExplicitModule, SourceLocation(), 1750 ConfigMismatchIsRecoverable ? ASTReader::ARR_ConfigurationMismatch : 0, 1751 &LoadedModuleFile)) { 1752 case ASTReader::Success: 1753 // We successfully loaded the module file; remember the set of provided 1754 // modules so that we don't try to load implicit modules for them. 1755 ListenerRef.registerAll(); 1756 return true; 1757 1758 case ASTReader::ConfigurationMismatch: 1759 // Ignore unusable module files. 1760 getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch) 1761 << FileName; 1762 // All modules provided by any files we tried and failed to load are now 1763 // unavailable; includes of those modules should now be handled textually. 1764 ListenerRef.markAllUnavailable(); 1765 return true; 1766 1767 default: 1768 return false; 1769 } 1770 } 1771 1772 namespace { 1773 enum ModuleSource { 1774 MS_ModuleNotFound, 1775 MS_ModuleCache, 1776 MS_PrebuiltModulePath, 1777 MS_ModuleBuildPragma 1778 }; 1779 } // end namespace 1780 1781 /// Select a source for loading the named module and compute the filename to 1782 /// load it from. 1783 static ModuleSource selectModuleSource( 1784 Module *M, StringRef ModuleName, std::string &ModuleFilename, 1785 const std::map<std::string, std::string, std::less<>> &BuiltModules, 1786 HeaderSearch &HS) { 1787 assert(ModuleFilename.empty() && "Already has a module source?"); 1788 1789 // Check to see if the module has been built as part of this compilation 1790 // via a module build pragma. 1791 auto BuiltModuleIt = BuiltModules.find(ModuleName); 1792 if (BuiltModuleIt != BuiltModules.end()) { 1793 ModuleFilename = BuiltModuleIt->second; 1794 return MS_ModuleBuildPragma; 1795 } 1796 1797 // Try to load the module from the prebuilt module path. 1798 const HeaderSearchOptions &HSOpts = HS.getHeaderSearchOpts(); 1799 if (!HSOpts.PrebuiltModuleFiles.empty() || 1800 !HSOpts.PrebuiltModulePaths.empty()) { 1801 ModuleFilename = HS.getPrebuiltModuleFileName(ModuleName); 1802 if (HSOpts.EnablePrebuiltImplicitModules && ModuleFilename.empty()) 1803 ModuleFilename = HS.getPrebuiltImplicitModuleFileName(M); 1804 if (!ModuleFilename.empty()) 1805 return MS_PrebuiltModulePath; 1806 } 1807 1808 // Try to load the module from the module cache. 1809 if (M) { 1810 ModuleFilename = HS.getCachedModuleFileName(M); 1811 return MS_ModuleCache; 1812 } 1813 1814 return MS_ModuleNotFound; 1815 } 1816 1817 ModuleLoadResult CompilerInstance::findOrCompileModuleAndReadAST( 1818 StringRef ModuleName, SourceLocation ImportLoc, 1819 SourceLocation ModuleNameLoc, bool IsInclusionDirective) { 1820 // Search for a module with the given name. 1821 HeaderSearch &HS = PP->getHeaderSearchInfo(); 1822 Module *M = 1823 HS.lookupModule(ModuleName, ImportLoc, true, !IsInclusionDirective); 1824 1825 // Select the source and filename for loading the named module. 1826 std::string ModuleFilename; 1827 ModuleSource Source = 1828 selectModuleSource(M, ModuleName, ModuleFilename, BuiltModules, HS); 1829 if (Source == MS_ModuleNotFound) { 1830 // We can't find a module, error out here. 1831 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found) 1832 << ModuleName << SourceRange(ImportLoc, ModuleNameLoc); 1833 return nullptr; 1834 } 1835 if (ModuleFilename.empty()) { 1836 if (M && M->HasIncompatibleModuleFile) { 1837 // We tried and failed to load a module file for this module. Fall 1838 // back to textual inclusion for its headers. 1839 return ModuleLoadResult::ConfigMismatch; 1840 } 1841 1842 getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled) 1843 << ModuleName; 1844 return nullptr; 1845 } 1846 1847 // Create an ASTReader on demand. 1848 if (!getASTReader()) 1849 createASTReader(); 1850 1851 // Time how long it takes to load the module. 1852 llvm::Timer Timer; 1853 if (FrontendTimerGroup) 1854 Timer.init("loading." + ModuleFilename, "Loading " + ModuleFilename, 1855 *FrontendTimerGroup); 1856 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr); 1857 llvm::TimeTraceScope TimeScope("Module Load", ModuleName); 1858 1859 // Try to load the module file. If we are not trying to load from the 1860 // module cache, we don't know how to rebuild modules. 1861 unsigned ARRFlags = Source == MS_ModuleCache 1862 ? ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing | 1863 ASTReader::ARR_TreatModuleWithErrorsAsOutOfDate 1864 : Source == MS_PrebuiltModulePath 1865 ? 0 1866 : ASTReader::ARR_ConfigurationMismatch; 1867 switch (getASTReader()->ReadAST(ModuleFilename, 1868 Source == MS_PrebuiltModulePath 1869 ? serialization::MK_PrebuiltModule 1870 : Source == MS_ModuleBuildPragma 1871 ? serialization::MK_ExplicitModule 1872 : serialization::MK_ImplicitModule, 1873 ImportLoc, ARRFlags)) { 1874 case ASTReader::Success: { 1875 if (M) 1876 return M; 1877 assert(Source != MS_ModuleCache && 1878 "missing module, but file loaded from cache"); 1879 1880 // A prebuilt module is indexed as a ModuleFile; the Module does not exist 1881 // until the first call to ReadAST. Look it up now. 1882 M = HS.lookupModule(ModuleName, ImportLoc, true, !IsInclusionDirective); 1883 1884 // Check whether M refers to the file in the prebuilt module path. 1885 if (M && M->getASTFile()) 1886 if (auto ModuleFile = FileMgr->getFile(ModuleFilename)) 1887 if (*ModuleFile == M->getASTFile()) 1888 return M; 1889 1890 getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt) 1891 << ModuleName; 1892 return ModuleLoadResult(); 1893 } 1894 1895 case ASTReader::OutOfDate: 1896 case ASTReader::Missing: 1897 // The most interesting case. 1898 break; 1899 1900 case ASTReader::ConfigurationMismatch: 1901 if (Source == MS_PrebuiltModulePath) 1902 // FIXME: We shouldn't be setting HadFatalFailure below if we only 1903 // produce a warning here! 1904 getDiagnostics().Report(SourceLocation(), 1905 diag::warn_module_config_mismatch) 1906 << ModuleFilename; 1907 // Fall through to error out. 1908 [[fallthrough]]; 1909 case ASTReader::VersionMismatch: 1910 case ASTReader::HadErrors: 1911 ModuleLoader::HadFatalFailure = true; 1912 // FIXME: The ASTReader will already have complained, but can we shoehorn 1913 // that diagnostic information into a more useful form? 1914 return ModuleLoadResult(); 1915 1916 case ASTReader::Failure: 1917 ModuleLoader::HadFatalFailure = true; 1918 return ModuleLoadResult(); 1919 } 1920 1921 // ReadAST returned Missing or OutOfDate. 1922 if (Source != MS_ModuleCache) { 1923 // We don't know the desired configuration for this module and don't 1924 // necessarily even have a module map. Since ReadAST already produces 1925 // diagnostics for these two cases, we simply error out here. 1926 return ModuleLoadResult(); 1927 } 1928 1929 // The module file is missing or out-of-date. Build it. 1930 assert(M && "missing module, but trying to compile for cache"); 1931 1932 // Check whether there is a cycle in the module graph. 1933 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack(); 1934 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end(); 1935 for (; Pos != PosEnd; ++Pos) { 1936 if (Pos->first == ModuleName) 1937 break; 1938 } 1939 1940 if (Pos != PosEnd) { 1941 SmallString<256> CyclePath; 1942 for (; Pos != PosEnd; ++Pos) { 1943 CyclePath += Pos->first; 1944 CyclePath += " -> "; 1945 } 1946 CyclePath += ModuleName; 1947 1948 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle) 1949 << ModuleName << CyclePath; 1950 return nullptr; 1951 } 1952 1953 // Check whether we have already attempted to build this module (but 1954 // failed). 1955 if (getPreprocessorOpts().FailedModules && 1956 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) { 1957 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built) 1958 << ModuleName << SourceRange(ImportLoc, ModuleNameLoc); 1959 return nullptr; 1960 } 1961 1962 // Try to compile and then read the AST. 1963 if (!compileModuleAndReadAST(*this, ImportLoc, ModuleNameLoc, M, 1964 ModuleFilename)) { 1965 assert(getDiagnostics().hasErrorOccurred() && 1966 "undiagnosed error in compileModuleAndReadAST"); 1967 if (getPreprocessorOpts().FailedModules) 1968 getPreprocessorOpts().FailedModules->addFailed(ModuleName); 1969 return nullptr; 1970 } 1971 1972 // Okay, we've rebuilt and now loaded the module. 1973 return M; 1974 } 1975 1976 ModuleLoadResult 1977 CompilerInstance::loadModule(SourceLocation ImportLoc, 1978 ModuleIdPath Path, 1979 Module::NameVisibilityKind Visibility, 1980 bool IsInclusionDirective) { 1981 // Determine what file we're searching from. 1982 StringRef ModuleName = Path[0].first->getName(); 1983 SourceLocation ModuleNameLoc = Path[0].second; 1984 1985 // If we've already handled this import, just return the cached result. 1986 // This one-element cache is important to eliminate redundant diagnostics 1987 // when both the preprocessor and parser see the same import declaration. 1988 if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) { 1989 // Make the named module visible. 1990 if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule) 1991 TheASTReader->makeModuleVisible(LastModuleImportResult, Visibility, 1992 ImportLoc); 1993 return LastModuleImportResult; 1994 } 1995 1996 // If we don't already have information on this module, load the module now. 1997 Module *Module = nullptr; 1998 ModuleMap &MM = getPreprocessor().getHeaderSearchInfo().getModuleMap(); 1999 if (auto MaybeModule = MM.getCachedModuleLoad(*Path[0].first)) { 2000 // Use the cached result, which may be nullptr. 2001 Module = *MaybeModule; 2002 } else if (ModuleName == getLangOpts().CurrentModule) { 2003 // This is the module we're building. 2004 Module = PP->getHeaderSearchInfo().lookupModule( 2005 ModuleName, ImportLoc, /*AllowSearch*/ true, 2006 /*AllowExtraModuleMapSearch*/ !IsInclusionDirective); 2007 2008 MM.cacheModuleLoad(*Path[0].first, Module); 2009 } else { 2010 ModuleLoadResult Result = findOrCompileModuleAndReadAST( 2011 ModuleName, ImportLoc, ModuleNameLoc, IsInclusionDirective); 2012 if (!Result.isNormal()) 2013 return Result; 2014 if (!Result) 2015 DisableGeneratingGlobalModuleIndex = true; 2016 Module = Result; 2017 MM.cacheModuleLoad(*Path[0].first, Module); 2018 } 2019 2020 // If we never found the module, fail. Otherwise, verify the module and link 2021 // it up. 2022 if (!Module) 2023 return ModuleLoadResult(); 2024 2025 // Verify that the rest of the module path actually corresponds to 2026 // a submodule. 2027 bool MapPrivateSubModToTopLevel = false; 2028 for (unsigned I = 1, N = Path.size(); I != N; ++I) { 2029 StringRef Name = Path[I].first->getName(); 2030 clang::Module *Sub = Module->findSubmodule(Name); 2031 2032 // If the user is requesting Foo.Private and it doesn't exist, try to 2033 // match Foo_Private and emit a warning asking for the user to write 2034 // @import Foo_Private instead. FIXME: remove this when existing clients 2035 // migrate off of Foo.Private syntax. 2036 if (!Sub && Name == "Private" && Module == Module->getTopLevelModule()) { 2037 SmallString<128> PrivateModule(Module->Name); 2038 PrivateModule.append("_Private"); 2039 2040 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> PrivPath; 2041 auto &II = PP->getIdentifierTable().get( 2042 PrivateModule, PP->getIdentifierInfo(Module->Name)->getTokenID()); 2043 PrivPath.push_back(std::make_pair(&II, Path[0].second)); 2044 2045 std::string FileName; 2046 // If there is a modulemap module or prebuilt module, load it. 2047 if (PP->getHeaderSearchInfo().lookupModule(PrivateModule, ImportLoc, true, 2048 !IsInclusionDirective) || 2049 selectModuleSource(nullptr, PrivateModule, FileName, BuiltModules, 2050 PP->getHeaderSearchInfo()) != MS_ModuleNotFound) 2051 Sub = loadModule(ImportLoc, PrivPath, Visibility, IsInclusionDirective); 2052 if (Sub) { 2053 MapPrivateSubModToTopLevel = true; 2054 PP->markClangModuleAsAffecting(Module); 2055 if (!getDiagnostics().isIgnored( 2056 diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) { 2057 getDiagnostics().Report(Path[I].second, 2058 diag::warn_no_priv_submodule_use_toplevel) 2059 << Path[I].first << Module->getFullModuleName() << PrivateModule 2060 << SourceRange(Path[0].second, Path[I].second) 2061 << FixItHint::CreateReplacement(SourceRange(Path[0].second), 2062 PrivateModule); 2063 getDiagnostics().Report(Sub->DefinitionLoc, 2064 diag::note_private_top_level_defined); 2065 } 2066 } 2067 } 2068 2069 if (!Sub) { 2070 // Attempt to perform typo correction to find a module name that works. 2071 SmallVector<StringRef, 2> Best; 2072 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)(); 2073 2074 for (class Module *SubModule : Module->submodules()) { 2075 unsigned ED = 2076 Name.edit_distance(SubModule->Name, 2077 /*AllowReplacements=*/true, BestEditDistance); 2078 if (ED <= BestEditDistance) { 2079 if (ED < BestEditDistance) { 2080 Best.clear(); 2081 BestEditDistance = ED; 2082 } 2083 2084 Best.push_back(SubModule->Name); 2085 } 2086 } 2087 2088 // If there was a clear winner, user it. 2089 if (Best.size() == 1) { 2090 getDiagnostics().Report(Path[I].second, diag::err_no_submodule_suggest) 2091 << Path[I].first << Module->getFullModuleName() << Best[0] 2092 << SourceRange(Path[0].second, Path[I - 1].second) 2093 << FixItHint::CreateReplacement(SourceRange(Path[I].second), 2094 Best[0]); 2095 2096 Sub = Module->findSubmodule(Best[0]); 2097 } 2098 } 2099 2100 if (!Sub) { 2101 // No submodule by this name. Complain, and don't look for further 2102 // submodules. 2103 getDiagnostics().Report(Path[I].second, diag::err_no_submodule) 2104 << Path[I].first << Module->getFullModuleName() 2105 << SourceRange(Path[0].second, Path[I - 1].second); 2106 break; 2107 } 2108 2109 Module = Sub; 2110 } 2111 2112 // Make the named module visible, if it's not already part of the module 2113 // we are parsing. 2114 if (ModuleName != getLangOpts().CurrentModule) { 2115 if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) { 2116 // We have an umbrella header or directory that doesn't actually include 2117 // all of the headers within the directory it covers. Complain about 2118 // this missing submodule and recover by forgetting that we ever saw 2119 // this submodule. 2120 // FIXME: Should we detect this at module load time? It seems fairly 2121 // expensive (and rare). 2122 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule) 2123 << Module->getFullModuleName() 2124 << SourceRange(Path.front().second, Path.back().second); 2125 2126 return ModuleLoadResult(Module, ModuleLoadResult::MissingExpected); 2127 } 2128 2129 // Check whether this module is available. 2130 if (Preprocessor::checkModuleIsAvailable(getLangOpts(), getTarget(), 2131 *Module, getDiagnostics())) { 2132 getDiagnostics().Report(ImportLoc, diag::note_module_import_here) 2133 << SourceRange(Path.front().second, Path.back().second); 2134 LastModuleImportLoc = ImportLoc; 2135 LastModuleImportResult = ModuleLoadResult(); 2136 return ModuleLoadResult(); 2137 } 2138 2139 TheASTReader->makeModuleVisible(Module, Visibility, ImportLoc); 2140 } 2141 2142 // Check for any configuration macros that have changed. 2143 clang::Module *TopModule = Module->getTopLevelModule(); 2144 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) { 2145 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I], 2146 Module, ImportLoc); 2147 } 2148 2149 // Resolve any remaining module using export_as for this one. 2150 getPreprocessor() 2151 .getHeaderSearchInfo() 2152 .getModuleMap() 2153 .resolveLinkAsDependencies(TopModule); 2154 2155 LastModuleImportLoc = ImportLoc; 2156 LastModuleImportResult = ModuleLoadResult(Module); 2157 return LastModuleImportResult; 2158 } 2159 2160 void CompilerInstance::createModuleFromSource(SourceLocation ImportLoc, 2161 StringRef ModuleName, 2162 StringRef Source) { 2163 // Avoid creating filenames with special characters. 2164 SmallString<128> CleanModuleName(ModuleName); 2165 for (auto &C : CleanModuleName) 2166 if (!isAlphanumeric(C)) 2167 C = '_'; 2168 2169 // FIXME: Using a randomized filename here means that our intermediate .pcm 2170 // output is nondeterministic (as .pcm files refer to each other by name). 2171 // Can this affect the output in any way? 2172 SmallString<128> ModuleFileName; 2173 if (std::error_code EC = llvm::sys::fs::createTemporaryFile( 2174 CleanModuleName, "pcm", ModuleFileName)) { 2175 getDiagnostics().Report(ImportLoc, diag::err_fe_unable_to_open_output) 2176 << ModuleFileName << EC.message(); 2177 return; 2178 } 2179 std::string ModuleMapFileName = (CleanModuleName + ".map").str(); 2180 2181 FrontendInputFile Input( 2182 ModuleMapFileName, 2183 InputKind(getLanguageFromOptions(Invocation->getLangOpts()), 2184 InputKind::ModuleMap, /*Preprocessed*/true)); 2185 2186 std::string NullTerminatedSource(Source.str()); 2187 2188 auto PreBuildStep = [&](CompilerInstance &Other) { 2189 // Create a virtual file containing our desired source. 2190 // FIXME: We shouldn't need to do this. 2191 FileEntryRef ModuleMapFile = Other.getFileManager().getVirtualFileRef( 2192 ModuleMapFileName, NullTerminatedSource.size(), 0); 2193 Other.getSourceManager().overrideFileContents( 2194 ModuleMapFile, llvm::MemoryBuffer::getMemBuffer(NullTerminatedSource)); 2195 2196 Other.BuiltModules = std::move(BuiltModules); 2197 Other.DeleteBuiltModules = false; 2198 }; 2199 2200 auto PostBuildStep = [this](CompilerInstance &Other) { 2201 BuiltModules = std::move(Other.BuiltModules); 2202 }; 2203 2204 // Build the module, inheriting any modules that we've built locally. 2205 if (compileModuleImpl(*this, ImportLoc, ModuleName, Input, StringRef(), 2206 ModuleFileName, PreBuildStep, PostBuildStep)) { 2207 BuiltModules[std::string(ModuleName)] = std::string(ModuleFileName); 2208 llvm::sys::RemoveFileOnSignal(ModuleFileName); 2209 } 2210 } 2211 2212 void CompilerInstance::makeModuleVisible(Module *Mod, 2213 Module::NameVisibilityKind Visibility, 2214 SourceLocation ImportLoc) { 2215 if (!TheASTReader) 2216 createASTReader(); 2217 if (!TheASTReader) 2218 return; 2219 2220 TheASTReader->makeModuleVisible(Mod, Visibility, ImportLoc); 2221 } 2222 2223 GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex( 2224 SourceLocation TriggerLoc) { 2225 if (getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty()) 2226 return nullptr; 2227 if (!TheASTReader) 2228 createASTReader(); 2229 // Can't do anything if we don't have the module manager. 2230 if (!TheASTReader) 2231 return nullptr; 2232 // Get an existing global index. This loads it if not already 2233 // loaded. 2234 TheASTReader->loadGlobalIndex(); 2235 GlobalModuleIndex *GlobalIndex = TheASTReader->getGlobalIndex(); 2236 // If the global index doesn't exist, create it. 2237 if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() && 2238 hasPreprocessor()) { 2239 llvm::sys::fs::create_directories( 2240 getPreprocessor().getHeaderSearchInfo().getModuleCachePath()); 2241 if (llvm::Error Err = GlobalModuleIndex::writeIndex( 2242 getFileManager(), getPCHContainerReader(), 2243 getPreprocessor().getHeaderSearchInfo().getModuleCachePath())) { 2244 // FIXME this drops the error on the floor. This code is only used for 2245 // typo correction and drops more than just this one source of errors 2246 // (such as the directory creation failure above). It should handle the 2247 // error. 2248 consumeError(std::move(Err)); 2249 return nullptr; 2250 } 2251 TheASTReader->resetForReload(); 2252 TheASTReader->loadGlobalIndex(); 2253 GlobalIndex = TheASTReader->getGlobalIndex(); 2254 } 2255 // For finding modules needing to be imported for fixit messages, 2256 // we need to make the global index cover all modules, so we do that here. 2257 if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) { 2258 ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap(); 2259 bool RecreateIndex = false; 2260 for (ModuleMap::module_iterator I = MMap.module_begin(), 2261 E = MMap.module_end(); I != E; ++I) { 2262 Module *TheModule = I->second; 2263 OptionalFileEntryRef Entry = TheModule->getASTFile(); 2264 if (!Entry) { 2265 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path; 2266 Path.push_back(std::make_pair( 2267 getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc)); 2268 std::reverse(Path.begin(), Path.end()); 2269 // Load a module as hidden. This also adds it to the global index. 2270 loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false); 2271 RecreateIndex = true; 2272 } 2273 } 2274 if (RecreateIndex) { 2275 if (llvm::Error Err = GlobalModuleIndex::writeIndex( 2276 getFileManager(), getPCHContainerReader(), 2277 getPreprocessor().getHeaderSearchInfo().getModuleCachePath())) { 2278 // FIXME As above, this drops the error on the floor. 2279 consumeError(std::move(Err)); 2280 return nullptr; 2281 } 2282 TheASTReader->resetForReload(); 2283 TheASTReader->loadGlobalIndex(); 2284 GlobalIndex = TheASTReader->getGlobalIndex(); 2285 } 2286 HaveFullGlobalModuleIndex = true; 2287 } 2288 return GlobalIndex; 2289 } 2290 2291 // Check global module index for missing imports. 2292 bool 2293 CompilerInstance::lookupMissingImports(StringRef Name, 2294 SourceLocation TriggerLoc) { 2295 // Look for the symbol in non-imported modules, but only if an error 2296 // actually occurred. 2297 if (!buildingModule()) { 2298 // Load global module index, or retrieve a previously loaded one. 2299 GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex( 2300 TriggerLoc); 2301 2302 // Only if we have a global index. 2303 if (GlobalIndex) { 2304 GlobalModuleIndex::HitSet FoundModules; 2305 2306 // Find the modules that reference the identifier. 2307 // Note that this only finds top-level modules. 2308 // We'll let diagnoseTypo find the actual declaration module. 2309 if (GlobalIndex->lookupIdentifier(Name, FoundModules)) 2310 return true; 2311 } 2312 } 2313 2314 return false; 2315 } 2316 void CompilerInstance::resetAndLeakSema() { llvm::BuryPointer(takeSema()); } 2317 2318 void CompilerInstance::setExternalSemaSource( 2319 IntrusiveRefCntPtr<ExternalSemaSource> ESS) { 2320 ExternalSemaSrc = std::move(ESS); 2321 } 2322