[dwarfdump] Add verbose output for .debug-line section

[JDevlieghere]

Summary

This patch adds dumping of line table instructions as well as the final
state at each specified pc value in verbose mode. This is essentially
the same as the default in Darwin's dwarfdump. Dumping the actual line
table opcodes can be particularly useful for something like debugging a
bad .debug_line section.

[aprantl]

Doing this during parsing doesn't seem too intrusive and looks like it is the right trade-off.
Do you have a test case, too?

[JDevlieghere]

In D37971#873777, @aprantl wrote:

Doing this during parsing doesn't seem too intrusive and looks like it is the right trade-off.
Do you have a test case, too?

Jup, I put up the code before/while fixing the tests. I've added a verbose.test to check the printing of the opcodes. The existing tests that use verbose mode essentially verify that the resulting rows are still identical. As a verification I also ran a diff against Darwin's dwarfdump and the printed opcodes are identical.

[dblaikie]

lib/DebugInfo/DWARF/DWARFDebugLine.cpp

445 ↗

(On Diff #115662)

If we don't have one already, should probably have a DW_LNE enum stringification function generated from Dwarf.def - and use that to print the DW_LNE_* first, outside the switch, then use the switch to dump the specific parameters, if any, etc.

462 ↗

(On Diff #115662)

There's some inconsistency in whitespace (some of the printing "DW_LNE_foo (" and some without the space) - pick one for consistency.

test/DebugInfo/MIR/X86/empty-inline.mir

14–16 ↗

(On Diff #115662)

Perhaps it's worth un-verbosifying test cases when they need to be touched manually like this anyway?

[aprantl]

Added a couple more inline comments.

Since you aren't checking for the verbose details in many of the modified tests, perhaps it would be better to replace the RUN command with a --debug-line (non-verbose) invocation?
This is not super important, so feel free to decide what to do on a case-by-case basis.

lib/DebugInfo/DWARF/DWARFContext.cpp

341

Add: // Verbose dumping is done during parsing and not on the intermediate representation.

lib/DebugInfo/DWARF/DWARFDebugLine.cpp

445 ↗

(On Diff #115662)

To avoid typos and make the binary smaller, I'd prefer:
dwarf::LNExtendedString(DW_LNE_end_sequence)
here and below...

[aprantl]

Looks like I just typed up everything that David said :-)

[JDevlieghere]

Thanks Dave, I've updated the diff with your feedback.

test/DebugInfo/MIR/X86/empty-inline.mir

14–16 ↗

(On Diff #115662)

That's how I got started before switching to this approach. I wasn't confident enough about the content of the verbose output not being part of the test. I definitely don't want to reduce the test quality for this kind of change. If there are tests that stick out where it would obviously not matter, I'd be more than happy to change it!

[dblaikie]

lib/DebugInfo/DWARF/DWARFDebugLine.cpp

444–445 ↗

(On Diff #115666)

Could this go outside the switch? So it's written once rather than in every case in the switch? Or are there some cases that need to avoid it or otherwise do something different? (& if possible, the newline printing could also go after the switch to avoid that being repeated in every case)

test/DebugInfo/MIR/X86/empty-inline.mir

14–16 ↗

(On Diff #115662)

Seems like the opposite, though - by removing the CHECK-NEXTs you've reduced the quality of the test by allowing other line entries to be present, etc, potentially.

So it's probably better here, for instance, to unverbosify the test to keep it closer to the original intent. (possibly similarly on other tests)

[JDevlieghere]

• Moved printing outside switch.
• Un-verbosed test cases.

[JDevlieghere]

test/DebugInfo/MIR/X86/empty-inline.mir

14–16 ↗

(On Diff #115662)

Fair enough, I agree that this is probably better. Thanks!

[aprantl]

Did you accidentally upload the wrong patch?

[JDevlieghere]

• Upload the correct patch (Thanks Adrian!)

[dblaikie]

test/DebugInfo/MIR/X86/empty-inline.mir

7 ↗

(On Diff #115847)

I don't think the {{.*}} is needed? Maybe - not sure how whitespace-ignorant FileCheck is by default.

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

55–58 ↗

(On Diff #115847)

Why did these line numbers change?

[JDevlieghere]

test/DebugInfo/MIR/X86/empty-inline.mir

7 ↗

(On Diff #115847)

AFAIK only leading and trailing whitespace is ignored. An additional benefit is that most of the lines won't have to be changed if we ever want to make the test verbose again.

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

55–58 ↗

(On Diff #115847)

That's because added the 3 run lines at the top of the file, before the code.

[probinson]

test/DebugInfo/MIR/X86/empty-inline.mir

7 ↗

(On Diff #115847)

I am pretty sure that FileCheck treats all whitespace as variable length, unless you tell it to be strict.

[JDevlieghere]

• Remove regex for whitespace

[JDevlieghere]

test/DebugInfo/MIR/X86/empty-inline.mir

7 ↗

(On Diff #115847)

Seems like you were both right! I've updated the tests.

[dblaikie]

Seems good

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,
 };
 
 /// Container for dump options that control which debug information will be
 /// dumped.
 struct DIDumpOptions {
   unsigned DumpType = DIDT_All;
-  bool DumpEH = false;
   bool ShowChildren = 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:
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts,
             std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets);
 
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts) override {
     std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets;
     dump(OS, DumpOpts, DumpOffsets);
   }
 
-  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

 }
 
 void DWARFContext::dump(
     raw_ostream &OS, DIDumpOptions DumpOpts,
     std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets) {
 
   Optional<uint64_t> DumpOffset;
   uint64_t DumpType = DumpOpts.DumpType;
-  bool DumpEH = DumpOpts.DumpEH;
   unsigned RecDepth =
       DumpOpts.ShowChildren ? std::numeric_limits<unsigned>::max() : 0;
 
   StringRef Extension = sys::path::extension(DObj->getFileName());
   bool IsDWO = (Extension == ".dwo") || (Extension == ".dwp");
 
   // Print UUID header.
   const auto *ObjFile = DObj->getFile();
if (shouldDump(Explicit, ".debug_loc", DIDT_ID_DebugLoc,
                  DObj->getLocSection().Data)) {
     getDebugLoc()->dump(OS, getRegisterInfo());
   }
   if (shouldDump(ExplicitDWO, ".debug_loc.dwo", DIDT_ID_DebugLoc,
                  DObj->getLocDWOSection().Data)) {
     getDebugLocDWO()->dump(OS, getRegisterInfo());
   }
 
-  if (shouldDump(Explicit, ".debug_frame", DIDT_ID_DebugFrames,
+  if (shouldDump(Explicit, ".debug_frame", DIDT_ID_DebugFrame,
                  DObj->getDebugFrameSection())) {
     getDebugFrame()->dump(OS);
   }
-  if (DumpEH && !getEHFrame()->empty()) {
-    OS << "\n.eh_frame contents:\n";
+
+  if (shouldDump(Explicit, ".eh_frame", DIDT_ID_DebugFrame,
+                 DObj->getEHFrameSection())) {
     getEHFrame()->dump(OS);
   }
 
   if (DumpType & DIDT_DebugMacro) {
     if (Explicit || !getDebugMacro()->empty()) {
       OS << "\n.debug_macinfo contents:\n";
       getDebugMacro()->dump(OS);
     }
for (const auto &CU : compile_units()) {
       if (!CUDIE)
         continue;
       if (auto StmtOffset = toSectionOffset(CUDIE.find(DW_AT_stmt_list))) {
         DWARFDataExtractor lineData(*DObj, DObj->getLineSection(),
                                     isLittleEndian(), savedAddressByteSize);
         DWARFDebugLine::LineTable LineTable;
         uint32_t Offset = *StmtOffset;
         LineTable.parse(lineData, &Offset);
         LineTable.dump(OS);
       }
     }
   }
 
   // FIXME: This seems sketchy.
   for (const auto &CU : compile_units()) {
     savedAddressByteSize = CU->getAddressByteSize();
     break;

 
 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/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-NEXT: DW_CFA_offset: reg8 -4
 ; FRAMES-NEXT: DW_CFA_nop:
 ; FRAMES-NEXT: DW_CFA_nop:
 
 ; FRAMES: 00000014 00000010 00000000 FDE cie=00000000 pc=00000000...00000022
 ; FRAMES:      DW_CFA_advance_loc: 3
 ; FRAMES-NEXT: DW_CFA_def_cfa_offset: +12
 ; FRAMES-NEXT: DW_CFA_nop:
 
 ; FRAMES: 00000028 00000014 00000000 FDE cie=00000000 pc=00000030...00000080
 ; 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
-
+; FRAMES: .eh_frame

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
-
+# CHECK: .eh_frame contents:

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
-
+# CHECK: .eh_frame contents:

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

 static std::array<llvm::Optional<uint64_t>, (unsigned)DIDT_ID_Count> DumpOffsets;
 #define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME)                \
   static opt<OffsetOption> Dump##ENUM_NAME(                                    \
       CMDLINE_NAME, desc("Dump the " ELF_NAME " section"),                     \
       cat(SectionCategory));
 #include "llvm/BinaryFormat/Dwarf.def"
 #undef HANDLE_DWARF_SECTION
 
+static alias DumpDebugFrameAlias("eh-frame", desc("Alias for -debug-frame"),
+                                 aliasopt(DumpDebugFrame));
 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>
     ShowChildren("show-children",
                  desc("Show a debug info entry's children when selectively "
                       "printing with the =<Offset> option"));

 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,

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, "frames", ".debug_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));
 }
 
 void VerifySuccess(DWARFContext &DwarfContext) {
   SmallString<1024> Str;
   raw_svector_ostream Strm(Str);
-  EXPECT_TRUE(DwarfContext.verify(Strm, DIDT_All));
+  EXPECT_TRUE(DwarfContext.verify(Strm));
 }
 
 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 because it is larger than
   // the compile unit itself.
 
   const char *yamldata = R"(