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   for (unsigned i = 0; i < GCOV_TOPN_VALUES; i++)
 123     {
 124       if (value == counters[2 * i])
 125         {
 126           if (use_atomic)
 127             __atomic_fetch_add (&counters[2 * i + 1], GCOV_TOPN_VALUES,
 128                                 __ATOMIC_RELAXED);
 129           else
 130             counters[2 * i + 1] += GCOV_TOPN_VALUES;
 131           return;
 132         }
 133       else if (counters[2 * i + 1] <= 0)
 134         {
 135           /* We found an empty slot.  */
 136           counters[2 * i] = value;
 137           counters[2 * i + 1] = GCOV_TOPN_VALUES;
 138           return;
 139         }
 140     }
 141
 142   /* We haven't found an empty slot, then decrement all
 143      counter values by one.  */
 144   for (unsigned i = 0; i < GCOV_TOPN_VALUES; i++)
 145     {
 146       if (use_atomic)
 147         __atomic_fetch_sub (&counters[2 * i + 1], 1, __ATOMIC_RELAXED);
 148       else
 149         counters[2 * i + 1]--;
 150     }
 151 }
 152
 153 #ifdef L_gcov_topn_values_profiler
 154 void
 155 __gcov_topn_values_profiler (gcov_type *counters, gcov_type value)
 156 {
 157   __gcov_topn_values_profiler_body (counters, value, 0);
 158 }
 159 #endif
 160
 161 #if defined(L_gcov_topn_values_profiler_atomic) && GCOV_SUPPORTS_ATOMIC
 162
 163 /* Update one value profilers (COUNTERS) for a given VALUE.
 164
 165    CAVEAT: Following function is not thread-safe, only total number
 166    of executions (COUNTERS[2]) is update with an atomic instruction.
 167    Problem is that one cannot atomically update two counters
 168    (COUNTERS[0] and COUNTERS[1]), for more information please read
 169    following email thread:
 170    https://gcc.gnu.org/ml/gcc-patches/2016-08/msg00024.html.  */
 171
 172 void
 173 __gcov_topn_values_profiler_atomic (gcov_type *counters, gcov_type value)
 174 {
 175   __gcov_topn_values_profiler_body (counters, value, 1);
 176 }
 177 #endif
 178
 179 #ifdef L_gcov_indirect_call_profiler_v4
 180
 181 /* These two variables are used to actually track caller and callee.  Keep
 182    them in TLS memory so races are not common (they are written to often).
 183    The variables are set directly by GCC instrumented code, so declaration
 184    here must match one in tree-profile.c  */
 185
 186 #if defined(HAVE_CC_TLS) && !defined (USE_EMUTLS)
 187 __thread
 188 #endif
 189 struct indirect_call_tuple __gcov_indirect_call;
 190
 191 /* By default, the C++ compiler will use function addresses in the
 192    vtable entries.  Setting TARGET_VTABLE_USES_DESCRIPTORS to nonzero
 193    tells the compiler to use function descriptors instead.  The value
 194    of this macro says how many words wide the descriptor is (normally 2).
 195
 196    It is assumed that the address of a function descriptor may be treated
 197    as a pointer to a function.  */
 198
 199 /* Tries to determine the most common value among its inputs. */
 200 void
 201 __gcov_indirect_call_profiler_v4 (gcov_type value, void* cur_func)
 202 {
 203   /* If the C++ virtual tables contain function descriptors then one
 204      function may have multiple descriptors and we need to dereference
 205      the descriptors to see if they point to the same function.  */
 206   if (cur_func == __gcov_indirect_call.callee
 207       || (__LIBGCC_VTABLE_USES_DESCRIPTORS__
 208           && *(void **) cur_func == *(void **) __gcov_indirect_call.callee))
 209     __gcov_topn_values_profiler_body (__gcov_indirect_call.counters, value, 0);
 210
 211   __gcov_indirect_call.callee = NULL;
 212 }
 213 #endif
 214
 215 #ifdef L_gcov_time_profiler
 216
 217 /* Counter for first visit of each function.  */
 218 gcov_type __gcov_time_profiler_counter ATTRIBUTE_HIDDEN;
 219
 220 #endif
 221
 222 #ifdef L_gcov_average_profiler
 223 /* Increase corresponding COUNTER by VALUE.  FIXME: Perhaps we want
 224    to saturate up.  */
 225
 226 void
 227 __gcov_average_profiler (gcov_type *counters, gcov_type value)
 228 {
 229   counters[0] += value;
 230   counters[1] ++;
 231 }
 232 #endif
 233
 234 #if defined(L_gcov_average_profiler_atomic) && GCOV_SUPPORTS_ATOMIC
 235 /* Increase corresponding COUNTER by VALUE.  FIXME: Perhaps we want
 236    to saturate up.  Function is thread-safe.  */
 237
 238 void
 239 __gcov_average_profiler_atomic (gcov_type *counters, gcov_type value)
 240 {
 241   __atomic_fetch_add (&counters[0], value, __ATOMIC_RELAXED);
 242   __atomic_fetch_add (&counters[1], 1, __ATOMIC_RELAXED);
 243 }
 244 #endif
 245
 246 #ifdef L_gcov_ior_profiler
 247 /* Bitwise-OR VALUE into COUNTER.  */
 248
 249 void
 250 __gcov_ior_profiler (gcov_type *counters, gcov_type value)
 251 {
 252   *counters |= value;
 253 }
 254 #endif
 255
 256 #if defined(L_gcov_ior_profiler_atomic) && GCOV_SUPPORTS_ATOMIC
 257 /* Bitwise-OR VALUE into COUNTER.  Function is thread-safe.  */
 258
 259 void
 260 __gcov_ior_profiler_atomic (gcov_type *counters, gcov_type value)
 261 {
 262   __atomic_fetch_or (&counters[0], value, __ATOMIC_RELAXED);
 263 }
 264 #endif
 265
 266
 267 #endif /* inhibit_libc */