1 /* gmon_io.c - Input and output from/to gmon.out files.
3 Copyright 2000, 2001, 2002, 2004, 2005 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
23 #include "search_list.h"
27 #include "basic_blocks.h"
29 #include "call_graph.h"
32 #include "gmon.h" /* Fetch header for old format. */
35 #include "libiberty.h"
42 enum gmon_ptr_signedness
{
47 static enum gmon_ptr_size
gmon_get_ptr_size (void);
48 static enum gmon_ptr_signedness
gmon_get_ptr_signedness (void);
50 #ifdef BFD_HOST_U_64_BIT
51 static int gmon_io_read_64 (FILE *, BFD_HOST_U_64_BIT
*);
52 static int gmon_io_write_64 (FILE *, BFD_HOST_U_64_BIT
);
54 static int gmon_read_raw_arc
55 (FILE *, bfd_vma
*, bfd_vma
*, unsigned long *);
56 static int gmon_write_raw_arc
57 (FILE *, bfd_vma
, bfd_vma
, unsigned long);
60 int gmon_file_version
= 0; /* 0 == old (non-versioned) file format. */
62 static enum gmon_ptr_size
67 /* Pick best size for pointers. Start with the ELF size, and if not
68 elf go with the architecture's address size. */
69 size
= bfd_get_arch_size (core_bfd
);
71 size
= bfd_arch_bits_per_address (core_bfd
);
82 fprintf (stderr
, _("%s: address size has unexpected value of %u\n"),
88 static enum gmon_ptr_signedness
89 gmon_get_ptr_signedness ()
93 /* Figure out whether to sign extend. If BFD doesn't know, assume no. */
94 sext
= bfd_get_sign_extend_vma (core_bfd
);
97 return (sext
? ptr_signed
: ptr_unsigned
);
101 gmon_io_read_32 (FILE *ifp
, unsigned int *valp
)
105 if (fread (buf
, 1, 4, ifp
) != 4)
107 *valp
= bfd_get_32 (core_bfd
, buf
);
111 #ifdef BFD_HOST_U_64_BIT
113 gmon_io_read_64 (FILE *ifp
, BFD_HOST_U_64_BIT
*valp
)
117 if (fread (buf
, 1, 8, ifp
) != 8)
119 *valp
= bfd_get_64 (core_bfd
, buf
);
125 gmon_io_read_vma (FILE *ifp
, bfd_vma
*valp
)
128 #ifdef BFD_HOST_U_64_BIT
129 BFD_HOST_U_64_BIT val64
;
132 switch (gmon_get_ptr_size ())
135 if (gmon_io_read_32 (ifp
, &val32
))
137 if (gmon_get_ptr_signedness () == ptr_signed
)
143 #ifdef BFD_HOST_U_64_BIT
145 if (gmon_io_read_64 (ifp
, &val64
))
147 #ifdef BFD_HOST_64_BIT
148 if (gmon_get_ptr_signedness () == ptr_signed
)
149 *valp
= (BFD_HOST_64_BIT
) val64
;
160 gmon_io_read (FILE *ifp
, char *buf
, size_t n
)
162 if (fread (buf
, 1, n
, ifp
) != n
)
168 gmon_io_write_32 (FILE *ofp
, unsigned int val
)
172 bfd_put_32 (core_bfd
, (bfd_vma
) val
, buf
);
173 if (fwrite (buf
, 1, 4, ofp
) != 4)
178 #ifdef BFD_HOST_U_64_BIT
180 gmon_io_write_64 (FILE *ofp
, BFD_HOST_U_64_BIT val
)
184 bfd_put_64 (core_bfd
, (bfd_vma
) val
, buf
);
185 if (fwrite (buf
, 1, 8, ofp
) != 8)
192 gmon_io_write_vma (FILE *ofp
, bfd_vma val
)
195 switch (gmon_get_ptr_size ())
198 if (gmon_io_write_32 (ofp
, (unsigned int) val
))
202 #ifdef BFD_HOST_U_64_BIT
204 if (gmon_io_write_64 (ofp
, (BFD_HOST_U_64_BIT
) val
))
213 gmon_io_write_8 (FILE *ofp
, unsigned int val
)
217 bfd_put_8 (core_bfd
, val
, buf
);
218 if (fwrite (buf
, 1, 1, ofp
) != 1)
224 gmon_io_write (FILE *ofp
, char *buf
, size_t n
)
226 if (fwrite (buf
, 1, n
, ofp
) != n
)
232 gmon_read_raw_arc (FILE *ifp
, bfd_vma
*fpc
, bfd_vma
*spc
, unsigned long *cnt
)
234 #ifdef BFD_HOST_U_64_BIT
235 BFD_HOST_U_64_BIT cnt64
;
239 if (gmon_io_read_vma (ifp
, fpc
)
240 || gmon_io_read_vma (ifp
, spc
))
243 switch (gmon_get_ptr_size ())
246 if (gmon_io_read_32 (ifp
, &cnt32
))
251 #ifdef BFD_HOST_U_64_BIT
253 if (gmon_io_read_64 (ifp
, &cnt64
))
263 gmon_write_raw_arc (FILE *ofp
, bfd_vma fpc
, bfd_vma spc
, unsigned long cnt
)
266 if (gmon_io_write_vma (ofp
, fpc
)
267 || gmon_io_write_vma (ofp
, spc
))
270 switch (gmon_get_ptr_size ())
273 if (gmon_io_write_32 (ofp
, (unsigned int) cnt
))
277 #ifdef BFD_HOST_U_64_BIT
279 if (gmon_io_write_64 (ofp
, (BFD_HOST_U_64_BIT
) cnt
))
288 gmon_out_read (const char *filename
)
291 struct gmon_hdr ghdr
;
293 int nhist
= 0, narcs
= 0, nbbs
= 0;
295 /* Open gmon.out file. */
296 if (strcmp (filename
, "-") == 0)
300 SET_BINARY (fileno (stdin
));
305 ifp
= fopen (filename
, FOPEN_RB
);
314 if (fread (&ghdr
, sizeof (struct gmon_hdr
), 1, ifp
) != 1)
316 fprintf (stderr
, _("%s: file too short to be a gmon file\n"),
321 if ((file_format
== FF_MAGIC
)
322 || (file_format
== FF_AUTO
&& !strncmp (&ghdr
.cookie
[0], GMON_MAGIC
, 4)))
324 if (file_format
== FF_MAGIC
&& strncmp (&ghdr
.cookie
[0], GMON_MAGIC
, 4))
326 fprintf (stderr
, _("%s: file `%s' has bad magic cookie\n"),
331 /* Right magic, so it's probably really a new gmon.out file. */
332 gmon_file_version
= bfd_get_32 (core_bfd
, (bfd_byte
*) ghdr
.version
);
334 if (gmon_file_version
!= GMON_VERSION
&& gmon_file_version
!= 0)
337 _("%s: file `%s' has unsupported version %d\n"),
338 whoami
, filename
, gmon_file_version
);
342 /* Read in all the records. */
343 while (fread (&tag
, sizeof (tag
), 1, ifp
) == 1)
347 case GMON_TAG_TIME_HIST
:
349 gmon_input
|= INPUT_HISTOGRAM
;
350 hist_read_rec (ifp
, filename
);
353 case GMON_TAG_CG_ARC
:
355 gmon_input
|= INPUT_CALL_GRAPH
;
356 cg_read_rec (ifp
, filename
);
359 case GMON_TAG_BB_COUNT
:
361 gmon_input
|= INPUT_BB_COUNTS
;
362 bb_read_rec (ifp
, filename
);
367 _("%s: %s: found bad tag %d (file corrupted?)\n"),
368 whoami
, filename
, tag
);
373 else if (file_format
== FF_AUTO
374 || file_format
== FF_BSD
375 || file_format
== FF_BSD44
)
384 int samp_bytes
, header_size
= 0;
386 bfd_vma from_pc
, self_pc
;
390 unsigned int version
;
392 /* Information from a gmon.out file is in two parts: an array of
393 sampling hits within pc ranges, and the arcs. */
394 gmon_input
= INPUT_HISTOGRAM
| INPUT_CALL_GRAPH
;
396 /* This fseek() ought to work even on stdin as long as it's
397 not an interactive device (heck, is there anybody who would
398 want to type in a gmon.out at the terminal?). */
399 if (fseek (ifp
, 0, SEEK_SET
) < 0)
405 /* The beginning of the old BSD header and the 4.4BSD header
406 are the same: lowpc, highpc, ncnt */
407 if (gmon_io_read_vma (ifp
, &tmp
.low_pc
)
408 || gmon_io_read_vma (ifp
, &tmp
.high_pc
)
409 || gmon_io_read_32 (ifp
, &tmp
.ncnt
))
412 fprintf (stderr
, _("%s: file too short to be a gmon file\n"),
417 /* Check to see if this a 4.4BSD-style header. */
418 if (gmon_io_read_32 (ifp
, &version
))
421 if (version
== GMONVERSION
)
423 unsigned int profrate
;
425 /* 4.4BSD format header. */
426 if (gmon_io_read_32 (ifp
, &profrate
))
431 else if (hz
!= (int) profrate
)
434 _("%s: profiling rate incompatible with first gmon file\n"),
439 switch (gmon_get_ptr_size ())
442 header_size
= GMON_HDRSIZE_BSD44_32
;
446 header_size
= GMON_HDRSIZE_BSD44_64
;
452 /* Old style BSD format. */
453 if (file_format
== FF_BSD44
)
455 fprintf (stderr
, _("%s: file `%s' has bad magic cookie\n"),
460 switch (gmon_get_ptr_size ())
463 header_size
= GMON_HDRSIZE_OLDBSD_32
;
467 header_size
= GMON_HDRSIZE_OLDBSD_64
;
472 /* Position the file to after the header. */
473 if (fseek (ifp
, header_size
, SEEK_SET
) < 0)
479 if (s_highpc
&& (tmp
.low_pc
!= h
.low_pc
480 || tmp
.high_pc
!= h
.high_pc
|| tmp
.ncnt
!= h
.ncnt
))
482 fprintf (stderr
, _("%s: incompatible with first gmon file\n"),
488 s_lowpc
= (bfd_vma
) h
.low_pc
;
489 s_highpc
= (bfd_vma
) h
.high_pc
;
490 lowpc
= (bfd_vma
) h
.low_pc
/ sizeof (UNIT
);
491 highpc
= (bfd_vma
) h
.high_pc
/ sizeof (UNIT
);
492 samp_bytes
= h
.ncnt
- header_size
;
493 hist_num_bins
= samp_bytes
/ sizeof (UNIT
);
496 printf ("[gmon_out_read] lowpc 0x%lx highpc 0x%lx ncnt %d\n",
497 (unsigned long) h
.low_pc
, (unsigned long) h
.high_pc
,
499 printf ("[gmon_out_read] s_lowpc 0x%lx s_highpc 0x%lx\n",
500 (unsigned long) s_lowpc
, (unsigned long) s_highpc
);
501 printf ("[gmon_out_read] lowpc 0x%lx highpc 0x%lx\n",
502 (unsigned long) lowpc
, (unsigned long) highpc
);
503 printf ("[gmon_out_read] samp_bytes %d hist_num_bins %d\n",
504 samp_bytes
, hist_num_bins
));
506 /* Make sure that we have sensible values. */
507 if (samp_bytes
< 0 || lowpc
> highpc
)
510 _("%s: file '%s' does not appear to be in gmon.out format\n"),
521 (int *) xmalloc (hist_num_bins
* sizeof (hist_sample
[0]));
523 memset (hist_sample
, 0, hist_num_bins
* sizeof (hist_sample
[0]));
526 for (i
= 0; i
< hist_num_bins
; ++i
)
528 if (fread (raw_bin_count
, sizeof (raw_bin_count
), 1, ifp
) != 1)
531 _("%s: unexpected EOF after reading %d/%d bins\n"),
532 whoami
, --i
, hist_num_bins
);
536 hist_sample
[i
] += bfd_get_16 (core_bfd
, (bfd_byte
*) raw_bin_count
);
539 /* The rest of the file consists of a bunch of
540 <from,self,count> tuples. */
541 while (gmon_read_raw_arc (ifp
, &from_pc
, &self_pc
, &count
) == 0)
546 printf ("[gmon_out_read] frompc 0x%lx selfpc 0x%lx count %lu\n",
547 (unsigned long) from_pc
, (unsigned long) self_pc
, count
));
550 cg_tally (from_pc
, self_pc
, count
);
557 /* How many ticks per second? If we can't tell, report
564 fprintf (stderr
, _("time is in ticks, not seconds\n"));
570 fprintf (stderr
, _("%s: don't know how to deal with file format %d\n"),
571 whoami
, file_format
);
575 if (output_style
& STYLE_GMON_INFO
)
577 printf (_("File `%s' (version %d) contains:\n"),
578 filename
, gmon_file_version
);
580 _("\t%d histogram record\n") :
581 _("\t%d histogram records\n"), nhist
);
583 _("\t%d call-graph record\n") :
584 _("\t%d call-graph records\n"), narcs
);
586 _("\t%d basic-block count record\n") :
587 _("\t%d basic-block count records\n"), nbbs
);
588 first_output
= FALSE
;
594 gmon_out_write (const char *filename
)
597 struct gmon_hdr ghdr
;
599 ofp
= fopen (filename
, FOPEN_WB
);
606 if (file_format
== FF_AUTO
|| file_format
== FF_MAGIC
)
608 /* Write gmon header. */
610 memcpy (&ghdr
.cookie
[0], GMON_MAGIC
, 4);
611 bfd_put_32 (core_bfd
, (bfd_vma
) GMON_VERSION
, (bfd_byte
*) ghdr
.version
);
613 if (fwrite (&ghdr
, sizeof (ghdr
), 1, ofp
) != 1)
619 /* Write execution time histogram if we have one. */
620 if (gmon_input
& INPUT_HISTOGRAM
)
621 hist_write_hist (ofp
, filename
);
623 /* Write call graph arcs if we have any. */
624 if (gmon_input
& INPUT_CALL_GRAPH
)
625 cg_write_arcs (ofp
, filename
);
627 /* Write basic-block info if we have it. */
628 if (gmon_input
& INPUT_BB_COUNTS
)
629 bb_write_blocks (ofp
, filename
);
631 else if (file_format
== FF_BSD
|| file_format
== FF_BSD44
)
634 unsigned int i
, hdrsize
;
640 memset (pad
, 0, sizeof (pad
));
643 /* Decide how large the header will be. Use the 4.4BSD format
644 header if explicitly specified, or if the profiling rate is
645 non-standard. Otherwise, use the old BSD format. */
646 if (file_format
== FF_BSD44
650 switch (gmon_get_ptr_size ())
653 hdrsize
= GMON_HDRSIZE_BSD44_32
;
657 hdrsize
= GMON_HDRSIZE_BSD44_64
;
664 switch (gmon_get_ptr_size ())
667 hdrsize
= GMON_HDRSIZE_OLDBSD_32
;
671 hdrsize
= GMON_HDRSIZE_OLDBSD_64
;
672 /* FIXME: Checking host compiler defines here means that we can't
673 use a cross gprof alpha OSF. */
674 #if defined(__alpha__) && defined (__osf__)
681 /* Write the parts of the headers that are common to both the
682 old BSD and 4.4BSD formats. */
683 if (gmon_io_write_vma (ofp
, s_lowpc
)
684 || gmon_io_write_vma (ofp
, s_highpc
)
685 || gmon_io_write_32 (ofp
, hist_num_bins
* sizeof (UNIT
) + hdrsize
))
691 /* Write out the 4.4BSD header bits, if that's what we're using. */
692 if (file_format
== FF_BSD44
695 if (gmon_io_write_32 (ofp
, GMONVERSION
)
696 || gmon_io_write_32 (ofp
, (unsigned int) hz
))
703 /* Now write out any necessary padding after the meaningful
706 && fwrite (pad
, 1, padsize
, ofp
) != padsize
)
712 /* Dump the samples. */
713 for (i
= 0; i
< hist_num_bins
; ++i
)
715 bfd_put_16 (core_bfd
, (bfd_vma
) hist_sample
[i
],
716 (bfd_byte
*) &raw_bin_count
[0]);
717 if (fwrite (&raw_bin_count
[0], sizeof (raw_bin_count
), 1, ofp
) != 1)
724 /* Dump the normalized raw arc information. */
725 for (sym
= symtab
.base
; sym
< symtab
.limit
; ++sym
)
727 for (arc
= sym
->cg
.children
; arc
; arc
= arc
->next_child
)
729 if (gmon_write_raw_arc (ofp
, arc
->parent
->addr
,
730 arc
->child
->addr
, arc
->count
))
736 printf ("[dumpsum] frompc 0x%lx selfpc 0x%lx count %lu\n",
737 (unsigned long) arc
->parent
->addr
,
738 (unsigned long) arc
->child
->addr
, arc
->count
));
746 fprintf (stderr
, _("%s: don't know how to deal with file format %d\n"),
747 whoami
, file_format
);