remove unused files
[platform/upstream/gcc48.git] / gcc / gcov-dump.c
1 /* Dump a gcov file, for debugging use.
2    Copyright (C) 2002-2013 Free Software Foundation, Inc.
3    Contributed by Nathan Sidwell <nathan@codesourcery.com>
4
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.
9
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.
14
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/>.  */
18
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"
30
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);
36 static void tag_blocks (const char *, unsigned, unsigned);
37 static void tag_arcs (const char *, unsigned, unsigned);
38 static void tag_lines (const char *, unsigned, unsigned);
39 static void tag_counters (const char *, unsigned, unsigned);
40 static void tag_summary (const char *, unsigned, unsigned);
41 extern int main (int, char **);
42
43 typedef struct tag_format
44 {
45   unsigned tag;
46   char const *name;
47   void (*proc) (const char *, unsigned, unsigned);
48 } tag_format_t;
49
50 static int flag_dump_contents = 0;
51 static int flag_dump_positions = 0;
52
53 static const struct option options[] =
54 {
55   { "help",                 no_argument,       NULL, 'h' },
56   { "version",              no_argument,       NULL, 'v' },
57   { "long",                 no_argument,       NULL, 'l' },
58   { "positions",            no_argument,       NULL, 'o' },
59   { 0, 0, 0, 0 }
60 };
61
62 static const tag_format_t tag_table[] =
63 {
64   {0, "NOP", NULL},
65   {0, "UNKNOWN", NULL},
66   {0, "COUNTERS", tag_counters},
67   {GCOV_TAG_FUNCTION, "FUNCTION", tag_function},
68   {GCOV_TAG_BLOCKS, "BLOCKS", tag_blocks},
69   {GCOV_TAG_ARCS, "ARCS", tag_arcs},
70   {GCOV_TAG_LINES, "LINES", tag_lines},
71   {GCOV_TAG_OBJECT_SUMMARY, "OBJECT_SUMMARY", tag_summary},
72   {GCOV_TAG_PROGRAM_SUMMARY, "PROGRAM_SUMMARY", tag_summary},
73   {0, NULL, NULL}
74 };
75
76 int
77 main (int argc ATTRIBUTE_UNUSED, char **argv)
78 {
79   int opt;
80   const char *p;
81
82   p = argv[0] + strlen (argv[0]);
83   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
84     --p;
85   progname = p;
86
87   xmalloc_set_program_name (progname);
88
89   /* Unlock the stdio streams.  */
90   unlock_std_streams ();
91
92   gcc_init_libintl ();
93
94   diagnostic_initialize (global_dc, 0);
95
96   while ((opt = getopt_long (argc, argv, "hlpv", options, NULL)) != -1)
97     {
98       switch (opt)
99         {
100         case 'h':
101           print_usage ();
102           break;
103         case 'v':
104           print_version ();
105           break;
106         case 'l':
107           flag_dump_contents = 1;
108           break;
109         case 'p':
110           flag_dump_positions = 1;
111           break;
112         default:
113           fprintf (stderr, "unknown flag `%c'\n", opt);
114         }
115     }
116
117   while (argv[optind])
118     dump_gcov_file (argv[optind++]);
119   return 0;
120 }
121
122 static void
123 print_usage (void)
124 {
125   printf ("Usage: gcov-dump [OPTION] ... gcovfiles\n");
126   printf ("Print coverage file contents\n");
127   printf ("  -h, --help           Print this help\n");
128   printf ("  -v, --version        Print version number\n");
129   printf ("  -l, --long           Dump record contents too\n");
130   printf ("  -p, --positions      Dump record positions\n");
131 }
132
133 static void
134 print_version (void)
135 {
136   printf ("gcov-dump %s%s\n", pkgversion_string, version_string);
137   printf ("Copyright (C) 2013 Free Software Foundation, Inc.\n");
138   printf ("This is free software; see the source for copying conditions.\n"
139           "There is NO warranty; not even for MERCHANTABILITY or \n"
140           "FITNESS FOR A PARTICULAR PURPOSE.\n\n");
141 }
142
143 static void
144 print_prefix (const char *filename, unsigned depth, gcov_position_t position)
145 {
146   static const char prefix[] = "    ";
147
148   printf ("%s:", filename);
149   if (flag_dump_positions)
150     printf ("%lu:", (unsigned long) position);
151   printf ("%.*s", (int) depth, prefix);
152 }
153
154 static void
155 dump_gcov_file (const char *filename)
156 {
157   unsigned tags[4];
158   unsigned depth = 0;
159
160   if (!gcov_open (filename, 1))
161     {
162       fprintf (stderr, "%s:cannot open\n", filename);
163       return;
164     }
165
166   /* magic */
167   {
168     unsigned magic = gcov_read_unsigned ();
169     unsigned version;
170     const char *type = NULL;
171     int endianness = 0;
172     char m[4], v[4];
173
174     if ((endianness = gcov_magic (magic, GCOV_DATA_MAGIC)))
175       type = "data";
176     else if ((endianness = gcov_magic (magic, GCOV_NOTE_MAGIC)))
177       type = "note";
178     else
179       {
180         printf ("%s:not a gcov file\n", filename);
181         gcov_close ();
182         return;
183       }
184     version = gcov_read_unsigned ();
185     GCOV_UNSIGNED2STRING (v, version);
186     GCOV_UNSIGNED2STRING (m, magic);
187
188     printf ("%s:%s:magic `%.4s':version `%.4s'%s\n", filename, type,
189             m, v, endianness < 0 ? " (swapped endianness)" : "");
190     if (version != GCOV_VERSION)
191       {
192         char e[4];
193
194         GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
195         printf ("%s:warning:current version is `%.4s'\n", filename, e);
196       }
197   }
198
199   /* stamp */
200   {
201     unsigned stamp = gcov_read_unsigned ();
202
203     printf ("%s:stamp %lu\n", filename, (unsigned long)stamp);
204   }
205
206   while (1)
207     {
208       gcov_position_t base, position = gcov_position ();
209       unsigned tag, length;
210       tag_format_t const *format;
211       unsigned tag_depth;
212       int error;
213       unsigned mask;
214
215       tag = gcov_read_unsigned ();
216       if (!tag)
217         break;
218       length = gcov_read_unsigned ();
219       base = gcov_position ();
220       mask = GCOV_TAG_MASK (tag) >> 1;
221       for (tag_depth = 4; mask; mask >>= 8)
222         {
223           if ((mask & 0xff) != 0xff)
224             {
225               printf ("%s:tag `%08x' is invalid\n", filename, tag);
226               break;
227             }
228           tag_depth--;
229         }
230       for (format = tag_table; format->name; format++)
231         if (format->tag == tag)
232           goto found;
233       format = &tag_table[GCOV_TAG_IS_COUNTER (tag) ? 2 : 1];
234     found:;
235       if (tag)
236         {
237           if (depth && depth < tag_depth)
238             {
239               if (!GCOV_TAG_IS_SUBTAG (tags[depth - 1], tag))
240                 printf ("%s:tag `%08x' is incorrectly nested\n",
241                         filename, tag);
242             }
243           depth = tag_depth;
244           tags[depth - 1] = tag;
245         }
246
247       print_prefix (filename, tag_depth, position);
248       printf ("%08x:%4u:%s", tag, length, format->name);
249       if (format->proc)
250         (*format->proc) (filename, tag, length);
251
252       printf ("\n");
253       if (flag_dump_contents && format->proc)
254         {
255           unsigned long actual_length = gcov_position () - base;
256
257           if (actual_length > length)
258             printf ("%s:record size mismatch %lu bytes overread\n",
259                     filename, actual_length - length);
260           else if (length > actual_length)
261             printf ("%s:record size mismatch %lu bytes unread\n",
262                     filename, length - actual_length);
263         }
264       gcov_sync (base, length);
265       if ((error = gcov_is_error ()))
266         {
267           printf (error < 0 ? "%s:counter overflow at %lu\n" :
268                   "%s:read error at %lu\n", filename,
269                   (long unsigned) gcov_position ());
270           break;
271         }
272     }
273   gcov_close ();
274 }
275
276 static void
277 tag_function (const char *filename ATTRIBUTE_UNUSED,
278               unsigned tag ATTRIBUTE_UNUSED, unsigned length)
279 {
280   unsigned long pos = gcov_position ();
281
282   if (!length)
283     printf (" placeholder");
284   else
285     {
286       printf (" ident=%u", gcov_read_unsigned ());
287       printf (", lineno_checksum=0x%08x", gcov_read_unsigned ());
288       printf (", cfg_checksum=0x%08x", gcov_read_unsigned ());
289
290       if (gcov_position () - pos < length)
291         {
292           const char *name;
293           
294           name = gcov_read_string ();
295           printf (", `%s'", name ? name : "NULL");
296           name = gcov_read_string ();
297           printf (" %s", name ? name : "NULL");
298           printf (":%u", gcov_read_unsigned ());
299         }
300     }
301 }
302
303 static void
304 tag_blocks (const char *filename ATTRIBUTE_UNUSED,
305             unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
306 {
307   unsigned n_blocks = GCOV_TAG_BLOCKS_NUM (length);
308
309   printf (" %u blocks", n_blocks);
310
311   if (flag_dump_contents)
312     {
313       unsigned ix;
314
315       for (ix = 0; ix != n_blocks; ix++)
316         {
317           if (!(ix & 7))
318             {
319               printf ("\n");
320               print_prefix (filename, 0, gcov_position ());
321               printf ("\t\t%u", ix);
322             }
323           printf (" %04x", gcov_read_unsigned ());
324         }
325     }
326 }
327
328 static void
329 tag_arcs (const char *filename ATTRIBUTE_UNUSED,
330           unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
331 {
332   unsigned n_arcs = GCOV_TAG_ARCS_NUM (length);
333
334   printf (" %u arcs", n_arcs);
335   if (flag_dump_contents)
336     {
337       unsigned ix;
338       unsigned blockno = gcov_read_unsigned ();
339
340       for (ix = 0; ix != n_arcs; ix++)
341         {
342           unsigned dst, flags;
343
344           if (!(ix & 3))
345             {
346               printf ("\n");
347               print_prefix (filename, 0, gcov_position ());
348               printf ("\tblock %u:", blockno);
349             }
350           dst = gcov_read_unsigned ();
351           flags = gcov_read_unsigned ();
352           printf (" %u:%04x", dst, flags);
353           if (flags)
354             {
355               char c = '(';
356               
357               if (flags & GCOV_ARC_ON_TREE)
358                 printf ("%ctree", c), c = ',';
359               if (flags & GCOV_ARC_FAKE)
360                 printf ("%cfake", c), c = ',';
361               if (flags & GCOV_ARC_FALLTHROUGH)
362                 printf ("%cfall", c), c = ',';
363               printf (")");
364             }
365         }
366     }
367 }
368
369 static void
370 tag_lines (const char *filename ATTRIBUTE_UNUSED,
371            unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
372 {
373   if (flag_dump_contents)
374     {
375       unsigned blockno = gcov_read_unsigned ();
376       char const *sep = NULL;
377
378       while (1)
379         {
380           gcov_position_t position = gcov_position ();
381           const char *source = NULL;
382           unsigned lineno = gcov_read_unsigned ();
383
384           if (!lineno)
385             {
386               source = gcov_read_string ();
387               if (!source)
388                 break;
389               sep = NULL;
390             }
391
392           if (!sep)
393             {
394               printf ("\n");
395               print_prefix (filename, 0, position);
396               printf ("\tblock %u:", blockno);
397               sep = "";
398             }
399           if (lineno)
400             {
401               printf ("%s%u", sep, lineno);
402               sep = ", ";
403             }
404           else
405             {
406               printf ("%s`%s'", sep, source);
407               sep = ":";
408             }
409         }
410     }
411 }
412
413 static void
414 tag_counters (const char *filename ATTRIBUTE_UNUSED,
415               unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
416 {
417   static const char *const counter_names[] = GCOV_COUNTER_NAMES;
418   unsigned n_counts = GCOV_TAG_COUNTER_NUM (length);
419
420   printf (" %s %u counts",
421           counter_names[GCOV_COUNTER_FOR_TAG (tag)], n_counts);
422   if (flag_dump_contents)
423     {
424       unsigned ix;
425
426       for (ix = 0; ix != n_counts; ix++)
427         {
428           gcov_type count;
429
430           if (!(ix & 7))
431             {
432               printf ("\n");
433               print_prefix (filename, 0, gcov_position ());
434               printf ("\t\t%u", ix);
435             }
436
437           count = gcov_read_counter ();
438           printf (" ");
439           printf (HOST_WIDEST_INT_PRINT_DEC, count);
440         }
441     }
442 }
443
444 static void
445 tag_summary (const char *filename ATTRIBUTE_UNUSED,
446              unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
447 {
448   struct gcov_summary summary;
449   unsigned ix, h_ix;
450   gcov_bucket_type *histo_bucket;
451
452   gcov_read_summary (&summary);
453   printf (" checksum=0x%08x", summary.checksum);
454
455   for (ix = 0; ix != GCOV_COUNTERS_SUMMABLE; ix++)
456     {
457       printf ("\n");
458       print_prefix (filename, 0, 0);
459       printf ("\t\tcounts=%u, runs=%u",
460               summary.ctrs[ix].num, summary.ctrs[ix].runs);
461
462       printf (", sum_all=" HOST_WIDEST_INT_PRINT_DEC,
463               (HOST_WIDEST_INT)summary.ctrs[ix].sum_all);
464       printf (", run_max=" HOST_WIDEST_INT_PRINT_DEC,
465               (HOST_WIDEST_INT)summary.ctrs[ix].run_max);
466       printf (", sum_max=" HOST_WIDEST_INT_PRINT_DEC,
467               (HOST_WIDEST_INT)summary.ctrs[ix].sum_max);
468       if (ix != GCOV_COUNTER_ARCS)
469         continue;
470       printf ("\n");
471       print_prefix (filename, 0, 0);
472       printf ("\t\tcounter histogram:");
473       for (h_ix = 0; h_ix < GCOV_HISTOGRAM_SIZE; h_ix++)
474         {
475           histo_bucket = &summary.ctrs[ix].histogram[h_ix];
476           if (!histo_bucket->num_counters)
477             continue;
478           printf ("\n");
479           print_prefix (filename, 0, 0);
480           printf ("\t\t%d: num counts=%u, min counter="
481               HOST_WIDEST_INT_PRINT_DEC ", cum_counter="
482               HOST_WIDEST_INT_PRINT_DEC,
483               h_ix, histo_bucket->num_counters,
484               (HOST_WIDEST_INT)histo_bucket->min_value,
485               (HOST_WIDEST_INT)histo_bucket->cum_value);
486         }
487     }
488 }