Commit | Line | Data |
---|---|---|
252b5132 RH |
1 | /* |
2 | * Input and output from/to gmon.out files. | |
3 | */ | |
4 | #include "cg_arcs.h" | |
5 | #include "basic_blocks.h" | |
6 | #include "bfd.h" | |
7 | #include "corefile.h" | |
8 | #include "call_graph.h" | |
9 | #include "gmon_io.h" | |
10 | #include "gmon_out.h" | |
11 | #include "gmon.h" /* fetch header for old format */ | |
12 | #include "gprof.h" | |
13 | #include "hertz.h" | |
14 | #include "hist.h" | |
15 | #include "libiberty.h" | |
16 | ||
17 | int gmon_input = 0; | |
18 | int gmon_file_version = 0; /* 0 == old (non-versioned) file format */ | |
19 | ||
20 | /* | |
21 | * This probably ought to be in libbfd. | |
22 | */ | |
23 | bfd_vma | |
24 | DEFUN (get_vma, (abfd, addr), bfd * abfd AND bfd_byte * addr) | |
25 | { | |
26 | switch (sizeof (char*)) | |
27 | { | |
28 | case 4: | |
29 | return bfd_get_32 (abfd, addr); | |
30 | case 8: | |
31 | return bfd_get_64 (abfd, addr); | |
32 | default: | |
33 | fprintf (stderr, _("%s: bfd_vma has unexpected size of %ld bytes\n"), | |
34 | whoami, (long) sizeof (char*)); | |
35 | done (1); | |
36 | } | |
37 | } | |
38 | ||
39 | ||
40 | /* | |
41 | * This probably ought to be in libbfd. | |
42 | */ | |
43 | void | |
44 | DEFUN (put_vma, (abfd, val, addr), bfd * abfd AND bfd_vma val AND bfd_byte * addr) | |
45 | { | |
46 | switch (sizeof (char*)) | |
47 | { | |
48 | case 4: | |
49 | bfd_put_32 (abfd, val, addr); | |
50 | break; | |
51 | case 8: | |
52 | bfd_put_64 (abfd, val, addr); | |
53 | break; | |
54 | default: | |
55 | fprintf (stderr, _("%s: bfd_vma has unexpected size of %ld bytes\n"), | |
56 | whoami, (long) sizeof (char*)); | |
57 | done (1); | |
58 | } | |
59 | } | |
60 | ||
61 | ||
62 | void | |
63 | DEFUN (gmon_out_read, (filename), const char *filename) | |
64 | { | |
65 | FILE *ifp; | |
66 | struct gmon_hdr ghdr; | |
67 | unsigned char tag; | |
68 | int nhist = 0, narcs = 0, nbbs = 0; | |
69 | ||
70 | /* open gmon.out file: */ | |
71 | ||
72 | if (strcmp (filename, "-") == 0) | |
73 | { | |
74 | ifp = stdin; | |
5af11cab AM |
75 | #ifdef SET_BINARY |
76 | SET_BINARY (fileno (stdin)); | |
77 | #endif | |
252b5132 RH |
78 | } |
79 | else | |
80 | { | |
81 | ifp = fopen (filename, FOPEN_RB); | |
82 | if (!ifp) | |
83 | { | |
84 | perror (filename); | |
85 | done (1); | |
86 | } | |
87 | } | |
88 | if (fread (&ghdr, sizeof (struct gmon_hdr), 1, ifp) != 1) | |
89 | { | |
90 | fprintf (stderr, _("%s: file too short to be a gmon file\n"), | |
91 | filename); | |
92 | done (1); | |
93 | } | |
94 | ||
95 | if ((file_format == FF_MAGIC) || | |
96 | (file_format == FF_AUTO && !strncmp (&ghdr.cookie[0], GMON_MAGIC, 4))) | |
97 | { | |
98 | if (file_format == FF_MAGIC && strncmp (&ghdr.cookie[0], GMON_MAGIC, 4)) | |
99 | { | |
100 | fprintf (stderr, _("%s: file `%s' has bad magic cookie\n"), | |
101 | whoami, filename); | |
102 | done (1); | |
103 | } | |
104 | ||
105 | /* right magic, so it's probably really a new gmon.out file */ | |
106 | ||
107 | gmon_file_version = bfd_get_32 (core_bfd, (bfd_byte *) ghdr.version); | |
108 | if (gmon_file_version != GMON_VERSION && gmon_file_version != 0) | |
109 | { | |
110 | fprintf (stderr, | |
111 | _("%s: file `%s' has unsupported version %d\n"), | |
112 | whoami, filename, gmon_file_version); | |
113 | done (1); | |
114 | } | |
115 | ||
116 | /* read in all the records: */ | |
117 | while (fread (&tag, sizeof (tag), 1, ifp) == 1) | |
118 | { | |
119 | switch (tag) | |
120 | { | |
121 | case GMON_TAG_TIME_HIST: | |
122 | ++nhist; | |
123 | gmon_input |= INPUT_HISTOGRAM; | |
124 | hist_read_rec (ifp, filename); | |
125 | break; | |
126 | ||
127 | case GMON_TAG_CG_ARC: | |
128 | ++narcs; | |
129 | gmon_input |= INPUT_CALL_GRAPH; | |
130 | cg_read_rec (ifp, filename); | |
131 | break; | |
132 | ||
133 | case GMON_TAG_BB_COUNT: | |
134 | ++nbbs; | |
135 | gmon_input |= INPUT_BB_COUNTS; | |
136 | bb_read_rec (ifp, filename); | |
137 | break; | |
138 | ||
139 | default: | |
140 | fprintf (stderr, | |
141 | _("%s: %s: found bad tag %d (file corrupted?)\n"), | |
142 | whoami, filename, tag); | |
143 | done (1); | |
144 | } | |
145 | } | |
146 | } | |
147 | else if (file_format == FF_AUTO | |
148 | || file_format == FF_BSD | |
149 | || file_format == FF_BSD44) | |
150 | { | |
151 | struct hdr | |
152 | { | |
153 | bfd_vma low_pc; | |
154 | bfd_vma high_pc; | |
155 | int ncnt; | |
156 | }; | |
157 | int i, samp_bytes, header_size; | |
158 | unsigned long count; | |
159 | bfd_vma from_pc, self_pc; | |
160 | struct raw_arc raw_arc; | |
161 | struct raw_phdr raw; | |
162 | static struct hdr h; | |
163 | UNIT raw_bin_count; | |
164 | struct hdr tmp; | |
165 | ||
166 | /* | |
167 | * Information from a gmon.out file is in two parts: an array of | |
168 | * sampling hits within pc ranges, and the arcs. | |
169 | */ | |
170 | gmon_input = INPUT_HISTOGRAM | INPUT_CALL_GRAPH; | |
171 | ||
172 | /* | |
173 | * This fseek() ought to work even on stdin as long as it's | |
174 | * not an interactive device (heck, is there anybody who would | |
175 | * want to type in a gmon.out at the terminal?). | |
176 | */ | |
177 | if (fseek (ifp, 0, SEEK_SET) < 0) | |
178 | { | |
179 | perror (filename); | |
180 | done (1); | |
181 | } | |
182 | if (fread (&raw, 1, sizeof (struct raw_phdr), ifp) | |
183 | != sizeof (struct raw_phdr)) | |
184 | { | |
185 | fprintf (stderr, _("%s: file too short to be a gmon file\n"), | |
186 | filename); | |
187 | done (1); | |
188 | } | |
189 | tmp.low_pc = get_vma (core_bfd, (bfd_byte *) &raw.low_pc[0]); | |
190 | tmp.high_pc = get_vma (core_bfd, (bfd_byte *) &raw.high_pc[0]); | |
191 | tmp.ncnt = bfd_get_32 (core_bfd, (bfd_byte *) &raw.ncnt[0]); | |
192 | ||
193 | if (bfd_get_32 (core_bfd, (bfd_byte *) &raw.version[0]) | |
194 | == GMONVERSION) | |
195 | { | |
196 | int profrate; | |
197 | ||
198 | /* 4.4BSD format header. */ | |
199 | ||
200 | profrate = bfd_get_32 (core_bfd, (bfd_byte *) &raw.profrate[0]); | |
201 | if (!s_highpc) | |
202 | hz = profrate; | |
203 | else if (hz != profrate) | |
204 | { | |
205 | fprintf (stderr, | |
206 | _("%s: profiling rate incompatible with first gmon file\n"), | |
207 | filename); | |
208 | done (1); | |
209 | } | |
210 | ||
211 | header_size = sizeof (struct raw_phdr); | |
212 | } | |
213 | else | |
214 | { | |
215 | /* old style BSD format. */ | |
216 | if (file_format == FF_BSD44) | |
217 | { | |
218 | fprintf (stderr, _("%s: file `%s' has bad magic cookie\n"), | |
219 | whoami, filename); | |
220 | done (1); | |
221 | } | |
222 | ||
223 | if (fseek (ifp, sizeof (struct old_raw_phdr), SEEK_SET) < 0) | |
224 | { | |
225 | perror (filename); | |
226 | done (1); | |
227 | } | |
228 | ||
229 | header_size = sizeof (struct old_raw_phdr); | |
230 | } | |
231 | ||
232 | if (s_highpc && (tmp.low_pc != h.low_pc || | |
233 | tmp.high_pc != h.high_pc || tmp.ncnt != h.ncnt)) | |
234 | { | |
235 | fprintf (stderr, _("%s: incompatible with first gmon file\n"), | |
236 | filename); | |
237 | done (1); | |
238 | } | |
239 | h = tmp; | |
240 | s_lowpc = (bfd_vma) h.low_pc; | |
241 | s_highpc = (bfd_vma) h.high_pc; | |
242 | lowpc = (bfd_vma) h.low_pc / sizeof (UNIT); | |
243 | highpc = (bfd_vma) h.high_pc / sizeof (UNIT); | |
244 | samp_bytes = h.ncnt - header_size; | |
245 | hist_num_bins = samp_bytes / sizeof (UNIT); | |
246 | DBG (SAMPLEDEBUG, | |
247 | printf ("[gmon_out_read] lowpc 0x%lx highpc 0x%lx ncnt %d\n", | |
fdcf7d43 ILT |
248 | (unsigned long) h.low_pc, (unsigned long) h.high_pc, |
249 | h.ncnt); | |
252b5132 | 250 | printf ("[gmon_out_read] s_lowpc 0x%lx s_highpc 0x%lx\n", |
fdcf7d43 | 251 | (unsigned long) s_lowpc, (unsigned long) s_highpc); |
252b5132 | 252 | printf ("[gmon_out_read] lowpc 0x%lx highpc 0x%lx\n", |
fdcf7d43 | 253 | (unsigned long) lowpc, (unsigned long) highpc); |
252b5132 RH |
254 | printf ("[gmon_out_read] samp_bytes %d hist_num_bins %d\n", |
255 | samp_bytes, hist_num_bins)); | |
256 | ||
2d35e9f6 NC |
257 | /* Make sure that we have sensible values. */ |
258 | if (samp_bytes < 0 || lowpc > highpc) | |
259 | { | |
260 | fprintf (stderr, | |
261 | _("%s: file '%s' does not appear to be in gmon.out format\n"), | |
262 | whoami, filename); | |
263 | done (1); | |
264 | } | |
265 | ||
252b5132 RH |
266 | if (hist_num_bins) |
267 | { | |
268 | ++nhist; | |
269 | } | |
270 | ||
271 | if (!hist_sample) | |
272 | { | |
273 | hist_sample = | |
274 | (int *) xmalloc (hist_num_bins * sizeof (hist_sample[0])); | |
275 | memset (hist_sample, 0, hist_num_bins * sizeof (hist_sample[0])); | |
276 | } | |
277 | ||
278 | for (i = 0; i < hist_num_bins; ++i) | |
279 | { | |
280 | if (fread (raw_bin_count, sizeof (raw_bin_count), 1, ifp) != 1) | |
281 | { | |
282 | fprintf (stderr, | |
283 | _("%s: unexpected EOF after reading %d/%d bins\n"), | |
284 | whoami, --i, hist_num_bins); | |
285 | done (1); | |
286 | } | |
287 | hist_sample[i] += bfd_get_16 (core_bfd, (bfd_byte *) raw_bin_count); | |
288 | } | |
289 | ||
290 | /* | |
291 | * The rest of the file consists of a bunch of <from,self,count> | |
292 | * tuples: | |
293 | */ | |
294 | while (fread (&raw_arc, sizeof (raw_arc), 1, ifp) == 1) | |
295 | { | |
296 | ++narcs; | |
297 | from_pc = get_vma (core_bfd, (bfd_byte *) raw_arc.from_pc); | |
298 | self_pc = get_vma (core_bfd, (bfd_byte *) raw_arc.self_pc); | |
299 | count = bfd_get_32 (core_bfd, (bfd_byte *) raw_arc.count); | |
300 | DBG (SAMPLEDEBUG, | |
301 | printf ("[gmon_out_read] frompc 0x%lx selfpc 0x%lx count %lu\n", | |
fdcf7d43 | 302 | (unsigned long) from_pc, (unsigned long) self_pc, count)); |
252b5132 RH |
303 | /* add this arc: */ |
304 | cg_tally (from_pc, self_pc, count); | |
305 | } | |
306 | fclose (ifp); | |
307 | ||
308 | if (hz == HZ_WRONG) | |
309 | { | |
310 | /* | |
311 | * How many ticks per second? If we can't tell, report | |
312 | * time in ticks. | |
313 | */ | |
314 | hz = hertz (); | |
315 | if (hz == HZ_WRONG) | |
316 | { | |
317 | hz = 1; | |
318 | fprintf (stderr, _("time is in ticks, not seconds\n")); | |
319 | } | |
320 | } | |
321 | } | |
322 | else | |
323 | { | |
324 | fprintf (stderr, _("%s: don't know how to deal with file format %d\n"), | |
325 | whoami, file_format); | |
326 | done (1); | |
327 | } | |
328 | ||
329 | if (output_style & STYLE_GMON_INFO) | |
330 | { | |
331 | printf (_("File `%s' (version %d) contains:\n"), | |
332 | filename, gmon_file_version); | |
333 | printf (_("\t%d histogram record%s\n"), | |
334 | nhist, nhist == 1 ? "" : "s"); | |
335 | printf (_("\t%d call-graph record%s\n"), | |
336 | narcs, narcs == 1 ? "" : "s"); | |
337 | printf (_("\t%d basic-block count record%s\n"), | |
338 | nbbs, nbbs == 1 ? "" : "s"); | |
339 | first_output = FALSE; | |
340 | } | |
341 | } | |
342 | ||
343 | ||
344 | void | |
345 | DEFUN (gmon_out_write, (filename), const char *filename) | |
346 | { | |
347 | FILE *ofp; | |
348 | struct gmon_hdr ghdr; | |
349 | ||
350 | ofp = fopen (filename, FOPEN_WB); | |
351 | if (!ofp) | |
352 | { | |
353 | perror (filename); | |
354 | done (1); | |
355 | } | |
356 | ||
357 | if (file_format == FF_AUTO || file_format == FF_MAGIC) | |
358 | { | |
359 | /* write gmon header: */ | |
360 | ||
361 | memcpy (&ghdr.cookie[0], GMON_MAGIC, 4); | |
362 | bfd_put_32 (core_bfd, GMON_VERSION, (bfd_byte *) ghdr.version); | |
363 | if (fwrite (&ghdr, sizeof (ghdr), 1, ofp) != 1) | |
364 | { | |
365 | perror (filename); | |
366 | done (1); | |
367 | } | |
368 | ||
369 | /* write execution time histogram if we have one: */ | |
370 | if (gmon_input & INPUT_HISTOGRAM) | |
371 | { | |
372 | hist_write_hist (ofp, filename); | |
373 | } | |
374 | ||
375 | /* write call graph arcs if we have any: */ | |
376 | if (gmon_input & INPUT_CALL_GRAPH) | |
377 | { | |
378 | cg_write_arcs (ofp, filename); | |
379 | } | |
380 | ||
381 | /* write basic-block info if we have it: */ | |
382 | if (gmon_input & INPUT_BB_COUNTS) | |
383 | { | |
384 | bb_write_blocks (ofp, filename); | |
385 | } | |
386 | } | |
387 | else if (file_format == FF_BSD || file_format == FF_BSD44) | |
388 | { | |
389 | struct raw_arc raw_arc; | |
390 | UNIT raw_bin_count; | |
391 | struct raw_phdr h; | |
392 | int i; | |
393 | Arc *arc; | |
394 | Sym *sym; | |
395 | ||
396 | memset (&h, 0, sizeof h); | |
397 | put_vma (core_bfd, s_lowpc, (bfd_byte *) &h.low_pc); | |
398 | put_vma (core_bfd, s_highpc, (bfd_byte *) &h.high_pc); | |
399 | bfd_put_32 (core_bfd, | |
400 | hist_num_bins * sizeof (UNIT) + sizeof (struct raw_phdr), | |
401 | (bfd_byte *) &h.ncnt); | |
402 | ||
403 | /* Write header. Use new style BSD format is explicitly | |
404 | specified, or if the profiling rate is non-standard; | |
405 | otherwise, use the old BSD format. */ | |
406 | if (file_format == FF_BSD44 | |
407 | || hz != hertz ()) | |
408 | { | |
409 | bfd_put_32 (core_bfd, GMONVERSION, (bfd_byte *) &h.version); | |
410 | bfd_put_32 (core_bfd, hz, (bfd_byte *) &h.profrate); | |
411 | if (fwrite (&h, sizeof (struct raw_phdr), 1, ofp) != 1) | |
412 | { | |
413 | perror (filename); | |
414 | done (1); | |
415 | } | |
416 | } | |
417 | else | |
418 | { | |
419 | if (fwrite (&h, sizeof (struct old_raw_phdr), 1, ofp) != 1) | |
420 | { | |
421 | perror (filename); | |
422 | done (1); | |
423 | } | |
424 | } | |
425 | ||
426 | /* dump the samples: */ | |
427 | ||
428 | for (i = 0; i < hist_num_bins; ++i) | |
429 | { | |
430 | bfd_put_16 (core_bfd, hist_sample[i], (bfd_byte *) & raw_bin_count[0]); | |
431 | if (fwrite (&raw_bin_count[0], sizeof (raw_bin_count), 1, ofp) != 1) | |
432 | { | |
433 | perror (filename); | |
434 | done (1); | |
435 | } | |
436 | } | |
437 | ||
438 | /* dump the normalized raw arc information: */ | |
439 | ||
440 | for (sym = symtab.base; sym < symtab.limit; ++sym) | |
441 | { | |
442 | for (arc = sym->cg.children; arc; arc = arc->next_child) | |
443 | { | |
444 | put_vma (core_bfd, arc->parent->addr, | |
445 | (bfd_byte *) raw_arc.from_pc); | |
446 | put_vma (core_bfd, arc->child->addr, | |
447 | (bfd_byte *) raw_arc.self_pc); | |
448 | bfd_put_32 (core_bfd, arc->count, (bfd_byte *) raw_arc.count); | |
449 | if (fwrite (&raw_arc, sizeof (raw_arc), 1, ofp) != 1) | |
450 | { | |
451 | perror (filename); | |
452 | done (1); | |
453 | } | |
454 | DBG (SAMPLEDEBUG, | |
455 | printf ("[dumpsum] frompc 0x%lx selfpc 0x%lx count %lu\n", | |
fdcf7d43 ILT |
456 | (unsigned long) arc->parent->addr, |
457 | (unsigned long) arc->child->addr, arc->count)); | |
252b5132 RH |
458 | } |
459 | } | |
460 | fclose (ofp); | |
461 | } | |
462 | else | |
463 | { | |
464 | fprintf (stderr, _("%s: don't know how to deal with file format %d\n"), | |
465 | whoami, file_format); | |
466 | done (1); | |
467 | } | |
468 | } |