[llvm-dwarfdump] Hide .debug_str and die reference offsets in brief mode

[JDevlieghere]

Summary

• Hide .debug_str offset
• Hide offset into the CU of a die reference

Before:

0x0000002a:   DW_TAG_subprogram
                DW_AT_low_pc    (0x0000000100000fb0)
                DW_AT_high_pc   (0x00000008)
                DW_AT_frame_base        (<0x1> 56 )
                DW_AT_name      ( .debug_str[0x00000056] = "main")
                DW_AT_decl_file ("/Users/jonas/llvm/brief/a.c")
                DW_AT_decl_line (1)
                DW_AT_type      (cu + 0x0043 => {0x00000043})
                DW_AT_external  (true)

After:

0x0000002a:   DW_TAG_subprogram
                DW_AT_low_pc    (0x0000000100000fb0)
                DW_AT_high_pc   (0x00000008)
                DW_AT_frame_base        (<0x1> 56 )
                DW_AT_name      ( .debug_str = "main")
                DW_AT_decl_file ("/Users/jonas/llvm/brief/a.c")
                DW_AT_decl_line (1)
                DW_AT_type      (cu + 0x0043)
                DW_AT_external  (true)

[aprantl]

llvm/lib/DebugInfo/DWARF/DWARFFormValue.cpp

487

I think we might even want to drop the .debug_str = part. What does Darwin's dwarfdump do in comparison?

[aprantl]

Also, could you please add a testcase? You can probably reuse the input from one of the existing testcases.

[JDevlieghere]

• Hide .debug_str = part as well
• Update test case

I had to generate new assembly because the current test didn't have a DIE reference. I hope this is alright?

[dblaikie]

llvm/trunk/test/tools/llvm-dwarfdump/X86/brief.s

7–10 ↗

(On Diff #111748)

It's probably worth having a positive test for what the string printing looks like in brief mode? I know it was mentioned in the patch description, but it was revised before committing & I was curious to see how it actually prints out now.

FWIW, I'd think we might want to drive towards printing something as simple as:

compile_unit
  name: "foo"

(ie: dropping as much of the ()[]{} sort of stuff as possible, and dropping the DW_*_ prefixes too - since they're unambiguous as to what's a DW_TAG, DW_AT, DW_OP, etc, based on context)

[dblaikie]

ping

[JDevlieghere]

Hi Dave,

The positive tests have been committed as part of D37334 because I had to change the test anyway. Let me know if you think something is still missing!

With regards to dropping the prefixes, I talked to Adrian and he makes a pretty good argument in favor of keeping them. Maybe this is something to discuss on the mailing list as an NFC? I've had a look and implementing this should be relatively straightforward so it really boils down to whether we want to do this or not.

llvm/include/llvm/DebugInfo/DWARF/DWARFFormValue.h

 //===- DWARFFormValue.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DWARFFORMVALUE_H
 #define LLVM_DEBUGINFO_DWARFFORMVALUE_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include <cstdint>
 
 namespace llvm {
 
 class DWARFUnit;
 class raw_ostream;
 
public:
 
   void setBlockValue(const ArrayRef<uint8_t> &Data) {
     Value.data = Data.data();
     setUValue(Data.size());
   }
 
   bool isFormClass(FormClass FC) const;
   const DWARFUnit *getUnit() const { return U; }
-  void dump(raw_ostream &OS) const;
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts = DIDumpOptions()) const;
 
   /// Extracts a value in \p Data at offset \p *OffsetPtr.
   ///
   /// The passed DWARFUnit is allowed to be nullptr, in which case some
   /// kind of forms that depend on Unit information are disallowed.
   /// \param Data The DWARFDataExtractor to use.
   /// \param OffsetPtr The offset within \p Data where the data starts.
   /// \param U The optional DWARFUnit supplying information for some forms.

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

static void dumpApplePropertyAttribute(raw_ostream &OS, uint64_t Val) {
   } while (true);
   OS << ")";
 }
 
 static void dumpRanges(raw_ostream &OS, const DWARFAddressRangesVector& Ranges,
                        unsigned AddressSize, unsigned Indent) {
   if (Ranges.empty())
     return;
-  
   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);
   }
 }
if (!DumpOpts.Brief) {
     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(";
-  
   StringRef Name;
   std::string File;
   auto Color = syntax::Enumerator;
   if (Attr == DW_AT_decl_file || Attr == DW_AT_call_file) {
     Color = syntax::String;
     if (const auto *LT = U->getContext().getLineTableForUnit(U))
       if (LT->getFileNameByIndex(formValue.getAsUnsignedConstant().getValue(), U->getCompilationDir(), DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, File)) {
         File = '"' + File + '"';
         Name = File;
       }
   } else if (Optional<uint64_t> Val = formValue.getAsUnsignedConstant())
     Name = AttributeValueString(Attr, *Val);
-  
   if (!Name.empty())
     WithColor(OS, Color) << Name;
   else if (Attr == DW_AT_decl_line || Attr == DW_AT_call_line)
     OS << *formValue.getAsUnsignedConstant();
   else
-    formValue.dump(OS);
-  
+    formValue.dump(OS, DumpOpts);
   // We have dumped the attribute raw value. For some attributes
   // having both the raw value and the pretty-printed value is
   // interesting. These attributes are handled below.
   if (Attr == DW_AT_specification || Attr == DW_AT_abstract_origin) {
     if (const char *Name = Die.getAttributeValueAsReferencedDie(Attr).getName(DINameKind::LinkageName))
         OS << " \"" << Name << '\"';
   } else if (Attr == DW_AT_APPLE_property_attribute) {
     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 {

 
 void DWARFDie::dump(raw_ostream &OS, unsigned RecurseDepth, unsigned Indent,
                     DIDumpOptions DumpOpts) const {
   if (!isValid())
     return;
   DWARFDataExtractor 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)
if (abbrCode) {
             // 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 {

llvm/lib/DebugInfo/DWARF/DWARFFormValue.cpp

if (!Str.empty()) {
       Value.data = reinterpret_cast<const uint8_t *>(Str.data());
       *OffsetPtr += Value.uval;
     }
   }
 
   return true;
 }
 
-void DWARFFormValue::dump(raw_ostream &OS) const {
+void DWARFFormValue::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
   uint64_t UValue = Value.uval;
   bool CURelativeOffset = false;
 
   switch (Form) {
   case DW_FORM_addr:
     OS << format("0x%016" PRIx64, UValue);
     break;
   case DW_FORM_GNU_addr_index: {
void DWARFFormValue::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
 
   case DW_FORM_sdata:
     OS << Value.sval;
     break;
   case DW_FORM_udata:
     OS << Value.uval;
     break;
   case DW_FORM_strp:
+    if (!DumpOpts.Brief)
       OS << format(" .debug_str[0x%8.8x] = ", (uint32_t)UValue);
+    else
+      OS << format(" .debug_str = ", (uint32_t)UValue);
     dumpString(OS);
     break;
   case DW_FORM_strx:
   case DW_FORM_strx1:
   case DW_FORM_strx2:
   case DW_FORM_strx3:
   case DW_FORM_strx4:
   case DW_FORM_GNU_str_index:
case DW_FORM_sec_offset:
     OS << format("0x%08x", (uint32_t)UValue);
     break;
 
   default:
     OS << format("DW_FORM(0x%4.4x)", Form);
     break;
   }
 
-  if (CURelativeOffset) {
+  if (CURelativeOffset && !DumpOpts.Brief) {
     OS << " => {";
     WithColor(OS, syntax::Address).get()
         << format("0x%8.8" PRIx64, UValue + (U ? U->getOffset() : 0));
     OS << "}";
   }
 }
 
 void DWARFFormValue::dumpString(raw_ostream &OS) const {