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