sravan/system76-coreboot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

src/lib: Remove space between function name and (

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