/* Routines required for instrumenting a program. */
/* Compile this one with gcc. */
/* Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+ 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
unsigned n_counters __attribute__ ((unused))) {}
#endif
+#ifdef L_gcov_merge_single
+void __gcov_merge_single (gcov_type *counters __attribute__ ((unused)),
+ unsigned n_counters __attribute__ ((unused))) {}
+#endif
+
+#ifdef L_gcov_merge_delta
+void __gcov_merge_delta (gcov_type *counters __attribute__ ((unused)),
+ unsigned n_counters __attribute__ ((unused))) {}
+#endif
+
#else
#include <string.h>
#if GCOV_LOCKED
#include <fcntl.h>
#include <errno.h>
+#include <sys/stat.h>
#endif
#ifdef L_gcov
object file included in multiple programs. */
static gcov_unsigned_t gcov_crc32;
-static void
-gcov_version_mismatch (struct gcov_info *ptr, gcov_unsigned_t version)
+static int
+gcov_version (struct gcov_info *ptr, gcov_unsigned_t version)
{
- gcov_unsigned_t expected = GCOV_VERSION;
- unsigned ix;
- char e[4], v[4];
-
- for (ix = 4; ix--; expected >>= 8, version >>= 8)
+ if (version != GCOV_VERSION)
{
- e[ix] = expected;
- v[ix] = version;
+ char v[4], e[4];
+
+ GCOV_UNSIGNED2STRING (v, version);
+ GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
+
+ fprintf (stderr,
+ "profiling:%s:Version mismatch - expected %.4s got %.4s\n",
+ ptr->filename, e, v);
+ return 0;
}
-
- fprintf (stderr,
- "profiling:%s:Version mismatch - expected %.4s got %.4s\n",
- ptr->filename, e, v);
+ return 1;
}
/* Dump the coverage counts. We merge with existing counts when
struct gcov_info *gi_ptr;
struct gcov_summary this_program;
struct gcov_summary all;
+ struct gcov_ctr_summary *cs_ptr;
+ const struct gcov_ctr_info *ci_ptr;
+ unsigned t_ix;
+ gcov_unsigned_t c_num;
memset (&all, 0, sizeof (all));
/* Find the totals for this execution. */
memset (&this_program, 0, sizeof (this_program));
for (gi_ptr = gcov_list; gi_ptr; gi_ptr = gi_ptr->next)
{
- const struct gcov_ctr_info *ci_ptr;
- struct gcov_ctr_summary *cs_ptr;
- unsigned t_ix;
-
- for (t_ix = 0, ci_ptr = gi_ptr->counts, cs_ptr = this_program.ctrs;
- t_ix != GCOV_COUNTERS_SUMMABLE; t_ix++, cs_ptr++)
- if ((1 << t_ix) & gi_ptr->ctr_mask)
- {
- const gcov_type *c_ptr;
- gcov_unsigned_t c_num;
-
- cs_ptr->num += ci_ptr->num;
- for (c_num = ci_ptr->num, c_ptr = ci_ptr->values; c_num--; c_ptr++)
- {
- cs_ptr->sum_all += *c_ptr;
- if (cs_ptr->run_max < *c_ptr)
- cs_ptr->run_max = *c_ptr;
- }
- ci_ptr++;
- }
+ ci_ptr = gi_ptr->counts;
+ for (t_ix = 0; t_ix < GCOV_COUNTERS_SUMMABLE; t_ix++)
+ {
+ if (!((1 << t_ix) & gi_ptr->ctr_mask))
+ continue;
+
+ cs_ptr = &this_program.ctrs[t_ix];
+ cs_ptr->num += ci_ptr->num;
+ for (c_num = 0; c_num < ci_ptr->num; c_num++)
+ {
+ cs_ptr->sum_all += ci_ptr->values[c_num];
+ if (cs_ptr->run_max < ci_ptr->values[c_num])
+ cs_ptr->run_max = ci_ptr->values[c_num];
+ }
+ ci_ptr++;
+ }
}
- /* Now merge each file */
+ /* Now merge each file. */
for (gi_ptr = gcov_list; gi_ptr; gi_ptr = gi_ptr->next)
{
struct gcov_summary this_object;
gcov_type *values[GCOV_COUNTERS];
const struct gcov_fn_info *fi_ptr;
unsigned fi_stride;
- unsigned c_ix, t_ix, f_ix;
- const struct gcov_ctr_info *ci_ptr;
- struct gcov_ctr_summary *cs_ptr;
+ unsigned c_ix, f_ix, n_counts;
struct gcov_ctr_summary *cs_obj, *cs_tobj, *cs_prg, *cs_tprg, *cs_all;
int error = 0;
- int merging;
gcov_unsigned_t tag, length;
gcov_position_t summary_pos = 0;
+ gcov_position_t eof_pos = 0;
- /* Totals for this object file. */
memset (&this_object, 0, sizeof (this_object));
- for (t_ix = c_ix = 0,
- ci_ptr = gi_ptr->counts, cs_ptr = this_object.ctrs;
- t_ix != GCOV_COUNTERS_SUMMABLE; t_ix++, cs_ptr++)
+ memset (&object, 0, sizeof (object));
+
+ /* Totals for this object file. */
+ ci_ptr = gi_ptr->counts;
+ for (t_ix = 0; t_ix < GCOV_COUNTERS_SUMMABLE; t_ix++)
+ {
+ if (!((1 << t_ix) & gi_ptr->ctr_mask))
+ continue;
+
+ cs_ptr = &this_object.ctrs[t_ix];
+ cs_ptr->num += ci_ptr->num;
+ for (c_num = 0; c_num < ci_ptr->num; c_num++)
+ {
+ cs_ptr->sum_all += ci_ptr->values[c_num];
+ if (cs_ptr->run_max < ci_ptr->values[c_num])
+ cs_ptr->run_max = ci_ptr->values[c_num];
+ }
+
+ ci_ptr++;
+ }
+
+ c_ix = 0;
+ for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++)
if ((1 << t_ix) & gi_ptr->ctr_mask)
{
- const gcov_type *c_ptr;
- gcov_unsigned_t c_num;
-
- cs_ptr->num += ci_ptr->num;
- values[c_ix] = ci_ptr->values;
- for (c_num = ci_ptr->num, c_ptr = ci_ptr->values; c_num--; c_ptr++)
- {
- cs_ptr->sum_all += *c_ptr;
- if (cs_ptr->run_max < *c_ptr)
- cs_ptr->run_max = *c_ptr;
- }
+ values[c_ix] = gi_ptr->counts[c_ix].values;
c_ix++;
- ci_ptr++;
}
/* Calculate the function_info stride. This depends on the
fi_stride &= ~(__alignof__ (struct gcov_fn_info) - 1);
}
- /* Open for modification, if possible */
- merging = gcov_open (gi_ptr->filename, 0);
- if (!merging)
+ if (!gcov_open (gi_ptr->filename))
{
fprintf (stderr, "profiling:%s:Cannot open\n", gi_ptr->filename);
continue;
}
-
- if (merging > 0)
+
+ tag = gcov_read_unsigned ();
+ if (tag)
{
/* Merge data from file. */
- if (gcov_read_unsigned () != GCOV_DATA_MAGIC)
+ if (tag != GCOV_DATA_MAGIC)
{
fprintf (stderr, "profiling:%s:Not a gcov data file\n",
gi_ptr->filename);
- read_fatal:;
- gcov_close ();
- continue;
- }
- length = gcov_read_unsigned ();
- if (length != GCOV_VERSION)
- {
- gcov_version_mismatch (gi_ptr, length);
goto read_fatal;
}
+ length = gcov_read_unsigned ();
+ if (!gcov_version (gi_ptr, length))
+ goto read_fatal;
+
+ length = gcov_read_unsigned ();
+ if (length != gi_ptr->stamp)
+ /* Read from a different compilation. Overwrite the file. */
+ goto rewrite;
/* Merge execution counts for each function. */
- for (f_ix = gi_ptr->n_functions, fi_ptr = gi_ptr->functions;
- f_ix--;
- fi_ptr = (const struct gcov_fn_info *)
- ((const char *) fi_ptr + fi_stride))
+ for (f_ix = 0; f_ix < gi_ptr->n_functions; f_ix++)
{
+ fi_ptr = (const struct gcov_fn_info *)
+ ((const char *) gi_ptr->functions + f_ix * fi_stride);
tag = gcov_read_unsigned ();
length = gcov_read_unsigned ();
- /* Check function */
+ /* Check function. */
if (tag != GCOV_TAG_FUNCTION
|| length != GCOV_TAG_FUNCTION_LENGTH
|| gcov_read_unsigned () != fi_ptr->ident
goto read_fatal;
}
- for (c_ix = t_ix = 0; t_ix != GCOV_COUNTERS; t_ix++)
- if ((1 << t_ix) & gi_ptr->ctr_mask)
- {
- unsigned n_counts = fi_ptr->n_ctrs[c_ix];
- gcov_merge_fn merge = gi_ptr->counts[c_ix].merge;
+ c_ix = 0;
+ for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++)
+ {
+ gcov_merge_fn merge;
+
+ if (!((1 << t_ix) & gi_ptr->ctr_mask))
+ continue;
+
+ n_counts = fi_ptr->n_ctrs[c_ix];
+ merge = gi_ptr->counts[c_ix].merge;
- tag = gcov_read_unsigned ();
- length = gcov_read_unsigned ();
- if (tag != GCOV_TAG_FOR_COUNTER (t_ix)
- || length != GCOV_TAG_COUNTER_LENGTH (n_counts))
- goto read_mismatch;
- (*merge) (values[c_ix], n_counts);
- values[c_ix] += n_counts;
- c_ix++;
+ tag = gcov_read_unsigned ();
+ length = gcov_read_unsigned ();
+ if (tag != GCOV_TAG_FOR_COUNTER (t_ix)
+ || length != GCOV_TAG_COUNTER_LENGTH (n_counts))
+ goto read_mismatch;
+ (*merge) (values[c_ix], n_counts);
+ values[c_ix] += n_counts;
+ c_ix++;
}
if ((error = gcov_is_error ()))
goto read_error;
}
+ f_ix = ~0u;
/* Check program & object summary */
while (1)
{
- gcov_position_t base = gcov_position ();
int is_program;
+ eof_pos = gcov_position ();
tag = gcov_read_unsigned ();
if (!tag)
break;
+
length = gcov_read_unsigned ();
is_program = tag == GCOV_TAG_PROGRAM_SUMMARY;
if (length != GCOV_TAG_SUMMARY_LENGTH
goto read_error;
if (is_program && program.checksum == gcov_crc32)
{
- summary_pos = base;
+ summary_pos = eof_pos;
goto rewrite;
}
}
- if (!gcov_is_eof ())
- {
- read_error:;
- fprintf (stderr, error < 0 ? "profiling:%s:Overflow merging\n"
- : "profiling:%s:Error merging\n", gi_ptr->filename);
- goto read_fatal;
- }
- rewrite:;
- gcov_rewrite ();
}
- else
- memset (&object, 0, sizeof (object));
+ goto rewrite;
+
+ read_error:;
+ fprintf (stderr, error < 0 ? "profiling:%s:Overflow merging\n"
+ : "profiling:%s:Error merging\n", gi_ptr->filename);
+
+ read_fatal:;
+ gcov_close ();
+ continue;
+
+ rewrite:;
+ gcov_rewrite ();
if (!summary_pos)
memset (&program, 0, sizeof (program));
/* Merge the summaries. */
f_ix = ~0u;
- for (t_ix = c_ix = 0,
- cs_obj = object.ctrs, cs_tobj = this_object.ctrs,
- cs_prg = program.ctrs, cs_tprg = this_program.ctrs,
- cs_all = all.ctrs;
- t_ix != GCOV_COUNTERS_SUMMABLE;
- t_ix++, cs_obj++, cs_tobj++, cs_prg++, cs_tprg++, cs_all++)
+ for (t_ix = 0; t_ix < GCOV_COUNTERS_SUMMABLE; t_ix++)
{
+ cs_obj = &object.ctrs[t_ix];
+ cs_tobj = &this_object.ctrs[t_ix];
+ cs_prg = &program.ctrs[t_ix];
+ cs_tprg = &this_program.ctrs[t_ix];
+ cs_all = &all.ctrs[t_ix];
+
if ((1 << t_ix) & gi_ptr->ctr_mask)
{
if (!cs_obj->runs++)
if (cs_prg->run_max < cs_tprg->run_max)
cs_prg->run_max = cs_tprg->run_max;
cs_prg->sum_max += cs_tprg->run_max;
-
- values[c_ix] = gi_ptr->counts[c_ix].values;
- c_ix++;
}
else if (cs_obj->num || cs_prg->num)
goto read_mismatch;
}
}
+ c_ix = 0;
+ for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++)
+ if ((1 << t_ix) & gi_ptr->ctr_mask)
+ {
+ values[c_ix] = gi_ptr->counts[c_ix].values;
+ c_ix++;
+ }
+
program.checksum = gcov_crc32;
/* Write out the data. */
gcov_write_tag_length (GCOV_DATA_MAGIC, GCOV_VERSION);
+ gcov_write_unsigned (gi_ptr->stamp);
/* Write execution counts for each function. */
- for (f_ix = gi_ptr->n_functions, fi_ptr = gi_ptr->functions; f_ix--;
- fi_ptr = (const struct gcov_fn_info *)
- ((const char *) fi_ptr + fi_stride))
+ for (f_ix = 0; f_ix < gi_ptr->n_functions; f_ix++)
{
+ fi_ptr = (const struct gcov_fn_info *)
+ ((const char *) gi_ptr->functions + f_ix * fi_stride);
+
/* Announce function. */
gcov_write_tag_length (GCOV_TAG_FUNCTION, GCOV_TAG_FUNCTION_LENGTH);
gcov_write_unsigned (fi_ptr->ident);
gcov_write_unsigned (fi_ptr->checksum);
- for (c_ix = t_ix = 0; t_ix != GCOV_COUNTERS; t_ix++)
- if ((1 << t_ix) & gi_ptr->ctr_mask)
- {
- unsigned n_counts = fi_ptr->n_ctrs[c_ix];
- gcov_type *c_ptr;
+ c_ix = 0;
+ for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++)
+ {
+ gcov_type *c_ptr;
+
+ if (!((1 << t_ix) & gi_ptr->ctr_mask))
+ continue;
+
+ n_counts = fi_ptr->n_ctrs[c_ix];
- gcov_write_tag_length (GCOV_TAG_FOR_COUNTER (t_ix),
- GCOV_TAG_COUNTER_LENGTH (n_counts));
- c_ptr = values[c_ix];
- while (n_counts--)
- gcov_write_counter (*c_ptr++);
- values[c_ix] = c_ptr;
- c_ix++;
- }
+ gcov_write_tag_length (GCOV_TAG_FOR_COUNTER (t_ix),
+ GCOV_TAG_COUNTER_LENGTH (n_counts));
+ c_ptr = values[c_ix];
+ while (n_counts--)
+ gcov_write_counter (*c_ptr++);
+
+ values[c_ix] = c_ptr;
+ c_ix++;
+ }
}
/* Object file summary. */
gcov_write_summary (GCOV_TAG_OBJECT_SUMMARY, &object);
/* Generate whole program statistics. */
- gcov_seek (summary_pos);
+ if (eof_pos)
+ gcov_seek (eof_pos);
gcov_write_summary (GCOV_TAG_PROGRAM_SUMMARY, &program);
+ if (!summary_pos)
+ gcov_write_unsigned (0);
if ((error = gcov_close ()))
fprintf (stderr, error < 0 ?
"profiling:%s:Overflow writing\n" :
{
if (!info->version)
return;
- if (info->version != GCOV_VERSION)
- gcov_version_mismatch (info, info->version);
- else
+ if (gcov_version (info, info->version))
{
const char *ptr = info->filename;
gcov_unsigned_t crc32 = gcov_crc32;
}
#endif /* L_gcov_merge_add */
+#ifdef L_gcov_merge_single
+/* The profile merging function for choosing the most common value.
+ It is given an array COUNTERS of N_COUNTERS old counters and it
+ reads the same number of counters from the gcov file. The counters
+ are split into 3-tuples where the members of the tuple have
+ meanings:
+
+ -- the stored candidate on the most common value of the measured entity
+ -- counter
+ -- total number of evaluations of the value */
+void
+__gcov_merge_single (gcov_type *counters, unsigned n_counters)
+{
+ unsigned i, n_measures;
+ gcov_type value, counter, all;
+
+ GCOV_CHECK (!(n_counters % 3));
+ n_measures = n_counters / 3;
+ for (i = 0; i < n_measures; i++, counters += 3)
+ {
+ value = gcov_read_counter ();
+ counter = gcov_read_counter ();
+ all = gcov_read_counter ();
+
+ if (counters[0] == value)
+ counters[1] += counter;
+ else if (counter > counters[1])
+ {
+ counters[0] = value;
+ counters[1] = counter - counters[1];
+ }
+ else
+ counters[1] -= counter;
+ counters[2] += all;
+ }
+}
+#endif /* L_gcov_merge_single */
+
+#ifdef L_gcov_merge_delta
+/* The profile merging function for choosing the most common
+ difference between two consecutive evaluations of the value. It is
+ given an array COUNTERS of N_COUNTERS old counters and it reads the
+ same number of counters from the gcov file. The counters are split
+ into 4-tuples where the members of the tuple have meanings:
+
+ -- the last value of the measured entity
+ -- the stored candidate on the most common difference
+ -- counter
+ -- total number of evaluations of the value */
+void
+__gcov_merge_delta (gcov_type *counters, unsigned n_counters)
+{
+ unsigned i, n_measures;
+ gcov_type last, value, counter, all;
+
+ GCOV_CHECK (!(n_counters % 4));
+ n_measures = n_counters / 4;
+ for (i = 0; i < n_measures; i++, counters += 4)
+ {
+ last = gcov_read_counter ();
+ value = gcov_read_counter ();
+ counter = gcov_read_counter ();
+ all = gcov_read_counter ();
+
+ if (counters[1] == value)
+ counters[2] += counter;
+ else if (counter > counters[2])
+ {
+ counters[1] = value;
+ counters[2] = counter - counters[2];
+ }
+ else
+ counters[2] -= counter;
+ counters[3] += all;
+ }
+}
+#endif /* L_gcov_merge_delta */
+
+#ifdef L_gcov_fork
+/* A wrapper for the fork function. Flushes the accumulated profiling data, so
+ that they are not counted twice. */
+
+pid_t
+__gcov_fork (void)
+{
+ __gcov_flush ();
+ return fork ();
+}
+#endif
+
+#ifdef L_gcov_execl
+/* A wrapper for the execl function. Flushes the accumulated profiling data, so
+ that they are not lost. */
+
+int
+__gcov_execl (const char *path, const char *arg, ...)
+{
+ va_list ap, aq;
+ unsigned i, length;
+ char **args;
+
+ __gcov_flush ();
+
+ va_start (ap, arg);
+ va_copy (aq, ap);
+
+ length = 2;
+ while (va_arg (ap, char *))
+ length++;
+ va_end (ap);
+
+ args = alloca (length * sizeof (void *));
+ args[0] = (char *) arg;
+ for (i = 1; i < length; i++)
+ args[i] = va_arg (aq, char *);
+ va_end (aq);
+
+ return execv (path, args);
+}
+#endif
+
+#ifdef L_gcov_execlp
+/* A wrapper for the execlp function. Flushes the accumulated profiling data, so
+ that they are not lost. */
+
+int
+__gcov_execlp (const char *path, const char *arg, ...)
+{
+ va_list ap, aq;
+ unsigned i, length;
+ char **args;
+
+ __gcov_flush ();
+
+ va_start (ap, arg);
+ va_copy (aq, ap);
+
+ length = 2;
+ while (va_arg (ap, char *))
+ length++;
+ va_end (ap);
+
+ args = alloca (length * sizeof (void *));
+ args[0] = (char *) arg;
+ for (i = 1; i < length; i++)
+ args[i] = va_arg (aq, char *);
+ va_end (aq);
+
+ return execvp (path, args);
+}
+#endif
+
+#ifdef L_gcov_execle
+/* A wrapper for the execle function. Flushes the accumulated profiling data, so
+ that they are not lost. */
+
+int
+__gcov_execle (const char *path, const char *arg, ...)
+{
+ va_list ap, aq;
+ unsigned i, length;
+ char **args;
+ char **envp;
+
+ __gcov_flush ();
+
+ va_start (ap, arg);
+ va_copy (aq, ap);
+
+ length = 2;
+ while (va_arg (ap, char *))
+ length++;
+ va_end (ap);
+
+ args = alloca (length * sizeof (void *));
+ args[0] = (char *) arg;
+ for (i = 1; i < length; i++)
+ args[i] = va_arg (aq, char *);
+ envp = va_arg (aq, char **);
+ va_end (aq);
+
+ return execve (path, args, envp);
+}
+#endif
+
+#ifdef L_gcov_execv
+/* A wrapper for the execv function. Flushes the accumulated profiling data, so
+ that they are not lost. */
+
+int
+__gcov_execv (const char *path, char *const argv[])
+{
+ __gcov_flush ();
+ return execv (path, argv);
+}
+#endif
+
+#ifdef L_gcov_execvp
+/* A wrapper for the execvp function. Flushes the accumulated profiling data, so
+ that they are not lost. */
+
+int
+__gcov_execvp (const char *path, char *const argv[])
+{
+ __gcov_flush ();
+ return execvp (path, argv);
+}
+#endif
+
+#ifdef L_gcov_execve
+/* A wrapper for the execve function. Flushes the accumulated profiling data, so
+ that they are not lost. */
+
+int
+__gcov_execve (const char *path, char *const argv[], char *const envp[])
+{
+ __gcov_flush ();
+ return execve (path, argv, envp);
+}
+#endif
#endif /* inhibit_libc */
OSDN Git Service
