[DebugInfo] Dump fields according to their formats.

[ikudrin]

Summary

This patch changes dumping fields of debugging tables which have different sizes in DWARF32 and DWARF64 formats, and which were reported as 8-digit hex values so that they use widths of 8 or 16 digits according to the format of the corresponding table. Other cases are left unaffected by this change, in particular:

• Fields of .debug_names, because they are printed with floating width without leading zeroes;
• Abbreviation and type offsets in compilation and type units, because they use the width of 4 digits in dumping.

[ikudrin]

• Add test DebugInfo/X86/debug-frame-dwarf64.s

[dblaikie]

Looks good - might be good/better to commit per-section, to isolate the changes/testing/etc.

llvm/lib/DebugInfo/DWARF/DWARFFormValue.cpp

486 ↗

(On Diff #264213)

maybe pull this 16/8 computation out to the top, as you have in other parts of this patch? and/or refactor it into a utility function that gives the offset length, given the DWARF format.

[ikudrin]

In D79997#2039229, @dblaikie wrote:

Looks good - might be good/better to commit per-section, to isolate the changes/testing/etc.

Thanks! I'll split it on commit.

llvm/lib/DebugInfo/DWARF/DWARFFormValue.cpp

486 ↗

(On Diff #264213)

maybe pull this 16/8 computation out to the top, as you have in other parts of this patch?

OK.

and/or refactor it into a utility function that gives the offset length, given the DWARF format.

I would not add that separate function; that would just bloat the common code. I think, that if not an explicit expression, I would prefer to use 2 * dwarf::getDwarfOffsetByteSize(Format).

[jhenderson]

All makes sense to me. LGTM.

llvm/test/DebugInfo/dwarfdump-64-bit-dwarf.test

4–5 ↗

(On Diff #264213)

This comment (and maybe even the test as a whole) looks a little stale nowadays...

[ikudrin]

llvm/test/DebugInfo/dwarfdump-64-bit-dwarf.test

4–5 ↗

(On Diff #264213)

You are probably right. I'll prepare a separate review for that.

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h

 class raw_ostream;
 
 class DWARFDebugArangeSet {
 public:
   struct Header {
     /// The total length of the entries for that set, not including the length
     /// field itself.
     uint64_t Length;
+    /// The DWARF format of the set.
+    dwarf::DwarfFormat Format;
     /// The offset from the beginning of the .debug_info section of the
     /// compilation unit entry referenced by the table.
     uint64_t CuOffset;
     /// The DWARF version number.
     uint16_t Version;
     /// The size in bytes of an address on the target architecture. For segmented
     /// addressing, this is the size of the offset portion of the address.
     uint8_t AddrSize;

llvm/lib/DebugInfo/DWARF/DWARFDebugArangeSet.cpp

Error DWARFDebugArangeSet::extract(DWARFDataExtractor data,
   // a segment, an address and a length. The segment selector size is given by
   // the segment_selector_size field of the header; the address and length
   // size are each given by the address_size field of the header. Each set of
   // tuples is terminated by a 0 for the segment, a 0 for the address and 0
   // for the length. If the segment_selector_size field in the header is zero,
   // the segment selectors are omitted from all tuples, including
   // the terminating tuple.
 
-  dwarf::DwarfFormat format;
   Error Err = Error::success();
-  std::tie(HeaderData.Length, format) = data.getInitialLength(offset_ptr, &Err);
+  std::tie(HeaderData.Length, HeaderData.Format) =
+      data.getInitialLength(offset_ptr, &Err);
   HeaderData.Version = data.getU16(offset_ptr, &Err);
-  HeaderData.CuOffset =
-      data.getUnsigned(offset_ptr, dwarf::getDwarfOffsetByteSize(format), &Err);
+  HeaderData.CuOffset = data.getUnsigned(
+      offset_ptr, dwarf::getDwarfOffsetByteSize(HeaderData.Format), &Err);
   HeaderData.AddrSize = data.getU8(offset_ptr, &Err);
   HeaderData.SegSize = data.getU8(offset_ptr, &Err);
   if (Err) {
     return createStringError(errc::invalid_argument,
                              "parsing address ranges table at offset 0x%" PRIx64
                              ": %s",
                              Offset, toString(std::move(Err)).c_str());
   }
 
   // Perform basic validation of the header fields.
   uint64_t full_length =
-      dwarf::getUnitLengthFieldByteSize(format) + HeaderData.Length;
+      dwarf::getUnitLengthFieldByteSize(HeaderData.Format) + HeaderData.Length;
   if (!data.isValidOffsetForDataOfSize(Offset, full_length))
     return createStringError(errc::invalid_argument,
                              "the length of address range table at offset "
                              "0x%" PRIx64 " exceeds section size",
                              Offset);
   if (HeaderData.AddrSize != 4 && HeaderData.AddrSize != 8)
     return createStringError(errc::invalid_argument,
                              "address range table at offset 0x%" PRIx64
Error DWARFDebugArangeSet::extract(DWARFDataExtractor data,
 
   return createStringError(errc::invalid_argument,
                            "address range table at offset 0x%" PRIx64
                            " is not terminated by null entry",
                            Offset);
 }
 
 void DWARFDebugArangeSet::dump(raw_ostream &OS) const {
+  int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(HeaderData.Format);
   OS << "Address Range Header: "
-     << format("length = 0x%8.8" PRIx64 ", ", HeaderData.Length)
+     << format("length = 0x%0*" PRIx64 ", ", OffsetDumpWidth, HeaderData.Length)
      << format("version = 0x%4.4x, ", HeaderData.Version)
-     << format("cu_offset = 0x%8.8" PRIx64 ", ", HeaderData.CuOffset)
+     << format("cu_offset = 0x%0*" PRIx64 ", ", OffsetDumpWidth,
+               HeaderData.CuOffset)
      << format("addr_size = 0x%2.2x, ", HeaderData.AddrSize)
      << format("seg_size = 0x%2.2x\n", HeaderData.SegSize);
 
   for (const auto &Desc : ArangeDescriptors) {
     Desc.dump(OS, HeaderData.AddrSize);
     OS << '\n';
   }
 }

llvm/test/DebugInfo/X86/dwarfdump-debug-aranges.s

 # CHECK-NOT: [0x
 .L1end:
 
 ## Case 2: Check that the address size of 4 is supported.
     .long   .L2end - .L2version     # Length
 # CHECK: Address Range Header: length = 0x0000001c,
 .L2version:
     .short  2                       # Version
-    .long   0x11223344              # Debug Info Offset
+    .long   0x112233                # Debug Info Offset
     .byte   4                       # Address Size
     .byte   0                       # Segment Selector Size
 # CHECK-SAME: version = 0x0002,
-# CHECK-SAME: cu_offset = 0x11223344,
+# CHECK-SAME: cu_offset = 0x00112233,
 # CHECK-SAME: addr_size = 0x04,
 # CHECK-SAME: seg_size = 0x00
     .space  4                       # Padding
 .L2tuples:
     .long   0x11223344, 0x01020304  # Address and length
 # CHECK-NEXT: [0x11223344,  0x12243648)
     .long   0, 0                    # Termination tuple
 # CHECK-NOT: [0x
 .L2end:
 
 ## Case 3: Check that the address size of 8 is also supported.
     .long   .L3end - .L3version     # Length
 # CHECK: Address Range Header: length = 0x0000002c,
 .L3version:
     .short  2                       # Version
-    .long   0x22334455              # Debug Info Offset
+    .long   0x112233                # Debug Info Offset
     .byte   8                       # Address Size
     .byte   0                       # Segment Selector Size
 # CHECK-SAME: version = 0x0002,
-# CHECK-SAME: cu_offset = 0x22334455,
+# CHECK-SAME: cu_offset = 0x00112233,
 # CHECK-SAME: addr_size = 0x08,
 # CHECK-SAME: seg_size = 0x00
     .space  4                       # Padding
 .L3tuples:
     .quad   0x1122334455667788      # Address
     .quad   0x0102030405060708      # Length
 # CHECK-NEXT: [0x1122334455667788,  0x122436485a6c7e90)
     .quad   0, 0                    # Termination tuple
 # CHECK-NOT: [0x
 .L3end:
 
 ## Case 4: Check that 64-bit DWARF format is supported.
     .long 0xffffffff                # DWARF64 mark
     .quad   .L4end - .L4version     # Length
-# CHECK: Address Range Header: length = 0x0000001c,
+# CHECK: Address Range Header: length = 0x000000000000001c,
 .L4version:
     .short  2                       # Version
-    .quad   0x1234567899aabbcc      # Debug Info Offset
+    .quad   0x123456789abc          # Debug Info Offset
     .byte   4                       # Address Size
     .byte   0                       # Segment Selector Size
 # CHECK-SAME: version = 0x0002,
-# CHECK-SAME: cu_offset = 0x1234567899aabbcc,
+# CHECK-SAME: cu_offset = 0x0000123456789abc,
 # CHECK-SAME: addr_size = 0x04,
 # CHECK-SAME: seg_size = 0x00
                                     # No padding
 .L4tuples:
     .long   0, 1                    # Address and length
 # CHECK-NEXT: [0x00000000,  0x00000001)
     .long   0, 0                    # Termination tuple
 # CHECK-NOT: [0x
 .L4end: