[thirdparty/gcc.git] / libgcc / libgcov.h

/* Header file for libgcov-*.c.
   Copyright (C) 1996-2017 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 "tsystem.h"
#include "coretypes.h"
#include "tm.h"
#include "libgcc_tm.h"
#include "gcov.h"

#if __CHAR_BIT__ == 8
typedef unsigned gcov_unsigned_t __attribute__ ((mode (SI)));
typedef unsigned gcov_position_t __attribute__ ((mode (SI)));
#if LONG_LONG_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 LONG_LONG_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 LONG_LONG_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

/* 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_write_tag_length __gcov_write_tag_length
#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_counter __gcov_write_counter
#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
#define gcov_sort_n_vals __gcov_sort_n_vals

#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

/* Some Macros specific to gcov-tool.  */

#define L_gcov 1
#define L_gcov_merge_add 1
#define L_gcov_merge_single 1
#define L_gcov_merge_ior 1
#define L_gcov_merge_time_profile 1
#define L_gcov_merge_icall_topn 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 gcov_magic

#ifdef HAVE_GAS_HIDDEN
#define ATTRIBUTE_HIDDEN  __attribute__ ((__visibility__ ("hidden")))
#else
#define ATTRIBUTE_HIDDEN
#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 */
  const char *filename;		/* output file name */

  gcov_merge_fn merge[GCOV_COUNTERS];  /* merge functions (null for
					  unused) */
  
  unsigned n_functions;		/* number of functions */

#ifndef IN_GCOV_TOOL
  const struct gcov_fn_info *const *functions; /* pointer to pointers
                                                  to function information  */
#else
  const struct gcov_fn_info **functions;
#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;
};
  
/* Exactly one of these will be active in the process.  */
extern struct gcov_master __gcov_master;

/* 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;

/* 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 value.  */
extern void __gcov_merge_single (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 merge function is used for topn indirect call counters.  */
extern void __gcov_merge_icall_topn (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_one_value_profiler (gcov_type *, gcov_type);
extern void __gcov_one_value_profiler_atomic (gcov_type *, gcov_type);
extern void __gcov_indirect_call_profiler_v2 (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);
extern void __gcov_indirect_call_topn_profiler (gcov_type, void *);
extern void gcov_sort_n_vals (gcov_type *, int);

#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_counter (gcov_type) ATTRIBUTE_HIDDEN;
GCOV_LINKAGE void gcov_write_tag_length (gcov_unsigned_t, gcov_unsigned_t)
    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 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
}

#endif /* !inhibit_libc */

#endif /* GCC_LIBGCOV_H */
Commit	Line	Data
67745126	1	/* Header file for libgcov-*.c.
aad93da1	2	Copyright (C) 1996-2017 Free Software Foundation, Inc.
67745126	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
e76f6040	36	#ifndef IN_GCOV_TOOL
	37	/* About the target. */
	38	/* This path will be used by libgcov runtime. */
	39
67745126	40	#include "tconfig.h"
	41	#include "tsystem.h"
	42	#include "coretypes.h"
	43	#include "tm.h"
	44	#include "libgcc_tm.h"
44d47185	45	#include "gcov.h"
67745126	46
d2dc729f	47	#if __CHAR_BIT__ == 8
67745126	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
d2dc729f	58	#if __CHAR_BIT__ == 16
67745126	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
1186f97a	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
8ceaa1ef	104	#define gcov_sort_n_vals __gcov_sort_n_vals
1186f97a	105
e76f6040	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
e76f6040	130	#define L_gcov_merge_ior 1
e76f6040	131	#define L_gcov_merge_time_profile 1
8ceaa1ef	132	#define L_gcov_merge_icall_topn 1
e76f6040	133
e76f6040	134	extern gcov_type gcov_read_counter_mem ();
e76f6040	135	extern unsigned gcov_get_merge_weight ();
145d88ea	136	extern struct gcov_info *gcov_list;
e76f6040	137
	138	#endif /* !IN_GCOV_TOOL */
	139
67745126	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
67745126	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 */
3dc22a01	183	struct gcov_ctr_info ctrs[1]; /* instrumented counters */
67745126	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 */
e76f6040	202
e76f6040	203	#ifndef IN_GCOV_TOOL
67745126	204	const struct gcov_fn_info const functions; /* pointer to pointers
e76f6040	205	to function information */
	206	#else
	207	const struct gcov_fn_info **functions;
	208	#endif /* !IN_GCOV_TOOL */
67745126	209	};
67745126	210
859fa1a9	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. */
bc587267	217	struct gcov_root *next;
bc587267	218	struct gcov_root *prev;
859fa1a9	219	};
	220
	221	extern struct gcov_root __gcov_root ATTRIBUTE_HIDDEN;
	222
bc587267	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
859fa1a9	232	/* Dump a set of gcov objects. */
	233	extern void __gcov_dump_one (struct gcov_root *) ATTRIBUTE_HIDDEN;
	234
67745126	235	/* Register a new object file module. */
	236	extern void __gcov_init (struct gcov_info *) ATTRIBUTE_HIDDEN;
	237
db46bcd3	238	/* GCOV exit function registered via a static destructor. */
	239	extern void __gcov_exit (void) ATTRIBUTE_HIDDEN;
	240
b12d2330	241	/* Function to reset all counters to 0. Both externally visible (and
b12d2330	242	overridable) and internal version. */
b12d2330	243	extern void __gcov_reset_int (void) ATTRIBUTE_HIDDEN;
67745126	244
bc587267	245	/* User function to enable early write of profile information so far. */
bc587267	246	extern void __gcov_dump_int (void) ATTRIBUTE_HIDDEN;
67745126	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
67745126	257	/* The merge function that just ors the counters together. */
	258	extern void __gcov_merge_ior (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
	259
8ceaa1ef	260	/* The merge function is used for topn indirect call counters. */
	261	extern void __gcov_merge_icall_topn (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
	262
67745126	263	/* The profiler functions. */
67745126	264	extern void __gcov_interval_profiler (gcov_type *, gcov_type, int, unsigned);
2d2b4107	265	extern void __gcov_interval_profiler_atomic (gcov_type *, gcov_type, int,
2d2b4107	266	unsigned);
67745126	267	extern void __gcov_pow2_profiler (gcov_type *, gcov_type);
2d2b4107	268	extern void __gcov_pow2_profiler_atomic (gcov_type *, gcov_type);
67745126	269	extern void __gcov_one_value_profiler (gcov_type *, gcov_type);
2d2b4107	270	extern void __gcov_one_value_profiler_atomic (gcov_type *, gcov_type);
67745126	271	extern void __gcov_indirect_call_profiler_v2 (gcov_type, void *);
67745126	272	extern void __gcov_time_profiler (gcov_type *);
2d2b4107	273	extern void __gcov_time_profiler_atomic (gcov_type *);
67745126	274	extern void __gcov_average_profiler (gcov_type *, gcov_type);
2d2b4107	275	extern void __gcov_average_profiler_atomic (gcov_type *, gcov_type);
67745126	276	extern void __gcov_ior_profiler (gcov_type *, gcov_type);
2d2b4107	277	extern void __gcov_ior_profiler_atomic (gcov_type *, gcov_type);
8ceaa1ef	278	extern void __gcov_indirect_call_topn_profiler (gcov_type, void *);
8ceaa1ef	279	extern void gcov_sort_n_vals (gcov_type *, int);
67745126	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;
1186f97a	301	GCOV_LINKAGE void gcov_rewrite (void) ATTRIBUTE_HIDDEN;
67745126	302
e76f6040	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
67745126	343	#endif /* !inhibit_libc */
	344
	345	#endif /* GCC_LIBGCOV_H */