Illustrate an alternative for tracking includes per submodule.

[vsapsai]

Summary

Aggregated transitive includes are stored in SubmoduleState, includes
per submodule for subsequent serialization are stored in
IncludedFilesPerSubmodule.

[vsapsai]

Handle BuildingSubmoduleStack not storing the top-level module.

clang/include/clang/Lex/ExternalPreprocessorSource.h

 //===- ExternalPreprocessorSource.h - Abstract Macro Interface --*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the ExternalPreprocessorSource interface, which enables
 //  construction of macro definitions from some external source.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_CLANG_LEX_EXTERNALPREPROCESSORSOURCE_H
 #define LLVM_CLANG_LEX_EXTERNALPREPROCESSORSOURCE_H
 
+#include "clang/Lex/Preprocessor.h"
+
 namespace clang {
 
 class IdentifierInfo;
 class Module;
 
 /// Abstract interface for external sources of preprocessor
 /// information.
 ///
public:
   ///
   /// The ID 0 is associated with the NULL identifier.
   virtual IdentifierInfo *GetIdentifier(unsigned ID) = 0;
 
   /// Map a module ID to a module.
   virtual Module *getModule(unsigned ModuleID) = 0;
 
   /// Return the files directly included in the given (sub)module.
-  virtual const llvm::DenseMap<const FileEntry *, unsigned> *
-  getIncludedFiles(Module *M) = 0;
+  virtual const Preprocessor::IncludeInfoMap *getIncludedFiles(Module *M) = 0;
 };
 
 }
 
 #endif

clang/include/clang/Lex/Preprocessor.h

struct PreambleSkipInfo {
     PreambleSkipInfo(SourceLocation HashTokenLoc, SourceLocation IfTokenLoc,
                      bool FoundNonSkipPortion, bool FoundElse,
                      SourceLocation ElseLoc)
         : HashTokenLoc(HashTokenLoc), IfTokenLoc(IfTokenLoc),
           FoundNonSkipPortion(FoundNonSkipPortion), FoundElse(FoundElse),
           ElseLoc(ElseLoc) {}
   };
 
+  struct IncludeInfo {
+    unsigned NumIncludes;
+  };
+  using IncludeInfoMap = llvm::DenseMap<const FileEntry *, IncludeInfo>;
+
 private:
   friend class ASTReader;
   friend class MacroArgs;
 
   class PreambleConditionalStackStore {
     enum State {
       Off = 0,
       Recording = 1,
private:
   /// For each IdentifierInfo that was associated with a macro, we
   /// keep a mapping to the history of all macro definitions and #undefs in
   /// the reverse order (the latest one is in the head of the list).
   ///
   /// This mapping lives within the \p CurSubmoduleState.
   using MacroMap = llvm::DenseMap<const IdentifierInfo *, MacroState>;
 
   struct SubmoduleState;
-  struct SubmoduleIncludeState;
 
   /// Information about a submodule that we're currently building.
   struct BuildingSubmoduleInfo {
     /// The module that we are building.
     Module *M;
 
     /// The location at which the module was included.
     SourceLocation ImportLoc;
 
     /// Whether we entered this submodule via a pragma.
     bool IsPragma;
 
     /// The previous SubmoduleState.
     SubmoduleState *OuterSubmoduleState;
 
     /// The number of pending module macro names when we started building this.
     unsigned OuterPendingModuleMacroNames;
 
-    /// The previous SubmoduleIncludeState.
-    SubmoduleIncludeState *OuterSubmoduleIncludeState;
-
     BuildingSubmoduleInfo(Module *M, SourceLocation ImportLoc, bool IsPragma,
                           SubmoduleState *OuterSubmoduleState,
-                          unsigned OuterPendingModuleMacroNames,
-                          SubmoduleIncludeState *OuterSubmoduleIncludeState)
+                          unsigned OuterPendingModuleMacroNames)
         : M(M), ImportLoc(ImportLoc), IsPragma(IsPragma),
           OuterSubmoduleState(OuterSubmoduleState),
-          OuterPendingModuleMacroNames(OuterPendingModuleMacroNames),
-          OuterSubmoduleIncludeState(OuterSubmoduleIncludeState) {}
+          OuterPendingModuleMacroNames(OuterPendingModuleMacroNames) {}
   };
   SmallVector<BuildingSubmoduleInfo, 8> BuildingSubmoduleStack;
 
   /// Information about a submodule's preprocessor state.
   struct SubmoduleState {
     /// The macros for the submodule.
     MacroMap Macros;
 
     /// The set of modules that are visible within the submodule.
     VisibleModuleSet VisibleModules;
 
+    IncludeInfoMap IncludedFiles;
+
     // FIXME: CounterValue?
     // FIXME: PragmaPushMacroInfo?
   };
   std::map<Module *, SubmoduleState> Submodules;
 
   /// The preprocessor state for preprocessing outside of any submodule.
   SubmoduleState NullSubmoduleState;
 
   /// The current submodule state. Will be \p NullSubmoduleState if we're not
   /// in a submodule.
   SubmoduleState *CurSubmoduleState;
 
-  /// Information about a (sub)module's preprocessor include state.
-  struct SubmoduleIncludeState {
-    /// For each included file, we track the number of includes.
-    llvm::DenseMap<const FileEntry *, unsigned> IncludedFiles;
-
-    /// The set of modules that are visible within the submodule.
-    VisibleModuleSet VisibleModules;
-  };
   /// The include state for each (sub)module.
-  std::map<Module *, SubmoduleIncludeState> SubmoduleIncludeStates;
-
-  /// The include state outside of any (sub)module.
-  SubmoduleIncludeState NullSubmoduleIncludeState;
-
-  /// The current include state.
-  SubmoduleIncludeState *CurSubmoduleIncludeState;
-
-  /// For each included file, we track the number of includes.
-  llvm::DenseMap<const FileEntry *, unsigned> IncludedFiles;
+  std::map<Module *, IncludeInfoMap> IncludedFilesPerSubmodule;
 
   /// The set of known macros exported from modules.
   llvm::FoldingSet<ModuleMacro> ModuleMacros;
 
   /// The names of potential module macros that we've not yet processed.
   llvm::SmallVector<const IdentifierInfo *, 32> PendingModuleMacroNames;
 
   /// The list of module macros, for each identifier, that are not overridden by
private:
 
   /// MacroInfos are managed as a chain for easy disposal.  This is the head
   /// of that list.
   MacroInfoChain *MIChainHead = nullptr;
 
   void updateOutOfDateIdentifier(IdentifierInfo &II) const;
 
   /// Get the external include information for the given (sub)module.
-  const llvm::DenseMap<const FileEntry *, unsigned> *
-  getExternalSubmoduleIncludes(Module *M) const;
+  const IncludeInfoMap *getExternalSubmoduleIncludes(Module *M) const;
 
 public:
   Preprocessor(std::shared_ptr<PreprocessorOptions> PPOpts,
                DiagnosticsEngine &diags, LangOptions &opts, SourceManager &SM,
                HeaderSearch &Headers, ModuleLoader &TheModuleLoader,
                IdentifierInfoLookup *IILookup = nullptr,
                bool OwnsHeaderSearch = false,
                TranslationUnitKind TUKind = TU_Complete);
public:
   bool firstTimeLexingFile(const FileEntry *File) const;
 
   /// Increment the include counter for a locally included file by one.
   void incrementIncludeCount(const FileEntry *File);
 
   /// Increment the include counter for a file transitively included file.
   void incrementTransitiveIncludeCount(const FileEntry *File, unsigned Count);
 
-  /// Get the include information outside of any (sub)module.
-  const llvm::DenseMap<const FileEntry *, unsigned> &
-  getNullSubmoduleIncludes() const {
-    return NullSubmoduleIncludeState.IncludedFiles;
-  }
-
   /// Get the include information for the given local (sub)module.
-  const llvm::DenseMap<const FileEntry *, unsigned> *
-  getLocalSubmoduleIncludes(Module *M) const;
+  const IncludeInfoMap *getLocalSubmoduleIncludes(Module *M) const;
 
   /// Return the name of the macro defined before \p Loc that has
   /// spelling \p Tokens.  If there are multiple macros with same spelling,
   /// return the last one defined.
   StringRef getLastMacroWithSpelling(SourceLocation Loc,
                                      ArrayRef<TokenValue> Tokens) const;
 
   const std::string &getPredefines() const { return Predefines; }

clang/include/clang/Serialization/ASTReader.h

public:
   };
 
 private:
   /// A list of modules that were imported by precompiled headers or
   /// any other non-module AST file.
   SmallVector<ImportedSubmodule, 2> ImportedModules;
 
   /// Mapping between a read (sub)module and the file include information.
-  llvm::DenseMap<Module *, llvm::DenseMap<const FileEntry *, unsigned>>
-      SubmoduleIncludedFiles;
+  llvm::DenseMap<Module *, Preprocessor::IncludeInfoMap> SubmoduleIncludedFiles;
   //@}
 
   /// The system include root to be used when loading the
   /// precompiled header.
   std::string isysroot;
 
   /// Whether to disable the normal validation performed on precompiled
   /// headers and module files when they are loaded.
private:
   void loadPendingDeclChain(Decl *D, uint64_t LocalOffset);
   void loadObjCCategories(serialization::GlobalDeclID ID, ObjCInterfaceDecl *D,
                           unsigned PreviousGeneration = 0);
 
   RecordLocation getLocalBitOffset(uint64_t GlobalOffset);
   uint64_t getGlobalBitOffset(ModuleFile &M, uint64_t LocalOffset);
 
   /// Read the record containing files included in a (sub)module.
-  llvm::DenseMap<const FileEntry *, unsigned>
-  readIncludedFiles(ModuleFile &F, RecordData &Record);
+  Preprocessor::IncludeInfoMap readIncludedFiles(ModuleFile &F,
+                                                 RecordData &Record);
 
   /// Returns the first preprocessed entity ID that begins or ends after
   /// \arg Loc.
   serialization::PreprocessedEntityID
   findPreprocessedEntity(SourceLocation Loc, bool EndsAfter) const;
 
   /// Find the next module that contains entities and return the ID
   /// of the first entry.
public:
   serialization::SubmoduleID
   getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID);
 
   /// Retrieve the submodule that corresponds to a global submodule ID.
   ///
   Module *getSubmodule(serialization::SubmoduleID GlobalID);
 
   /// Return the files directly included in the given (sub)module.
-  const llvm::DenseMap<const FileEntry *, unsigned> *
-  getIncludedFiles(Module *M) override;
+  const Preprocessor::IncludeInfoMap *getIncludedFiles(Module *M) override;
 
   /// Retrieve the module that corresponds to the given module ID.
   ///
   /// Note: overrides method in ExternalASTSource
   Module *getModule(unsigned ID) override;
 
   /// Retrieve the module file with a given local ID within the specified
   /// ModuleFile.

clang/include/clang/Serialization/ASTWriter.h

 #ifndef LLVM_CLANG_SERIALIZATION_ASTWRITER_H
 #define LLVM_CLANG_SERIALIZATION_ASTWRITER_H
 
 #include "clang/AST/ASTMutationListener.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
+#include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaConsumer.h"
 #include "clang/Serialization/ASTBitCodes.h"
 #include "clang/Serialization/ASTDeserializationListener.h"
 #include "clang/Serialization/PCHContainerOperations.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
public:
   /// Emit a token.
   void AddToken(const Token &Tok, RecordDataImpl &Record);
 
   /// Emit a AlignPackInfo.
   void AddAlignPackInfo(const Sema::AlignPackInfo &Info,
                         RecordDataImpl &Record);
 
   /// Emit included files information.
-  void
-  addIncludedFiles(const llvm::DenseMap<const FileEntry *, unsigned> &Files,
+  void addIncludedFiles(const Preprocessor::IncludeInfoMap &Files,
                         RecordDataImpl &Record);
 
   /// Emit a source location.
   void AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record);
 
   /// Emit a source range.
   void AddSourceRange(SourceRange Range, RecordDataImpl &Record);
 
   /// Emit a reference to an identifier.

clang/lib/Lex/PPLexerChange.cpp

void Preprocessor::HandleMicrosoftCommentPaste(Token &Tok) {
   // preprocessor directive mode), so just return EOF as our token.
   assert(!FoundLexer && "Lexer should return EOD before EOF in PP mode");
 }
 
 void Preprocessor::EnterSubmodule(Module *M, SourceLocation ImportLoc,
                                   bool ForPragma) {
   if (!getLangOpts().ModulesLocalVisibility) {
     // Just track that we entered this submodule.
-    BuildingSubmoduleStack.push_back(BuildingSubmoduleInfo(
-        M, ImportLoc, ForPragma, CurSubmoduleState,
-        PendingModuleMacroNames.size(), CurSubmoduleIncludeState));
-
-    CurSubmoduleIncludeState = &SubmoduleIncludeStates[M];
+    BuildingSubmoduleStack.push_back(
+        BuildingSubmoduleInfo(M, ImportLoc, ForPragma, CurSubmoduleState,
+                              PendingModuleMacroNames.size()));
 
     if (Callbacks)
       Callbacks->EnteredSubmodule(M, ImportLoc, ForPragma);
     return;
   }
 
   // Resolve as much of the module definition as we can now, before we enter
   // one of its headers.
for (auto &Macro : StartingMacros) {
 
       MacroState MS(Macro.second.getLatest());
       MS.setOverriddenMacros(*this, Macro.second.getOverriddenMacros());
       State.Macros.insert(std::make_pair(Macro.first, std::move(MS)));
     }
   }
 
   // Track that we entered this module.
-  BuildingSubmoduleStack.push_back(BuildingSubmoduleInfo(
-      M, ImportLoc, ForPragma, CurSubmoduleState,
-      PendingModuleMacroNames.size(), CurSubmoduleIncludeState));
+  BuildingSubmoduleStack.push_back(
+      BuildingSubmoduleInfo(M, ImportLoc, ForPragma, CurSubmoduleState,
+                            PendingModuleMacroNames.size()));
 
   if (Callbacks)
     Callbacks->EnteredSubmodule(M, ImportLoc, ForPragma);
 
   // Switch to this submodule as the current submodule.
   CurSubmoduleState = &State;
-  CurSubmoduleIncludeState = &SubmoduleIncludeStates[M];
 
   // This module is visible to itself.
   if (FirstTime)
     makeModuleVisible(M, ImportLoc);
 }
 
 bool Preprocessor::needModuleMacros() const {
   // If we're not within a submodule, we never need to create ModuleMacros.
if (BuildingSubmoduleStack.empty() ||
     return nullptr;
   }
 
   auto &Info = BuildingSubmoduleStack.back();
 
   Module *LeavingMod = Info.M;
   SourceLocation ImportLoc = Info.ImportLoc;
 
-  CurSubmoduleIncludeState = Info.OuterSubmoduleIncludeState;
-
   if (!needModuleMacros() ||
       (!getLangOpts().ModulesLocalVisibility &&
        LeavingMod->getTopLevelModuleName() != getLangOpts().CurrentModule)) {
     // If we don't need module macros, or this is not a module for which we
     // are tracking macro visibility, don't build any, and preserve the list
     // of pending names for the surrounding submodule.
     BuildingSubmoduleStack.pop_back();
 

clang/lib/Lex/Preprocessor.cpp

: PPOpts(std::move(PPOpts)), Diags(&diags), LangOpts(opts),
       FileMgr(Headers.getFileMgr()), SourceMgr(SM),
       ScratchBuf(new ScratchBuffer(SourceMgr)), HeaderInfo(Headers),
       TheModuleLoader(TheModuleLoader), ExternalSource(nullptr),
       // As the language options may have not been loaded yet (when
       // deserializing an ASTUnit), adding keywords to the identifier table is
       // deferred to Preprocessor::Initialize().
       Identifiers(IILookup), PragmaHandlers(new PragmaNamespace(StringRef())),
       TUKind(TUKind), SkipMainFilePreamble(0, true),
-      CurSubmoduleState(&NullSubmoduleState),
-      CurSubmoduleIncludeState(&NullSubmoduleIncludeState) {
+      CurSubmoduleState(&NullSubmoduleState) {
   OwnsHeaderSearch = OwnsHeaders;
 
   // Default to discarding comments.
   KeepComments = false;
   KeepMacroComments = false;
   SuppressIncludeNotFoundError = false;
 
   // Macro expansion is enabled.
void Preprocessor::PrintStats() {
 
   llvm::errs() << NumMacroExpanded << "/" << NumFnMacroExpanded << "/"
              << NumBuiltinMacroExpanded << " obj/fn/builtin macros expanded, "
              << NumFastMacroExpanded << " on the fast path.\n";
   llvm::errs() << (NumFastTokenPaste+NumTokenPaste)
              << " token paste (##) operations performed, "
              << NumFastTokenPaste << " on the fast path.\n";
 
+  // FIXME: List information for all submodules.
   unsigned NumSingleIncludedFiles = 0, MaxNumIncludes = 0;
-  for (const auto &Include : IncludedFiles) {
-    if (MaxNumIncludes < Include.second)
-      MaxNumIncludes = Include.second;
-    NumSingleIncludedFiles += Include.second == 1;
+  for (const auto &IncludePair : CurSubmoduleState->IncludedFiles) {
+    if (MaxNumIncludes < IncludePair.second.NumIncludes)
+      MaxNumIncludes = IncludePair.second.NumIncludes;
+    NumSingleIncludedFiles += IncludePair.second.NumIncludes == 1;
   }
   llvm::errs() << NumSingleIncludedFiles << " files included exactly once.\n"
                << MaxNumIncludes << " max times a file is included.\n";
 
   llvm::errs() << "\nPreprocessor Memory: " << getTotalMemory() << "B total";
 
   llvm::errs() << "\n  BumpPtr: " << BP.getTotalMemory();
   llvm::errs() << "\n  Macro Expanded Tokens: "
if (!SourceMgr.isLoadedFileID(MainFileID)) {
     // Tell the header info that the main file was entered.  If the file is later
     // #imported, it won't be re-entered.
     if (const FileEntry *FE = SourceMgr.getFileEntryForID(MainFileID)) {
       (void)getHeaderSearchInfo().getFileInfo(FE);
       incrementIncludeCount(FE);
     }
   }
 
-  if (Module *M = getCurrentModule())
-    CurSubmoduleIncludeState = &SubmoduleIncludeStates[M];
-
   // Preprocess Predefines to populate the initial preprocessor state.
   std::unique_ptr<llvm::MemoryBuffer> SB =
     llvm::MemoryBuffer::getMemBufferCopy(Predefines, "<built-in>");
   assert(SB && "Cannot create predefined source buffer");
   FileID FID = SourceMgr.createFileID(std::move(SB));
   assert(FID.isValid() && "Could not create FileID for predefines?");
   setPredefinesFileID(FID);
 
if (!Suffix.empty()) {
     EnterTokens(Suffix);
     return false;
   }
   return true;
 }
 
 void Preprocessor::makeModuleVisible(Module *M, SourceLocation Loc) {
   CurSubmoduleState->VisibleModules.setVisible(
-      M, Loc, [](Module *) {},
+      M, Loc,
+      [&](Module *M) {
+        const IncludeInfoMap *Includes = getLocalSubmoduleIncludes(M);
+        if (!Includes)
+          Includes = getExternalSubmoduleIncludes(M);
+        if (Includes)
+          for (const auto &E : *Includes)
+            incrementTransitiveIncludeCount(E.getFirst(),
+                                            E.getSecond().NumIncludes);
+      },
       [&](ArrayRef<Module *> Path, Module *Conflict, StringRef Message) {
         // FIXME: Include the path in the diagnostic.
         // FIXME: Include the import location for the conflicting module.
         Diag(ModuleImportLoc, diag::warn_module_conflict)
             << Path[0]->getFullModuleName()
             << Conflict->getFullModuleName()
             << Message;
       });
 
-  CurSubmoduleIncludeState->VisibleModules.setVisible(
-      M, Loc,
-      [&](Module *M) {
-        const auto *Includes = getLocalSubmoduleIncludes(M);
-        if (!Includes)
-          Includes = getExternalSubmoduleIncludes(M);
-        if (Includes)
-          for (const auto &E : *Includes)
-            incrementTransitiveIncludeCount(E.getFirst(), E.getSecond());
-      },
-      [](ArrayRef<Module *>, Module *, StringRef) {});
-
   // Add this module to the imports list of the currently-built submodule.
   if (!BuildingSubmoduleStack.empty() && M != BuildingSubmoduleStack.back().M)
     BuildingSubmoduleStack.back().M->Imports.insert(M);
 }
 
 bool Preprocessor::FinishLexStringLiteral(Token &Result, std::string &String,
                                           const char *DiagnosticTag,
                                           bool AllowMacroExpansion) {
void Preprocessor::createPreprocessingRecord() {
   if (Record)
     return;
 
   Record = new PreprocessingRecord(getSourceManager());
   addPPCallbacks(std::unique_ptr<PPCallbacks>(Record));
 }
 
 bool Preprocessor::includedAtLeastOnce(const FileEntry *File) const {
-  auto It = IncludedFiles.find(File);
-  if (It == IncludedFiles.end())
+  auto It = CurSubmoduleState->IncludedFiles.find(File);
+  if (It == CurSubmoduleState->IncludedFiles.end())
     return false;
-  return It->second >= 1;
+  return It->second.NumIncludes >= 1;
 }
 
 bool Preprocessor::firstTimeLexingFile(const FileEntry *File) const {
-  auto It = IncludedFiles.find(File);
-  if (It == IncludedFiles.end())
+  auto It = CurSubmoduleState->IncludedFiles.find(File);
+  if (It == CurSubmoduleState->IncludedFiles.end())
     return false;
-  return It->second == 1;
+  return It->second.NumIncludes == 1;
 }
 
 void Preprocessor::incrementTransitiveIncludeCount(const FileEntry *File,
                                                    unsigned Count) {
   // Compared to `incrementIncludeCount`, we're not incrementing the count in
   // CurSubmoduleIncludeState`. This is to ensure it always only contains
   // **locally** included files and not transitively included ones.
-  IncludedFiles[File] += Count;
+  CurSubmoduleState->IncludedFiles[File].NumIncludes += Count;
 }
 
 void Preprocessor::incrementIncludeCount(const FileEntry *File) {
-  CurSubmoduleIncludeState->IncludedFiles[File] += 1;
-  IncludedFiles[File] += 1;
+  Module *CurrentSubmodule = nullptr;
+  if (!BuildingSubmoduleStack.empty())
+    CurrentSubmodule = BuildingSubmoduleStack.back().M;
+  else
+    CurrentSubmodule = getCurrentModule();
+  if (CurrentSubmodule)
+    IncludedFilesPerSubmodule[CurrentSubmodule][File].NumIncludes += 1;
+  CurSubmoduleState->IncludedFiles[File].NumIncludes += 1;
 }
 
-const llvm::DenseMap<const FileEntry *, unsigned> *
+const Preprocessor::IncludeInfoMap *
 Preprocessor::getLocalSubmoduleIncludes(Module *M) const {
-  auto It = SubmoduleIncludeStates.find(M);
-  if (It != SubmoduleIncludeStates.end())
-    return &It->second.IncludedFiles;
+  auto It = IncludedFilesPerSubmodule.find(M);
+  if (It != IncludedFilesPerSubmodule.end())
+    return &It->second;
   return nullptr;
 }
 
-const llvm::DenseMap<const FileEntry *, unsigned> *
+const Preprocessor::IncludeInfoMap *
 Preprocessor::getExternalSubmoduleIncludes(Module *M) const {
   if (ExternalSource)
     return ExternalSource->getIncludedFiles(M);
   return nullptr;
 }

clang/lib/Serialization/ASTReader.cpp

case MACRO_OFFSET: {
       break;
     }
 
     case PP_NUM_INCLUDES: {
       if (F.isModule())
         break;
 
       for (const auto &E : readIncludedFiles(F, Record))
-        PP.incrementTransitiveIncludeCount(E.getFirst(), E.getSecond());
+        PP.incrementTransitiveIncludeCount(E.getFirst(),
+                                           E.getSecond().NumIncludes);
       break;
     }
 
     case LATE_PARSED_TEMPLATE:
       LateParsedTemplates.emplace_back(
           std::piecewise_construct, std::forward_as_tuple(&F),
           std::forward_as_tuple(Record.begin(), Record.end()));
       break;
ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
   ContinuousRangeMap<uint32_t, int, 2>::iterator I
     = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
   assert(I != M.SubmoduleRemap.end()
          && "Invalid index into submodule index remap");
 
   return LocalID + I->second;
 }
 
-llvm::DenseMap<const FileEntry *, unsigned>
-ASTReader::readIncludedFiles(ModuleFile &F, RecordData &Record) {
+Preprocessor::IncludeInfoMap ASTReader::readIncludedFiles(ModuleFile &F,
+                                                          RecordData &Record) {
   unsigned Idx = 0;
   unsigned TotalCount = Record[Idx++];
   unsigned IncludedOnceCount = Record[Idx++];
 
   auto ReadFile = [&]() -> OptionalFileEntryRefDegradesToFileEntryPtr {
     unsigned InputFileID = Record[Idx++];
     auto InputFileInfo = readInputFileInfo(F, InputFileID);
     return FileMgr.getOptionalFileRef(InputFileInfo.Filename);
   };
 
-  llvm::DenseMap<const FileEntry *, unsigned> Result;
+  Preprocessor::IncludeInfoMap Result;
   for (unsigned I = 0; I < IncludedOnceCount; ++I)
     if (const FileEntry *File = ReadFile())
-      Result.insert({File, 1});
+      Result.insert({File, {1}});
   for (unsigned I = 0; I < TotalCount - IncludedOnceCount; ++I)
     if (const FileEntry *File = ReadFile())
-      Result.insert({File, 2}); // squash "more than one" include into exactly 2
+      Result.insert(
+          {File, {2}}); // squash "more than one" include into exactly 2
   return Result;
 }
 
-const llvm::DenseMap<const FileEntry *, unsigned> *
-ASTReader::getIncludedFiles(Module *M) {
+const Preprocessor::IncludeInfoMap *ASTReader::getIncludedFiles(Module *M) {
   ModuleFile *F = getModuleManager().lookup(M->getASTFile());
   if (!F)
     return nullptr;
 
-  auto ResultIt = SubmoduleIncludedFiles.insert(
-      {M, llvm::DenseMap<const FileEntry *, unsigned>{}});
-  auto &Result = ResultIt.first->second;
+  auto ResultIt =
+      SubmoduleIncludedFiles.insert({M, Preprocessor::IncludeInfoMap{}});
+  Preprocessor::IncludeInfoMap &Result = ResultIt.first->second;
   if (!ResultIt.second)
     return &Result;
 
   auto It = F->SubmoduleIncludedFiles.find(M->getFullModuleName());
   if (It == F->SubmoduleIncludedFiles.end())
     return nullptr;
   auto &Record = It->second;
 

clang/lib/Serialization/ASTWriter.cpp

 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TargetOptions.h"
 #include "clang/Basic/Version.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/MacroInfo.h"
 #include "clang/Lex/ModuleMap.h"
 #include "clang/Lex/PreprocessingRecord.h"
-#include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Lex/Token.h"
 #include "clang/Sema/IdentifierResolver.h"
 #include "clang/Sema/ObjCMethodList.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/Weak.h"
 #include "clang/Serialization/ASTBitCodes.h"
 #include "clang/Serialization/ASTReader.h"
if (Loc.isInvalid())
       return true;
     if (PP.getSourceManager().getFileID(Loc) == PP.getPredefinesFileID())
       return true;
   }
 
   return false;
 }
 
-void ASTWriter::addIncludedFiles(
-    const llvm::DenseMap<const FileEntry *, unsigned> &Files,
+void ASTWriter::addIncludedFiles(const Preprocessor::IncludeInfoMap &Files,
                                  RecordDataImpl &Record) {
   // Map the FileEntry map into an input file ID vector.
   llvm::SmallVector<std::pair<uint64_t, unsigned>> FileIDs;
   for (const auto &E : Files) {
     auto InputFileIt = InputFileIDs.find(E.first);
     assert(InputFileIt != InputFileIDs.end() &&
            "Included file is an known input file");
-    FileIDs.emplace_back(InputFileIt->second, E.second);
+    FileIDs.emplace_back(InputFileIt->second, E.second.NumIncludes);
   }
 
   // Ensure the order is stable.
   llvm::sort(FileIDs, [](const auto &LHS, const auto &RHS) {
     return LHS.first < RHS.first;
   });
 
   // [begin, It) - included exactly once
void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) {
 
   unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
   {
     RecordData::value_type Record[] = {MACRO_OFFSET, MacroOffsets.size(),
                                        FirstMacroID - NUM_PREDEF_MACRO_IDS,
                                        MacroOffsetsBase - ASTBlockStartOffset};
     Stream.EmitRecordWithBlob(MacroOffsetAbbrev, Record, bytes(MacroOffsets));
   }
-
-  addIncludedFiles(PP.getNullSubmoduleIncludes(), Record);
-  Stream.EmitRecord(PP_NUM_INCLUDES, Record);
-  Record.clear();
 }
 
 void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec,
                                         uint64_t MacroOffsetsBase) {
   if (PPRec.local_begin() == PPRec.local_end())
     return;
 
   SmallVector<PPEntityOffset, 64> PreprocessedEntityOffsets;
if (!Inits.empty())
       Stream.EmitRecord(SUBMODULE_INITIALIZERS, Inits);
 
     // Emit the name of the re-exported module, if any.
     if (!Mod->ExportAsModule.empty()) {
       RecordData::value_type Record[] = {SUBMODULE_EXPORT_AS};
       Stream.EmitRecordWithBlob(ExportAsAbbrev, Record, Mod->ExportAsModule);
     }
 
-    if (const auto *Includes = PP->getLocalSubmoduleIncludes(Mod)) {
+    if (const Preprocessor::IncludeInfoMap *Includes =
+            PP->getLocalSubmoduleIncludes(Mod)) {
       RecordData Record;
       addIncludedFiles(*Includes, Record);
       Stream.EmitRecord(SUBMODULE_NUM_INCLUDES, Record);
       Record.clear();
     }
 
     // Queue up the submodules of this module.
     for (auto *M : Mod->submodules())