blob: 740f1db825f40263a974533d37dada614b20505d [file] [log] [blame]
Daniel Dunbar636404a2009-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 Dunbar56d9c292009-11-14 02:47:17 +000011#include "clang/AST/ASTConsumer.h"
Daniel Dunbardf3e30c2009-11-13 08:20:47 +000012#include "clang/AST/ASTContext.h"
Douglas Gregorbcfc7d02011-12-02 23:42:12 +000013#include "clang/AST/Decl.h"
Daniel Dunbar636404a2009-11-13 03:51:44 +000014#include "clang/Basic/Diagnostic.h"
Daniel Dunbar546a6762009-11-13 04:12:06 +000015#include "clang/Basic/FileManager.h"
16#include "clang/Basic/SourceManager.h"
Daniel Dunbar636404a2009-11-13 03:51:44 +000017#include "clang/Basic/TargetInfo.h"
Daniel Dunbar4f2bc552010-01-13 00:48:06 +000018#include "clang/Basic/Version.h"
Alp Tokerf988d002014-06-06 10:36:22 +000019#include "clang/Config/config.h"
David Blaikie8b00dcb2011-09-26 00:21:47 +000020#include "clang/Frontend/ChainedDiagnosticConsumer.h"
Daniel Dunbar4f2bc552010-01-13 00:48:06 +000021#include "clang/Frontend/FrontendAction.h"
Douglas Gregorfaeb1d42011-09-12 23:31:24 +000022#include "clang/Frontend/FrontendActions.h"
Daniel Dunbarf7093b52009-11-13 09:36:05 +000023#include "clang/Frontend/FrontendDiagnostic.h"
Daniel Dunbar2083c322011-04-07 18:31:10 +000024#include "clang/Frontend/LogDiagnosticPrinter.h"
Ted Kremenek4610ea22011-10-29 00:12:39 +000025#include "clang/Frontend/SerializedDiagnosticPrinter.h"
Daniel Dunbar7d75afc2009-11-13 05:52:34 +000026#include "clang/Frontend/TextDiagnosticPrinter.h"
Daniel Dunbaraaa148f2009-11-13 05:52:11 +000027#include "clang/Frontend/Utils.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000028#include "clang/Frontend/VerifyDiagnosticConsumer.h"
29#include "clang/Lex/HeaderSearch.h"
30#include "clang/Lex/PTHManager.h"
31#include "clang/Lex/Preprocessor.h"
Daniel Dunbarf7093b52009-11-13 09:36:05 +000032#include "clang/Sema/CodeCompleteConsumer.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000033#include "clang/Sema/Sema.h"
34#include "clang/Serialization/ASTReader.h"
John Thompson2255f2c2014-04-23 12:57:01 +000035#include "clang/Serialization/GlobalModuleIndex.h"
Douglas Gregor171b7802010-03-30 17:33:59 +000036#include "llvm/ADT/Statistic.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000037#include "llvm/Support/CrashRecoveryContext.h"
Rafael Espindola71de0b62014-06-13 17:20:50 +000038#include "llvm/Support/Errc.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000039#include "llvm/Support/FileSystem.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000040#include "llvm/Support/Host.h"
Douglas Gregore2124892012-01-29 20:15:24 +000041#include "llvm/Support/LockFileManager.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000042#include "llvm/Support/MemoryBuffer.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000043#include "llvm/Support/Path.h"
44#include "llvm/Support/Program.h"
45#include "llvm/Support/Signals.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000046#include "llvm/Support/Timer.h"
47#include "llvm/Support/raw_ostream.h"
Douglas Gregor527b1c92013-03-25 21:19:16 +000048#include <sys/stat.h>
Rafael Espindola8a8e5542014-06-12 17:19:42 +000049#include <system_error>
Douglas Gregor37da3272013-03-25 21:51:16 +000050#include <time.h>
Douglas Gregor54a88812011-10-05 14:53:30 +000051
Daniel Dunbar636404a2009-11-13 03:51:44 +000052using namespace clang;
53
Adrian Prantlbb165fb2015-06-20 18:53:08 +000054CompilerInstance::CompilerInstance(
55 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
56 bool BuildingModule)
57 : ModuleLoader(BuildingModule), Invocation(new CompilerInvocation()),
58 ModuleManager(nullptr), ThePCHContainerOperations(PCHContainerOps),
59 BuildGlobalModuleIndex(false), HaveFullGlobalModuleIndex(false),
60 ModuleBuildFailed(false) {}
Daniel Dunbar636404a2009-11-13 03:51:44 +000061
62CompilerInstance::~CompilerInstance() {
Benjamin Kramer3c717b42012-10-14 19:21:21 +000063 assert(OutputFiles.empty() && "Still output files in flight?");
Daniel Dunbare922d9b2010-02-16 01:54:47 +000064}
65
Daniel Dunbar68242252010-01-30 21:47:07 +000066void CompilerInstance::setInvocation(CompilerInvocation *Value) {
Ted Kremenek5e14d392011-03-21 18:40:17 +000067 Invocation = Value;
Daniel Dunbar68242252010-01-30 21:47:07 +000068}
69
Douglas Gregorc1bbec82013-01-25 00:45:27 +000070bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
Douglas Gregore060e572013-01-25 01:03:03 +000071 return (BuildGlobalModuleIndex ||
Douglas Gregor11ef0b72013-03-22 21:26:48 +000072 (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
73 getFrontendOpts().GenerateGlobalModuleIndex)) &&
Douglas Gregore060e572013-01-25 01:03:03 +000074 !ModuleBuildFailed;
Douglas Gregorc1bbec82013-01-25 00:45:27 +000075}
76
David Blaikie9c902b52011-09-25 23:23:43 +000077void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
Douglas Gregor7f95d262010-04-05 23:52:57 +000078 Diagnostics = Value;
Daniel Dunbare01dc862009-11-14 01:20:40 +000079}
80
Daniel Dunbare01dc862009-11-14 01:20:40 +000081void CompilerInstance::setTarget(TargetInfo *Value) {
Ted Kremenek5e14d392011-03-21 18:40:17 +000082 Target = Value;
Daniel Dunbare01dc862009-11-14 01:20:40 +000083}
84
85void CompilerInstance::setFileManager(FileManager *Value) {
Ted Kremenek5e14d392011-03-21 18:40:17 +000086 FileMgr = Value;
Ben Langmuirc8130a72014-02-20 21:59:23 +000087 if (Value)
88 VirtualFileSystem = Value->getVirtualFileSystem();
89 else
90 VirtualFileSystem.reset();
Daniel Dunbare01dc862009-11-14 01:20:40 +000091}
92
NAKAMURA Takumi82a35112011-10-08 11:31:46 +000093void CompilerInstance::setSourceManager(SourceManager *Value) {
Ted Kremenek5e14d392011-03-21 18:40:17 +000094 SourceMgr = Value;
Daniel Dunbare01dc862009-11-14 01:20:40 +000095}
96
Ted Kremenek5e14d392011-03-21 18:40:17 +000097void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; }
Daniel Dunbare01dc862009-11-14 01:20:40 +000098
Ted Kremenek5e14d392011-03-21 18:40:17 +000099void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; }
Daniel Dunbare01dc862009-11-14 01:20:40 +0000100
Douglas Gregor0e93f012010-08-12 23:31:19 +0000101void CompilerInstance::setSema(Sema *S) {
102 TheSema.reset(S);
103}
104
David Blaikie6beb6aa2014-08-10 19:56:51 +0000105void CompilerInstance::setASTConsumer(std::unique_ptr<ASTConsumer> Value) {
106 Consumer = std::move(Value);
Daniel Dunbar56d9c292009-11-14 02:47:17 +0000107}
108
Daniel Dunbare01dc862009-11-14 01:20:40 +0000109void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
110 CompletionConsumer.reset(Value);
111}
David Blaikie61535812014-08-10 20:12:39 +0000112
113std::unique_ptr<Sema> CompilerInstance::takeSema() {
114 return std::move(TheSema);
115}
116
Argyrios Kyrtzidis1b7ed912014-02-27 04:11:59 +0000117IntrusiveRefCntPtr<ASTReader> CompilerInstance::getModuleManager() const {
118 return ModuleManager;
119}
120void CompilerInstance::setModuleManager(IntrusiveRefCntPtr<ASTReader> Reader) {
121 ModuleManager = Reader;
122}
Daniel Dunbare01dc862009-11-14 01:20:40 +0000123
Justin Bogner86d12592014-06-19 19:36:03 +0000124std::shared_ptr<ModuleDependencyCollector>
125CompilerInstance::getModuleDepCollector() const {
126 return ModuleDepCollector;
127}
128
129void CompilerInstance::setModuleDepCollector(
130 std::shared_ptr<ModuleDependencyCollector> Collector) {
131 ModuleDepCollector = Collector;
132}
133
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000134// Diagnostics
Douglas Gregor811db4e2012-10-23 22:26:28 +0000135static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
Daniel Dunbar7b833062011-04-07 18:59:02 +0000136 const CodeGenOptions *CodeGenOpts,
David Blaikie9c902b52011-09-25 23:23:43 +0000137 DiagnosticsEngine &Diags) {
Rafael Espindoladae941a2014-08-25 18:17:04 +0000138 std::error_code EC;
David Blaikie11f8a942014-09-15 17:30:56 +0000139 std::unique_ptr<raw_ostream> StreamOwner;
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000140 raw_ostream *OS = &llvm::errs();
Douglas Gregor811db4e2012-10-23 22:26:28 +0000141 if (DiagOpts->DiagnosticLogFile != "-") {
Daniel Dunbar2083c322011-04-07 18:31:10 +0000142 // Create the output stream.
David Blaikie11f8a942014-09-15 17:30:56 +0000143 auto FileOS = llvm::make_unique<llvm::raw_fd_ostream>(
Rafael Espindoladae941a2014-08-25 18:17:04 +0000144 DiagOpts->DiagnosticLogFile, EC,
David Blaikie11f8a942014-09-15 17:30:56 +0000145 llvm::sys::fs::F_Append | llvm::sys::fs::F_Text);
Rafael Espindoladae941a2014-08-25 18:17:04 +0000146 if (EC) {
Daniel Dunbar2083c322011-04-07 18:31:10 +0000147 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
Rafael Espindoladae941a2014-08-25 18:17:04 +0000148 << DiagOpts->DiagnosticLogFile << EC.message();
Daniel Dunbar2083c322011-04-07 18:31:10 +0000149 } else {
150 FileOS->SetUnbuffered();
151 FileOS->SetUseAtomicWrites(true);
David Blaikie11f8a942014-09-15 17:30:56 +0000152 OS = FileOS.get();
153 StreamOwner = std::move(FileOS);
Daniel Dunbar2083c322011-04-07 18:31:10 +0000154 }
155 }
156
157 // Chain in the diagnostic client which will log the diagnostics.
David Blaikie7ee25502014-09-15 17:50:10 +0000158 auto Logger = llvm::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,
159 std::move(StreamOwner));
Daniel Dunbar7b833062011-04-07 18:59:02 +0000160 if (CodeGenOpts)
161 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
David Blaikie7ee25502014-09-15 17:50:10 +0000162 assert(Diags.ownsClient());
Alexander Kornienko41c247a2014-11-17 23:46:02 +0000163 Diags.setClient(
164 new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger)));
Daniel Dunbar2083c322011-04-07 18:31:10 +0000165}
166
Douglas Gregor811db4e2012-10-23 22:26:28 +0000167static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
Ted Kremenek4610ea22011-10-29 00:12:39 +0000168 DiagnosticsEngine &Diags,
169 StringRef OutputFile) {
David Blaikie7ee25502014-09-15 17:50:10 +0000170 auto SerializedConsumer =
Justin Bogner5a6a2fc2014-10-23 22:20:11 +0000171 clang::serialized_diags::create(OutputFile, DiagOpts);
Ahmed Charles9a16beb2014-03-07 19:33:25 +0000172
Alexander Kornienko254b7db2014-11-13 13:08:27 +0000173 if (Diags.ownsClient()) {
174 Diags.setClient(new ChainedDiagnosticConsumer(
Alexander Kornienko41c247a2014-11-17 23:46:02 +0000175 Diags.takeClient(), std::move(SerializedConsumer)));
Alexander Kornienko254b7db2014-11-13 13:08:27 +0000176 } else {
177 Diags.setClient(new ChainedDiagnosticConsumer(
Alexander Kornienko4c0ef3792014-11-17 14:46:28 +0000178 Diags.getClient(), std::move(SerializedConsumer)));
Alexander Kornienko254b7db2014-11-13 13:08:27 +0000179 }
Ted Kremenek4610ea22011-10-29 00:12:39 +0000180}
181
Sean Silvaf1b49e22013-01-20 01:58:28 +0000182void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
Douglas Gregor30071cea2013-05-03 23:07:45 +0000183 bool ShouldOwnClient) {
Sean Silvaf1b49e22013-01-20 01:58:28 +0000184 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
Douglas Gregor30071cea2013-05-03 23:07:45 +0000185 ShouldOwnClient, &getCodeGenOpts());
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000186}
187
Dylan Noblesmithc95d8192012-02-20 14:00:23 +0000188IntrusiveRefCntPtr<DiagnosticsEngine>
Douglas Gregor811db4e2012-10-23 22:26:28 +0000189CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
David Blaikiee2eefae2011-09-25 23:39:51 +0000190 DiagnosticConsumer *Client,
Douglas Gregor2b9b4642011-09-13 01:26:44 +0000191 bool ShouldOwnClient,
Daniel Dunbar7b833062011-04-07 18:59:02 +0000192 const CodeGenOptions *CodeGenOpts) {
Dylan Noblesmithc95d8192012-02-20 14:00:23 +0000193 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
194 IntrusiveRefCntPtr<DiagnosticsEngine>
Douglas Gregor811db4e2012-10-23 22:26:28 +0000195 Diags(new DiagnosticsEngine(DiagID, Opts));
Daniel Dunbar1b39a2e2009-11-14 07:53:24 +0000196
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000197 // Create the diagnostic client for reporting errors or for
198 // implementing -verify.
Douglas Gregord0e9e3a2011-09-29 00:38:00 +0000199 if (Client) {
Douglas Gregor30071cea2013-05-03 23:07:45 +0000200 Diags->setClient(Client, ShouldOwnClient);
Douglas Gregord0e9e3a2011-09-29 00:38:00 +0000201 } else
Douglas Gregor44c6ee72010-11-11 00:39:14 +0000202 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
Daniel Dunbar50ec0da2009-11-14 03:24:39 +0000203
204 // Chain in -verify checker, if requested.
Douglas Gregor811db4e2012-10-23 22:26:28 +0000205 if (Opts->VerifyDiagnostics)
David Blaikie69609dc2011-09-26 00:38:03 +0000206 Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000207
Daniel Dunbar2083c322011-04-07 18:31:10 +0000208 // Chain in -diagnostic-log-file dumper, if requested.
Douglas Gregor811db4e2012-10-23 22:26:28 +0000209 if (!Opts->DiagnosticLogFile.empty())
Daniel Dunbar7b833062011-04-07 18:59:02 +0000210 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000211
Douglas Gregor811db4e2012-10-23 22:26:28 +0000212 if (!Opts->DiagnosticSerializationFile.empty())
Ted Kremenek4610ea22011-10-29 00:12:39 +0000213 SetupSerializedDiagnostics(Opts, *Diags,
Douglas Gregor811db4e2012-10-23 22:26:28 +0000214 Opts->DiagnosticSerializationFile);
Ted Kremenek4610ea22011-10-29 00:12:39 +0000215
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000216 // Configure our handling of diagnostics.
Douglas Gregor811db4e2012-10-23 22:26:28 +0000217 ProcessWarningOptions(*Diags, *Opts);
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000218
Douglas Gregor7f95d262010-04-05 23:52:57 +0000219 return Diags;
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000220}
221
222// File Manager
223
Daniel Dunbar546a6762009-11-13 04:12:06 +0000224void CompilerInstance::createFileManager() {
Ben Langmuirc8130a72014-02-20 21:59:23 +0000225 if (!hasVirtualFileSystem()) {
226 // TODO: choose the virtual file system based on the CompilerInvocation.
227 setVirtualFileSystem(vfs::getRealFileSystem());
228 }
229 FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem);
Daniel Dunbar546a6762009-11-13 04:12:06 +0000230}
231
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000232// Source Manager
233
Chris Lattner5159f612010-11-23 08:35:12 +0000234void CompilerInstance::createSourceManager(FileManager &FileMgr) {
Ted Kremenek5e14d392011-03-21 18:40:17 +0000235 SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
Daniel Dunbar546a6762009-11-13 04:12:06 +0000236}
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000237
Alp Tokerc3580002014-07-07 06:05:00 +0000238// Initialize the remapping of files to alternative contents, e.g.,
239// those specified through other files.
240static void InitializeFileRemapping(DiagnosticsEngine &Diags,
241 SourceManager &SourceMgr,
242 FileManager &FileMgr,
243 const PreprocessorOptions &InitOpts) {
244 // Remap files in the source manager (with buffers).
Alp Toker1b070d22014-07-07 07:47:20 +0000245 for (const auto &RB : InitOpts.RemappedFileBuffers) {
Alp Tokerc3580002014-07-07 06:05:00 +0000246 // Create the file entry for the file that we're mapping from.
247 const FileEntry *FromFile =
Alp Toker1b070d22014-07-07 07:47:20 +0000248 FileMgr.getVirtualFile(RB.first, RB.second->getBufferSize(), 0);
Alp Tokerc3580002014-07-07 06:05:00 +0000249 if (!FromFile) {
Alp Toker1b070d22014-07-07 07:47:20 +0000250 Diags.Report(diag::err_fe_remap_missing_from_file) << RB.first;
Alp Tokerc3580002014-07-07 06:05:00 +0000251 if (!InitOpts.RetainRemappedFileBuffers)
Alp Toker1b070d22014-07-07 07:47:20 +0000252 delete RB.second;
Alp Tokerc3580002014-07-07 06:05:00 +0000253 continue;
254 }
255
256 // Override the contents of the "from" file with the contents of
257 // the "to" file.
Alp Toker1b070d22014-07-07 07:47:20 +0000258 SourceMgr.overrideFileContents(FromFile, RB.second,
Alp Tokerc3580002014-07-07 06:05:00 +0000259 InitOpts.RetainRemappedFileBuffers);
260 }
261
262 // Remap files in the source manager (with other files).
Alp Toker1b070d22014-07-07 07:47:20 +0000263 for (const auto &RF : InitOpts.RemappedFiles) {
Alp Tokerc3580002014-07-07 06:05:00 +0000264 // Find the file that we're mapping to.
Alp Toker1b070d22014-07-07 07:47:20 +0000265 const FileEntry *ToFile = FileMgr.getFile(RF.second);
Alp Tokerc3580002014-07-07 06:05:00 +0000266 if (!ToFile) {
Alp Toker1b070d22014-07-07 07:47:20 +0000267 Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;
Alp Tokerc3580002014-07-07 06:05:00 +0000268 continue;
269 }
270
271 // Create the file entry for the file that we're mapping from.
272 const FileEntry *FromFile =
Alp Toker1b070d22014-07-07 07:47:20 +0000273 FileMgr.getVirtualFile(RF.first, ToFile->getSize(), 0);
Alp Tokerc3580002014-07-07 06:05:00 +0000274 if (!FromFile) {
Alp Toker1b070d22014-07-07 07:47:20 +0000275 Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first;
Alp Tokerc3580002014-07-07 06:05:00 +0000276 continue;
277 }
278
279 // Override the contents of the "from" file with the contents of
280 // the "to" file.
281 SourceMgr.overrideFileContents(FromFile, ToFile);
282 }
283
284 SourceMgr.setOverridenFilesKeepOriginalName(
285 InitOpts.RemappedFilesKeepOriginalName);
286}
287
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000288// Preprocessor
289
Argyrios Kyrtzidise1974dc2014-03-07 07:47:58 +0000290void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
Douglas Gregor08142532011-08-26 23:56:07 +0000291 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000292
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000293 // Create a PTH manager if we are using some form of a token cache.
Craig Topper49a27902014-05-22 04:46:25 +0000294 PTHManager *PTHMgr = nullptr;
Daniel Dunbard6ea9022009-11-17 05:52:41 +0000295 if (!PPOpts.TokenCache.empty())
Douglas Gregor08142532011-08-26 23:56:07 +0000296 PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000297
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000298 // Create the Preprocessor.
Douglas Gregorb85b9cc2012-10-24 16:19:39 +0000299 HeaderSearch *HeaderInfo = new HeaderSearch(&getHeaderSearchOpts(),
Manuel Klimek1f76c4e2013-10-24 07:51:24 +0000300 getSourceManager(),
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +0000301 getDiagnostics(),
Douglas Gregor89929282012-01-30 06:01:29 +0000302 getLangOpts(),
303 &getTarget());
Alp Toker96637802014-05-02 03:43:38 +0000304 PP = new Preprocessor(&getPreprocessorOpts(), getDiagnostics(), getLangOpts(),
Douglas Gregor08142532011-08-26 23:56:07 +0000305 getSourceManager(), *HeaderInfo, *this, PTHMgr,
Alp Toker96637802014-05-02 03:43:38 +0000306 /*OwnsHeaderSearch=*/true, TUKind);
Alp Toker1ae02f62014-05-02 03:43:30 +0000307 PP->Initialize(getTarget());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000308
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000309 // Note that this is different then passing PTHMgr to Preprocessor's ctor.
310 // That argument is used as the IdentifierInfoLookup argument to
311 // IdentifierTable's ctor.
312 if (PTHMgr) {
Douglas Gregor08142532011-08-26 23:56:07 +0000313 PTHMgr->setPreprocessor(&*PP);
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000314 PP->setPTHManager(PTHMgr);
315 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000316
Douglas Gregor7f6d60d2010-03-19 16:15:56 +0000317 if (PPOpts.DetailedRecord)
Argyrios Kyrtzidisf3d587e2012-12-04 07:27:05 +0000318 PP->createPreprocessingRecord();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000319
Alp Tokerc3580002014-07-07 06:05:00 +0000320 // Apply remappings to the source manager.
321 InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
322 PP->getFileManager(), PPOpts);
323
324 // Predefine macros and configure the preprocessor.
Adrian Prantlfb2398d2015-07-17 01:19:54 +0000325 InitializePreprocessor(*PP, PPOpts, getPCHContainerReader(),
Adrian Prantlbb165fb2015-06-20 18:53:08 +0000326 getFrontendOpts());
Alp Tokerc3580002014-07-07 06:05:00 +0000327
328 // Initialize the header search object.
329 ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(),
330 PP->getLangOpts(), PP->getTargetInfo().getTriple());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000331
Jordan Rose17441582013-01-30 01:52:57 +0000332 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
333
Chandler Carruthff8d9432015-03-28 01:10:44 +0000334 if (PP->getLangOpts().Modules)
335 PP->getHeaderSearchInfo().setModuleCachePath(getSpecificModuleCachePath());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000336
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000337 // Handle generating dependencies, if requested.
Douglas Gregor08142532011-08-26 23:56:07 +0000338 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000339 if (!DepOpts.OutputFile.empty())
Ben Langmuircb69b572014-03-07 06:40:32 +0000340 TheDependencyFileGenerator.reset(
341 DependencyFileGenerator::CreateAndAttachToPreprocessor(*PP, DepOpts));
Douglas Gregor2e129652012-02-02 23:45:13 +0000342 if (!DepOpts.DOTOutputFile.empty())
343 AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile,
Douglas Gregor83d46be2012-02-02 00:54:52 +0000344 getHeaderSearchOpts().Sysroot);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000345
Ben Langmuir33c80902014-06-30 20:04:14 +0000346 for (auto &Listener : DependencyCollectors)
347 Listener->attachToPreprocessor(*PP);
348
Justin Bogner86d12592014-06-19 19:36:03 +0000349 // If we don't have a collector, but we are collecting module dependencies,
350 // then we're the top level compiler instance and need to create one.
351 if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty())
352 ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(
353 DepOpts.ModuleDependencyOutputDir);
Hans Wennborg0fd62072013-08-09 00:32:23 +0000354
Daniel Dunbar27734fd2011-02-02 15:41:17 +0000355 // Handle generating header include information, if requested.
356 if (DepOpts.ShowHeaderIncludes)
357 AttachHeaderIncludeGen(*PP);
Daniel Dunbar1af1d27512011-02-02 21:11:31 +0000358 if (!DepOpts.HeaderIncludeOutputFile.empty()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000359 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
Daniel Dunbar1af1d27512011-02-02 21:11:31 +0000360 if (OutputPath == "-")
361 OutputPath = "";
Daniel Dunbarfe908a82011-03-21 19:37:38 +0000362 AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath,
363 /*ShowDepth=*/false);
Daniel Dunbar1af1d27512011-02-02 21:11:31 +0000364 }
Hans Wennborg0fd62072013-08-09 00:32:23 +0000365
366 if (DepOpts.PrintShowIncludes) {
367 AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/false, /*OutputPath=*/"",
368 /*ShowDepth=*/true, /*MSStyle=*/true);
369 }
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000370}
Daniel Dunbardf3e30c2009-11-13 08:20:47 +0000371
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +0000372std::string CompilerInstance::getSpecificModuleCachePath() {
373 // Set up the module path, including the hash for the
374 // module-creation options.
Richard Smithd520a252015-07-21 18:07:47 +0000375 SmallString<256> SpecificModuleCache(getHeaderSearchOpts().ModuleCachePath);
376 if (!SpecificModuleCache.empty() && !getHeaderSearchOpts().DisableModuleHash)
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +0000377 llvm::sys::path::append(SpecificModuleCache,
378 getInvocation().getModuleHash());
379 return SpecificModuleCache.str();
380}
381
Daniel Dunbardf3e30c2009-11-13 08:20:47 +0000382// ASTContext
383
384void CompilerInstance::createASTContext() {
385 Preprocessor &PP = getPreprocessor();
Ted Kremenek5e14d392011-03-21 18:40:17 +0000386 Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
Alp Toker08043432014-05-03 03:46:04 +0000387 PP.getIdentifierTable(), PP.getSelectorTable(),
388 PP.getBuiltinInfo());
389 Context->InitBuiltinTypes(getTarget());
Daniel Dunbardf3e30c2009-11-13 08:20:47 +0000390}
Daniel Dunbar599313e2009-11-13 08:21:10 +0000391
392// ExternalASTSource
393
Nico Weber824285e2014-05-08 04:26:47 +0000394void CompilerInstance::createPCHExternalASTSource(
395 StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors,
396 void *DeserializationListener, bool OwnDeserializationListener) {
Sebastian Redl009e7f22010-10-05 16:15:19 +0000397 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
Richard Smith4eca9b92015-02-04 23:37:59 +0000398 ModuleManager = createPCHExternalASTSource(
Nico Weber824285e2014-05-08 04:26:47 +0000399 Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation,
400 AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(),
Adrian Prantlfb2398d2015-07-17 01:19:54 +0000401 getPCHContainerReader(), DeserializationListener,
Adrian Prantlbb165fb2015-06-20 18:53:08 +0000402 OwnDeserializationListener, Preamble,
Nico Weber824285e2014-05-08 04:26:47 +0000403 getFrontendOpts().UseGlobalModuleIndex);
Daniel Dunbar599313e2009-11-13 08:21:10 +0000404}
405
Richard Smith4eca9b92015-02-04 23:37:59 +0000406IntrusiveRefCntPtr<ASTReader> CompilerInstance::createPCHExternalASTSource(
Yaron Keren5b816062015-07-06 08:47:15 +0000407 StringRef Path, StringRef Sysroot, bool DisablePCHValidation,
Nico Weber824285e2014-05-08 04:26:47 +0000408 bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context,
Adrian Prantlfb2398d2015-07-17 01:19:54 +0000409 const PCHContainerReader &PCHContainerRdr,
Nico Weber824285e2014-05-08 04:26:47 +0000410 void *DeserializationListener, bool OwnDeserializationListener,
411 bool Preamble, bool UseGlobalModuleIndex) {
Ben Langmuirdcf73862014-03-12 00:06:17 +0000412 HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
413
Adrian Prantlbb165fb2015-06-20 18:53:08 +0000414 IntrusiveRefCntPtr<ASTReader> Reader(new ASTReader(
Adrian Prantlfb2398d2015-07-17 01:19:54 +0000415 PP, Context, PCHContainerRdr, Sysroot.empty() ? "" : Sysroot.data(),
Adrian Prantlbb165fb2015-06-20 18:53:08 +0000416 DisablePCHValidation, AllowPCHWithCompilerErrors,
417 /*AllowConfigurationMismatch*/ false, HSOpts.ModulesValidateSystemHeaders,
418 UseGlobalModuleIndex));
Richard Smith4eca9b92015-02-04 23:37:59 +0000419
420 // We need the external source to be set up before we read the AST, because
421 // eagerly-deserialized declarations may use it.
422 Context.setExternalSource(Reader.get());
Daniel Dunbar599313e2009-11-13 08:21:10 +0000423
Sebastian Redl07a89a82010-07-30 00:29:29 +0000424 Reader->setDeserializationListener(
Nico Weber824285e2014-05-08 04:26:47 +0000425 static_cast<ASTDeserializationListener *>(DeserializationListener),
426 /*TakeOwnership=*/OwnDeserializationListener);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000427 switch (Reader->ReadAST(Path,
428 Preamble ? serialization::MK_Preamble
Douglas Gregor4b29c162012-10-22 23:51:00 +0000429 : serialization::MK_PCH,
Argyrios Kyrtzidis2ec29362012-11-15 18:57:22 +0000430 SourceLocation(),
Ben Langmuir3d4417c2014-02-07 17:31:11 +0000431 ASTReader::ARR_None)) {
Sebastian Redl2c499f62010-08-18 23:56:43 +0000432 case ASTReader::Success:
Daniel Dunbar599313e2009-11-13 08:21:10 +0000433 // Set the predefines buffer as suggested by the PCH reader. Typically, the
434 // predefines buffer will be empty.
435 PP.setPredefines(Reader->getSuggestedPredefines());
Richard Smith4eca9b92015-02-04 23:37:59 +0000436 return Reader;
Daniel Dunbar599313e2009-11-13 08:21:10 +0000437
Sebastian Redl2c499f62010-08-18 23:56:43 +0000438 case ASTReader::Failure:
Daniel Dunbar599313e2009-11-13 08:21:10 +0000439 // Unrecoverable failure: don't even try to process the input file.
440 break;
441
Douglas Gregor7029ce12013-03-19 00:28:20 +0000442 case ASTReader::Missing:
Douglas Gregorc9ad5fb2012-10-22 22:50:17 +0000443 case ASTReader::OutOfDate:
444 case ASTReader::VersionMismatch:
445 case ASTReader::ConfigurationMismatch:
446 case ASTReader::HadErrors:
Daniel Dunbar599313e2009-11-13 08:21:10 +0000447 // No suitable PCH file could be found. Return an error.
448 break;
449 }
450
Richard Smith4eca9b92015-02-04 23:37:59 +0000451 Context.setExternalSource(nullptr);
Craig Topper49a27902014-05-22 04:46:25 +0000452 return nullptr;
Daniel Dunbar599313e2009-11-13 08:21:10 +0000453}
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000454
455// Code Completion
456
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000457static bool EnableCodeCompletion(Preprocessor &PP,
Douglas Gregor8e984da2010-08-04 16:47:14 +0000458 const std::string &Filename,
459 unsigned Line,
460 unsigned Column) {
461 // Tell the source manager to chop off the given file at a specific
462 // line and column.
Chris Lattner5159f612010-11-23 08:35:12 +0000463 const FileEntry *Entry = PP.getFileManager().getFile(Filename);
Douglas Gregor8e984da2010-08-04 16:47:14 +0000464 if (!Entry) {
465 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
466 << Filename;
467 return true;
468 }
469
470 // Truncate the named file at the given line/column.
471 PP.SetCodeCompletionPoint(Entry, Line, Column);
472 return false;
473}
474
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000475void CompilerInstance::createCodeCompletionConsumer() {
476 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
Douglas Gregor8e984da2010-08-04 16:47:14 +0000477 if (!CompletionConsumer) {
Erik Verbruggen2fca3c22012-04-12 10:31:12 +0000478 setCodeCompletionConsumer(
Douglas Gregor8e984da2010-08-04 16:47:14 +0000479 createCodeCompletionConsumer(getPreprocessor(),
480 Loc.FileName, Loc.Line, Loc.Column,
Dmitri Gribenko3292d062012-07-02 17:35:10 +0000481 getFrontendOpts().CodeCompleteOpts,
Douglas Gregor8e984da2010-08-04 16:47:14 +0000482 llvm::outs()));
483 if (!CompletionConsumer)
484 return;
485 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
486 Loc.Line, Loc.Column)) {
Craig Topper49a27902014-05-22 04:46:25 +0000487 setCodeCompletionConsumer(nullptr);
Douglas Gregor00a0cf72010-03-16 06:04:47 +0000488 return;
Douglas Gregor8e984da2010-08-04 16:47:14 +0000489 }
Douglas Gregorf09935f2009-12-01 05:55:20 +0000490
491 if (CompletionConsumer->isOutputBinary() &&
Rafael Espindolaa3346d82013-06-12 20:44:26 +0000492 llvm::sys::ChangeStdoutToBinary()) {
Douglas Gregorf09935f2009-12-01 05:55:20 +0000493 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
Craig Topper49a27902014-05-22 04:46:25 +0000494 setCodeCompletionConsumer(nullptr);
Douglas Gregorf09935f2009-12-01 05:55:20 +0000495 }
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000496}
497
Kovarththanan Rajaratnam5505dff2009-11-29 09:57:35 +0000498void CompilerInstance::createFrontendTimer() {
Richard Smithce18a182015-07-14 00:26:00 +0000499 FrontendTimerGroup.reset(new llvm::TimerGroup("Clang front-end time report"));
500 FrontendTimer.reset(
501 new llvm::Timer("Clang front-end timer", *FrontendTimerGroup));
Kovarththanan Rajaratnam5505dff2009-11-29 09:57:35 +0000502}
503
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000504CodeCompleteConsumer *
505CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
Yaron Keren5b816062015-07-06 08:47:15 +0000506 StringRef Filename,
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000507 unsigned Line,
508 unsigned Column,
Dmitri Gribenko3292d062012-07-02 17:35:10 +0000509 const CodeCompleteOptions &Opts,
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000510 raw_ostream &OS) {
Douglas Gregor8e984da2010-08-04 16:47:14 +0000511 if (EnableCodeCompletion(PP, Filename, Line, Column))
Craig Topper49a27902014-05-22 04:46:25 +0000512 return nullptr;
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000513
514 // Set up the creation routine for code-completion.
Dmitri Gribenko3292d062012-07-02 17:35:10 +0000515 return new PrintingCodeCompleteConsumer(Opts, OS);
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000516}
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000517
Douglas Gregor69f74f82011-08-25 22:30:56 +0000518void CompilerInstance::createSema(TranslationUnitKind TUKind,
Douglas Gregor0e93f012010-08-12 23:31:19 +0000519 CodeCompleteConsumer *CompletionConsumer) {
520 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
Douglas Gregor69f74f82011-08-25 22:30:56 +0000521 TUKind, CompletionConsumer));
Douglas Gregor0e93f012010-08-12 23:31:19 +0000522}
523
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000524// Output Files
525
Rafael Espindola269ec0f2015-04-10 14:11:52 +0000526void CompilerInstance::addOutputFile(OutputFile &&OutFile) {
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000527 assert(OutFile.OS && "Attempt to add empty stream to output list!");
Rafael Espindola269ec0f2015-04-10 14:11:52 +0000528 OutputFiles.push_back(std::move(OutFile));
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000529}
530
Kovarththanan Rajaratnam1c558cd2010-03-06 12:07:48 +0000531void CompilerInstance::clearOutputFiles(bool EraseFiles) {
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000532 for (OutputFile &OF : OutputFiles) {
533 // Manually close the stream before we rename it.
534 OF.OS.reset();
535
536 if (!OF.TempFilename.empty()) {
Anders Carlssonb5c356a2011-03-06 22:25:35 +0000537 if (EraseFiles) {
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000538 llvm::sys::fs::remove(OF.TempFilename);
Anders Carlssonb5c356a2011-03-06 22:25:35 +0000539 } else {
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000540 SmallString<128> NewOutFile(OF.Filename);
Anders Carlssonb5c356a2011-03-06 22:25:35 +0000541
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +0000542 // If '-working-directory' was passed, the output filename should be
543 // relative to that.
Anders Carlsson9ba8fb12011-03-14 01:13:54 +0000544 FileMgr->FixupRelativePath(NewOutFile);
Rafael Espindolac0809172014-06-12 14:02:15 +0000545 if (std::error_code ec =
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000546 llvm::sys::fs::rename(OF.TempFilename, NewOutFile)) {
Manuel Klimek3ef9c442012-05-16 20:55:58 +0000547 getDiagnostics().Report(diag::err_unable_to_rename_temp)
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000548 << OF.TempFilename << OF.Filename << ec.message();
Anders Carlssonb5c356a2011-03-06 22:25:35 +0000549
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000550 llvm::sys::fs::remove(OF.TempFilename);
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000551 }
552 }
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000553 } else if (!OF.Filename.empty() && EraseFiles)
554 llvm::sys::fs::remove(OF.Filename);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000555
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000556 }
557 OutputFiles.clear();
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000558 NonSeekStream.reset();
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000559}
560
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000561raw_pwrite_stream *
562CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile,
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000563 StringRef Extension) {
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000564 return createOutputFile(getFrontendOpts().OutputFile, Binary,
Daniel Dunbarae77b3d2012-03-03 00:36:06 +0000565 /*RemoveFileOnSignal=*/true, InFile, Extension,
566 /*UseTemporary=*/true);
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000567}
568
Alp Tokerea046722014-06-03 17:23:34 +0000569llvm::raw_null_ostream *CompilerInstance::createNullOutputFile() {
Rafael Espindola269ec0f2015-04-10 14:11:52 +0000570 auto OS = llvm::make_unique<llvm::raw_null_ostream>();
571 llvm::raw_null_ostream *Ret = OS.get();
572 addOutputFile(OutputFile("", "", std::move(OS)));
573 return Ret;
Alp Tokerea046722014-06-03 17:23:34 +0000574}
575
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000576raw_pwrite_stream *
577CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary,
578 bool RemoveFileOnSignal, StringRef InFile,
579 StringRef Extension, bool UseTemporary,
Daniel Dunbarb9c62c02012-03-03 00:36:02 +0000580 bool CreateMissingDirectories) {
Rafael Espindoladae941a2014-08-25 18:17:04 +0000581 std::string OutputPathName, TempPathName;
582 std::error_code EC;
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000583 std::unique_ptr<raw_pwrite_stream> OS = createOutputFile(
Rafael Espindoladae941a2014-08-25 18:17:04 +0000584 OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension,
Rafael Espindolac80a4062015-04-10 14:30:43 +0000585 UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName);
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000586 if (!OS) {
Rafael Espindoladae941a2014-08-25 18:17:04 +0000587 getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath
588 << EC.message();
Craig Topper49a27902014-05-22 04:46:25 +0000589 return nullptr;
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000590 }
591
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000592 raw_pwrite_stream *Ret = OS.get();
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000593 // Add the output file -- but don't try to remove "-", since this means we are
594 // using stdin.
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000595 addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "",
Rafael Espindola269ec0f2015-04-10 14:11:52 +0000596 TempPathName, std::move(OS)));
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000597
Rafael Espindola269ec0f2015-04-10 14:11:52 +0000598 return Ret;
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000599}
600
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000601std::unique_ptr<llvm::raw_pwrite_stream> CompilerInstance::createOutputFile(
Rafael Espindoladae941a2014-08-25 18:17:04 +0000602 StringRef OutputPath, std::error_code &Error, bool Binary,
603 bool RemoveFileOnSignal, StringRef InFile, StringRef Extension,
604 bool UseTemporary, bool CreateMissingDirectories,
605 std::string *ResultPathName, std::string *TempPathName) {
Daniel Dunbarb9c62c02012-03-03 00:36:02 +0000606 assert((!CreateMissingDirectories || UseTemporary) &&
607 "CreateMissingDirectories is only allowed when using temporary files");
608
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000609 std::string OutFile, TempFile;
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000610 if (!OutputPath.empty()) {
611 OutFile = OutputPath;
612 } else if (InFile == "-") {
613 OutFile = "-";
614 } else if (!Extension.empty()) {
Rafael Espindola399ab332013-06-26 04:32:59 +0000615 SmallString<128> Path(InFile);
616 llvm::sys::path::replace_extension(Path, Extension);
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000617 OutFile = Path.str();
618 } else {
619 OutFile = "-";
620 }
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000621
Ahmed Charlesb8984322014-03-07 20:03:18 +0000622 std::unique_ptr<llvm::raw_fd_ostream> OS;
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000623 std::string OSFile;
624
Rafael Espindola73c23a72013-06-27 18:26:26 +0000625 if (UseTemporary) {
626 if (OutFile == "-")
627 UseTemporary = false;
628 else {
629 llvm::sys::fs::file_status Status;
630 llvm::sys::fs::status(OutputPath, Status);
631 if (llvm::sys::fs::exists(Status)) {
632 // Fail early if we can't write to the final destination.
633 if (!llvm::sys::fs::can_write(OutputPath))
Craig Topper49a27902014-05-22 04:46:25 +0000634 return nullptr;
Rafael Espindola73c23a72013-06-27 18:26:26 +0000635
636 // Don't use a temporary if the output is a special file. This handles
637 // things like '-o /dev/null'
638 if (!llvm::sys::fs::is_regular_file(Status))
639 UseTemporary = false;
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000640 }
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000641 }
642 }
643
Rafael Espindola73c23a72013-06-27 18:26:26 +0000644 if (UseTemporary) {
Rafael Espindola73c23a72013-06-27 18:26:26 +0000645 // Create a temporary file.
646 SmallString<128> TempPath;
647 TempPath = OutFile;
648 TempPath += "-%%%%%%%%";
649 int fd;
Rafael Espindolac0809172014-06-12 14:02:15 +0000650 std::error_code EC =
Yaron Keren92e1b622015-03-18 10:17:07 +0000651 llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
Rafael Espindola157f34b2013-06-28 03:49:04 +0000652
653 if (CreateMissingDirectories &&
Rafael Espindola71de0b62014-06-13 17:20:50 +0000654 EC == llvm::errc::no_such_file_or_directory) {
Rafael Espindola157f34b2013-06-28 03:49:04 +0000655 StringRef Parent = llvm::sys::path::parent_path(OutputPath);
656 EC = llvm::sys::fs::create_directories(Parent);
657 if (!EC) {
Yaron Keren92e1b622015-03-18 10:17:07 +0000658 EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
Rafael Espindola157f34b2013-06-28 03:49:04 +0000659 }
660 }
661
662 if (!EC) {
NAKAMURA Takumi69f35282014-08-11 06:53:11 +0000663 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
Rafael Espindola73c23a72013-06-27 18:26:26 +0000664 OSFile = TempFile = TempPath.str();
665 }
666 // If we failed to create the temporary, fallback to writing to the file
667 // directly. This handles the corner case where we cannot write to the
668 // directory, but can write to the file.
669 }
670
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000671 if (!OS) {
672 OSFile = OutFile;
NAKAMURA Takumi69f35282014-08-11 06:53:11 +0000673 OS.reset(new llvm::raw_fd_ostream(
Rafael Espindoladae941a2014-08-25 18:17:04 +0000674 OSFile, Error,
NAKAMURA Takumi69f35282014-08-11 06:53:11 +0000675 (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text)));
Rafael Espindoladae941a2014-08-25 18:17:04 +0000676 if (Error)
Craig Topper49a27902014-05-22 04:46:25 +0000677 return nullptr;
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000678 }
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000679
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000680 // Make sure the out stream file gets removed if we crash.
Daniel Dunbare326f9b2011-01-31 22:00:42 +0000681 if (RemoveFileOnSignal)
Rafael Espindola18556de2013-06-13 21:02:40 +0000682 llvm::sys::RemoveFileOnSignal(OSFile);
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000683
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000684 if (ResultPathName)
685 *ResultPathName = OutFile;
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000686 if (TempPathName)
687 *TempPathName = TempFile;
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000688
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000689 if (!Binary || OS->supportsSeeking())
690 return std::move(OS);
691
692 auto B = llvm::make_unique<llvm::buffer_ostream>(*OS);
693 assert(!NonSeekStream);
694 NonSeekStream = std::move(OS);
695 return std::move(B);
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000696}
Daniel Dunbar409e8902009-11-14 07:53:04 +0000697
698// Initialization Utilities
699
Argyrios Kyrtzidis1b3240b2012-11-09 19:40:33 +0000700bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
701 return InitializeSourceManager(Input, getDiagnostics(),
Douglas Gregora686e1b2012-01-27 19:52:33 +0000702 getFileManager(), getSourceManager(),
703 getFrontendOpts());
Daniel Dunbar409e8902009-11-14 07:53:04 +0000704}
705
Argyrios Kyrtzidis1b3240b2012-11-09 19:40:33 +0000706bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input,
David Blaikie9c902b52011-09-25 23:23:43 +0000707 DiagnosticsEngine &Diags,
Daniel Dunbar409e8902009-11-14 07:53:04 +0000708 FileManager &FileMgr,
709 SourceManager &SourceMgr,
710 const FrontendOptions &Opts) {
Argyrios Kyrtzidis1b3240b2012-11-09 19:40:33 +0000711 SrcMgr::CharacteristicKind
Argyrios Kyrtzidis873c8582012-11-09 19:40:39 +0000712 Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
Argyrios Kyrtzidis1b3240b2012-11-09 19:40:33 +0000713
Argyrios Kyrtzidis6566e232012-11-09 19:40:45 +0000714 if (Input.isBuffer()) {
David Blaikie50a5f972014-08-29 07:59:55 +0000715 SourceMgr.setMainFileID(SourceMgr.createFileID(
716 std::unique_ptr<llvm::MemoryBuffer>(Input.getBuffer()), Kind));
Argyrios Kyrtzidis6566e232012-11-09 19:40:45 +0000717 assert(!SourceMgr.getMainFileID().isInvalid() &&
718 "Couldn't establish MainFileID!");
719 return true;
720 }
721
722 StringRef InputFile = Input.getFile();
723
Argyrios Kyrtzidis7c06d862011-09-19 20:40:35 +0000724 // Figure out where to get and map in the main file.
725 if (InputFile != "-") {
Benjamin Kramer3841fa32013-08-12 13:46:52 +0000726 const FileEntry *File = FileMgr.getFile(InputFile, /*OpenFile=*/true);
Dan Gohman52765212010-10-26 21:13:51 +0000727 if (!File) {
Daniel Dunbar409e8902009-11-14 07:53:04 +0000728 Diags.Report(diag::err_fe_error_reading) << InputFile;
729 return false;
730 }
Daniel Dunbare2951f42012-11-05 22:53:33 +0000731
732 // The natural SourceManager infrastructure can't currently handle named
733 // pipes, but we would at least like to accept them for the main
Benjamin Kramer3841fa32013-08-12 13:46:52 +0000734 // file. Detect them here, read them with the volatile flag so FileMgr will
735 // pick up the correct size, and simply override their contents as we do for
736 // STDIN.
Daniel Dunbare2951f42012-11-05 22:53:33 +0000737 if (File->isNamedPipe()) {
Benjamin Kramera8857962014-10-26 22:44:13 +0000738 auto MB = FileMgr.getBufferForFile(File, /*isVolatile=*/true);
739 if (MB) {
Benjamin Kramer3841fa32013-08-12 13:46:52 +0000740 // Create a new virtual file that will have the correct size.
Benjamin Kramera8857962014-10-26 22:44:13 +0000741 File = FileMgr.getVirtualFile(InputFile, (*MB)->getBufferSize(), 0);
742 SourceMgr.overrideFileContents(File, std::move(*MB));
Benjamin Kramer3841fa32013-08-12 13:46:52 +0000743 } else {
Benjamin Kramera8857962014-10-26 22:44:13 +0000744 Diags.Report(diag::err_cannot_open_file) << InputFile
745 << MB.getError().message();
Daniel Dunbare2951f42012-11-05 22:53:33 +0000746 return false;
747 }
Daniel Dunbare2951f42012-11-05 22:53:33 +0000748 }
Daniel Dunbardb0745a2012-11-27 00:04:16 +0000749
Alp Tokerb671e342014-05-21 01:12:41 +0000750 SourceMgr.setMainFileID(
751 SourceMgr.createFileID(File, SourceLocation(), Kind));
Daniel Dunbar409e8902009-11-14 07:53:04 +0000752 } else {
Rafael Espindola2d2b4202014-07-06 17:43:24 +0000753 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> SBOrErr =
754 llvm::MemoryBuffer::getSTDIN();
755 if (std::error_code EC = SBOrErr.getError()) {
756 Diags.Report(diag::err_fe_error_reading_stdin) << EC.message();
Daniel Dunbar409e8902009-11-14 07:53:04 +0000757 return false;
758 }
Rafael Espindola2d2b4202014-07-06 17:43:24 +0000759 std::unique_ptr<llvm::MemoryBuffer> SB = std::move(SBOrErr.get());
760
Dan Gohman2f76cd72010-10-26 23:21:25 +0000761 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
Chris Lattner5159f612010-11-23 08:35:12 +0000762 SB->getBufferSize(), 0);
Alp Tokerb671e342014-05-21 01:12:41 +0000763 SourceMgr.setMainFileID(
764 SourceMgr.createFileID(File, SourceLocation(), Kind));
David Blaikie49cc3182014-08-27 20:54:45 +0000765 SourceMgr.overrideFileContents(File, std::move(SB));
Daniel Dunbar409e8902009-11-14 07:53:04 +0000766 }
767
Dan Gohman52765212010-10-26 21:13:51 +0000768 assert(!SourceMgr.getMainFileID().isInvalid() &&
769 "Couldn't establish MainFileID!");
Daniel Dunbar409e8902009-11-14 07:53:04 +0000770 return true;
771}
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000772
773// High-Level Operations
774
775bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
776 assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
777 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
778 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
779
780 // FIXME: Take this as an argument, once all the APIs we used have moved to
781 // taking it as an input instead of hard-coding llvm::errs.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000782 raw_ostream &OS = llvm::errs();
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000783
784 // Create the target instance.
Alp Toker80758082014-07-06 05:26:44 +0000785 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(),
786 getInvocation().TargetOpts));
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000787 if (!hasTarget())
788 return false;
789
790 // Inform the target of the language options.
791 //
792 // FIXME: We shouldn't need to do this, the target should be immutable once
793 // created. This complexity should be lifted elsewhere.
Alp Toker74437972014-07-06 05:14:24 +0000794 getTarget().adjust(getLangOpts());
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000795
Fariborz Jahanian29898f42012-04-16 21:03:30 +0000796 // rewriter project will change target built-in bool type from its default.
797 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
798 getTarget().noSignedCharForObjCBool();
799
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000800 // Validate/process some options.
801 if (getHeaderSearchOpts().Verbose)
802 OS << "clang -cc1 version " CLANG_VERSION_STRING
Alp Tokerf988d002014-06-06 10:36:22 +0000803 << " based upon " << BACKEND_PACKAGE_STRING
Sebastian Pop8188c8a2011-11-01 21:33:06 +0000804 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000805
806 if (getFrontendOpts().ShowTimers)
807 createFrontendTimer();
808
Douglas Gregor171b7802010-03-30 17:33:59 +0000809 if (getFrontendOpts().ShowStats)
810 llvm::EnableStatistics();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000811
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000812 for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) {
Ted Kremenekeeccb302014-08-27 15:14:15 +0000813 // Reset the ID tables if we are reusing the SourceManager and parsing
814 // regular files.
815 if (hasSourceManager() && !Act.isModelParsingAction())
Daniel Dunbaraed46fc2010-06-07 23:23:50 +0000816 getSourceManager().clearIDTables();
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000817
Douglas Gregor32fbe312012-01-20 16:28:04 +0000818 if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) {
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000819 Act.Execute();
820 Act.EndSourceFile();
821 }
822 }
823
Argyrios Kyrtzidis7910d7b2011-12-07 05:52:12 +0000824 // Notify the diagnostic client that all files were processed.
825 getDiagnostics().getClient()->finish();
826
Chris Lattner198cb4d2010-04-07 18:47:42 +0000827 if (getDiagnosticOpts().ShowCarets) {
Argyrios Kyrtzidisc79346a2010-11-18 20:06:46 +0000828 // We can have multiple diagnostics sharing one diagnostic client.
829 // Get the total number of warnings/errors from the client.
830 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
831 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000832
Chris Lattner198cb4d2010-04-07 18:47:42 +0000833 if (NumWarnings)
834 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
835 if (NumWarnings && NumErrors)
836 OS << " and ";
837 if (NumErrors)
838 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
839 if (NumWarnings || NumErrors)
840 OS << " generated.\n";
841 }
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000842
Daniel Dunbaraed46fc2010-06-07 23:23:50 +0000843 if (getFrontendOpts().ShowStats && hasFileManager()) {
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000844 getFileManager().PrintStats();
845 OS << "\n";
846 }
847
Argyrios Kyrtzidisbc467932010-11-18 21:13:57 +0000848 return !getDiagnostics().getClient()->getNumErrors();
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000849}
850
Douglas Gregorfaeb1d42011-09-12 23:31:24 +0000851/// \brief Determine the appropriate source input kind based on language
852/// options.
853static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
854 if (LangOpts.OpenCL)
855 return IK_OpenCL;
856 if (LangOpts.CUDA)
857 return IK_CUDA;
858 if (LangOpts.ObjC1)
859 return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
860 return LangOpts.CPlusPlus? IK_CXX : IK_C;
861}
862
Douglas Gregor514b6362011-11-29 19:06:37 +0000863/// \brief Compile a module file for the given module, using the options
Ben Langmuirb797d592014-07-19 16:29:28 +0000864/// provided by the importing compiler instance. Returns true if the module
865/// was built without errors.
866static bool compileModuleImpl(CompilerInstance &ImportingInstance,
867 SourceLocation ImportLoc,
868 Module *Module,
869 StringRef ModuleFileName) {
Douglas Gregor514b6362011-11-29 19:06:37 +0000870 ModuleMap &ModMap
871 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
872
Douglas Gregorfaeb1d42011-09-12 23:31:24 +0000873 // Construct a compiler invocation for creating this module.
Dylan Noblesmithc95d8192012-02-20 14:00:23 +0000874 IntrusiveRefCntPtr<CompilerInvocation> Invocation
Douglas Gregorfaeb1d42011-09-12 23:31:24 +0000875 (new CompilerInvocation(ImportingInstance.getInvocation()));
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000876
Douglas Gregorf545f672011-11-29 21:59:16 +0000877 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
878
Douglas Gregor44bf68d2011-09-15 20:53:28 +0000879 // For any options that aren't intended to affect how a module is built,
880 // reset them to their default values.
Ted Kremenek8cf47df2011-11-17 23:01:24 +0000881 Invocation->getLangOpts()->resetNonModularOptions();
Douglas Gregorf545f672011-11-29 21:59:16 +0000882 PPOpts.resetNonModularOptions();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000883
Douglas Gregor5dc38992013-02-07 00:21:12 +0000884 // Remove any macro definitions that are explicitly ignored by the module.
885 // They aren't supposed to affect how the module is built anyway.
886 const HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
Benjamin Kramerbbdd7642014-03-01 14:48:57 +0000887 PPOpts.Macros.erase(
888 std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
889 [&HSOpts](const std::pair<std::string, bool> &def) {
890 StringRef MacroDef = def.first;
891 return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0;
892 }),
893 PPOpts.Macros.end());
Douglas Gregor5dc38992013-02-07 00:21:12 +0000894
Douglas Gregor7d106e42011-11-15 19:35:01 +0000895 // Note the name of the module we're building.
Douglas Gregor6dc57922011-11-29 18:31:39 +0000896 Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
Douglas Gregor7d106e42011-11-15 19:35:01 +0000897
Douglas Gregor7a626572012-11-29 23:55:25 +0000898 // Make sure that the failed-module structure has been allocated in
899 // the importing instance, and propagate the pointer to the newly-created
900 // instance.
901 PreprocessorOptions &ImportingPPOpts
902 = ImportingInstance.getInvocation().getPreprocessorOpts();
903 if (!ImportingPPOpts.FailedModules)
904 ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet;
905 PPOpts.FailedModules = ImportingPPOpts.FailedModules;
906
Douglas Gregorf545f672011-11-29 21:59:16 +0000907 // If there is a module map file, build the module using the module map.
Douglas Gregor44bf68d2011-09-15 20:53:28 +0000908 // Set up the inputs/outputs so that we build the module from its umbrella
909 // header.
Douglas Gregorfaeb1d42011-09-12 23:31:24 +0000910 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
Douglas Gregor1735f4e2011-09-13 23:15:45 +0000911 FrontendOpts.OutputFile = ModuleFileName.str();
Douglas Gregorfaeb1d42011-09-12 23:31:24 +0000912 FrontendOpts.DisableFree = false;
Douglas Gregorc1bbec82013-01-25 00:45:27 +0000913 FrontendOpts.GenerateGlobalModuleIndex = false;
Douglas Gregorfaeb1d42011-09-12 23:31:24 +0000914 FrontendOpts.Inputs.clear();
Douglas Gregorf545f672011-11-29 21:59:16 +0000915 InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000916
Douglas Gregorf545f672011-11-29 21:59:16 +0000917 // Don't free the remapped file buffers; they are owned by our caller.
918 PPOpts.RetainRemappedFileBuffers = true;
919
Douglas Gregor2b9b4642011-09-13 01:26:44 +0000920 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
Douglas Gregor3728ea72011-09-13 23:20:27 +0000921 assert(ImportingInstance.getInvocation().getModuleHash() ==
Douglas Gregorf545f672011-11-29 21:59:16 +0000922 Invocation->getModuleHash() && "Module hash mismatch!");
923
Douglas Gregorfaeb1d42011-09-12 23:31:24 +0000924 // Construct a compiler instance that will be used to actually create the
925 // module.
Adrian Prantlbb165fb2015-06-20 18:53:08 +0000926 CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
927 /*BuildingModule=*/true);
Douglas Gregorfaeb1d42011-09-12 23:31:24 +0000928 Instance.setInvocation(&*Invocation);
Douglas Gregor6b930962013-05-03 22:58:43 +0000929
930 Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
931 ImportingInstance.getDiagnosticClient()),
Douglas Gregor30071cea2013-05-03 23:07:45 +0000932 /*ShouldOwnClient=*/true);
Douglas Gregoraf8f0262012-11-30 18:38:50 +0000933
Ben Langmuirc8130a72014-02-20 21:59:23 +0000934 Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
935
Douglas Gregor63365432012-11-30 22:11:57 +0000936 // Note that this module is part of the module build stack, so that we
Douglas Gregoraf8f0262012-11-30 18:38:50 +0000937 // can detect cycles in the module graph.
Ben Langmuird066d4c2014-02-28 21:16:07 +0000938 Instance.setFileManager(&ImportingInstance.getFileManager());
Douglas Gregoraf8f0262012-11-30 18:38:50 +0000939 Instance.createSourceManager(Instance.getFileManager());
940 SourceManager &SourceMgr = Instance.getSourceManager();
Douglas Gregor63365432012-11-30 22:11:57 +0000941 SourceMgr.setModuleBuildStack(
942 ImportingInstance.getSourceManager().getModuleBuildStack());
943 SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(),
Douglas Gregoraf8f0262012-11-30 18:38:50 +0000944 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
945
Justin Bogner86d12592014-06-19 19:36:03 +0000946 // If we're collecting module dependencies, we need to share a collector
Richard Smith38c1e6d2015-08-09 06:03:55 +0000947 // between all of the module CompilerInstances. Other than that, we don't
948 // want to produce any dependency output from the module build.
Justin Bogner86d12592014-06-19 19:36:03 +0000949 Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
Richard Smith38c1e6d2015-08-09 06:03:55 +0000950 Invocation->getDependencyOutputOpts() = DependencyOutputOptions();
Justin Bogner86d12592014-06-19 19:36:03 +0000951
Manuel Klimek1f76c4e2013-10-24 07:51:24 +0000952 // Get or create the module map that we'll use to build this module.
953 std::string InferredModuleMapContent;
954 if (const FileEntry *ModuleMapFile =
955 ModMap.getContainingModuleMapFile(Module)) {
956 // Use the module map where this module resides.
Benjamin Kramer3204b152015-05-29 19:42:19 +0000957 FrontendOpts.Inputs.emplace_back(ModuleMapFile->getName(), IK);
Manuel Klimek1f76c4e2013-10-24 07:51:24 +0000958 } else {
Richard Smith2b63d152015-05-16 02:28:53 +0000959 SmallString<128> FakeModuleMapFile(Module->Directory->getName());
960 llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map");
Benjamin Kramer3204b152015-05-29 19:42:19 +0000961 FrontendOpts.Inputs.emplace_back(FakeModuleMapFile, IK);
Richard Smith2b63d152015-05-16 02:28:53 +0000962
Manuel Klimek1f76c4e2013-10-24 07:51:24 +0000963 llvm::raw_string_ostream OS(InferredModuleMapContent);
964 Module->print(OS);
965 OS.flush();
Manuel Klimek1f76c4e2013-10-24 07:51:24 +0000966
Rafael Espindolad87f8d72014-08-27 20:03:29 +0000967 std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
Manuel Klimek1f76c4e2013-10-24 07:51:24 +0000968 llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
969 ModuleMapFile = Instance.getFileManager().getVirtualFile(
Richard Smith2b63d152015-05-16 02:28:53 +0000970 FakeModuleMapFile, InferredModuleMapContent.size(), 0);
David Blaikie49cc3182014-08-27 20:54:45 +0000971 SourceMgr.overrideFileContents(ModuleMapFile, std::move(ModuleMapBuffer));
Manuel Klimek1f76c4e2013-10-24 07:51:24 +0000972 }
Douglas Gregoraf8f0262012-11-30 18:38:50 +0000973
Ben Langmuir9d6448b2014-08-09 00:57:23 +0000974 // Construct a module-generating action. Passing through the module map is
Ben Langmuirbeee15e2014-04-14 18:00:01 +0000975 // safe because the FileManager is shared between the compiler instances.
Ben Langmuir9d6448b2014-08-09 00:57:23 +0000976 GenerateModuleAction CreateModuleAction(
977 ModMap.getModuleMapFileForUniquing(Module), Module->IsSystem);
Richard Smith99891da2014-10-14 02:08:30 +0000978
979 ImportingInstance.getDiagnostics().Report(ImportLoc,
980 diag::remark_module_build)
981 << Module->Name << ModuleFileName;
982
Douglas Gregor51e0b542011-10-04 00:21:21 +0000983 // Execute the action to actually build the module in-place. Use a separate
984 // thread so that we get a stack large enough.
985 const unsigned ThreadStackSize = 8 << 20;
986 llvm::CrashRecoveryContext CRC;
Richard Smith841f1c72014-03-04 21:50:01 +0000987 CRC.RunSafelyOnThread([&]() { Instance.ExecuteAction(CreateModuleAction); },
988 ThreadStackSize);
Douglas Gregor6b930962013-05-03 22:58:43 +0000989
Richard Smith99891da2014-10-14 02:08:30 +0000990 ImportingInstance.getDiagnostics().Report(ImportLoc,
991 diag::remark_module_build_done)
992 << Module->Name;
993
Douglas Gregorf545f672011-11-29 21:59:16 +0000994 // Delete the temporary module map file.
995 // FIXME: Even though we're executing under crash protection, it would still
996 // be nice to do this with RemoveFileOnSignal when we can. However, that
997 // doesn't make sense for all clients, so clean this up manually.
Benjamin Kramer13afbf42012-10-14 19:50:53 +0000998 Instance.clearOutputFiles(/*EraseFiles=*/true);
Douglas Gregor5e306b12013-01-23 22:38:11 +0000999
1000 // We've rebuilt a module. If we're allowed to generate or update the global
1001 // module index, record that fact in the importing compiler instance.
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001002 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
Douglas Gregor5e306b12013-01-23 22:38:11 +00001003 ImportingInstance.setBuildGlobalModuleIndex(true);
1004 }
Ben Langmuirb797d592014-07-19 16:29:28 +00001005
1006 return !Instance.getDiagnostics().hasErrorOccurred();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001007}
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001008
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001009static bool compileAndLoadModule(CompilerInstance &ImportingInstance,
1010 SourceLocation ImportLoc,
Ben Langmuirb797d592014-07-19 16:29:28 +00001011 SourceLocation ModuleNameLoc, Module *Module,
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001012 StringRef ModuleFileName) {
Ben Langmuird213aab2014-09-26 22:42:23 +00001013 DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1014
Ben Langmuirb797d592014-07-19 16:29:28 +00001015 auto diagnoseBuildFailure = [&] {
Ben Langmuird213aab2014-09-26 22:42:23 +00001016 Diags.Report(ModuleNameLoc, diag::err_module_not_built)
Ben Langmuirb797d592014-07-19 16:29:28 +00001017 << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1018 };
1019
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001020 // FIXME: have LockFileManager return an error_code so that we can
1021 // avoid the mkdir when the directory already exists.
1022 StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
1023 llvm::sys::fs::create_directories(Dir);
1024
1025 while (1) {
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001026 unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001027 llvm::LockFileManager Locked(ModuleFileName);
1028 switch (Locked) {
1029 case llvm::LockFileManager::LFS_Error:
Ben Langmuird213aab2014-09-26 22:42:23 +00001030 Diags.Report(ModuleNameLoc, diag::err_module_lock_failure)
1031 << Module->Name;
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001032 return false;
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001033
1034 case llvm::LockFileManager::LFS_Owned:
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001035 // We're responsible for building the module ourselves.
Ben Langmuirb797d592014-07-19 16:29:28 +00001036 if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
1037 ModuleFileName)) {
1038 diagnoseBuildFailure();
1039 return false;
1040 }
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001041 break;
1042
1043 case llvm::LockFileManager::LFS_Shared:
1044 // Someone else is responsible for building the module. Wait for them to
1045 // finish.
Ben Langmuir1daf4802015-02-09 20:35:13 +00001046 switch (Locked.waitForUnlock()) {
1047 case llvm::LockFileManager::Res_Success:
1048 ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1049 break;
1050 case llvm::LockFileManager::Res_OwnerDied:
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001051 continue; // try again to get the lock.
Ben Langmuir1daf4802015-02-09 20:35:13 +00001052 case llvm::LockFileManager::Res_Timeout:
1053 Diags.Report(ModuleNameLoc, diag::err_module_lock_timeout)
1054 << Module->Name;
1055 // Clear the lock file so that future invokations can make progress.
1056 Locked.unsafeRemoveLockFile();
1057 return false;
1058 }
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001059 break;
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001060 }
1061
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001062 // Try to read the module file, now that we've compiled it.
1063 ASTReader::ASTReadResult ReadResult =
1064 ImportingInstance.getModuleManager()->ReadAST(
Richard Smithe842a472014-10-22 02:05:46 +00001065 ModuleFileName, serialization::MK_ImplicitModule, ImportLoc,
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001066 ModuleLoadCapabilities);
1067
1068 if (ReadResult == ASTReader::OutOfDate &&
1069 Locked == llvm::LockFileManager::LFS_Shared) {
1070 // The module may be out of date in the presence of file system races,
1071 // or if one of its imports depends on header search paths that are not
1072 // consistent with this ImportingInstance. Try again...
1073 continue;
1074 } else if (ReadResult == ASTReader::Missing) {
Ben Langmuirb797d592014-07-19 16:29:28 +00001075 diagnoseBuildFailure();
Ben Langmuird213aab2014-09-26 22:42:23 +00001076 } else if (ReadResult != ASTReader::Success &&
1077 !Diags.hasErrorOccurred()) {
1078 // The ASTReader didn't diagnose the error, so conservatively report it.
1079 diagnoseBuildFailure();
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001080 }
1081 return ReadResult == ASTReader::Success;
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001082 }
1083}
1084
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001085/// \brief Diagnose differences between the current definition of the given
1086/// configuration macro and the definition provided on the command line.
1087static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1088 Module *Mod, SourceLocation ImportLoc) {
1089 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
1090 SourceManager &SourceMgr = PP.getSourceManager();
1091
1092 // If this identifier has never had a macro definition, then it could
1093 // not have changed.
1094 if (!Id->hadMacroDefinition())
1095 return;
Richard Smith20e883e2015-04-29 23:20:19 +00001096 auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id);
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001097
Richard Smith20e883e2015-04-29 23:20:19 +00001098 // Find the macro definition from the command line.
1099 MacroInfo *CmdLineDefinition = nullptr;
1100 for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001101 // We only care about the predefines buffer.
Richard Smith20e883e2015-04-29 23:20:19 +00001102 FileID FID = SourceMgr.getFileID(MD->getLocation());
1103 if (FID.isInvalid() || FID != PP.getPredefinesFileID())
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001104 continue;
Richard Smith20e883e2015-04-29 23:20:19 +00001105 if (auto *DMD = dyn_cast<DefMacroDirective>(MD))
1106 CmdLineDefinition = DMD->getMacroInfo();
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001107 break;
1108 }
1109
Richard Smith20e883e2015-04-29 23:20:19 +00001110 auto *CurrentDefinition = PP.getMacroInfo(Id);
1111 if (CurrentDefinition == CmdLineDefinition) {
1112 // Macro matches. Nothing to do.
1113 } else if (!CurrentDefinition) {
1114 // This macro was defined on the command line, then #undef'd later.
1115 // Complain.
1116 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1117 << true << ConfigMacro << Mod->getFullModuleName();
1118 auto LatestDef = LatestLocalMD->getDefinition();
1119 assert(LatestDef.isUndefined() &&
1120 "predefined macro went away with no #undef?");
1121 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1122 << true;
1123 return;
1124 } else if (!CmdLineDefinition) {
1125 // There was no definition for this macro in the predefines buffer,
1126 // but there was a local definition. Complain.
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001127 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1128 << false << ConfigMacro << Mod->getFullModuleName();
Richard Smith20e883e2015-04-29 23:20:19 +00001129 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1130 diag::note_module_def_undef_here)
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001131 << false;
Richard Smith20e883e2015-04-29 23:20:19 +00001132 } else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,
1133 /*Syntactically=*/true)) {
1134 // The macro definitions differ.
1135 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1136 << false << ConfigMacro << Mod->getFullModuleName();
1137 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1138 diag::note_module_def_undef_here)
1139 << false;
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001140 }
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001141}
1142
Douglas Gregor527b1c92013-03-25 21:19:16 +00001143/// \brief Write a new timestamp file with the given path.
1144static void writeTimestampFile(StringRef TimestampFile) {
Rafael Espindoladae941a2014-08-25 18:17:04 +00001145 std::error_code EC;
1146 llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None);
Douglas Gregor527b1c92013-03-25 21:19:16 +00001147}
1148
1149/// \brief Prune the module cache of modules that haven't been accessed in
1150/// a long time.
1151static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1152 struct stat StatBuf;
1153 llvm::SmallString<128> TimestampFile;
1154 TimestampFile = HSOpts.ModuleCachePath;
1155 llvm::sys::path::append(TimestampFile, "modules.timestamp");
1156
1157 // Try to stat() the timestamp file.
1158 if (::stat(TimestampFile.c_str(), &StatBuf)) {
1159 // If the timestamp file wasn't there, create one now.
1160 if (errno == ENOENT) {
1161 writeTimestampFile(TimestampFile);
1162 }
1163 return;
1164 }
1165
1166 // Check whether the time stamp is older than our pruning interval.
1167 // If not, do nothing.
1168 time_t TimeStampModTime = StatBuf.st_mtime;
Craig Topper49a27902014-05-22 04:46:25 +00001169 time_t CurrentTime = time(nullptr);
Benjamin Kramerdbcf5032013-03-29 17:39:43 +00001170 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
Douglas Gregor527b1c92013-03-25 21:19:16 +00001171 return;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001172
1173 // Write a new timestamp file so that nobody else attempts to prune.
1174 // There is a benign race condition here, if two Clang instances happen to
1175 // notice at the same time that the timestamp is out-of-date.
1176 writeTimestampFile(TimestampFile);
1177
1178 // Walk the entire module cache, looking for unused module files and module
1179 // indices.
Rafael Espindolac0809172014-06-12 14:02:15 +00001180 std::error_code EC;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001181 SmallString<128> ModuleCachePathNative;
1182 llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
Yaron Keren92e1b622015-03-18 10:17:07 +00001183 for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001184 Dir != DirEnd && !EC; Dir.increment(EC)) {
1185 // If we don't have a directory, there's nothing to look into.
Rafael Espindolaa07f7202013-07-17 04:23:07 +00001186 if (!llvm::sys::fs::is_directory(Dir->path()))
Douglas Gregor527b1c92013-03-25 21:19:16 +00001187 continue;
1188
1189 // Walk all of the files within this directory.
Douglas Gregor527b1c92013-03-25 21:19:16 +00001190 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1191 File != FileEnd && !EC; File.increment(EC)) {
1192 // We only care about module and global module index files.
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001193 StringRef Extension = llvm::sys::path::extension(File->path());
1194 if (Extension != ".pcm" && Extension != ".timestamp" &&
1195 llvm::sys::path::filename(File->path()) != "modules.idx")
Douglas Gregor527b1c92013-03-25 21:19:16 +00001196 continue;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001197
1198 // Look at this file. If we can't stat it, there's nothing interesting
1199 // there.
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001200 if (::stat(File->path().c_str(), &StatBuf))
Douglas Gregor527b1c92013-03-25 21:19:16 +00001201 continue;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001202
1203 // If the file has been used recently enough, leave it there.
1204 time_t FileAccessTime = StatBuf.st_atime;
Benjamin Kramerdbcf5032013-03-29 17:39:43 +00001205 if (CurrentTime - FileAccessTime <=
1206 time_t(HSOpts.ModuleCachePruneAfter)) {
Douglas Gregor527b1c92013-03-25 21:19:16 +00001207 continue;
1208 }
1209
1210 // Remove the file.
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001211 llvm::sys::fs::remove(File->path());
1212
1213 // Remove the timestamp file.
1214 std::string TimpestampFilename = File->path() + ".timestamp";
1215 llvm::sys::fs::remove(TimpestampFilename);
Douglas Gregor527b1c92013-03-25 21:19:16 +00001216 }
1217
1218 // If we removed all of the files in the directory, remove the directory
1219 // itself.
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001220 if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1221 llvm::sys::fs::directory_iterator() && !EC)
Rafael Espindola2a008782014-01-10 21:32:14 +00001222 llvm::sys::fs::remove(Dir->path());
Douglas Gregor527b1c92013-03-25 21:19:16 +00001223 }
1224}
1225
John Thompson2255f2c2014-04-23 12:57:01 +00001226void CompilerInstance::createModuleManager() {
1227 if (!ModuleManager) {
1228 if (!hasASTContext())
1229 createASTContext();
1230
Chandler Carruth580dd292015-03-24 21:44:25 +00001231 // If we're implicitly building modules but not currently recursively
1232 // building a module, check whether we need to prune the module cache.
1233 if (getLangOpts().ImplicitModules &&
1234 getSourceManager().getModuleBuildStack().empty() &&
John Thompson2255f2c2014-04-23 12:57:01 +00001235 getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1236 getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1237 pruneModuleCache(getHeaderSearchOpts());
1238 }
1239
1240 HeaderSearchOptions &HSOpts = getHeaderSearchOpts();
1241 std::string Sysroot = HSOpts.Sysroot;
1242 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
Richard Smithce18a182015-07-14 00:26:00 +00001243 std::unique_ptr<llvm::Timer> ReadTimer;
1244 if (FrontendTimerGroup)
1245 ReadTimer = llvm::make_unique<llvm::Timer>("Reading modules",
1246 *FrontendTimerGroup);
Adrian Prantlbb165fb2015-06-20 18:53:08 +00001247 ModuleManager = new ASTReader(
Adrian Prantlfb2398d2015-07-17 01:19:54 +00001248 getPreprocessor(), *Context, getPCHContainerReader(),
Adrian Prantlbb165fb2015-06-20 18:53:08 +00001249 Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation,
1250 /*AllowASTWithCompilerErrors=*/false,
1251 /*AllowConfigurationMismatch=*/false,
1252 HSOpts.ModulesValidateSystemHeaders,
Richard Smithce18a182015-07-14 00:26:00 +00001253 getFrontendOpts().UseGlobalModuleIndex,
1254 std::move(ReadTimer));
John Thompson2255f2c2014-04-23 12:57:01 +00001255 if (hasASTConsumer()) {
1256 ModuleManager->setDeserializationListener(
1257 getASTConsumer().GetASTDeserializationListener());
1258 getASTContext().setASTMutationListener(
1259 getASTConsumer().GetASTMutationListener());
1260 }
1261 getASTContext().setExternalSource(ModuleManager);
1262 if (hasSema())
1263 ModuleManager->InitializeSema(getSema());
Richard Smith0f99d6a2015-08-09 08:48:41 +00001264 if (hasASTConsumer()) {
1265 getASTConsumer().Initialize(getASTContext());
John Thompson2255f2c2014-04-23 12:57:01 +00001266 ModuleManager->StartTranslationUnit(&getASTConsumer());
Richard Smith0f99d6a2015-08-09 08:48:41 +00001267 }
Richard Smith03f7e612015-08-09 02:28:42 +00001268
1269 if (TheDependencyFileGenerator)
1270 TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
1271 if (ModuleDepCollector)
1272 ModuleDepCollector->attachToASTReader(*ModuleManager);
1273 for (auto &Listener : DependencyCollectors)
1274 Listener->attachToASTReader(*ModuleManager);
John Thompson2255f2c2014-04-23 12:57:01 +00001275 }
1276}
1277
Richard Smithd4b230b2014-10-27 23:01:16 +00001278bool CompilerInstance::loadModuleFile(StringRef FileName) {
Richard Smithce18a182015-07-14 00:26:00 +00001279 llvm::Timer Timer;
1280 if (FrontendTimerGroup)
1281 Timer.init("Preloading " + FileName.str(), *FrontendTimerGroup);
1282 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1283
Richard Smithd4b230b2014-10-27 23:01:16 +00001284 // Helper to recursively read the module names for all modules we're adding.
1285 // We mark these as known and redirect any attempt to load that module to
1286 // the files we were handed.
1287 struct ReadModuleNames : ASTReaderListener {
1288 CompilerInstance &CI;
Richard Smith0f99d6a2015-08-09 08:48:41 +00001289 llvm::SmallVector<IdentifierInfo*, 8> LoadedModules;
Richard Smithe842a472014-10-22 02:05:46 +00001290
Richard Smith0f99d6a2015-08-09 08:48:41 +00001291 ReadModuleNames(CompilerInstance &CI) : CI(CI) {}
Richard Smithe842a472014-10-22 02:05:46 +00001292
Richard Smithd4b230b2014-10-27 23:01:16 +00001293 void ReadModuleName(StringRef ModuleName) override {
Richard Smith0f99d6a2015-08-09 08:48:41 +00001294 LoadedModules.push_back(
1295 CI.getPreprocessor().getIdentifierInfo(ModuleName));
Richard Smithd4b230b2014-10-27 23:01:16 +00001296 }
Richard Smith0f99d6a2015-08-09 08:48:41 +00001297
1298 void registerAll() {
1299 for (auto *II : LoadedModules) {
1300 CI.KnownModules[II] = CI.getPreprocessor()
1301 .getHeaderSearchInfo()
1302 .getModuleMap()
1303 .findModule(II->getName());
1304 }
1305 LoadedModules.clear();
1306 }
1307 };
Richard Smithd4b230b2014-10-27 23:01:16 +00001308
Richard Smith7f330cd2015-03-18 01:42:29 +00001309 // If we don't already have an ASTReader, create one now.
1310 if (!ModuleManager)
1311 createModuleManager();
1312
Richard Smith0f99d6a2015-08-09 08:48:41 +00001313 auto Listener = llvm::make_unique<ReadModuleNames>(*this);
1314 auto &ListenerRef = *Listener;
1315 ASTReader::ListenerScope ReadModuleNamesListener(*ModuleManager,
1316 std::move(Listener));
Richard Smith7f330cd2015-03-18 01:42:29 +00001317
Richard Smith0f99d6a2015-08-09 08:48:41 +00001318 // Try to load the module file.
1319 if (ModuleManager->ReadAST(FileName, serialization::MK_ExplicitModule,
1320 SourceLocation(), ASTReader::ARR_None)
1321 != ASTReader::Success)
Richard Smithd4b230b2014-10-27 23:01:16 +00001322 return false;
1323
Richard Smith0f99d6a2015-08-09 08:48:41 +00001324 // We successfully loaded the module file; remember the set of provided
1325 // modules so that we don't try to load implicit modules for them.
1326 ListenerRef.registerAll();
Richard Smithd4b230b2014-10-27 23:01:16 +00001327 return true;
Richard Smithe842a472014-10-22 02:05:46 +00001328}
1329
1330ModuleLoadResult
Douglas Gregor7a626572012-11-29 23:55:25 +00001331CompilerInstance::loadModule(SourceLocation ImportLoc,
1332 ModuleIdPath Path,
1333 Module::NameVisibilityKind Visibility,
1334 bool IsInclusionDirective) {
Richard Smith92304e02013-10-18 22:48:20 +00001335 // Determine what file we're searching from.
1336 StringRef ModuleName = Path[0].first->getName();
1337 SourceLocation ModuleNameLoc = Path[0].second;
1338
Douglas Gregor1805b8a2011-11-30 04:26:53 +00001339 // If we've already handled this import, just return the cached result.
1340 // This one-element cache is important to eliminate redundant diagnostics
1341 // when both the preprocessor and parser see the same import declaration.
Douglas Gregorff2be532011-12-01 17:11:21 +00001342 if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) {
1343 // Make the named module visible.
Ben Langmuirb537a3a2014-07-23 15:30:23 +00001344 if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule &&
1345 ModuleName != getLangOpts().ImplementationOfModule)
Argyrios Kyrtzidis125df052013-02-01 16:36:12 +00001346 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
Richard Smitha7e2cc62015-05-01 01:53:09 +00001347 ImportLoc);
Douglas Gregor69021972011-11-30 17:33:56 +00001348 return LastModuleImportResult;
Douglas Gregorff2be532011-12-01 17:11:21 +00001349 }
Douglas Gregor5196bc62011-11-30 04:03:44 +00001350
Craig Topper49a27902014-05-22 04:46:25 +00001351 clang::Module *Module = nullptr;
Richard Smith92304e02013-10-18 22:48:20 +00001352
Douglas Gregor5196bc62011-11-30 04:03:44 +00001353 // If we don't already have information on this module, load the module now.
Douglas Gregorde3ef502011-11-30 23:21:26 +00001354 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
Douglas Gregor69021972011-11-30 17:33:56 +00001355 = KnownModules.find(Path[0].first);
Douglas Gregor2537a362011-12-08 17:01:29 +00001356 if (Known != KnownModules.end()) {
1357 // Retrieve the cached top-level module.
1358 Module = Known->second;
Ben Langmuirb537a3a2014-07-23 15:30:23 +00001359 } else if (ModuleName == getLangOpts().CurrentModule ||
1360 ModuleName == getLangOpts().ImplementationOfModule) {
Douglas Gregor2537a362011-12-08 17:01:29 +00001361 // This is the module we're building.
Ben Langmuir527040e2014-05-05 05:31:33 +00001362 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
Douglas Gregor2537a362011-12-08 17:01:29 +00001363 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1364 } else {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001365 // Search for a module with the given name.
Douglas Gregor279a6c32012-01-29 17:08:11 +00001366 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
Ben Langmuir9eb229b2014-01-22 23:19:39 +00001367 if (!Module) {
1368 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1369 << ModuleName
1370 << SourceRange(ImportLoc, ModuleNameLoc);
1371 ModuleBuildFailed = true;
1372 return ModuleLoadResult();
1373 }
1374
Richard Smithd520a252015-07-21 18:07:47 +00001375 std::string ModuleFileName =
Richard Smith86cc8292015-08-09 08:58:36 +00001376 PP->getHeaderSearchInfo().getModuleFileName(Module);
Richard Smithd520a252015-07-21 18:07:47 +00001377 if (ModuleFileName.empty()) {
Manuel Klimekd2e8b042015-02-20 11:44:41 +00001378 getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
1379 << ModuleName;
1380 ModuleBuildFailed = true;
1381 return ModuleLoadResult();
1382 }
Richard Smithd4b230b2014-10-27 23:01:16 +00001383
Douglas Gregor5196bc62011-11-30 04:03:44 +00001384 // If we don't already have an ASTReader, create one now.
John Thompson2255f2c2014-04-23 12:57:01 +00001385 if (!ModuleManager)
1386 createModuleManager();
Douglas Gregor5196bc62011-11-30 04:03:44 +00001387
Richard Smithce18a182015-07-14 00:26:00 +00001388 llvm::Timer Timer;
1389 if (FrontendTimerGroup)
1390 Timer.init("Loading " + ModuleFileName, *FrontendTimerGroup);
1391 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1392
Douglas Gregor7029ce12013-03-19 00:28:20 +00001393 // Try to load the module file.
Richard Smith86cc8292015-08-09 08:58:36 +00001394 unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing;
Richard Smithe842a472014-10-22 02:05:46 +00001395 switch (ModuleManager->ReadAST(ModuleFileName,
Richard Smith86cc8292015-08-09 08:58:36 +00001396 serialization::MK_ImplicitModule,
Richard Smithd4b230b2014-10-27 23:01:16 +00001397 ImportLoc, ARRFlags)) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001398 case ASTReader::Success:
1399 break;
1400
Eli Friedman963ff2c2013-09-17 00:51:29 +00001401 case ASTReader::OutOfDate:
Douglas Gregor7029ce12013-03-19 00:28:20 +00001402 case ASTReader::Missing: {
Eli Friedman963ff2c2013-09-17 00:51:29 +00001403 // The module file is missing or out-of-date. Build it.
Ben Langmuir9eb229b2014-01-22 23:19:39 +00001404 assert(Module && "missing module file");
Douglas Gregor7029ce12013-03-19 00:28:20 +00001405 // Check whether there is a cycle in the module graph.
1406 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1407 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1408 for (; Pos != PosEnd; ++Pos) {
1409 if (Pos->first == ModuleName)
1410 break;
1411 }
1412
1413 if (Pos != PosEnd) {
1414 SmallString<256> CyclePath;
1415 for (; Pos != PosEnd; ++Pos) {
1416 CyclePath += Pos->first;
1417 CyclePath += " -> ";
1418 }
1419 CyclePath += ModuleName;
1420
1421 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1422 << ModuleName << CyclePath;
1423 return ModuleLoadResult();
1424 }
Douglas Gregor7a626572012-11-29 23:55:25 +00001425
1426 // Check whether we have already attempted to build this module (but
1427 // failed).
1428 if (getPreprocessorOpts().FailedModules &&
1429 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1430 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1431 << ModuleName
1432 << SourceRange(ImportLoc, ModuleNameLoc);
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001433 ModuleBuildFailed = true;
Douglas Gregor7a626572012-11-29 23:55:25 +00001434 return ModuleLoadResult();
1435 }
1436
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001437 // Try to compile and then load the module.
1438 if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module,
1439 ModuleFileName)) {
Ben Langmuird213aab2014-09-26 22:42:23 +00001440 assert(getDiagnostics().hasErrorOccurred() &&
1441 "undiagnosed error in compileAndLoadModule");
Douglas Gregor0f2b4632013-01-10 02:04:18 +00001442 if (getPreprocessorOpts().FailedModules)
1443 getPreprocessorOpts().FailedModules->addFailed(ModuleName);
Craig Topper49a27902014-05-22 04:46:25 +00001444 KnownModules[Path[0].first] = nullptr;
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001445 ModuleBuildFailed = true;
Douglas Gregor7a626572012-11-29 23:55:25 +00001446 return ModuleLoadResult();
Douglas Gregor188dbef2012-11-07 17:46:15 +00001447 }
1448
1449 // Okay, we've rebuilt and now loaded the module.
1450 break;
1451 }
1452
Douglas Gregorc9ad5fb2012-10-22 22:50:17 +00001453 case ASTReader::VersionMismatch:
1454 case ASTReader::ConfigurationMismatch:
1455 case ASTReader::HadErrors:
Argyrios Kyrtzidisdc9fdaf2013-05-24 05:44:08 +00001456 ModuleLoader::HadFatalFailure = true;
Richard Smith0f99d6a2015-08-09 08:48:41 +00001457 // FIXME: The ASTReader will already have complained, but can we shoehorn
Douglas Gregor5196bc62011-11-30 04:03:44 +00001458 // that diagnostic information into a more useful form?
Craig Topper49a27902014-05-22 04:46:25 +00001459 KnownModules[Path[0].first] = nullptr;
Douglas Gregor7a626572012-11-29 23:55:25 +00001460 return ModuleLoadResult();
Douglas Gregor5196bc62011-11-30 04:03:44 +00001461
1462 case ASTReader::Failure:
Argyrios Kyrtzidisdc9fdaf2013-05-24 05:44:08 +00001463 ModuleLoader::HadFatalFailure = true;
Douglas Gregor69021972011-11-30 17:33:56 +00001464 // Already complained, but note now that we failed.
Craig Topper49a27902014-05-22 04:46:25 +00001465 KnownModules[Path[0].first] = nullptr;
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001466 ModuleBuildFailed = true;
Douglas Gregor7a626572012-11-29 23:55:25 +00001467 return ModuleLoadResult();
Douglas Gregor5196bc62011-11-30 04:03:44 +00001468 }
Argyrios Kyrtzidis43af5132012-09-29 01:06:04 +00001469
Douglas Gregor69021972011-11-30 17:33:56 +00001470 // Cache the result of this top-level module lookup for later.
1471 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
Douglas Gregor08142532011-08-26 23:56:07 +00001472 }
Douglas Gregor5196bc62011-11-30 04:03:44 +00001473
Douglas Gregor69021972011-11-30 17:33:56 +00001474 // If we never found the module, fail.
1475 if (!Module)
Douglas Gregor7a626572012-11-29 23:55:25 +00001476 return ModuleLoadResult();
Douglas Gregor69021972011-11-30 17:33:56 +00001477
Douglas Gregor5196bc62011-11-30 04:03:44 +00001478 // Verify that the rest of the module path actually corresponds to
1479 // a submodule.
Douglas Gregor69021972011-11-30 17:33:56 +00001480 if (Path.size() > 1) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001481 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1482 StringRef Name = Path[I].first->getName();
Douglas Gregoreb90e832012-01-04 23:32:19 +00001483 clang::Module *Sub = Module->findSubmodule(Name);
Douglas Gregor5196bc62011-11-30 04:03:44 +00001484
Douglas Gregoreb90e832012-01-04 23:32:19 +00001485 if (!Sub) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001486 // Attempt to perform typo correction to find a module name that works.
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001487 SmallVector<StringRef, 2> Best;
Douglas Gregor5196bc62011-11-30 04:03:44 +00001488 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1489
Douglas Gregoreb90e832012-01-04 23:32:19 +00001490 for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1491 JEnd = Module->submodule_end();
Matt Beaumont-Gayeb44eda2011-11-30 19:41:21 +00001492 J != JEnd; ++J) {
Douglas Gregoreb90e832012-01-04 23:32:19 +00001493 unsigned ED = Name.edit_distance((*J)->Name,
Douglas Gregor5196bc62011-11-30 04:03:44 +00001494 /*AllowReplacements=*/true,
1495 BestEditDistance);
1496 if (ED <= BestEditDistance) {
Douglas Gregoreb90e832012-01-04 23:32:19 +00001497 if (ED < BestEditDistance) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001498 Best.clear();
Douglas Gregoreb90e832012-01-04 23:32:19 +00001499 BestEditDistance = ED;
1500 }
1501
1502 Best.push_back((*J)->Name);
Douglas Gregor5196bc62011-11-30 04:03:44 +00001503 }
1504 }
1505
1506 // If there was a clear winner, user it.
1507 if (Best.size() == 1) {
1508 getDiagnostics().Report(Path[I].second,
1509 diag::err_no_submodule_suggest)
Douglas Gregor69021972011-11-30 17:33:56 +00001510 << Path[I].first << Module->getFullModuleName() << Best[0]
Douglas Gregor5196bc62011-11-30 04:03:44 +00001511 << SourceRange(Path[0].second, Path[I-1].second)
1512 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1513 Best[0]);
Douglas Gregoreb90e832012-01-04 23:32:19 +00001514
1515 Sub = Module->findSubmodule(Best[0]);
Douglas Gregor5196bc62011-11-30 04:03:44 +00001516 }
1517 }
1518
Douglas Gregoreb90e832012-01-04 23:32:19 +00001519 if (!Sub) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001520 // No submodule by this name. Complain, and don't look for further
1521 // submodules.
1522 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
Douglas Gregor69021972011-11-30 17:33:56 +00001523 << Path[I].first << Module->getFullModuleName()
Douglas Gregor5196bc62011-11-30 04:03:44 +00001524 << SourceRange(Path[0].second, Path[I-1].second);
1525 break;
1526 }
1527
Douglas Gregoreb90e832012-01-04 23:32:19 +00001528 Module = Sub;
Douglas Gregor5196bc62011-11-30 04:03:44 +00001529 }
Douglas Gregor08142532011-08-26 23:56:07 +00001530 }
Ben Langmuirb537a3a2014-07-23 15:30:23 +00001531
1532 // Don't make the module visible if we are in the implementation.
1533 if (ModuleName == getLangOpts().ImplementationOfModule)
1534 return ModuleLoadResult(Module, false);
Douglas Gregor5196bc62011-11-30 04:03:44 +00001535
Douglas Gregor2537a362011-12-08 17:01:29 +00001536 // Make the named module visible, if it's not already part of the module
1537 // we are parsing.
Douglas Gregor98a52db2011-12-20 00:28:52 +00001538 if (ModuleName != getLangOpts().CurrentModule) {
1539 if (!Module->IsFromModuleFile) {
1540 // We have an umbrella header or directory that doesn't actually include
1541 // all of the headers within the directory it covers. Complain about
1542 // this missing submodule and recover by forgetting that we ever saw
1543 // this submodule.
1544 // FIXME: Should we detect this at module load time? It seems fairly
1545 // expensive (and rare).
1546 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1547 << Module->getFullModuleName()
1548 << SourceRange(Path.front().second, Path.back().second);
Craig Topper49a27902014-05-22 04:46:25 +00001549
1550 return ModuleLoadResult(nullptr, true);
Douglas Gregor98a52db2011-12-20 00:28:52 +00001551 }
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00001552
1553 // Check whether this module is available.
Richard Smitha3feee22013-10-28 22:18:19 +00001554 clang::Module::Requirement Requirement;
Richard Smith3c1a41a2014-12-02 00:08:08 +00001555 clang::Module::UnresolvedHeaderDirective MissingHeader;
Daniel Jasper0761a8a2013-12-17 10:31:37 +00001556 if (!Module->isAvailable(getLangOpts(), getTarget(), Requirement,
1557 MissingHeader)) {
1558 if (MissingHeader.FileNameLoc.isValid()) {
1559 getDiagnostics().Report(MissingHeader.FileNameLoc,
1560 diag::err_module_header_missing)
1561 << MissingHeader.IsUmbrella << MissingHeader.FileName;
1562 } else {
1563 getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
1564 << Module->getFullModuleName()
1565 << Requirement.second << Requirement.first
1566 << SourceRange(Path.front().second, Path.back().second);
1567 }
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00001568 LastModuleImportLoc = ImportLoc;
Douglas Gregor7a626572012-11-29 23:55:25 +00001569 LastModuleImportResult = ModuleLoadResult();
1570 return ModuleLoadResult();
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00001571 }
1572
Richard Smitha7e2cc62015-05-01 01:53:09 +00001573 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
Douglas Gregor98a52db2011-12-20 00:28:52 +00001574 }
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001575
1576 // Check for any configuration macros that have changed.
1577 clang::Module *TopModule = Module->getTopLevelModule();
1578 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1579 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1580 Module, ImportLoc);
1581 }
1582
Douglas Gregor1805b8a2011-11-30 04:26:53 +00001583 LastModuleImportLoc = ImportLoc;
Douglas Gregor7a626572012-11-29 23:55:25 +00001584 LastModuleImportResult = ModuleLoadResult(Module, false);
1585 return LastModuleImportResult;
Douglas Gregor08142532011-08-26 23:56:07 +00001586}
Douglas Gregorc147b0b2013-01-12 01:29:50 +00001587
1588void CompilerInstance::makeModuleVisible(Module *Mod,
Argyrios Kyrtzidis125df052013-02-01 16:36:12 +00001589 Module::NameVisibilityKind Visibility,
Richard Smitha7e2cc62015-05-01 01:53:09 +00001590 SourceLocation ImportLoc) {
Richard Smith42413142015-05-15 20:05:43 +00001591 if (!ModuleManager)
1592 createModuleManager();
1593 if (!ModuleManager)
1594 return;
1595
Richard Smitha7e2cc62015-05-01 01:53:09 +00001596 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
Douglas Gregorc147b0b2013-01-12 01:29:50 +00001597}
1598
John Thompson2255f2c2014-04-23 12:57:01 +00001599GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex(
1600 SourceLocation TriggerLoc) {
1601 if (!ModuleManager)
1602 createModuleManager();
1603 // Can't do anything if we don't have the module manager.
1604 if (!ModuleManager)
Craig Topper49a27902014-05-22 04:46:25 +00001605 return nullptr;
John Thompson2255f2c2014-04-23 12:57:01 +00001606 // Get an existing global index. This loads it if not already
1607 // loaded.
1608 ModuleManager->loadGlobalIndex();
1609 GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
1610 // If the global index doesn't exist, create it.
1611 if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
1612 hasPreprocessor()) {
1613 llvm::sys::fs::create_directories(
1614 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
1615 GlobalModuleIndex::writeIndex(
Adrian Prantlfb2398d2015-07-17 01:19:54 +00001616 getFileManager(), getPCHContainerReader(),
Adrian Prantlbb165fb2015-06-20 18:53:08 +00001617 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
John Thompson2255f2c2014-04-23 12:57:01 +00001618 ModuleManager->resetForReload();
1619 ModuleManager->loadGlobalIndex();
1620 GlobalIndex = ModuleManager->getGlobalIndex();
1621 }
1622 // For finding modules needing to be imported for fixit messages,
1623 // we need to make the global index cover all modules, so we do that here.
1624 if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
1625 ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap();
1626 bool RecreateIndex = false;
1627 for (ModuleMap::module_iterator I = MMap.module_begin(),
1628 E = MMap.module_end(); I != E; ++I) {
1629 Module *TheModule = I->second;
1630 const FileEntry *Entry = TheModule->getASTFile();
1631 if (!Entry) {
1632 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
1633 Path.push_back(std::make_pair(
1634 getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
1635 std::reverse(Path.begin(), Path.end());
1636 // Load a module as hidden. This also adds it to the global index.
John Thompsone0a5afe2014-04-23 13:45:44 +00001637 loadModule(TheModule->DefinitionLoc, Path,
John Thompson2255f2c2014-04-23 12:57:01 +00001638 Module::Hidden, false);
1639 RecreateIndex = true;
1640 }
1641 }
1642 if (RecreateIndex) {
1643 GlobalModuleIndex::writeIndex(
Adrian Prantlfb2398d2015-07-17 01:19:54 +00001644 getFileManager(), getPCHContainerReader(),
Adrian Prantlbb165fb2015-06-20 18:53:08 +00001645 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
John Thompson2255f2c2014-04-23 12:57:01 +00001646 ModuleManager->resetForReload();
1647 ModuleManager->loadGlobalIndex();
1648 GlobalIndex = ModuleManager->getGlobalIndex();
1649 }
1650 HaveFullGlobalModuleIndex = true;
1651 }
1652 return GlobalIndex;
1653}
John Thompson2d94bbb2014-04-23 19:04:32 +00001654
1655// Check global module index for missing imports.
1656bool
1657CompilerInstance::lookupMissingImports(StringRef Name,
1658 SourceLocation TriggerLoc) {
1659 // Look for the symbol in non-imported modules, but only if an error
1660 // actually occurred.
1661 if (!buildingModule()) {
1662 // Load global module index, or retrieve a previously loaded one.
1663 GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex(
1664 TriggerLoc);
1665
1666 // Only if we have a global index.
1667 if (GlobalIndex) {
1668 GlobalModuleIndex::HitSet FoundModules;
1669
1670 // Find the modules that reference the identifier.
1671 // Note that this only finds top-level modules.
1672 // We'll let diagnoseTypo find the actual declaration module.
1673 if (GlobalIndex->lookupIdentifier(Name, FoundModules))
1674 return true;
1675 }
1676 }
1677
1678 return false;
1679}
David Blaikiea97eaa12014-08-29 16:53:14 +00001680void CompilerInstance::resetAndLeakSema() { BuryPointer(takeSema()); }