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@intel.com>
Reviewed-on: https://review.coreboot.org/18731
Tested-by: build bot (Jenkins)
Reviewed-by: Martin Roth <martinroth@google.com>

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. */