[Serialization] Compress serialized macro expansion SLocEntries

[sammccall]

Summary

Macro expansion SLocEntries are significant to PCH size (7-10% in my tests).
These store the expansion end location as vbr8. However it's highly predictable:

• for macro arg expansion it's zero
• for object macros it equals the expansion start
• for function macros it's usually shortly after the expansion start

Instead, this change stores (bool relative, unsigned value).
If relative is true, ExpEnd is ExpBegin+value, otherwise it's just value.
We define abbreviations to cover the common cases above.

This saves ~15% of SM_SLOC_EXPANSION, which is 1-1.5% of overall PCH size.

[ilya-biryukov]

clang/lib/Serialization/ASTWriter.cpp

2181

NIT: maybe avoid the lambda? The code is short enough to be readable without early returns:

unsigned Abbrev = 0;
if (Expansion.isExpansionTokenRange()) {
  if (Expansion.isMacroArgExpansion())
    Abbrev = SLocArgExpansionAbbrv;
  else if (EndIsRelative && Expansion.isFunctionMacroExpansion())
    Abbrev = SLocFunctionExpansionAbbrv;
  else if (EndIsRelative)
    Abbrev = SLocObjectExpansionAbbrv;
}

2195

It's probably obvious, but I'm not an expert in bitcode format.

Can we have larger records now than before? Are any records emitted without abbreviations larger than with abbreviations?

clang/lib/Serialization/ASTReader.cpp

if (!Buffer)
       return true;
     SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
                            BaseOffset + Offset, IncludeLoc);
     break;
   }
 
   case SM_SLOC_EXPANSION_ENTRY: {
     SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
-    SourceMgr.createExpansionLoc(SpellingLoc,
-                                     ReadSourceLocation(*F, Record[2]),
-                                     ReadSourceLocation(*F, Record[3]),
-                                     Record[5],
-                                     Record[4],
-                                     ID,
-                                     BaseOffset + Record[0]);
+    unsigned SpellingLength = Record[2];
+    SourceLocation ExpansionStart = ReadSourceLocation(*F, Record[3]);
+    bool EndIsToken = Record[4];
+    bool EndIsRelative = Record[5];
+    SourceLocation ExpansionEnd =
+        EndIsRelative ? ExpansionStart.getLocWithOffset(Record[6])
+                      : ReadSourceLocation(*F, Record[6]);
+    SourceMgr.createExpansionLoc(SpellingLoc, ExpansionStart, ExpansionEnd,
+                                 SpellingLength, EndIsToken, ID,
     break;
   }
   }
 
   return false;
 }
 
 std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {

clang/lib/Serialization/ASTWriter.cpp

static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream,
   Abbrev->Add(BitCodeAbbrevOp(Compressed ? SM_SLOC_BUFFER_BLOB_COMPRESSED
                                          : SM_SLOC_BUFFER_BLOB));
   if (Compressed)
     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Uncompressed size
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob
   return Stream.EmitAbbrev(std::move(Abbrev));
 }
 
-/// Create an abbreviation for the SLocEntry that refers to a macro
-/// expansion.
-static unsigned CreateSLocExpansionAbbrev(llvm::BitstreamWriter &Stream) {
+/// We use a family of abbreviations for common cases of expansion SLocEntrys.
+static std::shared_ptr<llvm::BitCodeAbbrev> SLocExpansionAbbrevCommon() {
   using namespace llvm;
-
   auto Abbrev = std::make_shared<BitCodeAbbrev>();
   Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_EXPANSION_ENTRY));
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
-  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location
-  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location
-  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location
-  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Is token range
-  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length
+  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling start
+  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Spelling length
+  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Expansion start
+  Abbrev->Add(BitCodeAbbrevOp(1));                       // ExpEnd is token
+  return Abbrev;
+}
+
+/// Create an abbreviation for the SLocEntry that refers to a macro
+/// argument expansion.
+static unsigned CreateSLocArgExpansionAbbrev(llvm::BitstreamWriter &Stream) {
+  using namespace llvm;
+  auto Abbrev = SLocExpansionAbbrevCommon();
+  Abbrev->Add(BitCodeAbbrevOp(0)); // ExpEnd is relative
+  Abbrev->Add(BitCodeAbbrevOp(0)); // ExpEnd
+  return Stream.EmitAbbrev(std::move(Abbrev));
+}
+
+/// Create an abbreviation for the SLocEntry that refers to a macro
+/// expansion.
+static unsigned CreateSLocObjectExpansionAbbrev(llvm::BitstreamWriter &Stream) {
+  using namespace llvm;
+  auto Abbrev = SLocExpansionAbbrevCommon();
+  Abbrev->Add(BitCodeAbbrevOp(1)); // ExpEnd is relative
+  Abbrev->Add(BitCodeAbbrevOp(0)); // ExpEnd
+  return Stream.EmitAbbrev(std::move(Abbrev));
+}
+
+/// Create an abbreviation for the SLocEntry that refers to a function-like
+/// macro expansion.
+static unsigned
+CreateSLocFunctionExpansionAbbrev(llvm::BitstreamWriter &Stream) {
+  using namespace llvm;
+  auto Abbrev = SLocExpansionAbbrevCommon();
+  Abbrev->Add(BitCodeAbbrevOp(1));                       // ExpEnd is relative
+  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End
   return Stream.EmitAbbrev(std::move(Abbrev));
 }
 
 /// Emit key length and data length as ULEB-encoded data, and return them as a
 /// pair.
 static std::pair<unsigned, unsigned>
 emitULEBKeyDataLength(unsigned KeyLen, unsigned DataLen, raw_ostream &Out) {
   llvm::encodeULEB128(KeyLen, Out);
void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr,
   const uint64_t SourceManagerBlockOffset = Stream.GetCurrentBitNo();
 
   // Abbreviations for the various kinds of source-location entries.
   unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream);
   unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream);
   unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream, false);
   unsigned SLocBufferBlobCompressedAbbrv =
       CreateSLocBufferBlobAbbrev(Stream, true);
-  unsigned SLocExpansionAbbrv = CreateSLocExpansionAbbrev(Stream);
+  unsigned SLocArgExpansionAbbrv = CreateSLocArgExpansionAbbrev(Stream);
+  unsigned SLocObjectExpansionAbbrv = CreateSLocObjectExpansionAbbrev(Stream);
+  unsigned SLocFunctionExpansionAbbrv =
+      CreateSLocFunctionExpansionAbbrev(Stream);
 
   // Write out the source location entry table. We skip the first
   // entry, which is always the same dummy entry.
   std::vector<uint32_t> SLocEntryOffsets;
   uint64_t SLocEntryOffsetsBase = Stream.GetCurrentBitNo();
   RecordData PreloadSLocs;
   SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1);
   for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size();
if (SLoc->isFile()) {
         StringRef Blob(Buffer->getBufferStart(), Buffer->getBufferSize() + 1);
         emitBlob(Stream, Blob, SLocBufferBlobCompressedAbbrv,
                  SLocBufferBlobAbbrv);
       }
     } else {
       // The source location entry is a macro expansion.
       const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion();
       AddSourceLocation(Expansion.getSpellingLoc(), Record);
-      AddSourceLocation(Expansion.getExpansionLocStart(), Record);
-      AddSourceLocation(Expansion.isMacroArgExpansion()
-                            ? SourceLocation()
-                            : Expansion.getExpansionLocEnd(),
-                        Record);
-      Record.push_back(Expansion.isExpansionTokenRange());
-
-      // Compute the token length for this macro expansion.
+      // Compute the length for this macro expansion.
       SourceLocation::UIntTy NextOffset = SourceMgr.getNextLocalOffset();
       if (I + 1 != N)
         NextOffset = SourceMgr.getLocalSLocEntry(I + 1).getOffset();
       Record.push_back(NextOffset - SLoc->getOffset() - 1);
-      Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, Record);
+
+      // ExpStart, ExpEndIsToken, ExpEndIsRelative, ExpEnd
+      AddSourceLocation(Expansion.getExpansionLocStart(), Record);
+      Record.push_back(Expansion.isExpansionTokenRange());
+      SourceLocation ExpEnd = Expansion.isMacroArgExpansion()
+                                  ? SourceLocation()
+                                  : Expansion.getExpansionLocEnd();
+      SourceLocation::IntTy Delta;
+      bool EndIsRelative =
+          SourceMgr.isInSameSLocAddrSpace(Expansion.getExpansionLocStart(),
+                                          ExpEnd, &Delta) &&
+          Delta >= 0;
+      Record.push_back(EndIsRelative);
+      if (EndIsRelative)
+        Record.push_back(Delta);
+      else
+        AddSourceLocation(ExpEnd, Record);
+
+      // Common cases are covered by abbreviations.
+      unsigned Abbrev = [&]() -> unsigned {
+        if (!Expansion.isExpansionTokenRange()) // Token splits.
+          return 0;
+        if (Expansion.isMacroArgExpansion())
+          return SLocArgExpansionAbbrv;
+        if (!EndIsRelative) // Expansion start/end in different FileIDs.
+          return 0;
+        if (Expansion.isFunctionMacroExpansion())
+          return SLocFunctionExpansionAbbrv;
+        return SLocObjectExpansionAbbrv;
+      }();
+      if (Abbrev)
+        Stream.EmitRecordWithAbbrev(Abbrev, Record);
+      else
+        Stream.EmitRecord(SM_SLOC_EXPANSION_ENTRY,
+                          // To emit without abbrev, we must omit the code.
+                          llvm::makeArrayRef(Record).drop_front(1));
     }
   }
 
   Stream.ExitBlock();
 
   if (SLocEntryOffsets.empty())
     return;