blob: 554ca352e1cc874ff796197fd5a2e4cb237099b8 [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"
Douglas Gregorf18d0d82010-08-12 23:31:19 +000011#include "clang/Sema/Sema.h"
Daniel Dunbar12ce6942009-11-14 02:47:17 +000012#include "clang/AST/ASTConsumer.h"
Daniel Dunbar5eb81002009-11-13 08:20:47 +000013#include "clang/AST/ASTContext.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"
Daniel Dunbar22dacfa2009-11-13 05:52:11 +000019#include "clang/Lex/HeaderSearch.h"
20#include "clang/Lex/Preprocessor.h"
21#include "clang/Lex/PTHManager.h"
David Blaikie4e85b8a2011-09-26 00:21:47 +000022#include "clang/Frontend/ChainedDiagnosticConsumer.h"
Daniel Dunbar0397af22010-01-13 00:48:06 +000023#include "clang/Frontend/FrontendAction.h"
Douglas Gregor21cae202011-09-12 23:31:24 +000024#include "clang/Frontend/FrontendActions.h"
Daniel Dunbarc2f484f2009-11-13 09:36:05 +000025#include "clang/Frontend/FrontendDiagnostic.h"
Daniel Dunbar9df23492011-04-07 18:31:10 +000026#include "clang/Frontend/LogDiagnosticPrinter.h"
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +000027#include "clang/Frontend/TextDiagnosticPrinter.h"
David Blaikie621bc692011-09-26 00:38:03 +000028#include "clang/Frontend/VerifyDiagnosticConsumer.h"
Daniel Dunbar22dacfa2009-11-13 05:52:11 +000029#include "clang/Frontend/Utils.h"
Sebastian Redl6ab7cd82010-08-18 23:57:17 +000030#include "clang/Serialization/ASTReader.h"
Daniel Dunbarc2f484f2009-11-13 09:36:05 +000031#include "clang/Sema/CodeCompleteConsumer.h"
Michael J. Spencer32bef4e2011-01-10 02:34:13 +000032#include "llvm/Support/FileSystem.h"
Daniel Dunbarccb6cb62009-11-14 07:53:04 +000033#include "llvm/Support/MemoryBuffer.h"
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +000034#include "llvm/Support/raw_ostream.h"
Douglas Gregor95dd5582010-03-30 17:33:59 +000035#include "llvm/ADT/Statistic.h"
Kovarththanan Rajaratnamf79bafa2009-11-29 09:57:35 +000036#include "llvm/Support/Timer.h"
Michael J. Spencer03013fa2010-11-29 18:12:39 +000037#include "llvm/Support/Host.h"
38#include "llvm/Support/Path.h"
39#include "llvm/Support/Program.h"
40#include "llvm/Support/Signals.h"
Michael J. Spencer3a321e22010-12-09 17:36:38 +000041#include "llvm/Support/system_error.h"
Dylan Noblesmith16266012011-06-23 12:20:57 +000042#include "llvm/Config/config.h"
Daniel Dunbar2a79e162009-11-13 03:51:44 +000043using namespace clang;
44
Daniel Dunbar42e9f8e42010-02-16 01:54:47 +000045CompilerInstance::CompilerInstance()
Douglas Gregorf62d43d2011-07-19 16:10:42 +000046 : Invocation(new CompilerInvocation()), ModuleManager(0) {
Daniel Dunbar6228ca02010-01-30 21:47:07 +000047}
Daniel Dunbar2a79e162009-11-13 03:51:44 +000048
49CompilerInstance::~CompilerInstance() {
Daniel Dunbar42e9f8e42010-02-16 01:54:47 +000050}
51
Daniel Dunbar6228ca02010-01-30 21:47:07 +000052void CompilerInstance::setInvocation(CompilerInvocation *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000053 Invocation = Value;
Daniel Dunbar6228ca02010-01-30 21:47:07 +000054}
55
David Blaikied6471f72011-09-25 23:23:43 +000056void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
Douglas Gregor28019772010-04-05 23:52:57 +000057 Diagnostics = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000058}
59
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000060void CompilerInstance::setTarget(TargetInfo *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000061 Target = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000062}
63
64void CompilerInstance::setFileManager(FileManager *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000065 FileMgr = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000066}
67
Ted Kremenek4f327862011-03-21 18:40:17 +000068void CompilerInstance::setSourceManager(SourceManager *Value) {
69 SourceMgr = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000070}
71
Ted Kremenek4f327862011-03-21 18:40:17 +000072void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; }
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000073
Ted Kremenek4f327862011-03-21 18:40:17 +000074void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; }
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000075
Douglas Gregorf18d0d82010-08-12 23:31:19 +000076void CompilerInstance::setSema(Sema *S) {
77 TheSema.reset(S);
78}
79
Daniel Dunbar12ce6942009-11-14 02:47:17 +000080void CompilerInstance::setASTConsumer(ASTConsumer *Value) {
81 Consumer.reset(Value);
82}
83
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000084void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
85 CompletionConsumer.reset(Value);
86}
87
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +000088// Diagnostics
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +000089static void SetUpBuildDumpLog(const DiagnosticOptions &DiagOpts,
Axel Naumann7d0c4cc2010-10-11 09:13:46 +000090 unsigned argc, const char* const *argv,
David Blaikied6471f72011-09-25 23:23:43 +000091 DiagnosticsEngine &Diags) {
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +000092 std::string ErrorInfo;
Chris Lattner5f9e2722011-07-23 10:55:15 +000093 llvm::OwningPtr<raw_ostream> OS(
Kovarththanan Rajaratnam69247132010-03-17 09:47:30 +000094 new llvm::raw_fd_ostream(DiagOpts.DumpBuildInformation.c_str(), ErrorInfo));
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +000095 if (!ErrorInfo.empty()) {
Kovarththanan Rajaratnam3d67b1e2010-03-17 09:24:48 +000096 Diags.Report(diag::err_fe_unable_to_open_logfile)
97 << DiagOpts.DumpBuildInformation << ErrorInfo;
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +000098 return;
99 }
100
Daniel Dunbardd63b282009-12-11 23:04:35 +0000101 (*OS) << "clang -cc1 command line arguments: ";
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000102 for (unsigned i = 0; i != argc; ++i)
103 (*OS) << argv[i] << ' ';
104 (*OS) << '\n';
105
106 // Chain in a diagnostic client which will log the diagnostics.
David Blaikie78ad0b92011-09-25 23:39:51 +0000107 DiagnosticConsumer *Logger =
Kovarththanan Rajaratnam69247132010-03-17 09:47:30 +0000108 new TextDiagnosticPrinter(*OS.take(), DiagOpts, /*OwnsOutputStream=*/true);
David Blaikie4e85b8a2011-09-26 00:21:47 +0000109 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger));
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000110}
111
Daniel Dunbar9df23492011-04-07 18:31:10 +0000112static void SetUpDiagnosticLog(const DiagnosticOptions &DiagOpts,
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000113 const CodeGenOptions *CodeGenOpts,
David Blaikied6471f72011-09-25 23:23:43 +0000114 DiagnosticsEngine &Diags) {
Daniel Dunbar9df23492011-04-07 18:31:10 +0000115 std::string ErrorInfo;
116 bool OwnsStream = false;
Chris Lattner5f9e2722011-07-23 10:55:15 +0000117 raw_ostream *OS = &llvm::errs();
Daniel Dunbar9df23492011-04-07 18:31:10 +0000118 if (DiagOpts.DiagnosticLogFile != "-") {
119 // Create the output stream.
120 llvm::raw_fd_ostream *FileOS(
121 new llvm::raw_fd_ostream(DiagOpts.DiagnosticLogFile.c_str(),
Daniel Dunbare01eceb2011-04-07 20:19:21 +0000122 ErrorInfo, llvm::raw_fd_ostream::F_Append));
Daniel Dunbar9df23492011-04-07 18:31:10 +0000123 if (!ErrorInfo.empty()) {
124 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
125 << DiagOpts.DumpBuildInformation << ErrorInfo;
126 } else {
127 FileOS->SetUnbuffered();
128 FileOS->SetUseAtomicWrites(true);
129 OS = FileOS;
130 OwnsStream = true;
131 }
132 }
133
134 // Chain in the diagnostic client which will log the diagnostics.
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000135 LogDiagnosticPrinter *Logger = new LogDiagnosticPrinter(*OS, DiagOpts,
136 OwnsStream);
137 if (CodeGenOpts)
138 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
David Blaikie4e85b8a2011-09-26 00:21:47 +0000139 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger));
Daniel Dunbar9df23492011-04-07 18:31:10 +0000140}
141
Douglas Gregore47be3e2010-11-11 00:39:14 +0000142void CompilerInstance::createDiagnostics(int Argc, const char* const *Argv,
David Blaikie78ad0b92011-09-25 23:39:51 +0000143 DiagnosticConsumer *Client,
Douglas Gregoraee526e2011-09-29 00:38:00 +0000144 bool ShouldOwnClient,
145 bool ShouldCloneClient) {
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000146 Diagnostics = createDiagnostics(getDiagnosticOpts(), Argc, Argv, Client,
Douglas Gregoraee526e2011-09-29 00:38:00 +0000147 ShouldOwnClient, ShouldCloneClient,
148 &getCodeGenOpts());
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000149}
150
David Blaikied6471f72011-09-25 23:23:43 +0000151llvm::IntrusiveRefCntPtr<DiagnosticsEngine>
Douglas Gregor28019772010-04-05 23:52:57 +0000152CompilerInstance::createDiagnostics(const DiagnosticOptions &Opts,
Douglas Gregore47be3e2010-11-11 00:39:14 +0000153 int Argc, const char* const *Argv,
David Blaikie78ad0b92011-09-25 23:39:51 +0000154 DiagnosticConsumer *Client,
Douglas Gregor78243652011-09-13 01:26:44 +0000155 bool ShouldOwnClient,
Douglas Gregoraee526e2011-09-29 00:38:00 +0000156 bool ShouldCloneClient,
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000157 const CodeGenOptions *CodeGenOpts) {
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +0000158 llvm::IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
David Blaikied6471f72011-09-25 23:23:43 +0000159 llvm::IntrusiveRefCntPtr<DiagnosticsEngine>
160 Diags(new DiagnosticsEngine(DiagID));
Daniel Dunbar221c7212009-11-14 07:53:24 +0000161
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000162 // Create the diagnostic client for reporting errors or for
163 // implementing -verify.
Douglas Gregoraee526e2011-09-29 00:38:00 +0000164 if (Client) {
165 if (ShouldCloneClient)
166 Diags->setClient(Client->clone(*Diags), ShouldOwnClient);
167 else
168 Diags->setClient(Client, ShouldOwnClient);
169 } else
Douglas Gregore47be3e2010-11-11 00:39:14 +0000170 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
Daniel Dunbarf79dced2009-11-14 03:24:39 +0000171
172 // Chain in -verify checker, if requested.
Douglas Gregor78243652011-09-13 01:26:44 +0000173 if (Opts.VerifyDiagnostics)
David Blaikie621bc692011-09-26 00:38:03 +0000174 Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000175
Daniel Dunbar9df23492011-04-07 18:31:10 +0000176 // Chain in -diagnostic-log-file dumper, if requested.
177 if (!Opts.DiagnosticLogFile.empty())
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000178 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
Daniel Dunbar9df23492011-04-07 18:31:10 +0000179
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000180 if (!Opts.DumpBuildInformation.empty())
Kovarththanan Rajaratnam3d67b1e2010-03-17 09:24:48 +0000181 SetUpBuildDumpLog(Opts, Argc, Argv, *Diags);
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000182
183 // Configure our handling of diagnostics.
Kovarththanan Rajaratnam5bf932b2010-03-17 09:36:02 +0000184 ProcessWarningOptions(*Diags, Opts);
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000185
Douglas Gregor28019772010-04-05 23:52:57 +0000186 return Diags;
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000187}
188
189// File Manager
190
Daniel Dunbar16b74492009-11-13 04:12:06 +0000191void CompilerInstance::createFileManager() {
Ted Kremenek4f327862011-03-21 18:40:17 +0000192 FileMgr = new FileManager(getFileSystemOpts());
Daniel Dunbar16b74492009-11-13 04:12:06 +0000193}
194
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000195// Source Manager
196
Chris Lattner39b49bc2010-11-23 08:35:12 +0000197void CompilerInstance::createSourceManager(FileManager &FileMgr) {
Ted Kremenek4f327862011-03-21 18:40:17 +0000198 SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
Daniel Dunbar16b74492009-11-13 04:12:06 +0000199}
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000200
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000201// Preprocessor
202
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000203void CompilerInstance::createPreprocessor() {
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000204 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
205
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000206 // Create a PTH manager if we are using some form of a token cache.
207 PTHManager *PTHMgr = 0;
Daniel Dunbar049d3a02009-11-17 05:52:41 +0000208 if (!PPOpts.TokenCache.empty())
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000209 PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
210
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000211 // Create the Preprocessor.
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000212 HeaderSearch *HeaderInfo = new HeaderSearch(getFileManager());
Douglas Gregor998b3d32011-09-01 23:39:15 +0000213 PP = new Preprocessor(getDiagnostics(), getLangOpts(), &getTarget(),
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000214 getSourceManager(), *HeaderInfo, *this, PTHMgr,
215 /*OwnsHeaderSearch=*/true);
216
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000217 // Note that this is different then passing PTHMgr to Preprocessor's ctor.
218 // That argument is used as the IdentifierInfoLookup argument to
219 // IdentifierTable's ctor.
220 if (PTHMgr) {
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000221 PTHMgr->setPreprocessor(&*PP);
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000222 PP->setPTHManager(PTHMgr);
223 }
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000224
Douglas Gregor94dc8f62010-03-19 16:15:56 +0000225 if (PPOpts.DetailedRecord)
Douglas Gregordca8ee82011-05-06 16:33:08 +0000226 PP->createPreprocessingRecord(
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000227 PPOpts.DetailedRecordIncludesNestedMacroExpansions);
Douglas Gregor94dc8f62010-03-19 16:15:56 +0000228
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000229 InitializePreprocessor(*PP, PPOpts, getHeaderSearchOpts(), getFrontendOpts());
230
Douglas Gregor6e975c42011-09-13 23:15:45 +0000231 // Set up the module path, including the hash for the
232 // module-creation options.
233 llvm::SmallString<256> SpecificModuleCache(
234 getHeaderSearchOpts().ModuleCachePath);
235 if (!getHeaderSearchOpts().DisableModuleHash)
236 llvm::sys::path::append(SpecificModuleCache,
237 getInvocation().getModuleHash());
Douglas Gregorfba18aa2011-09-15 22:00:41 +0000238 PP->getHeaderSearchInfo().configureModules(SpecificModuleCache,
239 getPreprocessorOpts().ModuleBuildPath.empty()
240 ? std::string()
241 : getPreprocessorOpts().ModuleBuildPath.back());
Douglas Gregor6e975c42011-09-13 23:15:45 +0000242
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000243 // Handle generating dependencies, if requested.
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000244 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000245 if (!DepOpts.OutputFile.empty())
246 AttachDependencyFileGen(*PP, DepOpts);
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000247
Daniel Dunbareef63e02011-02-02 15:41:17 +0000248 // Handle generating header include information, if requested.
249 if (DepOpts.ShowHeaderIncludes)
250 AttachHeaderIncludeGen(*PP);
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000251 if (!DepOpts.HeaderIncludeOutputFile.empty()) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000252 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000253 if (OutputPath == "-")
254 OutputPath = "";
Daniel Dunbarda608852011-03-21 19:37:38 +0000255 AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath,
256 /*ShowDepth=*/false);
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000257 }
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000258}
Daniel Dunbar5eb81002009-11-13 08:20:47 +0000259
260// ASTContext
261
262void CompilerInstance::createASTContext() {
263 Preprocessor &PP = getPreprocessor();
Ted Kremenek4f327862011-03-21 18:40:17 +0000264 Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000265 &getTarget(), PP.getIdentifierTable(),
Ted Kremenek4f327862011-03-21 18:40:17 +0000266 PP.getSelectorTable(), PP.getBuiltinInfo(),
267 /*size_reserve=*/ 0);
Daniel Dunbar5eb81002009-11-13 08:20:47 +0000268}
Daniel Dunbar0f800392009-11-13 08:21:10 +0000269
270// ExternalASTSource
271
Chris Lattner5f9e2722011-07-23 10:55:15 +0000272void CompilerInstance::createPCHExternalASTSource(StringRef Path,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000273 bool DisablePCHValidation,
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +0000274 bool DisableStatCache,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000275 void *DeserializationListener){
Daniel Dunbar0f800392009-11-13 08:21:10 +0000276 llvm::OwningPtr<ExternalASTSource> Source;
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +0000277 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
Daniel Dunbar0f800392009-11-13 08:21:10 +0000278 Source.reset(createPCHExternalASTSource(Path, getHeaderSearchOpts().Sysroot,
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +0000279 DisablePCHValidation,
280 DisableStatCache,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000281 getPreprocessor(), getASTContext(),
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +0000282 DeserializationListener,
283 Preamble));
Douglas Gregorf62d43d2011-07-19 16:10:42 +0000284 ModuleManager = static_cast<ASTReader*>(Source.get());
Daniel Dunbar0f800392009-11-13 08:21:10 +0000285 getASTContext().setExternalSource(Source);
286}
287
288ExternalASTSource *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000289CompilerInstance::createPCHExternalASTSource(StringRef Path,
Daniel Dunbar0f800392009-11-13 08:21:10 +0000290 const std::string &Sysroot,
Douglas Gregorfae3b2f2010-07-27 00:27:13 +0000291 bool DisablePCHValidation,
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +0000292 bool DisableStatCache,
Daniel Dunbar0f800392009-11-13 08:21:10 +0000293 Preprocessor &PP,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000294 ASTContext &Context,
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +0000295 void *DeserializationListener,
296 bool Preamble) {
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000297 llvm::OwningPtr<ASTReader> Reader;
Douglas Gregorf8a1e512011-09-02 00:26:20 +0000298 Reader.reset(new ASTReader(PP, Context,
Douglas Gregor832d6202011-07-22 16:35:34 +0000299 Sysroot.empty() ? "" : Sysroot.c_str(),
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +0000300 DisablePCHValidation, DisableStatCache));
Daniel Dunbar0f800392009-11-13 08:21:10 +0000301
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000302 Reader->setDeserializationListener(
Sebastian Redl571db7f2010-08-18 23:56:56 +0000303 static_cast<ASTDeserializationListener *>(DeserializationListener));
Douglas Gregor72a9ae12011-07-22 16:00:58 +0000304 switch (Reader->ReadAST(Path,
305 Preamble ? serialization::MK_Preamble
306 : serialization::MK_PCH)) {
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000307 case ASTReader::Success:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000308 // Set the predefines buffer as suggested by the PCH reader. Typically, the
309 // predefines buffer will be empty.
310 PP.setPredefines(Reader->getSuggestedPredefines());
311 return Reader.take();
312
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000313 case ASTReader::Failure:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000314 // Unrecoverable failure: don't even try to process the input file.
315 break;
316
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000317 case ASTReader::IgnorePCH:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000318 // No suitable PCH file could be found. Return an error.
319 break;
320 }
321
322 return 0;
323}
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000324
325// Code Completion
326
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000327static bool EnableCodeCompletion(Preprocessor &PP,
328 const std::string &Filename,
329 unsigned Line,
330 unsigned Column) {
331 // Tell the source manager to chop off the given file at a specific
332 // line and column.
Chris Lattner39b49bc2010-11-23 08:35:12 +0000333 const FileEntry *Entry = PP.getFileManager().getFile(Filename);
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000334 if (!Entry) {
335 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
336 << Filename;
337 return true;
338 }
339
340 // Truncate the named file at the given line/column.
341 PP.SetCodeCompletionPoint(Entry, Line, Column);
342 return false;
343}
344
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000345void CompilerInstance::createCodeCompletionConsumer() {
346 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000347 if (!CompletionConsumer) {
348 CompletionConsumer.reset(
349 createCodeCompletionConsumer(getPreprocessor(),
350 Loc.FileName, Loc.Line, Loc.Column,
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000351 getFrontendOpts().ShowMacrosInCodeCompletion,
Douglas Gregord8e8a582010-05-25 21:41:55 +0000352 getFrontendOpts().ShowCodePatternsInCodeCompletion,
Douglas Gregor8071e422010-08-15 06:18:01 +0000353 getFrontendOpts().ShowGlobalSymbolsInCodeCompletion,
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000354 llvm::outs()));
355 if (!CompletionConsumer)
356 return;
357 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
358 Loc.Line, Loc.Column)) {
359 CompletionConsumer.reset();
Douglas Gregorc3d43b72010-03-16 06:04:47 +0000360 return;
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000361 }
Douglas Gregor2b4074f2009-12-01 05:55:20 +0000362
363 if (CompletionConsumer->isOutputBinary() &&
364 llvm::sys::Program::ChangeStdoutToBinary()) {
365 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
366 CompletionConsumer.reset();
367 }
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000368}
369
Kovarththanan Rajaratnamf79bafa2009-11-29 09:57:35 +0000370void CompilerInstance::createFrontendTimer() {
371 FrontendTimer.reset(new llvm::Timer("Clang front-end timer"));
372}
373
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000374CodeCompleteConsumer *
375CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
376 const std::string &Filename,
377 unsigned Line,
378 unsigned Column,
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000379 bool ShowMacros,
Douglas Gregord8e8a582010-05-25 21:41:55 +0000380 bool ShowCodePatterns,
Douglas Gregor8071e422010-08-15 06:18:01 +0000381 bool ShowGlobals,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000382 raw_ostream &OS) {
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000383 if (EnableCodeCompletion(PP, Filename, Line, Column))
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000384 return 0;
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000385
386 // Set up the creation routine for code-completion.
Douglas Gregora9f4f622010-10-11 22:12:15 +0000387 return new PrintingCodeCompleteConsumer(ShowMacros, ShowCodePatterns,
Douglas Gregor8071e422010-08-15 06:18:01 +0000388 ShowGlobals, OS);
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000389}
Daniel Dunbara9204832009-11-13 10:37:48 +0000390
Douglas Gregor467dc882011-08-25 22:30:56 +0000391void CompilerInstance::createSema(TranslationUnitKind TUKind,
Douglas Gregorf18d0d82010-08-12 23:31:19 +0000392 CodeCompleteConsumer *CompletionConsumer) {
393 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
Douglas Gregor467dc882011-08-25 22:30:56 +0000394 TUKind, CompletionConsumer));
Douglas Gregorf18d0d82010-08-12 23:31:19 +0000395}
396
Daniel Dunbara9204832009-11-13 10:37:48 +0000397// Output Files
398
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000399void CompilerInstance::addOutputFile(const OutputFile &OutFile) {
400 assert(OutFile.OS && "Attempt to add empty stream to output list!");
401 OutputFiles.push_back(OutFile);
Daniel Dunbara9204832009-11-13 10:37:48 +0000402}
403
Kovarththanan Rajaratname51dd7b2010-03-06 12:07:48 +0000404void CompilerInstance::clearOutputFiles(bool EraseFiles) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000405 for (std::list<OutputFile>::iterator
Daniel Dunbara9204832009-11-13 10:37:48 +0000406 it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000407 delete it->OS;
408 if (!it->TempFilename.empty()) {
Anders Carlssonaf036a62011-03-06 22:25:35 +0000409 if (EraseFiles) {
410 bool existed;
411 llvm::sys::fs::remove(it->TempFilename, existed);
412 } else {
413 llvm::SmallString<128> NewOutFile(it->Filename);
414
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +0000415 // If '-working-directory' was passed, the output filename should be
416 // relative to that.
Anders Carlsson2e2468e2011-03-14 01:13:54 +0000417 FileMgr->FixupRelativePath(NewOutFile);
Anders Carlssonaf036a62011-03-06 22:25:35 +0000418 if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename,
419 NewOutFile.str())) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000420 getDiagnostics().Report(diag::err_fe_unable_to_rename_temp)
Anders Carlssonaf036a62011-03-06 22:25:35 +0000421 << it->TempFilename << it->Filename << ec.message();
422
423 bool existed;
424 llvm::sys::fs::remove(it->TempFilename, existed);
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000425 }
426 }
427 } else if (!it->Filename.empty() && EraseFiles)
428 llvm::sys::Path(it->Filename).eraseFromDisk();
429
Daniel Dunbara9204832009-11-13 10:37:48 +0000430 }
431 OutputFiles.clear();
432}
433
Daniel Dunbarf482d592009-11-13 18:32:08 +0000434llvm::raw_fd_ostream *
435CompilerInstance::createDefaultOutputFile(bool Binary,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000436 StringRef InFile,
437 StringRef Extension) {
Daniel Dunbarf482d592009-11-13 18:32:08 +0000438 return createOutputFile(getFrontendOpts().OutputFile, Binary,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000439 /*RemoveFileOnSignal=*/true, InFile, Extension);
Daniel Dunbarf482d592009-11-13 18:32:08 +0000440}
441
442llvm::raw_fd_ostream *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000443CompilerInstance::createOutputFile(StringRef OutputPath,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000444 bool Binary, bool RemoveFileOnSignal,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000445 StringRef InFile,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000446 StringRef Extension,
447 bool UseTemporary) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000448 std::string Error, OutputPathName, TempPathName;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000449 llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000450 RemoveFileOnSignal,
Daniel Dunbarf482d592009-11-13 18:32:08 +0000451 InFile, Extension,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000452 UseTemporary,
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000453 &OutputPathName,
454 &TempPathName);
Daniel Dunbarf482d592009-11-13 18:32:08 +0000455 if (!OS) {
Daniel Dunbar36043592009-12-03 09:13:30 +0000456 getDiagnostics().Report(diag::err_fe_unable_to_open_output)
457 << OutputPath << Error;
458 return 0;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000459 }
460
461 // Add the output file -- but don't try to remove "-", since this means we are
462 // using stdin.
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000463 addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "",
464 TempPathName, OS));
Daniel Dunbarf482d592009-11-13 18:32:08 +0000465
466 return OS;
467}
468
469llvm::raw_fd_ostream *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000470CompilerInstance::createOutputFile(StringRef OutputPath,
Daniel Dunbarf482d592009-11-13 18:32:08 +0000471 std::string &Error,
472 bool Binary,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000473 bool RemoveFileOnSignal,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000474 StringRef InFile,
475 StringRef Extension,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000476 bool UseTemporary,
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000477 std::string *ResultPathName,
478 std::string *TempPathName) {
479 std::string OutFile, TempFile;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000480 if (!OutputPath.empty()) {
481 OutFile = OutputPath;
482 } else if (InFile == "-") {
483 OutFile = "-";
484 } else if (!Extension.empty()) {
485 llvm::sys::Path Path(InFile);
486 Path.eraseSuffix();
487 Path.appendSuffix(Extension);
488 OutFile = Path.str();
489 } else {
490 OutFile = "-";
491 }
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000492
493 llvm::OwningPtr<llvm::raw_fd_ostream> OS;
494 std::string OSFile;
495
496 if (UseTemporary && OutFile != "-") {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000497 llvm::sys::Path OutPath(OutFile);
498 // Only create the temporary if we can actually write to OutPath, otherwise
499 // we want to fail early.
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000500 bool Exists;
501 if ((llvm::sys::fs::exists(OutPath.str(), Exists) || !Exists) ||
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000502 (OutPath.isRegularFile() && OutPath.canWrite())) {
503 // Create a temporary file.
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000504 llvm::SmallString<128> TempPath;
505 TempPath = OutFile;
506 TempPath += "-%%%%%%%%";
507 int fd;
508 if (llvm::sys::fs::unique_file(TempPath.str(), fd, TempPath,
509 /*makeAbsolute=*/false) == llvm::errc::success) {
510 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
511 OSFile = TempFile = TempPath.str();
512 }
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000513 }
514 }
515
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000516 if (!OS) {
517 OSFile = OutFile;
518 OS.reset(
519 new llvm::raw_fd_ostream(OSFile.c_str(), Error,
520 (Binary ? llvm::raw_fd_ostream::F_Binary : 0)));
521 if (!Error.empty())
522 return 0;
523 }
Daniel Dunbarf482d592009-11-13 18:32:08 +0000524
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000525 // Make sure the out stream file gets removed if we crash.
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000526 if (RemoveFileOnSignal)
527 llvm::sys::RemoveFileOnSignal(llvm::sys::Path(OSFile));
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000528
Daniel Dunbarf482d592009-11-13 18:32:08 +0000529 if (ResultPathName)
530 *ResultPathName = OutFile;
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000531 if (TempPathName)
532 *TempPathName = TempFile;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000533
Daniel Dunbarfc971022009-11-20 22:32:38 +0000534 return OS.take();
Daniel Dunbarf482d592009-11-13 18:32:08 +0000535}
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000536
537// Initialization Utilities
538
Chris Lattner5f9e2722011-07-23 10:55:15 +0000539bool CompilerInstance::InitializeSourceManager(StringRef InputFile) {
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000540 return InitializeSourceManager(InputFile, getDiagnostics(), getFileManager(),
541 getSourceManager(), getFrontendOpts());
542}
543
Chris Lattner5f9e2722011-07-23 10:55:15 +0000544bool CompilerInstance::InitializeSourceManager(StringRef InputFile,
David Blaikied6471f72011-09-25 23:23:43 +0000545 DiagnosticsEngine &Diags,
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000546 FileManager &FileMgr,
547 SourceManager &SourceMgr,
548 const FrontendOptions &Opts) {
Argyrios Kyrtzidis507097e2011-09-19 20:40:35 +0000549 // Figure out where to get and map in the main file.
550 if (InputFile != "-") {
Chris Lattner39b49bc2010-11-23 08:35:12 +0000551 const FileEntry *File = FileMgr.getFile(InputFile);
Dan Gohman694137c2010-10-26 21:13:51 +0000552 if (!File) {
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000553 Diags.Report(diag::err_fe_error_reading) << InputFile;
554 return false;
555 }
Dan Gohman694137c2010-10-26 21:13:51 +0000556 SourceMgr.createMainFileID(File);
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000557 } else {
Michael J. Spencer4eeebc42010-12-16 03:28:14 +0000558 llvm::OwningPtr<llvm::MemoryBuffer> SB;
559 if (llvm::MemoryBuffer::getSTDIN(SB)) {
Michael J. Spencer3a321e22010-12-09 17:36:38 +0000560 // FIXME: Give ec.message() in this diag.
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000561 Diags.Report(diag::err_fe_error_reading_stdin);
562 return false;
563 }
Dan Gohman90d90812010-10-26 23:21:25 +0000564 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
Chris Lattner39b49bc2010-11-23 08:35:12 +0000565 SB->getBufferSize(), 0);
Dan Gohman90d90812010-10-26 23:21:25 +0000566 SourceMgr.createMainFileID(File);
Michael J. Spencer4eeebc42010-12-16 03:28:14 +0000567 SourceMgr.overrideFileContents(File, SB.take());
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000568 }
569
Dan Gohman694137c2010-10-26 21:13:51 +0000570 assert(!SourceMgr.getMainFileID().isInvalid() &&
571 "Couldn't establish MainFileID!");
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000572 return true;
573}
Daniel Dunbar0397af22010-01-13 00:48:06 +0000574
575// High-Level Operations
576
577bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
578 assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
579 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
580 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
581
582 // FIXME: Take this as an argument, once all the APIs we used have moved to
583 // taking it as an input instead of hard-coding llvm::errs.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000584 raw_ostream &OS = llvm::errs();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000585
586 // Create the target instance.
587 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), getTargetOpts()));
588 if (!hasTarget())
589 return false;
590
591 // Inform the target of the language options.
592 //
593 // FIXME: We shouldn't need to do this, the target should be immutable once
594 // created. This complexity should be lifted elsewhere.
595 getTarget().setForcedLangOptions(getLangOpts());
596
597 // Validate/process some options.
598 if (getHeaderSearchOpts().Verbose)
599 OS << "clang -cc1 version " CLANG_VERSION_STRING
600 << " based upon " << PACKAGE_STRING
601 << " hosted on " << llvm::sys::getHostTriple() << "\n";
602
603 if (getFrontendOpts().ShowTimers)
604 createFrontendTimer();
605
Douglas Gregor95dd5582010-03-30 17:33:59 +0000606 if (getFrontendOpts().ShowStats)
607 llvm::EnableStatistics();
608
Daniel Dunbar0397af22010-01-13 00:48:06 +0000609 for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) {
610 const std::string &InFile = getFrontendOpts().Inputs[i].second;
611
Daniel Dunbar20560482010-06-07 23:23:50 +0000612 // Reset the ID tables if we are reusing the SourceManager.
613 if (hasSourceManager())
614 getSourceManager().clearIDTables();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000615
Daniel Dunbard3598a62010-06-07 23:23:06 +0000616 if (Act.BeginSourceFile(*this, InFile, getFrontendOpts().Inputs[i].first)) {
Daniel Dunbar0397af22010-01-13 00:48:06 +0000617 Act.Execute();
618 Act.EndSourceFile();
619 }
620 }
621
Chris Lattner53eee7b2010-04-07 18:47:42 +0000622 if (getDiagnosticOpts().ShowCarets) {
Argyrios Kyrtzidisf2224d82010-11-18 20:06:46 +0000623 // We can have multiple diagnostics sharing one diagnostic client.
624 // Get the total number of warnings/errors from the client.
625 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
626 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
Chris Lattner53eee7b2010-04-07 18:47:42 +0000627
628 if (NumWarnings)
629 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
630 if (NumWarnings && NumErrors)
631 OS << " and ";
632 if (NumErrors)
633 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
634 if (NumWarnings || NumErrors)
635 OS << " generated.\n";
636 }
Daniel Dunbar0397af22010-01-13 00:48:06 +0000637
Daniel Dunbar20560482010-06-07 23:23:50 +0000638 if (getFrontendOpts().ShowStats && hasFileManager()) {
Daniel Dunbar0397af22010-01-13 00:48:06 +0000639 getFileManager().PrintStats();
640 OS << "\n";
641 }
642
Argyrios Kyrtzidisab41b972010-11-18 21:13:57 +0000643 return !getDiagnostics().getClient()->getNumErrors();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000644}
645
Douglas Gregor21cae202011-09-12 23:31:24 +0000646/// \brief Determine the appropriate source input kind based on language
647/// options.
648static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
649 if (LangOpts.OpenCL)
650 return IK_OpenCL;
651 if (LangOpts.CUDA)
652 return IK_CUDA;
653 if (LangOpts.ObjC1)
654 return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
655 return LangOpts.CPlusPlus? IK_CXX : IK_C;
656}
657
658/// \brief Compile a module file for the given module name with the given
659/// umbrella header, using the options provided by the importing compiler
660/// instance.
661static void compileModule(CompilerInstance &ImportingInstance,
662 StringRef ModuleName,
Douglas Gregor6e975c42011-09-13 23:15:45 +0000663 StringRef ModuleFileName,
Douglas Gregor21cae202011-09-12 23:31:24 +0000664 StringRef UmbrellaHeader) {
Douglas Gregor21cae202011-09-12 23:31:24 +0000665 // Construct a compiler invocation for creating this module.
666 llvm::IntrusiveRefCntPtr<CompilerInvocation> Invocation
667 (new CompilerInvocation(ImportingInstance.getInvocation()));
Douglas Gregorb2d39c22011-09-15 20:53:28 +0000668
669 // For any options that aren't intended to affect how a module is built,
670 // reset them to their default values.
Douglas Gregor1c7e0472011-09-13 20:44:41 +0000671 Invocation->getLangOpts().resetNonModularOptions();
672 Invocation->getPreprocessorOpts().resetNonModularOptions();
Douglas Gregorb2d39c22011-09-15 20:53:28 +0000673
674 // Note that this module is part of the module build path, so that we
675 // can detect cycles in the module graph.
Douglas Gregor4ebd45f2011-09-15 20:40:10 +0000676 Invocation->getPreprocessorOpts().ModuleBuildPath.push_back(ModuleName);
Douglas Gregor1c7e0472011-09-13 20:44:41 +0000677
Douglas Gregorb2d39c22011-09-15 20:53:28 +0000678 // Set up the inputs/outputs so that we build the module from its umbrella
679 // header.
Douglas Gregor21cae202011-09-12 23:31:24 +0000680 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
Douglas Gregor6e975c42011-09-13 23:15:45 +0000681 FrontendOpts.OutputFile = ModuleFileName.str();
Douglas Gregor21cae202011-09-12 23:31:24 +0000682 FrontendOpts.DisableFree = false;
683 FrontendOpts.Inputs.clear();
684 FrontendOpts.Inputs.push_back(
685 std::make_pair(getSourceInputKindFromOptions(Invocation->getLangOpts()),
686 UmbrellaHeader));
Douglas Gregor78243652011-09-13 01:26:44 +0000687
688 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
689
Douglas Gregor4ebd45f2011-09-15 20:40:10 +0000690
Douglas Gregor76d991e2011-09-13 23:20:27 +0000691 assert(ImportingInstance.getInvocation().getModuleHash() ==
692 Invocation->getModuleHash() && "Module hash mismatch!");
Douglas Gregor21cae202011-09-12 23:31:24 +0000693
694 // Construct a compiler instance that will be used to actually create the
695 // module.
696 CompilerInstance Instance;
697 Instance.setInvocation(&*Invocation);
Douglas Gregor78243652011-09-13 01:26:44 +0000698 Instance.createDiagnostics(/*argc=*/0, /*argv=*/0,
699 &ImportingInstance.getDiagnosticClient(),
Douglas Gregoraee526e2011-09-29 00:38:00 +0000700 /*ShouldOwnClient=*/true,
701 /*ShouldCloneClient=*/true);
Douglas Gregor21cae202011-09-12 23:31:24 +0000702
703 // Construct a module-generating action.
704 GeneratePCHAction CreateModuleAction(true);
705
706 // Execute the action to actually build the module in-place.
707 // FIXME: Need to synchronize when multiple processes do this.
708 Instance.ExecuteAction(CreateModuleAction);
Douglas Gregor78243652011-09-13 01:26:44 +0000709}
Douglas Gregor21cae202011-09-12 23:31:24 +0000710
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000711ModuleKey CompilerInstance::loadModule(SourceLocation ImportLoc,
712 IdentifierInfo &ModuleName,
713 SourceLocation ModuleNameLoc) {
714 // Determine what file we're searching from.
715 SourceManager &SourceMgr = getSourceManager();
716 SourceLocation ExpandedImportLoc = SourceMgr.getExpansionLoc(ImportLoc);
717 const FileEntry *CurFile
718 = SourceMgr.getFileEntryForID(SourceMgr.getFileID(ExpandedImportLoc));
719 if (!CurFile)
720 CurFile = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID());
721
722 // Search for a module with the given name.
Douglas Gregor21cae202011-09-12 23:31:24 +0000723 std::string UmbrellaHeader;
Douglas Gregor6e975c42011-09-13 23:15:45 +0000724 std::string ModuleFileName;
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000725 const FileEntry *ModuleFile
Douglas Gregor21cae202011-09-12 23:31:24 +0000726 = PP->getHeaderSearchInfo().lookupModule(ModuleName.getName(),
Douglas Gregor6e975c42011-09-13 23:15:45 +0000727 &ModuleFileName,
Douglas Gregor21cae202011-09-12 23:31:24 +0000728 &UmbrellaHeader);
729
730 bool BuildingModule = false;
731 if (!ModuleFile && !UmbrellaHeader.empty()) {
732 // We didn't find the module, but there is an umbrella header that
733 // can be used to create the module file. Create a separate compilation
734 // module to do so.
Douglas Gregor4ebd45f2011-09-15 20:40:10 +0000735
736 // Check whether there is a cycle in the module graph.
737 SmallVectorImpl<std::string> &ModuleBuildPath
738 = getPreprocessorOpts().ModuleBuildPath;
739 SmallVectorImpl<std::string>::iterator Pos
740 = std::find(ModuleBuildPath.begin(), ModuleBuildPath.end(),
741 ModuleName.getName());
742 if (Pos != ModuleBuildPath.end()) {
743 llvm::SmallString<256> CyclePath;
744 for (; Pos != ModuleBuildPath.end(); ++Pos) {
745 CyclePath += *Pos;
746 CyclePath += " -> ";
747 }
748 CyclePath += ModuleName.getName();
749
750 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
751 << ModuleName.getName() << CyclePath;
752 return 0;
753 }
754
Douglas Gregor21cae202011-09-12 23:31:24 +0000755 BuildingModule = true;
Douglas Gregor6e975c42011-09-13 23:15:45 +0000756 compileModule(*this, ModuleName.getName(), ModuleFileName, UmbrellaHeader);
Douglas Gregor21cae202011-09-12 23:31:24 +0000757 ModuleFile = PP->getHeaderSearchInfo().lookupModule(ModuleName.getName());
758 }
759
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000760 if (!ModuleFile) {
Douglas Gregor21cae202011-09-12 23:31:24 +0000761 getDiagnostics().Report(ModuleNameLoc,
762 BuildingModule? diag::err_module_not_built
763 : diag::err_module_not_found)
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000764 << ModuleName.getName()
765 << SourceRange(ImportLoc, ModuleNameLoc);
766 return 0;
767 }
768
769 // If we don't already have an ASTReader, create one now.
770 if (!ModuleManager) {
Douglas Gregorde8a9052011-09-14 23:13:09 +0000771 if (!hasASTContext())
772 createASTContext();
773
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000774 std::string Sysroot = getHeaderSearchOpts().Sysroot;
775 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
Douglas Gregorf8a1e512011-09-02 00:26:20 +0000776 ModuleManager = new ASTReader(getPreprocessor(), *Context,
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000777 Sysroot.empty() ? "" : Sysroot.c_str(),
778 PPOpts.DisablePCHValidation,
779 PPOpts.DisableStatCache);
Douglas Gregorde8a9052011-09-14 23:13:09 +0000780 if (hasASTConsumer()) {
781 ModuleManager->setDeserializationListener(
782 getASTConsumer().GetASTDeserializationListener());
783 getASTContext().setASTMutationListener(
784 getASTConsumer().GetASTMutationListener());
785 }
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000786 llvm::OwningPtr<ExternalASTSource> Source;
787 Source.reset(ModuleManager);
788 getASTContext().setExternalSource(Source);
Douglas Gregorde8a9052011-09-14 23:13:09 +0000789 if (hasSema())
790 ModuleManager->InitializeSema(getSema());
Douglas Gregor1a995dd2011-09-15 18:47:32 +0000791 if (hasASTConsumer())
792 ModuleManager->StartTranslationUnit(&getASTConsumer());
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000793 }
794
795 // Try to load the module we found.
796 switch (ModuleManager->ReadAST(ModuleFile->getName(),
797 serialization::MK_Module)) {
798 case ASTReader::Success:
799 break;
800
801 case ASTReader::IgnorePCH:
802 // FIXME: The ASTReader will already have complained, but can we showhorn
803 // that diagnostic information into a more useful form?
804 return 0;
805
806 case ASTReader::Failure:
807 // Already complained.
808 return 0;
809 }
810
811 // FIXME: The module file's FileEntry makes a poor key indeed!
812 return (ModuleKey)ModuleFile;
813}
Daniel Dunbar0397af22010-01-13 00:48:06 +0000814