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