blob: f83c8704f67705aa2918dd1568225bf66fee6449 [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 Gregor2bc75072011-10-05 14:53:30 +000047
Daniel Dunbar2a79e162009-11-13 03:51:44 +000048using namespace clang;
49
Daniel Dunbar42e9f8e42010-02-16 01:54:47 +000050CompilerInstance::CompilerInstance()
Douglas Gregora6b00fc2013-01-23 22:38:11 +000051 : Invocation(new CompilerInvocation()), ModuleManager(0),
Douglas Gregorf575d6e2013-01-25 00:45:27 +000052 BuildGlobalModuleIndex(false), ModuleBuildFailed(false) {
Daniel Dunbar6228ca02010-01-30 21:47:07 +000053}
Daniel Dunbar2a79e162009-11-13 03:51:44 +000054
55CompilerInstance::~CompilerInstance() {
Benjamin Kramerac447fc2012-10-14 19:21:21 +000056 assert(OutputFiles.empty() && "Still output files in flight?");
Daniel Dunbar42e9f8e42010-02-16 01:54:47 +000057}
58
Daniel Dunbar6228ca02010-01-30 21:47:07 +000059void CompilerInstance::setInvocation(CompilerInvocation *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000060 Invocation = Value;
Daniel Dunbar6228ca02010-01-30 21:47:07 +000061}
62
Douglas Gregorf575d6e2013-01-25 00:45:27 +000063bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
Douglas Gregor1a49d972013-01-25 01:03:03 +000064 return (BuildGlobalModuleIndex ||
Douglas Gregored2fc2a2013-03-22 21:26:48 +000065 (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
66 getFrontendOpts().GenerateGlobalModuleIndex)) &&
Douglas Gregor1a49d972013-01-25 01:03:03 +000067 !ModuleBuildFailed;
Douglas Gregorf575d6e2013-01-25 00:45:27 +000068}
69
David Blaikied6471f72011-09-25 23:23:43 +000070void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
Douglas Gregor28019772010-04-05 23:52:57 +000071 Diagnostics = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000072}
73
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000074void CompilerInstance::setTarget(TargetInfo *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000075 Target = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000076}
77
78void CompilerInstance::setFileManager(FileManager *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000079 FileMgr = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000080}
81
NAKAMURA Takumia789ca92011-10-08 11:31:46 +000082void CompilerInstance::setSourceManager(SourceManager *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000083 SourceMgr = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000084}
85
Ted Kremenek4f327862011-03-21 18:40:17 +000086void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; }
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000087
Ted Kremenek4f327862011-03-21 18:40:17 +000088void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; }
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000089
Douglas Gregorf18d0d82010-08-12 23:31:19 +000090void CompilerInstance::setSema(Sema *S) {
91 TheSema.reset(S);
92}
93
Daniel Dunbar12ce6942009-11-14 02:47:17 +000094void CompilerInstance::setASTConsumer(ASTConsumer *Value) {
95 Consumer.reset(Value);
96}
97
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000098void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
99 CompletionConsumer.reset(Value);
100}
101
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000102// Diagnostics
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000103static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000104 const CodeGenOptions *CodeGenOpts,
David Blaikied6471f72011-09-25 23:23:43 +0000105 DiagnosticsEngine &Diags) {
Daniel Dunbar9df23492011-04-07 18:31:10 +0000106 std::string ErrorInfo;
107 bool OwnsStream = false;
Chris Lattner5f9e2722011-07-23 10:55:15 +0000108 raw_ostream *OS = &llvm::errs();
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000109 if (DiagOpts->DiagnosticLogFile != "-") {
Daniel Dunbar9df23492011-04-07 18:31:10 +0000110 // Create the output stream.
111 llvm::raw_fd_ostream *FileOS(
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000112 new llvm::raw_fd_ostream(DiagOpts->DiagnosticLogFile.c_str(),
Daniel Dunbare01eceb2011-04-07 20:19:21 +0000113 ErrorInfo, llvm::raw_fd_ostream::F_Append));
Daniel Dunbar9df23492011-04-07 18:31:10 +0000114 if (!ErrorInfo.empty()) {
115 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
Sean Silvad2ff76b2013-01-20 01:58:26 +0000116 << DiagOpts->DiagnosticLogFile << ErrorInfo;
Daniel Dunbar9df23492011-04-07 18:31:10 +0000117 } else {
118 FileOS->SetUnbuffered();
119 FileOS->SetUseAtomicWrites(true);
120 OS = FileOS;
121 OwnsStream = true;
122 }
123 }
124
125 // Chain in the diagnostic client which will log the diagnostics.
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000126 LogDiagnosticPrinter *Logger = new LogDiagnosticPrinter(*OS, DiagOpts,
127 OwnsStream);
128 if (CodeGenOpts)
129 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
David Blaikie4e85b8a2011-09-26 00:21:47 +0000130 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger));
Daniel Dunbar9df23492011-04-07 18:31:10 +0000131}
132
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000133static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
Ted Kremenek78002122011-10-29 00:12:39 +0000134 DiagnosticsEngine &Diags,
135 StringRef OutputFile) {
136 std::string ErrorInfo;
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000137 OwningPtr<llvm::raw_fd_ostream> OS;
Ted Kremenek78002122011-10-29 00:12:39 +0000138 OS.reset(new llvm::raw_fd_ostream(OutputFile.str().c_str(), ErrorInfo,
139 llvm::raw_fd_ostream::F_Binary));
140
141 if (!ErrorInfo.empty()) {
142 Diags.Report(diag::warn_fe_serialized_diag_failure)
143 << OutputFile << ErrorInfo;
144 return;
145 }
146
147 DiagnosticConsumer *SerializedConsumer =
Ted Kremenek2a764102011-12-17 05:26:11 +0000148 clang::serialized_diags::create(OS.take(), DiagOpts);
Ted Kremenek78002122011-10-29 00:12:39 +0000149
150
151 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(),
152 SerializedConsumer));
153}
154
Sean Silvad47afb92013-01-20 01:58:28 +0000155void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
Douglas Gregoraee526e2011-09-29 00:38:00 +0000156 bool ShouldOwnClient,
157 bool ShouldCloneClient) {
Sean Silvad47afb92013-01-20 01:58:28 +0000158 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
Douglas Gregoraee526e2011-09-29 00:38:00 +0000159 ShouldOwnClient, ShouldCloneClient,
160 &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,
Douglas Gregoraee526e2011-09-29 00:38:00 +0000167 bool ShouldCloneClient,
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000168 const CodeGenOptions *CodeGenOpts) {
Dylan Noblesmithc93dc782012-02-20 14:00:23 +0000169 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
170 IntrusiveRefCntPtr<DiagnosticsEngine>
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000171 Diags(new DiagnosticsEngine(DiagID, Opts));
Daniel Dunbar221c7212009-11-14 07:53:24 +0000172
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000173 // Create the diagnostic client for reporting errors or for
174 // implementing -verify.
Douglas Gregoraee526e2011-09-29 00:38:00 +0000175 if (Client) {
176 if (ShouldCloneClient)
177 Diags->setClient(Client->clone(*Diags), ShouldOwnClient);
178 else
179 Diags->setClient(Client, ShouldOwnClient);
180 } else
Douglas Gregore47be3e2010-11-11 00:39:14 +0000181 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
Daniel Dunbarf79dced2009-11-14 03:24:39 +0000182
183 // Chain in -verify checker, if requested.
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000184 if (Opts->VerifyDiagnostics)
David Blaikie621bc692011-09-26 00:38:03 +0000185 Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000186
Daniel Dunbar9df23492011-04-07 18:31:10 +0000187 // Chain in -diagnostic-log-file dumper, if requested.
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000188 if (!Opts->DiagnosticLogFile.empty())
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000189 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000190
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000191 if (!Opts->DiagnosticSerializationFile.empty())
Ted Kremenek78002122011-10-29 00:12:39 +0000192 SetupSerializedDiagnostics(Opts, *Diags,
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000193 Opts->DiagnosticSerializationFile);
Ted Kremenek78002122011-10-29 00:12:39 +0000194
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000195 // Configure our handling of diagnostics.
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000196 ProcessWarningOptions(*Diags, *Opts);
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000197
Douglas Gregor28019772010-04-05 23:52:57 +0000198 return Diags;
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000199}
200
201// File Manager
202
Daniel Dunbar16b74492009-11-13 04:12:06 +0000203void CompilerInstance::createFileManager() {
Ted Kremenek4f327862011-03-21 18:40:17 +0000204 FileMgr = new FileManager(getFileSystemOpts());
Daniel Dunbar16b74492009-11-13 04:12:06 +0000205}
206
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000207// Source Manager
208
Chris Lattner39b49bc2010-11-23 08:35:12 +0000209void CompilerInstance::createSourceManager(FileManager &FileMgr) {
Ted Kremenek4f327862011-03-21 18:40:17 +0000210 SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
Daniel Dunbar16b74492009-11-13 04:12:06 +0000211}
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000212
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000213// Preprocessor
214
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000215void CompilerInstance::createPreprocessor() {
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000216 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000217
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000218 // Create a PTH manager if we are using some form of a token cache.
219 PTHManager *PTHMgr = 0;
Daniel Dunbar049d3a02009-11-17 05:52:41 +0000220 if (!PPOpts.TokenCache.empty())
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000221 PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000222
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000223 // Create the Preprocessor.
Douglas Gregorc042edd2012-10-24 16:19:39 +0000224 HeaderSearch *HeaderInfo = new HeaderSearch(&getHeaderSearchOpts(),
225 getFileManager(),
Douglas Gregor51f564f2011-12-31 04:05:44 +0000226 getDiagnostics(),
Douglas Gregordc58aa72012-01-30 06:01:29 +0000227 getLangOpts(),
228 &getTarget());
Douglas Gregor36a16492012-10-24 17:46:57 +0000229 PP = new Preprocessor(&getPreprocessorOpts(),
230 getDiagnostics(), getLangOpts(), &getTarget(),
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000231 getSourceManager(), *HeaderInfo, *this, PTHMgr,
232 /*OwnsHeaderSearch=*/true);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000233
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000234 // Note that this is different then passing PTHMgr to Preprocessor's ctor.
235 // That argument is used as the IdentifierInfoLookup argument to
236 // IdentifierTable's ctor.
237 if (PTHMgr) {
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000238 PTHMgr->setPreprocessor(&*PP);
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000239 PP->setPTHManager(PTHMgr);
240 }
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000241
Douglas Gregor94dc8f62010-03-19 16:15:56 +0000242 if (PPOpts.DetailedRecord)
Argyrios Kyrtzidis37ed1272012-12-04 07:27:05 +0000243 PP->createPreprocessingRecord();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000244
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000245 InitializePreprocessor(*PP, PPOpts, getHeaderSearchOpts(), getFrontendOpts());
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000246
Jordan Rose74c24982013-01-30 01:52:57 +0000247 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
248
Douglas Gregor6e975c42011-09-13 23:15:45 +0000249 // Set up the module path, including the hash for the
250 // module-creation options.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000251 SmallString<256> SpecificModuleCache(
Douglas Gregor6e975c42011-09-13 23:15:45 +0000252 getHeaderSearchOpts().ModuleCachePath);
253 if (!getHeaderSearchOpts().DisableModuleHash)
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000254 llvm::sys::path::append(SpecificModuleCache,
Douglas Gregor6e975c42011-09-13 23:15:45 +0000255 getInvocation().getModuleHash());
Douglas Gregor5e3f9222011-12-08 17:01:29 +0000256 PP->getHeaderSearchInfo().setModuleCachePath(SpecificModuleCache);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000257
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000258 // Handle generating dependencies, if requested.
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000259 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000260 if (!DepOpts.OutputFile.empty())
261 AttachDependencyFileGen(*PP, DepOpts);
Douglas Gregor773303a2012-02-02 23:45:13 +0000262 if (!DepOpts.DOTOutputFile.empty())
263 AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile,
Douglas Gregorc69a1812012-02-02 00:54:52 +0000264 getHeaderSearchOpts().Sysroot);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000265
Douglas Gregorc69a1812012-02-02 00:54:52 +0000266
Daniel Dunbareef63e02011-02-02 15:41:17 +0000267 // Handle generating header include information, if requested.
268 if (DepOpts.ShowHeaderIncludes)
269 AttachHeaderIncludeGen(*PP);
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000270 if (!DepOpts.HeaderIncludeOutputFile.empty()) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000271 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000272 if (OutputPath == "-")
273 OutputPath = "";
Daniel Dunbarda608852011-03-21 19:37:38 +0000274 AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath,
275 /*ShowDepth=*/false);
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000276 }
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000277}
Daniel Dunbar5eb81002009-11-13 08:20:47 +0000278
279// ASTContext
280
281void CompilerInstance::createASTContext() {
282 Preprocessor &PP = getPreprocessor();
Ted Kremenek4f327862011-03-21 18:40:17 +0000283 Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000284 &getTarget(), PP.getIdentifierTable(),
Ted Kremenek4f327862011-03-21 18:40:17 +0000285 PP.getSelectorTable(), PP.getBuiltinInfo(),
286 /*size_reserve=*/ 0);
Daniel Dunbar5eb81002009-11-13 08:20:47 +0000287}
Daniel Dunbar0f800392009-11-13 08:21:10 +0000288
289// ExternalASTSource
290
Chris Lattner5f9e2722011-07-23 10:55:15 +0000291void CompilerInstance::createPCHExternalASTSource(StringRef Path,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000292 bool DisablePCHValidation,
Argyrios Kyrtzidisbef35c92012-03-07 01:51:17 +0000293 bool AllowPCHWithCompilerErrors,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000294 void *DeserializationListener){
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000295 OwningPtr<ExternalASTSource> Source;
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +0000296 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
Daniel Dunbar0f800392009-11-13 08:21:10 +0000297 Source.reset(createPCHExternalASTSource(Path, getHeaderSearchOpts().Sysroot,
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000298 DisablePCHValidation,
Argyrios Kyrtzidisbef35c92012-03-07 01:51:17 +0000299 AllowPCHWithCompilerErrors,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000300 getPreprocessor(), getASTContext(),
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +0000301 DeserializationListener,
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000302 Preamble,
303 getFrontendOpts().UseGlobalModuleIndex));
Douglas Gregorf62d43d2011-07-19 16:10:42 +0000304 ModuleManager = static_cast<ASTReader*>(Source.get());
Daniel Dunbar0f800392009-11-13 08:21:10 +0000305 getASTContext().setExternalSource(Source);
306}
307
308ExternalASTSource *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000309CompilerInstance::createPCHExternalASTSource(StringRef Path,
Daniel Dunbar0f800392009-11-13 08:21:10 +0000310 const std::string &Sysroot,
Douglas Gregorfae3b2f2010-07-27 00:27:13 +0000311 bool DisablePCHValidation,
Argyrios Kyrtzidisbef35c92012-03-07 01:51:17 +0000312 bool AllowPCHWithCompilerErrors,
Daniel Dunbar0f800392009-11-13 08:21:10 +0000313 Preprocessor &PP,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000314 ASTContext &Context,
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +0000315 void *DeserializationListener,
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000316 bool Preamble,
317 bool UseGlobalModuleIndex) {
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000318 OwningPtr<ASTReader> Reader;
Douglas Gregorf8a1e512011-09-02 00:26:20 +0000319 Reader.reset(new ASTReader(PP, Context,
Douglas Gregor832d6202011-07-22 16:35:34 +0000320 Sysroot.empty() ? "" : Sysroot.c_str(),
Argyrios Kyrtzidis4182ed62012-10-31 20:59:50 +0000321 DisablePCHValidation,
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000322 AllowPCHWithCompilerErrors,
323 UseGlobalModuleIndex));
Daniel Dunbar0f800392009-11-13 08:21:10 +0000324
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000325 Reader->setDeserializationListener(
Sebastian Redl571db7f2010-08-18 23:56:56 +0000326 static_cast<ASTDeserializationListener *>(DeserializationListener));
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000327 switch (Reader->ReadAST(Path,
328 Preamble ? serialization::MK_Preamble
Douglas Gregor38295be2012-10-22 23:51:00 +0000329 : serialization::MK_PCH,
Argyrios Kyrtzidis958bcaf2012-11-15 18:57:22 +0000330 SourceLocation(),
Douglas Gregor38295be2012-10-22 23:51:00 +0000331 ASTReader::ARR_None)) {
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000332 case ASTReader::Success:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000333 // Set the predefines buffer as suggested by the PCH reader. Typically, the
334 // predefines buffer will be empty.
335 PP.setPredefines(Reader->getSuggestedPredefines());
336 return Reader.take();
337
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000338 case ASTReader::Failure:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000339 // Unrecoverable failure: don't even try to process the input file.
340 break;
341
Douglas Gregor677e15f2013-03-19 00:28:20 +0000342 case ASTReader::Missing:
Douglas Gregor4825fd72012-10-22 22:50:17 +0000343 case ASTReader::OutOfDate:
344 case ASTReader::VersionMismatch:
345 case ASTReader::ConfigurationMismatch:
346 case ASTReader::HadErrors:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000347 // No suitable PCH file could be found. Return an error.
348 break;
349 }
350
351 return 0;
352}
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000353
354// Code Completion
355
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000356static bool EnableCodeCompletion(Preprocessor &PP,
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000357 const std::string &Filename,
358 unsigned Line,
359 unsigned Column) {
360 // Tell the source manager to chop off the given file at a specific
361 // line and column.
Chris Lattner39b49bc2010-11-23 08:35:12 +0000362 const FileEntry *Entry = PP.getFileManager().getFile(Filename);
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000363 if (!Entry) {
364 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
365 << Filename;
366 return true;
367 }
368
369 // Truncate the named file at the given line/column.
370 PP.SetCodeCompletionPoint(Entry, Line, Column);
371 return false;
372}
373
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000374void CompilerInstance::createCodeCompletionConsumer() {
375 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000376 if (!CompletionConsumer) {
Erik Verbruggen9bc0c292012-04-12 10:31:12 +0000377 setCodeCompletionConsumer(
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000378 createCodeCompletionConsumer(getPreprocessor(),
379 Loc.FileName, Loc.Line, Loc.Column,
Dmitri Gribenkod99ef532012-07-02 17:35:10 +0000380 getFrontendOpts().CodeCompleteOpts,
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000381 llvm::outs()));
382 if (!CompletionConsumer)
383 return;
384 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
385 Loc.Line, Loc.Column)) {
Erik Verbruggen9bc0c292012-04-12 10:31:12 +0000386 setCodeCompletionConsumer(0);
Douglas Gregorc3d43b72010-03-16 06:04:47 +0000387 return;
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000388 }
Douglas Gregor2b4074f2009-12-01 05:55:20 +0000389
390 if (CompletionConsumer->isOutputBinary() &&
391 llvm::sys::Program::ChangeStdoutToBinary()) {
392 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
Erik Verbruggen9bc0c292012-04-12 10:31:12 +0000393 setCodeCompletionConsumer(0);
Douglas Gregor2b4074f2009-12-01 05:55:20 +0000394 }
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000395}
396
Kovarththanan Rajaratnamf79bafa2009-11-29 09:57:35 +0000397void CompilerInstance::createFrontendTimer() {
398 FrontendTimer.reset(new llvm::Timer("Clang front-end timer"));
399}
400
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000401CodeCompleteConsumer *
402CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
403 const std::string &Filename,
404 unsigned Line,
405 unsigned Column,
Dmitri Gribenkod99ef532012-07-02 17:35:10 +0000406 const CodeCompleteOptions &Opts,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000407 raw_ostream &OS) {
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000408 if (EnableCodeCompletion(PP, Filename, Line, Column))
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000409 return 0;
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000410
411 // Set up the creation routine for code-completion.
Dmitri Gribenkod99ef532012-07-02 17:35:10 +0000412 return new PrintingCodeCompleteConsumer(Opts, OS);
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000413}
Daniel Dunbara9204832009-11-13 10:37:48 +0000414
Douglas Gregor467dc882011-08-25 22:30:56 +0000415void CompilerInstance::createSema(TranslationUnitKind TUKind,
Douglas Gregorf18d0d82010-08-12 23:31:19 +0000416 CodeCompleteConsumer *CompletionConsumer) {
417 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
Douglas Gregor467dc882011-08-25 22:30:56 +0000418 TUKind, CompletionConsumer));
Douglas Gregorf18d0d82010-08-12 23:31:19 +0000419}
420
Daniel Dunbara9204832009-11-13 10:37:48 +0000421// Output Files
422
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000423void CompilerInstance::addOutputFile(const OutputFile &OutFile) {
424 assert(OutFile.OS && "Attempt to add empty stream to output list!");
425 OutputFiles.push_back(OutFile);
Daniel Dunbara9204832009-11-13 10:37:48 +0000426}
427
Kovarththanan Rajaratname51dd7b2010-03-06 12:07:48 +0000428void CompilerInstance::clearOutputFiles(bool EraseFiles) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000429 for (std::list<OutputFile>::iterator
Daniel Dunbara9204832009-11-13 10:37:48 +0000430 it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000431 delete it->OS;
432 if (!it->TempFilename.empty()) {
Anders Carlssonaf036a62011-03-06 22:25:35 +0000433 if (EraseFiles) {
434 bool existed;
435 llvm::sys::fs::remove(it->TempFilename, existed);
436 } else {
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000437 SmallString<128> NewOutFile(it->Filename);
Anders Carlssonaf036a62011-03-06 22:25:35 +0000438
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +0000439 // If '-working-directory' was passed, the output filename should be
440 // relative to that.
Anders Carlsson2e2468e2011-03-14 01:13:54 +0000441 FileMgr->FixupRelativePath(NewOutFile);
Anders Carlssonaf036a62011-03-06 22:25:35 +0000442 if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename,
443 NewOutFile.str())) {
Manuel Klimek832a2aa2012-05-16 20:55:58 +0000444 getDiagnostics().Report(diag::err_unable_to_rename_temp)
Anders Carlssonaf036a62011-03-06 22:25:35 +0000445 << it->TempFilename << it->Filename << ec.message();
446
447 bool existed;
448 llvm::sys::fs::remove(it->TempFilename, existed);
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000449 }
450 }
451 } else if (!it->Filename.empty() && EraseFiles)
452 llvm::sys::Path(it->Filename).eraseFromDisk();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000453
Daniel Dunbara9204832009-11-13 10:37:48 +0000454 }
455 OutputFiles.clear();
456}
457
Daniel Dunbarf482d592009-11-13 18:32:08 +0000458llvm::raw_fd_ostream *
459CompilerInstance::createDefaultOutputFile(bool Binary,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000460 StringRef InFile,
461 StringRef Extension) {
Daniel Dunbarf482d592009-11-13 18:32:08 +0000462 return createOutputFile(getFrontendOpts().OutputFile, Binary,
Daniel Dunbare21dd282012-03-03 00:36:06 +0000463 /*RemoveFileOnSignal=*/true, InFile, Extension,
464 /*UseTemporary=*/true);
Daniel Dunbarf482d592009-11-13 18:32:08 +0000465}
466
467llvm::raw_fd_ostream *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000468CompilerInstance::createOutputFile(StringRef OutputPath,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000469 bool Binary, bool RemoveFileOnSignal,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000470 StringRef InFile,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000471 StringRef Extension,
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000472 bool UseTemporary,
473 bool CreateMissingDirectories) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000474 std::string Error, OutputPathName, TempPathName;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000475 llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000476 RemoveFileOnSignal,
Daniel Dunbarf482d592009-11-13 18:32:08 +0000477 InFile, Extension,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000478 UseTemporary,
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000479 CreateMissingDirectories,
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000480 &OutputPathName,
481 &TempPathName);
Daniel Dunbarf482d592009-11-13 18:32:08 +0000482 if (!OS) {
Daniel Dunbar36043592009-12-03 09:13:30 +0000483 getDiagnostics().Report(diag::err_fe_unable_to_open_output)
484 << OutputPath << Error;
485 return 0;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000486 }
487
488 // Add the output file -- but don't try to remove "-", since this means we are
489 // using stdin.
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000490 addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "",
491 TempPathName, OS));
Daniel Dunbarf482d592009-11-13 18:32:08 +0000492
493 return OS;
494}
495
496llvm::raw_fd_ostream *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000497CompilerInstance::createOutputFile(StringRef OutputPath,
Daniel Dunbarf482d592009-11-13 18:32:08 +0000498 std::string &Error,
499 bool Binary,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000500 bool RemoveFileOnSignal,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000501 StringRef InFile,
502 StringRef Extension,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000503 bool UseTemporary,
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000504 bool CreateMissingDirectories,
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000505 std::string *ResultPathName,
506 std::string *TempPathName) {
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000507 assert((!CreateMissingDirectories || UseTemporary) &&
508 "CreateMissingDirectories is only allowed when using temporary files");
509
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000510 std::string OutFile, TempFile;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000511 if (!OutputPath.empty()) {
512 OutFile = OutputPath;
513 } else if (InFile == "-") {
514 OutFile = "-";
515 } else if (!Extension.empty()) {
516 llvm::sys::Path Path(InFile);
517 Path.eraseSuffix();
518 Path.appendSuffix(Extension);
519 OutFile = Path.str();
520 } else {
521 OutFile = "-";
522 }
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000523
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000524 OwningPtr<llvm::raw_fd_ostream> OS;
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000525 std::string OSFile;
526
527 if (UseTemporary && OutFile != "-") {
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000528 // Only create the temporary if the parent directory exists (or create
529 // missing directories is true) and we can actually write to OutPath,
530 // otherwise we want to fail early.
531 SmallString<256> AbsPath(OutputPath);
532 llvm::sys::fs::make_absolute(AbsPath);
533 llvm::sys::Path OutPath(AbsPath);
534 bool ParentExists = false;
535 if (llvm::sys::fs::exists(llvm::sys::path::parent_path(AbsPath.str()),
536 ParentExists))
537 ParentExists = false;
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000538 bool Exists;
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000539 if ((CreateMissingDirectories || ParentExists) &&
540 ((llvm::sys::fs::exists(AbsPath.str(), Exists) || !Exists) ||
541 (OutPath.isRegularFile() && OutPath.canWrite()))) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000542 // Create a temporary file.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000543 SmallString<128> TempPath;
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000544 TempPath = OutFile;
545 TempPath += "-%%%%%%%%";
546 int fd;
547 if (llvm::sys::fs::unique_file(TempPath.str(), fd, TempPath,
Eric Christopher7d9ae252012-05-11 00:10:07 +0000548 /*makeAbsolute=*/false, 0664)
549 == llvm::errc::success) {
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000550 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
551 OSFile = TempFile = TempPath.str();
552 }
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000553 }
554 }
555
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000556 if (!OS) {
557 OSFile = OutFile;
558 OS.reset(
559 new llvm::raw_fd_ostream(OSFile.c_str(), Error,
560 (Binary ? llvm::raw_fd_ostream::F_Binary : 0)));
561 if (!Error.empty())
562 return 0;
563 }
Daniel Dunbarf482d592009-11-13 18:32:08 +0000564
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000565 // Make sure the out stream file gets removed if we crash.
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000566 if (RemoveFileOnSignal)
567 llvm::sys::RemoveFileOnSignal(llvm::sys::Path(OSFile));
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000568
Daniel Dunbarf482d592009-11-13 18:32:08 +0000569 if (ResultPathName)
570 *ResultPathName = OutFile;
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000571 if (TempPathName)
572 *TempPathName = TempFile;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000573
Daniel Dunbarfc971022009-11-20 22:32:38 +0000574 return OS.take();
Daniel Dunbarf482d592009-11-13 18:32:08 +0000575}
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000576
577// Initialization Utilities
578
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000579bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
580 return InitializeSourceManager(Input, getDiagnostics(),
Douglas Gregora1f1fad2012-01-27 19:52:33 +0000581 getFileManager(), getSourceManager(),
582 getFrontendOpts());
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000583}
584
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000585bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input,
David Blaikied6471f72011-09-25 23:23:43 +0000586 DiagnosticsEngine &Diags,
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000587 FileManager &FileMgr,
588 SourceManager &SourceMgr,
589 const FrontendOptions &Opts) {
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000590 SrcMgr::CharacteristicKind
Argyrios Kyrtzidis8616f9a2012-11-09 19:40:39 +0000591 Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000592
Argyrios Kyrtzidisecd27bf2012-11-09 19:40:45 +0000593 if (Input.isBuffer()) {
594 SourceMgr.createMainFileIDForMemBuffer(Input.getBuffer(), Kind);
595 assert(!SourceMgr.getMainFileID().isInvalid() &&
596 "Couldn't establish MainFileID!");
597 return true;
598 }
599
600 StringRef InputFile = Input.getFile();
601
Argyrios Kyrtzidis507097e2011-09-19 20:40:35 +0000602 // Figure out where to get and map in the main file.
603 if (InputFile != "-") {
Chris Lattner39b49bc2010-11-23 08:35:12 +0000604 const FileEntry *File = FileMgr.getFile(InputFile);
Dan Gohman694137c2010-10-26 21:13:51 +0000605 if (!File) {
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000606 Diags.Report(diag::err_fe_error_reading) << InputFile;
607 return false;
608 }
Daniel Dunbarce36ecd2012-11-05 22:53:33 +0000609
610 // The natural SourceManager infrastructure can't currently handle named
611 // pipes, but we would at least like to accept them for the main
612 // file. Detect them here, read them with the more generic MemoryBuffer
613 // function, and simply override their contents as we do for STDIN.
614 if (File->isNamedPipe()) {
615 OwningPtr<llvm::MemoryBuffer> MB;
616 if (llvm::error_code ec = llvm::MemoryBuffer::getFile(InputFile, MB)) {
617 Diags.Report(diag::err_cannot_open_file) << InputFile << ec.message();
618 return false;
619 }
Daniel Dunbaracf36122012-11-27 00:04:16 +0000620
621 // Create a new virtual file that will have the correct size.
622 File = FileMgr.getVirtualFile(InputFile, MB->getBufferSize(), 0);
Daniel Dunbarce36ecd2012-11-05 22:53:33 +0000623 SourceMgr.overrideFileContents(File, MB.take());
624 }
Daniel Dunbaracf36122012-11-27 00:04:16 +0000625
626 SourceMgr.createMainFileID(File, Kind);
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000627 } else {
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000628 OwningPtr<llvm::MemoryBuffer> SB;
Michael J. Spencer4eeebc42010-12-16 03:28:14 +0000629 if (llvm::MemoryBuffer::getSTDIN(SB)) {
Michael J. Spencer3a321e22010-12-09 17:36:38 +0000630 // FIXME: Give ec.message() in this diag.
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000631 Diags.Report(diag::err_fe_error_reading_stdin);
632 return false;
633 }
Dan Gohman90d90812010-10-26 23:21:25 +0000634 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
Chris Lattner39b49bc2010-11-23 08:35:12 +0000635 SB->getBufferSize(), 0);
Douglas Gregora1f1fad2012-01-27 19:52:33 +0000636 SourceMgr.createMainFileID(File, Kind);
Michael J. Spencer4eeebc42010-12-16 03:28:14 +0000637 SourceMgr.overrideFileContents(File, SB.take());
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000638 }
639
Dan Gohman694137c2010-10-26 21:13:51 +0000640 assert(!SourceMgr.getMainFileID().isInvalid() &&
641 "Couldn't establish MainFileID!");
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000642 return true;
643}
Daniel Dunbar0397af22010-01-13 00:48:06 +0000644
645// High-Level Operations
646
647bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
648 assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
649 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
650 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
651
652 // FIXME: Take this as an argument, once all the APIs we used have moved to
653 // taking it as an input instead of hard-coding llvm::errs.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000654 raw_ostream &OS = llvm::errs();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000655
656 // Create the target instance.
Douglas Gregor49a87542012-11-16 04:24:59 +0000657 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), &getTargetOpts()));
Daniel Dunbar0397af22010-01-13 00:48:06 +0000658 if (!hasTarget())
659 return false;
660
661 // Inform the target of the language options.
662 //
663 // FIXME: We shouldn't need to do this, the target should be immutable once
664 // created. This complexity should be lifted elsewhere.
665 getTarget().setForcedLangOptions(getLangOpts());
666
Fariborz Jahanian93a49942012-04-16 21:03:30 +0000667 // rewriter project will change target built-in bool type from its default.
668 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
669 getTarget().noSignedCharForObjCBool();
670
Daniel Dunbar0397af22010-01-13 00:48:06 +0000671 // Validate/process some options.
672 if (getHeaderSearchOpts().Verbose)
673 OS << "clang -cc1 version " CLANG_VERSION_STRING
674 << " based upon " << PACKAGE_STRING
Sebastian Pop5d8b9542011-11-01 21:33:06 +0000675 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
Daniel Dunbar0397af22010-01-13 00:48:06 +0000676
677 if (getFrontendOpts().ShowTimers)
678 createFrontendTimer();
679
Douglas Gregor95dd5582010-03-30 17:33:59 +0000680 if (getFrontendOpts().ShowStats)
681 llvm::EnableStatistics();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000682
Daniel Dunbar0397af22010-01-13 00:48:06 +0000683 for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) {
Daniel Dunbar20560482010-06-07 23:23:50 +0000684 // Reset the ID tables if we are reusing the SourceManager.
685 if (hasSourceManager())
686 getSourceManager().clearIDTables();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000687
Douglas Gregor1f6b2b52012-01-20 16:28:04 +0000688 if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) {
Daniel Dunbar0397af22010-01-13 00:48:06 +0000689 Act.Execute();
690 Act.EndSourceFile();
691 }
692 }
693
Argyrios Kyrtzidis29f27872011-12-07 05:52:12 +0000694 // Notify the diagnostic client that all files were processed.
695 getDiagnostics().getClient()->finish();
696
Chris Lattner53eee7b2010-04-07 18:47:42 +0000697 if (getDiagnosticOpts().ShowCarets) {
Argyrios Kyrtzidisf2224d82010-11-18 20:06:46 +0000698 // We can have multiple diagnostics sharing one diagnostic client.
699 // Get the total number of warnings/errors from the client.
700 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
701 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000702
Chris Lattner53eee7b2010-04-07 18:47:42 +0000703 if (NumWarnings)
704 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
705 if (NumWarnings && NumErrors)
706 OS << " and ";
707 if (NumErrors)
708 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
709 if (NumWarnings || NumErrors)
710 OS << " generated.\n";
711 }
Daniel Dunbar0397af22010-01-13 00:48:06 +0000712
Daniel Dunbar20560482010-06-07 23:23:50 +0000713 if (getFrontendOpts().ShowStats && hasFileManager()) {
Daniel Dunbar0397af22010-01-13 00:48:06 +0000714 getFileManager().PrintStats();
715 OS << "\n";
716 }
717
Argyrios Kyrtzidisab41b972010-11-18 21:13:57 +0000718 return !getDiagnostics().getClient()->getNumErrors();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000719}
720
Douglas Gregor21cae202011-09-12 23:31:24 +0000721/// \brief Determine the appropriate source input kind based on language
722/// options.
723static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
724 if (LangOpts.OpenCL)
725 return IK_OpenCL;
726 if (LangOpts.CUDA)
727 return IK_CUDA;
728 if (LangOpts.ObjC1)
729 return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
730 return LangOpts.CPlusPlus? IK_CXX : IK_C;
731}
732
Douglas Gregor0ced7992011-10-04 00:21:21 +0000733namespace {
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000734 struct CompileModuleMapData {
735 CompilerInstance &Instance;
736 GenerateModuleAction &CreateModuleAction;
737 };
738}
739
740/// \brief Helper function that executes the module-generating action under
741/// a crash recovery context.
742static void doCompileMapModule(void *UserData) {
743 CompileModuleMapData &Data
744 = *reinterpret_cast<CompileModuleMapData *>(UserData);
745 Data.Instance.ExecuteAction(Data.CreateModuleAction);
746}
747
Douglas Gregor2a060852013-02-07 00:21:12 +0000748namespace {
749 /// \brief Function object that checks with the given macro definition should
750 /// be removed, because it is one of the ignored macros.
751 class RemoveIgnoredMacro {
752 const HeaderSearchOptions &HSOpts;
753
754 public:
755 explicit RemoveIgnoredMacro(const HeaderSearchOptions &HSOpts)
756 : HSOpts(HSOpts) { }
757
758 bool operator()(const std::pair<std::string, bool> &def) const {
Douglas Gregor005d51b2013-02-07 01:18:48 +0000759 StringRef MacroDef = def.first;
760 return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0;
Douglas Gregor2a060852013-02-07 00:21:12 +0000761 }
762 };
763}
764
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000765/// \brief Compile a module file for the given module, using the options
766/// provided by the importing compiler instance.
Douglas Gregor21cae202011-09-12 23:31:24 +0000767static void compileModule(CompilerInstance &ImportingInstance,
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000768 SourceLocation ImportLoc,
Douglas Gregor1a4761e2011-11-30 23:21:26 +0000769 Module *Module,
Douglas Gregor933e7a62011-11-29 18:31:39 +0000770 StringRef ModuleFileName) {
Douglas Gregor52f12722012-01-29 20:15:24 +0000771 llvm::LockFileManager Locked(ModuleFileName);
Douglas Gregor2bc75072011-10-05 14:53:30 +0000772 switch (Locked) {
Douglas Gregor52f12722012-01-29 20:15:24 +0000773 case llvm::LockFileManager::LFS_Error:
Douglas Gregor2bc75072011-10-05 14:53:30 +0000774 return;
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000775
Douglas Gregor52f12722012-01-29 20:15:24 +0000776 case llvm::LockFileManager::LFS_Owned:
Douglas Gregor2bc75072011-10-05 14:53:30 +0000777 // We're responsible for building the module ourselves. Do so below.
778 break;
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000779
Douglas Gregor52f12722012-01-29 20:15:24 +0000780 case llvm::LockFileManager::LFS_Shared:
Douglas Gregor2bc75072011-10-05 14:53:30 +0000781 // Someone else is responsible for building the module. Wait for them to
782 // finish.
783 Locked.waitForUnlock();
Douglas Gregor7cdd2812012-11-07 17:46:15 +0000784 return;
Douglas Gregor2bc75072011-10-05 14:53:30 +0000785 }
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000786
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000787 ModuleMap &ModMap
788 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
789
Douglas Gregor21cae202011-09-12 23:31:24 +0000790 // Construct a compiler invocation for creating this module.
Dylan Noblesmithc93dc782012-02-20 14:00:23 +0000791 IntrusiveRefCntPtr<CompilerInvocation> Invocation
Douglas Gregor21cae202011-09-12 23:31:24 +0000792 (new CompilerInvocation(ImportingInstance.getInvocation()));
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000793
Douglas Gregor18ee5472011-11-29 21:59:16 +0000794 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
795
Douglas Gregorb2d39c22011-09-15 20:53:28 +0000796 // For any options that aren't intended to affect how a module is built,
797 // reset them to their default values.
Ted Kremenekd3b74d92011-11-17 23:01:24 +0000798 Invocation->getLangOpts()->resetNonModularOptions();
Douglas Gregor18ee5472011-11-29 21:59:16 +0000799 PPOpts.resetNonModularOptions();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000800
Douglas Gregor2a060852013-02-07 00:21:12 +0000801 // Remove any macro definitions that are explicitly ignored by the module.
802 // They aren't supposed to affect how the module is built anyway.
803 const HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
804 PPOpts.Macros.erase(std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
805 RemoveIgnoredMacro(HSOpts)),
806 PPOpts.Macros.end());
807
808
Douglas Gregorb86b8dc2011-11-15 19:35:01 +0000809 // Note the name of the module we're building.
Douglas Gregor933e7a62011-11-29 18:31:39 +0000810 Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
Douglas Gregorb86b8dc2011-11-15 19:35:01 +0000811
Douglas Gregor463d9092012-11-29 23:55:25 +0000812 // Make sure that the failed-module structure has been allocated in
813 // the importing instance, and propagate the pointer to the newly-created
814 // instance.
815 PreprocessorOptions &ImportingPPOpts
816 = ImportingInstance.getInvocation().getPreprocessorOpts();
817 if (!ImportingPPOpts.FailedModules)
818 ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet;
819 PPOpts.FailedModules = ImportingPPOpts.FailedModules;
820
Douglas Gregor18ee5472011-11-29 21:59:16 +0000821 // If there is a module map file, build the module using the module map.
Douglas Gregorb2d39c22011-09-15 20:53:28 +0000822 // Set up the inputs/outputs so that we build the module from its umbrella
823 // header.
Douglas Gregor21cae202011-09-12 23:31:24 +0000824 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
Douglas Gregor6e975c42011-09-13 23:15:45 +0000825 FrontendOpts.OutputFile = ModuleFileName.str();
Douglas Gregor21cae202011-09-12 23:31:24 +0000826 FrontendOpts.DisableFree = false;
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000827 FrontendOpts.GenerateGlobalModuleIndex = false;
Douglas Gregor21cae202011-09-12 23:31:24 +0000828 FrontendOpts.Inputs.clear();
Douglas Gregor18ee5472011-11-29 21:59:16 +0000829 InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000830
Douglas Gregor18ee5472011-11-29 21:59:16 +0000831 // Get or create the module map that we'll use to build this module.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000832 SmallString<128> TempModuleMapFileName;
Douglas Gregor18ee5472011-11-29 21:59:16 +0000833 if (const FileEntry *ModuleMapFile
834 = ModMap.getContainingModuleMapFile(Module)) {
835 // Use the module map where this module resides.
Douglas Gregor1f6b2b52012-01-20 16:28:04 +0000836 FrontendOpts.Inputs.push_back(FrontendInputFile(ModuleMapFile->getName(),
837 IK));
Douglas Gregor18ee5472011-11-29 21:59:16 +0000838 } else {
839 // Create a temporary module map file.
840 TempModuleMapFileName = Module->Name;
841 TempModuleMapFileName += "-%%%%%%%%.map";
842 int FD;
843 if (llvm::sys::fs::unique_file(TempModuleMapFileName.str(), FD,
844 TempModuleMapFileName,
Douglas Gregor1e821e92011-12-06 22:05:29 +0000845 /*makeAbsolute=*/true)
Douglas Gregore9120292011-12-06 23:04:08 +0000846 != llvm::errc::success) {
Douglas Gregorf64114b2011-12-07 00:54:14 +0000847 ImportingInstance.getDiagnostics().Report(diag::err_module_map_temp_file)
848 << TempModuleMapFileName;
Douglas Gregor18ee5472011-11-29 21:59:16 +0000849 return;
Douglas Gregore9120292011-12-06 23:04:08 +0000850 }
Douglas Gregor18ee5472011-11-29 21:59:16 +0000851 // Print the module map to this file.
852 llvm::raw_fd_ostream OS(FD, /*shouldClose=*/true);
853 Module->print(OS);
854 FrontendOpts.Inputs.push_back(
Douglas Gregor1f6b2b52012-01-20 16:28:04 +0000855 FrontendInputFile(TempModuleMapFileName.str().str(), IK));
Douglas Gregor18ee5472011-11-29 21:59:16 +0000856 }
857
858 // Don't free the remapped file buffers; they are owned by our caller.
859 PPOpts.RetainRemappedFileBuffers = true;
860
Douglas Gregor78243652011-09-13 01:26:44 +0000861 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
Douglas Gregor76d991e2011-09-13 23:20:27 +0000862 assert(ImportingInstance.getInvocation().getModuleHash() ==
Douglas Gregor18ee5472011-11-29 21:59:16 +0000863 Invocation->getModuleHash() && "Module hash mismatch!");
864
Douglas Gregor21cae202011-09-12 23:31:24 +0000865 // Construct a compiler instance that will be used to actually create the
866 // module.
867 CompilerInstance Instance;
868 Instance.setInvocation(&*Invocation);
Sean Silvad47afb92013-01-20 01:58:28 +0000869 Instance.createDiagnostics(&ImportingInstance.getDiagnosticClient(),
Douglas Gregoraee526e2011-09-29 00:38:00 +0000870 /*ShouldOwnClient=*/true,
871 /*ShouldCloneClient=*/true);
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000872
Douglas Gregor4565e482012-11-30 22:11:57 +0000873 // Note that this module is part of the module build stack, so that we
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000874 // can detect cycles in the module graph.
875 Instance.createFileManager(); // FIXME: Adopt file manager from importer?
876 Instance.createSourceManager(Instance.getFileManager());
877 SourceManager &SourceMgr = Instance.getSourceManager();
Douglas Gregor4565e482012-11-30 22:11:57 +0000878 SourceMgr.setModuleBuildStack(
879 ImportingInstance.getSourceManager().getModuleBuildStack());
880 SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(),
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000881 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
882
883
Douglas Gregor21cae202011-09-12 23:31:24 +0000884 // Construct a module-generating action.
Douglas Gregor18ee5472011-11-29 21:59:16 +0000885 GenerateModuleAction CreateModuleAction;
886
Douglas Gregor0ced7992011-10-04 00:21:21 +0000887 // Execute the action to actually build the module in-place. Use a separate
888 // thread so that we get a stack large enough.
889 const unsigned ThreadStackSize = 8 << 20;
890 llvm::CrashRecoveryContext CRC;
Douglas Gregor18ee5472011-11-29 21:59:16 +0000891 CompileModuleMapData Data = { Instance, CreateModuleAction };
892 CRC.RunSafelyOnThread(&doCompileMapModule, &Data, ThreadStackSize);
893
894 // Delete the temporary module map file.
895 // FIXME: Even though we're executing under crash protection, it would still
896 // be nice to do this with RemoveFileOnSignal when we can. However, that
897 // doesn't make sense for all clients, so clean this up manually.
Benjamin Kramera2e94892012-10-14 19:50:53 +0000898 Instance.clearOutputFiles(/*EraseFiles=*/true);
Douglas Gregor18ee5472011-11-29 21:59:16 +0000899 if (!TempModuleMapFileName.empty())
900 llvm::sys::Path(TempModuleMapFileName).eraseFromDisk();
Douglas Gregora6b00fc2013-01-23 22:38:11 +0000901
902 // We've rebuilt a module. If we're allowed to generate or update the global
903 // module index, record that fact in the importing compiler instance.
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000904 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
Douglas Gregora6b00fc2013-01-23 22:38:11 +0000905 ImportingInstance.setBuildGlobalModuleIndex(true);
906 }
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000907}
Douglas Gregor21cae202011-09-12 23:31:24 +0000908
Douglas Gregor63a72682013-03-20 00:22:05 +0000909/// \brief Diagnose differences between the current definition of the given
910/// configuration macro and the definition provided on the command line.
911static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
912 Module *Mod, SourceLocation ImportLoc) {
913 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
914 SourceManager &SourceMgr = PP.getSourceManager();
915
916 // If this identifier has never had a macro definition, then it could
917 // not have changed.
918 if (!Id->hadMacroDefinition())
919 return;
920
921 // If this identifier does not currently have a macro definition,
922 // check whether it had one on the command line.
923 if (!Id->hasMacroDefinition()) {
924 MacroDirective *UndefMD = PP.getMacroDirectiveHistory(Id);
925 for (MacroDirective *MD = UndefMD; MD; MD = MD->getPrevious()) {
926
927 FileID FID = SourceMgr.getFileID(MD->getLocation());
928 if (FID.isInvalid())
929 continue;
930
931 const llvm::MemoryBuffer *Buffer = SourceMgr.getBuffer(FID);
932 if (!Buffer)
933 continue;
934
935 // We only care about the predefines buffer.
936 if (!StringRef(Buffer->getBufferIdentifier()).equals("<built-in>"))
937 continue;
938
939 // This macro was defined on the command line, then #undef'd later.
940 // Complain.
941 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
942 << true << ConfigMacro << Mod->getFullModuleName();
943 if (UndefMD->getUndefLoc().isValid())
944 PP.Diag(UndefMD->getUndefLoc(), diag::note_module_def_undef_here)
945 << true;
946 return;
947 }
948
949 // Okay: no definition in the predefines buffer.
950 return;
951 }
952
953 // This identifier has a macro definition. Check whether we had a definition
954 // on the command line.
955 MacroDirective *DefMD = PP.getMacroDirective(Id);
956 MacroDirective *PredefinedMD = 0;
957 for (MacroDirective *MD = DefMD; MD; MD = MD->getPrevious()) {
958 FileID FID = SourceMgr.getFileID(MD->getLocation());
959 if (FID.isInvalid())
960 continue;
961
962 const llvm::MemoryBuffer *Buffer = SourceMgr.getBuffer(FID);
963 if (!Buffer)
964 continue;
965
966 // We only care about the predefines buffer.
967 if (!StringRef(Buffer->getBufferIdentifier()).equals("<built-in>"))
968 continue;
969
970 PredefinedMD = MD;
971 break;
972 }
973
974 // If there was no definition for this macro in the predefines buffer,
975 // complain.
976 if (!PredefinedMD ||
977 (!PredefinedMD->getLocation().isValid() &&
978 PredefinedMD->getUndefLoc().isValid())) {
979 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
980 << false << ConfigMacro << Mod->getFullModuleName();
981 PP.Diag(DefMD->getLocation(), diag::note_module_def_undef_here)
982 << false;
983 return;
984 }
985
986 // If the current macro definition is the same as the predefined macro
987 // definition, it's okay.
988 if (DefMD == PredefinedMD ||
989 DefMD->getInfo()->isIdenticalTo(*PredefinedMD->getInfo(), PP))
990 return;
991
992 // The macro definitions differ.
993 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
994 << false << ConfigMacro << Mod->getFullModuleName();
995 PP.Diag(DefMD->getLocation(), diag::note_module_def_undef_here)
996 << false;
997}
998
Douglas Gregor463d9092012-11-29 23:55:25 +0000999ModuleLoadResult
1000CompilerInstance::loadModule(SourceLocation ImportLoc,
1001 ModuleIdPath Path,
1002 Module::NameVisibilityKind Visibility,
1003 bool IsInclusionDirective) {
Douglas Gregorb514c792011-11-30 04:26:53 +00001004 // If we've already handled this import, just return the cached result.
1005 // This one-element cache is important to eliminate redundant diagnostics
1006 // when both the preprocessor and parser see the same import declaration.
Douglas Gregor5e356932011-12-01 17:11:21 +00001007 if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) {
1008 // Make the named module visible.
1009 if (LastModuleImportResult)
Argyrios Kyrtzidis5ebcb202013-02-01 16:36:12 +00001010 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
Douglas Gregor906d66a2013-03-20 21:10:35 +00001011 ImportLoc, /*Complain=*/false);
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001012 return LastModuleImportResult;
Douglas Gregor5e356932011-12-01 17:11:21 +00001013 }
Douglas Gregorb514c792011-11-30 04:26:53 +00001014
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001015 // Determine what file we're searching from.
Douglas Gregor3d3589d2011-11-30 00:36:36 +00001016 StringRef ModuleName = Path[0].first->getName();
1017 SourceLocation ModuleNameLoc = Path[0].second;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001018
Douglas Gregor1a4761e2011-11-30 23:21:26 +00001019 clang::Module *Module = 0;
Douglas Gregor3d3589d2011-11-30 00:36:36 +00001020
Douglas Gregor49009ec2011-11-30 04:03:44 +00001021 // If we don't already have information on this module, load the module now.
Douglas Gregor1a4761e2011-11-30 23:21:26 +00001022 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001023 = KnownModules.find(Path[0].first);
Douglas Gregor5e3f9222011-12-08 17:01:29 +00001024 if (Known != KnownModules.end()) {
1025 // Retrieve the cached top-level module.
1026 Module = Known->second;
1027 } else if (ModuleName == getLangOpts().CurrentModule) {
1028 // This is the module we're building.
1029 Module = PP->getHeaderSearchInfo().getModuleMap().findModule(ModuleName);
1030 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1031 } else {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001032 // Search for a module with the given name.
Douglas Gregore434ec72012-01-29 17:08:11 +00001033 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001034 std::string ModuleFileName;
Douglas Gregor8bf778e2013-02-06 22:40:31 +00001035 if (Module) {
Douglas Gregore434ec72012-01-29 17:08:11 +00001036 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module);
Douglas Gregor8bf778e2013-02-06 22:40:31 +00001037 } else
Douglas Gregore434ec72012-01-29 17:08:11 +00001038 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(ModuleName);
Douglas Gregor463d9092012-11-29 23:55:25 +00001039
Douglas Gregor49009ec2011-11-30 04:03:44 +00001040 // If we don't already have an ASTReader, create one now.
1041 if (!ModuleManager) {
1042 if (!hasASTContext())
1043 createASTContext();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +00001044
Douglas Gregor49009ec2011-11-30 04:03:44 +00001045 std::string Sysroot = getHeaderSearchOpts().Sysroot;
1046 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1047 ModuleManager = new ASTReader(getPreprocessor(), *Context,
1048 Sysroot.empty() ? "" : Sysroot.c_str(),
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001049 PPOpts.DisablePCHValidation,
1050 /*AllowASTWithCompilerErrors=*/false,
1051 getFrontendOpts().UseGlobalModuleIndex);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001052 if (hasASTConsumer()) {
1053 ModuleManager->setDeserializationListener(
1054 getASTConsumer().GetASTDeserializationListener());
1055 getASTContext().setASTMutationListener(
1056 getASTConsumer().GetASTMutationListener());
Douglas Gregora8235d62012-10-09 23:05:51 +00001057 getPreprocessor().setPPMutationListener(
1058 getASTConsumer().GetPPMutationListener());
Douglas Gregor49009ec2011-11-30 04:03:44 +00001059 }
Dylan Noblesmith6f42b622012-02-05 02:12:40 +00001060 OwningPtr<ExternalASTSource> Source;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001061 Source.reset(ModuleManager);
1062 getASTContext().setExternalSource(Source);
1063 if (hasSema())
1064 ModuleManager->InitializeSema(getSema());
1065 if (hasASTConsumer())
1066 ModuleManager->StartTranslationUnit(&getASTConsumer());
Douglas Gregorde8a9052011-09-14 23:13:09 +00001067 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001068
Douglas Gregor677e15f2013-03-19 00:28:20 +00001069 // Try to load the module file.
1070 unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing;
1071 switch (ModuleManager->ReadAST(ModuleFileName, serialization::MK_Module,
1072 ImportLoc, ARRFlags)) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001073 case ASTReader::Success:
1074 break;
1075
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001076 case ASTReader::OutOfDate: {
Douglas Gregor677e15f2013-03-19 00:28:20 +00001077 // The module file is out-of-date. Remove it, then rebuild it.
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001078 bool Existed;
1079 llvm::sys::fs::remove(ModuleFileName, Existed);
Douglas Gregor677e15f2013-03-19 00:28:20 +00001080 }
1081 // Fall through to build the module again.
1082
1083 case ASTReader::Missing: {
1084 // The module file is (now) missing. Build it.
1085
1086 // If we don't have a module, we don't know how to build the module file.
1087 // Complain and return.
1088 if (!Module) {
1089 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1090 << ModuleName
1091 << SourceRange(ImportLoc, ModuleNameLoc);
1092 ModuleBuildFailed = true;
1093 return ModuleLoadResult();
1094 }
1095
1096 // Check whether there is a cycle in the module graph.
1097 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1098 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1099 for (; Pos != PosEnd; ++Pos) {
1100 if (Pos->first == ModuleName)
1101 break;
1102 }
1103
1104 if (Pos != PosEnd) {
1105 SmallString<256> CyclePath;
1106 for (; Pos != PosEnd; ++Pos) {
1107 CyclePath += Pos->first;
1108 CyclePath += " -> ";
1109 }
1110 CyclePath += ModuleName;
1111
1112 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1113 << ModuleName << CyclePath;
1114 return ModuleLoadResult();
1115 }
Douglas Gregor463d9092012-11-29 23:55:25 +00001116
1117 // Check whether we have already attempted to build this module (but
1118 // failed).
1119 if (getPreprocessorOpts().FailedModules &&
1120 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1121 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1122 << ModuleName
1123 << SourceRange(ImportLoc, ModuleNameLoc);
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001124 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001125 return ModuleLoadResult();
1126 }
1127
Douglas Gregor677e15f2013-03-19 00:28:20 +00001128 // Try to compile the module.
Douglas Gregor830ea5b2012-11-30 18:38:50 +00001129 compileModule(*this, ModuleNameLoc, Module, ModuleFileName);
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001130
Douglas Gregor677e15f2013-03-19 00:28:20 +00001131 // Try to read the module file, now that we've compiled it.
1132 ASTReader::ASTReadResult ReadResult
1133 = ModuleManager->ReadAST(ModuleFileName,
Argyrios Kyrtzidis958bcaf2012-11-15 18:57:22 +00001134 serialization::MK_Module, ImportLoc,
Douglas Gregor677e15f2013-03-19 00:28:20 +00001135 ASTReader::ARR_Missing);
1136 if (ReadResult != ASTReader::Success) {
1137 if (ReadResult == ASTReader::Missing) {
1138 getDiagnostics().Report(ModuleNameLoc,
1139 Module? diag::err_module_not_built
1140 : diag::err_module_not_found)
1141 << ModuleName
1142 << SourceRange(ImportLoc, ModuleNameLoc);
1143 }
1144
Douglas Gregorb8a8be12013-01-10 02:04:18 +00001145 if (getPreprocessorOpts().FailedModules)
1146 getPreprocessorOpts().FailedModules->addFailed(ModuleName);
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001147 KnownModules[Path[0].first] = 0;
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001148 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001149 return ModuleLoadResult();
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001150 }
1151
1152 // Okay, we've rebuilt and now loaded the module.
1153 break;
1154 }
1155
Douglas Gregor4825fd72012-10-22 22:50:17 +00001156 case ASTReader::VersionMismatch:
1157 case ASTReader::ConfigurationMismatch:
1158 case ASTReader::HadErrors:
Douglas Gregor49009ec2011-11-30 04:03:44 +00001159 // FIXME: The ASTReader will already have complained, but can we showhorn
1160 // that diagnostic information into a more useful form?
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001161 KnownModules[Path[0].first] = 0;
Douglas Gregor463d9092012-11-29 23:55:25 +00001162 return ModuleLoadResult();
Douglas Gregor49009ec2011-11-30 04:03:44 +00001163
1164 case ASTReader::Failure:
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001165 // Already complained, but note now that we failed.
1166 KnownModules[Path[0].first] = 0;
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001167 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001168 return ModuleLoadResult();
Douglas Gregor49009ec2011-11-30 04:03:44 +00001169 }
1170
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001171 if (!Module) {
1172 // If we loaded the module directly, without finding a module map first,
1173 // we'll have loaded the module's information from the module itself.
1174 Module = PP->getHeaderSearchInfo().getModuleMap()
1175 .findModule((Path[0].first->getName()));
1176 }
Argyrios Kyrtzidise2ac16b2012-09-29 01:06:04 +00001177
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001178 // Cache the result of this top-level module lookup for later.
1179 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001180 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001181
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001182 // If we never found the module, fail.
1183 if (!Module)
Douglas Gregor463d9092012-11-29 23:55:25 +00001184 return ModuleLoadResult();
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001185
Douglas Gregor49009ec2011-11-30 04:03:44 +00001186 // Verify that the rest of the module path actually corresponds to
1187 // a submodule.
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001188 if (Path.size() > 1) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001189 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1190 StringRef Name = Path[I].first->getName();
Douglas Gregorb7a78192012-01-04 23:32:19 +00001191 clang::Module *Sub = Module->findSubmodule(Name);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001192
Douglas Gregorb7a78192012-01-04 23:32:19 +00001193 if (!Sub) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001194 // Attempt to perform typo correction to find a module name that works.
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00001195 SmallVector<StringRef, 2> Best;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001196 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1197
Douglas Gregorb7a78192012-01-04 23:32:19 +00001198 for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1199 JEnd = Module->submodule_end();
Matt Beaumont-Gaye25633f2011-11-30 19:41:21 +00001200 J != JEnd; ++J) {
Douglas Gregorb7a78192012-01-04 23:32:19 +00001201 unsigned ED = Name.edit_distance((*J)->Name,
Douglas Gregor49009ec2011-11-30 04:03:44 +00001202 /*AllowReplacements=*/true,
1203 BestEditDistance);
1204 if (ED <= BestEditDistance) {
Douglas Gregorb7a78192012-01-04 23:32:19 +00001205 if (ED < BestEditDistance) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001206 Best.clear();
Douglas Gregorb7a78192012-01-04 23:32:19 +00001207 BestEditDistance = ED;
1208 }
1209
1210 Best.push_back((*J)->Name);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001211 }
1212 }
1213
1214 // If there was a clear winner, user it.
1215 if (Best.size() == 1) {
1216 getDiagnostics().Report(Path[I].second,
1217 diag::err_no_submodule_suggest)
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001218 << Path[I].first << Module->getFullModuleName() << Best[0]
Douglas Gregor49009ec2011-11-30 04:03:44 +00001219 << SourceRange(Path[0].second, Path[I-1].second)
1220 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1221 Best[0]);
Douglas Gregorb7a78192012-01-04 23:32:19 +00001222
1223 Sub = Module->findSubmodule(Best[0]);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001224 }
1225 }
1226
Douglas Gregorb7a78192012-01-04 23:32:19 +00001227 if (!Sub) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001228 // No submodule by this name. Complain, and don't look for further
1229 // submodules.
1230 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001231 << Path[I].first << Module->getFullModuleName()
Douglas Gregor49009ec2011-11-30 04:03:44 +00001232 << SourceRange(Path[0].second, Path[I-1].second);
1233 break;
1234 }
1235
Douglas Gregorb7a78192012-01-04 23:32:19 +00001236 Module = Sub;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001237 }
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001238 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001239
Douglas Gregor5e3f9222011-12-08 17:01:29 +00001240 // Make the named module visible, if it's not already part of the module
1241 // we are parsing.
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001242 if (ModuleName != getLangOpts().CurrentModule) {
1243 if (!Module->IsFromModuleFile) {
1244 // We have an umbrella header or directory that doesn't actually include
1245 // all of the headers within the directory it covers. Complain about
1246 // this missing submodule and recover by forgetting that we ever saw
1247 // this submodule.
1248 // FIXME: Should we detect this at module load time? It seems fairly
1249 // expensive (and rare).
1250 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1251 << Module->getFullModuleName()
1252 << SourceRange(Path.front().second, Path.back().second);
1253
Douglas Gregor463d9092012-11-29 23:55:25 +00001254 return ModuleLoadResult(0, true);
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001255 }
Douglas Gregor51f564f2011-12-31 04:05:44 +00001256
1257 // Check whether this module is available.
1258 StringRef Feature;
Douglas Gregordc58aa72012-01-30 06:01:29 +00001259 if (!Module->isAvailable(getLangOpts(), getTarget(), Feature)) {
Douglas Gregor51f564f2011-12-31 04:05:44 +00001260 getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
1261 << Module->getFullModuleName()
1262 << Feature
1263 << SourceRange(Path.front().second, Path.back().second);
1264 LastModuleImportLoc = ImportLoc;
Douglas Gregor463d9092012-11-29 23:55:25 +00001265 LastModuleImportResult = ModuleLoadResult();
1266 return ModuleLoadResult();
Douglas Gregor51f564f2011-12-31 04:05:44 +00001267 }
1268
Douglas Gregor906d66a2013-03-20 21:10:35 +00001269 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc,
1270 /*Complain=*/true);
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001271 }
Douglas Gregor63a72682013-03-20 00:22:05 +00001272
1273 // Check for any configuration macros that have changed.
1274 clang::Module *TopModule = Module->getTopLevelModule();
1275 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1276 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1277 Module, ImportLoc);
1278 }
1279
Douglas Gregor93ebfa62011-12-02 23:42:12 +00001280 // If this module import was due to an inclusion directive, create an
1281 // implicit import declaration to capture it in the AST.
1282 if (IsInclusionDirective && hasASTContext()) {
1283 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
Argyrios Kyrtzidisd3d98162012-10-03 01:58:37 +00001284 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
1285 ImportLoc, Module,
1286 Path.back().second);
1287 TU->addDecl(ImportD);
1288 if (Consumer)
1289 Consumer->HandleImplicitImportDecl(ImportD);
Douglas Gregor93ebfa62011-12-02 23:42:12 +00001290 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001291
Douglas Gregorb514c792011-11-30 04:26:53 +00001292 LastModuleImportLoc = ImportLoc;
Douglas Gregor463d9092012-11-29 23:55:25 +00001293 LastModuleImportResult = ModuleLoadResult(Module, false);
1294 return LastModuleImportResult;
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001295}
Douglas Gregorca2ab452013-01-12 01:29:50 +00001296
1297void CompilerInstance::makeModuleVisible(Module *Mod,
Argyrios Kyrtzidis5ebcb202013-02-01 16:36:12 +00001298 Module::NameVisibilityKind Visibility,
Douglas Gregor906d66a2013-03-20 21:10:35 +00001299 SourceLocation ImportLoc,
1300 bool Complain){
1301 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc, Complain);
Douglas Gregorca2ab452013-01-12 01:29:50 +00001302}
1303