GNUBoot
/
coreboot-kgpe-d16
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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>
This commit is contained in:
Lee Leahy 2017-03-09 14:07:18 -08:00 committed by Martin Roth
parent b6ee0f9d92
commit 38768c328a
6 changed files with 336 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/lib/gcov-glue.c
View File

@ -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);

194
src/lib/gcov-io.c
View File

@ -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;

128
src/lib/gcov-io.h
View File

@ -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

344
src/lib/libgcov.c
View File

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

2
src/lib/selfboot.c
View File

@ -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;

2
src/lib/thread.c
View File

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