[DebugInfo] Report the format of the DWARF64 sections.

[ikudrin]

Summary

The patch adds printing a special mark when dumping a section which is in the 64-bit DWARF format, which helps to distinguish the actual format of the section.

[jhenderson]

llvm/lib/DebugInfo/DWARF/DWARFCompileUnit.cpp

20–21

I wonder if it would make sense to print DWARF32 for when we're not using DWARF64? That would make the output more regular and parseable. What do you think?

llvm/test/DebugInfo/X86/debug-frame-dwarf64.s

1

Is there no testing already for DWARF64 debug_frame? If not, you should probably test the length fields and any other bits that are DWARF64 related too. If you don't want to do it as part of this change, that's fine, but perhaps it should be a prerequisite?

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

212

This block might belong below the ERR block to match order of usage.

247

Nit: too many blank lines.

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

2

Nit: unrelated (and bad?) change.

[ikudrin]

Thanks, @jhenderson! I'll address the comments in the next update.

llvm/lib/DebugInfo/DWARF/DWARFCompileUnit.cpp

20–21

I thought about that, but the changes in the output would make it incompatible with lots of existing tests and, probably, might affect some external tools.

[dblaikie]

Perhaps it'd be too subtle, but another direction we could go would be to print the length as 32 or 64 bits depending on the encoding and using that to signal 64/32, without an explicit field. It'd match the input format (where the size of the length indicates whether it's 32 or 64).

[ikudrin]

In D78208#1986988, @dblaikie wrote:

Perhaps it'd be too subtle, but another direction we could go would be to print the length as 32 or 64 bits depending on the encoding and using that to signal 64/32, without an explicit field. It'd match the input format (where the size of the length indicates whether it's 32 or 64).

The idea is interesting, but the output would not be that explicit, right? And all the leading zeros would look so tedious to my taste. Moreover, it would require changes in more places in the code to make the output uniform.

Another possibility is the way used in readelf:

Compilation Unit @ offset 0x0:
 Length:        0x430 (32-bit)

or

Length:        0x430 (64-bit)

However, it looks like it does that only for .debug_info sections; for other debug tables it just prints the value of the length. And for some sections, like .debug_frame, that approach cannot be used without breaking the output format.

[ikudrin]

I am open to the discussion about the best ways to indicate the 64-bit DWARF format. Meanwhile, fixing the nits spotted by @jhenderson. Thanks again!

llvm/test/DebugInfo/X86/debug-frame-dwarf64.s

1

Let's add the test right here.

[jhenderson]

I thought about that, but the changes in the output would make it incompatible with lots of existing tests and, probably, might affect some external tools.

I think the effect on external tools is a non-issue, not in the sense that it wouldn't be a problem (it could be), but rather in the sense that as it stands, this change introduces an issue anyway, since the external tools might suddenly start seeing this new format, or worse, might start seeing it at a future point when something causes a file to start using DWARF64.

Everything else in this change looks fine to me. I also don't feel strongly about the above point - nothing actually produces DWARF64 currently that I know of, so maybe it's not worth worrying about too much either way.

[ikudrin]

In D78208#1988941, @jhenderson wrote:

Everything else in this change looks fine to me. I also don't feel strongly about the above point - nothing actually produces DWARF64 currently that I know of, so maybe it's not worth worrying about too much either way.

Well, actually, I am going to add that generating soon. I am adding the reporting so that there will be a tool to be used in the tests.

[dblaikie]

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

302

Looks like this format already provides some precedent for using 16 hex digit alignment for DWARF64 and 8 for DWARF32. It seems like you've updated /some/ places to do that but not all? (eg: debug_pubnames still seems to use an 8 hex digit rendering of the length )

& yeah, as Jared mentioned - I don't think the text format of the dumper is a place to worry too much about format changing, etc. But I don't feel /super/ strongly about only rendering this data via the length of the length field, versus being more explicit in some way, but I'd like the length rendering to be consistent across the different length fields/sections/etc.

[ikudrin]

• Rebased on top of D79997

[jhenderson]

Given D79997, do we really need this still? The DWARF format of something could be inferred from the width of the length field, I'd think.

[ikudrin]

In D78208#2041180, @jhenderson wrote:

Given D79997, do we really need this still? The DWARF format of something could be inferred from the width of the length field, I'd think.

I am starting working on producers so that they are able to generate DWARF64 debugging info. Dumping the actual format of sections will make tests for them more explicit.

[aprantl]

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

302

I can speak from experience that I received a surprising of reports about various broken perl scripts whenever we changed the output format of dwarfdump, so it's reasonable to be mindful. But this change is additive and carries important information, so let's do it!

[jhenderson]

So, given we're going to start emitting DWARF64 stuff, unless it is going to be forevermore opt-in only (it won't...), I do think my earlier point stands, that people need to expect that output will sometimes change, if it means producing more useful output. In this case too, if the output might suddenly change and break their scripts, just because their debug data has grown a few bytes bigger, it might be very confusing. I think we should just bite the bullet, make the output format change for DWARF32 too, and document the change in behaviour in a release note. Yes, it will break things, but better that people are aware why there's a sudden breakage rather than one appearing in 5 years time when their DWARF grows a bit too big.

[ikudrin]

I've prepared an alternative version, which reports both 32- and 64-bit formats, D80523. Let's check and decide, which is more preferable, compatibility or consistency of the reports.

[ikudrin]

Abandoning in favor of D80523.

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/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/DWARFAcceleratorTable.cpp

if (Key == StringSection.getCStr(&StringOffset))
       return make_range({*this, DataOffset}, ValueIterator());
   }
   return make_range(ValueIterator(), ValueIterator());
 }
 
 void DWARFDebugNames::Header::dump(ScopedPrinter &W) const {
   DictScope HeaderScope(W, "Header");
   W.printHex("Length", UnitLength);
+  if (Format == dwarf::DWARF64)
+    W.printString("Format", "DWARF64");
   W.printNumber("Version", Version);
   W.printNumber("CU count", CompUnitCount);
   W.printNumber("Local TU count", LocalTypeUnitCount);
   W.printNumber("Foreign TU count", ForeignTypeUnitCount);
   W.printNumber("Bucket count", BucketCount);
   W.printNumber("Name count", NameCount);
   W.printHex("Abbreviations table size", AbbrevTableSize);
   W.startLine() << "Augmentation: '" << AugmentationString << "'\n";

llvm/lib/DebugInfo/DWARF/DWARFCompileUnit.cpp

 #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) {
   OS << format("0x%08" PRIx64, getOffset()) << ": Compile Unit:"
-     << " length = " << format("0x%08" PRIx64, getLength())
-     << " version = " << format("0x%04x", getVersion());
+     << " length = " << format("0x%08" PRIx64, getLength());
+  if (getFormat() == dwarf::DWARF64)
+    OS << " format = DWARF64";
+  OS << " 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());
   OS << " (next unit at " << format("0x%08" PRIx64, getNextUnitOffset())

llvm/lib/DebugInfo/DWARF/DWARFDebugAddr.cpp

WarnCallback(createStringError(errc::invalid_argument,
                                    " assuming version 5"));
   return extractV5(Data, OffsetPtr, CUAddrSize, WarnCallback);
 }
 
 void DWARFDebugAddrTable::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
   if (DumpOpts.Verbose)
     OS << format("0x%8.8" PRIx64 ": ", Offset);
   if (Length) {
-    int LengthFieldWidth = (Format == dwarf::DwarfFormat::DWARF64) ? 16 : 8;
-    OS << format("Address table header: length = 0x%0*" PRIx64
-                 ", version = 0x%4.4" PRIx16 ", addr_size = 0x%2.2" PRIx8
+    OS << "Address table header: ";
+    if (Format == dwarf::DwarfFormat::DWARF64)
+      OS << format("length = 0x%016" PRIx64 ", format = DWARF64", Length);
+    else
+      OS << format("length = 0x%08" PRIx64, Length);
+    OS << format(", version = 0x%4.4" PRIx16 ", addr_size = 0x%2.2" PRIx8
                  ", seg_size = 0x%2.2" PRIx8 "\n",
-                 LengthFieldWidth, Length, Version, AddrSize, SegSize);
+                 Version, AddrSize, SegSize);
   }
 
   if (Addrs.size() > 0) {
     const char *AddrFmt =
         (AddrSize == 4) ? "0x%8.8" PRIx64 "\n" : "0x%16.16" PRIx64 "\n";
     OS << "Addrs: [\n";
     for (uint64_t Addr : Addrs)
       OS << format(AddrFmt, Addr);

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 {
   OS << "Address Range Header: "
-     << format("length = 0x%8.8" PRIx64 ", ", HeaderData.Length)
-     << format("version = 0x%4.4x, ", HeaderData.Version)
+     << format("length = 0x%8.8" PRIx64 ", ", HeaderData.Length);
+  if (HeaderData.Format == dwarf::DWARF64)
+    OS << "format = DWARF64, ";
+  OS << format("version = 0x%4.4x, ", HeaderData.Version)
      << format("cu_offset = 0x%8.8" PRIx64 ", ", 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/DWARFDebugFrame.cpp

if (IsEH)
     return 0;
   if (IsDWARF64)
     return DW64_CIE_ID;
   return DW_CIE_ID;
 }
 
 void CIE::dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH) const {
   OS << format("%08" PRIx64, Offset)
      << format(" %0*" PRIx64, IsDWARF64 ? 16 : 8, Length)
      << format(" %0*" PRIx64, IsDWARF64 && !IsEH ? 16 : 8,
                getCIEId(IsDWARF64, IsEH))
      << " CIE\n";
+  if (IsDWARF64)
+    OS << "  Format:                DWARF64\n";
   OS << format("  Version:               %d\n", Version);
   OS << "  Augmentation:          \"" << Augmentation << "\"\n";
   if (Version >= 4) {
     OS << format("  Address size:          %u\n", (uint32_t)AddressSize);
     OS << format("  Segment desc size:     %u\n",
                  (uint32_t)SegmentDescriptorSize);
   }
   OS << format("  Code alignment factor: %u\n", (uint32_t)CodeAlignmentFactor);
OS << format("%08" PRIx64, Offset)
      << format(" %0*" PRIx64, IsDWARF64 && !IsEH ? 16 : 8, CIEPointer)
      << " FDE cie=";
   if (LinkedCIE)
     OS << format("%08" PRIx64, LinkedCIE->getOffset());
   else
     OS << "<invalid offset>";
   OS << format(" pc=%08" PRIx64 "...%08" PRIx64 "\n", InitialLocation,
                InitialLocation + AddressRange);
+  if (IsDWARF64)
+    OS << "  Format:       DWARF64\n";
   if (LSDAAddress)
     OS << format("  LSDA Address: %016" PRIx64 "\n", *LSDAAddress);
   CFIs.dump(OS, MRI, IsEH);
   OS << "\n";
 }
 
 DWARFDebugFrame::DWARFDebugFrame(Triple::ArchType Arch,
     bool IsEH, uint64_t EHFrameAddress)

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

void DWARFDebugLine::Prologue::clear() {
   FileNames.clear();
 }
 
 void DWARFDebugLine::Prologue::dump(raw_ostream &OS,
                                     DIDumpOptions DumpOptions) const {
   if (!totalLengthIsValid())
     return;
   OS << "Line table prologue:\n"
-     << format("    total_length: 0x%8.8" PRIx64 "\n", TotalLength)
-     << format("         version: %u\n", getVersion());
+     << format("    total_length: 0x%8.8" PRIx64 "\n", TotalLength);
+  if (isDWARF64())
+    OS << "          format: DWARF64\n";
+  OS << 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)
      << format(" min_inst_length: %u\n", MinInstLength)
      << format(getVersion() >= 4 ? "max_ops_per_inst: %u\n" : "", MaxOpsPerInst)

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);
+    if (S.Format == dwarf::DWARF64)
+      OS << " format = DWARF64";
     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 << (GnuStyle ? "Offset     Linkage  Kind     Name\n"
                     : "Offset     Name\n");
 
     for (const Entry &E : S.Entries) {
       OS << format("0x%8.8" PRIx64 " ", E.SecOffset);

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);
+  OS << format("%s list header: length = 0x%8.8" PRIx64, ListTypeString.data(),
+               HeaderData.Length);
+  if (Format == dwarf::DWARF64)
+    OS << ", format = DWARF64";
+  OS << format(", 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",
+               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);
       if (DumpOpts.Verbose)
         OS << format(" => 0x%8.8" PRIx64,
                      Off + HeaderOffset + getHeaderSize(Format));

llvm/lib/DebugInfo/DWARF/DWARFTypeUnit.cpp

void DWARFTypeUnit::dump(raw_ostream &OS, DIDumpOptions DumpOpts) {
   if (DumpOpts.SummarizeTypes) {
     OS << "name = '" << Name << "'"
        << " type_signature = " << format("0x%016" PRIx64, getTypeHash())
        << " length = " << format("0x%08" PRIx64, getLength()) << '\n';
     return;
   }
 
   OS << format("0x%08" PRIx64, getOffset()) << ": Type Unit:"
-     << " length = " << format("0x%08" PRIx64, getLength())
-     << " version = " << format("0x%04x", getVersion());
+     << " length = " << format("0x%08" PRIx64, getLength());
+  if (getFormat() == dwarf::DWARF64)
+    OS << " format = DWARF64";
+  OS << " 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())
      << " type_offset = " << format("0x%04" PRIx64, getTypeOffset())
      << " (next unit at " << format("0x%08" PRIx64, getNextUnitOffset())
      << ")\n";
 
   if (DWARFDie TU = getUnitDIE(false))
     TU.dump(OS, 0, DumpOpts);
   else
     OS << "<type unit can't be parsed!>\n\n";
 }

llvm/test/DebugInfo/X86/debug-frame-dwarf64.s

+# RUN: llvm-mc -triple x86_64 %s -filetype=obj -o - | \
+# RUN:   llvm-dwarfdump -debug-frame - | \
+# RUN:   FileCheck %s
+
+# CHECK:      .debug_frame contents:
+# CHECK:      CIE
+# CHECK-NEXT: Format: DWARF64
+# CHECK:      FDE
+# CHECK-NEXT: Format: DWARF64
+
+    .section .debug_frame, "", @progbits
+.LCIE:
+    .long 0xffffffff            # DWARF64 mark
+    .quad .LCIEend-.LCIEid      # Length
+.LCIEid:
+    .quad 0xffffffffffffffff    # CIE id
+    .byte 4                     # Version
+    .asciz ""                   # Augmentation
+    .byte 8                     # Address size
+    .byte 0                     # Segment selector size
+    .uleb128 1                  # Code alignment factor
+    .sleb128 -8                 # Data alignment factor
+    .uleb128 16                 # Return address register
+    .byte 0                     # DW_CFA_nop
+.LCIEend:
+.LFDE:
+    .long 0xffffffff            # DWARF64 mark
+    .quad .LFDEend-.LFDEcieptr  # Length
+.LFDEcieptr:
+    .quad .LCIE-.debug_frame    # CIE pointer
+    .quad 0x00112233            # Initial location
+    .quad 0x00010000            # Address range
+.LFDEend:

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

 # 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 = 0x0000001c, format = DWARF64,
 .L4version:
     .short  2                       # Version
     .quad   0x1234567899aabbcc      # Debug Info Offset
     .byte   4                       # Address Size
     .byte   0                       # Segment Selector Size
 # CHECK-SAME: version = 0x0002,
 # CHECK-SAME: cu_offset = 0x1234567899aabbcc,
 # 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-names.s

 # CHECK-NEXT:         DW_IDX_die_offset: 0x00000001
 # CHECK-NEXT:       }
 # CHECK-NEXT:     }
 # CHECK-NEXT:   ]
 # CHECK-NEXT: }
 # CHECK-NEXT: Name Index @ 0xac {
 # CHECK-NEXT:   Header {
 # CHECK-NEXT:     Length: 0x68
+# CHECK-NEXT:     Format: DWARF64
 # CHECK-NEXT:     Version: 5
 # CHECK-NEXT:     CU count: 1
 # CHECK-NEXT:     Local TU count: 1
 # CHECK-NEXT:     Foreign TU count: 1
 # CHECK-NEXT:     Bucket count: 1
 # CHECK-NEXT:     Name count: 1
 # CHECK-NEXT:     Abbreviations table size: 0x9
 # CHECK-NEXT:     Augmentation: ''

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-SAME: format = DWARF64
 # CHECK-SAME: version = 0x0002
 # CHECK-SAME: unit_offset = 0x1122334455667788
 # CHECK-SAME: unit_size = 0x1100220033004400
 # CHECK-NEXT: Offset     Name
 # CHECK-NEXT: 0xaa01aaaabbbbbbbb "foo"
 # CHECK-NEXT: 0xaa02aaaabbbbbbbb "bar"
 
     .section .debug_pubnames,"",@progbits

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.
 

 
 # 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))
 
+# RNGLISTS:      .debug_rnglists contents:
+# RNGLISTS:      range list header:
+# RNGLISTS-SAME:   length = 0x00000031,
+# RNGLISTS-SAME:   format = DWARF64,
+# 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: 0x00000010
+# RNGLISTS-NEXT: 0x00000020
+# 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 = 0x00000022,
+# RNGLISTS-SAME:   format = DWARF64,
+# 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: 0x00000010
+# RNGLISTS-NEXT: 0x00000011
+# RNGLISTS-NEXT: ]
+# RNGLISTS-NEXT: ranges:
+# RNGLISTS-NEXT: <End of list>
+# RNGLISTS-NEXT: [0x0000002a, 0x00000034)
+# RNGLISTS-NEXT: <End of list>
+
+
 #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

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

 RUN: llvm-dwarfdump %p/Inputs/dwarfdump.elf-mips64-64-bit-dwarf \
-RUN:   --debug-line | FileCheck %s
+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:         format: DWARF64
 CHECK:        version: 2
 CHECK:prologue_length: 0x000001ab
 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:         format: DWARF64
 CHECK:        version: 2
 CHECK:prologue_length: 0x00000048
 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:         format: DWARF64
 CHECK:        version: 2
 CHECK:prologue_length: 0x00000044
 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:         format: DWARF64
 CHECK:        version: 2
 CHECK:prologue_length: 0x00000048
 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_addr_dwarf64.s

 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o - | \
 # RUN:   llvm-dwarfdump -debug-addr - | \
 # RUN:   FileCheck %s
 
 # CHECK:      .debug_addr contents:
 # CHECK-NEXT: Address table header:
 # CHECK-SAME: length = 0x000000000000000c,
+# CHECK-SAME: format = DWARF64,
 # CHECK-SAME: version = 0x0005,
 # CHECK-SAME: addr_size = 0x04,
 # CHECK-SAME: seg_size = 0x00
 # CHECK-NEXT: Addrs: [
 # CHECK-NEXT: 0x00000000
 # CHECK-NEXT: 0x00001000
 # CHECK-NEXT: ]
 

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 = 0x0000000f format = DWARF64
 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:           format: DWARF64
 # CHECK-NEXT:          version: 4
 # CHECK-NEXT:  prologue_length: 0x00000016
 
 # 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

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 = 0x00000021 format = DWARF64
 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 = 0x00000022 format = DWARF64
 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