libgcc/libgcov-driver.c

   1 /* Routines required for instrumenting a program.  */
   2 /* Compile this one with gcc.  */
   3 /* Copyright (C) 1989-2020 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 Under Section 7 of GPL version 3, you are granted additional
  18 permissions described in the GCC Runtime Library Exception, version
  19 3.1, as published by the Free Software Foundation.
  20
  21 You should have received a copy of the GNU General Public License and
  22 a copy of the GCC Runtime Library Exception along with this program;
  23 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24 <http://www.gnu.org/licenses/>.  */
  25
  26 #include "libgcov.h"
  27 #include "gcov-io.h"
  28
  29 #if defined(inhibit_libc)
  30 /* If libc and its header files are not available, provide dummy functions.  */
  31
  32 #if defined(L_gcov)
  33 void __gcov_init (struct gcov_info *p __attribute__ ((unused))) {}
  34 #endif
  35
  36 #else /* inhibit_libc */
  37
  38 #include <string.h>
  39 #if GCOV_LOCKED
  40 #include <fcntl.h>
  41 #include <errno.h>
  42 #include <sys/stat.h>
  43 #endif
  44
  45 #ifdef L_gcov
  46
  47 /* A utility function for outputting errors.  */
  48 static int gcov_error (const char *, ...);
  49
  50 #if !IN_GCOV_TOOL
  51 static void gcov_error_exit (void);
  52 #endif
  53
  54 #include "gcov-io.c"
  55
  56 #define GCOV_PROF_PREFIX "libgcov profiling error:%s:"
  57
  58 struct gcov_fn_buffer
  59 {
  60   struct gcov_fn_buffer *next;
  61   unsigned fn_ix;
  62   struct gcov_fn_info info;
  63   /* note gcov_fn_info ends in a trailing array.  */
  64 };
  65
  66 struct gcov_summary_buffer
  67 {
  68   struct gcov_summary_buffer *next;
  69   struct gcov_summary summary;
  70 };
  71
  72 /* A struct that bundles all the related information about the
  73    gcda filename.  */
  74
  75 struct gcov_filename
  76 {
  77   char *filename;  /* filename buffer */
  78   int strip; /* leading chars to strip from filename */
  79   char *prefix; /* prefix string */
  80 };
  81
  82 static struct gcov_fn_buffer *
  83 free_fn_data (const struct gcov_info *gi_ptr, struct gcov_fn_buffer *buffer,
  84               unsigned limit)
  85 {
  86   struct gcov_fn_buffer *next;
  87   unsigned ix, n_ctr = 0;
  88
  89   if (!buffer)
  90     return 0;
  91   next = buffer->next;
  92
  93   for (ix = 0; ix != limit; ix++)
  94     if (gi_ptr->merge[ix])
  95       free (buffer->info.ctrs[n_ctr++].values);
  96   free (buffer);
  97   return next;
  98 }
  99
 100 static struct gcov_fn_buffer **
 101 buffer_fn_data (const char *filename, const struct gcov_info *gi_ptr,
 102                 struct gcov_fn_buffer **end_ptr, unsigned fn_ix)
 103 {
 104   unsigned n_ctrs = 0, ix = 0;
 105   struct gcov_fn_buffer *fn_buffer;
 106   unsigned len;
 107
 108   for (ix = GCOV_COUNTERS; ix--;)
 109     if (gi_ptr->merge[ix])
 110       n_ctrs++;
 111
 112   len = sizeof (*fn_buffer) + sizeof (fn_buffer->info.ctrs[0]) * n_ctrs;
 113   fn_buffer = (struct gcov_fn_buffer *) xmalloc (len);
 114
 115   if (!fn_buffer)
 116     goto fail;
 117
 118   fn_buffer->next = 0;
 119   fn_buffer->fn_ix = fn_ix;
 120   fn_buffer->info.ident = gcov_read_unsigned ();
 121   fn_buffer->info.lineno_checksum = gcov_read_unsigned ();
 122   fn_buffer->info.cfg_checksum = gcov_read_unsigned ();
 123
 124   for (n_ctrs = ix = 0; ix != GCOV_COUNTERS; ix++)
 125     {
 126       gcov_unsigned_t length;
 127       gcov_type *values;
 128
 129       if (!gi_ptr->merge[ix])
 130         continue;
 131
 132       if (gcov_read_unsigned () != GCOV_TAG_FOR_COUNTER (ix))
 133         {
 134           len = 0;
 135           goto fail;
 136         }
 137
 138       length = GCOV_TAG_COUNTER_NUM (gcov_read_unsigned ());
 139       len = length * sizeof (gcov_type);
 140       values = (gcov_type *) xmalloc (len);
 141       if (!values)
 142         goto fail;
 143
 144       fn_buffer->info.ctrs[n_ctrs].num = length;
 145       fn_buffer->info.ctrs[n_ctrs].values = values;
 146
 147       while (length--)
 148         *values++ = gcov_read_counter ();
 149       n_ctrs++;
 150     }
 151
 152   *end_ptr = fn_buffer;
 153   return &fn_buffer->next;
 154
 155 fail:
 156   gcov_error (GCOV_PROF_PREFIX "Function %u %s %u \n", filename, fn_ix,
 157               len ? "cannot allocate" : "counter mismatch", len ? len : ix);
 158
 159   return (struct gcov_fn_buffer **)free_fn_data (gi_ptr, fn_buffer, ix);
 160 }
 161
 162 /* Convert VERSION into a string description and return the it.
 163    BUFFER is used for storage of the string.  The code should be
 164    aligned wit gcov-iov.c.  */
 165
 166 static char *
 167 gcov_version_string (char *buffer, char version[4])
 168 {
 169   if (version[0] < 'A' || version[0] > 'Z'
 170       || version[1] < '0' || version[1] > '9'
 171       || version[2] < '0' || version[2] > '9')
 172     sprintf (buffer, "(unknown)");
 173   else
 174     {
 175       unsigned major = 10 * (version[0] - 'A') + (version[1] - '0');
 176       unsigned minor = version[2] - '0';
 177       sprintf (buffer, "%u.%u (%s)", major, minor,
 178                version[3] == '*' ? "release" : "experimental");
 179     }
 180   return buffer;
 181 }
 182
 183 /* Check if VERSION of the info block PTR matches libgcov one.
 184    Return 1 on success, or zero in case of versions mismatch.
 185    If FILENAME is not NULL, its value used for reporting purposes
 186    instead of value from the info block.  */
 187
 188 static int
 189 gcov_version (struct gcov_info *ptr, gcov_unsigned_t version,
 190               const char *filename)
 191 {
 192   if (version != GCOV_VERSION)
 193     {
 194       char v[4], e[4];
 195       char version_string[128], expected_string[128];
 196
 197       GCOV_UNSIGNED2STRING (v, version);
 198       GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
 199
 200       gcov_error (GCOV_PROF_PREFIX "Version mismatch - expected %s (%.4s) "
 201                   "got %s (%.4s)\n",
 202                   filename? filename : ptr->filename,
 203                   gcov_version_string (expected_string, e), e,
 204                   gcov_version_string (version_string, v), v);
 205       return 0;
 206     }
 207   return 1;
 208 }
 209
 210 /* buffer for the fn_data from another program.  */
 211 static struct gcov_fn_buffer *fn_buffer;
 212
 213 /* Including system dependent components. */
 214 #include "libgcov-driver-system.c"
 215
 216 /* This function merges counters in GI_PTR to an existing gcda file.
 217    Return 0 on success.
 218    Return -1 on error. In this case, caller will goto read_fatal.  */
 219
 220 static int
 221 merge_one_data (const char *filename,
 222                 struct gcov_info *gi_ptr,
 223                 struct gcov_summary *summary)
 224 {
 225   gcov_unsigned_t tag, length;
 226   unsigned t_ix;
 227   int f_ix = -1;
 228   int error = 0;
 229   struct gcov_fn_buffer **fn_tail = &fn_buffer;
 230
 231   length = gcov_read_unsigned ();
 232   if (!gcov_version (gi_ptr, length, filename))
 233     return -1;
 234
 235   length = gcov_read_unsigned ();
 236   if (length != gi_ptr->stamp)
 237     {
 238       /* Read from a different compilation.  Overwrite the file.  */
 239       gcov_error (GCOV_PROF_PREFIX "overwriting an existing profile data "
 240                   "with a different timestamp\n", filename);
 241       return 0;
 242     }
 243
 244   tag = gcov_read_unsigned ();
 245   if (tag != GCOV_TAG_OBJECT_SUMMARY)
 246     goto read_mismatch;
 247   length = gcov_read_unsigned ();
 248   gcc_assert (length > 0);
 249   gcov_read_summary (summary);
 250
 251   tag = gcov_read_unsigned ();
 252   /* Merge execution counts for each function.  */
 253   for (f_ix = 0; (unsigned)f_ix != gi_ptr->n_functions;
 254        f_ix++, tag = gcov_read_unsigned ())
 255     {
 256       const struct gcov_ctr_info *ci_ptr;
 257       const struct gcov_fn_info *gfi_ptr = gi_ptr->functions[f_ix];
 258
 259       if (tag != GCOV_TAG_FUNCTION)
 260         goto read_mismatch;
 261
 262       length = gcov_read_unsigned ();
 263       if (!length)
 264         /* This function did not appear in the other program.
 265            We have nothing to merge.  */
 266         continue;
 267
 268       if (length != GCOV_TAG_FUNCTION_LENGTH)
 269         goto read_mismatch;
 270
 271       if (!gfi_ptr || gfi_ptr->key != gi_ptr)
 272         {
 273           /* This function appears in the other program.  We
 274              need to buffer the information in order to write
 275              it back out -- we'll be inserting data before
 276              this point, so cannot simply keep the data in the
 277              file.  */
 278           fn_tail = buffer_fn_data (filename, gi_ptr, fn_tail, f_ix);
 279           if (!fn_tail)
 280             goto read_mismatch;
 281           continue;
 282         }
 283
 284       length = gcov_read_unsigned ();
 285       if (length != gfi_ptr->ident)
 286         goto read_mismatch;
 287
 288       length = gcov_read_unsigned ();
 289       if (length != gfi_ptr->lineno_checksum)
 290         goto read_mismatch;
 291
 292       length = gcov_read_unsigned ();
 293       if (length != gfi_ptr->cfg_checksum)
 294         goto read_mismatch;
 295
 296       ci_ptr = gfi_ptr->ctrs;
 297       for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++)
 298         {
 299           gcov_merge_fn merge = gi_ptr->merge[t_ix];
 300
 301           if (!merge)
 302             continue;
 303
 304           tag = gcov_read_unsigned ();
 305           length = gcov_read_unsigned ();
 306           if (tag != GCOV_TAG_FOR_COUNTER (t_ix)
 307               || (length != GCOV_TAG_COUNTER_LENGTH (ci_ptr->num)
 308                   && t_ix != GCOV_COUNTER_V_TOPN
 309                   && t_ix != GCOV_COUNTER_V_INDIR))
 310             goto read_mismatch;
 311           (*merge) (ci_ptr->values, ci_ptr->num);
 312           ci_ptr++;
 313         }
 314       if ((error = gcov_is_error ()))
 315         goto read_error;
 316     }
 317
 318   if (tag)
 319     {
 320     read_mismatch:;
 321       gcov_error (GCOV_PROF_PREFIX "Merge mismatch for %s %u\n",
 322                   filename, f_ix >= 0 ? "function" : "summary",
 323                   f_ix < 0 ? -1 - f_ix : f_ix);
 324       return -1;
 325     }
 326   return 0;
 327
 328 read_error:
 329   gcov_error (GCOV_PROF_PREFIX "%s merging\n", filename,
 330               error < 0 ? "Overflow": "Error");
 331   return -1;
 332 }
 333
 334 /* Store all TOP N counters where each has a dynamic length.  */
 335
 336 static void
 337 write_top_counters (const struct gcov_ctr_info *ci_ptr,
 338                     unsigned t_ix,
 339                     gcov_unsigned_t n_counts)
 340 {
 341   unsigned counters = n_counts / GCOV_TOPN_MEM_COUNTERS;
 342   gcc_assert (n_counts % GCOV_TOPN_MEM_COUNTERS == 0);
 343   unsigned pair_total = 0;
 344   for (unsigned i = 0; i < counters; i++)
 345     pair_total += ci_ptr->values[GCOV_TOPN_MEM_COUNTERS * i + 1];
 346   unsigned disk_size = GCOV_TOPN_DISK_COUNTERS * counters + 2 * pair_total;
 347   gcov_write_tag_length (GCOV_TAG_FOR_COUNTER (t_ix),
 348                          GCOV_TAG_COUNTER_LENGTH (disk_size));
 349
 350   for (unsigned i = 0; i < counters; i++)
 351     {
 352       gcov_type pair_count = ci_ptr->values[GCOV_TOPN_MEM_COUNTERS * i + 1];
 353       gcov_write_counter (ci_ptr->values[GCOV_TOPN_MEM_COUNTERS * i]);
 354       gcov_write_counter (pair_count);
 355       for (struct gcov_kvp *node
 356            = (struct gcov_kvp *)ci_ptr->values[GCOV_TOPN_MEM_COUNTERS * i + 2];
 357            node != NULL; node = node->next)
 358         {
 359           gcov_write_counter (node->value);
 360           gcov_write_counter (node->count);
 361         }
 362     }
 363 }
 364
 365 /* Write counters in GI_PTR and the summary in PRG to a gcda file. In
 366    the case of appending to an existing file, SUMMARY_POS will be non-zero.
 367    We will write the file starting from SUMMAY_POS.  */
 368
 369 static void
 370 write_one_data (const struct gcov_info *gi_ptr,
 371                 const struct gcov_summary *prg_p)
 372 {
 373   unsigned f_ix;
 374
 375   gcov_write_tag_length (GCOV_DATA_MAGIC, GCOV_VERSION);
 376   gcov_write_unsigned (gi_ptr->stamp);
 377
 378   /* Generate whole program statistics.  */
 379   gcov_write_summary (GCOV_TAG_OBJECT_SUMMARY, prg_p);
 380
 381   /* Write execution counts for each function.  */
 382   for (f_ix = 0; f_ix != gi_ptr->n_functions; f_ix++)
 383     {
 384       unsigned buffered = 0;
 385       const struct gcov_fn_info *gfi_ptr;
 386       const struct gcov_ctr_info *ci_ptr;
 387       gcov_unsigned_t length;
 388       unsigned t_ix;
 389
 390       if (fn_buffer && fn_buffer->fn_ix == f_ix)
 391         {
 392           /* Buffered data from another program.  */
 393           buffered = 1;
 394           gfi_ptr = &fn_buffer->info;
 395           length = GCOV_TAG_FUNCTION_LENGTH;
 396         }
 397       else
 398         {
 399           gfi_ptr = gi_ptr->functions[f_ix];
 400           if (gfi_ptr && gfi_ptr->key == gi_ptr)
 401             length = GCOV_TAG_FUNCTION_LENGTH;
 402           else
 403                 length = 0;
 404         }
 405
 406       gcov_write_tag_length (GCOV_TAG_FUNCTION, length);
 407       if (!length)
 408         continue;
 409
 410       gcov_write_unsigned (gfi_ptr->ident);
 411       gcov_write_unsigned (gfi_ptr->lineno_checksum);
 412       gcov_write_unsigned (gfi_ptr->cfg_checksum);
 413
 414       ci_ptr = gfi_ptr->ctrs;
 415       for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++)
 416         {
 417           gcov_unsigned_t n_counts;
 418           gcov_type *c_ptr;
 419
 420           if (!gi_ptr->merge[t_ix])
 421             continue;
 422
 423           n_counts = ci_ptr->num;
 424
 425           if (gi_ptr->merge[t_ix] == __gcov_merge_topn)
 426             write_top_counters (ci_ptr, t_ix, n_counts);
 427           else
 428             {
 429               gcov_write_tag_length (GCOV_TAG_FOR_COUNTER (t_ix),
 430                                      GCOV_TAG_COUNTER_LENGTH (n_counts));
 431               c_ptr = ci_ptr->values;
 432               while (n_counts--)
 433                 gcov_write_counter (*c_ptr++);
 434             }
 435
 436           ci_ptr++;
 437         }
 438       if (buffered)
 439         fn_buffer = free_fn_data (gi_ptr, fn_buffer, GCOV_COUNTERS);
 440     }
 441
 442   gcov_write_unsigned (0);
 443 }
 444
 445 /* Helper function for merging summary.  */
 446
 447 static void
 448 merge_summary (int run_counted, struct gcov_summary *summary,
 449               gcov_type run_max)
 450 {
 451   if (!run_counted)
 452     {
 453       summary->runs++;
 454       summary->sum_max += run_max;
 455     }
 456 }
 457
 458 /* Dump the coverage counts for one gcov_info object. We merge with existing
 459    counts when possible, to avoid growing the .da files ad infinitum. We use
 460    this program's checksum to make sure we only accumulate whole program
 461    statistics to the correct summary. An object file might be embedded
 462    in two separate programs, and we must keep the two program
 463    summaries separate.  */
 464
 465 static void
 466 dump_one_gcov (struct gcov_info *gi_ptr, struct gcov_filename *gf,
 467                unsigned run_counted, gcov_type run_max)
 468 {
 469   struct gcov_summary summary = {};
 470   int error;
 471   gcov_unsigned_t tag;
 472   fn_buffer = 0;
 473
 474   error = gcov_exit_open_gcda_file (gi_ptr, gf);
 475   if (error == -1)
 476     return;
 477
 478   tag = gcov_read_unsigned ();
 479   if (tag)
 480     {
 481       /* Merge data from file.  */
 482       if (tag != GCOV_DATA_MAGIC)
 483         {
 484           gcov_error (GCOV_PROF_PREFIX "Not a gcov data file\n",
 485                       gf->filename);
 486           goto read_fatal;
 487         }
 488       error = merge_one_data (gf->filename, gi_ptr, &summary);
 489       if (error == -1)
 490         goto read_fatal;
 491     }
 492
 493   gcov_rewrite ();
 494
 495   merge_summary (run_counted, &summary, run_max);
 496
 497   write_one_data (gi_ptr, &summary);
 498   /* fall through */
 499
 500 read_fatal:;
 501   while (fn_buffer)
 502     fn_buffer = free_fn_data (gi_ptr, fn_buffer, GCOV_COUNTERS);
 503
 504   if ((error = gcov_close ()))
 505     gcov_error (error  < 0 ?
 506                 GCOV_PROF_PREFIX "Overflow writing\n" :
 507                 GCOV_PROF_PREFIX "Error writing\n",
 508                 gf->filename);
 509 }
 510
 511
 512 /* Dump all the coverage counts for the program. It first computes program
 513    summary and then traverses gcov_list list and dumps the gcov_info
 514    objects one by one.  */
 515
 516 #if !IN_GCOV_TOOL
 517 static
 518 #endif
 519 void
 520 gcov_do_dump (struct gcov_info *list, int run_counted)
 521 {
 522   struct gcov_info *gi_ptr;
 523   struct gcov_filename gf;
 524
 525   /* Compute run_max of this program run.  */
 526   gcov_type run_max = 0;
 527   for (gi_ptr = list; gi_ptr; gi_ptr = gi_ptr->next)
 528     for (unsigned f_ix = 0; (unsigned)f_ix != gi_ptr->n_functions; f_ix++)
 529       {
 530         const struct gcov_ctr_info *cinfo
 531           = &gi_ptr->functions[f_ix]->ctrs[GCOV_COUNTER_ARCS];
 532
 533         for (unsigned i = 0; i < cinfo->num; i++)
 534           if (run_max < cinfo->values[i])
 535             run_max = cinfo->values[i];
 536       }
 537
 538   allocate_filename_struct (&gf);
 539
 540   /* Now merge each file.  */
 541   for (gi_ptr = list; gi_ptr; gi_ptr = gi_ptr->next)
 542     {
 543       dump_one_gcov (gi_ptr, &gf, run_counted, run_max);
 544       free (gf.filename);
 545     }
 546
 547   free (gf.prefix);
 548 }
 549
 550 #if IN_GCOV_TOOL
 551 const char *
 552 __attribute__ ((unused))
 553 gcov_get_filename (struct gcov_info *list)
 554 {
 555   return list->filename;
 556 }
 557 #endif
 558
 559 #if !IN_GCOV_TOOL
 560 void
 561 __gcov_dump_one (struct gcov_root *root)
 562 {
 563   if (root->dumped)
 564     return;
 565
 566   gcov_do_dump (root->list, root->run_counted);
 567
 568   root->dumped = 1;
 569   root->run_counted = 1;
 570 }
 571
 572 /* Per-dynamic-object gcov state.  */
 573 struct gcov_root __gcov_root;
 574
 575 /* Exactly one of these will be live in the process image.  */
 576 struct gcov_master __gcov_master =
 577   {GCOV_VERSION, 0};
 578
 579 void
 580 __gcov_exit (void)
 581 {
 582   __gcov_dump_one (&__gcov_root);
 583   if (__gcov_root.next)
 584     __gcov_root.next->prev = __gcov_root.prev;
 585   if (__gcov_root.prev)
 586     __gcov_root.prev->next = __gcov_root.next;
 587   else
 588     __gcov_master.root = __gcov_root.next;
 589
 590   gcov_error_exit ();
 591 }
 592
 593 /* Add a new object file onto the bb chain.  Invoked automatically
 594   when running an object file's global ctors.  */
 595
 596 void
 597 __gcov_init (struct gcov_info *info)
 598 {
 599   if (!info->version || !info->n_functions)
 600     return;
 601   if (gcov_version (info, info->version, 0))
 602     {
 603       if (!__gcov_root.list)
 604         {
 605           /* Add to master list and at exit function.  */
 606           if (gcov_version (NULL, __gcov_master.version, "<master>"))
 607             {
 608               __gcov_root.next = __gcov_master.root;
 609               if (__gcov_master.root)
 610                 __gcov_master.root->prev = &__gcov_root;
 611               __gcov_master.root = &__gcov_root;
 612             }
 613         }
 614
 615       info->next = __gcov_root.list;
 616       __gcov_root.list = info;
 617     }
 618 }
 619 #endif /* !IN_GCOV_TOOL */
 620 #endif /* L_gcov */
 621 #endif /* inhibit_libc */