[DWARF] Introduce -brief command line option to llvm-dwarfdump

[sgravani]

Summary

This patch introduces a new command line option, called brief, to llvm-dwarfdump.
When -brief is used, the attribute forms for the .debug_info section will not be emitted to output.

[aprantl]

Thanks, I made a couple of comments inline.

include/llvm/DebugInfo/DWARF/DWARFDie.h

123

This line appears to be > 80-columns. Did you run the patch through clang-format?

lib/DebugInfo/DWARF/DWARFDie.cpp

82

clang-format again :-)

133

extra whitespace

363

Looks like this was accidentally left in?

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

86

I assume that eventually we will want to hide more than just DW_FORMs (e.g., similar to Darwin dwarfdump's output) so it might be better to just generally say something like "Print fewer low-level details".

Personally, I would like this mode to become the default, and then introduce a --verbose option to get to the original output, but we can have that discussion another time.

[aprantl]

test/tools/llvm-dwarfdump/brief.s

4

Maybe add a comment here explaining what the test is checking:
# Verify that --brief hides DW_FORMs.

[dblaikie]

test/tools/llvm-dwarfdump/brief.s

4

Might be worth checking a whole attribute line to demonstrate the output format more clearly. (arguably this test could pass if no attributes were dumped at all, for example)

[probinson]

lib/DebugInfo/DWARF/DWARFDie.cpp

331

Indentation? (run clang-format ...)

test/tools/llvm-dwarfdump/lit.local.cfg

1

All llvm-dwarfdump tests are in target-specific subdirectories; please move this file and your new test to a new X86 subdirectory.

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

86

I agree with Adrian. In fact the comment is already incorrect, the option hides abbrev codes as well as forms.

[probinson]

Subscribe llvm-commits

[sgravani]

Addressed the reviewers' comments:

1. Used clang-format on patch
2. Updated description of --brief
3. Moved test case to X86 subdirectory in llvm-dwarfdump test directory
4. Added an integer declaration in the test case

[aprantl]

It looks like you accidentally created a diff between your last patch and the new version. When uploading a revised patch, please always upload the diff from svn trunk.

test/tools/llvm-dwarfdump/brief.s

7

What David meant here was that
CHECK-NOT: DW_FORM
is also true for empty output.
If we instead check for

CHECK: DW_TAG_compile_unit
CHECK-NOT: DW_FORM
CHECK: DW_AT

or (probably better)

CHECK: DW_TAG_compile_unit {{$}}

We match an entire line of output and the test case is more robust.

[sgravani]

Updated to the diff to be from the svn trunk.
Modified test case to be more robust.

[aprantl]

Thanks, this LGTM now.

include/llvm/DebugInfo/DIContext.h

 };
 
 /// Container for dump options that control which debug information will be
 /// dumped.
 struct DIDumpOptions {
     DIDumpType DumpType = DIDT_All;
     bool DumpEH = false;
     bool SummarizeTypes = false;
+    bool Brief = false;
 };
 
 class DIContext {
 public:
   enum DIContextKind {
     CK_DWARF,
     CK_PDB
   };

include/llvm/DebugInfo/DWARF/DWARFCompileUnit.h

DWARFCompileUnit(DWARFContext &Context, const DWARFSection &Section,
                    const DWARFUnitSectionBase &UnitSection,
                    const DWARFUnitIndex::Entry *Entry)
       : DWARFUnit(Context, Section, DA, RS, SS, SOS, AOS, LS, LE, IsDWO,
                   UnitSection, Entry) {}
 
   // VTable anchor.
   ~DWARFCompileUnit() override;
 
-  void dump(raw_ostream &OS);
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts);
 
   static const DWARFSectionKind Section = DW_SECT_INFO;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARFCOMPILEUNIT_H

include/llvm/DebugInfo/DWARF/DWARFDie.h

public:
   }
 
   /// Dump the DIE and all of its attributes to the supplied stream.
   ///
   /// \param OS the stream to use for output.
   /// \param recurseDepth the depth to recurse to when dumping this DIE and its
   /// children.
   /// \param indent the number of characters to indent each line that is output.
-  void dump(raw_ostream &OS, unsigned recurseDepth, unsigned indent = 0) const;
+  void dump(raw_ostream &OS, unsigned recurseDepth, unsigned indent = 0, DIDumpOptions DumpOpts = DIDumpOptions()) const;
 
   /// Extract the specified attribute from this DIE.
   ///
   /// Extract an attribute value from this DIE only. This call doesn't look
   /// for the attribute value in any DW_AT_specification or
   /// DW_AT_abstract_origin referenced DIEs.
   ///
   /// \param Attr the attribute to extract.

lib/DebugInfo/DWARF/DWARFCompileUnit.cpp

 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
-void DWARFCompileUnit::dump(raw_ostream &OS) {
+void DWARFCompileUnit::dump(raw_ostream &OS, DIDumpOptions DumpOpts) {
   OS << format("0x%08x", getOffset()) << ": Compile Unit:"
      << " length = " << format("0x%08x", getLength())
      << " version = " << format("0x%04x", getVersion());
   if (getVersion() >= 5)
     OS << " unit_type = " << dwarf::UnitTypeString(getUnitType());
   OS << " abbr_offset = " << format("0x%04x", getAbbreviations()->getOffset())
      << " addr_size = " << format("0x%02x", getAddressByteSize())
      << " (next unit at " << format("0x%08x", getNextUnitOffset())
      << ")\n";
 
   if (DWARFDie CUDie = getUnitDIE(false))
-    CUDie.dump(OS, -1U);
+    CUDie.dump(OS, -1U, 0, DumpOpts);
   else
     OS << "<compile unit can't be parsed!>\n\n";
 }
 
 // VTable anchor.
 DWARFCompileUnit::~DWARFCompileUnit() = default;

lib/DebugInfo/DWARF/DWARFContext.cpp

if (DumpType == DIDT_All || DumpType == DIDT_AbbrevDwo)
     if (const DWARFDebugAbbrev *D = getDebugAbbrevDWO()) {
       OS << "\n.debug_abbrev.dwo contents:\n";
       D->dump(OS);
     }
 
   if (DumpType == DIDT_All || DumpType == DIDT_Info) {
     OS << "\n.debug_info contents:\n";
     for (const auto &CU : compile_units())
-      CU->dump(OS);
+      CU->dump(OS, DumpOpts);
   }
 
   if ((DumpType == DIDT_All || DumpType == DIDT_InfoDwo) &&
       getNumDWOCompileUnits()) {
     OS << "\n.debug_info.dwo contents:\n";
     for (const auto &DWOCU : dwo_compile_units())
-      DWOCU->dump(OS);
+      DWOCU->dump(OS, DumpOpts);
   }
 
   if ((DumpType == DIDT_All || DumpType == DIDT_Types) && getNumTypeUnits()) {
     OS << "\n.debug_types contents:\n";
     for (const auto &TUS : type_unit_sections())
       for (const auto &TU : TUS)
         TU->dump(OS, SummarizeTypes);
   }

lib/DebugInfo/DWARF/DWARFDie.cpp

static void dumpRanges(raw_ostream &OS, const DWARFAddressRangesVector& Ranges,
   
   for (const auto &Range: Ranges) {
     OS << '\n';
     OS.indent(Indent);
     OS << format("[0x%0*" PRIx64 " - 0x%0*" PRIx64 ")",
                  AddressSize*2, Range.LowPC,
                  AddressSize*2, Range.HighPC);
   }
-}
+} 
 
 static void dumpAttribute(raw_ostream &OS, const DWARFDie &Die,
                           uint32_t *OffsetPtr, dwarf::Attribute Attr,
-                          dwarf::Form Form, unsigned Indent) {
+                          dwarf::Form Form, unsigned Indent, DIDumpOptions DumpOpts) {
   if (!Die.isValid())
     return;
   const char BaseIndent[] = "            ";
   OS << BaseIndent;
   OS.indent(Indent+2);
   auto attrString = AttributeString(Attr);
   if (!attrString.empty())
     WithColor(OS, syntax::Attribute) << attrString;
   else
     WithColor(OS, syntax::Attribute).get() << format("DW_AT_Unknown_%x", Attr);
   
+  if(!DumpOpts.Brief){
     auto formString = FormEncodingString(Form);
     if (!formString.empty())
       OS << " [" << formString << ']';
     else
       OS << format(" [DW_FORM_Unknown_%x]", Form);
+  }
   
   DWARFUnit *U = Die.getDwarfUnit();
   DWARFFormValue formValue(Form);
   
   if (!formValue.extractValue(U->getDebugInfoExtractor(), OffsetPtr, U))
     return;
   
   OS << "\t(";
if (Attr == DW_AT_specification || Attr == DW_AT_abstract_origin) {
     if (Optional<uint64_t> OptVal = formValue.getAsUnsignedConstant())
       dumpApplePropertyAttribute(OS, *OptVal);
   } else if (Attr == DW_AT_ranges) {
     dumpRanges(OS, Die.getAddressRanges(), U->getAddressByteSize(),
                sizeof(BaseIndent)+Indent+4);
   }
   
   OS << ")\n";
+
 }
 
 bool DWARFDie::isSubprogramDIE() const {
   return getTag() == DW_TAG_subprogram;
 }
 
 bool DWARFDie::isSubroutineDIE() const {
   auto Tag = getTag();
void DWARFDie::getCallerFrame(uint32_t &CallFile, uint32_t &CallLine,
                               uint32_t &CallColumn,
                               uint32_t &CallDiscriminator) const {
   CallFile = toUnsigned(find(DW_AT_call_file), 0);
   CallLine = toUnsigned(find(DW_AT_call_line), 0);
   CallColumn = toUnsigned(find(DW_AT_call_column), 0);
   CallDiscriminator = toUnsigned(find(DW_AT_GNU_discriminator), 0);
 }
 
+
 void DWARFDie::dump(raw_ostream &OS, unsigned RecurseDepth,
-                    unsigned Indent) const {
+                    unsigned Indent, DIDumpOptions DumpOpts ) const {
   if (!isValid())
     return;
   DataExtractor debug_info_data = U->getDebugInfoExtractor();
   const uint32_t Offset = getOffset();
   uint32_t offset = Offset;
   
   if (debug_info_data.isValidOffset(offset)) {
     uint32_t abbrCode = debug_info_data.getULEB128(&offset);
     WithColor(OS, syntax::Address).get() << format("\n0x%8.8x: ", Offset);
     
     if (abbrCode) {
       auto AbbrevDecl = getAbbreviationDeclarationPtr();
       if (AbbrevDecl) {
         auto tagString = TagString(getTag());
         if (!tagString.empty())
           WithColor(OS, syntax::Tag).get().indent(Indent) << tagString;
         else
           WithColor(OS, syntax::Tag).get().indent(Indent)
           << format("DW_TAG_Unknown_%x", getTag());
         
-        OS << format(" [%u] %c\n", abbrCode,
+        if(!DumpOpts.Brief)
+        OS << format(" [%u] %c", abbrCode,
                      AbbrevDecl->hasChildren() ? '*' : ' ');
+        OS << '\n';
         
         // Dump all data in the DIE for the attributes.
         for (const auto &AttrSpec : AbbrevDecl->attributes()) {
           if (AttrSpec.Form == DW_FORM_implicit_const) {
             // We are dumping .debug_info section ,
             // implicit_const attribute values are not really stored here,
             // but in .debug_abbrev section. So we just skip such attrs.
             continue;
           }
           dumpAttribute(OS, *this, &offset, AttrSpec.Attr, AttrSpec.Form,
-                        Indent);
+                        Indent, DumpOpts);
         }
         
         DWARFDie child = getFirstChild();
         if (RecurseDepth > 0 && child) {
           while (child) {
-            child.dump(OS, RecurseDepth-1, Indent+2);
+            child.dump(OS, RecurseDepth-1, Indent+2, DumpOpts);
             child = child.getSibling();
           }
         }
       } else {
         OS << "Abbreviation code not found in 'debug_abbrev' class for code: "
         << abbrCode << '\n';
       }
     } else {
       OS.indent(Indent) << "NULL\n";
     }
   }
 }
+/*
+void DWARFDie::dump(raw_ostream &OS, unsigned RecurseDepth,
+                    unsigned Indent, DIDumpOptions DumpOpts) const {
+
+  if (!isValid())
+    return;
+  DataExtractor debug_info_data = U->getDebugInfoExtractor();
+  const uint32_t Offset = getOffset();
+  uint32_t offset = Offset;
+  
+  if (debug_info_data.isValidOffset(offset)) {
+    uint32_t abbrCode = debug_info_data.getULEB128(&offset);
+    WithColor(OS, syntax::Address).get() << format("\n0x%8.8x: ", Offset);
+    
+    if (abbrCode) {
+      auto AbbrevDecl = getAbbreviationDeclarationPtr();
+      if (AbbrevDecl) {
+        auto tagString = TagString(getTag());
+        if (!tagString.empty())
+          WithColor(OS, syntax::Tag).get().indent(Indent) << tagString;
+        else
+          WithColor(OS, syntax::Tag).get().indent(Indent)
+          << format("DW_TAG_Unknown_%x", getTag());
        
+        if(!DumpOpts.Brief){
+          OS << format(" [%u] %c", abbrCode,
+                     AbbrevDecl->hasChildren() ? '*' : ' ');
+        }
+        OS << '\n';
+        
+        // Dump all data in the DIE for the attributes.
+        for (const auto &AttrSpec : AbbrevDecl->attributes()) {
+          if (AttrSpec.Form == DW_FORM_implicit_const) {
+            // We are dumping .debug_info section ,
+            // implicit_const attribute values are not really stored here,
+            // but in .debug_abbrev section. So we just skip such attrs.
+            continue;
+          }
+          dumpAttribute(OS, *this, &offset, AttrSpec.Attr, AttrSpec.Form,
+                        Indent, DumpOpts);
+        }
+        
+        DWARFDie child = getFirstChild();
+        if (RecurseDepth > 0 && child) {
+          while (child) {
+            child.dump(OS, RecurseDepth-1, Indent+2, DumpOpts);
+            child = child.getSibling();
+          }
+        }
+      } else {
+        OS << "Abbreviation code not found in 'debug_abbrev' class for code: "
+        << abbrCode << '\n';
+      }
+    } else {
+      OS.indent(Indent) << "NULL\n";
+    }
+  }
+}
+*/
 DWARFDie DWARFDie::getParent() const {
   if (isValid())
     return U->getParent(Die);
   return DWARFDie();
 }
 
 DWARFDie DWARFDie::getSibling() const {
   if (isValid())

test/tools/llvm-dwarfdump/brief.s

+# RUN: llvm-mc %s -filetype obj -triple x86_64-apple-darwin -o - \
+# RUN: | llvm-dwarfdump -debug-dump=info -brief - \
+# RUN: | FileCheck %s
+
+# CHECK: DW_TAG_compile_unit
+# CHECK-NOT: [{{[0-9]+}}]
+# CHECK-NOT: DW_FORM
+
+  .section  __TEXT,__text,regular,pure_instructions
+  .section  __DWARF,__debug_str,regular,debug
+Linfo_string:
+  .asciz  "basic.c"               ## string offset=42
+  .section  __DWARF,__debug_loc,regular,debug
+Lsection_debug_loc:
+  .section  __DWARF,__debug_abbrev,regular,debug
+Lsection_abbrev:
+  .byte 1                       ## Abbreviation Code
+  .byte 17                      ## DW_TAG_compile_unit
+  .byte 0                       ## DW_CHILDREN_no
+  .byte 37                      ## DW_AT_producer
+  .byte 14                      ## DW_FORM_strp
+  .byte 19                      ## DW_AT_language
+  .byte 5                       ## DW_FORM_data2
+  .byte 3                       ## DW_AT_name
+  .byte 14                      ## DW_FORM_strp
+  .byte 16                      ## DW_AT_stmt_list
+  .byte 23                      ## DW_FORM_sec_offset
+  .byte 27                      ## DW_AT_comp_dir
+  .byte 14                      ## DW_FORM_strp
+  .byte 0                       ## EOM(1)
+  .byte 0                       ## EOM(2)
+  .byte 0                       ## EOM(3)
+  .section  __DWARF,__debug_info,regular,debug
+Lsection_info:
+Lcu_begin0:
+  .long 26                      ## Length of Unit
+  .short  4                       ## DWARF version number
+Lset0 = Lsection_abbrev-Lsection_abbrev ## Offset Into Abbrev. Section
+  .long Lset0
+  .byte 8                       ## Address Size (in bytes)
+  .byte 1                       ## Abbrev [1] 0xb:0x13 DW_TAG_compile_unit
+  .long 0                       ## DW_AT_producer
+  .short  12                      ## DW_AT_language
+  .long 42                      ## DW_AT_name
+Lset1 = Lline_table_start0-Lsection_line ## DW_AT_stmt_list
+  .long Lset1
+  .long 50                      ## DW_AT_comp_dir
+  .section  __DWARF,__debug_ranges,regular,debug
+Ldebug_range:
+  .section  __DWARF,__debug_macinfo,regular,debug
+Ldebug_macinfo:
+Lcu_macro_begin0:
+  .byte 0                       ## End Of Macro List Mark
+  .section  __DWARF,__apple_names,regular,debug
+Lnames_begin:
+  .long 1212240712              ## Header Magic
+  .short  1                       ## Header Version
+  .short  0                       ## Header Hash Function
+  .long 1                       ## Header Bucket Count
+  .long 0                       ## Header Hash Count
+  .long 12                      ## Header Data Length
+  .long 0                       ## HeaderData Die Offset Base
+  .long 1                       ## HeaderData Atom Count
+  .short  1                       ## DW_ATOM_die_offset
+  .short  6                       ## DW_FORM_data4
+  .long -1                      ## Bucket 0
+  .section  __DWARF,__apple_objc,regular,debug
+Lobjc_begin:
+  .long 1212240712              ## Header Magic
+  .short  1                       ## Header Version
+  .short  0                       ## Header Hash Function
+  .long 1                       ## Header Bucket Count
+  .long 0                       ## Header Hash Count
+  .long 12                      ## Header Data Length
+  .long 0                       ## HeaderData Die Offset Base
+  .long 1                       ## HeaderData Atom Count
+  .short  1                       ## DW_ATOM_die_offset
+  .short  6                       ## DW_FORM_data4
+  .long -1                      ## Bucket 0
+  .section  __DWARF,__apple_namespac,regular,debug
+Lnamespac_begin:
+  .long 1212240712              ## Header Magic
+  .short  1                       ## Header Version
+  .short  0                       ## Header Hash Function
+  .long 1                       ## Header Bucket Count
+  .long 0                       ## Header Hash Count
+  .long 12                      ## Header Data Length
+  .long 0                       ## HeaderData Die Offset Base
+  .long 1                       ## HeaderData Atom Count
+  .short  1                       ## DW_ATOM_die_offset
+  .short  6                       ## DW_FORM_data4
+  .long -1                      ## Bucket 0
+  .section  __DWARF,__apple_types,regular,debug
+Ltypes_begin:
+  .long 1212240712              ## Header Magic
+  .short  1                       ## Header Version
+  .short  0                       ## Header Hash Function
+  .long 1                       ## Header Bucket Count
+  .long 0                       ## Header Hash Count
+  .long 20                      ## Header Data Length
+  .long 0                       ## HeaderData Die Offset Base
+  .long 3                       ## HeaderData Atom Count
+  .short  1                       ## DW_ATOM_die_offset
+  .short  6                       ## DW_FORM_data4
+  .short  3                       ## DW_ATOM_die_tag
+  .short  5                       ## DW_FORM_data2
+  .short  4                       ## DW_ATOM_type_flags
+  .short  11                      ## DW_FORM_data1
+  .long -1                      ## Bucket 0
+  .section  __DWARF,__apple_exttypes,regular,debug
+Lexttypes_begin:
+  .long 1212240712              ## Header Magic
+  .short  1                       ## Header Version
+  .short  0                       ## Header Hash Function
+  .long 1                       ## Header Bucket Count
+  .long 0                       ## Header Hash Count
+  .long 12                      ## Header Data Length
+  .long 0                       ## HeaderData Die Offset Base
+  .long 1                       ## HeaderData Atom Count
+  .short  7                       ## DW_ATOM_ext_types
+  .short  6                       ## DW_FORM_data4
+  .long -1                      ## Bucket 0
+
+.subsections_via_symbols
+  .section  __DWARF,__debug_line,regular,debug
+Lsection_line:
+Lline_table_start0:
+  
 No newline at end of file

test/tools/llvm-dwarfdump/lit.local.cfg

+if not 'X86' in config.root.targets:
+    config.unsupported = True

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

static cl::opt<bool>
     SummarizeTypes("summarize-types",
                    cl::desc("Abbreviate the description of type unit entries"));
 
 static cl::opt<bool> Verify("verify", cl::desc("Verify the DWARF debug info"));
 
 static cl::opt<bool> Quiet("quiet",
                            cl::desc("Use with -verify to not emit to STDOUT."));
 
+static cl::opt<bool> Brief("brief", cl::desc("Do not emit attribute forms."));
+
 static void error(StringRef Filename, std::error_code EC) {
   if (!EC)
     return;
   errs() << Filename << ": " << EC.message() << "\n";
   exit(1);
 }
 
 static void DumpObjectFile(ObjectFile &Obj, Twine Filename) {
   std::unique_ptr<DIContext> DICtx(new DWARFContextInMemory(Obj));
 
   outs() << Filename.str() << ":\tfile format " << Obj.getFileFormatName()
          << "\n\n";
 
   // Dump the complete DWARF structure.
   DIDumpOptions DumpOpts;
   DumpOpts.DumpType = DumpType;
   DumpOpts.SummarizeTypes = SummarizeTypes;
+  DumpOpts.Brief = Brief;
   DICtx->dump(outs(), DumpOpts);
 }
 
 static void DumpInput(StringRef Filename) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> BuffOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
   error(Filename, BuffOrErr.getError());
   std::unique_ptr<MemoryBuffer> Buff = std::move(BuffOrErr.get());