X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Flibgcov.c;h=49cf3c7004ceb86348ff104d6c13041293dfbcc6;hb=b7837065e4ec51e8a0ed5fdb0303f2273d3a5d92;hp=826617f14b4260b05da68659cb1cacd82bcd3cd7;hpb=b4d48d675e7a3d7a30834741f83259da59c7cf82;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/libgcov.c b/gcc/libgcov.c index 826617f14b4..49cf3c7004c 100644 --- a/gcc/libgcov.c +++ b/gcc/libgcov.c @@ -1,7 +1,7 @@ /* 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. @@ -79,6 +79,7 @@ void __gcov_merge_delta (gcov_type *counters __attribute__ ((unused)), #if GCOV_LOCKED #include #include +#include #endif #ifdef L_gcov @@ -94,13 +95,16 @@ static gcov_unsigned_t gcov_crc32; static int gcov_version (struct gcov_info *ptr, gcov_unsigned_t version) { - gcov_unsigned_t expected = GCOV_VERSION; - if (version != GCOV_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, (const char *)&expected, (const char *)&version); + ptr->filename, e, v); return 0; } return 1; @@ -119,32 +123,32 @@ gcov_exit (void) 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. */ @@ -155,36 +159,41 @@ gcov_exit (void) 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; gcov_unsigned_t tag, length; gcov_position_t summary_pos = 0; + gcov_position_t eof_pos = 0; memset (&this_object, 0, sizeof (this_object)); memset (&object, 0, sizeof (object)); /* Totals for this object file. */ - 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++) + 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 @@ -210,9 +219,7 @@ gcov_exit (void) { fprintf (stderr, "profiling:%s:Not a gcov data file\n", gi_ptr->filename); - read_fatal:; - gcov_close (); - continue; + goto read_fatal; } length = gcov_read_unsigned (); if (!gcov_version (gi_ptr, length)) @@ -220,19 +227,14 @@ gcov_exit (void) length = gcov_read_unsigned (); if (length != gi_ptr->stamp) - { - /* Read from a different compilation. Overwrite the - file. */ - gcov_truncate (); - goto rewrite; - } + /* 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 (); @@ -249,34 +251,41 @@ gcov_exit (void) 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 @@ -287,19 +296,21 @@ gcov_exit (void) goto read_error; if (is_program && program.checksum == gcov_crc32) { - summary_pos = base; + summary_pos = eof_pos; goto rewrite; } } } + 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; - } + 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) @@ -307,13 +318,14 @@ gcov_exit (void) /* 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++) @@ -333,9 +345,6 @@ gcov_exit (void) 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; @@ -353,6 +362,14 @@ gcov_exit (void) } } + 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. */ @@ -360,37 +377,46 @@ gcov_exit (void) 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" : @@ -478,10 +504,12 @@ __gcov_merge_add (gcov_type *counters, unsigned n_counters) #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 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 */ @@ -491,9 +519,7 @@ __gcov_merge_single (gcov_type *counters, unsigned n_counters) unsigned i, n_measures; gcov_type value, counter, all; - if (n_counters % 3) - abort (); - + GCOV_CHECK (!(n_counters % 3)); n_measures = n_counters / 3; for (i = 0; i < n_measures; i++, counters += 3) { @@ -516,11 +542,12 @@ __gcov_merge_single (gcov_type *counters, unsigned n_counters) #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 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 @@ -531,9 +558,7 @@ __gcov_merge_delta (gcov_type *counters, unsigned n_counters) unsigned i, n_measures; gcov_type last, value, counter, all; - if (n_counters % 4) - abort (); - + GCOV_CHECK (!(n_counters % 4)); n_measures = n_counters / 4; for (i = 0; i < n_measures; i++, counters += 4) { @@ -556,4 +581,146 @@ __gcov_merge_delta (gcov_type *counters, unsigned n_counters) } #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 */