blob: a20e7d7ed08ec8819bea9a524e0e2336288107c4 [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 ||
65 (ModuleManager && ModuleManager->isGlobalIndexUnavailable())) &&
66 !ModuleBuildFailed;
Douglas Gregorf575d6e2013-01-25 00:45:27 +000067}
68
David Blaikied6471f72011-09-25 23:23:43 +000069void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
Douglas Gregor28019772010-04-05 23:52:57 +000070 Diagnostics = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000071}
72
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000073void CompilerInstance::setTarget(TargetInfo *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000074 Target = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000075}
76
77void CompilerInstance::setFileManager(FileManager *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000078 FileMgr = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000079}
80
NAKAMURA Takumia789ca92011-10-08 11:31:46 +000081void CompilerInstance::setSourceManager(SourceManager *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000082 SourceMgr = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000083}
84
Ted Kremenek4f327862011-03-21 18:40:17 +000085void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; }
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000086
Ted Kremenek4f327862011-03-21 18:40:17 +000087void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; }
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000088
Douglas Gregorf18d0d82010-08-12 23:31:19 +000089void CompilerInstance::setSema(Sema *S) {
90 TheSema.reset(S);
91}
92
Daniel Dunbar12ce6942009-11-14 02:47:17 +000093void CompilerInstance::setASTConsumer(ASTConsumer *Value) {
94 Consumer.reset(Value);
95}
96
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000097void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
98 CompletionConsumer.reset(Value);
99}
100
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000101// Diagnostics
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000102static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000103 const CodeGenOptions *CodeGenOpts,
David Blaikied6471f72011-09-25 23:23:43 +0000104 DiagnosticsEngine &Diags) {
Daniel Dunbar9df23492011-04-07 18:31:10 +0000105 std::string ErrorInfo;
106 bool OwnsStream = false;
Chris Lattner5f9e2722011-07-23 10:55:15 +0000107 raw_ostream *OS = &llvm::errs();
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000108 if (DiagOpts->DiagnosticLogFile != "-") {
Daniel Dunbar9df23492011-04-07 18:31:10 +0000109 // Create the output stream.
110 llvm::raw_fd_ostream *FileOS(
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000111 new llvm::raw_fd_ostream(DiagOpts->DiagnosticLogFile.c_str(),
Daniel Dunbare01eceb2011-04-07 20:19:21 +0000112 ErrorInfo, llvm::raw_fd_ostream::F_Append));
Daniel Dunbar9df23492011-04-07 18:31:10 +0000113 if (!ErrorInfo.empty()) {
114 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
Sean Silvad2ff76b2013-01-20 01:58:26 +0000115 << DiagOpts->DiagnosticLogFile << ErrorInfo;
Daniel Dunbar9df23492011-04-07 18:31:10 +0000116 } else {
117 FileOS->SetUnbuffered();
118 FileOS->SetUseAtomicWrites(true);
119 OS = FileOS;
120 OwnsStream = true;
121 }
122 }
123
124 // Chain in the diagnostic client which will log the diagnostics.
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000125 LogDiagnosticPrinter *Logger = new LogDiagnosticPrinter(*OS, DiagOpts,
126 OwnsStream);
127 if (CodeGenOpts)
128 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
David Blaikie4e85b8a2011-09-26 00:21:47 +0000129 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger));
Daniel Dunbar9df23492011-04-07 18:31:10 +0000130}
131
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000132static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
Ted Kremenek78002122011-10-29 00:12:39 +0000133 DiagnosticsEngine &Diags,
134 StringRef OutputFile) {
135 std::string ErrorInfo;
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000136 OwningPtr<llvm::raw_fd_ostream> OS;
Ted Kremenek78002122011-10-29 00:12:39 +0000137 OS.reset(new llvm::raw_fd_ostream(OutputFile.str().c_str(), ErrorInfo,
138 llvm::raw_fd_ostream::F_Binary));
139
140 if (!ErrorInfo.empty()) {
141 Diags.Report(diag::warn_fe_serialized_diag_failure)
142 << OutputFile << ErrorInfo;
143 return;
144 }
145
146 DiagnosticConsumer *SerializedConsumer =
Ted Kremenek2a764102011-12-17 05:26:11 +0000147 clang::serialized_diags::create(OS.take(), DiagOpts);
Ted Kremenek78002122011-10-29 00:12:39 +0000148
149
150 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(),
151 SerializedConsumer));
152}
153
Sean Silvad47afb92013-01-20 01:58:28 +0000154void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
Douglas Gregoraee526e2011-09-29 00:38:00 +0000155 bool ShouldOwnClient,
156 bool ShouldCloneClient) {
Sean Silvad47afb92013-01-20 01:58:28 +0000157 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
Douglas Gregoraee526e2011-09-29 00:38:00 +0000158 ShouldOwnClient, ShouldCloneClient,
159 &getCodeGenOpts());
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000160}
161
Dylan Noblesmithc93dc782012-02-20 14:00:23 +0000162IntrusiveRefCntPtr<DiagnosticsEngine>
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000163CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
David Blaikie78ad0b92011-09-25 23:39:51 +0000164 DiagnosticConsumer *Client,
Douglas Gregor78243652011-09-13 01:26:44 +0000165 bool ShouldOwnClient,
Douglas Gregoraee526e2011-09-29 00:38:00 +0000166 bool ShouldCloneClient,
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000167 const CodeGenOptions *CodeGenOpts) {
Dylan Noblesmithc93dc782012-02-20 14:00:23 +0000168 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
169 IntrusiveRefCntPtr<DiagnosticsEngine>
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000170 Diags(new DiagnosticsEngine(DiagID, Opts));
Daniel Dunbar221c7212009-11-14 07:53:24 +0000171
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000172 // Create the diagnostic client for reporting errors or for
173 // implementing -verify.
Douglas Gregoraee526e2011-09-29 00:38:00 +0000174 if (Client) {
175 if (ShouldCloneClient)
176 Diags->setClient(Client->clone(*Diags), ShouldOwnClient);
177 else
178 Diags->setClient(Client, ShouldOwnClient);
179 } else
Douglas Gregore47be3e2010-11-11 00:39:14 +0000180 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
Daniel Dunbarf79dced2009-11-14 03:24:39 +0000181
182 // Chain in -verify checker, if requested.
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000183 if (Opts->VerifyDiagnostics)
David Blaikie621bc692011-09-26 00:38:03 +0000184 Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000185
Daniel Dunbar9df23492011-04-07 18:31:10 +0000186 // Chain in -diagnostic-log-file dumper, if requested.
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000187 if (!Opts->DiagnosticLogFile.empty())
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000188 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000189
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000190 if (!Opts->DiagnosticSerializationFile.empty())
Ted Kremenek78002122011-10-29 00:12:39 +0000191 SetupSerializedDiagnostics(Opts, *Diags,
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000192 Opts->DiagnosticSerializationFile);
Ted Kremenek78002122011-10-29 00:12:39 +0000193
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000194 // Configure our handling of diagnostics.
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000195 ProcessWarningOptions(*Diags, *Opts);
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000196
Douglas Gregor28019772010-04-05 23:52:57 +0000197 return Diags;
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000198}
199
200// File Manager
201
Daniel Dunbar16b74492009-11-13 04:12:06 +0000202void CompilerInstance::createFileManager() {
Ted Kremenek4f327862011-03-21 18:40:17 +0000203 FileMgr = new FileManager(getFileSystemOpts());
Daniel Dunbar16b74492009-11-13 04:12:06 +0000204}
205
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000206// Source Manager
207
Chris Lattner39b49bc2010-11-23 08:35:12 +0000208void CompilerInstance::createSourceManager(FileManager &FileMgr) {
Ted Kremenek4f327862011-03-21 18:40:17 +0000209 SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
Daniel Dunbar16b74492009-11-13 04:12:06 +0000210}
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000211
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000212// Preprocessor
213
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000214void CompilerInstance::createPreprocessor() {
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000215 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000216
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000217 // Create a PTH manager if we are using some form of a token cache.
218 PTHManager *PTHMgr = 0;
Daniel Dunbar049d3a02009-11-17 05:52:41 +0000219 if (!PPOpts.TokenCache.empty())
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000220 PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000221
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000222 // Create the Preprocessor.
Douglas Gregorc042edd2012-10-24 16:19:39 +0000223 HeaderSearch *HeaderInfo = new HeaderSearch(&getHeaderSearchOpts(),
224 getFileManager(),
Douglas Gregor51f564f2011-12-31 04:05:44 +0000225 getDiagnostics(),
Douglas Gregordc58aa72012-01-30 06:01:29 +0000226 getLangOpts(),
227 &getTarget());
Douglas Gregor36a16492012-10-24 17:46:57 +0000228 PP = new Preprocessor(&getPreprocessorOpts(),
229 getDiagnostics(), getLangOpts(), &getTarget(),
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000230 getSourceManager(), *HeaderInfo, *this, PTHMgr,
231 /*OwnsHeaderSearch=*/true);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000232
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000233 // Note that this is different then passing PTHMgr to Preprocessor's ctor.
234 // That argument is used as the IdentifierInfoLookup argument to
235 // IdentifierTable's ctor.
236 if (PTHMgr) {
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000237 PTHMgr->setPreprocessor(&*PP);
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000238 PP->setPTHManager(PTHMgr);
239 }
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000240
Douglas Gregor94dc8f62010-03-19 16:15:56 +0000241 if (PPOpts.DetailedRecord)
Argyrios Kyrtzidis37ed1272012-12-04 07:27:05 +0000242 PP->createPreprocessingRecord();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000243
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000244 InitializePreprocessor(*PP, PPOpts, getHeaderSearchOpts(), getFrontendOpts());
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000245
Jordan Rose74c24982013-01-30 01:52:57 +0000246 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
247
Douglas Gregor6e975c42011-09-13 23:15:45 +0000248 // Set up the module path, including the hash for the
249 // module-creation options.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000250 SmallString<256> SpecificModuleCache(
Douglas Gregor6e975c42011-09-13 23:15:45 +0000251 getHeaderSearchOpts().ModuleCachePath);
252 if (!getHeaderSearchOpts().DisableModuleHash)
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000253 llvm::sys::path::append(SpecificModuleCache,
Douglas Gregor6e975c42011-09-13 23:15:45 +0000254 getInvocation().getModuleHash());
Douglas Gregor5e3f9222011-12-08 17:01:29 +0000255 PP->getHeaderSearchInfo().setModuleCachePath(SpecificModuleCache);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000256
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000257 // Handle generating dependencies, if requested.
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000258 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000259 if (!DepOpts.OutputFile.empty())
260 AttachDependencyFileGen(*PP, DepOpts);
Douglas Gregor773303a2012-02-02 23:45:13 +0000261 if (!DepOpts.DOTOutputFile.empty())
262 AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile,
Douglas Gregorc69a1812012-02-02 00:54:52 +0000263 getHeaderSearchOpts().Sysroot);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000264
Douglas Gregorc69a1812012-02-02 00:54:52 +0000265
Daniel Dunbareef63e02011-02-02 15:41:17 +0000266 // Handle generating header include information, if requested.
267 if (DepOpts.ShowHeaderIncludes)
268 AttachHeaderIncludeGen(*PP);
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000269 if (!DepOpts.HeaderIncludeOutputFile.empty()) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000270 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000271 if (OutputPath == "-")
272 OutputPath = "";
Daniel Dunbarda608852011-03-21 19:37:38 +0000273 AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath,
274 /*ShowDepth=*/false);
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000275 }
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000276}
Daniel Dunbar5eb81002009-11-13 08:20:47 +0000277
278// ASTContext
279
280void CompilerInstance::createASTContext() {
281 Preprocessor &PP = getPreprocessor();
Ted Kremenek4f327862011-03-21 18:40:17 +0000282 Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000283 &getTarget(), PP.getIdentifierTable(),
Ted Kremenek4f327862011-03-21 18:40:17 +0000284 PP.getSelectorTable(), PP.getBuiltinInfo(),
285 /*size_reserve=*/ 0);
Daniel Dunbar5eb81002009-11-13 08:20:47 +0000286}
Daniel Dunbar0f800392009-11-13 08:21:10 +0000287
288// ExternalASTSource
289
Chris Lattner5f9e2722011-07-23 10:55:15 +0000290void CompilerInstance::createPCHExternalASTSource(StringRef Path,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000291 bool DisablePCHValidation,
Argyrios Kyrtzidisbef35c92012-03-07 01:51:17 +0000292 bool AllowPCHWithCompilerErrors,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000293 void *DeserializationListener){
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000294 OwningPtr<ExternalASTSource> Source;
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +0000295 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
Daniel Dunbar0f800392009-11-13 08:21:10 +0000296 Source.reset(createPCHExternalASTSource(Path, getHeaderSearchOpts().Sysroot,
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000297 DisablePCHValidation,
Argyrios Kyrtzidisbef35c92012-03-07 01:51:17 +0000298 AllowPCHWithCompilerErrors,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000299 getPreprocessor(), getASTContext(),
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +0000300 DeserializationListener,
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000301 Preamble,
302 getFrontendOpts().UseGlobalModuleIndex));
Douglas Gregorf62d43d2011-07-19 16:10:42 +0000303 ModuleManager = static_cast<ASTReader*>(Source.get());
Daniel Dunbar0f800392009-11-13 08:21:10 +0000304 getASTContext().setExternalSource(Source);
305}
306
307ExternalASTSource *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000308CompilerInstance::createPCHExternalASTSource(StringRef Path,
Daniel Dunbar0f800392009-11-13 08:21:10 +0000309 const std::string &Sysroot,
Douglas Gregorfae3b2f2010-07-27 00:27:13 +0000310 bool DisablePCHValidation,
Argyrios Kyrtzidisbef35c92012-03-07 01:51:17 +0000311 bool AllowPCHWithCompilerErrors,
Daniel Dunbar0f800392009-11-13 08:21:10 +0000312 Preprocessor &PP,
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000313 ASTContext &Context,
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +0000314 void *DeserializationListener,
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000315 bool Preamble,
316 bool UseGlobalModuleIndex) {
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000317 OwningPtr<ASTReader> Reader;
Douglas Gregorf8a1e512011-09-02 00:26:20 +0000318 Reader.reset(new ASTReader(PP, Context,
Douglas Gregor832d6202011-07-22 16:35:34 +0000319 Sysroot.empty() ? "" : Sysroot.c_str(),
Argyrios Kyrtzidis4182ed62012-10-31 20:59:50 +0000320 DisablePCHValidation,
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000321 AllowPCHWithCompilerErrors,
322 UseGlobalModuleIndex));
Daniel Dunbar0f800392009-11-13 08:21:10 +0000323
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000324 Reader->setDeserializationListener(
Sebastian Redl571db7f2010-08-18 23:56:56 +0000325 static_cast<ASTDeserializationListener *>(DeserializationListener));
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000326 switch (Reader->ReadAST(Path,
327 Preamble ? serialization::MK_Preamble
Douglas Gregor38295be2012-10-22 23:51:00 +0000328 : serialization::MK_PCH,
Argyrios Kyrtzidis958bcaf2012-11-15 18:57:22 +0000329 SourceLocation(),
Douglas Gregor38295be2012-10-22 23:51:00 +0000330 ASTReader::ARR_None)) {
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000331 case ASTReader::Success:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000332 // Set the predefines buffer as suggested by the PCH reader. Typically, the
333 // predefines buffer will be empty.
334 PP.setPredefines(Reader->getSuggestedPredefines());
335 return Reader.take();
336
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000337 case ASTReader::Failure:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000338 // Unrecoverable failure: don't even try to process the input file.
339 break;
340
Douglas Gregor677e15f2013-03-19 00:28:20 +0000341 case ASTReader::Missing:
Douglas Gregor4825fd72012-10-22 22:50:17 +0000342 case ASTReader::OutOfDate:
343 case ASTReader::VersionMismatch:
344 case ASTReader::ConfigurationMismatch:
345 case ASTReader::HadErrors:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000346 // No suitable PCH file could be found. Return an error.
347 break;
348 }
349
350 return 0;
351}
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000352
353// Code Completion
354
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000355static bool EnableCodeCompletion(Preprocessor &PP,
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000356 const std::string &Filename,
357 unsigned Line,
358 unsigned Column) {
359 // Tell the source manager to chop off the given file at a specific
360 // line and column.
Chris Lattner39b49bc2010-11-23 08:35:12 +0000361 const FileEntry *Entry = PP.getFileManager().getFile(Filename);
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000362 if (!Entry) {
363 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
364 << Filename;
365 return true;
366 }
367
368 // Truncate the named file at the given line/column.
369 PP.SetCodeCompletionPoint(Entry, Line, Column);
370 return false;
371}
372
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000373void CompilerInstance::createCodeCompletionConsumer() {
374 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000375 if (!CompletionConsumer) {
Erik Verbruggen9bc0c292012-04-12 10:31:12 +0000376 setCodeCompletionConsumer(
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000377 createCodeCompletionConsumer(getPreprocessor(),
378 Loc.FileName, Loc.Line, Loc.Column,
Dmitri Gribenkod99ef532012-07-02 17:35:10 +0000379 getFrontendOpts().CodeCompleteOpts,
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000380 llvm::outs()));
381 if (!CompletionConsumer)
382 return;
383 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
384 Loc.Line, Loc.Column)) {
Erik Verbruggen9bc0c292012-04-12 10:31:12 +0000385 setCodeCompletionConsumer(0);
Douglas Gregorc3d43b72010-03-16 06:04:47 +0000386 return;
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000387 }
Douglas Gregor2b4074f2009-12-01 05:55:20 +0000388
389 if (CompletionConsumer->isOutputBinary() &&
390 llvm::sys::Program::ChangeStdoutToBinary()) {
391 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
Erik Verbruggen9bc0c292012-04-12 10:31:12 +0000392 setCodeCompletionConsumer(0);
Douglas Gregor2b4074f2009-12-01 05:55:20 +0000393 }
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000394}
395
Kovarththanan Rajaratnamf79bafa2009-11-29 09:57:35 +0000396void CompilerInstance::createFrontendTimer() {
397 FrontendTimer.reset(new llvm::Timer("Clang front-end timer"));
398}
399
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000400CodeCompleteConsumer *
401CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
402 const std::string &Filename,
403 unsigned Line,
404 unsigned Column,
Dmitri Gribenkod99ef532012-07-02 17:35:10 +0000405 const CodeCompleteOptions &Opts,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000406 raw_ostream &OS) {
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000407 if (EnableCodeCompletion(PP, Filename, Line, Column))
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000408 return 0;
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000409
410 // Set up the creation routine for code-completion.
Dmitri Gribenkod99ef532012-07-02 17:35:10 +0000411 return new PrintingCodeCompleteConsumer(Opts, OS);
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000412}
Daniel Dunbara9204832009-11-13 10:37:48 +0000413
Douglas Gregor467dc882011-08-25 22:30:56 +0000414void CompilerInstance::createSema(TranslationUnitKind TUKind,
Douglas Gregorf18d0d82010-08-12 23:31:19 +0000415 CodeCompleteConsumer *CompletionConsumer) {
416 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
Douglas Gregor467dc882011-08-25 22:30:56 +0000417 TUKind, CompletionConsumer));
Douglas Gregorf18d0d82010-08-12 23:31:19 +0000418}
419
Daniel Dunbara9204832009-11-13 10:37:48 +0000420// Output Files
421
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000422void CompilerInstance::addOutputFile(const OutputFile &OutFile) {
423 assert(OutFile.OS && "Attempt to add empty stream to output list!");
424 OutputFiles.push_back(OutFile);
Daniel Dunbara9204832009-11-13 10:37:48 +0000425}
426
Kovarththanan Rajaratname51dd7b2010-03-06 12:07:48 +0000427void CompilerInstance::clearOutputFiles(bool EraseFiles) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000428 for (std::list<OutputFile>::iterator
Daniel Dunbara9204832009-11-13 10:37:48 +0000429 it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000430 delete it->OS;
431 if (!it->TempFilename.empty()) {
Anders Carlssonaf036a62011-03-06 22:25:35 +0000432 if (EraseFiles) {
433 bool existed;
434 llvm::sys::fs::remove(it->TempFilename, existed);
435 } else {
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000436 SmallString<128> NewOutFile(it->Filename);
Anders Carlssonaf036a62011-03-06 22:25:35 +0000437
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +0000438 // If '-working-directory' was passed, the output filename should be
439 // relative to that.
Anders Carlsson2e2468e2011-03-14 01:13:54 +0000440 FileMgr->FixupRelativePath(NewOutFile);
Anders Carlssonaf036a62011-03-06 22:25:35 +0000441 if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename,
442 NewOutFile.str())) {
Manuel Klimek832a2aa2012-05-16 20:55:58 +0000443 getDiagnostics().Report(diag::err_unable_to_rename_temp)
Anders Carlssonaf036a62011-03-06 22:25:35 +0000444 << it->TempFilename << it->Filename << ec.message();
445
446 bool existed;
447 llvm::sys::fs::remove(it->TempFilename, existed);
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000448 }
449 }
450 } else if (!it->Filename.empty() && EraseFiles)
451 llvm::sys::Path(it->Filename).eraseFromDisk();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000452
Daniel Dunbara9204832009-11-13 10:37:48 +0000453 }
454 OutputFiles.clear();
455}
456
Daniel Dunbarf482d592009-11-13 18:32:08 +0000457llvm::raw_fd_ostream *
458CompilerInstance::createDefaultOutputFile(bool Binary,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000459 StringRef InFile,
460 StringRef Extension) {
Daniel Dunbarf482d592009-11-13 18:32:08 +0000461 return createOutputFile(getFrontendOpts().OutputFile, Binary,
Daniel Dunbare21dd282012-03-03 00:36:06 +0000462 /*RemoveFileOnSignal=*/true, InFile, Extension,
463 /*UseTemporary=*/true);
Daniel Dunbarf482d592009-11-13 18:32:08 +0000464}
465
466llvm::raw_fd_ostream *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000467CompilerInstance::createOutputFile(StringRef OutputPath,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000468 bool Binary, bool RemoveFileOnSignal,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000469 StringRef InFile,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000470 StringRef Extension,
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000471 bool UseTemporary,
472 bool CreateMissingDirectories) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000473 std::string Error, OutputPathName, TempPathName;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000474 llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000475 RemoveFileOnSignal,
Daniel Dunbarf482d592009-11-13 18:32:08 +0000476 InFile, Extension,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000477 UseTemporary,
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000478 CreateMissingDirectories,
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000479 &OutputPathName,
480 &TempPathName);
Daniel Dunbarf482d592009-11-13 18:32:08 +0000481 if (!OS) {
Daniel Dunbar36043592009-12-03 09:13:30 +0000482 getDiagnostics().Report(diag::err_fe_unable_to_open_output)
483 << OutputPath << Error;
484 return 0;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000485 }
486
487 // Add the output file -- but don't try to remove "-", since this means we are
488 // using stdin.
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000489 addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "",
490 TempPathName, OS));
Daniel Dunbarf482d592009-11-13 18:32:08 +0000491
492 return OS;
493}
494
495llvm::raw_fd_ostream *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000496CompilerInstance::createOutputFile(StringRef OutputPath,
Daniel Dunbarf482d592009-11-13 18:32:08 +0000497 std::string &Error,
498 bool Binary,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000499 bool RemoveFileOnSignal,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000500 StringRef InFile,
501 StringRef Extension,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000502 bool UseTemporary,
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000503 bool CreateMissingDirectories,
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000504 std::string *ResultPathName,
505 std::string *TempPathName) {
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000506 assert((!CreateMissingDirectories || UseTemporary) &&
507 "CreateMissingDirectories is only allowed when using temporary files");
508
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000509 std::string OutFile, TempFile;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000510 if (!OutputPath.empty()) {
511 OutFile = OutputPath;
512 } else if (InFile == "-") {
513 OutFile = "-";
514 } else if (!Extension.empty()) {
515 llvm::sys::Path Path(InFile);
516 Path.eraseSuffix();
517 Path.appendSuffix(Extension);
518 OutFile = Path.str();
519 } else {
520 OutFile = "-";
521 }
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000522
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000523 OwningPtr<llvm::raw_fd_ostream> OS;
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000524 std::string OSFile;
525
526 if (UseTemporary && OutFile != "-") {
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000527 // Only create the temporary if the parent directory exists (or create
528 // missing directories is true) and we can actually write to OutPath,
529 // otherwise we want to fail early.
530 SmallString<256> AbsPath(OutputPath);
531 llvm::sys::fs::make_absolute(AbsPath);
532 llvm::sys::Path OutPath(AbsPath);
533 bool ParentExists = false;
534 if (llvm::sys::fs::exists(llvm::sys::path::parent_path(AbsPath.str()),
535 ParentExists))
536 ParentExists = false;
Michael J. Spencer32bef4e2011-01-10 02:34:13 +0000537 bool Exists;
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000538 if ((CreateMissingDirectories || ParentExists) &&
539 ((llvm::sys::fs::exists(AbsPath.str(), Exists) || !Exists) ||
540 (OutPath.isRegularFile() && OutPath.canWrite()))) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000541 // Create a temporary file.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000542 SmallString<128> TempPath;
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000543 TempPath = OutFile;
544 TempPath += "-%%%%%%%%";
545 int fd;
546 if (llvm::sys::fs::unique_file(TempPath.str(), fd, TempPath,
Eric Christopher7d9ae252012-05-11 00:10:07 +0000547 /*makeAbsolute=*/false, 0664)
548 == llvm::errc::success) {
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000549 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
550 OSFile = TempFile = TempPath.str();
551 }
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000552 }
553 }
554
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000555 if (!OS) {
556 OSFile = OutFile;
557 OS.reset(
558 new llvm::raw_fd_ostream(OSFile.c_str(), Error,
559 (Binary ? llvm::raw_fd_ostream::F_Binary : 0)));
560 if (!Error.empty())
561 return 0;
562 }
Daniel Dunbarf482d592009-11-13 18:32:08 +0000563
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000564 // Make sure the out stream file gets removed if we crash.
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000565 if (RemoveFileOnSignal)
566 llvm::sys::RemoveFileOnSignal(llvm::sys::Path(OSFile));
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000567
Daniel Dunbarf482d592009-11-13 18:32:08 +0000568 if (ResultPathName)
569 *ResultPathName = OutFile;
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000570 if (TempPathName)
571 *TempPathName = TempFile;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000572
Daniel Dunbarfc971022009-11-20 22:32:38 +0000573 return OS.take();
Daniel Dunbarf482d592009-11-13 18:32:08 +0000574}
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000575
576// Initialization Utilities
577
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000578bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
579 return InitializeSourceManager(Input, getDiagnostics(),
Douglas Gregora1f1fad2012-01-27 19:52:33 +0000580 getFileManager(), getSourceManager(),
581 getFrontendOpts());
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000582}
583
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000584bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input,
David Blaikied6471f72011-09-25 23:23:43 +0000585 DiagnosticsEngine &Diags,
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000586 FileManager &FileMgr,
587 SourceManager &SourceMgr,
588 const FrontendOptions &Opts) {
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000589 SrcMgr::CharacteristicKind
Argyrios Kyrtzidis8616f9a2012-11-09 19:40:39 +0000590 Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000591
Argyrios Kyrtzidisecd27bf2012-11-09 19:40:45 +0000592 if (Input.isBuffer()) {
593 SourceMgr.createMainFileIDForMemBuffer(Input.getBuffer(), Kind);
594 assert(!SourceMgr.getMainFileID().isInvalid() &&
595 "Couldn't establish MainFileID!");
596 return true;
597 }
598
599 StringRef InputFile = Input.getFile();
600
Argyrios Kyrtzidis507097e2011-09-19 20:40:35 +0000601 // Figure out where to get and map in the main file.
602 if (InputFile != "-") {
Chris Lattner39b49bc2010-11-23 08:35:12 +0000603 const FileEntry *File = FileMgr.getFile(InputFile);
Dan Gohman694137c2010-10-26 21:13:51 +0000604 if (!File) {
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000605 Diags.Report(diag::err_fe_error_reading) << InputFile;
606 return false;
607 }
Daniel Dunbarce36ecd2012-11-05 22:53:33 +0000608
609 // The natural SourceManager infrastructure can't currently handle named
610 // pipes, but we would at least like to accept them for the main
611 // file. Detect them here, read them with the more generic MemoryBuffer
612 // function, and simply override their contents as we do for STDIN.
613 if (File->isNamedPipe()) {
614 OwningPtr<llvm::MemoryBuffer> MB;
615 if (llvm::error_code ec = llvm::MemoryBuffer::getFile(InputFile, MB)) {
616 Diags.Report(diag::err_cannot_open_file) << InputFile << ec.message();
617 return false;
618 }
Daniel Dunbaracf36122012-11-27 00:04:16 +0000619
620 // Create a new virtual file that will have the correct size.
621 File = FileMgr.getVirtualFile(InputFile, MB->getBufferSize(), 0);
Daniel Dunbarce36ecd2012-11-05 22:53:33 +0000622 SourceMgr.overrideFileContents(File, MB.take());
623 }
Daniel Dunbaracf36122012-11-27 00:04:16 +0000624
625 SourceMgr.createMainFileID(File, Kind);
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000626 } else {
Dylan Noblesmith6f42b622012-02-05 02:12:40 +0000627 OwningPtr<llvm::MemoryBuffer> SB;
Michael J. Spencer4eeebc42010-12-16 03:28:14 +0000628 if (llvm::MemoryBuffer::getSTDIN(SB)) {
Michael J. Spencer3a321e22010-12-09 17:36:38 +0000629 // FIXME: Give ec.message() in this diag.
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000630 Diags.Report(diag::err_fe_error_reading_stdin);
631 return false;
632 }
Dan Gohman90d90812010-10-26 23:21:25 +0000633 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
Chris Lattner39b49bc2010-11-23 08:35:12 +0000634 SB->getBufferSize(), 0);
Douglas Gregora1f1fad2012-01-27 19:52:33 +0000635 SourceMgr.createMainFileID(File, Kind);
Michael J. Spencer4eeebc42010-12-16 03:28:14 +0000636 SourceMgr.overrideFileContents(File, SB.take());
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000637 }
638
Dan Gohman694137c2010-10-26 21:13:51 +0000639 assert(!SourceMgr.getMainFileID().isInvalid() &&
640 "Couldn't establish MainFileID!");
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000641 return true;
642}
Daniel Dunbar0397af22010-01-13 00:48:06 +0000643
644// High-Level Operations
645
646bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
647 assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
648 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
649 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
650
651 // FIXME: Take this as an argument, once all the APIs we used have moved to
652 // taking it as an input instead of hard-coding llvm::errs.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000653 raw_ostream &OS = llvm::errs();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000654
655 // Create the target instance.
Douglas Gregor49a87542012-11-16 04:24:59 +0000656 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), &getTargetOpts()));
Daniel Dunbar0397af22010-01-13 00:48:06 +0000657 if (!hasTarget())
658 return false;
659
660 // Inform the target of the language options.
661 //
662 // FIXME: We shouldn't need to do this, the target should be immutable once
663 // created. This complexity should be lifted elsewhere.
664 getTarget().setForcedLangOptions(getLangOpts());
665
Fariborz Jahanian93a49942012-04-16 21:03:30 +0000666 // rewriter project will change target built-in bool type from its default.
667 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
668 getTarget().noSignedCharForObjCBool();
669
Daniel Dunbar0397af22010-01-13 00:48:06 +0000670 // Validate/process some options.
671 if (getHeaderSearchOpts().Verbose)
672 OS << "clang -cc1 version " CLANG_VERSION_STRING
673 << " based upon " << PACKAGE_STRING
Sebastian Pop5d8b9542011-11-01 21:33:06 +0000674 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
Daniel Dunbar0397af22010-01-13 00:48:06 +0000675
676 if (getFrontendOpts().ShowTimers)
677 createFrontendTimer();
678
Douglas Gregor95dd5582010-03-30 17:33:59 +0000679 if (getFrontendOpts().ShowStats)
680 llvm::EnableStatistics();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000681
Daniel Dunbar0397af22010-01-13 00:48:06 +0000682 for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) {
Daniel Dunbar20560482010-06-07 23:23:50 +0000683 // Reset the ID tables if we are reusing the SourceManager.
684 if (hasSourceManager())
685 getSourceManager().clearIDTables();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000686
Douglas Gregor1f6b2b52012-01-20 16:28:04 +0000687 if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) {
Daniel Dunbar0397af22010-01-13 00:48:06 +0000688 Act.Execute();
689 Act.EndSourceFile();
690 }
691 }
692
Argyrios Kyrtzidis29f27872011-12-07 05:52:12 +0000693 // Notify the diagnostic client that all files were processed.
694 getDiagnostics().getClient()->finish();
695
Chris Lattner53eee7b2010-04-07 18:47:42 +0000696 if (getDiagnosticOpts().ShowCarets) {
Argyrios Kyrtzidisf2224d82010-11-18 20:06:46 +0000697 // We can have multiple diagnostics sharing one diagnostic client.
698 // Get the total number of warnings/errors from the client.
699 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
700 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000701
Chris Lattner53eee7b2010-04-07 18:47:42 +0000702 if (NumWarnings)
703 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
704 if (NumWarnings && NumErrors)
705 OS << " and ";
706 if (NumErrors)
707 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
708 if (NumWarnings || NumErrors)
709 OS << " generated.\n";
710 }
Daniel Dunbar0397af22010-01-13 00:48:06 +0000711
Daniel Dunbar20560482010-06-07 23:23:50 +0000712 if (getFrontendOpts().ShowStats && hasFileManager()) {
Daniel Dunbar0397af22010-01-13 00:48:06 +0000713 getFileManager().PrintStats();
714 OS << "\n";
715 }
716
Argyrios Kyrtzidisab41b972010-11-18 21:13:57 +0000717 return !getDiagnostics().getClient()->getNumErrors();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000718}
719
Douglas Gregor21cae202011-09-12 23:31:24 +0000720/// \brief Determine the appropriate source input kind based on language
721/// options.
722static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
723 if (LangOpts.OpenCL)
724 return IK_OpenCL;
725 if (LangOpts.CUDA)
726 return IK_CUDA;
727 if (LangOpts.ObjC1)
728 return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
729 return LangOpts.CPlusPlus? IK_CXX : IK_C;
730}
731
Douglas Gregor0ced7992011-10-04 00:21:21 +0000732namespace {
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000733 struct CompileModuleMapData {
734 CompilerInstance &Instance;
735 GenerateModuleAction &CreateModuleAction;
736 };
737}
738
739/// \brief Helper function that executes the module-generating action under
740/// a crash recovery context.
741static void doCompileMapModule(void *UserData) {
742 CompileModuleMapData &Data
743 = *reinterpret_cast<CompileModuleMapData *>(UserData);
744 Data.Instance.ExecuteAction(Data.CreateModuleAction);
745}
746
Douglas Gregor2a060852013-02-07 00:21:12 +0000747namespace {
748 /// \brief Function object that checks with the given macro definition should
749 /// be removed, because it is one of the ignored macros.
750 class RemoveIgnoredMacro {
751 const HeaderSearchOptions &HSOpts;
752
753 public:
754 explicit RemoveIgnoredMacro(const HeaderSearchOptions &HSOpts)
755 : HSOpts(HSOpts) { }
756
757 bool operator()(const std::pair<std::string, bool> &def) const {
Douglas Gregor005d51b2013-02-07 01:18:48 +0000758 StringRef MacroDef = def.first;
759 return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0;
Douglas Gregor2a060852013-02-07 00:21:12 +0000760 }
761 };
762}
763
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000764/// \brief Compile a module file for the given module, using the options
765/// provided by the importing compiler instance.
Douglas Gregor21cae202011-09-12 23:31:24 +0000766static void compileModule(CompilerInstance &ImportingInstance,
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000767 SourceLocation ImportLoc,
Douglas Gregor1a4761e2011-11-30 23:21:26 +0000768 Module *Module,
Douglas Gregor933e7a62011-11-29 18:31:39 +0000769 StringRef ModuleFileName) {
Douglas Gregor52f12722012-01-29 20:15:24 +0000770 llvm::LockFileManager Locked(ModuleFileName);
Douglas Gregor2bc75072011-10-05 14:53:30 +0000771 switch (Locked) {
Douglas Gregor52f12722012-01-29 20:15:24 +0000772 case llvm::LockFileManager::LFS_Error:
Douglas Gregor2bc75072011-10-05 14:53:30 +0000773 return;
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000774
Douglas Gregor52f12722012-01-29 20:15:24 +0000775 case llvm::LockFileManager::LFS_Owned:
Douglas Gregor2bc75072011-10-05 14:53:30 +0000776 // We're responsible for building the module ourselves. Do so below.
777 break;
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000778
Douglas Gregor52f12722012-01-29 20:15:24 +0000779 case llvm::LockFileManager::LFS_Shared:
Douglas Gregor2bc75072011-10-05 14:53:30 +0000780 // Someone else is responsible for building the module. Wait for them to
781 // finish.
782 Locked.waitForUnlock();
Douglas Gregor7cdd2812012-11-07 17:46:15 +0000783 return;
Douglas Gregor2bc75072011-10-05 14:53:30 +0000784 }
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000785
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000786 ModuleMap &ModMap
787 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
788
Douglas Gregor21cae202011-09-12 23:31:24 +0000789 // Construct a compiler invocation for creating this module.
Dylan Noblesmithc93dc782012-02-20 14:00:23 +0000790 IntrusiveRefCntPtr<CompilerInvocation> Invocation
Douglas Gregor21cae202011-09-12 23:31:24 +0000791 (new CompilerInvocation(ImportingInstance.getInvocation()));
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000792
Douglas Gregor18ee5472011-11-29 21:59:16 +0000793 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
794
Douglas Gregorb2d39c22011-09-15 20:53:28 +0000795 // For any options that aren't intended to affect how a module is built,
796 // reset them to their default values.
Ted Kremenekd3b74d92011-11-17 23:01:24 +0000797 Invocation->getLangOpts()->resetNonModularOptions();
Douglas Gregor18ee5472011-11-29 21:59:16 +0000798 PPOpts.resetNonModularOptions();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000799
Douglas Gregor2a060852013-02-07 00:21:12 +0000800 // Remove any macro definitions that are explicitly ignored by the module.
801 // They aren't supposed to affect how the module is built anyway.
802 const HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
803 PPOpts.Macros.erase(std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
804 RemoveIgnoredMacro(HSOpts)),
805 PPOpts.Macros.end());
806
807
Douglas Gregorb86b8dc2011-11-15 19:35:01 +0000808 // Note the name of the module we're building.
Douglas Gregor933e7a62011-11-29 18:31:39 +0000809 Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
Douglas Gregorb86b8dc2011-11-15 19:35:01 +0000810
Douglas Gregor463d9092012-11-29 23:55:25 +0000811 // Make sure that the failed-module structure has been allocated in
812 // the importing instance, and propagate the pointer to the newly-created
813 // instance.
814 PreprocessorOptions &ImportingPPOpts
815 = ImportingInstance.getInvocation().getPreprocessorOpts();
816 if (!ImportingPPOpts.FailedModules)
817 ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet;
818 PPOpts.FailedModules = ImportingPPOpts.FailedModules;
819
Douglas Gregor18ee5472011-11-29 21:59:16 +0000820 // If there is a module map file, build the module using the module map.
Douglas Gregorb2d39c22011-09-15 20:53:28 +0000821 // Set up the inputs/outputs so that we build the module from its umbrella
822 // header.
Douglas Gregor21cae202011-09-12 23:31:24 +0000823 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
Douglas Gregor6e975c42011-09-13 23:15:45 +0000824 FrontendOpts.OutputFile = ModuleFileName.str();
Douglas Gregor21cae202011-09-12 23:31:24 +0000825 FrontendOpts.DisableFree = false;
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000826 FrontendOpts.GenerateGlobalModuleIndex = false;
Douglas Gregor21cae202011-09-12 23:31:24 +0000827 FrontendOpts.Inputs.clear();
Douglas Gregor18ee5472011-11-29 21:59:16 +0000828 InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000829
Douglas Gregor18ee5472011-11-29 21:59:16 +0000830 // Get or create the module map that we'll use to build this module.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000831 SmallString<128> TempModuleMapFileName;
Douglas Gregor18ee5472011-11-29 21:59:16 +0000832 if (const FileEntry *ModuleMapFile
833 = ModMap.getContainingModuleMapFile(Module)) {
834 // Use the module map where this module resides.
Douglas Gregor1f6b2b52012-01-20 16:28:04 +0000835 FrontendOpts.Inputs.push_back(FrontendInputFile(ModuleMapFile->getName(),
836 IK));
Douglas Gregor18ee5472011-11-29 21:59:16 +0000837 } else {
838 // Create a temporary module map file.
839 TempModuleMapFileName = Module->Name;
840 TempModuleMapFileName += "-%%%%%%%%.map";
841 int FD;
842 if (llvm::sys::fs::unique_file(TempModuleMapFileName.str(), FD,
843 TempModuleMapFileName,
Douglas Gregor1e821e92011-12-06 22:05:29 +0000844 /*makeAbsolute=*/true)
Douglas Gregore9120292011-12-06 23:04:08 +0000845 != llvm::errc::success) {
Douglas Gregorf64114b2011-12-07 00:54:14 +0000846 ImportingInstance.getDiagnostics().Report(diag::err_module_map_temp_file)
847 << TempModuleMapFileName;
Douglas Gregor18ee5472011-11-29 21:59:16 +0000848 return;
Douglas Gregore9120292011-12-06 23:04:08 +0000849 }
Douglas Gregor18ee5472011-11-29 21:59:16 +0000850 // Print the module map to this file.
851 llvm::raw_fd_ostream OS(FD, /*shouldClose=*/true);
852 Module->print(OS);
853 FrontendOpts.Inputs.push_back(
Douglas Gregor1f6b2b52012-01-20 16:28:04 +0000854 FrontendInputFile(TempModuleMapFileName.str().str(), IK));
Douglas Gregor18ee5472011-11-29 21:59:16 +0000855 }
856
857 // Don't free the remapped file buffers; they are owned by our caller.
858 PPOpts.RetainRemappedFileBuffers = true;
859
Douglas Gregor78243652011-09-13 01:26:44 +0000860 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
Douglas Gregor76d991e2011-09-13 23:20:27 +0000861 assert(ImportingInstance.getInvocation().getModuleHash() ==
Douglas Gregor18ee5472011-11-29 21:59:16 +0000862 Invocation->getModuleHash() && "Module hash mismatch!");
863
Douglas Gregor21cae202011-09-12 23:31:24 +0000864 // Construct a compiler instance that will be used to actually create the
865 // module.
866 CompilerInstance Instance;
867 Instance.setInvocation(&*Invocation);
Sean Silvad47afb92013-01-20 01:58:28 +0000868 Instance.createDiagnostics(&ImportingInstance.getDiagnosticClient(),
Douglas Gregoraee526e2011-09-29 00:38:00 +0000869 /*ShouldOwnClient=*/true,
870 /*ShouldCloneClient=*/true);
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000871
Douglas Gregor4565e482012-11-30 22:11:57 +0000872 // Note that this module is part of the module build stack, so that we
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000873 // can detect cycles in the module graph.
874 Instance.createFileManager(); // FIXME: Adopt file manager from importer?
875 Instance.createSourceManager(Instance.getFileManager());
876 SourceManager &SourceMgr = Instance.getSourceManager();
Douglas Gregor4565e482012-11-30 22:11:57 +0000877 SourceMgr.setModuleBuildStack(
878 ImportingInstance.getSourceManager().getModuleBuildStack());
879 SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(),
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000880 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
881
882
Douglas Gregor21cae202011-09-12 23:31:24 +0000883 // Construct a module-generating action.
Douglas Gregor18ee5472011-11-29 21:59:16 +0000884 GenerateModuleAction CreateModuleAction;
885
Douglas Gregor0ced7992011-10-04 00:21:21 +0000886 // Execute the action to actually build the module in-place. Use a separate
887 // thread so that we get a stack large enough.
888 const unsigned ThreadStackSize = 8 << 20;
889 llvm::CrashRecoveryContext CRC;
Douglas Gregor18ee5472011-11-29 21:59:16 +0000890 CompileModuleMapData Data = { Instance, CreateModuleAction };
891 CRC.RunSafelyOnThread(&doCompileMapModule, &Data, ThreadStackSize);
892
893 // Delete the temporary module map file.
894 // FIXME: Even though we're executing under crash protection, it would still
895 // be nice to do this with RemoveFileOnSignal when we can. However, that
896 // doesn't make sense for all clients, so clean this up manually.
Benjamin Kramera2e94892012-10-14 19:50:53 +0000897 Instance.clearOutputFiles(/*EraseFiles=*/true);
Douglas Gregor18ee5472011-11-29 21:59:16 +0000898 if (!TempModuleMapFileName.empty())
899 llvm::sys::Path(TempModuleMapFileName).eraseFromDisk();
Douglas Gregora6b00fc2013-01-23 22:38:11 +0000900
901 // We've rebuilt a module. If we're allowed to generate or update the global
902 // module index, record that fact in the importing compiler instance.
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000903 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
Douglas Gregora6b00fc2013-01-23 22:38:11 +0000904 ImportingInstance.setBuildGlobalModuleIndex(true);
905 }
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000906}
Douglas Gregor21cae202011-09-12 23:31:24 +0000907
Douglas Gregor63a72682013-03-20 00:22:05 +0000908/// \brief Diagnose differences between the current definition of the given
909/// configuration macro and the definition provided on the command line.
910static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
911 Module *Mod, SourceLocation ImportLoc) {
912 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
913 SourceManager &SourceMgr = PP.getSourceManager();
914
915 // If this identifier has never had a macro definition, then it could
916 // not have changed.
917 if (!Id->hadMacroDefinition())
918 return;
919
920 // If this identifier does not currently have a macro definition,
921 // check whether it had one on the command line.
922 if (!Id->hasMacroDefinition()) {
923 MacroDirective *UndefMD = PP.getMacroDirectiveHistory(Id);
924 for (MacroDirective *MD = UndefMD; MD; MD = MD->getPrevious()) {
925
926 FileID FID = SourceMgr.getFileID(MD->getLocation());
927 if (FID.isInvalid())
928 continue;
929
930 const llvm::MemoryBuffer *Buffer = SourceMgr.getBuffer(FID);
931 if (!Buffer)
932 continue;
933
934 // We only care about the predefines buffer.
935 if (!StringRef(Buffer->getBufferIdentifier()).equals("<built-in>"))
936 continue;
937
938 // This macro was defined on the command line, then #undef'd later.
939 // Complain.
940 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
941 << true << ConfigMacro << Mod->getFullModuleName();
942 if (UndefMD->getUndefLoc().isValid())
943 PP.Diag(UndefMD->getUndefLoc(), diag::note_module_def_undef_here)
944 << true;
945 return;
946 }
947
948 // Okay: no definition in the predefines buffer.
949 return;
950 }
951
952 // This identifier has a macro definition. Check whether we had a definition
953 // on the command line.
954 MacroDirective *DefMD = PP.getMacroDirective(Id);
955 MacroDirective *PredefinedMD = 0;
956 for (MacroDirective *MD = DefMD; MD; MD = MD->getPrevious()) {
957 FileID FID = SourceMgr.getFileID(MD->getLocation());
958 if (FID.isInvalid())
959 continue;
960
961 const llvm::MemoryBuffer *Buffer = SourceMgr.getBuffer(FID);
962 if (!Buffer)
963 continue;
964
965 // We only care about the predefines buffer.
966 if (!StringRef(Buffer->getBufferIdentifier()).equals("<built-in>"))
967 continue;
968
969 PredefinedMD = MD;
970 break;
971 }
972
973 // If there was no definition for this macro in the predefines buffer,
974 // complain.
975 if (!PredefinedMD ||
976 (!PredefinedMD->getLocation().isValid() &&
977 PredefinedMD->getUndefLoc().isValid())) {
978 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
979 << false << ConfigMacro << Mod->getFullModuleName();
980 PP.Diag(DefMD->getLocation(), diag::note_module_def_undef_here)
981 << false;
982 return;
983 }
984
985 // If the current macro definition is the same as the predefined macro
986 // definition, it's okay.
987 if (DefMD == PredefinedMD ||
988 DefMD->getInfo()->isIdenticalTo(*PredefinedMD->getInfo(), PP))
989 return;
990
991 // The macro definitions differ.
992 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
993 << false << ConfigMacro << Mod->getFullModuleName();
994 PP.Diag(DefMD->getLocation(), diag::note_module_def_undef_here)
995 << false;
996}
997
Douglas Gregor463d9092012-11-29 23:55:25 +0000998ModuleLoadResult
999CompilerInstance::loadModule(SourceLocation ImportLoc,
1000 ModuleIdPath Path,
1001 Module::NameVisibilityKind Visibility,
1002 bool IsInclusionDirective) {
Douglas Gregorb514c792011-11-30 04:26:53 +00001003 // If we've already handled this import, just return the cached result.
1004 // This one-element cache is important to eliminate redundant diagnostics
1005 // when both the preprocessor and parser see the same import declaration.
Douglas Gregor5e356932011-12-01 17:11:21 +00001006 if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) {
1007 // Make the named module visible.
1008 if (LastModuleImportResult)
Argyrios Kyrtzidis5ebcb202013-02-01 16:36:12 +00001009 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
1010 ImportLoc);
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001011 return LastModuleImportResult;
Douglas Gregor5e356932011-12-01 17:11:21 +00001012 }
Douglas Gregorb514c792011-11-30 04:26:53 +00001013
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001014 // Determine what file we're searching from.
Douglas Gregor3d3589d2011-11-30 00:36:36 +00001015 StringRef ModuleName = Path[0].first->getName();
1016 SourceLocation ModuleNameLoc = Path[0].second;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001017
Douglas Gregor1a4761e2011-11-30 23:21:26 +00001018 clang::Module *Module = 0;
Douglas Gregor3d3589d2011-11-30 00:36:36 +00001019
Douglas Gregor49009ec2011-11-30 04:03:44 +00001020 // If we don't already have information on this module, load the module now.
Douglas Gregor1a4761e2011-11-30 23:21:26 +00001021 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001022 = KnownModules.find(Path[0].first);
Douglas Gregor5e3f9222011-12-08 17:01:29 +00001023 if (Known != KnownModules.end()) {
1024 // Retrieve the cached top-level module.
1025 Module = Known->second;
1026 } else if (ModuleName == getLangOpts().CurrentModule) {
1027 // This is the module we're building.
1028 Module = PP->getHeaderSearchInfo().getModuleMap().findModule(ModuleName);
1029 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1030 } else {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001031 // Search for a module with the given name.
Douglas Gregore434ec72012-01-29 17:08:11 +00001032 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001033 std::string ModuleFileName;
Douglas Gregor8bf778e2013-02-06 22:40:31 +00001034 if (Module) {
Douglas Gregore434ec72012-01-29 17:08:11 +00001035 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module);
Douglas Gregor8bf778e2013-02-06 22:40:31 +00001036 } else
Douglas Gregore434ec72012-01-29 17:08:11 +00001037 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(ModuleName);
Douglas Gregor463d9092012-11-29 23:55:25 +00001038
Douglas Gregor49009ec2011-11-30 04:03:44 +00001039 // If we don't already have an ASTReader, create one now.
1040 if (!ModuleManager) {
1041 if (!hasASTContext())
1042 createASTContext();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +00001043
Douglas Gregor49009ec2011-11-30 04:03:44 +00001044 std::string Sysroot = getHeaderSearchOpts().Sysroot;
1045 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1046 ModuleManager = new ASTReader(getPreprocessor(), *Context,
1047 Sysroot.empty() ? "" : Sysroot.c_str(),
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001048 PPOpts.DisablePCHValidation,
1049 /*AllowASTWithCompilerErrors=*/false,
1050 getFrontendOpts().UseGlobalModuleIndex);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001051 if (hasASTConsumer()) {
1052 ModuleManager->setDeserializationListener(
1053 getASTConsumer().GetASTDeserializationListener());
1054 getASTContext().setASTMutationListener(
1055 getASTConsumer().GetASTMutationListener());
Douglas Gregora8235d62012-10-09 23:05:51 +00001056 getPreprocessor().setPPMutationListener(
1057 getASTConsumer().GetPPMutationListener());
Douglas Gregor49009ec2011-11-30 04:03:44 +00001058 }
Dylan Noblesmith6f42b622012-02-05 02:12:40 +00001059 OwningPtr<ExternalASTSource> Source;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001060 Source.reset(ModuleManager);
1061 getASTContext().setExternalSource(Source);
1062 if (hasSema())
1063 ModuleManager->InitializeSema(getSema());
1064 if (hasASTConsumer())
1065 ModuleManager->StartTranslationUnit(&getASTConsumer());
Douglas Gregorde8a9052011-09-14 23:13:09 +00001066 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001067
Douglas Gregor677e15f2013-03-19 00:28:20 +00001068 // Try to load the module file.
1069 unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing;
1070 switch (ModuleManager->ReadAST(ModuleFileName, serialization::MK_Module,
1071 ImportLoc, ARRFlags)) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001072 case ASTReader::Success:
1073 break;
1074
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001075 case ASTReader::OutOfDate: {
Douglas Gregor677e15f2013-03-19 00:28:20 +00001076 // The module file is out-of-date. Remove it, then rebuild it.
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001077 bool Existed;
1078 llvm::sys::fs::remove(ModuleFileName, Existed);
Douglas Gregor677e15f2013-03-19 00:28:20 +00001079 }
1080 // Fall through to build the module again.
1081
1082 case ASTReader::Missing: {
1083 // The module file is (now) missing. Build it.
1084
1085 // If we don't have a module, we don't know how to build the module file.
1086 // Complain and return.
1087 if (!Module) {
1088 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1089 << ModuleName
1090 << SourceRange(ImportLoc, ModuleNameLoc);
1091 ModuleBuildFailed = true;
1092 return ModuleLoadResult();
1093 }
1094
1095 // Check whether there is a cycle in the module graph.
1096 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1097 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1098 for (; Pos != PosEnd; ++Pos) {
1099 if (Pos->first == ModuleName)
1100 break;
1101 }
1102
1103 if (Pos != PosEnd) {
1104 SmallString<256> CyclePath;
1105 for (; Pos != PosEnd; ++Pos) {
1106 CyclePath += Pos->first;
1107 CyclePath += " -> ";
1108 }
1109 CyclePath += ModuleName;
1110
1111 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1112 << ModuleName << CyclePath;
1113 return ModuleLoadResult();
1114 }
Douglas Gregor463d9092012-11-29 23:55:25 +00001115
1116 // Check whether we have already attempted to build this module (but
1117 // failed).
1118 if (getPreprocessorOpts().FailedModules &&
1119 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1120 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1121 << ModuleName
1122 << SourceRange(ImportLoc, ModuleNameLoc);
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001123 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001124 return ModuleLoadResult();
1125 }
1126
Douglas Gregor677e15f2013-03-19 00:28:20 +00001127 // Try to compile the module.
Douglas Gregor830ea5b2012-11-30 18:38:50 +00001128 compileModule(*this, ModuleNameLoc, Module, ModuleFileName);
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001129
Douglas Gregor677e15f2013-03-19 00:28:20 +00001130 // Try to read the module file, now that we've compiled it.
1131 ASTReader::ASTReadResult ReadResult
1132 = ModuleManager->ReadAST(ModuleFileName,
Argyrios Kyrtzidis958bcaf2012-11-15 18:57:22 +00001133 serialization::MK_Module, ImportLoc,
Douglas Gregor677e15f2013-03-19 00:28:20 +00001134 ASTReader::ARR_Missing);
1135 if (ReadResult != ASTReader::Success) {
1136 if (ReadResult == ASTReader::Missing) {
1137 getDiagnostics().Report(ModuleNameLoc,
1138 Module? diag::err_module_not_built
1139 : diag::err_module_not_found)
1140 << ModuleName
1141 << SourceRange(ImportLoc, ModuleNameLoc);
1142 }
1143
Douglas Gregorb8a8be12013-01-10 02:04:18 +00001144 if (getPreprocessorOpts().FailedModules)
1145 getPreprocessorOpts().FailedModules->addFailed(ModuleName);
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001146 KnownModules[Path[0].first] = 0;
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001147 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001148 return ModuleLoadResult();
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001149 }
1150
1151 // Okay, we've rebuilt and now loaded the module.
1152 break;
1153 }
1154
Douglas Gregor4825fd72012-10-22 22:50:17 +00001155 case ASTReader::VersionMismatch:
1156 case ASTReader::ConfigurationMismatch:
1157 case ASTReader::HadErrors:
Douglas Gregor49009ec2011-11-30 04:03:44 +00001158 // FIXME: The ASTReader will already have complained, but can we showhorn
1159 // that diagnostic information into a more useful form?
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001160 KnownModules[Path[0].first] = 0;
Douglas Gregor463d9092012-11-29 23:55:25 +00001161 return ModuleLoadResult();
Douglas Gregor49009ec2011-11-30 04:03:44 +00001162
1163 case ASTReader::Failure:
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001164 // Already complained, but note now that we failed.
1165 KnownModules[Path[0].first] = 0;
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001166 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001167 return ModuleLoadResult();
Douglas Gregor49009ec2011-11-30 04:03:44 +00001168 }
1169
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001170 if (!Module) {
1171 // If we loaded the module directly, without finding a module map first,
1172 // we'll have loaded the module's information from the module itself.
1173 Module = PP->getHeaderSearchInfo().getModuleMap()
1174 .findModule((Path[0].first->getName()));
1175 }
Argyrios Kyrtzidise2ac16b2012-09-29 01:06:04 +00001176
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001177 // Cache the result of this top-level module lookup for later.
1178 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001179 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001180
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001181 // If we never found the module, fail.
1182 if (!Module)
Douglas Gregor463d9092012-11-29 23:55:25 +00001183 return ModuleLoadResult();
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001184
Douglas Gregor49009ec2011-11-30 04:03:44 +00001185 // Verify that the rest of the module path actually corresponds to
1186 // a submodule.
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001187 if (Path.size() > 1) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001188 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1189 StringRef Name = Path[I].first->getName();
Douglas Gregorb7a78192012-01-04 23:32:19 +00001190 clang::Module *Sub = Module->findSubmodule(Name);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001191
Douglas Gregorb7a78192012-01-04 23:32:19 +00001192 if (!Sub) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001193 // Attempt to perform typo correction to find a module name that works.
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00001194 SmallVector<StringRef, 2> Best;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001195 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1196
Douglas Gregorb7a78192012-01-04 23:32:19 +00001197 for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1198 JEnd = Module->submodule_end();
Matt Beaumont-Gaye25633f2011-11-30 19:41:21 +00001199 J != JEnd; ++J) {
Douglas Gregorb7a78192012-01-04 23:32:19 +00001200 unsigned ED = Name.edit_distance((*J)->Name,
Douglas Gregor49009ec2011-11-30 04:03:44 +00001201 /*AllowReplacements=*/true,
1202 BestEditDistance);
1203 if (ED <= BestEditDistance) {
Douglas Gregorb7a78192012-01-04 23:32:19 +00001204 if (ED < BestEditDistance) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001205 Best.clear();
Douglas Gregorb7a78192012-01-04 23:32:19 +00001206 BestEditDistance = ED;
1207 }
1208
1209 Best.push_back((*J)->Name);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001210 }
1211 }
1212
1213 // If there was a clear winner, user it.
1214 if (Best.size() == 1) {
1215 getDiagnostics().Report(Path[I].second,
1216 diag::err_no_submodule_suggest)
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001217 << Path[I].first << Module->getFullModuleName() << Best[0]
Douglas Gregor49009ec2011-11-30 04:03:44 +00001218 << SourceRange(Path[0].second, Path[I-1].second)
1219 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1220 Best[0]);
Douglas Gregorb7a78192012-01-04 23:32:19 +00001221
1222 Sub = Module->findSubmodule(Best[0]);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001223 }
1224 }
1225
Douglas Gregorb7a78192012-01-04 23:32:19 +00001226 if (!Sub) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001227 // No submodule by this name. Complain, and don't look for further
1228 // submodules.
1229 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001230 << Path[I].first << Module->getFullModuleName()
Douglas Gregor49009ec2011-11-30 04:03:44 +00001231 << SourceRange(Path[0].second, Path[I-1].second);
1232 break;
1233 }
1234
Douglas Gregorb7a78192012-01-04 23:32:19 +00001235 Module = Sub;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001236 }
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001237 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001238
Douglas Gregor5e3f9222011-12-08 17:01:29 +00001239 // Make the named module visible, if it's not already part of the module
1240 // we are parsing.
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001241 if (ModuleName != getLangOpts().CurrentModule) {
1242 if (!Module->IsFromModuleFile) {
1243 // We have an umbrella header or directory that doesn't actually include
1244 // all of the headers within the directory it covers. Complain about
1245 // this missing submodule and recover by forgetting that we ever saw
1246 // this submodule.
1247 // FIXME: Should we detect this at module load time? It seems fairly
1248 // expensive (and rare).
1249 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1250 << Module->getFullModuleName()
1251 << SourceRange(Path.front().second, Path.back().second);
1252
Douglas Gregor463d9092012-11-29 23:55:25 +00001253 return ModuleLoadResult(0, true);
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001254 }
Douglas Gregor51f564f2011-12-31 04:05:44 +00001255
1256 // Check whether this module is available.
1257 StringRef Feature;
Douglas Gregordc58aa72012-01-30 06:01:29 +00001258 if (!Module->isAvailable(getLangOpts(), getTarget(), Feature)) {
Douglas Gregor51f564f2011-12-31 04:05:44 +00001259 getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
1260 << Module->getFullModuleName()
1261 << Feature
1262 << SourceRange(Path.front().second, Path.back().second);
1263 LastModuleImportLoc = ImportLoc;
Douglas Gregor463d9092012-11-29 23:55:25 +00001264 LastModuleImportResult = ModuleLoadResult();
1265 return ModuleLoadResult();
Douglas Gregor51f564f2011-12-31 04:05:44 +00001266 }
1267
Argyrios Kyrtzidis5ebcb202013-02-01 16:36:12 +00001268 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001269 }
Douglas Gregor63a72682013-03-20 00:22:05 +00001270
1271 // Check for any configuration macros that have changed.
1272 clang::Module *TopModule = Module->getTopLevelModule();
1273 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1274 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1275 Module, ImportLoc);
1276 }
1277
Douglas Gregor93ebfa62011-12-02 23:42:12 +00001278 // If this module import was due to an inclusion directive, create an
1279 // implicit import declaration to capture it in the AST.
1280 if (IsInclusionDirective && hasASTContext()) {
1281 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
Argyrios Kyrtzidisd3d98162012-10-03 01:58:37 +00001282 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
1283 ImportLoc, Module,
1284 Path.back().second);
1285 TU->addDecl(ImportD);
1286 if (Consumer)
1287 Consumer->HandleImplicitImportDecl(ImportD);
Douglas Gregor93ebfa62011-12-02 23:42:12 +00001288 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001289
Douglas Gregorb514c792011-11-30 04:26:53 +00001290 LastModuleImportLoc = ImportLoc;
Douglas Gregor463d9092012-11-29 23:55:25 +00001291 LastModuleImportResult = ModuleLoadResult(Module, false);
1292 return LastModuleImportResult;
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001293}
Douglas Gregorca2ab452013-01-12 01:29:50 +00001294
1295void CompilerInstance::makeModuleVisible(Module *Mod,
Argyrios Kyrtzidis5ebcb202013-02-01 16:36:12 +00001296 Module::NameVisibilityKind Visibility,
1297 SourceLocation ImportLoc){
1298 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
Douglas Gregorca2ab452013-01-12 01:29:50 +00001299}
1300