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