libgcc/libgcov-profiler.c

   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 */