blob: c65d34bd2a960fda7cae597618d52b39500be5e2 [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"
Stephen Hines6bcf27b2014-05-29 04:14:42 -070034#include "clang/Serialization/GlobalModuleIndex.h"
Douglas Gregor95dd5582010-03-30 17:33:59 +000035#include "llvm/ADT/Statistic.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000036#include "llvm/Config/config.h"
37#include "llvm/Support/CrashRecoveryContext.h"
38#include "llvm/Support/FileSystem.h"
Michael J. Spencer03013fa2010-11-29 18:12:39 +000039#include "llvm/Support/Host.h"
Douglas Gregor52f12722012-01-29 20:15:24 +000040#include "llvm/Support/LockFileManager.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000041#include "llvm/Support/MemoryBuffer.h"
Michael J. Spencer03013fa2010-11-29 18:12:39 +000042#include "llvm/Support/Path.h"
43#include "llvm/Support/Program.h"
44#include "llvm/Support/Signals.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000045#include "llvm/Support/Timer.h"
46#include "llvm/Support/raw_ostream.h"
Michael J. Spencer3a321e22010-12-09 17:36:38 +000047#include "llvm/Support/system_error.h"
Douglas Gregord44d2872013-03-25 21:19:16 +000048#include <sys/stat.h>
Douglas Gregor87ab0662013-03-25 21:51:16 +000049#include <time.h>
Douglas Gregor2bc75072011-10-05 14:53:30 +000050
Daniel Dunbar2a79e162009-11-13 03:51:44 +000051using namespace clang;
52
Stephen Hines6bcf27b2014-05-29 04:14:42 -070053CompilerInstance::CompilerInstance(bool BuildingModule)
54 : ModuleLoader(BuildingModule),
55 Invocation(new CompilerInvocation()), ModuleManager(nullptr),
56 BuildGlobalModuleIndex(false), HaveFullGlobalModuleIndex(false),
57 ModuleBuildFailed(false) {
Daniel Dunbar6228ca02010-01-30 21:47:07 +000058}
Daniel Dunbar2a79e162009-11-13 03:51:44 +000059
60CompilerInstance::~CompilerInstance() {
Benjamin Kramerac447fc2012-10-14 19:21:21 +000061 assert(OutputFiles.empty() && "Still output files in flight?");
Daniel Dunbar42e9f8e42010-02-16 01:54:47 +000062}
63
Daniel Dunbar6228ca02010-01-30 21:47:07 +000064void CompilerInstance::setInvocation(CompilerInvocation *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000065 Invocation = Value;
Daniel Dunbar6228ca02010-01-30 21:47:07 +000066}
67
Douglas Gregorf575d6e2013-01-25 00:45:27 +000068bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
Douglas Gregor1a49d972013-01-25 01:03:03 +000069 return (BuildGlobalModuleIndex ||
Douglas Gregored2fc2a2013-03-22 21:26:48 +000070 (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
71 getFrontendOpts().GenerateGlobalModuleIndex)) &&
Douglas Gregor1a49d972013-01-25 01:03:03 +000072 !ModuleBuildFailed;
Douglas Gregorf575d6e2013-01-25 00:45:27 +000073}
74
David Blaikied6471f72011-09-25 23:23:43 +000075void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
Douglas Gregor28019772010-04-05 23:52:57 +000076 Diagnostics = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000077}
78
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000079void CompilerInstance::setTarget(TargetInfo *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000080 Target = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000081}
82
83void CompilerInstance::setFileManager(FileManager *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000084 FileMgr = Value;
Stephen Hines651f13c2014-04-23 16:59:28 -070085 if (Value)
86 VirtualFileSystem = Value->getVirtualFileSystem();
87 else
88 VirtualFileSystem.reset();
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000089}
90
NAKAMURA Takumia789ca92011-10-08 11:31:46 +000091void CompilerInstance::setSourceManager(SourceManager *Value) {
Ted Kremenek4f327862011-03-21 18:40:17 +000092 SourceMgr = Value;
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000093}
94
Ted Kremenek4f327862011-03-21 18:40:17 +000095void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; }
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000096
Ted Kremenek4f327862011-03-21 18:40:17 +000097void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; }
Daniel Dunbar8a9f5692009-11-14 01:20:40 +000098
Douglas Gregorf18d0d82010-08-12 23:31:19 +000099void CompilerInstance::setSema(Sema *S) {
100 TheSema.reset(S);
101}
102
Daniel Dunbar12ce6942009-11-14 02:47:17 +0000103void CompilerInstance::setASTConsumer(ASTConsumer *Value) {
104 Consumer.reset(Value);
105}
106
Daniel Dunbar8a9f5692009-11-14 01:20:40 +0000107void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
108 CompletionConsumer.reset(Value);
109}
Stephen Hines651f13c2014-04-23 16:59:28 -0700110
111IntrusiveRefCntPtr<ASTReader> CompilerInstance::getModuleManager() const {
112 return ModuleManager;
113}
114void CompilerInstance::setModuleManager(IntrusiveRefCntPtr<ASTReader> Reader) {
115 ModuleManager = Reader;
116}
Daniel Dunbar8a9f5692009-11-14 01:20:40 +0000117
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000118// Diagnostics
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000119static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000120 const CodeGenOptions *CodeGenOpts,
David Blaikied6471f72011-09-25 23:23:43 +0000121 DiagnosticsEngine &Diags) {
Daniel Dunbar9df23492011-04-07 18:31:10 +0000122 std::string ErrorInfo;
123 bool OwnsStream = false;
Chris Lattner5f9e2722011-07-23 10:55:15 +0000124 raw_ostream *OS = &llvm::errs();
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000125 if (DiagOpts->DiagnosticLogFile != "-") {
Daniel Dunbar9df23492011-04-07 18:31:10 +0000126 // Create the output stream.
Stephen Hines651f13c2014-04-23 16:59:28 -0700127 llvm::raw_fd_ostream *FileOS(new llvm::raw_fd_ostream(
128 DiagOpts->DiagnosticLogFile.c_str(), ErrorInfo,
129 llvm::sys::fs::F_Append | llvm::sys::fs::F_Text));
Daniel Dunbar9df23492011-04-07 18:31:10 +0000130 if (!ErrorInfo.empty()) {
131 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
Sean Silvad2ff76b2013-01-20 01:58:26 +0000132 << DiagOpts->DiagnosticLogFile << ErrorInfo;
Daniel Dunbar9df23492011-04-07 18:31:10 +0000133 } else {
134 FileOS->SetUnbuffered();
135 FileOS->SetUseAtomicWrites(true);
136 OS = FileOS;
137 OwnsStream = true;
138 }
139 }
140
141 // Chain in the diagnostic client which will log the diagnostics.
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000142 LogDiagnosticPrinter *Logger = new LogDiagnosticPrinter(*OS, DiagOpts,
143 OwnsStream);
144 if (CodeGenOpts)
145 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
David Blaikie4e85b8a2011-09-26 00:21:47 +0000146 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger));
Daniel Dunbar9df23492011-04-07 18:31:10 +0000147}
148
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000149static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
Ted Kremenek78002122011-10-29 00:12:39 +0000150 DiagnosticsEngine &Diags,
151 StringRef OutputFile) {
152 std::string ErrorInfo;
Stephen Hines651f13c2014-04-23 16:59:28 -0700153 std::unique_ptr<llvm::raw_fd_ostream> OS;
Ted Kremenek78002122011-10-29 00:12:39 +0000154 OS.reset(new llvm::raw_fd_ostream(OutputFile.str().c_str(), ErrorInfo,
Stephen Hines651f13c2014-04-23 16:59:28 -0700155 llvm::sys::fs::F_None));
Rafael Espindolad965f952013-07-16 19:44:23 +0000156
Ted Kremenek78002122011-10-29 00:12:39 +0000157 if (!ErrorInfo.empty()) {
158 Diags.Report(diag::warn_fe_serialized_diag_failure)
159 << OutputFile << ErrorInfo;
160 return;
161 }
Ted Kremenek78002122011-10-29 00:12:39 +0000162
Stephen Hines651f13c2014-04-23 16:59:28 -0700163 DiagnosticConsumer *SerializedConsumer =
164 clang::serialized_diags::create(OS.release(), DiagOpts);
165
Ted Kremenek78002122011-10-29 00:12:39 +0000166 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(),
167 SerializedConsumer));
168}
169
Sean Silvad47afb92013-01-20 01:58:28 +0000170void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
Douglas Gregorcc2b6532013-05-03 23:07:45 +0000171 bool ShouldOwnClient) {
Sean Silvad47afb92013-01-20 01:58:28 +0000172 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
Douglas Gregorcc2b6532013-05-03 23:07:45 +0000173 ShouldOwnClient, &getCodeGenOpts());
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000174}
175
Dylan Noblesmithc93dc782012-02-20 14:00:23 +0000176IntrusiveRefCntPtr<DiagnosticsEngine>
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000177CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
David Blaikie78ad0b92011-09-25 23:39:51 +0000178 DiagnosticConsumer *Client,
Douglas Gregor78243652011-09-13 01:26:44 +0000179 bool ShouldOwnClient,
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000180 const CodeGenOptions *CodeGenOpts) {
Dylan Noblesmithc93dc782012-02-20 14:00:23 +0000181 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
182 IntrusiveRefCntPtr<DiagnosticsEngine>
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000183 Diags(new DiagnosticsEngine(DiagID, Opts));
Daniel Dunbar221c7212009-11-14 07:53:24 +0000184
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000185 // Create the diagnostic client for reporting errors or for
186 // implementing -verify.
Douglas Gregoraee526e2011-09-29 00:38:00 +0000187 if (Client) {
Douglas Gregorcc2b6532013-05-03 23:07:45 +0000188 Diags->setClient(Client, ShouldOwnClient);
Douglas Gregoraee526e2011-09-29 00:38:00 +0000189 } else
Douglas Gregore47be3e2010-11-11 00:39:14 +0000190 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
Daniel Dunbarf79dced2009-11-14 03:24:39 +0000191
192 // Chain in -verify checker, if requested.
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000193 if (Opts->VerifyDiagnostics)
David Blaikie621bc692011-09-26 00:38:03 +0000194 Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000195
Daniel Dunbar9df23492011-04-07 18:31:10 +0000196 // Chain in -diagnostic-log-file dumper, if requested.
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000197 if (!Opts->DiagnosticLogFile.empty())
Daniel Dunbarb6534bb2011-04-07 18:59:02 +0000198 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000199
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000200 if (!Opts->DiagnosticSerializationFile.empty())
Ted Kremenek78002122011-10-29 00:12:39 +0000201 SetupSerializedDiagnostics(Opts, *Diags,
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000202 Opts->DiagnosticSerializationFile);
Ted Kremenek78002122011-10-29 00:12:39 +0000203
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000204 // Configure our handling of diagnostics.
Douglas Gregor02c23eb2012-10-23 22:26:28 +0000205 ProcessWarningOptions(*Diags, *Opts);
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000206
Douglas Gregor28019772010-04-05 23:52:57 +0000207 return Diags;
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000208}
209
210// File Manager
211
Daniel Dunbar16b74492009-11-13 04:12:06 +0000212void CompilerInstance::createFileManager() {
Stephen Hines651f13c2014-04-23 16:59:28 -0700213 if (!hasVirtualFileSystem()) {
214 // TODO: choose the virtual file system based on the CompilerInvocation.
215 setVirtualFileSystem(vfs::getRealFileSystem());
216 }
217 FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem);
Daniel Dunbar16b74492009-11-13 04:12:06 +0000218}
219
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000220// Source Manager
221
Chris Lattner39b49bc2010-11-23 08:35:12 +0000222void CompilerInstance::createSourceManager(FileManager &FileMgr) {
Ted Kremenek4f327862011-03-21 18:40:17 +0000223 SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
Daniel Dunbar16b74492009-11-13 04:12:06 +0000224}
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000225
Daniel Dunbar0fbb3d92009-11-13 05:52:34 +0000226// Preprocessor
227
Stephen Hines651f13c2014-04-23 16:59:28 -0700228void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000229 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000230
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000231 // Create a PTH manager if we are using some form of a token cache.
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700232 PTHManager *PTHMgr = nullptr;
Daniel Dunbar049d3a02009-11-17 05:52:41 +0000233 if (!PPOpts.TokenCache.empty())
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000234 PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000235
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000236 // Create the Preprocessor.
Douglas Gregorc042edd2012-10-24 16:19:39 +0000237 HeaderSearch *HeaderInfo = new HeaderSearch(&getHeaderSearchOpts(),
Manuel Klimekee0cd372013-10-24 07:51:24 +0000238 getSourceManager(),
Douglas Gregor51f564f2011-12-31 04:05:44 +0000239 getDiagnostics(),
Douglas Gregordc58aa72012-01-30 06:01:29 +0000240 getLangOpts(),
241 &getTarget());
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700242 PP = new Preprocessor(&getPreprocessorOpts(), getDiagnostics(), getLangOpts(),
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000243 getSourceManager(), *HeaderInfo, *this, PTHMgr,
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700244 /*OwnsHeaderSearch=*/true, TUKind);
245 PP->Initialize(getTarget());
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000246
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000247 // Note that this is different then passing PTHMgr to Preprocessor's ctor.
248 // That argument is used as the IdentifierInfoLookup argument to
249 // IdentifierTable's ctor.
250 if (PTHMgr) {
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000251 PTHMgr->setPreprocessor(&*PP);
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000252 PP->setPTHManager(PTHMgr);
253 }
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000254
Douglas Gregor94dc8f62010-03-19 16:15:56 +0000255 if (PPOpts.DetailedRecord)
Argyrios Kyrtzidis37ed1272012-12-04 07:27:05 +0000256 PP->createPreprocessingRecord();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000257
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000258 InitializePreprocessor(*PP, PPOpts, getHeaderSearchOpts(), getFrontendOpts());
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000259
Jordan Rose74c24982013-01-30 01:52:57 +0000260 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
261
Douglas Gregor6e975c42011-09-13 23:15:45 +0000262 // Set up the module path, including the hash for the
263 // module-creation options.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000264 SmallString<256> SpecificModuleCache(
Douglas Gregor6e975c42011-09-13 23:15:45 +0000265 getHeaderSearchOpts().ModuleCachePath);
266 if (!getHeaderSearchOpts().DisableModuleHash)
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000267 llvm::sys::path::append(SpecificModuleCache,
Douglas Gregor6e975c42011-09-13 23:15:45 +0000268 getInvocation().getModuleHash());
Douglas Gregor5e3f9222011-12-08 17:01:29 +0000269 PP->getHeaderSearchInfo().setModuleCachePath(SpecificModuleCache);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000270
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000271 // Handle generating dependencies, if requested.
Douglas Gregor6aa52ec2011-08-26 23:56:07 +0000272 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000273 if (!DepOpts.OutputFile.empty())
Stephen Hines651f13c2014-04-23 16:59:28 -0700274 TheDependencyFileGenerator.reset(
275 DependencyFileGenerator::CreateAndAttachToPreprocessor(*PP, DepOpts));
Douglas Gregor773303a2012-02-02 23:45:13 +0000276 if (!DepOpts.DOTOutputFile.empty())
277 AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile,
Douglas Gregorc69a1812012-02-02 00:54:52 +0000278 getHeaderSearchOpts().Sysroot);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000279
Hans Wennborg708002e2013-08-09 00:32:23 +0000280
Daniel Dunbareef63e02011-02-02 15:41:17 +0000281 // Handle generating header include information, if requested.
282 if (DepOpts.ShowHeaderIncludes)
283 AttachHeaderIncludeGen(*PP);
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000284 if (!DepOpts.HeaderIncludeOutputFile.empty()) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000285 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000286 if (OutputPath == "-")
287 OutputPath = "";
Daniel Dunbarda608852011-03-21 19:37:38 +0000288 AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath,
289 /*ShowDepth=*/false);
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000290 }
Hans Wennborg708002e2013-08-09 00:32:23 +0000291
292 if (DepOpts.PrintShowIncludes) {
293 AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/false, /*OutputPath=*/"",
294 /*ShowDepth=*/true, /*MSStyle=*/true);
295 }
Daniel Dunbar22dacfa2009-11-13 05:52:11 +0000296}
Daniel Dunbar5eb81002009-11-13 08:20:47 +0000297
298// ASTContext
299
300void CompilerInstance::createASTContext() {
301 Preprocessor &PP = getPreprocessor();
Ted Kremenek4f327862011-03-21 18:40:17 +0000302 Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700303 PP.getIdentifierTable(), PP.getSelectorTable(),
304 PP.getBuiltinInfo());
305 Context->InitBuiltinTypes(getTarget());
Daniel Dunbar5eb81002009-11-13 08:20:47 +0000306}
Daniel Dunbar0f800392009-11-13 08:21:10 +0000307
308// ExternalASTSource
309
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700310void CompilerInstance::createPCHExternalASTSource(
311 StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors,
312 void *DeserializationListener, bool OwnDeserializationListener) {
Stephen Hines651f13c2014-04-23 16:59:28 -0700313 IntrusiveRefCntPtr<ExternalASTSource> Source;
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +0000314 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700315 Source = createPCHExternalASTSource(
316 Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation,
317 AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(),
318 DeserializationListener, OwnDeserializationListener, Preamble,
319 getFrontendOpts().UseGlobalModuleIndex);
Stephen Hines651f13c2014-04-23 16:59:28 -0700320 ModuleManager = static_cast<ASTReader*>(Source.getPtr());
Daniel Dunbar0f800392009-11-13 08:21:10 +0000321 getASTContext().setExternalSource(Source);
322}
323
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700324ExternalASTSource *CompilerInstance::createPCHExternalASTSource(
325 StringRef Path, const std::string &Sysroot, bool DisablePCHValidation,
326 bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context,
327 void *DeserializationListener, bool OwnDeserializationListener,
328 bool Preamble, bool UseGlobalModuleIndex) {
Stephen Hines651f13c2014-04-23 16:59:28 -0700329 HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
330
331 std::unique_ptr<ASTReader> Reader;
Douglas Gregorf8a1e512011-09-02 00:26:20 +0000332 Reader.reset(new ASTReader(PP, Context,
Douglas Gregor832d6202011-07-22 16:35:34 +0000333 Sysroot.empty() ? "" : Sysroot.c_str(),
Argyrios Kyrtzidis4182ed62012-10-31 20:59:50 +0000334 DisablePCHValidation,
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000335 AllowPCHWithCompilerErrors,
Stephen Hines651f13c2014-04-23 16:59:28 -0700336 /*AllowConfigurationMismatch*/false,
337 HSOpts.ModulesValidateSystemHeaders,
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000338 UseGlobalModuleIndex));
Daniel Dunbar0f800392009-11-13 08:21:10 +0000339
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000340 Reader->setDeserializationListener(
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700341 static_cast<ASTDeserializationListener *>(DeserializationListener),
342 /*TakeOwnership=*/OwnDeserializationListener);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000343 switch (Reader->ReadAST(Path,
344 Preamble ? serialization::MK_Preamble
Douglas Gregor38295be2012-10-22 23:51:00 +0000345 : serialization::MK_PCH,
Argyrios Kyrtzidis958bcaf2012-11-15 18:57:22 +0000346 SourceLocation(),
Douglas Gregor38295be2012-10-22 23:51:00 +0000347 ASTReader::ARR_None)) {
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000348 case ASTReader::Success:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000349 // Set the predefines buffer as suggested by the PCH reader. Typically, the
350 // predefines buffer will be empty.
351 PP.setPredefines(Reader->getSuggestedPredefines());
Stephen Hines651f13c2014-04-23 16:59:28 -0700352 return Reader.release();
Daniel Dunbar0f800392009-11-13 08:21:10 +0000353
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000354 case ASTReader::Failure:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000355 // Unrecoverable failure: don't even try to process the input file.
356 break;
357
Douglas Gregor677e15f2013-03-19 00:28:20 +0000358 case ASTReader::Missing:
Douglas Gregor4825fd72012-10-22 22:50:17 +0000359 case ASTReader::OutOfDate:
360 case ASTReader::VersionMismatch:
361 case ASTReader::ConfigurationMismatch:
362 case ASTReader::HadErrors:
Daniel Dunbar0f800392009-11-13 08:21:10 +0000363 // No suitable PCH file could be found. Return an error.
364 break;
365 }
366
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700367 return nullptr;
Daniel Dunbar0f800392009-11-13 08:21:10 +0000368}
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000369
370// Code Completion
371
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000372static bool EnableCodeCompletion(Preprocessor &PP,
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000373 const std::string &Filename,
374 unsigned Line,
375 unsigned Column) {
376 // Tell the source manager to chop off the given file at a specific
377 // line and column.
Chris Lattner39b49bc2010-11-23 08:35:12 +0000378 const FileEntry *Entry = PP.getFileManager().getFile(Filename);
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000379 if (!Entry) {
380 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
381 << Filename;
382 return true;
383 }
384
385 // Truncate the named file at the given line/column.
386 PP.SetCodeCompletionPoint(Entry, Line, Column);
387 return false;
388}
389
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000390void CompilerInstance::createCodeCompletionConsumer() {
391 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000392 if (!CompletionConsumer) {
Erik Verbruggen9bc0c292012-04-12 10:31:12 +0000393 setCodeCompletionConsumer(
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000394 createCodeCompletionConsumer(getPreprocessor(),
395 Loc.FileName, Loc.Line, Loc.Column,
Dmitri Gribenkod99ef532012-07-02 17:35:10 +0000396 getFrontendOpts().CodeCompleteOpts,
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000397 llvm::outs()));
398 if (!CompletionConsumer)
399 return;
400 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
401 Loc.Line, Loc.Column)) {
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700402 setCodeCompletionConsumer(nullptr);
Douglas Gregorc3d43b72010-03-16 06:04:47 +0000403 return;
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000404 }
Douglas Gregor2b4074f2009-12-01 05:55:20 +0000405
406 if (CompletionConsumer->isOutputBinary() &&
Rafael Espindolaa6035692013-06-12 20:44:26 +0000407 llvm::sys::ChangeStdoutToBinary()) {
Douglas Gregor2b4074f2009-12-01 05:55:20 +0000408 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700409 setCodeCompletionConsumer(nullptr);
Douglas Gregor2b4074f2009-12-01 05:55:20 +0000410 }
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000411}
412
Kovarththanan Rajaratnamf79bafa2009-11-29 09:57:35 +0000413void CompilerInstance::createFrontendTimer() {
414 FrontendTimer.reset(new llvm::Timer("Clang front-end timer"));
415}
416
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000417CodeCompleteConsumer *
418CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
419 const std::string &Filename,
420 unsigned Line,
421 unsigned Column,
Dmitri Gribenkod99ef532012-07-02 17:35:10 +0000422 const CodeCompleteOptions &Opts,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000423 raw_ostream &OS) {
Douglas Gregor1abc6bc2010-08-04 16:47:14 +0000424 if (EnableCodeCompletion(PP, Filename, Line, Column))
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700425 return nullptr;
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000426
427 // Set up the creation routine for code-completion.
Dmitri Gribenkod99ef532012-07-02 17:35:10 +0000428 return new PrintingCodeCompleteConsumer(Opts, OS);
Daniel Dunbarc2f484f2009-11-13 09:36:05 +0000429}
Daniel Dunbara9204832009-11-13 10:37:48 +0000430
Douglas Gregor467dc882011-08-25 22:30:56 +0000431void CompilerInstance::createSema(TranslationUnitKind TUKind,
Douglas Gregorf18d0d82010-08-12 23:31:19 +0000432 CodeCompleteConsumer *CompletionConsumer) {
433 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
Douglas Gregor467dc882011-08-25 22:30:56 +0000434 TUKind, CompletionConsumer));
Douglas Gregorf18d0d82010-08-12 23:31:19 +0000435}
436
Daniel Dunbara9204832009-11-13 10:37:48 +0000437// Output Files
438
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000439void CompilerInstance::addOutputFile(const OutputFile &OutFile) {
440 assert(OutFile.OS && "Attempt to add empty stream to output list!");
441 OutputFiles.push_back(OutFile);
Daniel Dunbara9204832009-11-13 10:37:48 +0000442}
443
Kovarththanan Rajaratname51dd7b2010-03-06 12:07:48 +0000444void CompilerInstance::clearOutputFiles(bool EraseFiles) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000445 for (std::list<OutputFile>::iterator
Daniel Dunbara9204832009-11-13 10:37:48 +0000446 it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000447 delete it->OS;
448 if (!it->TempFilename.empty()) {
Anders Carlssonaf036a62011-03-06 22:25:35 +0000449 if (EraseFiles) {
Stephen Hines651f13c2014-04-23 16:59:28 -0700450 llvm::sys::fs::remove(it->TempFilename);
Anders Carlssonaf036a62011-03-06 22:25:35 +0000451 } else {
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000452 SmallString<128> NewOutFile(it->Filename);
Anders Carlssonaf036a62011-03-06 22:25:35 +0000453
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +0000454 // If '-working-directory' was passed, the output filename should be
455 // relative to that.
Anders Carlsson2e2468e2011-03-14 01:13:54 +0000456 FileMgr->FixupRelativePath(NewOutFile);
Anders Carlssonaf036a62011-03-06 22:25:35 +0000457 if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename,
458 NewOutFile.str())) {
Manuel Klimek832a2aa2012-05-16 20:55:58 +0000459 getDiagnostics().Report(diag::err_unable_to_rename_temp)
Anders Carlssonaf036a62011-03-06 22:25:35 +0000460 << it->TempFilename << it->Filename << ec.message();
461
Stephen Hines651f13c2014-04-23 16:59:28 -0700462 llvm::sys::fs::remove(it->TempFilename);
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000463 }
464 }
465 } else if (!it->Filename.empty() && EraseFiles)
Rafael Espindola48955f82013-06-26 04:32:59 +0000466 llvm::sys::fs::remove(it->Filename);
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000467
Daniel Dunbara9204832009-11-13 10:37:48 +0000468 }
469 OutputFiles.clear();
470}
471
Daniel Dunbarf482d592009-11-13 18:32:08 +0000472llvm::raw_fd_ostream *
473CompilerInstance::createDefaultOutputFile(bool Binary,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000474 StringRef InFile,
475 StringRef Extension) {
Daniel Dunbarf482d592009-11-13 18:32:08 +0000476 return createOutputFile(getFrontendOpts().OutputFile, Binary,
Daniel Dunbare21dd282012-03-03 00:36:06 +0000477 /*RemoveFileOnSignal=*/true, InFile, Extension,
478 /*UseTemporary=*/true);
Daniel Dunbarf482d592009-11-13 18:32:08 +0000479}
480
481llvm::raw_fd_ostream *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000482CompilerInstance::createOutputFile(StringRef OutputPath,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000483 bool Binary, bool RemoveFileOnSignal,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000484 StringRef InFile,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000485 StringRef Extension,
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000486 bool UseTemporary,
487 bool CreateMissingDirectories) {
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000488 std::string Error, OutputPathName, TempPathName;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000489 llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000490 RemoveFileOnSignal,
Daniel Dunbarf482d592009-11-13 18:32:08 +0000491 InFile, Extension,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000492 UseTemporary,
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000493 CreateMissingDirectories,
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000494 &OutputPathName,
495 &TempPathName);
Daniel Dunbarf482d592009-11-13 18:32:08 +0000496 if (!OS) {
Daniel Dunbar36043592009-12-03 09:13:30 +0000497 getDiagnostics().Report(diag::err_fe_unable_to_open_output)
498 << OutputPath << Error;
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700499 return nullptr;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000500 }
501
502 // Add the output file -- but don't try to remove "-", since this means we are
503 // using stdin.
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000504 addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "",
505 TempPathName, OS));
Daniel Dunbarf482d592009-11-13 18:32:08 +0000506
507 return OS;
508}
509
510llvm::raw_fd_ostream *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000511CompilerInstance::createOutputFile(StringRef OutputPath,
Daniel Dunbarf482d592009-11-13 18:32:08 +0000512 std::string &Error,
513 bool Binary,
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000514 bool RemoveFileOnSignal,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000515 StringRef InFile,
516 StringRef Extension,
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000517 bool UseTemporary,
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000518 bool CreateMissingDirectories,
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000519 std::string *ResultPathName,
520 std::string *TempPathName) {
Daniel Dunbar12f28ab2012-03-03 00:36:02 +0000521 assert((!CreateMissingDirectories || UseTemporary) &&
522 "CreateMissingDirectories is only allowed when using temporary files");
523
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000524 std::string OutFile, TempFile;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000525 if (!OutputPath.empty()) {
526 OutFile = OutputPath;
527 } else if (InFile == "-") {
528 OutFile = "-";
529 } else if (!Extension.empty()) {
Rafael Espindola48955f82013-06-26 04:32:59 +0000530 SmallString<128> Path(InFile);
531 llvm::sys::path::replace_extension(Path, Extension);
Daniel Dunbarf482d592009-11-13 18:32:08 +0000532 OutFile = Path.str();
533 } else {
534 OutFile = "-";
535 }
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000536
Stephen Hines651f13c2014-04-23 16:59:28 -0700537 std::unique_ptr<llvm::raw_fd_ostream> OS;
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000538 std::string OSFile;
539
Rafael Espindola375a4f52013-06-27 18:26:26 +0000540 if (UseTemporary) {
541 if (OutFile == "-")
542 UseTemporary = false;
543 else {
544 llvm::sys::fs::file_status Status;
545 llvm::sys::fs::status(OutputPath, Status);
546 if (llvm::sys::fs::exists(Status)) {
547 // Fail early if we can't write to the final destination.
548 if (!llvm::sys::fs::can_write(OutputPath))
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700549 return nullptr;
Rafael Espindola375a4f52013-06-27 18:26:26 +0000550
551 // Don't use a temporary if the output is a special file. This handles
552 // things like '-o /dev/null'
553 if (!llvm::sys::fs::is_regular_file(Status))
554 UseTemporary = false;
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000555 }
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000556 }
557 }
558
Rafael Espindola375a4f52013-06-27 18:26:26 +0000559 if (UseTemporary) {
Rafael Espindola375a4f52013-06-27 18:26:26 +0000560 // Create a temporary file.
561 SmallString<128> TempPath;
562 TempPath = OutFile;
563 TempPath += "-%%%%%%%%";
564 int fd;
Rafael Espindola70e7aec2013-07-05 21:13:58 +0000565 llvm::error_code EC =
566 llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath);
Rafael Espindola8ffd0a42013-06-28 03:49:04 +0000567
568 if (CreateMissingDirectories &&
Rafael Espindolaabab1832013-07-05 14:15:24 +0000569 EC == llvm::errc::no_such_file_or_directory) {
Rafael Espindola8ffd0a42013-06-28 03:49:04 +0000570 StringRef Parent = llvm::sys::path::parent_path(OutputPath);
571 EC = llvm::sys::fs::create_directories(Parent);
572 if (!EC) {
Rafael Espindola70e7aec2013-07-05 21:13:58 +0000573 EC = llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath);
Rafael Espindola8ffd0a42013-06-28 03:49:04 +0000574 }
575 }
576
577 if (!EC) {
Rafael Espindola375a4f52013-06-27 18:26:26 +0000578 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
579 OSFile = TempFile = TempPath.str();
580 }
581 // If we failed to create the temporary, fallback to writing to the file
582 // directly. This handles the corner case where we cannot write to the
583 // directory, but can write to the file.
584 }
585
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000586 if (!OS) {
587 OSFile = OutFile;
Rafael Espindolad965f952013-07-16 19:44:23 +0000588 OS.reset(new llvm::raw_fd_ostream(
589 OSFile.c_str(), Error,
Stephen Hines651f13c2014-04-23 16:59:28 -0700590 (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text)));
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000591 if (!Error.empty())
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700592 return nullptr;
Argyrios Kyrtzidis7e909852011-07-28 00:45:10 +0000593 }
Daniel Dunbarf482d592009-11-13 18:32:08 +0000594
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000595 // Make sure the out stream file gets removed if we crash.
Daniel Dunbarff9cd962011-01-31 22:00:42 +0000596 if (RemoveFileOnSignal)
Rafael Espindola6f2e23b2013-06-13 21:02:40 +0000597 llvm::sys::RemoveFileOnSignal(OSFile);
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000598
Daniel Dunbarf482d592009-11-13 18:32:08 +0000599 if (ResultPathName)
600 *ResultPathName = OutFile;
Argyrios Kyrtzidisdc245722010-09-17 17:38:48 +0000601 if (TempPathName)
602 *TempPathName = TempFile;
Daniel Dunbarf482d592009-11-13 18:32:08 +0000603
Stephen Hines651f13c2014-04-23 16:59:28 -0700604 return OS.release();
Daniel Dunbarf482d592009-11-13 18:32:08 +0000605}
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000606
607// Initialization Utilities
608
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000609bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
610 return InitializeSourceManager(Input, getDiagnostics(),
Douglas Gregora1f1fad2012-01-27 19:52:33 +0000611 getFileManager(), getSourceManager(),
612 getFrontendOpts());
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000613}
614
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000615bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input,
David Blaikied6471f72011-09-25 23:23:43 +0000616 DiagnosticsEngine &Diags,
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000617 FileManager &FileMgr,
618 SourceManager &SourceMgr,
619 const FrontendOptions &Opts) {
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000620 SrcMgr::CharacteristicKind
Argyrios Kyrtzidis8616f9a2012-11-09 19:40:39 +0000621 Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
Argyrios Kyrtzidis8e1fbbc2012-11-09 19:40:33 +0000622
Argyrios Kyrtzidisecd27bf2012-11-09 19:40:45 +0000623 if (Input.isBuffer()) {
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700624 SourceMgr.setMainFileID(SourceMgr.createFileID(Input.getBuffer(), Kind));
Argyrios Kyrtzidisecd27bf2012-11-09 19:40:45 +0000625 assert(!SourceMgr.getMainFileID().isInvalid() &&
626 "Couldn't establish MainFileID!");
627 return true;
628 }
629
630 StringRef InputFile = Input.getFile();
631
Argyrios Kyrtzidis507097e2011-09-19 20:40:35 +0000632 // Figure out where to get and map in the main file.
633 if (InputFile != "-") {
Benjamin Kramera3bf8972013-08-12 13:46:52 +0000634 const FileEntry *File = FileMgr.getFile(InputFile, /*OpenFile=*/true);
Dan Gohman694137c2010-10-26 21:13:51 +0000635 if (!File) {
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000636 Diags.Report(diag::err_fe_error_reading) << InputFile;
637 return false;
638 }
Daniel Dunbarce36ecd2012-11-05 22:53:33 +0000639
640 // The natural SourceManager infrastructure can't currently handle named
641 // pipes, but we would at least like to accept them for the main
Benjamin Kramera3bf8972013-08-12 13:46:52 +0000642 // file. Detect them here, read them with the volatile flag so FileMgr will
643 // pick up the correct size, and simply override their contents as we do for
644 // STDIN.
Daniel Dunbarce36ecd2012-11-05 22:53:33 +0000645 if (File->isNamedPipe()) {
Benjamin Kramera3bf8972013-08-12 13:46:52 +0000646 std::string ErrorStr;
647 if (llvm::MemoryBuffer *MB =
648 FileMgr.getBufferForFile(File, &ErrorStr, /*isVolatile=*/true)) {
649 // Create a new virtual file that will have the correct size.
650 File = FileMgr.getVirtualFile(InputFile, MB->getBufferSize(), 0);
651 SourceMgr.overrideFileContents(File, MB);
652 } else {
653 Diags.Report(diag::err_cannot_open_file) << InputFile << ErrorStr;
Daniel Dunbarce36ecd2012-11-05 22:53:33 +0000654 return false;
655 }
Daniel Dunbarce36ecd2012-11-05 22:53:33 +0000656 }
Daniel Dunbaracf36122012-11-27 00:04:16 +0000657
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700658 SourceMgr.setMainFileID(
659 SourceMgr.createFileID(File, SourceLocation(), Kind));
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000660 } else {
Stephen Hines651f13c2014-04-23 16:59:28 -0700661 std::unique_ptr<llvm::MemoryBuffer> SB;
Benjamin Kramera3bf8972013-08-12 13:46:52 +0000662 if (llvm::error_code ec = llvm::MemoryBuffer::getSTDIN(SB)) {
663 Diags.Report(diag::err_fe_error_reading_stdin) << ec.message();
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000664 return false;
665 }
Dan Gohman90d90812010-10-26 23:21:25 +0000666 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
Chris Lattner39b49bc2010-11-23 08:35:12 +0000667 SB->getBufferSize(), 0);
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700668 SourceMgr.setMainFileID(
669 SourceMgr.createFileID(File, SourceLocation(), Kind));
Stephen Hines651f13c2014-04-23 16:59:28 -0700670 SourceMgr.overrideFileContents(File, SB.release());
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000671 }
672
Dan Gohman694137c2010-10-26 21:13:51 +0000673 assert(!SourceMgr.getMainFileID().isInvalid() &&
674 "Couldn't establish MainFileID!");
Daniel Dunbarccb6cb62009-11-14 07:53:04 +0000675 return true;
676}
Daniel Dunbar0397af22010-01-13 00:48:06 +0000677
678// High-Level Operations
679
680bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
681 assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
682 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
683 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
684
685 // FIXME: Take this as an argument, once all the APIs we used have moved to
686 // taking it as an input instead of hard-coding llvm::errs.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000687 raw_ostream &OS = llvm::errs();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000688
689 // Create the target instance.
Douglas Gregor49a87542012-11-16 04:24:59 +0000690 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), &getTargetOpts()));
Daniel Dunbar0397af22010-01-13 00:48:06 +0000691 if (!hasTarget())
692 return false;
693
694 // Inform the target of the language options.
695 //
696 // FIXME: We shouldn't need to do this, the target should be immutable once
697 // created. This complexity should be lifted elsewhere.
698 getTarget().setForcedLangOptions(getLangOpts());
699
Fariborz Jahanian93a49942012-04-16 21:03:30 +0000700 // rewriter project will change target built-in bool type from its default.
701 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
702 getTarget().noSignedCharForObjCBool();
703
Daniel Dunbar0397af22010-01-13 00:48:06 +0000704 // Validate/process some options.
705 if (getHeaderSearchOpts().Verbose)
706 OS << "clang -cc1 version " CLANG_VERSION_STRING
707 << " based upon " << PACKAGE_STRING
Sebastian Pop5d8b9542011-11-01 21:33:06 +0000708 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
Daniel Dunbar0397af22010-01-13 00:48:06 +0000709
710 if (getFrontendOpts().ShowTimers)
711 createFrontendTimer();
712
Douglas Gregor95dd5582010-03-30 17:33:59 +0000713 if (getFrontendOpts().ShowStats)
714 llvm::EnableStatistics();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000715
Daniel Dunbar0397af22010-01-13 00:48:06 +0000716 for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) {
Daniel Dunbar20560482010-06-07 23:23:50 +0000717 // Reset the ID tables if we are reusing the SourceManager.
718 if (hasSourceManager())
719 getSourceManager().clearIDTables();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000720
Douglas Gregor1f6b2b52012-01-20 16:28:04 +0000721 if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) {
Daniel Dunbar0397af22010-01-13 00:48:06 +0000722 Act.Execute();
723 Act.EndSourceFile();
724 }
725 }
726
Argyrios Kyrtzidis29f27872011-12-07 05:52:12 +0000727 // Notify the diagnostic client that all files were processed.
728 getDiagnostics().getClient()->finish();
729
Chris Lattner53eee7b2010-04-07 18:47:42 +0000730 if (getDiagnosticOpts().ShowCarets) {
Argyrios Kyrtzidisf2224d82010-11-18 20:06:46 +0000731 // We can have multiple diagnostics sharing one diagnostic client.
732 // Get the total number of warnings/errors from the client.
733 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
734 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000735
Chris Lattner53eee7b2010-04-07 18:47:42 +0000736 if (NumWarnings)
737 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
738 if (NumWarnings && NumErrors)
739 OS << " and ";
740 if (NumErrors)
741 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
742 if (NumWarnings || NumErrors)
743 OS << " generated.\n";
744 }
Daniel Dunbar0397af22010-01-13 00:48:06 +0000745
Daniel Dunbar20560482010-06-07 23:23:50 +0000746 if (getFrontendOpts().ShowStats && hasFileManager()) {
Daniel Dunbar0397af22010-01-13 00:48:06 +0000747 getFileManager().PrintStats();
748 OS << "\n";
749 }
750
Argyrios Kyrtzidisab41b972010-11-18 21:13:57 +0000751 return !getDiagnostics().getClient()->getNumErrors();
Daniel Dunbar0397af22010-01-13 00:48:06 +0000752}
753
Douglas Gregor21cae202011-09-12 23:31:24 +0000754/// \brief Determine the appropriate source input kind based on language
755/// options.
756static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
757 if (LangOpts.OpenCL)
758 return IK_OpenCL;
759 if (LangOpts.CUDA)
760 return IK_CUDA;
761 if (LangOpts.ObjC1)
762 return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
763 return LangOpts.CPlusPlus? IK_CXX : IK_C;
764}
765
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000766/// \brief Compile a module file for the given module, using the options
767/// provided by the importing compiler instance.
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700768static void compileModuleImpl(CompilerInstance &ImportingInstance,
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000769 SourceLocation ImportLoc,
Douglas Gregor1a4761e2011-11-30 23:21:26 +0000770 Module *Module,
Douglas Gregor933e7a62011-11-29 18:31:39 +0000771 StringRef ModuleFileName) {
Douglas Gregorf9e357d2011-11-29 19:06:37 +0000772 ModuleMap &ModMap
773 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
774
Douglas Gregor21cae202011-09-12 23:31:24 +0000775 // Construct a compiler invocation for creating this module.
Dylan Noblesmithc93dc782012-02-20 14:00:23 +0000776 IntrusiveRefCntPtr<CompilerInvocation> Invocation
Douglas Gregor21cae202011-09-12 23:31:24 +0000777 (new CompilerInvocation(ImportingInstance.getInvocation()));
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000778
Douglas Gregor18ee5472011-11-29 21:59:16 +0000779 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
780
Douglas Gregorb2d39c22011-09-15 20:53:28 +0000781 // For any options that aren't intended to affect how a module is built,
782 // reset them to their default values.
Ted Kremenekd3b74d92011-11-17 23:01:24 +0000783 Invocation->getLangOpts()->resetNonModularOptions();
Douglas Gregor18ee5472011-11-29 21:59:16 +0000784 PPOpts.resetNonModularOptions();
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000785
Douglas Gregor2a060852013-02-07 00:21:12 +0000786 // Remove any macro definitions that are explicitly ignored by the module.
787 // They aren't supposed to affect how the module is built anyway.
788 const HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
Stephen Hines651f13c2014-04-23 16:59:28 -0700789 PPOpts.Macros.erase(
790 std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
791 [&HSOpts](const std::pair<std::string, bool> &def) {
792 StringRef MacroDef = def.first;
793 return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0;
794 }),
795 PPOpts.Macros.end());
Douglas Gregor2a060852013-02-07 00:21:12 +0000796
Douglas Gregorb86b8dc2011-11-15 19:35:01 +0000797 // Note the name of the module we're building.
Douglas Gregor933e7a62011-11-29 18:31:39 +0000798 Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
Douglas Gregorb86b8dc2011-11-15 19:35:01 +0000799
Douglas Gregor463d9092012-11-29 23:55:25 +0000800 // Make sure that the failed-module structure has been allocated in
801 // the importing instance, and propagate the pointer to the newly-created
802 // instance.
803 PreprocessorOptions &ImportingPPOpts
804 = ImportingInstance.getInvocation().getPreprocessorOpts();
805 if (!ImportingPPOpts.FailedModules)
806 ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet;
807 PPOpts.FailedModules = ImportingPPOpts.FailedModules;
808
Douglas Gregor18ee5472011-11-29 21:59:16 +0000809 // If there is a module map file, build the module using the module map.
Douglas Gregorb2d39c22011-09-15 20:53:28 +0000810 // Set up the inputs/outputs so that we build the module from its umbrella
811 // header.
Douglas Gregor21cae202011-09-12 23:31:24 +0000812 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
Douglas Gregor6e975c42011-09-13 23:15:45 +0000813 FrontendOpts.OutputFile = ModuleFileName.str();
Douglas Gregor21cae202011-09-12 23:31:24 +0000814 FrontendOpts.DisableFree = false;
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000815 FrontendOpts.GenerateGlobalModuleIndex = false;
Douglas Gregor21cae202011-09-12 23:31:24 +0000816 FrontendOpts.Inputs.clear();
Douglas Gregor18ee5472011-11-29 21:59:16 +0000817 InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000818
Douglas Gregor18ee5472011-11-29 21:59:16 +0000819 // Don't free the remapped file buffers; they are owned by our caller.
820 PPOpts.RetainRemappedFileBuffers = true;
821
Douglas Gregor78243652011-09-13 01:26:44 +0000822 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
Douglas Gregor76d991e2011-09-13 23:20:27 +0000823 assert(ImportingInstance.getInvocation().getModuleHash() ==
Douglas Gregor18ee5472011-11-29 21:59:16 +0000824 Invocation->getModuleHash() && "Module hash mismatch!");
825
Douglas Gregor21cae202011-09-12 23:31:24 +0000826 // Construct a compiler instance that will be used to actually create the
827 // module.
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700828 CompilerInstance Instance(/*BuildingModule=*/true);
Douglas Gregor21cae202011-09-12 23:31:24 +0000829 Instance.setInvocation(&*Invocation);
Douglas Gregora4a90ca2013-05-03 22:58:43 +0000830
831 Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
832 ImportingInstance.getDiagnosticClient()),
Douglas Gregorcc2b6532013-05-03 23:07:45 +0000833 /*ShouldOwnClient=*/true);
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000834
Stephen Hines651f13c2014-04-23 16:59:28 -0700835 Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
836
Douglas Gregor4565e482012-11-30 22:11:57 +0000837 // Note that this module is part of the module build stack, so that we
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000838 // can detect cycles in the module graph.
Stephen Hines651f13c2014-04-23 16:59:28 -0700839 Instance.setFileManager(&ImportingInstance.getFileManager());
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000840 Instance.createSourceManager(Instance.getFileManager());
841 SourceManager &SourceMgr = Instance.getSourceManager();
Douglas Gregor4565e482012-11-30 22:11:57 +0000842 SourceMgr.setModuleBuildStack(
843 ImportingInstance.getSourceManager().getModuleBuildStack());
844 SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(),
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000845 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
846
Manuel Klimekee0cd372013-10-24 07:51:24 +0000847 // Get or create the module map that we'll use to build this module.
848 std::string InferredModuleMapContent;
849 if (const FileEntry *ModuleMapFile =
850 ModMap.getContainingModuleMapFile(Module)) {
851 // Use the module map where this module resides.
852 FrontendOpts.Inputs.push_back(
853 FrontendInputFile(ModuleMapFile->getName(), IK));
854 } else {
855 llvm::raw_string_ostream OS(InferredModuleMapContent);
856 Module->print(OS);
857 OS.flush();
858 FrontendOpts.Inputs.push_back(
859 FrontendInputFile("__inferred_module.map", IK));
860
861 const llvm::MemoryBuffer *ModuleMapBuffer =
862 llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
863 ModuleMapFile = Instance.getFileManager().getVirtualFile(
864 "__inferred_module.map", InferredModuleMapContent.size(), 0);
865 SourceMgr.overrideFileContents(ModuleMapFile, ModuleMapBuffer);
866 }
Douglas Gregor830ea5b2012-11-30 18:38:50 +0000867
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700868 // Construct a module-generating action. Passing through Module->ModuleMap is
869 // safe because the FileManager is shared between the compiler instances.
870 GenerateModuleAction CreateModuleAction(Module->ModuleMap, Module->IsSystem);
Douglas Gregor18ee5472011-11-29 21:59:16 +0000871
Douglas Gregor0ced7992011-10-04 00:21:21 +0000872 // Execute the action to actually build the module in-place. Use a separate
873 // thread so that we get a stack large enough.
874 const unsigned ThreadStackSize = 8 << 20;
875 llvm::CrashRecoveryContext CRC;
Stephen Hines651f13c2014-04-23 16:59:28 -0700876 CRC.RunSafelyOnThread([&]() { Instance.ExecuteAction(CreateModuleAction); },
877 ThreadStackSize);
Douglas Gregora4a90ca2013-05-03 22:58:43 +0000878
Douglas Gregor18ee5472011-11-29 21:59:16 +0000879 // Delete the temporary module map file.
880 // FIXME: Even though we're executing under crash protection, it would still
881 // be nice to do this with RemoveFileOnSignal when we can. However, that
882 // doesn't make sense for all clients, so clean this up manually.
Benjamin Kramera2e94892012-10-14 19:50:53 +0000883 Instance.clearOutputFiles(/*EraseFiles=*/true);
Douglas Gregora6b00fc2013-01-23 22:38:11 +0000884
885 // We've rebuilt a module. If we're allowed to generate or update the global
886 // module index, record that fact in the importing compiler instance.
Douglas Gregorf575d6e2013-01-25 00:45:27 +0000887 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
Douglas Gregora6b00fc2013-01-23 22:38:11 +0000888 ImportingInstance.setBuildGlobalModuleIndex(true);
889 }
NAKAMURA Takumia789ca92011-10-08 11:31:46 +0000890}
Douglas Gregor21cae202011-09-12 23:31:24 +0000891
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700892static void compileModule(CompilerInstance &ImportingInstance,
893 SourceLocation ImportLoc,
894 Module *Module,
895 StringRef ModuleFileName) {
896 // FIXME: have LockFileManager return an error_code so that we can
897 // avoid the mkdir when the directory already exists.
898 StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
899 llvm::sys::fs::create_directories(Dir);
900
901 while (1) {
902 llvm::LockFileManager Locked(ModuleFileName);
903 switch (Locked) {
904 case llvm::LockFileManager::LFS_Error:
905 return;
906
907 case llvm::LockFileManager::LFS_Owned:
908 // We're responsible for building the module ourselves. Do so below.
909 break;
910
911 case llvm::LockFileManager::LFS_Shared:
912 // Someone else is responsible for building the module. Wait for them to
913 // finish.
914 if (Locked.waitForUnlock() == llvm::LockFileManager::Res_OwnerDied)
915 continue; // try again to get the lock.
916 return;
917 }
918
919 return compileModuleImpl(ImportingInstance, ImportLoc, Module,
920 ModuleFileName);
921 }
922}
923
Douglas Gregor63a72682013-03-20 00:22:05 +0000924/// \brief Diagnose differences between the current definition of the given
925/// configuration macro and the definition provided on the command line.
926static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
927 Module *Mod, SourceLocation ImportLoc) {
928 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
929 SourceManager &SourceMgr = PP.getSourceManager();
930
931 // If this identifier has never had a macro definition, then it could
932 // not have changed.
933 if (!Id->hadMacroDefinition())
934 return;
935
936 // If this identifier does not currently have a macro definition,
937 // check whether it had one on the command line.
938 if (!Id->hasMacroDefinition()) {
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000939 MacroDirective::DefInfo LatestDef =
940 PP.getMacroDirectiveHistory(Id)->getDefinition();
941 for (MacroDirective::DefInfo Def = LatestDef; Def;
942 Def = Def.getPreviousDefinition()) {
943 FileID FID = SourceMgr.getFileID(Def.getLocation());
Douglas Gregor63a72682013-03-20 00:22:05 +0000944 if (FID.isInvalid())
945 continue;
946
Douglas Gregor63a72682013-03-20 00:22:05 +0000947 // We only care about the predefines buffer.
Douglas Gregor670b2e62013-04-03 03:16:36 +0000948 if (FID != PP.getPredefinesFileID())
Douglas Gregor63a72682013-03-20 00:22:05 +0000949 continue;
950
951 // This macro was defined on the command line, then #undef'd later.
952 // Complain.
953 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
954 << true << ConfigMacro << Mod->getFullModuleName();
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000955 if (LatestDef.isUndefined())
956 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
Douglas Gregor63a72682013-03-20 00:22:05 +0000957 << true;
958 return;
959 }
960
961 // Okay: no definition in the predefines buffer.
962 return;
963 }
964
965 // This identifier has a macro definition. Check whether we had a definition
966 // on the command line.
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000967 MacroDirective::DefInfo LatestDef =
968 PP.getMacroDirectiveHistory(Id)->getDefinition();
969 MacroDirective::DefInfo PredefinedDef;
970 for (MacroDirective::DefInfo Def = LatestDef; Def;
971 Def = Def.getPreviousDefinition()) {
972 FileID FID = SourceMgr.getFileID(Def.getLocation());
Douglas Gregor63a72682013-03-20 00:22:05 +0000973 if (FID.isInvalid())
974 continue;
975
Douglas Gregor63a72682013-03-20 00:22:05 +0000976 // We only care about the predefines buffer.
Douglas Gregor670b2e62013-04-03 03:16:36 +0000977 if (FID != PP.getPredefinesFileID())
Douglas Gregor63a72682013-03-20 00:22:05 +0000978 continue;
979
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000980 PredefinedDef = Def;
Douglas Gregor63a72682013-03-20 00:22:05 +0000981 break;
982 }
983
984 // If there was no definition for this macro in the predefines buffer,
985 // complain.
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000986 if (!PredefinedDef ||
987 (!PredefinedDef.getLocation().isValid() &&
988 PredefinedDef.getUndefLocation().isValid())) {
Douglas Gregor63a72682013-03-20 00:22:05 +0000989 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
990 << false << ConfigMacro << Mod->getFullModuleName();
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000991 PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here)
Douglas Gregor63a72682013-03-20 00:22:05 +0000992 << false;
993 return;
994 }
995
996 // If the current macro definition is the same as the predefined macro
997 // definition, it's okay.
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +0000998 if (LatestDef.getMacroInfo() == PredefinedDef.getMacroInfo() ||
Argyrios Kyrtzidisbd25ff82013-04-03 17:39:30 +0000999 LatestDef.getMacroInfo()->isIdenticalTo(*PredefinedDef.getMacroInfo(),PP,
1000 /*Syntactically=*/true))
Douglas Gregor63a72682013-03-20 00:22:05 +00001001 return;
1002
1003 // The macro definitions differ.
1004 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1005 << false << ConfigMacro << Mod->getFullModuleName();
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +00001006 PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here)
Douglas Gregor63a72682013-03-20 00:22:05 +00001007 << false;
1008}
1009
Douglas Gregord44d2872013-03-25 21:19:16 +00001010/// \brief Write a new timestamp file with the given path.
1011static void writeTimestampFile(StringRef TimestampFile) {
1012 std::string ErrorInfo;
1013 llvm::raw_fd_ostream Out(TimestampFile.str().c_str(), ErrorInfo,
Stephen Hines651f13c2014-04-23 16:59:28 -07001014 llvm::sys::fs::F_None);
Douglas Gregord44d2872013-03-25 21:19:16 +00001015}
1016
1017/// \brief Prune the module cache of modules that haven't been accessed in
1018/// a long time.
1019static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1020 struct stat StatBuf;
1021 llvm::SmallString<128> TimestampFile;
1022 TimestampFile = HSOpts.ModuleCachePath;
1023 llvm::sys::path::append(TimestampFile, "modules.timestamp");
1024
1025 // Try to stat() the timestamp file.
1026 if (::stat(TimestampFile.c_str(), &StatBuf)) {
1027 // If the timestamp file wasn't there, create one now.
1028 if (errno == ENOENT) {
1029 writeTimestampFile(TimestampFile);
1030 }
1031 return;
1032 }
1033
1034 // Check whether the time stamp is older than our pruning interval.
1035 // If not, do nothing.
1036 time_t TimeStampModTime = StatBuf.st_mtime;
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001037 time_t CurrentTime = time(nullptr);
Benjamin Kramer93ce7d52013-03-29 17:39:43 +00001038 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
Douglas Gregord44d2872013-03-25 21:19:16 +00001039 return;
Douglas Gregord44d2872013-03-25 21:19:16 +00001040
1041 // Write a new timestamp file so that nobody else attempts to prune.
1042 // There is a benign race condition here, if two Clang instances happen to
1043 // notice at the same time that the timestamp is out-of-date.
1044 writeTimestampFile(TimestampFile);
1045
1046 // Walk the entire module cache, looking for unused module files and module
1047 // indices.
1048 llvm::error_code EC;
1049 SmallString<128> ModuleCachePathNative;
1050 llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1051 for (llvm::sys::fs::directory_iterator
1052 Dir(ModuleCachePathNative.str(), EC), DirEnd;
1053 Dir != DirEnd && !EC; Dir.increment(EC)) {
1054 // If we don't have a directory, there's nothing to look into.
Rafael Espindolab470d1a2013-07-17 04:23:07 +00001055 if (!llvm::sys::fs::is_directory(Dir->path()))
Douglas Gregord44d2872013-03-25 21:19:16 +00001056 continue;
1057
1058 // Walk all of the files within this directory.
Douglas Gregord44d2872013-03-25 21:19:16 +00001059 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1060 File != FileEnd && !EC; File.increment(EC)) {
1061 // We only care about module and global module index files.
Stephen Hines651f13c2014-04-23 16:59:28 -07001062 StringRef Extension = llvm::sys::path::extension(File->path());
1063 if (Extension != ".pcm" && Extension != ".timestamp" &&
1064 llvm::sys::path::filename(File->path()) != "modules.idx")
Douglas Gregord44d2872013-03-25 21:19:16 +00001065 continue;
Douglas Gregord44d2872013-03-25 21:19:16 +00001066
1067 // Look at this file. If we can't stat it, there's nothing interesting
1068 // there.
Stephen Hines651f13c2014-04-23 16:59:28 -07001069 if (::stat(File->path().c_str(), &StatBuf))
Douglas Gregord44d2872013-03-25 21:19:16 +00001070 continue;
Douglas Gregord44d2872013-03-25 21:19:16 +00001071
1072 // If the file has been used recently enough, leave it there.
1073 time_t FileAccessTime = StatBuf.st_atime;
Benjamin Kramer93ce7d52013-03-29 17:39:43 +00001074 if (CurrentTime - FileAccessTime <=
1075 time_t(HSOpts.ModuleCachePruneAfter)) {
Douglas Gregord44d2872013-03-25 21:19:16 +00001076 continue;
1077 }
1078
1079 // Remove the file.
Stephen Hines651f13c2014-04-23 16:59:28 -07001080 llvm::sys::fs::remove(File->path());
1081
1082 // Remove the timestamp file.
1083 std::string TimpestampFilename = File->path() + ".timestamp";
1084 llvm::sys::fs::remove(TimpestampFilename);
Douglas Gregord44d2872013-03-25 21:19:16 +00001085 }
1086
1087 // If we removed all of the files in the directory, remove the directory
1088 // itself.
Stephen Hines651f13c2014-04-23 16:59:28 -07001089 if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1090 llvm::sys::fs::directory_iterator() && !EC)
1091 llvm::sys::fs::remove(Dir->path());
Douglas Gregord44d2872013-03-25 21:19:16 +00001092 }
1093}
1094
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001095void CompilerInstance::createModuleManager() {
1096 if (!ModuleManager) {
1097 if (!hasASTContext())
1098 createASTContext();
1099
1100 // If we're not recursively building a module, check whether we
1101 // need to prune the module cache.
1102 if (getSourceManager().getModuleBuildStack().empty() &&
1103 getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1104 getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1105 pruneModuleCache(getHeaderSearchOpts());
1106 }
1107
1108 HeaderSearchOptions &HSOpts = getHeaderSearchOpts();
1109 std::string Sysroot = HSOpts.Sysroot;
1110 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1111 ModuleManager = new ASTReader(getPreprocessor(), *Context,
1112 Sysroot.empty() ? "" : Sysroot.c_str(),
1113 PPOpts.DisablePCHValidation,
1114 /*AllowASTWithCompilerErrors=*/false,
1115 /*AllowConfigurationMismatch=*/false,
1116 HSOpts.ModulesValidateSystemHeaders,
1117 getFrontendOpts().UseGlobalModuleIndex);
1118 if (hasASTConsumer()) {
1119 ModuleManager->setDeserializationListener(
1120 getASTConsumer().GetASTDeserializationListener());
1121 getASTContext().setASTMutationListener(
1122 getASTConsumer().GetASTMutationListener());
1123 }
1124 getASTContext().setExternalSource(ModuleManager);
1125 if (hasSema())
1126 ModuleManager->InitializeSema(getSema());
1127 if (hasASTConsumer())
1128 ModuleManager->StartTranslationUnit(&getASTConsumer());
1129 }
1130}
1131
Douglas Gregor463d9092012-11-29 23:55:25 +00001132ModuleLoadResult
1133CompilerInstance::loadModule(SourceLocation ImportLoc,
1134 ModuleIdPath Path,
1135 Module::NameVisibilityKind Visibility,
1136 bool IsInclusionDirective) {
Richard Smithb934d242013-10-18 22:48:20 +00001137 // Determine what file we're searching from.
1138 StringRef ModuleName = Path[0].first->getName();
1139 SourceLocation ModuleNameLoc = Path[0].second;
1140
Douglas Gregorb514c792011-11-30 04:26:53 +00001141 // If we've already handled this import, just return the cached result.
1142 // This one-element cache is important to eliminate redundant diagnostics
1143 // when both the preprocessor and parser see the same import declaration.
Douglas Gregor5e356932011-12-01 17:11:21 +00001144 if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) {
1145 // Make the named module visible.
Richard Smithb934d242013-10-18 22:48:20 +00001146 if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
Argyrios Kyrtzidis5ebcb202013-02-01 16:36:12 +00001147 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
Douglas Gregor906d66a2013-03-20 21:10:35 +00001148 ImportLoc, /*Complain=*/false);
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001149 return LastModuleImportResult;
Douglas Gregor5e356932011-12-01 17:11:21 +00001150 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001151
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001152 clang::Module *Module = nullptr;
Richard Smithb934d242013-10-18 22:48:20 +00001153
Douglas Gregor49009ec2011-11-30 04:03:44 +00001154 // If we don't already have information on this module, load the module now.
Douglas Gregor1a4761e2011-11-30 23:21:26 +00001155 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001156 = KnownModules.find(Path[0].first);
Douglas Gregor5e3f9222011-12-08 17:01:29 +00001157 if (Known != KnownModules.end()) {
1158 // Retrieve the cached top-level module.
1159 Module = Known->second;
1160 } else if (ModuleName == getLangOpts().CurrentModule) {
1161 // This is the module we're building.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001162 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
Douglas Gregor5e3f9222011-12-08 17:01:29 +00001163 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1164 } else {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001165 // Search for a module with the given name.
Douglas Gregore434ec72012-01-29 17:08:11 +00001166 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
Stephen Hines651f13c2014-04-23 16:59:28 -07001167 if (!Module) {
1168 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1169 << ModuleName
1170 << SourceRange(ImportLoc, ModuleNameLoc);
1171 ModuleBuildFailed = true;
1172 return ModuleLoadResult();
1173 }
1174
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001175 std::string ModuleFileName =
1176 PP->getHeaderSearchInfo().getModuleFileName(Module);
Douglas Gregor463d9092012-11-29 23:55:25 +00001177
Douglas Gregor49009ec2011-11-30 04:03:44 +00001178 // If we don't already have an ASTReader, create one now.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001179 if (!ModuleManager)
1180 createModuleManager();
Douglas Gregor49009ec2011-11-30 04:03:44 +00001181
Stephen Hines651f13c2014-04-23 16:59:28 -07001182 if (TheDependencyFileGenerator)
1183 TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
1184
Douglas Gregor677e15f2013-03-19 00:28:20 +00001185 // Try to load the module file.
1186 unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing;
1187 switch (ModuleManager->ReadAST(ModuleFileName, serialization::MK_Module,
1188 ImportLoc, ARRFlags)) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001189 case ASTReader::Success:
1190 break;
1191
Eli Friedman0295c232013-09-17 00:51:29 +00001192 case ASTReader::OutOfDate:
Douglas Gregor677e15f2013-03-19 00:28:20 +00001193 case ASTReader::Missing: {
Eli Friedman0295c232013-09-17 00:51:29 +00001194 // The module file is missing or out-of-date. Build it.
Stephen Hines651f13c2014-04-23 16:59:28 -07001195 assert(Module && "missing module file");
Douglas Gregor677e15f2013-03-19 00:28:20 +00001196 // Check whether there is a cycle in the module graph.
1197 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1198 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1199 for (; Pos != PosEnd; ++Pos) {
1200 if (Pos->first == ModuleName)
1201 break;
1202 }
1203
1204 if (Pos != PosEnd) {
1205 SmallString<256> CyclePath;
1206 for (; Pos != PosEnd; ++Pos) {
1207 CyclePath += Pos->first;
1208 CyclePath += " -> ";
1209 }
1210 CyclePath += ModuleName;
1211
1212 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1213 << ModuleName << CyclePath;
1214 return ModuleLoadResult();
1215 }
Douglas Gregor463d9092012-11-29 23:55:25 +00001216
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001217 getDiagnostics().Report(ImportLoc, diag::remark_module_build)
1218 << ModuleName << ModuleFileName;
1219
Douglas Gregor463d9092012-11-29 23:55:25 +00001220 // Check whether we have already attempted to build this module (but
1221 // failed).
1222 if (getPreprocessorOpts().FailedModules &&
1223 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1224 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1225 << ModuleName
1226 << SourceRange(ImportLoc, ModuleNameLoc);
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001227 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001228 return ModuleLoadResult();
1229 }
1230
Douglas Gregor677e15f2013-03-19 00:28:20 +00001231 // Try to compile the module.
Douglas Gregor830ea5b2012-11-30 18:38:50 +00001232 compileModule(*this, ModuleNameLoc, Module, ModuleFileName);
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001233
Douglas Gregor677e15f2013-03-19 00:28:20 +00001234 // Try to read the module file, now that we've compiled it.
1235 ASTReader::ASTReadResult ReadResult
1236 = ModuleManager->ReadAST(ModuleFileName,
Argyrios Kyrtzidis958bcaf2012-11-15 18:57:22 +00001237 serialization::MK_Module, ImportLoc,
Douglas Gregor677e15f2013-03-19 00:28:20 +00001238 ASTReader::ARR_Missing);
1239 if (ReadResult != ASTReader::Success) {
1240 if (ReadResult == ASTReader::Missing) {
1241 getDiagnostics().Report(ModuleNameLoc,
1242 Module? diag::err_module_not_built
1243 : diag::err_module_not_found)
1244 << ModuleName
1245 << SourceRange(ImportLoc, ModuleNameLoc);
1246 }
1247
Douglas Gregorb8a8be12013-01-10 02:04:18 +00001248 if (getPreprocessorOpts().FailedModules)
1249 getPreprocessorOpts().FailedModules->addFailed(ModuleName);
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001250 KnownModules[Path[0].first] = nullptr;
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001251 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001252 return ModuleLoadResult();
Douglas Gregor7cdd2812012-11-07 17:46:15 +00001253 }
1254
1255 // Okay, we've rebuilt and now loaded the module.
1256 break;
1257 }
1258
Douglas Gregor4825fd72012-10-22 22:50:17 +00001259 case ASTReader::VersionMismatch:
1260 case ASTReader::ConfigurationMismatch:
1261 case ASTReader::HadErrors:
Argyrios Kyrtzidis3b7deda2013-05-24 05:44:08 +00001262 ModuleLoader::HadFatalFailure = true;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001263 // FIXME: The ASTReader will already have complained, but can we showhorn
1264 // that diagnostic information into a more useful form?
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001265 KnownModules[Path[0].first] = nullptr;
Douglas Gregor463d9092012-11-29 23:55:25 +00001266 return ModuleLoadResult();
Douglas Gregor49009ec2011-11-30 04:03:44 +00001267
1268 case ASTReader::Failure:
Argyrios Kyrtzidis3b7deda2013-05-24 05:44:08 +00001269 ModuleLoader::HadFatalFailure = true;
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001270 // Already complained, but note now that we failed.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001271 KnownModules[Path[0].first] = nullptr;
Douglas Gregorf575d6e2013-01-25 00:45:27 +00001272 ModuleBuildFailed = true;
Douglas Gregor463d9092012-11-29 23:55:25 +00001273 return ModuleLoadResult();
Douglas Gregor49009ec2011-11-30 04:03:44 +00001274 }
Argyrios Kyrtzidise2ac16b2012-09-29 01:06:04 +00001275
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001276 // Cache the result of this top-level module lookup for later.
1277 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001278 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001279
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001280 // If we never found the module, fail.
1281 if (!Module)
Douglas Gregor463d9092012-11-29 23:55:25 +00001282 return ModuleLoadResult();
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001283
Douglas Gregor49009ec2011-11-30 04:03:44 +00001284 // Verify that the rest of the module path actually corresponds to
1285 // a submodule.
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001286 if (Path.size() > 1) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001287 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1288 StringRef Name = Path[I].first->getName();
Douglas Gregorb7a78192012-01-04 23:32:19 +00001289 clang::Module *Sub = Module->findSubmodule(Name);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001290
Douglas Gregorb7a78192012-01-04 23:32:19 +00001291 if (!Sub) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001292 // Attempt to perform typo correction to find a module name that works.
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00001293 SmallVector<StringRef, 2> Best;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001294 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1295
Douglas Gregorb7a78192012-01-04 23:32:19 +00001296 for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1297 JEnd = Module->submodule_end();
Matt Beaumont-Gaye25633f2011-11-30 19:41:21 +00001298 J != JEnd; ++J) {
Douglas Gregorb7a78192012-01-04 23:32:19 +00001299 unsigned ED = Name.edit_distance((*J)->Name,
Douglas Gregor49009ec2011-11-30 04:03:44 +00001300 /*AllowReplacements=*/true,
1301 BestEditDistance);
1302 if (ED <= BestEditDistance) {
Douglas Gregorb7a78192012-01-04 23:32:19 +00001303 if (ED < BestEditDistance) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001304 Best.clear();
Douglas Gregorb7a78192012-01-04 23:32:19 +00001305 BestEditDistance = ED;
1306 }
1307
1308 Best.push_back((*J)->Name);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001309 }
1310 }
1311
1312 // If there was a clear winner, user it.
1313 if (Best.size() == 1) {
1314 getDiagnostics().Report(Path[I].second,
1315 diag::err_no_submodule_suggest)
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001316 << Path[I].first << Module->getFullModuleName() << Best[0]
Douglas Gregor49009ec2011-11-30 04:03:44 +00001317 << SourceRange(Path[0].second, Path[I-1].second)
1318 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1319 Best[0]);
Douglas Gregorb7a78192012-01-04 23:32:19 +00001320
1321 Sub = Module->findSubmodule(Best[0]);
Douglas Gregor49009ec2011-11-30 04:03:44 +00001322 }
1323 }
1324
Douglas Gregorb7a78192012-01-04 23:32:19 +00001325 if (!Sub) {
Douglas Gregor49009ec2011-11-30 04:03:44 +00001326 // No submodule by this name. Complain, and don't look for further
1327 // submodules.
1328 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
Douglas Gregor392ed2b2011-11-30 17:33:56 +00001329 << Path[I].first << Module->getFullModuleName()
Douglas Gregor49009ec2011-11-30 04:03:44 +00001330 << SourceRange(Path[0].second, Path[I-1].second);
1331 break;
1332 }
1333
Douglas Gregorb7a78192012-01-04 23:32:19 +00001334 Module = Sub;
Douglas Gregor49009ec2011-11-30 04:03:44 +00001335 }
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001336 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001337
Douglas Gregor5e3f9222011-12-08 17:01:29 +00001338 // Make the named module visible, if it's not already part of the module
1339 // we are parsing.
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001340 if (ModuleName != getLangOpts().CurrentModule) {
1341 if (!Module->IsFromModuleFile) {
1342 // We have an umbrella header or directory that doesn't actually include
1343 // all of the headers within the directory it covers. Complain about
1344 // this missing submodule and recover by forgetting that we ever saw
1345 // this submodule.
1346 // FIXME: Should we detect this at module load time? It seems fairly
1347 // expensive (and rare).
1348 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1349 << Module->getFullModuleName()
1350 << SourceRange(Path.front().second, Path.back().second);
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001351
1352 return ModuleLoadResult(nullptr, true);
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001353 }
Douglas Gregor51f564f2011-12-31 04:05:44 +00001354
1355 // Check whether this module is available.
Richard Smith5794b532013-10-28 22:18:19 +00001356 clang::Module::Requirement Requirement;
Stephen Hines651f13c2014-04-23 16:59:28 -07001357 clang::Module::HeaderDirective MissingHeader;
1358 if (!Module->isAvailable(getLangOpts(), getTarget(), Requirement,
1359 MissingHeader)) {
1360 if (MissingHeader.FileNameLoc.isValid()) {
1361 getDiagnostics().Report(MissingHeader.FileNameLoc,
1362 diag::err_module_header_missing)
1363 << MissingHeader.IsUmbrella << MissingHeader.FileName;
1364 } else {
1365 getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
1366 << Module->getFullModuleName()
1367 << Requirement.second << Requirement.first
1368 << SourceRange(Path.front().second, Path.back().second);
1369 }
Douglas Gregor51f564f2011-12-31 04:05:44 +00001370 LastModuleImportLoc = ImportLoc;
Douglas Gregor463d9092012-11-29 23:55:25 +00001371 LastModuleImportResult = ModuleLoadResult();
1372 return ModuleLoadResult();
Douglas Gregor51f564f2011-12-31 04:05:44 +00001373 }
1374
Douglas Gregor906d66a2013-03-20 21:10:35 +00001375 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc,
1376 /*Complain=*/true);
Douglas Gregor305dc3e2011-12-20 00:28:52 +00001377 }
Douglas Gregor63a72682013-03-20 00:22:05 +00001378
1379 // Check for any configuration macros that have changed.
1380 clang::Module *TopModule = Module->getTopLevelModule();
1381 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1382 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1383 Module, ImportLoc);
1384 }
1385
Douglas Gregor93ebfa62011-12-02 23:42:12 +00001386 // If this module import was due to an inclusion directive, create an
1387 // implicit import declaration to capture it in the AST.
1388 if (IsInclusionDirective && hasASTContext()) {
1389 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
Argyrios Kyrtzidisd3d98162012-10-03 01:58:37 +00001390 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
1391 ImportLoc, Module,
1392 Path.back().second);
1393 TU->addDecl(ImportD);
1394 if (Consumer)
1395 Consumer->HandleImplicitImportDecl(ImportD);
Douglas Gregor93ebfa62011-12-02 23:42:12 +00001396 }
Douglas Gregor49009ec2011-11-30 04:03:44 +00001397
Douglas Gregorb514c792011-11-30 04:26:53 +00001398 LastModuleImportLoc = ImportLoc;
Douglas Gregor463d9092012-11-29 23:55:25 +00001399 LastModuleImportResult = ModuleLoadResult(Module, false);
1400 return LastModuleImportResult;
Douglas Gregor6aa52ec2011-08-26 23:56:07 +00001401}
Douglas Gregorca2ab452013-01-12 01:29:50 +00001402
1403void CompilerInstance::makeModuleVisible(Module *Mod,
Argyrios Kyrtzidis5ebcb202013-02-01 16:36:12 +00001404 Module::NameVisibilityKind Visibility,
Douglas Gregor906d66a2013-03-20 21:10:35 +00001405 SourceLocation ImportLoc,
1406 bool Complain){
1407 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc, Complain);
Douglas Gregorca2ab452013-01-12 01:29:50 +00001408}
1409
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001410GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex(
1411 SourceLocation TriggerLoc) {
1412 if (!ModuleManager)
1413 createModuleManager();
1414 // Can't do anything if we don't have the module manager.
1415 if (!ModuleManager)
1416 return nullptr;
1417 // Get an existing global index. This loads it if not already
1418 // loaded.
1419 ModuleManager->loadGlobalIndex();
1420 GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
1421 // If the global index doesn't exist, create it.
1422 if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
1423 hasPreprocessor()) {
1424 llvm::sys::fs::create_directories(
1425 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
1426 GlobalModuleIndex::writeIndex(
1427 getFileManager(),
1428 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
1429 ModuleManager->resetForReload();
1430 ModuleManager->loadGlobalIndex();
1431 GlobalIndex = ModuleManager->getGlobalIndex();
1432 }
1433 // For finding modules needing to be imported for fixit messages,
1434 // we need to make the global index cover all modules, so we do that here.
1435 if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
1436 ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap();
1437 bool RecreateIndex = false;
1438 for (ModuleMap::module_iterator I = MMap.module_begin(),
1439 E = MMap.module_end(); I != E; ++I) {
1440 Module *TheModule = I->second;
1441 const FileEntry *Entry = TheModule->getASTFile();
1442 if (!Entry) {
1443 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
1444 Path.push_back(std::make_pair(
1445 getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
1446 std::reverse(Path.begin(), Path.end());
1447 // Load a module as hidden. This also adds it to the global index.
1448 loadModule(TheModule->DefinitionLoc, Path,
1449 Module::Hidden, false);
1450 RecreateIndex = true;
1451 }
1452 }
1453 if (RecreateIndex) {
1454 GlobalModuleIndex::writeIndex(
1455 getFileManager(),
1456 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
1457 ModuleManager->resetForReload();
1458 ModuleManager->loadGlobalIndex();
1459 GlobalIndex = ModuleManager->getGlobalIndex();
1460 }
1461 HaveFullGlobalModuleIndex = true;
1462 }
1463 return GlobalIndex;
1464}
1465
1466// Check global module index for missing imports.
1467bool
1468CompilerInstance::lookupMissingImports(StringRef Name,
1469 SourceLocation TriggerLoc) {
1470 // Look for the symbol in non-imported modules, but only if an error
1471 // actually occurred.
1472 if (!buildingModule()) {
1473 // Load global module index, or retrieve a previously loaded one.
1474 GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex(
1475 TriggerLoc);
1476
1477 // Only if we have a global index.
1478 if (GlobalIndex) {
1479 GlobalModuleIndex::HitSet FoundModules;
1480
1481 // Find the modules that reference the identifier.
1482 // Note that this only finds top-level modules.
1483 // We'll let diagnoseTypo find the actual declaration module.
1484 if (GlobalIndex->lookupIdentifier(Name, FoundModules))
1485 return true;
1486 }
1487 }
1488
1489 return false;
1490}