1 /* File format for coverage information
2 Copyright (C) 1996, 1997, 1998, 2000, 2002, 2003, 2004, 2005, 2007,
3 2008 Free Software Foundation, Inc.
4 Contributed by Bob Manson <manson@cygnus.com>.
5 Completely remangled by Nathan Sidwell <nathan@codesourcery.com>.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* Routines declared in gcov-io.h. This file should be #included by
24 another source file, after having #included gcov-io.h. */
27 static void gcov_write_block (unsigned);
28 static gcov_unsigned_t
*gcov_write_words (unsigned);
30 static const gcov_unsigned_t
*gcov_read_words (unsigned);
32 static void gcov_allocate (unsigned);
35 static inline gcov_unsigned_t
from_file (gcov_unsigned_t value
)
40 value
= (value
>> 16) | (value
<< 16);
41 value
= ((value
& 0xff00ff) << 8) | ((value
>> 8) & 0xff00ff);
47 /* Open a gcov file. NAME is the name of the file to open and MODE
48 indicates whether a new file should be created, or an existing file
49 opened for modification. If MODE is >= 0 an existing file will be
50 opened, if possible, and if MODE is <= 0, a new file will be
51 created. Use MODE=0 to attempt to reopen an existing file and then
52 fall back on creating a new one. Return zero on failure, >0 on
53 opening an existing file and <0 on creating a new one. */
57 gcov_open (const char *name
)
59 gcov_open (const char *name
, int mode
)
69 s_flock
.l_type
= F_WRLCK
;
70 s_flock
.l_whence
= SEEK_SET
;
72 s_flock
.l_len
= 0; /* Until EOF. */
73 s_flock
.l_pid
= getpid ();
76 gcc_assert (!gcov_var
.file
);
78 gcov_var
.offset
= gcov_var
.length
= 0;
79 gcov_var
.overread
= -1u;
86 fd
= open (name
, O_RDWR
);
88 fd
= open (name
, O_RDWR
| O_CREAT
, 0666);
92 while (fcntl (fd
, F_SETLKW
, &s_flock
) && errno
== EINTR
)
95 gcov_var
.file
= fdopen (fd
, "r+b");
108 if (fstat (fd
, &st
) < 0)
110 fclose (gcov_var
.file
);
117 gcov_var
.mode
= mode
* 2 + 1;
120 gcov_var
.mode
= mode
* 2 + 1;
123 gcov_var
.file
= fopen (name
, "r+b");
128 gcov_var
.file
= fopen (name
, "w+b");
130 gcov_var
.mode
= mode
* 2 + 1;
136 setbuf (gcov_var
.file
, (char *)0);
141 /* Close the current gcov file. Flushes data to disk. Returns nonzero
142 on failure or error flag set. */
150 if (gcov_var
.offset
&& gcov_var
.mode
< 0)
151 gcov_write_block (gcov_var
.offset
);
153 fclose (gcov_var
.file
);
158 free (gcov_var
.buffer
);
163 return gcov_var
.error
;
167 /* Check if MAGIC is EXPECTED. Use it to determine endianness of the
168 file. Returns +1 for same endian, -1 for other endian and zero for
172 gcov_magic (gcov_unsigned_t magic
, gcov_unsigned_t expected
)
174 if (magic
== expected
)
176 magic
= (magic
>> 16) | (magic
<< 16);
177 magic
= ((magic
& 0xff00ff) << 8) | ((magic
>> 8) & 0xff00ff);
178 if (magic
== expected
)
189 gcov_allocate (unsigned length
)
191 size_t new_size
= gcov_var
.alloc
;
194 new_size
= GCOV_BLOCK_SIZE
;
198 gcov_var
.alloc
= new_size
;
199 gcov_var
.buffer
= XRESIZEVAR (gcov_unsigned_t
, gcov_var
.buffer
, new_size
<< 2);
204 /* Write out the current block, if needs be. */
207 gcov_write_block (unsigned size
)
209 if (fwrite (gcov_var
.buffer
, size
<< 2, 1, gcov_var
.file
) != 1)
211 gcov_var
.start
+= size
;
212 gcov_var
.offset
-= size
;
215 /* Allocate space to write BYTES bytes to the gcov file. Return a
216 pointer to those bytes, or NULL on failure. */
218 static gcov_unsigned_t
*
219 gcov_write_words (unsigned words
)
221 gcov_unsigned_t
*result
;
223 gcc_assert (gcov_var
.mode
< 0);
225 if (gcov_var
.offset
>= GCOV_BLOCK_SIZE
)
227 gcov_write_block (GCOV_BLOCK_SIZE
);
230 gcc_assert (gcov_var
.offset
== 1);
231 memcpy (gcov_var
.buffer
, gcov_var
.buffer
+ GCOV_BLOCK_SIZE
, 4);
235 if (gcov_var
.offset
+ words
> gcov_var
.alloc
)
236 gcov_allocate (gcov_var
.offset
+ words
);
238 result
= &gcov_var
.buffer
[gcov_var
.offset
];
239 gcov_var
.offset
+= words
;
244 /* Write unsigned VALUE to coverage file. Sets error flag
248 gcov_write_unsigned (gcov_unsigned_t value
)
250 gcov_unsigned_t
*buffer
= gcov_write_words (1);
255 /* Write counter VALUE to coverage file. Sets error flag
260 gcov_write_counter (gcov_type value
)
262 gcov_unsigned_t
*buffer
= gcov_write_words (2);
264 buffer
[0] = (gcov_unsigned_t
) value
;
265 if (sizeof (value
) > sizeof (gcov_unsigned_t
))
266 buffer
[1] = (gcov_unsigned_t
) (value
>> 32);
270 #endif /* IN_LIBGCOV */
273 /* Write STRING to coverage file. Sets error flag on file
274 error, overflow flag on overflow */
277 gcov_write_string (const char *string
)
281 gcov_unsigned_t
*buffer
;
285 length
= strlen (string
);
286 alloc
= (length
+ 4) >> 2;
289 buffer
= gcov_write_words (1 + alloc
);
293 memcpy (&buffer
[1], string
, length
);
298 /* Write a tag TAG and reserve space for the record length. Return a
299 value to be used for gcov_write_length. */
301 GCOV_LINKAGE gcov_position_t
302 gcov_write_tag (gcov_unsigned_t tag
)
304 gcov_position_t result
= gcov_var
.start
+ gcov_var
.offset
;
305 gcov_unsigned_t
*buffer
= gcov_write_words (2);
313 /* Write a record length using POSITION, which was returned by
314 gcov_write_tag. The current file position is the end of the
315 record, and is restored before returning. Returns nonzero on
319 gcov_write_length (gcov_position_t position
)
322 gcov_unsigned_t length
;
323 gcov_unsigned_t
*buffer
;
325 gcc_assert (gcov_var
.mode
< 0);
326 gcc_assert (position
+ 2 <= gcov_var
.start
+ gcov_var
.offset
);
327 gcc_assert (position
>= gcov_var
.start
);
328 offset
= position
- gcov_var
.start
;
329 length
= gcov_var
.offset
- offset
- 2;
330 buffer
= (gcov_unsigned_t
*) &gcov_var
.buffer
[offset
];
332 if (gcov_var
.offset
>= GCOV_BLOCK_SIZE
)
333 gcov_write_block (gcov_var
.offset
);
336 #else /* IN_LIBGCOV */
338 /* Write a tag TAG and length LENGTH. */
341 gcov_write_tag_length (gcov_unsigned_t tag
, gcov_unsigned_t length
)
343 gcov_unsigned_t
*buffer
= gcov_write_words (2);
349 /* Write a summary structure to the gcov file. Return nonzero on
353 gcov_write_summary (gcov_unsigned_t tag
, const struct gcov_summary
*summary
)
356 const struct gcov_ctr_summary
*csum
;
358 gcov_write_tag_length (tag
, GCOV_TAG_SUMMARY_LENGTH
);
359 gcov_write_unsigned (summary
->checksum
);
360 for (csum
= summary
->ctrs
, ix
= GCOV_COUNTERS_SUMMABLE
; ix
--; csum
++)
362 gcov_write_unsigned (csum
->num
);
363 gcov_write_unsigned (csum
->runs
);
364 gcov_write_counter (csum
->sum_all
);
365 gcov_write_counter (csum
->run_max
);
366 gcov_write_counter (csum
->sum_max
);
369 #endif /* IN_LIBGCOV */
373 /* Return a pointer to read BYTES bytes from the gcov file. Returns
374 NULL on failure (read past EOF). */
376 static const gcov_unsigned_t
*
377 gcov_read_words (unsigned words
)
379 const gcov_unsigned_t
*result
;
380 unsigned excess
= gcov_var
.length
- gcov_var
.offset
;
382 gcc_assert (gcov_var
.mode
> 0);
385 gcov_var
.start
+= gcov_var
.offset
;
389 gcc_assert (excess
== 1);
390 memcpy (gcov_var
.buffer
, gcov_var
.buffer
+ gcov_var
.offset
, 4);
393 memmove (gcov_var
.buffer
, gcov_var
.buffer
+ gcov_var
.offset
, excess
* 4);
396 gcov_var
.length
= excess
;
398 gcc_assert (!gcov_var
.length
|| gcov_var
.length
== 1);
399 excess
= GCOV_BLOCK_SIZE
;
401 if (gcov_var
.length
+ words
> gcov_var
.alloc
)
402 gcov_allocate (gcov_var
.length
+ words
);
403 excess
= gcov_var
.alloc
- gcov_var
.length
;
405 excess
= fread (gcov_var
.buffer
+ gcov_var
.length
,
406 1, excess
<< 2, gcov_var
.file
) >> 2;
407 gcov_var
.length
+= excess
;
408 if (gcov_var
.length
< words
)
410 gcov_var
.overread
+= words
- gcov_var
.length
;
415 result
= &gcov_var
.buffer
[gcov_var
.offset
];
416 gcov_var
.offset
+= words
;
420 /* Read unsigned value from a coverage file. Sets error flag on file
421 error, overflow flag on overflow */
423 GCOV_LINKAGE gcov_unsigned_t
424 gcov_read_unsigned (void)
426 gcov_unsigned_t value
;
427 const gcov_unsigned_t
*buffer
= gcov_read_words (1);
431 value
= from_file (buffer
[0]);
435 /* Read counter value from a coverage file. Sets error flag on file
436 error, overflow flag on overflow */
438 GCOV_LINKAGE gcov_type
439 gcov_read_counter (void)
442 const gcov_unsigned_t
*buffer
= gcov_read_words (2);
446 value
= from_file (buffer
[0]);
447 if (sizeof (value
) > sizeof (gcov_unsigned_t
))
448 value
|= ((gcov_type
) from_file (buffer
[1])) << 32;
455 /* Read string from coverage file. Returns a pointer to a static
456 buffer, or NULL on empty string. You must copy the string before
457 calling another gcov function. */
460 GCOV_LINKAGE
const char *
461 gcov_read_string (void)
463 unsigned length
= gcov_read_unsigned ();
468 return (const char *) gcov_read_words (length
);
473 gcov_read_summary (struct gcov_summary
*summary
)
476 struct gcov_ctr_summary
*csum
;
478 summary
->checksum
= gcov_read_unsigned ();
479 for (csum
= summary
->ctrs
, ix
= GCOV_COUNTERS_SUMMABLE
; ix
--; csum
++)
481 csum
->num
= gcov_read_unsigned ();
482 csum
->runs
= gcov_read_unsigned ();
483 csum
->sum_all
= gcov_read_counter ();
484 csum
->run_max
= gcov_read_counter ();
485 csum
->sum_max
= gcov_read_counter ();
490 /* Reset to a known position. BASE should have been obtained from
491 gcov_position, LENGTH should be a record length. */
494 gcov_sync (gcov_position_t base
, gcov_unsigned_t length
)
496 gcc_assert (gcov_var
.mode
> 0);
498 if (base
- gcov_var
.start
<= gcov_var
.length
)
499 gcov_var
.offset
= base
- gcov_var
.start
;
502 gcov_var
.offset
= gcov_var
.length
= 0;
503 fseek (gcov_var
.file
, base
<< 2, SEEK_SET
);
504 gcov_var
.start
= ftell (gcov_var
.file
) >> 2;
510 /* Move to a given position in a gcov file. */
513 gcov_seek (gcov_position_t base
)
515 gcc_assert (gcov_var
.mode
< 0);
517 gcov_write_block (gcov_var
.offset
);
518 fseek (gcov_var
.file
, base
<< 2, SEEK_SET
);
519 gcov_var
.start
= ftell (gcov_var
.file
) >> 2;
524 /* Return the modification time of the current gcov file. */
531 if (fstat (fileno (gcov_var
.file
), &status
))
534 return status
.st_mtime
;