[dwarfdump] Make .eh_frame an alias for .debug_frame

[JDevlieghere]

Summary

This patch makes the .eh_frame extension an alias for .debug_frame.
Up till now it was only possible to dump the section using objdump, but
not with dwarfdump. Since the two are essentially interchangeable, we
dump whichever of the two is present.

As a workaround, this patch also adds parsing for 3 currently
unimplemented CFA instructions: DW_CFA_def_cfa_expression,
DW_CFA_expression, and DW_CFA_val_expression. Because I lack the
required knowledge, I just parse the fields without actually creating
the instructions.

Finally, this also fixes the typo in the .debug_frame section name
which incorrectly contained a trailing s.

[rnk]

lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

191–200

Why does this need to be part of this change? It seems nicer to commit this without the change, XFAIL or workaround whatever test relies on these, and implement the DW_OP expression machine in a follow-up change.

[JDevlieghere]

lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

191–200

I agree, and essentially this is the workaround. Unless we just want to bail and don't care about any subsequent instructions that we might understand, we need to at least increment the offset. Failing isn't really an option imho because .eh_frame is part of "all" and that might have a pretty big impact.

Maybe I can update the comment to stress that this is a workaround?

[aprantl]

include/llvm/DebugInfo/DIContext.h

160

Do we want to retain the ability to verify only part of a file? E.g., --verify --debug-info?

[aprantl]

Sorry, I accidentally marked this as accepted.

[aprantl]

include/llvm/DebugInfo/DIContext.h

160

To answer my rhetoric question: I think we do.

[probinson]

My impression is that .eh_frame and .debug_frame are interchangeable and in fact you get only one or the other in any given compilation. So, if you ask for .debug_frame and the object has .eh_frame, I think we should still dump it; and vice versa.

[JDevlieghere]

include/llvm/DebugInfo/DIContext.h

160

This doesn't change the behavior though? Both the (explicit) DumpType argument and the member in DIDumpOptions are always set to the same value.

[aprantl]

In D37852#871076, @probinson wrote:

My impression is that .eh_frame and .debug_frame are interchangeable and in fact you get only one or the other in any given compilation. So, if you ask for .debug_frame and the object has .eh_frame, I think we should still dump it; and vice versa.

I think we can apply the same rules as for .dwo sections here. If DumpDebugFrame is requested we dump .debug_frame and .eh_frame, whichever exists.
For compatibility with Darwin dwarfdump we can add a --eh-frame option that is an alias to --debug-frame.

[JDevlieghere]

Thanks! I've updated the diff and description to make .eh_frame an alias for .debug_frame.

[aprantl]

include/llvm/DebugInfo/DIContext.h

160

Oh sorry, I overlooked that DumpType is a member of DumpOpts!

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

64

You could just declare it as alias(DumpDebuFrame) instead.

tools/llvm-objdump/llvm-objdump.cpp

195

I think I would feel more comfortable if we would leave the llvm-objdump options untouched.

[JDevlieghere]

Feedback Adrian.

include/llvm/BinaryFormat/Dwarf.def

 // TODO: Add Mach-O and COFF names.
 // Official DWARF sections.
 HANDLE_DWARF_SECTION(DebugAbbrev, ".debug_abbrev", "debug-abbrev")
 HANDLE_DWARF_SECTION(DebugAranges, ".debug_aranges", "debug-aranges")
 HANDLE_DWARF_SECTION(DebugInfo, ".debug_info", "debug-info")
 HANDLE_DWARF_SECTION(DebugTypes, ".debug_types", "debug-types")
 HANDLE_DWARF_SECTION(DebugLine, ".debug_line", "debug-line")
 HANDLE_DWARF_SECTION(DebugLoc, ".debug_loc", "debug-loc")
-HANDLE_DWARF_SECTION(DebugFrames, ".debug_frames", "debug-frames")
+HANDLE_DWARF_SECTION(DebugFrame, ".debug_frame", "debug-frame")
 HANDLE_DWARF_SECTION(DebugMacro, ".debug_macro", "debug-macro")
 HANDLE_DWARF_SECTION(DebugRanges, ".debug_ranges", "debug-ranges")
 HANDLE_DWARF_SECTION(DebugPubnames, ".debug_pubnames", "debug-pubnames")
 HANDLE_DWARF_SECTION(DebugPubtypes, ".debug_pubtypes", "debug-pubtypes")
 HANDLE_DWARF_SECTION(DebugGnuPubnames, ".debug_gnu_pubnames", "debug-gnu-pubnames")
 HANDLE_DWARF_SECTION(DebugGnuPubtypes, ".debug_gnu_pubtypes", "debug-gnu-pubtypes")
 HANDLE_DWARF_SECTION(DebugStr, ".debug_str", "debug-str")
 HANDLE_DWARF_SECTION(DebugStrOffsets, ".debug_str_offsets", "debug-str-offsets")

include/llvm/DebugInfo/DIContext.h

 #undef HANDLE_DWARF_SECTION
   DIDT_UUID = 1 << (DIDT_ID_UUID - 1),
 };
 
 /// Container for dump options that control which debug information will be
 /// dumped.
 struct DIDumpOptions {
     unsigned DumpType = DIDT_All;
-    bool DumpEH = false;
     bool SummarizeTypes = false;
     bool Verbose = false;
 };
 
 class DIContext {
 public:
   enum DIContextKind {
     CK_DWARF,
     CK_PDB
   };
 
   DIContext(DIContextKind K) : Kind(K) {}
   virtual ~DIContext() = default;
 
   DIContextKind getKind() const { return Kind; }
 
   virtual void dump(raw_ostream &OS, DIDumpOptions DumpOpts) = 0;
 
-  virtual bool verify(raw_ostream &OS, unsigned DumpType = DIDT_All,
-                      DIDumpOptions DumpOpts = {}) {
+  virtual bool verify(raw_ostream &OS, DIDumpOptions DumpOpts = {}) {
     // No verifier? Just say things went well.
     return true;
   }
 
   virtual DILineInfo getLineInfoForAddress(uint64_t Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;
   virtual DILineInfoTable getLineInfoForAddressRange(uint64_t Address,
       uint64_t Size, DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;

include/llvm/DebugInfo/DWARF/DWARFContext.h

public:
   const DWARFObject &getDWARFObj() const { return *DObj; }
 
   static bool classof(const DIContext *DICtx) {
     return DICtx->getKind() == CK_DWARF;
   }
 
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts) override;
 
-  bool verify(raw_ostream &OS, unsigned DumpType = DIDT_All,
-              DIDumpOptions DumpOpts = {}) override;
+  bool verify(raw_ostream &OS, DIDumpOptions DumpOpts = {}) override;
 
   using cu_iterator_range = DWARFUnitSection<DWARFCompileUnit>::iterator_range;
   using tu_iterator_range = DWARFUnitSection<DWARFTypeUnit>::iterator_range;
   using tu_section_iterator_range = iterator_range<decltype(TUs)::iterator>;
 
   /// Get compile units in this context.
   cu_iterator_range compile_units() {
     parseCompileUnits();

lib/DebugInfo/DWARF/DWARFContext.cpp

while (offset < size) {
         OS << format("\"%s\"", S);
       OS << "\n";
     }
   }
 }
 
 void DWARFContext::dump(raw_ostream &OS, DIDumpOptions DumpOpts) {
   uint64_t DumpType = DumpOpts.DumpType;
-  bool DumpEH = DumpOpts.DumpEH;
 
   StringRef Extension = sys::path::extension(DObj->getFileName());
   bool IsDWO = (Extension == ".dwo") || (Extension == ".dwp");
 
   // Print UUID header.
   const auto *ObjFile = DObj->getFile();
   if (!(DumpType & DIDT_UUID) || DumpType == DIDT_All)
     outs() << ObjFile->getFileName() << ":\tfile format "
if (shouldDump(DIDT_DebugLoc, DObj->getLocSection().Data)) {
     OS << "\n.debug_loc contents:\n";
     getDebugLoc()->dump(OS, getRegisterInfo());
   }
   if (shouldDumpDWO(DIDT_DebugLoc, DObj->getLocDWOSection().Data)) {
     OS << "\n.debug_loc.dwo contents:\n";
     getDebugLocDWO()->dump(OS, getRegisterInfo());
   }
 
-  if (shouldDump(DIDT_DebugFrames, DObj->getDebugFrameSection())) {
+  if (shouldDump(DIDT_DebugFrame, DObj->getDebugFrameSection())) {
     OS << "\n.debug_frame contents:\n";
     getDebugFrame()->dump(OS);
   }
-  if (DumpEH && !getEHFrame()->empty()) {
+
+  if (shouldDump(DIDT_DebugFrame, DObj->getEHFrameSection())) {
     OS << "\n.eh_frame contents:\n";
     getEHFrame()->dump(OS);
   }
 
   if (DumpType & DIDT_DebugMacro) {
     if (Explicit || !getDebugMacro()->empty()) {
       OS << "\n.debug_macinfo contents:\n";
       getDebugMacro()->dump(OS);

 
 DWARFDie DWARFContext::getDIEForOffset(uint32_t Offset) {
   parseCompileUnits();
   if (auto *CU = CUs.getUnitForOffset(Offset))
     return CU->getDIEForOffset(Offset);
   return DWARFDie();
 }
 
-bool DWARFContext::verify(raw_ostream &OS, unsigned DumpType,
-                          DIDumpOptions DumpOpts) {
+bool DWARFContext::verify(raw_ostream &OS, DIDumpOptions DumpOpts) {
   bool Success = true;
   DWARFVerifier verifier(OS, *this, DumpOpts);
 
   Success &= verifier.handleDebugAbbrev();
-  if (DumpType & DIDT_DebugInfo)
+  if (DumpOpts.DumpType & DIDT_DebugInfo)
     Success &= verifier.handleDebugInfo();
-  if (DumpType & DIDT_DebugLine)
+  if (DumpOpts.DumpType & DIDT_DebugLine)
     Success &= verifier.handleDebugLine();
   Success &= verifier.handleAccelTables();
   return Success;
 }
 
 const DWARFUnitIndex &DWARFContext::getCUIndex() {
   if (CUIndex)
     return *CUIndex;

lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

if (Primary) {
           // Operands: ULEB128, SLEB128
           // Note: see comment for the previous case
           auto op1 = Data.getULEB128(Offset);
           auto op2 = (uint64_t)Data.getSLEB128(Offset);
           addInstruction(Opcode, op1, op2);
           break;
         }
         case DW_CFA_def_cfa_expression:
+          // FIXME: Parse the actual instruction.
+          *Offset += Data.getULEB128(Offset);
+          break;
         case DW_CFA_expression:
-        case DW_CFA_val_expression:
-          // TODO: implement this
-          report_fatal_error("Values with expressions not implemented yet!");
+        case DW_CFA_val_expression: {
+          // FIXME: Parse the actual instruction.
+          Data.getULEB128(Offset);
+          *Offset += Data.getULEB128(Offset);
+          break;
+        }
       }
     }
   }
 }
 
 namespace {
 
 /// \brief DWARF Common Information Entry (CIE)

test/Assembler/return-column.s

 // RUN: llvm-mc -triple i686-unknown-linux-gnu -filetype asm -o - %s | FileCheck %s -check-prefix CHECK-ASM-ROUNDTRIP
-// RUN: llvm-mc -triple i686-unknown-linux-gnu -filetype obj -o - %s | llvm-objdump -dwarf=frames - | FileCheck %s -check-prefix CHECK-EH_FRAME
+// RUN: llvm-mc -triple i686-unknown-linux-gnu -filetype obj -o - %s | llvm-objdump -dwarf=eh - | FileCheck %s -check-prefix CHECK-EH_FRAME
 // REQUIRES: x86-registered-target
 
   .text
 
   .section .text.f,"ax",@progbits
   .global f
   .type f,@function
 f:

 
 // CHECK-EH_FRAME: 00000000 00000014 ffffffff CIE
 // CHECK-EH_FRAME:   Return address column: 0
 
 // CHECK-EH_FRAME: 0000002c 00000014 ffffffff CIE
 // CHECK-EH_FRAME:   Return address column: 65
 
 // CHECK-EH_FRAME-NOT: ........ 00000014 ffffffff CIE
-

test/DebugInfo/dwarfdump-debug-frame-simple.test

-; RUN: llvm-dwarfdump %p/Inputs/dwarfdump-test-32bit.elf.o --debug-frames | FileCheck %s -check-prefix FRAMES
+; RUN: llvm-dwarfdump %p/Inputs/dwarfdump-test-32bit.elf.o --debug-frame | FileCheck %s -check-prefix FRAMES
 ; Note: the input file was generated from Inputs/dwarfdump-test-32bit.elf.c
 
 ; FRAMES: .debug_frame
 ; FRAMES-NOT: .eh_frame
 
 ; FRAMES: 00000000 00000010 ffffffff CIE
 ; FRAMES: Version: 1
 ; FRAMES:      DW_CFA_def_cfa: reg4 +4

 ; FRAMES:      DW_CFA_advance_loc: 1
 ; FRAMES-NEXT: DW_CFA_def_cfa_offset: +8
 ; FRAMES-NEXT: DW_CFA_offset: reg5 -8
 ; FRAMES-NEXT: DW_CFA_advance_loc: 2
 ; FRAMES-NEXT: DW_CFA_def_cfa_register: reg5
 
 ; FRAMES-NOT: CIE
 ; FRAMES-NOT: FDE
-

test/MC/X86/i386-darwin-frame-register.ll

-; RUN: llc -filetype=obj %s -o - | llvm-dwarfdump -debug-frames - | FileCheck %s
+; RUN: llc -filetype=obj %s -o - | llvm-dwarfdump -debug-frame - | FileCheck %s
 
 ; IR reduced from a dummy:
 ; void foo() {}
 
 ; x86 Darwin uses different register mappings for eh_frame and debug_frame
 ; sections. Check that the right mapping is used in debug_frame.
 ; In the debug_frame mapping, regsiter 4 is ESP, thus the below tests that
 ; the CFA is ESP+4 upon function entry.

test/tools/dsymutil/X86/frame-1.test

 # REQUIRES: object-emission
 # RUN: rm -rf %t
 # RUN: mkdir -p %t
 # RUN: llc -filetype=obj %p/../Inputs/frame-dw2.ll -o %t/frame-dw2.o
-# RUN: llvm-dsymutil -f -oso-prepend-path=%t -y %s -o - | llvm-dwarfdump -debug-frames - | FileCheck %s
+# RUN: llvm-dsymutil -f -oso-prepend-path=%t -y %s -o - | llvm-dwarfdump -debug-frame - | FileCheck %s
 
 # This test is meant to verify that identical CIEs will get reused
 # in the same file but also inbetween files. For this to happen, we
 # link twice the same file using this made-up debug map:
 
 ---
 triple:          'i386-apple-darwin'
 objects:

 # CHECK: 00000000 {{[0-9a-f]*}} ffffffff CIE
 # CHECK-NOT: FDE
 # CHECK:  FDE cie=00000000 pc=00001000...00001
 # CHECK-NOT: FDE
 # CHECK:  FDE cie=00000000 pc=00002000...00002
 # CHECK-NOT: FDE
 # CHECK:  FDE cie=00000000 pc=00003000...00003
 # CHECK-NOT: FDE
-

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

 # REQUIRES: object-emission
 # RUN: rm -rf %t
 # RUN: mkdir -p %t
 # RUN: llc -filetype=obj %p/../Inputs/frame-dw2.ll -o %t/frame-dw2.o
 # RUN: llc -filetype=obj %p/../Inputs/frame-dw4.ll -o %t/frame-dw4.o
-# RUN: llvm-dsymutil -f -oso-prepend-path=%t -y %s -o - | llvm-dwarfdump -debug-frames - | FileCheck %s
+# RUN: llvm-dsymutil -f -oso-prepend-path=%t -y %s -o - | llvm-dwarfdump -debug-frame - | FileCheck %s
 
 # Check the handling of multiple different CIEs. To have CIEs that
 # appear to be different, use a dwarf2 version of the file along with
 # a dwarf 4 version. The CIE header version (and layout) will be different.
 # FIXME: this test also checks that we didn't reuse the first CIE when it
 # appears again. This is a behavior we inherited from dsymutil-classic
 # but this should be fixed (see comment in patchFrameInfoForObject())
 ---

 # 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: Version:{{.*}}1
 # CHECK-NOT: FDE
 # CHECK:  FDE cie=[[CIEDW2]] pc=00004000...00004
 # CHECK-NOT: FDE
-

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

-# RUN: llvm-objdump -dwarf=frames %p/Inputs/eh_frame.macho-arm64 2>/dev/null | FileCheck %s
+# RUN: llvm-objdump -dwarf=eh %p/Inputs/eh_frame.macho-arm64 2>/dev/null | FileCheck %s
 
 # CHECK: .eh_frame contents:
 
 # CHECK: 00000000 00000010 ffffffff CIE
 # CHECK:   Version:               1
 # CHECK:   Augmentation:          "zR"
 # CHECK:   Code alignment factor: 1
 # CHECK:   Data alignment factor: -8

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

-# RUN: llvm-objdump -dwarf=frames %p/Inputs/eh_frame.elf-mipsel | FileCheck %s
+# RUN: llvm-objdump -dwarf=eh %p/Inputs/eh_frame.elf-mipsel | FileCheck %s
 
 # CHECK: .eh_frame contents:
 
 # CHECK: 00000000 00000018 ffffffff CIE
 # CHECK:   Version:               1
 # CHECK:   Augmentation:          "zPLR"
 # CHECK:   Code alignment factor: 1
 # CHECK:   Data alignment factor: -4

test/tools/llvm-objdump/eh_frame_zero_cie.test

-# RUN: llvm-objdump -dwarf=frames %p/Inputs/eh_frame_zero_cie.o 2>/dev/null | FileCheck %s
+# RUN: llvm-objdump -dwarf=eh %p/Inputs/eh_frame_zero_cie.o 2>/dev/null | FileCheck %s
 
 # CHECK: .eh_frame contents:
 
 # CHECK: 00000000 00000000 ffffffff CIE
 # CHECK:   Version:               0
 # CHECK:   Augmentation:          ""
 # CHECK:   Code alignment factor: 0
 # CHECK:   Data alignment factor: 0
 # CHECK:   Return address column: 0

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

 
 static unsigned DumpType = DIDT_Null;
 #define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME)                \
   static opt<bool> Dump##ENUM_NAME(CMDLINE_NAME,                               \
                                    desc("Dump the " ELF_NAME " section"),      \
                                    cat(SectionCategory));
 #include "llvm/BinaryFormat/Dwarf.def"
 #undef HANDLE_DWARF_SECTION
+static opt<bool> DumpEHFrame("eh-frame", desc("Dump the .eh_frame section"),
+                             cat(SectionCategory));
 static opt<bool> DumpUUID("uuid", desc("Show the UUID for each architecture"),
                           cat(DwarfDumpCategory));
 static alias DumpUUIDAlias("u", desc("Alias for -uuid"), aliasopt(DumpUUID));
 
 static opt<bool>
     SummarizeTypes("summarize-types",
                    desc("Abbreviate the description of type unit entries"));
 static opt<bool> Verify("verify", desc("Verify the DWARF debug info"),

 static bool verifyObjectFile(ObjectFile &Obj, Twine Filename) {
   std::unique_ptr<DIContext> DICtx = DWARFContext::create(Obj);
 
   // Verify the DWARF and exit with non-zero exit status if verification
   // fails.
   raw_ostream &stream = Quiet ? nulls() : outs();
   stream << "Verifying " << Filename.str() << ":\tfile format "
   << Obj.getFileFormatName() << "\n";
-  bool Result = DICtx->verify(stream, DumpType, getDumpOpts());
+  bool Result = DICtx->verify(stream, getDumpOpts());
   if (Result)
     stream << "No errors.\n";
   else
     stream << "Errors detected.\n";
   return Result;
 }
 
 static bool handleBuffer(StringRef Filename, MemoryBufferRef Buffer,
int main(int argc, char **argv) {
 
   // Defaults to dumping all sections, unless brief mode is specified in which
   // case only the .debug_info section in dumped.
 #define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME)                \
   if (Dump##ENUM_NAME)                                                         \
     DumpType |= DIDT_##ENUM_NAME;
 #include "llvm/BinaryFormat/Dwarf.def"
 #undef HANDLE_DWARF_SECTION
+  if (DumpEHFrame)
+    DumpType |= DIDT_DebugFrame;
   if (DumpUUID)
     DumpType |= DIDT_UUID;
   if (DumpAll)
     DumpType = DIDT_All;
   if (DumpType == DIDT_Null) {
     if (Verbose)
       DumpType = DIDT_All;
     else

tools/llvm-objdump/MachODump.cpp

static void ProcessMachO(StringRef Name, MachOObjectFile *MachOOF,
   if (WeakBind)
     printWeakBindTable(MachOOF);
 
   if (DwarfDumpType != DIDT_Null) {
     std::unique_ptr<DIContext> DICtx = DWARFContext::create(*MachOOF);
     // Dump the complete DWARF structure.
     DIDumpOptions DumpOpts;
     DumpOpts.DumpType = DwarfDumpType;
-    DumpOpts.DumpEH = true;
     DICtx->dump(outs(), DumpOpts);
   }
 }
 
 // printUnknownCPUType() helps print_fat_headers for unknown CPU's.
 static void printUnknownCPUType(uint32_t cputype, uint32_t cpusubtype) {
   outs() << "    cputype (" << cputype << ")\n";
   outs() << "    cpusubtype (" << cpusubtype << ")\n";
for (xf = xar_file_first(xar, xi); xf; xf = xar_file_next(xi)) {
     type = nullptr;
     mode = nullptr;
     user = nullptr;
     group = nullptr;
     size = nullptr;
     mtime = nullptr;
     name = nullptr;
     for(key = xar_prop_first(xf, xp); key; key = xar_prop_next(xp)){
-      const char *val = nullptr; 
+      const char *val = nullptr;
       xar_prop_get(xf, key, &val);
 #if 0 // Useful for debugging.
       outs() << "key: " << key << " value: " << val << "\n";
 #endif
       if(strcmp(key, "type") == 0)
         type = val;
       if(strcmp(key, "mode") == 0)
         mode = val;
if(!xp){
              << XarFilename.c_str() << "\n";
       xar_close(xar);
       return;
     }
     member_name = NULL;
     member_type = NULL;
     member_size_string = NULL;
     for(key = xar_prop_first(xf, xp); key; key = xar_prop_next(xp)){
-      const char *val = nullptr; 
+      const char *val = nullptr;
       xar_prop_get(xf, key, &val);
 #if 0 // Useful for debugging.
       outs() << "key: " << key << " value: " << val << "\n";
 #endif
       if (strcmp(key, "name") == 0)
         member_name = val;
       if (strcmp(key, "type") == 0)
         member_type = val;

tools/llvm-objdump/llvm-objdump.cpp

cl::opt<bool>
     llvm::PrintImmHex("print-imm-hex",
                       cl::desc("Use hex format for immediate values"));
 
 cl::opt<bool> PrintFaultMaps("fault-map-section",
                              cl::desc("Display contents of faultmap section"));
 
 cl::opt<DIDumpType> llvm::DwarfDumpType(
     "dwarf", cl::init(DIDT_Null), cl::desc("Dump of dwarf debug sections:"),
-    cl::values(clEnumValN(DIDT_DebugFrames, "frames", ".debug_frame")));
+    cl::values(clEnumValN(DIDT_DebugFrame, "frame", ".debug_frame"),
+               clEnumValN(DIDT_DebugFrame, "eh", ".eh_frame")));
 
 cl::opt<bool> PrintSource(
     "source",
     cl::desc(
         "Display source inlined with disassembly. Implies disassmble object"));
 
 cl::alias PrintSourceShort("S", cl::desc("Alias for -source"),
                            cl::aliasopt(PrintSource));
if (RawClangAST)
     printRawClangAST(o);
   if (PrintFaultMaps)
     printFaultMaps(o);
   if (DwarfDumpType != DIDT_Null) {
     std::unique_ptr<DIContext> DICtx = DWARFContext::create(*o);
     // Dump the complete DWARF structure.
     DIDumpOptions DumpOpts;
     DumpOpts.DumpType = DwarfDumpType;
-    DumpOpts.DumpEH = true;
     DICtx->dump(outs(), DumpOpts);
   }
 }
 
 static void DumpObject(const COFFImportFile *I, const Archive *A) {
   StringRef ArchiveName = A ? A->getFileName() : "";
 
   // Avoid other output when using a raw option.

unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

TEST(DWARFDebugInfo, TestImplicitConstAbbrevs) {
   for (auto it = Val1Range.first; it != Val1Range.second; ++it)
     EXPECT_EQ(it->second, AbbrevPtrVal1);
   EXPECT_EQ(DIEs.find(Val2)->second, AbbrevPtrVal2);
 }
 
 void VerifyWarning(DWARFContext &DwarfContext, StringRef Error) {
   SmallString<1024> Str;
   raw_svector_ostream Strm(Str);
-  EXPECT_TRUE(DwarfContext.verify(Strm, DIDT_All));
+  EXPECT_TRUE(DwarfContext.verify(Strm));
   EXPECT_TRUE(Str.str().contains(Error));
 }
 
 void VerifyError(DWARFContext &DwarfContext, StringRef Error) {
   SmallString<1024> Str;
   raw_svector_ostream Strm(Str);
-  EXPECT_FALSE(DwarfContext.verify(Strm, DIDT_All));
+  EXPECT_FALSE(DwarfContext.verify(Strm));
   EXPECT_TRUE(Str.str().contains(Error));
 }
 
 TEST(DWARFDebugInfo, TestDwarfVerifyInvalidCURef) {
   // Create a single compile unit with a single function that has a DW_AT_type
   // that is CU relative. The CU offset is not valid becuase it is larger than
   // the compile unit itself.