CompilerInstance.cpp revision a1f1fad8b60e1cb9d21a40a37f2e03150bcbeb6f
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 SrcMgr::CharacteristicKind Kind){ 582 return InitializeSourceManager(InputFile, Kind, getDiagnostics(), 583 getFileManager(), getSourceManager(), 584 getFrontendOpts()); 585} 586 587bool CompilerInstance::InitializeSourceManager(StringRef InputFile, 588 SrcMgr::CharacteristicKind Kind, 589 DiagnosticsEngine &Diags, 590 FileManager &FileMgr, 591 SourceManager &SourceMgr, 592 const FrontendOptions &Opts) { 593 // Figure out where to get and map in the main file. 594 if (InputFile != "-") { 595 const FileEntry *File = FileMgr.getFile(InputFile); 596 if (!File) { 597 Diags.Report(diag::err_fe_error_reading) << InputFile; 598 return false; 599 } 600 SourceMgr.createMainFileID(File, Kind); 601 } else { 602 llvm::OwningPtr<llvm::MemoryBuffer> SB; 603 if (llvm::MemoryBuffer::getSTDIN(SB)) { 604 // FIXME: Give ec.message() in this diag. 605 Diags.Report(diag::err_fe_error_reading_stdin); 606 return false; 607 } 608 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(), 609 SB->getBufferSize(), 0); 610 SourceMgr.createMainFileID(File, Kind); 611 SourceMgr.overrideFileContents(File, SB.take()); 612 } 613 614 assert(!SourceMgr.getMainFileID().isInvalid() && 615 "Couldn't establish MainFileID!"); 616 return true; 617} 618 619// High-Level Operations 620 621bool CompilerInstance::ExecuteAction(FrontendAction &Act) { 622 assert(hasDiagnostics() && "Diagnostics engine is not initialized!"); 623 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!"); 624 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!"); 625 626 // FIXME: Take this as an argument, once all the APIs we used have moved to 627 // taking it as an input instead of hard-coding llvm::errs. 628 raw_ostream &OS = llvm::errs(); 629 630 // Create the target instance. 631 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), getTargetOpts())); 632 if (!hasTarget()) 633 return false; 634 635 // Inform the target of the language options. 636 // 637 // FIXME: We shouldn't need to do this, the target should be immutable once 638 // created. This complexity should be lifted elsewhere. 639 getTarget().setForcedLangOptions(getLangOpts()); 640 641 // Validate/process some options. 642 if (getHeaderSearchOpts().Verbose) 643 OS << "clang -cc1 version " CLANG_VERSION_STRING 644 << " based upon " << PACKAGE_STRING 645 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n"; 646 647 if (getFrontendOpts().ShowTimers) 648 createFrontendTimer(); 649 650 if (getFrontendOpts().ShowStats) 651 llvm::EnableStatistics(); 652 653 for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) { 654 // Reset the ID tables if we are reusing the SourceManager. 655 if (hasSourceManager()) 656 getSourceManager().clearIDTables(); 657 658 if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) { 659 Act.Execute(); 660 Act.EndSourceFile(); 661 } 662 } 663 664 // Notify the diagnostic client that all files were processed. 665 getDiagnostics().getClient()->finish(); 666 667 if (getDiagnosticOpts().ShowCarets) { 668 // We can have multiple diagnostics sharing one diagnostic client. 669 // Get the total number of warnings/errors from the client. 670 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings(); 671 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors(); 672 673 if (NumWarnings) 674 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s"); 675 if (NumWarnings && NumErrors) 676 OS << " and "; 677 if (NumErrors) 678 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s"); 679 if (NumWarnings || NumErrors) 680 OS << " generated.\n"; 681 } 682 683 if (getFrontendOpts().ShowStats && hasFileManager()) { 684 getFileManager().PrintStats(); 685 OS << "\n"; 686 } 687 688 return !getDiagnostics().getClient()->getNumErrors(); 689} 690 691/// \brief Determine the appropriate source input kind based on language 692/// options. 693static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) { 694 if (LangOpts.OpenCL) 695 return IK_OpenCL; 696 if (LangOpts.CUDA) 697 return IK_CUDA; 698 if (LangOpts.ObjC1) 699 return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC; 700 return LangOpts.CPlusPlus? IK_CXX : IK_C; 701} 702 703namespace { 704 struct CompileModuleMapData { 705 CompilerInstance &Instance; 706 GenerateModuleAction &CreateModuleAction; 707 }; 708} 709 710/// \brief Helper function that executes the module-generating action under 711/// a crash recovery context. 712static void doCompileMapModule(void *UserData) { 713 CompileModuleMapData &Data 714 = *reinterpret_cast<CompileModuleMapData *>(UserData); 715 Data.Instance.ExecuteAction(Data.CreateModuleAction); 716} 717 718namespace { 719 /// \brief Class that manages the creation of a lock file to aid 720 /// implicit coordination between different processes. 721 /// 722 /// The implicit coordination works by creating a ".lock" file alongside 723 /// the file that we're coordinating for, using the atomicity of the file 724 /// system to ensure that only a single process can create that ".lock" file. 725 /// When the lock file is removed, the owning process has finished the 726 /// operation. 727 class LockFileManager { 728 public: 729 /// \brief Describes the state of a lock file. 730 enum LockFileState { 731 /// \brief The lock file has been created and is owned by this instance 732 /// of the object. 733 LFS_Owned, 734 /// \brief The lock file already exists and is owned by some other 735 /// instance. 736 LFS_Shared, 737 /// \brief An error occurred while trying to create or find the lock 738 /// file. 739 LFS_Error 740 }; 741 742 private: 743 llvm::SmallString<128> LockFileName; 744 llvm::SmallString<128> UniqueLockFileName; 745 746 llvm::Optional<std::pair<std::string, int> > Owner; 747 llvm::Optional<llvm::error_code> Error; 748 749 LockFileManager(const LockFileManager &); 750 LockFileManager &operator=(const LockFileManager &); 751 752 static llvm::Optional<std::pair<std::string, int> > 753 readLockFile(StringRef LockFileName); 754 755 static bool processStillExecuting(StringRef Hostname, int PID); 756 757 public: 758 759 LockFileManager(StringRef FileName); 760 ~LockFileManager(); 761 762 /// \brief Determine the state of the lock file. 763 LockFileState getState() const; 764 765 operator LockFileState() const { return getState(); } 766 767 /// \brief For a shared lock, wait until the owner releases the lock. 768 void waitForUnlock(); 769 }; 770} 771 772/// \brief Attempt to read the lock file with the given name, if it exists. 773/// 774/// \param LockFileName The name of the lock file to read. 775/// 776/// \returns The process ID of the process that owns this lock file 777llvm::Optional<std::pair<std::string, int> > 778LockFileManager::readLockFile(StringRef LockFileName) { 779 // Check whether the lock file exists. If not, clearly there's nothing 780 // to read, so we just return. 781 bool Exists = false; 782 if (llvm::sys::fs::exists(LockFileName, Exists) || !Exists) 783 return llvm::Optional<std::pair<std::string, int> >(); 784 785 // Read the owning host and PID out of the lock file. If it appears that the 786 // owning process is dead, the lock file is invalid. 787 int PID = 0; 788 std::string Hostname; 789 std::ifstream Input(LockFileName.str().c_str()); 790 if (Input >> Hostname >> PID && PID > 0 && 791 processStillExecuting(Hostname, PID)) 792 return std::make_pair(Hostname, PID); 793 794 // Delete the lock file. It's invalid anyway. 795 bool Existed; 796 llvm::sys::fs::remove(LockFileName, Existed); 797 return llvm::Optional<std::pair<std::string, int> >(); 798} 799 800bool LockFileManager::processStillExecuting(StringRef Hostname, int PID) { 801#if LLVM_ON_UNIX 802 char MyHostname[256]; 803 MyHostname[255] = 0; 804 MyHostname[0] = 0; 805 gethostname(MyHostname, 255); 806 // Check whether the process is dead. If so, we're done. 807 if (MyHostname == Hostname && getsid(PID) == -1 && errno == ESRCH) 808 return false; 809#endif 810 811 return true; 812} 813 814LockFileManager::LockFileManager(StringRef FileName) 815{ 816 LockFileName = FileName; 817 LockFileName += ".lock"; 818 819 // If the lock file already exists, don't bother to try to create our own 820 // lock file; it won't work anyway. Just figure out who owns this lock file. 821 if ((Owner = readLockFile(LockFileName))) 822 return; 823 824 // Create a lock file that is unique to this instance. 825 UniqueLockFileName = LockFileName; 826 UniqueLockFileName += "-%%%%%%%%"; 827 int UniqueLockFileID; 828 if (llvm::error_code EC 829 = llvm::sys::fs::unique_file(UniqueLockFileName.str(), 830 UniqueLockFileID, 831 UniqueLockFileName, 832 /*makeAbsolute=*/false)) { 833 Error = EC; 834 return; 835 } 836 837 // Write our process ID to our unique lock file. 838 { 839 llvm::raw_fd_ostream Out(UniqueLockFileID, /*shouldClose=*/true); 840 841#if LLVM_ON_UNIX 842 // FIXME: move getpid() call into LLVM 843 char hostname[256]; 844 hostname[255] = 0; 845 hostname[0] = 0; 846 gethostname(hostname, 255); 847 Out << hostname << ' ' << getpid(); 848#else 849 Out << "localhost 1"; 850#endif 851 Out.close(); 852 853 if (Out.has_error()) { 854 // We failed to write out PID, so make up an excuse, remove the 855 // unique lock file, and fail. 856 Error = llvm::make_error_code(llvm::errc::no_space_on_device); 857 bool Existed; 858 llvm::sys::fs::remove(UniqueLockFileName.c_str(), Existed); 859 return; 860 } 861 } 862 863 // Create a hard link from the lock file name. If this succeeds, we're done. 864 llvm::error_code EC 865 = llvm::sys::fs::create_hard_link(UniqueLockFileName.str(), 866 LockFileName.str()); 867 if (EC == llvm::errc::success) 868 return; 869 870 // Creating the hard link failed. 871 872#ifdef LLVM_ON_UNIX 873 // The creation of the hard link may appear to fail, but if stat'ing the 874 // unique file returns a link count of 2, then we can still declare success. 875 struct stat StatBuf; 876 if (stat(UniqueLockFileName.c_str(), &StatBuf) == 0 && 877 StatBuf.st_nlink == 2) 878 return; 879#endif 880 881 // Someone else managed to create the lock file first. Wipe out our unique 882 // lock file (it's useless now) and read the process ID from the lock file. 883 bool Existed; 884 llvm::sys::fs::remove(UniqueLockFileName.str(), Existed); 885 if ((Owner = readLockFile(LockFileName))) 886 return; 887 888 // There is a lock file that nobody owns; try to clean it up and report 889 // an error. 890 llvm::sys::fs::remove(LockFileName.str(), Existed); 891 Error = EC; 892} 893 894LockFileManager::LockFileState LockFileManager::getState() const { 895 if (Owner) 896 return LFS_Shared; 897 898 if (Error) 899 return LFS_Error; 900 901 return LFS_Owned; 902} 903 904LockFileManager::~LockFileManager() { 905 if (getState() != LFS_Owned) 906 return; 907 908 // Since we own the lock, remove the lock file and our own unique lock file. 909 bool Existed; 910 llvm::sys::fs::remove(LockFileName.str(), Existed); 911 llvm::sys::fs::remove(UniqueLockFileName.str(), Existed); 912} 913 914void LockFileManager::waitForUnlock() { 915 if (getState() != LFS_Shared) 916 return; 917 918#if LLVM_ON_WIN32 919 unsigned long Interval = 1; 920#else 921 struct timespec Interval; 922 Interval.tv_sec = 0; 923 Interval.tv_nsec = 1000000; 924#endif 925 // Don't wait more than an hour for the file to appear. 926 const unsigned MaxSeconds = 3600; 927 do { 928 // Sleep for the designated interval, to allow the owning process time to 929 // finish up and 930 // FIXME: Should we hook in to system APIs to get a notification when the 931 // lock file is deleted? 932#if LLVM_ON_WIN32 933 Sleep(Interval); 934#else 935 nanosleep(&Interval, NULL); 936#endif 937 // If the file no longer exists, we're done. 938 bool Exists = false; 939 if (!llvm::sys::fs::exists(LockFileName.str(), Exists) && !Exists) 940 return; 941 942 if (!processStillExecuting((*Owner).first, (*Owner).second)) 943 return; 944 945 // Exponentially increase the time we wait for the lock to be removed. 946#if LLVM_ON_WIN32 947 Interval *= 2; 948#else 949 Interval.tv_sec *= 2; 950 Interval.tv_nsec *= 2; 951 if (Interval.tv_nsec >= 1000000000) { 952 ++Interval.tv_sec; 953 Interval.tv_nsec -= 1000000000; 954 } 955#endif 956 } while ( 957#if LLVM_ON_WIN32 958 Interval < MaxSeconds * 1000 959#else 960 Interval.tv_sec < (time_t)MaxSeconds 961#endif 962 ); 963 964 // Give up. 965} 966 967/// \brief Compile a module file for the given module, using the options 968/// provided by the importing compiler instance. 969static void compileModule(CompilerInstance &ImportingInstance, 970 Module *Module, 971 StringRef ModuleFileName) { 972 LockFileManager Locked(ModuleFileName); 973 switch (Locked) { 974 case LockFileManager::LFS_Error: 975 return; 976 977 case LockFileManager::LFS_Owned: 978 // We're responsible for building the module ourselves. Do so below. 979 break; 980 981 case LockFileManager::LFS_Shared: 982 // Someone else is responsible for building the module. Wait for them to 983 // finish. 984 Locked.waitForUnlock(); 985 break; 986 } 987 988 ModuleMap &ModMap 989 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap(); 990 991 // Construct a compiler invocation for creating this module. 992 llvm::IntrusiveRefCntPtr<CompilerInvocation> Invocation 993 (new CompilerInvocation(ImportingInstance.getInvocation())); 994 995 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); 996 997 // For any options that aren't intended to affect how a module is built, 998 // reset them to their default values. 999 Invocation->getLangOpts()->resetNonModularOptions(); 1000 PPOpts.resetNonModularOptions(); 1001 1002 // Note the name of the module we're building. 1003 Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName(); 1004 1005 // Note that this module is part of the module build path, so that we 1006 // can detect cycles in the module graph. 1007 PPOpts.ModuleBuildPath.push_back(Module->getTopLevelModuleName()); 1008 1009 // If there is a module map file, build the module using the module map. 1010 // Set up the inputs/outputs so that we build the module from its umbrella 1011 // header. 1012 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts(); 1013 FrontendOpts.OutputFile = ModuleFileName.str(); 1014 FrontendOpts.DisableFree = false; 1015 FrontendOpts.Inputs.clear(); 1016 InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts()); 1017 1018 // Get or create the module map that we'll use to build this module. 1019 llvm::SmallString<128> TempModuleMapFileName; 1020 if (const FileEntry *ModuleMapFile 1021 = ModMap.getContainingModuleMapFile(Module)) { 1022 // Use the module map where this module resides. 1023 FrontendOpts.Inputs.push_back(FrontendInputFile(ModuleMapFile->getName(), 1024 IK)); 1025 } else { 1026 // Create a temporary module map file. 1027 TempModuleMapFileName = Module->Name; 1028 TempModuleMapFileName += "-%%%%%%%%.map"; 1029 int FD; 1030 if (llvm::sys::fs::unique_file(TempModuleMapFileName.str(), FD, 1031 TempModuleMapFileName, 1032 /*makeAbsolute=*/true) 1033 != llvm::errc::success) { 1034 ImportingInstance.getDiagnostics().Report(diag::err_module_map_temp_file) 1035 << TempModuleMapFileName; 1036 return; 1037 } 1038 // Print the module map to this file. 1039 llvm::raw_fd_ostream OS(FD, /*shouldClose=*/true); 1040 Module->print(OS); 1041 FrontendOpts.Inputs.push_back( 1042 FrontendInputFile(TempModuleMapFileName.str().str(), IK)); 1043 } 1044 1045 // Don't free the remapped file buffers; they are owned by our caller. 1046 PPOpts.RetainRemappedFileBuffers = true; 1047 1048 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0; 1049 assert(ImportingInstance.getInvocation().getModuleHash() == 1050 Invocation->getModuleHash() && "Module hash mismatch!"); 1051 1052 // Construct a compiler instance that will be used to actually create the 1053 // module. 1054 CompilerInstance Instance; 1055 Instance.setInvocation(&*Invocation); 1056 Instance.createDiagnostics(/*argc=*/0, /*argv=*/0, 1057 &ImportingInstance.getDiagnosticClient(), 1058 /*ShouldOwnClient=*/true, 1059 /*ShouldCloneClient=*/true); 1060 1061 // Construct a module-generating action. 1062 GenerateModuleAction CreateModuleAction; 1063 1064 // Execute the action to actually build the module in-place. Use a separate 1065 // thread so that we get a stack large enough. 1066 const unsigned ThreadStackSize = 8 << 20; 1067 llvm::CrashRecoveryContext CRC; 1068 CompileModuleMapData Data = { Instance, CreateModuleAction }; 1069 CRC.RunSafelyOnThread(&doCompileMapModule, &Data, ThreadStackSize); 1070 1071 // Delete the temporary module map file. 1072 // FIXME: Even though we're executing under crash protection, it would still 1073 // be nice to do this with RemoveFileOnSignal when we can. However, that 1074 // doesn't make sense for all clients, so clean this up manually. 1075 if (!TempModuleMapFileName.empty()) 1076 llvm::sys::Path(TempModuleMapFileName).eraseFromDisk(); 1077} 1078 1079Module *CompilerInstance::loadModule(SourceLocation ImportLoc, 1080 ModuleIdPath Path, 1081 Module::NameVisibilityKind Visibility, 1082 bool IsInclusionDirective) { 1083 // If we've already handled this import, just return the cached result. 1084 // This one-element cache is important to eliminate redundant diagnostics 1085 // when both the preprocessor and parser see the same import declaration. 1086 if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) { 1087 // Make the named module visible. 1088 if (LastModuleImportResult) 1089 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility); 1090 return LastModuleImportResult; 1091 } 1092 1093 // Determine what file we're searching from. 1094 SourceManager &SourceMgr = getSourceManager(); 1095 SourceLocation ExpandedImportLoc = SourceMgr.getExpansionLoc(ImportLoc); 1096 const FileEntry *CurFile 1097 = SourceMgr.getFileEntryForID(SourceMgr.getFileID(ExpandedImportLoc)); 1098 if (!CurFile) 1099 CurFile = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID()); 1100 1101 StringRef ModuleName = Path[0].first->getName(); 1102 SourceLocation ModuleNameLoc = Path[0].second; 1103 1104 clang::Module *Module = 0; 1105 const FileEntry *ModuleFile = 0; 1106 1107 // If we don't already have information on this module, load the module now. 1108 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known 1109 = KnownModules.find(Path[0].first); 1110 if (Known != KnownModules.end()) { 1111 // Retrieve the cached top-level module. 1112 Module = Known->second; 1113 } else if (ModuleName == getLangOpts().CurrentModule) { 1114 // This is the module we're building. 1115 Module = PP->getHeaderSearchInfo().getModuleMap().findModule(ModuleName); 1116 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first; 1117 } else { 1118 // Search for a module with the given name. 1119 std::string ModuleFileName; 1120 ModuleFile 1121 = PP->getHeaderSearchInfo().lookupModule(ModuleName, Module, 1122 &ModuleFileName); 1123 1124 bool BuildingModule = false; 1125 if (!ModuleFile && Module) { 1126 // The module is not cached, but we have a module map from which we can 1127 // build the module. 1128 1129 // Check whether there is a cycle in the module graph. 1130 SmallVectorImpl<std::string> &ModuleBuildPath 1131 = getPreprocessorOpts().ModuleBuildPath; 1132 SmallVectorImpl<std::string>::iterator Pos 1133 = std::find(ModuleBuildPath.begin(), ModuleBuildPath.end(), ModuleName); 1134 if (Pos != ModuleBuildPath.end()) { 1135 llvm::SmallString<256> CyclePath; 1136 for (; Pos != ModuleBuildPath.end(); ++Pos) { 1137 CyclePath += *Pos; 1138 CyclePath += " -> "; 1139 } 1140 CyclePath += ModuleName; 1141 1142 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle) 1143 << ModuleName << CyclePath; 1144 return 0; 1145 } 1146 1147 getDiagnostics().Report(ModuleNameLoc, diag::warn_module_build) 1148 << ModuleName; 1149 BuildingModule = true; 1150 compileModule(*this, Module, ModuleFileName); 1151 ModuleFile = FileMgr->getFile(ModuleFileName); 1152 } 1153 1154 if (!ModuleFile) { 1155 getDiagnostics().Report(ModuleNameLoc, 1156 BuildingModule? diag::err_module_not_built 1157 : diag::err_module_not_found) 1158 << ModuleName 1159 << SourceRange(ImportLoc, ModuleNameLoc); 1160 return 0; 1161 } 1162 1163 // If we don't already have an ASTReader, create one now. 1164 if (!ModuleManager) { 1165 if (!hasASTContext()) 1166 createASTContext(); 1167 1168 std::string Sysroot = getHeaderSearchOpts().Sysroot; 1169 const PreprocessorOptions &PPOpts = getPreprocessorOpts(); 1170 ModuleManager = new ASTReader(getPreprocessor(), *Context, 1171 Sysroot.empty() ? "" : Sysroot.c_str(), 1172 PPOpts.DisablePCHValidation, 1173 PPOpts.DisableStatCache); 1174 if (hasASTConsumer()) { 1175 ModuleManager->setDeserializationListener( 1176 getASTConsumer().GetASTDeserializationListener()); 1177 getASTContext().setASTMutationListener( 1178 getASTConsumer().GetASTMutationListener()); 1179 } 1180 llvm::OwningPtr<ExternalASTSource> Source; 1181 Source.reset(ModuleManager); 1182 getASTContext().setExternalSource(Source); 1183 if (hasSema()) 1184 ModuleManager->InitializeSema(getSema()); 1185 if (hasASTConsumer()) 1186 ModuleManager->StartTranslationUnit(&getASTConsumer()); 1187 } 1188 1189 // Try to load the module we found. 1190 switch (ModuleManager->ReadAST(ModuleFile->getName(), 1191 serialization::MK_Module)) { 1192 case ASTReader::Success: 1193 break; 1194 1195 case ASTReader::IgnorePCH: 1196 // FIXME: The ASTReader will already have complained, but can we showhorn 1197 // that diagnostic information into a more useful form? 1198 KnownModules[Path[0].first] = 0; 1199 return 0; 1200 1201 case ASTReader::Failure: 1202 // Already complained, but note now that we failed. 1203 KnownModules[Path[0].first] = 0; 1204 return 0; 1205 } 1206 1207 if (!Module) { 1208 // If we loaded the module directly, without finding a module map first, 1209 // we'll have loaded the module's information from the module itself. 1210 Module = PP->getHeaderSearchInfo().getModuleMap() 1211 .findModule((Path[0].first->getName())); 1212 } 1213 1214 // Cache the result of this top-level module lookup for later. 1215 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first; 1216 } 1217 1218 // If we never found the module, fail. 1219 if (!Module) 1220 return 0; 1221 1222 // Verify that the rest of the module path actually corresponds to 1223 // a submodule. 1224 if (Path.size() > 1) { 1225 for (unsigned I = 1, N = Path.size(); I != N; ++I) { 1226 StringRef Name = Path[I].first->getName(); 1227 clang::Module *Sub = Module->findSubmodule(Name); 1228 1229 if (!Sub) { 1230 // Attempt to perform typo correction to find a module name that works. 1231 llvm::SmallVector<StringRef, 2> Best; 1232 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)(); 1233 1234 for (clang::Module::submodule_iterator J = Module->submodule_begin(), 1235 JEnd = Module->submodule_end(); 1236 J != JEnd; ++J) { 1237 unsigned ED = Name.edit_distance((*J)->Name, 1238 /*AllowReplacements=*/true, 1239 BestEditDistance); 1240 if (ED <= BestEditDistance) { 1241 if (ED < BestEditDistance) { 1242 Best.clear(); 1243 BestEditDistance = ED; 1244 } 1245 1246 Best.push_back((*J)->Name); 1247 } 1248 } 1249 1250 // If there was a clear winner, user it. 1251 if (Best.size() == 1) { 1252 getDiagnostics().Report(Path[I].second, 1253 diag::err_no_submodule_suggest) 1254 << Path[I].first << Module->getFullModuleName() << Best[0] 1255 << SourceRange(Path[0].second, Path[I-1].second) 1256 << FixItHint::CreateReplacement(SourceRange(Path[I].second), 1257 Best[0]); 1258 1259 Sub = Module->findSubmodule(Best[0]); 1260 } 1261 } 1262 1263 if (!Sub) { 1264 // No submodule by this name. Complain, and don't look for further 1265 // submodules. 1266 getDiagnostics().Report(Path[I].second, diag::err_no_submodule) 1267 << Path[I].first << Module->getFullModuleName() 1268 << SourceRange(Path[0].second, Path[I-1].second); 1269 break; 1270 } 1271 1272 Module = Sub; 1273 } 1274 } 1275 1276 // Make the named module visible, if it's not already part of the module 1277 // we are parsing. 1278 if (ModuleName != getLangOpts().CurrentModule) { 1279 if (!Module->IsFromModuleFile) { 1280 // We have an umbrella header or directory that doesn't actually include 1281 // all of the headers within the directory it covers. Complain about 1282 // this missing submodule and recover by forgetting that we ever saw 1283 // this submodule. 1284 // FIXME: Should we detect this at module load time? It seems fairly 1285 // expensive (and rare). 1286 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule) 1287 << Module->getFullModuleName() 1288 << SourceRange(Path.front().second, Path.back().second); 1289 1290 return 0; 1291 } 1292 1293 // Check whether this module is available. 1294 StringRef Feature; 1295 if (!Module->isAvailable(getLangOpts(), Feature)) { 1296 getDiagnostics().Report(ImportLoc, diag::err_module_unavailable) 1297 << Module->getFullModuleName() 1298 << Feature 1299 << SourceRange(Path.front().second, Path.back().second); 1300 LastModuleImportLoc = ImportLoc; 1301 LastModuleImportResult = 0; 1302 return 0; 1303 } 1304 1305 ModuleManager->makeModuleVisible(Module, Visibility); 1306 } 1307 1308 // If this module import was due to an inclusion directive, create an 1309 // implicit import declaration to capture it in the AST. 1310 if (IsInclusionDirective && hasASTContext()) { 1311 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl(); 1312 TU->addDecl(ImportDecl::CreateImplicit(getASTContext(), TU, 1313 ImportLoc, Module, 1314 Path.back().second)); 1315 } 1316 1317 LastModuleImportLoc = ImportLoc; 1318 LastModuleImportResult = Module; 1319 return Module; 1320} 1321