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