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