contrib/gcc-8.0/gcc/gcov-io.c

   1 /* File format for coverage information
   2    Copyright (C) 1996-2018 Free Software Foundation, Inc.
   3    Contributed by Bob Manson <manson@cygnus.com>.
   4    Completely remangled by Nathan Sidwell <nathan@codesourcery.com>.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 Under Section 7 of GPL version 3, you are granted additional
  19 permissions described in the GCC Runtime Library Exception, version
  20 3.1, as published by the Free Software Foundation.
  21
  22 You should have received a copy of the GNU General Public License and
  23 a copy of the GCC Runtime Library Exception along with this program;
  24 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  25 <http://www.gnu.org/licenses/>.  */
  26
  27 /* Routines declared in gcov-io.h.  This file should be #included by
  28    another source file, after having #included gcov-io.h.  */
  29
  30 #if !IN_GCOV
  31 static void gcov_write_block (unsigned);
  32 static gcov_unsigned_t *gcov_write_words (unsigned);
  33 #endif
  34 static const gcov_unsigned_t *gcov_read_words (unsigned);
  35 #if !IN_LIBGCOV
  36 static void gcov_allocate (unsigned);
  37 #endif
  38
  39 /* Optimum number of gcov_unsigned_t's read from or written to disk.  */
  40 #define GCOV_BLOCK_SIZE (1 << 10)
  41
  42 struct gcov_var
  43 {
  44   FILE *file;
  45   gcov_position_t start;        /* Position of first byte of block */
  46   unsigned offset;              /* Read/write position within the block.  */
  47   unsigned length;              /* Read limit in the block.  */
  48   unsigned overread;            /* Number of words overread.  */
  49   int error;                    /* < 0 overflow, > 0 disk error.  */
  50   int mode;                     /* < 0 writing, > 0 reading */
  51 #if IN_LIBGCOV
  52   /* Holds one block plus 4 bytes, thus all coverage reads & writes
  53      fit within this buffer and we always can transfer GCOV_BLOCK_SIZE
  54      to and from the disk. libgcov never backtracks and only writes 4
  55      or 8 byte objects.  */
  56   gcov_unsigned_t buffer[GCOV_BLOCK_SIZE + 1];
  57 #else
  58   int endian;                   /* Swap endianness.  */
  59   /* Holds a variable length block, as the compiler can write
  60      strings and needs to backtrack.  */
  61   size_t alloc;
  62   gcov_unsigned_t *buffer;
  63 #endif
  64 } gcov_var;
  65
  66 /* Save the current position in the gcov file.  */
  67 /* We need to expose this function when compiling for gcov-tool.  */
  68 #ifndef IN_GCOV_TOOL
  69 static inline
  70 #endif
  71 gcov_position_t
  72 gcov_position (void)
  73 {
  74   gcov_nonruntime_assert (gcov_var.mode > 0);
  75   return gcov_var.start + gcov_var.offset;
  76 }
  77
  78 /* Return nonzero if the error flag is set.  */
  79 /* We need to expose this function when compiling for gcov-tool.  */
  80 #ifndef IN_GCOV_TOOL
  81 static inline
  82 #endif
  83 int
  84 gcov_is_error (void)
  85 {
  86   return gcov_var.file ? gcov_var.error : 1;
  87 }
  88
  89 #if IN_LIBGCOV
  90 /* Move to beginning of file and initialize for writing.  */
  91 GCOV_LINKAGE inline void
  92 gcov_rewrite (void)
  93 {
  94   gcov_var.mode = -1;
  95   gcov_var.start = 0;
  96   gcov_var.offset = 0;
  97   fseek (gcov_var.file, 0L, SEEK_SET);
  98 }
  99 #endif
 100
 101 static inline gcov_unsigned_t from_file (gcov_unsigned_t value)
 102 {
 103 #if !IN_LIBGCOV
 104   if (gcov_var.endian)
 105     {
 106       value = (value >> 16) | (value << 16);
 107       value = ((value & 0xff00ff) << 8) | ((value >> 8) & 0xff00ff);
 108     }
 109 #endif
 110   return value;
 111 }
 112
 113 /* Open a gcov file. NAME is the name of the file to open and MODE
 114    indicates whether a new file should be created, or an existing file
 115    opened. If MODE is >= 0 an existing file will be opened, if
 116    possible, and if MODE is <= 0, a new file will be created. Use
 117    MODE=0 to attempt to reopen an existing file and then fall back on
 118    creating a new one.  If MODE > 0, the file will be opened in
 119    read-only mode.  Otherwise it will be opened for modification.
 120    Return zero on failure, non-zero on success.  */
 121
 122 GCOV_LINKAGE int
 123 #if IN_LIBGCOV
 124 gcov_open (const char *name)
 125 #else
 126 gcov_open (const char *name, int mode)
 127 #endif
 128 {
 129 #if IN_LIBGCOV
 130   int mode = 0;
 131 #endif
 132 #if GCOV_LOCKED
 133   struct flock s_flock;
 134   int fd;
 135
 136   s_flock.l_whence = SEEK_SET;
 137   s_flock.l_start = 0;
 138   s_flock.l_len = 0; /* Until EOF.  */
 139   s_flock.l_pid = getpid ();
 140 #endif
 141
 142   gcov_nonruntime_assert (!gcov_var.file);
 143   gcov_var.start = 0;
 144   gcov_var.offset = gcov_var.length = 0;
 145   gcov_var.overread = -1u;
 146   gcov_var.error = 0;
 147 #if !IN_LIBGCOV
 148   gcov_var.endian = 0;
 149 #endif
 150 #if GCOV_LOCKED
 151   if (mode > 0)
 152     {
 153       /* Read-only mode - acquire a read-lock.  */
 154       s_flock.l_type = F_RDLCK;
 155       /* pass mode (ignored) for compatibility */
 156       fd = open (name, O_RDONLY, S_IRUSR | S_IWUSR);
 157     }
 158   else
 159      {
 160        /* Write mode - acquire a write-lock.  */
 161        s_flock.l_type = F_WRLCK;
 162        /* Truncate if force new mode.  */
 163        fd = open (name, O_RDWR | O_CREAT | (mode < 0 ? O_TRUNC : 0), 0666);
 164     }
 165   if (fd < 0)
 166     return 0;
 167
 168   while (fcntl (fd, F_SETLKW, &s_flock) && errno == EINTR)
 169     continue;
 170
 171   gcov_var.file = fdopen (fd, (mode > 0) ? "rb" : "r+b");
 172
 173   if (!gcov_var.file)
 174     {
 175       close (fd);
 176       return 0;
 177     }
 178 #else
 179   if (mode >= 0)
 180     /* Open an existing file.  */
 181     gcov_var.file = fopen (name, (mode > 0) ? "rb" : "r+b");
 182
 183   if (gcov_var.file)
 184     mode = 1;
 185   else if (mode <= 0)
 186     /* Create a new file.  */
 187     gcov_var.file = fopen (name, "w+b");
 188
 189   if (!gcov_var.file)
 190     return 0;
 191 #endif
 192
 193   gcov_var.mode = mode ? mode : 1;
 194
 195   setbuf (gcov_var.file, (char *)0);
 196
 197   return 1;
 198 }
 199
 200 /* Close the current gcov file. Flushes data to disk. Returns nonzero
 201    on failure or error flag set.  */
 202
 203 GCOV_LINKAGE int
 204 gcov_close (void)
 205 {
 206   if (gcov_var.file)
 207     {
 208 #if !IN_GCOV
 209       if (gcov_var.offset && gcov_var.mode < 0)
 210         gcov_write_block (gcov_var.offset);
 211 #endif
 212       fclose (gcov_var.file);
 213       gcov_var.file = 0;
 214       gcov_var.length = 0;
 215     }
 216 #if !IN_LIBGCOV
 217   free (gcov_var.buffer);
 218   gcov_var.alloc = 0;
 219   gcov_var.buffer = 0;
 220 #endif
 221   gcov_var.mode = 0;
 222   return gcov_var.error;
 223 }
 224
 225 #if !IN_LIBGCOV
 226 /* Check if MAGIC is EXPECTED. Use it to determine endianness of the
 227    file. Returns +1 for same endian, -1 for other endian and zero for
 228    not EXPECTED.  */
 229
 230 GCOV_LINKAGE int
 231 gcov_magic (gcov_unsigned_t magic, gcov_unsigned_t expected)
 232 {
 233   if (magic == expected)
 234     return 1;
 235   magic = (magic >> 16) | (magic << 16);
 236   magic = ((magic & 0xff00ff) << 8) | ((magic >> 8) & 0xff00ff);
 237   if (magic == expected)
 238     {
 239       gcov_var.endian = 1;
 240       return -1;
 241     }
 242   return 0;
 243 }
 244 #endif
 245
 246 #if !IN_LIBGCOV
 247 static void
 248 gcov_allocate (unsigned length)
 249 {
 250   size_t new_size = gcov_var.alloc;
 251
 252   if (!new_size)
 253     new_size = GCOV_BLOCK_SIZE;
 254   new_size += length;
 255   new_size *= 2;
 256
 257   gcov_var.alloc = new_size;
 258   gcov_var.buffer = XRESIZEVAR (gcov_unsigned_t, gcov_var.buffer, new_size << 2);
 259 }
 260 #endif
 261
 262 #if !IN_GCOV
 263 /* Write out the current block, if needs be.  */
 264
 265 static void
 266 gcov_write_block (unsigned size)
 267 {
 268   if (fwrite (gcov_var.buffer, size << 2, 1, gcov_var.file) != 1)
 269     gcov_var.error = 1;
 270   gcov_var.start += size;
 271   gcov_var.offset -= size;
 272 }
 273
 274 /* Allocate space to write BYTES bytes to the gcov file. Return a
 275    pointer to those bytes, or NULL on failure.  */
 276
 277 static gcov_unsigned_t *
 278 gcov_write_words (unsigned words)
 279 {
 280   gcov_unsigned_t *result;
 281
 282   gcov_nonruntime_assert (gcov_var.mode < 0);
 283 #if IN_LIBGCOV
 284   if (gcov_var.offset >= GCOV_BLOCK_SIZE)
 285     {
 286       gcov_write_block (GCOV_BLOCK_SIZE);
 287       if (gcov_var.offset)
 288         {
 289           memcpy (gcov_var.buffer, gcov_var.buffer + GCOV_BLOCK_SIZE, 4);
 290         }
 291     }
 292 #else
 293   if (gcov_var.offset + words > gcov_var.alloc)
 294     gcov_allocate (gcov_var.offset + words);
 295 #endif
 296   result = &gcov_var.buffer[gcov_var.offset];
 297   gcov_var.offset += words;
 298
 299   return result;
 300 }
 301
 302 /* Write unsigned VALUE to coverage file.  Sets error flag
 303    appropriately.  */
 304
 305 GCOV_LINKAGE void
 306 gcov_write_unsigned (gcov_unsigned_t value)
 307 {
 308   gcov_unsigned_t *buffer = gcov_write_words (1);
 309
 310   buffer[0] = value;
 311 }
 312
 313 /* Write counter VALUE to coverage file.  Sets error flag
 314    appropriately.  */
 315
 316 #if IN_LIBGCOV
 317 GCOV_LINKAGE void
 318 gcov_write_counter (gcov_type value)
 319 {
 320   gcov_unsigned_t *buffer = gcov_write_words (2);
 321
 322   buffer[0] = (gcov_unsigned_t) value;
 323   if (sizeof (value) > sizeof (gcov_unsigned_t))
 324     buffer[1] = (gcov_unsigned_t) (value >> 32);
 325   else
 326     buffer[1] = 0;
 327 }
 328 #endif /* IN_LIBGCOV */
 329
 330 #if !IN_LIBGCOV
 331 /* Write STRING to coverage file.  Sets error flag on file
 332    error, overflow flag on overflow */
 333
 334 GCOV_LINKAGE void
 335 gcov_write_string (const char *string)
 336 {
 337   unsigned length = 0;
 338   unsigned alloc = 0;
 339   gcov_unsigned_t *buffer;
 340
 341   if (string)
 342     {
 343       length = strlen (string);
 344       alloc = (length + 4) >> 2;
 345     }
 346
 347   buffer = gcov_write_words (1 + alloc);
 348
 349   buffer[0] = alloc;
 350
 351   if (alloc > 0)
 352     {
 353       buffer[alloc] = 0; /* place nul terminators.  */
 354       memcpy (&buffer[1], string, length);
 355     }
 356 }
 357 #endif
 358
 359 #if !IN_LIBGCOV
 360 /* Write FILENAME to coverage file.  Sets error flag on file
 361    error, overflow flag on overflow */
 362
 363 GCOV_LINKAGE void
 364 gcov_write_filename (const char *filename)
 365 {
 366   if (profile_abs_path_flag && filename && filename[0]
 367       && !(IS_DIR_SEPARATOR (filename[0])
 368 #if HAVE_DOS_BASED_FILE_SYSTEM
 369            || filename[1] == ':'
 370 #endif
 371           ))
 372     {
 373       char *buf = getcwd (NULL, 0);
 374       if (buf != NULL && buf[0])
 375         {
 376           size_t len = strlen (buf);
 377           buf = (char*)xrealloc (buf, len + strlen (filename) + 2);
 378           if (!IS_DIR_SEPARATOR (buf[len - 1]))
 379             strcat (buf, "/");
 380           strcat (buf, filename);
 381           gcov_write_string (buf);
 382           free (buf);
 383           return;
 384         }
 385     }
 386
 387   gcov_write_string (filename);
 388 }
 389 #endif
 390
 391 #if !IN_LIBGCOV
 392 /* Write a tag TAG and reserve space for the record length. Return a
 393    value to be used for gcov_write_length.  */
 394
 395 GCOV_LINKAGE gcov_position_t
 396 gcov_write_tag (gcov_unsigned_t tag)
 397 {
 398   gcov_position_t result = gcov_var.start + gcov_var.offset;
 399   gcov_unsigned_t *buffer = gcov_write_words (2);
 400
 401   buffer[0] = tag;
 402   buffer[1] = 0;
 403
 404   return result;
 405 }
 406
 407 /* Write a record length using POSITION, which was returned by
 408    gcov_write_tag.  The current file position is the end of the
 409    record, and is restored before returning.  Returns nonzero on
 410    overflow.  */
 411
 412 GCOV_LINKAGE void
 413 gcov_write_length (gcov_position_t position)
 414 {
 415   unsigned offset;
 416   gcov_unsigned_t length;
 417   gcov_unsigned_t *buffer;
 418
 419   gcov_nonruntime_assert (gcov_var.mode < 0);
 420   gcov_nonruntime_assert (position + 2 <= gcov_var.start + gcov_var.offset);
 421   gcov_nonruntime_assert (position >= gcov_var.start);
 422   offset = position - gcov_var.start;
 423   length = gcov_var.offset - offset - 2;
 424   buffer = (gcov_unsigned_t *) &gcov_var.buffer[offset];
 425   buffer[1] = length;
 426   if (gcov_var.offset >= GCOV_BLOCK_SIZE)
 427     gcov_write_block (gcov_var.offset);
 428 }
 429
 430 #else /* IN_LIBGCOV */
 431
 432 /* Write a tag TAG and length LENGTH.  */
 433
 434 GCOV_LINKAGE void
 435 gcov_write_tag_length (gcov_unsigned_t tag, gcov_unsigned_t length)
 436 {
 437   gcov_unsigned_t *buffer = gcov_write_words (2);
 438
 439   buffer[0] = tag;
 440   buffer[1] = length;
 441 }
 442
 443 /* Write a summary structure to the gcov file.  Return nonzero on
 444    overflow.  */
 445
 446 GCOV_LINKAGE void
 447 gcov_write_summary (gcov_unsigned_t tag, const struct gcov_summary *summary)
 448 {
 449   unsigned ix, h_ix, bv_ix, h_cnt = 0;
 450   const struct gcov_ctr_summary *csum;
 451   unsigned histo_bitvector[GCOV_HISTOGRAM_BITVECTOR_SIZE];
 452
 453   /* Count number of non-zero histogram entries, and fill in a bit vector
 454      of non-zero indices. The histogram is only currently computed for arc
 455      counters.  */
 456   for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
 457     histo_bitvector[bv_ix] = 0;
 458   csum = &summary->ctrs[GCOV_COUNTER_ARCS];
 459   for (h_ix = 0; h_ix < GCOV_HISTOGRAM_SIZE; h_ix++)
 460     if (csum->histogram[h_ix].num_counters)
 461       {
 462         histo_bitvector[h_ix / 32] |= 1 << (h_ix % 32);
 463         h_cnt++;
 464       }
 465   gcov_write_tag_length (tag, GCOV_TAG_SUMMARY_LENGTH (h_cnt));
 466   gcov_write_unsigned (summary->checksum);
 467   for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++)
 468     {
 469       gcov_write_unsigned (csum->num);
 470       gcov_write_unsigned (csum->runs);
 471       gcov_write_counter (csum->sum_all);
 472       gcov_write_counter (csum->run_max);
 473       gcov_write_counter (csum->sum_max);
 474       if (ix != GCOV_COUNTER_ARCS)
 475         {
 476           for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
 477             gcov_write_unsigned (0);
 478           continue;
 479         }
 480       for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
 481         gcov_write_unsigned (histo_bitvector[bv_ix]);
 482       for (h_ix = 0; h_ix < GCOV_HISTOGRAM_SIZE; h_ix++)
 483         {
 484           if (!csum->histogram[h_ix].num_counters)
 485             continue;
 486           gcov_write_unsigned (csum->histogram[h_ix].num_counters);
 487           gcov_write_counter (csum->histogram[h_ix].min_value);
 488           gcov_write_counter (csum->histogram[h_ix].cum_value);
 489         }
 490     }
 491 }
 492 #endif /* IN_LIBGCOV */
 493
 494 #endif /*!IN_GCOV */
 495
 496 /* Return a pointer to read BYTES bytes from the gcov file. Returns
 497    NULL on failure (read past EOF).  */
 498
 499 static const gcov_unsigned_t *
 500 gcov_read_words (unsigned words)
 501 {
 502   const gcov_unsigned_t *result;
 503   unsigned excess = gcov_var.length - gcov_var.offset;
 504
 505   if (gcov_var.mode <= 0)
 506     return NULL;
 507
 508   if (excess < words)
 509     {
 510       gcov_var.start += gcov_var.offset;
 511       if (excess)
 512         {
 513 #if IN_LIBGCOV
 514           memcpy (gcov_var.buffer, gcov_var.buffer + gcov_var.offset, 4);
 515 #else
 516           memmove (gcov_var.buffer, gcov_var.buffer + gcov_var.offset,
 517                    excess * 4);
 518 #endif
 519         }
 520       gcov_var.offset = 0;
 521       gcov_var.length = excess;
 522 #if IN_LIBGCOV
 523       excess = GCOV_BLOCK_SIZE;
 524 #else
 525       if (gcov_var.length + words > gcov_var.alloc)
 526         gcov_allocate (gcov_var.length + words);
 527       excess = gcov_var.alloc - gcov_var.length;
 528 #endif
 529       excess = fread (gcov_var.buffer + gcov_var.length,
 530                       1, excess << 2, gcov_var.file) >> 2;
 531       gcov_var.length += excess;
 532       if (gcov_var.length < words)
 533         {
 534           gcov_var.overread += words - gcov_var.length;
 535           gcov_var.length = 0;
 536           return 0;
 537         }
 538     }
 539   result = &gcov_var.buffer[gcov_var.offset];
 540   gcov_var.offset += words;
 541   return result;
 542 }
 543
 544 /* Read unsigned value from a coverage file. Sets error flag on file
 545    error, overflow flag on overflow */
 546
 547 GCOV_LINKAGE gcov_unsigned_t
 548 gcov_read_unsigned (void)
 549 {
 550   gcov_unsigned_t value;
 551   const gcov_unsigned_t *buffer = gcov_read_words (1);
 552
 553   if (!buffer)
 554     return 0;
 555   value = from_file (buffer[0]);
 556   return value;
 557 }
 558
 559 /* Read counter value from a coverage file. Sets error flag on file
 560    error, overflow flag on overflow */
 561
 562 GCOV_LINKAGE gcov_type
 563 gcov_read_counter (void)
 564 {
 565   gcov_type value;
 566   const gcov_unsigned_t *buffer = gcov_read_words (2);
 567
 568   if (!buffer)
 569     return 0;
 570   value = from_file (buffer[0]);
 571   if (sizeof (value) > sizeof (gcov_unsigned_t))
 572     value |= ((gcov_type) from_file (buffer[1])) << 32;
 573   else if (buffer[1])
 574     gcov_var.error = -1;
 575
 576   return value;
 577 }
 578
 579 /* We need to expose the below function when compiling for gcov-tool.  */
 580
 581 #if !IN_LIBGCOV || defined (IN_GCOV_TOOL)
 582 /* Read string from coverage file. Returns a pointer to a static
 583    buffer, or NULL on empty string. You must copy the string before
 584    calling another gcov function.  */
 585
 586 GCOV_LINKAGE const char *
 587 gcov_read_string (void)
 588 {
 589   unsigned length = gcov_read_unsigned ();
 590
 591   if (!length)
 592     return 0;
 593
 594   return (const char *) gcov_read_words (length);
 595 }
 596 #endif
 597
 598 GCOV_LINKAGE void
 599 gcov_read_summary (struct gcov_summary *summary)
 600 {
 601   unsigned ix, h_ix, bv_ix, h_cnt = 0;
 602   struct gcov_ctr_summary *csum;
 603   unsigned histo_bitvector[GCOV_HISTOGRAM_BITVECTOR_SIZE];
 604   unsigned cur_bitvector;
 605
 606   summary->checksum = gcov_read_unsigned ();
 607   for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++)
 608     {
 609       csum->num = gcov_read_unsigned ();
 610       csum->runs = gcov_read_unsigned ();
 611       csum->sum_all = gcov_read_counter ();
 612       csum->run_max = gcov_read_counter ();
 613       csum->sum_max = gcov_read_counter ();
 614       memset (csum->histogram, 0,
 615               sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
 616       for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
 617         {
 618           histo_bitvector[bv_ix] = gcov_read_unsigned ();
 619 #if IN_LIBGCOV
 620           /* When building libgcov we don't include system.h, which includes
 621              hwint.h (where popcount_hwi is declared). However, libgcov.a
 622              is built by the bootstrapped compiler and therefore the builtins
 623              are always available.  */
 624           h_cnt += __builtin_popcount (histo_bitvector[bv_ix]);
 625 #else
 626           h_cnt += popcount_hwi (histo_bitvector[bv_ix]);
 627 #endif
 628         }
 629       bv_ix = 0;
 630       h_ix = 0;
 631       cur_bitvector = 0;
 632       while (h_cnt--)
 633         {
 634           /* Find the index corresponding to the next entry we will read in.
 635              First find the next non-zero bitvector and re-initialize
 636              the histogram index accordingly, then right shift and increment
 637              the index until we find a set bit.  */
 638           while (!cur_bitvector)
 639             {
 640               h_ix = bv_ix * 32;
 641               if (bv_ix >= GCOV_HISTOGRAM_BITVECTOR_SIZE)
 642                 gcov_error ("corrupted profile info: summary histogram "
 643                             "bitvector is corrupt");
 644               cur_bitvector = histo_bitvector[bv_ix++];
 645             }
 646           while (!(cur_bitvector & 0x1))
 647             {
 648               h_ix++;
 649               cur_bitvector >>= 1;
 650             }
 651           if (h_ix >= GCOV_HISTOGRAM_SIZE)
 652             gcov_error ("corrupted profile info: summary histogram "
 653                         "index is corrupt");
 654
 655           csum->histogram[h_ix].num_counters = gcov_read_unsigned ();
 656           csum->histogram[h_ix].min_value = gcov_read_counter ();
 657           csum->histogram[h_ix].cum_value = gcov_read_counter ();
 658           /* Shift off the index we are done with and increment to the
 659              corresponding next histogram entry.  */
 660           cur_bitvector >>= 1;
 661           h_ix++;
 662         }
 663     }
 664 }
 665
 666 /* We need to expose the below function when compiling for gcov-tool.  */
 667
 668 #if !IN_LIBGCOV || defined (IN_GCOV_TOOL)
 669 /* Reset to a known position.  BASE should have been obtained from
 670    gcov_position, LENGTH should be a record length.  */
 671
 672 GCOV_LINKAGE void
 673 gcov_sync (gcov_position_t base, gcov_unsigned_t length)
 674 {
 675   gcov_nonruntime_assert (gcov_var.mode > 0);
 676   base += length;
 677   if (base - gcov_var.start <= gcov_var.length)
 678     gcov_var.offset = base - gcov_var.start;
 679   else
 680     {
 681       gcov_var.offset = gcov_var.length = 0;
 682       fseek (gcov_var.file, base << 2, SEEK_SET);
 683       gcov_var.start = ftell (gcov_var.file) >> 2;
 684     }
 685 }
 686 #endif
 687
 688 #if IN_LIBGCOV
 689 /* Move to a given position in a gcov file.  */
 690
 691 GCOV_LINKAGE void
 692 gcov_seek (gcov_position_t base)
 693 {
 694   if (gcov_var.offset)
 695     gcov_write_block (gcov_var.offset);
 696   fseek (gcov_var.file, base << 2, SEEK_SET);
 697   gcov_var.start = ftell (gcov_var.file) >> 2;
 698 }
 699 #endif
 700
 701 #if IN_GCOV > 0
 702 /* Return the modification time of the current gcov file.  */
 703
 704 GCOV_LINKAGE time_t
 705 gcov_time (void)
 706 {
 707   struct stat status;
 708
 709   if (fstat (fileno (gcov_var.file), &status))
 710     return 0;
 711   else
 712     return status.st_mtime;
 713 }
 714 #endif /* IN_GCOV */
 715
 716 #if !IN_GCOV
 717 /* Determine the index into histogram for VALUE. */
 718
 719 #if IN_LIBGCOV
 720 static unsigned
 721 #else
 722 GCOV_LINKAGE unsigned
 723 #endif
 724 gcov_histo_index (gcov_type value)
 725 {
 726   gcov_type_unsigned v = (gcov_type_unsigned)value;
 727   unsigned r = 0;
 728   unsigned prev2bits = 0;
 729
 730   /* Find index into log2 scale histogram, where each of the log2
 731      sized buckets is divided into 4 linear sub-buckets for better
 732      focus in the higher buckets.  */
 733
 734   /* Find the place of the most-significant bit set.  */
 735   if (v > 0)
 736     {
 737 #if IN_LIBGCOV
 738       /* When building libgcov we don't include system.h, which includes
 739          hwint.h (where floor_log2 is declared). However, libgcov.a
 740          is built by the bootstrapped compiler and therefore the builtins
 741          are always available.  */
 742       r = sizeof (long long) * __CHAR_BIT__ - 1 - __builtin_clzll (v);
 743 #else
 744       /* We use floor_log2 from hwint.c, which takes a HOST_WIDE_INT
 745          that is 64 bits and gcov_type_unsigned is 64 bits.  */
 746       r = floor_log2 (v);
 747 #endif
 748     }
 749
 750   /* If at most the 2 least significant bits are set (value is
 751      0 - 3) then that value is our index into the lowest set of
 752      four buckets.  */
 753   if (r < 2)
 754     return (unsigned)value;
 755
 756   gcov_nonruntime_assert (r < 64);
 757
 758   /* Find the two next most significant bits to determine which
 759      of the four linear sub-buckets to select.  */
 760   prev2bits = (v >> (r - 2)) & 0x3;
 761   /* Finally, compose the final bucket index from the log2 index and
 762      the next 2 bits. The minimum r value at this point is 2 since we
 763      returned above if r was 2 or more, so the minimum bucket at this
 764      point is 4.  */
 765   return (r - 1) * 4 + prev2bits;
 766 }
 767
 768 /* Merge SRC_HISTO into TGT_HISTO. The counters are assumed to be in
 769    the same relative order in both histograms, and are matched up
 770    and merged in reverse order. Each counter is assigned an equal portion of
 771    its entry's original cumulative counter value when computing the
 772    new merged cum_value.  */
 773
 774 static void gcov_histogram_merge (gcov_bucket_type *tgt_histo,
 775                                   gcov_bucket_type *src_histo)
 776 {
 777   int src_i, tgt_i, tmp_i = 0;
 778   unsigned src_num, tgt_num, merge_num;
 779   gcov_type src_cum, tgt_cum, merge_src_cum, merge_tgt_cum, merge_cum;
 780   gcov_type merge_min;
 781   gcov_bucket_type tmp_histo[GCOV_HISTOGRAM_SIZE];
 782   int src_done = 0;
 783
 784   memset (tmp_histo, 0, sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
 785
 786   /* Assume that the counters are in the same relative order in both
 787      histograms. Walk the histograms from largest to smallest entry,
 788      matching up and combining counters in order.  */
 789   src_num = 0;
 790   src_cum = 0;
 791   src_i = GCOV_HISTOGRAM_SIZE - 1;
 792   for (tgt_i = GCOV_HISTOGRAM_SIZE - 1; tgt_i >= 0 && !src_done; tgt_i--)
 793     {
 794       tgt_num = tgt_histo[tgt_i].num_counters;
 795       tgt_cum = tgt_histo[tgt_i].cum_value;
 796       /* Keep going until all of the target histogram's counters at this
 797          position have been matched and merged with counters from the
 798          source histogram.  */
 799       while (tgt_num > 0 && !src_done)
 800         {
 801           /* If this is either the first time through this loop or we just
 802              exhausted the previous non-zero source histogram entry, look
 803              for the next non-zero source histogram entry.  */
 804           if (!src_num)
 805             {
 806               /* Locate the next non-zero entry.  */
 807               while (src_i >= 0 && !src_histo[src_i].num_counters)
 808                 src_i--;
 809               /* If source histogram has fewer counters, then just copy over the
 810                  remaining target counters and quit.  */
 811               if (src_i < 0)
 812                 {
 813                   tmp_histo[tgt_i].num_counters += tgt_num;
 814                   tmp_histo[tgt_i].cum_value += tgt_cum;
 815                   if (!tmp_histo[tgt_i].min_value ||
 816                       tgt_histo[tgt_i].min_value < tmp_histo[tgt_i].min_value)
 817                     tmp_histo[tgt_i].min_value = tgt_histo[tgt_i].min_value;
 818                   while (--tgt_i >= 0)
 819                     {
 820                       tmp_histo[tgt_i].num_counters
 821                           += tgt_histo[tgt_i].num_counters;
 822                       tmp_histo[tgt_i].cum_value += tgt_histo[tgt_i].cum_value;
 823                       if (!tmp_histo[tgt_i].min_value ||
 824                           tgt_histo[tgt_i].min_value
 825                           < tmp_histo[tgt_i].min_value)
 826                         tmp_histo[tgt_i].min_value = tgt_histo[tgt_i].min_value;
 827                     }
 828
 829                   src_done = 1;
 830                   break;
 831                 }
 832
 833               src_num = src_histo[src_i].num_counters;
 834               src_cum = src_histo[src_i].cum_value;
 835             }
 836
 837           /* The number of counters to merge on this pass is the minimum
 838              of the remaining counters from the current target and source
 839              histogram entries.  */
 840           merge_num = tgt_num;
 841           if (src_num < merge_num)
 842             merge_num = src_num;
 843
 844           /* The merged min_value is the sum of the min_values from target
 845              and source.  */
 846           merge_min = tgt_histo[tgt_i].min_value + src_histo[src_i].min_value;
 847
 848           /* Compute the portion of source and target entries' cum_value
 849              that will be apportioned to the counters being merged.
 850              The total remaining cum_value from each entry is divided
 851              equally among the counters from that histogram entry if we
 852              are not merging all of them.  */
 853           merge_src_cum = src_cum;
 854           if (merge_num < src_num)
 855             merge_src_cum = merge_num * src_cum / src_num;
 856           merge_tgt_cum = tgt_cum;
 857           if (merge_num < tgt_num)
 858             merge_tgt_cum = merge_num * tgt_cum / tgt_num;
 859           /* The merged cum_value is the sum of the source and target
 860              components.  */
 861           merge_cum = merge_src_cum + merge_tgt_cum;
 862
 863           /* Update the remaining number of counters and cum_value left
 864              to be merged from this source and target entry.  */
 865           src_cum -= merge_src_cum;
 866           tgt_cum -= merge_tgt_cum;
 867           src_num -= merge_num;
 868           tgt_num -= merge_num;
 869
 870           /* The merged counters get placed in the new merged histogram
 871              at the entry for the merged min_value.  */
 872           tmp_i = gcov_histo_index (merge_min);
 873           gcov_nonruntime_assert (tmp_i < GCOV_HISTOGRAM_SIZE);
 874           tmp_histo[tmp_i].num_counters += merge_num;
 875           tmp_histo[tmp_i].cum_value += merge_cum;
 876           if (!tmp_histo[tmp_i].min_value ||
 877               merge_min < tmp_histo[tmp_i].min_value)
 878             tmp_histo[tmp_i].min_value = merge_min;
 879
 880           /* Ensure the search for the next non-zero src_histo entry starts
 881              at the next smallest histogram bucket.  */
 882           if (!src_num)
 883             src_i--;
 884         }
 885     }
 886
 887   gcov_nonruntime_assert (tgt_i < 0);
 888
 889   /* In the case where there were more counters in the source histogram,
 890      accumulate the remaining unmerged cumulative counter values. Add
 891      those to the smallest non-zero target histogram entry. Otherwise,
 892      the total cumulative counter values in the histogram will be smaller
 893      than the sum_all stored in the summary, which will complicate
 894      computing the working set information from the histogram later on.  */
 895   if (src_num)
 896     src_i--;
 897   while (src_i >= 0)
 898     {
 899       src_cum += src_histo[src_i].cum_value;
 900       src_i--;
 901     }
 902   /* At this point, tmp_i should be the smallest non-zero entry in the
 903      tmp_histo.  */
 904   gcov_nonruntime_assert (tmp_i >= 0 && tmp_i < GCOV_HISTOGRAM_SIZE
 905                           && tmp_histo[tmp_i].num_counters > 0);
 906   tmp_histo[tmp_i].cum_value += src_cum;
 907
 908   /* Finally, copy the merged histogram into tgt_histo.  */
 909   memcpy (tgt_histo, tmp_histo,
 910           sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
 911 }
 912 #endif /* !IN_GCOV */
 913
 914 /* This is used by gcov-dump (IN_GCOV == -1) and in the compiler
 915    (!IN_GCOV && !IN_LIBGCOV).  */
 916 #if IN_GCOV <= 0 && !IN_LIBGCOV
 917 /* Compute the working set information from the counter histogram in
 918    the profile summary. This is an array of information corresponding to a
 919    range of percentages of the total execution count (sum_all), and includes
 920    the number of counters required to cover that working set percentage and
 921    the minimum counter value in that working set.  */
 922
 923 GCOV_LINKAGE void
 924 compute_working_sets (const struct gcov_ctr_summary *summary,
 925                       gcov_working_set_t *gcov_working_sets)
 926 {
 927   gcov_type working_set_cum_values[NUM_GCOV_WORKING_SETS];
 928   gcov_type ws_cum_hotness_incr;
 929   gcov_type cum, tmp_cum;
 930   const gcov_bucket_type *histo_bucket;
 931   unsigned ws_ix, c_num, count;
 932   int h_ix;
 933
 934   /* Compute the amount of sum_all that the cumulative hotness grows
 935      by in each successive working set entry, which depends on the
 936      number of working set entries.  */
 937   ws_cum_hotness_incr = summary->sum_all / NUM_GCOV_WORKING_SETS;
 938
 939   /* Next fill in an array of the cumulative hotness values corresponding
 940      to each working set summary entry we are going to compute below.
 941      Skip 0% statistics, which can be extrapolated from the
 942      rest of the summary data.  */
 943   cum = ws_cum_hotness_incr;
 944   for (ws_ix = 0; ws_ix < NUM_GCOV_WORKING_SETS;
 945        ws_ix++, cum += ws_cum_hotness_incr)
 946     working_set_cum_values[ws_ix] = cum;
 947   /* The last summary entry is reserved for (roughly) 99.9% of the
 948      working set. Divide by 1024 so it becomes a shift, which gives
 949      almost exactly 99.9%.  */
 950   working_set_cum_values[NUM_GCOV_WORKING_SETS-1]
 951       = summary->sum_all - summary->sum_all/1024;
 952
 953   /* Next, walk through the histogram in decending order of hotness
 954      and compute the statistics for the working set summary array.
 955      As histogram entries are accumulated, we check to see which
 956      working set entries have had their expected cum_value reached
 957      and fill them in, walking the working set entries in increasing
 958      size of cum_value.  */
 959   ws_ix = 0; /* The current entry into the working set array.  */
 960   cum = 0; /* The current accumulated counter sum.  */
 961   count = 0; /* The current accumulated count of block counters.  */
 962   for (h_ix = GCOV_HISTOGRAM_SIZE - 1;
 963        h_ix >= 0 && ws_ix < NUM_GCOV_WORKING_SETS; h_ix--)
 964     {
 965       histo_bucket = &summary->histogram[h_ix];
 966
 967       /* If we haven't reached the required cumulative counter value for
 968          the current working set percentage, simply accumulate this histogram
 969          entry into the running sums and continue to the next histogram
 970          entry.  */
 971       if (cum + histo_bucket->cum_value < working_set_cum_values[ws_ix])
 972         {
 973           cum += histo_bucket->cum_value;
 974           count += histo_bucket->num_counters;
 975           continue;
 976         }
 977
 978       /* If adding the current histogram entry's cumulative counter value
 979          causes us to exceed the current working set size, then estimate
 980          how many of this histogram entry's counter values are required to
 981          reach the working set size, and fill in working set entries
 982          as we reach their expected cumulative value.  */
 983       for (c_num = 0, tmp_cum = cum;
 984            c_num < histo_bucket->num_counters && ws_ix < NUM_GCOV_WORKING_SETS;
 985            c_num++)
 986         {
 987           count++;
 988           /* If we haven't reached the last histogram entry counter, add
 989              in the minimum value again. This will underestimate the
 990              cumulative sum so far, because many of the counter values in this
 991              entry may have been larger than the minimum. We could add in the
 992              average value every time, but that would require an expensive
 993              divide operation.  */
 994           if (c_num + 1 < histo_bucket->num_counters)
 995             tmp_cum += histo_bucket->min_value;
 996           /* If we have reached the last histogram entry counter, then add
 997              in the entire cumulative value.  */
 998           else
 999             tmp_cum = cum + histo_bucket->cum_value;
1000
1001           /* Next walk through successive working set entries and fill in
1002              the statistics for any whose size we have reached by accumulating
1003              this histogram counter.  */
1004           while (ws_ix < NUM_GCOV_WORKING_SETS
1005                  && tmp_cum >= working_set_cum_values[ws_ix])
1006             {
1007               gcov_working_sets[ws_ix].num_counters = count;
1008               gcov_working_sets[ws_ix].min_counter
1009                   = histo_bucket->min_value;
1010               ws_ix++;
1011             }
1012         }
1013       /* Finally, update the running cumulative value since we were
1014          using a temporary above.  */
1015       cum += histo_bucket->cum_value;
1016     }
1017   gcov_nonruntime_assert (ws_ix == NUM_GCOV_WORKING_SETS);
1018 }
1019 #endif /* IN_GCOV <= 0 && !IN_LIBGCOV */