![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hp.gprof.tar CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / gprof|
Return to hp.gprof.tar CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / gprof |
1.1 root 1: gprof/ 775 22 12 0 4611253540 5106 gprof/Makefile 444 14 12 5404 4341434366 6642 #
2: # Copyright (c) 1987 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 this notice is preserved and that due credit is given
7: # to the University of California at Berkeley. The name of the University
8: # may not be used to endorse or promote products derived from this
9: # software without specific written prior permission. This software
10: # is provided ``as is'' without express or implied warranty.
11: #
12: # @(#)Makefile 5.10 (Berkeley) 1/2/88
13: #
14: CFLAGS= -O
15: LIBC= /lib/libc.a
16: HDRS= gprof.h ${MACHINE}.h
17: SRCS= gprof.c arcs.c dfn.c lookup.c ${MACHINE}.c hertz.c \
18: printgprof.c printlist.c
19: OBJS= gprof.o arcs.o dfn.o lookup.o ${MACHINE}.o hertz.o \
20: printgprof.o printlist.o
21: LIBDIR= ../../lib
22:
23: all: gprof
24:
25: gprof: ${OBJS} ${LIBC}
26: ${CC} -o $@ ${CFLAGS} ${OBJS}
27:
28: gcrt0.h: FRC
29: -if [ -r gcrt0.h ] && \
30: cmp -s gcrt0.h ${LIBDIR}/libc/${MACHINE}/csu/gmon.h; then \
31: :; \
32: else \
33: rm -f gcrt0.h; \
34: cp ${LIBDIR}/libc/${MACHINE}/csu/gmon.h gcrt0.h; \
35: fi
36:
37: clean: FRC
38: rm -f ${OBJS} core gprof
39:
40: depend: FRC
41: mkdep ${CFLAGS} ${SRCS}
42:
43: install: FRC
44: install -s -m 755 gprof ${DESTDIR}/usr/ucb/gprof
45: install -c -m 644 gprof.flat ${DESTDIR}/usr/lib
46: install -c -m 644 gprof.callg ${DESTDIR}/usr/lib
47:
48: lint: FRC
49: lint ${CFLAGS} ${SRCS}
50:
51: tags: FRC
52: ctags ${SRCS}
53:
54: FRC:
55:
56: # DO NOT DELETE THIS LINE -- mkdep uses it.
57: # DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY.
58:
59: gprof.o: gprof.c gprof.h /usr/include/stdio.h /usr/include/sys/types.h
60: gprof.o: /usr/include/sys/stat.h /usr/include/a.out.h /usr/include/sys/exec.h
61: gprof.o: gcrt0.h tahoe.h
62: arcs.o: arcs.c gprof.h /usr/include/stdio.h /usr/include/sys/types.h
63: arcs.o: /usr/include/sys/stat.h /usr/include/a.out.h /usr/include/sys/exec.h
64: arcs.o: gcrt0.h tahoe.h
65: dfn.o: dfn.c /usr/include/stdio.h gprof.h /usr/include/stdio.h
66: dfn.o: /usr/include/sys/types.h /usr/include/sys/stat.h /usr/include/a.out.h
67: dfn.o: /usr/include/sys/exec.h gcrt0.h tahoe.h
68: lookup.o: lookup.c gprof.h /usr/include/stdio.h /usr/include/sys/types.h
69: lookup.o: /usr/include/sys/stat.h /usr/include/a.out.h /usr/include/sys/exec.h
70: lookup.o: gcrt0.h tahoe.h
71: tahoe.o: tahoe.c gprof.h /usr/include/stdio.h /usr/include/sys/types.h
72: tahoe.o: /usr/include/sys/stat.h /usr/include/a.out.h /usr/include/sys/exec.h
73: tahoe.o: gcrt0.h tahoe.h
74: hertz.o: hertz.c /usr/include/sys/time.h /usr/include/time.h
75: printgprof.o: printgprof.c gprof.h /usr/include/stdio.h
76: printgprof.o: /usr/include/sys/types.h /usr/include/sys/stat.h
77: printgprof.o: /usr/include/a.out.h /usr/include/sys/exec.h gcrt0.h tahoe.h
78: printlist.o: printlist.c gprof.h /usr/include/stdio.h /usr/include/sys/types.h
79: printlist.o: /usr/include/sys/stat.h /usr/include/a.out.h
80: printlist.o: /usr/include/sys/exec.h gcrt0.h tahoe.h
81:
82: # IF YOU PUT ANYTHING HERE IT WILL GO AWAY
83: gprof/tags 664 22 12 5307 4167370176 6074 Mgprof gprof.c /^main(argc, argv)$/
84: addarc arcs.c /^addarc( parentp , childp , count )$/
85: addlist printlist.c /^addlist( listp , funcname )$/
86: alignentries gprof.c /^alignentries()$/
87: arccmp printgprof.c /^arccmp( thisp , thatp )$/
88: arclookup lookup.c /^arclookup( parentp , childp )$/
89: asgnsamples gprof.c /^asgnsamples()$/
90: cyclelink arcs.c /^cyclelink()$/
91: cycletime arcs.c /^cycletime()$/
92: dfn dfn.c /^dfn( parentp )$/
93: dfn_busy dfn.c /^dfn_busy( childp )$/
94: dfn_findcycle dfn.c /^dfn_findcycle( childp )$/
95: dfn_numbered dfn.c /^dfn_numbered( childp )$/
96: dfn_post_visit dfn.c /^dfn_post_visit( parentp )$/
97: dfn_pre_visit dfn.c /^dfn_pre_visit( parentp )$/
98: dfn_self_cycle dfn.c /^dfn_self_cycle( parentp )$/
99: doarcs arcs.c /^doarcs()$/
100: doflags arcs.c /^doflags()$/
101: done gprof.c /^done()$/
102: dotime arcs.c /^dotime()$/
103: dumpsum gprof.c /^dumpsum( sumfile )$/
104: findcall tahoe.c /^findcall( parentp , p_lowpc , p_highpc )$/
105: flatprofheader printgprof.c /^flatprofheader()$/
106: flatprofline printgprof.c /^flatprofline( np )$/
107: funcsymbol gprof.c /^funcsymbol( nlistp )$/
108: getnfile gprof.c /^getnfile()$/
109: getpfile gprof.c /^getpfile(filename)$/
110: getstrtab gprof.c /^getstrtab(nfile)$/
111: getsymtab gprof.c /^getsymtab(nfile)$/
112: gettextspace gprof.c /^gettextspace( nfile )$/
113: gprofheader printgprof.c /^gprofheader()$/
114: gprofline printgprof.c /^gprofline( np )$/
115: hertz hertz.c /^hertz()$/
116: inheritflags arcs.c /^inheritflags( childp )$/
117: max gprof.c /^max(a, b)$/
118: membercmp printgprof.c /^membercmp( this , that )$/
119: min gprof.c /^min(a, b)$/
120: namecmp printgprof.c /^namecmp( npp1 , npp2 )$/
121: nllookup lookup.c /^nllookup( address )$/
122: onlist printlist.c /^onlist( listp , funcname )$/
123: openpfile gprof.c /^openpfile(filename)$/
124: operandlength tahoe.c /^operandlength( modep )$/
125: operandmode tahoe.c /^operandmode( modep )$/
126: operandname tahoe.c /^operandname( mode )$/
127: printblurb printgprof.c /^printblurb( blurbname )$/
128: printchildren printgprof.c /^printchildren( parentp )$/
129: printcycle printgprof.c /^printcycle( cyclep )$/
130: printgprof printgprof.c /^printgprof(timesortnlp)$/
131: printindex printgprof.c /^printindex()$/
132: printmembers printgprof.c /^printmembers( cyclep )$/
133: printname printgprof.c /^printname( selfp )$/
134: printparents printgprof.c /^printparents( childp )$/
135: printprof printgprof.c /^printprof()$/
136: readsamples gprof.c /^readsamples(pfile)$/
137: reladdr tahoe.c /^reladdr( modep )$/
138: sortchildren printgprof.c /^sortchildren( parentp )$/
139: sortmembers printgprof.c /^sortmembers( cyclep )$/
140: sortparents printgprof.c /^sortparents( childp )$/
141: tally gprof.c /^tally( rawp )$/
142: timecmp printgprof.c /^timecmp( npp1 , npp2 )$/
143: timepropagate arcs.c /^timepropagate( parentp )$/
144: topcmp arcs.c /^topcmp( npp1 , npp2 )$/
145: totalcmp printgprof.c /^totalcmp( npp1 , npp2 )$/
146: valcmp gprof.c /^valcmp(p1, p2)$/
147: gcrt0.h tahoe.h
148:
149: # IF YOU PUT ANYTHING HERE IT WILL GO AWAY
150: gprof/printlist.c 444 22 12 3250 4044774075 7376 /*
151: * Copyright (c) 1983 Regents of the University of California.
152: * All rights reserved. The Berkeley software License Agreement
153: * specifies the terms and conditions for redistribution.
154: */
155:
156: #ifndef lint
157: static char sccsid[] = "@(#)printlist.c 5.2 (Berkeley) 4/27/87";
158: #endif not lint
159:
160: #include "gprof.h"
161:
162: /*
163: * these are the lists of names:
164: * there is the list head and then the listname
165: * is a pointer to the list head
166: * (for ease of passing to stringlist functions).
167: */
168: struct stringlist kfromhead = { 0 , 0 };
169: struct stringlist *kfromlist = &kfromhead;
170: struct stringlist ktohead = { 0 , 0 };
171: struct stringlist *ktolist = &ktohead;
172: struct stringlist fhead = { 0 , 0 };
173: struct stringlist *flist = &fhead;
174: struct stringlist Fhead = { 0 , 0 };
175: struct stringlist *Flist = &Fhead;
176: struct stringlist ehead = { 0 , 0 };
177: struct stringlist *elist = &ehead;
178: struct stringlist Ehead = { 0 , 0 };
179: struct stringlist *Elist = &Ehead;
180:
181: addlist( listp , funcname )
182: struct stringlist *listp;
183: char *funcname;
184: {
185: struct stringlist *slp;
186:
187: slp = (struct stringlist *) malloc( sizeof(struct stringlist));
188: if ( slp == (struct stringlist *) 0 ) {
189: fprintf( stderr, "gprof: ran out room for printlist\n" );
190: done();
191: }
192: slp -> next = listp -> next;
193: slp -> string = funcname;
194: listp -> next = slp;
195: }
196:
197: bool
198: onlist( listp , funcname )
199: struct stringlist *listp;
200: char *funcname;
201: {
202: struct stringlist *slp;
203:
204: for ( slp = listp -> next ; slp ; slp = slp -> next ) {
205: if ( ! strcmp( slp -> string , funcname ) ) {
206: return TRUE;
207: }
208: if ( funcname[0] == '_' && ! strcmp( slp -> string , &funcname[1] ) ) {
209: return TRUE;
210: }
211: }
212: return FALSE;
213: }
214: tahoe.c /^operandlength( modep )$/
215: operandmode tahoe.c /^operandmode( modep )$/
216: operandname tahoe.c /^operandname( mode )$/
217: printblurb printgprof.c /^printblurb( blurbname )$/
218: printchildren printgprof.c /^printchildren( parentp )$/
219: printcycle printgprof.c /^printcycle( cyclep )$/
220: printgprof printgprof.c /^printgprof(timesortnlp)$/
221: printindex gprof/gprof.c 444 33 12 36756 4436154435 6523 /*
222: * Copyright (c) 1983 Regents of the University of California.
223: * All rights reserved. The Berkeley software License Agreement
224: * specifies the terms and conditions for redistribution.
225: */
226:
227: #ifndef lint
228: char copyright[] =
229: "@(#) Copyright (c) 1983 Regents of the University of California.\n\
230: All rights reserved.\n";
231: #endif not lint
232:
233: #ifndef lint
234: static char sccsid[] = "@(#)gprof.c 5.3 (Berkeley) 1/2/88";
235: #endif not lint
236:
237: #include "gprof.h"
238:
239: char *whoami = "gprof";
240:
241: /*
242: * things which get -E excluded by default.
243: */
244: char *defaultEs[] = { "mcount" , "__mcleanup" , 0 };
245:
246: main(argc, argv)
247: int argc;
248: char **argv;
249: {
250: char **sp;
251: nltype **timesortnlp;
252:
253: --argc;
254: argv++;
255: debug = 0;
256: bflag = TRUE;
257: while ( *argv != 0 && **argv == '-' ) {
258: (*argv)++;
259: switch ( **argv ) {
260: case 'a':
261: aflag = TRUE;
262: break;
263: case 'b':
264: bflag = FALSE;
265: break;
266: case 'c':
267: #if hp300
268: fprintf(stderr, "gprof -c isn't supported on hp300s yet\n");
269: exit(1);
270: #endif
271: cflag = TRUE;
272: break;
273: case 'd':
274: dflag = TRUE;
275: (*argv)++;
276: debug |= atoi( *argv );
277: debug |= ANYDEBUG;
278: # ifdef DEBUG
279: printf("[main] debug = %d\n", debug);
280: # else not DEBUG
281: printf("%s: -d ignored\n", whoami);
282: # endif DEBUG
283: break;
284: case 'E':
285: ++argv;
286: addlist( Elist , *argv );
287: Eflag = TRUE;
288: addlist( elist , *argv );
289: eflag = TRUE;
290: break;
291: case 'e':
292: addlist( elist , *++argv );
293: eflag = TRUE;
294: break;
295: case 'F':
296: ++argv;
297: addlist( Flist , *argv );
298: Fflag = TRUE;
299: addlist( flist , *argv );
300: fflag = TRUE;
301: break;
302: case 'f':
303: addlist( flist , *++argv );
304: fflag = TRUE;
305: break;
306: case 'H':
307: hz = atoi( *++argv );
308: if (hz < 0 || hz > 100000) {
309: fprintf(stderr, "unreasonable HZ value, using default\n");
310: hz = 0;
311: }
312: break;
313: case 'k':
314: addlist( kfromlist , *++argv );
315: addlist( ktolist , *++argv );
316: kflag = TRUE;
317: break;
318: case 's':
319: sflag = TRUE;
320: break;
321: case 'z':
322: zflag = TRUE;
323: break;
324: }
325: argv++;
326: }
327: if ( *argv != 0 ) {
328: a_outname = *argv;
329: argv++;
330: } else {
331: a_outname = A_OUTNAME;
332: }
333: if ( *argv != 0 ) {
334: gmonname = *argv;
335: argv++;
336: } else {
337: gmonname = GMONNAME;
338: }
339: /*
340: * turn off default functions
341: */
342: for ( sp = &defaultEs[0] ; *sp ; sp++ ) {
343: Eflag = TRUE;
344: addlist( Elist , *sp );
345: eflag = TRUE;
346: addlist( elist , *sp );
347: }
348: /*
349: * how many ticks per second?
350: * if we can't tell, report time in ticks.
351: */
352: if (hz == 0)
353: hz = hertz();
354: if (hz == 0) {
355: hz = 1;
356: fprintf(stderr, "time is in ticks, not seconds\n");
357: }
358: /*
359: * get information about a.out file.
360: */
361: getnfile();
362: /*
363: * get information about mon.out file(s).
364: */
365: do {
366: getpfile( gmonname );
367: if ( *argv != 0 ) {
368: gmonname = *argv;
369: }
370: } while ( *argv++ != 0 );
371: /*
372: * dump out a gmon.sum file if requested
373: */
374: if ( sflag ) {
375: dumpsum( GMONSUM );
376: }
377: /*
378: * assign samples to procedures
379: */
380: asgnsamples();
381: /*
382: * assemble the dynamic profile
383: */
384: timesortnlp = doarcs();
385: /*
386: * print the dynamic profile
387: */
388: printgprof( timesortnlp );
389: /*
390: * print the flat profile
391: */
392: printprof();
393: /*
394: * print the index
395: */
396: printindex();
397: done();
398: }
399:
400: /*
401: * Set up string and symbol tables from a.out.
402: * and optionally the text space.
403: * On return symbol table is sorted by value.
404: */
405: getnfile()
406: {
407: FILE *nfile;
408: int valcmp();
409:
410: nfile = fopen( a_outname ,"r");
411: if (nfile == NULL) {
412: perror( a_outname );
413: done();
414: }
415: fread(&xbuf, 1, sizeof(xbuf), nfile);
416: if (N_BADMAG(xbuf)) {
417: fprintf(stderr, "%s: %s: bad format\n", whoami , a_outname );
418: done();
419: }
420: getstrtab(nfile);
421: getsymtab(nfile);
422: gettextspace( nfile );
423: qsort(nl, nname, sizeof(nltype), valcmp);
424: fclose(nfile);
425: # ifdef DEBUG
426: if ( debug & AOUTDEBUG ) {
427: register int j;
428:
429: for (j = 0; j < nname; j++){
430: printf("[getnfile] 0X%08x\t%s\n", nl[j].value, nl[j].name);
431: }
432: }
433: # endif DEBUG
434: }
435:
436: getstrtab(nfile)
437: FILE *nfile;
438: {
439:
440: fseek(nfile, (long)(N_SYMOFF(xbuf) + xbuf.a_syms), 0);
441: if (fread(&ssiz, sizeof (ssiz), 1, nfile) == 0) {
442: fprintf(stderr, "%s: %s: no string table (old format?)\n" ,
443: whoami , a_outname );
444: done();
445: }
446: strtab = (char *)calloc(ssiz, 1);
447: if (strtab == NULL) {
448: fprintf(stderr, "%s: %s: no room for %d bytes of string table",
449: whoami , a_outname , ssiz);
450: done();
451: }
452: if (fread(strtab+sizeof(ssiz), ssiz-sizeof(ssiz), 1, nfile) != 1) {
453: fprintf(stderr, "%s: %s: error reading string table\n",
454: whoami , a_outname );
455: done();
456: }
457: }
458:
459: /*
460: * Read in symbol table
461: */
462: getsymtab(nfile)
463: FILE *nfile;
464: {
465: register long i;
466: int askfor;
467: struct nlist nbuf;
468:
469: /* pass1 - count symbols */
470: fseek(nfile, (long)N_SYMOFF(xbuf), 0);
471: nname = 0;
472: for (i = xbuf.a_syms; i > 0; i -= sizeof(struct nlist)) {
473: fread(&nbuf, sizeof(nbuf), 1, nfile);
474: if ( ! funcsymbol( &nbuf ) ) {
475: continue;
476: }
477: nname++;
478: }
479: if (nname == 0) {
480: fprintf(stderr, "%s: %s: no symbols\n", whoami , a_outname );
481: done();
482: }
483: askfor = nname + 1;
484: nl = (nltype *) calloc( askfor , sizeof(nltype) );
485: if (nl == 0) {
486: fprintf(stderr, "%s: No room for %d bytes of symbol table\n",
487: whoami, askfor * sizeof(nltype) );
488: done();
489: }
490:
491: /* pass2 - read symbols */
492: fseek(nfile, (long)N_SYMOFF(xbuf), 0);
493: npe = nl;
494: nname = 0;
495: for (i = xbuf.a_syms; i > 0; i -= sizeof(struct nlist)) {
496: fread(&nbuf, sizeof(nbuf), 1, nfile);
497: if ( ! funcsymbol( &nbuf ) ) {
498: # ifdef DEBUG
499: if ( debug & AOUTDEBUG ) {
500: printf( "[getsymtab] rejecting: 0x%x %s\n" ,
501: nbuf.n_type , strtab + nbuf.n_un.n_strx );
502: }
503: # endif DEBUG
504: continue;
505: }
506: npe->value = nbuf.n_value;
507: npe->name = strtab+nbuf.n_un.n_strx;
508: # ifdef DEBUG
509: if ( debug & AOUTDEBUG ) {
510: printf( "[getsymtab] %d %s 0x%08x\n" ,
511: nname , npe -> name , npe -> value );
512: }
513: # endif DEBUG
514: npe++;
515: nname++;
516: }
517: npe->value = -1;
518: }
519:
520: /*
521: * read in the text space of an a.out file
522: */
523: gettextspace( nfile )
524: FILE *nfile;
525: {
526: char *malloc();
527:
528: if ( cflag == 0 ) {
529: return;
530: }
531: textspace = (u_char *) malloc( xbuf.a_text );
532: if ( textspace == 0 ) {
533: fprintf( stderr , "%s: ran out room for %d bytes of text space: " ,
534: whoami , xbuf.a_text );
535: fprintf( stderr , "can't do -c\n" );
536: return;
537: }
538: (void) fseek( nfile , N_TXTOFF( xbuf ) , 0 );
539: if ( fread( textspace , 1 , xbuf.a_text , nfile ) != xbuf.a_text ) {
540: fprintf( stderr , "%s: couldn't read text space: " , whoami );
541: fprintf( stderr , "can't do -c\n" );
542: free( textspace );
543: textspace = 0;
544: return;
545: }
546: }
547: /*
548: * information from a gmon.out file is in two parts:
549: * an array of sampling hits within pc ranges,
550: * and the arcs.
551: */
552: getpfile(filename)
553: char *filename;
554: {
555: FILE *pfile;
556: FILE *openpfile();
557: struct rawarc arc;
558:
559: pfile = openpfile(filename);
560: readsamples(pfile);
561: /*
562: * the rest of the file consists of
563: * a bunch of <from,self,count> tuples.
564: */
565: while ( fread( &arc , sizeof arc , 1 , pfile ) == 1 ) {
566: # ifdef DEBUG
567: if ( debug & SAMPLEDEBUG ) {
568: printf( "[getpfile] frompc 0x%x selfpc 0x%x count %d\n" ,
569: arc.raw_frompc , arc.raw_selfpc , arc.raw_count );
570: }
571: # endif DEBUG
572: /*
573: * add this arc
574: */
575: tally( &arc );
576: }
577: fclose(pfile);
578: }
579:
580: FILE *
581: openpfile(filename)
582: char *filename;
583: {
584: struct hdr tmp;
585: FILE *pfile;
586:
587: if((pfile = fopen(filename, "r")) == NULL) {
588: perror(filename);
589: done();
590: }
591: fread(&tmp, sizeof(struct hdr), 1, pfile);
592: if ( s_highpc != 0 && ( tmp.lowpc != h.lowpc ||
593: tmp.highpc != h.highpc || tmp.ncnt != h.ncnt ) ) {
594: fprintf(stderr, "%s: incompatible with first gmon file\n", filename);
595: done();
596: }
597: h = tmp;
598: s_lowpc = (unsigned long) h.lowpc;
599: s_highpc = (unsigned long) h.highpc;
600: lowpc = (unsigned long)h.lowpc / sizeof(UNIT);
601: highpc = (unsigned long)h.highpc / sizeof(UNIT);
602: sampbytes = h.ncnt - sizeof(struct hdr);
603: nsamples = sampbytes / sizeof (UNIT);
604: # ifdef DEBUG
605: if ( debug & SAMPLEDEBUG ) {
606: printf( "[openpfile] hdr.lowpc 0x%x hdr.highpc 0x%x hdr.ncnt %d\n",
607: h.lowpc , h.highpc , h.ncnt );
608: printf( "[openpfile] s_lowpc 0x%x s_highpc 0x%x\n" ,
609: s_lowpc , s_highpc );
610: printf( "[openpfile] lowpc 0x%x highpc 0x%x\n" ,
611: lowpc , highpc );
612: printf( "[openpfile] sampbytes %d nsamples %d\n" ,
613: sampbytes , nsamples );
614: }
615: # endif DEBUG
616: return(pfile);
617: }
618:
619: tally( rawp )
620: struct rawarc *rawp;
621: {
622: nltype *parentp;
623: nltype *childp;
624:
625: parentp = nllookup( rawp -> raw_frompc );
626: childp = nllookup( rawp -> raw_selfpc );
627: if ( kflag
628: && onlist( kfromlist , parentp -> name )
629: && onlist( ktolist , childp -> name ) ) {
630: return;
631: }
632: childp -> ncall += rawp -> raw_count;
633: # ifdef DEBUG
634: if ( debug & TALLYDEBUG ) {
635: printf( "[tally] arc from %s to %s traversed %d times\n" ,
636: parentp -> name , childp -> name , rawp -> raw_count );
637: }
638: # endif DEBUG
639: addarc( parentp , childp , rawp -> raw_count );
640: }
641:
642: /*
643: * dump out the gmon.sum file
644: */
645: dumpsum( sumfile )
646: char *sumfile;
647: {
648: register nltype *nlp;
649: register arctype *arcp;
650: struct rawarc arc;
651: FILE *sfile;
652:
653: if ( ( sfile = fopen ( sumfile , "w" ) ) == NULL ) {
654: perror( sumfile );
655: done();
656: }
657: /*
658: * dump the header; use the last header read in
659: */
660: if ( fwrite( &h , sizeof h , 1 , sfile ) != 1 ) {
661: perror( sumfile );
662: done();
663: }
664: /*
665: * dump the samples
666: */
667: if (fwrite(samples, sizeof (UNIT), nsamples, sfile) != nsamples) {
668: perror( sumfile );
669: done();
670: }
671: /*
672: * dump the normalized raw arc information
673: */
674: for ( nlp = nl ; nlp < npe ; nlp++ ) {
675: for ( arcp = nlp -> children ; arcp ; arcp = arcp -> arc_childlist ) {
676: arc.raw_frompc = arcp -> arc_parentp -> value;
677: arc.raw_selfpc = arcp -> arc_childp -> value;
678: arc.raw_count = arcp -> arc_count;
679: if ( fwrite ( &arc , sizeof arc , 1 , sfile ) != 1 ) {
680: perror( sumfile );
681: done();
682: }
683: # ifdef DEBUG
684: if ( debug & SAMPLEDEBUG ) {
685: printf( "[dumpsum] frompc 0x%x selfpc 0x%x count %d\n" ,
686: arc.raw_frompc , arc.raw_selfpc , arc.raw_count );
687: }
688: # endif DEBUG
689: }
690: }
691: fclose( sfile );
692: }
693:
694: valcmp(p1, p2)
695: nltype *p1, *p2;
696: {
697: if ( p1 -> value < p2 -> value ) {
698: return LESSTHAN;
699: }
700: if ( p1 -> value > p2 -> value ) {
701: return GREATERTHAN;
702: }
703: return EQUALTO;
704: }
705:
706: readsamples(pfile)
707: FILE *pfile;
708: {
709: register i;
710: UNIT sample;
711:
712: if (samples == 0) {
713: samples = (UNIT *) calloc(sampbytes, sizeof (UNIT));
714: if (samples == 0) {
715: fprintf( stderr , "%s: No room for %d sample pc's\n",
716: whoami , sampbytes / sizeof (UNIT));
717: done();
718: }
719: }
720: for (i = 0; i < nsamples; i++) {
721: fread(&sample, sizeof (UNIT), 1, pfile);
722: if (feof(pfile))
723: break;
724: samples[i] += sample;
725: }
726: if (i != nsamples) {
727: fprintf(stderr,
728: "%s: unexpected EOF after reading %d/%d samples\n",
729: whoami , --i , nsamples );
730: done();
731: }
732: }
733:
734: /*
735: * Assign samples to the procedures to which they belong.
736: *
737: * There are three cases as to where pcl and pch can be
738: * with respect to the routine entry addresses svalue0 and svalue1
739: * as shown in the following diagram. overlap computes the
740: * distance between the arrows, the fraction of the sample
741: * that is to be credited to the routine which starts at svalue0.
742: *
743: * svalue0 svalue1
744: * | |
745: * v v
746: *
747: * +-----------------------------------------------+
748: * | |
749: * | ->| |<- ->| |<- ->| |<- |
750: * | | | | | |
751: * +---------+ +---------+ +---------+
752: *
753: * ^ ^ ^ ^ ^ ^
754: * | | | | | |
755: * pcl pch pcl pch pcl pch
756: *
757: * For the vax we assert that samples will never fall in the first
758: * two bytes of any routine, since that is the entry mask,
759: * thus we give call alignentries() to adjust the entry points if
760: * the entry mask falls in one bucket but the code for the routine
761: * doesn't start until the next bucket. In conjunction with the
762: * alignment of routine addresses, this should allow us to have
763: * only one sample for every four bytes of text space and never
764: * have any overlap (the two end cases, above).
765: */
766: asgnsamples()
767: {
768: register int j;
769: UNIT ccnt;
770: double time;
771: unsigned long pcl, pch;
772: register int i;
773: unsigned long overlap;
774: unsigned long svalue0, svalue1;
775:
776: /* read samples and assign to namelist symbols */
777: scale = highpc - lowpc;
778: scale /= nsamples;
779: alignentries();
780: for (i = 0, j = 1; i < nsamples; i++) {
781: ccnt = samples[i];
782: if (ccnt == 0)
783: continue;
784: pcl = lowpc + scale * i;
785: pch = lowpc + scale * (i + 1);
786: time = ccnt;
787: # ifdef DEBUG
788: if ( debug & SAMPLEDEBUG ) {
789: printf( "[asgnsamples] pcl 0x%x pch 0x%x ccnt %d\n" ,
790: pcl , pch , ccnt );
791: }
792: # endif DEBUG
793: totime += time;
794: for (j = j - 1; j < nname; j++) {
795: svalue0 = nl[j].svalue;
796: svalue1 = nl[j+1].svalue;
797: /*
798: * if high end of tick is below entry address,
799: * go for next tick.
800: */
801: if (pch < svalue0)
802: break;
803: /*
804: * if low end of tick into next routine,
805: * go for next routine.
806: */
807: if (pcl >= svalue1)
808: continue;
809: overlap = min(pch, svalue1) - max(pcl, svalue0);
810: if (overlap > 0) {
811: # ifdef DEBUG
812: if (debug & SAMPLEDEBUG) {
813: printf("[asgnsamples] (0x%x->0x%x-0x%x) %s gets %f ticks %d overlap\n",
814: nl[j].value/sizeof(UNIT), svalue0, svalue1,
815: nl[j].name,
816: overlap * time / scale, overlap);
817: }
818: # endif DEBUG
819: nl[j].time += overlap * time / scale;
820: }
821: }
822: }
823: # ifdef DEBUG
824: if (debug & SAMPLEDEBUG) {
825: printf("[asgnsamples] totime %f\n", totime);
826: }
827: # endif DEBUG
828: }
829:
830:
831: unsigned long
832: min(a, b)
833: unsigned long a,b;
834: {
835: if (a<b)
836: return(a);
837: return(b);
838: }
839:
840: unsigned long
841: max(a, b)
842: unsigned long a,b;
843: {
844: if (a>b)
845: return(a);
846: return(b);
847: }
848:
849: /*
850: * calculate scaled entry point addresses (to save time in asgnsamples),
851: * and possibly push the scaled entry points over the entry mask,
852: * if it turns out that the entry point is in one bucket and the code
853: * for a routine is in the next bucket.
854: */
855: alignentries()
856: {
857: register struct nl *nlp;
858: unsigned long bucket_of_entry;
859: unsigned long bucket_of_code;
860:
861: for (nlp = nl; nlp < npe; nlp++) {
862: nlp -> svalue = nlp -> value / sizeof(UNIT);
863: bucket_of_entry = (nlp->svalue - lowpc) / scale;
864: bucket_of_code = (nlp->svalue + UNITS_TO_CODE - lowpc) / scale;
865: if (bucket_of_entry < bucket_of_code) {
866: # ifdef DEBUG
867: if (debug & SAMPLEDEBUG) {
868: printf("[alignentries] pushing svalue 0x%x to 0x%x\n",
869: nlp->svalue, nlp->svalue + UNITS_TO_CODE);
870: }
871: # endif DEBUG
872: nlp->svalue += UNITS_TO_CODE;
873: }
874: }
875: }
876:
877: bool
878: funcsymbol( nlistp )
879: struct nlist *nlistp;
880: {
881: extern char *strtab; /* string table from a.out */
882: extern int aflag; /* if static functions aren't desired */
883: char *name;
884:
885: /*
886: * must be a text symbol,
887: * and static text symbols don't qualify if aflag set.
888: */
889: if ( ! ( ( nlistp -> n_type == ( N_TEXT | N_EXT ) )
890: || ( ( nlistp -> n_type == N_TEXT ) && ( aflag == 0 ) ) ) ) {
891: return FALSE;
892: }
893: /*
894: * can't have any `funny' characters in name,
895: * where `funny' includes `.', .o file names
896: * and `$', pascal labels.
897: */
898: for ( name = strtab + nlistp -> n_un.n_strx ; *name ; name += 1 ) {
899: if ( *name == '.' || *name == '$' ) {
900: return FALSE;
901: }
902: }
903: return TRUE;
904: }
905:
906: done()
907: {
908:
909: exit(0);
910: }
911: -------+
912: * gprof/gprof.h 444 22 12 15325 4230312011 6465 /*
913: * Copyright (c) 1983 Regents of the University of California.
914: * All rights reserved. The Berkeley software License Agreement
915: * specifies the terms and conditions for redistribution.
916: *
917: * @(#)gprof.h 5.4 (Berkeley) 1/2/88
918: */
919:
920: #include <stdio.h>
921: #include <sys/types.h>
922: #include <sys/stat.h>
923: #include <a.out.h>
924: #include "gcrt0.h"
925:
926: #if vax
927: # include "vax.h"
928: #endif
929: #if sun
930: # include "sun.h"
931: #endif
932: #if tahoe
933: # include "tahoe.h"
934: #endif
935: #if hp300
936: # include "hp300.h"
937: #endif
938:
939:
940: /*
941: * who am i, for error messages.
942: */
943: char *whoami;
944:
945: /*
946: * booleans
947: */
948: typedef int bool;
949: #define FALSE 0
950: #define TRUE 1
951:
952: /*
953: * ticks per second
954: */
955: long hz;
956:
957: typedef u_short UNIT; /* unit of profiling */
958: char *a_outname;
959: #define A_OUTNAME "a.out"
960:
961: char *gmonname;
962: #define GMONNAME "gmon.out"
963: #define GMONSUM "gmon.sum"
964:
965: /*
966: * blurbs on the flat and graph profiles.
967: */
968: #define FLAT_BLURB "/usr/lib/gprof.flat"
969: #define CALLG_BLURB "/usr/lib/gprof.callg"
970:
971: /*
972: * a constructed arc,
973: * with pointers to the namelist entry of the parent and the child,
974: * a count of how many times this arc was traversed,
975: * and pointers to the next parent of this child and
976: * the next child of this parent.
977: */
978: struct arcstruct {
979: struct nl *arc_parentp; /* pointer to parent's nl entry */
980: struct nl *arc_childp; /* pointer to child's nl entry */
981: long arc_count; /* how calls from parent to child */
982: double arc_time; /* time inherited along arc */
983: double arc_childtime; /* childtime inherited along arc */
984: struct arcstruct *arc_parentlist; /* parents-of-this-child list */
985: struct arcstruct *arc_childlist; /* children-of-this-parent list */
986: };
987: typedef struct arcstruct arctype;
988:
989: /*
990: * The symbol table;
991: * for each external in the specified file we gather
992: * its address, the number of calls and compute its share of cpu time.
993: */
994: struct nl {
995: char *name; /* the name */
996: unsigned long value; /* the pc entry point */
997: unsigned long svalue; /* entry point aligned to histograms */
998: double time; /* ticks in this routine */
999: double childtime; /* cumulative ticks in children */
1000: long ncall; /* how many times called */
1001: long selfcalls; /* how many calls to self */
1002: double propfraction; /* what % of time propagates */
1003: double propself; /* how much self time propagates */
1004: double propchild; /* how much child time propagates */
1005: bool printflag; /* should this be printed? */
1006: int index; /* index in the graph list */
1007: int toporder; /* graph call chain top-sort order */
1008: int cycleno; /* internal number of cycle on */
1009: struct nl *cyclehead; /* pointer to head of cycle */
1010: struct nl *cnext; /* pointer to next member of cycle */
1011: arctype *parents; /* list of caller arcs */
1012: arctype *children; /* list of callee arcs */
1013: };
1014: typedef struct nl nltype;
1015:
1016: nltype *nl; /* the whole namelist */
1017: nltype *npe; /* the virtual end of the namelist */
1018: int nname; /* the number of function names */
1019:
1020: /*
1021: * flag which marks a nl entry as topologically ``busy''
1022: * flag which marks a nl entry as topologically ``not_numbered''
1023: */
1024: #define DFN_BUSY -1
1025: #define DFN_NAN 0
1026:
1027: /*
1028: * namelist entries for cycle headers.
1029: * the number of discovered cycles.
1030: */
1031: nltype *cyclenl; /* cycle header namelist */
1032: int ncycle; /* number of cycles discovered */
1033:
1034: /*
1035: * The header on the gmon.out file.
1036: * gmon.out consists of one of these headers,
1037: * and then an array of ncnt samples
1038: * representing the discretized program counter values.
1039: * this should be a struct phdr, but since everything is done
1040: * as UNITs, this is in UNITs too.
1041: */
1042: struct hdr {
1043: UNIT *lowpc;
1044: UNIT *highpc;
1045: int ncnt;
1046: };
1047:
1048: struct hdr h;
1049:
1050: int debug;
1051:
1052: /*
1053: * Each discretized pc sample has
1054: * a count of the number of samples in its range
1055: */
1056: UNIT *samples;
1057:
1058: unsigned long s_lowpc; /* lowpc from the profile file */
1059: unsigned long s_highpc; /* highpc from the profile file */
1060: unsigned lowpc, highpc; /* range profiled, in UNIT's */
1061: unsigned sampbytes; /* number of bytes of samples */
1062: int nsamples; /* number of samples */
1063: double actime; /* accumulated time thus far for putprofline */
1064: double totime; /* total time for all routines */
1065: double printtime; /* total of time being printed */
1066: double scale; /* scale factor converting samples to pc
1067: values: each sample covers scale bytes */
1068: char *strtab; /* string table in core */
1069: off_t ssiz; /* size of the string table */
1070: struct exec xbuf; /* exec header of a.out */
1071: unsigned char *textspace; /* text space of a.out in core */
1072:
1073: /*
1074: * option flags, from a to z.
1075: */
1076: bool aflag; /* suppress static functions */
1077: bool bflag; /* blurbs, too */
1078: bool cflag; /* discovered call graph, too */
1079: bool dflag; /* debugging options */
1080: bool eflag; /* specific functions excluded */
1081: bool Eflag; /* functions excluded with time */
1082: bool fflag; /* specific functions requested */
1083: bool Fflag; /* functions requested with time */
1084: bool kflag; /* arcs to be deleted */
1085: bool sflag; /* sum multiple gmon.out files */
1086: bool zflag; /* zero time/called functions, too */
1087:
1088: /*
1089: * structure for various string lists
1090: */
1091: struct stringlist {
1092: struct stringlist *next;
1093: char *string;
1094: };
1095: struct stringlist *elist;
1096: struct stringlist *Elist;
1097: struct stringlist *flist;
1098: struct stringlist *Flist;
1099: struct stringlist *kfromlist;
1100: struct stringlist *ktolist;
1101:
1102: /*
1103: * function declarations
1104: */
1105: /*
1106: addarc();
1107: */
1108: int arccmp();
1109: arctype *arclookup();
1110: /*
1111: asgnsamples();
1112: printblurb();
1113: cyclelink();
1114: dfn();
1115: */
1116: bool dfn_busy();
1117: /*
1118: dfn_findcycle();
1119: */
1120: bool dfn_numbered();
1121: /*
1122: dfn_post_visit();
1123: dfn_pre_visit();
1124: dfn_self_cycle();
1125: */
1126: nltype **doarcs();
1127: /*
1128: done();
1129: findcalls();
1130: flatprofheader();
1131: flatprofline();
1132: */
1133: bool funcsymbol();
1134: /*
1135: getnfile();
1136: getpfile();
1137: getstrtab();
1138: getsymtab();
1139: gettextspace();
1140: gprofheader();
1141: gprofline();
1142: main();
1143: */
1144: unsigned long max();
1145: int membercmp();
1146: unsigned long min();
1147: nltype *nllookup();
1148: FILE *openpfile();
1149: long operandlength();
1150: operandenum operandmode();
1151: char *operandname();
1152: /*
1153: printchildren();
1154: printcycle();
1155: printgprof();
1156: printmembers();
1157: printname();
1158: printparents();
1159: printprof();
1160: readsamples();
1161: */
1162: unsigned long reladdr();
1163: /*
1164: sortchildren();
1165: sortmembers();
1166: sortparents();
1167: tally();
1168: timecmp();
1169: topcmp();
1170: */
1171: int totalcmp();
1172: /*
1173: valcmp();
1174: */
1175:
1176: #define LESSTHAN -1
1177: #define EQUALTO 0
1178: #define GREATERTHAN 1
1179:
1180: #define DFNDEBUG 1
1181: #define CYCLEDEBUG 2
1182: #define ARCDEBUG 4
1183: #define TALLYDEBUG 8
1184: #define TIMEDEBUG 16
1185: #define SAMPLEDEBUG 32
1186: #define AOUTDEBUG 64
1187: #define CALLDEBUG 128
1188: #define LOOKUPDEBUG 256
1189: #define PROPDEBUG 512
1190: #define ANYDEBUG 1024
1191: ext; /* pointer to next member of cycle */
1192: arctype *parents; /* list of caller arcs */
1193: arctype *children; /* list of callee arcs */
1194: };
1195: typedef struct nl nltype;
1196:
1197: nltype *nl; /* the whole namelist */
1198: nltype *npe; /* the virtual end of the namelist */
1199: int nname; /* the number of funcgprof/dfn.c 444 22 12 14644 3500670430 6130 /*
1200: * Copyright (c) 1983 Regents of the University of California.
1201: * All rights reserved. The Berkeley software License Agreement
1202: * specifies the terms and conditions for redistribution.
1203: */
1204:
1205: #ifndef lint
1206: static char sccsid[] = "@(#)dfn.c 5.1 (Berkeley) 6/4/85";
1207: #endif not lint
1208:
1209: #include <stdio.h>
1210: #include "gprof.h"
1211:
1212: #define DFN_DEPTH 100
1213: struct dfnstruct {
1214: nltype *nlentryp;
1215: int cycletop;
1216: };
1217: typedef struct dfnstruct dfntype;
1218:
1219: dfntype dfn_stack[ DFN_DEPTH ];
1220: int dfn_depth = 0;
1221:
1222: int dfn_counter = DFN_NAN;
1223:
1224: /*
1225: * given this parent, depth first number its children.
1226: */
1227: dfn( parentp )
1228: nltype *parentp;
1229: {
1230: arctype *arcp;
1231:
1232: # ifdef DEBUG
1233: if ( debug & DFNDEBUG ) {
1234: printf( "[dfn] dfn(" );
1235: printname( parentp );
1236: printf( ")\n" );
1237: }
1238: # endif DEBUG
1239: /*
1240: * if we're already numbered, no need to look any furthur.
1241: */
1242: if ( dfn_numbered( parentp ) ) {
1243: return;
1244: }
1245: /*
1246: * if we're already busy, must be a cycle
1247: */
1248: if ( dfn_busy( parentp ) ) {
1249: dfn_findcycle( parentp );
1250: return;
1251: }
1252: /*
1253: * visit yourself before your children
1254: */
1255: dfn_pre_visit( parentp );
1256: /*
1257: * visit children
1258: */
1259: for ( arcp = parentp -> children ; arcp ; arcp = arcp -> arc_childlist ) {
1260: dfn( arcp -> arc_childp );
1261: }
1262: /*
1263: * visit yourself after your children
1264: */
1265: dfn_post_visit( parentp );
1266: }
1267:
1268: /*
1269: * push a parent onto the stack and mark it busy
1270: */
1271: dfn_pre_visit( parentp )
1272: nltype *parentp;
1273: {
1274:
1275: dfn_depth += 1;
1276: if ( dfn_depth >= DFN_DEPTH ) {
1277: fprintf( stderr , "[dfn] out of my depth (dfn_stack overflow)\n" );
1278: exit( 1 );
1279: }
1280: dfn_stack[ dfn_depth ].nlentryp = parentp;
1281: dfn_stack[ dfn_depth ].cycletop = dfn_depth;
1282: parentp -> toporder = DFN_BUSY;
1283: # ifdef DEBUG
1284: if ( debug & DFNDEBUG ) {
1285: printf( "[dfn_pre_visit]\t\t%d:" , dfn_depth );
1286: printname( parentp );
1287: printf( "\n" );
1288: }
1289: # endif DEBUG
1290: }
1291:
1292: /*
1293: * are we already numbered?
1294: */
1295: bool
1296: dfn_numbered( childp )
1297: nltype *childp;
1298: {
1299:
1300: return ( childp -> toporder != DFN_NAN && childp -> toporder != DFN_BUSY );
1301: }
1302:
1303: /*
1304: * are we already busy?
1305: */
1306: bool
1307: dfn_busy( childp )
1308: nltype *childp;
1309: {
1310:
1311: if ( childp -> toporder == DFN_NAN ) {
1312: return FALSE;
1313: }
1314: return TRUE;
1315: }
1316:
1317: /*
1318: * MISSING: an explanation
1319: */
1320: dfn_findcycle( childp )
1321: nltype *childp;
1322: {
1323: int cycletop;
1324: nltype *cycleheadp;
1325: nltype *tailp;
1326: int index;
1327:
1328: for ( cycletop = dfn_depth ; cycletop > 0 ; cycletop -= 1 ) {
1329: cycleheadp = dfn_stack[ cycletop ].nlentryp;
1330: if ( childp == cycleheadp ) {
1331: break;
1332: }
1333: if ( childp -> cyclehead != childp &&
1334: childp -> cyclehead == cycleheadp ) {
1335: break;
1336: }
1337: }
1338: if ( cycletop <= 0 ) {
1339: fprintf( stderr , "[dfn_findcycle] couldn't find head of cycle\n" );
1340: exit( 1 );
1341: }
1342: # ifdef DEBUG
1343: if ( debug & DFNDEBUG ) {
1344: printf( "[dfn_findcycle] dfn_depth %d cycletop %d " ,
1345: dfn_depth , cycletop );
1346: printname( cycleheadp );
1347: printf( "\n" );
1348: }
1349: # endif DEBUG
1350: if ( cycletop == dfn_depth ) {
1351: /*
1352: * this is previous function, e.g. this calls itself
1353: * sort of boring
1354: */
1355: dfn_self_cycle( childp );
1356: } else {
1357: /*
1358: * glom intervening functions that aren't already
1359: * glommed into this cycle.
1360: * things have been glommed when their cyclehead field
1361: * points to the head of the cycle they are glommed into.
1362: */
1363: for ( tailp = cycleheadp ; tailp -> cnext ; tailp = tailp -> cnext ) {
1364: /* void: chase down to tail of things already glommed */
1365: # ifdef DEBUG
1366: if ( debug & DFNDEBUG ) {
1367: printf( "[dfn_findcycle] tail " );
1368: printname( tailp );
1369: printf( "\n" );
1370: }
1371: # endif DEBUG
1372: }
1373: /*
1374: * if what we think is the top of the cycle
1375: * has a cyclehead field, then it's not really the
1376: * head of the cycle, which is really what we want
1377: */
1378: if ( cycleheadp -> cyclehead != cycleheadp ) {
1379: cycleheadp = cycleheadp -> cyclehead;
1380: # ifdef DEBUG
1381: if ( debug & DFNDEBUG ) {
1382: printf( "[dfn_findcycle] new cyclehead " );
1383: printname( cycleheadp );
1384: printf( "\n" );
1385: }
1386: # endif DEBUG
1387: }
1388: for ( index = cycletop + 1 ; index <= dfn_depth ; index += 1 ) {
1389: childp = dfn_stack[ index ].nlentryp;
1390: if ( childp -> cyclehead == childp ) {
1391: /*
1392: * not yet glommed anywhere, glom it
1393: * and fix any children it has glommed
1394: */
1395: tailp -> cnext = childp;
1396: childp -> cyclehead = cycleheadp;
1397: # ifdef DEBUG
1398: if ( debug & DFNDEBUG ) {
1399: printf( "[dfn_findcycle] glomming " );
1400: printname( childp );
1401: printf( " onto " );
1402: printname( cycleheadp );
1403: printf( "\n" );
1404: }
1405: # endif DEBUG
1406: for ( tailp = childp ; tailp->cnext ; tailp = tailp->cnext ) {
1407: tailp -> cnext -> cyclehead = cycleheadp;
1408: # ifdef DEBUG
1409: if ( debug & DFNDEBUG ) {
1410: printf( "[dfn_findcycle] and its tail " );
1411: printname( tailp -> cnext );
1412: printf( " onto " );
1413: printname( cycleheadp );
1414: printf( "\n" );
1415: }
1416: # endif DEBUG
1417: }
1418: } else if ( childp -> cyclehead != cycleheadp /* firewall */ ) {
1419: fprintf( stderr ,
1420: "[dfn_busy] glommed, but not to cyclehead\n" );
1421: }
1422: }
1423: }
1424: }
1425:
1426: /*
1427: * deal with self-cycles
1428: * for lint: ARGSUSED
1429: */
1430: dfn_self_cycle( parentp )
1431: nltype *parentp;
1432: {
1433: /*
1434: * since we are taking out self-cycles elsewhere
1435: * no need for the special case, here.
1436: */
1437: # ifdef DEBUG
1438: if ( debug & DFNDEBUG ) {
1439: printf( "[dfn_self_cycle] " );
1440: printname( parentp );
1441: printf( "\n" );
1442: }
1443: # endif DEBUG
1444: }
1445:
1446: /*
1447: * visit a node after all its children
1448: * [MISSING: an explanation]
1449: * and pop it off the stack
1450: */
1451: dfn_post_visit( parentp )
1452: nltype *parentp;
1453: {
1454: nltype *memberp;
1455:
1456: # ifdef DEBUG
1457: if ( debug & DFNDEBUG ) {
1458: printf( "[dfn_post_visit]\t%d: " , dfn_depth );
1459: printname( parentp );
1460: printf( "\n" );
1461: }
1462: # endif DEBUG
1463: /*
1464: * number functions and things in their cycles
1465: * unless the function is itself part of a cycle
1466: */
1467: if ( parentp -> cyclehead == parentp ) {
1468: dfn_counter += 1;
1469: for ( memberp = parentp ; memberp ; memberp = memberp -> cnext ) {
1470: memberp -> toporder = dfn_counter;
1471: # ifdef DEBUG
1472: if ( debug & DFNDEBUG ) {
1473: printf( "[dfn_post_visit]\t\tmember " );
1474: printname( memberp );
1475: printf( " -> toporder = %d\n" , dfn_counter );
1476: }
1477: # endif DEBUG
1478: }
1479: } else {
1480: # ifdef DEBUG
1481: if ( debug & DFNDEBUG ) {
1482: printf( "[dfn_post_visit]\t\tis part of a cycle\n" );
1483: }
1484: # endif DEBUG
1485: }
1486: dfn_depth -= 1;
1487: }
1488: cycletop > 0 ; cycletop -= 1 ) {
1489: cycleheadp = dfn_stack[ cycletop ].nlentryp;
1490: if ( childp gprof/arcs.c 444 22 12 35645 4044770454 6330 /*
1491: * Copyright (c) 1983 Regents of the University of California.
1492: * All rights reserved. The Berkeley software License Agreement
1493: * specifies the terms and conditions for redistribution.
1494: */
1495:
1496: #ifndef lint
1497: static char sccsid[] = "@(#)arcs.c 5.3 (Berkeley) 1/7/86";
1498: #endif not lint
1499:
1500: #include "gprof.h"
1501:
1502: /*
1503: * add (or just increment) an arc
1504: */
1505: addarc( parentp , childp , count )
1506: nltype *parentp;
1507: nltype *childp;
1508: long count;
1509: {
1510: arctype *calloc();
1511: arctype *arcp;
1512:
1513: # ifdef DEBUG
1514: if ( debug & TALLYDEBUG ) {
1515: printf( "[addarc] %d arcs from %s to %s\n" ,
1516: count , parentp -> name , childp -> name );
1517: }
1518: # endif DEBUG
1519: arcp = arclookup( parentp , childp );
1520: if ( arcp != 0 ) {
1521: /*
1522: * a hit: just increment the count.
1523: */
1524: # ifdef DEBUG
1525: if ( debug & TALLYDEBUG ) {
1526: printf( "[tally] hit %d += %d\n" ,
1527: arcp -> arc_count , count );
1528: }
1529: # endif DEBUG
1530: arcp -> arc_count += count;
1531: return;
1532: }
1533: arcp = calloc( 1 , sizeof *arcp );
1534: arcp -> arc_parentp = parentp;
1535: arcp -> arc_childp = childp;
1536: arcp -> arc_count = count;
1537: /*
1538: * prepend this child to the children of this parent
1539: */
1540: arcp -> arc_childlist = parentp -> children;
1541: parentp -> children = arcp;
1542: /*
1543: * prepend this parent to the parents of this child
1544: */
1545: arcp -> arc_parentlist = childp -> parents;
1546: childp -> parents = arcp;
1547: }
1548:
1549: /*
1550: * the code below topologically sorts the graph (collapsing cycles),
1551: * and propagates time bottom up and flags top down.
1552: */
1553:
1554: /*
1555: * the topologically sorted name list pointers
1556: */
1557: nltype **topsortnlp;
1558:
1559: topcmp( npp1 , npp2 )
1560: nltype **npp1;
1561: nltype **npp2;
1562: {
1563: return (*npp1) -> toporder - (*npp2) -> toporder;
1564: }
1565:
1566: nltype **
1567: doarcs()
1568: {
1569: nltype *parentp, **timesortnlp;
1570: arctype *arcp;
1571: long index;
1572:
1573: /*
1574: * initialize various things:
1575: * zero out child times.
1576: * count self-recursive calls.
1577: * indicate that nothing is on cycles.
1578: */
1579: for ( parentp = nl ; parentp < npe ; parentp++ ) {
1580: parentp -> childtime = 0.0;
1581: arcp = arclookup( parentp , parentp );
1582: if ( arcp != 0 ) {
1583: parentp -> ncall -= arcp -> arc_count;
1584: parentp -> selfcalls = arcp -> arc_count;
1585: } else {
1586: parentp -> selfcalls = 0;
1587: }
1588: parentp -> propfraction = 0.0;
1589: parentp -> propself = 0.0;
1590: parentp -> propchild = 0.0;
1591: parentp -> printflag = FALSE;
1592: parentp -> toporder = DFN_NAN;
1593: parentp -> cycleno = 0;
1594: parentp -> cyclehead = parentp;
1595: parentp -> cnext = 0;
1596: if ( cflag ) {
1597: findcall( parentp , parentp -> value , (parentp+1) -> value );
1598: }
1599: }
1600: /*
1601: * topologically order things
1602: * if any node is unnumbered,
1603: * number it and any of its descendents.
1604: */
1605: for ( parentp = nl ; parentp < npe ; parentp++ ) {
1606: if ( parentp -> toporder == DFN_NAN ) {
1607: dfn( parentp );
1608: }
1609: }
1610: /*
1611: * link together nodes on the same cycle
1612: */
1613: cyclelink();
1614: /*
1615: * Sort the symbol table in reverse topological order
1616: */
1617: topsortnlp = (nltype **) calloc( nname , sizeof(nltype *) );
1618: if ( topsortnlp == (nltype **) 0 ) {
1619: fprintf( stderr , "[doarcs] ran out of memory for topo sorting\n" );
1620: }
1621: for ( index = 0 ; index < nname ; index += 1 ) {
1622: topsortnlp[ index ] = &nl[ index ];
1623: }
1624: qsort( topsortnlp , nname , sizeof(nltype *) , topcmp );
1625: # ifdef DEBUG
1626: if ( debug & DFNDEBUG ) {
1627: printf( "[doarcs] topological sort listing\n" );
1628: for ( index = 0 ; index < nname ; index += 1 ) {
1629: printf( "[doarcs] " );
1630: printf( "%d:" , topsortnlp[ index ] -> toporder );
1631: printname( topsortnlp[ index ] );
1632: printf( "\n" );
1633: }
1634: }
1635: # endif DEBUG
1636: /*
1637: * starting from the topological top,
1638: * propagate print flags to children.
1639: * also, calculate propagation fractions.
1640: * this happens before time propagation
1641: * since time propagation uses the fractions.
1642: */
1643: doflags();
1644: /*
1645: * starting from the topological bottom,
1646: * propogate children times up to parents.
1647: */
1648: dotime();
1649: /*
1650: * Now, sort by propself + propchild.
1651: * sorting both the regular function names
1652: * and cycle headers.
1653: */
1654: timesortnlp = (nltype **) calloc( nname + ncycle , sizeof(nltype *) );
1655: if ( timesortnlp == (nltype **) 0 ) {
1656: fprintf( stderr , "%s: ran out of memory for sorting\n" , whoami );
1657: }
1658: for ( index = 0 ; index < nname ; index++ ) {
1659: timesortnlp[index] = &nl[index];
1660: }
1661: for ( index = 1 ; index <= ncycle ; index++ ) {
1662: timesortnlp[nname+index-1] = &cyclenl[index];
1663: }
1664: qsort( timesortnlp , nname + ncycle , sizeof(nltype *) , totalcmp );
1665: for ( index = 0 ; index < nname + ncycle ; index++ ) {
1666: timesortnlp[ index ] -> index = index + 1;
1667: }
1668: return( timesortnlp );
1669: }
1670:
1671: dotime()
1672: {
1673: int index;
1674:
1675: cycletime();
1676: for ( index = 0 ; index < nname ; index += 1 ) {
1677: timepropagate( topsortnlp[ index ] );
1678: }
1679: }
1680:
1681: timepropagate( parentp )
1682: nltype *parentp;
1683: {
1684: arctype *arcp;
1685: nltype *childp;
1686: double share;
1687: double propshare;
1688:
1689: if ( parentp -> propfraction == 0.0 ) {
1690: return;
1691: }
1692: /*
1693: * gather time from children of this parent.
1694: */
1695: for ( arcp = parentp -> children ; arcp ; arcp = arcp -> arc_childlist ) {
1696: childp = arcp -> arc_childp;
1697: if ( arcp -> arc_count == 0 ) {
1698: continue;
1699: }
1700: if ( childp == parentp ) {
1701: continue;
1702: }
1703: if ( childp -> propfraction == 0.0 ) {
1704: continue;
1705: }
1706: if ( childp -> cyclehead != childp ) {
1707: if ( parentp -> cycleno == childp -> cycleno ) {
1708: continue;
1709: }
1710: if ( parentp -> toporder <= childp -> toporder ) {
1711: fprintf( stderr , "[propagate] toporder botches\n" );
1712: }
1713: childp = childp -> cyclehead;
1714: } else {
1715: if ( parentp -> toporder <= childp -> toporder ) {
1716: fprintf( stderr , "[propagate] toporder botches\n" );
1717: continue;
1718: }
1719: }
1720: if ( childp -> ncall == 0 ) {
1721: continue;
1722: }
1723: /*
1724: * distribute time for this arc
1725: */
1726: arcp -> arc_time = childp -> time
1727: * ( ( (double) arcp -> arc_count ) /
1728: ( (double) childp -> ncall ) );
1729: arcp -> arc_childtime = childp -> childtime
1730: * ( ( (double) arcp -> arc_count ) /
1731: ( (double) childp -> ncall ) );
1732: share = arcp -> arc_time + arcp -> arc_childtime;
1733: parentp -> childtime += share;
1734: /*
1735: * ( 1 - propfraction ) gets lost along the way
1736: */
1737: propshare = parentp -> propfraction * share;
1738: /*
1739: * fix things for printing
1740: */
1741: parentp -> propchild += propshare;
1742: arcp -> arc_time *= parentp -> propfraction;
1743: arcp -> arc_childtime *= parentp -> propfraction;
1744: /*
1745: * add this share to the parent's cycle header, if any.
1746: */
1747: if ( parentp -> cyclehead != parentp ) {
1748: parentp -> cyclehead -> childtime += share;
1749: parentp -> cyclehead -> propchild += propshare;
1750: }
1751: # ifdef DEBUG
1752: if ( debug & PROPDEBUG ) {
1753: printf( "[dotime] child \t" );
1754: printname( childp );
1755: printf( " with %f %f %d/%d\n" ,
1756: childp -> time , childp -> childtime ,
1757: arcp -> arc_count , childp -> ncall );
1758: printf( "[dotime] parent\t" );
1759: printname( parentp );
1760: printf( "\n[dotime] share %f\n" , share );
1761: }
1762: # endif DEBUG
1763: }
1764: }
1765:
1766: cyclelink()
1767: {
1768: register nltype *nlp;
1769: register nltype *cyclenlp;
1770: int cycle;
1771: nltype *memberp;
1772: arctype *arcp;
1773:
1774: /*
1775: * Count the number of cycles, and initialze the cycle lists
1776: */
1777: ncycle = 0;
1778: for ( nlp = nl ; nlp < npe ; nlp++ ) {
1779: /*
1780: * this is how you find unattached cycles
1781: */
1782: if ( nlp -> cyclehead == nlp && nlp -> cnext != 0 ) {
1783: ncycle += 1;
1784: }
1785: }
1786: /*
1787: * cyclenl is indexed by cycle number:
1788: * i.e. it is origin 1, not origin 0.
1789: */
1790: cyclenl = (nltype *) calloc( ncycle + 1 , sizeof( nltype ) );
1791: if ( cyclenl == 0 ) {
1792: fprintf( stderr , "%s: No room for %d bytes of cycle headers\n" ,
1793: whoami , ( ncycle + 1 ) * sizeof( nltype ) );
1794: done();
1795: }
1796: /*
1797: * now link cycles to true cycleheads,
1798: * number them, accumulate the data for the cycle
1799: */
1800: cycle = 0;
1801: for ( nlp = nl ; nlp < npe ; nlp++ ) {
1802: if ( !( nlp -> cyclehead == nlp && nlp -> cnext != 0 ) ) {
1803: continue;
1804: }
1805: cycle += 1;
1806: cyclenlp = &cyclenl[cycle];
1807: cyclenlp -> name = 0; /* the name */
1808: cyclenlp -> value = 0; /* the pc entry point */
1809: cyclenlp -> time = 0.0; /* ticks in this routine */
1810: cyclenlp -> childtime = 0.0; /* cumulative ticks in children */
1811: cyclenlp -> ncall = 0; /* how many times called */
1812: cyclenlp -> selfcalls = 0; /* how many calls to self */
1813: cyclenlp -> propfraction = 0.0; /* what % of time propagates */
1814: cyclenlp -> propself = 0.0; /* how much self time propagates */
1815: cyclenlp -> propchild = 0.0; /* how much child time propagates */
1816: cyclenlp -> printflag = TRUE; /* should this be printed? */
1817: cyclenlp -> index = 0; /* index in the graph list */
1818: cyclenlp -> toporder = DFN_NAN; /* graph call chain top-sort order */
1819: cyclenlp -> cycleno = cycle; /* internal number of cycle on */
1820: cyclenlp -> cyclehead = cyclenlp; /* pointer to head of cycle */
1821: cyclenlp -> cnext = nlp; /* pointer to next member of cycle */
1822: cyclenlp -> parents = 0; /* list of caller arcs */
1823: cyclenlp -> children = 0; /* list of callee arcs */
1824: # ifdef DEBUG
1825: if ( debug & CYCLEDEBUG ) {
1826: printf( "[cyclelink] " );
1827: printname( nlp );
1828: printf( " is the head of cycle %d\n" , cycle );
1829: }
1830: # endif DEBUG
1831: /*
1832: * link members to cycle header
1833: */
1834: for ( memberp = nlp ; memberp ; memberp = memberp -> cnext ) {
1835: memberp -> cycleno = cycle;
1836: memberp -> cyclehead = cyclenlp;
1837: }
1838: /*
1839: * count calls from outside the cycle
1840: * and those among cycle members
1841: */
1842: for ( memberp = nlp ; memberp ; memberp = memberp -> cnext ) {
1843: for ( arcp=memberp->parents ; arcp ; arcp=arcp->arc_parentlist ) {
1844: if ( arcp -> arc_parentp == memberp ) {
1845: continue;
1846: }
1847: if ( arcp -> arc_parentp -> cycleno == cycle ) {
1848: cyclenlp -> selfcalls += arcp -> arc_count;
1849: } else {
1850: cyclenlp -> ncall += arcp -> arc_count;
1851: }
1852: }
1853: }
1854: }
1855: }
1856:
1857: cycletime()
1858: {
1859: int cycle;
1860: nltype *cyclenlp;
1861: nltype *childp;
1862:
1863: for ( cycle = 1 ; cycle <= ncycle ; cycle += 1 ) {
1864: cyclenlp = &cyclenl[ cycle ];
1865: for ( childp = cyclenlp -> cnext ; childp ; childp = childp -> cnext ) {
1866: if ( childp -> propfraction == 0.0 ) {
1867: /*
1868: * all members have the same propfraction except those
1869: * that were excluded with -E
1870: */
1871: continue;
1872: }
1873: cyclenlp -> time += childp -> time;
1874: }
1875: cyclenlp -> propself = cyclenlp -> propfraction * cyclenlp -> time;
1876: }
1877: }
1878:
1879: /*
1880: * in one top to bottom pass over the topologically sorted namelist
1881: * propagate:
1882: * printflag as the union of parents' printflags
1883: * propfraction as the sum of fractional parents' propfractions
1884: * and while we're here, sum time for functions.
1885: */
1886: doflags()
1887: {
1888: int index;
1889: nltype *childp;
1890: nltype *oldhead;
1891:
1892: oldhead = 0;
1893: for ( index = nname-1 ; index >= 0 ; index -= 1 ) {
1894: childp = topsortnlp[ index ];
1895: /*
1896: * if we haven't done this function or cycle,
1897: * inherit things from parent.
1898: * this way, we are linear in the number of arcs
1899: * since we do all members of a cycle (and the cycle itself)
1900: * as we hit the first member of the cycle.
1901: */
1902: if ( childp -> cyclehead != oldhead ) {
1903: oldhead = childp -> cyclehead;
1904: inheritflags( childp );
1905: }
1906: # ifdef DEBUG
1907: if ( debug & PROPDEBUG ) {
1908: printf( "[doflags] " );
1909: printname( childp );
1910: printf( " inherits printflag %d and propfraction %f\n" ,
1911: childp -> printflag , childp -> propfraction );
1912: }
1913: # endif DEBUG
1914: if ( ! childp -> printflag ) {
1915: /*
1916: * printflag is off
1917: * it gets turned on by
1918: * being on -f list,
1919: * or there not being any -f list and not being on -e list.
1920: */
1921: if ( onlist( flist , childp -> name )
1922: || ( !fflag && !onlist( elist , childp -> name ) ) ) {
1923: childp -> printflag = TRUE;
1924: }
1925: } else {
1926: /*
1927: * this function has printing parents:
1928: * maybe someone wants to shut it up
1929: * by putting it on -e list. (but favor -f over -e)
1930: */
1931: if ( ( !onlist( flist , childp -> name ) )
1932: && onlist( elist , childp -> name ) ) {
1933: childp -> printflag = FALSE;
1934: }
1935: }
1936: if ( childp -> propfraction == 0.0 ) {
1937: /*
1938: * no parents to pass time to.
1939: * collect time from children if
1940: * its on -F list,
1941: * or there isn't any -F list and its not on -E list.
1942: */
1943: if ( onlist( Flist , childp -> name )
1944: || ( !Fflag && !onlist( Elist , childp -> name ) ) ) {
1945: childp -> propfraction = 1.0;
1946: }
1947: } else {
1948: /*
1949: * it has parents to pass time to,
1950: * but maybe someone wants to shut it up
1951: * by puttting it on -E list. (but favor -F over -E)
1952: */
1953: if ( !onlist( Flist , childp -> name )
1954: && onlist( Elist , childp -> name ) ) {
1955: childp -> propfraction = 0.0;
1956: }
1957: }
1958: childp -> propself = childp -> time * childp -> propfraction;
1959: printtime += childp -> propself;
1960: # ifdef DEBUG
1961: if ( debug & PROPDEBUG ) {
1962: printf( "[doflags] " );
1963: printname( childp );
1964: printf( " ends up with printflag %d and propfraction %f\n" ,
1965: childp -> printflag , childp -> propfraction );
1966: printf( "time %f propself %f printtime %f\n" ,
1967: childp -> time , childp -> propself , printtime );
1968: }
1969: # endif DEBUG
1970: }
1971: }
1972:
1973: /*
1974: * check if any parent of this child
1975: * (or outside parents of this cycle)
1976: * have their print flags on and set the
1977: * print flag of the child (cycle) appropriately.
1978: * similarly, deal with propagation fractions from parents.
1979: */
1980: inheritflags( childp )
1981: nltype *childp;
1982: {
1983: nltype *headp;
1984: arctype *arcp;
1985: nltype *parentp;
1986: nltype *memp;
1987:
1988: headp = childp -> cyclehead;
1989: if ( childp == headp ) {
1990: /*
1991: * just a regular child, check its parents
1992: */
1993: childp -> printflag = FALSE;
1994: childp -> propfraction = 0.0;
1995: for (arcp = childp -> parents ; arcp ; arcp = arcp -> arc_parentlist) {
1996: parentp = arcp -> arc_parentp;
1997: if ( childp == parentp ) {
1998: continue;
1999: }
2000: childp -> printflag |= parentp -> printflag;
2001: /*
2002: * if the child was never actually called
2003: * (e.g. this arc is static (and all others are, too))
2004: * no time propagates along this arc.
2005: */
2006: if ( childp -> ncall ) {
2007: childp -> propfraction += parentp -> propfraction
2008: * ( ( (double) arcp -> arc_count )
2009: / ( (double) childp -> ncall ) );
2010: }
2011: }
2012: } else {
2013: /*
2014: * its a member of a cycle, look at all parents from
2015: * outside the cycle
2016: */
2017: headp -> printflag = FALSE;
2018: headp -> propfraction = 0.0;
2019: for ( memp = headp -> cnext ; memp ; memp = memp -> cnext ) {
2020: for (arcp = memp->parents ; arcp ; arcp = arcp->arc_parentlist) {
2021: if ( arcp -> arc_parentp -> cyclehead == headp ) {
2022: continue;
2023: }
2024: parentp = arcp -> arc_parentp;
2025: headp -> printflag |= parentp -> printflag;
2026: /*
2027: * if the cycle was never actually called
2028: * (e.g. this arc is static (and all others are, too))
2029: * no time propagates along this arc.
2030: */
2031: if ( headp -> ncall ) {
2032: headp -> propfraction += parentp -> propfraction
2033: * ( ( (double) arcp -> arc_count )
2034: / ( (double) headp -> ncall ) );
2035: }
2036: }
2037: }
2038: for ( memp = headp ; memp ; memp = memp -> cnext ) {
2039: memp -> printflag = headp -> printflag;
2040: memp -> propfraction = headp -> propfraction;
2041: }
2042: }
2043: }
2044:
2045: if ( childp -> cyclehead != oldhead ) {
2046: oldhead = childp -> cyclehead;
2047: inheritfgprof/printgprof.c 444 22 12 42731 4167372703 7565 /*
2048: * Copyright (c) 1983 Regents of the University of California.
2049: * All rights reserved. The Berkeley software License Agreement
2050: * specifies the terms and conditions for redistribution.
2051: */
2052:
2053: #ifndef lint
2054: static char sccsid[] = "@(#)printgprof.c 5.3 (Berkeley) 1/2/88";
2055: #endif not lint
2056:
2057: #include "gprof.h"
2058:
2059: printprof()
2060: {
2061: register nltype *np;
2062: nltype **sortednlp;
2063: int index, timecmp();
2064:
2065: actime = 0.0;
2066: printf( "\f\n" );
2067: flatprofheader();
2068: /*
2069: * Sort the symbol table in by time
2070: */
2071: sortednlp = (nltype **) calloc( nname , sizeof(nltype *) );
2072: if ( sortednlp == (nltype **) 0 ) {
2073: fprintf( stderr , "[printprof] ran out of memory for time sorting\n" );
2074: }
2075: for ( index = 0 ; index < nname ; index += 1 ) {
2076: sortednlp[ index ] = &nl[ index ];
2077: }
2078: qsort( sortednlp , nname , sizeof(nltype *) , timecmp );
2079: for ( index = 0 ; index < nname ; index += 1 ) {
2080: np = sortednlp[ index ];
2081: flatprofline( np );
2082: }
2083: actime = 0.0;
2084: cfree( sortednlp );
2085: }
2086:
2087: timecmp( npp1 , npp2 )
2088: nltype **npp1, **npp2;
2089: {
2090: double timediff;
2091: long calldiff;
2092:
2093: timediff = (*npp2) -> time - (*npp1) -> time;
2094: if ( timediff > 0.0 )
2095: return 1 ;
2096: if ( timediff < 0.0 )
2097: return -1;
2098: calldiff = (*npp2) -> ncall - (*npp1) -> ncall;
2099: if ( calldiff > 0 )
2100: return 1;
2101: if ( calldiff < 0 )
2102: return -1;
2103: return( strcmp( (*npp1) -> name , (*npp2) -> name ) );
2104: }
2105:
2106: /*
2107: * header for flatprofline
2108: */
2109: flatprofheader()
2110: {
2111:
2112: if ( bflag ) {
2113: printblurb( FLAT_BLURB );
2114: }
2115: printf( "\ngranularity: each sample hit covers %d byte(s)" ,
2116: (long) scale * sizeof(UNIT) );
2117: if ( totime > 0.0 ) {
2118: printf( " for %.2f%% of %.2f seconds\n\n" ,
2119: 100.0/totime , totime / hz );
2120: } else {
2121: printf( " no time accumulated\n\n" );
2122: /*
2123: * this doesn't hurt sinc eall the numerators will be zero.
2124: */
2125: totime = 1.0;
2126: }
2127: printf( "%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s %-8.8s\n" ,
2128: "% " , "cumulative" , "self " , "" , "self " , "total " , "" );
2129: printf( "%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s %-8.8s\n" ,
2130: "time" , "seconds " , "seconds" , "calls" ,
2131: "ms/call" , "ms/call" , "name" );
2132: }
2133:
2134: flatprofline( np )
2135: register nltype *np;
2136: {
2137:
2138: if ( zflag == 0 && np -> ncall == 0 && np -> time == 0 ) {
2139: return;
2140: }
2141: actime += np -> time;
2142: printf( "%5.1f %10.2f %8.2f" ,
2143: 100 * np -> time / totime , actime / hz , np -> time / hz );
2144: if ( np -> ncall != 0 ) {
2145: printf( " %8d %8.2f %8.2f " , np -> ncall ,
2146: 1000 * np -> time / hz / np -> ncall ,
2147: 1000 * ( np -> time + np -> childtime ) / hz / np -> ncall );
2148: } else {
2149: printf( " %8.8s %8.8s %8.8s " , "" , "" , "" );
2150: }
2151: printname( np );
2152: printf( "\n" );
2153: }
2154:
2155: gprofheader()
2156: {
2157:
2158: if ( bflag ) {
2159: printblurb( CALLG_BLURB );
2160: }
2161: printf( "\ngranularity: each sample hit covers %d byte(s)" ,
2162: (long) scale * sizeof(UNIT) );
2163: if ( printtime > 0.0 ) {
2164: printf( " for %.2f%% of %.2f seconds\n\n" ,
2165: 100.0/printtime , printtime / hz );
2166: } else {
2167: printf( " no time propagated\n\n" );
2168: /*
2169: * this doesn't hurt, since all the numerators will be 0.0
2170: */
2171: printtime = 1.0;
2172: }
2173: printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s %-8.8s\n" ,
2174: "" , "" , "" , "" , "called" , "total" , "parents");
2175: printf( "%-6.6s %5.5s %7.7s %11.11s %7.7s+%-7.7s %-8.8s\t%5.5s\n" ,
2176: "index" , "%time" , "self" , "descendents" ,
2177: "called" , "self" , "name" , "index" );
2178: printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s %-8.8s\n" ,
2179: "" , "" , "" , "" , "called" , "total" , "children");
2180: printf( "\n" );
2181: }
2182:
2183: gprofline( np )
2184: register nltype *np;
2185: {
2186: char kirkbuffer[ BUFSIZ ];
2187:
2188: sprintf( kirkbuffer , "[%d]" , np -> index );
2189: printf( "%-6.6s %5.1f %7.2f %11.2f" ,
2190: kirkbuffer ,
2191: 100 * ( np -> propself + np -> propchild ) / printtime ,
2192: np -> propself / hz ,
2193: np -> propchild / hz );
2194: if ( ( np -> ncall + np -> selfcalls ) != 0 ) {
2195: printf( " %7d" , np -> ncall );
2196: if ( np -> selfcalls != 0 ) {
2197: printf( "+%-7d " , np -> selfcalls );
2198: } else {
2199: printf( " %7.7s " , "" );
2200: }
2201: } else {
2202: printf( " %7.7s %7.7s " , "" , "" );
2203: }
2204: printname( np );
2205: printf( "\n" );
2206: }
2207:
2208: printgprof(timesortnlp)
2209: nltype **timesortnlp;
2210: {
2211: int index;
2212: nltype *parentp;
2213:
2214: /*
2215: * Print out the structured profiling list
2216: */
2217: gprofheader();
2218: for ( index = 0 ; index < nname + ncycle ; index ++ ) {
2219: parentp = timesortnlp[ index ];
2220: if ( zflag == 0 &&
2221: parentp -> ncall == 0 &&
2222: parentp -> selfcalls == 0 &&
2223: parentp -> propself == 0 &&
2224: parentp -> propchild == 0 ) {
2225: continue;
2226: }
2227: if ( ! parentp -> printflag ) {
2228: continue;
2229: }
2230: if ( parentp -> name == 0 && parentp -> cycleno != 0 ) {
2231: /*
2232: * cycle header
2233: */
2234: printcycle( parentp );
2235: printmembers( parentp );
2236: } else {
2237: printparents( parentp );
2238: gprofline( parentp );
2239: printchildren( parentp );
2240: }
2241: printf( "\n" );
2242: printf( "-----------------------------------------------\n" );
2243: printf( "\n" );
2244: }
2245: cfree( timesortnlp );
2246: }
2247:
2248: /*
2249: * sort by decreasing propagated time
2250: * if times are equal, but one is a cycle header,
2251: * say that's first (e.g. less, i.e. -1).
2252: * if one's name doesn't have an underscore and the other does,
2253: * say the one is first.
2254: * all else being equal, sort by names.
2255: */
2256: int
2257: totalcmp( npp1 , npp2 )
2258: nltype **npp1;
2259: nltype **npp2;
2260: {
2261: register nltype *np1 = *npp1;
2262: register nltype *np2 = *npp2;
2263: double diff;
2264:
2265: diff = ( np1 -> propself + np1 -> propchild )
2266: - ( np2 -> propself + np2 -> propchild );
2267: if ( diff < 0.0 )
2268: return 1;
2269: if ( diff > 0.0 )
2270: return -1;
2271: if ( np1 -> name == 0 && np1 -> cycleno != 0 )
2272: return -1;
2273: if ( np2 -> name == 0 && np2 -> cycleno != 0 )
2274: return 1;
2275: if ( np1 -> name == 0 )
2276: return -1;
2277: if ( np2 -> name == 0 )
2278: return 1;
2279: if ( *(np1 -> name) != '_' && *(np2 -> name) == '_' )
2280: return -1;
2281: if ( *(np1 -> name) == '_' && *(np2 -> name) != '_' )
2282: return 1;
2283: if ( np1 -> ncall > np2 -> ncall )
2284: return -1;
2285: if ( np1 -> ncall < np2 -> ncall )
2286: return 1;
2287: return strcmp( np1 -> name , np2 -> name );
2288: }
2289:
2290: printparents( childp )
2291: nltype *childp;
2292: {
2293: nltype *parentp;
2294: arctype *arcp;
2295: nltype *cycleheadp;
2296:
2297: if ( childp -> cyclehead != 0 ) {
2298: cycleheadp = childp -> cyclehead;
2299: } else {
2300: cycleheadp = childp;
2301: }
2302: if ( childp -> parents == 0 ) {
2303: printf( "%6.6s %5.5s %7.7s %11.11s %7.7s %7.7s <spontaneous>\n" ,
2304: "" , "" , "" , "" , "" , "" );
2305: return;
2306: }
2307: sortparents( childp );
2308: for ( arcp = childp -> parents ; arcp ; arcp = arcp -> arc_parentlist ) {
2309: parentp = arcp -> arc_parentp;
2310: if ( childp == parentp ||
2311: ( childp->cycleno != 0 && parentp->cycleno == childp->cycleno ) ) {
2312: /*
2313: * selfcall or call among siblings
2314: */
2315: printf( "%6.6s %5.5s %7.7s %11.11s %7d %7.7s " ,
2316: "" , "" , "" , "" ,
2317: arcp -> arc_count , "" );
2318: printname( parentp );
2319: printf( "\n" );
2320: } else {
2321: /*
2322: * regular parent of child
2323: */
2324: printf( "%6.6s %5.5s %7.2f %11.2f %7d/%-7d " ,
2325: "" , "" ,
2326: arcp -> arc_time / hz , arcp -> arc_childtime / hz ,
2327: arcp -> arc_count , cycleheadp -> ncall );
2328: printname( parentp );
2329: printf( "\n" );
2330: }
2331: }
2332: }
2333:
2334: printchildren( parentp )
2335: nltype *parentp;
2336: {
2337: nltype *childp;
2338: arctype *arcp;
2339:
2340: sortchildren( parentp );
2341: arcp = parentp -> children;
2342: for ( arcp = parentp -> children ; arcp ; arcp = arcp -> arc_childlist ) {
2343: childp = arcp -> arc_childp;
2344: if ( childp == parentp ||
2345: ( childp->cycleno != 0 && childp->cycleno == parentp->cycleno ) ) {
2346: /*
2347: * self call or call to sibling
2348: */
2349: printf( "%6.6s %5.5s %7.7s %11.11s %7d %7.7s " ,
2350: "" , "" , "" , "" , arcp -> arc_count , "" );
2351: printname( childp );
2352: printf( "\n" );
2353: } else {
2354: /*
2355: * regular child of parent
2356: */
2357: printf( "%6.6s %5.5s %7.2f %11.2f %7d/%-7d " ,
2358: "" , "" ,
2359: arcp -> arc_time / hz , arcp -> arc_childtime / hz ,
2360: arcp -> arc_count , childp -> cyclehead -> ncall );
2361: printname( childp );
2362: printf( "\n" );
2363: }
2364: }
2365: }
2366:
2367: printname( selfp )
2368: nltype *selfp;
2369: {
2370:
2371: if ( selfp -> name != 0 ) {
2372: printf( "%s" , selfp -> name );
2373: # ifdef DEBUG
2374: if ( debug & DFNDEBUG ) {
2375: printf( "{%d} " , selfp -> toporder );
2376: }
2377: if ( debug & PROPDEBUG ) {
2378: printf( "%5.2f%% " , selfp -> propfraction );
2379: }
2380: # endif DEBUG
2381: }
2382: if ( selfp -> cycleno != 0 ) {
2383: printf( " <cycle %d>" , selfp -> cycleno );
2384: }
2385: if ( selfp -> index != 0 ) {
2386: if ( selfp -> printflag ) {
2387: printf( " [%d]" , selfp -> index );
2388: } else {
2389: printf( " (%d)" , selfp -> index );
2390: }
2391: }
2392: }
2393:
2394: sortchildren( parentp )
2395: nltype *parentp;
2396: {
2397: arctype *arcp;
2398: arctype *detachedp;
2399: arctype sorted;
2400: arctype *prevp;
2401:
2402: /*
2403: * unlink children from parent,
2404: * then insertion sort back on to sorted's children.
2405: * *arcp the arc you have detached and are inserting.
2406: * *detachedp the rest of the arcs to be sorted.
2407: * sorted arc list onto which you insertion sort.
2408: * *prevp arc before the arc you are comparing.
2409: */
2410: sorted.arc_childlist = 0;
2411: for ( (arcp = parentp -> children)&&(detachedp = arcp -> arc_childlist);
2412: arcp ;
2413: (arcp = detachedp)&&(detachedp = detachedp -> arc_childlist)) {
2414: /*
2415: * consider *arcp as disconnected
2416: * insert it into sorted
2417: */
2418: for ( prevp = &sorted ;
2419: prevp -> arc_childlist ;
2420: prevp = prevp -> arc_childlist ) {
2421: if ( arccmp( arcp , prevp -> arc_childlist ) != LESSTHAN ) {
2422: break;
2423: }
2424: }
2425: arcp -> arc_childlist = prevp -> arc_childlist;
2426: prevp -> arc_childlist = arcp;
2427: }
2428: /*
2429: * reattach sorted children to parent
2430: */
2431: parentp -> children = sorted.arc_childlist;
2432: }
2433:
2434: sortparents( childp )
2435: nltype *childp;
2436: {
2437: arctype *arcp;
2438: arctype *detachedp;
2439: arctype sorted;
2440: arctype *prevp;
2441:
2442: /*
2443: * unlink parents from child,
2444: * then insertion sort back on to sorted's parents.
2445: * *arcp the arc you have detached and are inserting.
2446: * *detachedp the rest of the arcs to be sorted.
2447: * sorted arc list onto which you insertion sort.
2448: * *prevp arc before the arc you are comparing.
2449: */
2450: sorted.arc_parentlist = 0;
2451: for ( (arcp = childp -> parents)&&(detachedp = arcp -> arc_parentlist);
2452: arcp ;
2453: (arcp = detachedp)&&(detachedp = detachedp -> arc_parentlist)) {
2454: /*
2455: * consider *arcp as disconnected
2456: * insert it into sorted
2457: */
2458: for ( prevp = &sorted ;
2459: prevp -> arc_parentlist ;
2460: prevp = prevp -> arc_parentlist ) {
2461: if ( arccmp( arcp , prevp -> arc_parentlist ) != GREATERTHAN ) {
2462: break;
2463: }
2464: }
2465: arcp -> arc_parentlist = prevp -> arc_parentlist;
2466: prevp -> arc_parentlist = arcp;
2467: }
2468: /*
2469: * reattach sorted arcs to child
2470: */
2471: childp -> parents = sorted.arc_parentlist;
2472: }
2473:
2474: /*
2475: * print a cycle header
2476: */
2477: printcycle( cyclep )
2478: nltype *cyclep;
2479: {
2480: char kirkbuffer[ BUFSIZ ];
2481:
2482: sprintf( kirkbuffer , "[%d]" , cyclep -> index );
2483: printf( "%-6.6s %5.1f %7.2f %11.2f %7d" ,
2484: kirkbuffer ,
2485: 100 * ( cyclep -> propself + cyclep -> propchild ) / printtime ,
2486: cyclep -> propself / hz ,
2487: cyclep -> propchild / hz ,
2488: cyclep -> ncall );
2489: if ( cyclep -> selfcalls != 0 ) {
2490: printf( "+%-7d" , cyclep -> selfcalls );
2491: } else {
2492: printf( " %7.7s" , "" );
2493: }
2494: printf( " <cycle %d as a whole>\t[%d]\n" ,
2495: cyclep -> cycleno , cyclep -> index );
2496: }
2497:
2498: /*
2499: * print the members of a cycle
2500: */
2501: printmembers( cyclep )
2502: nltype *cyclep;
2503: {
2504: nltype *memberp;
2505:
2506: sortmembers( cyclep );
2507: for ( memberp = cyclep -> cnext ; memberp ; memberp = memberp -> cnext ) {
2508: printf( "%6.6s %5.5s %7.2f %11.2f %7d" ,
2509: "" , "" , memberp -> propself / hz , memberp -> propchild / hz ,
2510: memberp -> ncall );
2511: if ( memberp -> selfcalls != 0 ) {
2512: printf( "+%-7d" , memberp -> selfcalls );
2513: } else {
2514: printf( " %7.7s" , "" );
2515: }
2516: printf( " " );
2517: printname( memberp );
2518: printf( "\n" );
2519: }
2520: }
2521:
2522: /*
2523: * sort members of a cycle
2524: */
2525: sortmembers( cyclep )
2526: nltype *cyclep;
2527: {
2528: nltype *todo;
2529: nltype *doing;
2530: nltype *prev;
2531:
2532: /*
2533: * detach cycle members from cyclehead,
2534: * and insertion sort them back on.
2535: */
2536: todo = cyclep -> cnext;
2537: cyclep -> cnext = 0;
2538: for ( (doing = todo)&&(todo = doing -> cnext);
2539: doing ;
2540: (doing = todo )&&(todo = doing -> cnext )){
2541: for ( prev = cyclep ; prev -> cnext ; prev = prev -> cnext ) {
2542: if ( membercmp( doing , prev -> cnext ) == GREATERTHAN ) {
2543: break;
2544: }
2545: }
2546: doing -> cnext = prev -> cnext;
2547: prev -> cnext = doing;
2548: }
2549: }
2550:
2551: /*
2552: * major sort is on propself + propchild,
2553: * next is sort on ncalls + selfcalls.
2554: */
2555: int
2556: membercmp( this , that )
2557: nltype *this;
2558: nltype *that;
2559: {
2560: double thistime = this -> propself + this -> propchild;
2561: double thattime = that -> propself + that -> propchild;
2562: long thiscalls = this -> ncall + this -> selfcalls;
2563: long thatcalls = that -> ncall + that -> selfcalls;
2564:
2565: if ( thistime > thattime ) {
2566: return GREATERTHAN;
2567: }
2568: if ( thistime < thattime ) {
2569: return LESSTHAN;
2570: }
2571: if ( thiscalls > thatcalls ) {
2572: return GREATERTHAN;
2573: }
2574: if ( thiscalls < thatcalls ) {
2575: return LESSTHAN;
2576: }
2577: return EQUALTO;
2578: }
2579: /*
2580: * compare two arcs to/from the same child/parent.
2581: * - if one arc is a self arc, it's least.
2582: * - if one arc is within a cycle, it's less than.
2583: * - if both arcs are within a cycle, compare arc counts.
2584: * - if neither arc is within a cycle, compare with
2585: * arc_time + arc_childtime as major key
2586: * arc count as minor key
2587: */
2588: int
2589: arccmp( thisp , thatp )
2590: arctype *thisp;
2591: arctype *thatp;
2592: {
2593: nltype *thisparentp = thisp -> arc_parentp;
2594: nltype *thischildp = thisp -> arc_childp;
2595: nltype *thatparentp = thatp -> arc_parentp;
2596: nltype *thatchildp = thatp -> arc_childp;
2597: double thistime;
2598: double thattime;
2599:
2600: # ifdef DEBUG
2601: if ( debug & TIMEDEBUG ) {
2602: printf( "[arccmp] " );
2603: printname( thisparentp );
2604: printf( " calls " );
2605: printname ( thischildp );
2606: printf( " %f + %f %d/%d\n" ,
2607: thisp -> arc_time , thisp -> arc_childtime ,
2608: thisp -> arc_count , thischildp -> ncall );
2609: printf( "[arccmp] " );
2610: printname( thatparentp );
2611: printf( " calls " );
2612: printname( thatchildp );
2613: printf( " %f + %f %d/%d\n" ,
2614: thatp -> arc_time , thatp -> arc_childtime ,
2615: thatp -> arc_count , thatchildp -> ncall );
2616: printf( "\n" );
2617: }
2618: # endif DEBUG
2619: if ( thisparentp == thischildp ) {
2620: /* this is a self call */
2621: return LESSTHAN;
2622: }
2623: if ( thatparentp == thatchildp ) {
2624: /* that is a self call */
2625: return GREATERTHAN;
2626: }
2627: if ( thisparentp -> cycleno != 0 && thischildp -> cycleno != 0 &&
2628: thisparentp -> cycleno == thischildp -> cycleno ) {
2629: /* this is a call within a cycle */
2630: if ( thatparentp -> cycleno != 0 && thatchildp -> cycleno != 0 &&
2631: thatparentp -> cycleno == thatchildp -> cycleno ) {
2632: /* that is a call within the cycle, too */
2633: if ( thisp -> arc_count < thatp -> arc_count ) {
2634: return LESSTHAN;
2635: }
2636: if ( thisp -> arc_count > thatp -> arc_count ) {
2637: return GREATERTHAN;
2638: }
2639: return EQUALTO;
2640: } else {
2641: /* that isn't a call within the cycle */
2642: return LESSTHAN;
2643: }
2644: } else {
2645: /* this isn't a call within a cycle */
2646: if ( thatparentp -> cycleno != 0 && thatchildp -> cycleno != 0 &&
2647: thatparentp -> cycleno == thatchildp -> cycleno ) {
2648: /* that is a call within a cycle */
2649: return GREATERTHAN;
2650: } else {
2651: /* neither is a call within a cycle */
2652: thistime = thisp -> arc_time + thisp -> arc_childtime;
2653: thattime = thatp -> arc_time + thatp -> arc_childtime;
2654: if ( thistime < thattime )
2655: return LESSTHAN;
2656: if ( thistime > thattime )
2657: return GREATERTHAN;
2658: if ( thisp -> arc_count < thatp -> arc_count )
2659: return LESSTHAN;
2660: if ( thisp -> arc_count > thatp -> arc_count )
2661: return GREATERTHAN;
2662: return EQUALTO;
2663: }
2664: }
2665: }
2666:
2667: printblurb( blurbname )
2668: char *blurbname;
2669: {
2670: FILE *blurbfile;
2671: int input;
2672:
2673: blurbfile = fopen( blurbname , "r" );
2674: if ( blurbfile == NULL ) {
2675: perror( blurbname );
2676: return;
2677: }
2678: while ( ( input = getc( blurbfile ) ) != EOF ) {
2679: putchar( input );
2680: }
2681: fclose( blurbfile );
2682: }
2683:
2684: int
2685: namecmp( npp1 , npp2 )
2686: nltype **npp1, **npp2;
2687: {
2688: return( strcmp( (*npp1) -> name , (*npp2) -> name ) );
2689: }
2690:
2691: printindex()
2692: {
2693: nltype **namesortnlp;
2694: register nltype *nlp;
2695: int index, nnames, todo, i, j;
2696: char peterbuffer[ BUFSIZ ];
2697:
2698: /*
2699: * Now, sort regular function name alphbetically
2700: * to create an index.
2701: */
2702: namesortnlp = (nltype **) calloc( nname + ncycle , sizeof(nltype *) );
2703: if ( namesortnlp == (nltype **) 0 ) {
2704: fprintf( stderr , "%s: ran out of memory for sorting\n" , whoami );
2705: }
2706: for ( index = 0 , nnames = 0 ; index < nname ; index++ ) {
2707: if ( zflag == 0 && nl[index].ncall == 0 && nl[index].time == 0 )
2708: continue;
2709: namesortnlp[nnames++] = &nl[index];
2710: }
2711: qsort( namesortnlp , nnames , sizeof(nltype *) , namecmp );
2712: for ( index = 1 , todo = nnames ; index <= ncycle ; index++ ) {
2713: namesortnlp[todo++] = &cyclenl[index];
2714: }
2715: printf( "\f\nIndex by function name\n\n" );
2716: index = ( todo + 2 ) / 3;
2717: for ( i = 0; i < index ; i++ ) {
2718: for ( j = i; j < todo ; j += index ) {
2719: nlp = namesortnlp[ j ];
2720: if ( nlp -> printflag ) {
2721: sprintf( peterbuffer , "[%d]" , nlp -> index );
2722: } else {
2723: sprintf( peterbuffer , "(%d)" , nlp -> index );
2724: }
2725: if ( j < nnames ) {
2726: printf( "%6.6s %-19.19s" , peterbuffer , nlp -> name );
2727: } else {
2728: printf( "%6.6s " , peterbuffer );
2729: sprintf( peterbuffer , "<cycle %d>" , nlp -> cycleno );
2730: printf( "%-19.19s" , peterbuffer );
2731: }
2732: }
2733: printf( "\n" );
2734: }
2735: cfree( namesortnlp );
2736: }
2737: thisp -> arc_parentp;
2738: nltype *thisgprof/hertz.c 444 22 12 1405 3500670604 6467 /*
2739: * Copyright (c) 1983 Regents of the University of California.
2740: * All rights reserved. The Berkeley software License Agreement
2741: * specifies the terms and conditions for redistribution.
2742: */
2743:
2744: #ifndef lint
2745: static char sccsid[] = "@(#)hertz.c 5.1 (Berkeley) 6/4/85";
2746: #endif not lint
2747:
2748: #include <sys/time.h>
2749:
2750: /*
2751: * discover the tick frequency of the machine
2752: * if something goes wrong, we return 0, an impossible hertz.
2753: */
2754: #define HZ_WRONG 0
2755:
2756: hertz()
2757: {
2758: struct itimerval tim;
2759:
2760: tim.it_interval.tv_sec = 0;
2761: tim.it_interval.tv_usec = 1;
2762: tim.it_value.tv_sec = 0;
2763: tim.it_value.tv_usec = 0;
2764: setitimer(ITIMER_REAL, &tim, 0);
2765: setitimer(ITIMER_REAL, 0, &tim);
2766: if (tim.it_interval.tv_usec < 2)
2767: return(HZ_WRONG);
2768: return (1000000 / tim.it_interval.tv_usec);
2769: }
2770: gprof/lookup.c 444 22 12 3642 3500670643 6654 /*
2771: * Copyright (c) 1983 Regents of the University of California.
2772: * All rights reserved. The Berkeley software License Agreement
2773: * specifies the terms and conditions for redistribution.
2774: */
2775:
2776: #ifndef lint
2777: static char sccsid[] = "@(#)lookup.c 5.1 (Berkeley) 6/4/85";
2778: #endif not lint
2779:
2780: #include "gprof.h"
2781:
2782: /*
2783: * look up an address in a sorted-by-address namelist
2784: * this deals with misses by mapping them to the next lower
2785: * entry point.
2786: */
2787: nltype *
2788: nllookup( address )
2789: unsigned long address;
2790: {
2791: register long low;
2792: register long middle;
2793: register long high;
2794: # ifdef DEBUG
2795: register int probes;
2796:
2797: probes = 0;
2798: # endif DEBUG
2799: for ( low = 0 , high = nname - 1 ; low != high ; ) {
2800: # ifdef DEBUG
2801: probes += 1;
2802: # endif DEBUG
2803: middle = ( high + low ) >> 1;
2804: if ( nl[ middle ].value <= address && nl[ middle+1 ].value > address ) {
2805: # ifdef DEBUG
2806: if ( debug & LOOKUPDEBUG ) {
2807: printf( "[nllookup] %d (%d) probes\n" , probes , nname-1 );
2808: }
2809: # endif DEBUG
2810: return &nl[ middle ];
2811: }
2812: if ( nl[ middle ].value > address ) {
2813: high = middle;
2814: } else {
2815: low = middle + 1;
2816: }
2817: }
2818: fprintf( stderr , "[nllookup] binary search fails???\n" );
2819: return 0;
2820: }
2821:
2822: arctype *
2823: arclookup( parentp , childp )
2824: nltype *parentp;
2825: nltype *childp;
2826: {
2827: arctype *arcp;
2828:
2829: if ( parentp == 0 || childp == 0 ) {
2830: fprintf( "[arclookup] parentp == 0 || childp == 0\n" );
2831: return 0;
2832: }
2833: # ifdef DEBUG
2834: if ( debug & LOOKUPDEBUG ) {
2835: printf( "[arclookup] parent %s child %s\n" ,
2836: parentp -> name , childp -> name );
2837: }
2838: # endif DEBUG
2839: for ( arcp = parentp -> children ; arcp ; arcp = arcp -> arc_childlist ) {
2840: # ifdef DEBUG
2841: if ( debug & LOOKUPDEBUG ) {
2842: printf( "[arclookup]\t arc_parent %s arc_child %s\n" ,
2843: arcp -> arc_parentp -> name ,
2844: arcp -> arc_childp -> name );
2845: }
2846: # endif DEBUG
2847: if ( arcp -> arc_childp == childp ) {
2848: return arcp;
2849: }
2850: }
2851: return 0;
2852: }
2853:
2854: }
2855: printf( "\n" );
2856: }
2857: cfree( namesortnlp );
2858: }
2859: thisp -> arc_parentp;
2860: nltype *thisgprof/tahoe.c 444 22 12 16405 3610154261 6457 #ifndef lint
2861: static char *sccsid = "@(#)tahoe.c 1.2 (Berkeley) 1/7/86";
2862: #endif not lint
2863:
2864: #include "gprof.h"
2865:
2866: /*
2867: * a namelist entry to be the child of indirect callf
2868: */
2869: nltype indirectchild = {
2870: "(*)" , /* the name */
2871: (unsigned long) 0 , /* the pc entry point */
2872: (unsigned long) 0 , /* entry point aligned to histogram */
2873: (double) 0.0 , /* ticks in this routine */
2874: (double) 0.0 , /* cumulative ticks in children */
2875: (long) 0 , /* how many times called */
2876: (long) 0 , /* how many calls to self */
2877: (double) 1.0 , /* propagation fraction */
2878: (double) 0.0 , /* self propagation time */
2879: (double) 0.0 , /* child propagation time */
2880: (bool) 0 , /* print flag */
2881: (int) 0 , /* index in the graph list */
2882: (int) 0 , /* graph call chain top-sort order */
2883: (int) 0 , /* internal number of cycle on */
2884: (struct nl *) &indirectchild , /* pointer to head of cycle */
2885: (struct nl *) 0 , /* pointer to next member of cycle */
2886: (arctype *) 0 , /* list of caller arcs */
2887: (arctype *) 0 /* list of callee arcs */
2888: };
2889:
2890: operandenum
2891: operandmode( modep )
2892: unsigned char *modep;
2893: {
2894: long usesreg = ((long)*modep) & 0xf;
2895:
2896: switch ( ((long)*modep) >> 4 ) {
2897: case 0:
2898: case 1:
2899: case 2:
2900: case 3:
2901: return literal;
2902: case 4:
2903: return indexed;
2904: case 5:
2905: return reg;
2906: case 6:
2907: return regdef;
2908: case 7:
2909: return autodec;
2910: case 8:
2911: return ( usesreg != 0xe ? autoinc : immediate );
2912: case 9:
2913: return ( usesreg != PC ? autoincdef : absolute );
2914: case 10:
2915: return ( usesreg != PC ? bytedisp : byterel );
2916: case 11:
2917: return ( usesreg != PC ? bytedispdef : bytereldef );
2918: case 12:
2919: return ( usesreg != PC ? worddisp : wordrel );
2920: case 13:
2921: return ( usesreg != PC ? worddispdef : wordreldef );
2922: case 14:
2923: return ( usesreg != PC ? longdisp : longrel );
2924: case 15:
2925: return ( usesreg != PC ? longdispdef : longreldef );
2926: }
2927: /* NOTREACHED */
2928: }
2929:
2930: char *
2931: operandname( mode )
2932: operandenum mode;
2933: {
2934:
2935: switch ( mode ) {
2936: case literal:
2937: return "literal";
2938: case indexed:
2939: return "indexed";
2940: case reg:
2941: return "register";
2942: case regdef:
2943: return "register deferred";
2944: case autodec:
2945: return "autodecrement";
2946: case autoinc:
2947: return "autoincrement";
2948: case autoincdef:
2949: return "autoincrement deferred";
2950: case bytedisp:
2951: return "byte displacement";
2952: case bytedispdef:
2953: return "byte displacement deferred";
2954: case byterel:
2955: return "byte relative";
2956: case bytereldef:
2957: return "byte relative deferred";
2958: case worddisp:
2959: return "word displacement";
2960: case worddispdef:
2961: return "word displacement deferred";
2962: case wordrel:
2963: return "word relative";
2964: case wordreldef:
2965: return "word relative deferred";
2966: case immediate:
2967: return "immediate";
2968: case absolute:
2969: return "absolute";
2970: case longdisp:
2971: return "long displacement";
2972: case longdispdef:
2973: return "long displacement deferred";
2974: case longrel:
2975: return "long relative";
2976: case longreldef:
2977: return "long relative deferred";
2978: }
2979: /* NOTREACHED */
2980: }
2981:
2982: long
2983: operandlength( modep )
2984: unsigned char *modep;
2985: {
2986:
2987: switch ( operandmode( modep ) ) {
2988: case literal:
2989: case reg:
2990: case regdef:
2991: case autodec:
2992: case autoinc:
2993: case autoincdef:
2994: return 1;
2995: case bytedisp:
2996: case bytedispdef:
2997: case byterel:
2998: case bytereldef:
2999: return 2;
3000: case worddisp:
3001: case worddispdef:
3002: case wordrel:
3003: case wordreldef:
3004: return 3;
3005: case immediate:
3006: case absolute:
3007: case longdisp:
3008: case longdispdef:
3009: case longrel:
3010: case longreldef:
3011: return 5;
3012: case indexed:
3013: return 1+operandlength( modep + 1 );
3014: }
3015: /* NOTREACHED */
3016: }
3017:
3018: unsigned long
3019: reladdr( modep )
3020: char *modep;
3021: {
3022: operandenum mode = operandmode( modep );
3023: char *cp;
3024: short *sp;
3025: long *lp;
3026: int i;
3027: long value = 0;
3028:
3029: cp = modep;
3030: cp += 1; /* skip over the mode */
3031: switch ( mode ) {
3032: default:
3033: fprintf( stderr , "[reladdr] not relative address\n" );
3034: return (unsigned long) modep;
3035: case byterel:
3036: return (unsigned long) ( cp + sizeof *cp + *cp );
3037: case wordrel:
3038: for (i = 0; i < sizeof *sp; i++)
3039: value = (value << 8) + (cp[i] & 0xff);
3040: return (unsigned long) ( cp + sizeof *sp + value );
3041: case longrel:
3042: for (i = 0; i < sizeof *lp; i++)
3043: value = (value << 8) + (cp[i] & 0xff);
3044: return (unsigned long) ( cp + sizeof *lp + value );
3045: }
3046: }
3047:
3048: findcall( parentp , p_lowpc , p_highpc )
3049: nltype *parentp;
3050: unsigned long p_lowpc;
3051: unsigned long p_highpc;
3052: {
3053: unsigned char *instructp;
3054: long length;
3055: nltype *childp;
3056: operandenum mode;
3057: operandenum firstmode;
3058: unsigned long destpc;
3059:
3060: if ( textspace == 0 ) {
3061: return;
3062: }
3063: if ( p_lowpc < s_lowpc ) {
3064: p_lowpc = s_lowpc;
3065: }
3066: if ( p_highpc > s_highpc ) {
3067: p_highpc = s_highpc;
3068: }
3069: # ifdef DEBUG
3070: if ( debug & CALLDEBUG ) {
3071: printf( "[findcall] %s: 0x%x to 0x%x\n" ,
3072: parentp -> name , p_lowpc , p_highpc );
3073: }
3074: # endif DEBUG
3075: for ( instructp = textspace + p_lowpc ;
3076: instructp < textspace + p_highpc ;
3077: instructp += length ) {
3078: length = 1;
3079: if ( *instructp == CALLF ) {
3080: /*
3081: * maybe a callf, better check it out.
3082: * skip the count of the number of arguments.
3083: */
3084: # ifdef DEBUG
3085: if ( debug & CALLDEBUG ) {
3086: printf( "[findcall]\t0x%x:callf" , instructp - textspace );
3087: }
3088: # endif DEBUG
3089: firstmode = operandmode( instructp+length );
3090: switch ( firstmode ) {
3091: case literal:
3092: case immediate:
3093: break;
3094: default:
3095: goto botched;
3096: }
3097: length += operandlength( instructp+length );
3098: mode = operandmode( instructp + length );
3099: # ifdef DEBUG
3100: if ( debug & CALLDEBUG ) {
3101: printf( "\tfirst operand is %s", operandname( firstmode ) );
3102: printf( "\tsecond operand is %s\n" , operandname( mode ) );
3103: }
3104: # endif DEBUG
3105: switch ( mode ) {
3106: case regdef:
3107: case bytedispdef:
3108: case worddispdef:
3109: case longdispdef:
3110: case bytereldef:
3111: case wordreldef:
3112: case longreldef:
3113: /*
3114: * indirect call: call through pointer
3115: * either *d(r) as a parameter or local
3116: * (r) as a return value
3117: * *f as a global pointer
3118: * [are there others that we miss?,
3119: * e.g. arrays of pointers to functions???]
3120: */
3121: addarc( parentp , &indirectchild , (long) 0 );
3122: length += operandlength( instructp + length );
3123: continue;
3124: case byterel:
3125: case wordrel:
3126: case longrel:
3127: /*
3128: * regular pc relative addressing
3129: * check that this is the address of
3130: * a function.
3131: */
3132: destpc = reladdr( instructp+length )
3133: - (unsigned long) textspace;
3134: if ( destpc >= s_lowpc && destpc <= s_highpc ) {
3135: childp = nllookup( destpc );
3136: # ifdef DEBUG
3137: if ( debug & CALLDEBUG ) {
3138: printf( "[findcall]\tdestpc 0x%x" , destpc );
3139: printf( " childp->name %s" , childp -> name );
3140: printf( " childp->value 0x%x\n" ,
3141: childp -> value );
3142: }
3143: # endif DEBUG
3144: if ( childp -> value == destpc ) {
3145: /*
3146: * a hit
3147: */
3148: addarc( parentp , childp , (long) 0 );
3149: length += operandlength( instructp + length );
3150: continue;
3151: }
3152: goto botched;
3153: }
3154: /*
3155: * else:
3156: * it looked like a callf,
3157: * but it wasn't to anywhere.
3158: */
3159: goto botched;
3160: default:
3161: botched:
3162: /*
3163: * something funny going on.
3164: */
3165: # ifdef DEBUG
3166: if ( debug & CALLDEBUG ) {
3167: printf( "[findcall]\tbut it's a botch\n" );
3168: }
3169: # endif DEBUG
3170: length = 1;
3171: continue;
3172: }
3173: }
3174: }
3175: }
3176: rddisp:
3177: case worddispdef:
3178: case wordrel:
3179: case wordreldef:
3180: return 3;
3181: case immediate:
3182: case absolute:
3183: case longdisp:
3184: case longdispdef:
3185: case longrel:
3186: case longreldef:
3187: return 5;
3188: case indexed:
3189: return 1+operandlength( modep + 1 );
3190: gprof/gprof.flat 444 22 12 2050 3335276057 7163
3191:
3192:
3193: flat profile:
3194:
3195: % the percentage of the total running time of the
3196: time program used by this function.
3197:
3198: cumulative a running sum of the number of seconds accounted
3199: seconds for by this function and those listed above it.
3200:
3201: self the number of seconds accounted for by this
3202: seconds function alone. This is the major sort for this
3203: listing.
3204:
3205: calls the number of times this function was invoked, if
3206: this function is profiled, else blank.
3207:
3208: self the average number of milliseconds spent in this
3209: ms/call function per call, if this function is profiled,
3210: else blank.
3211:
3212: total the average number of milliseconds spent in this
3213: ms/call function and its descendents per call, if this
3214: function is profiled, else blank.
3215:
3216: name the name of the function. This is the minor sort
3217: for this listing. The index shows the location of
3218: the function in the gprof listing. If the index is
3219: in parenthesis it shows where it would appear in
3220: the gprof listing if it were to be printed.
3221:
3222: all]\tdestpc 0x%x" , destpc );
3223: printf( " childp->name %s" , childp -> name );
3224: printf( " childp->value 0x%x\n" ,
3225: childp -> value );
3226: }
3227: # endif DEBUG
3228: if ( childp -> value == destpc ) {
3229: /*
3230: * a hit
3231: */
3232: addarc( parentp , childp , (long) 0 );
3233: length += operandlength( instructp + length );
3234: continue;
3235: }
3236: goto botched;
3237: }
3238: /*
3239: * else:
3240: * it looked like a callf,
3241: * but it wasn't to anywhere.
3242: */
3243: gprof/vax.h 444 22 12 1711 3500671075 6141 /*
3244: * Copyright (c) 1983 Regents of the University of California.
3245: * All rights reserved. The Berkeley software License Agreement
3246: * specifies the terms and conditions for redistribution.
3247: *
3248: * @(#)vax.h 5.1 (Berkeley) 6/4/85
3249: */
3250:
3251: /*
3252: * opcode of the `calls' instruction
3253: */
3254: #define CALLS 0xfb
3255:
3256: /*
3257: * offset (in bytes) of the code from the entry address of a routine.
3258: * (see asgnsamples for use and explanation.)
3259: */
3260: #define OFFSET_OF_CODE 2
3261: #define UNITS_TO_CODE (OFFSET_OF_CODE / sizeof(UNIT))
3262:
3263: /*
3264: * register for pc relative addressing
3265: */
3266: #define PC 0xf
3267:
3268: enum opermodes {
3269: literal, indexed, reg, regdef, autodec, autoinc, autoincdef,
3270: bytedisp, bytedispdef, worddisp, worddispdef, longdisp, longdispdef,
3271: immediate, absolute, byterel, bytereldef, wordrel, wordreldef,
3272: longrel, longreldef
3273: };
3274: typedef enum opermodes operandenum;
3275:
3276: struct modebyte {
3277: unsigned int regfield:4;
3278: unsigned int modefield:4;
3279: };
3280:
3281: gprof/gprof.callg 444 22 12 6303 3002376446 7316
3282:
3283:
3284: call graph profile:
3285: The sum of self and descendents is the major sort
3286: for this listing.
3287:
3288: function entries:
3289:
3290: index the index of the function in the call graph
3291: listing, as an aid to locating it (see below).
3292:
3293: %time the percentage of the total time of the program
3294: accounted for by this function and its
3295: descendents.
3296:
3297: self the number of seconds spent in this function
3298: itself.
3299:
3300: descendents
3301: the number of seconds spent in the descendents of
3302: this function on behalf of this function.
3303:
3304: called the number of times this function is called (other
3305: than recursive calls).
3306:
3307: self the number of times this function calls itself
3308: recursively.
3309:
3310: name the name of the function, with an indication of
3311: its membership in a cycle, if any.
3312:
3313: index the index of the function in the call graph
3314: listing, as an aid to locating it.
3315:
3316:
3317:
3318: parent listings:
3319:
3320: self* the number of seconds of this function's self time
3321: which is due to calls from this parent.
3322:
3323: descendents*
3324: the number of seconds of this function's
3325: descendent time which is due to calls from this
3326: parent.
3327:
3328: called** the number of times this function is called by
3329: this parent. This is the numerator of the
3330: fraction which divides up the function's time to
3331: its parents.
3332:
3333: total* the number of times this function was called by
3334: all of its parents. This is the denominator of
3335: the propagation fraction.
3336:
3337: parents the name of this parent, with an indication of the
3338: parent's membership in a cycle, if any.
3339:
3340: index the index of this parent in the call graph
3341: listing, as an aid in locating it.
3342:
3343:
3344:
3345: children listings:
3346:
3347: self* the number of seconds of this child's self time
3348: which is due to being called by this function.
3349:
3350: descendent*
3351: the number of seconds of this child's descendent's
3352: time which is due to being called by this
3353: function.
3354:
3355: called** the number of times this child is called by this
3356: function. This is the numerator of the
3357: propagation fraction for this child.
3358:
3359: total* the number of times this child is called by all
3360: functions. This is the denominator of the
3361: propagation fraction.
3362:
3363: children the name of this child, and an indication of its
3364: membership in a cycle, if any.
3365:
3366: index the index of this child in the call graph listing,
3367: as an aid to locating it.
3368:
3369:
3370:
3371: * these fields are omitted for parents (or
3372: children) in the same cycle as the function. If
3373: the function (or child) is a member of a cycle,
3374: the propagated times and propagation denominator
3375: represent the self time and descendent time of the
3376: cycle as a whole.
3377:
3378: ** static-only parents and children are indicated
3379: by a call count of 0.
3380:
3381:
3382:
3383: cycle listings:
3384: the cycle as a whole is listed with the same
3385: fields as a function entry. Below it are listed
3386: the members of the cycle, and their contributions
3387: to the time and call counts of the cycle.
3388:
3389: om this
3390: parent.
3391:
3392: called** the number of times this function is called by
3393: this parent. This is the numerator of the
3394: fraction which divides up the function's time to
3395: its parents.
3396:
3397: total* the number of times this function was called by
3398: all of its parents. This is gprof/tahoe.h 444 22 12 1253 3610153710 6435 /* tahoe.h 1.1 86/01/07 */
3399:
3400: /*
3401: * opcode of the `callf' instruction
3402: */
3403: #define CALLF 0xfe
3404:
3405: /*
3406: * offset (in bytes) of the code from the entry address of a routine.
3407: * (see asgnsamples for use and explanation.)
3408: */
3409: #define OFFSET_OF_CODE 2
3410: #define UNITS_TO_CODE (OFFSET_OF_CODE / sizeof(UNIT))
3411:
3412: /*
3413: * register for pc relative addressing
3414: */
3415: #define PC 0xf
3416:
3417: enum opermodes {
3418: literal, indexed, reg, regdef, autodec, autoinc, autoincdef,
3419: bytedisp, bytedispdef, worddisp, worddispdef, longdisp, longdispdef,
3420: immediate, absolute, byterel, bytereldef, wordrel, wordreldef,
3421: longrel, longreldef
3422: };
3423: typedef enum opermodes operandenum;
3424: gprof/vax.c 444 22 12 16774 3610154261 6166 /*
3425: * Copyright (c) 1983 Regents of the University of California.
3426: * All rights reserved. The Berkeley software License Agreement
3427: * specifies the terms and conditions for redistribution.
3428: */
3429:
3430: #ifndef lint
3431: static char sccsid[] = "@(#)vax.c 5.3 (Berkeley) 1/7/86";
3432: #endif not lint
3433:
3434: #include "gprof.h"
3435:
3436: /*
3437: * a namelist entry to be the child of indirect calls
3438: */
3439: nltype indirectchild = {
3440: "(*)" , /* the name */
3441: (unsigned long) 0 , /* the pc entry point */
3442: (unsigned long) 0 , /* entry point aligned to histogram */
3443: (double) 0.0 , /* ticks in this routine */
3444: (double) 0.0 , /* cumulative ticks in children */
3445: (long) 0 , /* how many times called */
3446: (long) 0 , /* how many calls to self */
3447: (double) 1.0 , /* propagation fraction */
3448: (double) 0.0 , /* self propagation time */
3449: (double) 0.0 , /* child propagation time */
3450: (bool) 0 , /* print flag */
3451: (int) 0 , /* index in the graph list */
3452: (int) 0 , /* graph call chain top-sort order */
3453: (int) 0 , /* internal number of cycle on */
3454: (struct nl *) &indirectchild , /* pointer to head of cycle */
3455: (struct nl *) 0 , /* pointer to next member of cycle */
3456: (arctype *) 0 , /* list of caller arcs */
3457: (arctype *) 0 /* list of callee arcs */
3458: };
3459:
3460: operandenum
3461: operandmode( modep )
3462: struct modebyte *modep;
3463: {
3464: long usesreg = modep -> regfield;
3465:
3466: switch ( modep -> modefield ) {
3467: case 0:
3468: case 1:
3469: case 2:
3470: case 3:
3471: return literal;
3472: case 4:
3473: return indexed;
3474: case 5:
3475: return reg;
3476: case 6:
3477: return regdef;
3478: case 7:
3479: return autodec;
3480: case 8:
3481: return ( usesreg != PC ? autoinc : immediate );
3482: case 9:
3483: return ( usesreg != PC ? autoincdef : absolute );
3484: case 10:
3485: return ( usesreg != PC ? bytedisp : byterel );
3486: case 11:
3487: return ( usesreg != PC ? bytedispdef : bytereldef );
3488: case 12:
3489: return ( usesreg != PC ? worddisp : wordrel );
3490: case 13:
3491: return ( usesreg != PC ? worddispdef : wordreldef );
3492: case 14:
3493: return ( usesreg != PC ? longdisp : longrel );
3494: case 15:
3495: return ( usesreg != PC ? longdispdef : longreldef );
3496: }
3497: /* NOTREACHED */
3498: }
3499:
3500: char *
3501: operandname( mode )
3502: operandenum mode;
3503: {
3504:
3505: switch ( mode ) {
3506: case literal:
3507: return "literal";
3508: case indexed:
3509: return "indexed";
3510: case reg:
3511: return "register";
3512: case regdef:
3513: return "register deferred";
3514: case autodec:
3515: return "autodecrement";
3516: case autoinc:
3517: return "autoincrement";
3518: case autoincdef:
3519: return "autoincrement deferred";
3520: case bytedisp:
3521: return "byte displacement";
3522: case bytedispdef:
3523: return "byte displacement deferred";
3524: case byterel:
3525: return "byte relative";
3526: case bytereldef:
3527: return "byte relative deferred";
3528: case worddisp:
3529: return "word displacement";
3530: case worddispdef:
3531: return "word displacement deferred";
3532: case wordrel:
3533: return "word relative";
3534: case wordreldef:
3535: return "word relative deferred";
3536: case immediate:
3537: return "immediate";
3538: case absolute:
3539: return "absolute";
3540: case longdisp:
3541: return "long displacement";
3542: case longdispdef:
3543: return "long displacement deferred";
3544: case longrel:
3545: return "long relative";
3546: case longreldef:
3547: return "long relative deferred";
3548: }
3549: /* NOTREACHED */
3550: }
3551:
3552: long
3553: operandlength( modep )
3554: struct modebyte *modep;
3555: {
3556:
3557: switch ( operandmode( modep ) ) {
3558: case literal:
3559: case reg:
3560: case regdef:
3561: case autodec:
3562: case autoinc:
3563: case autoincdef:
3564: return 1;
3565: case bytedisp:
3566: case bytedispdef:
3567: case byterel:
3568: case bytereldef:
3569: return 2;
3570: case worddisp:
3571: case worddispdef:
3572: case wordrel:
3573: case wordreldef:
3574: return 3;
3575: case immediate:
3576: case absolute:
3577: case longdisp:
3578: case longdispdef:
3579: case longrel:
3580: case longreldef:
3581: return 5;
3582: case indexed:
3583: return 1+operandlength( (struct modebyte *) ((char *) modep) + 1 );
3584: }
3585: /* NOTREACHED */
3586: }
3587:
3588: unsigned long
3589: reladdr( modep )
3590: struct modebyte *modep;
3591: {
3592: operandenum mode = operandmode( modep );
3593: char *cp;
3594: short *sp;
3595: long *lp;
3596:
3597: cp = (char *) modep;
3598: cp += 1; /* skip over the mode */
3599: switch ( mode ) {
3600: default:
3601: fprintf( stderr , "[reladdr] not relative address\n" );
3602: return (unsigned long) modep;
3603: case byterel:
3604: return (unsigned long) ( cp + sizeof *cp + *cp );
3605: case wordrel:
3606: sp = (short *) cp;
3607: return (unsigned long) ( cp + sizeof *sp + *sp );
3608: case longrel:
3609: lp = (long *) cp;
3610: return (unsigned long) ( cp + sizeof *lp + *lp );
3611: }
3612: }
3613:
3614: findcall( parentp , p_lowpc , p_highpc )
3615: nltype *parentp;
3616: unsigned long p_lowpc;
3617: unsigned long p_highpc;
3618: {
3619: unsigned char *instructp;
3620: long length;
3621: nltype *childp;
3622: operandenum mode;
3623: operandenum firstmode;
3624: unsigned long destpc;
3625:
3626: if ( textspace == 0 ) {
3627: return;
3628: }
3629: if ( p_lowpc < s_lowpc ) {
3630: p_lowpc = s_lowpc;
3631: }
3632: if ( p_highpc > s_highpc ) {
3633: p_highpc = s_highpc;
3634: }
3635: # ifdef DEBUG
3636: if ( debug & CALLDEBUG ) {
3637: printf( "[findcall] %s: 0x%x to 0x%x\n" ,
3638: parentp -> name , p_lowpc , p_highpc );
3639: }
3640: # endif DEBUG
3641: for ( instructp = textspace + p_lowpc ;
3642: instructp < textspace + p_highpc ;
3643: instructp += length ) {
3644: length = 1;
3645: if ( *instructp == CALLS ) {
3646: /*
3647: * maybe a calls, better check it out.
3648: * skip the count of the number of arguments.
3649: */
3650: # ifdef DEBUG
3651: if ( debug & CALLDEBUG ) {
3652: printf( "[findcall]\t0x%x:calls" , instructp - textspace );
3653: }
3654: # endif DEBUG
3655: firstmode = operandmode( (struct modebyte *) (instructp+length) );
3656: switch ( firstmode ) {
3657: case literal:
3658: case immediate:
3659: break;
3660: default:
3661: goto botched;
3662: }
3663: length += operandlength( (struct modebyte *) (instructp+length) );
3664: mode = operandmode( (struct modebyte *) ( instructp + length ) );
3665: # ifdef DEBUG
3666: if ( debug & CALLDEBUG ) {
3667: printf( "\tfirst operand is %s", operandname( firstmode ) );
3668: printf( "\tsecond operand is %s\n" , operandname( mode ) );
3669: }
3670: # endif DEBUG
3671: switch ( mode ) {
3672: case regdef:
3673: case bytedispdef:
3674: case worddispdef:
3675: case longdispdef:
3676: case bytereldef:
3677: case wordreldef:
3678: case longreldef:
3679: /*
3680: * indirect call: call through pointer
3681: * either *d(r) as a parameter or local
3682: * (r) as a return value
3683: * *f as a global pointer
3684: * [are there others that we miss?,
3685: * e.g. arrays of pointers to functions???]
3686: */
3687: addarc( parentp , &indirectchild , (long) 0 );
3688: length += operandlength(
3689: (struct modebyte *) ( instructp + length ) );
3690: continue;
3691: case byterel:
3692: case wordrel:
3693: case longrel:
3694: /*
3695: * regular pc relative addressing
3696: * check that this is the address of
3697: * a function.
3698: */
3699: destpc = reladdr( (struct modebyte *) (instructp+length) )
3700: - (unsigned long) textspace;
3701: if ( destpc >= s_lowpc && destpc <= s_highpc ) {
3702: childp = nllookup( destpc );
3703: # ifdef DEBUG
3704: if ( debug & CALLDEBUG ) {
3705: printf( "[findcall]\tdestpc 0x%x" , destpc );
3706: printf( " childp->name %s" , childp -> name );
3707: printf( " childp->value 0x%x\n" ,
3708: childp -> value );
3709: }
3710: # endif DEBUG
3711: if ( childp -> value == destpc ) {
3712: /*
3713: * a hit
3714: */
3715: addarc( parentp , childp , (long) 0 );
3716: length += operandlength( (struct modebyte *)
3717: ( instructp + length ) );
3718: continue;
3719: }
3720: goto botched;
3721: }
3722: /*
3723: * else:
3724: * it looked like a calls,
3725: * but it wasn't to anywhere.
3726: */
3727: goto botched;
3728: default:
3729: botched:
3730: /*
3731: * something funny going on.
3732: */
3733: # ifdef DEBUG
3734: if ( debug & CALLDEBUG ) {
3735: printf( "[findcall]\tbut it's a botch\n" );
3736: }
3737: # endif DEBUG
3738: length = 1;
3739: continue;
3740: }
3741: }
3742: }
3743: }
3744: def:gprof/hp300.h 444 22 12 465 4230222453 6153 /* hp300.h 1.1 88/04/08 */
3745:
3746: /*
3747: * offset (in bytes) of the code from the entry address of a routine.
3748: * (see asgnsamples for use and explanation.)
3749: */
3750: #define OFFSET_OF_CODE 0
3751: #define UNITS_TO_CODE (OFFSET_OF_CODE / sizeof(UNIT))
3752:
3753: enum opermodes { dummy };
3754: typedef enum opermodes operandenum;
3755: �D hp300.h r3 RCS �E makefile �F hp300.c �G � gcrt0.h ä gprof.o å arcs.o æ dfn.o ç lookup.o è hp300.o é hertz.o ê printgprof.o gprof/RCS/ 775 14 12 0 4436154436 5547 gprof/RCS/Makefile,v 444 14 12 12541 4341434416 7547 head 1.3;
3756: access ;
3757: symbols ;
3758: locks ; strict;
3759: comment @# @;
3760:
3761:
3762: 1.3
3763: date 88.04.14.00.19.51; author lepreau; state Exp;
3764: branches ;
3765: next 1.2;
3766:
3767: 1.2
3768: date 88.04.11.21.50.07; author donn; state Exp;
3769: branches ;
3770: next 1.1;
3771:
3772: 1.1
3773: date 88.04.08.16.53.49; author donn; state Rel;
3774: branches 1.1.1.1;
3775: next ;
3776:
3777: 1.1.1.1
3778: date 88.11.19.20.14.41; author lepreau; state Exp;
3779: branches ;
3780: next ;
3781:
3782:
3783: desc
3784: @Makefile for gprof, 4.3a BSD.
3785: @
3786:
3787:
3788: 1.3
3789: log
3790: @We don't have a group "bin" yet
3791: @
3792: text
3793: @#
3794: # Copyright (c) 1987 Regents of the University of California.
3795: # All rights reserved.
3796: #
3797: # Redistribution and use in source and binary forms are permitted
3798: # provided that this notice is preserved and that due credit is given
3799: # to the University of California at Berkeley. The name of the University
3800: # may not be used to endorse or promote products derived from this
3801: # software without specific written prior permission. This software
3802: # is provided ``as is'' without express or implied warranty.
3803: #
3804: # @@(#)Makefile 5.10 (Berkeley) 1/2/88
3805: #
3806: CFLAGS= -O
3807: LIBC= /lib/libc.a
3808: HDRS= gprof.h ${MACHINE}.h
3809: SRCS= gprof.c arcs.c dfn.c lookup.c ${MACHINE}.c hertz.c \
3810: printgprof.c printlist.c
3811: OBJS= gprof.o arcs.o dfn.o lookup.o ${MACHINE}.o hertz.o \
3812: printgprof.o printlist.o
3813: LIBDIR= ../../lib
3814:
3815: all: gprof
3816:
3817: gprof: ${OBJS} ${LIBC}
3818: ${CC} -o $@@ ${CFLAGS} ${OBJS}
3819:
3820: gcrt0.h: FRC
3821: -if [ -r gcrt0.h ] && \
3822: cmp -s gcrt0.h ${LIBDIR}/libc/${MACHINE}/csu/gmon.h; then \
3823: :; \
3824: else \
3825: rm -f gcrt0.h; \
3826: cp ${LIBDIR}/libc/${MACHINE}/csu/gmon.h gcrt0.h; \
3827: fi
3828:
3829: clean: FRC
3830: rm -f ${OBJS} core gprof
3831:
3832: depend: FRC
3833: mkdep ${CFLAGS} ${SRCS}
3834:
3835: install: FRC
3836: install -s -m 755 gprof ${DESTDIR}/usr/ucb/gprof
3837: install -c -m 644 gprof.flat ${DESTDIR}/usr/lib
3838: install -c -m 644 gprof.callg ${DESTDIR}/usr/lib
3839:
3840: lint: FRC
3841: lint ${CFLAGS} ${SRCS}
3842:
3843: tags: FRC
3844: ctags ${SRCS}
3845:
3846: FRC:
3847:
3848: # DO NOT DELETE THIS LINE -- mkdep uses it.
3849: # DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY.
3850:
3851: gprof.o: gprof.c gprof.h /usr/include/stdio.h /usr/include/sys/types.h
3852: gprof.o: /usr/include/sys/stat.h /usr/include/a.out.h /usr/include/sys/exec.h
3853: gprof.o: gcrt0.h tahoe.h
3854: arcs.o: arcs.c gprof.h /usr/include/stdio.h /usr/include/sys/types.h
3855: arcs.o: /usr/include/sys/stat.h /usr/include/a.out.h /usr/include/sys/exec.h
3856: arcs.o: gcrt0.h tahoe.h
3857: dfn.o: dfn.c /usr/include/stdio.h gprof.h /usr/include/stdio.h
3858: dfn.o: /usr/include/sys/types.h /usr/include/sys/stat.h /usr/include/a.out.h
3859: dfn.o: /usr/include/sys/exec.h gcrt0.h tahoe.h
3860: lookup.o: lookup.c gprof.h /usr/include/stdio.h /usr/include/sys/types.h
3861: lookup.o: /usr/include/sys/stat.h /usr/include/a.out.h /usr/include/sys/exec.h
3862: lookup.o: gcrt0.h tahoe.h
3863: tahoe.o: tahoe.c gprof.h /usr/include/stdio.h /usr/include/sys/types.h
3864: tahoe.o: /usr/include/sys/stat.h /usr/include/a.out.h /usr/include/sys/exec.h
3865: tahoe.o: gcrt0.h tahoe.h
3866: hertz.o: hertz.c /usr/include/sys/time.h /usr/include/time.h
3867: printgprof.o: printgprof.c gprof.h /usr/include/stdio.h
3868: printgprof.o: /usr/include/sys/types.h /usr/include/sys/stat.h
3869: printgprof.o: /usr/include/a.out.h /usr/include/sys/exec.h gcrt0.h tahoe.h
3870: printlist.o: printlist.c gprof.h /usr/include/stdio.h /usr/include/sys/types.h
3871: printlist.o: /usr/include/sys/stat.h /usr/include/a.out.h
3872: printlist.o: /usr/include/sys/exec.h gcrt0.h tahoe.h
3873:
3874: # IF YOU PUT ANYTHING HERE IT WILL GO AWAY
3875: @
3876:
3877:
3878: 1.2
3879: log
3880: @Make it possible to build gprof outside /usr/src.
3881: @
3882: text
3883: @d44 3
3884: a46 3
3885: install -s -o bin -g bin -m 755 gprof ${DESTDIR}/usr/ucb/gprof
3886: install -c -o bin -g bin -m 644 gprof.flat ${DESTDIR}/usr/lib
3887: install -c -o bin -g bin -m 644 gprof.callg ${DESTDIR}/usr/lib
3888: @
3889:
3890:
3891: 1.1
3892: log
3893: @ucb sid 5.10, 1/2/88.
3894: @
3895: text
3896: @d21 1
3897: d30 1
3898: a30 1
3899: cmp -s gcrt0.h ../../lib/libc/${MACHINE}/csu/gmon.h; then \
3900: d34 1
3901: a34 1
3902: cp ../../lib/libc/${MACHINE}/csu/gmon.h gcrt0.h; \
3903: @
3904:
3905:
3906: 1.1.1.1
3907: log
3908: @4.3 release, sid 5.2, 6/18/85.
3909: The odd placement of this rev is because it got left out earlier.
3910: @
3911: text
3912: @d2 2
3913: a3 3
3914: # Copyright (c) 1983 Regents of the University of California.
3915: # All rights reserved. The Berkeley software License Agreement
3916: # specifies the terms and conditions for redistribution.
3917: d5 6
3918: a10 1
3919: # @@(#)Makefile 5.2 (Berkeley) 6/18/85
3920: d12 9
3921: a20 1
3922: SCCSID = @@(#)Makefile 5.2 (Berkeley) 6/18/85
3923: d22 1
3924: a22 3
3925: DFLAGS =
3926: CFLAGS = -O ${DFLAGS}
3927: LINTFLAGS = -x -a -n ${DFLAGS}
3928: d24 2
3929: a25 3
3930: RM= /bin/rm -f
3931: INSTALL=install
3932: PR=pr
3933: d27 8
3934: a34 5
3935: GPROFHDRS = gprof.h vax.h
3936: GPROFSRCS = gprof.c arcs.c dfn.c lookup.c calls.c hertz.c \
3937: printgprof.c printlist.c
3938: GPROFOBJS = gprof.o arcs.o dfn.o lookup.o calls.o hertz.o \
3939: printgprof.o printlist.o
3940: d36 2
3941: a37 2
3942: gprof: ${GPROFOBJS}
3943: cc -o gprof ${CFLAGS} ${GPROFOBJS}
3944: d39 2
3945: a40 4
3946: install: gprof gprof.flat gprof.callg
3947: install -s -g kmem -m 2755 gprof ${DESTDIR}/usr/ucb/gprof
3948: install -c -m 644 gprof.flat ${DESTDIR}/usr/lib
3949: install -c -m 644 gprof.callg ${DESTDIR}/usr/lib
3950: d42 4
3951: a45 2
3952: clean:
3953: ${RM} ${GPROFOBJS} errs gprof
3954: d47 2
3955: a48 2
3956: gcrt0.h:
3957: cp /usr/src/libc/csu/gcrt0.h gcrt0.h
3958: d50 2
3959: a51 6
3960: print:
3961: @@ ls -l | ${PR}
3962: @@ ${PR} makefile
3963: @@ ${PR} gcrt0.h
3964: @@ ${PR} ${GPROFHDRS} ${GPROFSRCS}
3965: @@ ${PR} gprof.flat gprof.callg
3966: d53 1
3967: a53 2
3968: lint:
3969: lint ${LINTFLAGS} ${DFLAGS} ${GPROFSRCS}
3970: d55 27
3971: a81 8
3972: gprof.o: gprof.c gprof.h vax.h gcrt0.h
3973: arcs.o: arcs.c gprof.h vax.h gcrt0.h
3974: lookup.o: lookup.c gprof.h vax.h gcrt0.h
3975: dfn.o: dfn.c gprof.h vax.h gcrt0.h
3976: calls.o: calls.c gprof.h vax.h gcrt0.h
3977: hertz.o: gprof.h vax.h hertz.c
3978: printgprof.o: printgprof.c gprof.h vax.h gcrt0.h
3979: printlist.o: printlist.c gprof.h vax.h gcrt0.h
3980: @
3981: r/include/sys/stat.h /usr/include/a.out.h
3982: dfn.o: /usr/include/sys/exec.h gcrt0.h tahoe.h
3983: lookup.o: lookup.c gprof.h /usr/include/stdio.h /usr/include/sys/typesgprof/RCS/arcs.c,v 444 14 12 36636 4341433707 7220 head 1.2;
3984: access ;
3985: symbols ;
3986: locks ; strict;
3987: comment @ * @;
3988:
3989:
3990: 1.2
3991: date 88.11.19.20.10.46; author lepreau; state Exp;
3992: branches ;
3993: next 1.1;
3994:
3995: 1.1
3996: date 88.11.19.19.57.28; author lepreau; state Rel;
3997: branches ;
3998: next ;
3999:
4000:
4001: desc
4002: @@
4003:
4004:
4005: 1.2
4006: log
4007: @ucb sid 5.3, 1/7/86. Went out in hpbsd 1.0.
4008: @
4009: text
4010: @/*
4011: * Copyright (c) 1983 Regents of the University of California.
4012: * All rights reserved. The Berkeley software License Agreement
4013: * specifies the terms and conditions for redistribution.
4014: */
4015:
4016: #ifndef lint
4017: static char sccsid[] = "@@(#)arcs.c 5.3 (Berkeley) 1/7/86";
4018: #endif not lint
4019:
4020: #include "gprof.h"
4021:
4022: /*
4023: * add (or just increment) an arc
4024: */
4025: addarc( parentp , childp , count )
4026: nltype *parentp;
4027: nltype *childp;
4028: long count;
4029: {
4030: arctype *calloc();
4031: arctype *arcp;
4032:
4033: # ifdef DEBUG
4034: if ( debug & TALLYDEBUG ) {
4035: printf( "[addarc] %d arcs from %s to %s\n" ,
4036: count , parentp -> name , childp -> name );
4037: }
4038: # endif DEBUG
4039: arcp = arclookup( parentp , childp );
4040: if ( arcp != 0 ) {
4041: /*
4042: * a hit: just increment the count.
4043: */
4044: # ifdef DEBUG
4045: if ( debug & TALLYDEBUG ) {
4046: printf( "[tally] hit %d += %d\n" ,
4047: arcp -> arc_count , count );
4048: }
4049: # endif DEBUG
4050: arcp -> arc_count += count;
4051: return;
4052: }
4053: arcp = calloc( 1 , sizeof *arcp );
4054: arcp -> arc_parentp = parentp;
4055: arcp -> arc_childp = childp;
4056: arcp -> arc_count = count;
4057: /*
4058: * prepend this child to the children of this parent
4059: */
4060: arcp -> arc_childlist = parentp -> children;
4061: parentp -> children = arcp;
4062: /*
4063: * prepend this parent to the parents of this child
4064: */
4065: arcp -> arc_parentlist = childp -> parents;
4066: childp -> parents = arcp;
4067: }
4068:
4069: /*
4070: * the code below topologically sorts the graph (collapsing cycles),
4071: * and propagates time bottom up and flags top down.
4072: */
4073:
4074: /*
4075: * the topologically sorted name list pointers
4076: */
4077: nltype **topsortnlp;
4078:
4079: topcmp( npp1 , npp2 )
4080: nltype **npp1;
4081: nltype **npp2;
4082: {
4083: return (*npp1) -> toporder - (*npp2) -> toporder;
4084: }
4085:
4086: nltype **
4087: doarcs()
4088: {
4089: nltype *parentp, **timesortnlp;
4090: arctype *arcp;
4091: long index;
4092:
4093: /*
4094: * initialize various things:
4095: * zero out child times.
4096: * count self-recursive calls.
4097: * indicate that nothing is on cycles.
4098: */
4099: for ( parentp = nl ; parentp < npe ; parentp++ ) {
4100: parentp -> childtime = 0.0;
4101: arcp = arclookup( parentp , parentp );
4102: if ( arcp != 0 ) {
4103: parentp -> ncall -= arcp -> arc_count;
4104: parentp -> selfcalls = arcp -> arc_count;
4105: } else {
4106: parentp -> selfcalls = 0;
4107: }
4108: parentp -> propfraction = 0.0;
4109: parentp -> propself = 0.0;
4110: parentp -> propchild = 0.0;
4111: parentp -> printflag = FALSE;
4112: parentp -> toporder = DFN_NAN;
4113: parentp -> cycleno = 0;
4114: parentp -> cyclehead = parentp;
4115: parentp -> cnext = 0;
4116: if ( cflag ) {
4117: findcall( parentp , parentp -> value , (parentp+1) -> value );
4118: }
4119: }
4120: /*
4121: * topologically order things
4122: * if any node is unnumbered,
4123: * number it and any of its descendents.
4124: */
4125: for ( parentp = nl ; parentp < npe ; parentp++ ) {
4126: if ( parentp -> toporder == DFN_NAN ) {
4127: dfn( parentp );
4128: }
4129: }
4130: /*
4131: * link together nodes on the same cycle
4132: */
4133: cyclelink();
4134: /*
4135: * Sort the symbol table in reverse topological order
4136: */
4137: topsortnlp = (nltype **) calloc( nname , sizeof(nltype *) );
4138: if ( topsortnlp == (nltype **) 0 ) {
4139: fprintf( stderr , "[doarcs] ran out of memory for topo sorting\n" );
4140: }
4141: for ( index = 0 ; index < nname ; index += 1 ) {
4142: topsortnlp[ index ] = &nl[ index ];
4143: }
4144: qsort( topsortnlp , nname , sizeof(nltype *) , topcmp );
4145: # ifdef DEBUG
4146: if ( debug & DFNDEBUG ) {
4147: printf( "[doarcs] topological sort listing\n" );
4148: for ( index = 0 ; index < nname ; index += 1 ) {
4149: printf( "[doarcs] " );
4150: printf( "%d:" , topsortnlp[ index ] -> toporder );
4151: printname( topsortnlp[ index ] );
4152: printf( "\n" );
4153: }
4154: }
4155: # endif DEBUG
4156: /*
4157: * starting from the topological top,
4158: * propagate print flags to children.
4159: * also, calculate propagation fractions.
4160: * this happens before time propagation
4161: * since time propagation uses the fractions.
4162: */
4163: doflags();
4164: /*
4165: * starting from the topological bottom,
4166: * propogate children times up to parents.
4167: */
4168: dotime();
4169: /*
4170: * Now, sort by propself + propchild.
4171: * sorting both the regular function names
4172: * and cycle headers.
4173: */
4174: timesortnlp = (nltype **) calloc( nname + ncycle , sizeof(nltype *) );
4175: if ( timesortnlp == (nltype **) 0 ) {
4176: fprintf( stderr , "%s: ran out of memory for sorting\n" , whoami );
4177: }
4178: for ( index = 0 ; index < nname ; index++ ) {
4179: timesortnlp[index] = &nl[index];
4180: }
4181: for ( index = 1 ; index <= ncycle ; index++ ) {
4182: timesortnlp[nname+index-1] = &cyclenl[index];
4183: }
4184: qsort( timesortnlp , nname + ncycle , sizeof(nltype *) , totalcmp );
4185: for ( index = 0 ; index < nname + ncycle ; index++ ) {
4186: timesortnlp[ index ] -> index = index + 1;
4187: }
4188: return( timesortnlp );
4189: }
4190:
4191: dotime()
4192: {
4193: int index;
4194:
4195: cycletime();
4196: for ( index = 0 ; index < nname ; index += 1 ) {
4197: timepropagate( topsortnlp[ index ] );
4198: }
4199: }
4200:
4201: timepropagate( parentp )
4202: nltype *parentp;
4203: {
4204: arctype *arcp;
4205: nltype *childp;
4206: double share;
4207: double propshare;
4208:
4209: if ( parentp -> propfraction == 0.0 ) {
4210: return;
4211: }
4212: /*
4213: * gather time from children of this parent.
4214: */
4215: for ( arcp = parentp -> children ; arcp ; arcp = arcp -> arc_childlist ) {
4216: childp = arcp -> arc_childp;
4217: if ( arcp -> arc_count == 0 ) {
4218: continue;
4219: }
4220: if ( childp == parentp ) {
4221: continue;
4222: }
4223: if ( childp -> propfraction == 0.0 ) {
4224: continue;
4225: }
4226: if ( childp -> cyclehead != childp ) {
4227: if ( parentp -> cycleno == childp -> cycleno ) {
4228: continue;
4229: }
4230: if ( parentp -> toporder <= childp -> toporder ) {
4231: fprintf( stderr , "[propagate] toporder botches\n" );
4232: }
4233: childp = childp -> cyclehead;
4234: } else {
4235: if ( parentp -> toporder <= childp -> toporder ) {
4236: fprintf( stderr , "[propagate] toporder botches\n" );
4237: continue;
4238: }
4239: }
4240: if ( childp -> ncall == 0 ) {
4241: continue;
4242: }
4243: /*
4244: * distribute time for this arc
4245: */
4246: arcp -> arc_time = childp -> time
4247: * ( ( (double) arcp -> arc_count ) /
4248: ( (double) childp -> ncall ) );
4249: arcp -> arc_childtime = childp -> childtime
4250: * ( ( (double) arcp -> arc_count ) /
4251: ( (double) childp -> ncall ) );
4252: share = arcp -> arc_time + arcp -> arc_childtime;
4253: parentp -> childtime += share;
4254: /*
4255: * ( 1 - propfraction ) gets lost along the way
4256: */
4257: propshare = parentp -> propfraction * share;
4258: /*
4259: * fix things for printing
4260: */
4261: parentp -> propchild += propshare;
4262: arcp -> arc_time *= parentp -> propfraction;
4263: arcp -> arc_childtime *= parentp -> propfraction;
4264: /*
4265: * add this share to the parent's cycle header, if any.
4266: */
4267: if ( parentp -> cyclehead != parentp ) {
4268: parentp -> cyclehead -> childtime += share;
4269: parentp -> cyclehead -> propchild += propshare;
4270: }
4271: # ifdef DEBUG
4272: if ( debug & PROPDEBUG ) {
4273: printf( "[dotime] child \t" );
4274: printname( childp );
4275: printf( " with %f %f %d/%d\n" ,
4276: childp -> time , childp -> childtime ,
4277: arcp -> arc_count , childp -> ncall );
4278: printf( "[dotime] parent\t" );
4279: printname( parentp );
4280: printf( "\n[dotime] share %f\n" , share );
4281: }
4282: # endif DEBUG
4283: }
4284: }
4285:
4286: cyclelink()
4287: {
4288: register nltype *nlp;
4289: register nltype *cyclenlp;
4290: int cycle;
4291: nltype *memberp;
4292: arctype *arcp;
4293:
4294: /*
4295: * Count the number of cycles, and initialze the cycle lists
4296: */
4297: ncycle = 0;
4298: for ( nlp = nl ; nlp < npe ; nlp++ ) {
4299: /*
4300: * this is how you find unattached cycles
4301: */
4302: if ( nlp -> cyclehead == nlp && nlp -> cnext != 0 ) {
4303: ncycle += 1;
4304: }
4305: }
4306: /*
4307: * cyclenl is indexed by cycle number:
4308: * i.e. it is origin 1, not origin 0.
4309: */
4310: cyclenl = (nltype *) calloc( ncycle + 1 , sizeof( nltype ) );
4311: if ( cyclenl == 0 ) {
4312: fprintf( stderr , "%s: No room for %d bytes of cycle headers\n" ,
4313: whoami , ( ncycle + 1 ) * sizeof( nltype ) );
4314: done();
4315: }
4316: /*
4317: * now link cycles to true cycleheads,
4318: * number them, accumulate the data for the cycle
4319: */
4320: cycle = 0;
4321: for ( nlp = nl ; nlp < npe ; nlp++ ) {
4322: if ( !( nlp -> cyclehead == nlp && nlp -> cnext != 0 ) ) {
4323: continue;
4324: }
4325: cycle += 1;
4326: cyclenlp = &cyclenl[cycle];
4327: cyclenlp -> name = 0; /* the name */
4328: cyclenlp -> value = 0; /* the pc entry point */
4329: cyclenlp -> time = 0.0; /* ticks in this routine */
4330: cyclenlp -> childtime = 0.0; /* cumulative ticks in children */
4331: cyclenlp -> ncall = 0; /* how many times called */
4332: cyclenlp -> selfcalls = 0; /* how many calls to self */
4333: cyclenlp -> propfraction = 0.0; /* what % of time propagates */
4334: cyclenlp -> propself = 0.0; /* how much self time propagates */
4335: cyclenlp -> propchild = 0.0; /* how much child time propagates */
4336: cyclenlp -> printflag = TRUE; /* should this be printed? */
4337: cyclenlp -> index = 0; /* index in the graph list */
4338: cyclenlp -> toporder = DFN_NAN; /* graph call chain top-sort order */
4339: cyclenlp -> cycleno = cycle; /* internal number of cycle on */
4340: cyclenlp -> cyclehead = cyclenlp; /* pointer to head of cycle */
4341: cyclenlp -> cnext = nlp; /* pointer to next member of cycle */
4342: cyclenlp -> parents = 0; /* list of caller arcs */
4343: cyclenlp -> children = 0; /* list of callee arcs */
4344: # ifdef DEBUG
4345: if ( debug & CYCLEDEBUG ) {
4346: printf( "[cyclelink] " );
4347: printname( nlp );
4348: printf( " is the head of cycle %d\n" , cycle );
4349: }
4350: # endif DEBUG
4351: /*
4352: * link members to cycle header
4353: */
4354: for ( memberp = nlp ; memberp ; memberp = memberp -> cnext ) {
4355: memberp -> cycleno = cycle;
4356: memberp -> cyclehead = cyclenlp;
4357: }
4358: /*
4359: * count calls from outside the cycle
4360: * and those among cycle members
4361: */
4362: for ( memberp = nlp ; memberp ; memberp = memberp -> cnext ) {
4363: for ( arcp=memberp->parents ; arcp ; arcp=arcp->arc_parentlist ) {
4364: if ( arcp -> arc_parentp == memberp ) {
4365: continue;
4366: }
4367: if ( arcp -> arc_parentp -> cycleno == cycle ) {
4368: cyclenlp -> selfcalls += arcp -> arc_count;
4369: } else {
4370: cyclenlp -> ncall += arcp -> arc_count;
4371: }
4372: }
4373: }
4374: }
4375: }
4376:
4377: cycletime()
4378: {
4379: int cycle;
4380: nltype *cyclenlp;
4381: nltype *childp;
4382:
4383: for ( cycle = 1 ; cycle <= ncycle ; cycle += 1 ) {
4384: cyclenlp = &cyclenl[ cycle ];
4385: for ( childp = cyclenlp -> cnext ; childp ; childp = childp -> cnext ) {
4386: if ( childp -> propfraction == 0.0 ) {
4387: /*
4388: * all members have the same propfraction except those
4389: * that were excluded with -E
4390: */
4391: continue;
4392: }
4393: cyclenlp -> time += childp -> time;
4394: }
4395: cyclenlp -> propself = cyclenlp -> propfraction * cyclenlp -> time;
4396: }
4397: }
4398:
4399: /*
4400: * in one top to bottom pass over the topologically sorted namelist
4401: * propagate:
4402: * printflag as the union of parents' printflags
4403: * propfraction as the sum of fractional parents' propfractions
4404: * and while we're here, sum time for functions.
4405: */
4406: doflags()
4407: {
4408: int index;
4409: nltype *childp;
4410: nltype *oldhead;
4411:
4412: oldhead = 0;
4413: for ( index = nname-1 ; index >= 0 ; index -= 1 ) {
4414: childp = topsortnlp[ index ];
4415: /*
4416: * if we haven't done this function or cycle,
4417: * inherit things from parent.
4418: * this way, we are linear in the number of arcs
4419: * since we do all members of a cycle (and the cycle itself)
4420: * as we hit the first member of the cycle.
4421: */
4422: if ( childp -> cyclehead != oldhead ) {
4423: oldhead = childp -> cyclehead;
4424: inheritflags( childp );
4425: }
4426: # ifdef DEBUG
4427: if ( debug & PROPDEBUG ) {
4428: printf( "[doflags] " );
4429: printname( childp );
4430: printf( " inherits printflag %d and propfraction %f\n" ,
4431: childp -> printflag , childp -> propfraction );
4432: }
4433: # endif DEBUG
4434: if ( ! childp -> printflag ) {
4435: /*
4436: * printflag is off
4437: * it gets turned on by
4438: * being on -f list,
4439: * or there not being any -f list and not being on -e list.
4440: */
4441: if ( onlist( flist , childp -> name )
4442: || ( !fflag && !onlist( elist , childp -> name ) ) ) {
4443: childp -> printflag = TRUE;
4444: }
4445: } else {
4446: /*
4447: * this function has printing parents:
4448: * maybe someone wants to shut it up
4449: * by putting it on -e list. (but favor -f over -e)
4450: */
4451: if ( ( !onlist( flist , childp -> name ) )
4452: && onlist( elist , childp -> name ) ) {
4453: childp -> printflag = FALSE;
4454: }
4455: }
4456: if ( childp -> propfraction == 0.0 ) {
4457: /*
4458: * no parents to pass time to.
4459: * collect time from children if
4460: * its on -F list,
4461: * or there isn't any -F list and its not on -E list.
4462: */
4463: if ( onlist( Flist , childp -> name )
4464: || ( !Fflag && !onlist( Elist , childp -> name ) ) ) {
4465: childp -> propfraction = 1.0;
4466: }
4467: } else {
4468: /*
4469: * it has parents to pass time to,
4470: * but maybe someone wants to shut it up
4471: * by puttting it on -E list. (but favor -F over -E)
4472: */
4473: if ( !onlist( Flist , childp -> name )
4474: && onlist( Elist , childp -> name ) ) {
4475: childp -> propfraction = 0.0;
4476: }
4477: }
4478: childp -> propself = childp -> time * childp -> propfraction;
4479: printtime += childp -> propself;
4480: # ifdef DEBUG
4481: if ( debug & PROPDEBUG ) {
4482: printf( "[doflags] " );
4483: printname( childp );
4484: printf( " ends up with printflag %d and propfraction %f\n" ,
4485: childp -> printflag , childp -> propfraction );
4486: printf( "time %f propself %f printtime %f\n" ,
4487: childp -> time , childp -> propself , printtime );
4488: }
4489: # endif DEBUG
4490: }
4491: }
4492:
4493: /*
4494: * check if any parent of this child
4495: * (or outside parents of this cycle)
4496: * have their print flags on and set the
4497: * print flag of the child (cycle) appropriately.
4498: * similarly, deal with propagation fractions from parents.
4499: */
4500: inheritflags( childp )
4501: nltype *childp;
4502: {
4503: nltype *headp;
4504: arctype *arcp;
4505: nltype *parentp;
4506: nltype *memp;
4507:
4508: headp = childp -> cyclehead;
4509: if ( childp == headp ) {
4510: /*
4511: * just a regular child, check its parents
4512: */
4513: childp -> printflag = FALSE;
4514: childp -> propfraction = 0.0;
4515: for (arcp = childp -> parents ; arcp ; arcp = arcp -> arc_parentlist) {
4516: parentp = arcp -> arc_parentp;
4517: if ( childp == parentp ) {
4518: continue;
4519: }
4520: childp -> printflag |= parentp -> printflag;
4521: /*
4522: * if the child was never actually called
4523: * (e.g. this arc is static (and all others are, too))
4524: * no time propagates along this arc.
4525: */
4526: if ( childp -> ncall ) {
4527: childp -> propfraction += parentp -> propfraction
4528: * ( ( (double) arcp -> arc_count )
4529: / ( (double) childp -> ncall ) );
4530: }
4531: }
4532: } else {
4533: /*
4534: * its a member of a cycle, look at all parents from
4535: * outside the cycle
4536: */
4537: headp -> printflag = FALSE;
4538: headp -> propfraction = 0.0;
4539: for ( memp = headp -> cnext ; memp ; memp = memp -> cnext ) {
4540: for (arcp = memp->parents ; arcp ; arcp = arcp->arc_parentlist) {
4541: if ( arcp -> arc_parentp -> cyclehead == headp ) {
4542: continue;
4543: }
4544: parentp = arcp -> arc_parentp;
4545: headp -> printflag |= parentp -> printflag;
4546: /*
4547: * if the cycle was never actually called
4548: * (e.g. this arc is static (and all others are, too))
4549: * no time propagates along this arc.
4550: */
4551: if ( headp -> ncall ) {
4552: headp -> propfraction += parentp -> propfraction
4553: * ( ( (double) arcp -> arc_count )
4554: / ( (double) headp -> ncall ) );
4555: }
4556: }
4557: }
4558: for ( memp = headp ; memp ; memp = memp -> cnext ) {
4559: memp -> printflag = headp -> printflag;
4560: memp -> propfraction = headp -> propfraction;
4561: }
4562: }
4563: }
4564: @
4565:
4566:
4567: 1.1
4568: log
4569: @4.3 release
4570: @
4571: text
4572: @d8 1
4573: a8 1
4574: static char sccsid[] = "@@(#)arcs.c 5.2 (Berkeley) 6/4/85";
4575: d108 1
4576: a108 1
4577: findcalls( parentp , parentp -> value , (parentp+1) -> value );
4578: @
4579: tname( childp );
4580: printf( " inherits printflag %d and propfraction %f\n" ,
4581: childp -> printflaggprof/RCS/gprof.c,v 444 33 12 42045 4436154434 7377 head 1.4;
4582: access ;
4583: symbols ;
4584: locks ; strict;
4585: comment @ * @;
4586:
4587:
4588: 1.4
4589: date 89.05.22.22.07.18; author mike; state Exp;
4590: branches ;
4591: next 1.3;
4592:
4593: 1.3
4594: date 88.11.19.20.20.04; author lepreau; state Exp;
4595: branches ;
4596: next 1.2;
4597:
4598: 1.2
4599: date 88.11.19.20.18.45; author lepreau; state Exp;
4600: branches ;
4601: next 1.1;
4602:
4603: 1.1
4604: date 88.11.19.19.57.30; author lepreau; state Rel;
4605: branches ;
4606: next ;
4607:
4608:
4609: desc
4610: @@
4611:
4612:
4613: 1.4
4614: log
4615: @added -H option to specify hertz value for machine with alternate
4616: profiling timer running at a rate different from the default clock
4617: @
4618: text
4619: @/*
4620: * Copyright (c) 1983 Regents of the University of California.
4621: * All rights reserved. The Berkeley software License Agreement
4622: * specifies the terms and conditions for redistribution.
4623: */
4624:
4625: #ifndef lint
4626: char copyright[] =
4627: "@@(#) Copyright (c) 1983 Regents of the University of California.\n\
4628: All rights reserved.\n";
4629: #endif not lint
4630:
4631: #ifndef lint
4632: static char sccsid[] = "@@(#)gprof.c 5.3 (Berkeley) 1/2/88";
4633: #endif not lint
4634:
4635: #include "gprof.h"
4636:
4637: char *whoami = "gprof";
4638:
4639: /*
4640: * things which get -E excluded by default.
4641: */
4642: char *defaultEs[] = { "mcount" , "__mcleanup" , 0 };
4643:
4644: main(argc, argv)
4645: int argc;
4646: char **argv;
4647: {
4648: char **sp;
4649: nltype **timesortnlp;
4650:
4651: --argc;
4652: argv++;
4653: debug = 0;
4654: bflag = TRUE;
4655: while ( *argv != 0 && **argv == '-' ) {
4656: (*argv)++;
4657: switch ( **argv ) {
4658: case 'a':
4659: aflag = TRUE;
4660: break;
4661: case 'b':
4662: bflag = FALSE;
4663: break;
4664: case 'c':
4665: #if hp300
4666: fprintf(stderr, "gprof -c isn't supported on hp300s yet\n");
4667: exit(1);
4668: #endif
4669: cflag = TRUE;
4670: break;
4671: case 'd':
4672: dflag = TRUE;
4673: (*argv)++;
4674: debug |= atoi( *argv );
4675: debug |= ANYDEBUG;
4676: # ifdef DEBUG
4677: printf("[main] debug = %d\n", debug);
4678: # else not DEBUG
4679: printf("%s: -d ignored\n", whoami);
4680: # endif DEBUG
4681: break;
4682: case 'E':
4683: ++argv;
4684: addlist( Elist , *argv );
4685: Eflag = TRUE;
4686: addlist( elist , *argv );
4687: eflag = TRUE;
4688: break;
4689: case 'e':
4690: addlist( elist , *++argv );
4691: eflag = TRUE;
4692: break;
4693: case 'F':
4694: ++argv;
4695: addlist( Flist , *argv );
4696: Fflag = TRUE;
4697: addlist( flist , *argv );
4698: fflag = TRUE;
4699: break;
4700: case 'f':
4701: addlist( flist , *++argv );
4702: fflag = TRUE;
4703: break;
4704: case 'H':
4705: hz = atoi( *++argv );
4706: if (hz < 0 || hz > 100000) {
4707: fprintf(stderr, "unreasonable HZ value, using default\n");
4708: hz = 0;
4709: }
4710: break;
4711: case 'k':
4712: addlist( kfromlist , *++argv );
4713: addlist( ktolist , *++argv );
4714: kflag = TRUE;
4715: break;
4716: case 's':
4717: sflag = TRUE;
4718: break;
4719: case 'z':
4720: zflag = TRUE;
4721: break;
4722: }
4723: argv++;
4724: }
4725: if ( *argv != 0 ) {
4726: a_outname = *argv;
4727: argv++;
4728: } else {
4729: a_outname = A_OUTNAME;
4730: }
4731: if ( *argv != 0 ) {
4732: gmonname = *argv;
4733: argv++;
4734: } else {
4735: gmonname = GMONNAME;
4736: }
4737: /*
4738: * turn off default functions
4739: */
4740: for ( sp = &defaultEs[0] ; *sp ; sp++ ) {
4741: Eflag = TRUE;
4742: addlist( Elist , *sp );
4743: eflag = TRUE;
4744: addlist( elist , *sp );
4745: }
4746: /*
4747: * how many ticks per second?
4748: * if we can't tell, report time in ticks.
4749: */
4750: if (hz == 0)
4751: hz = hertz();
4752: if (hz == 0) {
4753: hz = 1;
4754: fprintf(stderr, "time is in ticks, not seconds\n");
4755: }
4756: /*
4757: * get information about a.out file.
4758: */
4759: getnfile();
4760: /*
4761: * get information about mon.out file(s).
4762: */
4763: do {
4764: getpfile( gmonname );
4765: if ( *argv != 0 ) {
4766: gmonname = *argv;
4767: }
4768: } while ( *argv++ != 0 );
4769: /*
4770: * dump out a gmon.sum file if requested
4771: */
4772: if ( sflag ) {
4773: dumpsum( GMONSUM );
4774: }
4775: /*
4776: * assign samples to procedures
4777: */
4778: asgnsamples();
4779: /*
4780: * assemble the dynamic profile
4781: */
4782: timesortnlp = doarcs();
4783: /*
4784: * print the dynamic profile
4785: */
4786: printgprof( timesortnlp );
4787: /*
4788: * print the flat profile
4789: */
4790: printprof();
4791: /*
4792: * print the index
4793: */
4794: printindex();
4795: done();
4796: }
4797:
4798: /*
4799: * Set up string and symbol tables from a.out.
4800: * and optionally the text space.
4801: * On return symbol table is sorted by value.
4802: */
4803: getnfile()
4804: {
4805: FILE *nfile;
4806: int valcmp();
4807:
4808: nfile = fopen( a_outname ,"r");
4809: if (nfile == NULL) {
4810: perror( a_outname );
4811: done();
4812: }
4813: fread(&xbuf, 1, sizeof(xbuf), nfile);
4814: if (N_BADMAG(xbuf)) {
4815: fprintf(stderr, "%s: %s: bad format\n", whoami , a_outname );
4816: done();
4817: }
4818: getstrtab(nfile);
4819: getsymtab(nfile);
4820: gettextspace( nfile );
4821: qsort(nl, nname, sizeof(nltype), valcmp);
4822: fclose(nfile);
4823: # ifdef DEBUG
4824: if ( debug & AOUTDEBUG ) {
4825: register int j;
4826:
4827: for (j = 0; j < nname; j++){
4828: printf("[getnfile] 0X%08x\t%s\n", nl[j].value, nl[j].name);
4829: }
4830: }
4831: # endif DEBUG
4832: }
4833:
4834: getstrtab(nfile)
4835: FILE *nfile;
4836: {
4837:
4838: fseek(nfile, (long)(N_SYMOFF(xbuf) + xbuf.a_syms), 0);
4839: if (fread(&ssiz, sizeof (ssiz), 1, nfile) == 0) {
4840: fprintf(stderr, "%s: %s: no string table (old format?)\n" ,
4841: whoami , a_outname );
4842: done();
4843: }
4844: strtab = (char *)calloc(ssiz, 1);
4845: if (strtab == NULL) {
4846: fprintf(stderr, "%s: %s: no room for %d bytes of string table",
4847: whoami , a_outname , ssiz);
4848: done();
4849: }
4850: if (fread(strtab+sizeof(ssiz), ssiz-sizeof(ssiz), 1, nfile) != 1) {
4851: fprintf(stderr, "%s: %s: error reading string table\n",
4852: whoami , a_outname );
4853: done();
4854: }
4855: }
4856:
4857: /*
4858: * Read in symbol table
4859: */
4860: getsymtab(nfile)
4861: FILE *nfile;
4862: {
4863: register long i;
4864: int askfor;
4865: struct nlist nbuf;
4866:
4867: /* pass1 - count symbols */
4868: fseek(nfile, (long)N_SYMOFF(xbuf), 0);
4869: nname = 0;
4870: for (i = xbuf.a_syms; i > 0; i -= sizeof(struct nlist)) {
4871: fread(&nbuf, sizeof(nbuf), 1, nfile);
4872: if ( ! funcsymbol( &nbuf ) ) {
4873: continue;
4874: }
4875: nname++;
4876: }
4877: if (nname == 0) {
4878: fprintf(stderr, "%s: %s: no symbols\n", whoami , a_outname );
4879: done();
4880: }
4881: askfor = nname + 1;
4882: nl = (nltype *) calloc( askfor , sizeof(nltype) );
4883: if (nl == 0) {
4884: fprintf(stderr, "%s: No room for %d bytes of symbol table\n",
4885: whoami, askfor * sizeof(nltype) );
4886: done();
4887: }
4888:
4889: /* pass2 - read symbols */
4890: fseek(nfile, (long)N_SYMOFF(xbuf), 0);
4891: npe = nl;
4892: nname = 0;
4893: for (i = xbuf.a_syms; i > 0; i -= sizeof(struct nlist)) {
4894: fread(&nbuf, sizeof(nbuf), 1, nfile);
4895: if ( ! funcsymbol( &nbuf ) ) {
4896: # ifdef DEBUG
4897: if ( debug & AOUTDEBUG ) {
4898: printf( "[getsymtab] rejecting: 0x%x %s\n" ,
4899: nbuf.n_type , strtab + nbuf.n_un.n_strx );
4900: }
4901: # endif DEBUG
4902: continue;
4903: }
4904: npe->value = nbuf.n_value;
4905: npe->name = strtab+nbuf.n_un.n_strx;
4906: # ifdef DEBUG
4907: if ( debug & AOUTDEBUG ) {
4908: printf( "[getsymtab] %d %s 0x%08x\n" ,
4909: nname , npe -> name , npe -> value );
4910: }
4911: # endif DEBUG
4912: npe++;
4913: nname++;
4914: }
4915: npe->value = -1;
4916: }
4917:
4918: /*
4919: * read in the text space of an a.out file
4920: */
4921: gettextspace( nfile )
4922: FILE *nfile;
4923: {
4924: char *malloc();
4925:
4926: if ( cflag == 0 ) {
4927: return;
4928: }
4929: textspace = (u_char *) malloc( xbuf.a_text );
4930: if ( textspace == 0 ) {
4931: fprintf( stderr , "%s: ran out room for %d bytes of text space: " ,
4932: whoami , xbuf.a_text );
4933: fprintf( stderr , "can't do -c\n" );
4934: return;
4935: }
4936: (void) fseek( nfile , N_TXTOFF( xbuf ) , 0 );
4937: if ( fread( textspace , 1 , xbuf.a_text , nfile ) != xbuf.a_text ) {
4938: fprintf( stderr , "%s: couldn't read text space: " , whoami );
4939: fprintf( stderr , "can't do -c\n" );
4940: free( textspace );
4941: textspace = 0;
4942: return;
4943: }
4944: }
4945: /*
4946: * information from a gmon.out file is in two parts:
4947: * an array of sampling hits within pc ranges,
4948: * and the arcs.
4949: */
4950: getpfile(filename)
4951: char *filename;
4952: {
4953: FILE *pfile;
4954: FILE *openpfile();
4955: struct rawarc arc;
4956:
4957: pfile = openpfile(filename);
4958: readsamples(pfile);
4959: /*
4960: * the rest of the file consists of
4961: * a bunch of <from,self,count> tuples.
4962: */
4963: while ( fread( &arc , sizeof arc , 1 , pfile ) == 1 ) {
4964: # ifdef DEBUG
4965: if ( debug & SAMPLEDEBUG ) {
4966: printf( "[getpfile] frompc 0x%x selfpc 0x%x count %d\n" ,
4967: arc.raw_frompc , arc.raw_selfpc , arc.raw_count );
4968: }
4969: # endif DEBUG
4970: /*
4971: * add this arc
4972: */
4973: tally( &arc );
4974: }
4975: fclose(pfile);
4976: }
4977:
4978: FILE *
4979: openpfile(filename)
4980: char *filename;
4981: {
4982: struct hdr tmp;
4983: FILE *pfile;
4984:
4985: if((pfile = fopen(filename, "r")) == NULL) {
4986: perror(filename);
4987: done();
4988: }
4989: fread(&tmp, sizeof(struct hdr), 1, pfile);
4990: if ( s_highpc != 0 && ( tmp.lowpc != h.lowpc ||
4991: tmp.highpc != h.highpc || tmp.ncnt != h.ncnt ) ) {
4992: fprintf(stderr, "%s: incompatible with first gmon file\n", filename);
4993: done();
4994: }
4995: h = tmp;
4996: s_lowpc = (unsigned long) h.lowpc;
4997: s_highpc = (unsigned long) h.highpc;
4998: lowpc = (unsigned long)h.lowpc / sizeof(UNIT);
4999: highpc = (unsigned long)h.highpc / sizeof(UNIT);
5000: sampbytes = h.ncnt - sizeof(struct hdr);
5001: nsamples = sampbytes / sizeof (UNIT);
5002: # ifdef DEBUG
5003: if ( debug & SAMPLEDEBUG ) {
5004: printf( "[openpfile] hdr.lowpc 0x%x hdr.highpc 0x%x hdr.ncnt %d\n",
5005: h.lowpc , h.highpc , h.ncnt );
5006: printf( "[openpfile] s_lowpc 0x%x s_highpc 0x%x\n" ,
5007: s_lowpc , s_highpc );
5008: printf( "[openpfile] lowpc 0x%x highpc 0x%x\n" ,
5009: lowpc , highpc );
5010: printf( "[openpfile] sampbytes %d nsamples %d\n" ,
5011: sampbytes , nsamples );
5012: }
5013: # endif DEBUG
5014: return(pfile);
5015: }
5016:
5017: tally( rawp )
5018: struct rawarc *rawp;
5019: {
5020: nltype *parentp;
5021: nltype *childp;
5022:
5023: parentp = nllookup( rawp -> raw_frompc );
5024: childp = nllookup( rawp -> raw_selfpc );
5025: if ( kflag
5026: && onlist( kfromlist , parentp -> name )
5027: && onlist( ktolist , childp -> name ) ) {
5028: return;
5029: }
5030: childp -> ncall += rawp -> raw_count;
5031: # ifdef DEBUG
5032: if ( debug & TALLYDEBUG ) {
5033: printf( "[tally] arc from %s to %s traversed %d times\n" ,
5034: parentp -> name , childp -> name , rawp -> raw_count );
5035: }
5036: # endif DEBUG
5037: addarc( parentp , childp , rawp -> raw_count );
5038: }
5039:
5040: /*
5041: * dump out the gmon.sum file
5042: */
5043: dumpsum( sumfile )
5044: char *sumfile;
5045: {
5046: register nltype *nlp;
5047: register arctype *arcp;
5048: struct rawarc arc;
5049: FILE *sfile;
5050:
5051: if ( ( sfile = fopen ( sumfile , "w" ) ) == NULL ) {
5052: perror( sumfile );
5053: done();
5054: }
5055: /*
5056: * dump the header; use the last header read in
5057: */
5058: if ( fwrite( &h , sizeof h , 1 , sfile ) != 1 ) {
5059: perror( sumfile );
5060: done();
5061: }
5062: /*
5063: * dump the samples
5064: */
5065: if (fwrite(samples, sizeof (UNIT), nsamples, sfile) != nsamples) {
5066: perror( sumfile );
5067: done();
5068: }
5069: /*
5070: * dump the normalized raw arc information
5071: */
5072: for ( nlp = nl ; nlp < npe ; nlp++ ) {
5073: for ( arcp = nlp -> children ; arcp ; arcp = arcp -> arc_childlist ) {
5074: arc.raw_frompc = arcp -> arc_parentp -> value;
5075: arc.raw_selfpc = arcp -> arc_childp -> value;
5076: arc.raw_count = arcp -> arc_count;
5077: if ( fwrite ( &arc , sizeof arc , 1 , sfile ) != 1 ) {
5078: perror( sumfile );
5079: done();
5080: }
5081: # ifdef DEBUG
5082: if ( debug & SAMPLEDEBUG ) {
5083: printf( "[dumpsum] frompc 0x%x selfpc 0x%x count %d\n" ,
5084: arc.raw_frompc , arc.raw_selfpc , arc.raw_count );
5085: }
5086: # endif DEBUG
5087: }
5088: }
5089: fclose( sfile );
5090: }
5091:
5092: valcmp(p1, p2)
5093: nltype *p1, *p2;
5094: {
5095: if ( p1 -> value < p2 -> value ) {
5096: return LESSTHAN;
5097: }
5098: if ( p1 -> value > p2 -> value ) {
5099: return GREATERTHAN;
5100: }
5101: return EQUALTO;
5102: }
5103:
5104: readsamples(pfile)
5105: FILE *pfile;
5106: {
5107: register i;
5108: UNIT sample;
5109:
5110: if (samples == 0) {
5111: samples = (UNIT *) calloc(sampbytes, sizeof (UNIT));
5112: if (samples == 0) {
5113: fprintf( stderr , "%s: No room for %d sample pc's\n",
5114: whoami , sampbytes / sizeof (UNIT));
5115: done();
5116: }
5117: }
5118: for (i = 0; i < nsamples; i++) {
5119: fread(&sample, sizeof (UNIT), 1, pfile);
5120: if (feof(pfile))
5121: break;
5122: samples[i] += sample;
5123: }
5124: if (i != nsamples) {
5125: fprintf(stderr,
5126: "%s: unexpected EOF after reading %d/%d samples\n",
5127: whoami , --i , nsamples );
5128: done();
5129: }
5130: }
5131:
5132: /*
5133: * Assign samples to the procedures to which they belong.
5134: *
5135: * There are three cases as to where pcl and pch can be
5136: * with respect to the routine entry addresses svalue0 and svalue1
5137: * as shown in the following diagram. overlap computes the
5138: * distance between the arrows, the fraction of the sample
5139: * that is to be credited to the routine which starts at svalue0.
5140: *
5141: * svalue0 svalue1
5142: * | |
5143: * v v
5144: *
5145: * +-----------------------------------------------+
5146: * | |
5147: * | ->| |<- ->| |<- ->| |<- |
5148: * | | | | | |
5149: * +---------+ +---------+ +---------+
5150: *
5151: * ^ ^ ^ ^ ^ ^
5152: * | | | | | |
5153: * pcl pch pcl pch pcl pch
5154: *
5155: * For the vax we assert that samples will never fall in the first
5156: * two bytes of any routine, since that is the entry mask,
5157: * thus we give call alignentries() to adjust the entry points if
5158: * the entry mask falls in one bucket but the code for the routine
5159: * doesn't start until the next bucket. In conjunction with the
5160: * alignment of routine addresses, this should allow us to have
5161: * only one sample for every four bytes of text space and never
5162: * have any overlap (the two end cases, above).
5163: */
5164: asgnsamples()
5165: {
5166: register int j;
5167: UNIT ccnt;
5168: double time;
5169: unsigned long pcl, pch;
5170: register int i;
5171: unsigned long overlap;
5172: unsigned long svalue0, svalue1;
5173:
5174: /* read samples and assign to namelist symbols */
5175: scale = highpc - lowpc;
5176: scale /= nsamples;
5177: alignentries();
5178: for (i = 0, j = 1; i < nsamples; i++) {
5179: ccnt = samples[i];
5180: if (ccnt == 0)
5181: continue;
5182: pcl = lowpc + scale * i;
5183: pch = lowpc + scale * (i + 1);
5184: time = ccnt;
5185: # ifdef DEBUG
5186: if ( debug & SAMPLEDEBUG ) {
5187: printf( "[asgnsamples] pcl 0x%x pch 0x%x ccnt %d\n" ,
5188: pcl , pch , ccnt );
5189: }
5190: # endif DEBUG
5191: totime += time;
5192: for (j = j - 1; j < nname; j++) {
5193: svalue0 = nl[j].svalue;
5194: svalue1 = nl[j+1].svalue;
5195: /*
5196: * if high end of tick is below entry address,
5197: * go for next tick.
5198: */
5199: if (pch < svalue0)
5200: break;
5201: /*
5202: * if low end of tick into next routine,
5203: * go for next routine.
5204: */
5205: if (pcl >= svalue1)
5206: continue;
5207: overlap = min(pch, svalue1) - max(pcl, svalue0);
5208: if (overlap > 0) {
5209: # ifdef DEBUG
5210: if (debug & SAMPLEDEBUG) {
5211: printf("[asgnsamples] (0x%x->0x%x-0x%x) %s gets %f ticks %d overlap\n",
5212: nl[j].value/sizeof(UNIT), svalue0, svalue1,
5213: nl[j].name,
5214: overlap * time / scale, overlap);
5215: }
5216: # endif DEBUG
5217: nl[j].time += overlap * time / scale;
5218: }
5219: }
5220: }
5221: # ifdef DEBUG
5222: if (debug & SAMPLEDEBUG) {
5223: printf("[asgnsamples] totime %f\n", totime);
5224: }
5225: # endif DEBUG
5226: }
5227:
5228:
5229: unsigned long
5230: min(a, b)
5231: unsigned long a,b;
5232: {
5233: if (a<b)
5234: return(a);
5235: return(b);
5236: }
5237:
5238: unsigned long
5239: max(a, b)
5240: unsigned long a,b;
5241: {
5242: if (a>b)
5243: return(a);
5244: return(b);
5245: }
5246:
5247: /*
5248: * calculate scaled entry point addresses (to save time in asgnsamples),
5249: * and possibly push the scaled entry points over the entry mask,
5250: * if it turns out that the entry point is in one bucket and the code
5251: * for a routine is in the next bucket.
5252: */
5253: alignentries()
5254: {
5255: register struct nl *nlp;
5256: unsigned long bucket_of_entry;
5257: unsigned long bucket_of_code;
5258:
5259: for (nlp = nl; nlp < npe; nlp++) {
5260: nlp -> svalue = nlp -> value / sizeof(UNIT);
5261: bucket_of_entry = (nlp->svalue - lowpc) / scale;
5262: bucket_of_code = (nlp->svalue + UNITS_TO_CODE - lowpc) / scale;
5263: if (bucket_of_entry < bucket_of_code) {
5264: # ifdef DEBUG
5265: if (debug & SAMPLEDEBUG) {
5266: printf("[alignentries] pushing svalue 0x%x to 0x%x\n",
5267: nlp->svalue, nlp->svalue + UNITS_TO_CODE);
5268: }
5269: # endif DEBUG
5270: nlp->svalue += UNITS_TO_CODE;
5271: }
5272: }
5273: }
5274:
5275: bool
5276: funcsymbol( nlistp )
5277: struct nlist *nlistp;
5278: {
5279: extern char *strtab; /* string table from a.out */
5280: extern int aflag; /* if static functions aren't desired */
5281: char *name;
5282:
5283: /*
5284: * must be a text symbol,
5285: * and static text symbols don't qualify if aflag set.
5286: */
5287: if ( ! ( ( nlistp -> n_type == ( N_TEXT | N_EXT ) )
5288: || ( ( nlistp -> n_type == N_TEXT ) && ( aflag == 0 ) ) ) ) {
5289: return FALSE;
5290: }
5291: /*
5292: * can't have any `funny' characters in name,
5293: * where `funny' includes `.', .o file names
5294: * and `$', pascal labels.
5295: */
5296: for ( name = strtab + nlistp -> n_un.n_strx ; *name ; name += 1 ) {
5297: if ( *name == '.' || *name == '$' ) {
5298: return FALSE;
5299: }
5300: }
5301: return TRUE;
5302: }
5303:
5304: done()
5305: {
5306:
5307: exit(0);
5308: }
5309: @
5310:
5311:
5312: 1.3
5313: log
5314: @orignally done by donn, ifdef'ed on hp300, went out with hpbsd 1.0.
5315: date: 88/04/11 21:50:52; author: donn; state: Exp; lines added/del: 4/0
5316: It'd take a hell of a lot of work to get gprof -c working, probably not
5317: worth the effort.
5318: @
5319: text
5320: @d86 7
5321: d132 2
5322: a133 1
5323: hz = hertz();
5324: @
5325:
5326:
5327: 1.2
5328: log
5329: @ucb sid 5.3, 1/2/88.
5330: @
5331: text
5332: @d47 4
5333: @
5334:
5335:
5336: 1.1
5337: log
5338: @4.3 release
5339: @
5340: text
5341: @d14 1
5342: a14 1
5343: static char sccsid[] = "@@(#)gprof.c 5.1 (Berkeley) 6/4/85";
5344: d82 5
5345: d176 1
5346: d294 1
5347: a294 1
5348: unsigned char *malloc();
5349: d299 1
5350: a299 1
5351: textspace = malloc( xbuf.a_text );
5352: d371 1
5353: a371 1
5354: nsamples = sampbytes / sizeof (unsigned UNIT);
5355: d395 5
5356: d435 1
5357: a435 1
5358: if (fwrite(samples, sizeof(unsigned UNIT), nsamples, sfile) != nsamples) {
5359: d478 1
5360: a478 1
5361: unsigned UNIT sample;
5362: d481 1
5363: a481 1
5364: samples = (unsigned UNIT *) calloc(sampbytes, sizeof (unsigned UNIT));
5365: d484 1
5366: a484 1
5367: whoami , sampbytes / sizeof (unsigned UNIT));
5368: d489 1
5369: a489 1
5370: fread(&sample, sizeof (unsigned UNIT), 1, pfile);
5371: d537 1
5372: a537 1
5373: unsigned UNIT ccnt;
5374: @
5375:
5376:
5377: /* read samples and assign to namelist symbols */
5378: scale = highpc - lowpc;
5379: scale /= nsamples;
5380: alignentries();
5381: for (i = 0, j = 1; i < nsamples; i++) {
5382: ccnt = samples[i];
5383: if (ccnt == 0)
5384: continue;
5385: pcl = lowpc + scale * i;
5386: pch = lowpc + scale * (i + 1);
5387: time = ccnt;
5388: # ifdef DEBUG
5389: if ( debug & SAMPLEDEBUG ) {
5390: printf( "[asgnsamples] pcl 0x%x pch 0x%x ccnt %d\n" ,
5391: pcl , pch , ccnt );
5392: }
5393: # endif DEBUG
5394: totime += time;
5395: for (j = j - 1; j gprof/RCS/gprof.h,v 444 14 12 17117 4341435175 7404 head 1.3;
5396: access ;
5397: symbols ;
5398: locks ; strict;
5399: comment @ * @;
5400:
5401:
5402: 1.3
5403: date 88.11.19.20.22.09; author lepreau; state Exp;
5404: branches ;
5405: next 1.2;
5406:
5407: 1.2
5408: date 88.11.19.20.21.29; author lepreau; state Exp;
5409: branches ;
5410: next 1.1;
5411:
5412: 1.1
5413: date 88.11.19.19.57.31; author lepreau; state Rel;
5414: branches ;
5415: next ;
5416:
5417:
5418: desc
5419: @@
5420:
5421:
5422: 1.3
5423: log
5424: @add hp300.h, originally done by Donn on 4/11/88; went out with hpbsd 1.0.
5425: @
5426: text
5427: @/*
5428: * Copyright (c) 1983 Regents of the University of California.
5429: * All rights reserved. The Berkeley software License Agreement
5430: * specifies the terms and conditions for redistribution.
5431: *
5432: * @@(#)gprof.h 5.4 (Berkeley) 1/2/88
5433: */
5434:
5435: #include <stdio.h>
5436: #include <sys/types.h>
5437: #include <sys/stat.h>
5438: #include <a.out.h>
5439: #include "gcrt0.h"
5440:
5441: #if vax
5442: # include "vax.h"
5443: #endif
5444: #if sun
5445: # include "sun.h"
5446: #endif
5447: #if tahoe
5448: # include "tahoe.h"
5449: #endif
5450: #if hp300
5451: # include "hp300.h"
5452: #endif
5453:
5454:
5455: /*
5456: * who am i, for error messages.
5457: */
5458: char *whoami;
5459:
5460: /*
5461: * booleans
5462: */
5463: typedef int bool;
5464: #define FALSE 0
5465: #define TRUE 1
5466:
5467: /*
5468: * ticks per second
5469: */
5470: long hz;
5471:
5472: typedef u_short UNIT; /* unit of profiling */
5473: char *a_outname;
5474: #define A_OUTNAME "a.out"
5475:
5476: char *gmonname;
5477: #define GMONNAME "gmon.out"
5478: #define GMONSUM "gmon.sum"
5479:
5480: /*
5481: * blurbs on the flat and graph profiles.
5482: */
5483: #define FLAT_BLURB "/usr/lib/gprof.flat"
5484: #define CALLG_BLURB "/usr/lib/gprof.callg"
5485:
5486: /*
5487: * a constructed arc,
5488: * with pointers to the namelist entry of the parent and the child,
5489: * a count of how many times this arc was traversed,
5490: * and pointers to the next parent of this child and
5491: * the next child of this parent.
5492: */
5493: struct arcstruct {
5494: struct nl *arc_parentp; /* pointer to parent's nl entry */
5495: struct nl *arc_childp; /* pointer to child's nl entry */
5496: long arc_count; /* how calls from parent to child */
5497: double arc_time; /* time inherited along arc */
5498: double arc_childtime; /* childtime inherited along arc */
5499: struct arcstruct *arc_parentlist; /* parents-of-this-child list */
5500: struct arcstruct *arc_childlist; /* children-of-this-parent list */
5501: };
5502: typedef struct arcstruct arctype;
5503:
5504: /*
5505: * The symbol table;
5506: * for each external in the specified file we gather
5507: * its address, the number of calls and compute its share of cpu time.
5508: */
5509: struct nl {
5510: char *name; /* the name */
5511: unsigned long value; /* the pc entry point */
5512: unsigned long svalue; /* entry point aligned to histograms */
5513: double time; /* ticks in this routine */
5514: double childtime; /* cumulative ticks in children */
5515: long ncall; /* how many times called */
5516: long selfcalls; /* how many calls to self */
5517: double propfraction; /* what % of time propagates */
5518: double propself; /* how much self time propagates */
5519: double propchild; /* how much child time propagates */
5520: bool printflag; /* should this be printed? */
5521: int index; /* index in the graph list */
5522: int toporder; /* graph call chain top-sort order */
5523: int cycleno; /* internal number of cycle on */
5524: struct nl *cyclehead; /* pointer to head of cycle */
5525: struct nl *cnext; /* pointer to next member of cycle */
5526: arctype *parents; /* list of caller arcs */
5527: arctype *children; /* list of callee arcs */
5528: };
5529: typedef struct nl nltype;
5530:
5531: nltype *nl; /* the whole namelist */
5532: nltype *npe; /* the virtual end of the namelist */
5533: int nname; /* the number of function names */
5534:
5535: /*
5536: * flag which marks a nl entry as topologically ``busy''
5537: * flag which marks a nl entry as topologically ``not_numbered''
5538: */
5539: #define DFN_BUSY -1
5540: #define DFN_NAN 0
5541:
5542: /*
5543: * namelist entries for cycle headers.
5544: * the number of discovered cycles.
5545: */
5546: nltype *cyclenl; /* cycle header namelist */
5547: int ncycle; /* number of cycles discovered */
5548:
5549: /*
5550: * The header on the gmon.out file.
5551: * gmon.out consists of one of these headers,
5552: * and then an array of ncnt samples
5553: * representing the discretized program counter values.
5554: * this should be a struct phdr, but since everything is done
5555: * as UNITs, this is in UNITs too.
5556: */
5557: struct hdr {
5558: UNIT *lowpc;
5559: UNIT *highpc;
5560: int ncnt;
5561: };
5562:
5563: struct hdr h;
5564:
5565: int debug;
5566:
5567: /*
5568: * Each discretized pc sample has
5569: * a count of the number of samples in its range
5570: */
5571: UNIT *samples;
5572:
5573: unsigned long s_lowpc; /* lowpc from the profile file */
5574: unsigned long s_highpc; /* highpc from the profile file */
5575: unsigned lowpc, highpc; /* range profiled, in UNIT's */
5576: unsigned sampbytes; /* number of bytes of samples */
5577: int nsamples; /* number of samples */
5578: double actime; /* accumulated time thus far for putprofline */
5579: double totime; /* total time for all routines */
5580: double printtime; /* total of time being printed */
5581: double scale; /* scale factor converting samples to pc
5582: values: each sample covers scale bytes */
5583: char *strtab; /* string table in core */
5584: off_t ssiz; /* size of the string table */
5585: struct exec xbuf; /* exec header of a.out */
5586: unsigned char *textspace; /* text space of a.out in core */
5587:
5588: /*
5589: * option flags, from a to z.
5590: */
5591: bool aflag; /* suppress static functions */
5592: bool bflag; /* blurbs, too */
5593: bool cflag; /* discovered call graph, too */
5594: bool dflag; /* debugging options */
5595: bool eflag; /* specific functions excluded */
5596: bool Eflag; /* functions excluded with time */
5597: bool fflag; /* specific functions requested */
5598: bool Fflag; /* functions requested with time */
5599: bool kflag; /* arcs to be deleted */
5600: bool sflag; /* sum multiple gmon.out files */
5601: bool zflag; /* zero time/called functions, too */
5602:
5603: /*
5604: * structure for various string lists
5605: */
5606: struct stringlist {
5607: struct stringlist *next;
5608: char *string;
5609: };
5610: struct stringlist *elist;
5611: struct stringlist *Elist;
5612: struct stringlist *flist;
5613: struct stringlist *Flist;
5614: struct stringlist *kfromlist;
5615: struct stringlist *ktolist;
5616:
5617: /*
5618: * function declarations
5619: */
5620: /*
5621: addarc();
5622: */
5623: int arccmp();
5624: arctype *arclookup();
5625: /*
5626: asgnsamples();
5627: printblurb();
5628: cyclelink();
5629: dfn();
5630: */
5631: bool dfn_busy();
5632: /*
5633: dfn_findcycle();
5634: */
5635: bool dfn_numbered();
5636: /*
5637: dfn_post_visit();
5638: dfn_pre_visit();
5639: dfn_self_cycle();
5640: */
5641: nltype **doarcs();
5642: /*
5643: done();
5644: findcalls();
5645: flatprofheader();
5646: flatprofline();
5647: */
5648: bool funcsymbol();
5649: /*
5650: getnfile();
5651: getpfile();
5652: getstrtab();
5653: getsymtab();
5654: gettextspace();
5655: gprofheader();
5656: gprofline();
5657: main();
5658: */
5659: unsigned long max();
5660: int membercmp();
5661: unsigned long min();
5662: nltype *nllookup();
5663: FILE *openpfile();
5664: long operandlength();
5665: operandenum operandmode();
5666: char *operandname();
5667: /*
5668: printchildren();
5669: printcycle();
5670: printgprof();
5671: printmembers();
5672: printname();
5673: printparents();
5674: printprof();
5675: readsamples();
5676: */
5677: unsigned long reladdr();
5678: /*
5679: sortchildren();
5680: sortmembers();
5681: sortparents();
5682: tally();
5683: timecmp();
5684: topcmp();
5685: */
5686: int totalcmp();
5687: /*
5688: valcmp();
5689: */
5690:
5691: #define LESSTHAN -1
5692: #define EQUALTO 0
5693: #define GREATERTHAN 1
5694:
5695: #define DFNDEBUG 1
5696: #define CYCLEDEBUG 2
5697: #define ARCDEBUG 4
5698: #define TALLYDEBUG 8
5699: #define TIMEDEBUG 16
5700: #define SAMPLEDEBUG 32
5701: #define AOUTDEBUG 64
5702: #define CALLDEBUG 128
5703: #define LOOKUPDEBUG 256
5704: #define PROPDEBUG 512
5705: #define ANYDEBUG 1024
5706: @
5707:
5708:
5709: 1.2
5710: log
5711: @ucb sid 5.4, 1/2/88.
5712: @
5713: text
5714: @d24 3
5715: @
5716:
5717:
5718: 1.1
5719: log
5720: @4.3 release
5721: @
5722: text
5723: @d6 1
5724: a6 1
5725: * @@(#)gprof.h 5.1 (Berkeley) 6/4/85
5726: d19 1
5727: a19 1
5728: # include "sun.h"
5729: d21 3
5730: d43 1
5731: a43 1
5732: typedef short UNIT; /* unit of profiling */
5733: d50 1
5734: a50 1
5735:
5736: d142 1
5737: a142 1
5738: unsigned UNIT *samples;
5739: d170 1
5740: d185 2
5741: d191 1
5742: d193 1
5743: d196 1
5744: d201 1
5745: d203 1
5746: d205 1
5747: d207 1
5748: d211 1
5749: d213 1
5750: d218 1
5751: d220 1
5752: d229 1
5753: d238 1
5754: d247 1
5755: d249 1
5756: d256 1
5757: d258 1
5758: d260 1
5759: d273 1
5760: a273 1
5761: #define CALLSDEBUG 128
5762: @
5763: */
5764: #define DFN_BUSY -1
5765: #define DFN_NAN 0
5766:
5767: /*
5768: * namelist entries for cycle headers.
5769: * the number of discovered cycles.
5770: */
5771: nltype *cyclenl; /* cycle header namelist */
5772: int ncycle; /* number of cycles discovered */
5773:
5774: /*
5775: * The header on the gmon.out file.
5776: * gmon.out consists of one of these headers,
5777: * and then an array of ncnt samples
5778: * representing the discretized program counter valuesgprof/RCS/printgprof.c,v 444 14 12 44067 4341433537 10460 head 1.2;
5779: access ;
5780: symbols ;
5781: locks ; strict;
5782: comment @ * @;
5783:
5784:
5785: 1.2
5786: date 88.11.19.20.08.36; author lepreau; state Exp;
5787: branches ;
5788: next 1.1;
5789:
5790: 1.1
5791: date 88.11.19.19.57.32; author lepreau; state Rel;
5792: branches ;
5793: next ;
5794:
5795:
5796: desc
5797: @@
5798:
5799:
5800: 1.2
5801: log
5802: @ucb sid 5.3, 1/2/88. went out in hpbsd 1.0
5803: @
5804: text
5805: @/*
5806: * Copyright (c) 1983 Regents of the University of California.
5807: * All rights reserved. The Berkeley software License Agreement
5808: * specifies the terms and conditions for redistribution.
5809: */
5810:
5811: #ifndef lint
5812: static char sccsid[] = "@@(#)printgprof.c 5.3 (Berkeley) 1/2/88";
5813: #endif not lint
5814:
5815: #include "gprof.h"
5816:
5817: printprof()
5818: {
5819: register nltype *np;
5820: nltype **sortednlp;
5821: int index, timecmp();
5822:
5823: actime = 0.0;
5824: printf( "\f\n" );
5825: flatprofheader();
5826: /*
5827: * Sort the symbol table in by time
5828: */
5829: sortednlp = (nltype **) calloc( nname , sizeof(nltype *) );
5830: if ( sortednlp == (nltype **) 0 ) {
5831: fprintf( stderr , "[printprof] ran out of memory for time sorting\n" );
5832: }
5833: for ( index = 0 ; index < nname ; index += 1 ) {
5834: sortednlp[ index ] = &nl[ index ];
5835: }
5836: qsort( sortednlp , nname , sizeof(nltype *) , timecmp );
5837: for ( index = 0 ; index < nname ; index += 1 ) {
5838: np = sortednlp[ index ];
5839: flatprofline( np );
5840: }
5841: actime = 0.0;
5842: cfree( sortednlp );
5843: }
5844:
5845: timecmp( npp1 , npp2 )
5846: nltype **npp1, **npp2;
5847: {
5848: double timediff;
5849: long calldiff;
5850:
5851: timediff = (*npp2) -> time - (*npp1) -> time;
5852: if ( timediff > 0.0 )
5853: return 1 ;
5854: if ( timediff < 0.0 )
5855: return -1;
5856: calldiff = (*npp2) -> ncall - (*npp1) -> ncall;
5857: if ( calldiff > 0 )
5858: return 1;
5859: if ( calldiff < 0 )
5860: return -1;
5861: return( strcmp( (*npp1) -> name , (*npp2) -> name ) );
5862: }
5863:
5864: /*
5865: * header for flatprofline
5866: */
5867: flatprofheader()
5868: {
5869:
5870: if ( bflag ) {
5871: printblurb( FLAT_BLURB );
5872: }
5873: printf( "\ngranularity: each sample hit covers %d byte(s)" ,
5874: (long) scale * sizeof(UNIT) );
5875: if ( totime > 0.0 ) {
5876: printf( " for %.2f%% of %.2f seconds\n\n" ,
5877: 100.0/totime , totime / hz );
5878: } else {
5879: printf( " no time accumulated\n\n" );
5880: /*
5881: * this doesn't hurt sinc eall the numerators will be zero.
5882: */
5883: totime = 1.0;
5884: }
5885: printf( "%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s %-8.8s\n" ,
5886: "% " , "cumulative" , "self " , "" , "self " , "total " , "" );
5887: printf( "%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s %-8.8s\n" ,
5888: "time" , "seconds " , "seconds" , "calls" ,
5889: "ms/call" , "ms/call" , "name" );
5890: }
5891:
5892: flatprofline( np )
5893: register nltype *np;
5894: {
5895:
5896: if ( zflag == 0 && np -> ncall == 0 && np -> time == 0 ) {
5897: return;
5898: }
5899: actime += np -> time;
5900: printf( "%5.1f %10.2f %8.2f" ,
5901: 100 * np -> time / totime , actime / hz , np -> time / hz );
5902: if ( np -> ncall != 0 ) {
5903: printf( " %8d %8.2f %8.2f " , np -> ncall ,
5904: 1000 * np -> time / hz / np -> ncall ,
5905: 1000 * ( np -> time + np -> childtime ) / hz / np -> ncall );
5906: } else {
5907: printf( " %8.8s %8.8s %8.8s " , "" , "" , "" );
5908: }
5909: printname( np );
5910: printf( "\n" );
5911: }
5912:
5913: gprofheader()
5914: {
5915:
5916: if ( bflag ) {
5917: printblurb( CALLG_BLURB );
5918: }
5919: printf( "\ngranularity: each sample hit covers %d byte(s)" ,
5920: (long) scale * sizeof(UNIT) );
5921: if ( printtime > 0.0 ) {
5922: printf( " for %.2f%% of %.2f seconds\n\n" ,
5923: 100.0/printtime , printtime / hz );
5924: } else {
5925: printf( " no time propagated\n\n" );
5926: /*
5927: * this doesn't hurt, since all the numerators will be 0.0
5928: */
5929: printtime = 1.0;
5930: }
5931: printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s %-8.8s\n" ,
5932: "" , "" , "" , "" , "called" , "total" , "parents");
5933: printf( "%-6.6s %5.5s %7.7s %11.11s %7.7s+%-7.7s %-8.8s\t%5.5s\n" ,
5934: "index" , "%time" , "self" , "descendents" ,
5935: "called" , "self" , "name" , "index" );
5936: printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s %-8.8s\n" ,
5937: "" , "" , "" , "" , "called" , "total" , "children");
5938: printf( "\n" );
5939: }
5940:
5941: gprofline( np )
5942: register nltype *np;
5943: {
5944: char kirkbuffer[ BUFSIZ ];
5945:
5946: sprintf( kirkbuffer , "[%d]" , np -> index );
5947: printf( "%-6.6s %5.1f %7.2f %11.2f" ,
5948: kirkbuffer ,
5949: 100 * ( np -> propself + np -> propchild ) / printtime ,
5950: np -> propself / hz ,
5951: np -> propchild / hz );
5952: if ( ( np -> ncall + np -> selfcalls ) != 0 ) {
5953: printf( " %7d" , np -> ncall );
5954: if ( np -> selfcalls != 0 ) {
5955: printf( "+%-7d " , np -> selfcalls );
5956: } else {
5957: printf( " %7.7s " , "" );
5958: }
5959: } else {
5960: printf( " %7.7s %7.7s " , "" , "" );
5961: }
5962: printname( np );
5963: printf( "\n" );
5964: }
5965:
5966: printgprof(timesortnlp)
5967: nltype **timesortnlp;
5968: {
5969: int index;
5970: nltype *parentp;
5971:
5972: /*
5973: * Print out the structured profiling list
5974: */
5975: gprofheader();
5976: for ( index = 0 ; index < nname + ncycle ; index ++ ) {
5977: parentp = timesortnlp[ index ];
5978: if ( zflag == 0 &&
5979: parentp -> ncall == 0 &&
5980: parentp -> selfcalls == 0 &&
5981: parentp -> propself == 0 &&
5982: parentp -> propchild == 0 ) {
5983: continue;
5984: }
5985: if ( ! parentp -> printflag ) {
5986: continue;
5987: }
5988: if ( parentp -> name == 0 && parentp -> cycleno != 0 ) {
5989: /*
5990: * cycle header
5991: */
5992: printcycle( parentp );
5993: printmembers( parentp );
5994: } else {
5995: printparents( parentp );
5996: gprofline( parentp );
5997: printchildren( parentp );
5998: }
5999: printf( "\n" );
6000: printf( "-----------------------------------------------\n" );
6001: printf( "\n" );
6002: }
6003: cfree( timesortnlp );
6004: }
6005:
6006: /*
6007: * sort by decreasing propagated time
6008: * if times are equal, but one is a cycle header,
6009: * say that's first (e.g. less, i.e. -1).
6010: * if one's name doesn't have an underscore and the other does,
6011: * say the one is first.
6012: * all else being equal, sort by names.
6013: */
6014: int
6015: totalcmp( npp1 , npp2 )
6016: nltype **npp1;
6017: nltype **npp2;
6018: {
6019: register nltype *np1 = *npp1;
6020: register nltype *np2 = *npp2;
6021: double diff;
6022:
6023: diff = ( np1 -> propself + np1 -> propchild )
6024: - ( np2 -> propself + np2 -> propchild );
6025: if ( diff < 0.0 )
6026: return 1;
6027: if ( diff > 0.0 )
6028: return -1;
6029: if ( np1 -> name == 0 && np1 -> cycleno != 0 )
6030: return -1;
6031: if ( np2 -> name == 0 && np2 -> cycleno != 0 )
6032: return 1;
6033: if ( np1 -> name == 0 )
6034: return -1;
6035: if ( np2 -> name == 0 )
6036: return 1;
6037: if ( *(np1 -> name) != '_' && *(np2 -> name) == '_' )
6038: return -1;
6039: if ( *(np1 -> name) == '_' && *(np2 -> name) != '_' )
6040: return 1;
6041: if ( np1 -> ncall > np2 -> ncall )
6042: return -1;
6043: if ( np1 -> ncall < np2 -> ncall )
6044: return 1;
6045: return strcmp( np1 -> name , np2 -> name );
6046: }
6047:
6048: printparents( childp )
6049: nltype *childp;
6050: {
6051: nltype *parentp;
6052: arctype *arcp;
6053: nltype *cycleheadp;
6054:
6055: if ( childp -> cyclehead != 0 ) {
6056: cycleheadp = childp -> cyclehead;
6057: } else {
6058: cycleheadp = childp;
6059: }
6060: if ( childp -> parents == 0 ) {
6061: printf( "%6.6s %5.5s %7.7s %11.11s %7.7s %7.7s <spontaneous>\n" ,
6062: "" , "" , "" , "" , "" , "" );
6063: return;
6064: }
6065: sortparents( childp );
6066: for ( arcp = childp -> parents ; arcp ; arcp = arcp -> arc_parentlist ) {
6067: parentp = arcp -> arc_parentp;
6068: if ( childp == parentp ||
6069: ( childp->cycleno != 0 && parentp->cycleno == childp->cycleno ) ) {
6070: /*
6071: * selfcall or call among siblings
6072: */
6073: printf( "%6.6s %5.5s %7.7s %11.11s %7d %7.7s " ,
6074: "" , "" , "" , "" ,
6075: arcp -> arc_count , "" );
6076: printname( parentp );
6077: printf( "\n" );
6078: } else {
6079: /*
6080: * regular parent of child
6081: */
6082: printf( "%6.6s %5.5s %7.2f %11.2f %7d/%-7d " ,
6083: "" , "" ,
6084: arcp -> arc_time / hz , arcp -> arc_childtime / hz ,
6085: arcp -> arc_count , cycleheadp -> ncall );
6086: printname( parentp );
6087: printf( "\n" );
6088: }
6089: }
6090: }
6091:
6092: printchildren( parentp )
6093: nltype *parentp;
6094: {
6095: nltype *childp;
6096: arctype *arcp;
6097:
6098: sortchildren( parentp );
6099: arcp = parentp -> children;
6100: for ( arcp = parentp -> children ; arcp ; arcp = arcp -> arc_childlist ) {
6101: childp = arcp -> arc_childp;
6102: if ( childp == parentp ||
6103: ( childp->cycleno != 0 && childp->cycleno == parentp->cycleno ) ) {
6104: /*
6105: * self call or call to sibling
6106: */
6107: printf( "%6.6s %5.5s %7.7s %11.11s %7d %7.7s " ,
6108: "" , "" , "" , "" , arcp -> arc_count , "" );
6109: printname( childp );
6110: printf( "\n" );
6111: } else {
6112: /*
6113: * regular child of parent
6114: */
6115: printf( "%6.6s %5.5s %7.2f %11.2f %7d/%-7d " ,
6116: "" , "" ,
6117: arcp -> arc_time / hz , arcp -> arc_childtime / hz ,
6118: arcp -> arc_count , childp -> cyclehead -> ncall );
6119: printname( childp );
6120: printf( "\n" );
6121: }
6122: }
6123: }
6124:
6125: printname( selfp )
6126: nltype *selfp;
6127: {
6128:
6129: if ( selfp -> name != 0 ) {
6130: printf( "%s" , selfp -> name );
6131: # ifdef DEBUG
6132: if ( debug & DFNDEBUG ) {
6133: printf( "{%d} " , selfp -> toporder );
6134: }
6135: if ( debug & PROPDEBUG ) {
6136: printf( "%5.2f%% " , selfp -> propfraction );
6137: }
6138: # endif DEBUG
6139: }
6140: if ( selfp -> cycleno != 0 ) {
6141: printf( " <cycle %d>" , selfp -> cycleno );
6142: }
6143: if ( selfp -> index != 0 ) {
6144: if ( selfp -> printflag ) {
6145: printf( " [%d]" , selfp -> index );
6146: } else {
6147: printf( " (%d)" , selfp -> index );
6148: }
6149: }
6150: }
6151:
6152: sortchildren( parentp )
6153: nltype *parentp;
6154: {
6155: arctype *arcp;
6156: arctype *detachedp;
6157: arctype sorted;
6158: arctype *prevp;
6159:
6160: /*
6161: * unlink children from parent,
6162: * then insertion sort back on to sorted's children.
6163: * *arcp the arc you have detached and are inserting.
6164: * *detachedp the rest of the arcs to be sorted.
6165: * sorted arc list onto which you insertion sort.
6166: * *prevp arc before the arc you are comparing.
6167: */
6168: sorted.arc_childlist = 0;
6169: for ( (arcp = parentp -> children)&&(detachedp = arcp -> arc_childlist);
6170: arcp ;
6171: (arcp = detachedp)&&(detachedp = detachedp -> arc_childlist)) {
6172: /*
6173: * consider *arcp as disconnected
6174: * insert it into sorted
6175: */
6176: for ( prevp = &sorted ;
6177: prevp -> arc_childlist ;
6178: prevp = prevp -> arc_childlist ) {
6179: if ( arccmp( arcp , prevp -> arc_childlist ) != LESSTHAN ) {
6180: break;
6181: }
6182: }
6183: arcp -> arc_childlist = prevp -> arc_childlist;
6184: prevp -> arc_childlist = arcp;
6185: }
6186: /*
6187: * reattach sorted children to parent
6188: */
6189: parentp -> children = sorted.arc_childlist;
6190: }
6191:
6192: sortparents( childp )
6193: nltype *childp;
6194: {
6195: arctype *arcp;
6196: arctype *detachedp;
6197: arctype sorted;
6198: arctype *prevp;
6199:
6200: /*
6201: * unlink parents from child,
6202: * then insertion sort back on to sorted's parents.
6203: * *arcp the arc you have detached and are inserting.
6204: * *detachedp the rest of the arcs to be sorted.
6205: * sorted arc list onto which you insertion sort.
6206: * *prevp arc before the arc you are comparing.
6207: */
6208: sorted.arc_parentlist = 0;
6209: for ( (arcp = childp -> parents)&&(detachedp = arcp -> arc_parentlist);
6210: arcp ;
6211: (arcp = detachedp)&&(detachedp = detachedp -> arc_parentlist)) {
6212: /*
6213: * consider *arcp as disconnected
6214: * insert it into sorted
6215: */
6216: for ( prevp = &sorted ;
6217: prevp -> arc_parentlist ;
6218: prevp = prevp -> arc_parentlist ) {
6219: if ( arccmp( arcp , prevp -> arc_parentlist ) != GREATERTHAN ) {
6220: break;
6221: }
6222: }
6223: arcp -> arc_parentlist = prevp -> arc_parentlist;
6224: prevp -> arc_parentlist = arcp;
6225: }
6226: /*
6227: * reattach sorted arcs to child
6228: */
6229: childp -> parents = sorted.arc_parentlist;
6230: }
6231:
6232: /*
6233: * print a cycle header
6234: */
6235: printcycle( cyclep )
6236: nltype *cyclep;
6237: {
6238: char kirkbuffer[ BUFSIZ ];
6239:
6240: sprintf( kirkbuffer , "[%d]" , cyclep -> index );
6241: printf( "%-6.6s %5.1f %7.2f %11.2f %7d" ,
6242: kirkbuffer ,
6243: 100 * ( cyclep -> propself + cyclep -> propchild ) / printtime ,
6244: cyclep -> propself / hz ,
6245: cyclep -> propchild / hz ,
6246: cyclep -> ncall );
6247: if ( cyclep -> selfcalls != 0 ) {
6248: printf( "+%-7d" , cyclep -> selfcalls );
6249: } else {
6250: printf( " %7.7s" , "" );
6251: }
6252: printf( " <cycle %d as a whole>\t[%d]\n" ,
6253: cyclep -> cycleno , cyclep -> index );
6254: }
6255:
6256: /*
6257: * print the members of a cycle
6258: */
6259: printmembers( cyclep )
6260: nltype *cyclep;
6261: {
6262: nltype *memberp;
6263:
6264: sortmembers( cyclep );
6265: for ( memberp = cyclep -> cnext ; memberp ; memberp = memberp -> cnext ) {
6266: printf( "%6.6s %5.5s %7.2f %11.2f %7d" ,
6267: "" , "" , memberp -> propself / hz , memberp -> propchild / hz ,
6268: memberp -> ncall );
6269: if ( memberp -> selfcalls != 0 ) {
6270: printf( "+%-7d" , memberp -> selfcalls );
6271: } else {
6272: printf( " %7.7s" , "" );
6273: }
6274: printf( " " );
6275: printname( memberp );
6276: printf( "\n" );
6277: }
6278: }
6279:
6280: /*
6281: * sort members of a cycle
6282: */
6283: sortmembers( cyclep )
6284: nltype *cyclep;
6285: {
6286: nltype *todo;
6287: nltype *doing;
6288: nltype *prev;
6289:
6290: /*
6291: * detach cycle members from cyclehead,
6292: * and insertion sort them back on.
6293: */
6294: todo = cyclep -> cnext;
6295: cyclep -> cnext = 0;
6296: for ( (doing = todo)&&(todo = doing -> cnext);
6297: doing ;
6298: (doing = todo )&&(todo = doing -> cnext )){
6299: for ( prev = cyclep ; prev -> cnext ; prev = prev -> cnext ) {
6300: if ( membercmp( doing , prev -> cnext ) == GREATERTHAN ) {
6301: break;
6302: }
6303: }
6304: doing -> cnext = prev -> cnext;
6305: prev -> cnext = doing;
6306: }
6307: }
6308:
6309: /*
6310: * major sort is on propself + propchild,
6311: * next is sort on ncalls + selfcalls.
6312: */
6313: int
6314: membercmp( this , that )
6315: nltype *this;
6316: nltype *that;
6317: {
6318: double thistime = this -> propself + this -> propchild;
6319: double thattime = that -> propself + that -> propchild;
6320: long thiscalls = this -> ncall + this -> selfcalls;
6321: long thatcalls = that -> ncall + that -> selfcalls;
6322:
6323: if ( thistime > thattime ) {
6324: return GREATERTHAN;
6325: }
6326: if ( thistime < thattime ) {
6327: return LESSTHAN;
6328: }
6329: if ( thiscalls > thatcalls ) {
6330: return GREATERTHAN;
6331: }
6332: if ( thiscalls < thatcalls ) {
6333: return LESSTHAN;
6334: }
6335: return EQUALTO;
6336: }
6337: /*
6338: * compare two arcs to/from the same child/parent.
6339: * - if one arc is a self arc, it's least.
6340: * - if one arc is within a cycle, it's less than.
6341: * - if both arcs are within a cycle, compare arc counts.
6342: * - if neither arc is within a cycle, compare with
6343: * arc_time + arc_childtime as major key
6344: * arc count as minor key
6345: */
6346: int
6347: arccmp( thisp , thatp )
6348: arctype *thisp;
6349: arctype *thatp;
6350: {
6351: nltype *thisparentp = thisp -> arc_parentp;
6352: nltype *thischildp = thisp -> arc_childp;
6353: nltype *thatparentp = thatp -> arc_parentp;
6354: nltype *thatchildp = thatp -> arc_childp;
6355: double thistime;
6356: double thattime;
6357:
6358: # ifdef DEBUG
6359: if ( debug & TIMEDEBUG ) {
6360: printf( "[arccmp] " );
6361: printname( thisparentp );
6362: printf( " calls " );
6363: printname ( thischildp );
6364: printf( " %f + %f %d/%d\n" ,
6365: thisp -> arc_time , thisp -> arc_childtime ,
6366: thisp -> arc_count , thischildp -> ncall );
6367: printf( "[arccmp] " );
6368: printname( thatparentp );
6369: printf( " calls " );
6370: printname( thatchildp );
6371: printf( " %f + %f %d/%d\n" ,
6372: thatp -> arc_time , thatp -> arc_childtime ,
6373: thatp -> arc_count , thatchildp -> ncall );
6374: printf( "\n" );
6375: }
6376: # endif DEBUG
6377: if ( thisparentp == thischildp ) {
6378: /* this is a self call */
6379: return LESSTHAN;
6380: }
6381: if ( thatparentp == thatchildp ) {
6382: /* that is a self call */
6383: return GREATERTHAN;
6384: }
6385: if ( thisparentp -> cycleno != 0 && thischildp -> cycleno != 0 &&
6386: thisparentp -> cycleno == thischildp -> cycleno ) {
6387: /* this is a call within a cycle */
6388: if ( thatparentp -> cycleno != 0 && thatchildp -> cycleno != 0 &&
6389: thatparentp -> cycleno == thatchildp -> cycleno ) {
6390: /* that is a call within the cycle, too */
6391: if ( thisp -> arc_count < thatp -> arc_count ) {
6392: return LESSTHAN;
6393: }
6394: if ( thisp -> arc_count > thatp -> arc_count ) {
6395: return GREATERTHAN;
6396: }
6397: return EQUALTO;
6398: } else {
6399: /* that isn't a call within the cycle */
6400: return LESSTHAN;
6401: }
6402: } else {
6403: /* this isn't a call within a cycle */
6404: if ( thatparentp -> cycleno != 0 && thatchildp -> cycleno != 0 &&
6405: thatparentp -> cycleno == thatchildp -> cycleno ) {
6406: /* that is a call within a cycle */
6407: return GREATERTHAN;
6408: } else {
6409: /* neither is a call within a cycle */
6410: thistime = thisp -> arc_time + thisp -> arc_childtime;
6411: thattime = thatp -> arc_time + thatp -> arc_childtime;
6412: if ( thistime < thattime )
6413: return LESSTHAN;
6414: if ( thistime > thattime )
6415: return GREATERTHAN;
6416: if ( thisp -> arc_count < thatp -> arc_count )
6417: return LESSTHAN;
6418: if ( thisp -> arc_count > thatp -> arc_count )
6419: return GREATERTHAN;
6420: return EQUALTO;
6421: }
6422: }
6423: }
6424:
6425: printblurb( blurbname )
6426: char *blurbname;
6427: {
6428: FILE *blurbfile;
6429: int input;
6430:
6431: blurbfile = fopen( blurbname , "r" );
6432: if ( blurbfile == NULL ) {
6433: perror( blurbname );
6434: return;
6435: }
6436: while ( ( input = getc( blurbfile ) ) != EOF ) {
6437: putchar( input );
6438: }
6439: fclose( blurbfile );
6440: }
6441:
6442: int
6443: namecmp( npp1 , npp2 )
6444: nltype **npp1, **npp2;
6445: {
6446: return( strcmp( (*npp1) -> name , (*npp2) -> name ) );
6447: }
6448:
6449: printindex()
6450: {
6451: nltype **namesortnlp;
6452: register nltype *nlp;
6453: int index, nnames, todo, i, j;
6454: char peterbuffer[ BUFSIZ ];
6455:
6456: /*
6457: * Now, sort regular function name alphbetically
6458: * to create an index.
6459: */
6460: namesortnlp = (nltype **) calloc( nname + ncycle , sizeof(nltype *) );
6461: if ( namesortnlp == (nltype **) 0 ) {
6462: fprintf( stderr , "%s: ran out of memory for sorting\n" , whoami );
6463: }
6464: for ( index = 0 , nnames = 0 ; index < nname ; index++ ) {
6465: if ( zflag == 0 && nl[index].ncall == 0 && nl[index].time == 0 )
6466: continue;
6467: namesortnlp[nnames++] = &nl[index];
6468: }
6469: qsort( namesortnlp , nnames , sizeof(nltype *) , namecmp );
6470: for ( index = 1 , todo = nnames ; index <= ncycle ; index++ ) {
6471: namesortnlp[todo++] = &cyclenl[index];
6472: }
6473: printf( "\f\nIndex by function name\n\n" );
6474: index = ( todo + 2 ) / 3;
6475: for ( i = 0; i < index ; i++ ) {
6476: for ( j = i; j < todo ; j += index ) {
6477: nlp = namesortnlp[ j ];
6478: if ( nlp -> printflag ) {
6479: sprintf( peterbuffer , "[%d]" , nlp -> index );
6480: } else {
6481: sprintf( peterbuffer , "(%d)" , nlp -> index );
6482: }
6483: if ( j < nnames ) {
6484: printf( "%6.6s %-19.19s" , peterbuffer , nlp -> name );
6485: } else {
6486: printf( "%6.6s " , peterbuffer );
6487: sprintf( peterbuffer , "<cycle %d>" , nlp -> cycleno );
6488: printf( "%-19.19s" , peterbuffer );
6489: }
6490: }
6491: printf( "\n" );
6492: }
6493: cfree( namesortnlp );
6494: }
6495: @
6496:
6497:
6498: 1.1
6499: log
6500: @4.3 release
6501: @
6502: text
6503: @d8 1
6504: a8 1
6505: static char sccsid[] = "@@(#)printgprof.c 5.1 (Berkeley) 6/4/85";
6506: d17 1
6507: a17 1
6508: int index;
6509: d128 1
6510: a128 1
6511: "" , "" , "" , "" , "called" , "total" , "parents" , "" );
6512: d133 1
6513: a133 1
6514: "" , "" , "" , "" , "called" , "total" , "children" , "" );
6515: @
6516: ame( thisparentp );
6517: printf( " calls " );
6518: printname ( thischildp );
6519: printf( " %f + %f %d/%d\n" ,
6520: thisp -> arc_time , thisp -> arc_childtime ,
6521: thisp -> arc_count , thischildp -> ncall );
6522: printf( "[arccmp] " );
6523: printname( thatparentp );
6524: printf( " calls " );
6525: printname( thatchildp );
6526: printf( " %f + %f %d/%d\n" ,
6527: thatp -> arc_time , thatp -> arc_childtime ,
6528: thatp -> arc_count , thatchildp -> ncalgprof/RCS/printlist.c,v 444 14 12 4133 4341433623 10260 head 1.2;
6529: access ;
6530: symbols ;
6531: locks ; strict;
6532: comment @ * @;
6533:
6534:
6535: 1.2
6536: date 88.11.19.20.09.47; author lepreau; state Exp;
6537: branches ;
6538: next 1.1;
6539:
6540: 1.1
6541: date 88.11.19.19.57.33; author lepreau; state Rel;
6542: branches ;
6543: next ;
6544:
6545:
6546: desc
6547: @@
6548:
6549:
6550: 1.2
6551: log
6552: @ucb sid 5.2, 4/27/87. Went out in hpbsd 1.0.
6553: @
6554: text
6555: @/*
6556: * Copyright (c) 1983 Regents of the University of California.
6557: * All rights reserved. The Berkeley software License Agreement
6558: * specifies the terms and conditions for redistribution.
6559: */
6560:
6561: #ifndef lint
6562: static char sccsid[] = "@@(#)printlist.c 5.2 (Berkeley) 4/27/87";
6563: #endif not lint
6564:
6565: #include "gprof.h"
6566:
6567: /*
6568: * these are the lists of names:
6569: * there is the list head and then the listname
6570: * is a pointer to the list head
6571: * (for ease of passing to stringlist functions).
6572: */
6573: struct stringlist kfromhead = { 0 , 0 };
6574: struct stringlist *kfromlist = &kfromhead;
6575: struct stringlist ktohead = { 0 , 0 };
6576: struct stringlist *ktolist = &ktohead;
6577: struct stringlist fhead = { 0 , 0 };
6578: struct stringlist *flist = &fhead;
6579: struct stringlist Fhead = { 0 , 0 };
6580: struct stringlist *Flist = &Fhead;
6581: struct stringlist ehead = { 0 , 0 };
6582: struct stringlist *elist = &ehead;
6583: struct stringlist Ehead = { 0 , 0 };
6584: struct stringlist *Elist = &Ehead;
6585:
6586: addlist( listp , funcname )
6587: struct stringlist *listp;
6588: char *funcname;
6589: {
6590: struct stringlist *slp;
6591:
6592: slp = (struct stringlist *) malloc( sizeof(struct stringlist));
6593: if ( slp == (struct stringlist *) 0 ) {
6594: fprintf( stderr, "gprof: ran out room for printlist\n" );
6595: done();
6596: }
6597: slp -> next = listp -> next;
6598: slp -> string = funcname;
6599: listp -> next = slp;
6600: }
6601:
6602: bool
6603: onlist( listp , funcname )
6604: struct stringlist *listp;
6605: char *funcname;
6606: {
6607: struct stringlist *slp;
6608:
6609: for ( slp = listp -> next ; slp ; slp = slp -> next ) {
6610: if ( ! strcmp( slp -> string , funcname ) ) {
6611: return TRUE;
6612: }
6613: if ( funcname[0] == '_' && ! strcmp( slp -> string , &funcname[1] ) ) {
6614: return TRUE;
6615: }
6616: }
6617: return FALSE;
6618: }
6619: @
6620:
6621:
6622: 1.1
6623: log
6624: @4.3 release
6625: @
6626: text
6627: @d8 1
6628: a8 1
6629: static char sccsid[] = "@@(#)printlist.c 5.1 (Berkeley) 6/4/85";
6630: d19 4
6631: @
6632: y
6633: * to create an index.
6634: */
6635: namesortnlp = (nltype **) calloc( nname + ncycle , sizeof(nltype *) );
6636: if ( namesortnlp == (nltype **) 0 ) {
6637: fprintf( stderr , "%s: ran out of memory for sorting\n" , whoami );
6638: }
6639: for ( index = 0 , nnames = 0 ; index < nname ; index++ ) {
6640: if ( zflag == 0 && nl[index].ncall == 0 && nl[index].time == 0 )
6641: continue;
6642: namesortnlp[nnames++] = &nl[index];
6643: }
6644: qsort( namgprof/RCS/vax.c,v 444 14 12 20716 4341433744 7057 head 1.2;
6645: access ;
6646: symbols ;
6647: locks ; strict;
6648: comment @ * @;
6649:
6650:
6651: 1.2
6652: date 88.11.19.20.11.13; author lepreau; state Exp;
6653: branches ;
6654: next 1.1;
6655:
6656: 1.1
6657: date 88.11.19.19.57.29; author lepreau; state Rel;
6658: branches ;
6659: next ;
6660:
6661:
6662: desc
6663: @In 4.3bsd called "calls.c", now renamed to <machine>.c
6664: @
6665:
6666:
6667: 1.2
6668: log
6669: @ucb sid 5.3. 1/7/86. went out in hpbsd 1.0.
6670: @
6671: text
6672: @/*
6673: * Copyright (c) 1983 Regents of the University of California.
6674: * All rights reserved. The Berkeley software License Agreement
6675: * specifies the terms and conditions for redistribution.
6676: */
6677:
6678: #ifndef lint
6679: static char sccsid[] = "@@(#)vax.c 5.3 (Berkeley) 1/7/86";
6680: #endif not lint
6681:
6682: #include "gprof.h"
6683:
6684: /*
6685: * a namelist entry to be the child of indirect calls
6686: */
6687: nltype indirectchild = {
6688: "(*)" , /* the name */
6689: (unsigned long) 0 , /* the pc entry point */
6690: (unsigned long) 0 , /* entry point aligned to histogram */
6691: (double) 0.0 , /* ticks in this routine */
6692: (double) 0.0 , /* cumulative ticks in children */
6693: (long) 0 , /* how many times called */
6694: (long) 0 , /* how many calls to self */
6695: (double) 1.0 , /* propagation fraction */
6696: (double) 0.0 , /* self propagation time */
6697: (double) 0.0 , /* child propagation time */
6698: (bool) 0 , /* print flag */
6699: (int) 0 , /* index in the graph list */
6700: (int) 0 , /* graph call chain top-sort order */
6701: (int) 0 , /* internal number of cycle on */
6702: (struct nl *) &indirectchild , /* pointer to head of cycle */
6703: (struct nl *) 0 , /* pointer to next member of cycle */
6704: (arctype *) 0 , /* list of caller arcs */
6705: (arctype *) 0 /* list of callee arcs */
6706: };
6707:
6708: operandenum
6709: operandmode( modep )
6710: struct modebyte *modep;
6711: {
6712: long usesreg = modep -> regfield;
6713:
6714: switch ( modep -> modefield ) {
6715: case 0:
6716: case 1:
6717: case 2:
6718: case 3:
6719: return literal;
6720: case 4:
6721: return indexed;
6722: case 5:
6723: return reg;
6724: case 6:
6725: return regdef;
6726: case 7:
6727: return autodec;
6728: case 8:
6729: return ( usesreg != PC ? autoinc : immediate );
6730: case 9:
6731: return ( usesreg != PC ? autoincdef : absolute );
6732: case 10:
6733: return ( usesreg != PC ? bytedisp : byterel );
6734: case 11:
6735: return ( usesreg != PC ? bytedispdef : bytereldef );
6736: case 12:
6737: return ( usesreg != PC ? worddisp : wordrel );
6738: case 13:
6739: return ( usesreg != PC ? worddispdef : wordreldef );
6740: case 14:
6741: return ( usesreg != PC ? longdisp : longrel );
6742: case 15:
6743: return ( usesreg != PC ? longdispdef : longreldef );
6744: }
6745: /* NOTREACHED */
6746: }
6747:
6748: char *
6749: operandname( mode )
6750: operandenum mode;
6751: {
6752:
6753: switch ( mode ) {
6754: case literal:
6755: return "literal";
6756: case indexed:
6757: return "indexed";
6758: case reg:
6759: return "register";
6760: case regdef:
6761: return "register deferred";
6762: case autodec:
6763: return "autodecrement";
6764: case autoinc:
6765: return "autoincrement";
6766: case autoincdef:
6767: return "autoincrement deferred";
6768: case bytedisp:
6769: return "byte displacement";
6770: case bytedispdef:
6771: return "byte displacement deferred";
6772: case byterel:
6773: return "byte relative";
6774: case bytereldef:
6775: return "byte relative deferred";
6776: case worddisp:
6777: return "word displacement";
6778: case worddispdef:
6779: return "word displacement deferred";
6780: case wordrel:
6781: return "word relative";
6782: case wordreldef:
6783: return "word relative deferred";
6784: case immediate:
6785: return "immediate";
6786: case absolute:
6787: return "absolute";
6788: case longdisp:
6789: return "long displacement";
6790: case longdispdef:
6791: return "long displacement deferred";
6792: case longrel:
6793: return "long relative";
6794: case longreldef:
6795: return "long relative deferred";
6796: }
6797: /* NOTREACHED */
6798: }
6799:
6800: long
6801: operandlength( modep )
6802: struct modebyte *modep;
6803: {
6804:
6805: switch ( operandmode( modep ) ) {
6806: case literal:
6807: case reg:
6808: case regdef:
6809: case autodec:
6810: case autoinc:
6811: case autoincdef:
6812: return 1;
6813: case bytedisp:
6814: case bytedispdef:
6815: case byterel:
6816: case bytereldef:
6817: return 2;
6818: case worddisp:
6819: case worddispdef:
6820: case wordrel:
6821: case wordreldef:
6822: return 3;
6823: case immediate:
6824: case absolute:
6825: case longdisp:
6826: case longdispdef:
6827: case longrel:
6828: case longreldef:
6829: return 5;
6830: case indexed:
6831: return 1+operandlength( (struct modebyte *) ((char *) modep) + 1 );
6832: }
6833: /* NOTREACHED */
6834: }
6835:
6836: unsigned long
6837: reladdr( modep )
6838: struct modebyte *modep;
6839: {
6840: operandenum mode = operandmode( modep );
6841: char *cp;
6842: short *sp;
6843: long *lp;
6844:
6845: cp = (char *) modep;
6846: cp += 1; /* skip over the mode */
6847: switch ( mode ) {
6848: default:
6849: fprintf( stderr , "[reladdr] not relative address\n" );
6850: return (unsigned long) modep;
6851: case byterel:
6852: return (unsigned long) ( cp + sizeof *cp + *cp );
6853: case wordrel:
6854: sp = (short *) cp;
6855: return (unsigned long) ( cp + sizeof *sp + *sp );
6856: case longrel:
6857: lp = (long *) cp;
6858: return (unsigned long) ( cp + sizeof *lp + *lp );
6859: }
6860: }
6861:
6862: findcall( parentp , p_lowpc , p_highpc )
6863: nltype *parentp;
6864: unsigned long p_lowpc;
6865: unsigned long p_highpc;
6866: {
6867: unsigned char *instructp;
6868: long length;
6869: nltype *childp;
6870: operandenum mode;
6871: operandenum firstmode;
6872: unsigned long destpc;
6873:
6874: if ( textspace == 0 ) {
6875: return;
6876: }
6877: if ( p_lowpc < s_lowpc ) {
6878: p_lowpc = s_lowpc;
6879: }
6880: if ( p_highpc > s_highpc ) {
6881: p_highpc = s_highpc;
6882: }
6883: # ifdef DEBUG
6884: if ( debug & CALLDEBUG ) {
6885: printf( "[findcall] %s: 0x%x to 0x%x\n" ,
6886: parentp -> name , p_lowpc , p_highpc );
6887: }
6888: # endif DEBUG
6889: for ( instructp = textspace + p_lowpc ;
6890: instructp < textspace + p_highpc ;
6891: instructp += length ) {
6892: length = 1;
6893: if ( *instructp == CALLS ) {
6894: /*
6895: * maybe a calls, better check it out.
6896: * skip the count of the number of arguments.
6897: */
6898: # ifdef DEBUG
6899: if ( debug & CALLDEBUG ) {
6900: printf( "[findcall]\t0x%x:calls" , instructp - textspace );
6901: }
6902: # endif DEBUG
6903: firstmode = operandmode( (struct modebyte *) (instructp+length) );
6904: switch ( firstmode ) {
6905: case literal:
6906: case immediate:
6907: break;
6908: default:
6909: goto botched;
6910: }
6911: length += operandlength( (struct modebyte *) (instructp+length) );
6912: mode = operandmode( (struct modebyte *) ( instructp + length ) );
6913: # ifdef DEBUG
6914: if ( debug & CALLDEBUG ) {
6915: printf( "\tfirst operand is %s", operandname( firstmode ) );
6916: printf( "\tsecond operand is %s\n" , operandname( mode ) );
6917: }
6918: # endif DEBUG
6919: switch ( mode ) {
6920: case regdef:
6921: case bytedispdef:
6922: case worddispdef:
6923: case longdispdef:
6924: case bytereldef:
6925: case wordreldef:
6926: case longreldef:
6927: /*
6928: * indirect call: call through pointer
6929: * either *d(r) as a parameter or local
6930: * (r) as a return value
6931: * *f as a global pointer
6932: * [are there others that we miss?,
6933: * e.g. arrays of pointers to functions???]
6934: */
6935: addarc( parentp , &indirectchild , (long) 0 );
6936: length += operandlength(
6937: (struct modebyte *) ( instructp + length ) );
6938: continue;
6939: case byterel:
6940: case wordrel:
6941: case longrel:
6942: /*
6943: * regular pc relative addressing
6944: * check that this is the address of
6945: * a function.
6946: */
6947: destpc = reladdr( (struct modebyte *) (instructp+length) )
6948: - (unsigned long) textspace;
6949: if ( destpc >= s_lowpc && destpc <= s_highpc ) {
6950: childp = nllookup( destpc );
6951: # ifdef DEBUG
6952: if ( debug & CALLDEBUG ) {
6953: printf( "[findcall]\tdestpc 0x%x" , destpc );
6954: printf( " childp->name %s" , childp -> name );
6955: printf( " childp->value 0x%x\n" ,
6956: childp -> value );
6957: }
6958: # endif DEBUG
6959: if ( childp -> value == destpc ) {
6960: /*
6961: * a hit
6962: */
6963: addarc( parentp , childp , (long) 0 );
6964: length += operandlength( (struct modebyte *)
6965: ( instructp + length ) );
6966: continue;
6967: }
6968: goto botched;
6969: }
6970: /*
6971: * else:
6972: * it looked like a calls,
6973: * but it wasn't to anywhere.
6974: */
6975: goto botched;
6976: default:
6977: botched:
6978: /*
6979: * something funny going on.
6980: */
6981: # ifdef DEBUG
6982: if ( debug & CALLDEBUG ) {
6983: printf( "[findcall]\tbut it's a botch\n" );
6984: }
6985: # endif DEBUG
6986: length = 1;
6987: continue;
6988: }
6989: }
6990: }
6991: }
6992: @
6993:
6994:
6995: 1.1
6996: log
6997: @4.3 release
6998: @
6999: text
7000: @d8 1
7001: a8 1
7002: static char sccsid[] = "@@(#)calls.c 5.1 (Berkeley) 6/4/85";
7003: d191 1
7004: a191 1
7005: findcalls( parentp , p_lowpc , p_highpc )
7006: d213 2
7007: a214 2
7008: if ( debug & CALLSDEBUG ) {
7009: printf( "[findcalls] %s: 0x%x to 0x%x\n" ,
7010: d228 2
7011: a229 2
7012: if ( debug & CALLSDEBUG ) {
7013: printf( "[findcalls]\t0x%x:calls" , instructp - textspace );
7014: d243 1
7015: a243 1
7016: if ( debug & CALLSDEBUG ) {
7017: d281 2
7018: a282 2
7019: if ( debug & CALLSDEBUG ) {
7020: printf( "[findcalls]\tdestpc 0x%x" , destpc );
7021: d311 2
7022: a312 2
7023: if ( debug & CALLSDEBUG ) {
7024: printf( "[findcalls]\tbut it's a botch\n" );
7025: @
7026: terel:
7027: return (unsigned long) ( cp + sizeof *gprof/makefile 444 22 12 770 4227233605 6656 #
7028: # Copyright (c) 1983 Regents of the University of California.
7029: # All rights reserved. The Berkeley software License Agreement
7030: # specifies the terms and conditions for redistribution.
7031: #
7032: # @(#)makefile 5.1 (Berkeley) 10/14/86
7033: #
7034: DESTDIR=
7035: MACHINE=`machine`
7036:
7037: .c.o:
7038: make -f Makefile ${MFLAGS} MACHINE=${MACHINE} $*.o
7039:
7040: all: FRC
7041: make -f Makefile ${MFLAGS} MACHINE=${MACHINE}
7042:
7043: FRC:
7044:
7045: install:
7046: make -f Makefile ${MFLAGS} MACHINE=${MACHINE} install
7047:
7048: clean:
7049: make -f Makefile ${MFLAGS} MACHINE=${MACHINE} clean
7050: of.o gprof/hp300.c 444 22 12 276 4230223517 6150 #include "gprof.h"
7051:
7052: /*
7053: * gprof -c isn't currently supported...
7054: */
7055: findcall( parentp , p_lowpc , p_highpc )
7056: nltype *parentp;
7057: unsigned long p_lowpc;
7058: unsigned long p_highpc;
7059: {
7060: }
7061: lookup.c �> tahoe.c �?
7062: gprof.flat �@ vax.h �A gprof.callg �B tahoe.h �C vax.c �D hp300.h r3 RCS �E makefile �F hp300.c �G � gcrt0.h ä gprof.o å arcs.o æ dfn.o ç lookup.o è hp300.o é hertz.o ê printgprof.o gprof/gcrt0.h 444 22 12 3637 4231040575 6370 /*
7063: * Copyright (c) 1980 Regents of the University of California.
7064: * All rights reserved. The Berkeley software License Agreement
7065: * specifies the terms and conditions for redistribution.
7066: *
7067: * @(#)gmon.h 5.1 (Berkeley) 5/30/85
7068: */
7069:
7070: struct phdr {
7071: char *lpc;
7072: char *hpc;
7073: int ncnt;
7074: };
7075:
7076: /*
7077: * histogram counters are unsigned shorts (according to the kernel).
7078: */
7079: #define HISTCOUNTER unsigned short
7080:
7081: /*
7082: * fraction of text space to allocate for histogram counters
7083: * here, 1/2
7084: */
7085: #define HISTFRACTION 2
7086:
7087: /*
7088: * Fraction of text space to allocate for from hash buckets.
7089: * The value of HASHFRACTION is based on the minimum number of bytes
7090: * of separation between two subroutine call points in the object code.
7091: * Given MIN_SUBR_SEPARATION bytes of separation the value of
7092: * HASHFRACTION is calculated as:
7093: *
7094: * HASHFRACTION = MIN_SUBR_SEPARATION / (2 * sizeof(short) - 1);
7095: *
7096: * For the VAX, the shortest two call sequence is:
7097: *
7098: * calls $0,(r0)
7099: * calls $0,(r0)
7100: *
7101: * which is separated by only three bytes, thus HASHFRACTION is
7102: * calculated as:
7103: *
7104: * HASHFRACTION = 3 / (2 * 2 - 1) = 1
7105: *
7106: * Note that the division above rounds down, thus if MIN_SUBR_FRACTION
7107: * is less than three, this algorithm will not work!
7108: */
7109: #define HASHFRACTION 1
7110:
7111: /*
7112: * percent of text space to allocate for tostructs
7113: * with a minimum.
7114: */
7115: #define ARCDENSITY 2
7116: #define MINARCS 50
7117:
7118: struct tostruct {
7119: char *selfpc;
7120: long count;
7121: unsigned short link;
7122: };
7123:
7124: /*
7125: * a raw arc,
7126: * with pointers to the calling site and the called site
7127: * and a count.
7128: */
7129: struct rawarc {
7130: unsigned long raw_frompc;
7131: unsigned long raw_selfpc;
7132: long raw_count;
7133: };
7134:
7135: /*
7136: * general rounding functions.
7137: */
7138: #define ROUNDDOWN(x,y) (((x)/(y))*(y))
7139: #define ROUNDUP(x,y) ((((x)+(y)-1)/(y))*(y))
7140: hort
7141:
7142: /*
7143: * fraction of text space to allocate for histogram counters
7144: * here, 1/2
7145: #include "gprof.h"
7146:
7147: /*
7148: * gprof -c isn't currently supported...
7149: */
7150: findcall( parentp , p_lowpc , p_highpc )
7151: nltype *parentp;
7152: unsigned long p_lowpc;
7153: unsigned long p_highpc;
7154: {
7155: }
7156: lookup.c �> tahoe.c �?
7157: gprof.flat �@ vax.h �A gprof.callg �B tahoe.h �C vax.c �D hp300.h r3 RCS �E makefile �F hp300.c �G � gcrt0.h ä gprof.o å arcs.o æ dfn.o ç lookup.o è hp300.o é hertz.o ê printgprof.o gprof/gcrt0.h 444 22 12 3637 4231040575 6370 /*
7158: * Copyright (c) 1980 Regents of the University of California.
7159: * All rights reserved. The Berkeley software License Agreement
7160: * specifies the terms and conditions for redistribution.
7161: *
7162: * @(#)gmon.h 5.1 (Berkeley) 5/30/85
7163: */
7164:
7165: struct phdr {
7166: char *lpc;
7167: char *hpc;
7168: int ncnt;
7169: };
7170:
7171: /*
7172: * histogram counters are unsigned shorts (according to the kernel).
7173: */
7174: #define HISTCOUNTER unsigned short
7175:
7176: /*
7177: * fraction of text space to allocate for histogram counters
7178: * here, 1/2
7179: */
7180: #define HISTFRACTION 2
7181:
7182: /*
7183: * Fraction of text space to allocate for from hash buckets.
7184: * The value of HASHFRACTION is based on the minimum number of bytes
7185: * of separation between two subroutine call points in the object code.
7186: * Given MIN_SUBR_SEPARATION bytes of separation the value of
7187: * HASHFRACTION is calculated as:
7188: *
7189: * HASHFRACTION = MIN_SUBR_SEPARATION / (2 * sizeof(short) - 1);
7190: *
7191: * For the VAX, the shortest two call sequence is:
7192: *
7193: * calls $0,(r0)
7194: * calls $0,(r0)
7195: *
7196: * which is separated by only three bytes, thus HASHFRACTION is
7197: * calculated as:
7198: *
7199: * HASHFRACTION = 3 / (2 * 2 - 1) = 1
7200: *
7201: * Note that the division above rounds down, thus if MIN_SUBR_FRACTION
7202: * is less than three, this algorithm will not work!
7203: */
7204: #define HASHFRACTION 1
7205:
7206: /*
7207: * percent of text space to allocate for tostructs
7208: * with a minimum.
7209: */
7210: #define ARCDENSITY 2
7211: #define MINARCS 50
7212:
7213: struct tostruct {
7214: cha
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.