blob: 76f2f9bc6b2855cee3c0184f20f9f08f59e85bca [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
Artem Belevichb5bc9232015-09-22 17:23:22 +000081void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; }
82void CompilerInstance::setAuxTarget(TargetInfo *Value) { AuxTarget = Value; }
Daniel Dunbare01dc862009-11-14 01:20:40 +000083
84void CompilerInstance::setFileManager(FileManager *Value) {
Ted Kremenek5e14d392011-03-21 18:40:17 +000085 FileMgr = Value;
Ben Langmuirc8130a72014-02-20 21:59:23 +000086 if (Value)
87 VirtualFileSystem = Value->getVirtualFileSystem();
88 else
89 VirtualFileSystem.reset();
Daniel Dunbare01dc862009-11-14 01:20:40 +000090}
91
NAKAMURA Takumi82a35112011-10-08 11:31:46 +000092void CompilerInstance::setSourceManager(SourceManager *Value) {
Ted Kremenek5e14d392011-03-21 18:40:17 +000093 SourceMgr = Value;
Daniel Dunbare01dc862009-11-14 01:20:40 +000094}
95
Ted Kremenek5e14d392011-03-21 18:40:17 +000096void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; }
Daniel Dunbare01dc862009-11-14 01:20:40 +000097
Richard Smith293534b2015-08-18 20:39:29 +000098void CompilerInstance::setASTContext(ASTContext *Value) {
99 Context = Value;
100
101 if (Context && Consumer)
102 getASTConsumer().Initialize(getASTContext());
103}
Daniel Dunbare01dc862009-11-14 01:20:40 +0000104
Douglas Gregor0e93f012010-08-12 23:31:19 +0000105void CompilerInstance::setSema(Sema *S) {
106 TheSema.reset(S);
107}
108
David Blaikie6beb6aa2014-08-10 19:56:51 +0000109void CompilerInstance::setASTConsumer(std::unique_ptr<ASTConsumer> Value) {
110 Consumer = std::move(Value);
Richard Smith293534b2015-08-18 20:39:29 +0000111
112 if (Context && Consumer)
113 getASTConsumer().Initialize(getASTContext());
Daniel Dunbar56d9c292009-11-14 02:47:17 +0000114}
115
Daniel Dunbare01dc862009-11-14 01:20:40 +0000116void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
117 CompletionConsumer.reset(Value);
118}
David Blaikie61535812014-08-10 20:12:39 +0000119
120std::unique_ptr<Sema> CompilerInstance::takeSema() {
121 return std::move(TheSema);
122}
123
Argyrios Kyrtzidis1b7ed912014-02-27 04:11:59 +0000124IntrusiveRefCntPtr<ASTReader> CompilerInstance::getModuleManager() const {
125 return ModuleManager;
126}
127void CompilerInstance::setModuleManager(IntrusiveRefCntPtr<ASTReader> Reader) {
128 ModuleManager = Reader;
129}
Daniel Dunbare01dc862009-11-14 01:20:40 +0000130
Justin Bogner86d12592014-06-19 19:36:03 +0000131std::shared_ptr<ModuleDependencyCollector>
132CompilerInstance::getModuleDepCollector() const {
133 return ModuleDepCollector;
134}
135
136void CompilerInstance::setModuleDepCollector(
137 std::shared_ptr<ModuleDependencyCollector> Collector) {
138 ModuleDepCollector = Collector;
139}
140
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000141// Diagnostics
Douglas Gregor811db4e2012-10-23 22:26:28 +0000142static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
Daniel Dunbar7b833062011-04-07 18:59:02 +0000143 const CodeGenOptions *CodeGenOpts,
David Blaikie9c902b52011-09-25 23:23:43 +0000144 DiagnosticsEngine &Diags) {
Rafael Espindoladae941a2014-08-25 18:17:04 +0000145 std::error_code EC;
David Blaikie11f8a942014-09-15 17:30:56 +0000146 std::unique_ptr<raw_ostream> StreamOwner;
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000147 raw_ostream *OS = &llvm::errs();
Douglas Gregor811db4e2012-10-23 22:26:28 +0000148 if (DiagOpts->DiagnosticLogFile != "-") {
Daniel Dunbar2083c322011-04-07 18:31:10 +0000149 // Create the output stream.
David Blaikie11f8a942014-09-15 17:30:56 +0000150 auto FileOS = llvm::make_unique<llvm::raw_fd_ostream>(
Rafael Espindoladae941a2014-08-25 18:17:04 +0000151 DiagOpts->DiagnosticLogFile, EC,
David Blaikie11f8a942014-09-15 17:30:56 +0000152 llvm::sys::fs::F_Append | llvm::sys::fs::F_Text);
Rafael Espindoladae941a2014-08-25 18:17:04 +0000153 if (EC) {
Daniel Dunbar2083c322011-04-07 18:31:10 +0000154 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
Rafael Espindoladae941a2014-08-25 18:17:04 +0000155 << DiagOpts->DiagnosticLogFile << EC.message();
Daniel Dunbar2083c322011-04-07 18:31:10 +0000156 } else {
157 FileOS->SetUnbuffered();
David Blaikie11f8a942014-09-15 17:30:56 +0000158 OS = FileOS.get();
159 StreamOwner = std::move(FileOS);
Daniel Dunbar2083c322011-04-07 18:31:10 +0000160 }
161 }
162
163 // Chain in the diagnostic client which will log the diagnostics.
David Blaikie7ee25502014-09-15 17:50:10 +0000164 auto Logger = llvm::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,
165 std::move(StreamOwner));
Daniel Dunbar7b833062011-04-07 18:59:02 +0000166 if (CodeGenOpts)
167 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
David Blaikie7ee25502014-09-15 17:50:10 +0000168 assert(Diags.ownsClient());
Alexander Kornienko41c247a2014-11-17 23:46:02 +0000169 Diags.setClient(
170 new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger)));
Daniel Dunbar2083c322011-04-07 18:31:10 +0000171}
172
Douglas Gregor811db4e2012-10-23 22:26:28 +0000173static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
Ted Kremenek4610ea22011-10-29 00:12:39 +0000174 DiagnosticsEngine &Diags,
175 StringRef OutputFile) {
David Blaikie7ee25502014-09-15 17:50:10 +0000176 auto SerializedConsumer =
Justin Bogner5a6a2fc2014-10-23 22:20:11 +0000177 clang::serialized_diags::create(OutputFile, DiagOpts);
Ahmed Charles9a16beb2014-03-07 19:33:25 +0000178
Alexander Kornienko254b7db2014-11-13 13:08:27 +0000179 if (Diags.ownsClient()) {
180 Diags.setClient(new ChainedDiagnosticConsumer(
Alexander Kornienko41c247a2014-11-17 23:46:02 +0000181 Diags.takeClient(), std::move(SerializedConsumer)));
Alexander Kornienko254b7db2014-11-13 13:08:27 +0000182 } else {
183 Diags.setClient(new ChainedDiagnosticConsumer(
Alexander Kornienko4c0ef3792014-11-17 14:46:28 +0000184 Diags.getClient(), std::move(SerializedConsumer)));
Alexander Kornienko254b7db2014-11-13 13:08:27 +0000185 }
Ted Kremenek4610ea22011-10-29 00:12:39 +0000186}
187
Sean Silvaf1b49e22013-01-20 01:58:28 +0000188void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
Douglas Gregor30071cea2013-05-03 23:07:45 +0000189 bool ShouldOwnClient) {
Sean Silvaf1b49e22013-01-20 01:58:28 +0000190 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
Douglas Gregor30071cea2013-05-03 23:07:45 +0000191 ShouldOwnClient, &getCodeGenOpts());
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000192}
193
Dylan Noblesmithc95d8192012-02-20 14:00:23 +0000194IntrusiveRefCntPtr<DiagnosticsEngine>
Douglas Gregor811db4e2012-10-23 22:26:28 +0000195CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
David Blaikiee2eefae2011-09-25 23:39:51 +0000196 DiagnosticConsumer *Client,
Douglas Gregor2b9b4642011-09-13 01:26:44 +0000197 bool ShouldOwnClient,
Daniel Dunbar7b833062011-04-07 18:59:02 +0000198 const CodeGenOptions *CodeGenOpts) {
Dylan Noblesmithc95d8192012-02-20 14:00:23 +0000199 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
200 IntrusiveRefCntPtr<DiagnosticsEngine>
Douglas Gregor811db4e2012-10-23 22:26:28 +0000201 Diags(new DiagnosticsEngine(DiagID, Opts));
Daniel Dunbar1b39a2e2009-11-14 07:53:24 +0000202
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000203 // Create the diagnostic client for reporting errors or for
204 // implementing -verify.
Douglas Gregord0e9e3a2011-09-29 00:38:00 +0000205 if (Client) {
Douglas Gregor30071cea2013-05-03 23:07:45 +0000206 Diags->setClient(Client, ShouldOwnClient);
Douglas Gregord0e9e3a2011-09-29 00:38:00 +0000207 } else
Douglas Gregor44c6ee72010-11-11 00:39:14 +0000208 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
Daniel Dunbar50ec0da2009-11-14 03:24:39 +0000209
210 // Chain in -verify checker, if requested.
Douglas Gregor811db4e2012-10-23 22:26:28 +0000211 if (Opts->VerifyDiagnostics)
David Blaikie69609dc2011-09-26 00:38:03 +0000212 Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000213
Daniel Dunbar2083c322011-04-07 18:31:10 +0000214 // Chain in -diagnostic-log-file dumper, if requested.
Douglas Gregor811db4e2012-10-23 22:26:28 +0000215 if (!Opts->DiagnosticLogFile.empty())
Daniel Dunbar7b833062011-04-07 18:59:02 +0000216 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000217
Douglas Gregor811db4e2012-10-23 22:26:28 +0000218 if (!Opts->DiagnosticSerializationFile.empty())
Ted Kremenek4610ea22011-10-29 00:12:39 +0000219 SetupSerializedDiagnostics(Opts, *Diags,
Douglas Gregor811db4e2012-10-23 22:26:28 +0000220 Opts->DiagnosticSerializationFile);
Ted Kremenek4610ea22011-10-29 00:12:39 +0000221
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000222 // Configure our handling of diagnostics.
Douglas Gregor811db4e2012-10-23 22:26:28 +0000223 ProcessWarningOptions(*Diags, *Opts);
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000224
Douglas Gregor7f95d262010-04-05 23:52:57 +0000225 return Diags;
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000226}
227
228// File Manager
229
Daniel Dunbar546a6762009-11-13 04:12:06 +0000230void CompilerInstance::createFileManager() {
Ben Langmuirc8130a72014-02-20 21:59:23 +0000231 if (!hasVirtualFileSystem()) {
232 // TODO: choose the virtual file system based on the CompilerInvocation.
233 setVirtualFileSystem(vfs::getRealFileSystem());
234 }
235 FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem);
Daniel Dunbar546a6762009-11-13 04:12:06 +0000236}
237
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000238// Source Manager
239
Chris Lattner5159f612010-11-23 08:35:12 +0000240void CompilerInstance::createSourceManager(FileManager &FileMgr) {
Ted Kremenek5e14d392011-03-21 18:40:17 +0000241 SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
Daniel Dunbar546a6762009-11-13 04:12:06 +0000242}
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000243
Alp Tokerc3580002014-07-07 06:05:00 +0000244// Initialize the remapping of files to alternative contents, e.g.,
245// those specified through other files.
246static void InitializeFileRemapping(DiagnosticsEngine &Diags,
247 SourceManager &SourceMgr,
248 FileManager &FileMgr,
249 const PreprocessorOptions &InitOpts) {
250 // Remap files in the source manager (with buffers).
Alp Toker1b070d22014-07-07 07:47:20 +0000251 for (const auto &RB : InitOpts.RemappedFileBuffers) {
Alp Tokerc3580002014-07-07 06:05:00 +0000252 // Create the file entry for the file that we're mapping from.
253 const FileEntry *FromFile =
Alp Toker1b070d22014-07-07 07:47:20 +0000254 FileMgr.getVirtualFile(RB.first, RB.second->getBufferSize(), 0);
Alp Tokerc3580002014-07-07 06:05:00 +0000255 if (!FromFile) {
Alp Toker1b070d22014-07-07 07:47:20 +0000256 Diags.Report(diag::err_fe_remap_missing_from_file) << RB.first;
Alp Tokerc3580002014-07-07 06:05:00 +0000257 if (!InitOpts.RetainRemappedFileBuffers)
Alp Toker1b070d22014-07-07 07:47:20 +0000258 delete RB.second;
Alp Tokerc3580002014-07-07 06:05:00 +0000259 continue;
260 }
261
262 // Override the contents of the "from" file with the contents of
263 // the "to" file.
Alp Toker1b070d22014-07-07 07:47:20 +0000264 SourceMgr.overrideFileContents(FromFile, RB.second,
Alp Tokerc3580002014-07-07 06:05:00 +0000265 InitOpts.RetainRemappedFileBuffers);
266 }
267
268 // Remap files in the source manager (with other files).
Alp Toker1b070d22014-07-07 07:47:20 +0000269 for (const auto &RF : InitOpts.RemappedFiles) {
Alp Tokerc3580002014-07-07 06:05:00 +0000270 // Find the file that we're mapping to.
Alp Toker1b070d22014-07-07 07:47:20 +0000271 const FileEntry *ToFile = FileMgr.getFile(RF.second);
Alp Tokerc3580002014-07-07 06:05:00 +0000272 if (!ToFile) {
Alp Toker1b070d22014-07-07 07:47:20 +0000273 Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;
Alp Tokerc3580002014-07-07 06:05:00 +0000274 continue;
275 }
276
277 // Create the file entry for the file that we're mapping from.
278 const FileEntry *FromFile =
Alp Toker1b070d22014-07-07 07:47:20 +0000279 FileMgr.getVirtualFile(RF.first, ToFile->getSize(), 0);
Alp Tokerc3580002014-07-07 06:05:00 +0000280 if (!FromFile) {
Alp Toker1b070d22014-07-07 07:47:20 +0000281 Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first;
Alp Tokerc3580002014-07-07 06:05:00 +0000282 continue;
283 }
284
285 // Override the contents of the "from" file with the contents of
286 // the "to" file.
287 SourceMgr.overrideFileContents(FromFile, ToFile);
288 }
289
290 SourceMgr.setOverridenFilesKeepOriginalName(
291 InitOpts.RemappedFilesKeepOriginalName);
292}
293
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000294// Preprocessor
295
Argyrios Kyrtzidise1974dc2014-03-07 07:47:58 +0000296void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
Douglas Gregor08142532011-08-26 23:56:07 +0000297 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000298
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000299 // Create a PTH manager if we are using some form of a token cache.
Craig Topper49a27902014-05-22 04:46:25 +0000300 PTHManager *PTHMgr = nullptr;
Daniel Dunbard6ea9022009-11-17 05:52:41 +0000301 if (!PPOpts.TokenCache.empty())
Douglas Gregor08142532011-08-26 23:56:07 +0000302 PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000303
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000304 // Create the Preprocessor.
Douglas Gregorb85b9cc2012-10-24 16:19:39 +0000305 HeaderSearch *HeaderInfo = new HeaderSearch(&getHeaderSearchOpts(),
Manuel Klimek1f76c4e2013-10-24 07:51:24 +0000306 getSourceManager(),
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +0000307 getDiagnostics(),
Douglas Gregor89929282012-01-30 06:01:29 +0000308 getLangOpts(),
309 &getTarget());
Alp Toker96637802014-05-02 03:43:38 +0000310 PP = new Preprocessor(&getPreprocessorOpts(), getDiagnostics(), getLangOpts(),
Douglas Gregor08142532011-08-26 23:56:07 +0000311 getSourceManager(), *HeaderInfo, *this, PTHMgr,
Alp Toker96637802014-05-02 03:43:38 +0000312 /*OwnsHeaderSearch=*/true, TUKind);
Artem Belevichb5bc9232015-09-22 17:23:22 +0000313 PP->Initialize(getTarget(), getAuxTarget());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000314
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000315 // Note that this is different then passing PTHMgr to Preprocessor's ctor.
316 // That argument is used as the IdentifierInfoLookup argument to
317 // IdentifierTable's ctor.
318 if (PTHMgr) {
Douglas Gregor08142532011-08-26 23:56:07 +0000319 PTHMgr->setPreprocessor(&*PP);
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000320 PP->setPTHManager(PTHMgr);
321 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000322
Douglas Gregor7f6d60d2010-03-19 16:15:56 +0000323 if (PPOpts.DetailedRecord)
Argyrios Kyrtzidisf3d587e2012-12-04 07:27:05 +0000324 PP->createPreprocessingRecord();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000325
Alp Tokerc3580002014-07-07 06:05:00 +0000326 // Apply remappings to the source manager.
327 InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
328 PP->getFileManager(), PPOpts);
329
330 // Predefine macros and configure the preprocessor.
Adrian Prantlfb2398d2015-07-17 01:19:54 +0000331 InitializePreprocessor(*PP, PPOpts, getPCHContainerReader(),
Adrian Prantlbb165fb2015-06-20 18:53:08 +0000332 getFrontendOpts());
Alp Tokerc3580002014-07-07 06:05:00 +0000333
334 // Initialize the header search object.
335 ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(),
336 PP->getLangOpts(), PP->getTargetInfo().getTriple());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000337
Jordan Rose17441582013-01-30 01:52:57 +0000338 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
339
Richard Smith3938f0c2015-08-15 00:34:15 +0000340 if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules)
Chandler Carruthff8d9432015-03-28 01:10:44 +0000341 PP->getHeaderSearchInfo().setModuleCachePath(getSpecificModuleCachePath());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000342
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000343 // Handle generating dependencies, if requested.
Douglas Gregor08142532011-08-26 23:56:07 +0000344 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000345 if (!DepOpts.OutputFile.empty())
Ben Langmuircb69b572014-03-07 06:40:32 +0000346 TheDependencyFileGenerator.reset(
347 DependencyFileGenerator::CreateAndAttachToPreprocessor(*PP, DepOpts));
Douglas Gregor2e129652012-02-02 23:45:13 +0000348 if (!DepOpts.DOTOutputFile.empty())
349 AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile,
Douglas Gregor83d46be2012-02-02 00:54:52 +0000350 getHeaderSearchOpts().Sysroot);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000351
Justin Bogner86d12592014-06-19 19:36:03 +0000352 // If we don't have a collector, but we are collecting module dependencies,
353 // then we're the top level compiler instance and need to create one.
Bruno Cardoso Lopesb1631d92016-03-29 23:47:40 +0000354 if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty()) {
Justin Bogner86d12592014-06-19 19:36:03 +0000355 ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(
356 DepOpts.ModuleDependencyOutputDir);
Bruno Cardoso Lopesb1631d92016-03-29 23:47:40 +0000357 }
358
359 if (ModuleDepCollector)
360 addDependencyCollector(ModuleDepCollector);
361
362 for (auto &Listener : DependencyCollectors)
363 Listener->attachToPreprocessor(*PP);
Hans Wennborg0fd62072013-08-09 00:32:23 +0000364
Daniel Dunbar27734fd2011-02-02 15:41:17 +0000365 // Handle generating header include information, if requested.
366 if (DepOpts.ShowHeaderIncludes)
Nico Weberf54146c2016-03-23 18:46:57 +0000367 AttachHeaderIncludeGen(*PP, DepOpts);
Daniel Dunbar1af1d27512011-02-02 21:11:31 +0000368 if (!DepOpts.HeaderIncludeOutputFile.empty()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000369 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
Daniel Dunbar1af1d27512011-02-02 21:11:31 +0000370 if (OutputPath == "-")
371 OutputPath = "";
Nico Weberf54146c2016-03-23 18:46:57 +0000372 AttachHeaderIncludeGen(*PP, DepOpts,
Ivan Krasin1193f2c2015-08-13 04:04:37 +0000373 /*ShowAllHeaders=*/true, OutputPath,
Daniel Dunbarfe908a82011-03-21 19:37:38 +0000374 /*ShowDepth=*/false);
Daniel Dunbar1af1d27512011-02-02 21:11:31 +0000375 }
Hans Wennborg0fd62072013-08-09 00:32:23 +0000376
377 if (DepOpts.PrintShowIncludes) {
Nico Weberf54146c2016-03-23 18:46:57 +0000378 AttachHeaderIncludeGen(*PP, DepOpts,
Nico Weber149d95222016-03-23 18:00:22 +0000379 /*ShowAllHeaders=*/true, /*OutputPath=*/"",
Hans Wennborg0fd62072013-08-09 00:32:23 +0000380 /*ShowDepth=*/true, /*MSStyle=*/true);
381 }
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000382}
Daniel Dunbardf3e30c2009-11-13 08:20:47 +0000383
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +0000384std::string CompilerInstance::getSpecificModuleCachePath() {
385 // Set up the module path, including the hash for the
386 // module-creation options.
Richard Smithd520a252015-07-21 18:07:47 +0000387 SmallString<256> SpecificModuleCache(getHeaderSearchOpts().ModuleCachePath);
388 if (!SpecificModuleCache.empty() && !getHeaderSearchOpts().DisableModuleHash)
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +0000389 llvm::sys::path::append(SpecificModuleCache,
390 getInvocation().getModuleHash());
391 return SpecificModuleCache.str();
392}
393
Daniel Dunbardf3e30c2009-11-13 08:20:47 +0000394// ASTContext
395
396void CompilerInstance::createASTContext() {
397 Preprocessor &PP = getPreprocessor();
Richard Smith293534b2015-08-18 20:39:29 +0000398 auto *Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
399 PP.getIdentifierTable(), PP.getSelectorTable(),
400 PP.getBuiltinInfo());
Artem Belevichb5bc9232015-09-22 17:23:22 +0000401 Context->InitBuiltinTypes(getTarget(), getAuxTarget());
Richard Smith293534b2015-08-18 20:39:29 +0000402 setASTContext(Context);
Daniel Dunbardf3e30c2009-11-13 08:20:47 +0000403}
Daniel Dunbar599313e2009-11-13 08:21:10 +0000404
405// ExternalASTSource
406
Nico Weber824285e2014-05-08 04:26:47 +0000407void CompilerInstance::createPCHExternalASTSource(
408 StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors,
409 void *DeserializationListener, bool OwnDeserializationListener) {
Sebastian Redl009e7f22010-10-05 16:15:19 +0000410 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
Richard Smith4eca9b92015-02-04 23:37:59 +0000411 ModuleManager = createPCHExternalASTSource(
Nico Weber824285e2014-05-08 04:26:47 +0000412 Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation,
413 AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(),
Douglas Gregor6623e1f2015-11-03 18:33:07 +0000414 getPCHContainerReader(),
415 getFrontendOpts().ModuleFileExtensions,
416 DeserializationListener,
Adrian Prantlbb165fb2015-06-20 18:53:08 +0000417 OwnDeserializationListener, Preamble,
Nico Weber824285e2014-05-08 04:26:47 +0000418 getFrontendOpts().UseGlobalModuleIndex);
Daniel Dunbar599313e2009-11-13 08:21:10 +0000419}
420
Richard Smith4eca9b92015-02-04 23:37:59 +0000421IntrusiveRefCntPtr<ASTReader> CompilerInstance::createPCHExternalASTSource(
Yaron Keren5b816062015-07-06 08:47:15 +0000422 StringRef Path, StringRef Sysroot, bool DisablePCHValidation,
Nico Weber824285e2014-05-08 04:26:47 +0000423 bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context,
Adrian Prantlfb2398d2015-07-17 01:19:54 +0000424 const PCHContainerReader &PCHContainerRdr,
Douglas Gregor6623e1f2015-11-03 18:33:07 +0000425 ArrayRef<IntrusiveRefCntPtr<ModuleFileExtension>> Extensions,
Nico Weber824285e2014-05-08 04:26:47 +0000426 void *DeserializationListener, bool OwnDeserializationListener,
427 bool Preamble, bool UseGlobalModuleIndex) {
Ben Langmuirdcf73862014-03-12 00:06:17 +0000428 HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
429
Adrian Prantlbb165fb2015-06-20 18:53:08 +0000430 IntrusiveRefCntPtr<ASTReader> Reader(new ASTReader(
Douglas Gregor6623e1f2015-11-03 18:33:07 +0000431 PP, Context, PCHContainerRdr, Extensions,
432 Sysroot.empty() ? "" : Sysroot.data(), DisablePCHValidation,
433 AllowPCHWithCompilerErrors, /*AllowConfigurationMismatch*/ false,
434 HSOpts.ModulesValidateSystemHeaders, UseGlobalModuleIndex));
Richard Smith4eca9b92015-02-04 23:37:59 +0000435
436 // We need the external source to be set up before we read the AST, because
437 // eagerly-deserialized declarations may use it.
438 Context.setExternalSource(Reader.get());
Daniel Dunbar599313e2009-11-13 08:21:10 +0000439
Sebastian Redl07a89a82010-07-30 00:29:29 +0000440 Reader->setDeserializationListener(
Nico Weber824285e2014-05-08 04:26:47 +0000441 static_cast<ASTDeserializationListener *>(DeserializationListener),
442 /*TakeOwnership=*/OwnDeserializationListener);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000443 switch (Reader->ReadAST(Path,
444 Preamble ? serialization::MK_Preamble
Douglas Gregor4b29c162012-10-22 23:51:00 +0000445 : serialization::MK_PCH,
Argyrios Kyrtzidis2ec29362012-11-15 18:57:22 +0000446 SourceLocation(),
Ben Langmuir3d4417c2014-02-07 17:31:11 +0000447 ASTReader::ARR_None)) {
Sebastian Redl2c499f62010-08-18 23:56:43 +0000448 case ASTReader::Success:
Daniel Dunbar599313e2009-11-13 08:21:10 +0000449 // Set the predefines buffer as suggested by the PCH reader. Typically, the
450 // predefines buffer will be empty.
451 PP.setPredefines(Reader->getSuggestedPredefines());
Richard Smith4eca9b92015-02-04 23:37:59 +0000452 return Reader;
Daniel Dunbar599313e2009-11-13 08:21:10 +0000453
Sebastian Redl2c499f62010-08-18 23:56:43 +0000454 case ASTReader::Failure:
Daniel Dunbar599313e2009-11-13 08:21:10 +0000455 // Unrecoverable failure: don't even try to process the input file.
456 break;
457
Douglas Gregor7029ce12013-03-19 00:28:20 +0000458 case ASTReader::Missing:
Douglas Gregorc9ad5fb2012-10-22 22:50:17 +0000459 case ASTReader::OutOfDate:
460 case ASTReader::VersionMismatch:
461 case ASTReader::ConfigurationMismatch:
462 case ASTReader::HadErrors:
Daniel Dunbar599313e2009-11-13 08:21:10 +0000463 // No suitable PCH file could be found. Return an error.
464 break;
465 }
466
Richard Smith4eca9b92015-02-04 23:37:59 +0000467 Context.setExternalSource(nullptr);
Craig Topper49a27902014-05-22 04:46:25 +0000468 return nullptr;
Daniel Dunbar599313e2009-11-13 08:21:10 +0000469}
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000470
471// Code Completion
472
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000473static bool EnableCodeCompletion(Preprocessor &PP,
Benjamin Kramer0772c422016-02-13 13:42:54 +0000474 StringRef Filename,
Douglas Gregor8e984da2010-08-04 16:47:14 +0000475 unsigned Line,
476 unsigned Column) {
477 // Tell the source manager to chop off the given file at a specific
478 // line and column.
Chris Lattner5159f612010-11-23 08:35:12 +0000479 const FileEntry *Entry = PP.getFileManager().getFile(Filename);
Douglas Gregor8e984da2010-08-04 16:47:14 +0000480 if (!Entry) {
481 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
482 << Filename;
483 return true;
484 }
485
486 // Truncate the named file at the given line/column.
487 PP.SetCodeCompletionPoint(Entry, Line, Column);
488 return false;
489}
490
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000491void CompilerInstance::createCodeCompletionConsumer() {
492 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
Douglas Gregor8e984da2010-08-04 16:47:14 +0000493 if (!CompletionConsumer) {
Erik Verbruggen2fca3c22012-04-12 10:31:12 +0000494 setCodeCompletionConsumer(
Douglas Gregor8e984da2010-08-04 16:47:14 +0000495 createCodeCompletionConsumer(getPreprocessor(),
496 Loc.FileName, Loc.Line, Loc.Column,
Dmitri Gribenko3292d062012-07-02 17:35:10 +0000497 getFrontendOpts().CodeCompleteOpts,
Douglas Gregor8e984da2010-08-04 16:47:14 +0000498 llvm::outs()));
499 if (!CompletionConsumer)
500 return;
501 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
502 Loc.Line, Loc.Column)) {
Craig Topper49a27902014-05-22 04:46:25 +0000503 setCodeCompletionConsumer(nullptr);
Douglas Gregor00a0cf72010-03-16 06:04:47 +0000504 return;
Douglas Gregor8e984da2010-08-04 16:47:14 +0000505 }
Douglas Gregorf09935f2009-12-01 05:55:20 +0000506
507 if (CompletionConsumer->isOutputBinary() &&
Rafael Espindolaa3346d82013-06-12 20:44:26 +0000508 llvm::sys::ChangeStdoutToBinary()) {
Douglas Gregorf09935f2009-12-01 05:55:20 +0000509 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
Craig Topper49a27902014-05-22 04:46:25 +0000510 setCodeCompletionConsumer(nullptr);
Douglas Gregorf09935f2009-12-01 05:55:20 +0000511 }
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000512}
513
Kovarththanan Rajaratnam5505dff2009-11-29 09:57:35 +0000514void CompilerInstance::createFrontendTimer() {
Richard Smithce18a182015-07-14 00:26:00 +0000515 FrontendTimerGroup.reset(new llvm::TimerGroup("Clang front-end time report"));
516 FrontendTimer.reset(
517 new llvm::Timer("Clang front-end timer", *FrontendTimerGroup));
Kovarththanan Rajaratnam5505dff2009-11-29 09:57:35 +0000518}
519
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000520CodeCompleteConsumer *
521CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
Yaron Keren5b816062015-07-06 08:47:15 +0000522 StringRef Filename,
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000523 unsigned Line,
524 unsigned Column,
Dmitri Gribenko3292d062012-07-02 17:35:10 +0000525 const CodeCompleteOptions &Opts,
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000526 raw_ostream &OS) {
Douglas Gregor8e984da2010-08-04 16:47:14 +0000527 if (EnableCodeCompletion(PP, Filename, Line, Column))
Craig Topper49a27902014-05-22 04:46:25 +0000528 return nullptr;
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000529
530 // Set up the creation routine for code-completion.
Dmitri Gribenko3292d062012-07-02 17:35:10 +0000531 return new PrintingCodeCompleteConsumer(Opts, OS);
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000532}
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000533
Douglas Gregor69f74f82011-08-25 22:30:56 +0000534void CompilerInstance::createSema(TranslationUnitKind TUKind,
Douglas Gregor0e93f012010-08-12 23:31:19 +0000535 CodeCompleteConsumer *CompletionConsumer) {
536 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
Douglas Gregor69f74f82011-08-25 22:30:56 +0000537 TUKind, CompletionConsumer));
Douglas Gregor0e93f012010-08-12 23:31:19 +0000538}
539
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000540// Output Files
541
Rafael Espindola269ec0f2015-04-10 14:11:52 +0000542void CompilerInstance::addOutputFile(OutputFile &&OutFile) {
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000543 assert(OutFile.OS && "Attempt to add empty stream to output list!");
Rafael Espindola269ec0f2015-04-10 14:11:52 +0000544 OutputFiles.push_back(std::move(OutFile));
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000545}
546
Kovarththanan Rajaratnam1c558cd2010-03-06 12:07:48 +0000547void CompilerInstance::clearOutputFiles(bool EraseFiles) {
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000548 for (OutputFile &OF : OutputFiles) {
549 // Manually close the stream before we rename it.
550 OF.OS.reset();
551
552 if (!OF.TempFilename.empty()) {
Anders Carlssonb5c356a2011-03-06 22:25:35 +0000553 if (EraseFiles) {
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000554 llvm::sys::fs::remove(OF.TempFilename);
Anders Carlssonb5c356a2011-03-06 22:25:35 +0000555 } else {
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000556 SmallString<128> NewOutFile(OF.Filename);
Anders Carlssonb5c356a2011-03-06 22:25:35 +0000557
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +0000558 // If '-working-directory' was passed, the output filename should be
559 // relative to that.
Anders Carlsson9ba8fb12011-03-14 01:13:54 +0000560 FileMgr->FixupRelativePath(NewOutFile);
Rafael Espindolac0809172014-06-12 14:02:15 +0000561 if (std::error_code ec =
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000562 llvm::sys::fs::rename(OF.TempFilename, NewOutFile)) {
Manuel Klimek3ef9c442012-05-16 20:55:58 +0000563 getDiagnostics().Report(diag::err_unable_to_rename_temp)
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000564 << OF.TempFilename << OF.Filename << ec.message();
Anders Carlssonb5c356a2011-03-06 22:25:35 +0000565
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000566 llvm::sys::fs::remove(OF.TempFilename);
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000567 }
568 }
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000569 } else if (!OF.Filename.empty() && EraseFiles)
570 llvm::sys::fs::remove(OF.Filename);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000571
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000572 }
573 OutputFiles.clear();
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000574 NonSeekStream.reset();
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000575}
576
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000577raw_pwrite_stream *
578CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile,
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000579 StringRef Extension) {
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000580 return createOutputFile(getFrontendOpts().OutputFile, Binary,
Daniel Dunbarae77b3d2012-03-03 00:36:06 +0000581 /*RemoveFileOnSignal=*/true, InFile, Extension,
582 /*UseTemporary=*/true);
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000583}
584
Alp Tokerea046722014-06-03 17:23:34 +0000585llvm::raw_null_ostream *CompilerInstance::createNullOutputFile() {
Rafael Espindola269ec0f2015-04-10 14:11:52 +0000586 auto OS = llvm::make_unique<llvm::raw_null_ostream>();
587 llvm::raw_null_ostream *Ret = OS.get();
588 addOutputFile(OutputFile("", "", std::move(OS)));
589 return Ret;
Alp Tokerea046722014-06-03 17:23:34 +0000590}
591
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000592raw_pwrite_stream *
593CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary,
594 bool RemoveFileOnSignal, StringRef InFile,
595 StringRef Extension, bool UseTemporary,
Daniel Dunbarb9c62c02012-03-03 00:36:02 +0000596 bool CreateMissingDirectories) {
Rafael Espindoladae941a2014-08-25 18:17:04 +0000597 std::string OutputPathName, TempPathName;
598 std::error_code EC;
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000599 std::unique_ptr<raw_pwrite_stream> OS = createOutputFile(
Rafael Espindoladae941a2014-08-25 18:17:04 +0000600 OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension,
Rafael Espindolac80a4062015-04-10 14:30:43 +0000601 UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName);
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000602 if (!OS) {
Rafael Espindoladae941a2014-08-25 18:17:04 +0000603 getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath
604 << EC.message();
Craig Topper49a27902014-05-22 04:46:25 +0000605 return nullptr;
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000606 }
607
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000608 raw_pwrite_stream *Ret = OS.get();
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000609 // Add the output file -- but don't try to remove "-", since this means we are
610 // using stdin.
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000611 addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "",
Rafael Espindola269ec0f2015-04-10 14:11:52 +0000612 TempPathName, std::move(OS)));
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000613
Rafael Espindola269ec0f2015-04-10 14:11:52 +0000614 return Ret;
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000615}
616
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000617std::unique_ptr<llvm::raw_pwrite_stream> CompilerInstance::createOutputFile(
Rafael Espindoladae941a2014-08-25 18:17:04 +0000618 StringRef OutputPath, std::error_code &Error, bool Binary,
619 bool RemoveFileOnSignal, StringRef InFile, StringRef Extension,
620 bool UseTemporary, bool CreateMissingDirectories,
621 std::string *ResultPathName, std::string *TempPathName) {
Daniel Dunbarb9c62c02012-03-03 00:36:02 +0000622 assert((!CreateMissingDirectories || UseTemporary) &&
623 "CreateMissingDirectories is only allowed when using temporary files");
624
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000625 std::string OutFile, TempFile;
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000626 if (!OutputPath.empty()) {
627 OutFile = OutputPath;
628 } else if (InFile == "-") {
629 OutFile = "-";
630 } else if (!Extension.empty()) {
Rafael Espindola399ab332013-06-26 04:32:59 +0000631 SmallString<128> Path(InFile);
632 llvm::sys::path::replace_extension(Path, Extension);
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000633 OutFile = Path.str();
634 } else {
635 OutFile = "-";
636 }
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000637
Ahmed Charlesb8984322014-03-07 20:03:18 +0000638 std::unique_ptr<llvm::raw_fd_ostream> OS;
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000639 std::string OSFile;
640
Rafael Espindola73c23a72013-06-27 18:26:26 +0000641 if (UseTemporary) {
642 if (OutFile == "-")
643 UseTemporary = false;
644 else {
645 llvm::sys::fs::file_status Status;
646 llvm::sys::fs::status(OutputPath, Status);
647 if (llvm::sys::fs::exists(Status)) {
648 // Fail early if we can't write to the final destination.
Douglas Katzman8bfac2c2015-09-17 16:45:12 +0000649 if (!llvm::sys::fs::can_write(OutputPath)) {
Rafael Espindolaee4e08b2015-10-05 11:49:35 +0000650 Error = make_error_code(llvm::errc::operation_not_permitted);
Craig Topper49a27902014-05-22 04:46:25 +0000651 return nullptr;
Douglas Katzman8bfac2c2015-09-17 16:45:12 +0000652 }
Rafael Espindola73c23a72013-06-27 18:26:26 +0000653
654 // Don't use a temporary if the output is a special file. This handles
655 // things like '-o /dev/null'
656 if (!llvm::sys::fs::is_regular_file(Status))
657 UseTemporary = false;
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000658 }
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000659 }
660 }
661
Rafael Espindola73c23a72013-06-27 18:26:26 +0000662 if (UseTemporary) {
Rafael Espindola73c23a72013-06-27 18:26:26 +0000663 // Create a temporary file.
664 SmallString<128> TempPath;
665 TempPath = OutFile;
666 TempPath += "-%%%%%%%%";
667 int fd;
Rafael Espindolac0809172014-06-12 14:02:15 +0000668 std::error_code EC =
Yaron Keren92e1b622015-03-18 10:17:07 +0000669 llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
Rafael Espindola157f34b2013-06-28 03:49:04 +0000670
671 if (CreateMissingDirectories &&
Rafael Espindola71de0b62014-06-13 17:20:50 +0000672 EC == llvm::errc::no_such_file_or_directory) {
Rafael Espindola157f34b2013-06-28 03:49:04 +0000673 StringRef Parent = llvm::sys::path::parent_path(OutputPath);
674 EC = llvm::sys::fs::create_directories(Parent);
675 if (!EC) {
Yaron Keren92e1b622015-03-18 10:17:07 +0000676 EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
Rafael Espindola157f34b2013-06-28 03:49:04 +0000677 }
678 }
679
680 if (!EC) {
NAKAMURA Takumi69f35282014-08-11 06:53:11 +0000681 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
Rafael Espindola73c23a72013-06-27 18:26:26 +0000682 OSFile = TempFile = TempPath.str();
683 }
684 // If we failed to create the temporary, fallback to writing to the file
685 // directly. This handles the corner case where we cannot write to the
686 // directory, but can write to the file.
687 }
688
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000689 if (!OS) {
690 OSFile = OutFile;
NAKAMURA Takumi69f35282014-08-11 06:53:11 +0000691 OS.reset(new llvm::raw_fd_ostream(
Rafael Espindoladae941a2014-08-25 18:17:04 +0000692 OSFile, Error,
NAKAMURA Takumi69f35282014-08-11 06:53:11 +0000693 (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text)));
Rafael Espindoladae941a2014-08-25 18:17:04 +0000694 if (Error)
Craig Topper49a27902014-05-22 04:46:25 +0000695 return nullptr;
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000696 }
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000697
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000698 // Make sure the out stream file gets removed if we crash.
Daniel Dunbare326f9b2011-01-31 22:00:42 +0000699 if (RemoveFileOnSignal)
Rafael Espindola18556de2013-06-13 21:02:40 +0000700 llvm::sys::RemoveFileOnSignal(OSFile);
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000701
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000702 if (ResultPathName)
703 *ResultPathName = OutFile;
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000704 if (TempPathName)
705 *TempPathName = TempFile;
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000706
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000707 if (!Binary || OS->supportsSeeking())
708 return std::move(OS);
709
710 auto B = llvm::make_unique<llvm::buffer_ostream>(*OS);
711 assert(!NonSeekStream);
712 NonSeekStream = std::move(OS);
713 return std::move(B);
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000714}
Daniel Dunbar409e8902009-11-14 07:53:04 +0000715
716// Initialization Utilities
717
Argyrios Kyrtzidis1b3240b2012-11-09 19:40:33 +0000718bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
Nico Weber2ca4be92016-03-01 23:16:44 +0000719 return InitializeSourceManager(
720 Input, getDiagnostics(), getFileManager(), getSourceManager(),
721 hasPreprocessor() ? &getPreprocessor().getHeaderSearchInfo() : nullptr,
Nico Weber4b5aede2016-03-13 02:44:13 +0000722 getDependencyOutputOpts(), getFrontendOpts());
Daniel Dunbar409e8902009-11-14 07:53:04 +0000723}
724
Nico Weber2ca4be92016-03-01 23:16:44 +0000725// static
Nico Weber4b5aede2016-03-13 02:44:13 +0000726bool CompilerInstance::InitializeSourceManager(
727 const FrontendInputFile &Input, DiagnosticsEngine &Diags,
728 FileManager &FileMgr, SourceManager &SourceMgr, HeaderSearch *HS,
729 DependencyOutputOptions &DepOpts, const FrontendOptions &Opts) {
Argyrios Kyrtzidis1b3240b2012-11-09 19:40:33 +0000730 SrcMgr::CharacteristicKind
Argyrios Kyrtzidis873c8582012-11-09 19:40:39 +0000731 Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
Argyrios Kyrtzidis1b3240b2012-11-09 19:40:33 +0000732
Argyrios Kyrtzidis6566e232012-11-09 19:40:45 +0000733 if (Input.isBuffer()) {
David Blaikie50a5f972014-08-29 07:59:55 +0000734 SourceMgr.setMainFileID(SourceMgr.createFileID(
735 std::unique_ptr<llvm::MemoryBuffer>(Input.getBuffer()), Kind));
Yaron Keren8b563662015-10-03 10:46:20 +0000736 assert(SourceMgr.getMainFileID().isValid() &&
Argyrios Kyrtzidis6566e232012-11-09 19:40:45 +0000737 "Couldn't establish MainFileID!");
738 return true;
739 }
740
741 StringRef InputFile = Input.getFile();
742
Argyrios Kyrtzidis7c06d862011-09-19 20:40:35 +0000743 // Figure out where to get and map in the main file.
744 if (InputFile != "-") {
Nico Weber2ca4be92016-03-01 23:16:44 +0000745 const FileEntry *File;
746 if (Opts.FindPchSource.empty()) {
747 File = FileMgr.getFile(InputFile, /*OpenFile=*/true);
748 } else {
749 // When building a pch file in clang-cl mode, the .h file is built as if
750 // it was included by a cc file. Since the driver doesn't know about
751 // all include search directories, the frontend must search the input
752 // file through HeaderSearch here, as if it had been included by the
753 // cc file at Opts.FindPchSource.
754 const FileEntry *FindFile = FileMgr.getFile(Opts.FindPchSource);
755 if (!FindFile) {
756 Diags.Report(diag::err_fe_error_reading) << Opts.FindPchSource;
757 return false;
758 }
759 const DirectoryLookup *UnusedCurDir;
760 SmallVector<std::pair<const FileEntry *, const DirectoryEntry *>, 16>
761 Includers;
762 Includers.push_back(std::make_pair(FindFile, FindFile->getDir()));
763 File = HS->LookupFile(InputFile, SourceLocation(), /*isAngled=*/false,
764 /*FromDir=*/nullptr,
765 /*CurDir=*/UnusedCurDir, Includers,
766 /*SearchPath=*/nullptr,
767 /*RelativePath=*/nullptr,
768 /*RequestingModule=*/nullptr,
769 /*SuggestedModule=*/nullptr, /*SkipCache=*/true);
Nico Weber4b5aede2016-03-13 02:44:13 +0000770 // Also add the header to /showIncludes output.
771 if (File)
Nico Weberf54146c2016-03-23 18:46:57 +0000772 DepOpts.ShowIncludesPretendHeader = File->getName();
Nico Weber2ca4be92016-03-01 23:16:44 +0000773 }
Dan Gohman52765212010-10-26 21:13:51 +0000774 if (!File) {
Daniel Dunbar409e8902009-11-14 07:53:04 +0000775 Diags.Report(diag::err_fe_error_reading) << InputFile;
776 return false;
777 }
Daniel Dunbare2951f42012-11-05 22:53:33 +0000778
779 // The natural SourceManager infrastructure can't currently handle named
780 // pipes, but we would at least like to accept them for the main
Benjamin Kramer3841fa32013-08-12 13:46:52 +0000781 // file. Detect them here, read them with the volatile flag so FileMgr will
782 // pick up the correct size, and simply override their contents as we do for
783 // STDIN.
Daniel Dunbare2951f42012-11-05 22:53:33 +0000784 if (File->isNamedPipe()) {
Benjamin Kramera8857962014-10-26 22:44:13 +0000785 auto MB = FileMgr.getBufferForFile(File, /*isVolatile=*/true);
786 if (MB) {
Benjamin Kramer3841fa32013-08-12 13:46:52 +0000787 // Create a new virtual file that will have the correct size.
Benjamin Kramera8857962014-10-26 22:44:13 +0000788 File = FileMgr.getVirtualFile(InputFile, (*MB)->getBufferSize(), 0);
789 SourceMgr.overrideFileContents(File, std::move(*MB));
Benjamin Kramer3841fa32013-08-12 13:46:52 +0000790 } else {
Benjamin Kramera8857962014-10-26 22:44:13 +0000791 Diags.Report(diag::err_cannot_open_file) << InputFile
792 << MB.getError().message();
Daniel Dunbare2951f42012-11-05 22:53:33 +0000793 return false;
794 }
Daniel Dunbare2951f42012-11-05 22:53:33 +0000795 }
Daniel Dunbardb0745a2012-11-27 00:04:16 +0000796
Alp Tokerb671e342014-05-21 01:12:41 +0000797 SourceMgr.setMainFileID(
798 SourceMgr.createFileID(File, SourceLocation(), Kind));
Daniel Dunbar409e8902009-11-14 07:53:04 +0000799 } else {
Rafael Espindola2d2b4202014-07-06 17:43:24 +0000800 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> SBOrErr =
801 llvm::MemoryBuffer::getSTDIN();
802 if (std::error_code EC = SBOrErr.getError()) {
803 Diags.Report(diag::err_fe_error_reading_stdin) << EC.message();
Daniel Dunbar409e8902009-11-14 07:53:04 +0000804 return false;
805 }
Rafael Espindola2d2b4202014-07-06 17:43:24 +0000806 std::unique_ptr<llvm::MemoryBuffer> SB = std::move(SBOrErr.get());
807
Dan Gohman2f76cd72010-10-26 23:21:25 +0000808 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
Chris Lattner5159f612010-11-23 08:35:12 +0000809 SB->getBufferSize(), 0);
Alp Tokerb671e342014-05-21 01:12:41 +0000810 SourceMgr.setMainFileID(
811 SourceMgr.createFileID(File, SourceLocation(), Kind));
David Blaikie49cc3182014-08-27 20:54:45 +0000812 SourceMgr.overrideFileContents(File, std::move(SB));
Daniel Dunbar409e8902009-11-14 07:53:04 +0000813 }
814
Yaron Keren8b563662015-10-03 10:46:20 +0000815 assert(SourceMgr.getMainFileID().isValid() &&
Dan Gohman52765212010-10-26 21:13:51 +0000816 "Couldn't establish MainFileID!");
Daniel Dunbar409e8902009-11-14 07:53:04 +0000817 return true;
818}
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000819
820// High-Level Operations
821
822bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
823 assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
824 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
825 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
826
827 // FIXME: Take this as an argument, once all the APIs we used have moved to
828 // taking it as an input instead of hard-coding llvm::errs.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000829 raw_ostream &OS = llvm::errs();
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000830
831 // Create the target instance.
Alp Toker80758082014-07-06 05:26:44 +0000832 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(),
Saleem Abdulrasool724275ba2016-04-07 05:41:11 +0000833 getInvocation().TargetOpts,
834 getInvocation().getCodeGenOpts()));
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000835 if (!hasTarget())
836 return false;
837
Artem Belevichb5bc9232015-09-22 17:23:22 +0000838 // Create TargetInfo for the other side of CUDA compilation.
839 if (getLangOpts().CUDA && !getFrontendOpts().AuxTriple.empty()) {
840 std::shared_ptr<TargetOptions> TO(new TargetOptions);
841 TO->Triple = getFrontendOpts().AuxTriple;
Saleem Abdulrasool724275ba2016-04-07 05:41:11 +0000842 setAuxTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), TO,
843 getInvocation().getCodeGenOpts()));
Artem Belevichb5bc9232015-09-22 17:23:22 +0000844 }
845
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000846 // Inform the target of the language options.
847 //
848 // FIXME: We shouldn't need to do this, the target should be immutable once
849 // created. This complexity should be lifted elsewhere.
Alp Toker74437972014-07-06 05:14:24 +0000850 getTarget().adjust(getLangOpts());
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000851
Fariborz Jahanian29898f42012-04-16 21:03:30 +0000852 // rewriter project will change target built-in bool type from its default.
853 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
854 getTarget().noSignedCharForObjCBool();
855
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000856 // Validate/process some options.
857 if (getHeaderSearchOpts().Verbose)
858 OS << "clang -cc1 version " CLANG_VERSION_STRING
Alp Tokerf988d002014-06-06 10:36:22 +0000859 << " based upon " << BACKEND_PACKAGE_STRING
Sebastian Pop8188c8a2011-11-01 21:33:06 +0000860 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000861
862 if (getFrontendOpts().ShowTimers)
863 createFrontendTimer();
864
Douglas Gregor171b7802010-03-30 17:33:59 +0000865 if (getFrontendOpts().ShowStats)
866 llvm::EnableStatistics();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000867
Vedant Kumar5b60ad62015-11-16 00:59:34 +0000868 for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) {
Ted Kremenekeeccb302014-08-27 15:14:15 +0000869 // Reset the ID tables if we are reusing the SourceManager and parsing
870 // regular files.
871 if (hasSourceManager() && !Act.isModelParsingAction())
Daniel Dunbaraed46fc2010-06-07 23:23:50 +0000872 getSourceManager().clearIDTables();
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000873
Vedant Kumar5b60ad62015-11-16 00:59:34 +0000874 if (Act.BeginSourceFile(*this, FIF)) {
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000875 Act.Execute();
876 Act.EndSourceFile();
877 }
878 }
879
Argyrios Kyrtzidis7910d7b2011-12-07 05:52:12 +0000880 // Notify the diagnostic client that all files were processed.
881 getDiagnostics().getClient()->finish();
882
Chris Lattner198cb4d2010-04-07 18:47:42 +0000883 if (getDiagnosticOpts().ShowCarets) {
Argyrios Kyrtzidisc79346a2010-11-18 20:06:46 +0000884 // We can have multiple diagnostics sharing one diagnostic client.
885 // Get the total number of warnings/errors from the client.
886 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
887 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000888
Chris Lattner198cb4d2010-04-07 18:47:42 +0000889 if (NumWarnings)
890 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
891 if (NumWarnings && NumErrors)
892 OS << " and ";
893 if (NumErrors)
894 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
895 if (NumWarnings || NumErrors)
896 OS << " generated.\n";
897 }
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000898
Daniel Dunbaraed46fc2010-06-07 23:23:50 +0000899 if (getFrontendOpts().ShowStats && hasFileManager()) {
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000900 getFileManager().PrintStats();
901 OS << "\n";
902 }
903
Argyrios Kyrtzidisbc467932010-11-18 21:13:57 +0000904 return !getDiagnostics().getClient()->getNumErrors();
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000905}
906
Douglas Gregorfaeb1d42011-09-12 23:31:24 +0000907/// \brief Determine the appropriate source input kind based on language
908/// options.
909static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
910 if (LangOpts.OpenCL)
911 return IK_OpenCL;
912 if (LangOpts.CUDA)
913 return IK_CUDA;
914 if (LangOpts.ObjC1)
915 return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
916 return LangOpts.CPlusPlus? IK_CXX : IK_C;
917}
918
Douglas Gregor514b6362011-11-29 19:06:37 +0000919/// \brief Compile a module file for the given module, using the options
Ben Langmuirb797d592014-07-19 16:29:28 +0000920/// provided by the importing compiler instance. Returns true if the module
921/// was built without errors.
922static bool compileModuleImpl(CompilerInstance &ImportingInstance,
923 SourceLocation ImportLoc,
924 Module *Module,
925 StringRef ModuleFileName) {
Douglas Gregor514b6362011-11-29 19:06:37 +0000926 ModuleMap &ModMap
927 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
928
Douglas Gregorfaeb1d42011-09-12 23:31:24 +0000929 // Construct a compiler invocation for creating this module.
Dylan Noblesmithc95d8192012-02-20 14:00:23 +0000930 IntrusiveRefCntPtr<CompilerInvocation> Invocation
Douglas Gregorfaeb1d42011-09-12 23:31:24 +0000931 (new CompilerInvocation(ImportingInstance.getInvocation()));
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000932
Douglas Gregorf545f672011-11-29 21:59:16 +0000933 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
934
Douglas Gregor44bf68d2011-09-15 20:53:28 +0000935 // For any options that aren't intended to affect how a module is built,
936 // reset them to their default values.
Ted Kremenek8cf47df2011-11-17 23:01:24 +0000937 Invocation->getLangOpts()->resetNonModularOptions();
Douglas Gregorf545f672011-11-29 21:59:16 +0000938 PPOpts.resetNonModularOptions();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000939
Douglas Gregor5dc38992013-02-07 00:21:12 +0000940 // Remove any macro definitions that are explicitly ignored by the module.
941 // They aren't supposed to affect how the module is built anyway.
942 const HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
Benjamin Kramerbbdd7642014-03-01 14:48:57 +0000943 PPOpts.Macros.erase(
944 std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
945 [&HSOpts](const std::pair<std::string, bool> &def) {
946 StringRef MacroDef = def.first;
947 return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0;
948 }),
949 PPOpts.Macros.end());
Douglas Gregor5dc38992013-02-07 00:21:12 +0000950
Douglas Gregor7d106e42011-11-15 19:35:01 +0000951 // Note the name of the module we're building.
Douglas Gregor6dc57922011-11-29 18:31:39 +0000952 Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
Douglas Gregor7d106e42011-11-15 19:35:01 +0000953
Douglas Gregor7a626572012-11-29 23:55:25 +0000954 // Make sure that the failed-module structure has been allocated in
955 // the importing instance, and propagate the pointer to the newly-created
956 // instance.
957 PreprocessorOptions &ImportingPPOpts
958 = ImportingInstance.getInvocation().getPreprocessorOpts();
959 if (!ImportingPPOpts.FailedModules)
960 ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet;
961 PPOpts.FailedModules = ImportingPPOpts.FailedModules;
962
Douglas Gregorf545f672011-11-29 21:59:16 +0000963 // If there is a module map file, build the module using the module map.
Douglas Gregor44bf68d2011-09-15 20:53:28 +0000964 // Set up the inputs/outputs so that we build the module from its umbrella
965 // header.
Douglas Gregorfaeb1d42011-09-12 23:31:24 +0000966 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
Douglas Gregor1735f4e2011-09-13 23:15:45 +0000967 FrontendOpts.OutputFile = ModuleFileName.str();
Douglas Gregorfaeb1d42011-09-12 23:31:24 +0000968 FrontendOpts.DisableFree = false;
Douglas Gregorc1bbec82013-01-25 00:45:27 +0000969 FrontendOpts.GenerateGlobalModuleIndex = false;
Richard Smithe75ee0f2015-08-17 07:13:32 +0000970 FrontendOpts.BuildingImplicitModule = true;
Douglas Gregorfaeb1d42011-09-12 23:31:24 +0000971 FrontendOpts.Inputs.clear();
Douglas Gregorf545f672011-11-29 21:59:16 +0000972 InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000973
Douglas Gregorf545f672011-11-29 21:59:16 +0000974 // Don't free the remapped file buffers; they are owned by our caller.
975 PPOpts.RetainRemappedFileBuffers = true;
976
Douglas Gregor2b9b4642011-09-13 01:26:44 +0000977 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
Douglas Gregor3728ea72011-09-13 23:20:27 +0000978 assert(ImportingInstance.getInvocation().getModuleHash() ==
Douglas Gregorf545f672011-11-29 21:59:16 +0000979 Invocation->getModuleHash() && "Module hash mismatch!");
980
Douglas Gregorfaeb1d42011-09-12 23:31:24 +0000981 // Construct a compiler instance that will be used to actually create the
982 // module.
Adrian Prantlbb165fb2015-06-20 18:53:08 +0000983 CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
984 /*BuildingModule=*/true);
Douglas Gregorfaeb1d42011-09-12 23:31:24 +0000985 Instance.setInvocation(&*Invocation);
Douglas Gregor6b930962013-05-03 22:58:43 +0000986
987 Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
988 ImportingInstance.getDiagnosticClient()),
Douglas Gregor30071cea2013-05-03 23:07:45 +0000989 /*ShouldOwnClient=*/true);
Douglas Gregoraf8f0262012-11-30 18:38:50 +0000990
Ben Langmuirc8130a72014-02-20 21:59:23 +0000991 Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
992
Douglas Gregor63365432012-11-30 22:11:57 +0000993 // Note that this module is part of the module build stack, so that we
Douglas Gregoraf8f0262012-11-30 18:38:50 +0000994 // can detect cycles in the module graph.
Ben Langmuird066d4c2014-02-28 21:16:07 +0000995 Instance.setFileManager(&ImportingInstance.getFileManager());
Douglas Gregoraf8f0262012-11-30 18:38:50 +0000996 Instance.createSourceManager(Instance.getFileManager());
997 SourceManager &SourceMgr = Instance.getSourceManager();
Douglas Gregor63365432012-11-30 22:11:57 +0000998 SourceMgr.setModuleBuildStack(
999 ImportingInstance.getSourceManager().getModuleBuildStack());
1000 SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(),
Douglas Gregoraf8f0262012-11-30 18:38:50 +00001001 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
1002
Justin Bogner86d12592014-06-19 19:36:03 +00001003 // If we're collecting module dependencies, we need to share a collector
Richard Smith38c1e6d2015-08-09 06:03:55 +00001004 // between all of the module CompilerInstances. Other than that, we don't
1005 // want to produce any dependency output from the module build.
Justin Bogner86d12592014-06-19 19:36:03 +00001006 Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
Richard Smith38c1e6d2015-08-09 06:03:55 +00001007 Invocation->getDependencyOutputOpts() = DependencyOutputOptions();
Justin Bogner86d12592014-06-19 19:36:03 +00001008
Manuel Klimek1f76c4e2013-10-24 07:51:24 +00001009 // Get or create the module map that we'll use to build this module.
1010 std::string InferredModuleMapContent;
1011 if (const FileEntry *ModuleMapFile =
1012 ModMap.getContainingModuleMapFile(Module)) {
1013 // Use the module map where this module resides.
Benjamin Kramer3204b152015-05-29 19:42:19 +00001014 FrontendOpts.Inputs.emplace_back(ModuleMapFile->getName(), IK);
Manuel Klimek1f76c4e2013-10-24 07:51:24 +00001015 } else {
Richard Smith2b63d152015-05-16 02:28:53 +00001016 SmallString<128> FakeModuleMapFile(Module->Directory->getName());
1017 llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map");
Benjamin Kramer3204b152015-05-29 19:42:19 +00001018 FrontendOpts.Inputs.emplace_back(FakeModuleMapFile, IK);
Richard Smith2b63d152015-05-16 02:28:53 +00001019
Manuel Klimek1f76c4e2013-10-24 07:51:24 +00001020 llvm::raw_string_ostream OS(InferredModuleMapContent);
1021 Module->print(OS);
1022 OS.flush();
Manuel Klimek1f76c4e2013-10-24 07:51:24 +00001023
Rafael Espindolad87f8d72014-08-27 20:03:29 +00001024 std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
Manuel Klimek1f76c4e2013-10-24 07:51:24 +00001025 llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
1026 ModuleMapFile = Instance.getFileManager().getVirtualFile(
Richard Smith2b63d152015-05-16 02:28:53 +00001027 FakeModuleMapFile, InferredModuleMapContent.size(), 0);
David Blaikie49cc3182014-08-27 20:54:45 +00001028 SourceMgr.overrideFileContents(ModuleMapFile, std::move(ModuleMapBuffer));
Manuel Klimek1f76c4e2013-10-24 07:51:24 +00001029 }
Douglas Gregoraf8f0262012-11-30 18:38:50 +00001030
Ben Langmuir9d6448b2014-08-09 00:57:23 +00001031 // Construct a module-generating action. Passing through the module map is
Ben Langmuirbeee15e2014-04-14 18:00:01 +00001032 // safe because the FileManager is shared between the compiler instances.
Ben Langmuir9d6448b2014-08-09 00:57:23 +00001033 GenerateModuleAction CreateModuleAction(
1034 ModMap.getModuleMapFileForUniquing(Module), Module->IsSystem);
Richard Smith99891da2014-10-14 02:08:30 +00001035
1036 ImportingInstance.getDiagnostics().Report(ImportLoc,
1037 diag::remark_module_build)
1038 << Module->Name << ModuleFileName;
1039
Douglas Gregor51e0b542011-10-04 00:21:21 +00001040 // Execute the action to actually build the module in-place. Use a separate
1041 // thread so that we get a stack large enough.
1042 const unsigned ThreadStackSize = 8 << 20;
1043 llvm::CrashRecoveryContext CRC;
Richard Smith841f1c72014-03-04 21:50:01 +00001044 CRC.RunSafelyOnThread([&]() { Instance.ExecuteAction(CreateModuleAction); },
1045 ThreadStackSize);
Douglas Gregor6b930962013-05-03 22:58:43 +00001046
Richard Smith99891da2014-10-14 02:08:30 +00001047 ImportingInstance.getDiagnostics().Report(ImportLoc,
1048 diag::remark_module_build_done)
1049 << Module->Name;
1050
Douglas Gregorf545f672011-11-29 21:59:16 +00001051 // Delete the temporary module map file.
1052 // FIXME: Even though we're executing under crash protection, it would still
1053 // be nice to do this with RemoveFileOnSignal when we can. However, that
1054 // doesn't make sense for all clients, so clean this up manually.
Benjamin Kramer13afbf42012-10-14 19:50:53 +00001055 Instance.clearOutputFiles(/*EraseFiles=*/true);
Douglas Gregor5e306b12013-01-23 22:38:11 +00001056
1057 // We've rebuilt a module. If we're allowed to generate or update the global
1058 // module index, record that fact in the importing compiler instance.
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001059 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
Douglas Gregor5e306b12013-01-23 22:38:11 +00001060 ImportingInstance.setBuildGlobalModuleIndex(true);
1061 }
Ben Langmuirb797d592014-07-19 16:29:28 +00001062
1063 return !Instance.getDiagnostics().hasErrorOccurred();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001064}
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001065
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001066static bool compileAndLoadModule(CompilerInstance &ImportingInstance,
1067 SourceLocation ImportLoc,
Ben Langmuirb797d592014-07-19 16:29:28 +00001068 SourceLocation ModuleNameLoc, Module *Module,
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001069 StringRef ModuleFileName) {
Ben Langmuird213aab2014-09-26 22:42:23 +00001070 DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1071
Ben Langmuirb797d592014-07-19 16:29:28 +00001072 auto diagnoseBuildFailure = [&] {
Ben Langmuird213aab2014-09-26 22:42:23 +00001073 Diags.Report(ModuleNameLoc, diag::err_module_not_built)
Ben Langmuirb797d592014-07-19 16:29:28 +00001074 << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1075 };
1076
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001077 // FIXME: have LockFileManager return an error_code so that we can
1078 // avoid the mkdir when the directory already exists.
1079 StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
1080 llvm::sys::fs::create_directories(Dir);
1081
1082 while (1) {
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001083 unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001084 llvm::LockFileManager Locked(ModuleFileName);
1085 switch (Locked) {
1086 case llvm::LockFileManager::LFS_Error:
Ben Langmuird213aab2014-09-26 22:42:23 +00001087 Diags.Report(ModuleNameLoc, diag::err_module_lock_failure)
1088 << Module->Name;
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001089 return false;
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001090
1091 case llvm::LockFileManager::LFS_Owned:
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001092 // We're responsible for building the module ourselves.
Ben Langmuirb797d592014-07-19 16:29:28 +00001093 if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
1094 ModuleFileName)) {
1095 diagnoseBuildFailure();
1096 return false;
1097 }
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001098 break;
1099
1100 case llvm::LockFileManager::LFS_Shared:
1101 // Someone else is responsible for building the module. Wait for them to
1102 // finish.
Ben Langmuir1daf4802015-02-09 20:35:13 +00001103 switch (Locked.waitForUnlock()) {
1104 case llvm::LockFileManager::Res_Success:
1105 ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1106 break;
1107 case llvm::LockFileManager::Res_OwnerDied:
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001108 continue; // try again to get the lock.
Ben Langmuir1daf4802015-02-09 20:35:13 +00001109 case llvm::LockFileManager::Res_Timeout:
1110 Diags.Report(ModuleNameLoc, diag::err_module_lock_timeout)
1111 << Module->Name;
1112 // Clear the lock file so that future invokations can make progress.
1113 Locked.unsafeRemoveLockFile();
1114 return false;
1115 }
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001116 break;
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001117 }
1118
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001119 // Try to read the module file, now that we've compiled it.
1120 ASTReader::ASTReadResult ReadResult =
1121 ImportingInstance.getModuleManager()->ReadAST(
Richard Smithe842a472014-10-22 02:05:46 +00001122 ModuleFileName, serialization::MK_ImplicitModule, ImportLoc,
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001123 ModuleLoadCapabilities);
1124
1125 if (ReadResult == ASTReader::OutOfDate &&
1126 Locked == llvm::LockFileManager::LFS_Shared) {
1127 // The module may be out of date in the presence of file system races,
1128 // or if one of its imports depends on header search paths that are not
1129 // consistent with this ImportingInstance. Try again...
1130 continue;
1131 } else if (ReadResult == ASTReader::Missing) {
Ben Langmuirb797d592014-07-19 16:29:28 +00001132 diagnoseBuildFailure();
Ben Langmuird213aab2014-09-26 22:42:23 +00001133 } else if (ReadResult != ASTReader::Success &&
1134 !Diags.hasErrorOccurred()) {
1135 // The ASTReader didn't diagnose the error, so conservatively report it.
1136 diagnoseBuildFailure();
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001137 }
1138 return ReadResult == ASTReader::Success;
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001139 }
1140}
1141
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001142/// \brief Diagnose differences between the current definition of the given
1143/// configuration macro and the definition provided on the command line.
1144static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1145 Module *Mod, SourceLocation ImportLoc) {
1146 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
1147 SourceManager &SourceMgr = PP.getSourceManager();
1148
1149 // If this identifier has never had a macro definition, then it could
1150 // not have changed.
1151 if (!Id->hadMacroDefinition())
1152 return;
Richard Smith20e883e2015-04-29 23:20:19 +00001153 auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id);
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001154
Richard Smith20e883e2015-04-29 23:20:19 +00001155 // Find the macro definition from the command line.
1156 MacroInfo *CmdLineDefinition = nullptr;
1157 for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001158 // We only care about the predefines buffer.
Richard Smith20e883e2015-04-29 23:20:19 +00001159 FileID FID = SourceMgr.getFileID(MD->getLocation());
1160 if (FID.isInvalid() || FID != PP.getPredefinesFileID())
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001161 continue;
Richard Smith20e883e2015-04-29 23:20:19 +00001162 if (auto *DMD = dyn_cast<DefMacroDirective>(MD))
1163 CmdLineDefinition = DMD->getMacroInfo();
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001164 break;
1165 }
1166
Richard Smith20e883e2015-04-29 23:20:19 +00001167 auto *CurrentDefinition = PP.getMacroInfo(Id);
1168 if (CurrentDefinition == CmdLineDefinition) {
1169 // Macro matches. Nothing to do.
1170 } else if (!CurrentDefinition) {
1171 // This macro was defined on the command line, then #undef'd later.
1172 // Complain.
1173 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1174 << true << ConfigMacro << Mod->getFullModuleName();
1175 auto LatestDef = LatestLocalMD->getDefinition();
1176 assert(LatestDef.isUndefined() &&
1177 "predefined macro went away with no #undef?");
1178 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1179 << true;
1180 return;
1181 } else if (!CmdLineDefinition) {
1182 // There was no definition for this macro in the predefines buffer,
1183 // but there was a local definition. Complain.
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001184 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1185 << false << ConfigMacro << Mod->getFullModuleName();
Richard Smith20e883e2015-04-29 23:20:19 +00001186 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1187 diag::note_module_def_undef_here)
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001188 << false;
Richard Smith20e883e2015-04-29 23:20:19 +00001189 } else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,
1190 /*Syntactically=*/true)) {
1191 // The macro definitions differ.
1192 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1193 << false << ConfigMacro << Mod->getFullModuleName();
1194 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1195 diag::note_module_def_undef_here)
1196 << false;
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001197 }
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001198}
1199
Douglas Gregor527b1c92013-03-25 21:19:16 +00001200/// \brief Write a new timestamp file with the given path.
1201static void writeTimestampFile(StringRef TimestampFile) {
Rafael Espindoladae941a2014-08-25 18:17:04 +00001202 std::error_code EC;
1203 llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None);
Douglas Gregor527b1c92013-03-25 21:19:16 +00001204}
1205
1206/// \brief Prune the module cache of modules that haven't been accessed in
1207/// a long time.
1208static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1209 struct stat StatBuf;
1210 llvm::SmallString<128> TimestampFile;
1211 TimestampFile = HSOpts.ModuleCachePath;
Richard Smith3938f0c2015-08-15 00:34:15 +00001212 assert(!TimestampFile.empty());
Douglas Gregor527b1c92013-03-25 21:19:16 +00001213 llvm::sys::path::append(TimestampFile, "modules.timestamp");
1214
1215 // Try to stat() the timestamp file.
1216 if (::stat(TimestampFile.c_str(), &StatBuf)) {
1217 // If the timestamp file wasn't there, create one now.
1218 if (errno == ENOENT) {
1219 writeTimestampFile(TimestampFile);
1220 }
1221 return;
1222 }
1223
1224 // Check whether the time stamp is older than our pruning interval.
1225 // If not, do nothing.
1226 time_t TimeStampModTime = StatBuf.st_mtime;
Craig Topper49a27902014-05-22 04:46:25 +00001227 time_t CurrentTime = time(nullptr);
Benjamin Kramerdbcf5032013-03-29 17:39:43 +00001228 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
Douglas Gregor527b1c92013-03-25 21:19:16 +00001229 return;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001230
1231 // Write a new timestamp file so that nobody else attempts to prune.
1232 // There is a benign race condition here, if two Clang instances happen to
1233 // notice at the same time that the timestamp is out-of-date.
1234 writeTimestampFile(TimestampFile);
1235
1236 // Walk the entire module cache, looking for unused module files and module
1237 // indices.
Rafael Espindolac0809172014-06-12 14:02:15 +00001238 std::error_code EC;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001239 SmallString<128> ModuleCachePathNative;
1240 llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
Yaron Keren92e1b622015-03-18 10:17:07 +00001241 for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001242 Dir != DirEnd && !EC; Dir.increment(EC)) {
1243 // If we don't have a directory, there's nothing to look into.
Rafael Espindolaa07f7202013-07-17 04:23:07 +00001244 if (!llvm::sys::fs::is_directory(Dir->path()))
Douglas Gregor527b1c92013-03-25 21:19:16 +00001245 continue;
1246
1247 // Walk all of the files within this directory.
Douglas Gregor527b1c92013-03-25 21:19:16 +00001248 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1249 File != FileEnd && !EC; File.increment(EC)) {
1250 // We only care about module and global module index files.
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001251 StringRef Extension = llvm::sys::path::extension(File->path());
1252 if (Extension != ".pcm" && Extension != ".timestamp" &&
1253 llvm::sys::path::filename(File->path()) != "modules.idx")
Douglas Gregor527b1c92013-03-25 21:19:16 +00001254 continue;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001255
1256 // Look at this file. If we can't stat it, there's nothing interesting
1257 // there.
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001258 if (::stat(File->path().c_str(), &StatBuf))
Douglas Gregor527b1c92013-03-25 21:19:16 +00001259 continue;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001260
1261 // If the file has been used recently enough, leave it there.
1262 time_t FileAccessTime = StatBuf.st_atime;
Benjamin Kramerdbcf5032013-03-29 17:39:43 +00001263 if (CurrentTime - FileAccessTime <=
1264 time_t(HSOpts.ModuleCachePruneAfter)) {
Douglas Gregor527b1c92013-03-25 21:19:16 +00001265 continue;
1266 }
1267
1268 // Remove the file.
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001269 llvm::sys::fs::remove(File->path());
1270
1271 // Remove the timestamp file.
1272 std::string TimpestampFilename = File->path() + ".timestamp";
1273 llvm::sys::fs::remove(TimpestampFilename);
Douglas Gregor527b1c92013-03-25 21:19:16 +00001274 }
1275
1276 // If we removed all of the files in the directory, remove the directory
1277 // itself.
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001278 if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1279 llvm::sys::fs::directory_iterator() && !EC)
Rafael Espindola2a008782014-01-10 21:32:14 +00001280 llvm::sys::fs::remove(Dir->path());
Douglas Gregor527b1c92013-03-25 21:19:16 +00001281 }
1282}
1283
John Thompson2255f2c2014-04-23 12:57:01 +00001284void CompilerInstance::createModuleManager() {
1285 if (!ModuleManager) {
1286 if (!hasASTContext())
1287 createASTContext();
1288
Chandler Carruth580dd292015-03-24 21:44:25 +00001289 // If we're implicitly building modules but not currently recursively
1290 // building a module, check whether we need to prune the module cache.
Richard Smith3938f0c2015-08-15 00:34:15 +00001291 if (getSourceManager().getModuleBuildStack().empty() &&
1292 !getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty() &&
John Thompson2255f2c2014-04-23 12:57:01 +00001293 getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1294 getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1295 pruneModuleCache(getHeaderSearchOpts());
1296 }
1297
1298 HeaderSearchOptions &HSOpts = getHeaderSearchOpts();
1299 std::string Sysroot = HSOpts.Sysroot;
1300 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
Richard Smithce18a182015-07-14 00:26:00 +00001301 std::unique_ptr<llvm::Timer> ReadTimer;
1302 if (FrontendTimerGroup)
1303 ReadTimer = llvm::make_unique<llvm::Timer>("Reading modules",
1304 *FrontendTimerGroup);
Adrian Prantlbb165fb2015-06-20 18:53:08 +00001305 ModuleManager = new ASTReader(
Richard Smith293534b2015-08-18 20:39:29 +00001306 getPreprocessor(), getASTContext(), getPCHContainerReader(),
Douglas Gregor6623e1f2015-11-03 18:33:07 +00001307 getFrontendOpts().ModuleFileExtensions,
Adrian Prantlbb165fb2015-06-20 18:53:08 +00001308 Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation,
1309 /*AllowASTWithCompilerErrors=*/false,
1310 /*AllowConfigurationMismatch=*/false,
1311 HSOpts.ModulesValidateSystemHeaders,
Richard Smithce18a182015-07-14 00:26:00 +00001312 getFrontendOpts().UseGlobalModuleIndex,
1313 std::move(ReadTimer));
John Thompson2255f2c2014-04-23 12:57:01 +00001314 if (hasASTConsumer()) {
1315 ModuleManager->setDeserializationListener(
1316 getASTConsumer().GetASTDeserializationListener());
1317 getASTContext().setASTMutationListener(
1318 getASTConsumer().GetASTMutationListener());
1319 }
1320 getASTContext().setExternalSource(ModuleManager);
1321 if (hasSema())
1322 ModuleManager->InitializeSema(getSema());
Richard Smith293534b2015-08-18 20:39:29 +00001323 if (hasASTConsumer())
John Thompson2255f2c2014-04-23 12:57:01 +00001324 ModuleManager->StartTranslationUnit(&getASTConsumer());
Richard Smith03f7e612015-08-09 02:28:42 +00001325
1326 if (TheDependencyFileGenerator)
1327 TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
Richard Smith03f7e612015-08-09 02:28:42 +00001328 for (auto &Listener : DependencyCollectors)
1329 Listener->attachToASTReader(*ModuleManager);
John Thompson2255f2c2014-04-23 12:57:01 +00001330 }
1331}
1332
Richard Smithd4b230b2014-10-27 23:01:16 +00001333bool CompilerInstance::loadModuleFile(StringRef FileName) {
Richard Smithce18a182015-07-14 00:26:00 +00001334 llvm::Timer Timer;
1335 if (FrontendTimerGroup)
1336 Timer.init("Preloading " + FileName.str(), *FrontendTimerGroup);
1337 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1338
Richard Smithd4b230b2014-10-27 23:01:16 +00001339 // Helper to recursively read the module names for all modules we're adding.
1340 // We mark these as known and redirect any attempt to load that module to
1341 // the files we were handed.
1342 struct ReadModuleNames : ASTReaderListener {
1343 CompilerInstance &CI;
Richard Smith0f99d6a2015-08-09 08:48:41 +00001344 llvm::SmallVector<IdentifierInfo*, 8> LoadedModules;
Richard Smithe842a472014-10-22 02:05:46 +00001345
Richard Smith0f99d6a2015-08-09 08:48:41 +00001346 ReadModuleNames(CompilerInstance &CI) : CI(CI) {}
Richard Smithe842a472014-10-22 02:05:46 +00001347
Richard Smithd4b230b2014-10-27 23:01:16 +00001348 void ReadModuleName(StringRef ModuleName) override {
Richard Smith0f99d6a2015-08-09 08:48:41 +00001349 LoadedModules.push_back(
1350 CI.getPreprocessor().getIdentifierInfo(ModuleName));
Richard Smithd4b230b2014-10-27 23:01:16 +00001351 }
Richard Smith0f99d6a2015-08-09 08:48:41 +00001352
1353 void registerAll() {
1354 for (auto *II : LoadedModules) {
1355 CI.KnownModules[II] = CI.getPreprocessor()
1356 .getHeaderSearchInfo()
1357 .getModuleMap()
1358 .findModule(II->getName());
1359 }
1360 LoadedModules.clear();
1361 }
Richard Smith8a308ec2015-11-05 00:54:55 +00001362
1363 void markAllUnavailable() {
1364 for (auto *II : LoadedModules) {
1365 if (Module *M = CI.getPreprocessor()
1366 .getHeaderSearchInfo()
1367 .getModuleMap()
1368 .findModule(II->getName()))
1369 M->HasIncompatibleModuleFile = true;
1370 }
1371 LoadedModules.clear();
1372 }
Richard Smith0f99d6a2015-08-09 08:48:41 +00001373 };
Richard Smithd4b230b2014-10-27 23:01:16 +00001374
Richard Smith7f330cd2015-03-18 01:42:29 +00001375 // If we don't already have an ASTReader, create one now.
1376 if (!ModuleManager)
1377 createModuleManager();
1378
Richard Smith0f99d6a2015-08-09 08:48:41 +00001379 auto Listener = llvm::make_unique<ReadModuleNames>(*this);
1380 auto &ListenerRef = *Listener;
1381 ASTReader::ListenerScope ReadModuleNamesListener(*ModuleManager,
1382 std::move(Listener));
Richard Smith7f330cd2015-03-18 01:42:29 +00001383
Richard Smith0f99d6a2015-08-09 08:48:41 +00001384 // Try to load the module file.
Richard Smith95dc57a2015-10-16 23:20:19 +00001385 switch (ModuleManager->ReadAST(FileName, serialization::MK_ExplicitModule,
1386 SourceLocation(),
1387 ASTReader::ARR_ConfigurationMismatch)) {
1388 case ASTReader::Success:
Richard Smith8a308ec2015-11-05 00:54:55 +00001389 // We successfully loaded the module file; remember the set of provided
1390 // modules so that we don't try to load implicit modules for them.
1391 ListenerRef.registerAll();
1392 return true;
Richard Smith95dc57a2015-10-16 23:20:19 +00001393
1394 case ASTReader::ConfigurationMismatch:
1395 // Ignore unusable module files.
1396 getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch)
1397 << FileName;
Richard Smith8a308ec2015-11-05 00:54:55 +00001398 // All modules provided by any files we tried and failed to load are now
1399 // unavailable; includes of those modules should now be handled textually.
1400 ListenerRef.markAllUnavailable();
Richard Smith95dc57a2015-10-16 23:20:19 +00001401 return true;
1402
1403 default:
1404 return false;
1405 }
Richard Smithe842a472014-10-22 02:05:46 +00001406}
1407
1408ModuleLoadResult
Douglas Gregor7a626572012-11-29 23:55:25 +00001409CompilerInstance::loadModule(SourceLocation ImportLoc,
1410 ModuleIdPath Path,
1411 Module::NameVisibilityKind Visibility,
1412 bool IsInclusionDirective) {
Richard Smith92304e02013-10-18 22:48:20 +00001413 // Determine what file we're searching from.
1414 StringRef ModuleName = Path[0].first->getName();
1415 SourceLocation ModuleNameLoc = Path[0].second;
1416
Douglas Gregor1805b8a2011-11-30 04:26:53 +00001417 // If we've already handled this import, just return the cached result.
1418 // This one-element cache is important to eliminate redundant diagnostics
1419 // when both the preprocessor and parser see the same import declaration.
Yaron Keren8b563662015-10-03 10:46:20 +00001420 if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) {
Douglas Gregorff2be532011-12-01 17:11:21 +00001421 // Make the named module visible.
Richard Smith7e82e012016-02-19 22:25:36 +00001422 if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
Argyrios Kyrtzidis125df052013-02-01 16:36:12 +00001423 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
Richard Smitha7e2cc62015-05-01 01:53:09 +00001424 ImportLoc);
Douglas Gregor69021972011-11-30 17:33:56 +00001425 return LastModuleImportResult;
Douglas Gregorff2be532011-12-01 17:11:21 +00001426 }
Douglas Gregor5196bc62011-11-30 04:03:44 +00001427
Craig Topper49a27902014-05-22 04:46:25 +00001428 clang::Module *Module = nullptr;
Richard Smith92304e02013-10-18 22:48:20 +00001429
Douglas Gregor5196bc62011-11-30 04:03:44 +00001430 // If we don't already have information on this module, load the module now.
Douglas Gregorde3ef502011-11-30 23:21:26 +00001431 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
Douglas Gregor69021972011-11-30 17:33:56 +00001432 = KnownModules.find(Path[0].first);
Douglas Gregor2537a362011-12-08 17:01:29 +00001433 if (Known != KnownModules.end()) {
1434 // Retrieve the cached top-level module.
1435 Module = Known->second;
Richard Smith7e82e012016-02-19 22:25:36 +00001436 } else if (ModuleName == getLangOpts().CurrentModule) {
Douglas Gregor2537a362011-12-08 17:01:29 +00001437 // This is the module we're building.
Ben Langmuir527040e2014-05-05 05:31:33 +00001438 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
Douglas Gregor2537a362011-12-08 17:01:29 +00001439 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1440 } else {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001441 // Search for a module with the given name.
Douglas Gregor279a6c32012-01-29 17:08:11 +00001442 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
Ben Langmuir9eb229b2014-01-22 23:19:39 +00001443 if (!Module) {
1444 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1445 << ModuleName
1446 << SourceRange(ImportLoc, ModuleNameLoc);
1447 ModuleBuildFailed = true;
1448 return ModuleLoadResult();
1449 }
1450
Richard Smithd520a252015-07-21 18:07:47 +00001451 std::string ModuleFileName =
Richard Smith86cc8292015-08-09 08:58:36 +00001452 PP->getHeaderSearchInfo().getModuleFileName(Module);
Richard Smithd520a252015-07-21 18:07:47 +00001453 if (ModuleFileName.empty()) {
Richard Smith8a308ec2015-11-05 00:54:55 +00001454 if (Module->HasIncompatibleModuleFile) {
1455 // We tried and failed to load a module file for this module. Fall
1456 // back to textual inclusion for its headers.
1457 return ModuleLoadResult(nullptr, /*missingExpected*/true);
1458 }
1459
Manuel Klimekd2e8b042015-02-20 11:44:41 +00001460 getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
1461 << ModuleName;
1462 ModuleBuildFailed = true;
1463 return ModuleLoadResult();
1464 }
Richard Smithd4b230b2014-10-27 23:01:16 +00001465
Douglas Gregor5196bc62011-11-30 04:03:44 +00001466 // If we don't already have an ASTReader, create one now.
John Thompson2255f2c2014-04-23 12:57:01 +00001467 if (!ModuleManager)
1468 createModuleManager();
Douglas Gregor5196bc62011-11-30 04:03:44 +00001469
Richard Smithce18a182015-07-14 00:26:00 +00001470 llvm::Timer Timer;
1471 if (FrontendTimerGroup)
1472 Timer.init("Loading " + ModuleFileName, *FrontendTimerGroup);
1473 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1474
Douglas Gregor7029ce12013-03-19 00:28:20 +00001475 // Try to load the module file.
Richard Smith86cc8292015-08-09 08:58:36 +00001476 unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing;
Richard Smithe842a472014-10-22 02:05:46 +00001477 switch (ModuleManager->ReadAST(ModuleFileName,
Richard Smith86cc8292015-08-09 08:58:36 +00001478 serialization::MK_ImplicitModule,
Richard Smithd4b230b2014-10-27 23:01:16 +00001479 ImportLoc, ARRFlags)) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001480 case ASTReader::Success:
1481 break;
1482
Eli Friedman963ff2c2013-09-17 00:51:29 +00001483 case ASTReader::OutOfDate:
Douglas Gregor7029ce12013-03-19 00:28:20 +00001484 case ASTReader::Missing: {
Eli Friedman963ff2c2013-09-17 00:51:29 +00001485 // The module file is missing or out-of-date. Build it.
Ben Langmuir9eb229b2014-01-22 23:19:39 +00001486 assert(Module && "missing module file");
Douglas Gregor7029ce12013-03-19 00:28:20 +00001487 // Check whether there is a cycle in the module graph.
1488 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1489 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1490 for (; Pos != PosEnd; ++Pos) {
1491 if (Pos->first == ModuleName)
1492 break;
1493 }
1494
1495 if (Pos != PosEnd) {
1496 SmallString<256> CyclePath;
1497 for (; Pos != PosEnd; ++Pos) {
1498 CyclePath += Pos->first;
1499 CyclePath += " -> ";
1500 }
1501 CyclePath += ModuleName;
1502
1503 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1504 << ModuleName << CyclePath;
1505 return ModuleLoadResult();
1506 }
Douglas Gregor7a626572012-11-29 23:55:25 +00001507
1508 // Check whether we have already attempted to build this module (but
1509 // failed).
1510 if (getPreprocessorOpts().FailedModules &&
1511 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1512 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1513 << ModuleName
1514 << SourceRange(ImportLoc, ModuleNameLoc);
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001515 ModuleBuildFailed = true;
Douglas Gregor7a626572012-11-29 23:55:25 +00001516 return ModuleLoadResult();
1517 }
1518
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001519 // Try to compile and then load the module.
1520 if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module,
1521 ModuleFileName)) {
Ben Langmuird213aab2014-09-26 22:42:23 +00001522 assert(getDiagnostics().hasErrorOccurred() &&
1523 "undiagnosed error in compileAndLoadModule");
Douglas Gregor0f2b4632013-01-10 02:04:18 +00001524 if (getPreprocessorOpts().FailedModules)
1525 getPreprocessorOpts().FailedModules->addFailed(ModuleName);
Craig Topper49a27902014-05-22 04:46:25 +00001526 KnownModules[Path[0].first] = nullptr;
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001527 ModuleBuildFailed = true;
Douglas Gregor7a626572012-11-29 23:55:25 +00001528 return ModuleLoadResult();
Douglas Gregor188dbef2012-11-07 17:46:15 +00001529 }
1530
1531 // Okay, we've rebuilt and now loaded the module.
1532 break;
1533 }
1534
Douglas Gregorc9ad5fb2012-10-22 22:50:17 +00001535 case ASTReader::VersionMismatch:
1536 case ASTReader::ConfigurationMismatch:
1537 case ASTReader::HadErrors:
Argyrios Kyrtzidisdc9fdaf2013-05-24 05:44:08 +00001538 ModuleLoader::HadFatalFailure = true;
Richard Smith0f99d6a2015-08-09 08:48:41 +00001539 // FIXME: The ASTReader will already have complained, but can we shoehorn
Douglas Gregor5196bc62011-11-30 04:03:44 +00001540 // that diagnostic information into a more useful form?
Craig Topper49a27902014-05-22 04:46:25 +00001541 KnownModules[Path[0].first] = nullptr;
Douglas Gregor7a626572012-11-29 23:55:25 +00001542 return ModuleLoadResult();
Douglas Gregor5196bc62011-11-30 04:03:44 +00001543
1544 case ASTReader::Failure:
Argyrios Kyrtzidisdc9fdaf2013-05-24 05:44:08 +00001545 ModuleLoader::HadFatalFailure = true;
Douglas Gregor69021972011-11-30 17:33:56 +00001546 // Already complained, but note now that we failed.
Craig Topper49a27902014-05-22 04:46:25 +00001547 KnownModules[Path[0].first] = nullptr;
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001548 ModuleBuildFailed = true;
Douglas Gregor7a626572012-11-29 23:55:25 +00001549 return ModuleLoadResult();
Douglas Gregor5196bc62011-11-30 04:03:44 +00001550 }
Argyrios Kyrtzidis43af5132012-09-29 01:06:04 +00001551
Douglas Gregor69021972011-11-30 17:33:56 +00001552 // Cache the result of this top-level module lookup for later.
1553 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
Douglas Gregor08142532011-08-26 23:56:07 +00001554 }
Douglas Gregor5196bc62011-11-30 04:03:44 +00001555
Douglas Gregor69021972011-11-30 17:33:56 +00001556 // If we never found the module, fail.
1557 if (!Module)
Douglas Gregor7a626572012-11-29 23:55:25 +00001558 return ModuleLoadResult();
Douglas Gregor69021972011-11-30 17:33:56 +00001559
Douglas Gregor5196bc62011-11-30 04:03:44 +00001560 // Verify that the rest of the module path actually corresponds to
1561 // a submodule.
Douglas Gregor69021972011-11-30 17:33:56 +00001562 if (Path.size() > 1) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001563 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1564 StringRef Name = Path[I].first->getName();
Douglas Gregoreb90e832012-01-04 23:32:19 +00001565 clang::Module *Sub = Module->findSubmodule(Name);
Douglas Gregor5196bc62011-11-30 04:03:44 +00001566
Douglas Gregoreb90e832012-01-04 23:32:19 +00001567 if (!Sub) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001568 // Attempt to perform typo correction to find a module name that works.
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001569 SmallVector<StringRef, 2> Best;
Douglas Gregor5196bc62011-11-30 04:03:44 +00001570 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1571
Douglas Gregoreb90e832012-01-04 23:32:19 +00001572 for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1573 JEnd = Module->submodule_end();
Matt Beaumont-Gayeb44eda2011-11-30 19:41:21 +00001574 J != JEnd; ++J) {
Douglas Gregoreb90e832012-01-04 23:32:19 +00001575 unsigned ED = Name.edit_distance((*J)->Name,
Douglas Gregor5196bc62011-11-30 04:03:44 +00001576 /*AllowReplacements=*/true,
1577 BestEditDistance);
1578 if (ED <= BestEditDistance) {
Douglas Gregoreb90e832012-01-04 23:32:19 +00001579 if (ED < BestEditDistance) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001580 Best.clear();
Douglas Gregoreb90e832012-01-04 23:32:19 +00001581 BestEditDistance = ED;
1582 }
1583
1584 Best.push_back((*J)->Name);
Douglas Gregor5196bc62011-11-30 04:03:44 +00001585 }
1586 }
1587
1588 // If there was a clear winner, user it.
1589 if (Best.size() == 1) {
1590 getDiagnostics().Report(Path[I].second,
1591 diag::err_no_submodule_suggest)
Douglas Gregor69021972011-11-30 17:33:56 +00001592 << Path[I].first << Module->getFullModuleName() << Best[0]
Douglas Gregor5196bc62011-11-30 04:03:44 +00001593 << SourceRange(Path[0].second, Path[I-1].second)
1594 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1595 Best[0]);
Douglas Gregoreb90e832012-01-04 23:32:19 +00001596
1597 Sub = Module->findSubmodule(Best[0]);
Douglas Gregor5196bc62011-11-30 04:03:44 +00001598 }
1599 }
1600
Douglas Gregoreb90e832012-01-04 23:32:19 +00001601 if (!Sub) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001602 // No submodule by this name. Complain, and don't look for further
1603 // submodules.
1604 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
Douglas Gregor69021972011-11-30 17:33:56 +00001605 << Path[I].first << Module->getFullModuleName()
Douglas Gregor5196bc62011-11-30 04:03:44 +00001606 << SourceRange(Path[0].second, Path[I-1].second);
1607 break;
1608 }
1609
Douglas Gregoreb90e832012-01-04 23:32:19 +00001610 Module = Sub;
Douglas Gregor5196bc62011-11-30 04:03:44 +00001611 }
Douglas Gregor08142532011-08-26 23:56:07 +00001612 }
Ben Langmuirb537a3a2014-07-23 15:30:23 +00001613
Douglas Gregor2537a362011-12-08 17:01:29 +00001614 // Make the named module visible, if it's not already part of the module
1615 // we are parsing.
Douglas Gregor98a52db2011-12-20 00:28:52 +00001616 if (ModuleName != getLangOpts().CurrentModule) {
1617 if (!Module->IsFromModuleFile) {
1618 // We have an umbrella header or directory that doesn't actually include
1619 // all of the headers within the directory it covers. Complain about
1620 // this missing submodule and recover by forgetting that we ever saw
1621 // this submodule.
1622 // FIXME: Should we detect this at module load time? It seems fairly
1623 // expensive (and rare).
1624 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1625 << Module->getFullModuleName()
1626 << SourceRange(Path.front().second, Path.back().second);
Craig Topper49a27902014-05-22 04:46:25 +00001627
1628 return ModuleLoadResult(nullptr, true);
Douglas Gregor98a52db2011-12-20 00:28:52 +00001629 }
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00001630
1631 // Check whether this module is available.
Richard Smitha3feee22013-10-28 22:18:19 +00001632 clang::Module::Requirement Requirement;
Richard Smith3c1a41a2014-12-02 00:08:08 +00001633 clang::Module::UnresolvedHeaderDirective MissingHeader;
Daniel Jasper0761a8a2013-12-17 10:31:37 +00001634 if (!Module->isAvailable(getLangOpts(), getTarget(), Requirement,
1635 MissingHeader)) {
1636 if (MissingHeader.FileNameLoc.isValid()) {
1637 getDiagnostics().Report(MissingHeader.FileNameLoc,
1638 diag::err_module_header_missing)
1639 << MissingHeader.IsUmbrella << MissingHeader.FileName;
1640 } else {
1641 getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
1642 << Module->getFullModuleName()
1643 << Requirement.second << Requirement.first
1644 << SourceRange(Path.front().second, Path.back().second);
1645 }
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00001646 LastModuleImportLoc = ImportLoc;
Douglas Gregor7a626572012-11-29 23:55:25 +00001647 LastModuleImportResult = ModuleLoadResult();
1648 return ModuleLoadResult();
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00001649 }
1650
Richard Smitha7e2cc62015-05-01 01:53:09 +00001651 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
Douglas Gregor98a52db2011-12-20 00:28:52 +00001652 }
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001653
1654 // Check for any configuration macros that have changed.
1655 clang::Module *TopModule = Module->getTopLevelModule();
1656 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1657 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1658 Module, ImportLoc);
1659 }
1660
Douglas Gregor1805b8a2011-11-30 04:26:53 +00001661 LastModuleImportLoc = ImportLoc;
Douglas Gregor7a626572012-11-29 23:55:25 +00001662 LastModuleImportResult = ModuleLoadResult(Module, false);
1663 return LastModuleImportResult;
Douglas Gregor08142532011-08-26 23:56:07 +00001664}
Douglas Gregorc147b0b2013-01-12 01:29:50 +00001665
1666void CompilerInstance::makeModuleVisible(Module *Mod,
Argyrios Kyrtzidis125df052013-02-01 16:36:12 +00001667 Module::NameVisibilityKind Visibility,
Richard Smitha7e2cc62015-05-01 01:53:09 +00001668 SourceLocation ImportLoc) {
Richard Smith42413142015-05-15 20:05:43 +00001669 if (!ModuleManager)
1670 createModuleManager();
1671 if (!ModuleManager)
1672 return;
1673
Richard Smitha7e2cc62015-05-01 01:53:09 +00001674 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
Douglas Gregorc147b0b2013-01-12 01:29:50 +00001675}
1676
John Thompson2255f2c2014-04-23 12:57:01 +00001677GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex(
1678 SourceLocation TriggerLoc) {
Richard Smith3938f0c2015-08-15 00:34:15 +00001679 if (getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
1680 return nullptr;
John Thompson2255f2c2014-04-23 12:57:01 +00001681 if (!ModuleManager)
1682 createModuleManager();
1683 // Can't do anything if we don't have the module manager.
1684 if (!ModuleManager)
Craig Topper49a27902014-05-22 04:46:25 +00001685 return nullptr;
John Thompson2255f2c2014-04-23 12:57:01 +00001686 // Get an existing global index. This loads it if not already
1687 // loaded.
1688 ModuleManager->loadGlobalIndex();
1689 GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
1690 // If the global index doesn't exist, create it.
1691 if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
1692 hasPreprocessor()) {
1693 llvm::sys::fs::create_directories(
1694 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
1695 GlobalModuleIndex::writeIndex(
Adrian Prantlfb2398d2015-07-17 01:19:54 +00001696 getFileManager(), getPCHContainerReader(),
Adrian Prantlbb165fb2015-06-20 18:53:08 +00001697 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
John Thompson2255f2c2014-04-23 12:57:01 +00001698 ModuleManager->resetForReload();
1699 ModuleManager->loadGlobalIndex();
1700 GlobalIndex = ModuleManager->getGlobalIndex();
1701 }
1702 // For finding modules needing to be imported for fixit messages,
1703 // we need to make the global index cover all modules, so we do that here.
1704 if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
1705 ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap();
1706 bool RecreateIndex = false;
1707 for (ModuleMap::module_iterator I = MMap.module_begin(),
1708 E = MMap.module_end(); I != E; ++I) {
1709 Module *TheModule = I->second;
1710 const FileEntry *Entry = TheModule->getASTFile();
1711 if (!Entry) {
1712 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
1713 Path.push_back(std::make_pair(
Richard Smith629d8e62015-08-11 00:03:28 +00001714 getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
John Thompson2255f2c2014-04-23 12:57:01 +00001715 std::reverse(Path.begin(), Path.end());
Richard Smith629d8e62015-08-11 00:03:28 +00001716 // Load a module as hidden. This also adds it to the global index.
1717 loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false);
John Thompson2255f2c2014-04-23 12:57:01 +00001718 RecreateIndex = true;
1719 }
1720 }
1721 if (RecreateIndex) {
1722 GlobalModuleIndex::writeIndex(
Adrian Prantlfb2398d2015-07-17 01:19:54 +00001723 getFileManager(), getPCHContainerReader(),
Adrian Prantlbb165fb2015-06-20 18:53:08 +00001724 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
John Thompson2255f2c2014-04-23 12:57:01 +00001725 ModuleManager->resetForReload();
1726 ModuleManager->loadGlobalIndex();
1727 GlobalIndex = ModuleManager->getGlobalIndex();
1728 }
1729 HaveFullGlobalModuleIndex = true;
1730 }
1731 return GlobalIndex;
1732}
John Thompson2d94bbb2014-04-23 19:04:32 +00001733
1734// Check global module index for missing imports.
1735bool
1736CompilerInstance::lookupMissingImports(StringRef Name,
1737 SourceLocation TriggerLoc) {
1738 // Look for the symbol in non-imported modules, but only if an error
1739 // actually occurred.
1740 if (!buildingModule()) {
1741 // Load global module index, or retrieve a previously loaded one.
1742 GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex(
1743 TriggerLoc);
1744
1745 // Only if we have a global index.
1746 if (GlobalIndex) {
1747 GlobalModuleIndex::HitSet FoundModules;
1748
1749 // Find the modules that reference the identifier.
1750 // Note that this only finds top-level modules.
1751 // We'll let diagnoseTypo find the actual declaration module.
1752 if (GlobalIndex->lookupIdentifier(Name, FoundModules))
1753 return true;
1754 }
1755 }
1756
1757 return false;
1758}
David Blaikiea97eaa12014-08-29 16:53:14 +00001759void CompilerInstance::resetAndLeakSema() { BuryPointer(takeSema()); }