Update.
[glibc.git] / gmon / gmon.c
blob834351eeec5954f16baccf8de192bba6175a8fba
1 /*-
2 * Copyright (c) 1983, 1992, 1993
3 * The Regents of the University of California. All rights reserved.
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.
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.
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>
39 #include <errno.h>
40 #include <stdio.h>
41 #include <fcntl.h>
42 #include <unistd.h>
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <string.h>
47 #include <unistd.h>
49 extern int __profile_frequency __P ((void));
51 struct __bb *__bb_head; /* Head of basic-block list or NULL. */
53 struct gmonparam _gmonparam = { GMON_PROF_OFF };
56 * See profil(2) where this is described:
58 static int s_scale;
59 #define SCALE_1_TO_1 0x10000L
61 #define ERR(s) write(2, s, sizeof(s) - 1)
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;
70 * Control profiling
71 * profiling is what mcount checks to see if
72 * all the data structures are ready.
74 void
75 __moncontrol (mode)
76 int mode;
78 struct gmonparam *p = &_gmonparam;
80 /* Don't change the state if we ran into an error. */
81 if (p->state == GMON_PROF_ERROR)
82 return;
84 if (mode)
86 /* start */
87 __profil((void *) p->kcount, p->kcountsize, p->lowpc, s_scale);
88 p->state = GMON_PROF_ON;
90 else
92 /* stop */
93 __profil(NULL, 0, 0, 0);
94 p->state = GMON_PROF_OFF;
99 void
100 __monstartup (lowpc, highpc)
101 u_long lowpc;
102 u_long highpc;
104 register int o;
105 char *cp;
106 struct gmonparam *p = &_gmonparam;
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.
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;
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);
133 cp = calloc (p->kcountsize + p->fromssize + p->tossize, 1);
134 if (! cp)
136 ERR("monstartup: out of memory\n");
137 p->tos = NULL;
138 p->state = GMON_PROF_ERROR;
139 return;
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;
147 p->tos[0].link = 0;
149 o = p->highpc - p->lowpc;
150 if (p->kcountsize < (u_long) o)
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;
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;
170 __moncontrol(1);
172 weak_alias(__monstartup, monstartup)
175 static void
176 internal_function
177 write_hist (fd)
178 int fd;
180 u_char tag = GMON_TAG_TIME_HIST;
181 struct gmon_hist_hdr thdr __attribute__ ((aligned (__alignof__ (char *))));
183 if (_gmonparam.kcountsize > 0)
185 struct iovec iov[3] =
187 { &tag, sizeof (tag) },
188 { &thdr, sizeof (struct gmon_hist_hdr) },
189 { _gmonparam.kcount, _gmonparam.kcountsize }
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';
200 __writev (fd, iov, 3);
205 static void
206 internal_function
207 write_call_graph (fd)
208 int fd;
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;
219 for (nfilled = 0; nfilled < NARCS_PER_WRITEV; ++nfilled)
221 iov[2 * nfilled].iov_base = &tag;
222 iov[2 * nfilled].iov_len = sizeof (tag);
224 iov[2 * nfilled + 1].iov_base = &raw_arc[nfilled];
225 iov[2 * nfilled + 1].iov_len = sizeof (struct gmon_cg_arc_record);
228 nfilled = 0;
229 from_len = _gmonparam.fromssize / sizeof (*_gmonparam.froms);
230 for (from_index = 0; from_index < from_len; ++from_index)
232 if (_gmonparam.froms[from_index] == 0)
233 continue;
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)
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;
247 if (++nfilled == NARCS_PER_WRITEV)
249 __writev (fd, iov, 2 * nfilled);
250 nfilled = 0;
254 if (nfilled > 0)
255 __writev (fd, iov, 2 * nfilled);
259 static void
260 internal_function
261 write_bb_counts (fd)
262 int fd;
264 struct __bb *grp;
265 u_char tag = GMON_TAG_BB_COUNT;
266 size_t ncounts;
267 size_t i;
269 struct iovec bbhead[2] =
271 { &tag, sizeof (tag) },
272 { &ncounts, sizeof (ncounts) }
274 struct iovec bbbody[8];
275 size_t nfilled;
277 for (i = 0; i < (sizeof (bbbody) / sizeof (bbbody[0])); i += 2)
279 bbbody[i].iov_len = sizeof (grp->addresses[0]);
280 bbbody[i + 1].iov_len = sizeof (grp->counts[0]);
283 /* Write each group of basic-block info (all basic-blocks in a
284 compilation unit form a single group). */
286 for (grp = __bb_head; grp; grp = grp->next)
288 ncounts = grp->ncounts;
289 __writev (fd, bbhead, 2);
290 for (nfilled = i = 0; i < ncounts; ++i)
292 if (nfilled > (sizeof (bbbody) / sizeof (bbbody[0])) - 2)
294 __writev (fd, bbbody, nfilled);
295 nfilled = 0;
298 bbbody[nfilled++].iov_base = (char *) &grp->addresses[i];
299 bbbody[nfilled++].iov_base = &grp->counts[i];
301 if (nfilled > 0)
302 __writev (fd, bbbody, nfilled);
307 static void
308 write_gmon (void)
310 struct gmon_hdr ghdr __attribute__ ((aligned (__alignof__ (int))));
311 int fd = -1;
312 char *env;
314 env = getenv ("GMON_OUT_PREFIX");
315 if (env != NULL && !__libc_enable_secure)
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);
323 if (fd == -1)
325 fd = __open ("gmon.out", O_CREAT|O_TRUNC|O_WRONLY, 0666);
326 if (fd < 0)
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;
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));
342 /* write PC histogram: */
343 write_hist (fd);
345 /* write call-graph: */
346 write_call_graph (fd);
348 /* write basic-block execution counts: */
349 write_bb_counts (fd);
351 __close (fd);
355 void
356 __write_profiling (void)
358 int save = _gmonparam.state;
359 _gmonparam.state = GMON_PROF_OFF;
360 if (save == GMON_PROF_ON)
361 write_gmon ();
362 _gmonparam.state = save;
364 weak_alias (__write_profiling, write_profiling)
367 void
368 _mcleanup (void)
370 __moncontrol (0);
372 if (_gmonparam.state != GMON_PROF_ERROR)
373 write_gmon ();
375 /* free the memory. */
376 if (_gmonparam.tos != NULL)
377 free (_gmonparam.tos);