blob: ec1f9590606ed4c48e2f9533eceb477bf2f5137c [file] [log] [blame]
Daniel Dunbar2a79e162009-11-13 03:51:44 +00001//===--- 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"
Daniel Dunbar12ce6942009-11-14 02:47:17 +000011#include "clang/AST/ASTConsumer.h"
Daniel Dunbar5eb81002009-11-13 08:20:47 +000012#include "clang/AST/ASTContext.h"
Douglas Gregor93ebfa62011-12-02 23:42:12 +000013#include "clang/AST/Decl.h"
Daniel Dunbar2a79e162009-11-13 03:51:44 +000014#include "clang/Basic/Diagnostic.h"
Daniel Dunbar16b74492009-11-13 04:12:06 +000015#include "clang/Basic/FileManager.h"
16#include "clang/Basic/SourceManager.h"
Daniel Dunbar2a79e162009-11-13 03:51:44 +000017#include "clang/Basic/TargetInfo.h"
Daniel Dunbar0397af22010-01-13 00:48:06 +000018#include "clang/Basic/Version.h"
David Blaikie4e85b8a2011-09-26 00:21:47 +000019#include "clang/Frontend/ChainedDiagnosticConsumer.h"
Daniel Dunbar0397af22010-01-13 00:48:06 +000020#include "clang/Frontend/FrontendAction.h"
Douglas Gregor21cae202011-09-12 23:31:24 +000021#include "clang/Frontend/FrontendActions.h"
Daniel Dunbarc2f484f2009-11-13 09:36:05 +000022#include "clang/Frontend/FrontendDiagnostic.h"
Daniel Dunbar9df23492011-04-07 18:31:10 +000023#include "clang/Frontend/LogDiagnosticPrinter.h"
Ted Kremenek78002122011-10-29 00:12:39 +000024#include "clang/Frontend/SerializedDiagnosticPrinter.h"
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +000025#include "clang/Frontend/TextDiagnosticPrinter.h"
Daniel Dunbar22dacfa2009-11-13 05:52:11 +000026#include "clang/Frontend/Utils.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000027#include "clang/Frontend/VerifyDiagnosticConsumer.h"
28#include "clang/Lex/HeaderSearch.h"
29#include "clang/Lex/PTHManager.h"
30#include "clang/Lex/Preprocessor.h"
Daniel Dunbarc2f484f2009-11-13 09:36:05 +000031#include "clang/Sema/CodeCompleteConsumer.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000032#include "clang/Sema/Sema.h"
33#include "clang/Serialization/ASTReader.h"
Douglas Gregor95dd5582010-03-30 17:33:59 +000034#include "llvm/ADT/Statistic.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000035#include "llvm/Config/config.h"
36#include "llvm/Support/CrashRecoveryContext.h"
37#include "llvm/Support/FileSystem.h"
Michael J. Spencer03013fa2010-11-29 18:12:39 +000038#include "llvm/Support/Host.h"
Douglas Gregor52f12722012-01-29 20:15:24 +000039#include "llvm/Support/LockFileManager.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000040#include "llvm/Support/MemoryBuffer.h"
Michael J. Spencer03013fa2010-11-29 18:12:39 +000041#include "llvm/Support/Path.h"
42#include "llvm/Support/Program.h"
43#include "llvm/Support/Signals.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000044#include "llvm/Support/Timer.h"
45#include "llvm/Support/raw_ostream.h"
Michael J. Spencer3a321e22010-12-09 17:36:38 +000046#include "llvm/Support/system_error.h"
Douglas Gregord44d2872013-03-25 21:19:16 +000047#include <sys/stat.h>
Douglas Gregor87ab0662013-03-25 21:51:16 +000048#include <time.h>
Douglas Gregor2bc75072011-10-05 14:53:30 +000049
Daniel Dunbar2a79e162009-11-13 03:51:44 +000050using namespace clang;
51
Daniel Dunbar42e9f8e42010-02-16 01:54:47 +000052CompilerInstance::CompilerInstance()
Douglas Gregora6b00fc2013-01-23 22:38:11 +000053 : Invocation(new CompilerInvocation()), ModuleManager(0),
Douglas Gregorf575d6e2013-01-25 00:45:27 +000054 BuildGlobalModuleIndex(false), ModuleBuildFailed(false) {
Daniel Dunbar6228ca02010-01-30 21:47:07 +000055}
Daniel Dunbar2a79e162009-11-13 03:51:44 +000056
57CompilerInstance::~CompilerInstance() {
Benjamin Kramerac447fc2012-10-14 19:21:21 +000058 assert(OutputFiles.empty() && "Still output files in flight?");
Daniel Dunbar42e9f8e42010-02-16 01:54:47 +000059}
60
Daniel Dunbar6228ca02010-01-30 21:47:07 +000061void CompilerInstance::setInvocation(CompilerInvocation *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000062 Invocation = Value;
Daniel Dunbar6228ca02010-01-30 21:47:07 +000063}
64
Douglas Gregorf575d6e2013-01-25 00:45:27 +000065bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
Douglas Gregor1a49d972013-01-25 01:03:03 +000066 return (BuildGlobalModuleIndex ||
Douglas Gregored2fc2a2013-03-22 21:26:48 +000067 (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
68 getFrontendOpts().GenerateGlobalModuleIndex)) &&
Douglas Gregor1a49d972013-01-25 01:03:03 +000069 !ModuleBuildFailed;
Douglas Gregorf575d6e2013-01-25 00:45:27 +000070}
71
David Blaikied6471f72011-09-25 23:23:43 +000072void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
Douglas Gregor28019772010-04-05 23:52:57 +000073 Diagnostics = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000074}
75
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000076void CompilerInstance::setTarget(TargetInfo *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000077 Target = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000078}
79
80void CompilerInstance::setFileManager(FileManager *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000081 FileMgr = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000082}
83
NAKAMURA Takumia789ca92011-10-08 11:31:46 +000084void CompilerInstance::setSourceManager(SourceManager *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000085 SourceMgr = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000086}
87
Ted Kremenek4f327862011-03-21 18:40:17 +000088void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; }
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000089
Ted Kremenek4f327862011-03-21 18:40:17 +000090void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; }
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000091
Douglas Gregorf18d0d82010-08-12 23:31:19 +000092void CompilerInstance::setSema(Sema *S) {
93 TheSema.reset(S);
94}
95
Daniel Dunbar12ce6942009-11-14 02:47:17 +000096void CompilerInstance::setASTConsumer(ASTConsumer *Value) {
97 Consumer.reset(Value);
98}
99
Daniel Dunbar8a9f5692009-11-14 01:20:40 +0000100void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
101 CompletionConsumer.reset(Value);
102}
103
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000104// Diagnostics
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000105static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000106 const CodeGenOptions *CodeGenOpts,
David Blaikied6471f72011-09-25 23:23:43 +0000107 DiagnosticsEngine &Diags) {
Daniel Dunbar9df23492011-04-07 18:31:10 +0000108 std::string ErrorInfo;
109 bool OwnsStream = false;
Chris Lattner5f9e2722011-07-23 10:55:15 +0000110 raw_ostream *OS = &llvm::errs();
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000111 if (DiagOpts->DiagnosticLogFile != "-") {
Daniel Dunbar9df23492011-04-07 18:31:10 +0000112 // Create the output stream.
113 llvm::raw_fd_ostream *FileOS(
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000114 new llvm::raw_fd_ostream(DiagOpts->DiagnosticLogFile.c_str(),
Daniel Dunbare01eceb2011-04-07 20:19:21 +0000115 ErrorInfo, llvm::raw_fd_ostream::F_Append));
Daniel Dunbar9df23492011-04-07 18:31:10 +0000116 if (!ErrorInfo.empty()) {
117 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
Sean Silvad2ff76b2013-01-20 01:58:26 +0000118 << DiagOpts->DiagnosticLogFile << ErrorInfo;
Daniel Dunbar9df23492011-04-07 18:31:10 +0000119 } else {
120 FileOS->SetUnbuffered();
121 FileOS->SetUseAtomicWrites(true);
122 OS = FileOS;
123 OwnsStream = true;
124 }
125 }
126
127 // Chain in the diagnostic client which will log the diagnostics.
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000128 LogDiagnosticPrinter *Logger = new LogDiagnosticPrinter(*OS, DiagOpts,
129 OwnsStream);
130 if (CodeGenOpts)
131 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
David Blaikie4e85b8a2011-09-26 00:21:47 +0000132 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger));
Daniel Dunbar9df23492011-04-07 18:31:10 +0000133}
134
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000135static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
Ted Kremenek78002122011-10-29 00:12:39 +0000136 DiagnosticsEngine &Diags,
137 StringRef OutputFile) {
138 std::string ErrorInfo;
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000139 OwningPtr<llvm::raw_fd_ostream> OS;
Ted Kremenek78002122011-10-29 00:12:39 +0000140 OS.reset(new llvm::raw_fd_ostream(OutputFile.str().c_str(), ErrorInfo,
141 llvm::raw_fd_ostream::F_Binary));
142
143 if (!ErrorInfo.empty()) {
144 Diags.Report(diag::warn_fe_serialized_diag_failure)
145 << OutputFile << ErrorInfo;
146 return;
147 }
148
149 DiagnosticConsumer *SerializedConsumer =
Ted Kremenek2a764102011-12-17 05:26:11 +0000150 clang::serialized_diags::create(OS.take(), DiagOpts);
Ted Kremenek78002122011-10-29 00:12:39 +0000151
152
153 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(),
154 SerializedConsumer));
155}
156
Sean Silvad47afb92013-01-20 01:58:28 +0000157void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
Douglas Gregorcc2b6532013-05-03 23:07:45 +0000158 bool ShouldOwnClient) {
Sean Silvad47afb92013-01-20 01:58:28 +0000159 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
Douglas Gregorcc2b6532013-05-03 23:07:45 +0000160 ShouldOwnClient, &getCodeGenOpts());
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000161}
162
Dylan Noblesmithc93dc782012-02-20 14:00:23 +0000163IntrusiveRefCntPtr<DiagnosticsEngine>
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000164CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
David Blaikie78ad0b92011-09-25 23:39:51 +0000165 DiagnosticConsumer *Client,
Douglas Gregor78243652011-09-13 01:26:44 +0000166 bool ShouldOwnClient,
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000167 const CodeGenOptions *CodeGenOpts) {
Dylan Noblesmithc93dc782012-02-20 14:00:23 +0000168 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
169 IntrusiveRefCntPtr<DiagnosticsEngine>
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000170 Diags(new DiagnosticsEngine(DiagID, Opts));
Daniel Dunbar221c7212009-11-14 07:53:24 +0000171
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000172 // Create the diagnostic client for reporting errors or for
173 // implementing -verify.
Douglas Gregoraee526e2011-09-29 00:38:00 +0000174 if (Client) {
Douglas Gregorcc2b6532013-05-03 23:07:45 +0000175 Diags->setClient(Client, ShouldOwnClient);
Douglas Gregoraee526e2011-09-29 00:38:00 +0000176 } else
Douglas Gregore47be3e2010-11-11 00:39:14 +0000177 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
Daniel Dunbarf79dced2009-11-14 03:24:39 +0000178
179 // Chain in -verify checker, if requested.
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000180 if (Opts->VerifyDiagnostics)
David Blaikie621bc692011-09-26 00:38:03 +0000181 Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000182
Daniel Dunbar9df23492011-04-07 18:31:10 +0000183 // Chain in -diagnostic-log-file dumper, if requested.
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000184 if (!Opts->DiagnosticLogFile.empty())
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000185 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000186
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000187 if (!Opts->DiagnosticSerializationFile.empty())
Ted Kremenek78002122011-10-29 00:12:39 +0000188 SetupSerializedDiagnostics(Opts, *Diags,
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000189 Opts->DiagnosticSerializationFile);
Ted Kremenek78002122011-10-29 00:12:39 +0000190
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000191 // Configure our handling of diagnostics.
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000192 ProcessWarningOptions(*Diags, *Opts);
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000193
Douglas Gregor28019772010-04-05 23:52:57 +0000194 return Diags;
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000195}
196
197// File Manager
198
Daniel Dunbar16b74492009-11-13 04:12:06 +0000199void CompilerInstance::createFileManager() {
Ted Kremenek4f327862011-03-21 18:40:17 +0000200 FileMgr = new FileManager(getFileSystemOpts());
Daniel Dunbar16b74492009-11-13 04:12:06 +0000201}
202
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000203// Source Manager
204
Chris Lattner39b49bc2010-11-23 08:35:12 +0000205void CompilerInstance::createSourceManager(FileManager &FileMgr) {
Ted Kremenek4f327862011-03-21 18:40:17 +0000206 SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
Daniel Dunbar16b74492009-11-13 04:12:06 +0000207}
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000208
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000209// Preprocessor
210
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000211void CompilerInstance::createPreprocessor() {
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000212 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000213
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000214 // Create a PTH manager if we are using some form of a token cache.
215 PTHManager *PTHMgr = 0;
Daniel Dunbar049d3a02009-11-17 05:52:41 +0000216 if (!PPOpts.TokenCache.empty())
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000217 PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000218
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000219 // Create the Preprocessor.
Douglas Gregorc042edd2012-10-24 16:19:39 +0000220 HeaderSearch *HeaderInfo = new HeaderSearch(&getHeaderSearchOpts(),
221 getFileManager(),
Douglas Gregor51f564f2011-12-31 04:05:44 +0000222 getDiagnostics(),
Douglas Gregordc58aa72012-01-30 06:01:29 +0000223 getLangOpts(),
224 &getTarget());
Douglas Gregor36a16492012-10-24 17:46:57 +0000225 PP = new Preprocessor(&getPreprocessorOpts(),
226 getDiagnostics(), getLangOpts(), &getTarget(),
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000227 getSourceManager(), *HeaderInfo, *this, PTHMgr,
228 /*OwnsHeaderSearch=*/true);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000229
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000230 // 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.
233 if (PTHMgr) {
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000234 PTHMgr->setPreprocessor(&*PP);
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000235 PP->setPTHManager(PTHMgr);
236 }
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000237
Douglas Gregor94dc8f62010-03-19 16:15:56 +0000238 if (PPOpts.DetailedRecord)
Argyrios Kyrtzidis37ed1272012-12-04 07:27:05 +0000239 PP->createPreprocessingRecord();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000240
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000241 InitializePreprocessor(*PP, PPOpts, getHeaderSearchOpts(), getFrontendOpts());
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000242
Jordan Rose74c24982013-01-30 01:52:57 +0000243 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
244
Douglas Gregor6e975c42011-09-13 23:15:45 +0000245 // Set up the module path, including the hash for the
246 // module-creation options.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000247 SmallString<256> SpecificModuleCache(
Douglas Gregor6e975c42011-09-13 23:15:45 +0000248 getHeaderSearchOpts().ModuleCachePath);
249 if (!getHeaderSearchOpts().DisableModuleHash)
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000250 llvm::sys::path::append(SpecificModuleCache,
Douglas Gregor6e975c42011-09-13 23:15:45 +0000251 getInvocation().getModuleHash());
Douglas Gregor5e3f9222011-12-08 17:01:29 +0000252 PP->getHeaderSearchInfo().setModuleCachePath(SpecificModuleCache);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000253
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000254 // Handle generating dependencies, if requested.
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000255 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000256 if (!DepOpts.OutputFile.empty())
257 AttachDependencyFileGen(*PP, DepOpts);
Douglas Gregor773303a2012-02-02 23:45:13 +0000258 if (!DepOpts.DOTOutputFile.empty())
259 AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile,
Douglas Gregorc69a1812012-02-02 00:54:52 +0000260 getHeaderSearchOpts().Sysroot);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000261
Douglas Gregorc69a1812012-02-02 00:54:52 +0000262
Daniel Dunbareef63e02011-02-02 15:41:17 +0000263 // Handle generating header include information, if requested.
264 if (DepOpts.ShowHeaderIncludes)
265 AttachHeaderIncludeGen(*PP);
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000266 if (!DepOpts.HeaderIncludeOutputFile.empty()) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000267 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000268 if (OutputPath == "-")
269 OutputPath = "";
Daniel Dunbarda608852011-03-21 19:37:38 +0000270 AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath,
271 /*ShowDepth=*/false);
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000272 }
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000273}
Daniel Dunbar5eb81002009-11-13 08:20:47 +0000274
275// ASTContext
276
277void CompilerInstance::createASTContext() {
278 Preprocessor &PP = getPreprocessor();
Ted Kremenek4f327862011-03-21 18:40:17 +0000279 Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000280 &getTarget(), PP.getIdentifierTable(),
Ted Kremenek4f327862011-03-21 18:40:17 +0000281 PP.getSelectorTable(), PP.getBuiltinInfo(),
282 /*size_reserve=*/ 0);
Daniel Dunbar5eb81002009-11-13 08:20:47 +0000283}
Daniel Dunbar0f800392009-11-13 08:21:10 +0000284
285// ExternalASTSource
286
Chris Lattner5f9e2722011-07-23 10:55:15 +0000287void CompilerInstance::createPCHExternalASTSource(StringRef Path,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000288 bool DisablePCHValidation,
Argyrios Kyrtzidisbef35c92012-03-07 01:51:17 +0000289 bool AllowPCHWithCompilerErrors,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000290 void *DeserializationListener){
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000291 OwningPtr<ExternalASTSource> Source;
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +0000292 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
Daniel Dunbar0f800392009-11-13 08:21:10 +0000293 Source.reset(createPCHExternalASTSource(Path, getHeaderSearchOpts().Sysroot,
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000294 DisablePCHValidation,
Argyrios Kyrtzidisbef35c92012-03-07 01:51:17 +0000295 AllowPCHWithCompilerErrors,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000296 getPreprocessor(), getASTContext(),
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +0000297 DeserializationListener,
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000298 Preamble,
299 getFrontendOpts().UseGlobalModuleIndex));
Douglas Gregorf62d43d2011-07-19 16:10:42 +0000300 ModuleManager = static_cast<ASTReader*>(Source.get());
Daniel Dunbar0f800392009-11-13 08:21:10 +0000301 getASTContext().setExternalSource(Source);
302}
303
304ExternalASTSource *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000305CompilerInstance::createPCHExternalASTSource(StringRef Path,
Daniel Dunbar0f800392009-11-13 08:21:10 +0000306 const std::string &Sysroot,
Douglas Gregorfae3b2f2010-07-27 00:27:13 +0000307 bool DisablePCHValidation,
Argyrios Kyrtzidisbef35c92012-03-07 01:51:17 +0000308 bool AllowPCHWithCompilerErrors,
Daniel Dunbar0f800392009-11-13 08:21:10 +0000309 Preprocessor &PP,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000310 ASTContext &Context,
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +0000311 void *DeserializationListener,
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000312 bool Preamble,
313 bool UseGlobalModuleIndex) {
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000314 OwningPtr<ASTReader> Reader;
Douglas Gregorf8a1e512011-09-02 00:26:20 +0000315 Reader.reset(new ASTReader(PP, Context,
Douglas Gregor832d6202011-07-22 16:35:34 +0000316 Sysroot.empty() ? "" : Sysroot.c_str(),
Argyrios Kyrtzidis4182ed62012-10-31 20:59:50 +0000317 DisablePCHValidation,
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000318 AllowPCHWithCompilerErrors,
319 UseGlobalModuleIndex));
Daniel Dunbar0f800392009-11-13 08:21:10 +0000320
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000321 Reader->setDeserializationListener(
Sebastian Redl571db7f2010-08-18 23:56:56 +0000322 static_cast<ASTDeserializationListener *>(DeserializationListener));
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000323 switch (Reader->ReadAST(Path,
324 Preamble ? serialization::MK_Preamble
Douglas Gregor38295be2012-10-22 23:51:00 +0000325 : serialization::MK_PCH,
Argyrios Kyrtzidis958bcaf2012-11-15 18:57:22 +0000326 SourceLocation(),
Douglas Gregor38295be2012-10-22 23:51:00 +0000327 ASTReader::ARR_None)) {
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000328 case ASTReader::Success:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000329 // Set the predefines buffer as suggested by the PCH reader. Typically, the
330 // predefines buffer will be empty.
331 PP.setPredefines(Reader->getSuggestedPredefines());
332 return Reader.take();
333
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000334 case ASTReader::Failure:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000335 // Unrecoverable failure: don't even try to process the input file.
336 break;
337
Douglas Gregor677e15f2013-03-19 00:28:20 +0000338 case ASTReader::Missing:
Douglas Gregor4825fd72012-10-22 22:50:17 +0000339 case ASTReader::OutOfDate:
340 case ASTReader::VersionMismatch:
341 case ASTReader::ConfigurationMismatch:
342 case ASTReader::HadErrors:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000343 // No suitable PCH file could be found. Return an error.
344 break;
345 }
346
347 return 0;
348}
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000349
350// Code Completion
351
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000352static bool EnableCodeCompletion(Preprocessor &PP,
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000353 const std::string &Filename,
354 unsigned Line,
355 unsigned Column) {
356 // Tell the source manager to chop off the given file at a specific
357 // line and column.
Chris Lattner39b49bc2010-11-23 08:35:12 +0000358 const FileEntry *Entry = PP.getFileManager().getFile(Filename);
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000359 if (!Entry) {
360 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
361 << Filename;
362 return true;
363 }
364
365 // Truncate the named file at the given line/column.
366 PP.SetCodeCompletionPoint(Entry, Line, Column);
367 return false;
368}
369
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000370void CompilerInstance::createCodeCompletionConsumer() {
371 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000372 if (!CompletionConsumer) {
Erik Verbruggen9bc0c292012-04-12 10:31:12 +0000373 setCodeCompletionConsumer(
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000374 createCodeCompletionConsumer(getPreprocessor(),
375 Loc.FileName, Loc.Line, Loc.Column,
Dmitri Gribenkod99ef532012-07-02 17:35:10 +0000376 getFrontendOpts().CodeCompleteOpts,
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000377 llvm::outs()));
378 if (!CompletionConsumer)
379 return;
380 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
381 Loc.Line, Loc.Column)) {
Erik Verbruggen9bc0c292012-04-12 10:31:12 +0000382 setCodeCompletionConsumer(0);
Douglas Gregorc3d43b72010-03-16 06:04:47 +0000383 return;
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000384 }
Douglas Gregor2b4074f2009-12-01 05:55:20 +0000385
386 if (CompletionConsumer->isOutputBinary() &&
Rafael Espindolaa6035692013-06-12 20:44:26 +0000387 llvm::sys::ChangeStdoutToBinary()) {
Douglas Gregor2b4074f2009-12-01 05:55:20 +0000388 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
Erik Verbruggen9bc0c292012-04-12 10:31:12 +0000389 setCodeCompletionConsumer(0);
Douglas Gregor2b4074f2009-12-01 05:55:20 +0000390 }
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000391}
392
Kovarththanan Rajaratnamf79bafa2009-11-29 09:57:35 +0000393void CompilerInstance::createFrontendTimer() {
394 FrontendTimer.reset(new llvm::Timer("Clang front-end timer"));
395}
396
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000397CodeCompleteConsumer *
398CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
399 const std::string &Filename,
400 unsigned Line,
401 unsigned Column,
Dmitri Gribenkod99ef532012-07-02 17:35:10 +0000402 const CodeCompleteOptions &Opts,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000403 raw_ostream &OS) {
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000404 if (EnableCodeCompletion(PP, Filename, Line, Column))
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000405 return 0;
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000406
407 // Set up the creation routine for code-completion.
Dmitri Gribenkod99ef532012-07-02 17:35:10 +0000408 return new PrintingCodeCompleteConsumer(Opts, OS);
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000409}
Daniel Dunbara9204832009-11-13 10:37:48 +0000410
Douglas Gregor467dc882011-08-25 22:30:56 +0000411void CompilerInstance::createSema(TranslationUnitKind TUKind,
Douglas Gregorf18d0d82010-08-12 23:31:19 +0000412 CodeCompleteConsumer *CompletionConsumer) {
413 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
Douglas Gregor467dc882011-08-25 22:30:56 +0000414 TUKind, CompletionConsumer));
Douglas Gregorf18d0d82010-08-12 23:31:19 +0000415}
416
Daniel Dunbara9204832009-11-13 10:37:48 +0000417// Output Files
418
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000419void CompilerInstance::addOutputFile(const OutputFile &OutFile) {
420 assert(OutFile.OS && "Attempt to add empty stream to output list!");
421 OutputFiles.push_back(OutFile);
Daniel Dunbara9204832009-11-13 10:37:48 +0000422}
423
Kovarththanan Rajaratname51dd7b2010-03-06 12:07:48 +0000424void CompilerInstance::clearOutputFiles(bool EraseFiles) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000425 for (std::list<OutputFile>::iterator
Daniel Dunbara9204832009-11-13 10:37:48 +0000426 it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000427 delete it->OS;
428 if (!it->TempFilename.empty()) {
Anders Carlssonaf036a62011-03-06 22:25:35 +0000429 if (EraseFiles) {
430 bool existed;
431 llvm::sys::fs::remove(it->TempFilename, existed);
432 } else {
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000433 SmallString<128> NewOutFile(it->Filename);
Anders Carlssonaf036a62011-03-06 22:25:35 +0000434
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +0000435 // If '-working-directory' was passed, the output filename should be
436 // relative to that.
Anders Carlsson2e2468e2011-03-14 01:13:54 +0000437 FileMgr->FixupRelativePath(NewOutFile);
Anders Carlssonaf036a62011-03-06 22:25:35 +0000438 if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename,
439 NewOutFile.str())) {
Manuel Klimek832a2aa2012-05-16 20:55:58 +0000440 getDiagnostics().Report(diag::err_unable_to_rename_temp)
Anders Carlssonaf036a62011-03-06 22:25:35 +0000441 << it->TempFilename << it->Filename << ec.message();
442
443 bool existed;
444 llvm::sys::fs::remove(it->TempFilename, existed);
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000445 }
446 }
447 } else if (!it->Filename.empty() && EraseFiles)
Rafael Espindola48955f82013-06-26 04:32:59 +0000448 llvm::sys::fs::remove(it->Filename);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000449
Daniel Dunbara9204832009-11-13 10:37:48 +0000450 }
451 OutputFiles.clear();
452}
453
Daniel Dunbarf482d592009-11-13 18:32:08 +0000454llvm::raw_fd_ostream *
455CompilerInstance::createDefaultOutputFile(bool Binary,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000456 StringRef InFile,
457 StringRef Extension) {
Daniel Dunbarf482d592009-11-13 18:32:08 +0000458 return createOutputFile(getFrontendOpts().OutputFile, Binary,
Daniel Dunbare21dd282012-03-03 00:36:06 +0000459 /*RemoveFileOnSignal=*/true, InFile, Extension,
460 /*UseTemporary=*/true);
Daniel Dunbarf482d592009-11-13 18:32:08 +0000461}
462
463llvm::raw_fd_ostream *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000464CompilerInstance::createOutputFile(StringRef OutputPath,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000465 bool Binary, bool RemoveFileOnSignal,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000466 StringRef InFile,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000467 StringRef Extension,
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000468 bool UseTemporary,
469 bool CreateMissingDirectories) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000470 std::string Error, OutputPathName, TempPathName;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000471 llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000472 RemoveFileOnSignal,
Daniel Dunbarf482d592009-11-13 18:32:08 +0000473 InFile, Extension,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000474 UseTemporary,
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000475 CreateMissingDirectories,
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000476 &OutputPathName,
477 &TempPathName);
Daniel Dunbarf482d592009-11-13 18:32:08 +0000478 if (!OS) {
Daniel Dunbar36043592009-12-03 09:13:30 +0000479 getDiagnostics().Report(diag::err_fe_unable_to_open_output)
480 << OutputPath << Error;
481 return 0;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000482 }
483
484 // Add the output file -- but don't try to remove "-", since this means we are
485 // using stdin.
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000486 addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "",
487 TempPathName, OS));
Daniel Dunbarf482d592009-11-13 18:32:08 +0000488
489 return OS;
490}
491
492llvm::raw_fd_ostream *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000493CompilerInstance::createOutputFile(StringRef OutputPath,
Daniel Dunbarf482d592009-11-13 18:32:08 +0000494 std::string &Error,
495 bool Binary,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000496 bool RemoveFileOnSignal,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000497 StringRef InFile,
498 StringRef Extension,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000499 bool UseTemporary,
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000500 bool CreateMissingDirectories,
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000501 std::string *ResultPathName,
502 std::string *TempPathName) {
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000503 assert((!CreateMissingDirectories || UseTemporary) &&
504 "CreateMissingDirectories is only allowed when using temporary files");
505
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000506 std::string OutFile, TempFile;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000507 if (!OutputPath.empty()) {
508 OutFile = OutputPath;
509 } else if (InFile == "-") {
510 OutFile = "-";
511 } else if (!Extension.empty()) {
Rafael Espindola48955f82013-06-26 04:32:59 +0000512 SmallString<128> Path(InFile);
513 llvm::sys::path::replace_extension(Path, Extension);
Daniel Dunbarf482d592009-11-13 18:32:08 +0000514 OutFile = Path.str();
515 } else {
516 OutFile = "-";
517 }
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000518
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000519 OwningPtr<llvm::raw_fd_ostream> OS;
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000520 std::string OSFile;
521
Rafael Espindola375a4f52013-06-27 18:26:26 +0000522 if (UseTemporary) {
523 if (OutFile == "-")
524 UseTemporary = false;
525 else {
526 llvm::sys::fs::file_status Status;
527 llvm::sys::fs::status(OutputPath, Status);
528 if (llvm::sys::fs::exists(Status)) {
529 // Fail early if we can't write to the final destination.
530 if (!llvm::sys::fs::can_write(OutputPath))
531 return 0;
532
533 // Don't use a temporary if the output is a special file. This handles
534 // things like '-o /dev/null'
535 if (!llvm::sys::fs::is_regular_file(Status))
536 UseTemporary = false;
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000537 }
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000538 }
539 }
540
Rafael Espindola375a4f52013-06-27 18:26:26 +0000541 if (UseTemporary) {
542 SmallString<256> AbsPath(OutputPath);
543 llvm::sys::fs::make_absolute(AbsPath);
544
545 // If the parent directory doesn't exist and we can't create it, fail.
546 bool ParentExists =
547 llvm::sys::fs::exists(llvm::sys::path::parent_path(AbsPath.str()));
548 if (!CreateMissingDirectories && !ParentExists) {
549 Error = "Parent directory doesn't exist";
550 return 0;
551 }
552
553 // Create a temporary file.
554 SmallString<128> TempPath;
555 TempPath = OutFile;
556 TempPath += "-%%%%%%%%";
557 int fd;
558 if (!llvm::sys::fs::unique_file(TempPath.str(), fd, TempPath,
559 /*makeAbsolute=*/false, 0664)) {
560 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
561 OSFile = TempFile = TempPath.str();
562 }
563 // If we failed to create the temporary, fallback to writing to the file
564 // directly. This handles the corner case where we cannot write to the
565 // directory, but can write to the file.
566 }
567
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000568 if (!OS) {
569 OSFile = OutFile;
570 OS.reset(
571 new llvm::raw_fd_ostream(OSFile.c_str(), Error,
572 (Binary ? llvm::raw_fd_ostream::F_Binary : 0)));
573 if (!Error.empty())
574 return 0;
575 }
Daniel Dunbarf482d592009-11-13 18:32:08 +0000576
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000577 // Make sure the out stream file gets removed if we crash.
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000578 if (RemoveFileOnSignal)
Rafael Espindola6f2e23b2013-06-13 21:02:40 +0000579 llvm::sys::RemoveFileOnSignal(OSFile);
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000580
Daniel Dunbarf482d592009-11-13 18:32:08 +0000581 if (ResultPathName)
582 *ResultPathName = OutFile;
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000583 if (TempPathName)
584 *TempPathName = TempFile;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000585
Daniel Dunbarfc971022009-11-20 22:32:38 +0000586 return OS.take();
Daniel Dunbarf482d592009-11-13 18:32:08 +0000587}
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000588
589// Initialization Utilities
590
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000591bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
592 return InitializeSourceManager(Input, getDiagnostics(),
Douglas Gregora1f1fad2012-01-27 19:52:33 +0000593 getFileManager(), getSourceManager(),
594 getFrontendOpts());
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000595}
596
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000597bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input,
David Blaikied6471f72011-09-25 23:23:43 +0000598 DiagnosticsEngine &Diags,
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000599 FileManager &FileMgr,
600 SourceManager &SourceMgr,
601 const FrontendOptions &Opts) {
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000602 SrcMgr::CharacteristicKind
Argyrios Kyrtzidis8616f9a2012-11-09 19:40:39 +0000603 Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000604
Argyrios Kyrtzidisecd27bf2012-11-09 19:40:45 +0000605 if (Input.isBuffer()) {
606 SourceMgr.createMainFileIDForMemBuffer(Input.getBuffer(), Kind);
607 assert(!SourceMgr.getMainFileID().isInvalid() &&
608 "Couldn't establish MainFileID!");
609 return true;
610 }
611
612 StringRef InputFile = Input.getFile();
613
Argyrios Kyrtzidis507097e2011-09-19 20:40:35 +0000614 // Figure out where to get and map in the main file.
615 if (InputFile != "-") {
Chris Lattner39b49bc2010-11-23 08:35:12 +0000616 const FileEntry *File = FileMgr.getFile(InputFile);
Dan Gohman694137c2010-10-26 21:13:51 +0000617 if (!File) {
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000618 Diags.Report(diag::err_fe_error_reading) << InputFile;
619 return false;
620 }
Daniel Dunbarce36ecd2012-11-05 22:53:33 +0000621
622 // The natural SourceManager infrastructure can't currently handle named
623 // pipes, but we would at least like to accept them for the main
624 // file. Detect them here, read them with the more generic MemoryBuffer
625 // function, and simply override their contents as we do for STDIN.
626 if (File->isNamedPipe()) {
627 OwningPtr<llvm::MemoryBuffer> MB;
628 if (llvm::error_code ec = llvm::MemoryBuffer::getFile(InputFile, MB)) {
629 Diags.Report(diag::err_cannot_open_file) << InputFile << ec.message();
630 return false;
631 }
Daniel Dunbaracf36122012-11-27 00:04:16 +0000632
633 // Create a new virtual file that will have the correct size.
634 File = FileMgr.getVirtualFile(InputFile, MB->getBufferSize(), 0);
Daniel Dunbarce36ecd2012-11-05 22:53:33 +0000635 SourceMgr.overrideFileContents(File, MB.take());
636 }
Daniel Dunbaracf36122012-11-27 00:04:16 +0000637
638 SourceMgr.createMainFileID(File, Kind);
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000639 } else {
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000640 OwningPtr<llvm::MemoryBuffer> SB;
Michael J. Spencer4eeebc42010-12-16 03:28:14 +0000641 if (llvm::MemoryBuffer::getSTDIN(SB)) {
Michael J. Spencer3a321e22010-12-09 17:36:38 +0000642 // FIXME: Give ec.message() in this diag.
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000643 Diags.Report(diag::err_fe_error_reading_stdin);
644 return false;
645 }
Dan Gohman90d90812010-10-26 23:21:25 +0000646 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
Chris Lattner39b49bc2010-11-23 08:35:12 +0000647 SB->getBufferSize(), 0);
Douglas Gregora1f1fad2012-01-27 19:52:33 +0000648 SourceMgr.createMainFileID(File, Kind);
Michael J. Spencer4eeebc42010-12-16 03:28:14 +0000649 SourceMgr.overrideFileContents(File, SB.take());
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000650 }
651
Dan Gohman694137c2010-10-26 21:13:51 +0000652 assert(!SourceMgr.getMainFileID().isInvalid() &&
653 "Couldn't establish MainFileID!");
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000654 return true;
655}
Daniel Dunbar0397af22010-01-13 00:48:06 +0000656
657// High-Level Operations
658
659bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
660 assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
661 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
662 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
663
664 // FIXME: Take this as an argument, once all the APIs we used have moved to
665 // taking it as an input instead of hard-coding llvm::errs.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000666 raw_ostream &OS = llvm::errs();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000667
668 // Create the target instance.
Douglas Gregor49a87542012-11-16 04:24:59 +0000669 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), &getTargetOpts()));
Daniel Dunbar0397af22010-01-13 00:48:06 +0000670 if (!hasTarget())
671 return false;
672
673 // Inform the target of the language options.
674 //
675 // FIXME: We shouldn't need to do this, the target should be immutable once
676 // created. This complexity should be lifted elsewhere.
677 getTarget().setForcedLangOptions(getLangOpts());
678
Fariborz Jahanian93a49942012-04-16 21:03:30 +0000679 // rewriter project will change target built-in bool type from its default.
680 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
681 getTarget().noSignedCharForObjCBool();
682
Daniel Dunbar0397af22010-01-13 00:48:06 +0000683 // Validate/process some options.
684 if (getHeaderSearchOpts().Verbose)
685 OS << "clang -cc1 version " CLANG_VERSION_STRING
686 << " based upon " << PACKAGE_STRING
Sebastian Pop5d8b9542011-11-01 21:33:06 +0000687 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
Daniel Dunbar0397af22010-01-13 00:48:06 +0000688
689 if (getFrontendOpts().ShowTimers)
690 createFrontendTimer();
691
Douglas Gregor95dd5582010-03-30 17:33:59 +0000692 if (getFrontendOpts().ShowStats)
693 llvm::EnableStatistics();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000694
Daniel Dunbar0397af22010-01-13 00:48:06 +0000695 for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) {
Daniel Dunbar20560482010-06-07 23:23:50 +0000696 // Reset the ID tables if we are reusing the SourceManager.
697 if (hasSourceManager())
698 getSourceManager().clearIDTables();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000699
Douglas Gregor1f6b2b52012-01-20 16:28:04 +0000700 if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) {
Daniel Dunbar0397af22010-01-13 00:48:06 +0000701 Act.Execute();
702 Act.EndSourceFile();
703 }
704 }
705
Argyrios Kyrtzidis29f27872011-12-07 05:52:12 +0000706 // Notify the diagnostic client that all files were processed.
707 getDiagnostics().getClient()->finish();
708
Chris Lattner53eee7b2010-04-07 18:47:42 +0000709 if (getDiagnosticOpts().ShowCarets) {
Argyrios Kyrtzidisf2224d82010-11-18 20:06:46 +0000710 // We can have multiple diagnostics sharing one diagnostic client.
711 // Get the total number of warnings/errors from the client.
712 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
713 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000714
Chris Lattner53eee7b2010-04-07 18:47:42 +0000715 if (NumWarnings)
716 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
717 if (NumWarnings && NumErrors)
718 OS << " and ";
719 if (NumErrors)
720 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
721 if (NumWarnings || NumErrors)
722 OS << " generated.\n";
723 }
Daniel Dunbar0397af22010-01-13 00:48:06 +0000724
Daniel Dunbar20560482010-06-07 23:23:50 +0000725 if (getFrontendOpts().ShowStats && hasFileManager()) {
Daniel Dunbar0397af22010-01-13 00:48:06 +0000726 getFileManager().PrintStats();
727 OS << "\n";
728 }
729
Argyrios Kyrtzidisab41b972010-11-18 21:13:57 +0000730 return !getDiagnostics().getClient()->getNumErrors();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000731}
732
Douglas Gregor21cae202011-09-12 23:31:24 +0000733/// \brief Determine the appropriate source input kind based on language
734/// options.
735static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
736 if (LangOpts.OpenCL)
737 return IK_OpenCL;
738 if (LangOpts.CUDA)
739 return IK_CUDA;
740 if (LangOpts.ObjC1)
741 return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
742 return LangOpts.CPlusPlus? IK_CXX : IK_C;
743}
744
Douglas Gregor0ced7992011-10-04 00:21:21 +0000745namespace {
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000746 struct CompileModuleMapData {
747 CompilerInstance &Instance;
748 GenerateModuleAction &CreateModuleAction;
749 };
750}
751
752/// \brief Helper function that executes the module-generating action under
753/// a crash recovery context.
754static void doCompileMapModule(void *UserData) {
755 CompileModuleMapData &Data
756 = *reinterpret_cast<CompileModuleMapData *>(UserData);
757 Data.Instance.ExecuteAction(Data.CreateModuleAction);
758}
759
Douglas Gregor2a060852013-02-07 00:21:12 +0000760namespace {
761 /// \brief Function object that checks with the given macro definition should
762 /// be removed, because it is one of the ignored macros.
763 class RemoveIgnoredMacro {
764 const HeaderSearchOptions &HSOpts;
765
766 public:
767 explicit RemoveIgnoredMacro(const HeaderSearchOptions &HSOpts)
768 : HSOpts(HSOpts) { }
769
770 bool operator()(const std::pair<std::string, bool> &def) const {
Douglas Gregor005d51b2013-02-07 01:18:48 +0000771 StringRef MacroDef = def.first;
772 return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0;
Douglas Gregor2a060852013-02-07 00:21:12 +0000773 }
774 };
775}
776
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000777/// \brief Compile a module file for the given module, using the options
778/// provided by the importing compiler instance.
Douglas Gregor21cae202011-09-12 23:31:24 +0000779static void compileModule(CompilerInstance &ImportingInstance,
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000780 SourceLocation ImportLoc,
Douglas Gregor1a4761e2011-11-30 23:21:26 +0000781 Module *Module,
Douglas Gregor933e7a62011-11-29 18:31:39 +0000782 StringRef ModuleFileName) {
Douglas Gregor52f12722012-01-29 20:15:24 +0000783 llvm::LockFileManager Locked(ModuleFileName);
Douglas Gregor2bc75072011-10-05 14:53:30 +0000784 switch (Locked) {
Douglas Gregor52f12722012-01-29 20:15:24 +0000785 case llvm::LockFileManager::LFS_Error:
Douglas Gregor2bc75072011-10-05 14:53:30 +0000786 return;
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000787
Douglas Gregor52f12722012-01-29 20:15:24 +0000788 case llvm::LockFileManager::LFS_Owned:
Douglas Gregor2bc75072011-10-05 14:53:30 +0000789 // We're responsible for building the module ourselves. Do so below.
790 break;
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000791
Douglas Gregor52f12722012-01-29 20:15:24 +0000792 case llvm::LockFileManager::LFS_Shared:
Douglas Gregor2bc75072011-10-05 14:53:30 +0000793 // Someone else is responsible for building the module. Wait for them to
794 // finish.
795 Locked.waitForUnlock();
Douglas Gregor7cdd2812012-11-07 17:46:15 +0000796 return;
Douglas Gregor2bc75072011-10-05 14:53:30 +0000797 }
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000798
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000799 ModuleMap &ModMap
800 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
801
Douglas Gregor21cae202011-09-12 23:31:24 +0000802 // Construct a compiler invocation for creating this module.
Dylan Noblesmithc93dc782012-02-20 14:00:23 +0000803 IntrusiveRefCntPtr<CompilerInvocation> Invocation
Douglas Gregor21cae202011-09-12 23:31:24 +0000804 (new CompilerInvocation(ImportingInstance.getInvocation()));
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000805
Douglas Gregor18ee5472011-11-29 21:59:16 +0000806 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
807
Douglas Gregorb2d39c22011-09-15 20:53:28 +0000808 // For any options that aren't intended to affect how a module is built,
809 // reset them to their default values.
Ted Kremenekd3b74d92011-11-17 23:01:24 +0000810 Invocation->getLangOpts()->resetNonModularOptions();
Douglas Gregor18ee5472011-11-29 21:59:16 +0000811 PPOpts.resetNonModularOptions();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000812
Douglas Gregor2a060852013-02-07 00:21:12 +0000813 // Remove any macro definitions that are explicitly ignored by the module.
814 // They aren't supposed to affect how the module is built anyway.
815 const HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
816 PPOpts.Macros.erase(std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
817 RemoveIgnoredMacro(HSOpts)),
818 PPOpts.Macros.end());
819
820
Douglas Gregorb86b8dc2011-11-15 19:35:01 +0000821 // Note the name of the module we're building.
Douglas Gregor933e7a62011-11-29 18:31:39 +0000822 Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
Douglas Gregorb86b8dc2011-11-15 19:35:01 +0000823
Douglas Gregor463d9092012-11-29 23:55:25 +0000824 // Make sure that the failed-module structure has been allocated in
825 // the importing instance, and propagate the pointer to the newly-created
826 // instance.
827 PreprocessorOptions &ImportingPPOpts
828 = ImportingInstance.getInvocation().getPreprocessorOpts();
829 if (!ImportingPPOpts.FailedModules)
830 ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet;
831 PPOpts.FailedModules = ImportingPPOpts.FailedModules;
832
Douglas Gregor18ee5472011-11-29 21:59:16 +0000833 // If there is a module map file, build the module using the module map.
Douglas Gregorb2d39c22011-09-15 20:53:28 +0000834 // Set up the inputs/outputs so that we build the module from its umbrella
835 // header.
Douglas Gregor21cae202011-09-12 23:31:24 +0000836 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
Douglas Gregor6e975c42011-09-13 23:15:45 +0000837 FrontendOpts.OutputFile = ModuleFileName.str();
Douglas Gregor21cae202011-09-12 23:31:24 +0000838 FrontendOpts.DisableFree = false;
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000839 FrontendOpts.GenerateGlobalModuleIndex = false;
Douglas Gregor21cae202011-09-12 23:31:24 +0000840 FrontendOpts.Inputs.clear();
Douglas Gregor18ee5472011-11-29 21:59:16 +0000841 InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000842
Douglas Gregor18ee5472011-11-29 21:59:16 +0000843 // Get or create the module map that we'll use to build this module.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000844 SmallString<128> TempModuleMapFileName;
Douglas Gregor18ee5472011-11-29 21:59:16 +0000845 if (const FileEntry *ModuleMapFile
846 = ModMap.getContainingModuleMapFile(Module)) {
847 // Use the module map where this module resides.
Douglas Gregor1f6b2b52012-01-20 16:28:04 +0000848 FrontendOpts.Inputs.push_back(FrontendInputFile(ModuleMapFile->getName(),
849 IK));
Douglas Gregor18ee5472011-11-29 21:59:16 +0000850 } else {
851 // Create a temporary module map file.
852 TempModuleMapFileName = Module->Name;
853 TempModuleMapFileName += "-%%%%%%%%.map";
854 int FD;
855 if (llvm::sys::fs::unique_file(TempModuleMapFileName.str(), FD,
856 TempModuleMapFileName,
Douglas Gregor1e821e92011-12-06 22:05:29 +0000857 /*makeAbsolute=*/true)
Douglas Gregore9120292011-12-06 23:04:08 +0000858 != llvm::errc::success) {
Douglas Gregorf64114b2011-12-07 00:54:14 +0000859 ImportingInstance.getDiagnostics().Report(diag::err_module_map_temp_file)
860 << TempModuleMapFileName;
Douglas Gregor18ee5472011-11-29 21:59:16 +0000861 return;
Douglas Gregore9120292011-12-06 23:04:08 +0000862 }
Douglas Gregor18ee5472011-11-29 21:59:16 +0000863 // Print the module map to this file.
864 llvm::raw_fd_ostream OS(FD, /*shouldClose=*/true);
865 Module->print(OS);
866 FrontendOpts.Inputs.push_back(
Douglas Gregor1f6b2b52012-01-20 16:28:04 +0000867 FrontendInputFile(TempModuleMapFileName.str().str(), IK));
Douglas Gregor18ee5472011-11-29 21:59:16 +0000868 }
869
870 // Don't free the remapped file buffers; they are owned by our caller.
871 PPOpts.RetainRemappedFileBuffers = true;
872
Douglas Gregor78243652011-09-13 01:26:44 +0000873 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
Douglas Gregor76d991e2011-09-13 23:20:27 +0000874 assert(ImportingInstance.getInvocation().getModuleHash() ==
Douglas Gregor18ee5472011-11-29 21:59:16 +0000875 Invocation->getModuleHash() && "Module hash mismatch!");
876
Douglas Gregor21cae202011-09-12 23:31:24 +0000877 // Construct a compiler instance that will be used to actually create the
878 // module.
879 CompilerInstance Instance;
880 Instance.setInvocation(&*Invocation);
Douglas Gregora4a90ca2013-05-03 22:58:43 +0000881
882 Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
883 ImportingInstance.getDiagnosticClient()),
Douglas Gregorcc2b6532013-05-03 23:07:45 +0000884 /*ShouldOwnClient=*/true);
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000885
Douglas Gregor4565e482012-11-30 22:11:57 +0000886 // Note that this module is part of the module build stack, so that we
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000887 // can detect cycles in the module graph.
888 Instance.createFileManager(); // FIXME: Adopt file manager from importer?
889 Instance.createSourceManager(Instance.getFileManager());
890 SourceManager &SourceMgr = Instance.getSourceManager();
Douglas Gregor4565e482012-11-30 22:11:57 +0000891 SourceMgr.setModuleBuildStack(
892 ImportingInstance.getSourceManager().getModuleBuildStack());
893 SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(),
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000894 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
895
896
Douglas Gregor21cae202011-09-12 23:31:24 +0000897 // Construct a module-generating action.
Douglas Gregor8f5d7d12013-06-21 16:28:10 +0000898 GenerateModuleAction CreateModuleAction(Module->IsSystem);
Douglas Gregor18ee5472011-11-29 21:59:16 +0000899
Douglas Gregor0ced7992011-10-04 00:21:21 +0000900 // Execute the action to actually build the module in-place. Use a separate
901 // thread so that we get a stack large enough.
902 const unsigned ThreadStackSize = 8 << 20;
903 llvm::CrashRecoveryContext CRC;
Douglas Gregor18ee5472011-11-29 21:59:16 +0000904 CompileModuleMapData Data = { Instance, CreateModuleAction };
905 CRC.RunSafelyOnThread(&doCompileMapModule, &Data, ThreadStackSize);
Douglas Gregora4a90ca2013-05-03 22:58:43 +0000906
Douglas Gregor18ee5472011-11-29 21:59:16 +0000907
908 // Delete the temporary module map file.
909 // FIXME: Even though we're executing under crash protection, it would still
910 // be nice to do this with RemoveFileOnSignal when we can. However, that
911 // doesn't make sense for all clients, so clean this up manually.
Benjamin Kramera2e94892012-10-14 19:50:53 +0000912 Instance.clearOutputFiles(/*EraseFiles=*/true);
Douglas Gregor18ee5472011-11-29 21:59:16 +0000913 if (!TempModuleMapFileName.empty())
Rafael Espindola48955f82013-06-26 04:32:59 +0000914 llvm::sys::fs::remove(TempModuleMapFileName.str());
Douglas Gregora6b00fc2013-01-23 22:38:11 +0000915
916 // We've rebuilt a module. If we're allowed to generate or update the global
917 // module index, record that fact in the importing compiler instance.
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000918 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
Douglas Gregora6b00fc2013-01-23 22:38:11 +0000919 ImportingInstance.setBuildGlobalModuleIndex(true);
920 }
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000921}
Douglas Gregor21cae202011-09-12 23:31:24 +0000922
Douglas Gregor63a72682013-03-20 00:22:05 +0000923/// \brief Diagnose differences between the current definition of the given
924/// configuration macro and the definition provided on the command line.
925static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
926 Module *Mod, SourceLocation ImportLoc) {
927 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
928 SourceManager &SourceMgr = PP.getSourceManager();
929
930 // If this identifier has never had a macro definition, then it could
931 // not have changed.
932 if (!Id->hadMacroDefinition())
933 return;
934
935 // If this identifier does not currently have a macro definition,
936 // check whether it had one on the command line.
937 if (!Id->hasMacroDefinition()) {
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000938 MacroDirective::DefInfo LatestDef =
939 PP.getMacroDirectiveHistory(Id)->getDefinition();
940 for (MacroDirective::DefInfo Def = LatestDef; Def;
941 Def = Def.getPreviousDefinition()) {
942 FileID FID = SourceMgr.getFileID(Def.getLocation());
Douglas Gregor63a72682013-03-20 00:22:05 +0000943 if (FID.isInvalid())
944 continue;
945
Douglas Gregor63a72682013-03-20 00:22:05 +0000946 // We only care about the predefines buffer.
Douglas Gregor670b2e62013-04-03 03:16:36 +0000947 if (FID != PP.getPredefinesFileID())
Douglas Gregor63a72682013-03-20 00:22:05 +0000948 continue;
949
950 // This macro was defined on the command line, then #undef'd later.
951 // Complain.
952 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
953 << true << ConfigMacro << Mod->getFullModuleName();
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000954 if (LatestDef.isUndefined())
955 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
Douglas Gregor63a72682013-03-20 00:22:05 +0000956 << true;
957 return;
958 }
959
960 // Okay: no definition in the predefines buffer.
961 return;
962 }
963
964 // This identifier has a macro definition. Check whether we had a definition
965 // on the command line.
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000966 MacroDirective::DefInfo LatestDef =
967 PP.getMacroDirectiveHistory(Id)->getDefinition();
968 MacroDirective::DefInfo PredefinedDef;
969 for (MacroDirective::DefInfo Def = LatestDef; Def;
970 Def = Def.getPreviousDefinition()) {
971 FileID FID = SourceMgr.getFileID(Def.getLocation());
Douglas Gregor63a72682013-03-20 00:22:05 +0000972 if (FID.isInvalid())
973 continue;
974
Douglas Gregor63a72682013-03-20 00:22:05 +0000975 // We only care about the predefines buffer.
Douglas Gregor670b2e62013-04-03 03:16:36 +0000976 if (FID != PP.getPredefinesFileID())
Douglas Gregor63a72682013-03-20 00:22:05 +0000977 continue;
978
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000979 PredefinedDef = Def;
Douglas Gregor63a72682013-03-20 00:22:05 +0000980 break;
981 }
982
983 // If there was no definition for this macro in the predefines buffer,
984 // complain.
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000985 if (!PredefinedDef ||
986 (!PredefinedDef.getLocation().isValid() &&
987 PredefinedDef.getUndefLocation().isValid())) {
Douglas Gregor63a72682013-03-20 00:22:05 +0000988 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
989 << false << ConfigMacro << Mod->getFullModuleName();
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000990 PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here)
Douglas Gregor63a72682013-03-20 00:22:05 +0000991 << false;
992 return;
993 }
994
995 // If the current macro definition is the same as the predefined macro
996 // definition, it's okay.
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000997 if (LatestDef.getMacroInfo() == PredefinedDef.getMacroInfo() ||
Argyrios Kyrtzidisbd25ff82013-04-03 17:39:30 +0000998 LatestDef.getMacroInfo()->isIdenticalTo(*PredefinedDef.getMacroInfo(),PP,
999 /*Syntactically=*/true))
Douglas Gregor63a72682013-03-20 00:22:05 +00001000 return;
1001
1002 // The macro definitions differ.
1003 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1004 << false << ConfigMacro << Mod->getFullModuleName();
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +00001005 PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here)
Douglas Gregor63a72682013-03-20 00:22:05 +00001006 << false;
1007}
1008
Douglas Gregord44d2872013-03-25 21:19:16 +00001009/// \brief Write a new timestamp file with the given path.
1010static void writeTimestampFile(StringRef TimestampFile) {
1011 std::string ErrorInfo;
1012 llvm::raw_fd_ostream Out(TimestampFile.str().c_str(), ErrorInfo,
1013 llvm::raw_fd_ostream::F_Binary);
1014}
1015
1016/// \brief Prune the module cache of modules that haven't been accessed in
1017/// a long time.
1018static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1019 struct stat StatBuf;
1020 llvm::SmallString<128> TimestampFile;
1021 TimestampFile = HSOpts.ModuleCachePath;
1022 llvm::sys::path::append(TimestampFile, "modules.timestamp");
1023
1024 // Try to stat() the timestamp file.
1025 if (::stat(TimestampFile.c_str(), &StatBuf)) {
1026 // If the timestamp file wasn't there, create one now.
1027 if (errno == ENOENT) {
1028 writeTimestampFile(TimestampFile);
1029 }
1030 return;
1031 }
1032
1033 // Check whether the time stamp is older than our pruning interval.
1034 // If not, do nothing.
1035 time_t TimeStampModTime = StatBuf.st_mtime;
1036 time_t CurrentTime = time(0);
Benjamin Kramer93ce7d52013-03-29 17:39:43 +00001037 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
Douglas Gregord44d2872013-03-25 21:19:16 +00001038 return;
Douglas Gregord44d2872013-03-25 21:19:16 +00001039
1040 // Write a new timestamp file so that nobody else attempts to prune.
1041 // There is a benign race condition here, if two Clang instances happen to
1042 // notice at the same time that the timestamp is out-of-date.
1043 writeTimestampFile(TimestampFile);
1044
1045 // Walk the entire module cache, looking for unused module files and module
1046 // indices.
1047 llvm::error_code EC;
1048 SmallString<128> ModuleCachePathNative;
1049 llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1050 for (llvm::sys::fs::directory_iterator
1051 Dir(ModuleCachePathNative.str(), EC), DirEnd;
1052 Dir != DirEnd && !EC; Dir.increment(EC)) {
1053 // If we don't have a directory, there's nothing to look into.
1054 bool IsDirectory;
1055 if (llvm::sys::fs::is_directory(Dir->path(), IsDirectory) || !IsDirectory)
1056 continue;
1057
1058 // Walk all of the files within this directory.
1059 bool RemovedAllFiles = true;
1060 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1061 File != FileEnd && !EC; File.increment(EC)) {
1062 // We only care about module and global module index files.
1063 if (llvm::sys::path::extension(File->path()) != ".pcm" &&
1064 llvm::sys::path::filename(File->path()) != "modules.idx") {
1065 RemovedAllFiles = false;
1066 continue;
1067 }
1068
1069 // Look at this file. If we can't stat it, there's nothing interesting
1070 // there.
1071 if (::stat(File->path().c_str(), &StatBuf)) {
1072 RemovedAllFiles = false;
1073 continue;
1074 }
1075
1076 // If the file has been used recently enough, leave it there.
1077 time_t FileAccessTime = StatBuf.st_atime;
Benjamin Kramer93ce7d52013-03-29 17:39:43 +00001078 if (CurrentTime - FileAccessTime <=
1079 time_t(HSOpts.ModuleCachePruneAfter)) {
1080 RemovedAllFiles = false;
Douglas Gregord44d2872013-03-25 21:19:16 +00001081 continue;
1082 }
1083
1084 // Remove the file.
1085 bool Existed;
1086 if (llvm::sys::fs::remove(File->path(), Existed) || !Existed) {
1087 RemovedAllFiles = false;
1088 }
1089 }
1090
1091 // If we removed all of the files in the directory, remove the directory
1092 // itself.
1093 if (RemovedAllFiles) {
1094 bool Existed;
1095 llvm::sys::fs::remove(Dir->path(), Existed);
1096 }
1097 }
1098}
1099
Douglas Gregor463d9092012-11-29 23:55:25 +00001100ModuleLoadResult
1101CompilerInstance::loadModule(SourceLocation ImportLoc,
1102 ModuleIdPath Path,
1103 Module::NameVisibilityKind Visibility,
1104 bool IsInclusionDirective) {
Douglas Gregorb514c792011-11-30 04:26:53 +00001105 // If we've already handled this import, just return the cached result.
1106 // This one-element cache is important to eliminate redundant diagnostics
1107 // when both the preprocessor and parser see the same import declaration.
Douglas Gregor5e356932011-12-01 17:11:21 +00001108 if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) {
1109 // Make the named module visible.
1110 if (LastModuleImportResult)
Argyrios Kyrtzidis5ebcb202013-02-01 16:36:12 +00001111 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
Douglas Gregor906d66a2013-03-20 21:10:35 +00001112 ImportLoc, /*Complain=*/false);
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001113 return LastModuleImportResult;
Douglas Gregor5e356932011-12-01 17:11:21 +00001114 }
Douglas Gregorb514c792011-11-30 04:26:53 +00001115
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001116 // Determine what file we're searching from.
Douglas Gregor3d3589d2011-11-30 00:36:36 +00001117 StringRef ModuleName = Path[0].first->getName();
1118 SourceLocation ModuleNameLoc = Path[0].second;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001119
Douglas Gregor1a4761e2011-11-30 23:21:26 +00001120 clang::Module *Module = 0;
Douglas Gregor3d3589d2011-11-30 00:36:36 +00001121
Douglas Gregor49009ec2011-11-30 04:03:44 +00001122 // If we don't already have information on this module, load the module now.
Douglas Gregor1a4761e2011-11-30 23:21:26 +00001123 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001124 = KnownModules.find(Path[0].first);
Douglas Gregor5e3f9222011-12-08 17:01:29 +00001125 if (Known != KnownModules.end()) {
1126 // Retrieve the cached top-level module.
1127 Module = Known->second;
1128 } else if (ModuleName == getLangOpts().CurrentModule) {
1129 // This is the module we're building.
1130 Module = PP->getHeaderSearchInfo().getModuleMap().findModule(ModuleName);
1131 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1132 } else {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001133 // Search for a module with the given name.
Douglas Gregore434ec72012-01-29 17:08:11 +00001134 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001135 std::string ModuleFileName;
Douglas Gregor8bf778e2013-02-06 22:40:31 +00001136 if (Module) {
Douglas Gregore434ec72012-01-29 17:08:11 +00001137 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module);
Douglas Gregor8bf778e2013-02-06 22:40:31 +00001138 } else
Douglas Gregore434ec72012-01-29 17:08:11 +00001139 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(ModuleName);
Douglas Gregor463d9092012-11-29 23:55:25 +00001140
Douglas Gregor49009ec2011-11-30 04:03:44 +00001141 // If we don't already have an ASTReader, create one now.
1142 if (!ModuleManager) {
1143 if (!hasASTContext())
1144 createASTContext();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +00001145
Douglas Gregord44d2872013-03-25 21:19:16 +00001146 // If we're not recursively building a module, check whether we
1147 // need to prune the module cache.
1148 if (getSourceManager().getModuleBuildStack().empty() &&
1149 getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1150 getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1151 pruneModuleCache(getHeaderSearchOpts());
1152 }
1153
Douglas Gregor49009ec2011-11-30 04:03:44 +00001154 std::string Sysroot = getHeaderSearchOpts().Sysroot;
1155 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1156 ModuleManager = new ASTReader(getPreprocessor(), *Context,
1157 Sysroot.empty() ? "" : Sysroot.c_str(),
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001158 PPOpts.DisablePCHValidation,
1159 /*AllowASTWithCompilerErrors=*/false,
1160 getFrontendOpts().UseGlobalModuleIndex);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001161 if (hasASTConsumer()) {
1162 ModuleManager->setDeserializationListener(
1163 getASTConsumer().GetASTDeserializationListener());
1164 getASTContext().setASTMutationListener(
1165 getASTConsumer().GetASTMutationListener());
1166 }
Dylan Noblesmith6f42b622012-02-05 02:12:40 +00001167 OwningPtr<ExternalASTSource> Source;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001168 Source.reset(ModuleManager);
1169 getASTContext().setExternalSource(Source);
1170 if (hasSema())
1171 ModuleManager->InitializeSema(getSema());
1172 if (hasASTConsumer())
1173 ModuleManager->StartTranslationUnit(&getASTConsumer());
Douglas Gregorde8a9052011-09-14 23:13:09 +00001174 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001175
Douglas Gregor677e15f2013-03-19 00:28:20 +00001176 // Try to load the module file.
1177 unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing;
1178 switch (ModuleManager->ReadAST(ModuleFileName, serialization::MK_Module,
1179 ImportLoc, ARRFlags)) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001180 case ASTReader::Success:
1181 break;
1182
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001183 case ASTReader::OutOfDate: {
Douglas Gregor677e15f2013-03-19 00:28:20 +00001184 // The module file is out-of-date. Remove it, then rebuild it.
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001185 bool Existed;
1186 llvm::sys::fs::remove(ModuleFileName, Existed);
Douglas Gregor677e15f2013-03-19 00:28:20 +00001187 }
1188 // Fall through to build the module again.
1189
1190 case ASTReader::Missing: {
1191 // The module file is (now) missing. Build it.
1192
1193 // If we don't have a module, we don't know how to build the module file.
1194 // Complain and return.
1195 if (!Module) {
1196 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1197 << ModuleName
1198 << SourceRange(ImportLoc, ModuleNameLoc);
1199 ModuleBuildFailed = true;
1200 return ModuleLoadResult();
1201 }
1202
1203 // Check whether there is a cycle in the module graph.
1204 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1205 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1206 for (; Pos != PosEnd; ++Pos) {
1207 if (Pos->first == ModuleName)
1208 break;
1209 }
1210
1211 if (Pos != PosEnd) {
1212 SmallString<256> CyclePath;
1213 for (; Pos != PosEnd; ++Pos) {
1214 CyclePath += Pos->first;
1215 CyclePath += " -> ";
1216 }
1217 CyclePath += ModuleName;
1218
1219 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1220 << ModuleName << CyclePath;
1221 return ModuleLoadResult();
1222 }
Douglas Gregor463d9092012-11-29 23:55:25 +00001223
1224 // Check whether we have already attempted to build this module (but
1225 // failed).
1226 if (getPreprocessorOpts().FailedModules &&
1227 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1228 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1229 << ModuleName
1230 << SourceRange(ImportLoc, ModuleNameLoc);
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001231 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001232 return ModuleLoadResult();
1233 }
1234
Douglas Gregor677e15f2013-03-19 00:28:20 +00001235 // Try to compile the module.
Douglas Gregor830ea5b2012-11-30 18:38:50 +00001236 compileModule(*this, ModuleNameLoc, Module, ModuleFileName);
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001237
Douglas Gregor677e15f2013-03-19 00:28:20 +00001238 // Try to read the module file, now that we've compiled it.
1239 ASTReader::ASTReadResult ReadResult
1240 = ModuleManager->ReadAST(ModuleFileName,
Argyrios Kyrtzidis958bcaf2012-11-15 18:57:22 +00001241 serialization::MK_Module, ImportLoc,
Douglas Gregor677e15f2013-03-19 00:28:20 +00001242 ASTReader::ARR_Missing);
1243 if (ReadResult != ASTReader::Success) {
1244 if (ReadResult == ASTReader::Missing) {
1245 getDiagnostics().Report(ModuleNameLoc,
1246 Module? diag::err_module_not_built
1247 : diag::err_module_not_found)
1248 << ModuleName
1249 << SourceRange(ImportLoc, ModuleNameLoc);
1250 }
1251
Douglas Gregorb8a8be12013-01-10 02:04:18 +00001252 if (getPreprocessorOpts().FailedModules)
1253 getPreprocessorOpts().FailedModules->addFailed(ModuleName);
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001254 KnownModules[Path[0].first] = 0;
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001255 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001256 return ModuleLoadResult();
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001257 }
1258
1259 // Okay, we've rebuilt and now loaded the module.
1260 break;
1261 }
1262
Douglas Gregor4825fd72012-10-22 22:50:17 +00001263 case ASTReader::VersionMismatch:
1264 case ASTReader::ConfigurationMismatch:
1265 case ASTReader::HadErrors:
Argyrios Kyrtzidis3b7deda2013-05-24 05:44:08 +00001266 ModuleLoader::HadFatalFailure = true;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001267 // FIXME: The ASTReader will already have complained, but can we showhorn
1268 // that diagnostic information into a more useful form?
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001269 KnownModules[Path[0].first] = 0;
Douglas Gregor463d9092012-11-29 23:55:25 +00001270 return ModuleLoadResult();
Douglas Gregor49009ec2011-11-30 04:03:44 +00001271
1272 case ASTReader::Failure:
Argyrios Kyrtzidis3b7deda2013-05-24 05:44:08 +00001273 ModuleLoader::HadFatalFailure = true;
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001274 // Already complained, but note now that we failed.
1275 KnownModules[Path[0].first] = 0;
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001276 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001277 return ModuleLoadResult();
Douglas Gregor49009ec2011-11-30 04:03:44 +00001278 }
1279
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001280 if (!Module) {
1281 // If we loaded the module directly, without finding a module map first,
1282 // we'll have loaded the module's information from the module itself.
1283 Module = PP->getHeaderSearchInfo().getModuleMap()
1284 .findModule((Path[0].first->getName()));
1285 }
Argyrios Kyrtzidise2ac16b2012-09-29 01:06:04 +00001286
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001287 // Cache the result of this top-level module lookup for later.
1288 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001289 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001290
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001291 // If we never found the module, fail.
1292 if (!Module)
Douglas Gregor463d9092012-11-29 23:55:25 +00001293 return ModuleLoadResult();
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001294
Douglas Gregor49009ec2011-11-30 04:03:44 +00001295 // Verify that the rest of the module path actually corresponds to
1296 // a submodule.
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001297 if (Path.size() > 1) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001298 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1299 StringRef Name = Path[I].first->getName();
Douglas Gregorb7a78192012-01-04 23:32:19 +00001300 clang::Module *Sub = Module->findSubmodule(Name);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001301
Douglas Gregorb7a78192012-01-04 23:32:19 +00001302 if (!Sub) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001303 // Attempt to perform typo correction to find a module name that works.
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00001304 SmallVector<StringRef, 2> Best;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001305 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1306
Douglas Gregorb7a78192012-01-04 23:32:19 +00001307 for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1308 JEnd = Module->submodule_end();
Matt Beaumont-Gaye25633f2011-11-30 19:41:21 +00001309 J != JEnd; ++J) {
Douglas Gregorb7a78192012-01-04 23:32:19 +00001310 unsigned ED = Name.edit_distance((*J)->Name,
Douglas Gregor49009ec2011-11-30 04:03:44 +00001311 /*AllowReplacements=*/true,
1312 BestEditDistance);
1313 if (ED <= BestEditDistance) {
Douglas Gregorb7a78192012-01-04 23:32:19 +00001314 if (ED < BestEditDistance) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001315 Best.clear();
Douglas Gregorb7a78192012-01-04 23:32:19 +00001316 BestEditDistance = ED;
1317 }
1318
1319 Best.push_back((*J)->Name);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001320 }
1321 }
1322
1323 // If there was a clear winner, user it.
1324 if (Best.size() == 1) {
1325 getDiagnostics().Report(Path[I].second,
1326 diag::err_no_submodule_suggest)
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001327 << Path[I].first << Module->getFullModuleName() << Best[0]
Douglas Gregor49009ec2011-11-30 04:03:44 +00001328 << SourceRange(Path[0].second, Path[I-1].second)
1329 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1330 Best[0]);
Douglas Gregorb7a78192012-01-04 23:32:19 +00001331
1332 Sub = Module->findSubmodule(Best[0]);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001333 }
1334 }
1335
Douglas Gregorb7a78192012-01-04 23:32:19 +00001336 if (!Sub) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001337 // No submodule by this name. Complain, and don't look for further
1338 // submodules.
1339 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001340 << Path[I].first << Module->getFullModuleName()
Douglas Gregor49009ec2011-11-30 04:03:44 +00001341 << SourceRange(Path[0].second, Path[I-1].second);
1342 break;
1343 }
1344
Douglas Gregorb7a78192012-01-04 23:32:19 +00001345 Module = Sub;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001346 }
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001347 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001348
Douglas Gregor5e3f9222011-12-08 17:01:29 +00001349 // Make the named module visible, if it's not already part of the module
1350 // we are parsing.
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001351 if (ModuleName != getLangOpts().CurrentModule) {
1352 if (!Module->IsFromModuleFile) {
1353 // We have an umbrella header or directory that doesn't actually include
1354 // all of the headers within the directory it covers. Complain about
1355 // this missing submodule and recover by forgetting that we ever saw
1356 // this submodule.
1357 // FIXME: Should we detect this at module load time? It seems fairly
1358 // expensive (and rare).
1359 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1360 << Module->getFullModuleName()
1361 << SourceRange(Path.front().second, Path.back().second);
1362
Douglas Gregor463d9092012-11-29 23:55:25 +00001363 return ModuleLoadResult(0, true);
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001364 }
Douglas Gregor51f564f2011-12-31 04:05:44 +00001365
1366 // Check whether this module is available.
1367 StringRef Feature;
Douglas Gregordc58aa72012-01-30 06:01:29 +00001368 if (!Module->isAvailable(getLangOpts(), getTarget(), Feature)) {
Douglas Gregor51f564f2011-12-31 04:05:44 +00001369 getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
1370 << Module->getFullModuleName()
1371 << Feature
1372 << SourceRange(Path.front().second, Path.back().second);
1373 LastModuleImportLoc = ImportLoc;
Douglas Gregor463d9092012-11-29 23:55:25 +00001374 LastModuleImportResult = ModuleLoadResult();
1375 return ModuleLoadResult();
Douglas Gregor51f564f2011-12-31 04:05:44 +00001376 }
1377
Douglas Gregor906d66a2013-03-20 21:10:35 +00001378 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc,
1379 /*Complain=*/true);
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001380 }
Douglas Gregor63a72682013-03-20 00:22:05 +00001381
1382 // Check for any configuration macros that have changed.
1383 clang::Module *TopModule = Module->getTopLevelModule();
1384 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1385 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1386 Module, ImportLoc);
1387 }
1388
Douglas Gregor93ebfa62011-12-02 23:42:12 +00001389 // If this module import was due to an inclusion directive, create an
1390 // implicit import declaration to capture it in the AST.
1391 if (IsInclusionDirective && hasASTContext()) {
1392 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
Argyrios Kyrtzidisd3d98162012-10-03 01:58:37 +00001393 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
1394 ImportLoc, Module,
1395 Path.back().second);
1396 TU->addDecl(ImportD);
1397 if (Consumer)
1398 Consumer->HandleImplicitImportDecl(ImportD);
Douglas Gregor93ebfa62011-12-02 23:42:12 +00001399 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001400
Douglas Gregorb514c792011-11-30 04:26:53 +00001401 LastModuleImportLoc = ImportLoc;
Douglas Gregor463d9092012-11-29 23:55:25 +00001402 LastModuleImportResult = ModuleLoadResult(Module, false);
1403 return LastModuleImportResult;
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001404}
Douglas Gregorca2ab452013-01-12 01:29:50 +00001405
1406void CompilerInstance::makeModuleVisible(Module *Mod,
Argyrios Kyrtzidis5ebcb202013-02-01 16:36:12 +00001407 Module::NameVisibilityKind Visibility,
Douglas Gregor906d66a2013-03-20 21:10:35 +00001408 SourceLocation ImportLoc,
1409 bool Complain){
1410 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc, Complain);
Douglas Gregorca2ab452013-01-12 01:29:50 +00001411}
1412