dwarfdump: Add an option to collect debug info quality metrics

[aprantl]

Summary

At the last LLVM dev meeting we had a debug info for optimized code BoF session. In that session I presented some graphs that showed how the quality of the debug info produced by LLVM changed over the last couple of years. This is a cleaned up version of the patch I used to collect the this data. It is implemented as an extension of llvm-dwarfdump, adding a new --statistics option. The intended use-case is to automatically run this on the debug info produced by, e.g., our bots, to identify eyebrow-raising changes or regressions introduced by new transformations that we could act on.

In the current form, two kinds of data are being collected:

• the number of variables that have a debug location versus the number of variables in total (this takes into account inlined instances of the same function, so if a variable is completely missing form only one instance it will be found)
• the PC range covered by variable location descriptions versus the PC range of all variables' containing lexical scopes

The output format is versioned and extensible, so I'm looking forward to both bug fixes and ideas for other data that would be interesting to track.

[dblaikie]

lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

77–78

I believe C++11 lower_bound supports heterogenous lookup, so you don't need to create a LocationList to query - you can write an asymmetric comparison (unsigned < LocationList) & use that.

I believe we use that to find a CU at an offset - the function's in DWARFContext, I think (just search for lower_bound in lib/DebugInfo/DWARF and you should find this example easily enough, probably)

80

Might be worth adding a range-based lower_bound to STLExtras.h? I think there are a few uses of std::lower_bound that could be switched to that.

82

No need for the "-> bool" here, if you want to skip it.

tools/llvm-dwarfdump/Statistics.cpp

64

Name wouldn't be unambiguous - due to shadowing?

67

Should we gather statistics on that? (honestly there might be cases where it's more efficient to describe a variable as being in one location with one address range - even though the scope has a hole in it, for example (eg: scope says [a, b)+[c,d)+[e,f) but the variable location says '[a,b) it's in register foo, [c,f) it's in register bar' - I /think/ that's probably OK to do, the debugger/consumer shouldn't consult the variable if it's looking at an instruction in [d,e), right?)

178

Worth having two formats?

It seems especially strange/uncommon to have both outputs generated in a single run and need to filter them out with different pipes - is there any precedent for that in other LLVM tools?

I'd say if, as the comment above suggests, the stats are only really interesting in comparison with stats from another run, then maybe only the machine-readable form is relevant?

193–194

that'll get rounded down, if I recall correctly - is that desirable (eg: 49.999% will render as 49% not 50%?)

196

This might not be the best statistic.

Consider code like this

void f() {
  g();
  h j = k();
  return j;
}

optimized, 'j' should never have a location range that covers the entire scope of 'f'. There's no value for 'j' during 'g()'.

So maybe it'd be necessary to track which bytes of a scope are covered by a location list, after the earliest byte in the scope that is covered.

Separately you could track this statistic (which bytes of a scope are covered by the variable) - but not expect this statistic to approach 100%.

[aprantl]

lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

77–78

I added an operator< which is not quite what you suggested, but what all the other DWARF lookups were doing.

tools/llvm-dwarfdump/Statistics.cpp

64

Yes, this doesn't handle

void f() {
  { int i = 1; }
  { int i = 2; }
}

correctly right now, and I'm also not quite sure how to fix this right now. We could give all lexical scopes unique names based on their nesting levels, but if there are two inlined instances of the same function:

void f(bool b) {
  if (b) {
    int i = 1;
  } else {
    int i = 2;
  }
}

one inlined as f(true), and one as f(false) with only one lexical block remaining in each inlined instance, I don't know how to handle that.

67

Yeah, it's not something I would collect always, but as a one-off it would be interesting. I recently fixed a bug related to this in r305599 and there's probably more opportunities.

196

This case even appears in my test case. The point of this number was to look at the delta between two compilers, and not for the ratio to ever approach 100%.
I really like the idea of only starting at the first byte of coverage though, so changed the implementation to collect number instead.

[aprantl]

Address review feedback. Thanks!

[aprantl]

Fix typo and refactor.

[aprantl]

ping.

[rnk]

You probably want to rebase this to pick up rL312042.

tools/llvm-dwarfdump/Statistics.cpp

64

Numbering the scopes reminds me of what MSVC does for name mangling static locals. I don't think it's terribly important to worry about local variable shadowing in the first iteration of this. I suspect it mostly comes up for induction variables (I and E).

[aprantl]

Rebased and addressed additional review feedback.

[aprantl]

pinging @dblaikie.

[aprantl]

In D36627#880222, @aprantl wrote:

pinging @dblaikie.

ping.

[rnk]

In D36627#888477, @aprantl wrote:

In D36627#880222, @aprantl wrote:

pinging @dblaikie.

ping.

@dblaikie is at a conference. I think we should go ahead and land this and iterate. It's a testing tool anyway. Looks good!

tools/llvm-dwarfdump/Statistics.cpp

176–177

This sentence needs editting, I think it's supposed to say, "It's impossible to reduce ..."

[aprantl]

I think we should go ahead and land this and iterate.

Yes, I would also like to point out that this is meant to be a starting point and an invitation to the community to improve / add other (hopefully even better) metrics to the tool!

include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h

 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include <cstdint>
 
 namespace llvm {
 
 class raw_ostream;
 
 class DWARFDebugLoc {
+public:
   /// A single location within a location list.
   struct Entry {
     /// The beginning address of the instruction range.
     uint64_t Begin;
     /// The ending address of the instruction range.
     uint64_t End;
     /// The location of the variable within the specified range.
     SmallVector<unsigned char, 4> Loc;
   };
 
   /// A list of locations that contain one variable.
   struct LocationList {
     /// The beginning offset where this location list is stored in the debug_loc
     /// section.
     unsigned Offset;
     /// All the locations in which the variable is stored.
     SmallVector<Entry, 2> Entries;
   };
 
   using LocationLists = SmallVector<LocationList, 4>;
 
+private:
   /// A list of all the variables in the debug_loc section, each one describing
   /// the locations in which the variable is stored.
   LocationLists Locations;
 
 public:
   /// Print the location lists found within the debug_loc section.
   void dump(raw_ostream &OS) 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);
+
+  /// Return location list entries at \c Offset.
+  const LocationList *getLocationList(unsigned Offset) const;
 };
 
 class DWARFDebugLocDWO {
   struct Entry {
     uint64_t Start;
     uint32_t Length;
     SmallVector<unsigned char, 4> Loc;
   };

lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

while (true) {
       E.Loc.append(str.begin(), str.end());
       Loc.Entries.push_back(std::move(E));
     }
   }
   if (data.isValidOffset(Offset))
     errs() << "error: failed to consume entire .debug_loc section\n";
 }
 
+const DWARFDebugLoc::LocationList *
+DWARFDebugLoc::getLocationList(unsigned Offset) const {
+  DWARFDebugLoc::LocationList Searched;
+  Searched.Offset = Offset;
+  const LocationList *List =
+      std::lower_bound(Locations.begin(), Locations.end(), Searched,
+                       [&](DWARFDebugLoc::LocationList A,
+                           DWARFDebugLoc::LocationList B) -> bool {
+                         return A.Offset < B.Offset;
+                       });
+  if (List->Offset != Offset)
+    return nullptr;
+  return List;
+}
+
 void DWARFDebugLocDWO::parse(DataExtractor data) {
   uint32_t Offset = 0;
   while (data.isValidOffset(Offset)) {
     Locations.resize(Locations.size() + 1);
     LocationList &Loc = Locations.back();
     Loc.Offset = Offset;
     dwarf::LocationListEntry Kind;
     while ((Kind = static_cast<dwarf::LocationListEntry>(

test/tools/llvm-dwarfdump/X86/statistics.ll

+; RUN: llc -O0 %s -o - -filetype=obj | llvm-dwarfdump -statistics - | FileCheck %s
+
+; int GlobalConst = 42;
+; int Global;
+;
+; struct S {
+;   static const int constant = 24;
+; } s;
+;
+; int __attribute__((always_inline)) square(int i) { return i * i; }
+; int cube(int i) {
+;   int squared = square(i);
+;   return squared*i;
+; }
+
+; GlobalConst,Global,s,s.constant,square::i,cube::i,cube::squared
+; CHECK: "unique source variables":7
+; +1 extra inline i.
+; CHECK: "source variables":8
+; -1 square::i
+; CHECK: "variables with location":7
+; CHECK: "scope bytes total":[[BYTES:[0-9]+]]
+; Because of the dbg.value in the middle of the function, the pc range coverage
+; must be below 100%.
+; CHECK-NOT: "scope bytes covered":0
+; CHECK-NOT "scope bytes covered":[[BYTES]]
+; CHECK: "scope bytes covered":
+
+; ModuleID = '/tmp/quality.cpp'
+source_filename = "/tmp/quality.cpp"
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.12.0"
+
+%struct.S = type { i8 }
+
+@GlobalConst = global i32 42, align 4, !dbg !0
+@Global = global i32 0, align 4, !dbg !6
+@s = global %struct.S zeroinitializer, align 1, !dbg !9
+
+; Function Attrs: alwaysinline nounwind ssp uwtable
+define i32 @_Z6squarei(i32 %i) #0 !dbg !20 {
+entry:
+  %i.addr = alloca i32, align 4
+  store i32 %i, i32* %i.addr, align 4
+  ; Modified to loose debug info for i here.
+  call void @llvm.dbg.declare(metadata i32* undef, metadata !23, metadata !24), !dbg !25
+  %0 = load i32, i32* %i.addr, align 4, !dbg !26
+  %1 = load i32, i32* %i.addr, align 4, !dbg !27
+  %mul = mul nsw i32 %0, %1, !dbg !28
+  ret i32 %mul, !dbg !29
+}
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+declare void @llvm.dbg.value(metadata, metadata, metadata) #1
+
+; Function Attrs: noinline nounwind optnone ssp uwtable
+define i32 @_Z4cubei(i32 %i) #2 !dbg !30 {
+entry:
+  %i.addr.i = alloca i32, align 4
+  call void @llvm.dbg.declare(metadata i32* %i.addr.i, metadata !23, metadata !24), !dbg !31
+  %i.addr = alloca i32, align 4
+  %squared = alloca i32, align 4
+  store i32 %i, i32* %i.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %i.addr, metadata !33, metadata !24), !dbg !34
+  %0 = load i32, i32* %i.addr, align 4, !dbg !37
+  store i32 %0, i32* %i.addr.i, align 4
+  %1 = load i32, i32* %i.addr.i, align 4, !dbg !38
+  %2 = load i32, i32* %i.addr.i, align 4, !dbg !39
+  %mul.i = mul nsw i32 %1, %2, !dbg !40
+  ; Modified to cover only about 50% of the lexical scope.
+  call void @llvm.dbg.value(metadata i32 %mul.i, metadata !35, metadata !24), !dbg !36
+  store i32 %mul.i, i32* %squared, align 4, !dbg !36
+  %3 = load i32, i32* %squared, align 4, !dbg !41
+  %4 = load i32, i32* %i.addr, align 4, !dbg !42
+  %mul = mul nsw i32 %3, %4, !dbg !43
+  ret i32 %mul, !dbg !44
+}
+
+attributes #0 = { alwaysinline nounwind ssp uwtable }
+attributes #1 = { nounwind readnone speculatable }
+attributes #2 = { noinline nounwind optnone ssp uwtable }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!15, !16, !17, !18}
+!llvm.ident = !{!19}
+
+!0 = !DIGlobalVariableExpression(var: !1)
+!1 = distinct !DIGlobalVariable(name: "GlobalConst", scope: !2, file: !3, line: 1, type: !8, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 6.0.0 (trunk 310529) (llvm/trunk 310534)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
+!3 = !DIFile(filename: "/tmp/quality.cpp", directory: "/Volumes/Data/llvm")
+!4 = !{}
+!5 = !{!0, !6, !9}
+!6 = !DIGlobalVariableExpression(var: !7)
+!7 = distinct !DIGlobalVariable(name: "Global", scope: !2, file: !3, line: 2, type: !8, isLocal: false, isDefinition: true)
+!8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!9 = !DIGlobalVariableExpression(var: !10)
+!10 = distinct !DIGlobalVariable(name: "s", scope: !2, file: !3, line: 6, type: !11, isLocal: false, isDefinition: true)
+!11 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "S", file: !3, line: 4, size: 8, elements: !12, identifier: "_ZTS1S")
+!12 = !{!13}
+!13 = !DIDerivedType(tag: DW_TAG_member, name: "constant", scope: !11, file: !3, line: 5, baseType: !14, flags: DIFlagStaticMember, extraData: i32 24)
+!14 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !8)
+!15 = !{i32 2, !"Dwarf Version", i32 4}
+!16 = !{i32 2, !"Debug Info Version", i32 3}
+!17 = !{i32 1, !"wchar_size", i32 4}
+!18 = !{i32 7, !"PIC Level", i32 2}
+!19 = !{!"clang version 6.0.0 (trunk 310529) (llvm/trunk 310534)"}
+!20 = distinct !DISubprogram(name: "square", linkageName: "_Z6squarei", scope: !3, file: !3, line: 8, type: !21, isLocal: false, isDefinition: true, scopeLine: 8, flags: DIFlagPrototyped, isOptimized: false, unit: !2, variables: !4)
+!21 = !DISubroutineType(types: !22)
+!22 = !{!8, !8}
+!23 = !DILocalVariable(name: "i", arg: 1, scope: !20, file: !3, line: 8, type: !8)
+!24 = !DIExpression()
+!25 = !DILocation(line: 8, column: 47, scope: !20)
+!26 = !DILocation(line: 8, column: 59, scope: !20)
+!27 = !DILocation(line: 8, column: 63, scope: !20)
+!28 = !DILocation(line: 8, column: 61, scope: !20)
+!29 = !DILocation(line: 8, column: 52, scope: !20)
+!30 = distinct !DISubprogram(name: "cube", linkageName: "_Z4cubei", scope: !3, file: !3, line: 9, type: !21, isLocal: false, isDefinition: true, scopeLine: 9, flags: DIFlagPrototyped, isOptimized: false, unit: !2, variables: !4)
+!31 = !DILocation(line: 8, column: 47, scope: !20, inlinedAt: !32)
+!32 = distinct !DILocation(line: 10, column: 17, scope: !30)
+!33 = !DILocalVariable(name: "i", arg: 1, scope: !30, file: !3, line: 9, type: !8)
+!34 = !DILocation(line: 9, column: 14, scope: !30)
+!35 = !DILocalVariable(name: "squared", scope: !30, file: !3, line: 10, type: !8)
+!36 = !DILocation(line: 10, column: 7, scope: !30)
+!37 = !DILocation(line: 10, column: 24, scope: !30)
+!38 = !DILocation(line: 8, column: 59, scope: !20, inlinedAt: !32)
+!39 = !DILocation(line: 8, column: 63, scope: !20, inlinedAt: !32)
+!40 = !DILocation(line: 8, column: 61, scope: !20, inlinedAt: !32)
+!41 = !DILocation(line: 11, column: 10, scope: !30)
+!42 = !DILocation(line: 11, column: 18, scope: !30)
+!43 = !DILocation(line: 11, column: 17, scope: !30)
+!44 = !DILocation(line: 11, column: 3, scope: !30)

tools/llvm-dwarfdump/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   DebugInfoDWARF
   Object
   Support
   )
 
 add_llvm_tool(llvm-dwarfdump
+  Statistics.cpp
   llvm-dwarfdump.cpp
   )
 
 if(LLVM_USE_SANITIZE_COVERAGE)
   add_subdirectory(fuzzer)
 endif()

tools/llvm-dwarfdump/Statistics.cpp

+#include "llvm/ADT/DenseMap.h"
+#include "llvm/DebugInfo/DIContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
+#define DEBUG_TYPE "dwarfdump"
+using namespace llvm;
+
+/// Holds statistics for one functions (or other entity that has a PC range and
+/// contains variables, such as a compile unit).
+struct StatsPerFunction {
+  /// Number of inlined instances of this function.
+  unsigned NumFnInlined = 0;
+  /// Number of variables with location across all inlined instances.
+  unsigned TotalVarWithLoc = 0;
+  /// Number of constants with location across all inlined instances.
+  unsigned ConstantMembers = 0;
+  /// List of all variables in this function.
+  SmallDenseMap<StringRef, char, 4> VarsInFunction;
+  /// Total number of PC range covered by DW_AT_locations.
+  unsigned BytesCovered = 0;
+  /// Total number of PC range bytes in the enclosing scope for each seen
+  /// variable.
+  unsigned BytesTotal = 0;
+  /// Compile units also cover a PC range, but have this flag set to false.
+  bool IsFunction = false;
+};
+
+/// Collect debug info quality metrics for one DIE.
+static void collectStatsForDie(DWARFDie Die, std::string Prefix,
+                               uint64_t BytesInScope,
+                               StringMap<StatsPerFunction> &Statistics) {
+  bool HasLoc = false;
+  unsigned BytesCovered = 0;
+  if (Die.find(dwarf::DW_AT_const_value)) {
+    // This catches constant members *and* variables.
+    HasLoc = true;
+    BytesCovered = BytesInScope;
+  } else if (Die.getTag() == dwarf::DW_TAG_variable ||
+             Die.getTag() == dwarf::DW_TAG_formal_parameter) {
+    // Handle variables and function arguments.
+    auto FormValue = Die.find(dwarf::DW_AT_location);
+    HasLoc = FormValue.hasValue();
+    if (HasLoc) {
+      // Get PC coverage.
+      if (auto DebugLocOffset = FormValue->getAsSectionOffset()) {
+        auto *DebugLoc = Die.getDwarfUnit()->getContext().getDebugLoc();
+        if (auto List = DebugLoc->getLocationList(*DebugLocOffset))
+          for (auto Entry : List->Entries)
+            BytesCovered += Entry.End - Entry.Begin;
+        assert(BytesInScope);
+      } else {
+        // Assume the entire range is covered by a single location.
+        BytesCovered = BytesInScope;
+      }
+    }
+  } else {
+    // Not a variable or constant member.
+    return;
+  }
+
+  // Collect PC range coverage data.
+  const char *Name = Die.getName(DINameKind::ShortName);
+  auto &Stats = Statistics[Prefix];
+  Stats.VarsInFunction.insert({Name, 0});
+  if (BytesInScope) {
+    Stats.TotalVarWithLoc += (unsigned)HasLoc;
+    // Turns out we have a lot of ranges that extend past the lexical scope.
+    Stats.BytesCovered += std::min<uint64_t>(BytesInScope, BytesCovered);
+    Stats.BytesTotal += BytesInScope;
+  } else {
+    Stats.ConstantMembers++;
+  }
+}
+
+/// Recursively collect debug info quality metrics.
+static void collectStatsRecursive(DWARFDie Die, std::string Prefix,
+                                  uint64_t BytesInScope,
+                                  StringMap<StatsPerFunction> &Statistics) {
+  // Handle any kind of lexical scope.
+  if (Die.getTag() == dwarf::DW_TAG_subprogram ||
+      Die.getTag() == dwarf::DW_TAG_inlined_subroutine ||
+      Die.getTag() == dwarf::DW_TAG_lexical_block) {
+    // Ignore forward declarations.
+    if (Die.find(dwarf::DW_AT_declaration))
+      return;
+
+    // Count the function.
+    if (Die.getTag() != dwarf::DW_TAG_lexical_block) {
+      StringRef Name = Die.getName(DINameKind::LinkageName);
+      if (Name.empty())
+        Name = Die.getName(DINameKind::ShortName);
+      Prefix = Name;
+      // Skip over abstract origins.
+      if (Die.find(dwarf::DW_AT_inline))
+        return;
+      // We've seen an (inlined) instance of this function.
+      auto &Stats = Statistics[Name];
+      Stats.NumFnInlined++;
+      Stats.IsFunction = true;
+    }
+
+    // PC Ranges.
+    auto Ranges = Die.getAddressRanges();
+    uint64_t BytesInThisScope = 0;
+    for (auto Range : Ranges)
+      BytesInThisScope += Range.HighPC - Range.LowPC;
+    if (BytesInThisScope)
+      BytesInScope = BytesInThisScope;
+  } else {
+    // Not a scope, visit the Die itself. It could be a variable.
+    collectStatsForDie(Die, Prefix, BytesInScope, Statistics);
+  }
+
+  // Traverse children.
+  DWARFDie Child = Die.getFirstChild();
+  while (Child) {
+    collectStatsRecursive(Child, Prefix, BytesInScope, Statistics);
+    Child = Child.getSibling();
+  }
+}
+
+/// Print machine-readable to stdout, human-readable to stderr.
+/// The machine-readable format is single-line JSON output.
+/// \{
+static void printDatum(const char* Key, StringRef Value) {
+  llvm::outs() << ",\"" << Key << "\":" << Value << "\"";
+  llvm::errs() << Key << ": " << Value << '\n';
+}
+static void printDatum(const char* Key, uint64_t Value) {
+  llvm::outs() << ",\"" << Key << "\":" << Value << '"';
+  llvm::errs() << Key << ": " << Value << '\n';
+}
+/// \}
+
+
+/// Collect debug info quality metrics for an entire DIContext.
+///
+/// Do the impossible and reduce the quality of the debug info down to a few
+/// numbers. The idea is to condense the data into numbers that can be tracked
+/// over time to identify trends in newer compiler versions and gauge the effect
+/// of particular optimizations. The raw numbers themselves are not particularly
+/// useful, only the delta between compiling the same program with different
+/// compilers is.
+void collectStats(DIContext &DICtx, StringRef Filename, StringRef FormatName) {
+  StringMap<StatsPerFunction> Statistics;
+  for (const auto &CU : static_cast<DWARFContext *>(&DICtx)->compile_units())
+    if (DWARFDie CUDie = CU->getUnitDIE(false))
+      collectStatsRecursive(CUDie, "/", 0, Statistics);
+
+  /// 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 = 1;
+  unsigned VarTotal = 0;
+  unsigned VarUnique = 0;
+  unsigned VarWithLoc = 0;
+  uint64_t ScopeBytesTotal = 0;
+  uint64_t ScopeBytesCovered = 0;
+  unsigned NumFunctions = 0;
+  unsigned NumInlinedFunctions = 0;
+  for (auto &Entry : Statistics) {
+    StatsPerFunction &Stats = Entry.getValue();
+    unsigned TotalVars = Stats.VarsInFunction.size() * Stats.NumFnInlined;
+    unsigned Constants = Stats.ConstantMembers;
+    VarWithLoc += Stats.TotalVarWithLoc + Constants;
+    VarTotal += TotalVars + Constants;
+    VarUnique += Stats.VarsInFunction.size();
+    DEBUG(
+      for (auto V : Stats.VarsInFunction)
+        llvm::dbgs() << Entry.getKey() << ": " << V.first << "\n"
+    );
+    ScopeBytesCovered += Stats.BytesCovered;
+    ScopeBytesTotal += Stats.BytesTotal;
+    NumFunctions += Stats.IsFunction;
+    NumInlinedFunctions += Stats.IsFunction * Stats.NumFnInlined;
+  }
+
+  // Print summary: Machine-readable to stdout, human-readable to stderr.
+  llvm::outs().SetBufferSize(1024);
+  llvm::outs() << "{\"version\":\"" << Version << '"';
+  llvm::errs() << "Variable location quality metrics\n";
+  llvm::errs() << "---------------------------------\n";
+  printDatum("file", Filename);
+  printDatum("format", FormatName);
+  printDatum("source functions", NumFunctions);
+  printDatum("inlined functions", NumInlinedFunctions);
+  printDatum("unique source variables", VarUnique);
+  printDatum("source variables", VarTotal);
+  printDatum("variables with location", VarWithLoc);
+  printDatum("scope bytes total", ScopeBytesTotal);
+  printDatum("scope bytes covered", ScopeBytesCovered);
+  llvm::outs() << "}\n";
+  llvm::errs() << "Total Availability: " << (VarWithLoc * 100) / VarTotal
+               << "%\n";
+  llvm::errs() << "PC Ranges covered: "
+               << (ScopeBytesCovered * 100) / ScopeBytesTotal << "%\n";
+  return;
+}

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

 
 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("Print fewer low-level details"));
 
+static cl::opt<bool>
+    Statistics("statistics", cl::desc("Print debug info quality statistics"));
+
 static void error(StringRef Filename, std::error_code EC) {
   if (!EC)
     return;
   errs() << Filename << ": " << EC.message() << "\n";
   exit(1);
 }
 
+void collectStats(DIContext &DICtx, StringRef Filename, StringRef FormatName);
+
 static void DumpObjectFile(ObjectFile &Obj, Twine Filename) {
   std::unique_ptr<DIContext> DICtx = DWARFContext::create(Obj);
+  if (Statistics)
+    return collectStats(*DICtx, Filename.str(), Obj.getFileFormatName());
 
+  // Dump the complete DWARF structure.
   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) {