utils/llvm-locstats/llvm-locstats.py - llvm-project/llvm - Git at Google

 #!/usr/bin/env python
 #
 # This is a tool that works like debug location coverage calculator.
 # It parses the llvm-dwarfdump --statistics output by reporting it
 # in a more human readable way.
 #

 from __future__ import print_function
 import argparse
 import os
 import sys
 from json import loads
 from math import ceil
 from collections import OrderedDict
 from subprocess import Popen, PIPE

 # This special value has been used to mark statistics that overflowed.
 TAINT_VALUE = "tainted"

 # Initialize the plot.
 def init_plot(plt):
     plt.title("Debug Location Statistics", fontweight="bold")
     plt.xlabel("location buckets")
     plt.ylabel("number of variables in the location buckets")
     plt.xticks(rotation=45, fontsize="x-small")
     plt.yticks()


 # Finalize the plot.
 def finish_plot(plt):
     plt.legend()
     plt.grid(color="grey", which="major", axis="y", linestyle="-", linewidth=0.3)
     plt.savefig("locstats.png")
     print('The plot was saved within "locstats.png".')


 # Holds the debug location statistics.
 class LocationStats:
     def __init__(
         self,
         file_name,
         variables_total,
         variables_total_locstats,
         variables_with_loc,
         variables_scope_bytes_covered,
         variables_scope_bytes,
         variables_coverage_map,
     ):
         self.file_name = file_name
         self.variables_total = variables_total
         self.variables_total_locstats = variables_total_locstats
         self.variables_with_loc = variables_with_loc
         self.scope_bytes_covered = variables_scope_bytes_covered
         self.scope_bytes = variables_scope_bytes
         self.variables_coverage_map = variables_coverage_map

     # Get the PC ranges coverage.
     def get_pc_coverage(self):
         if self.scope_bytes_covered == TAINT_VALUE or self.scope_bytes == TAINT_VALUE:
             return TAINT_VALUE
         pc_ranges_covered = int(
             ceil(self.scope_bytes_covered * 100.0) / self.scope_bytes
         )
         return pc_ranges_covered

     # Pretty print the debug location buckets.
     def pretty_print(self):
         if self.scope_bytes == 0:
             print("No scope bytes found.")
             return -1

         pc_ranges_covered = self.get_pc_coverage()
         variables_coverage_per_map = {}
         for cov_bucket in coverage_buckets():
             variables_coverage_per_map[cov_bucket] = None
             if (
                 self.variables_coverage_map[cov_bucket] == TAINT_VALUE
                 or self.variables_total_locstats == TAINT_VALUE
             ):
                 variables_coverage_per_map[cov_bucket] = TAINT_VALUE
             else:
                 variables_coverage_per_map[cov_bucket] = int(
                     ceil(self.variables_coverage_map[cov_bucket] * 100.0)
                     / self.variables_total_locstats
                 )

         print(" =================================================")
         print("            Debug Location Statistics       ")
         print(" =================================================")
         print("     cov%           samples         percentage(~)  ")
         print(" -------------------------------------------------")
         for cov_bucket in coverage_buckets():
             if (
                 self.variables_coverage_map[cov_bucket]
                 or self.variables_total_locstats == TAINT_VALUE
             ):
                 print(
                     "   {0:10}     {1:8}              {2:3}%".format(
                         cov_bucket,
                         self.variables_coverage_map[cov_bucket],
                         variables_coverage_per_map[cov_bucket],
                     )
                 )
             else:
                 print(
                     "   {0:10}     {1:8d}              {2:3d}%".format(
                         cov_bucket,
                         self.variables_coverage_map[cov_bucket],
                         variables_coverage_per_map[cov_bucket],
                     )
                 )
         print(" =================================================")
         print(
             " -the number of debug variables processed: "
             + str(self.variables_total_locstats)
         )
         print(" -PC ranges covered: " + str(pc_ranges_covered) + "%")

         # Only if we are processing all the variables output the total
         # availability.
         if self.variables_total and self.variables_with_loc:
             total_availability = None
             if (
                 self.variables_total == TAINT_VALUE
                 or self.variables_with_loc == TAINT_VALUE
             ):
                 total_availability = TAINT_VALUE
             else:
                 total_availability = int(
                     ceil(self.variables_with_loc * 100.0) / self.variables_total
                 )
             print(" -------------------------------------------------")
             print(" -total availability: " + str(total_availability) + "%")
         print(" =================================================")

         return 0

     # Draw a plot representing the location buckets.
     def draw_plot(self):
         from matplotlib import pyplot as plt

         buckets = range(len(self.variables_coverage_map))
         plt.figure(figsize=(12, 8))
         init_plot(plt)
         plt.bar(
             buckets,
             self.variables_coverage_map.values(),
             align="center",
             tick_label=self.variables_coverage_map.keys(),
             label="variables of {}".format(self.file_name),
         )

         # Place the text box with the coverage info.
         pc_ranges_covered = self.get_pc_coverage()
         props = dict(boxstyle="round", facecolor="wheat", alpha=0.5)
         plt.text(
             0.02,
             0.90,
             "PC ranges covered: {}%".format(pc_ranges_covered),
             transform=plt.gca().transAxes,
             fontsize=12,
             verticalalignment="top",
             bbox=props,
         )

         finish_plot(plt)

     # Compare the two LocationStats objects and draw a plot showing
     # the difference.
     def draw_location_diff(self, locstats_to_compare):
         from matplotlib import pyplot as plt

         pc_ranges_covered = self.get_pc_coverage()
         pc_ranges_covered_to_compare = locstats_to_compare.get_pc_coverage()

         buckets = range(len(self.variables_coverage_map))
         buckets_to_compare = range(len(locstats_to_compare.variables_coverage_map))

         fig = plt.figure(figsize=(12, 8))
         ax = fig.add_subplot(111)
         init_plot(plt)

         comparison_keys = list(coverage_buckets())
         ax.bar(
             buckets,
             self.variables_coverage_map.values(),
             align="edge",
             width=0.4,
             label="variables of {}".format(self.file_name),
         )
         ax.bar(
             buckets_to_compare,
             locstats_to_compare.variables_coverage_map.values(),
             color="r",
             align="edge",
             width=-0.4,
             label="variables of {}".format(locstats_to_compare.file_name),
         )
         ax.set_xticks(range(len(comparison_keys)))
         ax.set_xticklabels(comparison_keys)

         props = dict(boxstyle="round", facecolor="wheat", alpha=0.5)
         plt.text(
             0.02,
             0.88,
             "{} PC ranges covered: {}%".format(self.file_name, pc_ranges_covered),
             transform=plt.gca().transAxes,
             fontsize=12,
             verticalalignment="top",
             bbox=props,
         )
         plt.text(
             0.02,
             0.83,
             "{} PC ranges covered: {}%".format(
                 locstats_to_compare.file_name, pc_ranges_covered_to_compare
             ),
             transform=plt.gca().transAxes,
             fontsize=12,
             verticalalignment="top",
             bbox=props,
         )

         finish_plot(plt)


 # Define the location buckets.
 def coverage_buckets():
     yield "0%"
     yield "(0%,10%)"
     for start in range(10, 91, 10):
         yield "[{0}%,{1}%)".format(start, start + 10)
     yield "100%"


 # Parse the JSON representing the debug statistics, and create a
 # LocationStats object.
 def parse_locstats(opts, binary):
     # 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 = None
     variables_scope_bytes_entry_values = None
     variables_coverage_map = OrderedDict()

     # Get the directory of the LLVM tools.
     llvm_dwarfdump_cmd = os.path.join(os.path.dirname(__file__), "llvm-dwarfdump")
     # The statistics llvm-dwarfdump option.
     llvm_dwarfdump_stats_opt = "--statistics"

     # Generate the stats with the llvm-dwarfdump.
     subproc = Popen(
         [llvm_dwarfdump_cmd, llvm_dwarfdump_stats_opt, binary],
         stdin=PIPE,
         stdout=PIPE,
         stderr=PIPE,
         universal_newlines=True,
     )
     cmd_stdout, cmd_stderr = subproc.communicate()

     # TODO: Handle errors that are coming from llvm-dwarfdump.

     # Get the JSON and parse it.
     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.

     def init_field(name):
         if json_parsed[name] == "overflowed":
             print('warning: "' + name + '" field overflowed.')
             return TAINT_VALUE
         return json_parsed[name]

     if opts.only_variables:
         # Read the JSON only for local variables.
         variables_total_locstats = init_field(
             "#local vars processed by location statistics"
         )
         variables_scope_bytes_covered = init_field(
             "sum_all_local_vars(#bytes in parent scope covered" " by DW_AT_location)"
         )
         variables_scope_bytes = init_field("sum_all_local_vars(#bytes in parent scope)")
         if not opts.ignore_debug_entry_values:
             for cov_bucket in coverage_buckets():
                 cov_category = (
                     "#local vars with {} of parent scope covered "
                     "by DW_AT_location".format(cov_bucket)
                 )
                 variables_coverage_map[cov_bucket] = init_field(cov_category)
         else:
             variables_scope_bytes_entry_values = init_field(
                 "sum_all_local_vars(#bytes in parent scope "
                 "covered by DW_OP_entry_value)"
             )
             if (
                 variables_scope_bytes_covered != TAINT_VALUE
                 and variables_scope_bytes_entry_values != TAINT_VALUE
             ):
                 variables_scope_bytes_covered = (
                     variables_scope_bytes_covered - variables_scope_bytes_entry_values
                 )
             for cov_bucket in coverage_buckets():
                 cov_category = (
                     "#local vars - entry values with {} of parent scope "
                     "covered by DW_AT_location".format(cov_bucket)
                 )
                 variables_coverage_map[cov_bucket] = init_field(cov_category)
     elif opts.only_formal_parameters:
         # Read the JSON only for formal parameters.
         variables_total_locstats = init_field(
             "#params processed by location statistics"
         )
         variables_scope_bytes_covered = init_field(
             "sum_all_params(#bytes in parent scope covered " "by DW_AT_location)"
         )
         variables_scope_bytes = init_field("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 parent scope covered "
                     "by DW_AT_location".format(cov_bucket)
                 )
                 variables_coverage_map[cov_bucket] = init_field(cov_category)
         else:
             variables_scope_bytes_entry_values = init_field(
                 "sum_all_params(#bytes in parent scope covered " "by DW_OP_entry_value)"
             )
             if (
                 variables_scope_bytes_covered != TAINT_VALUE
                 and variables_scope_bytes_entry_values != TAINT_VALUE
             ):
                 variables_scope_bytes_covered = (
                     variables_scope_bytes_covered - variables_scope_bytes_entry_values
                 )
             for cov_bucket in coverage_buckets():
                 cov_category = (
                     "#params - entry values with {} of parent scope covered"
                     " by DW_AT_location".format(cov_bucket)
                 )
                 variables_coverage_map[cov_bucket] = init_field(cov_category)
     else:
         # Read the JSON for both local variables and formal parameters.
         variables_total = init_field("#source variables")
         variables_with_loc = init_field("#source variables with location")
         variables_total_locstats = init_field(
             "#variables processed by location statistics"
         )
         variables_scope_bytes_covered = init_field(
             "sum_all_variables(#bytes in parent scope covered " "by DW_AT_location)"
         )
         variables_scope_bytes = init_field("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 parent scope covered "
                     "by DW_AT_location".format(cov_bucket)
                 )
                 variables_coverage_map[cov_bucket] = init_field(cov_category)
         else:
             variables_scope_bytes_entry_values = init_field(
                 "sum_all_variables(#bytes in parent scope covered "
                 "by DW_OP_entry_value)"
             )
             if (
                 variables_scope_bytes_covered != TAINT_VALUE
                 and variables_scope_bytes_entry_values != TAINT_VALUE
             ):
                 variables_scope_bytes_covered = (
                     variables_scope_bytes_covered - variables_scope_bytes_entry_values
                 )
             for cov_bucket in coverage_buckets():
                 cov_category = (
                     "#variables - entry values with {} of parent scope covered "
                     "by DW_AT_location".format(cov_bucket)
                 )
                 variables_coverage_map[cov_bucket] = init_field(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):
     parser.add_argument(
         "--only-variables",
         action="store_true",
         default=False,
         help="calculate the location statistics only for local variables",
     )
     parser.add_argument(
         "--only-formal-parameters",
         action="store_true",
         default=False,
         help="calculate the location statistics only for formal parameters",
     )
     parser.add_argument(
         "--ignore-debug-entry-values",
         action="store_true",
         default=False,
         help="ignore the location statistics on locations with " "entry values",
     )
     parser.add_argument(
         "--draw-plot",
         action="store_true",
         default=False,
         help="show histogram of location buckets generated (requires " "matplotlib)",
     )
     parser.add_argument(
         "--compare",
         action="store_true",
         default=False,
         help="compare the debug location coverage on two files provided, "
         "and draw a plot showing the difference  (requires "
         "matplotlib)",
     )
     parser.add_argument("file_names", nargs="+", type=str, help="file to process")

     return parser.parse_args()


 # Verify that the program inputs meet the requirements.
 def verify_program_inputs(opts):
     if len(sys.argv) < 2:
         print("error: Too few arguments.")
         return False

     if opts.only_variables and opts.only_formal_parameters:
         print("error: Please use just one --only* option.")
         return False

     if not opts.compare and len(opts.file_names) != 1:
         print("error: Please specify only one file to process.")
         return False

     if opts.compare and len(opts.file_names) != 2:
         print("error: Please specify two files to process.")
         return False

     if opts.draw_plot or opts.compare:
         try:
             import matplotlib
         except ImportError:
             print("error: matplotlib not found.")
             return False

     return True


 def Main():
     parser = argparse.ArgumentParser()
     opts = parse_program_args(parser)

     if not verify_program_inputs(opts):
         parser.print_help()
         sys.exit(1)

     binary_file = opts.file_names[0]
     locstats = parse_locstats(opts, binary_file)

     if not opts.compare:
         if opts.draw_plot:
             # Draw a histogram representing the location buckets.
             locstats.draw_plot()
         else:
             # Pretty print collected info on the standard output.
             if locstats.pretty_print() == -1:
                 sys.exit(0)
     else:
         binary_file_to_compare = opts.file_names[1]
         locstats_to_compare = parse_locstats(opts, binary_file_to_compare)
         # Draw a plot showing the difference in debug location coverage between
         # two files.
         locstats.draw_location_diff(locstats_to_compare)


 if __name__ == "__main__":
     Main()
     sys.exit(0)
	#!/usr/bin/env python
	#
	# This is a tool that works like debug location coverage calculator.
	# It parses the llvm-dwarfdump --statistics output by reporting it
	# in a more human readable way.
	#

	from __future__ import print_function
	import argparse
	import os
	import sys
	from json import loads
	from math import ceil
	from collections import OrderedDict
	from subprocess import Popen, PIPE

	# This special value has been used to mark statistics that overflowed.
	TAINT_VALUE = "tainted"

	# Initialize the plot.
	def init_plot(plt):
	plt.title("Debug Location Statistics", fontweight="bold")
	plt.xlabel("location buckets")
	plt.ylabel("number of variables in the location buckets")
	plt.xticks(rotation=45, fontsize="x-small")
	plt.yticks()


	# Finalize the plot.
	def finish_plot(plt):
	plt.legend()
	plt.grid(color="grey", which="major", axis="y", linestyle="-", linewidth=0.3)
	plt.savefig("locstats.png")
	print('The plot was saved within "locstats.png".')


	# Holds the debug location statistics.
	class LocationStats:
	def __init__(
	self,
	file_name,
	variables_total,
	variables_total_locstats,
	variables_with_loc,
	variables_scope_bytes_covered,
	variables_scope_bytes,
	variables_coverage_map,
	):
	self.file_name = file_name
	self.variables_total = variables_total
	self.variables_total_locstats = variables_total_locstats
	self.variables_with_loc = variables_with_loc
	self.scope_bytes_covered = variables_scope_bytes_covered
	self.scope_bytes = variables_scope_bytes
	self.variables_coverage_map = variables_coverage_map

	# Get the PC ranges coverage.
	def get_pc_coverage(self):
	if self.scope_bytes_covered == TAINT_VALUE or self.scope_bytes == TAINT_VALUE:
	return TAINT_VALUE
	pc_ranges_covered = int(
	ceil(self.scope_bytes_covered * 100.0) / self.scope_bytes
	)
	return pc_ranges_covered

	# Pretty print the debug location buckets.
	def pretty_print(self):
	if self.scope_bytes == 0:
	print("No scope bytes found.")
	return -1

	pc_ranges_covered = self.get_pc_coverage()
	variables_coverage_per_map = {}
	for cov_bucket in coverage_buckets():
	variables_coverage_per_map[cov_bucket] = None
	if (
	self.variables_coverage_map[cov_bucket] == TAINT_VALUE
	or self.variables_total_locstats == TAINT_VALUE
	):
	variables_coverage_per_map[cov_bucket] = TAINT_VALUE
	else:
	variables_coverage_per_map[cov_bucket] = int(
	ceil(self.variables_coverage_map[cov_bucket] * 100.0)
	/ self.variables_total_locstats
	)

	print(" =================================================")
	print(" Debug Location Statistics ")
	print(" =================================================")
	print(" cov% samples percentage(~) ")
	print(" -------------------------------------------------")
	for cov_bucket in coverage_buckets():
	if (
	self.variables_coverage_map[cov_bucket]
	or self.variables_total_locstats == TAINT_VALUE
	):
	print(
	" {0:10} {1:8} {2:3}%".format(
	cov_bucket,
	self.variables_coverage_map[cov_bucket],
	variables_coverage_per_map[cov_bucket],
	)
	)
	else:
	print(
	" {0:10} {1:8d} {2:3d}%".format(
	cov_bucket,
	self.variables_coverage_map[cov_bucket],
	variables_coverage_per_map[cov_bucket],
	)
	)
	print(" =================================================")
	print(
	" -the number of debug variables processed: "
	+ str(self.variables_total_locstats)
	)
	print(" -PC ranges covered: " + str(pc_ranges_covered) + "%")

	# Only if we are processing all the variables output the total
	# availability.
	if self.variables_total and self.variables_with_loc:
	total_availability = None
	if (
	self.variables_total == TAINT_VALUE
	or self.variables_with_loc == TAINT_VALUE
	):
	total_availability = TAINT_VALUE
	else:
	total_availability = int(
	ceil(self.variables_with_loc * 100.0) / self.variables_total
	)
	print(" -------------------------------------------------")
	print(" -total availability: " + str(total_availability) + "%")
	print(" =================================================")

	return 0

	# Draw a plot representing the location buckets.
	def draw_plot(self):
	from matplotlib import pyplot as plt

	buckets = range(len(self.variables_coverage_map))
	plt.figure(figsize=(12, 8))
	init_plot(plt)
	plt.bar(
	buckets,
	self.variables_coverage_map.values(),
	align="center",
	tick_label=self.variables_coverage_map.keys(),
	label="variables of {}".format(self.file_name),
	)

	# Place the text box with the coverage info.
	pc_ranges_covered = self.get_pc_coverage()
	props = dict(boxstyle="round", facecolor="wheat", alpha=0.5)
	plt.text(
	0.02,
	0.90,
	"PC ranges covered: {}%".format(pc_ranges_covered),
	transform=plt.gca().transAxes,
	fontsize=12,
	verticalalignment="top",
	bbox=props,
	)

	finish_plot(plt)

	# Compare the two LocationStats objects and draw a plot showing
	# the difference.
	def draw_location_diff(self, locstats_to_compare):
	from matplotlib import pyplot as plt

	pc_ranges_covered = self.get_pc_coverage()
	pc_ranges_covered_to_compare = locstats_to_compare.get_pc_coverage()

	buckets = range(len(self.variables_coverage_map))
	buckets_to_compare = range(len(locstats_to_compare.variables_coverage_map))

	fig = plt.figure(figsize=(12, 8))
	ax = fig.add_subplot(111)
	init_plot(plt)

	comparison_keys = list(coverage_buckets())
	ax.bar(
	buckets,
	self.variables_coverage_map.values(),
	align="edge",
	width=0.4,
	label="variables of {}".format(self.file_name),
	)
	ax.bar(
	buckets_to_compare,
	locstats_to_compare.variables_coverage_map.values(),
	color="r",
	align="edge",
	width=-0.4,
	label="variables of {}".format(locstats_to_compare.file_name),
	)
	ax.set_xticks(range(len(comparison_keys)))
	ax.set_xticklabels(comparison_keys)

	props = dict(boxstyle="round", facecolor="wheat", alpha=0.5)
	plt.text(
	0.02,
	0.88,
	"{} PC ranges covered: {}%".format(self.file_name, pc_ranges_covered),
	transform=plt.gca().transAxes,
	fontsize=12,
	verticalalignment="top",
	bbox=props,
	)
	plt.text(
	0.02,
	0.83,
	"{} PC ranges covered: {}%".format(
	locstats_to_compare.file_name, pc_ranges_covered_to_compare
	),
	transform=plt.gca().transAxes,
	fontsize=12,
	verticalalignment="top",
	bbox=props,
	)

	finish_plot(plt)


	# Define the location buckets.
	def coverage_buckets():
	yield "0%"
	yield "(0%,10%)"
	for start in range(10, 91, 10):
	yield "[{0}%,{1}%)".format(start, start + 10)
	yield "100%"


	# Parse the JSON representing the debug statistics, and create a
	# LocationStats object.
	def parse_locstats(opts, binary):
	# 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 = None
	variables_scope_bytes_entry_values = None
	variables_coverage_map = OrderedDict()

	# Get the directory of the LLVM tools.
	llvm_dwarfdump_cmd = os.path.join(os.path.dirname(__file__), "llvm-dwarfdump")
	# The statistics llvm-dwarfdump option.
	llvm_dwarfdump_stats_opt = "--statistics"

	# Generate the stats with the llvm-dwarfdump.
	subproc = Popen(
	[llvm_dwarfdump_cmd, llvm_dwarfdump_stats_opt, binary],
	stdin=PIPE,
	stdout=PIPE,
	stderr=PIPE,
	universal_newlines=True,
	)
	cmd_stdout, cmd_stderr = subproc.communicate()

	# TODO: Handle errors that are coming from llvm-dwarfdump.

	# Get the JSON and parse it.
	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.

	def init_field(name):
	if json_parsed[name] == "overflowed":
	print('warning: "' + name + '" field overflowed.')
	return TAINT_VALUE
	return json_parsed[name]

	if opts.only_variables:
	# Read the JSON only for local variables.
	variables_total_locstats = init_field(
	"#local vars processed by location statistics"
	)
	variables_scope_bytes_covered = init_field(
	"sum_all_local_vars(#bytes in parent scope covered" " by DW_AT_location)"
	)
	variables_scope_bytes = init_field("sum_all_local_vars(#bytes in parent scope)")
	if not opts.ignore_debug_entry_values:
	for cov_bucket in coverage_buckets():
	cov_category = (
	"#local vars with {} of parent scope covered "
	"by DW_AT_location".format(cov_bucket)
	)
	variables_coverage_map[cov_bucket] = init_field(cov_category)
	else:
	variables_scope_bytes_entry_values = init_field(
	"sum_all_local_vars(#bytes in parent scope "
	"covered by DW_OP_entry_value)"
	)
	if (
	variables_scope_bytes_covered != TAINT_VALUE
	and variables_scope_bytes_entry_values != TAINT_VALUE
	):
	variables_scope_bytes_covered = (
	variables_scope_bytes_covered - variables_scope_bytes_entry_values
	)
	for cov_bucket in coverage_buckets():
	cov_category = (
	"#local vars - entry values with {} of parent scope "
	"covered by DW_AT_location".format(cov_bucket)
	)
	variables_coverage_map[cov_bucket] = init_field(cov_category)
	elif opts.only_formal_parameters:
	# Read the JSON only for formal parameters.
	variables_total_locstats = init_field(
	"#params processed by location statistics"
	)
	variables_scope_bytes_covered = init_field(
	"sum_all_params(#bytes in parent scope covered " "by DW_AT_location)"
	)
	variables_scope_bytes = init_field("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 parent scope covered "
	"by DW_AT_location".format(cov_bucket)
	)
	variables_coverage_map[cov_bucket] = init_field(cov_category)
	else:
	variables_scope_bytes_entry_values = init_field(
	"sum_all_params(#bytes in parent scope covered " "by DW_OP_entry_value)"
	)
	if (
	variables_scope_bytes_covered != TAINT_VALUE
	and variables_scope_bytes_entry_values != TAINT_VALUE
	):
	variables_scope_bytes_covered = (
	variables_scope_bytes_covered - variables_scope_bytes_entry_values
	)
	for cov_bucket in coverage_buckets():
	cov_category = (
	"#params - entry values with {} of parent scope covered"
	" by DW_AT_location".format(cov_bucket)
	)
	variables_coverage_map[cov_bucket] = init_field(cov_category)
	else:
	# Read the JSON for both local variables and formal parameters.
	variables_total = init_field("#source variables")
	variables_with_loc = init_field("#source variables with location")
	variables_total_locstats = init_field(
	"#variables processed by location statistics"
	)
	variables_scope_bytes_covered = init_field(
	"sum_all_variables(#bytes in parent scope covered " "by DW_AT_location)"
	)
	variables_scope_bytes = init_field("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 parent scope covered "
	"by DW_AT_location".format(cov_bucket)
	)
	variables_coverage_map[cov_bucket] = init_field(cov_category)
	else:
	variables_scope_bytes_entry_values = init_field(
	"sum_all_variables(#bytes in parent scope covered "
	"by DW_OP_entry_value)"
	)
	if (
	variables_scope_bytes_covered != TAINT_VALUE
	and variables_scope_bytes_entry_values != TAINT_VALUE
	):
	variables_scope_bytes_covered = (
	variables_scope_bytes_covered - variables_scope_bytes_entry_values
	)
	for cov_bucket in coverage_buckets():
	cov_category = (
	"#variables - entry values with {} of parent scope covered "
	"by DW_AT_location".format(cov_bucket)
	)
	variables_coverage_map[cov_bucket] = init_field(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):
	parser.add_argument(
	"--only-variables",
	action="store_true",
	default=False,
	help="calculate the location statistics only for local variables",
	)
	parser.add_argument(
	"--only-formal-parameters",
	action="store_true",
	default=False,
	help="calculate the location statistics only for formal parameters",
	)
	parser.add_argument(
	"--ignore-debug-entry-values",
	action="store_true",
	default=False,
	help="ignore the location statistics on locations with " "entry values",
	)
	parser.add_argument(
	"--draw-plot",
	action="store_true",
	default=False,
	help="show histogram of location buckets generated (requires " "matplotlib)",
	)
	parser.add_argument(
	"--compare",
	action="store_true",
	default=False,
	help="compare the debug location coverage on two files provided, "
	"and draw a plot showing the difference (requires "
	"matplotlib)",
	)
	parser.add_argument("file_names", nargs="+", type=str, help="file to process")

	return parser.parse_args()


	# Verify that the program inputs meet the requirements.
	def verify_program_inputs(opts):
	if len(sys.argv) < 2:
	print("error: Too few arguments.")
	return False

	if opts.only_variables and opts.only_formal_parameters:
	print("error: Please use just one --only* option.")
	return False

	if not opts.compare and len(opts.file_names) != 1:
	print("error: Please specify only one file to process.")
	return False

	if opts.compare and len(opts.file_names) != 2:
	print("error: Please specify two files to process.")
	return False

	if opts.draw_plot or opts.compare:
	try:
	import matplotlib
	except ImportError:
	print("error: matplotlib not found.")
	return False

	return True


	def Main():
	parser = argparse.ArgumentParser()
	opts = parse_program_args(parser)

	if not verify_program_inputs(opts):
	parser.print_help()
	sys.exit(1)

	binary_file = opts.file_names[0]
	locstats = parse_locstats(opts, binary_file)

	if not opts.compare:
	if opts.draw_plot:
	# Draw a histogram representing the location buckets.
	locstats.draw_plot()
	else:
	# Pretty print collected info on the standard output.
	if locstats.pretty_print() == -1:
	sys.exit(0)
	else:
	binary_file_to_compare = opts.file_names[1]
	locstats_to_compare = parse_locstats(opts, binary_file_to_compare)
	# Draw a plot showing the difference in debug location coverage between
	# two files.
	locstats.draw_location_diff(locstats_to_compare)


	if __name__ == "__main__":
	Main()
	sys.exit(0)