![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gmon.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / lib / libc / vax / csu|
Return to gmon.c CVS log | Up to [CSRG BSD Unix] / 43BSD / lib / libc / vax / csu |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #if defined(LIBC_SCCS) && !defined(lint)
8: static char sccsid[] = "@(#)gmon.c 5.3 (Berkeley) 3/9/86";
9: #endif LIBC_SCCS and not lint
10:
11: #ifdef DEBUG
12: #include <stdio.h>
13: #endif DEBUG
14:
15: #include "gmon.h"
16:
17: /*
18: * froms is actually a bunch of unsigned shorts indexing tos
19: */
20: static int profiling = 3;
21: static unsigned short *froms;
22: static struct tostruct *tos = 0;
23: static long tolimit = 0;
24: static char *s_lowpc = 0;
25: static char *s_highpc = 0;
26: static unsigned long s_textsize = 0;
27:
28: static int ssiz;
29: static char *sbuf;
30: static int s_scale;
31: /* see profil(2) where this is describe (incorrectly) */
32: #define SCALE_1_TO_1 0x10000L
33:
34: #define MSG "No space for monitor buffer(s)\n"
35:
36: monstartup(lowpc, highpc)
37: char *lowpc;
38: char *highpc;
39: {
40: int monsize;
41: char *buffer;
42: char *sbrk();
43: extern char *minbrk;
44:
45: /*
46: * round lowpc and highpc to multiples of the density we're using
47: * so the rest of the scaling (here and in gprof) stays in ints.
48: */
49: lowpc = (char *)
50: ROUNDDOWN((unsigned)lowpc, HISTFRACTION*sizeof(HISTCOUNTER));
51: s_lowpc = lowpc;
52: highpc = (char *)
53: ROUNDUP((unsigned)highpc, HISTFRACTION*sizeof(HISTCOUNTER));
54: s_highpc = highpc;
55: s_textsize = highpc - lowpc;
56: monsize = (s_textsize / HISTFRACTION) + sizeof(struct phdr);
57: buffer = sbrk( monsize );
58: if ( buffer == (char *) -1 ) {
59: write( 2 , MSG , sizeof(MSG) );
60: return;
61: }
62: froms = (unsigned short *) sbrk( s_textsize / HASHFRACTION );
63: if ( froms == (unsigned short *) -1 ) {
64: write( 2 , MSG , sizeof(MSG) );
65: froms = 0;
66: return;
67: }
68: tolimit = s_textsize * ARCDENSITY / 100;
69: if ( tolimit < MINARCS ) {
70: tolimit = MINARCS;
71: } else if ( tolimit > 65534 ) {
72: tolimit = 65534;
73: }
74: tos = (struct tostruct *) sbrk( tolimit * sizeof( struct tostruct ) );
75: if ( tos == (struct tostruct *) -1 ) {
76: write( 2 , MSG , sizeof(MSG) );
77: froms = 0;
78: tos = 0;
79: return;
80: }
81: minbrk = sbrk(0);
82: tos[0].link = 0;
83: monitor( lowpc , highpc , buffer , monsize , tolimit );
84: }
85:
86: _mcleanup()
87: {
88: int fd;
89: int fromindex;
90: int endfrom;
91: char *frompc;
92: int toindex;
93: struct rawarc rawarc;
94:
95: fd = creat( "gmon.out" , 0666 );
96: if ( fd < 0 ) {
97: perror( "mcount: gmon.out" );
98: return;
99: }
100: # ifdef DEBUG
101: fprintf( stderr , "[mcleanup] sbuf 0x%x ssiz %d\n" , sbuf , ssiz );
102: # endif DEBUG
103: write( fd , sbuf , ssiz );
104: endfrom = s_textsize / (HASHFRACTION * sizeof(*froms));
105: for ( fromindex = 0 ; fromindex < endfrom ; fromindex++ ) {
106: if ( froms[fromindex] == 0 ) {
107: continue;
108: }
109: frompc = s_lowpc + (fromindex * HASHFRACTION * sizeof(*froms));
110: for (toindex=froms[fromindex]; toindex!=0; toindex=tos[toindex].link) {
111: # ifdef DEBUG
112: fprintf( stderr ,
113: "[mcleanup] frompc 0x%x selfpc 0x%x count %d\n" ,
114: frompc , tos[toindex].selfpc , tos[toindex].count );
115: # endif DEBUG
116: rawarc.raw_frompc = (unsigned long) frompc;
117: rawarc.raw_selfpc = (unsigned long) tos[toindex].selfpc;
118: rawarc.raw_count = tos[toindex].count;
119: write( fd , &rawarc , sizeof rawarc );
120: }
121: }
122: close( fd );
123: }
124:
125: asm(".text");
126: asm(".align 2");
127: asm("#the beginning of mcount()");
128: asm(".data");
129: mcount()
130: {
131: register char *selfpc; /* r11 => r5 */
132: register unsigned short *frompcindex; /* r10 => r4 */
133: register struct tostruct *top; /* r9 => r3 */
134: register struct tostruct *prevtop; /* r8 => r2 */
135: register long toindex; /* r7 => r1 */
136:
137: /*
138: * find the return address for mcount,
139: * and the return address for mcount's caller.
140: */
141: asm(" .text"); /* make sure we're in text space */
142: asm(" movl (sp), r11"); /* selfpc = ... (jsb frame) */
143: asm(" movl 16(fp), r10"); /* frompcindex = (calls frame) */
144: /*
145: * check that we are profiling
146: * and that we aren't recursively invoked.
147: */
148: if (profiling) {
149: goto out;
150: }
151: profiling++;
152: /*
153: * check that frompcindex is a reasonable pc value.
154: * for example: signal catchers get called from the stack,
155: * not from text space. too bad.
156: */
157: frompcindex = (unsigned short *)((long)frompcindex - (long)s_lowpc);
158: if ((unsigned long)frompcindex > s_textsize) {
159: goto done;
160: }
161: frompcindex =
162: &froms[((long)frompcindex) / (HASHFRACTION * sizeof(*froms))];
163: toindex = *frompcindex;
164: if (toindex == 0) {
165: /*
166: * first time traversing this arc
167: */
168: toindex = ++tos[0].link;
169: if (toindex >= tolimit) {
170: goto overflow;
171: }
172: *frompcindex = toindex;
173: top = &tos[toindex];
174: top->selfpc = selfpc;
175: top->count = 1;
176: top->link = 0;
177: goto done;
178: }
179: top = &tos[toindex];
180: if (top->selfpc == selfpc) {
181: /*
182: * arc at front of chain; usual case.
183: */
184: top->count++;
185: goto done;
186: }
187: /*
188: * have to go looking down chain for it.
189: * top points to what we are looking at,
190: * prevtop points to previous top.
191: * we know it is not at the head of the chain.
192: */
193: for (; /* goto done */; ) {
194: if (top->link == 0) {
195: /*
196: * top is end of the chain and none of the chain
197: * had top->selfpc == selfpc.
198: * so we allocate a new tostruct
199: * and link it to the head of the chain.
200: */
201: toindex = ++tos[0].link;
202: if (toindex >= tolimit) {
203: goto overflow;
204: }
205: top = &tos[toindex];
206: top->selfpc = selfpc;
207: top->count = 1;
208: top->link = *frompcindex;
209: *frompcindex = toindex;
210: goto done;
211: }
212: /*
213: * otherwise, check the next arc on the chain.
214: */
215: prevtop = top;
216: top = &tos[top->link];
217: if (top->selfpc == selfpc) {
218: /*
219: * there it is.
220: * increment its count
221: * move it to the head of the chain.
222: */
223: top->count++;
224: toindex = prevtop->link;
225: prevtop->link = top->link;
226: top->link = *frompcindex;
227: *frompcindex = toindex;
228: goto done;
229: }
230:
231: }
232: done:
233: profiling--;
234: /* and fall through */
235: out:
236: asm(" rsb");
237:
238: overflow:
239: profiling++; /* halt further profiling */
240: # define TOLIMIT "mcount: tos overflow\n"
241: write(2, TOLIMIT, sizeof(TOLIMIT));
242: goto out;
243: }
244: asm(".text");
245: asm("#the end of mcount()");
246: asm(".data");
247:
248: /*VARARGS1*/
249: monitor( lowpc , highpc , buf , bufsiz , nfunc )
250: char *lowpc;
251: char *highpc;
252: char *buf; /* declared ``short buffer[]'' in monitor(3) */
253: int bufsiz;
254: int nfunc; /* not used, available for compatability only */
255: {
256: register o;
257:
258: if ( lowpc == 0 ) {
259: moncontrol(0);
260: _mcleanup();
261: return;
262: }
263: sbuf = buf;
264: ssiz = bufsiz;
265: ( (struct phdr *) buf ) -> lpc = lowpc;
266: ( (struct phdr *) buf ) -> hpc = highpc;
267: ( (struct phdr *) buf ) -> ncnt = ssiz;
268: bufsiz -= sizeof(struct phdr);
269: if ( bufsiz <= 0 )
270: return;
271: o = highpc - lowpc;
272: if( bufsiz < o )
273: s_scale = ( (float) bufsiz / o ) * SCALE_1_TO_1;
274: else
275: s_scale = SCALE_1_TO_1;
276: moncontrol(1);
277: }
278:
279: /*
280: * Control profiling
281: * profiling is what mcount checks to see if
282: * all the data structures are ready.
283: */
284: moncontrol(mode)
285: int mode;
286: {
287: if (mode) {
288: /* start */
289: profil(sbuf + sizeof(struct phdr), ssiz - sizeof(struct phdr),
290: s_lowpc, s_scale);
291: profiling = 0;
292: } else {
293: /* stop */
294: profil((char *)0, 0, 0, 0);
295: profiling = 3;
296: }
297: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.