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

123–124

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)

126

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.

128

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

tools/llvm-dwarfdump/Statistics.cpp

65

Name wouldn't be unambiguous - due to shadowing?

68

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?)

179

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?

194–195

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

197

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

123–124

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

65

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.

68

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.

197

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

65

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

175–176

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/ADT/STLExtras.h

 
 /// Provide wrappers to std::partition which take ranges instead of having to
 /// pass begin/end explicitly.
 template <typename R, typename UnaryPredicate>
 auto partition(R &&Range, UnaryPredicate P) -> decltype(std::begin(Range)) {
   return std::partition(std::begin(Range), std::end(Range), P);
 }
 
+/// Provide wrappers to std::lower_bound which take ranges instead of having to
+/// pass begin/end explicitly.
+template <typename R, typename ForwardIt>
+auto lower_bound(R &&Range, ForwardIt I) -> decltype(std::begin(Range)) {
+  return std::lower_bound(std::begin(Range), std::end(Range), I);
+}
+
 /// \brief Given a range of type R, iterate the entire range and return a
 /// SmallVector with elements of the vector.  This is useful, for example,
 /// when you want to iterate a range and then sort the results.
 template <unsigned Size, typename R>
 SmallVector<typename std::remove_const<detail::ValueOfRange<R>>::type, Size>
 to_vector(R &&Range) {
   return {std::begin(Range), std::end(Range)};
 }

include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h

 
 public:
   /// Print the location lists found within the debug_loc section.
   void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo) 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);
-  
   Optional<LocationList> parseOneLocationList(DWARFDataExtractor Data,
                                               uint32_t *Offset);
+
+  /// Return location list entries at \c Offset.
+  const LocationList *getLocationList(unsigned Offset) const;
 };
 
 class DWARFDebugLocDWO {
 public:
   struct Entry {
     uint64_t Start;
     uint32_t Length;
     SmallVector<char, 4> Loc;

lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

else
       break;
   }
   if (data.isValidOffset(Offset))
     errs() << "error: failed to consume entire .debug_loc section\n";
 }
 
 Optional<DWARFDebugLocDWO::LocationList>
 DWARFDebugLocDWO::parseOneLocationList(DataExtractor Data, unsigned *Offset) {
   LocationList LL;
   LL.Offset = *Offset;
 
   // dwarf::DW_LLE_end_of_list_entry is 0 and indicates the end of the list.
   while (auto Kind =
              static_cast<dwarf::LocationListEntry>(Data.getU8(Offset))) {
     if (Kind != dwarf::DW_LLE_startx_length) {
       llvm::errs() << "error: dumping support for LLE of kind " << (int)Kind
                    << " not implemented\n";
       return None;
     }
 
     Entry E;
     E.Start = Data.getULEB128(Offset);
     E.Length = Data.getU32(Offset);
 
     unsigned Bytes = Data.getU16(Offset);
     // A single location description describing the location of the object...
     StringRef str = Data.getData().substr(*Offset, Bytes);
     *Offset += Bytes;
     E.Loc.resize(str.size());
     std::copy(str.begin(), str.end(), E.Loc.begin());
 
     LL.Entries.push_back(std::move(E));
   }
   return LL;
 }
 
+const DWARFDebugLoc::LocationList *
+DWARFDebugLoc::getLocationList(unsigned Offset) const {
+  auto List =
+      std::lower_bound(Locations.begin(), Locations.end(), Offset,
+                       [](const DWARFDebugLoc::LocationList &Entry,
+                          unsigned Offset) { return Entry.Offset < Offset; });
+  if (List->Offset != Offset)
+    return nullptr;
+  return List;
+}
+
 void DWARFDebugLocDWO::parse(DataExtractor data) {
   IsLittleEndian = data.isLittleEndian();
   AddressSize = data.getAddressSize();
 
   uint32_t Offset = 0;
   while (data.isValidOffset(Offset)) {
     if (auto LL = parseOneLocationList(data, &Offset))
       Locations.push_back(std::move(*LL));

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

+; RUN: llc -O0 %s -o - -filetype=obj \
+; RUN:   | 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
+  call void @llvm.dbg.value(metadata i32 %3, metadata !35, metadata !24), !dbg !36
+  %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, expr: !DIExpression())
+!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, expr: !DIExpression())
+!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, expr: !DIExpression())
+!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)

test/tools/llvm-dwarfdump/cmdline.test

 RUN: llvm-dwarfdump -h 2>&1 | FileCheck --check-prefix=HELP %s
 RUN: llvm-dwarfdump --help 2>&1 | FileCheck --check-prefix=HELP %s
 HELP: USAGE: llvm-dwarfdump{{[^ ]*}} [options] <input object files or .dSYM bundles>
 HELP-NOT: -reverse-iterate
 HELP: Section-specific Dump Options
 HELP: -debug-info            - Dump the .debug_info section
 HELP: -eh-frame
 HELP: -recurse-depth=<N> 
 HELP: -show-children
 HELP: -show-parents
+HELP: -statistics
 HELP: -summarize-types
 HELP-NOT: -reverse-iterate
 
 RUN: llvm-dwarfdump --version 2>&1 | FileCheck --check-prefix=VERSION %s
 VERSION: {{ version }}

tools/llvm-dwarfdump/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   DebugInfoDWARF
   AllTargetsDescs
   AllTargetsInfos
   MC
   Object
   Support
   )
 
 add_llvm_tool(llvm-dwarfdump
+  Statistics.cpp
   llvm-dwarfdump.cpp
   )
 
 add_subdirectory(fuzzer)

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 PerFunctionStats {
+  /// 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.
+  SmallDenseSet<uint32_t, 4> VarsInFunction;
+  /// Compile units also cover a PC range, but have this flag set to false.
+  bool IsFunction = false;
+};
+
+/// Holds accumulated global statistics about local variables.
+struct GlobalStats {
+  /// Total number of PC range bytes covered by DW_AT_locations.
+  unsigned ScopeBytesCovered = 0;
+  /// Total number of PC range bytes in each variable's enclosing scope,
+  /// starting from the first definition of the variable.
+  unsigned ScopeBytesFromFirstDefinition = 0;
+};
+
+/// Extract the low pc from a Die.
+static uint64_t getLowPC(DWARFDie Die) {
+  if (Die.getAddressRanges().size())
+    return Die.getAddressRanges()[0].LowPC;
+  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 Prefix,
+                               uint64_t ScopeLowPC, uint64_t BytesInScope,
+                               StringMap<PerFunctionStats> &FnStatMap,
+                               GlobalStats &GlobalStats) {
+  bool HasLoc = false;
+  uint64_t BytesCovered = 0;
+  uint64_t OffsetToFirstDefinition = 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;
+          if (List->Entries.size()) {
+            uint64_t FirstDef = List->Entries[0].Begin;
+            uint64_t UnitOfs = getLowPC(Die.getDwarfUnit()->getUnitDIE());
+            // Ranges sometimes start before the lexical scope.
+            if (UnitOfs + FirstDef >= ScopeLowPC)
+              OffsetToFirstDefinition = UnitOfs + FirstDef - ScopeLowPC;
+            // Or even after it. Count that as a failure.
+            if (OffsetToFirstDefinition > BytesInScope)
+              OffsetToFirstDefinition = 0;
+          }
+        }
+        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.
+  auto &FnStats = FnStatMap[Prefix];
+  if (DWARFDie D =
+          Die.getAttributeValueAsReferencedDie(dwarf::DW_AT_abstract_origin))
+    Die = D;
+  // This is a unique ID for the variable inside the current object file.
+  unsigned CanonicalDieOffset = Die.getOffset();
+  FnStats.VarsInFunction.insert(CanonicalDieOffset);
+  if (BytesInScope) {
+    FnStats.TotalVarWithLoc += (unsigned)HasLoc;
+    // Adjust for the fact the variables often start their lifetime in the
+    // middle of the scope.
+    BytesInScope -= OffsetToFirstDefinition;
+    // Turns out we have a lot of ranges that extend past the lexical scope.
+    GlobalStats.ScopeBytesCovered += std::min(BytesInScope, BytesCovered);
+    GlobalStats.ScopeBytesFromFirstDefinition += BytesInScope;
+    assert(GlobalStats.ScopeBytesCovered <=
+           GlobalStats.ScopeBytesFromFirstDefinition);
+  } else {
+    FnStats.ConstantMembers++;
+  }
+}
+
+/// Recursively collect debug info quality metrics.
+static void collectStatsRecursive(DWARFDie Die, std::string Prefix,
+                                  uint64_t ScopeLowPC, uint64_t BytesInScope,
+                                  StringMap<PerFunctionStats> &FnStatMap,
+                                  GlobalStats &GlobalStats) {
+  // 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 &FnStats = FnStatMap[Name];
+      FnStats.NumFnInlined++;
+      FnStats.IsFunction = true;
+    }
+
+    // PC Ranges.
+    auto Ranges = Die.getAddressRanges();
+    uint64_t BytesInThisScope = 0;
+    for (auto Range : Ranges)
+      BytesInThisScope += Range.HighPC - Range.LowPC;
+    ScopeLowPC = getLowPC(Die);
+
+    if (BytesInThisScope)
+      BytesInScope = BytesInThisScope;
+  } else {
+    // Not a scope, visit the Die itself. It could be a variable.
+    collectStatsForDie(Die, Prefix, ScopeLowPC, BytesInScope, FnStatMap,
+                       GlobalStats);
+  }
+
+  // Traverse children.
+  DWARFDie Child = Die.getFirstChild();
+  while (Child) {
+    collectStatsRecursive(Child, Prefix, ScopeLowPC, BytesInScope, FnStatMap,
+                          GlobalStats);
+    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 << '"';
+  DEBUG(llvm::dbgs() << Key << ": " << Value << '\n');
+}
+static void printDatum(const char *Key, uint64_t Value) {
+  llvm::outs() << ",\"" << Key << "\":" << Value;
+  DEBUG(llvm::dbgs() << 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) {
+  GlobalStats GlobalStats;
+  StringMap<PerFunctionStats> Statistics;
+  for (const auto &CU : static_cast<DWARFContext *>(&DICtx)->compile_units())
+    if (DWARFDie CUDie = CU->getUnitDIE(false))
+      collectStatsRecursive(CUDie, "/", 0, 0, Statistics, GlobalStats);
+
+  /// 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;
+  unsigned NumFunctions = 0;
+  unsigned NumInlinedFunctions = 0;
+  for (auto &Entry : Statistics) {
+    PerFunctionStats &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 << "\n");
+    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 << '"';
+  DEBUG(llvm::dbgs() << "Variable location quality metrics\n";
+        llvm::dbgs() << "---------------------------------\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", GlobalStats.ScopeBytesFromFirstDefinition);
+  printDatum("scope bytes covered", GlobalStats.ScopeBytesCovered);
+  llvm::outs() << "}\n";
+  DEBUG(
+      llvm::dbgs() << "Total Availability: "
+                   << (int)std::round((VarWithLoc * 100.0) / VarTotal) << "%\n";
+      llvm::dbgs() << "PC Ranges covered: "
+                   << (int)std::round((GlobalStats.ScopeBytesCovered * 100.0) /
+                                      GlobalStats.ScopeBytesFromFirstDefinition)
+                   << "%\n");
+  return;
+}

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

static opt<unsigned> RecurseDepth(
     cat(DwarfDumpCategory), init(-1U), value_desc("N"));
 static alias RecurseDepthAlias("r", desc("Alias for -recurse-depth"),
                                aliasopt(RecurseDepth));
 
 static opt<bool>
     SummarizeTypes("summarize-types",
                    desc("Abbreviate the description of type unit entries"),
                    cat(DwarfDumpCategory));
+static cl::opt<bool>
+    Statistics("statistics",
+               cl::desc("Emit JSON-formatted debug info quality statistics"),
+               cat(DwarfDumpCategory));
 static opt<bool> Verify("verify", desc("Verify the DWARF debug info"),
                         cat(DwarfDumpCategory));
 static opt<bool> Quiet("quiet", desc("Use with -verify to not emit to STDOUT."),
                        cat(DwarfDumpCategory));
 static opt<bool> Verbose("verbose",
                          desc("Print more low-level encoding details"),
                          cat(DwarfDumpCategory));
 static alias VerboseAlias("v", desc("Alias for -verbose"), aliasopt(Verbose),
static DIDumpOptions getDumpOpts() {
   DumpOpts.SummarizeTypes = SummarizeTypes;
   DumpOpts.Verbose = Verbose;
   // In -verify mode, print DIEs without children in error messages.
   if (Verify)
     return DumpOpts.noImplicitRecursion();
   return DumpOpts;
 }
 
+void collectStats(DIContext &DICtx, StringRef Filename, StringRef FormatName);
+
+static bool collectStatsForObjectFile(ObjectFile &Obj, Twine Filename) {
+  std::unique_ptr<DIContext> DICtx = DWARFContext::create(Obj);
+  collectStats(*DICtx, Filename.str(), Obj.getFileFormatName());
+  return true;
+}
+
 static bool dumpObjectFile(ObjectFile &Obj, Twine Filename) {
   std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(Obj);
   logAllUnhandledErrors(DICtx->loadRegisterInfo(Obj), errs(),
                         Filename.str() + ": ");
   // The UUID dump already contains all the same information.
   if (!(DumpType & DIDT_UUID) || DumpType == DIDT_All)
     outs() << Filename << ":\tfile format " << Obj.getFileFormatName() << '\n';
 
#undef HANDLE_DWARF_SECTION
   }
 
   if (Verify) {
     // If we encountered errors during verify, exit with a non-zero exit status.
     if (!std::all_of(Objects.begin(), Objects.end(), [](std::string Object) {
           return handleFile(Object, verifyObjectFile);
         }))
       exit(1);
-  } else
+  } else if (Statistics)
+    for (auto Object : Objects)
+      handleFile(Object, collectStatsForObjectFile);
+  else
     for (auto Object : Objects)
       handleFile(Object, dumpObjectFile);
 
   return EXIT_SUCCESS;
 }