1 /* Dump a gcov file, for debugging use. 2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 3 Free Software Foundation, Inc. 4 Contributed by Nathan Sidwell <nathan@codesourcery.com> 5 6 Gcov is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3, or (at your option) 9 any later version. 10 11 Gcov is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with Gcov; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #include "config.h" 21 #include "system.h" 22 #include "coretypes.h" 23 #include "tm.h" 24 #include "version.h" 25 #include <getopt.h> 26 #define IN_GCOV (-1) 27 #include "gcov-io.h" 28 #include "gcov-io.c" 29 30 static void dump_file (const char *); 31 static void print_prefix (const char *, unsigned, gcov_position_t); 32 static void print_usage (void); 33 static void print_version (void); 34 static void tag_function (const char *, unsigned, unsigned); 35 static void tag_blocks (const char *, unsigned, unsigned); 36 static void tag_arcs (const char *, unsigned, unsigned); 37 static void tag_lines (const char *, unsigned, unsigned); 38 static void tag_counters (const char *, unsigned, unsigned); 39 static void tag_summary (const char *, unsigned, unsigned); 40 extern int main (int, char **); 41 42 typedef struct tag_format 43 { 44 unsigned tag; 45 char const *name; 46 void (*proc) (const char *, unsigned, unsigned); 47 } tag_format_t; 48 49 static int flag_dump_contents = 0; 50 static int flag_dump_positions = 0; 51 52 static const struct option options[] = 53 { 54 { "help", no_argument, NULL, 'h' }, 55 { "version", no_argument, NULL, 'v' }, 56 { "long", no_argument, NULL, 'l' }, 57 { "positions", no_argument, NULL, 'o' }, 58 { 0, 0, 0, 0 } 59 }; 60 61 static const tag_format_t tag_table[] = 62 { 63 {0, "NOP", NULL}, 64 {0, "UNKNOWN", NULL}, 65 {0, "COUNTERS", tag_counters}, 66 {GCOV_TAG_FUNCTION, "FUNCTION", tag_function}, 67 {GCOV_TAG_BLOCKS, "BLOCKS", tag_blocks}, 68 {GCOV_TAG_ARCS, "ARCS", tag_arcs}, 69 {GCOV_TAG_LINES, "LINES", tag_lines}, 70 {GCOV_TAG_OBJECT_SUMMARY, "OBJECT_SUMMARY", tag_summary}, 71 {GCOV_TAG_PROGRAM_SUMMARY, "PROGRAM_SUMMARY", tag_summary}, 72 {0, NULL, NULL} 73 }; 74 75 int 76 main (int argc ATTRIBUTE_UNUSED, char **argv) 77 { 78 int opt; 79 80 /* Unlock the stdio streams. */ 81 unlock_std_streams (); 82 83 while ((opt = getopt_long (argc, argv, "hlpv", options, NULL)) != -1) 84 { 85 switch (opt) 86 { 87 case 'h': 88 print_usage (); 89 break; 90 case 'v': 91 print_version (); 92 break; 93 case 'l': 94 flag_dump_contents = 1; 95 break; 96 case 'p': 97 flag_dump_positions = 1; 98 break; 99 default: 100 fprintf (stderr, "unknown flag `%c'\n", opt); 101 } 102 } 103 104 while (argv[optind]) 105 dump_file (argv[optind++]); 106 return 0; 107 } 108 109 static void 110 print_usage (void) 111 { 112 printf ("Usage: gcov-dump [OPTION] ... gcovfiles\n"); 113 printf ("Print coverage file contents\n"); 114 printf (" -h, --help Print this help\n"); 115 printf (" -v, --version Print version number\n"); 116 printf (" -l, --long Dump record contents too\n"); 117 printf (" -p, --positions Dump record positions\n"); 118 } 119 120 static void 121 print_version (void) 122 { 123 printf ("gcov-dump %s%s\n", pkgversion_string, version_string); 124 printf ("Copyright (C) 2010 Free Software Foundation, Inc.\n"); 125 printf ("This is free software; see the source for copying conditions.\n" 126 "There is NO warranty; not even for MERCHANTABILITY or \n" 127 "FITNESS FOR A PARTICULAR PURPOSE.\n\n"); 128 } 129 130 static void 131 print_prefix (const char *filename, unsigned depth, gcov_position_t position) 132 { 133 static const char prefix[] = " "; 134 135 printf ("%s:", filename); 136 if (flag_dump_positions) 137 printf ("%lu:", (unsigned long) position); 138 printf ("%.*s", (int) depth, prefix); 139 } 140 141 static void 142 dump_file (const char *filename) 143 { 144 unsigned tags[4]; 145 unsigned depth = 0; 146 147 if (!gcov_open (filename, 1)) 148 { 149 fprintf (stderr, "%s:cannot open\n", filename); 150 return; 151 } 152 153 /* magic */ 154 { 155 unsigned magic = gcov_read_unsigned (); 156 unsigned version; 157 const char *type = NULL; 158 int endianness = 0; 159 char m[4], v[4]; 160 161 if ((endianness = gcov_magic (magic, GCOV_DATA_MAGIC))) 162 type = "data"; 163 else if ((endianness = gcov_magic (magic, GCOV_NOTE_MAGIC))) 164 type = "note"; 165 else 166 { 167 printf ("%s:not a gcov file\n", filename); 168 gcov_close (); 169 return; 170 } 171 version = gcov_read_unsigned (); 172 GCOV_UNSIGNED2STRING (v, version); 173 GCOV_UNSIGNED2STRING (m, magic); 174 175 printf ("%s:%s:magic `%.4s':version `%.4s'%s\n", filename, type, 176 m, v, endianness < 0 ? " (swapped endianness)" : ""); 177 if (version != GCOV_VERSION) 178 { 179 char e[4]; 180 181 GCOV_UNSIGNED2STRING (e, GCOV_VERSION); 182 printf ("%s:warning:current version is `%.4s'\n", filename, e); 183 } 184 } 185 186 /* stamp */ 187 { 188 unsigned stamp = gcov_read_unsigned (); 189 190 printf ("%s:stamp %lu\n", filename, (unsigned long)stamp); 191 } 192 193 while (1) 194 { 195 gcov_position_t base, position = gcov_position (); 196 unsigned tag, length; 197 tag_format_t const *format; 198 unsigned tag_depth; 199 int error; 200 unsigned mask; 201 202 tag = gcov_read_unsigned (); 203 if (!tag) 204 break; 205 length = gcov_read_unsigned (); 206 base = gcov_position (); 207 mask = GCOV_TAG_MASK (tag) >> 1; 208 for (tag_depth = 4; mask; mask >>= 8) 209 { 210 if ((mask & 0xff) != 0xff) 211 { 212 printf ("%s:tag `%08x' is invalid\n", filename, tag); 213 break; 214 } 215 tag_depth--; 216 } 217 for (format = tag_table; format->name; format++) 218 if (format->tag == tag) 219 goto found; 220 format = &tag_table[GCOV_TAG_IS_COUNTER (tag) ? 2 : 1]; 221 found:; 222 if (tag) 223 { 224 if (depth && depth < tag_depth) 225 { 226 if (!GCOV_TAG_IS_SUBTAG (tags[depth - 1], tag)) 227 printf ("%s:tag `%08x' is incorrectly nested\n", 228 filename, tag); 229 } 230 depth = tag_depth; 231 tags[depth - 1] = tag; 232 } 233 234 print_prefix (filename, tag_depth, position); 235 printf ("%08x:%4u:%s", tag, length, format->name); 236 if (format->proc) 237 (*format->proc) (filename, tag, length); 238 239 printf ("\n"); 240 if (flag_dump_contents && format->proc) 241 { 242 unsigned long actual_length = gcov_position () - base; 243 244 if (actual_length > length) 245 printf ("%s:record size mismatch %lu bytes overread\n", 246 filename, actual_length - length); 247 else if (length > actual_length) 248 printf ("%s:record size mismatch %lu bytes unread\n", 249 filename, length - actual_length); 250 } 251 gcov_sync (base, length); 252 if ((error = gcov_is_error ())) 253 { 254 printf (error < 0 ? "%s:counter overflow at %lu\n" : 255 "%s:read error at %lu\n", filename, 256 (long unsigned) gcov_position ()); 257 break; 258 } 259 } 260 gcov_close (); 261 } 262 263 static void 264 tag_function (const char *filename ATTRIBUTE_UNUSED, 265 unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED) 266 { 267 unsigned long pos = gcov_position (); 268 269 printf (" ident=%u", gcov_read_unsigned ()); 270 printf (", checksum=0x%08x", gcov_read_unsigned ()); 271 272 if (gcov_position () - pos < length) 273 { 274 const char *name; 275 276 name = gcov_read_string (); 277 printf (", `%s'", name ? name : "NULL"); 278 name = gcov_read_string (); 279 printf (" %s", name ? name : "NULL"); 280 printf (":%u", gcov_read_unsigned ()); 281 } 282 } 283 284 static void 285 tag_blocks (const char *filename ATTRIBUTE_UNUSED, 286 unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED) 287 { 288 unsigned n_blocks = GCOV_TAG_BLOCKS_NUM (length); 289 290 printf (" %u blocks", n_blocks); 291 292 if (flag_dump_contents) 293 { 294 unsigned ix; 295 296 for (ix = 0; ix != n_blocks; ix++) 297 { 298 if (!(ix & 7)) 299 { 300 printf ("\n"); 301 print_prefix (filename, 0, gcov_position ()); 302 printf ("\t\t%u", ix); 303 } 304 printf (" %04x", gcov_read_unsigned ()); 305 } 306 } 307 } 308 309 static void 310 tag_arcs (const char *filename ATTRIBUTE_UNUSED, 311 unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED) 312 { 313 unsigned n_arcs = GCOV_TAG_ARCS_NUM (length); 314 315 printf (" %u arcs", n_arcs); 316 if (flag_dump_contents) 317 { 318 unsigned ix; 319 unsigned blockno = gcov_read_unsigned (); 320 321 for (ix = 0; ix != n_arcs; ix++) 322 { 323 unsigned dst, flags; 324 325 if (!(ix & 3)) 326 { 327 printf ("\n"); 328 print_prefix (filename, 0, gcov_position ()); 329 printf ("\tblock %u:", blockno); 330 } 331 dst = gcov_read_unsigned (); 332 flags = gcov_read_unsigned (); 333 printf (" %u:%04x", dst, flags); 334 } 335 } 336 } 337 338 static void 339 tag_lines (const char *filename ATTRIBUTE_UNUSED, 340 unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED) 341 { 342 if (flag_dump_contents) 343 { 344 unsigned blockno = gcov_read_unsigned (); 345 char const *sep = NULL; 346 347 while (1) 348 { 349 gcov_position_t position = gcov_position (); 350 const char *source = NULL; 351 unsigned lineno = gcov_read_unsigned (); 352 353 if (!lineno) 354 { 355 source = gcov_read_string (); 356 if (!source) 357 break; 358 sep = NULL; 359 } 360 361 if (!sep) 362 { 363 printf ("\n"); 364 print_prefix (filename, 0, position); 365 printf ("\tblock %u:", blockno); 366 sep = ""; 367 } 368 if (lineno) 369 { 370 printf ("%s%u", sep, lineno); 371 sep = ", "; 372 } 373 else 374 { 375 printf ("%s`%s'", sep, source); 376 sep = ":"; 377 } 378 } 379 } 380 } 381 382 static void 383 tag_counters (const char *filename ATTRIBUTE_UNUSED, 384 unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED) 385 { 386 static const char *const counter_names[] = GCOV_COUNTER_NAMES; 387 unsigned n_counts = GCOV_TAG_COUNTER_NUM (length); 388 389 printf (" %s %u counts", 390 counter_names[GCOV_COUNTER_FOR_TAG (tag)], n_counts); 391 if (flag_dump_contents) 392 { 393 unsigned ix; 394 395 for (ix = 0; ix != n_counts; ix++) 396 { 397 gcov_type count; 398 399 if (!(ix & 7)) 400 { 401 printf ("\n"); 402 print_prefix (filename, 0, gcov_position ()); 403 printf ("\t\t%u", ix); 404 } 405 406 count = gcov_read_counter (); 407 printf (" "); 408 printf (HOST_WIDEST_INT_PRINT_DEC, count); 409 } 410 } 411 } 412 413 static void 414 tag_summary (const char *filename ATTRIBUTE_UNUSED, 415 unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED) 416 { 417 struct gcov_summary summary; 418 unsigned ix; 419 420 gcov_read_summary (&summary); 421 printf (" checksum=0x%08x", summary.checksum); 422 423 for (ix = 0; ix != GCOV_COUNTERS_SUMMABLE; ix++) 424 { 425 printf ("\n"); 426 print_prefix (filename, 0, 0); 427 printf ("\t\tcounts=%u, runs=%u", 428 summary.ctrs[ix].num, summary.ctrs[ix].runs); 429 430 printf (", sum_all=" HOST_WIDEST_INT_PRINT_DEC, 431 (HOST_WIDEST_INT)summary.ctrs[ix].sum_all); 432 printf (", run_max=" HOST_WIDEST_INT_PRINT_DEC, 433 (HOST_WIDEST_INT)summary.ctrs[ix].run_max); 434 printf (", sum_max=" HOST_WIDEST_INT_PRINT_DEC, 435 (HOST_WIDEST_INT)summary.ctrs[ix].sum_max); 436 } 437 } 438