1 /* gmon_io.c - Input and output from/to gmon.out files.
3 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005
4 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
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 2 of the License, or
11 (at your option) any later version.
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.
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
24 #include "search_list.h"
28 #include "basic_blocks.h"
30 #include "call_graph.h"
33 #include "gmon.h" /* Fetch header for old format. */
36 #include "libiberty.h"
43 enum gmon_ptr_signedness
{
48 static enum gmon_ptr_size
gmon_get_ptr_size (void);
49 static enum gmon_ptr_signedness
gmon_get_ptr_signedness (void);
51 #ifdef BFD_HOST_U_64_BIT
52 static int gmon_io_read_64 (FILE *, BFD_HOST_U_64_BIT
*);
53 static int gmon_io_write_64 (FILE *, BFD_HOST_U_64_BIT
);
55 static int gmon_read_raw_arc
56 (FILE *, bfd_vma
*, bfd_vma
*, unsigned long *);
57 static int gmon_write_raw_arc
58 (FILE *, bfd_vma
, bfd_vma
, unsigned long);
61 int gmon_file_version
= 0; /* 0 == old (non-versioned) file format. */
63 static enum gmon_ptr_size
68 /* Pick best size for pointers. Start with the ELF size, and if not
69 elf go with the architecture's address size. */
70 size
= bfd_get_arch_size (core_bfd
);
72 size
= bfd_arch_bits_per_address (core_bfd
);
83 fprintf (stderr
, _("%s: address size has unexpected value of %u\n"),
89 static enum gmon_ptr_signedness
90 gmon_get_ptr_signedness ()
94 /* Figure out whether to sign extend. If BFD doesn't know, assume no. */
95 sext
= bfd_get_sign_extend_vma (core_bfd
);
98 return (sext
? ptr_signed
: ptr_unsigned
);
102 gmon_io_read_32 (FILE *ifp
, unsigned int *valp
)
106 if (fread (buf
, 1, 4, ifp
) != 4)
108 *valp
= bfd_get_32 (core_bfd
, buf
);
112 #ifdef BFD_HOST_U_64_BIT
114 gmon_io_read_64 (FILE *ifp
, BFD_HOST_U_64_BIT
*valp
)
118 if (fread (buf
, 1, 8, ifp
) != 8)
120 *valp
= bfd_get_64 (core_bfd
, buf
);
126 gmon_io_read_vma (FILE *ifp
, bfd_vma
*valp
)
129 #ifdef BFD_HOST_U_64_BIT
130 BFD_HOST_U_64_BIT val64
;
133 switch (gmon_get_ptr_size ())
136 if (gmon_io_read_32 (ifp
, &val32
))
138 if (gmon_get_ptr_signedness () == ptr_signed
)
144 #ifdef BFD_HOST_U_64_BIT
146 if (gmon_io_read_64 (ifp
, &val64
))
148 #ifdef BFD_HOST_64_BIT
149 if (gmon_get_ptr_signedness () == ptr_signed
)
150 *valp
= (BFD_HOST_64_BIT
) val64
;
161 gmon_io_read (FILE *ifp
, char *buf
, size_t n
)
163 if (fread (buf
, 1, n
, ifp
) != n
)
169 gmon_io_write_32 (FILE *ofp
, unsigned int val
)
173 bfd_put_32 (core_bfd
, (bfd_vma
) val
, buf
);
174 if (fwrite (buf
, 1, 4, ofp
) != 4)
179 #ifdef BFD_HOST_U_64_BIT
181 gmon_io_write_64 (FILE *ofp
, BFD_HOST_U_64_BIT val
)
185 bfd_put_64 (core_bfd
, (bfd_vma
) val
, buf
);
186 if (fwrite (buf
, 1, 8, ofp
) != 8)
193 gmon_io_write_vma (FILE *ofp
, bfd_vma val
)
196 switch (gmon_get_ptr_size ())
199 if (gmon_io_write_32 (ofp
, (unsigned int) val
))
203 #ifdef BFD_HOST_U_64_BIT
205 if (gmon_io_write_64 (ofp
, (BFD_HOST_U_64_BIT
) val
))
214 gmon_io_write_8 (FILE *ofp
, unsigned int val
)
218 bfd_put_8 (core_bfd
, val
, buf
);
219 if (fwrite (buf
, 1, 1, ofp
) != 1)
225 gmon_io_write (FILE *ofp
, char *buf
, size_t n
)
227 if (fwrite (buf
, 1, n
, ofp
) != n
)
233 gmon_read_raw_arc (FILE *ifp
, bfd_vma
*fpc
, bfd_vma
*spc
, unsigned long *cnt
)
235 #ifdef BFD_HOST_U_64_BIT
236 BFD_HOST_U_64_BIT cnt64
;
240 if (gmon_io_read_vma (ifp
, fpc
)
241 || gmon_io_read_vma (ifp
, spc
))
244 switch (gmon_get_ptr_size ())
247 if (gmon_io_read_32 (ifp
, &cnt32
))
252 #ifdef BFD_HOST_U_64_BIT
254 if (gmon_io_read_64 (ifp
, &cnt64
))
267 gmon_write_raw_arc (FILE *ofp
, bfd_vma fpc
, bfd_vma spc
, unsigned long cnt
)
270 if (gmon_io_write_vma (ofp
, fpc
)
271 || gmon_io_write_vma (ofp
, spc
))
274 switch (gmon_get_ptr_size ())
277 if (gmon_io_write_32 (ofp
, (unsigned int) cnt
))
281 #ifdef BFD_HOST_U_64_BIT
283 if (gmon_io_write_64 (ofp
, (BFD_HOST_U_64_BIT
) cnt
))
292 gmon_out_read (const char *filename
)
295 struct gmon_hdr ghdr
;
297 int nhist
= 0, narcs
= 0, nbbs
= 0;
299 /* Open gmon.out file. */
300 if (strcmp (filename
, "-") == 0)
304 SET_BINARY (fileno (stdin
));
309 ifp
= fopen (filename
, FOPEN_RB
);
318 if (fread (&ghdr
, sizeof (struct gmon_hdr
), 1, ifp
) != 1)
320 fprintf (stderr
, _("%s: file too short to be a gmon file\n"),
325 if ((file_format
== FF_MAGIC
)
326 || (file_format
== FF_AUTO
&& !strncmp (&ghdr
.cookie
[0], GMON_MAGIC
, 4)))
328 if (file_format
== FF_MAGIC
&& strncmp (&ghdr
.cookie
[0], GMON_MAGIC
, 4))
330 fprintf (stderr
, _("%s: file `%s' has bad magic cookie\n"),
335 /* Right magic, so it's probably really a new gmon.out file. */
336 gmon_file_version
= bfd_get_32 (core_bfd
, (bfd_byte
*) ghdr
.version
);
338 if (gmon_file_version
!= GMON_VERSION
&& gmon_file_version
!= 0)
341 _("%s: file `%s' has unsupported version %d\n"),
342 whoami
, filename
, gmon_file_version
);
346 /* Read in all the records. */
347 while (fread (&tag
, sizeof (tag
), 1, ifp
) == 1)
351 case GMON_TAG_TIME_HIST
:
353 gmon_input
|= INPUT_HISTOGRAM
;
354 hist_read_rec (ifp
, filename
);
357 case GMON_TAG_CG_ARC
:
359 gmon_input
|= INPUT_CALL_GRAPH
;
360 cg_read_rec (ifp
, filename
);
363 case GMON_TAG_BB_COUNT
:
365 gmon_input
|= INPUT_BB_COUNTS
;
366 bb_read_rec (ifp
, filename
);
371 _("%s: %s: found bad tag %d (file corrupted?)\n"),
372 whoami
, filename
, tag
);
377 else if (file_format
== FF_AUTO
378 || file_format
== FF_BSD
379 || file_format
== FF_BSD44
)
388 int samp_bytes
, header_size
= 0;
390 bfd_vma from_pc
, self_pc
;
394 unsigned int version
;
396 /* Information from a gmon.out file is in two parts: an array of
397 sampling hits within pc ranges, and the arcs. */
398 gmon_input
= INPUT_HISTOGRAM
| INPUT_CALL_GRAPH
;
400 /* This fseek() ought to work even on stdin as long as it's
401 not an interactive device (heck, is there anybody who would
402 want to type in a gmon.out at the terminal?). */
403 if (fseek (ifp
, 0, SEEK_SET
) < 0)
409 /* The beginning of the old BSD header and the 4.4BSD header
410 are the same: lowpc, highpc, ncnt */
411 if (gmon_io_read_vma (ifp
, &tmp
.low_pc
)
412 || gmon_io_read_vma (ifp
, &tmp
.high_pc
)
413 || gmon_io_read_32 (ifp
, &tmp
.ncnt
))
416 fprintf (stderr
, _("%s: file too short to be a gmon file\n"),
421 /* Check to see if this a 4.4BSD-style header. */
422 if (gmon_io_read_32 (ifp
, &version
))
425 if (version
== GMONVERSION
)
427 unsigned int profrate
;
429 /* 4.4BSD format header. */
430 if (gmon_io_read_32 (ifp
, &profrate
))
435 else if (hz
!= (int) profrate
)
438 _("%s: profiling rate incompatible with first gmon file\n"),
443 switch (gmon_get_ptr_size ())
446 header_size
= GMON_HDRSIZE_BSD44_32
;
450 header_size
= GMON_HDRSIZE_BSD44_64
;
456 /* Old style BSD format. */
457 if (file_format
== FF_BSD44
)
459 fprintf (stderr
, _("%s: file `%s' has bad magic cookie\n"),
464 switch (gmon_get_ptr_size ())
467 header_size
= GMON_HDRSIZE_OLDBSD_32
;
471 header_size
= GMON_HDRSIZE_OLDBSD_64
;
476 /* Position the file to after the header. */
477 if (fseek (ifp
, header_size
, SEEK_SET
) < 0)
483 if (s_highpc
&& (tmp
.low_pc
!= h
.low_pc
484 || tmp
.high_pc
!= h
.high_pc
|| tmp
.ncnt
!= h
.ncnt
))
486 fprintf (stderr
, _("%s: incompatible with first gmon file\n"),
492 s_lowpc
= (bfd_vma
) h
.low_pc
;
493 s_highpc
= (bfd_vma
) h
.high_pc
;
494 lowpc
= (bfd_vma
) h
.low_pc
/ sizeof (UNIT
);
495 highpc
= (bfd_vma
) h
.high_pc
/ sizeof (UNIT
);
496 samp_bytes
= h
.ncnt
- header_size
;
497 hist_num_bins
= samp_bytes
/ sizeof (UNIT
);
500 printf ("[gmon_out_read] lowpc 0x%lx highpc 0x%lx ncnt %d\n",
501 (unsigned long) h
.low_pc
, (unsigned long) h
.high_pc
,
503 printf ("[gmon_out_read] s_lowpc 0x%lx s_highpc 0x%lx\n",
504 (unsigned long) s_lowpc
, (unsigned long) s_highpc
);
505 printf ("[gmon_out_read] lowpc 0x%lx highpc 0x%lx\n",
506 (unsigned long) lowpc
, (unsigned long) highpc
);
507 printf ("[gmon_out_read] samp_bytes %d hist_num_bins %d\n",
508 samp_bytes
, hist_num_bins
));
510 /* Make sure that we have sensible values. */
511 if (samp_bytes
< 0 || lowpc
> highpc
)
514 _("%s: file '%s' does not appear to be in gmon.out format\n"),
525 (int *) xmalloc (hist_num_bins
* sizeof (hist_sample
[0]));
527 memset (hist_sample
, 0, hist_num_bins
* sizeof (hist_sample
[0]));
530 for (i
= 0; i
< hist_num_bins
; ++i
)
532 if (fread (raw_bin_count
, sizeof (raw_bin_count
), 1, ifp
) != 1)
535 _("%s: unexpected EOF after reading %d/%d bins\n"),
536 whoami
, --i
, hist_num_bins
);
540 hist_sample
[i
] += bfd_get_16 (core_bfd
, (bfd_byte
*) raw_bin_count
);
543 /* The rest of the file consists of a bunch of
544 <from,self,count> tuples. */
545 while (gmon_read_raw_arc (ifp
, &from_pc
, &self_pc
, &count
) == 0)
550 printf ("[gmon_out_read] frompc 0x%lx selfpc 0x%lx count %lu\n",
551 (unsigned long) from_pc
, (unsigned long) self_pc
, count
));
554 cg_tally (from_pc
, self_pc
, count
);
561 /* How many ticks per second? If we can't tell, report
568 fprintf (stderr
, _("time is in ticks, not seconds\n"));
574 fprintf (stderr
, _("%s: don't know how to deal with file format %d\n"),
575 whoami
, file_format
);
579 if (output_style
& STYLE_GMON_INFO
)
581 printf (_("File `%s' (version %d) contains:\n"),
582 filename
, gmon_file_version
);
584 _("\t%d histogram record\n") :
585 _("\t%d histogram records\n"), nhist
);
587 _("\t%d call-graph record\n") :
588 _("\t%d call-graph records\n"), narcs
);
590 _("\t%d basic-block count record\n") :
591 _("\t%d basic-block count records\n"), nbbs
);
592 first_output
= FALSE
;
598 gmon_out_write (const char *filename
)
601 struct gmon_hdr ghdr
;
603 ofp
= fopen (filename
, FOPEN_WB
);
610 if (file_format
== FF_AUTO
|| file_format
== FF_MAGIC
)
612 /* Write gmon header. */
614 memcpy (&ghdr
.cookie
[0], GMON_MAGIC
, 4);
615 bfd_put_32 (core_bfd
, (bfd_vma
) GMON_VERSION
, (bfd_byte
*) ghdr
.version
);
617 if (fwrite (&ghdr
, sizeof (ghdr
), 1, ofp
) != 1)
623 /* Write execution time histogram if we have one. */
624 if (gmon_input
& INPUT_HISTOGRAM
)
625 hist_write_hist (ofp
, filename
);
627 /* Write call graph arcs if we have any. */
628 if (gmon_input
& INPUT_CALL_GRAPH
)
629 cg_write_arcs (ofp
, filename
);
631 /* Write basic-block info if we have it. */
632 if (gmon_input
& INPUT_BB_COUNTS
)
633 bb_write_blocks (ofp
, filename
);
635 else if (file_format
== FF_BSD
|| file_format
== FF_BSD44
)
638 unsigned int i
, hdrsize
;
644 memset (pad
, 0, sizeof (pad
));
647 /* Decide how large the header will be. Use the 4.4BSD format
648 header if explicitly specified, or if the profiling rate is
649 non-standard. Otherwise, use the old BSD format. */
650 if (file_format
== FF_BSD44
654 switch (gmon_get_ptr_size ())
657 hdrsize
= GMON_HDRSIZE_BSD44_32
;
661 hdrsize
= GMON_HDRSIZE_BSD44_64
;
668 switch (gmon_get_ptr_size ())
671 hdrsize
= GMON_HDRSIZE_OLDBSD_32
;
675 hdrsize
= GMON_HDRSIZE_OLDBSD_64
;
676 /* FIXME: Checking host compiler defines here means that we can't
677 use a cross gprof alpha OSF. */
678 #if defined(__alpha__) && defined (__osf__)
685 /* Write the parts of the headers that are common to both the
686 old BSD and 4.4BSD formats. */
687 if (gmon_io_write_vma (ofp
, s_lowpc
)
688 || gmon_io_write_vma (ofp
, s_highpc
)
689 || gmon_io_write_32 (ofp
, hist_num_bins
* sizeof (UNIT
) + hdrsize
))
695 /* Write out the 4.4BSD header bits, if that's what we're using. */
696 if (file_format
== FF_BSD44
699 if (gmon_io_write_32 (ofp
, GMONVERSION
)
700 || gmon_io_write_32 (ofp
, (unsigned int) hz
))
707 /* Now write out any necessary padding after the meaningful
710 && fwrite (pad
, 1, padsize
, ofp
) != padsize
)
716 /* Dump the samples. */
717 for (i
= 0; i
< hist_num_bins
; ++i
)
719 bfd_put_16 (core_bfd
, (bfd_vma
) hist_sample
[i
],
720 (bfd_byte
*) &raw_bin_count
[0]);
721 if (fwrite (&raw_bin_count
[0], sizeof (raw_bin_count
), 1, ofp
) != 1)
728 /* Dump the normalized raw arc information. */
729 for (sym
= symtab
.base
; sym
< symtab
.limit
; ++sym
)
731 for (arc
= sym
->cg
.children
; arc
; arc
= arc
->next_child
)
733 if (gmon_write_raw_arc (ofp
, arc
->parent
->addr
,
734 arc
->child
->addr
, arc
->count
))
740 printf ("[dumpsum] frompc 0x%lx selfpc 0x%lx count %lu\n",
741 (unsigned long) arc
->parent
->addr
,
742 (unsigned long) arc
->child
->addr
, arc
->count
));
750 fprintf (stderr
, _("%s: don't know how to deal with file format %d\n"),
751 whoami
, file_format
);
This page took 0.045029 seconds and 4 git commands to generate.