gcc/coverage.c

   1 /* Read and write coverage files, and associated functionality.
   2    Copyright (C) 1990-2013 Free Software Foundation, Inc.
   3    Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
   4    based on some ideas from Dain Samples of UC Berkeley.
   5    Further mangling by Bob Manson, Cygnus Support.
   6    Further mangled by Nathan Sidwell, CodeSourcery
   7
   8 This file is part of GCC.
   9
  10 GCC is free software; you can redistribute it and/or modify it under
  11 the terms of the GNU General Public License as published by the Free
  12 Software Foundation; either version 3, or (at your option) any later
  13 version.
  14
  15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  18 for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GCC; see the file COPYING3.  If not see
  22 <http://www.gnu.org/licenses/>.  */
  23
  24
  25 #define GCOV_LINKAGE
  26
  27 #include "config.h"
  28 #include "system.h"
  29 #include "coretypes.h"
  30 #include "tm.h"
  31 #include "rtl.h"
  32 #include "tree.h"
  33 #include "flags.h"
  34 #include "output.h"
  35 #include "regs.h"
  36 #include "expr.h"
  37 #include "function.h"
  38 #include "basic-block.h"
  39 #include "toplev.h"
  40 #include "tm_p.h"
  41 #include "ggc.h"
  42 #include "coverage.h"
  43 #include "langhooks.h"
  44 #include "hash-table.h"
  45 #include "tree-iterator.h"
  46 #include "cgraph.h"
  47 #include "dumpfile.h"
  48 #include "diagnostic-core.h"
  49 #include "intl.h"
  50 #include "filenames.h"
  51 #include "target.h"
  52
  53 #include "gcov-io.h"
  54 #include "gcov-io.c"
  55
  56 struct GTY((chain_next ("%h.next"))) coverage_data
  57 {
  58   struct coverage_data *next;    /* next function */
  59   unsigned ident;                /* function ident */
  60   unsigned lineno_checksum;      /* function lineno checksum */
  61   unsigned cfg_checksum;         /* function cfg checksum */
  62   tree fn_decl;                  /* the function decl */
  63   tree ctr_vars[GCOV_COUNTERS];  /* counter variables.  */
  64 };
  65
  66 /* Counts information for a function.  */
  67 typedef struct counts_entry
  68 {
  69   /* We hash by  */
  70   unsigned ident;
  71   unsigned ctr;
  72
  73   /* Store  */
  74   unsigned lineno_checksum;
  75   unsigned cfg_checksum;
  76   gcov_type *counts;
  77   struct gcov_ctr_summary summary;
  78
  79   /* hash_table support.  */
  80   typedef counts_entry value_type;
  81   typedef counts_entry compare_type;
  82   static inline hashval_t hash (const value_type *);
  83   static int equal (const value_type *, const compare_type *);
  84   static void remove (value_type *);
  85 } counts_entry_t;
  86
  87 static GTY(()) struct coverage_data *functions_head = 0;
  88 static struct coverage_data **functions_tail = &functions_head;
  89 static unsigned no_coverage = 0;
  90
  91 /* Cumulative counter information for whole program.  */
  92 static unsigned prg_ctr_mask; /* Mask of counter types generated.  */
  93
  94 /* Counter information for current function.  */
  95 static unsigned fn_ctr_mask; /* Mask of counters used.  */
  96 static GTY(()) tree fn_v_ctrs[GCOV_COUNTERS];   /* counter variables.  */
  97 static unsigned fn_n_ctrs[GCOV_COUNTERS]; /* Counters allocated.  */
  98 static unsigned fn_b_ctrs[GCOV_COUNTERS]; /* Allocation base.  */
  99
 100 /* Coverage info VAR_DECL and function info type nodes.  */
 101 static GTY(()) tree gcov_info_var;
 102 static GTY(()) tree gcov_fn_info_type;
 103 static GTY(()) tree gcov_fn_info_ptr_type;
 104
 105 /* Name of the notes (gcno) output file.  The "bbg" prefix is for
 106    historical reasons, when the notes file contained only the
 107    basic block graph notes.
 108    If this is NULL we're not writing to the notes file.  */
 109 static char *bbg_file_name;
 110
 111 /* File stamp for notes file.  */
 112 static unsigned bbg_file_stamp;
 113
 114 /* Name of the count data (gcda) file.  */
 115 static char *da_file_name;
 116
 117 /* The names of merge functions for counters.  */
 118 static const char *const ctr_merge_functions[GCOV_COUNTERS] = GCOV_MERGE_FUNCTIONS;
 119 static const char *const ctr_names[GCOV_COUNTERS] = GCOV_COUNTER_NAMES;
 120
 121 /* Forward declarations.  */
 122 static void read_counts_file (void);
 123 static tree build_var (tree, tree, int);
 124 static void build_fn_info_type (tree, unsigned, tree);
 125 static void build_info_type (tree, tree);
 126 static tree build_fn_info (const struct coverage_data *, tree, tree);
 127 static tree build_info (tree, tree);
 128 static bool coverage_obj_init (void);
 129 static vec<constructor_elt, va_gc> *coverage_obj_fn
 130 (vec<constructor_elt, va_gc> *, tree, struct coverage_data const *);
 131 static void coverage_obj_finish (vec<constructor_elt, va_gc> *);
 132 \f
 133 /* Return the type node for gcov_type.  */
 134
 135 tree
 136 get_gcov_type (void)
 137 {
 138   enum machine_mode mode = smallest_mode_for_size (GCOV_TYPE_SIZE, MODE_INT);
 139   return lang_hooks.types.type_for_mode (mode, false);
 140 }
 141
 142 /* Return the type node for gcov_unsigned_t.  */
 143
 144 static tree
 145 get_gcov_unsigned_t (void)
 146 {
 147   enum machine_mode mode = smallest_mode_for_size (32, MODE_INT);
 148   return lang_hooks.types.type_for_mode (mode, true);
 149 }
 150 \f
 151 inline hashval_t
 152 counts_entry::hash (const value_type *entry)
 153 {
 154   return entry->ident * GCOV_COUNTERS + entry->ctr;
 155 }
 156
 157 inline int
 158 counts_entry::equal (const value_type *entry1,
 159                      const compare_type *entry2)
 160 {
 161   return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
 162 }
 163
 164 inline void
 165 counts_entry::remove (value_type *entry)
 166 {
 167   free (entry->counts);
 168   free (entry);
 169 }
 170
 171 /* Hash table of count data.  */
 172 static hash_table <counts_entry> counts_hash;
 173
 174 /* Read in the counts file, if available.  */
 175
 176 static void
 177 read_counts_file (void)
 178 {
 179   gcov_unsigned_t fn_ident = 0;
 180   struct gcov_summary summary;
 181   unsigned new_summary = 1;
 182   gcov_unsigned_t tag;
 183   int is_error = 0;
 184   unsigned lineno_checksum = 0;
 185   unsigned cfg_checksum = 0;
 186
 187   if (!gcov_open (da_file_name, 1))
 188     return;
 189
 190   if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC))
 191     {
 192       warning (0, "%qs is not a gcov data file", da_file_name);
 193       gcov_close ();
 194       return;
 195     }
 196   else if ((tag = gcov_read_unsigned ()) != GCOV_VERSION)
 197     {
 198       char v[4], e[4];
 199
 200       GCOV_UNSIGNED2STRING (v, tag);
 201       GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
 202
 203       warning (0, "%qs is version %q.*s, expected version %q.*s",
 204                da_file_name, 4, v, 4, e);
 205       gcov_close ();
 206       return;
 207     }
 208
 209   /* Read the stamp, used for creating a generation count.  */
 210   tag = gcov_read_unsigned ();
 211   bbg_file_stamp = crc32_unsigned (bbg_file_stamp, tag);
 212
 213   counts_hash.create (10);
 214   while ((tag = gcov_read_unsigned ()))
 215     {
 216       gcov_unsigned_t length;
 217       gcov_position_t offset;
 218
 219       length = gcov_read_unsigned ();
 220       offset = gcov_position ();
 221       if (tag == GCOV_TAG_FUNCTION)
 222         {
 223           if (length)
 224             {
 225               fn_ident = gcov_read_unsigned ();
 226               lineno_checksum = gcov_read_unsigned ();
 227               cfg_checksum = gcov_read_unsigned ();
 228             }
 229           else
 230             fn_ident = lineno_checksum = cfg_checksum = 0;
 231           new_summary = 1;
 232         }
 233       else if (tag == GCOV_TAG_PROGRAM_SUMMARY)
 234         {
 235           struct gcov_summary sum;
 236           unsigned ix;
 237
 238           if (new_summary)
 239             memset (&summary, 0, sizeof (summary));
 240
 241           gcov_read_summary (&sum);
 242           for (ix = 0; ix != GCOV_COUNTERS_SUMMABLE; ix++)
 243             {
 244               summary.ctrs[ix].runs += sum.ctrs[ix].runs;
 245               summary.ctrs[ix].sum_all += sum.ctrs[ix].sum_all;
 246               if (summary.ctrs[ix].run_max < sum.ctrs[ix].run_max)
 247                 summary.ctrs[ix].run_max = sum.ctrs[ix].run_max;
 248               summary.ctrs[ix].sum_max += sum.ctrs[ix].sum_max;
 249             }
 250           if (new_summary)
 251             memcpy (summary.ctrs[GCOV_COUNTER_ARCS].histogram,
 252                     sum.ctrs[GCOV_COUNTER_ARCS].histogram,
 253                     sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
 254           else
 255             gcov_histogram_merge (summary.ctrs[GCOV_COUNTER_ARCS].histogram,
 256                                   sum.ctrs[GCOV_COUNTER_ARCS].histogram);
 257           new_summary = 0;
 258         }
 259       else if (GCOV_TAG_IS_COUNTER (tag) && fn_ident)
 260         {
 261           counts_entry_t **slot, *entry, elt;
 262           unsigned n_counts = GCOV_TAG_COUNTER_NUM (length);
 263           unsigned ix;
 264
 265           elt.ident = fn_ident;
 266           elt.ctr = GCOV_COUNTER_FOR_TAG (tag);
 267
 268           slot = counts_hash.find_slot (&elt, INSERT);
 269           entry = *slot;
 270           if (!entry)
 271             {
 272               *slot = entry = XCNEW (counts_entry_t);
 273               entry->ident = fn_ident;
 274               entry->ctr = elt.ctr;
 275               entry->lineno_checksum = lineno_checksum;
 276               entry->cfg_checksum = cfg_checksum;
 277               if (elt.ctr < GCOV_COUNTERS_SUMMABLE)
 278                 entry->summary = summary.ctrs[elt.ctr];
 279               entry->summary.num = n_counts;
 280               entry->counts = XCNEWVEC (gcov_type, n_counts);
 281             }
 282           else if (entry->lineno_checksum != lineno_checksum
 283                    || entry->cfg_checksum != cfg_checksum)
 284             {
 285               error ("Profile data for function %u is corrupted", fn_ident);
 286               error ("checksum is (%x,%x) instead of (%x,%x)",
 287                      entry->lineno_checksum, entry->cfg_checksum,
 288                      lineno_checksum, cfg_checksum);
 289               counts_hash.dispose ();
 290               break;
 291             }
 292           else if (entry->summary.num != n_counts)
 293             {
 294               error ("Profile data for function %u is corrupted", fn_ident);
 295               error ("number of counters is %d instead of %d", entry->summary.num, n_counts);
 296               counts_hash.dispose ();
 297               break;
 298             }
 299           else if (elt.ctr >= GCOV_COUNTERS_SUMMABLE)
 300             {
 301               error ("cannot merge separate %s counters for function %u",
 302                      ctr_names[elt.ctr], fn_ident);
 303               goto skip_merge;
 304             }
 305           else
 306             {
 307               entry->summary.runs += summary.ctrs[elt.ctr].runs;
 308               entry->summary.sum_all += summary.ctrs[elt.ctr].sum_all;
 309               if (entry->summary.run_max < summary.ctrs[elt.ctr].run_max)
 310                 entry->summary.run_max = summary.ctrs[elt.ctr].run_max;
 311               entry->summary.sum_max += summary.ctrs[elt.ctr].sum_max;
 312             }
 313           for (ix = 0; ix != n_counts; ix++)
 314             entry->counts[ix] += gcov_read_counter ();
 315         skip_merge:;
 316         }
 317       gcov_sync (offset, length);
 318       if ((is_error = gcov_is_error ()))
 319         {
 320           error (is_error < 0 ? "%qs has overflowed" : "%qs is corrupted",
 321                  da_file_name);
 322           counts_hash.dispose ();
 323           break;
 324         }
 325     }
 326
 327   gcov_close ();
 328 }
 329
 330 /* Returns the counters for a particular tag.  */
 331
 332 gcov_type *
 333 get_coverage_counts (unsigned counter, unsigned expected,
 334                      unsigned cfg_checksum, unsigned lineno_checksum,
 335                      const struct gcov_ctr_summary **summary)
 336 {
 337   counts_entry_t *entry, elt;
 338
 339   /* No hash table, no counts.  */
 340   if (!counts_hash.is_created ())
 341     {
 342       static int warned = 0;
 343
 344       if (!warned++)
 345         inform (input_location, (flag_guess_branch_prob
 346                  ? "file %s not found, execution counts estimated"
 347                  : "file %s not found, execution counts assumed to be zero"),
 348                 da_file_name);
 349       return NULL;
 350     }
 351
 352   elt.ident = current_function_funcdef_no + 1;
 353   elt.ctr = counter;
 354   entry = counts_hash.find (&elt);
 355   if (!entry || !entry->summary.num)
 356     /* The function was not emitted, or is weak and not chosen in the
 357        final executable.  Silently fail, because there's nothing we
 358        can do about it.  */
 359     return NULL;
 360
 361   if (entry->cfg_checksum != cfg_checksum
 362       || entry->summary.num != expected)
 363     {
 364       static int warned = 0;
 365       bool warning_printed = false;
 366       tree id = DECL_ASSEMBLER_NAME (current_function_decl);
 367
 368       warning_printed =
 369         warning_at (input_location, OPT_Wcoverage_mismatch,
 370                     "the control flow of function %qE does not match "
 371                     "its profile data (counter %qs)", id, ctr_names[counter]);
 372       if (warning_printed)
 373         {
 374          inform (input_location, "use -Wno-error=coverage-mismatch to tolerate "
 375                  "the mismatch but performance may drop if the function is hot");
 376
 377           if (!seen_error ()
 378               && !warned++)
 379             {
 380               inform (input_location, "coverage mismatch ignored");
 381               inform (input_location, flag_guess_branch_prob
 382                       ? G_("execution counts estimated")
 383                       : G_("execution counts assumed to be zero"));
 384               if (!flag_guess_branch_prob)
 385                 inform (input_location,
 386                         "this can result in poorly optimized code");
 387             }
 388         }
 389
 390       return NULL;
 391     }
 392   else if (entry->lineno_checksum != lineno_checksum)
 393     {
 394       warning (0, "source locations for function %qE have changed,"
 395                " the profile data may be out of date",
 396                DECL_ASSEMBLER_NAME (current_function_decl));
 397     }
 398
 399   if (summary)
 400     *summary = &entry->summary;
 401
 402   return entry->counts;
 403 }
 404
 405 /* Allocate NUM counters of type COUNTER. Returns nonzero if the
 406    allocation succeeded.  */
 407
 408 int
 409 coverage_counter_alloc (unsigned counter, unsigned num)
 410 {
 411   if (no_coverage)
 412     return 0;
 413
 414   if (!num)
 415     return 1;
 416
 417   if (!fn_v_ctrs[counter])
 418     {
 419       tree array_type = build_array_type (get_gcov_type (), NULL_TREE);
 420
 421       fn_v_ctrs[counter]
 422         = build_var (current_function_decl, array_type, counter);
 423     }
 424
 425   fn_b_ctrs[counter] = fn_n_ctrs[counter];
 426   fn_n_ctrs[counter] += num;
 427
 428   fn_ctr_mask |= 1 << counter;
 429   return 1;
 430 }
 431
 432 /* Generate a tree to access COUNTER NO.  */
 433
 434 tree
 435 tree_coverage_counter_ref (unsigned counter, unsigned no)
 436 {
 437   tree gcov_type_node = get_gcov_type ();
 438
 439   gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]);
 440
 441   no += fn_b_ctrs[counter];
 442
 443   /* "no" here is an array index, scaled to bytes later.  */
 444   return build4 (ARRAY_REF, gcov_type_node, fn_v_ctrs[counter],
 445                  build_int_cst (integer_type_node, no), NULL, NULL);
 446 }
 447
 448 /* Generate a tree to access the address of COUNTER NO.  */
 449
 450 tree
 451 tree_coverage_counter_addr (unsigned counter, unsigned no)
 452 {
 453   tree gcov_type_node = get_gcov_type ();
 454
 455   gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]);
 456   no += fn_b_ctrs[counter];
 457
 458   /* "no" here is an array index, scaled to bytes later.  */
 459   return build_fold_addr_expr (build4 (ARRAY_REF, gcov_type_node,
 460                                        fn_v_ctrs[counter],
 461                                        build_int_cst (integer_type_node, no),
 462                                        NULL, NULL));
 463 }
 464 \f
 465
 466 /* Generate a checksum for a string.  CHKSUM is the current
 467    checksum.  */
 468
 469 static unsigned
 470 coverage_checksum_string (unsigned chksum, const char *string)
 471 {
 472   int i;
 473   char *dup = NULL;
 474
 475   /* Look for everything that looks if it were produced by
 476      get_file_function_name and zero out the second part
 477      that may result from flag_random_seed.  This is not critical
 478      as the checksums are used only for sanity checking.  */
 479   for (i = 0; string[i]; i++)
 480     {
 481       int offset = 0;
 482       if (!strncmp (string + i, "_GLOBAL__N_", 11))
 483       offset = 11;
 484       if (!strncmp (string + i, "_GLOBAL__", 9))
 485       offset = 9;
 486
 487       /* C++ namespaces do have scheme:
 488          _GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname
 489        since filename might contain extra underscores there seems
 490        to be no better chance then walk all possible offsets looking
 491        for magicnumber.  */
 492       if (offset)
 493         {
 494           for (i = i + offset; string[i]; i++)
 495             if (string[i]=='_')
 496               {
 497                 int y;
 498
 499                 for (y = 1; y < 9; y++)
 500                   if (!(string[i + y] >= '0' && string[i + y] <= '9')
 501                       && !(string[i + y] >= 'A' && string[i + y] <= 'F'))
 502                     break;
 503                 if (y != 9 || string[i + 9] != '_')
 504                   continue;
 505                 for (y = 10; y < 18; y++)
 506                   if (!(string[i + y] >= '0' && string[i + y] <= '9')
 507                       && !(string[i + y] >= 'A' && string[i + y] <= 'F'))
 508                     break;
 509                 if (y != 18)
 510                   continue;
 511                 if (!dup)
 512                   string = dup = xstrdup (string);
 513                 for (y = 10; y < 18; y++)
 514                   dup[i + y] = '0';
 515               }
 516           break;
 517         }
 518     }
 519
 520   chksum = crc32_string (chksum, string);
 521   free (dup);
 522
 523   return chksum;
 524 }
 525
 526 /* Compute checksum for the current function.  We generate a CRC32.  */
 527
 528 unsigned
 529 coverage_compute_lineno_checksum (void)
 530 {
 531   expanded_location xloc
 532     = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
 533   unsigned chksum = xloc.line;
 534
 535   chksum = coverage_checksum_string (chksum, xloc.file);
 536   chksum = coverage_checksum_string
 537     (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)));
 538
 539   return chksum;
 540 }
 541
 542 /* Compute cfg checksum for the current function.
 543    The checksum is calculated carefully so that
 544    source code changes that doesn't affect the control flow graph
 545    won't change the checksum.
 546    This is to make the profile data useable across source code change.
 547    The downside of this is that the compiler may use potentially
 548    wrong profile data - that the source code change has non-trivial impact
 549    on the validity of profile data (e.g. the reversed condition)
 550    but the compiler won't detect the change and use the wrong profile data.  */
 551
 552 unsigned
 553 coverage_compute_cfg_checksum (void)
 554 {
 555   basic_block bb;
 556   unsigned chksum = n_basic_blocks;
 557
 558   FOR_EACH_BB (bb)
 559     {
 560       edge e;
 561       edge_iterator ei;
 562       chksum = crc32_byte (chksum, bb->index);
 563       FOR_EACH_EDGE (e, ei, bb->succs)
 564         {
 565           chksum = crc32_byte (chksum, e->dest->index);
 566         }
 567     }
 568
 569   return chksum;
 570 }
 571 \f
 572 /* Begin output to the notes file for the current function.
 573    Writes the function header. Returns nonzero if data should be output.  */
 574
 575 int
 576 coverage_begin_function (unsigned lineno_checksum, unsigned cfg_checksum)
 577 {
 578   expanded_location xloc;
 579   unsigned long offset;
 580
 581   /* We don't need to output .gcno file unless we're under -ftest-coverage
 582      (e.g. -fprofile-arcs/generate/use don't need .gcno to work). */
 583   if (no_coverage || !bbg_file_name)
 584     return 0;
 585
 586   xloc = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
 587
 588   /* Announce function */
 589   offset = gcov_write_tag (GCOV_TAG_FUNCTION);
 590   gcov_write_unsigned (current_function_funcdef_no + 1);
 591   gcov_write_unsigned (lineno_checksum);
 592   gcov_write_unsigned (cfg_checksum);
 593   gcov_write_string (IDENTIFIER_POINTER
 594                      (DECL_ASSEMBLER_NAME (current_function_decl)));
 595   gcov_write_string (xloc.file);
 596   gcov_write_unsigned (xloc.line);
 597   gcov_write_length (offset);
 598
 599   return !gcov_is_error ();
 600 }
 601
 602 /* Finish coverage data for the current function. Verify no output
 603    error has occurred.  Save function coverage counts.  */
 604
 605 void
 606 coverage_end_function (unsigned lineno_checksum, unsigned cfg_checksum)
 607 {
 608   unsigned i;
 609
 610   if (bbg_file_name && gcov_is_error ())
 611     {
 612       warning (0, "error writing %qs", bbg_file_name);
 613       unlink (bbg_file_name);
 614       bbg_file_name = NULL;
 615     }
 616
 617   if (fn_ctr_mask)
 618     {
 619       struct coverage_data *item = 0;
 620
 621       /* If the function is extern (i.e. extern inline), then we won't
 622          be outputting it, so don't chain it onto the function
 623          list.  */
 624       if (!DECL_EXTERNAL (current_function_decl))
 625         {
 626           item = ggc_alloc_coverage_data ();
 627
 628           item->ident = current_function_funcdef_no + 1;
 629           item->lineno_checksum = lineno_checksum;
 630           item->cfg_checksum = cfg_checksum;
 631
 632           item->fn_decl = current_function_decl;
 633           item->next = 0;
 634           *functions_tail = item;
 635           functions_tail = &item->next;
 636         }
 637
 638       for (i = 0; i != GCOV_COUNTERS; i++)
 639         {
 640           tree var = fn_v_ctrs[i];
 641
 642           if (item)
 643             item->ctr_vars[i] = var;
 644           if (var)
 645             {
 646               tree array_type = build_index_type (size_int (fn_n_ctrs[i] - 1));
 647               array_type = build_array_type (get_gcov_type (), array_type);
 648               TREE_TYPE (var) = array_type;
 649               DECL_SIZE (var) = TYPE_SIZE (array_type);
 650               DECL_SIZE_UNIT (var) = TYPE_SIZE_UNIT (array_type);
 651               varpool_finalize_decl (var);
 652             }
 653
 654           fn_b_ctrs[i] = fn_n_ctrs[i] = 0;
 655           fn_v_ctrs[i] = NULL_TREE;
 656         }
 657       prg_ctr_mask |= fn_ctr_mask;
 658       fn_ctr_mask = 0;
 659     }
 660 }
 661
 662 /* Build a coverage variable of TYPE for function FN_DECL.  If COUNTER
 663    >= 0 it is a counter array, otherwise it is the function structure.  */
 664
 665 static tree
 666 build_var (tree fn_decl, tree type, int counter)
 667 {
 668   tree var = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL_TREE, type);
 669   const char *fn_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn_decl));
 670   char *buf;
 671   size_t fn_name_len, len;
 672
 673   fn_name = targetm.strip_name_encoding (fn_name);
 674   fn_name_len = strlen (fn_name);
 675   buf = XALLOCAVEC (char, fn_name_len + 8 + sizeof (int) * 3);
 676
 677   if (counter < 0)
 678     strcpy (buf, "__gcov__");
 679   else
 680     sprintf (buf, "__gcov%u_", counter);
 681   len = strlen (buf);
 682 #ifndef NO_DOT_IN_LABEL
 683   buf[len - 1] = '.';
 684 #elif !defined NO_DOLLAR_IN_LABEL
 685   buf[len - 1] = '$';
 686 #endif
 687   memcpy (buf + len, fn_name, fn_name_len + 1);
 688   DECL_NAME (var) = get_identifier (buf);
 689   TREE_STATIC (var) = 1;
 690   TREE_ADDRESSABLE (var) = 1;
 691   DECL_ALIGN (var) = TYPE_ALIGN (type);
 692
 693   return var;
 694 }
 695
 696 /* Creates the gcov_fn_info RECORD_TYPE.  */
 697
 698 static void
 699 build_fn_info_type (tree type, unsigned counters, tree gcov_info_type)
 700 {
 701   tree ctr_info = lang_hooks.types.make_type (RECORD_TYPE);
 702   tree field, fields;
 703   tree array_type;
 704
 705   gcc_assert (counters);
 706
 707   /* ctr_info::num */
 708   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
 709                       get_gcov_unsigned_t ());
 710   fields = field;
 711
 712   /* ctr_info::values */
 713   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
 714                       build_pointer_type (get_gcov_type ()));
 715   DECL_CHAIN (field) = fields;
 716   fields = field;
 717
 718   finish_builtin_struct (ctr_info, "__gcov_ctr_info", fields, NULL_TREE);
 719
 720   /* key */
 721   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
 722                       build_pointer_type (build_qualified_type
 723                                           (gcov_info_type, TYPE_QUAL_CONST)));
 724   fields = field;
 725
 726   /* ident */
 727   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
 728                       get_gcov_unsigned_t ());
 729   DECL_CHAIN (field) = fields;
 730   fields = field;
 731
 732   /* lineno_checksum */
 733   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
 734                       get_gcov_unsigned_t ());
 735   DECL_CHAIN (field) = fields;
 736   fields = field;
 737
 738   /* cfg checksum */
 739   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
 740                       get_gcov_unsigned_t ());
 741   DECL_CHAIN (field) = fields;
 742   fields = field;
 743
 744   array_type = build_index_type (size_int (counters - 1));
 745   array_type = build_array_type (ctr_info, array_type);
 746
 747   /* counters */
 748   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, array_type);
 749   DECL_CHAIN (field) = fields;
 750   fields = field;
 751
 752   finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE);
 753 }
 754
 755 /* Returns a CONSTRUCTOR for a gcov_fn_info.  DATA is
 756    the coverage data for the function and TYPE is the gcov_fn_info
 757    RECORD_TYPE.  KEY is the object file key.  */
 758
 759 static tree
 760 build_fn_info (const struct coverage_data *data, tree type, tree key)
 761 {
 762   tree fields = TYPE_FIELDS (type);
 763   tree ctr_type;
 764   unsigned ix;
 765   vec<constructor_elt, va_gc> *v1 = NULL;
 766   vec<constructor_elt, va_gc> *v2 = NULL;
 767
 768   /* key */
 769   CONSTRUCTOR_APPEND_ELT (v1, fields,
 770                           build1 (ADDR_EXPR, TREE_TYPE (fields), key));
 771   fields = DECL_CHAIN (fields);
 772
 773   /* ident */
 774   CONSTRUCTOR_APPEND_ELT (v1, fields,
 775                           build_int_cstu (get_gcov_unsigned_t (),
 776                                           data->ident));
 777   fields = DECL_CHAIN (fields);
 778
 779   /* lineno_checksum */
 780   CONSTRUCTOR_APPEND_ELT (v1, fields,
 781                           build_int_cstu (get_gcov_unsigned_t (),
 782                                           data->lineno_checksum));
 783   fields = DECL_CHAIN (fields);
 784
 785   /* cfg_checksum */
 786   CONSTRUCTOR_APPEND_ELT (v1, fields,
 787                           build_int_cstu (get_gcov_unsigned_t (),
 788                                           data->cfg_checksum));
 789   fields = DECL_CHAIN (fields);
 790
 791   /* counters */
 792   ctr_type = TREE_TYPE (TREE_TYPE (fields));
 793   for (ix = 0; ix != GCOV_COUNTERS; ix++)
 794     if (prg_ctr_mask & (1 << ix))
 795       {
 796         vec<constructor_elt, va_gc> *ctr = NULL;
 797         tree var = data->ctr_vars[ix];
 798         unsigned count = 0;
 799
 800         if (var)
 801           count
 802             = tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (var))), 0)
 803             + 1;
 804
 805         CONSTRUCTOR_APPEND_ELT (ctr, TYPE_FIELDS (ctr_type),
 806                                 build_int_cstu (get_gcov_unsigned_t (),
 807                                                 count));
 808
 809         if (var)
 810           CONSTRUCTOR_APPEND_ELT (ctr, DECL_CHAIN (TYPE_FIELDS (ctr_type)),
 811                                   build_fold_addr_expr (var));
 812
 813         CONSTRUCTOR_APPEND_ELT (v2, NULL, build_constructor (ctr_type, ctr));
 814       }
 815
 816   CONSTRUCTOR_APPEND_ELT (v1, fields,
 817                           build_constructor (TREE_TYPE (fields), v2));
 818
 819   return build_constructor (type, v1);
 820 }
 821
 822 /* Create gcov_info struct.  TYPE is the incomplete RECORD_TYPE to be
 823    completed, and FN_INFO_PTR_TYPE is a pointer to the function info type.  */
 824
 825 static void
 826 build_info_type (tree type, tree fn_info_ptr_type)
 827 {
 828   tree field, fields = NULL_TREE;
 829   tree merge_fn_type;
 830
 831   /* Version ident */
 832   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
 833                       get_gcov_unsigned_t ());
 834   DECL_CHAIN (field) = fields;
 835   fields = field;
 836
 837   /* next pointer */
 838   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
 839                       build_pointer_type (build_qualified_type
 840                                           (type, TYPE_QUAL_CONST)));
 841   DECL_CHAIN (field) = fields;
 842   fields = field;
 843
 844   /* stamp */
 845   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
 846                       get_gcov_unsigned_t ());
 847   DECL_CHAIN (field) = fields;
 848   fields = field;
 849
 850   /* Filename */
 851   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
 852                       build_pointer_type (build_qualified_type
 853                                           (char_type_node, TYPE_QUAL_CONST)));
 854   DECL_CHAIN (field) = fields;
 855   fields = field;
 856
 857   /* merge fn array */
 858   merge_fn_type
 859     = build_function_type_list (void_type_node,
 860                                 build_pointer_type (get_gcov_type ()),
 861                                 get_gcov_unsigned_t (), NULL_TREE);
 862   merge_fn_type
 863     = build_array_type (build_pointer_type (merge_fn_type),
 864                         build_index_type (size_int (GCOV_COUNTERS - 1)));
 865   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
 866                       merge_fn_type);
 867   DECL_CHAIN (field) = fields;
 868   fields = field;
 869
 870   /* n_functions */
 871   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
 872                       get_gcov_unsigned_t ());
 873   DECL_CHAIN (field) = fields;
 874   fields = field;
 875
 876   /* function_info pointer pointer */
 877   fn_info_ptr_type = build_pointer_type
 878     (build_qualified_type (fn_info_ptr_type, TYPE_QUAL_CONST));
 879   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
 880                       fn_info_ptr_type);
 881   DECL_CHAIN (field) = fields;
 882   fields = field;
 883
 884   finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE);
 885 }
 886
 887 /* Returns a CONSTRUCTOR for the gcov_info object.  INFO_TYPE is the
 888    gcov_info structure type, FN_ARY is the array of pointers to
 889    function info objects.  */
 890
 891 static tree
 892 build_info (tree info_type, tree fn_ary)
 893 {
 894   tree info_fields = TYPE_FIELDS (info_type);
 895   tree merge_fn_type, n_funcs;
 896   unsigned ix;
 897   tree filename_string;
 898   int da_file_name_len;
 899   vec<constructor_elt, va_gc> *v1 = NULL;
 900   vec<constructor_elt, va_gc> *v2 = NULL;
 901
 902   /* Version ident */
 903   CONSTRUCTOR_APPEND_ELT (v1, info_fields,
 904                           build_int_cstu (TREE_TYPE (info_fields),
 905                                           GCOV_VERSION));
 906   info_fields = DECL_CHAIN (info_fields);
 907
 908   /* next -- NULL */
 909   CONSTRUCTOR_APPEND_ELT (v1, info_fields, null_pointer_node);
 910   info_fields = DECL_CHAIN (info_fields);
 911
 912   /* stamp */
 913   CONSTRUCTOR_APPEND_ELT (v1, info_fields,
 914                           build_int_cstu (TREE_TYPE (info_fields),
 915                                           bbg_file_stamp));
 916   info_fields = DECL_CHAIN (info_fields);
 917
 918   /* Filename */
 919   da_file_name_len = strlen (da_file_name);
 920   filename_string = build_string (da_file_name_len + 1, da_file_name);
 921   TREE_TYPE (filename_string) = build_array_type
 922     (char_type_node, build_index_type (size_int (da_file_name_len)));
 923   CONSTRUCTOR_APPEND_ELT (v1, info_fields,
 924                           build1 (ADDR_EXPR, TREE_TYPE (info_fields),
 925                                   filename_string));
 926   info_fields = DECL_CHAIN (info_fields);
 927
 928   /* merge fn array -- NULL slots indicate unmeasured counters */
 929   merge_fn_type = TREE_TYPE (TREE_TYPE (info_fields));
 930   for (ix = 0; ix != GCOV_COUNTERS; ix++)
 931     {
 932       tree ptr = null_pointer_node;
 933
 934       if ((1u << ix) & prg_ctr_mask)
 935         {
 936           tree merge_fn = build_decl (BUILTINS_LOCATION,
 937                                       FUNCTION_DECL,
 938                                       get_identifier (ctr_merge_functions[ix]),
 939                                       TREE_TYPE (merge_fn_type));
 940           DECL_EXTERNAL (merge_fn) = 1;
 941           TREE_PUBLIC (merge_fn) = 1;
 942           DECL_ARTIFICIAL (merge_fn) = 1;
 943           TREE_NOTHROW (merge_fn) = 1;
 944           /* Initialize assembler name so we can stream out. */
 945           DECL_ASSEMBLER_NAME (merge_fn);
 946           ptr = build1 (ADDR_EXPR, merge_fn_type, merge_fn);
 947         }
 948       CONSTRUCTOR_APPEND_ELT (v2, NULL, ptr);
 949     }
 950   CONSTRUCTOR_APPEND_ELT (v1, info_fields,
 951                           build_constructor (TREE_TYPE (info_fields), v2));
 952   info_fields = DECL_CHAIN (info_fields);
 953
 954   /* n_functions */
 955   n_funcs = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (fn_ary)));
 956   n_funcs = fold_build2 (PLUS_EXPR, TREE_TYPE (info_fields),
 957                          n_funcs, size_one_node);
 958   CONSTRUCTOR_APPEND_ELT (v1, info_fields, n_funcs);
 959   info_fields = DECL_CHAIN (info_fields);
 960
 961   /* functions */
 962   CONSTRUCTOR_APPEND_ELT (v1, info_fields,
 963                           build1 (ADDR_EXPR, TREE_TYPE (info_fields), fn_ary));
 964   info_fields = DECL_CHAIN (info_fields);
 965
 966   gcc_assert (!info_fields);
 967   return build_constructor (info_type, v1);
 968 }
 969
 970 /* Create the gcov_info types and object.  Generate the constructor
 971    function to call __gcov_init.  Does not generate the initializer
 972    for the object.  Returns TRUE if coverage data is being emitted.  */
 973
 974 static bool
 975 coverage_obj_init (void)
 976 {
 977   tree gcov_info_type, ctor, stmt, init_fn;
 978   unsigned n_counters = 0;
 979   unsigned ix;
 980   struct coverage_data *fn;
 981   struct coverage_data **fn_prev;
 982   char name_buf[32];
 983
 984   no_coverage = 1; /* Disable any further coverage.  */
 985
 986   if (!prg_ctr_mask)
 987     return false;
 988
 989   if (cgraph_dump_file)
 990     fprintf (cgraph_dump_file, "Using data file %s\n", da_file_name);
 991
 992   /* Prune functions.  */
 993   for (fn_prev = &functions_head; (fn = *fn_prev);)
 994     if (DECL_STRUCT_FUNCTION (fn->fn_decl))
 995       fn_prev = &fn->next;
 996     else
 997       /* The function is not being emitted, remove from list.  */
 998       *fn_prev = fn->next;
 999
1000   if (functions_head == NULL)
1001     return false;
1002
1003   for (ix = 0; ix != GCOV_COUNTERS; ix++)
1004     if ((1u << ix) & prg_ctr_mask)
1005       n_counters++;
1006
1007   /* Build the info and fn_info types.  These are mutually recursive.  */
1008   gcov_info_type = lang_hooks.types.make_type (RECORD_TYPE);
1009   gcov_fn_info_type = lang_hooks.types.make_type (RECORD_TYPE);
1010   gcov_fn_info_ptr_type = build_pointer_type
1011     (build_qualified_type (gcov_fn_info_type, TYPE_QUAL_CONST));
1012   build_fn_info_type (gcov_fn_info_type, n_counters, gcov_info_type);
1013   build_info_type (gcov_info_type, gcov_fn_info_ptr_type);
1014
1015   /* Build the gcov info var, this is referred to in its own
1016      initializer.  */
1017   gcov_info_var = build_decl (BUILTINS_LOCATION,
1018                               VAR_DECL, NULL_TREE, gcov_info_type);
1019   TREE_STATIC (gcov_info_var) = 1;
1020   ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0);
1021   DECL_NAME (gcov_info_var) = get_identifier (name_buf);
1022
1023   /* Build a decl for __gcov_init.  */
1024   init_fn = build_pointer_type (gcov_info_type);
1025   init_fn = build_function_type_list (void_type_node, init_fn, NULL);
1026   init_fn = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
1027                         get_identifier ("__gcov_init"), init_fn);
1028   TREE_PUBLIC (init_fn) = 1;
1029   DECL_EXTERNAL (init_fn) = 1;
1030   DECL_ASSEMBLER_NAME (init_fn);
1031
1032   /* Generate a call to __gcov_init(&gcov_info).  */
1033   ctor = NULL;
1034   stmt = build_fold_addr_expr (gcov_info_var);
1035   stmt = build_call_expr (init_fn, 1, stmt);
1036   append_to_statement_list (stmt, &ctor);
1037
1038   /* Generate a constructor to run it.  */
1039   cgraph_build_static_cdtor ('I', ctor, DEFAULT_INIT_PRIORITY);
1040
1041   return true;
1042 }
1043
1044 /* Generate the coverage function info for FN and DATA.  Append a
1045    pointer to that object to CTOR and return the appended CTOR.  */
1046
1047 static vec<constructor_elt, va_gc> *
1048 coverage_obj_fn (vec<constructor_elt, va_gc> *ctor, tree fn,
1049                  struct coverage_data const *data)
1050 {
1051   tree init = build_fn_info (data, gcov_fn_info_type, gcov_info_var);
1052   tree var = build_var (fn, gcov_fn_info_type, -1);
1053
1054   DECL_INITIAL (var) = init;
1055   varpool_finalize_decl (var);
1056
1057   CONSTRUCTOR_APPEND_ELT (ctor, NULL,
1058                           build1 (ADDR_EXPR, gcov_fn_info_ptr_type, var));
1059   return ctor;
1060 }
1061
1062 /* Finalize the coverage data.  Generates the array of pointers to
1063    function objects from CTOR.  Generate the gcov_info initializer.  */
1064
1065 static void
1066 coverage_obj_finish (vec<constructor_elt, va_gc> *ctor)
1067 {
1068   unsigned n_functions = vec_safe_length (ctor);
1069   tree fn_info_ary_type = build_array_type
1070     (build_qualified_type (gcov_fn_info_ptr_type, TYPE_QUAL_CONST),
1071      build_index_type (size_int (n_functions - 1)));
1072   tree fn_info_ary = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL_TREE,
1073                                  fn_info_ary_type);
1074   char name_buf[32];
1075
1076   TREE_STATIC (fn_info_ary) = 1;
1077   ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 1);
1078   DECL_NAME (fn_info_ary) = get_identifier (name_buf);
1079   DECL_INITIAL (fn_info_ary) = build_constructor (fn_info_ary_type, ctor);
1080   varpool_finalize_decl (fn_info_ary);
1081
1082   DECL_INITIAL (gcov_info_var)
1083     = build_info (TREE_TYPE (gcov_info_var), fn_info_ary);
1084   varpool_finalize_decl (gcov_info_var);
1085 }
1086
1087 /* Perform file-level initialization. Read in data file, generate name
1088    of notes file.  */
1089
1090 void
1091 coverage_init (const char *filename)
1092 {
1093   int len = strlen (filename);
1094   int prefix_len = 0;
1095
1096   if (!profile_data_prefix && !IS_ABSOLUTE_PATH (filename))
1097     profile_data_prefix = getpwd ();
1098
1099   if (profile_data_prefix)
1100     prefix_len = strlen (profile_data_prefix);
1101
1102   /* Name of da file.  */
1103   da_file_name = XNEWVEC (char, len + strlen (GCOV_DATA_SUFFIX)
1104                           + prefix_len + 2);
1105
1106   if (profile_data_prefix)
1107     {
1108       memcpy (da_file_name, profile_data_prefix, prefix_len);
1109       da_file_name[prefix_len++] = '/';
1110     }
1111   memcpy (da_file_name + prefix_len, filename, len);
1112   strcpy (da_file_name + prefix_len + len, GCOV_DATA_SUFFIX);
1113
1114   bbg_file_stamp = local_tick;
1115
1116   if (flag_branch_probabilities)
1117     read_counts_file ();
1118
1119   /* Name of bbg file.  */
1120   if (flag_test_coverage && !flag_compare_debug)
1121     {
1122       bbg_file_name = XNEWVEC (char, len + strlen (GCOV_NOTE_SUFFIX) + 1);
1123       memcpy (bbg_file_name, filename, len);
1124       strcpy (bbg_file_name + len, GCOV_NOTE_SUFFIX);
1125
1126       if (!gcov_open (bbg_file_name, -1))
1127         {
1128           error ("cannot open %s", bbg_file_name);
1129           bbg_file_name = NULL;
1130         }
1131       else
1132         {
1133           gcov_write_unsigned (GCOV_NOTE_MAGIC);
1134           gcov_write_unsigned (GCOV_VERSION);
1135           gcov_write_unsigned (bbg_file_stamp);
1136         }
1137     }
1138 }
1139
1140 /* Performs file-level cleanup.  Close notes file, generate coverage
1141    variables and constructor.  */
1142
1143 void
1144 coverage_finish (void)
1145 {
1146   if (bbg_file_name && gcov_close ())
1147     unlink (bbg_file_name);
1148
1149   if (!flag_branch_probabilities && flag_test_coverage
1150       && (!local_tick || local_tick == (unsigned)-1))
1151     /* Only remove the da file, if we're emitting coverage code and
1152        cannot uniquely stamp it.  If we can stamp it, libgcov will DTRT.  */
1153     unlink (da_file_name);
1154
1155   if (coverage_obj_init ())
1156     {
1157       vec<constructor_elt, va_gc> *fn_ctor = NULL;
1158       struct coverage_data *fn;
1159
1160       for (fn = functions_head; fn; fn = fn->next)
1161         fn_ctor = coverage_obj_fn (fn_ctor, fn->fn_decl, fn);
1162       coverage_obj_finish (fn_ctor);
1163     }
1164 }
1165
1166 #include "gt-coverage.h"