ATTRIBUTE_UNUSED;
#endif
#define gcov_save_position(STREAM) \
- ftell (STREAM)
+ da_file_position (STREAM)
#define gcov_reserve_length(STREAM) \
- (gcov_write_unsigned (STREAM, 0) ? 0 : ftell (STREAM) - 4)
+ (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) \
- fseek (STREAM, BASE + (long)LENGTH, SEEK_SET)
+ da_file_seek (STREAM, BASE + (long)LENGTH, SEEK_SET)
#define gcov_skip(STREAM, LENGTH) \
- fseek (STREAM, LENGTH, SEEK_CUR)
+ da_file_seek (STREAM, LENGTH, SEEK_CUR)
#define gcov_skip_string(STREAM, LENGTH) \
- fseek (STREAM, (LENGTH) + 4 - ((LENGTH) & 3), SEEK_CUR)
-
+ 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. */
value >>= 8;
}
return ((sizeof (value) > sizeof (buffer) && value)
- || fwrite (buffer, sizeof (buffer), 1, file) != 1);
+ || da_file_write (buffer, 1, sizeof (buffer), file) != sizeof (buffer));
}
/* Write VALUE to coverage file FILE. Return nonzero if failed due to
value >>= 8;
}
return ((sizeof (value) > sizeof (buffer) && value != 0 && value != -1)
- || fwrite (buffer, sizeof (buffer), 1, file) != 1);
+ || da_file_write (buffer, 1, sizeof (buffer), file) != sizeof (buffer));
}
/* Write VALUE to coverage file FILE. Return nonzero if failed due to
const char *string;
{
unsigned pad = 0;
+ unsigned rem = 4 - (length & 3);
if (string)
return (gcov_write_unsigned (file, length)
- || fwrite (string, length, 1, file) != 1
- || fwrite (&pad, 4 - (length & 3), 1, file) != 1);
+ || da_file_write (string, 1, length, file) != length
+ || da_file_write (&pad, 1, rem, file) != rem);
else
return gcov_write_unsigned (file, 0);
}
unsigned ix;
unsigned char buffer[4];
- if (fread (buffer, sizeof (buffer), 1, file) != 1)
+ if (da_file_read (buffer, 1, sizeof (buffer), file) != sizeof (buffer))
return 1;
for (ix = sizeof (value); ix < sizeof (buffer); ix++)
if (buffer[ix])
unsigned ix;
unsigned char buffer[8];
- if (fread (buffer, sizeof (buffer), 1, file) != 1)
+ if (da_file_read (buffer, 1, sizeof (buffer), file) != sizeof (buffer))
return 1;
for (ix = sizeof (value); ix < sizeof (buffer); ix++)
if (buffer[ix])
length += 4 - (length & 3);
*string_p = (char *) xmalloc (length);
- return fread (*string_p, length, 1, file) != 1;
+ return da_file_read (*string_p, 1, length, file) != length;
}
FILE *file;
long place;
{
- long here = ftell (file);
- int result = (!place || fseek (file, place, SEEK_SET)
+ long here = da_file_position (file);
+ int result = (!place || da_file_seek (file, place, SEEK_SET)
|| gcov_write_unsigned (file, here - place - 4));
- if (fseek (file, here, SEEK_SET))
+ if (da_file_seek (file, here, SEEK_SET))
result = 1;
return result;
}
}
#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 ();
+#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 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;
+#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;
+}
+
+/* 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;
+}
+
+/* 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;
+}
+
+/* Tests whether we have reached end of .da file. */
+static int
+da_file_eof ()
+{
+ return actual_da_file_position == actual_da_file_length;
+}
+
+/* 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;
+}
+
+/* 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;
+{
+ 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;
+}
+
+/* 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;
+}
+
+/* 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;
+{
+ return fwrite (data, elts, len, file);
+}
+
+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);
+}
+
+static unsigned long
+da_file_position (file)
+ FILE *file;
+{
+ return ftell (file);
+}
+
+static int
+da_file_seek (file, pos, whence)
+ FILE *file;
+ long pos;
+ int whence;
+{
+ return fseek (file, pos, whence);
+}
+#endif
+
#endif /* GCC_GCOV_IO_H */
#undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
#include <stdio.h>
-#include "gcov-io.h"
#include <string.h>
#if defined (TARGET_HAS_F_SETLKW)
#include <fcntl.h>
#include <errno.h>
#endif
+#include "gcov-io.h"
/* Chain of per-object gcov structures. */
static struct gcov_info *gcov_list;
for (ptr = gcov_list; ptr; ptr = ptr->next)
{
- FILE *da_file;
struct gcov_summary object;
struct gcov_summary local_prg;
int merging = 0;
memset (&object, 0, sizeof (object));
/* Open for modification */
- if ((da_file = fopen (ptr->filename, "r+b")))
- merging = 1;
- else if ((da_file = fopen (ptr->filename, "w+b")))
- ;
- else
+ if (!da_file_open (ptr->filename, &merging))
{
fprintf (stderr, "profiling:%s:Cannot open\n", ptr->filename);
ptr->filename = 0;
continue;
}
-#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 (da_file), F_SETLKW, &s_flock)
- && errno == EINTR)
- continue;
-#endif
if (merging)
{
/* Merge data from file. */
- if (gcov_read_unsigned (da_file, &tag) || tag != GCOV_DATA_MAGIC)
+ if (gcov_read_unsigned (0, &tag) || tag != GCOV_DATA_MAGIC)
{
fprintf (stderr, "profiling:%s:Not a gcov data file\n",
ptr->filename);
read_fatal:;
- fclose (da_file);
+ da_file_close ();
ptr->filename = 0;
continue;
}
- if (gcov_read_unsigned (da_file, &length) || length != GCOV_VERSION)
+ if (gcov_read_unsigned (0, &length) || length != GCOV_VERSION)
{
gcov_version_mismatch (ptr, length);
goto read_fatal;
for (ix = ptr->n_functions, fn_info = ptr->functions;
ix--; fn_info++)
{
- if (gcov_read_unsigned (da_file, &tag)
- || gcov_read_unsigned (da_file, &length))
+ if (gcov_read_unsigned (0, &tag)
+ || gcov_read_unsigned (0, &length))
{
read_error:;
fprintf (stderr, "profiling:%s:Error merging\n",
goto read_fatal;
}
- if (gcov_read_unsigned (da_file, &flength)
- || gcov_skip_string (da_file, flength)
- || gcov_read_unsigned (da_file, &checksum))
+ if (gcov_read_unsigned (0, &flength)
+ || gcov_skip_string (0, flength)
+ || gcov_read_unsigned (0, &checksum))
goto read_error;
if (flength != strlen (fn_info->name)
|| checksum != fn_info->checksum)
f_sect_index < fn_info->n_counter_sections;
f_sect_index++)
{
- if (gcov_read_unsigned (da_file, &tag)
- || gcov_read_unsigned (da_file, &length))
+ unsigned n_counters;
+
+ if (gcov_read_unsigned (0, &tag)
+ || gcov_read_unsigned (0, &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 (fn_info->counter_sections[f_sect_index].tag != tag
- || sect_index == ptr->n_counter_sections
- || length / 8 != fn_info->counter_sections[f_sect_index].n_counters)
+ if (sect_index == ptr->n_counter_sections
+ || fn_info->counter_sections[f_sect_index].tag != tag)
goto read_mismatch;
-
- for (jx = fn_info->counter_sections[f_sect_index].n_counters;
- jx--; counters[sect_index]++)
- if (gcov_read_counter (da_file, &count))
- goto read_error;
+
+ n_counters = fn_info->counter_sections[f_sect_index].n_counters;
+ if (n_counters != length / 8)
+ goto read_mismatch;
+
+ for (jx = 0; jx < n_counters; jx++)
+ if (gcov_read_counter (0, &count))
+ goto read_error;
else
- *counters[sect_index] += count;
+ counters[sect_index][jx] += count;
+ counters[sect_index] += n_counters;
}
}
/* Check object summary */
- if (gcov_read_unsigned (da_file, &tag)
- || gcov_read_unsigned (da_file, &length))
+ if (gcov_read_unsigned (0, &tag)
+ || gcov_read_unsigned (0, &length))
goto read_error;
if (tag != GCOV_TAG_OBJECT_SUMMARY)
goto read_mismatch;
- if (gcov_read_summary (da_file, &object))
+ if (gcov_read_summary (0, &object))
goto read_error;
/* Check program summary */
while (1)
{
- long base = ftell (da_file);
+ long base = da_file_position (0);
- if (gcov_read_unsigned (da_file, &tag)
- || gcov_read_unsigned (da_file, &length))
+ if (gcov_read_unsigned (0, &tag)
+ || gcov_read_unsigned (0, &length))
{
- if (feof (da_file))
+ if (da_file_eof ())
break;
goto read_error;
}
&& tag != GCOV_TAG_PLACEHOLDER_SUMMARY
&& tag != GCOV_TAG_INCORRECT_SUMMARY)
goto read_mismatch;
- if (gcov_read_summary (da_file, &local_prg))
+ if (gcov_read_summary (0, &local_prg))
goto read_error;
if (local_prg.checksum != program.checksum)
continue;
ptr->wkspc = base;
break;
}
- fseek (da_file, 0, SEEK_SET);
+ da_file_seek (0, 0, SEEK_SET);
}
object.runs++;
/* Write out the data. */
if (/* magic */
- gcov_write_unsigned (da_file, GCOV_DATA_MAGIC)
+ gcov_write_unsigned (0, GCOV_DATA_MAGIC)
/* version number */
- || gcov_write_unsigned (da_file, GCOV_VERSION))
+ || gcov_write_unsigned (0, GCOV_VERSION))
{
write_error:;
- fclose (da_file);
+ da_file_close ();
fprintf (stderr, "profiling:%s:Error writing\n", ptr->filename);
ptr->filename = 0;
continue;
for (ix = ptr->n_functions, fn_info = ptr->functions; ix--; fn_info++)
{
/* Announce function. */
- if (gcov_write_unsigned (da_file, GCOV_TAG_FUNCTION)
- || !(base = gcov_reserve_length (da_file))
+ if (gcov_write_unsigned (0, GCOV_TAG_FUNCTION)
+ || !(base = gcov_reserve_length (0))
/* function name */
- || gcov_write_string (da_file, fn_info->name,
+ || gcov_write_string (0, fn_info->name,
strlen (fn_info->name))
/* function checksum */
- || gcov_write_unsigned (da_file, fn_info->checksum)
- || gcov_write_length (da_file, base))
+ || gcov_write_unsigned (0, fn_info->checksum)
+ || gcov_write_length (0, base))
goto write_error;
/* counters. */
if (sect_index == ptr->n_counter_sections)
abort ();
- if (gcov_write_unsigned (da_file, tag)
- || !(base = gcov_reserve_length (da_file)))
+ if (gcov_write_unsigned (0, tag)
+ || !(base = gcov_reserve_length (0)))
goto write_error;
for (jx = fn_info->counter_sections[f_sect_index].n_counters; jx--;)
if (object.arc_max_sum < count)
object.arc_max_sum = count;
}
- if (gcov_write_counter (da_file, count))
+ if (gcov_write_counter (0, count))
goto write_error; /* RIP Edsger Dijkstra */
}
- if (gcov_write_length (da_file, base))
+ if (gcov_write_length (0, base))
goto write_error;
}
}
/* Object file summary. */
- if (gcov_write_summary (da_file, GCOV_TAG_OBJECT_SUMMARY, &object))
+ if (gcov_write_summary (0, GCOV_TAG_OBJECT_SUMMARY, &object))
goto write_error;
if (merging >= 0)
{
- if (fseek (da_file, 0, SEEK_END))
+ if (da_file_seek (0, 0, SEEK_END))
goto write_error;
- ptr->wkspc = ftell (da_file);
- if (gcov_write_summary (da_file, GCOV_TAG_PLACEHOLDER_SUMMARY,
+ ptr->wkspc = da_file_position (0);
+ if (gcov_write_summary (0, GCOV_TAG_PLACEHOLDER_SUMMARY,
&program))
goto write_error;
}
else if (ptr->wkspc)
{
/* Zap trailing program summary */
- if (fseek (da_file, ptr->wkspc, SEEK_SET))
+ if (da_file_seek (0, ptr->wkspc, SEEK_SET))
goto write_error;
if (!local_prg.runs)
ptr->wkspc = 0;
- if (gcov_write_unsigned (da_file,
- local_prg.runs ? GCOV_TAG_PLACEHOLDER_SUMMARY
- : GCOV_TAG_INCORRECT_SUMMARY))
+ if (gcov_write_unsigned (0, local_prg.runs
+ ? GCOV_TAG_PLACEHOLDER_SUMMARY
+ : GCOV_TAG_INCORRECT_SUMMARY))
goto write_error;
}
- if (fflush (da_file))
- goto write_error;
- if (fclose (da_file))
+ if (da_file_close ())
{
fprintf (stderr, "profiling:%s:Error closing\n", ptr->filename);
ptr->filename = 0;
projects / thirdparty / gcc.git / commitdiff
