/* File format for coverage information
- Copyright (C) 1996, 1997, 1998, 2000, 2002 Free Software Foundation, Inc.
+ 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>.
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
The basic format of the files is
- file : int32:magic int32:version record*
+ file : int32:magic int32:version int32:stamp 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
+ version number. The stamp value is used to synchronize bbg and
+ counter files and to synchronize merging within a counter file. It
+ need not be an absolute time stamp, merely a ticker that increments
+ fast enough and cycles slow enough to distinguish different
+ compile/run/compile cycles.
+
+ 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
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 heirarchy, without
+ 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: function-graph*
+ bbg: unit function-graph*
+ unit: header int32:checksum string:source
function-graph: announce_function basic_blocks {arcs | lines}*
- announce_function: header string:name int32:checksum
- string:source int32:lineno
+ 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
blocks they are for.
The data file contains the following records.
- da: {function-data* summary:object summary:program*}*
+ da: {unit function-data* summary:object summary:program*}*
+ unit: header int32:checksum
function-data: announce_function arc_counts
- announce_function: header string:name int32:checksum
+ announce_function: header int32:ident int32:checksum
arc_counts: header int64:count*
- summary: in32:checksum int32:runs int32:arcs int64:sum int64:max \
- int64:max_sum int64:sum_max
+ 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.
merged.
This file is included by both the compiler, gcov tools and the
- library. The IN_LIBGCC2 define distinguishes these cases. When
- IN_LIBGCC2 is nonzero, we're building libgcc2 for the target and
- know the compiler is (the just built) gcc. Otherwise we're
- generating code for the host, and the compiler may or may not be
- gcc. In this latter case, you must ensure that 'gcov_type' is
- typedefed to something suitable (unsigned HOST_WIDEST_INT is
- usually what you want). */
+ 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_LIBGCC2
-#if LONG_TYPE_SIZE == GCOV_TYPE_SIZE
-typedef long gcov_type;
+#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 long long gcov_type;
+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
-#endif /* IN_LIBGCC2 */
/* File suffixes. */
#define GCOV_DATA_SUFFIX ".da"
file. Values [41..9f] for those in the bbg file and [a1..ff] for
the data file. */
-#define GCOV_TAG_FUNCTION ((unsigned)0x01000000)
-#define GCOV_TAG_BLOCKS ((unsigned)0x01410000)
-#define GCOV_TAG_ARCS ((unsigned)0x01430000)
-#define GCOV_TAG_LINES ((unsigned)0x01450000)
-#define GCOV_TAG_ARC_COUNTS ((unsigned)0x01a10000)
-#define GCOV_TAG_OBJECT_SUMMARY ((unsigned)0xa1000000)
-#define GCOV_TAG_PROGRAM_SUMMARY ((unsigned)0xa3000000)
-#define GCOV_TAG_PLACEHOLDER_SUMMARY ((unsigned)0xa5000000)
-#define GCOV_TAG_INCORRECT_SUMMARY ((unsigned)0xa7000000)
+#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
/* 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
{
- unsigned checksum; /* checksum of program */
- unsigned runs; /* number of program runs */
- unsigned arcs; /* number of instrumented arcs */
- gcov_type arc_sum; /* sum of all arc counters */
- gcov_type arc_max_one; /* max counter on any one run */
- gcov_type arc_max_sum; /* maximum arc_sum */
- gcov_type arc_sum_max; /* sum of max_one */
+ 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. */
-/* Information about section of counters for a function. */
-struct counter_section
+#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
{
- unsigned tag; /* Tag of the section. */
- unsigned n_counters; /* Number of counters in the section. */
+ gcov_unsigned_t ident; /* unique ident of function */
+ gcov_unsigned_t checksum; /* function checksum */
+ unsigned n_ctrs[0]; /* instrumented counters */
};
-#if IN_LIBGCC2
-/* Information about section of counters for an object file. */
-struct counter_section_data
-{
- unsigned tag; /* Tag of the section. */
- unsigned n_counters; /* Number of counters in the section. */
- gcov_type *counters; /* The data. */
-};
+/* Type of function used to merge counters. */
+typedef void (*gcov_merge_fn) (gcov_type *, gcov_unsigned_t);
-/* Information about a single function. */
-struct function_info
+/* Information about counters. */
+struct gcov_ctr_info
{
- const char *name; /* (mangled) name of function */
- unsigned checksum; /* function checksum */
- unsigned n_counter_sections; /* Number of types of counters */
- const struct counter_section *counter_sections;
- /* The section descriptions */
+ 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
{
- unsigned long version; /* expected version number */
+ gcov_unsigned_t version; /* expected version number */
struct gcov_info *next; /* link to next, used by libgcc */
+ gcov_unsigned_t stamp; /* uniquifying time stamp */
const char *filename; /* output file name */
- long wkspc; /* libgcc workspace */
-
- unsigned n_functions; /* number of functions */
- const struct function_info *functions; /* table of functions */
-
- unsigned n_counter_sections; /* Number of types of counters */
- const struct counter_section_data *counter_sections;
- /* The data to be put into the sections. */
+
+ 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. */
/* Called before fork, to avoid double counting. */
extern void __gcov_flush (void);
-/* Since this file is used in both host and target files, and we don't
- include ansidecl.h in target files, provide some necessary macros. */
-#ifndef PARAMS
-# define PARAMS(X) X
-#endif
-#ifndef ATTRIBUTE_UNUSED
-# define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
-#endif
-
-#endif /* IN_LIBGCC2 */
-
-/* Functions for reading and writing gcov files. */
-static int gcov_write_unsigned PARAMS((FILE *, unsigned))
- ATTRIBUTE_UNUSED;
-static int gcov_write_counter PARAMS((FILE *, gcov_type))
- ATTRIBUTE_UNUSED;
-static int gcov_write_string PARAMS((FILE *, const char *, unsigned))
- ATTRIBUTE_UNUSED;
-static int gcov_read_unsigned PARAMS((FILE *, unsigned *))
- ATTRIBUTE_UNUSED;
-static int gcov_read_counter PARAMS((FILE *, gcov_type *))
- ATTRIBUTE_UNUSED;
-#if !IN_LIBGCC2
-static int gcov_read_string PARAMS((FILE *, char **, unsigned *))
- ATTRIBUTE_UNUSED;
-#endif
-static int gcov_read_summary PARAMS ((FILE *, struct gcov_summary *))
- ATTRIBUTE_UNUSED;
-#if IN_LIBGCC2
-static int gcov_write_summary PARAMS ((FILE *, unsigned,
- const struct gcov_summary *))
- ATTRIBUTE_UNUSED;
-#endif
-#define gcov_save_position(STREAM) \
- da_file_position (STREAM)
-#define gcov_reserve_length(STREAM) \
- (gcov_write_unsigned (STREAM, 0) ? 0 : da_file_position (STREAM) - 4)
-static int gcov_write_length PARAMS((FILE *, long))
- ATTRIBUTE_UNUSED;
-#define gcov_resync(STREAM, BASE, LENGTH) \
- da_file_seek (STREAM, BASE + (long)LENGTH, SEEK_SET)
-#define gcov_skip(STREAM, LENGTH) \
- da_file_seek (STREAM, LENGTH, SEEK_CUR)
-#define gcov_skip_string(STREAM, LENGTH) \
- da_file_seek (STREAM, (LENGTH) + 4 - ((LENGTH) & 3), SEEK_CUR)
-#if IN_LIBGCC2
-static FILE *da_file_open PARAMS ((const char *, int *));
-static int da_file_close PARAMS ((void));
-static int da_file_eof PARAMS ((void));
-static int da_file_error PARAMS ((void));
-#endif
-static unsigned long da_file_position PARAMS ((FILE *));
-static int da_file_seek PARAMS ((FILE *, long, int));
-static size_t da_file_write PARAMS ((const void *, size_t, size_t, FILE *));
-static size_t da_file_read PARAMS ((void *, size_t, size_t, FILE *));
-
-/* Write VALUE to coverage file FILE. Return nonzero if failed due to
- file i/o error, or value error. */
-
-static int
-gcov_write_unsigned (file, value)
- FILE *file;
- unsigned value;
-{
- char buffer[4];
- unsigned ix;
-
- for (ix = sizeof (buffer); ix--; )
- {
- buffer[ix] = value;
- value >>= 8;
- }
- return ((sizeof (value) > sizeof (buffer) && value)
- || da_file_write (buffer, 1, sizeof (buffer), file) != sizeof (buffer));
-}
-
-/* Write VALUE to coverage file FILE. Return nonzero if failed due to
- file i/o error, or value error. Negative values are not checked
- here -- they are checked in gcov_read_counter. */
-
-static int
-gcov_write_counter (file, value)
- FILE *file;
- gcov_type value;
-{
- char buffer[8];
- unsigned ix;
-
- for (ix = sizeof (buffer); ix--; )
- {
- buffer[ix] = value;
- value >>= 8;
- }
- return ((sizeof (value) > sizeof (buffer) && value != 0 && value != -1)
- || da_file_write (buffer, 1, sizeof (buffer), file) != sizeof (buffer));
-}
-
-/* Write VALUE to coverage file FILE. Return nonzero if failed due to
- file i/o error, or value error. */
-
-static int
-gcov_write_string (file, string, length)
- FILE *file;
- unsigned length;
- const char *string;
-{
- unsigned pad = 0;
- unsigned rem = 4 - (length & 3);
-
- if (string)
- return (gcov_write_unsigned (file, length)
- || da_file_write (string, 1, length, file) != length
- || da_file_write (&pad, 1, rem, file) != rem);
- else
- return gcov_write_unsigned (file, 0);
-}
-
-/* Read *VALUE_P from coverage file FILE. Return nonzero if failed
- due to file i/o error, or range error. */
-
-static int
-gcov_read_unsigned (file, value_p)
- FILE *file;
- unsigned *value_p;
-{
- unsigned value = 0;
- unsigned ix;
- unsigned char buffer[4];
-
- if (da_file_read (buffer, 1, sizeof (buffer), file) != sizeof (buffer))
- return 1;
- for (ix = sizeof (value); ix < sizeof (buffer); ix++)
- if (buffer[ix])
- return 1;
- for (ix = 0; ix != sizeof (buffer); ix++)
- {
- value <<= 8;
- value |= buffer[ix];
- }
- *value_p = value;
- return 0;
-}
-
-/* Read *VALUE_P from coverage file FILE. Return nonzero if failed
- due to file i/o error, or range error. */
-
-static int
-gcov_read_counter (file, value_p)
- FILE *file;
- gcov_type *value_p;
-{
- gcov_type value = 0;
- unsigned ix;
- unsigned char buffer[8];
-
- if (da_file_read (buffer, 1, sizeof (buffer), file) != sizeof (buffer))
- return 1;
- for (ix = sizeof (value); ix < sizeof (buffer); ix++)
- if (buffer[ix])
- return 1;
- for (ix = 0; ix != sizeof (buffer); ix++)
- {
- value <<= 8;
- value |= buffer[ix];
- }
-
- *value_p = value;
- return value < 0;
-}
+/* The merge function that just sums the counters. */
+extern void __gcov_merge_add (gcov_type *, unsigned);
-#if !IN_LIBGCC2
-
-/* Read string from coverage file FILE. Length is stored in *LENGTH_P
- (if non-null), a buffer is allocated and returned in *STRING_P.
- Return nonzero if failed due to file i/o error, or range
- error. Uses xmalloc to allocate the string buffer. */
-
-static int
-gcov_read_string (file, string_p, length_p)
- FILE *file;
- char **string_p;
- unsigned *length_p;
-{
- unsigned length;
+/* The merge function to choose the most often value. */
+extern void __gcov_merge_single (gcov_type *, unsigned);
- if (gcov_read_unsigned (file, &length))
- return 1;
-
- if (length_p)
- *length_p = length;
- free (*string_p);
-
- *string_p = NULL;
- if (!length)
- return 0;
-
- length += 4 - (length & 3);
- *string_p = (char *) xmalloc (length);
-
- return da_file_read (*string_p, 1, length, file) != length;
-
-}
+/* The merge function to choose the most often difference between consecutive
+ values. */
+extern void __gcov_merge_delta (gcov_type *, unsigned);
+#endif /* IN_LIBGCOV */
-#endif /* !IN_LIBGCC2 */
+#if IN_LIBGCOV >= 0
-/* Write a record length at PLACE. The current file position is the
- end of the record, and is restored before returning. Returns
- nonzero on failure. */
+/* Optimum size read from or written to disk. */
+#define GCOV_BLOCK_SIZE (1 << 12)
-static int
-gcov_write_length (file, place)
- FILE *file;
- long place;
+GCOV_LINKAGE struct gcov_var
{
- long here = da_file_position (file);
- int result = (!place || da_file_seek (file, place, SEEK_SET)
- || gcov_write_unsigned (file, here - place - 4));
- if (da_file_seek (file, here, SEEK_SET))
- result = 1;
- return result;
-}
-
-#define GCOV_SUMMARY_LENGTH 44
-static int
-gcov_read_summary (da_file, summary)
- FILE *da_file;
- struct gcov_summary *summary;
-{
- return (gcov_read_unsigned (da_file, &summary->checksum)
- || gcov_read_unsigned (da_file, &summary->runs)
- || gcov_read_unsigned (da_file, &summary->arcs)
- || gcov_read_counter (da_file, &summary->arc_sum)
- || gcov_read_counter (da_file, &summary->arc_max_one)
- || gcov_read_counter (da_file, &summary->arc_max_sum)
- || gcov_read_counter (da_file, &summary->arc_sum_max));
-}
-
-#if IN_LIBGCC2
-static int
-gcov_write_summary (da_file, tag, summary)
- FILE *da_file;
- unsigned tag;
- const struct gcov_summary *summary;
-{
- long base;
-
- return (gcov_write_unsigned (da_file, tag)
- || !(base = gcov_reserve_length (da_file))
- || gcov_write_unsigned (da_file, summary->checksum)
- || gcov_write_unsigned (da_file, summary->runs)
- || gcov_write_unsigned (da_file, summary->arcs)
- || gcov_write_counter (da_file, summary->arc_sum)
- || gcov_write_counter (da_file, summary->arc_max_one)
- || gcov_write_counter (da_file, summary->arc_max_sum)
- || gcov_write_counter (da_file, summary->arc_sum_max)
- || gcov_write_length (da_file, base));
-}
+ 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
-
-#if IN_LIBGCC2
-/* The kernel had problems with managing a lot of small reads/writes we use;
- the functions below are used to buffer whole file in memory, thus reading and
- writing it only once. This should be feasible, as we have this amount
- of memory for counters allocated anyway. */
-
-static FILE *actual_da_file;
-static unsigned long actual_da_file_position;
-static unsigned long actual_da_file_length;
-static char *actual_da_file_buffer;
-static unsigned long actual_da_file_buffer_size;
-
-/* Open the file NAME and return it; in EXISTED return 1 if it existed
- already. */
-static FILE *
-da_file_open (name, existed)
- const char *name;
- int *existed;
-{
-#if defined (TARGET_HAS_F_SETLKW)
- struct flock s_flock;
-
- s_flock.l_type = F_WRLCK;
- s_flock.l_whence = SEEK_SET;
- s_flock.l_start = 0;
- s_flock.l_len = 0; /* Until EOF. */
- s_flock.l_pid = getpid ();
+} 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_truncate (void);
+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 (actual_da_file)
- return 0;
- actual_da_file_position = 0;
- if (!actual_da_file_buffer)
- {
- actual_da_file_buffer = malloc (1);
- actual_da_file_buffer_size = 1;
- }
-
- actual_da_file = fopen (name, "r+t");
- if (actual_da_file)
- *existed = 1;
- else
- {
- actual_da_file = fopen (name, "w+t");
- if (actual_da_file)
- *existed = 0;
- else
- return 0;
- }
+#if !IN_GCOV
+/* Available outside gcov */
+GCOV_LINKAGE void gcov_write_unsigned (gcov_unsigned_t);
+#endif
-#if defined (TARGET_HAS_F_SETLKW)
- /* After a fork, another process might try to read and/or write
- the same file simultaneously. So if we can, lock the file to
- avoid race conditions. */
- while (fcntl (fileno (actual_da_file), F_SETLKW, &s_flock)
- && errno == EINTR)
- continue;
+#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 (*existed)
- {
- if (fseek (actual_da_file, 0, SEEK_END))
- {
- fclose (actual_da_file);
- actual_da_file = 0;
- return 0;
- }
- actual_da_file_length = ftell (actual_da_file);
- rewind (actual_da_file);
- }
- else
- actual_da_file_length = 0;
-
- if (actual_da_file_length > actual_da_file_buffer_size)
- {
- actual_da_file_buffer_size = actual_da_file_length;
- actual_da_file_buffer = realloc (actual_da_file_buffer,
- actual_da_file_buffer_size);
- if (!actual_da_file_buffer)
- {
- fclose (actual_da_file);
- actual_da_file = 0;
- return 0;
- }
- }
-
- if (*existed)
- {
- if (fread (actual_da_file_buffer, actual_da_file_length,
- 1, actual_da_file) != 1)
- {
- fclose (actual_da_file);
- actual_da_file = 0;
- return 0;
- }
- rewind (actual_da_file);
- }
-
- return actual_da_file;
-}
+#if IN_GCOV > 0
+/* Available in gcov */
+GCOV_LINKAGE time_t gcov_time (void);
+#endif
-/* Write changes to the .da file and close it. */
-static int da_file_close ()
-{
- if (!actual_da_file)
- return -1;
-
- if (fwrite (actual_da_file_buffer, actual_da_file_length,
- 1, actual_da_file) != 1)
- return da_file_error ();
-
- if (fclose (actual_da_file))
- {
- actual_da_file = 0;
- return -1;
- }
-
- actual_da_file = 0;
- return 0;
-}
+/* 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)
-/* Returns current position in .da file. */
-static unsigned long
-da_file_position (file)
- FILE *file;
-{
- if (file)
- return ftell (file);
- return actual_da_file_position;
-}
+/* Save the current position in the gcov file. */
-/* Tests whether we have reached end of .da file. */
-static int
-da_file_eof ()
+static inline gcov_position_t
+gcov_position (void)
{
- return actual_da_file_position == actual_da_file_length;
+ GCOV_CHECK_READING ();
+ return gcov_var.start + gcov_var.offset;
}
-/* Change position in the .da file. */
-static int
-da_file_seek (file, pos, whence)
- FILE *file;
- long pos;
- int whence;
-{
- if (file)
- return fseek (file, pos, whence);
-
- if (!actual_da_file)
- return -1;
-
- switch (whence)
- {
- case SEEK_CUR:
- if (pos < 0 && (unsigned long) -pos > actual_da_file_position)
- return da_file_error ();
-
- actual_da_file_position += pos;
- break;
- case SEEK_SET:
- actual_da_file_position = pos;
- break;
- case SEEK_END:
- if ((unsigned long) -pos > actual_da_file_length)
- return da_file_error ();
- actual_da_file_position = actual_da_file_length + pos;
- }
- if (actual_da_file_position > actual_da_file_length)
- return da_file_error ();
- return 0;
-}
+/* Return nonzero if we read to end of file. */
-/* Write LEN chars of DATA to actual .da file; ELTS is expected to be 1,
- FILE 0. */
-static size_t
-da_file_write (data, elts, len, file)
- const void *data;
- size_t elts;
- size_t len;
- FILE *file;
+static inline int
+gcov_is_eof (void)
{
- size_t l = len;
- const char *dat = data;
-
- if (file)
- return fwrite (data, elts, len, file);
-
- if (elts != 1)
- abort ();
-
- if (!actual_da_file)
- return -1;
- if (actual_da_file_position + len > actual_da_file_buffer_size)
- {
- actual_da_file_buffer_size = 2 * (actual_da_file_position + len);
- actual_da_file_buffer = realloc (actual_da_file_buffer,
- actual_da_file_buffer_size);
- if (!actual_da_file_buffer)
- return da_file_error ();
- }
- while (len--)
- actual_da_file_buffer[actual_da_file_position++] = *dat++;
- if (actual_da_file_position > actual_da_file_length)
- actual_da_file_length = actual_da_file_position;
-
- return l;
+ return !gcov_var.overread;
}
-/* Read LEN chars of DATA from actual .da file; ELTS is expected to be 1,
- FILE 0. */
-static size_t
-da_file_read (data, elts, len, file)
- void *data;
- size_t elts;
- size_t len;
- FILE *file;
-{
- size_t l;
- char *dat = data;
-
- if (file)
- return fread (data, elts, len, file);
-
- if (elts != 1)
- abort ();
-
- if (!actual_da_file)
- return -1;
- if (actual_da_file_position + len > actual_da_file_length)
- len = actual_da_file_length - actual_da_file_position;
- l = len;
-
- while (len--)
- *dat++ = actual_da_file_buffer[actual_da_file_position++];
- return l;
-}
+/* Return nonzero if the error flag is set. */
-/* Close the current .da file and report error. */
-static int
-da_file_error ()
-{
- if (actual_da_file)
- fclose (actual_da_file);
- actual_da_file = 0;
- return -1;
-}
-#else /* !IN_LIBGCC2 */
-static size_t
-da_file_write (data, elts, len, file)
- const void *data;
- size_t elts;
- size_t len;
- FILE *file;
+static inline int
+gcov_is_error (void)
{
- return fwrite (data, elts, len, file);
+ return gcov_var.file ? gcov_var.error : 1;
}
-static size_t
-da_file_read (data, elts, len, file)
- void *data;
- size_t elts;
- size_t len;
- FILE *file;
-{
- return fread (data, elts, len, file);
-}
+#if IN_LIBGCOV
+/* Move to beginning of file and initialize for writing. */
-static unsigned long
-da_file_position (file)
- FILE *file;
+static inline void
+gcov_rewrite (void)
{
- return ftell (file);
+ GCOV_CHECK_READING ();
+ gcov_var.mode = -1;
+ gcov_var.start = 0;
+ gcov_var.offset = 0;
+ fseek (gcov_var.file, 0L, SEEK_SET);
}
-static int
-da_file_seek (file, pos, whence)
- FILE *file;
- long pos;
- int whence;
+static inline void
+gcov_truncate (void)
{
- return fseek (file, pos, whence);
+ ftruncate (fileno (gcov_var.file), 0L);
}
#endif
+#endif /* IN_LIBGCOV >= 0 */
+
#endif /* GCC_GCOV_IO_H */
OSDN Git Service
