lcov 1.9-2 / usr / bin / geninfo

#!/usr/bin/perl -w
#
#   Copyright (c) International Business Machines  Corp., 2002,2010
#
#   This program is free software;  you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation; either version 2 of the License, or (at
#   your option) any later version.
#
#   This program is distributed in the hope that it will be useful, but
#   WITHOUT ANY WARRANTY;  without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
#   General Public License for more details.                 
#
#   You should have received a copy of the GNU General Public License
#   along with this program;  if not, write to the Free Software
#   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
#
# geninfo
#
#   This script generates .info files from data files as created by code
#   instrumented with gcc's built-in profiling mechanism. Call it with
#   --help and refer to the geninfo man page to get information on usage
#   and available options.
#
#
# Authors:
#   2002-08-23 created by Peter Oberparleiter <Peter.Oberparleiter@de.ibm.com>
#                         IBM Lab Boeblingen
#        based on code by Manoj Iyer <manjo@mail.utexas.edu> and
#                         Megan Bock <mbock@us.ibm.com>
#                         IBM Austin
#   2002-09-05 / Peter Oberparleiter: implemented option that allows file list
#   2003-04-16 / Peter Oberparleiter: modified read_gcov so that it can also
#                parse the new gcov format which is to be introduced in gcc 3.3
#   2003-04-30 / Peter Oberparleiter: made info write to STDERR, not STDOUT
#   2003-07-03 / Peter Oberparleiter: added line checksum support, added
#                --no-checksum
#   2003-09-18 / Nigel Hinds: capture branch coverage data from GCOV
#   2003-12-11 / Laurent Deniel: added --follow option
#                workaround gcov (<= 3.2.x) bug with empty .da files
#   2004-01-03 / Laurent Deniel: Ignore empty .bb files
#   2004-02-16 / Andreas Krebbel: Added support for .gcno/.gcda files and
#                gcov versioning
#   2004-08-09 / Peter Oberparleiter: added configuration file support
#   2008-07-14 / Tom Zoerner: added --function-coverage command line option
#   2008-08-13 / Peter Oberparleiter: modified function coverage
#                implementation (now enabled per default)
#

use strict;
use File::Basename; 
use File::Spec::Functions qw /abs2rel catdir file_name_is_absolute splitdir
			      splitpath/;
use Getopt::Long;
use Digest::MD5 qw(md5_base64);


# Constants
our $lcov_version	= 'LCOV version 1.9';
our $lcov_url		= "http://ltp.sourceforge.net/coverage/lcov.php";
our $gcov_tool		= "gcov";
our $tool_name		= basename($0);

our $GCOV_VERSION_3_4_0	= 0x30400;
our $GCOV_VERSION_3_3_0	= 0x30300;
our $GCNO_FUNCTION_TAG	= 0x01000000;
our $GCNO_LINES_TAG	= 0x01450000;
our $GCNO_FILE_MAGIC	= 0x67636e6f;
our $BBG_FILE_MAGIC	= 0x67626267;

our $COMPAT_HAMMER	= "hammer";

our $ERROR_GCOV		= 0;
our $ERROR_SOURCE	= 1;
our $ERROR_GRAPH	= 2;

our $EXCL_START = "LCOV_EXCL_START";
our $EXCL_STOP = "LCOV_EXCL_STOP";
our $EXCL_LINE = "LCOV_EXCL_LINE";

our $BR_LINE		= 0;
our $BR_BLOCK		= 1;
our $BR_BRANCH		= 2;
our $BR_TAKEN		= 3;
our $BR_VEC_ENTRIES	= 4;
our $BR_VEC_WIDTH	= 32;

our $UNNAMED_BLOCK	= 9999;

# Prototypes
sub print_usage(*);
sub gen_info($);
sub process_dafile($$);
sub match_filename($@);
sub solve_ambiguous_match($$$);
sub split_filename($);
sub solve_relative_path($$);
sub read_gcov_header($);
sub read_gcov_file($);
sub info(@);
sub get_gcov_version();
sub system_no_output($@);
sub read_config($);
sub apply_config($);
sub get_exclusion_data($);
sub apply_exclusion_data($$);
sub process_graphfile($$);
sub filter_fn_name($);
sub warn_handler($);
sub die_handler($);
sub graph_error($$);
sub graph_expect($);
sub graph_read(*$;$);
sub graph_skip(*$;$);
sub sort_uniq(@);
sub sort_uniq_lex(@);
sub graph_cleanup($);
sub graph_find_base($);
sub graph_from_bb($$$);
sub graph_add_order($$$);
sub read_bb_word(*;$);
sub read_bb_value(*;$);
sub read_bb_string(*$);
sub read_bb($$);
sub read_bbg_word(*;$);
sub read_bbg_value(*;$);
sub read_bbg_string(*);
sub read_bbg_lines_record(*$$$$$$);
sub read_bbg($$);
sub read_gcno_word(*;$);
sub read_gcno_value(*$;$);
sub read_gcno_string(*$);
sub read_gcno_lines_record(*$$$$$$$);
sub read_gcno_function_record(*$$$$);
sub read_gcno($$);
sub get_gcov_capabilities();
sub get_overall_line($$$$);
sub print_overall_rate($$$$$$$$$);
sub br_gvec_len($);
sub br_gvec_get($$);
sub debug($);
sub int_handler();


# Global variables
our $gcov_version;
our $graph_file_extension;
our $data_file_extension;
our @data_directory;
our $test_name = "";
our $quiet;
our $help;
our $output_filename;
our $base_directory;
our $version;
our $follow;
our $checksum;
our $no_checksum;
our $compat_libtool;
our $no_compat_libtool;
our $adjust_testname;
our $config;		# Configuration file contents
our $compatibility;	# Compatibility version flag - used to indicate
			# non-standard GCOV data format versions
our @ignore_errors;	# List of errors to ignore (parameter)
our @ignore;		# List of errors to ignore (array)
our $initial;
our $no_recursion = 0;
our $maxdepth;
our $no_markers = 0;
our $opt_derive_func_data = 0;
our $debug = 0;
our $gcov_caps;
our @gcov_options;

our $cwd = `pwd`;
chomp($cwd);


#
# Code entry point
#

# Register handler routine to be called when interrupted
$SIG{"INT"} = \&int_handler;
$SIG{__WARN__} = \&warn_handler;
$SIG{__DIE__} = \&die_handler;

# Prettify version string
$lcov_version =~ s/\$\s*Revision\s*:?\s*(\S+)\s*\$/$1/;

# Set LANG so that gcov output will be in a unified format
$ENV{"LANG"} = "C";

# Read configuration file if available
if (defined($ENV{"HOME"}) && (-r $ENV{"HOME"}."/.lcovrc"))
{
	$config = read_config($ENV{"HOME"}."/.lcovrc");
}
elsif (-r "/etc/lcovrc")
{
	$config = read_config("/etc/lcovrc");
}

if ($config)
{
	# Copy configuration file values to variables
	apply_config({
		"geninfo_gcov_tool"		=> \$gcov_tool,
		"geninfo_adjust_testname"	=> \$adjust_testname,
		"geninfo_checksum"		=> \$checksum,
		"geninfo_no_checksum"		=> \$no_checksum, # deprecated
		"geninfo_compat_libtool"	=> \$compat_libtool});

	# Merge options
	if (defined($no_checksum))
	{
		$checksum = ($no_checksum ? 0 : 1);
		$no_checksum = undef;
	}
}

# Parse command line options
if (!GetOptions("test-name|t=s" => \$test_name,
		"output-filename|o=s" => \$output_filename,
		"checksum" => \$checksum,
		"no-checksum" => \$no_checksum,
		"base-directory|b=s" => \$base_directory,
		"version|v" =>\$version,
		"quiet|q" => \$quiet,
		"help|h|?" => \$help,
		"follow|f" => \$follow,
		"compat-libtool" => \$compat_libtool,
		"no-compat-libtool" => \$no_compat_libtool,
		"gcov-tool=s" => \$gcov_tool,
		"ignore-errors=s" => \@ignore_errors,
		"initial|i" => \$initial,
		"no-recursion" => \$no_recursion,
		"no-markers" => \$no_markers,
		"derive-func-data" => \$opt_derive_func_data,
		"debug" => \$debug,
		))
{
	print(STDERR "Use $tool_name --help to get usage information\n");
	exit(1);
}
else
{
	# Merge options
	if (defined($no_checksum))
	{
		$checksum = ($no_checksum ? 0 : 1);
		$no_checksum = undef;
	}

	if (defined($no_compat_libtool))
	{
		$compat_libtool = ($no_compat_libtool ? 0 : 1);
		$no_compat_libtool = undef;
	}
}

@data_directory = @ARGV;

# Check for help option
if ($help)
{
	print_usage(*STDOUT);
	exit(0);
}

# Check for version option
if ($version)
{
	print("$tool_name: $lcov_version\n");
	exit(0);
}

# Make sure test names only contain valid characters
if ($test_name =~ s/\W/_/g)
{
	warn("WARNING: invalid characters removed from testname!\n");
}

# Adjust test name to include uname output if requested
if ($adjust_testname)
{
	$test_name .= "__".`uname -a`;
	$test_name =~ s/\W/_/g;
}

# Make sure base_directory contains an absolute path specification
if ($base_directory)
{
	$base_directory = solve_relative_path($cwd, $base_directory);
}

# Check for follow option
if ($follow)
{
	$follow = "-follow"
}
else
{
	$follow = "";
}

# Determine checksum mode
if (defined($checksum))
{
	# Normalize to boolean
	$checksum = ($checksum ? 1 : 0);
}
else
{
	# Default is off
	$checksum = 0;
}

# Determine libtool compatibility mode
if (defined($compat_libtool))
{
	$compat_libtool = ($compat_libtool? 1 : 0);
}
else
{
	# Default is on
	$compat_libtool = 1;
}

# Determine max depth for recursion
if ($no_recursion)
{
	$maxdepth = "-maxdepth 1";
}
else
{
	$maxdepth = "";
}

# Check for directory name
if (!@data_directory)
{
	die("No directory specified\n".
	    "Use $tool_name --help to get usage information\n");
}
else
{
	foreach (@data_directory)
	{
		stat($_);
		if (!-r _)
		{
			die("ERROR: cannot read $_!\n");
		}
	}
}

if (@ignore_errors)
{
	my @expanded;
	my $error;

	# Expand comma-separated entries
	foreach (@ignore_errors) {
		if (/,/)
		{
			push(@expanded, split(",", $_));
		}
		else
		{
			push(@expanded, $_);
		}
	}

	foreach (@expanded)
	{
		/^gcov$/ && do { $ignore[$ERROR_GCOV] = 1; next; } ;
		/^source$/ && do { $ignore[$ERROR_SOURCE] = 1; next; };
		/^graph$/ && do { $ignore[$ERROR_GRAPH] = 1; next; };
		die("ERROR: unknown argument for --ignore-errors: $_\n");
	}
}

if (system_no_output(3, $gcov_tool, "--help") == -1)
{
	die("ERROR: need tool $gcov_tool!\n");
}

$gcov_version = get_gcov_version();

if ($gcov_version < $GCOV_VERSION_3_4_0)
{
	if (defined($compatibility) && $compatibility eq $COMPAT_HAMMER)
	{
		$data_file_extension = ".da";
		$graph_file_extension = ".bbg";
	}
	else
	{
		$data_file_extension = ".da";
		$graph_file_extension = ".bb";
	}
}
else
{
	$data_file_extension = ".gcda";
	$graph_file_extension = ".gcno";
}	

# Determine gcov options
$gcov_caps = get_gcov_capabilities();
push(@gcov_options, "-b") if ($gcov_caps->{'branch-probabilities'});
push(@gcov_options, "-c") if ($gcov_caps->{'branch-counts'});
push(@gcov_options, "-a") if ($gcov_caps->{'all-blocks'});
push(@gcov_options, "-p") if ($gcov_caps->{'preserve-paths'});

# Check output filename
if (defined($output_filename) && ($output_filename ne "-"))
{
	# Initially create output filename, data is appended
	# for each data file processed
	local *DUMMY_HANDLE;
	open(DUMMY_HANDLE, ">$output_filename")
		or die("ERROR: cannot create $output_filename!\n");
	close(DUMMY_HANDLE);

	# Make $output_filename an absolute path because we're going
	# to change directories while processing files
	if (!($output_filename =~ /^\/(.*)$/))
	{
		$output_filename = $cwd."/".$output_filename;
	}
}

# Do something
foreach my $entry (@data_directory) {
	gen_info($entry);
}

if ($initial) {
	warn("Note: --initial does not generate branch coverage ".
	     "data\n");
}
info("Finished .info-file creation\n");

exit(0);



#
# print_usage(handle)
#
# Print usage information.
#

sub print_usage(*)
{
	local *HANDLE = $_[0];

	print(HANDLE <<END_OF_USAGE);
Usage: $tool_name [OPTIONS] DIRECTORY

Traverse DIRECTORY and create a .info file for each data file found. Note
that you may specify more than one directory, all of which are then processed
sequentially.

  -h, --help                        Print this help, then exit
  -v, --version                     Print version number, then exit
  -q, --quiet                       Do not print progress messages
  -i, --initial                     Capture initial zero coverage data
  -t, --test-name NAME              Use test case name NAME for resulting data
  -o, --output-filename OUTFILE     Write data only to OUTFILE
  -f, --follow                      Follow links when searching .da/.gcda files
  -b, --base-directory DIR          Use DIR as base directory for relative paths
      --(no-)checksum               Enable (disable) line checksumming
      --(no-)compat-libtool         Enable (disable) libtool compatibility mode
      --gcov-tool TOOL              Specify gcov tool location
      --ignore-errors ERROR         Continue after ERROR (gcov, source, graph)
      --no-recursion                Exclude subdirectories from processing
      --function-coverage           Capture function call counts
      --no-markers                  Ignore exclusion markers in source code
      --derive-func-data            Generate function data from line data

For more information see: $lcov_url
END_OF_USAGE
	;
}

#
# get_common_prefix(min_dir, filenames)
#
# Return the longest path prefix shared by all filenames. MIN_DIR specifies
# the minimum number of directories that a filename may have after removing
# the prefix.
#

sub get_common_prefix($@)
{
	my ($min_dir, @files) = @_;
	my $file;
	my @prefix;
	my $i;

	foreach $file (@files) {
		my ($v, $d, $f) = splitpath($file);
		my @comp = splitdir($d);

		if (!@prefix) {
			@prefix = @comp;
			next;
		}
		for ($i = 0; $i < scalar(@comp) && $i < scalar(@prefix); $i++) {
			if ($comp[$i] ne $prefix[$i] ||
			    ((scalar(@comp) - ($i + 1)) <= $min_dir)) {
				delete(@prefix[$i..scalar(@prefix)]);
				last;
			}
		}
	}

	return catdir(@prefix);
}

#
# gen_info(directory)
#
# Traverse DIRECTORY and create a .info file for each data file found.
# The .info file contains TEST_NAME in the following format:
#
#   TN:<test name>
#
# For each source file name referenced in the data file, there is a section
# containing source code and coverage data:
#
#   SF:<absolute path to the source file>
#   FN:<line number of function start>,<function name> for each function
#   DA:<line number>,<execution count> for each instrumented line
#   LH:<number of lines with an execution count> greater than 0
#   LF:<number of instrumented lines>
#
# Sections are separated by:
#
#   end_of_record
#
# In addition to the main source code file there are sections for each
# #included file containing executable code. Note that the absolute path
# of a source file is generated by interpreting the contents of the respective
# graph file. Relative filenames are prefixed with the directory in which the
# graph file is found. Note also that symbolic links to the graph file will be
# resolved so that the actual file path is used instead of the path to a link.
# This approach is necessary for the mechanism to work with the /proc/gcov
# files.
#
# Die on error.
#

sub gen_info($)
{
	my $directory = $_[0];
	my @file_list;
	my $file;
	my $prefix;
	my $type;
	my $ext;

	if ($initial) {
		$type = "graph";
		$ext = $graph_file_extension;
	} else {
		$type = "data";
		$ext = $data_file_extension;
	}

	if (-d $directory)
	{
		info("Scanning $directory for $ext files ...\n");

		@file_list = `find "$directory" $maxdepth $follow -name \\*$ext -type f 2>/dev/null`;
		chomp(@file_list);
		@file_list or
			die("ERROR: no $ext files found in $directory!\n");
		$prefix = get_common_prefix(1, @file_list);
		info("Found %d %s files in %s\n", $#file_list+1, $type,
		     $directory);
	}
	else
	{
		@file_list = ($directory);
		$prefix = "";
	}

	# Process all files in list
	foreach $file (@file_list) {
		# Process file
		if ($initial) {
			process_graphfile($file, $prefix);
		} else {
			process_dafile($file, $prefix);
		}
	}
}


sub derive_data($$$)
{
	my ($contentdata, $funcdata, $bbdata) = @_;
	my @gcov_content = @{$contentdata};
	my @gcov_functions = @{$funcdata};
	my %fn_count;
	my %ln_fn;
	my $line;
	my $maxline;
	my %fn_name;
	my $fn;
	my $count;

	if (!defined($bbdata)) {
		return @gcov_functions;
	}

	# First add existing function data
	while (@gcov_functions) {
		$count = shift(@gcov_functions);
		$fn = shift(@gcov_functions);

		$fn_count{$fn} = $count;
	}

	# Convert line coverage data to function data
	foreach $fn (keys(%{$bbdata})) {
		my $line_data = $bbdata->{$fn};
		my $line;

		if ($fn eq "") {
			next;
		}
		# Find the lowest line count for this function
		$count = 0;
		foreach $line (@$line_data) {
			my $lcount = $gcov_content[ ( $line - 1 ) * 3 + 1 ];

			if (($lcount > 0) &&
			    (($count == 0) || ($lcount < $count))) {
				$count = $lcount;
			}
		}
		$fn_count{$fn} = $count;
	}


	# Check if we got data for all functions
	foreach $fn (keys(%fn_name)) {
		if ($fn eq "") {
			next;
		}
		if (defined($fn_count{$fn})) {
			next;
		}
		warn("WARNING: no derived data found for function $fn\n");
	}

	# Convert hash to list in @gcov_functions format
	foreach $fn (sort(keys(%fn_count))) {
		push(@gcov_functions, $fn_count{$fn}, $fn);
	}

	return @gcov_functions;
}

#
# get_filenames(directory, pattern)
#
# Return a list of filenames found in directory which match the specified
# pattern.
#
# Die on error.
#

sub get_filenames($$)
{
	my ($dirname, $pattern) = @_;
	my @result;
	my $directory;
	local *DIR;

	opendir(DIR, $dirname) or
		die("ERROR: cannot read directory $dirname\n");
	while ($directory = readdir(DIR)) {
		push(@result, $directory) if ($directory =~ /$pattern/);
	}
	closedir(DIR);

	return @result;
}

#
# process_dafile(da_filename, dir)
#
# Create a .info file for a single data file.
#
# Die on error.
#

sub process_dafile($$)
{
	my ($file, $dir) = @_;
	my $da_filename;	# Name of data file to process
	my $da_dir;		# Directory of data file
	my $source_dir;		# Directory of source file
	my $da_basename;	# data filename without ".da/.gcda" extension
	my $bb_filename;	# Name of respective graph file
	my $bb_basename;	# Basename of the original graph file
	my $graph;		# Contents of graph file
	my $instr;		# Contents of graph file part 2
	my $gcov_error;		# Error code of gcov tool
	my $object_dir;		# Directory containing all object files
	my $source_filename;	# Name of a source code file
	my $gcov_file;		# Name of a .gcov file
	my @gcov_content;	# Content of a .gcov file
	my $gcov_branches;	# Branch content of a .gcov file
	my @gcov_functions;	# Function calls of a .gcov file
	my @gcov_list;		# List of generated .gcov files
	my $line_number;	# Line number count
	my $lines_hit;		# Number of instrumented lines hit
	my $lines_found;	# Number of instrumented lines found
	my $funcs_hit;		# Number of instrumented functions hit
	my $funcs_found;	# Number of instrumented functions found
	my $br_hit;
	my $br_found;
	my $source;		# gcov source header information
	my $object;		# gcov object header information
	my @matches;		# List of absolute paths matching filename
	my @unprocessed;	# List of unprocessed source code files
	my $base_dir;		# Base directory for current file
	my @tmp_links;		# Temporary links to be cleaned up
	my @result;
	my $index;
	my $da_renamed;		# If data file is to be renamed
	local *INFO_HANDLE;

	info("Processing %s\n", abs2rel($file, $dir));
	# Get path to data file in absolute and normalized form (begins with /,
	# contains no more ../ or ./)
	$da_filename = solve_relative_path($cwd, $file);

	# Get directory and basename of data file
	($da_dir, $da_basename) = split_filename($da_filename);

	# avoid files from .libs dirs 	 
	if ($compat_libtool && $da_dir =~ m/(.*)\/\.libs$/) {
		$source_dir = $1;
	} else {
		$source_dir = $da_dir;
	}

	if (-z $da_filename)
	{
		$da_renamed = 1;
	}
	else
	{
		$da_renamed = 0;
	}

	# Construct base_dir for current file
	if ($base_directory)
	{
		$base_dir = $base_directory;
	}
	else
	{
		$base_dir = $source_dir;
	}

	# Check for writable $base_dir (gcov will try to write files there)
	stat($base_dir);
	if (!-w _)
	{
		die("ERROR: cannot write to directory $base_dir!\n");
	}

	# Construct name of graph file
	$bb_basename = $da_basename.$graph_file_extension;
	$bb_filename = "$da_dir/$bb_basename";

	# Find out the real location of graph file in case we're just looking at
	# a link
	while (readlink($bb_filename))
	{
		my $last_dir = dirname($bb_filename);

		$bb_filename = readlink($bb_filename);
		$bb_filename = solve_relative_path($last_dir, $bb_filename);
	}

	# Ignore empty graph file (e.g. source file with no statement)
	if (-z $bb_filename)
	{
		warn("WARNING: empty $bb_filename (skipped)\n");
		return;
	}

	# Read contents of graph file into hash. We need it later to find out
	# the absolute path to each .gcov file created as well as for
	# information about functions and their source code positions.
	if ($gcov_version < $GCOV_VERSION_3_4_0)
	{
		if (defined($compatibility) && $compatibility eq $COMPAT_HAMMER)
		{
			($instr, $graph) = read_bbg($bb_filename, $base_dir);
		}
		else
		{
			($instr, $graph) = read_bb($bb_filename, $base_dir);
		}
	} 
	else
	{
		($instr, $graph) = read_gcno($bb_filename, $base_dir);
	} 

	# Set $object_dir to real location of object files. This may differ
	# from $da_dir if the graph file is just a link to the "real" object
	# file location.
	$object_dir = dirname($bb_filename);

	# Is the data file in a different directory? (this happens e.g. with
	# the gcov-kernel patch)
	if ($object_dir ne $da_dir)
	{
		# Need to create link to data file in $object_dir
		system("ln", "-s", $da_filename, 
		       "$object_dir/$da_basename$data_file_extension")
			and die ("ERROR: cannot create link $object_dir/".
				 "$da_basename$data_file_extension!\n");
		push(@tmp_links,
		     "$object_dir/$da_basename$data_file_extension");
		# Need to create link to graph file if basename of link
		# and file are different (CONFIG_MODVERSION compat)
		if ((basename($bb_filename) ne $bb_basename) &&
		    (! -e "$object_dir/$bb_basename")) {
			symlink($bb_filename, "$object_dir/$bb_basename") or
				warn("WARNING: cannot create link ".
				     "$object_dir/$bb_basename\n");
			push(@tmp_links, "$object_dir/$bb_basename");
		}
	}

	# Change to directory containing data files and apply GCOV
        chdir($base_dir);

	if ($da_renamed)
	{
		# Need to rename empty data file to workaround
	        # gcov <= 3.2.x bug (Abort)
		system_no_output(3, "mv", "$da_filename", "$da_filename.ori")
			and die ("ERROR: cannot rename $da_filename\n");
	}

	# Execute gcov command and suppress standard output
	$gcov_error = system_no_output(1, $gcov_tool, $da_filename,
				       "-o", $object_dir, @gcov_options);

	if ($da_renamed)
	{
		system_no_output(3, "mv", "$da_filename.ori", "$da_filename")
			and die ("ERROR: cannot rename $da_filename.ori");
	}

	# Clean up temporary links
	foreach (@tmp_links) {
		unlink($_);
	}

	if ($gcov_error)
	{
		if ($ignore[$ERROR_GCOV])
		{
			warn("WARNING: GCOV failed for $da_filename!\n");
			return;
		}
		die("ERROR: GCOV failed for $da_filename!\n");
	}

	# Collect data from resulting .gcov files and create .info file
	@gcov_list = get_filenames('.', '\.gcov$');

	# Check for files
	if (!@gcov_list)
	{
		warn("WARNING: gcov did not create any files for ".
		     "$da_filename!\n");
	}

	# Check whether we're writing to a single file
	if ($output_filename)
	{
		if ($output_filename eq "-")
		{
			*INFO_HANDLE = *STDOUT;
		}
		else
		{
			# Append to output file
			open(INFO_HANDLE, ">>$output_filename")
				or die("ERROR: cannot write to ".
				       "$output_filename!\n");
		}
	}
	else
	{
		# Open .info file for output
		open(INFO_HANDLE, ">$da_filename.info")
			or die("ERROR: cannot create $da_filename.info!\n");
	}

	# Write test name
	printf(INFO_HANDLE "TN:%s\n", $test_name);

	# Traverse the list of generated .gcov files and combine them into a
	# single .info file
	@unprocessed = keys(%{$instr});
	foreach $gcov_file (sort(@gcov_list))
	{
		my $i;
		my $num;

		($source, $object) = read_gcov_header($gcov_file);

		if (defined($source))
		{
			$source = solve_relative_path($base_dir, $source);
		}

		# gcov will happily create output even if there's no source code
		# available - this interferes with checksum creation so we need
		# to pull the emergency brake here.
		if (defined($source) && ! -r $source && $checksum)
		{
			if ($ignore[$ERROR_SOURCE])
			{
				warn("WARNING: could not read source file ".
				     "$source\n");
				next;
			}
			die("ERROR: could not read source file $source\n");
		}

		@matches = match_filename(defined($source) ? $source :
					  $gcov_file, keys(%{$instr}));

		# Skip files that are not mentioned in the graph file
		if (!@matches)
		{
			warn("WARNING: cannot find an entry for ".$gcov_file.
			     " in $graph_file_extension file, skipping ".
			     "file!\n");
			unlink($gcov_file);
			next;
		}

		# Read in contents of gcov file
		@result = read_gcov_file($gcov_file);
		if (!defined($result[0])) {
			warn("WARNING: skipping unreadable file ".
			     $gcov_file."\n");
			unlink($gcov_file);
			next;
		}
		@gcov_content = @{$result[0]};
		$gcov_branches = $result[1];
		@gcov_functions = @{$result[2]};

		# Skip empty files
		if (!@gcov_content)
		{
			warn("WARNING: skipping empty file ".$gcov_file."\n");
			unlink($gcov_file);
			next;
		}

		if (scalar(@matches) == 1)
		{
			# Just one match
			$source_filename = $matches[0];
		}
		else
		{
			# Try to solve the ambiguity
			$source_filename = solve_ambiguous_match($gcov_file,
						\@matches, \@gcov_content);
		}

		# Remove processed file from list
		for ($index = scalar(@unprocessed) - 1; $index >= 0; $index--)
		{
			if ($unprocessed[$index] eq $source_filename)
			{
				splice(@unprocessed, $index, 1);
				last;
			}
		}

		# Write absolute path of source file
		printf(INFO_HANDLE "SF:%s\n", $source_filename);

		# If requested, derive function coverage data from
		# line coverage data of the first line of a function
		if ($opt_derive_func_data) {
			@gcov_functions =
				derive_data(\@gcov_content, \@gcov_functions,
					    $graph->{$source_filename});
		}

		# Write function-related information
		if (defined($graph->{$source_filename}))
		{
			my $fn_data = $graph->{$source_filename};
			my $fn;

			foreach $fn (sort
				{$fn_data->{$a}->[0] <=> $fn_data->{$b}->[0]}
				keys(%{$fn_data})) {
				my $ln_data = $fn_data->{$fn};
				my $line = $ln_data->[0];

				# Skip empty function
				if ($fn eq "") {
					next;
				}
				# Remove excluded functions
				if (!$no_markers) {
					my $gfn;
					my $found = 0;

					foreach $gfn (@gcov_functions) {
						if ($gfn eq $fn) {
							$found = 1;
							last;
						}
					}
					if (!$found) {
						next;
					}
				}

				# Normalize function name
				$fn = filter_fn_name($fn);

				print(INFO_HANDLE "FN:$line,$fn\n");
			}
		}

		#--
		#-- FNDA: <call-count>, <function-name>
		#-- FNF: overall count of functions
		#-- FNH: overall count of functions with non-zero call count
		#--
		$funcs_found = 0;
		$funcs_hit = 0;
		while (@gcov_functions)
		{
			my $count = shift(@gcov_functions);
			my $fn = shift(@gcov_functions);

			$fn = filter_fn_name($fn);
			printf(INFO_HANDLE "FNDA:$count,$fn\n");
			$funcs_found++;
			$funcs_hit++ if ($count > 0);
		}
		if ($funcs_found > 0) {
			printf(INFO_HANDLE "FNF:%s\n", $funcs_found);
			printf(INFO_HANDLE "FNH:%s\n", $funcs_hit);
		}

		# Write coverage information for each instrumented branch:
		#
		#   BRDA:<line number>,<block number>,<branch number>,<taken>
		#
		# where 'taken' is the number of times the branch was taken
		# or '-' if the block to which the branch belongs was never
		# executed
		$br_found = 0;
		$br_hit = 0;
		$num = br_gvec_len($gcov_branches);
		for ($i = 0; $i < $num; $i++) {
			my ($line, $block, $branch, $taken) =
				br_gvec_get($gcov_branches, $i);

			print(INFO_HANDLE "BRDA:$line,$block,$branch,$taken\n");
			$br_found++;
			$br_hit++ if ($taken ne '-' && $taken > 0);
		}
		if ($br_found > 0) {
			printf(INFO_HANDLE "BRF:%s\n", $br_found);
			printf(INFO_HANDLE "BRH:%s\n", $br_hit);
		}

		# Reset line counters
		$line_number = 0;
		$lines_found = 0;
		$lines_hit = 0;

		# Write coverage information for each instrumented line
		# Note: @gcov_content contains a list of (flag, count, source)
		# tuple for each source code line
		while (@gcov_content)
		{
			$line_number++;

			# Check for instrumented line
			if ($gcov_content[0])
			{
				$lines_found++;
				printf(INFO_HANDLE "DA:".$line_number.",".
				       $gcov_content[1].($checksum ?
				       ",". md5_base64($gcov_content[2]) : "").
				       "\n");

				# Increase $lines_hit in case of an execution
				# count>0
				if ($gcov_content[1] > 0) { $lines_hit++; }
			}

			# Remove already processed data from array
			splice(@gcov_content,0,3);
		}

		# Write line statistics and section separator
		printf(INFO_HANDLE "LF:%s\n", $lines_found);
		printf(INFO_HANDLE "LH:%s\n", $lines_hit);
		print(INFO_HANDLE "end_of_record\n");

		# Remove .gcov file after processing
		unlink($gcov_file);
	}

	# Check for files which show up in the graph file but were never
	# processed
	if (@unprocessed && @gcov_list)
	{
		foreach (@unprocessed)
		{
			warn("WARNING: no data found for $_\n");
		}
	}

	if (!($output_filename && ($output_filename eq "-")))
	{
		close(INFO_HANDLE);
	}

	# Change back to initial directory
	chdir($cwd);
}


#
# solve_relative_path(path, dir)
#
# Solve relative path components of DIR which, if not absolute, resides in PATH.
#

sub solve_relative_path($$)
{
	my $path = $_[0];
	my $dir = $_[1];
	my $result;

	$result = $dir;
	# Prepend path if not absolute
	if ($dir =~ /^[^\/]/)
	{
		$result = "$path/$result";
	}

	# Remove //
	$result =~ s/\/\//\//g;

	# Remove .
	$result =~ s/\/\.\//\//g;

	# Solve ..
	while ($result =~ s/\/[^\/]+\/\.\.\//\//)
	{
	}

	# Remove preceding ..
	$result =~ s/^\/\.\.\//\//g;

	return $result;
}


#
# match_filename(gcov_filename, list)
#
# Return a list of those entries of LIST which match the relative filename
# GCOV_FILENAME.
#

sub match_filename($@)
{
	my ($filename, @list) = @_;
	my ($vol, $dir, $file) = splitpath($filename);
	my @comp = splitdir($dir);
	my $comps = scalar(@comp);
	my $entry;
	my @result;

entry:
	foreach $entry (@list) {
		my ($evol, $edir, $efile) = splitpath($entry);
		my @ecomp;
		my $ecomps;
		my $i;

		# Filename component must match
		if ($efile ne $file) {
			next;
		}
		# Check directory components last to first for match
		@ecomp = splitdir($edir);
		$ecomps = scalar(@ecomp);
		if ($ecomps < $comps) {
			next;
		}
		for ($i = 0; $i < $comps; $i++) {
			if ($comp[$comps - $i - 1] ne
			    $ecomp[$ecomps - $i - 1]) {
				next entry;
			}
		}
		push(@result, $entry),
	}

	return @result;
}

#
# solve_ambiguous_match(rel_filename, matches_ref, gcov_content_ref)
#
# Try to solve ambiguous matches of mapping (gcov file) -> (source code) file
# by comparing source code provided in the GCOV file with that of the files
# in MATCHES. REL_FILENAME identifies the relative filename of the gcov
# file.
# 
# Return the one real match or die if there is none.
#

sub solve_ambiguous_match($$$)
{
	my $rel_name = $_[0];
	my $matches = $_[1];
	my $content = $_[2];
	my $filename;
	my $index;
	my $no_match;
	local *SOURCE;

	# Check the list of matches
	foreach $filename (@$matches)
	{

		# Compare file contents
		open(SOURCE, $filename)
			or die("ERROR: cannot read $filename!\n");

		$no_match = 0;
		for ($index = 2; <SOURCE>; $index += 3)
		{
			chomp;

			# Also remove CR from line-end
			s/\015$//;

			if ($_ ne @$content[$index])
			{
				$no_match = 1;
				last;
			}
		}

		close(SOURCE);

		if (!$no_match)
		{
			info("Solved source file ambiguity for $rel_name\n");
			return $filename;
		}
	}

	die("ERROR: could not match gcov data for $rel_name!\n");
}


#
# split_filename(filename)
#
# Return (path, filename, extension) for a given FILENAME.
#

sub split_filename($)
{
	my @path_components = split('/', $_[0]);
	my @file_components = split('\.', pop(@path_components));
	my $extension = pop(@file_components);

	return (join("/",@path_components), join(".",@file_components),
		$extension);
}


#
# read_gcov_header(gcov_filename)
#
# Parse file GCOV_FILENAME and return a list containing the following
# information:
#
#   (source, object)
#
# where:
#
# source: complete relative path of the source code file (gcc >= 3.3 only)
# object: name of associated graph file
#
# Die on error.
#

sub read_gcov_header($)
{
	my $source;
	my $object;
	local *INPUT;

	if (!open(INPUT, $_[0]))
	{
		if ($ignore_errors[$ERROR_GCOV])
		{
			warn("WARNING: cannot read $_[0]!\n");
			return (undef,undef);
		}
		die("ERROR: cannot read $_[0]!\n");
	}

	while (<INPUT>)
	{
		chomp($_);

		# Also remove CR from line-end
		s/\015$//;

		if (/^\s+-:\s+0:Source:(.*)$/)
		{
			# Source: header entry
			$source = $1;
		}
		elsif (/^\s+-:\s+0:Object:(.*)$/)
		{
			# Object: header entry
			$object = $1;
		}
		else
		{
			last;
		}
	}

	close(INPUT);

	return ($source, $object);
}


#
# br_gvec_len(vector)
#
# Return the number of entries in the branch coverage vector.
#

sub br_gvec_len($)
{
	my ($vec) = @_;

	return 0 if (!defined($vec));
	return (length($vec) * 8 / $BR_VEC_WIDTH) / $BR_VEC_ENTRIES;
}


#
# br_gvec_get(vector, number)
#
# Return an entry from the branch coverage vector.
#

sub br_gvec_get($$)
{
	my ($vec, $num) = @_;
	my $line;
	my $block;
	my $branch;
	my $taken;
	my $offset = $num * $BR_VEC_ENTRIES;

	# Retrieve data from vector
	$line	= vec($vec, $offset + $BR_LINE, $BR_VEC_WIDTH);
	$block	= vec($vec, $offset + $BR_BLOCK, $BR_VEC_WIDTH);
	$branch = vec($vec, $offset + $BR_BRANCH, $BR_VEC_WIDTH);
	$taken	= vec($vec, $offset + $BR_TAKEN, $BR_VEC_WIDTH);

	# Decode taken value from an integer
	if ($taken == 0) {
		$taken = "-";
	} else {
		$taken--;
	}

	return ($line, $block, $branch, $taken);
}


#
# br_gvec_push(vector, line, block, branch, taken)
#
# Add an entry to the branch coverage vector.
#

sub br_gvec_push($$$$$)
{
	my ($vec, $line, $block, $branch, $taken) = @_;
	my $offset;

	$vec = "" if (!defined($vec));
	$offset = br_gvec_len($vec) * $BR_VEC_ENTRIES;

	# Encode taken value into an integer
	if ($taken eq "-") {
		$taken = 0;
	} else {
		$taken++;
	}

	# Add to vector
	vec($vec, $offset + $BR_LINE, $BR_VEC_WIDTH) = $line;
	vec($vec, $offset + $BR_BLOCK, $BR_VEC_WIDTH) = $block;
	vec($vec, $offset + $BR_BRANCH, $BR_VEC_WIDTH) = $branch;
	vec($vec, $offset + $BR_TAKEN, $BR_VEC_WIDTH) = $taken;

	return $vec;
}


#
# read_gcov_file(gcov_filename)
#
# Parse file GCOV_FILENAME (.gcov file format) and return the list:
# (reference to gcov_content, reference to gcov_branch, reference to gcov_func)
#
# gcov_content is a list of 3 elements
# (flag, count, source) for each source code line:
#
# $result[($line_number-1)*3+0] = instrumentation flag for line $line_number
# $result[($line_number-1)*3+1] = execution count for line $line_number
# $result[($line_number-1)*3+2] = source code text for line $line_number
#
# gcov_branch is a vector of 4 4-byte long elements for each branch:
# line number, block number, branch number, count + 1 or 0
#
# gcov_func is a list of 2 elements
# (number of calls, function name) for each function
#
# Die on error.
#

sub read_gcov_file($)
{
	my $filename = $_[0];
	my @result = ();
	my $branches = "";
	my @functions = ();
	my $number;
	my $exclude_flag = 0;
	my $exclude_line = 0;
	my $last_block = $UNNAMED_BLOCK;
	my $last_line = 0;
	local *INPUT;

	if (!open(INPUT, $filename)) {
		if ($ignore_errors[$ERROR_GCOV])
		{
			warn("WARNING: cannot read $filename!\n");
			return (undef, undef, undef);
		}
		die("ERROR: cannot read $filename!\n");
	}

	if ($gcov_version < $GCOV_VERSION_3_3_0)
	{
		# Expect gcov format as used in gcc < 3.3
		while (<INPUT>)
		{
			chomp($_);

			# Also remove CR from line-end
			s/\015$//;

			if (/^branch\s+(\d+)\s+taken\s+=\s+(\d+)/) {
				next if ($exclude_line);
				$branches = br_gvec_push($branches, $last_line,
						$last_block, $1, $2);
			} elsif (/^branch\s+(\d+)\s+never\s+executed/) {
				next if ($exclude_line);
				$branches = br_gvec_push($branches, $last_line,
						$last_block, $1, '-');
			}
			elsif (/^call/ || /^function/)
			{
				# Function call return data
			}
			else
			{
				$last_line++;
				# Check for exclusion markers
				if (!$no_markers) {
					if (/$EXCL_STOP/) {
						$exclude_flag = 0;
					} elsif (/$EXCL_START/) {
						$exclude_flag = 1;
					}
					if (/$EXCL_LINE/ || $exclude_flag) {
						$exclude_line = 1;
					} else {
						$exclude_line = 0;
					}
				}
				# Source code execution data
				if (/^\t\t(.*)$/)
				{
					# Uninstrumented line
					push(@result, 0);
					push(@result, 0);
					push(@result, $1);
					next;
				}
				$number = (split(" ",substr($_, 0, 16)))[0];

				# Check for zero count which is indicated
				# by ######
				if ($number eq "######") { $number = 0;	}

				if ($exclude_line) {
					# Register uninstrumented line instead
					push(@result, 0);
					push(@result, 0);
				} else {
					push(@result, 1);
					push(@result, $number);
				}
				push(@result, substr($_, 16));
			}
		}
	}
	else
	{
		# Expect gcov format as used in gcc >= 3.3
		while (<INPUT>)
		{
			chomp($_);

			# Also remove CR from line-end
			s/\015$//;

			if (/^\s*(\d+|\$+):\s*(\d+)-block\s+(\d+)\s*$/) {
				# Block information - used to group related
				# branches
				$last_line = $2;
				$last_block = $3;
			} elsif (/^branch\s+(\d+)\s+taken\s+(\d+)/) {
				next if ($exclude_line);
				$branches = br_gvec_push($branches, $last_line,
						$last_block, $1, $2);
			} elsif (/^branch\s+(\d+)\s+never\s+executed/) {
				next if ($exclude_line);
				$branches = br_gvec_push($branches, $last_line,
						$last_block, $1, '-');
			}
			elsif (/^function\s+(\S+)\s+called\s+(\d+)/)
			{
				if ($exclude_line) {
					next;
				}
				push(@functions, $2, $1);
			}
			elsif (/^call/)
			{
				# Function call return data
			}
			elsif (/^\s*([^:]+):\s*([^:]+):(.*)$/)
			{
				my ($count, $line, $code) = ($1, $2, $3);

				$last_line = $line;
				$last_block = $UNNAMED_BLOCK;
				# Check for exclusion markers
				if (!$no_markers) {
					if (/$EXCL_STOP/) {
						$exclude_flag = 0;
					} elsif (/$EXCL_START/) {
						$exclude_flag = 1;
					}
					if (/$EXCL_LINE/ || $exclude_flag) {
						$exclude_line = 1;
					} else {
						$exclude_line = 0;
					}
				}
				# <exec count>:<line number>:<source code>
				if ($line eq "0")
				{
					# Extra data
				}
				elsif ($count eq "-")
				{
					# Uninstrumented line
					push(@result, 0);
					push(@result, 0);
					push(@result, $code);
				}
				else
				{
					if ($exclude_line) {
						push(@result, 0);
						push(@result, 0);
					} else {
						# Check for zero count
						if ($count eq "#####") {
							$count = 0;
						}
						push(@result, 1);
						push(@result, $count);
					}
					push(@result, $code);
				}
			}
		}
	}

	close(INPUT);
	if ($exclude_flag) {
		warn("WARNING: unterminated exclusion section in $filename\n");
	}
	return(\@result, $branches, \@functions);
}


#
# Get the GCOV tool version. Return an integer number which represents the
# GCOV version. Version numbers can be compared using standard integer
# operations.
#

sub get_gcov_version()
{
	local *HANDLE;
	my $version_string;
	my $result;

	open(GCOV_PIPE, "$gcov_tool -v |")
		or die("ERROR: cannot retrieve gcov version!\n");
	$version_string = <GCOV_PIPE>;
	close(GCOV_PIPE);

	$result = 0;
	if ($version_string =~ /(\d+)\.(\d+)(\.(\d+))?/)
	{
		if (defined($4))
		{
			info("Found gcov version: $1.$2.$4\n");
			$result = $1 << 16 | $2 << 8 | $4;
		}
		else
		{
			info("Found gcov version: $1.$2\n");
			$result = $1 << 16 | $2 << 8;
		}
	}
        if ($version_string =~ /suse/i && $result == 0x30303 ||
            $version_string =~ /mandrake/i && $result == 0x30302)
	{
		info("Using compatibility mode for GCC 3.3 (hammer)\n");
		$compatibility = $COMPAT_HAMMER;
	}
	return $result;
}


#
# info(printf_parameter)
#
# Use printf to write PRINTF_PARAMETER to stdout only when the $quiet flag
# is not set.
#

sub info(@)
{
	if (!$quiet)
	{
		# Print info string
		if (defined($output_filename) && ($output_filename eq "-"))
		{
			# Don't interfere with the .info output to STDOUT
			printf(STDERR @_);
		}
		else
		{
			printf(@_);
		}
	}
}


#
# int_handler()
#
# Called when the script was interrupted by an INT signal (e.g. CTRl-C)
#

sub int_handler()
{
	if ($cwd) { chdir($cwd); }
	info("Aborted.\n");
	exit(1);
}


#
# system_no_output(mode, parameters)
#
# Call an external program using PARAMETERS while suppressing depending on
# the value of MODE:
#
#   MODE & 1: suppress STDOUT
#   MODE & 2: suppress STDERR
#
# Return 0 on success, non-zero otherwise.
#

sub system_no_output($@)
{
	my $mode = shift;
	my $result;
	local *OLD_STDERR;
	local *OLD_STDOUT;

	# Save old stdout and stderr handles
	($mode & 1) && open(OLD_STDOUT, ">>&STDOUT");
	($mode & 2) && open(OLD_STDERR, ">>&STDERR");

	# Redirect to /dev/null
	($mode & 1) && open(STDOUT, ">/dev/null");
	($mode & 2) && open(STDERR, ">/dev/null");
 
	system(@_);
	$result = $?;

	# Close redirected handles
	($mode & 1) && close(STDOUT);
	($mode & 2) && close(STDERR);

	# Restore old handles
	($mode & 1) && open(STDOUT, ">>&OLD_STDOUT");
	($mode & 2) && open(STDERR, ">>&OLD_STDERR");
 
	return $result;
}


#
# read_config(filename)
#
# Read configuration file FILENAME and return a reference to a hash containing
# all valid key=value pairs found.
#

sub read_config($)
{
	my $filename = $_[0];
	my %result;
	my $key;
	my $value;
	local *HANDLE;

	if (!open(HANDLE, "<$filename"))
	{
		warn("WARNING: cannot read configuration file $filename\n");
		return undef;
	}
	while (<HANDLE>)
	{
		chomp;
		# Skip comments
		s/#.*//;
		# Remove leading blanks
		s/^\s+//;
		# Remove trailing blanks
		s/\s+$//;
		next unless length;
		($key, $value) = split(/\s*=\s*/, $_, 2);
		if (defined($key) && defined($value))
		{
			$result{$key} = $value;
		}
		else
		{
			warn("WARNING: malformed statement in line $. ".
			     "of configuration file $filename\n");
		}
	}
	close(HANDLE);
	return \%result;
}


#
# apply_config(REF)
#
# REF is a reference to a hash containing the following mapping:
#
#   key_string => var_ref
#
# where KEY_STRING is a keyword and VAR_REF is a reference to an associated
# variable. If the global configuration hash CONFIG contains a value for
# keyword KEY_STRING, VAR_REF will be assigned the value for that keyword. 
#

sub apply_config($)
{
	my $ref = $_[0];

	foreach (keys(%{$ref}))
	{
		if (defined($config->{$_}))
		{
			${$ref->{$_}} = $config->{$_};
		}
	}
}


#
# get_exclusion_data(filename)
#
# Scan specified source code file for exclusion markers and return
#   linenumber -> 1
# for all lines which should be excluded.
#

sub get_exclusion_data($)
{
	my ($filename) = @_;
	my %list;
	my $flag = 0;
	local *HANDLE;

	if (!open(HANDLE, "<$filename")) {
		warn("WARNING: could not open $filename\n");
		return undef;
	}
	while (<HANDLE>) {
		if (/$EXCL_STOP/) {
			$flag = 0;
		} elsif (/$EXCL_START/) {
			$flag = 1;
		}
		if (/$EXCL_LINE/ || $flag) {
			$list{$.} = 1;
		}
	}
	close(HANDLE);

	if ($flag) {
		warn("WARNING: unterminated exclusion section in $filename\n");
	}

	return \%list;
}


#
# apply_exclusion_data(instr, graph)
#
# Remove lines from instr and graph data structures which are marked
# for exclusion in the source code file.
#
# Return adjusted (instr, graph).
#
# graph         : file name -> function data
# function data : function name -> line data
# line data     : [ line1, line2, ... ]
#
# instr     : filename -> line data
# line data : [ line1, line2, ... ]
#

sub apply_exclusion_data($$)
{
	my ($instr, $graph) = @_;
	my $filename;
	my %excl_data;
	my $excl_read_failed = 0;

	# Collect exclusion marker data
	foreach $filename (sort_uniq_lex(keys(%{$graph}), keys(%{$instr}))) {
		my $excl = get_exclusion_data($filename);

		# Skip and note if file could not be read
		if (!defined($excl)) {
			$excl_read_failed = 1;
			next;
		}

		# Add to collection if there are markers
		$excl_data{$filename} = $excl if (keys(%{$excl}) > 0);
	}

	# Warn if not all source files could be read
	if ($excl_read_failed) {
		warn("WARNING: some exclusion markers may be ignored\n");
	}

	# Skip if no markers were found
	return ($instr, $graph) if (keys(%excl_data) == 0);

	# Apply exclusion marker data to graph
	foreach $filename (keys(%excl_data)) {
		my $function_data = $graph->{$filename};
		my $excl = $excl_data{$filename};
		my $function;

		next if (!defined($function_data));

		foreach $function (keys(%{$function_data})) {
			my $line_data = $function_data->{$function};
			my $line;
			my @new_data;

			# To be consistent with exclusion parser in non-initial
			# case we need to remove a function if the first line
			# was excluded
			if ($excl->{$line_data->[0]}) {
				delete($function_data->{$function});
				next;
			}
			# Copy only lines which are not excluded
			foreach $line (@{$line_data}) {
				push(@new_data, $line) if (!$excl->{$line});
			}

			# Store modified list
			if (scalar(@new_data) > 0) {
				$function_data->{$function} = \@new_data;
			} else {
				# All of this function was excluded
				delete($function_data->{$function});
			}
		}

		# Check if all functions of this file were excluded
		if (keys(%{$function_data}) == 0) {
			delete($graph->{$filename});
		}
	}

	# Apply exclusion marker data to instr
	foreach $filename (keys(%excl_data)) {
		my $line_data = $instr->{$filename};
		my $excl = $excl_data{$filename};
		my $line;
		my @new_data;

		next if (!defined($line_data));

		# Copy only lines which are not excluded
		foreach $line (@{$line_data}) {
			push(@new_data, $line) if (!$excl->{$line});
		}

		# Store modified list
		if (scalar(@new_data) > 0) {
			$instr->{$filename} = \@new_data;
		} else {
			# All of this file was excluded
			delete($instr->{$filename});
		}
	}

	return ($instr, $graph);
}


sub process_graphfile($$)
{
	my ($file, $dir) = @_;
	my $graph_filename = $file;
	my $graph_dir;
	my $graph_basename;
	my $source_dir;
	my $base_dir;
	my $graph;
	my $instr;
	my $filename;
	local *INFO_HANDLE;

	info("Processing %s\n", abs2rel($file, $dir));

	# Get path to data file in absolute and normalized form (begins with /,
	# contains no more ../ or ./)
	$graph_filename = solve_relative_path($cwd, $graph_filename);

	# Get directory and basename of data file
	($graph_dir, $graph_basename) = split_filename($graph_filename);

	# avoid files from .libs dirs 	 
	if ($compat_libtool && $graph_dir =~ m/(.*)\/\.libs$/) {
		$source_dir = $1;
	} else {
		$source_dir = $graph_dir;
	}

	# Construct base_dir for current file
	if ($base_directory)
	{
		$base_dir = $base_directory;
	}
	else
	{
		$base_dir = $source_dir;
	}

	if ($gcov_version < $GCOV_VERSION_3_4_0)
	{
		if (defined($compatibility) && $compatibility eq $COMPAT_HAMMER)
		{
			($instr, $graph) = read_bbg($graph_filename, $base_dir);
		}
		else
		{
			($instr, $graph) = read_bb($graph_filename, $base_dir);
		}
	} 
	else
	{
		($instr, $graph) = read_gcno($graph_filename, $base_dir);
	}

	if (!$no_markers) {
		# Apply exclusion marker data to graph file data
		($instr, $graph) = apply_exclusion_data($instr, $graph);
	}

	# Check whether we're writing to a single file
	if ($output_filename)
	{
		if ($output_filename eq "-")
		{
			*INFO_HANDLE = *STDOUT;
		}
		else
		{
			# Append to output file
			open(INFO_HANDLE, ">>$output_filename")
				or die("ERROR: cannot write to ".
				       "$output_filename!\n");
		}
	}
	else
	{
		# Open .info file for output
		open(INFO_HANDLE, ">$graph_filename.info")
			or die("ERROR: cannot create $graph_filename.info!\n");
	}

	# Write test name
	printf(INFO_HANDLE "TN:%s\n", $test_name);
	foreach $filename (sort(keys(%{$instr})))
	{
		my $funcdata = $graph->{$filename};
		my $line;
		my $linedata;

		print(INFO_HANDLE "SF:$filename\n");

		if (defined($funcdata)) {
			my @functions = sort {$funcdata->{$a}->[0] <=>
					      $funcdata->{$b}->[0]}
					     keys(%{$funcdata});
			my $func;

			# Gather list of instrumented lines and functions
			foreach $func (@functions) {
				$linedata = $funcdata->{$func};

				# Print function name and starting line
				print(INFO_HANDLE "FN:".$linedata->[0].
				      ",".filter_fn_name($func)."\n");
			}
			# Print zero function coverage data
			foreach $func (@functions) {
				print(INFO_HANDLE "FNDA:0,".
				      filter_fn_name($func)."\n");
			}
			# Print function summary
			print(INFO_HANDLE "FNF:".scalar(@functions)."\n");
			print(INFO_HANDLE "FNH:0\n");
		}
		# Print zero line coverage data
		foreach $line (@{$instr->{$filename}}) {
			print(INFO_HANDLE "DA:$line,0\n");
		}
		# Print line summary
		print(INFO_HANDLE "LF:".scalar(@{$instr->{$filename}})."\n");
		print(INFO_HANDLE "LH:0\n");

		print(INFO_HANDLE "end_of_record\n");
	}
	if (!($output_filename && ($output_filename eq "-")))
	{
		close(INFO_HANDLE);
	}
}

sub filter_fn_name($)
{
	my ($fn) = @_;

	# Remove characters used internally as function name delimiters
	$fn =~ s/[,=]/_/g;

	return $fn;
}

sub warn_handler($)
{
	my ($msg) = @_;

	warn("$tool_name: $msg");
}

sub die_handler($)
{
	my ($msg) = @_;

	die("$tool_name: $msg");
}


#
# graph_error(filename, message)
#
# Print message about error in graph file. If ignore_graph_error is set, return.
# Otherwise abort.
#

sub graph_error($$)
{
	my ($filename, $msg) = @_;

	if ($ignore[$ERROR_GRAPH]) {
		warn("WARNING: $filename: $msg - skipping\n");
		return;
	}
	die("ERROR: $filename: $msg\n");
}

#
# graph_expect(description)
#
# If debug is set to a non-zero value, print the specified description of what
# is expected to be read next from the graph file.
#

sub graph_expect($)
{
	my ($msg) = @_;

	if (!$debug || !defined($msg)) {
		return;
	}

	print(STDERR "DEBUG: expecting $msg\n");
}

#
# graph_read(handle, bytes[, description])
#
# Read and return the specified number of bytes from handle. Return undef
# if the number of bytes could not be read.
#

sub graph_read(*$;$)
{
	my ($handle, $length, $desc) = @_;
	my $data;
	my $result;

	graph_expect($desc);
	$result = read($handle, $data, $length);
	if ($debug) {
		my $ascii = "";
		my $hex = "";
		my $i;

		print(STDERR "DEBUG: read($length)=$result: ");
		for ($i = 0; $i < length($data); $i++) {
			my $c = substr($data, $i, 1);;
			my $n = ord($c);

			$hex .= sprintf("%02x ", $n);
			if ($n >= 32 && $n <= 127) {
				$ascii .= $c;
			} else {
				$ascii .= ".";
			}
		}
		print(STDERR "$hex |$ascii|");
		print(STDERR "\n");
	}
	if ($result != $length) {
		return undef;
	}
	return $data;
}

#
# graph_skip(handle, bytes[, description])
#
# Read and discard the specified number of bytes from handle. Return non-zero
# if bytes could be read, zero otherwise.
#

sub graph_skip(*$;$)
{
	my ($handle, $length, $desc) = @_;

	if (defined(graph_read($handle, $length, $desc))) {
		return 1;
	}
	return 0;
}

#
# sort_uniq(list)
#
# Return list in numerically ascending order and without duplicate entries.
#

sub sort_uniq(@)
{
	my (@list) = @_;
	my %hash;

	foreach (@list) {
		$hash{$_} = 1;
	}
	return sort { $a <=> $b } keys(%hash);
}

#
# sort_uniq_lex(list)
#
# Return list in lexically ascending order and without duplicate entries.
#

sub sort_uniq_lex(@)
{
	my (@list) = @_;
	my %hash;

	foreach (@list) {
		$hash{$_} = 1;
	}
	return sort keys(%hash);
}

#
# graph_cleanup(graph)
#
# Remove entries for functions with no lines. Remove duplicate line numbers.
# Sort list of line numbers numerically ascending.
#

sub graph_cleanup($)
{
	my ($graph) = @_;
	my $filename;

	foreach $filename (keys(%{$graph})) {
		my $per_file = $graph->{$filename};
		my $function;

		foreach $function (keys(%{$per_file})) {
			my $lines = $per_file->{$function};

			if (scalar(@$lines) == 0) {
				# Remove empty function
				delete($per_file->{$function});
				next;
			}
			# Normalize list
			$per_file->{$function} = [ sort_uniq(@$lines) ];
		}
		if (scalar(keys(%{$per_file})) == 0) {
			# Remove empty file
			delete($graph->{$filename});
		}
	}
}

#
# graph_find_base(bb)
#
# Try to identify the filename which is the base source file for the
# specified bb data.
#

sub graph_find_base($)
{
	my ($bb) = @_;
	my %file_count;
	my $basefile;
	my $file;
	my $func;
	my $filedata;
	my $count;
	my $num;

	# Identify base name for this bb data.
	foreach $func (keys(%{$bb})) {
		$filedata = $bb->{$func};

		foreach $file (keys(%{$filedata})) {
			$count = $file_count{$file};

			# Count file occurrence
			$file_count{$file} = defined($count) ? $count + 1 : 1;
		}
	}
	$count = 0;
	$num = 0;
	foreach $file (keys(%file_count)) {
		if ($file_count{$file} > $count) {
			# The file that contains code for the most functions
			# is likely the base file
			$count = $file_count{$file};
			$num = 1;
			$basefile = $file;
		} elsif ($file_count{$file} == $count) {
			# If more than one file could be the basefile, we
			# don't have a basefile
			$basefile = undef;
		}
	}

	return $basefile;
}

#
# graph_from_bb(bb, fileorder, bb_filename)
#
# Convert data from bb to the graph format and list of instrumented lines.
# Returns (instr, graph).
#
# bb         : function name -> file data
#            : undef -> file order
# file data  : filename -> line data
# line data  : [ line1, line2, ... ]
#
# file order : function name -> [ filename1, filename2, ... ]
#
# graph         : file name -> function data
# function data : function name -> line data
# line data     : [ line1, line2, ... ]
#
# instr     : filename -> line data
# line data : [ line1, line2, ... ]
#

sub graph_from_bb($$$)
{
	my ($bb, $fileorder, $bb_filename) = @_;
	my $graph = {};
	my $instr = {};
	my $basefile;
	my $file;
	my $func;
	my $filedata;
	my $linedata;
	my $order;

	$basefile = graph_find_base($bb);
	# Create graph structure
	foreach $func (keys(%{$bb})) {
		$filedata = $bb->{$func};
		$order = $fileorder->{$func};

		# Account for lines in functions
		if (defined($basefile) && defined($filedata->{$basefile})) {
			# If the basefile contributes to this function,
			# account this function to the basefile.
			$graph->{$basefile}->{$func} = $filedata->{$basefile};
		} else {
			# If the basefile does not contribute to this function,
			# account this function to the first file contributing
			# lines.
			$graph->{$order->[0]}->{$func} =
				$filedata->{$order->[0]};
		}

		foreach $file (keys(%{$filedata})) {
			# Account for instrumented lines
			$linedata = $filedata->{$file};
			push(@{$instr->{$file}}, @$linedata);
		}
	}
	# Clean up array of instrumented lines
	foreach $file (keys(%{$instr})) {
		$instr->{$file} = [ sort_uniq(@{$instr->{$file}}) ];
	}

	return ($instr, $graph);
}

#
# graph_add_order(fileorder, function, filename)
#
# Add an entry for filename to the fileorder data set for function.
#

sub graph_add_order($$$)
{
	my ($fileorder, $function, $filename) = @_;
	my $item;
	my $list;

	$list = $fileorder->{$function};
	foreach $item (@$list) {
		if ($item eq $filename) {
			return;
		}
	}
	push(@$list, $filename);
	$fileorder->{$function} = $list;
}
#
# read_bb_word(handle[, description])
#
# Read and return a word in .bb format from handle.
#

sub read_bb_word(*;$)
{
	my ($handle, $desc) = @_;

	return graph_read($handle, 4, $desc);
}

#
# read_bb_value(handle[, description])
#
# Read a word in .bb format from handle and return the word and its integer
# value.
#

sub read_bb_value(*;$)
{
	my ($handle, $desc) = @_;
	my $word;

	$word = read_bb_word($handle, $desc);
	return undef if (!defined($word));

	return ($word, unpack("V", $word));
}

#
# read_bb_string(handle, delimiter)
#
# Read and return a string in .bb format from handle up to the specified
# delimiter value.
#

sub read_bb_string(*$)
{
	my ($handle, $delimiter) = @_;
	my $word;
	my $value;
	my $string = "";

	graph_expect("string");
	do {
		($word, $value) = read_bb_value($handle, "string or delimiter");
		return undef if (!defined($value));
		if ($value != $delimiter) {
			$string .= $word;
		}
	} while ($value != $delimiter);
	$string =~ s/\0//g;

	return $string;
}

#
# read_bb(filename, base_dir)
#
# Read the contents of the specified .bb file and return (instr, graph), where:
#
#   instr     : filename -> line data
#   line data : [ line1, line2, ... ]
#
#   graph     :     filename -> file_data
#   file_data : function name -> line_data
#   line_data : [ line1, line2, ... ]
#
# Relative filenames are converted to absolute form using base_dir as
# base directory. See the gcov info pages of gcc 2.95 for a description of
# the .bb file format.
#

sub read_bb($$)
{
	my ($bb_filename, $base) = @_;
	my $minus_one = 0x80000001;
	my $minus_two = 0x80000002;
	my $value;
	my $filename;
	my $function;
	my $bb = {};
	my $fileorder = {};
	my $instr;
	my $graph;
	local *HANDLE;

	open(HANDLE, "<$bb_filename") or goto open_error;
	binmode(HANDLE);
	while (!eof(HANDLE)) {
		$value = read_bb_value(*HANDLE, "data word");
		goto incomplete if (!defined($value));
		if ($value == $minus_one) {
			# Source file name
			graph_expect("filename");
			$filename = read_bb_string(*HANDLE, $minus_one);
			goto incomplete if (!defined($filename));
			if ($filename ne "") {
				$filename = solve_relative_path($base,
								$filename);
			}
		} elsif ($value == $minus_two) {
			# Function name
			graph_expect("function name");
			$function = read_bb_string(*HANDLE, $minus_two);
			goto incomplete if (!defined($function));
		} elsif ($value > 0) {
			# Line number
			if (!defined($filename) || !defined($function)) {
				warn("WARNING: unassigned line number ".
				     "$value\n");
				next;
			}
			push(@{$bb->{$function}->{$filename}}, $value);
			graph_add_order($fileorder, $function, $filename);
		}
	}
	close(HANDLE);
	($instr, $graph) = graph_from_bb($bb, $fileorder, $bb_filename);
	graph_cleanup($graph);

	return ($instr, $graph);

open_error:
	graph_error($bb_filename, "could not open file");
	return undef;
incomplete:
	graph_error($bb_filename, "reached unexpected end of file");
	return undef;
}

#
# read_bbg_word(handle[, description])
#
# Read and return a word in .bbg format.
#

sub read_bbg_word(*;$)
{
	my ($handle, $desc) = @_;

	return graph_read($handle, 4, $desc);
}

#
# read_bbg_value(handle[, description])
#
# Read a word in .bbg format from handle and return its integer value.
#

sub read_bbg_value(*;$)
{
	my ($handle, $desc) = @_;
	my $word;

	$word = read_bbg_word($handle, $desc);
	return undef if (!defined($word));

	return unpack("N", $word);
}

#
# read_bbg_string(handle)
#
# Read and return a string in .bbg format.
#

sub read_bbg_string(*)
{
	my ($handle, $desc) = @_;
	my $length;
	my $string;

	graph_expect("string");
	# Read string length
	$length = read_bbg_value($handle, "string length");
	return undef if (!defined($length));
	if ($length == 0) {
		return "";
	}
	# Read string
	$string = graph_read($handle, $length, "string");
	return undef if (!defined($string));
	# Skip padding
	graph_skip($handle, 4 - $length % 4, "string padding") or return undef;

	return $string;
}

#
# read_bbg_lines_record(handle, bbg_filename, bb, fileorder, filename,
#                       function, base)
#
# Read a bbg format lines record from handle and add the relevant data to
# bb and fileorder. Return filename on success, undef on error.
#

sub read_bbg_lines_record(*$$$$$$)
{
	my ($handle, $bbg_filename, $bb, $fileorder, $filename, $function,
	    $base) = @_;
	my $string;
	my $lineno;

	graph_expect("lines record");
	# Skip basic block index
	graph_skip($handle, 4, "basic block index") or return undef;
	while (1) {
		# Read line number
		$lineno = read_bbg_value($handle, "line number");
		return undef if (!defined($lineno));
		if ($lineno == 0) {
			# Got a marker for a new filename
			graph_expect("filename");
			$string = read_bbg_string($handle);
			return undef if (!defined($string));
			# Check for end of record
			if ($string eq "") {
				return $filename;
			}
			$filename = solve_relative_path($base, $string);
			next;
		}
		# Got an actual line number
		if (!defined($filename)) {
			warn("WARNING: unassigned line number in ".
			     "$bbg_filename\n");
			next;
		}
		push(@{$bb->{$function}->{$filename}}, $lineno);
		graph_add_order($fileorder, $function, $filename);
	}
}

#
# read_bbg(filename, base_dir)
#
# Read the contents of the specified .bbg file and return the following mapping:
#   graph:     filename -> file_data
#   file_data: function name -> line_data
#   line_data: [ line1, line2, ... ]
#
# Relative filenames are converted to absolute form using base_dir as
# base directory. See the gcov-io.h file in the SLES 9 gcc 3.3.3 source code
# for a description of the .bbg format.
#

sub read_bbg($$)
{
	my ($bbg_filename, $base) = @_;
	my $file_magic = 0x67626267;
	my $tag_function = 0x01000000;
	my $tag_lines = 0x01450000;
	my $word;
	my $tag;
	my $length;
	my $function;
	my $filename;
	my $bb = {};
	my $fileorder = {};
	my $instr;
	my $graph;
	local *HANDLE;

	open(HANDLE, "<$bbg_filename") or goto open_error;
	binmode(HANDLE);
	# Read magic
	$word = read_bbg_value(*HANDLE, "file magic");
	goto incomplete if (!defined($word));
	# Check magic
	if ($word != $file_magic) {
		goto magic_error;
	}
	# Skip version
	graph_skip(*HANDLE, 4, "version") or goto incomplete;
	while (!eof(HANDLE)) {
		# Read record tag
		$tag = read_bbg_value(*HANDLE, "record tag");
		goto incomplete if (!defined($tag));
		# Read record length
		$length = read_bbg_value(*HANDLE, "record length");
		goto incomplete if (!defined($tag));
		if ($tag == $tag_function) {
			graph_expect("function record");
			# Read function name
			graph_expect("function name");
			$function = read_bbg_string(*HANDLE);
			goto incomplete if (!defined($function));
			$filename = undef;
			# Skip function checksum
			graph_skip(*HANDLE, 4, "function checksum")
				or goto incomplete;
		} elsif ($tag == $tag_lines) {
			# Read lines record
			$filename = read_bbg_lines_record(HANDLE, $bbg_filename,
					  $bb, $fileorder, $filename,
					  $function, $base);
			goto incomplete if (!defined($filename));
		} else {
			# Skip record contents
			graph_skip(*HANDLE, $length, "unhandled record")
				or goto incomplete;
		}
	}
	close(HANDLE);
	($instr, $graph) = graph_from_bb($bb, $fileorder, $bbg_filename);
	graph_cleanup($graph);

	return ($instr, $graph);

open_error:
	graph_error($bbg_filename, "could not open file");
	return undef;
incomplete:
	graph_error($bbg_filename, "reached unexpected end of file");
	return undef;
magic_error:
	graph_error($bbg_filename, "found unrecognized bbg file magic");
	return undef;
}

#
# read_gcno_word(handle[, description])
#
# Read and return a word in .gcno format.
#

sub read_gcno_word(*;$)
{
	my ($handle, $desc) = @_;

	return graph_read($handle, 4, $desc);
}

#
# read_gcno_value(handle, big_endian[, description])
#
# Read a word in .gcno format from handle and return its integer value
# according to the specified endianness.
#

sub read_gcno_value(*$;$)
{
	my ($handle, $big_endian, $desc) = @_;
	my $word;

	$word = read_gcno_word($handle, $desc);
	return undef if (!defined($word));
	if ($big_endian) {
		return unpack("N", $word);
	} else {
		return unpack("V", $word);
	}
}

#
# read_gcno_string(handle, big_endian)
#
# Read and return a string in .gcno format.
#

sub read_gcno_string(*$)
{
	my ($handle, $big_endian) = @_;
	my $length;
	my $string;

	graph_expect("string");
	# Read string length
	$length = read_gcno_value($handle, $big_endian, "string length");
	return undef if (!defined($length));
	if ($length == 0) {
		return "";
	}
	$length *= 4;
	# Read string
	$string = graph_read($handle, $length, "string and padding");
	return undef if (!defined($string));
	$string =~ s/\0//g;

	return $string;
}

#
# read_gcno_lines_record(handle, gcno_filename, bb, fileorder, filename,
#                        function, base, big_endian)
#
# Read a gcno format lines record from handle and add the relevant data to
# bb and fileorder. Return filename on success, undef on error.
#

sub read_gcno_lines_record(*$$$$$$$)
{
	my ($handle, $gcno_filename, $bb, $fileorder, $filename, $function,
	    $base, $big_endian) = @_;
	my $string;
	my $lineno;

	graph_expect("lines record");
	# Skip basic block index
	graph_skip($handle, 4, "basic block index") or return undef;
	while (1) {
		# Read line number
		$lineno = read_gcno_value($handle, $big_endian, "line number");
		return undef if (!defined($lineno));
		if ($lineno == 0) {
			# Got a marker for a new filename
			graph_expect("filename");
			$string = read_gcno_string($handle, $big_endian);
			return undef if (!defined($string));
			# Check for end of record
			if ($string eq "") {
				return $filename;
			}
			$filename = solve_relative_path($base, $string);
			next;
		}
		# Got an actual line number
		if (!defined($filename)) {
			warn("WARNING: unassigned line number in ".
			     "$gcno_filename\n");
			next;
		}
		# Add to list
		push(@{$bb->{$function}->{$filename}}, $lineno);
		graph_add_order($fileorder, $function, $filename);
	}
}

#
# read_gcno_function_record(handle, graph, base, big_endian)
#
# Read a gcno format function record from handle and add the relevant data
# to graph. Return (filename, function) on success, undef on error. 
#

sub read_gcno_function_record(*$$$$)
{
	my ($handle, $bb, $fileorder, $base, $big_endian) = @_;
	my $filename;
	my $function;
	my $lineno;
	my $lines;

	graph_expect("function record");
	# Skip ident and checksum
	graph_skip($handle, 8, "function ident and checksum") or return undef;
	# Read function name
	graph_expect("function name");
	$function = read_gcno_string($handle, $big_endian);
	return undef if (!defined($function));
	# Read filename
	graph_expect("filename");
	$filename = read_gcno_string($handle, $big_endian);
	return undef if (!defined($filename));
	$filename = solve_relative_path($base, $filename);
	# Read first line number
	$lineno = read_gcno_value($handle, $big_endian, "initial line number");
	return undef if (!defined($lineno));
	# Add to list
	push(@{$bb->{$function}->{$filename}}, $lineno);
	graph_add_order($fileorder, $function, $filename);

	return ($filename, $function);
}

#
# read_gcno(filename, base_dir)
#
# Read the contents of the specified .gcno file and return the following
# mapping:
#   graph:    filename -> file_data
#   file_data: function name -> line_data
#   line_data: [ line1, line2, ... ]
#
# Relative filenames are converted to absolute form using base_dir as
# base directory. See the gcov-io.h file in the gcc 3.3 source code
# for a description of the .gcno format.
#

sub read_gcno($$)
{
	my ($gcno_filename, $base) = @_;
	my $file_magic = 0x67636e6f;
	my $tag_function = 0x01000000;
	my $tag_lines = 0x01450000;
	my $big_endian;
	my $word;
	my $tag;
	my $length;
	my $filename;
	my $function;
	my $bb = {};
	my $fileorder = {};
	my $instr;
	my $graph;
	local *HANDLE;

	open(HANDLE, "<$gcno_filename") or goto open_error;
	binmode(HANDLE);
	# Read magic
	$word = read_gcno_word(*HANDLE, "file magic");
	goto incomplete if (!defined($word));
	# Determine file endianness
	if (unpack("N", $word) == $file_magic) {
		$big_endian = 1;
	} elsif (unpack("V", $word) == $file_magic) {
		$big_endian = 0;
	} else {
		goto magic_error;
	}
	# Skip version and stamp
	graph_skip(*HANDLE, 8, "version and stamp") or goto incomplete;
	while (!eof(HANDLE)) {
		my $next_pos;
		my $curr_pos;

		# Read record tag
		$tag = read_gcno_value(*HANDLE, $big_endian, "record tag");
		goto incomplete if (!defined($tag));
		# Read record length
		$length = read_gcno_value(*HANDLE, $big_endian,
					  "record length");
		goto incomplete if (!defined($length));
		# Convert length to bytes
		$length *= 4;
		# Calculate start of next record
		$next_pos = tell(HANDLE);
		goto tell_error if ($next_pos == -1);
		$next_pos += $length;
		# Process record
		if ($tag == $tag_function) {
			($filename, $function) = read_gcno_function_record(
				*HANDLE, $bb, $fileorder, $base, $big_endian);
			goto incomplete if (!defined($function));
		} elsif ($tag == $tag_lines) {
			# Read lines record
			$filename = read_gcno_lines_record(*HANDLE,
					$gcno_filename, $bb, $fileorder,
					$filename, $function, $base,
					$big_endian);
			goto incomplete if (!defined($filename));
		} else {
			# Skip record contents
			graph_skip(*HANDLE, $length, "unhandled record")
				or goto incomplete;
		}
		# Ensure that we are at the start of the next record
		$curr_pos = tell(HANDLE);
		goto tell_error if ($curr_pos == -1);
		next if ($curr_pos == $next_pos);
		goto record_error if ($curr_pos > $next_pos);
		graph_skip(*HANDLE, $next_pos - $curr_pos,
			   "unhandled record content")
			or goto incomplete;
	}
	close(HANDLE);
	($instr, $graph) = graph_from_bb($bb, $fileorder, $gcno_filename);
	graph_cleanup($graph);

	return ($instr, $graph);

open_error:
	graph_error($gcno_filename, "could not open file");
	return undef;
incomplete:
	graph_error($gcno_filename, "reached unexpected end of file");
	return undef;
magic_error:
	graph_error($gcno_filename, "found unrecognized gcno file magic");
	return undef;
tell_error:
	graph_error($gcno_filename, "could not determine file position");
	return undef;
record_error:
	graph_error($gcno_filename, "found unrecognized record format");
	return undef;
}

sub debug($)
{
	my ($msg) = @_;

	return if (!$debug);
	print(STDERR "DEBUG: $msg");
}

#
# get_gcov_capabilities
#
# Determine the list of available gcov options.
#

sub get_gcov_capabilities()
{
	my $help = `$gcov_tool --help`;
	my %capabilities;

	foreach (split(/\n/, $help)) {
		next if (!/--(\S+)/);
		next if ($1 eq 'help');
		next if ($1 eq 'version');
		next if ($1 eq 'object-directory');

		$capabilities{$1} = 1;
		debug("gcov has capability '$1'\n");
	}

	return \%capabilities;
}