blob: d2e93685062890ed1d9c85b83644f055711d7a4e [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(
Rafael Espindolad965f952013-07-16 19:44:23 +0000114 new llvm::raw_fd_ostream(DiagOpts->DiagnosticLogFile.c_str(), ErrorInfo,
115 llvm::sys::fs::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,
Rafael Espindolad965f952013-07-16 19:44:23 +0000141 llvm::sys::fs::F_Binary));
142
Ted Kremenek78002122011-10-29 00:12:39 +0000143 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
Hans Wennborg708002e2013-08-09 00:32:23 +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 }
Hans Wennborg708002e2013-08-09 00:32:23 +0000273
274 if (DepOpts.PrintShowIncludes) {
275 AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/false, /*OutputPath=*/"",
276 /*ShowDepth=*/true, /*MSStyle=*/true);
277 }
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000278}
Daniel Dunbar5eb81002009-11-13 08:20:47 +0000279
280// ASTContext
281
282void CompilerInstance::createASTContext() {
283 Preprocessor &PP = getPreprocessor();
Ted Kremenek4f327862011-03-21 18:40:17 +0000284 Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000285 &getTarget(), PP.getIdentifierTable(),
Ted Kremenek4f327862011-03-21 18:40:17 +0000286 PP.getSelectorTable(), PP.getBuiltinInfo(),
287 /*size_reserve=*/ 0);
Daniel Dunbar5eb81002009-11-13 08:20:47 +0000288}
Daniel Dunbar0f800392009-11-13 08:21:10 +0000289
290// ExternalASTSource
291
Chris Lattner5f9e2722011-07-23 10:55:15 +0000292void CompilerInstance::createPCHExternalASTSource(StringRef Path,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000293 bool DisablePCHValidation,
Argyrios Kyrtzidisbef35c92012-03-07 01:51:17 +0000294 bool AllowPCHWithCompilerErrors,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000295 void *DeserializationListener){
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000296 OwningPtr<ExternalASTSource> Source;
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +0000297 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
Daniel Dunbar0f800392009-11-13 08:21:10 +0000298 Source.reset(createPCHExternalASTSource(Path, getHeaderSearchOpts().Sysroot,
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000299 DisablePCHValidation,
Argyrios Kyrtzidisbef35c92012-03-07 01:51:17 +0000300 AllowPCHWithCompilerErrors,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000301 getPreprocessor(), getASTContext(),
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +0000302 DeserializationListener,
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000303 Preamble,
304 getFrontendOpts().UseGlobalModuleIndex));
Douglas Gregorf62d43d2011-07-19 16:10:42 +0000305 ModuleManager = static_cast<ASTReader*>(Source.get());
Daniel Dunbar0f800392009-11-13 08:21:10 +0000306 getASTContext().setExternalSource(Source);
307}
308
309ExternalASTSource *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000310CompilerInstance::createPCHExternalASTSource(StringRef Path,
Daniel Dunbar0f800392009-11-13 08:21:10 +0000311 const std::string &Sysroot,
Douglas Gregorfae3b2f2010-07-27 00:27:13 +0000312 bool DisablePCHValidation,
Argyrios Kyrtzidisbef35c92012-03-07 01:51:17 +0000313 bool AllowPCHWithCompilerErrors,
Daniel Dunbar0f800392009-11-13 08:21:10 +0000314 Preprocessor &PP,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000315 ASTContext &Context,
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +0000316 void *DeserializationListener,
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000317 bool Preamble,
318 bool UseGlobalModuleIndex) {
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000319 OwningPtr<ASTReader> Reader;
Douglas Gregorf8a1e512011-09-02 00:26:20 +0000320 Reader.reset(new ASTReader(PP, Context,
Douglas Gregor832d6202011-07-22 16:35:34 +0000321 Sysroot.empty() ? "" : Sysroot.c_str(),
Argyrios Kyrtzidis4182ed62012-10-31 20:59:50 +0000322 DisablePCHValidation,
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000323 AllowPCHWithCompilerErrors,
324 UseGlobalModuleIndex));
Daniel Dunbar0f800392009-11-13 08:21:10 +0000325
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000326 Reader->setDeserializationListener(
Sebastian Redl571db7f2010-08-18 23:56:56 +0000327 static_cast<ASTDeserializationListener *>(DeserializationListener));
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000328 switch (Reader->ReadAST(Path,
329 Preamble ? serialization::MK_Preamble
Douglas Gregor38295be2012-10-22 23:51:00 +0000330 : serialization::MK_PCH,
Argyrios Kyrtzidis958bcaf2012-11-15 18:57:22 +0000331 SourceLocation(),
Douglas Gregor38295be2012-10-22 23:51:00 +0000332 ASTReader::ARR_None)) {
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000333 case ASTReader::Success:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000334 // 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();
338
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000339 case ASTReader::Failure:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000340 // Unrecoverable failure: don't even try to process the input file.
341 break;
342
Douglas Gregor677e15f2013-03-19 00:28:20 +0000343 case ASTReader::Missing:
Douglas Gregor4825fd72012-10-22 22:50:17 +0000344 case ASTReader::OutOfDate:
345 case ASTReader::VersionMismatch:
346 case ASTReader::ConfigurationMismatch:
347 case ASTReader::HadErrors:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000348 // No suitable PCH file could be found. Return an error.
349 break;
350 }
351
352 return 0;
353}
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000354
355// Code Completion
356
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000357static bool EnableCodeCompletion(Preprocessor &PP,
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000358 const std::string &Filename,
359 unsigned Line,
360 unsigned Column) {
361 // Tell the source manager to chop off the given file at a specific
362 // line and column.
Chris Lattner39b49bc2010-11-23 08:35:12 +0000363 const FileEntry *Entry = PP.getFileManager().getFile(Filename);
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000364 if (!Entry) {
365 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
366 << Filename;
367 return true;
368 }
369
370 // Truncate the named file at the given line/column.
371 PP.SetCodeCompletionPoint(Entry, Line, Column);
372 return false;
373}
374
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000375void CompilerInstance::createCodeCompletionConsumer() {
376 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000377 if (!CompletionConsumer) {
Erik Verbruggen9bc0c292012-04-12 10:31:12 +0000378 setCodeCompletionConsumer(
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000379 createCodeCompletionConsumer(getPreprocessor(),
380 Loc.FileName, Loc.Line, Loc.Column,
Dmitri Gribenkod99ef532012-07-02 17:35:10 +0000381 getFrontendOpts().CodeCompleteOpts,
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000382 llvm::outs()));
383 if (!CompletionConsumer)
384 return;
385 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
386 Loc.Line, Loc.Column)) {
Erik Verbruggen9bc0c292012-04-12 10:31:12 +0000387 setCodeCompletionConsumer(0);
Douglas Gregorc3d43b72010-03-16 06:04:47 +0000388 return;
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000389 }
Douglas Gregor2b4074f2009-12-01 05:55:20 +0000390
391 if (CompletionConsumer->isOutputBinary() &&
Rafael Espindolaa6035692013-06-12 20:44:26 +0000392 llvm::sys::ChangeStdoutToBinary()) {
Douglas Gregor2b4074f2009-12-01 05:55:20 +0000393 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
Erik Verbruggen9bc0c292012-04-12 10:31:12 +0000394 setCodeCompletionConsumer(0);
Douglas Gregor2b4074f2009-12-01 05:55:20 +0000395 }
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000396}
397
Kovarththanan Rajaratnamf79bafa2009-11-29 09:57:35 +0000398void CompilerInstance::createFrontendTimer() {
399 FrontendTimer.reset(new llvm::Timer("Clang front-end timer"));
400}
401
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000402CodeCompleteConsumer *
403CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
404 const std::string &Filename,
405 unsigned Line,
406 unsigned Column,
Dmitri Gribenkod99ef532012-07-02 17:35:10 +0000407 const CodeCompleteOptions &Opts,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000408 raw_ostream &OS) {
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000409 if (EnableCodeCompletion(PP, Filename, Line, Column))
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000410 return 0;
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000411
412 // Set up the creation routine for code-completion.
Dmitri Gribenkod99ef532012-07-02 17:35:10 +0000413 return new PrintingCodeCompleteConsumer(Opts, OS);
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000414}
Daniel Dunbara9204832009-11-13 10:37:48 +0000415
Douglas Gregor467dc882011-08-25 22:30:56 +0000416void CompilerInstance::createSema(TranslationUnitKind TUKind,
Douglas Gregorf18d0d82010-08-12 23:31:19 +0000417 CodeCompleteConsumer *CompletionConsumer) {
418 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
Douglas Gregor467dc882011-08-25 22:30:56 +0000419 TUKind, CompletionConsumer));
Douglas Gregorf18d0d82010-08-12 23:31:19 +0000420}
421
Daniel Dunbara9204832009-11-13 10:37:48 +0000422// Output Files
423
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000424void CompilerInstance::addOutputFile(const OutputFile &OutFile) {
425 assert(OutFile.OS && "Attempt to add empty stream to output list!");
426 OutputFiles.push_back(OutFile);
Daniel Dunbara9204832009-11-13 10:37:48 +0000427}
428
Kovarththanan Rajaratname51dd7b2010-03-06 12:07:48 +0000429void CompilerInstance::clearOutputFiles(bool EraseFiles) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000430 for (std::list<OutputFile>::iterator
Daniel Dunbara9204832009-11-13 10:37:48 +0000431 it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000432 delete it->OS;
433 if (!it->TempFilename.empty()) {
Anders Carlssonaf036a62011-03-06 22:25:35 +0000434 if (EraseFiles) {
435 bool existed;
436 llvm::sys::fs::remove(it->TempFilename, existed);
437 } else {
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000438 SmallString<128> NewOutFile(it->Filename);
Anders Carlssonaf036a62011-03-06 22:25:35 +0000439
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +0000440 // If '-working-directory' was passed, the output filename should be
441 // relative to that.
Anders Carlsson2e2468e2011-03-14 01:13:54 +0000442 FileMgr->FixupRelativePath(NewOutFile);
Anders Carlssonaf036a62011-03-06 22:25:35 +0000443 if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename,
444 NewOutFile.str())) {
Manuel Klimek832a2aa2012-05-16 20:55:58 +0000445 getDiagnostics().Report(diag::err_unable_to_rename_temp)
Anders Carlssonaf036a62011-03-06 22:25:35 +0000446 << it->TempFilename << it->Filename << ec.message();
447
448 bool existed;
449 llvm::sys::fs::remove(it->TempFilename, existed);
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000450 }
451 }
452 } else if (!it->Filename.empty() && EraseFiles)
Rafael Espindola48955f82013-06-26 04:32:59 +0000453 llvm::sys::fs::remove(it->Filename);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000454
Daniel Dunbara9204832009-11-13 10:37:48 +0000455 }
456 OutputFiles.clear();
457}
458
Daniel Dunbarf482d592009-11-13 18:32:08 +0000459llvm::raw_fd_ostream *
460CompilerInstance::createDefaultOutputFile(bool Binary,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000461 StringRef InFile,
462 StringRef Extension) {
Daniel Dunbarf482d592009-11-13 18:32:08 +0000463 return createOutputFile(getFrontendOpts().OutputFile, Binary,
Daniel Dunbare21dd282012-03-03 00:36:06 +0000464 /*RemoveFileOnSignal=*/true, InFile, Extension,
465 /*UseTemporary=*/true);
Daniel Dunbarf482d592009-11-13 18:32:08 +0000466}
467
468llvm::raw_fd_ostream *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000469CompilerInstance::createOutputFile(StringRef OutputPath,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000470 bool Binary, bool RemoveFileOnSignal,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000471 StringRef InFile,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000472 StringRef Extension,
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000473 bool UseTemporary,
474 bool CreateMissingDirectories) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000475 std::string Error, OutputPathName, TempPathName;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000476 llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000477 RemoveFileOnSignal,
Daniel Dunbarf482d592009-11-13 18:32:08 +0000478 InFile, Extension,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000479 UseTemporary,
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000480 CreateMissingDirectories,
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000481 &OutputPathName,
482 &TempPathName);
Daniel Dunbarf482d592009-11-13 18:32:08 +0000483 if (!OS) {
Daniel Dunbar36043592009-12-03 09:13:30 +0000484 getDiagnostics().Report(diag::err_fe_unable_to_open_output)
485 << OutputPath << Error;
486 return 0;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000487 }
488
489 // Add the output file -- but don't try to remove "-", since this means we are
490 // using stdin.
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000491 addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "",
492 TempPathName, OS));
Daniel Dunbarf482d592009-11-13 18:32:08 +0000493
494 return OS;
495}
496
497llvm::raw_fd_ostream *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000498CompilerInstance::createOutputFile(StringRef OutputPath,
Daniel Dunbarf482d592009-11-13 18:32:08 +0000499 std::string &Error,
500 bool Binary,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000501 bool RemoveFileOnSignal,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000502 StringRef InFile,
503 StringRef Extension,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000504 bool UseTemporary,
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000505 bool CreateMissingDirectories,
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000506 std::string *ResultPathName,
507 std::string *TempPathName) {
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000508 assert((!CreateMissingDirectories || UseTemporary) &&
509 "CreateMissingDirectories is only allowed when using temporary files");
510
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000511 std::string OutFile, TempFile;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000512 if (!OutputPath.empty()) {
513 OutFile = OutputPath;
514 } else if (InFile == "-") {
515 OutFile = "-";
516 } else if (!Extension.empty()) {
Rafael Espindola48955f82013-06-26 04:32:59 +0000517 SmallString<128> Path(InFile);
518 llvm::sys::path::replace_extension(Path, Extension);
Daniel Dunbarf482d592009-11-13 18:32:08 +0000519 OutFile = Path.str();
520 } else {
521 OutFile = "-";
522 }
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000523
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000524 OwningPtr<llvm::raw_fd_ostream> OS;
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000525 std::string OSFile;
526
Rafael Espindola375a4f52013-06-27 18:26:26 +0000527 if (UseTemporary) {
528 if (OutFile == "-")
529 UseTemporary = false;
530 else {
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))
536 return 0;
537
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;
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000542 }
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000543 }
544 }
545
Rafael Espindola375a4f52013-06-27 18:26:26 +0000546 if (UseTemporary) {
Rafael Espindola375a4f52013-06-27 18:26:26 +0000547 // Create a temporary file.
548 SmallString<128> TempPath;
549 TempPath = OutFile;
550 TempPath += "-%%%%%%%%";
551 int fd;
Rafael Espindola70e7aec2013-07-05 21:13:58 +0000552 llvm::error_code EC =
553 llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath);
Rafael Espindola8ffd0a42013-06-28 03:49:04 +0000554
555 if (CreateMissingDirectories &&
Rafael Espindolaabab1832013-07-05 14:15:24 +0000556 EC == llvm::errc::no_such_file_or_directory) {
Rafael Espindola8ffd0a42013-06-28 03:49:04 +0000557 StringRef Parent = llvm::sys::path::parent_path(OutputPath);
558 EC = llvm::sys::fs::create_directories(Parent);
559 if (!EC) {
Rafael Espindola70e7aec2013-07-05 21:13:58 +0000560 EC = llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath);
Rafael Espindola8ffd0a42013-06-28 03:49:04 +0000561 }
562 }
563
564 if (!EC) {
Rafael Espindola375a4f52013-06-27 18:26:26 +0000565 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
566 OSFile = TempFile = TempPath.str();
567 }
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.
571 }
572
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000573 if (!OS) {
574 OSFile = OutFile;
Rafael Espindolad965f952013-07-16 19:44:23 +0000575 OS.reset(new llvm::raw_fd_ostream(
576 OSFile.c_str(), Error,
577 (Binary ? llvm::sys::fs::F_Binary : llvm::sys::fs::F_None)));
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000578 if (!Error.empty())
579 return 0;
580 }
Daniel Dunbarf482d592009-11-13 18:32:08 +0000581
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000582 // Make sure the out stream file gets removed if we crash.
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000583 if (RemoveFileOnSignal)
Rafael Espindola6f2e23b2013-06-13 21:02:40 +0000584 llvm::sys::RemoveFileOnSignal(OSFile);
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000585
Daniel Dunbarf482d592009-11-13 18:32:08 +0000586 if (ResultPathName)
587 *ResultPathName = OutFile;
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000588 if (TempPathName)
589 *TempPathName = TempFile;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000590
Daniel Dunbarfc971022009-11-20 22:32:38 +0000591 return OS.take();
Daniel Dunbarf482d592009-11-13 18:32:08 +0000592}
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000593
594// Initialization Utilities
595
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000596bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
597 return InitializeSourceManager(Input, getDiagnostics(),
Douglas Gregora1f1fad2012-01-27 19:52:33 +0000598 getFileManager(), getSourceManager(),
599 getFrontendOpts());
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000600}
601
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000602bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input,
David Blaikied6471f72011-09-25 23:23:43 +0000603 DiagnosticsEngine &Diags,
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000604 FileManager &FileMgr,
605 SourceManager &SourceMgr,
606 const FrontendOptions &Opts) {
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000607 SrcMgr::CharacteristicKind
Argyrios Kyrtzidis8616f9a2012-11-09 19:40:39 +0000608 Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000609
Argyrios Kyrtzidisecd27bf2012-11-09 19:40:45 +0000610 if (Input.isBuffer()) {
611 SourceMgr.createMainFileIDForMemBuffer(Input.getBuffer(), Kind);
612 assert(!SourceMgr.getMainFileID().isInvalid() &&
613 "Couldn't establish MainFileID!");
614 return true;
615 }
616
617 StringRef InputFile = Input.getFile();
618
Argyrios Kyrtzidis507097e2011-09-19 20:40:35 +0000619 // Figure out where to get and map in the main file.
620 if (InputFile != "-") {
Chris Lattner39b49bc2010-11-23 08:35:12 +0000621 const FileEntry *File = FileMgr.getFile(InputFile);
Dan Gohman694137c2010-10-26 21:13:51 +0000622 if (!File) {
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000623 Diags.Report(diag::err_fe_error_reading) << InputFile;
624 return false;
625 }
Daniel Dunbarce36ecd2012-11-05 22:53:33 +0000626
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 more generic MemoryBuffer
630 // function, and simply override their contents as we do for STDIN.
631 if (File->isNamedPipe()) {
632 OwningPtr<llvm::MemoryBuffer> MB;
633 if (llvm::error_code ec = llvm::MemoryBuffer::getFile(InputFile, MB)) {
634 Diags.Report(diag::err_cannot_open_file) << InputFile << ec.message();
635 return false;
636 }
Daniel Dunbaracf36122012-11-27 00:04:16 +0000637
638 // Create a new virtual file that will have the correct size.
639 File = FileMgr.getVirtualFile(InputFile, MB->getBufferSize(), 0);
Daniel Dunbarce36ecd2012-11-05 22:53:33 +0000640 SourceMgr.overrideFileContents(File, MB.take());
641 }
Daniel Dunbaracf36122012-11-27 00:04:16 +0000642
643 SourceMgr.createMainFileID(File, Kind);
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000644 } else {
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000645 OwningPtr<llvm::MemoryBuffer> SB;
Michael J. Spencer4eeebc42010-12-16 03:28:14 +0000646 if (llvm::MemoryBuffer::getSTDIN(SB)) {
Michael J. Spencer3a321e22010-12-09 17:36:38 +0000647 // FIXME: Give ec.message() in this diag.
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000648 Diags.Report(diag::err_fe_error_reading_stdin);
649 return false;
650 }
Dan Gohman90d90812010-10-26 23:21:25 +0000651 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
Chris Lattner39b49bc2010-11-23 08:35:12 +0000652 SB->getBufferSize(), 0);
Douglas Gregora1f1fad2012-01-27 19:52:33 +0000653 SourceMgr.createMainFileID(File, Kind);
Michael J. Spencer4eeebc42010-12-16 03:28:14 +0000654 SourceMgr.overrideFileContents(File, SB.take());
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000655 }
656
Dan Gohman694137c2010-10-26 21:13:51 +0000657 assert(!SourceMgr.getMainFileID().isInvalid() &&
658 "Couldn't establish MainFileID!");
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000659 return true;
660}
Daniel Dunbar0397af22010-01-13 00:48:06 +0000661
662// High-Level Operations
663
664bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
665 assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
666 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
667 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
668
669 // FIXME: Take this as an argument, once all the APIs we used have moved to
670 // taking it as an input instead of hard-coding llvm::errs.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000671 raw_ostream &OS = llvm::errs();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000672
673 // Create the target instance.
Douglas Gregor49a87542012-11-16 04:24:59 +0000674 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), &getTargetOpts()));
Daniel Dunbar0397af22010-01-13 00:48:06 +0000675 if (!hasTarget())
676 return false;
677
678 // Inform the target of the language options.
679 //
680 // FIXME: We shouldn't need to do this, the target should be immutable once
681 // created. This complexity should be lifted elsewhere.
682 getTarget().setForcedLangOptions(getLangOpts());
683
Fariborz Jahanian93a49942012-04-16 21:03:30 +0000684 // rewriter project will change target built-in bool type from its default.
685 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
686 getTarget().noSignedCharForObjCBool();
687
Daniel Dunbar0397af22010-01-13 00:48:06 +0000688 // Validate/process some options.
689 if (getHeaderSearchOpts().Verbose)
690 OS << "clang -cc1 version " CLANG_VERSION_STRING
691 << " based upon " << PACKAGE_STRING
Sebastian Pop5d8b9542011-11-01 21:33:06 +0000692 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
Daniel Dunbar0397af22010-01-13 00:48:06 +0000693
694 if (getFrontendOpts().ShowTimers)
695 createFrontendTimer();
696
Douglas Gregor95dd5582010-03-30 17:33:59 +0000697 if (getFrontendOpts().ShowStats)
698 llvm::EnableStatistics();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000699
Daniel Dunbar0397af22010-01-13 00:48:06 +0000700 for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) {
Daniel Dunbar20560482010-06-07 23:23:50 +0000701 // Reset the ID tables if we are reusing the SourceManager.
702 if (hasSourceManager())
703 getSourceManager().clearIDTables();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000704
Douglas Gregor1f6b2b52012-01-20 16:28:04 +0000705 if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) {
Daniel Dunbar0397af22010-01-13 00:48:06 +0000706 Act.Execute();
707 Act.EndSourceFile();
708 }
709 }
710
Argyrios Kyrtzidis29f27872011-12-07 05:52:12 +0000711 // Notify the diagnostic client that all files were processed.
712 getDiagnostics().getClient()->finish();
713
Chris Lattner53eee7b2010-04-07 18:47:42 +0000714 if (getDiagnosticOpts().ShowCarets) {
Argyrios Kyrtzidisf2224d82010-11-18 20:06:46 +0000715 // We can have multiple diagnostics sharing one diagnostic client.
716 // Get the total number of warnings/errors from the client.
717 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
718 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000719
Chris Lattner53eee7b2010-04-07 18:47:42 +0000720 if (NumWarnings)
721 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
722 if (NumWarnings && NumErrors)
723 OS << " and ";
724 if (NumErrors)
725 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
726 if (NumWarnings || NumErrors)
727 OS << " generated.\n";
728 }
Daniel Dunbar0397af22010-01-13 00:48:06 +0000729
Daniel Dunbar20560482010-06-07 23:23:50 +0000730 if (getFrontendOpts().ShowStats && hasFileManager()) {
Daniel Dunbar0397af22010-01-13 00:48:06 +0000731 getFileManager().PrintStats();
732 OS << "\n";
733 }
734
Argyrios Kyrtzidisab41b972010-11-18 21:13:57 +0000735 return !getDiagnostics().getClient()->getNumErrors();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000736}
737
Douglas Gregor21cae202011-09-12 23:31:24 +0000738/// \brief Determine the appropriate source input kind based on language
739/// options.
740static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
741 if (LangOpts.OpenCL)
742 return IK_OpenCL;
743 if (LangOpts.CUDA)
744 return IK_CUDA;
745 if (LangOpts.ObjC1)
746 return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
747 return LangOpts.CPlusPlus? IK_CXX : IK_C;
748}
749
Douglas Gregor0ced7992011-10-04 00:21:21 +0000750namespace {
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000751 struct CompileModuleMapData {
752 CompilerInstance &Instance;
753 GenerateModuleAction &CreateModuleAction;
754 };
755}
756
757/// \brief Helper function that executes the module-generating action under
758/// a crash recovery context.
759static void doCompileMapModule(void *UserData) {
760 CompileModuleMapData &Data
761 = *reinterpret_cast<CompileModuleMapData *>(UserData);
762 Data.Instance.ExecuteAction(Data.CreateModuleAction);
763}
764
Douglas Gregor2a060852013-02-07 00:21:12 +0000765namespace {
766 /// \brief Function object that checks with the given macro definition should
767 /// be removed, because it is one of the ignored macros.
768 class RemoveIgnoredMacro {
769 const HeaderSearchOptions &HSOpts;
770
771 public:
772 explicit RemoveIgnoredMacro(const HeaderSearchOptions &HSOpts)
773 : HSOpts(HSOpts) { }
774
775 bool operator()(const std::pair<std::string, bool> &def) const {
Douglas Gregor005d51b2013-02-07 01:18:48 +0000776 StringRef MacroDef = def.first;
777 return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0;
Douglas Gregor2a060852013-02-07 00:21:12 +0000778 }
779 };
780}
781
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000782/// \brief Compile a module file for the given module, using the options
783/// provided by the importing compiler instance.
Douglas Gregor21cae202011-09-12 23:31:24 +0000784static void compileModule(CompilerInstance &ImportingInstance,
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000785 SourceLocation ImportLoc,
Douglas Gregor1a4761e2011-11-30 23:21:26 +0000786 Module *Module,
Douglas Gregor933e7a62011-11-29 18:31:39 +0000787 StringRef ModuleFileName) {
Rafael Espindola8ffd0a42013-06-28 03:49:04 +0000788 // FIXME: have LockFileManager return an error_code so that we can
789 // avoid the mkdir when the directory already exists.
790 StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
791 llvm::sys::fs::create_directories(Dir);
792
Douglas Gregor52f12722012-01-29 20:15:24 +0000793 llvm::LockFileManager Locked(ModuleFileName);
Douglas Gregor2bc75072011-10-05 14:53:30 +0000794 switch (Locked) {
Douglas Gregor52f12722012-01-29 20:15:24 +0000795 case llvm::LockFileManager::LFS_Error:
Douglas Gregor2bc75072011-10-05 14:53:30 +0000796 return;
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000797
Douglas Gregor52f12722012-01-29 20:15:24 +0000798 case llvm::LockFileManager::LFS_Owned:
Douglas Gregor2bc75072011-10-05 14:53:30 +0000799 // We're responsible for building the module ourselves. Do so below.
800 break;
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000801
Douglas Gregor52f12722012-01-29 20:15:24 +0000802 case llvm::LockFileManager::LFS_Shared:
Douglas Gregor2bc75072011-10-05 14:53:30 +0000803 // Someone else is responsible for building the module. Wait for them to
804 // finish.
805 Locked.waitForUnlock();
Douglas Gregor7cdd2812012-11-07 17:46:15 +0000806 return;
Douglas Gregor2bc75072011-10-05 14:53:30 +0000807 }
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000808
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000809 ModuleMap &ModMap
810 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
811
Douglas Gregor21cae202011-09-12 23:31:24 +0000812 // Construct a compiler invocation for creating this module.
Dylan Noblesmithc93dc782012-02-20 14:00:23 +0000813 IntrusiveRefCntPtr<CompilerInvocation> Invocation
Douglas Gregor21cae202011-09-12 23:31:24 +0000814 (new CompilerInvocation(ImportingInstance.getInvocation()));
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000815
Douglas Gregor18ee5472011-11-29 21:59:16 +0000816 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
817
Douglas Gregorb2d39c22011-09-15 20:53:28 +0000818 // For any options that aren't intended to affect how a module is built,
819 // reset them to their default values.
Ted Kremenekd3b74d92011-11-17 23:01:24 +0000820 Invocation->getLangOpts()->resetNonModularOptions();
Douglas Gregor18ee5472011-11-29 21:59:16 +0000821 PPOpts.resetNonModularOptions();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000822
Douglas Gregor2a060852013-02-07 00:21:12 +0000823 // Remove any macro definitions that are explicitly ignored by the module.
824 // They aren't supposed to affect how the module is built anyway.
825 const HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
826 PPOpts.Macros.erase(std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
827 RemoveIgnoredMacro(HSOpts)),
828 PPOpts.Macros.end());
829
830
Douglas Gregorb86b8dc2011-11-15 19:35:01 +0000831 // Note the name of the module we're building.
Douglas Gregor933e7a62011-11-29 18:31:39 +0000832 Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
Douglas Gregorb86b8dc2011-11-15 19:35:01 +0000833
Douglas Gregor463d9092012-11-29 23:55:25 +0000834 // Make sure that the failed-module structure has been allocated in
835 // the importing instance, and propagate the pointer to the newly-created
836 // instance.
837 PreprocessorOptions &ImportingPPOpts
838 = ImportingInstance.getInvocation().getPreprocessorOpts();
839 if (!ImportingPPOpts.FailedModules)
840 ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet;
841 PPOpts.FailedModules = ImportingPPOpts.FailedModules;
842
Douglas Gregor18ee5472011-11-29 21:59:16 +0000843 // If there is a module map file, build the module using the module map.
Douglas Gregorb2d39c22011-09-15 20:53:28 +0000844 // Set up the inputs/outputs so that we build the module from its umbrella
845 // header.
Douglas Gregor21cae202011-09-12 23:31:24 +0000846 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
Douglas Gregor6e975c42011-09-13 23:15:45 +0000847 FrontendOpts.OutputFile = ModuleFileName.str();
Douglas Gregor21cae202011-09-12 23:31:24 +0000848 FrontendOpts.DisableFree = false;
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000849 FrontendOpts.GenerateGlobalModuleIndex = false;
Douglas Gregor21cae202011-09-12 23:31:24 +0000850 FrontendOpts.Inputs.clear();
Douglas Gregor18ee5472011-11-29 21:59:16 +0000851 InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000852
Douglas Gregor18ee5472011-11-29 21:59:16 +0000853 // Get or create the module map that we'll use to build this module.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000854 SmallString<128> TempModuleMapFileName;
Douglas Gregor18ee5472011-11-29 21:59:16 +0000855 if (const FileEntry *ModuleMapFile
856 = ModMap.getContainingModuleMapFile(Module)) {
857 // Use the module map where this module resides.
Douglas Gregor1f6b2b52012-01-20 16:28:04 +0000858 FrontendOpts.Inputs.push_back(FrontendInputFile(ModuleMapFile->getName(),
859 IK));
Douglas Gregor18ee5472011-11-29 21:59:16 +0000860 } else {
861 // Create a temporary module map file.
Douglas Gregor18ee5472011-11-29 21:59:16 +0000862 int FD;
Rafael Espindola1ec4a862013-07-05 20:00:06 +0000863 if (llvm::sys::fs::createTemporaryFile(Module->Name, "map", FD,
864 TempModuleMapFileName)) {
Douglas Gregorf64114b2011-12-07 00:54:14 +0000865 ImportingInstance.getDiagnostics().Report(diag::err_module_map_temp_file)
866 << TempModuleMapFileName;
Douglas Gregor18ee5472011-11-29 21:59:16 +0000867 return;
Douglas Gregore9120292011-12-06 23:04:08 +0000868 }
Douglas Gregor18ee5472011-11-29 21:59:16 +0000869 // Print the module map to this file.
870 llvm::raw_fd_ostream OS(FD, /*shouldClose=*/true);
871 Module->print(OS);
872 FrontendOpts.Inputs.push_back(
Douglas Gregor1f6b2b52012-01-20 16:28:04 +0000873 FrontendInputFile(TempModuleMapFileName.str().str(), IK));
Douglas Gregor18ee5472011-11-29 21:59:16 +0000874 }
875
876 // Don't free the remapped file buffers; they are owned by our caller.
877 PPOpts.RetainRemappedFileBuffers = true;
878
Douglas Gregor78243652011-09-13 01:26:44 +0000879 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
Douglas Gregor76d991e2011-09-13 23:20:27 +0000880 assert(ImportingInstance.getInvocation().getModuleHash() ==
Douglas Gregor18ee5472011-11-29 21:59:16 +0000881 Invocation->getModuleHash() && "Module hash mismatch!");
882
Douglas Gregor21cae202011-09-12 23:31:24 +0000883 // Construct a compiler instance that will be used to actually create the
884 // module.
885 CompilerInstance Instance;
886 Instance.setInvocation(&*Invocation);
Douglas Gregora4a90ca2013-05-03 22:58:43 +0000887
888 Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
889 ImportingInstance.getDiagnosticClient()),
Douglas Gregorcc2b6532013-05-03 23:07:45 +0000890 /*ShouldOwnClient=*/true);
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000891
Douglas Gregor4565e482012-11-30 22:11:57 +0000892 // Note that this module is part of the module build stack, so that we
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000893 // can detect cycles in the module graph.
894 Instance.createFileManager(); // FIXME: Adopt file manager from importer?
895 Instance.createSourceManager(Instance.getFileManager());
896 SourceManager &SourceMgr = Instance.getSourceManager();
Douglas Gregor4565e482012-11-30 22:11:57 +0000897 SourceMgr.setModuleBuildStack(
898 ImportingInstance.getSourceManager().getModuleBuildStack());
899 SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(),
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000900 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
901
902
Douglas Gregor21cae202011-09-12 23:31:24 +0000903 // Construct a module-generating action.
Douglas Gregor8f5d7d12013-06-21 16:28:10 +0000904 GenerateModuleAction CreateModuleAction(Module->IsSystem);
Douglas Gregor18ee5472011-11-29 21:59:16 +0000905
Douglas Gregor0ced7992011-10-04 00:21:21 +0000906 // Execute the action to actually build the module in-place. Use a separate
907 // thread so that we get a stack large enough.
908 const unsigned ThreadStackSize = 8 << 20;
909 llvm::CrashRecoveryContext CRC;
Douglas Gregor18ee5472011-11-29 21:59:16 +0000910 CompileModuleMapData Data = { Instance, CreateModuleAction };
911 CRC.RunSafelyOnThread(&doCompileMapModule, &Data, ThreadStackSize);
Douglas Gregora4a90ca2013-05-03 22:58:43 +0000912
Douglas Gregor18ee5472011-11-29 21:59:16 +0000913
914 // Delete the temporary module map file.
915 // FIXME: Even though we're executing under crash protection, it would still
916 // be nice to do this with RemoveFileOnSignal when we can. However, that
917 // doesn't make sense for all clients, so clean this up manually.
Benjamin Kramera2e94892012-10-14 19:50:53 +0000918 Instance.clearOutputFiles(/*EraseFiles=*/true);
Douglas Gregor18ee5472011-11-29 21:59:16 +0000919 if (!TempModuleMapFileName.empty())
Rafael Espindola48955f82013-06-26 04:32:59 +0000920 llvm::sys::fs::remove(TempModuleMapFileName.str());
Douglas Gregora6b00fc2013-01-23 22:38:11 +0000921
922 // We've rebuilt a module. If we're allowed to generate or update the global
923 // module index, record that fact in the importing compiler instance.
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000924 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
Douglas Gregora6b00fc2013-01-23 22:38:11 +0000925 ImportingInstance.setBuildGlobalModuleIndex(true);
926 }
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000927}
Douglas Gregor21cae202011-09-12 23:31:24 +0000928
Douglas Gregor63a72682013-03-20 00:22:05 +0000929/// \brief Diagnose differences between the current definition of the given
930/// configuration macro and the definition provided on the command line.
931static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
932 Module *Mod, SourceLocation ImportLoc) {
933 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
934 SourceManager &SourceMgr = PP.getSourceManager();
935
936 // If this identifier has never had a macro definition, then it could
937 // not have changed.
938 if (!Id->hadMacroDefinition())
939 return;
940
941 // If this identifier does not currently have a macro definition,
942 // check whether it had one on the command line.
943 if (!Id->hasMacroDefinition()) {
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000944 MacroDirective::DefInfo LatestDef =
945 PP.getMacroDirectiveHistory(Id)->getDefinition();
946 for (MacroDirective::DefInfo Def = LatestDef; Def;
947 Def = Def.getPreviousDefinition()) {
948 FileID FID = SourceMgr.getFileID(Def.getLocation());
Douglas Gregor63a72682013-03-20 00:22:05 +0000949 if (FID.isInvalid())
950 continue;
951
Douglas Gregor63a72682013-03-20 00:22:05 +0000952 // We only care about the predefines buffer.
Douglas Gregor670b2e62013-04-03 03:16:36 +0000953 if (FID != PP.getPredefinesFileID())
Douglas Gregor63a72682013-03-20 00:22:05 +0000954 continue;
955
956 // This macro was defined on the command line, then #undef'd later.
957 // Complain.
958 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
959 << true << ConfigMacro << Mod->getFullModuleName();
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000960 if (LatestDef.isUndefined())
961 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
Douglas Gregor63a72682013-03-20 00:22:05 +0000962 << true;
963 return;
964 }
965
966 // Okay: no definition in the predefines buffer.
967 return;
968 }
969
970 // This identifier has a macro definition. Check whether we had a definition
971 // on the command line.
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000972 MacroDirective::DefInfo LatestDef =
973 PP.getMacroDirectiveHistory(Id)->getDefinition();
974 MacroDirective::DefInfo PredefinedDef;
975 for (MacroDirective::DefInfo Def = LatestDef; Def;
976 Def = Def.getPreviousDefinition()) {
977 FileID FID = SourceMgr.getFileID(Def.getLocation());
Douglas Gregor63a72682013-03-20 00:22:05 +0000978 if (FID.isInvalid())
979 continue;
980
Douglas Gregor63a72682013-03-20 00:22:05 +0000981 // We only care about the predefines buffer.
Douglas Gregor670b2e62013-04-03 03:16:36 +0000982 if (FID != PP.getPredefinesFileID())
Douglas Gregor63a72682013-03-20 00:22:05 +0000983 continue;
984
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000985 PredefinedDef = Def;
Douglas Gregor63a72682013-03-20 00:22:05 +0000986 break;
987 }
988
989 // If there was no definition for this macro in the predefines buffer,
990 // complain.
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000991 if (!PredefinedDef ||
992 (!PredefinedDef.getLocation().isValid() &&
993 PredefinedDef.getUndefLocation().isValid())) {
Douglas Gregor63a72682013-03-20 00:22:05 +0000994 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
995 << false << ConfigMacro << Mod->getFullModuleName();
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000996 PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here)
Douglas Gregor63a72682013-03-20 00:22:05 +0000997 << false;
998 return;
999 }
1000
1001 // If the current macro definition is the same as the predefined macro
1002 // definition, it's okay.
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +00001003 if (LatestDef.getMacroInfo() == PredefinedDef.getMacroInfo() ||
Argyrios Kyrtzidisbd25ff82013-04-03 17:39:30 +00001004 LatestDef.getMacroInfo()->isIdenticalTo(*PredefinedDef.getMacroInfo(),PP,
1005 /*Syntactically=*/true))
Douglas Gregor63a72682013-03-20 00:22:05 +00001006 return;
1007
1008 // The macro definitions differ.
1009 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1010 << false << ConfigMacro << Mod->getFullModuleName();
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +00001011 PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here)
Douglas Gregor63a72682013-03-20 00:22:05 +00001012 << false;
1013}
1014
Douglas Gregord44d2872013-03-25 21:19:16 +00001015/// \brief Write a new timestamp file with the given path.
1016static void writeTimestampFile(StringRef TimestampFile) {
1017 std::string ErrorInfo;
1018 llvm::raw_fd_ostream Out(TimestampFile.str().c_str(), ErrorInfo,
Rafael Espindolad965f952013-07-16 19:44:23 +00001019 llvm::sys::fs::F_Binary);
Douglas Gregord44d2872013-03-25 21:19:16 +00001020}
1021
1022/// \brief Prune the module cache of modules that haven't been accessed in
1023/// a long time.
1024static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1025 struct stat StatBuf;
1026 llvm::SmallString<128> TimestampFile;
1027 TimestampFile = HSOpts.ModuleCachePath;
1028 llvm::sys::path::append(TimestampFile, "modules.timestamp");
1029
1030 // Try to stat() the timestamp file.
1031 if (::stat(TimestampFile.c_str(), &StatBuf)) {
1032 // If the timestamp file wasn't there, create one now.
1033 if (errno == ENOENT) {
1034 writeTimestampFile(TimestampFile);
1035 }
1036 return;
1037 }
1038
1039 // Check whether the time stamp is older than our pruning interval.
1040 // If not, do nothing.
1041 time_t TimeStampModTime = StatBuf.st_mtime;
1042 time_t CurrentTime = time(0);
Benjamin Kramer93ce7d52013-03-29 17:39:43 +00001043 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
Douglas Gregord44d2872013-03-25 21:19:16 +00001044 return;
Douglas Gregord44d2872013-03-25 21:19:16 +00001045
1046 // Write a new timestamp file so that nobody else attempts to prune.
1047 // There is a benign race condition here, if two Clang instances happen to
1048 // notice at the same time that the timestamp is out-of-date.
1049 writeTimestampFile(TimestampFile);
1050
1051 // Walk the entire module cache, looking for unused module files and module
1052 // indices.
1053 llvm::error_code EC;
1054 SmallString<128> ModuleCachePathNative;
1055 llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1056 for (llvm::sys::fs::directory_iterator
1057 Dir(ModuleCachePathNative.str(), EC), DirEnd;
1058 Dir != DirEnd && !EC; Dir.increment(EC)) {
1059 // If we don't have a directory, there's nothing to look into.
Rafael Espindolab470d1a2013-07-17 04:23:07 +00001060 if (!llvm::sys::fs::is_directory(Dir->path()))
Douglas Gregord44d2872013-03-25 21:19:16 +00001061 continue;
1062
1063 // Walk all of the files within this directory.
1064 bool RemovedAllFiles = true;
1065 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1066 File != FileEnd && !EC; File.increment(EC)) {
1067 // We only care about module and global module index files.
1068 if (llvm::sys::path::extension(File->path()) != ".pcm" &&
1069 llvm::sys::path::filename(File->path()) != "modules.idx") {
1070 RemovedAllFiles = false;
1071 continue;
1072 }
1073
1074 // Look at this file. If we can't stat it, there's nothing interesting
1075 // there.
1076 if (::stat(File->path().c_str(), &StatBuf)) {
1077 RemovedAllFiles = false;
1078 continue;
1079 }
1080
1081 // If the file has been used recently enough, leave it there.
1082 time_t FileAccessTime = StatBuf.st_atime;
Benjamin Kramer93ce7d52013-03-29 17:39:43 +00001083 if (CurrentTime - FileAccessTime <=
1084 time_t(HSOpts.ModuleCachePruneAfter)) {
1085 RemovedAllFiles = false;
Douglas Gregord44d2872013-03-25 21:19:16 +00001086 continue;
1087 }
1088
1089 // Remove the file.
1090 bool Existed;
1091 if (llvm::sys::fs::remove(File->path(), Existed) || !Existed) {
1092 RemovedAllFiles = false;
1093 }
1094 }
1095
1096 // If we removed all of the files in the directory, remove the directory
1097 // itself.
1098 if (RemovedAllFiles) {
1099 bool Existed;
1100 llvm::sys::fs::remove(Dir->path(), Existed);
1101 }
1102 }
1103}
1104
Douglas Gregor463d9092012-11-29 23:55:25 +00001105ModuleLoadResult
1106CompilerInstance::loadModule(SourceLocation ImportLoc,
1107 ModuleIdPath Path,
1108 Module::NameVisibilityKind Visibility,
1109 bool IsInclusionDirective) {
Douglas Gregorb514c792011-11-30 04:26:53 +00001110 // 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.
Douglas Gregor5e356932011-12-01 17:11:21 +00001113 if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) {
1114 // Make the named module visible.
1115 if (LastModuleImportResult)
Argyrios Kyrtzidis5ebcb202013-02-01 16:36:12 +00001116 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
Douglas Gregor906d66a2013-03-20 21:10:35 +00001117 ImportLoc, /*Complain=*/false);
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001118 return LastModuleImportResult;
Douglas Gregor5e356932011-12-01 17:11:21 +00001119 }
Douglas Gregorb514c792011-11-30 04:26:53 +00001120
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001121 // Determine what file we're searching from.
Douglas Gregor3d3589d2011-11-30 00:36:36 +00001122 StringRef ModuleName = Path[0].first->getName();
1123 SourceLocation ModuleNameLoc = Path[0].second;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001124
Douglas Gregor1a4761e2011-11-30 23:21:26 +00001125 clang::Module *Module = 0;
Douglas Gregor3d3589d2011-11-30 00:36:36 +00001126
Douglas Gregor49009ec2011-11-30 04:03:44 +00001127 // If we don't already have information on this module, load the module now.
Douglas Gregor1a4761e2011-11-30 23:21:26 +00001128 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001129 = KnownModules.find(Path[0].first);
Douglas Gregor5e3f9222011-12-08 17:01:29 +00001130 if (Known != KnownModules.end()) {
1131 // Retrieve the cached top-level module.
1132 Module = Known->second;
1133 } else if (ModuleName == getLangOpts().CurrentModule) {
1134 // This is the module we're building.
1135 Module = PP->getHeaderSearchInfo().getModuleMap().findModule(ModuleName);
1136 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1137 } else {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001138 // Search for a module with the given name.
Douglas Gregore434ec72012-01-29 17:08:11 +00001139 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001140 std::string ModuleFileName;
Douglas Gregor8bf778e2013-02-06 22:40:31 +00001141 if (Module) {
Douglas Gregore434ec72012-01-29 17:08:11 +00001142 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module);
Douglas Gregor8bf778e2013-02-06 22:40:31 +00001143 } else
Douglas Gregore434ec72012-01-29 17:08:11 +00001144 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(ModuleName);
Douglas Gregor463d9092012-11-29 23:55:25 +00001145
Douglas Gregor49009ec2011-11-30 04:03:44 +00001146 // If we don't already have an ASTReader, create one now.
1147 if (!ModuleManager) {
1148 if (!hasASTContext())
1149 createASTContext();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +00001150
Douglas Gregord44d2872013-03-25 21:19:16 +00001151 // If we're not recursively building a module, check whether we
1152 // need to prune the module cache.
1153 if (getSourceManager().getModuleBuildStack().empty() &&
1154 getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1155 getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1156 pruneModuleCache(getHeaderSearchOpts());
1157 }
1158
Douglas Gregor49009ec2011-11-30 04:03:44 +00001159 std::string Sysroot = getHeaderSearchOpts().Sysroot;
1160 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1161 ModuleManager = new ASTReader(getPreprocessor(), *Context,
1162 Sysroot.empty() ? "" : Sysroot.c_str(),
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001163 PPOpts.DisablePCHValidation,
1164 /*AllowASTWithCompilerErrors=*/false,
1165 getFrontendOpts().UseGlobalModuleIndex);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001166 if (hasASTConsumer()) {
1167 ModuleManager->setDeserializationListener(
1168 getASTConsumer().GetASTDeserializationListener());
1169 getASTContext().setASTMutationListener(
1170 getASTConsumer().GetASTMutationListener());
1171 }
Dylan Noblesmith6f42b622012-02-05 02:12:40 +00001172 OwningPtr<ExternalASTSource> Source;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001173 Source.reset(ModuleManager);
1174 getASTContext().setExternalSource(Source);
1175 if (hasSema())
1176 ModuleManager->InitializeSema(getSema());
1177 if (hasASTConsumer())
1178 ModuleManager->StartTranslationUnit(&getASTConsumer());
Douglas Gregorde8a9052011-09-14 23:13:09 +00001179 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001180
Douglas Gregor677e15f2013-03-19 00:28:20 +00001181 // Try to load the module file.
1182 unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing;
1183 switch (ModuleManager->ReadAST(ModuleFileName, serialization::MK_Module,
1184 ImportLoc, ARRFlags)) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001185 case ASTReader::Success:
1186 break;
1187
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001188 case ASTReader::OutOfDate: {
Douglas Gregor677e15f2013-03-19 00:28:20 +00001189 // The module file is out-of-date. Remove it, then rebuild it.
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001190 bool Existed;
1191 llvm::sys::fs::remove(ModuleFileName, Existed);
Douglas Gregor677e15f2013-03-19 00:28:20 +00001192 }
1193 // Fall through to build the module again.
1194
1195 case ASTReader::Missing: {
1196 // The module file is (now) missing. Build it.
1197
1198 // If we don't have a module, we don't know how to build the module file.
1199 // Complain and return.
1200 if (!Module) {
1201 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1202 << ModuleName
1203 << SourceRange(ImportLoc, ModuleNameLoc);
1204 ModuleBuildFailed = true;
1205 return ModuleLoadResult();
1206 }
1207
1208 // Check whether there is a cycle in the module graph.
1209 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1210 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1211 for (; Pos != PosEnd; ++Pos) {
1212 if (Pos->first == ModuleName)
1213 break;
1214 }
1215
1216 if (Pos != PosEnd) {
1217 SmallString<256> CyclePath;
1218 for (; Pos != PosEnd; ++Pos) {
1219 CyclePath += Pos->first;
1220 CyclePath += " -> ";
1221 }
1222 CyclePath += ModuleName;
1223
1224 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1225 << ModuleName << CyclePath;
1226 return ModuleLoadResult();
1227 }
Douglas Gregor463d9092012-11-29 23:55:25 +00001228
1229 // Check whether we have already attempted to build this module (but
1230 // failed).
1231 if (getPreprocessorOpts().FailedModules &&
1232 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1233 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1234 << ModuleName
1235 << SourceRange(ImportLoc, ModuleNameLoc);
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001236 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001237 return ModuleLoadResult();
1238 }
1239
Douglas Gregor677e15f2013-03-19 00:28:20 +00001240 // Try to compile the module.
Douglas Gregor830ea5b2012-11-30 18:38:50 +00001241 compileModule(*this, ModuleNameLoc, Module, ModuleFileName);
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001242
Douglas Gregor677e15f2013-03-19 00:28:20 +00001243 // Try to read the module file, now that we've compiled it.
1244 ASTReader::ASTReadResult ReadResult
1245 = ModuleManager->ReadAST(ModuleFileName,
Argyrios Kyrtzidis958bcaf2012-11-15 18:57:22 +00001246 serialization::MK_Module, ImportLoc,
Douglas Gregor677e15f2013-03-19 00:28:20 +00001247 ASTReader::ARR_Missing);
1248 if (ReadResult != ASTReader::Success) {
1249 if (ReadResult == ASTReader::Missing) {
1250 getDiagnostics().Report(ModuleNameLoc,
1251 Module? diag::err_module_not_built
1252 : diag::err_module_not_found)
1253 << ModuleName
1254 << SourceRange(ImportLoc, ModuleNameLoc);
1255 }
1256
Douglas Gregorb8a8be12013-01-10 02:04:18 +00001257 if (getPreprocessorOpts().FailedModules)
1258 getPreprocessorOpts().FailedModules->addFailed(ModuleName);
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001259 KnownModules[Path[0].first] = 0;
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001260 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001261 return ModuleLoadResult();
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001262 }
1263
1264 // Okay, we've rebuilt and now loaded the module.
1265 break;
1266 }
1267
Douglas Gregor4825fd72012-10-22 22:50:17 +00001268 case ASTReader::VersionMismatch:
1269 case ASTReader::ConfigurationMismatch:
1270 case ASTReader::HadErrors:
Argyrios Kyrtzidis3b7deda2013-05-24 05:44:08 +00001271 ModuleLoader::HadFatalFailure = true;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001272 // FIXME: The ASTReader will already have complained, but can we showhorn
1273 // that diagnostic information into a more useful form?
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001274 KnownModules[Path[0].first] = 0;
Douglas Gregor463d9092012-11-29 23:55:25 +00001275 return ModuleLoadResult();
Douglas Gregor49009ec2011-11-30 04:03:44 +00001276
1277 case ASTReader::Failure:
Argyrios Kyrtzidis3b7deda2013-05-24 05:44:08 +00001278 ModuleLoader::HadFatalFailure = true;
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001279 // Already complained, but note now that we failed.
1280 KnownModules[Path[0].first] = 0;
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001281 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001282 return ModuleLoadResult();
Douglas Gregor49009ec2011-11-30 04:03:44 +00001283 }
1284
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001285 if (!Module) {
1286 // If we loaded the module directly, without finding a module map first,
1287 // we'll have loaded the module's information from the module itself.
1288 Module = PP->getHeaderSearchInfo().getModuleMap()
1289 .findModule((Path[0].first->getName()));
1290 }
Argyrios Kyrtzidise2ac16b2012-09-29 01:06:04 +00001291
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001292 // Cache the result of this top-level module lookup for later.
1293 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001294 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001295
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001296 // If we never found the module, fail.
1297 if (!Module)
Douglas Gregor463d9092012-11-29 23:55:25 +00001298 return ModuleLoadResult();
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001299
Douglas Gregor49009ec2011-11-30 04:03:44 +00001300 // Verify that the rest of the module path actually corresponds to
1301 // a submodule.
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001302 if (Path.size() > 1) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001303 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1304 StringRef Name = Path[I].first->getName();
Douglas Gregorb7a78192012-01-04 23:32:19 +00001305 clang::Module *Sub = Module->findSubmodule(Name);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001306
Douglas Gregorb7a78192012-01-04 23:32:19 +00001307 if (!Sub) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001308 // Attempt to perform typo correction to find a module name that works.
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00001309 SmallVector<StringRef, 2> Best;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001310 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1311
Douglas Gregorb7a78192012-01-04 23:32:19 +00001312 for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1313 JEnd = Module->submodule_end();
Matt Beaumont-Gaye25633f2011-11-30 19:41:21 +00001314 J != JEnd; ++J) {
Douglas Gregorb7a78192012-01-04 23:32:19 +00001315 unsigned ED = Name.edit_distance((*J)->Name,
Douglas Gregor49009ec2011-11-30 04:03:44 +00001316 /*AllowReplacements=*/true,
1317 BestEditDistance);
1318 if (ED <= BestEditDistance) {
Douglas Gregorb7a78192012-01-04 23:32:19 +00001319 if (ED < BestEditDistance) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001320 Best.clear();
Douglas Gregorb7a78192012-01-04 23:32:19 +00001321 BestEditDistance = ED;
1322 }
1323
1324 Best.push_back((*J)->Name);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001325 }
1326 }
1327
1328 // If there was a clear winner, user it.
1329 if (Best.size() == 1) {
1330 getDiagnostics().Report(Path[I].second,
1331 diag::err_no_submodule_suggest)
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001332 << Path[I].first << Module->getFullModuleName() << Best[0]
Douglas Gregor49009ec2011-11-30 04:03:44 +00001333 << SourceRange(Path[0].second, Path[I-1].second)
1334 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1335 Best[0]);
Douglas Gregorb7a78192012-01-04 23:32:19 +00001336
1337 Sub = Module->findSubmodule(Best[0]);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001338 }
1339 }
1340
Douglas Gregorb7a78192012-01-04 23:32:19 +00001341 if (!Sub) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001342 // No submodule by this name. Complain, and don't look for further
1343 // submodules.
1344 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001345 << Path[I].first << Module->getFullModuleName()
Douglas Gregor49009ec2011-11-30 04:03:44 +00001346 << SourceRange(Path[0].second, Path[I-1].second);
1347 break;
1348 }
1349
Douglas Gregorb7a78192012-01-04 23:32:19 +00001350 Module = Sub;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001351 }
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001352 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001353
Douglas Gregor5e3f9222011-12-08 17:01:29 +00001354 // Make the named module visible, if it's not already part of the module
1355 // we are parsing.
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001356 if (ModuleName != getLangOpts().CurrentModule) {
1357 if (!Module->IsFromModuleFile) {
1358 // We have an umbrella header or directory that doesn't actually include
1359 // all of the headers within the directory it covers. Complain about
1360 // this missing submodule and recover by forgetting that we ever saw
1361 // this submodule.
1362 // FIXME: Should we detect this at module load time? It seems fairly
1363 // expensive (and rare).
1364 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1365 << Module->getFullModuleName()
1366 << SourceRange(Path.front().second, Path.back().second);
1367
Douglas Gregor463d9092012-11-29 23:55:25 +00001368 return ModuleLoadResult(0, true);
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001369 }
Douglas Gregor51f564f2011-12-31 04:05:44 +00001370
1371 // Check whether this module is available.
1372 StringRef Feature;
Douglas Gregordc58aa72012-01-30 06:01:29 +00001373 if (!Module->isAvailable(getLangOpts(), getTarget(), Feature)) {
Douglas Gregor51f564f2011-12-31 04:05:44 +00001374 getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
1375 << Module->getFullModuleName()
1376 << Feature
1377 << SourceRange(Path.front().second, Path.back().second);
1378 LastModuleImportLoc = ImportLoc;
Douglas Gregor463d9092012-11-29 23:55:25 +00001379 LastModuleImportResult = ModuleLoadResult();
1380 return ModuleLoadResult();
Douglas Gregor51f564f2011-12-31 04:05:44 +00001381 }
1382
Douglas Gregor906d66a2013-03-20 21:10:35 +00001383 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc,
1384 /*Complain=*/true);
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001385 }
Douglas Gregor63a72682013-03-20 00:22:05 +00001386
1387 // Check for any configuration macros that have changed.
1388 clang::Module *TopModule = Module->getTopLevelModule();
1389 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1390 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1391 Module, ImportLoc);
1392 }
1393
Douglas Gregor93ebfa62011-12-02 23:42:12 +00001394 // If this module import was due to an inclusion directive, create an
1395 // implicit import declaration to capture it in the AST.
1396 if (IsInclusionDirective && hasASTContext()) {
1397 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
Argyrios Kyrtzidisd3d98162012-10-03 01:58:37 +00001398 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
1399 ImportLoc, Module,
1400 Path.back().second);
1401 TU->addDecl(ImportD);
1402 if (Consumer)
1403 Consumer->HandleImplicitImportDecl(ImportD);
Douglas Gregor93ebfa62011-12-02 23:42:12 +00001404 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001405
Douglas Gregorb514c792011-11-30 04:26:53 +00001406 LastModuleImportLoc = ImportLoc;
Douglas Gregor463d9092012-11-29 23:55:25 +00001407 LastModuleImportResult = ModuleLoadResult(Module, false);
1408 return LastModuleImportResult;
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001409}
Douglas Gregorca2ab452013-01-12 01:29:50 +00001410
1411void CompilerInstance::makeModuleVisible(Module *Mod,
Argyrios Kyrtzidis5ebcb202013-02-01 16:36:12 +00001412 Module::NameVisibilityKind Visibility,
Douglas Gregor906d66a2013-03-20 21:10:35 +00001413 SourceLocation ImportLoc,
1414 bool Complain){
1415 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc, Complain);
Douglas Gregorca2ab452013-01-12 01:29:50 +00001416}
1417