[DebugInfo] Report the format of debug info tables.

[ikudrin]

Summary

This adds printing the format, DWARF32 or DWARF64, when dumping debug info sections so that the actual format of a table can be read directly from the report.

This is an alternative for D78208, where only the 64-bit format was reported and the reports for the 32-bit format, which is a prevailing case, were not changed. While D78208 is much safer, this patch may be considered as more consistent.

[MaskRay]

I vote for this patch (explicit format = DWARF{32,64})

[jhenderson]

Thanks, LGTM, but obviously wait for others to give their input.

llvm/test/DebugInfo/dwarfdump-pubnames.test

5

Aside: it's weird that some outputs use commas to separate things and others don't.

[probinson]

I believe GNU readelf and friends tend to put this info after the length, e.g. "Length: 0x1234 (64-bit)" or "Length: 0x1234 (32-bit)" so it might be worth being vaguely similar.

[ikudrin]

In D80523#2057999, @probinson wrote:

I believe GNU readelf and friends tend to put this info after the length, e.g. "Length: 0x1234 (64-bit)" or "Length: 0x1234 (32-bit)" so it might be worth being vaguely similar.

We do not follow their dumping format, so we should be free to choose our own way. Note also that we already report the format of .debug_str_offsets sections like format = DWARF32/64. Personally, I do not have any strong preferences for any dumping format. I just need some reliable way to write tests for producers.

[ikudrin]

llvm/test/DebugInfo/dwarfdump-pubnames.test

5

I've prepared D80806 for that.

[ikudrin]

• Rebased on the tip.

[probinson]

LGTM with the suggested helper.

llvm/include/llvm/BinaryFormat/Dwarf.h

484

And a helper taking bool IsDWARF64) here, so DWARFDebugFrame isn't using it's own idea of the format strings.

StringRef FormatString(bool IsDWARF64) {
  return FormatString(IsDWARF64 ? DWARF64 : DWARF32);
}

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

318

Use FormatString(bool) helper here.

354

Use FormatString(bool) helper here.

[ikudrin]

Thanks to all reviewers! It looks like we have reached the consensus at this variant, so I am going to land it, splitting into smaller parts for individual tables.

lld/test/ELF/eh-frame-hdr-augmentation.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld --hash-style=sysv --eh-frame-hdr %t.o -o %t -shared
 // RUN: llvm-objdump --dwarf=frames %t | FileCheck %s
 
 // CHECK: .eh_frame contents:
 
 // CHECK:      00000000 0000001c 00000000 CIE
+// CHECK-NEXT:   Format:                DWARF32
 // CHECK-NEXT:   Version:                       1
 // CHECK-NEXT:   Augmentation:             "zPLR"
 // CHECK-NEXT:   Code alignment factor: 1
 // CHECK-NEXT:   Data alignment factor: -8
 // CHECK-NEXT:   Return address column: 16
 // CHECK-NEXT:   Personality Address: 0000000000001029
 // CHECK-NEXT:   Augmentation data:
 
 // CHECK:      DW_CFA_def_cfa:  reg7 +8
 // CHECK-NEXT: DW_CFA_offset:   reg16 -8
 // CHECK-NEXT: DW_CFA_nop:
 // CHECK-NEXT: DW_CFA_nop:
 
 // CHECK:      00000020 00000014 00000024 FDE cie=00000000 pc=00001014...00001014
+// CHECK-NEXT:   Format:       DWARF32
 // CHECK-NEXT:   LSDA Address: 000000000000100b
 // CHECK-NEXT:   DW_CFA_nop:
 // CHECK-NEXT:   DW_CFA_nop:
 // CHECK-NEXT:   DW_CFA_nop:
 
         .cfi_startproc
         .cfi_personality 0x9b, g
         .cfi_lsda 0x1b, h

llvm/include/llvm/BinaryFormat/Dwarf.h

 StringRef LocListEncodingString(unsigned Encoding);
 StringRef CallFrameString(unsigned Encoding, Triple::ArchType Arch);
 StringRef ApplePropertyString(unsigned);
 StringRef UnitTypeString(unsigned);
 StringRef AtomTypeString(unsigned Atom);
 StringRef GDBIndexEntryKindString(GDBIndexEntryKind Kind);
 StringRef GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage);
 StringRef IndexString(unsigned Idx);
+StringRef FormatString(DwarfFormat Format);
 /// @}
 
 /// \defgroup DwarfConstantsParsing Dwarf constants parsing functions
 ///
 /// These functions map their strings back to the corresponding enumeration
 /// value or return 0 if there is none, except for these exceptions:
 ///
 /// \li \a getTag() returns \a DW_TAG_invalid on invalid input.

llvm/lib/BinaryFormat/Dwarf.cpp

bool llvm::dwarf::isValidFormForVersion(Form F, unsigned Version,
                                         bool ExtensionsOk) {
   if (FormVendor(F) == DWARF_VENDOR_DWARF) {
     unsigned FV = FormVersion(F);
     return FV > 0 && FV <= Version;
   }
   return ExtensionsOk;
 }
 
+StringRef llvm::dwarf::FormatString(DwarfFormat Format) {
+  switch (Format) {
+  case DWARF32:
+    return "DWARF32";
+  case DWARF64:
+    return "DWARF64";
+  }
+  return StringRef();
+}
+
 constexpr char llvm::dwarf::EnumTraits<Attribute>::Type[];
 constexpr char llvm::dwarf::EnumTraits<Form>::Type[];
 constexpr char llvm::dwarf::EnumTraits<Index>::Type[];
 constexpr char llvm::dwarf::EnumTraits<Tag>::Type[];
 constexpr char llvm::dwarf::EnumTraits<LineNumberOps>::Type[];

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);
+  W.printString("Format", dwarf::FormatString(Format));
   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/Support/raw_ostream.h"
 
 using namespace llvm;
 
 void DWARFCompileUnit::dump(raw_ostream &OS, DIDumpOptions DumpOpts) {
   int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(getFormat());
   OS << format("0x%08" PRIx64, getOffset()) << ": Compile Unit:"
      << " length = " << format("0x%0*" PRIx64, OffsetDumpWidth, getLength())
+     << ", format = " << dwarf::FormatString(getFormat())
      << ", 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

if (Offset < ContributionHeader) {
       OS << (ContributionHeader - Offset) << "\n";
     }
     OS << format("0x%8.8" PRIx64 ": ", ContributionHeader);
     // In DWARF v5 the contribution size in the descriptor does not equal
     // the originally encoded length (it does not contain the length of the
     // version field and the padding, a total of 4 bytes). Add them back in
     // for reporting.
     OS << "Contribution size = " << (Contribution->Size + (Version < 5 ? 0 : 4))
-       << ", Format = " << (Format == DWARF32 ? "DWARF32" : "DWARF64")
+       << ", Format = " << dwarf::FormatString(Format)
        << ", 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);

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
-                 ", seg_size = 0x%2.2" PRIx8 "\n",
-                 LengthFieldWidth, Length, Version, AddrSize, SegSize);
+    int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(Format);
+    OS << "Address table header: "
+       << format("length = 0x%0*" PRIx64, OffsetDumpWidth, Length)
+       << ", format = " << dwarf::FormatString(Format)
+       << format(", version = 0x%4.4" PRIx16, Version)
+       << format(", addr_size = 0x%2.2" PRIx8, AddrSize)
+       << format(", seg_size = 0x%2.2" PRIx8, SegSize) << "\n";
   }
 
   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

return createStringError(errc::invalid_argument,
                            " 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%0*" PRIx64 ", ", OffsetDumpWidth, HeaderData.Length)
+     << "format = " << dwarf::FormatString(HeaderData.Format) << ", "
      << format("version = 0x%4.4x, ", HeaderData.Version)
      << 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/DWARFDebugFrame.cpp

if (IsEH && Length == 0) {
     OS << format("%08" PRIx64, Offset) << " ZERO terminator\n";
     return;
   }
 
   OS << format("%08" PRIx64, Offset)
      << format(" %0*" PRIx64, IsDWARF64 ? 16 : 8, Length)
      << format(" %0*" PRIx64, IsDWARF64 && !IsEH ? 16 : 8,
                getCIEId(IsDWARF64, IsEH))
-     << " CIE\n";
-  OS << format("  Version:               %d\n", Version);
-  OS << "  Augmentation:          \"" << Augmentation << "\"\n";
+     << " CIE\n"
+     << "  Format:                " << (IsDWARF64 ? "DWARF64" : "DWARF32")
+     << "\n"
+     << format("  Version:               %d\n", Version)
+     << "  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("  Data alignment factor: %d\n", (int32_t)DataAlignmentFactor);
   OS << format("  Return address column: %d\n", (int32_t)ReturnAddressRegister);
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);
+  OS << "  Format:       " << (IsDWARF64 ? "DWARF64" : "DWARF32") << "\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::dump(raw_ostream &OS,
                                     DIDumpOptions DumpOptions) const {
   if (!totalLengthIsValid())
     return;
   int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(FormParams.Format);
   OS << "Line table prologue:\n"
      << format("    total_length: 0x%0*" PRIx64 "\n", OffsetDumpWidth,
                TotalLength)
+     << "          format: " << dwarf::FormatString(FormParams.Format) << "\n"
      << 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%0*" PRIx64 "\n", OffsetDumpWidth,
                PrologueLength)

llvm/lib/DebugInfo/DWARF/DWARFDebugPubTable.cpp

while (PubNames.isValidOffset(Offset)) {
     }
   }
 }
 
 void DWARFDebugPubTable::dump(raw_ostream &OS) const {
   for (const Set &S : Sets) {
     int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(S.Format);
     OS << "length = " << format("0x%0*" PRIx64, OffsetDumpWidth, S.Length);
+    OS << ", format = " << dwarf::FormatString(S.Format);
     OS << ", version = " << format("0x%04x", S.Version);
     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");
 

llvm/lib/DebugInfo/DWARF/DWARFListTable.cpp

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);
   int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(Format);
-  OS << format("%s list header: length = 0x%0*" PRIx64
-               ", version = 0x%4.4" PRIx16 ", addr_size = 0x%2.2" PRIx8
+  OS << format("%s list header: length = 0x%0*" PRIx64, ListTypeString.data(),
+               OffsetDumpWidth, HeaderData.Length)
+     << ", format = " << dwarf::FormatString(Format)
+     << 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",
-               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%0*" PRIx64, OffsetDumpWidth, Off);
       if (DumpOpts.Verbose)

llvm/lib/DebugInfo/DWARF/DWARFTypeUnit.cpp

OS << "name = '" << Name << "'"
        << ", type_signature = " << format("0x%016" PRIx64, getTypeHash())
        << ", length = " << format("0x%0*" PRIx64, OffsetDumpWidth, getLength())
        << '\n';
     return;
   }
 
   OS << format("0x%08" PRIx64, getOffset()) << ": Type Unit:"
      << " length = " << format("0x%0*" PRIx64, OffsetDumpWidth, getLength())
+     << ", format = " << dwarf::FormatString(getFormat())
      << ", 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/CodeGen/X86/debug-loclists.ll

 ; CHECK-NEXT:   DW_AT_name {{.*}} "x"
 
 ; CHECK:      DW_TAG_variable
 ; CHECK-NEXT:   DW_AT_location [DW_FORM_loclistx]   (indexed (0x2) loclist = 0x00000031:
 ; CHECK-NEXT:     [0x0000000000000003, 0x0000000000000004) ".text._Z2f1ii": DW_OP_reg0 RAX)
 ; CHECK-NEXT:   DW_AT_name {{.*}} "r"
 
 ; CHECK:      .debug_loclists contents:
-; CHECK-NEXT: 0x00000000: locations list header: length = 0x00000035, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000003
+; CHECK-NEXT: 0x00000000: locations list header: length = 0x00000035, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000003
 
 ; DWO:      .debug_loclists.dwo contents:
-; DWO-NEXT: 0x00000000: locations list header: length = 0x00000035, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000003
+; DWO-NEXT: 0x00000000: locations list header: length = 0x00000035, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000003
 
 ; CHECK-NEXT: offsets: [
 ; CHECK-NEXT: 0x0000000c => 0x00000018
 ; CHECK-NEXT: 0x0000001d => 0x00000029
 ; CHECK-NEXT: 0x00000025 => 0x00000031
 ; CHECK-NEXT: ]
 
 ; Don't use startx_length if there's more than one entry, because the shared

llvm/test/DebugInfo/RISCV/dwarf-riscv-relocs.ll

 ; DWARF-DUMP: DW_AT_name      ("int")
 ; DWARF-DUMP: DW_AT_encoding  (DW_ATE_signed)
 ; DWARF-DUMP: DW_AT_byte_size (0x04)
 
 ; DWARF-DUMP: .debug_line contents:
 ; DWARF-DUMP-NEXT: debug_line[0x00000000]
 ; DWARF-DUMP-NEXT: Line table prologue:
 ; DWARF-DUMP-NEXT:     total_length: 0x0000005f
+; DWARF-DUMP-NEXT:           format: DWARF32
 ; DWARF-DUMP-NEXT:          version: 5
 ; DWARF-DUMP-NEXT:     address_size: 4
 ; DWARF-DUMP-NEXT:  seg_select_size: 0
 ; DWARF-DUMP-NEXT:  prologue_length: 0x0000003e
 ; DWARF-DUMP-NEXT:  min_inst_length: 1
 ; DWARF-DUMP-NEXT: max_ops_per_inst: 1
 ; DWARF-DUMP-NEXT:  default_is_stmt: 1
 ; DWARF-DUMP-NEXT:        line_base: -5

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:      00000000 0000000000000010 ffffffffffffffff CIE
+# CHECK-NEXT:   Format:                DWARF64
 # CHECK-NEXT:   Version:               4
 # CHECK-NEXT:   Augmentation:          ""
 # CHECK-NEXT:   Address size:          8
 # CHECK-NEXT:   Segment desc size:     0
 # CHECK-NEXT:   Code alignment factor: 1
 # CHECK-NEXT:   Data alignment factor: -8
 # CHECK-NEXT:   Return address column: 16
 # CHECK-EMPTY:
 # CHECK-NEXT:   DW_CFA_nop:
 
 # CHECK:      0000001c 0000000000000018 0000000000000000 FDE cie=00000000 pc=00112233...00122233
+# 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

llvm/test/DebugInfo/X86/debug_addr.ll

 ; DWARF5-NOT: Compile Unit
 ; DWARF5: DW_TAG_skeleton_unit
 ; DWARF5-NOT: DW_TAG_{{.*}}
 ; DWARF5: DW_AT_dwo_name{{.*}}test.dwo
 ; DWARF5: DW_AT_addr_base{{.*}}0x00000008
 ; DWARF5: DW_AT_low_pc [DW_FORM_addrx] (indexed (00000000) address = 0x0000000000000000 ".text")
 ; DWARF5: DW_AT_call_return_pc [DW_FORM_addrx] (indexed (00000002) address = 0x0000000000000018 ".text")
 ; DWARF5: .debug_addr contents:
-; DWARF5-NEXT: 0x00000000: Address table header: length = 0x00000010, version = 0x0005, addr_size = 0x04, seg_size = 0x00
+; DWARF5-NEXT: 0x00000000: Address table header: length = 0x00000010, format = DWARF32, version = 0x0005, addr_size = 0x04, seg_size = 0x00
 ; DWARF5-NEXT: Addrs: [
 ; DWARF5-NEXT: 0x00000000
 ; DWARF5-NEXT: 0x00000010
 ; DWARF5-NEXT: 0x00000018
 ; DWARF5-NEXT: ]
 
 ; ModuleID = './test.c'
 source_filename = "./test.c"

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 = 0x000000000000001c,
+# CHECK-SAME: format = DWARF64,
 .L4version:
     .short  2                       # Version
     .quad   0x123456789abc          # Debug Info Offset
     .byte   4                       # Address Size
     .byte   0                       # Segment Selector Size
 # CHECK-SAME: version = 0x0002,
 # 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: format = DWARF64,
 # 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: ]

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

 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o %t.o
 # RUN: llvm-dwarfdump -v %t.o | FileCheck %s
 
 # CHECK:      .debug_info
 # CHECK:       DW_AT_name{{.*}}"stub"
 # CHECK:       DW_AT_location [DW_FORM_sec_offset]   (0x0000000c
 # CHECK-NEXT:    [0x0000000000000010, 0x0000000000000020): DW_OP_breg5 RDI+0
 # CHECK-NEXT:    [0x0000000000000530, 0x0000000000000540): DW_OP_breg6 RBP-8, DW_OP_deref
 # CHECK-NEXT:    [0x0000000000000700, 0x0000000000000710): DW_OP_breg5 RDI+0
 
 # CHECK:      .debug_loclists contents:
-# CHECK-NEXT: 0x00000000: locations list header: length = 0x0000002c, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# CHECK-NEXT: 0x00000000: locations list header: length = 0x0000002c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 # CHECK-NEXT: 0x0000000c:
 # CHECK-NEXT:   DW_LLE_offset_pair  (0x0000000000000000, 0x0000000000000010): DW_OP_breg5 RDI+0
 # CHECK-NEXT:   DW_LLE_base_address (0x0000000000000500)
 # CHECK-NEXT:   DW_LLE_offset_pair  (0x0000000000000030, 0x0000000000000040)
 # CHECK-NEXT:                   => [0x0000000000000530, 0x0000000000000540): DW_OP_breg6 RBP-8, DW_OP_deref
 # CHECK-NEXT:   DW_LLE_start_length (0x0000000000000700, 0x0000000000000010)
 # CHECK-NEXT:                   => [0x0000000000000700, 0x0000000000000710): DW_OP_breg5 RDI+0
 # CHECK-NEXT:   DW_LLE_end_of_list  ()

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

.Lnames3:
   .byte   0x00                        # End of list: foo
   .p2align  2
 .Lnames_end2:
 
 # CHECK: .debug_names contents:
 # CHECK-NEXT: Name Index @ 0x0 {
 # CHECK-NEXT:   Header {
 # CHECK-NEXT:     Length: 0x60
+# CHECK-NEXT:     Format: DWARF32
 # CHECK-NEXT:     Version: 5
 # CHECK-NEXT:     CU count: 1
 # CHECK-NEXT:     Local TU count: 0
 # CHECK-NEXT:     Foreign TU count: 0
 # CHECK-NEXT:     Bucket count: 2
 # CHECK-NEXT:     Name count: 2
 # CHECK-NEXT:     Abbreviations table size: 0x7
 # CHECK-NEXT:     Augmentation: ''

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

 # 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 = 0x0000000000000032
+# CHECK-SAME: format = DWARF64
 # CHECK-SAME: version = 0x0002
 # CHECK-SAME: unit_offset = 0x0000112233445566
 # CHECK-SAME: unit_size = 0x0000110022003300
 # CHECK-NEXT: Offset     Name
 # CHECK-NEXT: 0x0000aa01aaaabbbb "foo"
 # CHECK-NEXT: 0x0000aa02aaaabbbb "bar"
 
     .section .debug_pubnames,"",@progbits

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

 .endif
 .ifdef MACHO
         .long   0
 .endif
         .byte   0 # NULL
 CU_5_end:
 
 # CHECK-LABEL: .debug_info contents:
-# CHECK: 0x00000000: Compile Unit: length = 0x00000016, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000001a)
+# CHECK: 0x00000000: Compile Unit: length = 0x00000016, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000001a)
 # CHECK: 0x0000000c: DW_TAG_compile_unit
 # CHECK-NEXT: DW_AT_producer {{.*}} "Handmade DWARF producer"
 # CHECK-NEXT: DW_AT_name {{.*}} "V5_compile_unit"
 # CHECK-NEXT: DW_AT_stmt_list {{.*}} (0x00000000)
 
 .ifdef ELF
         .section .debug_line,"",@progbits
 .endif

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

 # The compile-unit DIE, with DW_AT_producer, DW_AT_name, DW_AT_stmt_list.
         .byte 1
         .long str_producer
         .long str_CU_4
         .long LH_4_start
         .byte 0 # NULL
 CU_4_end:
 
-# CHECK: 0x00000000: Compile Unit: length = 0x00000015, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000019)
+# CHECK: 0x00000000: Compile Unit: length = 0x00000015, format = DWARF32, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000019)
 # CHECK: 0x0000000b: DW_TAG_compile_unit
 
 # DWARF v5 normal CU header.
         .long  CU_5_end-CU_5_version  # Length of Unit
 CU_5_version:
         .short 5               # DWARF version number
         .byte 1                # DWARF Unit Type
         .byte 8                # Address Size (in bytes)
         .long .debug_abbrev    # Offset Into Abbrev. Section
 # The compile-unit DIE, with DW_AT_producer, DW_AT_name, DW_AT_stmt_list.
         .byte 1
         .long str_producer
         .long str_CU_5
         .long LH_5_start
         .byte 0 # NULL
 CU_5_end:
 
-# CHECK: 0x00000019: Compile Unit: length = 0x00000016, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000033)
+# CHECK: 0x00000019: Compile Unit: length = 0x00000016, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000033)
 # CHECK: 0x00000025: DW_TAG_compile_unit
 
         .section .debug_info.dwo,"e",@progbits
 # CHECK-LABEL: .debug_info.dwo
 
 # DWARF v5 split CU header.
         .long  CU_split_5_end-CU_split_5_version # Length of Unit
 CU_split_5_version:
         .short 5                # DWARF version number
         .byte 5                 # DWARF Unit Type
         .byte 8                 # Address Size (in bytes)
         .long .debug_abbrev.dwo # Offset Into Abbrev. Section
         .quad 0x5a              # DWO ID
 # The split compile-unit DIE, with DW_AT_producer, DW_AT_name, DW_AT_stmt_list.
         .byte 1
         .long dwo_producer
         .long dwo_CU_5
         .long dwo_LH_5_start
         .byte 0 # NULL
 CU_split_5_end:
 
-# CHECK: 0x00000000: Compile Unit: length = 0x0000001e, version = 0x0005, unit_type = DW_UT_split_compile, abbr_offset = 0x0000, addr_size = 0x08, DWO_id = 0x000000000000005a (next unit at 0x00000022)
+# CHECK: 0x00000000: Compile Unit: length = 0x0000001e, format = DWARF32, version = 0x0005, unit_type = DW_UT_split_compile, abbr_offset = 0x0000, addr_size = 0x08, DWO_id = 0x000000000000005a (next unit at 0x00000022)
 # CHECK: 0x00000014: DW_TAG_compile_unit
 # CHECK-NEXT: DW_AT_producer {{.*}} "Handmade DWO producer"
 # CHECK-NEXT: DW_AT_name {{.*}} "V5_dwo_compile_unit"
 
 # Now a DWARF v5 type unit, which goes in a .debug_info.dwo comdat.
 # Note there will not be another ".debug_info.dwo contents:" line, even though
 # there is a separate ELF section header; it's dumped along with the previous
 # unit as if they were in a single section.

 # The type DIE, which has a name.
 TU_split_5_type:
         .byte 3
         .long dwo_TU_5
         .byte 0 # NULL
         .byte 0 # NULL
 TU_split_5_end:
 
-# CHECK: 0x00000000: Type Unit: length = 0x00000020, version = 0x0005, unit_type = DW_UT_split_type, abbr_offset = 0x0000, addr_size = 0x08, name = 'V5_split_type_unit', type_signature = 0x8899aabbccddeeff, type_offset = 0x001d (next unit at 0x00000024)
+# CHECK: 0x00000000: Type Unit: length = 0x00000020, format = DWARF32, version = 0x0005, unit_type = DW_UT_split_type, abbr_offset = 0x0000, addr_size = 0x08, name = 'V5_split_type_unit', type_signature = 0x8899aabbccddeeff, type_offset = 0x001d (next unit at 0x00000024)
 # CHECK: 0x00000018: DW_TAG_type_unit
 
         .section .debug_types,"",@progbits
 # CHECK-LABEL: .debug_types contents:
 
 # DWARF v4 Type unit header. Normal/split are identical so we do only one.
 TU_4_start:
         .long  TU_4_end-TU_4_version  # Length of Unit

 # The type DIE, which has a name.
 TU_4_type:
         .byte 3
         .long str_TU_4
         .byte 0 # NULL
         .byte 0 # NULL
 TU_4_end:
 
-# CHECK: 0x00000000: Type Unit: length = 0x0000001f, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x08, name = 'V4_type_unit', type_signature = 0x0011223344556677, type_offset = 0x001c (next unit at 0x00000023)
+# CHECK: 0x00000000: Type Unit: length = 0x0000001f, format = DWARF32, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x08, name = 'V4_type_unit', type_signature = 0x0011223344556677, type_offset = 0x001c (next unit at 0x00000023)
 # CHECK: 0x00000017: DW_TAG_type_unit
 
         .section .debug_line,"",@progbits
 # CHECK-LABEL: .debug_line contents:
 
 # DWARF v4 line-table header.
 LH_4_start:
         .long   LH_4_end-LH_4_version   # Length of Unit

llvm/test/DebugInfo/X86/dwarfdump-line-dwo.s

LH_1_params:
         .byte   0x42            # File Size
         .byte   0               # End of list
 LH_1_header_end:
         # Line number program, which is empty.
 LH_1_end:
 
 # PART1:      Line table prologue:
 # PART1-NEXT: total_length: 0x0000002e
+# PART1-NEXT: format: DWARF32
 # PART1-NEXT: version: 4
 # PART1-NEXT: prologue_length: 0x00000028
 # PART1:      include_directories[  1] = "Directory1"
 # PART1:      file_names[  1]
 # PART1:      name: "File1"
 
 # Second line table.
 LH_2_start:
LH_2_params:
         .byte   0x24            # File Size
         .byte   0               # End of list
 LH_2_header_end:
         # Line number program, which is empty.
 LH_2_end:
 
 # PART2:      Line table prologue:
 # PART2-NEXT: total_length: 0x00000028
+# PART2-NEXT: format: DWARF32
 # PART2-NEXT: version: 4
 # PART2-NEXT: prologue_length: 0x00000022
 # PART2-NOT:  prologue:
 # PART2:      include_directories[  1] = "Dir2"
 # PART2:      file_names[  1]
 # PART2:      name: "File2"
 # PART2-NOT:  prologue:

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

 
 #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:   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: 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:   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: 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/fission-ranges.ll

 ; section and that the compile unit has a DW_AT_rnglists_base attribute.
 ; The table should contain at least one rangelist with at least 2 individual ranges.
 
 ; V5RNGLISTS:      .debug_info contents:
 ; V5RNGLISTS:      DW_TAG_compile_unit
 ; V5RNGLISTS-NOT:  DW_TAG
 ; V5RNGLISTS:      DW_AT_rnglists_base [DW_FORM_sec_offset]  (0x0000000c)
 ; V5RNGLISTS:      .debug_rnglists contents:
-; V5RNGLISTS-NEXT: 0x00000000: range list header: length = 0x00000019, version = 0x0005,
+; V5RNGLISTS-NEXT: 0x00000000: range list header: length = 0x00000019, format = DWARF32, version = 0x0005,
 ; V5RNGLISTS-SAME: addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000001
 ; V5RNGLISTS-NEXT: offsets: [
 ; V5RNGLISTS-NEXT: => 0x00000010
 ; V5RNGLISTS-NEXT: ]
 ; V5RNGLISTS-NEXT: ranges:
 ; V5RNGLISTS-NEXT: 0x00000010: [DW_RLE_offset_pair]:
 ; V5RNGLISTS-NEXT: 0x00000013: [DW_RLE_offset_pair]:
 ; V5RNGLISTS:      0x{{[0-9a-f]+}}: [DW_RLE_end_of_list]

llvm/test/DebugInfo/X86/gnu-public-names-gmlt.ll

 
 ; GPUB: .debug_gnu_pubnames contents:
 ; GPUB-NEXT: unit_offset = 0x00000000
 ; GPUB-NEXT: Name
 ; GPUB-NEXT: "f2"
 ; GPUB-NEXT: "f3"
 
 ; GPUB: .debug_gnu_pubtypes contents:
-; GPUB-NEXT: length = 0x0000000e, version = 0x0002, unit_offset = 0x00000000
+; GPUB-NEXT: length = 0x0000000e, format = DWARF32, version = 0x0002, unit_offset = 0x00000000
 ; GPUB-NEXT: Name
 
 ; NONE-NOT: .debug_pubnames contents:
 ; NONE-NOT: .debug_pubtypes contents:
 ; NONE-NOT: .debug_gnu_pubnames contents:
 ; NONE-NOT: .debug_gnu_pubtypes contents:
 
 

llvm/test/DebugInfo/X86/rnglists_curanges.ll

 ;
 ; Compile with clangc -gdwarf-5 -O0 -S -emit-llvm
 ;
 ; CHECK:      .debug_info contents:
 ; CHECK:      DW_TAG_compile_unit
 ; CHECK-NOT:  DW_TAG
 ; CHECK:      DW_AT_rnglists_base [DW_FORM_sec_offset]                   (0x0000000c)
 ; CHECK:      .debug_rnglists contents:
-; CHECK:      0x00000000: range list header: length = 0x00000013, version = 0x0005,
+; CHECK:      0x00000000: range list header: length = 0x00000013, format = DWARF32, version = 0x0005,
 ; CHECK-SAME: addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000001
 
 ; Function Attrs: noinline nounwind optnone uwtable
 define dso_local void @f1() section "text.foo" !dbg !7 {
 entry:
   ret void, !dbg !10
 }
 

llvm/test/DebugInfo/X86/split-dwarf-v5-ranges.ll

 ; RUN: llc -split-dwarf-file=foo.dwo -mtriple=x86_64-unknown-linux-gnu -filetype=obj < %s \
 ; RUN:      | llvm-dwarfdump -v -debug-info -debug-rnglists - | FileCheck %s
 
 ; CHECK: .debug_info contents:
 ; CHECK: .debug_info.dwo contents:
 ; CHECK: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x0) rangelist = 0x00000010
 ; CHECK:          [0x0000000000000001, 0x000000000000000c) ".text"
 ; CHECK:          [0x000000000000000e, 0x0000000000000013) ".text")
 
 ; CHECK: .debug_rnglists.dwo contents:
-; CHECK: 0x00000000: range list header: length = 0x00000015, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000001
+; CHECK: 0x00000000: range list header: length = 0x00000015, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000001
 ; CHECK: offsets: [
 ; CHECK: 0x00000004 => 0x00000010
 ; CHECK: ]
 ; CHECK: ranges:
 ; CHECK: 0x00000010: [DW_RLE_base_addressx]:  0x0000000000000000
 ; CHECK: 0x00000012: [DW_RLE_offset_pair  ]:  0x0000000000000001, 0x000000000000000c => [0x0000000000000001, 0x000000000000000c)
 ; CHECK: 0x00000015: [DW_RLE_offset_pair  ]:  0x000000000000000e, 0x0000000000000013 => [0x000000000000000e, 0x0000000000000013)
 ; CHECK: 0x00000018: [DW_RLE_end_of_list  ]

llvm/test/DebugInfo/dwarfdump-pubnames.test

 RUN: llvm-dwarfdump %p/Inputs/dwarfdump-pubnames.elf-x86-64 \
 RUN:   --debug-pubnames | FileCheck %s
 
 CHECK: .debug_pubnames contents:
-CHECK: length = 0x000000a1, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000141
+CHECK: length = 0x000000a1, format = DWARF32, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000141
 
 CHECK: Offset        Name
 CHECK: 0x00000098    "global_namespace_variable"
 CHECK: 0x000000a7    "global_namespace_function"
 CHECK: 0x000000ec    "static_member_function"
 CHECK: 0x0000007c    "global_variable"
 CHECK: 0x00000103    "global_function"
 CHECK: 0x000000c2    "member_function"
 

llvm/test/DebugInfo/dwarfdump-zlib.test

 REQUIRES: zlib
 
 RUN: llvm-dwarfdump -v %p/Inputs/dwarfdump-test-zlib.elf-x86-64 | FileCheck %s
 RUN: llvm-dwarfdump -v %p/Inputs/dwarfdump-test-zlib.o.elf-x86-64 | FileCheck %s
 RUN: llvm-dwarfdump -v %p/Inputs/dwarfdump-test-zlibgnu.elf-x86-64 | FileCheck %s
 
 CHECK: .debug_abbrev contents
 
 // Dump content of a little section to check that both zlib and zlib gnu styles do
 // the decompression correctly and result is the same. This and above also checks
 // that sections names are properly shown in zlib-gnu style (without additional 'z' prefix).
 CHECK: .debug_info contents
-CHECK: 0x00000000: Compile Unit: length = 0x00000144, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000148)
+CHECK: 0x00000000: Compile Unit: length = 0x00000144, format = DWARF32, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000148)
 
 // Also check that relocations in the .zdebug sections are handled correctly:
 CHECK: DW_AT_ranges {{.*}} (0x00000000{{$}}
 CHECK-NEXT: [0x

llvm/test/DebugInfo/typeunit-header.test

 RUN: llvm-dwarfdump -v %p/Inputs/typeunit-header.elf-x86-64 | FileCheck %s
 
 This is testing a bugfix where parsing the type unit header was not 
 taking the unit's intial length field into account when validating.
 
 The input file is hand-coded assembler to generate a type unit stub,
 which only contains a type unit DIE with a sole visibility attribute.
 
 We make sure that llvm-dwarfdump is parsing the type unit header correctly
 and displays it. 
 
 CHECK: .debug_types contents:
-CHECK: 0x00000000: Type Unit: length = 0x00000019, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x08, name = '', type_signature = 0x0011223344556677, type_offset = 0x0019 (next unit at 0x0000001d)
+CHECK: 0x00000000: Type Unit: length = 0x00000019, format = DWARF32, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x08, name = '', type_signature = 0x0011223344556677, type_offset = 0x0019 (next unit at 0x0000001d)
 CHECK: 0x00000017: DW_TAG_type_unit [1] *
 CHECK: DW_AT_visibility [DW_FORM_data1] (DW_VIS_local)

llvm/test/MC/ARM/dwarf-asm-multiple-sections-dwarf-2.s

 // DWARF:               DW_AT_low_pc {{.*}}(0x0000000000000000)
 // DWARF:               DW_AT_high_pc {{.*}}(0x0000000000000004)
 
 // DWARF: DW_TAG_label
 // DWARF-NEXT: DW_AT_name {{.*}}("a")
 
 
 // DWARF: .debug_aranges contents:
-// DWARF-NEXT: Address Range Header: length = 0x00000024, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x04, seg_size = 0x00
+// DWARF-NEXT: Address Range Header: length = 0x00000024, format = DWARF32, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x04, seg_size = 0x00
 // DWARF-NEXT: [0x00000000, 0x00000004)
 // DWARF-NEXT: [0x00000000, 0x00000004)
 
 // DWARF: .debug_line contents:
 // DWARF:      0x0000000000000000      7      0      1   0   0 is_stmt
 // DWARF-NEXT: 0x0000000000000004      7      0      1   0   0 is_stmt end_sequence
 // DWARF:      0x0000000000000000     11      0      1   0   0 is_stmt
 // DWARF-NEXT: 0x0000000000000004     11      0      1   0   0 is_stmt end_sequence

llvm/test/MC/ARM/dwarf-asm-multiple-sections.s

 // DWARF: 0x{{[0-9a-f]+}}:   DW_TAG_label [2]
 // DWARF-NEXT: DW_AT_name [DW_FORM_string]     ("a")
 
 // DWARF: 0x{{[0-9a-f]+}}:   DW_TAG_label [2]
 // DWARF-NEXT: DW_AT_name [DW_FORM_string]     ("b")
 
 
 // DWARF: .debug_aranges contents:
-// DWARF-NEXT: Address Range Header: length = 0x00000024, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x04, seg_size = 0x00
+// DWARF-NEXT: Address Range Header: length = 0x00000024, format = DWARF32, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x04, seg_size = 0x00
 // DWARF-NEXT: [0x00000000, 0x00000004)
 // DWARF-NEXT: [0x00000000, 0x00000004)
 
 
 // DWARF-DL: .debug_line contents:
 // DWARF-DL: version: [[DWVER]]
 // DWARF-DL-5:    address_size: 4
 // DWARF-DL-5:    include_directories[  0] = "/tmp"

 // DWARF34:      .debug_ranges contents:
 // DWARF34-NEXT: 00000000 ffffffff 00000000
 // DWARF34-NEXT: 00000000 00000000 00000004
 // DWARF34-NEXT: 00000000 ffffffff 00000000
 // DWARF34-NEXT: 00000000 00000000 00000004
 // DWARF34-NEXT: 00000000 <End of list>
 
 // DWARF5:      .debug_rnglists contents:
-// DWARF5-NEXT: 0x00000000: range list header: length = 0x00000015, version = 0x0005, addr_size = 0x04, seg_size = 0x00, offset_entry_count = 0x00000000
+// DWARF5-NEXT: 0x00000000: range list header: length = 0x00000015, format = DWARF32, version = 0x0005, addr_size = 0x04, seg_size = 0x00, offset_entry_count = 0x00000000
 // DWARF5-NEXT: ranges:
 // DWARF5-NEXT: 0x0000000c: [DW_RLE_start_length]: 0x00000000, 0x00000004 => [0x00000000, 0x00000004)
 // DWARF5-NEXT: 0x00000012: [DW_RLE_start_length]: 0x00000000, 0x00000004 => [0x00000000, 0x00000004)
 // DWARF5-NEXT: 0x00000018: [DW_RLE_end_of_list ]
 
 
 // Offsets are different in DWARF v5 due to different header layout.
 // RELOC: RELOCATION RECORDS FOR [.debug_info]:

llvm/test/MC/ARM/dwarf-asm-nonstandard-section.s

 // DWARF:               DW_AT_low_pc (0x0000000000000000)
 // DWARF:               DW_AT_high_pc (0x0000000000000004)
 
 // DWARF: DW_TAG_label
 // DWARF-NEXT: DW_AT_name ("b")
 
 
 // DWARF: .debug_aranges contents:
-// DWARF-NEXT: Address Range Header: length = 0x0000001c, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x04, seg_size = 0x00
+// DWARF-NEXT: Address Range Header: length = 0x0000001c, format = DWARF32, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x04, seg_size = 0x00
 // DWARF-NEXT: [0x00000000, 0x00000004)
 
 
 // DWARF: .debug_line contents:
 // DWARF:      0x0000000000000000      7      0      1   0   0  is_stmt
 // DWARF-NEXT: 0x0000000000000004      7      0      1   0   0  is_stmt end_sequence
 
 

llvm/test/MC/ARM/dwarf-asm-single-section.s

 // DWARF:               DW_AT_low_pc (0x0000000000000000)
 // DWARF:               DW_AT_high_pc (0x0000000000000004)
 
 // DWARF: DW_TAG_label
 // DWARF-NEXT: DW_AT_name ("a")
 
 
 // DWARF: .debug_aranges contents:
-// DWARF-NEXT: Address Range Header: length = 0x0000001c, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x04, seg_size = 0x00
+// DWARF-NEXT: Address Range Header: length = 0x0000001c, format = DWARF32, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x04, seg_size = 0x00
 // DWARF-NEXT: [0x00000000, 0x00000004)
 
 // DWARF: .debug_line contents:
 // DWARF:      0x0000000000000000      7      0      1   0   0 is_stmt
 // DWARF-NEXT: 0x0000000000000004      7      0      1   0   0 is_stmt end_sequence
 
 
 // DWARF-NOT: .debug_ranges contents:

llvm/test/MC/MachO/gen-dwarf.s

 // CHECK:      DW_AT_name ("baz")
 // CHECK:      DW_AT_decl_file ([[FILE]])
 // CHECK:      DW_AT_decl_line (10)
 // CHECK:      DW_AT_low_pc (0x0000000000000007)
 
 // CHECK:    NULL
 
 // CHECK: .debug_aranges contents:
-// CHECK: Address Range Header: length = 0x0000001c, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x04, seg_size = 0x00
+// CHECK: Address Range Header: length = 0x0000001c, format = DWARF32, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x04, seg_size = 0x00
 
 // CHECK: .debug_line contents:
 // CHECK: Line table prologue:
 // We don't check the total_length as it includes lengths of temp paths
 // CHECK:         version: 4
 // We don't check the prologue_length as it too includes lengths of temp paths
 // CHECK: min_inst_length: 1
 // CHECK: default_is_stmt: 1

llvm/test/MC/Mips/eh-frame.s

 // RELOCS:        Section ({{.+}}) .rel{{a?}}.eh_frame {
 // ABS32-NEXT:      R_MIPS_32
 // ABS64-NEXT:      R_MIPS_64/R_MIPS_NONE/R_MIPS_NONE
 // PIC32-NEXT:      R_MIPS_PC32
 // PIC64-NEXT:      R_MIPS_PC32/R_MIPS_NONE/R_MIPS_NONE
 // RELOCS-NEXT:   }
 
 // DWARF32: 00000000 00000010 00000000 CIE
+// DWARF32-NEXT:     Format:                DWARF32
 // DWARF32-NEXT:     Version:               1
 // DWARF32-NEXT:     Augmentation:          "zR"
 // DWARF32-NEXT:     Code alignment factor: 1
 // DWARF32-NEXT:     Data alignment factor: -4
 // DWARF32-NEXT:     Return address column: 31
 // DWARF32_ABS-NEXT: Augmentation data: 0B
 //                                      ^^ fde pointer encoding: DW_EH_PE_sdata4
 // DWARF32_PIC-NEXT: Augmentation data: 1B
 //                                      ^^ fde pointer encoding: DW_EH_PE_pcrel | DW_EH_PE_sdata4
 // DWARF32-EMPTY:
 // DWARF32-NEXT:     DW_CFA_def_cfa_register: reg29
 //
 // DWARF32: 00000014 00000010 00000018 FDE cie=00000000 pc=00000000...00000000
+// DWARF32-NEXT:     Format:       DWARF32
 // DWARF32-NEXT:     DW_CFA_nop:
 // DWARF32-NEXT:     DW_CFA_nop:
 // DWARF32-NEXT:     DW_CFA_nop:
 
 
 // DWARF64: 00000000 00000010 00000000 CIE
+// DWARF64-NEXT:     Format:                DWARF32
 // DWARF64-NEXT:     Version:               1
 // DWARF64-NEXT:     Augmentation:          "zR"
 // DWARF64-NEXT:     Code alignment factor: 1
 // DWARF64-NEXT:     Data alignment factor: -8
 //                                          ^^ GAS uses -4. Should be ok as long as
 //                                             all offsets we need are a multiple of 8.
 // DWARF64-NEXT:     Return address column: 31
 // DWARF64_ABS-NEXT: Augmentation data: 0C
 //                                      ^^ fde pointer encoding: DW_EH_PE_sdata8
 // DWARF64_PIC:      Augmentation data: 1B
 //                                      ^^ fde pointer encoding: DW_EH_PE_pcrel | DW_EH_PE_sdata4
 // DWARF64-EMPTY:
 // DWARF64-NEXT:     DW_CFA_def_cfa_register: reg29
 // DWARF64_PIC-NEXT: DW_CFA_nop:
 //
 // DWARF64_ABS:      00000014 00000018 00000018 FDE cie=00000000 pc=00000000...00000000
 // DWARF64_PIC:      00000014 00000010 00000018 FDE cie=00000000 pc=00000000...00000000
+// DWARF64-NEXT:     Format:       DWARF32
 // DWARF64-NEXT:     DW_CFA_nop:
 // DWARF64-NEXT:     DW_CFA_nop:
 // DWARF64-NEXT:     DW_CFA_nop:

llvm/test/MC/WebAssembly/dwarfdump.ll

 ; RUN: llc -filetype=obj %s -o - | llvm-dwarfdump - | FileCheck %s
 
 ; CHECK: .debug_info contents:
-; CHECK-NEXT: 0x00000000: Compile Unit: length = 0x0000006e, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x04 (next unit at 0x00000072)
+; CHECK-NEXT: 0x00000000: Compile Unit: length = 0x0000006e, format = DWARF32, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x04 (next unit at 0x00000072)
 
 ; CHECK: 0x0000000b: DW_TAG_compile_unit
 ; CHECK-NEXT:              DW_AT_producer ("clang version 6.0.0 (trunk 315924) (llvm/trunk 315960)")
 ; CHECK-NEXT:              DW_AT_language (DW_LANG_C99)
 ; CHECK-NEXT:              DW_AT_name ("test.c")
 ; CHECK-NEXT:              DW_AT_stmt_list  (0x00000000)
 ; CHECK-NEXT:              DW_AT_comp_dir ("/usr/local/google/home/sbc/dev/wasm/simple")
 ; CHECK-NEXT:              DW_AT_GNU_pubnames (true)

llvm/test/tools/dsymutil/ARM/obfuscated.test

 CHECK:          length: 0x00000000
 CHECK: file_names[  1]:
 CHECK:            name: "six.c"
 CHECK:       dir_index: 0
 CHECK:        mod_time: 0x00000000
 CHECK:          length: 0x00000000
 
 CHECK: .debug_pubnames contents:
-CHECK: length = 0x00000017, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000044
+CHECK: length = 0x00000017, format = DWARF32, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000044
 CHECK: 0x0000002e "main"
-CHECK: length = 0x00000016, version = 0x0002, unit_offset = 0x00000044, unit_size = 0x00000044
+CHECK: length = 0x00000016, format = DWARF32, version = 0x0002, unit_offset = 0x00000044, unit_size = 0x00000044
 CHECK: 0x0000002e "one"
-CHECK: length = 0x00000016, version = 0x0002, unit_offset = 0x00000088, unit_size = 0x00000044
+CHECK: length = 0x00000016, format = DWARF32, version = 0x0002, unit_offset = 0x00000088, unit_size = 0x00000044
 CHECK: 0x0000002e "two"
-CHECK: length = 0x00000018, version = 0x0002, unit_offset = 0x000000cc, unit_size = 0x00000044
+CHECK: length = 0x00000018, format = DWARF32, version = 0x0002, unit_offset = 0x000000cc, unit_size = 0x00000044
 CHECK: 0x0000002e "three"
-CHECK: length = 0x00000017, version = 0x0002, unit_offset = 0x00000110, unit_size = 0x00000044
+CHECK: length = 0x00000017, format = DWARF32, version = 0x0002, unit_offset = 0x00000110, unit_size = 0x00000044
 CHECK: 0x0000002e "four"
-CHECK: length = 0x00000017, version = 0x0002, unit_offset = 0x00000154, unit_size = 0x00000044
+CHECK: length = 0x00000017, format = DWARF32, version = 0x0002, unit_offset = 0x00000154, unit_size = 0x00000044
 CHECK: 0x0000002e "five"
-CHECK: length = 0x00000016, version = 0x0002, unit_offset = 0x00000198, unit_size = 0x00000044
+CHECK: length = 0x00000016, format = DWARF32, version = 0x0002, unit_offset = 0x00000198, unit_size = 0x00000044
 CHECK: 0x0000002e "six"
 
 CHECK: .apple_names contents:
 
 CHECK: String: 0x00000091 "five"
 CHECK-NEXT: Data 0 [
 CHECK-NEXT:   Atom[0]: 0x00000182
 CHECK-NEXT: ]

llvm/test/tools/dsymutil/X86/basic-linking-x86.test

 CHECK:      DW_AT_high_pc (0x0000000100000fa9)
 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 
 CHECK:    NULL
 
 CHECK-NOT: .debug_loc contents
 
 CHECK:.debug_aranges contents:
-CHECK-NEXT:Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00
+CHECK-NEXT:Address Range Header: length = 0x0000002c, format = DWARF32, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT:[0x0000000100000ea0, 0x0000000100000ec4)
-CHECK-NEXT:Address Range Header: length = 0x0000003c, version = 0x0002, cu_offset = 0x00000081, addr_size = 0x08, seg_size = 0x00
+CHECK-NEXT:Address Range Header: length = 0x0000003c, format = DWARF32, version = 0x0002, cu_offset = 0x00000081, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT:[0x0000000100000ed0, 0x0000000100000f19)
 CHECK-NEXT:[0x0000000100000f20, 0x0000000100000f37)
-CHECK-NEXT:Address Range Header: length = 0x0000003c, version = 0x0002, cu_offset = 0x00000126, addr_size = 0x08, seg_size = 0x00
+CHECK-NEXT:Address Range Header: length = 0x0000003c, format = DWARF32, version = 0x0002, cu_offset = 0x00000126, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT:[0x0000000100000f40, 0x0000000100000f84)
 CHECK-NEXT:[0x0000000100000f90, 0x0000000100000fa9)
 
 CHECK: .debug_line contents:
 CHECK: file_names[  1]:
 CHECK-NEXT: name: "basic1.c"
 CHECK-NEXT: dir_index: 0
 CHECK: Address            Line   Column File   ISA Discriminator Flags

 CHECK-NEXT: 0x0000000100000f6c     19      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f7b     20      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f84     20      0      1   0             0  is_stmt end_sequence
 CHECK-NEXT: 0x0000000100000f90     11      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f9b     12      0      1   0             0  is_stmt prologue_end
 CHECK-NEXT: 0x0000000100000fa9     12      0      1   0             0  is_stmt end_sequence
 
 CHECK: .debug_pubnames contents:
-CHECK-NEXT: length = 0x00000017, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000081
+CHECK-NEXT: length = 0x00000017, format = DWARF32, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000081
 CHECK-NEXT: Offset     Name
 CHECK-NEXT: 0x00000026 "main"
-CHECK-NEXT: length = 0x00000036, version = 0x0002, unit_offset = 0x00000081, unit_size = 0x000000a5
+CHECK-NEXT: length = 0x00000036, format = DWARF32, version = 0x0002, unit_offset = 0x00000081, unit_size = 0x000000a5
 CHECK-NEXT: Offset     Name
 CHECK-NEXT: 0x0000002d "private_int"
 CHECK-NEXT: 0x00000042 "baz"
 CHECK-NEXT: 0x00000057 "foo"
 CHECK-NEXT: 0x00000086 "inc"
-CHECK-NEXT: length = 0x00000026, version = 0x0002, unit_offset = 0x00000126, unit_size = 0x00000096
+CHECK-NEXT: length = 0x00000026, format = DWARF32, version = 0x0002, unit_offset = 0x00000126, unit_size = 0x00000096
 CHECK-NEXT: Offset     Name
 CHECK-NEXT: 0x00000026 "val"
 CHECK-NEXT: 0x00000048 "bar"
 CHECK-NEXT: 0x00000077 "inc"
 
 CHECK: .debug_pubtypes contents:
-CHECK-NEXT: length = 0x0000001f, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000081
+CHECK-NEXT: length = 0x0000001f, format = DWARF32, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000081
 CHECK-NEXT: Offset     Name
 CHECK-NEXT: 0x00000063 "int"
 CHECK-NEXT: 0x00000079 "char"
-CHECK-NEXT: length = 0x00000016, version = 0x0002, unit_offset = 0x00000081, unit_size = 0x000000a5
+CHECK-NEXT: length = 0x00000016, format = DWARF32, version = 0x0002, unit_offset = 0x00000081, unit_size = 0x000000a5
 CHECK-NEXT: Offset     Name
 CHECK-NEXT: 0x00000026 "int"
-CHECK-NEXT: length = 0x00000016, version = 0x0002, unit_offset = 0x00000126, unit_size = 0x00000096
+CHECK-NEXT: length = 0x00000016, format = DWARF32, version = 0x0002, unit_offset = 0x00000126, unit_size = 0x00000096
 CHECK-NEXT: Offset     Name
 CHECK-NEXT: 0x00000041 "int"

llvm/test/tools/dsymutil/X86/basic-lto-dw4-linking-x86.test

 CHECK-NEXT:              (0x0000000000000000, 0x000000000000000c): DW_OP_reg5 RDI, DW_OP_piece 0x4
 CHECK-NOT: :
 CHECK:      0x00000025:
 CHECK-NEXT:              (0x0000000000000000, 0x000000000000000f): DW_OP_reg5 RDI, DW_OP_piece 0x4
 CHECK-NEXT:              (0x0000000000000019, 0x000000000000001d): DW_OP_reg5 RDI, DW_OP_piece 0x4
 
 
 CHECK: .debug_aranges contents:
-CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00
+CHECK-NEXT: Address Range Header: length = 0x0000002c, format = DWARF32, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f40,  0x0000000100000f4b)
-CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000077, addr_size = 0x08, seg_size = 0x00
+CHECK-NEXT: Address Range Header: length = 0x0000002c, format = DWARF32, version = 0x0002, cu_offset = 0x00000077, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f50, 0x0000000100000f87)
-CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x0000011b, addr_size = 0x08, seg_size = 0x00
+CHECK-NEXT: Address Range Header: length = 0x0000002c, format = DWARF32, version = 0x0002, cu_offset = 0x0000011b, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f90, 0x0000000100000fb4)
 
 CHECK: .debug_line contents:
 CHECK: file_names[  1]:
 CHECK-NEXT: name: "basic1.c"
 CHECK-NEXT: dir_index: 0
 CHECK: Address            Line   Column File   ISA Discriminator Flags
 CHECK-NEXT: ------------------ ------ ------ ------ --- ------------- -------------

 CHECK-NEXT: 0x0000000100000f9f     12     10      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000fa7     20      1      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000fa9     19     18      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000fab     19     10      1   0             0
 CHECK-NEXT: 0x0000000100000fb2     20      1      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000fb4     20      1      1   0             0  is_stmt end_sequence
 
 CHECK: .debug_pubnames contents:
-CHECK-NEXT: length = 0x00000017, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000077
+CHECK-NEXT: length = 0x00000017, format = DWARF32, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000077
 CHECK-NEXT: Offset     Name
 CHECK-NEXT: 0x0000002a "main"
-CHECK-NEXT: length = 0x0000002e, version = 0x0002, unit_offset = 0x00000077, unit_size = 0x000000a4
+CHECK-NEXT: length = 0x0000002e, format = DWARF32, version = 0x0002, unit_offset = 0x00000077, unit_size = 0x000000a4
 CHECK-NEXT: Offset     Name
 CHECK-NEXT: 0x00000031 "baz"
 CHECK-NEXT: 0x00000046 "private_int"
 CHECK-NEXT: 0x00000067 "foo"
-CHECK-NEXT: length = 0x0000001e, version = 0x0002, unit_offset = 0x0000011b, unit_size = 0x00000085
+CHECK-NEXT: length = 0x0000001e, format = DWARF32, version = 0x0002, unit_offset = 0x0000011b, unit_size = 0x00000085
 CHECK-NEXT: Offset     Name
 CHECK-NEXT: 0x0000002a "val"
 CHECK-NEXT: 0x00000050 "bar"
 
 CHECK: .debug_pubtypes contents:
-CHECK-NEXT: length = 0x00000017, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000077
+CHECK-NEXT: length = 0x00000017, format = DWARF32, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000077
 CHECK-NEXT: Offset     Name
 CHECK-NEXT: 0x0000006f "char"
-CHECK-NEXT: length = 0x00000016, version = 0x0002, unit_offset = 0x00000077, unit_size = 0x000000a4
+CHECK-NEXT: length = 0x00000016, format = DWARF32, version = 0x0002, unit_offset = 0x00000077, unit_size = 0x000000a4
 CHECK-NEXT: Offset     Name
 CHECK-NEXT: 0x0000002a "int"

llvm/test/tools/dsymutil/X86/basic-lto-linking-x86.test

 CHECK-NEXT: 0x00000000:
 CHECK-NEXT:              (0x0000000000000000, 0x000000000000000e): DW_OP_reg5 RDI, DW_OP_piece 0x4
 CHECK-NOT: :
 CHECK:      0x00000025:
 CHECK-NEXT:              (0x0000000000000000, 0x000000000000000f): DW_OP_reg5 RDI, DW_OP_piece 0x4
 CHECK-NEXT:              (0x0000000000000019, 0x000000000000001d): DW_OP_reg5 RDI, DW_OP_piece 0x4
 
 CHECK: .debug_aranges contents:
-CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00
+CHECK-NEXT: Address Range Header: length = 0x0000002c, format = DWARF32, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f40, 0x0000000100000f4b)
-CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000081, addr_size = 0x08, seg_size = 0x00
+CHECK-NEXT: Address Range Header: length = 0x0000002c, format = DWARF32, version = 0x0002, cu_offset = 0x00000081, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f50, 0x0000000100000f89)
-CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x0000013a, addr_size = 0x08, seg_size = 0x00
+CHECK-NEXT: Address Range Header: length = 0x0000002c, format = DWARF32, version = 0x0002, cu_offset = 0x0000013a, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f90, 0x0000000100000fb4)
 
 
 CHECK: .debug_line contents
 CHECK: file_names[  1]:
 CHECK-NEXT: name: "basic1.c"
 CHECK-NEXT: dir_index: 0
 CHECK: 0x0000000100000f40     23      0      1   0             0  is_stmt

 CHECK: 0x0000000100000f9a     17      0      1   0             0  is_stmt
 CHECK: 0x0000000100000f9f     12      0      1   0             0  is_stmt
 CHECK: 0x0000000100000fa7     20      0      1   0             0  is_stmt
 CHECK: 0x0000000100000fa9     19      0      1   0             0  is_stmt
 CHECK: 0x0000000100000fb2     20      0      1   0             0  is_stmt
 CHECK: 0x0000000100000fb4     20      0      1   0             0  is_stmt end_sequence
 
 CHECK: .debug_pubnames contents:
-CHECK-NEXT: length = 0x00000017, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000081
+CHECK-NEXT: length = 0x00000017, format = DWARF32, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000081
 CHECK-NEXT: Offset     Name
 CHECK-NEXT: 0x00000026 "main"
-CHECK-NEXT: length = 0x0000002e, version = 0x0002, unit_offset = 0x00000081, unit_size = 0x000000b9
+CHECK-NEXT: length = 0x0000002e, format = DWARF32, version = 0x0002, unit_offset = 0x00000081, unit_size = 0x000000b9
 CHECK-NEXT: Offset     Name
 CHECK-NEXT: 0x00000026 "private_int"
 CHECK-NEXT: 0x0000003f "baz"
 CHECK-NEXT: 0x00000058 "foo"
-CHECK-NEXT: length = 0x0000001e, version = 0x0002, unit_offset = 0x0000013a, unit_size = 0x000000ac
+CHECK-NEXT: length = 0x0000001e, format = DWARF32, version = 0x0002, unit_offset = 0x0000013a, unit_size = 0x000000ac
 CHECK-NEXT: Offset     Name
 CHECK-NEXT: 0x00000026 "val"
 CHECK-NEXT: 0x00000045 "bar"
 
 CHECK: .debug_pubtypes contents:
-CHECK-NEXT: length = 0x0000001f, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000081
+CHECK-NEXT: length = 0x0000001f, format = DWARF32, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000081
 CHECK-NEXT: Offset     Name
 CHECK-NEXT: 0x00000063 "int"
 CHECK-NEXT: 0x00000079 "char"
 
 CHECK: .apple_names contents:
 CHECK-NEXT: Header {
 CHECK-NEXT:   Magic: 0x48415348
 CHECK-NEXT:   Version: 0x1

llvm/test/tools/dsymutil/X86/empty-CU.test

 RUN: dsymutil --update -f %p/../Inputs/empty-CU.o -o - | llvm-dwarfdump -v - -debug-info | FileCheck %s
 
 CHECK: .debug_info contents:
-CHECK: 0x00000000: Compile Unit: length = 0x00000008, version = 0x0003, abbr_offset = 0x0000, addr_size = 0x04 (next unit at 0x0000000c)
+CHECK: 0x00000000: Compile Unit: length = 0x00000008, format = DWARF32, version = 0x0003, abbr_offset = 0x0000, addr_size = 0x04 (next unit at 0x0000000c)
 
 CHECK: 0x0000000b: DW_TAG_compile_unit [1]

llvm/test/tools/dsymutil/X86/frame-2.test

symbols:
       - { sym: _baz, objAddr: 0x0, binAddr: 0x3000, size: 0x12 }
   - filename: frame-dw2.o
     symbols:
       - { sym: _bar, objAddr: 0x0, binAddr: 0x4000, size: 0x12 }
 ...
 
 # CHECK: .debug_frame contents:
 # CHECK: 00000000 {{[0-9a-f]*}} ffffffff CIE
+# CHECK-NEXT: Format: DWARF32
 # CHECK-NEXT: Version:{{.*}}1
 # CHECK-NOT: FDE
 # CHECK:  FDE cie=00000000 pc=00001000...00001
 # CHECK-NOT: FDE
 # CHECK:  FDE cie=00000000 pc=00002000...00002
 # CHECK-NOT: FDE
 # CHECK: [[CIEDW4:[0-9a-f]*]] 00000010 ffffffff CIE
+# CHECK-NEXT: Format: DWARF32
 # CHECK-NEXT: Version:{{.*}}4
 # CHECK-NOT: FDE
 # CHECK:  FDE cie=[[CIEDW4]] pc=00003000...00003
 # CHECK-NOT: FDE
 # CHECK: [[CIEDW2:[0-9a-f]*]] {{[0-9a-f]*}} ffffffff CIE
+# CHECK-NEXT: Format: DWARF32
 # CHECK-NEXT: Version:{{.*}}1
 # CHECK-NOT: FDE
 # CHECK:  FDE cie=[[CIEDW2]] pc=00004000...00004
 # CHECK-NOT: FDE
 # CHECK: .eh_frame contents:

llvm/test/tools/dsymutil/X86/generate-empty-CU.test

objects:
   - filename:        /Inputs/basic-lto.macho.x86_64.o
     timestamp:       1417654896
     symbols:
       - { sym: _main, objAddr: 0x0000000000000000, binAddr: 0x0000000100000F40, size: 0x00000010 }
       - { sym: _bar, objAddr: 0x0000000000000050, binAddr: 0x0000000100000F90, size: 0x00000024 }
 ...
 
 .debug_info contents:
-CHECK: Compile Unit: length = 0x0000007d, version = 0x0002, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000081)
+CHECK: Compile Unit: length = 0x0000007d, format = DWARF32, version = 0x0002, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000081)
 
 CHECK: DW_TAG_compile_unit
 CHECK:        DW_AT_name {{.*}} "basic1.c"
 CHECK:   DW_TAG_subprogram
                 DW_AT_name {{.*}} "main"
 
-CHECK: 0x00000081: Compile Unit: length = 0x00000089, version = 0x0002, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000010e)
+CHECK: 0x00000081: Compile Unit: length = 0x00000089, format = DWARF32, version = 0x0002, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000010e)
 
 CHECK: DW_TAG_compile_unit
 CHECK:        DW_AT_name {{.*}} "basic3.c"
 
 CHECK:   DW_TAG_subprogram [7] *
 CHECK:          DW_AT_name {{.*}} = "bar"

llvm/test/tools/llvm-dwarfdump/X86/debug-line.s

 ## Show that llvm-dwarfdump dumps the whole .debug_line section when
 ## --debug-line is specified.
 
 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o %t.o
 # RUN: llvm-dwarfdump --debug-line %t.o | FileCheck %s --match-full-lines
 
 # CHECK:      .debug_line contents:
 # CHECK-NEXT: debug_line[0x00000000]
 # CHECK-NEXT: Line table prologue:
 # CHECK-NEXT:     total_length: 0x00000069
+# CHECK-NEXT:           format: DWARF32
 # CHECK-NEXT:          version: 5
 # CHECK-NEXT:     address_size: 8
 # CHECK-NEXT:  seg_select_size: 0
 # CHECK-NEXT:  prologue_length: 0x0000004c
 # CHECK-NEXT:  min_inst_length: 1
 # CHECK-NEXT: max_ops_per_inst: 1
 # CHECK-NEXT:  default_is_stmt: 1
 # CHECK-NEXT:        line_base: -5

 # CHECK-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
 # CHECK-NEXT: 0x0000000000000002      1      0      1   0             0  is_stmt
 # CHECK-NEXT: 0x0000000000000002      1      4      3   0             0  is_stmt
 # CHECK-NEXT: 0x0000000000000024      1      4      3   5             6  basic_block prologue_end epilogue_begin end_sequence
 # CHECK-EMPTY:
 # CHECK-NEXT: debug_line[0x0000006d]
 # CHECK-NEXT: Line table prologue:
 # CHECK-NEXT:     total_length: 0x0000001b
+# CHECK-NEXT:           format: DWARF32
 # CHECK-NEXT:          version: 4
 # CHECK-NEXT:  prologue_length: 0x00000015
 # CHECK-NEXT:  min_inst_length: 2
 # CHECK-NEXT: max_ops_per_inst: 4
 # CHECK-NEXT:  default_is_stmt: 0
 # CHECK-NEXT:        line_base: 42
 # CHECK-NEXT:       line_range: 10
 # CHECK-NEXT:      opcode_base: 2

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

 # RUN: llvm-mc %s -filetype obj -triple i386-pc-linux -o %t.o
 # RUN: llvm-dwarfdump -debug-addr %t.o | FileCheck %s
 
 # CHECK:          .debug_addr contents
 
-# CHECK-NEXT:     length = 0x0000000c, version = 0x0005, addr_size = 0x04, seg_size = 0x00
+# CHECK-NEXT:     length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x04, seg_size = 0x00
 # CHECK-NEXT:     Addrs: [
 # CHECK-NEXT:     0x00000000
 # CHECK-NEXT:     0x00000001
 # CHECK-NEXT:     ]
-# CHECK-NEXT:     length = 0x00000004, version = 0x0005, addr_size = 0x04, seg_size = 0x00
+# CHECK-NEXT:     length = 0x00000004, format = DWARF32, version = 0x0005, addr_size = 0x04, seg_size = 0x00
 # CHECK-NOT:      {{.}}
 
   .section  .debug_abbrev,"",@progbits
   .byte 1                       # Abbreviation Code
   .section  .debug_info,"",@progbits
 .Lcu_begin0:
   .long 8                       # Length of Unit
   .short  5                     # DWARF version number

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

 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o %t.o
 # RUN: llvm-dwarfdump -debug-addr %t.o | FileCheck %s
 
 # CHECK:          .debug_addr contents
-# CHECK-NEXT:     length = 0x00000014, version = 0x0005, addr_size = 0x08, seg_size = 0x00
+# CHECK-NEXT:     length = 0x00000014, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
 # CHECK-NEXT:     Addrs: [
 # CHECK-NEXT:     0x0000000100000000
 # CHECK-NEXT:     0x0000000100000001
 # CHECK-NEXT:     ]
 # CHECK-NOT:      {{.}}
 
   .section  .debug_abbrev,"",@progbits
   .byte 1                       # Abbreviation Code

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

 # RUN: llvm-mc %s -filetype obj -triple i386-pc-linux -o - | \
 # RUN: llvm-dwarfdump -debug-addr - 2> %t.warn | FileCheck %s
 # RUN: FileCheck %s -input-file %t.warn -check-prefix=WARN
 
 # WARN: address table at offset 0x0 has address size 8 which is different from CU address size 4
 # WARN-NOT: {{.}}
 
 # CHECK: .debug_addr contents
-# CHECK-NEXT:     length = 0x0000000c, version = 0x0005, addr_size = 0x08, seg_size = 0x00
+# CHECK-NEXT:     length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
 # CHECK-NEXT:     Addrs: [
 # CHECK-NEXT:     0x0000000100000000
 # CHECK-NEXT:     ]
-# CHECK-NEXT:     length = 0x0000000c, version = 0x0005, addr_size = 0x04, seg_size = 0x00
+# CHECK-NEXT:     length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x04, seg_size = 0x00
 # CHECK-NEXT:     Addrs: [
 # CHECK-NEXT:     0x00000000
 # CHECK-NEXT:     0x00000001
 # CHECK-NEXT:     ]
 # CHECK-NOT:      {{.}}
 
   .section  .debug_abbrev,"",@progbits
   .byte 1                       # Abbreviation Code

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_addr_rela.s

 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o - | \
 # RUN:   llvm-dwarfdump -debug-addr - | \
 # RUN:   FileCheck %s
 
 ## This checks that we use DWARFDataExtractor::getRelocatedAddress() to read
 ## addresses of an address table. In this test, the raw data in the .debug_addr
 ## section does not contain the full address, thus, it is required to resolve
 ## a RELA relocation to recover the real value.
 
 # CHECK:      .debug_addr contents
-# CHECK-NEXT: length = 0x0000000c, version = 0x0005, addr_size = 0x08, seg_size = 0x00
+# CHECK-NEXT: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
 # CHECK-NEXT: Addrs: [
 # CHECK-NEXT: 0x000000000000002a
 # CHECK-NEXT: ]
 
     .text
     .space  0x2a
 .Lfoo:
 

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

 # RUN: llvm-mc %s -filetype obj -triple i386-pc-linux -o - | \
 # RUN: not llvm-dwarfdump -debug-addr - 2> %t.err | FileCheck %s
 # RUN: FileCheck %s -input-file %t.err -check-prefix=ERR
 
 # ERR: address table at offset 0x0 has unsupported version 6
 # ERR: address table at offset 0x20 has unsupported version 4
 # ERR-NOT: {{.}}
 
 # CHECK: .debug_addr contents
-# CHECK-NEXT:     length = 0x0000000c, version = 0x0005, addr_size = 0x04, seg_size = 0x00
+# CHECK-NEXT:     length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x04, seg_size = 0x00
 # CHECK-NEXT:     Addrs: [
 # CHECK-NEXT:     0x00000002
 # CHECK-NEXT:     0x00000003
 # CHECK-NEXT:     ]
 # CHECK-NOT:      {{.}}
 
   .section  .debug_abbrev,"",@progbits
   .byte 1                       # Abbreviation Code

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

 # RUN: llvm-mc %s -filetype=obj -triple=i686-pc-linux -o %t
 # RUN: llvm-dwarfdump -v %t | FileCheck %s
 
 # CHECK:      .eh_frame contents:
 # CHECK:        00000018 00000010 0000001c FDE cie=00000000 pc=00000000...00000000
+# CHECK-NEXT:     Format:       DWARF32
 # CHECK-NEXT:     DW_CFA_GNU_args_size: +16
 # CHECK-NEXT:     DW_CFA_nop:
 
 .text
 .globl foo
 .type  foo,@function
 foo:
  .cfi_startproc
  .cfi_escape 0x2e, 0x10
  .cfi_endproc

llvm/test/tools/llvm-dwarfdump/X86/debug_frame_offset.test

 RUN: llc -filetype=obj %p/../../dsymutil/Inputs/frame-dw2.ll -o - \
 RUN:   | llvm-dwarfdump -debug-frame=0x00000014 - | FileCheck %s
 CHECK: .debug_frame contents:
 CHECK-NEXT: 00000014 00000014 00000000 FDE cie=00000000 pc=00000000...0000001d
+CHECK-NEXT:   Format:       DWARF32
 CHECK-NEXT:   DW_CFA_advance_loc: 1
 CHECK-NOT: pc
 
 RUN: llvm-dwarfdump %p/../../dsymutil/Inputs/basic1.macho.x86_64.o \
 RUN:   -eh-frame=0x00000018 | FileCheck %s --check-prefix=EH
 EH: .eh_frame contents:
 EH-NEXT: 00000018 00000024 0000001c FDE cie=00000000 pc=fffffffffffffd00...fffffffffffffd24
+EH-NEXT:   Format:       DWARF32
 EH-NEXT:   DW_CFA_advance_loc: 1
 EH-NOT: pc
 EH-NOT: CIE

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

# RUN:   FileCheck %s
         
         .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 = 0x000000000000000f
+# CHECK-SAME: 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: 0x00000000fffffff0
+# CHECK-NEXT:           format: DWARF64
 # CHECK-NEXT:          version: 4
 # 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

llvm/test/tools/llvm-dwarfdump/X86/debug_line_invalid.test

 # FATAL-NOT:  debug_line
 
 ## For non-fatal issues, the table data should be dumped:
 
 ## Version 0 table.
 # NONFATAL:      debug_line[0x00000048]
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL-NEXT:    total_length: 0x00000002
+# NONFATAL-NEXT:          format: DWARF32
 # NONFATAL-NEXT:         version: 0
 # NONFATAL-NOT: prologue_length
 
 ## Version 1 table.
 # NONFATAL:      debug_line[0x0000004e]
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL-NEXT:    total_length: 0x00000002
+# NONFATAL-NEXT:          format: DWARF32
 # NONFATAL-NEXT:         version: 1
 # NONFATAL-NOT: prologue_length
 
 ## Malformed directory format with no path component.
 # NONFATAL:      debug_line[0x00000054]
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL:      prologue_length: 0x00000013
 # NONFATAL-NOT:  include_directories

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

 # REGULAR-NEXT:      [0x0000000000000006, 0x0000000000000007): DW_OP_reg6 RBP
 # VERBOSE-NEXT:      [0x0000000000000006, 0x0000000000000007) ".text": DW_OP_reg6 RBP
 
 # REGULAR-NEXT:      [0x0000000000000007, 0x0000000000000008): DW_OP_reg7 RSP
 # VERBOSE-NEXT:      [0x0000000000000007, 0x0000000000000008) ".text": DW_OP_reg7 RSP
 
 # BOTH-NEXT:         DW_LLE_startx_length (0x000000000000dead, 0x0000000000000001): DW_OP_reg4 RSI)
 
-# BOTH: locations list header: length = 0x00000056, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# BOTH: locations list header: length = 0x00000056, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 # BOTH-NEXT: 0x0000000c:
 # BOTH-NEXT:     DW_LLE_startx_endx     (0x0000000000000000, 0x0000000000000001): DW_OP_reg0 RAX
 # BOTH-NEXT:     DW_LLE_startx_length   (0x0000000000000001, 0x0000000000000001): DW_OP_reg1 RDX
 # BOTH-NEXT:     DW_LLE_offset_pair     (0x0000000000000002, 0x0000000000000003): DW_OP_reg2 RCX
 
 # REGULAR-NEXT:  <default>: DW_OP_reg3 RBX
 # VERBOSE-NEXT:  DW_LLE_default_location()
 # VERBOSE-NEXT:            => <default>: DW_OP_reg3 RBX

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

 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o %t.o
 # RUN: llvm-dwarfdump %t.o | FileCheck %s
 
-# CHECK: 0x00000000: Compile Unit: length = 0x00000009, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000000d)
+# CHECK: 0x00000000: Compile Unit: length = 0x00000009, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000000d)
 # CHECK: 0x0000000c: DW_TAG_compile_unit
 
   .section  .debug_abbrev,"",@progbits
   .byte 1                       # Abbreviation Code
   .byte 17                      # DW_TAG_compile_unit
   .byte 0                       # DW_CHILDREN_no
   .byte 0                       # EOM(1)
   .byte 0                       # EOM(2)

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

 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o %t.o
 # RUN: llvm-dwarfdump -v %t.o | FileCheck %s
 
 # DW_LLE_startx_length has different `length` encoding in pre-DWARF 5
 # and final DWARF 5 versions. This test checks we are able to parse
 # the final version which uses ULEB128 and not the U32.
 
 # CHECK:         .debug_loclists contents:
-# CHECK-NEXT:    0x00000000: locations list header: length = 0x0000000e, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# CHECK-NEXT:    0x00000000: locations list header: length = 0x0000000e, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 # CHECK-NEXT:    0x0000000c:
 # CHECK-NEXT:                DW_LLE_startx_length (0x0000000000000001, 0x0000000000000010): DW_OP_reg5 RDI
 # CHECK-NEXT:                DW_LLE_end_of_list   ()
 
 .section .debug_loclists,"",@progbits
  .long  .Ldebug_loclist_table_end0-.Ldebug_loclist_table_start0
 .Ldebug_loclist_table_start0:
  .short 5         # Version.

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

 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o %t.o
 # RUN: not llvm-dwarfdump --debug-rnglists %t.o 2> %t.err | FileCheck %s --check-prefixes=TERSE,BOTH
 # RUN: FileCheck %s --input-file %t.err --check-prefix=ERR
 # RUN: not llvm-dwarfdump -v --debug-rnglists %t.o 2> %t.err | FileCheck %s --check-prefixes=VERBOSE,BOTH
 # RUN: FileCheck %s --input-file %t.err --check-prefix=ERR
 
 # BOTH:         .debug_rnglists contents:
-# TERSE-NEXT:     range list header: length = 0x00000037, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# TERSE-NEXT:     range list header: length = 0x00000037, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 
 # VERBOSE-NEXT: 0x{{[0-9a-f]*}}:
-# VERBOSE-SAME: range list header: length = 0x00000037, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# VERBOSE-SAME: range list header: length = 0x00000037, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 
 # BOTH-NEXT:    ranges:
 # TERSE-NEXT:   [0x0000000000000010, 0x0000000000000020)
 # TERSE-NEXT:   [0x0000000000000025, 0x00000000000000a5)
 # TERSE-NEXT:   <End of list>
 # TERSE-NEXT:   [0x0000000000000100, 0x0000000000000200)
 # TERSE-NEXT:   <End of list>
 
 # VERBOSE-NEXT: 0x0000000c: [DW_RLE_start_end   ]: [0x0000000000000010, 0x0000000000000020)
 # VERBOSE-NEXT: 0x0000001d: [DW_RLE_start_length]:  0x0000000000000025, 0x0000000000000080
 # VERBOSE-SAME: => [0x0000000000000025, 0x00000000000000a5)
 # VERBOSE-NEXT: 0x00000028: [DW_RLE_end_of_list ]
 # VERBOSE-NEXT: 0x00000029: [DW_RLE_start_end   ]: [0x0000000000000100, 0x0000000000000200)
 # VERBOSE-NEXT: 0x0000003a: [DW_RLE_end_of_list ]
 
-# TERSE-NEXT:   range list header: length = 0x0000002b, version = 0x0005, addr_size = 0x04, seg_size = 0x00, offset_entry_count = 0x00000002
+# TERSE-NEXT:   range list header: length = 0x0000002b, format = DWARF32, version = 0x0005, addr_size = 0x04, seg_size = 0x00, offset_entry_count = 0x00000002
 
 # VERBOSE-NEXT: 0x{{[0-9a-f]*}}:
-# VERBOSE-SAME: range list header: length = 0x0000002b, version = 0x0005, addr_size = 0x04, seg_size = 0x00, offset_entry_count = 0x00000002
+# VERBOSE-SAME: range list header: length = 0x0000002b, format = DWARF32, version = 0x0005, addr_size = 0x04, seg_size = 0x00, offset_entry_count = 0x00000002
 
 # BOTH-NEXT:    offsets: [
 # BOTH-NEXT:      0x00000008
 # VERBOSE-SAME:   => 0x0000004f
 # BOTH-NEXT:      0x0000001b
 # VERBOSE-SAME:   => 0x00000062
 # BOTH-NEXT:    ]
 # BOTH-NEXT:    ranges:
 
 # TERSE-NEXT:   [0x00000000, 0x00000000)
 # TERSE-NEXT:   [0x00000002, 0x00000006)
 # TERSE-NEXT:   <End of list>
 # TERSE-NEXT:   [0x00000036, 0x00000136)
 # TERSE-NEXT:   <End of list>
 
 # VERBOSE-NEXT: 0x0000004f: [DW_RLE_start_end   ]: [0x00000000, 0x00000000)
 # VERBOSE-NEXT: 0x00000058: [DW_RLE_start_end   ]: [0x00000002, 0x00000006)
 # VERBOSE-NEXT: 0x00000061: [DW_RLE_end_of_list ]
 # VERBOSE-NEXT: 0x00000062: [DW_RLE_start_length]:  0x00000036, 0x00000100 => [0x00000036, 0x00000136)
 # VERBOSE-NEXT: 0x00000069: [DW_RLE_end_of_list ]
 
-# TERSE-NEXT:   range list header: length = 0x00000008, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# TERSE-NEXT:   range list header: length = 0x00000008, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 
 # VERBOSE-NEXT: 0x{{[0-9a-f]*}}:
-# VERBOSE-SAME: range list header: length = 0x00000008, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# VERBOSE-SAME: range list header: length = 0x00000008, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 
 # BOTH-NOT:     offsets:
 # BOTH:         ranges:
 # BOTH-NOT:     [
 
-# TERSE-NEXT:   range list header: length = 0x0000000b, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# TERSE-NEXT:   range list header: length = 0x0000000b, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 
 # VERBOSE-NEXT: 0x{{[0-9a-f]*}}:
-# VERBOSE-SAME: range list header: length = 0x0000000b, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# VERBOSE-SAME: range list header: length = 0x0000000b, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 
 # BOTH-NEXT:    ranges:
 # TERSE-NEXT:   <End of list>
 
 # VERBOSE-NEXT: 0x00000082: [DW_RLE_base_addressx]:  0x0000000000000000
 # VERBOSE-NEXT: 0x00000084: [DW_RLE_end_of_list ]
 
-# TERSE-NEXT:   range list header: length = 0x0000000c, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# TERSE-NEXT:   range list header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 
 # VERBOSE-NEXT: 0x{{[0-9a-f]*}}:
-# VERBOSE-SAME: range list header: length = 0x0000000c, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# VERBOSE-SAME: range list header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 
 # BOTH-NEXT:    ranges:
 # TERSE-NEXT:   [0x0000000000000000, 0x000000000000002a)
 # TERSE-NEXT:   <End of list>
 
 # VERBOSE-NEXT: 0x000000a1: [DW_RLE_startx_length]:  0x0000000000000002, 0x000000000000002a => [0x0000000000000000, 0x000000000000002a)
 # VERBOSE-NEXT: 0x000000a4: [DW_RLE_end_of_list ]
 
-# TERSE-NEXT:   range list header: length = 0x0000000e, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# TERSE-NEXT:   range list header: length = 0x0000000e, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 
 # VERBOSE-NEXT: 0x{{[0-9a-f]*}}:
-# VERBOSE-SAME: range list header: length = 0x0000000e, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# VERBOSE-SAME: range list header: length = 0x0000000e, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 
 # BOTH-NEXT:    ranges:
 # TERSE-NEXT:   [0x0000000000000800, 0x0000000000001000)
 # TERSE-NEXT:   <End of list>
 
 # VERBOSE-NEXT: 0x000000b1: [DW_RLE_offset_pair]:  0x0000000000000800, 0x0000000000001000 =>
 # VERBOSE-SAME:                                   [0x0000000000000800, 0x0000000000001000)
 # VERBOSE-NEXT: 0x000000b6: [DW_RLE_end_of_list]
 
-# TERSE-NEXT:   range list header: length = 0x00000017, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# TERSE-NEXT:   range list header: length = 0x00000017, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 
 # VERBOSE-NEXT: 0x{{[0-9a-f]*}}:
-# VERBOSE-SAME: range list header: length = 0x00000017, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# VERBOSE-SAME: range list header: length = 0x00000017, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 
 # BOTH-NEXT:    ranges:
 # TERSE-NEXT:   [0x0000000000001800, 0x0000000000002000)
 # TERSE-NEXT:   <End of list>
 
 # VERBOSE-NEXT: 0x000000c3: [DW_RLE_base_address]:  0x0000000000001000
 # VERBOSE-NEXT: 0x000000cc: [DW_RLE_offset_pair ]:  0x0000000000000800, 0x0000000000001000 =>
 # VERBOSE-SAME:                                    [0x0000000000001800, 0x0000000000002000)

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 = 0x000000000000001a,
+# CHECK-SAME:   format = DWARF64,
 # 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: 0x0000000000000011 => 0x00000025
 # CHECK-NEXT: ]

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

 # RUN: llvm-mc %S/Inputs/debug_rnglists_short_section.s -filetype obj -triple x86_64-pc-linux -o - | \
 # RUN: not llvm-dwarfdump --debug-rnglists - 2>&1 | FileCheck %s --check-prefix=SHORT
 # SHORT-NOT: error:
 # SHORT-NOT: range list header
 # SHORT: error: parsing .debug_rnglists table at offset 0x0: unexpected end of data at offset 0x0
 # SHORT-NOT: range list header
 # SHORT-NOT: error:
 
 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o - | \
 # RUN: not llvm-dwarfdump --debug-rnglists - 2> %t.err | FileCheck %s --check-prefix=GOOD
 # RUN: FileCheck %s --input-file %t.err
 
 # GOOD: .debug_rnglists contents:
-# GOOD-NEXT: range list header: length = 0x0000001e, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000001
+# GOOD-NEXT: range list header: length = 0x0000001e, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000001
 # GOOD-NEXT: offsets: [
 # GOOD-NEXT:    0x00000004
 # GOOD-NEXT: ]
 # GOOD-NEXT: ranges:
 # GOOD-NEXT: [0x0000000000000010, 0x0000000000000020)
 # GOOD-NEXT: <End of list>
-# GOOD-NEXT: range list header: length = 0x0000001a, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# GOOD-NEXT: range list header: length = 0x0000001a, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 # GOOD-NEXT: ranges:
 # GOOD-NEXT: [0x0000000000000030, 0x0000000000000040)
 # GOOD-NEXT: <End of list>
 # GOOD-NOT:  range list header
 
 # CHECK-NOT: error:
 # CHECK: error: .debug_rnglists table at offset 0x22 has too small length (0xb) to contain a complete header
 # CHECK-NEXT: error: unrecognised .debug_rnglists table version 4 in table at offset 0x2d

llvm/test/tools/llvm-dwarfdump/X86/eh-frame-return-address-reg.s

 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o %t.o
 # RUN: llvm-dwarfdump -v %t.o | FileCheck %s
 
 # The format of the .eh_frame section is similar in
 # format and purpose to the .debug_frame section.
 # Version 1 is often used for .eh_frame,
 # and also it was used for DWARF v2. For that case,
 # return address register should be encoded as ubyte,
 # while later versions use ULEB128. This test case
 # checks that we are able to dump it correctly.
 
 # CHECK:      .eh_frame contents:
 # CHECK:      00000000 00000010 00000000 CIE
+# CHECK-NEXT:   Format:                DWARF32
 # CHECK-NEXT:   Version:               1
 # CHECK-NEXT:   Augmentation:          "zR"
 # CHECK-NEXT:   Code alignment factor: 1
 # CHECK-NEXT:   Data alignment factor: 1
 # CHECK-NEXT:   Return address column: 240
 # CHECK-NEXT:   Augmentation data:     1A
 
 .text

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

 # RUN: llvm-mc %s -filetype obj -triple x86_64-apple-darwin -o - \
 # RUN:   | llvm-dwarfdump -lookup=0xb - | \
 # RUN: FileCheck %s -check-prefixes=CHECK,LEX,B
 
 # RUN: llvm-mc %s -filetype obj -triple x86_64-apple-darwin -o - \
 # RUN:   | llvm-dwarfdump -lookup=0x14 - | \
 # RUN: FileCheck %s -check-prefixes=CHECK,C
 
-# CHECK: Compile Unit: length = 0x00000060, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000064)
+# CHECK: Compile Unit: length = 0x00000060, format = DWARF32, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000064)
 
 # CHECK: DW_TAG_compile_unit
 # CHECK:   DW_AT_name        ("foo.c")
 # CHECK:   DW_AT_stmt_list   (0x00000000)
 # CHECK:   DW_AT_low_pc      (0x0000000000000000)
 # CHECK:   DW_AT_high_pc     (0x0000000000000016)
 
 # CHECK: DW_TAG_subprogram

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

# RUN:   FileCheck %s
 
         .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 = 0x0000000000000021
+# CHECK-SAME: 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
 
         .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 = 0x0000000000000022
+# CHECK-SAME: 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

llvm/test/tools/llvm-dwp/X86/info-v5.s

 # this checks llvm-dwp handling of DWARFv5 Info section header.
 
 # RUN: llvm-mc --triple=x86_64-unknown-linux --filetype=obj --split-dwarf-file=%t.dwo -dwarf-version=5 %s -o %t.o
 
 # RUN: llvm-dwp %t.dwo -o %t.dwp
 # RUN: llvm-dwarfdump -v %t.dwp | FileCheck %s
 
 #CHECK-DAG: .debug_info.dwo contents:
-#CHECK: 0x00000000: Compile Unit: length = 0x00000050, version = 0x0005, unit_type = DW_UT_split_compile, abbr_offset = 0x0000, addr_size = 0x08, DWO_id = [[DWOID:.*]] (next unit at 0x00000054)
+#CHECK: 0x00000000: Compile Unit: length = 0x00000050, format = DWARF32, version = 0x0005, unit_type = DW_UT_split_compile, abbr_offset = 0x0000, addr_size = 0x08, DWO_id = [[DWOID:.*]] (next unit at 0x00000054)
 
 # CHECK-DAG: .debug_cu_index contents:
 # CHECK: version = 2 slots = 2
 # CHECK: Index Signature          INFO                     ABBREV
 # CHECK: 1 [[DWOID]] [0x00000000, 0x00000054) [0x00000000, 0x0000002a)
 
   .section  .debug_info.dwo,"e",@progbits
   .long .Ldebug_info_dwo_end0-.Ldebug_info_dwo_start0 # Length of Unit

llvm/test/tools/llvm-dwp/X86/simple.test

 TYPES:     DW_AT_signature {{.*}} ([[BARSIG:.*]])
 CHECK:   DW_TAG_subprogram
 CHECK:     DW_AT_name {{.*}} "b"
 CHECK:     DW_TAG_formal_parameter
 
 NOTYP-NOT: .debug_types.dwo contents:
 TYPES-LABEL: .debug_types.dwo contents:
 TYPES: [[FOOUOFF:0x[0-9a-f]*]]:
-TYPES-LABEL: Type Unit: length = 0x00000020, version = 0x0004, abbr_offset =
+TYPES-LABEL: Type Unit: length = 0x00000020, format = DWARF32, version = 0x0004, abbr_offset =
 TYPES:         0x[[AAOFF]], addr_size = 0x08, name = 'foo', type_signature = [[FOOSIG]], type_offset = 0x[[FOOOFF:.*]] (next unit at [[BARUOFF:.*]])
 TYPES:             DW_TAG_type_unit
 TYPES: [[FOOOFF]]:   DW_TAG_structure_type
 TYPES:                 DW_AT_name {{.*}} "foo"
 TYPES: [[BARUOFF]]:
-TYPES-LABEL: Type Unit: length = 0x00000020, version = 0x0004, abbr_offset =
+TYPES-LABEL: Type Unit: length = 0x00000020, format = DWARF32, version = 0x0004, abbr_offset =
 TYPES:         0x[[BAOFF]], addr_size = 0x08, name = 'bar', type_signature = [[BARSIG]], type_offset = 0x001e (next unit at [[XUOFF:.*]])
 TYPES:             DW_TAG_type_unit
 TYPES: 0x00000042:   DW_TAG_structure_type
 TYPES:                 DW_AT_name {{.*}} "bar"
 
 CHECK-LABEL: .debug_cu_index contents:
 CHECK: Index Signature INFO                      ABBREV                             LINE                     STR_OFFSETS
 TYPES:     1 [[DWOA]]  {{\[}}[[AOFF]], [[BOFF]]) [0x0000[[AAOFF]], 0x0000[[BAOFF]]) [0x00000000, 0x0000001a) [0x00000000, 0x00000010)

llvm/test/tools/llvm-dwp/X86/type_dedup.test

 b.cpp:
   struct common { };
   common b1;
   struct bdistinct { };
   bdistinct b2;
 
 CHECK-LABEL: .debug_types.dwo contents:
 CHECK: [[COMMONUOFF:0x[0-9a-f]*]]:
-CHECK-LABEL: Type Unit: length = 0x00000020, version = 0x0004, abbr_offset =
+CHECK-LABEL: Type Unit: length = 0x00000020, format = DWARF32, version = 0x0004, abbr_offset =
 CHECK:         0x0000, addr_size = 0x08, name = 'common', type_signature = [[COMMONSIG:0x[0-9a-f]*]], type_offset = 0x[[COMMONOFF:.*]] (next unit at [[AUOFF:.*]])
 CHECK:                DW_TAG_type_unit
 CHECK: [[COMMONOFF]]:   DW_TAG_structure_type
 CHECK:                    DW_AT_name {{.*}} "common"
 CHECK: [[AUOFF]]:
-CHECK-LABEL: Type Unit: length = 0x00000020, version = 0x0004, abbr_offset =
+CHECK-LABEL: Type Unit: length = 0x00000020, format = DWARF32, version = 0x0004, abbr_offset =
 CHECK:         0x0000, addr_size = 0x08, name = 'adistinct', type_signature = [[ASIG:0x[0-9a-f]*]], type_offset = 0x[[AOFF:.*]] (next unit at [[BUOFF:.*]])
 CHECK:             DW_TAG_type_unit
 CHECK: 0x00000042:   DW_TAG_structure_type
 CHECK:                 DW_AT_name {{.*}} "adistinct"
 CHECK: [[BUOFF]]:
-CHECK-LABEL: Type Unit: length = 0x00000020, version = 0x0004, abbr_offset =
+CHECK-LABEL: Type Unit: length = 0x00000020, format = DWARF32, version = 0x0004, abbr_offset =
 CHECK:         0x{{.*}}, addr_size = 0x08, name = 'bdistinct', type_signature = [[BSIG:0x[0-9a-f]*]], type_offset = 0x[[BOFF:.*]] (next unit at [[XUOFF:.*]])
 CHECK:             DW_TAG_type_unit
 CHECK: 0x00000066:   DW_TAG_structure_type
 CHECK:                 DW_AT_name {{.*}} "bdistinct"
 CHECK-NOT: Type Unit