[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

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

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

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

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/include/llvm/DebugInfo/DWARF/DWARFDebugPubTable.h

public:
   /// the names of global objects and functions, or global types, respectively,
   /// whose definitions are represented by debugging information entries owned
   /// by a single compilation unit.
   struct Set {
     /// 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;
+
     /// This number is specific to the name lookup table and is independent of
     /// the DWARF version number.
     uint16_t Version;
 
     /// The offset from the beginning of the .debug_info section of the
     /// compilation unit header referenced by the set.
     uint64_t Offset;
 

llvm/include/llvm/DebugInfo/DWARF/DWARFFormValue.h

union {
       int64_t sval;
       const char *cstr;
     };
     const uint8_t *data = nullptr;
     uint64_t SectionIndex;      /// Section index for reference forms.
   };
 
   dwarf::Form Form;             /// Form for this value.
+  dwarf::DwarfFormat Format =
+      dwarf::DWARF32;           /// Remember the DWARF format at extract time.
   ValueType Value;              /// Contains all data for the form.
   const DWARFUnit *U = nullptr; /// Remember the DWARFUnit at extract time.
   const DWARFContext *C = nullptr; /// Context for extract time.
 
   DWARFFormValue(dwarf::Form F, ValueType V) : Form(F), Value(V) {}
 
 public:
   DWARFFormValue(dwarf::Form F = dwarf::Form(0)) : Form(F) {}

llvm/include/llvm/DebugInfo/DWARF/DWARFUnit.h

public:
   }
   uint16_t getVersion() const { return Header.getVersion(); }
   uint8_t getAddressByteSize() const { return Header.getAddressByteSize(); }
   uint8_t getRefAddrByteSize() const { return Header.getRefAddrByteSize(); }
   uint8_t getDwarfOffsetByteSize() const {
     return Header.getDwarfOffsetByteSize();
   }
   uint64_t getLength() const { return Header.getLength(); }
+  dwarf::DwarfFormat getFormat() const { return Header.getFormat(); }
   uint8_t getUnitType() const { return Header.getUnitType(); }
   bool isTypeUnit() const { return Header.isTypeUnit(); }
   uint64_t getNextUnitOffset() const { return Header.getNextUnitOffset(); }
   const DWARFSection &getLineSection() const { return LineSection; }
   StringRef getStringSection() const { return StringSection; }
   const DWARFSection &getStringOffsetSection() const {
     return StringOffsetSection;
   }

llvm/lib/DebugInfo/DWARF/DWARFCompileUnit.cpp

 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 void DWARFCompileUnit::dump(raw_ostream &OS, DIDumpOptions DumpOpts) {
+  int OffsetDumpWidth = getFormat() == dwarf::DWARF64 ? 16 : 8;
   OS << format("0x%08" PRIx64, getOffset()) << ": Compile Unit:"
-     << " length = " << format("0x%08" PRIx64, getLength())
+     << " length = " << format("0x%0*" PRIx64, OffsetDumpWidth, getLength())
      << " version = " << format("0x%04x", getVersion());
   if (getVersion() >= 5)
     OS << " unit_type = " << dwarf::UnitTypeString(getUnitType());
   OS << " abbr_offset = "
      << format("0x%04" PRIx64, getAbbreviations()->getOffset())
      << " addr_size = " << format("0x%02x", getAddressByteSize());
   if (getVersion() >= 5 && getUnitType() != dwarf::DW_UT_compile)
     OS << " DWO_id = " << format("0x%016" PRIx64, *getDWOId());

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

for (auto &Contribution : Contributions) {
     // Report an ill-formed contribution.
     if (!Contribution) {
       OS << "error: invalid contribution to string offsets table in section ."
          << SectionName << ".\n";
       return;
     }
 
     dwarf::DwarfFormat Format = Contribution->getFormat();
+    int OffsetDumpWidth = Format == DWARF64 ? 16 : 8;
     uint16_t Version = Contribution->getVersion();
     uint64_t ContributionHeader = Contribution->Base;
     // In DWARF v5 there is a contribution header that immediately precedes
     // the string offsets base (the location we have previously retrieved from
     // the CU DIE's DW_AT_str_offsets attribute). The header is located either
     // 8 or 16 bytes before the base, depending on the contribution's format.
     if (Version >= 5)
       ContributionHeader -= Format == DWARF32 ? 8 : 16;
OS << "Contribution size = " << (Contribution->Size + (Version < 5 ? 0 : 4))
        << ", Version = " << Version << "\n";
 
     Offset = Contribution->Base;
     unsigned EntrySize = Contribution->getDwarfOffsetByteSize();
     while (Offset - Contribution->Base < Contribution->Size) {
       OS << format("0x%8.8" PRIx64 ": ", Offset);
       uint64_t StringOffset =
           StrOffsetExt.getRelocatedValue(EntrySize, &Offset);
-      OS << format("%8.8" PRIx64 " ", StringOffset);
+      OS << format("%0*" PRIx64 " ", OffsetDumpWidth, StringOffset);
       const char *S = StrData.getCStr(&StringOffset);
       if (S)
         OS << format("\"%s\"", S);
       OS << "\n";
     }
   }
   // Report a gap at the end of the table.
   if (Offset < SectionSize) {

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 = HeaderData.Format == dwarf::DWARF64 ? 16 : 8;
   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/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

void DWARFDebugLine::Prologue::clear() {
   IncludeDirectories.clear();
   FileNames.clear();
 }
 
 void DWARFDebugLine::Prologue::dump(raw_ostream &OS,
                                     DIDumpOptions DumpOptions) const {
   if (!totalLengthIsValid())
     return;
+  int OffsetDumpWidth = isDWARF64() ? 16 : 8;
   OS << "Line table prologue:\n"
-     << format("    total_length: 0x%8.8" PRIx64 "\n", TotalLength)
+     << format("    total_length: 0x%0*" PRIx64 "\n", OffsetDumpWidth,
+               TotalLength)
      << format("         version: %u\n", getVersion());
   if (!versionIsSupported(getVersion()))
     return;
   if (getVersion() >= 5)
     OS << format("    address_size: %u\n", getAddressSize())
        << format(" seg_select_size: %u\n", SegSelectorSize);
-  OS << format(" prologue_length: 0x%8.8" PRIx64 "\n", PrologueLength)
+  OS << format(" prologue_length: 0x%0*" PRIx64 "\n", OffsetDumpWidth,
+               PrologueLength)
      << format(" min_inst_length: %u\n", MinInstLength)
      << format(getVersion() >= 4 ? "max_ops_per_inst: %u\n" : "", MaxOpsPerInst)
      << format(" default_is_stmt: %u\n", DefaultIsStmt)
      << format("       line_base: %i\n", LineBase)
      << format("      line_range: %u\n", LineRange)
      << format("     opcode_base: %u\n", OpcodeBase);
 
   for (uint32_t I = 0; I != StandardOpcodeLengths.size(); ++I)

llvm/lib/DebugInfo/DWARF/DWARFDebugPubTable.cpp

DWARFDebugPubTable::DWARFDebugPubTable(const DWARFObject &Obj,
                                        bool LittleEndian, bool GnuStyle)
     : GnuStyle(GnuStyle) {
   DWARFDataExtractor PubNames(Obj, Sec, LittleEndian, 0);
   uint64_t Offset = 0;
   while (PubNames.isValidOffset(Offset)) {
     Sets.push_back({});
     Set &SetData = Sets.back();
 
-    dwarf::DwarfFormat Format;
-    std::tie(SetData.Length, Format) = PubNames.getInitialLength(&Offset);
-    const unsigned OffsetSize = dwarf::getDwarfOffsetByteSize(Format);
+    std::tie(SetData.Length, SetData.Format) =
+        PubNames.getInitialLength(&Offset);
+    const unsigned OffsetSize = dwarf::getDwarfOffsetByteSize(SetData.Format);
 
     SetData.Version = PubNames.getU16(&Offset);
     SetData.Offset = PubNames.getRelocatedValue(OffsetSize, &Offset);
     SetData.Size = PubNames.getUnsigned(&Offset, OffsetSize);
 
     while (Offset < Sec.Data.size()) {
       uint64_t DieRef = PubNames.getUnsigned(&Offset, OffsetSize);
       if (DieRef == 0)
         break;
       uint8_t IndexEntryValue = GnuStyle ? PubNames.getU8(&Offset) : 0;
       StringRef Name = PubNames.getCStrRef(&Offset);
       SetData.Entries.push_back(
           {DieRef, PubIndexEntryDescriptor(IndexEntryValue), Name});
     }
   }
 }
 
 void DWARFDebugPubTable::dump(raw_ostream &OS) const {
   for (const Set &S : Sets) {
-    OS << "length = " << format("0x%08" PRIx64, S.Length);
+    int OffsetDumpWidth = S.Format == dwarf::DWARF64 ? 16 : 8;
+    OS << "length = " << format("0x%0*" PRIx64, OffsetDumpWidth, S.Length);
     OS << " version = " << format("0x%04x", S.Version);
-    OS << " unit_offset = " << format("0x%08" PRIx64, S.Offset);
-    OS << " unit_size = " << format("0x%08" PRIx64, S.Size) << '\n';
+    OS << " unit_offset = "
+       << format("0x%0*" PRIx64, OffsetDumpWidth, S.Offset);
+    OS << " unit_size = " << format("0x%0*" PRIx64, OffsetDumpWidth, S.Size)
+       << '\n';
     OS << (GnuStyle ? "Offset     Linkage  Kind     Name\n"
                     : "Offset     Name\n");
 
     for (const Entry &E : S.Entries) {
-      OS << format("0x%8.8" PRIx64 " ", E.SecOffset);
+      OS << format("0x%0*" PRIx64 " ", OffsetDumpWidth, E.SecOffset);
       if (GnuStyle) {
         StringRef EntryLinkage =
             GDBIndexEntryLinkageString(E.Descriptor.Linkage);
         StringRef EntryKind = dwarf::GDBIndexEntryKindString(E.Descriptor.Kind);
         OS << format("%-8s", EntryLinkage.data()) << ' '
            << format("%-8s", EntryKind.data()) << ' ';
       }
       OS << '\"' << E.Name << "\"\n";
     }
   }
 }

llvm/lib/DebugInfo/DWARF/DWARFFormValue.cpp

 bool DWARFFormValue::extractValue(const DWARFDataExtractor &Data,
                                   uint64_t *OffsetPtr, dwarf::FormParams FP,
                                   const DWARFContext *Ctx,
                                   const DWARFUnit *CU) {
   if (!Ctx && CU)
     Ctx = &CU->getContext();
   C = Ctx;
   U = CU;
+  Format = FP.Format;
   bool Indirect = false;
   bool IsBlock = false;
   Value.data = nullptr;
   // Read the value for the form into value and follow and DW_FORM_indirect
   // instances we run into
   Error Err = Error::success();
   do {
     Indirect = false;
void DWARFFormValue::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
   case DW_FORM_sdata:
     OS << Value.sval;
     break;
   case DW_FORM_udata:
     OS << Value.uval;
     break;
   case DW_FORM_strp:
     if (DumpOpts.Verbose)
-      OS << format(" .debug_str[0x%8.8" PRIx64 "] = ", UValue);
+      OS << format(" .debug_str[0x%0*" PRIx64 "] = ",
+                   Format == DWARF64 ? 16 : 8, UValue);
     dumpString(OS);
     break;
   case DW_FORM_line_strp:
     if (DumpOpts.Verbose)
-      OS << format(" .debug_line_str[0x%8.8" PRIx64 "] = ", UValue);
+      OS << format(" .debug_line_str[0x%0*" PRIx64 "] = ",
+                   Format == DWARF64 ? 16 : 8, UValue);
     dumpString(OS);
     break;
   case DW_FORM_strx:
   case DW_FORM_strx1:
   case DW_FORM_strx2:
   case DW_FORM_strx3:
   case DW_FORM_strx4:
   case DW_FORM_GNU_str_index:
case DW_FORM_rnglistx:
     OS << format("indexed (0x%x) rangelist = ", (uint32_t)UValue);
     break;
 
   case DW_FORM_loclistx:
     OS << format("indexed (0x%x) loclist = ", (uint32_t)UValue);
     break;
 
   case DW_FORM_sec_offset:
-    AddrOS << format("0x%08" PRIx64, UValue);
+    AddrOS << format("0x%0*" PRIx64, Format == DWARF64 ? 16 : 8, UValue);
     break;
 
   default:
     OS << format("DW_FORM(0x%4.4x)", Form);
     break;
   }
 
   if (CURelativeOffset) {

llvm/lib/DebugInfo/DWARF/DWARFListTable.cpp

Error DWARFListTableHeader::extract(DWARFDataExtractor Data,
   for (uint32_t I = 0; I < HeaderData.OffsetEntryCount; ++I)
     Offsets.push_back(Data.getRelocatedValue(OffsetByteSize, OffsetPtr));
   return Error::success();
 }
 
 void DWARFListTableHeader::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
   if (DumpOpts.Verbose)
     OS << format("0x%8.8" PRIx64 ": ", HeaderOffset);
-  OS << format(
-      "%s list header: length = 0x%8.8" PRIx64 ", version = 0x%4.4" PRIx16 ", "
-      "addr_size = 0x%2.2" PRIx8 ", seg_size = 0x%2.2" PRIx8
-      ", offset_entry_count = "
-      "0x%8.8" PRIx32 "\n",
-      ListTypeString.data(), HeaderData.Length, HeaderData.Version,
-      HeaderData.AddrSize, HeaderData.SegSize, HeaderData.OffsetEntryCount);
+  int OffsetDumpWidth = Format == dwarf::DWARF64 ? 16 : 8;
+  OS << format("%s list header: length = 0x%0*" PRIx64
+               ", version = 0x%4.4" PRIx16 ", addr_size = 0x%2.2" PRIx8
+               ", seg_size = 0x%2.2" PRIx8
+               ", offset_entry_count = 0x%8.8" PRIx32 "\n",
+               ListTypeString.data(), OffsetDumpWidth, HeaderData.Length,
+               HeaderData.Version, HeaderData.AddrSize, HeaderData.SegSize,
+               HeaderData.OffsetEntryCount);
 
   if (HeaderData.OffsetEntryCount > 0) {
     OS << "offsets: [";
     for (const auto &Off : Offsets) {
-      OS << format("\n0x%8.8" PRIx64, Off);
+      OS << format("\n0x%0*" PRIx64, OffsetDumpWidth, Off);
       if (DumpOpts.Verbose)
-        OS << format(" => 0x%8.8" PRIx64,
+        OS << format(" => 0x%08" PRIx64,
                      Off + HeaderOffset + getHeaderSize(Format));
     }
     OS << "\n]\n";
   }
 }
 
 uint64_t DWARFListTableHeader::length() const {
   if (HeaderData.Length == 0)
     return 0;
   return HeaderData.Length + dwarf::getUnitLengthFieldByteSize(Format);
 }

llvm/lib/DebugInfo/DWARF/DWARFTypeUnit.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <cinttypes>
 
 using namespace llvm;
 
 void DWARFTypeUnit::dump(raw_ostream &OS, DIDumpOptions DumpOpts) {
   DWARFDie TD = getDIEForOffset(getTypeOffset() + getOffset());
   const char *Name = TD.getName(DINameKind::ShortName);
+  int OffsetDumpWidth = getFormat() == dwarf::DWARF64 ? 16 : 8;
 
   if (DumpOpts.SummarizeTypes) {
     OS << "name = '" << Name << "'"
        << " type_signature = " << format("0x%016" PRIx64, getTypeHash())
-       << " length = " << format("0x%08" PRIx64, getLength()) << '\n';
+       << " length = " << format("0x%0*" PRIx64, OffsetDumpWidth, getLength())
+       << '\n';
     return;
   }
 
   OS << format("0x%08" PRIx64, getOffset()) << ": Type Unit:"
-     << " length = " << format("0x%08" PRIx64, getLength())
+     << " length = " << format("0x%0*" PRIx64, OffsetDumpWidth, getLength())
      << " version = " << format("0x%04x", getVersion());
   if (getVersion() >= 5)
     OS << " unit_type = " << dwarf::UnitTypeString(getUnitType());
   OS << " abbr_offset = "
      << format("0x%04" PRIx64, getAbbreviations()->getOffset())
      << " addr_size = " << format("0x%02x", getAddressByteSize())
      << " name = '" << Name << "'"
      << " type_signature = " << format("0x%016" PRIx64, getTypeHash())

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:

llvm/test/DebugInfo/X86/dwarfdump-debug-loclists-dwarf64.s

+# RUN: llvm-mc %s -filetype obj -triple x86_64 -o - | \
+# RUN:   llvm-dwarfdump -v -debug-loclists - | \
+# RUN:   FileCheck %s
+
+# CHECK:      .debug_loclists contents:
+# CHECK-NEXT: locations list header:
+# CHECK-SAME: length = 0x0000000000000028,
+# CHECK-SAME: version = 0x0005,
+# CHECK-SAME: addr_size = 0x08,
+# CHECK-SAME: seg_size = 0x00,
+# CHECK-SAME: offset_entry_count = 0x00000002
+# CHECK-NEXT: offsets: [
+# CHECK-NEXT: 0x0000000000000010 => 0x00000024
+# CHECK-NEXT: 0x0000000000000018 => 0x0000002c
+# CHECK-NEXT: ]
+# CHECK-NEXT: 0x00000024:
+# CHECK-NEXT:   DW_LLE_offset_pair (0x0000000000000001, 0x0000000000000002): DW_OP_consts +7, DW_OP_stack_value
+# CHECK-NEXT:   DW_LLE_end_of_list ()
+# CHECK-EMPTY:
+# CHECK-NEXT: 0x0000002c:
+# CHECK-NEXT:   DW_LLE_offset_pair (0x0000000000000005, 0x0000000000000007): DW_OP_consts +12, DW_OP_stack_value
+# CHECK-NEXT:   DW_LLE_end_of_list ()
+
+    .section .debug_loclists, "", @progbits
+    .long 0xffffffff            # DWARF64 mark
+    .quad .LLLEnd-.LLLBegin     # Length
+.LLLBegin:
+    .short 5                    # Version
+    .byte 8                     # Address size
+    .byte 0                     # Segment selector size
+    .long 2                     # Offset entry count
+.LLLBase:
+    .quad .LLL0-.LLLBase
+    .quad .LLL1-.LLLBase
+.LLL0:
+    .byte 4                     # DW_LLE_offset_pair
+    .uleb128 1                  #   starting offset
+    .uleb128 2                  #   ending offset
+    .byte 3                     # Loc expr size
+    .byte 17                    # DW_OP_consts
+    .byte 7                     # 7
+    .byte 159                   # DW_OP_stack_value
+    .byte 0                     # DW_LLE_end_of_list
+
+.LLL1:
+    .byte 4                     # DW_LLE_offset_pair
+    .uleb128 5                  #   starting offset
+    .uleb128 7                  #   ending offset
+    .byte 3                     # Loc expr size
+    .byte 17                    # DW_OP_consts
+    .byte 12                    # 12
+    .byte 159                   # DW_OP_stack_value
+    .byte 0                     # DW_LLE_end_of_list
+.LLLEnd:

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

 # RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o - | \
 # RUN:   llvm-dwarfdump -debug-pubnames - | \
 # RUN:   FileCheck %s
 
 # CHECK: .debug_pubnames contents:
-# CHECK-NEXT: length = 0x00000032
+# CHECK-NEXT: length = 0x0000000000000032
 # CHECK-SAME: version = 0x0002
-# CHECK-SAME: unit_offset = 0x1122334455667788
-# CHECK-SAME: unit_size = 0x1100220033004400
+# CHECK-SAME: unit_offset = 0x0000112233445566
+# CHECK-SAME: unit_size = 0x0000110022003300
 # CHECK-NEXT: Offset     Name
-# CHECK-NEXT: 0xaa01aaaabbbbbbbb "foo"
-# CHECK-NEXT: 0xaa02aaaabbbbbbbb "bar"
+# CHECK-NEXT: 0x0000aa01aaaabbbb "foo"
+# CHECK-NEXT: 0x0000aa02aaaabbbb "bar"
 
     .section .debug_pubnames,"",@progbits
     .long 0xffffffff            # DWARF64 mark
     .quad .Lend - .Lversion     # Unit Length
 .Lversion:
     .short 2                    # Version
-    .quad 0x1122334455667788    # Debug Info Offset
-    .quad 0x1100220033004400    # Debug Info Length
-    .quad 0xaa01aaaabbbbbbbb    # Tuple0: Offset
+    .quad 0x112233445566        # Debug Info Offset
+    .quad 0x110022003300        # Debug Info Length
+    .quad 0xaa01aaaabbbb        # Tuple0: Offset
     .asciz "foo"                #         Name
-    .quad 0xaa02aaaabbbbbbbb    # Tuple1: Offset
+    .quad 0xaa02aaaabbbb        # Tuple1: Offset
     .asciz "bar"                #         Name
     .quad 0                     # Terminator
 .Lend:

llvm/test/DebugInfo/X86/dwarfdump-header-64.s

LH_5_params:
         .byte   0x53
         .byte   0x54
 LH_5_header_end:
         # Line number program, which is empty.
 LH_5_end:
 
 # CHECK-LABEL: .debug_line contents:
 # CHECK: Line table prologue:
-# CHECK: total_length: 0x00000050
+# CHECK: total_length: 0x0000000000000050
 # CHECK: version: 5
 # CHECK: address_size: 8
 # CHECK: seg_select_size: 0
-# CHECK: prologue_length: 0x00000044
+# CHECK: prologue_length: 0x0000000000000044
 # CHECK: max_ops_per_inst: 1
-# CHECK: include_directories[  0] = .debug_str[0x00000028] = "Directory5a"
-# CHECK: include_directories[  1] = .debug_str[0x00000034] = "Directory5b"
+# CHECK: include_directories[  0] = .debug_str[0x0000000000000028] = "Directory5a"
+# CHECK: include_directories[  1] = .debug_str[0x0000000000000034] = "Directory5b"
 # CHECK-NOT: include_directories
 # CHECK: file_names[  0]:
 # CHECK-NEXT: name: "File5a"
 # CHECK-NEXT: dir_index: 0
 # CHECK-NEXT: mod_time: 0x00000051
 # CHECK-NEXT: length: 0x00000052
 # CHECK: file_names[  1]:
 # CHECK-NEXT: name: "File5b"
 # CHECK-NEXT: dir_index: 1
 # CHECK-NEXT: mod_time: 0x00000053
 # CHECK-NEXT: length: 0x00000054
 # CHECK-NOT: file_names

llvm/test/DebugInfo/X86/dwarfdump-rnglists-dwarf64.s

 # RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o %t.o
 # RUN: not llvm-dwarfdump -v -debug-info %t.o 2> %t.err | FileCheck %s
 # RUN: FileCheck %s --input-file %t.err --check-prefix=ERR
 # RUN: not llvm-dwarfdump -lookup 10 %t.o 2> %t2.err
 # RUN: FileCheck %s --input-file %t2.err --check-prefix=ERR
+# RUN: llvm-dwarfdump -debug-rnglists %t.o | \
+# RUN:   FileCheck %s --check-prefix=RNGLISTS
 
 # Test object to verify dwarfdump handles v5 range lists in 64-bit DWARF format.
 # This is similar to 'dwarfdump-rnglists.s', which uses 32-bit DWARF format.
 # We use very simplified compile unit dies.
 # There are 2 full CUs with DW_AT_rnglists_base, one with a DW_AT_ranges
 # attribute using DW_FORM_sec_offset, the other with DW_AT_ranges using
 # DW_FORM_rnglistx.
 

 Range1_start:               # Range1: 0x2a - 0x34
         .space 10
 Range1_end:
 
 # CHECK:      .debug_info contents:
 # CHECK:      Compile Unit: 
 # CHECK-NOT:  Compile Unit:
 # CHECK:      DW_TAG_compile_unit
-# CHECK-NEXT: DW_AT_rnglists_base [DW_FORM_sec_offset]  (0x00000014)
-# CHECK-NEXT: DW_AT_ranges [DW_FORM_sec_offset] (0x00000024
+# CHECK-NEXT: DW_AT_rnglists_base [DW_FORM_sec_offset]  (0x0000000000000014)
+# CHECK-NEXT: DW_AT_ranges [DW_FORM_sec_offset] (0x0000000000000024
 # CHECK-NEXT: [0x00000014, 0x0000001e) ".text"
 # CHECK-NEXT: [0x0000002a, 0x00000034) ".text")
 
 # CHECK:      Compile Unit:
 # CHECK-NOT:  Compile Unit:
 # CHECK:      DW_TAG_compile_unit
-# CHECK-NEXT: DW_AT_rnglists_base [DW_FORM_sec_offset]  (0x00000014)
+# CHECK-NEXT: DW_AT_rnglists_base [DW_FORM_sec_offset]  (0x0000000000000014)
 # CHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x1) rangelist = 0x00000034
 # CHECK-NEXT: [0x0000002a, 0x00000034) ".text")
 
 # CHECK:      .debug_info.dwo contents:
 # CHECK:      Compile Unit:
 # CHECK-NOT:  contents:
 # CHECK:      DW_TAG_compile_unit
 # CHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x1) rangelist = 0x00000025
 # CHECK-NEXT: [0x0000002a, 0x00000034))
 
 #ERR: error: parsing a range list table: did not detect a valid list table with base = 0x8
 #ERR: error: decoding address ranges: missing or invalid range list table
 #ERR: error: decoding address ranges: invalid range list offset 0xfa0
+
+# RNGLISTS:      .debug_rnglists contents:
+# RNGLISTS:      range list header:
+# RNGLISTS-SAME:   length = 0x0000000000000031,
+# RNGLISTS-SAME:   version = 0x0005,
+# RNGLISTS-SAME:   addr_size = 0x04,
+# RNGLISTS-SAME:   seg_size = 0x00,
+# RNGLISTS-SAME:   offset_entry_count = 0x00000002
+# RNGLISTS-NEXT: offsets: [
+# RNGLISTS-NEXT: 0x0000000000000010
+# RNGLISTS-NEXT: 0x0000000000000020
+# RNGLISTS-NEXT: ]
+# RNGLISTS-NEXT: ranges:
+# RNGLISTS-NEXT: [0x00000014, 0x0000001e)
+# RNGLISTS-NEXT: [0x0000002a, 0x00000034)
+# RNGLISTS-NEXT: <End of list>
+# RNGLISTS-NEXT: [0x0000002a, 0x00000034)
+# RNGLISTS-NEXT: <End of list>
+
+# RNGLISTS:      .debug_rnglists.dwo contents:
+# RNGLISTS:      range list header:
+# RNGLISTS-SAME:   length = 0x0000000000000022,
+# RNGLISTS-SAME:   version = 0x0005,
+# RNGLISTS-SAME:   addr_size = 0x04,
+# RNGLISTS-SAME:   seg_size = 0x00,
+# RNGLISTS-SAME:   offset_entry_count = 0x00000002
+# RNGLISTS-NEXT: offsets: [
+# RNGLISTS-NEXT: 0x0000000000000010
+# RNGLISTS-NEXT: 0x0000000000000011
+# RNGLISTS-NEXT: ]
+# RNGLISTS-NEXT: ranges:
+# RNGLISTS-NEXT: <End of list>
+# RNGLISTS-NEXT: [0x0000002a, 0x00000034)
+# RNGLISTS-NEXT: <End of list>

llvm/test/DebugInfo/X86/dwarfdump-str-offsets-macho.s

 # COMMON-NOT:  NULL
 # COMMON:      DW_TAG_variable
 # COMMON-NEXT: DW_AT_name [DW_FORM_strx4] (indexed (00000006) string = "MyVar3")
 # 
 # Second compile unit (b.cpp)
 # COMMON:      DW_TAG_compile_unit
 # COMMON-NEXT: DW_AT_producer [DW_FORM_strx] (indexed (00000000) string = "Handmade DWARF producer")
 # COMMON-NEXT: DW_AT_name [DW_FORM_strx] (indexed (00000001) string = "Compile_Unit_2")
-# COMMON-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x00000038)
+# COMMON-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x0000000000000038)
 # COMMON-NEXT: DW_AT_comp_dir [DW_FORM_strx] (indexed (00000002) string = "/home/test/CU2")
 # 
 # The type unit
 # COMMON:      .debug_types contents:
 # COMMON:      DW_TAG_type_unit
 # COMMON-NEXT: DW_AT_name [DW_FORM_strx] (indexed (00000000) string = "Type_Unit")
 # COMMON-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset]       (0x00000058)
 # COMMON:      DW_TAG_structure_type
 # COMMON-NEXT: DW_AT_name [DW_FORM_strx] (indexed (00000001) string = "MyStruct")
 # 
 # The .debug_str_offsets section
 # COMMON:      .debug_str_offsets contents:
 # COMMON-NEXT: 0x00000000: Contribution size = 32, Format = DWARF32, Version = 5
 # COMMON-NEXT: 0x00000008: 00000000 "Handmade DWARF producer"
 # COMMON-NEXT: 0x0000000c: 00000018 "Compile_Unit_1"
 # COMMON-NEXT: 0x00000010: 00000027 "/home/test/CU1"
 # COMMON-NEXT: 0x00000014: 00000067 "MyFunc"
 # COMMON-NEXT: 0x00000018: 0000006e "MyVar1"
 # COMMON-NEXT: 0x0000001c: 00000075 "MyVar2"
 # COMMON-NEXT: 0x00000020: 0000007c "MyVar3"
 # COMMON-NEXT: 0x00000024: Gap, length = 4
 # COMMON-NEXT: 0x00000028: Contribution size = 28, Format = DWARF64, Version = 5
-# COMMON-NEXT: 0x00000038: 00000000 "Handmade DWARF producer"
-# COMMON-NEXT: 0x00000040: 00000036 "Compile_Unit_2"
-# COMMON-NEXT: 0x00000048: 00000045 "/home/test/CU2"
+# COMMON-NEXT: 0x00000038: 0000000000000000 "Handmade DWARF producer"
+# COMMON-NEXT: 0x00000040: 0000000000000036 "Compile_Unit_2"
+# COMMON-NEXT: 0x00000048: 0000000000000045 "/home/test/CU2"
 # COMMON-NEXT: 0x00000050: Contribution size = 12, Format = DWARF32, Version = 5
 # COMMON-NEXT: 0x00000058: 00000054 "Type_Unit"
 # COMMON-NEXT: 0x0000005c: 0000005e "MyStruct"

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

 
 # CHECK:      .debug_str.dwo contents:
 # CHECK-NEXT: 0x00000000: "Compilation Unit"
 # CHECK-NEXT: 0x00000011: "Type Unit"
 # CHECK-NEXT: 0x0000001b: "Structure"
 
 # CHECK:      .debug_str_offsets.dwo contents:
 # CHECK-NEXT: 0x00000000: Contribution size = 24, Format = DWARF64, Version = 4
-# CHECK-NEXT: 0x00000000: 00000000 "Compilation Unit"
-# CHECK-NEXT: 0x00000008: 00000011 "Type Unit"
-# CHECK-NEXT: 0x00000010: 0000001b "Structure"
+# CHECK-NEXT: 0x00000000: 0000000000000000 "Compilation Unit"
+# CHECK-NEXT: 0x00000008: 0000000000000011 "Type Unit"
+# CHECK-NEXT: 0x00000010: 000000000000001b "Structure"
 
     .section .debug_str.dwo, "MSe", @progbits, 1
 .LStr0:
     .asciz "Compilation Unit"
 .LStr1:
     .asciz "Type Unit"
 .LStr2:
     .asciz "Structure"

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

 # CHECK-NEXT: 0x00000016: "CU1 Producer"
 # CHECK-NEXT: 0x00000023: "CU1 Name"
 
 # CHECK:      .debug_str_offsets.dwo contents:
 # CHECK-NEXT: 0x00000000: Contribution size = 8, Format = DWARF32, Version = 4
 # CHECK-NEXT: 0x00000000: 00000000 "CU0 Producer"
 # CHECK-NEXT: 0x00000004: 0000000d "CU0 Name"
 # CHECK-NEXT: 0x00000008: Contribution size = 16, Format = DWARF64, Version = 4
-# CHECK-NEXT: 0x00000008: 00000016 "CU1 Producer"
-# CHECK-NEXT: 0x00000010: 00000023 "CU1 Name"
+# CHECK-NEXT: 0x00000008: 0000000000000016 "CU1 Producer"
+# CHECK-NEXT: 0x00000010: 0000000000000023 "CU1 Name"
 
     .section .debug_str.dwo, "MSe", @progbits, 1
 .LStr0:
     .asciz "CU0 Producer"
 .LStr1:
     .asciz "CU0 Name"
 .LStr2:
     .asciz "CU1 Producer"

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

 # COMMON-NOT:  NULL
 # COMMON:      DW_TAG_variable
 # COMMON-NEXT: DW_AT_name [DW_FORM_strx4] (indexed (00000006) string = "MyVar3")
 # 
 # Second compile unit (b.cpp)
 # COMMON:      DW_TAG_compile_unit
 # COMMON-NEXT: DW_AT_producer [DW_FORM_strx] (indexed (00000000) string = "Handmade DWARF producer")
 # COMMON-NEXT: DW_AT_name [DW_FORM_strx] (indexed (00000001) string = "Compile_Unit_2")
-# COMMON-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x00000038)
+# COMMON-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x0000000000000038)
 # COMMON-NEXT: DW_AT_comp_dir [DW_FORM_strx] (indexed (00000002) string = "/home/test/CU2")
 # 
 # The split CU
 # SPLIT:       .debug_info.dwo contents:
 # SPLIT-NOT:   contents:
 # SPLIT:       DW_TAG_compile_unit
 # SPLIT-NEXT:  DW_AT_producer [DW_FORM_strx] (indexed (00000000) string = "Handmade split DWARF producer")
 # SPLIT-NEXT:  DW_AT_name [DW_FORM_strx] (indexed (00000001) string = "V5_split_compile_unit")

 # COMMON-NEXT: 0x0000000c: 00000018 "Compile_Unit_1"
 # COMMON-NEXT: 0x00000010: 00000027 "/home/test/CU1"
 # COMMON-NEXT: 0x00000014: 00000067 "MyFunc"
 # COMMON-NEXT: 0x00000018: 0000006e "MyVar1"
 # COMMON-NEXT: 0x0000001c: 00000075 "MyVar2"
 # COMMON-NEXT: 0x00000020: 0000007c "MyVar3"
 # COMMON-NEXT: Gap, length = 4
 # COMMON-NEXT: 0x00000028: Contribution size = 28, Format = DWARF64, Version = 5
-# COMMON-NEXT: 0x00000038: 00000000 "Handmade DWARF producer"
-# COMMON-NEXT: 0x00000040: 00000036 "Compile_Unit_2"
-# COMMON-NEXT: 0x00000048: 00000045 "/home/test/CU2"
+# COMMON-NEXT: 0x00000038: 0000000000000000 "Handmade DWARF producer"
+# COMMON-NEXT: 0x00000040: 0000000000000036 "Compile_Unit_2"
+# COMMON-NEXT: 0x00000048: 0000000000000045 "/home/test/CU2"
 # COMMON-NEXT: 0x00000050: Contribution size = 12, Format = DWARF32, Version = 5
 # COMMON-NEXT: 0x00000058: 00000054 "Type_Unit"
 # COMMON-NEXT: 0x0000005c: 0000005e "MyStruct"
 # 
 # SPLIT:       .debug_str_offsets.dwo contents:
 # SPLIT-NEXT:  0x00000000: Contribution size = 24, Format = DWARF32, Version = 5
 # SPLIT-NEXT:  0x00000008: 00000000 "Handmade split DWARF producer"
 # SPLIT-NEXT:  0x0000000c: 0000001e "V5_split_compile_unit"
 # SPLIT-NEXT:  0x00000010: 00000034 "/home/test/splitCU"
 # SPLIT-NEXT:  0x00000014: 00000047 "V5_split_type_unit"
 # SPLIT-NEXT:  0x00000018: 0000005a "V5_split_Mystruct"
 
 # VERIFY: No errors.
 
 # ERR-NOT: parsing a range list table:

llvm/test/DebugInfo/X86/dwp-dwarf64.s

 # RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o - | \
 # RUN:   llvm-dwarfdump -debug-info - | \
 # RUN:   FileCheck %s
 
 # CHECK:      .debug_info.dwo contents:
 
 # CHECK:      0x00000000: Compile Unit:
-# CHECK-SAME:   length = 0x00000018
+# CHECK-SAME:   length = 0x0000000000000018
 # CHECK-SAME:   version = 0x0004
 # CHECK-SAME:   abbr_offset = 0x0000
 # CHECK-SAME:   addr_size = 0x04
 
 # CHECK:      0x00000017: DW_TAG_compile_unit
 # CHECK-NEXT:   DW_AT_name ("a.c")
 # CHECK-NEXT:   DW_AT_GNU_dwo_id (0x1100001122222222)
 

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

 RUN: llvm-dwarfdump %p/Inputs/dwarfdump.elf-mips64-64-bit-dwarf \
 RUN:   --debug-line | FileCheck %s
 
 # FIXME: llvm-dwarfdump's support for 64-bit dwarf is currently limited to
 # .debug_line.
 
-CHECK:   total_length: 0x00000212
+CHECK:   total_length: 0x0000000000000212
 CHECK:        version: 2
-CHECK:prologue_length: 0x000001ab
+CHECK:prologue_length: 0x00000000000001ab
 CHECK:min_inst_length: 1
 CHECK:default_is_stmt: 1
 CHECK:      line_base: -5
 CHECK:     line_range: 14
 CHECK:    opcode_base: 13
 CHECK: is_stmt end_sequence
 
-CHECK:   total_length: 0x0000007c
+CHECK:   total_length: 0x000000000000007c
 CHECK:        version: 2
-CHECK:prologue_length: 0x00000048
+CHECK:prologue_length: 0x0000000000000048
 CHECK:min_inst_length: 1
 CHECK:default_is_stmt: 1
 CHECK:      line_base: -5
 CHECK:     line_range: 14
 CHECK:    opcode_base: 13
 CHECK: is_stmt end_sequence
 
-CHECK:   total_length: 0x00000094
+CHECK:   total_length: 0x0000000000000094
 CHECK:        version: 2
-CHECK:prologue_length: 0x00000044
+CHECK:prologue_length: 0x0000000000000044
 CHECK:min_inst_length: 1
 CHECK:default_is_stmt: 1
 CHECK:      line_base: -5
 CHECK:     line_range: 14
 CHECK:    opcode_base: 13
 CHECK: is_stmt end_sequence
 
-CHECK:   total_length: 0x0000007c
+CHECK:   total_length: 0x000000000000007c
 CHECK:        version: 2
-CHECK:prologue_length: 0x00000048
+CHECK:prologue_length: 0x0000000000000048
 CHECK:min_inst_length: 1
 CHECK:default_is_stmt: 1
 CHECK:      line_base: -5
 CHECK:     line_range: 14
 CHECK:    opcode_base: 13
 CHECK: is_stmt end_sequence

llvm/test/tools/llvm-dwarfdump/X86/debug_info_min_dwarf64.s

# RUN:   FileCheck %s
         .byte 0x00  # EOM(3)
         
         .section .debug_info,"",@progbits
 # CHECK: .debug_info contents:
 # CHECK-NEXT: 0x00000000: Compile Unit:
 DI_4_64_start:
         .long 0xffffffff       # DWARF64 mark
         .quad DI_4_64_end - DI_4_64_version # Length of Unit
-# CHECK-SAME: length = 0x0000000f
+# CHECK-SAME: length = 0x000000000000000f
 DI_4_64_version:
         .short 4               # DWARF version number
 # CHECK-SAME: version = 0x0004
         .quad .debug_abbrev    # Offset Into Abbrev. Section
 # CHECK-SAME: abbr_offset = 0x0000
         .byte 8                # Address Size (in bytes)
 # CHECK-SAME: addr_size = 0x08
 # CHECK-SAME: (next unit at 0x0000001b)
 
         .byte 1                # Abbreviation code
 # CHECK: 0x00000017: DW_TAG_compile_unit
         .short 4               # DW_LANG_C_plus_plus
 # CHECK-NEXT: DW_AT_language (DW_LANG_C_plus_plus)
         .byte 0                # NULL
 DI_4_64_end:
 

llvm/test/tools/llvm-dwarfdump/X86/debug_line_dwarf64_large_table.s

 ## Test that we can dump the (intact) prologue of a large table which was
 ## truncated. Also, make sure we don't get confused by a DWARF64 length which
 ## matches one of the reserved initial length values.
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux %s >%t
 # RUN: llvm-dwarfdump %t -debug-line 2>&1 | FileCheck %s
 
 # CHECK: debug_line[0x00000000]
 # CHECK-NEXT: warning: line table program with offset 0x00000000 has length 0xfffffffc but only 0x0000003a bytes are available
 # CHECK-NEXT: Line table prologue:
-# CHECK-NEXT:     total_length: 0xfffffff0
+# CHECK-NEXT:     total_length: 0x00000000fffffff0
 # CHECK-NEXT:          version: 4
-# CHECK-NEXT:  prologue_length: 0x00000016
+# CHECK-NEXT:  prologue_length: 0x0000000000000016
 
 # CHECK:      0x000000000badbeef      1      0      1   0             0  is_stmt end_sequence
 
 .section .debug_line,"",@progbits
 .long   0xffffffff      # Length of Unit (DWARF-64 format)
 .quad   0xfffffff0
 .short  4               # DWARF version number
 .quad   .Lprologue1_end-.Lprologue1_start # Length of Prologue

llvm/test/tools/llvm-dwarfdump/X86/debug_rnglists_dwarf64.s

 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o - | \
 # RUN:   llvm-dwarfdump -v --debug-rnglists - | \
 # RUN:   FileCheck %s
 
 # CHECK:      .debug_rnglists contents:
 # CHECK-NEXT: 0x00000000: range list header:
-# CHECK-SAME:   length = 0x0000001a,
+# CHECK-SAME:   length = 0x000000000000001a,
 # CHECK-SAME:   version = 0x0005,
 # CHECK-SAME:   addr_size = 0x08,
 # CHECK-SAME:   seg_size = 0x00,
 # CHECK-SAME:   offset_entry_count = 0x00000002
 # CHECK-NEXT: offsets: [
-# CHECK-NEXT: 0x00000010 => 0x00000024
-# CHECK-NEXT: 0x00000011 => 0x00000025
+# CHECK-NEXT: 0x0000000000000010 => 0x00000024
+# CHECK-NEXT: 0x0000000000000011 => 0x00000025
 # CHECK-NEXT: ]
 # CHECK-NEXT: ranges:
 # CHECK-NEXT: 0x00000024: [DW_RLE_end_of_list]
 # CHECK-NEXT: 0x00000025: [DW_RLE_end_of_list]
 
     .section .debug_rnglists,"",@progbits
     .long 0xffffffff         # DWARF64 mark
     .quad .Lend - .Lversion  # Table length

llvm/test/tools/llvm-dwarfdump/X86/typeunit-v4-dwarf64.s

# RUN:   FileCheck %s
         .byte 0x00  # EOM(3)
 
         .section .debug_types,"",@progbits
 # CHECK: .debug_types contents:
 # CHECK-NEXT: 0x00000000: Type Unit:
 TU_4_64_start:
         .long 0xffffffff            # DWARF64 mark
         .quad TU_4_64_end-TU_4_64_version  # Length of Unit
-# CHECK-SAME: length = 0x00000021
+# CHECK-SAME: length = 0x0000000000000021
 TU_4_64_version:
         .short 4                    # DWARF version number
 # CHECK-SAME: version = 0x0004
         .quad .debug_abbrev         # Offset Into Abbrev. Section
 # CHECK-SAME: abbr_offset = 0x0000
         .byte 8                     # Address Size (in bytes)
 # CHECK-SAME: addr_size = 0x08
 # CHECK-SAME: name = ''

llvm/test/tools/llvm-dwarfdump/X86/typeunit-v5-dwarf64.s

# RUN:   FileCheck %s
         .byte 0x00  # EOM(3)
 
         .section .debug_info,"",@progbits
 # CHECK: .debug_info contents:
 # CHECK-NEXT: 0x00000000: Type Unit:
 TU_5_64_start:
         .long 0xffffffff            # DWARF64 mark
         .quad TU_5_64_end-TU_5_64_version  # Length of Unit
-# CHECK-SAME: length = 0x00000022
+# CHECK-SAME: length = 0x0000000000000022
 TU_5_64_version:
         .short 5                    # DWARF version number
 # CHECK-SAME: version = 0x0005
         .byte 2                     # DW_UT_type
         .byte 8                     # Address Size (in bytes)
         .quad .debug_abbrev         # Offset Into Abbrev. Section
 # CHECK-SAME: abbr_offset = 0x0000
 # CHECK-SAME: addr_size = 0x08

llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp

 const uint64_t DumpTestSample64Val = 0x11223344556677;
 ArrayRef<uint8_t> DumpTestSample64 = toBytes(DumpTestSample64Val);
 
 INSTANTIATE_TEST_CASE_P(
     DumpValueParams, DumpValueFixture,
     testing::Values(DumpValueParams{DW_FORM_strp, DumpTestSample32, DWARF32,
                                     " .debug_str[0x00112233] = "},
                     DumpValueParams{DW_FORM_strp, DumpTestSample64, DWARF64,
-                                    " .debug_str[0x11223344556677] = "},
+                                    " .debug_str[0x0011223344556677] = "},
                     DumpValueParams{DW_FORM_line_strp, DumpTestSample32,
                                     DWARF32, " .debug_line_str[0x00112233] = "},
                     DumpValueParams{DW_FORM_line_strp, DumpTestSample64,
                                     DWARF64,
-                                    " .debug_line_str[0x11223344556677] = "},
+                                    " .debug_line_str[0x0011223344556677] = "},
                     DumpValueParams{DW_FORM_sec_offset, DumpTestSample32,
                                     DWARF32, "0x00112233"},
                     DumpValueParams{DW_FORM_sec_offset, DumpTestSample64,
-                                    DWARF64, "0x11223344556677"}), );
+                                    DWARF64, "0x0011223344556677"}), );
 
 } // end anonymous namespace