[clang][lex][modules] Stop tracking number of includes

[jansvoboda11]

Summary

This patch stops tracking the number of includes of a file. The information is not used anywhere except for stat printing. Only tracking the fact whether a file was included or not simplifies the code and should be more efficient.

Depends on D114095.

[dexonsmith]

I have a couple of nits inline, but otherwise LGTM if you squash with https://reviews.llvm.org/D114095.

clang/include/clang/Lex/Preprocessor.h

1230–1232

Looks like the comment (and function name) are bitrotting here. For the name, I suggest trackIncludeFile() or something.

1242

A using declaration for the DenseSet might be nice.

[jansvoboda11]

Squashed into D114095.

clang/include/clang/Lex/Preprocessor.h

private:
 
   /// 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;
 
-  /// The number of times each file was included.
-  llvm::DenseMap<const FileEntry *, unsigned short> IncludedFiles;
+  /// The files that have been included.
+  llvm::DenseSet<const FileEntry *> IncludedFiles;
 
   /// 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
public:
   macros(bool IncludeExternalMacros = true) const {
     macro_iterator begin = macro_begin(IncludeExternalMacros);
     macro_iterator end = macro_end(IncludeExternalMacros);
     return llvm::make_range(begin, end);
   }
 
   /// \}
 
   /// Increment the count for the number of times the specified FileEntry has
   /// been entered. Returns true if this is the first time it file was included.
   bool incrementIncludeCount(const FileEntry *File) {
-    auto It = IncludedFiles.insert({File, 0});
-    ++It.first->second;
-    return It.second;
+    return IncludedFiles.insert(File).second;
   }
 
   /// Return true if this header has already been included.
   bool alreadyIncluded(const FileEntry *File) const {
     return IncludedFiles.count(File);
   }
 
-  /// Get the included files along with the include count.
-  llvm::DenseMap<const FileEntry *, unsigned short> &getIncludedFiles() {
+  /// Get the included files.
+  llvm::DenseSet<const FileEntry *> &getIncludedFiles() {
     return IncludedFiles;
   }
-  const llvm::DenseMap<const FileEntry *, unsigned short> &
-  getIncludedFiles() const {
+  const llvm::DenseSet<const FileEntry *> &getIncludedFiles() const {
     return IncludedFiles;
   }
 
   /// 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;

clang/lib/Lex/Preprocessor.cpp

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";
 
-  unsigned MaxNumIncludes = 0, NumSingleIncludedFiles = 0;
-  for (const auto &IncludedFile : IncludedFiles) {
-    if (MaxNumIncludes < IncludedFile.second)
-      MaxNumIncludes = IncludedFile.second;
-    NumSingleIncludedFiles += IncludedFile.second == 1;
-  }
-  llvm::errs() << NumSingleIncludedFiles << " 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: "
                << llvm::capacity_in_bytes(MacroExpandedTokens);
   llvm::errs() << "\n  Predefines Buffer: " << Predefines.capacity();
   // FIXME: List information for all submodules.
   llvm::errs() << "\n  Macros: "

clang/lib/Serialization/ASTReader.cpp

 
 void ASTReader::readIncludedFiles(ModuleFile &F, StringRef Blob,
                                   Preprocessor &PP) {
   using namespace llvm::support;
 
   const unsigned char *D = (const unsigned char *)Blob.data();
   unsigned FileCount = endian::readNext<uint32_t, little, unaligned>(D);
 
-  for (unsigned I = 0; I < FileCount; ++I) {
-    auto InputFileID = endian::readNext<uint32_t, little, unaligned>(D);
-    auto NumIncludes = endian::readNext<uint16_t, little, unaligned>(D);
-
-    auto InputFileInfo = readInputFileInfo(F, InputFileID);
-    if (auto File = PP.getFileManager().getFile(InputFileInfo.Filename)) {
-      unsigned short &PPNumIncludes = PP.getIncludedFiles()[*File];
-      PPNumIncludes = std::max(PPNumIncludes, NumIncludes);
-    }
+  for (unsigned I = 0; I < FileCount; ++D)
+    for (unsigned Bit = 0; Bit < 8 && I < FileCount; ++Bit, ++I)
+      if (*D & (1 << Bit)) {
+        auto InputFileInfo = readInputFileInfo(F, I);
+        if (auto File = PP.getFileManager().getFile(InputFileInfo.Filename))
+          PP.getIncludedFiles().insert(*File);
       }
 }
 
 llvm::Error ASTReader::ReadASTBlock(ModuleFile &F,
                                     unsigned ClientLoadCapabilities) {
   BitstreamCursor &Stream = F.Stream;
 
   if (llvm::Error Err = Stream.EnterSubBlock(AST_BLOCK_ID))
     return Err;

clang/lib/Serialization/ASTWriter.cpp

static bool shouldIgnoreMacro(MacroDirective *MD, bool IsModule,
   }
 
   return false;
 }
 
 void ASTWriter::writeIncludedFiles(raw_ostream &Out, const Preprocessor &PP) {
   using namespace llvm::support;
 
-  std::vector<std::pair<uint32_t, unsigned short>> IncludedInputFiles;
+  std::vector<bool> IncludedInputFiles;
   for (const auto &File : PP.getIncludedFiles()) {
-    auto InputFileIt = InputFileIDs.find(File.first);
-    if (InputFileIt != InputFileIDs.end())
-      IncludedInputFiles.emplace_back(InputFileIt->second, File.second);
+    auto InputFileIt = InputFileIDs.find(File);
+    if (InputFileIt == InputFileIDs.end())
+      continue;
+    auto InputFileID = InputFileIt->second;
+    if (IncludedInputFiles.size() <= InputFileID)
+      IncludedInputFiles.resize(InputFileID + 1);
+    IncludedInputFiles[InputFileIt->second] = true;
   }
 
-  llvm::sort(IncludedInputFiles);
-
   endian::Writer LE(Out, little);
   LE.write<uint32_t>(IncludedInputFiles.size());
-
-  for (const auto &IncludedInputFile : IncludedInputFiles) {
-    LE.write<uint32_t>(IncludedInputFile.first);
-    LE.write<uint16_t>(IncludedInputFile.second);
-  }
+  Out << bytes(IncludedInputFiles);
 }
 
 /// Writes the block containing the serialized form of the
 /// preprocessor.
 void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) {
   uint64_t MacroOffsetsBase = Stream.GetCurrentBitNo();
 
   PreprocessingRecord *PPRec = PP.getPreprocessingRecord();