1	//===--- CompilerInstance.cpp ---------------------------------------------===//
2	//
3	// 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
6	//
7	//===----------------------------------------------------------------------===//
8
9	#include "clang/Frontend/CompilerInstance.h"
10	#include "clang/AST/ASTConsumer.h"
11	#include "clang/AST/ASTContext.h"
12	#include "clang/AST/Decl.h"
13	#include "clang/Basic/CharInfo.h"
14	#include "clang/Basic/Diagnostic.h"
15	#include "clang/Basic/DiagnosticOptions.h"
16	#include "clang/Basic/FileManager.h"
17	#include "clang/Basic/LangStandard.h"
18	#include "clang/Basic/SourceManager.h"
19	#include "clang/Basic/Stack.h"
20	#include "clang/Basic/TargetInfo.h"
21	#include "clang/Basic/Version.h"
22	#include "clang/Config/config.h"
23	#include "clang/Frontend/ChainedDiagnosticConsumer.h"
24	#include "clang/Frontend/FrontendAction.h"
25	#include "clang/Frontend/FrontendActions.h"
26	#include "clang/Frontend/FrontendDiagnostic.h"
27	#include "clang/Frontend/FrontendPluginRegistry.h"
28	#include "clang/Frontend/LogDiagnosticPrinter.h"
29	#include "clang/Frontend/SARIFDiagnosticPrinter.h"
30	#include "clang/Frontend/SerializedDiagnosticPrinter.h"
31	#include "clang/Frontend/TextDiagnosticPrinter.h"
32	#include "clang/Frontend/Utils.h"
33	#include "clang/Frontend/VerifyDiagnosticConsumer.h"
34	#include "clang/Lex/HeaderSearch.h"
35	#include "clang/Lex/Preprocessor.h"
36	#include "clang/Lex/PreprocessorOptions.h"
37	#include "clang/Sema/CodeCompleteConsumer.h"
38	#include "clang/Sema/Sema.h"
39	#include "clang/Serialization/ASTReader.h"
40	#include "clang/Serialization/GlobalModuleIndex.h"
41	#include "clang/Serialization/InMemoryModuleCache.h"
42	#include "llvm/ADT/STLExtras.h"
43	#include "llvm/ADT/ScopeExit.h"
44	#include "llvm/ADT/Statistic.h"
45	#include "llvm/Config/llvm-config.h"
46	#include "llvm/Support/BuryPointer.h"
47	#include "llvm/Support/CrashRecoveryContext.h"
48	#include "llvm/Support/Errc.h"
49	#include "llvm/Support/FileSystem.h"
50	#include "llvm/Support/LockFileManager.h"
51	#include "llvm/Support/MemoryBuffer.h"
52	#include "llvm/Support/Path.h"
53	#include "llvm/Support/Program.h"
54	#include "llvm/Support/Signals.h"
55	#include "llvm/Support/TimeProfiler.h"
56	#include "llvm/Support/Timer.h"
57	#include "llvm/Support/raw_ostream.h"
58	#include "llvm/TargetParser/Host.h"
59	#include <optional>
60	#include <time.h>
61	#include <utility>
62
63	using namespace clang;
64
65	CompilerInstance::CompilerInstance(
66	std::shared_ptr<PCHContainerOperations> PCHContainerOps,
67	InMemoryModuleCache *SharedModuleCache)
68	: ModuleLoader(/* BuildingModule = */ SharedModuleCache),
69	Invocation(new CompilerInvocation()),
70	ModuleCache(SharedModuleCache ? SharedModuleCache
71	: new InMemoryModuleCache),
72	ThePCHContainerOperations(std::move(PCHContainerOps)) {}
73
74	CompilerInstance::~CompilerInstance() {
75	assert(OutputFiles.empty() && "Still output files in flight?");
76	}
77
78	void CompilerInstance::setInvocation(
79	std::shared_ptr<CompilerInvocation> Value) {
80	Invocation = std::move(Value);
81	}
82
83	bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
84	return (BuildGlobalModuleIndex ||
85	(TheASTReader && TheASTReader->isGlobalIndexUnavailable() &&
86	getFrontendOpts().GenerateGlobalModuleIndex)) &&
87	!DisableGeneratingGlobalModuleIndex;
88	}
89
90	void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
91	Diagnostics = Value;
92	}
93
94	void CompilerInstance::setVerboseOutputStream(raw_ostream &Value) {
95	OwnedVerboseOutputStream.reset();
96	VerboseOutputStream = &Value;
97	}
98
99	void CompilerInstance::setVerboseOutputStream(std::unique_ptr<raw_ostream> Value) {
100	OwnedVerboseOutputStream.swap(u&: Value);
101	VerboseOutputStream = OwnedVerboseOutputStream.get();
102	}
103
104	void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; }
105	void CompilerInstance::setAuxTarget(TargetInfo *Value) { AuxTarget = Value; }
106
107	bool CompilerInstance::createTarget() {
108	// Create the target instance.
109	setTarget(TargetInfo::CreateTargetInfo(Diags&: getDiagnostics(),
110	Opts: getInvocation().TargetOpts));
111	if (!hasTarget())
112	return false;
113
114	// Check whether AuxTarget exists, if not, then create TargetInfo for the
115	// other side of CUDA/OpenMP/SYCL compilation.
116	if (!getAuxTarget() &&
117	(getLangOpts().CUDA || getLangOpts().OpenMPIsTargetDevice ||
118	getLangOpts().SYCLIsDevice) &&
119	!getFrontendOpts().AuxTriple.empty()) {
120	auto TO = std::make_shared<TargetOptions>();
121	TO->Triple = llvm::Triple::normalize(Str: getFrontendOpts().AuxTriple);
122	if (getFrontendOpts().AuxTargetCPU)
123	TO->CPU = *getFrontendOpts().AuxTargetCPU;
124	if (getFrontendOpts().AuxTargetFeatures)
125	TO->FeaturesAsWritten = *getFrontendOpts().AuxTargetFeatures;
126	TO->HostTriple = getTarget().getTriple().str();
127	setAuxTarget(TargetInfo::CreateTargetInfo(Diags&: getDiagnostics(), Opts: TO));
128	}
129
130	if (!getTarget().hasStrictFP() && !getLangOpts().ExpStrictFP) {
131	if (getLangOpts().RoundingMath) {
132	getDiagnostics().Report(diag::warn_fe_backend_unsupported_fp_rounding);
133	getLangOpts().RoundingMath = false;
134	}
135	auto FPExc = getLangOpts().getFPExceptionMode();
136	if (FPExc != LangOptions::FPE_Default && FPExc != LangOptions::FPE_Ignore) {
137	getDiagnostics().Report(diag::warn_fe_backend_unsupported_fp_exceptions);
138	getLangOpts().setFPExceptionMode(LangOptions::FPE_Ignore);
139	}
140	// FIXME: can we disable FEnvAccess?
141	}
142
143	// We should do it here because target knows nothing about
144	// language options when it's being created.
145	if (getLangOpts().OpenCL &&
146	!getTarget().validateOpenCLTarget(Opts: getLangOpts(), Diags&: getDiagnostics()))
147	return false;
148
149	// Inform the target of the language options.
150	// FIXME: We shouldn't need to do this, the target should be immutable once
151	// created. This complexity should be lifted elsewhere.
152	getTarget().adjust(Diags&: getDiagnostics(), Opts&: getLangOpts());
153
154	if (auto *Aux = getAuxTarget())
155	getTarget().setAuxTarget(Aux);
156
157	return true;
158	}
159
160	llvm::vfs::FileSystem &CompilerInstance::getVirtualFileSystem() const {
161	return getFileManager().getVirtualFileSystem();
162	}
163
164	void CompilerInstance::setFileManager(FileManager *Value) {
165	FileMgr = Value;
166	}
167
168	void CompilerInstance::setSourceManager(SourceManager *Value) {
169	SourceMgr = Value;
170	}
171
172	void CompilerInstance::setPreprocessor(std::shared_ptr<Preprocessor> Value) {
173	PP = std::move(Value);
174	}
175
176	void CompilerInstance::setASTContext(ASTContext *Value) {
177	Context = Value;
178
179	if (Context && Consumer)
180	getASTConsumer().Initialize(Context&: getASTContext());
181	}
182
183	void CompilerInstance::setSema(Sema *S) {
184	TheSema.reset(p: S);
185	}
186
187	void CompilerInstance::setASTConsumer(std::unique_ptr<ASTConsumer> Value) {
188	Consumer = std::move(Value);
189
190	if (Context && Consumer)
191	getASTConsumer().Initialize(Context&: getASTContext());
192	}
193
194	void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
195	CompletionConsumer.reset(p: Value);
196	}
197
198	std::unique_ptr<Sema> CompilerInstance::takeSema() {
199	return std::move(TheSema);
200	}
201
202	IntrusiveRefCntPtr<ASTReader> CompilerInstance::getASTReader() const {
203	return TheASTReader;
204	}
205	void CompilerInstance::setASTReader(IntrusiveRefCntPtr<ASTReader> Reader) {
206	assert(ModuleCache.get() == &Reader->getModuleManager().getModuleCache() &&
207	"Expected ASTReader to use the same PCM cache");
208	TheASTReader = std::move(Reader);
209	}
210
211	std::shared_ptr<ModuleDependencyCollector>
212	CompilerInstance::getModuleDepCollector() const {
213	return ModuleDepCollector;
214	}
215
216	void CompilerInstance::setModuleDepCollector(
217	std::shared_ptr<ModuleDependencyCollector> Collector) {
218	ModuleDepCollector = std::move(Collector);
219	}
220
221	static void collectHeaderMaps(const HeaderSearch &HS,
222	std::shared_ptr<ModuleDependencyCollector> MDC) {
223	SmallVector<std::string, 4> HeaderMapFileNames;
224	HS.getHeaderMapFileNames(Names&: HeaderMapFileNames);
225	for (auto &Name : HeaderMapFileNames)
226	MDC->addFile(Filename: Name);
227	}
228
229	static void collectIncludePCH(CompilerInstance &CI,
230	std::shared_ptr<ModuleDependencyCollector> MDC) {
231	const PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
232	if (PPOpts.ImplicitPCHInclude.empty())
233	return;
234
235	StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
236	FileManager &FileMgr = CI.getFileManager();
237	auto PCHDir = FileMgr.getOptionalDirectoryRef(DirName: PCHInclude);
238	if (!PCHDir) {
239	MDC->addFile(Filename: PCHInclude);
240	return;
241	}
242
243	std::error_code EC;
244	SmallString<128> DirNative;
245	llvm::sys::path::native(path: PCHDir->getName(), result&: DirNative);
246	llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
247	SimpleASTReaderListener Validator(CI.getPreprocessor());
248	for (llvm::vfs::directory_iterator Dir = FS.dir_begin(Dir: DirNative, EC), DirEnd;
249	Dir != DirEnd && !EC; Dir.increment(EC)) {
250	// Check whether this is an AST file. ASTReader::isAcceptableASTFile is not
251	// used here since we're not interested in validating the PCH at this time,
252	// but only to check whether this is a file containing an AST.
253	if (!ASTReader::readASTFileControlBlock(
254	Filename: Dir->path(), FileMgr, ModuleCache: CI.getModuleCache(),
255	PCHContainerRdr: CI.getPCHContainerReader(),
256	/*FindModuleFileExtensions=*/false, Listener&: Validator,
257	/*ValidateDiagnosticOptions=*/false))
258	MDC->addFile(Filename: Dir->path());
259	}
260	}
261
262	static void collectVFSEntries(CompilerInstance &CI,
263	std::shared_ptr<ModuleDependencyCollector> MDC) {
264	if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
265	return;
266
267	// Collect all VFS found.
268	SmallVector<llvm::vfs::YAMLVFSEntry, 16> VFSEntries;
269	for (const std::string &VFSFile : CI.getHeaderSearchOpts().VFSOverlayFiles) {
270	llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
271	llvm::MemoryBuffer::getFile(Filename: VFSFile);
272	if (!Buffer)
273	return;
274	llvm::vfs::collectVFSFromYAML(Buffer: std::move(Buffer.get()),
275	/*DiagHandler*/ nullptr, YAMLFilePath: VFSFile, CollectedEntries&: VFSEntries);
276	}
277
278	for (auto &E : VFSEntries)
279	MDC->addFile(Filename: E.VPath, FileDst: E.RPath);
280	}
281
282	// Diagnostics
283	static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
284	const CodeGenOptions *CodeGenOpts,
285	DiagnosticsEngine &Diags) {
286	std::error_code EC;
287	std::unique_ptr<raw_ostream> StreamOwner;
288	raw_ostream *OS = &llvm::errs();
289	if (DiagOpts->DiagnosticLogFile != "-") {
290	// Create the output stream.
291	auto FileOS = std::make_unique<llvm::raw_fd_ostream>(
292	args&: DiagOpts->DiagnosticLogFile, args&: EC,
293	args: llvm::sys::fs::OF_Append | llvm::sys::fs::OF_TextWithCRLF);
294	if (EC) {
295	Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
296	<< DiagOpts->DiagnosticLogFile << EC.message();
297	} else {
298	FileOS->SetUnbuffered();
299	OS = FileOS.get();
300	StreamOwner = std::move(FileOS);
301	}
302	}
303
304	// Chain in the diagnostic client which will log the diagnostics.
305	auto Logger = std::make_unique<LogDiagnosticPrinter>(args&: *OS, args&: DiagOpts,
306	args: std::move(StreamOwner));
307	if (CodeGenOpts)
308	Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
309	if (Diags.ownsClient()) {
310	Diags.setClient(
311	client: new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger)));
312	} else {
313	Diags.setClient(
314	client: new ChainedDiagnosticConsumer(Diags.getClient(), std::move(Logger)));
315	}
316	}
317
318	static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
319	DiagnosticsEngine &Diags,
320	StringRef OutputFile) {
321	auto SerializedConsumer =
322	clang::serialized_diags::create(OutputFile, Diags: DiagOpts);
323
324	if (Diags.ownsClient()) {
325	Diags.setClient(client: new ChainedDiagnosticConsumer(
326	Diags.takeClient(), std::move(SerializedConsumer)));
327	} else {
328	Diags.setClient(client: new ChainedDiagnosticConsumer(
329	Diags.getClient(), std::move(SerializedConsumer)));
330	}
331	}
332
333	void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
334	bool ShouldOwnClient) {
335	Diagnostics = createDiagnostics(Opts: &getDiagnosticOpts(), Client,
336	ShouldOwnClient, CodeGenOpts: &getCodeGenOpts());
337	}
338
339	IntrusiveRefCntPtr<DiagnosticsEngine>
340	CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
341	DiagnosticConsumer *Client,
342	bool ShouldOwnClient,
343	const CodeGenOptions *CodeGenOpts) {
344	IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
345	IntrusiveRefCntPtr<DiagnosticsEngine>
346	Diags(new DiagnosticsEngine(DiagID, Opts));
347
348	// Create the diagnostic client for reporting errors or for
349	// implementing -verify.
350	if (Client) {
351	Diags->setClient(client: Client, ShouldOwnClient);
352	} else if (Opts->getFormat() == DiagnosticOptions::SARIF) {
353	Diags->setClient(client: new SARIFDiagnosticPrinter(llvm::errs(), Opts));
354	} else
355	Diags->setClient(client: new TextDiagnosticPrinter(llvm::errs(), Opts));
356
357	// Chain in -verify checker, if requested.
358	if (Opts->VerifyDiagnostics)
359	Diags->setClient(client: new VerifyDiagnosticConsumer(*Diags));
360
361	// Chain in -diagnostic-log-file dumper, if requested.
362	if (!Opts->DiagnosticLogFile.empty())
363	SetUpDiagnosticLog(DiagOpts: Opts, CodeGenOpts, Diags&: *Diags);
364
365	if (!Opts->DiagnosticSerializationFile.empty())
366	SetupSerializedDiagnostics(DiagOpts: Opts, Diags&: *Diags,
367	OutputFile: Opts->DiagnosticSerializationFile);
368
369	// Configure our handling of diagnostics.
370	ProcessWarningOptions(Diags&: *Diags, Opts: *Opts);
371
372	return Diags;
373	}
374
375	// File Manager
376
377	FileManager *CompilerInstance::createFileManager(
378	IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) {
379	if (!VFS)
380	VFS = FileMgr ? &FileMgr->getVirtualFileSystem()
381	: createVFSFromCompilerInvocation(CI: getInvocation(),
382	Diags&: getDiagnostics());
383	assert(VFS && "FileManager has no VFS?");
384	FileMgr = new FileManager(getFileSystemOpts(), std::move(VFS));
385	return FileMgr.get();
386	}
387
388	// Source Manager
389
390	void CompilerInstance::createSourceManager(FileManager &FileMgr) {
391	SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
392	}
393
394	// Initialize the remapping of files to alternative contents, e.g.,
395	// those specified through other files.
396	static void InitializeFileRemapping(DiagnosticsEngine &Diags,
397	SourceManager &SourceMgr,
398	FileManager &FileMgr,
399	const PreprocessorOptions &InitOpts) {
400	// Remap files in the source manager (with buffers).
401	for (const auto &RB : InitOpts.RemappedFileBuffers) {
402	// Create the file entry for the file that we're mapping from.
403	FileEntryRef FromFile =
404	FileMgr.getVirtualFileRef(Filename: RB.first, Size: RB.second->getBufferSize(), ModificationTime: 0);
405
406	// Override the contents of the "from" file with the contents of the
407	// "to" file. If the caller owns the buffers, then pass a MemoryBufferRef;
408	// otherwise, pass as a std::unique_ptr<MemoryBuffer> to transfer ownership
409	// to the SourceManager.
410	if (InitOpts.RetainRemappedFileBuffers)
411	SourceMgr.overrideFileContents(SourceFile: FromFile, Buffer: RB.second->getMemBufferRef());
412	else
413	SourceMgr.overrideFileContents(
414	SourceFile: FromFile, Buffer: std::unique_ptr<llvm::MemoryBuffer>(
415	const_cast<llvm::MemoryBuffer *>(RB.second)));
416	}
417
418	// Remap files in the source manager (with other files).
419	for (const auto &RF : InitOpts.RemappedFiles) {
420	// Find the file that we're mapping to.
421	OptionalFileEntryRef ToFile = FileMgr.getOptionalFileRef(Filename: RF.second);
422	if (!ToFile) {
423	Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;
424	continue;
425	}
426
427	// Create the file entry for the file that we're mapping from.
428	const FileEntry *FromFile =
429	FileMgr.getVirtualFile(Filename: RF.first, Size: ToFile->getSize(), ModificationTime: 0);
430	if (!FromFile) {
431	Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first;
432	continue;
433	}
434
435	// Override the contents of the "from" file with the contents of
436	// the "to" file.
437	SourceMgr.overrideFileContents(SourceFile: FromFile, NewFile: *ToFile);
438	}
439
440	SourceMgr.setOverridenFilesKeepOriginalName(
441	InitOpts.RemappedFilesKeepOriginalName);
442	}
443
444	// Preprocessor
445
446	void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
447	const PreprocessorOptions &PPOpts = getPreprocessorOpts();
448
449	// The AST reader holds a reference to the old preprocessor (if any).
450	TheASTReader.reset();
451
452	// Create the Preprocessor.
453	HeaderSearch *HeaderInfo =
454	new HeaderSearch(getHeaderSearchOptsPtr(), getSourceManager(),
455	getDiagnostics(), getLangOpts(), &getTarget());
456	PP = std::make_shared<Preprocessor>(args: Invocation->getPreprocessorOptsPtr(),
457	args&: getDiagnostics(), args&: getLangOpts(),
458	args&: getSourceManager(), args&: *HeaderInfo, args&: *this,
459	/*IdentifierInfoLookup=*/args: nullptr,
460	/*OwnsHeaderSearch=*/args: true, args&: TUKind);
461	getTarget().adjust(Diags&: getDiagnostics(), Opts&: getLangOpts());
462	PP->Initialize(Target: getTarget(), AuxTarget: getAuxTarget());
463
464	if (PPOpts.DetailedRecord)
465	PP->createPreprocessingRecord();
466
467	// Apply remappings to the source manager.
468	InitializeFileRemapping(Diags&: PP->getDiagnostics(), SourceMgr&: PP->getSourceManager(),
469	FileMgr&: PP->getFileManager(), InitOpts: PPOpts);
470
471	// Predefine macros and configure the preprocessor.
472	InitializePreprocessor(PP&: *PP, PPOpts, PCHContainerRdr: getPCHContainerReader(),
473	FEOpts: getFrontendOpts(), CodeGenOpts: getCodeGenOpts());
474
475	// Initialize the header search object. In CUDA compilations, we use the aux
476	// triple (the host triple) to initialize our header search, since we need to
477	// find the host headers in order to compile the CUDA code.
478	const llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple();
479	if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA &&
480	PP->getAuxTargetInfo())
481	HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple();
482
483	ApplyHeaderSearchOptions(HS&: PP->getHeaderSearchInfo(), HSOpts: getHeaderSearchOpts(),
484	Lang: PP->getLangOpts(), triple: *HeaderSearchTriple);
485
486	PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
487
488	if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules) {
489	std::string ModuleHash = getInvocation().getModuleHash();
490	PP->getHeaderSearchInfo().setModuleHash(ModuleHash);
491	PP->getHeaderSearchInfo().setModuleCachePath(
492	getSpecificModuleCachePath(ModuleHash));
493	}
494
495	// Handle generating dependencies, if requested.
496	const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
497	if (!DepOpts.OutputFile.empty())
498	addDependencyCollector(Listener: std::make_shared<DependencyFileGenerator>(args: DepOpts));
499	if (!DepOpts.DOTOutputFile.empty())
500	AttachDependencyGraphGen(PP&: *PP, OutputFile: DepOpts.DOTOutputFile,
501	SysRoot: getHeaderSearchOpts().Sysroot);
502
503	// If we don't have a collector, but we are collecting module dependencies,
504	// then we're the top level compiler instance and need to create one.
505	if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty()) {
506	ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(
507	args: DepOpts.ModuleDependencyOutputDir);
508	}
509
510	// If there is a module dep collector, register with other dep collectors
511	// and also (a) collect header maps and (b) TODO: input vfs overlay files.
512	if (ModuleDepCollector) {
513	addDependencyCollector(Listener: ModuleDepCollector);
514	collectHeaderMaps(HS: PP->getHeaderSearchInfo(), MDC: ModuleDepCollector);
515	collectIncludePCH(CI&: *this, MDC: ModuleDepCollector);
516	collectVFSEntries(CI&: *this, MDC: ModuleDepCollector);
517	}
518
519	for (auto &Listener : DependencyCollectors)
520	Listener->attachToPreprocessor(PP&: *PP);
521
522	// Handle generating header include information, if requested.
523	if (DepOpts.ShowHeaderIncludes)
524	AttachHeaderIncludeGen(PP&: *PP, DepOpts);
525	if (!DepOpts.HeaderIncludeOutputFile.empty()) {
526	StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
527	if (OutputPath == "-")
528	OutputPath = "";
529	AttachHeaderIncludeGen(PP&: *PP, DepOpts,
530	/*ShowAllHeaders=*/true, OutputPath,
531	/*ShowDepth=*/false);
532	}
533
534	if (DepOpts.ShowIncludesDest != ShowIncludesDestination::None) {
535	AttachHeaderIncludeGen(PP&: *PP, DepOpts,
536	/*ShowAllHeaders=*/true, /*OutputPath=*/"",
537	/*ShowDepth=*/true, /*MSStyle=*/true);
538	}
539	}
540
541	std::string CompilerInstance::getSpecificModuleCachePath(StringRef ModuleHash) {
542	// Set up the module path, including the hash for the module-creation options.
543	SmallString<256> SpecificModuleCache(getHeaderSearchOpts().ModuleCachePath);
544	if (!SpecificModuleCache.empty() && !getHeaderSearchOpts().DisableModuleHash)
545	llvm::sys::path::append(path&: SpecificModuleCache, a: ModuleHash);
546	return std::string(SpecificModuleCache);
547	}
548
549	// ASTContext
550
551	void CompilerInstance::createASTContext() {
552	Preprocessor &PP = getPreprocessor();
553	auto *Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
554	PP.getIdentifierTable(), PP.getSelectorTable(),
555	PP.getBuiltinInfo(), PP.TUKind);
556	Context->InitBuiltinTypes(Target: getTarget(), AuxTarget: getAuxTarget());
557	setASTContext(Context);
558	}
559
560	// ExternalASTSource
561
562	namespace {
563	// Helper to recursively read the module names for all modules we're adding.
564	// We mark these as known and redirect any attempt to load that module to
565	// the files we were handed.
566	struct ReadModuleNames : ASTReaderListener {
567	Preprocessor &PP;
568	llvm::SmallVector<std::string, 8> LoadedModules;
569
570	ReadModuleNames(Preprocessor &PP) : PP(PP) {}
571
572	void ReadModuleName(StringRef ModuleName) override {
573	// Keep the module name as a string for now. It's not safe to create a new
574	// IdentifierInfo from an ASTReader callback.
575	LoadedModules.push_back(Elt: ModuleName.str());
576	}
577
578	void registerAll() {
579	ModuleMap &MM = PP.getHeaderSearchInfo().getModuleMap();
580	for (const std::string &LoadedModule : LoadedModules)
581	MM.cacheModuleLoad(II: *PP.getIdentifierInfo(Name: LoadedModule),
582	M: MM.findModule(Name: LoadedModule));
583	LoadedModules.clear();
584	}
585
586	void markAllUnavailable() {
587	for (const std::string &LoadedModule : LoadedModules) {
588	if (Module *M = PP.getHeaderSearchInfo().getModuleMap().findModule(
589	Name: LoadedModule)) {
590	M->HasIncompatibleModuleFile = true;
591
592	// Mark module as available if the only reason it was unavailable
593	// was missing headers.
594	SmallVector<Module *, 2> Stack;
595	Stack.push_back(Elt: M);
596	while (!Stack.empty()) {
597	Module *Current = Stack.pop_back_val();
598	if (Current->IsUnimportable) continue;
599	Current->IsAvailable = true;
600	auto SubmodulesRange = Current->submodules();
601	Stack.insert(I: Stack.end(), From: SubmodulesRange.begin(),
602	To: SubmodulesRange.end());
603	}
604	}
605	}
606	LoadedModules.clear();
607	}
608	};
609	} // namespace
610
611	void CompilerInstance::createPCHExternalASTSource(
612	StringRef Path, DisableValidationForModuleKind DisableValidation,
613	bool AllowPCHWithCompilerErrors, void *DeserializationListener,
614	bool OwnDeserializationListener) {
615	bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
616	TheASTReader = createPCHExternalASTSource(
617	Path, Sysroot: getHeaderSearchOpts().Sysroot, DisableValidation,
618	AllowPCHWithCompilerErrors, PP&: getPreprocessor(), ModuleCache&: getModuleCache(),
619	Context&: getASTContext(), PCHContainerRdr: getPCHContainerReader(),
620	Extensions: getFrontendOpts().ModuleFileExtensions, DependencyCollectors,
621	DeserializationListener, OwnDeserializationListener, Preamble,
622	UseGlobalModuleIndex: getFrontendOpts().UseGlobalModuleIndex);
623	}
624
625	IntrusiveRefCntPtr<ASTReader> CompilerInstance::createPCHExternalASTSource(
626	StringRef Path, StringRef Sysroot,
627	DisableValidationForModuleKind DisableValidation,
628	bool AllowPCHWithCompilerErrors, Preprocessor &PP,
629	InMemoryModuleCache &ModuleCache, ASTContext &Context,
630	const PCHContainerReader &PCHContainerRdr,
631	ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
632	ArrayRef<std::shared_ptr<DependencyCollector>> DependencyCollectors,
633	void *DeserializationListener, bool OwnDeserializationListener,
634	bool Preamble, bool UseGlobalModuleIndex) {
635	HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
636
637	IntrusiveRefCntPtr<ASTReader> Reader(new ASTReader(
638	PP, ModuleCache, &Context, PCHContainerRdr, Extensions,
639	Sysroot.empty() ? "" : Sysroot.data(), DisableValidation,
640	AllowPCHWithCompilerErrors, /*AllowConfigurationMismatch*/ false,
641	HSOpts.ModulesValidateSystemHeaders, HSOpts.ValidateASTInputFilesContent,
642	UseGlobalModuleIndex));
643
644	// We need the external source to be set up before we read the AST, because
645	// eagerly-deserialized declarations may use it.
646	Context.setExternalSource(Reader.get());
647
648	Reader->setDeserializationListener(
649	Listener: static_cast<ASTDeserializationListener *>(DeserializationListener),
650	/*TakeOwnership=*/OwnDeserializationListener);
651
652	for (auto &Listener : DependencyCollectors)
653	Listener->attachToASTReader(R&: *Reader);
654
655	auto Listener = std::make_unique<ReadModuleNames>(args&: PP);
656	auto &ListenerRef = *Listener;
657	ASTReader::ListenerScope ReadModuleNamesListener(*Reader,
658	std::move(Listener));
659
660	switch (Reader->ReadAST(FileName: Path,
661	Type: Preamble ? serialization::MK_Preamble
662	: serialization::MK_PCH,
663	ImportLoc: SourceLocation(),
664	ClientLoadCapabilities: ASTReader::ARR_None)) {
665	case ASTReader::Success:
666	// Set the predefines buffer as suggested by the PCH reader. Typically, the
667	// predefines buffer will be empty.
668	PP.setPredefines(Reader->getSuggestedPredefines());
669	ListenerRef.registerAll();
670	return Reader;
671
672	case ASTReader::Failure:
673	// Unrecoverable failure: don't even try to process the input file.
674	break;
675
676	case ASTReader::Missing:
677	case ASTReader::OutOfDate:
678	case ASTReader::VersionMismatch:
679	case ASTReader::ConfigurationMismatch:
680	case ASTReader::HadErrors:
681	// No suitable PCH file could be found. Return an error.
682	break;
683	}
684
685	ListenerRef.markAllUnavailable();
686	Context.setExternalSource(nullptr);
687	return nullptr;
688	}
689
690	// Code Completion
691
692	static bool EnableCodeCompletion(Preprocessor &PP,
693	StringRef Filename,
694	unsigned Line,
695	unsigned Column) {
696	// Tell the source manager to chop off the given file at a specific
697	// line and column.
698	auto Entry = PP.getFileManager().getOptionalFileRef(Filename);
699	if (!Entry) {
700	PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
701	<< Filename;
702	return true;
703	}
704
705	// Truncate the named file at the given line/column.
706	PP.SetCodeCompletionPoint(File: *Entry, Line, Column);
707	return false;
708	}
709
710	void CompilerInstance::createCodeCompletionConsumer() {
711	const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
712	if (!CompletionConsumer) {
713	setCodeCompletionConsumer(createCodeCompletionConsumer(
714	PP&: getPreprocessor(), Filename: Loc.FileName, Line: Loc.Line, Column: Loc.Column,
715	Opts: getFrontendOpts().CodeCompleteOpts, OS&: llvm::outs()));
716	return;
717	} else if (EnableCodeCompletion(PP&: getPreprocessor(), Filename: Loc.FileName,
718	Line: Loc.Line, Column: Loc.Column)) {
719	setCodeCompletionConsumer(nullptr);
720	return;
721	}
722	}
723
724	void CompilerInstance::createFrontendTimer() {
725	FrontendTimerGroup.reset(
726	p: new llvm::TimerGroup("frontend", "Clang front-end time report"));
727	FrontendTimer.reset(
728	p: new llvm::Timer("frontend", "Clang front-end timer",
729	*FrontendTimerGroup));
730	}
731
732	CodeCompleteConsumer *
733	CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
734	StringRef Filename,
735	unsigned Line,
736	unsigned Column,
737	const CodeCompleteOptions &Opts,
738	raw_ostream &OS) {
739	if (EnableCodeCompletion(PP, Filename, Line, Column))
740	return nullptr;
741
742	// Set up the creation routine for code-completion.
743	return new PrintingCodeCompleteConsumer(Opts, OS);
744	}
745
746	void CompilerInstance::createSema(TranslationUnitKind TUKind,
747	CodeCompleteConsumer *CompletionConsumer) {
748	TheSema.reset(p: new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
749	TUKind, CompletionConsumer));
750
751	// Set up API notes.
752	TheSema->APINotes.setSwiftVersion(getAPINotesOpts().SwiftVersion);
753
754	// Attach the external sema source if there is any.
755	if (ExternalSemaSrc) {
756	TheSema->addExternalSource(E: ExternalSemaSrc.get());
757	ExternalSemaSrc->InitializeSema(S&: *TheSema);
758	}
759
760	// If we're building a module and are supposed to load API notes,
761	// notify the API notes manager.
762	if (auto *currentModule = getPreprocessor().getCurrentModule()) {
763	(void)TheSema->APINotes.loadCurrentModuleAPINotes(
764	M: currentModule, LookInModule: getLangOpts().APINotesModules,
765	SearchPaths: getAPINotesOpts().ModuleSearchPaths);
766	}
767	}
768
769	// Output Files
770
771	void CompilerInstance::clearOutputFiles(bool EraseFiles) {
772	// The ASTConsumer can own streams that write to the output files.
773	assert(!hasASTConsumer() && "ASTConsumer should be reset");
774	// Ignore errors that occur when trying to discard the temp file.
775	for (OutputFile &OF : OutputFiles) {
776	if (EraseFiles) {
777	if (OF.File)
778	consumeError(Err: OF.File->discard());
779	if (!OF.Filename.empty())
780	llvm::sys::fs::remove(path: OF.Filename);
781	continue;
782	}
783
784	if (!OF.File)
785	continue;
786
787	if (OF.File->TmpName.empty()) {
788	consumeError(Err: OF.File->discard());
789	continue;
790	}
791
792	llvm::Error E = OF.File->keep(Name: OF.Filename);
793	if (!E)
794	continue;
795
796	getDiagnostics().Report(diag::err_unable_to_rename_temp)
797	<< OF.File->TmpName << OF.Filename << std::move(E);
798
799	llvm::sys::fs::remove(path: OF.File->TmpName);
800	}
801	OutputFiles.clear();
802	if (DeleteBuiltModules) {
803	for (auto &Module : BuiltModules)
804	llvm::sys::fs::remove(path: Module.second);
805	BuiltModules.clear();
806	}
807	}
808
809	std::unique_ptr<raw_pwrite_stream> CompilerInstance::createDefaultOutputFile(
810	bool Binary, StringRef InFile, StringRef Extension, bool RemoveFileOnSignal,
811	bool CreateMissingDirectories, bool ForceUseTemporary) {
812	StringRef OutputPath = getFrontendOpts().OutputFile;
813	std::optional<SmallString<128>> PathStorage;
814	if (OutputPath.empty()) {
815	if (InFile == "-" || Extension.empty()) {
816	OutputPath = "-";
817	} else {
818	PathStorage.emplace(args&: InFile);
819	llvm::sys::path::replace_extension(path&: *PathStorage, extension: Extension);
820	OutputPath = *PathStorage;
821	}
822	}
823
824	return createOutputFile(OutputPath, Binary, RemoveFileOnSignal,
825	UseTemporary: getFrontendOpts().UseTemporary || ForceUseTemporary,
826	CreateMissingDirectories);
827	}
828
829	std::unique_ptr<raw_pwrite_stream> CompilerInstance::createNullOutputFile() {
830	return std::make_unique<llvm::raw_null_ostream>();
831	}
832
833	std::unique_ptr<raw_pwrite_stream>
834	CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary,
835	bool RemoveFileOnSignal, bool UseTemporary,
836	bool CreateMissingDirectories) {
837	Expected<std::unique_ptr<raw_pwrite_stream>> OS =
838	createOutputFileImpl(OutputPath, Binary, RemoveFileOnSignal, UseTemporary,
839	CreateMissingDirectories);
840	if (OS)
841	return std::move(*OS);
842	getDiagnostics().Report(diag::err_fe_unable_to_open_output)
843	<< OutputPath << errorToErrorCode(OS.takeError()).message();
844	return nullptr;
845	}
846
847	Expected<std::unique_ptr<llvm::raw_pwrite_stream>>
848	CompilerInstance::createOutputFileImpl(StringRef OutputPath, bool Binary,
849	bool RemoveFileOnSignal,
850	bool UseTemporary,
851	bool CreateMissingDirectories) {
852	assert((!CreateMissingDirectories || UseTemporary) &&
853	"CreateMissingDirectories is only allowed when using temporary files");
854
855	// If '-working-directory' was passed, the output filename should be
856	// relative to that.
857	std::optional<SmallString<128>> AbsPath;
858	if (OutputPath != "-" && !llvm::sys::path::is_absolute(path: OutputPath)) {
859	assert(hasFileManager() &&
860	"File Manager is required to fix up relative path.\n");
861
862	AbsPath.emplace(args&: OutputPath);
863	FileMgr->FixupRelativePath(path&: *AbsPath);
864	OutputPath = *AbsPath;
865	}
866
867	std::unique_ptr<llvm::raw_fd_ostream> OS;
868	std::optional<StringRef> OSFile;
869
870	if (UseTemporary) {
871	if (OutputPath == "-")
872	UseTemporary = false;
873	else {
874	llvm::sys::fs::file_status Status;
875	llvm::sys::fs::status(path: OutputPath, result&: Status);
876	if (llvm::sys::fs::exists(status: Status)) {
877	// Fail early if we can't write to the final destination.
878	if (!llvm::sys::fs::can_write(Path: OutputPath))
879	return llvm::errorCodeToError(
880	EC: make_error_code(E: llvm::errc::operation_not_permitted));
881
882	// Don't use a temporary if the output is a special file. This handles
883	// things like '-o /dev/null'
884	if (!llvm::sys::fs::is_regular_file(status: Status))
885	UseTemporary = false;
886	}
887	}
888	}
889
890	std::optional<llvm::sys::fs::TempFile> Temp;
891	if (UseTemporary) {
892	// Create a temporary file.
893	// Insert -%%%%%%%% before the extension (if any), and because some tools
894	// (noticeable, clang's own GlobalModuleIndex.cpp) glob for build
895	// artifacts, also append .tmp.
896	StringRef OutputExtension = llvm::sys::path::extension(path: OutputPath);
897	SmallString<128> TempPath =
898	StringRef(OutputPath).drop_back(N: OutputExtension.size());
899	TempPath += "-%%%%%%%%";
900	TempPath += OutputExtension;
901	TempPath += ".tmp";
902	llvm::sys::fs::OpenFlags BinaryFlags =
903	Binary ? llvm::sys::fs::OF_None : llvm::sys::fs::OF_Text;
904	Expected<llvm::sys::fs::TempFile> ExpectedFile =
905	llvm::sys::fs::TempFile::create(
906	Model: TempPath, Mode: llvm::sys::fs::all_read | llvm::sys::fs::all_write,
907	ExtraFlags: BinaryFlags);
908
909	llvm::Error E = handleErrors(
910	E: ExpectedFile.takeError(), Hs: [&](const llvm::ECError &E) -> llvm::Error {
911	std::error_code EC = E.convertToErrorCode();
912	if (CreateMissingDirectories &&
913	EC == llvm::errc::no_such_file_or_directory) {
914	StringRef Parent = llvm::sys::path::parent_path(path: OutputPath);
915	EC = llvm::sys::fs::create_directories(path: Parent);
916	if (!EC) {
917	ExpectedFile = llvm::sys::fs::TempFile::create(
918	Model: TempPath, Mode: llvm::sys::fs::all_read | llvm::sys::fs::all_write,
919	ExtraFlags: BinaryFlags);
920	if (!ExpectedFile)
921	return llvm::errorCodeToError(
922	EC: llvm::errc::no_such_file_or_directory);
923	}
924	}
925	return llvm::errorCodeToError(EC);
926	});
927
928	if (E) {
929	consumeError(Err: std::move(E));
930	} else {
931	Temp = std::move(ExpectedFile.get());
932	OS.reset(p: new llvm::raw_fd_ostream(Temp->FD, /*shouldClose=*/false));
933	OSFile = Temp->TmpName;
934	}
935	// If we failed to create the temporary, fallback to writing to the file
936	// directly. This handles the corner case where we cannot write to the
937	// directory, but can write to the file.
938	}
939
940	if (!OS) {
941	OSFile = OutputPath;
942	std::error_code EC;
943	OS.reset(p: new llvm::raw_fd_ostream(
944	*OSFile, EC,
945	(Binary ? llvm::sys::fs::OF_None : llvm::sys::fs::OF_TextWithCRLF)));
946	if (EC)
947	return llvm::errorCodeToError(EC);
948	}
949
950	// Add the output file -- but don't try to remove "-", since this means we are
951	// using stdin.
952	OutputFiles.emplace_back(args: ((OutputPath != "-") ? OutputPath : "").str(),
953	args: std::move(Temp));
954
955	if (!Binary || OS->supportsSeeking())
956	return std::move(OS);
957
958	return std::make_unique<llvm::buffer_unique_ostream>(args: std::move(OS));
959	}
960
961	// Initialization Utilities
962
963	bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
964	return InitializeSourceManager(Input, Diags&: getDiagnostics(), FileMgr&: getFileManager(),
965	SourceMgr&: getSourceManager());
966	}
967
968	// static
969	bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input,
970	DiagnosticsEngine &Diags,
971	FileManager &FileMgr,
972	SourceManager &SourceMgr) {
973	SrcMgr::CharacteristicKind Kind =
974	Input.getKind().getFormat() == InputKind::ModuleMap
975	? Input.isSystem() ? SrcMgr::C_System_ModuleMap
976	: SrcMgr::C_User_ModuleMap
977	: Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
978
979	if (Input.isBuffer()) {
980	SourceMgr.setMainFileID(SourceMgr.createFileID(Buffer: Input.getBuffer(), FileCharacter: Kind));
981	assert(SourceMgr.getMainFileID().isValid() &&
982	"Couldn't establish MainFileID!");
983	return true;
984	}
985
986	StringRef InputFile = Input.getFile();
987
988	// Figure out where to get and map in the main file.
989	auto FileOrErr = InputFile == "-"
990	? FileMgr.getSTDIN()
991	: FileMgr.getFileRef(Filename: InputFile, /*OpenFile=*/true);
992	if (!FileOrErr) {
993	auto EC = llvm::errorToErrorCode(Err: FileOrErr.takeError());
994	if (InputFile != "-")
995	Diags.Report(diag::err_fe_error_reading) << InputFile << EC.message();
996	else
997	Diags.Report(diag::err_fe_error_reading_stdin) << EC.message();
998	return false;
999	}
1000
1001	SourceMgr.setMainFileID(
1002	SourceMgr.createFileID(SourceFile: *FileOrErr, IncludePos: SourceLocation(), FileCharacter: Kind));
1003
1004	assert(SourceMgr.getMainFileID().isValid() &&
1005	"Couldn't establish MainFileID!");
1006	return true;
1007	}
1008
1009	// High-Level Operations
1010
1011	bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
1012	assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
1013	assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
1014	assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
1015
1016	// Mark this point as the bottom of the stack if we don't have somewhere
1017	// better. We generally expect frontend actions to be invoked with (nearly)
1018	// DesiredStackSpace available.
1019	noteBottomOfStack();
1020
1021	auto FinishDiagnosticClient = llvm::make_scope_exit(F: [&]() {
1022	// Notify the diagnostic client that all files were processed.
1023	getDiagnosticClient().finish();
1024	});
1025
1026	raw_ostream &OS = getVerboseOutputStream();
1027
1028	if (!Act.PrepareToExecute(CI&: *this))
1029	return false;
1030
1031	if (!createTarget())
1032	return false;
1033
1034	// rewriter project will change target built-in bool type from its default.
1035	if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
1036	getTarget().noSignedCharForObjCBool();
1037
1038	// Validate/process some options.
1039	if (getHeaderSearchOpts().Verbose)
1040	OS << "clang -cc1 version " CLANG_VERSION_STRING << " based upon LLVM "
1041	<< LLVM_VERSION_STRING << " default target "
1042	<< llvm::sys::getDefaultTargetTriple() << "\n";
1043
1044	if (getCodeGenOpts().TimePasses)
1045	createFrontendTimer();
1046
1047	if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty())
1048	llvm::EnableStatistics(DoPrintOnExit: false);
1049
1050	// Sort vectors containing toc data and no toc data variables to facilitate
1051	// binary search later.
1052	llvm::sort(C&: getCodeGenOpts().TocDataVarsUserSpecified);
1053	llvm::sort(C&: getCodeGenOpts().NoTocDataVars);
1054
1055	for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) {
1056	// Reset the ID tables if we are reusing the SourceManager and parsing
1057	// regular files.
1058	if (hasSourceManager() && !Act.isModelParsingAction())
1059	getSourceManager().clearIDTables();
1060
1061	if (Act.BeginSourceFile(CI&: *this, Input: FIF)) {
1062	if (llvm::Error Err = Act.Execute()) {
1063	consumeError(Err: std::move(Err)); // FIXME this drops errors on the floor.
1064	}
1065	Act.EndSourceFile();
1066	}
1067	}
1068
1069	printDiagnosticStats();
1070
1071	if (getFrontendOpts().ShowStats) {
1072	if (hasFileManager()) {
1073	getFileManager().PrintStats();
1074	OS << '\n';
1075	}
1076	llvm::PrintStatistics(OS);
1077	}
1078	StringRef StatsFile = getFrontendOpts().StatsFile;
1079	if (!StatsFile.empty()) {
1080	llvm::sys::fs::OpenFlags FileFlags = llvm::sys::fs::OF_TextWithCRLF;
1081	if (getFrontendOpts().AppendStats)
1082	FileFlags |= llvm::sys::fs::OF_Append;
1083	std::error_code EC;
1084	auto StatS =
1085	std::make_unique<llvm::raw_fd_ostream>(args&: StatsFile, args&: EC, args&: FileFlags);
1086	if (EC) {
1087	getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file)
1088	<< StatsFile << EC.message();
1089	} else {
1090	llvm::PrintStatisticsJSON(OS&: *StatS);
1091	}
1092	}
1093
1094	return !getDiagnostics().getClient()->getNumErrors();
1095	}
1096
1097	void CompilerInstance::printDiagnosticStats() {
1098	if (!getDiagnosticOpts().ShowCarets)
1099	return;
1100
1101	raw_ostream &OS = getVerboseOutputStream();
1102
1103	// We can have multiple diagnostics sharing one diagnostic client.
1104	// Get the total number of warnings/errors from the client.
1105	unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
1106	unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
1107
1108	if (NumWarnings)
1109	OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
1110	if (NumWarnings && NumErrors)
1111	OS << " and ";
1112	if (NumErrors)
1113	OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
1114	if (NumWarnings || NumErrors) {
1115	OS << " generated";
1116	if (getLangOpts().CUDA) {
1117	if (!getLangOpts().CUDAIsDevice) {
1118	OS << " when compiling for host";
1119	} else {
1120	OS << " when compiling for " << getTargetOpts().CPU;
1121	}
1122	}
1123	OS << ".\n";
1124	}
1125	}
1126
1127	void CompilerInstance::LoadRequestedPlugins() {
1128	// Load any requested plugins.
1129	for (const std::string &Path : getFrontendOpts().Plugins) {
1130	std::string Error;
1131	if (llvm::sys::DynamicLibrary::LoadLibraryPermanently(Path.c_str(), &Error))
1132	getDiagnostics().Report(diag::err_fe_unable_to_load_plugin)
1133	<< Path << Error;
1134	}
1135
1136	// Check if any of the loaded plugins replaces the main AST action
1137	for (const FrontendPluginRegistry::entry &Plugin :
1138	FrontendPluginRegistry::entries()) {
1139	std::unique_ptr<PluginASTAction> P(Plugin.instantiate());
1140	if (P->getActionType() == PluginASTAction::ReplaceAction) {
1141	getFrontendOpts().ProgramAction = clang::frontend::PluginAction;
1142	getFrontendOpts().ActionName = Plugin.getName().str();
1143	break;
1144	}
1145	}
1146	}
1147
1148	/// Determine the appropriate source input kind based on language
1149	/// options.
1150	static Language getLanguageFromOptions(const LangOptions &LangOpts) {
1151	if (LangOpts.OpenCL)
1152	return Language::OpenCL;
1153	if (LangOpts.CUDA)
1154	return Language::CUDA;
1155	if (LangOpts.ObjC)
1156	return LangOpts.CPlusPlus ? Language::ObjCXX : Language::ObjC;
1157	return LangOpts.CPlusPlus ? Language::CXX : Language::C;
1158	}
1159
1160	/// Compile a module file for the given module, using the options
1161	/// provided by the importing compiler instance. Returns true if the module
1162	/// was built without errors.
1163	static bool
1164	compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
1165	StringRef ModuleName, FrontendInputFile Input,
1166	StringRef OriginalModuleMapFile, StringRef ModuleFileName,
1167	llvm::function_ref<void(CompilerInstance &)> PreBuildStep =
1168	[](CompilerInstance &) {},
1169	llvm::function_ref<void(CompilerInstance &)> PostBuildStep =
1170	[](CompilerInstance &) {}) {
1171	llvm::TimeTraceScope TimeScope("Module Compile", ModuleName);
1172
1173	// Never compile a module that's already finalized - this would cause the
1174	// existing module to be freed, causing crashes if it is later referenced
1175	if (ImportingInstance.getModuleCache().isPCMFinal(Filename: ModuleFileName)) {
1176	ImportingInstance.getDiagnostics().Report(
1177	ImportLoc, diag::err_module_rebuild_finalized)
1178	<< ModuleName;
1179	return false;
1180	}
1181
1182	// Construct a compiler invocation for creating this module.
1183	auto Invocation =
1184	std::make_shared<CompilerInvocation>(args&: ImportingInstance.getInvocation());
1185
1186	PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1187
1188	// For any options that aren't intended to affect how a module is built,
1189	// reset them to their default values.
1190	Invocation->resetNonModularOptions();
1191
1192	// Remove any macro definitions that are explicitly ignored by the module.
1193	// They aren't supposed to affect how the module is built anyway.
1194	HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
1195	llvm::erase_if(C&: PPOpts.Macros,
1196	P: [&HSOpts](const std::pair<std::string, bool> &def) {
1197	StringRef MacroDef = def.first;
1198	return HSOpts.ModulesIgnoreMacros.contains(
1199	key: llvm::CachedHashString(MacroDef.split(Separator: '=').first));
1200	});
1201
1202	// If the original compiler invocation had -fmodule-name, pass it through.
1203	Invocation->getLangOpts().ModuleName =
1204	ImportingInstance.getInvocation().getLangOpts().ModuleName;
1205
1206	// Note the name of the module we're building.
1207	Invocation->getLangOpts().CurrentModule = std::string(ModuleName);
1208
1209	// If there is a module map file, build the module using the module map.
1210	// Set up the inputs/outputs so that we build the module from its umbrella
1211	// header.
1212	FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
1213	FrontendOpts.OutputFile = ModuleFileName.str();
1214	FrontendOpts.DisableFree = false;
1215	FrontendOpts.GenerateGlobalModuleIndex = false;
1216	FrontendOpts.BuildingImplicitModule = true;
1217	FrontendOpts.OriginalModuleMap = std::string(OriginalModuleMapFile);
1218	// Force implicitly-built modules to hash the content of the module file.
1219	HSOpts.ModulesHashContent = true;
1220	FrontendOpts.Inputs = {Input};
1221
1222	// Don't free the remapped file buffers; they are owned by our caller.
1223	PPOpts.RetainRemappedFileBuffers = true;
1224
1225	DiagnosticOptions &DiagOpts = Invocation->getDiagnosticOpts();
1226
1227	DiagOpts.VerifyDiagnostics = 0;
1228	assert(ImportingInstance.getInvocation().getModuleHash() ==
1229	Invocation->getModuleHash() && "Module hash mismatch!");
1230
1231	// Construct a compiler instance that will be used to actually create the
1232	// module. Since we're sharing an in-memory module cache,
1233	// CompilerInstance::CompilerInstance is responsible for finalizing the
1234	// buffers to prevent use-after-frees.
1235	CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
1236	&ImportingInstance.getModuleCache());
1237	auto &Inv = *Invocation;
1238	Instance.setInvocation(std::move(Invocation));
1239
1240	Instance.createDiagnostics(Client: new ForwardingDiagnosticConsumer(
1241	ImportingInstance.getDiagnosticClient()),
1242	/*ShouldOwnClient=*/true);
1243
1244	if (llvm::is_contained(Range&: DiagOpts.SystemHeaderWarningsModules, Element: ModuleName))
1245	Instance.getDiagnostics().setSuppressSystemWarnings(false);
1246
1247	if (FrontendOpts.ModulesShareFileManager) {
1248	Instance.setFileManager(&ImportingInstance.getFileManager());
1249	} else {
1250	Instance.createFileManager(VFS: &ImportingInstance.getVirtualFileSystem());
1251	}
1252	Instance.createSourceManager(FileMgr&: Instance.getFileManager());
1253	SourceManager &SourceMgr = Instance.getSourceManager();
1254
1255	// Note that this module is part of the module build stack, so that we
1256	// can detect cycles in the module graph.
1257	SourceMgr.setModuleBuildStack(
1258	ImportingInstance.getSourceManager().getModuleBuildStack());
1259	SourceMgr.pushModuleBuildStack(moduleName: ModuleName,
1260	importLoc: FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
1261
1262	// Make sure that the failed-module structure has been allocated in
1263	// the importing instance, and propagate the pointer to the newly-created
1264	// instance.
1265	if (!ImportingInstance.hasFailedModulesSet())
1266	ImportingInstance.createFailedModulesSet();
1267	Instance.setFailedModulesSet(ImportingInstance.getFailedModulesSetPtr());
1268
1269	// If we're collecting module dependencies, we need to share a collector
1270	// between all of the module CompilerInstances. Other than that, we don't
1271	// want to produce any dependency output from the module build.
1272	Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
1273	Inv.getDependencyOutputOpts() = DependencyOutputOptions();
1274
1275	ImportingInstance.getDiagnostics().Report(ImportLoc,
1276	diag::remark_module_build)
1277	<< ModuleName << ModuleFileName;
1278
1279	PreBuildStep(Instance);
1280
1281	// Execute the action to actually build the module in-place. Use a separate
1282	// thread so that we get a stack large enough.
1283	bool Crashed = !llvm::CrashRecoveryContext().RunSafelyOnThread(
1284	[&]() {
1285	GenerateModuleFromModuleMapAction Action;
1286	Instance.ExecuteAction(Act&: Action);
1287	},
1288	RequestedStackSize: DesiredStackSize);
1289
1290	PostBuildStep(Instance);
1291
1292	ImportingInstance.getDiagnostics().Report(ImportLoc,
1293	diag::remark_module_build_done)
1294	<< ModuleName;
1295
1296	if (Crashed) {
1297	// Clear the ASTConsumer if it hasn't been already, in case it owns streams
1298	// that must be closed before clearing output files.
1299	Instance.setSema(nullptr);
1300	Instance.setASTConsumer(nullptr);
1301
1302	// Delete any remaining temporary files related to Instance.
1303	Instance.clearOutputFiles(/*EraseFiles=*/true);
1304	}
1305
1306	// If \p AllowPCMWithCompilerErrors is set return 'success' even if errors
1307	// occurred.
1308	return !Instance.getDiagnostics().hasErrorOccurred() ||
1309	Instance.getFrontendOpts().AllowPCMWithCompilerErrors;
1310	}
1311
1312	static OptionalFileEntryRef getPublicModuleMap(FileEntryRef File,
1313	FileManager &FileMgr) {
1314	StringRef Filename = llvm::sys::path::filename(path: File.getName());
1315	SmallString<128> PublicFilename(File.getDir().getName());
1316	if (Filename == "module_private.map")
1317	llvm::sys::path::append(path&: PublicFilename, a: "module.map");
1318	else if (Filename == "module.private.modulemap")
1319	llvm::sys::path::append(path&: PublicFilename, a: "module.modulemap");
1320	else
1321	return std::nullopt;
1322	return FileMgr.getOptionalFileRef(Filename: PublicFilename);
1323	}
1324
1325	/// Compile a module file for the given module in a separate compiler instance,
1326	/// using the options provided by the importing compiler instance. Returns true
1327	/// if the module was built without errors.
1328	static bool compileModule(CompilerInstance &ImportingInstance,
1329	SourceLocation ImportLoc, Module *Module,
1330	StringRef ModuleFileName) {
1331	InputKind IK(getLanguageFromOptions(LangOpts: ImportingInstance.getLangOpts()),
1332	InputKind::ModuleMap);
1333
1334	// Get or create the module map that we'll use to build this module.
1335	ModuleMap &ModMap
1336	= ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1337	SourceManager &SourceMgr = ImportingInstance.getSourceManager();
1338	bool Result;
1339	if (FileID ModuleMapFID = ModMap.getContainingModuleMapFileID(Module);
1340	ModuleMapFID.isValid()) {
1341	// We want to use the top-level module map. If we don't, the compiling
1342	// instance may think the containing module map is a top-level one, while
1343	// the importing instance knows it's included from a parent module map via
1344	// the extern directive. This mismatch could bite us later.
1345	SourceLocation Loc = SourceMgr.getIncludeLoc(FID: ModuleMapFID);
1346	while (Loc.isValid() && isModuleMap(CK: SourceMgr.getFileCharacteristic(Loc))) {
1347	ModuleMapFID = SourceMgr.getFileID(SpellingLoc: Loc);
1348	Loc = SourceMgr.getIncludeLoc(FID: ModuleMapFID);
1349	}
1350
1351	OptionalFileEntryRef ModuleMapFile =
1352	SourceMgr.getFileEntryRefForID(FID: ModuleMapFID);
1353	assert(ModuleMapFile && "Top-level module map with no FileID");
1354
1355	// Canonicalize compilation to start with the public module map. This is
1356	// vital for submodules declarations in the private module maps to be
1357	// correctly parsed when depending on a top level module in the public one.
1358	if (OptionalFileEntryRef PublicMMFile = getPublicModuleMap(
1359	File: *ModuleMapFile, FileMgr&: ImportingInstance.getFileManager()))
1360	ModuleMapFile = PublicMMFile;
1361
1362	StringRef ModuleMapFilePath = ModuleMapFile->getNameAsRequested();
1363
1364	// Use the module map where this module resides.
1365	Result = compileModuleImpl(
1366	ImportingInstance, ImportLoc, ModuleName: Module->getTopLevelModuleName(),
1367	Input: FrontendInputFile(ModuleMapFilePath, IK, +Module->IsSystem),
1368	OriginalModuleMapFile: ModMap.getModuleMapFileForUniquing(M: Module)->getName(), ModuleFileName);
1369	} else {
1370	// FIXME: We only need to fake up an input file here as a way of
1371	// transporting the module's directory to the module map parser. We should
1372	// be able to do that more directly, and parse from a memory buffer without
1373	// inventing this file.
1374	SmallString<128> FakeModuleMapFile(Module->Directory->getName());
1375	llvm::sys::path::append(path&: FakeModuleMapFile, a: "__inferred_module.map");
1376
1377	std::string InferredModuleMapContent;
1378	llvm::raw_string_ostream OS(InferredModuleMapContent);
1379	Module->print(OS);
1380	OS.flush();
1381
1382	Result = compileModuleImpl(
1383	ImportingInstance, ImportLoc, ModuleName: Module->getTopLevelModuleName(),
1384	Input: FrontendInputFile(FakeModuleMapFile, IK, +Module->IsSystem),
1385	OriginalModuleMapFile: ModMap.getModuleMapFileForUniquing(M: Module)->getName(),
1386	ModuleFileName,
1387	PreBuildStep: [&](CompilerInstance &Instance) {
1388	std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
1389	llvm::MemoryBuffer::getMemBuffer(InputData: InferredModuleMapContent);
1390	FileEntryRef ModuleMapFile = Instance.getFileManager().getVirtualFileRef(
1391	Filename: FakeModuleMapFile, Size: InferredModuleMapContent.size(), ModificationTime: 0);
1392	Instance.getSourceManager().overrideFileContents(
1393	SourceFile: ModuleMapFile, Buffer: std::move(ModuleMapBuffer));
1394	});
1395	}
1396
1397	// We've rebuilt a module. If we're allowed to generate or update the global
1398	// module index, record that fact in the importing compiler instance.
1399	if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
1400	ImportingInstance.setBuildGlobalModuleIndex(true);
1401	}
1402
1403	return Result;
1404	}
1405
1406	/// Read the AST right after compiling the module.
1407	static bool readASTAfterCompileModule(CompilerInstance &ImportingInstance,
1408	SourceLocation ImportLoc,
1409	SourceLocation ModuleNameLoc,
1410	Module *Module, StringRef ModuleFileName,
1411	bool *OutOfDate) {
1412	DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1413
1414	unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
1415	if (OutOfDate)
1416	ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1417
1418	// Try to read the module file, now that we've compiled it.
1419	ASTReader::ASTReadResult ReadResult =
1420	ImportingInstance.getASTReader()->ReadAST(
1421	FileName: ModuleFileName, Type: serialization::MK_ImplicitModule, ImportLoc,
1422	ClientLoadCapabilities: ModuleLoadCapabilities);
1423	if (ReadResult == ASTReader::Success)
1424	return true;
1425
1426	// The caller wants to handle out-of-date failures.
1427	if (OutOfDate && ReadResult == ASTReader::OutOfDate) {
1428	*OutOfDate = true;
1429	return false;
1430	}
1431
1432	// The ASTReader didn't diagnose the error, so conservatively report it.
1433	if (ReadResult == ASTReader::Missing || !Diags.hasErrorOccurred())
1434	Diags.Report(ModuleNameLoc, diag::err_module_not_built)
1435	<< Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1436
1437	return false;
1438	}
1439
1440	/// Compile a module in a separate compiler instance and read the AST,
1441	/// returning true if the module compiles without errors.
1442	static bool compileModuleAndReadASTImpl(CompilerInstance &ImportingInstance,
1443	SourceLocation ImportLoc,
1444	SourceLocation ModuleNameLoc,
1445	Module *Module,
1446	StringRef ModuleFileName) {
1447	if (!compileModule(ImportingInstance, ImportLoc: ModuleNameLoc, Module,
1448	ModuleFileName)) {
1449	ImportingInstance.getDiagnostics().Report(ModuleNameLoc,
1450	diag::err_module_not_built)
1451	<< Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1452	return false;
1453	}
1454
1455	return readASTAfterCompileModule(ImportingInstance, ImportLoc, ModuleNameLoc,
1456	Module, ModuleFileName,
1457	/*OutOfDate=*/nullptr);
1458	}
1459
1460	/// Compile a module in a separate compiler instance and read the AST,
1461	/// returning true if the module compiles without errors, using a lock manager
1462	/// to avoid building the same module in multiple compiler instances.
1463	///
1464	/// Uses a lock file manager and exponential backoff to reduce the chances that
1465	/// multiple instances will compete to create the same module. On timeout,
1466	/// deletes the lock file in order to avoid deadlock from crashing processes or
1467	/// bugs in the lock file manager.
1468	static bool compileModuleAndReadASTBehindLock(
1469	CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
1470	SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName) {
1471	DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1472
1473	Diags.Report(ModuleNameLoc, diag::remark_module_lock)
1474	<< ModuleFileName << Module->Name;
1475
1476	// FIXME: have LockFileManager return an error_code so that we can
1477	// avoid the mkdir when the directory already exists.
1478	StringRef Dir = llvm::sys::path::parent_path(path: ModuleFileName);
1479	llvm::sys::fs::create_directories(path: Dir);
1480
1481	while (true) {
1482	llvm::LockFileManager Locked(ModuleFileName);
1483	switch (Locked) {
1484	case llvm::LockFileManager::LFS_Error:
1485	// ModuleCache takes care of correctness and locks are only necessary for
1486	// performance. Fallback to building the module in case of any lock
1487	// related errors.
1488	Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure)
1489	<< Module->Name << Locked.getErrorMessage();
1490	// Clear out any potential leftover.
1491	Locked.unsafeRemoveLockFile();
1492	[[fallthrough]];
1493	case llvm::LockFileManager::LFS_Owned:
1494	// We're responsible for building the module ourselves.
1495	return compileModuleAndReadASTImpl(ImportingInstance, ImportLoc,
1496	ModuleNameLoc, Module, ModuleFileName);
1497
1498	case llvm::LockFileManager::LFS_Shared:
1499	break; // The interesting case.
1500	}
1501
1502	// Someone else is responsible for building the module. Wait for them to
1503	// finish.
1504	switch (Locked.waitForUnlock()) {
1505	case llvm::LockFileManager::Res_Success:
1506	break; // The interesting case.
1507	case llvm::LockFileManager::Res_OwnerDied:
1508	continue; // try again to get the lock.
1509	case llvm::LockFileManager::Res_Timeout:
1510	// Since ModuleCache takes care of correctness, we try waiting for
1511	// another process to complete the build so clang does not do it done
1512	// twice. If case of timeout, build it ourselves.
1513	Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout)
1514	<< Module->Name;
1515	// Clear the lock file so that future invocations can make progress.
1516	Locked.unsafeRemoveLockFile();
1517	continue;
1518	}
1519
1520	// Read the module that was just written by someone else.
1521	bool OutOfDate = false;
1522	if (readASTAfterCompileModule(ImportingInstance, ImportLoc, ModuleNameLoc,
1523	Module, ModuleFileName, OutOfDate: &OutOfDate))
1524	return true;
1525	if (!OutOfDate)
1526	return false;
1527
1528	// The module may be out of date in the presence of file system races,
1529	// or if one of its imports depends on header search paths that are not
1530	// consistent with this ImportingInstance. Try again...
1531	}
1532	}
1533
1534	/// Compile a module in a separate compiler instance and read the AST,
1535	/// returning true if the module compiles without errors, potentially using a
1536	/// lock manager to avoid building the same module in multiple compiler
1537	/// instances.
1538	static bool compileModuleAndReadAST(CompilerInstance &ImportingInstance,
1539	SourceLocation ImportLoc,
1540	SourceLocation ModuleNameLoc,
1541	Module *Module, StringRef ModuleFileName) {
1542	return ImportingInstance.getInvocation()
1543	.getFrontendOpts()
1544	.BuildingImplicitModuleUsesLock
1545	? compileModuleAndReadASTBehindLock(ImportingInstance, ImportLoc,
1546	ModuleNameLoc, Module,
1547	ModuleFileName)
1548	: compileModuleAndReadASTImpl(ImportingInstance, ImportLoc,
1549	ModuleNameLoc, Module,
1550	ModuleFileName);
1551	}
1552
1553	/// Diagnose differences between the current definition of the given
1554	/// configuration macro and the definition provided on the command line.
1555	static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1556	Module *Mod, SourceLocation ImportLoc) {
1557	IdentifierInfo *Id = PP.getIdentifierInfo(Name: ConfigMacro);
1558	SourceManager &SourceMgr = PP.getSourceManager();
1559
1560	// If this identifier has never had a macro definition, then it could
1561	// not have changed.
1562	if (!Id->hadMacroDefinition())
1563	return;
1564	auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(II: Id);
1565
1566	// Find the macro definition from the command line.
1567	MacroInfo *CmdLineDefinition = nullptr;
1568	for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
1569	// We only care about the predefines buffer.
1570	FileID FID = SourceMgr.getFileID(SpellingLoc: MD->getLocation());
1571	if (FID.isInvalid() || FID != PP.getPredefinesFileID())
1572	continue;
1573	if (auto *DMD = dyn_cast<DefMacroDirective>(Val: MD))
1574	CmdLineDefinition = DMD->getMacroInfo();
1575	break;
1576	}
1577
1578	auto *CurrentDefinition = PP.getMacroInfo(II: Id);
1579	if (CurrentDefinition == CmdLineDefinition) {
1580	// Macro matches. Nothing to do.
1581	} else if (!CurrentDefinition) {
1582	// This macro was defined on the command line, then #undef'd later.
1583	// Complain.
1584	PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1585	<< true << ConfigMacro << Mod->getFullModuleName();
1586	auto LatestDef = LatestLocalMD->getDefinition();
1587	assert(LatestDef.isUndefined() &&
1588	"predefined macro went away with no #undef?");
1589	PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1590	<< true;
1591	return;
1592	} else if (!CmdLineDefinition) {
1593	// There was no definition for this macro in the predefines buffer,
1594	// but there was a local definition. Complain.
1595	PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1596	<< false << ConfigMacro << Mod->getFullModuleName();
1597	PP.Diag(CurrentDefinition->getDefinitionLoc(),
1598	diag::note_module_def_undef_here)
1599	<< false;
1600	} else if (!CurrentDefinition->isIdenticalTo(Other: *CmdLineDefinition, PP,
1601	/*Syntactically=*/true)) {
1602	// The macro definitions differ.
1603	PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1604	<< false << ConfigMacro << Mod->getFullModuleName();
1605	PP.Diag(CurrentDefinition->getDefinitionLoc(),
1606	diag::note_module_def_undef_here)
1607	<< false;
1608	}
1609	}
1610
1611	static void checkConfigMacros(Preprocessor &PP, Module *M,
1612	SourceLocation ImportLoc) {
1613	clang::Module *TopModule = M->getTopLevelModule();
1614	for (const StringRef ConMacro : TopModule->ConfigMacros) {
1615	checkConfigMacro(PP, ConfigMacro: ConMacro, Mod: M, ImportLoc);
1616	}
1617	}
1618
1619	/// Write a new timestamp file with the given path.
1620	static void writeTimestampFile(StringRef TimestampFile) {
1621	std::error_code EC;
1622	llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::OF_None);
1623	}
1624
1625	/// Prune the module cache of modules that haven't been accessed in
1626	/// a long time.
1627	static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1628	llvm::sys::fs::file_status StatBuf;
1629	llvm::SmallString<128> TimestampFile;
1630	TimestampFile = HSOpts.ModuleCachePath;
1631	assert(!TimestampFile.empty());
1632	llvm::sys::path::append(path&: TimestampFile, a: "modules.timestamp");
1633
1634	// Try to stat() the timestamp file.
1635	if (std::error_code EC = llvm::sys::fs::status(path: TimestampFile, result&: StatBuf)) {
1636	// If the timestamp file wasn't there, create one now.
1637	if (EC == std::errc::no_such_file_or_directory) {
1638	writeTimestampFile(TimestampFile);
1639	}
1640	return;
1641	}
1642
1643	// Check whether the time stamp is older than our pruning interval.
1644	// If not, do nothing.
1645	time_t TimeStampModTime =
1646	llvm::sys::toTimeT(TP: StatBuf.getLastModificationTime());
1647	time_t CurrentTime = time(timer: nullptr);
1648	if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
1649	return;
1650
1651	// Write a new timestamp file so that nobody else attempts to prune.
1652	// There is a benign race condition here, if two Clang instances happen to
1653	// notice at the same time that the timestamp is out-of-date.
1654	writeTimestampFile(TimestampFile);
1655
1656	// Walk the entire module cache, looking for unused module files and module
1657	// indices.
1658	std::error_code EC;
1659	SmallString<128> ModuleCachePathNative;
1660	llvm::sys::path::native(path: HSOpts.ModuleCachePath, result&: ModuleCachePathNative);
1661	for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
1662	Dir != DirEnd && !EC; Dir.increment(ec&: EC)) {
1663	// If we don't have a directory, there's nothing to look into.
1664	if (!llvm::sys::fs::is_directory(Path: Dir->path()))
1665	continue;
1666
1667	// Walk all of the files within this directory.
1668	for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1669	File != FileEnd && !EC; File.increment(ec&: EC)) {
1670	// We only care about module and global module index files.
1671	StringRef Extension = llvm::sys::path::extension(path: File->path());
1672	if (Extension != ".pcm" && Extension != ".timestamp" &&
1673	llvm::sys::path::filename(path: File->path()) != "modules.idx")
1674	continue;
1675
1676	// Look at this file. If we can't stat it, there's nothing interesting
1677	// there.
1678	if (llvm::sys::fs::status(path: File->path(), result&: StatBuf))
1679	continue;
1680
1681	// If the file has been used recently enough, leave it there.
1682	time_t FileAccessTime = llvm::sys::toTimeT(TP: StatBuf.getLastAccessedTime());
1683	if (CurrentTime - FileAccessTime <=
1684	time_t(HSOpts.ModuleCachePruneAfter)) {
1685	continue;
1686	}
1687
1688	// Remove the file.
1689	llvm::sys::fs::remove(path: File->path());
1690
1691	// Remove the timestamp file.
1692	std::string TimpestampFilename = File->path() + ".timestamp";
1693	llvm::sys::fs::remove(path: TimpestampFilename);
1694	}
1695
1696	// If we removed all of the files in the directory, remove the directory
1697	// itself.
1698	if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1699	llvm::sys::fs::directory_iterator() && !EC)
1700	llvm::sys::fs::remove(path: Dir->path());
1701	}
1702	}
1703
1704	void CompilerInstance::createASTReader() {
1705	if (TheASTReader)
1706	return;
1707
1708	if (!hasASTContext())
1709	createASTContext();
1710
1711	// If we're implicitly building modules but not currently recursively
1712	// building a module, check whether we need to prune the module cache.
1713	if (getSourceManager().getModuleBuildStack().empty() &&
1714	!getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty() &&
1715	getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1716	getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1717	pruneModuleCache(HSOpts: getHeaderSearchOpts());
1718	}
1719
1720	HeaderSearchOptions &HSOpts = getHeaderSearchOpts();
1721	std::string Sysroot = HSOpts.Sysroot;
1722	const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1723	const FrontendOptions &FEOpts = getFrontendOpts();
1724	std::unique_ptr<llvm::Timer> ReadTimer;
1725
1726	if (FrontendTimerGroup)
1727	ReadTimer = std::make_unique<llvm::Timer>(args: "reading_modules",
1728	args: "Reading modules",
1729	args&: *FrontendTimerGroup);
1730	TheASTReader = new ASTReader(
1731	getPreprocessor(), getModuleCache(), &getASTContext(),
1732	getPCHContainerReader(), getFrontendOpts().ModuleFileExtensions,
1733	Sysroot.empty() ? "" : Sysroot.c_str(),
1734	PPOpts.DisablePCHOrModuleValidation,
1735	/*AllowASTWithCompilerErrors=*/FEOpts.AllowPCMWithCompilerErrors,
1736	/*AllowConfigurationMismatch=*/false, HSOpts.ModulesValidateSystemHeaders,
1737	HSOpts.ValidateASTInputFilesContent,
1738	getFrontendOpts().UseGlobalModuleIndex, std::move(ReadTimer));
1739	if (hasASTConsumer()) {
1740	TheASTReader->setDeserializationListener(
1741	Listener: getASTConsumer().GetASTDeserializationListener());
1742	getASTContext().setASTMutationListener(
1743	getASTConsumer().GetASTMutationListener());
1744	}
1745	getASTContext().setExternalSource(TheASTReader);
1746	if (hasSema())
1747	TheASTReader->InitializeSema(S&: getSema());
1748	if (hasASTConsumer())
1749	TheASTReader->StartTranslationUnit(Consumer: &getASTConsumer());
1750
1751	for (auto &Listener : DependencyCollectors)
1752	Listener->attachToASTReader(R&: *TheASTReader);
1753	}
1754
1755	bool CompilerInstance::loadModuleFile(
1756	StringRef FileName, serialization::ModuleFile *&LoadedModuleFile) {
1757	llvm::Timer Timer;
1758	if (FrontendTimerGroup)
1759	Timer.init(TimerName: "preloading." + FileName.str(), TimerDescription: "Preloading " + FileName.str(),
1760	tg&: *FrontendTimerGroup);
1761	llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1762
1763	// If we don't already have an ASTReader, create one now.
1764	if (!TheASTReader)
1765	createASTReader();
1766
1767	// If -Wmodule-file-config-mismatch is mapped as an error or worse, allow the
1768	// ASTReader to diagnose it, since it can produce better errors that we can.
1769	bool ConfigMismatchIsRecoverable =
1770	getDiagnostics().getDiagnosticLevel(diag::warn_module_config_mismatch,
1771	SourceLocation())
1772	<= DiagnosticsEngine::Warning;
1773
1774	auto Listener = std::make_unique<ReadModuleNames>(args&: *PP);
1775	auto &ListenerRef = *Listener;
1776	ASTReader::ListenerScope ReadModuleNamesListener(*TheASTReader,
1777	std::move(Listener));
1778
1779	// Try to load the module file.
1780	switch (TheASTReader->ReadAST(
1781	FileName, Type: serialization::MK_ExplicitModule, ImportLoc: SourceLocation(),
1782	ClientLoadCapabilities: ConfigMismatchIsRecoverable ? ASTReader::ARR_ConfigurationMismatch : 0,
1783	NewLoadedModuleFile: &LoadedModuleFile)) {
1784	case ASTReader::Success:
1785	// We successfully loaded the module file; remember the set of provided
1786	// modules so that we don't try to load implicit modules for them.
1787	ListenerRef.registerAll();
1788	return true;
1789
1790	case ASTReader::ConfigurationMismatch:
1791	// Ignore unusable module files.
1792	getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch)
1793	<< FileName;
1794	// All modules provided by any files we tried and failed to load are now
1795	// unavailable; includes of those modules should now be handled textually.
1796	ListenerRef.markAllUnavailable();
1797	return true;
1798
1799	default:
1800	return false;
1801	}
1802	}
1803
1804	namespace {
1805	enum ModuleSource {
1806	MS_ModuleNotFound,
1807	MS_ModuleCache,
1808	MS_PrebuiltModulePath,
1809	MS_ModuleBuildPragma
1810	};
1811	} // end namespace
1812
1813	/// Select a source for loading the named module and compute the filename to
1814	/// load it from.
1815	static ModuleSource selectModuleSource(
1816	Module *M, StringRef ModuleName, std::string &ModuleFilename,
1817	const std::map<std::string, std::string, std::less<>> &BuiltModules,
1818	HeaderSearch &HS) {
1819	assert(ModuleFilename.empty() && "Already has a module source?");
1820
1821	// Check to see if the module has been built as part of this compilation
1822	// via a module build pragma.
1823	auto BuiltModuleIt = BuiltModules.find(x: ModuleName);
1824	if (BuiltModuleIt != BuiltModules.end()) {
1825	ModuleFilename = BuiltModuleIt->second;
1826	return MS_ModuleBuildPragma;
1827	}
1828
1829	// Try to load the module from the prebuilt module path.
1830	const HeaderSearchOptions &HSOpts = HS.getHeaderSearchOpts();
1831	if (!HSOpts.PrebuiltModuleFiles.empty() ||
1832	!HSOpts.PrebuiltModulePaths.empty()) {
1833	ModuleFilename = HS.getPrebuiltModuleFileName(ModuleName);
1834	if (HSOpts.EnablePrebuiltImplicitModules && ModuleFilename.empty())
1835	ModuleFilename = HS.getPrebuiltImplicitModuleFileName(Module: M);
1836	if (!ModuleFilename.empty())
1837	return MS_PrebuiltModulePath;
1838	}
1839
1840	// Try to load the module from the module cache.
1841	if (M) {
1842	ModuleFilename = HS.getCachedModuleFileName(Module: M);
1843	return MS_ModuleCache;
1844	}
1845
1846	return MS_ModuleNotFound;
1847	}
1848
1849	ModuleLoadResult CompilerInstance::findOrCompileModuleAndReadAST(
1850	StringRef ModuleName, SourceLocation ImportLoc,
1851	SourceLocation ModuleNameLoc, bool IsInclusionDirective) {
1852	// Search for a module with the given name.
1853	HeaderSearch &HS = PP->getHeaderSearchInfo();
1854	Module *M =
1855	HS.lookupModule(ModuleName, ImportLoc, AllowSearch: true, AllowExtraModuleMapSearch: !IsInclusionDirective);
1856
1857	// Check for any configuration macros that have changed. This is done
1858	// immediately before potentially building a module in case this module
1859	// depends on having one of its configuration macros defined to successfully
1860	// build. If this is not done the user will never see the warning.
1861	if (M)
1862	checkConfigMacros(PP&: getPreprocessor(), M, ImportLoc);
1863
1864	// Select the source and filename for loading the named module.
1865	std::string ModuleFilename;
1866	ModuleSource Source =
1867	selectModuleSource(M, ModuleName, ModuleFilename, BuiltModules, HS);
1868	if (Source == MS_ModuleNotFound) {
1869	// We can't find a module, error out here.
1870	getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1871	<< ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
1872	return nullptr;
1873	}
1874	if (ModuleFilename.empty()) {
1875	if (M && M->HasIncompatibleModuleFile) {
1876	// We tried and failed to load a module file for this module. Fall
1877	// back to textual inclusion for its headers.
1878	return ModuleLoadResult::ConfigMismatch;
1879	}
1880
1881	getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
1882	<< ModuleName;
1883	return nullptr;
1884	}
1885
1886	// Create an ASTReader on demand.
1887	if (!getASTReader())
1888	createASTReader();
1889
1890	// Time how long it takes to load the module.
1891	llvm::Timer Timer;
1892	if (FrontendTimerGroup)
1893	Timer.init(TimerName: "loading." + ModuleFilename, TimerDescription: "Loading " + ModuleFilename,
1894	tg&: *FrontendTimerGroup);
1895	llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1896	llvm::TimeTraceScope TimeScope("Module Load", ModuleName);
1897
1898	// Try to load the module file. If we are not trying to load from the
1899	// module cache, we don't know how to rebuild modules.
1900	unsigned ARRFlags = Source == MS_ModuleCache
1901	? ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing |
1902	ASTReader::ARR_TreatModuleWithErrorsAsOutOfDate
1903	: Source == MS_PrebuiltModulePath
1904	? 0
1905	: ASTReader::ARR_ConfigurationMismatch;
1906	switch (getASTReader()->ReadAST(FileName: ModuleFilename,
1907	Type: Source == MS_PrebuiltModulePath
1908	? serialization::MK_PrebuiltModule
1909	: Source == MS_ModuleBuildPragma
1910	? serialization::MK_ExplicitModule
1911	: serialization::MK_ImplicitModule,
1912	ImportLoc, ClientLoadCapabilities: ARRFlags)) {
1913	case ASTReader::Success: {
1914	if (M)
1915	return M;
1916	assert(Source != MS_ModuleCache &&
1917	"missing module, but file loaded from cache");
1918
1919	// A prebuilt module is indexed as a ModuleFile; the Module does not exist
1920	// until the first call to ReadAST. Look it up now.
1921	M = HS.lookupModule(ModuleName, ImportLoc, AllowSearch: true, AllowExtraModuleMapSearch: !IsInclusionDirective);
1922
1923	// Check whether M refers to the file in the prebuilt module path.
1924	if (M && M->getASTFile())
1925	if (auto ModuleFile = FileMgr->getFile(Filename: ModuleFilename))
1926	if (*ModuleFile == M->getASTFile())
1927	return M;
1928
1929	getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt)
1930	<< ModuleName;
1931	return ModuleLoadResult();
1932	}
1933
1934	case ASTReader::OutOfDate:
1935	case ASTReader::Missing:
1936	// The most interesting case.
1937	break;
1938
1939	case ASTReader::ConfigurationMismatch:
1940	if (Source == MS_PrebuiltModulePath)
1941	// FIXME: We shouldn't be setting HadFatalFailure below if we only
1942	// produce a warning here!
1943	getDiagnostics().Report(SourceLocation(),
1944	diag::warn_module_config_mismatch)
1945	<< ModuleFilename;
1946	// Fall through to error out.
1947	[[fallthrough]];
1948	case ASTReader::VersionMismatch:
1949	case ASTReader::HadErrors:
1950	ModuleLoader::HadFatalFailure = true;
1951	// FIXME: The ASTReader will already have complained, but can we shoehorn
1952	// that diagnostic information into a more useful form?
1953	return ModuleLoadResult();
1954
1955	case ASTReader::Failure:
1956	ModuleLoader::HadFatalFailure = true;
1957	return ModuleLoadResult();
1958	}
1959
1960	// ReadAST returned Missing or OutOfDate.
1961	if (Source != MS_ModuleCache) {
1962	// We don't know the desired configuration for this module and don't
1963	// necessarily even have a module map. Since ReadAST already produces
1964	// diagnostics for these two cases, we simply error out here.
1965	return ModuleLoadResult();
1966	}
1967
1968	// The module file is missing or out-of-date. Build it.
1969	assert(M && "missing module, but trying to compile for cache");
1970
1971	// Check whether there is a cycle in the module graph.
1972	ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1973	ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1974	for (; Pos != PosEnd; ++Pos) {
1975	if (Pos->first == ModuleName)
1976	break;
1977	}
1978
1979	if (Pos != PosEnd) {
1980	SmallString<256> CyclePath;
1981	for (; Pos != PosEnd; ++Pos) {
1982	CyclePath += Pos->first;
1983	CyclePath += " -> ";
1984	}
1985	CyclePath += ModuleName;
1986
1987	getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1988	<< ModuleName << CyclePath;
1989	return nullptr;
1990	}
1991
1992	// Check whether we have already attempted to build this module (but failed).
1993	if (FailedModules && FailedModules->hasAlreadyFailed(module: ModuleName)) {
1994	getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1995	<< ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
1996	return nullptr;
1997	}
1998
1999	// Try to compile and then read the AST.
2000	if (!compileModuleAndReadAST(ImportingInstance&: *this, ImportLoc, ModuleNameLoc, Module: M,
2001	ModuleFileName: ModuleFilename)) {
2002	assert(getDiagnostics().hasErrorOccurred() &&
2003	"undiagnosed error in compileModuleAndReadAST");
2004	if (FailedModules)
2005	FailedModules->addFailed(module: ModuleName);
2006	return nullptr;
2007	}
2008
2009	// Okay, we've rebuilt and now loaded the module.
2010	return M;
2011	}
2012
2013	ModuleLoadResult
2014	CompilerInstance::loadModule(SourceLocation ImportLoc,
2015	ModuleIdPath Path,
2016	Module::NameVisibilityKind Visibility,
2017	bool IsInclusionDirective) {
2018	// Determine what file we're searching from.
2019	StringRef ModuleName = Path[0].first->getName();
2020	SourceLocation ModuleNameLoc = Path[0].second;
2021
2022	// If we've already handled this import, just return the cached result.
2023	// This one-element cache is important to eliminate redundant diagnostics
2024	// when both the preprocessor and parser see the same import declaration.
2025	if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) {
2026	// Make the named module visible.
2027	if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
2028	TheASTReader->makeModuleVisible(Mod: LastModuleImportResult, NameVisibility: Visibility,
2029	ImportLoc);
2030	return LastModuleImportResult;
2031	}
2032
2033	// If we don't already have information on this module, load the module now.
2034	Module *Module = nullptr;
2035	ModuleMap &MM = getPreprocessor().getHeaderSearchInfo().getModuleMap();
2036	if (auto MaybeModule = MM.getCachedModuleLoad(II: *Path[0].first)) {
2037	// Use the cached result, which may be nullptr.
2038	Module = *MaybeModule;
2039	// Config macros are already checked before building a module, but they need
2040	// to be checked at each import location in case any of the config macros
2041	// have a new value at the current `ImportLoc`.
2042	if (Module)
2043	checkConfigMacros(PP&: getPreprocessor(), M: Module, ImportLoc);
2044	} else if (ModuleName == getLangOpts().CurrentModule) {
2045	// This is the module we're building.
2046	Module = PP->getHeaderSearchInfo().lookupModule(
2047	ModuleName, ImportLoc, /*AllowSearch*/ true,
2048	/*AllowExtraModuleMapSearch*/ !IsInclusionDirective);
2049
2050	// Config macros do not need to be checked here for two reasons.
2051	// * This will always be textual inclusion, and thus the config macros
2052	// actually do impact the content of the header.
2053	// * `Preprocessor::HandleHeaderIncludeOrImport` will never call this
2054	// function as the `#include` or `#import` is textual.
2055
2056	MM.cacheModuleLoad(II: *Path[0].first, M: Module);
2057	} else {
2058	ModuleLoadResult Result = findOrCompileModuleAndReadAST(
2059	ModuleName, ImportLoc, ModuleNameLoc, IsInclusionDirective);
2060	if (!Result.isNormal())
2061	return Result;
2062	if (!Result)
2063	DisableGeneratingGlobalModuleIndex = true;
2064	Module = Result;
2065	MM.cacheModuleLoad(II: *Path[0].first, M: Module);
2066	}
2067
2068	// If we never found the module, fail. Otherwise, verify the module and link
2069	// it up.
2070	if (!Module)
2071	return ModuleLoadResult();
2072
2073	// Verify that the rest of the module path actually corresponds to
2074	// a submodule.
2075	bool MapPrivateSubModToTopLevel = false;
2076	for (unsigned I = 1, N = Path.size(); I != N; ++I) {
2077	StringRef Name = Path[I].first->getName();
2078	clang::Module *Sub = Module->findSubmodule(Name);
2079
2080	// If the user is requesting Foo.Private and it doesn't exist, try to
2081	// match Foo_Private and emit a warning asking for the user to write
2082	// @import Foo_Private instead. FIXME: remove this when existing clients
2083	// migrate off of Foo.Private syntax.
2084	if (!Sub && Name == "Private" && Module == Module->getTopLevelModule()) {
2085	SmallString<128> PrivateModule(Module->Name);
2086	PrivateModule.append(RHS: "_Private");
2087
2088	SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> PrivPath;
2089	auto &II = PP->getIdentifierTable().get(
2090	Name: PrivateModule, TokenCode: PP->getIdentifierInfo(Name: Module->Name)->getTokenID());
2091	PrivPath.push_back(Elt: std::make_pair(x: &II, y: Path[0].second));
2092
2093	std::string FileName;
2094	// If there is a modulemap module or prebuilt module, load it.
2095	if (PP->getHeaderSearchInfo().lookupModule(ModuleName: PrivateModule, ImportLoc, AllowSearch: true,
2096	AllowExtraModuleMapSearch: !IsInclusionDirective) ||
2097	selectModuleSource(M: nullptr, ModuleName: PrivateModule, ModuleFilename&: FileName, BuiltModules,
2098	HS&: PP->getHeaderSearchInfo()) != MS_ModuleNotFound)
2099	Sub = loadModule(ImportLoc, Path: PrivPath, Visibility, IsInclusionDirective);
2100	if (Sub) {
2101	MapPrivateSubModToTopLevel = true;
2102	PP->markClangModuleAsAffecting(M: Module);
2103	if (!getDiagnostics().isIgnored(
2104	diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) {
2105	getDiagnostics().Report(Path[I].second,
2106	diag::warn_no_priv_submodule_use_toplevel)
2107	<< Path[I].first << Module->getFullModuleName() << PrivateModule
2108	<< SourceRange(Path[0].second, Path[I].second)
2109	<< FixItHint::CreateReplacement(SourceRange(Path[0].second),
2110	PrivateModule);
2111	getDiagnostics().Report(Sub->DefinitionLoc,
2112	diag::note_private_top_level_defined);
2113	}
2114	}
2115	}
2116
2117	if (!Sub) {
2118	// Attempt to perform typo correction to find a module name that works.
2119	SmallVector<StringRef, 2> Best;
2120	unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
2121
2122	for (class Module *SubModule : Module->submodules()) {
2123	unsigned ED =
2124	Name.edit_distance(Other: SubModule->Name,
2125	/*AllowReplacements=*/true, MaxEditDistance: BestEditDistance);
2126	if (ED <= BestEditDistance) {
2127	if (ED < BestEditDistance) {
2128	Best.clear();
2129	BestEditDistance = ED;
2130	}
2131
2132	Best.push_back(Elt: SubModule->Name);
2133	}
2134	}
2135
2136	// If there was a clear winner, user it.
2137	if (Best.size() == 1) {
2138	getDiagnostics().Report(Path[I].second, diag::err_no_submodule_suggest)
2139	<< Path[I].first << Module->getFullModuleName() << Best[0]
2140	<< SourceRange(Path[0].second, Path[I - 1].second)
2141	<< FixItHint::CreateReplacement(SourceRange(Path[I].second),
2142	Best[0]);
2143
2144	Sub = Module->findSubmodule(Name: Best[0]);
2145	}
2146	}
2147
2148	if (!Sub) {
2149	// No submodule by this name. Complain, and don't look for further
2150	// submodules.
2151	getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
2152	<< Path[I].first << Module->getFullModuleName()
2153	<< SourceRange(Path[0].second, Path[I - 1].second);
2154	break;
2155	}
2156
2157	Module = Sub;
2158	}
2159
2160	// Make the named module visible, if it's not already part of the module
2161	// we are parsing.
2162	if (ModuleName != getLangOpts().CurrentModule) {
2163	if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) {
2164	// We have an umbrella header or directory that doesn't actually include
2165	// all of the headers within the directory it covers. Complain about
2166	// this missing submodule and recover by forgetting that we ever saw
2167	// this submodule.
2168	// FIXME: Should we detect this at module load time? It seems fairly
2169	// expensive (and rare).
2170	getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
2171	<< Module->getFullModuleName()
2172	<< SourceRange(Path.front().second, Path.back().second);
2173
2174	return ModuleLoadResult(Module, ModuleLoadResult::MissingExpected);
2175	}
2176
2177	// Check whether this module is available.
2178	if (Preprocessor::checkModuleIsAvailable(LangOpts: getLangOpts(), TargetInfo: getTarget(),
2179	M: *Module, Diags&: getDiagnostics())) {
2180	getDiagnostics().Report(ImportLoc, diag::note_module_import_here)
2181	<< SourceRange(Path.front().second, Path.back().second);
2182	LastModuleImportLoc = ImportLoc;
2183	LastModuleImportResult = ModuleLoadResult();
2184	return ModuleLoadResult();
2185	}
2186
2187	TheASTReader->makeModuleVisible(Mod: Module, NameVisibility: Visibility, ImportLoc);
2188	}
2189
2190	// Resolve any remaining module using export_as for this one.
2191	getPreprocessor()
2192	.getHeaderSearchInfo()
2193	.getModuleMap()
2194	.resolveLinkAsDependencies(Mod: Module->getTopLevelModule());
2195
2196	LastModuleImportLoc = ImportLoc;
2197	LastModuleImportResult = ModuleLoadResult(Module);
2198	return LastModuleImportResult;
2199	}
2200
2201	void CompilerInstance::createModuleFromSource(SourceLocation ImportLoc,
2202	StringRef ModuleName,
2203	StringRef Source) {
2204	// Avoid creating filenames with special characters.
2205	SmallString<128> CleanModuleName(ModuleName);
2206	for (auto &C : CleanModuleName)
2207	if (!isAlphanumeric(c: C))
2208	C = '_';
2209
2210	// FIXME: Using a randomized filename here means that our intermediate .pcm
2211	// output is nondeterministic (as .pcm files refer to each other by name).
2212	// Can this affect the output in any way?
2213	SmallString<128> ModuleFileName;
2214	if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
2215	Prefix: CleanModuleName, Suffix: "pcm", ResultPath&: ModuleFileName)) {
2216	getDiagnostics().Report(ImportLoc, diag::err_fe_unable_to_open_output)
2217	<< ModuleFileName << EC.message();
2218	return;
2219	}
2220	std::string ModuleMapFileName = (CleanModuleName + ".map").str();
2221
2222	FrontendInputFile Input(
2223	ModuleMapFileName,
2224	InputKind(getLanguageFromOptions(LangOpts: Invocation->getLangOpts()),
2225	InputKind::ModuleMap, /*Preprocessed*/true));
2226
2227	std::string NullTerminatedSource(Source.str());
2228
2229	auto PreBuildStep = [&](CompilerInstance &Other) {
2230	// Create a virtual file containing our desired source.
2231	// FIXME: We shouldn't need to do this.
2232	FileEntryRef ModuleMapFile = Other.getFileManager().getVirtualFileRef(
2233	Filename: ModuleMapFileName, Size: NullTerminatedSource.size(), ModificationTime: 0);
2234	Other.getSourceManager().overrideFileContents(
2235	SourceFile: ModuleMapFile, Buffer: llvm::MemoryBuffer::getMemBuffer(InputData: NullTerminatedSource));
2236
2237	Other.BuiltModules = std::move(BuiltModules);
2238	Other.DeleteBuiltModules = false;
2239	};
2240
2241	auto PostBuildStep = [this](CompilerInstance &Other) {
2242	BuiltModules = std::move(Other.BuiltModules);
2243	};
2244
2245	// Build the module, inheriting any modules that we've built locally.
2246	if (compileModuleImpl(ImportingInstance&: *this, ImportLoc, ModuleName, Input, OriginalModuleMapFile: StringRef(),
2247	ModuleFileName, PreBuildStep, PostBuildStep)) {
2248	BuiltModules[std::string(ModuleName)] = std::string(ModuleFileName);
2249	llvm::sys::RemoveFileOnSignal(Filename: ModuleFileName);
2250	}
2251	}
2252
2253	void CompilerInstance::makeModuleVisible(Module *Mod,
2254	Module::NameVisibilityKind Visibility,
2255	SourceLocation ImportLoc) {
2256	if (!TheASTReader)
2257	createASTReader();
2258	if (!TheASTReader)
2259	return;
2260
2261	TheASTReader->makeModuleVisible(Mod, NameVisibility: Visibility, ImportLoc);
2262	}
2263
2264	GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex(
2265	SourceLocation TriggerLoc) {
2266	if (getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
2267	return nullptr;
2268	if (!TheASTReader)
2269	createASTReader();
2270	// Can't do anything if we don't have the module manager.
2271	if (!TheASTReader)
2272	return nullptr;
2273	// Get an existing global index. This loads it if not already
2274	// loaded.
2275	TheASTReader->loadGlobalIndex();
2276	GlobalModuleIndex *GlobalIndex = TheASTReader->getGlobalIndex();
2277	// If the global index doesn't exist, create it.
2278	if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
2279	hasPreprocessor()) {
2280	llvm::sys::fs::create_directories(
2281	path: getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2282	if (llvm::Error Err = GlobalModuleIndex::writeIndex(
2283	FileMgr&: getFileManager(), PCHContainerRdr: getPCHContainerReader(),
2284	Path: getPreprocessor().getHeaderSearchInfo().getModuleCachePath())) {
2285	// FIXME this drops the error on the floor. This code is only used for
2286	// typo correction and drops more than just this one source of errors
2287	// (such as the directory creation failure above). It should handle the
2288	// error.
2289	consumeError(Err: std::move(Err));
2290	return nullptr;
2291	}
2292	TheASTReader->resetForReload();
2293	TheASTReader->loadGlobalIndex();
2294	GlobalIndex = TheASTReader->getGlobalIndex();
2295	}
2296	// For finding modules needing to be imported for fixit messages,
2297	// we need to make the global index cover all modules, so we do that here.
2298	if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
2299	ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap();
2300	bool RecreateIndex = false;
2301	for (ModuleMap::module_iterator I = MMap.module_begin(),
2302	E = MMap.module_end(); I != E; ++I) {
2303	Module *TheModule = I->second;
2304	OptionalFileEntryRef Entry = TheModule->getASTFile();
2305	if (!Entry) {
2306	SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
2307	Path.push_back(Elt: std::make_pair(
2308	x: getPreprocessor().getIdentifierInfo(Name: TheModule->Name), y&: TriggerLoc));
2309	std::reverse(first: Path.begin(), last: Path.end());
2310	// Load a module as hidden. This also adds it to the global index.
2311	loadModule(ImportLoc: TheModule->DefinitionLoc, Path, Visibility: Module::Hidden, IsInclusionDirective: false);
2312	RecreateIndex = true;
2313	}
2314	}
2315	if (RecreateIndex) {
2316	if (llvm::Error Err = GlobalModuleIndex::writeIndex(
2317	FileMgr&: getFileManager(), PCHContainerRdr: getPCHContainerReader(),
2318	Path: getPreprocessor().getHeaderSearchInfo().getModuleCachePath())) {
2319	// FIXME As above, this drops the error on the floor.
2320	consumeError(Err: std::move(Err));
2321	return nullptr;
2322	}
2323	TheASTReader->resetForReload();
2324	TheASTReader->loadGlobalIndex();
2325	GlobalIndex = TheASTReader->getGlobalIndex();
2326	}
2327	HaveFullGlobalModuleIndex = true;
2328	}
2329	return GlobalIndex;
2330	}
2331
2332	// Check global module index for missing imports.
2333	bool
2334	CompilerInstance::lookupMissingImports(StringRef Name,
2335	SourceLocation TriggerLoc) {
2336	// Look for the symbol in non-imported modules, but only if an error
2337	// actually occurred.
2338	if (!buildingModule()) {
2339	// Load global module index, or retrieve a previously loaded one.
2340	GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex(
2341	TriggerLoc);
2342
2343	// Only if we have a global index.
2344	if (GlobalIndex) {
2345	GlobalModuleIndex::HitSet FoundModules;
2346
2347	// Find the modules that reference the identifier.
2348	// Note that this only finds top-level modules.
2349	// We'll let diagnoseTypo find the actual declaration module.
2350	if (GlobalIndex->lookupIdentifier(Name, Hits&: FoundModules))
2351	return true;
2352	}
2353	}
2354
2355	return false;
2356	}
2357	void CompilerInstance::resetAndLeakSema() { llvm::BuryPointer(Ptr: takeSema()); }
2358
2359	void CompilerInstance::setExternalSemaSource(
2360	IntrusiveRefCntPtr<ExternalSemaSource> ESS) {
2361	ExternalSemaSrc = std::move(ESS);
2362	}
2363