1 /* Routines required for instrumenting a program. */ 2 /* Compile this one with gcc. */ 3 /* Copyright (C) 1989-2020 Free Software Foundation, Inc. 4 5 This file is part of GCC. 6 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. 11 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. 16 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. 20 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/>. */ 25 26 #include "libgcov.h" 27 #if !defined(inhibit_libc) 28 29 /* Detect whether target can support atomic update of profilers. */ 30 #if __SIZEOF_LONG_LONG__ == 4 && __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 31 #define GCOV_SUPPORTS_ATOMIC 1 32 #else 33 #if __SIZEOF_LONG_LONG__ == 8 && __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 34 #define GCOV_SUPPORTS_ATOMIC 1 35 #else 36 #define GCOV_SUPPORTS_ATOMIC 0 37 #endif 38 #endif 39 40 #ifdef L_gcov_interval_profiler 41 /* If VALUE is in interval <START, START + STEPS - 1>, then increases the 42 corresponding counter in COUNTERS. If the VALUE is above or below 43 the interval, COUNTERS[STEPS] or COUNTERS[STEPS + 1] is increased 44 instead. */ 45 46 void 47 __gcov_interval_profiler (gcov_type *counters, gcov_type value, 48 int start, unsigned steps) 49 { 50 gcov_type delta = value - start; 51 if (delta < 0) 52 counters[steps + 1]++; 53 else if (delta >= steps) 54 counters[steps]++; 55 else 56 counters[delta]++; 57 } 58 #endif 59 60 #if defined(L_gcov_interval_profiler_atomic) && GCOV_SUPPORTS_ATOMIC 61 /* If VALUE is in interval <START, START + STEPS - 1>, then increases the 62 corresponding counter in COUNTERS. If the VALUE is above or below 63 the interval, COUNTERS[STEPS] or COUNTERS[STEPS + 1] is increased 64 instead. Function is thread-safe. */ 65 66 void 67 __gcov_interval_profiler_atomic (gcov_type *counters, gcov_type value, 68 int start, unsigned steps) 69 { 70 gcov_type delta = value - start; 71 if (delta < 0) 72 __atomic_fetch_add (&counters[steps + 1], 1, __ATOMIC_RELAXED); 73 else if (delta >= steps) 74 __atomic_fetch_add (&counters[steps], 1, __ATOMIC_RELAXED); 75 else 76 __atomic_fetch_add (&counters[delta], 1, __ATOMIC_RELAXED); 77 } 78 #endif 79 80 #ifdef L_gcov_pow2_profiler 81 /* If VALUE is a power of two, COUNTERS[1] is incremented. Otherwise 82 COUNTERS[0] is incremented. */ 83 84 void 85 __gcov_pow2_profiler (gcov_type *counters, gcov_type value) 86 { 87 if (value == 0 || (value & (value - 1))) 88 counters[0]++; 89 else 90 counters[1]++; 91 } 92 #endif 93 94 #if defined(L_gcov_pow2_profiler_atomic) && GCOV_SUPPORTS_ATOMIC 95 /* If VALUE is a power of two, COUNTERS[1] is incremented. Otherwise 96 COUNTERS[0] is incremented. Function is thread-safe. */ 97 98 void 99 __gcov_pow2_profiler_atomic (gcov_type *counters, gcov_type value) 100 { 101 if (value == 0 || (value & (value - 1))) 102 __atomic_fetch_add (&counters[0], 1, __ATOMIC_RELAXED); 103 else 104 __atomic_fetch_add (&counters[1], 1, __ATOMIC_RELAXED); 105 } 106 #endif 107 108 109 /* Tries to determine N most commons value among its inputs. */ 110 111 static inline void 112 __gcov_topn_values_profiler_body (gcov_type *counters, gcov_type value, 113 int use_atomic) 114 { 115 if (use_atomic) 116 __atomic_fetch_add (&counters[0], 1, __ATOMIC_RELAXED); 117 else 118 counters[0]++; 119 120 ++counters; 121 122 /* First try to find an existing value. */ 123 int empty_counter = -1; 124 125 for (unsigned i = 0; i < GCOV_TOPN_VALUES; i++) 126 if (value == counters[2 * i]) 127 { 128 if (use_atomic) 129 __atomic_fetch_add (&counters[2 * i + 1], GCOV_TOPN_VALUES, 130 __ATOMIC_RELAXED); 131 else 132 counters[2 * i + 1] += GCOV_TOPN_VALUES; 133 return; 134 } 135 else if (counters[2 * i + 1] <= 0) 136 empty_counter = i; 137 138 /* Find an empty slot for a new value. */ 139 if (empty_counter != -1) 140 { 141 counters[2 * empty_counter] = value; 142 counters[2 * empty_counter + 1] = GCOV_TOPN_VALUES; 143 return; 144 } 145 146 /* We haven't found an empty slot, then decrement all 147 counter values by one. */ 148 for (unsigned i = 0; i < GCOV_TOPN_VALUES; i++) 149 if (use_atomic) 150 __atomic_fetch_sub (&counters[2 * i + 1], 1, __ATOMIC_RELAXED); 151 else 152 counters[2 * i + 1]--; 153 } 154 155 #ifdef L_gcov_topn_values_profiler 156 void 157 __gcov_topn_values_profiler (gcov_type *counters, gcov_type value) 158 { 159 __gcov_topn_values_profiler_body (counters, value, 0); 160 } 161 #endif 162 163 #if defined(L_gcov_topn_values_profiler_atomic) && GCOV_SUPPORTS_ATOMIC 164 165 /* Update one value profilers (COUNTERS) for a given VALUE. 166 167 CAVEAT: Following function is not thread-safe, only total number 168 of executions (COUNTERS[2]) is update with an atomic instruction. 169 Problem is that one cannot atomically update two counters 170 (COUNTERS[0] and COUNTERS[1]), for more information please read 171 following email thread: 172 https://gcc.gnu.org/ml/gcc-patches/2016-08/msg00024.html. */ 173 174 void 175 __gcov_topn_values_profiler_atomic (gcov_type *counters, gcov_type value) 176 { 177 __gcov_topn_values_profiler_body (counters, value, 1); 178 } 179 #endif 180 181 #ifdef L_gcov_indirect_call_profiler_v4 182 183 /* These two variables are used to actually track caller and callee. Keep 184 them in TLS memory so races are not common (they are written to often). 185 The variables are set directly by GCC instrumented code, so declaration 186 here must match one in tree-profile.c */ 187 188 #if defined(HAVE_CC_TLS) && !defined (USE_EMUTLS) 189 __thread 190 #endif 191 struct indirect_call_tuple __gcov_indirect_call; 192 193 /* By default, the C++ compiler will use function addresses in the 194 vtable entries. Setting TARGET_VTABLE_USES_DESCRIPTORS to nonzero 195 tells the compiler to use function descriptors instead. The value 196 of this macro says how many words wide the descriptor is (normally 2). 197 198 It is assumed that the address of a function descriptor may be treated 199 as a pointer to a function. */ 200 201 /* Tries to determine the most common value among its inputs. */ 202 static inline void 203 __gcov_indirect_call_profiler_body (gcov_type value, void *cur_func, 204 int use_atomic) 205 { 206 /* If the C++ virtual tables contain function descriptors then one 207 function may have multiple descriptors and we need to dereference 208 the descriptors to see if they point to the same function. */ 209 if (cur_func == __gcov_indirect_call.callee 210 || (__LIBGCC_VTABLE_USES_DESCRIPTORS__ 211 && *(void **) cur_func == *(void **) __gcov_indirect_call.callee)) 212 __gcov_topn_values_profiler_body (__gcov_indirect_call.counters, value, 213 use_atomic); 214 215 __gcov_indirect_call.callee = NULL; 216 } 217 218 void 219 __gcov_indirect_call_profiler_v4 (gcov_type value, void *cur_func) 220 { 221 __gcov_indirect_call_profiler_body (value, cur_func, 0); 222 } 223 224 #if GCOV_SUPPORTS_ATOMIC 225 void 226 __gcov_indirect_call_profiler_v4_atomic (gcov_type value, void *cur_func) 227 { 228 __gcov_indirect_call_profiler_body (value, cur_func, 1); 229 } 230 #endif 231 232 #endif 233 234 #ifdef L_gcov_time_profiler 235 236 /* Counter for first visit of each function. */ 237 gcov_type __gcov_time_profiler_counter ATTRIBUTE_HIDDEN; 238 239 #endif 240 241 #ifdef L_gcov_average_profiler 242 /* Increase corresponding COUNTER by VALUE. FIXME: Perhaps we want 243 to saturate up. */ 244 245 void 246 __gcov_average_profiler (gcov_type *counters, gcov_type value) 247 { 248 counters[0] += value; 249 counters[1] ++; 250 } 251 #endif 252 253 #if defined(L_gcov_average_profiler_atomic) && GCOV_SUPPORTS_ATOMIC 254 /* Increase corresponding COUNTER by VALUE. FIXME: Perhaps we want 255 to saturate up. Function is thread-safe. */ 256 257 void 258 __gcov_average_profiler_atomic (gcov_type *counters, gcov_type value) 259 { 260 __atomic_fetch_add (&counters[0], value, __ATOMIC_RELAXED); 261 __atomic_fetch_add (&counters[1], 1, __ATOMIC_RELAXED); 262 } 263 #endif 264 265 #ifdef L_gcov_ior_profiler 266 /* Bitwise-OR VALUE into COUNTER. */ 267 268 void 269 __gcov_ior_profiler (gcov_type *counters, gcov_type value) 270 { 271 *counters |= value; 272 } 273 #endif 274 275 #if defined(L_gcov_ior_profiler_atomic) && GCOV_SUPPORTS_ATOMIC 276 /* Bitwise-OR VALUE into COUNTER. Function is thread-safe. */ 277 278 void 279 __gcov_ior_profiler_atomic (gcov_type *counters, gcov_type value) 280 { 281 __atomic_fetch_or (&counters[0], value, __ATOMIC_RELAXED); 282 } 283 #endif 284 285 286 #endif /* inhibit_libc */ 287