| /* File format for coverage information |
| Copyright (C) 1996, 1997, 1998, 2000, 2002, 2003, 2004, 2005, 2007, |
| 2008 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. |
| */ |
| |
| /* Routines declared in gcov-io.h. This file should be #included by |
| another source file, after having #included gcov-io.h. */ |
| |
| #if !IN_GCOV |
| static void gcov_write_block(unsigned int); |
| static gcov_unsigned_t *gcov_write_words(unsigned int); |
| #endif |
| static const gcov_unsigned_t *gcov_read_words(unsigned int); |
| #if !IN_LIBGCOV |
| static void gcov_allocate(unsigned int); |
| #endif |
| |
| static inline gcov_unsigned_t from_file(gcov_unsigned_t value) |
| { |
| #if !IN_LIBGCOV |
| if (gcov_var.endian) { |
| value = (value >> 16) | (value << 16); |
| value = ((value & 0xff00ff) << 8) | ((value >> 8) & 0xff00ff); |
| } |
| #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, >0 on opening an existing file and <0 on |
| creating a new one. */ |
| |
| GCOV_LINKAGE int |
| #if IN_LIBGCOV |
| gcov_open(const char *name) |
| #else |
| gcov_open(const char *name, int mode) |
| #endif |
| { |
| #if IN_LIBGCOV |
| const 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(); |
| #endif |
| |
| gcc_assert(!gcov_var.file); |
| gcov_var.start = 0; |
| gcov_var.offset = gcov_var.length = 0; |
| gcov_var.overread = -1u; |
| gcov_var.error = 0; |
| #if !IN_LIBGCOV |
| gcov_var.endian = 0; |
| #endif |
| #if GCOV_LOCKED |
| if (mode > 0) { |
| /* Read-only mode - acquire a read-lock. */ |
| s_flock.l_type = F_RDLCK; |
| fd = open(name, O_RDONLY); |
| } else { |
| /* Write mode - acquire a write-lock. */ |
| s_flock.l_type = F_WRLCK; |
| fd = open(name, O_RDWR | O_CREAT, 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; |
| } |
| |
| 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, (mode > 0) ? "rb" : "r+b"); |
| |
| if (gcov_var.file) |
| gcov_var.mode = 1; |
| else if (mode <= 0) { |
| gcov_var.file = fopen(name, "w+b"); |
| if (gcov_var.file) |
| gcov_var.mode = mode * 2 + 1; |
| } |
| if (!gcov_var.file) |
| return 0; |
| #endif |
| |
| setbuf(gcov_var.file, (char *)0); |
| |
| 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 !IN_GCOV |
| if (gcov_var.offset && gcov_var.mode < 0) |
| gcov_write_block(gcov_var.offset); |
| #endif |
| fclose(gcov_var.file); |
| gcov_var.file = 0; |
| gcov_var.length = 0; |
| } |
| #if !IN_LIBGCOV |
| free(gcov_var.buffer); |
| gcov_var.alloc = 0; |
| gcov_var.buffer = 0; |
| #endif |
| gcov_var.mode = 0; |
| return gcov_var.error; |
| } |
| |
| #if !IN_LIBGCOV |
| /* 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; |
| magic = (magic >> 16) | (magic << 16); |
| magic = ((magic & 0xff00ff) << 8) | ((magic >> 8) & 0xff00ff); |
| if (magic == expected) { |
| gcov_var.endian = 1; |
| return -1; |
| } |
| return 0; |
| } |
| #endif |
| |
| #if !IN_LIBGCOV |
| static void |
| gcov_allocate(unsigned int 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 = XRESIZEVAR(gcov_unsigned_t, gcov_var.buffer, |
| new_size << 2); |
| } |
| #endif |
| |
| #if !IN_GCOV |
| /* Write out the current block, if needs be. */ |
| |
| static void |
| gcov_write_block(unsigned int size) |
| { |
| if (fwrite(gcov_var.buffer, size << 2, 1, gcov_var.file) != 1) |
| gcov_var.error = 1; |
| gcov_var.start += size; |
| gcov_var.offset -= size; |
| } |
| |
| /* Allocate space to write BYTES bytes to the gcov file. Return a |
| pointer to those bytes, or NULL on failure. */ |
| |
| static gcov_unsigned_t * |
| gcov_write_words(unsigned int words) |
| { |
| gcov_unsigned_t *result; |
| |
| gcc_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) { |
| gcc_assert(gcov_var.offset == 1); |
| memcpy(gcov_var.buffer, gcov_var.buffer |
| + GCOV_BLOCK_SIZE, 4); |
| } |
| } |
| #else |
| if (gcov_var.offset + words > gcov_var.alloc) |
| gcov_allocate(gcov_var.offset + words); |
| #endif |
| result = &gcov_var.buffer[gcov_var.offset]; |
| gcov_var.offset += words; |
| |
| return result; |
| } |
| |
| /* Write unsigned VALUE to coverage file. Sets error flag |
| appropriately. */ |
| |
| GCOV_LINKAGE void |
| gcov_write_unsigned(gcov_unsigned_t value) |
| { |
| gcov_unsigned_t *buffer = gcov_write_words(1); |
| |
| buffer[0] = value; |
| } |
| |
| /* Write counter VALUE to coverage file. Sets error flag |
| appropriately. */ |
| |
| #if IN_LIBGCOV |
| GCOV_LINKAGE void |
| gcov_write_counter(gcov_type value) |
| { |
| gcov_unsigned_t *buffer = gcov_write_words(2); |
| |
| buffer[0] = (gcov_unsigned_t) value; |
| if (sizeof(value) > sizeof(gcov_unsigned_t)) |
| buffer[1] = (gcov_unsigned_t) (value >> 32); |
| else |
| buffer[1] = 0; |
| } |
| #endif /* IN_LIBGCOV */ |
| |
| #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 int length = 0; |
| unsigned int alloc = 0; |
| gcov_unsigned_t *buffer; |
| |
| if (string) { |
| length = strlen(string); |
| alloc = (length + 4) >> 2; |
| } |
| |
| buffer = gcov_write_words(1 + alloc); |
| |
| buffer[0] = alloc; |
| buffer[alloc] = 0; |
| memcpy(&buffer[1], string, length); |
| } |
| #endif |
| |
| #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_var.start + gcov_var.offset; |
| gcov_unsigned_t *buffer = gcov_write_words(2); |
| |
| buffer[0] = tag; |
| buffer[1] = 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) |
| { |
| unsigned int offset; |
| gcov_unsigned_t length; |
| gcov_unsigned_t *buffer; |
| |
| gcc_assert(gcov_var.mode < 0); |
| gcc_assert(position + 2 <= gcov_var.start + gcov_var.offset); |
| gcc_assert(position >= gcov_var.start); |
| offset = position - gcov_var.start; |
| length = gcov_var.offset - offset - 2; |
| buffer = (gcov_unsigned_t *) &gcov_var.buffer[offset]; |
| buffer[1] = length; |
| if (gcov_var.offset >= GCOV_BLOCK_SIZE) |
| gcov_write_block(gcov_var.offset); |
| } |
| |
| #else /* IN_LIBGCOV */ |
| |
| /* Write a tag TAG and length LENGTH. */ |
| |
| GCOV_LINKAGE void |
| gcov_write_tag_length(gcov_unsigned_t tag, gcov_unsigned_t length) |
| { |
| gcov_unsigned_t *buffer = gcov_write_words(2); |
| |
| buffer[0] = tag; |
| buffer[1] = length; |
| } |
| |
| /* Write a summary structure to the gcov file. Return nonzero on |
| overflow. */ |
| |
| GCOV_LINKAGE void |
| gcov_write_summary(gcov_unsigned_t tag, const struct gcov_summary *summary) |
| { |
| unsigned int 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); |
| } |
| } |
| #endif /* IN_LIBGCOV */ |
| |
| #endif /*!IN_GCOV */ |
| |
| /* Return a pointer to read BYTES bytes from the gcov file. Returns |
| NULL on failure (read past EOF). */ |
| |
| static const gcov_unsigned_t * |
| gcov_read_words(unsigned int words) |
| { |
| const gcov_unsigned_t *result; |
| unsigned int excess = gcov_var.length - gcov_var.offset; |
| |
| gcc_assert(gcov_var.mode > 0); |
| if (excess < words) { |
| gcov_var.start += gcov_var.offset; |
| #if IN_LIBGCOV |
| if (excess) { |
| gcc_assert(excess == 1); |
| memcpy(gcov_var.buffer, gcov_var.buffer |
| + gcov_var.offset, 4); |
| } |
| #else |
| memmove(gcov_var.buffer, gcov_var.buffer |
| + gcov_var.offset, excess * 4); |
| #endif |
| gcov_var.offset = 0; |
| gcov_var.length = excess; |
| #if IN_LIBGCOV |
| gcc_assert(!gcov_var.length || gcov_var.length == 1); |
| excess = GCOV_BLOCK_SIZE; |
| #else |
| if (gcov_var.length + words > gcov_var.alloc) |
| gcov_allocate(gcov_var.length + words); |
| excess = gcov_var.alloc - gcov_var.length; |
| #endif |
| excess = fread(gcov_var.buffer + gcov_var.length, |
| 1, excess << 2, gcov_var.file) >> 2; |
| gcov_var.length += excess; |
| if (gcov_var.length < words) { |
| gcov_var.overread += words - gcov_var.length; |
| gcov_var.length = 0; |
| return 0; |
| } |
| } |
| result = &gcov_var.buffer[gcov_var.offset]; |
| gcov_var.offset += words; |
| return result; |
| } |
| |
| /* 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; |
| const gcov_unsigned_t *buffer = gcov_read_words(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; |
| const gcov_unsigned_t *buffer = gcov_read_words(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; |
| } |
| |
| /* 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 int length = gcov_read_unsigned(); |
| |
| if (!length) |
| return 0; |
| |
| return (const char *) gcov_read_words(length); |
| } |
| #endif |
| |
| GCOV_LINKAGE void |
| gcov_read_summary(struct gcov_summary *summary) |
| { |
| unsigned int 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(); |
| } |
| } |
| |
| #if !IN_LIBGCOV |
| /* 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) |
| { |
| gcc_assert(gcov_var.mode > 0); |
| base += length; |
| if (base - gcov_var.start <= gcov_var.length) |
| gcov_var.offset = base - gcov_var.start; |
| else { |
| gcov_var.offset = gcov_var.length = 0; |
| fseek(gcov_var.file, base << 2, SEEK_SET); |
| gcov_var.start = ftell(gcov_var.file) >> 2; |
| } |
| } |
| #endif |
| |
| #if IN_LIBGCOV |
| /* Move to a given position in a gcov file. */ |
| |
| GCOV_LINKAGE void |
| gcov_seek(gcov_position_t base) |
| { |
| gcc_assert(gcov_var.mode < 0); |
| if (gcov_var.offset) |
| gcov_write_block(gcov_var.offset); |
| fseek(gcov_var.file, base << 2, SEEK_SET); |
| gcov_var.start = ftell(gcov_var.file) >> 2; |
| } |
| #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 */ |