1/* File format for coverage information
2   Copyright (C) 1996-2014 Free Software Foundation, Inc.
3   Contributed by Bob Manson <manson@cygnus.com>.
4   Completely remangled by Nathan Sidwell <nathan@codesourcery.com>.
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16for more details.
17
18Under Section 7 of GPL version 3, you are granted additional
19permissions described in the GCC Runtime Library Exception, version
203.1, as published by the Free Software Foundation.
21
22You should have received a copy of the GNU General Public License and
23a copy of the GCC Runtime Library Exception along with this program;
24see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
25<http://www.gnu.org/licenses/>.  */
26
27
28/* Coverage information is held in two files.  A notes file, which is
29   generated by the compiler, and a data file, which is generated by
30   the program under test.  Both files use a similar structure.  We do
31   not attempt to make these files backwards compatible with previous
32   versions, as you only need coverage information when developing a
33   program.  We do hold version information, so that mismatches can be
34   detected, and we use a format that allows tools to skip information
35   they do not understand or are not interested in.
36
37   Numbers are recorded in the 32 bit unsigned binary form of the
38   endianness of the machine generating the file. 64 bit numbers are
39   stored as two 32 bit numbers, the low part first.  Strings are
40   padded with 1 to 4 NUL bytes, to bring the length up to a multiple
41   of 4. The number of 4 bytes is stored, followed by the padded
42   string. Zero length and NULL strings are simply stored as a length
43   of zero (they have no trailing NUL or padding).
44
45   	int32:  byte3 byte2 byte1 byte0 | byte0 byte1 byte2 byte3
46	int64:  int32:low int32:high
47	string: int32:0 | int32:length char* char:0 padding
48	padding: | char:0 | char:0 char:0 | char:0 char:0 char:0
49	item: int32 | int64 | string
50
51   The basic format of the files is
52
53   	file : int32:magic int32:version int32:stamp record*
54
55   The magic ident is different for the notes and the data files.  The
56   magic ident is used to determine the endianness of the file, when
57   reading.  The version is the same for both files and is derived
58   from gcc's version number. The stamp value is used to synchronize
59   note and data files and to synchronize merging within a data
60   file. It need not be an absolute time stamp, merely a ticker that
61   increments fast enough and cycles slow enough to distinguish
62   different compile/run/compile cycles.
63
64   Although the ident and version are formally 32 bit numbers, they
65   are derived from 4 character ASCII strings.  The version number
66   consists of the single character major version number, a two
67   character minor version number (leading zero for versions less than
68   10), and a single character indicating the status of the release.
69   That will be 'e' experimental, 'p' prerelease and 'r' for release.
70   Because, by good fortune, these are in alphabetical order, string
71   collating can be used to compare version strings.  Be aware that
72   the 'e' designation will (naturally) be unstable and might be
73   incompatible with itself.  For gcc 3.4 experimental, it would be
74   '304e' (0x33303465).  When the major version reaches 10, the
75   letters A-Z will be used.  Assuming minor increments releases every
76   6 months, we have to make a major increment every 50 years.
77   Assuming major increments releases every 5 years, we're ok for the
78   next 155 years -- good enough for me.
79
80   A record has a tag, length and variable amount of data.
81
82   	record: header data
83	header: int32:tag int32:length
84	data: item*
85
86   Records are not nested, but there is a record hierarchy.  Tag
87   numbers reflect this hierarchy.  Tags are unique across note and
88   data files.  Some record types have a varying amount of data.  The
89   LENGTH is the number of 4bytes that follow and is usually used to
90   determine how much data.  The tag value is split into 4 8-bit
91   fields, one for each of four possible levels.  The most significant
92   is allocated first.  Unused levels are zero.  Active levels are
93   odd-valued, so that the LSB of the level is one.  A sub-level
94   incorporates the values of its superlevels.  This formatting allows
95   you to determine the tag hierarchy, without understanding the tags
96   themselves, and is similar to the standard section numbering used
97   in technical documents.  Level values [1..3f] are used for common
98   tags, values [41..9f] for the notes file and [a1..ff] for the data
99   file.
100
101   The notes file contains the following records
102   	note: unit function-graph*
103	unit: header int32:checksum string:source
104	function-graph: announce_function basic_blocks {arcs | lines}*
105	announce_function: header int32:ident
106		int32:lineno_checksum int32:cfg_checksum
107		string:name string:source int32:lineno
108	basic_block: header int32:flags*
109	arcs: header int32:block_no arc*
110	arc:  int32:dest_block int32:flags
111        lines: header int32:block_no line*
112               int32:0 string:NULL
113	line:  int32:line_no | int32:0 string:filename
114
115   The BASIC_BLOCK record holds per-bb flags.  The number of blocks
116   can be inferred from its data length.  There is one ARCS record per
117   basic block.  The number of arcs from a bb is implicit from the
118   data length.  It enumerates the destination bb and per-arc flags.
119   There is one LINES record per basic block, it enumerates the source
120   lines which belong to that basic block.  Source file names are
121   introduced by a line number of 0, following lines are from the new
122   source file.  The initial source file for the function is NULL, but
123   the current source file should be remembered from one LINES record
124   to the next.  The end of a block is indicated by an empty filename
125   - this does not reset the current source file.  Note there is no
126   ordering of the ARCS and LINES records: they may be in any order,
127   interleaved in any manner.  The current filename follows the order
128   the LINES records are stored in the file, *not* the ordering of the
129   blocks they are for.
130
131   The data file contains the following records.
132        data: {unit summary:program* build_info zero_fixup function-data*}*
133	unit: header int32:checksum
134        function-data:	announce_function present counts
135	announce_function: header int32:ident
136		int32:lineno_checksum int32:cfg_checksum
137	present: header int32:present
138	counts: header int64:count*
139	summary: int32:checksum {count-summary}GCOV_COUNTERS_SUMMABLE
140	count-summary:	int32:num int32:runs int64:sum
141			int64:max int64:sum_max histogram
142        histogram: {int32:bitvector}8 histogram-buckets*
143        histogram-buckets: int32:num int64:min int64:sum
144        build_info: string:info*
145        zero_fixup: int32:num int32:bitvector*
146
147   The ANNOUNCE_FUNCTION record is the same as that in the note file,
148   but without the source location.  The COUNTS gives the
149   counter values for instrumented features.  The about the whole
150   program.  The checksum is used for whole program summaries, and
151   disambiguates different programs which include the same
152   instrumented object file.  There may be several program summaries,
153   each with a unique checksum.  The object summary's checksum is
154   zero.  Note that the data file might contain information from
155   several runs concatenated, or the data might be merged.
156
157   BUILD_INFO record contains a list of strings that is used
158   to include in the data file information about the profile generate
159   build.  For example, it can be used to include source revision
160   information that is useful in diagnosing profile mis-matches.
161
162   ZERO_FIXUP record contains a count of functions in the gcda file
163   and an array of bitvectors indexed by the function index's in the
164   function-data section. Each bit flags whether the function was a
165   COMDAT that had all-zero profiles that was fixed up by dyn-ipa
166   using profiles from functions with matching checksums in other modules.
167
168   This file is included by both the compiler, gcov tools and the
169   runtime support library libgcov. IN_LIBGCOV and IN_GCOV are used to
170   distinguish which case is which.  If IN_LIBGCOV is nonzero,
171   libgcov is being built. If IN_GCOV is nonzero, the gcov tools are
172   being built. Otherwise the compiler is being built. IN_GCOV may be
173   positive or negative. If positive, we are compiling a tool that
174   requires additional functions (see the code for knowledge of what
175   those functions are).  */
176
177#ifndef GCC_GCOV_IO_H
178#define GCC_GCOV_IO_H
179
180#ifndef __KERNEL__
181# define _GCOV_FILE      FILE
182# define _GCOV_fclose    fclose
183# define _GCOV_ftell     ftell
184# define _GCOV_fseek     fseek
185# define _GCOV_ftruncate ftruncate
186# define _GCOV_fread     fread
187# define _GCOV_fwrite    fwrite
188# define _GCOV_fread     fread
189# define _GCOV_fileno    fileno
190# define _GCOV_fopen     fopen
191#endif
192
193#ifndef IN_LIBGCOV
194/* About the host */
195
196typedef unsigned gcov_unsigned_t;
197typedef unsigned gcov_position_t;
198
199#if LONG_LONG_TYPE_SIZE > 32
200#define GCOV_TYPE_ATOMIC_FETCH_ADD_FN __atomic_fetch_add_8
201#define GCOV_TYPE_ATOMIC_FETCH_ADD BUILT_IN_ATOMIC_FETCH_ADD_8
202#else
203#define GCOV_TYPE_ATOMIC_FETCH_ADD_FN __atomic_fetch_add_4
204#define GCOV_TYPE_ATOMIC_FETCH_ADD BUILT_IN_ATOMIC_FETCH_ADD_4
205#endif
206#define PROFILE_GEN_EDGE_ATOMIC (flag_profile_gen_atomic == 1 || \
207                                 flag_profile_gen_atomic == 3)
208#define PROFILE_GEN_VALUE_ATOMIC (flag_profile_gen_atomic == 2 || \
209                                  flag_profile_gen_atomic == 3)
210
211/* gcov_type is typedef'd elsewhere for the compiler */
212#if IN_GCOV
213#define GCOV_LINKAGE static
214typedef HOST_WIDEST_INT gcov_type;
215typedef unsigned HOST_WIDEST_INT gcov_type_unsigned;
216#if IN_GCOV > 0
217#include <sys/types.h>
218#endif
219
220#define FUNC_ID_WIDTH HOST_BITS_PER_WIDE_INT/2
221#define FUNC_ID_MASK ((1L << FUNC_ID_WIDTH) - 1)
222#define EXTRACT_MODULE_ID_FROM_GLOBAL_ID(gid) (unsigned)(((gid) >> FUNC_ID_WIDTH) & FUNC_ID_MASK)
223#define EXTRACT_FUNC_ID_FROM_GLOBAL_ID(gid) (unsigned)((gid) & FUNC_ID_MASK)
224#define FUNC_GLOBAL_ID(m,f) ((((HOST_WIDE_INT) (m)) << FUNC_ID_WIDTH) | (f)
225
226#else /*!IN_GCOV */
227#define GCOV_TYPE_SIZE (LONG_LONG_TYPE_SIZE > 32 ? 64 : 32)
228#endif
229
230#if defined (HOST_HAS_F_SETLKW)
231#define GCOV_LOCKED 1
232#else
233#define GCOV_LOCKED 0
234#endif
235
236#define ATTRIBUTE_HIDDEN
237
238#endif /* !IN_LIBGOCV */
239
240#ifndef GCOV_LINKAGE
241#define GCOV_LINKAGE extern
242#endif
243
244/* File suffixes.  */
245#define GCOV_DATA_SUFFIX ".gcda"
246#define GCOV_NOTE_SUFFIX ".gcno"
247
248/* File magic. Must not be palindromes.  */
249#define GCOV_DATA_MAGIC ((gcov_unsigned_t)0x67636461) /* "gcda" */
250#define GCOV_NOTE_MAGIC ((gcov_unsigned_t)0x67636e6f) /* "gcno" */
251
252/* gcov-iov.h is automatically generated by the makefile from
253   version.c, it looks like
254   	#define GCOV_VERSION ((gcov_unsigned_t)0x89abcdef)
255*/
256#include "gcov-iov.h"
257
258/* Convert a magic or version number to a 4 character string.  */
259#define GCOV_UNSIGNED2STRING(ARRAY,VALUE)	\
260  ((ARRAY)[0] = (char)((VALUE) >> 24),		\
261   (ARRAY)[1] = (char)((VALUE) >> 16),		\
262   (ARRAY)[2] = (char)((VALUE) >> 8),		\
263   (ARRAY)[3] = (char)((VALUE) >> 0))
264
265/* The record tags.  Values [1..3f] are for tags which may be in either
266   file.  Values [41..9f] for those in the note file and [a1..ff] for
267   the data file.  The tag value zero is used as an explicit end of
268   file marker -- it is not required to be present.  */
269
270#define GCOV_TAG_FUNCTION	 ((gcov_unsigned_t)0x01000000)
271#define GCOV_TAG_FUNCTION_LENGTH (3)
272#define GCOV_TAG_BLOCKS		 ((gcov_unsigned_t)0x01410000)
273#define GCOV_TAG_BLOCKS_LENGTH(NUM) (NUM)
274#define GCOV_TAG_BLOCKS_NUM(LENGTH) (LENGTH)
275#define GCOV_TAG_ARCS		 ((gcov_unsigned_t)0x01430000)
276#define GCOV_TAG_ARCS_LENGTH(NUM)  (1 + (NUM) * 2)
277#define GCOV_TAG_ARCS_NUM(LENGTH)  (((LENGTH) - 1) / 2)
278#define GCOV_TAG_LINES		 ((gcov_unsigned_t)0x01450000)
279#define GCOV_TAG_COUNTER_BASE 	 ((gcov_unsigned_t)0x01a10000)
280#define GCOV_TAG_COUNTER_LENGTH(NUM) ((NUM) * 2)
281#define GCOV_TAG_COUNTER_NUM(LENGTH) ((LENGTH) / 2)
282#define GCOV_TAG_OBJECT_SUMMARY  ((gcov_unsigned_t)0xa1000000) /* Obsolete */
283#define GCOV_TAG_PROGRAM_SUMMARY ((gcov_unsigned_t)0xa3000000)
284#define GCOV_TAG_COMDAT_ZERO_FIXUP ((gcov_unsigned_t)0xa9000000)
285/* Ceiling divide by 32 bit word size, plus one word to hold NUM.  */
286#define GCOV_TAG_COMDAT_ZERO_FIXUP_LENGTH(NUM) (1 + (NUM + 31) / 32)
287#define GCOV_TAG_SUMMARY_LENGTH(NUM)  \
288        (1 + GCOV_COUNTERS_SUMMABLE * (10 + 3 * 2) + (NUM) * 5)
289#define GCOV_TAG_BUILD_INFO ((gcov_unsigned_t)0xa7000000)
290#define GCOV_TAG_MODULE_INFO ((gcov_unsigned_t)0xab000000)
291#define GCOV_TAG_AFDO_FILE_NAMES ((gcov_unsigned_t)0xaa000000)
292#define GCOV_TAG_AFDO_FUNCTION ((gcov_unsigned_t)0xac000000)
293#define GCOV_TAG_AFDO_MODULE_GROUPING ((gcov_unsigned_t)0xae000000)
294#define GCOV_TAG_AFDO_WORKING_SET ((gcov_unsigned_t)0xaf000000)
295
296/* Counters that are collected.  */
297#define DEF_GCOV_COUNTER(COUNTER, NAME, MERGE_FN) COUNTER,
298enum {
299#include "gcov-counter.def"
300GCOV_COUNTERS
301};
302#undef DEF_GCOV_COUNTER
303
304/* Counters which can be summaried.  */
305#define GCOV_COUNTERS_SUMMABLE (GCOV_COUNTER_ARCS + 1)
306
307/* The first of counters used for value profiling.  They must form a
308   consecutive interval and their order must match the order of
309   HIST_TYPEs in value-prof.h.  */
310#define GCOV_FIRST_VALUE_COUNTER GCOV_COUNTERS_SUMMABLE
311
312/* The last of counters used for value profiling.  */
313#define GCOV_LAST_VALUE_COUNTER (GCOV_COUNTERS - 2)
314
315/* Number of counters used for value profiling.  */
316#define GCOV_N_VALUE_COUNTERS \
317  (GCOV_LAST_VALUE_COUNTER - GCOV_FIRST_VALUE_COUNTER + 1)
318
319#define GCOV_ICALL_TOPN_VAL  2   /* Track two hottest callees */
320#define GCOV_ICALL_TOPN_NCOUNTS  9 /* The number of counter entries per icall callsite */
321
322/* Convert a counter index to a tag.  */
323#define GCOV_TAG_FOR_COUNTER(COUNT)				\
324	(GCOV_TAG_COUNTER_BASE + ((gcov_unsigned_t)(COUNT) << 17))
325/* Convert a tag to a counter.  */
326#define GCOV_COUNTER_FOR_TAG(TAG)					\
327	((unsigned)(((TAG) - GCOV_TAG_COUNTER_BASE) >> 17))
328/* Check whether a tag is a counter tag.  */
329#define GCOV_TAG_IS_COUNTER(TAG)				\
330	(!((TAG) & 0xFFFF) && GCOV_COUNTER_FOR_TAG (TAG) < GCOV_COUNTERS)
331
332/* The tag level mask has 1's in the position of the inner levels, &
333   the lsb of the current level, and zero on the current and outer
334   levels.  */
335#define GCOV_TAG_MASK(TAG) (((TAG) - 1) ^ (TAG))
336
337/* Return nonzero if SUB is an immediate subtag of TAG.  */
338#define GCOV_TAG_IS_SUBTAG(TAG,SUB)				\
339	(GCOV_TAG_MASK (TAG) >> 8 == GCOV_TAG_MASK (SUB) 	\
340	 && !(((SUB) ^ (TAG)) & ~GCOV_TAG_MASK (TAG)))
341
342/* Return nonzero if SUB is at a sublevel to TAG.  */
343#define GCOV_TAG_IS_SUBLEVEL(TAG,SUB)				\
344     	(GCOV_TAG_MASK (TAG) > GCOV_TAG_MASK (SUB))
345
346/* Basic block flags.  */
347#define GCOV_BLOCK_UNEXPECTED	(1 << 1)
348
349/* Arc flags.  */
350#define GCOV_ARC_ON_TREE 	(1 << 0)
351#define GCOV_ARC_FAKE		(1 << 1)
352#define GCOV_ARC_FALLTHROUGH	(1 << 2)
353
354/* Structured records.  */
355
356/* Structure used for each bucket of the log2 histogram of counter values.  */
357typedef struct
358{
359  /* Number of counters whose profile count falls within the bucket.  */
360  gcov_unsigned_t num_counters;
361  /* Smallest profile count included in this bucket.  */
362  gcov_type min_value;
363  /* Cumulative value of the profile counts in this bucket.  */
364  gcov_type cum_value;
365} gcov_bucket_type;
366
367/* For a log2 scale histogram with each range split into 4
368   linear sub-ranges, there will be at most 64 (max gcov_type bit size) - 1 log2
369   ranges since the lowest 2 log2 values share the lowest 4 linear
370   sub-range (values 0 - 3).  This is 252 total entries (63*4).  */
371
372#define GCOV_HISTOGRAM_SIZE 252
373
374/* How many unsigned ints are required to hold a bit vector of non-zero
375   histogram entries when the histogram is written to the gcov file.
376   This is essentially a ceiling divide by 32 bits.  */
377#define GCOV_HISTOGRAM_BITVECTOR_SIZE (GCOV_HISTOGRAM_SIZE + 31) / 32
378
379/* Cumulative counter data.  */
380struct gcov_ctr_summary
381{
382  gcov_unsigned_t num;		/* number of counters.  */
383  gcov_unsigned_t runs;		/* number of program runs */
384  gcov_type sum_all;		/* sum of all counters accumulated.  */
385  gcov_type run_max;		/* maximum value on a single run.  */
386  gcov_type sum_max;    	/* sum of individual run max values.  */
387  gcov_bucket_type histogram[GCOV_HISTOGRAM_SIZE]; /* histogram of
388                                                      counter values.  */
389};
390
391/* Object & program summary record.  */
392struct gcov_summary
393{
394  gcov_unsigned_t checksum;	/* checksum of program */
395  struct gcov_ctr_summary ctrs[GCOV_COUNTERS_SUMMABLE];
396};
397
398#define GCOV_MODULE_UNKNOWN_LANG  0
399#define GCOV_MODULE_C_LANG    1
400#define GCOV_MODULE_CPP_LANG  2
401#define GCOV_MODULE_FORT_LANG 3
402
403#define GCOV_MODULE_ASM_STMTS (1 << 16)
404#define GCOV_MODULE_LANG_MASK 0xffff
405
406/* Source module info. The data structure is used in
407   both runtime and profile-use phase. Make sure to allocate
408   enough space for the variable length member.  */
409struct gcov_module_info
410{
411  gcov_unsigned_t ident;
412  gcov_unsigned_t is_primary; /* this is overloaded to mean two things:
413                                 (1) means FDO/LIPO in instrumented binary.
414                                 (2) means IS_PRIMARY in persistent file or
415                                     memory copy used in profile-use.  */
416  gcov_unsigned_t flags;      /* bit 0: is_exported,
417                                 bit 1: need to include all the auxiliary
418                                 modules in use compilation.  */
419  gcov_unsigned_t lang; /* lower 16 bits encode the language, and the upper
420                           16 bits enocde other attributes, such as whether
421                           any assembler is present in the source, etc.  */
422  gcov_unsigned_t ggc_memory; /* memory needed for parsing in kb  */
423  char *da_filename;
424  char *source_filename;
425  gcov_unsigned_t num_quote_paths;
426  gcov_unsigned_t num_bracket_paths;
427  gcov_unsigned_t num_system_paths;
428  gcov_unsigned_t num_cpp_defines;
429  gcov_unsigned_t num_cpp_includes;
430  gcov_unsigned_t num_cl_args;
431  char *string_array[1];
432};
433
434extern struct gcov_module_info **module_infos;
435extern unsigned primary_module_id;
436#define SET_MODULE_INCLUDE_ALL_AUX(modu) ((modu->flags |= 0x2))
437#define MODULE_INCLUDE_ALL_AUX_FLAG(modu) ((modu->flags & 0x2))
438#define SET_MODULE_EXPORTED(modu) ((modu->flags |= 0x1))
439#define MODULE_EXPORTED_FLAG(modu) ((modu->flags & 0x1))
440#define PRIMARY_MODULE_EXPORTED                                         \
441  (MODULE_EXPORTED_FLAG (module_infos[0])                               \
442   && !((module_infos[0]->lang & GCOV_MODULE_ASM_STMTS)                 \
443        && flag_ripa_disallow_asm_modules))
444
445#if !defined(inhibit_libc)
446
447/* Functions for reading and writing gcov files. In libgcov you can
448   open the file for reading then writing. Elsewhere you can open the
449   file either for reading or for writing. When reading a file you may
450   use the gcov_read_* functions, gcov_sync, gcov_position, &
451   gcov_error. When writing a file you may use the gcov_write
452   functions, gcov_seek & gcov_error. When a file is to be rewritten
453   you use the functions for reading, then gcov_rewrite then the
454   functions for writing.  Your file may become corrupted if you break
455   these invariants.  */
456
457#if !IN_LIBGCOV
458GCOV_LINKAGE int gcov_open (const char */*name*/, int /*direction*/);
459GCOV_LINKAGE int gcov_magic (gcov_unsigned_t, gcov_unsigned_t);
460#endif
461
462/* Available everywhere.  */
463GCOV_LINKAGE int gcov_close (void) ATTRIBUTE_HIDDEN;
464GCOV_LINKAGE gcov_unsigned_t gcov_read_unsigned (void) ATTRIBUTE_HIDDEN;
465GCOV_LINKAGE gcov_type gcov_read_counter (void) ATTRIBUTE_HIDDEN;
466GCOV_LINKAGE void gcov_read_summary (struct gcov_summary *) ATTRIBUTE_HIDDEN;
467GCOV_LINKAGE int *gcov_read_comdat_zero_fixup (gcov_unsigned_t,
468                                               gcov_unsigned_t *)
469    ATTRIBUTE_HIDDEN;
470GCOV_LINKAGE char **gcov_read_build_info (gcov_unsigned_t, gcov_unsigned_t *)
471  ATTRIBUTE_HIDDEN;
472GCOV_LINKAGE const char *gcov_read_string (void);
473GCOV_LINKAGE void gcov_sync (gcov_position_t /*base*/,
474			     gcov_unsigned_t /*length */);
475GCOV_LINKAGE gcov_unsigned_t gcov_read_string_array (char **, gcov_unsigned_t)
476  ATTRIBUTE_HIDDEN;
477
478
479#if !IN_LIBGCOV && IN_GCOV != 1
480GCOV_LINKAGE void gcov_read_module_info (struct gcov_module_info *mod_info,
481					 gcov_unsigned_t len) ATTRIBUTE_HIDDEN;
482#endif
483
484#if !IN_GCOV
485/* Available outside gcov */
486GCOV_LINKAGE void gcov_write_unsigned (gcov_unsigned_t) ATTRIBUTE_HIDDEN;
487GCOV_LINKAGE gcov_unsigned_t gcov_compute_string_array_len (char **,
488                                                            gcov_unsigned_t)
489  ATTRIBUTE_HIDDEN;
490GCOV_LINKAGE void gcov_write_string_array (char **, gcov_unsigned_t)
491  ATTRIBUTE_HIDDEN;
492#endif
493
494#if !IN_GCOV && !IN_LIBGCOV
495/* Available only in compiler */
496GCOV_LINKAGE unsigned gcov_histo_index (gcov_type value);
497GCOV_LINKAGE void gcov_write_string (const char *);
498GCOV_LINKAGE gcov_position_t gcov_write_tag (gcov_unsigned_t);
499GCOV_LINKAGE void gcov_write_length (gcov_position_t /*position*/);
500#endif
501
502#if IN_GCOV <= 0 && !IN_LIBGCOV
503/* Available in gcov-dump and the compiler.  */
504
505/* Number of data points in the working set summary array. Using 128
506   provides information for at least every 1% increment of the total
507   profile size. The last entry is hardwired to 99.9% of the total.  */
508#define NUM_GCOV_WORKING_SETS 128
509
510/* Working set size statistics for a given percentage of the entire
511   profile (sum_all from the counter summary).  */
512typedef struct gcov_working_set_info
513{
514  /* Number of hot counters included in this working set.  */
515  unsigned num_counters;
516  /* Smallest counter included in this working set.  */
517  gcov_type min_counter;
518} gcov_working_set_t;
519
520GCOV_LINKAGE void compute_working_sets (const struct gcov_ctr_summary *summary,
521                                        gcov_working_set_t *gcov_working_sets);
522#endif
523
524#if IN_GCOV > 0
525/* Available in gcov */
526GCOV_LINKAGE time_t gcov_time (void);
527#endif
528
529#endif /* !inhibit_libc  */
530
531#endif /* GCC_GCOV_IO_H */
532