diff options
| -rw-r--r-- | src/lib/gcov-glue.c | 2 | ||||
| -rw-r--r-- | src/lib/gcov-io.c | 194 | ||||
| -rw-r--r-- | src/lib/gcov-io.h | 128 | ||||
| -rw-r--r-- | src/lib/libgcov.c | 344 | ||||
| -rw-r--r-- | src/lib/selfboot.c | 2 | ||||
| -rw-r--r-- | src/lib/thread.c | 2 |
6 files changed, 336 insertions, 336 deletions
diff --git a/src/lib/gcov-glue.c b/src/lib/gcov-glue.c index d5e5584e87..45c3efa5a8 100644 --- a/src/lib/gcov-glue.c +++ b/src/lib/gcov-glue.c @@ -80,7 +80,7 @@ static int fseek(FILE *stream, long offset, int whence) { /* fseek should only be called with offset==0 and whence==SEEK_SET * to a freshly opened file. */ - gcc_assert (offset == 0 && whence == SEEK_SET); + gcc_assert(offset == 0 && whence == SEEK_SET); #if CONFIG_DEBUG_COVERAGE printk(BIOS_DEBUG, "fseek %s offset=%ld whence=%d\n", stream->filename, offset, whence); diff --git a/src/lib/gcov-io.c b/src/lib/gcov-io.c index 2ec3999f71..7f3b7281f4 100644 --- a/src/lib/gcov-io.c +++ b/src/lib/gcov-io.c @@ -25,15 +25,15 @@ permissions described in the GCC Runtime Library Exception, version another source file, after having #included gcov-io.h. */ #if !IN_GCOV -static void gcov_write_block (unsigned int); -static gcov_unsigned_t *gcov_write_words (unsigned int); +static void gcov_write_block(unsigned int); +static gcov_unsigned_t *gcov_write_words(unsigned int); #endif -static const gcov_unsigned_t *gcov_read_words (unsigned int); +static const gcov_unsigned_t *gcov_read_words(unsigned int); #if !IN_LIBGCOV -static void gcov_allocate (unsigned int); +static void gcov_allocate(unsigned int); #endif -static inline gcov_unsigned_t from_file (gcov_unsigned_t value) +static inline gcov_unsigned_t from_file(gcov_unsigned_t value) { #if !IN_LIBGCOV if (gcov_var.endian) @@ -57,9 +57,9 @@ static inline gcov_unsigned_t from_file (gcov_unsigned_t value) GCOV_LINKAGE int #if IN_LIBGCOV -gcov_open (const char *name) +gcov_open(const char *name) #else -gcov_open (const char *name, int mode) +gcov_open(const char *name, int mode) #endif { #if IN_LIBGCOV @@ -72,10 +72,10 @@ gcov_open (const char *name, int mode) s_flock.l_whence = SEEK_SET; s_flock.l_start = 0; s_flock.l_len = 0; /* Until EOF. */ - s_flock.l_pid = getpid (); + s_flock.l_pid = getpid(); #endif - gcc_assert (!gcov_var.file); + gcc_assert(!gcov_var.file); gcov_var.start = 0; gcov_var.offset = gcov_var.length = 0; gcov_var.overread = -1u; @@ -88,25 +88,25 @@ gcov_open (const char *name, int mode) { /* Read-only mode - acquire a read-lock. */ s_flock.l_type = F_RDLCK; - fd = open (name, O_RDONLY); + 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); + fd = open(name, O_RDWR | O_CREAT, 0666); } if (fd < 0) return 0; - while (fcntl (fd, F_SETLKW, &s_flock) && errno == EINTR) + while (fcntl(fd, F_SETLKW, &s_flock) && errno == EINTR) continue; - gcov_var.file = fdopen (fd, (mode > 0) ? "rb" : "r+b"); + gcov_var.file = fdopen(fd, (mode > 0) ? "rb" : "r+b"); if (!gcov_var.file) { - close (fd); + close(fd); return 0; } @@ -116,9 +116,9 @@ gcov_open (const char *name, int mode) { struct stat st; - if (fstat (fd, &st) < 0) + if (fstat(fd, &st) < 0) { - fclose (gcov_var.file); + fclose(gcov_var.file); gcov_var.file = 0; return 0; } @@ -131,13 +131,13 @@ gcov_open (const char *name, int mode) gcov_var.mode = mode * 2 + 1; #else if (mode >= 0) - gcov_var.file = fopen (name, (mode > 0) ? "rb" : "r+b"); + 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"); + gcov_var.file = fopen(name, "w+b"); if (gcov_var.file) gcov_var.mode = mode * 2 + 1; } @@ -145,7 +145,7 @@ gcov_open (const char *name, int mode) return 0; #endif - setbuf (gcov_var.file, (char *)0); + setbuf(gcov_var.file, (char *)0); return 1; } @@ -154,20 +154,20 @@ gcov_open (const char *name, int mode) on failure or error flag set. */ GCOV_LINKAGE int -gcov_close (void) +gcov_close(void) { if (gcov_var.file) { #if !IN_GCOV if (gcov_var.offset && gcov_var.mode < 0) - gcov_write_block (gcov_var.offset); + gcov_write_block(gcov_var.offset); #endif - fclose (gcov_var.file); + fclose(gcov_var.file); gcov_var.file = 0; gcov_var.length = 0; } #if !IN_LIBGCOV - free (gcov_var.buffer); + free(gcov_var.buffer); gcov_var.alloc = 0; gcov_var.buffer = 0; #endif @@ -181,7 +181,7 @@ gcov_close (void) not EXPECTED. */ GCOV_LINKAGE int -gcov_magic (gcov_unsigned_t magic, gcov_unsigned_t expected) +gcov_magic(gcov_unsigned_t magic, gcov_unsigned_t expected) { if (magic == expected) return 1; @@ -198,7 +198,7 @@ gcov_magic (gcov_unsigned_t magic, gcov_unsigned_t expected) #if !IN_LIBGCOV static void -gcov_allocate (unsigned int length) +gcov_allocate(unsigned int length) { size_t new_size = gcov_var.alloc; @@ -208,7 +208,7 @@ gcov_allocate (unsigned int length) new_size *= 2; gcov_var.alloc = new_size; - gcov_var.buffer = XRESIZEVAR (gcov_unsigned_t, gcov_var.buffer, new_size << 2); + gcov_var.buffer = XRESIZEVAR(gcov_unsigned_t, gcov_var.buffer, new_size << 2); } #endif @@ -216,9 +216,9 @@ gcov_allocate (unsigned int length) /* Write out the current block, if needs be. */ static void -gcov_write_block (unsigned int size) +gcov_write_block(unsigned int size) { - if (fwrite (gcov_var.buffer, size << 2, 1, gcov_var.file) != 1) + if (fwrite(gcov_var.buffer, size << 2, 1, gcov_var.file) != 1) gcov_var.error = 1; gcov_var.start += size; gcov_var.offset -= size; @@ -228,24 +228,24 @@ gcov_write_block (unsigned int size) pointer to those bytes, or NULL on failure. */ static gcov_unsigned_t * -gcov_write_words (unsigned int words) +gcov_write_words(unsigned int words) { gcov_unsigned_t *result; - gcc_assert (gcov_var.mode < 0); + gcc_assert(gcov_var.mode < 0); #if IN_LIBGCOV if (gcov_var.offset >= GCOV_BLOCK_SIZE) { - gcov_write_block (GCOV_BLOCK_SIZE); + gcov_write_block(GCOV_BLOCK_SIZE); if (gcov_var.offset) { - gcc_assert (gcov_var.offset == 1); - memcpy (gcov_var.buffer, gcov_var.buffer + GCOV_BLOCK_SIZE, 4); + gcc_assert(gcov_var.offset == 1); + memcpy(gcov_var.buffer, gcov_var.buffer + GCOV_BLOCK_SIZE, 4); } } #else if (gcov_var.offset + words > gcov_var.alloc) - gcov_allocate (gcov_var.offset + words); + gcov_allocate(gcov_var.offset + words); #endif result = &gcov_var.buffer[gcov_var.offset]; gcov_var.offset += words; @@ -257,9 +257,9 @@ gcov_write_words (unsigned int words) appropriately. */ GCOV_LINKAGE void -gcov_write_unsigned (gcov_unsigned_t value) +gcov_write_unsigned(gcov_unsigned_t value) { - gcov_unsigned_t *buffer = gcov_write_words (1); + gcov_unsigned_t *buffer = gcov_write_words(1); buffer[0] = value; } @@ -269,12 +269,12 @@ gcov_write_unsigned (gcov_unsigned_t value) #if IN_LIBGCOV GCOV_LINKAGE void -gcov_write_counter (gcov_type value) +gcov_write_counter(gcov_type value) { - gcov_unsigned_t *buffer = gcov_write_words (2); + gcov_unsigned_t *buffer = gcov_write_words(2); buffer[0] = (gcov_unsigned_t) value; - if (sizeof (value) > sizeof (gcov_unsigned_t)) + if (sizeof(value) > sizeof(gcov_unsigned_t)) buffer[1] = (gcov_unsigned_t) (value >> 32); else buffer[1] = 0; @@ -286,7 +286,7 @@ gcov_write_counter (gcov_type value) error, overflow flag on overflow */ GCOV_LINKAGE void -gcov_write_string (const char *string) +gcov_write_string(const char *string) { unsigned int length = 0; unsigned int alloc = 0; @@ -294,15 +294,15 @@ gcov_write_string (const char *string) if (string) { - length = strlen (string); + length = strlen(string); alloc = (length + 4) >> 2; } - buffer = gcov_write_words (1 + alloc); + buffer = gcov_write_words(1 + alloc); buffer[0] = alloc; buffer[alloc] = 0; - memcpy (&buffer[1], string, length); + memcpy(&buffer[1], string, length); } #endif @@ -311,10 +311,10 @@ gcov_write_string (const char *string) value to be used for gcov_write_length. */ GCOV_LINKAGE gcov_position_t -gcov_write_tag (gcov_unsigned_t tag) +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); + gcov_unsigned_t *buffer = gcov_write_words(2); buffer[0] = tag; buffer[1] = 0; @@ -328,21 +328,21 @@ gcov_write_tag (gcov_unsigned_t tag) overflow. */ GCOV_LINKAGE void -gcov_write_length (gcov_position_t position) +gcov_write_length(gcov_position_t position) { unsigned int offset; gcov_unsigned_t length; gcov_unsigned_t *buffer; - gcc_assert (gcov_var.mode < 0); - gcc_assert (position + 2 <= gcov_var.start + gcov_var.offset); - gcc_assert (position >= gcov_var.start); + 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); + gcov_write_block(gcov_var.offset); } #else /* IN_LIBGCOV */ @@ -350,9 +350,9 @@ gcov_write_length (gcov_position_t position) /* Write a tag TAG and length LENGTH. */ GCOV_LINKAGE void -gcov_write_tag_length (gcov_unsigned_t tag, gcov_unsigned_t length) +gcov_write_tag_length(gcov_unsigned_t tag, gcov_unsigned_t length) { - gcov_unsigned_t *buffer = gcov_write_words (2); + gcov_unsigned_t *buffer = gcov_write_words(2); buffer[0] = tag; buffer[1] = length; @@ -362,20 +362,20 @@ gcov_write_tag_length (gcov_unsigned_t tag, gcov_unsigned_t length) overflow. */ GCOV_LINKAGE void -gcov_write_summary (gcov_unsigned_t tag, const struct gcov_summary *summary) +gcov_write_summary(gcov_unsigned_t tag, const struct gcov_summary *summary) { unsigned int ix; const struct gcov_ctr_summary *csum; - gcov_write_tag_length (tag, GCOV_TAG_SUMMARY_LENGTH); - gcov_write_unsigned (summary->checksum); + gcov_write_tag_length(tag, GCOV_TAG_SUMMARY_LENGTH); + gcov_write_unsigned(summary->checksum); for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++) { - gcov_write_unsigned (csum->num); - gcov_write_unsigned (csum->runs); - gcov_write_counter (csum->sum_all); - gcov_write_counter (csum->run_max); - gcov_write_counter (csum->sum_max); + gcov_write_unsigned(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 */ @@ -386,35 +386,35 @@ gcov_write_summary (gcov_unsigned_t tag, const struct gcov_summary *summary) NULL on failure (read past EOF). */ static const gcov_unsigned_t * -gcov_read_words (unsigned int words) +gcov_read_words(unsigned int words) { const gcov_unsigned_t *result; unsigned int excess = gcov_var.length - gcov_var.offset; - gcc_assert (gcov_var.mode > 0); + gcc_assert(gcov_var.mode > 0); if (excess < words) { gcov_var.start += gcov_var.offset; #if IN_LIBGCOV if (excess) { - gcc_assert (excess == 1); - memcpy (gcov_var.buffer, gcov_var.buffer + gcov_var.offset, 4); + gcc_assert(excess == 1); + memcpy(gcov_var.buffer, gcov_var.buffer + gcov_var.offset, 4); } #else - memmove (gcov_var.buffer, gcov_var.buffer + gcov_var.offset, excess * 4); + memmove(gcov_var.buffer, gcov_var.buffer + gcov_var.offset, excess * 4); #endif gcov_var.offset = 0; gcov_var.length = excess; #if IN_LIBGCOV - gcc_assert (!gcov_var.length || gcov_var.length == 1); + gcc_assert(!gcov_var.length || gcov_var.length == 1); excess = GCOV_BLOCK_SIZE; #else if (gcov_var.length + words > gcov_var.alloc) - gcov_allocate (gcov_var.length + words); + gcov_allocate(gcov_var.length + words); excess = gcov_var.alloc - gcov_var.length; #endif - excess = fread (gcov_var.buffer + gcov_var.length, + excess = fread(gcov_var.buffer + gcov_var.length, 1, excess << 2, gcov_var.file) >> 2; gcov_var.length += excess; if (gcov_var.length < words) @@ -433,14 +433,14 @@ gcov_read_words (unsigned int words) error, overflow flag on overflow */ GCOV_LINKAGE gcov_unsigned_t -gcov_read_unsigned (void) +gcov_read_unsigned(void) { gcov_unsigned_t value; - const gcov_unsigned_t *buffer = gcov_read_words (1); + const gcov_unsigned_t *buffer = gcov_read_words(1); if (!buffer) return 0; - value = from_file (buffer[0]); + value = from_file(buffer[0]); return value; } @@ -448,16 +448,16 @@ gcov_read_unsigned (void) error, overflow flag on overflow */ GCOV_LINKAGE gcov_type -gcov_read_counter (void) +gcov_read_counter(void) { gcov_type value; - const gcov_unsigned_t *buffer = gcov_read_words (2); + 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; + 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; @@ -470,31 +470,31 @@ gcov_read_counter (void) #if !IN_LIBGCOV GCOV_LINKAGE const char * -gcov_read_string (void) +gcov_read_string(void) { - unsigned int length = gcov_read_unsigned (); + unsigned int length = gcov_read_unsigned(); if (!length) return 0; - return (const char *) gcov_read_words (length); + return (const char *) gcov_read_words(length); } #endif GCOV_LINKAGE void -gcov_read_summary (struct gcov_summary *summary) +gcov_read_summary(struct gcov_summary *summary) { unsigned int ix; struct gcov_ctr_summary *csum; - summary->checksum = gcov_read_unsigned (); + 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 (); + 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(); } } @@ -503,17 +503,17 @@ gcov_read_summary (struct gcov_summary *summary) gcov_position, LENGTH should be a record length. */ GCOV_LINKAGE void -gcov_sync (gcov_position_t base, gcov_unsigned_t length) +gcov_sync(gcov_position_t base, gcov_unsigned_t length) { - gcc_assert (gcov_var.mode > 0); + gcc_assert(gcov_var.mode > 0); base += length; if (base - gcov_var.start <= gcov_var.length) gcov_var.offset = base - gcov_var.start; else { gcov_var.offset = gcov_var.length = 0; - fseek (gcov_var.file, base << 2, SEEK_SET); - gcov_var.start = ftell (gcov_var.file) >> 2; + fseek(gcov_var.file, base << 2, SEEK_SET); + gcov_var.start = ftell(gcov_var.file) >> 2; } } #endif @@ -522,13 +522,13 @@ gcov_sync (gcov_position_t base, gcov_unsigned_t length) /* Move to a given position in a gcov file. */ GCOV_LINKAGE void -gcov_seek (gcov_position_t base) +gcov_seek(gcov_position_t base) { - gcc_assert (gcov_var.mode < 0); + gcc_assert(gcov_var.mode < 0); if (gcov_var.offset) - gcov_write_block (gcov_var.offset); - fseek (gcov_var.file, base << 2, SEEK_SET); - gcov_var.start = ftell (gcov_var.file) >> 2; + gcov_write_block(gcov_var.offset); + fseek(gcov_var.file, base << 2, SEEK_SET); + gcov_var.start = ftell(gcov_var.file) >> 2; } #endif @@ -536,11 +536,11 @@ gcov_seek (gcov_position_t base) /* Return the modification time of the current gcov file. */ GCOV_LINKAGE time_t -gcov_time (void) +gcov_time(void) { struct stat status; - if (fstat (fileno (gcov_var.file), &status)) + if (fstat(fileno(gcov_var.file), &status)) return 0; else return status.st_mtime; diff --git a/src/lib/gcov-io.h b/src/lib/gcov-io.h index d55588fbc7..a033c288a0 100644 --- a/src/lib/gcov-io.h +++ b/src/lib/gcov-io.h @@ -181,35 +181,35 @@ permissions described in the GCC Runtime Library Exception, version /* About the target */ #if BITS_PER_UNIT == 8 -typedef unsigned int gcov_unsigned_t __attribute__ ((mode (SI))); -typedef unsigned int gcov_position_t __attribute__ ((mode (SI))); +typedef unsigned int gcov_unsigned_t __attribute__ ((mode(SI))); +typedef unsigned int gcov_position_t __attribute__ ((mode(SI))); #if LONG_LONG_TYPE_SIZE > 32 -typedef signed gcov_type __attribute__ ((mode (DI))); +typedef signed gcov_type __attribute__ ((mode(DI))); #else -typedef signed gcov_type __attribute__ ((mode (SI))); +typedef signed gcov_type __attribute__ ((mode(SI))); #endif #else #if BITS_PER_UNIT == 16 -typedef unsigned int gcov_unsigned_t __attribute__ ((mode (HI))); -typedef unsigned int gcov_position_t __attribute__ ((mode (HI))); +typedef unsigned int gcov_unsigned_t __attribute__ ((mode(HI))); +typedef unsigned int gcov_position_t __attribute__ ((mode(HI))); #if LONG_LONG_TYPE_SIZE > 32 -typedef signed gcov_type __attribute__ ((mode (SI))); +typedef signed gcov_type __attribute__ ((mode(SI))); #else -typedef signed gcov_type __attribute__ ((mode (HI))); +typedef signed gcov_type __attribute__ ((mode(HI))); #endif #else -typedef unsigned int gcov_unsigned_t __attribute__ ((mode (QI))); -typedef unsigned int gcov_position_t __attribute__ ((mode (QI))); +typedef unsigned int gcov_unsigned_t __attribute__ ((mode(QI))); +typedef unsigned int gcov_position_t __attribute__ ((mode(QI))); #if LONG_LONG_TYPE_SIZE > 32 -typedef signed gcov_type __attribute__ ((mode (HI))); +typedef signed gcov_type __attribute__ ((mode(HI))); #else -typedef signed gcov_type __attribute__ ((mode (QI))); +typedef signed gcov_type __attribute__ ((mode(QI))); #endif #endif #endif -#if defined (TARGET_POSIX_IO) +#if defined(TARGET_POSIX_IO) #define GCOV_LOCKED 1 #else #define GCOV_LOCKED 0 @@ -231,7 +231,7 @@ typedef HOST_WIDEST_INT gcov_type; #define GCOV_TYPE_SIZE (LONG_LONG_TYPE_SIZE > 32 ? 64 : 32) #endif -#if defined (HOST_HAS_F_SETLKW) +#if defined(HOST_HAS_F_SETLKW) #define GCOV_LOCKED 1 #else #define GCOV_LOCKED 0 @@ -270,7 +270,7 @@ typedef HOST_WIDEST_INT gcov_type; #pragma GCC poison gcov_read_string gcov_sync gcov_time gcov_magic #ifdef HAVE_GAS_HIDDEN -#define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden"))) +#define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__("hidden"))) #else #define ATTRIBUTE_HIDDEN #endif @@ -379,7 +379,7 @@ typedef HOST_WIDEST_INT gcov_type; ((unsigned int)(((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) + (!((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 @@ -388,12 +388,12 @@ typedef HOST_WIDEST_INT gcov_type; /* 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) \ + (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)) + (GCOV_TAG_MASK(TAG) > GCOV_TAG_MASK(SUB)) /* Basic block flags. */ #define GCOV_BLOCK_UNEXPECTED (1 << 1) @@ -469,43 +469,43 @@ struct gcov_info }; /* Register a new object file module. */ -extern void __gcov_init (struct gcov_info *) ATTRIBUTE_HIDDEN; +extern void __gcov_init(struct gcov_info *) ATTRIBUTE_HIDDEN; #ifndef __COREBOOT__ /* Called before fork, to avoid double counting. */ -extern void __gcov_flush (void) ATTRIBUTE_HIDDEN; +extern void __gcov_flush(void) ATTRIBUTE_HIDDEN; #endif /* The merge function that just sums the counters. */ -extern void __gcov_merge_add (gcov_type *, unsigned int) ATTRIBUTE_HIDDEN; +extern void __gcov_merge_add(gcov_type *, unsigned int) ATTRIBUTE_HIDDEN; /* The merge function to choose the most common value. */ -extern void __gcov_merge_single (gcov_type *, unsigned int) ATTRIBUTE_HIDDEN; +extern void __gcov_merge_single(gcov_type *, unsigned int) ATTRIBUTE_HIDDEN; /* The merge function to choose the most common difference between consecutive values. */ -extern void __gcov_merge_delta (gcov_type *, unsigned int) ATTRIBUTE_HIDDEN; +extern void __gcov_merge_delta(gcov_type *, unsigned int) ATTRIBUTE_HIDDEN; /* The merge function that just ors the counters together. */ -extern void __gcov_merge_ior (gcov_type *, unsigned int) ATTRIBUTE_HIDDEN; +extern void __gcov_merge_ior(gcov_type *, unsigned int) ATTRIBUTE_HIDDEN; /* The profiler functions. */ -extern void __gcov_interval_profiler (gcov_type *, gcov_type, int, unsigned int); -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_average_profiler (gcov_type *, gcov_type); -extern void __gcov_ior_profiler (gcov_type *, gcov_type); +extern void __gcov_interval_profiler(gcov_type *, gcov_type, int, unsigned int); +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_average_profiler(gcov_type *, gcov_type); +extern void __gcov_ior_profiler(gcov_type *, gcov_type); #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 []) +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 @@ -550,68 +550,68 @@ GCOV_LINKAGE struct gcov_var 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; +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); +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; +GCOV_LINKAGE int gcov_close(void) ATTRIBUTE_HIDDEN; /* Available everywhere. */ -static gcov_position_t gcov_position (void); -static int gcov_is_error (void); +static gcov_position_t gcov_position(void); +static int gcov_is_error(void); -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 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; #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) +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*/, +GCOV_LINKAGE void gcov_write_summary(gcov_unsigned_t /*tag*/, const struct gcov_summary *) ATTRIBUTE_HIDDEN; -static void gcov_rewrite (void); -GCOV_LINKAGE void gcov_seek (gcov_position_t /*position*/) ATTRIBUTE_HIDDEN; +static void gcov_rewrite(void); +GCOV_LINKAGE void gcov_seek(gcov_position_t /*position*/) ATTRIBUTE_HIDDEN; #else /* Available outside libgcov */ -GCOV_LINKAGE const char *gcov_read_string (void); -GCOV_LINKAGE void gcov_sync (gcov_position_t /*base*/, +GCOV_LINKAGE const char *gcov_read_string(void); +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_unsigned(gcov_unsigned_t) ATTRIBUTE_HIDDEN; #endif #if !IN_GCOV && !IN_LIBGCOV /* Available only in compiler */ -GCOV_LINKAGE void gcov_write_string (const char *); -GCOV_LINKAGE gcov_position_t gcov_write_tag (gcov_unsigned_t); -GCOV_LINKAGE void gcov_write_length (gcov_position_t /*position*/); +GCOV_LINKAGE void gcov_write_string(const char *); +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); +GCOV_LINKAGE time_t gcov_time(void); #endif /* Save the current position in the gcov file. */ static inline gcov_position_t -gcov_position (void) +gcov_position(void) { - gcc_assert (gcov_var.mode > 0); + gcc_assert(gcov_var.mode > 0); return gcov_var.start + gcov_var.offset; } /* Return nonzero if the error flag is set. */ static inline int -gcov_is_error (void) +gcov_is_error(void) { return gcov_var.file ? gcov_var.error : 1; } @@ -620,13 +620,13 @@ gcov_is_error (void) /* Move to beginning of file and initialize for writing. */ static inline void -gcov_rewrite (void) +gcov_rewrite(void) { - gcc_assert (gcov_var.mode > 0); + gcc_assert(gcov_var.mode > 0); gcov_var.mode = -1; gcov_var.start = 0; gcov_var.offset = 0; - fseek (gcov_var.file, 0L, SEEK_SET); + fseek(gcov_var.file, 0L, SEEK_SET); } #endif diff --git a/src/lib/libgcov.c b/src/lib/libgcov.c index 488eb45571..024b2c38ba 100644 --- a/src/lib/libgcov.c +++ b/src/lib/libgcov.c @@ -30,7 +30,7 @@ permissions described in the GCC Runtime Library Exception, version typedef s32 pid_t; #define gcc_assert(x) ASSERT(x) #define fprintf(file, x...) printk(BIOS_ERR, x) -#define alloca(size) __builtin_alloca (size) +#define alloca(size) __builtin_alloca(size) #include "gcov-glue.c" /* Define MACROs to be used by coreboot compilation. */ @@ -73,22 +73,22 @@ typedef s32 pid_t; /* 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) {} +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)), +void __gcov_merge_add(gcov_type *counters __attribute__ ((unused)), unsigned int n_counters __attribute__ ((unused))) {} #endif #ifdef L_gcov_merge_single -void __gcov_merge_single (gcov_type *counters __attribute__ ((unused)), +void __gcov_merge_single(gcov_type *counters __attribute__ ((unused)), unsigned int n_counters __attribute__ ((unused))) {} #endif #ifdef L_gcov_merge_delta -void __gcov_merge_delta (gcov_type *counters __attribute__ ((unused)), +void __gcov_merge_delta(gcov_type *counters __attribute__ ((unused)), unsigned int n_counters __attribute__ ((unused))) {} #endif @@ -128,7 +128,7 @@ static size_t gcov_max_filename = 0; Returns zero on success, or -1 if an error occurred. */ static int -create_file_directory (char *filename) +create_file_directory(char *filename) { #ifdef __COREBOOT__ (void) filename; @@ -153,16 +153,16 @@ create_file_directory (char *filename) *s = '\0'; /* Try to make directory if it doesn't already exist. */ - if (access (filename, F_OK) == -1 + if (access(filename, F_OK) == -1 #ifdef TARGET_POSIX_IO - && mkdir (filename, 0755) == -1 + && mkdir(filename, 0755) == -1 #else - && mkdir (filename) == -1 + && mkdir(filename) == -1 #endif /* The directory might have been made by another process. */ && errno != EEXIST) { - fprintf (stderr, "profiling:%s:Cannot create directory\n", + fprintf(stderr, "profiling:%s:Cannot create directory\n", filename); *s = sep; return -1; @@ -176,7 +176,7 @@ create_file_directory (char *filename) } static struct gcov_fn_buffer * -free_fn_data (const struct gcov_info *gi_ptr, struct gcov_fn_buffer *buffer, +free_fn_data(const struct gcov_info *gi_ptr, struct gcov_fn_buffer *buffer, unsigned int limit) { struct gcov_fn_buffer *next; @@ -188,13 +188,13 @@ free_fn_data (const struct gcov_info *gi_ptr, struct gcov_fn_buffer *buffer, for (ix = 0; ix != limit; ix++) if (gi_ptr->merge[ix]) - free (buffer->info.ctrs[n_ctr++].values); - free (buffer); + free(buffer->info.ctrs[n_ctr++].values); + free(buffer); return next; } static struct gcov_fn_buffer ** -buffer_fn_data (const char *filename, const struct gcov_info *gi_ptr, +buffer_fn_data(const char *filename, const struct gcov_info *gi_ptr, struct gcov_fn_buffer **end_ptr, unsigned int fn_ix) { unsigned int n_ctrs = 0, ix = 0; @@ -205,17 +205,17 @@ buffer_fn_data (const char *filename, const struct gcov_info *gi_ptr, if (gi_ptr->merge[ix]) n_ctrs++; - len = sizeof (*fn_buffer) + sizeof (fn_buffer->info.ctrs[0]) * n_ctrs; - fn_buffer = (struct gcov_fn_buffer *)malloc (len); + len = sizeof(*fn_buffer) + sizeof(fn_buffer->info.ctrs[0]) * n_ctrs; + fn_buffer = (struct gcov_fn_buffer *)malloc(len); if (!fn_buffer) goto fail; fn_buffer->next = 0; fn_buffer->fn_ix = fn_ix; - fn_buffer->info.ident = gcov_read_unsigned (); - fn_buffer->info.lineno_checksum = gcov_read_unsigned (); - fn_buffer->info.cfg_checksum = gcov_read_unsigned (); + fn_buffer->info.ident = gcov_read_unsigned(); + fn_buffer->info.lineno_checksum = gcov_read_unsigned(); + fn_buffer->info.cfg_checksum = gcov_read_unsigned(); for (n_ctrs = ix = 0; ix != GCOV_COUNTERS; ix++) { @@ -225,15 +225,15 @@ buffer_fn_data (const char *filename, const struct gcov_info *gi_ptr, if (!gi_ptr->merge[ix]) continue; - if (gcov_read_unsigned () != GCOV_TAG_FOR_COUNTER (ix)) + if (gcov_read_unsigned() != GCOV_TAG_FOR_COUNTER(ix)) { len = 0; goto fail; } - length = GCOV_TAG_COUNTER_NUM (gcov_read_unsigned ()); - len = length * sizeof (gcov_type); - values = (gcov_type *)malloc (len); + length = GCOV_TAG_COUNTER_NUM(gcov_read_unsigned()); + len = length * sizeof(gcov_type); + values = (gcov_type *)malloc(len); if (!values) goto fail; @@ -241,7 +241,7 @@ buffer_fn_data (const char *filename, const struct gcov_info *gi_ptr, fn_buffer->info.ctrs[n_ctrs].values = values; while (length--) - *values++ = gcov_read_counter (); + *values++ = gcov_read_counter(); n_ctrs++; } @@ -249,16 +249,16 @@ buffer_fn_data (const char *filename, const struct gcov_info *gi_ptr, return &fn_buffer->next; fail: - fprintf (stderr, "profiling:%s:Function %u %s %u \n", filename, fn_ix, + fprintf(stderr, "profiling:%s:Function %u %s %u \n", filename, fn_ix, len ? "cannot allocate" : "counter mismatch", len ? len : ix); - return (struct gcov_fn_buffer **)free_fn_data (gi_ptr, fn_buffer, ix); + return (struct gcov_fn_buffer **)free_fn_data(gi_ptr, fn_buffer, ix); } /* Add an unsigned value to the current crc */ static gcov_unsigned_t -crc32_unsigned (gcov_unsigned_t crc32, gcov_unsigned_t value) +crc32_unsigned(gcov_unsigned_t crc32, gcov_unsigned_t value) { unsigned int ix; @@ -280,17 +280,17 @@ crc32_unsigned (gcov_unsigned_t crc32, gcov_unsigned_t value) instead of value from the info block. */ static int -gcov_version (struct gcov_info *ptr, gcov_unsigned_t version, +gcov_version(struct gcov_info *ptr, 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); + GCOV_UNSIGNED2STRING(v, version); + GCOV_UNSIGNED2STRING(e, GCOV_VERSION); - fprintf (stderr, + fprintf(stderr, "profiling:%s:Version mismatch - expected %.4s got %.4s\n", filename? filename : ptr->filename, e, v); return 0; @@ -306,7 +306,7 @@ gcov_version (struct gcov_info *ptr, gcov_unsigned_t version, summaries separate. */ static void -gcov_exit (void) +gcov_exit(void) { struct gcov_info *gi_ptr; const struct gcov_fn_info *gfi_ptr; @@ -323,13 +323,13 @@ gcov_exit (void) char *gi_filename, *gi_filename_up; gcov_unsigned_t crc32 = 0; - memset (&all_prg, 0, sizeof (all_prg)); + memset(&all_prg, 0, sizeof(all_prg)); /* Find the totals for this execution. */ - memset (&this_prg, 0, sizeof (this_prg)); + memset(&this_prg, 0, sizeof(this_prg)); for (gi_ptr = gcov_list; gi_ptr; gi_ptr = gi_ptr->next) { - crc32 = crc32_unsigned (crc32, gi_ptr->stamp); - crc32 = crc32_unsigned (crc32, gi_ptr->n_functions); + crc32 = crc32_unsigned(crc32, gi_ptr->stamp); + crc32 = crc32_unsigned(crc32, gi_ptr->n_functions); for (f_ix = 0; (unsigned int)f_ix != gi_ptr->n_functions; f_ix++) { @@ -338,8 +338,8 @@ gcov_exit (void) if (gfi_ptr && gfi_ptr->key != gi_ptr) gfi_ptr = 0; - crc32 = crc32_unsigned (crc32, gfi_ptr ? gfi_ptr->cfg_checksum : 0); - crc32 = crc32_unsigned (crc32, + crc32 = crc32_unsigned(crc32, gfi_ptr ? gfi_ptr->cfg_checksum : 0); + crc32 = crc32_unsigned(crc32, gfi_ptr ? gfi_ptr->lineno_checksum : 0); if (!gfi_ptr) continue; @@ -352,7 +352,7 @@ gcov_exit (void) cs_ptr = &this_prg.ctrs[t_ix]; cs_ptr->num += ci_ptr->num; - crc32 = crc32_unsigned (crc32, ci_ptr->num); + crc32 = crc32_unsigned(crc32, ci_ptr->num); for (c_num = 0; c_num < ci_ptr->num; c_num++) { @@ -371,7 +371,7 @@ gcov_exit (void) char *tmp = getenv("GCOV_PREFIX_STRIP"); if (tmp) { - gcov_prefix_strip = atoi (tmp); + gcov_prefix_strip = atoi(tmp); /* Do not consider negative values. */ if (gcov_prefix_strip < 0) gcov_prefix_strip = 0; @@ -385,7 +385,7 @@ gcov_exit (void) prefix_length = strlen(gcov_prefix); /* Remove an unnecessary trailing '/' */ - if (IS_DIR_SEPARATOR (gcov_prefix[prefix_length - 1])) + if (IS_DIR_SEPARATOR(gcov_prefix[prefix_length - 1])) prefix_length--; } else @@ -400,9 +400,9 @@ gcov_exit (void) prefix_length = 1; } /* Allocate and initialize the filename scratch space plus one. */ - gi_filename = (char *) alloca (prefix_length + gcov_max_filename + 2); + gi_filename = (char *) alloca(prefix_length + gcov_max_filename + 2); if (prefix_length) - memcpy (gi_filename, gcov_prefix, prefix_length); + memcpy(gi_filename, gcov_prefix, prefix_length); gi_filename_up = gi_filename + prefix_length; /* Now merge each file. */ @@ -445,46 +445,46 @@ gcov_exit (void) } /* Update complete filename with stripped original. */ - if (prefix_length != 0 && !IS_DIR_SEPARATOR (*fname)) + if (prefix_length != 0 && !IS_DIR_SEPARATOR(*fname)) { /* If prefix is given, add directory separator. */ - strcpy (gi_filename_up, "/"); - strcpy (gi_filename_up + 1, fname); + strcpy(gi_filename_up, "/"); + strcpy(gi_filename_up + 1, fname); } else - strcpy (gi_filename_up, fname); + strcpy(gi_filename_up, fname); - if (!gcov_open (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)) + if (create_file_directory(gi_filename)) { - fprintf (stderr, "profiling:%s:Skip\n", gi_filename); + fprintf(stderr, "profiling:%s:Skip\n", gi_filename); continue; } - if (!gcov_open (gi_filename)) + if (!gcov_open(gi_filename)) { - fprintf (stderr, "profiling:%s:Cannot open\n", gi_filename); + fprintf(stderr, "profiling:%s:Cannot open\n", gi_filename); continue; } } - tag = gcov_read_unsigned (); + tag = gcov_read_unsigned(); if (tag) { /* Merge data from file. */ if (tag != GCOV_DATA_MAGIC) { - fprintf (stderr, "profiling:%s:Not a gcov data file\n", + fprintf(stderr, "profiling:%s:Not a gcov data file\n", gi_filename); goto read_fatal; } - length = gcov_read_unsigned (); - if (!gcov_version (gi_ptr, length, gi_filename)) + length = gcov_read_unsigned(); + if (!gcov_version(gi_ptr, length, gi_filename)) goto read_fatal; - length = gcov_read_unsigned (); + length = gcov_read_unsigned(); if (length != gi_ptr->stamp) /* Read from a different compilation. Overwrite the file. */ goto rewrite; @@ -494,17 +494,17 @@ gcov_exit (void) { struct gcov_summary tmp; - eof_pos = gcov_position (); - tag = gcov_read_unsigned (); + eof_pos = gcov_position(); + tag = gcov_read_unsigned(); if (tag != GCOV_TAG_PROGRAM_SUMMARY) break; f_ix--; - length = gcov_read_unsigned (); + length = gcov_read_unsigned(); if (length != GCOV_TAG_SUMMARY_LENGTH) goto read_mismatch; - gcov_read_summary (&tmp); - if ((error = gcov_is_error ())) + gcov_read_summary(&tmp); + if ((error = gcov_is_error())) goto read_error; if (summary_pos || tmp.checksum != crc32) goto next_summary; @@ -520,14 +520,14 @@ gcov_exit (void) /* Merge execution counts for each function. */ for (f_ix = 0; (unsigned int)f_ix != gi_ptr->n_functions; - f_ix++, tag = gcov_read_unsigned ()) + f_ix++, tag = gcov_read_unsigned()) { gfi_ptr = gi_ptr->functions[f_ix]; if (tag != GCOV_TAG_FUNCTION) goto read_mismatch; - length = gcov_read_unsigned (); + length = gcov_read_unsigned(); if (!length) /* This function did not appear in the other program. We have nothing to merge. */ @@ -543,22 +543,22 @@ gcov_exit (void) it back out -- we'll be inserting data before this point, so cannot simply keep the data in the file. */ - fn_tail = buffer_fn_data (gi_filename, + fn_tail = buffer_fn_data(gi_filename, gi_ptr, fn_tail, f_ix); if (!fn_tail) goto read_mismatch; continue; } - length = gcov_read_unsigned (); + length = gcov_read_unsigned(); if (length != gfi_ptr->ident) goto read_mismatch; - length = gcov_read_unsigned (); + length = gcov_read_unsigned(); if (length != gfi_ptr->lineno_checksum) goto read_mismatch; - length = gcov_read_unsigned (); + length = gcov_read_unsigned(); if (length != gfi_ptr->cfg_checksum) goto read_mismatch; @@ -570,22 +570,22 @@ gcov_exit (void) if (!merge) continue; - tag = gcov_read_unsigned (); - length = gcov_read_unsigned (); - if (tag != GCOV_TAG_FOR_COUNTER (t_ix) - || length != GCOV_TAG_COUNTER_LENGTH (ci_ptr->num)) + tag = gcov_read_unsigned(); + length = gcov_read_unsigned(); + if (tag != GCOV_TAG_FOR_COUNTER(t_ix) + || length != GCOV_TAG_COUNTER_LENGTH(ci_ptr->num)) goto read_mismatch; - (*merge) (ci_ptr->values, ci_ptr->num); + (*merge)(ci_ptr->values, ci_ptr->num); ci_ptr++; } - if ((error = gcov_is_error ())) + if ((error = gcov_is_error())) goto read_error; } if (tag) { read_mismatch:; - fprintf (stderr, "profiling:%s:Merge mismatch for %s %u\n", + fprintf(stderr, "profiling:%s:Merge mismatch for %s %u\n", gi_filename, f_ix >= 0 ? "function" : "summary", f_ix < 0 ? -1 - f_ix : f_ix); goto read_fatal; @@ -594,16 +594,16 @@ gcov_exit (void) goto rewrite; read_error:; - fprintf (stderr, "profiling:%s:%s merging\n", gi_filename, + fprintf(stderr, "profiling:%s:%s merging\n", gi_filename, error < 0 ? "Overflow": "Error"); goto read_fatal; rewrite:; - gcov_rewrite (); + gcov_rewrite(); if (!summary_pos) { - memset (&prg, 0, sizeof (prg)); + memset(&prg, 0, sizeof(prg)); summary_pos = eof_pos; } @@ -627,12 +627,12 @@ gcov_exit (void) goto read_mismatch; if (!cs_all->runs && cs_prg->runs) - memcpy (cs_all, cs_prg, sizeof (*cs_all)); + memcpy(cs_all, cs_prg, sizeof(*cs_all)); else if (!all_prg.checksum && (!GCOV_LOCKED || cs_all->runs == cs_prg->runs) - && memcmp (cs_all, cs_prg, sizeof (*cs_all))) + && memcmp(cs_all, cs_prg, sizeof(*cs_all))) { - fprintf (stderr, "profiling:%s:Invocation mismatch - some data files may have been removed%s\n", + fprintf(stderr, "profiling:%s:Invocation mismatch - some data files may have been removed%s\n", gi_filename, GCOV_LOCKED ? "" : " or concurrently updated without locking support"); all_prg.checksum = ~0u; @@ -644,18 +644,18 @@ gcov_exit (void) /* Write out the data. */ if (!eof_pos) { - gcov_write_tag_length (GCOV_DATA_MAGIC, GCOV_VERSION); - gcov_write_unsigned (gi_ptr->stamp); + gcov_write_tag_length(GCOV_DATA_MAGIC, GCOV_VERSION); + gcov_write_unsigned(gi_ptr->stamp); } if (summary_pos) - gcov_seek (summary_pos); + gcov_seek(summary_pos); /* Generate whole program statistics. */ - gcov_write_summary (GCOV_TAG_PROGRAM_SUMMARY, &prg); + gcov_write_summary(GCOV_TAG_PROGRAM_SUMMARY, &prg); if (summary_pos < eof_pos) - gcov_seek (eof_pos); + gcov_seek(eof_pos); /* Write execution counts for each function. */ for (f_ix = 0; (unsigned int)f_ix != gi_ptr->n_functions; f_ix++) @@ -678,13 +678,13 @@ gcov_exit (void) length = 0; } - gcov_write_tag_length (GCOV_TAG_FUNCTION, length); + gcov_write_tag_length(GCOV_TAG_FUNCTION, length); if (!length) continue; - gcov_write_unsigned (gfi_ptr->ident); - gcov_write_unsigned (gfi_ptr->lineno_checksum); - gcov_write_unsigned (gfi_ptr->cfg_checksum); + gcov_write_unsigned(gfi_ptr->ident); + gcov_write_unsigned(gfi_ptr->lineno_checksum); + gcov_write_unsigned(gfi_ptr->cfg_checksum); ci_ptr = gfi_ptr->ctrs; for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++) @@ -693,25 +693,25 @@ gcov_exit (void) continue; n_counts = ci_ptr->num; - gcov_write_tag_length (GCOV_TAG_FOR_COUNTER (t_ix), - GCOV_TAG_COUNTER_LENGTH (n_counts)); + gcov_write_tag_length(GCOV_TAG_FOR_COUNTER(t_ix), + GCOV_TAG_COUNTER_LENGTH(n_counts)); gcov_type *c_ptr = ci_ptr->values; while (n_counts--) - gcov_write_counter (*c_ptr++); + gcov_write_counter(*c_ptr++); ci_ptr++; } if (buffered) - fn_buffer = free_fn_data (gi_ptr, fn_buffer, GCOV_COUNTERS); + fn_buffer = free_fn_data(gi_ptr, fn_buffer, GCOV_COUNTERS); } - gcov_write_unsigned (0); + gcov_write_unsigned(0); read_fatal:; while (fn_buffer) - fn_buffer = free_fn_data (gi_ptr, fn_buffer, GCOV_COUNTERS); + fn_buffer = free_fn_data(gi_ptr, fn_buffer, GCOV_COUNTERS); - if ((error = gcov_close ())) - fprintf (stderr, error < 0 ? + if ((error = gcov_close())) + fprintf(stderr, error < 0 ? "profiling:%s:Overflow writing\n" : "profiling:%s:Error writing\n", gi_filename); @@ -722,11 +722,11 @@ gcov_exit (void) when running an object file's global ctors. */ void -__gcov_init (struct gcov_info *info) +__gcov_init(struct gcov_info *info) { if (!info->version || !info->n_functions) return; - if (gcov_version (info, info->version, 0)) + if (gcov_version(info, info->version, 0)) { size_t filename_length = strlen(info->filename); @@ -736,7 +736,7 @@ __gcov_init (struct gcov_info *info) #ifndef __COREBOOT__ if (!gcov_list) - atexit (gcov_exit); + atexit(gcov_exit); #endif info->next = gcov_list; @@ -750,11 +750,11 @@ __gcov_init (struct gcov_info *info) profile information gathered so far. */ void -__gcov_flush (void) +__gcov_flush(void) { const struct gcov_info *gi_ptr; - gcov_exit (); + gcov_exit(); for (gi_ptr = gcov_list; gi_ptr; gi_ptr = gi_ptr->next) { unsigned int f_ix; @@ -772,7 +772,7 @@ __gcov_flush (void) if (!gi_ptr->merge[t_ix]) continue; - memset (ci_ptr->values, 0, sizeof (gcov_type) * ci_ptr->num); + memset(ci_ptr->values, 0, sizeof(gcov_type) * ci_ptr->num); ci_ptr++; } } @@ -786,10 +786,10 @@ __gcov_flush (void) 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 int n_counters) +__gcov_merge_add(gcov_type *counters, unsigned int n_counters) { for (; n_counters; counters++, n_counters--) - *counters += gcov_read_counter (); + *counters += gcov_read_counter(); } #endif /* L_gcov_merge_add */ @@ -798,10 +798,10 @@ __gcov_merge_add (gcov_type *counters, unsigned int n_counters) 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 int n_counters) +__gcov_merge_ior(gcov_type *counters, unsigned int n_counters) { for (; n_counters; counters++, n_counters--) - *counters |= gcov_read_counter (); + *counters |= gcov_read_counter(); } #endif @@ -817,18 +817,18 @@ __gcov_merge_ior (gcov_type *counters, unsigned int n_counters) * -- total number of evaluations of the value */ void -__gcov_merge_single (gcov_type *counters, unsigned int n_counters) +__gcov_merge_single(gcov_type *counters, unsigned int n_counters) { unsigned int i, n_measures; gcov_type value, counter, all; - gcc_assert (!(n_counters % 3)); + 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 (); + value = gcov_read_counter(); + counter = gcov_read_counter(); + all = gcov_read_counter(); if (counters[0] == value) counters[1] += counter; @@ -857,19 +857,19 @@ __gcov_merge_single (gcov_type *counters, unsigned int n_counters) * -- total number of evaluations of the value */ void -__gcov_merge_delta (gcov_type *counters, unsigned int n_counters) +__gcov_merge_delta(gcov_type *counters, unsigned int n_counters) { unsigned int i, n_measures; gcov_type value, counter, all; - gcc_assert (!(n_counters % 4)); + 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 (); + /* last = */ gcov_read_counter(); + value = gcov_read_counter(); + counter = gcov_read_counter(); + all = gcov_read_counter(); if (counters[1] == value) counters[2] += counter; @@ -892,7 +892,7 @@ __gcov_merge_delta (gcov_type *counters, unsigned int n_counters) instead. */ void -__gcov_interval_profiler (gcov_type *counters, gcov_type value, +__gcov_interval_profiler(gcov_type *counters, gcov_type value, int start, unsigned int steps) { gcov_type delta = value - start; @@ -910,7 +910,7 @@ __gcov_interval_profiler (gcov_type *counters, gcov_type value, COUNTERS[0] is incremented. */ void -__gcov_pow2_profiler (gcov_type *counters, gcov_type value) +__gcov_pow2_profiler(gcov_type *counters, gcov_type value) { if (value & (value - 1)) counters[0]++; @@ -930,7 +930,7 @@ __gcov_pow2_profiler (gcov_type *counters, gcov_type value) In any case, COUNTERS[2] is incremented. */ static inline void -__gcov_one_value_profiler_body (gcov_type *counters, gcov_type value) +__gcov_one_value_profiler_body(gcov_type *counters, gcov_type value) { if (value == counters[0]) counters[1]++; @@ -946,9 +946,9 @@ __gcov_one_value_profiler_body (gcov_type *counters, gcov_type value) #ifdef L_gcov_one_value_profiler void -__gcov_one_value_profiler (gcov_type *counters, gcov_type value) +__gcov_one_value_profiler(gcov_type *counters, gcov_type value) { - __gcov_one_value_profiler_body (counters, value); + __gcov_one_value_profiler_body(counters, value); } #endif @@ -973,7 +973,7 @@ __gcov_one_value_profiler (gcov_type *counters, gcov_type value) /* Tries to determine the most common value among its inputs. */ void -__gcov_indirect_call_profiler (gcov_type *counter, gcov_type value, +__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 @@ -982,7 +982,7 @@ __gcov_indirect_call_profiler (gcov_type *counter, gcov_type value, if (cur_func == callee_func || (VTABLE_USES_DESCRIPTORS && callee_func && *(void **) cur_func == *(void **) callee_func)) - __gcov_one_value_profiler_body (counter, value); + __gcov_one_value_profiler_body(counter, value); } #endif @@ -992,7 +992,7 @@ __gcov_indirect_call_profiler (gcov_type *counter, gcov_type value, to saturate up. */ void -__gcov_average_profiler (gcov_type *counters, gcov_type value) +__gcov_average_profiler(gcov_type *counters, gcov_type value) { counters[0] += value; counters[1] ++; @@ -1004,7 +1004,7 @@ __gcov_average_profiler (gcov_type *counters, gcov_type value) to saturate up. */ void -__gcov_ior_profiler (gcov_type *counters, gcov_type value) +__gcov_ior_profiler(gcov_type *counters, gcov_type value) { *counters |= value; } @@ -1015,10 +1015,10 @@ __gcov_ior_profiler (gcov_type *counters, gcov_type value) that they are not counted twice. */ pid_t -__gcov_fork (void) +__gcov_fork(void) { - __gcov_flush (); - return fork (); + __gcov_flush(); + return fork(); } #endif @@ -1027,29 +1027,29 @@ __gcov_fork (void) that they are not lost. */ int -__gcov_execl (const char *path, char *arg, ...) +__gcov_execl(const char *path, char *arg, ...) { va_list ap, aq; unsigned int i, length; char **args; - __gcov_flush (); + __gcov_flush(); - va_start (ap, arg); - va_copy (aq, ap); + va_start(ap, arg); + va_copy(aq, ap); length = 2; - while (va_arg (ap, char *)) + while (va_arg(ap, char *)) length++; - va_end (ap); + va_end(ap); - args = (char **) alloca (length * sizeof (void *)); + args = (char **) alloca(length * sizeof(void *)); args[0] = arg; for (i = 1; i < length; i++) - args[i] = va_arg (aq, char *); - va_end (aq); + args[i] = va_arg(aq, char *); + va_end(aq); - return execv (path, args); + return execv(path, args); } #endif @@ -1058,29 +1058,29 @@ __gcov_execl (const char *path, char *arg, ...) that they are not lost. */ int -__gcov_execlp (const char *path, char *arg, ...) +__gcov_execlp(const char *path, char *arg, ...) { va_list ap, aq; unsigned int i, length; char **args; - __gcov_flush (); + __gcov_flush(); - va_start (ap, arg); - va_copy (aq, ap); + va_start(ap, arg); + va_copy(aq, ap); length = 2; - while (va_arg (ap, char *)) + while (va_arg(ap, char *)) length++; - va_end (ap); + va_end(ap); - args = (char **) alloca (length * sizeof (void *)); + args = (char **) alloca(length * sizeof(void *)); args[0] = arg; for (i = 1; i < length; i++) - args[i] = va_arg (aq, char *); - va_end (aq); + args[i] = va_arg(aq, char *); + va_end(aq); - return execvp (path, args); + return execvp(path, args); } #endif @@ -1089,31 +1089,31 @@ __gcov_execlp (const char *path, char *arg, ...) that they are not lost. */ int -__gcov_execle (const char *path, char *arg, ...) +__gcov_execle(const char *path, char *arg, ...) { va_list ap, aq; unsigned int i, length; char **args; char **envp; - __gcov_flush (); + __gcov_flush(); - va_start (ap, arg); - va_copy (aq, ap); + va_start(ap, arg); + va_copy(aq, ap); length = 2; - while (va_arg (ap, char *)) + while (va_arg(ap, char *)) length++; - va_end (ap); + va_end(ap); - args = (char **) alloca (length * sizeof (void *)); + 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); + args[i] = va_arg(aq, char *); + envp = va_arg(aq, char **); + va_end(aq); - return execve (path, args, envp); + return execve(path, args, envp); } #endif @@ -1122,10 +1122,10 @@ __gcov_execle (const char *path, char *arg, ...) that they are not lost. */ int -__gcov_execv (const char *path, char *const argv[]) +__gcov_execv(const char *path, char *const argv[]) { - __gcov_flush (); - return execv (path, argv); + __gcov_flush(); + return execv(path, argv); } #endif @@ -1134,10 +1134,10 @@ __gcov_execv (const char *path, char *const argv[]) that they are not lost. */ int -__gcov_execvp (const char *path, char *const argv[]) +__gcov_execvp(const char *path, char *const argv[]) { - __gcov_flush (); - return execvp (path, argv); + __gcov_flush(); + return execvp(path, argv); } #endif @@ -1146,10 +1146,10 @@ __gcov_execvp (const char *path, char *const argv[]) that they are not lost. */ int -__gcov_execve (const char *path, char *const argv[], char *const envp[]) +__gcov_execve(const char *path, char *const argv[], char *const envp[]) { - __gcov_flush (); - return execve (path, argv, envp); + __gcov_flush(); + return execve(path, argv, envp); } #endif #endif /* inhibit_libc */ diff --git a/src/lib/selfboot.c b/src/lib/selfboot.c index f9f41d46df..86f77f72df 100644 --- a/src/lib/selfboot.c +++ b/src/lib/selfboot.c @@ -135,7 +135,7 @@ static int relocate_segment(unsigned long buffer, struct segment *seg) return 0; if (!arch_supports_bounce_buffer()) - die ("bounce buffer not supported"); + die("bounce buffer not supported"); start = seg->s_dstaddr; middle = start + seg->s_filesz; diff --git a/src/lib/thread.c b/src/lib/thread.c index 9387b037dd..53ffb92c59 100644 --- a/src/lib/thread.c +++ b/src/lib/thread.c @@ -186,7 +186,7 @@ static void asmlinkage call_wrapper_block_state(void *arg) /* Prepare a thread so that it starts by executing thread_entry(thread_arg). * Within thread_entry() it will call func(arg). */ static void prepare_thread(struct thread *t, void *func, void *arg, - void asmlinkage (*thread_entry)(void *), + asmlinkage void(*thread_entry)(void *), void *thread_arg) { /* Stash the function and argument to run. */ |