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