WIP: [DWARF] Collect statistics for DW_OP_entry_value

[vsk]

Summary

It might be interesting to see how many parameters with entry_value locations there are compared to how many parameters-with-location there are overall.

I can clean up this patch and push it forward if there's general interest. Here are some numbers from a stage2 RelAsserts build of clang.

~/src/builds/llvm-project-master-stage2-RA (0) $ ../llvm-project-master-RA/bin/llvm-dwarfdump --statistics ./bin/clang.dSYM | ppjson
{ 'call site entries': 6113835,
  'file':  'bin/clang.dSYM/Contents/Resources/DWARF/clang',
  'formal params with binary location': 5928235,
  'formal params with binary location containing entry value': 0,
  'formal params with source location': 4200769,
  'formal params with type': 8436986,
  'format':  'Mach-O 64-bit x86-64',
  'inlined funcs with abstract origins': 5859344,
  'inlined functions': 5859344,
  'scope bytes covered': 563026378,
  'scope bytes total': 969630990,
  'source functions': 468524,
  'source functions with location': 468075,
  'source variables': 10246465,
  'total formal params': 8436986,
  'total function size': 65502932,
  'total inlined function size': 48065586,
  'total vars': 1142370,
  'unique source variables': 1408162,
  'variables with location': 6751342,
  'vars with binary location': 710703,
  'vars with source location': 1059166,
  'vars with type': 1142370,
  'version': 3}

(with -femit-debug-entry-values)
~/src/builds/param-entry-vals-stage2 (0) $ ../llvm-project-master-RA/bin/llvm-dwarfdump --statistics ./bin/clang.dSYM | ppjson
{ 'call site entries': 6471968,
  'file':  'bin/clang.dSYM/Contents/Resources/DWARF/clang',
  'formal params with binary location': 5928218,
  'formal params with binary location containing entry value': 70017,
  'formal params with source location': 4200754,
  'formal params with type': 8437413,
  'format':  'Mach-O 64-bit x86-64',
  'inlined funcs with abstract origins': 5859331,
  'inlined functions': 5859331,
  'scope bytes covered': 580573865,
  'scope bytes total': 969629704,
  'source functions': 468520,
  'source functions with location': 468071,
  'source variables': 10246437,
  'total formal params': 8437413,
  'total function size': 65502621,
  'total inlined function size': 48065442,
  'total vars': 1142364,
  'unique source variables': 1408152,
  'variables with location': 6751217,
  'vars with binary location': 710704,
  'vars with source location': 1059160,
  'vars with type': 1142364,
  'version': 3}

[djtodoro]

@vsk Thanks for this! We have discussed about this on the other threads and the stats is useful for sure!
Having this stats gives us info about the "normal" (non-entry values) debug location coverage, because those locations with the entry value are useless if do not have proper call_site and call_site_paramters debug information generated in the .debug_info section.

WDYT about having a separate tool that will calculate and report more (verbose) info about the debug location coverage? I have already mentioned it on the D58042 and the link of the 'WIP' of the tool is https://github.com/djolertrk/llvm-locstats.
We can play with that and add more options we found useful for us.

[vsk]

In D65178#1598514, @djtodoro wrote:

@vsk Thanks for this! We have discussed about this on the other threads and the stats is useful for sure!
Having this stats gives us info about the "normal" (non-entry values) debug location coverage, because those locations with the entry value are useless if do not have proper call_site and call_site_paramters debug information generated in the .debug_info section.

WDYT about having a separate tool that will calculate and report more (verbose) info about the debug location coverage? I have already mentioned it on the D58042 and the link of the 'WIP' of the tool is https://github.com/djolertrk/llvm-locstats.
We can play with that and add more options we found useful for us.

Thanks for the link. I’ll set this patch aside for now. Maybe any relevant parts can be folded into the locstats tool later.

Copying some discussion with Eric about the goals of this:

On Jul 23, 2019, at 9:31 PM, Eric Christopher wrote:

I guess? I'm curious what we'd get out of it in general? Is the
thought that we could try to classify how often we have to do more
work to recover parameters? Not against it, just trying to see why :)

Vedant:
I’d like to get the percentage of parameters guaranteed to have an available location.

I think this should correlate with backtrace quality (if not, that’s interesting too, maybe it means the debugger has bugs).

Counting entry_value descriptions is a starting point, but I think you’d need to check that the ranges in a parameter location description span the whole function to finish the patch.

As-is, I thought “# entry values” could be fun to look at as the callsiteparam work lands.

[djtodoro]

@vsk IIUC, you think the tool will be useful ? :)

I’ll set this patch aside for now.

I think the goal of this patch is desirable for sure. In addition, I am not opposed to coexisting of this kind of stats within both of the llvm-dwarfdump and llvm-locstats, but that can be a point of discussion.

Maybe any relevant parts can be folded into the locstats tool later.

Thanks! Those parts can be folded for sure! Just to mention, currently, there is an option in the llvm-locstats tool (--ignore-entry-values) that reports the debug location coverage by ignoring the debug entry values.

[vsk]

In D65178#1600664, @djtodoro wrote:

@vsk IIUC, you think the tool will be useful ? :)

I’ll set this patch aside for now.

I think the goal of this patch is desirable for sure. In addition, I am not opposed to coexisting of this kind of stats within both of the llvm-dwarfdump and llvm-locstats, but that can be a point of discussion.

Maybe any relevant parts can be folded into the locstats tool later.

Thanks! Those parts can be folded for sure! Just to mention, currently, there is an option in the llvm-locstats tool (--ignore-entry-values) that reports the debug location coverage by ignoring the debug entry values.

Thanks, that's perfect. I was looking for something just like 'llvm-locstats -only-formal-parameters [-ignore-entry-values]'. I'd love to see this functionality upstream eventually (maybe as a dwarfdump subtool?).

[djtodoro]

@vsk Thanks! As soon as we re-land the callsiteparam work I will start cleaning up the code and up streaming it!

There are options to look only for parameters or local variables. The help output:

llvm-locstats --help
...

Specific Options:

 --ignore-entry-values    - Ignore the location statistics on locations with entry values.
 --ignore-inlined         - Ignore the location statistics on inlined instances.
 --only-formal-parameters - Calculate the location statistics only for formal parameters.
 --only-variables         - Calculate the location statistics only for local variables.

...

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

 #define LLVM_DEBUGINFO_DWARFEXPRESSION_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/DataExtractor.h"
 
 namespace llvm {
+struct DWARFAttribute;
+class DWARFContext;
 class DWARFUnit;
 class MCRegisterInfo;
 class raw_ostream;
 
 class DWARFExpression {
 public:
   class iterator;
 
public:
     friend bool operator==(const iterator &, const iterator &);
   };
 
   DWARFExpression(DataExtractor Data, uint16_t Version, uint8_t AddressSize)
       : Data(Data), Version(Version), AddressSize(AddressSize) {
     assert(AddressSize == 8 || AddressSize == 4 || AddressSize == 2);
   }
 
+  /// Form DWARFExpression objects by parsing a DW_AT_location attribute and
+  /// pass them into a visitor function.
+  static void visitExpressionsInLocation(const DWARFAttribute &Location,
+                                         DWARFUnit &U, DWARFContext &DCtx,
+                                         function_ref<void(DWARFExpression)> F);
+
   iterator begin() const { return iterator(this, 0); }
   iterator end() const { return iterator(this, Data.getData().size()); }
 
   void print(raw_ostream &OS, const MCRegisterInfo *RegInfo, DWARFUnit *U,
              bool IsEH = false) const;
 
   bool verify(DWARFUnit *U);
 

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

 //===-- DWARFExpression.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/Support/Format.h"
 #include <cassert>
 #include <cstdint>
 #include <vector>
for (unsigned Operand = 0; Operand < 2; ++Operand) {
 
     OperandEndOffsets[Operand] = Offset;
   }
 
   EndOffset = Offset;
   return true;
 }
 
+void DWARFExpression::visitExpressionsInLocation(
+    const DWARFAttribute &Location, DWARFUnit &U, DWARFContext &DCtx,
+    function_ref<void(DWARFExpression)> F) {
+  assert(Location.Attr == DW_AT_location && "Attribute isn't a location");
+  auto Visit = [&](StringRef D) {
+    DataExtractor Data(D, DCtx.isLittleEndian(), 0);
+    F(DWARFExpression(Data, U.getVersion(), U.getAddressByteSize()));
+  };
+  if (Optional<ArrayRef<uint8_t>> Expr = Location.Value.getAsBlock()) {
+    // Visit inlined locations.
+    Visit(llvm::toStringRef(*Expr));
+  } else if (auto LocOffset = Location.Value.getAsSectionOffset()) {
+    // Visit location lists.
+    if (auto DebugLoc = DCtx.getDebugLoc())
+      if (auto LocList = DebugLoc->getLocationListAtOffset(*LocOffset))
+        for (const auto &Entry : LocList->Entries)
+          Visit({Entry.Loc.data(), Entry.Loc.size()});
+  }
+}
+
 static bool prettyPrintRegisterOp(raw_ostream &OS, uint8_t Opcode,
                                   uint64_t Operands[2],
                                   const MCRegisterInfo *MRI, bool isEH) {
   if (!MRI)
     return false;
 
   uint64_t DwarfRegNum;
   unsigned OpNum = 0;

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

if (auto SectionOffset = AttrValue.Value.getAsSectionOffset()) {
       if (*SectionOffset >= DObj.getLineSection().Data.size())
         ReportError("DW_AT_stmt_list offset is beyond .debug_line bounds: " +
                     llvm::formatv("{0:x8}", *SectionOffset));
       break;
     }
     ReportError("DIE has invalid DW_AT_stmt_list encoding:");
     break;
   case DW_AT_location: {
-    auto VerifyLocationExpr = [&](StringRef D) {
-      DWARFUnit *U = Die.getDwarfUnit();
-      DataExtractor Data(D, DCtx.isLittleEndian(), 0);
-      DWARFExpression Expression(Data, U->getVersion(),
-                                 U->getAddressByteSize());
+    auto VerifyLocationExpr = [&](DWARFExpression Expression) {
       bool Error = llvm::any_of(Expression, [](DWARFExpression::Operation &Op) {
         return Op.isError();
       });
       if (Error || !Expression.verify(U))
         ReportError("DIE contains invalid DWARF expression:");
     };
-    if (Optional<ArrayRef<uint8_t>> Expr = AttrValue.Value.getAsBlock()) {
-      // Verify inlined location.
-      VerifyLocationExpr(llvm::toStringRef(*Expr));
-    } else if (auto LocOffset = AttrValue.Value.getAsSectionOffset()) {
-      // Verify location list.
-      if (auto DebugLoc = DCtx.getDebugLoc())
-        if (auto LocList = DebugLoc->getLocationListAtOffset(*LocOffset))
-          for (const auto &Entry : LocList->Entries)
-            VerifyLocationExpr({Entry.Loc.data(), Entry.Loc.size()});
-    }
+    DWARFExpression::visitExpressionsInLocation(AttrValue, *U, DCtx,
+                                                VerifyLocationExpr);
     break;
   }
   case DW_AT_specification:
   case DW_AT_abstract_origin: {
     if (auto ReferencedDie = Die.getAttributeValueAsReferencedDie(Attr)) {
       auto DieTag = Die.getTag();
       auto RefTag = ReferencedDie.getTag();
       if (DieTag == RefTag)

llvm/tools/llvm-dwarfdump/Statistics.cpp

struct PerFunctionStats {
   /// Number of function parameters.
   unsigned NumParams = 0;
   /// Number of function parameters with source location.
   unsigned NumParamSourceLocations = 0;
   /// Number of function parameters with type.
   unsigned NumParamTypes = 0;
   /// Number of function parameters with a DW_AT_location.
   unsigned NumParamLocations = 0;
+  /// Number of function parameters with a DW_AT_location containing a
+  /// DW_OP_entry_value description (or the GNU equivalent).
+  unsigned NumParamLocationsWithEntryVal = 0;
   /// Number of variables.
   unsigned NumVars = 0;
   /// Number of variables with source location.
   unsigned NumVarSourceLocations = 0;
   /// Number of variables wtih type.
   unsigned NumVarTypes = 0;
   /// Number of variables wtih DW_AT_location.
   unsigned NumVarLocations = 0;
static uint64_t getLowPC(DWARFDie Die) {
   return dwarf::toAddress(Die.find(dwarf::DW_AT_low_pc), 0);
 }
 
 /// Collect debug info quality metrics for one DIE.
 static void collectStatsForDie(DWARFDie Die, std::string FnPrefix,
                                std::string VarPrefix, uint64_t ScopeLowPC,
                                uint64_t BytesInScope, uint32_t InlineDepth,
                                StringMap<PerFunctionStats> &FnStatMap,
-                               GlobalStats &GlobalStats) {
+                               GlobalStats &GlobalStats, DWARFContext &DICtx) {
   bool HasLoc = false;
   bool HasSrcLoc = false;
   bool HasType = false;
   bool IsArtificial = false;
   uint64_t BytesCovered = 0;
   uint64_t OffsetToFirstDefinition = 0;
 
   if (Die.getTag() == dwarf::DW_TAG_call_site) {
static void collectStatsForDie(DWARFDie Die, std::string FnPrefix,
   }
   if (!IsArtificial) {
     if (Die.getTag() == dwarf::DW_TAG_formal_parameter) {
       FnStats.NumParams++;
       if (HasType)
         FnStats.NumParamTypes++;
       if (HasSrcLoc)
         FnStats.NumParamSourceLocations++;
-      if (HasLoc)
+      if (HasLoc) {
         FnStats.NumParamLocations++;
+
+        bool HasEntryVal = false;
+        auto SearchForEntryVal = [&](DWARFExpression Expression) {
+          if (HasEntryVal)
+            return;
+          HasEntryVal =
+              llvm::any_of(Expression, [](DWARFExpression::Operation &Op) {
+                return Op.getCode() == dwarf::DW_OP_GNU_entry_value ||
+                       Op.getCode() == dwarf::DW_OP_entry_value;
+              });
+        };
+
+        DWARFUnit &U = *Die.getDwarfUnit();
+        for (const DWARFAttribute &Attr : Die.attributes()) {
+          if (Attr.Attr == dwarf::DW_AT_location) {
+            DWARFExpression::visitExpressionsInLocation(Attr, U, DICtx,
+                                                        SearchForEntryVal);
+            if (HasEntryVal) {
+              FnStats.NumParamLocationsWithEntryVal++;
+              break;
+            }
+          }
+        }
+      }
     } else if (Die.getTag() == dwarf::DW_TAG_variable) {
       FnStats.NumVars++;
       if (HasType)
         FnStats.NumVarTypes++;
       if (HasSrcLoc)
         FnStats.NumVarSourceLocations++;
       if (HasLoc)
         FnStats.NumVarLocations++;
     }
   }
 }
 
 /// Recursively collect debug info quality metrics.
 static void collectStatsRecursive(DWARFDie Die, std::string FnPrefix,
                                   std::string VarPrefix, uint64_t ScopeLowPC,
                                   uint64_t BytesInScope, uint32_t InlineDepth,
                                   StringMap<PerFunctionStats> &FnStatMap,
-                                  GlobalStats &GlobalStats) {
+                                  GlobalStats &GlobalStats,
+                                  DWARFContext &DICtx) {
   // Handle any kind of lexical scope.
   const dwarf::Tag Tag = Die.getTag();
   const bool IsFunction = Tag == dwarf::DW_TAG_subprogram;
   const bool IsBlock = Tag == dwarf::DW_TAG_lexical_block;
   const bool IsInlinedFunction = Tag == dwarf::DW_TAG_inlined_subroutine;
   if (IsFunction || IsInlinedFunction || IsBlock) {
 
     // Reset VarPrefix when entering a new function.
if (BytesInThisScope) {
       if (IsFunction)
         GlobalStats.FunctionSize += BytesInThisScope;
       else if (IsInlinedFunction && InlineDepth == 0)
         GlobalStats.InlineFunctionSize += BytesInThisScope;
     }
   } else {
     // Not a scope, visit the Die itself. It could be a variable.
     collectStatsForDie(Die, FnPrefix, VarPrefix, ScopeLowPC, BytesInScope,
-                       InlineDepth, FnStatMap, GlobalStats);
+                       InlineDepth, FnStatMap, GlobalStats, DICtx);
   }
 
   // Set InlineDepth correctly for child recursion
   if (IsFunction)
     InlineDepth = 0;
   else if (IsInlinedFunction)
     ++InlineDepth;
 
   // Traverse children.
   unsigned LexicalBlockIndex = 0;
   DWARFDie Child = Die.getFirstChild();
   while (Child) {
     std::string ChildVarPrefix = VarPrefix;
     if (Child.getTag() == dwarf::DW_TAG_lexical_block)
       ChildVarPrefix += toHex(LexicalBlockIndex++) + '.';
 
     collectStatsRecursive(Child, FnPrefix, ChildVarPrefix, ScopeLowPC,
-                          BytesInScope, InlineDepth, FnStatMap, GlobalStats);
+                          BytesInScope, InlineDepth, FnStatMap, GlobalStats,
+                          DICtx);
     Child = Child.getSibling();
   }
 }
 
 /// Print machine-readable output.
 /// The machine-readable format is single-line JSON output.
 /// \{
 static void printDatum(raw_ostream &OS, const char *Key, StringRef Value) {

 /// compilers is.
 bool collectStatsForObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
                                Twine Filename, raw_ostream &OS) {
   StringRef FormatName = Obj.getFileFormatName();
   GlobalStats GlobalStats;
   StringMap<PerFunctionStats> Statistics;
   for (const auto &CU : static_cast<DWARFContext *>(&DICtx)->compile_units())
     if (DWARFDie CUDie = CU->getNonSkeletonUnitDIE(false))
-      collectStatsRecursive(CUDie, "/", "g", 0, 0, 0, Statistics, GlobalStats);
+      collectStatsRecursive(CUDie, "/", "g", 0, 0, 0, Statistics, GlobalStats,
+                            DICtx);
 
   /// The version number should be increased every time the algorithm is changed
   /// (including bug fixes). New metrics may be added without increasing the
   /// version.
   unsigned Version = 3;
   unsigned VarParamTotal = 0;
   unsigned VarParamUnique = 0;
   unsigned VarParamWithLoc = 0;
   unsigned NumFunctions = 0;
   unsigned NumInlinedFunctions = 0;
   unsigned NumFuncsWithSrcLoc = 0;
   unsigned NumAbstractOrigins = 0;
   unsigned ParamTotal = 0;
   unsigned ParamWithType = 0;
   unsigned ParamWithLoc = 0;
+  unsigned ParamWithEntryValLoc = 0;
   unsigned ParamWithSrcLoc = 0;
   unsigned VarTotal = 0;
   unsigned VarWithType = 0;
   unsigned VarWithSrcLoc = 0;
   unsigned VarWithLoc = 0;
   for (auto &Entry : Statistics) {
     PerFunctionStats &Stats = Entry.getValue();
     unsigned TotalVars = Stats.VarsInFunction.size() * Stats.NumFnInlined;
LLVM_DEBUG(for (auto &V
                << Entry.getKey() << ": " << V.getKey() << "\n");
     NumFunctions += Stats.IsFunction;
     NumFuncsWithSrcLoc += Stats.HasSourceLocation;
     NumInlinedFunctions += Stats.IsFunction * Stats.NumFnInlined;
     NumAbstractOrigins += Stats.IsFunction * Stats.NumAbstractOrigins;
     ParamTotal += Stats.NumParams;
     ParamWithType += Stats.NumParamTypes;
     ParamWithLoc += Stats.NumParamLocations;
+    ParamWithEntryValLoc += Stats.NumParamLocationsWithEntryVal;
     ParamWithSrcLoc += Stats.NumParamSourceLocations;
     VarTotal += Stats.NumVars;
     VarWithType += Stats.NumVarTypes;
     VarWithLoc += Stats.NumVarLocations;
     VarWithSrcLoc += Stats.NumVarSourceLocations;
   }
 
   // Print summary.
printDatum(OS, "scope bytes total",
              GlobalStats.ScopeBytesFromFirstDefinition);
   printDatum(OS, "scope bytes covered", GlobalStats.ScopeBytesCovered);
   printDatum(OS, "total function size", GlobalStats.FunctionSize);
   printDatum(OS, "total inlined function size", GlobalStats.InlineFunctionSize);
   printDatum(OS, "total formal params", ParamTotal);
   printDatum(OS, "formal params with source location", ParamWithSrcLoc);
   printDatum(OS, "formal params with type", ParamWithType);
   printDatum(OS, "formal params with binary location", ParamWithLoc);
+  printDatum(OS, "formal params with binary location containing entry value",
+             ParamWithEntryValLoc);
   printDatum(OS, "total vars", VarTotal);
   printDatum(OS, "vars with source location", VarWithSrcLoc);
   printDatum(OS, "vars with type", VarWithType);
   printDatum(OS, "vars with binary location", VarWithLoc);
   OS << "}\n";
   LLVM_DEBUG(
       llvm::dbgs() << "Total Availability: "
                    << (int)std::round((VarParamWithLoc * 100.0) / VarParamTotal)
                    << "%\n";
       llvm::dbgs() << "PC Ranges covered: "
                    << (int)std::round((GlobalStats.ScopeBytesCovered * 100.0) /
                                       GlobalStats.ScopeBytesFromFirstDefinition)
                    << "%\n");
   return true;
 }