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]);
186 if (s_highpc
&& (tmp
.low_pc
!= h
.low_pc
||
187 tmp
.high_pc
!= h
.high_pc
|| tmp
.ncnt
!= h
.ncnt
))
189 fprintf (stderr
, "%s: incompatible with first gmon file\n",
194 s_lowpc
= (bfd_vma
) h
.low_pc
;
195 s_highpc
= (bfd_vma
) h
.high_pc
;
196 lowpc
= (bfd_vma
) h
.low_pc
/ sizeof (UNIT
);
197 highpc
= (bfd_vma
) h
.high_pc
/ sizeof (UNIT
);
198 samp_bytes
= h
.ncnt
- sizeof (struct raw_phdr
);
199 hist_num_bins
= samp_bytes
/ sizeof (UNIT
);
201 printf ("[gmon_out_read] lowpc 0x%lx highpc 0x%lx ncnt %d\n",
202 h
.low_pc
, h
.high_pc
, h
.ncnt
);
203 printf ("[gmon_out_read] s_lowpc 0x%lx s_highpc 0x%lx\n",
205 printf ("[gmon_out_read] lowpc 0x%lx highpc 0x%lx\n",
207 printf ("[gmon_out_read] samp_bytes %d hist_num_bins %d\n",
208 samp_bytes
, hist_num_bins
));
218 (int *) xmalloc (hist_num_bins
* sizeof (hist_sample
[0]));
219 memset (hist_sample
, 0, hist_num_bins
* sizeof (hist_sample
[0]));
222 for (i
= 0; i
< hist_num_bins
; ++i
)
224 if (fread (raw_bin_count
, sizeof (raw_bin_count
), 1, ifp
) != 1)
227 "%s: unexpected EOF after reading %d/%d bins\n",
228 whoami
, --i
, hist_num_bins
);
231 hist_sample
[i
] += bfd_get_16 (core_bfd
, (bfd_byte
*) raw_bin_count
);
235 * The rest of the file consists of a bunch of <from,self,count>
238 while (fread (&raw_arc
, sizeof (raw_arc
), 1, ifp
) == 1)
241 from_pc
= get_vma (core_bfd
, (bfd_byte
*) raw_arc
.from_pc
);
242 self_pc
= get_vma (core_bfd
, (bfd_byte
*) raw_arc
.self_pc
);
243 count
= bfd_get_32 (core_bfd
, (bfd_byte
*) raw_arc
.count
);
245 printf ("[gmon_out_read] frompc 0x%lx selfpc 0x%lx count %d\n",
246 from_pc
, self_pc
, count
));
248 cg_tally (from_pc
, self_pc
, count
);
255 * How many ticks per second? If we can't tell, report
262 fprintf (stderr
, "time is in ticks, not seconds\n");
268 fprintf (stderr
, "%s: don't know how to deal with file format %d\n",
269 whoami
, file_format
);
273 if (output_style
& STYLE_GMON_INFO
)
275 printf ("File `%s' (version %d) contains:\n",
276 filename
, gmon_file_version
);
277 printf ("\t%d histogram record%s\n",
278 nhist
, nhist
== 1 ? "" : "s");
279 printf ("\t%d call-graph record%s\n",
280 narcs
, narcs
== 1 ? "" : "s");
281 printf ("\t%d basic-block count record%s\n",
282 nbbs
, nbbs
== 1 ? "" : "s");
283 first_output
= FALSE
;
289 DEFUN (gmon_out_write
, (filename
), const char *filename
)
292 struct gmon_hdr ghdr
;
294 ofp
= fopen (filename
, FOPEN_WB
);
301 if (file_format
== FF_AUTO
|| file_format
== FF_MAGIC
)
303 /* write gmon header: */
305 memcpy (&ghdr
.cookie
[0], GMON_MAGIC
, 4);
306 bfd_put_32 (core_bfd
, GMON_VERSION
, (bfd_byte
*) ghdr
.version
);
307 if (fwrite (&ghdr
, sizeof (ghdr
), 1, ofp
) != 1)
313 /* write execution time histogram if we have one: */
314 if (gmon_input
& INPUT_HISTOGRAM
)
316 hist_write_hist (ofp
, filename
);
319 /* write call graph arcs if we have any: */
320 if (gmon_input
& INPUT_CALL_GRAPH
)
322 cg_write_arcs (ofp
, filename
);
325 /* write basic-block info if we have it: */
326 if (gmon_input
& INPUT_BB_COUNTS
)
328 bb_write_blocks (ofp
, filename
);
331 else if (file_format
== FF_BSD
)
333 struct raw_arc raw_arc
;
340 put_vma (core_bfd
, s_lowpc
, (bfd_byte
*) & lpc
);
341 put_vma (core_bfd
, s_highpc
, (bfd_byte
*) & hpc
);
342 bfd_put_32 (core_bfd
,
343 hist_num_bins
* sizeof (UNIT
) + sizeof (struct raw_phdr
),
344 (bfd_byte
*) & ncnt
);
347 if (fwrite (&lpc
, sizeof (lpc
), 1, ofp
) != 1
348 || fwrite (&hpc
, sizeof (hpc
), 1, ofp
) != 1
349 || fwrite (&ncnt
, sizeof (ncnt
), 1, ofp
) != 1)
355 /* dump the samples: */
357 for (i
= 0; i
< hist_num_bins
; ++i
)
359 bfd_put_16 (core_bfd
, hist_sample
[i
], (bfd_byte
*) & raw_bin_count
[0]);
360 if (fwrite (&raw_bin_count
[0], sizeof (raw_bin_count
), 1, ofp
) != 1)
367 /* dump the normalized raw arc information: */
369 for (sym
= symtab
.base
; sym
< symtab
.limit
; ++sym
)
371 for (arc
= sym
->cg
.children
; arc
; arc
= arc
->next_child
)
373 put_vma (core_bfd
, arc
->parent
->addr
,
374 (bfd_byte
*) raw_arc
.from_pc
);
375 put_vma (core_bfd
, arc
->child
->addr
,
376 (bfd_byte
*) raw_arc
.self_pc
);
377 bfd_put_32 (core_bfd
, arc
->count
, (bfd_byte
*) raw_arc
.count
);
378 if (fwrite (&raw_arc
, sizeof (raw_arc
), 1, ofp
) != 1)
384 printf ("[dumpsum] frompc 0x%lx selfpc 0x%lx count %d\n",
385 arc
->parent
->addr
, arc
->child
->addr
, arc
->count
));
392 fprintf (stderr
, "%s: don't know how to deal with file format %d\n",
393 whoami
, file_format
);