Split up debug info and debug abbrev section in the flatv1 schema, and add options to control which debug information blocks to split

Author: rastogishubham

llvm/include/llvm/CASObjectFormats/Data.h

@@ -124,7 +124,8 @@ class BlockData {
   /// \p Fixups add no storage cost if they are not used.
   static void encode(uint64_t Size, uint64_t Alignment,
                      uint64_t AlignmentOffset, Optional<StringRef> Content,
-                     ArrayRef<Fixup> Fixups, SmallVectorImpl<char> &Data);
+                     ArrayRef<Fixup> Fixups, SmallVectorImpl<char> &Data,
+                     bool IsDebugInfoBlock = false);
 
   Error decode(uint64_t &Size, uint64_t &Alignment, uint64_t &AlignmentOffset,
                Optional<StringRef> &Content, FixupList &Fixups) const;

llvm/include/llvm/CASObjectFormats/FlatV1.h

@@ -208,7 +208,8 @@ class BlockRef : public SpecificRef<BlockRef> {
   static constexpr StringLiteral KindString = "cas.o:block";
 
   static Expected<BlockRef> create(CompileUnitBuilder &CUB,
-                                   const jitlink::Block &Block);
+                                   const jitlink::Block &Block,
+                                   cas::CASID *AbbrevID = nullptr);
 
   static Expected<BlockRef> get(Expected<ObjectFormatObjectProxy> Ref);
   static Expected<BlockRef> get(const ObjectFileSchema &Schema,
@@ -313,6 +314,8 @@ class CompileUnitBuilder {
 
   Error createSection(const jitlink::Section &S);
   Error createBlock(const jitlink::Block &B);
+  Expected<cas::CASID> createAbbrevBlock(const jitlink::Block &B);
+  Error createInfoBlock(const jitlink::Block &B, cas::CASID *AbbrevID);
   Error createSymbol(const jitlink::Symbol &S);
 
   // Lookup functions. The result must exist in the cache already.

llvm/include/llvm/ExecutionEngine/JITLink/DWARFRecordSectionSplitter.h

@@ -21,10 +21,15 @@ namespace jitlink {
 class DWARFRecordSectionSplitter {
 public:
   DWARFRecordSectionSplitter(StringRef SectionName);
-  Error operator()(LinkGraph &G);
+  Error operator()(LinkGraph &G,
+                   std::vector<uint64_t> *AbbrevOffsets = nullptr);
 
 private:
-  Error processBlock(LinkGraph &G, Block &B, LinkGraph::SplitBlockCache &Cache);
+  Error processBlock(LinkGraph &G, Block &B);
+  Error processDebugInfoBlock(LinkGraph &G, Block &B,
+                              std::vector<uint64_t> *AbbrevOffsets);
+  Error processDebugAbbrevBlock(LinkGraph &G, Block &B,
+                                std::vector<uint64_t> *AbbrevOffsets);
 
   StringRef SectionName;
 };

llvm/lib/CASObjectFormats/Data.cpp

@@ -60,7 +60,8 @@ void FixupList::iterator::decode(bool IsInit) {
 
 void BlockData::encode(uint64_t Size, uint64_t Alignment,
                        uint64_t AlignmentOffset, Optional<StringRef> Content,
-                       ArrayRef<Fixup> Fixups, SmallVectorImpl<char> &Data) {
+                       ArrayRef<Fixup> Fixups, SmallVectorImpl<char> &Data,
+                       bool IsDebugInfoBlock) {
   assert(!Content || Size == Content->size() && "Mismatched content size");
   assert(Alignment && "Expected non-zero alignment");
   assert(isPowerOf2_64(Alignment) && "Expected alignment to be a power of 2");
@@ -81,8 +82,48 @@ void BlockData::encode(uint64_t Size, uint64_t Alignment,
                  (unsigned(IsZeroFill) << IsZeroFillBit));
 
   encoding::writeVBR8(Size, Data);
-  if (Content)
-    Data.append(Content->begin(), Content->end());
+  if (Content) {
+    if (!IsDebugInfoBlock) {
+      Data.append(Content->begin(), Content->end());
+    } else {
+      // This is a debug info block, the abbreviation offset can cause
+      // deduplication to fail, handle it here.
+      StringRef SizeOfUnit = Content->substr(0, 4);
+      unsigned SizeOfUnitInt = 0;
+      SizeOfUnitInt |= SizeOfUnit[3];
+      SizeOfUnitInt <<= 8;
+      SizeOfUnitInt |= SizeOfUnit[2];
+      SizeOfUnitInt <<= 8;
+      SizeOfUnitInt |= SizeOfUnit[1];
+      SizeOfUnitInt <<= 8;
+      SizeOfUnitInt |= SizeOfUnit[0];
+      if (SizeOfUnitInt != 0xffffffff) {
+        // This is a 32-bit DWARF format, copy the first 6 bytes for size and
+        // DWARF version, skip the next 4 bytes and copy 0's, then copy the
+        // rest.
+        Data.append(Content->begin(), Content->begin() + 6);
+        Data.push_back(0);
+        Data.push_back(0);
+        Data.push_back(0);
+        Data.push_back(0);
+        Data.append(Content->begin() + 10, Content->end());
+      } else {
+        // This is a 64-bit DWARF format, copy the first 16 bytes for size,
+        // DWARF version, unit type, and address size, skip the next 8 bytes and
+        // copy 0's, then copy the rest.
+        Data.append(Content->begin(), Content->begin() + 16);
+        Data.push_back(0);
+        Data.push_back(0);
+        Data.push_back(0);
+        Data.push_back(0);
+        Data.push_back(0);
+        Data.push_back(0);
+        Data.push_back(0);
+        Data.push_back(0);
+        Data.append(Content->begin() + 24, Content->end());
+      }
+    }
+  }
   FixupList::encode(Fixups, Data);
 
   if (!HasAlignmentOffset)

llvm/lib/CASObjectFormats/FlatV1.cpp

@@ -321,11 +321,20 @@ static Error decodeFixup(const FlatV1ObjectReader &Reader, StringRef &Data,
 }
 
 Expected<BlockRef> BlockRef::create(CompileUnitBuilder &CUB,
-                                    const jitlink::Block &Block) {
+                                    const jitlink::Block &Block,
+                                    cas::CASID *AbbrevID) {
   Expected<Builder> B = Builder::startNode(CUB.Schema, KindString);
   if (!B)
     return B.takeError();
 
+  bool IsDebugInfoBlock = false;
+  // If we are creating a cas block out of a debug_info jitlink::Block, add the
+  // debug_abbrev cas block CAS ID as a refrence
+  if (Block.getSection().getName() == "__DWARF,__debug_info") {
+    B->IDs.push_back(*AbbrevID);
+    IsDebugInfoBlock = true;
+  }
+
   // Encode Section.
   auto SectionIndex = CUB.getSectionIndex(Block.getSection());
   if (!SectionIndex)
@@ -366,11 +375,10 @@ Expected<BlockRef> BlockRef::create(CompileUnitBuilder &CUB,
       return std::move(E);
     BlockSize = Content->size();
   }
-
   SmallString<1024> EncodeContent;
   data::BlockData::encode(BlockSize, Block.getAlignment(),
                           Block.getAlignmentOffset(), Content, Fixups,
-                          EncodeContent);
+                          EncodeContent, IsDebugInfoBlock);
 
   StringRef BlockData(EncodeContent);
   // Encode content first with size and data.
@@ -689,12 +697,37 @@ Error CompileUnitBuilder::createSection(const jitlink::Section &S) {
 }
 
 Error CompileUnitBuilder::createBlock(const jitlink::Block &B) {
+  if (B.getSection().getName() == "__DWARF,__debug_abbrev" ||
+      B.getSection().getName() == "__DWARF,__debug_info")
+    return Error::success();
+  // Store the current idx. It is created in order so just add in the end.
+  BlockIndexStarts.push_back(Indexes.size());
+  auto Block = BlockRef::create(*this, B);
+  if (!Block)
+    return Block.takeError();
+  commitNode(*Block);
+  return Error::success();
+}
+
+Expected<cas::CASID>
+CompileUnitBuilder::createAbbrevBlock(const jitlink::Block &B) {
   // Store the current idx. It is created in order so just add in the end.
   BlockIndexStarts.push_back(Indexes.size());
   auto Block = BlockRef::create(*this, B);
   if (!Block)
     return Block.takeError();
   commitNode(*Block);
+  return Block->getID();
+}
+
+Error CompileUnitBuilder::createInfoBlock(const jitlink::Block &B,
+                                          cas::CASID *AbbrevID) {
+  // Store the current idx. It is created in order so just add in the end.
+  BlockIndexStarts.push_back(Indexes.size());
+  auto Block = BlockRef::create(*this, B, AbbrevID);
+  if (!Block)
+    return Block.takeError();
+  commitNode(*Block);
   return Error::success();
 }
 
@@ -792,8 +825,24 @@ Expected<CompileUnitRef> CompileUnitRef::create(const ObjectFileSchema &Schema,
     llvm::sort(Builder.Blocks.begin() + PreviousSize, Builder.Blocks.end(),
                compareBlocksByAddress);
   };
-  for (const jitlink::Section &Section : G.sections())
+  SmallVector<const jitlink::Block *, 16> AbbrevBlocks;
+  SmallVector<const jitlink::Block *, 16> InfoBlocks;
+  for (const jitlink::Section &Section : G.sections()) {
+    if (Section.getName() == "__DWARF,__debug_abbrev")
+      AbbrevBlocks.append(Section.blocks().begin(), Section.blocks().end());
+    else if (Section.getName() == "__DWARF,__debug_info")
+      InfoBlocks.append(Section.blocks().begin(), Section.blocks().end());
     appendBlocks(Section.blocks());
+  }
+  // If the number of debug_abbrev blocks are 1, we assume that the
+  // abbreviations could not be split up, and every debug_info compile unit
+  // should have a reference to the same abbreviation.
+  assert(AbbrevBlocks.size() == 1 ||
+         AbbrevBlocks.size() == InfoBlocks.size() &&
+             "The number of Abbreviation contributions should be equal to the "
+             "number of Compile Units");
+  llvm::sort(InfoBlocks.begin(), InfoBlocks.end(), compareBlocksByAddress);
+  llvm::sort(AbbrevBlocks.begin(), AbbrevBlocks.end(), compareBlocksByAddress);
 
 #ifndef NDEBUG
   for (auto *S : makeArrayRef(Symbols).slice(0, DefinedSymbolsSize))
@@ -815,6 +864,22 @@ Expected<CompileUnitRef> CompileUnitRef::create(const ObjectFileSchema &Schema,
       return std::move(E);
   }
 
+  // Create BlockRefs for Abbrevs and Compile Units
+  SmallVector<cas::CASID, 16> AbbrevIDs;
+  for (auto *B : AbbrevBlocks) {
+    Expected<cas::CASID> ID = Builder.createAbbrevBlock(*B);
+    if (!ID)
+      return ID.takeError();
+    AbbrevIDs.push_back(*ID);
+  }
+  unsigned I = 0;
+  for (auto *B : InfoBlocks) {
+    if (auto E = Builder.createInfoBlock(
+            *B, AbbrevIDs.size() == 1 ? &AbbrevIDs[0] : &AbbrevIDs[I]))
+      return std::move(E);
+    I++;
+  }
+
   auto B = Builder::startRootNode(Schema, KindString);
   if (!B)
     return B.takeError();