摘自http://www.opensource.apple.com/source/gcc/gcc-5484/gcc/gcov.c
View Code
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 <nathan@codesourcery.com> 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 }
468
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
