(gmp-objs): Add inlines.
[kopensolaris-gnu/glibc.git] / gmon / gmon.c
1 /*-
2  * Copyright (c) 1983, 1992, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
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.
20  *
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
31  * SUCH DAMAGE.
32  */
33 #include <sys/param.h>
34 #include <sys/time.h>
35 #include <sys/gmon.h>
36 #include <sys/gmon_out.h>
37 #include <sys/uio.h>
38
39 #include <errno.h>
40 #include <stdio.h>
41 #include <fcntl.h>
42 #include <unistd.h>
43
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <string.h>
47 #include <unistd.h>
48
49 extern int __profile_frequency __P ((void));
50
51 struct __bb *__bb_head; /*  Head of basic-block list or NULL. */
52
53 struct gmonparam _gmonparam = { GMON_PROF_OFF };
54
55 /*
56  * See profil(2) where this is described:
57  */
58 static int      s_scale;
59 #define         SCALE_1_TO_1    0x10000L
60
61 #define ERR(s) __write(2, s, sizeof(s) - 1)
62
63 void moncontrol __P ((int mode));
64 void __moncontrol __P ((int mode));
65 static void write_hist __P ((int fd)) internal_function;
66 static void write_call_graph __P ((int fd)) internal_function;
67 static void write_bb_counts __P ((int fd)) internal_function;
68
69 /*
70  * Control profiling
71  *      profiling is what mcount checks to see if
72  *      all the data structures are ready.
73  */
74 void
75 __moncontrol (mode)
76      int mode;
77 {
78   struct gmonparam *p = &_gmonparam;
79
80   /* Don't change the state if we ran into an error.  */
81   if (p->state == GMON_PROF_ERROR)
82     return;
83
84   if (mode)
85     {
86       /* start */
87       __profil((void *) p->kcount, p->kcountsize, p->lowpc, s_scale);
88       p->state = GMON_PROF_ON;
89     }
90   else
91     {
92       /* stop */
93       __profil(NULL, 0, 0, 0);
94       p->state = GMON_PROF_OFF;
95     }
96 }
97
98
99 void
100 __monstartup (lowpc, highpc)
101      u_long lowpc;
102      u_long highpc;
103 {
104   register int o;
105   char *cp;
106   struct gmonparam *p = &_gmonparam;
107
108   /*
109    * round lowpc and highpc to multiples of the density we're using
110    * so the rest of the scaling (here and in gprof) stays in ints.
111    */
112   p->lowpc = ROUNDDOWN(lowpc, HISTFRACTION * sizeof(HISTCOUNTER));
113   p->highpc = ROUNDUP(highpc, HISTFRACTION * sizeof(HISTCOUNTER));
114   p->textsize = p->highpc - p->lowpc;
115   p->kcountsize = p->textsize / HISTFRACTION;
116   p->hashfraction = HASHFRACTION;
117   p->log_hashfraction = -1;
118   /* The following test must be kept in sync with the corresponding
119      test in mcount.c.  */
120   if ((HASHFRACTION & (HASHFRACTION - 1)) == 0) {
121       /* if HASHFRACTION is a power of two, mcount can use shifting
122          instead of integer division.  Precompute shift amount. */
123       p->log_hashfraction = ffs(p->hashfraction * sizeof(*p->froms)) - 1;
124   }
125   p->fromssize = p->textsize / HASHFRACTION;
126   p->tolimit = p->textsize * ARCDENSITY / 100;
127   if (p->tolimit < MINARCS)
128     p->tolimit = MINARCS;
129   else if (p->tolimit > MAXARCS)
130     p->tolimit = MAXARCS;
131   p->tossize = p->tolimit * sizeof(struct tostruct);
132
133   cp = calloc (p->kcountsize + p->fromssize + p->tossize, 1);
134   if (! cp)
135     {
136       ERR("monstartup: out of memory\n");
137       p->tos = NULL;
138       p->state = GMON_PROF_ERROR;
139       return;
140     }
141   p->tos = (struct tostruct *)cp;
142   cp += p->tossize;
143   p->kcount = (u_short *)cp;
144   cp += p->kcountsize;
145   p->froms = (u_short *)cp;
146
147   p->tos[0].link = 0;
148
149   o = p->highpc - p->lowpc;
150   if (p->kcountsize < (u_long) o)
151     {
152 #ifndef hp300
153       s_scale = ((float)p->kcountsize / o ) * SCALE_1_TO_1;
154 #else
155       /* avoid floating point operations */
156       int quot = o / p->kcountsize;
157
158       if (quot >= 0x10000)
159         s_scale = 1;
160       else if (quot >= 0x100)
161         s_scale = 0x10000 / quot;
162       else if (o >= 0x800000)
163         s_scale = 0x1000000 / (o / (p->kcountsize >> 8));
164       else
165         s_scale = 0x1000000 / ((o << 8) / p->kcountsize);
166 #endif
167     } else
168       s_scale = SCALE_1_TO_1;
169
170   __moncontrol(1);
171 }
172 weak_alias(__monstartup, monstartup)
173
174
175 static void
176 internal_function
177 write_hist (fd)
178      int fd;
179 {
180   u_char tag = GMON_TAG_TIME_HIST;
181   struct gmon_hist_hdr thdr __attribute__ ((aligned (__alignof__ (char *))));
182
183   if (_gmonparam.kcountsize > 0)
184     {
185       struct iovec iov[3] =
186         {
187           { &tag, sizeof (tag) },
188           { &thdr, sizeof (struct gmon_hist_hdr) },
189           { _gmonparam.kcount, _gmonparam.kcountsize }
190         };
191
192       *(char **) thdr.low_pc = (char *) _gmonparam.lowpc;
193       *(char **) thdr.high_pc = (char *) _gmonparam.highpc;
194       *(int32_t *) thdr.hist_size = (_gmonparam.kcountsize
195                                      / sizeof (HISTCOUNTER));
196       *(int32_t *) thdr.prof_rate = __profile_frequency ();
197       strncpy (thdr.dimen, "seconds", sizeof (thdr.dimen));
198       thdr.dimen_abbrev = 's';
199
200       __writev (fd, iov, 3);
201     }
202 }
203
204
205 static void
206 internal_function
207 write_call_graph (fd)
208      int fd;
209 {
210 #define NARCS_PER_WRITEV        32
211   u_char tag = GMON_TAG_CG_ARC;
212   struct gmon_cg_arc_record raw_arc[NARCS_PER_WRITEV]
213     __attribute__ ((aligned (__alignof__ (char*))));
214   int from_index, to_index, from_len;
215   u_long frompc;
216   struct iovec iov[2 * NARCS_PER_WRITEV];
217   int nfilled;
218
219   for (nfilled = 0; nfilled < NARCS_PER_WRITEV; ++nfilled)
220     {
221       iov[2 * nfilled].iov_base = &tag;
222       iov[2 * nfilled].iov_len = sizeof (tag);
223
224       iov[2 * nfilled + 1].iov_base = &raw_arc[nfilled];
225       iov[2 * nfilled + 1].iov_len = sizeof (struct gmon_cg_arc_record);
226     }
227
228   nfilled = 0;
229   from_len = _gmonparam.fromssize / sizeof (*_gmonparam.froms);
230   for (from_index = 0; from_index < from_len; ++from_index)
231     {
232       if (_gmonparam.froms[from_index] == 0)
233         continue;
234
235       frompc = _gmonparam.lowpc;
236       frompc += (from_index * _gmonparam.hashfraction
237                  * sizeof (*_gmonparam.froms));
238       for (to_index = _gmonparam.froms[from_index];
239            to_index != 0;
240            to_index = _gmonparam.tos[to_index].link)
241         {
242           *(char **) raw_arc[nfilled].from_pc = (char *) frompc;
243           *(char **) raw_arc[nfilled].self_pc =
244             (char *)_gmonparam.tos[to_index].selfpc;
245           *(int *) raw_arc[nfilled].count = _gmonparam.tos[to_index].count;
246
247           if (++nfilled == NARCS_PER_WRITEV)
248             {
249               __writev (fd, iov, 2 * nfilled);
250               nfilled = 0;
251             }
252         }
253     }
254   if (nfilled > 0)
255     __writev (fd, iov, 2 * nfilled);
256 }
257
258
259 static void
260 internal_function
261 write_bb_counts (fd)
262      int fd;
263 {
264   struct __bb *grp;
265   u_char tag = GMON_TAG_BB_COUNT;
266   size_t ncounts;
267   size_t i;
268
269   struct iovec bbhead[2] =
270     {
271       { &tag, sizeof (tag) },
272       { &ncounts, sizeof (ncounts) }
273     };
274   struct iovec bbbody[8];
275   size_t nfilled;
276
277   for (i = 0; i < (sizeof (bbbody) / sizeof (bbbody[0])); i += 2)
278     {
279       bbbody[i].iov_len = sizeof (grp->addresses[0]);
280       bbbody[i + 1].iov_len = sizeof (grp->counts[0]);
281     }
282
283   /* Write each group of basic-block info (all basic-blocks in a
284      compilation unit form a single group). */
285
286   for (grp = __bb_head; grp; grp = grp->next)
287     {
288       ncounts = grp->ncounts;
289       __writev (fd, bbhead, 2);
290       for (nfilled = i = 0; i < ncounts; ++i)
291         {
292           if (nfilled > (sizeof (bbbody) / sizeof (bbbody[0])) - 2)
293             {
294               __writev (fd, bbbody, nfilled);
295               nfilled = 0;
296             }
297
298           bbbody[nfilled++].iov_base = (char *) &grp->addresses[i];
299           bbbody[nfilled++].iov_base = &grp->counts[i];
300         }
301       if (nfilled > 0)
302         __writev (fd, bbbody, nfilled);
303     }
304 }
305
306
307 static void
308 write_gmon (void)
309 {
310     struct gmon_hdr ghdr __attribute__ ((aligned (__alignof__ (int))));
311     int fd = -1;
312     char *env;
313
314     env = getenv ("GMON_OUT_PREFIX");
315     if (env != NULL && !__libc_enable_secure)
316       {
317         size_t len = strlen (env);
318         char buf[len + 20];
319         sprintf (buf, "%s.%u", env, __getpid ());
320         fd = __open (buf, O_CREAT|O_TRUNC|O_WRONLY, 0666);
321       }
322
323     if (fd == -1)
324       {
325         fd = __open ("gmon.out", O_CREAT|O_TRUNC|O_WRONLY, 0666);
326         if (fd < 0)
327           {
328             char buf[300];
329             int errnum = errno;
330             fprintf (stderr, "_mcleanup: gmon.out: %s\n",
331                      __strerror_r (errnum, buf, sizeof buf));
332             return;
333           }
334       }
335
336     /* write gmon.out header: */
337     memset (&ghdr, '\0', sizeof (struct gmon_hdr));
338     memcpy (&ghdr.cookie[0], GMON_MAGIC, sizeof (ghdr.cookie));
339     *(int32_t *) ghdr.version = GMON_VERSION;
340     __write (fd, &ghdr, sizeof (struct gmon_hdr));
341
342     /* write PC histogram: */
343     write_hist (fd);
344
345     /* write call-graph: */
346     write_call_graph (fd);
347
348     /* write basic-block execution counts: */
349     write_bb_counts (fd);
350
351     __close (fd);
352 }
353
354
355 void
356 __write_profiling (void)
357 {
358   int save = _gmonparam.state;
359   _gmonparam.state = GMON_PROF_OFF;
360   if (save == GMON_PROF_ON)
361     write_gmon ();
362   _gmonparam.state = save;
363 }
364 weak_alias (__write_profiling, write_profiling)
365
366
367 void
368 _mcleanup (void)
369 {
370   __moncontrol (0);
371
372   if (_gmonparam.state != GMON_PROF_ERROR)
373     write_gmon ();
374
375   /* free the memory. */
376   if (_gmonparam.tos != NULL)
377     free (_gmonparam.tos);
378 }