* config/i386/i386.c (ix86_adjust_stack_and_probe_stack_clash): New.
[official-gcc.git] / gcc / gcov-dump.c
blobd24e72ac4a13471a658a155aafcc6618b93b1031
1 /* Dump a gcov file, for debugging use.
2 Copyright (C) 2002-2017 Free Software Foundation, Inc.
3 Contributed by Nathan Sidwell <nathan@codesourcery.com>
5 Gcov is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3, or (at your option)
8 any later version.
10 Gcov is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with Gcov; see the file COPYING3. If not see
17 <http://www.gnu.org/licenses/>. */
19 #include "config.h"
20 #include "system.h"
21 #include "coretypes.h"
22 #include "tm.h"
23 #include "version.h"
24 #include "intl.h"
25 #include "diagnostic.h"
26 #include <getopt.h>
27 #define IN_GCOV (-1)
28 #include "gcov-io.h"
29 #include "gcov-io.c"
31 static void dump_gcov_file (const char *);
32 static void print_prefix (const char *, unsigned, gcov_position_t);
33 static void print_usage (void);
34 static void print_version (void);
35 static void tag_function (const char *, unsigned, unsigned, unsigned);
36 static void tag_blocks (const char *, unsigned, unsigned, unsigned);
37 static void tag_arcs (const char *, unsigned, unsigned, unsigned);
38 static void tag_lines (const char *, unsigned, unsigned, unsigned);
39 static void tag_counters (const char *, unsigned, unsigned, unsigned);
40 static void tag_summary (const char *, unsigned, unsigned, unsigned);
41 static void dump_working_sets (const char *filename ATTRIBUTE_UNUSED,
42 const struct gcov_ctr_summary *summary,
43 unsigned depth);
44 extern int main (int, char **);
46 typedef struct tag_format
48 unsigned tag;
49 char const *name;
50 void (*proc) (const char *, unsigned, unsigned, unsigned);
51 } tag_format_t;
53 static int flag_dump_contents = 0;
54 static int flag_dump_positions = 0;
55 static int flag_dump_working_sets = 0;
57 static const struct option options[] =
59 { "help", no_argument, NULL, 'h' },
60 { "version", no_argument, NULL, 'v' },
61 { "long", no_argument, NULL, 'l' },
62 { "positions", no_argument, NULL, 'o' },
63 { "working-sets", no_argument, NULL, 'w' },
64 { 0, 0, 0, 0 }
67 #define VALUE_PADDING_PREFIX " "
68 #define VALUE_PREFIX "%2d: "
70 static const tag_format_t tag_table[] =
72 {0, "NOP", NULL},
73 {0, "UNKNOWN", NULL},
74 {0, "COUNTERS", tag_counters},
75 {GCOV_TAG_FUNCTION, "FUNCTION", tag_function},
76 {GCOV_TAG_BLOCKS, "BLOCKS", tag_blocks},
77 {GCOV_TAG_ARCS, "ARCS", tag_arcs},
78 {GCOV_TAG_LINES, "LINES", tag_lines},
79 {GCOV_TAG_OBJECT_SUMMARY, "OBJECT_SUMMARY", tag_summary},
80 {GCOV_TAG_PROGRAM_SUMMARY, "PROGRAM_SUMMARY", tag_summary},
81 {0, NULL, NULL}
84 int
85 main (int argc ATTRIBUTE_UNUSED, char **argv)
87 int opt;
88 const char *p;
90 p = argv[0] + strlen (argv[0]);
91 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
92 --p;
93 progname = p;
95 xmalloc_set_program_name (progname);
97 /* Unlock the stdio streams. */
98 unlock_std_streams ();
100 gcc_init_libintl ();
102 diagnostic_initialize (global_dc, 0);
104 while ((opt = getopt_long (argc, argv, "hlpvw", options, NULL)) != -1)
106 switch (opt)
108 case 'h':
109 print_usage ();
110 break;
111 case 'v':
112 print_version ();
113 break;
114 case 'l':
115 flag_dump_contents = 1;
116 break;
117 case 'p':
118 flag_dump_positions = 1;
119 break;
120 case 'w':
121 flag_dump_working_sets = 1;
122 break;
123 default:
124 fprintf (stderr, "unknown flag `%c'\n", opt);
128 while (argv[optind])
129 dump_gcov_file (argv[optind++]);
130 return 0;
133 static void
134 print_usage (void)
136 printf ("Usage: gcov-dump [OPTION] ... gcovfiles\n");
137 printf ("Print coverage file contents\n");
138 printf (" -h, --help Print this help\n");
139 printf (" -l, --long Dump record contents too\n");
140 printf (" -p, --positions Dump record positions\n");
141 printf (" -v, --version Print version number\n");
142 printf (" -w, --working-sets Dump working set computed from summary\n");
143 printf ("\nFor bug reporting instructions, please see:\n%s.\n",
144 bug_report_url);
147 static void
148 print_version (void)
150 printf ("gcov-dump %s%s\n", pkgversion_string, version_string);
151 printf ("Copyright (C) 2017 Free Software Foundation, Inc.\n");
152 printf ("This is free software; see the source for copying conditions.\n"
153 "There is NO warranty; not even for MERCHANTABILITY or \n"
154 "FITNESS FOR A PARTICULAR PURPOSE.\n\n");
157 static void
158 print_prefix (const char *filename, unsigned depth, gcov_position_t position)
160 static const char prefix[] = " ";
162 printf ("%s:", filename);
163 if (flag_dump_positions)
164 printf ("%5lu:", (unsigned long) position);
165 printf ("%.*s", (int) 2 * depth, prefix);
168 static void
169 dump_gcov_file (const char *filename)
171 unsigned tags[4];
172 unsigned depth = 0;
174 if (!gcov_open (filename, 1))
176 fprintf (stderr, "%s:cannot open\n", filename);
177 return;
180 /* magic */
182 unsigned magic = gcov_read_unsigned ();
183 unsigned version;
184 const char *type = NULL;
185 int endianness = 0;
186 char m[4], v[4];
188 if ((endianness = gcov_magic (magic, GCOV_DATA_MAGIC)))
189 type = "data";
190 else if ((endianness = gcov_magic (magic, GCOV_NOTE_MAGIC)))
191 type = "note";
192 else
194 printf ("%s:not a gcov file\n", filename);
195 gcov_close ();
196 return;
198 version = gcov_read_unsigned ();
199 GCOV_UNSIGNED2STRING (v, version);
200 GCOV_UNSIGNED2STRING (m, magic);
202 printf ("%s:%s:magic `%.4s':version `%.4s'%s\n", filename, type,
203 m, v, endianness < 0 ? " (swapped endianness)" : "");
204 if (version != GCOV_VERSION)
206 char e[4];
208 GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
209 printf ("%s:warning:current version is `%.4s'\n", filename, e);
213 /* stamp */
215 unsigned stamp = gcov_read_unsigned ();
217 printf ("%s:stamp %lu\n", filename, (unsigned long)stamp);
220 while (1)
222 gcov_position_t base, position = gcov_position ();
223 unsigned tag, length;
224 tag_format_t const *format;
225 unsigned tag_depth;
226 int error;
227 unsigned mask;
229 tag = gcov_read_unsigned ();
230 if (!tag)
231 break;
232 length = gcov_read_unsigned ();
233 base = gcov_position ();
234 mask = GCOV_TAG_MASK (tag) >> 1;
235 for (tag_depth = 4; mask; mask >>= 8)
237 if ((mask & 0xff) != 0xff)
239 printf ("%s:tag `%08x' is invalid\n", filename, tag);
240 break;
242 tag_depth--;
244 for (format = tag_table; format->name; format++)
245 if (format->tag == tag)
246 goto found;
247 format = &tag_table[GCOV_TAG_IS_COUNTER (tag) ? 2 : 1];
248 found:;
249 if (tag)
251 if (depth && depth < tag_depth)
253 if (!GCOV_TAG_IS_SUBTAG (tags[depth - 1], tag))
254 printf ("%s:tag `%08x' is incorrectly nested\n",
255 filename, tag);
257 depth = tag_depth;
258 tags[depth - 1] = tag;
261 print_prefix (filename, tag_depth, position);
262 printf ("%08x:%4u:%s", tag, length, format->name);
263 if (format->proc)
264 (*format->proc) (filename, tag, length, depth);
266 printf ("\n");
267 if (flag_dump_contents && format->proc)
269 unsigned long actual_length = gcov_position () - base;
271 if (actual_length > length)
272 printf ("%s:record size mismatch %lu bytes overread\n",
273 filename, actual_length - length);
274 else if (length > actual_length)
275 printf ("%s:record size mismatch %lu bytes unread\n",
276 filename, length - actual_length);
278 gcov_sync (base, length);
279 if ((error = gcov_is_error ()))
281 printf (error < 0 ? "%s:counter overflow at %lu\n" :
282 "%s:read error at %lu\n", filename,
283 (long unsigned) gcov_position ());
284 break;
287 gcov_close ();
290 static void
291 tag_function (const char *filename ATTRIBUTE_UNUSED,
292 unsigned tag ATTRIBUTE_UNUSED, unsigned length,
293 unsigned depth ATTRIBUTE_UNUSED)
295 unsigned long pos = gcov_position ();
297 if (!length)
298 printf (" placeholder");
299 else
301 printf (" ident=%u", gcov_read_unsigned ());
302 printf (", lineno_checksum=0x%08x", gcov_read_unsigned ());
303 printf (", cfg_checksum=0x%08x", gcov_read_unsigned ());
305 if (gcov_position () - pos < length)
307 const char *name;
309 name = gcov_read_string ();
310 printf (", `%s'", name ? name : "NULL");
311 name = gcov_read_string ();
312 printf (" %s", name ? name : "NULL");
313 printf (":%u", gcov_read_unsigned ());
318 static void
319 tag_blocks (const char *filename ATTRIBUTE_UNUSED,
320 unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED,
321 unsigned depth ATTRIBUTE_UNUSED)
323 printf (" %u blocks", gcov_read_unsigned ());
326 static void
327 tag_arcs (const char *filename ATTRIBUTE_UNUSED,
328 unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED,
329 unsigned depth)
331 unsigned n_arcs = GCOV_TAG_ARCS_NUM (length);
333 printf (" %u arcs", n_arcs);
334 if (flag_dump_contents)
336 unsigned ix;
337 unsigned blockno = gcov_read_unsigned ();
339 for (ix = 0; ix != n_arcs; ix++)
341 unsigned dst, flags;
343 if (!(ix & 3))
345 printf ("\n");
346 print_prefix (filename, depth, gcov_position ());
347 printf (VALUE_PADDING_PREFIX "block %u:", blockno);
349 dst = gcov_read_unsigned ();
350 flags = gcov_read_unsigned ();
351 printf (" %u:%04x", dst, flags);
352 if (flags)
354 char c = '(';
356 if (flags & GCOV_ARC_ON_TREE)
357 printf ("%ctree", c), c = ',';
358 if (flags & GCOV_ARC_FAKE)
359 printf ("%cfake", c), c = ',';
360 if (flags & GCOV_ARC_FALLTHROUGH)
361 printf ("%cfall", c), c = ',';
362 printf (")");
368 static void
369 tag_lines (const char *filename ATTRIBUTE_UNUSED,
370 unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED,
371 unsigned depth)
373 if (flag_dump_contents)
375 unsigned blockno = gcov_read_unsigned ();
376 char const *sep = NULL;
378 while (1)
380 gcov_position_t position = gcov_position ();
381 const char *source = NULL;
382 unsigned lineno = gcov_read_unsigned ();
384 if (!lineno)
386 source = gcov_read_string ();
387 if (!source)
388 break;
389 sep = NULL;
392 if (!sep)
394 printf ("\n");
395 print_prefix (filename, depth, position);
396 printf (VALUE_PADDING_PREFIX "block %u:", blockno);
397 sep = "";
399 if (lineno)
401 printf ("%s%u", sep, lineno);
402 sep = ", ";
404 else
406 printf ("%s`%s'", sep, source);
407 sep = ":";
413 static void
414 tag_counters (const char *filename ATTRIBUTE_UNUSED,
415 unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED,
416 unsigned depth)
418 #define DEF_GCOV_COUNTER(COUNTER, NAME, MERGE_FN) NAME,
419 static const char *const counter_names[] = {
420 #include "gcov-counter.def"
422 #undef DEF_GCOV_COUNTER
423 unsigned n_counts = GCOV_TAG_COUNTER_NUM (length);
425 printf (" %s %u counts",
426 counter_names[GCOV_COUNTER_FOR_TAG (tag)], n_counts);
427 if (flag_dump_contents)
429 unsigned ix;
431 for (ix = 0; ix != n_counts; ix++)
433 gcov_type count;
435 if (!(ix & 7))
437 printf ("\n");
438 print_prefix (filename, depth, gcov_position ());
439 printf (VALUE_PADDING_PREFIX VALUE_PREFIX, ix);
442 count = gcov_read_counter ();
443 printf ("%" PRId64 " ", count);
448 static void
449 tag_summary (const char *filename ATTRIBUTE_UNUSED,
450 unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED,
451 unsigned depth)
453 struct gcov_summary summary;
454 unsigned ix, h_ix;
455 gcov_bucket_type *histo_bucket;
457 gcov_read_summary (&summary);
458 printf (" checksum=0x%08x", summary.checksum);
460 for (ix = 0; ix != GCOV_COUNTERS_SUMMABLE; ix++)
462 printf ("\n");
463 print_prefix (filename, depth, 0);
464 printf (VALUE_PADDING_PREFIX "counts=%u, runs=%u",
465 summary.ctrs[ix].num, summary.ctrs[ix].runs);
467 printf (", sum_all=%" PRId64,
468 (int64_t)summary.ctrs[ix].sum_all);
469 printf (", run_max=%" PRId64,
470 (int64_t)summary.ctrs[ix].run_max);
471 printf (", sum_max=%" PRId64,
472 (int64_t)summary.ctrs[ix].sum_max);
473 if (ix != GCOV_COUNTER_ARCS)
474 continue;
475 printf ("\n");
476 print_prefix (filename, depth, 0);
477 printf (VALUE_PADDING_PREFIX "counter histogram:");
478 for (h_ix = 0; h_ix < GCOV_HISTOGRAM_SIZE; h_ix++)
480 histo_bucket = &summary.ctrs[ix].histogram[h_ix];
481 if (!histo_bucket->num_counters)
482 continue;
483 printf ("\n");
484 print_prefix (filename, depth, 0);
485 printf (VALUE_PADDING_PREFIX VALUE_PREFIX "num counts=%u, "
486 "min counter=%" PRId64 ", cum_counter=%" PRId64,
487 h_ix, histo_bucket->num_counters,
488 (int64_t)histo_bucket->min_value,
489 (int64_t)histo_bucket->cum_value);
491 if (flag_dump_working_sets)
492 dump_working_sets (filename, &summary.ctrs[ix], depth);
496 static void
497 dump_working_sets (const char *filename ATTRIBUTE_UNUSED,
498 const struct gcov_ctr_summary *summary,
499 unsigned depth)
501 gcov_working_set_t gcov_working_sets[NUM_GCOV_WORKING_SETS];
502 unsigned ws_ix, pctinc, pct;
503 gcov_working_set_t *ws_info;
505 compute_working_sets (summary, gcov_working_sets);
507 printf ("\n");
508 print_prefix (filename, depth, 0);
509 printf (VALUE_PADDING_PREFIX "counter working sets:");
510 /* Multiply the percentage by 100 to avoid float. */
511 pctinc = 100 * 100 / NUM_GCOV_WORKING_SETS;
512 for (ws_ix = 0, pct = pctinc; ws_ix < NUM_GCOV_WORKING_SETS;
513 ws_ix++, pct += pctinc)
515 if (ws_ix == NUM_GCOV_WORKING_SETS - 1)
516 pct = 9990;
517 ws_info = &gcov_working_sets[ws_ix];
518 /* Print out the percentage using int arithmatic to avoid float. */
519 printf ("\n");
520 print_prefix (filename, depth + 1, 0);
521 printf (VALUE_PADDING_PREFIX "%u.%02u%%: num counts=%u, min counter="
522 "%" PRId64,
523 pct / 100, pct - (pct / 100 * 100),
524 ws_info->num_counters,
525 (int64_t)ws_info->min_counter);