X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Flibgcov.c;h=850680612835dca799aed6e4bd104635eb324a5e;hb=11a8ca07364cc782101c13138a71707359bc229b;hp=37d3e800c1a08f2632cdc7c9c097ac494b55afec;hpb=9219dd0a97690c85202ee9f576b49b58b9659bcf;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/libgcov.c b/gcc/libgcov.c index 37d3e800c1a..85068061283 100644 --- a/gcc/libgcov.c +++ b/gcc/libgcov.c @@ -29,17 +29,6 @@ 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. */ -#if defined(inhibit_libc) -/* If libc and its header files are not available, provide dummy functions. */ - -void __gcov_init (void *p); -void __gcov_flush (void); - -void __gcov_init (void *p) { } -void __gcov_flush (void) { } - -#else - /* It is incorrect to include config.h here, because this file is being compiled for the target, and hence definitions concerning only the host do not apply. */ @@ -49,40 +38,75 @@ void __gcov_flush (void) { } #include "coretypes.h" #include "tm.h" +#if defined(inhibit_libc) +#define IN_LIBGCOV (-1) +#else #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */ #include +#define IN_LIBGCOV 1 +#if defined(L_gcov) +#define GCOV_LINKAGE /* nothing */ +#endif +#endif +#include "gcov-io.h" + +#if defined(inhibit_libc) +/* If libc and its header files are not available, provide dummy functions. */ + +#ifdef L_gcov +void __gcov_init (struct gcov_info *p __attribute__ ((unused))) {} +void __gcov_flush (void) {} +#endif + +#ifdef L_gcov_merge_add +void __gcov_merge_add (gcov_type *counters __attribute__ ((unused)), + 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 -#if defined (TARGET_HAS_F_SETLKW) +#if GCOV_LOCKED #include #include #endif -#define IN_LIBGCOV 1 -#include "gcov-io.h" + +#ifdef L_gcov +#include "gcov-io.c" /* Chain of per-object gcov structures. */ static struct gcov_info *gcov_list; /* A program checksum allows us to distinguish program data for an object file included in multiple programs. */ -static unsigned gcov_crc32; +static gcov_unsigned_t gcov_crc32; -static void -gcov_version_mismatch (struct gcov_info *ptr, unsigned version) +static int +gcov_version (struct gcov_info *ptr, gcov_unsigned_t version) { - unsigned 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 @@ -95,344 +119,308 @@ gcov_version_mismatch (struct gcov_info *ptr, unsigned version) static void gcov_exit (void) { - struct gcov_info *ptr; - unsigned ix, jx; - struct gcov_summary program; - gcov_type program_max_one = 0; - gcov_type program_max_sum = 0; - gcov_type program_sum = 0; - unsigned program_arcs = 0; - - memset (&program, 0, sizeof (program)); - program.checksum = gcov_crc32; - - for (ptr = gcov_list; ptr; ptr = ptr->next) + 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) { - struct gcov_summary object; - struct gcov_summary local_prg; - int merging; - long base; - const struct function_info *fn_info; - gcov_type **counters; - gcov_type *count_ptr; - gcov_type object_max_one = 0; - gcov_type count; - unsigned tag, length, flength, checksum; - unsigned arc_data_index, f_sect_index, sect_index; - - ptr->wkspc = 0; - if (!ptr->filename) - continue; - - counters = malloc (sizeof (gcov_type *) * ptr->n_counter_sections); - for (ix = 0; ix < ptr->n_counter_sections; ix++) - counters[ix] = ptr->counter_sections[ix].counters; - - for (arc_data_index = 0; - arc_data_index < ptr->n_counter_sections - && ptr->counter_sections[arc_data_index].tag != GCOV_TAG_ARC_COUNTS; - arc_data_index++) - continue; - - if (arc_data_index == ptr->n_counter_sections) - { - /* For now; later we may want to just measure other profiles, - but now I am lazy to check for all consequences. */ - abort (); - } - for (ix = ptr->counter_sections[arc_data_index].n_counters, - count_ptr = ptr->counter_sections[arc_data_index].counters; ix--;) + ci_ptr = gi_ptr->counts; + for (t_ix = 0; t_ix < GCOV_COUNTERS_SUMMABLE; t_ix++) { - gcov_type count = *count_ptr++; + if (!((1 << t_ix) & gi_ptr->ctr_mask)) + continue; - if (count > object_max_one) - object_max_one = count; + 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++; } - if (object_max_one > program_max_one) - program_max_one = object_max_one; - - memset (&local_prg, 0, sizeof (local_prg)); + } + + /* Now merge each file. */ + for (gi_ptr = gcov_list; gi_ptr; gi_ptr = gi_ptr->next) + { + struct gcov_summary this_object; + struct gcov_summary object, program; + gcov_type *values[GCOV_COUNTERS]; + const struct gcov_fn_info *fi_ptr; + unsigned fi_stride; + 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; + + memset (&this_object, 0, sizeof (this_object)); memset (&object, 0, sizeof (object)); - /* Open for modification */ - merging = gcov_open (ptr->filename, 0); + /* 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_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++; + } + + 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++; + } + + /* Calculate the function_info stride. This depends on the + number of counter types being measured. */ + fi_stride = sizeof (struct gcov_fn_info) + c_ix * sizeof (unsigned); + if (__alignof__ (struct gcov_fn_info) > sizeof (unsigned)) + { + fi_stride += __alignof__ (struct gcov_fn_info) - 1; + fi_stride &= ~(__alignof__ (struct gcov_fn_info) - 1); + } - if (!merging) + if (!gcov_open (gi_ptr->filename)) { - fprintf (stderr, "profiling:%s:Cannot open\n", ptr->filename); - ptr->filename = 0; + 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 (&tag) || tag != GCOV_DATA_MAGIC) + if (tag != GCOV_DATA_MAGIC) { fprintf (stderr, "profiling:%s:Not a gcov data file\n", - ptr->filename); + gi_ptr->filename); read_fatal:; gcov_close (); - ptr->filename = 0; continue; } - if (gcov_read_unsigned (&length) || length != GCOV_VERSION) + length = gcov_read_unsigned (); + if (!gcov_version (gi_ptr, length)) + goto read_fatal; + + length = gcov_read_unsigned (); + if (length != gi_ptr->stamp) { - gcov_version_mismatch (ptr, length); - goto read_fatal; + /* Read from a different compilation. Overwrite the + file. */ + gcov_truncate (); + goto rewrite; } /* Merge execution counts for each function. */ - for (ix = ptr->n_functions, fn_info = ptr->functions; - ix--; fn_info++) + for (f_ix = 0; f_ix < gi_ptr->n_functions; f_ix++) { - if (gcov_read_unsigned (&tag) || gcov_read_unsigned (&length)) - { - read_error:; - fprintf (stderr, "profiling:%s:Error merging\n", - ptr->filename); - goto read_fatal; - } - - /* Check function */ - if (tag != GCOV_TAG_FUNCTION) + 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. */ + if (tag != GCOV_TAG_FUNCTION + || length != GCOV_TAG_FUNCTION_LENGTH + || gcov_read_unsigned () != fi_ptr->ident + || gcov_read_unsigned () != fi_ptr->checksum) { read_mismatch:; - fprintf (stderr, "profiling:%s:Merge mismatch at %s\n", - ptr->filename, fn_info->name); + fprintf (stderr, "profiling:%s:Merge mismatch for %s\n", + gi_ptr->filename, + f_ix + 1 ? "function" : "summaries"); goto read_fatal; } - if (gcov_read_unsigned (&flength) - || gcov_skip_string (flength) - || gcov_read_unsigned (&checksum)) - goto read_error; - if (flength != strlen (fn_info->name) - || checksum != fn_info->checksum) - goto read_mismatch; - - /* Counters. */ - for (f_sect_index = 0; - f_sect_index < fn_info->n_counter_sections; - f_sect_index++) + c_ix = 0; + for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++) { - unsigned n_counters; - - if (gcov_read_unsigned (&tag) - || gcov_read_unsigned (&length)) - goto read_error; - for (sect_index = 0; - sect_index < ptr->n_counter_sections; - sect_index++) - if (ptr->counter_sections[sect_index].tag == tag) - break; - if (sect_index == ptr->n_counter_sections - || fn_info->counter_sections[f_sect_index].tag != tag) - goto read_mismatch; - - n_counters = fn_info->counter_sections[f_sect_index].n_counters; - if (n_counters != length / 8) + 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; - - for (jx = 0; jx < n_counters; jx++) - if (gcov_read_counter (&count)) - goto read_error; - else - counters[sect_index][jx] += count; - counters[sect_index] += n_counters; + (*merge) (values[c_ix], n_counts); + values[c_ix] += n_counts; + c_ix++; } + if ((error = gcov_is_error ())) + goto read_error; } - /* Check object summary */ - if (gcov_read_unsigned (&tag) || gcov_read_unsigned (&length)) - goto read_error; - if (tag != GCOV_TAG_OBJECT_SUMMARY) - goto read_mismatch; - if (gcov_read_summary (&object)) - goto read_error; - - /* Check program summary */ + f_ix = ~0u; + /* Check program & object summary */ while (1) { - long base = gcov_save_position (); + gcov_position_t base = gcov_position (); + int is_program; - if (gcov_read_unsigned (&tag) - || gcov_read_unsigned (&length)) - { - if (gcov_eof ()) - break; - goto read_error; - } - if (tag != GCOV_TAG_PROGRAM_SUMMARY - && tag != GCOV_TAG_PLACEHOLDER_SUMMARY - && tag != GCOV_TAG_INCORRECT_SUMMARY) + tag = gcov_read_unsigned (); + if (!tag) + break; + length = gcov_read_unsigned (); + is_program = tag == GCOV_TAG_PROGRAM_SUMMARY; + if (length != GCOV_TAG_SUMMARY_LENGTH + || (!is_program && tag != GCOV_TAG_OBJECT_SUMMARY)) goto read_mismatch; - if (gcov_read_summary (&local_prg)) + gcov_read_summary (is_program ? &program : &object); + if ((error = gcov_is_error ())) goto read_error; - if (local_prg.checksum != program.checksum) - continue; - if (tag == GCOV_TAG_PLACEHOLDER_SUMMARY) + if (is_program && program.checksum == gcov_crc32) { - fprintf (stderr, - "profiling:%s:Concurrent race detected\n", - ptr->filename); - goto read_fatal; + summary_pos = base; + goto rewrite; } - merging = 0; - if (tag != GCOV_TAG_PROGRAM_SUMMARY) - break; + } + } + + 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 (); + if (!summary_pos) + memset (&program, 0, sizeof (program)); + + /* Merge the summaries. */ + f_ix = ~0u; + 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 = &program.ctrs[t_ix]; + cs_all = &all.ctrs[t_ix]; + + if ((1 << t_ix) & gi_ptr->ctr_mask) + { + if (!cs_obj->runs++) + cs_obj->num = cs_tobj->num; + else if (cs_obj->num != cs_tobj->num) + goto read_mismatch; + cs_obj->sum_all += cs_tobj->sum_all; + if (cs_obj->run_max < cs_tobj->run_max) + cs_obj->run_max = cs_tobj->run_max; + cs_obj->sum_max += cs_tobj->run_max; - if (program.runs - && memcmp (&program, &local_prg, sizeof (program))) - { - fprintf (stderr, "profiling:%s:Invocation mismatch\n", - ptr->filename); - local_prg.runs = 0; - } - else - memcpy (&program, &local_prg, sizeof (program)); - ptr->wkspc = base; - break; + if (!cs_prg->runs++) + cs_prg->num = cs_tprg->num; + else if (cs_prg->num != cs_tprg->num) + goto read_mismatch; + cs_prg->sum_all += cs_tprg->sum_all; + 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; + } + else if (cs_obj->num || cs_prg->num) + goto read_mismatch; + + if (!cs_all->runs && cs_prg->runs) + memcpy (cs_all, cs_prg, sizeof (*cs_all)); + else if (!all.checksum + && (!GCOV_LOCKED || cs_all->runs == cs_prg->runs) + && memcmp (cs_all, cs_prg, sizeof (*cs_all))) + { + fprintf (stderr, "profiling:%s:Invocation mismatch - some data files may have been removed%s", + gi_ptr->filename, GCOV_LOCKED + ? "" : " or concurrent update without locking support"); + all.checksum = ~0u; } - gcov_resync (0, 0); } + + 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++; + } - object.runs++; - object.arcs = ptr->counter_sections[arc_data_index].n_counters; - object.arc_sum = 0; - if (object.arc_max_one < object_max_one) - object.arc_max_one = object_max_one; - object.arc_sum_max += object_max_one; + program.checksum = gcov_crc32; /* Write out the data. */ - if (/* magic */ - gcov_write_unsigned (GCOV_DATA_MAGIC) - /* version number */ - || gcov_write_unsigned (GCOV_VERSION)) - { - write_error:; - gcov_close (); - fprintf (stderr, "profiling:%s:Error writing\n", ptr->filename); - ptr->filename = 0; - continue; - } + gcov_write_tag_length (GCOV_DATA_MAGIC, GCOV_VERSION); + gcov_write_unsigned (gi_ptr->stamp); /* Write execution counts for each function. */ - for (ix = 0; ix < ptr->n_counter_sections; ix++) - counters[ix] = ptr->counter_sections[ix].counters; - for (ix = ptr->n_functions, fn_info = ptr->functions; ix--; fn_info++) + 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. */ - if (gcov_write_unsigned (GCOV_TAG_FUNCTION) - || !(base = gcov_reserve_length ()) - /* function name */ - || gcov_write_string (fn_info->name) - /* function checksum */ - || gcov_write_unsigned (fn_info->checksum) - || gcov_write_length (base)) - goto write_error; - - /* counters. */ - for (f_sect_index = 0; - f_sect_index < fn_info->n_counter_sections; - f_sect_index++) + gcov_write_tag_length (GCOV_TAG_FUNCTION, GCOV_TAG_FUNCTION_LENGTH); + gcov_write_unsigned (fi_ptr->ident); + gcov_write_unsigned (fi_ptr->checksum); + + c_ix = 0; + for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++) { - tag = fn_info->counter_sections[f_sect_index].tag; - for (sect_index = 0; - sect_index < ptr->n_counter_sections; - sect_index++) - if (ptr->counter_sections[sect_index].tag == tag) - break; - if (sect_index == ptr->n_counter_sections) - abort (); - - if (gcov_write_unsigned (tag) - || !(base = gcov_reserve_length ())) - goto write_error; - - for (jx = fn_info->counter_sections[f_sect_index].n_counters; jx--;) - { - gcov_type count = *counters[sect_index]++; - - if (tag == GCOV_TAG_ARC_COUNTS) - { - object.arc_sum += count; - if (object.arc_max_sum < count) - object.arc_max_sum = count; - } - if (gcov_write_counter (count)) - goto write_error; /* RIP Edsger Dijkstra */ - } - if (gcov_write_length (base)) - goto write_error; - } - } + gcov_type *c_ptr; - /* Object file summary. */ - if (gcov_write_summary (GCOV_TAG_OBJECT_SUMMARY, &object)) - goto write_error; + if (!((1 << t_ix) & gi_ptr->ctr_mask)) + continue; - if (merging) - { - ptr->wkspc = gcov_seek_end (); - if (gcov_write_summary (GCOV_TAG_PLACEHOLDER_SUMMARY, - &program)) - goto write_error; - } - else if (ptr->wkspc) - { - /* Zap trailing program summary */ - if (gcov_resync (ptr->wkspc, 0)) - goto write_error; - if (!local_prg.runs) - ptr->wkspc = 0; - if (gcov_write_unsigned (local_prg.runs - ? GCOV_TAG_PLACEHOLDER_SUMMARY - : GCOV_TAG_INCORRECT_SUMMARY)) - goto write_error; - } + 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++); - if (gcov_close ()) - { - fprintf (stderr, "profiling:%s:Error closing\n", ptr->filename); - ptr->filename = 0; - } - else - { - program_arcs += ptr->counter_sections[arc_data_index].n_counters; - program_sum += object.arc_sum; - if (program_max_sum < object.arc_max_sum) - program_max_sum = object.arc_max_sum; + values[c_ix] = c_ptr; + c_ix++; + } } - free(counters); - } - /* Generate whole program statistics. */ - program.runs++; - program.arcs = program_arcs; - program.arc_sum = program_sum; - if (program.arc_max_one < program_max_one) - program.arc_max_one = program_max_one; - if (program.arc_max_sum < program_max_sum) - program.arc_max_sum = program_max_sum; - program.arc_sum_max += program_max_one; - - /* Upate whole program statistics. */ - for (ptr = gcov_list; ptr; ptr = ptr->next) - if (ptr->filename && ptr->wkspc) - { - if (!gcov_open (ptr->filename, 1)) - { - fprintf (stderr, "profiling:%s:Cannot open\n", ptr->filename); - continue; - } - - if (gcov_resync (ptr->wkspc, 0) - || gcov_write_summary (GCOV_TAG_PROGRAM_SUMMARY, &program)) - fprintf (stderr, "profiling:%s:Error writing\n", ptr->filename); - if (gcov_close ()) - fprintf (stderr, "profiling:%s:Error closing\n", ptr->filename); - } + /* Object file summary. */ + gcov_write_summary (GCOV_TAG_OBJECT_SUMMARY, &object); + + /* Generate whole program statistics. */ + gcov_seek (summary_pos); + gcov_write_summary (GCOV_TAG_PROGRAM_SUMMARY, &program); + if ((error = gcov_close ())) + fprintf (stderr, error < 0 ? + "profiling:%s:Overflow writing\n" : + "profiling:%s:Error writing\n", + gi_ptr->filename); + } } /* Add a new object file onto the bb chain. Invoked automatically @@ -443,21 +431,19 @@ __gcov_init (struct gcov_info *info) { 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; - unsigned crc32 = gcov_crc32; + gcov_unsigned_t crc32 = gcov_crc32; do { unsigned ix; - unsigned value = *ptr << 24; + gcov_unsigned_t value = *ptr << 24; for (ix = 8; ix--; value <<= 1) { - unsigned feedback; + gcov_unsigned_t feedback; feedback = (value ^ crc32) & 0x80000000 ? 0x04c11db7 : 0; crc32 <<= 1; @@ -484,17 +470,113 @@ __gcov_init (struct gcov_info *info) void __gcov_flush (void) { - struct gcov_info *ptr; + const struct gcov_info *gi_ptr; gcov_exit (); - for (ptr = gcov_list; ptr; ptr = ptr->next) + for (gi_ptr = gcov_list; gi_ptr; gi_ptr = gi_ptr->next) { - unsigned i, j; + unsigned t_ix; + const struct gcov_ctr_info *ci_ptr; - for (j = 0; j < ptr->n_counter_sections; j++) - for (i = ptr->counter_sections[j].n_counters; i--;) - ptr->counter_sections[j].counters[i] = 0; + for (t_ix = 0, ci_ptr = gi_ptr->counts; t_ix != GCOV_COUNTERS; t_ix++) + if ((1 << t_ix) & gi_ptr->ctr_mask) + { + memset (ci_ptr->values, 0, sizeof (gcov_type) * ci_ptr->num); + ci_ptr++; + } + } +} + +#endif /* L_gcov */ + +#ifdef L_gcov_merge_add +/* The profile merging function that just adds the counters. It is given + an array COUNTERS of N_COUNTERS old counters and it reads the same number + of counters from the gcov file. */ +void +__gcov_merge_add (gcov_type *counters, unsigned n_counters) +{ + for (; n_counters; counters++, n_counters--) + *counters += gcov_read_counter (); +} +#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 */ #endif /* inhibit_libc */