1 /* 2 * Copyright (c) 1983, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by the University of 16 * California, Berkeley and its contributors. 17 * 4. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 #ifndef lint 35 static const char copyright[] = 36 "@(#) Copyright (c) 1983, 1993\n\ 37 The Regents of the University of California. All rights reserved.\n"; 38 #endif /* not lint */ 39 40 #ifndef lint 41 #if 0 42 static char sccsid[] = "@(#)gprof.c 8.1 (Berkeley) 6/6/93"; 43 #endif 44 static const char rcsid[] = 45 "$FreeBSD$"; 46 #endif /* not lint */ 47 48 #include <err.h> 49 #include "gprof.h" 50 51 static int valcmp(const void *, const void *); 52 53 54 static struct gmonhdr gmonhdr; 55 static int lflag; 56 static int Lflag; 57 58 main(argc, argv) 59 int argc; 60 char **argv; 61 { 62 char **sp; 63 nltype **timesortnlp; 64 char **defaultEs; 65 66 --argc; 67 argv++; 68 debug = 0; 69 bflag = TRUE; 70 while ( *argv != 0 && **argv == '-' ) { 71 (*argv)++; 72 switch ( **argv ) { 73 case 'a': 74 aflag = TRUE; 75 break; 76 case 'b': 77 bflag = FALSE; 78 break; 79 case 'C': 80 Cflag = TRUE; 81 cyclethreshold = atoi( *++argv ); 82 break; 83 case 'c': 84 #if defined(vax) || defined(tahoe) 85 cflag = TRUE; 86 #else 87 errx(1, "-c isn't supported on this architecture yet"); 88 #endif 89 break; 90 case 'd': 91 dflag = TRUE; 92 setlinebuf(stdout); 93 debug |= atoi( *++argv ); 94 debug |= ANYDEBUG; 95 # ifdef DEBUG 96 printf("[main] debug = %d\n", debug); 97 # else not DEBUG 98 printf("gprof: -d ignored\n"); 99 # endif DEBUG 100 break; 101 case 'E': 102 ++argv; 103 addlist( Elist , *argv ); 104 Eflag = TRUE; 105 addlist( elist , *argv ); 106 eflag = TRUE; 107 break; 108 case 'e': 109 addlist( elist , *++argv ); 110 eflag = TRUE; 111 break; 112 case 'F': 113 ++argv; 114 addlist( Flist , *argv ); 115 Fflag = TRUE; 116 addlist( flist , *argv ); 117 fflag = TRUE; 118 break; 119 case 'f': 120 addlist( flist , *++argv ); 121 fflag = TRUE; 122 break; 123 case 'k': 124 addlist( kfromlist , *++argv ); 125 addlist( ktolist , *++argv ); 126 kflag = TRUE; 127 break; 128 case 'l': 129 lflag = 1; 130 Lflag = 0; 131 break; 132 case 'L': 133 Lflag = 1; 134 lflag = 0; 135 break; 136 case 's': 137 sflag = TRUE; 138 break; 139 case 'u': 140 uflag = TRUE; 141 break; 142 case 'z': 143 zflag = TRUE; 144 break; 145 } 146 argv++; 147 } 148 if ( *argv != 0 ) { 149 a_outname = *argv; 150 argv++; 151 } else { 152 a_outname = A_OUTNAME; 153 } 154 if ( *argv != 0 ) { 155 gmonname = *argv; 156 argv++; 157 } else { 158 gmonname = (char *) malloc(strlen(a_outname)+6); 159 strcpy(gmonname, a_outname); 160 strcat(gmonname, ".gmon"); 161 } 162 /* 163 * get information from the executable file. 164 */ 165 if (elf_getnfile(a_outname, &defaultEs) == -1 && 166 aout_getnfile(a_outname, &defaultEs) == -1) 167 errx(1, "%s: bad format", a_outname); 168 /* 169 * sort symbol table. 170 */ 171 qsort(nl, nname, sizeof(nltype), valcmp); 172 /* 173 * turn off default functions 174 */ 175 for ( sp = defaultEs ; *sp ; sp++ ) { 176 Eflag = TRUE; 177 addlist( Elist , *sp ); 178 eflag = TRUE; 179 addlist( elist , *sp ); 180 } 181 /* 182 * get information about mon.out file(s). 183 */ 184 do { 185 getpfile( gmonname ); 186 if ( *argv != 0 ) { 187 gmonname = *argv; 188 } 189 } while ( *argv++ != 0 ); 190 /* 191 * how many ticks per second? 192 * if we can't tell, report time in ticks. 193 */ 194 if (hz == 0) { 195 hz = 1; 196 fprintf(stderr, "time is in ticks, not seconds\n"); 197 } 198 /* 199 * dump out a gmon.sum file if requested 200 */ 201 if ( sflag ) { 202 dumpsum( GMONSUM ); 203 } 204 /* 205 * assign samples to procedures 206 */ 207 asgnsamples(); 208 /* 209 * assemble the dynamic profile 210 */ 211 timesortnlp = doarcs(); 212 /* 213 * print the dynamic profile 214 */ 215 if(!lflag) { 216 printgprof( timesortnlp ); 217 } 218 /* 219 * print the flat profile 220 */ 221 if(!Lflag) { 222 printprof(); 223 } 224 /* 225 * print the index 226 */ 227 printindex(); 228 done(); 229 } 230 231 /* 232 * information from a gmon.out file is in two parts: 233 * an array of sampling hits within pc ranges, 234 * and the arcs. 235 */ 236 getpfile(filename) 237 char *filename; 238 { 239 FILE *pfile; 240 FILE *openpfile(); 241 struct rawarc arc; 242 243 pfile = openpfile(filename); 244 readsamples(pfile); 245 /* 246 * the rest of the file consists of 247 * a bunch of <from,self,count> tuples. 248 */ 249 while ( fread( &arc , sizeof arc , 1 , pfile ) == 1 ) { 250 # ifdef DEBUG 251 if ( debug & SAMPLEDEBUG ) { 252 printf( "[getpfile] frompc 0x%x selfpc 0x%x count %d\n" , 253 arc.raw_frompc , arc.raw_selfpc , arc.raw_count ); 254 } 255 # endif DEBUG 256 /* 257 * add this arc 258 */ 259 tally( &arc ); 260 } 261 fclose(pfile); 262 } 263 264 FILE * 265 openpfile(filename) 266 char *filename; 267 { 268 struct gmonhdr tmp; 269 FILE *pfile; 270 int size; 271 int rate; 272 273 if((pfile = fopen(filename, "r")) == NULL) { 274 perror(filename); 275 done(); 276 } 277 fread(&tmp, sizeof(struct gmonhdr), 1, pfile); 278 if ( s_highpc != 0 && ( tmp.lpc != gmonhdr.lpc || 279 tmp.hpc != gmonhdr.hpc || tmp.ncnt != gmonhdr.ncnt ) ) { 280 warnx("%s: incompatible with first gmon file", filename); 281 done(); 282 } 283 gmonhdr = tmp; 284 if ( gmonhdr.version == GMONVERSION ) { 285 rate = gmonhdr.profrate; 286 size = sizeof(struct gmonhdr); 287 } else { 288 fseek(pfile, sizeof(struct ophdr), SEEK_SET); 289 size = sizeof(struct ophdr); 290 gmonhdr.profrate = rate = hertz(); 291 gmonhdr.version = GMONVERSION; 292 } 293 if (hz == 0) { 294 hz = rate; 295 } else if (hz != rate) { 296 fprintf(stderr, 297 "%s: profile clock rate (%d) %s (%d) in first gmon file\n", 298 filename, rate, "incompatible with clock rate", hz); 299 done(); 300 } 301 s_lowpc = (unsigned long) gmonhdr.lpc; 302 s_highpc = (unsigned long) gmonhdr.hpc; 303 lowpc = (unsigned long)gmonhdr.lpc / sizeof(UNIT); 304 highpc = (unsigned long)gmonhdr.hpc / sizeof(UNIT); 305 sampbytes = gmonhdr.ncnt - size; 306 nsamples = sampbytes / sizeof (UNIT); 307 # ifdef DEBUG 308 if ( debug & SAMPLEDEBUG ) { 309 printf( "[openpfile] hdr.lpc 0x%x hdr.hpc 0x%x hdr.ncnt %d\n", 310 gmonhdr.lpc , gmonhdr.hpc , gmonhdr.ncnt ); 311 printf( "[openpfile] s_lowpc 0x%x s_highpc 0x%x\n" , 312 s_lowpc , s_highpc ); 313 printf( "[openpfile] lowpc 0x%x highpc 0x%x\n" , 314 lowpc , highpc ); 315 printf( "[openpfile] sampbytes %d nsamples %d\n" , 316 sampbytes , nsamples ); 317 printf( "[openpfile] sample rate %d\n" , hz ); 318 } 319 # endif DEBUG 320 return(pfile); 321 } 322 323 tally( rawp ) 324 struct rawarc *rawp; 325 { 326 nltype *parentp; 327 nltype *childp; 328 329 parentp = nllookup( rawp -> raw_frompc ); 330 childp = nllookup( rawp -> raw_selfpc ); 331 if ( parentp == 0 || childp == 0 ) 332 return; 333 if ( kflag 334 && onlist( kfromlist , parentp -> name ) 335 && onlist( ktolist , childp -> name ) ) { 336 return; 337 } 338 childp -> ncall += rawp -> raw_count; 339 # ifdef DEBUG 340 if ( debug & TALLYDEBUG ) { 341 printf( "[tally] arc from %s to %s traversed %d times\n" , 342 parentp -> name , childp -> name , rawp -> raw_count ); 343 } 344 # endif DEBUG 345 addarc( parentp , childp , rawp -> raw_count ); 346 } 347 348 /* 349 * dump out the gmon.sum file 350 */ 351 dumpsum( sumfile ) 352 char *sumfile; 353 { 354 register nltype *nlp; 355 register arctype *arcp; 356 struct rawarc arc; 357 FILE *sfile; 358 359 if ( ( sfile = fopen ( sumfile , "w" ) ) == NULL ) { 360 perror( sumfile ); 361 done(); 362 } 363 /* 364 * dump the header; use the last header read in 365 */ 366 if ( fwrite( &gmonhdr , sizeof gmonhdr , 1 , sfile ) != 1 ) { 367 perror( sumfile ); 368 done(); 369 } 370 /* 371 * dump the samples 372 */ 373 if (fwrite(samples, sizeof (UNIT), nsamples, sfile) != nsamples) { 374 perror( sumfile ); 375 done(); 376 } 377 /* 378 * dump the normalized raw arc information 379 */ 380 for ( nlp = nl ; nlp < npe ; nlp++ ) { 381 for ( arcp = nlp -> children ; arcp ; arcp = arcp -> arc_childlist ) { 382 arc.raw_frompc = arcp -> arc_parentp -> value; 383 arc.raw_selfpc = arcp -> arc_childp -> value; 384 arc.raw_count = arcp -> arc_count; 385 if ( fwrite ( &arc , sizeof arc , 1 , sfile ) != 1 ) { 386 perror( sumfile ); 387 done(); 388 } 389 # ifdef DEBUG 390 if ( debug & SAMPLEDEBUG ) { 391 printf( "[dumpsum] frompc 0x%x selfpc 0x%x count %d\n" , 392 arc.raw_frompc , arc.raw_selfpc , arc.raw_count ); 393 } 394 # endif DEBUG 395 } 396 } 397 fclose( sfile ); 398 } 399 400 static int 401 valcmp(v1, v2) 402 const void *v1; 403 const void *v2; 404 { 405 const nltype *p1 = (const nltype *)v1; 406 const nltype *p2 = (const nltype *)v2; 407 408 if ( p1 -> value < p2 -> value ) { 409 return LESSTHAN; 410 } 411 if ( p1 -> value > p2 -> value ) { 412 return GREATERTHAN; 413 } 414 return EQUALTO; 415 } 416 417 readsamples(pfile) 418 FILE *pfile; 419 { 420 register i; 421 UNIT sample; 422 423 if (samples == 0) { 424 samples = (UNIT *) calloc(sampbytes, sizeof (UNIT)); 425 if (samples == 0) { 426 warnx("no room for %d sample pc's", sampbytes / sizeof (UNIT)); 427 done(); 428 } 429 } 430 for (i = 0; i < nsamples; i++) { 431 fread(&sample, sizeof (UNIT), 1, pfile); 432 if (feof(pfile)) 433 break; 434 samples[i] += sample; 435 } 436 if (i != nsamples) { 437 warnx("unexpected EOF after reading %d/%d samples", --i , nsamples ); 438 done(); 439 } 440 } 441 442 /* 443 * Assign samples to the procedures to which they belong. 444 * 445 * There are three cases as to where pcl and pch can be 446 * with respect to the routine entry addresses svalue0 and svalue1 447 * as shown in the following diagram. overlap computes the 448 * distance between the arrows, the fraction of the sample 449 * that is to be credited to the routine which starts at svalue0. 450 * 451 * svalue0 svalue1 452 * | | 453 * v v 454 * 455 * +-----------------------------------------------+ 456 * | | 457 * | ->| |<- ->| |<- ->| |<- | 458 * | | | | | | 459 * +---------+ +---------+ +---------+ 460 * 461 * ^ ^ ^ ^ ^ ^ 462 * | | | | | | 463 * pcl pch pcl pch pcl pch 464 * 465 * For the vax we assert that samples will never fall in the first 466 * two bytes of any routine, since that is the entry mask, 467 * thus we give call alignentries() to adjust the entry points if 468 * the entry mask falls in one bucket but the code for the routine 469 * doesn't start until the next bucket. In conjunction with the 470 * alignment of routine addresses, this should allow us to have 471 * only one sample for every four bytes of text space and never 472 * have any overlap (the two end cases, above). 473 */ 474 asgnsamples() 475 { 476 register int j; 477 UNIT ccnt; 478 double time; 479 unsigned long pcl, pch; 480 register int i; 481 unsigned long overlap; 482 unsigned long svalue0, svalue1; 483 484 /* read samples and assign to namelist symbols */ 485 scale = highpc - lowpc; 486 scale /= nsamples; 487 alignentries(); 488 for (i = 0, j = 1; i < nsamples; i++) { 489 ccnt = samples[i]; 490 if (ccnt == 0) 491 continue; 492 pcl = lowpc + (unsigned long)(scale * i); 493 pch = lowpc + (unsigned long)(scale * (i + 1)); 494 time = ccnt; 495 # ifdef DEBUG 496 if ( debug & SAMPLEDEBUG ) { 497 printf( "[asgnsamples] pcl 0x%x pch 0x%x ccnt %d\n" , 498 pcl , pch , ccnt ); 499 } 500 # endif DEBUG 501 totime += time; 502 for (j = j - 1; j < nname; j++) { 503 svalue0 = nl[j].svalue; 504 svalue1 = nl[j+1].svalue; 505 /* 506 * if high end of tick is below entry address, 507 * go for next tick. 508 */ 509 if (pch < svalue0) 510 break; 511 /* 512 * if low end of tick into next routine, 513 * go for next routine. 514 */ 515 if (pcl >= svalue1) 516 continue; 517 overlap = min(pch, svalue1) - max(pcl, svalue0); 518 if (overlap > 0) { 519 # ifdef DEBUG 520 if (debug & SAMPLEDEBUG) { 521 printf("[asgnsamples] (0x%x->0x%x-0x%x) %s gets %f ticks %d overlap\n", 522 nl[j].value/sizeof(UNIT), svalue0, svalue1, 523 nl[j].name, 524 overlap * time / scale, overlap); 525 } 526 # endif DEBUG 527 nl[j].time += overlap * time / scale; 528 } 529 } 530 } 531 # ifdef DEBUG 532 if (debug & SAMPLEDEBUG) { 533 printf("[asgnsamples] totime %f\n", totime); 534 } 535 # endif DEBUG 536 } 537 538 539 unsigned long 540 min(a, b) 541 unsigned long a,b; 542 { 543 if (a<b) 544 return(a); 545 return(b); 546 } 547 548 unsigned long 549 max(a, b) 550 unsigned long a,b; 551 { 552 if (a>b) 553 return(a); 554 return(b); 555 } 556 557 /* 558 * calculate scaled entry point addresses (to save time in asgnsamples), 559 * and possibly push the scaled entry points over the entry mask, 560 * if it turns out that the entry point is in one bucket and the code 561 * for a routine is in the next bucket. 562 */ 563 alignentries() 564 { 565 register struct nl *nlp; 566 unsigned long bucket_of_entry; 567 unsigned long bucket_of_code; 568 569 for (nlp = nl; nlp < npe; nlp++) { 570 nlp -> svalue = nlp -> value / sizeof(UNIT); 571 bucket_of_entry = (nlp->svalue - lowpc) / scale; 572 bucket_of_code = (nlp->svalue + UNITS_TO_CODE - lowpc) / scale; 573 if (bucket_of_entry < bucket_of_code) { 574 # ifdef DEBUG 575 if (debug & SAMPLEDEBUG) { 576 printf("[alignentries] pushing svalue 0x%x to 0x%x\n", 577 nlp->svalue, nlp->svalue + UNITS_TO_CODE); 578 } 579 # endif DEBUG 580 nlp->svalue += UNITS_TO_CODE; 581 } 582 } 583 } 584 585 done() 586 { 587 588 exit(0); 589 } 590