libgcc/libgcov.h

   1 /* Header file for libgcov-*.c.
   2    Copyright (C) 1996-2020 Free Software Foundation, Inc.
   3
   4    This file is part of GCC.
   5
   6    GCC is free software; you can redistribute it and/or modify it under
   7    the terms of the GNU General Public License as published by the Free
   8    Software Foundation; either version 3, or (at your option) any later
   9    version.
  10
  11    GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12    WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14    for more details.
  15
  16    Under Section 7 of GPL version 3, you are granted additional
  17    permissions described in the GCC Runtime Library Exception, version
  18    3.1, as published by the Free Software Foundation.
  19
  20    You should have received a copy of the GNU General Public License and
  21    a copy of the GCC Runtime Library Exception along with this program;
  22    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23    <http://www.gnu.org/licenses/>.  */
  24
  25 #ifndef GCC_LIBGCOV_H
  26 #define GCC_LIBGCOV_H
  27
  28 /* work around the poisoned malloc/calloc in system.h.  */
  29 #ifndef xmalloc
  30 #define xmalloc malloc
  31 #endif
  32 #ifndef xcalloc
  33 #define xcalloc calloc
  34 #endif
  35
  36 #ifndef IN_GCOV_TOOL
  37 /* About the target.  */
  38 /* This path will be used by libgcov runtime.  */
  39
  40 #include "tconfig.h"
  41 #include "auto-target.h"
  42 #include "tsystem.h"
  43 #include "coretypes.h"
  44 #include "tm.h"
  45 #include "libgcc_tm.h"
  46 #include "gcov.h"
  47
  48 #if __CHAR_BIT__ == 8
  49 typedef unsigned gcov_unsigned_t __attribute__ ((mode (SI)));
  50 typedef unsigned gcov_position_t __attribute__ ((mode (SI)));
  51 #if LONG_LONG_TYPE_SIZE > 32
  52 typedef signed gcov_type __attribute__ ((mode (DI)));
  53 typedef unsigned gcov_type_unsigned __attribute__ ((mode (DI)));
  54 #else
  55 typedef signed gcov_type __attribute__ ((mode (SI)));
  56 typedef unsigned gcov_type_unsigned __attribute__ ((mode (SI)));
  57 #endif
  58 #else
  59 #if __CHAR_BIT__ == 16
  60 typedef unsigned gcov_unsigned_t __attribute__ ((mode (HI)));
  61 typedef unsigned gcov_position_t __attribute__ ((mode (HI)));
  62 #if LONG_LONG_TYPE_SIZE > 32
  63 typedef signed gcov_type __attribute__ ((mode (SI)));
  64 typedef unsigned gcov_type_unsigned __attribute__ ((mode (SI)));
  65 #else
  66 typedef signed gcov_type __attribute__ ((mode (HI)));
  67 typedef unsigned gcov_type_unsigned __attribute__ ((mode (HI)));
  68 #endif
  69 #else
  70 typedef unsigned gcov_unsigned_t __attribute__ ((mode (QI)));
  71 typedef unsigned gcov_position_t __attribute__ ((mode (QI)));
  72 #if LONG_LONG_TYPE_SIZE > 32
  73 typedef signed gcov_type __attribute__ ((mode (HI)));
  74 typedef unsigned gcov_type_unsigned __attribute__ ((mode (HI)));
  75 #else
  76 typedef signed gcov_type __attribute__ ((mode (QI)));
  77 typedef unsigned gcov_type_unsigned __attribute__ ((mode (QI)));
  78 #endif
  79 #endif
  80 #endif
  81
  82 #if defined (TARGET_POSIX_IO)
  83 #define GCOV_LOCKED 1
  84 #else
  85 #define GCOV_LOCKED 0
  86 #endif
  87
  88 /* In libgcov we need these functions to be extern, so prefix them with
  89    __gcov.  In libgcov they must also be hidden so that the instance in
  90    the executable is not also used in a DSO.  */
  91 #define gcov_var __gcov_var
  92 #define gcov_open __gcov_open
  93 #define gcov_close __gcov_close
  94 #define gcov_write_tag_length __gcov_write_tag_length
  95 #define gcov_position __gcov_position
  96 #define gcov_seek __gcov_seek
  97 #define gcov_rewrite __gcov_rewrite
  98 #define gcov_is_error __gcov_is_error
  99 #define gcov_write_unsigned __gcov_write_unsigned
 100 #define gcov_write_counter __gcov_write_counter
 101 #define gcov_write_summary __gcov_write_summary
 102 #define gcov_read_unsigned __gcov_read_unsigned
 103 #define gcov_read_counter __gcov_read_counter
 104 #define gcov_read_summary __gcov_read_summary
 105
 106 #else /* IN_GCOV_TOOL */
 107 /* About the host.  */
 108 /* This path will be compiled for the host and linked into
 109    gcov-tool binary.  */
 110
 111 #include "config.h"
 112 #include "system.h"
 113 #include "coretypes.h"
 114 #include "tm.h"
 115
 116 typedef unsigned gcov_unsigned_t;
 117 typedef unsigned gcov_position_t;
 118 /* gcov_type is typedef'd elsewhere for the compiler */
 119 #if defined (HOST_HAS_F_SETLKW)
 120 #define GCOV_LOCKED 1
 121 #else
 122 #define GCOV_LOCKED 0
 123 #endif
 124
 125 /* Some Macros specific to gcov-tool.  */
 126
 127 #define L_gcov 1
 128 #define L_gcov_merge_add 1
 129 #define L_gcov_merge_topn 1
 130 #define L_gcov_merge_ior 1
 131 #define L_gcov_merge_time_profile 1
 132
 133 extern gcov_type gcov_read_counter_mem ();
 134 extern unsigned gcov_get_merge_weight ();
 135 extern struct gcov_info *gcov_list;
 136
 137 #endif /* !IN_GCOV_TOOL */
 138
 139 #if defined(inhibit_libc)
 140 #define IN_LIBGCOV (-1)
 141 #else
 142 #define IN_LIBGCOV 1
 143 #if defined(L_gcov)
 144 #define GCOV_LINKAGE /* nothing */
 145 #endif
 146 #endif
 147
 148 /* Poison these, so they don't accidentally slip in.  */
 149 #pragma GCC poison gcov_write_string gcov_write_tag gcov_write_length
 150 #pragma GCC poison gcov_time
 151
 152 #ifdef HAVE_GAS_HIDDEN
 153 #define ATTRIBUTE_HIDDEN  __attribute__ ((__visibility__ ("hidden")))
 154 #else
 155 #define ATTRIBUTE_HIDDEN
 156 #endif
 157
 158 #include "gcov-io.h"
 159
 160 /* Structures embedded in coveraged program.  The structures generated
 161    by write_profile must match these.  */
 162
 163 /* Information about counters for a single function.  */
 164 struct gcov_ctr_info
 165 {
 166   gcov_unsigned_t num;          /* number of counters.  */
 167   gcov_type *values;            /* their values.  */
 168 };
 169
 170 /* Information about a single function.  This uses the trailing array
 171    idiom. The number of counters is determined from the merge pointer
 172    array in gcov_info.  The key is used to detect which of a set of
 173    comdat functions was selected -- it points to the gcov_info object
 174    of the object file containing the selected comdat function.  */
 175
 176 struct gcov_fn_info
 177 {
 178   const struct gcov_info *key;          /* comdat key */
 179   gcov_unsigned_t ident;                /* unique ident of function */
 180   gcov_unsigned_t lineno_checksum;      /* function lineo_checksum */
 181   gcov_unsigned_t cfg_checksum;         /* function cfg checksum */
 182   struct gcov_ctr_info ctrs[1];         /* instrumented counters */
 183 };
 184
 185 /* Type of function used to merge counters.  */
 186 typedef void (*gcov_merge_fn) (gcov_type *, gcov_unsigned_t);
 187
 188 /* Information about a single object file.  */
 189 struct gcov_info
 190 {
 191   gcov_unsigned_t version;      /* expected version number */
 192   struct gcov_info *next;       /* link to next, used by libgcov */
 193
 194   gcov_unsigned_t stamp;        /* uniquifying time stamp */
 195   const char *filename;         /* output file name */
 196
 197   gcov_merge_fn merge[GCOV_COUNTERS];  /* merge functions (null for
 198                                           unused) */
 199
 200   unsigned n_functions;         /* number of functions */
 201
 202 #ifndef IN_GCOV_TOOL
 203   const struct gcov_fn_info *const *functions; /* pointer to pointers
 204                                                   to function information  */
 205 #else
 206   const struct gcov_fn_info **functions;
 207 #endif /* !IN_GCOV_TOOL */
 208 };
 209
 210 /* Root of a program/shared-object state */
 211 struct gcov_root
 212 {
 213   struct gcov_info *list;
 214   unsigned dumped : 1;  /* counts have been dumped.  */
 215   unsigned run_counted : 1;  /* run has been accounted for.  */
 216   struct gcov_root *next;
 217   struct gcov_root *prev;
 218 };
 219
 220 extern struct gcov_root __gcov_root ATTRIBUTE_HIDDEN;
 221
 222 struct gcov_master
 223 {
 224   gcov_unsigned_t version;
 225   struct gcov_root *root;
 226 };
 227
 228 struct indirect_call_tuple
 229 {
 230   /* Callee function.  */
 231   void *callee;
 232
 233   /* Pointer to counters.  */
 234   gcov_type *counters;
 235 };
 236
 237 /* Exactly one of these will be active in the process.  */
 238 extern struct gcov_master __gcov_master;
 239
 240 /* Dump a set of gcov objects.  */
 241 extern void __gcov_dump_one (struct gcov_root *) ATTRIBUTE_HIDDEN;
 242
 243 /* Register a new object file module.  */
 244 extern void __gcov_init (struct gcov_info *) ATTRIBUTE_HIDDEN;
 245
 246 /* GCOV exit function registered via a static destructor.  */
 247 extern void __gcov_exit (void) ATTRIBUTE_HIDDEN;
 248
 249 /* Function to reset all counters to 0.  Both externally visible (and
 250    overridable) and internal version.  */
 251 extern void __gcov_reset_int (void) ATTRIBUTE_HIDDEN;
 252
 253 /* User function to enable early write of profile information so far.  */
 254 extern void __gcov_dump_int (void) ATTRIBUTE_HIDDEN;
 255
 256 /* Lock critical section for __gcov_dump and __gcov_reset functions.  */
 257 extern void __gcov_lock (void) ATTRIBUTE_HIDDEN;
 258
 259 /* Unlock critical section for __gcov_dump and __gcov_reset functions.  */
 260 extern void __gcov_unlock (void) ATTRIBUTE_HIDDEN;
 261
 262 /* The merge function that just sums the counters.  */
 263 extern void __gcov_merge_add (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
 264
 265 /* The merge function to select the minimum valid counter value.  */
 266 extern void __gcov_merge_time_profile (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
 267
 268 /* The merge function to choose the most common N values.  */
 269 extern void __gcov_merge_topn (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
 270
 271 /* The merge function that just ors the counters together.  */
 272 extern void __gcov_merge_ior (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
 273
 274 /* The profiler functions.  */
 275 extern void __gcov_interval_profiler (gcov_type *, gcov_type, int, unsigned);
 276 extern void __gcov_interval_profiler_atomic (gcov_type *, gcov_type, int,
 277                                              unsigned);
 278 extern void __gcov_pow2_profiler (gcov_type *, gcov_type);
 279 extern void __gcov_pow2_profiler_atomic (gcov_type *, gcov_type);
 280 extern void __gcov_topn_values_profiler (gcov_type *, gcov_type);
 281 extern void __gcov_topn_values_profiler_atomic (gcov_type *, gcov_type);
 282 extern void __gcov_indirect_call_profiler_v4 (gcov_type, void *);
 283 extern void __gcov_indirect_call_profiler_v4_atomic (gcov_type, void *);
 284 extern void __gcov_time_profiler (gcov_type *);
 285 extern void __gcov_time_profiler_atomic (gcov_type *);
 286 extern void __gcov_average_profiler (gcov_type *, gcov_type);
 287 extern void __gcov_average_profiler_atomic (gcov_type *, gcov_type);
 288 extern void __gcov_ior_profiler (gcov_type *, gcov_type);
 289 extern void __gcov_ior_profiler_atomic (gcov_type *, gcov_type);
 290
 291 #ifndef inhibit_libc
 292 /* The wrappers around some library functions..  */
 293 extern pid_t __gcov_fork (void) ATTRIBUTE_HIDDEN;
 294 extern int __gcov_execl (const char *, char *, ...) ATTRIBUTE_HIDDEN;
 295 extern int __gcov_execlp (const char *, char *, ...) ATTRIBUTE_HIDDEN;
 296 extern int __gcov_execle (const char *, char *, ...) ATTRIBUTE_HIDDEN;
 297 extern int __gcov_execv (const char *, char *const []) ATTRIBUTE_HIDDEN;
 298 extern int __gcov_execvp (const char *, char *const []) ATTRIBUTE_HIDDEN;
 299 extern int __gcov_execve (const char *, char  *const [], char *const [])
 300   ATTRIBUTE_HIDDEN;
 301
 302 /* Functions that only available in libgcov.  */
 303 GCOV_LINKAGE int gcov_open (const char */*name*/) ATTRIBUTE_HIDDEN;
 304 GCOV_LINKAGE void gcov_write_counter (gcov_type) ATTRIBUTE_HIDDEN;
 305 GCOV_LINKAGE void gcov_write_tag_length (gcov_unsigned_t, gcov_unsigned_t)
 306     ATTRIBUTE_HIDDEN;
 307 GCOV_LINKAGE void gcov_write_summary (gcov_unsigned_t /*tag*/,
 308                                       const struct gcov_summary *)
 309     ATTRIBUTE_HIDDEN;
 310 GCOV_LINKAGE void gcov_seek (gcov_position_t /*position*/) ATTRIBUTE_HIDDEN;
 311 GCOV_LINKAGE void gcov_rewrite (void) ATTRIBUTE_HIDDEN;
 312
 313 /* "Counts" stored in gcda files can be a real counter value, or
 314    an target address. When differentiate these two types because
 315    when manipulating counts, we should only change real counter values,
 316    rather target addresses.  */
 317
 318 static inline gcov_type
 319 gcov_get_counter (void)
 320 {
 321 #ifndef IN_GCOV_TOOL
 322   /* This version is for reading count values in libgcov runtime:
 323      we read from gcda files.  */
 324
 325   return gcov_read_counter ();
 326 #else
 327   /* This version is for gcov-tool. We read the value from memory and
 328      multiply it by the merge weight.  */
 329
 330   return gcov_read_counter_mem () * gcov_get_merge_weight ();
 331 #endif
 332 }
 333
 334 /* Similar function as gcov_get_counter(), but do not scale
 335    when read value is equal to IGNORE_SCALING.  */
 336
 337 static inline gcov_type
 338 gcov_get_counter_ignore_scaling (gcov_type ignore_scaling ATTRIBUTE_UNUSED)
 339 {
 340 #ifndef IN_GCOV_TOOL
 341   /* This version is for reading count values in libgcov runtime:
 342      we read from gcda files.  */
 343
 344   return gcov_read_counter ();
 345 #else
 346   /* This version is for gcov-tool. We read the value from memory and
 347      multiply it by the merge weight.  */
 348
 349   gcov_type v = gcov_read_counter_mem ();
 350   if (v != ignore_scaling)
 351     v *= gcov_get_merge_weight ();
 352
 353   return v;
 354 #endif
 355 }
 356
 357 /* Similar function as gcov_get_counter(), but handles target address
 358    counters.  */
 359
 360 static inline gcov_type
 361 gcov_get_counter_target (void)
 362 {
 363 #ifndef IN_GCOV_TOOL
 364   /* This version is for reading count target values in libgcov runtime:
 365      we read from gcda files.  */
 366
 367   return gcov_read_counter ();
 368 #else
 369   /* This version is for gcov-tool.  We read the value from memory and we do NOT
 370      multiply it by the merge weight.  */
 371
 372   return gcov_read_counter_mem ();
 373 #endif
 374 }
 375
 376 /* Add VALUE to *COUNTER and make it with atomic operation
 377    if USE_ATOMIC is true.  */
 378
 379 static inline void
 380 gcov_counter_add (gcov_type *counter, gcov_type value, int use_atomic)
 381 {
 382   if (use_atomic)
 383     __atomic_fetch_add (counter, value, __ATOMIC_RELAXED);
 384   else
 385     *counter += value;
 386 }
 387
 388 /* Set NODE to memory location COUNTER and make it with atomic operation
 389    if USE_ATOMIC is true.  */
 390
 391 static inline int
 392 gcov_counter_set_if_null (gcov_type *counter, struct gcov_kvp *node,
 393                           int use_atomic)
 394 {
 395   if (use_atomic)
 396     return !__sync_val_compare_and_swap (counter, NULL, (intptr_t)node);
 397   else
 398     {
 399       *counter = (intptr_t)node;
 400       return 1;
 401     }
 402 }
 403
 404 /* Add key value pair VALUE:COUNT to a top N COUNTERS.  When INCREMENT_TOTAL
 405    is true, add COUNT to total of the TOP counter.  If USE_ATOMIC is true,
 406    do it in atomic way.  */
 407
 408 static inline void
 409 gcov_topn_add_value (gcov_type *counters, gcov_type value, gcov_type count,
 410                      int use_atomic, int increment_total)
 411 {
 412   if (increment_total)
 413     gcov_counter_add (&counters[0], 1, use_atomic);
 414
 415   struct gcov_kvp *prev_node = NULL;
 416   struct gcov_kvp *minimal_node = NULL;
 417   struct gcov_kvp *current_node  = (struct gcov_kvp *)counters[2];
 418
 419   while (current_node)
 420     {
 421       if (current_node->value == value)
 422         {
 423           gcov_counter_add (&current_node->count, count, use_atomic);
 424           return;
 425         }
 426
 427       if (minimal_node == NULL
 428           || current_node->count < minimal_node->count)
 429         minimal_node = current_node;
 430
 431       prev_node = current_node;
 432       current_node = current_node->next;
 433     }
 434
 435   if (counters[1] == GCOV_TOPN_MAXIMUM_TRACKED_VALUES)
 436     {
 437       if (--minimal_node->count < count)
 438         {
 439           minimal_node->value = value;
 440           minimal_node->count = count;
 441         }
 442     }
 443   else
 444     {
 445       struct gcov_kvp *new_node
 446         = (struct gcov_kvp *)xcalloc (1, sizeof (struct gcov_kvp));
 447       new_node->value = value;
 448       new_node->count = count;
 449
 450       int success = 0;
 451       if (!counters[2])
 452         success = gcov_counter_set_if_null (&counters[2], new_node, use_atomic);
 453       else if (prev_node && !prev_node->next)
 454         success = gcov_counter_set_if_null ((gcov_type *)&prev_node->next,
 455                                             new_node, use_atomic);
 456
 457       /* Increment number of nodes.  */
 458       if (success)
 459         gcov_counter_add (&counters[1], 1, use_atomic);
 460     }
 461 }
 462
 463 #endif /* !inhibit_libc */
 464
 465 #endif /* GCC_LIBGCOV_H */