Introduce debug_str_offsets representation in MCCAS

MCCAS has an ability to have different block types for different data,
this patch introduces DebugStrOffsetsRef and
DebugStringOffsetsSectionRef to represent the debug_str_offsets section
in DWARF5.

Author: rastogishubham

llvm/include/llvm/MCCAS/MCCASObjectV1.def

@@ -18,6 +18,7 @@ CASV1_SIMPLE_DATA_REF(DataInCodeRef, mc:data_in_code)
 CASV1_SIMPLE_DATA_REF(CStringRef, mc:cstring)
 CASV1_SIMPLE_DATA_REF(MergedFragmentRef, mc:merged_fragment)
 CASV1_SIMPLE_DATA_REF(DebugStrRef, mc:debug_string)
+CASV1_SIMPLE_DATA_REF(DebugStrOffsetsRef, mc:debug_string_offsets)
 CASV1_SIMPLE_DATA_REF(DebugLineRef, mc:debug_line)
 CASV1_SIMPLE_DATA_REF(DebugLineUnoptRef, mc:debug_line_unopt)
 CASV1_SIMPLE_DATA_REF(DebugInfoUnoptRef, mc:debug_info_unopt)
@@ -40,6 +41,7 @@ CASV1_SIMPLE_GROUP_REF(DebugLineSectionRef, mc:debug_line_section)
 CASV1_SIMPLE_GROUP_REF(AtomRef, mc:atom)
 CASV1_SIMPLE_GROUP_REF(SymbolTableRef, mc:symbol_table)
 CASV1_SIMPLE_GROUP_REF(DebugStringSectionRef, mc:debug_string_section)
+CASV1_SIMPLE_GROUP_REF(DebugStringOffsetsSectionRef, mc:debug_string_offsets_section)
 CASV1_SIMPLE_GROUP_REF(DIEAbbrevSetRef, mc:debug_DIE_abbrev_set)
 CASV1_SIMPLE_GROUP_REF(DIETopLevelRef, mc:debug_DIE_top_level)
 CASV1_SIMPLE_GROUP_REF(DIEDedupeTopLevelRef, mc:debug_DIE_Dedupe_top_level)

llvm/include/llvm/MCCAS/MCCASObjectV1.h

@@ -599,6 +599,10 @@ class MCCASBuilder {
   // string in the section.
   Error createDebugStrSection();
 
+  // If a DWARF String Offsets section exists, create a DebugStrOffsetsRef CAS
+  // object for the section.
+  Error createDebugStrOffsetsSection();
+
   /// If there is any padding between one section and the next, create a
   /// PaddingRef CAS object to represent the bytes of Padding between the two
   /// sections.

llvm/lib/MCCAS/MCCASObjectV1.cpp

@@ -765,6 +765,20 @@ static Error createGenericDebugSection(MCCASBuilder &MB,
   return Error::success();
 }
 
+Expected<DebugStringOffsetsSectionRef>
+DebugStringOffsetsSectionRef::create(MCCASBuilder &MB,
+                                     ArrayRef<cas::ObjectRef> Fragments) {
+  Expected<Builder> B = Builder::startNode(MB.Schema, KindString);
+  if (!B)
+    return B.takeError();
+
+  if (auto E = createGenericDebugSection<DebugStringOffsetsSectionRef>(
+          MB, Fragments, B->Data, B->Refs))
+    return E;
+
+  return get(B->build());
+}
+
 Expected<uint64_t> SectionRef::materialize(MCCASReader &Reader,
                                            raw_ostream *Stream) const {
   // Start a new section for relocations.
@@ -1218,6 +1232,14 @@ static Expected<uint64_t> materializeGenericDebugSection(MCCASReader &Reader,
   return Size;
 }
 
+Expected<uint64_t>
+DebugStringOffsetsSectionRef::materialize(MCCASReader &Reader,
+                                          raw_ostream *Stream) const {
+  StringRef Remaining = getData();
+  return materializeGenericDebugSection<DebugStringOffsetsSectionRef>(
+      Reader, Remaining, *this);
+}
+
 Expected<AtomRef> AtomRef::create(MCCASBuilder &MB,
                                   ArrayRef<cas::ObjectRef> Fragments) {
   Expected<Builder> B = Builder::startNode(MB.Schema, KindString);
@@ -2373,6 +2395,23 @@ MCCASBuilder::createGenericDebugRef(MCSection *Section) {
   return *DebugCASRef;
 }
 
+Error MCCASBuilder::createDebugStrOffsetsSection() {
+
+  auto MaybeDebugStringOffsetsRef =
+      createGenericDebugRef<DebugStrOffsetsRef>(DwarfSections.StrOffsets);
+  if (!MaybeDebugStringOffsetsRef)
+    return Error::success();
+
+  if (!*MaybeDebugStringOffsetsRef)
+    return MaybeDebugStringOffsetsRef->takeError();
+
+  startSection(DwarfSections.StrOffsets);
+  addNode(**MaybeDebugStringOffsetsRef);
+  if (auto E = createPaddingRef(DwarfSections.StrOffsets))
+    return E;
+  return finalizeSection<DebugStringOffsetsSectionRef>();
+}
+
 static ArrayRef<char> getFragmentContents(const MCFragment &Fragment) {
   switch (Fragment.getKind()) {
 #define MCFRAGMENT_NODE_REF(MCFragmentName, MCEnumName, MCEnumIdentifier)      \
@@ -2504,6 +2543,13 @@ Error MCCASBuilder::buildFragments() {
       continue;
     }
 
+    // Handle Debug Str Offsets sections separately.
+    if (&Sec == DwarfSections.StrOffsets) {
+      if (auto E = createDebugStrOffsetsSection())
+        return E;
+      continue;
+    }
+
     // Start Subsection for one section.
     startSection(&Sec);
 
@@ -2663,7 +2709,7 @@ void MCCASBuilder::startSection(const MCSection *Sec) {
       // For the Dwarf Sections, just append the relocations to the
       // SectionRelocs. No Atoms are considered for this section.
       if (R.F && Sec != DwarfSections.Line && Sec != DwarfSections.DebugInfo &&
-          Sec != DwarfSections.Abbrev)
+          Sec != DwarfSections.Abbrev && Sec != DwarfSections.StrOffsets)
         RelMap[R.F].push_back(R.MRE);
       else
         // If the fragment is nullptr, it should a section with only relocation
@@ -2866,6 +2912,8 @@ Expected<uint64_t> MCCASReader::materializeGroup(cas::ObjectRef ID) {
     return F->materialize(*this);
   if (auto F = DebugStringSectionRef::Cast(*Node))
     return F->materialize(*this);
+  if (auto F = DebugStringOffsetsSectionRef::Cast(*Node))
+    return F->materialize(*this);
   if (auto F = CStringRef::Cast(*Node)) {
     auto Size = F->materialize(OS);
     if (!Size)
@@ -2930,6 +2978,8 @@ Expected<uint64_t> MCCASReader::materializeSection(cas::ObjectRef ID,
     Stream->write_zeros(1);
     return *Size + 1;
   }
+  if (auto F = DebugStrOffsetsRef::Cast(*Node))
+    return F->materialize(*Stream);
   if (auto F = AddendsRef::Cast(*Node))
     // AddendsRef is already handled when materializing Atoms, skip.
     return 0;