1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ 2 /* decode-gcov.c gcov decoder program 3 * 4 * Copyright (C) 2003 Red Hat Inc. 5 * 6 * Partially derived from gcov, 7 * Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998, 8 * 1999, 2000, 2001, 2002 Free Software Foundation, Inc. 9 * 10 * This file is NOT licensed under the Academic Free License 11 * as it is largely derived from gcov.c and gcov-io.h in the 12 * gcc source code. 13 * 14 * This program is free software; you can redistribute it and/or modify 15 * it under the terms of the GNU General Public License as published by 16 * the Free Software Foundation; either version 2 of the License, or 17 * (at your option) any later version. 18 * 19 * This program is distributed in the hope that it will be useful, 20 * but WITHOUT ANY WARRANTY; without even the implied warranty of 21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 22 * GNU General Public License for more details. 23 * 24 * You should have received a copy of the GNU General Public License 25 * along with this program; if not, write to the Free Software 26 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 27 * 28 */ 29 30 #include <config.h> 31 #define DBUS_COMPILATION /* cheat */ 32 #include <dbus/dbus-list.h> 33 #include <dbus/dbus-string.h> 34 #include <dbus/dbus-sysdeps.h> 35 #include <dbus/dbus-marshal.h> 36 #include <dbus/dbus-hash.h> 37 #undef DBUS_COMPILATION 38 #include <stdio.h> 39 #include <stdlib.h> 40 #include <string.h> 41 42 #ifndef DBUS_HAVE_INT64 43 #error "gcov support can't be built without 64-bit integer support" 44 #endif 45 46 static void 47 die (const char *message) 48 { 49 fprintf (stderr, "%s", message); 50 exit (1); 51 } 52 53 /* This bizarro function is from gcov-io.h in gcc source tree */ 54 static int 55 fetch_long (long *dest, 56 const char *source, 57 size_t bytes) 58 { 59 long value = 0; 60 int i; 61 62 for (i = bytes - 1; (size_t) i > (sizeof (*dest) - 1); i--) 63 if (source[i] & ((size_t) i == (bytes - 1) ? 127 : 255 )) 64 return 1; 65 66 for (; i >= 0; i--) 67 value = value * 256 + (source[i] & ((size_t)i == (bytes - 1) ? 127 : 255)); 68 69 if ((source[bytes - 1] & 128) && (value > 0)) 70 value = - value; 71 72 *dest = value; 73 return 0; 74 } 75 76 static int 77 fetch_long64 (dbus_int64_t *dest, 78 const char *source, 79 size_t bytes) 80 { 81 dbus_int64_t value = 0; 82 int i; 83 84 for (i = bytes - 1; (size_t) i > (sizeof (*dest) - 1); i--) 85 if (source[i] & ((size_t) i == (bytes - 1) ? 127 : 255 )) 86 return 1; 87 88 for (; i >= 0; i--) 89 value = value * 256 + (source[i] & ((size_t)i == (bytes - 1) ? 127 : 255)); 90 91 if ((source[bytes - 1] & 128) && (value > 0)) 92 value = - value; 93 94 *dest = value; 95 return 0; 96 } 97 98 #define BB_FILENAME (-1) 99 #define BB_FUNCTION (-2) 100 #define BB_ENDOFLIST 0 101 102 static dbus_bool_t 103 string_get_int (const DBusString *str, 104 int start, 105 long *val) 106 { 107 const char *p; 108 109 if ((_dbus_string_get_length (str) - start) < 4) 110 return FALSE; 111 112 p = _dbus_string_get_const_data (str); 113 114 p += start; 115 116 fetch_long (val, p, 4); 117 118 return TRUE; 119 } 120 121 static dbus_bool_t 122 string_get_int64 (const DBusString *str, 123 int start, 124 dbus_int64_t *val) 125 { 126 const char *p; 127 128 if ((_dbus_string_get_length (str) - start) < 8) 129 return FALSE; 130 131 p = _dbus_string_get_const_data (str); 132 133 p += start; 134 135 fetch_long64 (val, p, 8); 136 137 return TRUE; 138 } 139 140 static dbus_bool_t 141 string_get_string (const DBusString *str, 142 int start, 143 long terminator, 144 DBusString *val, 145 int *end) 146 { 147 int i; 148 long n; 149 150 i = start; 151 while (string_get_int (str, i, &n)) 152 { 153 unsigned char b; 154 155 i += 4; 156 157 if (n == terminator) 158 break; 159 160 b = n & 0xff; 161 if (b) 162 { 163 _dbus_string_append_byte (val, b); 164 b = (n >> 8) & 0xff; 165 if (b) 166 { 167 _dbus_string_append_byte (val, b); 168 b = (n >> 16) & 0xff; 169 if (b) 170 { 171 _dbus_string_append_byte (val, b); 172 b = (n >> 24) & 0xff; 173 if (b) 174 _dbus_string_append_byte (val, b); 175 } 176 } 177 } 178 } 179 180 *end = i; 181 182 return TRUE; 183 } 184 185 #ifdef DBUS_HAVE_GCC33_GCOV 186 /* In gcc33 .bbg files, there's a function name of the form: 187 * -1, length, name (padded to 4), -1, checksum 188 */ 189 static dbus_bool_t 190 string_get_function (const DBusString *str, 191 int start, 192 DBusString *funcname, 193 int *checksum, 194 int *next) 195 { 196 int end; 197 long val; 198 int i; 199 200 i = start; 201 202 if (!string_get_int (str, i, &val)) 203 die ("no room for -1 before function name\n"); 204 205 i += 4; 206 207 if (val != -1) 208 die ("value before function name is not -1\n"); 209 210 if (!string_get_int (str, i, &val)) 211 die ("no length found for function name\n"); 212 213 i += 4; 214 215 end = i + val; 216 if (end > _dbus_string_get_length (str)) 217 die ("Function name length points past end of file\n"); 218 219 if (!_dbus_string_append (funcname, 220 _dbus_string_get_const_data (str) + i)) 221 die ("no memory\n"); 222 223 /* skip alignment padding the length doesn't include the nul so add 1 224 */ 225 i = _DBUS_ALIGN_VALUE (end + 1, 4); 226 227 if (!string_get_int (str, i, &val) || 228 val != -1) 229 die ("-1 at end of function name not found\n"); 230 231 i += 4; 232 233 if (!string_get_int (str, i, &val)) 234 die ("no checksum found at end of function name\n"); 235 236 i += 4; 237 238 *checksum = val; 239 240 *next = i; 241 242 return TRUE; 243 } 244 #endif /* DBUS_HAVE_GCC33_GCOV */ 245 246 static void 247 dump_bb_file (const DBusString *contents) 248 { 249 int i; 250 long val; 251 int n_functions; 252 253 n_functions = 0; 254 i = 0; 255 while (string_get_int (contents, i, &val)) 256 { 257 i += 4; 258 259 switch (val) 260 { 261 case BB_FILENAME: 262 { 263 DBusString f; 264 265 if (!_dbus_string_init (&f)) 266 die ("no memory\n"); 267 268 if (string_get_string (contents, i, 269 BB_FILENAME, 270 &f, &i)) 271 { 272 printf ("File %s\n", _dbus_string_get_const_data (&f)); 273 } 274 _dbus_string_free (&f); 275 } 276 break; 277 case BB_FUNCTION: 278 { 279 DBusString f; 280 if (!_dbus_string_init (&f)) 281 die ("no memory\n"); 282 283 if (string_get_string (contents, i, 284 BB_FUNCTION, 285 &f, &i)) 286 { 287 printf ("Function %s\n", _dbus_string_get_const_data (&f)); 288 } 289 _dbus_string_free (&f); 290 291 n_functions += 1; 292 } 293 break; 294 case BB_ENDOFLIST: 295 printf ("End of block\n"); 296 break; 297 default: 298 printf ("Line %ld\n", val); 299 break; 300 } 301 } 302 303 printf ("%d functions in file\n", n_functions); 304 } 305 306 #define FLAG_ON_TREE 0x1 307 #define FLAG_FAKE 0x2 308 #define FLAG_FALL_THROUGH 0x4 309 310 static void 311 dump_bbg_file (const DBusString *contents) 312 { 313 int i; 314 long val; 315 int n_functions; 316 int n_arcs; 317 int n_blocks; 318 int n_arcs_off_tree; 319 320 n_arcs_off_tree = 0; 321 n_blocks = 0; 322 n_arcs = 0; 323 n_functions = 0; 324 i = 0; 325 while (i < _dbus_string_get_length (contents)) 326 { 327 long n_blocks_in_func; 328 long n_arcs_in_func; 329 int j; 330 331 #ifdef DBUS_HAVE_GCC33_GCOV 332 /* In gcc33 .bbg files, there's a function name of the form: 333 * -1, length, name (padded to 4), -1, checksum 334 * after that header on each function description, it's 335 * the same as in gcc32 336 */ 337 338 { 339 DBusString funcname; 340 int checksum; 341 342 if (!_dbus_string_init (&funcname)) 343 die ("no memory\n"); 344 345 if (!string_get_function (contents, i, 346 &funcname, &checksum, &i)) 347 die ("could not read function name\n"); 348 349 printf ("Function name is \"%s\" checksum %d\n", 350 _dbus_string_get_const_data (&funcname), 351 checksum); 352 353 _dbus_string_free (&funcname); 354 } 355 #endif /* DBUS_HAVE_GCC33_GCOV */ 356 357 if (!string_get_int (contents, i, &val)) 358 die ("no count of blocks in func found\n"); 359 360 i += 4; 361 362 n_blocks_in_func = val; 363 364 if (!string_get_int (contents, i, &n_arcs_in_func)) 365 break; 366 367 i += 4; 368 369 printf ("Function has %ld blocks and %ld arcs\n", 370 n_blocks_in_func, n_arcs_in_func); 371 372 n_functions += 1; 373 n_blocks += n_blocks_in_func; 374 n_arcs += n_arcs_in_func; 375 376 j = 0; 377 while (j < n_blocks_in_func) 378 { 379 long n_arcs_in_block; 380 int k; 381 382 if (!string_get_int (contents, i, &n_arcs_in_block)) 383 break; 384 385 i += 4; 386 387 printf (" Block has %ld arcs\n", n_arcs_in_block); 388 389 k = 0; 390 while (k < n_arcs_in_block) 391 { 392 long destination_block; 393 long flags; 394 395 if (!string_get_int (contents, i, &destination_block)) 396 break; 397 398 i += 4; 399 400 if (!string_get_int (contents, i, &flags)) 401 break; 402 403 i += 4; 404 405 printf (" Arc has destination block %ld flags 0x%lx\n", 406 destination_block, flags); 407 408 if ((flags & FLAG_ON_TREE) == 0) 409 n_arcs_off_tree += 1; 410 411 ++k; 412 } 413 414 if (k < n_arcs_in_block) 415 break; 416 417 ++j; 418 } 419 420 if (j < n_blocks_in_func) 421 break; 422 423 if (!string_get_int (contents, i, &val)) 424 break; 425 426 i += 4; 427 428 if (val != -1) 429 die ("-1 separator not found\n"); 430 } 431 432 printf ("%d functions %d blocks %d arcs %d off-tree arcs in file\n", 433 n_functions, n_blocks, n_arcs, n_arcs_off_tree); 434 } 435 436 #ifndef DBUS_HAVE_GCC33_GCOV 437 438 /* gcc 3.2 version: 439 * The da file contains first a count of arcs in the file, 440 * then a count of executions for all "off tree" arcs 441 * in the file. 442 */ 443 static void 444 dump_da_file (const DBusString *contents) 445 { 446 int i; 447 dbus_int64_t val; 448 int n_arcs; 449 int claimed_n_arcs; 450 451 i = 0; 452 if (!string_get_int64 (contents, i, &val)) 453 return; 454 455 i += 8; 456 457 printf ("%ld arcs in file\n", (long) val); 458 claimed_n_arcs = val; 459 460 n_arcs = 0; 461 while (string_get_int64 (contents, i, &val)) 462 { 463 i += 8; 464 465 printf ("%ld executions of arc %d\n", 466 (long) val, n_arcs); 467 468 ++n_arcs; 469 } 470 471 if (n_arcs != claimed_n_arcs) 472 { 473 printf ("File claimed to have %d arcs but only had %d\n", 474 claimed_n_arcs, n_arcs); 475 } 476 } 477 478 #else /* DBUS_HAVE_GCC33_GCOV */ 479 480 /* gcc 3.3 version: 481 * The da file is more complex than 3.2. 482 * 483 * We have a magic value of "-123" only it isn't really 484 * -123, it's -123 as encoded by the crackass gcov-io.h 485 * routines. Anyway, 4 bytes. 486 * 487 * We then have: 488 * 489 * - 4 byte count of how many functions in the following list 490 * - 4 byte length of random extra data 491 * - the random extra data, just skip it, info pages have some 492 * details on what might be in there or see __bb_exit_func in gcc 493 * - then for each function (number of functions given above): 494 * . -1, length, funcname, alignment padding, -1 495 * . checksum 496 * . 4 byte number of arcs in function 497 * . 8 bytes each, a count of execution for each arc 498 * 499 * Now, the whole thing *starting with the magic* can repeat. 500 * This is caused by multiple runs of the profiled app appending 501 * to the file. 502 */ 503 static void 504 dump_da_file (const DBusString *contents) 505 { 506 int i; 507 dbus_int64_t v64; 508 long val; 509 int n_sections; 510 int total_functions; 511 512 total_functions = 0; 513 n_sections = 0; 514 515 i = 0; 516 while (i < _dbus_string_get_length (contents)) 517 { 518 int claimed_n_functions; 519 int n_functions; 520 int total_arcs; 521 522 printf (".da file section %d\n", n_sections); 523 524 if (!string_get_int (contents, i, &val)) 525 die ("no magic found in .da file\n"); 526 527 i += 4; 528 529 if (val != -123) 530 die ("wrong file magic in .da file\n"); 531 532 if (!string_get_int (contents, i, &val)) 533 die ("no function count in .da file\n"); 534 i += 4; 535 claimed_n_functions = val; 536 537 printf ("%d functions expected in section %d of .da file\n", 538 claimed_n_functions, n_sections); 539 540 if (!string_get_int (contents, i, &val)) 541 die ("no extra data length in .da file\n"); 542 543 i += 4; 544 545 i += val; 546 547 total_arcs = 0; 548 n_functions = 0; 549 while (n_functions < claimed_n_functions) 550 { 551 DBusString funcname; 552 int checksum; 553 int claimed_n_arcs; 554 int n_arcs; 555 556 if (!_dbus_string_init (&funcname)) 557 die ("no memory\n"); 558 559 if (!string_get_function (contents, i, 560 &funcname, &checksum, &i)) 561 die ("could not read function name\n"); 562 563 if (!string_get_int (contents, i, &val)) 564 die ("no arc count for function\n"); 565 566 i += 4; 567 claimed_n_arcs = val; 568 569 printf (" %d arcs in function %d %s checksum %d\n", 570 claimed_n_arcs, n_functions, 571 _dbus_string_get_const_data (&funcname), 572 checksum); 573 574 n_arcs = 0; 575 while (n_arcs < claimed_n_arcs) 576 { 577 if (!string_get_int64 (contents, i, &v64)) 578 die ("did not get execution count for arc\n"); 579 580 i += 8; 581 582 printf (" %ld executions of arc %d (total arcs %d)\n", 583 (long) v64, n_arcs, total_arcs + n_arcs); 584 585 ++n_arcs; 586 } 587 588 _dbus_string_free (&funcname); 589 590 total_arcs += n_arcs; 591 ++n_functions; 592 } 593 594 printf ("total of %d functions and %d arcs in section %d\n", 595 n_functions, total_arcs, n_sections); 596 597 total_functions += n_functions; 598 ++n_sections; 599 } 600 601 printf ("%d total function sections in %d total .da file sections\n", 602 total_functions, n_sections); 603 } 604 605 #endif /* DBUS_HAVE_GCC33_GCOV */ 606 607 typedef struct Arc Arc; 608 typedef struct Block Block; 609 typedef struct Function Function; 610 typedef struct File File; 611 typedef struct Line Line; 612 613 struct Arc 614 { 615 int source; 616 int target; 617 dbus_int64_t arc_count; 618 unsigned int count_valid : 1; 619 unsigned int on_tree : 1; 620 unsigned int fake : 1; 621 unsigned int fall_through : 1; 622 Arc *pred_next; 623 Arc *succ_next; 624 }; 625 626 struct Block 627 { 628 Arc *succ; 629 Arc *pred; 630 dbus_int64_t succ_count; 631 dbus_int64_t pred_count; 632 dbus_int64_t exec_count; 633 DBusList *lines; 634 unsigned int count_valid : 1; 635 unsigned int on_tree : 1; 636 unsigned int inside_dbus_build_tests : 1; 637 }; 638 639 struct Function 640 { 641 char *name; 642 int checksum; 643 Block *block_graph; 644 int n_blocks; 645 /* number of blocks in DBUS_BUILD_TESTS */ 646 int n_test_blocks; 647 int n_test_blocks_executed; 648 /* number of blocks outside DBUS_BUILD_TESTS */ 649 int n_nontest_blocks; 650 int n_nontest_blocks_executed; 651 /* Summary result flags */ 652 unsigned int unused : 1; 653 unsigned int inside_dbus_build_tests : 1; 654 unsigned int partial : 1; /* only some of the blocks were executed */ 655 }; 656 657 struct Line 658 { 659 int number; 660 char *text; 661 DBusList *blocks; 662 unsigned int inside_dbus_build_tests : 1; 663 unsigned int partial : 1; /* only some of the blocks were executed */ 664 }; 665 666 struct File 667 { 668 char *name; 669 Line *lines; 670 int n_lines; 671 DBusList *functions; 672 }; 673 674 static void 675 function_add_arc (Function *function, 676 long source, 677 long target, 678 long flags) 679 { 680 Arc *arc; 681 682 arc = dbus_new0 (Arc, 1); 683 if (arc == NULL) 684 die ("no memory\n"); 685 686 arc->target = target; 687 arc->source = source; 688 689 arc->succ_next = function->block_graph[source].succ; 690 function->block_graph[source].succ = arc; 691 function->block_graph[source].succ_count += 1; 692 693 arc->pred_next = function->block_graph[target].pred; 694 function->block_graph[target].pred = arc; 695 function->block_graph[target].pred_count += 1; 696 697 if ((flags & FLAG_ON_TREE) != 0) 698 arc->on_tree = TRUE; 699 700 if ((flags & FLAG_FAKE) != 0) 701 arc->fake = TRUE; 702 703 if ((flags & FLAG_FALL_THROUGH) != 0) 704 arc->fall_through = TRUE; 705 } 706 707 708 static Arc* 709 reverse_arcs (Arc *arc) 710 { 711 struct Arc *prev = 0; 712 struct Arc *next; 713 714 for ( ; arc; arc = next) 715 { 716 next = arc->succ_next; 717 arc->succ_next = prev; 718 prev = arc; 719 } 720 721 return prev; 722 } 723 724 static void 725 function_reverse_succ_arcs (Function *func) 726 { 727 /* Must reverse the order of all succ arcs, to ensure that they match 728 * the order of the data in the .da file. 729 */ 730 int i; 731 732 for (i = 0; i < func->n_blocks; i++) 733 if (func->block_graph[i].succ) 734 func->block_graph[i].succ = reverse_arcs (func->block_graph[i].succ); 735 } 736 737 static void 738 get_functions_from_bbg (const DBusString *contents, 739 DBusList **functions) 740 { 741 int i; 742 long val; 743 int n_functions; 744 int n_arcs; 745 int n_blocks; 746 int n_arcs_off_tree; 747 748 #if 0 749 printf ("Loading arcs and blocks from .bbg file\n"); 750 #endif 751 752 n_arcs_off_tree = 0; 753 n_blocks = 0; 754 n_arcs = 0; 755 n_functions = 0; 756 i = 0; 757 while (i < _dbus_string_get_length (contents)) 758 { 759 Function *func; 760 long n_blocks_in_func; 761 long n_arcs_in_func; 762 int j; 763 764 #ifdef DBUS_HAVE_GCC33_GCOV 765 DBusString funcname; 766 int checksum; 767 768 /* In gcc33 .bbg files, there's a function name of the form: 769 * -1, length, name (padded to 4), -1, checksum 770 * after that header on each function description, it's 771 * the same as in gcc32 772 */ 773 if (!_dbus_string_init (&funcname)) 774 die ("no memory\n"); 775 776 if (!string_get_function (contents, i, 777 &funcname, &checksum, &i)) 778 die ("could not read function name\n"); 779 #endif /* DBUS_HAVE_GCC33_GCOV */ 780 781 if (!string_get_int (contents, i, &val)) 782 break; 783 784 n_blocks_in_func = val; 785 786 i += 4; 787 788 if (!string_get_int (contents, i, &n_arcs_in_func)) 789 break; 790 791 i += 4; 792 793 n_functions += 1; 794 n_blocks += n_blocks_in_func; 795 n_arcs += n_arcs_in_func; 796 797 func = dbus_new0 (Function, 1); 798 if (func == NULL) 799 die ("no memory\n"); 800 801 #ifdef DBUS_HAVE_GCC33_GCOV 802 func->name = _dbus_strdup (_dbus_string_get_const_data (&funcname)); 803 func->checksum = checksum; 804 _dbus_string_free (&funcname); 805 #endif 806 807 func->block_graph = dbus_new0 (Block, n_blocks_in_func); 808 func->n_blocks = n_blocks_in_func; 809 810 j = 0; 811 while (j < n_blocks_in_func) 812 { 813 long n_arcs_in_block; 814 int k; 815 816 if (!string_get_int (contents, i, &n_arcs_in_block)) 817 break; 818 819 i += 4; 820 821 k = 0; 822 while (k < n_arcs_in_block) 823 { 824 long destination_block; 825 long flags; 826 827 if (!string_get_int (contents, i, &destination_block)) 828 break; 829 830 i += 4; 831 832 if (!string_get_int (contents, i, &flags)) 833 break; 834 835 i += 4; 836 837 if ((flags & FLAG_ON_TREE) == 0) 838 n_arcs_off_tree += 1; 839 840 function_add_arc (func, j, destination_block, 841 flags); 842 843 ++k; 844 } 845 846 if (k < n_arcs_in_block) 847 break; 848 849 ++j; 850 } 851 852 if (j < n_blocks_in_func) 853 break; 854 855 function_reverse_succ_arcs (func); 856 857 if (!_dbus_list_append (functions, func)) 858 die ("no memory\n"); 859 860 if (!string_get_int (contents, i, &val)) 861 break; 862 863 i += 4; 864 865 if (val != -1) 866 die ("-1 separator not found in .bbg file\n"); 867 } 868 869 #if 0 870 printf ("%d functions %d blocks %d arcs %d off-tree arcs in file\n", 871 n_functions, n_blocks, n_arcs, n_arcs_off_tree); 872 #endif 873 874 _dbus_assert (n_functions == _dbus_list_get_length (functions)); 875 } 876 877 #ifdef DBUS_HAVE_GCC33_GCOV 878 static void 879 add_counts_from_da (const DBusString *contents, 880 DBusList **functions) 881 { 882 int i; 883 dbus_int64_t v64; 884 long val; 885 int n_sections; 886 DBusList *link; 887 Function *current_func; 888 int current_block; 889 Arc *current_arc; 890 891 n_sections = 0; 892 893 i = 0; 894 while (i < _dbus_string_get_length (contents)) 895 { 896 int claimed_n_functions; 897 int n_functions; 898 899 if (!string_get_int (contents, i, &val)) 900 die ("no magic found in .da file\n"); 901 902 i += 4; 903 904 if (val != -123) 905 die ("wrong file magic in .da file\n"); 906 907 if (!string_get_int (contents, i, &val)) 908 die ("no function count in .da file\n"); 909 i += 4; 910 claimed_n_functions = val; 911 912 if (!string_get_int (contents, i, &val)) 913 die ("no extra data length in .da file\n"); 914 915 i += 4; 916 917 i += val; 918 919 link = _dbus_list_get_first_link (functions); 920 if (link == NULL) 921 goto no_more_functions; 922 923 n_functions = 0; 924 while (n_functions < claimed_n_functions && link != NULL) 925 { 926 DBusString funcname; 927 int checksum; 928 int claimed_n_arcs; 929 int n_arcs; 930 931 current_func = link->data; 932 current_block = 0; 933 current_arc = current_func->block_graph[current_block].succ; 934 935 if (!_dbus_string_init (&funcname)) 936 die ("no memory\n"); 937 938 if (!string_get_function (contents, i, 939 &funcname, &checksum, &i)) 940 die ("could not read function name\n"); 941 942 if (!_dbus_string_equal_c_str (&funcname, current_func->name)) 943 { 944 fprintf (stderr, "Expecting .da info for %s but got %s\n", 945 current_func->name, 946 _dbus_string_get_const_data (&funcname)); 947 exit (1); 948 } 949 950 if (checksum != current_func->checksum) 951 die (".da file checksum doesn't match checksum from .bbg file\n"); 952 953 if (!string_get_int (contents, i, &val)) 954 die ("no arc count for function\n"); 955 956 i += 4; 957 claimed_n_arcs = val; 958 959 /* For each arc in the profile, find the corresponding 960 * arc in the function and increment its count 961 */ 962 n_arcs = 0; 963 while (n_arcs < claimed_n_arcs) 964 { 965 if (!string_get_int64 (contents, i, &v64)) 966 die ("did not get execution count for arc\n"); 967 968 i += 8; 969 970 /* Find the next arc in the function that isn't on tree */ 971 while (current_arc == NULL || 972 current_arc->on_tree) 973 { 974 if (current_arc == NULL) 975 { 976 ++current_block; 977 978 if (current_block >= current_func->n_blocks) 979 die ("too many blocks in function\n"); 980 981 current_arc = current_func->block_graph[current_block].succ; 982 } 983 else 984 { 985 current_arc = current_arc->succ_next; 986 } 987 } 988 989 _dbus_assert (current_arc != NULL); 990 _dbus_assert (!current_arc->on_tree); 991 992 current_arc->arc_count = v64; 993 current_arc->count_valid = TRUE; 994 current_func->block_graph[current_block].succ_count -= 1; 995 current_func->block_graph[current_arc->target].pred_count -= 1; 996 997 ++n_arcs; 998 999 current_arc = current_arc->succ_next; 1000 } 1001 1002 _dbus_string_free (&funcname); 1003 1004 link = _dbus_list_get_next_link (functions, link); 1005 ++n_functions; 1006 1007 if (link == NULL && n_functions < claimed_n_functions) 1008 { 1009 fprintf (stderr, "Ran out of functions loading .da file\n"); 1010 goto no_more_functions; 1011 } 1012 } 1013 1014 no_more_functions: 1015 1016 ++n_sections; 1017 } 1018 } 1019 #else /* DBUS_HAVE_GCC33_GCOV */ 1020 static void 1021 add_counts_from_da (const DBusString *contents, 1022 DBusList **functions) 1023 { 1024 int i; 1025 dbus_int64_t val; 1026 int n_arcs; 1027 int claimed_n_arcs; 1028 DBusList *link; 1029 Function *current_func; 1030 int current_block; 1031 Arc *current_arc; 1032 1033 #if 0 1034 printf ("Loading execution count for each arc from .da file\n"); 1035 #endif 1036 1037 i = 0; 1038 if (!string_get_int64 (contents, i, &val)) 1039 return; 1040 1041 i += 8; 1042 1043 claimed_n_arcs = val; 1044 1045 link = _dbus_list_get_first_link (functions); 1046 if (link == NULL) 1047 goto done; 1048 1049 current_func = link->data; 1050 current_block = 0; 1051 current_arc = current_func->block_graph[current_block].succ; 1052 1053 n_arcs = 0; 1054 while (string_get_int64 (contents, i, &val)) 1055 { 1056 i += 8; 1057 1058 while (current_arc == NULL || 1059 current_arc->on_tree) 1060 { 1061 if (current_arc == NULL) 1062 { 1063 ++current_block; 1064 1065 if (current_block == current_func->n_blocks) 1066 { 1067 link = _dbus_list_get_next_link (functions, link); 1068 if (link == NULL) 1069 { 1070 fprintf (stderr, "Ran out of functions loading .da file\n"); 1071 goto done; 1072 } 1073 current_func = link->data; 1074 current_block = 0; 1075 } 1076 1077 current_arc = current_func->block_graph[current_block].succ; 1078 } 1079 else 1080 { 1081 current_arc = current_arc->succ_next; 1082 } 1083 } 1084 1085 _dbus_assert (current_arc != NULL); 1086 _dbus_assert (!current_arc->on_tree); 1087 1088 current_arc->arc_count = val; 1089 current_arc->count_valid = TRUE; 1090 current_func->block_graph[current_block].succ_count -= 1; 1091 current_func->block_graph[current_arc->target].pred_count -= 1; 1092 1093 ++n_arcs; 1094 1095 current_arc = current_arc->succ_next; 1096 } 1097 1098 done: 1099 1100 if (n_arcs != claimed_n_arcs) 1101 { 1102 fprintf (stderr, "File claimed to have %d arcs but only had %d\n", 1103 claimed_n_arcs, n_arcs); 1104 exit (1); 1105 } 1106 1107 #if 0 1108 printf ("%d arcs in file\n", n_arcs); 1109 #endif 1110 } 1111 #endif 1112 1113 static void 1114 function_solve_graph (Function *func) 1115 { 1116 int passes, changes; 1117 dbus_int64_t total; 1118 int i; 1119 Arc *arc; 1120 Block *block_graph; 1121 int n_blocks; 1122 1123 #if 0 1124 printf ("Solving function graph\n"); 1125 #endif 1126 1127 n_blocks = func->n_blocks; 1128 block_graph = func->block_graph; 1129 1130 /* For every block in the file, 1131 - if every exit/entrance arc has a known count, then set the block count 1132 - if the block count is known, and every exit/entrance arc but one has 1133 a known execution count, then set the count of the remaining arc 1134 1135 As arc counts are set, decrement the succ/pred count, but don't delete 1136 the arc, that way we can easily tell when all arcs are known, or only 1137 one arc is unknown. */ 1138 1139 /* The order that the basic blocks are iterated through is important. 1140 Since the code that finds spanning trees starts with block 0, low numbered 1141 arcs are put on the spanning tree in preference to high numbered arcs. 1142 Hence, most instrumented arcs are at the end. Graph solving works much 1143 faster if we propagate numbers from the end to the start. 1144 1145 This takes an average of slightly more than 3 passes. */ 1146 1147 changes = 1; 1148 passes = 0; 1149 while (changes) 1150 { 1151 passes++; 1152 changes = 0; 1153 1154 for (i = n_blocks - 1; i >= 0; i--) 1155 { 1156 if (! block_graph[i].count_valid) 1157 { 1158 if (block_graph[i].succ_count == 0) 1159 { 1160 total = 0; 1161 for (arc = block_graph[i].succ; arc; 1162 arc = arc->succ_next) 1163 total += arc->arc_count; 1164 block_graph[i].exec_count = total; 1165 block_graph[i].count_valid = 1; 1166 changes = 1; 1167 } 1168 else if (block_graph[i].pred_count == 0) 1169 { 1170 total = 0; 1171 for (arc = block_graph[i].pred; arc; 1172 arc = arc->pred_next) 1173 total += arc->arc_count; 1174 block_graph[i].exec_count = total; 1175 block_graph[i].count_valid = 1; 1176 changes = 1; 1177 } 1178 } 1179 if (block_graph[i].count_valid) 1180 { 1181 if (block_graph[i].succ_count == 1) 1182 { 1183 total = 0; 1184 /* One of the counts will be invalid, but it is zero, 1185 so adding it in also doesn't hurt. */ 1186 for (arc = block_graph[i].succ; arc; 1187 arc = arc->succ_next) 1188 total += arc->arc_count; 1189 /* Calculate count for remaining arc by conservation. */ 1190 total = block_graph[i].exec_count - total; 1191 /* Search for the invalid arc, and set its count. */ 1192 for (arc = block_graph[i].succ; arc; 1193 arc = arc->succ_next) 1194 if (! arc->count_valid) 1195 break; 1196 if (! arc) 1197 die ("arc == NULL\n"); 1198 arc->count_valid = 1; 1199 arc->arc_count = total; 1200 block_graph[i].succ_count -= 1; 1201 1202 block_graph[arc->target].pred_count -= 1; 1203 changes = 1; 1204 } 1205 if (block_graph[i].pred_count == 1) 1206 { 1207 total = 0; 1208 /* One of the counts will be invalid, but it is zero, 1209 so adding it in also doesn't hurt. */ 1210 for (arc = block_graph[i].pred; arc; 1211 arc = arc->pred_next) 1212 total += arc->arc_count; 1213 /* Calculate count for remaining arc by conservation. */ 1214 total = block_graph[i].exec_count - total; 1215 /* Search for the invalid arc, and set its count. */ 1216 for (arc = block_graph[i].pred; arc; 1217 arc = arc->pred_next) 1218 if (! arc->count_valid) 1219 break; 1220 if (! arc) 1221 die ("arc == NULL\n"); 1222 arc->count_valid = 1; 1223 arc->arc_count = total; 1224 block_graph[i].pred_count -= 1; 1225 1226 block_graph[arc->source].succ_count -= 1; 1227 changes = 1; 1228 } 1229 } 1230 } 1231 } 1232 1233 /* If the graph has been correctly solved, every block will have a 1234 * succ and pred count of zero. 1235 */ 1236 { 1237 dbus_bool_t header = FALSE; 1238 for (i = 0; i < n_blocks; i++) 1239 { 1240 if (block_graph[i].succ_count || block_graph[i].pred_count) 1241 { 1242 if (!header) 1243 { 1244 fprintf (stderr, "WARNING: Block graph solved incorrectly for function %s\n", 1245 func->name); 1246 fprintf (stderr, " this error reflects a bug in decode-gcov.c or perhaps bogus data\n"); 1247 header = TRUE; 1248 } 1249 fprintf (stderr, " block %d has succ_count = %d pred_count = %d\n", 1250 i, (int) block_graph[i].succ_count, (int) block_graph[i].pred_count); 1251 } 1252 } 1253 } 1254 } 1255 1256 static void 1257 solve_graphs (DBusList **functions) 1258 { 1259 DBusList *link; 1260 1261 link = _dbus_list_get_first_link (functions); 1262 while (link != NULL) 1263 { 1264 Function *func = link->data; 1265 1266 function_solve_graph (func); 1267 1268 link = _dbus_list_get_next_link (functions, link); 1269 } 1270 } 1271 1272 static void 1273 load_functions_for_c_file (const DBusString *filename, 1274 DBusList **functions) 1275 { 1276 DBusString bbg_filename; 1277 DBusString da_filename; 1278 DBusString gcno_filename; 1279 DBusString gcda_filename; 1280 DBusString contents; 1281 DBusString *name; 1282 DBusError error; 1283 1284 /* With latest gcc it's .gcno instead of .bbg and 1285 * gcda instead of .da 1286 */ 1287 1288 dbus_error_init (&error); 1289 1290 if (!_dbus_string_init (&bbg_filename) || 1291 !_dbus_string_init (&da_filename) || 1292 !_dbus_string_init (&gcno_filename) || 1293 !_dbus_string_init (&gcda_filename) || 1294 !_dbus_string_copy (filename, 0, &bbg_filename, 0) || 1295 !_dbus_string_copy (filename, 0, &da_filename, 0) || 1296 !_dbus_string_copy (filename, 0, &gcno_filename, 0) || 1297 !_dbus_string_copy (filename, 0, &gcda_filename, 0) || 1298 !_dbus_string_init (&contents)) 1299 die ("no memory\n"); 1300 1301 _dbus_string_shorten (&bbg_filename, 2); 1302 _dbus_string_shorten (&da_filename, 2); 1303 1304 if (!_dbus_string_append (&bbg_filename, ".bbg") || 1305 !_dbus_string_append (&da_filename, ".da") || 1306 !_dbus_string_append (&bbg_filename, ".gcno") || 1307 !_dbus_string_append (&bbg_filename, ".gcda")) 1308 die ("no memory\n"); 1309 1310 if (_dbus_file_exists (_dbus_string_get_const_data (&gcno_filename))) 1311 name = &gcno_filename; 1312 else 1313 name = &bbg_filename; 1314 1315 if (!_dbus_file_get_contents (&contents, name, 1316 &error)) 1317 { 1318 fprintf (stderr, "Could not open file: %s\n", 1319 error.message); 1320 exit (1); 1321 } 1322 1323 get_functions_from_bbg (&contents, functions); 1324 1325 _dbus_string_set_length (&contents, 0); 1326 1327 if (_dbus_file_exists (_dbus_string_get_const_data (&gcda_filename))) 1328 name = &gcda_filename; 1329 else 1330 name = &da_filename; 1331 1332 if (!_dbus_file_get_contents (&contents, name, 1333 &error)) 1334 { 1335 /* Try .libs/file.da */ 1336 int slash; 1337 1338 if (_dbus_string_find_byte_backward (name, 1339 _dbus_string_get_length (name), 1340 '/', 1341 &slash)) 1342 { 1343 DBusString libs; 1344 _dbus_string_init_const (&libs, "/.libs"); 1345 1346 if (!_dbus_string_copy (&libs, 0, name, slash)) 1347 die ("no memory"); 1348 1349 dbus_error_free (&error); 1350 if (!_dbus_file_get_contents (&contents, name, 1351 &error)) 1352 { 1353 fprintf (stderr, "Could not open file: %s\n", 1354 error.message); 1355 exit (1); 1356 } 1357 } 1358 else 1359 { 1360 fprintf (stderr, "Could not open file: %s\n", 1361 error.message); 1362 exit (1); 1363 } 1364 } 1365 1366 add_counts_from_da (&contents, functions); 1367 1368 solve_graphs (functions); 1369 1370 _dbus_string_free (&contents); 1371 _dbus_string_free (&da_filename); 1372 _dbus_string_free (&bbg_filename); 1373 } 1374 1375 static void 1376 get_lines_from_bb_file (const DBusString *contents, 1377 File *fl) 1378 { 1379 int i; 1380 long val; 1381 int n_functions; 1382 dbus_bool_t in_our_file; 1383 DBusList *link; 1384 Function *func; 1385 int block; 1386 1387 #if 0 1388 printf ("Getting line numbers for blocks from .bb file\n"); 1389 #endif 1390 1391 /* There's this "filename" field in the .bb file which 1392 * mysteriously comes *after* the first function in the 1393 * file in the .bb file; and every .bb file seems to 1394 * have only one filename. I don't understand 1395 * what's going on here, so just set in_our_file = TRUE 1396 * at the start categorically. 1397 */ 1398 1399 block = 0; 1400 func = NULL; 1401 in_our_file = TRUE; 1402 link = _dbus_list_get_first_link (&fl->functions); 1403 n_functions = 0; 1404 i = 0; 1405 while (string_get_int (contents, i, &val)) 1406 { 1407 i += 4; 1408 1409 switch (val) 1410 { 1411 case BB_FILENAME: 1412 { 1413 DBusString f; 1414 1415 if (!_dbus_string_init (&f)) 1416 die ("no memory\n"); 1417 1418 if (string_get_string (contents, i, 1419 BB_FILENAME, 1420 &f, &i)) 1421 { 1422 /* fl->name is a full path and the filename in .bb is 1423 * not. 1424 */ 1425 DBusString tmp_str; 1426 1427 _dbus_string_init_const (&tmp_str, fl->name); 1428 1429 if (_dbus_string_ends_with_c_str (&tmp_str, 1430 _dbus_string_get_const_data (&f))) 1431 in_our_file = TRUE; 1432 else 1433 in_our_file = FALSE; 1434 1435 #if 0 1436 fprintf (stderr, 1437 "File %s in .bb, looking for %s, in_our_file = %d\n", 1438 _dbus_string_get_const_data (&f), 1439 fl->name, 1440 in_our_file); 1441 #endif 1442 } 1443 _dbus_string_free (&f); 1444 } 1445 break; 1446 case BB_FUNCTION: 1447 { 1448 DBusString f; 1449 if (!_dbus_string_init (&f)) 1450 die ("no memory\n"); 1451 1452 if (string_get_string (contents, i, 1453 BB_FUNCTION, 1454 &f, &i)) 1455 { 1456 #if 0 1457 fprintf (stderr, "Function %s\n", _dbus_string_get_const_data (&f)); 1458 #endif 1459 1460 block = 0; 1461 1462 if (in_our_file) 1463 { 1464 if (link == NULL) 1465 { 1466 fprintf (stderr, "No function object for function %s\n", 1467 _dbus_string_get_const_data (&f)); 1468 } 1469 else 1470 { 1471 func = link->data; 1472 link = _dbus_list_get_next_link (&fl->functions, link); 1473 1474 if (func->name == NULL) 1475 { 1476 if (!_dbus_string_copy_data (&f, &func->name)) 1477 die ("no memory\n"); 1478 } 1479 else 1480 { 1481 if (!_dbus_string_equal_c_str (&f, func->name)) 1482 { 1483 fprintf (stderr, "got function name \"%s\" (%d) from .bbg file, but \"%s\" (%d) from .bb file\n", 1484 func->name, strlen (func->name), 1485 _dbus_string_get_const_data (&f), 1486 _dbus_string_get_length (&f)); 1487 1488 } 1489 } 1490 } 1491 } 1492 } 1493 _dbus_string_free (&f); 1494 1495 n_functions += 1; 1496 } 1497 break; 1498 case BB_ENDOFLIST: 1499 block += 1; 1500 break; 1501 default: 1502 #if 0 1503 fprintf (stderr, "Line %ld\n", val); 1504 #endif 1505 1506 if (val >= fl->n_lines) 1507 { 1508 fprintf (stderr, "Line %ld but file only has %d lines\n", 1509 val, fl->n_lines); 1510 } 1511 else if (func != NULL) 1512 { 1513 val -= 1; /* To convert the 1-based line number to 0-based */ 1514 _dbus_assert (val >= 0); 1515 1516 if (block < func->n_blocks) 1517 { 1518 if (!_dbus_list_append (&func->block_graph[block].lines, 1519 &fl->lines[val])) 1520 die ("no memory\n"); 1521 1522 1523 if (!_dbus_list_append (&fl->lines[val].blocks, 1524 &func->block_graph[block])) 1525 die ("no memory\n"); 1526 } 1527 else 1528 { 1529 fprintf (stderr, "Line number for block %d but function only has %d blocks\n", 1530 block, func->n_blocks); 1531 } 1532 } 1533 else 1534 { 1535 fprintf (stderr, "Line %ld given outside of any function\n", 1536 val); 1537 } 1538 1539 break; 1540 } 1541 } 1542 1543 #if 0 1544 printf ("%d functions in file\n", n_functions); 1545 #endif 1546 } 1547 1548 1549 static void 1550 load_block_line_associations (const DBusString *filename, 1551 File *f) 1552 { 1553 DBusString bb_filename; 1554 DBusString contents; 1555 DBusError error; 1556 1557 dbus_error_init (&error); 1558 1559 if (!_dbus_string_init (&bb_filename) || 1560 !_dbus_string_copy (filename, 0, &bb_filename, 0) || 1561 !_dbus_string_init (&contents)) 1562 die ("no memory\n"); 1563 1564 _dbus_string_shorten (&bb_filename, 2); 1565 1566 if (!_dbus_string_append (&bb_filename, ".bb")) 1567 die ("no memory\n"); 1568 1569 if (!_dbus_file_get_contents (&contents, &bb_filename, 1570 &error)) 1571 { 1572 fprintf (stderr, "Could not open file: %s\n", 1573 error.message); 1574 exit (1); 1575 } 1576 1577 get_lines_from_bb_file (&contents, f); 1578 1579 _dbus_string_free (&contents); 1580 _dbus_string_free (&bb_filename); 1581 } 1582 1583 static int 1584 count_lines_in_string (const DBusString *str) 1585 { 1586 int n_lines; 1587 const char *p; 1588 const char *prev; 1589 const char *end; 1590 const char *last_line_end; 1591 1592 #if 0 1593 printf ("Counting lines in source file\n"); 1594 #endif 1595 1596 n_lines = 0; 1597 prev = NULL; 1598 p = _dbus_string_get_const_data (str); 1599 end = p + _dbus_string_get_length (str); 1600 last_line_end = p; 1601 while (p != end) 1602 { 1603 /* too lazy to handle \r\n as one linebreak */ 1604 if (*p == '\n' || *p == '\r') 1605 { 1606 ++n_lines; 1607 last_line_end = p + 1; 1608 } 1609 1610 prev = p; 1611 ++p; 1612 } 1613 1614 if (last_line_end != p) 1615 ++n_lines; 1616 1617 return n_lines; 1618 } 1619 1620 static void 1621 fill_line_content (const DBusString *str, 1622 Line *lines) 1623 { 1624 int n_lines; 1625 const char *p; 1626 const char *prev; 1627 const char *end; 1628 const char *last_line_end; 1629 1630 #if 0 1631 printf ("Saving contents of each line in source file\n"); 1632 #endif 1633 1634 n_lines = 0; 1635 prev = NULL; 1636 p = _dbus_string_get_const_data (str); 1637 end = p + _dbus_string_get_length (str); 1638 last_line_end = p; 1639 while (p != end) 1640 { 1641 if (*p == '\n' || *p == '\r') 1642 { 1643 lines[n_lines].text = dbus_malloc0 (p - last_line_end + 1); 1644 if (lines[n_lines].text == NULL) 1645 die ("no memory\n"); 1646 1647 memcpy (lines[n_lines].text, last_line_end, p - last_line_end); 1648 lines[n_lines].number = n_lines + 1; 1649 1650 ++n_lines; 1651 1652 last_line_end = p + 1; 1653 } 1654 1655 prev = p; 1656 ++p; 1657 } 1658 1659 if (p != last_line_end) 1660 { 1661 memcpy (lines[n_lines].text, last_line_end, p - last_line_end); 1662 ++n_lines; 1663 } 1664 } 1665 1666 static void 1667 mark_inside_dbus_build_tests (File *f) 1668 { 1669 int i; 1670 DBusList *link; 1671 int inside_depth; 1672 1673 inside_depth = 0; 1674 i = 0; 1675 while (i < f->n_lines) 1676 { 1677 Line *l = &f->lines[i]; 1678 dbus_bool_t is_verbose; 1679 1680 is_verbose = strstr (l->text, "_dbus_verbose") != NULL; 1681 1682 if (inside_depth == 0) 1683 { 1684 const char *a, *b; 1685 1686 a = strstr (l->text, "#if"); 1687 b = strstr (l->text, "DBUS_BUILD_TESTS"); 1688 if (a && b && (a < b)) 1689 inside_depth += 1; 1690 } 1691 else 1692 { 1693 if (strstr (l->text, "#if") != NULL) 1694 inside_depth += 1; 1695 else if (strstr (l->text, "#endif") != NULL) 1696 inside_depth -= 1; 1697 } 1698 1699 if (inside_depth > 0 || is_verbose) 1700 { 1701 /* Mark the line and its blocks */ 1702 DBusList *blink; 1703 1704 l->inside_dbus_build_tests = TRUE; 1705 1706 blink = _dbus_list_get_first_link (&l->blocks); 1707 while (blink != NULL) 1708 { 1709 Block *b = blink->data; 1710 1711 b->inside_dbus_build_tests = TRUE; 1712 1713 blink = _dbus_list_get_next_link (&l->blocks, blink); 1714 } 1715 } 1716 1717 ++i; 1718 } 1719 1720 /* Now mark functions where for all blocks that are associated 1721 * with a source line, the block is inside_dbus_build_tests. 1722 */ 1723 link = _dbus_list_get_first_link (&f->functions); 1724 while (link != NULL) 1725 { 1726 Function *func = link->data; 1727 1728 /* The issue is that some blocks aren't associated with a source line. 1729 * Assume they are inside/outside tests according to the source 1730 * line of the preceding block. For the first block, make it 1731 * match the first following block with a line associated. 1732 */ 1733 if (func->block_graph[0].lines == NULL) 1734 { 1735 /* find first following line */ 1736 i = 1; 1737 while (i < func->n_blocks) 1738 { 1739 if (func->block_graph[i].lines != NULL) 1740 { 1741 func->block_graph[0].inside_dbus_build_tests = 1742 func->block_graph[i].inside_dbus_build_tests; 1743 break; 1744 } 1745 1746 ++i; 1747 } 1748 } 1749 1750 /* Now mark all blocks but the first */ 1751 i = 1; 1752 while (i < func->n_blocks) 1753 { 1754 if (func->block_graph[i].lines == NULL) 1755 { 1756 func->block_graph[i].inside_dbus_build_tests = 1757 func->block_graph[i-1].inside_dbus_build_tests; 1758 } 1759 1760 ++i; 1761 } 1762 1763 i = 0; 1764 while (i < func->n_blocks) 1765 { 1766 /* Break as soon as any block is not a test block */ 1767 if (func->block_graph[i].lines != NULL && 1768 !func->block_graph[i].inside_dbus_build_tests) 1769 break; 1770 1771 ++i; 1772 } 1773 1774 if (i == func->n_blocks) 1775 func->inside_dbus_build_tests = TRUE; 1776 1777 link = _dbus_list_get_next_link (&f->functions, link); 1778 } 1779 } 1780 1781 static void 1782 mark_coverage (File *f) 1783 { 1784 int i; 1785 DBusList *link; 1786 1787 i = 0; 1788 while (i < f->n_lines) 1789 { 1790 Line *l = &f->lines[i]; 1791 DBusList *blink; 1792 int n_blocks; 1793 int n_blocks_executed; 1794 1795 n_blocks = 0; 1796 n_blocks_executed = 0; 1797 blink = _dbus_list_get_first_link (&l->blocks); 1798 while (blink != NULL) 1799 { 1800 Block *b = blink->data; 1801 1802 if (b->exec_count > 0) 1803 n_blocks_executed += 1; 1804 1805 n_blocks += 1; 1806 1807 blink = _dbus_list_get_next_link (&l->blocks, blink); 1808 } 1809 1810 if (n_blocks_executed > 0 && 1811 n_blocks_executed < n_blocks) 1812 l->partial = TRUE; 1813 1814 ++i; 1815 } 1816 1817 link = _dbus_list_get_first_link (&f->functions); 1818 while (link != NULL) 1819 { 1820 Function *func = link->data; 1821 int i; 1822 int n_test_blocks; 1823 int n_test_blocks_executed; 1824 int n_nontest_blocks; 1825 int n_nontest_blocks_executed; 1826 1827 n_test_blocks = 0; 1828 n_test_blocks_executed = 0; 1829 n_nontest_blocks = 0; 1830 n_nontest_blocks_executed = 0; 1831 1832 i = 0; 1833 while (i < func->n_blocks) 1834 { 1835 if (!func->block_graph[i].inside_dbus_build_tests) 1836 { 1837 n_nontest_blocks += 1; 1838 1839 if (func->block_graph[i].exec_count > 0) 1840 n_nontest_blocks_executed += 1; 1841 } 1842 else 1843 { 1844 n_test_blocks += 1; 1845 1846 if (func->block_graph[i].exec_count > 0) 1847 n_test_blocks_executed += 1; 1848 } 1849 1850 ++i; 1851 } 1852 1853 if (n_nontest_blocks_executed > 0 && 1854 n_nontest_blocks_executed < n_nontest_blocks) 1855 func->partial = TRUE; 1856 1857 if (n_nontest_blocks_executed == 0 && 1858 n_nontest_blocks > 0) 1859 func->unused = TRUE; 1860 1861 func->n_test_blocks = n_test_blocks; 1862 func->n_test_blocks_executed = n_test_blocks_executed; 1863 func->n_nontest_blocks = n_nontest_blocks; 1864 func->n_nontest_blocks_executed = n_nontest_blocks_executed; 1865 1866 link = _dbus_list_get_next_link (&f->functions, link); 1867 } 1868 } 1869 1870 static File* 1871 load_c_file (const DBusString *filename) 1872 { 1873 DBusString contents; 1874 DBusError error; 1875 File *f; 1876 1877 f = dbus_new0 (File, 1); 1878 if (f == NULL) 1879 die ("no memory\n"); 1880 1881 if (!_dbus_string_copy_data (filename, &f->name)) 1882 die ("no memory\n"); 1883 1884 if (!_dbus_string_init (&contents)) 1885 die ("no memory\n"); 1886 1887 dbus_error_init (&error); 1888 1889 if (!_dbus_file_get_contents (&contents, filename, 1890 &error)) 1891 { 1892 fprintf (stderr, "Could not open file: %s\n", 1893 error.message); 1894 dbus_error_free (&error); 1895 exit (1); 1896 } 1897 1898 load_functions_for_c_file (filename, &f->functions); 1899 1900 f->n_lines = count_lines_in_string (&contents); 1901 f->lines = dbus_new0 (Line, f->n_lines); 1902 if (f->lines == NULL) 1903 die ("no memory\n"); 1904 1905 fill_line_content (&contents, f->lines); 1906 1907 _dbus_string_free (&contents); 1908 1909 load_block_line_associations (filename, f); 1910 1911 mark_inside_dbus_build_tests (f); 1912 mark_coverage (f); 1913 1914 return f; 1915 } 1916 1917 typedef struct Stats Stats; 1918 1919 struct Stats 1920 { 1921 int n_blocks; 1922 int n_blocks_executed; 1923 int n_blocks_inside_dbus_build_tests; 1924 1925 int n_lines; /* lines that have blocks on them */ 1926 int n_lines_executed; 1927 int n_lines_partial; 1928 int n_lines_inside_dbus_build_tests; 1929 1930 int n_functions; 1931 int n_functions_executed; 1932 int n_functions_partial; 1933 int n_functions_inside_dbus_build_tests; 1934 }; 1935 1936 static dbus_bool_t 1937 line_was_executed (Line *l) 1938 { 1939 DBusList *link; 1940 1941 link = _dbus_list_get_first_link (&l->blocks); 1942 while (link != NULL) 1943 { 1944 Block *b = link->data; 1945 1946 if (b->exec_count > 0) 1947 return TRUE; 1948 1949 link = _dbus_list_get_next_link (&l->blocks, link); 1950 } 1951 1952 return FALSE; 1953 } 1954 1955 1956 static int 1957 line_exec_count (Line *l) 1958 { 1959 DBusList *link; 1960 dbus_int64_t total; 1961 1962 total = 0; 1963 link = _dbus_list_get_first_link (&l->blocks); 1964 while (link != NULL) 1965 { 1966 Block *b = link->data; 1967 1968 total += b->exec_count; 1969 1970 link = _dbus_list_get_next_link (&l->blocks, link); 1971 } 1972 1973 return total; 1974 } 1975 1976 static void 1977 merge_stats_for_file (Stats *stats, 1978 File *f) 1979 { 1980 int i; 1981 DBusList *link; 1982 1983 for (i = 0; i < f->n_lines; ++i) 1984 { 1985 Line *l = &f->lines[i]; 1986 1987 if (l->inside_dbus_build_tests) 1988 { 1989 stats->n_lines_inside_dbus_build_tests += 1; 1990 continue; 1991 } 1992 1993 if (line_was_executed (l)) 1994 stats->n_lines_executed += 1; 1995 1996 if (l->blocks != NULL) 1997 stats->n_lines += 1; 1998 1999 if (l->partial) 2000 stats->n_lines_partial += 1; 2001 } 2002 2003 link = _dbus_list_get_first_link (&f->functions); 2004 while (link != NULL) 2005 { 2006 Function *func = link->data; 2007 2008 if (func->inside_dbus_build_tests) 2009 stats->n_functions_inside_dbus_build_tests += 1; 2010 else 2011 { 2012 stats->n_functions += 1; 2013 2014 if (!func->unused) 2015 stats->n_functions_executed += 1; 2016 2017 if (func->partial) 2018 stats->n_functions_partial += 1; 2019 } 2020 2021 stats->n_blocks_inside_dbus_build_tests += 2022 func->n_test_blocks; 2023 2024 stats->n_blocks_executed += 2025 func->n_nontest_blocks_executed; 2026 2027 stats->n_blocks += 2028 func->n_nontest_blocks; 2029 2030 link = _dbus_list_get_next_link (&f->functions, link); 2031 } 2032 } 2033 2034 /* The output of this matches gcov exactly ("diff" shows no difference) */ 2035 static void 2036 print_annotated_source_gcov_format (File *f) 2037 { 2038 int i; 2039 2040 i = 0; 2041 while (i < f->n_lines) 2042 { 2043 Line *l = &f->lines[i]; 2044 2045 if (l->blocks != NULL) 2046 { 2047 int exec_count; 2048 2049 exec_count = line_exec_count (l); 2050 2051 if (exec_count > 0) 2052 printf ("%12d %s\n", 2053 exec_count, l->text); 2054 else 2055 printf (" ###### %s\n", l->text); 2056 } 2057 else 2058 { 2059 printf ("\t\t%s\n", l->text); 2060 } 2061 2062 ++i; 2063 } 2064 } 2065 2066 static void 2067 print_annotated_source (File *f) 2068 { 2069 int i; 2070 2071 i = 0; 2072 while (i < f->n_lines) 2073 { 2074 Line *l = &f->lines[i]; 2075 2076 if (l->inside_dbus_build_tests) 2077 printf ("*"); 2078 else 2079 printf (" "); 2080 2081 if (l->blocks != NULL) 2082 { 2083 int exec_count; 2084 2085 exec_count = line_exec_count (l); 2086 2087 if (exec_count > 0) 2088 printf ("%12d %s\n", 2089 exec_count, l->text); 2090 else 2091 printf (" ###### %s\n", l->text); 2092 } 2093 else 2094 { 2095 printf ("\t\t%s\n", l->text); 2096 } 2097 2098 ++i; 2099 } 2100 } 2101 2102 static void 2103 print_block_superdetails (File *f) 2104 { 2105 DBusList *link; 2106 int i; 2107 2108 link = _dbus_list_get_first_link (&f->functions); 2109 while (link != NULL) 2110 { 2111 Function *func = link->data; 2112 2113 printf ("=== %s():\n", func->name); 2114 2115 i = 0; 2116 while (i < func->n_blocks) 2117 { 2118 Block *b = &func->block_graph[i]; 2119 DBusList *l; 2120 2121 printf (" %5d executed %d times%s\n", i, 2122 (int) b->exec_count, 2123 b->inside_dbus_build_tests ? 2124 " [inside DBUS_BUILD_TESTS]" : ""); 2125 2126 l = _dbus_list_get_first_link (&b->lines); 2127 while (l != NULL) 2128 { 2129 Line *line = l->data; 2130 2131 printf ("4%d\t%s\n", line->number, line->text); 2132 2133 l = _dbus_list_get_next_link (&b->lines, l); 2134 } 2135 2136 ++i; 2137 } 2138 2139 link = _dbus_list_get_next_link (&f->functions, link); 2140 } 2141 } 2142 2143 static void 2144 print_one_file (const DBusString *filename) 2145 { 2146 if (_dbus_string_ends_with_c_str (filename, ".bb")) 2147 { 2148 DBusString contents; 2149 DBusError error; 2150 2151 if (!_dbus_string_init (&contents)) 2152 die ("no memory\n"); 2153 2154 dbus_error_init (&error); 2155 2156 if (!_dbus_file_get_contents (&contents, filename, 2157 &error)) 2158 { 2159 fprintf (stderr, "Could not open file: %s\n", 2160 error.message); 2161 dbus_error_free (&error); 2162 exit (1); 2163 } 2164 2165 dump_bb_file (&contents); 2166 2167 _dbus_string_free (&contents); 2168 } 2169 else if (_dbus_string_ends_with_c_str (filename, ".bbg")) 2170 { 2171 DBusString contents; 2172 DBusError error; 2173 2174 if (!_dbus_string_init (&contents)) 2175 die ("no memory\n"); 2176 2177 dbus_error_init (&error); 2178 2179 if (!_dbus_file_get_contents (&contents, filename, 2180 &error)) 2181 { 2182 fprintf (stderr, "Could not open file: %s\n", 2183 error.message); 2184 dbus_error_free (&error); 2185 exit (1); 2186 } 2187 2188 dump_bbg_file (&contents); 2189 2190 _dbus_string_free (&contents); 2191 } 2192 else if (_dbus_string_ends_with_c_str (filename, ".da")) 2193 { 2194 DBusString contents; 2195 DBusError error; 2196 2197 if (!_dbus_string_init (&contents)) 2198 die ("no memory\n"); 2199 2200 dbus_error_init (&error); 2201 2202 if (!_dbus_file_get_contents (&contents, filename, 2203 &error)) 2204 { 2205 fprintf (stderr, "Could not open file: %s\n", 2206 error.message); 2207 dbus_error_free (&error); 2208 exit (1); 2209 } 2210 2211 dump_da_file (&contents); 2212 2213 _dbus_string_free (&contents); 2214 } 2215 else if (_dbus_string_ends_with_c_str (filename, ".c")) 2216 { 2217 File *f; 2218 2219 f = load_c_file (filename); 2220 2221 print_annotated_source (f); 2222 } 2223 else 2224 { 2225 fprintf (stderr, "Unknown file type %s\n", 2226 _dbus_string_get_const_data (filename)); 2227 exit (1); 2228 } 2229 } 2230 2231 static void 2232 print_untested_functions (File *f) 2233 { 2234 DBusList *link; 2235 dbus_bool_t found; 2236 2237 found = FALSE; 2238 link = _dbus_list_get_first_link (&f->functions); 2239 while (link != NULL) 2240 { 2241 Function *func = link->data; 2242 2243 if (func->unused && 2244 !func->inside_dbus_build_tests) 2245 found = TRUE; 2246 2247 link = _dbus_list_get_next_link (&f->functions, link); 2248 } 2249 2250 if (!found) 2251 return; 2252 2253 printf ("Untested functions in %s\n", f->name); 2254 printf ("=======\n"); 2255 2256 link = _dbus_list_get_first_link (&f->functions); 2257 while (link != NULL) 2258 { 2259 Function *func = link->data; 2260 2261 if (func->unused && 2262 !func->inside_dbus_build_tests) 2263 printf (" %s\n", func->name); 2264 2265 link = _dbus_list_get_next_link (&f->functions, link); 2266 } 2267 2268 printf ("\n"); 2269 } 2270 2271 static void 2272 print_poorly_tested_functions (File *f, 2273 Stats *stats) 2274 { 2275 DBusList *link; 2276 dbus_bool_t found; 2277 2278 #define TEST_FRACTION(function) ((function)->n_nontest_blocks_executed / (double) (function)->n_nontest_blocks) 2279 2280 #define AVERAGE_COVERAGE ((stats)->n_blocks_executed / (double) (stats)->n_blocks) 2281 2282 #define POORLY_TESTED(function) (!(function)->unused && \ 2283 (function)->n_nontest_blocks > 0 && \ 2284 TEST_FRACTION (function) < AVERAGE_COVERAGE) 2285 2286 found = FALSE; 2287 link = _dbus_list_get_first_link (&f->functions); 2288 while (link != NULL) 2289 { 2290 Function *func = link->data; 2291 2292 if (POORLY_TESTED (func)) 2293 found = TRUE; 2294 2295 link = _dbus_list_get_next_link (&f->functions, link); 2296 } 2297 2298 if (!found) 2299 return; 2300 2301 printf ("Below average functions in %s\n", f->name); 2302 printf ("=======\n"); 2303 2304 link = _dbus_list_get_first_link (&f->functions); 2305 while (link != NULL) 2306 { 2307 Function *func = link->data; 2308 2309 if (POORLY_TESTED (func)) 2310 printf (" %s (%d%%)\n", func->name, 2311 (int) (TEST_FRACTION (func) * 100)); 2312 2313 link = _dbus_list_get_next_link (&f->functions, link); 2314 } 2315 2316 printf ("\n"); 2317 } 2318 2319 static int 2320 func_cmp (const void *a, 2321 const void *b) 2322 { 2323 Function *af = *(Function**) a; 2324 Function *bf = *(Function**) b; 2325 int a_untested = af->n_nontest_blocks - af->n_nontest_blocks_executed; 2326 int b_untested = bf->n_nontest_blocks - bf->n_nontest_blocks_executed; 2327 2328 /* Sort by number of untested blocks */ 2329 return b_untested - a_untested; 2330 } 2331 2332 static void 2333 print_n_untested_blocks_by_function (File *f, 2334 Stats *stats) 2335 { 2336 DBusList *link; 2337 Function **funcs; 2338 int n_found; 2339 int i; 2340 2341 n_found = 0; 2342 link = _dbus_list_get_first_link (&f->functions); 2343 while (link != NULL) 2344 { 2345 Function *func = link->data; 2346 2347 if (func->n_nontest_blocks_executed < 2348 func->n_nontest_blocks) 2349 n_found += 1; 2350 2351 link = _dbus_list_get_next_link (&f->functions, link); 2352 } 2353 2354 if (n_found == 0) 2355 return; 2356 2357 /* make an array so we can use qsort */ 2358 2359 funcs = dbus_new (Function*, n_found); 2360 if (funcs == NULL) 2361 return; 2362 2363 i = 0; 2364 link = _dbus_list_get_first_link (&f->functions); 2365 while (link != NULL) 2366 { 2367 Function *func = link->data; 2368 2369 if (func->n_nontest_blocks_executed < 2370 func->n_nontest_blocks) 2371 { 2372 funcs[i] = func; 2373 ++i; 2374 } 2375 2376 link = _dbus_list_get_next_link (&f->functions, link); 2377 } 2378 2379 _dbus_assert (i == n_found); 2380 2381 qsort (funcs, n_found, sizeof (Function*), 2382 func_cmp); 2383 2384 printf ("Incomplete functions in %s\n", f->name); 2385 printf ("=======\n"); 2386 2387 i = 0; 2388 while (i < n_found) 2389 { 2390 Function *func = funcs[i]; 2391 2392 printf (" %s (%d/%d untested blocks)\n", 2393 func->name, 2394 func->n_nontest_blocks - func->n_nontest_blocks_executed, 2395 func->n_nontest_blocks); 2396 2397 ++i; 2398 } 2399 2400 dbus_free (funcs); 2401 2402 printf ("\n"); 2403 } 2404 2405 static void 2406 print_stats (Stats *stats, 2407 const char *of_what) 2408 { 2409 int completely; 2410 2411 printf ("Summary (%s)\n", of_what); 2412 printf ("=======\n"); 2413 printf (" %g%% blocks executed (%d of %d)\n", 2414 (stats->n_blocks_executed / (double) stats->n_blocks) * 100.0, 2415 stats->n_blocks_executed, 2416 stats->n_blocks); 2417 2418 printf (" (ignored %d blocks of test-only/debug-only code)\n", 2419 stats->n_blocks_inside_dbus_build_tests); 2420 2421 printf (" %g%% functions executed (%d of %d)\n", 2422 (stats->n_functions_executed / (double) stats->n_functions) * 100.0, 2423 stats->n_functions_executed, 2424 stats->n_functions); 2425 2426 completely = stats->n_functions_executed - stats->n_functions_partial; 2427 printf (" %g%% functions completely executed (%d of %d)\n", 2428 (completely / (double) stats->n_functions) * 100.0, 2429 completely, 2430 stats->n_functions); 2431 2432 printf (" (ignored %d functions of test-only/debug-only code)\n", 2433 stats->n_functions_inside_dbus_build_tests); 2434 2435 printf (" %g%% lines executed (%d of %d)\n", 2436 (stats->n_lines_executed / (double) stats->n_lines) * 100.0, 2437 stats->n_lines_executed, 2438 stats->n_lines); 2439 2440 completely = stats->n_lines_executed - stats->n_lines_partial; 2441 printf (" %g%% lines completely executed (%d of %d)\n", 2442 (completely / (double) stats->n_lines) * 100.0, 2443 completely, 2444 stats->n_lines); 2445 2446 printf (" (ignored %d lines of test-only/debug-only code)\n", 2447 stats->n_lines_inside_dbus_build_tests); 2448 2449 printf ("\n"); 2450 } 2451 2452 typedef enum 2453 { 2454 MODE_PRINT, 2455 MODE_REPORT, 2456 MODE_BLOCKS, 2457 MODE_GCOV 2458 } Mode; 2459 2460 int 2461 main (int argc, char **argv) 2462 { 2463 DBusString filename; 2464 int i; 2465 Mode m; 2466 2467 if (argc < 2) 2468 { 2469 fprintf (stderr, "Must specify files on command line\n"); 2470 return 1; 2471 } 2472 2473 m = MODE_PRINT; 2474 i = 1; 2475 2476 if (strcmp (argv[i], "--report") == 0) 2477 { 2478 m = MODE_REPORT; 2479 ++i; 2480 } 2481 else if (strcmp (argv[i], "--blocks") == 0) 2482 { 2483 m = MODE_BLOCKS; 2484 ++i; 2485 } 2486 else if (strcmp (argv[i], "--gcov") == 0) 2487 { 2488 m = MODE_GCOV; 2489 ++i; 2490 } 2491 2492 2493 if (i == argc) 2494 { 2495 fprintf (stderr, "Must specify files on command line\n"); 2496 return 1; 2497 } 2498 2499 if (m == MODE_PRINT) 2500 { 2501 while (i < argc) 2502 { 2503 _dbus_string_init_const (&filename, argv[i]); 2504 2505 print_one_file (&filename); 2506 2507 ++i; 2508 } 2509 } 2510 else if (m == MODE_BLOCKS || m == MODE_GCOV) 2511 { 2512 while (i < argc) 2513 { 2514 File *f; 2515 2516 _dbus_string_init_const (&filename, argv[i]); 2517 2518 f = load_c_file (&filename); 2519 2520 if (m == MODE_BLOCKS) 2521 print_block_superdetails (f); 2522 else if (m == MODE_GCOV) 2523 print_annotated_source_gcov_format (f); 2524 2525 ++i; 2526 } 2527 } 2528 else if (m == MODE_REPORT) 2529 { 2530 Stats stats = { 0, }; 2531 DBusList *files; 2532 DBusList *link; 2533 DBusHashTable *stats_by_dir; 2534 DBusHashIter iter; 2535 2536 files = NULL; 2537 while (i < argc) 2538 { 2539 _dbus_string_init_const (&filename, argv[i]); 2540 2541 if (_dbus_string_ends_with_c_str (&filename, ".c")) 2542 { 2543 File *f; 2544 2545 f = load_c_file (&filename); 2546 2547 if (!_dbus_list_append (&files, f)) 2548 die ("no memory\n"); 2549 } 2550 else 2551 { 2552 fprintf (stderr, "Unknown file type %s\n", 2553 _dbus_string_get_const_data (&filename)); 2554 exit (1); 2555 } 2556 2557 ++i; 2558 } 2559 2560 link = _dbus_list_get_first_link (&files); 2561 while (link != NULL) 2562 { 2563 File *f = link->data; 2564 2565 merge_stats_for_file (&stats, f); 2566 2567 link = _dbus_list_get_next_link (&files, link); 2568 } 2569 2570 print_stats (&stats, "all files"); 2571 2572 stats_by_dir = _dbus_hash_table_new (DBUS_HASH_STRING, 2573 dbus_free, dbus_free); 2574 2575 link = _dbus_list_get_first_link (&files); 2576 while (link != NULL) 2577 { 2578 File *f = link->data; 2579 DBusString dirname; 2580 char *dirname_c; 2581 Stats *dir_stats; 2582 2583 _dbus_string_init_const (&filename, f->name); 2584 2585 if (!_dbus_string_init (&dirname)) 2586 die ("no memory\n"); 2587 2588 if (!_dbus_string_get_dirname (&filename, &dirname) || 2589 !_dbus_string_copy_data (&dirname, &dirname_c)) 2590 die ("no memory\n"); 2591 2592 dir_stats = _dbus_hash_table_lookup_string (stats_by_dir, 2593 dirname_c); 2594 2595 if (dir_stats == NULL) 2596 { 2597 dir_stats = dbus_new0 (Stats, 1); 2598 if (!_dbus_hash_table_insert_string (stats_by_dir, dirname_c, 2599 dir_stats)) 2600 die ("no memory\n"); 2601 } 2602 else 2603 dbus_free (dirname_c); 2604 2605 merge_stats_for_file (dir_stats, f); 2606 2607 link = _dbus_list_get_next_link (&files, link); 2608 } 2609 2610 _dbus_hash_iter_init (stats_by_dir, &iter); 2611 while (_dbus_hash_iter_next (&iter)) 2612 { 2613 const char *dirname = _dbus_hash_iter_get_string_key (&iter); 2614 Stats *dir_stats = _dbus_hash_iter_get_value (&iter); 2615 2616 print_stats (dir_stats, dirname); 2617 } 2618 2619 _dbus_hash_table_unref (stats_by_dir); 2620 2621 link = _dbus_list_get_first_link (&files); 2622 while (link != NULL) 2623 { 2624 File *f = link->data; 2625 2626 print_untested_functions (f); 2627 2628 link = _dbus_list_get_next_link (&files, link); 2629 } 2630 2631 link = _dbus_list_get_first_link (&files); 2632 while (link != NULL) 2633 { 2634 File *f = link->data; 2635 2636 print_poorly_tested_functions (f, &stats); 2637 2638 link = _dbus_list_get_next_link (&files, link); 2639 } 2640 2641 link = _dbus_list_get_first_link (&files); 2642 while (link != NULL) 2643 { 2644 File *f = link->data; 2645 2646 print_n_untested_blocks_by_function (f, &stats); 2647 2648 link = _dbus_list_get_next_link (&files, link); 2649 } 2650 } 2651 2652 return 0; 2653 } 2654
