2 * Copyright (c) 1991, 2000 The Regents of the University of California.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * This is a modified gmon.c by J.W.Hawtin <oolon@ankh.org>,
36 * 14/8/96 based on the original gmon.c in GCC and the hacked version
37 * solaris 2 sparc version (config/sparc/gmon-sol.c) by Mark Eichin. To do
38 * process profiling on solaris 2.X X86
40 * It must be used in conjunction with sol2-gc1.asm, which is used to start
41 * and stop process monitoring.
45 * On Solaris 2 _mcount is called by library functions not mcount, so support
46 * has been added for both.
48 * Also the prototype for profil() is different
50 * Solaris 2 does not seem to have char *minbrk which allows the setting of
51 * the minimum SBRK region so this code has been removed and lets pray malloc
52 * does not mess it up.
56 * This code could easily be integrated with the original gmon.c and perhaps
61 static char sccsid[] = "@(#)gmon.c 5.3 (Berkeley) 5/22/91";
69 #include "cygmon-gmon.h"
72 * froms is actually a bunch of unsigned shorts indexing tos
74 static int profiling = 3;
75 static unsigned short *froms;
76 static struct tostruct *tos = 0;
77 static long tolimit = 0;
78 static char *s_lowpc = 0;
79 static char *s_highpc = 0;
80 static unsigned long s_textsize = 0;
85 /* see profil(2) where this is describe (incorrectly) */
86 #define SCALE_1_TO_1 0x10000L
88 #define MSG "No space for profiling buffer(s)\n"
93 monstartup(lowpc, highpc)
102 * round lowpc and highpc to multiples of the density we're using
103 * so the rest of the scaling (here and in gprof) stays in ints.
106 ROUNDDOWN((unsigned)lowpc, HISTFRACTION*sizeof(HISTCOUNTER));
109 ROUNDUP((unsigned)highpc, HISTFRACTION*sizeof(HISTCOUNTER));
111 s_textsize = highpc - lowpc;
112 monsize = (s_textsize / HISTFRACTION) + sizeof(struct phdr);
113 buffer = (char *) sbrk (monsize);
114 if (buffer == (char *) -1)
116 write (2, MSG , sizeof(MSG));
119 bzero (buffer, monsize);
120 froms = (unsigned short *) sbrk (s_textsize / HASHFRACTION);
121 if (froms == (unsigned short *) -1)
123 write(2, MSG, sizeof(MSG));
127 bzero (froms, s_textsize / HASHFRACTION);
128 tolimit = s_textsize * ARCDENSITY / 100;
129 if (tolimit < MINARCS)
140 tos = (struct tostruct *) sbrk( tolimit * sizeof( struct tostruct ) );
141 if (tos == (struct tostruct *) -1)
143 write (2, MSG, sizeof(MSG));
148 bzero (tos, tolimit * sizeof( struct tostruct ) );
152 ( (struct phdr *) buffer ) -> lpc = lowpc;
153 ( (struct phdr *) buffer ) -> hpc = highpc;
154 ( (struct phdr *) buffer ) -> ncnt = ssiz;
155 monsize -= sizeof(struct phdr);
161 s_scale = ( (float) monsize / o ) * SCALE_1_TO_1;
164 s_scale = SCALE_1_TO_1;
176 struct rawarc rawarc;
179 profil_write (1, sbuf, ssiz);
181 endfrom = s_textsize / (HASHFRACTION * sizeof(*froms));
182 for ( fromindex = 0 ; fromindex < endfrom ; fromindex++ )
184 if ( froms[fromindex] == 0 )
188 frompc = s_lowpc + (fromindex * HASHFRACTION * sizeof(*froms));
189 for (toindex=froms[fromindex]; toindex!=0; toindex=tos[toindex].link)
191 rawarc.raw_frompc = (unsigned long) frompc;
192 rawarc.raw_selfpc = (unsigned long) tos[toindex].selfpc;
193 rawarc.raw_count = tos[toindex].count;
194 profil_write (2, &rawarc, sizeof (rawarc));
197 profil_write (3, 0, 0);
200 static char already_setup = 0;
204 register char *selfpc;
205 register unsigned short *frompcindex;
206 register struct tostruct *top;
207 register struct tostruct *prevtop;
208 register long toindex;
211 * find the return address for mcount,
212 * and the return address for mcount's caller.
215 /* selfpc = pc pushed by mcount call.
216 This identifies the function that was just entered. */
217 selfpc = (void *) __builtin_return_address (0);
218 /* frompcindex = pc in preceding frame.
219 This identifies the caller of the function just entered. */
220 frompcindex = (void *) __builtin_return_address (1);
227 monstartup(_ftext, _etext);
231 * check that we are profiling
232 * and that we aren't recursively invoked.
240 * check that frompcindex is a reasonable pc value.
241 * for example: signal catchers get called from the stack,
242 * not from text space. too bad.
244 frompcindex = (unsigned short *)((long)frompcindex - (long)s_lowpc);
245 if ((unsigned long)frompcindex > s_textsize)
250 &froms[((long)frompcindex) / (HASHFRACTION * sizeof(*froms))];
251 toindex = *frompcindex;
255 * first time traversing this arc
257 toindex = ++tos[0].link;
258 if (toindex >= tolimit)
262 *frompcindex = toindex;
264 top->selfpc = selfpc;
270 if (top->selfpc == selfpc)
273 * arc at front of chain; usual case.
279 * have to go looking down chain for it.
280 * top points to what we are looking at,
281 * prevtop points to previous top.
282 * we know it is not at the head of the chain.
284 for (; /* goto done */; )
289 * top is end of the chain and none of the chain
290 * had top->selfpc == selfpc.
291 * so we allocate a new tostruct
292 * and link it to the head of the chain.
294 toindex = ++tos[0].link;
295 if (toindex >= tolimit)
300 top->selfpc = selfpc;
302 top->link = *frompcindex;
303 *frompcindex = toindex;
307 * otherwise, check the next arc on the chain.
310 top = &tos[top->link];
311 if (top->selfpc == selfpc)
315 * increment its count
316 * move it to the head of the chain.
319 toindex = prevtop->link;
320 prevtop->link = top->link;
321 top->link = *frompcindex;
322 *frompcindex = toindex;
328 /* and fall through */
330 return; /* normal return restores saved registers */
333 profiling++; /* halt further profiling */
334 # define TOLIMIT "mcount: tos overflow\n"
335 write (2, TOLIMIT, sizeof(TOLIMIT));
341 * profiling is what mcount checks to see if
342 * all the data structures are ready.
350 profil((unsigned short *)(sbuf + sizeof(struct phdr)),
351 ssiz - sizeof(struct phdr),
352 (int)s_lowpc, s_scale);
359 profil((unsigned short *)0, 0, 0, 0);