llvm-dwarfdump: automatically dump both regular and .dwo variant of sections

[aprantl]

Summary

Since users typically don't really care about the .dwo / non.dwo distinction, this patch makes it so dwarfdump --debug-<info,...> dumps .debug_info and (if available) also .debug_info.dwo. This simplifies the command line interface (I've removed all dwo-specific dump options) and makes the tool friendlier to use.

[dblaikie]

Some thoughts/suggestions

lib/DebugInfo/DWARF/DWARFContext.cpp

426–429

Should this condition be sunk into dumpStringOffsetsSection?

test/DebugInfo/X86/fission-no-inlining.ll

5

Maybe "CHECK: contents:" So it's trivially obvious it's only checking for subprogram in the debug_info section?

test/DebugInfo/X86/generate-odr-hash.ll

77

Not following this change - it looks like it's checking for types in debug_types instead of debug_types.dwo?

130

Also probably "CHECK-NOT: contents:"

test/DebugInfo/X86/live-debug-variables.ll

30 ↗

(On Diff #114905)

Should we print the header if there's nothing in the section? I've know we do it for some sections and not for others - and kind of think maybe we shouldn't do it for any sections.

test/DebugInfo/X86/split-dwarf-multiple-cu-hash.ll

9

CHECK: contents:

test/DebugInfo/X86/split-dwarf-omit-empty.ll

21

CHECK: contents:

[aprantl]

Address review feedback.

lib/DebugInfo/DWARF/DWARFContext.cpp

426–429

No, it shouldn't be there at all to mirror all the other cases.

test/DebugInfo/X86/generate-odr-hash.ll

130

No, it looks like there's another section in between in some of the FileCheck runs using the same CHECK prefix.

test/DebugInfo/X86/live-debug-variables.ll

30 ↗

(On Diff #114905)

Currently we print the section header when the section was explicitly requested (either through --debug-loc or --all). We only print the .dwo section header when the non-dwo variant was requested and it is non-empty. My selfish thinking behind this decision was that we don't want the .dwo sections to show up at all on platforms that don't use DWOs.

[probinson]

lib/DebugInfo/DWARF/DWARFContext.cpp

256–257

IIUC dumping a .dwo file, we'll see:

.debug_abbrev contents:

.debug_abbrev.dwo contents:
<stuff>

etc for each section type, which seems a little weird.

[aprantl]

When dumping a .o file without a .debug_types section, should --debug-types

1. print nothing
2. print .debug_types:\nEOF

If the answer is (2), how should it behave on an empty .dwo file?

[probinson]

UI is tricky. I think I lean in the direction that if the section doesn't exist, don't print anything, even the "contents:" line.
This is certainly how I want --all to behave, and obviously it's easiest and self-consistent if that's how the tool always behaves. So for example --debug-types when there is no .debug_types section should print nothing.
I could see an argument that if I explicitly asked for a particular section and it doesn't exist, I should get the "contents:" line with nothing after it. But that's really not how I want --all to behave.

[aprantl]

Okay, I'll implement a "don't print anything if the section doesn't exist" approach, since that seems to align best with what everybody desires. Printing an empty "contents" only if the section was explicitly required is trickier to implement, so I'll leave this for a future improvement.

[probinson]

include/llvm/DebugInfo/DIContext.h

128

I am reminded that MSVC traditionally has not correctly handled enum values wider than 32 bits, so I'm happy to see this change and apologize for not noticing it in the original patch that added DIDumpType.
Or has MSVC learned to do 64-bit enum values? It used to just silently truncate to 32 bits.

[rnk]

include/llvm/DebugInfo/DIContext.h

128

Microsoft never implemented the rules about deducing the type of the enum from the enumerator values. It would be an ABI break in some ways if they did that today. You could argue that truncating enumerators that were too wide was already a bug, but that's the status.

Instead, they implemented strong enums as a way to let the user explicitly say "yeah, I really want a uint64_t", so this code should work fine.

[probinson]

include/llvm/DebugInfo/DIContext.h

128

Good to know, thanks!

[aprantl]

With this update:

1. llvm-dwarfdump --all prints only section headers (like .debug_info contents:) of non-empty sections.

2a. llvm-dwarfdump --<debug-info, ...> always prints a section header
2b. On platforms that support DWOs, llvm-dwarfdump --<debug-info ..> also always prints a section header for the corresponding .dwo section.

[aprantl]

Now comes with ROCK-SOLID .dwo detection!

[dblaikie]

lib/DebugInfo/DWARF/DWARFContext.cpp

243–245

Ah, so one extra wrinkle is that dwo sections can appear in non-dwo files...

For example when LLVM (& GCC) produce Fission output, they first output a single object file (with all the dwo and non-dwo, and text, etc) then use objcopy to extract the .dwo sections out into a separate file.

So not dumping DWO sections when present, even when not examining a .dwo file, is problematic. But they can silently not have headers (ie: if you ask to dump a types in a .o file, I don't think there's a need to print the types.dwo header if types.dwo is not present) - I think that's OK.

Does that make sense?

[aprantl]

use sys::path instead

[aprantl]

lib/DebugInfo/DWARF/DWARFContext.cpp

243–245

I think so. The behavior as implemented is:

When specifically requesting a section:

• in a .o file: empty .dwo section headers are skipped
• in a .dwo file: empty .dwo section headers are printed
• in both cases: nonempty .dwo sections are dumped.

I think this is what we want, right?

[probinson]

lib/DebugInfo/DWARF/DWARFContext.cpp

243

Hmmm now you are attaching a semantic significance to what is just a naming convention. I don't think that's appropriate.
We should not worry about what "kind" of file it is, just whether the sections exist or not.

[aprantl]

Clarify comment.

[aprantl]

lib/DebugInfo/DWARF/DWARFContext.cpp

243

Please note that this affects only whether we print *section headers for empty sections*.
The idea behind this condition is that we want to hide empty .dwo section headers when dumping a non-.dwo file. (With the one wrinkle that the intermediate products of clang that contain both .dwo and non-dwo sections are counted as non-dwo).

[aprantl]

Implement David's suggestion to skip empty non-dwo section headers in .dwo files.

[dblaikie]

Sounds good to me

[probinson]

lib/DebugInfo/DWARF/DWARFContext.cpp

243

Ok, I get that it's just a heuristic for deciding when to suppress headers for empty sections.
If you make it match .dwp as well as .dwo file extensions, I can live with that.

include/llvm/BinaryFormat/Dwarf.def

 // DWARF v5 Unit Types.
 HANDLE_DW_UT(0x01, compile)
 HANDLE_DW_UT(0x02, type)
 HANDLE_DW_UT(0x03, partial)
 HANDLE_DW_UT(0x04, skeleton)
 HANDLE_DW_UT(0x05, split_compile)
 HANDLE_DW_UT(0x06, split_type)
 
-// DWARF section types. (enum name, ELF name, cmdline name)
+// DWARF section types. (enum name, ELF name, ELF DWO name, cmdline name)
 // Note that these IDs don't mean anything.
 // TODO: Add Mach-O and COFF names.
 // Official DWARF sections.
 HANDLE_DWARF_SECTION(DebugAbbrev, ".debug_abbrev", "debug-abbrev")
-HANDLE_DWARF_SECTION(DebugAbbrevDwo, ".debug_abbrev.dwo", "debug-abbrev-dwo")
 HANDLE_DWARF_SECTION(DebugAranges, ".debug_aranges", "debug-aranges")
 HANDLE_DWARF_SECTION(DebugInfo, ".debug_info", "debug-info")
-HANDLE_DWARF_SECTION(DebugInfoDwo, ".debug_info.dwo", "debug-info-dwo")
 HANDLE_DWARF_SECTION(DebugTypes, ".debug_types", "debug-types")
-HANDLE_DWARF_SECTION(DebugTypesDwo, ".debug_types.dwo", "debug-types-dwo")
 HANDLE_DWARF_SECTION(DebugLine, ".debug_line", "debug-line")
-HANDLE_DWARF_SECTION(DebugLineDwo, ".debug_line.dwo", "debug-line-dwo")
 HANDLE_DWARF_SECTION(DebugLoc, ".debug_loc", "debug-loc")
-HANDLE_DWARF_SECTION(DebugLocDwo, ".debug_loc.dwo", "debug-loc-dwo")
 HANDLE_DWARF_SECTION(DebugFrames, ".debug_frames", "debug-frames")
 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")
-HANDLE_DWARF_SECTION(DebugStrDwo, ".debug_str.dwo", "debug-str-dwo")
-HANDLE_DWARF_SECTION(DebugStrOffsetsDwo, ".debug_str_offsets.dwo", "debug-str-offsets-dwo")
 HANDLE_DWARF_SECTION(DebugCUIndex, ".debug_cu_index", "debug-cu-index")
 HANDLE_DWARF_SECTION(DebugTUIndex, ".debug_tu_index", "debug-tu-index")
 // Vendor extensions.
 HANDLE_DWARF_SECTION(AppleNames, ".apple_names", "apple-names")
 HANDLE_DWARF_SECTION(AppleTypes, ".apple_types", "apple-types")
 HANDLE_DWARF_SECTION(AppleNamespaces, ".apple_namespaces", "apple-namespaces")
 HANDLE_DWARF_SECTION(AppleObjC, ".apple_objc", "apple-objc")
 HANDLE_DWARF_SECTION(GdbIndex, ".gdb_index", "gdb-index")

include/llvm/DebugInfo/DIContext.h

enum DIDumpTypeCounter {
   DIDT_ID_Null = 0,
 #define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME) \
   DIDT_ID_##ENUM_NAME,
 #include "llvm/BinaryFormat/Dwarf.def"
 #undef HANDLE_DWARF_SECTION
   DIDT_ID_UUID,
   DIDT_ID_Count
 };
-static_assert(DIDT_ID_Count <= 64, "section types overflow storage");
+static_assert(DIDT_ID_Count <= 32, "section types overflow storage");
 
 /// Selects which debug sections get dumped.
-enum DIDumpType : uint64_t {
+enum DIDumpType : unsigned {
   DIDT_Null,
-  DIDT_All             = ~0ULL,
+  DIDT_All             = ~0U,
 #define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME) \
-  DIDT_##ENUM_NAME = 1 << (DIDT_ID_##ENUM_NAME - 1),
+  DIDT_##ENUM_NAME = 1U << (DIDT_ID_##ENUM_NAME - 1),
 #include "llvm/BinaryFormat/Dwarf.def"
 #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 {
-    uint64_t DumpType = DIDT_All;
+    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, uint64_t DumpType = DIDT_All,
+  virtual bool verify(raw_ostream &OS, unsigned DumpType = DIDT_All,
                       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,

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, uint64_t DumpType = DIDT_All,
+  bool verify(raw_ostream &OS, unsigned DumpType = DIDT_All,
               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() {

include/llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h

 public:
   DWARFDebugAbbrev();
 
   const DWARFAbbreviationDeclarationSet *
   getAbbreviationDeclarationSet(uint64_t CUAbbrOffset) const;
 
   void dump(raw_ostream &OS) const;
   void extract(DataExtractor Data);
+  bool empty() const { return begin() == end(); }
 
   DWARFAbbreviationDeclarationSetMap::const_iterator begin() const {
     return AbbrDeclSets.begin();
   }
 
   DWARFAbbreviationDeclarationSetMap::const_iterator end() const {
     return AbbrDeclSets.end();
   }
 
 private:
   void clear();
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARFDEBUGABBREV_H

include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

public:
 
   /// \brief Dump the section data into the given stream.
   void dump(raw_ostream &OS) const;
 
   /// \brief Parse the section from raw data.
   /// data is assumed to be pointing to the beginning of the section.
   void parse(DataExtractor Data);
 
+  /// Return whether the section has any entries.
+  bool empty() const { return Entries.empty(); }
+
 private:
   std::vector<std::unique_ptr<FrameEntry>> Entries;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGFRAME_H

include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h

 
 public:
   /// Print the location lists found within the debug_loc section.
   void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo) const;
 
   /// Parse the debug_loc section accessible via the 'data' parameter using the
   /// address size also given in 'data' to interpret the address ranges.
   void parse(const DWARFDataExtractor &data);
   
   Optional<LocationList> parseOneLocationList(DWARFDataExtractor Data,
                                               uint32_t *Offset);
 };
 
 class DWARFDebugLocDWO {
 public:
   struct Entry {
     uint64_t Start;

include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h

 public:
   DWARFDebugMacro() = default;
 
   /// Print the macro list found within the debug_macinfo section.
   void dump(raw_ostream &OS) const;
 
   /// Parse the debug_macinfo section accessible via the 'data' parameter.
   void parse(DataExtractor data);
+
+  /// Return whether the section has any entries.
+  bool empty() const { return Macros.empty(); }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGMACRO_H

include/llvm/DebugInfo/DWARF/DWARFUnitIndex.h

 public:
   DWARFUnitIndex(DWARFSectionKind InfoColumnKind)
       : InfoColumnKind(InfoColumnKind) {}
 
   explicit operator bool() const { return Header.NumBuckets; }
 
   bool parse(DataExtractor IndexData);
   void dump(raw_ostream &OS) const;
+
   const Entry *getFromOffset(uint32_t Offset) const;
   const Entry *getFromHash(uint64_t Offset) const;
 
   ArrayRef<DWARFSectionKind> getColumnKinds() const {
     return makeArrayRef(ColumnKinds.get(), Header.NumColumns);
   }
 
   ArrayRef<Entry> getRows() const {
     return makeArrayRef(Rows.get(), Header.NumBuckets);
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFUNITINDEX_H

lib/DebugInfo/DWARF/DWARFContext.cpp

 #include "llvm/Object/MachO.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/RelocVisitor.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstdint>
 #include <map>
 #include <string>
 #include <tuple>
 #include <utility>
void DWARFContext::dump(raw_ostream &OS, DIDumpOptions DumpOpts) {
 
   const auto *ObjFile = DObj->getFile();
   if (!(DumpType & DIDT_UUID) || DumpType == DIDT_All)
     outs() << ObjFile->getFileName() << ":\tfile format "
            << ObjFile->getFileFormatName() << "\n\n";
   if (DumpType & DIDT_UUID)
     dumpUUID(OS, *ObjFile);
 
-  if (DumpType & DIDT_DebugAbbrev) {
-    OS << ".debug_abbrev contents:\n";
+  // Print a header for each explicitly-requested section.
+  // Otherwise just print one for non-empty sections.
+  bool Explicit = DumpType != DIDT_All;
+  auto shouldDump = [&](unsigned DIDT_Section, StringRef Section) {
+    return (DumpType & DIDT_Section) && (Explicit || !Section.empty());
+  };
+  // Only print empty .dwo section headers when dumping a .dwo file.
+  bool ExplicitDWO =
+      Explicit && sys::path::extension(DObj->getFileName()) == ".dwo";
+  auto shouldDumpDWO = [&](unsigned DIDT_Section, StringRef Section) {
+    return (DumpType & DIDT_Section) && (ExplicitDWO || !Section.empty());
+  };
+
+  if (shouldDump(DIDT_DebugAbbrev, DObj->getAbbrevSection())) {
+    OS << "\n.debug_abbrev contents:\n";
     getDebugAbbrev()->dump(OS);
   }
-
-  if (DumpType & DIDT_DebugAbbrevDwo)
-    if (const DWARFDebugAbbrev *D = getDebugAbbrevDWO()) {
-      OS << "\n.debug_abbrev.dwo contents:\n";
-      D->dump(OS);
-    }
+  if (shouldDumpDWO(DIDT_DebugAbbrev, DObj->getAbbrevDWOSection())) {
+    getDebugAbbrevDWO()->dump(OS);
 
-  if (DumpType & DIDT_DebugInfo) {
+  if (shouldDump(DIDT_DebugInfo, DObj->getInfoSection().Data)) {
     OS << "\n.debug_info contents:\n";
     for (const auto &CU : compile_units())
       CU->dump(OS, DumpOpts);
   }
-
-  if ((DumpType & DIDT_DebugInfoDwo) &&
-      getNumDWOCompileUnits()) {
+  if (shouldDumpDWO(DIDT_DebugInfo, DObj->getInfoDWOSection().Data)) {
     OS << "\n.debug_info.dwo contents:\n";
     for (const auto &DWOCU : dwo_compile_units())
       DWOCU->dump(OS, DumpOpts);
   }
 
-  if ((DumpType & DIDT_DebugTypes) && getNumTypeUnits()) {
+  if ((DumpType & DIDT_DebugTypes)) {
+    if (Explicit || getNumTypeUnits()) {
       OS << "\n.debug_types contents:\n";
       for (const auto &TUS : type_unit_sections())
         for (const auto &TU : TUS)
           TU->dump(OS, DumpOpts);
     }
-
-  if ((DumpType & DIDT_DebugTypesDwo) &&
-      getNumDWOTypeUnits()) {
+    if (ExplicitDWO || getNumDWOTypeUnits()) {
       OS << "\n.debug_types.dwo contents:\n";
       for (const auto &DWOTUS : dwo_type_unit_sections())
         for (const auto &DWOTU : DWOTUS)
           DWOTU->dump(OS, DumpOpts);
     }
+  }
 
-  if (DumpType & DIDT_DebugLoc) {
+  if (shouldDump(DIDT_DebugLoc, DObj->getLocSection().Data)) {
     OS << "\n.debug_loc contents:\n";
     getDebugLoc()->dump(OS, getRegisterInfo());
   }
-
-  if (DumpType & DIDT_DebugLocDwo) {
+  if (shouldDumpDWO(DIDT_DebugLoc, DObj->getLocDWOSection().Data)) {
     OS << "\n.debug_loc.dwo contents:\n";
     getDebugLocDWO()->dump(OS, getRegisterInfo());
   }
 
-  if (DumpType & DIDT_DebugFrames) {
+  if (shouldDump(DIDT_DebugFrames, DObj->getDebugFrameSection())) {
     OS << "\n.debug_frame contents:\n";
     getDebugFrame()->dump(OS);
-    if (DumpEH) {
-      OS << "\n.eh_frame contents:\n";
-      getEHFrame()->dump(OS);
-    }
-  }
+  }
+  if (DumpEH && !getEHFrame()->empty()) {
 
   if (DumpType & DIDT_DebugMacro) {
+    if (Explicit || !getDebugMacro()->empty()) {
       OS << "\n.debug_macinfo contents:\n";
       getDebugMacro()->dump(OS);
     }
+  }
 
-  uint32_t offset = 0;
-  if (DumpType & DIDT_DebugAranges) {
+  if (shouldDump(DIDT_DebugAranges, DObj->getARangeSection())) {
     OS << "\n.debug_aranges contents:\n";
+    uint32_t offset = 0;
     DataExtractor arangesData(DObj->getARangeSection(), isLittleEndian(), 0);
     DWARFDebugArangeSet set;
     while (set.extract(arangesData, &offset))
       set.dump(OS);
   }
 
   uint8_t savedAddressByteSize = 0;
-  if (DumpType & DIDT_DebugLine) {
+  if (shouldDump(DIDT_DebugLine, DObj->getLineSection().Data)) {
     OS << "\n.debug_line contents:\n";
     for (const auto &CU : compile_units()) {
       savedAddressByteSize = CU->getAddressByteSize();
       auto CUDIE = CU->getUnitDIE();
       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);
       }
     }
   }
 
-  if (DumpType & DIDT_DebugCUIndex) {
-    OS << "\n.debug_cu_index contents:\n";
-    getCUIndex().dump(OS);
-  }
-
-  if (DumpType & DIDT_DebugTUIndex) {
-    OS << "\n.debug_tu_index contents:\n";
-    getTUIndex().dump(OS);
+  // FIXME: This seems sketchy.
+  for (const auto &CU : compile_units()) {
+    savedAddressByteSize = CU->getAddressByteSize();
+    break;
   }
-
-  if (DumpType & DIDT_DebugLineDwo) {
+  if (shouldDumpDWO(DIDT_DebugLine, DObj->getLineDWOSection().Data)) {
     OS << "\n.debug_line.dwo contents:\n";
     unsigned stmtOffset = 0;
     DWARFDataExtractor lineData(*DObj, DObj->getLineDWOSection(),
                                 isLittleEndian(), savedAddressByteSize);
     DWARFDebugLine::LineTable LineTable;
     while (LineTable.Prologue.parse(lineData, &stmtOffset)) {
       LineTable.dump(OS);
       LineTable.clear();
     }
   }
 
-  if (DumpType & DIDT_DebugStr) {
+  if (shouldDump(DIDT_DebugCUIndex, DObj->getCUIndexSection())) {
+    OS << "\n.debug_cu_index contents:\n";
+    getCUIndex().dump(OS);
+  }
+
+  if (shouldDump(DIDT_DebugTUIndex, DObj->getTUIndexSection())) {
+    OS << "\n.debug_tu_index contents:\n";
+    getTUIndex().dump(OS);
+  }
+
+  if (shouldDump(DIDT_DebugStr, DObj->getStringSection())) {
     OS << "\n.debug_str contents:\n";
     DataExtractor strData(DObj->getStringSection(), isLittleEndian(), 0);
-    offset = 0;
+    uint32_t offset = 0;
     uint32_t strOffset = 0;
     while (const char *s = strData.getCStr(&offset)) {
       OS << format("0x%8.8x: \"%s\"\n", strOffset, s);
       strOffset = offset;
     }
   }
-
-  if ((DumpType & DIDT_DebugStrDwo) &&
-      !DObj->getStringDWOSection().empty()) {
+  if (shouldDumpDWO(DIDT_DebugStr, DObj->getStringDWOSection())) {
     OS << "\n.debug_str.dwo contents:\n";
     DataExtractor strDWOData(DObj->getStringDWOSection(), isLittleEndian(), 0);
-    offset = 0;
+    uint32_t offset = 0;
     uint32_t strDWOOffset = 0;
     while (const char *s = strDWOData.getCStr(&offset)) {
       OS << format("0x%8.8x: \"%s\"\n", strDWOOffset, s);
       strDWOOffset = offset;
     }
   }
 
-  if (DumpType & DIDT_DebugRanges) {
+  if (shouldDump(DIDT_DebugRanges, DObj->getRangeSection().Data)) {
     OS << "\n.debug_ranges contents:\n";
     // In fact, different compile units may have different address byte
-    // sizes, but for simplicity we just use the address byte size of the last
-    // compile unit (there is no easy and fast way to associate address range
-    // list and the compile unit it describes).
+    // sizes, but for simplicity we just use the address byte size of the
+    // last compile unit (there is no easy and fast way to associate address
+    // range list and the compile unit it describes).
+    // FIXME: savedAddressByteSize seems sketchy.
     DWARFDataExtractor rangesData(*DObj, DObj->getRangeSection(),
                                   isLittleEndian(), savedAddressByteSize);
-    offset = 0;
+    uint32_t offset = 0;
     DWARFDebugRangeList rangeList;
     while (rangeList.extract(rangesData, &offset))
       rangeList.dump(OS);
   }
 
-  if (DumpType & DIDT_DebugPubnames)
+  if (shouldDump(DIDT_DebugPubnames, DObj->getPubNamesSection()))
     DWARFDebugPubTable(DObj->getPubNamesSection(), isLittleEndian(), false)
         .dump("debug_pubnames", OS);
 
-  if (DumpType & DIDT_DebugPubtypes)
+  if (shouldDump(DIDT_DebugPubtypes, DObj->getPubTypesSection()))
     DWARFDebugPubTable(DObj->getPubTypesSection(), isLittleEndian(), false)
         .dump("debug_pubtypes", OS);
 
-  if (DumpType & DIDT_DebugGnuPubnames)
+  if (shouldDump(DIDT_DebugGnuPubnames, DObj->getGnuPubNamesSection()))
     DWARFDebugPubTable(DObj->getGnuPubNamesSection(), isLittleEndian(),
                        true /* GnuStyle */)
         .dump("debug_gnu_pubnames", OS);
 
-  if (DumpType & DIDT_DebugGnuPubtypes)
+  if (shouldDump(DIDT_DebugGnuPubtypes, DObj->getGnuPubTypesSection()))
     DWARFDebugPubTable(DObj->getGnuPubTypesSection(), isLittleEndian(),
                        true /* GnuStyle */)
         .dump("debug_gnu_pubtypes", OS);
 
-  if (DumpType & DIDT_DebugStrOffsets)
+  if (shouldDump(DIDT_DebugStrOffsets, DObj->getStringOffsetSection().Data))
     dumpStringOffsetsSection(
         OS, "debug_str_offsets", *DObj, DObj->getStringOffsetSection(),
         DObj->getStringSection(), isLittleEndian(), getMaxVersion());
-
-  if (DumpType & DIDT_DebugStrOffsetsDwo) {
+  if (shouldDumpDWO(DIDT_DebugStrOffsets,
+                    DObj->getStringOffsetDWOSection().Data))
     dumpStringOffsetsSection(
         OS, "debug_str_offsets.dwo", *DObj, DObj->getStringOffsetDWOSection(),
         DObj->getStringDWOSection(), isLittleEndian(), getMaxVersion());
-  }
 
-  if ((DumpType & DIDT_GdbIndex) &&
-      !DObj->getGdbIndexSection().empty()) {
+  if (shouldDump(DIDT_GdbIndex, DObj->getGdbIndexSection())) {
     OS << "\n.gnu_index contents:\n";
     getGdbIndex().dump(OS);
   }
 
-  if (DumpType & DIDT_AppleNames)
+  if (shouldDump(DIDT_AppleNames, DObj->getAppleNamesSection().Data))
     dumpAccelSection(OS, "apple_names", *DObj, DObj->getAppleNamesSection(),
                      DObj->getStringSection(), isLittleEndian());
 
-  if (DumpType & DIDT_AppleTypes)
+  if (shouldDump(DIDT_AppleTypes, DObj->getAppleTypesSection().Data))
     dumpAccelSection(OS, "apple_types", *DObj, DObj->getAppleTypesSection(),
                      DObj->getStringSection(), isLittleEndian());
 
-  if (DumpType & DIDT_AppleNamespaces)
+  if (shouldDump(DIDT_AppleNamespaces, DObj->getAppleNamespacesSection().Data))
     dumpAccelSection(OS, "apple_namespaces", *DObj,
                      DObj->getAppleNamespacesSection(),
                      DObj->getStringSection(), isLittleEndian());
 
-  if (DumpType & DIDT_AppleObjC)
+  if (shouldDump(DIDT_AppleObjC, DObj->getAppleObjCSection().Data))
     dumpAccelSection(OS, "apple_objc", *DObj, DObj->getAppleObjCSection(),
                      DObj->getStringSection(), isLittleEndian());
 }
 
 DWARFCompileUnit *DWARFContext::getDWOCompileUnitForHash(uint64_t Hash) {
   parseDWOCompileUnits();
 
   if (const auto &CUI = getCUIndex()) {

 
 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, uint64_t DumpType,
+bool DWARFContext::verify(raw_ostream &OS, unsigned DumpType,
                           DIDumpOptions DumpOpts) {
   bool Success = true;
   DWARFVerifier verifier(OS, *this, DumpOpts);
 
   Success &= verifier.handleDebugAbbrev();
   if (DumpType & DIDT_DebugInfo)
     Success &= verifier.handleDebugInfo();
   if (DumpType & DIDT_DebugLine)

test/DebugInfo/Inputs/gmlt.ll

 ; reordering in the linker), and looks wonky on platforms with zero values
 ; written in relocation places (dumper needs to be fixed to read the
 ; relocations rather than interpret that as the end of a range list))
 
 ; CHECK: 00000000 <End of list>
 
 
 ; Check that we don't emit any pubnames or pubtypes under -gmlt
-; CHECK: .debug_pubnames contents:
-; CHECK-NOT: Offset
-
-; CHECK: .debug_pubtypes contents:
-; CHECK-NOT: Offset
-
+; CHECK-NOT: .debug_pubnames contents:
+; CHECK-NOT: .debug_pubtypes contents:
 ; CHECK: .apple{{.*}} contents:
 
 ; Function Attrs: nounwind uwtable
 define void @_Z2f1v() #0 !dbg !4 {
 entry:
   ret void, !dbg !13
 }
 

test/DebugInfo/X86/fission-inline.ll

 ; CHECK-NOT: {{DW_|NULL}}
 ; CHECK:        DW_TAG_inlined_subroutine
 ; CHECK-NEXT:     DW_AT_abstract_origin {{.*}} "f2<int>"
 ; CHECK-NEXT:     DW_AT_ranges
 ; CHECK-NOT: {{DW_AT|DW_TAG|NULL}}
 ; CHECK:     DW_AT_call_file
 ; CHECK-NEXT:     DW_AT_call_line {{.*}} (18)
 ; CHECK-NOT: DW_
+; CHECK: .debug_info.dwo contents:
 
 ; RELOCS-NOT: RELOCATION RECORDS FOR [.rela.debug_ranges]
 
 ; Function Attrs: uwtable
 define void @_ZN3foo2f3Ez(...) #0 align 2 !dbg !10 {
 entry:
   call void @_Z2f1v(), !dbg !26
   call void @_Z2f1v(), !dbg !25

test/DebugInfo/X86/fission-no-inlining.ll

 ; RUN: llc -split-dwarf-file=foo.dwo -O0 < %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj | llvm-dwarfdump -debug-info - | FileCheck %s
 
+; CHECK: .debug_info contents:
 ; CHECK-NOT: DW_TAG_subprogram
+; CHECK: contents:
 
 ; IR generated from the following source:
 ; void f1();
 ; inline __attribute__((always_inline)) void f2() {
 ;   f1();
 ; }
 ; void f3() {
 ;   f2();

test/DebugInfo/X86/fission-ranges.ll

 
 
 ; CHECK: .debug_info.dwo contents:
 ; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[A:0x[0-9a-z]*]]
 ; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[E:0x[0-9a-z]*]]
 ; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[B:0x[0-9a-z]*]]
 ; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[D:0x[0-9a-z]*]]
 ; CHECK: DW_AT_ranges [DW_FORM_sec_offset]   (0x00000000
-; CHECK: .debug_loc contents:
+; CHECK-NOT: .debug_loc contents:
 ; CHECK-NOT: Beginning address offset
 ; CHECK: .debug_loc.dwo contents:
 
 ; Don't assume these locations are entirely correct - feel free to update them
 ; if they've changed due to a bugfix, change in register allocation, etc.
 
 ; CHECK:      [[A]]:
 ; CHECK-NEXT:   Addr idx 2 (w/ length 169): DW_OP_consts +0, DW_OP_stack_value

test/DebugInfo/X86/generate-odr-hash.ll

 ; CHECK-NEXT: DW_AT_decl_file
 ; CHECK-NEXT: DW_AT_decl_line
 
 ; CHECK: [[WOMBAT:^0x........]]: DW_TAG_structure_type
 ; CHECK-NEXT: DW_AT_declaration
 ; CHECK-NEXT: DW_AT_signature {{.*}} (0xfd756cee88f8a118)
 
 ; SINGLE-LABEL: .debug_types contents:
-; FISSION-NOT: .debug_types contents:
-; FISSION-LABEL: .debug_types.dwo contents:
+; FISSION: .debug_types.dwo contents:
 
 ; Check that we generate a hash for bar and the value.
 ; CHECK-NOT: type_signature
 ; CHECK-LABEL: type_signature = 0x1d02f3be30cc5688
 ; CHECK: DW_TAG_structure_type
 ; FISSION-NEXT: DW_AT_name {{.*}} ( indexed {{.*}} "bar"
 ; SINGLE-NEXT: DW_AT_name {{.*}} "bar"
 

 
 ; CHECK-LABEL: .debug_line contents:
 ; CHECK: Line table prologue
 ; CHECK-NOT: file_names[
 ; SINGLE: file_names{{.*}} bar.h
 ; CHECK: file_names{{.*}} bar.cpp
 ; CHECK-NOT: file_names[
 
-; CHECK-LABEL: .debug_line.dwo contents:
+; FISSION: .debug_line.dwo contents:
+; CHECK-NOT: .debug_line.dwo contents:
 ; FISSION: Line table prologue
 ; FISSION: opcode_base: 1
 ; FISSION-NOT: standard_opcode_lengths
 ; FISSION-NOT: include_directories
 ; FISSION-NOT: file_names[
 ; FISSION: file_names{{.*}} bar.h
 ; FISSION: file_names{{.*}} bar.cpp
 ; FISSION-NOT: file_names[

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

 ; 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: Name
 
-; NONE: .debug_pubnames contents:
-; NONE: {{^$}}
-; NONE: .debug_pubtypes contents:
-; NONE: {{^$}}
-; NONE: .debug_gnu_pubnames contents:
-; NONE: {{^$}}
-; NONE: .debug_gnu_pubtypes contents:
-; NONE: {{^$}}
+; NONE-NOT: .debug_pubnames contents:
+; NONE-NOT: .debug_pubtypes contents:
+; NONE-NOT: .debug_gnu_pubnames contents:
+; NONE-NOT: .debug_gnu_pubtypes contents:
 
 
 ; Function Attrs: noinline uwtable
 define void @_Z2f3v() #0 !dbg !7 {
 entry:
   call void @_Z2f1v(), !dbg !9
   ret void, !dbg !12
 }

test/DebugInfo/X86/split-dwarf-cross-unit-reference.ll

 ; RUN: llc -mtriple=x86_64-linux -split-dwarf-cross-cu-references -split-dwarf-file=foo.dwo -filetype=obj -o %t < %s
 ; RUN: llvm-objdump -r %t | FileCheck %s
-; RUN: llvm-dwarfdump -v -debug-info-dwo %t | FileCheck --check-prefix=ALL --check-prefix=INFO --check-prefix=DWO --check-prefix=CROSS %s
+; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck --check-prefix=ALL --check-prefix=INFO --check-prefix=DWO --check-prefix=CROSS %s
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck --check-prefix=ALL --check-prefix=INFO %s
 
 ; RUN: llc -mtriple=x86_64-linux -split-dwarf-file=foo.dwo -filetype=obj -o %t < %s
 ; RUN: llvm-objdump -r %t | FileCheck %s
-; RUN: llvm-dwarfdump -v -debug-info-dwo %t | FileCheck --check-prefix=ALL --check-prefix=DWO --check-prefix=NOCROSS %s
+; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck --check-prefix=ALL --check-prefix=DWO --check-prefix=NOCROSS %s
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck --check-prefix=ALL --check-prefix=INFO %s
 
 ; Testing cross-CU references for types, subprograms, and variables
 ; Built from code something like this:
 ; foo.cpp:
 ;   struct t1 { int i; };
 ;   void f();
 ;   __attribute__((always_inline)) void f1(t1 t) {

 ; * one debug_info->debug_info relocation in debug_info no matter what (for
 ;   split dwarf inlining)
 ; * debug_info uses relocations and ref_addr no matter what
 ; * debug_info.dwo uses relocations for types as well as abstract subprograms
 ;   and variables when -split-dwarf-cross-cu-references is used
 ; * debug_info.dwo contains duplicate types, abstract subprograms and abstract
 ;   variables otherwise to avoid the need for cross-cu references
 
+; DWO: .debug_info.dwo contents:
 ; CHECK-NOT: .rel{{a?}}.debug_info.dwo
 ; CHECK: RELOCATION RECORDS FOR [.rel{{a?}}.debug_info]:
 ; CHECK-NOT: RELOCATION RECORDS
 ; Expect one relocation in debug_info, from the inlined f1 in foo to its
 ; abstract origin in bar
 ; CHECK: R_X86_64_32 .debug_info
 ; CHECK-NOT: RELOCATION RECORDS
 ; CHECK-NOT: .debug_info

test/DebugInfo/X86/split-dwarf-multiple-cu-hash.ll

 ; RUN: rm -rf %t && mkdir -p %t
 ; RUN: %llc_dwarf -split-dwarf-file=foo.dwo  %s -filetype=obj -o %t/a.o
 ; RUN: %llc_dwarf -split-dwarf-file=bar.dwo  %s -filetype=obj -o %t/b.o
 ; RUN: llvm-dwarfdump -debug-info %t/a.o %t/b.o | FileCheck %s
 
+; CHECK: .debug_info contents:
 ; CHECK: dwo_id {{.*}}([[HASH:.*]])
 ; CHECK-NOT: dwo_id {{.*}}([[HASH]])
+; CHECK: .debug_info.dwo contents:
 
 target triple = "x86_64-pc-linux"
 
 ; Function Attrs: noinline nounwind uwtable
 define void @_Z1av() #0 !dbg !9 {
 entry:
   ret void, !dbg !12
 }

test/DebugInfo/X86/split-dwarf-omit-empty.ll

 ;     f2();
 ;   }
 ; $ clang++ -fno-split-dwarf-inlining {a,b}.cpp -emit-llvm -S -g
 ; $ llvm-link {a,b}.ll -S -o ab.ll
 ; Then strip out the @llvm.used global, so no out of line definition of 'f2'
 ; will be emitted. This emulates something more like the available_externally
 ; import performed by ThinLTO.
 
+; CHECK: .debug_info contents:
 ; CHECK: Compile Unit
 ; CHECK-NOT: Compile Unit
+; CHECK: .debug_info.dwo contents:
 
 target triple = "x86_64-pc-linux"
 
 declare void @_Z2f1v()
 
 ; Function Attrs: noinline norecurse uwtable
 define i32 @main() !dbg !9 {
 entry:

test/DebugInfo/dwarfdump-dump-flags.test

 ; RUN: llvm-dwarfdump %p/Inputs/dwarfdump-test.elf-x86-64 --all | FileCheck %s -check-prefix DUMP_ALL
 ; RUN: llvm-dwarfdump %p/Inputs/dwarfdump-test.elf-x86-64 --debug-info | FileCheck %s -check-prefix DUMP_INFO
 ; RUN: llvm-dwarfdump %p/Inputs/dwarfdump-test.elf-x86-64 --debug-ranges | FileCheck %s -check-prefix DUMP_RANGES
 ; RUN: llvm-dwarfdump %p/Inputs/dwarfdump-test.macho-i386.o -all | FileCheck %s -check-prefix DUMP_ALL
 ; RUN: llvm-dwarfdump %p/Inputs/dwarfdump-test.macho-i386.o --debug-info | FileCheck %s -check-prefix DUMP_INFO
 ; RUN: llvm-dwarfdump %p/Inputs/dwarfdump-test.macho-i386.o --debug-ranges | FileCheck %s -check-prefix DUMP_RANGES
 
 ; DUMP_ALL: .debug_info
-; DUMP_ALL: .debug_ranges
+; DUMP_ALL: .debug_str
 
 ; DUMP_INFO: .debug_info
 ; DUMP_INFO-NOT: .debug_ranges
+; DUMP_INFO-NOT: .debug_str
 
 ; DUMP_RANGES-NOT: .debug_info
 ; DUMP_RANGES: .debug_ranges
 

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

 
 // 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
 
 
-// DWARF: .debug_ranges contents:
-// DWARF-NOT: {{0-9a-f}}
-// DWARF: .debug_pubnames contents:
+// DWARF-NOT: .debug_ranges contents:
+// DWARF-NOT: .debug_pubnames contents:
 
 
 // RELOC: RELOCATION RECORDS FOR [.rel.debug_info]:
 // RELOC-NEXT: 00000006 R_ARM_ABS32 .debug_abbrev
 // RELOC-NEXT: 0000000c R_ARM_ABS32 .debug_line
 // RELOC-NEXT: R_ARM_ABS32 .text
 // RELOC-NEXT: R_ARM_ABS32 .text
 // RELOC-NEXT: R_ARM_ABS32 .text
 // RELOC-NEXT: R_ARM_ABS32 foo
 
 // RELOC-NOT: RELOCATION RECORDS FOR [.rel.debug_ranges]:
 
 // RELOC: RELOCATION RECORDS FOR [.rel.debug_aranges]:
 // RELOC-NEXT: 00000006 R_ARM_ABS32 .debug_info
 // RELOC-NEXT: 00000010 R_ARM_ABS32 .text
 // RELOC-NEXT: 00000018 R_ARM_ABS32 foo

test/MC/ARM/dwarf-asm-no-code.s

 // RUN: llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o %t -g -fdebug-compilation-dir=/tmp
 // RUN: llvm-dwarfdump -v %t | FileCheck -check-prefix DWARF %s
 // RUN: llvm-objdump -r %t | FileCheck -check-prefix RELOC %s
 
 // If there is no code in an assembly file, no debug info is produced
 
 .section .data, "aw"
 a:
 .long 42
 
-// DWARF: .debug_abbrev contents:
-// DWARF-NEXT: < EMPTY >
-
-// DWARF: .debug_info contents:
-
-// DWARF: .debug_aranges contents:
-
+// DWARF: ELF32-arm-little
+// DWARF-NOT: contents:
 // DWARF: .debug_line contents:
 
-// DWARF: .debug_ranges contents:
-
-
 // RELOC-NOT: RELOCATION RECORDS FOR [.rel.debug_info]:
 
 // RELOC-NOT: RELOCATION RECORDS FOR [.rel.debug_ranges]:
 
 // RELOC-NOT: RELOCATION RECORDS FOR [.rel.debug_aranges]:

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

 // 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: .debug_ranges contents:
-// DWARF-NOT: {{0-9a-f}}
-// DWARF: .debug_pubnames contents:
+// DWARF-NOT: .debug_ranges contents:
+// DWARF-NOT: .debug_pubnames contents:
 
 
 
 // RELOC: RELOCATION RECORDS FOR [.rel.debug_info]:
 // RELOC-NEXT: 00000006 R_ARM_ABS32 .debug_abbrev
 // RELOC-NEXT: 0000000c R_ARM_ABS32 .debug_line
 // RELOC-NEXT: R_ARM_ABS32 foo
 // RELOC-NEXT: R_ARM_ABS32 foo
 // RELOC-NEXT: R_ARM_ABS32 foo
 
 // RELOC-NOT: RELOCATION RECORDS FOR [.rel.debug_ranges]:
 
 // RELOC: RELOCATION RECORDS FOR [.rel.debug_aranges]:
 // RELOC-NEXT: 00000006 R_ARM_ABS32 .debug_info
 // RELOC-NEXT: 00000010 R_ARM_ABS32 foo

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

 // DWARF-NEXT: Address Range Header: length = 0x0000001c, 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: .debug_ranges contents:
-// DWARF-NOT: {{0-9a-f}}
-// DWARF: .debug_pubnames contents:
+// DWARF-NOT: .debug_ranges contents:
+// DWARF-NOT: .debug_pubnames contents:
 
 
 // RELOC: RELOCATION RECORDS FOR [.rel.debug_info]:
 // RELOC-NEXT: 00000006 R_ARM_ABS32 .debug_abbrev
 // RELOC-NEXT: 0000000c R_ARM_ABS32 .debug_line
 // RELOC-NEXT: R_ARM_ABS32 .text
 // RELOC-NEXT: R_ARM_ABS32 .text
 // RELOC-NEXT: R_ARM_ABS32 .text
 
 // RELOC-NOT: RELOCATION RECORDS FOR [.rel.debug_ranges]:
 
 // RELOC: RELOCATION RECORDS FOR [.rel.debug_aranges]:
 // RELOC-NEXT: 00000006 R_ARM_ABS32 .debug_info
 // RELOC-NEXT: 00000010 R_ARM_ABS32 .text

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

 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x0000008a] = "inc")
 CHECK:      DW_AT_type [DW_FORM_ref4]       (cu + 0x0041 => {0x00000167})
 CHECK:      DW_AT_low_pc [DW_FORM_addr]     (0x0000000100000f90)
 CHECK:      DW_AT_high_pc [DW_FORM_addr]    (0x0000000100000fa9)
 CHECK:      DW_AT_frame_base [DW_FORM_block1] (DW_OP_reg6 RBP)
 
 CHECK:    NULL
 
-CHECK: .debug_loc contents
-CHECK-NOT: Location
+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:[0x0000000100000ea0 - 0x0000000100000ec4)
 CHECK-NEXT:Address Range Header: length = 0x0000003c, 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

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

 RUN: llvm-dwp %p/../Inputs/empty.dwo -o %t
 RUN: llvm-dwarfdump -v %t | FileCheck %s
 
-CHECK-LABEL: .debug_cu_index
+CHECK: file format
+CHECK-NOT: .debug_cu_index
 CHECK-NOT: version
-CHECK-LABEL: .debug_tu_index
+CHECK-NOT: .debug_tu_index
 CHECK-NOT: version
-CHECK: .debug_

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

 
 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)
 TYPES:     3 [[DWOB]]  {{\[}}[[BOFF]], [[XOFF]]) [0x0000[[BAOFF]], 0x00000099)      [0x0000001a, 0x00000034) [0x00000010, 0x00000024)
 NOTYP:     3 [[DWOA]]  {{\[}}[[AOFF]], [[BOFF]]) [0x0000[[AAOFF]], 0x0000[[BAOFF]]) [0x00000000, 0x00000011) [0x00000000, 0x00000010)
 NOTYP:     4 [[DWOB]]  {{\[}}[[BOFF]], [[XOFF]]) [0x0000[[BAOFF]], 0x00000075)      [0x00000011, 0x00000022) [0x00000010, 0x00000024)
 
-CHECK-LABEL: .debug_tu_index contents:
-NOTYP-NOT: Index
+CHECK-NOT: .debug_tu_index contents:
 TYPES: Index Signature  TYPES                           ABBREV                             LINE                     STR_OFFSETS
 TYPES:     1 [[FOOSIG]] {{\[}}[[FOOUOFF]], [[BARUOFF]]) [0x0000[[AAOFF]], 0x0000[[BAOFF]]) [0x00000000, 0x0000001a) [0x00000000, 0x00000010)
 TYPES:     4 [[BARSIG]] {{\[}}[[BARUOFF]], [[XUOFF]])   [0x0000[[BAOFF]], 0x00000099)      [0x0000001a, 0x00000034) [0x00000010, 0x00000024)
 
 Ensure we do not create a debug_tu_index, even an empty or malformed one.
 NOTYPOBJ-NOT: .debug_tu_index
 
 CHECK-LABEL: .debug_str.dwo contents:

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

 
 cl::OptionCategory
     SectionCategory("Section-specific Dump Options",
                     "These control which sections are dumped.");
 static opt<bool> DumpAll("all", desc("Dump all debug info sections"),
                          cat(SectionCategory));
 static alias DumpAllAlias("a", desc("Alias for -all"), aliasopt(DumpAll));
 
-static uint64_t DumpType = DIDT_Null;
+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> DumpUUID("uuid", desc("Show the UUID for each architecture"),
                           cat(DwarfDumpCategory));

 }
 
 static void DumpObjectFile(ObjectFile &Obj, Twine Filename) {
   std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(Obj);
   logAllUnhandledErrors(DICtx->loadRegisterInfo(Obj), errs(),
                         Filename.str() + ": ");
   // The UUID dump already contains all the same information.
   if (!(DumpType & DIDT_UUID) || DumpType == DIDT_All)
-    outs() << Filename << ":\tfile format " << Obj.getFileFormatName()
-           << "\n\n";
+    outs() << Filename << ":\tfile format " << Obj.getFileFormatName() << '\n';
 
   // Dump the complete DWARF structure.
   DICtx->dump(outs(), GetDumpOpts());
 }
 
 static void DumpInput(StringRef Filename) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> BuffOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);