1 /* Copyright (C) 2001-2023 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <https://www.gnu.org/licenses/>. */
23 #include <sigsetops.h>
26 #include <sys/profil.h>
29 # include <gmon/sprofil.c>
32 #include <libc-internal.h>
52 unsigned int num_regions
;
53 struct region
*region
;
54 struct region
*last
, *overflow
;
55 struct itimerval saved_timer
;
56 struct sigaction saved_action
;
59 static unsigned int overflow_counter
;
61 static struct region default_overflow_region
=
66 .sample
= { &overflow_counter
},
71 static struct prof_info prof_info
;
73 static unsigned long int
74 pc_to_index (size_t pc
, size_t offset
, unsigned int scale
, int prof_uint
)
76 size_t i
= (pc
- offset
) / (prof_uint
? sizeof (int) : sizeof (short));
78 if (sizeof (unsigned long long int) > sizeof (size_t))
79 return (unsigned long long int) i
* scale
/ 65536;
81 return i
/ 65536 * scale
+ i
% 65536 * scale
/ 65536;
85 index_to_pc (unsigned long int n
, size_t offset
, unsigned int scale
,
88 size_t pc
, bin_size
= (prof_uint
? sizeof (int) : sizeof (short));
90 if (sizeof (unsigned long long int) > sizeof (size_t))
91 pc
= offset
+ (unsigned long long int) n
* bin_size
* 65536ull / scale
;
93 pc
= (offset
+ n
* bin_size
/ scale
* 65536
94 + n
* bin_size
% scale
* 65536 / scale
);
96 if (pc_to_index (pc
, offset
, scale
, prof_uint
) < n
)
97 /* Adjust for rounding error. */
100 assert (pc_to_index (pc
- 1, offset
, scale
, prof_uint
) < n
101 && pc_to_index (pc
, offset
, scale
, prof_uint
) >= n
);
107 profil_count (uintptr_t pcp
, int prof_uint
)
109 struct region
*region
, *r
= prof_info
.last
;
110 size_t lo
, hi
, mid
, pc
= pcp
;
113 /* Fast path: pc is in same region as before. */
114 if (pc
>= r
->start
&& pc
< r
->end
)
118 /* Slow path: do a binary search for the right region. */
119 lo
= 0; hi
= prof_info
.num_regions
- 1;
124 r
= prof_info
.region
+ mid
;
125 if (pc
>= r
->start
&& pc
< r
->end
)
138 /* No matching region: increment overflow count. There is no point
139 in updating the cache here, as it won't hit anyhow. */
140 region
= prof_info
.overflow
;
143 i
= pc_to_index (pc
, region
->offset
, region
->scale
, prof_uint
);
148 if (r
->sample
.ui
[i
] < (unsigned int) ~0)
153 if (r
->sample
.us
[i
] < (unsigned short) ~0)
160 ++prof_info
.overflow
->sample
.ui
[0];
162 ++prof_info
.overflow
->sample
.us
[0];
166 /* Get the machine-dependent definition of `__profil_counter', the signal
167 handler for SIGPROF. It calls `profil_count' (above) with the PC of the
169 #define __profil_counter __profil_counter_ushort
170 #define profil_count(pc) profil_count (pc, 0)
171 #include <profil-counter.h>
173 #undef __profil_counter
176 #define __profil_counter __profil_counter_uint
177 #define profil_count(pc) profil_count (pc, 1)
178 #include <profil-counter.h>
181 insert (int i
, unsigned long int start
, unsigned long int end
, struct prof
*p
,
188 return 0; /* don't bother with empty regions */
190 if (prof_info
.num_regions
== 0)
191 r
= malloc (sizeof (*r
));
193 r
= realloc (prof_info
.region
, (prof_info
.num_regions
+ 1) * sizeof (*r
));
197 to_copy
= prof_info
.num_regions
- i
;
199 memmove (r
+ i
+ 1, r
+ i
, to_copy
* sizeof (*r
));
201 r
[i
].offset
= p
->pr_off
;
202 r
[i
].nsamples
= p
->pr_size
/ (prof_uint
? sizeof (int) : sizeof (short));
203 r
[i
].scale
= p
->pr_scale
;
204 r
[i
].sample
.vp
= p
->pr_base
;
208 prof_info
.region
= r
;
209 ++prof_info
.num_regions
;
211 if (p
->pr_off
== 0 && p
->pr_scale
== 2)
212 prof_info
.overflow
= r
;
217 /* Add a new profiling region. If the new region overlaps with
218 existing ones, this may add multiple subregions so that the final
219 data structure is free of overlaps. The absence of overlaps makes
220 it possible to use a binary search in profil_count(). Note that
221 this function depends on new regions being presented in DECREASING
222 ORDER of starting address. */
225 add_region (struct prof
*p
, int prof_uint
)
227 unsigned long int nsamples
;
234 nsamples
= p
->pr_size
/ (prof_uint
? sizeof (int) : sizeof (short));
237 end
= index_to_pc (nsamples
, p
->pr_off
, p
->pr_scale
, prof_uint
);
239 /* Merge with existing regions. */
240 for (i
= 0; i
< prof_info
.num_regions
; ++i
)
242 if (start
< prof_info
.region
[i
].start
)
244 if (end
< prof_info
.region
[i
].start
)
246 else if (insert (i
, start
, prof_info
.region
[i
].start
, p
, prof_uint
)
250 start
= prof_info
.region
[i
].end
;
252 return insert (i
, start
, end
, p
, prof_uint
);
256 pcmp (const void *left
, const void *right
)
258 struct prof
*l
= *(struct prof
**) left
;
259 struct prof
*r
= *(struct prof
**) right
;
261 if (l
->pr_off
< r
->pr_off
)
263 else if (l
->pr_off
> r
->pr_off
)
269 __sprofil (struct prof
*profp
, int profcnt
, struct timeval
*tvp
,
272 struct prof
*p
[profcnt
];
273 struct itimerval timer
;
274 struct sigaction act
;
279 /* Return profiling period. */
280 unsigned long int t
= 1000000 / __profile_frequency ();
281 tvp
->tv_sec
= t
/ 1000000;
282 tvp
->tv_usec
= t
% 1000000;
285 if (prof_info
.num_regions
> 0)
287 /* Disable profiling. */
288 if (__setitimer (ITIMER_PROF
, &prof_info
.saved_timer
, NULL
) < 0)
291 if (__sigaction (SIGPROF
, &prof_info
.saved_action
, NULL
) < 0)
294 free (prof_info
.region
);
298 prof_info
.num_regions
= 0;
299 prof_info
.region
= NULL
;
300 prof_info
.overflow
= &default_overflow_region
;
302 for (i
= 0; i
< profcnt
; ++i
)
305 /* Sort in order of decreasing starting address: */
306 qsort (p
, profcnt
, sizeof (p
[0]), pcmp
);
308 /* Add regions in order of decreasing starting address: */
309 for (i
= 0; i
< profcnt
; ++i
)
310 if (add_region (p
[i
], (flags
& PROF_UINT
) != 0) < 0)
312 free (prof_info
.region
);
313 prof_info
.num_regions
= 0;
314 prof_info
.region
= NULL
;
318 if (prof_info
.num_regions
== 0)
321 prof_info
.last
= prof_info
.region
;
323 /* Install SIGPROF handler. */
325 act
.sa_sigaction
= flags
& PROF_UINT
326 ? __profil_counter_uint
327 : __profil_counter_ushort
;
328 act
.sa_flags
= SA_SIGINFO
;
330 act
.sa_handler
= flags
& PROF_UINT
331 ? (sighandler_t
) __profil_counter_uint
332 : (sighandler_t
) __profil_counter_ushort
;
335 act
.sa_flags
|= SA_RESTART
;
336 __sigfillset (&act
.sa_mask
);
337 if (__sigaction (SIGPROF
, &act
, &prof_info
.saved_action
) < 0)
340 /* Setup profiling timer. */
341 timer
.it_value
.tv_sec
= 0;
342 timer
.it_value
.tv_usec
= 1;
343 timer
.it_interval
= timer
.it_value
;
344 return __setitimer (ITIMER_PROF
, &timer
, &prof_info
.saved_timer
);
347 weak_alias (__sprofil
, sprofil
)