contrib/gcc-8.0/gcc/coverage.c

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