533 lines
19 KiB
C
533 lines
19 KiB
C
/* File format for coverage information
|
|
Copyright (C) 1996, 1997, 1998, 2000, 2002,
|
|
2003 Free Software Foundation, Inc.
|
|
Contributed by Bob Manson <manson@cygnus.com>.
|
|
Completely remangled by Nathan Sidwell <nathan@codesourcery.com>.
|
|
|
|
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 2, 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.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING. If not, write to the Free
|
|
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
|
|
02111-1307, USA. */
|
|
|
|
/* As a special exception, if you link this library with other files,
|
|
some of which are compiled with GCC, to produce an executable,
|
|
this library does not by itself cause the resulting executable
|
|
to be covered by the GNU General Public License.
|
|
This exception does not however invalidate any other reasons why
|
|
the executable file might be covered by the GNU General Public License. */
|
|
|
|
/* Coverage information is held in two files. A basic block graph
|
|
file, which is generated by the compiler, and a counter file, which
|
|
is generated by the program under test. Both files use a similar
|
|
structure. We do not attempt to make these files backwards
|
|
compatible with previous versions, as you only need coverage
|
|
information when developing a program. We do hold version
|
|
information, so that mismatches can be detected, and we use a
|
|
format that allows tools to skip information they do not understand
|
|
or are not interested in.
|
|
|
|
Numbers are recorded in big endian unsigned binary form. Either in
|
|
32 or 64 bits. Strings are stored with a length count and NUL
|
|
terminator, and 0 to 3 bytes of zero padding up to the next 4 byte
|
|
boundary. Zero length and NULL strings are simply stored as a
|
|
length of zero (they have no trailing NUL or padding).
|
|
|
|
int32: byte3 byte2 byte1 byte0
|
|
int64: byte7 byte6 byte5 byte4 byte3 byte2 byte1 byte0
|
|
string: int32:0 | int32:length char* char:0 padding
|
|
padding: | char:0 | char:0 char:0 | char:0 char:0 char:0
|
|
item: int32 | int64 | string
|
|
|
|
The basic format of the files is
|
|
|
|
file : int32:magic int32:version record*
|
|
|
|
The magic ident is different for the bbg and the counter files.
|
|
The version is the same for both files and is derived from gcc's
|
|
version number. Although the ident and version are formally 32 bit
|
|
numbers, they are derived from 4 character ASCII strings. The
|
|
version number consists of the single character major version
|
|
number, a two character minor version number (leading zero for
|
|
versions less than 10), and a single character indicating the
|
|
status of the release. That will be 'e' experimental, 'p'
|
|
prerelease and 'r' for release. Because, by good fortune, these are
|
|
in alphabetical order, string collating can be used to compare
|
|
version strings, and because numbers are stored big endian, numeric
|
|
comparison can be used when it is read as a 32 bit value. Be aware
|
|
that the 'e' designation will (naturally) be unstable and might be
|
|
incompatible with itself. For gcc 3.4 experimental, it would be
|
|
'304e' (0x33303465). When the major version reaches 10, the letters
|
|
A-Z will be used. Assuming minor increments releases every 6
|
|
months, we have to make a major increment every 50 years. Assuming
|
|
major increments releases every 5 years, we're ok for the next 155
|
|
years -- good enough for me.
|
|
|
|
A record has a tag, length and variable amount of data.
|
|
|
|
record: header data
|
|
header: int32:tag int32:length
|
|
data: item*
|
|
|
|
Records are not nested, but there is a record hierarchy. Tag
|
|
numbers reflect this hierarchy. Tags are unique across bbg and da
|
|
files. Some record types have a varying amount of data. The LENGTH
|
|
is usually used to determine how much data. The tag value is split
|
|
into 4 8-bit fields, one for each of four possible levels. The
|
|
most significant is allocated first. Unused levels are zero.
|
|
Active levels are odd-valued, so that the LSB of the level is one.
|
|
A sub-level incorporates the values of its superlevels. This
|
|
formatting allows you to determine the tag hierarchy, without
|
|
understanding the tags themselves, and is similar to the standard
|
|
section numbering used in technical documents. Level values
|
|
[1..3f] are used for common tags, values [41..9f] for the graph
|
|
file and [a1..ff] for the counter file.
|
|
|
|
The basic block graph file contains the following records
|
|
bbg: unit function-graph*
|
|
unit: header int32:checksum string:source
|
|
function-graph: announce_function basic_blocks {arcs | lines}*
|
|
announce_function: header int32:ident int32:checksum
|
|
string:name string:source int32:lineno
|
|
basic_block: header int32:flags*
|
|
arcs: header int32:block_no arc*
|
|
arc: int32:dest_block int32:flags
|
|
lines: header int32:block_no line*
|
|
int32:0 string:NULL
|
|
line: int32:line_no | int32:0 string:filename
|
|
|
|
The BASIC_BLOCK record holds per-bb flags. The number of blocks
|
|
can be inferred from its data length. There is one ARCS record per
|
|
basic block. The number of arcs from a bb is implicit from the
|
|
data length. It enumerates the destination bb and per-arc flags.
|
|
There is one LINES record per basic block, it enumerates the source
|
|
lines which belong to that basic block. Source file names are
|
|
introduced by a line number of 0, following lines are from the new
|
|
source file. The initial source file for the function is NULL, but
|
|
the current source file should be remembered from one LINES record
|
|
to the next. The end of a block is indicated by an empty filename
|
|
- this does not reset the current source file. Note there is no
|
|
ordering of the ARCS and LINES records: they may be in any order,
|
|
interleaved in any manner. The current filename follows the order
|
|
the LINES records are stored in the file, *not* the ordering of the
|
|
blocks they are for.
|
|
|
|
The data file contains the following records.
|
|
da: {unit function-data* summary:object summary:program*}*
|
|
unit: header int32:checksum
|
|
function-data: announce_function arc_counts
|
|
announce_function: header int32:ident int32:checksum
|
|
arc_counts: header int64:count*
|
|
summary: int32:checksum {count-summary}GCOV_COUNTERS
|
|
count-summary: int32:num int32:runs int64:sum
|
|
int64:max int64:sum_max
|
|
|
|
The ANNOUNCE_FUNCTION record is the same as that in the BBG file,
|
|
but without the source location.
|
|
The ARC_COUNTS gives the counter values for those arcs that are
|
|
instrumented. The SUMMARY records give information about the whole
|
|
object file and about the whole program. The checksum is used for
|
|
whole program summaries, and disambiguates different programs which
|
|
include the same instrumented object file. There may be several
|
|
program summaries, each with a unique checksum. The object
|
|
summary's checkum is zero. Note that the da file might contain
|
|
information from several runs concatenated, or the data might be
|
|
merged.
|
|
|
|
This file is included by both the compiler, gcov tools and the
|
|
runtime support library libgcov. IN_LIBGCOV and IN_GCOV are used to
|
|
distinguish which case is which. If IN_LIBGCOV is nonzero,
|
|
libgcov is being built. If IN_GCOV is nonzero, the gcov tools are
|
|
being built. Otherwise the compiler is being built. IN_GCOV may be
|
|
positive or negative. If positive, we are compiling a tool that
|
|
requires additional functions (see the code for knowledge of what
|
|
those functions are). */
|
|
|
|
#ifndef GCC_GCOV_IO_H
|
|
#define GCC_GCOV_IO_H
|
|
|
|
#if IN_LIBGCOV
|
|
/* About the target */
|
|
|
|
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)));
|
|
#else
|
|
typedef signed gcov_type __attribute__ ((mode (SI)));
|
|
#endif
|
|
|
|
#if defined (TARGET_HAS_F_SETLKW)
|
|
#define GCOV_LOCKED 1
|
|
#else
|
|
#define GCOV_LOCKED 0
|
|
#endif
|
|
|
|
#else /* !IN_LIBGCOV */
|
|
/* About the host */
|
|
|
|
typedef unsigned gcov_unsigned_t;
|
|
typedef unsigned gcov_position_t;
|
|
/* gcov_type is typedef'd elsewhere for the compiler */
|
|
#if IN_GCOV
|
|
#define GCOV_LINKAGE static
|
|
typedef HOST_WIDEST_INT gcov_type;
|
|
#if IN_GCOV > 0
|
|
#include <sys/types.h>
|
|
#endif
|
|
#else /*!IN_GCOV */
|
|
#if LONG_LONG_TYPE_SIZE > 32
|
|
#define GCOV_TYPE_NODE intDI_type_node
|
|
#else
|
|
#define GCOV_TYPE_NODE intSI_type_node
|
|
#endif
|
|
#endif
|
|
|
|
#if defined (HOST_HAS_F_SETLKW)
|
|
#define GCOV_LOCKED 1
|
|
#else
|
|
#define GCOV_LOCKED 0
|
|
#endif
|
|
|
|
#endif /* !IN_LIBGCOV */
|
|
|
|
/* In gcov we want function linkage to be static. In libgcov we need
|
|
these functions to be extern, so prefix them with __gcov. In the
|
|
compiler we want it extern, so that they can be accessed from
|
|
elsewhere. */
|
|
#if IN_LIBGCOV
|
|
#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_is_eof __gcov_is_eof
|
|
#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_read_string gcov_sync gcov_time
|
|
|
|
#endif
|
|
|
|
#ifndef GCOV_LINKAGE
|
|
#define GCOV_LINKAGE extern
|
|
#endif
|
|
|
|
/* File suffixes. */
|
|
#define GCOV_DATA_SUFFIX ".da"
|
|
#define GCOV_GRAPH_SUFFIX ".bbg"
|
|
|
|
/* File magic. */
|
|
#define GCOV_DATA_MAGIC 0x67636f76 /* "gcov" */
|
|
#define GCOV_GRAPH_MAGIC 0x67626267 /* "gbbg" */
|
|
|
|
/* gcov-iov.h is automatically generated by the makefile from
|
|
version.c, it looks like
|
|
#define GCOV_VERSION ((unsigned)0x89abcdef)
|
|
*/
|
|
#include "gcov-iov.h"
|
|
|
|
/* The record tags. Values [1..3f] are for tags which may be in either
|
|
file. Values [41..9f] for those in the bbg file and [a1..ff] for
|
|
the data file. */
|
|
|
|
#define GCOV_TAG_FUNCTION ((gcov_unsigned_t)0x01000000)
|
|
#define GCOV_TAG_FUNCTION_LENGTH (2 * 4)
|
|
#define GCOV_TAG_BLOCKS ((gcov_unsigned_t)0x01410000)
|
|
#define GCOV_TAG_BLOCKS_LENGTH(NUM) ((NUM) * 4)
|
|
#define GCOV_TAG_ARCS ((gcov_unsigned_t)0x01430000)
|
|
#define GCOV_TAG_ARCS_LENGTH(NUM) (1 * 4 + (NUM) * (2 * 4))
|
|
#define GCOV_TAG_LINES ((gcov_unsigned_t)0x01450000)
|
|
#define GCOV_TAG_COUNTER_BASE ((gcov_unsigned_t)0x01a10000)
|
|
#define GCOV_TAG_COUNTER_LENGTH(NUM) ((NUM) * 8)
|
|
#define GCOV_TAG_OBJECT_SUMMARY ((gcov_unsigned_t)0xa1000000)
|
|
#define GCOV_TAG_PROGRAM_SUMMARY ((gcov_unsigned_t)0xa3000000)
|
|
#define GCOV_TAG_SUMMARY_LENGTH \
|
|
(1 * 4 + GCOV_COUNTERS_SUMMABLE * (2 * 4 + 3 * 8))
|
|
|
|
/* Counters that are collected. */
|
|
#define GCOV_COUNTER_ARCS 0 /* Arc transitions. */
|
|
#define GCOV_COUNTERS_SUMMABLE 1 /* Counters which can be
|
|
summaried. */
|
|
#define GCOV_COUNTER_V_INTERVAL 1 /* Histogram of value inside an interval. */
|
|
#define GCOV_COUNTER_V_POW2 2 /* Histogram of exact power2 logarithm
|
|
of a value. */
|
|
#define GCOV_COUNTER_V_SINGLE 3 /* The most common value of expression. */
|
|
#define GCOV_COUNTER_V_DELTA 4 /* The most common difference between
|
|
consecutive values of expression. */
|
|
#define GCOV_COUNTERS 5
|
|
|
|
/* A list of human readable names of the counters */
|
|
#define GCOV_COUNTER_NAMES {"arcs", "interval", "pow2", "single", "delta"}
|
|
|
|
/* Names of merge functions for counters. */
|
|
#define GCOV_MERGE_FUNCTIONS {"__gcov_merge_add", \
|
|
"__gcov_merge_add", \
|
|
"__gcov_merge_add", \
|
|
"__gcov_merge_single", \
|
|
"__gcov_merge_delta"}
|
|
|
|
/* Convert a counter index to a tag. */
|
|
#define GCOV_TAG_FOR_COUNTER(COUNT) \
|
|
(GCOV_TAG_COUNTER_BASE + ((gcov_unsigned_t)(COUNT) << 17))
|
|
/* Convert a tag to a counter. */
|
|
#define GCOV_COUNTER_FOR_TAG(TAG) \
|
|
((unsigned)(((TAG) - GCOV_TAG_COUNTER_BASE) >> 17))
|
|
/* Check whether a tag is a counter tag. */
|
|
#define GCOV_TAG_IS_COUNTER(TAG) \
|
|
(!((TAG) & 0xFFFF) && GCOV_COUNTER_FOR_TAG (TAG) < GCOV_COUNTERS)
|
|
|
|
/* The tag level mask has 1's in the position of the inner levels, &
|
|
the lsb of the current level, and zero on the current and outer
|
|
levels. */
|
|
#define GCOV_TAG_MASK(TAG) (((TAG) - 1) ^ (TAG))
|
|
|
|
/* Return nonzero if SUB is an immediate subtag of TAG. */
|
|
#define GCOV_TAG_IS_SUBTAG(TAG,SUB) \
|
|
(GCOV_TAG_MASK (TAG) >> 8 == GCOV_TAG_MASK (SUB) \
|
|
&& !(((SUB) ^ (TAG)) & ~GCOV_TAG_MASK(TAG)))
|
|
|
|
/* Return nonzero if SUB is at a sublevel to TAG. */
|
|
#define GCOV_TAG_IS_SUBLEVEL(TAG,SUB) \
|
|
(GCOV_TAG_MASK (TAG) > GCOV_TAG_MASK (SUB))
|
|
|
|
/* Basic block flags. */
|
|
#define GCOV_BLOCK_UNEXPECTED (1 << 1)
|
|
|
|
/* Arc flags. */
|
|
#define GCOV_ARC_ON_TREE (1 << 0)
|
|
#define GCOV_ARC_FAKE (1 << 1)
|
|
#define GCOV_ARC_FALLTHROUGH (1 << 2)
|
|
|
|
/* Structured records. */
|
|
|
|
/* Cumulative counter data. */
|
|
struct gcov_ctr_summary
|
|
{
|
|
gcov_unsigned_t num; /* number of counters. */
|
|
gcov_unsigned_t runs; /* number of program runs */
|
|
gcov_type sum_all; /* sum of all counters accumulated. */
|
|
gcov_type run_max; /* maximum value on a single run. */
|
|
gcov_type sum_max; /* sum of individual run max values. */
|
|
};
|
|
|
|
/* Object & program summary record. */
|
|
struct gcov_summary
|
|
{
|
|
gcov_unsigned_t checksum; /* checksum of program */
|
|
struct gcov_ctr_summary ctrs[GCOV_COUNTERS_SUMMABLE];
|
|
};
|
|
|
|
/* Structures embedded in coveraged program. The structures generated
|
|
by write_profile must match these. */
|
|
|
|
#if IN_LIBGCOV
|
|
/* Information about a single function. This uses the trailing array
|
|
idiom. The number of counters is determined from the counter_mask
|
|
in gcov_info. We hold an array of function info, so have to
|
|
explicitly calculate the correct array stride. */
|
|
struct gcov_fn_info
|
|
{
|
|
gcov_unsigned_t ident; /* unique ident of function */
|
|
gcov_unsigned_t checksum; /* function checksum */
|
|
unsigned n_ctrs[0]; /* instrumented counters */
|
|
};
|
|
|
|
/* Type of function used to merge counters. */
|
|
typedef void (*gcov_merge_fn) (gcov_type *, gcov_unsigned_t);
|
|
|
|
/* Information about counters. */
|
|
struct gcov_ctr_info
|
|
{
|
|
gcov_unsigned_t num; /* number of counters. */
|
|
gcov_type *values; /* their values. */
|
|
gcov_merge_fn merge; /* The function used to merge them. */
|
|
};
|
|
|
|
/* 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 libgcc */
|
|
|
|
const char *filename; /* output file name */
|
|
|
|
unsigned n_functions; /* number of functions */
|
|
const struct gcov_fn_info *functions; /* table of functions */
|
|
|
|
unsigned ctr_mask; /* mask of counters instrumented. */
|
|
struct gcov_ctr_info counts[0]; /* count data. The number of bits
|
|
set in the ctr_mask field
|
|
determines how big this array
|
|
is. */
|
|
};
|
|
|
|
/* Register a new object file module. */
|
|
extern void __gcov_init (struct gcov_info *);
|
|
|
|
/* Called before fork, to avoid double counting. */
|
|
extern void __gcov_flush (void);
|
|
|
|
/* The merge function that just sums the counters. */
|
|
extern void __gcov_merge_add (gcov_type *, unsigned);
|
|
|
|
/* The merge function to choose the most often value. */
|
|
extern void __gcov_merge_single (gcov_type *, unsigned);
|
|
|
|
/* The merge function to choose the most often difference between consecutive
|
|
values. */
|
|
extern void __gcov_merge_delta (gcov_type *, unsigned);
|
|
#endif /* IN_LIBGCOV */
|
|
|
|
#if IN_LIBGCOV >= 0
|
|
|
|
/* Optimum size read from or written to disk. */
|
|
#define GCOV_BLOCK_SIZE (1 << 12)
|
|
|
|
GCOV_LINKAGE struct gcov_var
|
|
{
|
|
FILE *file;
|
|
gcov_position_t start; /* Position of first byte of block */
|
|
unsigned offset; /* Read/write position within the block. */
|
|
unsigned length; /* Read limit in the block. */
|
|
unsigned overread; /* Number of bytes overread. */
|
|
int error; /* < 0 overflow, > 0 disk error. */
|
|
int mode; /* < 0 writing, > 0 reading */
|
|
#if IN_LIBGCOV
|
|
/* Holds one block plus 4 bytes, thus all coverage reads & writes
|
|
fit within this buffer and we always can transfer GCOV_BLOCK_SIZE
|
|
to and from the disk. libgcov never backtracks and only writes 4
|
|
or 8 byte objects. */
|
|
unsigned char buffer[GCOV_BLOCK_SIZE + 4];
|
|
#else
|
|
/* Holds a variable length block, as the compiler can write
|
|
strings and needs to backtrack. */
|
|
size_t alloc;
|
|
unsigned char *buffer;
|
|
#endif
|
|
} gcov_var;
|
|
|
|
/* Functions for reading and writing gcov files. You can open a file
|
|
for (1) reading or (2) writing or (3) reading then rewriting. When
|
|
reading a file you may use the gcov_read_* functions, gcov_sync,
|
|
gcov_position, & gcov_error. When writing a file you
|
|
may use the gcov_write functions, gcov_seek & gcov_error. When a
|
|
file is to be rewritten you use the functions for reading, then
|
|
gcov_rewrite then the functions for writing. Your file may become
|
|
corrupted if you break these invariants. */
|
|
GCOV_LINKAGE int gcov_open (const char */*name*/, int /*truncate*/);
|
|
GCOV_LINKAGE int gcov_close (void);
|
|
|
|
/* Available everywhere. */
|
|
static gcov_position_t gcov_position (void);
|
|
static int gcov_is_error (void);
|
|
static int gcov_is_eof (void);
|
|
|
|
GCOV_LINKAGE gcov_unsigned_t gcov_read_unsigned (void);
|
|
GCOV_LINKAGE gcov_type gcov_read_counter (void);
|
|
GCOV_LINKAGE void gcov_read_summary (struct gcov_summary *);
|
|
|
|
#if IN_LIBGCOV
|
|
/* Available only in libgcov */
|
|
GCOV_LINKAGE void gcov_write_counter (gcov_type);
|
|
GCOV_LINKAGE void gcov_write_tag_length (gcov_unsigned_t, gcov_unsigned_t);
|
|
GCOV_LINKAGE void gcov_write_summary (gcov_unsigned_t /*tag*/,
|
|
const struct gcov_summary *);
|
|
static void gcov_rewrite (void);
|
|
GCOV_LINKAGE void gcov_seek (gcov_position_t /*position*/);
|
|
#else
|
|
/* Available outside libgcov */
|
|
GCOV_LINKAGE const char *gcov_read_string (void);
|
|
GCOV_LINKAGE void gcov_sync (gcov_position_t /*base*/,
|
|
gcov_unsigned_t /*length */);
|
|
#endif
|
|
|
|
#if !IN_GCOV
|
|
/* Available outside gcov */
|
|
GCOV_LINKAGE void gcov_write_unsigned (gcov_unsigned_t);
|
|
#endif
|
|
|
|
#if !IN_GCOV && !IN_LIBGCOV
|
|
/* Available only in compiler */
|
|
GCOV_LINKAGE void gcov_write_string (const char *);
|
|
GCOV_LINKAGE gcov_position_t gcov_write_tag (gcov_unsigned_t);
|
|
GCOV_LINKAGE void gcov_write_length (gcov_position_t /*position*/);
|
|
#endif
|
|
|
|
#if IN_GCOV > 0
|
|
/* Available in gcov */
|
|
GCOV_LINKAGE time_t gcov_time (void);
|
|
#endif
|
|
|
|
/* Make sure the library is used correctly. */
|
|
#if ENABLE_CHECKING
|
|
#define GCOV_CHECK(expr) ((expr) ? (void)0 : (void)abort ())
|
|
#else
|
|
#define GCOV_CHECK(expr)
|
|
#endif
|
|
#define GCOV_CHECK_READING() GCOV_CHECK(gcov_var.mode > 0)
|
|
#define GCOV_CHECK_WRITING() GCOV_CHECK(gcov_var.mode < 0)
|
|
|
|
/* Save the current position in the gcov file. */
|
|
|
|
static inline gcov_position_t
|
|
gcov_position (void)
|
|
{
|
|
GCOV_CHECK_READING ();
|
|
return gcov_var.start + gcov_var.offset;
|
|
}
|
|
|
|
/* Return nonzero if we read to end of file. */
|
|
|
|
static inline int
|
|
gcov_is_eof (void)
|
|
{
|
|
return !gcov_var.overread;
|
|
}
|
|
|
|
/* Return nonzero if the error flag is set. */
|
|
|
|
static inline int
|
|
gcov_is_error (void)
|
|
{
|
|
return gcov_var.file ? gcov_var.error : 1;
|
|
}
|
|
|
|
#if IN_LIBGCOV
|
|
/* Move to beginning of file and initialize for writing. */
|
|
|
|
static inline void
|
|
gcov_rewrite (void)
|
|
{
|
|
GCOV_CHECK_READING ();
|
|
gcov_var.mode = -1;
|
|
gcov_var.start = 0;
|
|
gcov_var.offset = 0;
|
|
fseek (gcov_var.file, 0L, SEEK_SET);
|
|
}
|
|
#endif
|
|
|
|
#endif /* IN_LIBGCOV >= 0 */
|
|
|
|
#endif /* GCC_GCOV_IO_H */
|