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