+# Copyright (c) International Business Machines Corp., 2002,2012

+ splitpath catpath/;

+use Cwd qw/abs_path/;

+if( $^O eq "msys" )

+{

+ require File::Spec::Win32;

+}

+our $tool_dir = abs_path(dirname($0));

+our $lcov_version = "LCOV version 1.12";

+our $GCOV_VERSION_4_7_0 = 0x40700;

+# Error classes which users may specify to ignore during processing

+our %ERROR_ID = (

+ "gcov" => $ERROR_GCOV,

+ "source" => $ERROR_SOURCE,

+ "graph" => $ERROR_GRAPH,

+);

+

+# Marker to exclude branch coverage but keep function and line coveage

+our $EXCL_BR_START = "LCOV_EXCL_BR_START";

+our $EXCL_BR_STOP = "LCOV_EXCL_BR_STOP";

+

+# Compatibility mode values

+our $COMPAT_VALUE_OFF = 0;

+our $COMPAT_VALUE_ON = 1;

+our $COMPAT_VALUE_AUTO = 2;

+

+# Compatibility mode value names

+our %COMPAT_NAME_TO_VALUE = (

+ "off" => $COMPAT_VALUE_OFF,

+ "on" => $COMPAT_VALUE_ON,

+ "auto" => $COMPAT_VALUE_AUTO,

+);

+

+# Compatiblity modes

+our $COMPAT_MODE_LIBTOOL = 1 << 0;

+our $COMPAT_MODE_HAMMER = 1 << 1;

+our $COMPAT_MODE_SPLIT_CRC = 1 << 2;

+

+# Compatibility mode names

+our %COMPAT_NAME_TO_MODE = (

+ "libtool" => $COMPAT_MODE_LIBTOOL,

+ "hammer" => $COMPAT_MODE_HAMMER,

+ "split_crc" => $COMPAT_MODE_SPLIT_CRC,

+ "android_4_4_0" => $COMPAT_MODE_SPLIT_CRC,

+);

+

+# Map modes to names

+our %COMPAT_MODE_TO_NAME = (

+ $COMPAT_MODE_LIBTOOL => "libtool",

+ $COMPAT_MODE_HAMMER => "hammer",

+ $COMPAT_MODE_SPLIT_CRC => "split_crc",

+);

+

+# Compatibility mode default values

+our %COMPAT_MODE_DEFAULTS = (

+ $COMPAT_MODE_LIBTOOL => $COMPAT_VALUE_ON,

+ $COMPAT_MODE_HAMMER => $COMPAT_VALUE_AUTO,

+ $COMPAT_MODE_SPLIT_CRC => $COMPAT_VALUE_AUTO,

+);

+

+# Compatibility mode auto-detection routines

+sub compat_hammer_autodetect();

+our %COMPAT_MODE_AUTO = (

+ $COMPAT_MODE_HAMMER => \&compat_hammer_autodetect,

+ $COMPAT_MODE_SPLIT_CRC => 1, # will be done later

+);

+our $BR_VEC_MAX = vec(pack('b*', 1 x $BR_VEC_WIDTH), 0, $BR_VEC_WIDTH);

+our $UNNAMED_BLOCK = -1;

+sub graph_read(*$;$$);

+sub uniq(@);

+sub read_bb($);

+sub read_bbg_lines_record(*$$$$$);

+sub read_bbg($);

+sub read_gcno_word(*;$$);

+sub read_gcno_value(*$;$$);

+sub read_gcno_lines_record(*$$$$$$);

+sub determine_gcno_split_crc($$$);

+sub read_gcno($);

+sub parse_ignore_errors(@);

+sub is_external($);

+sub compat_name($);

+sub parse_compat_modes($);

+sub is_compat($);

+sub is_compat_auto($);

+our $gcov_version_string;

+our $opt_compat_libtool;

+our $opt_no_compat_libtool;

+our $rc_adjust_src_path;# Regexp specifying parts to remove from source path

+our $adjust_src_pattern;

+our $adjust_src_replace;

+our $opt_external = 1;

+our $opt_no_external;

+our @internal_dirs;

+our $opt_config_file;

+our $opt_gcov_all_blocks = 1;

+our $opt_compat;

+our %opt_rc;

+our %compat_value;

+our $gcno_split_crc;

+our $func_coverage = 1;

+our $br_coverage = 0;

+our $rc_auto_base = 1;

+our $excl_line = "LCOV_EXCL_LINE";

+our $excl_br_line = "LCOV_EXCL_BR_LINE";

+# Set LC_ALL so that gcov output will be in a unified format

+$ENV{"LC_ALL"} = "C";

+# Check command line for a configuration file name

+Getopt::Long::Configure("pass_through", "no_auto_abbrev");

+GetOptions("config-file=s" => \$opt_config_file,

+ "rc=s%" => \%opt_rc);

+Getopt::Long::Configure("default");

+

+{

+ # Remove spaces around rc options

+ my %new_opt_rc;

+

+ while (my ($key, $value) = each(%opt_rc)) {

+ $key =~ s/^\s+|\s+$//g;

+ $value =~ s/^\s+|\s+$//g;

+

+ $new_opt_rc{$key} = $value;

+ }

+ %opt_rc = %new_opt_rc;

+}

+if (defined($opt_config_file)) {

+ $config = read_config($opt_config_file);

+} elsif (defined($ENV{"HOME"}) && (-r $ENV{"HOME"}."/.lcovrc"))

+if ($config || %opt_rc)

+ # Copy configuration file and --rc values to variables

+ "geninfo_compat_libtool" => \$opt_compat_libtool,

+ "geninfo_external" => \$opt_external,

+ "geninfo_gcov_all_blocks" => \$opt_gcov_all_blocks,

+ "geninfo_compat" => \$opt_compat,

+ "geninfo_adjust_src_path" => \$rc_adjust_src_path,

+ "geninfo_auto_base" => \$rc_auto_base,

+ "lcov_function_coverage" => \$func_coverage,

+ "lcov_branch_coverage" => \$br_coverage,

+ "lcov_excl_line" => \$excl_line,

+ "lcov_excl_br_line" => \$excl_br_line,

+ });

+

+ # Check regexp

+ if (defined($rc_adjust_src_path)) {

+ my ($pattern, $replace) = split(/\s*=>\s*/,

+ $rc_adjust_src_path);

+ local $SIG{__DIE__};

+ eval '$adjust_src_pattern = qr>'.$pattern.'>;';

+ if (!defined($adjust_src_pattern)) {

+ my $msg = $@;

+

+ chomp($msg);

+ $msg =~ s/at \(eval.*$//;

+ warn("WARNING: invalid pattern in ".

+ "geninfo_adjust_src_path: $msg\n");

+ } elsif (!defined($replace)) {

+ # If no replacement is specified, simply remove pattern

+ $adjust_src_replace = "";

+ } else {

+ $adjust_src_replace = $replace;

+ }

+ }

+ for my $regexp (($excl_line, $excl_br_line)) {

+ eval 'qr/'.$regexp.'/';

+ my $error = $@;

+ chomp($error);

+ $error =~ s/at \(eval.*$//;

+ die("ERROR: invalid exclude pattern: $error") if $error;

+ }

+ "compat-libtool" => \$opt_compat_libtool,

+ "no-compat-libtool" => \$opt_no_compat_libtool,

+ "external" => \$opt_external,

+ "no-external" => \$opt_no_external,

+ "compat=s" => \$opt_compat,

+ "config-file=s" => \$opt_config_file,

+ "rc=s%" => \%opt_rc,

+ if (defined($opt_no_compat_libtool))

+ $opt_compat_libtool = ($opt_no_compat_libtool ? 0 : 1);

+ $opt_no_compat_libtool = undef;

+ }

+

+ if (defined($opt_no_external)) {

+ $opt_external = 0;

+ $opt_no_external = undef;

+# Check gcov tool

+if (system_no_output(3, $gcov_tool, "--help") == -1)

+{

+ die("ERROR: need tool $gcov_tool!\n");

+}

+

+($gcov_version, $gcov_version_string) = get_gcov_version();

+

+# Determine gcov options

+$gcov_caps = get_gcov_capabilities();

+push(@gcov_options, "-b") if ($gcov_caps->{'branch-probabilities'} &&

+ ($br_coverage || $func_coverage));

+push(@gcov_options, "-c") if ($gcov_caps->{'branch-counts'} &&

+ $br_coverage);

+push(@gcov_options, "-a") if ($gcov_caps->{'all-blocks'} &&

+ $opt_gcov_all_blocks && $br_coverage);

+push(@gcov_options, "-p") if ($gcov_caps->{'preserve-paths'});

+

+# Determine compatibility modes

+parse_compat_modes($opt_compat);

+

+# Determine which errors the user wants us to ignore

+parse_ignore_errors(@ignore_errors);

+

+ if (is_compat($COMPAT_MODE_HAMMER))

+ open(DUMMY_HANDLE, ">", $output_filename)

+# Build list of directories to identify external files

+foreach my $entry(@data_directory, $base_directory) {

+ next if (!defined($entry));

+ push(@internal_dirs, solve_relative_path($cwd, $entry));

+}

+

+if ($initial && $br_coverage) {

+ --(no-)external Include (ignore) data for external files

+ --config-file FILENAME Specify configuration file location

+ --rc SETTING=VALUE Override configuration file setting

+ --compat MODE=on|off|auto Set compat MODE (libtool, hammer, split_crc)

+ @file_list = `find "$directory" $maxdepth $follow -name \\*$ext -type f -o -name \\*$ext -type l 2>/dev/null`;

+ if (!@file_list) {

+ warn("WARNING: no $ext files found in $directory - ".

+ "skipping!\n");

+ return;

+ }

+#

+# derive_data(contentdata, funcdata, bbdata)

+#

+# Calculate function coverage data by combining line coverage data and the

+# list of lines belonging to a function.

+#

+# contentdata: [ instr1, count1, source1, instr2, count2, source2, ... ]

+# instr<n>: Instrumentation flag for line n

+# count<n>: Execution count for line n

+# source<n>: Source code for line n

+#

+# funcdata: [ count1, func1, count2, func2, ... ]

+# count<n>: Execution count for function number n

+# func<n>: Function name for function number n

+#

+# bbdata: function_name -> [ line1, line2, ... ]

+# line<n>: Line number belonging to the corresponding function

+#

+

+ my $fninstr = 0;

+ my $linstr = $gcov_content[ ( $line - 1 ) * 3 + 0 ];

+ next if (!$linstr);

+ $fninstr = 1;

+ next if (!$fninstr);

+ $source_dir = $da_dir;

+ if (is_compat($COMPAT_MODE_LIBTOOL)) {

+ # Avoid files from .libs dirs

+ $source_dir =~ s/\.libs$//;

+ if (is_compat($COMPAT_MODE_HAMMER))

+ ($instr, $graph) = read_bbg($bb_filename);

+ ($instr, $graph) = read_bb($bb_filename);

+ ($instr, $graph) = read_gcno($bb_filename);

+ # Try to find base directory automatically if requested by user

+ if ($rc_auto_base) {

+ $base_dir = find_base_from_graph($base_dir, $instr, $graph);

+ }

+

+ ($instr, $graph) = adjust_graph_filenames($base_dir, $instr, $graph);

+

+ debug("chdir($base_dir)\n");

+ open(INFO_HANDLE, ">>", $output_filename)

+ open(INFO_HANDLE, ">", "$da_filename.info")

+ # Skip gcov file for gcc built-in code

+ next if ($gcov_file eq "<built-in>.gcov");

+

+ if (!defined($source)) {

+ # Derive source file name from gcov file name if

+ # header format could not be parsed

+ $source = $gcov_file;

+ $source =~ s/\.gcov$//;

+ }

+

+ $source = solve_relative_path($base_dir, $source);

+

+ if (defined($adjust_src_pattern)) {

+ # Apply transformation as specified by user

+ $source =~ s/$adjust_src_pattern/$adjust_src_replace/g;

+ if (! -r $source && $checksum)

+ @matches = match_filename($source, keys(%{$instr}));

+ # Skip external files if requested

+ if (!$opt_external) {

+ if (is_external($source_filename)) {

+ info(" ignoring data for external file ".

+ "$source_filename\n");

+ unlink($gcov_file);

+ next;

+ $block = $BR_VEC_MAX if ($block < 0);

+ my $volume;

+ my $directories;

+ my $filename;

+ my @dirs; # holds path elements

+ # Convert from Windows path to msys path

+ if( $^O eq "msys" )

+ {

+ # search for a windows drive letter at the beginning

+ ($volume, $directories, $filename) = File::Spec::Win32->splitpath( $dir );

+ if( $volume ne '' )

+ {

+ my $uppercase_volume;

+ # transform c/d\../e/f\g to Windows style c\d\..\e\f\g

+ $dir = File::Spec::Win32->canonpath( $dir );

+ # use Win32 module to retrieve path components

+ # $uppercase_volume is not used any further

+ ( $uppercase_volume, $directories, $filename ) = File::Spec::Win32->splitpath( $dir );

+ @dirs = File::Spec::Win32->splitdir( $directories );

+

+ # prepend volume, since in msys C: is always mounted to /c

+ $volume =~ s|^([a-zA-Z]+):|/\L$1\E|;

+ unshift( @dirs, $volume );

+

+ # transform to Unix style '/' path

+ $directories = File::Spec->catdir( @dirs );

+ $dir = File::Spec->catpath( '', $directories, $filename );

+ } else {

+ # eliminate '\' path separators

+ $dir = File::Spec->canonpath( $dir );

+ }

+ }

+

+ $result =~ s/\/\.$/\//g;

+

+ # Remove trailing /

+ $result =~ s/\/$//g;

+ open(SOURCE, "<", $filename)

+ if (!open(INPUT, "<", $_[0]))

+ $block = -1 if ($block == $BR_VEC_MAX);

+ $block = $BR_VEC_MAX if $block < 0;

+ my $exclude_br_flag = 0;

+ my $exclude_branch = 0;

+ if (!open(INPUT, "<", $filename)) {

+ next if (!$br_coverage);

+ next if ($exclude_branch);

+ next if (!$br_coverage);

+ next if ($exclude_branch);

+ if (/$excl_line/ || $exclude_flag) {

+ # Check for exclusion markers (branch exclude)

+ if (!$no_markers) {

+ if (/$EXCL_BR_STOP/) {

+ $exclude_br_flag = 0;

+ } elsif (/$EXCL_BR_START/) {

+ $exclude_br_flag = 1;

+ }

+ if (/$excl_br_line/ || $exclude_br_flag) {

+ $exclude_branch = 1;

+ } else {

+ $exclude_branch = 0;

+ }

+ }

+ next if (!$br_coverage);

+ next if ($exclude_branch);

+ next if (!$br_coverage);

+ next if ($exclude_branch);

+ elsif (/^function\s+(.+)\s+called\s+(\d+)\s+/)

+ next if (!$func_coverage);

+ if (/$excl_line/ || $exclude_flag) {

+ # Check for exclusion markers (branch exclude)

+ if (!$no_markers) {

+ if (/$EXCL_BR_STOP/) {

+ $exclude_br_flag = 0;

+ } elsif (/$EXCL_BR_START/) {

+ $exclude_br_flag = 1;

+ }

+ if (/$excl_br_line/ || $exclude_br_flag) {

+ $exclude_branch = 1;

+ } else {

+ $exclude_branch = 0;

+ }

+ }

+

+ if ($count =~ /^[#=]/) {

+ if ($exclude_flag || $exclude_br_flag) {

+ my $pipe_next_line;

+ open(GCOV_PIPE, "-|", "$gcov_tool --version")

+ # LLVM gcov keeps version information on the second line.

+ # For example, gcov --version yields:

+ # LLVM (http://llvm.org/):

+ # LLVM version 3.4svn

+

+ $pipe_next_line = <GCOV_PIPE>;

+ # In case version information is on first line.

+ # For example, with Xcode 7.0 gcov --version yields:

+ # Apple LLVM 7.0.0 (clang-700.0.65)

+

+ $version_string = $pipe_next_line if ($pipe_next_line && $version_string =~ /LLVM/);

+ # Remove version information in parenthesis to cope with the following:

+ # - gcov (GCC) 4.4.7 20120313 (Red Hat 4.4.7-3)

+ # - gcov (crosstool-NG 1.18.0) 4.7.2

+ $version_string =~ s/\([^\)]*\)//g;

+

+ if ($version_string =~ /LLVM/)

+ # Map LLVM versions to the version of GCC gcov which

+ # they emulate

+ if ($result >= 0x030400)

+ {

+ info("Found LLVM gcov version 3.4, which emulates gcov version 4.2\n");

+ $result = 0x040200;

+ }

+ else

+ {

+ warn("This version of LLVM's gcov is unknown. Assuming it emulates GCC gcov version 4.2.\n");

+ $result = 0x040200;

+ }

+ return ($result, $version_string);

+ ($mode & 1) && open(OLD_STDOUT, ">>&", "STDOUT");

+ ($mode & 2) && open(OLD_STDERR, ">>&", "STDERR");

+ ($mode & 1) && open(STDOUT, ">", "/dev/null");

+ ($mode & 2) && open(STDERR, ">", "/dev/null");

+ debug("system(".join(' ', @_).")\n");

+ ($mode & 1) && open(STDOUT, ">>&", "OLD_STDOUT");

+ ($mode & 2) && open(STDERR, ">>&", "OLD_STDERR");

+ if (!open(HANDLE, "<", $filename))

+# variable. If the global configuration hashes CONFIG or OPT_RC contain a value

+# for keyword KEY_STRING, VAR_REF will be assigned the value for that keyword.

+ if (defined($opt_rc{$_})) {

+ ${$ref->{$_}} = $opt_rc{$_};

+ } elsif (defined($config->{$_})) {

+ if (!open(HANDLE, "<", $filename)) {

+ if (/$excl_line/ || $flag) {

+ $instr->{$filename} = \@new_data;

+ $source_dir = $graph_dir;

+ if (is_compat($COMPAT_MODE_LIBTOOL)) {

+ # Avoid files from .libs dirs

+ $source_dir =~ s/\.libs$//;

+ # Ignore empty graph file (e.g. source file with no statement)

+ if (-z $graph_filename)

+ {

+ warn("WARNING: empty $graph_filename (skipped)\n");

+ return;

+ }

+

+ if (is_compat($COMPAT_MODE_HAMMER))

+ ($instr, $graph) = read_bbg($graph_filename);

+ ($instr, $graph) = read_bb($graph_filename);

+ ($instr, $graph) = read_gcno($graph_filename);

+ # Try to find base directory automatically if requested by user

+ if ($rc_auto_base) {

+ $base_dir = find_base_from_graph($base_dir, $instr, $graph);

+ }

+

+ ($instr, $graph) = adjust_graph_filenames($base_dir, $instr, $graph);

+

+ open(INFO_HANDLE, ">>", $output_filename)

+ open(INFO_HANDLE, ">", "$graph_filename.info")

+ # Skip external files if requested

+ if (!$opt_external) {

+ if (is_external($filename)) {

+ info(" ignoring data for external file ".

+ "$filename\n");

+ next;

+ }

+ }

+

+ if (defined($funcdata) && $func_coverage) {

+# graph_read(handle, bytes[, description, peek])

+# if the number of bytes could not be read. If PEEK is non-zero, reset

+# file position after read.

+sub graph_read(*$;$$)

+ my ($handle, $length, $desc, $peek) = @_;

+ my $pos;

+ if ($peek) {

+ $pos = tell($handle);

+ if ($pos == -1) {

+ warn("Could not get current file position: $!\n");

+ return undef;

+ }

+ }

+ my $op = $peek ? "peek" : "read";

+ print(STDERR "DEBUG: $op($length)=$result: ");

+ if ($peek) {

+ if (!seek($handle, $pos, 0)) {

+ warn("Could not set file position: $!\n");

+ return undef;

+ }

+ }

+# uniq(list)

+#

+# Return list without duplicate entries.

+#

+

+sub uniq(@)

+{

+ my (@list) = @_;

+ my @new_list;

+ my %known;

+

+ foreach my $item (@list) {

+ next if ($known{$item});

+ $known{$item} = 1;

+ push(@new_list, $item);

+ }

+

+ return @new_list;

+}

+

+#

+# parent_dir(dir)

+#

+# Return parent directory for DIR. DIR must not contain relative path

+# components.

+#

+

+sub parent_dir($)

+{

+ my ($dir) = @_;

+ my ($v, $d, $f) = splitpath($dir, 1);

+ my @dirs = splitdir($d);

+

+ pop(@dirs);

+

+ return catpath($v, catdir(@dirs), $f);

+}

+

+#

+# find_base_from_graph(base_dir, instr, graph)

+#

+# Try to determine the base directory of the graph file specified by INSTR

+# and GRAPH. The base directory is the base for all relative filenames in

+# the graph file. It is defined by the current working directory at time

+# of compiling the source file.

+#

+# This function implements a heuristic which relies on the following

+# assumptions:

+# - all files used for compilation are still present at their location

+# - the base directory is either BASE_DIR or one of its parent directories

+# - files by the same name are not present in multiple parent directories

+#

+

+sub find_base_from_graph($$$)

+{

+ my ($base_dir, $instr, $graph) = @_;

+ my $old_base;

+ my $best_miss;

+ my $best_base;

+ my %rel_files;

+

+ # Determine list of relative paths

+ foreach my $filename (keys(%{$instr}), keys(%{$graph})) {

+ next if (file_name_is_absolute($filename));

+

+ $rel_files{$filename} = 1;

+ }

+

+ # Early exit if there are no relative paths

+ return $base_dir if (!%rel_files);

+

+ do {

+ my $miss = 0;

+

+ foreach my $filename (keys(%rel_files)) {

+ if (!-e solve_relative_path($base_dir, $filename)) {

+ $miss++;

+ }

+ }

+

+ debug("base_dir=$base_dir miss=$miss\n");

+

+ # Exit if we find an exact match with no misses

+ return $base_dir if ($miss == 0);

+

+ # No exact match, aim for the one with the least source file

+ # misses

+ if (!defined($best_base) || $miss < $best_miss) {

+ $best_base = $base_dir;

+ $best_miss = $miss;

+ }

+

+ # Repeat until there's no more parent directory

+ $old_base = $base_dir;

+ $base_dir = parent_dir($base_dir);

+ } while ($old_base ne $base_dir);

+

+ return $best_base;

+}

+

+#

+# adjust_graph_filenames(base_dir, instr, graph)

+#

+# Make relative paths in INSTR and GRAPH absolute and apply

+# geninfo_adjust_src_path setting to graph file data.

+#

+

+sub adjust_graph_filenames($$$)

+{

+ my ($base_dir, $instr, $graph) = @_;

+

+ foreach my $filename (keys(%{$instr})) {

+ my $old_filename = $filename;

+

+ # Convert to absolute canonical form

+ $filename = solve_relative_path($base_dir, $filename);

+

+ # Apply adjustment

+ if (defined($adjust_src_pattern)) {

+ $filename =~ s/$adjust_src_pattern/$adjust_src_replace/g;

+ }

+

+ if ($filename ne $old_filename) {

+ $instr->{$filename} = delete($instr->{$old_filename});

+ }

+ }

+

+ foreach my $filename (keys(%{$graph})) {

+ my $old_filename = $filename;

+

+ # Make absolute

+ # Convert to absolute canonical form

+ $filename = solve_relative_path($base_dir, $filename);

+

+ # Apply adjustment

+ if (defined($adjust_src_pattern)) {

+ $filename =~ s/$adjust_src_pattern/$adjust_src_replace/g;

+ }

+

+ if ($filename ne $old_filename) {

+ $graph->{$filename} = delete($graph->{$old_filename});

+ }

+ }

+

+ return ($instr, $graph);

+}

+

+#

+ $per_file->{$function} = [ uniq(@$lines) ];

+

+# read_bb(filename)

+# See the gcov info pages of gcc 2.95 for a description of the .bb file format.

+sub read_bb($)

+ my ($bb_filename) = @_;

+ open(HANDLE, "<", $bb_filename) or goto open_error;

+# function)

+sub read_bbg_lines_record(*$$$$$)

+ my ($handle, $bbg_filename, $bb, $fileorder, $filename, $function) = @_;

+ $filename = $string;

+ if (!exists($bb->{$function}->{$filename})) {

+ $bb->{$function}->{$filename} = [];

+ }

+# read_bbg(filename)

+# 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) = @_;

+ open(HANDLE, "<", $bbg_filename) or goto open_error;

+ $function);

+# read_gcno_word(handle[, description, peek])

+sub read_gcno_word(*;$$)

+ my ($handle, $desc, $peek) = @_;

+ return graph_read($handle, 4, $desc, $peek);

+# read_gcno_value(handle, big_endian[, description, peek])

+# according to the specified endianness. If PEEK is non-zero, reset file

+# position after read.

+sub read_gcno_value(*$;$$)

+ my ($handle, $big_endian, $desc, $peek) = @_;

+ my $pos;

+ $word = read_gcno_word($handle, $desc, $peek);

+# function, big_endian)

+sub read_gcno_lines_record(*$$$$$$)

+ $big_endian) = @_;

+ $filename = $string;

+ if (!exists($bb->{$function}->{$filename})) {

+ $bb->{$function}->{$filename} = [];

+ }

+# determine_gcno_split_crc(handle, big_endian, rec_length)

+#

+# Determine if HANDLE refers to a .gcno file with a split checksum function

+# record format. Return non-zero in case of split checksum format, zero

+# otherwise, undef in case of read error.

+#

+

+sub determine_gcno_split_crc($$$)

+{

+ my ($handle, $big_endian, $rec_length) = @_;

+ my $strlen;

+ my $overlong_string;

+

+ return 1 if ($gcov_version >= $GCOV_VERSION_4_7_0);

+ return 1 if (is_compat($COMPAT_MODE_SPLIT_CRC));

+

+ # Heuristic:

+ # Decide format based on contents of next word in record:

+ # - pre-gcc 4.7

+ # This is the function name length / 4 which should be

+ # less than the remaining record length

+ # - gcc 4.7

+ # This is a checksum, likely with high-order bits set,

+ # resulting in a large number

+ $strlen = read_gcno_value($handle, $big_endian, undef, 1);

+ return undef if (!defined($strlen));

+ $overlong_string = 1 if ($strlen * 4 >= $rec_length - 12);

+

+ if ($overlong_string) {

+ if (is_compat_auto($COMPAT_MODE_SPLIT_CRC)) {

+ info("Auto-detected compatibility mode for split ".

+ "checksum .gcno file format\n");

+

+ return 1;

+ } else {

+ # Sanity check

+ warn("Found overlong string in function record: ".

+ "try '--compat split_crc'\n");

+ }

+ }

+

+ return 0;

+}

+

+#

+# read_gcno_function_record(handle, graph, big_endian, rec_length)

+ my ($handle, $bb, $fileorder, $big_endian, $rec_length) = @_;

+ # Determine if this is a function record with split checksums

+ if (!defined($gcno_split_crc)) {

+ $gcno_split_crc = determine_gcno_split_crc($handle, $big_endian,

+ $rec_length);

+ return undef if (!defined($gcno_split_crc));

+ }

+ # Skip cfg checksum word in case of split checksums

+ graph_skip($handle, 4, "function cfg checksum") if ($gcno_split_crc);

+# read_gcno(filename)

+# 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) = @_;

+ my $filelength;

+ open(HANDLE, "<", $gcno_filename) or goto open_error;

+ $filelength = (stat(HANDLE))[7];

+ # Catch garbage at the end of a gcno file

+ if ($next_pos > $filelength) {

+ debug("Overlong record: file_length=$filelength ".

+ "rec_length=$length\n");

+ warn("WARNING: $gcno_filename: Overlong record at end ".

+ "of file!\n");

+ last;

+ }

+ *HANDLE, $bb, $fileorder, $big_endian,

+ $length);

+ $filename, $function,

+ my %short_option_translations = (

+ 'a' => 'all-blocks',

+ 'b' => 'branch-probabilities',

+ 'c' => 'branch-counts',

+ 'f' => 'function-summaries',

+ 'h' => 'help',

+ 'l' => 'long-file-names',

+ 'n' => 'no-output',

+ 'o' => 'object-directory',

+ 'p' => 'preserve-paths',

+ 'u' => 'unconditional-branches',

+ 'v' => 'version',

+ );

+ my $capability;

+ if (/--(\S+)/) {

+ $capability = $1;

+ } else {

+ # If the line provides a short option, translate it.

+ next if (!/^\s*-(\S)\s/);

+ $capability = $short_option_translations{$1};

+ next if not defined($capability);

+ }

+ next if ($capability eq 'help');

+ next if ($capability eq 'version');

+ next if ($capability eq 'object-directory');

+ $capabilities{$capability} = 1;

+ debug("gcov has capability '$capability'\n");

+

+#

+# parse_ignore_errors(@ignore_errors)

+#

+# Parse user input about which errors to ignore.

+#

+

+sub parse_ignore_errors(@)

+{

+ my (@ignore_errors) = @_;

+ my @items;

+ my $item;

+

+ return if (!@ignore_errors);

+

+ foreach $item (@ignore_errors) {

+ $item =~ s/\s//g;

+ if ($item =~ /,/) {

+ # Split and add comma-separated parameters

+ push(@items, split(/,/, $item));

+ } else {

+ # Add single parameter

+ push(@items, $item);

+ }

+ }

+ foreach $item (@items) {

+ my $item_id = $ERROR_ID{lc($item)};

+

+ if (!defined($item_id)) {

+ die("ERROR: unknown argument for --ignore-errors: ".

+ "$item\n");

+ }

+ $ignore[$item_id] = 1;

+ }

+}

+

+#

+# is_external(filename)

+#

+# Determine if a file is located outside of the specified data directories.

+#

+

+sub is_external($)

+{

+ my ($filename) = @_;

+ my $dir;

+

+ foreach $dir (@internal_dirs) {

+ return 0 if ($filename =~ /^\Q$dir\/\E/);

+ }

+ return 1;

+}

+

+#

+# compat_name(mode)

+#

+# Return the name of compatibility mode MODE.

+#

+

+sub compat_name($)

+{

+ my ($mode) = @_;

+ my $name = $COMPAT_MODE_TO_NAME{$mode};

+

+ return $name if (defined($name));

+

+ return "<unknown>";

+}

+

+#

+# parse_compat_modes(opt)

+#

+# Determine compatibility mode settings.

+#

+

+sub parse_compat_modes($)

+{

+ my ($opt) = @_;

+ my @opt_list;

+ my %specified;

+

+ # Initialize with defaults

+ %compat_value = %COMPAT_MODE_DEFAULTS;

+

+ # Add old style specifications

+ if (defined($opt_compat_libtool)) {

+ $compat_value{$COMPAT_MODE_LIBTOOL} =

+ $opt_compat_libtool ? $COMPAT_VALUE_ON

+ : $COMPAT_VALUE_OFF;

+ }

+

+ # Parse settings

+ if (defined($opt)) {

+ @opt_list = split(/\s*,\s*/, $opt);

+ }

+ foreach my $directive (@opt_list) {

+ my ($mode, $value);

+

+ # Either

+ # mode=off|on|auto or

+ # mode (implies on)

+ if ($directive !~ /^(\w+)=(\w+)$/ &&

+ $directive !~ /^(\w+)$/) {

+ die("ERROR: Unknown compatibility mode specification: ".

+ "$directive!\n");

+ }

+ # Determine mode

+ $mode = $COMPAT_NAME_TO_MODE{lc($1)};

+ if (!defined($mode)) {

+ die("ERROR: Unknown compatibility mode '$1'!\n");

+ }

+ $specified{$mode} = 1;

+ # Determine value

+ if (defined($2)) {

+ $value = $COMPAT_NAME_TO_VALUE{lc($2)};

+ if (!defined($value)) {

+ die("ERROR: Unknown compatibility mode ".

+ "value '$2'!\n");

+ }

+ } else {

+ $value = $COMPAT_VALUE_ON;

+ }

+ $compat_value{$mode} = $value;

+ }

+ # Perform auto-detection

+ foreach my $mode (sort(keys(%compat_value))) {

+ my $value = $compat_value{$mode};

+ my $is_autodetect = "";

+ my $name = compat_name($mode);

+

+ if ($value == $COMPAT_VALUE_AUTO) {

+ my $autodetect = $COMPAT_MODE_AUTO{$mode};

+

+ if (!defined($autodetect)) {

+ die("ERROR: No auto-detection for ".

+ "mode '$name' available!\n");

+ }

+

+ if (ref($autodetect) eq "CODE") {

+ $value = &$autodetect();

+ $compat_value{$mode} = $value;

+ $is_autodetect = " (auto-detected)";

+ }

+ }

+

+ if ($specified{$mode}) {

+ if ($value == $COMPAT_VALUE_ON) {

+ info("Enabling compatibility mode ".

+ "'$name'$is_autodetect\n");

+ } elsif ($value == $COMPAT_VALUE_OFF) {

+ info("Disabling compatibility mode ".

+ "'$name'$is_autodetect\n");

+ } else {

+ info("Using delayed auto-detection for ".

+ "compatibility mode ".

+ "'$name'\n");

+ }

+ }

+ }

+}

+

+sub compat_hammer_autodetect()

+{

+ if ($gcov_version_string =~ /suse/i && $gcov_version == 0x30303 ||

+ $gcov_version_string =~ /mandrake/i && $gcov_version == 0x30302)

+ {

+ info("Auto-detected compatibility mode for GCC 3.3 (hammer)\n");

+ return $COMPAT_VALUE_ON;

+ }

+ return $COMPAT_VALUE_OFF;

+}

+

+#

+# is_compat(mode)

+#

+# Return non-zero if compatibility mode MODE is enabled.

+#

+

+sub is_compat($)

+{

+ my ($mode) = @_;

+

+ return 1 if ($compat_value{$mode} == $COMPAT_VALUE_ON);

+ return 0;

+}

+

+#

+# is_compat_auto(mode)

+#

+# Return non-zero if compatibility mode MODE is set to auto-detect.

+#

+

+sub is_compat_auto($)

+{

+ my ($mode) = @_;

+

+ return 1 if ($compat_value{$mode} == $COMPAT_VALUE_AUTO);

+ return 0;

+}