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