2 * Input and output from/to gmon.out files.
5 #include "basic_blocks.h"
8 #include "call_graph.h"
11 #include "gmon.h" /* fetch header for old format */
15 #include "libiberty.h"
18 int gmon_file_version
= 0; /* 0 == old (non-versioned) file format */
21 * This probably ought to be in libbfd.
24 DEFUN (get_vma
, (abfd
, addr
), bfd
* abfd AND bfd_byte
* addr
)
26 switch (sizeof (char*))
29 return bfd_get_32 (abfd
, addr
);
31 return bfd_get_64 (abfd
, addr
);
33 fprintf (stderr
, "%s: bfd_vma has unexpected size of %ld bytes\n",
34 whoami
, (long) sizeof (char*));
41 * This probably ought to be in libbfd.
44 DEFUN (put_vma
, (abfd
, val
, addr
), bfd
* abfd AND bfd_vma val AND bfd_byte
* addr
)
46 switch (sizeof (char*))
49 bfd_put_32 (abfd
, val
, addr
);
52 bfd_put_64 (abfd
, val
, addr
);
55 fprintf (stderr
, "%s: bfd_vma has unexpected size of %ld bytes\n",
56 whoami
, (long) sizeof (char*));
63 DEFUN (gmon_out_read
, (filename
), const char *filename
)
68 int nhist
= 0, narcs
= 0, nbbs
= 0;
70 /* open gmon.out file: */
72 if (strcmp (filename
, "-") == 0)
78 ifp
= fopen (filename
, FOPEN_RB
);
85 if (fread (&ghdr
, sizeof (struct gmon_hdr
), 1, ifp
) != 1)
87 fprintf (stderr
, "%s: file too short to be a gmon file\n",
92 if ((file_format
== FF_MAGIC
) ||
93 (file_format
== FF_AUTO
&& !strncmp (&ghdr
.cookie
[0], GMON_MAGIC
, 4)))
95 if (file_format
== FF_MAGIC
&& strncmp (&ghdr
.cookie
[0], GMON_MAGIC
, 4))
97 fprintf (stderr
, "%s: file `%s' has bad magic cookie\n",
102 /* right magic, so it's probably really a new gmon.out file */
104 gmon_file_version
= bfd_get_32 (core_bfd
, (bfd_byte
*) ghdr
.version
);
105 if (gmon_file_version
!= GMON_VERSION
&& gmon_file_version
!= 0)
108 "%s: file `%s' has unsupported version %d\n",
109 whoami
, filename
, gmon_file_version
);
113 /* read in all the records: */
114 while (fread (&tag
, sizeof (tag
), 1, ifp
) == 1)
118 case GMON_TAG_TIME_HIST
:
120 gmon_input
|= INPUT_HISTOGRAM
;
121 hist_read_rec (ifp
, filename
);
124 case GMON_TAG_CG_ARC
:
126 gmon_input
|= INPUT_CALL_GRAPH
;
127 cg_read_rec (ifp
, filename
);
130 case GMON_TAG_BB_COUNT
:
132 gmon_input
|= INPUT_BB_COUNTS
;
133 bb_read_rec (ifp
, filename
);
138 "%s: %s: found bad tag %d (file corrupted?)\n",
139 whoami
, filename
, tag
);
144 else if (file_format
== FF_AUTO
|| file_format
== FF_BSD
)
152 int i
, samp_bytes
, count
;
153 bfd_vma from_pc
, self_pc
;
154 struct raw_arc raw_arc
;
161 * Information from a gmon.out file is in two parts: an array of
162 * sampling hits within pc ranges, and the arcs.
164 gmon_input
= INPUT_HISTOGRAM
| INPUT_CALL_GRAPH
;
167 * This fseek() ought to work even on stdin as long as it's
168 * not an interactive device (heck, is there anybody who would
169 * want to type in a gmon.out at the terminal?).
171 if (fseek (ifp
, 0, SEEK_SET
) < 0)
176 if (fread (&raw
, 1, sizeof (struct raw_phdr
), ifp
)
177 != sizeof (struct raw_phdr
))
179 fprintf (stderr
, "%s: file too short to be a gmon file\n",
183 tmp
.low_pc
= get_vma (core_bfd
, (bfd_byte
*) &raw
.low_pc
[0]);
184 tmp
.high_pc
= get_vma (core_bfd
, (bfd_byte
*) &raw
.high_pc
[0]);
185 tmp
.ncnt
= bfd_get_32 (core_bfd
, (bfd_byte
*) &raw
.ncnt
[0]);
191 profrate
= bfd_get_32 (core_bfd
, (bfd_byte
*) &raw
.version
[0]);
194 else if (hz
!= profrate
)
197 "%s: profiling rate incompatible with first gmon file\n",
204 if (s_highpc
&& (tmp
.low_pc
!= h
.low_pc
||
205 tmp
.high_pc
!= h
.high_pc
|| tmp
.ncnt
!= h
.ncnt
))
207 fprintf (stderr
, "%s: incompatible with first gmon file\n",
212 s_lowpc
= (bfd_vma
) h
.low_pc
;
213 s_highpc
= (bfd_vma
) h
.high_pc
;
214 lowpc
= (bfd_vma
) h
.low_pc
/ sizeof (UNIT
);
215 highpc
= (bfd_vma
) h
.high_pc
/ sizeof (UNIT
);
216 samp_bytes
= h
.ncnt
- sizeof (struct raw_phdr
);
217 hist_num_bins
= samp_bytes
/ sizeof (UNIT
);
219 printf ("[gmon_out_read] lowpc 0x%lx highpc 0x%lx ncnt %d\n",
220 h
.low_pc
, h
.high_pc
, h
.ncnt
);
221 printf ("[gmon_out_read] s_lowpc 0x%lx s_highpc 0x%lx\n",
223 printf ("[gmon_out_read] lowpc 0x%lx highpc 0x%lx\n",
225 printf ("[gmon_out_read] samp_bytes %d hist_num_bins %d\n",
226 samp_bytes
, hist_num_bins
));
236 (int *) xmalloc (hist_num_bins
* sizeof (hist_sample
[0]));
237 memset (hist_sample
, 0, hist_num_bins
* sizeof (hist_sample
[0]));
240 for (i
= 0; i
< hist_num_bins
; ++i
)
242 if (fread (raw_bin_count
, sizeof (raw_bin_count
), 1, ifp
) != 1)
245 "%s: unexpected EOF after reading %d/%d bins\n",
246 whoami
, --i
, hist_num_bins
);
249 hist_sample
[i
] += bfd_get_16 (core_bfd
, (bfd_byte
*) raw_bin_count
);
253 * The rest of the file consists of a bunch of <from,self,count>
256 while (fread (&raw_arc
, sizeof (raw_arc
), 1, ifp
) == 1)
259 from_pc
= get_vma (core_bfd
, (bfd_byte
*) raw_arc
.from_pc
);
260 self_pc
= get_vma (core_bfd
, (bfd_byte
*) raw_arc
.self_pc
);
261 count
= bfd_get_32 (core_bfd
, (bfd_byte
*) raw_arc
.count
);
263 printf ("[gmon_out_read] frompc 0x%lx selfpc 0x%lx count %d\n",
264 from_pc
, self_pc
, count
));
266 cg_tally (from_pc
, self_pc
, count
);
273 * How many ticks per second? If we can't tell, report
280 fprintf (stderr
, "time is in ticks, not seconds\n");
286 fprintf (stderr
, "%s: don't know how to deal with file format %d\n",
287 whoami
, file_format
);
291 if (output_style
& STYLE_GMON_INFO
)
293 printf ("File `%s' (version %d) contains:\n",
294 filename
, gmon_file_version
);
295 printf ("\t%d histogram record%s\n",
296 nhist
, nhist
== 1 ? "" : "s");
297 printf ("\t%d call-graph record%s\n",
298 narcs
, narcs
== 1 ? "" : "s");
299 printf ("\t%d basic-block count record%s\n",
300 nbbs
, nbbs
== 1 ? "" : "s");
301 first_output
= FALSE
;
307 DEFUN (gmon_out_write
, (filename
), const char *filename
)
310 struct gmon_hdr ghdr
;
312 ofp
= fopen (filename
, FOPEN_WB
);
319 if (file_format
== FF_AUTO
|| file_format
== FF_MAGIC
)
321 /* write gmon header: */
323 memcpy (&ghdr
.cookie
[0], GMON_MAGIC
, 4);
324 bfd_put_32 (core_bfd
, GMON_VERSION
, (bfd_byte
*) ghdr
.version
);
325 if (fwrite (&ghdr
, sizeof (ghdr
), 1, ofp
) != 1)
331 /* write execution time histogram if we have one: */
332 if (gmon_input
& INPUT_HISTOGRAM
)
334 hist_write_hist (ofp
, filename
);
337 /* write call graph arcs if we have any: */
338 if (gmon_input
& INPUT_CALL_GRAPH
)
340 cg_write_arcs (ofp
, filename
);
343 /* write basic-block info if we have it: */
344 if (gmon_input
& INPUT_BB_COUNTS
)
346 bb_write_blocks (ofp
, filename
);
349 else if (file_format
== FF_BSD
)
351 struct raw_arc raw_arc
;
358 put_vma (core_bfd
, s_lowpc
, (bfd_byte
*) & lpc
);
359 put_vma (core_bfd
, s_highpc
, (bfd_byte
*) & hpc
);
360 bfd_put_32 (core_bfd
,
361 hist_num_bins
* sizeof (UNIT
) + sizeof (struct raw_phdr
),
362 (bfd_byte
*) & ncnt
);
365 if (fwrite (&lpc
, sizeof (lpc
), 1, ofp
) != 1
366 || fwrite (&hpc
, sizeof (hpc
), 1, ofp
) != 1
367 || fwrite (&ncnt
, sizeof (ncnt
), 1, ofp
) != 1)
373 /* dump the samples: */
375 for (i
= 0; i
< hist_num_bins
; ++i
)
377 bfd_put_16 (core_bfd
, hist_sample
[i
], (bfd_byte
*) & raw_bin_count
[0]);
378 if (fwrite (&raw_bin_count
[0], sizeof (raw_bin_count
), 1, ofp
) != 1)
385 /* dump the normalized raw arc information: */
387 for (sym
= symtab
.base
; sym
< symtab
.limit
; ++sym
)
389 for (arc
= sym
->cg
.children
; arc
; arc
= arc
->next_child
)
391 put_vma (core_bfd
, arc
->parent
->addr
,
392 (bfd_byte
*) raw_arc
.from_pc
);
393 put_vma (core_bfd
, arc
->child
->addr
,
394 (bfd_byte
*) raw_arc
.self_pc
);
395 bfd_put_32 (core_bfd
, arc
->count
, (bfd_byte
*) raw_arc
.count
);
396 if (fwrite (&raw_arc
, sizeof (raw_arc
), 1, ofp
) != 1)
402 printf ("[dumpsum] frompc 0x%lx selfpc 0x%lx count %d\n",
403 arc
->parent
->addr
, arc
->child
->addr
, arc
->count
));
410 fprintf (stderr
, "%s: don't know how to deal with file format %d\n",
411 whoami
, file_format
);