blob: c2f03970be3fdb8e304d2a8357923ac6794717b3 [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)
448 llvm::sys::Path(it->Filename).eraseFromDisk();
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()) {
512 llvm::sys::Path Path(InFile);
513 Path.eraseSuffix();
514 Path.appendSuffix(Extension);
515 OutFile = Path.str();
516 } else {
517 OutFile = "-";
518 }
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000519
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000520 OwningPtr<llvm::raw_fd_ostream> OS;
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000521 std::string OSFile;
522
523 if (UseTemporary && OutFile != "-") {
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000524 // Only create the temporary if the parent directory exists (or create
525 // missing directories is true) and we can actually write to OutPath,
526 // otherwise we want to fail early.
527 SmallString<256> AbsPath(OutputPath);
528 llvm::sys::fs::make_absolute(AbsPath);
529 llvm::sys::Path OutPath(AbsPath);
530 bool ParentExists = false;
531 if (llvm::sys::fs::exists(llvm::sys::path::parent_path(AbsPath.str()),
532 ParentExists))
533 ParentExists = false;
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000534 bool Exists;
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000535 if ((CreateMissingDirectories || ParentExists) &&
536 ((llvm::sys::fs::exists(AbsPath.str(), Exists) || !Exists) ||
537 (OutPath.isRegularFile() && OutPath.canWrite()))) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000538 // Create a temporary file.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000539 SmallString<128> TempPath;
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000540 TempPath = OutFile;
541 TempPath += "-%%%%%%%%";
542 int fd;
543 if (llvm::sys::fs::unique_file(TempPath.str(), fd, TempPath,
Eric Christopher7d9ae252012-05-11 00:10:07 +0000544 /*makeAbsolute=*/false, 0664)
545 == llvm::errc::success) {
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000546 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
547 OSFile = TempFile = TempPath.str();
548 }
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000549 }
550 }
551
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000552 if (!OS) {
553 OSFile = OutFile;
554 OS.reset(
555 new llvm::raw_fd_ostream(OSFile.c_str(), Error,
556 (Binary ? llvm::raw_fd_ostream::F_Binary : 0)));
557 if (!Error.empty())
558 return 0;
559 }
Daniel Dunbarf482d592009-11-13 18:32:08 +0000560
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000561 // Make sure the out stream file gets removed if we crash.
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000562 if (RemoveFileOnSignal)
Rafael Espindola6f2e23b2013-06-13 21:02:40 +0000563 llvm::sys::RemoveFileOnSignal(OSFile);
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000564
Daniel Dunbarf482d592009-11-13 18:32:08 +0000565 if (ResultPathName)
566 *ResultPathName = OutFile;
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000567 if (TempPathName)
568 *TempPathName = TempFile;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000569
Daniel Dunbarfc971022009-11-20 22:32:38 +0000570 return OS.take();
Daniel Dunbarf482d592009-11-13 18:32:08 +0000571}
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000572
573// Initialization Utilities
574
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000575bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
576 return InitializeSourceManager(Input, getDiagnostics(),
Douglas Gregora1f1fad2012-01-27 19:52:33 +0000577 getFileManager(), getSourceManager(),
578 getFrontendOpts());
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000579}
580
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000581bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input,
David Blaikied6471f72011-09-25 23:23:43 +0000582 DiagnosticsEngine &Diags,
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000583 FileManager &FileMgr,
584 SourceManager &SourceMgr,
585 const FrontendOptions &Opts) {
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000586 SrcMgr::CharacteristicKind
Argyrios Kyrtzidis8616f9a2012-11-09 19:40:39 +0000587 Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000588
Argyrios Kyrtzidisecd27bf2012-11-09 19:40:45 +0000589 if (Input.isBuffer()) {
590 SourceMgr.createMainFileIDForMemBuffer(Input.getBuffer(), Kind);
591 assert(!SourceMgr.getMainFileID().isInvalid() &&
592 "Couldn't establish MainFileID!");
593 return true;
594 }
595
596 StringRef InputFile = Input.getFile();
597
Argyrios Kyrtzidis507097e2011-09-19 20:40:35 +0000598 // Figure out where to get and map in the main file.
599 if (InputFile != "-") {
Chris Lattner39b49bc2010-11-23 08:35:12 +0000600 const FileEntry *File = FileMgr.getFile(InputFile);
Dan Gohman694137c2010-10-26 21:13:51 +0000601 if (!File) {
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000602 Diags.Report(diag::err_fe_error_reading) << InputFile;
603 return false;
604 }
Daniel Dunbarce36ecd2012-11-05 22:53:33 +0000605
606 // The natural SourceManager infrastructure can't currently handle named
607 // pipes, but we would at least like to accept them for the main
608 // file. Detect them here, read them with the more generic MemoryBuffer
609 // function, and simply override their contents as we do for STDIN.
610 if (File->isNamedPipe()) {
611 OwningPtr<llvm::MemoryBuffer> MB;
612 if (llvm::error_code ec = llvm::MemoryBuffer::getFile(InputFile, MB)) {
613 Diags.Report(diag::err_cannot_open_file) << InputFile << ec.message();
614 return false;
615 }
Daniel Dunbaracf36122012-11-27 00:04:16 +0000616
617 // Create a new virtual file that will have the correct size.
618 File = FileMgr.getVirtualFile(InputFile, MB->getBufferSize(), 0);
Daniel Dunbarce36ecd2012-11-05 22:53:33 +0000619 SourceMgr.overrideFileContents(File, MB.take());
620 }
Daniel Dunbaracf36122012-11-27 00:04:16 +0000621
622 SourceMgr.createMainFileID(File, Kind);
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000623 } else {
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000624 OwningPtr<llvm::MemoryBuffer> SB;
Michael J. Spencer4eeebc42010-12-16 03:28:14 +0000625 if (llvm::MemoryBuffer::getSTDIN(SB)) {
Michael J. Spencer3a321e22010-12-09 17:36:38 +0000626 // FIXME: Give ec.message() in this diag.
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000627 Diags.Report(diag::err_fe_error_reading_stdin);
628 return false;
629 }
Dan Gohman90d90812010-10-26 23:21:25 +0000630 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
Chris Lattner39b49bc2010-11-23 08:35:12 +0000631 SB->getBufferSize(), 0);
Douglas Gregora1f1fad2012-01-27 19:52:33 +0000632 SourceMgr.createMainFileID(File, Kind);
Michael J. Spencer4eeebc42010-12-16 03:28:14 +0000633 SourceMgr.overrideFileContents(File, SB.take());
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000634 }
635
Dan Gohman694137c2010-10-26 21:13:51 +0000636 assert(!SourceMgr.getMainFileID().isInvalid() &&
637 "Couldn't establish MainFileID!");
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000638 return true;
639}
Daniel Dunbar0397af22010-01-13 00:48:06 +0000640
641// High-Level Operations
642
643bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
644 assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
645 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
646 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
647
648 // FIXME: Take this as an argument, once all the APIs we used have moved to
649 // taking it as an input instead of hard-coding llvm::errs.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000650 raw_ostream &OS = llvm::errs();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000651
652 // Create the target instance.
Douglas Gregor49a87542012-11-16 04:24:59 +0000653 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), &getTargetOpts()));
Daniel Dunbar0397af22010-01-13 00:48:06 +0000654 if (!hasTarget())
655 return false;
656
657 // Inform the target of the language options.
658 //
659 // FIXME: We shouldn't need to do this, the target should be immutable once
660 // created. This complexity should be lifted elsewhere.
661 getTarget().setForcedLangOptions(getLangOpts());
662
Fariborz Jahanian93a49942012-04-16 21:03:30 +0000663 // rewriter project will change target built-in bool type from its default.
664 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
665 getTarget().noSignedCharForObjCBool();
666
Daniel Dunbar0397af22010-01-13 00:48:06 +0000667 // Validate/process some options.
668 if (getHeaderSearchOpts().Verbose)
669 OS << "clang -cc1 version " CLANG_VERSION_STRING
670 << " based upon " << PACKAGE_STRING
Sebastian Pop5d8b9542011-11-01 21:33:06 +0000671 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
Daniel Dunbar0397af22010-01-13 00:48:06 +0000672
673 if (getFrontendOpts().ShowTimers)
674 createFrontendTimer();
675
Douglas Gregor95dd5582010-03-30 17:33:59 +0000676 if (getFrontendOpts().ShowStats)
677 llvm::EnableStatistics();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000678
Daniel Dunbar0397af22010-01-13 00:48:06 +0000679 for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) {
Daniel Dunbar20560482010-06-07 23:23:50 +0000680 // Reset the ID tables if we are reusing the SourceManager.
681 if (hasSourceManager())
682 getSourceManager().clearIDTables();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000683
Douglas Gregor1f6b2b52012-01-20 16:28:04 +0000684 if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) {
Daniel Dunbar0397af22010-01-13 00:48:06 +0000685 Act.Execute();
686 Act.EndSourceFile();
687 }
688 }
689
Argyrios Kyrtzidis29f27872011-12-07 05:52:12 +0000690 // Notify the diagnostic client that all files were processed.
691 getDiagnostics().getClient()->finish();
692
Chris Lattner53eee7b2010-04-07 18:47:42 +0000693 if (getDiagnosticOpts().ShowCarets) {
Argyrios Kyrtzidisf2224d82010-11-18 20:06:46 +0000694 // We can have multiple diagnostics sharing one diagnostic client.
695 // Get the total number of warnings/errors from the client.
696 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
697 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000698
Chris Lattner53eee7b2010-04-07 18:47:42 +0000699 if (NumWarnings)
700 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
701 if (NumWarnings && NumErrors)
702 OS << " and ";
703 if (NumErrors)
704 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
705 if (NumWarnings || NumErrors)
706 OS << " generated.\n";
707 }
Daniel Dunbar0397af22010-01-13 00:48:06 +0000708
Daniel Dunbar20560482010-06-07 23:23:50 +0000709 if (getFrontendOpts().ShowStats && hasFileManager()) {
Daniel Dunbar0397af22010-01-13 00:48:06 +0000710 getFileManager().PrintStats();
711 OS << "\n";
712 }
713
Argyrios Kyrtzidisab41b972010-11-18 21:13:57 +0000714 return !getDiagnostics().getClient()->getNumErrors();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000715}
716
Douglas Gregor21cae202011-09-12 23:31:24 +0000717/// \brief Determine the appropriate source input kind based on language
718/// options.
719static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
720 if (LangOpts.OpenCL)
721 return IK_OpenCL;
722 if (LangOpts.CUDA)
723 return IK_CUDA;
724 if (LangOpts.ObjC1)
725 return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
726 return LangOpts.CPlusPlus? IK_CXX : IK_C;
727}
728
Douglas Gregor0ced7992011-10-04 00:21:21 +0000729namespace {
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000730 struct CompileModuleMapData {
731 CompilerInstance &Instance;
732 GenerateModuleAction &CreateModuleAction;
733 };
734}
735
736/// \brief Helper function that executes the module-generating action under
737/// a crash recovery context.
738static void doCompileMapModule(void *UserData) {
739 CompileModuleMapData &Data
740 = *reinterpret_cast<CompileModuleMapData *>(UserData);
741 Data.Instance.ExecuteAction(Data.CreateModuleAction);
742}
743
Douglas Gregor2a060852013-02-07 00:21:12 +0000744namespace {
745 /// \brief Function object that checks with the given macro definition should
746 /// be removed, because it is one of the ignored macros.
747 class RemoveIgnoredMacro {
748 const HeaderSearchOptions &HSOpts;
749
750 public:
751 explicit RemoveIgnoredMacro(const HeaderSearchOptions &HSOpts)
752 : HSOpts(HSOpts) { }
753
754 bool operator()(const std::pair<std::string, bool> &def) const {
Douglas Gregor005d51b2013-02-07 01:18:48 +0000755 StringRef MacroDef = def.first;
756 return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0;
Douglas Gregor2a060852013-02-07 00:21:12 +0000757 }
758 };
759}
760
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000761/// \brief Compile a module file for the given module, using the options
762/// provided by the importing compiler instance.
Douglas Gregor21cae202011-09-12 23:31:24 +0000763static void compileModule(CompilerInstance &ImportingInstance,
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000764 SourceLocation ImportLoc,
Douglas Gregor1a4761e2011-11-30 23:21:26 +0000765 Module *Module,
Douglas Gregor933e7a62011-11-29 18:31:39 +0000766 StringRef ModuleFileName) {
Douglas Gregor52f12722012-01-29 20:15:24 +0000767 llvm::LockFileManager Locked(ModuleFileName);
Douglas Gregor2bc75072011-10-05 14:53:30 +0000768 switch (Locked) {
Douglas Gregor52f12722012-01-29 20:15:24 +0000769 case llvm::LockFileManager::LFS_Error:
Douglas Gregor2bc75072011-10-05 14:53:30 +0000770 return;
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000771
Douglas Gregor52f12722012-01-29 20:15:24 +0000772 case llvm::LockFileManager::LFS_Owned:
Douglas Gregor2bc75072011-10-05 14:53:30 +0000773 // We're responsible for building the module ourselves. Do so below.
774 break;
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000775
Douglas Gregor52f12722012-01-29 20:15:24 +0000776 case llvm::LockFileManager::LFS_Shared:
Douglas Gregor2bc75072011-10-05 14:53:30 +0000777 // Someone else is responsible for building the module. Wait for them to
778 // finish.
779 Locked.waitForUnlock();
Douglas Gregor7cdd2812012-11-07 17:46:15 +0000780 return;
Douglas Gregor2bc75072011-10-05 14:53:30 +0000781 }
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000782
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000783 ModuleMap &ModMap
784 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
785
Douglas Gregor21cae202011-09-12 23:31:24 +0000786 // Construct a compiler invocation for creating this module.
Dylan Noblesmithc93dc782012-02-20 14:00:23 +0000787 IntrusiveRefCntPtr<CompilerInvocation> Invocation
Douglas Gregor21cae202011-09-12 23:31:24 +0000788 (new CompilerInvocation(ImportingInstance.getInvocation()));
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000789
Douglas Gregor18ee5472011-11-29 21:59:16 +0000790 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
791
Douglas Gregorb2d39c22011-09-15 20:53:28 +0000792 // For any options that aren't intended to affect how a module is built,
793 // reset them to their default values.
Ted Kremenekd3b74d92011-11-17 23:01:24 +0000794 Invocation->getLangOpts()->resetNonModularOptions();
Douglas Gregor18ee5472011-11-29 21:59:16 +0000795 PPOpts.resetNonModularOptions();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000796
Douglas Gregor2a060852013-02-07 00:21:12 +0000797 // Remove any macro definitions that are explicitly ignored by the module.
798 // They aren't supposed to affect how the module is built anyway.
799 const HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
800 PPOpts.Macros.erase(std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
801 RemoveIgnoredMacro(HSOpts)),
802 PPOpts.Macros.end());
803
804
Douglas Gregorb86b8dc2011-11-15 19:35:01 +0000805 // Note the name of the module we're building.
Douglas Gregor933e7a62011-11-29 18:31:39 +0000806 Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
Douglas Gregorb86b8dc2011-11-15 19:35:01 +0000807
Douglas Gregor463d9092012-11-29 23:55:25 +0000808 // Make sure that the failed-module structure has been allocated in
809 // the importing instance, and propagate the pointer to the newly-created
810 // instance.
811 PreprocessorOptions &ImportingPPOpts
812 = ImportingInstance.getInvocation().getPreprocessorOpts();
813 if (!ImportingPPOpts.FailedModules)
814 ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet;
815 PPOpts.FailedModules = ImportingPPOpts.FailedModules;
816
Douglas Gregor18ee5472011-11-29 21:59:16 +0000817 // If there is a module map file, build the module using the module map.
Douglas Gregorb2d39c22011-09-15 20:53:28 +0000818 // Set up the inputs/outputs so that we build the module from its umbrella
819 // header.
Douglas Gregor21cae202011-09-12 23:31:24 +0000820 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
Douglas Gregor6e975c42011-09-13 23:15:45 +0000821 FrontendOpts.OutputFile = ModuleFileName.str();
Douglas Gregor21cae202011-09-12 23:31:24 +0000822 FrontendOpts.DisableFree = false;
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000823 FrontendOpts.GenerateGlobalModuleIndex = false;
Douglas Gregor21cae202011-09-12 23:31:24 +0000824 FrontendOpts.Inputs.clear();
Douglas Gregor18ee5472011-11-29 21:59:16 +0000825 InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000826
Douglas Gregor18ee5472011-11-29 21:59:16 +0000827 // Get or create the module map that we'll use to build this module.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000828 SmallString<128> TempModuleMapFileName;
Douglas Gregor18ee5472011-11-29 21:59:16 +0000829 if (const FileEntry *ModuleMapFile
830 = ModMap.getContainingModuleMapFile(Module)) {
831 // Use the module map where this module resides.
Douglas Gregor1f6b2b52012-01-20 16:28:04 +0000832 FrontendOpts.Inputs.push_back(FrontendInputFile(ModuleMapFile->getName(),
833 IK));
Douglas Gregor18ee5472011-11-29 21:59:16 +0000834 } else {
835 // Create a temporary module map file.
836 TempModuleMapFileName = Module->Name;
837 TempModuleMapFileName += "-%%%%%%%%.map";
838 int FD;
839 if (llvm::sys::fs::unique_file(TempModuleMapFileName.str(), FD,
840 TempModuleMapFileName,
Douglas Gregor1e821e92011-12-06 22:05:29 +0000841 /*makeAbsolute=*/true)
Douglas Gregore9120292011-12-06 23:04:08 +0000842 != llvm::errc::success) {
Douglas Gregorf64114b2011-12-07 00:54:14 +0000843 ImportingInstance.getDiagnostics().Report(diag::err_module_map_temp_file)
844 << TempModuleMapFileName;
Douglas Gregor18ee5472011-11-29 21:59:16 +0000845 return;
Douglas Gregore9120292011-12-06 23:04:08 +0000846 }
Douglas Gregor18ee5472011-11-29 21:59:16 +0000847 // Print the module map to this file.
848 llvm::raw_fd_ostream OS(FD, /*shouldClose=*/true);
849 Module->print(OS);
850 FrontendOpts.Inputs.push_back(
Douglas Gregor1f6b2b52012-01-20 16:28:04 +0000851 FrontendInputFile(TempModuleMapFileName.str().str(), IK));
Douglas Gregor18ee5472011-11-29 21:59:16 +0000852 }
853
854 // Don't free the remapped file buffers; they are owned by our caller.
855 PPOpts.RetainRemappedFileBuffers = true;
856
Douglas Gregor78243652011-09-13 01:26:44 +0000857 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
Douglas Gregor76d991e2011-09-13 23:20:27 +0000858 assert(ImportingInstance.getInvocation().getModuleHash() ==
Douglas Gregor18ee5472011-11-29 21:59:16 +0000859 Invocation->getModuleHash() && "Module hash mismatch!");
860
Douglas Gregor21cae202011-09-12 23:31:24 +0000861 // Construct a compiler instance that will be used to actually create the
862 // module.
863 CompilerInstance Instance;
864 Instance.setInvocation(&*Invocation);
Douglas Gregora4a90ca2013-05-03 22:58:43 +0000865
866 Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
867 ImportingInstance.getDiagnosticClient()),
Douglas Gregorcc2b6532013-05-03 23:07:45 +0000868 /*ShouldOwnClient=*/true);
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000869
Douglas Gregor4565e482012-11-30 22:11:57 +0000870 // Note that this module is part of the module build stack, so that we
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000871 // can detect cycles in the module graph.
872 Instance.createFileManager(); // FIXME: Adopt file manager from importer?
873 Instance.createSourceManager(Instance.getFileManager());
874 SourceManager &SourceMgr = Instance.getSourceManager();
Douglas Gregor4565e482012-11-30 22:11:57 +0000875 SourceMgr.setModuleBuildStack(
876 ImportingInstance.getSourceManager().getModuleBuildStack());
877 SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(),
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000878 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
879
880
Douglas Gregor21cae202011-09-12 23:31:24 +0000881 // Construct a module-generating action.
Douglas Gregor18ee5472011-11-29 21:59:16 +0000882 GenerateModuleAction CreateModuleAction;
883
Douglas Gregor0ced7992011-10-04 00:21:21 +0000884 // Execute the action to actually build the module in-place. Use a separate
885 // thread so that we get a stack large enough.
886 const unsigned ThreadStackSize = 8 << 20;
887 llvm::CrashRecoveryContext CRC;
Douglas Gregor18ee5472011-11-29 21:59:16 +0000888 CompileModuleMapData Data = { Instance, CreateModuleAction };
889 CRC.RunSafelyOnThread(&doCompileMapModule, &Data, ThreadStackSize);
Douglas Gregora4a90ca2013-05-03 22:58:43 +0000890
Douglas Gregor18ee5472011-11-29 21:59:16 +0000891
892 // Delete the temporary module map file.
893 // FIXME: Even though we're executing under crash protection, it would still
894 // be nice to do this with RemoveFileOnSignal when we can. However, that
895 // doesn't make sense for all clients, so clean this up manually.
Benjamin Kramera2e94892012-10-14 19:50:53 +0000896 Instance.clearOutputFiles(/*EraseFiles=*/true);
Douglas Gregor18ee5472011-11-29 21:59:16 +0000897 if (!TempModuleMapFileName.empty())
898 llvm::sys::Path(TempModuleMapFileName).eraseFromDisk();
Douglas Gregora6b00fc2013-01-23 22:38:11 +0000899
900 // We've rebuilt a module. If we're allowed to generate or update the global
901 // module index, record that fact in the importing compiler instance.
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000902 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
Douglas Gregora6b00fc2013-01-23 22:38:11 +0000903 ImportingInstance.setBuildGlobalModuleIndex(true);
904 }
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000905}
Douglas Gregor21cae202011-09-12 23:31:24 +0000906
Douglas Gregor63a72682013-03-20 00:22:05 +0000907/// \brief Diagnose differences between the current definition of the given
908/// configuration macro and the definition provided on the command line.
909static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
910 Module *Mod, SourceLocation ImportLoc) {
911 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
912 SourceManager &SourceMgr = PP.getSourceManager();
913
914 // If this identifier has never had a macro definition, then it could
915 // not have changed.
916 if (!Id->hadMacroDefinition())
917 return;
918
919 // If this identifier does not currently have a macro definition,
920 // check whether it had one on the command line.
921 if (!Id->hasMacroDefinition()) {
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000922 MacroDirective::DefInfo LatestDef =
923 PP.getMacroDirectiveHistory(Id)->getDefinition();
924 for (MacroDirective::DefInfo Def = LatestDef; Def;
925 Def = Def.getPreviousDefinition()) {
926 FileID FID = SourceMgr.getFileID(Def.getLocation());
Douglas Gregor63a72682013-03-20 00:22:05 +0000927 if (FID.isInvalid())
928 continue;
929
Douglas Gregor63a72682013-03-20 00:22:05 +0000930 // We only care about the predefines buffer.
Douglas Gregor670b2e62013-04-03 03:16:36 +0000931 if (FID != PP.getPredefinesFileID())
Douglas Gregor63a72682013-03-20 00:22:05 +0000932 continue;
933
934 // This macro was defined on the command line, then #undef'd later.
935 // Complain.
936 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
937 << true << ConfigMacro << Mod->getFullModuleName();
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000938 if (LatestDef.isUndefined())
939 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
Douglas Gregor63a72682013-03-20 00:22:05 +0000940 << true;
941 return;
942 }
943
944 // Okay: no definition in the predefines buffer.
945 return;
946 }
947
948 // This identifier has a macro definition. Check whether we had a definition
949 // on the command line.
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000950 MacroDirective::DefInfo LatestDef =
951 PP.getMacroDirectiveHistory(Id)->getDefinition();
952 MacroDirective::DefInfo PredefinedDef;
953 for (MacroDirective::DefInfo Def = LatestDef; Def;
954 Def = Def.getPreviousDefinition()) {
955 FileID FID = SourceMgr.getFileID(Def.getLocation());
Douglas Gregor63a72682013-03-20 00:22:05 +0000956 if (FID.isInvalid())
957 continue;
958
Douglas Gregor63a72682013-03-20 00:22:05 +0000959 // We only care about the predefines buffer.
Douglas Gregor670b2e62013-04-03 03:16:36 +0000960 if (FID != PP.getPredefinesFileID())
Douglas Gregor63a72682013-03-20 00:22:05 +0000961 continue;
962
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000963 PredefinedDef = Def;
Douglas Gregor63a72682013-03-20 00:22:05 +0000964 break;
965 }
966
967 // If there was no definition for this macro in the predefines buffer,
968 // complain.
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000969 if (!PredefinedDef ||
970 (!PredefinedDef.getLocation().isValid() &&
971 PredefinedDef.getUndefLocation().isValid())) {
Douglas Gregor63a72682013-03-20 00:22:05 +0000972 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
973 << false << ConfigMacro << Mod->getFullModuleName();
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000974 PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here)
Douglas Gregor63a72682013-03-20 00:22:05 +0000975 << false;
976 return;
977 }
978
979 // If the current macro definition is the same as the predefined macro
980 // definition, it's okay.
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000981 if (LatestDef.getMacroInfo() == PredefinedDef.getMacroInfo() ||
Argyrios Kyrtzidisbd25ff82013-04-03 17:39:30 +0000982 LatestDef.getMacroInfo()->isIdenticalTo(*PredefinedDef.getMacroInfo(),PP,
983 /*Syntactically=*/true))
Douglas Gregor63a72682013-03-20 00:22:05 +0000984 return;
985
986 // The macro definitions differ.
987 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
988 << false << ConfigMacro << Mod->getFullModuleName();
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000989 PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here)
Douglas Gregor63a72682013-03-20 00:22:05 +0000990 << false;
991}
992
Douglas Gregord44d2872013-03-25 21:19:16 +0000993/// \brief Write a new timestamp file with the given path.
994static void writeTimestampFile(StringRef TimestampFile) {
995 std::string ErrorInfo;
996 llvm::raw_fd_ostream Out(TimestampFile.str().c_str(), ErrorInfo,
997 llvm::raw_fd_ostream::F_Binary);
998}
999
1000/// \brief Prune the module cache of modules that haven't been accessed in
1001/// a long time.
1002static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1003 struct stat StatBuf;
1004 llvm::SmallString<128> TimestampFile;
1005 TimestampFile = HSOpts.ModuleCachePath;
1006 llvm::sys::path::append(TimestampFile, "modules.timestamp");
1007
1008 // Try to stat() the timestamp file.
1009 if (::stat(TimestampFile.c_str(), &StatBuf)) {
1010 // If the timestamp file wasn't there, create one now.
1011 if (errno == ENOENT) {
1012 writeTimestampFile(TimestampFile);
1013 }
1014 return;
1015 }
1016
1017 // Check whether the time stamp is older than our pruning interval.
1018 // If not, do nothing.
1019 time_t TimeStampModTime = StatBuf.st_mtime;
1020 time_t CurrentTime = time(0);
Benjamin Kramer93ce7d52013-03-29 17:39:43 +00001021 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
Douglas Gregord44d2872013-03-25 21:19:16 +00001022 return;
Douglas Gregord44d2872013-03-25 21:19:16 +00001023
1024 // Write a new timestamp file so that nobody else attempts to prune.
1025 // There is a benign race condition here, if two Clang instances happen to
1026 // notice at the same time that the timestamp is out-of-date.
1027 writeTimestampFile(TimestampFile);
1028
1029 // Walk the entire module cache, looking for unused module files and module
1030 // indices.
1031 llvm::error_code EC;
1032 SmallString<128> ModuleCachePathNative;
1033 llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1034 for (llvm::sys::fs::directory_iterator
1035 Dir(ModuleCachePathNative.str(), EC), DirEnd;
1036 Dir != DirEnd && !EC; Dir.increment(EC)) {
1037 // If we don't have a directory, there's nothing to look into.
1038 bool IsDirectory;
1039 if (llvm::sys::fs::is_directory(Dir->path(), IsDirectory) || !IsDirectory)
1040 continue;
1041
1042 // Walk all of the files within this directory.
1043 bool RemovedAllFiles = true;
1044 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1045 File != FileEnd && !EC; File.increment(EC)) {
1046 // We only care about module and global module index files.
1047 if (llvm::sys::path::extension(File->path()) != ".pcm" &&
1048 llvm::sys::path::filename(File->path()) != "modules.idx") {
1049 RemovedAllFiles = false;
1050 continue;
1051 }
1052
1053 // Look at this file. If we can't stat it, there's nothing interesting
1054 // there.
1055 if (::stat(File->path().c_str(), &StatBuf)) {
1056 RemovedAllFiles = false;
1057 continue;
1058 }
1059
1060 // If the file has been used recently enough, leave it there.
1061 time_t FileAccessTime = StatBuf.st_atime;
Benjamin Kramer93ce7d52013-03-29 17:39:43 +00001062 if (CurrentTime - FileAccessTime <=
1063 time_t(HSOpts.ModuleCachePruneAfter)) {
1064 RemovedAllFiles = false;
Douglas Gregord44d2872013-03-25 21:19:16 +00001065 continue;
1066 }
1067
1068 // Remove the file.
1069 bool Existed;
1070 if (llvm::sys::fs::remove(File->path(), Existed) || !Existed) {
1071 RemovedAllFiles = false;
1072 }
1073 }
1074
1075 // If we removed all of the files in the directory, remove the directory
1076 // itself.
1077 if (RemovedAllFiles) {
1078 bool Existed;
1079 llvm::sys::fs::remove(Dir->path(), Existed);
1080 }
1081 }
1082}
1083
Douglas Gregor463d9092012-11-29 23:55:25 +00001084ModuleLoadResult
1085CompilerInstance::loadModule(SourceLocation ImportLoc,
1086 ModuleIdPath Path,
1087 Module::NameVisibilityKind Visibility,
1088 bool IsInclusionDirective) {
Douglas Gregorb514c792011-11-30 04:26:53 +00001089 // If we've already handled this import, just return the cached result.
1090 // This one-element cache is important to eliminate redundant diagnostics
1091 // when both the preprocessor and parser see the same import declaration.
Douglas Gregor5e356932011-12-01 17:11:21 +00001092 if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) {
1093 // Make the named module visible.
1094 if (LastModuleImportResult)
Argyrios Kyrtzidis5ebcb202013-02-01 16:36:12 +00001095 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
Douglas Gregor906d66a2013-03-20 21:10:35 +00001096 ImportLoc, /*Complain=*/false);
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001097 return LastModuleImportResult;
Douglas Gregor5e356932011-12-01 17:11:21 +00001098 }
Douglas Gregorb514c792011-11-30 04:26:53 +00001099
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001100 // Determine what file we're searching from.
Douglas Gregor3d3589d2011-11-30 00:36:36 +00001101 StringRef ModuleName = Path[0].first->getName();
1102 SourceLocation ModuleNameLoc = Path[0].second;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001103
Douglas Gregor1a4761e2011-11-30 23:21:26 +00001104 clang::Module *Module = 0;
Douglas Gregor3d3589d2011-11-30 00:36:36 +00001105
Douglas Gregor49009ec2011-11-30 04:03:44 +00001106 // If we don't already have information on this module, load the module now.
Douglas Gregor1a4761e2011-11-30 23:21:26 +00001107 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001108 = KnownModules.find(Path[0].first);
Douglas Gregor5e3f9222011-12-08 17:01:29 +00001109 if (Known != KnownModules.end()) {
1110 // Retrieve the cached top-level module.
1111 Module = Known->second;
1112 } else if (ModuleName == getLangOpts().CurrentModule) {
1113 // This is the module we're building.
1114 Module = PP->getHeaderSearchInfo().getModuleMap().findModule(ModuleName);
1115 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1116 } else {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001117 // Search for a module with the given name.
Douglas Gregore434ec72012-01-29 17:08:11 +00001118 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001119 std::string ModuleFileName;
Douglas Gregor8bf778e2013-02-06 22:40:31 +00001120 if (Module) {
Douglas Gregore434ec72012-01-29 17:08:11 +00001121 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module);
Douglas Gregor8bf778e2013-02-06 22:40:31 +00001122 } else
Douglas Gregore434ec72012-01-29 17:08:11 +00001123 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(ModuleName);
Douglas Gregor463d9092012-11-29 23:55:25 +00001124
Douglas Gregor49009ec2011-11-30 04:03:44 +00001125 // If we don't already have an ASTReader, create one now.
1126 if (!ModuleManager) {
1127 if (!hasASTContext())
1128 createASTContext();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +00001129
Douglas Gregord44d2872013-03-25 21:19:16 +00001130 // If we're not recursively building a module, check whether we
1131 // need to prune the module cache.
1132 if (getSourceManager().getModuleBuildStack().empty() &&
1133 getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1134 getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1135 pruneModuleCache(getHeaderSearchOpts());
1136 }
1137
Douglas Gregor49009ec2011-11-30 04:03:44 +00001138 std::string Sysroot = getHeaderSearchOpts().Sysroot;
1139 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1140 ModuleManager = new ASTReader(getPreprocessor(), *Context,
1141 Sysroot.empty() ? "" : Sysroot.c_str(),
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001142 PPOpts.DisablePCHValidation,
1143 /*AllowASTWithCompilerErrors=*/false,
1144 getFrontendOpts().UseGlobalModuleIndex);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001145 if (hasASTConsumer()) {
1146 ModuleManager->setDeserializationListener(
1147 getASTConsumer().GetASTDeserializationListener());
1148 getASTContext().setASTMutationListener(
1149 getASTConsumer().GetASTMutationListener());
1150 }
Dylan Noblesmith6f42b622012-02-05 02:12:40 +00001151 OwningPtr<ExternalASTSource> Source;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001152 Source.reset(ModuleManager);
1153 getASTContext().setExternalSource(Source);
1154 if (hasSema())
1155 ModuleManager->InitializeSema(getSema());
1156 if (hasASTConsumer())
1157 ModuleManager->StartTranslationUnit(&getASTConsumer());
Douglas Gregorde8a9052011-09-14 23:13:09 +00001158 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001159
Douglas Gregor677e15f2013-03-19 00:28:20 +00001160 // Try to load the module file.
1161 unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing;
1162 switch (ModuleManager->ReadAST(ModuleFileName, serialization::MK_Module,
1163 ImportLoc, ARRFlags)) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001164 case ASTReader::Success:
1165 break;
1166
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001167 case ASTReader::OutOfDate: {
Douglas Gregor677e15f2013-03-19 00:28:20 +00001168 // The module file is out-of-date. Remove it, then rebuild it.
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001169 bool Existed;
1170 llvm::sys::fs::remove(ModuleFileName, Existed);
Douglas Gregor677e15f2013-03-19 00:28:20 +00001171 }
1172 // Fall through to build the module again.
1173
1174 case ASTReader::Missing: {
1175 // The module file is (now) missing. Build it.
1176
1177 // If we don't have a module, we don't know how to build the module file.
1178 // Complain and return.
1179 if (!Module) {
1180 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1181 << ModuleName
1182 << SourceRange(ImportLoc, ModuleNameLoc);
1183 ModuleBuildFailed = true;
1184 return ModuleLoadResult();
1185 }
1186
1187 // Check whether there is a cycle in the module graph.
1188 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1189 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1190 for (; Pos != PosEnd; ++Pos) {
1191 if (Pos->first == ModuleName)
1192 break;
1193 }
1194
1195 if (Pos != PosEnd) {
1196 SmallString<256> CyclePath;
1197 for (; Pos != PosEnd; ++Pos) {
1198 CyclePath += Pos->first;
1199 CyclePath += " -> ";
1200 }
1201 CyclePath += ModuleName;
1202
1203 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1204 << ModuleName << CyclePath;
1205 return ModuleLoadResult();
1206 }
Douglas Gregor463d9092012-11-29 23:55:25 +00001207
1208 // Check whether we have already attempted to build this module (but
1209 // failed).
1210 if (getPreprocessorOpts().FailedModules &&
1211 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1212 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1213 << ModuleName
1214 << SourceRange(ImportLoc, ModuleNameLoc);
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001215 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001216 return ModuleLoadResult();
1217 }
1218
Douglas Gregor677e15f2013-03-19 00:28:20 +00001219 // Try to compile the module.
Douglas Gregor830ea5b2012-11-30 18:38:50 +00001220 compileModule(*this, ModuleNameLoc, Module, ModuleFileName);
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001221
Douglas Gregor677e15f2013-03-19 00:28:20 +00001222 // Try to read the module file, now that we've compiled it.
1223 ASTReader::ASTReadResult ReadResult
1224 = ModuleManager->ReadAST(ModuleFileName,
Argyrios Kyrtzidis958bcaf2012-11-15 18:57:22 +00001225 serialization::MK_Module, ImportLoc,
Douglas Gregor677e15f2013-03-19 00:28:20 +00001226 ASTReader::ARR_Missing);
1227 if (ReadResult != ASTReader::Success) {
1228 if (ReadResult == ASTReader::Missing) {
1229 getDiagnostics().Report(ModuleNameLoc,
1230 Module? diag::err_module_not_built
1231 : diag::err_module_not_found)
1232 << ModuleName
1233 << SourceRange(ImportLoc, ModuleNameLoc);
1234 }
1235
Douglas Gregorb8a8be12013-01-10 02:04:18 +00001236 if (getPreprocessorOpts().FailedModules)
1237 getPreprocessorOpts().FailedModules->addFailed(ModuleName);
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001238 KnownModules[Path[0].first] = 0;
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001239 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001240 return ModuleLoadResult();
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001241 }
1242
1243 // Okay, we've rebuilt and now loaded the module.
1244 break;
1245 }
1246
Douglas Gregor4825fd72012-10-22 22:50:17 +00001247 case ASTReader::VersionMismatch:
1248 case ASTReader::ConfigurationMismatch:
1249 case ASTReader::HadErrors:
Argyrios Kyrtzidis3b7deda2013-05-24 05:44:08 +00001250 ModuleLoader::HadFatalFailure = true;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001251 // FIXME: The ASTReader will already have complained, but can we showhorn
1252 // that diagnostic information into a more useful form?
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001253 KnownModules[Path[0].first] = 0;
Douglas Gregor463d9092012-11-29 23:55:25 +00001254 return ModuleLoadResult();
Douglas Gregor49009ec2011-11-30 04:03:44 +00001255
1256 case ASTReader::Failure:
Argyrios Kyrtzidis3b7deda2013-05-24 05:44:08 +00001257 ModuleLoader::HadFatalFailure = true;
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001258 // Already complained, but note now that we failed.
1259 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 Gregor49009ec2011-11-30 04:03:44 +00001262 }
1263
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001264 if (!Module) {
1265 // If we loaded the module directly, without finding a module map first,
1266 // we'll have loaded the module's information from the module itself.
1267 Module = PP->getHeaderSearchInfo().getModuleMap()
1268 .findModule((Path[0].first->getName()));
1269 }
Argyrios Kyrtzidise2ac16b2012-09-29 01:06:04 +00001270
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001271 // Cache the result of this top-level module lookup for later.
1272 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001273 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001274
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001275 // If we never found the module, fail.
1276 if (!Module)
Douglas Gregor463d9092012-11-29 23:55:25 +00001277 return ModuleLoadResult();
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001278
Douglas Gregor49009ec2011-11-30 04:03:44 +00001279 // Verify that the rest of the module path actually corresponds to
1280 // a submodule.
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001281 if (Path.size() > 1) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001282 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1283 StringRef Name = Path[I].first->getName();
Douglas Gregorb7a78192012-01-04 23:32:19 +00001284 clang::Module *Sub = Module->findSubmodule(Name);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001285
Douglas Gregorb7a78192012-01-04 23:32:19 +00001286 if (!Sub) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001287 // Attempt to perform typo correction to find a module name that works.
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00001288 SmallVector<StringRef, 2> Best;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001289 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1290
Douglas Gregorb7a78192012-01-04 23:32:19 +00001291 for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1292 JEnd = Module->submodule_end();
Matt Beaumont-Gaye25633f2011-11-30 19:41:21 +00001293 J != JEnd; ++J) {
Douglas Gregorb7a78192012-01-04 23:32:19 +00001294 unsigned ED = Name.edit_distance((*J)->Name,
Douglas Gregor49009ec2011-11-30 04:03:44 +00001295 /*AllowReplacements=*/true,
1296 BestEditDistance);
1297 if (ED <= BestEditDistance) {
Douglas Gregorb7a78192012-01-04 23:32:19 +00001298 if (ED < BestEditDistance) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001299 Best.clear();
Douglas Gregorb7a78192012-01-04 23:32:19 +00001300 BestEditDistance = ED;
1301 }
1302
1303 Best.push_back((*J)->Name);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001304 }
1305 }
1306
1307 // If there was a clear winner, user it.
1308 if (Best.size() == 1) {
1309 getDiagnostics().Report(Path[I].second,
1310 diag::err_no_submodule_suggest)
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001311 << Path[I].first << Module->getFullModuleName() << Best[0]
Douglas Gregor49009ec2011-11-30 04:03:44 +00001312 << SourceRange(Path[0].second, Path[I-1].second)
1313 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1314 Best[0]);
Douglas Gregorb7a78192012-01-04 23:32:19 +00001315
1316 Sub = Module->findSubmodule(Best[0]);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001317 }
1318 }
1319
Douglas Gregorb7a78192012-01-04 23:32:19 +00001320 if (!Sub) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001321 // No submodule by this name. Complain, and don't look for further
1322 // submodules.
1323 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001324 << Path[I].first << Module->getFullModuleName()
Douglas Gregor49009ec2011-11-30 04:03:44 +00001325 << SourceRange(Path[0].second, Path[I-1].second);
1326 break;
1327 }
1328
Douglas Gregorb7a78192012-01-04 23:32:19 +00001329 Module = Sub;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001330 }
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001331 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001332
Douglas Gregor5e3f9222011-12-08 17:01:29 +00001333 // Make the named module visible, if it's not already part of the module
1334 // we are parsing.
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001335 if (ModuleName != getLangOpts().CurrentModule) {
1336 if (!Module->IsFromModuleFile) {
1337 // We have an umbrella header or directory that doesn't actually include
1338 // all of the headers within the directory it covers. Complain about
1339 // this missing submodule and recover by forgetting that we ever saw
1340 // this submodule.
1341 // FIXME: Should we detect this at module load time? It seems fairly
1342 // expensive (and rare).
1343 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1344 << Module->getFullModuleName()
1345 << SourceRange(Path.front().second, Path.back().second);
1346
Douglas Gregor463d9092012-11-29 23:55:25 +00001347 return ModuleLoadResult(0, true);
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001348 }
Douglas Gregor51f564f2011-12-31 04:05:44 +00001349
1350 // Check whether this module is available.
1351 StringRef Feature;
Douglas Gregordc58aa72012-01-30 06:01:29 +00001352 if (!Module->isAvailable(getLangOpts(), getTarget(), Feature)) {
Douglas Gregor51f564f2011-12-31 04:05:44 +00001353 getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
1354 << Module->getFullModuleName()
1355 << Feature
1356 << SourceRange(Path.front().second, Path.back().second);
1357 LastModuleImportLoc = ImportLoc;
Douglas Gregor463d9092012-11-29 23:55:25 +00001358 LastModuleImportResult = ModuleLoadResult();
1359 return ModuleLoadResult();
Douglas Gregor51f564f2011-12-31 04:05:44 +00001360 }
1361
Douglas Gregor906d66a2013-03-20 21:10:35 +00001362 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc,
1363 /*Complain=*/true);
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001364 }
Douglas Gregor63a72682013-03-20 00:22:05 +00001365
1366 // Check for any configuration macros that have changed.
1367 clang::Module *TopModule = Module->getTopLevelModule();
1368 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1369 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1370 Module, ImportLoc);
1371 }
1372
Douglas Gregor93ebfa62011-12-02 23:42:12 +00001373 // If this module import was due to an inclusion directive, create an
1374 // implicit import declaration to capture it in the AST.
1375 if (IsInclusionDirective && hasASTContext()) {
1376 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
Argyrios Kyrtzidisd3d98162012-10-03 01:58:37 +00001377 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
1378 ImportLoc, Module,
1379 Path.back().second);
1380 TU->addDecl(ImportD);
1381 if (Consumer)
1382 Consumer->HandleImplicitImportDecl(ImportD);
Douglas Gregor93ebfa62011-12-02 23:42:12 +00001383 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001384
Douglas Gregorb514c792011-11-30 04:26:53 +00001385 LastModuleImportLoc = ImportLoc;
Douglas Gregor463d9092012-11-29 23:55:25 +00001386 LastModuleImportResult = ModuleLoadResult(Module, false);
1387 return LastModuleImportResult;
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001388}
Douglas Gregorca2ab452013-01-12 01:29:50 +00001389
1390void CompilerInstance::makeModuleVisible(Module *Mod,
Argyrios Kyrtzidis5ebcb202013-02-01 16:36:12 +00001391 Module::NameVisibilityKind Visibility,
Douglas Gregor906d66a2013-03-20 21:10:35 +00001392 SourceLocation ImportLoc,
1393 bool Complain){
1394 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc, Complain);
Douglas Gregorca2ab452013-01-12 01:29:50 +00001395}
1396