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; 75 #ifdef SET_BINARY 76 SET_BINARY (fileno (stdin)); 77 #endif 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", 248 (unsigned long) h.low_pc, (unsigned long) h.high_pc, 249 h.ncnt); 250 printf ("[gmon_out_read] s_lowpc 0x%lx s_highpc 0x%lx\n", 251 (unsigned long) s_lowpc, (unsigned long) s_highpc); 252 printf ("[gmon_out_read] lowpc 0x%lx highpc 0x%lx\n", 253 (unsigned long) lowpc, (unsigned long) highpc); 254 printf ("[gmon_out_read] samp_bytes %d hist_num_bins %d\n", 255 samp_bytes, hist_num_bins)); 256 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 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", 302 (unsigned long) from_pc, (unsigned long) self_pc, count)); 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", 456 (unsigned long) arc->parent->addr, 457 (unsigned long) arc->child->addr, arc->count)); 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 } 469