Viewing file: libgcov.h (16.95 KB) -rw-r--r-- Select action/file-type: (+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
/* Header file for libgcov-*.c. Copyright (C) 1996-2022 Free Software Foundation, Inc.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
Under Section 7 of GPL version 3, you are granted additional permissions described in the GCC Runtime Library Exception, version 3.1, as published by the Free Software Foundation.
You should have received a copy of the GNU General Public License and a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see <http://www.gnu.org/licenses/>. */
#ifndef GCC_LIBGCOV_H #define GCC_LIBGCOV_H
/* work around the poisoned malloc/calloc in system.h. */ #ifndef xmalloc #define xmalloc malloc #endif #ifndef xcalloc #define xcalloc calloc #endif
#ifndef IN_GCOV_TOOL /* About the target. */ /* This path will be used by libgcov runtime. */
#include "tconfig.h" #include "auto-target.h" #include "tsystem.h" #include "coretypes.h" #include "tm.h" #include "libgcc_tm.h" #include "gcov.h"
#if HAVE_SYS_MMAN_H #include <sys/mman.h> #endif
#if __CHAR_BIT__ == 8 typedef unsigned gcov_unsigned_t __attribute__ ((mode (SI))); typedef unsigned gcov_position_t __attribute__ ((mode (SI))); #if __LIBGCC_GCOV_TYPE_SIZE > 32 typedef signed gcov_type __attribute__ ((mode (DI))); typedef unsigned gcov_type_unsigned __attribute__ ((mode (DI))); #else typedef signed gcov_type __attribute__ ((mode (SI))); typedef unsigned gcov_type_unsigned __attribute__ ((mode (SI))); #endif #else #if __CHAR_BIT__ == 16 typedef unsigned gcov_unsigned_t __attribute__ ((mode (HI))); typedef unsigned gcov_position_t __attribute__ ((mode (HI))); #if __LIBGCC_GCOV_TYPE_SIZE > 32 typedef signed gcov_type __attribute__ ((mode (SI))); typedef unsigned gcov_type_unsigned __attribute__ ((mode (SI))); #else typedef signed gcov_type __attribute__ ((mode (HI))); typedef unsigned gcov_type_unsigned __attribute__ ((mode (HI))); #endif #else typedef unsigned gcov_unsigned_t __attribute__ ((mode (QI))); typedef unsigned gcov_position_t __attribute__ ((mode (QI))); #if __LIBGCC_GCOV_TYPE_SIZE > 32 typedef signed gcov_type __attribute__ ((mode (HI))); typedef unsigned gcov_type_unsigned __attribute__ ((mode (HI))); #else typedef signed gcov_type __attribute__ ((mode (QI))); typedef unsigned gcov_type_unsigned __attribute__ ((mode (QI))); #endif #endif #endif
#if defined (TARGET_POSIX_IO) #define GCOV_LOCKED 1 #else #define GCOV_LOCKED 0 #endif
#if defined (__MSVCRT__) #define GCOV_LOCKED_WITH_LOCKING 1 #else #define GCOV_LOCKED_WITH_LOCKING 0 #endif
#ifndef GCOV_SUPPORTS_ATOMIC /* Detect whether target can support atomic update of profilers. */ #if __SIZEOF_LONG_LONG__ == 4 && __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 #define GCOV_SUPPORTS_ATOMIC 1 #else #if __SIZEOF_LONG_LONG__ == 8 && __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 #define GCOV_SUPPORTS_ATOMIC 1 #else #define GCOV_SUPPORTS_ATOMIC 0 #endif #endif #endif
/* In libgcov we need these functions to be extern, so prefix them with __gcov. In libgcov they must also be hidden so that the instance in the executable is not also used in a DSO. */ #define gcov_var __gcov_var #define gcov_open __gcov_open #define gcov_close __gcov_close #define gcov_position __gcov_position #define gcov_seek __gcov_seek #define gcov_rewrite __gcov_rewrite #define gcov_is_error __gcov_is_error #define gcov_write_unsigned __gcov_write_unsigned #define gcov_write_summary __gcov_write_summary #define gcov_read_unsigned __gcov_read_unsigned #define gcov_read_counter __gcov_read_counter #define gcov_read_summary __gcov_read_summary
#else /* IN_GCOV_TOOL */ /* About the host. */ /* This path will be compiled for the host and linked into gcov-tool binary. */
#include "config.h" #include "system.h" #include "coretypes.h" #include "tm.h"
typedef unsigned gcov_unsigned_t; typedef unsigned gcov_position_t; /* gcov_type is typedef'd elsewhere for the compiler */
#if defined (HOST_HAS_F_SETLKW) #define GCOV_LOCKED 1 #else #define GCOV_LOCKED 0 #endif
#if defined (HOST_HAS_LK_LOCK) #define GCOV_LOCKED_WITH_LOCKING 1 #else #define GCOV_LOCKED_WITH_LOCKING 0 #endif
/* Some Macros specific to gcov-tool. */
#define L_gcov 1 #define L_gcov_merge_add 1 #define L_gcov_merge_topn 1 #define L_gcov_merge_ior 1 #define L_gcov_merge_time_profile 1
extern gcov_type gcov_read_counter_mem (); extern unsigned gcov_get_merge_weight (); extern struct gcov_info *gcov_list;
#endif /* !IN_GCOV_TOOL */
#if defined(inhibit_libc) #define IN_LIBGCOV (-1) #else #define IN_LIBGCOV 1 #if defined(L_gcov) #define GCOV_LINKAGE /* nothing */ #endif #endif
/* Poison these, so they don't accidentally slip in. */ #pragma GCC poison gcov_write_string gcov_write_tag gcov_write_length #pragma GCC poison gcov_time
#ifdef HAVE_GAS_HIDDEN #define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden"))) #else #define ATTRIBUTE_HIDDEN #endif
#if HAVE_SYS_MMAN_H #ifndef MAP_FAILED #define MAP_FAILED ((void *)-1) #endif
#if !defined (MAP_ANONYMOUS) && defined (MAP_ANON) #define MAP_ANONYMOUS MAP_ANON #endif #endif
#include "gcov-io.h"
/* Structures embedded in coveraged program. The structures generated by write_profile must match these. */
/* Information about counters for a single function. */ struct gcov_ctr_info { gcov_unsigned_t num; /* number of counters. */ gcov_type *values; /* their values. */ };
/* Information about a single function. This uses the trailing array idiom. The number of counters is determined from the merge pointer array in gcov_info. The key is used to detect which of a set of comdat functions was selected -- it points to the gcov_info object of the object file containing the selected comdat function. */
struct gcov_fn_info { const struct gcov_info *key; /* comdat key */ gcov_unsigned_t ident; /* unique ident of function */ gcov_unsigned_t lineno_checksum; /* function lineo_checksum */ gcov_unsigned_t cfg_checksum; /* function cfg checksum */ struct gcov_ctr_info ctrs[1]; /* instrumented counters */ };
/* Type of function used to merge counters. */ typedef void (*gcov_merge_fn) (gcov_type *, gcov_unsigned_t);
/* Information about a single object file. */ struct gcov_info { gcov_unsigned_t version; /* expected version number */ struct gcov_info *next; /* link to next, used by libgcov */
gcov_unsigned_t stamp; /* uniquifying time stamp */ gcov_unsigned_t checksum; /* unique object checksum */ const char *filename; /* output file name */
gcov_merge_fn merge[GCOV_COUNTERS]; /* merge functions (null for unused) */ gcov_unsigned_t n_functions; /* number of functions */
#ifndef IN_GCOV_TOOL const struct gcov_fn_info *const *functions; /* pointer to pointers to function information */ #else struct gcov_fn_info **functions; struct gcov_summary summary; #endif /* !IN_GCOV_TOOL */ };
/* Root of a program/shared-object state */ struct gcov_root { struct gcov_info *list; unsigned dumped : 1; /* counts have been dumped. */ unsigned run_counted : 1; /* run has been accounted for. */ struct gcov_root *next; struct gcov_root *prev; };
extern struct gcov_root __gcov_root ATTRIBUTE_HIDDEN;
struct gcov_master { gcov_unsigned_t version; struct gcov_root *root; };
struct indirect_call_tuple { /* Callee function. */ void *callee;
/* Pointer to counters. */ gcov_type *counters; }; /* Exactly one of these will be active in the process. */ extern struct gcov_master __gcov_master; extern struct gcov_kvp *__gcov_kvp_dynamic_pool; extern unsigned __gcov_kvp_dynamic_pool_index; extern unsigned __gcov_kvp_dynamic_pool_size;
/* Dump a set of gcov objects. */ extern void __gcov_dump_one (struct gcov_root *) ATTRIBUTE_HIDDEN;
/* Register a new object file module. */ extern void __gcov_init (struct gcov_info *) ATTRIBUTE_HIDDEN;
/* GCOV exit function registered via a static destructor. */ extern void __gcov_exit (void) ATTRIBUTE_HIDDEN;
/* Function to reset all counters to 0. Both externally visible (and overridable) and internal version. */ extern void __gcov_reset_int (void) ATTRIBUTE_HIDDEN;
/* User function to enable early write of profile information so far. */ extern void __gcov_dump_int (void) ATTRIBUTE_HIDDEN;
/* Lock critical section for __gcov_dump and __gcov_reset functions. */ extern void __gcov_lock (void) ATTRIBUTE_HIDDEN;
/* Unlock critical section for __gcov_dump and __gcov_reset functions. */ extern void __gcov_unlock (void) ATTRIBUTE_HIDDEN;
/* The merge function that just sums the counters. */ extern void __gcov_merge_add (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
/* The merge function to select the minimum valid counter value. */ extern void __gcov_merge_time_profile (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
/* The merge function to choose the most common N values. */ extern void __gcov_merge_topn (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
/* The merge function that just ors the counters together. */ extern void __gcov_merge_ior (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
/* The profiler functions. */ extern void __gcov_interval_profiler (gcov_type *, gcov_type, int, unsigned); extern void __gcov_interval_profiler_atomic (gcov_type *, gcov_type, int, unsigned); extern void __gcov_pow2_profiler (gcov_type *, gcov_type); extern void __gcov_pow2_profiler_atomic (gcov_type *, gcov_type); extern void __gcov_topn_values_profiler (gcov_type *, gcov_type); extern void __gcov_topn_values_profiler_atomic (gcov_type *, gcov_type); extern void __gcov_indirect_call_profiler_v4 (gcov_type, void *); extern void __gcov_indirect_call_profiler_v4_atomic (gcov_type, void *); extern void __gcov_time_profiler (gcov_type *); extern void __gcov_time_profiler_atomic (gcov_type *); extern void __gcov_average_profiler (gcov_type *, gcov_type); extern void __gcov_average_profiler_atomic (gcov_type *, gcov_type); extern void __gcov_ior_profiler (gcov_type *, gcov_type); extern void __gcov_ior_profiler_atomic (gcov_type *, gcov_type);
#ifndef inhibit_libc /* The wrappers around some library functions.. */ extern pid_t __gcov_fork (void) ATTRIBUTE_HIDDEN; extern int __gcov_execl (const char *, char *, ...) ATTRIBUTE_HIDDEN; extern int __gcov_execlp (const char *, char *, ...) ATTRIBUTE_HIDDEN; extern int __gcov_execle (const char *, char *, ...) ATTRIBUTE_HIDDEN; extern int __gcov_execv (const char *, char *const []) ATTRIBUTE_HIDDEN; extern int __gcov_execvp (const char *, char *const []) ATTRIBUTE_HIDDEN; extern int __gcov_execve (const char *, char *const [], char *const []) ATTRIBUTE_HIDDEN;
/* Functions that only available in libgcov. */ GCOV_LINKAGE int gcov_open (const char */*name*/) ATTRIBUTE_HIDDEN; GCOV_LINKAGE void gcov_write_summary (gcov_unsigned_t /*tag*/, const struct gcov_summary *) ATTRIBUTE_HIDDEN; GCOV_LINKAGE void gcov_seek (gcov_position_t /*position*/) ATTRIBUTE_HIDDEN; GCOV_LINKAGE void gcov_rewrite (void) ATTRIBUTE_HIDDEN;
/* "Counts" stored in gcda files can be a real counter value, or an target address. When differentiate these two types because when manipulating counts, we should only change real counter values, rather target addresses. */
static inline gcov_type gcov_get_counter (void) { #ifndef IN_GCOV_TOOL /* This version is for reading count values in libgcov runtime: we read from gcda files. */
return gcov_read_counter (); #else /* This version is for gcov-tool. We read the value from memory and multiply it by the merge weight. */
return gcov_read_counter_mem () * gcov_get_merge_weight (); #endif }
/* Similar function as gcov_get_counter(), but do not scale when read value is equal to IGNORE_SCALING. */
static inline gcov_type gcov_get_counter_ignore_scaling (gcov_type ignore_scaling ATTRIBUTE_UNUSED) { #ifndef IN_GCOV_TOOL /* This version is for reading count values in libgcov runtime: we read from gcda files. */
return gcov_read_counter (); #else /* This version is for gcov-tool. We read the value from memory and multiply it by the merge weight. */
gcov_type v = gcov_read_counter_mem (); if (v != ignore_scaling) v *= gcov_get_merge_weight ();
return v; #endif }
/* Similar function as gcov_get_counter(), but handles target address counters. */
static inline gcov_type gcov_get_counter_target (void) { #ifndef IN_GCOV_TOOL /* This version is for reading count target values in libgcov runtime: we read from gcda files. */
return gcov_read_counter (); #else /* This version is for gcov-tool. We read the value from memory and we do NOT multiply it by the merge weight. */
return gcov_read_counter_mem (); #endif }
/* Add VALUE to *COUNTER and make it with atomic operation if USE_ATOMIC is true. */
static inline void gcov_counter_add (gcov_type *counter, gcov_type value, int use_atomic ATTRIBUTE_UNUSED) { #if GCOV_SUPPORTS_ATOMIC if (use_atomic) __atomic_fetch_add (counter, value, __ATOMIC_RELAXED); else #endif *counter += value; }
#if HAVE_SYS_MMAN_H
/* Allocate LENGTH with mmap function. */
static inline void * malloc_mmap (size_t length) { return mmap (NULL, length, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); }
#endif
/* Allocate gcov_kvp from statically pre-allocated pool, or use heap otherwise. */
static inline struct gcov_kvp * allocate_gcov_kvp (void) { #define MMAP_CHUNK_SIZE (128 * 1024) struct gcov_kvp *new_node = NULL; unsigned kvp_sizeof = sizeof(struct gcov_kvp);
/* Try mmaped pool if available. */ #if !defined(IN_GCOV_TOOL) && !defined(L_gcov_merge_topn) && HAVE_SYS_MMAN_H if (__gcov_kvp_dynamic_pool == NULL || __gcov_kvp_dynamic_pool_index >= __gcov_kvp_dynamic_pool_size) { void *ptr = malloc_mmap (MMAP_CHUNK_SIZE); if (ptr != MAP_FAILED) { __gcov_kvp_dynamic_pool = ptr; __gcov_kvp_dynamic_pool_size = MMAP_CHUNK_SIZE / kvp_sizeof; __gcov_kvp_dynamic_pool_index = 0; } }
if (__gcov_kvp_dynamic_pool != NULL) { unsigned index; #if GCOV_SUPPORTS_ATOMIC index = __atomic_fetch_add (&__gcov_kvp_dynamic_pool_index, 1, __ATOMIC_RELAXED); #else index = __gcov_kvp_dynamic_pool_index++; #endif if (index < __gcov_kvp_dynamic_pool_size) new_node = __gcov_kvp_dynamic_pool + index; } #endif
/* Fallback to malloc. */ if (new_node == NULL) new_node = (struct gcov_kvp *)xcalloc (1, kvp_sizeof);
return new_node; }
/* Add key value pair VALUE:COUNT to a top N COUNTERS. When INCREMENT_TOTAL is true, add COUNT to total of the TOP counter. If USE_ATOMIC is true, do it in atomic way. Return true when the counter is full, otherwise return false. */
static inline unsigned gcov_topn_add_value (gcov_type *counters, gcov_type value, gcov_type count, int use_atomic, int increment_total) { if (increment_total) { /* In the multi-threaded mode, we can have an already merged profile with a negative total value. In that case, we should bail out. */ if (counters[0] < 0) return 0; gcov_counter_add (&counters[0], 1, use_atomic); }
struct gcov_kvp *prev_node = NULL; struct gcov_kvp *minimal_node = NULL; struct gcov_kvp *current_node = (struct gcov_kvp *)(intptr_t)counters[2];
while (current_node) { if (current_node->value == value) { gcov_counter_add (¤t_node->count, count, use_atomic); return 0; }
if (minimal_node == NULL || current_node->count < minimal_node->count) minimal_node = current_node;
prev_node = current_node; current_node = current_node->next; }
if (counters[1] == GCOV_TOPN_MAXIMUM_TRACKED_VALUES) { if (--minimal_node->count < count) { minimal_node->value = value; minimal_node->count = count; }
return 1; } else { struct gcov_kvp *new_node = allocate_gcov_kvp (); if (new_node == NULL) return 0;
new_node->value = value; new_node->count = count;
int success = 0; if (!counters[2]) { #if GCOV_SUPPORTS_ATOMIC if (use_atomic) { struct gcov_kvp **ptr = (struct gcov_kvp **)(intptr_t)&counters[2]; success = !__sync_val_compare_and_swap (ptr, 0, new_node); } else #endif { counters[2] = (intptr_t)new_node; success = 1; } } else if (prev_node && !prev_node->next) { #if GCOV_SUPPORTS_ATOMIC if (use_atomic) success = !__sync_val_compare_and_swap (&prev_node->next, 0, new_node); else #endif { prev_node->next = new_node; success = 1; } }
/* Increment number of nodes. */ if (success) gcov_counter_add (&counters[1], 1, use_atomic); }
return 0; }
#endif /* !inhibit_libc */
#endif /* GCC_LIBGCOV_H */
|