]>
gcc.gnu.org Git - gcc.git/blob - gcc/config/sparc/gmon-sol2.c
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. [rescinded 22 July 1999]
14 * 4. Neither the name of the University nor the names of its contributors
15 * may be used to endorse or promote products derived from this software
16 * without specific prior written permission.
18 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 /* Mangled into a form that works on Sparc Solaris 2 by Mark Eichin
32 * for Cygnus Support, July 1992.
39 #include "sparc/gmon.h"
46 #define HISTFRACTION 2
47 #define HISTCOUNTER unsigned short
48 #define HASHFRACTION 1
57 unsigned long raw_frompc
;
58 unsigned long raw_selfpc
;
61 #define ROUNDDOWN(x,y) (((x)/(y))*(y))
62 #define ROUNDUP(x,y) ((((x)+(y)-1)/(y))*(y))
66 /* extern mcount() asm ("mcount"); */
67 /*extern*/ char *minbrk
/* asm ("minbrk") */;
70 * froms is actually a bunch of unsigned shorts indexing tos
72 static int profiling
= 3;
73 static unsigned short *froms
;
74 static struct tostruct
*tos
= 0;
75 static long tolimit
= 0;
76 static char *s_lowpc
= 0;
77 static char *s_highpc
= 0;
78 static unsigned long s_textsize
= 0;
83 /* see profil(2) where this is describe (incorrectly) */
84 #define SCALE_1_TO_1 0x10000L
86 #define MSG "No space for profiling buffer(s)\n"
88 static void moncontrol
PARAMS ((int));
89 extern void monstartup
PARAMS ((char *, char *));
90 extern void _mcleanup
PARAMS ((void));
92 void monstartup(lowpc
, highpc
)
101 * round lowpc and highpc to multiples of the density we're using
102 * so the rest of the scaling (here and in gprof) stays in ints.
105 ROUNDDOWN((unsigned)lowpc
, HISTFRACTION
*sizeof(HISTCOUNTER
));
108 ROUNDUP((unsigned)highpc
, HISTFRACTION
*sizeof(HISTCOUNTER
));
110 s_textsize
= highpc
- lowpc
;
111 monsize
= (s_textsize
/ HISTFRACTION
) + sizeof(struct phdr
);
112 buffer
= sbrk( monsize
);
113 if ( buffer
== (char *) -1 ) {
114 write( 2 , MSG
, sizeof(MSG
) );
117 froms
= (unsigned short *) sbrk( s_textsize
/ HASHFRACTION
);
118 if ( froms
== (unsigned short *) -1 ) {
119 write( 2 , MSG
, sizeof(MSG
) );
123 tolimit
= s_textsize
* ARCDENSITY
/ 100;
124 if ( tolimit
< MINARCS
) {
126 } else if ( tolimit
> 65534 ) {
129 tos
= (struct tostruct
*) sbrk( tolimit
* sizeof( struct tostruct
) );
130 if ( tos
== (struct tostruct
*) -1 ) {
131 write( 2 , MSG
, sizeof(MSG
) );
140 ( (struct phdr
*) buffer
) -> lpc
= lowpc
;
141 ( (struct phdr
*) buffer
) -> hpc
= highpc
;
142 ( (struct phdr
*) buffer
) -> ncnt
= ssiz
;
143 monsize
-= sizeof(struct phdr
);
149 s_scale
= ( (float) monsize
/ o
) * SCALE_1_TO_1
;
150 #else /* avoid floating point */
152 int quot
= o
/ monsize
;
156 else if (quot
>= 0x100)
157 s_scale
= 0x10000 / quot
;
158 else if (o
>= 0x800000)
159 s_scale
= 0x1000000 / (o
/ (monsize
>> 8));
161 s_scale
= 0x1000000 / ((o
<< 8) / monsize
);
165 s_scale
= SCALE_1_TO_1
;
177 struct rawarc rawarc
;
179 const char *proffile
;
182 extern char **___Argv
;
186 if ((profdir
= getenv("PROFDIR")) != NULL
) {
187 /* If PROFDIR contains a null value, no profiling output is produced */
188 if (*profdir
== '\0') {
192 progname
=strrchr(___Argv
[0], '/');
193 if (progname
== NULL
)
198 sprintf(buf
, "%s/%ld.%s", profdir
, getpid(), progname
);
201 proffile
= "gmon.out";
204 fd
= creat( proffile
, 0666 );
210 fprintf( stderr
, "[mcleanup] sbuf 0x%x ssiz %d\n" , sbuf
, ssiz
);
212 write( fd
, sbuf
, ssiz
);
213 endfrom
= s_textsize
/ (HASHFRACTION
* sizeof(*froms
));
214 for ( fromindex
= 0 ; fromindex
< endfrom
; fromindex
++ ) {
215 if ( froms
[fromindex
] == 0 ) {
218 frompc
= s_lowpc
+ (fromindex
* HASHFRACTION
* sizeof(*froms
));
219 for (toindex
=froms
[fromindex
]; toindex
!=0; toindex
=tos
[toindex
].link
) {
222 "[mcleanup] frompc 0x%x selfpc 0x%x count %d\n" ,
223 frompc
, tos
[toindex
].selfpc
, tos
[toindex
].count
);
225 rawarc
.raw_frompc
= (unsigned long) frompc
;
226 rawarc
.raw_selfpc
= (unsigned long) tos
[toindex
].selfpc
;
227 rawarc
.raw_count
= tos
[toindex
].count
;
228 write( fd
, &rawarc
, sizeof rawarc
);
235 * The Sparc stack frame is only held together by the frame pointers
236 * in the register windows. According to the SVR4 SPARC ABI
237 * Supplement, Low Level System Information/Operating System
238 * Interface/Software Trap Types, a type 3 trap will flush all of the
239 * register windows to the stack, which will make it possible to walk
240 * the frames and find the return addresses.
241 * However, it seems awfully expensive to incur a trap (system
242 * call) for every function call. It turns out that "call" simply puts
243 * the return address in %o7 expecting the "save" in the procedure to
244 * shift it into %i7; this means that before the "save" occurs, %o7
245 * contains the address of the call to mcount, and %i7 still contains
246 * the caller above that. The asm mcount here simply saves those
247 * registers in argument registers and branches to internal_mcount,
248 * simulating a call with arguments.
250 * 1) the branch to internal_mcount is hard coded; it should be
251 * possible to tell asm to use the assembler-name of a symbol.
252 * 2) in theory, the function calling mcount could have saved %i7
253 * somewhere and reused the register; in practice, I *think* this will
254 * break longjmp (and maybe the debugger) but I'm not certain. (I take
255 * some comfort in the knowledge that it will break the native mcount
257 * 3) if builtin_return_address worked, this could be portable.
258 * However, it would really have to be optimized for arguments of 0
259 * and 1 and do something like what we have here in order to avoid the
260 * trap per function call performance hit.
261 * 4) the atexit and monsetup calls prevent this from simply
262 * being a leaf routine that doesn't do a "save" (and would thus have
263 * access to %o7 and %i7 directly) but the call to write() at the end
264 * would have also prevented this.
266 * -- [eichin:19920702.1107EST]
269 static void internal_mcount
PARAMS ((char *, unsigned short *)) ATTRIBUTE_UNUSED
;
271 /* i7 == last ret, -> frompcindex */
272 /* o7 == current ret, -> selfpc */
273 /* Solaris 2 libraries use _mcount. */
274 asm(".global _mcount; _mcount: mov %i7,%o1; mov %o7,%o0;b,a internal_mcount");
275 /* This is for compatibility with old versions of gcc which used mcount. */
276 asm(".global mcount; mcount: mov %i7,%o1; mov %o7,%o0;b,a internal_mcount");
278 static void internal_mcount(selfpc
, frompcindex
)
279 register char *selfpc
;
280 register unsigned short *frompcindex
;
282 register struct tostruct
*top
;
283 register struct tostruct
*prevtop
;
284 register long toindex
;
285 static char already_setup
;
288 * find the return address for mcount,
289 * and the return address for mcount's caller.
295 monstartup(0, (char *)etext
);
297 on_exit(_mcleanup
, 0);
303 * check that we are profiling
304 * and that we aren't recursively invoked.
311 * check that frompcindex is a reasonable pc value.
312 * for example: signal catchers get called from the stack,
313 * not from text space. too bad.
315 frompcindex
= (unsigned short *)((long)frompcindex
- (long)s_lowpc
);
316 if ((unsigned long)frompcindex
> s_textsize
) {
320 &froms
[((long)frompcindex
) / (HASHFRACTION
* sizeof(*froms
))];
321 toindex
= *frompcindex
;
324 * first time traversing this arc
326 toindex
= ++tos
[0].link
;
327 if (toindex
>= tolimit
) {
330 *frompcindex
= toindex
;
332 top
->selfpc
= selfpc
;
338 if (top
->selfpc
== selfpc
) {
340 * arc at front of chain; usual case.
346 * have to go looking down chain for it.
347 * top points to what we are looking at,
348 * prevtop points to previous top.
349 * we know it is not at the head of the chain.
351 for (; /* goto done */; ) {
352 if (top
->link
== 0) {
354 * top is end of the chain and none of the chain
355 * had top->selfpc == selfpc.
356 * so we allocate a new tostruct
357 * and link it to the head of the chain.
359 toindex
= ++tos
[0].link
;
360 if (toindex
>= tolimit
) {
364 top
->selfpc
= selfpc
;
366 top
->link
= *frompcindex
;
367 *frompcindex
= toindex
;
371 * otherwise, check the next arc on the chain.
374 top
= &tos
[top
->link
];
375 if (top
->selfpc
== selfpc
) {
378 * increment its count
379 * move it to the head of the chain.
382 toindex
= prevtop
->link
;
383 prevtop
->link
= top
->link
;
384 top
->link
= *frompcindex
;
385 *frompcindex
= toindex
;
392 /* and fall through */
394 return; /* normal return restores saved registers */
397 profiling
++; /* halt further profiling */
398 # define TOLIMIT "mcount: tos overflow\n"
399 write(2, TOLIMIT
, sizeof(TOLIMIT
));
405 * profiling is what mcount checks to see if
406 * all the data structures are ready.
408 static void moncontrol(mode
)
413 profil((unsigned short *)(sbuf
+ sizeof(struct phdr
)),
414 ssiz
- sizeof(struct phdr
),
415 (int)s_lowpc
, s_scale
);
419 profil((unsigned short *)0, 0, 0, 0);
This page took 0.056007 seconds and 5 git commands to generate.