[llvm-dwarfdump][Statistics] Unify coverage statistic computation

[krisb]

Summary

The patch removes OffsetToFirstDefinition in the 'scope bytes total' statistic computation. Thus it unifies the way the scope and the coverage buckets are computed. The rationals behind that are the following:

1. OffsetToFirstDefinition was used to calculate the variable's life range. However, there is no simple way to do it accurately, so the scope calculated this way might be misleading. See D69027 for more details on the subject.
2. Both 'scope bytes total' and coverage buckets seem to be intended to represent the same data in different ways. Otherwise, the statistics might be controversial and confusing.

Note that the approach gives up a thorough evaluation of debug information completeness (i.e. coverage buckets by themselves doesn't tell how good the debug information is). Only changes in coverage over time make a 'physical' sense.

[djtodoro]

@krisb Thanks for working on this!

Let me summarize this quickly.

This will remove mixing between calculation against enclosing and adjusted scope. We have concluded the adjustment heuristics are confusing and wrong in many cases, so we are giving up on that. The alternative is to generate the DW_AT_start_scope attribute, that represents exactly the adjusted scope, and having that we will be able to calculate the debug location statistics for the pieces of code where the variable is alive.

WDYT how "easy" will be to implement the DW_AT_start_scope attribute? I know that it might not be used anywhere else, but I think that having location statistics against variable's life will be very useful thing.

[djtodoro]

Please refactor the llvm/utils/llvm-locstats/llvm-locstats.py as well (there are variables containing *FromFirstDefinition).

[dblaikie]

In D70548#1756279, @djtodoro wrote:

@krisb Thanks for working on this!

Let me summarize this quickly.

This will remove mixing between calculation against enclosing and adjusted scope. We have concluded the adjustment heuristics are confusing and wrong in many cases, so we are giving up on that. The alternative is to generate the DW_AT_start_scope attribute, that represents exactly the adjusted scope, and having that we will be able to calculate the debug location statistics for the pieces of code where the variable is alive.

WDYT how "easy" will be to implement the DW_AT_start_scope attribute? I know that it might not be used anywhere else, but I think that having location statistics against variable's life will be very useful thing.

See my reply from D69027 - though thinking more closely, I'm not sure start_scope would really answer the question as it seems like it has many of the same issues as the adjusted scope we're removing - it assumes the code is laid out in order. Any use of DW_AT_ranges would invalidate it (& I /think/ many & perhaps most scopes are fragmented into ranges in optimized code which is where any of these stats are interesting) & basic block reordering, etc, is sort of the nail in the coffin.

"Yeah, that could be handy - but probably pretty complicated to propagate through the compiler & only have limited benefits to users (in normal debugger scenarios, rather than stats) - the difference between "this variable is out of scope" (or using another variable that would otherwise have been shadowed - that's pretty important) and "this variable's value is optimized out". The complexity of the implementation might be why it's not been implemented - possible that an implementation might be justifiable in a context of bigger improvements like is_stmt accuracy or sub-expression source range grouping, or other ideas that've been thrown around from time to time."

[krisb]

Refactored llvm/utils/llvm-locstats/llvm-locstats.py variable's names to avoid mentioning 'first def'.

[krisb]

In D70548#1756279, @djtodoro wrote:

@krisb Thanks for working on this!

Let me summarize this quickly.

This will remove mixing between calculation against enclosing and adjusted scope. We have concluded the adjustment heuristics are confusing and wrong in many cases, so we are giving up on that. The alternative is to generate the DW_AT_start_scope attribute, that represents exactly the adjusted scope, and having that we will be able to calculate the debug location statistics for the pieces of code where the variable is alive.

Thanks for summarizing this! This is perfectly correct.

In D70548#1756279, @djtodoro wrote:

WDYT how "easy" will be to implement the DW_AT_start_scope attribute? I know that it might not be used anywhere else, but I think that having location statistics against variable's life will be very useful thing.

I haven't investigated the subject in detail, but my initial guess is that life range may be computed as a union of basic blocks or their parts that 1) belong to the enclosing scope and 2) have debug value instructions that describe the variable (either with a valid location or with an undef). It looks easy to implement, but for practical use, it's probably too rough. I'm going to take another look a bit later.

In D70548#1756669, @djtodoro wrote:

Please refactor the llvm/utils/llvm-locstats/llvm-locstats.py as well (there are variables containing *FromFirstDefinition).

Thanks! Fixed.

[krisb]

In D70548#1757299, @dblaikie wrote:

In D70548#1756279, @djtodoro wrote:

@krisb Thanks for working on this!

Let me summarize this quickly.

This will remove mixing between calculation against enclosing and adjusted scope. We have concluded the adjustment heuristics are confusing and wrong in many cases, so we are giving up on that. The alternative is to generate the DW_AT_start_scope attribute, that represents exactly the adjusted scope, and having that we will be able to calculate the debug location statistics for the pieces of code where the variable is alive.

WDYT how "easy" will be to implement the DW_AT_start_scope attribute? I know that it might not be used anywhere else, but I think that having location statistics against variable's life will be very useful thing.

See my reply from D69027 - though thinking more closely, I'm not sure start_scope would really answer the question as it seems like it has many of the same issues as the adjusted scope we're removing - it assumes the code is laid out in order. Any use of DW_AT_ranges would invalidate it (& I /think/ many & perhaps most scopes are fragmented into ranges in optimized code which is where any of these stats are interesting) & basic block reordering, etc, is sort of the nail in the coffin.

The spec looks a bit confusing here, but if I understand it correctly, it should be possible to represent 'adjusted' scope precisely in all the situations.
Regarding DW_AT_start_scope the spec (dwarfv5) says (3.9 Declarations with Reduced Scope) :

Any debugging information entry for a declaration (including objects, subprograms, types and modules) whose scope has an address range that is a subset of the address range for the lexical scope most closely enclosing the declared entity may have a DW_AT_start_scope attribute to specify that reduced range of addresses.
There are two cases:

1. If the address range for the scope of the entry includes all of addresses for the containing scope except for a contiguous sequence of bytes at the beginning of the address range for the containing scope, then the address is specified using a value of class constant.

...

2. Otherwise, the set of addresses for the scope of the entity is specified using a value of class rnglistsptr. This value indicates the beginning of a range list.

I understand this as 'If it's possible to represent a reduced scope as an offset to an enclosing lexical scope, it is actually the offset. But in cases when there are no ways to correctly use offset here, it is described in a ranges list, which represents the reduced scope itself'. The latter should allow handling fragmented scopes, blocks reordering, ..., etc.

[avl]

@krisb the patch looks good to me. though I would prefer if someone from debuginfo project would approve it. Thank you.

[djtodoro]

In D70548#1757299, @dblaikie wrote:

In D70548#1756279, @djtodoro wrote:

@krisb Thanks for working on this!

Let me summarize this quickly.

This will remove mixing between calculation against enclosing and adjusted scope. We have concluded the adjustment heuristics are confusing and wrong in many cases, so we are giving up on that. The alternative is to generate the DW_AT_start_scope attribute, that represents exactly the adjusted scope, and having that we will be able to calculate the debug location statistics for the pieces of code where the variable is alive.

WDYT how "easy" will be to implement the DW_AT_start_scope attribute? I know that it might not be used anywhere else, but I think that having location statistics against variable's life will be very useful thing.

See my reply from D69027 - though thinking more closely, I'm not sure start_scope would really answer the question as it seems like it has many of the same issues as the adjusted scope we're removing - it assumes the code is laid out in order. Any use of DW_AT_ranges would invalidate it (& I /think/ many & perhaps most scopes are fragmented into ranges in optimized code which is where any of these stats are interesting) & basic block reordering, etc, is sort of the nail in the coffin.

"Yeah, that could be handy - but probably pretty complicated to propagate through the compiler & only have limited benefits to users (in normal debugger scenarios, rather than stats) - the difference between "this variable is out of scope" (or using another variable that would otherwise have been shadowed - that's pretty important) and "this variable's value is optimized out". The complexity of the implementation might be why it's not been implemented - possible that an implementation might be justifiable in a context of bigger improvements like is_stmt accuracy or sub-expression source range grouping, or other ideas that've been thrown around from time to time."

@dblaikie I see... There are many things to handle in order to make such stats valid.

In D70548#1758039, @krisb wrote:

In D70548#1756279, @djtodoro wrote:

@krisb Thanks for working on this!

Let me summarize this quickly.

This will remove mixing between calculation against enclosing and adjusted scope. We have concluded the adjustment heuristics are confusing and wrong in many cases, so we are giving up on that. The alternative is to generate the DW_AT_start_scope attribute, that represents exactly the adjusted scope, and having that we will be able to calculate the debug location statistics for the pieces of code where the variable is alive.

Thanks for summarizing this! This is perfectly correct.

In D70548#1756279, @djtodoro wrote:

WDYT how "easy" will be to implement the DW_AT_start_scope attribute? I know that it might not be used anywhere else, but I think that having location statistics against variable's life will be very useful thing.

I haven't investigated the subject in detail, but my initial guess is that life range may be computed as a union of basic blocks or their parts that 1) belong to the enclosing scope and 2) have debug value instructions that describe the variable (either with a valid location or with an undef). It looks easy to implement, but for practical use, it's probably too rough. I'm going to take another look a bit later.

In D70548#1756669, @djtodoro wrote:

Please refactor the llvm/utils/llvm-locstats/llvm-locstats.py as well (there are variables containing *FromFirstDefinition).

Thanks! Fixed.

@krisb Thanks for addressing the comments and considering the improvements!

[dblaikie]

@aprantl - seems mostly in your wheelhouse? (or is there someone else who owns these statistics more?)

[krisb]

Thank everyone for reviewing this!
Committed as 68f464ac2ef5de8cb2e8beaeee43c435c536539e.

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

 ; RUN: llc -debug-entry-values %s -o - -filetype=obj \
 ; RUN:   | llvm-dwarfdump -statistics - | FileCheck %s
 ;
 ; CHECK: "entry value scope bytes covered":5
 ; CHECK: "formal params scope bytes total":20
 ; CHECK: "formal params scope bytes covered":20
 ; CHECK: "formal params entry value scope bytes covered":5
-; CHECK: "vars scope bytes total":78
+; CHECK: "vars scope bytes total":90
 ; CHECK: "vars scope bytes covered":60
 ; CHECK: "vars entry value scope bytes covered":0
 ; CHECK: "total variables procesed by location statistics":6
 ; CHECK: "variables with 0% of its scope covered":1
 ; CHECK: "variables with 1-9% of its scope covered":0
 ; CHECK: "variables with 10-19% of its scope covered":0
 ; CHECK: "variables with 20-29% of its scope covered":0
 ; CHECK: "variables with 30-39% of its scope covered":0

llvm/test/tools/llvm-dwarfdump/X86/statistics-base-address.s

 # This tests the computation of the scope bytes covered by local variables. In
 # particular, the case when the variable starts in the middle of the enclosing
 # scope, and the compile unit has both DW_AT_ranges and DW_AT_low_pc attributes.
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj -o %t
 # RUN: llvm-dwarfdump --statistics %t | FileCheck %s
 
-# CHECK: "vars scope bytes total":8
+# CHECK: "vars scope bytes total":12
 # CHECK: "vars scope bytes covered":8
 
         .text
 
 # Add padding to ensure the function does not start at address zero.
         .zero 256
 
 f:                                      # @f

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

 # Test of the llmv-dwarfdump --statistics with split dwarf (dwo files)
-# (version 3).
+# (version >= 3).
 #
 # Create a directory in which to put all files, so .o file can find .dwo file.
 RUN: rm -rf %t && mkdir -p %t
 RUN: cp -f %S/Inputs/statistics-fib.split-dwarf.s %t/.
 RUN: cd %t
 RUN: llvm-mc -triple x86_64-unknown-linux-gnu statistics-fib.split-dwarf.s -filetype=obj -split-dwarf-file statistics-fib.split-dwarf.dwo -o statistics-fib.split-dwarf.o
 RUN: llvm-dwarfdump --statistics statistics-fib.split-dwarf.o | FileCheck %s
 

 #   printf ("fibonacci(9) = %d\n", result);
 #   result = fib(10);
 #   printf ("fibonacci(10) = %d\n", result);
 # 
 #   return 0;
 # }
 #
 
-CHECK: "version":3
+CHECK: "version":4
 CHECK: "source functions":3
 CHECK: "source functions with location":3
 CHECK: "inlined functions":7
 CHECK: "inlined funcs with abstract origins":7
 CHECK: "unique source variables":9
 CHECK: "source variables":30
 
 # Ideally the value below would be 33 but currently it's not.
 CHECK: "variables with location":22
 CHECK: "call site entries":7
-CHECK: "scope bytes total":2702
+CHECK: "scope bytes total":2817
 CHECK: "scope bytes covered":1160
 CHECK: "total function size":594
 CHECK: "total inlined function size":345
 CHECK: "total formal params":12
 CHECK: "formal params with source location":12
 CHECK: "formal params with type":12
 CHECK: "formal params with binary location":12
 CHECK: "total vars":18
 CHECK: "vars with source location":18
 CHECK: "vars with type":18
 
 # Ideally the value below would be 18, but currently it's not.
 CHECK: "vars with binary location":10

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

-# Test of the llmv-dwarfdump --statistics newly added stats (version 3).
+# Test of the llmv-dwarfdump --statistics newly added stats (version >= 3).
 #
 RUN: llvm-mc -triple x86_64-unknown-linux-gnu %S/Inputs/statistics-fib.s -filetype=obj -o %t-statistics-fib.o
 RUN: llvm-dwarfdump --statistics %t-statistics-fib.o | FileCheck %s
 
 # Source program - A version of Fibonacci
 # Compilation options:  -g -O3 -c
 #
 # int

 #   printf ("fibonacci(9) = %d\n", result);
 #   result = fib(10);
 #   printf ("fibonacci(10) = %d\n", result);
 # 
 #   return 0;
 # }
 #
 
-CHECK: "version":3
+CHECK: "version":4
 CHECK: "source functions":3
 CHECK: "source functions with location":3
 CHECK: "inlined functions":8
 CHECK: "inlined funcs with abstract origins":8
 CHECK: "unique source variables":9
 CHECK: "source variables":33
 
 # Ideally the value below would be 33 but currently it's not.
 CHECK: "variables with location":24
 CHECK: "call site entries":8
-CHECK: "scope bytes total":2958
+CHECK: "scope bytes total":3072
 CHECK: "scope bytes covered":1188
 CHECK: "total function size":636
 CHECK: "total inlined function size":388
 CHECK: "total formal params":13
 CHECK: "formal params with source location":13
 CHECK: "formal params with type":13
 CHECK: "formal params with binary location":13
 CHECK: "total vars":20
 CHECK: "vars with source location":20
 CHECK: "vars with type":20
 
 # Ideally the value below would be 20, but currently it's not.
 CHECK: "vars with binary location":11

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

 ; RUN: llc -O0 %s -o - -filetype=obj \
 ; RUN:   | llvm-dwarfdump -statistics - | FileCheck %s
-; CHECK: "version":3
+; CHECK: "version":4
 
 ; int GlobalConst = 42;
 ; int Global;
 ;
 ; struct S {
 ;   static const int constant = 24;
 ; } s;
 ;

llvm/tools/llvm-dwarfdump/Statistics.cpp

struct PerFunctionStats {
   /// Number of variables with DW_AT_location.
   unsigned NumVarLocations = 0;
 };
 
 /// Holds accumulated global statistics about DIEs.
 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;
+  /// Total number of PC range bytes in each variable's enclosing scope.
+  unsigned ScopeBytes = 0;
   /// Total number of PC range bytes covered by DW_AT_locations with
   /// the debug entry values (DW_OP_entry_value).
   unsigned ScopeEntryValueBytesCovered = 0;
   /// Total number of PC range bytes covered by DW_AT_locations of
   /// formal parameters.
   unsigned ParamScopeBytesCovered = 0;
-  /// Total number of PC range bytes in each variable's enclosing scope,
-  /// starting from the first definition of the variable (only for parameters).
-  unsigned ParamScopeBytesFromFirstDefinition = 0;
+  /// Total number of PC range bytes in each variable's enclosing scope
+  /// (only for parameters).
+  unsigned ParamScopeBytes = 0;
   /// Total number of PC range bytes covered by DW_AT_locations with
   /// the debug entry values (DW_OP_entry_value) (only for parameters).
   unsigned ParamScopeEntryValueBytesCovered = 0;
   /// Total number of PC range bytes covered by DW_AT_locations (only for local
   /// variables).
   unsigned VarScopeBytesCovered = 0;
-  /// Total number of PC range bytes in each variable's enclosing scope,
-  /// starting from the first definition of the variable (only for local
-  /// variables).
-  unsigned VarScopeBytesFromFirstDefinition = 0;
+  /// Total number of PC range bytes in each variable's enclosing scope
+  /// (only for local variables).
+  unsigned VarScopeBytes = 0;
   /// Total number of PC range bytes covered by DW_AT_locations with
   /// the debug entry values (DW_OP_entry_value) (only for local variables).
   unsigned VarScopeEntryValueBytesCovered = 0;
   /// Total number of call site entries (DW_AT_call_file & DW_AT_call_line).
   unsigned CallSiteEntries = 0;
   /// Total number of call site DIEs (DW_TAG_call_site).
   unsigned CallSiteDIEs = 0;
   /// Total number of call site parameter DIEs (DW_TAG_call_site_parameter).
struct LocationStats {
   /// Total number of local variables and function parameters processed.
   unsigned NumVarParam = 0;
   /// Total number of formal parameters processed.
   unsigned NumParam = 0;
   /// Total number of local variables processed.
   unsigned NumVar = 0;
 };
 
-/// Extract the low pc from a Die.
-static uint64_t getLowPC(DWARFDie Die) {
-  auto RangesOrError = Die.getAddressRanges();
-  DWARFAddressRangesVector Ranges;
-  if (RangesOrError)
-    Ranges = RangesOrError.get();
-  else
-    llvm::consumeError(RangesOrError.takeError());
-  if (Ranges.size())
-    return Ranges[0].LowPC;
-  return dwarf::toAddress(Die.find(dwarf::DW_AT_low_pc), 0);
-}
-
 /// Collect debug location statistics for one DIE.
 static void collectLocStats(uint64_t BytesCovered, uint64_t BytesInScope,
                             std::vector<unsigned> &VarParamLocStats,
                             std::vector<unsigned> &ParamLocStats,
                             std::vector<unsigned> &VarLocStats, bool IsParam,
                             bool IsLocalVar) {
   auto getCoverageBucket = [BytesCovered, BytesInScope]() -> unsigned {
     unsigned LocBucket = 100 * (double)BytesCovered / BytesInScope;
static void collectLocStats(uint64_t BytesCovered, uint64_t BytesInScope,
   if (IsParam)
     ParamLocStats[CoverageBucket]++;
   else if (IsLocalVar)
     VarLocStats[CoverageBucket]++;
 }
 
 /// 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,
+                               std::string VarPrefix, uint64_t BytesInScope,
+                               uint32_t InlineDepth,
                                StringMap<PerFunctionStats> &FnStatMap,
                                GlobalStats &GlobalStats,
                                LocationStats &LocStats) {
   bool HasLoc = false;
   bool HasSrcLoc = false;
   bool HasType = false;
   bool IsArtificial = false;
   uint64_t BytesCovered = 0;
   uint64_t BytesEntryValuesCovered = 0;
-  uint64_t OffsetToFirstDefinition = 0;
   auto &FnStats = FnStatMap[FnPrefix];
   bool IsParam = Die.getTag() == dwarf::DW_TAG_formal_parameter;
   bool IsLocalVar = Die.getTag() == dwarf::DW_TAG_variable;
 
   if (Die.getTag() == dwarf::DW_TAG_call_site ||
       Die.getTag() == dwarf::DW_TAG_GNU_call_site) {
     GlobalStats.CallSiteDIEs++;
     return;
if (!Loc) {
         BytesCovered = BytesInScope;
       } else {
         for (auto Entry : *Loc) {
           uint64_t BytesEntryCovered = Entry.Range->HighPC - Entry.Range->LowPC;
           BytesCovered += BytesEntryCovered;
           if (IsEntryValue(Entry.Expr))
             BytesEntryValuesCovered += BytesEntryCovered;
         }
-        if (!Loc->empty()) {
-          uint64_t FirstDef = Loc->front().Range->LowPC;
-          // Ranges sometimes start before the lexical scope.
-          if (FirstDef >= ScopeLowPC)
-            OffsetToFirstDefinition = FirstDef - ScopeLowPC;
-          // Or even after it. Count that as a failure.
-          if (OffsetToFirstDefinition > BytesInScope)
-            OffsetToFirstDefinition = 0;
-        }
-        assert(BytesInScope);
       }
     }
   }
 
   // Calculate the debug location statistics.
   if (BytesInScope) {
     LocStats.NumVarParam++;
     if (IsParam)
if (DWARFDie D =
           Die.getAttributeValueAsReferencedDie(dwarf::DW_AT_abstract_origin))
     Die = D;
   // By using the variable name + the path through the lexical block tree, the
   // keys are consistent across duplicate abstract origins in different CUs.
   std::string VarName = StringRef(Die.getName(DINameKind::ShortName));
   FnStats.VarsInFunction.insert(VarPrefix + VarName);
   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;
+    GlobalStats.ScopeBytes += BytesInScope;
     GlobalStats.ScopeEntryValueBytesCovered += BytesEntryValuesCovered;
     if (IsParam) {
       GlobalStats.ParamScopeBytesCovered +=
           std::min(BytesInScope, BytesCovered);
-      GlobalStats.ParamScopeBytesFromFirstDefinition += BytesInScope;
+      GlobalStats.ParamScopeBytes += BytesInScope;
       GlobalStats.ParamScopeEntryValueBytesCovered += BytesEntryValuesCovered;
     } else if (IsLocalVar) {
       GlobalStats.VarScopeBytesCovered += std::min(BytesInScope, BytesCovered);
-      GlobalStats.VarScopeBytesFromFirstDefinition += BytesInScope;
+      GlobalStats.VarScopeBytes += BytesInScope;
       GlobalStats.VarScopeEntryValueBytesCovered += BytesEntryValuesCovered;
     }
-    assert(GlobalStats.ScopeBytesCovered <=
-           GlobalStats.ScopeBytesFromFirstDefinition);
+    assert(GlobalStats.ScopeBytesCovered <= GlobalStats.ScopeBytes);
   } else if (Die.getTag() == dwarf::DW_TAG_member) {
     FnStats.ConstantMembers++;
   } else {
     FnStats.TotalVarWithLoc += (unsigned)HasLoc;
   }
   if (!IsArtificial) {
     if (IsParam) {
       FnStats.NumParams++;
if (IsParam) {
       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,
+                                  std::string VarPrefix, uint64_t BytesInScope,
+                                  uint32_t InlineDepth,
                                   StringMap<PerFunctionStats> &FnStatMap,
                                   GlobalStats &GlobalStats,
                                   LocationStats &LocStats) {
   // 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 (!RangesOrError) {
       llvm::consumeError(RangesOrError.takeError());
       return;
     }
 
     auto Ranges = RangesOrError.get();
     uint64_t BytesInThisScope = 0;
     for (auto Range : Ranges)
       BytesInThisScope += Range.HighPC - Range.LowPC;
-    ScopeLowPC = getLowPC(Die);
 
     // Count the function.
     if (!IsBlock) {
       StringRef Name = Die.getName(DINameKind::LinkageName);
       if (Name.empty())
         Name = Die.getName(DINameKind::ShortName);
       FnPrefix = Name;
       // Skip over abstract origins.
if (BytesInThisScope) {
       BytesInScope = 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, LocStats);
+    collectStatsForDie(Die, FnPrefix, VarPrefix, BytesInScope, InlineDepth,
+                       FnStatMap, GlobalStats, LocStats);
   }
 
   // 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,
-                          LocStats);
+    collectStatsRecursive(Child, FnPrefix, ChildVarPrefix, BytesInScope,
+                          InlineDepth, FnStatMap, GlobalStats, LocStats);
     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, json::Value Value) {

 bool collectStatsForObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
                                Twine Filename, raw_ostream &OS) {
   StringRef FormatName = Obj.getFileFormatName();
   GlobalStats GlobalStats;
   LocationStats LocStats;
   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, Statistics, GlobalStats,
                             LocStats);
 
   /// 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 Version = 4;
   unsigned VarParamTotal = 0;
   unsigned VarParamUnique = 0;
   unsigned VarParamWithLoc = 0;
   unsigned NumFunctions = 0;
   unsigned NumInlinedFunctions = 0;
   unsigned NumFuncsWithSrcLoc = 0;
   unsigned NumAbstractOrigins = 0;
   unsigned ParamTotal = 0;
bool collectStatsForObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
   printDatum(OS, "inlined functions", NumInlinedFunctions);
   printDatum(OS, "inlined funcs with abstract origins", NumAbstractOrigins);
   printDatum(OS, "unique source variables", VarParamUnique);
   printDatum(OS, "source variables", VarParamTotal);
   printDatum(OS, "variables with location", VarParamWithLoc);
   printDatum(OS, "call site entries", GlobalStats.CallSiteEntries);
   printDatum(OS, "call site DIEs", GlobalStats.CallSiteDIEs);
   printDatum(OS, "call site parameter DIEs", GlobalStats.CallSiteParamDIEs);
-  printDatum(OS, "scope bytes total",
-             GlobalStats.ScopeBytesFromFirstDefinition);
+  printDatum(OS, "scope bytes total", GlobalStats.ScopeBytes);
   printDatum(OS, "scope bytes covered", GlobalStats.ScopeBytesCovered);
   printDatum(OS, "entry value scope bytes covered",
              GlobalStats.ScopeEntryValueBytesCovered);
   printDatum(OS, "formal params scope bytes total",
-             GlobalStats.ParamScopeBytesFromFirstDefinition);
+             GlobalStats.ParamScopeBytes);
   printDatum(OS, "formal params scope bytes covered",
              GlobalStats.ParamScopeBytesCovered);
   printDatum(OS, "formal params entry value scope bytes covered",
              GlobalStats.ParamScopeEntryValueBytesCovered);
-  printDatum(OS, "vars scope bytes total",
-             GlobalStats.VarScopeBytesFromFirstDefinition);
+  printDatum(OS, "vars scope bytes total", GlobalStats.VarScopeBytes);
   printDatum(OS, "vars scope bytes covered", GlobalStats.VarScopeBytesCovered);
   printDatum(OS, "vars entry value scope bytes covered",
              GlobalStats.VarScopeEntryValueBytesCovered);
   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);
printLocationStats(OS, "vars (excluding the debug entry values)",
                      LocStats.VarNonEntryValLocStats);
   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)
+                                      GlobalStats.ScopeBytes)
                    << "%\n");
   return true;
 }

llvm/utils/llvm-locstats/llvm-locstats.py

for start in range(10, 91, 10):
     yield '{0}-{1}%'.format(start, start + 9)
   yield '100%'
 
 def locstats_output(
   variables_total,
   variables_total_locstats,
   variables_with_loc,
   scope_bytes_covered,
-  scope_bytes_from_first_def,
+  scope_bytes,
   variables_coverage_map
   ):
 
   pc_ranges_covered = int(ceil(scope_bytes_covered * 100.0)
-              / scope_bytes_from_first_def)
+              / scope_bytes)
   variables_coverage_per_map = {}
   for cov_bucket in coverage_buckets():
     variables_coverage_per_map[cov_bucket] = \
       int(ceil(variables_coverage_map[cov_bucket] * 100.0) \
                / variables_total_locstats)
 
   print (' =================================================')
   print ('            Debug Location Statistics       ')
if results.only_variables and results.only_formal_parameters:
     parser.print_help()
     sys.exit(1)
 
   # These will be different due to different options enabled.
   variables_total = None
   variables_total_locstats = None
   variables_with_loc = None
   variables_scope_bytes_covered = None
-  variables_scope_bytes_from_first_def = None
+  variables_scope_bytes = None
   variables_scope_bytes_entry_values = None
   variables_coverage_map = {}
   binary = results.file_name
 
   # Get the directory of the LLVM tools.
   llvm_dwarfdump_cmd = os.path.join(os.path.dirname(__file__), \
                                     "llvm-dwarfdump")
   # The statistics llvm-dwarfdump option.
except:
     sys.exit(1)
 
   if results.only_variables:
     # Read the JSON only for local variables.
     variables_total_locstats = \
       json_parsed['total vars procesed by location statistics']
     variables_scope_bytes_covered = \
       json_parsed['vars scope bytes covered']
-    variables_scope_bytes_from_first_def = \
+    variables_scope_bytes = \
       json_parsed['vars scope bytes total']
     if not results.ignore_debug_entry_values:
       for cov_bucket in coverage_buckets():
         cov_category = "vars with {} of its scope covered".format(cov_bucket)
         variables_coverage_map[cov_bucket] = json_parsed[cov_category]
     else:
       variables_scope_bytes_entry_values = \
         json_parsed['vars entry value scope bytes covered']
       variables_scope_bytes_covered = variables_scope_bytes_covered \
          - variables_scope_bytes_entry_values
       for cov_bucket in coverage_buckets():
         cov_category = \
           "vars (excluding the debug entry values) " \
           "with {} of its scope covered".format(cov_bucket)
         variables_coverage_map[cov_bucket] = json_parsed[cov_category]
   elif results.only_formal_parameters:
     # Read the JSON only for formal parameters.
     variables_total_locstats = \
       json_parsed['total params procesed by location statistics']
     variables_scope_bytes_covered = \
       json_parsed['formal params scope bytes covered']
-    variables_scope_bytes_from_first_def = \
+    variables_scope_bytes = \
       json_parsed['formal params scope bytes total']
     if not results.ignore_debug_entry_values:
       for cov_bucket in coverage_buckets():
         cov_category = "params with {} of its scope covered".format(cov_bucket)
         variables_coverage_map[cov_bucket] = json_parsed[cov_category]
     else:
       variables_scope_bytes_entry_values = \
         json_parsed['formal params entry value scope bytes covered']
       variables_scope_bytes_covered = variables_scope_bytes_covered \
         - variables_scope_bytes_entry_values
       for cov_bucket in coverage_buckets():
         cov_category = \
           "params (excluding the debug entry values) " \
           "with {} of its scope covered".format(cov_bucket)
         variables_coverage_map[cov_bucket] = json_parsed[cov_category]
   else:
     # Read the JSON for both local variables and formal parameters.
     variables_total = \
       json_parsed['source variables']
     variables_with_loc = json_parsed['variables with location']
     variables_total_locstats = \
       json_parsed['total variables procesed by location statistics']
     variables_scope_bytes_covered = \
       json_parsed['scope bytes covered']
-    variables_scope_bytes_from_first_def = \
+    variables_scope_bytes = \
       json_parsed['scope bytes total']
     if not results.ignore_debug_entry_values:
       for cov_bucket in coverage_buckets():
         cov_category = "variables with {} of its scope covered". \
                        format(cov_bucket)
         variables_coverage_map[cov_bucket] = json_parsed[cov_category]
     else:
       variables_scope_bytes_entry_values = \
         json_parsed['entry value scope bytes covered']
       variables_scope_bytes_covered = variables_scope_bytes_covered \
         - variables_scope_bytes_entry_values
       for cov_bucket in coverage_buckets():
         cov_category = "variables (excluding the debug entry values) " \
                        "with {} of its scope covered". format(cov_bucket)
         variables_coverage_map[cov_bucket] = json_parsed[cov_category]
 
   # Pretty print collected info.
   locstats_output(
     variables_total,
     variables_total_locstats,
     variables_with_loc,
     variables_scope_bytes_covered,
-    variables_scope_bytes_from_first_def,
+    variables_scope_bytes,
     variables_coverage_map
     )
 
 if __name__ == '__main__':
   Main()
   sys.exit(0)