libgcc/libgcov-profiler.c

   1 /* Routines required for instrumenting a program.  */
   2 /* Compile this one with gcc.  */
   3 /* Copyright (C) 1989-2014 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 #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.  */
  34
  35 void
  36 __gcov_interval_profiler (gcov_type *counters, gcov_type value,
  37                           int start, unsigned steps)
  38 {
  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]++;
  46 }
  47 #endif
  48
  49 #ifdef L_gcov_pow2_profiler
  50 /* If VALUE is a power of two, COUNTERS[1] is incremented.  Otherwise
  51    COUNTERS[0] is incremented.  */
  52
  53 void
  54 __gcov_pow2_profiler (gcov_type *counters, gcov_type value)
  55 {
  56   if (value & (value - 1))
  57     counters[0]++;
  58   else
  59     counters[1]++;
  60 }
  61 #endif
  62
  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.
  70
  71    In any case, COUNTERS[2] is incremented.  */
  72
  73 static inline void
  74 __gcov_one_value_profiler_body (gcov_type *counters, gcov_type value)
  75 {
  76   if (value == counters[0])
  77     counters[1]++;
  78   else if (counters[1] == 0)
  79     {
  80       counters[1] = 1;
  81       counters[0] = value;
  82     }
  83   else
  84     counters[1]--;
  85   counters[2]++;
  86 }
  87
  88 #ifdef L_gcov_one_value_profiler
  89 void
  90 __gcov_one_value_profiler (gcov_type *counters, gcov_type value)
  91 {
  92   __gcov_one_value_profiler_body (counters, value);
  93 }
  94 #endif
  95
  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.  */
  99
 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.
 107
 108    It is assumed that the address of a function descriptor may be treated
 109    as a pointer to a function.  */
 110
 111 #ifdef TARGET_VTABLE_USES_DESCRIPTORS
 112 #define VTABLE_USES_DESCRIPTORS 1
 113 #else
 114 #define VTABLE_USES_DESCRIPTORS 0
 115 #endif
 116
 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)
 121 {
 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);
 129 }
 130
 131 #endif
 132 #ifdef L_gcov_indirect_call_profiler_v2
 133
 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  */
 138
 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;
 147
 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.
 155
 156    It is assumed that the address of a function descriptor may be treated
 157    as a pointer to a function.  */
 158
 159 #ifdef TARGET_VTABLE_USES_DESCRIPTORS
 160 #define VTABLE_USES_DESCRIPTORS 1
 161 #else
 162 #define VTABLE_USES_DESCRIPTORS 0
 163 #endif
 164
 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)
 168 {
 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);
 176 }
 177 #endif
 178
 179 #ifdef L_gcov_time_profiler
 180
 181 /* Counter for first visit of each function.  */
 182 static gcov_type function_counter;
 183
 184 /* Sets corresponding COUNTERS if there is no value.  */
 185
 186 void
 187 __gcov_time_profiler (gcov_type* counters)
 188 {
 189   if (!counters[0])
 190     counters[0] = ++function_counter;
 191 }
 192 #endif
 193
 194 #ifdef L_gcov_average_profiler
 195 /* Increase corresponding COUNTER by VALUE.  FIXME: Perhaps we want
 196    to saturate up.  */
 197
 198 void
 199 __gcov_average_profiler (gcov_type *counters, gcov_type value)
 200 {
 201   counters[0] += value;
 202   counters[1] ++;
 203 }
 204 #endif
 205
 206 #ifdef L_gcov_ior_profiler
 207 /* Bitwise-OR VALUE into COUNTER.  */
 208
 209 void
 210 __gcov_ior_profiler (gcov_type *counters, gcov_type value)
 211 {
 212   *counters |= value;
 213 }
 214 #endif
 215
 216 #endif /* inhibit_libc */