libgcc/libgcov.h

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