blob: 8b4b16920668d94548ca44c351d431f265bd22c4 [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"
Duncan P. N. Exon Smith030d7d62017-03-20 17:58:26 +000016#include "clang/Basic/MemoryBufferCache.h"
Daniel Dunbar546a6762009-11-13 04:12:06 +000017#include "clang/Basic/SourceManager.h"
Daniel Dunbar636404a2009-11-13 03:51:44 +000018#include "clang/Basic/TargetInfo.h"
Daniel Dunbar4f2bc552010-01-13 00:48:06 +000019#include "clang/Basic/Version.h"
Alp Tokerf988d002014-06-06 10:36:22 +000020#include "clang/Config/config.h"
David Blaikie8b00dcb2011-09-26 00:21:47 +000021#include "clang/Frontend/ChainedDiagnosticConsumer.h"
Daniel Dunbar4f2bc552010-01-13 00:48:06 +000022#include "clang/Frontend/FrontendAction.h"
Douglas Gregorfaeb1d42011-09-12 23:31:24 +000023#include "clang/Frontend/FrontendActions.h"
Daniel Dunbarf7093b52009-11-13 09:36:05 +000024#include "clang/Frontend/FrontendDiagnostic.h"
Daniel Dunbar2083c322011-04-07 18:31:10 +000025#include "clang/Frontend/LogDiagnosticPrinter.h"
Ted Kremenek4610ea22011-10-29 00:12:39 +000026#include "clang/Frontend/SerializedDiagnosticPrinter.h"
Daniel Dunbar7d75afc2009-11-13 05:52:34 +000027#include "clang/Frontend/TextDiagnosticPrinter.h"
Daniel Dunbaraaa148f2009-11-13 05:52:11 +000028#include "clang/Frontend/Utils.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000029#include "clang/Frontend/VerifyDiagnosticConsumer.h"
30#include "clang/Lex/HeaderSearch.h"
31#include "clang/Lex/PTHManager.h"
32#include "clang/Lex/Preprocessor.h"
Mehdi Amini9670f842016-07-18 19:02:11 +000033#include "clang/Lex/PreprocessorOptions.h"
Daniel Dunbarf7093b52009-11-13 09:36:05 +000034#include "clang/Sema/CodeCompleteConsumer.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000035#include "clang/Sema/Sema.h"
36#include "clang/Serialization/ASTReader.h"
John Thompson2255f2c2014-04-23 12:57:01 +000037#include "clang/Serialization/GlobalModuleIndex.h"
Douglas Gregor171b7802010-03-30 17:33:59 +000038#include "llvm/ADT/Statistic.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000039#include "llvm/Support/CrashRecoveryContext.h"
Rafael Espindola71de0b62014-06-13 17:20:50 +000040#include "llvm/Support/Errc.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000041#include "llvm/Support/FileSystem.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000042#include "llvm/Support/Host.h"
Douglas Gregore2124892012-01-29 20:15:24 +000043#include "llvm/Support/LockFileManager.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000044#include "llvm/Support/MemoryBuffer.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000045#include "llvm/Support/Path.h"
46#include "llvm/Support/Program.h"
47#include "llvm/Support/Signals.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000048#include "llvm/Support/Timer.h"
49#include "llvm/Support/raw_ostream.h"
Douglas Gregor527b1c92013-03-25 21:19:16 +000050#include <sys/stat.h>
Rafael Espindola8a8e5542014-06-12 17:19:42 +000051#include <system_error>
Douglas Gregor37da3272013-03-25 21:51:16 +000052#include <time.h>
Benjamin Kramercfeacf52016-05-27 14:27:13 +000053#include <utility>
Douglas Gregor54a88812011-10-05 14:53:30 +000054
Daniel Dunbar636404a2009-11-13 03:51:44 +000055using namespace clang;
56
Adrian Prantlbb165fb2015-06-20 18:53:08 +000057CompilerInstance::CompilerInstance(
58 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
Duncan P. N. Exon Smith030d7d62017-03-20 17:58:26 +000059 MemoryBufferCache *SharedPCMCache)
60 : ModuleLoader(/* BuildingModule = */ SharedPCMCache),
61 Invocation(new CompilerInvocation()),
62 PCMCache(SharedPCMCache ? SharedPCMCache : new MemoryBufferCache),
63 ThePCHContainerOperations(std::move(PCHContainerOps)) {
64 // Don't allow this to invalidate buffers in use by others.
65 if (SharedPCMCache)
66 getPCMCache().finalizeCurrentBuffers();
67}
Daniel Dunbar636404a2009-11-13 03:51:44 +000068
69CompilerInstance::~CompilerInstance() {
Benjamin Kramer3c717b42012-10-14 19:21:21 +000070 assert(OutputFiles.empty() && "Still output files in flight?");
Daniel Dunbare922d9b2010-02-16 01:54:47 +000071}
72
David Blaikieea4395e2017-01-06 19:49:01 +000073void CompilerInstance::setInvocation(
74 std::shared_ptr<CompilerInvocation> Value) {
75 Invocation = std::move(Value);
Daniel Dunbar68242252010-01-30 21:47:07 +000076}
77
Douglas Gregorc1bbec82013-01-25 00:45:27 +000078bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
Douglas Gregore060e572013-01-25 01:03:03 +000079 return (BuildGlobalModuleIndex ||
Douglas Gregor11ef0b72013-03-22 21:26:48 +000080 (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
81 getFrontendOpts().GenerateGlobalModuleIndex)) &&
Douglas Gregore060e572013-01-25 01:03:03 +000082 !ModuleBuildFailed;
Douglas Gregorc1bbec82013-01-25 00:45:27 +000083}
84
David Blaikie9c902b52011-09-25 23:23:43 +000085void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
Douglas Gregor7f95d262010-04-05 23:52:57 +000086 Diagnostics = Value;
Daniel Dunbare01dc862009-11-14 01:20:40 +000087}
88
Artem Belevichb5bc9232015-09-22 17:23:22 +000089void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; }
90void CompilerInstance::setAuxTarget(TargetInfo *Value) { AuxTarget = Value; }
Daniel Dunbare01dc862009-11-14 01:20:40 +000091
92void CompilerInstance::setFileManager(FileManager *Value) {
Ted Kremenek5e14d392011-03-21 18:40:17 +000093 FileMgr = Value;
Ben Langmuirc8130a72014-02-20 21:59:23 +000094 if (Value)
95 VirtualFileSystem = Value->getVirtualFileSystem();
96 else
97 VirtualFileSystem.reset();
Daniel Dunbare01dc862009-11-14 01:20:40 +000098}
99
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000100void CompilerInstance::setSourceManager(SourceManager *Value) {
Ted Kremenek5e14d392011-03-21 18:40:17 +0000101 SourceMgr = Value;
Daniel Dunbare01dc862009-11-14 01:20:40 +0000102}
103
David Blaikie41565462017-01-05 19:48:07 +0000104void CompilerInstance::setPreprocessor(std::shared_ptr<Preprocessor> Value) {
105 PP = std::move(Value);
106}
Daniel Dunbare01dc862009-11-14 01:20:40 +0000107
Richard Smith293534b2015-08-18 20:39:29 +0000108void CompilerInstance::setASTContext(ASTContext *Value) {
109 Context = Value;
110
111 if (Context && Consumer)
112 getASTConsumer().Initialize(getASTContext());
113}
Daniel Dunbare01dc862009-11-14 01:20:40 +0000114
Douglas Gregor0e93f012010-08-12 23:31:19 +0000115void CompilerInstance::setSema(Sema *S) {
116 TheSema.reset(S);
117}
118
David Blaikie6beb6aa2014-08-10 19:56:51 +0000119void CompilerInstance::setASTConsumer(std::unique_ptr<ASTConsumer> Value) {
120 Consumer = std::move(Value);
Richard Smith293534b2015-08-18 20:39:29 +0000121
122 if (Context && Consumer)
123 getASTConsumer().Initialize(getASTContext());
Daniel Dunbar56d9c292009-11-14 02:47:17 +0000124}
125
Daniel Dunbare01dc862009-11-14 01:20:40 +0000126void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
127 CompletionConsumer.reset(Value);
128}
David Blaikie61535812014-08-10 20:12:39 +0000129
130std::unique_ptr<Sema> CompilerInstance::takeSema() {
131 return std::move(TheSema);
132}
133
Argyrios Kyrtzidis1b7ed912014-02-27 04:11:59 +0000134IntrusiveRefCntPtr<ASTReader> CompilerInstance::getModuleManager() const {
135 return ModuleManager;
136}
137void CompilerInstance::setModuleManager(IntrusiveRefCntPtr<ASTReader> Reader) {
Duncan P. N. Exon Smith030d7d62017-03-20 17:58:26 +0000138 assert(PCMCache.get() == &Reader->getModuleManager().getPCMCache() &&
139 "Expected ASTReader to use the same PCM cache");
Benjamin Kramerd6da1a02016-06-12 20:05:23 +0000140 ModuleManager = std::move(Reader);
Argyrios Kyrtzidis1b7ed912014-02-27 04:11:59 +0000141}
Daniel Dunbare01dc862009-11-14 01:20:40 +0000142
Justin Bogner86d12592014-06-19 19:36:03 +0000143std::shared_ptr<ModuleDependencyCollector>
144CompilerInstance::getModuleDepCollector() const {
145 return ModuleDepCollector;
146}
147
148void CompilerInstance::setModuleDepCollector(
149 std::shared_ptr<ModuleDependencyCollector> Collector) {
Benjamin Kramerd6da1a02016-06-12 20:05:23 +0000150 ModuleDepCollector = std::move(Collector);
Justin Bogner86d12592014-06-19 19:36:03 +0000151}
152
Bruno Cardoso Lopes181225b2016-12-11 04:27:28 +0000153static void collectHeaderMaps(const HeaderSearch &HS,
154 std::shared_ptr<ModuleDependencyCollector> MDC) {
155 SmallVector<std::string, 4> HeaderMapFileNames;
156 HS.getHeaderMapFileNames(HeaderMapFileNames);
157 for (auto &Name : HeaderMapFileNames)
158 MDC->addFile(Name);
159}
160
Bruno Cardoso Lopes7aff2bb2016-12-12 19:28:25 +0000161static void collectIncludePCH(CompilerInstance &CI,
162 std::shared_ptr<ModuleDependencyCollector> MDC) {
163 const PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
164 if (PPOpts.ImplicitPCHInclude.empty())
165 return;
166
167 StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
168 FileManager &FileMgr = CI.getFileManager();
169 const DirectoryEntry *PCHDir = FileMgr.getDirectory(PCHInclude);
170 if (!PCHDir) {
171 MDC->addFile(PCHInclude);
172 return;
173 }
174
175 std::error_code EC;
176 SmallString<128> DirNative;
177 llvm::sys::path::native(PCHDir->getName(), DirNative);
178 vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem();
179 SimpleASTReaderListener Validator(CI.getPreprocessor());
180 for (vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), DirEnd;
181 Dir != DirEnd && !EC; Dir.increment(EC)) {
182 // Check whether this is an AST file. ASTReader::isAcceptableASTFile is not
183 // used here since we're not interested in validating the PCH at this time,
184 // but only to check whether this is a file containing an AST.
185 if (!ASTReader::readASTFileControlBlock(
186 Dir->getName(), FileMgr, CI.getPCHContainerReader(),
187 /*FindModuleFileExtensions=*/false, Validator,
188 /*ValidateDiagnosticOptions=*/false))
189 MDC->addFile(Dir->getName());
190 }
191}
192
Bruno Cardoso Lopes82ec4fde2016-12-22 07:06:03 +0000193static void collectVFSEntries(CompilerInstance &CI,
194 std::shared_ptr<ModuleDependencyCollector> MDC) {
195 if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
196 return;
197
198 // Collect all VFS found.
199 SmallVector<vfs::YAMLVFSEntry, 16> VFSEntries;
200 for (const std::string &VFSFile : CI.getHeaderSearchOpts().VFSOverlayFiles) {
201 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
202 llvm::MemoryBuffer::getFile(VFSFile);
203 if (!Buffer)
204 return;
205 vfs::collectVFSFromYAML(std::move(Buffer.get()), /*DiagHandler*/ nullptr,
206 VFSFile, VFSEntries);
207 }
208
209 for (auto &E : VFSEntries)
210 MDC->addFile(E.VPath, E.RPath);
211}
212
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000213// Diagnostics
Douglas Gregor811db4e2012-10-23 22:26:28 +0000214static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
Daniel Dunbar7b833062011-04-07 18:59:02 +0000215 const CodeGenOptions *CodeGenOpts,
David Blaikie9c902b52011-09-25 23:23:43 +0000216 DiagnosticsEngine &Diags) {
Rafael Espindoladae941a2014-08-25 18:17:04 +0000217 std::error_code EC;
David Blaikie11f8a942014-09-15 17:30:56 +0000218 std::unique_ptr<raw_ostream> StreamOwner;
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000219 raw_ostream *OS = &llvm::errs();
Douglas Gregor811db4e2012-10-23 22:26:28 +0000220 if (DiagOpts->DiagnosticLogFile != "-") {
Daniel Dunbar2083c322011-04-07 18:31:10 +0000221 // Create the output stream.
David Blaikie11f8a942014-09-15 17:30:56 +0000222 auto FileOS = llvm::make_unique<llvm::raw_fd_ostream>(
Rafael Espindoladae941a2014-08-25 18:17:04 +0000223 DiagOpts->DiagnosticLogFile, EC,
David Blaikie11f8a942014-09-15 17:30:56 +0000224 llvm::sys::fs::F_Append | llvm::sys::fs::F_Text);
Rafael Espindoladae941a2014-08-25 18:17:04 +0000225 if (EC) {
Daniel Dunbar2083c322011-04-07 18:31:10 +0000226 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
Rafael Espindoladae941a2014-08-25 18:17:04 +0000227 << DiagOpts->DiagnosticLogFile << EC.message();
Daniel Dunbar2083c322011-04-07 18:31:10 +0000228 } else {
229 FileOS->SetUnbuffered();
David Blaikie11f8a942014-09-15 17:30:56 +0000230 OS = FileOS.get();
231 StreamOwner = std::move(FileOS);
Daniel Dunbar2083c322011-04-07 18:31:10 +0000232 }
233 }
234
235 // Chain in the diagnostic client which will log the diagnostics.
David Blaikie7ee25502014-09-15 17:50:10 +0000236 auto Logger = llvm::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,
237 std::move(StreamOwner));
Daniel Dunbar7b833062011-04-07 18:59:02 +0000238 if (CodeGenOpts)
239 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
David Blaikie7ee25502014-09-15 17:50:10 +0000240 assert(Diags.ownsClient());
Alexander Kornienko41c247a2014-11-17 23:46:02 +0000241 Diags.setClient(
242 new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger)));
Daniel Dunbar2083c322011-04-07 18:31:10 +0000243}
244
Douglas Gregor811db4e2012-10-23 22:26:28 +0000245static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
Ted Kremenek4610ea22011-10-29 00:12:39 +0000246 DiagnosticsEngine &Diags,
247 StringRef OutputFile) {
David Blaikie7ee25502014-09-15 17:50:10 +0000248 auto SerializedConsumer =
Justin Bogner5a6a2fc2014-10-23 22:20:11 +0000249 clang::serialized_diags::create(OutputFile, DiagOpts);
Ahmed Charles9a16beb2014-03-07 19:33:25 +0000250
Alexander Kornienko254b7db2014-11-13 13:08:27 +0000251 if (Diags.ownsClient()) {
252 Diags.setClient(new ChainedDiagnosticConsumer(
Alexander Kornienko41c247a2014-11-17 23:46:02 +0000253 Diags.takeClient(), std::move(SerializedConsumer)));
Alexander Kornienko254b7db2014-11-13 13:08:27 +0000254 } else {
255 Diags.setClient(new ChainedDiagnosticConsumer(
Alexander Kornienko4c0ef3792014-11-17 14:46:28 +0000256 Diags.getClient(), std::move(SerializedConsumer)));
Alexander Kornienko254b7db2014-11-13 13:08:27 +0000257 }
Ted Kremenek4610ea22011-10-29 00:12:39 +0000258}
259
Sean Silvaf1b49e22013-01-20 01:58:28 +0000260void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
Douglas Gregor30071cea2013-05-03 23:07:45 +0000261 bool ShouldOwnClient) {
Sean Silvaf1b49e22013-01-20 01:58:28 +0000262 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
Douglas Gregor30071cea2013-05-03 23:07:45 +0000263 ShouldOwnClient, &getCodeGenOpts());
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000264}
265
Dylan Noblesmithc95d8192012-02-20 14:00:23 +0000266IntrusiveRefCntPtr<DiagnosticsEngine>
Douglas Gregor811db4e2012-10-23 22:26:28 +0000267CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
David Blaikiee2eefae2011-09-25 23:39:51 +0000268 DiagnosticConsumer *Client,
Douglas Gregor2b9b4642011-09-13 01:26:44 +0000269 bool ShouldOwnClient,
Daniel Dunbar7b833062011-04-07 18:59:02 +0000270 const CodeGenOptions *CodeGenOpts) {
Dylan Noblesmithc95d8192012-02-20 14:00:23 +0000271 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
272 IntrusiveRefCntPtr<DiagnosticsEngine>
Douglas Gregor811db4e2012-10-23 22:26:28 +0000273 Diags(new DiagnosticsEngine(DiagID, Opts));
Daniel Dunbar1b39a2e2009-11-14 07:53:24 +0000274
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000275 // Create the diagnostic client for reporting errors or for
276 // implementing -verify.
Douglas Gregord0e9e3a2011-09-29 00:38:00 +0000277 if (Client) {
Douglas Gregor30071cea2013-05-03 23:07:45 +0000278 Diags->setClient(Client, ShouldOwnClient);
Douglas Gregord0e9e3a2011-09-29 00:38:00 +0000279 } else
Douglas Gregor44c6ee72010-11-11 00:39:14 +0000280 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
Daniel Dunbar50ec0da2009-11-14 03:24:39 +0000281
282 // Chain in -verify checker, if requested.
Douglas Gregor811db4e2012-10-23 22:26:28 +0000283 if (Opts->VerifyDiagnostics)
David Blaikie69609dc2011-09-26 00:38:03 +0000284 Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000285
Daniel Dunbar2083c322011-04-07 18:31:10 +0000286 // Chain in -diagnostic-log-file dumper, if requested.
Douglas Gregor811db4e2012-10-23 22:26:28 +0000287 if (!Opts->DiagnosticLogFile.empty())
Daniel Dunbar7b833062011-04-07 18:59:02 +0000288 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000289
Douglas Gregor811db4e2012-10-23 22:26:28 +0000290 if (!Opts->DiagnosticSerializationFile.empty())
Ted Kremenek4610ea22011-10-29 00:12:39 +0000291 SetupSerializedDiagnostics(Opts, *Diags,
Douglas Gregor811db4e2012-10-23 22:26:28 +0000292 Opts->DiagnosticSerializationFile);
Ted Kremenek4610ea22011-10-29 00:12:39 +0000293
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000294 // Configure our handling of diagnostics.
Douglas Gregor811db4e2012-10-23 22:26:28 +0000295 ProcessWarningOptions(*Diags, *Opts);
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000296
Douglas Gregor7f95d262010-04-05 23:52:57 +0000297 return Diags;
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000298}
299
300// File Manager
301
Daniel Dunbar546a6762009-11-13 04:12:06 +0000302void CompilerInstance::createFileManager() {
Ben Langmuirc8130a72014-02-20 21:59:23 +0000303 if (!hasVirtualFileSystem()) {
304 // TODO: choose the virtual file system based on the CompilerInvocation.
305 setVirtualFileSystem(vfs::getRealFileSystem());
306 }
307 FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem);
Daniel Dunbar546a6762009-11-13 04:12:06 +0000308}
309
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000310// Source Manager
311
Chris Lattner5159f612010-11-23 08:35:12 +0000312void CompilerInstance::createSourceManager(FileManager &FileMgr) {
Ted Kremenek5e14d392011-03-21 18:40:17 +0000313 SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
Daniel Dunbar546a6762009-11-13 04:12:06 +0000314}
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000315
Alp Tokerc3580002014-07-07 06:05:00 +0000316// Initialize the remapping of files to alternative contents, e.g.,
317// those specified through other files.
318static void InitializeFileRemapping(DiagnosticsEngine &Diags,
319 SourceManager &SourceMgr,
320 FileManager &FileMgr,
321 const PreprocessorOptions &InitOpts) {
322 // Remap files in the source manager (with buffers).
Alp Toker1b070d22014-07-07 07:47:20 +0000323 for (const auto &RB : InitOpts.RemappedFileBuffers) {
Alp Tokerc3580002014-07-07 06:05:00 +0000324 // Create the file entry for the file that we're mapping from.
325 const FileEntry *FromFile =
Alp Toker1b070d22014-07-07 07:47:20 +0000326 FileMgr.getVirtualFile(RB.first, RB.second->getBufferSize(), 0);
Alp Tokerc3580002014-07-07 06:05:00 +0000327 if (!FromFile) {
Alp Toker1b070d22014-07-07 07:47:20 +0000328 Diags.Report(diag::err_fe_remap_missing_from_file) << RB.first;
Alp Tokerc3580002014-07-07 06:05:00 +0000329 if (!InitOpts.RetainRemappedFileBuffers)
Alp Toker1b070d22014-07-07 07:47:20 +0000330 delete RB.second;
Alp Tokerc3580002014-07-07 06:05:00 +0000331 continue;
332 }
333
334 // Override the contents of the "from" file with the contents of
335 // the "to" file.
Alp Toker1b070d22014-07-07 07:47:20 +0000336 SourceMgr.overrideFileContents(FromFile, RB.second,
Alp Tokerc3580002014-07-07 06:05:00 +0000337 InitOpts.RetainRemappedFileBuffers);
338 }
339
340 // Remap files in the source manager (with other files).
Alp Toker1b070d22014-07-07 07:47:20 +0000341 for (const auto &RF : InitOpts.RemappedFiles) {
Alp Tokerc3580002014-07-07 06:05:00 +0000342 // Find the file that we're mapping to.
Alp Toker1b070d22014-07-07 07:47:20 +0000343 const FileEntry *ToFile = FileMgr.getFile(RF.second);
Alp Tokerc3580002014-07-07 06:05:00 +0000344 if (!ToFile) {
Alp Toker1b070d22014-07-07 07:47:20 +0000345 Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;
Alp Tokerc3580002014-07-07 06:05:00 +0000346 continue;
347 }
348
349 // Create the file entry for the file that we're mapping from.
350 const FileEntry *FromFile =
Alp Toker1b070d22014-07-07 07:47:20 +0000351 FileMgr.getVirtualFile(RF.first, ToFile->getSize(), 0);
Alp Tokerc3580002014-07-07 06:05:00 +0000352 if (!FromFile) {
Alp Toker1b070d22014-07-07 07:47:20 +0000353 Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first;
Alp Tokerc3580002014-07-07 06:05:00 +0000354 continue;
355 }
356
357 // Override the contents of the "from" file with the contents of
358 // the "to" file.
359 SourceMgr.overrideFileContents(FromFile, ToFile);
360 }
361
362 SourceMgr.setOverridenFilesKeepOriginalName(
363 InitOpts.RemappedFilesKeepOriginalName);
364}
365
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000366// Preprocessor
367
Argyrios Kyrtzidise1974dc2014-03-07 07:47:58 +0000368void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
Douglas Gregor08142532011-08-26 23:56:07 +0000369 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000370
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000371 // Create a PTH manager if we are using some form of a token cache.
Craig Topper49a27902014-05-22 04:46:25 +0000372 PTHManager *PTHMgr = nullptr;
Daniel Dunbard6ea9022009-11-17 05:52:41 +0000373 if (!PPOpts.TokenCache.empty())
Douglas Gregor08142532011-08-26 23:56:07 +0000374 PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000375
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000376 // Create the Preprocessor.
David Blaikie9c28cb32017-01-06 01:04:46 +0000377 HeaderSearch *HeaderInfo =
378 new HeaderSearch(getHeaderSearchOptsPtr(), getSourceManager(),
379 getDiagnostics(), getLangOpts(), &getTarget());
David Blaikie41565462017-01-05 19:48:07 +0000380 PP = std::make_shared<Preprocessor>(
381 Invocation->getPreprocessorOptsPtr(), getDiagnostics(), getLangOpts(),
Duncan P. N. Exon Smith030d7d62017-03-20 17:58:26 +0000382 getSourceManager(), getPCMCache(), *HeaderInfo, *this, PTHMgr,
David Blaikie41565462017-01-05 19:48:07 +0000383 /*OwnsHeaderSearch=*/true, TUKind);
Artem Belevichb5bc9232015-09-22 17:23:22 +0000384 PP->Initialize(getTarget(), getAuxTarget());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000385
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000386 // Note that this is different then passing PTHMgr to Preprocessor's ctor.
387 // That argument is used as the IdentifierInfoLookup argument to
388 // IdentifierTable's ctor.
389 if (PTHMgr) {
Douglas Gregor08142532011-08-26 23:56:07 +0000390 PTHMgr->setPreprocessor(&*PP);
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000391 PP->setPTHManager(PTHMgr);
392 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000393
Douglas Gregor7f6d60d2010-03-19 16:15:56 +0000394 if (PPOpts.DetailedRecord)
Argyrios Kyrtzidisf3d587e2012-12-04 07:27:05 +0000395 PP->createPreprocessingRecord();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000396
Alp Tokerc3580002014-07-07 06:05:00 +0000397 // Apply remappings to the source manager.
398 InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
399 PP->getFileManager(), PPOpts);
400
401 // Predefine macros and configure the preprocessor.
Adrian Prantlfb2398d2015-07-17 01:19:54 +0000402 InitializePreprocessor(*PP, PPOpts, getPCHContainerReader(),
Adrian Prantlbb165fb2015-06-20 18:53:08 +0000403 getFrontendOpts());
Alp Tokerc3580002014-07-07 06:05:00 +0000404
Justin Lebarf91086b2016-11-18 00:41:27 +0000405 // Initialize the header search object. In CUDA compilations, we use the aux
406 // triple (the host triple) to initialize our header search, since we need to
407 // find the host headers in order to compile the CUDA code.
408 const llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple();
409 if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA &&
410 PP->getAuxTargetInfo())
411 HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple();
412
Alp Tokerc3580002014-07-07 06:05:00 +0000413 ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(),
Justin Lebarf91086b2016-11-18 00:41:27 +0000414 PP->getLangOpts(), *HeaderSearchTriple);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000415
Jordan Rose17441582013-01-30 01:52:57 +0000416 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
417
Richard Smith3938f0c2015-08-15 00:34:15 +0000418 if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules)
Chandler Carruthff8d9432015-03-28 01:10:44 +0000419 PP->getHeaderSearchInfo().setModuleCachePath(getSpecificModuleCachePath());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000420
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000421 // Handle generating dependencies, if requested.
Douglas Gregor08142532011-08-26 23:56:07 +0000422 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000423 if (!DepOpts.OutputFile.empty())
Ben Langmuircb69b572014-03-07 06:40:32 +0000424 TheDependencyFileGenerator.reset(
425 DependencyFileGenerator::CreateAndAttachToPreprocessor(*PP, DepOpts));
Douglas Gregor2e129652012-02-02 23:45:13 +0000426 if (!DepOpts.DOTOutputFile.empty())
427 AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile,
Douglas Gregor83d46be2012-02-02 00:54:52 +0000428 getHeaderSearchOpts().Sysroot);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000429
Justin Bogner86d12592014-06-19 19:36:03 +0000430 // If we don't have a collector, but we are collecting module dependencies,
431 // then we're the top level compiler instance and need to create one.
Bruno Cardoso Lopesb1631d92016-03-29 23:47:40 +0000432 if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty()) {
Justin Bogner86d12592014-06-19 19:36:03 +0000433 ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(
434 DepOpts.ModuleDependencyOutputDir);
Bruno Cardoso Lopesb1631d92016-03-29 23:47:40 +0000435 }
436
Bruno Cardoso Lopes181225b2016-12-11 04:27:28 +0000437 // If there is a module dep collector, register with other dep collectors
438 // and also (a) collect header maps and (b) TODO: input vfs overlay files.
439 if (ModuleDepCollector) {
Bruno Cardoso Lopesb1631d92016-03-29 23:47:40 +0000440 addDependencyCollector(ModuleDepCollector);
Bruno Cardoso Lopes181225b2016-12-11 04:27:28 +0000441 collectHeaderMaps(PP->getHeaderSearchInfo(), ModuleDepCollector);
Bruno Cardoso Lopes7aff2bb2016-12-12 19:28:25 +0000442 collectIncludePCH(*this, ModuleDepCollector);
Bruno Cardoso Lopes82ec4fde2016-12-22 07:06:03 +0000443 collectVFSEntries(*this, ModuleDepCollector);
Bruno Cardoso Lopes181225b2016-12-11 04:27:28 +0000444 }
Bruno Cardoso Lopesb1631d92016-03-29 23:47:40 +0000445
446 for (auto &Listener : DependencyCollectors)
447 Listener->attachToPreprocessor(*PP);
Hans Wennborg0fd62072013-08-09 00:32:23 +0000448
Daniel Dunbar27734fd2011-02-02 15:41:17 +0000449 // Handle generating header include information, if requested.
450 if (DepOpts.ShowHeaderIncludes)
Nico Weberf54146c2016-03-23 18:46:57 +0000451 AttachHeaderIncludeGen(*PP, DepOpts);
Daniel Dunbar1af1d27512011-02-02 21:11:31 +0000452 if (!DepOpts.HeaderIncludeOutputFile.empty()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000453 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
Daniel Dunbar1af1d27512011-02-02 21:11:31 +0000454 if (OutputPath == "-")
455 OutputPath = "";
Nico Weberf54146c2016-03-23 18:46:57 +0000456 AttachHeaderIncludeGen(*PP, DepOpts,
Ivan Krasin1193f2c2015-08-13 04:04:37 +0000457 /*ShowAllHeaders=*/true, OutputPath,
Daniel Dunbarfe908a82011-03-21 19:37:38 +0000458 /*ShowDepth=*/false);
Daniel Dunbar1af1d27512011-02-02 21:11:31 +0000459 }
Hans Wennborg0fd62072013-08-09 00:32:23 +0000460
461 if (DepOpts.PrintShowIncludes) {
Nico Weberf54146c2016-03-23 18:46:57 +0000462 AttachHeaderIncludeGen(*PP, DepOpts,
Nico Weber149d95222016-03-23 18:00:22 +0000463 /*ShowAllHeaders=*/true, /*OutputPath=*/"",
Hans Wennborg0fd62072013-08-09 00:32:23 +0000464 /*ShowDepth=*/true, /*MSStyle=*/true);
465 }
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000466}
Daniel Dunbardf3e30c2009-11-13 08:20:47 +0000467
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +0000468std::string CompilerInstance::getSpecificModuleCachePath() {
469 // Set up the module path, including the hash for the
470 // module-creation options.
Richard Smithd520a252015-07-21 18:07:47 +0000471 SmallString<256> SpecificModuleCache(getHeaderSearchOpts().ModuleCachePath);
472 if (!SpecificModuleCache.empty() && !getHeaderSearchOpts().DisableModuleHash)
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +0000473 llvm::sys::path::append(SpecificModuleCache,
474 getInvocation().getModuleHash());
475 return SpecificModuleCache.str();
476}
477
Daniel Dunbardf3e30c2009-11-13 08:20:47 +0000478// ASTContext
479
480void CompilerInstance::createASTContext() {
481 Preprocessor &PP = getPreprocessor();
Richard Smith293534b2015-08-18 20:39:29 +0000482 auto *Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
483 PP.getIdentifierTable(), PP.getSelectorTable(),
484 PP.getBuiltinInfo());
Artem Belevichb5bc9232015-09-22 17:23:22 +0000485 Context->InitBuiltinTypes(getTarget(), getAuxTarget());
Richard Smith293534b2015-08-18 20:39:29 +0000486 setASTContext(Context);
Daniel Dunbardf3e30c2009-11-13 08:20:47 +0000487}
Daniel Dunbar599313e2009-11-13 08:21:10 +0000488
489// ExternalASTSource
490
Nico Weber824285e2014-05-08 04:26:47 +0000491void CompilerInstance::createPCHExternalASTSource(
492 StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors,
493 void *DeserializationListener, bool OwnDeserializationListener) {
Sebastian Redl009e7f22010-10-05 16:15:19 +0000494 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
Richard Smith4eca9b92015-02-04 23:37:59 +0000495 ModuleManager = createPCHExternalASTSource(
Nico Weber824285e2014-05-08 04:26:47 +0000496 Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation,
497 AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(),
Douglas Gregor6623e1f2015-11-03 18:33:07 +0000498 getPCHContainerReader(),
499 getFrontendOpts().ModuleFileExtensions,
Graydon Hoarece539b52017-03-29 17:33:09 +0000500 TheDependencyFileGenerator.get(),
501 DependencyCollectors,
Douglas Gregor6623e1f2015-11-03 18:33:07 +0000502 DeserializationListener,
Adrian Prantlbb165fb2015-06-20 18:53:08 +0000503 OwnDeserializationListener, Preamble,
Nico Weber824285e2014-05-08 04:26:47 +0000504 getFrontendOpts().UseGlobalModuleIndex);
Daniel Dunbar599313e2009-11-13 08:21:10 +0000505}
506
Richard Smith4eca9b92015-02-04 23:37:59 +0000507IntrusiveRefCntPtr<ASTReader> CompilerInstance::createPCHExternalASTSource(
Yaron Keren5b816062015-07-06 08:47:15 +0000508 StringRef Path, StringRef Sysroot, bool DisablePCHValidation,
Nico Weber824285e2014-05-08 04:26:47 +0000509 bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context,
Adrian Prantlfb2398d2015-07-17 01:19:54 +0000510 const PCHContainerReader &PCHContainerRdr,
David Blaikie61137e12017-01-05 18:23:18 +0000511 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
Graydon Hoarece539b52017-03-29 17:33:09 +0000512 DependencyFileGenerator *DependencyFile,
513 ArrayRef<std::shared_ptr<DependencyCollector>> DependencyCollectors,
Nico Weber824285e2014-05-08 04:26:47 +0000514 void *DeserializationListener, bool OwnDeserializationListener,
515 bool Preamble, bool UseGlobalModuleIndex) {
Ben Langmuirdcf73862014-03-12 00:06:17 +0000516 HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
517
Adrian Prantlbb165fb2015-06-20 18:53:08 +0000518 IntrusiveRefCntPtr<ASTReader> Reader(new ASTReader(
Douglas Gregor6623e1f2015-11-03 18:33:07 +0000519 PP, Context, PCHContainerRdr, Extensions,
520 Sysroot.empty() ? "" : Sysroot.data(), DisablePCHValidation,
521 AllowPCHWithCompilerErrors, /*AllowConfigurationMismatch*/ false,
522 HSOpts.ModulesValidateSystemHeaders, UseGlobalModuleIndex));
Richard Smith4eca9b92015-02-04 23:37:59 +0000523
524 // We need the external source to be set up before we read the AST, because
525 // eagerly-deserialized declarations may use it.
526 Context.setExternalSource(Reader.get());
Daniel Dunbar599313e2009-11-13 08:21:10 +0000527
Sebastian Redl07a89a82010-07-30 00:29:29 +0000528 Reader->setDeserializationListener(
Nico Weber824285e2014-05-08 04:26:47 +0000529 static_cast<ASTDeserializationListener *>(DeserializationListener),
530 /*TakeOwnership=*/OwnDeserializationListener);
Graydon Hoarece539b52017-03-29 17:33:09 +0000531
532 if (DependencyFile)
533 DependencyFile->AttachToASTReader(*Reader);
534 for (auto &Listener : DependencyCollectors)
535 Listener->attachToASTReader(*Reader);
536
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000537 switch (Reader->ReadAST(Path,
538 Preamble ? serialization::MK_Preamble
Douglas Gregor4b29c162012-10-22 23:51:00 +0000539 : serialization::MK_PCH,
Argyrios Kyrtzidis2ec29362012-11-15 18:57:22 +0000540 SourceLocation(),
Ben Langmuir3d4417c2014-02-07 17:31:11 +0000541 ASTReader::ARR_None)) {
Sebastian Redl2c499f62010-08-18 23:56:43 +0000542 case ASTReader::Success:
Daniel Dunbar599313e2009-11-13 08:21:10 +0000543 // Set the predefines buffer as suggested by the PCH reader. Typically, the
544 // predefines buffer will be empty.
545 PP.setPredefines(Reader->getSuggestedPredefines());
Richard Smith4eca9b92015-02-04 23:37:59 +0000546 return Reader;
Daniel Dunbar599313e2009-11-13 08:21:10 +0000547
Sebastian Redl2c499f62010-08-18 23:56:43 +0000548 case ASTReader::Failure:
Daniel Dunbar599313e2009-11-13 08:21:10 +0000549 // Unrecoverable failure: don't even try to process the input file.
550 break;
551
Douglas Gregor7029ce12013-03-19 00:28:20 +0000552 case ASTReader::Missing:
Douglas Gregorc9ad5fb2012-10-22 22:50:17 +0000553 case ASTReader::OutOfDate:
554 case ASTReader::VersionMismatch:
555 case ASTReader::ConfigurationMismatch:
556 case ASTReader::HadErrors:
Daniel Dunbar599313e2009-11-13 08:21:10 +0000557 // No suitable PCH file could be found. Return an error.
558 break;
559 }
560
Richard Smith4eca9b92015-02-04 23:37:59 +0000561 Context.setExternalSource(nullptr);
Craig Topper49a27902014-05-22 04:46:25 +0000562 return nullptr;
Daniel Dunbar599313e2009-11-13 08:21:10 +0000563}
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000564
565// Code Completion
566
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000567static bool EnableCodeCompletion(Preprocessor &PP,
Benjamin Kramer0772c422016-02-13 13:42:54 +0000568 StringRef Filename,
Douglas Gregor8e984da2010-08-04 16:47:14 +0000569 unsigned Line,
570 unsigned Column) {
571 // Tell the source manager to chop off the given file at a specific
572 // line and column.
Chris Lattner5159f612010-11-23 08:35:12 +0000573 const FileEntry *Entry = PP.getFileManager().getFile(Filename);
Douglas Gregor8e984da2010-08-04 16:47:14 +0000574 if (!Entry) {
575 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
576 << Filename;
577 return true;
578 }
579
580 // Truncate the named file at the given line/column.
581 PP.SetCodeCompletionPoint(Entry, Line, Column);
582 return false;
583}
584
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000585void CompilerInstance::createCodeCompletionConsumer() {
586 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
Douglas Gregor8e984da2010-08-04 16:47:14 +0000587 if (!CompletionConsumer) {
Erik Verbruggen2fca3c22012-04-12 10:31:12 +0000588 setCodeCompletionConsumer(
Douglas Gregor8e984da2010-08-04 16:47:14 +0000589 createCodeCompletionConsumer(getPreprocessor(),
590 Loc.FileName, Loc.Line, Loc.Column,
Dmitri Gribenko3292d062012-07-02 17:35:10 +0000591 getFrontendOpts().CodeCompleteOpts,
Douglas Gregor8e984da2010-08-04 16:47:14 +0000592 llvm::outs()));
593 if (!CompletionConsumer)
594 return;
595 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
596 Loc.Line, Loc.Column)) {
Craig Topper49a27902014-05-22 04:46:25 +0000597 setCodeCompletionConsumer(nullptr);
Douglas Gregor00a0cf72010-03-16 06:04:47 +0000598 return;
Douglas Gregor8e984da2010-08-04 16:47:14 +0000599 }
Douglas Gregorf09935f2009-12-01 05:55:20 +0000600
601 if (CompletionConsumer->isOutputBinary() &&
Rafael Espindolaa3346d82013-06-12 20:44:26 +0000602 llvm::sys::ChangeStdoutToBinary()) {
Douglas Gregorf09935f2009-12-01 05:55:20 +0000603 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
Craig Topper49a27902014-05-22 04:46:25 +0000604 setCodeCompletionConsumer(nullptr);
Douglas Gregorf09935f2009-12-01 05:55:20 +0000605 }
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000606}
607
Kovarththanan Rajaratnam5505dff2009-11-29 09:57:35 +0000608void CompilerInstance::createFrontendTimer() {
Matthias Braunae032b62016-11-18 19:43:25 +0000609 FrontendTimerGroup.reset(
610 new llvm::TimerGroup("frontend", "Clang front-end time report"));
Richard Smithce18a182015-07-14 00:26:00 +0000611 FrontendTimer.reset(
Matthias Braunae032b62016-11-18 19:43:25 +0000612 new llvm::Timer("frontend", "Clang front-end timer",
613 *FrontendTimerGroup));
Kovarththanan Rajaratnam5505dff2009-11-29 09:57:35 +0000614}
615
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000616CodeCompleteConsumer *
617CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
Yaron Keren5b816062015-07-06 08:47:15 +0000618 StringRef Filename,
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000619 unsigned Line,
620 unsigned Column,
Dmitri Gribenko3292d062012-07-02 17:35:10 +0000621 const CodeCompleteOptions &Opts,
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000622 raw_ostream &OS) {
Douglas Gregor8e984da2010-08-04 16:47:14 +0000623 if (EnableCodeCompletion(PP, Filename, Line, Column))
Craig Topper49a27902014-05-22 04:46:25 +0000624 return nullptr;
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000625
626 // Set up the creation routine for code-completion.
Dmitri Gribenko3292d062012-07-02 17:35:10 +0000627 return new PrintingCodeCompleteConsumer(Opts, OS);
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000628}
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000629
Douglas Gregor69f74f82011-08-25 22:30:56 +0000630void CompilerInstance::createSema(TranslationUnitKind TUKind,
Douglas Gregor0e93f012010-08-12 23:31:19 +0000631 CodeCompleteConsumer *CompletionConsumer) {
632 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
Douglas Gregor69f74f82011-08-25 22:30:56 +0000633 TUKind, CompletionConsumer));
Benjamin Kramer7de99692016-11-16 18:15:26 +0000634 // Attach the external sema source if there is any.
635 if (ExternalSemaSrc) {
636 TheSema->addExternalSource(ExternalSemaSrc.get());
637 ExternalSemaSrc->InitializeSema(*TheSema);
638 }
Douglas Gregor0e93f012010-08-12 23:31:19 +0000639}
640
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000641// Output Files
642
Rafael Espindola269ec0f2015-04-10 14:11:52 +0000643void CompilerInstance::addOutputFile(OutputFile &&OutFile) {
Rafael Espindola269ec0f2015-04-10 14:11:52 +0000644 OutputFiles.push_back(std::move(OutFile));
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000645}
646
Kovarththanan Rajaratnam1c558cd2010-03-06 12:07:48 +0000647void CompilerInstance::clearOutputFiles(bool EraseFiles) {
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000648 for (OutputFile &OF : OutputFiles) {
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000649 if (!OF.TempFilename.empty()) {
Anders Carlssonb5c356a2011-03-06 22:25:35 +0000650 if (EraseFiles) {
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000651 llvm::sys::fs::remove(OF.TempFilename);
Anders Carlssonb5c356a2011-03-06 22:25:35 +0000652 } else {
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000653 SmallString<128> NewOutFile(OF.Filename);
Anders Carlssonb5c356a2011-03-06 22:25:35 +0000654
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +0000655 // If '-working-directory' was passed, the output filename should be
656 // relative to that.
Anders Carlsson9ba8fb12011-03-14 01:13:54 +0000657 FileMgr->FixupRelativePath(NewOutFile);
Rafael Espindolac0809172014-06-12 14:02:15 +0000658 if (std::error_code ec =
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000659 llvm::sys::fs::rename(OF.TempFilename, NewOutFile)) {
Manuel Klimek3ef9c442012-05-16 20:55:58 +0000660 getDiagnostics().Report(diag::err_unable_to_rename_temp)
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000661 << OF.TempFilename << OF.Filename << ec.message();
Anders Carlssonb5c356a2011-03-06 22:25:35 +0000662
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000663 llvm::sys::fs::remove(OF.TempFilename);
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000664 }
665 }
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000666 } else if (!OF.Filename.empty() && EraseFiles)
667 llvm::sys::fs::remove(OF.Filename);
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000668 }
669 OutputFiles.clear();
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000670 NonSeekStream.reset();
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000671}
672
Peter Collingbourne03f89072016-07-15 00:55:40 +0000673std::unique_ptr<raw_pwrite_stream>
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000674CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile,
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000675 StringRef Extension) {
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000676 return createOutputFile(getFrontendOpts().OutputFile, Binary,
Daniel Dunbarae77b3d2012-03-03 00:36:06 +0000677 /*RemoveFileOnSignal=*/true, InFile, Extension,
678 /*UseTemporary=*/true);
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000679}
680
Peter Collingbourne03f89072016-07-15 00:55:40 +0000681std::unique_ptr<raw_pwrite_stream> CompilerInstance::createNullOutputFile() {
682 return llvm::make_unique<llvm::raw_null_ostream>();
Alp Tokerea046722014-06-03 17:23:34 +0000683}
684
Peter Collingbourne03f89072016-07-15 00:55:40 +0000685std::unique_ptr<raw_pwrite_stream>
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000686CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary,
687 bool RemoveFileOnSignal, StringRef InFile,
688 StringRef Extension, bool UseTemporary,
Daniel Dunbarb9c62c02012-03-03 00:36:02 +0000689 bool CreateMissingDirectories) {
Rafael Espindoladae941a2014-08-25 18:17:04 +0000690 std::string OutputPathName, TempPathName;
691 std::error_code EC;
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000692 std::unique_ptr<raw_pwrite_stream> OS = createOutputFile(
Rafael Espindoladae941a2014-08-25 18:17:04 +0000693 OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension,
Rafael Espindolac80a4062015-04-10 14:30:43 +0000694 UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName);
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000695 if (!OS) {
Rafael Espindoladae941a2014-08-25 18:17:04 +0000696 getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath
697 << EC.message();
Craig Topper49a27902014-05-22 04:46:25 +0000698 return nullptr;
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000699 }
700
701 // Add the output file -- but don't try to remove "-", since this means we are
702 // using stdin.
Peter Collingbourne03f89072016-07-15 00:55:40 +0000703 addOutputFile(
704 OutputFile((OutputPathName != "-") ? OutputPathName : "", TempPathName));
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000705
Peter Collingbourne03f89072016-07-15 00:55:40 +0000706 return OS;
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000707}
708
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000709std::unique_ptr<llvm::raw_pwrite_stream> CompilerInstance::createOutputFile(
Rafael Espindoladae941a2014-08-25 18:17:04 +0000710 StringRef OutputPath, std::error_code &Error, bool Binary,
711 bool RemoveFileOnSignal, StringRef InFile, StringRef Extension,
712 bool UseTemporary, bool CreateMissingDirectories,
713 std::string *ResultPathName, std::string *TempPathName) {
Daniel Dunbarb9c62c02012-03-03 00:36:02 +0000714 assert((!CreateMissingDirectories || UseTemporary) &&
715 "CreateMissingDirectories is only allowed when using temporary files");
716
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000717 std::string OutFile, TempFile;
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000718 if (!OutputPath.empty()) {
719 OutFile = OutputPath;
720 } else if (InFile == "-") {
721 OutFile = "-";
722 } else if (!Extension.empty()) {
Rafael Espindola399ab332013-06-26 04:32:59 +0000723 SmallString<128> Path(InFile);
724 llvm::sys::path::replace_extension(Path, Extension);
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000725 OutFile = Path.str();
726 } else {
727 OutFile = "-";
728 }
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000729
Ahmed Charlesb8984322014-03-07 20:03:18 +0000730 std::unique_ptr<llvm::raw_fd_ostream> OS;
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000731 std::string OSFile;
732
Rafael Espindola73c23a72013-06-27 18:26:26 +0000733 if (UseTemporary) {
734 if (OutFile == "-")
735 UseTemporary = false;
736 else {
737 llvm::sys::fs::file_status Status;
738 llvm::sys::fs::status(OutputPath, Status);
739 if (llvm::sys::fs::exists(Status)) {
740 // Fail early if we can't write to the final destination.
Douglas Katzman8bfac2c2015-09-17 16:45:12 +0000741 if (!llvm::sys::fs::can_write(OutputPath)) {
Rafael Espindolaee4e08b2015-10-05 11:49:35 +0000742 Error = make_error_code(llvm::errc::operation_not_permitted);
Craig Topper49a27902014-05-22 04:46:25 +0000743 return nullptr;
Douglas Katzman8bfac2c2015-09-17 16:45:12 +0000744 }
Rafael Espindola73c23a72013-06-27 18:26:26 +0000745
746 // Don't use a temporary if the output is a special file. This handles
747 // things like '-o /dev/null'
748 if (!llvm::sys::fs::is_regular_file(Status))
749 UseTemporary = false;
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000750 }
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000751 }
752 }
753
Rafael Espindola73c23a72013-06-27 18:26:26 +0000754 if (UseTemporary) {
Rafael Espindola73c23a72013-06-27 18:26:26 +0000755 // Create a temporary file.
756 SmallString<128> TempPath;
757 TempPath = OutFile;
758 TempPath += "-%%%%%%%%";
759 int fd;
Rafael Espindolac0809172014-06-12 14:02:15 +0000760 std::error_code EC =
Yaron Keren92e1b622015-03-18 10:17:07 +0000761 llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
Rafael Espindola157f34b2013-06-28 03:49:04 +0000762
763 if (CreateMissingDirectories &&
Rafael Espindola71de0b62014-06-13 17:20:50 +0000764 EC == llvm::errc::no_such_file_or_directory) {
Rafael Espindola157f34b2013-06-28 03:49:04 +0000765 StringRef Parent = llvm::sys::path::parent_path(OutputPath);
766 EC = llvm::sys::fs::create_directories(Parent);
767 if (!EC) {
Yaron Keren92e1b622015-03-18 10:17:07 +0000768 EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
Rafael Espindola157f34b2013-06-28 03:49:04 +0000769 }
770 }
771
772 if (!EC) {
NAKAMURA Takumi69f35282014-08-11 06:53:11 +0000773 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
Rafael Espindola73c23a72013-06-27 18:26:26 +0000774 OSFile = TempFile = TempPath.str();
775 }
776 // If we failed to create the temporary, fallback to writing to the file
777 // directly. This handles the corner case where we cannot write to the
778 // directory, but can write to the file.
779 }
780
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000781 if (!OS) {
782 OSFile = OutFile;
NAKAMURA Takumi69f35282014-08-11 06:53:11 +0000783 OS.reset(new llvm::raw_fd_ostream(
Rafael Espindoladae941a2014-08-25 18:17:04 +0000784 OSFile, Error,
NAKAMURA Takumi69f35282014-08-11 06:53:11 +0000785 (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text)));
Rafael Espindoladae941a2014-08-25 18:17:04 +0000786 if (Error)
Craig Topper49a27902014-05-22 04:46:25 +0000787 return nullptr;
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000788 }
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000789
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000790 // Make sure the out stream file gets removed if we crash.
Daniel Dunbare326f9b2011-01-31 22:00:42 +0000791 if (RemoveFileOnSignal)
Rafael Espindola18556de2013-06-13 21:02:40 +0000792 llvm::sys::RemoveFileOnSignal(OSFile);
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000793
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000794 if (ResultPathName)
795 *ResultPathName = OutFile;
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000796 if (TempPathName)
797 *TempPathName = TempFile;
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000798
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000799 if (!Binary || OS->supportsSeeking())
800 return std::move(OS);
801
802 auto B = llvm::make_unique<llvm::buffer_ostream>(*OS);
803 assert(!NonSeekStream);
804 NonSeekStream = std::move(OS);
805 return std::move(B);
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000806}
Daniel Dunbar409e8902009-11-14 07:53:04 +0000807
808// Initialization Utilities
809
Argyrios Kyrtzidis1b3240b2012-11-09 19:40:33 +0000810bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
Nico Weber2ca4be92016-03-01 23:16:44 +0000811 return InitializeSourceManager(
812 Input, getDiagnostics(), getFileManager(), getSourceManager(),
813 hasPreprocessor() ? &getPreprocessor().getHeaderSearchInfo() : nullptr,
Nico Weber4b5aede2016-03-13 02:44:13 +0000814 getDependencyOutputOpts(), getFrontendOpts());
Daniel Dunbar409e8902009-11-14 07:53:04 +0000815}
816
Nico Weber2ca4be92016-03-01 23:16:44 +0000817// static
Nico Weber4b5aede2016-03-13 02:44:13 +0000818bool CompilerInstance::InitializeSourceManager(
819 const FrontendInputFile &Input, DiagnosticsEngine &Diags,
820 FileManager &FileMgr, SourceManager &SourceMgr, HeaderSearch *HS,
821 DependencyOutputOptions &DepOpts, const FrontendOptions &Opts) {
Argyrios Kyrtzidis1b3240b2012-11-09 19:40:33 +0000822 SrcMgr::CharacteristicKind
Argyrios Kyrtzidis873c8582012-11-09 19:40:39 +0000823 Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
Argyrios Kyrtzidis1b3240b2012-11-09 19:40:33 +0000824
Argyrios Kyrtzidis6566e232012-11-09 19:40:45 +0000825 if (Input.isBuffer()) {
David Blaikie50a5f972014-08-29 07:59:55 +0000826 SourceMgr.setMainFileID(SourceMgr.createFileID(
827 std::unique_ptr<llvm::MemoryBuffer>(Input.getBuffer()), Kind));
Yaron Keren8b563662015-10-03 10:46:20 +0000828 assert(SourceMgr.getMainFileID().isValid() &&
Argyrios Kyrtzidis6566e232012-11-09 19:40:45 +0000829 "Couldn't establish MainFileID!");
830 return true;
831 }
832
833 StringRef InputFile = Input.getFile();
834
Argyrios Kyrtzidis7c06d862011-09-19 20:40:35 +0000835 // Figure out where to get and map in the main file.
836 if (InputFile != "-") {
Nico Weber2ca4be92016-03-01 23:16:44 +0000837 const FileEntry *File;
838 if (Opts.FindPchSource.empty()) {
839 File = FileMgr.getFile(InputFile, /*OpenFile=*/true);
840 } else {
841 // When building a pch file in clang-cl mode, the .h file is built as if
842 // it was included by a cc file. Since the driver doesn't know about
843 // all include search directories, the frontend must search the input
844 // file through HeaderSearch here, as if it had been included by the
845 // cc file at Opts.FindPchSource.
846 const FileEntry *FindFile = FileMgr.getFile(Opts.FindPchSource);
847 if (!FindFile) {
848 Diags.Report(diag::err_fe_error_reading) << Opts.FindPchSource;
849 return false;
850 }
851 const DirectoryLookup *UnusedCurDir;
852 SmallVector<std::pair<const FileEntry *, const DirectoryEntry *>, 16>
853 Includers;
854 Includers.push_back(std::make_pair(FindFile, FindFile->getDir()));
855 File = HS->LookupFile(InputFile, SourceLocation(), /*isAngled=*/false,
856 /*FromDir=*/nullptr,
857 /*CurDir=*/UnusedCurDir, Includers,
858 /*SearchPath=*/nullptr,
859 /*RelativePath=*/nullptr,
860 /*RequestingModule=*/nullptr,
861 /*SuggestedModule=*/nullptr, /*SkipCache=*/true);
Nico Weber4b5aede2016-03-13 02:44:13 +0000862 // Also add the header to /showIncludes output.
863 if (File)
Nico Weberf54146c2016-03-23 18:46:57 +0000864 DepOpts.ShowIncludesPretendHeader = File->getName();
Nico Weber2ca4be92016-03-01 23:16:44 +0000865 }
Dan Gohman52765212010-10-26 21:13:51 +0000866 if (!File) {
Daniel Dunbar409e8902009-11-14 07:53:04 +0000867 Diags.Report(diag::err_fe_error_reading) << InputFile;
868 return false;
869 }
Daniel Dunbare2951f42012-11-05 22:53:33 +0000870
871 // The natural SourceManager infrastructure can't currently handle named
872 // pipes, but we would at least like to accept them for the main
Benjamin Kramer3841fa32013-08-12 13:46:52 +0000873 // file. Detect them here, read them with the volatile flag so FileMgr will
874 // pick up the correct size, and simply override their contents as we do for
875 // STDIN.
Daniel Dunbare2951f42012-11-05 22:53:33 +0000876 if (File->isNamedPipe()) {
Benjamin Kramera8857962014-10-26 22:44:13 +0000877 auto MB = FileMgr.getBufferForFile(File, /*isVolatile=*/true);
878 if (MB) {
Benjamin Kramer3841fa32013-08-12 13:46:52 +0000879 // Create a new virtual file that will have the correct size.
Benjamin Kramera8857962014-10-26 22:44:13 +0000880 File = FileMgr.getVirtualFile(InputFile, (*MB)->getBufferSize(), 0);
881 SourceMgr.overrideFileContents(File, std::move(*MB));
Benjamin Kramer3841fa32013-08-12 13:46:52 +0000882 } else {
Benjamin Kramera8857962014-10-26 22:44:13 +0000883 Diags.Report(diag::err_cannot_open_file) << InputFile
884 << MB.getError().message();
Daniel Dunbare2951f42012-11-05 22:53:33 +0000885 return false;
886 }
Daniel Dunbare2951f42012-11-05 22:53:33 +0000887 }
Daniel Dunbardb0745a2012-11-27 00:04:16 +0000888
Alp Tokerb671e342014-05-21 01:12:41 +0000889 SourceMgr.setMainFileID(
890 SourceMgr.createFileID(File, SourceLocation(), Kind));
Daniel Dunbar409e8902009-11-14 07:53:04 +0000891 } else {
Rafael Espindola2d2b4202014-07-06 17:43:24 +0000892 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> SBOrErr =
893 llvm::MemoryBuffer::getSTDIN();
894 if (std::error_code EC = SBOrErr.getError()) {
895 Diags.Report(diag::err_fe_error_reading_stdin) << EC.message();
Daniel Dunbar409e8902009-11-14 07:53:04 +0000896 return false;
897 }
Rafael Espindola2d2b4202014-07-06 17:43:24 +0000898 std::unique_ptr<llvm::MemoryBuffer> SB = std::move(SBOrErr.get());
899
Dan Gohman2f76cd72010-10-26 23:21:25 +0000900 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
Chris Lattner5159f612010-11-23 08:35:12 +0000901 SB->getBufferSize(), 0);
Alp Tokerb671e342014-05-21 01:12:41 +0000902 SourceMgr.setMainFileID(
903 SourceMgr.createFileID(File, SourceLocation(), Kind));
David Blaikie49cc3182014-08-27 20:54:45 +0000904 SourceMgr.overrideFileContents(File, std::move(SB));
Daniel Dunbar409e8902009-11-14 07:53:04 +0000905 }
906
Yaron Keren8b563662015-10-03 10:46:20 +0000907 assert(SourceMgr.getMainFileID().isValid() &&
Dan Gohman52765212010-10-26 21:13:51 +0000908 "Couldn't establish MainFileID!");
Daniel Dunbar409e8902009-11-14 07:53:04 +0000909 return true;
910}
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000911
912// High-Level Operations
913
914bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
915 assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
916 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
917 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
918
919 // FIXME: Take this as an argument, once all the APIs we used have moved to
920 // taking it as an input instead of hard-coding llvm::errs.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000921 raw_ostream &OS = llvm::errs();
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000922
923 // Create the target instance.
Alp Toker80758082014-07-06 05:26:44 +0000924 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(),
Saleem Abdulrasool10a49722016-04-08 16:52:00 +0000925 getInvocation().TargetOpts));
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000926 if (!hasTarget())
927 return false;
928
Artem Belevichb5bc9232015-09-22 17:23:22 +0000929 // Create TargetInfo for the other side of CUDA compilation.
930 if (getLangOpts().CUDA && !getFrontendOpts().AuxTriple.empty()) {
Justin Lebar76945b22016-04-29 23:05:19 +0000931 auto TO = std::make_shared<TargetOptions>();
Artem Belevichb5bc9232015-09-22 17:23:22 +0000932 TO->Triple = getFrontendOpts().AuxTriple;
Justin Lebar76945b22016-04-29 23:05:19 +0000933 TO->HostTriple = getTarget().getTriple().str();
Saleem Abdulrasool10a49722016-04-08 16:52:00 +0000934 setAuxTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), TO));
Artem Belevichb5bc9232015-09-22 17:23:22 +0000935 }
936
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000937 // Inform the target of the language options.
938 //
939 // FIXME: We shouldn't need to do this, the target should be immutable once
940 // created. This complexity should be lifted elsewhere.
Alp Toker74437972014-07-06 05:14:24 +0000941 getTarget().adjust(getLangOpts());
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000942
Yaxun Liu2c17e822016-08-09 19:43:38 +0000943 // Adjust target options based on codegen options.
944 getTarget().adjustTargetOptions(getCodeGenOpts(), getTargetOpts());
945
Fariborz Jahanian29898f42012-04-16 21:03:30 +0000946 // rewriter project will change target built-in bool type from its default.
947 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
948 getTarget().noSignedCharForObjCBool();
949
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000950 // Validate/process some options.
951 if (getHeaderSearchOpts().Verbose)
952 OS << "clang -cc1 version " CLANG_VERSION_STRING
Alp Tokerf988d002014-06-06 10:36:22 +0000953 << " based upon " << BACKEND_PACKAGE_STRING
Sebastian Pop8188c8a2011-11-01 21:33:06 +0000954 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000955
956 if (getFrontendOpts().ShowTimers)
957 createFrontendTimer();
958
Matthias Braunabb6eea2016-09-26 18:53:34 +0000959 if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty())
Matthias Braunec1c5a22016-09-27 19:38:59 +0000960 llvm::EnableStatistics(false);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000961
Vedant Kumar5b60ad62015-11-16 00:59:34 +0000962 for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) {
Ted Kremenekeeccb302014-08-27 15:14:15 +0000963 // Reset the ID tables if we are reusing the SourceManager and parsing
964 // regular files.
965 if (hasSourceManager() && !Act.isModelParsingAction())
Daniel Dunbaraed46fc2010-06-07 23:23:50 +0000966 getSourceManager().clearIDTables();
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000967
Vedant Kumar5b60ad62015-11-16 00:59:34 +0000968 if (Act.BeginSourceFile(*this, FIF)) {
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000969 Act.Execute();
970 Act.EndSourceFile();
971 }
972 }
973
Argyrios Kyrtzidis7910d7b2011-12-07 05:52:12 +0000974 // Notify the diagnostic client that all files were processed.
975 getDiagnostics().getClient()->finish();
976
Chris Lattner198cb4d2010-04-07 18:47:42 +0000977 if (getDiagnosticOpts().ShowCarets) {
Argyrios Kyrtzidisc79346a2010-11-18 20:06:46 +0000978 // We can have multiple diagnostics sharing one diagnostic client.
979 // Get the total number of warnings/errors from the client.
980 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
981 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000982
Chris Lattner198cb4d2010-04-07 18:47:42 +0000983 if (NumWarnings)
984 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
985 if (NumWarnings && NumErrors)
986 OS << " and ";
987 if (NumErrors)
988 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
989 if (NumWarnings || NumErrors)
990 OS << " generated.\n";
991 }
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000992
Matthias Braunabb6eea2016-09-26 18:53:34 +0000993 if (getFrontendOpts().ShowStats) {
994 if (hasFileManager()) {
995 getFileManager().PrintStats();
996 OS << '\n';
997 }
998 llvm::PrintStatistics(OS);
999 }
1000 StringRef StatsFile = getFrontendOpts().StatsFile;
1001 if (!StatsFile.empty()) {
1002 std::error_code EC;
1003 auto StatS = llvm::make_unique<llvm::raw_fd_ostream>(StatsFile, EC,
1004 llvm::sys::fs::F_Text);
1005 if (EC) {
1006 getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file)
1007 << StatsFile << EC.message();
1008 } else {
1009 llvm::PrintStatisticsJSON(*StatS);
1010 }
Daniel Dunbar4f2bc552010-01-13 00:48:06 +00001011 }
1012
Argyrios Kyrtzidisbc467932010-11-18 21:13:57 +00001013 return !getDiagnostics().getClient()->getNumErrors();
Daniel Dunbar4f2bc552010-01-13 00:48:06 +00001014}
1015
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001016/// \brief Determine the appropriate source input kind based on language
1017/// options.
1018static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
1019 if (LangOpts.OpenCL)
1020 return IK_OpenCL;
1021 if (LangOpts.CUDA)
1022 return IK_CUDA;
1023 if (LangOpts.ObjC1)
1024 return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
1025 return LangOpts.CPlusPlus? IK_CXX : IK_C;
1026}
1027
Douglas Gregor514b6362011-11-29 19:06:37 +00001028/// \brief Compile a module file for the given module, using the options
Ben Langmuirb797d592014-07-19 16:29:28 +00001029/// provided by the importing compiler instance. Returns true if the module
1030/// was built without errors.
1031static bool compileModuleImpl(CompilerInstance &ImportingInstance,
1032 SourceLocation ImportLoc,
1033 Module *Module,
1034 StringRef ModuleFileName) {
Douglas Gregor514b6362011-11-29 19:06:37 +00001035 ModuleMap &ModMap
1036 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1037
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001038 // Construct a compiler invocation for creating this module.
David Blaikieea4395e2017-01-06 19:49:01 +00001039 auto Invocation =
1040 std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001041
Douglas Gregorf545f672011-11-29 21:59:16 +00001042 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1043
Douglas Gregor44bf68d2011-09-15 20:53:28 +00001044 // For any options that aren't intended to affect how a module is built,
1045 // reset them to their default values.
Ted Kremenek8cf47df2011-11-17 23:01:24 +00001046 Invocation->getLangOpts()->resetNonModularOptions();
Douglas Gregorf545f672011-11-29 21:59:16 +00001047 PPOpts.resetNonModularOptions();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001048
Douglas Gregor5dc38992013-02-07 00:21:12 +00001049 // Remove any macro definitions that are explicitly ignored by the module.
1050 // They aren't supposed to affect how the module is built anyway.
Duncan P. N. Exon Smith60fa2882017-03-13 18:45:08 +00001051 HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
Benjamin Kramerbbdd7642014-03-01 14:48:57 +00001052 PPOpts.Macros.erase(
1053 std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
1054 [&HSOpts](const std::pair<std::string, bool> &def) {
1055 StringRef MacroDef = def.first;
Justin Lebar5e83dfe2016-10-21 21:45:01 +00001056 return HSOpts.ModulesIgnoreMacros.count(
1057 llvm::CachedHashString(MacroDef.split('=').first)) > 0;
Benjamin Kramerbbdd7642014-03-01 14:48:57 +00001058 }),
1059 PPOpts.Macros.end());
Douglas Gregor5dc38992013-02-07 00:21:12 +00001060
Douglas Gregor7d106e42011-11-15 19:35:01 +00001061 // Note the name of the module we're building.
Douglas Gregor6dc57922011-11-29 18:31:39 +00001062 Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
Douglas Gregor7d106e42011-11-15 19:35:01 +00001063
Douglas Gregor7a626572012-11-29 23:55:25 +00001064 // Make sure that the failed-module structure has been allocated in
1065 // the importing instance, and propagate the pointer to the newly-created
1066 // instance.
1067 PreprocessorOptions &ImportingPPOpts
1068 = ImportingInstance.getInvocation().getPreprocessorOpts();
1069 if (!ImportingPPOpts.FailedModules)
David Blaikief95113d2017-01-05 19:11:31 +00001070 ImportingPPOpts.FailedModules =
1071 std::make_shared<PreprocessorOptions::FailedModulesSet>();
Douglas Gregor7a626572012-11-29 23:55:25 +00001072 PPOpts.FailedModules = ImportingPPOpts.FailedModules;
1073
Douglas Gregorf545f672011-11-29 21:59:16 +00001074 // If there is a module map file, build the module using the module map.
Douglas Gregor44bf68d2011-09-15 20:53:28 +00001075 // Set up the inputs/outputs so that we build the module from its umbrella
1076 // header.
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001077 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
Douglas Gregor1735f4e2011-09-13 23:15:45 +00001078 FrontendOpts.OutputFile = ModuleFileName.str();
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001079 FrontendOpts.DisableFree = false;
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001080 FrontendOpts.GenerateGlobalModuleIndex = false;
Richard Smithe75ee0f2015-08-17 07:13:32 +00001081 FrontendOpts.BuildingImplicitModule = true;
Duncan P. N. Exon Smith60fa2882017-03-13 18:45:08 +00001082 // Force implicitly-built modules to hash the content of the module file.
1083 HSOpts.ModulesHashContent = true;
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001084 FrontendOpts.Inputs.clear();
Douglas Gregorf545f672011-11-29 21:59:16 +00001085 InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001086
Douglas Gregorf545f672011-11-29 21:59:16 +00001087 // Don't free the remapped file buffers; they are owned by our caller.
1088 PPOpts.RetainRemappedFileBuffers = true;
1089
Douglas Gregor2b9b4642011-09-13 01:26:44 +00001090 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
Douglas Gregor3728ea72011-09-13 23:20:27 +00001091 assert(ImportingInstance.getInvocation().getModuleHash() ==
Douglas Gregorf545f672011-11-29 21:59:16 +00001092 Invocation->getModuleHash() && "Module hash mismatch!");
1093
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001094 // Construct a compiler instance that will be used to actually create the
Duncan P. N. Exon Smith030d7d62017-03-20 17:58:26 +00001095 // module. Since we're sharing a PCMCache,
1096 // CompilerInstance::CompilerInstance is responsible for finalizing the
1097 // buffers to prevent use-after-frees.
Adrian Prantlbb165fb2015-06-20 18:53:08 +00001098 CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
Duncan P. N. Exon Smith030d7d62017-03-20 17:58:26 +00001099 &ImportingInstance.getPreprocessor().getPCMCache());
David Blaikieea4395e2017-01-06 19:49:01 +00001100 auto &Inv = *Invocation;
1101 Instance.setInvocation(std::move(Invocation));
Douglas Gregor6b930962013-05-03 22:58:43 +00001102
1103 Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
1104 ImportingInstance.getDiagnosticClient()),
Douglas Gregor30071cea2013-05-03 23:07:45 +00001105 /*ShouldOwnClient=*/true);
Douglas Gregoraf8f0262012-11-30 18:38:50 +00001106
Ben Langmuirc8130a72014-02-20 21:59:23 +00001107 Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
1108
Douglas Gregor63365432012-11-30 22:11:57 +00001109 // Note that this module is part of the module build stack, so that we
Douglas Gregoraf8f0262012-11-30 18:38:50 +00001110 // can detect cycles in the module graph.
Ben Langmuird066d4c2014-02-28 21:16:07 +00001111 Instance.setFileManager(&ImportingInstance.getFileManager());
Douglas Gregoraf8f0262012-11-30 18:38:50 +00001112 Instance.createSourceManager(Instance.getFileManager());
1113 SourceManager &SourceMgr = Instance.getSourceManager();
Douglas Gregor63365432012-11-30 22:11:57 +00001114 SourceMgr.setModuleBuildStack(
1115 ImportingInstance.getSourceManager().getModuleBuildStack());
1116 SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(),
Douglas Gregoraf8f0262012-11-30 18:38:50 +00001117 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
1118
Justin Bogner86d12592014-06-19 19:36:03 +00001119 // If we're collecting module dependencies, we need to share a collector
Richard Smith38c1e6d2015-08-09 06:03:55 +00001120 // between all of the module CompilerInstances. Other than that, we don't
1121 // want to produce any dependency output from the module build.
Justin Bogner86d12592014-06-19 19:36:03 +00001122 Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
David Blaikieea4395e2017-01-06 19:49:01 +00001123 Inv.getDependencyOutputOpts() = DependencyOutputOptions();
Justin Bogner86d12592014-06-19 19:36:03 +00001124
Manuel Klimek1f76c4e2013-10-24 07:51:24 +00001125 // Get or create the module map that we'll use to build this module.
1126 std::string InferredModuleMapContent;
1127 if (const FileEntry *ModuleMapFile =
1128 ModMap.getContainingModuleMapFile(Module)) {
1129 // Use the module map where this module resides.
Benjamin Kramer3204b152015-05-29 19:42:19 +00001130 FrontendOpts.Inputs.emplace_back(ModuleMapFile->getName(), IK);
Manuel Klimek1f76c4e2013-10-24 07:51:24 +00001131 } else {
Richard Smith2b63d152015-05-16 02:28:53 +00001132 SmallString<128> FakeModuleMapFile(Module->Directory->getName());
1133 llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map");
Benjamin Kramer3204b152015-05-29 19:42:19 +00001134 FrontendOpts.Inputs.emplace_back(FakeModuleMapFile, IK);
Richard Smith2b63d152015-05-16 02:28:53 +00001135
Manuel Klimek1f76c4e2013-10-24 07:51:24 +00001136 llvm::raw_string_ostream OS(InferredModuleMapContent);
1137 Module->print(OS);
1138 OS.flush();
Manuel Klimek1f76c4e2013-10-24 07:51:24 +00001139
Rafael Espindolad87f8d72014-08-27 20:03:29 +00001140 std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
Manuel Klimek1f76c4e2013-10-24 07:51:24 +00001141 llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
1142 ModuleMapFile = Instance.getFileManager().getVirtualFile(
Richard Smith2b63d152015-05-16 02:28:53 +00001143 FakeModuleMapFile, InferredModuleMapContent.size(), 0);
David Blaikie49cc3182014-08-27 20:54:45 +00001144 SourceMgr.overrideFileContents(ModuleMapFile, std::move(ModuleMapBuffer));
Manuel Klimek1f76c4e2013-10-24 07:51:24 +00001145 }
Douglas Gregoraf8f0262012-11-30 18:38:50 +00001146
Ben Langmuir9d6448b2014-08-09 00:57:23 +00001147 // Construct a module-generating action. Passing through the module map is
Ben Langmuirbeee15e2014-04-14 18:00:01 +00001148 // safe because the FileManager is shared between the compiler instances.
Richard Smithbbcc9f02016-08-26 00:14:38 +00001149 GenerateModuleFromModuleMapAction CreateModuleAction(
Ben Langmuir9d6448b2014-08-09 00:57:23 +00001150 ModMap.getModuleMapFileForUniquing(Module), Module->IsSystem);
Richard Smith99891da2014-10-14 02:08:30 +00001151
1152 ImportingInstance.getDiagnostics().Report(ImportLoc,
1153 diag::remark_module_build)
1154 << Module->Name << ModuleFileName;
1155
Douglas Gregor51e0b542011-10-04 00:21:21 +00001156 // Execute the action to actually build the module in-place. Use a separate
1157 // thread so that we get a stack large enough.
1158 const unsigned ThreadStackSize = 8 << 20;
1159 llvm::CrashRecoveryContext CRC;
Richard Smith841f1c72014-03-04 21:50:01 +00001160 CRC.RunSafelyOnThread([&]() { Instance.ExecuteAction(CreateModuleAction); },
1161 ThreadStackSize);
Douglas Gregor6b930962013-05-03 22:58:43 +00001162
Richard Smith99891da2014-10-14 02:08:30 +00001163 ImportingInstance.getDiagnostics().Report(ImportLoc,
1164 diag::remark_module_build_done)
1165 << Module->Name;
1166
Douglas Gregorf545f672011-11-29 21:59:16 +00001167 // Delete the temporary module map file.
1168 // FIXME: Even though we're executing under crash protection, it would still
1169 // be nice to do this with RemoveFileOnSignal when we can. However, that
1170 // doesn't make sense for all clients, so clean this up manually.
Benjamin Kramer13afbf42012-10-14 19:50:53 +00001171 Instance.clearOutputFiles(/*EraseFiles=*/true);
Douglas Gregor5e306b12013-01-23 22:38:11 +00001172
1173 // We've rebuilt a module. If we're allowed to generate or update the global
1174 // module index, record that fact in the importing compiler instance.
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001175 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
Douglas Gregor5e306b12013-01-23 22:38:11 +00001176 ImportingInstance.setBuildGlobalModuleIndex(true);
1177 }
Ben Langmuirb797d592014-07-19 16:29:28 +00001178
1179 return !Instance.getDiagnostics().hasErrorOccurred();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001180}
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001181
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001182static bool compileAndLoadModule(CompilerInstance &ImportingInstance,
1183 SourceLocation ImportLoc,
Ben Langmuirb797d592014-07-19 16:29:28 +00001184 SourceLocation ModuleNameLoc, Module *Module,
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001185 StringRef ModuleFileName) {
Ben Langmuird213aab2014-09-26 22:42:23 +00001186 DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1187
Ben Langmuirb797d592014-07-19 16:29:28 +00001188 auto diagnoseBuildFailure = [&] {
Ben Langmuird213aab2014-09-26 22:42:23 +00001189 Diags.Report(ModuleNameLoc, diag::err_module_not_built)
Ben Langmuirb797d592014-07-19 16:29:28 +00001190 << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1191 };
1192
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001193 // FIXME: have LockFileManager return an error_code so that we can
1194 // avoid the mkdir when the directory already exists.
1195 StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
1196 llvm::sys::fs::create_directories(Dir);
1197
1198 while (1) {
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001199 unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001200 llvm::LockFileManager Locked(ModuleFileName);
1201 switch (Locked) {
1202 case llvm::LockFileManager::LFS_Error:
Bruno Cardoso Lopes5a0af1f2017-03-18 00:26:18 +00001203 // PCMCache takes care of correctness and locks are only necessary for
1204 // performance. Fallback to building the module in case of any lock
1205 // related errors.
1206 Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure)
Bruno Cardoso Lopes4a522222016-06-04 01:13:22 +00001207 << Module->Name << Locked.getErrorMessage();
Bruno Cardoso Lopes5a0af1f2017-03-18 00:26:18 +00001208 // Clear out any potential leftover.
1209 Locked.unsafeRemoveLockFile();
1210 // FALLTHROUGH
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001211 case llvm::LockFileManager::LFS_Owned:
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001212 // We're responsible for building the module ourselves.
Ben Langmuirb797d592014-07-19 16:29:28 +00001213 if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
1214 ModuleFileName)) {
1215 diagnoseBuildFailure();
1216 return false;
1217 }
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001218 break;
1219
1220 case llvm::LockFileManager::LFS_Shared:
1221 // Someone else is responsible for building the module. Wait for them to
1222 // finish.
Ben Langmuir1daf4802015-02-09 20:35:13 +00001223 switch (Locked.waitForUnlock()) {
1224 case llvm::LockFileManager::Res_Success:
1225 ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1226 break;
1227 case llvm::LockFileManager::Res_OwnerDied:
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001228 continue; // try again to get the lock.
Ben Langmuir1daf4802015-02-09 20:35:13 +00001229 case llvm::LockFileManager::Res_Timeout:
Bruno Cardoso Lopes5a0af1f2017-03-18 00:26:18 +00001230 // Since PCMCache takes care of correctness, we try waiting for another
1231 // process to complete the build so clang does not do it done twice. If
1232 // case of timeout, build it ourselves.
1233 Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout)
Ben Langmuir1daf4802015-02-09 20:35:13 +00001234 << Module->Name;
1235 // Clear the lock file so that future invokations can make progress.
1236 Locked.unsafeRemoveLockFile();
Bruno Cardoso Lopes5a0af1f2017-03-18 00:26:18 +00001237 continue;
Ben Langmuir1daf4802015-02-09 20:35:13 +00001238 }
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001239 break;
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001240 }
1241
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001242 // Try to read the module file, now that we've compiled it.
1243 ASTReader::ASTReadResult ReadResult =
1244 ImportingInstance.getModuleManager()->ReadAST(
Richard Smithe842a472014-10-22 02:05:46 +00001245 ModuleFileName, serialization::MK_ImplicitModule, ImportLoc,
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001246 ModuleLoadCapabilities);
1247
1248 if (ReadResult == ASTReader::OutOfDate &&
1249 Locked == llvm::LockFileManager::LFS_Shared) {
1250 // The module may be out of date in the presence of file system races,
1251 // or if one of its imports depends on header search paths that are not
1252 // consistent with this ImportingInstance. Try again...
1253 continue;
1254 } else if (ReadResult == ASTReader::Missing) {
Ben Langmuirb797d592014-07-19 16:29:28 +00001255 diagnoseBuildFailure();
Ben Langmuird213aab2014-09-26 22:42:23 +00001256 } else if (ReadResult != ASTReader::Success &&
1257 !Diags.hasErrorOccurred()) {
1258 // The ASTReader didn't diagnose the error, so conservatively report it.
1259 diagnoseBuildFailure();
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001260 }
1261 return ReadResult == ASTReader::Success;
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001262 }
1263}
1264
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001265/// \brief Diagnose differences between the current definition of the given
1266/// configuration macro and the definition provided on the command line.
1267static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1268 Module *Mod, SourceLocation ImportLoc) {
1269 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
1270 SourceManager &SourceMgr = PP.getSourceManager();
1271
1272 // If this identifier has never had a macro definition, then it could
1273 // not have changed.
1274 if (!Id->hadMacroDefinition())
1275 return;
Richard Smith20e883e2015-04-29 23:20:19 +00001276 auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id);
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001277
Richard Smith20e883e2015-04-29 23:20:19 +00001278 // Find the macro definition from the command line.
1279 MacroInfo *CmdLineDefinition = nullptr;
1280 for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001281 // We only care about the predefines buffer.
Richard Smith20e883e2015-04-29 23:20:19 +00001282 FileID FID = SourceMgr.getFileID(MD->getLocation());
1283 if (FID.isInvalid() || FID != PP.getPredefinesFileID())
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001284 continue;
Richard Smith20e883e2015-04-29 23:20:19 +00001285 if (auto *DMD = dyn_cast<DefMacroDirective>(MD))
1286 CmdLineDefinition = DMD->getMacroInfo();
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001287 break;
1288 }
1289
Richard Smith20e883e2015-04-29 23:20:19 +00001290 auto *CurrentDefinition = PP.getMacroInfo(Id);
1291 if (CurrentDefinition == CmdLineDefinition) {
1292 // Macro matches. Nothing to do.
1293 } else if (!CurrentDefinition) {
1294 // This macro was defined on the command line, then #undef'd later.
1295 // Complain.
1296 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1297 << true << ConfigMacro << Mod->getFullModuleName();
1298 auto LatestDef = LatestLocalMD->getDefinition();
1299 assert(LatestDef.isUndefined() &&
1300 "predefined macro went away with no #undef?");
1301 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1302 << true;
1303 return;
1304 } else if (!CmdLineDefinition) {
1305 // There was no definition for this macro in the predefines buffer,
1306 // but there was a local definition. Complain.
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001307 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1308 << false << ConfigMacro << Mod->getFullModuleName();
Richard Smith20e883e2015-04-29 23:20:19 +00001309 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1310 diag::note_module_def_undef_here)
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001311 << false;
Richard Smith20e883e2015-04-29 23:20:19 +00001312 } else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,
1313 /*Syntactically=*/true)) {
1314 // The macro definitions differ.
1315 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1316 << false << ConfigMacro << Mod->getFullModuleName();
1317 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1318 diag::note_module_def_undef_here)
1319 << false;
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001320 }
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001321}
1322
Douglas Gregor527b1c92013-03-25 21:19:16 +00001323/// \brief Write a new timestamp file with the given path.
1324static void writeTimestampFile(StringRef TimestampFile) {
Rafael Espindoladae941a2014-08-25 18:17:04 +00001325 std::error_code EC;
1326 llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None);
Douglas Gregor527b1c92013-03-25 21:19:16 +00001327}
1328
1329/// \brief Prune the module cache of modules that haven't been accessed in
1330/// a long time.
1331static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1332 struct stat StatBuf;
1333 llvm::SmallString<128> TimestampFile;
1334 TimestampFile = HSOpts.ModuleCachePath;
Richard Smith3938f0c2015-08-15 00:34:15 +00001335 assert(!TimestampFile.empty());
Douglas Gregor527b1c92013-03-25 21:19:16 +00001336 llvm::sys::path::append(TimestampFile, "modules.timestamp");
1337
1338 // Try to stat() the timestamp file.
1339 if (::stat(TimestampFile.c_str(), &StatBuf)) {
1340 // If the timestamp file wasn't there, create one now.
1341 if (errno == ENOENT) {
1342 writeTimestampFile(TimestampFile);
1343 }
1344 return;
1345 }
1346
1347 // Check whether the time stamp is older than our pruning interval.
1348 // If not, do nothing.
1349 time_t TimeStampModTime = StatBuf.st_mtime;
Craig Topper49a27902014-05-22 04:46:25 +00001350 time_t CurrentTime = time(nullptr);
Benjamin Kramerdbcf5032013-03-29 17:39:43 +00001351 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
Douglas Gregor527b1c92013-03-25 21:19:16 +00001352 return;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001353
1354 // Write a new timestamp file so that nobody else attempts to prune.
1355 // There is a benign race condition here, if two Clang instances happen to
1356 // notice at the same time that the timestamp is out-of-date.
1357 writeTimestampFile(TimestampFile);
1358
1359 // Walk the entire module cache, looking for unused module files and module
1360 // indices.
Rafael Espindolac0809172014-06-12 14:02:15 +00001361 std::error_code EC;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001362 SmallString<128> ModuleCachePathNative;
1363 llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
Yaron Keren92e1b622015-03-18 10:17:07 +00001364 for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001365 Dir != DirEnd && !EC; Dir.increment(EC)) {
1366 // If we don't have a directory, there's nothing to look into.
Rafael Espindolaa07f7202013-07-17 04:23:07 +00001367 if (!llvm::sys::fs::is_directory(Dir->path()))
Douglas Gregor527b1c92013-03-25 21:19:16 +00001368 continue;
1369
1370 // Walk all of the files within this directory.
Douglas Gregor527b1c92013-03-25 21:19:16 +00001371 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1372 File != FileEnd && !EC; File.increment(EC)) {
1373 // We only care about module and global module index files.
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001374 StringRef Extension = llvm::sys::path::extension(File->path());
1375 if (Extension != ".pcm" && Extension != ".timestamp" &&
1376 llvm::sys::path::filename(File->path()) != "modules.idx")
Douglas Gregor527b1c92013-03-25 21:19:16 +00001377 continue;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001378
1379 // Look at this file. If we can't stat it, there's nothing interesting
1380 // there.
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001381 if (::stat(File->path().c_str(), &StatBuf))
Douglas Gregor527b1c92013-03-25 21:19:16 +00001382 continue;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001383
1384 // If the file has been used recently enough, leave it there.
1385 time_t FileAccessTime = StatBuf.st_atime;
Benjamin Kramerdbcf5032013-03-29 17:39:43 +00001386 if (CurrentTime - FileAccessTime <=
1387 time_t(HSOpts.ModuleCachePruneAfter)) {
Douglas Gregor527b1c92013-03-25 21:19:16 +00001388 continue;
1389 }
1390
1391 // Remove the file.
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001392 llvm::sys::fs::remove(File->path());
1393
1394 // Remove the timestamp file.
1395 std::string TimpestampFilename = File->path() + ".timestamp";
1396 llvm::sys::fs::remove(TimpestampFilename);
Douglas Gregor527b1c92013-03-25 21:19:16 +00001397 }
1398
1399 // If we removed all of the files in the directory, remove the directory
1400 // itself.
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001401 if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1402 llvm::sys::fs::directory_iterator() && !EC)
Rafael Espindola2a008782014-01-10 21:32:14 +00001403 llvm::sys::fs::remove(Dir->path());
Douglas Gregor527b1c92013-03-25 21:19:16 +00001404 }
1405}
1406
John Thompson2255f2c2014-04-23 12:57:01 +00001407void CompilerInstance::createModuleManager() {
1408 if (!ModuleManager) {
1409 if (!hasASTContext())
1410 createASTContext();
1411
Chandler Carruth580dd292015-03-24 21:44:25 +00001412 // If we're implicitly building modules but not currently recursively
1413 // building a module, check whether we need to prune the module cache.
Richard Smith3938f0c2015-08-15 00:34:15 +00001414 if (getSourceManager().getModuleBuildStack().empty() &&
1415 !getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty() &&
John Thompson2255f2c2014-04-23 12:57:01 +00001416 getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1417 getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1418 pruneModuleCache(getHeaderSearchOpts());
1419 }
1420
1421 HeaderSearchOptions &HSOpts = getHeaderSearchOpts();
1422 std::string Sysroot = HSOpts.Sysroot;
1423 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
Richard Smithce18a182015-07-14 00:26:00 +00001424 std::unique_ptr<llvm::Timer> ReadTimer;
1425 if (FrontendTimerGroup)
Matthias Braunae032b62016-11-18 19:43:25 +00001426 ReadTimer = llvm::make_unique<llvm::Timer>("reading_modules",
1427 "Reading modules",
Richard Smithce18a182015-07-14 00:26:00 +00001428 *FrontendTimerGroup);
Adrian Prantlbb165fb2015-06-20 18:53:08 +00001429 ModuleManager = new ASTReader(
Richard Smith293534b2015-08-18 20:39:29 +00001430 getPreprocessor(), getASTContext(), getPCHContainerReader(),
Douglas Gregor6623e1f2015-11-03 18:33:07 +00001431 getFrontendOpts().ModuleFileExtensions,
Adrian Prantlbb165fb2015-06-20 18:53:08 +00001432 Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation,
1433 /*AllowASTWithCompilerErrors=*/false,
1434 /*AllowConfigurationMismatch=*/false,
1435 HSOpts.ModulesValidateSystemHeaders,
Richard Smithce18a182015-07-14 00:26:00 +00001436 getFrontendOpts().UseGlobalModuleIndex,
1437 std::move(ReadTimer));
John Thompson2255f2c2014-04-23 12:57:01 +00001438 if (hasASTConsumer()) {
1439 ModuleManager->setDeserializationListener(
1440 getASTConsumer().GetASTDeserializationListener());
1441 getASTContext().setASTMutationListener(
1442 getASTConsumer().GetASTMutationListener());
1443 }
1444 getASTContext().setExternalSource(ModuleManager);
1445 if (hasSema())
1446 ModuleManager->InitializeSema(getSema());
Richard Smith293534b2015-08-18 20:39:29 +00001447 if (hasASTConsumer())
John Thompson2255f2c2014-04-23 12:57:01 +00001448 ModuleManager->StartTranslationUnit(&getASTConsumer());
Richard Smith03f7e612015-08-09 02:28:42 +00001449
1450 if (TheDependencyFileGenerator)
1451 TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
Richard Smith03f7e612015-08-09 02:28:42 +00001452 for (auto &Listener : DependencyCollectors)
1453 Listener->attachToASTReader(*ModuleManager);
John Thompson2255f2c2014-04-23 12:57:01 +00001454 }
1455}
1456
Richard Smithd4b230b2014-10-27 23:01:16 +00001457bool CompilerInstance::loadModuleFile(StringRef FileName) {
Richard Smithce18a182015-07-14 00:26:00 +00001458 llvm::Timer Timer;
1459 if (FrontendTimerGroup)
Matthias Braunae032b62016-11-18 19:43:25 +00001460 Timer.init("preloading." + FileName.str(), "Preloading " + FileName.str(),
1461 *FrontendTimerGroup);
Richard Smithce18a182015-07-14 00:26:00 +00001462 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1463
Richard Smithd4b230b2014-10-27 23:01:16 +00001464 // Helper to recursively read the module names for all modules we're adding.
1465 // We mark these as known and redirect any attempt to load that module to
1466 // the files we were handed.
1467 struct ReadModuleNames : ASTReaderListener {
1468 CompilerInstance &CI;
Richard Smith0f99d6a2015-08-09 08:48:41 +00001469 llvm::SmallVector<IdentifierInfo*, 8> LoadedModules;
Richard Smithe842a472014-10-22 02:05:46 +00001470
Richard Smith0f99d6a2015-08-09 08:48:41 +00001471 ReadModuleNames(CompilerInstance &CI) : CI(CI) {}
Richard Smithe842a472014-10-22 02:05:46 +00001472
Richard Smithd4b230b2014-10-27 23:01:16 +00001473 void ReadModuleName(StringRef ModuleName) override {
Richard Smith0f99d6a2015-08-09 08:48:41 +00001474 LoadedModules.push_back(
1475 CI.getPreprocessor().getIdentifierInfo(ModuleName));
Richard Smithd4b230b2014-10-27 23:01:16 +00001476 }
Richard Smith0f99d6a2015-08-09 08:48:41 +00001477
1478 void registerAll() {
1479 for (auto *II : LoadedModules) {
1480 CI.KnownModules[II] = CI.getPreprocessor()
1481 .getHeaderSearchInfo()
1482 .getModuleMap()
1483 .findModule(II->getName());
1484 }
1485 LoadedModules.clear();
1486 }
Richard Smith8a308ec2015-11-05 00:54:55 +00001487
1488 void markAllUnavailable() {
1489 for (auto *II : LoadedModules) {
1490 if (Module *M = CI.getPreprocessor()
1491 .getHeaderSearchInfo()
1492 .getModuleMap()
Richard Smitha114c462016-12-06 00:40:17 +00001493 .findModule(II->getName())) {
Richard Smith8a308ec2015-11-05 00:54:55 +00001494 M->HasIncompatibleModuleFile = true;
Richard Smitha114c462016-12-06 00:40:17 +00001495
1496 // Mark module as available if the only reason it was unavailable
1497 // was missing headers.
1498 SmallVector<Module *, 2> Stack;
1499 Stack.push_back(M);
1500 while (!Stack.empty()) {
1501 Module *Current = Stack.pop_back_val();
1502 if (Current->IsMissingRequirement) continue;
1503 Current->IsAvailable = true;
1504 Stack.insert(Stack.end(),
1505 Current->submodule_begin(), Current->submodule_end());
1506 }
1507 }
Richard Smith8a308ec2015-11-05 00:54:55 +00001508 }
1509 LoadedModules.clear();
1510 }
Richard Smith0f99d6a2015-08-09 08:48:41 +00001511 };
Richard Smithd4b230b2014-10-27 23:01:16 +00001512
Richard Smith7f330cd2015-03-18 01:42:29 +00001513 // If we don't already have an ASTReader, create one now.
1514 if (!ModuleManager)
1515 createModuleManager();
1516
Richard Smith0f99d6a2015-08-09 08:48:41 +00001517 auto Listener = llvm::make_unique<ReadModuleNames>(*this);
1518 auto &ListenerRef = *Listener;
1519 ASTReader::ListenerScope ReadModuleNamesListener(*ModuleManager,
1520 std::move(Listener));
Richard Smith7f330cd2015-03-18 01:42:29 +00001521
Richard Smith0f99d6a2015-08-09 08:48:41 +00001522 // Try to load the module file.
Richard Smith95dc57a2015-10-16 23:20:19 +00001523 switch (ModuleManager->ReadAST(FileName, serialization::MK_ExplicitModule,
1524 SourceLocation(),
1525 ASTReader::ARR_ConfigurationMismatch)) {
1526 case ASTReader::Success:
Richard Smith8a308ec2015-11-05 00:54:55 +00001527 // We successfully loaded the module file; remember the set of provided
1528 // modules so that we don't try to load implicit modules for them.
1529 ListenerRef.registerAll();
1530 return true;
Richard Smith95dc57a2015-10-16 23:20:19 +00001531
1532 case ASTReader::ConfigurationMismatch:
1533 // Ignore unusable module files.
1534 getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch)
1535 << FileName;
Richard Smith8a308ec2015-11-05 00:54:55 +00001536 // All modules provided by any files we tried and failed to load are now
1537 // unavailable; includes of those modules should now be handled textually.
1538 ListenerRef.markAllUnavailable();
Richard Smith95dc57a2015-10-16 23:20:19 +00001539 return true;
1540
1541 default:
1542 return false;
1543 }
Richard Smithe842a472014-10-22 02:05:46 +00001544}
1545
1546ModuleLoadResult
Douglas Gregor7a626572012-11-29 23:55:25 +00001547CompilerInstance::loadModule(SourceLocation ImportLoc,
1548 ModuleIdPath Path,
1549 Module::NameVisibilityKind Visibility,
1550 bool IsInclusionDirective) {
Richard Smith92304e02013-10-18 22:48:20 +00001551 // Determine what file we're searching from.
1552 StringRef ModuleName = Path[0].first->getName();
1553 SourceLocation ModuleNameLoc = Path[0].second;
1554
Douglas Gregor1805b8a2011-11-30 04:26:53 +00001555 // If we've already handled this import, just return the cached result.
1556 // This one-element cache is important to eliminate redundant diagnostics
1557 // when both the preprocessor and parser see the same import declaration.
Yaron Keren8b563662015-10-03 10:46:20 +00001558 if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) {
Douglas Gregorff2be532011-12-01 17:11:21 +00001559 // Make the named module visible.
Richard Smith7e82e012016-02-19 22:25:36 +00001560 if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
Argyrios Kyrtzidis125df052013-02-01 16:36:12 +00001561 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
Richard Smitha7e2cc62015-05-01 01:53:09 +00001562 ImportLoc);
Douglas Gregor69021972011-11-30 17:33:56 +00001563 return LastModuleImportResult;
Douglas Gregorff2be532011-12-01 17:11:21 +00001564 }
Douglas Gregor5196bc62011-11-30 04:03:44 +00001565
Craig Topper49a27902014-05-22 04:46:25 +00001566 clang::Module *Module = nullptr;
Richard Smith92304e02013-10-18 22:48:20 +00001567
Douglas Gregor5196bc62011-11-30 04:03:44 +00001568 // If we don't already have information on this module, load the module now.
Douglas Gregorde3ef502011-11-30 23:21:26 +00001569 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
Douglas Gregor69021972011-11-30 17:33:56 +00001570 = KnownModules.find(Path[0].first);
Douglas Gregor2537a362011-12-08 17:01:29 +00001571 if (Known != KnownModules.end()) {
1572 // Retrieve the cached top-level module.
1573 Module = Known->second;
Richard Smith7e82e012016-02-19 22:25:36 +00001574 } else if (ModuleName == getLangOpts().CurrentModule) {
Douglas Gregor2537a362011-12-08 17:01:29 +00001575 // This is the module we're building.
Ben Langmuir527040e2014-05-05 05:31:33 +00001576 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
Douglas Gregor2537a362011-12-08 17:01:29 +00001577 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1578 } else {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001579 // Search for a module with the given name.
Douglas Gregor279a6c32012-01-29 17:08:11 +00001580 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
Manman Ren11f2a472016-08-18 17:42:15 +00001581 HeaderSearchOptions &HSOpts =
1582 PP->getHeaderSearchInfo().getHeaderSearchOpts();
1583
1584 std::string ModuleFileName;
1585 bool LoadFromPrebuiltModulePath = false;
1586 // We try to load the module from the prebuilt module paths. If not
1587 // successful, we then try to find it in the module cache.
1588 if (!HSOpts.PrebuiltModulePaths.empty()) {
1589 // Load the module from the prebuilt module path.
1590 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(
1591 ModuleName, "", /*UsePrebuiltPath*/ true);
1592 if (!ModuleFileName.empty())
1593 LoadFromPrebuiltModulePath = true;
1594 }
1595 if (!LoadFromPrebuiltModulePath && Module) {
1596 // Load the module from the module cache.
1597 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module);
1598 } else if (!LoadFromPrebuiltModulePath) {
1599 // We can't find a module, error out here.
Ben Langmuir9eb229b2014-01-22 23:19:39 +00001600 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1601 << ModuleName
1602 << SourceRange(ImportLoc, ModuleNameLoc);
1603 ModuleBuildFailed = true;
1604 return ModuleLoadResult();
1605 }
1606
Richard Smithd520a252015-07-21 18:07:47 +00001607 if (ModuleFileName.empty()) {
Manman Ren11f2a472016-08-18 17:42:15 +00001608 if (Module && Module->HasIncompatibleModuleFile) {
Richard Smith8a308ec2015-11-05 00:54:55 +00001609 // We tried and failed to load a module file for this module. Fall
1610 // back to textual inclusion for its headers.
Richard Smitha114c462016-12-06 00:40:17 +00001611 return ModuleLoadResult::ConfigMismatch;
Richard Smith8a308ec2015-11-05 00:54:55 +00001612 }
1613
Manuel Klimekd2e8b042015-02-20 11:44:41 +00001614 getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
1615 << ModuleName;
1616 ModuleBuildFailed = true;
1617 return ModuleLoadResult();
1618 }
Richard Smithd4b230b2014-10-27 23:01:16 +00001619
Douglas Gregor5196bc62011-11-30 04:03:44 +00001620 // If we don't already have an ASTReader, create one now.
John Thompson2255f2c2014-04-23 12:57:01 +00001621 if (!ModuleManager)
1622 createModuleManager();
Douglas Gregor5196bc62011-11-30 04:03:44 +00001623
Richard Smithce18a182015-07-14 00:26:00 +00001624 llvm::Timer Timer;
1625 if (FrontendTimerGroup)
Matthias Braunae032b62016-11-18 19:43:25 +00001626 Timer.init("loading." + ModuleFileName, "Loading " + ModuleFileName,
1627 *FrontendTimerGroup);
Richard Smithce18a182015-07-14 00:26:00 +00001628 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1629
Manman Ren11f2a472016-08-18 17:42:15 +00001630 // Try to load the module file. If we are trying to load from the prebuilt
1631 // module path, we don't have the module map files and don't know how to
1632 // rebuild modules.
1633 unsigned ARRFlags = LoadFromPrebuiltModulePath ?
1634 ASTReader::ARR_ConfigurationMismatch :
1635 ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing;
Richard Smithe842a472014-10-22 02:05:46 +00001636 switch (ModuleManager->ReadAST(ModuleFileName,
Manman Ren11f2a472016-08-18 17:42:15 +00001637 LoadFromPrebuiltModulePath ?
1638 serialization::MK_PrebuiltModule :
Richard Smith86cc8292015-08-09 08:58:36 +00001639 serialization::MK_ImplicitModule,
Manman Ren11f2a472016-08-18 17:42:15 +00001640 ImportLoc,
1641 ARRFlags)) {
1642 case ASTReader::Success: {
1643 if (LoadFromPrebuiltModulePath && !Module) {
1644 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1645 if (!Module || !Module->getASTFile() ||
1646 FileMgr->getFile(ModuleFileName) != Module->getASTFile()) {
1647 // Error out if Module does not refer to the file in the prebuilt
1648 // module path.
1649 getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt)
1650 << ModuleName;
1651 ModuleBuildFailed = true;
1652 KnownModules[Path[0].first] = nullptr;
1653 return ModuleLoadResult();
1654 }
1655 }
Douglas Gregor5196bc62011-11-30 04:03:44 +00001656 break;
Manman Ren11f2a472016-08-18 17:42:15 +00001657 }
Douglas Gregor5196bc62011-11-30 04:03:44 +00001658
Eli Friedman963ff2c2013-09-17 00:51:29 +00001659 case ASTReader::OutOfDate:
Douglas Gregor7029ce12013-03-19 00:28:20 +00001660 case ASTReader::Missing: {
Manman Ren11f2a472016-08-18 17:42:15 +00001661 if (LoadFromPrebuiltModulePath) {
1662 // We can't rebuild the module without a module map. Since ReadAST
1663 // already produces diagnostics for these two cases, we simply
1664 // error out here.
1665 ModuleBuildFailed = true;
1666 KnownModules[Path[0].first] = nullptr;
1667 return ModuleLoadResult();
1668 }
1669
Eli Friedman963ff2c2013-09-17 00:51:29 +00001670 // The module file is missing or out-of-date. Build it.
Ben Langmuir9eb229b2014-01-22 23:19:39 +00001671 assert(Module && "missing module file");
Douglas Gregor7029ce12013-03-19 00:28:20 +00001672 // Check whether there is a cycle in the module graph.
1673 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1674 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1675 for (; Pos != PosEnd; ++Pos) {
1676 if (Pos->first == ModuleName)
1677 break;
1678 }
1679
1680 if (Pos != PosEnd) {
1681 SmallString<256> CyclePath;
1682 for (; Pos != PosEnd; ++Pos) {
1683 CyclePath += Pos->first;
1684 CyclePath += " -> ";
1685 }
1686 CyclePath += ModuleName;
1687
1688 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1689 << ModuleName << CyclePath;
1690 return ModuleLoadResult();
1691 }
Douglas Gregor7a626572012-11-29 23:55:25 +00001692
1693 // Check whether we have already attempted to build this module (but
1694 // failed).
1695 if (getPreprocessorOpts().FailedModules &&
1696 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1697 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1698 << ModuleName
1699 << SourceRange(ImportLoc, ModuleNameLoc);
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001700 ModuleBuildFailed = true;
Douglas Gregor7a626572012-11-29 23:55:25 +00001701 return ModuleLoadResult();
1702 }
1703
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001704 // Try to compile and then load the module.
1705 if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module,
1706 ModuleFileName)) {
Ben Langmuird213aab2014-09-26 22:42:23 +00001707 assert(getDiagnostics().hasErrorOccurred() &&
1708 "undiagnosed error in compileAndLoadModule");
Douglas Gregor0f2b4632013-01-10 02:04:18 +00001709 if (getPreprocessorOpts().FailedModules)
1710 getPreprocessorOpts().FailedModules->addFailed(ModuleName);
Craig Topper49a27902014-05-22 04:46:25 +00001711 KnownModules[Path[0].first] = nullptr;
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001712 ModuleBuildFailed = true;
Douglas Gregor7a626572012-11-29 23:55:25 +00001713 return ModuleLoadResult();
Douglas Gregor188dbef2012-11-07 17:46:15 +00001714 }
1715
1716 // Okay, we've rebuilt and now loaded the module.
1717 break;
1718 }
1719
Douglas Gregorc9ad5fb2012-10-22 22:50:17 +00001720 case ASTReader::ConfigurationMismatch:
Manman Ren11f2a472016-08-18 17:42:15 +00001721 if (LoadFromPrebuiltModulePath)
1722 getDiagnostics().Report(SourceLocation(),
1723 diag::warn_module_config_mismatch)
1724 << ModuleFileName;
1725 // Fall through to error out.
1726 case ASTReader::VersionMismatch:
Douglas Gregorc9ad5fb2012-10-22 22:50:17 +00001727 case ASTReader::HadErrors:
Argyrios Kyrtzidisdc9fdaf2013-05-24 05:44:08 +00001728 ModuleLoader::HadFatalFailure = true;
Richard Smith0f99d6a2015-08-09 08:48:41 +00001729 // FIXME: The ASTReader will already have complained, but can we shoehorn
Douglas Gregor5196bc62011-11-30 04:03:44 +00001730 // that diagnostic information into a more useful form?
Craig Topper49a27902014-05-22 04:46:25 +00001731 KnownModules[Path[0].first] = nullptr;
Douglas Gregor7a626572012-11-29 23:55:25 +00001732 return ModuleLoadResult();
Douglas Gregor5196bc62011-11-30 04:03:44 +00001733
1734 case ASTReader::Failure:
Argyrios Kyrtzidisdc9fdaf2013-05-24 05:44:08 +00001735 ModuleLoader::HadFatalFailure = true;
Douglas Gregor69021972011-11-30 17:33:56 +00001736 // Already complained, but note now that we failed.
Craig Topper49a27902014-05-22 04:46:25 +00001737 KnownModules[Path[0].first] = nullptr;
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001738 ModuleBuildFailed = true;
Douglas Gregor7a626572012-11-29 23:55:25 +00001739 return ModuleLoadResult();
Douglas Gregor5196bc62011-11-30 04:03:44 +00001740 }
Argyrios Kyrtzidis43af5132012-09-29 01:06:04 +00001741
Douglas Gregor69021972011-11-30 17:33:56 +00001742 // Cache the result of this top-level module lookup for later.
1743 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
Douglas Gregor08142532011-08-26 23:56:07 +00001744 }
Douglas Gregor5196bc62011-11-30 04:03:44 +00001745
Douglas Gregor69021972011-11-30 17:33:56 +00001746 // If we never found the module, fail.
1747 if (!Module)
Douglas Gregor7a626572012-11-29 23:55:25 +00001748 return ModuleLoadResult();
Douglas Gregor69021972011-11-30 17:33:56 +00001749
Douglas Gregor5196bc62011-11-30 04:03:44 +00001750 // Verify that the rest of the module path actually corresponds to
1751 // a submodule.
Douglas Gregor69021972011-11-30 17:33:56 +00001752 if (Path.size() > 1) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001753 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1754 StringRef Name = Path[I].first->getName();
Douglas Gregoreb90e832012-01-04 23:32:19 +00001755 clang::Module *Sub = Module->findSubmodule(Name);
Douglas Gregor5196bc62011-11-30 04:03:44 +00001756
Douglas Gregoreb90e832012-01-04 23:32:19 +00001757 if (!Sub) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001758 // Attempt to perform typo correction to find a module name that works.
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001759 SmallVector<StringRef, 2> Best;
Douglas Gregor5196bc62011-11-30 04:03:44 +00001760 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1761
Douglas Gregoreb90e832012-01-04 23:32:19 +00001762 for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1763 JEnd = Module->submodule_end();
Matt Beaumont-Gayeb44eda2011-11-30 19:41:21 +00001764 J != JEnd; ++J) {
Douglas Gregoreb90e832012-01-04 23:32:19 +00001765 unsigned ED = Name.edit_distance((*J)->Name,
Douglas Gregor5196bc62011-11-30 04:03:44 +00001766 /*AllowReplacements=*/true,
1767 BestEditDistance);
1768 if (ED <= BestEditDistance) {
Douglas Gregoreb90e832012-01-04 23:32:19 +00001769 if (ED < BestEditDistance) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001770 Best.clear();
Douglas Gregoreb90e832012-01-04 23:32:19 +00001771 BestEditDistance = ED;
1772 }
1773
1774 Best.push_back((*J)->Name);
Douglas Gregor5196bc62011-11-30 04:03:44 +00001775 }
1776 }
1777
1778 // If there was a clear winner, user it.
1779 if (Best.size() == 1) {
1780 getDiagnostics().Report(Path[I].second,
1781 diag::err_no_submodule_suggest)
Douglas Gregor69021972011-11-30 17:33:56 +00001782 << Path[I].first << Module->getFullModuleName() << Best[0]
Douglas Gregor5196bc62011-11-30 04:03:44 +00001783 << SourceRange(Path[0].second, Path[I-1].second)
1784 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1785 Best[0]);
Douglas Gregoreb90e832012-01-04 23:32:19 +00001786
1787 Sub = Module->findSubmodule(Best[0]);
Douglas Gregor5196bc62011-11-30 04:03:44 +00001788 }
1789 }
1790
Douglas Gregoreb90e832012-01-04 23:32:19 +00001791 if (!Sub) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001792 // No submodule by this name. Complain, and don't look for further
1793 // submodules.
1794 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
Douglas Gregor69021972011-11-30 17:33:56 +00001795 << Path[I].first << Module->getFullModuleName()
Douglas Gregor5196bc62011-11-30 04:03:44 +00001796 << SourceRange(Path[0].second, Path[I-1].second);
1797 break;
1798 }
1799
Douglas Gregoreb90e832012-01-04 23:32:19 +00001800 Module = Sub;
Douglas Gregor5196bc62011-11-30 04:03:44 +00001801 }
Douglas Gregor08142532011-08-26 23:56:07 +00001802 }
Ben Langmuirb537a3a2014-07-23 15:30:23 +00001803
Douglas Gregor2537a362011-12-08 17:01:29 +00001804 // Make the named module visible, if it's not already part of the module
1805 // we are parsing.
Douglas Gregor98a52db2011-12-20 00:28:52 +00001806 if (ModuleName != getLangOpts().CurrentModule) {
1807 if (!Module->IsFromModuleFile) {
1808 // We have an umbrella header or directory that doesn't actually include
1809 // all of the headers within the directory it covers. Complain about
1810 // this missing submodule and recover by forgetting that we ever saw
1811 // this submodule.
1812 // FIXME: Should we detect this at module load time? It seems fairly
1813 // expensive (and rare).
1814 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1815 << Module->getFullModuleName()
1816 << SourceRange(Path.front().second, Path.back().second);
Craig Topper49a27902014-05-22 04:46:25 +00001817
Richard Smitha114c462016-12-06 00:40:17 +00001818 return ModuleLoadResult::MissingExpected;
Douglas Gregor98a52db2011-12-20 00:28:52 +00001819 }
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00001820
1821 // Check whether this module is available.
Richard Smitha3feee22013-10-28 22:18:19 +00001822 clang::Module::Requirement Requirement;
Richard Smith3c1a41a2014-12-02 00:08:08 +00001823 clang::Module::UnresolvedHeaderDirective MissingHeader;
Daniel Jasper0761a8a2013-12-17 10:31:37 +00001824 if (!Module->isAvailable(getLangOpts(), getTarget(), Requirement,
1825 MissingHeader)) {
1826 if (MissingHeader.FileNameLoc.isValid()) {
1827 getDiagnostics().Report(MissingHeader.FileNameLoc,
1828 diag::err_module_header_missing)
1829 << MissingHeader.IsUmbrella << MissingHeader.FileName;
1830 } else {
1831 getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
1832 << Module->getFullModuleName()
1833 << Requirement.second << Requirement.first
1834 << SourceRange(Path.front().second, Path.back().second);
1835 }
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00001836 LastModuleImportLoc = ImportLoc;
Douglas Gregor7a626572012-11-29 23:55:25 +00001837 LastModuleImportResult = ModuleLoadResult();
1838 return ModuleLoadResult();
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00001839 }
1840
Richard Smitha7e2cc62015-05-01 01:53:09 +00001841 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
Douglas Gregor98a52db2011-12-20 00:28:52 +00001842 }
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001843
1844 // Check for any configuration macros that have changed.
1845 clang::Module *TopModule = Module->getTopLevelModule();
1846 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1847 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1848 Module, ImportLoc);
1849 }
1850
Douglas Gregor1805b8a2011-11-30 04:26:53 +00001851 LastModuleImportLoc = ImportLoc;
Richard Smitha114c462016-12-06 00:40:17 +00001852 LastModuleImportResult = ModuleLoadResult(Module);
Douglas Gregor7a626572012-11-29 23:55:25 +00001853 return LastModuleImportResult;
Douglas Gregor08142532011-08-26 23:56:07 +00001854}
Douglas Gregorc147b0b2013-01-12 01:29:50 +00001855
1856void CompilerInstance::makeModuleVisible(Module *Mod,
Argyrios Kyrtzidis125df052013-02-01 16:36:12 +00001857 Module::NameVisibilityKind Visibility,
Richard Smitha7e2cc62015-05-01 01:53:09 +00001858 SourceLocation ImportLoc) {
Richard Smith42413142015-05-15 20:05:43 +00001859 if (!ModuleManager)
1860 createModuleManager();
1861 if (!ModuleManager)
1862 return;
1863
Richard Smitha7e2cc62015-05-01 01:53:09 +00001864 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
Douglas Gregorc147b0b2013-01-12 01:29:50 +00001865}
1866
John Thompson2255f2c2014-04-23 12:57:01 +00001867GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex(
1868 SourceLocation TriggerLoc) {
Richard Smith3938f0c2015-08-15 00:34:15 +00001869 if (getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
1870 return nullptr;
John Thompson2255f2c2014-04-23 12:57:01 +00001871 if (!ModuleManager)
1872 createModuleManager();
1873 // Can't do anything if we don't have the module manager.
1874 if (!ModuleManager)
Craig Topper49a27902014-05-22 04:46:25 +00001875 return nullptr;
John Thompson2255f2c2014-04-23 12:57:01 +00001876 // Get an existing global index. This loads it if not already
1877 // loaded.
1878 ModuleManager->loadGlobalIndex();
1879 GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
1880 // If the global index doesn't exist, create it.
1881 if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
1882 hasPreprocessor()) {
1883 llvm::sys::fs::create_directories(
1884 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
1885 GlobalModuleIndex::writeIndex(
Adrian Prantlfb2398d2015-07-17 01:19:54 +00001886 getFileManager(), getPCHContainerReader(),
Adrian Prantlbb165fb2015-06-20 18:53:08 +00001887 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
John Thompson2255f2c2014-04-23 12:57:01 +00001888 ModuleManager->resetForReload();
1889 ModuleManager->loadGlobalIndex();
1890 GlobalIndex = ModuleManager->getGlobalIndex();
1891 }
1892 // For finding modules needing to be imported for fixit messages,
1893 // we need to make the global index cover all modules, so we do that here.
1894 if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
1895 ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap();
1896 bool RecreateIndex = false;
1897 for (ModuleMap::module_iterator I = MMap.module_begin(),
1898 E = MMap.module_end(); I != E; ++I) {
1899 Module *TheModule = I->second;
1900 const FileEntry *Entry = TheModule->getASTFile();
1901 if (!Entry) {
1902 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
1903 Path.push_back(std::make_pair(
Richard Smith629d8e62015-08-11 00:03:28 +00001904 getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
John Thompson2255f2c2014-04-23 12:57:01 +00001905 std::reverse(Path.begin(), Path.end());
Richard Smith629d8e62015-08-11 00:03:28 +00001906 // Load a module as hidden. This also adds it to the global index.
1907 loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false);
John Thompson2255f2c2014-04-23 12:57:01 +00001908 RecreateIndex = true;
1909 }
1910 }
1911 if (RecreateIndex) {
1912 GlobalModuleIndex::writeIndex(
Adrian Prantlfb2398d2015-07-17 01:19:54 +00001913 getFileManager(), getPCHContainerReader(),
Adrian Prantlbb165fb2015-06-20 18:53:08 +00001914 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
John Thompson2255f2c2014-04-23 12:57:01 +00001915 ModuleManager->resetForReload();
1916 ModuleManager->loadGlobalIndex();
1917 GlobalIndex = ModuleManager->getGlobalIndex();
1918 }
1919 HaveFullGlobalModuleIndex = true;
1920 }
1921 return GlobalIndex;
1922}
John Thompson2d94bbb2014-04-23 19:04:32 +00001923
1924// Check global module index for missing imports.
1925bool
1926CompilerInstance::lookupMissingImports(StringRef Name,
1927 SourceLocation TriggerLoc) {
1928 // Look for the symbol in non-imported modules, but only if an error
1929 // actually occurred.
1930 if (!buildingModule()) {
1931 // Load global module index, or retrieve a previously loaded one.
1932 GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex(
1933 TriggerLoc);
1934
1935 // Only if we have a global index.
1936 if (GlobalIndex) {
1937 GlobalModuleIndex::HitSet FoundModules;
1938
1939 // Find the modules that reference the identifier.
1940 // Note that this only finds top-level modules.
1941 // We'll let diagnoseTypo find the actual declaration module.
1942 if (GlobalIndex->lookupIdentifier(Name, FoundModules))
1943 return true;
1944 }
1945 }
1946
1947 return false;
1948}
David Blaikiea97eaa12014-08-29 16:53:14 +00001949void CompilerInstance::resetAndLeakSema() { BuryPointer(takeSema()); }
Benjamin Kramer7de99692016-11-16 18:15:26 +00001950
1951void CompilerInstance::setExternalSemaSource(
1952 IntrusiveRefCntPtr<ExternalSemaSource> ESS) {
1953 ExternalSemaSrc = std::move(ESS);
1954}