forked from KolibriOS/kolibrios
913 lines
25 KiB
C
913 lines
25 KiB
C
/* Routines required for instrumenting a program. */
|
|
/* Compile this one with gcc. */
|
|
/* Copyright (C) 1989-2015 Free Software Foundation, Inc.
|
|
|
|
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 3, 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.
|
|
|
|
Under Section 7 of GPL version 3, you are granted additional
|
|
permissions described in the GCC Runtime Library Exception, version
|
|
3.1, as published by the Free Software Foundation.
|
|
|
|
You should have received a copy of the GNU General Public License and
|
|
a copy of the GCC Runtime Library Exception along with this program;
|
|
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#include "libgcov.h"
|
|
|
|
#if defined(inhibit_libc)
|
|
/* If libc and its header files are not available, provide dummy functions. */
|
|
|
|
#if defined(L_gcov)
|
|
void __gcov_init (struct gcov_info *p __attribute__ ((unused))) {}
|
|
#endif
|
|
|
|
#else /* inhibit_libc */
|
|
|
|
#include <string.h>
|
|
#if GCOV_LOCKED
|
|
#include <fcntl.h>
|
|
#include <errno.h>
|
|
#include <sys/stat.h>
|
|
#endif
|
|
|
|
#ifdef L_gcov
|
|
|
|
/* A utility function for outputing errors. */
|
|
static int gcov_error (const char *, ...);
|
|
|
|
#include "gcov-io.c"
|
|
|
|
struct gcov_fn_buffer
|
|
{
|
|
struct gcov_fn_buffer *next;
|
|
unsigned fn_ix;
|
|
struct gcov_fn_info info;
|
|
/* note gcov_fn_info ends in a trailing array. */
|
|
};
|
|
|
|
struct gcov_summary_buffer
|
|
{
|
|
struct gcov_summary_buffer *next;
|
|
struct gcov_summary summary;
|
|
};
|
|
|
|
/* A struct that bundles all the related information about the
|
|
gcda filename. */
|
|
|
|
struct gcov_filename
|
|
{
|
|
char *filename; /* filename buffer */
|
|
size_t max_length; /* maximum filename length */
|
|
int strip; /* leading chars to strip from filename */
|
|
size_t prefix; /* chars to prepend to filename */
|
|
};
|
|
|
|
static struct gcov_fn_buffer *
|
|
free_fn_data (const struct gcov_info *gi_ptr, struct gcov_fn_buffer *buffer,
|
|
unsigned limit)
|
|
{
|
|
struct gcov_fn_buffer *next;
|
|
unsigned ix, n_ctr = 0;
|
|
|
|
if (!buffer)
|
|
return 0;
|
|
next = buffer->next;
|
|
|
|
for (ix = 0; ix != limit; ix++)
|
|
if (gi_ptr->merge[ix])
|
|
free (buffer->info.ctrs[n_ctr++].values);
|
|
free (buffer);
|
|
return next;
|
|
}
|
|
|
|
static struct gcov_fn_buffer **
|
|
buffer_fn_data (const char *filename, const struct gcov_info *gi_ptr,
|
|
struct gcov_fn_buffer **end_ptr, unsigned fn_ix)
|
|
{
|
|
unsigned n_ctrs = 0, ix = 0;
|
|
struct gcov_fn_buffer *fn_buffer;
|
|
unsigned len;
|
|
|
|
for (ix = GCOV_COUNTERS; ix--;)
|
|
if (gi_ptr->merge[ix])
|
|
n_ctrs++;
|
|
|
|
len = sizeof (*fn_buffer) + sizeof (fn_buffer->info.ctrs[0]) * n_ctrs;
|
|
fn_buffer = (struct gcov_fn_buffer *) xmalloc (len);
|
|
|
|
if (!fn_buffer)
|
|
goto fail;
|
|
|
|
fn_buffer->next = 0;
|
|
fn_buffer->fn_ix = fn_ix;
|
|
fn_buffer->info.ident = gcov_read_unsigned ();
|
|
fn_buffer->info.lineno_checksum = gcov_read_unsigned ();
|
|
fn_buffer->info.cfg_checksum = gcov_read_unsigned ();
|
|
|
|
for (n_ctrs = ix = 0; ix != GCOV_COUNTERS; ix++)
|
|
{
|
|
gcov_unsigned_t length;
|
|
gcov_type *values;
|
|
|
|
if (!gi_ptr->merge[ix])
|
|
continue;
|
|
|
|
if (gcov_read_unsigned () != GCOV_TAG_FOR_COUNTER (ix))
|
|
{
|
|
len = 0;
|
|
goto fail;
|
|
}
|
|
|
|
length = GCOV_TAG_COUNTER_NUM (gcov_read_unsigned ());
|
|
len = length * sizeof (gcov_type);
|
|
values = (gcov_type *) xmalloc (len);
|
|
if (!values)
|
|
goto fail;
|
|
|
|
fn_buffer->info.ctrs[n_ctrs].num = length;
|
|
fn_buffer->info.ctrs[n_ctrs].values = values;
|
|
|
|
while (length--)
|
|
*values++ = gcov_read_counter ();
|
|
n_ctrs++;
|
|
}
|
|
|
|
*end_ptr = fn_buffer;
|
|
return &fn_buffer->next;
|
|
|
|
fail:
|
|
gcov_error ("profiling:%s:Function %u %s %u \n", filename, fn_ix,
|
|
len ? "cannot allocate" : "counter mismatch", len ? len : ix);
|
|
|
|
return (struct gcov_fn_buffer **)free_fn_data (gi_ptr, fn_buffer, ix);
|
|
}
|
|
|
|
/* Add an unsigned value to the current crc */
|
|
|
|
static gcov_unsigned_t
|
|
crc32_unsigned (gcov_unsigned_t crc32, gcov_unsigned_t value)
|
|
{
|
|
unsigned ix;
|
|
|
|
for (ix = 32; ix--; value <<= 1)
|
|
{
|
|
unsigned feedback;
|
|
|
|
feedback = (value ^ crc32) & 0x80000000 ? 0x04c11db7 : 0;
|
|
crc32 <<= 1;
|
|
crc32 ^= feedback;
|
|
}
|
|
|
|
return crc32;
|
|
}
|
|
|
|
/* Check if VERSION of the info block PTR matches libgcov one.
|
|
Return 1 on success, or zero in case of versions mismatch.
|
|
If FILENAME is not NULL, its value used for reporting purposes
|
|
instead of value from the info block. */
|
|
|
|
static int
|
|
gcov_version (struct gcov_info *ptr, gcov_unsigned_t version,
|
|
const char *filename)
|
|
{
|
|
if (version != GCOV_VERSION)
|
|
{
|
|
char v[4], e[4];
|
|
|
|
GCOV_UNSIGNED2STRING (v, version);
|
|
GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
|
|
|
|
gcov_error ("profiling:%s:Version mismatch - expected %.4s got %.4s\n",
|
|
filename? filename : ptr->filename, e, v);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/* Insert counter VALUE into HISTOGRAM. */
|
|
|
|
static void
|
|
gcov_histogram_insert(gcov_bucket_type *histogram, gcov_type value)
|
|
{
|
|
unsigned i;
|
|
|
|
i = gcov_histo_index(value);
|
|
histogram[i].num_counters++;
|
|
histogram[i].cum_value += value;
|
|
if (value < histogram[i].min_value)
|
|
histogram[i].min_value = value;
|
|
}
|
|
|
|
/* Computes a histogram of the arc counters to place in the summary SUM. */
|
|
|
|
static void
|
|
gcov_compute_histogram (struct gcov_info *list, struct gcov_summary *sum)
|
|
{
|
|
struct gcov_info *gi_ptr;
|
|
const struct gcov_fn_info *gfi_ptr;
|
|
const struct gcov_ctr_info *ci_ptr;
|
|
struct gcov_ctr_summary *cs_ptr;
|
|
unsigned t_ix, f_ix, ctr_info_ix, ix;
|
|
int h_ix;
|
|
|
|
/* This currently only applies to arc counters. */
|
|
t_ix = GCOV_COUNTER_ARCS;
|
|
|
|
/* First check if there are any counts recorded for this counter. */
|
|
cs_ptr = &(sum->ctrs[t_ix]);
|
|
if (!cs_ptr->num)
|
|
return;
|
|
|
|
for (h_ix = 0; h_ix < GCOV_HISTOGRAM_SIZE; h_ix++)
|
|
{
|
|
cs_ptr->histogram[h_ix].num_counters = 0;
|
|
cs_ptr->histogram[h_ix].min_value = cs_ptr->run_max;
|
|
cs_ptr->histogram[h_ix].cum_value = 0;
|
|
}
|
|
|
|
/* Walk through all the per-object structures and record each of
|
|
the count values in histogram. */
|
|
for (gi_ptr = list; gi_ptr; gi_ptr = gi_ptr->next)
|
|
{
|
|
if (!gi_ptr->merge[t_ix])
|
|
continue;
|
|
|
|
/* Find the appropriate index into the gcov_ctr_info array
|
|
for the counter we are currently working on based on the
|
|
existence of the merge function pointer for this object. */
|
|
for (ix = 0, ctr_info_ix = 0; ix < t_ix; ix++)
|
|
{
|
|
if (gi_ptr->merge[ix])
|
|
ctr_info_ix++;
|
|
}
|
|
for (f_ix = 0; f_ix != gi_ptr->n_functions; f_ix++)
|
|
{
|
|
gfi_ptr = gi_ptr->functions[f_ix];
|
|
|
|
if (!gfi_ptr || gfi_ptr->key != gi_ptr)
|
|
continue;
|
|
|
|
ci_ptr = &gfi_ptr->ctrs[ctr_info_ix];
|
|
for (ix = 0; ix < ci_ptr->num; ix++)
|
|
gcov_histogram_insert (cs_ptr->histogram, ci_ptr->values[ix]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* buffer for the fn_data from another program. */
|
|
static struct gcov_fn_buffer *fn_buffer;
|
|
/* buffer for summary from other programs to be written out. */
|
|
static struct gcov_summary_buffer *sum_buffer;
|
|
|
|
/* This function computes the program level summary and the histo-gram.
|
|
It computes and returns CRC32 and stored summary in THIS_PRG.
|
|
Also determines the longest filename length of the info files. */
|
|
|
|
#if !IN_GCOV_TOOL
|
|
static
|
|
#endif
|
|
gcov_unsigned_t
|
|
compute_summary (struct gcov_info *list, struct gcov_summary *this_prg,
|
|
size_t *max_length)
|
|
{
|
|
struct gcov_info *gi_ptr;
|
|
const struct gcov_fn_info *gfi_ptr;
|
|
struct gcov_ctr_summary *cs_ptr;
|
|
const struct gcov_ctr_info *ci_ptr;
|
|
int f_ix;
|
|
unsigned t_ix;
|
|
gcov_unsigned_t c_num;
|
|
gcov_unsigned_t crc32 = 0;
|
|
|
|
/* Find the totals for this execution. */
|
|
memset (this_prg, 0, sizeof (*this_prg));
|
|
*max_length = 0;
|
|
for (gi_ptr = list; gi_ptr; gi_ptr = gi_ptr->next)
|
|
{
|
|
size_t len = strlen (gi_ptr->filename);
|
|
if (len > *max_length)
|
|
*max_length = len;
|
|
|
|
crc32 = crc32_unsigned (crc32, gi_ptr->stamp);
|
|
crc32 = crc32_unsigned (crc32, gi_ptr->n_functions);
|
|
|
|
for (f_ix = 0; (unsigned)f_ix != gi_ptr->n_functions; f_ix++)
|
|
{
|
|
gfi_ptr = gi_ptr->functions[f_ix];
|
|
|
|
if (gfi_ptr && gfi_ptr->key != gi_ptr)
|
|
gfi_ptr = 0;
|
|
|
|
crc32 = crc32_unsigned (crc32, gfi_ptr ? gfi_ptr->cfg_checksum : 0);
|
|
crc32 = crc32_unsigned (crc32,
|
|
gfi_ptr ? gfi_ptr->lineno_checksum : 0);
|
|
if (!gfi_ptr)
|
|
continue;
|
|
|
|
ci_ptr = gfi_ptr->ctrs;
|
|
for (t_ix = 0; t_ix != GCOV_COUNTERS_SUMMABLE; t_ix++)
|
|
{
|
|
if (!gi_ptr->merge[t_ix])
|
|
continue;
|
|
|
|
cs_ptr = &(this_prg->ctrs[t_ix]);
|
|
cs_ptr->num += ci_ptr->num;
|
|
crc32 = crc32_unsigned (crc32, 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++;
|
|
}
|
|
}
|
|
}
|
|
gcov_compute_histogram (list, this_prg);
|
|
return crc32;
|
|
}
|
|
|
|
/* Including system dependent components. */
|
|
#include "libgcov-driver-system.c"
|
|
|
|
/* This function merges counters in GI_PTR to an existing gcda file.
|
|
Return 0 on success.
|
|
Return -1 on error. In this case, caller will goto read_fatal. */
|
|
|
|
static int
|
|
merge_one_data (const char *filename,
|
|
struct gcov_info *gi_ptr,
|
|
struct gcov_summary *prg_p,
|
|
struct gcov_summary *this_prg,
|
|
gcov_position_t *summary_pos_p,
|
|
gcov_position_t *eof_pos_p,
|
|
gcov_unsigned_t crc32)
|
|
{
|
|
gcov_unsigned_t tag, length;
|
|
unsigned t_ix;
|
|
int f_ix;
|
|
int error = 0;
|
|
struct gcov_fn_buffer **fn_tail = &fn_buffer;
|
|
struct gcov_summary_buffer **sum_tail = &sum_buffer;
|
|
|
|
length = gcov_read_unsigned ();
|
|
if (!gcov_version (gi_ptr, length, filename))
|
|
return -1;
|
|
|
|
length = gcov_read_unsigned ();
|
|
if (length != gi_ptr->stamp)
|
|
/* Read from a different compilation. Overwrite the file. */
|
|
return 0;
|
|
|
|
/* Look for program summary. */
|
|
for (f_ix = 0;;)
|
|
{
|
|
struct gcov_summary tmp;
|
|
|
|
*eof_pos_p = gcov_position ();
|
|
tag = gcov_read_unsigned ();
|
|
if (tag != GCOV_TAG_PROGRAM_SUMMARY)
|
|
break;
|
|
|
|
f_ix--;
|
|
length = gcov_read_unsigned ();
|
|
gcov_read_summary (&tmp);
|
|
if ((error = gcov_is_error ()))
|
|
goto read_error;
|
|
if (*summary_pos_p)
|
|
{
|
|
/* Save all summaries after the one that will be
|
|
merged into below. These will need to be rewritten
|
|
as histogram merging may change the number of non-zero
|
|
histogram entries that will be emitted, and thus the
|
|
size of the merged summary. */
|
|
(*sum_tail) = (struct gcov_summary_buffer *)
|
|
xmalloc (sizeof(struct gcov_summary_buffer));
|
|
(*sum_tail)->summary = tmp;
|
|
(*sum_tail)->next = 0;
|
|
sum_tail = &((*sum_tail)->next);
|
|
goto next_summary;
|
|
}
|
|
if (tmp.checksum != crc32)
|
|
goto next_summary;
|
|
|
|
for (t_ix = 0; t_ix != GCOV_COUNTERS_SUMMABLE; t_ix++)
|
|
if (tmp.ctrs[t_ix].num != this_prg->ctrs[t_ix].num)
|
|
goto next_summary;
|
|
*prg_p = tmp;
|
|
*summary_pos_p = *eof_pos_p;
|
|
|
|
next_summary:;
|
|
}
|
|
|
|
/* Merge execution counts for each function. */
|
|
for (f_ix = 0; (unsigned)f_ix != gi_ptr->n_functions;
|
|
f_ix++, tag = gcov_read_unsigned ())
|
|
{
|
|
const struct gcov_ctr_info *ci_ptr;
|
|
const struct gcov_fn_info *gfi_ptr = gi_ptr->functions[f_ix];
|
|
|
|
if (tag != GCOV_TAG_FUNCTION)
|
|
goto read_mismatch;
|
|
|
|
length = gcov_read_unsigned ();
|
|
if (!length)
|
|
/* This function did not appear in the other program.
|
|
We have nothing to merge. */
|
|
continue;
|
|
|
|
if (length != GCOV_TAG_FUNCTION_LENGTH)
|
|
goto read_mismatch;
|
|
|
|
if (!gfi_ptr || gfi_ptr->key != gi_ptr)
|
|
{
|
|
/* This function appears in the other program. We
|
|
need to buffer the information in order to write
|
|
it back out -- we'll be inserting data before
|
|
this point, so cannot simply keep the data in the
|
|
file. */
|
|
fn_tail = buffer_fn_data (filename, gi_ptr, fn_tail, f_ix);
|
|
if (!fn_tail)
|
|
goto read_mismatch;
|
|
continue;
|
|
}
|
|
|
|
length = gcov_read_unsigned ();
|
|
if (length != gfi_ptr->ident)
|
|
goto read_mismatch;
|
|
|
|
length = gcov_read_unsigned ();
|
|
if (length != gfi_ptr->lineno_checksum)
|
|
goto read_mismatch;
|
|
|
|
length = gcov_read_unsigned ();
|
|
if (length != gfi_ptr->cfg_checksum)
|
|
goto read_mismatch;
|
|
|
|
ci_ptr = gfi_ptr->ctrs;
|
|
for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++)
|
|
{
|
|
gcov_merge_fn merge = gi_ptr->merge[t_ix];
|
|
|
|
if (!merge)
|
|
continue;
|
|
|
|
tag = gcov_read_unsigned ();
|
|
length = gcov_read_unsigned ();
|
|
if (tag != GCOV_TAG_FOR_COUNTER (t_ix)
|
|
|| length != GCOV_TAG_COUNTER_LENGTH (ci_ptr->num))
|
|
goto read_mismatch;
|
|
(*merge) (ci_ptr->values, ci_ptr->num);
|
|
ci_ptr++;
|
|
}
|
|
if ((error = gcov_is_error ()))
|
|
goto read_error;
|
|
}
|
|
|
|
if (tag)
|
|
{
|
|
read_mismatch:;
|
|
gcov_error ("profiling:%s:Merge mismatch for %s %u\n",
|
|
filename, f_ix >= 0 ? "function" : "summary",
|
|
f_ix < 0 ? -1 - f_ix : f_ix);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
|
|
read_error:
|
|
gcov_error ("profiling:%s:%s merging\n", filename,
|
|
error < 0 ? "Overflow": "Error");
|
|
return -1;
|
|
}
|
|
|
|
/* Write counters in GI_PTR and the summary in PRG to a gcda file. In
|
|
the case of appending to an existing file, SUMMARY_POS will be non-zero.
|
|
We will write the file starting from SUMMAY_POS. */
|
|
|
|
static void
|
|
write_one_data (const struct gcov_info *gi_ptr,
|
|
const struct gcov_summary *prg_p,
|
|
const gcov_position_t eof_pos,
|
|
const gcov_position_t summary_pos)
|
|
{
|
|
unsigned f_ix;
|
|
struct gcov_summary_buffer *next_sum_buffer;
|
|
|
|
/* Write out the data. */
|
|
if (!eof_pos)
|
|
{
|
|
gcov_write_tag_length (GCOV_DATA_MAGIC, GCOV_VERSION);
|
|
gcov_write_unsigned (gi_ptr->stamp);
|
|
}
|
|
|
|
if (summary_pos)
|
|
gcov_seek (summary_pos);
|
|
|
|
/* Generate whole program statistics. */
|
|
gcov_write_summary (GCOV_TAG_PROGRAM_SUMMARY, prg_p);
|
|
|
|
/* Rewrite all the summaries that were after the summary we merged
|
|
into. This is necessary as the merged summary may have a different
|
|
size due to the number of non-zero histogram entries changing after
|
|
merging. */
|
|
|
|
while (sum_buffer)
|
|
{
|
|
gcov_write_summary (GCOV_TAG_PROGRAM_SUMMARY, &sum_buffer->summary);
|
|
next_sum_buffer = sum_buffer->next;
|
|
free (sum_buffer);
|
|
sum_buffer = next_sum_buffer;
|
|
}
|
|
|
|
/* Write execution counts for each function. */
|
|
for (f_ix = 0; f_ix != gi_ptr->n_functions; f_ix++)
|
|
{
|
|
unsigned buffered = 0;
|
|
const struct gcov_fn_info *gfi_ptr;
|
|
const struct gcov_ctr_info *ci_ptr;
|
|
gcov_unsigned_t length;
|
|
unsigned t_ix;
|
|
|
|
if (fn_buffer && fn_buffer->fn_ix == f_ix)
|
|
{
|
|
/* Buffered data from another program. */
|
|
buffered = 1;
|
|
gfi_ptr = &fn_buffer->info;
|
|
length = GCOV_TAG_FUNCTION_LENGTH;
|
|
}
|
|
else
|
|
{
|
|
gfi_ptr = gi_ptr->functions[f_ix];
|
|
if (gfi_ptr && gfi_ptr->key == gi_ptr)
|
|
length = GCOV_TAG_FUNCTION_LENGTH;
|
|
else
|
|
length = 0;
|
|
}
|
|
|
|
gcov_write_tag_length (GCOV_TAG_FUNCTION, length);
|
|
if (!length)
|
|
continue;
|
|
|
|
gcov_write_unsigned (gfi_ptr->ident);
|
|
gcov_write_unsigned (gfi_ptr->lineno_checksum);
|
|
gcov_write_unsigned (gfi_ptr->cfg_checksum);
|
|
|
|
ci_ptr = gfi_ptr->ctrs;
|
|
for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++)
|
|
{
|
|
gcov_unsigned_t n_counts;
|
|
gcov_type *c_ptr;
|
|
|
|
if (!gi_ptr->merge[t_ix])
|
|
continue;
|
|
|
|
n_counts = ci_ptr->num;
|
|
gcov_write_tag_length (GCOV_TAG_FOR_COUNTER (t_ix),
|
|
GCOV_TAG_COUNTER_LENGTH (n_counts));
|
|
c_ptr = ci_ptr->values;
|
|
while (n_counts--)
|
|
gcov_write_counter (*c_ptr++);
|
|
ci_ptr++;
|
|
}
|
|
if (buffered)
|
|
fn_buffer = free_fn_data (gi_ptr, fn_buffer, GCOV_COUNTERS);
|
|
}
|
|
|
|
gcov_write_unsigned (0);
|
|
}
|
|
|
|
/* Helper function for merging summary.
|
|
Return -1 on error. Return 0 on success. */
|
|
|
|
static int
|
|
merge_summary (const char *filename, int run_counted,
|
|
const struct gcov_info *gi_ptr, struct gcov_summary *prg,
|
|
struct gcov_summary *this_prg, gcov_unsigned_t crc32,
|
|
struct gcov_summary *all_prg __attribute__ ((unused)))
|
|
{
|
|
struct gcov_ctr_summary *cs_prg, *cs_tprg;
|
|
unsigned t_ix;
|
|
#if !GCOV_LOCKED
|
|
/* summary for all instances of program. */
|
|
struct gcov_ctr_summary *cs_all;
|
|
#endif
|
|
|
|
/* Merge the summaries. */
|
|
for (t_ix = 0; t_ix < GCOV_COUNTERS_SUMMABLE; t_ix++)
|
|
{
|
|
cs_prg = &(prg->ctrs[t_ix]);
|
|
cs_tprg = &(this_prg->ctrs[t_ix]);
|
|
|
|
if (gi_ptr->merge[t_ix])
|
|
{
|
|
int first = !cs_prg->runs;
|
|
|
|
if (!run_counted)
|
|
cs_prg->runs++;
|
|
if (first)
|
|
cs_prg->num = cs_tprg->num;
|
|
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;
|
|
if (first)
|
|
memcpy (cs_prg->histogram, cs_tprg->histogram,
|
|
sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
|
|
else
|
|
gcov_histogram_merge (cs_prg->histogram, cs_tprg->histogram);
|
|
}
|
|
else if (cs_prg->runs)
|
|
{
|
|
gcov_error ("profiling:%s:Merge mismatch for summary.\n",
|
|
filename);
|
|
return -1;
|
|
}
|
|
#if !GCOV_LOCKED
|
|
cs_all = &all_prg->ctrs[t_ix];
|
|
if (!cs_all->runs && cs_prg->runs)
|
|
{
|
|
cs_all->num = cs_prg->num;
|
|
cs_all->runs = cs_prg->runs;
|
|
cs_all->sum_all = cs_prg->sum_all;
|
|
cs_all->run_max = cs_prg->run_max;
|
|
cs_all->sum_max = cs_prg->sum_max;
|
|
}
|
|
else if (!all_prg->checksum
|
|
/* Don't compare the histograms, which may have slight
|
|
variations depending on the order they were updated
|
|
due to the truncating integer divides used in the
|
|
merge. */
|
|
&& (cs_all->num != cs_prg->num
|
|
|| cs_all->runs != cs_prg->runs
|
|
|| cs_all->sum_all != cs_prg->sum_all
|
|
|| cs_all->run_max != cs_prg->run_max
|
|
|| cs_all->sum_max != cs_prg->sum_max))
|
|
{
|
|
gcov_error ("profiling:%s:Data file mismatch - some "
|
|
"data files may have been concurrently "
|
|
"updated without locking support\n", filename);
|
|
all_prg->checksum = ~0u;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
prg->checksum = crc32;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Sort N entries in VALUE_ARRAY in descending order.
|
|
Each entry in VALUE_ARRAY has two values. The sorting
|
|
is based on the second value. */
|
|
|
|
GCOV_LINKAGE void
|
|
gcov_sort_n_vals (gcov_type *value_array, int n)
|
|
{
|
|
int j, k;
|
|
|
|
for (j = 2; j < n; j += 2)
|
|
{
|
|
gcov_type cur_ent[2];
|
|
|
|
cur_ent[0] = value_array[j];
|
|
cur_ent[1] = value_array[j + 1];
|
|
k = j - 2;
|
|
while (k >= 0 && value_array[k + 1] < cur_ent[1])
|
|
{
|
|
value_array[k + 2] = value_array[k];
|
|
value_array[k + 3] = value_array[k+1];
|
|
k -= 2;
|
|
}
|
|
value_array[k + 2] = cur_ent[0];
|
|
value_array[k + 3] = cur_ent[1];
|
|
}
|
|
}
|
|
|
|
/* Sort the profile counters for all indirect call sites. Counters
|
|
for each call site are allocated in array COUNTERS. */
|
|
|
|
static void
|
|
gcov_sort_icall_topn_counter (const struct gcov_ctr_info *counters)
|
|
{
|
|
int i;
|
|
gcov_type *values;
|
|
int n = counters->num;
|
|
|
|
gcc_assert (!(n % GCOV_ICALL_TOPN_NCOUNTS));
|
|
values = counters->values;
|
|
|
|
for (i = 0; i < n; i += GCOV_ICALL_TOPN_NCOUNTS)
|
|
{
|
|
gcov_type *value_array = &values[i + 1];
|
|
gcov_sort_n_vals (value_array, GCOV_ICALL_TOPN_NCOUNTS - 1);
|
|
}
|
|
}
|
|
|
|
/* Sort topn indirect_call profile counters in GI_PTR. */
|
|
|
|
static void
|
|
gcov_sort_topn_counter_arrays (const struct gcov_info *gi_ptr)
|
|
{
|
|
unsigned int i;
|
|
int f_ix;
|
|
const struct gcov_fn_info *gfi_ptr;
|
|
const struct gcov_ctr_info *ci_ptr;
|
|
|
|
if (!gi_ptr->merge[GCOV_COUNTER_ICALL_TOPNV])
|
|
return;
|
|
|
|
for (f_ix = 0; (unsigned)f_ix != gi_ptr->n_functions; f_ix++)
|
|
{
|
|
gfi_ptr = gi_ptr->functions[f_ix];
|
|
ci_ptr = gfi_ptr->ctrs;
|
|
for (i = 0; i < GCOV_COUNTERS; i++)
|
|
{
|
|
if (!gi_ptr->merge[i])
|
|
continue;
|
|
if (i == GCOV_COUNTER_ICALL_TOPNV)
|
|
{
|
|
gcov_sort_icall_topn_counter (ci_ptr);
|
|
break;
|
|
}
|
|
ci_ptr++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Dump the coverage counts for one gcov_info object. We merge with existing
|
|
counts when possible, to avoid growing the .da files ad infinitum. We use
|
|
this program's checksum to make sure we only accumulate whole program
|
|
statistics to the correct summary. An object file might be embedded
|
|
in two separate programs, and we must keep the two program
|
|
summaries separate. */
|
|
|
|
static void
|
|
dump_one_gcov (struct gcov_info *gi_ptr, struct gcov_filename *gf,
|
|
unsigned run_counted,
|
|
gcov_unsigned_t crc32, struct gcov_summary *all_prg,
|
|
struct gcov_summary *this_prg)
|
|
{
|
|
struct gcov_summary prg; /* summary for this object over all program. */
|
|
int error;
|
|
gcov_unsigned_t tag;
|
|
gcov_position_t summary_pos = 0;
|
|
gcov_position_t eof_pos = 0;
|
|
|
|
fn_buffer = 0;
|
|
sum_buffer = 0;
|
|
|
|
gcov_sort_topn_counter_arrays (gi_ptr);
|
|
|
|
error = gcov_exit_open_gcda_file (gi_ptr, gf);
|
|
if (error == -1)
|
|
return;
|
|
|
|
tag = gcov_read_unsigned ();
|
|
if (tag)
|
|
{
|
|
/* Merge data from file. */
|
|
if (tag != GCOV_DATA_MAGIC)
|
|
{
|
|
gcov_error ("profiling:%s:Not a gcov data file\n", gf->filename);
|
|
goto read_fatal;
|
|
}
|
|
error = merge_one_data (gf->filename, gi_ptr, &prg, this_prg,
|
|
&summary_pos, &eof_pos, crc32);
|
|
if (error == -1)
|
|
goto read_fatal;
|
|
}
|
|
|
|
gcov_rewrite ();
|
|
|
|
if (!summary_pos)
|
|
{
|
|
memset (&prg, 0, sizeof (prg));
|
|
summary_pos = eof_pos;
|
|
}
|
|
|
|
error = merge_summary (gf->filename, run_counted, gi_ptr, &prg, this_prg,
|
|
crc32, all_prg);
|
|
if (error == -1)
|
|
goto read_fatal;
|
|
|
|
write_one_data (gi_ptr, &prg, eof_pos, summary_pos);
|
|
/* fall through */
|
|
|
|
read_fatal:;
|
|
while (fn_buffer)
|
|
fn_buffer = free_fn_data (gi_ptr, fn_buffer, GCOV_COUNTERS);
|
|
|
|
if ((error = gcov_close ()))
|
|
gcov_error (error < 0 ?
|
|
"profiling:%s:Overflow writing\n" :
|
|
"profiling:%s:Error writing\n",
|
|
gf->filename);
|
|
}
|
|
|
|
|
|
/* Dump all the coverage counts for the program. It first computes program
|
|
summary and then traverses gcov_list list and dumps the gcov_info
|
|
objects one by one. */
|
|
|
|
#if !IN_GCOV_TOOL
|
|
static
|
|
#endif
|
|
void
|
|
gcov_do_dump (struct gcov_info *list, int run_counted)
|
|
{
|
|
struct gcov_info *gi_ptr;
|
|
struct gcov_filename gf;
|
|
gcov_unsigned_t crc32;
|
|
struct gcov_summary all_prg;
|
|
struct gcov_summary this_prg;
|
|
|
|
crc32 = compute_summary (list, &this_prg, &gf.max_length);
|
|
|
|
allocate_filename_struct (&gf);
|
|
#if !GCOV_LOCKED
|
|
memset (&all_prg, 0, sizeof (all_prg));
|
|
#endif
|
|
|
|
/* Now merge each file. */
|
|
for (gi_ptr = list; gi_ptr; gi_ptr = gi_ptr->next)
|
|
dump_one_gcov (gi_ptr, &gf, run_counted, crc32, &all_prg, &this_prg);
|
|
|
|
free (gf.filename);
|
|
}
|
|
|
|
#if !IN_GCOV_TOOL
|
|
void
|
|
__gcov_dump_one (struct gcov_root *root)
|
|
{
|
|
if (root->dumped)
|
|
return;
|
|
|
|
gcov_do_dump (root->list, root->run_counted);
|
|
|
|
root->dumped = 1;
|
|
root->run_counted = 1;
|
|
}
|
|
|
|
/* Per-dynamic-object gcov state. */
|
|
struct gcov_root __gcov_root;
|
|
|
|
/* Exactly one of these will be live in the process image. */
|
|
struct gcov_master __gcov_master =
|
|
{GCOV_VERSION, 0};
|
|
|
|
static void
|
|
gcov_exit (void)
|
|
{
|
|
__gcov_dump_one (&__gcov_root);
|
|
if (__gcov_root.next)
|
|
__gcov_root.next->prev = __gcov_root.prev;
|
|
if (__gcov_root.prev)
|
|
__gcov_root.prev->next = __gcov_root.next;
|
|
else
|
|
__gcov_master.root = __gcov_root.next;
|
|
}
|
|
|
|
/* Add a new object file onto the bb chain. Invoked automatically
|
|
when running an object file's global ctors. */
|
|
|
|
void
|
|
__gcov_init (struct gcov_info *info)
|
|
{
|
|
if (!info->version || !info->n_functions)
|
|
return;
|
|
if (gcov_version (info, info->version, 0))
|
|
{
|
|
if (!__gcov_root.list)
|
|
{
|
|
/* Add to master list and at exit function. */
|
|
if (gcov_version (NULL, __gcov_master.version, "<master>"))
|
|
{
|
|
__gcov_root.next = __gcov_master.root;
|
|
if (__gcov_master.root)
|
|
__gcov_master.root->prev = &__gcov_root;
|
|
__gcov_master.root = &__gcov_root;
|
|
}
|
|
atexit (gcov_exit);
|
|
}
|
|
|
|
info->next = __gcov_root.list;
|
|
__gcov_root.list = info;
|
|
}
|
|
}
|
|
#endif /* !IN_GCOV_TOOL */
|
|
#endif /* L_gcov */
|
|
#endif /* inhibit_libc */
|