test/decode-gcov.c

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