[DWARFYAML] Make the debug_abbrev_offset field optional.

[Higuoxing]

Summary

This patch helps make the debug_abbrev_offset field optional. We don't
need to calculate the value of this field in the future.

[jhenderson]

For some reason, I didn't get any email notification about this review. Could you let me know if there are any other patches you want me to review, please?

llvm/lib/ObjectYAML/DWARFEmitter.cpp

99

We should probably not be using report_fatal_error here. Either an Expected needs returning up the stack, or this should be an assertion, depending on whether a user input could reach this case or not.

450–456

I might be misremembering the llvm-dev conversation, but I think the style is if any level of an if statement requires braces, they all do (i.e. please add them to the inner if).

455

Please add a comment saying why it's okay to consumeError here rather than report it.

[Higuoxing]

Address comments.

[Higuoxing]

In D86614#2241184, @jhenderson wrote:

For some reason, I didn't get any email notification about this review. Could you let me know if there are any other patches you want me to review, please?

All of my uploaded patches are reviewed, thanks!

[jhenderson]

LGTM, thanks.

llvm/lib/ObjectYAML/DWARFEmitter.cpp

457

llvm/include/llvm/ObjectYAML/DWARFYAML.h

 
 struct Unit {
   dwarf::DwarfFormat Format;
   Optional<yaml::Hex64> Length;
   uint16_t Version;
   Optional<uint8_t> AddrSize;
   llvm::dwarf::UnitType Type; // Added in DWARF 5
   Optional<uint64_t> AbbrevTableID;
-  yaml::Hex64 AbbrOffset;
+  Optional<yaml::Hex64> AbbrOffset;
   std::vector<Entry> Entries;
 };
 
 struct File {
   StringRef Name;
   uint64_t DirIdx;
   uint64_t ModTime;
   uint64_t Length;
struct Data {
 
   std::vector<LineTable> DebugLines;
   Optional<std::vector<ListTable<RnglistEntry>>> DebugRnglists;
   Optional<std::vector<ListTable<LoclistEntry>>> DebugLoclists;
 
   bool isEmpty() const;
 
   SetVector<StringRef> getNonEmptySectionNames() const;
-  Expected<uint64_t> getAbbrevTableIndexByID(uint64_t ID) const;
+
+  struct AbbrevTableInfo {
+    uint64_t Index;
+    uint64_t Offset;
+  };
+  Expected<AbbrevTableInfo> getAbbrevTableInfoByID(uint64_t ID) const;
+  StringRef getAbbrevTableContentByIndex(uint64_t Index) const;
 
 private:
-  mutable std::unordered_map<uint64_t, uint64_t> AbbrevTableID2Index;
+  mutable std::unordered_map<uint64_t, AbbrevTableInfo> AbbrevTableInfoMap;
+  mutable std::unordered_map<uint64_t, std::string> AbbrevTableContents;
 };
 
 } // end namespace DWARFYAML
 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AttributeAbbrev)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Abbrev)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AbbrevTable)

llvm/lib/ObjectYAML/DWARFEmitter.cpp

Error DWARFYAML::emitDebugStr(raw_ostream &OS, const DWARFYAML::Data &DI) {
   for (auto Str : DI.DebugStrings) {
     OS.write(Str.data(), Str.size());
     OS.write('\0');
   }
 
   return Error::success();
 }
 
-Error DWARFYAML::emitDebugAbbrev(raw_ostream &OS, const DWARFYAML::Data &DI) {
-  for (const DWARFYAML::AbbrevTable &AbbrevTable : DI.DebugAbbrev) {
-    uint64_t AbbrevCode = 0;
-    for (const DWARFYAML::Abbrev &AbbrevDecl : AbbrevTable.Table) {
-      AbbrevCode =
-          AbbrevDecl.Code ? (uint64_t)*AbbrevDecl.Code : AbbrevCode + 1;
-      encodeULEB128(AbbrevCode, OS);
-      encodeULEB128(AbbrevDecl.Tag, OS);
-      OS.write(AbbrevDecl.Children);
-      for (auto Attr : AbbrevDecl.Attributes) {
-        encodeULEB128(Attr.Attribute, OS);
-        encodeULEB128(Attr.Form, OS);
-        if (Attr.Form == dwarf::DW_FORM_implicit_const)
-          encodeSLEB128(Attr.Value, OS);
-      }
-      encodeULEB128(0, OS);
-      encodeULEB128(0, OS);
-    }
+StringRef DWARFYAML::Data::getAbbrevTableContentByIndex(uint64_t Index) const {
+  if (Index >= DebugAbbrev.size())
+    report_fatal_error("index out of range");
+
+  auto It = AbbrevTableContents.find(Index);
+  if (It != AbbrevTableContents.cend())
+    return It->second;
+
+  std::string AbbrevTableBuffer;
+  raw_string_ostream OS(AbbrevTableBuffer);
+
+  for (const DWARFYAML::Abbrev &AbbrevDecl : DebugAbbrev[Index].Table) {
+    AbbrevCode = AbbrevDecl.Code ? (uint64_t)*AbbrevDecl.Code : AbbrevCode + 1;
 
-    // The abbreviations for a given compilation unit end with an entry
-    // consisting of a 0 byte for the abbreviation code.
-    OS.write_zeros(1);
+
+  AbbrevTableContents.insert({Index, AbbrevTableBuffer});
+
+  return AbbrevTableContents[Index];
+}
+
+Error DWARFYAML::emitDebugAbbrev(raw_ostream &OS, const DWARFYAML::Data &DI) {
+  for (uint64_t I = 0; I < DI.DebugAbbrev.size(); ++I) {
+    StringRef AbbrevTableContent = DI.getAbbrevTableContentByIndex(I);
+    OS.write(AbbrevTableContent.data(), AbbrevTableContent.size());
   }
 
   return Error::success();
 }
 
 Error DWARFYAML::emitDebugAranges(raw_ostream &OS, const DWARFYAML::Data &DI) {
   assert(DI.DebugAranges && "unexpected emitDebugAranges() call");
   for (auto Range : *DI.DebugAranges) {
static Expected<uint64_t> writeDIE(const DWARFYAML::Data &DI, uint64_t CUIndex,
                                    const DWARFYAML::Entry &Entry,
                                    raw_ostream &OS, bool IsLittleEndian) {
   uint64_t EntryBegin = OS.tell();
   encodeULEB128(Entry.AbbrCode, OS);
   uint32_t AbbrCode = Entry.AbbrCode;
   if (AbbrCode == 0 || Entry.Values.empty())
     return OS.tell() - EntryBegin;
 
-  Expected<uint64_t> AbbrevTableIndexOrErr =
-      DI.getAbbrevTableIndexByID(AbbrevTableID);
-  if (!AbbrevTableIndexOrErr)
+  Expected<DWARFYAML::Data::AbbrevTableInfo> AbbrevTableInfoOrErr =
+      DI.getAbbrevTableInfoByID(AbbrevTableID);
+  if (!AbbrevTableInfoOrErr)
     return createStringError(errc::invalid_argument,
-                             toString(AbbrevTableIndexOrErr.takeError()) +
+                             toString(AbbrevTableInfoOrErr.takeError()) +
                                  " for compilation unit with index " +
                                  utostr(CUIndex));
 
   ArrayRef<DWARFYAML::Abbrev> AbbrevDecls(
-      DI.DebugAbbrev[*AbbrevTableIndexOrErr].Table);
+      DI.DebugAbbrev[AbbrevTableInfoOrErr->Index].Table);
 
   if (AbbrCode > AbbrevDecls.size())
     return createStringError(
         errc::invalid_argument,
         "abbrev code must be less than or equal to the number of "
         "entries in abbreviation table");
   const DWARFYAML::Abbrev &Abbrev = AbbrevDecls[AbbrCode - 1];
   auto FormVal = Entry.Values.begin();
for (uint64_t I = 0; I < DI.CompileUnits.size(); ++I) {
 
     // If the length is specified in the YAML description, we use it instead of
     // the actual length.
     if (Unit.Length)
       Length = *Unit.Length;
 
     writeInitialLength(Unit.Format, Length, OS, DI.IsLittleEndian);
     writeInteger((uint16_t)Unit.Version, OS, DI.IsLittleEndian);
+
+    uint64_t AbbrevTableOffset = 0;
+    if (Unit.AbbrOffset) {
+      AbbrevTableOffset = *Unit.AbbrOffset;
+    } else {
+      if (Expected<DWARFYAML::Data::AbbrevTableInfo> AbbrevTableInfoOrErr =
+              DI.getAbbrevTableInfoByID(AbbrevTableID))
+        AbbrevTableOffset = AbbrevTableInfoOrErr->Offset;
+      else
+        consumeError(AbbrevTableInfoOrErr.takeError());
+    }
+
     if (Unit.Version >= 5) {
       writeInteger((uint8_t)Unit.Type, OS, DI.IsLittleEndian);
       writeInteger((uint8_t)AddrSize, OS, DI.IsLittleEndian);
-      writeDWARFOffset(Unit.AbbrOffset, Unit.Format, OS, DI.IsLittleEndian);
+      writeDWARFOffset(AbbrevTableOffset, Unit.Format, OS, DI.IsLittleEndian);
     } else {
-      writeDWARFOffset(Unit.AbbrOffset, Unit.Format, OS, DI.IsLittleEndian);
+      writeDWARFOffset(AbbrevTableOffset, Unit.Format, OS, DI.IsLittleEndian);
       writeInteger((uint8_t)AddrSize, OS, DI.IsLittleEndian);
     }
 
     OS.write(EntryBuffer.data(), EntryBuffer.size());
   }
 
   return Error::success();
 }

llvm/lib/ObjectYAML/DWARFYAML.cpp

if (DebugStrOffsets)
     SecNames.insert("debug_str_offsets");
   if (DebugRnglists)
     SecNames.insert("debug_rnglists");
   if (DebugLoclists)
     SecNames.insert("debug_loclists");
   return SecNames;
 }
 
-Expected<uint64_t> DWARFYAML::Data::getAbbrevTableIndexByID(uint64_t ID) const {
-  if (AbbrevTableID2Index.empty()) {
+Expected<DWARFYAML::Data::AbbrevTableInfo>
+DWARFYAML::Data::getAbbrevTableInfoByID(uint64_t ID) const {
+  if (AbbrevTableInfoMap.empty()) {
+    uint64_t AbbrevTableOffset = 0;
     for (auto &AbbrevTable : enumerate(DebugAbbrev)) {
       // If the abbrev table's ID isn't specified, we use the index as its ID.
       uint64_t AbbrevTableID =
           AbbrevTable.value().ID.getValueOr(AbbrevTable.index());
-      auto It =
-          AbbrevTableID2Index.insert({AbbrevTableID, AbbrevTable.index()});
+      auto It = AbbrevTableInfoMap.insert(
+          {AbbrevTableID, AbbrevTableInfo{/*Index=*/AbbrevTable.index(),
+                                          /*Offset=*/AbbrevTableOffset}});
       if (!It.second)
         return createStringError(
             errc::invalid_argument,
             "the ID (%" PRIu64 ") of abbrev table with index %zu has been used "
             "by abbrev table with index %" PRIu64,
-            AbbrevTableID, AbbrevTable.index(), It.first->second);
+            AbbrevTableID, AbbrevTable.index(), It.first->second.Index);
+
+      AbbrevTableOffset +=
+          getAbbrevTableContentByIndex(AbbrevTable.index()).size();
     }
   }
 
-  auto It = AbbrevTableID2Index.find(ID);
-  if (It == AbbrevTableID2Index.end())
+  auto It = AbbrevTableInfoMap.find(ID);
+  if (It == AbbrevTableInfoMap.end())
     return createStringError(errc::invalid_argument,
                              "cannot find abbrev table whose ID is %" PRIu64,
                              ID);
   return It->second;
 }
 
 namespace yaml {
 

 
 void MappingTraits<DWARFYAML::Unit>::mapping(IO &IO, DWARFYAML::Unit &Unit) {
   IO.mapOptional("Format", Unit.Format, dwarf::DWARF32);
   IO.mapOptional("Length", Unit.Length);
   IO.mapRequired("Version", Unit.Version);
   if (Unit.Version >= 5)
     IO.mapRequired("UnitType", Unit.Type);
   IO.mapOptional("AbbrevTableID", Unit.AbbrevTableID);
-  IO.mapRequired("AbbrOffset", Unit.AbbrOffset);
+  IO.mapOptional("AbbrOffset", Unit.AbbrOffset);
   IO.mapOptional("AddrSize", Unit.AddrSize);
   IO.mapOptional("Entries", Unit.Entries);
 }
 
 void MappingTraits<DWARFYAML::Entry>::mapping(IO &IO, DWARFYAML::Entry &Entry) {
   IO.mapRequired("AbbrCode", Entry.AbbrCode);
   IO.mapOptional("Values", Entry.Values);
 }

llvm/test/tools/yaml2obj/ELF/DWARF/debug-info.yaml

debug_info:
     - Version:    4
       AbbrOffset: 0x00
       Entries:
         - AbbrCode: 1
           Values:
             - Value: 0x1234
 
 ## o) Test that yaml2obj is able to generate compilation units according to the
-## associated abbrev table that is referenced by the 'AbbrevTableID'.
+## associated abbrev table that is referenced by the 'AbbrevTableID' and infer
+## the value of the debug_abbrev_offset field.
 
 # RUN: yaml2obj --docnum=17 %s -o %t17.o
 # RUN: llvm-readelf --hex-dump=.debug_info %t17.o | FileCheck %s --check-prefix=MULTI-TABLES
 
 #      MULTI-TABLES: Hex dump of section '.debug_info':
 # MULTI-TABLES-NEXT: 0x00000000 0c000000 04000800 00000801 34120000 ............4...
 ##                              ^-------                            unit_length (4-byte)
 ##                                       ^---                       version (2-byte)
- ID: 1
           Tag:      DW_TAG_compile_unit
           Children: DW_CHILDREN_no
           Attributes:
             - Attribute: DW_AT_low_pc
               Form:      DW_FORM_udata
   debug_info:
     - Version:       4
       AbbrevTableID: 2
-      AbbrOffset:    8
       Entries:
         - AbbrCode: 1
           Values:
             - Value: 0x1234
     - Version:       4
       AbbrevTableID: 2
-      AbbrOffset:    8
       Entries:
         - AbbrCode: 1
           Values:
             - Value: 0x4321
     - Version:       4
       AbbrevTableID: 0
-      AbbrOffset:    0
       Entries:
         - AbbrCode: 1
           Values:
             - Value: 0x5678
     - Version:       4
       AbbrevTableID: 1
-      AbbrOffset:    16
       Entries:
         - AbbrCode: 1
           Values:
             - Value: 0x8765
+
+## p) Test that when the debug_abbrev_offset field isn't specified and there is no associated
+## abbrev table, yaml2obj will assign 0 to the debug_abbrev_offset field.
+
+# RUN: yaml2obj --docnum=18 %s -o %t18.o
+# RUN: llvm-readelf --hex-dump=.debug_info %t18.o | FileCheck %s --check-prefix=ZERO-OFFSET
+
+#      ZERO-OFFSET: Hex dump of section '.debug_info':
+# ZERO-OFFSET-NEXT: 0x00000000 07000000 04000000 000008            ...........
+##                             ^-------                            unit_length (4-byte)
+##                                      ^---                       version (2-byte)
+##                                          ^--------              debug_abbrev_offset (4-byte)
+##                                                   ^-            address_size (1-byte)
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+DWARF:
+  debug_info:
+    - Version:       4
+      AbbrevTableID: [[ABBREVID=<none>]]
+
+## q) Test that when we assign an invalid 'AbbrevTableID' that doesn't point to an abbrev table,
+## yaml2obj will assign 0 to the debug_abbrev_offset field.
+
+# RUN: yaml2obj --docnum=18 -DABBREVID=2 %s -o %t18.o
+# RUN: llvm-readelf --hex-dump=.debug_info %t18.o | FileCheck %s --check-prefix=ZERO-OFFSET

llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

 TEST(DWARFDebugInfo, TestEmptyChildren) {
   const char *yamldata = "debug_abbrev:\n"
                          "  - Table:\n"
                          "      - Code:            0x00000001\n"
                          "        Tag:             DW_TAG_compile_unit\n"
                          "        Children:        DW_CHILDREN_yes\n"
                          "debug_info:\n"
                          "  - Version:         4\n"
-                         "    AbbrOffset:      0\n"
                          "    AddrSize:        8\n"
                          "    Entries:\n"
                          "      - AbbrCode:        0x00000001\n"
                          "        Values:\n"
                          "      - AbbrCode:        0x00000000\n"
                          "        Values:\n";
 
   auto ErrOrSections = DWARFYAML::emitDebugSections(StringRef(yamldata));
debug_abbrev:
             Attributes:
               - Attribute:       DW_AT_name
                 Form:            DW_FORM_strp
               - Attribute:       DW_AT_type
                 Form:            DW_FORM_ref4
     debug_info:
       - Length:          22
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
           - AbbrCode:        0x00000002
             Values:
               - Value:           0x000000000000000D
debug_abbrev:
             Attributes:
               - Attribute:       DW_AT_name
                 Form:            DW_FORM_strp
               - Attribute:       DW_AT_type
                 Form:            DW_FORM_ref_addr
     debug_info:
       - Length:          22
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
           - AbbrCode:        0x00000002
             Values:
               - Value:           0x000000000000000D
debug_abbrev:
             Attributes:
               - Attribute:       DW_AT_name
                 Form:            DW_FORM_strp
               - Attribute:       DW_AT_ranges
                 Form:            DW_FORM_sec_offset
     debug_info:
       - Length:          16
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
               - Value:           0x0000000000001000
 
   )";
debug_abbrev:
               - Attribute:       DW_AT_name
                 Form:            DW_FORM_strp
               - Attribute:       DW_AT_ranges
                 Form:            DW_FORM_sec_offset
     debug_info:
       - Length:          17
         Version:         5
         UnitType:        DW_UT_compile
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
               - Value:           0x0000000000001000
 
   )";
debug_abbrev:
             Attributes:
               - Attribute:       DW_AT_name
                 Form:            DW_FORM_strp
               - Attribute:       DW_AT_stmt_list
                 Form:            DW_FORM_sec_offset
     debug_info:
       - Length:          16
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
               - Value:           0x0000000000001000
 
   )";
debug_abbrev:
             Tag:             DW_TAG_compile_unit
             Children:        DW_CHILDREN_no
             Attributes:
               - Attribute:       DW_AT_name
                 Form:            DW_FORM_strp
     debug_info:
       - Length:          12
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000001234
   )";
   auto ErrOrSections = DWARFYAML::emitDebugSections(StringRef(yamldata));
   ASSERT_TRUE((bool)ErrOrSections);
debug_abbrev:
             Attributes:
               - Attribute:       DW_AT_name
                 Form:            DW_FORM_strp
               - Attribute:       DW_AT_type
                 Form:            DW_FORM_ref_addr
     debug_info:
       - Length:          22
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
           - AbbrCode:        0x00000002
             Values:
               - Value:           0x000000000000000D
debug_abbrev:
             Attributes:
               - Attribute:       DW_AT_name
                 Form:            DW_FORM_strp
               - Attribute:       DW_AT_stmt_list
                 Form:            DW_FORM_sec_offset
     debug_info:
       - Length:          16
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
               - Value:           0x0000000000000000
     debug_line:
       - Length:          68
debug_abbrev:
             Attributes:
               - Attribute:       DW_AT_name
                 Form:            DW_FORM_strp
               - Attribute:       DW_AT_stmt_list
                 Form:            DW_FORM_sec_offset
     debug_info:
       - Length:          16
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
               - Value:           0x0000000000000000
     debug_line:
       - Length:          61
debug_abbrev:
             Attributes:
               - Attribute:       DW_AT_name
                 Form:            DW_FORM_strp
               - Attribute:       DW_AT_stmt_list
                 Form:            DW_FORM_sec_offset
     debug_info:
       - Length:          16
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
               - Value:           0x0000000000000000
     debug_line:
       - Length:          61
debug_abbrev:
             Attributes:
               - Attribute:       DW_AT_name
                 Form:            DW_FORM_strp
               - Attribute:       DW_AT_stmt_list
                 Form:            DW_FORM_sec_offset
     debug_info:
       - Length:          16
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
               - Value:           0x0000000000000000
     debug_line:
       - Length:          71
debug_abbrev:
             Attributes:
               - Attribute:       DW_AT_name
                 Form:            DW_FORM_strp
               - Attribute:       DW_AT_stmt_list
                 Form:            DW_FORM_sec_offset
     debug_info:
       - Length:          16
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
               - Value:           0x0000000000000000
       - Length:          16
         Version:         4
         AbbrevTableID:   0
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x000000000000000D
               - Value:           0x0000000000000000
     debug_line:
       - Length:          60
debug_abbrev:
             Attributes:
               - Attribute:       DW_AT_low_pc
                 Form:            DW_FORM_addr
               - Attribute:       DW_AT_high_pc
                 Form:            DW_FORM_addr
     debug_info:
       - Length:          46
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000001000
               - Value:           0x0000000000001500
               - Value:           0x0000000000000001
           - AbbrCode:        0x00000002
debug_abbrev:
             Attributes:
               - Attribute:       DW_AT_low_pc
                 Form:            DW_FORM_addr
               - Attribute:       DW_AT_high_pc
                 Form:            DW_FORM_addr
     debug_info:
       - Length:          52
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
           - AbbrCode:        0x00000002
             Values:
               - Value:           0x000000000000000D
debug_abbrev:
                 Form:            DW_FORM_strp
               - Attribute:       DW_AT_low_pc
                 Form:            DW_FORM_addr
               - Attribute:       DW_AT_high_pc
                 Form:            DW_FORM_addr
     debug_info:
       - Length:          55
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
           - AbbrCode:        0x00000002
             Values:
               - Value:           0x000000000000000D
debug_abbrev:
             Attributes:
               - Attribute:       DW_AT_low_pc
                 Form:            DW_FORM_addr
               - Attribute:       DW_AT_high_pc
                 Form:            DW_FORM_addr
     debug_info:
       - Length:          85
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000001000
               - Value:           0x0000000000002000
               - Value:           0x0000000000000001
           - AbbrCode:        0x00000002
debug_abbrev:
                 Form:            DW_FORM_strp
               - Attribute:       DW_AT_low_pc
                 Form:            DW_FORM_addr
               - Attribute:       DW_AT_high_pc
                 Form:            DW_FORM_addr
     debug_info:
       - Length:          34
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
           - AbbrCode:        0x00000002
             Values:
               - Value:           0x000000000000000D
debug_abbrev:
                 Form:            DW_FORM_strp
               - Attribute:       DW_AT_low_pc
                 Form:            DW_FORM_addr
               - Attribute:       DW_AT_high_pc
                 Form:            DW_FORM_addr
     debug_info:
       - Length:          71
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000001000
               - Value:           0x0000000000002000
               - Value:           0x0000000000000001
           - AbbrCode:        0x00000002
debug_abbrev:
                 Form:            DW_FORM_strp
               - Attribute:       DW_AT_low_pc
                 Form:            DW_FORM_addr
               - Attribute:       DW_AT_high_pc
                 Form:            DW_FORM_addr
     debug_info:
       - Length:          73
         Version:         4
-        AbbrOffset:      0
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000001000
               - Value:           0x0000000000002000
               - Value:           0x0000000000000001
           - AbbrCode:        0x00000002