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);