[coreboot-gerrit] New patch to review for coreboot: src/lib: Remove space between function name and (
Lee Leahy (leroy.p.leahy@intel.com)
gerrit at coreboot.org
Fri Mar 10 03:18:01 CET 2017
Lee Leahy (leroy.p.leahy at intel.com) just uploaded a new patch set to gerrit, which you can find at https://review.coreboot.org/18731
-gerrit
commit c0c26940c4c792a543a5ae86610e7dd4038371ab
Author: Lee Leahy <leroy.p.leahy at intel.com>
Date: Thu Mar 9 14:07:18 2017 -0800
src/lib: Remove space between function name and (
Fix the following warning detected by checkpatch.pl:
WARNING: space prohibited between function name and open parenthesis '('
TEST=Build and run on Galileo Gen2
Change-Id: I8f3c79302dc5eb1861ffb245617a27addf8653ef
Signed-off-by: Lee Leahy <Leroy.P.Leahy at intel.com>
---
src/lib/gcov-glue.c | 2 +-
src/lib/gcov-io.c | 186 ++++++++++++++--------------
src/lib/gcov-io.h | 126 +++++++++----------
src/lib/libgcov.c | 344 ++++++++++++++++++++++++++--------------------------
src/lib/selfboot.c | 2 +-
src/lib/thread.c | 2 +-
6 files changed, 331 insertions(+), 331 deletions(-)
diff --git a/src/lib/gcov-glue.c b/src/lib/gcov-glue.c
index d5e5584..45c3efa 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 2ec3999..ba9cfc9 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;
@@ -259,7 +259,7 @@ gcov_write_words (unsigned int words)
GCOV_LINKAGE void
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)
@@ -436,11 +436,11 @@ GCOV_LINKAGE gcov_unsigned_t
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,19 +470,19 @@ 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 ();
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;
@@ -490,11 +490,11 @@ gcov_read_summary (struct gcov_summary *summary)
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 d55588f..4c29127 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,35 +550,35 @@ 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
@@ -589,29 +589,29 @@ GCOV_LINKAGE void gcov_write_unsigned (gcov_unsigned_t) ATTRIBUTE_HIDDEN;
#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 488eb45..024b2c3 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 f9f41d4..86f77f7 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 9387b03..53ffb92 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. */
More information about the coreboot-gerrit
mailing list