blob: a556f4e0df11712141ef7bd725c1038c2273aeb9 [file] [log] [blame]
Daniel Dunbar636404a2009-11-13 03:51:44 +00001//===--- CompilerInstance.cpp ---------------------------------------------===//
2//
Chandler Carruth2946cd72019-01-19 08:50:56 +00003// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
Daniel Dunbar636404a2009-11-13 03:51:44 +00006//
7//===----------------------------------------------------------------------===//
8
9#include "clang/Frontend/CompilerInstance.h"
Daniel Dunbar56d9c292009-11-14 02:47:17 +000010#include "clang/AST/ASTConsumer.h"
Daniel Dunbardf3e30c2009-11-13 08:20:47 +000011#include "clang/AST/ASTContext.h"
Douglas Gregorbcfc7d02011-12-02 23:42:12 +000012#include "clang/AST/Decl.h"
Richard Smith9565c75b2017-06-19 23:09:36 +000013#include "clang/Basic/CharInfo.h"
Daniel Dunbar636404a2009-11-13 03:51:44 +000014#include "clang/Basic/Diagnostic.h"
Daniel Dunbar546a6762009-11-13 04:12:06 +000015#include "clang/Basic/FileManager.h"
16#include "clang/Basic/SourceManager.h"
Richard Smith0a7b2972018-07-03 21:34:13 +000017#include "clang/Basic/Stack.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"
Chandler Carruth3a022472012-12-04 09:13:33 +000031#include "clang/Lex/Preprocessor.h"
Mehdi Amini9670f842016-07-18 19:02:11 +000032#include "clang/Lex/PreprocessorOptions.h"
Daniel Dunbarf7093b52009-11-13 09:36:05 +000033#include "clang/Sema/CodeCompleteConsumer.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000034#include "clang/Sema/Sema.h"
35#include "clang/Serialization/ASTReader.h"
John Thompson2255f2c2014-04-23 12:57:01 +000036#include "clang/Serialization/GlobalModuleIndex.h"
Duncan P. N. Exon Smith8bef5cd2019-03-09 17:33:56 +000037#include "clang/Serialization/InMemoryModuleCache.h"
Douglas Gregor171b7802010-03-30 17:33:59 +000038#include "llvm/ADT/Statistic.h"
David Blaikie9941da42018-11-17 18:04:13 +000039#include "llvm/Support/BuryPointer.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000040#include "llvm/Support/CrashRecoveryContext.h"
Rafael Espindola71de0b62014-06-13 17:20:50 +000041#include "llvm/Support/Errc.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000042#include "llvm/Support/FileSystem.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000043#include "llvm/Support/Host.h"
Douglas Gregore2124892012-01-29 20:15:24 +000044#include "llvm/Support/LockFileManager.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000045#include "llvm/Support/MemoryBuffer.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000046#include "llvm/Support/Path.h"
47#include "llvm/Support/Program.h"
48#include "llvm/Support/Signals.h"
Anton Afanasyevd880de22019-03-30 08:42:48 +000049#include "llvm/Support/TimeProfiler.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000050#include "llvm/Support/Timer.h"
51#include "llvm/Support/raw_ostream.h"
Douglas Gregor527b1c92013-03-25 21:19:16 +000052#include <sys/stat.h>
Rafael Espindola8a8e5542014-06-12 17:19:42 +000053#include <system_error>
Douglas Gregor37da3272013-03-25 21:51:16 +000054#include <time.h>
Benjamin Kramercfeacf52016-05-27 14:27:13 +000055#include <utility>
Douglas Gregor54a88812011-10-05 14:53:30 +000056
Daniel Dunbar636404a2009-11-13 03:51:44 +000057using namespace clang;
58
Adrian Prantlbb165fb2015-06-20 18:53:08 +000059CompilerInstance::CompilerInstance(
60 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
Duncan P. N. Exon Smith8bef5cd2019-03-09 17:33:56 +000061 InMemoryModuleCache *SharedModuleCache)
62 : ModuleLoader(/* BuildingModule = */ SharedModuleCache),
Duncan P. N. Exon Smith030d7d62017-03-20 17:58:26 +000063 Invocation(new CompilerInvocation()),
Duncan P. N. Exon Smith8bef5cd2019-03-09 17:33:56 +000064 ModuleCache(SharedModuleCache ? SharedModuleCache
65 : new InMemoryModuleCache),
Duncan P. N. Exon Smith0a2be462019-03-09 17:44:01 +000066 ThePCHContainerOperations(std::move(PCHContainerOps)) {}
Daniel Dunbar636404a2009-11-13 03:51:44 +000067
68CompilerInstance::~CompilerInstance() {
Benjamin Kramer3c717b42012-10-14 19:21:21 +000069 assert(OutputFiles.empty() && "Still output files in flight?");
Daniel Dunbare922d9b2010-02-16 01:54:47 +000070}
71
David Blaikieea4395e2017-01-06 19:49:01 +000072void CompilerInstance::setInvocation(
73 std::shared_ptr<CompilerInvocation> Value) {
74 Invocation = std::move(Value);
Daniel Dunbar68242252010-01-30 21:47:07 +000075}
76
Douglas Gregorc1bbec82013-01-25 00:45:27 +000077bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
Douglas Gregore060e572013-01-25 01:03:03 +000078 return (BuildGlobalModuleIndex ||
Douglas Gregor11ef0b72013-03-22 21:26:48 +000079 (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
80 getFrontendOpts().GenerateGlobalModuleIndex)) &&
Douglas Gregore060e572013-01-25 01:03:03 +000081 !ModuleBuildFailed;
Douglas Gregorc1bbec82013-01-25 00:45:27 +000082}
83
David Blaikie9c902b52011-09-25 23:23:43 +000084void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
Douglas Gregor7f95d262010-04-05 23:52:57 +000085 Diagnostics = Value;
Daniel Dunbare01dc862009-11-14 01:20:40 +000086}
87
Artem Belevichb5bc9232015-09-22 17:23:22 +000088void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; }
89void CompilerInstance::setAuxTarget(TargetInfo *Value) { AuxTarget = Value; }
Daniel Dunbare01dc862009-11-14 01:20:40 +000090
91void CompilerInstance::setFileManager(FileManager *Value) {
Ted Kremenek5e14d392011-03-21 18:40:17 +000092 FileMgr = Value;
Daniel Dunbare01dc862009-11-14 01:20:40 +000093}
94
NAKAMURA Takumi82a35112011-10-08 11:31:46 +000095void CompilerInstance::setSourceManager(SourceManager *Value) {
Ted Kremenek5e14d392011-03-21 18:40:17 +000096 SourceMgr = Value;
Daniel Dunbare01dc862009-11-14 01:20:40 +000097}
98
David Blaikie41565462017-01-05 19:48:07 +000099void CompilerInstance::setPreprocessor(std::shared_ptr<Preprocessor> Value) {
100 PP = std::move(Value);
101}
Daniel Dunbare01dc862009-11-14 01:20:40 +0000102
Richard Smith293534b2015-08-18 20:39:29 +0000103void CompilerInstance::setASTContext(ASTContext *Value) {
104 Context = Value;
105
106 if (Context && Consumer)
107 getASTConsumer().Initialize(getASTContext());
108}
Daniel Dunbare01dc862009-11-14 01:20:40 +0000109
Douglas Gregor0e93f012010-08-12 23:31:19 +0000110void CompilerInstance::setSema(Sema *S) {
111 TheSema.reset(S);
112}
113
David Blaikie6beb6aa2014-08-10 19:56:51 +0000114void CompilerInstance::setASTConsumer(std::unique_ptr<ASTConsumer> Value) {
115 Consumer = std::move(Value);
Richard Smith293534b2015-08-18 20:39:29 +0000116
117 if (Context && Consumer)
118 getASTConsumer().Initialize(getASTContext());
Daniel Dunbar56d9c292009-11-14 02:47:17 +0000119}
120
Daniel Dunbare01dc862009-11-14 01:20:40 +0000121void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
122 CompletionConsumer.reset(Value);
123}
David Blaikie61535812014-08-10 20:12:39 +0000124
125std::unique_ptr<Sema> CompilerInstance::takeSema() {
126 return std::move(TheSema);
127}
128
Argyrios Kyrtzidis1b7ed912014-02-27 04:11:59 +0000129IntrusiveRefCntPtr<ASTReader> CompilerInstance::getModuleManager() const {
130 return ModuleManager;
131}
132void CompilerInstance::setModuleManager(IntrusiveRefCntPtr<ASTReader> Reader) {
Duncan P. N. Exon Smith8bef5cd2019-03-09 17:33:56 +0000133 assert(ModuleCache.get() == &Reader->getModuleManager().getModuleCache() &&
Duncan P. N. Exon Smith030d7d62017-03-20 17:58:26 +0000134 "Expected ASTReader to use the same PCM cache");
Benjamin Kramerd6da1a02016-06-12 20:05:23 +0000135 ModuleManager = std::move(Reader);
Argyrios Kyrtzidis1b7ed912014-02-27 04:11:59 +0000136}
Daniel Dunbare01dc862009-11-14 01:20:40 +0000137
Justin Bogner86d12592014-06-19 19:36:03 +0000138std::shared_ptr<ModuleDependencyCollector>
139CompilerInstance::getModuleDepCollector() const {
140 return ModuleDepCollector;
141}
142
143void CompilerInstance::setModuleDepCollector(
144 std::shared_ptr<ModuleDependencyCollector> Collector) {
Benjamin Kramerd6da1a02016-06-12 20:05:23 +0000145 ModuleDepCollector = std::move(Collector);
Justin Bogner86d12592014-06-19 19:36:03 +0000146}
147
Bruno Cardoso Lopes181225b2016-12-11 04:27:28 +0000148static void collectHeaderMaps(const HeaderSearch &HS,
149 std::shared_ptr<ModuleDependencyCollector> MDC) {
150 SmallVector<std::string, 4> HeaderMapFileNames;
151 HS.getHeaderMapFileNames(HeaderMapFileNames);
152 for (auto &Name : HeaderMapFileNames)
153 MDC->addFile(Name);
154}
155
Bruno Cardoso Lopes7aff2bb2016-12-12 19:28:25 +0000156static void collectIncludePCH(CompilerInstance &CI,
157 std::shared_ptr<ModuleDependencyCollector> MDC) {
158 const PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
159 if (PPOpts.ImplicitPCHInclude.empty())
160 return;
161
162 StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
163 FileManager &FileMgr = CI.getFileManager();
Harlan Haskins8d323d12019-08-01 21:31:56 +0000164 auto PCHDir = FileMgr.getDirectory(PCHInclude);
Bruno Cardoso Lopes7aff2bb2016-12-12 19:28:25 +0000165 if (!PCHDir) {
166 MDC->addFile(PCHInclude);
167 return;
168 }
169
170 std::error_code EC;
171 SmallString<128> DirNative;
Harlan Haskins8d323d12019-08-01 21:31:56 +0000172 llvm::sys::path::native((*PCHDir)->getName(), DirNative);
Duncan P. N. Exon Smithdb8a7422019-03-26 22:32:06 +0000173 llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
Bruno Cardoso Lopes7aff2bb2016-12-12 19:28:25 +0000174 SimpleASTReaderListener Validator(CI.getPreprocessor());
Jonas Devliegherefc514902018-10-10 13:27:25 +0000175 for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), DirEnd;
Bruno Cardoso Lopes7aff2bb2016-12-12 19:28:25 +0000176 Dir != DirEnd && !EC; Dir.increment(EC)) {
177 // Check whether this is an AST file. ASTReader::isAcceptableASTFile is not
178 // used here since we're not interested in validating the PCH at this time,
179 // but only to check whether this is a file containing an AST.
180 if (!ASTReader::readASTFileControlBlock(
Sam McCall0ae00562018-09-14 12:47:38 +0000181 Dir->path(), FileMgr, CI.getPCHContainerReader(),
Bruno Cardoso Lopes7aff2bb2016-12-12 19:28:25 +0000182 /*FindModuleFileExtensions=*/false, Validator,
183 /*ValidateDiagnosticOptions=*/false))
Sam McCall0ae00562018-09-14 12:47:38 +0000184 MDC->addFile(Dir->path());
Bruno Cardoso Lopes7aff2bb2016-12-12 19:28:25 +0000185 }
186}
187
Bruno Cardoso Lopes82ec4fde2016-12-22 07:06:03 +0000188static void collectVFSEntries(CompilerInstance &CI,
189 std::shared_ptr<ModuleDependencyCollector> MDC) {
190 if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
191 return;
192
193 // Collect all VFS found.
Jonas Devliegherefc514902018-10-10 13:27:25 +0000194 SmallVector<llvm::vfs::YAMLVFSEntry, 16> VFSEntries;
Bruno Cardoso Lopes82ec4fde2016-12-22 07:06:03 +0000195 for (const std::string &VFSFile : CI.getHeaderSearchOpts().VFSOverlayFiles) {
196 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
197 llvm::MemoryBuffer::getFile(VFSFile);
198 if (!Buffer)
199 return;
Jonas Devliegherefc514902018-10-10 13:27:25 +0000200 llvm::vfs::collectVFSFromYAML(std::move(Buffer.get()),
201 /*DiagHandler*/ nullptr, VFSFile, VFSEntries);
Bruno Cardoso Lopes82ec4fde2016-12-22 07:06:03 +0000202 }
203
204 for (auto &E : VFSEntries)
205 MDC->addFile(E.VPath, E.RPath);
206}
207
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000208// Diagnostics
Douglas Gregor811db4e2012-10-23 22:26:28 +0000209static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
Daniel Dunbar7b833062011-04-07 18:59:02 +0000210 const CodeGenOptions *CodeGenOpts,
David Blaikie9c902b52011-09-25 23:23:43 +0000211 DiagnosticsEngine &Diags) {
Rafael Espindoladae941a2014-08-25 18:17:04 +0000212 std::error_code EC;
David Blaikie11f8a942014-09-15 17:30:56 +0000213 std::unique_ptr<raw_ostream> StreamOwner;
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000214 raw_ostream *OS = &llvm::errs();
Douglas Gregor811db4e2012-10-23 22:26:28 +0000215 if (DiagOpts->DiagnosticLogFile != "-") {
Daniel Dunbar2083c322011-04-07 18:31:10 +0000216 // Create the output stream.
David Blaikie11f8a942014-09-15 17:30:56 +0000217 auto FileOS = llvm::make_unique<llvm::raw_fd_ostream>(
Rafael Espindoladae941a2014-08-25 18:17:04 +0000218 DiagOpts->DiagnosticLogFile, EC,
Fangrui Songd9b948b2019-08-05 05:43:48 +0000219 llvm::sys::fs::OF_Append | llvm::sys::fs::OF_Text);
Rafael Espindoladae941a2014-08-25 18:17:04 +0000220 if (EC) {
Daniel Dunbar2083c322011-04-07 18:31:10 +0000221 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
Rafael Espindoladae941a2014-08-25 18:17:04 +0000222 << DiagOpts->DiagnosticLogFile << EC.message();
Daniel Dunbar2083c322011-04-07 18:31:10 +0000223 } else {
224 FileOS->SetUnbuffered();
David Blaikie11f8a942014-09-15 17:30:56 +0000225 OS = FileOS.get();
226 StreamOwner = std::move(FileOS);
Daniel Dunbar2083c322011-04-07 18:31:10 +0000227 }
228 }
229
230 // Chain in the diagnostic client which will log the diagnostics.
David Blaikie7ee25502014-09-15 17:50:10 +0000231 auto Logger = llvm::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,
232 std::move(StreamOwner));
Daniel Dunbar7b833062011-04-07 18:59:02 +0000233 if (CodeGenOpts)
234 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
Alex Lorenz88377d82019-06-10 23:32:42 +0000235 if (Diags.ownsClient()) {
236 Diags.setClient(
237 new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger)));
238 } else {
239 Diags.setClient(
240 new ChainedDiagnosticConsumer(Diags.getClient(), std::move(Logger)));
241 }
Daniel Dunbar2083c322011-04-07 18:31:10 +0000242}
243
Douglas Gregor811db4e2012-10-23 22:26:28 +0000244static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
Ted Kremenek4610ea22011-10-29 00:12:39 +0000245 DiagnosticsEngine &Diags,
246 StringRef OutputFile) {
David Blaikie7ee25502014-09-15 17:50:10 +0000247 auto SerializedConsumer =
Justin Bogner5a6a2fc2014-10-23 22:20:11 +0000248 clang::serialized_diags::create(OutputFile, DiagOpts);
Ahmed Charles9a16beb2014-03-07 19:33:25 +0000249
Alexander Kornienko254b7db2014-11-13 13:08:27 +0000250 if (Diags.ownsClient()) {
251 Diags.setClient(new ChainedDiagnosticConsumer(
Alexander Kornienko41c247a2014-11-17 23:46:02 +0000252 Diags.takeClient(), std::move(SerializedConsumer)));
Alexander Kornienko254b7db2014-11-13 13:08:27 +0000253 } else {
254 Diags.setClient(new ChainedDiagnosticConsumer(
Alexander Kornienko4c0ef3792014-11-17 14:46:28 +0000255 Diags.getClient(), std::move(SerializedConsumer)));
Alexander Kornienko254b7db2014-11-13 13:08:27 +0000256 }
Ted Kremenek4610ea22011-10-29 00:12:39 +0000257}
258
Sean Silvaf1b49e22013-01-20 01:58:28 +0000259void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
Douglas Gregor30071cea2013-05-03 23:07:45 +0000260 bool ShouldOwnClient) {
Sean Silvaf1b49e22013-01-20 01:58:28 +0000261 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
Douglas Gregor30071cea2013-05-03 23:07:45 +0000262 ShouldOwnClient, &getCodeGenOpts());
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000263}
264
Dylan Noblesmithc95d8192012-02-20 14:00:23 +0000265IntrusiveRefCntPtr<DiagnosticsEngine>
Douglas Gregor811db4e2012-10-23 22:26:28 +0000266CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
David Blaikiee2eefae2011-09-25 23:39:51 +0000267 DiagnosticConsumer *Client,
Douglas Gregor2b9b4642011-09-13 01:26:44 +0000268 bool ShouldOwnClient,
Daniel Dunbar7b833062011-04-07 18:59:02 +0000269 const CodeGenOptions *CodeGenOpts) {
Dylan Noblesmithc95d8192012-02-20 14:00:23 +0000270 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
271 IntrusiveRefCntPtr<DiagnosticsEngine>
Douglas Gregor811db4e2012-10-23 22:26:28 +0000272 Diags(new DiagnosticsEngine(DiagID, Opts));
Daniel Dunbar1b39a2e2009-11-14 07:53:24 +0000273
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000274 // Create the diagnostic client for reporting errors or for
275 // implementing -verify.
Douglas Gregord0e9e3a2011-09-29 00:38:00 +0000276 if (Client) {
Douglas Gregor30071cea2013-05-03 23:07:45 +0000277 Diags->setClient(Client, ShouldOwnClient);
Douglas Gregord0e9e3a2011-09-29 00:38:00 +0000278 } else
Douglas Gregor44c6ee72010-11-11 00:39:14 +0000279 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
Daniel Dunbar50ec0da2009-11-14 03:24:39 +0000280
281 // Chain in -verify checker, if requested.
Douglas Gregor811db4e2012-10-23 22:26:28 +0000282 if (Opts->VerifyDiagnostics)
David Blaikie69609dc2011-09-26 00:38:03 +0000283 Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000284
Daniel Dunbar2083c322011-04-07 18:31:10 +0000285 // Chain in -diagnostic-log-file dumper, if requested.
Douglas Gregor811db4e2012-10-23 22:26:28 +0000286 if (!Opts->DiagnosticLogFile.empty())
Daniel Dunbar7b833062011-04-07 18:59:02 +0000287 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000288
Douglas Gregor811db4e2012-10-23 22:26:28 +0000289 if (!Opts->DiagnosticSerializationFile.empty())
Ted Kremenek4610ea22011-10-29 00:12:39 +0000290 SetupSerializedDiagnostics(Opts, *Diags,
Douglas Gregor811db4e2012-10-23 22:26:28 +0000291 Opts->DiagnosticSerializationFile);
Fangrui Song6907ce22018-07-30 19:24:48 +0000292
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000293 // Configure our handling of diagnostics.
Douglas Gregor811db4e2012-10-23 22:26:28 +0000294 ProcessWarningOptions(*Diags, *Opts);
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000295
Douglas Gregor7f95d262010-04-05 23:52:57 +0000296 return Diags;
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000297}
298
299// File Manager
300
Duncan P. N. Exon Smith1da7eac2019-03-26 22:18:52 +0000301FileManager *CompilerInstance::createFileManager(
302 IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) {
303 if (!VFS)
Duncan P. N. Exon Smithdb8a7422019-03-26 22:32:06 +0000304 VFS = FileMgr ? &FileMgr->getVirtualFileSystem()
Duncan P. N. Exon Smith1da7eac2019-03-26 22:18:52 +0000305 : createVFSFromCompilerInvocation(getInvocation(),
306 getDiagnostics());
307 assert(VFS && "FileManager has no VFS?");
308 FileMgr = new FileManager(getFileSystemOpts(), std::move(VFS));
Raphael Isemannabc3d042017-09-12 16:54:53 +0000309 return FileMgr.get();
Daniel Dunbar546a6762009-11-13 04:12:06 +0000310}
311
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000312// Source Manager
313
Chris Lattner5159f612010-11-23 08:35:12 +0000314void CompilerInstance::createSourceManager(FileManager &FileMgr) {
Ted Kremenek5e14d392011-03-21 18:40:17 +0000315 SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
Daniel Dunbar546a6762009-11-13 04:12:06 +0000316}
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000317
Alp Tokerc3580002014-07-07 06:05:00 +0000318// Initialize the remapping of files to alternative contents, e.g.,
319// those specified through other files.
320static void InitializeFileRemapping(DiagnosticsEngine &Diags,
321 SourceManager &SourceMgr,
322 FileManager &FileMgr,
323 const PreprocessorOptions &InitOpts) {
324 // Remap files in the source manager (with buffers).
Alp Toker1b070d22014-07-07 07:47:20 +0000325 for (const auto &RB : InitOpts.RemappedFileBuffers) {
Alp Tokerc3580002014-07-07 06:05:00 +0000326 // Create the file entry for the file that we're mapping from.
327 const FileEntry *FromFile =
Alp Toker1b070d22014-07-07 07:47:20 +0000328 FileMgr.getVirtualFile(RB.first, RB.second->getBufferSize(), 0);
Alp Tokerc3580002014-07-07 06:05:00 +0000329 if (!FromFile) {
Alp Toker1b070d22014-07-07 07:47:20 +0000330 Diags.Report(diag::err_fe_remap_missing_from_file) << RB.first;
Alp Tokerc3580002014-07-07 06:05:00 +0000331 if (!InitOpts.RetainRemappedFileBuffers)
Alp Toker1b070d22014-07-07 07:47:20 +0000332 delete RB.second;
Alp Tokerc3580002014-07-07 06:05:00 +0000333 continue;
334 }
335
336 // Override the contents of the "from" file with the contents of
337 // the "to" file.
Alp Toker1b070d22014-07-07 07:47:20 +0000338 SourceMgr.overrideFileContents(FromFile, RB.second,
Alp Tokerc3580002014-07-07 06:05:00 +0000339 InitOpts.RetainRemappedFileBuffers);
340 }
341
342 // Remap files in the source manager (with other files).
Alp Toker1b070d22014-07-07 07:47:20 +0000343 for (const auto &RF : InitOpts.RemappedFiles) {
Alp Tokerc3580002014-07-07 06:05:00 +0000344 // Find the file that we're mapping to.
Harlan Haskins8d323d12019-08-01 21:31:56 +0000345 auto ToFile = FileMgr.getFile(RF.second);
Alp Tokerc3580002014-07-07 06:05:00 +0000346 if (!ToFile) {
Alp Toker1b070d22014-07-07 07:47:20 +0000347 Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;
Alp Tokerc3580002014-07-07 06:05:00 +0000348 continue;
349 }
350
351 // Create the file entry for the file that we're mapping from.
352 const FileEntry *FromFile =
Harlan Haskins8d323d12019-08-01 21:31:56 +0000353 FileMgr.getVirtualFile(RF.first, (*ToFile)->getSize(), 0);
Alp Tokerc3580002014-07-07 06:05:00 +0000354 if (!FromFile) {
Alp Toker1b070d22014-07-07 07:47:20 +0000355 Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first;
Alp Tokerc3580002014-07-07 06:05:00 +0000356 continue;
357 }
358
359 // Override the contents of the "from" file with the contents of
360 // the "to" file.
Harlan Haskins8d323d12019-08-01 21:31:56 +0000361 SourceMgr.overrideFileContents(FromFile, *ToFile);
Alp Tokerc3580002014-07-07 06:05:00 +0000362 }
363
364 SourceMgr.setOverridenFilesKeepOriginalName(
365 InitOpts.RemappedFilesKeepOriginalName);
366}
367
Daniel Dunbar7d75afc2009-11-13 05:52:34 +0000368// Preprocessor
369
Argyrios Kyrtzidise1974dc2014-03-07 07:47:58 +0000370void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
Douglas Gregor08142532011-08-26 23:56:07 +0000371 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000372
Benjamin Kramer5904c412018-11-05 12:46:02 +0000373 // The module manager holds a reference to the old preprocessor (if any).
374 ModuleManager.reset();
375
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());
Duncan P. N. Exon Smith8bef5cd2019-03-09 17:33:56 +0000380 PP = std::make_shared<Preprocessor>(Invocation->getPreprocessorOptsPtr(),
381 getDiagnostics(), getLangOpts(),
382 getSourceManager(), *HeaderInfo, *this,
383 /*IdentifierInfoLookup=*/nullptr,
384 /*OwnsHeaderSearch=*/true, TUKind);
Saleem Abdulrasool729379a2017-10-06 23:09:55 +0000385 getTarget().adjust(getLangOpts());
Artem Belevichb5bc9232015-09-22 17:23:22 +0000386 PP->Initialize(getTarget(), getAuxTarget());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000387
Douglas Gregor7f6d60d2010-03-19 16:15:56 +0000388 if (PPOpts.DetailedRecord)
Argyrios Kyrtzidisf3d587e2012-12-04 07:27:05 +0000389 PP->createPreprocessingRecord();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000390
Alp Tokerc3580002014-07-07 06:05:00 +0000391 // Apply remappings to the source manager.
392 InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
393 PP->getFileManager(), PPOpts);
394
395 // Predefine macros and configure the preprocessor.
Adrian Prantlfb2398d2015-07-17 01:19:54 +0000396 InitializePreprocessor(*PP, PPOpts, getPCHContainerReader(),
Adrian Prantlbb165fb2015-06-20 18:53:08 +0000397 getFrontendOpts());
Alp Tokerc3580002014-07-07 06:05:00 +0000398
Justin Lebarf91086b2016-11-18 00:41:27 +0000399 // Initialize the header search object. In CUDA compilations, we use the aux
400 // triple (the host triple) to initialize our header search, since we need to
401 // find the host headers in order to compile the CUDA code.
402 const llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple();
403 if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA &&
404 PP->getAuxTargetInfo())
405 HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple();
406
Alp Tokerc3580002014-07-07 06:05:00 +0000407 ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(),
Justin Lebarf91086b2016-11-18 00:41:27 +0000408 PP->getLangOpts(), *HeaderSearchTriple);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000409
Jordan Rose17441582013-01-30 01:52:57 +0000410 PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
411
Richard Smith3938f0c2015-08-15 00:34:15 +0000412 if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules)
Chandler Carruthff8d9432015-03-28 01:10:44 +0000413 PP->getHeaderSearchInfo().setModuleCachePath(getSpecificModuleCachePath());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000414
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000415 // Handle generating dependencies, if requested.
Douglas Gregor08142532011-08-26 23:56:07 +0000416 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000417 if (!DepOpts.OutputFile.empty())
Alex Lorenz8d9eb7a2019-06-19 17:07:36 +0000418 addDependencyCollector(std::make_shared<DependencyFileGenerator>(DepOpts));
Douglas Gregor2e129652012-02-02 23:45:13 +0000419 if (!DepOpts.DOTOutputFile.empty())
420 AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile,
Douglas Gregor83d46be2012-02-02 00:54:52 +0000421 getHeaderSearchOpts().Sysroot);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000422
Justin Bogner86d12592014-06-19 19:36:03 +0000423 // If we don't have a collector, but we are collecting module dependencies,
424 // then we're the top level compiler instance and need to create one.
Bruno Cardoso Lopesb1631d92016-03-29 23:47:40 +0000425 if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty()) {
Justin Bogner86d12592014-06-19 19:36:03 +0000426 ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(
427 DepOpts.ModuleDependencyOutputDir);
Bruno Cardoso Lopesb1631d92016-03-29 23:47:40 +0000428 }
429
Bruno Cardoso Lopes181225b2016-12-11 04:27:28 +0000430 // If there is a module dep collector, register with other dep collectors
431 // and also (a) collect header maps and (b) TODO: input vfs overlay files.
432 if (ModuleDepCollector) {
Bruno Cardoso Lopesb1631d92016-03-29 23:47:40 +0000433 addDependencyCollector(ModuleDepCollector);
Bruno Cardoso Lopes181225b2016-12-11 04:27:28 +0000434 collectHeaderMaps(PP->getHeaderSearchInfo(), ModuleDepCollector);
Bruno Cardoso Lopes7aff2bb2016-12-12 19:28:25 +0000435 collectIncludePCH(*this, ModuleDepCollector);
Bruno Cardoso Lopes82ec4fde2016-12-22 07:06:03 +0000436 collectVFSEntries(*this, ModuleDepCollector);
Bruno Cardoso Lopes181225b2016-12-11 04:27:28 +0000437 }
Bruno Cardoso Lopesb1631d92016-03-29 23:47:40 +0000438
439 for (auto &Listener : DependencyCollectors)
440 Listener->attachToPreprocessor(*PP);
Hans Wennborg0fd62072013-08-09 00:32:23 +0000441
Daniel Dunbar27734fd2011-02-02 15:41:17 +0000442 // Handle generating header include information, if requested.
443 if (DepOpts.ShowHeaderIncludes)
Nico Weberf54146c2016-03-23 18:46:57 +0000444 AttachHeaderIncludeGen(*PP, DepOpts);
Daniel Dunbar1af1d27512011-02-02 21:11:31 +0000445 if (!DepOpts.HeaderIncludeOutputFile.empty()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000446 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
Daniel Dunbar1af1d27512011-02-02 21:11:31 +0000447 if (OutputPath == "-")
448 OutputPath = "";
Nico Weberf54146c2016-03-23 18:46:57 +0000449 AttachHeaderIncludeGen(*PP, DepOpts,
Ivan Krasin1193f2c2015-08-13 04:04:37 +0000450 /*ShowAllHeaders=*/true, OutputPath,
Daniel Dunbarfe908a82011-03-21 19:37:38 +0000451 /*ShowDepth=*/false);
Daniel Dunbar1af1d27512011-02-02 21:11:31 +0000452 }
Hans Wennborg0fd62072013-08-09 00:32:23 +0000453
Erich Keane425f48d2018-05-04 15:58:31 +0000454 if (DepOpts.ShowIncludesDest != ShowIncludesDestination::None) {
Nico Weberf54146c2016-03-23 18:46:57 +0000455 AttachHeaderIncludeGen(*PP, DepOpts,
Nico Weber149d95222016-03-23 18:00:22 +0000456 /*ShowAllHeaders=*/true, /*OutputPath=*/"",
Hans Wennborg0fd62072013-08-09 00:32:23 +0000457 /*ShowDepth=*/true, /*MSStyle=*/true);
458 }
Daniel Dunbaraaa148f2009-11-13 05:52:11 +0000459}
Daniel Dunbardf3e30c2009-11-13 08:20:47 +0000460
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +0000461std::string CompilerInstance::getSpecificModuleCachePath() {
462 // Set up the module path, including the hash for the
463 // module-creation options.
Richard Smithd520a252015-07-21 18:07:47 +0000464 SmallString<256> SpecificModuleCache(getHeaderSearchOpts().ModuleCachePath);
465 if (!SpecificModuleCache.empty() && !getHeaderSearchOpts().DisableModuleHash)
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +0000466 llvm::sys::path::append(SpecificModuleCache,
467 getInvocation().getModuleHash());
468 return SpecificModuleCache.str();
469}
470
Daniel Dunbardf3e30c2009-11-13 08:20:47 +0000471// ASTContext
472
473void CompilerInstance::createASTContext() {
474 Preprocessor &PP = getPreprocessor();
Richard Smith293534b2015-08-18 20:39:29 +0000475 auto *Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
476 PP.getIdentifierTable(), PP.getSelectorTable(),
477 PP.getBuiltinInfo());
Artem Belevichb5bc9232015-09-22 17:23:22 +0000478 Context->InitBuiltinTypes(getTarget(), getAuxTarget());
Richard Smith293534b2015-08-18 20:39:29 +0000479 setASTContext(Context);
Daniel Dunbardf3e30c2009-11-13 08:20:47 +0000480}
Daniel Dunbar599313e2009-11-13 08:21:10 +0000481
482// ExternalASTSource
483
Nico Weber824285e2014-05-08 04:26:47 +0000484void CompilerInstance::createPCHExternalASTSource(
485 StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors,
486 void *DeserializationListener, bool OwnDeserializationListener) {
Sebastian Redl009e7f22010-10-05 16:15:19 +0000487 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
Richard Smith4eca9b92015-02-04 23:37:59 +0000488 ModuleManager = createPCHExternalASTSource(
Nico Weber824285e2014-05-08 04:26:47 +0000489 Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation,
Duncan P. N. Exon Smith8bef5cd2019-03-09 17:33:56 +0000490 AllowPCHWithCompilerErrors, getPreprocessor(), getModuleCache(),
491 getASTContext(), getPCHContainerReader(),
Alex Lorenz8d9eb7a2019-06-19 17:07:36 +0000492 getFrontendOpts().ModuleFileExtensions, DependencyCollectors,
493 DeserializationListener, OwnDeserializationListener, Preamble,
494 getFrontendOpts().UseGlobalModuleIndex);
Daniel Dunbar599313e2009-11-13 08:21:10 +0000495}
496
Richard Smith4eca9b92015-02-04 23:37:59 +0000497IntrusiveRefCntPtr<ASTReader> CompilerInstance::createPCHExternalASTSource(
Yaron Keren5b816062015-07-06 08:47:15 +0000498 StringRef Path, StringRef Sysroot, bool DisablePCHValidation,
Duncan P. N. Exon Smith8bef5cd2019-03-09 17:33:56 +0000499 bool AllowPCHWithCompilerErrors, Preprocessor &PP,
500 InMemoryModuleCache &ModuleCache, ASTContext &Context,
Adrian Prantlfb2398d2015-07-17 01:19:54 +0000501 const PCHContainerReader &PCHContainerRdr,
David Blaikie61137e12017-01-05 18:23:18 +0000502 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
Graydon Hoarece539b52017-03-29 17:33:09 +0000503 ArrayRef<std::shared_ptr<DependencyCollector>> DependencyCollectors,
Nico Weber824285e2014-05-08 04:26:47 +0000504 void *DeserializationListener, bool OwnDeserializationListener,
505 bool Preamble, bool UseGlobalModuleIndex) {
Ben Langmuirdcf73862014-03-12 00:06:17 +0000506 HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
507
Adrian Prantlbb165fb2015-06-20 18:53:08 +0000508 IntrusiveRefCntPtr<ASTReader> Reader(new ASTReader(
Duncan P. N. Exon Smith8bef5cd2019-03-09 17:33:56 +0000509 PP, ModuleCache, &Context, PCHContainerRdr, Extensions,
Douglas Gregor6623e1f2015-11-03 18:33:07 +0000510 Sysroot.empty() ? "" : Sysroot.data(), DisablePCHValidation,
511 AllowPCHWithCompilerErrors, /*AllowConfigurationMismatch*/ false,
512 HSOpts.ModulesValidateSystemHeaders, UseGlobalModuleIndex));
Richard Smith4eca9b92015-02-04 23:37:59 +0000513
514 // We need the external source to be set up before we read the AST, because
515 // eagerly-deserialized declarations may use it.
516 Context.setExternalSource(Reader.get());
Daniel Dunbar599313e2009-11-13 08:21:10 +0000517
Sebastian Redl07a89a82010-07-30 00:29:29 +0000518 Reader->setDeserializationListener(
Nico Weber824285e2014-05-08 04:26:47 +0000519 static_cast<ASTDeserializationListener *>(DeserializationListener),
520 /*TakeOwnership=*/OwnDeserializationListener);
Graydon Hoarece539b52017-03-29 17:33:09 +0000521
Graydon Hoarece539b52017-03-29 17:33:09 +0000522 for (auto &Listener : DependencyCollectors)
523 Listener->attachToASTReader(*Reader);
524
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000525 switch (Reader->ReadAST(Path,
526 Preamble ? serialization::MK_Preamble
Douglas Gregor4b29c162012-10-22 23:51:00 +0000527 : serialization::MK_PCH,
Argyrios Kyrtzidis2ec29362012-11-15 18:57:22 +0000528 SourceLocation(),
Ben Langmuir3d4417c2014-02-07 17:31:11 +0000529 ASTReader::ARR_None)) {
Sebastian Redl2c499f62010-08-18 23:56:43 +0000530 case ASTReader::Success:
Daniel Dunbar599313e2009-11-13 08:21:10 +0000531 // Set the predefines buffer as suggested by the PCH reader. Typically, the
532 // predefines buffer will be empty.
533 PP.setPredefines(Reader->getSuggestedPredefines());
Richard Smith4eca9b92015-02-04 23:37:59 +0000534 return Reader;
Daniel Dunbar599313e2009-11-13 08:21:10 +0000535
Sebastian Redl2c499f62010-08-18 23:56:43 +0000536 case ASTReader::Failure:
Daniel Dunbar599313e2009-11-13 08:21:10 +0000537 // Unrecoverable failure: don't even try to process the input file.
538 break;
539
Douglas Gregor7029ce12013-03-19 00:28:20 +0000540 case ASTReader::Missing:
Douglas Gregorc9ad5fb2012-10-22 22:50:17 +0000541 case ASTReader::OutOfDate:
542 case ASTReader::VersionMismatch:
543 case ASTReader::ConfigurationMismatch:
544 case ASTReader::HadErrors:
Daniel Dunbar599313e2009-11-13 08:21:10 +0000545 // No suitable PCH file could be found. Return an error.
546 break;
547 }
548
Richard Smith4eca9b92015-02-04 23:37:59 +0000549 Context.setExternalSource(nullptr);
Craig Topper49a27902014-05-22 04:46:25 +0000550 return nullptr;
Daniel Dunbar599313e2009-11-13 08:21:10 +0000551}
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000552
553// Code Completion
554
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000555static bool EnableCodeCompletion(Preprocessor &PP,
Benjamin Kramer0772c422016-02-13 13:42:54 +0000556 StringRef Filename,
Douglas Gregor8e984da2010-08-04 16:47:14 +0000557 unsigned Line,
558 unsigned Column) {
559 // Tell the source manager to chop off the given file at a specific
560 // line and column.
Harlan Haskins8d323d12019-08-01 21:31:56 +0000561 auto Entry = PP.getFileManager().getFile(Filename);
Douglas Gregor8e984da2010-08-04 16:47:14 +0000562 if (!Entry) {
563 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
564 << Filename;
565 return true;
566 }
567
568 // Truncate the named file at the given line/column.
Harlan Haskins8d323d12019-08-01 21:31:56 +0000569 PP.SetCodeCompletionPoint(*Entry, Line, Column);
Douglas Gregor8e984da2010-08-04 16:47:14 +0000570 return false;
571}
572
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000573void CompilerInstance::createCodeCompletionConsumer() {
574 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
Douglas Gregor8e984da2010-08-04 16:47:14 +0000575 if (!CompletionConsumer) {
Erik Verbruggen2fca3c22012-04-12 10:31:12 +0000576 setCodeCompletionConsumer(
Douglas Gregor8e984da2010-08-04 16:47:14 +0000577 createCodeCompletionConsumer(getPreprocessor(),
578 Loc.FileName, Loc.Line, Loc.Column,
Dmitri Gribenko3292d062012-07-02 17:35:10 +0000579 getFrontendOpts().CodeCompleteOpts,
Douglas Gregor8e984da2010-08-04 16:47:14 +0000580 llvm::outs()));
581 if (!CompletionConsumer)
582 return;
583 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
584 Loc.Line, Loc.Column)) {
Craig Topper49a27902014-05-22 04:46:25 +0000585 setCodeCompletionConsumer(nullptr);
Douglas Gregor00a0cf72010-03-16 06:04:47 +0000586 return;
Douglas Gregor8e984da2010-08-04 16:47:14 +0000587 }
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000588}
589
Kovarththanan Rajaratnam5505dff2009-11-29 09:57:35 +0000590void CompilerInstance::createFrontendTimer() {
Matthias Braunae032b62016-11-18 19:43:25 +0000591 FrontendTimerGroup.reset(
592 new llvm::TimerGroup("frontend", "Clang front-end time report"));
Richard Smithce18a182015-07-14 00:26:00 +0000593 FrontendTimer.reset(
Matthias Braunae032b62016-11-18 19:43:25 +0000594 new llvm::Timer("frontend", "Clang front-end timer",
595 *FrontendTimerGroup));
Kovarththanan Rajaratnam5505dff2009-11-29 09:57:35 +0000596}
597
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000598CodeCompleteConsumer *
599CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
Yaron Keren5b816062015-07-06 08:47:15 +0000600 StringRef Filename,
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000601 unsigned Line,
602 unsigned Column,
Dmitri Gribenko3292d062012-07-02 17:35:10 +0000603 const CodeCompleteOptions &Opts,
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000604 raw_ostream &OS) {
Douglas Gregor8e984da2010-08-04 16:47:14 +0000605 if (EnableCodeCompletion(PP, Filename, Line, Column))
Craig Topper49a27902014-05-22 04:46:25 +0000606 return nullptr;
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000607
608 // Set up the creation routine for code-completion.
Dmitri Gribenko3292d062012-07-02 17:35:10 +0000609 return new PrintingCodeCompleteConsumer(Opts, OS);
Daniel Dunbarf7093b52009-11-13 09:36:05 +0000610}
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000611
Douglas Gregor69f74f82011-08-25 22:30:56 +0000612void CompilerInstance::createSema(TranslationUnitKind TUKind,
Douglas Gregor0e93f012010-08-12 23:31:19 +0000613 CodeCompleteConsumer *CompletionConsumer) {
614 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
Douglas Gregor69f74f82011-08-25 22:30:56 +0000615 TUKind, CompletionConsumer));
Benjamin Kramer7de99692016-11-16 18:15:26 +0000616 // Attach the external sema source if there is any.
617 if (ExternalSemaSrc) {
618 TheSema->addExternalSource(ExternalSemaSrc.get());
619 ExternalSemaSrc->InitializeSema(*TheSema);
620 }
Douglas Gregor0e93f012010-08-12 23:31:19 +0000621}
622
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000623// Output Files
624
Rafael Espindola269ec0f2015-04-10 14:11:52 +0000625void CompilerInstance::addOutputFile(OutputFile &&OutFile) {
Rafael Espindola269ec0f2015-04-10 14:11:52 +0000626 OutputFiles.push_back(std::move(OutFile));
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000627}
628
Kovarththanan Rajaratnam1c558cd2010-03-06 12:07:48 +0000629void CompilerInstance::clearOutputFiles(bool EraseFiles) {
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000630 for (OutputFile &OF : OutputFiles) {
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000631 if (!OF.TempFilename.empty()) {
Anders Carlssonb5c356a2011-03-06 22:25:35 +0000632 if (EraseFiles) {
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000633 llvm::sys::fs::remove(OF.TempFilename);
Anders Carlssonb5c356a2011-03-06 22:25:35 +0000634 } else {
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000635 SmallString<128> NewOutFile(OF.Filename);
Anders Carlssonb5c356a2011-03-06 22:25:35 +0000636
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +0000637 // If '-working-directory' was passed, the output filename should be
638 // relative to that.
Anders Carlsson9ba8fb12011-03-14 01:13:54 +0000639 FileMgr->FixupRelativePath(NewOutFile);
Rafael Espindolac0809172014-06-12 14:02:15 +0000640 if (std::error_code ec =
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000641 llvm::sys::fs::rename(OF.TempFilename, NewOutFile)) {
Manuel Klimek3ef9c442012-05-16 20:55:58 +0000642 getDiagnostics().Report(diag::err_unable_to_rename_temp)
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000643 << OF.TempFilename << OF.Filename << ec.message();
Anders Carlssonb5c356a2011-03-06 22:25:35 +0000644
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000645 llvm::sys::fs::remove(OF.TempFilename);
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000646 }
647 }
Reid Kleckner0aa128e2015-04-10 17:27:58 +0000648 } else if (!OF.Filename.empty() && EraseFiles)
649 llvm::sys::fs::remove(OF.Filename);
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000650 }
651 OutputFiles.clear();
Richard Smith86a3ef52017-06-09 21:24:02 +0000652 if (DeleteBuiltModules) {
653 for (auto &Module : BuiltModules)
654 llvm::sys::fs::remove(Module.second);
655 BuiltModules.clear();
656 }
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000657 NonSeekStream.reset();
Daniel Dunbar566eeb22009-11-13 10:37:48 +0000658}
659
Peter Collingbourne03f89072016-07-15 00:55:40 +0000660std::unique_ptr<raw_pwrite_stream>
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000661CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile,
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000662 StringRef Extension) {
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000663 return createOutputFile(getFrontendOpts().OutputFile, Binary,
Daniel Dunbarae77b3d2012-03-03 00:36:06 +0000664 /*RemoveFileOnSignal=*/true, InFile, Extension,
665 /*UseTemporary=*/true);
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000666}
667
Peter Collingbourne03f89072016-07-15 00:55:40 +0000668std::unique_ptr<raw_pwrite_stream> CompilerInstance::createNullOutputFile() {
669 return llvm::make_unique<llvm::raw_null_ostream>();
Alp Tokerea046722014-06-03 17:23:34 +0000670}
671
Peter Collingbourne03f89072016-07-15 00:55:40 +0000672std::unique_ptr<raw_pwrite_stream>
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000673CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary,
674 bool RemoveFileOnSignal, StringRef InFile,
675 StringRef Extension, bool UseTemporary,
Daniel Dunbarb9c62c02012-03-03 00:36:02 +0000676 bool CreateMissingDirectories) {
Rafael Espindoladae941a2014-08-25 18:17:04 +0000677 std::string OutputPathName, TempPathName;
678 std::error_code EC;
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000679 std::unique_ptr<raw_pwrite_stream> OS = createOutputFile(
Rafael Espindoladae941a2014-08-25 18:17:04 +0000680 OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension,
Rafael Espindolac80a4062015-04-10 14:30:43 +0000681 UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName);
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000682 if (!OS) {
Rafael Espindoladae941a2014-08-25 18:17:04 +0000683 getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath
684 << EC.message();
Craig Topper49a27902014-05-22 04:46:25 +0000685 return nullptr;
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000686 }
687
688 // Add the output file -- but don't try to remove "-", since this means we are
689 // using stdin.
Peter Collingbourne03f89072016-07-15 00:55:40 +0000690 addOutputFile(
691 OutputFile((OutputPathName != "-") ? OutputPathName : "", TempPathName));
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000692
Peter Collingbourne03f89072016-07-15 00:55:40 +0000693 return OS;
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000694}
695
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000696std::unique_ptr<llvm::raw_pwrite_stream> CompilerInstance::createOutputFile(
Rafael Espindoladae941a2014-08-25 18:17:04 +0000697 StringRef OutputPath, std::error_code &Error, bool Binary,
698 bool RemoveFileOnSignal, StringRef InFile, StringRef Extension,
699 bool UseTemporary, bool CreateMissingDirectories,
700 std::string *ResultPathName, std::string *TempPathName) {
Daniel Dunbarb9c62c02012-03-03 00:36:02 +0000701 assert((!CreateMissingDirectories || UseTemporary) &&
702 "CreateMissingDirectories is only allowed when using temporary files");
703
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000704 std::string OutFile, TempFile;
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000705 if (!OutputPath.empty()) {
706 OutFile = OutputPath;
707 } else if (InFile == "-") {
708 OutFile = "-";
709 } else if (!Extension.empty()) {
Rafael Espindola399ab332013-06-26 04:32:59 +0000710 SmallString<128> Path(InFile);
711 llvm::sys::path::replace_extension(Path, Extension);
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000712 OutFile = Path.str();
713 } else {
714 OutFile = "-";
715 }
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000716
Ahmed Charlesb8984322014-03-07 20:03:18 +0000717 std::unique_ptr<llvm::raw_fd_ostream> OS;
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000718 std::string OSFile;
719
Rafael Espindola73c23a72013-06-27 18:26:26 +0000720 if (UseTemporary) {
721 if (OutFile == "-")
722 UseTemporary = false;
723 else {
724 llvm::sys::fs::file_status Status;
725 llvm::sys::fs::status(OutputPath, Status);
726 if (llvm::sys::fs::exists(Status)) {
727 // Fail early if we can't write to the final destination.
Douglas Katzman8bfac2c2015-09-17 16:45:12 +0000728 if (!llvm::sys::fs::can_write(OutputPath)) {
Rafael Espindolaee4e08b2015-10-05 11:49:35 +0000729 Error = make_error_code(llvm::errc::operation_not_permitted);
Craig Topper49a27902014-05-22 04:46:25 +0000730 return nullptr;
Douglas Katzman8bfac2c2015-09-17 16:45:12 +0000731 }
Rafael Espindola73c23a72013-06-27 18:26:26 +0000732
733 // Don't use a temporary if the output is a special file. This handles
734 // things like '-o /dev/null'
735 if (!llvm::sys::fs::is_regular_file(Status))
736 UseTemporary = false;
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000737 }
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000738 }
739 }
740
Rafael Espindola73c23a72013-06-27 18:26:26 +0000741 if (UseTemporary) {
Rafael Espindola73c23a72013-06-27 18:26:26 +0000742 // Create a temporary file.
Nico Weber2db47192017-08-08 16:21:23 +0000743 // Insert -%%%%%%%% before the extension (if any), and because some tools
744 // (noticeable, clang's own GlobalModuleIndex.cpp) glob for build
745 // artifacts, also append .tmp.
746 StringRef OutputExtension = llvm::sys::path::extension(OutFile);
747 SmallString<128> TempPath =
748 StringRef(OutFile).drop_back(OutputExtension.size());
Rafael Espindola73c23a72013-06-27 18:26:26 +0000749 TempPath += "-%%%%%%%%";
Nico Weber2db47192017-08-08 16:21:23 +0000750 TempPath += OutputExtension;
751 TempPath += ".tmp";
Rafael Espindola73c23a72013-06-27 18:26:26 +0000752 int fd;
Rafael Espindolac0809172014-06-12 14:02:15 +0000753 std::error_code EC =
Yaron Keren92e1b622015-03-18 10:17:07 +0000754 llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
Rafael Espindola157f34b2013-06-28 03:49:04 +0000755
756 if (CreateMissingDirectories &&
Rafael Espindola71de0b62014-06-13 17:20:50 +0000757 EC == llvm::errc::no_such_file_or_directory) {
Rafael Espindola157f34b2013-06-28 03:49:04 +0000758 StringRef Parent = llvm::sys::path::parent_path(OutputPath);
759 EC = llvm::sys::fs::create_directories(Parent);
760 if (!EC) {
Yaron Keren92e1b622015-03-18 10:17:07 +0000761 EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
Rafael Espindola157f34b2013-06-28 03:49:04 +0000762 }
763 }
764
765 if (!EC) {
NAKAMURA Takumi69f35282014-08-11 06:53:11 +0000766 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
Rafael Espindola73c23a72013-06-27 18:26:26 +0000767 OSFile = TempFile = TempPath.str();
768 }
769 // If we failed to create the temporary, fallback to writing to the file
770 // directly. This handles the corner case where we cannot write to the
771 // directory, but can write to the file.
772 }
773
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000774 if (!OS) {
775 OSFile = OutFile;
NAKAMURA Takumi69f35282014-08-11 06:53:11 +0000776 OS.reset(new llvm::raw_fd_ostream(
Rafael Espindoladae941a2014-08-25 18:17:04 +0000777 OSFile, Error,
Fangrui Songd9b948b2019-08-05 05:43:48 +0000778 (Binary ? llvm::sys::fs::OF_None : llvm::sys::fs::OF_Text)));
Rafael Espindoladae941a2014-08-25 18:17:04 +0000779 if (Error)
Craig Topper49a27902014-05-22 04:46:25 +0000780 return nullptr;
Argyrios Kyrtzidis08a2bfd2011-07-28 00:45:10 +0000781 }
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000782
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000783 // Make sure the out stream file gets removed if we crash.
Daniel Dunbare326f9b2011-01-31 22:00:42 +0000784 if (RemoveFileOnSignal)
Rafael Espindola18556de2013-06-13 21:02:40 +0000785 llvm::sys::RemoveFileOnSignal(OSFile);
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000786
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000787 if (ResultPathName)
788 *ResultPathName = OutFile;
Argyrios Kyrtzidisd0599972010-09-17 17:38:48 +0000789 if (TempPathName)
790 *TempPathName = TempFile;
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000791
Rafael Espindola2f16bc12015-04-14 15:15:49 +0000792 if (!Binary || OS->supportsSeeking())
793 return std::move(OS);
794
795 auto B = llvm::make_unique<llvm::buffer_ostream>(*OS);
796 assert(!NonSeekStream);
797 NonSeekStream = std::move(OS);
798 return std::move(B);
Daniel Dunbar420b0f12009-11-13 18:32:08 +0000799}
Daniel Dunbar409e8902009-11-14 07:53:04 +0000800
801// Initialization Utilities
802
Argyrios Kyrtzidis1b3240b2012-11-09 19:40:33 +0000803bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
Nico Weber2ca4be92016-03-01 23:16:44 +0000804 return InitializeSourceManager(
805 Input, getDiagnostics(), getFileManager(), getSourceManager(),
806 hasPreprocessor() ? &getPreprocessor().getHeaderSearchInfo() : nullptr,
Nico Weber4b5aede2016-03-13 02:44:13 +0000807 getDependencyOutputOpts(), getFrontendOpts());
Daniel Dunbar409e8902009-11-14 07:53:04 +0000808}
809
Nico Weber2ca4be92016-03-01 23:16:44 +0000810// static
Nico Weber4b5aede2016-03-13 02:44:13 +0000811bool CompilerInstance::InitializeSourceManager(
812 const FrontendInputFile &Input, DiagnosticsEngine &Diags,
813 FileManager &FileMgr, SourceManager &SourceMgr, HeaderSearch *HS,
814 DependencyOutputOptions &DepOpts, const FrontendOptions &Opts) {
Richard Smithf3f84612017-06-29 02:19:42 +0000815 SrcMgr::CharacteristicKind Kind =
816 Input.getKind().getFormat() == InputKind::ModuleMap
817 ? Input.isSystem() ? SrcMgr::C_System_ModuleMap
818 : SrcMgr::C_User_ModuleMap
819 : Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
Argyrios Kyrtzidis1b3240b2012-11-09 19:40:33 +0000820
Argyrios Kyrtzidis6566e232012-11-09 19:40:45 +0000821 if (Input.isBuffer()) {
Richard Smith6d9bc272017-09-09 01:14:04 +0000822 SourceMgr.setMainFileID(SourceMgr.createFileID(SourceManager::Unowned,
823 Input.getBuffer(), Kind));
Yaron Keren8b563662015-10-03 10:46:20 +0000824 assert(SourceMgr.getMainFileID().isValid() &&
Argyrios Kyrtzidis6566e232012-11-09 19:40:45 +0000825 "Couldn't establish MainFileID!");
826 return true;
827 }
828
829 StringRef InputFile = Input.getFile();
830
Argyrios Kyrtzidis7c06d862011-09-19 20:40:35 +0000831 // Figure out where to get and map in the main file.
832 if (InputFile != "-") {
Harlan Haskins8d323d12019-08-01 21:31:56 +0000833 auto FileOrErr = FileMgr.getFile(InputFile, /*OpenFile=*/true);
834 if (!FileOrErr) {
Daniel Dunbar409e8902009-11-14 07:53:04 +0000835 Diags.Report(diag::err_fe_error_reading) << InputFile;
836 return false;
837 }
Harlan Haskins8d323d12019-08-01 21:31:56 +0000838 auto File = *FileOrErr;
Daniel Dunbare2951f42012-11-05 22:53:33 +0000839
840 // The natural SourceManager infrastructure can't currently handle named
841 // pipes, but we would at least like to accept them for the main
Benjamin Kramer3841fa32013-08-12 13:46:52 +0000842 // file. Detect them here, read them with the volatile flag so FileMgr will
843 // pick up the correct size, and simply override their contents as we do for
844 // STDIN.
Daniel Dunbare2951f42012-11-05 22:53:33 +0000845 if (File->isNamedPipe()) {
Benjamin Kramera8857962014-10-26 22:44:13 +0000846 auto MB = FileMgr.getBufferForFile(File, /*isVolatile=*/true);
847 if (MB) {
Benjamin Kramer3841fa32013-08-12 13:46:52 +0000848 // Create a new virtual file that will have the correct size.
Benjamin Kramera8857962014-10-26 22:44:13 +0000849 File = FileMgr.getVirtualFile(InputFile, (*MB)->getBufferSize(), 0);
850 SourceMgr.overrideFileContents(File, std::move(*MB));
Benjamin Kramer3841fa32013-08-12 13:46:52 +0000851 } else {
Benjamin Kramera8857962014-10-26 22:44:13 +0000852 Diags.Report(diag::err_cannot_open_file) << InputFile
853 << MB.getError().message();
Daniel Dunbare2951f42012-11-05 22:53:33 +0000854 return false;
855 }
Daniel Dunbare2951f42012-11-05 22:53:33 +0000856 }
Daniel Dunbardb0745a2012-11-27 00:04:16 +0000857
Alp Tokerb671e342014-05-21 01:12:41 +0000858 SourceMgr.setMainFileID(
859 SourceMgr.createFileID(File, SourceLocation(), Kind));
Daniel Dunbar409e8902009-11-14 07:53:04 +0000860 } else {
Rafael Espindola2d2b4202014-07-06 17:43:24 +0000861 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> SBOrErr =
862 llvm::MemoryBuffer::getSTDIN();
863 if (std::error_code EC = SBOrErr.getError()) {
864 Diags.Report(diag::err_fe_error_reading_stdin) << EC.message();
Daniel Dunbar409e8902009-11-14 07:53:04 +0000865 return false;
866 }
Rafael Espindola2d2b4202014-07-06 17:43:24 +0000867 std::unique_ptr<llvm::MemoryBuffer> SB = std::move(SBOrErr.get());
868
Dan Gohman2f76cd72010-10-26 23:21:25 +0000869 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
Chris Lattner5159f612010-11-23 08:35:12 +0000870 SB->getBufferSize(), 0);
Alp Tokerb671e342014-05-21 01:12:41 +0000871 SourceMgr.setMainFileID(
872 SourceMgr.createFileID(File, SourceLocation(), Kind));
David Blaikie49cc3182014-08-27 20:54:45 +0000873 SourceMgr.overrideFileContents(File, std::move(SB));
Daniel Dunbar409e8902009-11-14 07:53:04 +0000874 }
875
Yaron Keren8b563662015-10-03 10:46:20 +0000876 assert(SourceMgr.getMainFileID().isValid() &&
Dan Gohman52765212010-10-26 21:13:51 +0000877 "Couldn't establish MainFileID!");
Daniel Dunbar409e8902009-11-14 07:53:04 +0000878 return true;
879}
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000880
881// High-Level Operations
882
883bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
884 assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
885 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
886 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
887
888 // FIXME: Take this as an argument, once all the APIs we used have moved to
889 // taking it as an input instead of hard-coding llvm::errs.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000890 raw_ostream &OS = llvm::errs();
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000891
Richard Smithd6509cf2018-09-15 01:21:15 +0000892 if (!Act.PrepareToExecute(*this))
893 return false;
894
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000895 // Create the target instance.
Alp Toker80758082014-07-06 05:26:44 +0000896 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(),
Saleem Abdulrasool10a49722016-04-08 16:52:00 +0000897 getInvocation().TargetOpts));
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000898 if (!hasTarget())
899 return false;
900
Gheorghe-Teodor Bercea59d7b772017-06-29 15:49:03 +0000901 // Create TargetInfo for the other side of CUDA and OpenMP compilation.
902 if ((getLangOpts().CUDA || getLangOpts().OpenMPIsDevice) &&
903 !getFrontendOpts().AuxTriple.empty()) {
Justin Lebar76945b22016-04-29 23:05:19 +0000904 auto TO = std::make_shared<TargetOptions>();
Petr Hosek7b274542018-08-08 22:23:57 +0000905 TO->Triple = llvm::Triple::normalize(getFrontendOpts().AuxTriple);
Justin Lebar76945b22016-04-29 23:05:19 +0000906 TO->HostTriple = getTarget().getTriple().str();
Saleem Abdulrasool10a49722016-04-08 16:52:00 +0000907 setAuxTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), TO));
Artem Belevichb5bc9232015-09-22 17:23:22 +0000908 }
909
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000910 // Inform the target of the language options.
911 //
912 // FIXME: We shouldn't need to do this, the target should be immutable once
913 // created. This complexity should be lifted elsewhere.
Alp Toker74437972014-07-06 05:14:24 +0000914 getTarget().adjust(getLangOpts());
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000915
Yaxun Liu2c17e822016-08-09 19:43:38 +0000916 // Adjust target options based on codegen options.
917 getTarget().adjustTargetOptions(getCodeGenOpts(), getTargetOpts());
918
Yaxun Liu95f2ca52019-01-30 12:26:54 +0000919 if (auto *Aux = getAuxTarget())
920 getTarget().setAuxTarget(Aux);
921
Fangrui Song6907ce22018-07-30 19:24:48 +0000922 // rewriter project will change target built-in bool type from its default.
Fariborz Jahanian29898f42012-04-16 21:03:30 +0000923 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
924 getTarget().noSignedCharForObjCBool();
925
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000926 // Validate/process some options.
927 if (getHeaderSearchOpts().Verbose)
928 OS << "clang -cc1 version " CLANG_VERSION_STRING
Alp Tokerf988d002014-06-06 10:36:22 +0000929 << " based upon " << BACKEND_PACKAGE_STRING
Sebastian Pop8188c8a2011-11-01 21:33:06 +0000930 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000931
932 if (getFrontendOpts().ShowTimers)
933 createFrontendTimer();
934
Matthias Braunabb6eea2016-09-26 18:53:34 +0000935 if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty())
Matthias Braunec1c5a22016-09-27 19:38:59 +0000936 llvm::EnableStatistics(false);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000937
Vedant Kumar5b60ad62015-11-16 00:59:34 +0000938 for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) {
Ted Kremenekeeccb302014-08-27 15:14:15 +0000939 // Reset the ID tables if we are reusing the SourceManager and parsing
940 // regular files.
941 if (hasSourceManager() && !Act.isModelParsingAction())
Daniel Dunbaraed46fc2010-06-07 23:23:50 +0000942 getSourceManager().clearIDTables();
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000943
Vedant Kumar5b60ad62015-11-16 00:59:34 +0000944 if (Act.BeginSourceFile(*this, FIF)) {
JF Bastien0e828952019-06-26 19:50:12 +0000945 if (llvm::Error Err = Act.Execute()) {
946 consumeError(std::move(Err)); // FIXME this drops errors on the floor.
947 }
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000948 Act.EndSourceFile();
949 }
950 }
951
Argyrios Kyrtzidis7910d7b2011-12-07 05:52:12 +0000952 // Notify the diagnostic client that all files were processed.
953 getDiagnostics().getClient()->finish();
954
Chris Lattner198cb4d2010-04-07 18:47:42 +0000955 if (getDiagnosticOpts().ShowCarets) {
Argyrios Kyrtzidisc79346a2010-11-18 20:06:46 +0000956 // We can have multiple diagnostics sharing one diagnostic client.
957 // Get the total number of warnings/errors from the client.
958 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
959 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000960
Chris Lattner198cb4d2010-04-07 18:47:42 +0000961 if (NumWarnings)
962 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
963 if (NumWarnings && NumErrors)
964 OS << " and ";
965 if (NumErrors)
966 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
Justin Lebar78137ec2017-09-07 18:37:16 +0000967 if (NumWarnings || NumErrors) {
968 OS << " generated";
969 if (getLangOpts().CUDA) {
970 if (!getLangOpts().CUDAIsDevice) {
971 OS << " when compiling for host";
972 } else {
973 OS << " when compiling for " << getTargetOpts().CPU;
974 }
975 }
976 OS << ".\n";
977 }
Chris Lattner198cb4d2010-04-07 18:47:42 +0000978 }
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000979
Matthias Braunabb6eea2016-09-26 18:53:34 +0000980 if (getFrontendOpts().ShowStats) {
981 if (hasFileManager()) {
982 getFileManager().PrintStats();
983 OS << '\n';
984 }
985 llvm::PrintStatistics(OS);
986 }
987 StringRef StatsFile = getFrontendOpts().StatsFile;
988 if (!StatsFile.empty()) {
989 std::error_code EC;
Fangrui Songd9b948b2019-08-05 05:43:48 +0000990 auto StatS = llvm::make_unique<llvm::raw_fd_ostream>(
991 StatsFile, EC, llvm::sys::fs::OF_Text);
Matthias Braunabb6eea2016-09-26 18:53:34 +0000992 if (EC) {
993 getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file)
994 << StatsFile << EC.message();
995 } else {
996 llvm::PrintStatisticsJSON(*StatS);
997 }
Daniel Dunbar4f2bc552010-01-13 00:48:06 +0000998 }
999
Argyrios Kyrtzidisbc467932010-11-18 21:13:57 +00001000 return !getDiagnostics().getClient()->getNumErrors();
Daniel Dunbar4f2bc552010-01-13 00:48:06 +00001001}
1002
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001003/// Determine the appropriate source input kind based on language
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001004/// options.
Richard Smith40c0efa2017-04-26 18:57:40 +00001005static InputKind::Language getLanguageFromOptions(const LangOptions &LangOpts) {
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001006 if (LangOpts.OpenCL)
Richard Smith40c0efa2017-04-26 18:57:40 +00001007 return InputKind::OpenCL;
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001008 if (LangOpts.CUDA)
Richard Smith40c0efa2017-04-26 18:57:40 +00001009 return InputKind::CUDA;
Erik Pilkingtonfa983902018-10-30 20:31:30 +00001010 if (LangOpts.ObjC)
Richard Smith40c0efa2017-04-26 18:57:40 +00001011 return LangOpts.CPlusPlus ? InputKind::ObjCXX : InputKind::ObjC;
1012 return LangOpts.CPlusPlus ? InputKind::CXX : InputKind::C;
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001013}
1014
Fangrui Song6907ce22018-07-30 19:24:48 +00001015/// Compile a module file for the given module, using the options
Ben Langmuirb797d592014-07-19 16:29:28 +00001016/// provided by the importing compiler instance. Returns true if the module
1017/// was built without errors.
Richard Smith5d2ed482017-06-09 19:22:32 +00001018static bool
1019compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
1020 StringRef ModuleName, FrontendInputFile Input,
1021 StringRef OriginalModuleMapFile, StringRef ModuleFileName,
1022 llvm::function_ref<void(CompilerInstance &)> PreBuildStep =
1023 [](CompilerInstance &) {},
1024 llvm::function_ref<void(CompilerInstance &)> PostBuildStep =
1025 [](CompilerInstance &) {}) {
Anton Afanasyevd880de22019-03-30 08:42:48 +00001026 llvm::TimeTraceScope TimeScope("Module Compile", ModuleName);
1027
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001028 // Construct a compiler invocation for creating this module.
David Blaikieea4395e2017-01-06 19:49:01 +00001029 auto Invocation =
1030 std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001031
Douglas Gregorf545f672011-11-29 21:59:16 +00001032 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
Fangrui Song6907ce22018-07-30 19:24:48 +00001033
Douglas Gregor44bf68d2011-09-15 20:53:28 +00001034 // For any options that aren't intended to affect how a module is built,
1035 // reset them to their default values.
Ted Kremenek8cf47df2011-11-17 23:01:24 +00001036 Invocation->getLangOpts()->resetNonModularOptions();
Douglas Gregorf545f672011-11-29 21:59:16 +00001037 PPOpts.resetNonModularOptions();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001038
Douglas Gregor5dc38992013-02-07 00:21:12 +00001039 // Remove any macro definitions that are explicitly ignored by the module.
1040 // They aren't supposed to affect how the module is built anyway.
Duncan P. N. Exon Smith60fa2882017-03-13 18:45:08 +00001041 HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
Benjamin Kramerbbdd7642014-03-01 14:48:57 +00001042 PPOpts.Macros.erase(
1043 std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
1044 [&HSOpts](const std::pair<std::string, bool> &def) {
1045 StringRef MacroDef = def.first;
Justin Lebar5e83dfe2016-10-21 21:45:01 +00001046 return HSOpts.ModulesIgnoreMacros.count(
1047 llvm::CachedHashString(MacroDef.split('=').first)) > 0;
Benjamin Kramerbbdd7642014-03-01 14:48:57 +00001048 }),
1049 PPOpts.Macros.end());
Douglas Gregor5dc38992013-02-07 00:21:12 +00001050
Bruno Cardoso Lopes970b2812018-03-20 22:36:39 +00001051 // If the original compiler invocation had -fmodule-name, pass it through.
1052 Invocation->getLangOpts()->ModuleName =
1053 ImportingInstance.getInvocation().getLangOpts()->ModuleName;
1054
Douglas Gregor7d106e42011-11-15 19:35:01 +00001055 // Note the name of the module we're building.
Richard Smith5d2ed482017-06-09 19:22:32 +00001056 Invocation->getLangOpts()->CurrentModule = ModuleName;
Douglas Gregor7d106e42011-11-15 19:35:01 +00001057
Douglas Gregor7a626572012-11-29 23:55:25 +00001058 // Make sure that the failed-module structure has been allocated in
1059 // the importing instance, and propagate the pointer to the newly-created
1060 // instance.
1061 PreprocessorOptions &ImportingPPOpts
1062 = ImportingInstance.getInvocation().getPreprocessorOpts();
1063 if (!ImportingPPOpts.FailedModules)
David Blaikief95113d2017-01-05 19:11:31 +00001064 ImportingPPOpts.FailedModules =
1065 std::make_shared<PreprocessorOptions::FailedModulesSet>();
Douglas Gregor7a626572012-11-29 23:55:25 +00001066 PPOpts.FailedModules = ImportingPPOpts.FailedModules;
1067
Douglas Gregorf545f672011-11-29 21:59:16 +00001068 // If there is a module map file, build the module using the module map.
Douglas Gregor44bf68d2011-09-15 20:53:28 +00001069 // Set up the inputs/outputs so that we build the module from its umbrella
1070 // header.
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001071 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
Douglas Gregor1735f4e2011-09-13 23:15:45 +00001072 FrontendOpts.OutputFile = ModuleFileName.str();
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001073 FrontendOpts.DisableFree = false;
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001074 FrontendOpts.GenerateGlobalModuleIndex = false;
Richard Smithe75ee0f2015-08-17 07:13:32 +00001075 FrontendOpts.BuildingImplicitModule = true;
Richard Smith5d2ed482017-06-09 19:22:32 +00001076 FrontendOpts.OriginalModuleMap = OriginalModuleMapFile;
Duncan P. N. Exon Smith60fa2882017-03-13 18:45:08 +00001077 // Force implicitly-built modules to hash the content of the module file.
1078 HSOpts.ModulesHashContent = true;
Richard Smith5d2ed482017-06-09 19:22:32 +00001079 FrontendOpts.Inputs = {Input};
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001080
Douglas Gregorf545f672011-11-29 21:59:16 +00001081 // Don't free the remapped file buffers; they are owned by our caller.
1082 PPOpts.RetainRemappedFileBuffers = true;
Fangrui Song6907ce22018-07-30 19:24:48 +00001083
Douglas Gregor2b9b4642011-09-13 01:26:44 +00001084 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
Douglas Gregor3728ea72011-09-13 23:20:27 +00001085 assert(ImportingInstance.getInvocation().getModuleHash() ==
Douglas Gregorf545f672011-11-29 21:59:16 +00001086 Invocation->getModuleHash() && "Module hash mismatch!");
Fangrui Song6907ce22018-07-30 19:24:48 +00001087
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001088 // Construct a compiler instance that will be used to actually create the
Duncan P. N. Exon Smith8bef5cd2019-03-09 17:33:56 +00001089 // module. Since we're sharing an in-memory module cache,
Duncan P. N. Exon Smith030d7d62017-03-20 17:58:26 +00001090 // CompilerInstance::CompilerInstance is responsible for finalizing the
1091 // buffers to prevent use-after-frees.
Adrian Prantlbb165fb2015-06-20 18:53:08 +00001092 CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
Duncan P. N. Exon Smith8bef5cd2019-03-09 17:33:56 +00001093 &ImportingInstance.getModuleCache());
David Blaikieea4395e2017-01-06 19:49:01 +00001094 auto &Inv = *Invocation;
1095 Instance.setInvocation(std::move(Invocation));
Douglas Gregor6b930962013-05-03 22:58:43 +00001096
1097 Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
1098 ImportingInstance.getDiagnosticClient()),
Douglas Gregor30071cea2013-05-03 23:07:45 +00001099 /*ShouldOwnClient=*/true);
Douglas Gregoraf8f0262012-11-30 18:38:50 +00001100
Douglas Gregor63365432012-11-30 22:11:57 +00001101 // Note that this module is part of the module build stack, so that we
Douglas Gregoraf8f0262012-11-30 18:38:50 +00001102 // can detect cycles in the module graph.
Ben Langmuird066d4c2014-02-28 21:16:07 +00001103 Instance.setFileManager(&ImportingInstance.getFileManager());
Douglas Gregoraf8f0262012-11-30 18:38:50 +00001104 Instance.createSourceManager(Instance.getFileManager());
1105 SourceManager &SourceMgr = Instance.getSourceManager();
Douglas Gregor63365432012-11-30 22:11:57 +00001106 SourceMgr.setModuleBuildStack(
1107 ImportingInstance.getSourceManager().getModuleBuildStack());
Richard Smith5d2ed482017-06-09 19:22:32 +00001108 SourceMgr.pushModuleBuildStack(ModuleName,
Douglas Gregoraf8f0262012-11-30 18:38:50 +00001109 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
1110
Justin Bogner86d12592014-06-19 19:36:03 +00001111 // If we're collecting module dependencies, we need to share a collector
Richard Smith38c1e6d2015-08-09 06:03:55 +00001112 // between all of the module CompilerInstances. Other than that, we don't
1113 // want to produce any dependency output from the module build.
Justin Bogner86d12592014-06-19 19:36:03 +00001114 Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
David Blaikieea4395e2017-01-06 19:49:01 +00001115 Inv.getDependencyOutputOpts() = DependencyOutputOptions();
Justin Bogner86d12592014-06-19 19:36:03 +00001116
Richard Smith99891da2014-10-14 02:08:30 +00001117 ImportingInstance.getDiagnostics().Report(ImportLoc,
1118 diag::remark_module_build)
Richard Smith5d2ed482017-06-09 19:22:32 +00001119 << ModuleName << ModuleFileName;
1120
1121 PreBuildStep(Instance);
Richard Smith99891da2014-10-14 02:08:30 +00001122
Douglas Gregor51e0b542011-10-04 00:21:21 +00001123 // Execute the action to actually build the module in-place. Use a separate
1124 // thread so that we get a stack large enough.
Douglas Gregor51e0b542011-10-04 00:21:21 +00001125 llvm::CrashRecoveryContext CRC;
Richard Smithf74d9462017-04-28 01:49:42 +00001126 CRC.RunSafelyOnThread(
1127 [&]() {
1128 GenerateModuleFromModuleMapAction Action;
1129 Instance.ExecuteAction(Action);
1130 },
Richard Smith0a7b2972018-07-03 21:34:13 +00001131 DesiredStackSize);
Douglas Gregor6b930962013-05-03 22:58:43 +00001132
Richard Smith5d2ed482017-06-09 19:22:32 +00001133 PostBuildStep(Instance);
1134
Richard Smith99891da2014-10-14 02:08:30 +00001135 ImportingInstance.getDiagnostics().Report(ImportLoc,
1136 diag::remark_module_build_done)
Richard Smith5d2ed482017-06-09 19:22:32 +00001137 << ModuleName;
Richard Smith99891da2014-10-14 02:08:30 +00001138
Douglas Gregorf545f672011-11-29 21:59:16 +00001139 // Delete the temporary module map file.
1140 // FIXME: Even though we're executing under crash protection, it would still
1141 // be nice to do this with RemoveFileOnSignal when we can. However, that
1142 // doesn't make sense for all clients, so clean this up manually.
Benjamin Kramer13afbf42012-10-14 19:50:53 +00001143 Instance.clearOutputFiles(/*EraseFiles=*/true);
Douglas Gregor5e306b12013-01-23 22:38:11 +00001144
Richard Smith5d2ed482017-06-09 19:22:32 +00001145 return !Instance.getDiagnostics().hasErrorOccurred();
1146}
1147
Bruno Cardoso Lopes22d97062018-05-02 02:25:03 +00001148static const FileEntry *getPublicModuleMap(const FileEntry *File,
1149 FileManager &FileMgr) {
1150 StringRef Filename = llvm::sys::path::filename(File->getName());
1151 SmallString<128> PublicFilename(File->getDir()->getName());
1152 if (Filename == "module_private.map")
1153 llvm::sys::path::append(PublicFilename, "module.map");
1154 else if (Filename == "module.private.modulemap")
1155 llvm::sys::path::append(PublicFilename, "module.modulemap");
1156 else
1157 return nullptr;
Harlan Haskins8d323d12019-08-01 21:31:56 +00001158 if (auto FE = FileMgr.getFile(PublicFilename))
1159 return *FE;
1160 return nullptr;
Bruno Cardoso Lopes22d97062018-05-02 02:25:03 +00001161}
1162
Fangrui Song6907ce22018-07-30 19:24:48 +00001163/// Compile a module file for the given module, using the options
Richard Smith5d2ed482017-06-09 19:22:32 +00001164/// provided by the importing compiler instance. Returns true if the module
1165/// was built without errors.
1166static bool compileModuleImpl(CompilerInstance &ImportingInstance,
1167 SourceLocation ImportLoc,
1168 Module *Module,
1169 StringRef ModuleFileName) {
1170 InputKind IK(getLanguageFromOptions(ImportingInstance.getLangOpts()),
1171 InputKind::ModuleMap);
1172
1173 // Get or create the module map that we'll use to build this module.
Fangrui Song6907ce22018-07-30 19:24:48 +00001174 ModuleMap &ModMap
Richard Smith5d2ed482017-06-09 19:22:32 +00001175 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1176 bool Result;
1177 if (const FileEntry *ModuleMapFile =
1178 ModMap.getContainingModuleMapFile(Module)) {
Bruno Cardoso Lopes22d97062018-05-02 02:25:03 +00001179 // Canonicalize compilation to start with the public module map. This is
1180 // vital for submodules declarations in the private module maps to be
1181 // correctly parsed when depending on a top level module in the public one.
1182 if (const FileEntry *PublicMMFile = getPublicModuleMap(
1183 ModuleMapFile, ImportingInstance.getFileManager()))
1184 ModuleMapFile = PublicMMFile;
1185
Richard Smith5d2ed482017-06-09 19:22:32 +00001186 // Use the module map where this module resides.
1187 Result = compileModuleImpl(
1188 ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1189 FrontendInputFile(ModuleMapFile->getName(), IK, +Module->IsSystem),
1190 ModMap.getModuleMapFileForUniquing(Module)->getName(),
1191 ModuleFileName);
1192 } else {
1193 // FIXME: We only need to fake up an input file here as a way of
1194 // transporting the module's directory to the module map parser. We should
1195 // be able to do that more directly, and parse from a memory buffer without
1196 // inventing this file.
1197 SmallString<128> FakeModuleMapFile(Module->Directory->getName());
1198 llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map");
1199
1200 std::string InferredModuleMapContent;
1201 llvm::raw_string_ostream OS(InferredModuleMapContent);
1202 Module->print(OS);
1203 OS.flush();
1204
1205 Result = compileModuleImpl(
1206 ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1207 FrontendInputFile(FakeModuleMapFile, IK, +Module->IsSystem),
1208 ModMap.getModuleMapFileForUniquing(Module)->getName(),
1209 ModuleFileName,
1210 [&](CompilerInstance &Instance) {
1211 std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
1212 llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
1213 ModuleMapFile = Instance.getFileManager().getVirtualFile(
1214 FakeModuleMapFile, InferredModuleMapContent.size(), 0);
1215 Instance.getSourceManager().overrideFileContents(
1216 ModuleMapFile, std::move(ModuleMapBuffer));
1217 });
1218 }
1219
Douglas Gregor5e306b12013-01-23 22:38:11 +00001220 // We've rebuilt a module. If we're allowed to generate or update the global
1221 // module index, record that fact in the importing compiler instance.
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001222 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
Douglas Gregor5e306b12013-01-23 22:38:11 +00001223 ImportingInstance.setBuildGlobalModuleIndex(true);
1224 }
Ben Langmuirb797d592014-07-19 16:29:28 +00001225
Richard Smith5d2ed482017-06-09 19:22:32 +00001226 return Result;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001227}
Douglas Gregorfaeb1d42011-09-12 23:31:24 +00001228
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001229static bool compileAndLoadModule(CompilerInstance &ImportingInstance,
1230 SourceLocation ImportLoc,
Ben Langmuirb797d592014-07-19 16:29:28 +00001231 SourceLocation ModuleNameLoc, Module *Module,
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001232 StringRef ModuleFileName) {
Ben Langmuird213aab2014-09-26 22:42:23 +00001233 DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1234
Ben Langmuirb797d592014-07-19 16:29:28 +00001235 auto diagnoseBuildFailure = [&] {
Ben Langmuird213aab2014-09-26 22:42:23 +00001236 Diags.Report(ModuleNameLoc, diag::err_module_not_built)
Ben Langmuirb797d592014-07-19 16:29:28 +00001237 << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1238 };
1239
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001240 // FIXME: have LockFileManager return an error_code so that we can
1241 // avoid the mkdir when the directory already exists.
1242 StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
1243 llvm::sys::fs::create_directories(Dir);
1244
1245 while (1) {
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001246 unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001247 llvm::LockFileManager Locked(ModuleFileName);
1248 switch (Locked) {
1249 case llvm::LockFileManager::LFS_Error:
Duncan P. N. Exon Smith8bef5cd2019-03-09 17:33:56 +00001250 // ModuleCache takes care of correctness and locks are only necessary for
Bruno Cardoso Lopes5a0af1f2017-03-18 00:26:18 +00001251 // performance. Fallback to building the module in case of any lock
1252 // related errors.
1253 Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure)
Bruno Cardoso Lopes4a522222016-06-04 01:13:22 +00001254 << Module->Name << Locked.getErrorMessage();
Bruno Cardoso Lopes5a0af1f2017-03-18 00:26:18 +00001255 // Clear out any potential leftover.
1256 Locked.unsafeRemoveLockFile();
Reid Kleckner4dc0b1a2018-11-01 19:54:45 +00001257 LLVM_FALLTHROUGH;
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001258 case llvm::LockFileManager::LFS_Owned:
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001259 // We're responsible for building the module ourselves.
Ben Langmuirb797d592014-07-19 16:29:28 +00001260 if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
1261 ModuleFileName)) {
1262 diagnoseBuildFailure();
1263 return false;
1264 }
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001265 break;
1266
1267 case llvm::LockFileManager::LFS_Shared:
1268 // Someone else is responsible for building the module. Wait for them to
1269 // finish.
Ben Langmuir1daf4802015-02-09 20:35:13 +00001270 switch (Locked.waitForUnlock()) {
1271 case llvm::LockFileManager::Res_Success:
1272 ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1273 break;
1274 case llvm::LockFileManager::Res_OwnerDied:
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001275 continue; // try again to get the lock.
Ben Langmuir1daf4802015-02-09 20:35:13 +00001276 case llvm::LockFileManager::Res_Timeout:
Duncan P. N. Exon Smith8bef5cd2019-03-09 17:33:56 +00001277 // Since ModuleCache takes care of correctness, we try waiting for
1278 // another process to complete the build so clang does not do it done
1279 // twice. If case of timeout, build it ourselves.
Bruno Cardoso Lopes5a0af1f2017-03-18 00:26:18 +00001280 Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout)
Ben Langmuir1daf4802015-02-09 20:35:13 +00001281 << Module->Name;
Alexander Kornienko2a8c18d2018-04-06 15:14:32 +00001282 // Clear the lock file so that future invocations can make progress.
Ben Langmuir1daf4802015-02-09 20:35:13 +00001283 Locked.unsafeRemoveLockFile();
Bruno Cardoso Lopes5a0af1f2017-03-18 00:26:18 +00001284 continue;
Ben Langmuir1daf4802015-02-09 20:35:13 +00001285 }
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001286 break;
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001287 }
1288
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001289 // Try to read the module file, now that we've compiled it.
1290 ASTReader::ASTReadResult ReadResult =
1291 ImportingInstance.getModuleManager()->ReadAST(
Richard Smithe842a472014-10-22 02:05:46 +00001292 ModuleFileName, serialization::MK_ImplicitModule, ImportLoc,
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001293 ModuleLoadCapabilities);
1294
1295 if (ReadResult == ASTReader::OutOfDate &&
1296 Locked == llvm::LockFileManager::LFS_Shared) {
1297 // The module may be out of date in the presence of file system races,
1298 // or if one of its imports depends on header search paths that are not
1299 // consistent with this ImportingInstance. Try again...
1300 continue;
1301 } else if (ReadResult == ASTReader::Missing) {
Ben Langmuirb797d592014-07-19 16:29:28 +00001302 diagnoseBuildFailure();
Ben Langmuird213aab2014-09-26 22:42:23 +00001303 } else if (ReadResult != ASTReader::Success &&
1304 !Diags.hasErrorOccurred()) {
1305 // The ASTReader didn't diagnose the error, so conservatively report it.
1306 diagnoseBuildFailure();
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001307 }
1308 return ReadResult == ASTReader::Success;
Argyrios Kyrtzidis4382fe72014-04-06 03:21:44 +00001309 }
1310}
1311
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001312/// Diagnose differences between the current definition of the given
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001313/// configuration macro and the definition provided on the command line.
1314static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1315 Module *Mod, SourceLocation ImportLoc) {
1316 IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
1317 SourceManager &SourceMgr = PP.getSourceManager();
Fangrui Song6907ce22018-07-30 19:24:48 +00001318
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001319 // If this identifier has never had a macro definition, then it could
1320 // not have changed.
1321 if (!Id->hadMacroDefinition())
1322 return;
Richard Smith20e883e2015-04-29 23:20:19 +00001323 auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id);
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001324
Richard Smith20e883e2015-04-29 23:20:19 +00001325 // Find the macro definition from the command line.
1326 MacroInfo *CmdLineDefinition = nullptr;
1327 for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001328 // We only care about the predefines buffer.
Richard Smith20e883e2015-04-29 23:20:19 +00001329 FileID FID = SourceMgr.getFileID(MD->getLocation());
1330 if (FID.isInvalid() || FID != PP.getPredefinesFileID())
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001331 continue;
Richard Smith20e883e2015-04-29 23:20:19 +00001332 if (auto *DMD = dyn_cast<DefMacroDirective>(MD))
1333 CmdLineDefinition = DMD->getMacroInfo();
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001334 break;
1335 }
1336
Richard Smith20e883e2015-04-29 23:20:19 +00001337 auto *CurrentDefinition = PP.getMacroInfo(Id);
1338 if (CurrentDefinition == CmdLineDefinition) {
1339 // Macro matches. Nothing to do.
1340 } else if (!CurrentDefinition) {
1341 // This macro was defined on the command line, then #undef'd later.
1342 // Complain.
1343 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1344 << true << ConfigMacro << Mod->getFullModuleName();
1345 auto LatestDef = LatestLocalMD->getDefinition();
1346 assert(LatestDef.isUndefined() &&
1347 "predefined macro went away with no #undef?");
1348 PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1349 << true;
1350 return;
1351 } else if (!CmdLineDefinition) {
1352 // There was no definition for this macro in the predefines buffer,
1353 // but there was a local definition. Complain.
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001354 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1355 << false << ConfigMacro << Mod->getFullModuleName();
Richard Smith20e883e2015-04-29 23:20:19 +00001356 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1357 diag::note_module_def_undef_here)
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001358 << false;
Richard Smith20e883e2015-04-29 23:20:19 +00001359 } else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,
1360 /*Syntactically=*/true)) {
1361 // The macro definitions differ.
1362 PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1363 << false << ConfigMacro << Mod->getFullModuleName();
1364 PP.Diag(CurrentDefinition->getDefinitionLoc(),
1365 diag::note_module_def_undef_here)
1366 << false;
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001367 }
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001368}
1369
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001370/// Write a new timestamp file with the given path.
Douglas Gregor527b1c92013-03-25 21:19:16 +00001371static void writeTimestampFile(StringRef TimestampFile) {
Rafael Espindoladae941a2014-08-25 18:17:04 +00001372 std::error_code EC;
Fangrui Songd9b948b2019-08-05 05:43:48 +00001373 llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::OF_None);
Douglas Gregor527b1c92013-03-25 21:19:16 +00001374}
1375
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001376/// Prune the module cache of modules that haven't been accessed in
Douglas Gregor527b1c92013-03-25 21:19:16 +00001377/// a long time.
1378static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1379 struct stat StatBuf;
1380 llvm::SmallString<128> TimestampFile;
1381 TimestampFile = HSOpts.ModuleCachePath;
Richard Smith3938f0c2015-08-15 00:34:15 +00001382 assert(!TimestampFile.empty());
Douglas Gregor527b1c92013-03-25 21:19:16 +00001383 llvm::sys::path::append(TimestampFile, "modules.timestamp");
1384
1385 // Try to stat() the timestamp file.
1386 if (::stat(TimestampFile.c_str(), &StatBuf)) {
1387 // If the timestamp file wasn't there, create one now.
1388 if (errno == ENOENT) {
1389 writeTimestampFile(TimestampFile);
1390 }
1391 return;
1392 }
1393
1394 // Check whether the time stamp is older than our pruning interval.
1395 // If not, do nothing.
1396 time_t TimeStampModTime = StatBuf.st_mtime;
Craig Topper49a27902014-05-22 04:46:25 +00001397 time_t CurrentTime = time(nullptr);
Benjamin Kramerdbcf5032013-03-29 17:39:43 +00001398 if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
Douglas Gregor527b1c92013-03-25 21:19:16 +00001399 return;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001400
1401 // Write a new timestamp file so that nobody else attempts to prune.
1402 // There is a benign race condition here, if two Clang instances happen to
1403 // notice at the same time that the timestamp is out-of-date.
1404 writeTimestampFile(TimestampFile);
1405
1406 // Walk the entire module cache, looking for unused module files and module
1407 // indices.
Rafael Espindolac0809172014-06-12 14:02:15 +00001408 std::error_code EC;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001409 SmallString<128> ModuleCachePathNative;
1410 llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
Yaron Keren92e1b622015-03-18 10:17:07 +00001411 for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001412 Dir != DirEnd && !EC; Dir.increment(EC)) {
1413 // If we don't have a directory, there's nothing to look into.
Rafael Espindolaa07f7202013-07-17 04:23:07 +00001414 if (!llvm::sys::fs::is_directory(Dir->path()))
Douglas Gregor527b1c92013-03-25 21:19:16 +00001415 continue;
1416
1417 // Walk all of the files within this directory.
Douglas Gregor527b1c92013-03-25 21:19:16 +00001418 for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1419 File != FileEnd && !EC; File.increment(EC)) {
1420 // We only care about module and global module index files.
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001421 StringRef Extension = llvm::sys::path::extension(File->path());
1422 if (Extension != ".pcm" && Extension != ".timestamp" &&
1423 llvm::sys::path::filename(File->path()) != "modules.idx")
Douglas Gregor527b1c92013-03-25 21:19:16 +00001424 continue;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001425
1426 // Look at this file. If we can't stat it, there's nothing interesting
1427 // there.
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001428 if (::stat(File->path().c_str(), &StatBuf))
Douglas Gregor527b1c92013-03-25 21:19:16 +00001429 continue;
Douglas Gregor527b1c92013-03-25 21:19:16 +00001430
1431 // If the file has been used recently enough, leave it there.
1432 time_t FileAccessTime = StatBuf.st_atime;
Benjamin Kramerdbcf5032013-03-29 17:39:43 +00001433 if (CurrentTime - FileAccessTime <=
1434 time_t(HSOpts.ModuleCachePruneAfter)) {
Douglas Gregor527b1c92013-03-25 21:19:16 +00001435 continue;
1436 }
1437
1438 // Remove the file.
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001439 llvm::sys::fs::remove(File->path());
1440
1441 // Remove the timestamp file.
1442 std::string TimpestampFilename = File->path() + ".timestamp";
1443 llvm::sys::fs::remove(TimpestampFilename);
Douglas Gregor527b1c92013-03-25 21:19:16 +00001444 }
1445
1446 // If we removed all of the files in the directory, remove the directory
1447 // itself.
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001448 if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1449 llvm::sys::fs::directory_iterator() && !EC)
Rafael Espindola2a008782014-01-10 21:32:14 +00001450 llvm::sys::fs::remove(Dir->path());
Douglas Gregor527b1c92013-03-25 21:19:16 +00001451 }
1452}
1453
John Thompson2255f2c2014-04-23 12:57:01 +00001454void CompilerInstance::createModuleManager() {
1455 if (!ModuleManager) {
1456 if (!hasASTContext())
1457 createASTContext();
1458
Chandler Carruth580dd292015-03-24 21:44:25 +00001459 // If we're implicitly building modules but not currently recursively
1460 // building a module, check whether we need to prune the module cache.
Richard Smith3938f0c2015-08-15 00:34:15 +00001461 if (getSourceManager().getModuleBuildStack().empty() &&
1462 !getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty() &&
John Thompson2255f2c2014-04-23 12:57:01 +00001463 getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1464 getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1465 pruneModuleCache(getHeaderSearchOpts());
1466 }
1467
1468 HeaderSearchOptions &HSOpts = getHeaderSearchOpts();
1469 std::string Sysroot = HSOpts.Sysroot;
1470 const PreprocessorOptions &PPOpts = getPreprocessorOpts();
Richard Smithce18a182015-07-14 00:26:00 +00001471 std::unique_ptr<llvm::Timer> ReadTimer;
1472 if (FrontendTimerGroup)
Matthias Braunae032b62016-11-18 19:43:25 +00001473 ReadTimer = llvm::make_unique<llvm::Timer>("reading_modules",
1474 "Reading modules",
Richard Smithce18a182015-07-14 00:26:00 +00001475 *FrontendTimerGroup);
Adrian Prantlbb165fb2015-06-20 18:53:08 +00001476 ModuleManager = new ASTReader(
Duncan P. N. Exon Smith8bef5cd2019-03-09 17:33:56 +00001477 getPreprocessor(), getModuleCache(), &getASTContext(),
1478 getPCHContainerReader(), getFrontendOpts().ModuleFileExtensions,
Adrian Prantlbb165fb2015-06-20 18:53:08 +00001479 Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation,
1480 /*AllowASTWithCompilerErrors=*/false,
1481 /*AllowConfigurationMismatch=*/false,
1482 HSOpts.ModulesValidateSystemHeaders,
Duncan P. N. Exon Smith8bef5cd2019-03-09 17:33:56 +00001483 getFrontendOpts().UseGlobalModuleIndex, std::move(ReadTimer));
John Thompson2255f2c2014-04-23 12:57:01 +00001484 if (hasASTConsumer()) {
1485 ModuleManager->setDeserializationListener(
1486 getASTConsumer().GetASTDeserializationListener());
1487 getASTContext().setASTMutationListener(
1488 getASTConsumer().GetASTMutationListener());
1489 }
1490 getASTContext().setExternalSource(ModuleManager);
1491 if (hasSema())
1492 ModuleManager->InitializeSema(getSema());
Richard Smith293534b2015-08-18 20:39:29 +00001493 if (hasASTConsumer())
John Thompson2255f2c2014-04-23 12:57:01 +00001494 ModuleManager->StartTranslationUnit(&getASTConsumer());
Richard Smith03f7e612015-08-09 02:28:42 +00001495
Richard Smith03f7e612015-08-09 02:28:42 +00001496 for (auto &Listener : DependencyCollectors)
1497 Listener->attachToASTReader(*ModuleManager);
John Thompson2255f2c2014-04-23 12:57:01 +00001498 }
1499}
1500
Richard Smithd4b230b2014-10-27 23:01:16 +00001501bool CompilerInstance::loadModuleFile(StringRef FileName) {
Richard Smithce18a182015-07-14 00:26:00 +00001502 llvm::Timer Timer;
1503 if (FrontendTimerGroup)
Matthias Braunae032b62016-11-18 19:43:25 +00001504 Timer.init("preloading." + FileName.str(), "Preloading " + FileName.str(),
1505 *FrontendTimerGroup);
Richard Smithce18a182015-07-14 00:26:00 +00001506 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1507
Richard Smithd4b230b2014-10-27 23:01:16 +00001508 // Helper to recursively read the module names for all modules we're adding.
1509 // We mark these as known and redirect any attempt to load that module to
1510 // the files we were handed.
1511 struct ReadModuleNames : ASTReaderListener {
1512 CompilerInstance &CI;
Richard Smith0f99d6a2015-08-09 08:48:41 +00001513 llvm::SmallVector<IdentifierInfo*, 8> LoadedModules;
Richard Smithe842a472014-10-22 02:05:46 +00001514
Richard Smith0f99d6a2015-08-09 08:48:41 +00001515 ReadModuleNames(CompilerInstance &CI) : CI(CI) {}
Richard Smithe842a472014-10-22 02:05:46 +00001516
Richard Smithd4b230b2014-10-27 23:01:16 +00001517 void ReadModuleName(StringRef ModuleName) override {
Richard Smith0f99d6a2015-08-09 08:48:41 +00001518 LoadedModules.push_back(
1519 CI.getPreprocessor().getIdentifierInfo(ModuleName));
Richard Smithd4b230b2014-10-27 23:01:16 +00001520 }
Richard Smith0f99d6a2015-08-09 08:48:41 +00001521
1522 void registerAll() {
1523 for (auto *II : LoadedModules) {
1524 CI.KnownModules[II] = CI.getPreprocessor()
1525 .getHeaderSearchInfo()
1526 .getModuleMap()
1527 .findModule(II->getName());
1528 }
1529 LoadedModules.clear();
1530 }
Richard Smith8a308ec2015-11-05 00:54:55 +00001531
1532 void markAllUnavailable() {
1533 for (auto *II : LoadedModules) {
1534 if (Module *M = CI.getPreprocessor()
1535 .getHeaderSearchInfo()
1536 .getModuleMap()
Richard Smitha114c462016-12-06 00:40:17 +00001537 .findModule(II->getName())) {
Richard Smith8a308ec2015-11-05 00:54:55 +00001538 M->HasIncompatibleModuleFile = true;
Richard Smitha114c462016-12-06 00:40:17 +00001539
1540 // Mark module as available if the only reason it was unavailable
1541 // was missing headers.
1542 SmallVector<Module *, 2> Stack;
1543 Stack.push_back(M);
1544 while (!Stack.empty()) {
1545 Module *Current = Stack.pop_back_val();
1546 if (Current->IsMissingRequirement) continue;
1547 Current->IsAvailable = true;
1548 Stack.insert(Stack.end(),
1549 Current->submodule_begin(), Current->submodule_end());
1550 }
1551 }
Richard Smith8a308ec2015-11-05 00:54:55 +00001552 }
1553 LoadedModules.clear();
1554 }
Richard Smith0f99d6a2015-08-09 08:48:41 +00001555 };
Richard Smithd4b230b2014-10-27 23:01:16 +00001556
Richard Smith7f330cd2015-03-18 01:42:29 +00001557 // If we don't already have an ASTReader, create one now.
1558 if (!ModuleManager)
1559 createModuleManager();
1560
Richard Smith7a985e12018-05-24 20:03:51 +00001561 // If -Wmodule-file-config-mismatch is mapped as an error or worse, allow the
1562 // ASTReader to diagnose it, since it can produce better errors that we can.
1563 bool ConfigMismatchIsRecoverable =
1564 getDiagnostics().getDiagnosticLevel(diag::warn_module_config_mismatch,
1565 SourceLocation())
1566 <= DiagnosticsEngine::Warning;
1567
Richard Smith0f99d6a2015-08-09 08:48:41 +00001568 auto Listener = llvm::make_unique<ReadModuleNames>(*this);
1569 auto &ListenerRef = *Listener;
1570 ASTReader::ListenerScope ReadModuleNamesListener(*ModuleManager,
1571 std::move(Listener));
Richard Smith7f330cd2015-03-18 01:42:29 +00001572
Richard Smith0f99d6a2015-08-09 08:48:41 +00001573 // Try to load the module file.
Richard Smith7a985e12018-05-24 20:03:51 +00001574 switch (ModuleManager->ReadAST(
1575 FileName, serialization::MK_ExplicitModule, SourceLocation(),
1576 ConfigMismatchIsRecoverable ? ASTReader::ARR_ConfigurationMismatch : 0)) {
Richard Smith95dc57a2015-10-16 23:20:19 +00001577 case ASTReader::Success:
Richard Smith8a308ec2015-11-05 00:54:55 +00001578 // We successfully loaded the module file; remember the set of provided
1579 // modules so that we don't try to load implicit modules for them.
1580 ListenerRef.registerAll();
1581 return true;
Richard Smith95dc57a2015-10-16 23:20:19 +00001582
1583 case ASTReader::ConfigurationMismatch:
1584 // Ignore unusable module files.
1585 getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch)
1586 << FileName;
Richard Smith8a308ec2015-11-05 00:54:55 +00001587 // All modules provided by any files we tried and failed to load are now
1588 // unavailable; includes of those modules should now be handled textually.
1589 ListenerRef.markAllUnavailable();
Richard Smith95dc57a2015-10-16 23:20:19 +00001590 return true;
1591
1592 default:
1593 return false;
1594 }
Richard Smithe842a472014-10-22 02:05:46 +00001595}
1596
1597ModuleLoadResult
Douglas Gregor7a626572012-11-29 23:55:25 +00001598CompilerInstance::loadModule(SourceLocation ImportLoc,
1599 ModuleIdPath Path,
1600 Module::NameVisibilityKind Visibility,
1601 bool IsInclusionDirective) {
Richard Smith92304e02013-10-18 22:48:20 +00001602 // Determine what file we're searching from.
Richard Smithd6509cf2018-09-15 01:21:15 +00001603 StringRef ModuleName = Path[0].first->getName();
Richard Smith92304e02013-10-18 22:48:20 +00001604 SourceLocation ModuleNameLoc = Path[0].second;
1605
Douglas Gregor1805b8a2011-11-30 04:26:53 +00001606 // If we've already handled this import, just return the cached result.
1607 // This one-element cache is important to eliminate redundant diagnostics
1608 // when both the preprocessor and parser see the same import declaration.
Yaron Keren8b563662015-10-03 10:46:20 +00001609 if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) {
Douglas Gregorff2be532011-12-01 17:11:21 +00001610 // Make the named module visible.
Richard Smith7e82e012016-02-19 22:25:36 +00001611 if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
Argyrios Kyrtzidis125df052013-02-01 16:36:12 +00001612 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
Richard Smitha7e2cc62015-05-01 01:53:09 +00001613 ImportLoc);
Douglas Gregor69021972011-11-30 17:33:56 +00001614 return LastModuleImportResult;
Douglas Gregorff2be532011-12-01 17:11:21 +00001615 }
Douglas Gregor5196bc62011-11-30 04:03:44 +00001616
Craig Topper49a27902014-05-22 04:46:25 +00001617 clang::Module *Module = nullptr;
Richard Smith92304e02013-10-18 22:48:20 +00001618
Douglas Gregor5196bc62011-11-30 04:03:44 +00001619 // If we don't already have information on this module, load the module now.
Douglas Gregorde3ef502011-11-30 23:21:26 +00001620 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
Douglas Gregor69021972011-11-30 17:33:56 +00001621 = KnownModules.find(Path[0].first);
Douglas Gregor2537a362011-12-08 17:01:29 +00001622 if (Known != KnownModules.end()) {
1623 // Retrieve the cached top-level module.
Fangrui Song6907ce22018-07-30 19:24:48 +00001624 Module = Known->second;
Richard Smith7e82e012016-02-19 22:25:36 +00001625 } else if (ModuleName == getLangOpts().CurrentModule) {
Bruno Cardoso Lopes52431f32018-07-18 23:21:19 +00001626 // This is the module we're building.
1627 Module = PP->getHeaderSearchInfo().lookupModule(
1628 ModuleName, /*AllowSearch*/ true,
1629 /*AllowExtraModuleMapSearch*/ !IsInclusionDirective);
Boris Kolpackovd30446f2017-08-31 06:26:43 +00001630 /// FIXME: perhaps we should (a) look for a module using the module name
1631 // to file map (PrebuiltModuleFiles) and (b) diagnose if still not found?
1632 //if (Module == nullptr) {
1633 // getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1634 // << ModuleName;
1635 // ModuleBuildFailed = true;
1636 // return ModuleLoadResult();
1637 //}
Douglas Gregor2537a362011-12-08 17:01:29 +00001638 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1639 } else {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001640 // Search for a module with the given name.
Bruno Cardoso Lopes52431f32018-07-18 23:21:19 +00001641 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName, true,
1642 !IsInclusionDirective);
Manman Ren11f2a472016-08-18 17:42:15 +00001643 HeaderSearchOptions &HSOpts =
1644 PP->getHeaderSearchInfo().getHeaderSearchOpts();
1645
1646 std::string ModuleFileName;
Richard Smith5d2ed482017-06-09 19:22:32 +00001647 enum ModuleSource {
1648 ModuleNotFound, ModuleCache, PrebuiltModulePath, ModuleBuildPragma
1649 } Source = ModuleNotFound;
1650
1651 // Check to see if the module has been built as part of this compilation
1652 // via a module build pragma.
1653 auto BuiltModuleIt = BuiltModules.find(ModuleName);
1654 if (BuiltModuleIt != BuiltModules.end()) {
1655 ModuleFileName = BuiltModuleIt->second;
1656 Source = ModuleBuildPragma;
1657 }
1658
1659 // Try to load the module from the prebuilt module path.
Boris Kolpackovd30446f2017-08-31 06:26:43 +00001660 if (Source == ModuleNotFound && (!HSOpts.PrebuiltModuleFiles.empty() ||
1661 !HSOpts.PrebuiltModulePaths.empty())) {
1662 ModuleFileName =
1663 PP->getHeaderSearchInfo().getPrebuiltModuleFileName(ModuleName);
Manman Ren11f2a472016-08-18 17:42:15 +00001664 if (!ModuleFileName.empty())
Richard Smith5d2ed482017-06-09 19:22:32 +00001665 Source = PrebuiltModulePath;
Manman Ren11f2a472016-08-18 17:42:15 +00001666 }
Richard Smith5d2ed482017-06-09 19:22:32 +00001667
1668 // Try to load the module from the module cache.
1669 if (Source == ModuleNotFound && Module) {
Boris Kolpackovd30446f2017-08-31 06:26:43 +00001670 ModuleFileName = PP->getHeaderSearchInfo().getCachedModuleFileName(Module);
Richard Smith5d2ed482017-06-09 19:22:32 +00001671 Source = ModuleCache;
1672 }
1673
1674 if (Source == ModuleNotFound) {
Manman Ren11f2a472016-08-18 17:42:15 +00001675 // We can't find a module, error out here.
Ben Langmuir9eb229b2014-01-22 23:19:39 +00001676 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
Richard Smith5d2ed482017-06-09 19:22:32 +00001677 << ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
Ben Langmuir9eb229b2014-01-22 23:19:39 +00001678 ModuleBuildFailed = true;
1679 return ModuleLoadResult();
1680 }
1681
Richard Smithd520a252015-07-21 18:07:47 +00001682 if (ModuleFileName.empty()) {
Manman Ren11f2a472016-08-18 17:42:15 +00001683 if (Module && Module->HasIncompatibleModuleFile) {
Richard Smith8a308ec2015-11-05 00:54:55 +00001684 // We tried and failed to load a module file for this module. Fall
1685 // back to textual inclusion for its headers.
Richard Smitha114c462016-12-06 00:40:17 +00001686 return ModuleLoadResult::ConfigMismatch;
Richard Smith8a308ec2015-11-05 00:54:55 +00001687 }
1688
Manuel Klimekd2e8b042015-02-20 11:44:41 +00001689 getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
1690 << ModuleName;
1691 ModuleBuildFailed = true;
1692 return ModuleLoadResult();
1693 }
Richard Smithd4b230b2014-10-27 23:01:16 +00001694
Douglas Gregor5196bc62011-11-30 04:03:44 +00001695 // If we don't already have an ASTReader, create one now.
John Thompson2255f2c2014-04-23 12:57:01 +00001696 if (!ModuleManager)
1697 createModuleManager();
Douglas Gregor5196bc62011-11-30 04:03:44 +00001698
Richard Smithce18a182015-07-14 00:26:00 +00001699 llvm::Timer Timer;
1700 if (FrontendTimerGroup)
Matthias Braunae032b62016-11-18 19:43:25 +00001701 Timer.init("loading." + ModuleFileName, "Loading " + ModuleFileName,
1702 *FrontendTimerGroup);
Richard Smithce18a182015-07-14 00:26:00 +00001703 llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
Anton Afanasyevd880de22019-03-30 08:42:48 +00001704 llvm::TimeTraceScope TimeScope("Module Load", ModuleName);
Richard Smithce18a182015-07-14 00:26:00 +00001705
Richard Smith5d2ed482017-06-09 19:22:32 +00001706 // Try to load the module file. If we are not trying to load from the
1707 // module cache, we don't know how to rebuild modules.
1708 unsigned ARRFlags = Source == ModuleCache ?
1709 ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing :
David Blaikie436f7b62018-11-08 20:47:30 +00001710 Source == PrebuiltModulePath ?
1711 0 :
1712 ASTReader::ARR_ConfigurationMismatch;
Richard Smithe842a472014-10-22 02:05:46 +00001713 switch (ModuleManager->ReadAST(ModuleFileName,
Richard Smith5d2ed482017-06-09 19:22:32 +00001714 Source == PrebuiltModulePath
1715 ? serialization::MK_PrebuiltModule
1716 : Source == ModuleBuildPragma
1717 ? serialization::MK_ExplicitModule
1718 : serialization::MK_ImplicitModule,
1719 ImportLoc, ARRFlags)) {
Manman Ren11f2a472016-08-18 17:42:15 +00001720 case ASTReader::Success: {
Richard Smith5d2ed482017-06-09 19:22:32 +00001721 if (Source != ModuleCache && !Module) {
Bruno Cardoso Lopes52431f32018-07-18 23:21:19 +00001722 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName, true,
1723 !IsInclusionDirective);
Harlan Haskins8d323d12019-08-01 21:31:56 +00001724 auto ModuleFile = FileMgr->getFile(ModuleFileName);
Manman Ren11f2a472016-08-18 17:42:15 +00001725 if (!Module || !Module->getASTFile() ||
Harlan Haskins8d323d12019-08-01 21:31:56 +00001726 !ModuleFile || (*ModuleFile != Module->getASTFile())) {
Manman Ren11f2a472016-08-18 17:42:15 +00001727 // Error out if Module does not refer to the file in the prebuilt
1728 // module path.
1729 getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt)
1730 << ModuleName;
1731 ModuleBuildFailed = true;
1732 KnownModules[Path[0].first] = nullptr;
1733 return ModuleLoadResult();
1734 }
1735 }
Douglas Gregor5196bc62011-11-30 04:03:44 +00001736 break;
Manman Ren11f2a472016-08-18 17:42:15 +00001737 }
Douglas Gregor5196bc62011-11-30 04:03:44 +00001738
Eli Friedman963ff2c2013-09-17 00:51:29 +00001739 case ASTReader::OutOfDate:
Douglas Gregor7029ce12013-03-19 00:28:20 +00001740 case ASTReader::Missing: {
Richard Smith5d2ed482017-06-09 19:22:32 +00001741 if (Source != ModuleCache) {
1742 // We don't know the desired configuration for this module and don't
1743 // necessarily even have a module map. Since ReadAST already produces
1744 // diagnostics for these two cases, we simply error out here.
Manman Ren11f2a472016-08-18 17:42:15 +00001745 ModuleBuildFailed = true;
1746 KnownModules[Path[0].first] = nullptr;
1747 return ModuleLoadResult();
1748 }
1749
Eli Friedman963ff2c2013-09-17 00:51:29 +00001750 // The module file is missing or out-of-date. Build it.
Ben Langmuir9eb229b2014-01-22 23:19:39 +00001751 assert(Module && "missing module file");
Douglas Gregor7029ce12013-03-19 00:28:20 +00001752 // Check whether there is a cycle in the module graph.
1753 ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1754 ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1755 for (; Pos != PosEnd; ++Pos) {
1756 if (Pos->first == ModuleName)
1757 break;
1758 }
1759
1760 if (Pos != PosEnd) {
1761 SmallString<256> CyclePath;
1762 for (; Pos != PosEnd; ++Pos) {
1763 CyclePath += Pos->first;
1764 CyclePath += " -> ";
1765 }
1766 CyclePath += ModuleName;
1767
1768 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1769 << ModuleName << CyclePath;
1770 return ModuleLoadResult();
1771 }
Douglas Gregor7a626572012-11-29 23:55:25 +00001772
1773 // Check whether we have already attempted to build this module (but
1774 // failed).
1775 if (getPreprocessorOpts().FailedModules &&
1776 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1777 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1778 << ModuleName
1779 << SourceRange(ImportLoc, ModuleNameLoc);
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001780 ModuleBuildFailed = true;
Douglas Gregor7a626572012-11-29 23:55:25 +00001781 return ModuleLoadResult();
1782 }
1783
Ben Langmuirdbdc0362014-06-17 22:35:27 +00001784 // Try to compile and then load the module.
1785 if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module,
1786 ModuleFileName)) {
Ben Langmuird213aab2014-09-26 22:42:23 +00001787 assert(getDiagnostics().hasErrorOccurred() &&
1788 "undiagnosed error in compileAndLoadModule");
Douglas Gregor0f2b4632013-01-10 02:04:18 +00001789 if (getPreprocessorOpts().FailedModules)
1790 getPreprocessorOpts().FailedModules->addFailed(ModuleName);
Craig Topper49a27902014-05-22 04:46:25 +00001791 KnownModules[Path[0].first] = nullptr;
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001792 ModuleBuildFailed = true;
Douglas Gregor7a626572012-11-29 23:55:25 +00001793 return ModuleLoadResult();
Douglas Gregor188dbef2012-11-07 17:46:15 +00001794 }
1795
1796 // Okay, we've rebuilt and now loaded the module.
1797 break;
1798 }
1799
Douglas Gregorc9ad5fb2012-10-22 22:50:17 +00001800 case ASTReader::ConfigurationMismatch:
Richard Smith5d2ed482017-06-09 19:22:32 +00001801 if (Source == PrebuiltModulePath)
1802 // FIXME: We shouldn't be setting HadFatalFailure below if we only
1803 // produce a warning here!
Manman Ren11f2a472016-08-18 17:42:15 +00001804 getDiagnostics().Report(SourceLocation(),
1805 diag::warn_module_config_mismatch)
1806 << ModuleFileName;
1807 // Fall through to error out.
Galina Kistanovae37ad5a2017-06-03 06:27:16 +00001808 LLVM_FALLTHROUGH;
Manman Ren11f2a472016-08-18 17:42:15 +00001809 case ASTReader::VersionMismatch:
Douglas Gregorc9ad5fb2012-10-22 22:50:17 +00001810 case ASTReader::HadErrors:
Argyrios Kyrtzidisdc9fdaf2013-05-24 05:44:08 +00001811 ModuleLoader::HadFatalFailure = true;
Richard Smith0f99d6a2015-08-09 08:48:41 +00001812 // FIXME: The ASTReader will already have complained, but can we shoehorn
Douglas Gregor5196bc62011-11-30 04:03:44 +00001813 // that diagnostic information into a more useful form?
Craig Topper49a27902014-05-22 04:46:25 +00001814 KnownModules[Path[0].first] = nullptr;
Douglas Gregor7a626572012-11-29 23:55:25 +00001815 return ModuleLoadResult();
Douglas Gregor5196bc62011-11-30 04:03:44 +00001816
1817 case ASTReader::Failure:
Argyrios Kyrtzidisdc9fdaf2013-05-24 05:44:08 +00001818 ModuleLoader::HadFatalFailure = true;
Douglas Gregor69021972011-11-30 17:33:56 +00001819 // Already complained, but note now that we failed.
Craig Topper49a27902014-05-22 04:46:25 +00001820 KnownModules[Path[0].first] = nullptr;
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001821 ModuleBuildFailed = true;
Douglas Gregor7a626572012-11-29 23:55:25 +00001822 return ModuleLoadResult();
Douglas Gregor5196bc62011-11-30 04:03:44 +00001823 }
Argyrios Kyrtzidis43af5132012-09-29 01:06:04 +00001824
Douglas Gregor69021972011-11-30 17:33:56 +00001825 // Cache the result of this top-level module lookup for later.
1826 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
Douglas Gregor08142532011-08-26 23:56:07 +00001827 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001828
Douglas Gregor69021972011-11-30 17:33:56 +00001829 // If we never found the module, fail.
1830 if (!Module)
Douglas Gregor7a626572012-11-29 23:55:25 +00001831 return ModuleLoadResult();
Richard Smith5d2ed482017-06-09 19:22:32 +00001832
Douglas Gregor5196bc62011-11-30 04:03:44 +00001833 // Verify that the rest of the module path actually corresponds to
1834 // a submodule.
Bruno Cardoso Lopes84bc0a22017-12-22 05:04:43 +00001835 bool MapPrivateSubModToTopLevel = false;
Richard Smithd6509cf2018-09-15 01:21:15 +00001836 if (Path.size() > 1) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001837 for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1838 StringRef Name = Path[I].first->getName();
Douglas Gregoreb90e832012-01-04 23:32:19 +00001839 clang::Module *Sub = Module->findSubmodule(Name);
Bruno Cardoso Lopes92849312018-02-12 23:43:21 +00001840
1841 // If the user is requesting Foo.Private and it doesn't exist, try to
1842 // match Foo_Private and emit a warning asking for the user to write
1843 // @import Foo_Private instead. FIXME: remove this when existing clients
1844 // migrate off of Foo.Private syntax.
1845 if (!Sub && PP->getLangOpts().ImplicitModules && Name == "Private" &&
1846 Module == Module->getTopLevelModule()) {
1847 SmallString<128> PrivateModule(Module->Name);
1848 PrivateModule.append("_Private");
1849
1850 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> PrivPath;
1851 auto &II = PP->getIdentifierTable().get(
1852 PrivateModule, PP->getIdentifierInfo(Module->Name)->getTokenID());
1853 PrivPath.push_back(std::make_pair(&II, Path[0].second));
1854
Bruno Cardoso Lopes52431f32018-07-18 23:21:19 +00001855 if (PP->getHeaderSearchInfo().lookupModule(PrivateModule, true,
1856 !IsInclusionDirective))
Bruno Cardoso Lopes92849312018-02-12 23:43:21 +00001857 Sub =
1858 loadModule(ImportLoc, PrivPath, Visibility, IsInclusionDirective);
1859 if (Sub) {
1860 MapPrivateSubModToTopLevel = true;
1861 if (!getDiagnostics().isIgnored(
1862 diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) {
1863 getDiagnostics().Report(Path[I].second,
1864 diag::warn_no_priv_submodule_use_toplevel)
1865 << Path[I].first << Module->getFullModuleName() << PrivateModule
1866 << SourceRange(Path[0].second, Path[I].second)
1867 << FixItHint::CreateReplacement(SourceRange(Path[0].second),
1868 PrivateModule);
1869 getDiagnostics().Report(Sub->DefinitionLoc,
1870 diag::note_private_top_level_defined);
1871 }
1872 }
1873 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001874
Douglas Gregoreb90e832012-01-04 23:32:19 +00001875 if (!Sub) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001876 // Attempt to perform typo correction to find a module name that works.
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001877 SmallVector<StringRef, 2> Best;
Douglas Gregor5196bc62011-11-30 04:03:44 +00001878 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
Fangrui Song6907ce22018-07-30 19:24:48 +00001879
1880 for (clang::Module::submodule_iterator J = Module->submodule_begin(),
Douglas Gregoreb90e832012-01-04 23:32:19 +00001881 JEnd = Module->submodule_end();
Matt Beaumont-Gayeb44eda2011-11-30 19:41:21 +00001882 J != JEnd; ++J) {
Douglas Gregoreb90e832012-01-04 23:32:19 +00001883 unsigned ED = Name.edit_distance((*J)->Name,
Douglas Gregor5196bc62011-11-30 04:03:44 +00001884 /*AllowReplacements=*/true,
1885 BestEditDistance);
1886 if (ED <= BestEditDistance) {
Douglas Gregoreb90e832012-01-04 23:32:19 +00001887 if (ED < BestEditDistance) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001888 Best.clear();
Douglas Gregoreb90e832012-01-04 23:32:19 +00001889 BestEditDistance = ED;
1890 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001891
Douglas Gregoreb90e832012-01-04 23:32:19 +00001892 Best.push_back((*J)->Name);
Douglas Gregor5196bc62011-11-30 04:03:44 +00001893 }
1894 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001895
Douglas Gregor5196bc62011-11-30 04:03:44 +00001896 // If there was a clear winner, user it.
1897 if (Best.size() == 1) {
Fangrui Song6907ce22018-07-30 19:24:48 +00001898 getDiagnostics().Report(Path[I].second,
Douglas Gregor5196bc62011-11-30 04:03:44 +00001899 diag::err_no_submodule_suggest)
Douglas Gregor69021972011-11-30 17:33:56 +00001900 << Path[I].first << Module->getFullModuleName() << Best[0]
Douglas Gregor5196bc62011-11-30 04:03:44 +00001901 << SourceRange(Path[0].second, Path[I-1].second)
1902 << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1903 Best[0]);
Fangrui Song6907ce22018-07-30 19:24:48 +00001904
Douglas Gregoreb90e832012-01-04 23:32:19 +00001905 Sub = Module->findSubmodule(Best[0]);
Douglas Gregor5196bc62011-11-30 04:03:44 +00001906 }
1907 }
Bruno Cardoso Lopes84bc0a22017-12-22 05:04:43 +00001908
Douglas Gregoreb90e832012-01-04 23:32:19 +00001909 if (!Sub) {
Douglas Gregor5196bc62011-11-30 04:03:44 +00001910 // No submodule by this name. Complain, and don't look for further
1911 // submodules.
1912 getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
Douglas Gregor69021972011-11-30 17:33:56 +00001913 << Path[I].first << Module->getFullModuleName()
Douglas Gregor5196bc62011-11-30 04:03:44 +00001914 << SourceRange(Path[0].second, Path[I-1].second);
1915 break;
1916 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001917
Douglas Gregoreb90e832012-01-04 23:32:19 +00001918 Module = Sub;
Douglas Gregor5196bc62011-11-30 04:03:44 +00001919 }
Douglas Gregor08142532011-08-26 23:56:07 +00001920 }
Ben Langmuirb537a3a2014-07-23 15:30:23 +00001921
Douglas Gregor2537a362011-12-08 17:01:29 +00001922 // Make the named module visible, if it's not already part of the module
1923 // we are parsing.
Douglas Gregor98a52db2011-12-20 00:28:52 +00001924 if (ModuleName != getLangOpts().CurrentModule) {
Bruno Cardoso Lopes84bc0a22017-12-22 05:04:43 +00001925 if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) {
Douglas Gregor98a52db2011-12-20 00:28:52 +00001926 // We have an umbrella header or directory that doesn't actually include
1927 // all of the headers within the directory it covers. Complain about
1928 // this missing submodule and recover by forgetting that we ever saw
1929 // this submodule.
1930 // FIXME: Should we detect this at module load time? It seems fairly
1931 // expensive (and rare).
1932 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1933 << Module->getFullModuleName()
1934 << SourceRange(Path.front().second, Path.back().second);
Craig Topper49a27902014-05-22 04:46:25 +00001935
Richard Smitha114c462016-12-06 00:40:17 +00001936 return ModuleLoadResult::MissingExpected;
Douglas Gregor98a52db2011-12-20 00:28:52 +00001937 }
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00001938
1939 // Check whether this module is available.
Richard Smith27e5aa02017-06-05 18:57:56 +00001940 if (Preprocessor::checkModuleIsAvailable(getLangOpts(), getTarget(),
1941 getDiagnostics(), Module)) {
1942 getDiagnostics().Report(ImportLoc, diag::note_module_import_here)
1943 << SourceRange(Path.front().second, Path.back().second);
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00001944 LastModuleImportLoc = ImportLoc;
Douglas Gregor7a626572012-11-29 23:55:25 +00001945 LastModuleImportResult = ModuleLoadResult();
1946 return ModuleLoadResult();
Douglas Gregor1fb5c3a2011-12-31 04:05:44 +00001947 }
1948
Richard Smitha7e2cc62015-05-01 01:53:09 +00001949 ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
Douglas Gregor98a52db2011-12-20 00:28:52 +00001950 }
Douglas Gregor35b13ec2013-03-20 00:22:05 +00001951
1952 // Check for any configuration macros that have changed.
1953 clang::Module *TopModule = Module->getTopLevelModule();
1954 for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1955 checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1956 Module, ImportLoc);
1957 }
1958
Bruno Cardoso Lopesa3b5f712018-04-16 19:42:32 +00001959 // Resolve any remaining module using export_as for this one.
1960 getPreprocessor()
1961 .getHeaderSearchInfo()
1962 .getModuleMap()
1963 .resolveLinkAsDependencies(TopModule);
1964
Douglas Gregor1805b8a2011-11-30 04:26:53 +00001965 LastModuleImportLoc = ImportLoc;
Richard Smitha114c462016-12-06 00:40:17 +00001966 LastModuleImportResult = ModuleLoadResult(Module);
Douglas Gregor7a626572012-11-29 23:55:25 +00001967 return LastModuleImportResult;
Douglas Gregor08142532011-08-26 23:56:07 +00001968}
Douglas Gregorc147b0b2013-01-12 01:29:50 +00001969
Richard Smith5d2ed482017-06-09 19:22:32 +00001970void CompilerInstance::loadModuleFromSource(SourceLocation ImportLoc,
1971 StringRef ModuleName,
1972 StringRef Source) {
Richard Smith9565c75b2017-06-19 23:09:36 +00001973 // Avoid creating filenames with special characters.
1974 SmallString<128> CleanModuleName(ModuleName);
1975 for (auto &C : CleanModuleName)
1976 if (!isAlphanumeric(C))
1977 C = '_';
1978
Richard Smith5d2ed482017-06-09 19:22:32 +00001979 // FIXME: Using a randomized filename here means that our intermediate .pcm
1980 // output is nondeterministic (as .pcm files refer to each other by name).
1981 // Can this affect the output in any way?
1982 SmallString<128> ModuleFileName;
1983 if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
Richard Smith9565c75b2017-06-19 23:09:36 +00001984 CleanModuleName, "pcm", ModuleFileName)) {
Richard Smith5d2ed482017-06-09 19:22:32 +00001985 getDiagnostics().Report(ImportLoc, diag::err_fe_unable_to_open_output)
1986 << ModuleFileName << EC.message();
1987 return;
1988 }
Richard Smith9565c75b2017-06-19 23:09:36 +00001989 std::string ModuleMapFileName = (CleanModuleName + ".map").str();
Richard Smith5d2ed482017-06-09 19:22:32 +00001990
1991 FrontendInputFile Input(
1992 ModuleMapFileName,
1993 InputKind(getLanguageFromOptions(*Invocation->getLangOpts()),
1994 InputKind::ModuleMap, /*Preprocessed*/true));
1995
1996 std::string NullTerminatedSource(Source.str());
1997
1998 auto PreBuildStep = [&](CompilerInstance &Other) {
1999 // Create a virtual file containing our desired source.
2000 // FIXME: We shouldn't need to do this.
2001 const FileEntry *ModuleMapFile = Other.getFileManager().getVirtualFile(
2002 ModuleMapFileName, NullTerminatedSource.size(), 0);
2003 Other.getSourceManager().overrideFileContents(
2004 ModuleMapFile,
2005 llvm::MemoryBuffer::getMemBuffer(NullTerminatedSource.c_str()));
2006
2007 Other.BuiltModules = std::move(BuiltModules);
Richard Smith86a3ef52017-06-09 21:24:02 +00002008 Other.DeleteBuiltModules = false;
Richard Smith5d2ed482017-06-09 19:22:32 +00002009 };
2010
2011 auto PostBuildStep = [this](CompilerInstance &Other) {
2012 BuiltModules = std::move(Other.BuiltModules);
Richard Smith5d2ed482017-06-09 19:22:32 +00002013 };
2014
2015 // Build the module, inheriting any modules that we've built locally.
2016 if (compileModuleImpl(*this, ImportLoc, ModuleName, Input, StringRef(),
2017 ModuleFileName, PreBuildStep, PostBuildStep)) {
2018 BuiltModules[ModuleName] = ModuleFileName.str();
2019 llvm::sys::RemoveFileOnSignal(ModuleFileName);
2020 }
2021}
2022
Douglas Gregorc147b0b2013-01-12 01:29:50 +00002023void CompilerInstance::makeModuleVisible(Module *Mod,
Argyrios Kyrtzidis125df052013-02-01 16:36:12 +00002024 Module::NameVisibilityKind Visibility,
Richard Smitha7e2cc62015-05-01 01:53:09 +00002025 SourceLocation ImportLoc) {
Richard Smith42413142015-05-15 20:05:43 +00002026 if (!ModuleManager)
2027 createModuleManager();
2028 if (!ModuleManager)
2029 return;
2030
Richard Smitha7e2cc62015-05-01 01:53:09 +00002031 ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
Douglas Gregorc147b0b2013-01-12 01:29:50 +00002032}
2033
John Thompson2255f2c2014-04-23 12:57:01 +00002034GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex(
2035 SourceLocation TriggerLoc) {
Richard Smith3938f0c2015-08-15 00:34:15 +00002036 if (getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
2037 return nullptr;
John Thompson2255f2c2014-04-23 12:57:01 +00002038 if (!ModuleManager)
2039 createModuleManager();
2040 // Can't do anything if we don't have the module manager.
2041 if (!ModuleManager)
Craig Topper49a27902014-05-22 04:46:25 +00002042 return nullptr;
John Thompson2255f2c2014-04-23 12:57:01 +00002043 // Get an existing global index. This loads it if not already
2044 // loaded.
2045 ModuleManager->loadGlobalIndex();
2046 GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
2047 // If the global index doesn't exist, create it.
2048 if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
2049 hasPreprocessor()) {
2050 llvm::sys::fs::create_directories(
2051 getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
JF Bastien0e828952019-06-26 19:50:12 +00002052 if (llvm::Error Err = GlobalModuleIndex::writeIndex(
2053 getFileManager(), getPCHContainerReader(),
2054 getPreprocessor().getHeaderSearchInfo().getModuleCachePath())) {
2055 // FIXME this drops the error on the floor. This code is only used for
2056 // typo correction and drops more than just this one source of errors
2057 // (such as the directory creation failure above). It should handle the
2058 // error.
2059 consumeError(std::move(Err));
2060 return nullptr;
2061 }
John Thompson2255f2c2014-04-23 12:57:01 +00002062 ModuleManager->resetForReload();
2063 ModuleManager->loadGlobalIndex();
2064 GlobalIndex = ModuleManager->getGlobalIndex();
2065 }
2066 // For finding modules needing to be imported for fixit messages,
2067 // we need to make the global index cover all modules, so we do that here.
2068 if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
2069 ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap();
2070 bool RecreateIndex = false;
2071 for (ModuleMap::module_iterator I = MMap.module_begin(),
2072 E = MMap.module_end(); I != E; ++I) {
2073 Module *TheModule = I->second;
2074 const FileEntry *Entry = TheModule->getASTFile();
2075 if (!Entry) {
2076 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
2077 Path.push_back(std::make_pair(
Richard Smith629d8e62015-08-11 00:03:28 +00002078 getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
John Thompson2255f2c2014-04-23 12:57:01 +00002079 std::reverse(Path.begin(), Path.end());
Richard Smith629d8e62015-08-11 00:03:28 +00002080 // Load a module as hidden. This also adds it to the global index.
2081 loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false);
John Thompson2255f2c2014-04-23 12:57:01 +00002082 RecreateIndex = true;
2083 }
2084 }
2085 if (RecreateIndex) {
JF Bastien0e828952019-06-26 19:50:12 +00002086 if (llvm::Error Err = GlobalModuleIndex::writeIndex(
2087 getFileManager(), getPCHContainerReader(),
2088 getPreprocessor().getHeaderSearchInfo().getModuleCachePath())) {
2089 // FIXME As above, this drops the error on the floor.
2090 consumeError(std::move(Err));
2091 return nullptr;
2092 }
John Thompson2255f2c2014-04-23 12:57:01 +00002093 ModuleManager->resetForReload();
2094 ModuleManager->loadGlobalIndex();
2095 GlobalIndex = ModuleManager->getGlobalIndex();
2096 }
2097 HaveFullGlobalModuleIndex = true;
2098 }
2099 return GlobalIndex;
2100}
John Thompson2d94bbb2014-04-23 19:04:32 +00002101
2102// Check global module index for missing imports.
2103bool
2104CompilerInstance::lookupMissingImports(StringRef Name,
2105 SourceLocation TriggerLoc) {
2106 // Look for the symbol in non-imported modules, but only if an error
2107 // actually occurred.
2108 if (!buildingModule()) {
2109 // Load global module index, or retrieve a previously loaded one.
2110 GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex(
2111 TriggerLoc);
2112
2113 // Only if we have a global index.
2114 if (GlobalIndex) {
2115 GlobalModuleIndex::HitSet FoundModules;
2116
2117 // Find the modules that reference the identifier.
2118 // Note that this only finds top-level modules.
2119 // We'll let diagnoseTypo find the actual declaration module.
2120 if (GlobalIndex->lookupIdentifier(Name, FoundModules))
2121 return true;
2122 }
2123 }
2124
2125 return false;
2126}
David Blaikie9941da42018-11-17 18:04:13 +00002127void CompilerInstance::resetAndLeakSema() { llvm::BuryPointer(takeSema()); }
Benjamin Kramer7de99692016-11-16 18:15:26 +00002128
2129void CompilerInstance::setExternalSemaSource(
2130 IntrusiveRefCntPtr<ExternalSemaSource> ESS) {
2131 ExternalSemaSrc = std::move(ESS);
2132}