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
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
33 #include <sys/param.h>
36 #include <sys/gmon_out.h>
49 extern char *_strerror_internal __P ((int, char *buf, size_t));
51 extern int __profile_frequency __P ((void));
53 struct __bb *__bb_head; /* Head of basic-block list or NULL. */
55 struct gmonparam _gmonparam = { GMON_PROF_OFF };
58 * See profil(2) where this is described:
61 #define SCALE_1_TO_1 0x10000L
63 #define ERR(s) write(2, s, sizeof(s) - 1)
65 void moncontrol __P ((int mode));
66 void __moncontrol __P ((int mode));
67 static void write_hist __P ((int fd));
68 static void write_call_graph __P ((int fd));
69 static void write_bb_counts __P ((int fd));
73 * profiling is what mcount checks to see if
74 * all the data structures are ready.
80 struct gmonparam *p = &_gmonparam;
85 __profil((void *) p->kcount, p->kcountsize, p->lowpc, s_scale);
86 p->state = GMON_PROF_ON;
91 __profil(NULL, 0, 0, 0);
92 p->state = GMON_PROF_OFF;
98 __monstartup (lowpc, highpc)
104 struct gmonparam *p = &_gmonparam;
107 * round lowpc and highpc to multiples of the density we're using
108 * so the rest of the scaling (here and in gprof) stays in ints.
110 p->lowpc = ROUNDDOWN(lowpc, HISTFRACTION * sizeof(HISTCOUNTER));
111 p->highpc = ROUNDUP(highpc, HISTFRACTION * sizeof(HISTCOUNTER));
112 p->textsize = p->highpc - p->lowpc;
113 p->kcountsize = p->textsize / HISTFRACTION;
114 p->hashfraction = HASHFRACTION;
115 p->log_hashfraction = -1;
116 /* The following test must be kept in sync with the corresponding
118 if ((HASHFRACTION & (HASHFRACTION - 1)) == 0) {
119 /* if HASHFRACTION is a power of two, mcount can use shifting
120 instead of integer division. Precompute shift amount. */
121 p->log_hashfraction = ffs(p->hashfraction * sizeof(*p->froms)) - 1;
123 p->fromssize = p->textsize / HASHFRACTION;
124 p->tolimit = p->textsize * ARCDENSITY / 100;
125 if (p->tolimit < MINARCS)
126 p->tolimit = MINARCS;
127 else if (p->tolimit > MAXARCS)
128 p->tolimit = MAXARCS;
129 p->tossize = p->tolimit * sizeof(struct tostruct);
131 cp = calloc (p->kcountsize + p->fromssize + p->tossize, 1);
134 ERR(_("monstartup: out of memory\n"));
137 p->tos = (struct tostruct *)cp;
139 p->kcount = (u_short *)cp;
141 p->froms = (u_short *)cp;
145 o = p->highpc - p->lowpc;
146 if (p->kcountsize < (u_long) o)
149 s_scale = ((float)p->kcountsize / o ) * SCALE_1_TO_1;
151 /* avoid floating point operations */
152 int quot = o / p->kcountsize;
156 else if (quot >= 0x100)
157 s_scale = 0x10000 / quot;
158 else if (o >= 0x800000)
159 s_scale = 0x1000000 / (o / (p->kcountsize >> 8));
161 s_scale = 0x1000000 / ((o << 8) / p->kcountsize);
164 s_scale = SCALE_1_TO_1;
168 weak_alias(__monstartup, monstartup)
175 u_char tag = GMON_TAG_TIME_HIST;
176 struct gmon_hist_hdr thdr __attribute__ ((aligned (__alignof__ (char *))));
178 if (_gmonparam.kcountsize > 0)
180 struct iovec iov[3] =
182 { &tag, sizeof (tag) },
183 { &thdr, sizeof (struct gmon_hist_hdr) },
184 { _gmonparam.kcount, _gmonparam.kcountsize }
187 *(char **) thdr.low_pc = (char *) _gmonparam.lowpc;
188 *(char **) thdr.high_pc = (char *) _gmonparam.highpc;
189 *(int32_t *) thdr.hist_size = (_gmonparam.kcountsize
190 / sizeof (HISTCOUNTER));
191 *(int32_t *) thdr.prof_rate = __profile_frequency ();
192 strncpy (thdr.dimen, "seconds", sizeof (thdr.dimen));
193 thdr.dimen_abbrev = 's';
195 __writev (fd, iov, 3);
201 write_call_graph (fd)
204 #define NARCS_PER_WRITEV 32
205 u_char tag = GMON_TAG_CG_ARC;
206 struct gmon_cg_arc_record raw_arc[NARCS_PER_WRITEV]
207 __attribute__ ((aligned (__alignof__ (char*))));
208 int from_index, to_index, from_len;
210 struct iovec iov[2 * NARCS_PER_WRITEV];
213 for (nfilled = 0; nfilled < NARCS_PER_WRITEV; ++nfilled)
215 iov[2 * nfilled].iov_base = &tag;
216 iov[2 * nfilled].iov_len = sizeof (tag);
218 iov[2 * nfilled + 1].iov_base = &raw_arc[nfilled];
219 iov[2 * nfilled + 1].iov_len = sizeof (struct gmon_cg_arc_record);
223 from_len = _gmonparam.fromssize / sizeof (*_gmonparam.froms);
224 for (from_index = 0; from_index < from_len; ++from_index)
226 if (_gmonparam.froms[from_index] == 0)
229 frompc = _gmonparam.lowpc;
230 frompc += (from_index * _gmonparam.hashfraction
231 * sizeof (*_gmonparam.froms));
232 for (to_index = _gmonparam.froms[from_index];
234 to_index = _gmonparam.tos[to_index].link)
236 *(char **) raw_arc[nfilled].from_pc = (char *) frompc;
237 *(char **) raw_arc[nfilled].self_pc =
238 (char *)_gmonparam.tos[to_index].selfpc;
239 *(int *) raw_arc[nfilled].count = _gmonparam.tos[to_index].count;
241 if (++nfilled == NARCS_PER_WRITEV)
243 __writev (fd, iov, 2 * nfilled);
249 __writev (fd, iov, 2 * nfilled);
258 u_char tag = GMON_TAG_BB_COUNT;
262 struct iovec bbhead[2] =
264 { &tag, sizeof (tag) },
265 { &ncounts, sizeof (ncounts) }
267 struct iovec bbbody[8];
270 for (i = 0; i < (sizeof (bbbody) / sizeof (bbbody[0])); i += 2)
272 bbbody[i].iov_len = sizeof (grp->addresses[0]);
273 bbbody[i + 1].iov_len = sizeof (grp->counts[0]);
276 /* Write each group of basic-block info (all basic-blocks in a
277 compilation unit form a single group). */
279 for (grp = __bb_head; grp; grp = grp->next)
281 ncounts = grp->ncounts;
282 __writev (fd, bbhead, 2);
283 for (nfilled = i = 0; i < ncounts; ++i)
285 if (nfilled > (sizeof (bbbody) / sizeof (bbbody[0])) - 2)
287 __writev (fd, bbbody, nfilled);
291 bbbody[nfilled++].iov_base = (char *) &grp->addresses[i];
292 bbbody[nfilled++].iov_base = &grp->counts[i];
295 __writev (fd, bbbody, nfilled);
303 struct gmon_hdr ghdr __attribute__ ((aligned (__alignof__ (int))));
306 fd = __open ("gmon.out", O_CREAT|O_TRUNC|O_WRONLY, 0666);
311 fprintf (stderr, "_mcleanup: gmon.out: %s\n",
312 _strerror_internal (errnum, buf, sizeof buf));
316 /* write gmon.out header: */
317 memset (&ghdr, '\0', sizeof (struct gmon_hdr));
318 memcpy (&ghdr.cookie[0], GMON_MAGIC, sizeof (ghdr.cookie));
319 *(int32_t *) ghdr.version = GMON_VERSION;
320 __write (fd, &ghdr, sizeof (struct gmon_hdr));
322 /* write PC histogram: */
325 /* write call-graph: */
326 write_call_graph (fd);
328 /* write basic-block execution counts: */
329 write_bb_counts (fd);
336 __write_profiling (void)
338 int save = _gmonparam.state;
339 _gmonparam.state = GMON_PROF_OFF;
340 if (save == GMON_PROF_ON)
342 _gmonparam.state = save;
344 weak_alias (__write_profiling, write_profiling)
354 /* free the memory. */
355 free (_gmonparam.tos);