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