gcc/coverage.c

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