1 //===--- CompilerInstance.cpp ---------------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "clang/Frontend/CompilerInstance.h"
11 #include "clang/AST/ASTConsumer.h"
12 #include "clang/AST/ASTContext.h"
13 #include "clang/AST/Decl.h"
14 #include "clang/Basic/Diagnostic.h"
15 #include "clang/Basic/FileManager.h"
16 #include "clang/Basic/SourceManager.h"
17 #include "clang/Basic/TargetInfo.h"
18 #include "clang/Basic/Version.h"
19 #include "clang/Frontend/ChainedDiagnosticConsumer.h"
20 #include "clang/Frontend/FrontendAction.h"
21 #include "clang/Frontend/FrontendActions.h"
22 #include "clang/Frontend/FrontendDiagnostic.h"
23 #include "clang/Frontend/LogDiagnosticPrinter.h"
24 #include "clang/Frontend/SerializedDiagnosticPrinter.h"
25 #include "clang/Frontend/TextDiagnosticPrinter.h"
26 #include "clang/Frontend/Utils.h"
27 #include "clang/Frontend/VerifyDiagnosticConsumer.h"
28 #include "clang/Lex/HeaderSearch.h"
29 #include "clang/Lex/PTHManager.h"
30 #include "clang/Lex/Preprocessor.h"
31 #include "clang/Sema/CodeCompleteConsumer.h"
32 #include "clang/Sema/Sema.h"
33 #include "clang/Serialization/ASTReader.h"
34 #include "llvm/ADT/Statistic.h"
35 #include "llvm/Config/config.h"
36 #include "llvm/Support/CrashRecoveryContext.h"
37 #include "llvm/Support/FileSystem.h"
38 #include "llvm/Support/Host.h"
39 #include "llvm/Support/LockFileManager.h"
40 #include "llvm/Support/MemoryBuffer.h"
41 #include "llvm/Support/Path.h"
42 #include "llvm/Support/Program.h"
43 #include "llvm/Support/Signals.h"
44 #include "llvm/Support/Timer.h"
45 #include "llvm/Support/raw_ostream.h"
46 #include "llvm/Support/system_error.h"
50 using namespace clang;
52 CompilerInstance::CompilerInstance()
53 : Invocation(new CompilerInvocation()), ModuleManager(0),
54 BuildGlobalModuleIndex(false), ModuleBuildFailed(false) {
57 CompilerInstance::~CompilerInstance() {
58 assert(OutputFiles.empty() && "Still output files in flight?");
61 void CompilerInstance::setInvocation(CompilerInvocation *Value) {
65 bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
66 return (BuildGlobalModuleIndex ||
67 (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
68 getFrontendOpts().GenerateGlobalModuleIndex)) &&
72 void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
76 void CompilerInstance::setTarget(TargetInfo *Value) {
80 void CompilerInstance::setFileManager(FileManager *Value) {
84 void CompilerInstance::setSourceManager(SourceManager *Value) {
88 void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; }
90 void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; }
92 void CompilerInstance::setSema(Sema *S) {
96 void CompilerInstance::setASTConsumer(ASTConsumer *Value) {
97 Consumer.reset(Value);
100 void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
101 CompletionConsumer.reset(Value);
105 static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
106 const CodeGenOptions *CodeGenOpts,
107 DiagnosticsEngine &Diags) {
108 std::string ErrorInfo;
109 bool OwnsStream = false;
110 raw_ostream *OS = &llvm::errs();
111 if (DiagOpts->DiagnosticLogFile != "-") {
112 // Create the output stream.
113 llvm::raw_fd_ostream *FileOS(
114 new llvm::raw_fd_ostream(DiagOpts->DiagnosticLogFile.c_str(), ErrorInfo,
115 llvm::sys::fs::F_Append));
116 if (!ErrorInfo.empty()) {
117 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
118 << DiagOpts->DiagnosticLogFile << ErrorInfo;
120 FileOS->SetUnbuffered();
121 FileOS->SetUseAtomicWrites(true);
127 // Chain in the diagnostic client which will log the diagnostics.
128 LogDiagnosticPrinter *Logger = new LogDiagnosticPrinter(*OS, DiagOpts,
131 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
132 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger));
135 static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
136 DiagnosticsEngine &Diags,
137 StringRef OutputFile) {
138 std::string ErrorInfo;
139 OwningPtr<llvm::raw_fd_ostream> OS;
140 OS.reset(new llvm::raw_fd_ostream(OutputFile.str().c_str(), ErrorInfo,
141 llvm::sys::fs::F_Binary));
143 if (!ErrorInfo.empty()) {
144 Diags.Report(diag::warn_fe_serialized_diag_failure)
145 << OutputFile << ErrorInfo;
149 DiagnosticConsumer *SerializedConsumer =
150 clang::serialized_diags::create(OS.take(), DiagOpts);
153 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(),
154 SerializedConsumer));
157 void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
158 bool ShouldOwnClient) {
159 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
160 ShouldOwnClient, &getCodeGenOpts());
163 IntrusiveRefCntPtr<DiagnosticsEngine>
164 CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
165 DiagnosticConsumer *Client,
166 bool ShouldOwnClient,
167 const CodeGenOptions *CodeGenOpts) {
168 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
169 IntrusiveRefCntPtr<DiagnosticsEngine>
170 Diags(new DiagnosticsEngine(DiagID, Opts));
172 // Create the diagnostic client for reporting errors or for
173 // implementing -verify.
175 Diags->setClient(Client, ShouldOwnClient);
177 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
179 // Chain in -verify checker, if requested.
180 if (Opts->VerifyDiagnostics)
181 Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
183 // Chain in -diagnostic-log-file dumper, if requested.
184 if (!Opts->DiagnosticLogFile.empty())
185 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
187 if (!Opts->DiagnosticSerializationFile.empty())
188 SetupSerializedDiagnostics(Opts, *Diags,
189 Opts->DiagnosticSerializationFile);
191 // Configure our handling of diagnostics.
192 ProcessWarningOptions(*Diags, *Opts);
199 void CompilerInstance::createFileManager() {
200 FileMgr = new FileManager(getFileSystemOpts());
205 void CompilerInstance::createSourceManager(FileManager &FileMgr) {
206 SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
211 void CompilerInstance::createPreprocessor() {
212 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
214 // Create a PTH manager if we are using some form of a token cache.
215 PTHManager *PTHMgr = 0;
216 if (!PPOpts.TokenCache.empty())
217 PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
219 // Create the Preprocessor.
220 HeaderSearch *HeaderInfo = new HeaderSearch(&getHeaderSearchOpts(),
225 PP = new Preprocessor(&getPreprocessorOpts(),
226 getDiagnostics(), getLangOpts(), &getTarget(),
227 getSourceManager(), *HeaderInfo, *this, PTHMgr,
228 /*OwnsHeaderSearch=*/true);
230 // Note that this is different then passing PTHMgr to Preprocessor's ctor.
231 // That argument is used as the IdentifierInfoLookup argument to
232 // IdentifierTable's ctor.
234 PTHMgr->setPreprocessor(&*PP);
235 PP->setPTHManager(PTHMgr);
238 if (PPOpts.DetailedRecord)
239 PP->createPreprocessingRecord();
241 InitializePreprocessor(*PP, PPOpts, getHeaderSearchOpts(), getFrontendOpts());
243 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
245 // Set up the module path, including the hash for the
246 // module-creation options.
247 SmallString<256> SpecificModuleCache(
248 getHeaderSearchOpts().ModuleCachePath);
249 if (!getHeaderSearchOpts().DisableModuleHash)
250 llvm::sys::path::append(SpecificModuleCache,
251 getInvocation().getModuleHash());
252 PP->getHeaderSearchInfo().setModuleCachePath(SpecificModuleCache);
254 // Handle generating dependencies, if requested.
255 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
256 if (!DepOpts.OutputFile.empty())
257 AttachDependencyFileGen(*PP, DepOpts);
258 if (!DepOpts.DOTOutputFile.empty())
259 AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile,
260 getHeaderSearchOpts().Sysroot);
263 // Handle generating header include information, if requested.
264 if (DepOpts.ShowHeaderIncludes)
265 AttachHeaderIncludeGen(*PP);
266 if (!DepOpts.HeaderIncludeOutputFile.empty()) {
267 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
268 if (OutputPath == "-")
270 AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath,
271 /*ShowDepth=*/false);
274 if (DepOpts.PrintShowIncludes) {
275 AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/false, /*OutputPath=*/"",
276 /*ShowDepth=*/true, /*MSStyle=*/true);
282 void CompilerInstance::createASTContext() {
283 Preprocessor &PP = getPreprocessor();
284 Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
285 &getTarget(), PP.getIdentifierTable(),
286 PP.getSelectorTable(), PP.getBuiltinInfo(),
287 /*size_reserve=*/ 0);
292 void CompilerInstance::createPCHExternalASTSource(StringRef Path,
293 bool DisablePCHValidation,
294 bool AllowPCHWithCompilerErrors,
295 void *DeserializationListener){
296 OwningPtr<ExternalASTSource> Source;
297 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
298 Source.reset(createPCHExternalASTSource(Path, getHeaderSearchOpts().Sysroot,
299 DisablePCHValidation,
300 AllowPCHWithCompilerErrors,
301 getPreprocessor(), getASTContext(),
302 DeserializationListener,
304 getFrontendOpts().UseGlobalModuleIndex));
305 ModuleManager = static_cast<ASTReader*>(Source.get());
306 getASTContext().setExternalSource(Source);
310 CompilerInstance::createPCHExternalASTSource(StringRef Path,
311 const std::string &Sysroot,
312 bool DisablePCHValidation,
313 bool AllowPCHWithCompilerErrors,
316 void *DeserializationListener,
318 bool UseGlobalModuleIndex) {
319 OwningPtr<ASTReader> Reader;
320 Reader.reset(new ASTReader(PP, Context,
321 Sysroot.empty() ? "" : Sysroot.c_str(),
322 DisablePCHValidation,
323 AllowPCHWithCompilerErrors,
324 UseGlobalModuleIndex));
326 Reader->setDeserializationListener(
327 static_cast<ASTDeserializationListener *>(DeserializationListener));
328 switch (Reader->ReadAST(Path,
329 Preamble ? serialization::MK_Preamble
330 : serialization::MK_PCH,
332 ASTReader::ARR_None)) {
333 case ASTReader::Success:
334 // Set the predefines buffer as suggested by the PCH reader. Typically, the
335 // predefines buffer will be empty.
336 PP.setPredefines(Reader->getSuggestedPredefines());
337 return Reader.take();
339 case ASTReader::Failure:
340 // Unrecoverable failure: don't even try to process the input file.
343 case ASTReader::Missing:
344 case ASTReader::OutOfDate:
345 case ASTReader::VersionMismatch:
346 case ASTReader::ConfigurationMismatch:
347 case ASTReader::HadErrors:
348 // No suitable PCH file could be found. Return an error.
357 static bool EnableCodeCompletion(Preprocessor &PP,
358 const std::string &Filename,
361 // Tell the source manager to chop off the given file at a specific
363 const FileEntry *Entry = PP.getFileManager().getFile(Filename);
365 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
370 // Truncate the named file at the given line/column.
371 PP.SetCodeCompletionPoint(Entry, Line, Column);
375 void CompilerInstance::createCodeCompletionConsumer() {
376 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
377 if (!CompletionConsumer) {
378 setCodeCompletionConsumer(
379 createCodeCompletionConsumer(getPreprocessor(),
380 Loc.FileName, Loc.Line, Loc.Column,
381 getFrontendOpts().CodeCompleteOpts,
383 if (!CompletionConsumer)
385 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
386 Loc.Line, Loc.Column)) {
387 setCodeCompletionConsumer(0);
391 if (CompletionConsumer->isOutputBinary() &&
392 llvm::sys::ChangeStdoutToBinary()) {
393 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
394 setCodeCompletionConsumer(0);
398 void CompilerInstance::createFrontendTimer() {
399 FrontendTimer.reset(new llvm::Timer("Clang front-end timer"));
402 CodeCompleteConsumer *
403 CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
404 const std::string &Filename,
407 const CodeCompleteOptions &Opts,
409 if (EnableCodeCompletion(PP, Filename, Line, Column))
412 // Set up the creation routine for code-completion.
413 return new PrintingCodeCompleteConsumer(Opts, OS);
416 void CompilerInstance::createSema(TranslationUnitKind TUKind,
417 CodeCompleteConsumer *CompletionConsumer) {
418 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
419 TUKind, CompletionConsumer));
424 void CompilerInstance::addOutputFile(const OutputFile &OutFile) {
425 assert(OutFile.OS && "Attempt to add empty stream to output list!");
426 OutputFiles.push_back(OutFile);
429 void CompilerInstance::clearOutputFiles(bool EraseFiles) {
430 for (std::list<OutputFile>::iterator
431 it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) {
433 if (!it->TempFilename.empty()) {
436 llvm::sys::fs::remove(it->TempFilename, existed);
438 SmallString<128> NewOutFile(it->Filename);
440 // If '-working-directory' was passed, the output filename should be
442 FileMgr->FixupRelativePath(NewOutFile);
443 if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename,
445 getDiagnostics().Report(diag::err_unable_to_rename_temp)
446 << it->TempFilename << it->Filename << ec.message();
449 llvm::sys::fs::remove(it->TempFilename, existed);
452 } else if (!it->Filename.empty() && EraseFiles)
453 llvm::sys::fs::remove(it->Filename);
459 llvm::raw_fd_ostream *
460 CompilerInstance::createDefaultOutputFile(bool Binary,
462 StringRef Extension) {
463 return createOutputFile(getFrontendOpts().OutputFile, Binary,
464 /*RemoveFileOnSignal=*/true, InFile, Extension,
465 /*UseTemporary=*/true);
468 llvm::raw_fd_ostream *
469 CompilerInstance::createOutputFile(StringRef OutputPath,
470 bool Binary, bool RemoveFileOnSignal,
474 bool CreateMissingDirectories) {
475 std::string Error, OutputPathName, TempPathName;
476 llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary,
480 CreateMissingDirectories,
484 getDiagnostics().Report(diag::err_fe_unable_to_open_output)
485 << OutputPath << Error;
489 // Add the output file -- but don't try to remove "-", since this means we are
491 addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "",
497 llvm::raw_fd_ostream *
498 CompilerInstance::createOutputFile(StringRef OutputPath,
501 bool RemoveFileOnSignal,
505 bool CreateMissingDirectories,
506 std::string *ResultPathName,
507 std::string *TempPathName) {
508 assert((!CreateMissingDirectories || UseTemporary) &&
509 "CreateMissingDirectories is only allowed when using temporary files");
511 std::string OutFile, TempFile;
512 if (!OutputPath.empty()) {
513 OutFile = OutputPath;
514 } else if (InFile == "-") {
516 } else if (!Extension.empty()) {
517 SmallString<128> Path(InFile);
518 llvm::sys::path::replace_extension(Path, Extension);
519 OutFile = Path.str();
524 OwningPtr<llvm::raw_fd_ostream> OS;
529 UseTemporary = false;
531 llvm::sys::fs::file_status Status;
532 llvm::sys::fs::status(OutputPath, Status);
533 if (llvm::sys::fs::exists(Status)) {
534 // Fail early if we can't write to the final destination.
535 if (!llvm::sys::fs::can_write(OutputPath))
538 // Don't use a temporary if the output is a special file. This handles
539 // things like '-o /dev/null'
540 if (!llvm::sys::fs::is_regular_file(Status))
541 UseTemporary = false;
547 // Create a temporary file.
548 SmallString<128> TempPath;
550 TempPath += "-%%%%%%%%";
552 llvm::error_code EC =
553 llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath);
555 if (CreateMissingDirectories &&
556 EC == llvm::errc::no_such_file_or_directory) {
557 StringRef Parent = llvm::sys::path::parent_path(OutputPath);
558 EC = llvm::sys::fs::create_directories(Parent);
560 EC = llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath);
565 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
566 OSFile = TempFile = TempPath.str();
568 // If we failed to create the temporary, fallback to writing to the file
569 // directly. This handles the corner case where we cannot write to the
570 // directory, but can write to the file.
575 OS.reset(new llvm::raw_fd_ostream(
576 OSFile.c_str(), Error,
577 (Binary ? llvm::sys::fs::F_Binary : llvm::sys::fs::F_None)));
582 // Make sure the out stream file gets removed if we crash.
583 if (RemoveFileOnSignal)
584 llvm::sys::RemoveFileOnSignal(OSFile);
587 *ResultPathName = OutFile;
589 *TempPathName = TempFile;
594 // Initialization Utilities
596 bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
597 return InitializeSourceManager(Input, getDiagnostics(),
598 getFileManager(), getSourceManager(),
602 bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input,
603 DiagnosticsEngine &Diags,
604 FileManager &FileMgr,
605 SourceManager &SourceMgr,
606 const FrontendOptions &Opts) {
607 SrcMgr::CharacteristicKind
608 Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
610 if (Input.isBuffer()) {
611 SourceMgr.createMainFileIDForMemBuffer(Input.getBuffer(), Kind);
612 assert(!SourceMgr.getMainFileID().isInvalid() &&
613 "Couldn't establish MainFileID!");
617 StringRef InputFile = Input.getFile();
619 // Figure out where to get and map in the main file.
620 if (InputFile != "-") {
621 const FileEntry *File = FileMgr.getFile(InputFile, /*OpenFile=*/true);
623 Diags.Report(diag::err_fe_error_reading) << InputFile;
627 // The natural SourceManager infrastructure can't currently handle named
628 // pipes, but we would at least like to accept them for the main
629 // file. Detect them here, read them with the volatile flag so FileMgr will
630 // pick up the correct size, and simply override their contents as we do for
632 if (File->isNamedPipe()) {
633 std::string ErrorStr;
634 if (llvm::MemoryBuffer *MB =
635 FileMgr.getBufferForFile(File, &ErrorStr, /*isVolatile=*/true)) {
636 // Create a new virtual file that will have the correct size.
637 File = FileMgr.getVirtualFile(InputFile, MB->getBufferSize(), 0);
638 SourceMgr.overrideFileContents(File, MB);
640 Diags.Report(diag::err_cannot_open_file) << InputFile << ErrorStr;
645 SourceMgr.createMainFileID(File, Kind);
647 OwningPtr<llvm::MemoryBuffer> SB;
648 if (llvm::error_code ec = llvm::MemoryBuffer::getSTDIN(SB)) {
649 Diags.Report(diag::err_fe_error_reading_stdin) << ec.message();
652 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
653 SB->getBufferSize(), 0);
654 SourceMgr.createMainFileID(File, Kind);
655 SourceMgr.overrideFileContents(File, SB.take());
658 assert(!SourceMgr.getMainFileID().isInvalid() &&
659 "Couldn't establish MainFileID!");
663 // High-Level Operations
665 bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
666 assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
667 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
668 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
670 // FIXME: Take this as an argument, once all the APIs we used have moved to
671 // taking it as an input instead of hard-coding llvm::errs.
672 raw_ostream &OS = llvm::errs();
674 // Create the target instance.
675 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), &getTargetOpts()));
679 // Inform the target of the language options.
681 // FIXME: We shouldn't need to do this, the target should be immutable once
682 // created. This complexity should be lifted elsewhere.
683 getTarget().setForcedLangOptions(getLangOpts());
685 // rewriter project will change target built-in bool type from its default.
686 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
687 getTarget().noSignedCharForObjCBool();
689 // Validate/process some options.
690 if (getHeaderSearchOpts().Verbose)
691 OS << "clang -cc1 version " CLANG_VERSION_STRING
692 << " based upon " << PACKAGE_STRING
693 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
695 if (getFrontendOpts().ShowTimers)
696 createFrontendTimer();
698 if (getFrontendOpts().ShowStats)
699 llvm::EnableStatistics();
701 for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) {
702 // Reset the ID tables if we are reusing the SourceManager.
703 if (hasSourceManager())
704 getSourceManager().clearIDTables();
706 if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) {
712 // Notify the diagnostic client that all files were processed.
713 getDiagnostics().getClient()->finish();
715 if (getDiagnosticOpts().ShowCarets) {
716 // We can have multiple diagnostics sharing one diagnostic client.
717 // Get the total number of warnings/errors from the client.
718 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
719 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
722 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
723 if (NumWarnings && NumErrors)
726 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
727 if (NumWarnings || NumErrors)
728 OS << " generated.\n";
731 if (getFrontendOpts().ShowStats && hasFileManager()) {
732 getFileManager().PrintStats();
736 return !getDiagnostics().getClient()->getNumErrors();
739 /// \brief Determine the appropriate source input kind based on language
741 static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
747 return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
748 return LangOpts.CPlusPlus? IK_CXX : IK_C;
752 struct CompileModuleMapData {
753 CompilerInstance &Instance;
754 GenerateModuleAction &CreateModuleAction;
758 /// \brief Helper function that executes the module-generating action under
759 /// a crash recovery context.
760 static void doCompileMapModule(void *UserData) {
761 CompileModuleMapData &Data
762 = *reinterpret_cast<CompileModuleMapData *>(UserData);
763 Data.Instance.ExecuteAction(Data.CreateModuleAction);
767 /// \brief Function object that checks with the given macro definition should
768 /// be removed, because it is one of the ignored macros.
769 class RemoveIgnoredMacro {
770 const HeaderSearchOptions &HSOpts;
773 explicit RemoveIgnoredMacro(const HeaderSearchOptions &HSOpts)
776 bool operator()(const std::pair<std::string, bool> &def) const {
777 StringRef MacroDef = def.first;
778 return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0;
783 /// \brief Compile a module file for the given module, using the options
784 /// provided by the importing compiler instance.
785 static void compileModule(CompilerInstance &ImportingInstance,
786 SourceLocation ImportLoc,
788 StringRef ModuleFileName) {
789 // FIXME: have LockFileManager return an error_code so that we can
790 // avoid the mkdir when the directory already exists.
791 StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
792 llvm::sys::fs::create_directories(Dir);
794 llvm::LockFileManager Locked(ModuleFileName);
796 case llvm::LockFileManager::LFS_Error:
799 case llvm::LockFileManager::LFS_Owned:
800 // We're responsible for building the module ourselves. Do so below.
803 case llvm::LockFileManager::LFS_Shared:
804 // Someone else is responsible for building the module. Wait for them to
806 Locked.waitForUnlock();
811 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
813 // Construct a compiler invocation for creating this module.
814 IntrusiveRefCntPtr<CompilerInvocation> Invocation
815 (new CompilerInvocation(ImportingInstance.getInvocation()));
817 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
819 // For any options that aren't intended to affect how a module is built,
820 // reset them to their default values.
821 Invocation->getLangOpts()->resetNonModularOptions();
822 PPOpts.resetNonModularOptions();
824 // Remove any macro definitions that are explicitly ignored by the module.
825 // They aren't supposed to affect how the module is built anyway.
826 const HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
827 PPOpts.Macros.erase(std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
828 RemoveIgnoredMacro(HSOpts)),
829 PPOpts.Macros.end());
832 // Note the name of the module we're building.
833 Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
835 // Make sure that the failed-module structure has been allocated in
836 // the importing instance, and propagate the pointer to the newly-created
838 PreprocessorOptions &ImportingPPOpts
839 = ImportingInstance.getInvocation().getPreprocessorOpts();
840 if (!ImportingPPOpts.FailedModules)
841 ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet;
842 PPOpts.FailedModules = ImportingPPOpts.FailedModules;
844 // If there is a module map file, build the module using the module map.
845 // Set up the inputs/outputs so that we build the module from its umbrella
847 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
848 FrontendOpts.OutputFile = ModuleFileName.str();
849 FrontendOpts.DisableFree = false;
850 FrontendOpts.GenerateGlobalModuleIndex = false;
851 FrontendOpts.Inputs.clear();
852 InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
854 // Don't free the remapped file buffers; they are owned by our caller.
855 PPOpts.RetainRemappedFileBuffers = true;
857 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
858 assert(ImportingInstance.getInvocation().getModuleHash() ==
859 Invocation->getModuleHash() && "Module hash mismatch!");
861 // Construct a compiler instance that will be used to actually create the
863 CompilerInstance Instance;
864 Instance.setInvocation(&*Invocation);
866 Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
867 ImportingInstance.getDiagnosticClient()),
868 /*ShouldOwnClient=*/true);
870 // Note that this module is part of the module build stack, so that we
871 // can detect cycles in the module graph.
872 Instance.createFileManager(); // FIXME: Adopt file manager from importer?
873 Instance.createSourceManager(Instance.getFileManager());
874 SourceManager &SourceMgr = Instance.getSourceManager();
875 SourceMgr.setModuleBuildStack(
876 ImportingInstance.getSourceManager().getModuleBuildStack());
877 SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(),
878 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
880 // Get or create the module map that we'll use to build this module.
881 std::string InferredModuleMapContent;
882 if (const FileEntry *ModuleMapFile =
883 ModMap.getContainingModuleMapFile(Module)) {
884 // Use the module map where this module resides.
885 FrontendOpts.Inputs.push_back(
886 FrontendInputFile(ModuleMapFile->getName(), IK));
888 llvm::raw_string_ostream OS(InferredModuleMapContent);
891 FrontendOpts.Inputs.push_back(
892 FrontendInputFile("__inferred_module.map", IK));
894 const llvm::MemoryBuffer *ModuleMapBuffer =
895 llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
896 ModuleMapFile = Instance.getFileManager().getVirtualFile(
897 "__inferred_module.map", InferredModuleMapContent.size(), 0);
898 SourceMgr.overrideFileContents(ModuleMapFile, ModuleMapBuffer);
901 // Construct a module-generating action.
902 GenerateModuleAction CreateModuleAction(Module->IsSystem);
904 // Execute the action to actually build the module in-place. Use a separate
905 // thread so that we get a stack large enough.
906 const unsigned ThreadStackSize = 8 << 20;
907 llvm::CrashRecoveryContext CRC;
908 CompileModuleMapData Data = { Instance, CreateModuleAction };
909 CRC.RunSafelyOnThread(&doCompileMapModule, &Data, ThreadStackSize);
912 // Delete the temporary module map file.
913 // FIXME: Even though we're executing under crash protection, it would still
914 // be nice to do this with RemoveFileOnSignal when we can. However, that
915 // doesn't make sense for all clients, so clean this up manually.
916 Instance.clearOutputFiles(/*EraseFiles=*/true);
918 // We've rebuilt a module. If we're allowed to generate or update the global
919 // module index, record that fact in the importing compiler instance.
920 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
921 ImportingInstance.setBuildGlobalModuleIndex(true);
925 /// \brief Diagnose differences between the current definition of the given
926 /// configuration macro and the definition provided on the command line.
927 static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
928 Module *Mod, SourceLocation ImportLoc) {
929 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
930 SourceManager &SourceMgr = PP.getSourceManager();
932 // If this identifier has never had a macro definition, then it could
934 if (!Id->hadMacroDefinition())
937 // If this identifier does not currently have a macro definition,
938 // check whether it had one on the command line.
939 if (!Id->hasMacroDefinition()) {
940 MacroDirective::DefInfo LatestDef =
941 PP.getMacroDirectiveHistory(Id)->getDefinition();
942 for (MacroDirective::DefInfo Def = LatestDef; Def;
943 Def = Def.getPreviousDefinition()) {
944 FileID FID = SourceMgr.getFileID(Def.getLocation());
948 // We only care about the predefines buffer.
949 if (FID != PP.getPredefinesFileID())
952 // This macro was defined on the command line, then #undef'd later.
954 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
955 << true << ConfigMacro << Mod->getFullModuleName();
956 if (LatestDef.isUndefined())
957 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
962 // Okay: no definition in the predefines buffer.
966 // This identifier has a macro definition. Check whether we had a definition
967 // on the command line.
968 MacroDirective::DefInfo LatestDef =
969 PP.getMacroDirectiveHistory(Id)->getDefinition();
970 MacroDirective::DefInfo PredefinedDef;
971 for (MacroDirective::DefInfo Def = LatestDef; Def;
972 Def = Def.getPreviousDefinition()) {
973 FileID FID = SourceMgr.getFileID(Def.getLocation());
977 // We only care about the predefines buffer.
978 if (FID != PP.getPredefinesFileID())
985 // If there was no definition for this macro in the predefines buffer,
987 if (!PredefinedDef ||
988 (!PredefinedDef.getLocation().isValid() &&
989 PredefinedDef.getUndefLocation().isValid())) {
990 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
991 << false << ConfigMacro << Mod->getFullModuleName();
992 PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here)
997 // If the current macro definition is the same as the predefined macro
998 // definition, it's okay.
999 if (LatestDef.getMacroInfo() == PredefinedDef.getMacroInfo() ||
1000 LatestDef.getMacroInfo()->isIdenticalTo(*PredefinedDef.getMacroInfo(),PP,
1001 /*Syntactically=*/true))
1004 // The macro definitions differ.
1005 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1006 << false << ConfigMacro << Mod->getFullModuleName();
1007 PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here)
1011 /// \brief Write a new timestamp file with the given path.
1012 static void writeTimestampFile(StringRef TimestampFile) {
1013 std::string ErrorInfo;
1014 llvm::raw_fd_ostream Out(TimestampFile.str().c_str(), ErrorInfo,
1015 llvm::sys::fs::F_Binary);
1018 /// \brief Prune the module cache of modules that haven't been accessed in
1020 static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1021 struct stat StatBuf;
1022 llvm::SmallString<128> TimestampFile;
1023 TimestampFile = HSOpts.ModuleCachePath;
1024 llvm::sys::path::append(TimestampFile, "modules.timestamp");
1026 // Try to stat() the timestamp file.
1027 if (::stat(TimestampFile.c_str(), &StatBuf)) {
1028 // If the timestamp file wasn't there, create one now.
1029 if (errno == ENOENT) {
1030 writeTimestampFile(TimestampFile);
1035 // Check whether the time stamp is older than our pruning interval.
1036 // If not, do nothing.
1037 time_t TimeStampModTime = StatBuf.st_mtime;
1038 time_t CurrentTime = time(0);
1039 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
1042 // Write a new timestamp file so that nobody else attempts to prune.
1043 // There is a benign race condition here, if two Clang instances happen to
1044 // notice at the same time that the timestamp is out-of-date.
1045 writeTimestampFile(TimestampFile);
1047 // Walk the entire module cache, looking for unused module files and module
1049 llvm::error_code EC;
1050 SmallString<128> ModuleCachePathNative;
1051 llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1052 for (llvm::sys::fs::directory_iterator
1053 Dir(ModuleCachePathNative.str(), EC), DirEnd;
1054 Dir != DirEnd && !EC; Dir.increment(EC)) {
1055 // If we don't have a directory, there's nothing to look into.
1056 if (!llvm::sys::fs::is_directory(Dir->path()))
1059 // Walk all of the files within this directory.
1060 bool RemovedAllFiles = true;
1061 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1062 File != FileEnd && !EC; File.increment(EC)) {
1063 // We only care about module and global module index files.
1064 if (llvm::sys::path::extension(File->path()) != ".pcm" &&
1065 llvm::sys::path::filename(File->path()) != "modules.idx") {
1066 RemovedAllFiles = false;
1070 // Look at this file. If we can't stat it, there's nothing interesting
1072 if (::stat(File->path().c_str(), &StatBuf)) {
1073 RemovedAllFiles = false;
1077 // If the file has been used recently enough, leave it there.
1078 time_t FileAccessTime = StatBuf.st_atime;
1079 if (CurrentTime - FileAccessTime <=
1080 time_t(HSOpts.ModuleCachePruneAfter)) {
1081 RemovedAllFiles = false;
1087 if (llvm::sys::fs::remove(File->path(), Existed) || !Existed) {
1088 RemovedAllFiles = false;
1092 // If we removed all of the files in the directory, remove the directory
1094 if (RemovedAllFiles) {
1096 llvm::sys::fs::remove(Dir->path(), Existed);
1102 CompilerInstance::loadModule(SourceLocation ImportLoc,
1104 Module::NameVisibilityKind Visibility,
1105 bool IsInclusionDirective) {
1106 // Determine what file we're searching from.
1107 StringRef ModuleName = Path[0].first->getName();
1108 SourceLocation ModuleNameLoc = Path[0].second;
1110 // If we've already handled this import, just return the cached result.
1111 // This one-element cache is important to eliminate redundant diagnostics
1112 // when both the preprocessor and parser see the same import declaration.
1113 if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) {
1114 // Make the named module visible.
1115 if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
1116 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
1117 ImportLoc, /*Complain=*/false);
1118 return LastModuleImportResult;
1121 clang::Module *Module = 0;
1123 // If we don't already have information on this module, load the module now.
1124 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
1125 = KnownModules.find(Path[0].first);
1126 if (Known != KnownModules.end()) {
1127 // Retrieve the cached top-level module.
1128 Module = Known->second;
1129 } else if (ModuleName == getLangOpts().CurrentModule) {
1130 // This is the module we're building.
1131 Module = PP->getHeaderSearchInfo().getModuleMap().findModule(ModuleName);
1132 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1134 // Search for a module with the given name.
1135 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1136 std::string ModuleFileName;
1138 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module);
1140 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(ModuleName);
1142 // If we don't already have an ASTReader, create one now.
1143 if (!ModuleManager) {
1144 if (!hasASTContext())
1147 // If we're not recursively building a module, check whether we
1148 // need to prune the module cache.
1149 if (getSourceManager().getModuleBuildStack().empty() &&
1150 getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1151 getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1152 pruneModuleCache(getHeaderSearchOpts());
1155 std::string Sysroot = getHeaderSearchOpts().Sysroot;
1156 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1157 ModuleManager = new ASTReader(getPreprocessor(), *Context,
1158 Sysroot.empty() ? "" : Sysroot.c_str(),
1159 PPOpts.DisablePCHValidation,
1160 /*AllowASTWithCompilerErrors=*/false,
1161 getFrontendOpts().UseGlobalModuleIndex);
1162 if (hasASTConsumer()) {
1163 ModuleManager->setDeserializationListener(
1164 getASTConsumer().GetASTDeserializationListener());
1165 getASTContext().setASTMutationListener(
1166 getASTConsumer().GetASTMutationListener());
1168 OwningPtr<ExternalASTSource> Source;
1169 Source.reset(ModuleManager);
1170 getASTContext().setExternalSource(Source);
1172 ModuleManager->InitializeSema(getSema());
1173 if (hasASTConsumer())
1174 ModuleManager->StartTranslationUnit(&getASTConsumer());
1177 // Try to load the module file.
1178 unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing;
1179 switch (ModuleManager->ReadAST(ModuleFileName, serialization::MK_Module,
1180 ImportLoc, ARRFlags)) {
1181 case ASTReader::Success:
1184 case ASTReader::OutOfDate:
1185 case ASTReader::Missing: {
1186 // The module file is missing or out-of-date. Build it.
1188 // If we don't have a module, we don't know how to build the module file.
1189 // Complain and return.
1191 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1193 << SourceRange(ImportLoc, ModuleNameLoc);
1194 ModuleBuildFailed = true;
1195 return ModuleLoadResult();
1198 // Check whether there is a cycle in the module graph.
1199 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1200 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1201 for (; Pos != PosEnd; ++Pos) {
1202 if (Pos->first == ModuleName)
1206 if (Pos != PosEnd) {
1207 SmallString<256> CyclePath;
1208 for (; Pos != PosEnd; ++Pos) {
1209 CyclePath += Pos->first;
1210 CyclePath += " -> ";
1212 CyclePath += ModuleName;
1214 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1215 << ModuleName << CyclePath;
1216 return ModuleLoadResult();
1219 // Check whether we have already attempted to build this module (but
1221 if (getPreprocessorOpts().FailedModules &&
1222 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1223 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1225 << SourceRange(ImportLoc, ModuleNameLoc);
1226 ModuleBuildFailed = true;
1227 return ModuleLoadResult();
1230 // Try to compile the module.
1231 compileModule(*this, ModuleNameLoc, Module, ModuleFileName);
1233 // Try to read the module file, now that we've compiled it.
1234 ASTReader::ASTReadResult ReadResult
1235 = ModuleManager->ReadAST(ModuleFileName,
1236 serialization::MK_Module, ImportLoc,
1237 ASTReader::ARR_Missing);
1238 if (ReadResult != ASTReader::Success) {
1239 if (ReadResult == ASTReader::Missing) {
1240 getDiagnostics().Report(ModuleNameLoc,
1241 Module? diag::err_module_not_built
1242 : diag::err_module_not_found)
1244 << SourceRange(ImportLoc, ModuleNameLoc);
1247 if (getPreprocessorOpts().FailedModules)
1248 getPreprocessorOpts().FailedModules->addFailed(ModuleName);
1249 KnownModules[Path[0].first] = 0;
1250 ModuleBuildFailed = true;
1251 return ModuleLoadResult();
1254 // Okay, we've rebuilt and now loaded the module.
1258 case ASTReader::VersionMismatch:
1259 case ASTReader::ConfigurationMismatch:
1260 case ASTReader::HadErrors:
1261 ModuleLoader::HadFatalFailure = true;
1262 // FIXME: The ASTReader will already have complained, but can we showhorn
1263 // that diagnostic information into a more useful form?
1264 KnownModules[Path[0].first] = 0;
1265 return ModuleLoadResult();
1267 case ASTReader::Failure:
1268 ModuleLoader::HadFatalFailure = true;
1269 // Already complained, but note now that we failed.
1270 KnownModules[Path[0].first] = 0;
1271 ModuleBuildFailed = true;
1272 return ModuleLoadResult();
1276 // If we loaded the module directly, without finding a module map first,
1277 // we'll have loaded the module's information from the module itself.
1278 Module = PP->getHeaderSearchInfo().getModuleMap()
1279 .findModule((Path[0].first->getName()));
1282 // Cache the result of this top-level module lookup for later.
1283 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1286 // If we never found the module, fail.
1288 return ModuleLoadResult();
1290 // Verify that the rest of the module path actually corresponds to
1292 if (Path.size() > 1) {
1293 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1294 StringRef Name = Path[I].first->getName();
1295 clang::Module *Sub = Module->findSubmodule(Name);
1298 // Attempt to perform typo correction to find a module name that works.
1299 SmallVector<StringRef, 2> Best;
1300 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1302 for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1303 JEnd = Module->submodule_end();
1305 unsigned ED = Name.edit_distance((*J)->Name,
1306 /*AllowReplacements=*/true,
1308 if (ED <= BestEditDistance) {
1309 if (ED < BestEditDistance) {
1311 BestEditDistance = ED;
1314 Best.push_back((*J)->Name);
1318 // If there was a clear winner, user it.
1319 if (Best.size() == 1) {
1320 getDiagnostics().Report(Path[I].second,
1321 diag::err_no_submodule_suggest)
1322 << Path[I].first << Module->getFullModuleName() << Best[0]
1323 << SourceRange(Path[0].second, Path[I-1].second)
1324 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1327 Sub = Module->findSubmodule(Best[0]);
1332 // No submodule by this name. Complain, and don't look for further
1334 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
1335 << Path[I].first << Module->getFullModuleName()
1336 << SourceRange(Path[0].second, Path[I-1].second);
1344 // Make the named module visible, if it's not already part of the module
1346 if (ModuleName != getLangOpts().CurrentModule) {
1347 if (!Module->IsFromModuleFile) {
1348 // We have an umbrella header or directory that doesn't actually include
1349 // all of the headers within the directory it covers. Complain about
1350 // this missing submodule and recover by forgetting that we ever saw
1352 // FIXME: Should we detect this at module load time? It seems fairly
1353 // expensive (and rare).
1354 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1355 << Module->getFullModuleName()
1356 << SourceRange(Path.front().second, Path.back().second);
1358 return ModuleLoadResult(0, true);
1361 // Check whether this module is available.
1362 clang::Module::Requirement Requirement;
1363 if (!Module->isAvailable(getLangOpts(), getTarget(), Requirement)) {
1364 getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
1365 << Module->getFullModuleName()
1366 << Requirement.second << Requirement.first
1367 << SourceRange(Path.front().second, Path.back().second);
1368 LastModuleImportLoc = ImportLoc;
1369 LastModuleImportResult = ModuleLoadResult();
1370 return ModuleLoadResult();
1373 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc,
1377 // Check for any configuration macros that have changed.
1378 clang::Module *TopModule = Module->getTopLevelModule();
1379 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1380 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1384 // If this module import was due to an inclusion directive, create an
1385 // implicit import declaration to capture it in the AST.
1386 if (IsInclusionDirective && hasASTContext()) {
1387 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
1388 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
1390 Path.back().second);
1391 TU->addDecl(ImportD);
1393 Consumer->HandleImplicitImportDecl(ImportD);
1396 LastModuleImportLoc = ImportLoc;
1397 LastModuleImportResult = ModuleLoadResult(Module, false);
1398 return LastModuleImportResult;
1401 void CompilerInstance::makeModuleVisible(Module *Mod,
1402 Module::NameVisibilityKind Visibility,
1403 SourceLocation ImportLoc,
1405 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc, Complain);