Daily bump.
[official-gcc.git] / libgcc / libgcov-profiler.c
blob3290bf62cc2b0dee064a7b095fb9d3d7bf01e584
1 /* Routines required for instrumenting a program. */
2 /* Compile this one with gcc. */
3 /* Copyright (C) 1989-2014 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
17 Under Section 7 of GPL version 3, you are granted additional
18 permissions described in the GCC Runtime Library Exception, version
19 3.1, as published by the Free Software Foundation.
21 You should have received a copy of the GNU General Public License and
22 a copy of the GCC Runtime Library Exception along with this program;
23 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 <http://www.gnu.org/licenses/>. */
26 #include "libgcov.h"
27 #if !defined(inhibit_libc)
29 #ifdef L_gcov_interval_profiler
30 /* If VALUE is in interval <START, START + STEPS - 1>, then increases the
31 corresponding counter in COUNTERS. If the VALUE is above or below
32 the interval, COUNTERS[STEPS] or COUNTERS[STEPS + 1] is increased
33 instead. */
35 void
36 __gcov_interval_profiler (gcov_type *counters, gcov_type value,
37 int start, unsigned steps)
39 gcov_type delta = value - start;
40 if (delta < 0)
41 counters[steps + 1]++;
42 else if (delta >= steps)
43 counters[steps]++;
44 else
45 counters[delta]++;
47 #endif
49 #ifdef L_gcov_pow2_profiler
50 /* If VALUE is a power of two, COUNTERS[1] is incremented. Otherwise
51 COUNTERS[0] is incremented. */
53 void
54 __gcov_pow2_profiler (gcov_type *counters, gcov_type value)
56 if (value & (value - 1))
57 counters[0]++;
58 else
59 counters[1]++;
61 #endif
63 /* Tries to determine the most common value among its inputs. Checks if the
64 value stored in COUNTERS[0] matches VALUE. If this is the case, COUNTERS[1]
65 is incremented. If this is not the case and COUNTERS[1] is not zero,
66 COUNTERS[1] is decremented. Otherwise COUNTERS[1] is set to one and
67 VALUE is stored to COUNTERS[0]. This algorithm guarantees that if this
68 function is called more than 50% of the time with one value, this value
69 will be in COUNTERS[0] in the end.
71 In any case, COUNTERS[2] is incremented. */
73 static inline void
74 __gcov_one_value_profiler_body (gcov_type *counters, gcov_type value)
76 if (value == counters[0])
77 counters[1]++;
78 else if (counters[1] == 0)
80 counters[1] = 1;
81 counters[0] = value;
83 else
84 counters[1]--;
85 counters[2]++;
88 #ifdef L_gcov_one_value_profiler
89 void
90 __gcov_one_value_profiler (gcov_type *counters, gcov_type value)
92 __gcov_one_value_profiler_body (counters, value);
94 #endif
96 #ifdef L_gcov_indirect_call_profiler
97 /* This function exist only for workaround of binutils bug 14342.
98 Once this compatibility hack is obsolette, it can be removed. */
100 /* By default, the C++ compiler will use function addresses in the
101 vtable entries. Setting TARGET_VTABLE_USES_DESCRIPTORS to nonzero
102 tells the compiler to use function descriptors instead. The value
103 of this macro says how many words wide the descriptor is (normally 2),
104 but it may be dependent on target flags. Since we do not have access
105 to the target flags here we just check to see if it is set and use
106 that to set VTABLE_USES_DESCRIPTORS to 0 or 1.
108 It is assumed that the address of a function descriptor may be treated
109 as a pointer to a function. */
111 #ifdef TARGET_VTABLE_USES_DESCRIPTORS
112 #define VTABLE_USES_DESCRIPTORS 1
113 #else
114 #define VTABLE_USES_DESCRIPTORS 0
115 #endif
117 /* Tries to determine the most common value among its inputs. */
118 void
119 __gcov_indirect_call_profiler (gcov_type* counter, gcov_type value,
120 void* cur_func, void* callee_func)
122 /* If the C++ virtual tables contain function descriptors then one
123 function may have multiple descriptors and we need to dereference
124 the descriptors to see if they point to the same function. */
125 if (cur_func == callee_func
126 || (VTABLE_USES_DESCRIPTORS && callee_func
127 && *(void **) cur_func == *(void **) callee_func))
128 __gcov_one_value_profiler_body (counter, value);
131 #endif
132 #ifdef L_gcov_indirect_call_profiler_v2
134 /* These two variables are used to actually track caller and callee. Keep
135 them in TLS memory so races are not common (they are written to often).
136 The variables are set directly by GCC instrumented code, so declaration
137 here must match one in tree-profile.c */
139 #if defined(HAVE_CC_TLS) && !defined (USE_EMUTLS)
140 __thread
141 #endif
142 void * __gcov_indirect_call_callee;
143 #if defined(HAVE_CC_TLS) && !defined (USE_EMUTLS)
144 __thread
145 #endif
146 gcov_type * __gcov_indirect_call_counters;
148 /* By default, the C++ compiler will use function addresses in the
149 vtable entries. Setting TARGET_VTABLE_USES_DESCRIPTORS to nonzero
150 tells the compiler to use function descriptors instead. The value
151 of this macro says how many words wide the descriptor is (normally 2),
152 but it may be dependent on target flags. Since we do not have access
153 to the target flags here we just check to see if it is set and use
154 that to set VTABLE_USES_DESCRIPTORS to 0 or 1.
156 It is assumed that the address of a function descriptor may be treated
157 as a pointer to a function. */
159 #ifdef TARGET_VTABLE_USES_DESCRIPTORS
160 #define VTABLE_USES_DESCRIPTORS 1
161 #else
162 #define VTABLE_USES_DESCRIPTORS 0
163 #endif
165 /* Tries to determine the most common value among its inputs. */
166 void
167 __gcov_indirect_call_profiler_v2 (gcov_type value, void* cur_func)
169 /* If the C++ virtual tables contain function descriptors then one
170 function may have multiple descriptors and we need to dereference
171 the descriptors to see if they point to the same function. */
172 if (cur_func == __gcov_indirect_call_callee
173 || (VTABLE_USES_DESCRIPTORS && __gcov_indirect_call_callee
174 && *(void **) cur_func == *(void **) __gcov_indirect_call_callee))
175 __gcov_one_value_profiler_body (__gcov_indirect_call_counters, value);
177 #endif
179 #ifdef L_gcov_time_profiler
181 /* Counter for first visit of each function. */
182 static gcov_type function_counter;
184 /* Sets corresponding COUNTERS if there is no value. */
186 void
187 __gcov_time_profiler (gcov_type* counters)
189 if (!counters[0])
190 counters[0] = ++function_counter;
192 #endif
194 #ifdef L_gcov_average_profiler
195 /* Increase corresponding COUNTER by VALUE. FIXME: Perhaps we want
196 to saturate up. */
198 void
199 __gcov_average_profiler (gcov_type *counters, gcov_type value)
201 counters[0] += value;
202 counters[1] ++;
204 #endif
206 #ifdef L_gcov_ior_profiler
207 /* Bitwise-OR VALUE into COUNTER. */
209 void
210 __gcov_ior_profiler (gcov_type *counters, gcov_type value)
212 *counters |= value;
214 #endif
216 #endif /* inhibit_libc */