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

/* Header file for libgcov-*.c.
   Copyright (C) 1996-2014 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"

#if BITS_PER_UNIT == 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 BITS_PER_UNIT == 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

#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_delta 1
#define L_gcov_merge_ior 1
#define L_gcov_merge_time_profile 1

/* Make certian internal functions/variables in libgcov available for
   gcov-tool access.  */
#define GCOV_TOOL_LINKAGE 

extern gcov_type gcov_read_counter_mem ();
extern unsigned gcov_get_merge_weight ();

#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

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

/* 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[0];		/* 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 */
};

/* Register a new object file module.  */
extern void __gcov_init (struct gcov_info *) ATTRIBUTE_HIDDEN;

/* Called before fork, to avoid double counting.  */
extern void __gcov_flush (void) ATTRIBUTE_HIDDEN;

/* Function to reset all counters to 0.  */
extern void __gcov_reset (void);

/* Function to enable early write of profile information so far.  */
extern void __gcov_dump (void);

/* 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 to choose the most common difference between
   consecutive values.  */
extern void __gcov_merge_delta (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_pow2_profiler (gcov_type *, gcov_type);
extern void __gcov_one_value_profiler (gcov_type *, gcov_type);
extern void __gcov_indirect_call_profiler (gcov_type*, gcov_type,
                                           void*, void*);
extern void __gcov_indirect_call_profiler_v2 (gcov_type, void *);
extern void __gcov_time_profiler (gcov_type *);
extern void __gcov_average_profiler (gcov_type *, gcov_type);
extern void __gcov_ior_profiler (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_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 inline void gcov_rewrite (void);

/* "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.
	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
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"
	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
e76f6040	86	#else /* IN_GCOV_TOOL */
	87	/* About the host. */
	88	/* This path will be compiled for the host and linked into
	89	gcov-tool binary. */
	90
	91	#include "config.h"
	92	#include "system.h"
	93	#include "coretypes.h"
	94	#include "tm.h"
	95
	96	typedef unsigned gcov_unsigned_t;
	97	typedef unsigned gcov_position_t;
	98	/* gcov_type is typedef'd elsewhere for the compiler */
	99	#if defined (HOST_HAS_F_SETLKW)
	100	#define GCOV_LOCKED 1
	101	#else
	102	#define GCOV_LOCKED 0
	103	#endif
	104
	105	/* Some Macros specific to gcov-tool. */
	106
	107	#define L_gcov 1
	108	#define L_gcov_merge_add 1
	109	#define L_gcov_merge_single 1
	110	#define L_gcov_merge_delta 1
	111	#define L_gcov_merge_ior 1
	112	#define L_gcov_merge_time_profile 1
	113
	114	/* Make certian internal functions/variables in libgcov available for
	115	gcov-tool access. */
	116	#define GCOV_TOOL_LINKAGE
	117
	118	extern gcov_type gcov_read_counter_mem ();
	119	extern unsigned gcov_get_merge_weight ();
	120
	121	#endif /* !IN_GCOV_TOOL */
	122
67745126	123	#if defined(inhibit_libc)
	124	#define IN_LIBGCOV (-1)
	125	#else
	126	#define IN_LIBGCOV 1
	127	#if defined(L_gcov)
	128	#define GCOV_LINKAGE /* nothing */
	129	#endif
	130	#endif
	131
	132	/* In libgcov we need these functions to be extern, so prefix them with
	133	__gcov. In libgcov they must also be hidden so that the instance in
	134	the executable is not also used in a DSO. */
	135	#define gcov_var __gcov_var
	136	#define gcov_open __gcov_open
	137	#define gcov_close __gcov_close
	138	#define gcov_write_tag_length __gcov_write_tag_length
	139	#define gcov_position __gcov_position
	140	#define gcov_seek __gcov_seek
	141	#define gcov_rewrite __gcov_rewrite
	142	#define gcov_is_error __gcov_is_error
	143	#define gcov_write_unsigned __gcov_write_unsigned
	144	#define gcov_write_counter __gcov_write_counter
	145	#define gcov_write_summary __gcov_write_summary
	146	#define gcov_read_unsigned __gcov_read_unsigned
	147	#define gcov_read_counter __gcov_read_counter
	148	#define gcov_read_summary __gcov_read_summary
	149
	150	/* Poison these, so they don't accidentally slip in. */
	151	#pragma GCC poison gcov_write_string gcov_write_tag gcov_write_length
	152	#pragma GCC poison gcov_time gcov_magic
	153
	154	#ifdef HAVE_GAS_HIDDEN
	155	#define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden")))
	156	#else
	157	#define ATTRIBUTE_HIDDEN
	158	#endif
	159
	160	#include "gcov-io.h"
	161
	162	/* Structures embedded in coveraged program. The structures generated
	163	by write_profile must match these. */
	164
	165	/* Information about counters for a single function. */
	166	struct gcov_ctr_info
	167	{
	168	gcov_unsigned_t num; /* number of counters. */
	169	gcov_type values; / their values. */
	170	};
	171
	172	/* Information about a single function. This uses the trailing array
	173	idiom. The number of counters is determined from the merge pointer
	174	array in gcov_info. The key is used to detect which of a set of
	175	comdat functions was selected -- it points to the gcov_info object
	176	of the object file containing the selected comdat function. */
	177
	178	struct gcov_fn_info
	179	{
	180	const struct gcov_info key; / comdat key */
	181	gcov_unsigned_t ident; /* unique ident of function */
	182	gcov_unsigned_t lineno_checksum; /* function lineo_checksum */
	183	gcov_unsigned_t cfg_checksum; /* function cfg checksum */
	184	struct gcov_ctr_info ctrs[0]; /* instrumented counters */
	185	};
	186
187	/* Type of function used to merge counters. */
188	typedef void (gcov_merge_fn) (gcov_type , gcov_unsigned_t);
189
190	/* Information about a single object file. */
191	struct gcov_info
192	{
193	gcov_unsigned_t version; /* expected version number */
194	struct gcov_info next; / link to next, used by libgcov */
195
196	gcov_unsigned_t stamp; /* uniquifying time stamp */
197	const char filename; / output file name */
198
199	gcov_merge_fn merge[GCOV_COUNTERS]; /* merge functions (null for
200	unused) */
201
202	unsigned n_functions; /* number of functions */
e76f6040	203
e76f6040	204	#ifndef IN_GCOV_TOOL
67745126	205	const struct gcov_fn_info const functions; /* pointer to pointers
e76f6040	206	to function information */
	207	#else
	208	const struct gcov_fn_info **functions;
	209	#endif /* !IN_GCOV_TOOL */
67745126	210	};
	211
	212	/* Register a new object file module. */
	213	extern void __gcov_init (struct gcov_info *) ATTRIBUTE_HIDDEN;
	214
	215	/* Called before fork, to avoid double counting. */
	216	extern void __gcov_flush (void) ATTRIBUTE_HIDDEN;
	217
	218	/* Function to reset all counters to 0. */
	219	extern void __gcov_reset (void);
	220
	221	/* Function to enable early write of profile information so far. */
	222	extern void __gcov_dump (void);
	223
	224	/* The merge function that just sums the counters. */
	225	extern void __gcov_merge_add (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
	226
	227	/* The merge function to select the minimum valid counter value. */
	228	extern void __gcov_merge_time_profile (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
	229
	230	/* The merge function to choose the most common value. */
	231	extern void __gcov_merge_single (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
	232
	233	/* The merge function to choose the most common difference between
	234	consecutive values. */
	235	extern void __gcov_merge_delta (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
	236
	237	/* The merge function that just ors the counters together. */
	238	extern void __gcov_merge_ior (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
	239
	240	/* The profiler functions. */
	241	extern void __gcov_interval_profiler (gcov_type *, gcov_type, int, unsigned);
	242	extern void __gcov_pow2_profiler (gcov_type *, gcov_type);
	243	extern void __gcov_one_value_profiler (gcov_type *, gcov_type);
	244	extern void __gcov_indirect_call_profiler (gcov_type*, gcov_type,
	245	void, void);
	246	extern void __gcov_indirect_call_profiler_v2 (gcov_type, void *);
	247	extern void __gcov_time_profiler (gcov_type *);
	248	extern void __gcov_average_profiler (gcov_type *, gcov_type);
	249	extern void __gcov_ior_profiler (gcov_type *, gcov_type);
	250
	251	#ifndef inhibit_libc
	252	/* The wrappers around some library functions.. */
	253	extern pid_t __gcov_fork (void) ATTRIBUTE_HIDDEN;
	254	extern int __gcov_execl (const char , char , ...) ATTRIBUTE_HIDDEN;
	255	extern int __gcov_execlp (const char , char , ...) ATTRIBUTE_HIDDEN;
	256	extern int __gcov_execle (const char , char , ...) ATTRIBUTE_HIDDEN;
	257	extern int __gcov_execv (const char , char const []) ATTRIBUTE_HIDDEN;
	258	extern int __gcov_execvp (const char , char const []) ATTRIBUTE_HIDDEN;
	259	extern int __gcov_execve (const char , char const [], char *const [])
	260	ATTRIBUTE_HIDDEN;
	261
	262	/* Functions that only available in libgcov. */
	263	GCOV_LINKAGE int gcov_open (const char /name*/) ATTRIBUTE_HIDDEN;
	264	GCOV_LINKAGE void gcov_write_counter (gcov_type) ATTRIBUTE_HIDDEN;
	265	GCOV_LINKAGE void gcov_write_tag_length (gcov_unsigned_t, gcov_unsigned_t)
	266	ATTRIBUTE_HIDDEN;
	267	GCOV_LINKAGE void gcov_write_summary (gcov_unsigned_t /tag/,
	268	const struct gcov_summary *)
	269	ATTRIBUTE_HIDDEN;
	270	GCOV_LINKAGE void gcov_seek (gcov_position_t /position/) ATTRIBUTE_HIDDEN;
	271	GCOV_LINKAGE inline void gcov_rewrite (void);
	272
e76f6040	273	/* "Counts" stored in gcda files can be a real counter value, or
	274	an target address. When differentiate these two types because
	275	when manipulating counts, we should only change real counter values,
	276	rather target addresses. */
	277
	278	static inline gcov_type
	279	gcov_get_counter (void)
	280	{
	281	#ifndef IN_GCOV_TOOL
	282	/* This version is for reading count values in libgcov runtime:
	283	we read from gcda files. */
	284
	285	return gcov_read_counter ();
	286	#else
	287	/* This version is for gcov-tool. We read the value from memory and
	288	multiply it by the merge weight. */
	289
	290	return gcov_read_counter_mem () * gcov_get_merge_weight ();
	291	#endif
	292	}
	293
	294	/* Similar function as gcov_get_counter(), but handles target address
	295	counters. */
	296
	297	static inline gcov_type
	298	gcov_get_counter_target (void)
	299	{
	300	#ifndef IN_GCOV_TOOL
	301	/* This version is for reading count target values in libgcov runtime:
	302	we read from gcda files. */
	303
	304	return gcov_read_counter ();
	305	#else
	306	/* This version is for gcov-tool. We read the value from memory and we do NOT
	307	multiply it by the merge weight. */
	308
	309	return gcov_read_counter_mem ();
	310	#endif
	311	}
	312
67745126	313	#endif /* !inhibit_libc */
	314
	315	#endif /* GCC_LIBGCOV_H */