| /* File format for coverage information |
| Copyright (C) 1996-2021 Free Software Foundation, Inc. |
| Contributed by Bob Manson <manson@cygnus.com>. |
| Completely remangled by Nathan Sidwell <nathan@codesourcery.com>. |
| |
| 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/>. */ |
| |
| /* Routines declared in gcov-io.h. This file should be #included by |
| another source file, after having #included gcov-io.h. */ |
| |
| static gcov_unsigned_t *gcov_read_words (void *buffer, unsigned); |
| |
| struct gcov_var |
| { |
| FILE *file; |
| int error; /* < 0 overflow, > 0 disk error. */ |
| int mode; /* < 0 writing, > 0 reading. */ |
| int endian; /* Swap endianness. */ |
| } 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) |
| { |
| return ftell (gcov_var.file); |
| } |
| |
| /* 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; |
| fseek (gcov_var.file, 0L, SEEK_SET); |
| } |
| #endif |
| |
| static inline gcov_unsigned_t |
| from_file (gcov_unsigned_t value) |
| { |
| #if !IN_LIBGCOV || defined (IN_GCOV_TOOL) |
| if (gcov_var.endian) |
| return __builtin_bswap32 (value); |
| #endif |
| return value; |
| } |
| |
| /* 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. 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 |
| gcov_open (const char *name) |
| #else |
| gcov_open (const char *name, int mode) |
| #endif |
| { |
| #if IN_LIBGCOV |
| int mode = 0; |
| #endif |
| #if GCOV_LOCKED |
| struct flock s_flock; |
| int fd; |
| |
| s_flock.l_whence = SEEK_SET; |
| s_flock.l_start = 0; |
| s_flock.l_len = 0; /* Until EOF. */ |
| s_flock.l_pid = getpid (); |
| #elif GCOV_LOCKED_WITH_LOCKING |
| int fd; |
| #endif |
| |
| gcov_nonruntime_assert (!gcov_var.file); |
| gcov_var.error = 0; |
| #if !IN_LIBGCOV || defined (IN_GCOV_TOOL) |
| gcov_var.endian = 0; |
| #endif |
| #if GCOV_LOCKED |
| if (mode > 0) |
| { |
| /* 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 |
| { |
| /* 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, (mode > 0) ? "rb" : "r+b"); |
| |
| if (!gcov_var.file) |
| { |
| close (fd); |
| return 0; |
| } |
| #elif GCOV_LOCKED_WITH_LOCKING |
| if (mode > 0) |
| { |
| /* pass mode (ignored) for compatibility */ |
| fd = open (name, O_RDONLY | O_BINARY, S_IRUSR | S_IWUSR); |
| } |
| else |
| { |
| /* Truncate if force new mode. */ |
| fd = open (name, O_RDWR | O_BINARY | O_CREAT | (mode < 0 ? O_TRUNC : 0), |
| 0666); |
| } |
| if (fd < 0) |
| return 0; |
| |
| if (_locking (fd, _LK_LOCK, LONG_MAX) < 0) |
| { |
| close (fd); |
| return 0; |
| } |
| |
| gcov_var.file = fdopen (fd, (mode > 0) ? "rb" : "r+b"); |
| |
| if (!gcov_var.file) |
| { |
| close (fd); |
| return 0; |
| } |
| #else |
| if (mode >= 0) |
| /* Open an existing file. */ |
| gcov_var.file = fopen (name, (mode > 0) ? "rb" : "r+b"); |
| |
| if (gcov_var.file) |
| mode = 1; |
| else if (mode <= 0) |
| /* Create a new file. */ |
| gcov_var.file = fopen (name, "w+b"); |
| |
| if (!gcov_var.file) |
| return 0; |
| #endif |
| |
| gcov_var.mode = mode ? mode : 1; |
| |
| return 1; |
| } |
| |
| /* Close the current gcov file. Flushes data to disk. Returns nonzero |
| on failure or error flag set. */ |
| |
| GCOV_LINKAGE int |
| gcov_close (void) |
| { |
| if (gcov_var.file) |
| { |
| if (fclose (gcov_var.file)) |
| gcov_var.error = 1; |
| |
| gcov_var.file = 0; |
| } |
| gcov_var.mode = 0; |
| return gcov_var.error; |
| } |
| |
| #if !IN_LIBGCOV || defined (IN_GCOV_TOOL) |
| /* Check if MAGIC is EXPECTED. Use it to determine endianness of the |
| file. Returns +1 for same endian, -1 for other endian and zero for |
| not EXPECTED. */ |
| |
| GCOV_LINKAGE int |
| gcov_magic (gcov_unsigned_t magic, gcov_unsigned_t expected) |
| { |
| if (magic == expected) |
| return 1; |
| |
| if (__builtin_bswap32 (magic) == expected) |
| { |
| gcov_var.endian = 1; |
| return -1; |
| } |
| return 0; |
| } |
| #endif |
| |
| #if !IN_GCOV |
| /* Write DATA of LENGTH characters to coverage file. */ |
| |
| GCOV_LINKAGE void |
| gcov_write (const void *data, unsigned length) |
| { |
| gcov_unsigned_t r = fwrite (data, length, 1, gcov_var.file); |
| if (r != 1) |
| gcov_var.error = 1; |
| } |
| |
| /* Write unsigned VALUE to coverage file. */ |
| |
| GCOV_LINKAGE void |
| gcov_write_unsigned (gcov_unsigned_t value) |
| { |
| gcov_unsigned_t r = fwrite (&value, sizeof (value), 1, gcov_var.file); |
| if (r != 1) |
| gcov_var.error = 1; |
| } |
| |
| #if !IN_LIBGCOV |
| /* Write STRING to coverage file. Sets error flag on file |
| error, overflow flag on overflow */ |
| |
| GCOV_LINKAGE void |
| gcov_write_string (const char *string) |
| { |
| unsigned length = 0; |
| |
| if (string) |
| length = strlen (string) + 1; |
| |
| gcov_write_unsigned (length); |
| if (length > 0) |
| { |
| gcov_unsigned_t r = fwrite (string, length, 1, gcov_var.file); |
| if (r != 1) |
| gcov_var.error = 1; |
| } |
| } |
| #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 |
| |
| /* Move to a given position in a gcov file. */ |
| |
| GCOV_LINKAGE void |
| gcov_seek (gcov_position_t base) |
| { |
| fseek (gcov_var.file, base, SEEK_SET); |
| } |
| |
| #if !IN_LIBGCOV |
| /* Write a tag TAG and reserve space for the record length. Return a |
| value to be used for gcov_write_length. */ |
| |
| GCOV_LINKAGE gcov_position_t |
| gcov_write_tag (gcov_unsigned_t tag) |
| { |
| gcov_position_t result = gcov_position (); |
| gcov_write_unsigned (tag); |
| gcov_write_unsigned (0); |
| |
| return result; |
| } |
| |
| /* Write a record length using POSITION, which was returned by |
| gcov_write_tag. The current file position is the end of the |
| record, and is restored before returning. Returns nonzero on |
| overflow. */ |
| |
| GCOV_LINKAGE void |
| gcov_write_length (gcov_position_t position) |
| { |
| gcov_position_t current_position = gcov_position (); |
| gcov_nonruntime_assert (gcov_var.mode < 0); |
| gcov_nonruntime_assert (current_position >= position + 2 * GCOV_WORD_SIZE); |
| |
| gcov_seek (position + GCOV_WORD_SIZE); |
| gcov_write_unsigned (current_position - position - 2 * GCOV_WORD_SIZE); |
| gcov_seek (current_position); |
| } |
| |
| #else /* IN_LIBGCOV */ |
| |
| /* Write a summary structure to the gcov file. */ |
| |
| GCOV_LINKAGE void |
| gcov_write_summary (gcov_unsigned_t tag, const struct gcov_summary *summary) |
| { |
| gcov_write_unsigned (tag); |
| gcov_write_unsigned (GCOV_TAG_SUMMARY_LENGTH); |
| gcov_write_unsigned (summary->runs); |
| gcov_write_unsigned (summary->sum_max); |
| } |
| |
| #endif /* IN_LIBGCOV */ |
| |
| #endif /*!IN_GCOV */ |
| |
| /* Return a pointer to read COUNT bytes from the gcov file. Returns |
| NULL on failure (read past EOF). */ |
| |
| static void * |
| gcov_read_bytes (void *buffer, unsigned count) |
| { |
| if (gcov_var.mode <= 0) |
| return NULL; |
| |
| unsigned read = fread (buffer, count, 1, gcov_var.file); |
| if (read != 1) |
| return NULL; |
| |
| return buffer; |
| } |
| |
| /* Read WORDS gcov_unsigned_t values from gcov file. */ |
| |
| static gcov_unsigned_t * |
| gcov_read_words (void *buffer, unsigned words) |
| { |
| return (gcov_unsigned_t *)gcov_read_bytes (buffer, GCOV_WORD_SIZE * words); |
| } |
| |
| /* Read unsigned value from a coverage file. Sets error flag on file |
| error, overflow flag on overflow */ |
| |
| GCOV_LINKAGE gcov_unsigned_t |
| gcov_read_unsigned (void) |
| { |
| gcov_unsigned_t value; |
| gcov_unsigned_t allocated_buffer[1]; |
| gcov_unsigned_t *buffer = gcov_read_words (&allocated_buffer, 1); |
| |
| if (!buffer) |
| return 0; |
| |
| value = from_file (buffer[0]); |
| return value; |
| } |
| |
| /* Read counter value from a coverage file. Sets error flag on file |
| error, overflow flag on overflow */ |
| |
| GCOV_LINKAGE gcov_type |
| gcov_read_counter (void) |
| { |
| gcov_type value; |
| gcov_unsigned_t allocated_buffer[2]; |
| gcov_unsigned_t *buffer = gcov_read_words (&allocated_buffer, 2); |
| |
| if (!buffer) |
| return 0; |
| value = from_file (buffer[0]); |
| if (sizeof (value) > sizeof (gcov_unsigned_t)) |
| value |= ((gcov_type) from_file (buffer[1])) << 32; |
| else if (buffer[1]) |
| 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. */ |
| |
| GCOV_LINKAGE const char * |
| gcov_read_string (void) |
| { |
| unsigned length = gcov_read_unsigned (); |
| |
| if (!length) |
| return 0; |
| |
| void *buffer = XNEWVEC (char *, length); |
| return (const char *) gcov_read_bytes (buffer, length); |
| } |
| #endif |
| |
| GCOV_LINKAGE void |
| gcov_read_summary (struct gcov_summary *summary) |
| { |
| summary->runs = gcov_read_unsigned (); |
| summary->sum_max = gcov_read_unsigned (); |
| } |
| |
| /* 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_nonruntime_assert (gcov_var.mode > 0); |
| base += length; |
| fseek (gcov_var.file, base, SEEK_SET); |
| } |
| #endif |
| |
| #if IN_GCOV > 0 |
| /* Return the modification time of the current gcov file. */ |
| |
| GCOV_LINKAGE time_t |
| gcov_time (void) |
| { |
| struct stat status; |
| |
| if (fstat (fileno (gcov_var.file), &status)) |
| return 0; |
| else |
| return status.st_mtime; |
| } |
| #endif /* IN_GCOV */ |