[DebugInfo] Show implicit_const values when dumping .debug_info section

[vleschuk]

Summary

r296253 (http://llvm.org/viewvc/llvm-project?view=revision&revision=296253) introduced incorrect behavior: implicit_const values were skipped when dumping .debug_info section. This patch makes behavior similar to DW_FORM_flag_present: attribute values for such forms are shown in .debug_info output in spite of the fact they are not really present in this section.

Also modified implicit-const-test to check both .debug_abbrev and .debug_info sections.

[dblaikie]

lib/DebugInfo/DWARF/DWARFDie.cpp

94–95

I wouldn't expect to see a special case here. Is it necessary? I'd expect extractValue to do the work necessary for whatever the attribute kind is (as it already does for form_present, I assume).

I guess the issue is that DWARFFormValue only holds the form enum, not the rest - I think that probably should be changed so that extractValue can still behave uniformly across all forms.

So DWARFFormValue should take the AttributeSpec... oh, but that has the attribute in it.

Maybe what's needed is a thing that represents the form +ByteSizeOrValue. Maybe it could be called "FormSpec" to match "AttributeSpec"? Not sure.

[vleschuk]

lib/DebugInfo/DWARF/DWARFDie.cpp

94–95

I guess the issue is that DWARFFormValue only holds the form enum, not the rest - I think that probably should be changed so that extractValue can still behave uniformly across all forms.

Actually DWARFFormValue holds not only enum but actual value too:

struct ValueType {                                                            
  ValueType() {                                                               
    uval = 0;                                                                 
  }                                                                           
                                                                              
  union {                                                                     
    uint64_t uval;                                                            
    int64_t sval;                                                             
    const char* cstr;                                                         
  };                                                                          
  const uint8_t* data = nullptr;                                              
};                                                                            
                                                                              
dwarf::Form Form; // Form for this value.                                     
ValueType Value; // Contains all data for the form.                             struct ValueType {                                                            
  ValueType() {                                                               
    uval = 0;                                                                 
  }                                                                           
                                                                              
  union {                                                                     
    uint64_t uval;                                                            
    int64_t sval;                                                             
    const char* cstr;                                                         
  };                                                                          
  const uint8_t* data = nullptr;                                              
};                                                                            
                                                                              
dwarf::Form Form; // Form for this value.                                     
ValueType Value; // Contains all data for the form.                           
struct ValueType {                                                            
  ValueType() {                                                               
    uval = 0;                                                                 
  }                                                                           
                                                                              
  union {                                                                     
    uint64_t uval;                                                            
    int64_t sval;                                                             
    const char* cstr;                                                         
  };                                                                          
  const uint8_t* data = nullptr;                                              
};                                                                            
                                                                              
dwarf::Form Form; // Form for this value.                                     
ValueType Value; // Contains all data for the form.

What extractValue() does - it actually fills the ValueType field of DWARFFormValue, for flag_present it just sets Value to "true" and doesn't need additional data. To fill in implicit_const from inside of extractValue() we need to pass the actual value to it and than assign it from within:

formValue.extractValue(/* ... */, int64_t actualValue);
// ... 
bool DWARFFormValue::extractValue(/* ... */, int64_t actualValue) {
  // ....
  case DW_FORM_implicit_const:
  Value.sdata = actualValue;
  break;
  // ...

That looks a little bit weird for me, as lots of useless actions are performed like passing data back and forth. I think having exceptional case for implicit_const in upper stack frame is better way here.

lib/DebugInfo/DWARF/DWARFDie.cpp

for (const auto &Range: Ranges) {
     OS.indent(Indent);
     OS << format("[0x%0*" PRIx64 " - 0x%0*" PRIx64 ")",
                  AddressSize*2, Range.first,
                  AddressSize*2, Range.second);
   }
 }
 
 static void dumpAttribute(raw_ostream &OS, const DWARFDie &Die,
-                          uint32_t *OffsetPtr, dwarf::Attribute Attr,
-                          dwarf::Form Form, unsigned Indent) {
+                          uint32_t *OffsetPtr,
+                          const DWARFAbbreviationDeclaration::AttributeSpec &AS,
+                          unsigned Indent) {
   if (!Die.isValid())
     return;
   const char BaseIndent[] = "            ";
   OS << BaseIndent;
   OS.indent(Indent+2);
+  const auto Attr = AS.Attr;
+  const auto Form = AS.Form;
   auto attrString = AttributeString(Attr);
   if (!attrString.empty())
     WithColor(OS, syntax::Attribute) << attrString;
   else
     WithColor(OS, syntax::Attribute).get() << format("DW_AT_Unknown_%x", Attr);
   
   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))
+  if (AS.isImplicitConst())
+    formValue.setSValue(*AS.ByteSizeOrValue);
+  else 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) {
if (abbrCode) {
         else
           WithColor(OS, syntax::Tag).get().indent(Indent)
           << format("DW_TAG_Unknown_%x", getTag());
         
         OS << format(" [%u] %c\n", abbrCode,
                      AbbrevDecl->hasChildren() ? '*' : ' ');
         
         // 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);
-        }
+        for (const auto &AttrSpec : AbbrevDecl->attributes())
+          dumpAttribute(OS, *this, &offset, AttrSpec, Indent);
         
         DWARFDie child = getFirstChild();
         if (RecurseDepth > 0 && child) {
           while (child) {
             child.dump(OS, RecurseDepth-1, Indent+2);
             child = child.getSibling();
           }
         }

lib/DebugInfo/DWARF/DWARFFormValue.cpp

if (uvalue > 0) {
           ++data_ptr;
         }
       }
       else
         OS << "NULL";
     }
     break;
 
+  case DW_FORM_implicit_const:
   case DW_FORM_sdata:     OS << Value.sval; break;
   case DW_FORM_udata:     OS << Value.uval; break;
   case DW_FORM_strp:
     OS << format(" .debug_str[0x%8.8x] = ", (uint32_t)uvalue);
     dumpString(OS);
     break;
   case DW_FORM_GNU_str_index:
     OS << format(" indexed (%8.8x) string = ", (uint32_t)uvalue);

test/DebugInfo/dwarfdump-implicit-const.test

-RUN: llvm-dwarfdump -debug-dump=abbrev %p/Inputs/implicit-const-test.o | FileCheck %s
-CHECK: DW_FORM_implicit_const -9223372036854775808
+RUN: llvm-dwarfdump -debug-dump=abbrev.dwo %p/Inputs/implicit-const-test.dwo | FileCheck --check-prefix=ABBREV-CHECK %s
+RUN: llvm-dwarfdump -debug-dump=info.dwo %p/Inputs/implicit-const-test.dwo | FileCheck --check-prefix=INFO-CHECK %s
+ABBREV-CHECK: DW_FORM_implicit_const
+ABBREV-CHECK-SAME: -9223372036854775808
+INFO-CHECK: [DW_FORM_implicit_const]
+INFO-CHECK-SAME: (-9223372036854775808)