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