[DWARF] Do not cut 64-bit values when dumping CIEs and FDEs.

[ikudrin]

Summary

This fixes printing long values that might reside in CIE and FDE, including offsets, lengths, and addresses.

[probinson]

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

291

Why the exception for .eh_frame?

[ikudrin]

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

291

CIE ID in .eh_frame, unlike .debug_frame, is always 4 bytes long, see https://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html

[probinson]

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

291

That description diverges from what my copy of the AMD64 psABI spec says (v0.99.8 from 2015), which has nothing in it to specify that CIE_id/CIE_pointer are always 4-byte. I agree that the CIE_id is not actually fixed; AFAICT the DWARF spec doesn't say what it should be, in normative text, although it uses 0xffffffff in an example. The psABI says that a position-independent .eh_frame should set CIE_id to 1.

Clearly we should be dumping the actual CIE_id field from the file, not pretending it's a particular fixed value. We also need to clear up under what conditions the field is 4 bytes versus 8; apparently it's not as simple as this patch suggests.

320

The FDE's offset-to-CIE field must exactly overlay the CIE's CIE_id field. This treats it as strictly format-dependent, which is not consistent with the Linux document you pointed to.

[ikudrin]

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

291

I am not sure what is the "CIE identifier tag" they talk about in the "Position independence" section you cited, but please take a look at a description for CIE id on page 62:

Table 4.6: Common Information Entry (CIE)
CIE id, 4, Value 0 for .eh_frame (used to distinguish CIEs and FDEs when scanning the section)

And a description for CIE pointer on page 64:

Table 4.8: Frame Descriptor Entry (FDE)
CIE pointer, 4, Distance from this field to the nearest preceding CIE (the value is subtracted from the current address). This value can never be zero and thus can be used to distinguish CIE’s and FDE’s when scanning the .eh_frame section

320

Oh, thanks! I'll fix that with the next update.

[probinson]

The table and page numbering in my copy of the psABI does not match yours, but I do see the values you cite. In my version, the CIE table also specifies that the Length field is 4 bytes (not optionally 12 bytes, or a 4-byte reserved value and 8-byte extended length, however you want to think about it). But likely the Linux folks have added that possibility, while maintaining a 4-byte CIE_id/pointer field, which (as I describe below) doesn't actually get the .eh_frame section into trouble.

What I was mentioning before is (in my copy) in section 3.7, 2nd paragraph. "Position independence: In order to avoid load time relocations for position independent code, the FDE CIE offset pointer should be stored relative to the start of CIE table entry. Frames using this extension of the DWARF standard must set the CIE identifier tag to 1." This appears to disagree with the table, which says the value is always 0; but I *think* the descriptions of the CIE offset/pointer here and in the table are trying to say the same thing. So I am not sure what the value 1 is about.

Aha, found the part of the DWARF spec that specifies the CIE id as 0xffffffff. Section 7.24 in DWARF v5, and something nearby in earlier versions. So it is normative after all.

I've been thinking about how the .debug_frame and .eh_frame definitions differ. In .debug_frame, the FDE's CIE pointer is an offset from the beginning of the .debug_frame section; thus, it must be 64-bit in the DWARF-64 format. In .eh_frame, the FDE's CIE pointer is the distance from the FDE to the CIE (loosely speaking) and so can be 32-bit so long as no individual set of CIE+FDEs exceeds 32-bits in length (likely a safe assumption). This means that .eh_frame can in fact support a DWARF-64-like overall length, while still having only a 4-byte CIE pointer.

We could rely on the section name to distinguish these formats; there is a verification opportunity here, as .debug_frame should have CIE_id = 0xffffffff[ffffffff], while .eh_frame should have CIE_id = 0 (4-byte) even given a 12-byte initial length field.

Regarding what to do with this patch, I still think we should print the CIE_id as read from the file, not hard-code values, because hard-coded values mean that mistakes in setting CIE_id will never be noticed. And you never know, things can change in the future.

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

291

I'm going to move my reply to the out-of-line comment section where it will be easier (for me at least) to read & follow.

[ikudrin]

• Fix the printing field length of CIE pointer for FDEs in .eh_frame.
• Keep the actual value of the CIE Id field.

I have to mention that I fell a bit uncomfortable storing a constant value that can be easily reconstructed. I prepared another patch which uses another approach to guarantee that the reading and dumping values are the same. Please, take a look at D73887 and tell me which variant you like better; I will abandon the other one.

[ikudrin]

Abandoning in favor of D73887.

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

 };
 
 /// An entry in either debug_frame or eh_frame. This entry can be a CIE or an
 /// FDE.
 class FrameEntry {
 public:
   enum FrameKind { FK_CIE, FK_FDE };
 
-  FrameEntry(FrameKind K, uint64_t Offset, uint64_t Length, uint64_t CodeAlign,
-             int64_t DataAlign, Triple::ArchType Arch)
-      : Kind(K), Offset(Offset), Length(Length),
+  FrameEntry(FrameKind K, bool IsDWARF64, uint64_t Offset, uint64_t Length,
+             uint64_t CodeAlign, int64_t DataAlign, Triple::ArchType Arch)
+      : Kind(K), IsDWARF64(IsDWARF64), Offset(Offset), Length(Length),
         CFIs(CodeAlign, DataAlign, Arch) {}
 
   virtual ~FrameEntry() {}
 
   FrameKind getKind() const { return Kind; }
   uint64_t getOffset() const { return Offset; }
   uint64_t getLength() const { return Length; }
   const CFIProgram &cfis() const { return CFIs; }
   CFIProgram &cfis() { return CFIs; }
 
   /// Dump the instructions in this CFI fragment
   virtual void dump(raw_ostream &OS, const MCRegisterInfo *MRI,
                     bool IsEH) const = 0;
 
 protected:
   const FrameKind Kind;
 
+  const bool IsDWARF64;
+
   /// Offset of this entry in the section.
   const uint64_t Offset;
 
   /// Entry length as specified in DWARF.
   const uint64_t Length;
 
   CFIProgram CFIs;
 };
 
 /// DWARF Common Information Entry (CIE)
 class CIE : public FrameEntry {
 public:
   // CIEs (and FDEs) are simply container classes, so the only sensible way to
   // create them is by providing the full parsed contents in the constructor.
-  CIE(uint64_t Offset, uint64_t Length, uint8_t Version,
-      SmallString<8> Augmentation, uint8_t AddressSize,
+  CIE(bool IsDWARF64, uint64_t Offset, uint64_t Length, uint64_t CIEId,
+      uint8_t Version, SmallString<8> Augmentation, uint8_t AddressSize,
       uint8_t SegmentDescriptorSize, uint64_t CodeAlignmentFactor,
       int64_t DataAlignmentFactor, uint64_t ReturnAddressRegister,
       SmallString<8> AugmentationData, uint32_t FDEPointerEncoding,
       uint32_t LSDAPointerEncoding, Optional<uint64_t> Personality,
       Optional<uint32_t> PersonalityEnc, Triple::ArchType Arch)
-      : FrameEntry(FK_CIE, Offset, Length, CodeAlignmentFactor,
+      : FrameEntry(FK_CIE, IsDWARF64, Offset, Length, CodeAlignmentFactor,
                    DataAlignmentFactor, Arch),
-        Version(Version), Augmentation(std::move(Augmentation)),
+        CIEId(CIEId), Version(Version), Augmentation(std::move(Augmentation)),
         AddressSize(AddressSize), SegmentDescriptorSize(SegmentDescriptorSize),
         CodeAlignmentFactor(CodeAlignmentFactor),
         DataAlignmentFactor(DataAlignmentFactor),
         ReturnAddressRegister(ReturnAddressRegister),
         AugmentationData(std::move(AugmentationData)),
         FDEPointerEncoding(FDEPointerEncoding),
         LSDAPointerEncoding(LSDAPointerEncoding), Personality(Personality),
         PersonalityEnc(PersonalityEnc) {}
public:
 
   uint32_t getLSDAPointerEncoding() const { return LSDAPointerEncoding; }
 
   void dump(raw_ostream &OS, const MCRegisterInfo *MRI,
             bool IsEH) const override;
 
 private:
   /// The following fields are defined in section 6.4.1 of the DWARF standard v4
+  const uint64_t CIEId;
   const uint8_t Version;
   const SmallString<8> Augmentation;
   const uint8_t AddressSize;
   const uint8_t SegmentDescriptorSize;
   const uint64_t CodeAlignmentFactor;
   const int64_t DataAlignmentFactor;
   const uint64_t ReturnAddressRegister;
 
   // The following are used when the CIE represents an EH frame entry.
   const SmallString<8> AugmentationData;
   const uint32_t FDEPointerEncoding;
   const uint32_t LSDAPointerEncoding;
   const Optional<uint64_t> Personality;
   const Optional<uint32_t> PersonalityEnc;
 };
 
 /// DWARF Frame Description Entry (FDE)
 class FDE : public FrameEntry {
 public:
   // Each FDE has a CIE it's "linked to". Our FDE contains is constructed with
   // an offset to the CIE (provided by parsing the FDE header). The CIE itself
   // is obtained lazily once it's actually required.
-  FDE(uint64_t Offset, uint64_t Length, int64_t LinkedCIEOffset,
+  FDE(bool IsDWARF64, uint64_t Offset, uint64_t Length, int64_t LinkedCIEOffset,
       uint64_t InitialLocation, uint64_t AddressRange, CIE *Cie,
       Optional<uint64_t> LSDAAddress, Triple::ArchType Arch)
-      : FrameEntry(FK_FDE, Offset, Length,
+      : FrameEntry(FK_FDE, IsDWARF64, Offset, Length,
                    Cie ? Cie->getCodeAlignmentFactor() : 0,
                    Cie ? Cie->getDataAlignmentFactor() : 0,
                    Arch),
         LinkedCIEOffset(LinkedCIEOffset), InitialLocation(InitialLocation),
         AddressRange(AddressRange), LinkedCIE(Cie), LSDAAddress(LSDAAddress) {}
 
   ~FDE() override = default;
 

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

for (const auto &Instr : Instructions) {
     OS << CallFrameString(Opcode, Arch) << ":";
     for (unsigned i = 0; i < Instr.Ops.size(); ++i)
       printOperand(OS, MRI, IsEH, Instr, i, Instr.Ops[i]);
     OS << '\n';
   }
 }
 
 void CIE::dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH) const {
-  OS << format("%08x %08x %08x CIE", (uint32_t)Offset, (uint32_t)Length,
-               IsEH ? 0 : DW_CIE_ID)
-     << "\n";
+  OS << format("%08" PRIx64, Offset)
+     << format(" %0*" PRIx64, IsDWARF64 ? 16 : 8, Length)
+     << format(" %0*" PRIx64, IsDWARF64 && !IsEH ? 16 : 8, CIEId)
+     << " CIE\n";
   OS << format("  Version:               %d\n", Version);
   OS << "  Augmentation:          \"" << Augmentation << "\"\n";
   if (Version >= 4) {
     OS << format("  Address size:          %u\n", (uint32_t)AddressSize);
     OS << format("  Segment desc size:     %u\n",
                  (uint32_t)SegmentDescriptorSize);
   }
   OS << format("  Code alignment factor: %u\n", (uint32_t)CodeAlignmentFactor);
   OS << format("  Data alignment factor: %d\n", (int32_t)DataAlignmentFactor);
   OS << format("  Return address column: %d\n", (int32_t)ReturnAddressRegister);
   if (Personality)
     OS << format("  Personality Address: %016" PRIx64 "\n", *Personality);
   if (!AugmentationData.empty()) {
     OS << "  Augmentation data:    ";
     for (uint8_t Byte : AugmentationData)
       OS << ' ' << hexdigit(Byte >> 4) << hexdigit(Byte & 0xf);
     OS << "\n";
   }
   OS << "\n";
   CFIs.dump(OS, MRI, IsEH);
   OS << "\n";
 }
 
 void FDE::dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH) const {
-  OS << format("%08x %08x %08x FDE ", (uint32_t)Offset, (uint32_t)Length,
-               (int32_t)LinkedCIEOffset);
-  OS << format("cie=%08x pc=%08x...%08x\n", (int32_t)LinkedCIEOffset,
-               (uint32_t)InitialLocation,
-               (uint32_t)InitialLocation + (uint32_t)AddressRange);
+  OS << format("%08" PRIx64, Offset)
+     << format(" %0*" PRIx64, IsDWARF64 ? 16 : 8, Length)
+     << format(" %0*" PRIx64, IsDWARF64 && !IsEH ? 16 : 8, LinkedCIEOffset)
+     << format(" FDE cie=%0*" PRIx64, IsDWARF64 && !IsEH ? 16 : 8,
+               LinkedCIEOffset)
+     << format(" pc=%08" PRIx64 "...%08" PRIx64, InitialLocation,
+               InitialLocation + AddressRange)
+     << "\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)
if (IsCIE) {
                         "Parsing augmentation data at %" PRIx64 " failed");
 
           AugmentationData = Data.getData().slice(StartAugmentationOffset,
                                                   EndAugmentationOffset);
         }
       }
 
       auto Cie = std::make_unique<CIE>(
-          StartOffset, Length, Version, AugmentationString, AddressSize,
-          SegmentDescriptorSize, CodeAlignmentFactor, DataAlignmentFactor,
-          ReturnAddressRegister, AugmentationData, FDEPointerEncoding,
-          LSDAPointerEncoding, Personality, PersonalityEncoding, Arch);
+          IsDWARF64, StartOffset, Length, Id, Version, AugmentationString,
+          AddressSize, SegmentDescriptorSize, CodeAlignmentFactor,
+          DataAlignmentFactor, ReturnAddressRegister, AugmentationData,
+          FDEPointerEncoding, LSDAPointerEncoding, Personality,
+          PersonalityEncoding, Arch);
       CIEs[StartOffset] = Cie.get();
       Entries.emplace_back(std::move(Cie));
     } else {
       // FDE
       uint64_t CIEPointer = Id;
       uint64_t InitialLocation = 0;
       uint64_t AddressRange = 0;
       Optional<uint64_t> LSDAAddress;
if (IsCIE) {
             ReportError(StartOffset,
                         "Parsing augmentation data at %" PRIx64 " failed");
         }
       } else {
         InitialLocation = Data.getRelocatedAddress(&Offset);
         AddressRange = Data.getRelocatedAddress(&Offset);
       }
 
-      Entries.emplace_back(new FDE(StartOffset, Length, CIEPointer,
-                                   InitialLocation, AddressRange,
-                                   Cie, LSDAAddress, Arch));
+      Entries.emplace_back(new FDE(IsDWARF64, StartOffset, Length, CIEPointer,
+                                   InitialLocation, AddressRange, Cie,
+                                   LSDAAddress, Arch));
     }
 
     if (Error E =
             Entries.back()->cfis().parse(Data, &Offset, EndStructureOffset)) {
       report_fatal_error(toString(std::move(E)));
     }
 
     if (Offset != EndStructureOffset)

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:   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=0000001c pc=fffffd00...fffffd24
+EH-NEXT: 00000018 00000024 0000001c FDE cie=0000001c pc=fffffffffffffd00...fffffffffffffd24
 EH-NEXT:   DW_CFA_advance_loc: 1
 EH-NOT: pc
 EH-NOT: CIE

llvm/test/tools/llvm-objdump/eh_frame-arm64.test

 # RUN: llvm-objdump -dwarf=frames %p/Inputs/eh_frame.macho-arm64 2>/dev/null | FileCheck %s
 
 # CHECK: .eh_frame contents:
 
 # CHECK: 00000000 00000010 00000000 CIE
 # CHECK:   Version:               1
 # CHECK:   Augmentation:          "zR"
 # CHECK:   Code alignment factor: 1
 # CHECK:   Data alignment factor: -8
 # CHECK:   Return address column: 30
 # CHECK:   Augmentation data:     10
 
 # CHECK:   DW_CFA_def_cfa: reg31 +0
 
-# CHECK: 00000014 00000020 00000018 FDE cie=00000018 pc=ffffffe4...00000004
+# CHECK: 00000014 00000020 00000018 FDE cie=00000018 pc=ffffffffffffffe4...00000004
 # CHECK:   DW_CFA_advance_loc: 8
 # CHECK:   DW_CFA_def_cfa_offset: +16
 # CHECK:   DW_CFA_offset: reg30 -8
 # CHECK:   DW_CFA_offset: reg29 -16
 # CHECK:   DW_CFA_nop:
 # CHECK:   DW_CFA_nop:
 # CHECK:   DW_CFA_nop:
 # CHECK:   DW_CFA_nop:

llvm/unittests/DebugInfo/DWARF/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   AsmPrinter
   DebugInfoDWARF
   MC
   Object
   ObjectYAML
   Support
   )
 
 add_llvm_unittest(DebugInfoDWARFTests
   DwarfGenerator.cpp
   DwarfUtils.cpp
   DWARFAcceleratorTableTest.cpp
   DWARFDebugArangeSetTest.cpp
+  DWARFDebugFrameTest.cpp
   DWARFDebugInfoTest.cpp
   DWARFDebugLineTest.cpp
   DWARFDieTest.cpp
   DWARFFormValueTest.cpp
   DWARFLocationExpressionTest.cpp
   )
 
 target_link_libraries(DebugInfoDWARFTests PRIVATE LLVMTestingSupport)

llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp

+//===- llvm/unittest/DebugInfo/DWARFDebugFrameTest.cpp --------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace {
+
+TEST(DWARFDebugFrame, CIEDumpDWARF64) {
+  dwarf::CIE TestCIE(
+      /* IsDWARF64 = */ true,
+      /* Offset = */ 0x1111abcdabcdULL,
+      /* Length = */ 0x2222abcdabcdULL,
+      /* CIEId = */ 0xffffffffffffffffULL,
+      /* Version = */ 3,
+      /* Augmentation = */ StringRef(),
+      /* AddressSize = */ 8,
+      /* SegmentDescriptorSize = */ 0,
+      /* CodeAlignmentFactor = */ 1,
+      /* DataAlignmentFactor = */ -8,
+      /* ReturnAddressRegister = */ 16,
+      /* AugmentationData = */ StringRef(),
+      /* FDEPointerEncoding = */ dwarf::DW_EH_PE_absptr,
+      /* LSDAPointerEncoding = */ dwarf::DW_EH_PE_omit,
+      /* Personality = */ None,
+      /* PersonalityEnc = */ None,
+      /* Arch = */ Triple::x86_64);
+  std::string Output;
+  raw_string_ostream OS(Output);
+  TestCIE.dump(OS, /* MRI = */ nullptr, /* IsEH = */ false);
+  OS.flush();
+  SmallVector<StringRef, 10> OutputLines;
+  StringRef(Output).split(OutputLines, '\n');
+  ASSERT_EQ(OutputLines.size(), 9U);
+  EXPECT_EQ(OutputLines[0],
+            "1111abcdabcd 00002222abcdabcd ffffffffffffffff CIE");
+}
+
+TEST(DWARFDebugFrame, CIEDumpEH) {
+  dwarf::CIE TestCIE(
+      /* IsDWARF64 = */ false,
+      /* Offset = */ 0x1000,
+      /* Length = */ 0x20,
+      /* CIEId = */ 0,
+      /* Version = */ 3,
+      /* Augmentation = */ StringRef(),
+      /* AddressSize = */ 8,
+      /* SegmentDescriptorSize = */ 0,
+      /* CodeAlignmentFactor = */ 1,
+      /* DataAlignmentFactor = */ -8,
+      /* ReturnAddressRegister = */ 16,
+      /* AugmentationData = */ StringRef(),
+      /* FDEPointerEncoding = */ dwarf::DW_EH_PE_absptr,
+      /* LSDAPointerEncoding = */ dwarf::DW_EH_PE_omit,
+      /* Personality = */ None,
+      /* PersonalityEnc = */ None,
+      /* Arch = */ Triple::x86_64);
+  std::string Output;
+  raw_string_ostream OS(Output);
+  TestCIE.dump(OS, /* MRI = */ nullptr, /* IsEH = */ true);
+  OS.flush();
+  StringRef FirstLine = StringRef(Output).split('\n').first;
+  EXPECT_EQ(FirstLine, "00001000 00000020 00000000 CIE");
+}
+
+TEST(DWARFDebugFrame, CIEDumpEHDWARF64) {
+  dwarf::CIE TestCIE(
+      /* IsDWARF64 = */ true,
+      /* Offset = */ 0x1000ULL,
+      /* Length = */ 0x20ULL,
+      /* CIEId = */ 0,
+      /* Version = */ 3,
+      /* Augmentation = */ StringRef(),
+      /* AddressSize = */ 8,
+      /* SegmentDescriptorSize = */ 0,
+      /* CodeAlignmentFactor = */ 1,
+      /* DataAlignmentFactor = */ -8,
+      /* ReturnAddressRegister = */ 16,
+      /* AugmentationData = */ StringRef(),
+      /* FDEPointerEncoding = */ dwarf::DW_EH_PE_absptr,
+      /* LSDAPointerEncoding = */ dwarf::DW_EH_PE_omit,
+      /* Personality = */ None,
+      /* PersonalityEnc = */ None,
+      /* Arch = */ Triple::x86_64);
+  std::string Output;
+  raw_string_ostream OS(Output);
+  TestCIE.dump(OS, /* MRI = */ nullptr, /* IsEH = */ true);
+  OS.flush();
+  SmallVector<StringRef, 10> OutputLines;
+  StringRef(Output).split(OutputLines, '\n');
+  ASSERT_EQ(OutputLines.size(), 9U);
+  EXPECT_EQ(OutputLines[0],
+            "00001000 0000000000000020 00000000 CIE");
+}
+
+TEST(DWARFDebugFrame, FDEDumpDWARF64) {
+  dwarf::FDE TestFDE(/* IsDWARF64 = */ true,
+                     /* Offset = */ 0x1111abcdabcdULL,
+                     /* Length = */ 0x2222abcdabcdULL,
+                     /* LinkedCIEOffset = */ 0x3333abcdabcdULL,
+                     /* InitialLocation = */ 0x4444abcdabcdULL,
+                     /* AddressRange = */ 0x111111111111ULL,
+                     /* Cie = */ nullptr,
+                     /* LSDAAddress = */ None,
+                     /* Arch = */ Triple::x86_64);
+  std::string Output;
+  raw_string_ostream OS(Output);
+  TestFDE.dump(OS, /* MRI = */ nullptr, /* IsEH = */ false);
+  OS.flush();
+  EXPECT_STREQ(
+      Output.c_str(),
+      "1111abcdabcd 00002222abcdabcd 00003333abcdabcd FDE "
+      "cie=00003333abcdabcd pc=4444abcdabcd...5555bcdebcde\n\n");
+}
+
+TEST(DWARFDebugFrame, FDEDumpEHDWARF64) {
+  dwarf::FDE TestFDE(/* IsDWARF64 = */ true,
+                     /* Offset = */ 0x1111abcdabcdULL,
+                     /* Length = */ 0x2222abcdabcdULL,
+                     /* LinkedCIEOffset = */ 0x33abcdULL,
+                     /* InitialLocation = */ 0x4444abcdabcdULL,
+                     /* AddressRange = */ 0x111111111111ULL,
+                     /* Cie = */ nullptr,
+                     /* LSDAAddress = */ None,
+                     /* Arch = */ Triple::x86_64);
+  std::string Output;
+  raw_string_ostream OS(Output);
+  TestFDE.dump(OS, /* MRI = */ nullptr, /* IsEH = */ true);
+  OS.flush();
+  EXPECT_STREQ(
+      Output.c_str(),
+      "1111abcdabcd 00002222abcdabcd 0033abcd FDE "
+      "cie=0033abcd pc=4444abcdabcd...5555bcdebcde\n\n");
+}
+
+} // end anonymous namespace