![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gprof.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ucb / gprof|
Return to gprof.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ucb / gprof |
1.1 ! root 1: #ifndef lint ! 2: static char *sccsid = "@(#)gprof.c 1.22 (Berkeley) 5/11/83"; ! 3: #endif lint ! 4: ! 5: #include "gprof.h" ! 6: ! 7: char *whoami = "gprof"; ! 8: ! 9: /* ! 10: * things which get -E excluded by default. ! 11: */ ! 12: char *defaultEs[] = { "mcount" , "__mcleanup" , 0 }; ! 13: ! 14: main(argc, argv) ! 15: int argc; ! 16: char **argv; ! 17: { ! 18: char **sp; ! 19: ! 20: --argc; ! 21: argv++; ! 22: debug = 0; ! 23: bflag = TRUE; ! 24: while ( *argv != 0 && **argv == '-' ) { ! 25: (*argv)++; ! 26: switch ( **argv ) { ! 27: case 'a': ! 28: aflag = TRUE; ! 29: break; ! 30: case 'b': ! 31: bflag = FALSE; ! 32: break; ! 33: case 'c': ! 34: cflag = TRUE; ! 35: break; ! 36: case 'd': ! 37: dflag = TRUE; ! 38: (*argv)++; ! 39: debug |= atoi( *argv ); ! 40: debug |= ANYDEBUG; ! 41: # ifdef DEBUG ! 42: printf("[main] debug = %d\n", debug); ! 43: # else not DEBUG ! 44: printf("%s: -d ignored\n", whoami); ! 45: # endif DEBUG ! 46: break; ! 47: case 'E': ! 48: ++argv; ! 49: addlist( Elist , *argv ); ! 50: Eflag = TRUE; ! 51: addlist( elist , *argv ); ! 52: eflag = TRUE; ! 53: break; ! 54: case 'e': ! 55: addlist( elist , *++argv ); ! 56: eflag = TRUE; ! 57: break; ! 58: case 'F': ! 59: ++argv; ! 60: addlist( Flist , *argv ); ! 61: Fflag = TRUE; ! 62: addlist( flist , *argv ); ! 63: fflag = TRUE; ! 64: break; ! 65: case 'f': ! 66: addlist( flist , *++argv ); ! 67: fflag = TRUE; ! 68: break; ! 69: case 's': ! 70: sflag = TRUE; ! 71: break; ! 72: case 'z': ! 73: zflag = TRUE; ! 74: break; ! 75: } ! 76: argv++; ! 77: } ! 78: if ( *argv != 0 ) { ! 79: a_outname = *argv; ! 80: argv++; ! 81: } else { ! 82: a_outname = A_OUTNAME; ! 83: } ! 84: if ( *argv != 0 ) { ! 85: gmonname = *argv; ! 86: argv++; ! 87: } else { ! 88: gmonname = GMONNAME; ! 89: } ! 90: /* ! 91: * turn off default functions ! 92: */ ! 93: for ( sp = &defaultEs[0] ; *sp ; sp++ ) { ! 94: Eflag = TRUE; ! 95: addlist( Elist , *sp ); ! 96: eflag = TRUE; ! 97: addlist( elist , *sp ); ! 98: } ! 99: /* ! 100: * how long is a clock tick? ! 101: */ ! 102: hz = hertz(); ! 103: /* ! 104: * get information about a.out file. ! 105: */ ! 106: getnfile(); ! 107: /* ! 108: * get information about mon.out file(s). ! 109: */ ! 110: do { ! 111: getpfile( gmonname ); ! 112: if ( *argv != 0 ) { ! 113: gmonname = *argv; ! 114: } ! 115: } while ( *argv++ != 0 ); ! 116: /* ! 117: * dump out a gmon.sum file if requested ! 118: */ ! 119: if ( sflag ) { ! 120: dumpsum( GMONSUM ); ! 121: } ! 122: /* ! 123: * assign samples to procedures ! 124: */ ! 125: asgnsamples(); ! 126: /* ! 127: * print the usual profile ! 128: */ ! 129: printprof(); ! 130: /* ! 131: * assemble and print the dynamic profile ! 132: */ ! 133: doarcs(); ! 134: done(); ! 135: } ! 136: ! 137: /* ! 138: * Set up string and symbol tables from a.out. ! 139: * and optionally the text space. ! 140: * On return symbol table is sorted by value. ! 141: */ ! 142: getnfile() ! 143: { ! 144: FILE *nfile; ! 145: ! 146: nfile = fopen( a_outname ,"r"); ! 147: if (nfile == NULL) { ! 148: perror( a_outname ); ! 149: done(); ! 150: } ! 151: fread(&xbuf, 1, sizeof(xbuf), nfile); ! 152: if (N_BADMAG(xbuf)) { ! 153: fprintf(stderr, "%s: %s: bad format\n", whoami , a_outname ); ! 154: done(); ! 155: } ! 156: getstrtab(nfile); ! 157: getsymtab(nfile); ! 158: gettextspace( nfile ); ! 159: qsort(nl, nname, sizeof(nltype), valcmp); ! 160: fclose(nfile); ! 161: # ifdef DEBUG ! 162: if ( debug & AOUTDEBUG ) { ! 163: register int j; ! 164: ! 165: for (j = 0; j < nname; j++){ ! 166: printf("[getnfile] 0X%08x\t%s\n", nl[j].value, nl[j].name); ! 167: } ! 168: } ! 169: # endif DEBUG ! 170: } ! 171: ! 172: getstrtab(nfile) ! 173: FILE *nfile; ! 174: { ! 175: ! 176: fseek(nfile, (long)(N_SYMOFF(xbuf) + xbuf.a_syms), 0); ! 177: if (fread(&ssiz, sizeof (ssiz), 1, nfile) == 0) { ! 178: fprintf(stderr, "%s: %s: no string table (old format?)\n" , ! 179: whoami , a_outname ); ! 180: done(); ! 181: } ! 182: strtab = (char *)calloc(ssiz, 1); ! 183: if (strtab == NULL) { ! 184: fprintf(stderr, "%s: %s: no room for %d bytes of string table", ! 185: whoami , a_outname , ssiz); ! 186: done(); ! 187: } ! 188: if (fread(strtab+sizeof(ssiz), ssiz-sizeof(ssiz), 1, nfile) != 1) { ! 189: fprintf(stderr, "%s: %s: error reading string table\n", ! 190: whoami , a_outname ); ! 191: done(); ! 192: } ! 193: } ! 194: ! 195: /* ! 196: * Read in symbol table ! 197: */ ! 198: getsymtab(nfile) ! 199: FILE *nfile; ! 200: { ! 201: register long i; ! 202: int askfor; ! 203: struct nlist nbuf; ! 204: ! 205: /* pass1 - count symbols */ ! 206: fseek(nfile, (long)N_SYMOFF(xbuf), 0); ! 207: nname = 0; ! 208: for (i = xbuf.a_syms; i > 0; i -= sizeof(struct nlist)) { ! 209: fread(&nbuf, sizeof(nbuf), 1, nfile); ! 210: if ( ! funcsymbol( &nbuf ) ) { ! 211: continue; ! 212: } ! 213: nname++; ! 214: } ! 215: if (nname == 0) { ! 216: fprintf(stderr, "%s: %s: no symbols\n", whoami , a_outname ); ! 217: done(); ! 218: } ! 219: askfor = nname + 1; ! 220: nl = (nltype *) calloc( askfor , sizeof(nltype) ); ! 221: if (nl == 0) { ! 222: fprintf(stderr, "%s: No room for %d bytes of symbol table\n", ! 223: whoami, askfor * sizeof(nltype) ); ! 224: done(); ! 225: } ! 226: ! 227: /* pass2 - read symbols */ ! 228: fseek(nfile, (long)N_SYMOFF(xbuf), 0); ! 229: npe = nl; ! 230: nname = 0; ! 231: for (i = xbuf.a_syms; i > 0; i -= sizeof(struct nlist)) { ! 232: fread(&nbuf, sizeof(nbuf), 1, nfile); ! 233: if ( ! funcsymbol( &nbuf ) ) { ! 234: # ifdef DEBUG ! 235: if ( debug & AOUTDEBUG ) { ! 236: printf( "[getsymtab] rejecting: 0x%x %s\n" , ! 237: nbuf.n_type , strtab + nbuf.n_un.n_strx ); ! 238: } ! 239: # endif DEBUG ! 240: continue; ! 241: } ! 242: npe->value = nbuf.n_value; ! 243: npe->name = strtab+nbuf.n_un.n_strx; ! 244: # ifdef DEBUG ! 245: if ( debug & AOUTDEBUG ) { ! 246: printf( "[getsymtab] %d %s 0x%08x\n" , ! 247: nname , npe -> name , npe -> value ); ! 248: } ! 249: # endif DEBUG ! 250: npe++; ! 251: nname++; ! 252: } ! 253: npe->value = -1; ! 254: } ! 255: ! 256: /* ! 257: * read in the text space of an a.out file ! 258: */ ! 259: gettextspace( nfile ) ! 260: FILE *nfile; ! 261: { ! 262: unsigned char *malloc(); ! 263: ! 264: if ( cflag == 0 ) { ! 265: return; ! 266: } ! 267: textspace = malloc( xbuf.a_text ); ! 268: if ( textspace == 0 ) { ! 269: fprintf( stderr , "%s: ran out room for %d bytes of text space: " , ! 270: whoami , xbuf.a_text ); ! 271: fprintf( stderr , "can't do -c\n" ); ! 272: return; ! 273: } ! 274: (void) fseek( nfile , N_TXTOFF( xbuf ) , 0 ); ! 275: if ( fread( textspace , 1 , xbuf.a_text , nfile ) != xbuf.a_text ) { ! 276: fprintf( stderr , "%s: couldn't read text space: " , whoami ); ! 277: fprintf( stderr , "can't do -c\n" ); ! 278: free( textspace ); ! 279: textspace = 0; ! 280: return; ! 281: } ! 282: } ! 283: /* ! 284: * information from a gmon.out file is in two parts: ! 285: * an array of sampling hits within pc ranges, ! 286: * and the arcs. ! 287: */ ! 288: getpfile(filename) ! 289: char *filename; ! 290: { ! 291: FILE *pfile; ! 292: FILE *openpfile(); ! 293: struct rawarc arc; ! 294: ! 295: pfile = openpfile(filename); ! 296: readsamples(pfile); ! 297: /* ! 298: * the rest of the file consists of ! 299: * a bunch of <from,self,count> tuples. ! 300: */ ! 301: while ( fread( &arc , sizeof arc , 1 , pfile ) == 1 ) { ! 302: # ifdef DEBUG ! 303: if ( debug & SAMPLEDEBUG ) { ! 304: printf( "[getpfile] frompc 0x%x selfpc 0x%x count %d\n" , ! 305: arc.raw_frompc , arc.raw_selfpc , arc.raw_count ); ! 306: } ! 307: # endif DEBUG ! 308: /* ! 309: * add this arc ! 310: */ ! 311: tally( &arc ); ! 312: } ! 313: fclose(pfile); ! 314: } ! 315: ! 316: FILE * ! 317: openpfile(filename) ! 318: char *filename; ! 319: { ! 320: struct hdr tmp; ! 321: FILE *pfile; ! 322: ! 323: if((pfile = fopen(filename, "r")) == NULL) { ! 324: perror(filename); ! 325: done(); ! 326: } ! 327: fread(&tmp, sizeof(struct hdr), 1, pfile); ! 328: if ( s_highpc != 0 && ( tmp.lowpc != h.lowpc || ! 329: tmp.highpc != h.highpc || tmp.ncnt != h.ncnt ) ) { ! 330: fprintf(stderr, "%s: incompatible with first gmon file\n", filename); ! 331: done(); ! 332: } ! 333: h = tmp; ! 334: s_lowpc = (unsigned long) h.lowpc; ! 335: s_highpc = (unsigned long) h.highpc; ! 336: lowpc = (unsigned long)h.lowpc / sizeof(UNIT); ! 337: highpc = (unsigned long)h.highpc / sizeof(UNIT); ! 338: sampbytes = h.ncnt - sizeof(struct hdr); ! 339: nsamples = sampbytes / sizeof (unsigned UNIT); ! 340: # ifdef DEBUG ! 341: if ( debug & SAMPLEDEBUG ) { ! 342: printf( "[openpfile] hdr.lowpc 0x%x hdr.highpc 0x%x hdr.ncnt %d\n", ! 343: h.lowpc , h.highpc , h.ncnt ); ! 344: printf( "[openpfile] s_lowpc 0x%x s_highpc 0x%x\n" , ! 345: s_lowpc , s_highpc ); ! 346: printf( "[openpfile] lowpc 0x%x highpc 0x%x\n" , ! 347: lowpc , highpc ); ! 348: printf( "[openpfile] sampbytes %d nsamples %d\n" , ! 349: sampbytes , nsamples ); ! 350: } ! 351: # endif DEBUG ! 352: return(pfile); ! 353: } ! 354: ! 355: tally( rawp ) ! 356: struct rawarc *rawp; ! 357: { ! 358: nltype *parentp; ! 359: nltype *childp; ! 360: ! 361: parentp = nllookup( rawp -> raw_frompc ); ! 362: childp = nllookup( rawp -> raw_selfpc ); ! 363: childp -> ncall += rawp -> raw_count; ! 364: # ifdef DEBUG ! 365: if ( debug & TALLYDEBUG ) { ! 366: printf( "[tally] arc from %s to %s traversed %d times\n" , ! 367: parentp -> name , childp -> name , rawp -> raw_count ); ! 368: } ! 369: # endif DEBUG ! 370: addarc( parentp , childp , rawp -> raw_count ); ! 371: } ! 372: ! 373: /* ! 374: * dump out the gmon.sum file ! 375: */ ! 376: dumpsum( sumfile ) ! 377: char *sumfile; ! 378: { ! 379: register nltype *nlp; ! 380: register arctype *arcp; ! 381: struct rawarc arc; ! 382: FILE *sfile; ! 383: ! 384: if ( ( sfile = fopen ( sumfile , "w" ) ) == NULL ) { ! 385: perror( sumfile ); ! 386: done(); ! 387: } ! 388: /* ! 389: * dump the header; use the last header read in ! 390: */ ! 391: if ( fwrite( &h , sizeof h , 1 , sfile ) != 1 ) { ! 392: perror( sumfile ); ! 393: done(); ! 394: } ! 395: /* ! 396: * dump the samples ! 397: */ ! 398: if (fwrite(samples, sizeof(unsigned UNIT), nsamples, sfile) != nsamples) { ! 399: perror( sumfile ); ! 400: done(); ! 401: } ! 402: /* ! 403: * dump the normalized raw arc information ! 404: */ ! 405: for ( nlp = nl ; nlp < npe ; nlp++ ) { ! 406: for ( arcp = nlp -> children ; arcp ; arcp = arcp -> arc_childlist ) { ! 407: arc.raw_frompc = arcp -> arc_parentp -> value; ! 408: arc.raw_selfpc = arcp -> arc_childp -> value; ! 409: arc.raw_count = arcp -> arc_count; ! 410: if ( fwrite ( &arc , sizeof arc , 1 , sfile ) != 1 ) { ! 411: perror( sumfile ); ! 412: done(); ! 413: } ! 414: # ifdef DEBUG ! 415: if ( debug & SAMPLEDEBUG ) { ! 416: printf( "[dumpsum] frompc 0x%x selfpc 0x%x count %d\n" , ! 417: arc.raw_frompc , arc.raw_selfpc , arc.raw_count ); ! 418: } ! 419: # endif DEBUG ! 420: } ! 421: } ! 422: fclose( sfile ); ! 423: } ! 424: ! 425: valcmp(p1, p2) ! 426: nltype *p1, *p2; ! 427: { ! 428: if ( p1 -> value < p2 -> value ) { ! 429: return LESSTHAN; ! 430: } ! 431: if ( p1 -> value > p2 -> value ) { ! 432: return GREATERTHAN; ! 433: } ! 434: return EQUALTO; ! 435: } ! 436: ! 437: readsamples(pfile) ! 438: FILE *pfile; ! 439: { ! 440: register i; ! 441: unsigned UNIT sample; ! 442: ! 443: if (samples == 0) { ! 444: samples = (unsigned UNIT *) calloc(sampbytes, sizeof (unsigned UNIT)); ! 445: if (samples == 0) { ! 446: fprintf( stderr , "%s: No room for %d sample pc's\n", ! 447: whoami , sampbytes / sizeof (unsigned UNIT)); ! 448: done(); ! 449: } ! 450: } ! 451: for (i = 0; i < nsamples; i++) { ! 452: fread(&sample, sizeof (unsigned UNIT), 1, pfile); ! 453: if (feof(pfile)) ! 454: break; ! 455: samples[i] += sample; ! 456: } ! 457: if (i != nsamples) { ! 458: fprintf(stderr, ! 459: "%s: unexpected EOF after reading %d/%d samples\n", ! 460: whoami , --i , nsamples ); ! 461: done(); ! 462: } ! 463: } ! 464: ! 465: /* ! 466: * Assign samples to the procedures to which they belong. ! 467: * ! 468: * There are three cases as to where pcl and pch can be ! 469: * with respect to the routine entry addresses svalue0 and svalue1 ! 470: * as shown in the following diagram. overlap computes the ! 471: * distance between the arrows, the fraction of the sample ! 472: * that is to be credited to the routine which starts at svalue0. ! 473: * ! 474: * svalue0 svalue1 ! 475: * | | ! 476: * v v ! 477: * ! 478: * +-----------------------------------------------+ ! 479: * | | ! 480: * | ->| |<- ->| |<- ->| |<- | ! 481: * | | | | | | ! 482: * +---------+ +---------+ +---------+ ! 483: * ! 484: * ^ ^ ^ ^ ^ ^ ! 485: * | | | | | | ! 486: * pcl pch pcl pch pcl pch ! 487: * ! 488: * For the vax we assert that samples will never fall in the first ! 489: * two bytes of any routine, since that is the entry mask, ! 490: * thus we give call alignentries() to adjust the entry points if ! 491: * the entry mask falls in one bucket but the code for the routine ! 492: * doesn't start until the next bucket. In conjunction with the ! 493: * alignment of routine addresses, this should allow us to have ! 494: * only one sample for every four bytes of text space and never ! 495: * have any overlap (the two end cases, above). ! 496: */ ! 497: asgnsamples() ! 498: { ! 499: register int j; ! 500: unsigned UNIT ccnt; ! 501: double time; ! 502: unsigned long pcl, pch; ! 503: register int i; ! 504: unsigned long overlap; ! 505: unsigned long svalue0, svalue1; ! 506: ! 507: /* read samples and assign to namelist symbols */ ! 508: scale = highpc - lowpc; ! 509: scale /= nsamples; ! 510: alignentries(); ! 511: for (i = 0, j = 1; i < nsamples; i++) { ! 512: ccnt = samples[i]; ! 513: if (ccnt == 0) ! 514: continue; ! 515: pcl = lowpc + scale * i; ! 516: pch = lowpc + scale * (i + 1); ! 517: time = ccnt; ! 518: # ifdef DEBUG ! 519: if ( debug & SAMPLEDEBUG ) { ! 520: printf( "[asgnsamples] pcl 0x%x pch 0x%x ccnt %d\n" , ! 521: pcl , pch , ccnt ); ! 522: } ! 523: # endif DEBUG ! 524: totime += time; ! 525: for (j = j - 1; j < nname; j++) { ! 526: svalue0 = nl[j].svalue; ! 527: svalue1 = nl[j+1].svalue; ! 528: /* ! 529: * if high end of tick is below entry address, ! 530: * go for next tick. ! 531: */ ! 532: if (pch < svalue0) ! 533: break; ! 534: /* ! 535: * if low end of tick into next routine, ! 536: * go for next routine. ! 537: */ ! 538: if (pcl >= svalue1) ! 539: continue; ! 540: overlap = min(pch, svalue1) - max(pcl, svalue0); ! 541: if (overlap > 0) { ! 542: # ifdef DEBUG ! 543: if (debug & SAMPLEDEBUG) { ! 544: printf("[asgnsamples] (0x%x->0x%x-0x%x) %s gets %f ticks %d overlap\n", ! 545: nl[j].value/sizeof(UNIT), svalue0, svalue1, ! 546: nl[j].name, ! 547: overlap * time / scale, overlap); ! 548: } ! 549: # endif DEBUG ! 550: nl[j].time += overlap * time / scale; ! 551: } ! 552: } ! 553: } ! 554: # ifdef DEBUG ! 555: if (debug & SAMPLEDEBUG) { ! 556: printf("[asgnsamples] totime %f\n", totime); ! 557: } ! 558: # endif DEBUG ! 559: } ! 560: ! 561: ! 562: unsigned long ! 563: min(a, b) ! 564: unsigned long a,b; ! 565: { ! 566: if (a<b) ! 567: return(a); ! 568: return(b); ! 569: } ! 570: ! 571: unsigned long ! 572: max(a, b) ! 573: unsigned long a,b; ! 574: { ! 575: if (a>b) ! 576: return(a); ! 577: return(b); ! 578: } ! 579: ! 580: /* ! 581: * calculate scaled entry point addresses (to save time in asgnsamples), ! 582: * and possibly push the scaled entry points over the entry mask, ! 583: * if it turns out that the entry point is in one bucket and the code ! 584: * for a routine is in the next bucket. ! 585: */ ! 586: alignentries() ! 587: { ! 588: register struct nl *nlp; ! 589: unsigned long bucket_of_entry; ! 590: unsigned long bucket_of_code; ! 591: ! 592: for (nlp = nl; nlp < npe; nlp++) { ! 593: nlp -> svalue = nlp -> value / sizeof(UNIT); ! 594: bucket_of_entry = (nlp->svalue - lowpc) / scale; ! 595: bucket_of_code = (nlp->svalue + UNITS_TO_CODE - lowpc) / scale; ! 596: if (bucket_of_entry < bucket_of_code) { ! 597: # ifdef DEBUG ! 598: if (debug & SAMPLEDEBUG) { ! 599: printf("[alignentries] pushing svalue 0x%x to 0x%x\n", ! 600: nlp->svalue, nlp->svalue + UNITS_TO_CODE); ! 601: } ! 602: # endif DEBUG ! 603: nlp->svalue += UNITS_TO_CODE; ! 604: } ! 605: } ! 606: } ! 607: ! 608: bool ! 609: funcsymbol( nlistp ) ! 610: struct nlist *nlistp; ! 611: { ! 612: extern char *strtab; /* string table from a.out */ ! 613: extern int aflag; /* if static functions aren't desired */ ! 614: char *name; ! 615: ! 616: /* ! 617: * must be a text symbol, ! 618: * and static text symbols don't qualify if aflag set. ! 619: */ ! 620: if ( ! ( ( nlistp -> n_type == ( N_TEXT | N_EXT ) ) ! 621: || ( ( nlistp -> n_type == N_TEXT ) && ( aflag == 0 ) ) ) ) { ! 622: return FALSE; ! 623: } ! 624: /* ! 625: * can't have any `funny' characters in name, ! 626: * where `funny' includes `.', .o file names ! 627: * and `$', pascal labels. ! 628: */ ! 629: for ( name = strtab + nlistp -> n_un.n_strx ; *name ; name += 1 ) { ! 630: if ( *name == '.' || *name == '$' ) { ! 631: return FALSE; ! 632: } ! 633: } ! 634: return TRUE; ! 635: } ! 636: ! 637: done() ! 638: { ! 639: ! 640: exit(0); ! 641: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.