Emeric Vigier | 2f62582 | 2012-08-06 11:09:52 -0400 | [diff] [blame] | 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 | } |