[llvm-dwarfdump][Stats] Clean up

[djtodoro]

Summary

-Clean up the source code
-Refactor the JSON fields
-Fix the test cases

[aprantl]

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

5

comparing this to variables with 0% of its scope covered, should we go even further in terms of coming up with a more descriptive field name?

[djtodoro]

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

5

I strongly agree.

How about total bytes in each local var's scope? And to changing all the similar fields respectively, in that way.

[aprantl]

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

5

Let's try to be systematic, and not too verbose, but still precise. Here's a suggestion using a TeX-style syntax that I happen to feel comfortable with, but I'm sure others' opinions will vary:

"local vars scope bytes covered" ->
"\sum_{all local vars} #bytes in parent scope covered by DW_AT_location"
"\sum_{all local vars} #bytes in parent scope"
"\sum_{all params} #bytes in parent scope"
...

"total variables procesed by location statistics" -> 
"#local vars + #params"

and not "\sum_{all local vars} 1" :-)

"#local vars with 0% of parent scope covered by DW_AT_location"
"#params \ entry values with [60%,70%) of parent scope covered by DW_AT_location"

Let me know what you think!

[djtodoro]

I've been away for a few days, sorry the late response.

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

5

I am also fan of the TeX syntax, and strong +1 for this.
OTOH, I think we should document this somehow, at least mentioning that the JSON fields are written in the spirit of the TeX. Please let me know if you agree with that.

[djtodoro]

-addressing comments
-refactoring the JSON fields in the spirit of the TeX syntax

[jhenderson]

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

5

To me, the logical thing to do would be to add a section to the llvm-dwarfdump CommandGuide documentation that describes the format.

[djtodoro]

@jhenderson Thanks for the comment.

[djtodoro]

-adding the documentation

[djtodoro]

-fixing a typo

[aprantl]

Now that I see it in front of me I'm not sure it was a great idea to use a backslash in quoting. But I also don't have a much better idea. TeX math notation is at least widely recognized and used in all kinds of software.

Could we make the string literals in the code raw string literals though?

i.e., r'\sum' in Python, and R"\sum" in C++.

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

268

I think this should be \/, a forward-slash, right?

[aprantl]

llvm/docs/CommandGuide/llvm-dwarfdump.rst

117

Nit: #bytes is a shorthand I made up, in TeX it would actually be \#bytes. Is |bytes| a better notation?

[djtodoro]

In D77789#2000264, @aprantl wrote:

Now that I see it in front of me I'm not sure it was a great idea to use a backslash in quoting. But I also don't have a much better idea. TeX math notation is at least widely recognized and used in all kinds of software.

The alternative is just to introduce our own syntax and document it well.
i. e.

\sum_{all_variables} ==> SUM_ALL(variables)
\# ==> #bytes
etc.

WDYT?

Could we make the string literals in the code raw string literals though?

i.e., r'\sum' in Python, and R"\sum" in C++.

I think we can do that.

llvm/docs/CommandGuide/llvm-dwarfdump.rst

117

Nit: #bytes is a shorthand I made up, in TeX it would actually be \#bytes.

Oh, yes. I see, but it has just looked better to me :)

Is |bytes| a better notation?

I think that looks even more unclear to me.

[MaskRay]

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

25

Add -NEXT: where applicable. This improves the FileCheck error messages greatly in case the diagnostic changes.

[aprantl]

\sum_{all_variables} ==> SUM_ALL(variables)
\# ==> #bytes

If we're using a more function-like syntax I less expect the summand to come after the closing )

Does this

sum(all local variables: #bytes in parent scope ...)

or

sum_all_local_vars(#bytes in parent scope ...)

SUM_all_local_vars(#bytes in parent scope ...)

work better?

[jhenderson]

When I said add documentation, I was actually thinking of a more in-depth write up of the format, what information is presented etc, probably in a separate sub-heading. I don't use the stastistics stuff mind you, so I don't know if it would be really beneficial.

[djtodoro]

In D77789#2000546, @aprantl wrote:

\sum_{all_variables} ==> SUM_ALL(variables)
\# ==> #bytes

If we're using a more function-like syntax I less expect the summand to come after the closing )

Does this

sum(all local variables: #bytes in parent scope ...)

or

sum_all_local_vars(#bytes in parent scope ...)

This is my favorite, but we'll see how that looks visually (when finished). :)

SUM_all_local_vars(#bytes in parent scope ...)

work better?

In D77789#2001392, @jhenderson wrote:

When I said add documentation, I was actually thinking of a more in-depth write up of the format, what information is presented etc, probably in a separate sub-heading. I don't use the stastistics stuff mind you, so I don't know if it would be really beneficial.

OK. Basically, we'll need an in-depth write up, since we will introduce the function-like syntax.

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

25

Sure. I didn't consider it, since it was present, but I'll refactor that as well.

[djtodoro]

-use a function-like syntax
-add the documentation

TODO: use the string literals to avoid \\.
(@aprantl I think we can use the string literals only in C++ part, since I think r'..'feature in Python was introduced in Python 3.x, but we still use Python 2.7 for the llvm-locstats)

[aprantl]

llvm/docs/CommandGuide/llvm-dwarfdump.rst

171

The :option:--statistics option generates single-line JSON output
representing quality metrics of the processed debug info. These metrics are useful
to compare changes between two compilers, particularly for judging the effect
that a change to the compiler has on the debug info quality.

The output is formatted as key-value pairs. The first pair contains a version number.
The following naming scheme is used for the keys:

...

177

why all only in the second case?

180

For aggregated values, the following keys are used:

184

- instead of \\?

[jhenderson]

llvm/docs/CommandGuide/llvm-dwarfdump.rst

116

You might want to add a link to the section below, so that users browsing on the web can click and jump to it.

[djtodoro]

llvm/docs/CommandGuide/llvm-dwarfdump.rst

116

Sure, I've added it.

171

Sorry I haven't had much time to take another look into the write-up, but this looks very good! Thanks a lot for the suggestion!

177

Fixed.

184

Much better!

[djtodoro]

-refactoring the docs

[jhenderson]

Thanks, doc changes look good to me. I assume you have built the documentation?

[djtodoro]

Thanks for the review!

[djtodoro]

In D77789#2012049, @jhenderson wrote:

Thanks, doc changes look good to me. I assume you have built the documentation?

Yes, I have. But I'll double check that before committing. Thanks!

[jroelofs]

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

47

@djtodoro This CHECK-NOT doesn't do anything, since it's missing the ':' after it. Mind taking a look?

[djtodoro]

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

47

@jroelofs Thanks a lot! Fixed with the 67d0e2160c4d.

llvm/docs/CommandGuide/llvm-dwarfdump.rst

 .. option:: --show-section-sizes
 
             Show the sizes of all debug sections, expressed in bytes.
 
 .. option:: --statistics
 
             Collect debug info quality metrics and print the results
             as machine-readable single-line JSON output.
+            The JSON fields follows the TeX-style syntax
+            (e.g. `\\sum_{all variables}` means `sum of all variables`; `#bytes`
+            means `number of bytes`, etc.).
 
 .. option:: --summarize-types
 
             Abbreviate the description of type unit entries.
 
 .. option:: -x, --regex
 
             Treat any <name> strings as regular expressions when searching

 
 .. option:: @<FILE>
 
             Read command-line options from `<FILE>`.
 
 EXIT STATUS
 -----------
 
 :program:`llvm-dwarfdump` returns 0 if the input files were parsed and dumped
 successfully. Otherwise, it returns 1.
 
 SEE ALSO
 --------
 
 :manpage:`dsymutil(1)`

llvm/test/DebugInfo/X86/dwarf-callsite-related-attrs.ll

 ; RUN: %llc_dwarf -mtriple=x86_64-- < %s -o - | FileCheck %s -check-prefix=ASM
 ; RUN: %llc_dwarf -debugger-tune=lldb -mtriple=x86_64-- < %s -filetype=obj -o %t.o
 ; RUN: llvm-dwarfdump %t.o -o - | FileCheck %s -check-prefix=OBJ -implicit-check-not=DW_TAG_call -implicit-check-not=DW_AT_call
 ; RUN: llvm-dwarfdump -verify %t.o 2>&1 | FileCheck %s -check-prefix=VERIFY
 ; RUN: llvm-dwarfdump -statistics %t.o | FileCheck %s -check-prefix=STATS
 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis -o /dev/null
 
 ; VERIFY: No errors.
-; STATS: "call site DIEs":6
+; STATS: "#call site DIEs":6
 
 @sink = global i32 0, align 4, !dbg !0
 
 define void @__has_no_subprogram() {
 entry:
   %0 = load volatile i32, i32* @sink, align 4
   %inc = add nsw i32 %0, 1
   store volatile i32 %inc, i32* @sink, align 4

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":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 (0%,10%) of its scope covered":0
-; CHECK: "variables with [10%,20%) of its scope covered":0
-; CHECK: "variables with [20%,30%) of its scope covered":0
-; CHECK: "variables with [30%,40%) of its scope covered":0
-; CHECK: "variables with [40%,50%) of its scope covered":0
-; CHECK: "variables with [50%,60%) of its scope covered":1
-; CHECK: "variables with [60%,70%) of its scope covered":0
-; CHECK: "variables with [70%,80%) of its scope covered":0
-; CHECK: "variables with [80%,90%) of its scope covered":1
-; CHECK: "variables with [90%,100%) of its scope covered":0
-; CHECK: "variables with 100% of its scope covered":3
-; CHECK: "variables (excluding the debug entry values) with 0% of its scope covered":1
-; CHECK: "variables (excluding the debug entry values) with (0%,10%) of its scope covered":0
-; CHECK: "variables (excluding the debug entry values) with [10%,20%) of its scope covered":0
-; CHECK: "variables (excluding the debug entry values) with [20%,30%) of its scope covered":0
-; CHECK: "variables (excluding the debug entry values) with [30%,40%) of its scope covered":0
-; CHECK: "variables (excluding the debug entry values) with [40%,50%) of its scope covered":0
-; CHECK: "variables (excluding the debug entry values) with [50%,60%) of its scope covered":2
-; CHECK: "variables (excluding the debug entry values) with [60%,70%) of its scope covered":0
-; CHECK: "variables (excluding the debug entry values) with [70%,80%) of its scope covered":0
-; CHECK: "variables (excluding the debug entry values) with [80%,90%) of its scope covered":1
-; CHECK: "variables (excluding the debug entry values) with [90%,100%) of its scope covered":0
-; CHECK: "variables (excluding the debug entry values) with 100% of its scope covered":2
-; CHECK: "total params procesed by location statistics":2
-; CHECK: "params with 0% of its scope covered":0
-; CHECK: "params with (0%,10%) of its scope covered":0
-; CHECK: "params with [10%,20%) of its scope covered":0
-; CHECK: "params with [20%,30%) of its scope covered":0
-; CHECK: "params with [30%,40%) of its scope covered":0
-; CHECK: "params with [40%,50%) of its scope covered":0
-; CHECK: "params with [50%,60%) of its scope covered":0
-; CHECK: "params with [60%,70%) of its scope covered":0
-; CHECK: "params with [70%,80%) of its scope covered":0
-; CHECK: "params with [80%,90%) of its scope covered":0
-; CHECK: "params with [90%,100%) of its scope covered":0
-; CHECK: "params with 100% of its scope covered":2
-; CHECK: "params (excluding the debug entry values) with 0% of its scope covered":0
-; CHECK: "params (excluding the debug entry values) with (0%,10%) of its scope covered":0
-; CHECK: "params (excluding the debug entry values) with [10%,20%) of its scope covered":0
-; CHECK: "params (excluding the debug entry values) with [20%,30%) of its scope covered":0
-; CHECK: "params (excluding the debug entry values) with [30%,40%) of its scope covered":0
-; CHECK: "params (excluding the debug entry values) with [40%,50%) of its scope covered":0
-; CHECK: "params (excluding the debug entry values) with [50%,60%) of its scope covered":1
-; CHECK: "params (excluding the debug entry values) with [60%,70%) of its scope covered":0
-; CHECK: "params (excluding the debug entry values) with [70%,80%) of its scope covered":0
-; CHECK: "params (excluding the debug entry values) with [80%,90%) of its scope covered":0
-; CHECK: "params (excluding the debug entry values) with [90%,100%) of its scope covered":0
-; CHECK: "params (excluding the debug entry values) with 100% of its scope covered":1
-; CHECK: "total vars procesed by location statistics":4
-; CHECK: "vars with 0% of its scope covered":1
-; CHECK: "vars with (0%,10%) of its scope covered":0
-; CHECK: "vars with [10%,20%) of its scope covered":0
-; CHECK: "vars with [20%,30%) of its scope covered":0
-; CHECK: "vars with [30%,40%) of its scope covered":0
-; CHECK: "vars with [40%,50%) of its scope covered":0
-; CHECK: "vars with [50%,60%) of its scope covered":1
-; CHECK: "vars with [60%,70%) of its scope covered":0
-; CHECK: "vars with [70%,80%) of its scope covered":0
-; CHECK: "vars with [80%,90%) of its scope covered":1
-; CHECK: "vars with [90%,100%) of its scope covered":0
-; CHECK: "vars with 100% of its scope covered":1
-; CHECK: "vars (excluding the debug entry values) with 0% of its scope covered":1
-; CHECK: "vars (excluding the debug entry values) with (0%,10%) of its scope covered":0
-; CHECK: "vars (excluding the debug entry values) with [10%,20%) of its scope covered":0
-; CHECK: "vars (excluding the debug entry values) with [20%,30%) of its scope covered":0
-; CHECK: "vars (excluding the debug entry values) with [30%,40%) of its scope covered":0
-; CHECK: "vars (excluding the debug entry values) with [40%,50%) of its scope covered":0
-; CHECK: "vars (excluding the debug entry values) with [50%,60%) of its scope covered":1
-; CHECK: "vars (excluding the debug entry values) with [60%,70%) of its scope covered":0
-; CHECK: "vars (excluding the debug entry values) with [70%,80%) of its scope covered":0
-; CHECK: "vars (excluding the debug entry values) with [80%,90%) of its scope covered":1
-; CHECK: "vars (excluding the debug entry values) with [90%,100%) of its scope covered":0
-; CHECK: "vars (excluding the debug entry values) with 100% of its scope covered":1
-;
+
+; CHECK: "\\sum_{all variables} #bytes in parent scope covered by DW_OP_entry_value":5
+; CHECK: "\\sum_{all params} #bytes in parent scope":20
+; CHECK: "\\sum_{all params} #bytes in parent scope covered by DW_AT_location":20
+; CHECK: "\\sum_{all params} #bytes in parent scope covered by DW_OP_entry_value":5
+; CHECK: "\\sum_{all local vars} #bytes in parent scope":90
+; CHECK: "\\sum_{all local vars} #bytes in parent scope covered by DW_AT_location":60
+; CHECK: "\\sum_{all local vars} #bytes in parent scope covered by DW_OP_entry_value":0
+; CHECK: "#variables processed by location statistics":6
+; CHECK: "#variables with 0% of parent scope covered by DW_AT_location":1
+; CHECK: "#variables with (0%,10%) of parent scope covered by DW_AT_location":0
+; CHECK: "#variables with [10%,20%) of parent scope covered by DW_AT_location":0
+; CHECK: "#variables with [20%,30%) of parent scope covered by DW_AT_location":0
+; CHECK: "#variables with [30%,40%) of parent scope covered by DW_AT_location":0
+; CHECK: "#variables with [40%,50%) of parent scope covered by DW_AT_location":0
+; CHECK: "#variables with [50%,60%) of parent scope covered by DW_AT_location":1
+; CHECK: "#variables with [60%,70%) of parent scope covered by DW_AT_location":0
+; CHECK: "#variables with [70%,80%) of parent scope covered by DW_AT_location":0
+; CHECK: "#variables with [80%,90%) of parent scope covered by DW_AT_location":1
+; CHECK: "#variables with [90%,100%) of parent scope covered by DW_AT_location":0
+; CHECK: "#variables with 100% of parent scope covered by DW_AT_location":3
+; CHECK: "#variables \\ entry values with 0% of parent scope covered by DW_AT_location":1
+; CHECK: "#variables \\ entry values with (0%,10%) of parent scope covered by DW_AT_location":0
+; CHECK: "#variables \\ entry values with [10%,20%) of parent scope covered by DW_AT_location":0
+; CHECK: "#variables \\ entry values with [20%,30%) of parent scope covered by DW_AT_location":0
+; CHECK: "#variables \\ entry values with [30%,40%) of parent scope covered by DW_AT_location":0
+; CHECK: "#variables \\ entry values with [40%,50%) of parent scope covered by DW_AT_location":0
+; CHECK: "#variables \\ entry values with [50%,60%) of parent scope covered by DW_AT_location":2
+; CHECK: "#variables \\ entry values with [60%,70%) of parent scope covered by DW_AT_location":0
+; CHECK: "#variables \\ entry values with [70%,80%) of parent scope covered by DW_AT_location":0
+; CHECK: "#variables \\ entry values with [80%,90%) of parent scope covered by DW_AT_location":1
+; CHECK: "#variables \\ entry values with [90%,100%) of parent scope covered by DW_AT_location":0
+; CHECK: "#variables \\ entry values with 100% of parent scope covered by DW_AT_location":2
+; CHECK: "#params processed by location statistics":2
+; CHECK: "#params with 0% of parent scope covered by DW_AT_location":0
+; CHECK: "#params with (0%,10%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params with [10%,20%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params with [20%,30%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params with [30%,40%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params with [40%,50%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params with [50%,60%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params with [60%,70%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params with [70%,80%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params with [80%,90%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params with [90%,100%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params with 100% of parent scope covered by DW_AT_location":2
+; CHECK: "#params \\ entry values with 0% of parent scope covered by DW_AT_location":0
+; CHECK: "#params \\ entry values with (0%,10%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params \\ entry values with [10%,20%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params \\ entry values with [20%,30%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params \\ entry values with [30%,40%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params \\ entry values with [40%,50%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params \\ entry values with [50%,60%) of parent scope covered by DW_AT_location":1
+; CHECK: "#params \\ entry values with [60%,70%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params \\ entry values with [70%,80%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params \\ entry values with [80%,90%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params \\ entry values with [90%,100%) of parent scope covered by DW_AT_location":0
+; CHECK: "#params \\ entry values with 100% of parent scope covered by DW_AT_location":1
+; CHECK: "#local vars processed by location statistics":4
+; CHECK: "#local vars with 0% of parent scope covered by DW_AT_location":1
+; CHECK: "#local vars with (0%,10%) of parent scope covered by DW_AT_location":0
+; CHECK: "#local vars with [10%,20%) of parent scope covered by DW_AT_location":0
+; CHECK: "#local vars with [20%,30%) of parent scope covered by DW_AT_location":0
+; CHECK: "#local vars with [30%,40%) of parent scope covered by DW_AT_location":0
+; CHECK: "#local vars with [40%,50%) of parent scope covered by DW_AT_location":0
+; CHECK: "#local vars with [50%,60%) of parent scope covered by DW_AT_location":1
+; CHECK: "#local vars with [60%,70%) of parent scope covered by DW_AT_location":0
+; CHECK: "#local vars with [70%,80%) of parent scope covered by DW_AT_location":0
+; CHECK: "#local vars with [80%,90%) of parent scope covered by DW_AT_location":1
+; CHECK: "#local vars with [90%,100%) of parent scope covered by DW_AT_location":0
+; CHECK: "#local vars with 100% of parent scope covered by DW_AT_location":1
+; CHECK: "#local vars \\ entry values with 0% of parent scope covered by DW_AT_location":1
+; CHECK: "#local vars \\ entry values with (0%,10%) of parent scope covered by DW_AT_location":0
+; CHECK: "#local vars \\ entry values with [10%,20%) of parent scope covered by DW_AT_location":0
+; CHECK: "#local vars \\ entry values with [20%,30%) of parent scope covered by DW_AT_location":0
+; CHECK: "#local vars \\ entry values with [30%,40%) of parent scope covered by DW_AT_location":0
+; CHECK: "#local vars \\ entry values with [40%,50%) of parent scope covered by DW_AT_location":0
+; CHECK: "#local vars \\ entry values with [50%,60%) of parent scope covered by DW_AT_location":1
+; CHECK: "#local vars \\ entry values with [60%,70%) of parent scope covered by DW_AT_location":0
+; CHECK: "#local vars \\ entry values with [70%,80%) of parent scope covered by DW_AT_location":0
+; CHECK: "#local vars \\ entry values with [80%,90%) of parent scope covered by DW_AT_location":1
+; CHECK: "#local vars \\ entry values with [90%,100%) of parent scope covered by DW_AT_location":0
+; CHECK: "#local vars \\ entry values with 100% of parent scope covered by DW_AT_location":1
+
 ; The source code of the test case:
 ; extern void fn3(int *);
 ; extern void fn2 (int);
 ; __attribute__((noinline))
 ; void
 ; fn1 (int x, int y)
 ; {
 ;   int u = x + y;
 ;   if (x > 1)
 ;     u += 1;
 ;   else
 ;     u += 2;
 ;   if (y > 4)
 ;     u += x;
 ;   int a = 7;
 ;   fn2 (a);
 ;   u --;
 ; }
-;
+
 ; __attribute__((noinline))
 ; int f()
 ; {
 ;   int l, k;
 ;   fn3(&l);
 ;   fn3(&k);
 ;   fn1 (l, k);
 ;   return 0;
 ; }
-;
+
 ; ModuleID = 'test.c'
 source_filename = "test.c"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: noinline nounwind uwtable
 define dso_local void @fn1(i32 %x, i32 %y) local_unnamed_addr !dbg !16 {
 entry:

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":12
-# CHECK: "vars scope bytes covered":8
+# CHECK: "\\sum_{all local vars} #bytes in parent scope":12
+# CHECK: "\\sum_{all local vars} #bytes in parent scope covered by DW_AT_location":8
 
         .text
 
 # Add padding to ensure the function does not start at address zero.
         .zero 256
 
 f:                                      # @f
 .Lf_begin:

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

 #   printf ("fibonacci(9) = %d\n", result);
 #   result = fib(10);
 #   printf ("fibonacci(10) = %d\n", result);
 # 
 #   return 0;
 # }
 #
 
-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
+CHECK: "version":5
+CHECK: "#functions":3
+CHECK: "#functions with location":3
+CHECK: "#inlined functions":7
+CHECK: "#inlined functions 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":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
+CHECK: "#source variables with location":22
+CHECK: "#call site entries":7
+CHECK: "\\sum_{all variables} #bytes in parent scope":2817
+CHECK: "\\sum_{all variables} #bytes in parent scope covered by DW_AT_location":1160
+CHECK: "#bytes witin functions":594
+CHECK: "#bytes witin inlined functions":345
+CHECK: "#params":12
+CHECK: "#params with source location":12
+CHECK: "#params with type":12
+CHECK: "#params with binary location":12
+CHECK: "#local vars":18
+CHECK: "#local vars with source location":18
+CHECK: "#local vars with type":18
 
 # Ideally the value below would be 18, but currently it's not.
-CHECK: "vars with binary location":10
+CHECK: "#local vars with binary location":10

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

 #   printf ("fibonacci(9) = %d\n", result);
 #   result = fib(10);
 #   printf ("fibonacci(10) = %d\n", result);
 # 
 #   return 0;
 # }
 #
 
-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
+CHECK: "version":5
+CHECK: "#functions":3
+CHECK: "#functions with location":3
+CHECK: "#inlined functions":8
+CHECK: "#inlined functions 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":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
+CHECK: "#source variables with location":24
+CHECK: "#call site entries":8
+CHECK: "\\sum_{all variables} #bytes in parent scope":3072
+CHECK: "\\sum_{all variables} #bytes in parent scope covered by DW_AT_location":1188
+CHECK: "#bytes witin functions":636
+CHECK: "#bytes witin inlined functions":388
+CHECK: "#params":13
+CHECK: "#params with source location":13
+CHECK: "#params with type":13
+CHECK: "#params with binary location":13
+CHECK: "#local vars":20
+CHECK: "#local vars with source location":20
+CHECK: "#local vars with type":20
 
 # Ideally the value below would be 20, but currently it's not.
-CHECK: "vars with binary location":11
+CHECK: "#local 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":4
+; CHECK: "version":5
 
 ; namespace test {
 ;  extern int a;
 ; }
 ; using test::a;
 ;
 ; int GlobalConst = 42;
 ; int Global;

 ;     - square::i,
 ;     - cube::i, cube::squared
 ;     - boo::1, boo::2
 ; Skipped entities:
 ;     - declaration of test::a,
 ;     - non-constant member S:fn,
 ;     - arguments of S:fn.
 
-; CHECK: "unique source variables":9
+; CHECK: "#unique source variables":9
 ; +1 extra inline i.
-; CHECK: "source variables":10
+; CHECK: "#source variables":10
 ; -1 square::i
-; CHECK: "variables with location":9
-; CHECK: "scope bytes total":[[BYTES:[0-9]+]]
+; CHECK: "#source variables with location":9
+; CHECK: "\\sum_{all variables} #bytes in parent scope":[[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":
-; CHECK: "total function size":[[FUNCSIZE:[0-9]+]]
-; CHECK: "total inlined function size":[[INLINESIZE:[0-9]+]]
-; CHECK: "size of __debug_info":380
-; CHECK: "size of __debug_loc":35
-; CHECK: "size of __debug_abbrev":303
-; CHECK: "size of __debug_line":117
-; CHECK: "size of __debug_str":204
+; CHECK-NOT: "\\sum_{all variables} #bytes in parent scope covered by DW_AT_location":0
+; CHECK-NOT "\\sum_{all variables} #bytes in parent scope covered by DW_AT_location":[[BYTES]]
+; CHECK: "\\sum_{all variables} #bytes in parent scope covered by DW_AT_location":
+; CHECK: "#bytes witin functions":[[FUNCSIZE:[0-9]+]]
+; CHECK: "#bytes witin inlined functions":[[INLINESIZE:[0-9]+]]
+; CHECK: "#bytes in __debug_info":380
+; CHECK: "#bytes in __debug_loc":35
+; CHECK: "#bytes in __debug_abbrev":303
+; CHECK: "#bytes in __debug_line":117
+; CHECK: "#bytes in __debug_str":204
 
 ; 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 (i32)* }
 

llvm/test/tools/llvm-dwarfdump/X86/stats-dbg-callsite-info.ll

 ; RUN: llc -emit-call-site-info -debug-entry-values %s -o - -filetype=obj \
 ; RUN:   | llvm-dwarfdump -statistics - | FileCheck %s
 ;
 ; The LLVM IR file was generated on this source code by using
 ; option '-femit-debug-entry-values'.
 ;
 ; extern void foo(int *a, int b, int c, int d, int e, int f);
 ; extern int getVal();
 ;
 ; void baa(int arg1, int arg2, int arg3) {
 ;   int local1 = getVal();
 ;   foo(&local1, arg2, 10, 15, arg3 + 3, arg1 + arg2);
 ; }
 ;
-; CHECK: "call site DIEs":2
-; CHECK-SAME: "call site parameter DIEs":6
+; CHECK: "#call site DIEs":2
+; CHECK-SAME: "#call site parameter DIEs":6
 ;
 ; ModuleID = 'test.c'
 source_filename = "test.c"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: nounwind uwtable
 define dso_local void @baa(i32 %arg1, i32 %arg2, i32 %arg3) local_unnamed_addr #0 !dbg !10 {

llvm/test/tools/llvm-dwarfdump/X86/stats-inlining-multi-cu.ll

 ; RUN: llc -O0 %s -o - -filetype=obj \
 ; RUN:   | llvm-dwarfdump -statistics - | FileCheck %s
 
 ; Test that abstract origins in multiple CUs are uniqued.
 
-; CHECK:      "source functions":4,
-; CHECK-SAME: "inlined functions":2,
-; CHECK-SAME: "unique source variables":4
-; CHECK-SAME: "source variables":6
-; CHECK-SAME: "variables with location":6
+; CHECK:      "#functions":4,
+; CHECK-SAME: "#inlined functions":2,
+; CHECK-SAME: "#unique source variables":4
+; CHECK-SAME: "#source variables":6
+; CHECK-SAME: "#source variables with location":6
 
 ;header.h:
 ;extern "C" int getchar();
 ;template<typename T> T __attribute__((always_inline)) inlined() {
 ;  if (getchar()=='a') {
 ;    int i = getchar();
 ;    return i;
 ;  } else {

llvm/test/tools/llvm-dwarfdump/X86/stats-inlining-single-cu.ll

 ; RUN: llc -O0 %s -o - -filetype=obj \
 ; RUN:   | llvm-dwarfdump -statistics - | FileCheck %s
 
 ; This test serves as a baseline / sanity-check for stats-inlining-multi-cu.ll
 ; The results for both tests should be identical.
 
-; CHECK:      "source functions":4,
-; CHECK-SAME: "inlined functions":2,
-; CHECK-SAME: "unique source variables":4
-; CHECK-SAME: "source variables":6
-; CHECK-SAME: "variables with location":6
+; CHECK:      "#functions":4,
+; CHECK-SAME: "#inlined functions":2,
+; CHECK-SAME: "#unique source variables":4
+; CHECK-SAME: "#source variables":6
+; CHECK-SAME: "#source variables with location":6
 
 ;header.h:
 ;extern "C" int getchar();
 ;template<typename T> T __attribute__((always_inline)) inlined() {
 ;  if (getchar()=='a') {
 ;    int i = getchar();
 ;    return i;
 ;  } else {

llvm/test/tools/llvm-dwarfdump/X86/stats-mulitple-cu-out-of-line.ll

 ; #include "test.h"
 ; int bar() { return foo(42); }
 ;
 ; $ cat test2.cpp
 ;
 ; #include "test.h"
 ; int far() { return foo(42); }
 
-; CHECK:      "source functions":3
-; CHECK-SAME: "source functions with location":3
-; CHECK-SAME: "inlined functions":0
-; CHECK-SAME: "unique source variables":1
-; CHECK-SAME: "source variables":2
-; CHECK-SAME: "variables with location":2
+; CHECK:      "#functions":3
+; CHECK-SAME: "#functions with location":3
+; CHECK-SAME: "#inlined functions":0
+; CHECK-SAME: "#unique source variables":1
+; CHECK-SAME: "#source variables":2
+; CHECK-SAME: "#source variables with location":2
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: noinline nounwind optnone uwtable
 define dso_local i32 @_Z3fooi.1(i32 %a) !dbg !9 {
 entry:
   %a.addr = alloca i32, align 4

llvm/test/tools/llvm-dwarfdump/X86/stats-multiple-cu-members.ll

 ; $ cat test1.cpp
 ; #include "test.h"
 ; s S1;
 ;
 ; $ cat test2.cpp
 ; #include "test.h"
 ; s S2;
 
-; CHECK:      "source variables":4
-; CHECK-SAME: "variables with location":4
+; CHECK:      "#source variables":4
+; CHECK-SAME: "#source variables with location":4
 
 source_filename = "llvm-link"
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %struct.s = type { i8 }
 %struct.s.1 = type { i8 }
 

llvm/test/tools/llvm-dwarfdump/X86/stats-multiple-cu-same-name.ll

 ; RUN: llc -O0 %s -o - -filetype=obj \
 ; RUN:   | llvm-dwarfdump -statistics - | FileCheck %s
 
 ; Test that statistics distinguish functions with the same name.
 
-; CHECK:      "source functions":4,
-; CHECK-SAME: "unique source variables":2
-; CHECK-SAME: "source variables":2
+; CHECK:      "#functions":4,
+; CHECK-SAME: "#unique source variables":2
+; CHECK-SAME: "#source variables":2
 
 ; $ cat test1.cpp
 ; static int foo(int a) {
 ;   return a;
 ; }
 ; int boo() { return foo(42); }
 ;
 ; $ cat test2.cpp

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 variables.
-  unsigned NumVars = 0;
-  /// Number of variables with source location.
-  unsigned NumVarSourceLocations = 0;
-  /// Number of variables with type.
-  unsigned NumVarTypes = 0;
-  /// Number of variables with DW_AT_location.
-  unsigned NumVarLocations = 0;
+  /// Number of local variables.
+  unsigned NumLocalVars = 0;
+  /// Number of local variables with source location.
+  unsigned NumLocalVarSourceLocations = 0;
+  /// Number of local variables with type.
+  unsigned NumLocalVarTypes = 0;
+  /// Number of local variables with DW_AT_location.
+  unsigned NumLocalVarLocations = 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.
   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
-  /// (only for parameters).
+  /// Total number of PC range bytes in each parameter's enclosing scope.
   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
-  /// (only for local variables).
-  unsigned VarScopeBytes = 0;
+  unsigned LocalVarScopeBytesCovered = 0;
+  /// Total number of PC range bytes in each local variable's enclosing scope.
+  unsigned LocalVarScopeBytes = 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;
+  unsigned LocalVarScopeEntryValueBytesCovered = 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).
   unsigned CallSiteParamDIEs = 0;
   /// Total byte size of concrete functions. This byte size includes
   /// inline functions contained in the concrete functions.
std::vector<unsigned> VarParamNonEntryValLocStats{
       std::vector<unsigned>(NumOfCoverageCategories, 0)};
   /// The debug location statistics for formal parameters.
   std::vector<unsigned> ParamLocStats{
       std::vector<unsigned>(NumOfCoverageCategories, 0)};
   /// Map non debug entry values coverage for formal parameters.
   std::vector<unsigned> ParamNonEntryValLocStats{
       std::vector<unsigned>(NumOfCoverageCategories, 0)};
   /// The debug location statistics for local variables.
-  std::vector<unsigned> VarLocStats{
+  std::vector<unsigned> LocalVarLocStats{
       std::vector<unsigned>(NumOfCoverageCategories, 0)};
   /// Map non debug entry values coverage for local variables.
-  std::vector<unsigned> VarNonEntryValLocStats{
+  std::vector<unsigned> LocalVarNonEntryValLocStats{
       std::vector<unsigned>(NumOfCoverageCategories, 0)};
   /// 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;
 };
 } // namespace
 
 /// 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) {
+                            std::vector<unsigned> &LocalVarLocStats,
+                            bool IsParam, bool IsLocalVar) {
   auto getCoverageBucket = [BytesCovered, BytesInScope]() -> unsigned {
     // No debug location at all for the variable.
     if (BytesCovered == 0)
       return 0;
     // Fully covered variable within its scope.
     if (BytesCovered >= BytesInScope)
       return NumOfCoverageCategories - 1;
     // Get covered range (e.g. 20%-29%).
     unsigned LocBucket = 100 * (double)BytesCovered / BytesInScope;
     LocBucket /= 10;
     return LocBucket + 1;
   };
 
   unsigned CoverageBucket = getCoverageBucket();
   VarParamLocStats[CoverageBucket]++;
   if (IsParam)
     ParamLocStats[CoverageBucket]++;
   else if (IsLocalVar)
-    VarLocStats[CoverageBucket]++;
+    LocalVarLocStats[CoverageBucket]++;
 }
 /// Construct an identifier for a given DIE from its Prefix, Name, DeclFileName
 /// and DeclLine. The identifier aims to be unique for any unique entities,
 /// but keeping the same among different instances of the same entity.
 static std::string constructDieID(DWARFDie Die,
                                   StringRef Prefix = StringRef()) {
   std::string IDStr;
   llvm::raw_string_ostream ID(IDStr);
static void collectStatsForDie(DWARFDie Die, std::string FnPrefix,
                                LocationStats &LocStats) {
   bool HasLoc = false;
   bool HasSrcLoc = false;
   bool HasType = false;
   uint64_t BytesCovered = 0;
   uint64_t BytesEntryValuesCovered = 0;
   auto &FnStats = FnStatMap[FnPrefix];
   bool IsParam = Die.getTag() == dwarf::DW_TAG_formal_parameter;
-  bool IsVariable = Die.getTag() == dwarf::DW_TAG_variable;
+  bool IsLocalVar = Die.getTag() == dwarf::DW_TAG_variable;
   bool IsConstantMember = Die.getTag() == dwarf::DW_TAG_member &&
                           Die.find(dwarf::DW_AT_const_value);
 
   if (Die.getTag() == dwarf::DW_TAG_call_site ||
       Die.getTag() == dwarf::DW_TAG_GNU_call_site) {
     GlobalStats.CallSiteDIEs++;
     return;
   }
 
   if (Die.getTag() == dwarf::DW_TAG_call_site_parameter ||
       Die.getTag() == dwarf::DW_TAG_GNU_call_site_parameter) {
     GlobalStats.CallSiteParamDIEs++;
     return;
   }
 
-  if (!IsParam && !IsVariable && !IsConstantMember) {
+  if (!IsParam && !IsLocalVar && !IsConstantMember) {
     // Not a variable or constant member.
     return;
   }
 
   // Ignore declarations of global variables.
-  if (IsVariable && Die.find(dwarf::DW_AT_declaration))
+  if (IsLocalVar && Die.find(dwarf::DW_AT_declaration))
     return;
 
   if (Die.findRecursively(dwarf::DW_AT_decl_file) &&
       Die.findRecursively(dwarf::DW_AT_decl_line))
     HasSrcLoc = true;
 
   if (Die.findRecursively(dwarf::DW_AT_type))
     HasType = true;
if (Die.find(dwarf::DW_AT_const_value)) {
     }
   }
 
   // Calculate the debug location statistics.
   if (BytesInScope) {
     LocStats.NumVarParam++;
     if (IsParam)
       LocStats.NumParam++;
-    else if (IsVariable)
+    else if (IsLocalVar)
       LocStats.NumVar++;
 
     collectLocStats(BytesCovered, BytesInScope, LocStats.VarParamLocStats,
-                    LocStats.ParamLocStats, LocStats.VarLocStats, IsParam,
-                    IsVariable);
+                    LocStats.ParamLocStats, LocStats.LocalVarLocStats, IsParam,
+                    IsLocalVar);
     // Non debug entry values coverage statistics.
     collectLocStats(BytesCovered - BytesEntryValuesCovered, BytesInScope,
                     LocStats.VarParamNonEntryValLocStats,
                     LocStats.ParamNonEntryValLocStats,
-                    LocStats.VarNonEntryValLocStats, IsParam, IsVariable);
+                    LocStats.LocalVarNonEntryValLocStats, IsParam, IsLocalVar);
   }
 
   // Collect PC range coverage data.
   if (DWARFDie D =
           Die.getAttributeValueAsReferencedDie(dwarf::DW_AT_abstract_origin))
     Die = D;
 
   std::string VarID = constructDieID(Die, VarPrefix);
   FnStats.VarsInFunction.insert(VarID);
 
   if (BytesInScope) {
     // Turns out we have a lot of ranges that extend past the lexical scope.
     GlobalStats.ScopeBytesCovered += std::min(BytesInScope, BytesCovered);
     GlobalStats.ScopeBytes += BytesInScope;
     GlobalStats.ScopeEntryValueBytesCovered += BytesEntryValuesCovered;
     if (IsParam) {
       GlobalStats.ParamScopeBytesCovered +=
           std::min(BytesInScope, BytesCovered);
       GlobalStats.ParamScopeBytes += BytesInScope;
       GlobalStats.ParamScopeEntryValueBytesCovered += BytesEntryValuesCovered;
-    } else if (IsVariable) {
-      GlobalStats.VarScopeBytesCovered += std::min(BytesInScope, BytesCovered);
-      GlobalStats.VarScopeBytes += BytesInScope;
-      GlobalStats.VarScopeEntryValueBytesCovered += BytesEntryValuesCovered;
+    } else if (IsLocalVar) {
+      GlobalStats.LocalVarScopeBytesCovered +=
+          std::min(BytesInScope, BytesCovered);
+      GlobalStats.LocalVarScopeBytes += BytesInScope;
+      GlobalStats.LocalVarScopeEntryValueBytesCovered +=
+          BytesEntryValuesCovered;
     }
     assert(GlobalStats.ScopeBytesCovered <= GlobalStats.ScopeBytes);
   }
 
   if (IsConstantMember) {
     FnStats.ConstantMembers++;
     return;
   }
 
   FnStats.TotalVarWithLoc += (unsigned)HasLoc;
 
   if (Die.find(dwarf::DW_AT_artificial)) {
     FnStats.NumArtificial++;
     return;
   }
 
   if (IsParam) {
     FnStats.NumParams++;
     if (HasType)
       FnStats.NumParamTypes++;
     if (HasSrcLoc)
       FnStats.NumParamSourceLocations++;
     if (HasLoc)
       FnStats.NumParamLocations++;
-  } else if (IsVariable) {
-    FnStats.NumVars++;
+  } else if (IsLocalVar) {
+    FnStats.NumLocalVars++;
     if (HasType)
-      FnStats.NumVarTypes++;
+      FnStats.NumLocalVarTypes++;
     if (HasSrcLoc)
-      FnStats.NumVarSourceLocations++;
+      FnStats.NumLocalVarSourceLocations++;
     if (HasLoc)
-      FnStats.NumVarLocations++;
+      FnStats.NumLocalVarLocations++;
   }
 }
 
 /// Recursively collect debug info quality metrics.
 static void collectStatsRecursive(DWARFDie Die, std::string FnPrefix,
                                   std::string VarPrefix, uint64_t BytesInScope,
                                   uint32_t InlineDepth,
                                   StringMap<PerFunctionStats> &FnStatMap,

 /// 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) {
   OS << ",\"" << Key << "\":" << Value;
   LLVM_DEBUG(llvm::dbgs() << Key << ": " << Value << '\n');
 }
 
-static void printLocationStats(raw_ostream &OS,
-                               const char *Key,
+static void printLocationStats(raw_ostream &OS, const char *Key,
                                std::vector<unsigned> &LocationStats) {
-  OS << ",\"" << Key << " with 0% of its scope covered\":"
+  OS << ",\"" << Key << " with 0% of parent scope covered by DW_AT_location\":"
      << LocationStats[0];
-  LLVM_DEBUG(llvm::dbgs() << Key << " with 0% of its scope covered: "
-                          << LocationStats[0] << '\n');
-  OS << ",\"" << Key << " with (0%,10%) of its scope covered\":"
+  LLVM_DEBUG(
+      llvm::dbgs() << Key
+                   << " with 0% of parent scope covered by DW_AT_location: \\"
+  OS << ",\"" << Key
+     << " with (0%,10%) of parent scope covered by DW_AT_location\":"
      << LocationStats[1];
-  LLVM_DEBUG(llvm::dbgs() << Key << " with (0%,10%) of its scope covered: "
-                          << LocationStats[1] << '\n');
+  LLVM_DEBUG(llvm::dbgs()
+             << Key
+             << " with (0%,10%) of parent scope covered by DW_AT_location: "
   for (unsigned i = 2; i < NumOfCoverageCategories - 1; ++i) {
     OS << ",\"" << Key << " with [" << (i - 1) * 10 << "%," << i * 10
-       << "%) of its scope covered\":" << LocationStats[i];
+       << "%) of parent scope covered by DW_AT_location\":" << LocationStats[i];
     LLVM_DEBUG(llvm::dbgs()
                << Key << " with [" << (i - 1) * 10 << "%," << i * 10
-               << "%) of its scope covered: " << LocationStats[i]);
+               << "%) of parent scope covered by DW_AT_location: "
+               << LocationStats[i]);
   }
-  OS << ",\"" << Key << " with 100% of its scope covered\":"
+  OS << ",\"" << Key
+     << " with 100% of parent scope covered by DW_AT_location\":"
      << LocationStats[NumOfCoverageCategories - 1];
-  LLVM_DEBUG(llvm::dbgs() << Key << " with 100% of its scope covered: "
-                          << LocationStats[NumOfCoverageCategories - 1]);
+  LLVM_DEBUG(
+      llvm::dbgs() << Key
+                   << " with 100% of parent scope covered by DW_AT_location: "
 }
 
 static void printSectionSizes(raw_ostream &OS, const SectionSizes &Sizes) {
   for (const auto &DebugSec : Sizes.DebugSectionSizes)
-    OS << ",\"size of " << DebugSec.getKey() << "\":" << DebugSec.getValue();
+    OS << ",\"#bytes in " << DebugSec.getKey() << "\":" << DebugSec.getValue();
 }
 
 /// \}
 
 /// 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
bool dwarfdump::collectStatsForObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
 
   /// Collect the sizes of debug sections.
   SectionSizes Sizes;
   calculateSectionSizes(Obj, Sizes, Filename);
 
   /// 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 = 4;
+  unsigned Version = 5;
   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 ParamWithSrcLoc = 0;
-  unsigned VarTotal = 0;
-  unsigned VarWithType = 0;
-  unsigned VarWithSrcLoc = 0;
-  unsigned VarWithLoc = 0;
+  unsigned LocalVarTotal = 0;
+  unsigned LocalVarWithType = 0;
+  unsigned LocalVarWithSrcLoc = 0;
+  unsigned LocalVarWithLoc = 0;
   for (auto &Entry : Statistics) {
     PerFunctionStats &Stats = Entry.getValue();
     unsigned TotalVars = Stats.VarsInFunction.size() *
                          (Stats.NumFnInlined + Stats.NumFnOutOfLine);
     // Count variables in global scope.
     if (!Stats.IsFunction)
-      TotalVars = Stats.NumVars + Stats.ConstantMembers + Stats.NumArtificial;
+      TotalVars =
+          Stats.NumLocalVars + Stats.ConstantMembers + Stats.NumArtificial;
     unsigned Constants = Stats.ConstantMembers;
     VarParamWithLoc += Stats.TotalVarWithLoc + Constants;
     VarParamTotal += TotalVars;
     VarParamUnique += Stats.VarsInFunction.size();
     LLVM_DEBUG(for (auto &V
                     : Stats.VarsInFunction) llvm::dbgs()
                << 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;
     ParamWithSrcLoc += Stats.NumParamSourceLocations;
-    VarTotal += Stats.NumVars;
-    VarWithType += Stats.NumVarTypes;
-    VarWithLoc += Stats.NumVarLocations;
-    VarWithSrcLoc += Stats.NumVarSourceLocations;
+    LocalVarTotal += Stats.NumLocalVars;
+    LocalVarWithType += Stats.NumLocalVarTypes;
+    LocalVarWithLoc += Stats.NumLocalVarLocations;
+    LocalVarWithSrcLoc += Stats.NumLocalVarSourceLocations;
   }
 
   // Print summary.
   OS.SetBufferSize(1024);
   OS << "{\"version\":" << Version;
   LLVM_DEBUG(llvm::dbgs() << "Variable location quality metrics\n";
              llvm::dbgs() << "---------------------------------\n");
+
   printDatum(OS, "file", Filename.str());
   printDatum(OS, "format", FormatName);
-  printDatum(OS, "source functions", NumFunctions);
-  printDatum(OS, "source functions with location", NumFuncsWithSrcLoc);
-  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.ScopeBytes);
-  printDatum(OS, "scope bytes covered", GlobalStats.ScopeBytesCovered);
-  printDatum(OS, "entry value scope bytes covered",
+
+  printDatum(OS, "#functions", NumFunctions);
+  printDatum(OS, "#functions with location", NumFuncsWithSrcLoc);
+  printDatum(OS, "#inlined functions", NumInlinedFunctions);
+  printDatum(OS, "#inlined functions with abstract origins",
+             NumAbstractOrigins);
+
+  // This includes local variables and formal parameters.
+  printDatum(OS, "#unique source variables", VarParamUnique);
+  printDatum(OS, "#source variables", VarParamTotal);
+  printDatum(OS, "#source 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, "\\\\sum_{all variables} #bytes in parent scope",
+             GlobalStats.ScopeBytes);
+  printDatum(OS,
+             "\\\\sum_{all variables} #bytes in parent scope covered by "
+             "DW_AT_location",
+             GlobalStats.ScopeBytesCovered);
+  printDatum(OS,
+             "\\\\sum_{all variables} #bytes in parent scope covered by "
+             "DW_OP_entry_value",
              GlobalStats.ScopeEntryValueBytesCovered);
-  printDatum(OS, "formal params scope bytes total",
+
+  printDatum(OS, "\\\\sum_{all params} #bytes in parent scope",
              GlobalStats.ParamScopeBytes);
-  printDatum(OS, "formal params scope bytes covered",
-             GlobalStats.ParamScopeBytesCovered);
-  printDatum(OS, "formal params entry value scope bytes covered",
+  printDatum(
+      OS,
+      "\\\\sum_{all params} #bytes in parent scope covered by DW_AT_location",
+  printDatum(OS,
+             "\\\\sum_{all params} #bytes in parent scope covered by "
+             "DW_OP_entry_value",
              GlobalStats.ParamScopeEntryValueBytesCovered);
-  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);
-  printDatum(OS, "formal params with binary location", ParamWithLoc);
-  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);
-  printDatum(OS, "total variables procesed by location statistics",
-             LocStats.NumVarParam);
+
+  printDatum(OS, "\\\\sum_{all local vars} #bytes in parent scope",
+             GlobalStats.LocalVarScopeBytes);
+  printDatum(OS,
+             "\\\\sum_{all local vars} #bytes in parent scope covered by "
+             "DW_AT_location",
+             GlobalStats.LocalVarScopeBytesCovered);
+  printDatum(OS,
+             "\\\\sum_{all local vars} #bytes in parent scope covered by "
+             "DW_OP_entry_value",
+             GlobalStats.LocalVarScopeEntryValueBytesCovered);
+
+  printDatum(OS, "#bytes witin functions", GlobalStats.FunctionSize);
+  printDatum(OS, "#bytes witin inlined functions",
+             GlobalStats.InlineFunctionSize);
+
+  // Print the summary for formal parameters.
+  printDatum(OS, "#params", ParamTotal);
+  printDatum(OS, "#params with source location", ParamWithSrcLoc);
+  printDatum(OS, "#params with type", ParamWithType);
+  printDatum(OS, "#params with binary location", ParamWithLoc);
+
+  // Print the summary for local variables.
+  printDatum(OS, "#local vars", LocalVarTotal);
+  printDatum(OS, "#local vars with source location", LocalVarWithSrcLoc);
+  printDatum(OS, "#local vars with type", LocalVarWithType);
+  printDatum(OS, "#local vars with binary location", LocalVarWithLoc);
+
+  // Print the debug section sizes.
   printSectionSizes(OS, Sizes);
-  printLocationStats(OS, "variables", LocStats.VarParamLocStats);
-  printLocationStats(OS, "variables (excluding the debug entry values)",
+
+  // Print the location statistics for variables (includes local variables
+  // and formal parameters).
+  printDatum(OS, "#variables processed by location statistics",
+             LocStats.NumVarParam);
+  printLocationStats(OS, "#variables", LocStats.VarParamLocStats);
+  printLocationStats(OS, "#variables \\\\ entry values",
                      LocStats.VarParamNonEntryValLocStats);
-  printDatum(OS, "total params procesed by location statistics",
-             LocStats.NumParam);
-  printLocationStats(OS, "params", LocStats.ParamLocStats);
-  printLocationStats(OS, "params (excluding the debug entry values)",
+
+  // Print the location statistics for formal parameters.
+  printDatum(OS, "#params processed by location statistics", LocStats.NumParam);
+  printLocationStats(OS, "#params", LocStats.ParamLocStats);
+  printLocationStats(OS, "#params \\\\ entry values",
                      LocStats.ParamNonEntryValLocStats);
-  printDatum(OS, "total vars procesed by location statistics", LocStats.NumVar);
-  printLocationStats(OS, "vars", LocStats.VarLocStats);
-  printLocationStats(OS, "vars (excluding the debug entry values)",
-                     LocStats.VarNonEntryValLocStats);
+
+  // Print the location statistics for local variables.
+  printDatum(OS, "#local vars processed by location statistics",
+             LocStats.NumVar);
+  printLocationStats(OS, "#local vars", LocStats.LocalVarLocStats);
+  printLocationStats(OS, "#local vars \\\\ entry values",
+                     LocStats.LocalVarNonEntryValLocStats);
   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.ScopeBytes)
                    << "%\n");
   return true;
 }

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

def parse_locstats(opts, binary):
   json_parsed = None
 
   try:
     json_parsed = loads(cmd_stdout)
   except:
     print ('error: No valid llvm-dwarfdump statistics found.')
     sys.exit(1)
 
+  # TODO: Parse the statistics Version from JSON.
+
   if opts.only_variables:
     # Read the JSON only for local variables.
     variables_total_locstats = \
-      json_parsed['total vars procesed by location statistics']
+      json_parsed['#local vars processed by location statistics']
     variables_scope_bytes_covered = \
-      json_parsed['vars scope bytes covered']
+      json_parsed['\\sum_{all local vars} #bytes in parent scope covered' \
+                  ' by DW_AT_location']
     variables_scope_bytes = \
-      json_parsed['vars scope bytes total']
+      json_parsed['\\sum_{all local vars} #bytes in parent scope']
     if not opts.ignore_debug_entry_values:
       for cov_bucket in coverage_buckets():
-        cov_category = "vars with {} of its scope covered".format(cov_bucket)
+        cov_category = "#local vars with {} of parent scope covered " \
+                       "by DW_AT_location".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']
+        json_parsed['\\sum_{all local vars} #bytes in parent scope ' \
+                    'covered by DW_OP_entry_value']
       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)
+          "#local vars \\\\ entry values with {} of parent scope " \
+          "covered by DW_AT_location".format(cov_bucket)
         variables_coverage_map[cov_bucket] = json_parsed[cov_category]
   elif opts.only_formal_parameters:
     # Read the JSON only for formal parameters.
     variables_total_locstats = \
-      json_parsed['total params procesed by location statistics']
+      json_parsed['#params processed by location statistics']
     variables_scope_bytes_covered = \
-      json_parsed['formal params scope bytes covered']
+      json_parsed['\\sum_{all params} #bytes in parent scope covered ' \
+                  'by DW_AT_location']
     variables_scope_bytes = \
-      json_parsed['formal params scope bytes total']
+      json_parsed['\\sum_{all params} #bytes in parent scope']
     if not opts.ignore_debug_entry_values:
       for cov_bucket in coverage_buckets():
-        cov_category = "params with {} of its scope covered".format(cov_bucket)
+        cov_category = "#params with {} of parent scope covered " \
+                       "by DW_AT_location".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']
+        json_parsed['\\sum_{all params} #bytes in parent scope covered ' \
+                    'by DW_OP_entry_value']
       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)
+          "#params \\\\ entry values with {} of parent scope covered" \
+          " by DW_AT_location".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']
+      json_parsed['#source variables']
+    variables_with_loc = json_parsed['#source variables with location']
     variables_total_locstats = \
-      json_parsed['total variables procesed by location statistics']
+      json_parsed['#variables processed by location statistics']
     variables_scope_bytes_covered = \
-      json_parsed['scope bytes covered']
+      json_parsed['\\sum_{all variables} #bytes in parent scope covered ' \
+                  'by DW_AT_location']
     variables_scope_bytes = \
-      json_parsed['scope bytes total']
+      json_parsed['\\sum_{all variables} #bytes in parent scope']
     if not opts.ignore_debug_entry_values:
       for cov_bucket in coverage_buckets():
-        cov_category = "variables with {} of its scope covered". \
-                       format(cov_bucket)
+        cov_category = "#variables with {} of parent scope covered " \
+                       "by DW_AT_location".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']
+        json_parsed['\\sum_{all variables} #bytes in parent scope covered ' \
+                    'by DW_OP_entry_value']
       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)
+        cov_category = \
+          "#variables \\\\ entry values with {} of parent scope covered " \
+          "by DW_AT_location".format(cov_bucket)
         variables_coverage_map[cov_bucket] = json_parsed[cov_category]
 
   return LocationStats(binary, variables_total, variables_total_locstats,
                        variables_with_loc, variables_scope_bytes_covered,
                        variables_scope_bytes, variables_coverage_map)
 
 # Parse the program arguments.
 def parse_program_args(parser):