2 * Copyright (c) 1991 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 * Re rework of the solaris 2 version of gmon by J.W.Hawtin 12/8/1996
36 * Does not work right yet.
40 * This is a modified gmon.c by J.W.Hawtin <J.W.Hawtin@lboro.ac.uk>,
41 * 14/8/96 based on the original gmon.c in GCC and the hacked version
42 * solaris 2 sparc version (config/sparc/gmon-sol.c) by Mark Eichin. To do
43 * process profiling on solaris 2.4 X86
45 * It must be used in conjunction with sol2-gc1.asm, which is used to start
46 * and stop process monitoring.
50 * On Solaris 2 _mcount is called my library functions not mcount, so support
51 * has been added for both.
53 * Also the prototype for profil() is different
55 * Solaris 2 does not seem to have char *minbrk whcih allows the setting of
56 * the minimum SBRK region so this code has been removed and lets pray malloc
57 * does not mess it up.
61 * This code could easily be integrated with the original gmon.c and perhaps
66 static char sccsid
[] = "@(#)gmon.c 5.3 (Berkeley) 5/22/91";
78 #include "i386/gmon.h"
88 #define HISTFRACTION 2
89 #define HISTCOUNTER unsigned short
90 #define HASHFRACTION 1
93 #define BASEADDRESS 0x8000000 /* On Solaris 2 X86 all executables start here
102 unsigned long raw_frompc
;
103 unsigned long raw_selfpc
;
106 #define ROUNDDOWN(x,y) (((x)/(y))*(y))
107 #define ROUNDUP(x,y) ((((x)+(y)-1)/(y))*(y))
113 extern char *sbrk ();
117 * froms is actually a bunch of unsigned shorts indexing tos
119 static int profiling
= 3;
120 static unsigned short *froms
;
121 static struct tostruct
*tos
= 0;
122 static long tolimit
= 0;
123 static char *s_lowpc
= 0;
124 static char *s_highpc
= 0;
125 static unsigned long s_textsize
= 0;
130 /* see profil(2) where this is describe (incorrectly) */
131 #define SCALE_1_TO_1 0x10000L
133 #define MSG "No space for profiling buffer(s)\n"
137 monstartup(lowpc
, highpc
)
146 * round lowpc and highpc to multiples of the density we're using
147 * so the rest of the scaling (here and in gprof) stays in ints.
150 ROUNDDOWN((unsigned)lowpc
, HISTFRACTION
*sizeof(HISTCOUNTER
));
153 ROUNDUP((unsigned)highpc
, HISTFRACTION
*sizeof(HISTCOUNTER
));
155 s_textsize
= highpc
- lowpc
;
156 monsize
= (s_textsize
/ HISTFRACTION
) + sizeof(struct phdr
);
157 buffer
= (char *) sbrk( monsize
);
158 if ( buffer
== (char *) -1 ) {
159 write( 2 , MSG
, sizeof(MSG
) );
162 froms
= (unsigned short *) sbrk( s_textsize
/ HASHFRACTION
);
163 if ( froms
== (unsigned short *) -1 ) {
164 write( 2 , MSG
, sizeof(MSG
) );
168 tolimit
= s_textsize
* ARCDENSITY
/ 100;
169 if ( tolimit
< MINARCS
) {
171 } else if ( tolimit
> 65534 ) {
174 tos
= (struct tostruct
*) sbrk( tolimit
* sizeof( struct tostruct
) );
175 if ( tos
== (struct tostruct
*) -1 ) {
176 write( 2 , MSG
, sizeof(MSG
) );
181 /* minbrk = (char *) sbrk(0);*/
185 ( (struct phdr
*) buffer
) -> lpc
= lowpc
;
186 ( (struct phdr
*) buffer
) -> hpc
= highpc
;
187 ( (struct phdr
*) buffer
) -> ncnt
= ssiz
;
188 monsize
-= sizeof(struct phdr
);
194 s_scale
= ( (float) monsize
/ o
) * SCALE_1_TO_1
;
195 #else /* avoid floating point */
197 int quot
= o
/ monsize
;
201 else if (quot
>= 0x100)
202 s_scale
= 0x10000 / quot
;
203 else if (o
>= 0x800000)
204 s_scale
= 0x1000000 / (o
/ (monsize
>> 8));
206 s_scale
= 0x1000000 / ((o
<< 8) / monsize
);
210 s_scale
= SCALE_1_TO_1
;
221 struct rawarc rawarc
;
224 fd
= creat( "gmon.out" , 0666 );
226 perror( "mcount: gmon.out" );
230 fprintf( stderr
, "[mcleanup] sbuf 0x%x ssiz %d\n" , sbuf
, ssiz
);
233 write( fd
, sbuf
, ssiz
);
234 endfrom
= s_textsize
/ (HASHFRACTION
* sizeof(*froms
));
235 for ( fromindex
= 0 ; fromindex
< endfrom
; fromindex
++ ) {
236 if ( froms
[fromindex
] == 0 ) {
239 frompc
= s_lowpc
+ (fromindex
* HASHFRACTION
* sizeof(*froms
));
240 for (toindex
=froms
[fromindex
]; toindex
!=0; toindex
=tos
[toindex
].link
) {
243 "[mcleanup] frompc 0x%x selfpc 0x%x count %d\n" ,
244 frompc
, tos
[toindex
].selfpc
, tos
[toindex
].count
);
246 rawarc
.raw_frompc
= (unsigned long) frompc
;
247 rawarc
.raw_selfpc
= (unsigned long) tos
[toindex
].selfpc
;
248 rawarc
.raw_count
= tos
[toindex
].count
;
249 write( fd
, &rawarc
, sizeof rawarc
);
255 /* Solaris 2 libraries use _mcount. */
256 asm(".globl _mcount; _mcount: jmp internal_mcount");
257 /* This is for compatibility with old versions of gcc which used mcount. */
258 asm(".globl mcount; mcount: jmp internal_mcount");
262 register char *selfpc
;
263 register unsigned short *frompcindex
;
264 register struct tostruct
*top
;
265 register struct tostruct
*prevtop
;
266 register long toindex
;
269 * find the return address for mcount,
270 * and the return address for mcount's caller.
273 /* selfpc = pc pushed by mcount call.
274 This identifies the function that was just entered. */
275 selfpc
= (void *) __builtin_return_address (0);
276 /* frompcindex = pc in preceding frame.
277 This identifies the caller of the function just entered. */
278 frompcindex
= (void *) __builtin_return_address (1);
281 * check that we are profiling
282 * and that we aren't recursively invoked.
289 * check that frompcindex is a reasonable pc value.
290 * for example: signal catchers get called from the stack,
291 * not from text space. too bad.
293 frompcindex
= (unsigned short *)((long)frompcindex
- (long)s_lowpc
);
294 if ((unsigned long)frompcindex
> s_textsize
) {
298 &froms
[((long)frompcindex
) / (HASHFRACTION
* sizeof(*froms
))];
299 toindex
= *frompcindex
;
302 * first time traversing this arc
304 toindex
= ++tos
[0].link
;
305 if (toindex
>= tolimit
) {
308 *frompcindex
= toindex
;
310 top
->selfpc
= selfpc
;
316 if (top
->selfpc
== selfpc
) {
318 * arc at front of chain; usual case.
324 * have to go looking down chain for it.
325 * top points to what we are looking at,
326 * prevtop points to previous top.
327 * we know it is not at the head of the chain.
329 for (; /* goto done */; ) {
330 if (top
->link
== 0) {
332 * top is end of the chain and none of the chain
333 * had top->selfpc == selfpc.
334 * so we allocate a new tostruct
335 * and link it to the head of the chain.
337 toindex
= ++tos
[0].link
;
338 if (toindex
>= tolimit
) {
342 top
->selfpc
= selfpc
;
344 top
->link
= *frompcindex
;
345 *frompcindex
= toindex
;
349 * otherwise, check the next arc on the chain.
352 top
= &tos
[top
->link
];
353 if (top
->selfpc
== selfpc
) {
356 * increment its count
357 * move it to the head of the chain.
360 toindex
= prevtop
->link
;
361 prevtop
->link
= top
->link
;
362 top
->link
= *frompcindex
;
363 *frompcindex
= toindex
;
370 /* and fall through */
372 return; /* normal return restores saved registers */
375 profiling
++; /* halt further profiling */
376 # define TOLIMIT "mcount: tos overflow\n"
377 write(2, TOLIMIT
, sizeof(TOLIMIT
));
383 * profiling is what mcount checks to see if
384 * all the data structures are ready.
392 profil((unsigned short *)(sbuf
+ sizeof(struct phdr
)),
393 ssiz
- sizeof(struct phdr
),
394 (int)s_lowpc
, s_scale
);
399 profil((unsigned short *)0, 0, 0, 0);