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