+our $lcov_version = 'LCOV version 1.9';

+# Prettify version string

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

+

+ if (/^(\w[\w-]*)(\s*)$/)

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

+our $lcov_version = 'LCOV version 1.9';

+# For line coverage/all coverage types if not specified

+our $hi_limit = 90;

+our $med_limit = 75;

+our $fn_hi_limit;

+our $fn_med_limit;

+

+# For branch coverage

+our $br_hi_limit;

+our $br_med_limit;

+our $overview_title = "top level";

+

+# Width for line coverage information in the source code view

+our $line_field_width = 12;

+

+# Width for branch coverage information in the source code view

+our $br_field_width = 16;

+

+# Internal Constants

+

+# Header types

+our $HDR_DIR = 0;

+our $HDR_FILE = 1;

+our $HDR_SOURCE = 2;

+our $HDR_TESTDESC = 3;

+our $HDR_FUNC = 4;

+

+# Sort types

+our $SORT_FILE = 0;

+our $SORT_LINE = 1;

+our $SORT_FUNC = 2;

+our $SORT_BRANCH = 3;

+

+# Fileview heading types

+our $HEAD_NO_DETAIL = 1;

+our $HEAD_DETAIL_HIDDEN = 2;

+our $HEAD_DETAIL_SHOWN = 3;

+

+# Offsets for storing branch coverage data in vectors

+our $BR_BLOCK = 0;

+our $BR_BRANCH = 1;

+our $BR_TAKEN = 2;

+our $BR_VEC_ENTRIES = 3;

+our $BR_VEC_WIDTH = 32;

+

+# Additional offsets used when converting branch coverage data to HTML

+our $BR_LEN = 3;

+our $BR_OPEN = 4;

+our $BR_CLOSE = 5;

+

+# Branch data combination types

+our $BR_SUB = 0;

+our $BR_ADD = 1;

+sub set_info_entry($$$$$$$$$;$$$$$$);

+sub get_affecting_tests($$$);

+sub write_dir_page($$$$$$$$$$$$$$$$$);

+sub classify_rate($$$$);

+sub br_taken_add($$);

+sub br_taken_sub($$);

+sub br_ivec_len($);

+sub br_ivec_get($$);

+sub br_ivec_push($$$$);

+sub combine_brcount($$$);

+sub get_br_found_and_hit($);

+sub warn_handler($);

+sub die_handler($);

+sub write_description_file($$$$$$$);

+sub write_function_table(*$$$$$$$$$$);

+sub write_header(*$$$$$$$$$$);

+sub write_header_line(*@);

+sub write_file_table(*$$$$$$$);

+sub write_file_table_prolog(*$@);

+sub write_file_table_entry(*$$$@);

+sub write_file_table_detail_entry(*$@);

+sub write_source($$$$$$$);

+sub write_source_line(*$$$$$$);

+our $br_coverage = 1; # If set, generate branch coverage statistics

+our $no_br_coverage; # Disable br_coverage

+our $demangle_cpp = 0; # Demangle C++ function names

+our @fileview_sortname = ("", "-sort-l", "-sort-f", "-sort-b");

+# Prettify version string

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

+

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

+ "genhtml_line_field_width" => \$line_field_width,

+ "genhtml_branch_hi_limit" => \$br_hi_limit,

+ "genhtml_branch_med_limit" => \$br_med_limit,

+ "genhtml_branch_coverage" => \$br_coverage,

+ "genhtml_branch_field_width" => \$br_field_width,

+# Copy limit values if not specified

+$fn_hi_limit = $hi_limit if (!defined($fn_hi_limit));

+$fn_med_limit = $med_limit if (!defined($fn_med_limit));

+$br_hi_limit = $hi_limit if (!defined($br_hi_limit));

+$br_med_limit = $med_limit if (!defined($br_med_limit));

+

+if (!GetOptions("output-directory|o=s" => \$output_directory,

+ "title|t=s" => \$test_title,

+ "description-file|d=s" => \$desc_filename,

+ "keep-descriptions|k" => \$keep_descriptions,

+ "css-file|c=s" => \$css_filename,

+ "baseline-file|b=s" => \$base_filename,

+ "prefix|p=s" => \$dir_prefix,

+ "show-details|s" => \$show_details,

+ "frames|f" => \$frames,

+ "quiet|q" => \$quiet,

+ "version|v" => \$version,

+ "branch-coverage" => \$br_coverage,

+ "no-branch-coverage" => \$no_br_coverage,

+ "demangle-cpp" => \$demangle_cpp,

+ if ($no_br_coverage) {

+ $br_coverage = 0;

+ }

+@fileview_sortlist = ($SORT_FILE);

+@funcview_sortlist = ($SORT_FILE);

+

+ push(@fileview_sortlist, $SORT_LINE);

+ push(@fileview_sortlist, $SORT_FUNC) if ($func_coverage);

+ push(@fileview_sortlist, $SORT_BRANCH) if ($br_coverage);

+ push(@funcview_sortlist, $SORT_LINE);

+# Ensure that the c++filt tool is available when using --demangle-cpp

+if ($demangle_cpp)

+{

+ if (system_no_output(3, "c++filt", "--version")) {

+ die("ERROR: could not find c++filt tool needed for ".

+ "--demangle-cpp\n");

+ }

+}

+

+ create_sub_dir($output_directory);

+ --(no-)branch-coverage Enable (disable) branch coverage display

+ --demangle-cpp Demangle C++ function names

+# get_overall_line(found, hit, name_singular, name_plural)

+#

+# Return a string containing overall information for the specified

+# found/hit data.

+#

+

+sub get_overall_line($$$$)

+{

+ my ($found, $hit, $name_sn, $name_pl) = @_;

+ my $name;

+

+ return "no data found" if (!defined($found) || $found == 0);

+ $name = ($found == 1) ? $name_sn : $name_pl;

+ return sprintf("%.1f%% (%d of %d %s)", $hit * 100 / $found, $hit,

+ $found, $name);

+}

+

+

+#

+# print_overall_rate(ln_do, ln_found, ln_hit, fn_do, fn_found, fn_hit, br_do

+# br_found, br_hit)

+#

+# Print overall coverage rates for the specified coverage types.

+#

+

+sub print_overall_rate($$$$$$$$$)

+{

+ my ($ln_do, $ln_found, $ln_hit, $fn_do, $fn_found, $fn_hit,

+ $br_do, $br_found, $br_hit) = @_;

+

+ info("Overall coverage rate:\n");

+ info(" lines......: %s\n",

+ get_overall_line($ln_found, $ln_hit, "line", "lines"))

+ if ($ln_do);

+ info(" functions..: %s\n",

+ get_overall_line($fn_found, $fn_hit, "function", "functions"))

+ if ($fn_do);

+ info(" branches...: %s\n",

+ get_overall_line($br_found, $br_hit, "branch", "branches"))

+ if ($br_do);

+}

+

+

+#

+ my $br_found;

+ my $br_hit;

+ my $total_br_found = 0;

+ my $total_br_hit = 0;

+ ($lines_found, $lines_hit, $fn_found, $fn_hit,

+ $br_found, $br_hit)

+ $fn_hit, $br_found, $br_hit, $link_name,

+ get_rate($fn_found, $fn_hit),

+ get_rate($br_found, $br_hit)];

+ $total_br_found += $br_found;

+ $total_br_hit += $br_hit;

+ $total_fn_found, $total_fn_hit, $total_br_found,

+ $total_br_hit, \%overview, {}, {}, {}, 0, $_);

+ $total_fn_found, $total_fn_hit,

+ $total_br_found, $total_br_hit);

+ print_overall_rate(1, $overall_found, $overall_hit,

+ $func_coverage, $total_fn_found, $total_fn_hit,

+ $br_coverage, $total_br_found, $total_br_hit);

+ chdir($cwd);

+sub write_dir_page($$$$$$$$$$$$$$$$$)

+ $overall_hit, $total_fn_found, $total_fn_hit, $total_br_found,

+ $total_br_hit, $overview, $testhash, $testfnchash, $testbrhash,

+ $view_type, $sort_type) = @_;

+ $total_fn_hit, $total_br_found, $total_br_hit, $sort_type);

+ $testfnchash, $testbrhash, $view_type, $sort_type);

+ my $br_found;

+ my $br_hit;

+ my $total_br_found = 0;

+ my $total_br_hit = 0;

+ my $testbrdata;

+ my %testbrhash;

+ ($lines_found, $lines_hit, $fn_found, $fn_hit, $br_found,

+ $br_hit, $testdata, $testfncdata, $testbrdata) =

+ process_file($trunc_dir, $rel_dir, $filename);

+ $fn_hit, $br_found, $br_hit,

+ $page_link,

+ get_rate($fn_found, $fn_hit),

+ get_rate($br_found, $br_hit)];

+ $testbrhash{$base_name} = $testbrdata;

+

+ $total_br_found += $br_found;

+ $total_br_hit += $br_hit;

+ $total_br_found, $total_br_hit, \%overview, {},

+ {}, {}, 1, $_);

+ $total_fn_hit, $total_br_found, $total_br_hit,

+ \%overview, \%testhash, \%testfnchash,

+ \%testbrhash, 1, $_);

+ return ($overall_found, $overall_hit, $total_fn_found, $total_fn_hit,

+ $total_br_found, $total_br_hit);

+sub write_function_page($$$$$$$$$$$$$$$$$$)

+ $lines_found, $lines_hit, $fn_found, $fn_hit, $br_found, $br_hit,

+ $sumcount, $funcdata, $sumfnccount, $testfncdata, $sumbrcount,

+ $testbrdata, $sort_type) = @_;

+ $fn_found, $fn_hit, $br_found, $br_hit, $sort_type);

+ $sumfnccount, $testfncdata, $sumbrcount,

+ $testbrdata, $base_name,

+ my $testbrdata;

+ my $sumbrcount;

+ my $br_found;

+ my $br_hit;

+ $sumfnccount, $testbrdata, $sumbrcount, $lines_found, $lines_hit,

+ $fn_found, $fn_hit, $br_found, $br_hit)

+ return ($lines_found, $lines_hit, $fn_found, $fn_hit,

+ $br_found, $br_hit, $testdata, $testfncdata,

+ $testbrdata);

+ $fn_found, $fn_hit, $br_found, $br_hit, 0);

+ $converted, $funcdata, $sumbrcount);

+ $fn_found, $fn_hit, $br_found,

+ $br_hit, $sumcount,

+ $testfncdata, $sumbrcount,

+ $testbrdata, $_);

+ return ($lines_found, $lines_hit, $fn_found, $fn_hit,

+ $br_found, $br_hit, $testdata, $testfncdata,

+ $testbrdata);

+ return ($lines_found, $lines_hit, $fn_found, $fn_hit, $br_found,

+ $br_hit, $testdata, $testfncdata, $testbrdata);

+# "testbr" -> \%testbrdata

+# "sumbr" -> \%sumbrcount

+# %testbrdata: name of test affecting this file -> \%testbrcount

+# %testbrcount : line number -> branch coverage data for a single test

+# %sumbrcount : line number -> branch coverage data for all tests

+# $brdata : vector of items: block, branch, taken

+ my $testbrdata;

+ my $testbrcount;

+ my $sumbrcount;

+ my $br_found;

+ my $br_hit;

+ /^TN:([^,]*)(,diff)?/ && do

+ $testname .= $2 if (defined($2));

+ $testfncdata, $sumfnccount, $testbrdata,

+ $sumbrcount) =

+ $testbrcount = $testbrdata->{$testname};

+ $testbrcount = {};

+

+ /^BRDA:(\d+),(\d+),(\d+),(\d+|-)/ && do {

+ # Branch coverage data found

+ my ($line, $block, $branch, $taken) =

+ ($1, $2, $3, $4);

+

+ $sumbrcount->{$line} =

+ br_ivec_push($sumbrcount->{$line},

+ $block, $branch, $taken);

+

+ # Add test-specific counts

+ if (defined($testname)) {

+ $testbrcount->{$line} =

+ br_ivec_push(

+ $testbrcount->{$line},

+ $block, $branch,

+ $taken);

+ }

+ last;

+ };

+

+ $testbrdata->{$testname} =

+ $testbrcount;

+ $sumfnccount,

+ $testbrdata,

+ $sumbrcount);

+ $sumfnccount, $testbrdata, $sumbrcount) =

+ get_info_entry($data);

+

+ # Get found/hit values for branch data

+ ($br_found, $br_hit) = get_br_found_and_hit($sumbrcount);

+

+ $data->{"b_found"} = $br_found;

+ $data->{"b_hit"} = $br_hit;

+ my $testbrdata = $_[0]->{"testbr"};

+ my $sumbrcount = $_[0]->{"sumbr"};

+ my $br_found = $_[0]->{"b_found"};

+ my $br_hit = $_[0]->{"b_hit"};

+ $testfncdata, $sumfnccount, $testbrdata, $sumbrcount,

+ $lines_found, $lines_hit, $fn_found, $fn_hit,

+ $br_found, $br_hit);

+# checkdata_ref, testfncdata_ref, sumfcncount_ref,

+# testbrdata_ref, sumbrcount_ref[,lines_found,

+# lines_hit, f_found, f_hit, $b_found, $b_hit])

+sub set_info_entry($$$$$$$$$;$$$$$$)

+ $data_ref->{"testbr"} = $_[7];

+ $data_ref->{"sumbr"} = $_[8];

+

+ if (defined($_[9])) { $data_ref->{"found"} = $_[9]; }

+ if (defined($_[10])) { $data_ref->{"hit"} = $_[10]; }

+ if (defined($_[11])) { $data_ref->{"f_found"} = $_[11]; }

+ if (defined($_[12])) { $data_ref->{"f_hit"} = $_[12]; }

+ if (defined($_[13])) { $data_ref->{"b_found"} = $_[13]; }

+ if (defined($_[14])) { $data_ref->{"b_hit"} = $_[14]; }

+ if (defined($funcdata1)) {

+ %result = %{$funcdata1};

+ }

+ if (defined($fnccount1)) {

+ %result = %{$fnccount1};

+ }

+

+#

+# brcount_to_db(brcount)

+#

+# Convert brcount data to the following format:

+#

+# db: line number -> block hash

+# block hash: block number -> branch hash

+# branch hash: branch number -> taken value

+#

+

+sub brcount_to_db($)

+{

+ my ($brcount) = @_;

+ my $line;

+ my $db;

+

+ # Add branches from first count to database

+ foreach $line (keys(%{$brcount})) {

+ my $brdata = $brcount->{$line};

+ my $i;

+ my $num = br_ivec_len($brdata);

+

+ for ($i = 0; $i < $num; $i++) {

+ my ($block, $branch, $taken) = br_ivec_get($brdata, $i);

+

+ $db->{$line}->{$block}->{$branch} = $taken;

+ }

+ }

+

+ return $db;

+}

+

+

+#

+# db_to_brcount(db)

+#

+# Convert branch coverage data back to brcount format.

+#

+

+sub db_to_brcount($)

+{

+ my ($db) = @_;

+ my $line;

+ my $brcount = {};

+ my $br_found = 0;

+ my $br_hit = 0;

+

+ # Convert database back to brcount format

+ foreach $line (sort({$a <=> $b} keys(%{$db}))) {

+ my $ldata = $db->{$line};

+ my $brdata;

+ my $block;

+

+ foreach $block (sort({$a <=> $b} keys(%{$ldata}))) {

+ my $bdata = $ldata->{$block};

+ my $branch;

+

+ foreach $branch (sort({$a <=> $b} keys(%{$bdata}))) {

+ my $taken = $bdata->{$branch};

+

+ $br_found++;

+ $br_hit++ if ($taken ne "-" && $taken > 0);

+ $brdata = br_ivec_push($brdata, $block,

+ $branch, $taken);

+ }

+ }

+ $brcount->{$line} = $brdata;

+ }

+

+ return ($brcount, $br_found, $br_hit);

+}

+

+

+#

+# combine_brcount(brcount1, brcount2, type)

+#

+# If add is BR_ADD, add branch coverage data and return list (brcount_added,

+# br_found, br_hit). If add is BR_SUB, subtract the taken values of brcount2

+# from brcount1 and return (brcount_sub, br_found, br_hit).

+#

+

+sub combine_brcount($$$)

+{

+ my ($brcount1, $brcount2, $type) = @_;

+ my $line;

+ my $block;

+ my $branch;

+ my $taken;

+ my $db;

+ my $br_found = 0;

+ my $br_hit = 0;

+ my $result;

+

+ # Convert branches from first count to database

+ $db = brcount_to_db($brcount1);

+ # Combine values from database and second count

+ foreach $line (keys(%{$brcount2})) {

+ my $brdata = $brcount2->{$line};

+ my $num = br_ivec_len($brdata);

+ my $i;

+

+ for ($i = 0; $i < $num; $i++) {

+ ($block, $branch, $taken) = br_ivec_get($brdata, $i);

+ my $new_taken = $db->{$line}->{$block}->{$branch};

+

+ if ($type == $BR_ADD) {

+ $new_taken = br_taken_add($new_taken, $taken);

+ } elsif ($type == $BR_SUB) {

+ $new_taken = br_taken_sub($new_taken, $taken);

+ }

+ $db->{$line}->{$block}->{$branch} = $new_taken

+ if (defined($new_taken));

+ }

+ }

+ # Convert database back to brcount format

+ ($result, $br_found, $br_hit) = db_to_brcount($db);

+

+ return ($result, $br_found, $br_hit);

+}

+

+

+#

+# add_testbrdata(testbrdata1, testbrdata2)

+#

+# Add branch coverage data for several tests. Return reference to

+# added_testbrdata.

+#

+

+sub add_testbrdata($$)

+{

+ my ($testbrdata1, $testbrdata2) = @_;

+ my %result;

+ my $testname;

+

+ foreach $testname (keys(%{$testbrdata1})) {

+ if (defined($testbrdata2->{$testname})) {

+ my $brcount;

+

+ # Branch coverage data for this testname exists

+ # in both data sets: add

+ ($brcount) = combine_brcount($testbrdata1->{$testname},

+ $testbrdata2->{$testname}, $BR_ADD);

+ $result{$testname} = $brcount;

+ next;

+ }

+ # Branch coverage data for this testname is unique to

+ # data set 1: copy

+ $result{$testname} = $testbrdata1->{$testname};

+ }

+

+ # Add count data for testnames unique to data set 2

+ foreach $testname (keys(%{$testbrdata2})) {

+ if (!defined($result{$testname})) {

+ $result{$testname} = $testbrdata2->{$testname};

+ }

+ }

+ return \%result;

+}

+

+

+ my $testbrdata1;

+ my $sumbrcount1;

+ my $testbrdata2;

+ my $sumbrcount2;

+ my $result_testbrdata;

+ my $result_sumbrcount;

+ my $br_found;

+ my $br_hit;

+ $sumfnccount1, $testbrdata1, $sumbrcount1) = get_info_entry($entry1);

+ $sumfnccount2, $testbrdata2, $sumbrcount2) = get_info_entry($entry2);

+ # Combine branch coverage data

+ $result_testbrdata = add_testbrdata($testbrdata1, $testbrdata2);

+ ($result_sumbrcount, $br_found, $br_hit) =

+ combine_brcount($sumbrcount1, $sumbrcount2, $BR_ADD);

+

+ $result_sumfnccount, $result_testbrdata,

+ $result_sumbrcount, $lines_found, $lines_hit,

+ $fn_found, $fn_hit, $br_found, $br_hit);

+ my ($dir) = @_;

+

+ system("mkdir", "-p" ,$dir)

+ and die("ERROR: cannot create directory $dir!\n");

+# total_fn_found, total_fn_hit, total_br_found,

+# total_br_hit)

+sub write_description_file($$$$$$$)

+ my $br_found = $_[5];

+ my $br_hit = $_[6];

+ $fn_hit, $br_found, $br_hit, 0);

+ font-family: sans-serif;

+ font-family: sans-serif;

+ font-family: sans-serif;

+ font-family: sans-serif;

+ font-family: sans-serif;

+ font-family: sans-serif;

+ font-size:80%;

+ font-size:80%;

+ font-size:80%;

+ font-family: sans-serif;

+ font-family: sans-serif;

+ font-family: sans-serif;

+ font-family: sans-serif;

+ font-family: sans-serif;

+ margin-top: 2px;

+ background-color: #FF6230;

+ /* Source code view: format for branches which were executed

+ * and taken */

+ span.branchCov

+ {

+ background-color: #CAD7FE;

+ }

+

+ /* Source code view: format for branches which were executed

+ * but not taken */

+ span.branchNoCov

+ {

+ background-color: #FF6230;

+ }

+

+ /* Source code view: format for branches which were not executed */

+ span.branchNoExec

+ {

+ background-color: #FF6230;

+ }

+

+ /* Source code view: format for the source code heading line */

+ pre.sourceHeading

+ {

+ white-space: pre;

+ font-family: monospace;

+ font-weight: bold;

+ margin: 0px;

+ }

+

+ /* All views: header legend value for low rate */

+ td.headerValueLegL

+ {

+ font-family: sans-serif;

+ text-align: center;

+ white-space: nowrap;

+ padding-left: 4px;

+ padding-right: 2px;

+ background-color: #FF0000;

+ font-size: 80%;

+ }

+

+ /* All views: header legend value for med rate */

+ td.headerValueLegM

+ {

+ font-family: sans-serif;

+ text-align: center;

+ white-space: nowrap;

+ padding-left: 2px;

+ padding-right: 2px;

+ background-color: #FFEA20;

+ font-size: 80%;

+ }

+

+ /* All views: header legend value for hi rate */

+ td.headerValueLegH

+ font-family: sans-serif;

+ white-space: nowrap;

+ padding-left: 2px;

+ padding-right: 4px;

+ background-color: #A7FC9D;

+ font-size: 80%;

+ }

+

+ /* All views except source code view: legend format for low coverage */

+ span.coverLegendCovLo

+ {

+ padding-top: 2px;

+ background-color: #FF0000;

+ }

+

+ /* All views except source code view: legend format for med coverage */

+ span.coverLegendCovMed

+ {

+ padding-left: 10px;

+ padding-right: 10px;

+ padding-top: 2px;

+ background-color: #FFEA20;

+ }

+

+ /* All views except source code view: legend format for hi coverage */

+ span.coverLegendCovHi

+ {

+ padding-left: 10px;

+ padding-right: 10px;

+ padding-top: 2px;

+ background-color: #A7FC9D;

+# write_header_line(handle, content)

+# Write a header line with the specified table contents.

+sub write_header_line(*@)

+ my ($handle, @content) = @_;

+ my $entry;

+ write_html($handle, " <tr>\n");

+ foreach $entry (@content) {

+ my ($width, $class, $text, $colspan) = @{$entry};

+ if (defined($width)) {

+ $width = " width=\"$width\"";

+ } else {

+ $width = "";

+ }

+ if (defined($class)) {

+ $class = " class=\"$class\"";

+ } else {

+ $class = "";

+ }

+ if (defined($colspan)) {

+ $colspan = " colspan=\"$colspan\"";

+ } else {

+ $colspan = "";

+ }

+ $text = "" if (!defined($text));

+ write_html($handle,

+ " <td$width$class$colspan>$text</td>\n");

+ }

+ write_html($handle, " </tr>\n");

+ <tr><td><img src="$_[1]glass.png" width=3 height=3 alt=""></td></tr>

+

+# write_file_table_prolog(handle, file_heading, ([heading, num_cols], ...))

+sub write_file_table_prolog(*$@)

+ my ($handle, $file_heading, @columns) = @_;

+ my $num_columns = 0;

+ my $file_width;

+ my $col;

+ my $width;

+ $width = 20 if (scalar(@columns) == 1);

+ $width = 10 if (scalar(@columns) == 2);

+ $width = 8 if (scalar(@columns) > 2);

+ foreach $col (@columns) {

+ my ($heading, $cols) = @{$col};

+ $num_columns += $cols;

+ }

+ $file_width = 100 - $num_columns * $width;

+ # Table definition

+ write_html($handle, <<END_OF_HTML);

+ <td width="$file_width%"><br></td>

+END_OF_HTML

+ # Empty first row

+ foreach $col (@columns) {

+ my ($heading, $cols) = @{$col};

+

+ while ($cols-- > 0) {

+ write_html($handle, <<END_OF_HTML);

+ <td width="$width%"></td>

+END_OF_HTML

+ }

+ }

+ # Next row

+ write_html($handle, <<END_OF_HTML);

+ <td class="tableHead">$file_heading</td>

+END_OF_HTML

+ # Heading row

+ foreach $col (@columns) {

+ my ($heading, $cols) = @{$col};

+ my $colspan = "";

+

+ $colspan = " colspan=$cols" if ($cols > 1);

+ write_html($handle, <<END_OF_HTML);

+ <td class="tableHead"$colspan>$heading</td>

+END_OF_HTML

+ }

+ write_html($handle, <<END_OF_HTML);

+# write_file_table_entry(handle, base_dir, filename, page_link,

+# ([ found, hit, med_limit, hi_limit, graph ], ..)

+sub write_file_table_entry(*$$$@)

+ my ($handle, $base_dir, $filename, $page_link, @entries) = @_;

+ my $entry;

+ # First column: filename

+ write_html($handle, <<END_OF_HTML);

+END_OF_HTML

+ # Columns as defined

+ foreach $entry (@entries) {

+ my ($found, $hit, $med, $hi, $graph) = @{$entry};

+ my $bar_graph;

+ my $class;

+ my $rate;

+

+ # Generate bar graph if requested

+ if ($graph) {

+ $bar_graph = get_bar_graph_code($base_dir, $found,

+ $hit);

+ write_html($handle, <<END_OF_HTML);

+ }

+ # Get rate color and text

+ if ($found == 0) {

+ $rate = "-";

+ $class = "Hi";

+ } else {

+ $rate = sprintf("%.1f&nbsp;%%", $hit * 100 / $found);

+ $class = $rate_name[classify_rate($found, $hit,

+ $med, $hi)];

+ }

+ write_html($handle, <<END_OF_HTML);

+ <td class="coverPer$class">$rate</td>

+ <td class="coverNum$class">$hit / $found</td>

+ }

+ # End of row

+ write_html($handle, <<END_OF_HTML);

+# write_file_table_detail_entry(filehandle, test_name, ([found, hit], ...))

+sub write_file_table_detail_entry(*$@)

+ my ($handle, $test, @entries) = @_;

+ my $entry;

+ if ($test eq "") {

+ $test = "<span style=\"font-style:italic\">&lt;unnamed&gt;</span>";

+ } elsif ($test =~ /^(.*),diff$/) {

+ $test = $1." (converted)";

+ # Testname

+ write_html($handle, <<END_OF_HTML);

+ <td class="testName" colspan=2>$test</td>

+ # Test data

+ foreach $entry (@entries) {

+ my ($found, $hit) = @{$entry};

+ my $rate = "-";

+

+ if ($found > 0) {

+ $rate = sprintf("%.1f&nbsp;%%", $hit * 100 / $found);

+ }

+ write_html($handle, <<END_OF_HTML);

+ <td class="testPer">$rate</td>

+ <td class="testNum">$hit&nbsp;/&nbsp;$found</td>

+ }

+

+ write_html($handle, <<END_OF_HTML);

+sub fmt_centered($$)

+{

+ my ($width, $text) = @_;

+ my $w0 = length($text);

+ my $w1 = int(($width - $w0) / 2);

+ my $w2 = $width - $w0 - $w1;

+

+ return (" "x$w1).$text.(" "x$w2);

+}

+

+

+ my $lineno_heading = " ";

+ my $branch_heading = "";

+ my $line_heading = fmt_centered($line_field_width, "Line data");

+ my $source_heading = " Source code";

+

+ if ($br_coverage) {

+ $branch_heading = fmt_centered($br_field_width, "Branch data").

+ " ";

+ }

+ <td>

+<pre class="sourceHeading">${lineno_heading}${branch_heading}${line_heading} ${source_heading}</pre>

+<pre class="source">

+# get_branch_blocks(brdata)

+#

+# Group branches that belong to the same basic block.

+#

+# Returns: [block1, block2, ...]

+# block: [branch1, branch2, ...]

+# branch: [block_num, branch_num, taken_count, text_length, open, close]

+#

+

+sub get_branch_blocks($)

+{

+ my ($brdata) = @_;

+ my $last_block_num;

+ my $block = [];

+ my @blocks;

+ my $i;

+ my $num = br_ivec_len($brdata);

+

+ # Group branches

+ for ($i = 0; $i < $num; $i++) {

+ my ($block_num, $branch, $taken) = br_ivec_get($brdata, $i);

+ my $br;

+

+ if (defined($last_block_num) && $block_num != $last_block_num) {

+ push(@blocks, $block);

+ $block = [];

+ }

+ $br = [$block_num, $branch, $taken, 3, 0, 0];

+ push(@{$block}, $br);

+ $last_block_num = $block_num;

+ }

+ push(@blocks, $block) if (scalar(@{$block}) > 0);

+

+ # Add braces to first and last branch in group

+ foreach $block (@blocks) {

+ $block->[0]->[$BR_OPEN] = 1;

+ $block->[0]->[$BR_LEN]++;

+ $block->[scalar(@{$block}) - 1]->[$BR_CLOSE] = 1;

+ $block->[scalar(@{$block}) - 1]->[$BR_LEN]++;

+ }

+

+ return @blocks;

+}

+

+#

+# get_block_len(block)

+#

+# Calculate total text length of all branches in a block of branches.

+#

+

+sub get_block_len($)

+{

+ my ($block) = @_;

+ my $len = 0;

+ my $branch;

+

+ foreach $branch (@{$block}) {

+ $len += $branch->[$BR_LEN];

+ }

+

+ return $len;

+}

+

+

+#

+# get_branch_html(brdata)

+#

+# Return a list of HTML lines which represent the specified branch coverage

+# data in source code view.

+#

+

+sub get_branch_html($)

+{

+ my ($brdata) = @_;

+ my @blocks = get_branch_blocks($brdata);

+ my $block;

+ my $branch;

+ my $line_len = 0;

+ my $line = []; # [branch2|" ", branch|" ", ...]

+ my @lines; # [line1, line2, ...]

+ my @result;

+

+ # Distribute blocks to lines

+ foreach $block (@blocks) {

+ my $block_len = get_block_len($block);

+

+ # Does this block fit into the current line?

+ if ($line_len + $block_len <= $br_field_width) {

+ # Add it

+ $line_len += $block_len;

+ push(@{$line}, @{$block});

+ next;

+ } elsif ($block_len <= $br_field_width) {

+ # It would fit if the line was empty - add it to new

+ # line

+ push(@lines, $line);

+ $line_len = $block_len;

+ $line = [ @{$block} ];

+ next;

+ }

+ # Split the block into several lines

+ foreach $branch (@{$block}) {

+ if ($line_len + $branch->[$BR_LEN] >= $br_field_width) {

+ # Start a new line

+ if (($line_len + 1 <= $br_field_width) &&

+ scalar(@{$line}) > 0 &&

+ !$line->[scalar(@$line) - 1]->[$BR_CLOSE]) {

+ # Try to align branch symbols to be in

+ # one # row

+ push(@{$line}, " ");

+ }

+ push(@lines, $line);

+ $line_len = 0;

+ $line = [];

+ }

+ push(@{$line}, $branch);

+ $line_len += $branch->[$BR_LEN];

+ }

+ }

+ push(@lines, $line);

+

+ # Convert to HTML

+ foreach $line (@lines) {

+ my $current = "";

+ my $current_len = 0;

+

+ foreach $branch (@$line) {

+ # Skip alignment space

+ if ($branch eq " ") {

+ $current .= " ";

+ $current_len++;

+ next;

+ }

+

+ my ($block_num, $br_num, $taken, $len, $open, $close) =

+ @{$branch};

+ my $class;

+ my $title;

+ my $text;

+

+ if ($taken eq '-') {

+ $class = "branchNoExec";

+ $text = " # ";

+ $title = "Branch $br_num was not executed";

+ } elsif ($taken == 0) {

+ $class = "branchNoCov";

+ $text = " - ";

+ $title = "Branch $br_num was not taken";

+ } else {

+ $class = "branchCov";

+ $text = " + ";

+ $title = "Branch $br_num was taken $taken ".

+ "time";

+ $title .= "s" if ($taken > 1);

+ }

+ $current .= "[" if ($open);

+ $current .= "<span class=\"$class\" title=\"$title\">";

+ $current .= $text."</span>";

+ $current .= "]" if ($close);

+ $current_len += $len;

+ }

+

+ # Right-align result text

+ if ($current_len < $br_field_width) {

+ $current = (" "x($br_field_width - $current_len)).

+ $current;

+ }

+ push(@result, $current);

+ }

+

+ return @result;

+}

+

+

+#

+# format_count(count, width)

+#

+# Return a right-aligned representation of count that fits in width characters.

+#

+

+sub format_count($$)

+{

+ my ($count, $width) = @_;

+ my $result;

+ my $exp;

+

+ $result = sprintf("%*.0f", $width, $count);

+ while (length($result) > $width) {

+ last if ($count < 10);

+ $exp++;

+ $count = int($count/10);

+ $result = sprintf("%*s", $width, ">$count*10^$exp");

+ }

+ return $result;

+}

+

+#

+# brdata, add_anchor)

+sub write_source_line(*$$$$$$)

+ my ($handle, $line, $source, $count, $converted, $brdata,

+ $add_anchor) = @_;

+ my $count_format;

+ my $count_field_width = $line_field_width - 1;

+ my @br_html;

+ my $html;

+ # Get branch HTML data for this line

+ @br_html = get_branch_html($brdata) if ($br_coverage);

+

+ if (!defined($count)) {

+ $count_format = " "x$count_field_width;

+ elsif ($count == 0) {

+ $result = $count;

+ $count_format = format_count($count, $count_field_width);

+ elsif ($converted && defined($highlight)) {

+ $result = "*".$count;

+ $count_format = format_count($count, $count_field_width);

+ else {

+ $result = $count;

+ $count_format = format_count($count, $count_field_width);

+ $result .= ":".$source;

+ if ($add_anchor)

+ $html = $anchor_start;

+ $html .= "<span class=\"lineNum\">".sprintf("%8d", $line)." </span>";

+ $html .= shift(@br_html).":" if ($br_coverage);

+ $html .= "$source_format$count_format : ";

+ $html .= escape_html($source);

+ $html .= "</span>" if ($source_format);

+ $html .= $anchor_end."\n";

+

+ write_html($handle, $html);

+

+ if ($br_coverage) {

+ # Add lines for overlong branch information

+ foreach (@br_html) {

+ write_html($handle, "<span class=\"lineNum\">".

+ " </span>$_\n");

+ }

+ }

+ <tr><td class="ruler"><img src="$_[1]glass.png" width=3 height=3 alt=""></td></tr>

+ <tr><td class="versionInfo">Generated by: <a href="$lcov_url"$break_code>$lcov_version</a></td></tr>

+

+sub max($$)

+ my ($a, $b) = @_;

+ return $a if ($a > $b);

+ return $b;

+

+sub write_header(*$$$$$$$$$$)

+ my $br_found = $_[8];

+ my $br_hit = $_[9];

+ my $sort_type = $_[10];

+ my $style;

+ my $rate;

+ my @row_left;

+ my @row_right;

+ my $num_rows;

+ my $i;

+ if ($type == $HDR_DIR)

+ elsif ($type == $HDR_FILE)

+ elsif ($type == $HDR_SOURCE || $type == $HDR_FUNC)

+ $view .= "<span style=\"font-size: 80%;\">";

+ if ($type == $HDR_SOURCE) {

+ } elsif ($type == $HDR_FUNC) {

+ $view .= "</span>";

+ elsif ($type == $HDR_TESTDESC)

+ if (%test_description && ($type != $HDR_TESTDESC))

+ if ($frames && ($type == $HDR_SOURCE || $type == $HDR_FUNC))

+ $test .= " ( <span style=\"font-size:80%;\">".

+ "<a href=\"$base_dir".

+ "view descriptions</a></span> )";

+ $test .= " ( <span style=\"font-size:80%;\">".

+ "<a href=\"$base_dir".

+ "view descriptions</a></span> )";

+

+ # Left row

+ push(@row_left, [[ "10%", "headerItem", "Current view:" ],

+ [ "35%", "headerValue", $view ]]);

+ push(@row_left, [[undef, "headerItem", "Test:"],

+ [undef, "headerValue", $test]]);

+ push(@row_left, [[undef, "headerItem", "Date:"],

+ [undef, "headerValue", $date]]);

+

+ # Right row

+ if ($legend && ($type == $HDR_SOURCE || $type == $HDR_FUNC)) {

+ my $text = <<END_OF_HTML;

+ Lines:

+ <span class="coverLegendCov">hit</span>

+ <span class="coverLegendNoCov">not hit</span>

+END_OF_HTML

+ if ($br_coverage) {

+ $text .= <<END_OF_HTML;

+ | Branches:

+ <span class="coverLegendCov">+</span> taken

+ <span class="coverLegendNoCov">-</span> not taken

+ <span class="coverLegendNoCov">#</span> not executed

+END_OF_HTML

+ }

+ push(@row_left, [[undef, "headerItem", "Legend:"],

+ [undef, "headerValueLeg", $text]]);

+ } elsif ($legend && ($type != $HDR_TESTDESC)) {

+ my $text = <<END_OF_HTML;

+ Rating:

+ <span class="coverLegendCovLo" title="Coverage rates below $med_limit % are classified as low">low: &lt; $med_limit %</span>

+ <span class="coverLegendCovMed" title="Coverage rates between $med_limit % and $hi_limit % are classified as medium">medium: &gt;= $med_limit %</span>

+ <span class="coverLegendCovHi" title="Coverage rates of $hi_limit % and more are classified as high">high: &gt;= $hi_limit %</span>

+END_OF_HTML

+ push(@row_left, [[undef, "headerItem", "Legend:"],

+ [undef, "headerValueLeg", $text]]);

+ }

+ if ($type == $HDR_TESTDESC) {

+ push(@row_right, [[ "55%" ]]);

+ push(@row_right, [["15%", undef, undef ],

+ ["10%", "headerCovTableHead", "Hit" ],

+ ["10%", "headerCovTableHead", "Total" ],

+ ["15%", "headerCovTableHead", "Coverage"]]);

+ }

+ # Line coverage

+ $style = $rate_name[classify_rate($lines_found, $lines_hit,

+ $med_limit, $hi_limit)];

+ $rate = format_rate($lines_found, $lines_hit);

+ push(@row_right, [[undef, "headerItem", "Lines:"],

+ [undef, "headerCovTableEntry", $lines_hit],

+ [undef, "headerCovTableEntry", $lines_found],

+ [undef, "headerCovTableEntry$style", $rate]])

+ if ($type != $HDR_TESTDESC);

+ # Function coverage

+ if ($func_coverage) {

+ $style = $rate_name[classify_rate($fn_found, $fn_hit,

+ $fn_med_limit, $fn_hi_limit)];

+ $rate = format_rate($fn_found, $fn_hit);

+ push(@row_right, [[undef, "headerItem", "Functions:"],

+ [undef, "headerCovTableEntry", $fn_hit],

+ [undef, "headerCovTableEntry", $fn_found],

+ [undef, "headerCovTableEntry$style", $rate]])

+ if ($type != $HDR_TESTDESC);

+ }

+ # Branch coverage

+ if ($br_coverage) {

+ $style = $rate_name[classify_rate($br_found, $br_hit,

+ $br_med_limit, $br_hi_limit)];

+ $rate = format_rate($br_found, $br_hit);

+ push(@row_right, [[undef, "headerItem", "Branches:"],

+ [undef, "headerCovTableEntry", $br_hit],

+ [undef, "headerCovTableEntry", $br_found],

+ [undef, "headerCovTableEntry$style", $rate]])

+ if ($type != $HDR_TESTDESC);

+ }

+

+ # Print rows

+ $num_rows = max(scalar(@row_left), scalar(@row_right));

+ for ($i = 0; $i < $num_rows; $i++) {

+ my $left = $row_left[$i];

+ my $right = $row_right[$i];

+

+ if (!defined($left)) {

+ $left = [[undef, undef, undef], [undef, undef, undef]];

+ }

+ if (!defined($right)) {

+ $right = [];

+ write_header_line(*HTML_HANDLE, @{$left},

+ [ $i == 0 ? "5%" : undef, undef, undef],

+ @{$right});

+

+ # Fourth line

+ if ($type == $SORT_FILE) {

+ } elsif ($type == $SORT_LINE) {

+ return sort({$hash->{$a}[7] <=> $hash->{$b}[7]} keys(%{$hash}));

+ } elsif ($type == $SORT_FUNC) {

+ return sort({$hash->{$a}[8] <=> $hash->{$b}[8]} keys(%{$hash}));

+ } elsif ($type == $SORT_BRANCH) {

+ # Sort by br coverage;

+ return sort({$hash->{$a}[9] <=> $hash->{$b}[9]} keys(%{$hash}));

+ if ($type == $HEAD_NO_DETAIL) {

+ if ($type == $HEAD_NO_DETAIL) {

+ } elsif ($type == $HEAD_DETAIL_HIDDEN) {

+ if ($type == $HEAD_NO_DETAIL) {

+sub get_br_code($$$$)

+{

+ my ($type, $text, $sort_button, $base) = @_;

+ my $result = $text;

+ my $link;

+

+ if ($sort_button) {

+ if ($type == $HEAD_NO_DETAIL) {

+ $link = "index-sort-b.$html_ext";

+ } else {

+ $link = "index-detail-sort-b.$html_ext";

+ }

+ }

+ $result .= get_sort_code($link, "Sort by branch coverage", $base);

+ return $result;

+}

+

+# testbrhash, fileview, sort_type)

+sub write_file_table(*$$$$$$$)

+ my $testbrhash = $_[5];

+ my $fileview = $_[6];

+ my $sort_type = $_[7];

+ my $br_found;

+ my $br_hit;

+ my $testbrdata;

+ my $br_code;

+ my @head_columns;

+ $file_code = get_file_code($detailed ? $HEAD_DETAIL_HIDDEN :

+ $HEAD_NO_DETAIL,

+ $sort && $sort_type != $SORT_FILE,

+ $base_dir);

+ $line_code = get_line_code($detailed ? $HEAD_DETAIL_SHOWN :

+ $HEAD_DETAIL_HIDDEN,

+ $sort_type,

+ $sort && $sort_type != $SORT_LINE,

+ $base_dir);

+ $func_code = get_func_code($detailed ? $HEAD_DETAIL_HIDDEN :

+ $HEAD_NO_DETAIL,

+ "Functions",

+ $sort && $sort_type != $SORT_FUNC,

+ $base_dir);

+ $br_code = get_br_code($detailed ? $HEAD_DETAIL_HIDDEN :

+ $HEAD_NO_DETAIL,

+ "Branches",

+ $sort && $sort_type != $SORT_BRANCH,

+ $base_dir);

+ $file_code = get_file_code($HEAD_NO_DETAIL,

+ $sort && $sort_type != $SORT_FILE,

+ $base_dir);

+ $line_code = get_line_code($HEAD_NO_DETAIL, $sort_type, "Line Coverage",

+ $sort && $sort_type != $SORT_LINE,

+ $base_dir);

+ $func_code = get_func_code($HEAD_NO_DETAIL, "Functions",

+ $sort && $sort_type != $SORT_FUNC,

+ $base_dir);

+ $br_code = get_br_code($HEAD_NO_DETAIL, "Branches",

+ $sort && $sort_type != $SORT_BRANCH,

+ $base_dir);

+ }

+ push(@head_columns, [ $line_code, 3 ]);

+ push(@head_columns, [ $func_code, 2]) if ($func_coverage);

+ push(@head_columns, [ $br_code, 2]) if ($br_coverage);

+

+ write_file_table_prolog(*HTML_HANDLE, $file_code, @head_columns);

+ my @columns;

+ ($found, $hit, $fn_found, $fn_hit, $br_found, $br_hit,

+ $page_link) = @{$overview->{$filename}};

+

+ # Line coverage

+ push(@columns, [$found, $hit, $med_limit, $hi_limit, 1]);

+ # Function coverage

+ if ($func_coverage) {

+ push(@columns, [$fn_found, $fn_hit, $fn_med_limit,

+ $fn_hi_limit, 0]);

+ }

+ # Branch coverage

+ if ($br_coverage) {

+ push(@columns, [$br_found, $br_hit, $br_med_limit,

+ $br_hi_limit, 0]);

+ }

+ write_file_table_entry(*HTML_HANDLE, $base_dir, $filename,

+ $page_link, @columns);

+ $testbrdata = $testbrhash->{$filename};

+ $testfncdata, $testbrdata) };

+ my @results;

+ ($found, $hit, $fn_found, $fn_hit, $br_found, $br_hit) =

+ push(@results, [$found, $hit]);

+ push(@results, [$fn_found, $fn_hit]) if ($func_coverage);

+ push(@results, [$br_found, $br_hit]) if ($br_coverage);

+ @results);

+# br_taken_to_num(taken)

+#

+# Convert a branch taken value .info format to number format.

+#

+

+sub br_taken_to_num($)

+{

+ my ($taken) = @_;

+

+ return 0 if ($taken eq '-');

+ return $taken + 1;

+}

+

+

+#

+# br_num_to_taken(taken)

+#

+# Convert a branch taken value in number format to .info format.

+#

+

+sub br_num_to_taken($)

+{

+ my ($taken) = @_;

+

+ return '-' if ($taken == 0);

+ return $taken - 1;

+}

+

+

+#

+# br_taken_add(taken1, taken2)

+#

+# Return the result of taken1 + taken2 for 'branch taken' values.

+#

+

+sub br_taken_add($$)

+{

+ my ($t1, $t2) = @_;

+

+ return $t1 if (!defined($t2));

+ return $t2 if (!defined($t1));

+ return $t1 if ($t2 eq '-');

+ return $t2 if ($t1 eq '-');

+ return $t1 + $t2;

+}

+

+

+#

+# br_taken_sub(taken1, taken2)

+#

+# Return the result of taken1 - taken2 for 'branch taken' values. Return 0

+# if the result would become negative.

+#

+

+sub br_taken_sub($$)

+{

+ my ($t1, $t2) = @_;

+

+ return $t1 if (!defined($t2));

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

+ return $t1 if ($t1 eq '-');

+ return $t1 if ($t2 eq '-');

+ return 0 if $t2 > $t1;

+ return $t1 - $t2;

+}

+

+

+#

+# br_ivec_len(vector)

+#

+# Return the number of entries in the branch coverage vector.

+#

+

+sub br_ivec_len($)

+{

+ my ($vec) = @_;

+

+ return 0 if (!defined($vec));

+ return (length($vec) * 8 / $BR_VEC_WIDTH) / $BR_VEC_ENTRIES;

+}

+

+

+#

+# br_ivec_get(vector, number)

+#

+# Return an entry from the branch coverage vector.

+#

+

+sub br_ivec_get($$)

+{

+ my ($vec, $num) = @_;

+ my $block;

+ my $branch;

+ my $taken;

+ my $offset = $num * $BR_VEC_ENTRIES;

+

+ # Retrieve data from vector

+ $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

+ $taken = br_num_to_taken($taken);

+

+ return ($block, $branch, $taken);

+}

+

+

+#

+# br_ivec_push(vector, block, branch, taken)

+#

+# Add an entry to the branch coverage vector. If an entry with the same

+# branch ID already exists, add the corresponding taken values.

+#

+

+sub br_ivec_push($$$$)

+{

+ my ($vec, $block, $branch, $taken) = @_;

+ my $offset;

+ my $num = br_ivec_len($vec);

+ my $i;

+

+ $vec = "" if (!defined($vec));

+

+ # Check if branch already exists in vector

+ for ($i = 0; $i < $num; $i++) {

+ my ($v_block, $v_branch, $v_taken) = br_ivec_get($vec, $i);

+

+ next if ($v_block != $block || $v_branch != $branch);

+

+ # Add taken counts

+ $taken = br_taken_add($taken, $v_taken);

+ last;

+ }

+

+ $offset = $i * $BR_VEC_ENTRIES;

+ $taken = br_taken_to_num($taken);

+

+ # Add to vector

+ 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;

+}

+

+

+#

+# get_br_found_and_hit(sumbrcount)

+#

+# Return (br_found, br_hit) for sumbrcount

+#

+

+sub get_br_found_and_hit($)

+{

+ my ($sumbrcount) = @_;

+ my $line;

+ my $br_found = 0;

+ my $br_hit = 0;

+

+ foreach $line (keys(%{$sumbrcount})) {

+ my $brdata = $sumbrcount->{$line};

+ my $i;

+ my $num = br_ivec_len($brdata);

+

+ for ($i = 0; $i < $num; $i++) {

+ my $taken;

+

+ (undef, undef, $taken) = br_ivec_get($brdata, $i);

+

+ $br_found++;

+ $br_hit++ if ($taken ne "-" && $taken > 0);

+ }

+ }

+

+ return ($br_found, $br_hit);

+}

+

+

+#

+# get_affecting_tests(testdata, testfncdata, testbrdata)

+sub get_affecting_tests($$$)

+ my ($testdata, $testfncdata, $testbrdata) = @_;

+ my $testbrcount;

+ my $br_found;

+ my $br_hit;

+ $testbrcount = $testbrdata->{$testname};

+ ($br_found, $br_hit) = get_br_found_and_hit($testbrcount);

+ $result{$testname} = "$found,$hit,$fn_found,$fn_hit,".

+ "$br_found,$br_hit";

+# converted_data, func_data, sumbrcount)

+sub write_source($$$$$$$)

+ my $sumbrcount = $_[6];

+ # Also remove CR from line-end

+ s/\015$//;

+

+ $sumbrcount->{$line_number}, $add_anchor));

+# sumfnccount, testfncdata, sumbrcount, testbrdata,

+# base_name, base_dir, sort_type)

+sub write_function_table(*$$$$$$$$$$)

+ my $sumbrcount = $_[6];

+ my $testbrdata = $_[7];

+ my $name = $_[8];

+ my $base = $_[9];

+ my $type = $_[10];

+ if (!defined($funcdata->{$func}))

+ {

+ next;

+ }

+

+ my $name = $func;

+ # Demangle C++ function names if requested

+ if ($demangle_cpp) {

+ $name = `c++filt "$name"`;

+ chomp($name);

+ }

+ # Escape any remaining special characters

+ $name = escape_html($name);

+ my %data;

+ my %base;

+ %data = %{$_[0]} if (defined($_[0]));

+ %base = %{$_[1]} if (defined($_[1]));

+ my $data_testbrdata;

+ my $data_testbrcount;

+ my $base_sumbrcount;

+ my $sumbrcount;

+ my $br_found;

+ my $br_hit;

+ $data_testfncdata, undef, $data_testbrdata) =

+ get_info_entry($data);

+ $base_sumfnccount, undef, $base_sumbrcount) =

+ get_info_entry($base);

+ $sumbrcount = {};

+ $data_testbrcount = $data_testbrdata->{$testname};

+ ($data_testbrcount) =

+ combine_brcount($data_testbrcount,

+ $base_sumbrcount, $BR_SUB);

+

+ $data_testbrdata->{$testname} =

+ $data_testbrcount;

+ delete($data_testbrdata->{$testname});

+ add_fnccount($sumfnccount, $data_testfnccount);

+ ($sumbrcount, $br_found, $br_hit) =

+ combine_brcount($sumbrcount, $data_testbrcount,

+ $BR_ADD);

+ $data_testbrdata, $sumbrcount, $found, $hit,

+ $fn_found, $fn_hit, $br_found, $br_hit);

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

+use File::Spec::Functions qw /abs2rel catdir file_name_is_absolute splitdir

+ splitpath/;

+our $lcov_version = 'LCOV version 1.9';

+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;

+sub process_dafile($$);

+sub get_exclusion_data($);

+sub apply_exclusion_data($$);

+sub process_graphfile($$);

+sub filter_fn_name($);

+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();

+

+our $no_markers = 0;

+our $opt_derive_func_data = 0;

+our $debug = 0;

+our $gcov_caps;

+our @gcov_options;

+# 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";

+

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

+if (!GetOptions("test-name|t=s" => \$test_name,

+ "output-filename|o=s" => \$output_filename,

+ "base-directory|b=s" => \$base_directory,

+ "version|v" =>\$version,

+ "quiet|q" => \$quiet,

+ "help|h|?" => \$help,

+ "follow|f" => \$follow,

+ "no-markers" => \$no_markers,

+ "derive-func-data" => \$opt_derive_func_data,

+ "debug" => \$debug,

+ /^graph$/ && do { $ignore[$ERROR_GRAPH] = 1; next; };

+# 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'});

+foreach my $entry (@data_directory) {

+ gen_info($entry);

+

+if ($initial) {

+ warn("Note: --initial does not generate branch coverage ".

+ "data\n");

+ --ignore-errors ERROR Continue after ERROR (gcov, source, graph)

+ --no-recursion Exclude subdirectories from processing

+ --no-markers Ignore exclusion markers in source code

+ --derive-func-data Generate function data from line data

+#

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

+}

+ my $file;

+ my $prefix;

+ my $type;

+ my $ext;

+

+ if ($initial) {

+ $type = "graph";

+ $ext = $graph_file_extension;

+ } else {

+ $type = "data";

+ $ext = $data_file_extension;

+ }

+ info("Scanning $directory for $ext files ...\n");

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

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

+ $prefix = "";

+ 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.

+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 $bb_basename; # Basename of the original graph file

+ my $graph; # Contents of graph file

+ my $instr; # Contents of graph file part 2

+ my $gcov_branches; # Branch content of a .gcov file

+ my $br_hit;

+ my $br_found;

+ my @tmp_links; # Temporary links to be cleaned up

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

+ $da_filename = solve_relative_path($cwd, $file);

+ $bb_basename = $da_basename.$graph_file_extension;

+ $bb_filename = "$da_dir/$bb_basename";

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

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

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

+ 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");

+ }

+ $gcov_error = system_no_output(1, $gcov_tool, $da_filename,

+ "-o", $object_dir, @gcov_options);

+ # Clean up temporary links

+ foreach (@tmp_links) {

+ unlink($_);

+ @gcov_list = get_filenames('.', '\.gcov$');

+ @unprocessed = keys(%{$instr});

+ foreach $gcov_file (sort(@gcov_list))

+ my $i;

+ my $num;

+

+ $gcov_file, keys(%{$instr}));

+ if (!defined($result[0])) {

+ warn("WARNING: skipping unreadable file ".

+ $gcov_file."\n");

+ unlink($gcov_file);

+ next;

+ }

+ $gcov_branches = $result[1];

+ # 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});

+ }

+

+ 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

+ # 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;

+ }

+ }

+ $fn = filter_fn_name($fn);

+ 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);

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

+ }

+

+ my ($filename, @list) = @_;

+ my ($vol, $dir, $file) = splitpath($filename);

+ my @comp = splitdir($dir);

+ my $comps = scalar(@comp);

+ my $entry;

+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),

+

+ # Also remove CR from line-end

+ s/\015$//;

+

+ # Also remove CR from line-end

+ s/\015$//;

+

+# 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;

+}

+

+

+#

+# gcov_branch is a vector of 4 4-byte long elements for each branch:

+# line number, block number, branch number, count + 1 or 0

+ my $branches = "";

+ my $exclude_flag = 0;

+ my $exclude_line = 0;

+ my $last_block = $UNNAMED_BLOCK;

+ my $last_line = 0;

+ 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");

+ }

+ # 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, '-');

+ $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;

+ }

+ }

+ if (/^\t\t(.*)$/)

+ {

+ # Uninstrumented line

+ push(@result, 0);

+ push(@result, 0);

+ push(@result, $1);

+ next;

+ }

+ if ($exclude_line) {

+ # Register uninstrumented line instead

+ push(@result, 0);

+ push(@result, 0);

+ } else {

+ push(@result, 1);

+ push(@result, $number);

+ }

+ # 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, '-');

+ if ($exclude_line) {

+ next;

+ }

+ 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;

+ }

+ }

+ if ($line eq "0")

+ elsif ($count eq "-")

+ push(@result, $code);

+ 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);

+ if ($exclude_flag) {

+ warn("WARNING: unterminated exclusion section in $filename\n");

+ return(\@result, $branches, \@functions);

+#

+# 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;

+ my $instr;

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

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

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

+ ($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);

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

+ my $funcdata = $graph->{$filename};

+ my $line;

+ my $linedata;

+ 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");

+

+sub filter_fn_name($)

+{

+ my ($fn) = @_;

+

+ # Remove characters used internally as function name delimiters

+ $fn =~ s/[,=]/_/g;

+

+ return $fn;

+}

+

+

+

+#

+# 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;

+}

+our $lcov_version = 'LCOV version 1.9';

+sub genpng_warn_handler($);

+sub genpng_die_handler($);

+# Prettify version string

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

+

+ $SIG{__WARN__} = \&genpng_warn_handler;

+ $SIG{__DIE__} = \&genpng_die_handler;

+sub genpng_warn_handler($)

+sub genpng_die_handler($)

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

+use File::Basename;

+use File::Path;

+use File::Find;

+use File::Temp qw /tempdir/;

+use File::Spec::Functions qw /abs2rel canonpath catdir catfile catpath

+ file_name_is_absolute rootdir splitdir splitpath/;

+use Cwd qw /abs_path getcwd/;

+our $lcov_version = 'LCOV version 1.9';

+our $gcov_dir;

+our $tmp_dir;

+

+# Internal constants

+our $GKV_PROC = 0; # gcov-kernel data in /proc via external patch

+our $GKV_SYS = 1; # gcov-kernel data in /sys via vanilla 2.6.31+

+our @GKV_NAME = ( "external", "upstream" );

+our $pkg_gkv_file = ".gcov_kernel_version";

+our $pkg_build_file = ".build_directory";

+our $BR_BLOCK = 0;

+our $BR_BRANCH = 1;

+our $BR_TAKEN = 2;

+our $BR_VEC_ENTRIES = 3;

+our $BR_VEC_WIDTH = 32;

+# Branch data combination types

+our $BR_SUB = 0;

+our $BR_ADD = 1;

+sub kernel_capture_initial();

+sub package_capture();

+sub set_info_entry($$$$$$$$$;$$$$$$);

+sub abort_handler($);

+sub temp_cleanup();

+sub setup_gkv();

+sub get_overall_line($$$$);

+sub print_overall_rate($$$$$$$$$);

+sub lcov_geninfo(@);

+sub create_package($$$;$);

+sub get_func_found_and_hit($);

+sub br_ivec_get($$);

+our $to_package;

+our $from_package;

+our $no_markers;

+our @temp_dirs;

+our $gcov_gkv; # gcov kernel support version found on machine

+our $opt_derive_func_data;

+our $opt_debug;

+our $opt_list_full_path;

+our $opt_no_list_full_path;

+our $opt_list_width = 80;

+our $opt_list_truncate_max = 20;

+our $ln_overall_found;

+our $ln_overall_hit;

+our $fn_overall_found;

+our $fn_overall_hit;

+our $br_overall_found;

+our $br_overall_hit;

+$SIG{'INT'} = \&abort_handler;

+$SIG{'QUIT'} = \&abort_handler;

+

+# Prettify version string

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

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

+ "lcov_tmp_dir" => \$tmp_dir,

+ "lcov_list_full_path" => \$opt_list_full_path,

+ "lcov_list_width" => \$opt_list_width,

+ "lcov_list_truncate_max"=> \$opt_list_truncate_max,

+ });

+ "add-tracefile|a=s" => \@add_tracefile,

+ "list|l=s" => \$list,

+ "kernel-directory|k=s" => \@kernel_directory,

+ "extract|e=s" => \$extract,

+ "remove|r=s" => \$remove,

+ "output-file|o=s" => \$output_filename,

+ "test-name|t=s" => \$test_name,

+ "zerocounters|z" => \$reset,

+ "quiet|q" => \$quiet,

+ "help|h|?" => \$help,

+ "version|v" => \$version,

+ "follow|f" => \$follow,

+ "base-directory|b=s" => \$base_directory,

+ "no-recursion" => \$no_recursion,

+ "to-package=s" => \$to_package,

+ "from-package=s" => \$from_package,

+ "no-markers" => \$no_markers,

+ "derive-func-data" => \$opt_derive_func_data,

+ "debug" => \$opt_debug,

+ "list-full-path" => \$opt_list_full_path,

+ "no-list-full-path" => \$opt_no_list_full_path,

+

+ if (defined($opt_no_list_full_path))

+ {

+ $opt_list_full_path = ($opt_no_list_full_path ? 0 : 1);

+ $opt_no_list_full_path = undef;

+ }

+# Check list width option

+if ($opt_list_width <= 40) {

+ die("ERROR: lcov_list_width parameter out of range (needs to be ".

+ "larger than 40)\n");

+}

+

+ die("Extra parameter found: '".join(" ", @ARGV)."'\n".

+

+# Determine kernel directory for gcov data

+if (!$from_package && !@directory && ($capture || $reset)) {

+ ($gcov_gkv, $gcov_dir) = setup_gkv();

+ # Capture source can be user space, kernel or package

+ if ($from_package) {

+ package_capture();

+ } elsif (@directory) {

+ } else {

+ if ($initial) {

+ if (defined($to_package)) {

+ die("ERROR: --initial cannot be used together ".

+ "with --to-package\n");

+ }

+ kernel_capture_initial();

+ } else {

+ kernel_capture();

+ }

+ ($ln_overall_found, $ln_overall_hit,

+ $fn_overall_found, $fn_overall_hit,

+ $br_overall_found, $br_overall_hit) = add_traces();

+ ($ln_overall_found, $ln_overall_hit,

+ $fn_overall_found, $fn_overall_hit,

+ $br_overall_found, $br_overall_hit) = remove();

+ ($ln_overall_found, $ln_overall_hit,

+ $fn_overall_found, $fn_overall_hit,

+ $br_overall_found, $br_overall_hit) = extract();

+ ($ln_overall_found, $ln_overall_hit,

+ $fn_overall_found, $fn_overall_hit,

+ $br_overall_found, $br_overall_hit) = diff();

+temp_cleanup();

+

+if (defined($ln_overall_found)) {

+ print_overall_rate(1, $ln_overall_found, $ln_overall_hit,

+ 1, $fn_overall_found, $fn_overall_hit,

+ 1, $br_overall_found, $br_overall_hit);

+} else {

+ info("Done.\n") if (!$list && !$capture);

+}

+ --ignore-errors ERRORS Continue after ERRORS (gcov, source, graph)

+ --no-recursion Exclude subdirectories from processing

+ --to-package FILENAME Store unprocessed coverage data in FILENAME

+ --from-package FILENAME Capture from unprocessed data in FILENAME

+ --no-markers Ignore exclusion markers in source code

+ --derive-func-data Generate function data from line data

+ --list-full-path Print full path during a list operation

+# Capture coverage data found in DIRECTORY and write it to a package (if

+# TO_PACKAGE specified) or to OUTPUT_FILENAME or STDOUT.

+ my $dir;

+ my $build;

+

+ if (!defined($to_package)) {

+ lcov_geninfo(@directory);

+ return;

+ }

+ if (scalar(@directory) != 1) {

+ die("ERROR: -d may be specified only once with --to-package\n");

+ }

+ $dir = $directory[0];

+ if (defined($base_directory)) {

+ $build = $base_directory;

+ } else {

+ $build = $dir;

+ }

+ create_package($to_package, $dir, $build);

+}

+

+

+#

+# kernel_reset()

+#

+# Reset kernel coverage.

+#

+# Die on error.

+#

+

+sub kernel_reset()

+{

+ local *HANDLE;

+ my $reset_file;

+

+ info("Resetting kernel execution counters\n");

+ if (-e "$gcov_dir/vmlinux") {

+ $reset_file = "$gcov_dir/vmlinux";

+ } elsif (-e "$gcov_dir/reset") {

+ $reset_file = "$gcov_dir/reset";

+ } else {

+ die("ERROR: no reset control found in $gcov_dir\n");

+ }

+ open(HANDLE, ">$reset_file") or

+ die("ERROR: cannot write to $reset_file!\n");

+ print(HANDLE "0");

+ close(HANDLE);

+}

+

+

+#

+# lcov_copy_single(from, to)

+#

+# Copy single regular file FROM to TO without checking its size. This is

+# required to work with special files generated by the kernel

+# seq_file-interface.

+#

+#

+sub lcov_copy_single($$)

+{

+ my ($from, $to) = @_;

+ my $content;

+ local $/;

+ local *HANDLE;

+

+ open(HANDLE, "<$from") or die("ERROR: cannot read $from: $!\n");

+ $content = <HANDLE>;

+ close(HANDLE);

+ open(HANDLE, ">$to") or die("ERROR: cannot write $from: $!\n");

+ if (defined($content)) {

+ print(HANDLE $content);

+ }

+ close(HANDLE);

+}

+

+#

+# lcov_find(dir, function, data[, extension, ...)])

+#

+# Search DIR for files and directories whose name matches PATTERN and run

+# FUNCTION for each match. If not pattern is specified, match all names.

+#

+# FUNCTION has the following prototype:

+# function(dir, relative_name, data)

+#

+# Where:

+# dir: the base directory for this search

+# relative_name: the name relative to the base directory of this entry

+# data: the DATA variable passed to lcov_find

+#

+sub lcov_find($$$;@)

+{

+ my ($dir, $fn, $data, @pattern) = @_;

+ my $result;

+ my $_fn = sub {

+ my $filename = $File::Find::name;

+

+ if (defined($result)) {

+ return;

+ }

+ $filename = abs2rel($filename, $dir);

+ foreach (@pattern) {

+ if ($filename =~ /$_/) {

+ goto ok;

+ }

+ }

+ return;

+ ok:

+ $result = &$fn($dir, $filename, $data);

+ };

+ if (scalar(@pattern) == 0) {

+ @pattern = ".*";

+ }

+ find( { wanted => $_fn, no_chdir => 1 }, $dir);

+

+ return $result;

+}

+

+#

+# lcov_copy_fn(from, rel, to)

+#

+# Copy directories, files and links from/rel to to/rel.

+#

+

+sub lcov_copy_fn($$$)

+{

+ my ($from, $rel, $to) = @_;

+ my $absfrom = canonpath(catfile($from, $rel));

+ my $absto = canonpath(catfile($to, $rel));

+

+ if (-d) {

+ if (! -d $absto) {

+ mkpath($absto) or

+ die("ERROR: cannot create directory $absto\n");

+ chmod(0700, $absto);

+ }

+ } elsif (-l) {

+ # Copy symbolic link

+ my $link = readlink($absfrom);

+

+ if (!defined($link)) {

+ die("ERROR: cannot read link $absfrom: $!\n");

+ }

+ symlink($link, $absto) or

+ die("ERROR: cannot create link $absto: $!\n");

+ } else {

+ lcov_copy_single($absfrom, $absto);

+ chmod(0600, $absto);

+ }

+ return undef;

+}

+

+#

+# lcov_copy(from, to, subdirs)

+#

+# Copy all specified SUBDIRS and files from directory FROM to directory TO. For

+# regular files, copy file contents without checking its size. This is required

+# to work with seq_file-generated files.

+#

+

+sub lcov_copy($$;@)

+{

+ my ($from, $to, @subdirs) = @_;

+ my @pattern;

+

+ foreach (@subdirs) {

+ push(@pattern, "^$_");

+ }

+ lcov_find($from, \&lcov_copy_fn, $to, @pattern);

+}

+

+#

+# lcov_geninfo(directory)

+#

+# Call geninfo for the specified directory and with the parameters specified

+# at the command line.

+#

+

+sub lcov_geninfo(@)

+{

+ my (@dir) = @_;

+ # Capture data

+ info("Capturing coverage data from ".join(" ", @dir)."\n");

+ @param = ("$tool_dir/geninfo", @dir);

+ if ($no_markers)

+ @param = (@param, "--no-markers");

+ if ($opt_derive_func_data)

+ {

+ @param = (@param, "--derive-func-data");

+ }

+ if ($opt_debug)

+ {

+ @param = (@param, "--debug");

+ }

+ system(@param) and exit($? >> 8);

+# read_file(filename)

+# Return the contents of the file defined by filename.

+sub read_file($)

+ my ($filename) = @_;

+ my $content;

+ local $\;

+ open(HANDLE, "<$filename") || return undef;

+ $content = <HANDLE>;

+ return $content;

+#

+# get_package(package_file)

+#

+# Unpack unprocessed coverage data files from package_file to a temporary

+# directory and return directory name, build directory and gcov kernel version

+# as found in package.

+#

+

+sub get_package($)

+{

+ my ($file) = @_;

+ my $dir = create_temp_dir();

+ my $gkv;

+ my $build;

+ my $cwd = getcwd();

+ my $count;

+ local *HANDLE;

+

+ info("Reading package $file:\n");

+ info(" data directory .......: $dir\n");

+ $file = abs_path($file);

+ chdir($dir);

+ open(HANDLE, "tar xvfz $file 2>/dev/null|")

+ or die("ERROR: could not process package $file\n");

+ while (<HANDLE>) {

+ if (/\.da$/ || /\.gcda$/) {

+ $count++;

+ }

+ }

+ close(HANDLE);

+ $build = read_file("$dir/$pkg_build_file");

+ if (defined($build)) {

+ info(" build directory ......: $build\n");

+ }

+ $gkv = read_file("$dir/$pkg_gkv_file");

+ if (defined($gkv)) {

+ $gkv = int($gkv);

+ if ($gkv != $GKV_PROC && $gkv != $GKV_SYS) {

+ die("ERROR: unsupported gcov kernel version found ".

+ "($gkv)\n");

+ }

+ info(" content type .........: kernel data\n");

+ info(" gcov kernel version ..: %s\n", $GKV_NAME[$gkv]);

+ } else {

+ info(" content type .........: application data\n");

+ }

+ info(" data files ...........: $count\n");

+ chdir($cwd);

+

+ return ($dir, $build, $gkv);

+}

+# write_file(filename, $content)

+# Create a file named filename and write the specified content to it.

+sub write_file($$)

+ my ($filename, $content) = @_;

+ local *HANDLE;

+ open(HANDLE, ">$filename") || return 0;

+ print(HANDLE $content);

+ close(HANDLE) || return 0;

+ return 1;

+}

+

+# count_package_data(filename)

+#

+# Count the number of coverage data files in the specified package file.

+#

+

+sub count_package_data($)

+{

+ my ($filename) = @_;

+ local *HANDLE;

+ my $count = 0;

+

+ open(HANDLE, "tar tfz $filename|") or return undef;

+ while (<HANDLE>) {

+ if (/\.da$/ || /\.gcda$/) {

+ $count++;

+ close(HANDLE);

+ return $count;

+}

+#

+# create_package(package_file, source_directory, build_directory[,

+# kernel_gcov_version])

+#

+# Store unprocessed coverage data files from source_directory to package_file.

+#

+sub create_package($$$;$)

+{

+ my ($file, $dir, $build, $gkv) = @_;

+ my $cwd = getcwd();

+

+ # Print information about the package

+ info("Creating package $file:\n");

+ info(" data directory .......: $dir\n");

+

+ # Handle build directory

+ if (defined($build)) {

+ info(" build directory ......: $build\n");

+ write_file("$dir/$pkg_build_file", $build)

+ or die("ERROR: could not write to ".

+ "$dir/$pkg_build_file\n");

+ # Handle gcov kernel version data

+ if (defined($gkv)) {

+ info(" content type .........: kernel data\n");

+ info(" gcov kernel version ..: %s\n", $GKV_NAME[$gkv]);

+ write_file("$dir/$pkg_gkv_file", $gkv)

+ or die("ERROR: could not write to ".

+ "$dir/$pkg_gkv_file\n");

+ } else {

+ info(" content type .........: application data\n");

+ # Create package

+ $file = abs_path($file);

+ chdir($dir);

+ system("tar cfz $file .")

+ and die("ERROR: could not create package $file\n");

+ # Remove temporary files

+ unlink("$dir/$pkg_build_file");

+ unlink("$dir/$pkg_gkv_file");

+ # Show number of data files

+ if (!$quiet) {

+ my $count = count_package_data($file);

+

+ if (defined($count)) {

+ info(" data files ...........: $count\n");

+ }

+ chdir($cwd);

+}

+

+sub find_link_fn($$$)

+{

+ my ($from, $rel, $filename) = @_;

+ my $absfile = catfile($from, $rel, $filename);

+

+ if (-l $absfile) {

+ return $absfile;

+ return undef;

+}

+

+#

+# get_base(dir)

+#

+# Return (BASE, OBJ), where

+# - BASE: is the path to the kernel base directory relative to dir

+# - OBJ: is the absolute path to the kernel build directory

+#

+

+sub get_base($)

+{

+ my ($dir) = @_;

+ my $marker = "kernel/gcov/base.gcno";

+ my $markerfile;

+ my $sys;

+ my $obj;

+ my $link;

+

+ $markerfile = lcov_find($dir, \&find_link_fn, $marker);

+ if (!defined($markerfile)) {

+ return (undef, undef);

+

+ # sys base is parent of parent of markerfile.

+ $sys = abs2rel(dirname(dirname(dirname($markerfile))), $dir);

+

+ # obj base is parent of parent of markerfile link target.

+ $link = readlink($markerfile);

+ if (!defined($link)) {

+ die("ERROR: could not read $markerfile\n");

+ $obj = dirname(dirname(dirname($link)));

+

+ return ($sys, $obj);

+}

+

+#

+# apply_base_dir(data_dir, base_dir, build_dir, @directories)

+#

+# Make entries in @directories relative to data_dir.

+#

+

+sub apply_base_dir($$$@)

+{

+ my ($data, $base, $build, @dirs) = @_;

+ my $dir;

+ my @result;

+

+ foreach $dir (@dirs) {

+ # Is directory path relative to data directory?

+ if (-d catdir($data, $dir)) {

+ push(@result, $dir);

+ next;

+ # Relative to the auto-detected base-directory?

+ if (defined($base)) {

+ if (-d catdir($data, $base, $dir)) {

+ push(@result, catdir($base, $dir));

+ next;

+ }

+ }

+ # Relative to the specified base-directory?

+ if (defined($base_directory)) {

+ if (file_name_is_absolute($base_directory)) {

+ $base = abs2rel($base_directory, rootdir());

+ } else {

+ $base = $base_directory;

+ }

+ if (-d catdir($data, $base, $dir)) {

+ push(@result, catdir($base, $dir));

+ next;

+ }

+ # Relative to the build directory?

+ if (defined($build)) {

+ if (file_name_is_absolute($build)) {

+ $base = abs2rel($build, rootdir());

+ } else {

+ $base = $build;

+ }

+ if (-d catdir($data, $base, $dir)) {

+ push(@result, catdir($base, $dir));

+ next;

+ }

+ }

+ die("ERROR: subdirectory $dir not found\n".

+ "Please use -b to specify the correct directory\n");

+ return @result;

+}

+

+#

+# copy_gcov_dir(dir, [@subdirectories])

+#

+# Create a temporary directory and copy all or, if specified, only some

+# subdirectories from dir to that directory. Return the name of the temporary

+# directory.

+#

+

+sub copy_gcov_dir($;@)

+{

+ my ($data, @dirs) = @_;

+ my $tempdir = create_temp_dir();

+

+ info("Copying data to temporary directory $tempdir\n");

+ lcov_copy($data, $tempdir, @dirs);

+

+ return $tempdir;

+}

+

+#

+# kernel_capture_initial

+#

+# Capture initial kernel coverage data, i.e. create a coverage data file from

+# static graph files which contains zero coverage data for all instrumented

+# lines.

+#

+

+sub kernel_capture_initial()

+{

+ my $build;

+ my $source;

+ my @params;

+

+ if (defined($base_directory)) {

+ $build = $base_directory;

+ $source = "specified";

+ } else {

+ (undef, $build) = get_base($gcov_dir);

+ if (!defined($build)) {

+ die("ERROR: could not auto-detect build directory.\n".

+ "Please use -b to specify the build directory\n");

+ }

+ $source = "auto-detected";

+ info("Using $build as kernel build directory ($source)\n");

+ # Build directory needs to be passed to geninfo

+ $base_directory = $build;

+ if (@kernel_directory) {

+ foreach my $dir (@kernel_directory) {

+ push(@params, "$build/$dir");

+ }

+ } else {

+ push(@params, $build);

+ lcov_geninfo(@params);

+}

+

+#

+# kernel_capture_from_dir(directory, gcov_kernel_version, build)

+#

+# Perform the actual kernel coverage capturing from the specified directory

+# assuming that the data was copied from the specified gcov kernel version.

+#

+

+sub kernel_capture_from_dir($$$)

+{

+ my ($dir, $gkv, $build) = @_;

+

+ # Create package or coverage file

+ if (defined($to_package)) {

+ create_package($to_package, $dir, $build, $gkv);

+ } else {

+ # Build directory needs to be passed to geninfo

+ $base_directory = $build;

+ lcov_geninfo($dir);

+}

+

+#

+# adjust_kernel_dir(dir, build)

+#

+# Adjust directories specified with -k so that they point to the directory

+# relative to DIR. Return the build directory if specified or the auto-

+# detected build-directory.

+#

+

+sub adjust_kernel_dir($$)

+{

+ my ($dir, $build) = @_;

+ my ($sys_base, $build_auto) = get_base($dir);

+

+ if (!defined($build)) {

+ $build = $build_auto;

+ if (!defined($build)) {

+ die("ERROR: could not auto-detect build directory.\n".

+ "Please use -b to specify the build directory\n");

+ # Make @kernel_directory relative to sysfs base

+ if (@kernel_directory) {

+ @kernel_directory = apply_base_dir($dir, $sys_base, $build,

+ @kernel_directory);

+ return $build;

+}

+sub kernel_capture()

+{

+ my $data_dir;

+ my $build = $base_directory;

+ if ($gcov_gkv == $GKV_SYS) {

+ $build = adjust_kernel_dir($gcov_dir, $build);

+ }

+ $data_dir = copy_gcov_dir($gcov_dir, @kernel_directory);

+ kernel_capture_from_dir($data_dir, $gcov_gkv, $build);

+}

+

+#

+# package_capture()

+#

+# Capture coverage data from a package of unprocessed coverage data files

+# as generated by lcov --to-package.

+#

+

+sub package_capture()

+{

+ my $dir;

+ my $build;

+ my $gkv;

+

+ ($dir, $build, $gkv) = get_package($from_package);

+

+ # Check for build directory

+ if (defined($base_directory)) {

+ if (defined($build)) {

+ info("Using build directory specified by -b.\n");

+ }

+ $build = $base_directory;

+ }

+

+ # Do the actual capture

+ if (defined($gkv)) {

+ if ($gkv == $GKV_SYS) {

+ $build = adjust_kernel_dir($dir, $build);

+ }

+ if (@kernel_directory) {

+ $dir = copy_gcov_dir($dir, @kernel_directory);

+ }

+ kernel_capture_from_dir($dir, $gkv, $build);

+ } else {

+ # Build directory needs to be passed to geninfo

+ $base_directory = $build;

+ lcov_geninfo($dir);

+ printf(@_)

+ # Don't interfere with the .info output to STDOUT

+# create_temp_dir()

+#

+# Create a temporary directory and return its path.

+sub create_temp_dir()

+ my $dir;

+ if (defined($tmp_dir)) {

+ $dir = tempdir(DIR => $tmp_dir, CLEANUP => 1);

+ } else {

+ $dir = tempdir(CLEANUP => 1);

+ if (!defined($dir)) {

+ die("ERROR: cannot create temporary directory\n");

+ push(@temp_dirs, $dir);

+ return $dir;

+}

+#

+# br_taken_to_num(taken)

+#

+# Convert a branch taken value .info format to number format.

+#

+sub br_taken_to_num($)

+{

+ my ($taken) = @_;

+ return 0 if ($taken eq '-');

+ return $taken + 1;

+# br_num_to_taken(taken)

+# Convert a branch taken value in number format to .info format.

+sub br_num_to_taken($)

+ my ($taken) = @_;

+ return '-' if ($taken == 0);

+ return $taken - 1;

+}

+

+#