gcc/gcov-io.c

   1 /* File format for coverage information
   2    Copyright (C) 1996, 1997, 1998, 2000, 2002,
   3    2003  Free Software Foundation, Inc.
   4    Contributed by Bob Manson <manson@cygnus.com>.
   5    Completely remangled by Nathan Sidwell <nathan@codesourcery.com>.
   6
   7 This file is part of GCC.
   8
   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 2, or (at your option) any later
  12 version.
  13
  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
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to the Free
  21 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  22 02111-1307, USA.  */
  23
  24 /* Routines declared in gcov-io.h.  This file should be #included by
  25    another source file, after having #included gcov-io.h.  */
  26
  27 #if !IN_GCOV
  28 static void gcov_write_block (unsigned);
  29 static gcov_unsigned_t *gcov_write_words (unsigned);
  30 #endif
  31 static const gcov_unsigned_t *gcov_read_words (unsigned);
  32 #if !IN_LIBGCOV
  33 static void gcov_allocate (unsigned);
  34 #endif
  35
  36 static inline gcov_unsigned_t from_file (gcov_unsigned_t value)
  37 {
  38 #if !IN_LIBGCOV
  39   if (gcov_var.endian)
  40     {
  41       value = (value >> 16) | (value << 16);
  42       value = ((value & 0xff00ff) << 8) | ((value >> 8) & 0xff00ff);
  43     }
  44 #endif
  45   return value;
  46 }
  47
  48 /* Open a gcov file. NAME is the name of the file to open and MODE
  49    indicates whether a new file should be created, or an existing file
  50    opened for modification. If MODE is >= 0 an existing file will be
  51    opened, if possible, and if MODE is <= 0, a new file will be
  52    created. Use MODE=0 to attempt to reopen an existing file and then
  53    fall back on creating a new one.  Return zero on failure, >0 on
  54    opening an existing file and <0 on creating a new one.  */
  55
  56 GCOV_LINKAGE int
  57 #if IN_LIBGCOV
  58 gcov_open (const char *name)
  59 #else
  60 gcov_open (const char *name, int mode)
  61 #endif
  62 {
  63 #if IN_LIBGCOV
  64   const int mode = 0;
  65 #endif
  66 #if GCOV_LOCKED
  67   struct flock s_flock;
  68
  69   s_flock.l_type = F_WRLCK;
  70   s_flock.l_whence = SEEK_SET;
  71   s_flock.l_start = 0;
  72   s_flock.l_len = 0; /* Until EOF.  */
  73   s_flock.l_pid = getpid ();
  74 #endif
  75
  76   if (gcov_var.file)
  77     abort ();
  78   gcov_var.start = 0;
  79   gcov_var.offset = gcov_var.length = 0;
  80   gcov_var.overread = -1u;
  81   gcov_var.error = 0;
  82 #if !IN_LIBGCOV
  83   gcov_var.endian = 0;
  84 #endif
  85   if (mode >= 0)
  86     gcov_var.file = fopen (name, "r+b");
  87   if (gcov_var.file)
  88     gcov_var.mode = 1;
  89   else if (mode <= 0)
  90     {
  91       gcov_var.file = fopen (name, "w+b");
  92       if (gcov_var.file)
  93         gcov_var.mode = mode * 2 + 1;
  94     }
  95   if (!gcov_var.file)
  96     return 0;
  97
  98   setbuf (gcov_var.file, (char *)0);
  99
 100 #if GCOV_LOCKED
 101   while (fcntl (fileno (gcov_var.file), F_SETLKW, &s_flock)
 102          && errno == EINTR)
 103     continue;
 104 #endif
 105
 106   return 1;
 107 }
 108
 109 /* Close the current gcov file. Flushes data to disk. Returns nonzero
 110    on failure or error flag set.  */
 111
 112 GCOV_LINKAGE int
 113 gcov_close (void)
 114 {
 115   if (gcov_var.file)
 116     {
 117 #if !IN_GCOV
 118       if (gcov_var.offset && gcov_var.mode < 0)
 119         gcov_write_block (gcov_var.offset);
 120 #endif
 121       fclose (gcov_var.file);
 122       gcov_var.file = 0;
 123       gcov_var.length = 0;
 124     }
 125 #if !IN_LIBGCOV
 126   free (gcov_var.buffer);
 127   gcov_var.alloc = 0;
 128   gcov_var.buffer = 0;
 129 #endif
 130   gcov_var.mode = 0;
 131   return gcov_var.error;
 132 }
 133
 134 #if !IN_LIBGCOV
 135 /* Check if MAGIC is EXPECTED. Use it to determine endianness of the
 136    file. Returns +1 for same endian, -1 for other endian and zero for
 137    not EXPECTED.  */
 138
 139 GCOV_LINKAGE int
 140 gcov_magic (gcov_unsigned_t magic, gcov_unsigned_t expected)
 141 {
 142   if (magic == expected)
 143     return 1;
 144   magic = (magic >> 16) | (magic << 16);
 145   magic = ((magic & 0xff00ff) << 8) | ((magic >> 8) & 0xff00ff);
 146   if (magic == expected)
 147     {
 148       gcov_var.endian = 1;
 149       return -1;
 150     }
 151   return 0;
 152 }
 153 #endif
 154
 155 #if !IN_LIBGCOV
 156 static void
 157 gcov_allocate (unsigned length)
 158 {
 159   size_t new_size = gcov_var.alloc;
 160
 161   if (!new_size)
 162     new_size = GCOV_BLOCK_SIZE;
 163   new_size += length;
 164   new_size *= 2;
 165
 166   gcov_var.alloc = new_size;
 167   gcov_var.buffer = xrealloc (gcov_var.buffer, new_size << 2);
 168 }
 169 #endif
 170
 171 #if !IN_GCOV
 172 /* Write out the current block, if needs be.  */
 173
 174 static void
 175 gcov_write_block (unsigned size)
 176 {
 177   if (fwrite (gcov_var.buffer, size << 2, 1, gcov_var.file) != 1)
 178     gcov_var.error = 1;
 179   gcov_var.start += size;
 180   gcov_var.offset -= size;
 181 }
 182
 183 /* Allocate space to write BYTES bytes to the gcov file. Return a
 184    pointer to those bytes, or NULL on failure.  */
 185
 186 static gcov_unsigned_t *
 187 gcov_write_words (unsigned words)
 188 {
 189   gcov_unsigned_t *result;
 190
 191   GCOV_CHECK_WRITING ();
 192 #if IN_LIBGCOV
 193   if (gcov_var.offset >= GCOV_BLOCK_SIZE)
 194     {
 195       gcov_write_block (GCOV_BLOCK_SIZE);
 196       if (gcov_var.offset)
 197         {
 198           GCOV_CHECK (gcov_var.offset == 1);
 199           memcpy (gcov_var.buffer, gcov_var.buffer + GCOV_BLOCK_SIZE, 4);
 200         }
 201     }
 202 #else
 203   if (gcov_var.offset + words > gcov_var.alloc)
 204     gcov_allocate (gcov_var.offset + words);
 205 #endif
 206   result = &gcov_var.buffer[gcov_var.offset];
 207   gcov_var.offset += words;
 208
 209   return result;
 210 }
 211
 212 /* Write unsigned VALUE to coverage file.  Sets error flag
 213    appropriately.  */
 214
 215 GCOV_LINKAGE void
 216 gcov_write_unsigned (gcov_unsigned_t value)
 217 {
 218   gcov_unsigned_t *buffer = gcov_write_words (1);
 219
 220   buffer[0] = value;
 221 }
 222
 223 /* Write counter VALUE to coverage file.  Sets error flag
 224    appropriately.  */
 225
 226 #if IN_LIBGCOV
 227 GCOV_LINKAGE void
 228 gcov_write_counter (gcov_type value)
 229 {
 230   gcov_unsigned_t *buffer = gcov_write_words (2);
 231
 232   buffer[0] = (gcov_unsigned_t) value;
 233   if (sizeof (value) > sizeof (gcov_unsigned_t))
 234     buffer[1] = (gcov_unsigned_t) (value >> 32);
 235   else
 236     buffer[1] = 0;
 237
 238   if (value < 0)
 239     gcov_var.error = -1;
 240 }
 241 #endif /* IN_LIBGCOV */
 242
 243 #if !IN_LIBGCOV
 244 /* Write STRING to coverage file.  Sets error flag on file
 245    error, overflow flag on overflow */
 246
 247 GCOV_LINKAGE void
 248 gcov_write_string (const char *string)
 249 {
 250   unsigned length = 0;
 251   unsigned alloc = 0;
 252   gcov_unsigned_t *buffer;
 253
 254   if (string)
 255     {
 256       length = strlen (string);
 257       alloc = (length + 4) >> 2;
 258     }
 259
 260   buffer = gcov_write_words (1 + alloc);
 261
 262   buffer[0] = alloc;
 263   buffer[alloc] = 0;
 264   memcpy (&buffer[1], string, length);
 265 }
 266 #endif
 267
 268 #if !IN_LIBGCOV
 269 /* Write a tag TAG and reserve space for the record length. Return a
 270    value to be used for gcov_write_length.  */
 271
 272 GCOV_LINKAGE gcov_position_t
 273 gcov_write_tag (gcov_unsigned_t tag)
 274 {
 275   gcov_position_t result = gcov_var.start + gcov_var.offset;
 276   gcov_unsigned_t *buffer = gcov_write_words (2);
 277
 278   buffer[0] = tag;
 279   buffer[1] = 0;
 280
 281   return result;
 282 }
 283
 284 /* Write a record length using POSITION, which was returned by
 285    gcov_write_tag.  The current file position is the end of the
 286    record, and is restored before returning.  Returns nonzero on
 287    overflow.  */
 288
 289 GCOV_LINKAGE void
 290 gcov_write_length (gcov_position_t position)
 291 {
 292   unsigned offset;
 293   gcov_unsigned_t length;
 294   gcov_unsigned_t *buffer;
 295
 296   GCOV_CHECK_WRITING ();
 297   GCOV_CHECK (position + 2 <= gcov_var.start + gcov_var.offset);
 298   GCOV_CHECK (position >= gcov_var.start);
 299   offset = position - gcov_var.start;
 300   length = gcov_var.offset - offset - 2;
 301   buffer = (gcov_unsigned_t *) &gcov_var.buffer[offset];
 302   buffer[1] = length;
 303   if (gcov_var.offset >= GCOV_BLOCK_SIZE)
 304     gcov_write_block (gcov_var.offset);
 305 }
 306
 307 #else /* IN_LIBGCOV */
 308
 309 /* Write a tag TAG and length LENGTH.  */
 310
 311 GCOV_LINKAGE void
 312 gcov_write_tag_length (gcov_unsigned_t tag, gcov_unsigned_t length)
 313 {
 314   gcov_unsigned_t *buffer = gcov_write_words (2);
 315
 316   buffer[0] = tag;
 317   buffer[1] = length;
 318 }
 319
 320 /* Write a summary structure to the gcov file.  Return nonzero on
 321    overflow.  */
 322
 323 GCOV_LINKAGE void
 324 gcov_write_summary (gcov_unsigned_t tag, const struct gcov_summary *summary)
 325 {
 326   unsigned ix;
 327   const struct gcov_ctr_summary *csum;
 328
 329   gcov_write_tag_length (tag, GCOV_TAG_SUMMARY_LENGTH);
 330   gcov_write_unsigned (summary->checksum);
 331   for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++)
 332     {
 333       gcov_write_unsigned (csum->num);
 334       gcov_write_unsigned (csum->runs);
 335       gcov_write_counter (csum->sum_all);
 336       gcov_write_counter (csum->run_max);
 337       gcov_write_counter (csum->sum_max);
 338     }
 339 }
 340 #endif /* IN_LIBGCOV */
 341
 342 #endif /*!IN_GCOV */
 343
 344 /* Return a pointer to read BYTES bytes from the gcov file. Returns
 345    NULL on failure (read past EOF).  */
 346
 347 static const gcov_unsigned_t *
 348 gcov_read_words (unsigned words)
 349 {
 350   const gcov_unsigned_t *result;
 351   unsigned excess = gcov_var.length - gcov_var.offset;
 352
 353   GCOV_CHECK_READING ();
 354   if (excess < words)
 355     {
 356       gcov_var.start += gcov_var.offset;
 357 #if IN_LIBGCOV
 358       if (excess)
 359         {
 360           GCOV_CHECK (excess == 1);
 361           memcpy (gcov_var.buffer, gcov_var.buffer + gcov_var.offset, 4);
 362         }
 363 #else
 364       memmove (gcov_var.buffer, gcov_var.buffer + gcov_var.offset, excess);
 365 #endif
 366       gcov_var.offset = 0;
 367       gcov_var.length = excess;
 368 #if IN_LIBGCOV
 369       GCOV_CHECK (!gcov_var.length || gcov_var.length == 1);
 370       excess = GCOV_BLOCK_SIZE;
 371 #else
 372       if (gcov_var.length + words > gcov_var.alloc)
 373         gcov_allocate (gcov_var.length + words);
 374       excess = gcov_var.alloc - gcov_var.length;
 375 #endif
 376       excess = fread (gcov_var.buffer + gcov_var.length,
 377                       1, excess << 2, gcov_var.file) >> 2;
 378       gcov_var.length += excess;
 379       if (gcov_var.length < words)
 380         {
 381           gcov_var.overread += words - gcov_var.length;
 382           gcov_var.length = 0;
 383           return 0;
 384         }
 385     }
 386   result = &gcov_var.buffer[gcov_var.offset];
 387   gcov_var.offset += words;
 388   return result;
 389 }
 390
 391 /* Read unsigned value from a coverage file. Sets error flag on file
 392    error, overflow flag on overflow */
 393
 394 GCOV_LINKAGE gcov_unsigned_t
 395 gcov_read_unsigned (void)
 396 {
 397   gcov_unsigned_t value;
 398   const gcov_unsigned_t *buffer = gcov_read_words (1);
 399
 400   if (!buffer)
 401     return 0;
 402   value = from_file (buffer[0]);
 403   return value;
 404 }
 405
 406 /* Read counter value from a coverage file. Sets error flag on file
 407    error, overflow flag on overflow */
 408
 409 GCOV_LINKAGE gcov_type
 410 gcov_read_counter (void)
 411 {
 412   gcov_type value;
 413   const gcov_unsigned_t *buffer = gcov_read_words (2);
 414
 415   if (!buffer)
 416     return 0;
 417   value = from_file (buffer[0]);
 418   if (sizeof (value) > sizeof (gcov_unsigned_t))
 419     value |= ((gcov_type) from_file (buffer[1])) << 32;
 420   else if (buffer[1])
 421     gcov_var.error = -1;
 422
 423   if (value < 0)
 424     gcov_var.error = -1;
 425   return value;
 426 }
 427
 428 /* Read string from coverage file. Returns a pointer to a static
 429    buffer, or NULL on empty string. You must copy the string before
 430    calling another gcov function.  */
 431
 432 #if !IN_LIBGCOV
 433 GCOV_LINKAGE const char *
 434 gcov_read_string (void)
 435 {
 436   unsigned length = gcov_read_unsigned ();
 437
 438   if (!length)
 439     return 0;
 440
 441   return (const char *) gcov_read_words (length);
 442 }
 443 #endif
 444
 445 GCOV_LINKAGE void
 446 gcov_read_summary (struct gcov_summary *summary)
 447 {
 448   unsigned ix;
 449   struct gcov_ctr_summary *csum;
 450
 451   summary->checksum = gcov_read_unsigned ();
 452   for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++)
 453     {
 454       csum->num = gcov_read_unsigned ();
 455       csum->runs = gcov_read_unsigned ();
 456       csum->sum_all = gcov_read_counter ();
 457       csum->run_max = gcov_read_counter ();
 458       csum->sum_max = gcov_read_counter ();
 459     }
 460 }
 461
 462 #if !IN_LIBGCOV
 463 /* Reset to a known position.  BASE should have been obtained from
 464    gcov_position, LENGTH should be a record length.  */
 465
 466 GCOV_LINKAGE void
 467 gcov_sync (gcov_position_t base, gcov_unsigned_t length)
 468 {
 469   GCOV_CHECK_READING ();
 470   base += length;
 471   if (base - gcov_var.start <= gcov_var.length)
 472     gcov_var.offset = base - gcov_var.start;
 473   else
 474     {
 475       gcov_var.offset = gcov_var.length = 0;
 476       fseek (gcov_var.file, base << 2, SEEK_SET);
 477       gcov_var.start = ftell (gcov_var.file) >> 2;
 478     }
 479 }
 480 #endif
 481
 482 #if IN_LIBGCOV
 483 /* Move to the a set position in a gcov file.  BASE is zero to move to
 484    the end, and nonzero to move to that position.  */
 485
 486 GCOV_LINKAGE void
 487 gcov_seek (gcov_position_t base)
 488 {
 489   GCOV_CHECK_WRITING ();
 490   if (gcov_var.offset)
 491     gcov_write_block (gcov_var.offset);
 492   fseek (gcov_var.file, base << 2, base ? SEEK_SET : SEEK_END);
 493   gcov_var.start = ftell (gcov_var.file) >> 2;
 494 }
 495 #endif
 496
 497 #if IN_GCOV > 0
 498 /* Return the modification time of the current gcov file.  */
 499
 500 GCOV_LINKAGE time_t
 501 gcov_time (void)
 502 {
 503   struct stat status;
 504
 505   if (fstat (fileno (gcov_var.file), &status))
 506     return 0;
 507   else
 508     return status.st_mtime;
 509 }
 510 #endif /* IN_GCOV */