/* File format for coverage information
- Copyright (C) 1996, 1997, 1998, 2000, 2002,
- 2003 Free Software Foundation, Inc.
+ Copyright (C) 1996-2020 Free Software Foundation, Inc.
Contributed by Bob Manson <manson@cygnus.com>.
Completely remangled by Nathan Sidwell <nathan@codesourcery.com>.
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 2, or (at your option) any later
+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
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
-You should have received a copy of the GNU General Public License
-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. */
+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/>. */
/* Routines declared in gcov-io.h. This file should be #included by
another source file, after having #included gcov-io.h. */
static void gcov_allocate (unsigned);
#endif
+/* Optimum number of gcov_unsigned_t's read from or written to disk. */
+#define GCOV_BLOCK_SIZE (1 << 10)
+
+struct gcov_var
+{
+ FILE *file;
+ gcov_position_t start; /* Position of first byte of block */
+ unsigned offset; /* Read/write position within the block. */
+ unsigned length; /* Read limit in the block. */
+ unsigned overread; /* Number of words overread. */
+ int error; /* < 0 overflow, > 0 disk error. */
+ int mode; /* < 0 writing, > 0 reading */
+#if IN_LIBGCOV
+ /* Holds one block plus 4 bytes, thus all coverage reads & writes
+ fit within this buffer and we always can transfer GCOV_BLOCK_SIZE
+ to and from the disk. libgcov never backtracks and only writes 4
+ or 8 byte objects. */
+ gcov_unsigned_t buffer[GCOV_BLOCK_SIZE + 1];
+#else
+ int endian; /* Swap endianness. */
+ /* Holds a variable length block, as the compiler can write
+ strings and needs to backtrack. */
+ size_t alloc;
+ gcov_unsigned_t *buffer;
+#endif
+} gcov_var;
+
+/* Save the current position in the gcov file. */
+/* We need to expose this function when compiling for gcov-tool. */
+#ifndef IN_GCOV_TOOL
+static inline
+#endif
+gcov_position_t
+gcov_position (void)
+{
+ gcov_nonruntime_assert (gcov_var.mode > 0);
+ return gcov_var.start + gcov_var.offset;
+}
+
+/* Return nonzero if the error flag is set. */
+/* We need to expose this function when compiling for gcov-tool. */
+#ifndef IN_GCOV_TOOL
+static inline
+#endif
+int
+gcov_is_error (void)
+{
+ return gcov_var.file ? gcov_var.error : 1;
+}
+
+#if IN_LIBGCOV
+/* Move to beginning of file and initialize for writing. */
+GCOV_LINKAGE inline void
+gcov_rewrite (void)
+{
+ gcov_var.mode = -1;
+ gcov_var.start = 0;
+ gcov_var.offset = 0;
+ fseek (gcov_var.file, 0L, SEEK_SET);
+}
+#endif
+
static inline gcov_unsigned_t from_file (gcov_unsigned_t value)
{
#if !IN_LIBGCOV
/* Open a gcov file. NAME is the name of the file to open and MODE
indicates whether a new file should be created, or an existing file
- opened for modification. If MODE is >= 0 an existing file will be
- opened, if possible, and if MODE is <= 0, a new file will be
- created. Use MODE=0 to attempt to reopen an existing file and then
- fall back on creating a new one. Return zero on failure, >0 on
- opening an existing file and <0 on creating a new one. */
+ opened. If MODE is >= 0 an existing file will be opened, if
+ possible, and if MODE is <= 0, a new file will be created. Use
+ MODE=0 to attempt to reopen an existing file and then fall back on
+ creating a new one. If MODE > 0, the file will be opened in
+ read-only mode. Otherwise it will be opened for modification.
+ Return zero on failure, non-zero on success. */
GCOV_LINKAGE int
#if IN_LIBGCOV
#endif
{
#if IN_LIBGCOV
- const int mode = 0;
+ int mode = 0;
#endif
#if GCOV_LOCKED
struct flock s_flock;
int fd;
- 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 (gcov_var.file)
- abort ();
+
+ gcov_nonruntime_assert (!gcov_var.file);
gcov_var.start = 0;
gcov_var.offset = gcov_var.length = 0;
gcov_var.overread = -1u;
#endif
#if GCOV_LOCKED
if (mode > 0)
- fd = open (name, O_RDWR);
+ {
+ /* Read-only mode - acquire a read-lock. */
+ s_flock.l_type = F_RDLCK;
+ /* pass mode (ignored) for compatibility */
+ fd = open (name, O_RDONLY, S_IRUSR | S_IWUSR);
+ }
else
- fd = open (name, O_RDWR | O_CREAT, 0666);
+ {
+ /* Write mode - acquire a write-lock. */
+ s_flock.l_type = F_WRLCK;
+ /* Truncate if force new mode. */
+ fd = open (name, O_RDWR | O_CREAT | (mode < 0 ? O_TRUNC : 0), 0666);
+ }
if (fd < 0)
return 0;
while (fcntl (fd, F_SETLKW, &s_flock) && errno == EINTR)
continue;
- gcov_var.file = fdopen (fd, "r+b");
+ gcov_var.file = fdopen (fd, (mode > 0) ? "rb" : "r+b");
+
if (!gcov_var.file)
{
close (fd);
return 0;
}
-
- if (mode > 0)
- gcov_var.mode = 1;
- else if (mode == 0)
- {
- struct stat st;
-
- if (fstat (fd, &st) < 0)
- {
- fclose (gcov_var.file);
- gcov_var.file = 0;
- return 0;
- }
- if (st.st_size != 0)
- gcov_var.mode = 1;
- else
- gcov_var.mode = mode * 2 + 1;
- }
- else
- gcov_var.mode = mode * 2 + 1;
#else
if (mode >= 0)
- gcov_var.file = fopen (name, "r+b");
+ /* Open an existing file. */
+ gcov_var.file = fopen (name, (mode > 0) ? "rb" : "r+b");
+
if (gcov_var.file)
- gcov_var.mode = 1;
+ mode = 1;
else if (mode <= 0)
- {
- gcov_var.file = fopen (name, "w+b");
- if (gcov_var.file)
- gcov_var.mode = mode * 2 + 1;
- }
+ /* Create a new file. */
+ gcov_var.file = fopen (name, "w+b");
+
if (!gcov_var.file)
return 0;
#endif
+ gcov_var.mode = mode ? mode : 1;
+
setbuf (gcov_var.file, (char *)0);
-
+
return 1;
}
gcov_allocate (unsigned length)
{
size_t new_size = gcov_var.alloc;
-
+
if (!new_size)
new_size = GCOV_BLOCK_SIZE;
new_size += length;
new_size *= 2;
-
+
gcov_var.alloc = new_size;
- gcov_var.buffer = xrealloc (gcov_var.buffer, new_size << 2);
+ gcov_var.buffer = XRESIZEVAR (gcov_unsigned_t, gcov_var.buffer, new_size << 2);
}
#endif
{
gcov_unsigned_t *result;
- GCOV_CHECK_WRITING ();
+ gcov_nonruntime_assert (gcov_var.mode < 0);
#if IN_LIBGCOV
if (gcov_var.offset >= GCOV_BLOCK_SIZE)
{
gcov_write_block (GCOV_BLOCK_SIZE);
if (gcov_var.offset)
{
- GCOV_CHECK (gcov_var.offset == 1);
memcpy (gcov_var.buffer, gcov_var.buffer + GCOV_BLOCK_SIZE, 4);
}
}
#endif
result = &gcov_var.buffer[gcov_var.offset];
gcov_var.offset += words;
-
+
return result;
}
buffer[1] = (gcov_unsigned_t) (value >> 32);
else
buffer[1] = 0;
-
- if (value < 0)
- gcov_var.error = -1;
}
#endif /* IN_LIBGCOV */
length = strlen (string);
alloc = (length + 4) >> 2;
}
-
+
buffer = gcov_write_words (1 + alloc);
buffer[0] = alloc;
- buffer[alloc] = 0;
- memcpy (&buffer[1], string, length);
+
+ if (alloc > 0)
+ {
+ buffer[alloc] = 0; /* place nul terminators. */
+ memcpy (&buffer[1], string, length);
+ }
+}
+#endif
+
+#if !IN_LIBGCOV
+/* Write FILENAME to coverage file. Sets error flag on file
+ error, overflow flag on overflow */
+
+GCOV_LINKAGE void
+gcov_write_filename (const char *filename)
+{
+ if (profile_abs_path_flag && filename && filename[0]
+ && !(IS_DIR_SEPARATOR (filename[0])
+#if HAVE_DOS_BASED_FILE_SYSTEM
+ || filename[1] == ':'
+#endif
+ ))
+ {
+ char *buf = getcwd (NULL, 0);
+ if (buf != NULL && buf[0])
+ {
+ size_t len = strlen (buf);
+ buf = (char*)xrealloc (buf, len + strlen (filename) + 2);
+ if (!IS_DIR_SEPARATOR (buf[len - 1]))
+ strcat (buf, "/");
+ strcat (buf, filename);
+ gcov_write_string (buf);
+ free (buf);
+ return;
+ }
+ }
+
+ gcov_write_string (filename);
}
#endif
buffer[0] = tag;
buffer[1] = 0;
-
+
return result;
}
gcov_unsigned_t length;
gcov_unsigned_t *buffer;
- GCOV_CHECK_WRITING ();
- GCOV_CHECK (position + 2 <= gcov_var.start + gcov_var.offset);
- GCOV_CHECK (position >= gcov_var.start);
+ gcov_nonruntime_assert (gcov_var.mode < 0);
+ gcov_nonruntime_assert (position + 2 <= gcov_var.start + gcov_var.offset);
+ gcov_nonruntime_assert (position >= gcov_var.start);
offset = position - gcov_var.start;
length = gcov_var.offset - offset - 2;
buffer = (gcov_unsigned_t *) &gcov_var.buffer[offset];
GCOV_LINKAGE void
gcov_write_summary (gcov_unsigned_t tag, const struct gcov_summary *summary)
{
- unsigned ix;
- const struct gcov_ctr_summary *csum;
-
gcov_write_tag_length (tag, GCOV_TAG_SUMMARY_LENGTH);
- gcov_write_unsigned (summary->checksum);
- for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++)
- {
- gcov_write_unsigned (csum->num);
- gcov_write_unsigned (csum->runs);
- gcov_write_counter (csum->sum_all);
- gcov_write_counter (csum->run_max);
- gcov_write_counter (csum->sum_max);
- }
+ gcov_write_unsigned (summary->runs);
+ gcov_write_unsigned (summary->sum_max);
}
+
#endif /* IN_LIBGCOV */
#endif /*!IN_GCOV */
{
const gcov_unsigned_t *result;
unsigned excess = gcov_var.length - gcov_var.offset;
-
- GCOV_CHECK_READING ();
+
+ if (gcov_var.mode <= 0)
+ return NULL;
+
if (excess < words)
{
gcov_var.start += gcov_var.offset;
-#if IN_LIBGCOV
if (excess)
{
- GCOV_CHECK (excess == 1);
+#if IN_LIBGCOV
memcpy (gcov_var.buffer, gcov_var.buffer + gcov_var.offset, 4);
- }
#else
- memmove (gcov_var.buffer, gcov_var.buffer + gcov_var.offset, excess * 4);
+ memmove (gcov_var.buffer, gcov_var.buffer + gcov_var.offset,
+ excess * 4);
#endif
+ }
gcov_var.offset = 0;
gcov_var.length = excess;
#if IN_LIBGCOV
- GCOV_CHECK (!gcov_var.length || gcov_var.length == 1);
excess = GCOV_BLOCK_SIZE;
#else
if (gcov_var.length + words > gcov_var.alloc)
value |= ((gcov_type) from_file (buffer[1])) << 32;
else if (buffer[1])
gcov_var.error = -1;
-
- if (value < 0)
- gcov_var.error = -1;
+
return value;
}
+/* Mangle filename path of BASE and output new allocated pointer with
+ mangled path. */
+
+char *
+mangle_path (char const *base)
+{
+ /* Convert '/' to '#', convert '..' to '^',
+ convert ':' to '~' on DOS based file system. */
+ const char *probe;
+ char *buffer = (char *)xmalloc (strlen (base) + 1);
+ char *ptr = buffer;
+
+#if HAVE_DOS_BASED_FILE_SYSTEM
+ if (base[0] && base[1] == ':')
+ {
+ ptr[0] = base[0];
+ ptr[1] = '~';
+ ptr += 2;
+ base += 2;
+ }
+#endif
+ for (; *base; base = probe)
+ {
+ size_t len;
+
+ for (probe = base; *probe; probe++)
+ if (*probe == '/')
+ break;
+ len = probe - base;
+ if (len == 2 && base[0] == '.' && base[1] == '.')
+ *ptr++ = '^';
+ else
+ {
+ memcpy (ptr, base, len);
+ ptr += len;
+ }
+ if (*probe)
+ {
+ *ptr++ = '#';
+ probe++;
+ }
+ }
+
+ /* Terminate the string. */
+ *ptr = '\0';
+
+ return buffer;
+}
+
+/* We need to expose the below function when compiling for gcov-tool. */
+
+#if !IN_LIBGCOV || defined (IN_GCOV_TOOL)
/* Read string from coverage file. Returns a pointer to a static
buffer, or NULL on empty string. You must copy the string before
calling another gcov function. */
-#if !IN_LIBGCOV
GCOV_LINKAGE const char *
gcov_read_string (void)
{
unsigned length = gcov_read_unsigned ();
-
+
if (!length)
return 0;
GCOV_LINKAGE void
gcov_read_summary (struct gcov_summary *summary)
{
- unsigned ix;
- struct gcov_ctr_summary *csum;
-
- summary->checksum = gcov_read_unsigned ();
- for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++)
- {
- csum->num = gcov_read_unsigned ();
- csum->runs = gcov_read_unsigned ();
- csum->sum_all = gcov_read_counter ();
- csum->run_max = gcov_read_counter ();
- csum->sum_max = gcov_read_counter ();
- }
+ summary->runs = gcov_read_unsigned ();
+ summary->sum_max = gcov_read_unsigned ();
}
-#if !IN_LIBGCOV
+/* We need to expose the below function when compiling for gcov-tool. */
+
+#if !IN_LIBGCOV || defined (IN_GCOV_TOOL)
/* Reset to a known position. BASE should have been obtained from
gcov_position, LENGTH should be a record length. */
GCOV_LINKAGE void
gcov_sync (gcov_position_t base, gcov_unsigned_t length)
{
- GCOV_CHECK_READING ();
+ gcov_nonruntime_assert (gcov_var.mode > 0);
base += length;
if (base - gcov_var.start <= gcov_var.length)
gcov_var.offset = base - gcov_var.start;
#endif
#if IN_LIBGCOV
-/* Move to the a set position in a gcov file. BASE is zero to move to
- the end, and nonzero to move to that position. */
+/* Move to a given position in a gcov file. */
GCOV_LINKAGE void
gcov_seek (gcov_position_t base)
{
- GCOV_CHECK_WRITING ();
if (gcov_var.offset)
gcov_write_block (gcov_var.offset);
- fseek (gcov_var.file, base << 2, base ? SEEK_SET : SEEK_END);
+ fseek (gcov_var.file, base << 2, SEEK_SET);
gcov_var.start = ftell (gcov_var.file) >> 2;
}
#endif
gcov_time (void)
{
struct stat status;
-
+
if (fstat (fileno (gcov_var.file), &status))
return 0;
else
projects / platform / upstream / gcc.git / blobdiff