[DebugInfo][DWARF64] Fix dumping pre-standard .debug_str_offsets.dwo sections.

[ikudrin]

Summary

The sizes of offsets in the .debug_str_offsets.dwo section depend on the format of compilation or type units referencing them: 4 bytes for DWARF32 units and 8 bytes for DWARF64 ones. The fix uses parsed units to determine the actual size of offsets in the corresponding part of the .debug_str_offsets.dwo section.

[ikudrin]

• Reformatted.

[jhenderson]

I've taken a quick look and things look fine, but my .debug_str_offsets knowledge is a little lacking, so it's probably best somebody else gives it a look.

[wolfgangp]

LGTM, with a slight caveat regarding reporting an error for degenerate stubs of string offset sections.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

247

Nice to get rid of this code!

llvm/test/DebugInfo/X86/dwarfdump-str-offsets-invalid-5.s

13

This isn't particularly important but it would be nice to emit a more precise error message on a degenerate .debug_str_offsets section like this.

[ikudrin]

llvm/test/DebugInfo/X86/dwarfdump-str-offsets-invalid-5.s

13

Currently, we report the irregularities found in the section, in some other way, but still. Did you mean some specific case which should be reported better/differently?

[wolfgangp]

llvm/test/DebugInfo/X86/dwarfdump-str-offsets-invalid-5.s

13

Just this particular case, where the section isn't big enough to accommodate even one single entry, let alone a contribution header. I thought it might be a bit more user-friendly to say something like "the section is too small to contain any meaningful information" instead of reporting a gap, which might be confusing.

[dblaikie]

llvm/test/DebugInfo/X86/dwarfdump-str-offsets-invalid-5.s

13

Yeah, I probably wouldn't encourage special-casing it - I'd slightly prefer the consistency. But what's binutils objdump do with that sort of situation (I know it prints "gaps" when dumping debug_loc - so might be worth seeing what it prints when there's only a gap/nothing else/especially short gap).

llvm/test/DebugInfo/X86/dwarfdump-str-offsets-v4-dwarf64-dwo.s

1–3

Honestly I'm not sure this situation is worth supporting - DWARFv4, non-standard extension (split DWARF), DWARF64. Might be nice to just go forward - supporting v5, standard split DWARF, DWARF64 - but if the v4 non-standard extension in DWARF64 is something you really want to support, so be it :)

21–30

Probably worth using some strings of different lengths (especially not all 4 or 8 bytes long) to make it clearer what's the string offset versus the byte offset of the record, etc.

[ikudrin]

llvm/test/DebugInfo/X86/dwarfdump-str-offsets-invalid-5.s

13

Well, I am inclining to avoid special cases like that. They are already covered with the existing diagnostics.

As for objdump, it seems like it does not print a separate report for the string offsets section.

llvm/test/DebugInfo/X86/dwarfdump-str-offsets-v4-dwarf64-dwo.s

1–3

This is mostly for completeness and simplifying the code at the same time. The DWARF64 v5 cases seem to be already supported.

21–30

Makes sense. Thanks!

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

Contributions.erase(
                     if (L && R)
                       return L->Base == R->Base && L->Size == R->Size;
                     return false;
                   }),
       Contributions.end());
   return Contributions;
 }
 
-static void dumpDWARFv5StringOffsetsSection(
-    raw_ostream &OS, DIDumpOptions DumpOpts, StringRef SectionName,
-    const DWARFObject &Obj, const DWARFSection &StringOffsetsSection,
-    StringRef StringSection, DWARFContext::unit_iterator_range Units,
+// Dump a DWARF string offsets section. This may be a DWARF v5 formatted
+// string offsets section, where each compile or type unit contributes a
+// number of entries (string offsets), with each contribution preceded by
+// a header containing size and version number. Alternatively, it may be a
+// monolithic series of string offsets, as generated by the pre-DWARF v5
+// implementation of split DWARF; however, in that case we still need to
+// collect contributions of units because the size of the offsets (4 or 8
+// bytes) depends on the format of the referencing unit (DWARF32 or DWARF64).
+static void dumpStringOffsetsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
+                                     StringRef SectionName,
+                                     const DWARFObject &Obj,
+                                     const DWARFSection &StringOffsetsSection,
+                                     StringRef StringSection,
+                                     DWARFContext::unit_iterator_range Units,
                                      bool LittleEndian) {
   auto Contributions = collectContributionData(Units);
   DWARFDataExtractor StrOffsetExt(Obj, StringOffsetsSection, LittleEndian, 0);
   DataExtractor StrData(StringSection, LittleEndian, 0);
   uint64_t SectionSize = StringOffsetsSection.Data.size();
   uint64_t Offset = 0;
   for (auto &Contribution : Contributions) {
     // Report an ill-formed contribution.
     if (!Contribution) {
static void dumpStringOffsetsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
   }
   // Report a gap at the end of the table.
   if (Offset < SectionSize) {
     OS << format("0x%8.8" PRIx64 ": Gap, length = ", Offset);
     OS << (SectionSize - Offset) << "\n";
   }
 }
 
-// Dump a DWARF string offsets section. This may be a DWARF v5 formatted
-// string offsets section, where each compile or type unit contributes a
-// number of entries (string offsets), with each contribution preceded by
-// a header containing size and version number. Alternatively, it may be a
-// monolithic series of string offsets, as generated by the pre-DWARF v5
-// implementation of split DWARF.
-static void dumpStringOffsetsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
-                                     StringRef SectionName,
-                                     const DWARFObject &Obj,
-                                     const DWARFSection &StringOffsetsSection,
-                                     StringRef StringSection,
-                                     DWARFContext::unit_iterator_range Units,
-                                     bool LittleEndian, unsigned MaxVersion) {
-  // If we have at least one (compile or type) unit with DWARF v5 or greater,
-  // we assume that the section is formatted like a DWARF v5 string offsets
-  // section.
-  if (MaxVersion >= 5)
-    dumpDWARFv5StringOffsetsSection(OS, DumpOpts, SectionName, Obj,
-                                    StringOffsetsSection, StringSection, Units,
-                                    LittleEndian);
-  else {
-    DataExtractor strOffsetExt(StringOffsetsSection.Data, LittleEndian, 0);
-    uint64_t offset = 0;
-    uint64_t size = StringOffsetsSection.Data.size();
-    // Ensure that size is a multiple of the size of an entry.
-    if (size & ((uint64_t)(sizeof(uint32_t) - 1))) {
-      OS << "error: size of ." << SectionName << " is not a multiple of "
-         << sizeof(uint32_t) << ".\n";
-      size &= -(uint64_t)sizeof(uint32_t);
-    }
-    DataExtractor StrData(StringSection, LittleEndian, 0);
-    while (offset < size) {
-      OS << format("0x%8.8" PRIx64 ": ", offset);
-      uint64_t StringOffset = strOffsetExt.getU32(&offset);
-      OS << format("%8.8" PRIx64 "  ", StringOffset);
-      const char *S = StrData.getCStr(&StringOffset);
-      if (S)
-        OS << format("\"%s\"", S);
-      OS << "\n";
-    }
-  }
-}
-
 // Dump the .debug_addr section.
 static void dumpAddrSection(raw_ostream &OS, DWARFDataExtractor &AddrData,
                             DIDumpOptions DumpOpts, uint16_t Version,
                             uint8_t AddrSize) {
   uint64_t Offset = 0;
   while (AddrData.isValidOffset(Offset)) {
     DWARFDebugAddrTable AddrTable;
     uint64_t TableOffset = Offset;
void DWARFContext::dump(
   if (shouldDump(Explicit, ".debug_gnu_pubtypes", DIDT_ID_DebugGnuPubtypes,
                  DObj->getGnuPubtypesSection().Data))
     DWARFDebugPubTable(*DObj, DObj->getGnuPubtypesSection(), isLittleEndian(),
                        true /* GnuStyle */)
         .dump(OS);
 
   if (shouldDump(Explicit, ".debug_str_offsets", DIDT_ID_DebugStrOffsets,
                  DObj->getStrOffsetsSection().Data))
-    dumpStringOffsetsSection(OS, DumpOpts, "debug_str_offsets", *DObj,
-                             DObj->getStrOffsetsSection(),
-                             DObj->getStrSection(), normal_units(),
-                             isLittleEndian(), getMaxVersion());
+    dumpStringOffsetsSection(
+        OS, DumpOpts, "debug_str_offsets", *DObj, DObj->getStrOffsetsSection(),
+        DObj->getStrSection(), normal_units(), isLittleEndian());
   if (shouldDump(ExplicitDWO, ".debug_str_offsets.dwo", DIDT_ID_DebugStrOffsets,
                  DObj->getStrOffsetsDWOSection().Data))
     dumpStringOffsetsSection(OS, DumpOpts, "debug_str_offsets.dwo", *DObj,
                              DObj->getStrOffsetsDWOSection(),
                              DObj->getStrDWOSection(), dwo_units(),
-                             isLittleEndian(), getMaxDWOVersion());
+                             isLittleEndian());
 
   if (shouldDump(Explicit, ".gdb_index", DIDT_ID_GdbIndex,
                  DObj->getGdbIndexSection())) {
     getGdbIndex().dump(OS);
   }
 
   if (shouldDump(Explicit, ".apple_names", DIDT_ID_AppleNames,
                  DObj->getAppleNamesSection().Data))

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

if (getVersion() >= 5) {
     if (!DescOrError)
       return DescOrError.takeError();
     return *DescOrError;
   }
   // Prior to DWARF v5, we derive the contribution size from the
   // index table (in a package file). In a .dwo file it is simply
   // the length of the string offsets section.
   if (!IndexEntry)
-    return {
-        Optional<StrOffsetsContributionDescriptor>(
-            {0, StringOffsetSection.Data.size(), 4, DWARF32})};
+    return {Optional<StrOffsetsContributionDescriptor>(
+        {0, StringOffsetSection.Data.size(), 4, Header.getFormat()})};
   if (C)
     return {Optional<StrOffsetsContributionDescriptor>(
-        {C->Offset, C->Length, 4, DWARF32})};
+        {C->Offset, C->Length, 4, Header.getFormat()})};
   return None;
 }

llvm/test/DebugInfo/X86/dwarfdump-str-offsets-invalid-5.s

 # RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o %t.o
 # RUN: llvm-dwarfdump -v %t.o | FileCheck --check-prefix=INVALIDSECTIONLENGTH %s
 #
 # Test object to verify that llvm-dwarfdump handles a degenerate string offsets
 # section.
 #
 # Every unit contributes to the string_offsets table.
         .section .debug_str_offsets,"",@progbits
 # A degenerate section, not enough for a single entry.
         .byte 2
 
-# INVALIDSECTIONLENGTH:      .debug_str_offsets contents:
-# INVALIDSECTIONLENGTH-NOT:  contents:
-# INVALIDSECTIONLENGTH:      error: size of .debug_str_offsets is not a multiple of 4.
+# INVALIDSECTIONLENGTH: .debug_str_offsets contents:
+# INVALIDSECTIONLENGTH: 0x00000000: Gap, length = 1

llvm/test/DebugInfo/X86/dwarfdump-str-offsets-v4-dwarf64-dwo.s

+## This tests dumping a .debug_str_offsets.dwo section which is referenced by
+## DWARF64 pre-v5 units and dumping attributes in such units which use the
+## DW_FORM_strx form.
+
+# RUN: llvm-mc -triple x86_64 %s -filetype=obj -o - | \
+# RUN:   llvm-dwarfdump -v - | \
+# RUN:   FileCheck %s
+
+# CHECK:      .debug_info.dwo contents:
+# CHECK:      Compile Unit:
+# CHECK:      DW_TAG_compile_unit [1]
+# CHECK-NEXT:   DW_AT_name [DW_FORM_strx] (indexed (00000000) string = "foo")
+
+# CHECK:      .debug_types.dwo contents:
+# CHECK:      Type Unit:
+# CHECK:      DW_TAG_type_unit [2] *
+# CHECK-NEXT:   DW_AT_name [DW_FORM_strx] (indexed (00000001) string = "bar")
+# CHECK:      DW_TAG_structure_type [3]  
+# CHECK-NEXT:   DW_AT_name [DW_FORM_strx] (indexed (00000002) string = "baz")
+
+# CHECK:      .debug_str.dwo contents:
+# CHECK-NEXT: 0x00000000: "foo"
+# CHECK-NEXT: 0x00000004: "bar"
+# CHECK-NEXT: 0x00000008: "baz"
+
+# CHECK:      .debug_str_offsets.dwo contents:
+# CHECK-NEXT: 0x00000000: Contribution size = 24, Format = DWARF64, Version = 4
+# CHECK-NEXT: 0x00000000: 00000000 "foo"
+# CHECK-NEXT: 0x00000008: 00000004 "bar"
+# CHECK-NEXT: 0x00000010: 00000008 "baz"
+
+    .section .debug_str.dwo, "MSe", @progbits, 1
+.LStrFoo:
+    .asciz "foo"
+.LStrBar:
+    .asciz "bar"
+.LStrBaz:
+    .asciz "baz"
+
+    .section .debug_str_offsets.dwo, "e", @progbits
+    .quad .LStrFoo-.debug_str.dwo   # 0: "foo"
+    .quad .LStrBar-.debug_str.dwo   # 1: "bar"
+    .quad .LStrBaz-.debug_str.dwo   # 2: "baz"
+
+    .section .debug_abbrev.dwo, "e", @progbits
+    .uleb128 0x01                   # Abbrev code
+    .uleb128 0x11                   # DW_TAG_compile_unit
+    .byte 0x00                      # DW_CHILDREN_no
+    .uleb128 0x03                   # DW_AT_name
+    .uleb128 0x1a                   # DW_FORM_strx
+    .byte 0x00                      # EOM(1)
+    .byte 0x00                      # EOM(2)
+    .uleb128 0x02                   # Abbrev code
+    .uleb128 0x41                   # DW_TAG_type_unit
+    .byte 0x01                      # DW_CHILDREN_yes
+    .uleb128 0x03                   # DW_AT_name
+    .uleb128 0x1a                   # DW_FORM_strx
+    .byte 0x00                      # EOM(1)
+    .byte 0x00                      # EOM(2)
+    .uleb128 0x03                   # Abbrev code
+    .uleb128 0x13                   # DW_TAG_structure_type
+    .byte 0x00                      # DW_CHILDREN_no (no members)
+    .uleb128 0x03                   # DW_AT_name
+    .uleb128 0x1a                   # DW_FORM_strx
+    .byte 0x00                      # EOM(1)
+    .byte 0x00                      # EOM(2)
+    .byte 0x00                      # EOM(3)
+
+    .section .debug_info.dwo, "e", @progbits
+    .long 0xffffffff                # DWARF64 mark
+    .quad .LCUEnd-.LCUVer           # Length
+.LCUVer:
+    .short 4                        # Version
+    .quad 0                         # Abbrev. offset
+    .byte 8                         # Address size
+    .uleb128 1                      # Abbrev [1] DW_TAG_compile_unit
+    .uleb128 0                      # DW_AT_name ("foo")
+.LCUEnd:
+
+    .section .debug_types.dwo, "e", @progbits
+.LTU:
+    .long 0xffffffff                # DWARF64 mark
+    .quad .LTUEnd-.LTUVer           # Length
+.LTUVer:
+    .short 4                        # Version
+    .quad 0                         # Abbrev. offset
+    .byte 8                         # Address size
+    .quad 0x11110022ffffffff        # Type Signature
+    .quad .LTUType-.LTU             # Type offset
+    .uleb128 2                      # Abbrev [2] DW_TAG_type_unit
+    .uleb128 1                      # DW_AT_name ("bar")
+.LTUType:
+    .uleb128 3                      # Abbrev [3] DW_TAG_structure_type
+    .uleb128 2                      # DW_AT_name ("baz")
+.LTUEnd:

llvm/test/DebugInfo/X86/dwarfdump-str-offsets-v4-dwarf64-dwp.s

+## This tests dumping a .debug_str_offsets.dwo section in a DWP file when it is
+## referenced by units in different formats: one unit is DWARF32 and another
+## is DWARF64, thus the .debug_str_offsets.dwo section has contributions with
+## different sizes of offsets.
+## This also checks that attributes in the units which use the DW_FORM_strx form
+## are dumped correctly.
+
+# RUN: llvm-mc -triple x86_64 %s -filetype=obj -o - | \
+# RUN:   llvm-dwarfdump -v - | \
+# RUN:   FileCheck %s
+
+# CHECK:      .debug_info.dwo contents:
+# CHECK:      Compile Unit:
+# CHECK:      DW_TAG_compile_unit [1]
+# CHECK-NEXT:   DW_AT_producer [DW_FORM_strx] (indexed (00000000) string = "foo")
+# CHECK-NEXT:   DW_AT_name [DW_FORM_strx] (indexed (00000001) string = "bar")
+# CHECK:      Compile Unit:
+# CHECK:      DW_TAG_compile_unit [1]
+# CHECK-NEXT:   DW_AT_producer [DW_FORM_strx] (indexed (00000000) string = "baz")
+# CHECK-NEXT:   DW_AT_name [DW_FORM_strx] (indexed (00000001) string = "qux")
+
+# CHECK:      .debug_str.dwo contents:
+# CHECK-NEXT: 0x00000000: "foo"
+# CHECK-NEXT: 0x00000004: "bar"
+# CHECK-NEXT: 0x00000008: "baz"
+# CHECK-NEXT: 0x0000000c: "qux"
+
+# CHECK:      .debug_str_offsets.dwo contents:
+# CHECK-NEXT: 0x00000000: Contribution size = 8, Format = DWARF32, Version = 4
+# CHECK-NEXT: 0x00000000: 00000000 "foo"
+# CHECK-NEXT: 0x00000004: 00000004 "bar"
+# CHECK-NEXT: 0x00000008: Contribution size = 16, Format = DWARF64, Version = 4
+# CHECK-NEXT: 0x00000008: 00000008 "baz"
+# CHECK-NEXT: 0x00000010: 0000000c "qux"
+
+    .section .debug_str.dwo, "MSe", @progbits, 1
+.LStrFoo:
+    .asciz "foo"
+.LStrBar:
+    .asciz "bar"
+.LStrBaz:
+    .asciz "baz"
+.LStrQux:
+    .asciz "qux"
+
+    .section .debug_str_offsets.dwo, "e", @progbits
+## The contribution of CU0 (DWARF32)
+.LSO0:
+    .long .LStrFoo-.debug_str.dwo   # 0: "foo"
+    .long .LStrBar-.debug_str.dwo   # 1: "bar"
+.LSO0End:
+## The contribution of CU1 (DWARF64)
+.LSO1:
+    .quad .LStrBaz-.debug_str.dwo   # 0: "baz"
+    .quad .LStrQux-.debug_str.dwo   # 1: "qux"
+.LSO1End:
+
+    .section .debug_abbrev.dwo, "e", @progbits
+## For simplicity and to make the test shorter, both compilation units share
+## the same abbreviations table.
+.LAbbr:
+    .uleb128 0x01                   # Abbrev code
+    .uleb128 0x11                   # DW_TAG_compile_unit
+    .byte 0x00                      # DW_CHILDREN_no
+    .uleb128 0x25                   # DW_AT_producer
+    .uleb128 0x1a                   # DW_FORM_strx
+    .uleb128 0x03                   # DW_AT_name
+    .uleb128 0x1a                   # DW_FORM_strx
+    .uleb128 0x2131                 # DW_AT_GNU_dwo_id
+    .uleb128 0x07                   # DW_FORM_data8
+    .byte 0x00                      # EOM(1)
+    .byte 0x00                      # EOM(2)
+    .byte 0x00                      # EOM(3)
+.LAbbrEnd:
+
+    .section .debug_info.dwo, "e", @progbits
+## CU0 uses the 32-bit DWARF format.
+.LCU0:
+    .long .LCU0End-.LCU0Ver         # Length
+.LCU0Ver:
+    .short 4                        # Version
+    .long 0                         # Abbrev. offset
+    .byte 8                         # Address size
+    .uleb128 1                      # Abbrev [1] DW_TAG_compile_unit
+    .uleb128 0                      # DW_AT_producer ("foo")
+    .uleb128 1                      # DW_AT_name ("bar")
+    .quad 0x1100001122222222        # DW_AT_GNU_dwo_id
+.LCU0End:
+## CU1 uses the 64-bit DWARF format.
+.LCU1:
+    .long 0xffffffff                # DWARF64 mark
+    .quad .LCU1End-.LCU1Ver           # Length
+.LCU1Ver:
+    .short 4                        # Version
+    .quad 0                         # Abbrev. offset
+    .byte 8                         # Address size
+    .uleb128 1                      # Abbrev [1] DW_TAG_compile_unit
+    .uleb128 0                      # DW_AT_producer ("baz")
+    .uleb128 1                      # DW_AT_name ("qux")
+    .quad 0x1100001133333333        # DW_AT_GNU_dwo_id
+.LCU1End:
+
+    .section .debug_cu_index, "", @progbits
+## Header:
+    .long 2                         # Version
+    .long 3                         # Section count
+    .long 2                         # Unit count
+    .long 4                         # Slot count
+## Hash Table of Signatures:
+    .quad 0
+    .quad 0
+    .quad 0x1100001122222222        # DWO Id of CU0
+    .quad 0x1100001133333333        # DWO Id of CU1
+## Parallel Table of Indexes:
+    .long 0
+    .long 0
+    .long 1
+    .long 2
+## Table of Section Offsets:
+## Row 0:
+    .long 1                         # DW_SECT_INFO
+    .long 3                         # DW_SECT_ABBREV
+    .long 6                         # DW_SECT_STR_OFFSETS
+## Row 1, offsets of contributions of CU0:
+    .long .LCU0-.debug_info.dwo
+    .long .LAbbr-.debug_abbrev.dwo
+    .long .LSO0-.debug_str_offsets.dwo
+## Row 2, offsets of contributions of CU1:
+    .long .LCU1-.debug_info.dwo
+    .long .LAbbr-.debug_abbrev.dwo
+    .long .LSO1-.debug_str_offsets.dwo
+## Table of Section Sizes:
+## Row 1, sizes of contributions of CU0:
+    .long .LCU0End-.LCU0
+    .long .LAbbrEnd-.LAbbr
+    .long .LSO0End-.LSO0
+## Row 2, sizes of contributions of CU1:
+    .long .LCU1End-.LCU1
+    .long .LAbbrEnd-.LAbbr
+    .long .LSO1End-.LSO1