gcov源码，供学习使用。

摘自http://www.opensource.apple.com/source/gcc/gcc-5484/gcc/gcov.c

   1 /* Gcov.c: prepend line execution counts and branch probabilities to a

   2    source file.

   3    Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998,

   4    1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.

   5    Contributed by James E. Wilson of Cygnus Support.

   6    Mangled by Bob Manson of Cygnus Support.

   7    Mangled further by Nathan Sidwell <[email protected]>

   8 

   9 Gcov is free software; you can redistribute it and/or modify

  10 it under the terms of the GNU General Public License as published by

  11 the Free Software Foundation; either version 2, or (at your option)

  12 any later version.

  13 

  14 Gcov is distributed in the hope that it will be useful,

  15 but WITHOUT ANY WARRANTY; without even the implied warranty of

  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  17 GNU General Public License for more details.

  18 

  19 You should have received a copy of the GNU General Public License

  20 along with Gcov; see the file COPYING.  If not, write to

  21 the Free Software Foundation, 59 Temple Place - Suite 330,

  22 Boston, MA 02111-1307, USA.  */

  23 

  24 /* ??? Print a list of the ten blocks with the highest execution counts,

  25    and list the line numbers corresponding to those blocks.  Also, perhaps

  26    list the line numbers with the highest execution counts, only printing

  27    the first if there are several which are all listed in the same block.  */

  28 

  29 /* ??? Should have an option to print the number of basic blocks, and the

  30    percent of them that are covered.  */

  31 

  32 /* ??? Does not correctly handle the case where two .bb files refer to

  33    the same included source file.  For example, if one has a short

  34    file containing only inline functions, which is then included in

  35    two other files, then there will be two .bb files which refer to

  36    the include file, but there is no way to get the total execution

  37    counts for the included file, can only get execution counts for one

  38    or the other of the including files. this can be fixed by --ratios

  39    --long-file-names --preserve-paths and perl.  */

  40 

  41 /* Need an option to show individual block counts, and show

  42    probabilities of fall through arcs.  */

  43 

  44 #include "config.h"

  45 #include "system.h"

  46 #include "coretypes.h"

  47 #include "tm.h"

  48 #include "intl.h"

  49 #include "version.h"

  50 

  51 #include <getopt.h>

  52 

  53 #define IN_GCOV 1

  54 #include "gcov-io.h"

  55 #include "gcov-io.c"

  56 

  57 /* The bbg file is generated by -ftest-coverage option. The da file is

  58    generated by a program compiled with -fprofile-arcs. Their formats

  59    are documented in gcov-io.h.  */

  60 

  61 /* The functions in this file for creating and solution program flow graphs

  62    are very similar to functions in the gcc source file profile.c.  In

  63    some places we make use of the knowledge of how profile.c works to

  64    select particular algorithms here.  */

  65 

  66 /* This is the size of the buffer used to read in source file lines.  */

  67 

  68 #define STRING_SIZE 200

  69 

  70 struct function_info;

  71 struct block_info;

  72 struct source_info;

  73 

  74 /* Describes an arc between two basic blocks.  */

  75 

  76 typedef struct arc_info

  77 {

  78   /* source and destination blocks.  */

  79   struct block_info *src;

  80   struct block_info *dst;

  81 

  82   /* transition counts.  */

  83   gcov_type count;

  84   /* used in cycle search, so that we do not clobber original counts.  */

  85   gcov_type cs_count;

  86 

  87   unsigned int count_valid : 1;

  88   unsigned int on_tree : 1;

  89   unsigned int fake : 1;

  90   unsigned int fall_through : 1;

  91 

  92   /* Arc is for a function that abnormally returns.  */

  93   unsigned int is_call_non_return : 1;

  94 

  95   /* Arc is for catch/setjump.  */

  96   unsigned int is_nonlocal_return : 1;

  97 

  98   /* Is an unconditional branch.  */

  99   unsigned int is_unconditional : 1;

 100 

 101   /* Loop making arc.  */

 102   unsigned int cycle : 1;

 103 

 104   /* Next branch on line.  */

 105   struct arc_info *line_next;

 106 

 107   /* Links to next arc on src and dst lists.  */

 108   struct arc_info *succ_next;

 109   struct arc_info *pred_next;

 110 } arc_t;

 111 

 112 /* Describes a basic block. Contains lists of arcs to successor and

 113    predecessor blocks.  */

 114 

 115 typedef struct block_info

 116 {

 117   /* Chain of exit and entry arcs.  */

 118   arc_t *succ;

 119   arc_t *pred;

 120 

 121   /* Number of unprocessed exit and entry arcs.  */

 122   gcov_type num_succ;

 123   gcov_type num_pred;

 124 

 125   /* Block execution count.  */

 126   gcov_type count;

 127   unsigned flags : 13;

 128   unsigned count_valid : 1;

 129   unsigned valid_chain : 1;

 130   unsigned invalid_chain : 1;

 131 

 132   /* Block is a call instrumenting site.  */

 133   unsigned is_call_site : 1; /* Does the call.  */

 134   unsigned is_call_return : 1; /* Is the return.  */

 135 

 136   /* Block is a landing pad for longjmp or throw.  */

 137   unsigned is_nonlocal_return : 1;

 138 

 139   union

 140   {

 141     struct

 142     {

 143      /* Array of line numbers and source files. source files are

 144         introduced by a linenumber of zero, the next 'line number' is

 145         the number of the source file.  Always starts with a source

 146         file.  */

 147       unsigned *encoding;

 148       unsigned num;

 149     } line; /* Valid until blocks are linked onto lines */

 150     struct

 151     {

 152       /* Single line graph cycle workspace.  Used for all-blocks

 153      mode.  */

 154       arc_t *arc;

 155       unsigned ident;

 156     } cycle; /* Used in all-blocks mode, after blocks are linked onto

 157            lines.  */

 158   } u;

 159 

 160   /* Temporary chain for solving graph, and for chaining blocks on one

 161      line.  */

 162   struct block_info *chain;

 163 

 164 } block_t;

 165 

 166 /* Describes a single function. Contains an array of basic blocks.  */

 167 

 168 typedef struct function_info

 169 {

 170   /* Name of function.  */

 171   char *name;

 172   unsigned ident;

 173   unsigned checksum;

 174 

 175   /* Array of basic blocks.  */

 176   block_t *blocks;

 177   unsigned num_blocks;

 178   unsigned blocks_executed;

 179 

 180   /* Raw arc coverage counts.  */

 181   gcov_type *counts;

 182   unsigned num_counts;

 183 

 184   /* First line number.  */

 185   unsigned line;

 186   struct source_info *src;

 187 

 188   /* Next function in same source file.  */

 189   struct function_info *line_next;

 190 

 191   /* Next function.  */

 192   struct function_info *next;

 193 } function_t;

 194 

 195 /* Describes coverage of a file or function.  */

 196 

 197 typedef struct coverage_info

 198 {

 199   int lines;

 200   int lines_executed;

 201 

 202   int branches;

 203   int branches_executed;

 204   int branches_taken;

 205 

 206   int calls;

 207   int calls_executed;

 208 

 209   char *name;

 210 } coverage_t;

 211 

 212 /* Describes a single line of source. Contains a chain of basic blocks

 213    with code on it.  */

 214 

 215 typedef struct line_info

 216 {

 217   gcov_type count;       /* execution count */

 218   union

 219   {

 220     arc_t *branches;       /* branches from blocks that end on this

 221                   line. Used for branch-counts when not

 222                   all-blocks mode.  */

 223     block_t *blocks;       /* blocks which start on this line.  Used

 224                   in all-blocks mode.  */

 225   } u;

 226   unsigned exists : 1;

 227 } line_t;

 228 

 229 /* Describes a file mentioned in the block graph.  Contains an array

 230    of line info.  */

 231 

 232 typedef struct source_info

 233 {

 234   /* Name of source file.  */

 235   char *name;

 236   unsigned index;

 237 

 238   /* Array of line information.  */

 239   line_t *lines;

 240   unsigned num_lines;

 241 

 242   coverage_t coverage;

 243 

 244   /* Functions in this source file.  These are in ascending line

 245      number order.  */

 246   function_t *functions;

 247 

 248   /* Next source file.  */

 249   struct source_info *next;

 250 } source_t;

 251 

 252 /* Holds a list of function basic block graphs.  */

 253 

 254 static function_t *functions;

 255 

 256 /* This points to the head of the sourcefile structure list.  */

 257 

 258 static source_t *sources;

 259 

 260 /* This holds data summary information.  */

 261 

 262 static struct gcov_summary object_summary;

 263 static unsigned program_count;

 264 

 265 /* Modification time of graph file.  */

 266 

 267 static time_t bbg_file_time;

 268 

 269 /* Name and file pointer of the input file for the basic block graph.  */

 270 

 271 static char *bbg_file_name;

 272 

 273 /* Stamp of the bbg file */

 274 static unsigned bbg_stamp;

 275 

 276 /* Name and file pointer of the input file for the arc count data.  */

 277 

 278 static char *da_file_name;

 279 

 280 /* Output branch probabilities.  */

 281 

 282 static int flag_branches = 0;

 283 

 284 /* Show unconditional branches too.  */

 285 static int flag_unconditional = 0;

 286 

 287 /* Output a gcov file if this is true.  This is on by default, and can

 288    be turned off by the -n option.  */

 289 

 290 static int flag_gcov_file = 1;

 291 

 292 /* For included files, make the gcov output file name include the name

 293    of the input source file.  For example, if x.h is included in a.c,

 294    then the output file name is a.c##x.h.gcov instead of x.h.gcov.  */

 295 

 296 static int flag_long_names = 0;

 297 

 298 /* Output count information for every basic block, not merely those

 299    that contain line number information.  */

 300 

 301 static int flag_all_blocks = 0;

 302 

 303 /* Output summary info for each function.  */

 304 

 305 static int flag_function_summary = 0;

 306 

 307 /* Object directory file prefix.  This is the directory/file where the

 308    graph and data files are looked for, if nonzero.  */

 309 

 310 static char *object_directory = 0;

 311 

 312 /* Preserve all pathname components. Needed when object files and

 313    source files are in subdirectories. '/' is mangled as '#', '.' is

 314    elided and '..' mangled to '^'.  */

 315 

 316 static int flag_preserve_paths = 0;

 317 

 318 /* Output the number of times a branch was taken as opposed to the percentage

 319    of times it was taken.  */

 320 

 321 static int flag_counts = 0;

 322 

 323 /* Forward declarations.  */

 324 static void fnotice (FILE *, const char *, ...) ATTRIBUTE_PRINTF_2;

 325 static int process_args (int, char **);

 326 static void print_usage (int) ATTRIBUTE_NORETURN;

 327 static void print_version (void) ATTRIBUTE_NORETURN;

 328 static void process_file (const char *);

 329 static void create_file_names (const char *);

 330 static source_t *find_source (const char *);

 331 static int read_graph_file (void);

 332 static int read_count_file (void);

 333 static void solve_flow_graph (function_t *);

 334 static void add_branch_counts (coverage_t *, const arc_t *);

 335 static void add_line_counts (coverage_t *, function_t *);

 336 static void function_summary (const coverage_t *, const char *);

 337 static const char *format_gcov (gcov_type, gcov_type, int);

 338 static void accumulate_line_counts (source_t *);

 339 static int output_branch_count (FILE *, int, const arc_t *);

 340 static void output_lines (FILE *, const source_t *);

 341 static char *make_gcov_file_name (const char *, const char *);

 342 static void release_structures (void);

 343 extern int main (int, char **);

 344 

 345 int

 346 main (int argc, char **argv)

 347 {

 348   int argno;

 349 

 350   /* Unlock the stdio streams.  */

 351   unlock_std_streams ();

 352 

 353   gcc_init_libintl ();

 354 

 355   argno = process_args (argc, argv);

 356   if (optind == argc)

 357     print_usage (true);

 358 

 359   for (; argno != argc; argno++)

 360     {

 361       release_structures ();

 362 

 363       process_file (argv[argno]);

 364     }

 365 

 366   return 0;

 367 }

 368 

 369 static void

 370 fnotice (FILE *file, const char *cmsgid, ...)

 371 {

 372   va_list ap;

 373 

 374   va_start (ap, cmsgid);

 375   vfprintf (file, _(cmsgid), ap);

 376   va_end (ap);

 377 }

 378 

 379 /* Print a usage message and exit.  If ERROR_P is nonzero, this is an error,

 380    otherwise the output of --help.  */

 381 

 382 static void

 383 print_usage (int error_p)

 384 {

 385   FILE *file = error_p ? stderr : stdout;

 386   int status = error_p ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE;

 387 

 388   fnotice (file, "Usage: gcov [OPTION]... SOURCEFILE\n\n");

 389   fnotice (file, "Print code coverage information.\n\n");

 390   fnotice (file, "  -h, --help                      Print this help, then exit\n");

 391   fnotice (file, "  -v, --version                   Print version number, then exit\n");

 392   fnotice (file, "  -a, --all-blocks                Show information for every basic block\n");

 393   fnotice (file, "  -b, --branch-probabilities      Include branch probabilities in output\n");

 394   fnotice (file, "  -c, --branch-counts             Given counts of branches taken\n\

 395                                     rather than percentages\n");

 396   fnotice (file, "  -n, --no-output                 Do not create an output file\n");

 397   fnotice (file, "  -l, --long-file-names           Use long output file names for included\n\

 398                                     source files\n");

 399   fnotice (file, "  -f, --function-summaries        Output summaries for each function\n");

 400   fnotice (file, "  -o, --object-directory DIR|FILE Search for object files in DIR or called FILE\n");

 401   fnotice (file, "  -p, --preserve-paths            Preserve all pathname components\n");

 402   fnotice (file, "  -u, --unconditional-branches    Show unconditional branch counts too\n");

 403   fnotice (file, "\nFor bug reporting instructions, please see:\n%s.\n",

 404        bug_report_url);

 405   exit (status);

 406 }

 407 

 408 /* Print version information and exit.  */

 409 

 410 static void

 411 print_version (void)

 412 {

 413   fnotice (stdout, "gcov (GCC) %s\n", version_string);

 414   fprintf (stdout, "Copyright %s 2004 Free Software Foundation, Inc.\n",

 415        _("(C)"));

 416   fnotice (stdout,

 417        _("This is free software; see the source for copying conditions.\n"

 418          "There is NO warranty; not even for MERCHANTABILITY or \n"

 419          "FITNESS FOR A PARTICULAR PURPOSE.\n\n"));

 420   exit (SUCCESS_EXIT_CODE);

 421 }

 422 

 423 static const struct option options[] =

 424 {

 425   { "help",                 no_argument,       NULL, 'h' },

 426   { "version",              no_argument,       NULL, 'v' },

 427   { "all-blocks",           no_argument,       NULL, 'a' },

 428   { "branch-probabilities", no_argument,       NULL, 'b' },

 429   { "branch-counts",        no_argument,       NULL, 'c' },

 430   { "no-output",            no_argument,       NULL, 'n' },

 431   { "long-file-names",      no_argument,       NULL, 'l' },

 432   { "function-summaries",   no_argument,       NULL, 'f' },

 433   { "preserve-paths",       no_argument,       NULL, 'p' },

 434   { "object-directory",     required_argument, NULL, 'o' },

 435   { "object-file",          required_argument, NULL, 'o' },

 436   { "unconditional-branches", no_argument,     NULL, 'u' },

 437   { 0, 0, 0, 0 }

 438 };

 439 

 440 /* Process args, return index to first non-arg.  */

 441 

 442 static int

 443 process_args (int argc, char **argv)

 444 {

 445   int opt;

 446 

 447   while ((opt = getopt_long (argc, argv, "abcfhlno:puv", options, NULL)) != -1)

 448     {

 449       switch (opt)

 450     {

 451     case 'a':

 452       flag_all_blocks = 1;

 453       break;

 454     case 'b':

 455       flag_branches = 1;

 456       break;

 457     case 'c':

 458       flag_counts = 1;

 459       break;

 460     case 'f':

 461       flag_function_summary = 1;

 462       break;

 463     case 'h':

 464       print_usage (false);

 465       /* print_usage will exit.  */

 466     case 'l':

 467       flag_long_names = 1;

 468       break;

 469     case 'n':

 470       flag_gcov_file = 0;

 471       break;

 472     case 'o':

 473       object_directory = optarg;

 474       break;

 475     case 'p':

 476       flag_preserve_paths = 1;

 477       break;

 478     case 'u':

 479       flag_unconditional = 1;

 480       break;

 481     case 'v':

 482       print_version ();

 483       /* print_version will exit.  */

 484     default:

 485       print_usage (true);

 486       /* print_usage will exit.  */

 487     }

 488     }

 489 

 490   return optind;

 491 }

 492 

 493 /* Process a single source file.  */

 494 

 495 static void

 496 process_file (const char *file_name)

 497 {

 498   source_t *src;

 499   function_t *fn;

 500 

 501   create_file_names (file_name);

 502   if (read_graph_file ())

 503     return;

 504 

 505   if (!functions)

 506     {

 507       fnotice (stderr, "%s:no functions found\n", bbg_file_name);

 508       return;

 509     }

 510 

 511   if (read_count_file ())

 512     return;

 513 

 514   for (fn = functions; fn; fn = fn->next)

 515     solve_flow_graph (fn);

 516   for (src = sources; src; src = src->next)

 517     src->lines = xcalloc (src->num_lines, sizeof (line_t));

 518   for (fn = functions; fn; fn = fn->next)

 519     {

 520       coverage_t coverage;

 521 

 522       memset (&coverage, 0, sizeof (coverage));

 523       coverage.name = fn->name;

 524       add_line_counts (flag_function_summary ? &coverage : NULL, fn);

 525       if (flag_function_summary)

 526     {

 527       function_summary (&coverage, "Function");

 528       fnotice (stdout, "\n");

 529     }

 530     }

 531 

 532   for (src = sources; src; src = src->next)

 533     {

 534       accumulate_line_counts (src);

 535       function_summary (&src->coverage, "File");

 536       if (flag_gcov_file)

 537     {

 538       char *gcov_file_name = make_gcov_file_name (file_name, src->name);

 539       FILE *gcov_file = fopen (gcov_file_name, "w");

 540 

 541       if (gcov_file)

 542         {

 543           fnotice (stdout, "%s:creating '%s'\n",

 544                src->name, gcov_file_name);

 545           output_lines (gcov_file, src);

 546           if (ferror (gcov_file))

 547             fnotice (stderr, "%s:error writing output file '%s'\n",

 548                  src->name, gcov_file_name);

 549           fclose (gcov_file);

 550         }

 551       else

 552         fnotice (stderr, "%s:could not open output file '%s'\n",

 553              src->name, gcov_file_name);

 554       free (gcov_file_name);

 555     }

 556       fnotice (stdout, "\n");

 557     }

 558 }

 559 

 560 /* Release all memory used.  */

 561 

 562 static void

 563 release_structures (void)

 564 {

 565   function_t *fn;

 566   source_t *src;

 567 

 568   free (bbg_file_name);

 569   free (da_file_name);

 570   da_file_name = bbg_file_name = NULL;

 571   bbg_file_time = 0;

 572   bbg_stamp = 0;

 573 

 574   while ((src = sources))

 575     {

 576       sources = src->next;

 577 

 578       free (src->name);

 579       free (src->lines);

 580     }

 581 

 582   while ((fn = functions))

 583     {

 584       unsigned ix;

 585       block_t *block;

 586 

 587       functions = fn->next;

 588       for (ix = fn->num_blocks, block = fn->blocks; ix--; block++)

 589     {

 590       arc_t *arc, *arc_n;

 591 

 592       for (arc = block->succ; arc; arc = arc_n)

 593         {

 594           arc_n = arc->succ_next;

 595           free (arc);

 596         }

 597     }

 598       free (fn->blocks);

 599       free (fn->counts);

 600     }

 601 }

 602 

 603 /* Generate the names of the graph and data files. If OBJECT_DIRECTORY

 604    is not specified, these are looked for in the current directory,

 605    and named from the basename of the FILE_NAME sans extension. If

 606    OBJECT_DIRECTORY is specified and is a directory, the files are in

 607    that directory, but named from the basename of the FILE_NAME, sans

 608    extension. Otherwise OBJECT_DIRECTORY is taken to be the name of

 609    the object *file*, and the data files are named from that.  */

 610 

 611 static void

 612 create_file_names (const char *file_name)

 613 {

 614   char *cptr;

 615   char *name;

 616   int length = strlen (file_name);

 617   int base;

 618 

 619   if (object_directory && object_directory[0])

 620     {

 621       struct stat status;

 622 

 623       length += strlen (object_directory) + 2;

 624       name = xmalloc (length);

 625       name[0] = 0;

 626 

 627       base = !stat (object_directory, &status) && S_ISDIR (status.st_mode);

 628       strcat (name, object_directory);

 629       if (base && name[strlen (name) - 1] != '/')

 630     strcat (name, "/");

 631     }

 632   else

 633     {

 634       name = xmalloc (length + 1);

 635       name[0] = 0;

 636       base = 1;

 637     }

 638 

 639   if (base)

 640     {

 641       /* Append source file name.  */

 642       cptr = strrchr (file_name, '/');

 643       strcat (name, cptr ? cptr + 1 : file_name);

 644     }

 645 

 646   /* Remove the extension.  */

 647   cptr = strrchr (name, '.');

 648   if (cptr)

 649     *cptr = 0;

 650 

 651   length = strlen (name);

 652   

 653   bbg_file_name = xmalloc (length + strlen (GCOV_NOTE_SUFFIX) + 1);

 654   strcpy (bbg_file_name, name);

 655   strcpy (bbg_file_name + length, GCOV_NOTE_SUFFIX);

 656 

 657   da_file_name = xmalloc (length + strlen (GCOV_DATA_SUFFIX) + 1);

 658   strcpy (da_file_name, name);

 659   strcpy (da_file_name + length, GCOV_DATA_SUFFIX);

 660 

 661   return;

 662 }

 663 

 664 /* Find or create a source file structure for FILE_NAME. Copies

 665    FILE_NAME on creation */

 666 

 667 static source_t *

 668 find_source (const char *file_name)

 669 {

 670   source_t *src;

 671 

 672   if (!file_name)

 673     file_name = "<unknown>";

 674 

 675   for (src = sources; src; src = src->next)

 676     if (!strcmp (file_name, src->name))

 677       return src;

 678 

 679   src = xcalloc (1, sizeof (source_t));

 680   src->name = xstrdup (file_name);

 681   src->coverage.name = src->name;

 682   src->index = sources ? sources->index + 1 : 1;

 683   src->next = sources;

 684   sources = src;

 685 

 686   return src;

 687 }

 688 

 689 /* Read the graph file. Return nonzero on fatal error.  */

 690 

 691 static int

 692 read_graph_file (void)

 693 {

 694   unsigned version;

 695   unsigned current_tag = 0;

 696   struct function_info *fn = NULL;

 697   source_t *src = NULL;

 698   unsigned ix;

 699   unsigned tag;

 700 

 701   if (!gcov_open (bbg_file_name, 1))

 702     {

 703       fnotice (stderr, "%s:cannot open graph file\n", bbg_file_name);

 704       return 1;

 705     }

 706   bbg_file_time = gcov_time ();

 707   if (!gcov_magic (gcov_read_unsigned (), GCOV_NOTE_MAGIC))

 708     {

 709       fnotice (stderr, "%s:not a gcov graph file\n", bbg_file_name);

 710       gcov_close ();

 711       return 1;

 712     }

 713 

 714   version = gcov_read_unsigned ();

 715   if (version != GCOV_VERSION)

 716     {

 717       char v[4], e[4];

 718 

 719       GCOV_UNSIGNED2STRING (v, version);

 720       GCOV_UNSIGNED2STRING (e, GCOV_VERSION);

 721 

 722       fnotice (stderr, "%s:version '%.4s', prefer '%.4s'\n",

 723            bbg_file_name, v, e);

 724     }

 725   bbg_stamp = gcov_read_unsigned ();

 726 

 727   while ((tag = gcov_read_unsigned ()))

 728     {

 729       unsigned length = gcov_read_unsigned ();

 730       gcov_position_t base = gcov_position ();

 731 

 732       if (tag == GCOV_TAG_FUNCTION)

 733     {

 734       char *function_name;

 735       unsigned ident, checksum, lineno;

 736       source_t *src;

 737       function_t *probe, *prev;

 738 

 739       ident = gcov_read_unsigned ();

 740       checksum = gcov_read_unsigned ();

 741       function_name = xstrdup (gcov_read_string ());

 742       src = find_source (gcov_read_string ());

 743       lineno = gcov_read_unsigned ();

 744 

 745       fn = xcalloc (1, sizeof (function_t));

 746       fn->name = function_name;

 747       fn->ident = ident;

 748       fn->checksum = checksum;

 749       fn->src = src;

 750       fn->line = lineno;

 751 

 752       fn->next = functions;

 753       functions = fn;

 754       current_tag = tag;

 755 

 756       if (lineno >= src->num_lines)

 757         src->num_lines = lineno + 1;

 758       /* Now insert it into the source file's list of

 759          functions. Normally functions will be encountered in

 760          ascending order, so a simple scan is quick.  */

 761       for (probe = src->functions, prev = NULL;

 762            probe && probe->line > lineno;

 763            prev = probe, probe = probe->line_next)

 764         continue;

 765       fn->line_next = probe;

 766       if (prev)

 767         prev->line_next = fn;

 768       else

 769         src->functions = fn;

 770     }

 771       else if (fn && tag == GCOV_TAG_BLOCKS)

 772     {

 773       if (fn->blocks)

 774         fnotice (stderr, "%s:already seen blocks for '%s'\n",

 775              bbg_file_name, fn->name);

 776       else

 777         {

 778           unsigned ix, num_blocks = GCOV_TAG_BLOCKS_NUM (length);

 779           fn->num_blocks = num_blocks;

 780 

 781           fn->blocks = xcalloc (fn->num_blocks, sizeof (block_t));

 782           for (ix = 0; ix != num_blocks; ix++)

 783         fn->blocks[ix].flags = gcov_read_unsigned ();

 784         }

 785     }

 786       else if (fn && tag == GCOV_TAG_ARCS)

 787     {

 788       unsigned src = gcov_read_unsigned ();

 789       unsigned num_dests = GCOV_TAG_ARCS_NUM (length);

 790 

 791       if (src >= fn->num_blocks || fn->blocks[src].succ)

 792         goto corrupt;

 793 

 794       while (num_dests--)

 795         {

 796           struct arc_info *arc;

 797           unsigned dest = gcov_read_unsigned ();

 798           unsigned flags = gcov_read_unsigned ();

 799 

 800           if (dest >= fn->num_blocks)

 801         goto corrupt;

 802           arc = xcalloc (1, sizeof (arc_t));

 803 

 804           arc->dst = &fn->blocks[dest];

 805           arc->src = &fn->blocks[src];

 806 

 807           arc->count = 0;

 808           arc->count_valid = 0;

 809           arc->on_tree = !!(flags & GCOV_ARC_ON_TREE);

 810           arc->fake = !!(flags & GCOV_ARC_FAKE);

 811           arc->fall_through = !!(flags & GCOV_ARC_FALLTHROUGH);

 812 

 813           arc->succ_next = fn->blocks[src].succ;

 814           fn->blocks[src].succ = arc;

 815           fn->blocks[src].num_succ++;

 816 

 817           arc->pred_next = fn->blocks[dest].pred;

 818           fn->blocks[dest].pred = arc;

 819           fn->blocks[dest].num_pred++;

 820 

 821           if (arc->fake)

 822         {

 823           if (src)

 824             {

 825               /* Exceptional exit from this function, the

 826              source block must be a call.  */

 827               fn->blocks[src].is_call_site = 1;

 828               arc->is_call_non_return = 1;

 829             }

 830           else

 831             {

 832               /* Non-local return from a callee of this

 833                  function. The destination block is a catch or

 834                  setjmp.  */

 835               arc->is_nonlocal_return = 1;

 836               fn->blocks[dest].is_nonlocal_return = 1;

 837             }

 838         }

 839 

 840           if (!arc->on_tree)

 841         fn->num_counts++;

 842         }

 843     }

 844       else if (fn && tag == GCOV_TAG_LINES)

 845     {

 846       unsigned blockno = gcov_read_unsigned ();

 847       unsigned *line_nos = xcalloc (length - 1, sizeof (unsigned));

 848 

 849       if (blockno >= fn->num_blocks || fn->blocks[blockno].u.line.encoding)

 850         goto corrupt;

 851 

 852       for (ix = 0; ;  )

 853         {

 854           unsigned lineno = gcov_read_unsigned ();

 855 

 856           if (lineno)

 857         {

 858           if (!ix)

 859             {

 860               line_nos[ix++] = 0;

 861               line_nos[ix++] = src->index;

 862             }

 863           line_nos[ix++] = lineno;

 864           if (lineno >= src->num_lines)

 865             src->num_lines = lineno + 1;

 866         }

 867           else

 868         {

 869           const char *file_name = gcov_read_string ();

 870 

 871           if (!file_name)

 872             break;

 873           src = find_source (file_name);

 874 

 875           line_nos[ix++] = 0;

 876           line_nos[ix++] = src->index;

 877         }

 878         }

 879 

 880       fn->blocks[blockno].u.line.encoding = line_nos;

 881       fn->blocks[blockno].u.line.num = ix;

 882     }

 883       else if (current_tag && !GCOV_TAG_IS_SUBTAG (current_tag, tag))

 884     {

 885       fn = NULL;

 886       current_tag = 0;

 887     }

 888       gcov_sync (base, length);

 889       if (gcov_is_error ())

 890     {

 891     corrupt:;

 892       fnotice (stderr, "%s:corrupted\n", bbg_file_name);

 893       gcov_close ();

 894       return 1;

 895     }

 896     }

 897   gcov_close ();

 898 

 899   /* We built everything backwards, so nreverse them all.  */

 900 

 901   /* Reverse sources. Not strictly necessary, but we'll then process

 902      them in the 'expected' order.  */

 903   {

 904     source_t *src, *src_p, *src_n;

 905 

 906     for (src_p = NULL, src = sources; src; src_p = src, src = src_n)

 907       {

 908     src_n = src->next;

 909     src->next = src_p;

 910       }

 911     sources =  src_p;

 912   }

 913 

 914   /* Reverse functions.  */

 915   {

 916     function_t *fn, *fn_p, *fn_n;

 917 

 918     for (fn_p = NULL, fn = functions; fn; fn_p = fn, fn = fn_n)

 919       {

 920     unsigned ix;

 921 

 922     fn_n = fn->next;

 923     fn->next = fn_p;

 924 

 925     /* Reverse the arcs.  */

 926     for (ix = fn->num_blocks; ix--;)

 927       {

 928         arc_t *arc, *arc_p, *arc_n;

 929 

 930         for (arc_p = NULL, arc = fn->blocks[ix].succ; arc;

 931          arc_p = arc, arc = arc_n)

 932           {

 933         arc_n = arc->succ_next;

 934         arc->succ_next = arc_p;

 935           }

 936         fn->blocks[ix].succ = arc_p;

 937 

 938         for (arc_p = NULL, arc = fn->blocks[ix].pred; arc;

 939          arc_p = arc, arc = arc_n)

 940           {

 941         arc_n = arc->pred_next;

 942         arc->pred_next = arc_p;

 943           }

 944         fn->blocks[ix].pred = arc_p;

 945       }

 946       }

 947     functions = fn_p;

 948   }

 949   return 0;

 950 }

 951 

 952 /* Reads profiles from the count file and attach to each

 953    function. Return nonzero if fatal error.  */

 954 

 955 static int

 956 read_count_file (void)

 957 {

 958   unsigned ix;

 959   unsigned version;

 960   unsigned tag;

 961   function_t *fn = NULL;

 962   int error = 0;

 963 

 964   if (!gcov_open (da_file_name, 1))

 965     {

 966       fnotice (stderr, "%s:cannot open data file\n", da_file_name);

 967       return 1;

 968     }

 969   if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC))

 970     {

 971       fnotice (stderr, "%s:not a gcov data file\n", da_file_name);

 972     cleanup:;

 973       gcov_close ();

 974       return 1;

 975     }

 976   version = gcov_read_unsigned ();

 977   if (version != GCOV_VERSION)

 978     {

 979       char v[4], e[4];

 980 

 981       GCOV_UNSIGNED2STRING (v, version);

 982       GCOV_UNSIGNED2STRING (e, GCOV_VERSION);

 983       

 984       fnotice (stderr, "%s:version '%.4s', prefer version '%.4s'\n",

 985            da_file_name, v, e);

 986     }

 987   tag = gcov_read_unsigned ();

 988   if (tag != bbg_stamp)

 989     {

 990       fnotice (stderr, "%s:stamp mismatch with graph file\n", da_file_name);

 991       goto cleanup;

 992     }

 993 

 994   while ((tag = gcov_read_unsigned ()))

 995     {

 996       unsigned length = gcov_read_unsigned ();

 997       unsigned long base = gcov_position ();

 998 

 999       if (tag == GCOV_TAG_OBJECT_SUMMARY)

1000     gcov_read_summary (&object_summary);

1001       else if (tag == GCOV_TAG_PROGRAM_SUMMARY)

1002     program_count++;

1003       else if (tag == GCOV_TAG_FUNCTION)

1004     {

1005       unsigned ident = gcov_read_unsigned ();

1006       struct function_info *fn_n = functions;

1007 

1008       for (fn = fn ? fn->next : NULL; ; fn = fn->next)

1009         {

1010           if (fn)

1011         ;

1012           else if ((fn = fn_n))

1013         fn_n = NULL;

1014           else

1015         {

1016           fnotice (stderr, "%s:unknown function '%u'\n",

1017                da_file_name, ident);

1018           break;

1019         }

1020           if (fn->ident == ident)

1021         break;

1022         }

1023 

1024       if (!fn)

1025         ;

1026       else if (gcov_read_unsigned () != fn->checksum)

1027         {

1028         mismatch:;

1029           fnotice (stderr, "%s:profile mismatch for '%s'\n",

1030                da_file_name, fn->name);

1031           goto cleanup;

1032         }

1033     }

1034       else if (tag == GCOV_TAG_FOR_COUNTER (GCOV_COUNTER_ARCS) && fn)

1035     {

1036       if (length != GCOV_TAG_COUNTER_LENGTH (fn->num_counts))

1037         goto mismatch;

1038 

1039       if (!fn->counts)

1040         fn->counts = xcalloc (fn->num_counts, sizeof (gcov_type));

1041 

1042       for (ix = 0; ix != fn->num_counts; ix++)

1043         fn->counts[ix] += gcov_read_counter ();

1044     }

1045       gcov_sync (base, length);

1046       if ((error = gcov_is_error ()))

1047     {

1048       fnotice (stderr, error < 0 ? "%s:overflowed\n" : "%s:corrupted\n",

1049            da_file_name);

1050       goto cleanup;

1051     }

1052     }

1053 

1054   gcov_close ();

1055   return 0;

1056 }

1057 

1058 /* Solve the flow graph. Propagate counts from the instrumented arcs

1059    to the blocks and the uninstrumented arcs.  */

1060 

1061 static void

1062 solve_flow_graph (function_t *fn)

1063 {

1064   unsigned ix;

1065   arc_t *arc;

1066   gcov_type *count_ptr = fn->counts;

1067   block_t *blk;

1068   block_t *valid_blocks = NULL;    /* valid, but unpropagated blocks.  */

1069   block_t *invalid_blocks = NULL;  /* invalid, but inferable blocks.  */

1070 

1071   if (fn->num_blocks < 2)

1072     fnotice (stderr, "%s:'%s' lacks entry and/or exit blocks\n",

1073          bbg_file_name, fn->name);

1074   else

1075     {

1076       if (fn->blocks[0].num_pred)

1077     fnotice (stderr, "%s:'%s' has arcs to entry block\n",

1078          bbg_file_name, fn->name);

1079       else

1080     /* We can't deduce the entry block counts from the lack of

1081        predecessors.  */

1082     fn->blocks[0].num_pred = ~(unsigned)0;

1083 

1084       if (fn->blocks[fn->num_blocks - 1].num_succ)

1085     fnotice (stderr, "%s:'%s' has arcs from exit block\n",

1086          bbg_file_name, fn->name);

1087       else

1088     /* Likewise, we can't deduce exit block counts from the lack

1089        of its successors.  */

1090     fn->blocks[fn->num_blocks - 1].num_succ = ~(unsigned)0;

1091     }

1092 

1093   /* Propagate the measured counts, this must be done in the same

1094      order as the code in profile.c  */

1095   for (ix = 0, blk = fn->blocks; ix != fn->num_blocks; ix++, blk++)

1096     {

1097       block_t const *prev_dst = NULL;

1098       int out_of_order = 0;

1099       int non_fake_succ = 0;

1100 

1101       for (arc = blk->succ; arc; arc = arc->succ_next)

1102     {

1103       if (!arc->fake)

1104         non_fake_succ++;

1105 

1106       if (!arc->on_tree)

1107         {

1108           if (count_ptr)

1109         arc->count = *count_ptr++;

1110           arc->count_valid = 1;

1111           blk->num_succ--;

1112           arc->dst->num_pred--;

1113         }

1114       if (prev_dst && prev_dst > arc->dst)

1115         out_of_order = 1;

1116       prev_dst = arc->dst;

1117     }

1118       if (non_fake_succ == 1)

1119     {

1120       /* If there is only one non-fake exit, it is an

1121          unconditional branch.  */

1122       for (arc = blk->succ; arc; arc = arc->succ_next)

1123         if (!arc->fake)

1124           {

1125         arc->is_unconditional = 1;

1126         /* If this block is instrumenting a call, it might be

1127            an artificial block. It is not artificial if it has

1128            a non-fallthrough exit, or the destination of this

1129            arc has more than one entry.  Mark the destination

1130            block as a return site, if none of those conditions

1131            hold.  */

1132         if (blk->is_call_site && arc->fall_through

1133             && arc->dst->pred == arc && !arc->pred_next)

1134           arc->dst->is_call_return = 1;

1135           }

1136     }

1137 

1138       /* Sort the successor arcs into ascending dst order. profile.c

1139      normally produces arcs in the right order, but sometimes with

1140      one or two out of order.  We're not using a particularly

1141      smart sort.  */

1142       if (out_of_order)

1143     {

1144       arc_t *start = blk->succ;

1145       unsigned changes = 1;

1146 

1147       while (changes)

1148         {

1149           arc_t *arc, *arc_p, *arc_n;

1150 

1151           changes = 0;

1152           for (arc_p = NULL, arc = start; (arc_n = arc->succ_next);)

1153         {

1154           if (arc->dst > arc_n->dst)

1155             {

1156               changes = 1;

1157               if (arc_p)

1158             arc_p->succ_next = arc_n;

1159               else

1160             start = arc_n;

1161               arc->succ_next = arc_n->succ_next;

1162               arc_n->succ_next = arc;

1163               arc_p = arc_n;

1164             }

1165           else

1166             {

1167               arc_p = arc;

1168               arc = arc_n;

1169             }

1170         }

1171         }

1172       blk->succ = start;

1173     }

1174 

1175       /* Place it on the invalid chain, it will be ignored if that's

1176      wrong.  */

1177       blk->invalid_chain = 1;

1178       blk->chain = invalid_blocks;

1179       invalid_blocks = blk;

1180     }

1181 

1182   while (invalid_blocks || valid_blocks)

1183     {

1184       while ((blk = invalid_blocks))

1185     {

1186       gcov_type total = 0;

1187       const arc_t *arc;

1188 

1189       invalid_blocks = blk->chain;

1190       blk->invalid_chain = 0;

1191       if (!blk->num_succ)

1192         for (arc = blk->succ; arc; arc = arc->succ_next)

1193           total += arc->count;

1194       else if (!blk->num_pred)

1195         for (arc = blk->pred; arc; arc = arc->pred_next)

1196           total += arc->count;

1197       else

1198         continue;

1199 

1200       blk->count = total;

1201       blk->count_valid = 1;

1202       blk->chain = valid_blocks;

1203       blk->valid_chain = 1;

1204       valid_blocks = blk;

1205     }

1206       while ((blk = valid_blocks))

1207     {

1208       gcov_type total;

1209       arc_t *arc, *inv_arc;

1210 

1211       valid_blocks = blk->chain;

1212       blk->valid_chain = 0;

1213       if (blk->num_succ == 1)

1214         {

1215           block_t *dst;

1216 

1217           total = blk->count;

1218           inv_arc = NULL;

1219           for (arc = blk->succ; arc; arc = arc->succ_next)

1220         {

1221           total -= arc->count;

1222           if (!arc->count_valid)

1223             inv_arc = arc;

1224         }

1225           dst = inv_arc->dst;

1226           inv_arc->count_valid = 1;

1227           inv_arc->count = total;

1228           blk->num_succ--;

1229           dst->num_pred--;

1230           if (dst->count_valid)

1231         {

1232           if (dst->num_pred == 1 && !dst->valid_chain)

1233             {

1234               dst->chain = valid_blocks;

1235               dst->valid_chain = 1;

1236               valid_blocks = dst;

1237             }

1238         }

1239           else

1240         {

1241           if (!dst->num_pred && !dst->invalid_chain)

1242             {

1243               dst->chain = invalid_blocks;

1244               dst->invalid_chain = 1;

1245               invalid_blocks = dst;

1246             }

1247         }

1248         }

1249       if (blk->num_pred == 1)

1250         {

1251           block_t *src;

1252 

1253           total = blk->count;

1254           inv_arc = NULL;

1255           for (arc = blk->pred; arc; arc = arc->pred_next)

1256         {

1257           total -= arc->count;

1258           if (!arc->count_valid)

1259             inv_arc = arc;

1260         }

1261           src = inv_arc->src;

1262           inv_arc->count_valid = 1;

1263           inv_arc->count = total;

1264           blk->num_pred--;

1265           src->num_succ--;

1266           if (src->count_valid)

1267         {

1268           if (src->num_succ == 1 && !src->valid_chain)

1269             {

1270               src->chain = valid_blocks;

1271               src->valid_chain = 1;

1272               valid_blocks = src;

1273             }

1274         }

1275           else

1276         {

1277           if (!src->num_succ && !src->invalid_chain)

1278             {

1279               src->chain = invalid_blocks;

1280               src->invalid_chain = 1;

1281               invalid_blocks = src;

1282             }

1283         }

1284         }

1285     }

1286     }

1287 

1288   /* If the graph has been correctly solved, every block will have a

1289      valid count.  */

1290   for (ix = 0; ix < fn->num_blocks; ix++)

1291     if (!fn->blocks[ix].count_valid)

1292       {

1293     fnotice (stderr, "%s:graph is unsolvable for '%s'\n",

1294          bbg_file_name, fn->name);

1295     break;

1296       }

1297 }

1298 

1299 

1300 

1301 /* Increment totals in COVERAGE according to arc ARC.  */

1302 

1303 static void

1304 add_branch_counts (coverage_t *coverage, const arc_t *arc)

1305 {

1306   if (arc->is_call_non_return)

1307     {

1308       coverage->calls++;

1309       if (arc->src->count)

1310     coverage->calls_executed++;

1311     }

1312   else if (!arc->is_unconditional)

1313     {

1314       coverage->branches++;

1315       if (arc->src->count)

1316     coverage->branches_executed++;

1317       if (arc->count)

1318     coverage->branches_taken++;

1319     }

1320 }

1321 

1322 /* Format a HOST_WIDE_INT as either a percent ratio, or absolute

1323    count.  If dp >= 0, format TOP/BOTTOM * 100 to DP decimal places.

1324    If DP is zero, no decimal point is printed. Only print 100% when

1325    TOP==BOTTOM and only print 0% when TOP=0.  If dp < 0, then simply

1326    format TOP.  Return pointer to a static string.  */

1327 

1328 static char const *

1329 format_gcov (gcov_type top, gcov_type bottom, int dp)

1330 {

1331   static char buffer[20];

1332 

1333   if (dp >= 0)

1334     {

1335       float ratio = bottom ? (float)top / bottom : 0;

1336       int ix;

1337       unsigned limit = 100;

1338       unsigned percent;

1339 

1340       for (ix = dp; ix--; )

1341     limit *= 10;

1342 

1343       percent = (unsigned) (ratio * limit + (float)0.5);

1344       if (percent <= 0 && top)

1345     percent = 1;

1346       else if (percent >= limit && top != bottom)

1347     percent = limit - 1;

1348       ix = sprintf (buffer, "%.*u%%", dp + 1, percent);

1349       if (dp)

1350     {

1351       dp++;

1352       do

1353         {

1354           buffer[ix+1] = buffer[ix];

1355           ix--;

1356         }

1357       while (dp--);

1358       buffer[ix + 1] = '.';

1359     }

1360     }

1361   else

1362     sprintf (buffer, HOST_WIDEST_INT_PRINT_DEC, (HOST_WIDEST_INT)top);

1363 

1364   return buffer;

1365 }

1366 

1367 

1368 /* Output summary info for a function.  */

1369 

1370 static void

1371 function_summary (const coverage_t *coverage, const char *title)

1372 {

1373   fnotice (stdout, "%s '%s'\n", title, coverage->name);

1374 

1375   if (coverage->lines)

1376     fnotice (stdout, "Lines executed:%s of %d\n",

1377          format_gcov (coverage->lines_executed, coverage->lines, 2),

1378          coverage->lines);

1379   else

1380     fnotice (stdout, "No executable lines\n");

1381 

1382   if (flag_branches)

1383     {

1384       if (coverage->branches)

1385     {

1386       fnotice (stdout, "Branches executed:%s of %d\n",

1387            format_gcov (coverage->branches_executed,

1388                 coverage->branches, 2),

1389            coverage->branches);

1390       fnotice (stdout, "Taken at least once:%s of %d\n",

1391            format_gcov (coverage->branches_taken,

1392                 coverage->branches, 2),

1393            coverage->branches);

1394     }

1395       else

1396     fnotice (stdout, "No branches\n");

1397       if (coverage->calls)

1398     fnotice (stdout, "Calls executed:%s of %d\n",

1399          format_gcov (coverage->calls_executed, coverage->calls, 2),

1400          coverage->calls);

1401       else

1402     fnotice (stdout, "No calls\n");

1403     }

1404 }

1405 

1406 /* Generate an output file name. LONG_OUTPUT_NAMES and PRESERVE_PATHS

1407    affect name generation. With preserve_paths we create a filename

1408    from all path components of the source file, replacing '/' with

1409    '#', without it we simply take the basename component. With

1410    long_output_names we prepend the processed name of the input file

1411    to each output name (except when the current source file is the

1412    input file, so you don't get a double concatenation). The two

1413    components are separated by '##'. Also '.' filename components are

1414    removed and '..'  components are renamed to '^'.  */

1415 

1416 static char *

1417 make_gcov_file_name (const char *input_name, const char *src_name)

1418 {

1419   char *cptr;

1420   char *name = xmalloc (strlen (src_name) + strlen (input_name) + 10);

1421 

1422   name[0] = 0;

1423   if (flag_long_names && strcmp (src_name, input_name))

1424     {

1425       /* Generate the input filename part.  */

1426       cptr = flag_preserve_paths ? NULL : strrchr (input_name, '/');

1427       strcat (name, cptr ? cptr + 1 : input_name);

1428       strcat (name, "##");

1429     }

1430 

1431   /* Generate the source filename part.  */

1432   cptr = flag_preserve_paths ? NULL : strrchr (src_name, '/');

1433   strcat (name, cptr ? cptr + 1 : src_name);

1434 

1435   if (flag_preserve_paths)

1436     {

1437       /* Convert '/' to '#', remove '/./', convert '/../' to '/^/' */

1438       char *prev;

1439 

1440       for (cptr = name; (cptr = strchr ((prev = cptr), '/'));)

1441     {

1442       unsigned shift = 0;

1443 

1444       if (prev + 1 == cptr && prev[0] == '.')

1445         {

1446           /* Remove '.' */

1447           shift = 2;

1448         }

1449       else if (prev + 2 == cptr && prev[0] == '.' && prev[1] == '.')

1450         {

1451           /* Convert '..' */

1452           shift = 1;

1453           prev[1] = '^';

1454         }

1455       else

1456         *cptr++ = '#';

1457       if (shift)

1458         {

1459           cptr = prev;

1460           do

1461         prev[0] = prev[shift];

1462           while (*prev++);

1463         }

1464     }

1465     }

1466 

1467   strcat (name, ".gcov");

1468   return name;

1469 }

1470 

1471 /* Scan through the bb_data for each line in the block, increment

1472    the line number execution count indicated by the execution count of

1473    the appropriate basic block.  */

1474 

1475 static void

1476 add_line_counts (coverage_t *coverage, function_t *fn)

1477 {

1478   unsigned ix;

1479   line_t *line = NULL; /* This is propagated from one iteration to the

1480               next.  */

1481 

1482   /* Scan each basic block.  */

1483   for (ix = 0; ix != fn->num_blocks; ix++)

1484     {

1485       block_t *block = &fn->blocks[ix];

1486       unsigned *encoding;

1487       const source_t *src = NULL;

1488       unsigned jx;

1489 

1490       if (block->count && ix && ix + 1 != fn->num_blocks)

1491     fn->blocks_executed++;

1492       for (jx = 0, encoding = block->u.line.encoding;

1493        jx != block->u.line.num; jx++, encoding++)

1494     if (!*encoding)

1495       {

1496         unsigned src_n = *++encoding;

1497 

1498         for (src = sources; src->index != src_n; src = src->next)

1499           continue;

1500         jx++;

1501       }

1502     else

1503       {

1504         line = &src->lines[*encoding];

1505 

1506         if (coverage)

1507           {

1508         if (!line->exists)

1509           coverage->lines++;

1510         if (!line->count && block->count)

1511           coverage->lines_executed++;

1512           }

1513         line->exists = 1;

1514         line->count += block->count;

1515       }

1516       free (block->u.line.encoding);

1517       block->u.cycle.arc = NULL;

1518       block->u.cycle.ident = ~0U;

1519 

1520       if (!ix || ix + 1 == fn->num_blocks)

1521     /* Entry or exit block */;

1522       else if (flag_all_blocks)

1523     {

1524       line_t *block_line = line ? line : &fn->src->lines[fn->line];

1525 

1526       block->chain = block_line->u.blocks;

1527       block_line->u.blocks = block;

1528     }

1529       else if (flag_branches)

1530     {

1531       arc_t *arc;

1532 

1533       for (arc = block->succ; arc; arc = arc->succ_next)

1534         {

1535           arc->line_next = line->u.branches;

1536           line->u.branches = arc;

1537           if (coverage && !arc->is_unconditional)

1538         add_branch_counts (coverage, arc);

1539         }

1540     }

1541     }

1542   if (!line)

1543     fnotice (stderr, "%s:no lines for '%s'\n", bbg_file_name, fn->name);

1544 }

1545 

1546 /* Accumulate the line counts of a file.  */

1547 

1548 static void

1549 accumulate_line_counts (source_t *src)

1550 {

1551   line_t *line;

1552   function_t *fn, *fn_p, *fn_n;

1553   unsigned ix;

1554 

1555   /* Reverse the function order.  */

1556   for (fn = src->functions, fn_p = NULL; fn;

1557        fn_p = fn, fn = fn_n)

1558     {

1559       fn_n = fn->line_next;

1560       fn->line_next = fn_p;

1561     }

1562   src->functions = fn_p;

1563 

1564   for (ix = src->num_lines, line = src->lines; ix--; line++)

1565     {

1566       if (!flag_all_blocks)

1567     {

1568       arc_t *arc, *arc_p, *arc_n;

1569 

1570       /* Total and reverse the branch information.  */

1571       for (arc = line->u.branches, arc_p = NULL; arc;

1572            arc_p = arc, arc = arc_n)

1573         {

1574           arc_n = arc->line_next;

1575           arc->line_next = arc_p;

1576 

1577           add_branch_counts (&src->coverage, arc);

1578         }

1579       line->u.branches = arc_p;

1580     }

1581       else if (line->u.blocks)

1582     {

1583       /* The user expects the line count to be the number of times

1584          a line has been executed. Simply summing the block count

1585          will give an artificially high number.  The Right Thing

1586          is to sum the entry counts to the graph of blocks on this

1587          line, then find the elementary cycles of the local graph

1588          and add the transition counts of those cycles.  */

1589       block_t *block, *block_p, *block_n;

1590       gcov_type count = 0;

1591 

1592       /* Reverse the block information.  */

1593       for (block = line->u.blocks, block_p = NULL; block;

1594            block_p = block, block = block_n)

1595         {

1596           block_n = block->chain;

1597           block->chain = block_p;

1598           block->u.cycle.ident = ix;

1599         }

1600       line->u.blocks = block_p;

1601 

1602       /* Sum the entry arcs.  */

1603       for (block = line->u.blocks; block; block = block->chain)

1604         {

1605           arc_t *arc;

1606 

1607           for (arc = block->pred; arc; arc = arc->pred_next)

1608         {

1609           if (arc->src->u.cycle.ident != ix)

1610             count += arc->count;

1611           if (flag_branches)

1612             add_branch_counts (&src->coverage, arc);

1613         }

1614 

1615           /* Initialize the cs_count.  */

1616           for (arc = block->succ; arc; arc = arc->succ_next)

1617         arc->cs_count = arc->count;

1618         }

1619 

1620       /* Find the loops. This uses the algorithm described in

1621          Tiernan 'An Efficient Search Algorithm to Find the

1622          Elementary Circuits of a Graph', CACM Dec 1970. We hold

1623          the P array by having each block point to the arc that

1624          connects to the previous block. The H array is implicitly

1625          held because of the arc ordering, and the block's

1626          previous arc pointer.

1627 

1628          Although the algorithm is O(N^3) for highly connected

1629          graphs, at worst we'll have O(N^2), as most blocks have

1630          only one or two exits. Most graphs will be small.

1631 

1632          For each loop we find, locate the arc with the smallest

1633          transition count, and add that to the cumulative

1634          count.  Decrease flow over the cycle and remove the arc

1635          from consideration.  */

1636       for (block = line->u.blocks; block; block = block->chain)

1637         {

1638           block_t *head = block;

1639           arc_t *arc;

1640 

1641         next_vertex:;

1642           arc = head->succ;

1643         current_vertex:;

1644           while (arc)

1645         {

1646           block_t *dst = arc->dst;

1647           if (/* Already used that arc.  */

1648               arc->cycle

1649               /* Not to same graph, or before first vertex.  */

1650               || dst->u.cycle.ident != ix

1651               /* Already in path.  */

1652               || dst->u.cycle.arc)

1653             {

1654               arc = arc->succ_next;

1655               continue;

1656             }

1657 

1658           if (dst == block)

1659             {

1660               /* Found a closing arc.  */

1661               gcov_type cycle_count = arc->cs_count;

1662               arc_t *cycle_arc = arc;

1663               arc_t *probe_arc;

1664 

1665               /* Locate the smallest arc count of the loop.  */

1666               for (dst = head; (probe_arc = dst->u.cycle.arc);

1667                dst = probe_arc->src)

1668             if (cycle_count > probe_arc->cs_count)

1669               {

1670                 cycle_count = probe_arc->cs_count;

1671                 cycle_arc = probe_arc;

1672               }

1673 

1674               count += cycle_count;

1675               cycle_arc->cycle = 1;

1676 

1677               /* Remove the flow from the cycle.  */

1678               arc->cs_count -= cycle_count;

1679               for (dst = head; (probe_arc = dst->u.cycle.arc);

1680                dst = probe_arc->src)

1681             probe_arc->cs_count -= cycle_count;

1682 

1683               /* Unwind to the cyclic arc.  */

1684               while (head != cycle_arc->src)

1685             {

1686               arc = head->u.cycle.arc;

1687               head->u.cycle.arc = NULL;

1688               head = arc->src;

1689             }

1690               /* Move on.  */

1691               arc = arc->succ_next;

1692               continue;

1693             }

1694 

1695           /* Add new block to chain.  */

1696           dst->u.cycle.arc = arc;

1697           head = dst;

1698           goto next_vertex;

1699         }

1700           /* We could not add another vertex to the path. Remove

1701          the last vertex from the list.  */

1702           arc = head->u.cycle.arc;

1703           if (arc)

1704         {

1705           /* It was not the first vertex. Move onto next arc.  */

1706           head->u.cycle.arc = NULL;

1707           head = arc->src;

1708           arc = arc->succ_next;

1709           goto current_vertex;

1710         }

1711           /* Mark this block as unusable.  */

1712           block->u.cycle.ident = ~0U;

1713         }

1714 

1715       line->count = count;

1716     }

1717 

1718       if (line->exists)

1719     {

1720       src->coverage.lines++;

1721       if (line->count)

1722         src->coverage.lines_executed++;

1723     }

1724     }

1725 }

1726 

1727 /* Output information about ARC number IX.  Returns nonzero if

1728    anything is output.  */

1729 

1730 static int

1731 output_branch_count (FILE *gcov_file, int ix, const arc_t *arc)

1732 {

1733 

1734   if (arc->is_call_non_return)

1735     {

1736       if (arc->src->count)

1737     {

1738       fnotice (gcov_file, "call   %2d returned %s\n", ix,

1739            format_gcov (arc->src->count - arc->count,

1740                 arc->src->count, -flag_counts));

1741     }

1742       else

1743     fnotice (gcov_file, "call   %2d never executed\n", ix);

1744     }

1745   else if (!arc->is_unconditional)

1746     {

1747       if (arc->src->count)

1748     fnotice (gcov_file, "branch %2d taken %s%s\n", ix,

1749          format_gcov (arc->count, arc->src->count, -flag_counts),

1750          arc->fall_through ? " (fallthrough)" : "");

1751       else

1752     fnotice (gcov_file, "branch %2d never executed\n", ix);

1753     }

1754   else if (flag_unconditional && !arc->dst->is_call_return)

1755     {

1756       if (arc->src->count)

1757     fnotice (gcov_file, "unconditional %2d taken %s\n", ix,

1758          format_gcov (arc->count, arc->src->count, -flag_counts));

1759       else

1760     fnotice (gcov_file, "unconditional %2d never executed\n", ix);

1761     }

1762   else

1763     return 0;

1764   return 1;

1765 

1766 }

1767 

1768 /* Read in the source file one line at a time, and output that line to

1769    the gcov file preceded by its execution count and other

1770    information.  */

1771 

1772 static void

1773 output_lines (FILE *gcov_file, const source_t *src)

1774 {

1775   FILE *source_file;

1776   unsigned line_num;    /* current line number.  */

1777   const line_t *line;           /* current line info ptr.  */

1778   char string[STRING_SIZE];     /* line buffer.  */

1779   char const *retval = "";    /* status of source file reading.  */

1780   function_t *fn = NULL;

1781 

1782   fprintf (gcov_file, "%9s:%5d:Source:%s\n", "-", 0, src->name);

1783   fprintf (gcov_file, "%9s:%5d:Graph:%s\n", "-", 0, bbg_file_name);

1784   fprintf (gcov_file, "%9s:%5d:Data:%s\n", "-", 0, da_file_name);

1785   fprintf (gcov_file, "%9s:%5d:Runs:%u\n", "-", 0,

1786        object_summary.ctrs[GCOV_COUNTER_ARCS].runs);

1787   fprintf (gcov_file, "%9s:%5d:Programs:%u\n", "-", 0, program_count);

1788 

1789   source_file = fopen (src->name, "r");

1790   if (!source_file)

1791     {

1792       fnotice (stderr, "%s:cannot open source file\n", src->name);

1793       retval = NULL;

1794     }

1795   else

1796     {

1797       struct stat status;

1798 

1799       if (!fstat (fileno (source_file), &status)

1800       && status.st_mtime > bbg_file_time)

1801     {

1802       fnotice (stderr, "%s:source file is newer than graph file '%s'\n",

1803            src->name, bbg_file_name);

1804       fprintf (gcov_file, "%9s:%5d:Source is newer than graph\n",

1805            "-", 0);

1806     }

1807     }

1808 

1809   if (flag_branches)

1810     fn = src->functions;

1811 

1812   for (line_num = 1, line = &src->lines[line_num];

1813        line_num < src->num_lines; line_num++, line++)

1814     {

1815       for (; fn && fn->line == line_num; fn = fn->line_next)

1816     {

1817       arc_t *arc = fn->blocks[fn->num_blocks - 1].pred;

1818       gcov_type return_count = fn->blocks[fn->num_blocks - 1].count;

1819       

1820       for (; arc; arc = arc->pred_next)

1821         if (arc->fake)

1822           return_count -= arc->count;

1823       

1824       fprintf (gcov_file, "function %s", fn->name);

1825       fprintf (gcov_file, " called %s",

1826            format_gcov (fn->blocks[0].count, 0, -1));

1827       fprintf (gcov_file, " returned %s",

1828            format_gcov (return_count, fn->blocks[0].count, 0));

1829       fprintf (gcov_file, " blocks executed %s",

1830            format_gcov (fn->blocks_executed, fn->num_blocks - 2, 0));

1831       fprintf (gcov_file, "\n");

1832     }

1833 

1834       /* For lines which don't exist in the .bb file, print '-' before

1835      the source line.  For lines which exist but were never

1836      executed, print '#####' before the source line.  Otherwise,

1837      print the execution count before the source line.  There are

1838      16 spaces of indentation added before the source line so that

1839      tabs won't be messed up.  */

1840       fprintf (gcov_file, "%9s:%5u:",

1841            !line->exists ? "-" : !line->count ? "#####"

1842            : format_gcov (line->count, 0, -1), line_num);

1843 

1844       if (retval)

1845     {

1846       /* Copy source line.  */

1847       do

1848         {

1849           retval = fgets (string, STRING_SIZE, source_file);

1850           if (!retval)

1851         break;

1852           fputs (retval, gcov_file);

1853         }

1854       while (!retval[0] || retval[strlen (retval) - 1] != '\n');

1855     }

1856       if (!retval)

1857     fputs ("/*EOF*/\n", gcov_file);

1858 

1859       if (flag_all_blocks)

1860     {

1861       block_t *block;

1862       arc_t *arc;

1863       int ix, jx;

1864 

1865       for (ix = jx = 0, block = line->u.blocks; block;

1866            block = block->chain)

1867         {

1868           if (!block->is_call_return)

1869         fprintf (gcov_file, "%9s:%5u-block %2d\n",

1870              !line->exists ? "-" : !block->count ? "$$$$$"

1871              : format_gcov (block->count, 0, -1),

1872              line_num, ix++);

1873           if (flag_branches)

1874         for (arc = block->succ; arc; arc = arc->succ_next)

1875           jx += output_branch_count (gcov_file, jx, arc);

1876         }

1877     }

1878       else if (flag_branches)

1879     {

1880       int ix;

1881       arc_t *arc;

1882 

1883       for (ix = 0, arc = line->u.branches; arc; arc = arc->line_next)

1884         ix += output_branch_count (gcov_file, ix, arc);

1885     }

1886     }

1887 

1888   /* Handle all remaining source lines.  There may be lines after the

1889      last line of code.  */

1890   if (retval)

1891     {

1892       for (; (retval = fgets (string, STRING_SIZE, source_file)); line_num++)

1893     {

1894       fprintf (gcov_file, "%9s:%5u:%s", "-", line_num, retval);

1895 

1896       while (!retval[0] || retval[strlen (retval) - 1] != '\n')

1897         {

1898           retval = fgets (string, STRING_SIZE, source_file);

1899           if (!retval)

1900         break;

1901           fputs (retval, gcov_file);

1902         }

1903     }

1904     }

1905 

1906   if (source_file)

1907     fclose (source_file);

1908 }

View Code