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>
48 extern int __profile_frequency (void);
50 struct __bb
*__bb_head
; /* Head of basic-block list or NULL. */
52 struct gmonparam _gmonparam
= { GMON_PROF_OFF
};
55 * See profil(2) where this is described:
58 #define SCALE_1_TO_1 0x10000L
60 #define ERR(s) write(2, s, sizeof(s) - 1)
64 * profiling is what mcount checks to see if
65 * all the data structures are ready.
68 DEFUN(moncontrol
, (mode
), int mode
)
70 struct gmonparam
*p
= &_gmonparam
;
75 profil((void *) p
->kcount
, p
->kcountsize
, p
->lowpc
, s_scale
);
76 p
->state
= GMON_PROF_ON
;
81 profil((void *) 0, 0, 0, 0);
82 p
->state
= GMON_PROF_OFF
;
88 DEFUN(monstartup
, (lowpc
, highpc
), u_long lowpc AND u_long highpc
)
92 struct gmonparam
*p
= &_gmonparam
;
95 * round lowpc and highpc to multiples of the density we're using
96 * so the rest of the scaling (here and in gprof) stays in ints.
98 p
->lowpc
= ROUNDDOWN(lowpc
, HISTFRACTION
* sizeof(HISTCOUNTER
));
99 p
->highpc
= ROUNDUP(highpc
, HISTFRACTION
* sizeof(HISTCOUNTER
));
100 p
->textsize
= p
->highpc
- p
->lowpc
;
101 p
->kcountsize
= p
->textsize
/ HISTFRACTION
;
102 p
->hashfraction
= HASHFRACTION
;
103 p
->log_hashfraction
= -1;
104 if ((HASHFRACTION
& (HASHFRACTION
- 1)) == 0) {
105 /* if HASHFRACTION is a power of two, mcount can use shifting
106 instead of integer division. Precompute shift amount. */
107 p
->log_hashfraction
= ffs(p
->hashfraction
* sizeof(*p
->froms
)) - 1;
109 p
->fromssize
= p
->textsize
/ HASHFRACTION
;
110 p
->tolimit
= p
->textsize
* ARCDENSITY
/ 100;
111 if (p
->tolimit
< MINARCS
)
112 p
->tolimit
= MINARCS
;
113 else if (p
->tolimit
> MAXARCS
)
114 p
->tolimit
= MAXARCS
;
115 p
->tossize
= p
->tolimit
* sizeof(struct tostruct
);
117 cp
= malloc (p
->kcountsize
+ p
->fromssize
+ p
->tossize
);
120 ERR("monstartup: out of memory\n");
123 bzero(cp
, p
->kcountsize
+ p
->fromssize
+ p
->tossize
);
124 p
->tos
= (struct tostruct
*)cp
;
126 p
->kcount
= (u_short
*)cp
;
128 p
->froms
= (u_short
*)cp
;
132 o
= p
->highpc
- p
->lowpc
;
133 if (p
->kcountsize
< (u_long
) o
)
136 s_scale
= ((float)p
->kcountsize
/ o
) * SCALE_1_TO_1
;
138 /* avoid floating point operations */
139 int quot
= o
/ p
->kcountsize
;
143 else if (quot
>= 0x100)
144 s_scale
= 0x10000 / quot
;
145 else if (o
>= 0x800000)
146 s_scale
= 0x1000000 / (o
/ (p
->kcountsize
>> 8));
148 s_scale
= 0x1000000 / ((o
<< 8) / p
->kcountsize
);
151 s_scale
= SCALE_1_TO_1
;
158 DEFUN(write_hist
, (fd
), int fd
)
160 const u_char tag
= GMON_TAG_TIME_HIST
;
161 struct gmon_hist_hdr thdr
;
164 if (_gmonparam
.kcountsize
> 0)
166 size
= _gmonparam
.kcountsize
/ sizeof(HISTCOUNTER
);
167 rate
= __profile_frequency();
168 bcopy(&_gmonparam
.lowpc
, &thdr
.low_pc
, sizeof(thdr
.low_pc
));
169 bcopy(&_gmonparam
.highpc
, &thdr
.high_pc
, sizeof(thdr
.high_pc
));
170 bcopy(&size
, &thdr
.hist_size
, sizeof(thdr
.hist_size
));
171 bcopy(&rate
, &thdr
.prof_rate
, sizeof(thdr
.prof_rate
));
172 strcpy(thdr
.dimen
, "seconds");
173 thdr
.dimen_abbrev
= 's';
175 write(fd
, &tag
, sizeof(tag
));
176 write(fd
, &thdr
, sizeof(thdr
));
177 write(fd
, _gmonparam
.kcount
, _gmonparam
.kcountsize
);
183 DEFUN(write_call_graph
, (fd
), int fd
)
185 const u_char tag
= GMON_TAG_CG_ARC
;
186 struct gmon_cg_arc_record raw_arc
;
187 int from_index
, to_index
, from_len
;
190 from_len
= _gmonparam
.fromssize
/ sizeof(*_gmonparam
.froms
);
191 for (from_index
= 0; from_index
< from_len
; ++from_index
)
193 if (_gmonparam
.froms
[from_index
] == 0)
196 frompc
= _gmonparam
.lowpc
;
197 frompc
+= (from_index
* _gmonparam
.hashfraction
198 * sizeof(*_gmonparam
.froms
));
199 for (to_index
= _gmonparam
.froms
[from_index
];
201 to_index
= _gmonparam
.tos
[to_index
].link
)
203 bcopy(&frompc
, &raw_arc
.from_pc
, sizeof(raw_arc
.from_pc
));
204 bcopy(&_gmonparam
.tos
[to_index
].selfpc
, &raw_arc
.self_pc
,
205 sizeof(raw_arc
.self_pc
));
206 bcopy(&_gmonparam
.tos
[to_index
].count
, &raw_arc
.count
,
207 sizeof(raw_arc
.count
));
209 write(fd
, &tag
, sizeof(tag
));
210 write(fd
, &raw_arc
, sizeof(raw_arc
));
217 DEFUN(write_bb_counts
, (fd
), int fd
)
220 const u_char tag
= GMON_TAG_BB_COUNT
;
224 /* Write each group of basic-block info (all basic-blocks in a
225 compilation unit form a single group). */
227 for (grp
= __bb_head
; grp
; grp
= grp
->next
)
229 ncounts
= grp
->ncounts
;
230 write(fd
, &tag
, sizeof(tag
));
231 write(fd
, &ncounts
, sizeof(ncounts
));
232 for (i
= 0; i
< ncounts
; ++i
)
234 write(fd
, &grp
->addresses
[i
], sizeof(grp
->addresses
[0]));
235 write(fd
, &grp
->counts
[i
], sizeof(grp
->counts
[0]));
242 DEFUN_VOID(_mcleanup
)
244 const int version
= GMON_VERSION
;
245 struct gmon_hdr ghdr
;
249 fd
= open("gmon.out", O_CREAT
|O_TRUNC
|O_WRONLY
, 0666);
252 perror("_mcleanup: gmon.out");
256 /* write gmon.out header: */
257 bcopy(GMON_MAGIC
, &ghdr
.cookie
[0], 4);
258 bcopy(&version
, &ghdr
.version
, sizeof(version
));
259 write(fd
, &ghdr
, sizeof(ghdr
));
261 /* write PC histogram: */
264 /* write call-graph: */
265 write_call_graph(fd
);
267 /* write basic-block execution counts: */