diff options
Diffstat (limited to 'lib/gcc/mipsel-linux-android/4.6/gcov-src')
| -rw-r--r-- | lib/gcc/mipsel-linux-android/4.6/gcov-src/gcov-io.c | 980 | ||||
| -rw-r--r-- | lib/gcc/mipsel-linux-android/4.6/gcov-src/gcov-io.h | 968 | ||||
| -rw-r--r-- | lib/gcc/mipsel-linux-android/4.6/gcov-src/gcov-iov.h | 4 | ||||
| -rw-r--r-- | lib/gcc/mipsel-linux-android/4.6/gcov-src/libgcov.c | 1989 |
4 files changed, 3941 insertions, 0 deletions
diff --git a/lib/gcc/mipsel-linux-android/4.6/gcov-src/gcov-io.c b/lib/gcc/mipsel-linux-android/4.6/gcov-src/gcov-io.c new file mode 100644 index 0000000..61ecd46 --- /dev/null +++ b/lib/gcc/mipsel-linux-android/4.6/gcov-src/gcov-io.c @@ -0,0 +1,980 @@ +/* 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. + +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. */ + +/* Redefine these here, rather than using the ones in system.h since + * including system.h leads to conflicting definitions of other + * symbols and macros. */ +#undef MIN +#define MIN(X,Y) ((X) < (Y) ? (X) : (Y)) + +#if !IN_GCOV +static void gcov_write_block (unsigned); +static gcov_unsigned_t *gcov_write_words (unsigned); +#endif +static const gcov_unsigned_t *gcov_read_words (unsigned); +#if !IN_LIBGCOV +static void gcov_allocate (unsigned); +#endif + +#ifdef __GCOV_KERNEL__ +struct gcov_var gcov_var ATTRIBUTE_HIDDEN; +#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. */ + +#ifndef __GCOV_KERNEL__ +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; +} +#else /* __GCOV_KERNEL__ */ + +extern _GCOV_FILE *gcov_current_file; + +GCOV_LINKAGE int +gcov_open (const char *name) +{ + gcov_var.start = 0; + gcov_var.offset = gcov_var.length = 0; + gcov_var.overread = -1u; + gcov_var.error = 0; + gcov_var.file = gcov_current_file; + gcov_var.mode = 1; + + return 1; +} +#endif /* __GCOV_KERNEL__ */ + +/* 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 + _GCOV_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 +/* Modify FILENAME to a canonical form after stripping known prefixes + in place. It removes '/proc/self/cwd' and '/proc/self/cwd/.'. + Returns the in-place modified filename. */ + +GCOV_LINKAGE char * +gcov_canonical_filename (char *filename) +{ + static char cwd_dot_str[] = "/proc/self/cwd/./"; + int cwd_dot_len = strlen (cwd_dot_str); + int cwd_len = cwd_dot_len - 2; /* without trailing './' */ + int filename_len = strlen (filename); + /* delete the longer prefix first */ + if (0 == strncmp (filename, cwd_dot_str, cwd_dot_len)) + { + memmove (filename, filename + cwd_dot_len, filename_len - cwd_dot_len); + filename[filename_len - cwd_dot_len] = '\0'; + return filename; + } + + if (0 == strncmp (filename, cwd_dot_str, cwd_len)) + { + memmove (filename, filename + cwd_len, filename_len - cwd_len); + filename[filename_len - cwd_len] = '\0'; + return filename; + } + return filename; +} + +/* Read LEN words and construct load latency info LL_INFO. */ + +GCOV_LINKAGE void +gcov_read_pmu_load_latency_info (gcov_pmu_ll_info_t *ll_info, + gcov_unsigned_t len ATTRIBUTE_UNUSED) +{ + const char *filename; + ll_info->counts = gcov_read_unsigned (); + ll_info->self = gcov_read_unsigned (); + ll_info->cum = gcov_read_unsigned (); + ll_info->lt_10 = gcov_read_unsigned (); + ll_info->lt_32 = gcov_read_unsigned (); + ll_info->lt_64 = gcov_read_unsigned (); + ll_info->lt_256 = gcov_read_unsigned (); + ll_info->lt_1024 = gcov_read_unsigned (); + ll_info->gt_1024 = gcov_read_unsigned (); + ll_info->wself = gcov_read_unsigned (); + ll_info->code_addr = gcov_read_counter (); + ll_info->line = gcov_read_unsigned (); + ll_info->discriminator = gcov_read_unsigned (); + filename = gcov_read_string (); + if (filename) + ll_info->filename = gcov_canonical_filename (xstrdup (filename)); + else + ll_info->filename = 0; +} + +/* Read LEN words and construct branch mispredict info BRM_INFO. */ + +GCOV_LINKAGE void +gcov_read_pmu_branch_mispredict_info (gcov_pmu_brm_info_t *brm_info, + gcov_unsigned_t len ATTRIBUTE_UNUSED) +{ + const char *filename; + brm_info->counts = gcov_read_unsigned (); + brm_info->self = gcov_read_unsigned (); + brm_info->cum = gcov_read_unsigned (); + brm_info->code_addr = gcov_read_counter (); + brm_info->line = gcov_read_unsigned (); + brm_info->discriminator = gcov_read_unsigned (); + filename = gcov_read_string (); + if (filename) + brm_info->filename = gcov_canonical_filename (xstrdup (filename)); + else + brm_info->filename = 0; +} + +/* Read LEN words from an open gcov file and construct data into pmu + tool header TOOL_HEADER. */ + +GCOV_LINKAGE void gcov_read_pmu_tool_header (gcov_pmu_tool_header_t *header, + gcov_unsigned_t len ATTRIBUTE_UNUSED) +{ + const char *str; + str = gcov_read_string (); + header->host_cpu = str ? xstrdup (str) : 0; + str = gcov_read_string (); + header->hostname = str ? xstrdup (str) : 0; + str = gcov_read_string (); + header->kernel_version = str ? xstrdup (str) : 0; + str = gcov_read_string (); + header->column_header = str ? xstrdup (str) : 0; + str = gcov_read_string (); + header->column_description = str ? xstrdup (str) : 0; + str = gcov_read_string (); + header->full_header = str ? xstrdup (str) : 0; +} +#endif + +#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 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 size) +{ + if (_GCOV_fwrite (gcov_var.buffer, size << 2, 1, gcov_var.file) != 1) + gcov_var.error = 1; + gcov_var.start += size; + gcov_var.offset -= size; +} + +#if IN_LIBGCOV +/* Return the number of words STRING would need including the length + field in the output stream itself. This should be identical to + "alloc" calculation in gcov_write_string(). */ + +GCOV_LINKAGE gcov_unsigned_t +gcov_string_length (const char *string) +{ + gcov_unsigned_t len = (string) ? strlen (string) : 0; + /* + 1 because of the length field. */ + gcov_unsigned_t alloc = 1 + ((len + 4) >> 2); + + /* Can not write a bigger than GCOV_BLOCK_SIZE string yet */ + gcc_assert (alloc < GCOV_BLOCK_SIZE); + return alloc; +} +#endif + +/* 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 words) +{ + gcov_unsigned_t *result; + + gcc_assert (gcov_var.mode < 0); +#if IN_LIBGCOV + if (gcov_var.offset + words >= GCOV_BLOCK_SIZE) + { + gcov_write_block (MIN (gcov_var.offset, GCOV_BLOCK_SIZE)); + if (gcov_var.offset) + { + gcc_assert (gcov_var.offset < GCOV_BLOCK_SIZE); + memcpy (gcov_var.buffer, + gcov_var.buffer + GCOV_BLOCK_SIZE, + gcov_var.offset << 2); + } + } +#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 */ + +/* 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; + unsigned 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); +} + +#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 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 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 words) +{ + const gcov_unsigned_t *result; + unsigned excess = gcov_var.length - gcov_var.offset; + + gcc_assert (gcov_var.mode > 0); + gcc_assert (words < GCOV_BLOCK_SIZE); + if (excess < words) + { + gcov_var.start += gcov_var.offset; +#if IN_LIBGCOV + if (excess) + { + gcc_assert (excess < GCOV_BLOCK_SIZE); + memmove (gcov_var.buffer, gcov_var.buffer + gcov_var.offset, excess * 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 + excess = (sizeof (gcov_var.buffer) / sizeof (gcov_var.buffer[0])) - gcov_var.length; +#else + if (gcov_var.length + words > gcov_var.alloc) + gcov_allocate (gcov_var.length + words); + excess = gcov_var.alloc - gcov_var.length; +#endif + excess = _GCOV_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. */ + +GCOV_LINKAGE const char * +gcov_read_string (void) +{ + unsigned length = gcov_read_unsigned (); + + if (!length) + return 0; + + return (const char *) gcov_read_words (length); +} + +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 (); + } +} + +#if !IN_LIBGCOV && IN_GCOV != 1 +/* Read LEN words (unsigned type) and construct MOD_INFO. */ + +GCOV_LINKAGE void +gcov_read_module_info (struct gcov_module_info *mod_info, + gcov_unsigned_t len) +{ + gcov_unsigned_t src_filename_len, filename_len, i, j, num_strings; + mod_info->ident = gcov_read_unsigned (); + mod_info->is_primary = gcov_read_unsigned (); + mod_info->is_exported = gcov_read_unsigned (); + mod_info->lang = gcov_read_unsigned (); + mod_info->num_quote_paths = gcov_read_unsigned (); + mod_info->num_bracket_paths = gcov_read_unsigned (); + mod_info->num_cpp_defines = gcov_read_unsigned (); + mod_info->num_cpp_includes = gcov_read_unsigned (); + mod_info->num_cl_args = gcov_read_unsigned (); + len -= 9; + + filename_len = gcov_read_unsigned (); + mod_info->da_filename = (char *) xmalloc (filename_len * + sizeof (gcov_unsigned_t)); + for (i = 0; i < filename_len; i++) + ((gcov_unsigned_t *) mod_info->da_filename)[i] = gcov_read_unsigned (); + len -= (filename_len + 1); + + src_filename_len = gcov_read_unsigned (); + mod_info->source_filename = (char *) xmalloc (src_filename_len * + sizeof (gcov_unsigned_t)); + for (i = 0; i < src_filename_len; i++) + ((gcov_unsigned_t *) mod_info->source_filename)[i] = gcov_read_unsigned (); + len -= (src_filename_len + 1); + + num_strings = mod_info->num_quote_paths + mod_info->num_bracket_paths + + mod_info->num_cpp_defines + mod_info->num_cpp_includes + + mod_info->num_cl_args; + for (j = 0; j < num_strings; j++) + { + gcov_unsigned_t string_len = gcov_read_unsigned (); + mod_info->string_array[j] = + (char *) xmalloc (string_len * sizeof (gcov_unsigned_t)); + for (i = 0; i < string_len; i++) + ((gcov_unsigned_t *) mod_info->string_array[j])[i] = + gcov_read_unsigned (); + len -= (string_len + 1); + } + gcc_assert (!len); +} +#endif + +#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) +{ +#ifdef __GCOV_KERNEL__ + /* should not reach this point */ + gcc_assert (0); +#else /* __GCOV_KERNEL__ */ + 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; + _GCOV_fseek (gcov_var.file, base << 2, SEEK_SET); + gcov_var.start = _GCOV_ftell (gcov_var.file) >> 2; + } +#endif /* __GCOV_KERNEL__ */ +} +#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); + _GCOV_fseek (gcov_var.file, base << 2, SEEK_SET); + gcov_var.start = _GCOV_ftell (gcov_var.file) >> 2; +} + +/* Truncate the gcov file at the current position. */ + +GCOV_LINKAGE void +gcov_truncate (void) +{ +#ifdef __GCOV_KERNEL__ + /* should not reach this point */ + gcc_assert (0); +#else /* __GCOV_KERNEL__ */ + long offs; + int filenum; + gcc_assert (gcov_var.mode < 0); + if (gcov_var.offset) + gcov_write_block (gcov_var.offset); + offs = ftell (gcov_var.file); + filenum = fileno (gcov_var.file); + if (offs == -1 || filenum == -1 || ftruncate (filenum, offs)) + gcov_var.error = 1; +#endif /* __GCOV_KERNEL__ */ +} +#endif + +#ifndef __GCOV_KERNEL__ +/* Convert an unsigned NUMBER to a percentage after dividing by + 100. */ + +GCOV_LINKAGE float +convert_unsigned_to_pct (const unsigned number) +{ + return (float)number / 100.0f; +} +#endif + +#if !IN_LIBGCOV && IN_GCOV != 1 +/* Print load latency information given by LL_INFO in a human readable + format into an open output file pointed by FP. NEWLINE specifies + whether or not to print a trailing newline. */ + +GCOV_LINKAGE void +print_load_latency_line (FILE *fp, const gcov_pmu_ll_info_t *ll_info, + const enum print_newline newline) +{ + if (!ll_info) + return; + fprintf (fp, " %u %.2f%% %.2f%% %.2f%% %.2f%% %.2f%% %.2f%% %.2f%% " + "%.2f%% %.2f%% " HOST_WIDEST_INT_PRINT_HEX " %s %d %d", + ll_info->counts, + convert_unsigned_to_pct (ll_info->self), + convert_unsigned_to_pct (ll_info->cum), + convert_unsigned_to_pct (ll_info->lt_10), + convert_unsigned_to_pct (ll_info->lt_32), + convert_unsigned_to_pct (ll_info->lt_64), + convert_unsigned_to_pct (ll_info->lt_256), + convert_unsigned_to_pct (ll_info->lt_1024), + convert_unsigned_to_pct (ll_info->gt_1024), + convert_unsigned_to_pct (ll_info->wself), + ll_info->code_addr, + ll_info->filename, + ll_info->line, + ll_info->discriminator); + if (newline == add_newline) + fprintf (fp, "\n"); +} + +/* Print BRM_INFO into the file pointed by FP. NEWLINE specifies + whether or not to print a trailing newline. */ + +GCOV_LINKAGE void +print_branch_mispredict_line (FILE *fp, const gcov_pmu_brm_info_t *brm_info, + const enum print_newline newline) +{ + if (!brm_info) + return; + fprintf (fp, " %u %.2f%% %.2f%% " HOST_WIDEST_INT_PRINT_HEX " %s %d %d", + brm_info->counts, + convert_unsigned_to_pct (brm_info->self), + convert_unsigned_to_pct (brm_info->cum), + brm_info->code_addr, + brm_info->filename, + brm_info->line, + brm_info->discriminator); + if (newline == add_newline) + fprintf (fp, "\n"); +} + +/* Print TOOL_HEADER into the file pointed by FP. NEWLINE specifies + whether or not to print a trailing newline. */ + +GCOV_LINKAGE void +print_pmu_tool_header (FILE *fp, gcov_pmu_tool_header_t *tool_header, + const enum print_newline newline) +{ + if (!tool_header) + return; + fprintf (fp, "\nhost_cpu: %s\n", tool_header->host_cpu); + fprintf (fp, "hostname: %s\n", tool_header->hostname); + fprintf (fp, "kernel_version: %s\n", tool_header->kernel_version); + fprintf (fp, "column_header: %s\n", tool_header->column_header); + fprintf (fp, "column_description: %s\n", tool_header->column_description); + fprintf (fp, "full_header: %s\n", tool_header->full_header); + if (newline == add_newline) + fprintf (fp, "\n"); +} +#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 */ + +#ifdef __GCOV_KERNEL__ + +/* File fclose operation in kernel mode. */ + +int +kernel_file_fclose (gcov_kernel_vfile *fp) +{ + return 0; +} + +/* File ftell operation in kernel mode. It currently should not + be called. */ + +long +kernel_file_ftell (gcov_kernel_vfile *fp) +{ + gcc_assert (0); /* should not reach here */ + return 0; +} + +/* File fseek operation in kernel mode. It should only be called + with OFFSET==0 and WHENCE==0 to a freshly opened file. */ + +int +kernel_file_fseek (gcov_kernel_vfile *fp, long offset, int whence) +{ + gcc_assert (offset == 0 && whence == 0 && fp->count == 0); + return 0; +} + +/* File ftruncate operation in kernel mode. It currently should not + be called. */ + +int +kernel_file_ftruncate (gcov_kernel_vfile *fp, off_t value) +{ + gcc_assert (0); /* should not reach here */ + return 0; +} + +/* File fread operation in kernel mode. It currently should not + be called. */ + +int +kernel_file_fread (void *ptr, size_t size, size_t nitems, + gcov_kernel_vfile *fp) +{ + gcc_assert (0); /* should not reach here */ + return 0; +} + +/* File fwrite operation in kernel mode. It outputs the data + to a buffer in the virual file. */ + +int +kernel_file_fwrite (const void *ptr, size_t size, + size_t nitems, gcov_kernel_vfile *fp) +{ + char *vbuf; + unsigned vsize, vpos; + unsigned len; + + if (!fp) return 0; + + vbuf = fp->buf; + vsize = fp->size; + vpos = fp->count; + + if (vsize <= vpos) + { + printk (KERN_ERR + "GCOV_KERNEL: something wrong: vbuf=%p vsize=%u vpos=%u\n", + vbuf, vsize, vpos); + return 0; + } + len = vsize - vpos; + len /= size; + + if (len > nitems) + len = nitems; + + memcpy (vbuf+vpos, ptr, size*len); + fp->count += len*size; + + if (len != nitems) + printk (KERN_ERR + "GCOV_KERNEL: something wrong: size=%lu nitems=%lu ret=%d\n", + size, nitems, len); + return len; +} + +/* File fileno operation in kernel mode. It currently should not + be called. */ + +int +kernel_file_fileno (gcov_kernel_vfile *fp) +{ + gcc_assert (0); /* should not reach here */ + return 0; +} +#else /* __GCOV_KERNEL__ */ + +#if IN_GCOV != 1 +/* Delete pmu tool header TOOL_HEADER. */ + +GCOV_LINKAGE void +destroy_pmu_tool_header (gcov_pmu_tool_header_t *tool_header) +{ + if (!tool_header) + return; + if (tool_header->host_cpu) + free (tool_header->host_cpu); + if (tool_header->hostname) + free (tool_header->hostname); + if (tool_header->kernel_version) + free (tool_header->kernel_version); + if (tool_header->column_header) + free (tool_header->column_header); + if (tool_header->column_description) + free (tool_header->column_description); + if (tool_header->full_header) + free (tool_header->full_header); +} +#endif + +#endif /* GCOV_KERNEL */ diff --git a/lib/gcc/mipsel-linux-android/4.6/gcov-src/gcov-io.h b/lib/gcc/mipsel-linux-android/4.6/gcov-src/gcov-io.h new file mode 100644 index 0000000..fe0ae20 --- /dev/null +++ b/lib/gcc/mipsel-linux-android/4.6/gcov-src/gcov-io.h @@ -0,0 +1,968 @@ +/* File format for coverage information + Copyright (C) 1996, 1997, 1998, 2000, 2002, + 2003, 2004, 2005, 2008, 2009 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/>. */ + + +/* Coverage information is held in two files. A notes file, which is + generated by the compiler, and a data file, which is generated by + the program under test. Both files use a similar structure. We do + not attempt to make these files backwards compatible with previous + versions, as you only need coverage information when developing a + program. We do hold version information, so that mismatches can be + detected, and we use a format that allows tools to skip information + they do not understand or are not interested in. + + Numbers are recorded in the 32 bit unsigned binary form of the + endianness of the machine generating the file. 64 bit numbers are + stored as two 32 bit numbers, the low part first. Strings are + padded with 1 to 4 NUL bytes, to bring the length up to a multiple + of 4. The number of 4 bytes is stored, followed by the padded + string. Zero length and NULL strings are simply stored as a length + of zero (they have no trailing NUL or padding). + + int32: byte3 byte2 byte1 byte0 | byte0 byte1 byte2 byte3 + int64: int32:low int32:high + string: int32:0 | int32:length char* char:0 padding + padding: | char:0 | char:0 char:0 | char:0 char:0 char:0 + item: int32 | int64 | string + + The basic format of the files is + + file : int32:magic int32:version int32:stamp record* + + The magic ident is different for the notes and the data files. The + magic ident is used to determine the endianness of the file, when + reading. The version is the same for both files and is derived + from gcc's version number. The stamp value is used to synchronize + note and data files and to synchronize merging within a data + file. It need not be an absolute time stamp, merely a ticker that + increments fast enough and cycles slow enough to distinguish + different compile/run/compile cycles. + + Although the ident and version are formally 32 bit numbers, they + are derived from 4 character ASCII strings. The version number + consists of the single character major version number, a two + character minor version number (leading zero for versions less than + 10), and a single character indicating the status of the release. + That will be 'e' experimental, 'p' prerelease and 'r' for release. + Because, by good fortune, these are in alphabetical order, string + collating can be used to compare version strings. Be aware that + the 'e' designation will (naturally) be unstable and might be + incompatible with itself. For gcc 3.4 experimental, it would be + '304e' (0x33303465). When the major version reaches 10, the + letters A-Z will be used. Assuming minor increments releases every + 6 months, we have to make a major increment every 50 years. + Assuming major increments releases every 5 years, we're ok for the + next 155 years -- good enough for me. + + A record has a tag, length and variable amount of data. + + record: header data + header: int32:tag int32:length + data: item* + + Records are not nested, but there is a record hierarchy. Tag + numbers reflect this hierarchy. Tags are unique across note and + data files. Some record types have a varying amount of data. The + LENGTH is the number of 4bytes that follow and is usually used to + determine how much data. The tag value is split into 4 8-bit + fields, one for each of four possible levels. The most significant + is allocated first. Unused levels are zero. Active levels are + odd-valued, so that the LSB of the level is one. A sub-level + incorporates the values of its superlevels. This formatting allows + you to determine the tag hierarchy, without understanding the tags + themselves, and is similar to the standard section numbering used + in technical documents. Level values [1..3f] are used for common + tags, values [41..9f] for the notes file and [a1..ff] for the data + file. + + The basic block graph file contains the following records + note: unit function-graph* + unit: header int32:checksum string:source + function-graph: announce_function basic_blocks {arcs | lines}* + announce_function: header int32:ident + int32:lineno_checksum int32:cfg_checksum + string:name string:source int32:lineno + basic_block: header int32:flags* + arcs: header int32:block_no arc* + arc: int32:dest_block int32:flags + lines: header int32:block_no line* + int32:0 string:NULL + line: int32:line_no | int32:0 string:filename + + The BASIC_BLOCK record holds per-bb flags. The number of blocks + can be inferred from its data length. There is one ARCS record per + basic block. The number of arcs from a bb is implicit from the + data length. It enumerates the destination bb and per-arc flags. + There is one LINES record per basic block, it enumerates the source + lines which belong to that basic block. Source file names are + introduced by a line number of 0, following lines are from the new + source file. The initial source file for the function is NULL, but + the current source file should be remembered from one LINES record + to the next. The end of a block is indicated by an empty filename + - this does not reset the current source file. Note there is no + ordering of the ARCS and LINES records: they may be in any order, + interleaved in any manner. The current filename follows the order + the LINES records are stored in the file, *not* the ordering of the + blocks they are for. + + The data file contains the following records. + data: {unit function-data* summary:object summary:program*}* + unit: header int32:checksum + function-data: announce_function arc_counts + announce_function: header int32:ident + int32:lineno_checksum int32:cfg_checksum + arc_counts: header int64:count* + summary: int32:checksum {count-summary}GCOV_COUNTERS + count-summary: int32:num int32:runs int64:sum + int64:max int64:sum_max + + The ANNOUNCE_FUNCTION record is the same as that in the note file, + but without the source location. The ARC_COUNTS gives the counter + values for those arcs that are instrumented. The SUMMARY records + give information about the whole object file and about the whole + program. The checksum is used for whole program summaries, and + disambiguates different programs which include the same + instrumented object file. There may be several program summaries, + each with a unique checksum. The object summary's checksum is zero. + Note that the data file might contain information from several runs + concatenated, or the data might be merged. + + This file is included by both the compiler, gcov tools and the + runtime support library libgcov. IN_LIBGCOV and IN_GCOV are used to + distinguish which case is which. If IN_LIBGCOV is nonzero, + libgcov is being built. If IN_GCOV is nonzero, the gcov tools are + being built. Otherwise the compiler is being built. IN_GCOV may be + positive or negative. If positive, we are compiling a tool that + requires additional functions (see the code for knowledge of what + those functions are). */ + +#ifndef GCC_GCOV_IO_H +#define GCC_GCOV_IO_H + +#ifdef __KERNEL__ +#ifndef __GCOV_KERNEL__ +#define __GCOV_KERNEL__ +#endif /* __GCOV_KERNEL__ */ +#endif /* __KERNEL__ */ + +#ifdef __GCOV_KERNEL__ +#define GCOV_LINKAGE /* nothing */ + +/* We need the definitions for + BITS_PER_UNIT and + LONG_LONG_TYPE_SIZE + They are defined in gcc/defaults.h and gcc/config/<arch_depend_files> + (like, gcc/config/i386/i386.h). And it can be overridden by setting + in build scripts. Here I hardcoded the value for x86. + Todo: using a program to auto-generate the vaules in build time. */ +#define BITS_PER_UNIT 8 +#define LONG_LONG_TYPE_SIZE 64 + +/* There are many gcc_assertions. Set the vaule to 1 if we want a warning + message if the assertion fails. */ +#ifndef ENABLE_ASSERT_CHECKING +#define ENABLE_ASSERT_CHECKING 1 +#endif + +#include <linux/fs.h> +#endif /* __GCOV_KERNEL__ */ + +/* Wrappers to the file operations. */ +#ifndef __GCOV_KERNEL__ +# define _GCOV_FILE FILE +# define _GCOV_fclose fclose +# define _GCOV_ftell ftell +# define _GCOV_fseek fseek +# define _GCOV_ftruncate ftruncate +# define _GCOV_fread fread +# define _GCOV_fwrite fwrite +# define _GCOV_fread fread +# define _GCOV_fileno fileno +#else /* __GCOV_KERNEL__ */ +/* In Linux kernel mode, a virtual file is used for file operations. */ +struct gcov_info; +typedef struct { + long size; /* size of buf */ + long count; /* element written into buf */ + struct gcov_info *info; + char buf[0]; +} gcov_kernel_vfile; + +# define _GCOV_FILE gcov_kernel_vfile + +/* gcc_assert() prints out a warning if the check fails. It + will not abort. */ +#if ENABLE_ASSERT_CHECKING +# define gcc_assert(EXPR) \ + ((void)(!(EXPR) ? printk (KERN_WARNING \ + "GCOV assertion fails: func=%s line=%d\n", \ + __FUNCTION__, __LINE__), 0 : 0)) +#else +# define gcc_assert(EXPR) ((void)(0 && (EXPR))) +#endif + +/* Wrappers to the file operations. */ +# define _GCOV_fclose kernel_file_fclose +# define _GCOV_ftell kernel_file_ftell +# define _GCOV_fseek kernel_file_fseek +# define _GCOV_ftruncate kernel_file_ftruncate +# define _GCOV_fread kernel_file_fread +# define _GCOV_fwrite kernel_file_fwrite +# define _GCOV_fileno kernel_file_fileno + +/* Declarations for virtual files operations. */ +extern int kernel_file_fclose (gcov_kernel_vfile *); +extern long kernel_file_ftell (gcov_kernel_vfile *); +extern int kernel_file_fseek (gcov_kernel_vfile *, long, int); +extern int kernel_file_ftruncate (gcov_kernel_vfile *, off_t); +extern int kernel_file_fread (void *, size_t, size_t, + gcov_kernel_vfile *); +extern int kernel_file_fwrite (const void *, size_t, size_t, + gcov_kernel_vfile *); +extern int kernel_file_fileno(gcov_kernel_vfile *); +#endif /* GCOV_KERNEL */ +#if IN_LIBGCOV + +#undef FUNC_ID_WIDTH +#undef FUNC_ID_MASK +/* About the target */ + +#if BITS_PER_UNIT == 8 +typedef unsigned gcov_unsigned_t __attribute__ ((mode (SI))); +typedef unsigned gcov_position_t __attribute__ ((mode (SI))); +#if LONG_LONG_TYPE_SIZE > 32 +typedef signed gcov_type __attribute__ ((mode (DI))); +#define FUNC_ID_WIDTH 32 +#define FUNC_ID_MASK ((1ll << FUNC_ID_WIDTH) - 1) +#else +typedef signed gcov_type __attribute__ ((mode (SI))); +#define FUNC_ID_WIDTH 16 +#define FUNC_ID_MASK ((1 << FUNC_ID_WIDTH) - 1) +#endif +#else /* BITS_PER_UNIT != 8 */ +#if BITS_PER_UNIT == 16 +typedef unsigned gcov_unsigned_t __attribute__ ((mode (HI))); +typedef unsigned gcov_position_t __attribute__ ((mode (HI))); +#if LONG_LONG_TYPE_SIZE > 32 +typedef signed gcov_type __attribute__ ((mode (SI))); +#define FUNC_ID_WIDTH 32 +#define FUNC_ID_MASK ((1ll << FUNC_ID_WIDTH) - 1) +#else +typedef signed gcov_type __attribute__ ((mode (HI))); +#define FUNC_ID_WIDTH 16 +#define FUNC_ID_MASK ((1 << FUNC_ID_WIDTH) - 1) +#endif +#else /* BITS_PER_UNIT != 16 */ +typedef unsigned gcov_unsigned_t __attribute__ ((mode (QI))); +typedef unsigned gcov_position_t __attribute__ ((mode (QI))); +#if LONG_LONG_TYPE_SIZE > 32 +typedef signed gcov_type __attribute__ ((mode (HI))); +#define FUNC_ID_WIDTH 32 +#define FUNC_ID_MASK ((1ll << FUNC_ID_WIDTH) - 1) +#else +typedef signed gcov_type __attribute__ ((mode (QI))); +#define FUNC_ID_WIDTH 16 +#define FUNC_ID_MASK ((1 << FUNC_ID_WIDTH) - 1) +#endif +#endif /* BITS_PER_UNIT == 16 */ + +#endif /* BITS_PER_UNIT == 8 */ + +#undef EXTRACT_MODULE_ID_FROM_GLOBAL_ID +#undef EXTRACT_FUNC_ID_FROM_GLOBAL_ID +#undef GEN_FUNC_GLOBAL_ID +#define EXTRACT_MODULE_ID_FROM_GLOBAL_ID(gid) \ + (gcov_unsigned_t)(((gid) >> FUNC_ID_WIDTH) & FUNC_ID_MASK) +#define EXTRACT_FUNC_ID_FROM_GLOBAL_ID(gid) \ + (gcov_unsigned_t)((gid) & FUNC_ID_MASK) +#define GEN_FUNC_GLOBAL_ID(m,f) ((((gcov_type) (m)) << FUNC_ID_WIDTH) | (f)) + + +#if defined (TARGET_POSIX_IO) +#define GCOV_LOCKED 1 +#else +#define GCOV_LOCKED 0 +#endif + +#else /* !IN_LIBGCOV */ +/* About the host */ + +typedef unsigned gcov_unsigned_t; +typedef unsigned gcov_position_t; + +/* gcov_type is typedef'd elsewhere for the compiler */ +#if IN_GCOV +#define GCOV_LINKAGE static +typedef HOST_WIDEST_INT gcov_type; +#if IN_GCOV > 0 +#include <sys/types.h> +#endif + +#define FUNC_ID_WIDTH HOST_BITS_PER_WIDE_INT/2 +#define FUNC_ID_MASK ((1L << FUNC_ID_WIDTH) - 1) +#define EXTRACT_MODULE_ID_FROM_GLOBAL_ID(gid) (unsigned)(((gid) >> FUNC_ID_WIDTH) & FUNC_ID_MASK) +#define EXTRACT_FUNC_ID_FROM_GLOBAL_ID(gid) (unsigned)((gid) & FUNC_ID_MASK) +#define FUNC_GLOBAL_ID(m,f) ((((HOST_WIDE_INT) (m)) << FUNC_ID_WIDTH) | (f) + +#else /*!IN_GCOV */ +#define GCOV_TYPE_SIZE (LONG_LONG_TYPE_SIZE > 32 ? 64 : 32) +#endif + +#if defined (HOST_HAS_F_SETLKW) +#define GCOV_LOCKED 1 +#else +#define GCOV_LOCKED 0 +#endif + +#endif /* !IN_LIBGCOV */ + +/* In gcov we want function linkage to be static. In the compiler we want + it extern, so that they can be accessed from elsewhere. In libgcov we + need these functions to be extern, so prefix them with __gcov. In + libgcov they must also be hidden so that the instance in the executable + is not also used in a DSO. */ +#if IN_LIBGCOV + +#ifndef __GCOV_KERNEL__ +#include "tconfig.h" +#endif /* __GCOV_KERNEL__ */ + +#define gcov_var __gcov_var +#define gcov_open __gcov_open +#define gcov_close __gcov_close +#define gcov_write_tag_length __gcov_write_tag_length +#define gcov_position __gcov_position +#define gcov_seek __gcov_seek +#define gcov_rewrite __gcov_rewrite +#define gcov_truncate __gcov_truncate +#define gcov_is_error __gcov_is_error +#define gcov_write_unsigned __gcov_write_unsigned +#define gcov_write_counter __gcov_write_counter +#define gcov_write_summary __gcov_write_summary +#define gcov_write_module_info __gcov_write_module_info +#define gcov_write_string __gcov_write_string +#define gcov_string_length __gcov_string_length +#define gcov_read_unsigned __gcov_read_unsigned +#define gcov_read_counter __gcov_read_counter +#define gcov_read_string __gcov_read_string +#define gcov_read_summary __gcov_read_summary +#define gcov_read_module_info __gcov_read_module_info +#define gcov_sort_n_vals __gcov_sort_n_vals +#define gcov_canonical_filename _gcov_canonical_filename +#define gcov_read_pmu_load_latency_info __gcov_read_pmu_load_latency_info +#define gcov_read_pmu_branch_mispredict_info __gcov_read_pmu_branch_mispredict_info +#define gcov_read_pmu_tool_header __gcov_read_pmu_tool_header +#define destroy_pmu_tool_header __destroy_pmu_tool_header + + +/* Poison these, so they don't accidentally slip in. */ +#pragma GCC poison gcov_write_tag gcov_write_length +#pragma GCC poison gcov_sync gcov_time gcov_magic + +#ifdef HAVE_GAS_HIDDEN +#define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden"))) +#else +#define ATTRIBUTE_HIDDEN +#endif + +#else + +#define ATTRIBUTE_HIDDEN + +#endif + +#ifndef GCOV_LINKAGE +#define GCOV_LINKAGE extern +#endif + +/* File suffixes. */ +#define GCOV_DATA_SUFFIX ".gcda" +#define GCOV_NOTE_SUFFIX ".gcno" + +/* File magic. Must not be palindromes. */ +#define GCOV_DATA_MAGIC ((gcov_unsigned_t)0x67636461) /* "gcda" */ +#define GCOV_NOTE_MAGIC ((gcov_unsigned_t)0x67636e6f) /* "gcno" */ + +/* gcov-iov.h is automatically generated by the makefile from + version.c, it looks like + #define GCOV_VERSION ((gcov_unsigned_t)0x89abcdef) +*/ +#include "gcov-iov.h" + +/* Convert a magic or version number to a 4 character string. */ +#define GCOV_UNSIGNED2STRING(ARRAY,VALUE) \ + ((ARRAY)[0] = (char)((VALUE) >> 24), \ + (ARRAY)[1] = (char)((VALUE) >> 16), \ + (ARRAY)[2] = (char)((VALUE) >> 8), \ + (ARRAY)[3] = (char)((VALUE) >> 0)) + +/* The record tags. Values [1..3f] are for tags which may be in either + file. Values [41..9f] for those in the note file and [a1..ff] for + the data file. The tag value zero is used as an explicit end of + file marker -- it is not required to be present. */ + +#define GCOV_TAG_FUNCTION ((gcov_unsigned_t)0x01000000) +#define GCOV_TAG_FUNCTION_LENGTH (3) +#define GCOV_TAG_BLOCKS ((gcov_unsigned_t)0x01410000) +#define GCOV_TAG_BLOCKS_LENGTH(NUM) (NUM) +#define GCOV_TAG_BLOCKS_NUM(LENGTH) (LENGTH) +#define GCOV_TAG_ARCS ((gcov_unsigned_t)0x01430000) +#define GCOV_TAG_ARCS_LENGTH(NUM) (1 + (NUM) * 2) +#define GCOV_TAG_ARCS_NUM(LENGTH) (((LENGTH) - 1) / 2) +#define GCOV_TAG_LINES ((gcov_unsigned_t)0x01450000) +#define GCOV_TAG_COUNTER_BASE ((gcov_unsigned_t)0x01a10000) +#define GCOV_TAG_COUNTER_LENGTH(NUM) ((NUM) * 2) +#define GCOV_TAG_COUNTER_NUM(LENGTH) ((LENGTH) / 2) +#define GCOV_TAG_OBJECT_SUMMARY ((gcov_unsigned_t)0xa1000000) +#define GCOV_TAG_PROGRAM_SUMMARY ((gcov_unsigned_t)0xa3000000) +#define GCOV_TAG_SUMMARY_LENGTH \ + (1 + GCOV_COUNTERS_SUMMABLE * (2 + 3 * 2)) +#define GCOV_TAG_MODULE_INFO ((gcov_unsigned_t)0xa4000000) +#define GCOV_TAG_PMU_LOAD_LATENCY_INFO ((gcov_unsigned_t)0xa5000000) +#define GCOV_TAG_PMU_LOAD_LATENCY_LENGTH(filename) \ + (gcov_string_length (filename) + 12 + 2) +#define GCOV_TAG_PMU_BRANCH_MISPREDICT_INFO ((gcov_unsigned_t)0xa7000000) +#define GCOV_TAG_PMU_BRANCH_MISPREDICT_LENGTH(filename) \ + (gcov_string_length (filename) + 5 + 2) +#define GCOV_TAG_PMU_TOOL_HEADER ((gcov_unsigned_t)0xa9000000) + +/* Counters that are collected. */ +#define GCOV_COUNTER_ARCS 0 /* Arc transitions. */ +#define GCOV_COUNTERS_SUMMABLE 1 /* Counters which can be + summaried. */ +#define GCOV_FIRST_VALUE_COUNTER 1 /* The first of counters used for value + profiling. They must form a consecutive + interval and their order must match + the order of HIST_TYPEs in + value-prof.h. */ +#define GCOV_COUNTER_V_INTERVAL 1 /* Histogram of value inside an interval. */ +#define GCOV_COUNTER_V_POW2 2 /* Histogram of exact power2 logarithm + of a value. */ +#define GCOV_COUNTER_V_SINGLE 3 /* The most common value of expression. */ +#define GCOV_COUNTER_V_DELTA 4 /* The most common difference between + consecutive values of expression. */ + +#define GCOV_COUNTER_V_INDIR 5 /* The most common indirect address */ +#define GCOV_COUNTER_AVERAGE 6 /* Compute average value passed to the + counter. */ +#define GCOV_COUNTER_IOR 7 /* IOR of the all values passed to + counter. */ +#define GCOV_COUNTER_ICALL_TOPNV 8 /* Top N value tracking for indirect calls */ +#define GCOV_LAST_VALUE_COUNTER 8 /* The last of counters used for value + profiling. */ +#define GCOV_COUNTER_DIRECT_CALL 9 /* Direct call counts. */ +#define GCOV_COUNTER_REUSE_DIST 10 /* Reuse distance measure. */ +#define GCOV_COUNTERS 11 + +/* Number of counters used for value profiling. */ +#define GCOV_N_VALUE_COUNTERS \ + (GCOV_LAST_VALUE_COUNTER - GCOV_FIRST_VALUE_COUNTER + 1) + + /* A list of human readable names of the counters */ +#define GCOV_COUNTER_NAMES {"arcs", "interval", "pow2", "single", \ + "delta","indirect_call", "average", "ior", \ + "indirect_call_topn", "direct_call", \ + "reuse_distance"} + +#define GCOV_ICALL_TOPN_VAL 2 /* Track two hottest callees */ +#define GCOV_ICALL_TOPN_NCOUNTS 9 /* The number of counter entries per icall callsite */ + /* Names of merge functions for counters. */ +#define GCOV_MERGE_FUNCTIONS {"__gcov_merge_add", \ + "__gcov_merge_add", \ + "__gcov_merge_add", \ + "__gcov_merge_single", \ + "__gcov_merge_delta", \ + "__gcov_merge_single", \ + "__gcov_merge_add", \ + "__gcov_merge_ior", \ + "__gcov_merge_icall_topn",\ + "__gcov_merge_dc",\ + "__gcov_merge_reusedist" } + +/* Convert a counter index to a tag. */ +#define GCOV_TAG_FOR_COUNTER(COUNT) \ + (GCOV_TAG_COUNTER_BASE + ((gcov_unsigned_t)(COUNT) << 17)) +/* Convert a tag to a counter. */ +#define GCOV_COUNTER_FOR_TAG(TAG) \ + ((unsigned)(((TAG) - GCOV_TAG_COUNTER_BASE) >> 17)) +/* Check whether a tag is a counter tag. */ +#define GCOV_TAG_IS_COUNTER(TAG) \ + (!((TAG) & 0xFFFF) && GCOV_COUNTER_FOR_TAG (TAG) < GCOV_COUNTERS) + +/* The tag level mask has 1's in the position of the inner levels, & + the lsb of the current level, and zero on the current and outer + levels. */ +#define GCOV_TAG_MASK(TAG) (((TAG) - 1) ^ (TAG)) + +/* Return nonzero if SUB is an immediate subtag of TAG. */ +#define GCOV_TAG_IS_SUBTAG(TAG,SUB) \ + (GCOV_TAG_MASK (TAG) >> 8 == GCOV_TAG_MASK (SUB) \ + && !(((SUB) ^ (TAG)) & ~GCOV_TAG_MASK(TAG))) + +/* Return nonzero if SUB is at a sublevel to TAG. */ +#define GCOV_TAG_IS_SUBLEVEL(TAG,SUB) \ + (GCOV_TAG_MASK (TAG) > GCOV_TAG_MASK (SUB)) + +/* Basic block flags. */ +#define GCOV_BLOCK_UNEXPECTED (1 << 1) + +/* Arc flags. */ +#define GCOV_ARC_ON_TREE (1 << 0) +#define GCOV_ARC_FAKE (1 << 1) +#define GCOV_ARC_FALLTHROUGH (1 << 2) + +/* Structured records. */ + +/* Cumulative counter data. */ +struct gcov_ctr_summary +{ + gcov_unsigned_t num; /* number of counters. */ + gcov_unsigned_t runs; /* number of program runs */ + gcov_type sum_all; /* sum of all counters accumulated. */ + gcov_type run_max; /* maximum value on a single run. */ + gcov_type sum_max; /* sum of individual run max values. */ +}; + +/* Object & program summary record. */ +struct gcov_summary +{ + gcov_unsigned_t checksum; /* checksum of program */ + struct gcov_ctr_summary ctrs[GCOV_COUNTERS_SUMMABLE]; +}; + +#define GCOV_MODULE_UNKNOWN_LANG 0 +#define GCOV_MODULE_C_LANG 1 +#define GCOV_MODULE_CPP_LANG 2 +#define GCOV_MODULE_FORT_LANG 3 + +#define GCOV_MODULE_ASM_STMTS (1 << 16) +#define GCOV_MODULE_LANG_MASK 0xffff + +enum print_newline {no_newline, add_newline}; + +/* Source module info. The data structure is used in + both runtime and profile-use phase. Make sure to allocate + enough space for the variable length member. */ +struct gcov_module_info +{ + gcov_unsigned_t ident; + gcov_unsigned_t is_primary; /* this is overloaded to mean two things: + (1) means FDO/LIPO in instrumented binary. + (2) means IS_PRIMARY in persistent file or + memory copy used in profile-use. */ + gcov_unsigned_t is_exported; + gcov_unsigned_t lang; /* lower 16 bits encode the language, and the upper + 16 bits enocde other attributes, such as whether + any assembler is present in the source, etc. */ + char *da_filename; + char *source_filename; + gcov_unsigned_t num_quote_paths; + gcov_unsigned_t num_bracket_paths; + gcov_unsigned_t num_cpp_defines; + gcov_unsigned_t num_cpp_includes; + gcov_unsigned_t num_cl_args; + char *string_array[1]; +}; + +extern struct gcov_module_info **module_infos; +extern unsigned primary_module_id; +#define PRIMARY_MODULE_EXPORTED \ + (module_infos[0]->is_exported \ + && !((module_infos[0]->lang & GCOV_MODULE_ASM_STMTS) \ + && flag_ripa_disallow_asm_modules)) + +/* Information about the hardware performance monitoring unit. */ +struct gcov_pmu_info +{ + const char *pmu_profile_filename; /* pmu profile filename */ + const char *pmu_tool; /* canonical pmu tool options */ + gcov_unsigned_t pmu_top_n_address; /* how many top addresses to symbolize */ +}; + +/* Information about the PMU tool header. */ +typedef struct gcov_pmu_tool_header { + char *host_cpu; + char *hostname; + char *kernel_version; + char *column_header; + char *column_description; + char *full_header; +} gcov_pmu_tool_header_t; + +/* Available only for PMUs which support PEBS or IBS using pfmon + tool. If any field here is changed, the length computation in + GCOV_TAG_PMU_LOAD_LATENCY_LENGTH must be updated as well. All + percentages are multiplied by 100 to make them out of 10000 and + only integer part is kept. */ +typedef struct gcov_pmu_load_latency_info +{ + gcov_unsigned_t counts; /* raw count of samples */ + gcov_unsigned_t self; /* per 10k of total samples */ + gcov_unsigned_t cum; /* per 10k cumulative weight */ + gcov_unsigned_t lt_10; /* per 10k with latency <= 10 cycles */ + gcov_unsigned_t lt_32; /* per 10k with latency <= 32 cycles */ + gcov_unsigned_t lt_64; /* per 10k with latency <= 64 cycles */ + gcov_unsigned_t lt_256; /* per 10k with latency <= 256 cycles */ + gcov_unsigned_t lt_1024; /* per 10k with latency <= 1024 cycles */ + gcov_unsigned_t gt_1024; /* per 10k with latency > 1024 cycles */ + gcov_unsigned_t wself; /* weighted average cost of this miss in cycles */ + gcov_type code_addr; /* the actual miss address (pc+1 for Intel) */ + gcov_unsigned_t line; /* line number corresponding to this miss */ + gcov_unsigned_t discriminator; /* discriminator information for this miss */ + char *filename; /* filename corresponding to this miss */ +} gcov_pmu_ll_info_t; + +/* This structure is used during runtime as well as in gcov. */ +typedef struct load_latency_infos +{ + /* An array describing the total number of load latency fields. */ + gcov_pmu_ll_info_t **ll_array; + /* The total number of entries in the load latency array. */ + unsigned ll_count; + /* The total number of entries currently allocated in the array. + Used for bookkeeping. */ + unsigned alloc_ll_count; + /* PMU tool header */ + gcov_pmu_tool_header_t *pmu_tool_header; +} ll_infos_t; + +/* Available only for PMUs which support PEBS or IBS using pfmon + tool. If any field here is changed, the length computation in + GCOV_TAG_PMU_BR_MISPREDICT_LENGTH must be updated as well. All + percentages are multiplied by 100 to make them out of 10000 and + only integer part is kept. */ +typedef struct gcov_pmu_branch_mispredict_info +{ + gcov_unsigned_t counts; /* raw count of samples */ + gcov_unsigned_t self; /* per 10k of total samples */ + gcov_unsigned_t cum; /* per 10k cumulative weight */ + gcov_type code_addr; /* the actual mispredict address */ + gcov_unsigned_t line; /* line number corresponding to this event */ + gcov_unsigned_t discriminator; /* discriminator for this event */ + char *filename; /* filename corresponding to this event */ +} gcov_pmu_brm_info_t; + +/* This structure is used during runtime as well as in gcov. */ +typedef struct branch_mispredict_infos +{ + /* An array describing the total number of mispredict entries. */ + gcov_pmu_brm_info_t **brm_array; + /* The total number of entries in the above array. */ + unsigned brm_count; + /* The total number of entries currently allocated in the array. + Used for bookkeeping. */ + unsigned alloc_brm_count; + /* PMU tool header */ + gcov_pmu_tool_header_t *pmu_tool_header; +} brm_infos_t; + +/* Structures embedded in coveraged program. The structures generated + by write_profile must match these. */ + +#if IN_LIBGCOV +/* Information about a single function. This uses the trailing array + idiom. The number of counters is determined from the counter_mask + in gcov_info. We hold an array of function info, so have to + explicitly calculate the correct array stride. */ + +struct gcov_fn_info +{ + gcov_unsigned_t ident; /* unique ident of function */ + gcov_unsigned_t lineno_checksum; /* function lineo_checksum */ + gcov_unsigned_t cfg_checksum; /* function cfg checksum */ + gcov_unsigned_t dc_offset; /* direct call offset */ + unsigned n_ctrs[0]; /* instrumented counters */ +}; + +/* Type of function used to merge counters. */ +typedef void (*gcov_merge_fn) (gcov_type *, gcov_unsigned_t); + +/* Information about counters. */ +struct gcov_ctr_info +{ + gcov_unsigned_t num; /* number of counters. */ + gcov_type *values; /* their values. */ + gcov_merge_fn merge; /* The function used to merge them. */ +}; + +/* Information about a single object file. */ +struct gcov_info +{ + gcov_unsigned_t version; /* expected version number */ + struct gcov_module_info *mod_info; /* addtional module info. */ + struct gcov_info *next; /* link to next, used by libgcov */ + + gcov_unsigned_t stamp; /* uniquifying time stamp */ + const char *filename; /* output file name */ + gcov_unsigned_t eof_pos; /* end position of profile data */ + unsigned n_functions; /* number of functions */ + const struct gcov_fn_info *functions; /* table of functions */ + + unsigned ctr_mask; /* mask of counters instrumented. */ + struct gcov_ctr_info counts[0]; /* count data. The number of bits + set in the ctr_mask field + determines how big this array + is. */ +}; + +/* Information about a single imported module. */ +struct dyn_imp_mod +{ + const struct gcov_info *imp_mod; + double weight; +}; + +/* Register a new object file module. */ +extern void __gcov_init (struct gcov_info *) ATTRIBUTE_HIDDEN; + +/* Called before fork, to avoid double counting. */ +extern void __gcov_flush (void) ATTRIBUTE_HIDDEN; + +/* The merge function that just sums the counters. */ +extern void __gcov_merge_add (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; + +/* The merge function to choose the most common value. */ +extern void __gcov_merge_single (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; + +/* The merge function to choose the most common difference between + consecutive values. */ +extern void __gcov_merge_delta (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; + +/* The merge function that just ors the counters together. */ +extern void __gcov_merge_ior (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; + +/* The merge function used for direct call counters. */ +extern void __gcov_merge_dc (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; + +/* The merge function used for reuse distance counters. */ +extern void __gcov_merge_reusedist (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; + +/* The merge function used for indirect call counters. */ +extern void __gcov_merge_icall_topn (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; + +/* The profiler functions. */ +extern void __gcov_interval_profiler (gcov_type *, gcov_type, int, unsigned); +extern void __gcov_pow2_profiler (gcov_type *, gcov_type); +extern void __gcov_one_value_profiler (gcov_type *, gcov_type); +extern void __gcov_indirect_call_profiler (gcov_type *, gcov_type, void *, void *); +extern void __gcov_indirect_call_topn_profiler (void *, void *, gcov_unsigned_t) ATTRIBUTE_HIDDEN; +extern void __gcov_direct_call_profiler (void *, void *, gcov_unsigned_t) ATTRIBUTE_HIDDEN; +extern void __gcov_average_profiler (gcov_type *, gcov_type); +extern void __gcov_ior_profiler (gcov_type *, gcov_type); +extern void __gcov_sort_n_vals (gcov_type *value_array, int n); + +/* Initialize/start/stop/dump performance monitoring unit (PMU) profile */ +void __gcov_init_pmu_profiler (struct gcov_pmu_info *) ATTRIBUTE_HIDDEN; +void __gcov_start_pmu_profiler (void) ATTRIBUTE_HIDDEN; +void __gcov_stop_pmu_profiler (void) ATTRIBUTE_HIDDEN; +void __gcov_end_pmu_profiler (int gcda_error) ATTRIBUTE_HIDDEN; + +#ifndef inhibit_libc +/* The wrappers around some library functions.. */ +extern pid_t __gcov_fork (void) ATTRIBUTE_HIDDEN; +extern int __gcov_execl (const char *, char *, ...) ATTRIBUTE_HIDDEN; +extern int __gcov_execlp (const char *, char *, ...) ATTRIBUTE_HIDDEN; +extern int __gcov_execle (const char *, char *, ...) ATTRIBUTE_HIDDEN; +extern int __gcov_execv (const char *, char *const []) ATTRIBUTE_HIDDEN; +extern int __gcov_execvp (const char *, char *const []) ATTRIBUTE_HIDDEN; +extern int __gcov_execve (const char *, char *const [], char *const []) + ATTRIBUTE_HIDDEN; +#endif + +#endif /* IN_LIBGCOV */ + +#if IN_LIBGCOV >= 0 + +/* Optimum number of gcov_unsigned_t's read from or written to disk. */ +#define GCOV_BLOCK_SIZE (1 << 10) + +struct gcov_var +{ + _GCOV_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 +}; + +/* In kernel mode, move gcov_var definition to gcov-io.c + to avoid dulipcate definitions. */ +#ifndef __GCOV_KERNEL__ +GCOV_LINKAGE struct gcov_var gcov_var ATTRIBUTE_HIDDEN; +#else +extern struct gcov_var gcov_var; +#endif + +/* Functions for reading and writing gcov files. In libgcov you can + open the file for reading then writing. Elsewhere you can open the + file either for reading or for writing. When reading a file you may + use the gcov_read_* functions, gcov_sync, gcov_position, & + gcov_error. When writing a file you may use the gcov_write + functions, gcov_seek & gcov_error. When a file is to be rewritten + you use the functions for reading, then gcov_rewrite then the + functions for writing. Your file may become corrupted if you break + these invariants. */ +#if IN_LIBGCOV +GCOV_LINKAGE int gcov_open (const char */*name*/) ATTRIBUTE_HIDDEN; +#else +GCOV_LINKAGE int gcov_open (const char */*name*/, int /*direction*/); +GCOV_LINKAGE int gcov_magic (gcov_unsigned_t, gcov_unsigned_t); +#endif +GCOV_LINKAGE int gcov_close (void) ATTRIBUTE_HIDDEN; + +/* Available everywhere. */ +static gcov_position_t gcov_position (void); +static int gcov_is_error (void); + +GCOV_LINKAGE const char *gcov_read_string (void) ATTRIBUTE_HIDDEN; +GCOV_LINKAGE gcov_unsigned_t gcov_read_unsigned (void) ATTRIBUTE_HIDDEN; +GCOV_LINKAGE gcov_type gcov_read_counter (void) ATTRIBUTE_HIDDEN; +GCOV_LINKAGE void gcov_read_summary (struct gcov_summary *) ATTRIBUTE_HIDDEN; +GCOV_LINKAGE char *gcov_canonical_filename (char *filename) ATTRIBUTE_HIDDEN; +GCOV_LINKAGE void +gcov_read_pmu_load_latency_info (gcov_pmu_ll_info_t *ll_info, + gcov_unsigned_t len) ATTRIBUTE_HIDDEN; +GCOV_LINKAGE void +gcov_read_pmu_branch_mispredict_info (gcov_pmu_brm_info_t *brm_info, + gcov_unsigned_t len) ATTRIBUTE_HIDDEN; +GCOV_LINKAGE void +gcov_read_pmu_tool_header (gcov_pmu_tool_header_t *tool_header, + gcov_unsigned_t len) ATTRIBUTE_HIDDEN; +#ifndef __GCOV_KERNEL__ +GCOV_LINKAGE float convert_unsigned_to_pct ( + const unsigned number) ATTRIBUTE_HIDDEN; +#endif /* __GCOV_KERNEL__ */ + +#if !IN_LIBGCOV && IN_GCOV != 1 +GCOV_LINKAGE void gcov_read_module_info (struct gcov_module_info *mod_info, + gcov_unsigned_t len) ATTRIBUTE_HIDDEN; +GCOV_LINKAGE void print_load_latency_line (FILE *fp, + const gcov_pmu_ll_info_t *ll_info, + const enum print_newline); +GCOV_LINKAGE void +print_branch_mispredict_line (FILE *fp, const gcov_pmu_brm_info_t *brm_info, + const enum print_newline); +GCOV_LINKAGE void print_pmu_tool_header (FILE *fp, + gcov_pmu_tool_header_t *tool_header, + const enum print_newline); +#endif + +#if IN_GCOV != 1 +GCOV_LINKAGE void destroy_pmu_tool_header (gcov_pmu_tool_header_t *tool_header) + ATTRIBUTE_HIDDEN; +#endif + +#if IN_LIBGCOV +/* Available only in libgcov */ +GCOV_LINKAGE void gcov_write_counter (gcov_type) ATTRIBUTE_HIDDEN; +GCOV_LINKAGE void gcov_write_tag_length (gcov_unsigned_t, gcov_unsigned_t) + ATTRIBUTE_HIDDEN; +GCOV_LINKAGE void gcov_write_summary (gcov_unsigned_t /*tag*/, + const struct gcov_summary *) + ATTRIBUTE_HIDDEN; + +GCOV_LINKAGE void gcov_write_module_infos (struct gcov_info *mod_info) + ATTRIBUTE_HIDDEN; +GCOV_LINKAGE const struct dyn_imp_mod ** +gcov_get_sorted_import_module_array (struct gcov_info *mod_info, unsigned *len) + ATTRIBUTE_HIDDEN; +static void gcov_rewrite (void); +GCOV_LINKAGE void gcov_seek (gcov_position_t /*position*/) ATTRIBUTE_HIDDEN; +GCOV_LINKAGE void gcov_truncate (void) ATTRIBUTE_HIDDEN; +GCOV_LINKAGE gcov_unsigned_t gcov_string_length (const char *) ATTRIBUTE_HIDDEN; +GCOV_LINKAGE unsigned gcov_gcda_file_size (struct gcov_info *); +#else +/* Available outside libgcov */ +GCOV_LINKAGE void gcov_sync (gcov_position_t /*base*/, + gcov_unsigned_t /*length */); +#endif + +#if !IN_GCOV +/* Available outside gcov */ +GCOV_LINKAGE void gcov_write_unsigned (gcov_unsigned_t) ATTRIBUTE_HIDDEN; +GCOV_LINKAGE void gcov_write_string (const char *) ATTRIBUTE_HIDDEN; +#endif + +#if !IN_GCOV && !IN_LIBGCOV +/* Available only in compiler */ +GCOV_LINKAGE gcov_position_t gcov_write_tag (gcov_unsigned_t); +GCOV_LINKAGE void gcov_write_length (gcov_position_t /*position*/); +#endif + +#if IN_GCOV > 0 +/* Available in gcov */ +GCOV_LINKAGE time_t gcov_time (void); +#endif + +/* Save the current position in the gcov file. */ + +static inline gcov_position_t +gcov_position (void) +{ + return gcov_var.start + gcov_var.offset; +} + +/* Return nonzero if the error flag is set. */ + +static inline 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. */ + +static inline void +gcov_rewrite (void) +{ + gcc_assert (gcov_var.mode > 0); + gcov_var.mode = -1; + gcov_var.start = 0; + gcov_var.offset = 0; + _GCOV_fseek (gcov_var.file, 0L, SEEK_SET); +} +#endif + +#endif /* IN_LIBGCOV >= 0 */ + +#endif /* GCC_GCOV_IO_H */ diff --git a/lib/gcc/mipsel-linux-android/4.6/gcov-src/gcov-iov.h b/lib/gcc/mipsel-linux-android/4.6/gcov-src/gcov-iov.h new file mode 100644 index 0000000..3c8c9ef --- /dev/null +++ b/lib/gcc/mipsel-linux-android/4.6/gcov-src/gcov-iov.h @@ -0,0 +1,4 @@ +/* Generated automatically by the program `build/gcov-iov' + from `4.6 (4 6) and prerelease (p)'. */ + +#define GCOV_VERSION ((gcov_unsigned_t)0x34303670) /* 406p */ diff --git a/lib/gcc/mipsel-linux-android/4.6/gcov-src/libgcov.c b/lib/gcc/mipsel-linux-android/4.6/gcov-src/libgcov.c new file mode 100644 index 0000000..613c1f4 --- /dev/null +++ b/lib/gcc/mipsel-linux-android/4.6/gcov-src/libgcov.c @@ -0,0 +1,1989 @@ +/* Routines required for instrumenting a program. */ +/* Compile this one with gcc. */ +/* Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, + 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009, 2010 + 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/>. */ + +/* Assume compiling for Linux Kernel if __KERNEL__ is defined. */ +#ifdef __KERNEL__ + /* Define MACROs to be used by kernel compilation. */ +# define L_gcov +# define L_gcov_interval_profiler +# define L_gcov_pow2_profiler +# define L_gcov_one_value_profiler +# define L_gcov_indirect_call_profiler +# define L_gcov_average_profiler +# define L_gcov_ior_profiler + +# define HAVE_CC_TLS 0 +# define __GCOV_KERNEL__ + +# define IN_LIBGCOV 1 +# define IN_GCOV 0 +#else /* __KERNEL__ */ +#include "tconfig.h" +#include "tsystem.h" +#include "coretypes.h" +#include "tm.h" +#endif /* __KERNEL__ */ + +#if 1 +#define THREAD_PREFIX __thread +#else +#define THREAD_PREFIX +#endif + +#ifndef __GCOV_KERNEL__ +#if defined(inhibit_libc) +#define IN_LIBGCOV (-1) +#else +#undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */ +#include <stdio.h> +#define IN_LIBGCOV 1 +#if defined(L_gcov) +#define GCOV_LINKAGE /* nothing */ +#endif +#endif +#endif /* __GCOV_KERNEL__ */ + +#include "gcov-io.h" + +#if defined(inhibit_libc) +/* If libc and its header files are not available, provide dummy functions. */ + +#ifdef L_gcov +void __gcov_init (struct gcov_info *p __attribute__ ((unused))) {} +void __gcov_flush (void) {} +#endif + +#ifdef L_gcov_merge_add +void __gcov_merge_add (gcov_type *counters __attribute__ ((unused)), + unsigned n_counters __attribute__ ((unused))) {} +#endif + +#ifdef L_gcov_merge_single +void __gcov_merge_single (gcov_type *counters __attribute__ ((unused)), + unsigned n_counters __attribute__ ((unused))) {} +#endif + +#ifdef L_gcov_merge_delta +void __gcov_merge_delta (gcov_type *counters __attribute__ ((unused)), + unsigned n_counters __attribute__ ((unused))) {} +#endif + +#else + +#ifndef __GCOV_KERNEL__ +#include <string.h> +#if GCOV_LOCKED +#include <fcntl.h> +#include <errno.h> +#include <sys/stat.h> +#endif +#endif /* __GCOV_KERNEL__ */ + +#ifdef L_gcov +#include "gcov-io.c" + +/* Utility function for outputing errors. */ +static int +gcov_error (const char *fmt, ...) +{ + int ret; + va_list argp; + va_start (argp, fmt); +#ifdef __GCOV_KERNEL__ + ret = vprintk (fmt, argp); +#else + ret = vfprintf (stderr, fmt, argp); +#endif + va_end (argp); + return ret; +} + +#ifndef __GCOV_KERNEL__ +/* Emitted in coverage.c. */ +extern char * __gcov_pmu_profile_filename; +extern char * __gcov_pmu_profile_options; +extern gcov_unsigned_t __gcov_pmu_top_n_address; + +/* Sampling rate. */ +extern gcov_unsigned_t __gcov_sampling_rate; +static int gcov_sampling_rate_initialized = 0; +void __gcov_set_sampling_rate (unsigned int rate); + +/* Set sampling rate to RATE. */ + +void __gcov_set_sampling_rate (unsigned int rate) +{ + __gcov_sampling_rate = rate; +} + +/* Per thread sample counter. */ +THREAD_PREFIX gcov_unsigned_t __gcov_sample_counter = 0; + +/* Chain of per-object gcov structures. */ +extern struct gcov_info *__gcov_list; + +/* Size of the longest file name. */ +static size_t gcov_max_filename = 0; +#endif /* __GCOV_KERNEL__ */ + +/* Unique identifier assigned to each module (object file). */ +static gcov_unsigned_t gcov_cur_module_id = 0; + +/* Pointer to the direct-call counters (per call-site counters). + Initialized by the caller. */ +THREAD_PREFIX gcov_type *__gcov_direct_call_counters ATTRIBUTE_HIDDEN; + +/* Direct call callee address. */ +THREAD_PREFIX void *__gcov_direct_call_callee ATTRIBUTE_HIDDEN; + +/* Pointer to the indirect-call counters (per call-site counters). + Initialized by the caller. */ +THREAD_PREFIX gcov_type *__gcov_indirect_call_topn_counters ATTRIBUTE_HIDDEN; + +/* Indirect call callee address. */ +THREAD_PREFIX void *__gcov_indirect_call_topn_callee ATTRIBUTE_HIDDEN; + +/* A program checksum allows us to distinguish program data for an + object file included in multiple programs. */ +static gcov_unsigned_t gcov_crc32; + +/* Dynamic call graph build and form module groups. */ +void __gcov_compute_module_groups (void) ATTRIBUTE_HIDDEN; +void __gcov_finalize_dyn_callgraph (void) ATTRIBUTE_HIDDEN; + +/* Profile summary for the gdca file, used in sanity check? */ +static struct gcov_summary all; + +/* Profile summary for this program in current exeuction. */ +static struct gcov_summary this_program; + +/* Profile summary for this object in current execuction. */ +static struct gcov_summary this_object; + +/* Merged profile summary for this program. */ +static struct gcov_summary program; + +/* Merged profile summary for this object. */ +static struct gcov_summary object; + +/* Record the position of summary info. */ +static gcov_position_t summary_pos = 0; + +/* Record the postion of eof. */ +static gcov_position_t eof_pos = 0; + +/* Number of chars in prefix to be stripped. */ +static int gcov_prefix_strip = 0; + +/* The length of path prefix. */ +static size_t prefix_length = 0; + +/* gi_filename is current object filename. + gi_filename_up points to the stripped filename. */ +static char *gi_filename, *gi_filename_up; + +static int gcov_open_by_filename (char * gi_filename); +static int gcov_exit_init (void); +static void gcov_dump_one_gcov (struct gcov_info *gi_ptr); + +/* Make sure path component of the given FILENAME exists, create + missing directories. FILENAME must be writable. + Returns zero on success, or -1 if an error occurred. */ + +static int +create_file_directory (char *filename) +{ +#if !defined(TARGET_POSIX_IO) && !defined(_WIN32) + (void) filename; + return -1; +#else + char *s; + + s = filename; + + if (HAS_DRIVE_SPEC(s)) + s += 2; + if (IS_DIR_SEPARATOR(*s)) + ++s; + for (; *s != '\0'; s++) + if (IS_DIR_SEPARATOR(*s)) + { + char sep = *s; + *s = '\0'; + + /* Try to make directory if it doesn't already exist. */ + if (access (filename, F_OK) == -1 +#ifdef TARGET_POSIX_IO + && mkdir (filename, 0755) == -1 +#else + && mkdir (filename) == -1 +#endif + /* The directory might have been made by another process. */ + && errno != EEXIST) + { + fprintf (stderr, "profiling:%s:Cannot create directory\n", + filename); + *s = sep; + return -1; + }; + + *s = sep; + }; + return 0; +#endif +} + +/* Open a file with the specified name. */ + +static int +gcov_open_by_filename (char * gi_filename) +{ + if (!gcov_open (gi_filename)) + { + /* Open failed likely due to missed directory. + Create directory and retry to open file. */ + if (create_file_directory (gi_filename)) + { + gcov_error ("profiling:%s:Skip\n", gi_filename); + return -1; + } + if (!gcov_open (gi_filename)) + { + gcov_error ("profiling:%s:Cannot open\n", gi_filename); + return -1; + } + } + return 0; +} + + +/* Determine whether a counter is active. */ + +static inline int +gcov_counter_active (const struct gcov_info *info, unsigned int type) +{ + return (1 << type) & info->ctr_mask; +} + +#ifndef __GCOV_KERNEL__ +/* 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 __attribute__ ((unused)), + 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); + + if (filename) + gcov_error ("profiling:%s:Version mismatch - expected %.4s got %.4s\n", + filename, e, v); + else + gcov_error ("profiling:Version mismatch - expected %.4s got %.4s\n", e, v); + return 0; + } + return 1; +} + +#define GCOV_GET_FILENAME gcov_strip_leading_dirs + +/* Strip GCOV_PREFIX_STRIP levels of leading '/' from FILENAME and + put the result into GI_FILENAME_UP. */ + +static void +gcov_strip_leading_dirs (int prefix_length, int gcov_prefix_strip, + const char *filename, char *gi_filename_up) +{ + /* Avoid to add multiple drive letters into combined path. */ + if (prefix_length != 0 && HAS_DRIVE_SPEC(filename)) + filename += 2; + + /* Build relocated filename, stripping off leading + directories from the initial filename if requested. */ + if (gcov_prefix_strip > 0) + { + int level = 0; + const char *s = filename; + if (IS_DIR_SEPARATOR(*s)) + ++s; + + /* Skip selected directory levels. */ + for (; (*s != '\0') && (level < gcov_prefix_strip); s++) + if (IS_DIR_SEPARATOR(*s)) + { + filename = s; + level++; + } + } + /* Update complete filename with stripped original. */ + if (prefix_length != 0 && !IS_DIR_SEPARATOR (*filename)) + { + /* If prefix is given, add directory separator. */ + strcpy (gi_filename_up, "/"); + strcpy (gi_filename_up + 1, filename); + } + else + strcpy (gi_filename_up, filename); +} + +/* This function allocates the space to store current file name. */ + +static void +gcov_alloc_filename (void) +{ + /* Get file name relocation prefix. Non-absolute values are ignored. */ + char *gcov_prefix = 0; + + prefix_length = 0; + gcov_prefix_strip = 0; + + { + /* Check if the level of dirs to strip off specified. */ + char *tmp = getenv ("GCOV_PREFIX_STRIP"); + if (tmp) + { + gcov_prefix_strip = atoi (tmp); + /* Do not consider negative values. */ + if (gcov_prefix_strip < 0) + gcov_prefix_strip = 0; + } + } + /* Get file name relocation prefix. Non-absolute values are ignored. */ + gcov_prefix = getenv ("GCOV_PREFIX"); + if (gcov_prefix) + { + prefix_length = strlen(gcov_prefix); + + /* Remove an unnecessary trailing '/' */ + if (IS_DIR_SEPARATOR (gcov_prefix[prefix_length - 1])) + prefix_length--; + } + else + prefix_length = 0; + + /* If no prefix was specified and a prefix stip, then we assume + relative. */ + if (gcov_prefix_strip != 0 && prefix_length == 0) + { + gcov_prefix = "."; + prefix_length = 1; + } + + /* Allocate and initialize the filename scratch space. */ + gi_filename = (char *) malloc (prefix_length + gcov_max_filename + 2); + if (prefix_length) + memcpy (gi_filename, gcov_prefix, prefix_length); + + gi_filename_up = gi_filename + prefix_length; +} + +/* Stop the pmu profiler and dump pmu profile info into the global file. */ + +static void +pmu_profile_stop (void) +{ + const char *pmu_profile_filename = __gcov_pmu_profile_filename; + const char *pmu_options = __gcov_pmu_profile_options; + size_t filename_length; + int gcda_error; + + if (!pmu_profile_filename || !pmu_options) + return; + + __gcov_stop_pmu_profiler (); + + filename_length = strlen (pmu_profile_filename); + if (filename_length > gcov_max_filename) + gcov_max_filename = filename_length; + /* Allocate and initialize the filename scratch space. */ + gcov_alloc_filename (); + GCOV_GET_FILENAME (prefix_length, gcov_prefix_strip, pmu_profile_filename, + gi_filename_up); + /* Open the gcda file for writing. We don't support merge yet. */ + gcda_error = gcov_open_by_filename (gi_filename); + __gcov_end_pmu_profiler (gcda_error); + if ((gcda_error = gcov_close ())) + gcov_error (gcda_error < 0 ? "pmu_profile_stop:%s:Overflow writing\n" : + "pmu_profile_stop:%s:Error writing\n", + gi_filename); +} + +/* 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); + } +} + +/* Write imported files (auxiliary modules) for primary module GI_PTR + into file GI_FILENAME. */ + +static void +gcov_write_import_file (char *gi_filename, struct gcov_info *gi_ptr) +{ + char *gi_imports_filename; + const char *gcov_suffix; + FILE *imports_file; + size_t prefix_length, suffix_length; + + gcov_suffix = getenv ("GCOV_IMPORTS_SUFFIX"); + if (!gcov_suffix || !strlen (gcov_suffix)) + gcov_suffix = ".imports"; + suffix_length = strlen (gcov_suffix); + prefix_length = strlen (gi_filename); + gi_imports_filename = (char *) alloca (prefix_length + suffix_length + 1); + memset (gi_imports_filename, 0, prefix_length + suffix_length + 1); + memcpy (gi_imports_filename, gi_filename, prefix_length); + memcpy (gi_imports_filename + prefix_length, gcov_suffix, suffix_length); + imports_file = fopen (gi_imports_filename, "w"); + if (imports_file) + { + const struct dyn_imp_mod **imp_mods; + unsigned i, imp_len; + imp_mods = gcov_get_sorted_import_module_array (gi_ptr, &imp_len); + if (imp_mods) + { + for (i = 0; i < imp_len; i++) + { + fprintf (imports_file, "%s\n", + imp_mods[i]->imp_mod->mod_info->source_filename); + fprintf (imports_file, "%s%s\n", + imp_mods[i]->imp_mod->mod_info->da_filename, GCOV_DATA_SUFFIX); + } + free (imp_mods); + } + fclose (imports_file); + } +} + +static void +gcov_dump_module_info (void) +{ + struct gcov_info *gi_ptr; + + __gcov_compute_module_groups (); + + /* Now write out module group info. */ + for (gi_ptr = __gcov_list; gi_ptr; gi_ptr = gi_ptr->next) + { + int error; + + GCOV_GET_FILENAME (prefix_length, gcov_prefix_strip, gi_ptr->filename, + gi_filename_up); + error = gcov_open_by_filename (gi_filename); + if (error != 0) + continue; + + /* Overwrite the zero word at the of the file. */ + gcov_rewrite (); + gcov_seek (gi_ptr->eof_pos); + + gcov_write_module_infos (gi_ptr); + gcov_truncate (); + + if ((error = gcov_close ())) + gcov_error (error < 0 ? "profiling:%s:Overflow writing\n" : + "profiling:%s:Error writing\n", + gi_filename); + gcov_write_import_file (gi_filename, gi_ptr); + } + __gcov_finalize_dyn_callgraph (); +} + +/* Dump the coverage counts. 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 +gcov_exit (void) +{ + struct gcov_info *gi_ptr; + int dump_module_info; + + /* Stop and write the PMU profile data into the global file. */ + pmu_profile_stop (); + + dump_module_info = gcov_exit_init (); + + for (gi_ptr = __gcov_list; gi_ptr; gi_ptr = gi_ptr->next) + gcov_dump_one_gcov (gi_ptr); + + if (dump_module_info) + gcov_dump_module_info (); + + free (gi_filename); +} + +/* 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 (!gcov_sampling_rate_initialized) + { + const char* env_value_str = getenv ("GCOV_SAMPLING_RATE"); + if (env_value_str) + { + int env_value_int = atoi(env_value_str); + if (env_value_int >= 1) + __gcov_sampling_rate = env_value_int; + } + gcov_sampling_rate_initialized = 1; + } + + if (!info->version) + return; + + if (gcov_version (info, info->version, 0)) + { + const char *ptr = info->filename; + gcov_unsigned_t crc32 = gcov_crc32; + size_t filename_length = strlen (info->filename); + struct gcov_pmu_info pmu_info; + + /* Refresh the longest file name information. */ + if (filename_length > gcov_max_filename) + gcov_max_filename = filename_length; + + /* Initialize the pmu profiler. */ + pmu_info.pmu_profile_filename = __gcov_pmu_profile_filename; + pmu_info.pmu_tool = __gcov_pmu_profile_options; + pmu_info.pmu_top_n_address = __gcov_pmu_top_n_address; + __gcov_init_pmu_profiler (&pmu_info); + if (pmu_info.pmu_profile_filename) + { + /* Refresh the longest file name information. */ + filename_length = strlen (pmu_info.pmu_profile_filename); + if (filename_length > gcov_max_filename) + gcov_max_filename = filename_length; + } + + /* Assign the module ID (starting at 1). */ + info->mod_info->ident = (++gcov_cur_module_id); + gcc_assert (EXTRACT_MODULE_ID_FROM_GLOBAL_ID (GEN_FUNC_GLOBAL_ID ( + info->mod_info->ident, 0)) + == info->mod_info->ident); + + do + { + unsigned ix; + gcov_unsigned_t value = *ptr << 24; + + for (ix = 8; ix--; value <<= 1) + { + gcov_unsigned_t feedback; + + feedback = (value ^ crc32) & 0x80000000 ? 0x04c11db7 : 0; + crc32 <<= 1; + crc32 ^= feedback; + } + } while (*ptr++); + + gcov_crc32 = crc32; + + if (!__gcov_list) + { + atexit (gcov_exit); + /* Start pmu profiler. */ + __gcov_start_pmu_profiler (); + } + + info->next = __gcov_list; + __gcov_list = info; + } + info->version = 0; +} + +/* Called before fork or exec - write out profile information gathered so + far and reset it to zero. This avoids duplication or loss of the + profile information gathered so far. */ + +void +__gcov_flush (void) +{ + const struct gcov_info *gi_ptr; + + __gcov_stop_pmu_profiler (); + gcov_exit (); + for (gi_ptr = __gcov_list; gi_ptr; gi_ptr = gi_ptr->next) + { + unsigned t_ix; + const struct gcov_ctr_info *ci_ptr; + + for (t_ix = 0, ci_ptr = gi_ptr->counts; t_ix != GCOV_COUNTERS; t_ix++) + if (gcov_counter_active (gi_ptr, t_ix)) + { + memset (ci_ptr->values, 0, sizeof (gcov_type) * ci_ptr->num); + ci_ptr++; + } + } + __gcov_start_pmu_profiler (); +} + +#else /* __GCOV_KERNEL__ */ + +#define GCOV_GET_FILENAME gcov_get_filename + +/* Copy the filename to the buffer. */ + +static inline void +gcov_get_filename (int prefix_length __attribute__ ((unused)), + int gcov_prefix_strip __attribute__ ((unused)), + const char *filename, char *gi_filename_up) +{ + strcpy (gi_filename_up, filename); +} + +/* 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) +{ + /* Empty */ +} + +/* Reserves a buffer to store the name of the file being processed. */ +static char _kernel_gi_filename[520]; + +/* This function allocates the space to store current file name. */ + +static void +gcov_alloc_filename (void) +{ + prefix_length = 0; + gcov_prefix_strip = 0; + gi_filename = _kernel_gi_filename; + gi_filename_up = _kernel_gi_filename; +} + +#endif /* __GCOV_KERNEL__ */ + +/* Determine number of active counters in gcov_info INFO, + the counter arrays are stored in VALUES if the coming + value of VALUES !=0. If FLAG_SORT_ICALL_TOPN_COUNTER !=0, + the icall_topn_counter in INFO will be sorted. + Return: the number of active counter types. */ + +static unsigned int +gcov_counter_array (const struct gcov_info *info, + gcov_type *values[GCOV_COUNTERS], + int flag_sort_icall_topn_counter) +{ + unsigned int i; + unsigned int result = 0; + + for (i = 0; i < GCOV_COUNTERS; i++) { + if (gcov_counter_active (info, i)) + { + if (values) + values[result] = info->counts[result].values; + if (flag_sort_icall_topn_counter && + (i == GCOV_COUNTER_ICALL_TOPNV)) + gcov_sort_icall_topn_counter (&info->counts[result]); + result++; + } + } + return result; +} + +/* Compute object summary recored in gcov_info INFO. The result is + stored in OBJ_SUM. Note that the caller is responsible for + zeroing out OBJ_SUM, otherwise the summary is accumulated. */ + +static void +gcov_object_summary (struct gcov_info *info, + struct gcov_summary *obj_sum) +{ + const struct gcov_ctr_info *ci_ptr; + struct gcov_ctr_summary *cs_ptr; + gcov_unsigned_t c_num; + unsigned t_ix; + + /* Totals for this object file. */ + ci_ptr = info->counts; + for (t_ix = 0; t_ix < GCOV_COUNTERS_SUMMABLE; t_ix++) + { + if (!gcov_counter_active (info, t_ix)) + continue; + + cs_ptr = &(obj_sum->ctrs[t_ix]); + cs_ptr->num += 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++; + } +} + +/* Merge with existing gcda file in the same directory to avoid + excessive growthe of the files. */ + +static int +gcov_merge_gcda_file (struct gcov_info *info, + gcov_type *values[GCOV_COUNTERS], + unsigned fi_stride) +{ + struct gcov_ctr_summary *cs_obj, *cs_tobj, *cs_prg, *cs_tprg, *cs_all; + unsigned t_ix, f_ix; + +#ifndef __GCOV_KERNEL__ + const struct gcov_fn_info *fi_ptr; + unsigned c_ix, n_counts; + int error = 0; + gcov_unsigned_t tag, length; + + eof_pos = 0; + summary_pos = 0; + + 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", gi_filename); + goto read_fatal; + } + length = gcov_read_unsigned (); + if (!gcov_version (info, length, gi_filename)) + goto read_fatal; + + length = gcov_read_unsigned (); + if (length != info->stamp) + /* Read from a different compilation. Overwrite the file. */ + goto rewrite; + + /* Merge execution counts for each function. */ + for (f_ix = 0; f_ix < info->n_functions; f_ix++) + { + fi_ptr = (const struct gcov_fn_info *) + ((const char *) info->functions + f_ix * fi_stride); + tag = gcov_read_unsigned (); + length = gcov_read_unsigned (); + + /* Check function. */ + if (tag != GCOV_TAG_FUNCTION + || length != GCOV_TAG_FUNCTION_LENGTH + || gcov_read_unsigned () != fi_ptr->ident + || gcov_read_unsigned () != fi_ptr->lineno_checksum + || gcov_read_unsigned () != fi_ptr->cfg_checksum) + goto read_mismatch; + + c_ix = 0; + for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++) + { + gcov_merge_fn merge; + + if (!((1 << t_ix) & info->ctr_mask)) + continue; + + n_counts = fi_ptr->n_ctrs[c_ix]; + merge = info->counts[c_ix].merge; + + tag = gcov_read_unsigned (); + length = gcov_read_unsigned (); + if (tag != GCOV_TAG_FOR_COUNTER (t_ix) + || length != GCOV_TAG_COUNTER_LENGTH (n_counts)) + goto read_mismatch; + (*merge) (values[c_ix], n_counts); + values[c_ix] += n_counts; + c_ix++; + } + if ((error = gcov_is_error ())) + goto read_error; + } + + f_ix = ~0u; + /* Check program & object summary. */ + while (1) + { + int is_program; + + eof_pos = gcov_position (); + tag = gcov_read_unsigned (); + if (!tag) + break; + + length = gcov_read_unsigned (); + is_program = tag == GCOV_TAG_PROGRAM_SUMMARY; + if (length != GCOV_TAG_SUMMARY_LENGTH + || (!is_program && tag != GCOV_TAG_OBJECT_SUMMARY)) + goto read_mismatch; + gcov_read_summary (is_program ? &program : &object); + if ((error = gcov_is_error ())) + goto read_error; + if (is_program && program.checksum == gcov_crc32) + { + summary_pos = eof_pos; + goto rewrite; + } + } + } + + goto rewrite; + +read_error:; + gcov_error (error < 0 ? "profiling:%s:Overflow merging\n" + : "profiling:%s:Error merging\n", gi_filename); + goto read_fatal; + +#endif /* __GCOV_KERNEL__ */ + + goto rewrite; + +read_mismatch:; + gcov_error ("profiling:%s:Merge mismatch for %s\n", gi_filename, + f_ix + 1 ? "function" : "summaries"); + goto read_fatal; /* work-around the compiler warning */ + +read_fatal:; + gcov_close (); + return 1; + +rewrite:; + gcov_rewrite (); + if (!summary_pos) + memset (&program, 0, sizeof (program)); + + /* Merge the summaries. */ + f_ix = ~0u; + for (t_ix = 0; t_ix < GCOV_COUNTERS_SUMMABLE; t_ix++) + { + cs_obj = &object.ctrs[t_ix]; + cs_tobj = &this_object.ctrs[t_ix]; + cs_prg = &program.ctrs[t_ix]; + cs_tprg = &this_program.ctrs[t_ix]; + cs_all = &all.ctrs[t_ix]; + + if ((1 << t_ix) & info->ctr_mask) + { + if (!cs_obj->runs++) + cs_obj->num = cs_tobj->num; + else if (cs_obj->num != cs_tobj->num) + goto read_mismatch; + cs_obj->sum_all += cs_tobj->sum_all; + if (cs_obj->run_max < cs_tobj->run_max) + cs_obj->run_max = cs_tobj->run_max; + cs_obj->sum_max += cs_tobj->run_max; + + if (!cs_prg->runs++) + cs_prg->num = cs_tprg->num; + else if (cs_prg->num != cs_tprg->num) + goto read_mismatch; + 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; + } + else if (cs_obj->num || cs_prg->num) + goto read_mismatch; + + if (!cs_all->runs && cs_prg->runs) + memcpy (cs_all, cs_prg, sizeof (*cs_all)); + else if (!all.checksum + && (!GCOV_LOCKED || cs_all->runs == cs_prg->runs) + && memcmp (cs_all, cs_prg, sizeof (*cs_all))) + { + gcov_error ("profiling:%s:Invocation mismatch - " + "some data files may have been removed%s", + gi_filename, GCOV_LOCKED + ? "" : " or concurrent update without locking support"); + all.checksum = ~0u; + } + } + + return 0; +} + +/* Calculate the function_info stride. This depends on the + number of counter types being measured. + NUM_COUNTER_TYPES is number of counter types recorded. + Return: the number of bytes for accessing next fn_info + (aligned to gcov_fn_info). */ + +static unsigned +gcov_compute_fi_stride (unsigned num_counter_types) +{ + unsigned fi_stride; + + fi_stride = offsetof (struct gcov_fn_info, n_ctrs) + + num_counter_types * sizeof (unsigned); + if (__alignof__ (struct gcov_fn_info) > sizeof (unsigned)) + { + fi_stride += __alignof__ (struct gcov_fn_info) - 1; + fi_stride &= ~(__alignof__ (struct gcov_fn_info) - 1); + } + return fi_stride; +} + +/* This function returns the size of gcda file to be written. Note + the size is in units of gcov_type. */ + +GCOV_LINKAGE unsigned +gcov_gcda_file_size (struct gcov_info *gi_ptr) +{ + unsigned size; + const struct gcov_fn_info *fi_ptr; + unsigned f_ix, t_ix, c_ix; + unsigned n_counts; + unsigned fi_stride; + gcov_type *values[GCOV_COUNTERS]; + + c_ix = gcov_counter_array (gi_ptr, values, 0); + fi_stride = gcov_compute_fi_stride (c_ix); + + /* GCOV_DATA_MAGIC, GCOV_VERSION and time_stamp. */ + size = 3; + + /* size for each function. */ + for (f_ix = 0; f_ix < gi_ptr->n_functions; f_ix++) + { + fi_ptr = (const struct gcov_fn_info *) + ((const char *) gi_ptr->functions + f_ix * fi_stride); + + size += 2 /* tag_length itself */ + + GCOV_TAG_FUNCTION_LENGTH; /* ident, lineno_cksum, cfg_cksm */ + + c_ix = 0; + for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++) + { + if (!((1 << t_ix) & gi_ptr->ctr_mask)) + continue; + + n_counts = fi_ptr->n_ctrs[c_ix]; + size += 2 + GCOV_TAG_COUNTER_LENGTH (n_counts); + c_ix++; + } + } + + /* Object summary. */ + size += 2 + GCOV_TAG_SUMMARY_LENGTH; + + /* Program summary. */ + size += 2 + GCOV_TAG_SUMMARY_LENGTH; + + size += 1; + + return size*4; +} + +/* Write profile data (including summary and module grouping information, + if available, to file. */ + +static void +gcov_write_gcda_file (struct gcov_info *gi_ptr, + unsigned fi_stride) +{ + const struct gcov_fn_info *fi_ptr; + gcov_type *values[GCOV_COUNTERS]; + unsigned t_ix, c_ix, f_ix, n_counts; + int error = 0; + + /* Write out the data. */ + gcov_write_tag_length (GCOV_DATA_MAGIC, GCOV_VERSION); + gcov_write_unsigned (gi_ptr->stamp); + + gcov_counter_array (gi_ptr, values, 0); + + /* Write execution counts for each function. */ + for (f_ix = 0; f_ix < gi_ptr->n_functions; f_ix++) + { + fi_ptr = (const struct gcov_fn_info *) + ((const char *) gi_ptr->functions + f_ix * fi_stride); + + /* Announce function. */ + gcov_write_tag_length (GCOV_TAG_FUNCTION, GCOV_TAG_FUNCTION_LENGTH); + gcov_write_unsigned (fi_ptr->ident); + gcov_write_unsigned (fi_ptr->lineno_checksum); + gcov_write_unsigned (fi_ptr->cfg_checksum); + + c_ix = 0; + for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++) + { + gcov_type *c_ptr; + + if (!((1 << t_ix) & gi_ptr->ctr_mask)) + continue; + + n_counts = fi_ptr->n_ctrs[c_ix]; + + gcov_write_tag_length (GCOV_TAG_FOR_COUNTER (t_ix), + GCOV_TAG_COUNTER_LENGTH (n_counts)); + c_ptr = values[c_ix]; + while (n_counts--) + gcov_write_counter (*c_ptr++); + + values[c_ix] = c_ptr; + c_ix++; + } + } + + /* Object file summary. */ + gcov_write_summary (GCOV_TAG_OBJECT_SUMMARY, &object); + + /* Generate whole program statistics. */ + program.checksum = gcov_crc32; + if (eof_pos) + gcov_seek (eof_pos); + gcov_write_summary (GCOV_TAG_PROGRAM_SUMMARY, &program); + if (!summary_pos) + gcov_write_unsigned (0); + + /* TODO: there is a problem here -- if there are other program + summary data after the matching one, setting eof_pos to this + position means that the module info table will overwrite the + those other program summary. It also means a mismatch error + may occur at the next merge if no matching program summary is + found before the module info data. */ + if (!summary_pos) + gi_ptr->eof_pos = gcov_position () - 1; + else + gi_ptr->eof_pos = gcov_position (); + + if ((error = gcov_close ())) + gcov_error (error < 0 ? + "profiling:%s:Overflow writing\n" : + "profiling:%s:Error writing\n", + gi_filename); +} + +/* Do some preparation work before calling the actual dumping + routine. + Return: 1 when module grouping info needs to be dumped, + 0 otherwise. */ + +static int +gcov_exit_init (void) +{ + struct gcov_info *gi_ptr; + int dump_module_info = 0; + + dump_module_info = 0; + gcov_prefix_strip = 0; + + memset (&all, 0, sizeof (all)); + + /* Find the totals for this execution. */ + memset (&this_program, 0, sizeof (this_program)); + for (gi_ptr = __gcov_list; gi_ptr; gi_ptr = gi_ptr->next) + { + gcov_object_summary (gi_ptr, &this_program); + + /* The IS_PRIMARY field is overloaded to indicate if this module + is FDO/LIPO. */ + dump_module_info |= gi_ptr->mod_info->is_primary; + } + + gcov_alloc_filename (); + + return dump_module_info; +} + +/* Dump one entry in the gcov_info list (for one object). */ + +static void +gcov_dump_one_gcov (struct gcov_info *gi_ptr) +{ + gcov_type *values[GCOV_COUNTERS]; + unsigned fi_stride; + unsigned c_ix; + int ret; + + memset (&this_object, 0, sizeof (this_object)); + memset (&object, 0, sizeof (object)); + + gcov_object_summary (gi_ptr, &this_object); + + c_ix = gcov_counter_array (gi_ptr, values, 1); + + fi_stride = gcov_compute_fi_stride (c_ix); + + GCOV_GET_FILENAME (prefix_length, gcov_prefix_strip, gi_ptr->filename, + gi_filename_up); + + if (gcov_open_by_filename (gi_filename) == -1) + return; + + /* Now merge this file. */ + ret = gcov_merge_gcda_file (gi_ptr, values, fi_stride); + if (ret != 0 ) return; + + gcov_write_gcda_file (gi_ptr, fi_stride); +} + +#endif /* L_gcov */ + +#ifdef L_gcov_merge_add +/* The profile merging function that just adds the counters. It is given + an array COUNTERS of N_COUNTERS old counters and it reads the same number + of counters from the gcov file. */ +void +__gcov_merge_add (gcov_type *counters, unsigned n_counters) +{ + for (; n_counters; counters++, n_counters--) + *counters += gcov_read_counter (); +} +#endif /* L_gcov_merge_add */ + +#ifdef L_gcov_merge_ior +/* The profile merging function that just adds the counters. It is given + an array COUNTERS of N_COUNTERS old counters and it reads the same number + of counters from the gcov file. */ +void +__gcov_merge_ior (gcov_type *counters, unsigned n_counters) +{ + for (; n_counters; counters++, n_counters--) + *counters |= gcov_read_counter (); +} +#endif + +#ifdef L_gcov_merge_reusedist + +/* Return the weighted arithmetic mean of two values. */ + +static gcov_type +__gcov_weighted_mean2 (gcov_type value1, gcov_type count1, + gcov_type value2, gcov_type count2) +{ + if (count1 + count2 == 0) + return 0; + else + return (value1 * count1 + value2 * count2) / (count1 + count2); +} + +void +__gcov_merge_reusedist (gcov_type *counters, unsigned n_counters) +{ + unsigned i; + + gcc_assert(!(n_counters % 4)); + + for (i = 0; i < n_counters; i += 4) + { + /* Decode current values. */ + gcov_type c_mean_dist = counters[i]; + gcov_type c_mean_size = counters[i+1]; + gcov_type c_count = counters[i+2]; + gcov_type c_dist_x_size = counters[i+3]; + + /* Read and decode values in file. */ + gcov_type f_mean_dist = __gcov_read_counter (); + gcov_type f_mean_size = __gcov_read_counter (); + gcov_type f_count = __gcov_read_counter (); + gcov_type f_dist_x_size = __gcov_read_counter (); + + /* Compute aggregates. */ + gcov_type a_mean_dist = __gcov_weighted_mean2 ( + f_mean_dist, f_count, c_mean_dist, c_count); + gcov_type a_mean_size = __gcov_weighted_mean2 ( + f_mean_size, f_count, c_mean_size, c_count); + gcov_type a_count = f_count + c_count; + gcov_type a_dist_x_size = f_dist_x_size + c_dist_x_size; + + /* Encode back into counters. */ + counters[i] = a_mean_dist; + counters[i+1] = a_mean_size; + counters[i+2] = a_count; + counters[i+3] = a_dist_x_size; + } +} + +#endif + +#ifdef L_gcov_merge_dc + +/* Returns 1 if the function global id GID is not valid. */ + +static int +__gcov_is_gid_insane (gcov_type gid) +{ + if (EXTRACT_MODULE_ID_FROM_GLOBAL_ID (gid) == 0 + || EXTRACT_FUNC_ID_FROM_GLOBAL_ID (gid) == 0) + return 1; + return 0; +} + +/* The profile merging function used for merging direct call counts + This function is given array COUNTERS of N_COUNTERS old counters and it + reads the same number of counters from the gcov file. */ + +void +__gcov_merge_dc (gcov_type *counters, unsigned n_counters) +{ + unsigned i; + + gcc_assert (!(n_counters % 2)); + for (i = 0; i < n_counters; i += 2) + { + gcov_type global_id = gcov_read_counter (); + gcov_type call_count = gcov_read_counter (); + + /* Note that global id counter may never have been set if no calls were + made from this call-site. */ + if (counters[i] && global_id) + { + /* TODO race condition requires us do the following correction. */ + if (__gcov_is_gid_insane (counters[i])) + counters[i] = global_id; + else if (__gcov_is_gid_insane (global_id)) + global_id = counters[i]; + + gcc_assert (counters[i] == global_id); + } + else if (global_id) + counters[i] = global_id; + + counters[i + 1] += call_count; + + /* Reset. */ + if (__gcov_is_gid_insane (counters[i])) + counters[i] = counters[i + 1] = 0; + + /* Assert that the invariant (global_id == 0) <==> (call_count == 0) + holds true after merging. */ + if (counters[i] == 0) + counters[i+1] = 0; + if (counters[i + 1] == 0) + counters[i] = 0; + } +} +#endif + +#ifdef L_gcov_merge_icall_topn +/* The profile merging function used for merging indirect call counts + This function is given array COUNTERS of N_COUNTERS old counters and it + reads the same number of counters from the gcov file. */ + +void +__gcov_merge_icall_topn (gcov_type *counters, unsigned n_counters) +{ + unsigned i, j, k, m; + + gcc_assert (!(n_counters % GCOV_ICALL_TOPN_NCOUNTS)); + for (i = 0; i < n_counters; i += GCOV_ICALL_TOPN_NCOUNTS) + { + gcov_type *value_array = &counters[i + 1]; + unsigned tmp_size = 2 * (GCOV_ICALL_TOPN_NCOUNTS - 1); + gcov_type *tmp_array + = (gcov_type *) alloca (tmp_size * sizeof (gcov_type)); + + for (j = 0; j < tmp_size; j++) + tmp_array[j] = 0; + + for (j = 0; j < GCOV_ICALL_TOPN_NCOUNTS - 1; j += 2) + { + tmp_array[j] = value_array[j]; + tmp_array[j + 1] = value_array [j + 1]; + } + + /* Skip the number_of_eviction entry. */ + gcov_read_counter (); + for (k = 0; k < GCOV_ICALL_TOPN_NCOUNTS - 1; k += 2) + { + int found = 0; + gcov_type global_id = gcov_read_counter (); + gcov_type call_count = gcov_read_counter (); + for (m = 0; m < j; m += 2) + { + if (tmp_array[m] == global_id) + { + found = 1; + tmp_array[m + 1] += call_count; + break; + } + } + if (!found) + { + tmp_array[j] = global_id; + tmp_array[j + 1] = call_count; + j += 2; + } + } + /* Now sort the temp array */ + gcov_sort_n_vals (tmp_array, j); + + /* Now copy back the top half of the temp array */ + for (k = 0; k < GCOV_ICALL_TOPN_NCOUNTS - 1; k += 2) + { + value_array[k] = tmp_array[k]; + value_array[k + 1] = tmp_array[k + 1]; + } + } +} +#endif + + +#ifdef L_gcov_merge_single +/* The profile merging function for choosing the most common value. + It is given an array COUNTERS of N_COUNTERS old counters and it + reads the same number of counters from the gcov file. The counters + are split into 3-tuples where the members of the tuple have + meanings: + + -- the stored candidate on the most common value of the measured entity + -- counter + -- total number of evaluations of the value */ +void +__gcov_merge_single (gcov_type *counters, unsigned n_counters) +{ + unsigned i, n_measures; + gcov_type value, counter, all; + + gcc_assert (!(n_counters % 3)); + n_measures = n_counters / 3; + for (i = 0; i < n_measures; i++, counters += 3) + { + value = gcov_read_counter (); + counter = gcov_read_counter (); + all = gcov_read_counter (); + + if (counters[0] == value) + counters[1] += counter; + else if (counter > counters[1]) + { + counters[0] = value; + counters[1] = counter - counters[1]; + } + else + counters[1] -= counter; + counters[2] += all; + } +} +#endif /* L_gcov_merge_single */ + +#ifdef L_gcov_merge_delta +/* The profile merging function for choosing the most common + difference between two consecutive evaluations of the value. It is + given an array COUNTERS of N_COUNTERS old counters and it reads the + same number of counters from the gcov file. The counters are split + into 4-tuples where the members of the tuple have meanings: + + -- the last value of the measured entity + -- the stored candidate on the most common difference + -- counter + -- total number of evaluations of the value */ +void +__gcov_merge_delta (gcov_type *counters, unsigned n_counters) +{ + unsigned i, n_measures; + gcov_type value, counter, all; + + gcc_assert (!(n_counters % 4)); + n_measures = n_counters / 4; + for (i = 0; i < n_measures; i++, counters += 4) + { + /* last = */ gcov_read_counter (); + value = gcov_read_counter (); + counter = gcov_read_counter (); + all = gcov_read_counter (); + + if (counters[1] == value) + counters[2] += counter; + else if (counter > counters[2]) + { + counters[1] = value; + counters[2] = counter - counters[2]; + } + else + counters[2] -= counter; + counters[3] += all; + } +} +#endif /* L_gcov_merge_delta */ + +#ifdef L_gcov_interval_profiler +/* If VALUE is in interval <START, START + STEPS - 1>, then increases the + corresponding counter in COUNTERS. If the VALUE is above or below + the interval, COUNTERS[STEPS] or COUNTERS[STEPS + 1] is increased + instead. */ + +void +__gcov_interval_profiler (gcov_type *counters, gcov_type value, + int start, unsigned steps) +{ + gcov_type delta = value - start; + if (delta < 0) + counters[steps + 1]++; + else if (delta >= steps) + counters[steps]++; + else + counters[delta]++; +} +#endif + +#ifdef L_gcov_pow2_profiler +/* If VALUE is a power of two, COUNTERS[1] is incremented. Otherwise + COUNTERS[0] is incremented. */ + +void +__gcov_pow2_profiler (gcov_type *counters, gcov_type value) +{ + if (value & (value - 1)) + counters[0]++; + else + counters[1]++; +} +#endif + +/* Tries to determine the most common value among its inputs. Checks if the + value stored in COUNTERS[0] matches VALUE. If this is the case, COUNTERS[1] + is incremented. If this is not the case and COUNTERS[1] is not zero, + COUNTERS[1] is decremented. Otherwise COUNTERS[1] is set to one and + VALUE is stored to COUNTERS[0]. This algorithm guarantees that if this + function is called more than 50% of the time with one value, this value + will be in COUNTERS[0] in the end. + + In any case, COUNTERS[2] is incremented. */ + +static inline void +__gcov_one_value_profiler_body (gcov_type *counters, gcov_type value) +{ + if (value == counters[0]) + counters[1]++; + else if (counters[1] == 0) + { + counters[1] = 1; + counters[0] = value; + } + else + counters[1]--; + counters[2]++; +} + +#ifdef L_gcov_indirect_call_topn_profiler +/* Tries to keep track the most frequent N values in the counters where + N is specified by parameter TOPN_VAL. To track top N values, 2*N counter + entries are used. + counter[0] --- the accumative count of the number of times one entry in + in the counters gets evicted/replaced due to limited capacity. + When this value reaches a threshold, the bottom N values are + cleared. + counter[1] through counter[2*N] records the top 2*N values collected so far. + Each value is represented by two entries: count[2*i+1] is the ith value, and + count[2*i+2] is the number of times the value is seen. */ + +static void +__gcov_topn_value_profiler_body (gcov_type *counters, gcov_type value, + gcov_unsigned_t topn_val) +{ + unsigned i, found = 0, have_zero_count = 0; + + gcov_type *entry; + gcov_type *lfu_entry = &counters[1]; + gcov_type *value_array = &counters[1]; + gcov_type *num_eviction = &counters[0]; + + /* There are 2*topn_val values tracked, each value takes two slots in the + counter array */ + for ( i = 0; i < (topn_val << 2); i += 2) + { + entry = &value_array[i]; + if ( entry[0] == value) + { + entry[1]++ ; + found = 1; + break; + } + else if (entry[1] == 0) + { + lfu_entry = entry; + have_zero_count = 1; + } + else if (entry[1] < lfu_entry[1]) + lfu_entry = entry; + } + + if (found) + return; + + /* lfu_entry is either an empty entry or an entry + with lowest count, which will be evicted. */ + lfu_entry[0] = value; + lfu_entry[1] = 1; + +#define GCOV_ICALL_COUNTER_CLEAR_THRESHOLD 3000 + + /* Too many evictions -- time to clear bottom entries to + avoid hot values bumping each other out. */ + if ( !have_zero_count + && ++*num_eviction >= GCOV_ICALL_COUNTER_CLEAR_THRESHOLD) + { + unsigned i, j; + gcov_type *p, minv; + gcov_type* tmp_cnts + = (gcov_type *)alloca (topn_val * sizeof(gcov_type)); + + *num_eviction = 0; + + for ( i = 0; i < topn_val; i++ ) + tmp_cnts[i] = 0; + + /* Find the largest topn_val values from the group of + 2*topn_val values and put them into tmp_cnts. */ + + for ( i = 0; i < 2 * topn_val; i += 2 ) + { + p = 0; + for ( j = 0; j < topn_val; j++ ) + { + if ( !p || tmp_cnts[j] < *p ) + p = &tmp_cnts[j]; + } + if ( value_array[i + 1] > *p ) + *p = value_array[i + 1]; + } + + minv = tmp_cnts[0]; + for ( j = 1; j < topn_val; j++ ) + { + if (tmp_cnts[j] < minv) + minv = tmp_cnts[j]; + } + /* Zero out low value entries */ + for ( i = 0; i < 2 * topn_val; i += 2 ) + { + if (value_array[i + 1] < minv) + { + value_array[i] = 0; + value_array[i + 1] = 0; + } + } + } +} +#endif + +#ifdef L_gcov_one_value_profiler +void +__gcov_one_value_profiler (gcov_type *counters, gcov_type value) +{ + __gcov_one_value_profiler_body (counters, value); +} +#endif + +#ifdef L_gcov_indirect_call_profiler + +/* By default, the C++ compiler will use function addresses in the + vtable entries. Setting TARGET_VTABLE_USES_DESCRIPTORS to nonzero + tells the compiler to use function descriptors instead. The value + of this macro says how many words wide the descriptor is (normally 2), + but it may be dependent on target flags. Since we do not have access + to the target flags here we just check to see if it is set and use + that to set VTABLE_USES_DESCRIPTORS to 0 or 1. + + It is assumed that the address of a function descriptor may be treated + as a pointer to a function. */ + +#ifdef TARGET_VTABLE_USES_DESCRIPTORS +#define VTABLE_USES_DESCRIPTORS 1 +#else +#define VTABLE_USES_DESCRIPTORS 0 +#endif + +/* Tries to determine the most common value among its inputs. */ +void +__gcov_indirect_call_profiler (gcov_type* counter, gcov_type value, + void* cur_func, void* callee_func) +{ + /* If the C++ virtual tables contain function descriptors then one + function may have multiple descriptors and we need to dereference + the descriptors to see if they point to the same function. */ + if (cur_func == callee_func + || (VTABLE_USES_DESCRIPTORS && callee_func + && *(void **) cur_func == *(void **) callee_func)) + __gcov_one_value_profiler_body (counter, value); +} +#endif + + +#ifdef L_gcov_indirect_call_topn_profiler +extern THREAD_PREFIX gcov_type *__gcov_indirect_call_topn_counters ATTRIBUTE_HIDDEN; +extern THREAD_PREFIX void *__gcov_indirect_call_topn_callee ATTRIBUTE_HIDDEN; +#ifdef TARGET_VTABLE_USES_DESCRIPTORS +#define VTABLE_USES_DESCRIPTORS 1 +#else +#define VTABLE_USES_DESCRIPTORS 0 +#endif +void +__gcov_indirect_call_topn_profiler (void *cur_func, + void *cur_module_gcov_info, + gcov_unsigned_t cur_func_id) +{ + void *callee_func = __gcov_indirect_call_topn_callee; + gcov_type *counter = __gcov_indirect_call_topn_counters; + /* If the C++ virtual tables contain function descriptors then one + function may have multiple descriptors and we need to dereference + the descriptors to see if they point to the same function. */ + if (cur_func == callee_func + || (VTABLE_USES_DESCRIPTORS && callee_func + && *(void **) cur_func == *(void **) callee_func)) + { + gcov_type global_id + = ((struct gcov_info *) cur_module_gcov_info)->mod_info->ident; + global_id = GEN_FUNC_GLOBAL_ID (global_id, cur_func_id); + __gcov_topn_value_profiler_body (counter, global_id, GCOV_ICALL_TOPN_VAL); + __gcov_indirect_call_topn_callee = 0; + } +} + +#endif + +#ifdef L_gcov_direct_call_profiler +extern THREAD_PREFIX gcov_type *__gcov_direct_call_counters ATTRIBUTE_HIDDEN; +extern THREAD_PREFIX void *__gcov_direct_call_callee ATTRIBUTE_HIDDEN; +/* Direct call profiler. */ +void +__gcov_direct_call_profiler (void *cur_func, + void *cur_module_gcov_info, + gcov_unsigned_t cur_func_id) +{ + if (cur_func == __gcov_direct_call_callee) + { + gcov_type global_id + = ((struct gcov_info *) cur_module_gcov_info)->mod_info->ident; + global_id = GEN_FUNC_GLOBAL_ID (global_id, cur_func_id); + __gcov_direct_call_counters[0] = global_id; + __gcov_direct_call_counters[1]++; + __gcov_direct_call_callee = 0; + } +} +#endif + + +#ifdef L_gcov_average_profiler +/* Increase corresponding COUNTER by VALUE. FIXME: Perhaps we want + to saturate up. */ + +void +__gcov_average_profiler (gcov_type *counters, gcov_type value) +{ + counters[0] += value; + counters[1] ++; +} +#endif + +#ifdef L_gcov_ior_profiler +/* Increase corresponding COUNTER by VALUE. FIXME: Perhaps we want + to saturate up. */ + +void +__gcov_ior_profiler (gcov_type *counters, gcov_type value) +{ + *counters |= value; +} +#endif + +#ifdef L_gcov_fork +/* A wrapper for the fork function. Flushes the accumulated profiling data, so + that they are not counted twice. */ + +pid_t +__gcov_fork (void) +{ + __gcov_flush (); + return fork (); +} +#endif + +#ifdef L_gcov_execl +/* A wrapper for the execl function. Flushes the accumulated profiling data, so + that they are not lost. */ + +int +__gcov_execl (const char *path, char *arg, ...) +{ + va_list ap, aq; + unsigned i, length; + char **args; + + __gcov_flush (); + + va_start (ap, arg); + va_copy (aq, ap); + + length = 2; + while (va_arg (ap, char *)) + length++; + va_end (ap); + + args = (char **) alloca (length * sizeof (void *)); + args[0] = arg; + for (i = 1; i < length; i++) + args[i] = va_arg (aq, char *); + va_end (aq); + + return execv (path, args); +} +#endif + +#ifdef L_gcov_execlp +/* A wrapper for the execlp function. Flushes the accumulated profiling data, so + that they are not lost. */ + +int +__gcov_execlp (const char *path, char *arg, ...) +{ + va_list ap, aq; + unsigned i, length; + char **args; + + __gcov_flush (); + + va_start (ap, arg); + va_copy (aq, ap); + + length = 2; + while (va_arg (ap, char *)) + length++; + va_end (ap); + + args = (char **) alloca (length * sizeof (void *)); + args[0] = arg; + for (i = 1; i < length; i++) + args[i] = va_arg (aq, char *); + va_end (aq); + + return execvp (path, args); +} +#endif + +#ifdef L_gcov_execle +/* A wrapper for the execle function. Flushes the accumulated profiling data, so + that they are not lost. */ + +int +__gcov_execle (const char *path, char *arg, ...) +{ + va_list ap, aq; + unsigned i, length; + char **args; + char **envp; + + __gcov_flush (); + + va_start (ap, arg); + va_copy (aq, ap); + + length = 2; + while (va_arg (ap, char *)) + length++; + va_end (ap); + + args = (char **) alloca (length * sizeof (void *)); + args[0] = arg; + for (i = 1; i < length; i++) + args[i] = va_arg (aq, char *); + envp = va_arg (aq, char **); + va_end (aq); + + return execve (path, args, envp); +} +#endif + +#ifdef L_gcov_execv +/* A wrapper for the execv function. Flushes the accumulated profiling data, so + that they are not lost. */ + +int +__gcov_execv (const char *path, char *const argv[]) +{ + __gcov_flush (); + return execv (path, argv); +} +#endif + +#ifdef L_gcov_execvp +/* A wrapper for the execvp function. Flushes the accumulated profiling data, so + that they are not lost. */ + +int +__gcov_execvp (const char *path, char *const argv[]) +{ + __gcov_flush (); + return execvp (path, argv); +} +#endif + +#ifdef L_gcov_execve +/* A wrapper for the execve function. Flushes the accumulated profiling data, so + that they are not lost. */ + +int +__gcov_execve (const char *path, char *const argv[], char *const envp[]) +{ + __gcov_flush (); + return execve (path, argv, envp); +} +#endif + +#ifdef __GCOV_KERNEL__ +/* + * Provide different implementation for the following functions: + * __gcov_init + * __gcov_exit + * + * Provide the following dummy merge functions: + * __gcov_merge_add + * __gcov_merge_single + * __gcov_merge_delta + * __gcov_merge_ior + * __gcov_merge_icall_topn + * __gcov_merge_dc + * __gcov_merge_reusedist + * + * Reuse the following functions: + * __gcov_interval_profiler() + * __gcov_pow2_profiler() + * __gcov_average_profiler() + * __gcov_ior_profiler() + * __gcov_one_value_profiler() + * __gcov_indirect_call_profiler() + * |-> __gcov_one_value_profiler_body() + * + * For LIPO: (TBD) + * Change slightly for the following functions: + * __gcov_merge_icall_topn + * __gcov_merge_dc + * + * Reuse the following functions: + * __gcov_direct_call_profiler() + * __gcov_indirect_call_topn_profiler() + * |-> __gcov_topn_value_profiler_body() + * + */ + +/* Current virual gcda file. This is for kernel use only. */ +gcov_kernel_vfile *gcov_current_file; + +/* Set current virutal gcda file. It needs to be set before dumping + profile data. */ + +void +gcov_set_vfile (gcov_kernel_vfile *file) +{ + gcov_current_file = file; +} + +/* Dump one entry in the gcov_info list (for one object) in kernel. */ + +void +gcov_kernel_dump_one_gcov (struct gcov_info *info) +{ + gcc_assert (gcov_current_file); + + gcov_exit_init (); + + gcov_dump_one_gcov (info); +} + +#define DUMMY_FUNC(func) \ +void func (gcov_type *counters __attribute__ ((unused)), \ + unsigned n_counters __attribute__ ((unused))) {} + +DUMMY_FUNC (__gcov_merge_add) +EXPORT_SYMBOL (__gcov_merge_add); + +DUMMY_FUNC (__gcov_merge_single) +EXPORT_SYMBOL (__gcov_merge_single); + +DUMMY_FUNC (__gcov_merge_delta) +EXPORT_SYMBOL (__gcov_merge_delta); + +DUMMY_FUNC(__gcov_merge_ior) +EXPORT_SYMBOL (__gcov_merge_ior); + +DUMMY_FUNC (__gcov_merge_icall_topn) +EXPORT_SYMBOL (__gcov_merge_icall_topn); + +DUMMY_FUNC (__gcov_merge_dc) +EXPORT_SYMBOL (__gcov_merge_dc); + +DUMMY_FUNC (__gcov_merge_reusedist) +EXPORT_SYMBOL (__gcov_merge_reusedist); + +EXPORT_SYMBOL (__gcov_average_profiler); +EXPORT_SYMBOL (__gcov_indirect_call_profiler); +EXPORT_SYMBOL (__gcov_interval_profiler); +EXPORT_SYMBOL (__gcov_ior_profiler); +EXPORT_SYMBOL (__gcov_one_value_profiler); +EXPORT_SYMBOL (__gcov_pow2_profiler); + +#endif /* __GCOV_KERNEL__ */ + +#endif /* inhibit_libc */ |