libgcc/libgcov.h

   1 /* Header file for libgcov-*.c.
   2    Copyright (C) 1996-2017 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 "tsystem.h"
  42 #include "coretypes.h"
  43 #include "tm.h"
  44 #include "libgcc_tm.h"
  45 #include "gcov.h"
  46
  47 #if __CHAR_BIT__ == 8
  48 typedef unsigned gcov_unsigned_t __attribute__ ((mode (SI)));
  49 typedef unsigned gcov_position_t __attribute__ ((mode (SI)));
  50 #if LONG_LONG_TYPE_SIZE > 32
  51 typedef signed gcov_type __attribute__ ((mode (DI)));
  52 typedef unsigned gcov_type_unsigned __attribute__ ((mode (DI)));
  53 #else
  54 typedef signed gcov_type __attribute__ ((mode (SI)));
  55 typedef unsigned gcov_type_unsigned __attribute__ ((mode (SI)));
  56 #endif
  57 #else
  58 #if __CHAR_BIT__ == 16
  59 typedef unsigned gcov_unsigned_t __attribute__ ((mode (HI)));
  60 typedef unsigned gcov_position_t __attribute__ ((mode (HI)));
  61 #if LONG_LONG_TYPE_SIZE > 32
  62 typedef signed gcov_type __attribute__ ((mode (SI)));
  63 typedef unsigned gcov_type_unsigned __attribute__ ((mode (SI)));
  64 #else
  65 typedef signed gcov_type __attribute__ ((mode (HI)));
  66 typedef unsigned gcov_type_unsigned __attribute__ ((mode (HI)));
  67 #endif
  68 #else
  69 typedef unsigned gcov_unsigned_t __attribute__ ((mode (QI)));
  70 typedef unsigned gcov_position_t __attribute__ ((mode (QI)));
  71 #if LONG_LONG_TYPE_SIZE > 32
  72 typedef signed gcov_type __attribute__ ((mode (HI)));
  73 typedef unsigned gcov_type_unsigned __attribute__ ((mode (HI)));
  74 #else
  75 typedef signed gcov_type __attribute__ ((mode (QI)));
  76 typedef unsigned gcov_type_unsigned __attribute__ ((mode (QI)));
  77 #endif
  78 #endif
  79 #endif
  80
  81 #if defined (TARGET_POSIX_IO)
  82 #define GCOV_LOCKED 1
  83 #else
  84 #define GCOV_LOCKED 0
  85 #endif
  86
  87 /* In libgcov we need these functions to be extern, so prefix them with
  88    __gcov.  In libgcov they must also be hidden so that the instance in
  89    the executable is not also used in a DSO.  */
  90 #define gcov_var __gcov_var
  91 #define gcov_open __gcov_open
  92 #define gcov_close __gcov_close
  93 #define gcov_write_tag_length __gcov_write_tag_length
  94 #define gcov_position __gcov_position
  95 #define gcov_seek __gcov_seek
  96 #define gcov_rewrite __gcov_rewrite
  97 #define gcov_is_error __gcov_is_error
  98 #define gcov_write_unsigned __gcov_write_unsigned
  99 #define gcov_write_counter __gcov_write_counter
 100 #define gcov_write_summary __gcov_write_summary
 101 #define gcov_read_unsigned __gcov_read_unsigned
 102 #define gcov_read_counter __gcov_read_counter
 103 #define gcov_read_summary __gcov_read_summary
 104 #define gcov_sort_n_vals __gcov_sort_n_vals
 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_single 1
 130 #define L_gcov_merge_ior 1
 131 #define L_gcov_merge_time_profile 1
 132 #define L_gcov_merge_icall_topn 1
 133
 134 extern gcov_type gcov_read_counter_mem ();
 135 extern unsigned gcov_get_merge_weight ();
 136 extern struct gcov_info *gcov_list;
 137
 138 #endif /* !IN_GCOV_TOOL */
 139
 140 #if defined(inhibit_libc)
 141 #define IN_LIBGCOV (-1)
 142 #else
 143 #define IN_LIBGCOV 1
 144 #if defined(L_gcov)
 145 #define GCOV_LINKAGE /* nothing */
 146 #endif
 147 #endif
 148
 149 /* Poison these, so they don't accidentally slip in.  */
 150 #pragma GCC poison gcov_write_string gcov_write_tag gcov_write_length
 151 #pragma GCC poison gcov_time gcov_magic
 152
 153 #ifdef HAVE_GAS_HIDDEN
 154 #define ATTRIBUTE_HIDDEN  __attribute__ ((__visibility__ ("hidden")))
 155 #else
 156 #define ATTRIBUTE_HIDDEN
 157 #endif
 158
 159 #include "gcov-io.h"
 160
 161 /* Structures embedded in coveraged program.  The structures generated
 162    by write_profile must match these.  */
 163
 164 /* Information about counters for a single function.  */
 165 struct gcov_ctr_info
 166 {
 167   gcov_unsigned_t num;          /* number of counters.  */
 168   gcov_type *values;            /* their values.  */
 169 };
 170
 171 /* Information about a single function.  This uses the trailing array
 172    idiom. The number of counters is determined from the merge pointer
 173    array in gcov_info.  The key is used to detect which of a set of
 174    comdat functions was selected -- it points to the gcov_info object
 175    of the object file containing the selected comdat function.  */
 176
 177 struct gcov_fn_info
 178 {
 179   const struct gcov_info *key;          /* comdat key */
 180   gcov_unsigned_t ident;                /* unique ident of function */
 181   gcov_unsigned_t lineno_checksum;      /* function lineo_checksum */
 182   gcov_unsigned_t cfg_checksum;         /* function cfg checksum */
 183   struct gcov_ctr_info ctrs[1];         /* instrumented counters */
 184 };
 185
 186 /* Type of function used to merge counters.  */
 187 typedef void (*gcov_merge_fn) (gcov_type *, gcov_unsigned_t);
 188
 189 /* Information about a single object file.  */
 190 struct gcov_info
 191 {
 192   gcov_unsigned_t version;      /* expected version number */
 193   struct gcov_info *next;       /* link to next, used by libgcov */
 194
 195   gcov_unsigned_t stamp;        /* uniquifying time stamp */
 196   const char *filename;         /* output file name */
 197
 198   gcov_merge_fn merge[GCOV_COUNTERS];  /* merge functions (null for
 199                                           unused) */
 200
 201   unsigned n_functions;         /* number of functions */
 202
 203 #ifndef IN_GCOV_TOOL
 204   const struct gcov_fn_info *const *functions; /* pointer to pointers
 205                                                   to function information  */
 206 #else
 207   const struct gcov_fn_info **functions;
 208 #endif /* !IN_GCOV_TOOL */
 209 };
 210
 211 /* Root of a program/shared-object state */
 212 struct gcov_root
 213 {
 214   struct gcov_info *list;
 215   unsigned dumped : 1;  /* counts have been dumped.  */
 216   unsigned run_counted : 1;  /* run has been accounted for.  */
 217   struct gcov_root *next;
 218   struct gcov_root *prev;
 219 };
 220
 221 extern struct gcov_root __gcov_root ATTRIBUTE_HIDDEN;
 222
 223 struct gcov_master
 224 {
 225   gcov_unsigned_t version;
 226   struct gcov_root *root;
 227 };
 228
 229 /* Exactly one of these will be active in the process.  */
 230 extern struct gcov_master __gcov_master;
 231
 232 /* Dump a set of gcov objects.  */
 233 extern void __gcov_dump_one (struct gcov_root *) ATTRIBUTE_HIDDEN;
 234
 235 /* Register a new object file module.  */
 236 extern void __gcov_init (struct gcov_info *) ATTRIBUTE_HIDDEN;
 237
 238 /* GCOV exit function registered via a static destructor.  */
 239 extern void __gcov_exit (void) ATTRIBUTE_HIDDEN;
 240
 241 /* Function to reset all counters to 0.  Both externally visible (and
 242    overridable) and internal version.  */
 243 extern void __gcov_reset_int (void) ATTRIBUTE_HIDDEN;
 244
 245 /* User function to enable early write of profile information so far.  */
 246 extern void __gcov_dump_int (void) ATTRIBUTE_HIDDEN;
 247
 248 /* The merge function that just sums the counters.  */
 249 extern void __gcov_merge_add (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
 250
 251 /* The merge function to select the minimum valid counter value.  */
 252 extern void __gcov_merge_time_profile (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
 253
 254 /* The merge function to choose the most common value.  */
 255 extern void __gcov_merge_single (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
 256
 257 /* The merge function that just ors the counters together.  */
 258 extern void __gcov_merge_ior (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
 259
 260 /* The merge function is used for topn indirect call counters.  */
 261 extern void __gcov_merge_icall_topn (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
 262
 263 /* The profiler functions.  */
 264 extern void __gcov_interval_profiler (gcov_type *, gcov_type, int, unsigned);
 265 extern void __gcov_interval_profiler_atomic (gcov_type *, gcov_type, int,
 266                                              unsigned);
 267 extern void __gcov_pow2_profiler (gcov_type *, gcov_type);
 268 extern void __gcov_pow2_profiler_atomic (gcov_type *, gcov_type);
 269 extern void __gcov_one_value_profiler (gcov_type *, gcov_type);
 270 extern void __gcov_one_value_profiler_atomic (gcov_type *, gcov_type);
 271 extern void __gcov_indirect_call_profiler_v2 (gcov_type, void *);
 272 extern void __gcov_time_profiler (gcov_type *);
 273 extern void __gcov_time_profiler_atomic (gcov_type *);
 274 extern void __gcov_average_profiler (gcov_type *, gcov_type);
 275 extern void __gcov_average_profiler_atomic (gcov_type *, gcov_type);
 276 extern void __gcov_ior_profiler (gcov_type *, gcov_type);
 277 extern void __gcov_ior_profiler_atomic (gcov_type *, gcov_type);
 278 extern void __gcov_indirect_call_topn_profiler (gcov_type, void *);
 279 extern void gcov_sort_n_vals (gcov_type *, int);
 280
 281 #ifndef inhibit_libc
 282 /* The wrappers around some library functions..  */
 283 extern pid_t __gcov_fork (void) ATTRIBUTE_HIDDEN;
 284 extern int __gcov_execl (const char *, char *, ...) ATTRIBUTE_HIDDEN;
 285 extern int __gcov_execlp (const char *, char *, ...) ATTRIBUTE_HIDDEN;
 286 extern int __gcov_execle (const char *, char *, ...) ATTRIBUTE_HIDDEN;
 287 extern int __gcov_execv (const char *, char *const []) ATTRIBUTE_HIDDEN;
 288 extern int __gcov_execvp (const char *, char *const []) ATTRIBUTE_HIDDEN;
 289 extern int __gcov_execve (const char *, char  *const [], char *const [])
 290   ATTRIBUTE_HIDDEN;
 291
 292 /* Functions that only available in libgcov.  */
 293 GCOV_LINKAGE int gcov_open (const char */*name*/) ATTRIBUTE_HIDDEN;
 294 GCOV_LINKAGE void gcov_write_counter (gcov_type) ATTRIBUTE_HIDDEN;
 295 GCOV_LINKAGE void gcov_write_tag_length (gcov_unsigned_t, gcov_unsigned_t)
 296     ATTRIBUTE_HIDDEN;
 297 GCOV_LINKAGE void gcov_write_summary (gcov_unsigned_t /*tag*/,
 298                                       const struct gcov_summary *)
 299     ATTRIBUTE_HIDDEN;
 300 GCOV_LINKAGE void gcov_seek (gcov_position_t /*position*/) ATTRIBUTE_HIDDEN;
 301 GCOV_LINKAGE void gcov_rewrite (void) ATTRIBUTE_HIDDEN;
 302
 303 /* "Counts" stored in gcda files can be a real counter value, or
 304    an target address. When differentiate these two types because
 305    when manipulating counts, we should only change real counter values,
 306    rather target addresses.  */
 307
 308 static inline gcov_type
 309 gcov_get_counter (void)
 310 {
 311 #ifndef IN_GCOV_TOOL
 312   /* This version is for reading count values in libgcov runtime:
 313      we read from gcda files.  */
 314
 315   return gcov_read_counter ();
 316 #else
 317   /* This version is for gcov-tool. We read the value from memory and
 318      multiply it by the merge weight.  */
 319
 320   return gcov_read_counter_mem () * gcov_get_merge_weight ();
 321 #endif
 322 }
 323
 324 /* Similar function as gcov_get_counter(), but handles target address
 325    counters.  */
 326
 327 static inline gcov_type
 328 gcov_get_counter_target (void)
 329 {
 330 #ifndef IN_GCOV_TOOL
 331   /* This version is for reading count target values in libgcov runtime:
 332      we read from gcda files.  */
 333
 334   return gcov_read_counter ();
 335 #else
 336   /* This version is for gcov-tool.  We read the value from memory and we do NOT
 337      multiply it by the merge weight.  */
 338
 339   return gcov_read_counter_mem ();
 340 #endif
 341 }
 342
 343 #endif /* !inhibit_libc */
 344
 345 #endif /* GCC_LIBGCOV_H */