Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / binutils-2.22 / gprof / gmon_io.c
1 /* gmon_io.c - Input and output from/to gmon.out files.
2
3    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
4    Free Software Foundation, Inc.
5
6    This file is part of GNU Binutils.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
21    02110-1301, USA.  */
22 \f
23 #include "gprof.h"
24 #include "binary-io.h"
25 #include "search_list.h"
26 #include "source.h"
27 #include "symtab.h"
28 #include "cg_arcs.h"
29 #include "basic_blocks.h"
30 #include "corefile.h"
31 #include "call_graph.h"
32 #include "gmon_io.h"
33 #include "gmon_out.h"
34 #include "gmon.h"               /* Fetch header for old format.  */
35 #include "hertz.h"
36 #include "hist.h"
37 #include "libiberty.h"
38
39 enum gmon_ptr_size {
40   ptr_32bit,
41   ptr_64bit
42 };
43
44 enum gmon_ptr_signedness {
45   ptr_signed,
46   ptr_unsigned
47 };
48
49 static enum gmon_ptr_size gmon_get_ptr_size (void);
50 static enum gmon_ptr_signedness gmon_get_ptr_signedness (void);
51
52 #ifdef BFD_HOST_U_64_BIT
53 static int gmon_io_read_64 (FILE *, BFD_HOST_U_64_BIT *);
54 static int gmon_io_write_64 (FILE *, BFD_HOST_U_64_BIT);
55 #endif
56 static int gmon_read_raw_arc
57   (FILE *, bfd_vma *, bfd_vma *, unsigned long *);
58 static int gmon_write_raw_arc
59   (FILE *, bfd_vma, bfd_vma, unsigned long);
60
61 int gmon_input = 0;
62 int gmon_file_version = 0;      /* 0 == old (non-versioned) file format.  */
63
64 static enum gmon_ptr_size
65 gmon_get_ptr_size ()
66 {
67   int size;
68
69   /* Pick best size for pointers.  Start with the ELF size, and if not
70      elf go with the architecture's address size.  */
71   size = bfd_get_arch_size (core_bfd);
72   if (size == -1)
73     size = bfd_arch_bits_per_address (core_bfd);
74
75   switch (size)
76     {
77     case 32:
78       return ptr_32bit;
79
80     case 64:
81       return ptr_64bit;
82
83     default:
84       fprintf (stderr, _("%s: address size has unexpected value of %u\n"),
85                whoami, size);
86       done (1);
87     }
88 }
89
90 static enum gmon_ptr_signedness
91 gmon_get_ptr_signedness ()
92 {
93   int sext;
94
95   /* Figure out whether to sign extend.  If BFD doesn't know, assume no.  */
96   sext = bfd_get_sign_extend_vma (core_bfd);
97   if (sext == -1)
98     return ptr_unsigned;
99   return (sext ? ptr_signed : ptr_unsigned);
100 }
101
102 int
103 gmon_io_read_32 (FILE *ifp, unsigned int *valp)
104 {
105   char buf[4];
106
107   if (fread (buf, 1, 4, ifp) != 4)
108     return 1;
109   *valp = bfd_get_32 (core_bfd, buf);
110   return 0;
111 }
112
113 #ifdef BFD_HOST_U_64_BIT
114 static int
115 gmon_io_read_64 (FILE *ifp, BFD_HOST_U_64_BIT *valp)
116 {
117   char buf[8];
118
119   if (fread (buf, 1, 8, ifp) != 8)
120     return 1;
121   *valp = bfd_get_64 (core_bfd, buf);
122   return 0;
123 }
124 #endif
125
126 int
127 gmon_io_read_vma (FILE *ifp, bfd_vma *valp)
128 {
129   unsigned int val32;
130 #ifdef BFD_HOST_U_64_BIT
131   BFD_HOST_U_64_BIT val64;
132 #endif
133
134   switch (gmon_get_ptr_size ())
135     {
136     case ptr_32bit:
137       if (gmon_io_read_32 (ifp, &val32))
138         return 1;
139       if (gmon_get_ptr_signedness () == ptr_signed)
140         *valp = (int) val32;
141       else
142         *valp = val32;
143       break;
144
145 #ifdef BFD_HOST_U_64_BIT
146     case ptr_64bit:
147       if (gmon_io_read_64 (ifp, &val64))
148         return 1;
149 #ifdef BFD_HOST_64_BIT
150       if (gmon_get_ptr_signedness () == ptr_signed)
151         *valp = (BFD_HOST_64_BIT) val64;
152       else
153 #endif
154         *valp = val64;
155       break;
156 #endif
157     }
158   return 0;
159 }
160
161 int
162 gmon_io_read (FILE *ifp, char *buf, size_t n)
163 {
164   if (fread (buf, 1, n, ifp) != n)
165     return 1;
166   return 0;
167 }
168
169 int
170 gmon_io_write_32 (FILE *ofp, unsigned int val)
171 {
172   char buf[4];
173
174   bfd_put_32 (core_bfd, (bfd_vma) val, buf);
175   if (fwrite (buf, 1, 4, ofp) != 4)
176     return 1;
177   return 0;
178 }
179
180 #ifdef BFD_HOST_U_64_BIT
181 static int
182 gmon_io_write_64 (FILE *ofp, BFD_HOST_U_64_BIT val)
183 {
184   char buf[8];
185
186   bfd_put_64 (core_bfd, (bfd_vma) val, buf);
187   if (fwrite (buf, 1, 8, ofp) != 8)
188     return 1;
189   return 0;
190 }
191 #endif
192
193 int
194 gmon_io_write_vma (FILE *ofp, bfd_vma val)
195 {
196
197   switch (gmon_get_ptr_size ())
198     {
199     case ptr_32bit:
200       if (gmon_io_write_32 (ofp, (unsigned int) val))
201         return 1;
202       break;
203
204 #ifdef BFD_HOST_U_64_BIT
205     case ptr_64bit:
206       if (gmon_io_write_64 (ofp, (BFD_HOST_U_64_BIT) val))
207         return 1;
208       break;
209 #endif
210     }
211   return 0;
212 }
213
214 int
215 gmon_io_write_8 (FILE *ofp, unsigned int val)
216 {
217   char buf[1];
218
219   bfd_put_8 (core_bfd, val, buf);
220   if (fwrite (buf, 1, 1, ofp) != 1)
221     return 1;
222   return 0;
223 }
224
225 int
226 gmon_io_write (FILE *ofp, char *buf, size_t n)
227 {
228   if (fwrite (buf, 1, n, ofp) != n)
229     return 1;
230   return 0;
231 }
232
233 static int
234 gmon_read_raw_arc (FILE *ifp, bfd_vma *fpc, bfd_vma *spc, unsigned long *cnt)
235 {
236 #ifdef BFD_HOST_U_64_BIT
237   BFD_HOST_U_64_BIT cnt64;
238 #endif
239   unsigned int cnt32;
240
241   if (gmon_io_read_vma (ifp, fpc)
242       || gmon_io_read_vma (ifp, spc))
243     return 1;
244
245   switch (gmon_get_ptr_size ())
246     {
247     case ptr_32bit:
248       if (gmon_io_read_32 (ifp, &cnt32))
249         return 1;
250       *cnt = cnt32;
251       break;
252
253 #ifdef BFD_HOST_U_64_BIT
254     case ptr_64bit:
255       if (gmon_io_read_64 (ifp, &cnt64))
256         return 1;
257       *cnt = cnt64;
258       break;
259 #endif
260
261     default:
262       return 1;
263     }
264   return 0;
265 }
266
267 static int
268 gmon_write_raw_arc (FILE *ofp, bfd_vma fpc, bfd_vma spc, unsigned long cnt)
269 {
270
271   if (gmon_io_write_vma (ofp, fpc)
272       || gmon_io_write_vma (ofp, spc))
273     return 1;
274
275   switch (gmon_get_ptr_size ())
276     {
277     case ptr_32bit:
278       if (gmon_io_write_32 (ofp, (unsigned int) cnt))
279         return 1;
280       break;
281
282 #ifdef BFD_HOST_U_64_BIT
283     case ptr_64bit:
284       if (gmon_io_write_64 (ofp, (BFD_HOST_U_64_BIT) cnt))
285         return 1;
286       break;
287 #endif
288     }
289   return 0;
290 }
291
292 void
293 gmon_out_read (const char *filename)
294 {
295   FILE *ifp;
296   struct gmon_hdr ghdr;
297   unsigned char tag;
298   int nhist = 0, narcs = 0, nbbs = 0;
299
300   /* Open gmon.out file.  */
301   if (strcmp (filename, "-") == 0)
302     {
303       ifp = stdin;
304       SET_BINARY (fileno (stdin));
305     }
306   else
307     {
308       ifp = fopen (filename, FOPEN_RB);
309
310       if (!ifp)
311         {
312           perror (filename);
313           done (1);
314         }
315     }
316
317   if (fread (&ghdr, sizeof (struct gmon_hdr), 1, ifp) != 1)
318     {
319       fprintf (stderr, _("%s: file too short to be a gmon file\n"),
320                filename);
321       done (1);
322     }
323
324   if ((file_format == FF_MAGIC)
325       || (file_format == FF_AUTO && !strncmp (&ghdr.cookie[0], GMON_MAGIC, 4)))
326     {
327       if (file_format == FF_MAGIC && strncmp (&ghdr.cookie[0], GMON_MAGIC, 4))
328         {
329           fprintf (stderr, _("%s: file `%s' has bad magic cookie\n"),
330                    whoami, filename);
331           done (1);
332         }
333
334       /* Right magic, so it's probably really a new gmon.out file.  */
335       gmon_file_version = bfd_get_32 (core_bfd, (bfd_byte *) ghdr.version);
336
337       if (gmon_file_version != GMON_VERSION && gmon_file_version != 0)
338         {
339           fprintf (stderr,
340                    _("%s: file `%s' has unsupported version %d\n"),
341                    whoami, filename, gmon_file_version);
342           done (1);
343         }
344
345       /* Read in all the records.  */
346       while (fread (&tag, sizeof (tag), 1, ifp) == 1)
347         {
348           switch (tag)
349             {
350             case GMON_TAG_TIME_HIST:
351               ++nhist;
352               gmon_input |= INPUT_HISTOGRAM;
353               hist_read_rec (ifp, filename);
354               break;
355
356             case GMON_TAG_CG_ARC:
357               ++narcs;
358               gmon_input |= INPUT_CALL_GRAPH;
359               cg_read_rec (ifp, filename);
360               break;
361
362             case GMON_TAG_BB_COUNT:
363               ++nbbs;
364               gmon_input |= INPUT_BB_COUNTS;
365               bb_read_rec (ifp, filename);
366               break;
367
368             default:
369               fprintf (stderr,
370                        _("%s: %s: found bad tag %d (file corrupted?)\n"),
371                        whoami, filename, tag);
372               done (1);
373             }
374         }
375     }
376   else if (file_format == FF_AUTO
377            || file_format == FF_BSD
378            || file_format == FF_BSD44)
379     {
380       struct hdr
381       {
382         bfd_vma low_pc;
383         bfd_vma high_pc;
384         unsigned int ncnt;
385       };
386       unsigned int i;
387       int samp_bytes, header_size = 0;
388       unsigned long count;
389       bfd_vma from_pc, self_pc;
390       UNIT raw_bin_count;
391       struct hdr tmp;
392       unsigned int version;
393       unsigned int hist_num_bins;
394
395       /* Information from a gmon.out file is in two parts: an array of
396          sampling hits within pc ranges, and the arcs.  */
397       gmon_input = INPUT_HISTOGRAM | INPUT_CALL_GRAPH;
398
399       /* This fseek() ought to work even on stdin as long as it's
400          not an interactive device (heck, is there anybody who would
401          want to type in a gmon.out at the terminal?).  */
402       if (fseek (ifp, 0, SEEK_SET) < 0)
403         {
404           perror (filename);
405           done (1);
406         }
407
408       /* The beginning of the old BSD header and the 4.4BSD header
409          are the same: lowpc, highpc, ncnt  */
410       if (gmon_io_read_vma (ifp, &tmp.low_pc)
411           || gmon_io_read_vma (ifp, &tmp.high_pc)
412           || gmon_io_read_32 (ifp, &tmp.ncnt))
413         {
414  bad_gmon_file:
415           fprintf (stderr, _("%s: file too short to be a gmon file\n"),
416                    filename);
417           done (1);
418         }
419
420       /* Check to see if this a 4.4BSD-style header.  */
421       if (gmon_io_read_32 (ifp, &version))
422         goto bad_gmon_file;
423
424       if (version == GMONVERSION)
425         {
426           unsigned int profrate;
427
428           /* 4.4BSD format header.  */
429           if (gmon_io_read_32 (ifp, &profrate))
430             goto bad_gmon_file;
431
432           if (!histograms)
433             hz = profrate;
434           else if (hz != (int) profrate)
435             {
436               fprintf (stderr,
437                        _("%s: profiling rate incompatible with first gmon file\n"),
438                        filename);
439               done (1);
440             }
441
442           switch (gmon_get_ptr_size ())
443             {
444             case ptr_32bit:
445               header_size = GMON_HDRSIZE_BSD44_32;
446               break;
447
448             case ptr_64bit:
449               header_size = GMON_HDRSIZE_BSD44_64;
450               break;
451             }
452         }
453       else
454         {
455           /* Old style BSD format.  */
456           if (file_format == FF_BSD44)
457             {
458               fprintf (stderr, _("%s: file `%s' has bad magic cookie\n"),
459                        whoami, filename);
460               done (1);
461             }
462
463           switch (gmon_get_ptr_size ())
464             {
465             case ptr_32bit:
466               header_size = GMON_HDRSIZE_OLDBSD_32;
467               break;
468
469             case ptr_64bit:
470               header_size = GMON_HDRSIZE_OLDBSD_64;
471               break;
472             }
473         }
474
475       /* Position the file to after the header.  */
476       if (fseek (ifp, header_size, SEEK_SET) < 0)
477         {
478           perror (filename);
479           done (1);
480         }
481
482       samp_bytes = tmp.ncnt - header_size;
483       hist_num_bins = samp_bytes / sizeof (UNIT);
484       if (histograms && (tmp.low_pc != histograms->lowpc
485                          || tmp.high_pc != histograms->highpc
486                          || (hist_num_bins != histograms->num_bins)))
487         {
488           fprintf (stderr, _("%s: incompatible with first gmon file\n"),
489                    filename);
490           done (1);
491         }
492
493       if (!histograms)
494         {
495           num_histograms = 1;
496           histograms = (struct histogram *) xmalloc (sizeof (struct histogram));
497           histograms->lowpc = tmp.low_pc;
498           histograms->highpc = tmp.high_pc;
499           histograms->num_bins = hist_num_bins;
500           hist_scale = (double)((tmp.high_pc - tmp.low_pc) / sizeof (UNIT))
501             / hist_num_bins;
502           histograms->sample = (int *) xmalloc (hist_num_bins * sizeof (int));
503           memset (histograms->sample, 0, 
504                   hist_num_bins * sizeof (int));
505         }
506
507       DBG (SAMPLEDEBUG,
508            printf ("[gmon_out_read] lowpc 0x%lx highpc 0x%lx ncnt %d\n",
509                    (unsigned long) tmp.low_pc, (unsigned long) tmp.high_pc,
510                    tmp.ncnt);
511            printf ("[gmon_out_read] samp_bytes %d hist_num_bins %d\n",
512                    samp_bytes, hist_num_bins));
513
514       /* Make sure that we have sensible values.  */
515       if (samp_bytes < 0 || histograms->lowpc > histograms->highpc)
516         {
517           fprintf (stderr,
518             _("%s: file '%s' does not appear to be in gmon.out format\n"),
519             whoami, filename);
520           done (1);
521         }
522
523       if (hist_num_bins)
524         ++nhist;
525
526       for (i = 0; i < hist_num_bins; ++i)
527         {
528           if (fread (raw_bin_count, sizeof (raw_bin_count), 1, ifp) != 1)
529             {
530               fprintf (stderr,
531                        _("%s: unexpected EOF after reading %d/%d bins\n"),
532                        whoami, --i, hist_num_bins);
533               done (1);
534             }
535
536           histograms->sample[i] 
537             += bfd_get_16 (core_bfd, (bfd_byte *) raw_bin_count);
538         }
539
540       /* The rest of the file consists of a bunch of
541          <from,self,count> tuples.  */
542       while (gmon_read_raw_arc (ifp, &from_pc, &self_pc, &count) == 0)
543         {
544           ++narcs;
545
546           DBG (SAMPLEDEBUG,
547              printf ("[gmon_out_read] frompc 0x%lx selfpc 0x%lx count %lu\n",
548                      (unsigned long) from_pc, (unsigned long) self_pc, count));
549
550           /* Add this arc.  */
551           cg_tally (from_pc, self_pc, count);
552         }
553
554       if (hz == HZ_WRONG)
555         {
556           /* How many ticks per second?  If we can't tell, report
557              time in ticks.  */
558           hz = hertz ();
559
560           if (hz == HZ_WRONG)
561             {
562               hz = 1;
563               fprintf (stderr, _("time is in ticks, not seconds\n"));
564             }
565         }
566     }
567   else
568     {
569       fprintf (stderr, _("%s: don't know how to deal with file format %d\n"),
570                whoami, file_format);
571       done (1);
572     }
573
574   if (ifp != stdin)
575     fclose (ifp);
576
577   if (output_style & STYLE_GMON_INFO)
578     {
579       printf (_("File `%s' (version %d) contains:\n"),
580               filename, gmon_file_version);
581       printf (nhist == 1 ?
582               _("\t%d histogram record\n") :
583               _("\t%d histogram records\n"), nhist);
584       printf (narcs == 1 ?
585               _("\t%d call-graph record\n") :
586               _("\t%d call-graph records\n"), narcs);
587       printf (nbbs == 1 ?
588               _("\t%d basic-block count record\n") :
589               _("\t%d basic-block count records\n"), nbbs);
590       first_output = FALSE;
591     }
592 }
593
594
595 void
596 gmon_out_write (const char *filename)
597 {
598   FILE *ofp;
599   struct gmon_hdr ghdr;
600
601   ofp = fopen (filename, FOPEN_WB);
602   if (!ofp)
603     {
604       perror (filename);
605       done (1);
606     }
607
608   if (file_format == FF_AUTO || file_format == FF_MAGIC)
609     {
610       /* Write gmon header.  */
611
612       memcpy (&ghdr.cookie[0], GMON_MAGIC, 4);
613       bfd_put_32 (core_bfd, (bfd_vma) GMON_VERSION, (bfd_byte *) ghdr.version);
614
615       if (fwrite (&ghdr, sizeof (ghdr), 1, ofp) != 1)
616         {
617           perror (filename);
618           done (1);
619         }
620
621       /* Write execution time histogram if we have one.  */
622       if (gmon_input & INPUT_HISTOGRAM)
623         hist_write_hist (ofp, filename);
624
625       /* Write call graph arcs if we have any.  */
626       if (gmon_input & INPUT_CALL_GRAPH)
627         cg_write_arcs (ofp, filename);
628
629       /* Write basic-block info if we have it.  */
630       if (gmon_input & INPUT_BB_COUNTS)
631         bb_write_blocks (ofp, filename);
632     }
633   else if (file_format == FF_BSD || file_format == FF_BSD44)
634     {
635       UNIT raw_bin_count;
636       unsigned int i, hdrsize;
637       unsigned padsize;
638       char pad[3*4];
639       Arc *arc;
640       Sym *sym;
641
642       memset (pad, 0, sizeof (pad));
643
644       hdrsize = 0;
645       /* Decide how large the header will be.  Use the 4.4BSD format
646          header if explicitly specified, or if the profiling rate is
647          non-standard.  Otherwise, use the old BSD format.  */
648       if (file_format == FF_BSD44
649           || hz != hertz())
650         {
651           padsize = 3*4;
652           switch (gmon_get_ptr_size ())
653             {
654             case ptr_32bit:
655               hdrsize = GMON_HDRSIZE_BSD44_32;
656               break;
657
658             case ptr_64bit:
659               hdrsize = GMON_HDRSIZE_BSD44_64;
660               break;
661             }
662         }
663       else
664         {
665           padsize = 0;
666           switch (gmon_get_ptr_size ())
667             {
668             case ptr_32bit:
669               hdrsize = GMON_HDRSIZE_OLDBSD_32;
670               break;
671
672             case ptr_64bit:
673               hdrsize = GMON_HDRSIZE_OLDBSD_64;
674               /* FIXME: Checking host compiler defines here means that we can't
675                  use a cross gprof alpha OSF.  */ 
676 #if defined(__alpha__) && defined (__osf__)
677               padsize = 4;
678 #endif
679               break;
680             }
681         }
682
683       /* Write the parts of the headers that are common to both the
684          old BSD and 4.4BSD formats.  */
685       if (gmon_io_write_vma (ofp, histograms->lowpc)
686           || gmon_io_write_vma (ofp, histograms->highpc)
687           || gmon_io_write_32 (ofp, histograms->num_bins 
688                                * sizeof (UNIT) + hdrsize))
689         {
690           perror (filename);
691           done (1);
692         }
693
694       /* Write out the 4.4BSD header bits, if that's what we're using.  */
695       if (file_format == FF_BSD44
696           || hz != hertz())
697         {
698           if (gmon_io_write_32 (ofp, GMONVERSION)
699               || gmon_io_write_32 (ofp, (unsigned int) hz))
700             {
701               perror (filename);
702               done (1);
703             }
704         }
705
706       /* Now write out any necessary padding after the meaningful
707          header bits.  */
708       if (padsize != 0
709           && fwrite (pad, 1, padsize, ofp) != padsize)
710         {
711           perror (filename);
712           done (1);
713         }
714
715       /* Dump the samples.  */
716       for (i = 0; i < histograms->num_bins; ++i)
717         {
718           bfd_put_16 (core_bfd, (bfd_vma) histograms->sample[i],
719                       (bfd_byte *) &raw_bin_count[0]);
720           if (fwrite (&raw_bin_count[0], sizeof (raw_bin_count), 1, ofp) != 1)
721             {
722               perror (filename);
723               done (1);
724             }
725         }
726
727       /* Dump the normalized raw arc information.  */
728       for (sym = symtab.base; sym < symtab.limit; ++sym)
729         {
730           for (arc = sym->cg.children; arc; arc = arc->next_child)
731             {
732               if (gmon_write_raw_arc (ofp, arc->parent->addr,
733                                       arc->child->addr, arc->count))
734                 {
735                   perror (filename);
736                   done (1);
737                 }
738               DBG (SAMPLEDEBUG,
739                    printf ("[dumpsum] frompc 0x%lx selfpc 0x%lx count %lu\n",
740                            (unsigned long) arc->parent->addr,
741                            (unsigned long) arc->child->addr, arc->count));
742             }
743         }
744
745       fclose (ofp);
746     }
747   else
748     {
749       fprintf (stderr, _("%s: don't know how to deal with file format %d\n"),
750                whoami, file_format);
751       done (1);
752     }
753 }