gcc/coverage.c

   1 /* Read and write coverage files, and associated functionality.
   2    Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2003, 2004, 2005 Free Software Foundation, Inc.
   4    Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
   5    based on some ideas from Dain Samples of UC Berkeley.
   6    Further mangling by Bob Manson, Cygnus Support.
   7    Further mangled by Nathan Sidwell, CodeSourcery
   8
   9 This file is part of GCC.
  10
  11 GCC is free software; you can redistribute it and/or modify it under
  12 the terms of the GNU General Public License as published by the Free
  13 Software Foundation; either version 2, or (at your option) any later
  14 version.
  15
  16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19 for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with GCC; see the file COPYING.  If not, write to the Free
  23 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  24 02110-1301, USA.  */
  25
  26
  27 #define GCOV_LINKAGE
  28
  29 #include "config.h"
  30 #include "system.h"
  31 #include "coretypes.h"
  32 #include "tm.h"
  33 #include "rtl.h"
  34 #include "tree.h"
  35 #include "flags.h"
  36 #include "output.h"
  37 #include "regs.h"
  38 #include "expr.h"
  39 #include "function.h"
  40 #include "toplev.h"
  41 #include "ggc.h"
  42 #include "coverage.h"
  43 #include "langhooks.h"
  44 #include "hashtab.h"
  45 #include "tree-iterator.h"
  46 #include "cgraph.h"
  47
  48 #include "gcov-io.c"
  49
  50 struct function_list
  51 {
  52   struct function_list *next;    /* next function */
  53   unsigned ident;                /* function ident */
  54   unsigned checksum;             /* function checksum */
  55   unsigned n_ctrs[GCOV_COUNTERS];/* number of counters.  */
  56 };
  57
  58 /* Counts information for a function.  */
  59 typedef struct counts_entry
  60 {
  61   /* We hash by  */
  62   unsigned ident;
  63   unsigned ctr;
  64
  65   /* Store  */
  66   unsigned checksum;
  67   gcov_type *counts;
  68   struct gcov_ctr_summary summary;
  69
  70   /* Workspace */
  71   struct counts_entry *chain;
  72
  73 } counts_entry_t;
  74
  75 static struct function_list *functions_head = 0;
  76 static struct function_list **functions_tail = &functions_head;
  77 static unsigned no_coverage = 0;
  78
  79 /* Cumulative counter information for whole program.  */
  80 static unsigned prg_ctr_mask; /* Mask of counter types generated.  */
  81 static unsigned prg_n_ctrs[GCOV_COUNTERS]; /* Total counters allocated.  */
  82
  83 /* Counter information for current function.  */
  84 static unsigned fn_ctr_mask; /* Mask of counters used.  */
  85 static unsigned fn_n_ctrs[GCOV_COUNTERS]; /* Counters allocated.  */
  86 static unsigned fn_b_ctrs[GCOV_COUNTERS]; /* Allocation base.  */
  87
  88 /* Name of the output file for coverage output file.  */
  89 static char *bbg_file_name;
  90 static unsigned bbg_file_opened;
  91 static int bbg_function_announced;
  92
  93 /* Name of the count data file.  */
  94 static char *da_file_name;
  95
  96 /* Hash table of count data.  */
  97 static htab_t counts_hash = NULL;
  98
  99 /* Trees representing the counter table arrays.  */
 100 static GTY(()) tree tree_ctr_tables[GCOV_COUNTERS];
 101
 102 /* The names of the counter tables.  Not used if we're
 103    generating counters at tree level.  */
 104 static GTY(()) rtx ctr_labels[GCOV_COUNTERS];
 105
 106 /* The names of merge functions for counters.  */
 107 static const char *const ctr_merge_functions[GCOV_COUNTERS] = GCOV_MERGE_FUNCTIONS;
 108 static const char *const ctr_names[GCOV_COUNTERS] = GCOV_COUNTER_NAMES;
 109
 110 /* Forward declarations.  */
 111 static hashval_t htab_counts_entry_hash (const void *);
 112 static int htab_counts_entry_eq (const void *, const void *);
 113 static void htab_counts_entry_del (void *);
 114 static void read_counts_file (void);
 115 static unsigned compute_checksum (void);
 116 static unsigned coverage_checksum_string (unsigned, const char *);
 117 static tree build_fn_info_type (unsigned);
 118 static tree build_fn_info_value (const struct function_list *, tree);
 119 static tree build_ctr_info_type (void);
 120 static tree build_ctr_info_value (unsigned, tree);
 121 static tree build_gcov_info (void);
 122 static void create_coverage (void);
 123 \f
 124 /* Return the type node for gcov_type.  */
 125
 126 tree
 127 get_gcov_type (void)
 128 {
 129   return lang_hooks.types.type_for_size (GCOV_TYPE_SIZE, false);
 130 }
 131
 132 /* Return the type node for gcov_unsigned_t.  */
 133
 134 static tree
 135 get_gcov_unsigned_t (void)
 136 {
 137   return lang_hooks.types.type_for_size (32, true);
 138 }
 139 \f
 140 static hashval_t
 141 htab_counts_entry_hash (const void *of)
 142 {
 143   const counts_entry_t *entry = of;
 144
 145   return entry->ident * GCOV_COUNTERS + entry->ctr;
 146 }
 147
 148 static int
 149 htab_counts_entry_eq (const void *of1, const void *of2)
 150 {
 151   const counts_entry_t *entry1 = of1;
 152   const counts_entry_t *entry2 = of2;
 153
 154   return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
 155 }
 156
 157 static void
 158 htab_counts_entry_del (void *of)
 159 {
 160   counts_entry_t *entry = of;
 161
 162   free (entry->counts);
 163   free (entry);
 164 }
 165
 166 /* Read in the counts file, if available.  */
 167
 168 static void
 169 read_counts_file (void)
 170 {
 171   gcov_unsigned_t fn_ident = 0;
 172   gcov_unsigned_t checksum = -1;
 173   counts_entry_t *summaried = NULL;
 174   unsigned seen_summary = 0;
 175   gcov_unsigned_t tag;
 176   int is_error = 0;
 177
 178   if (!gcov_open (da_file_name, 1))
 179     return;
 180
 181   if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC))
 182     {
 183       warning (0, "%qs is not a gcov data file", da_file_name);
 184       gcov_close ();
 185       return;
 186     }
 187   else if ((tag = gcov_read_unsigned ()) != GCOV_VERSION)
 188     {
 189       char v[4], e[4];
 190
 191       GCOV_UNSIGNED2STRING (v, tag);
 192       GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
 193
 194       warning (0, "%qs is version %q.*s, expected version %q.*s",
 195                da_file_name, 4, v, 4, e);
 196       gcov_close ();
 197       return;
 198     }
 199
 200   /* Read and discard the stamp.  */
 201   gcov_read_unsigned ();
 202
 203   counts_hash = htab_create (10,
 204                              htab_counts_entry_hash, htab_counts_entry_eq,
 205                              htab_counts_entry_del);
 206   while ((tag = gcov_read_unsigned ()))
 207     {
 208       gcov_unsigned_t length;
 209       gcov_position_t offset;
 210
 211       length = gcov_read_unsigned ();
 212       offset = gcov_position ();
 213       if (tag == GCOV_TAG_FUNCTION)
 214         {
 215           fn_ident = gcov_read_unsigned ();
 216           checksum = gcov_read_unsigned ();
 217           if (seen_summary)
 218             {
 219               /* We have already seen a summary, this means that this
 220                  new function begins a new set of program runs. We
 221                  must unlink the summaried chain.  */
 222               counts_entry_t *entry, *chain;
 223
 224               for (entry = summaried; entry; entry = chain)
 225                 {
 226                   chain = entry->chain;
 227                   entry->chain = NULL;
 228                 }
 229               summaried = NULL;
 230               seen_summary = 0;
 231             }
 232         }
 233       else if (tag == GCOV_TAG_PROGRAM_SUMMARY)
 234         {
 235           counts_entry_t *entry;
 236           struct gcov_summary summary;
 237
 238           gcov_read_summary (&summary);
 239           seen_summary = 1;
 240           for (entry = summaried; entry; entry = entry->chain)
 241             {
 242               struct gcov_ctr_summary *csum = &summary.ctrs[entry->ctr];
 243
 244               entry->summary.runs += csum->runs;
 245               entry->summary.sum_all += csum->sum_all;
 246               if (entry->summary.run_max < csum->run_max)
 247                 entry->summary.run_max = csum->run_max;
 248               entry->summary.sum_max += csum->sum_max;
 249             }
 250         }
 251       else if (GCOV_TAG_IS_COUNTER (tag) && fn_ident)
 252         {
 253           counts_entry_t **slot, *entry, elt;
 254           unsigned n_counts = GCOV_TAG_COUNTER_NUM (length);
 255           unsigned ix;
 256
 257           elt.ident = fn_ident;
 258           elt.ctr = GCOV_COUNTER_FOR_TAG (tag);
 259
 260           slot = (counts_entry_t **) htab_find_slot
 261             (counts_hash, &elt, INSERT);
 262           entry = *slot;
 263           if (!entry)
 264             {
 265               *slot = entry = XCNEW (counts_entry_t);
 266               entry->ident = elt.ident;
 267               entry->ctr = elt.ctr;
 268               entry->checksum = checksum;
 269               entry->summary.num = n_counts;
 270               entry->counts = XCNEWVEC (gcov_type, n_counts);
 271             }
 272           else if (entry->checksum != checksum)
 273             {
 274               error ("coverage mismatch for function %u while reading execution counters",
 275                      fn_ident);
 276               error ("checksum is %x instead of %x", entry->checksum, checksum);
 277               htab_delete (counts_hash);
 278               break;
 279             }
 280           else if (entry->summary.num != n_counts)
 281             {
 282               error ("coverage mismatch for function %u while reading execution counters",
 283                      fn_ident);
 284               error ("number of counters is %d instead of %d", entry->summary.num, n_counts);
 285               htab_delete (counts_hash);
 286               break;
 287             }
 288           else if (elt.ctr >= GCOV_COUNTERS_SUMMABLE)
 289             {
 290               error ("cannot merge separate %s counters for function %u",
 291                      ctr_names[elt.ctr], fn_ident);
 292               goto skip_merge;
 293             }
 294
 295           if (elt.ctr < GCOV_COUNTERS_SUMMABLE
 296               /* This should always be true for a just allocated entry,
 297                  and always false for an existing one. Check this way, in
 298                  case the gcov file is corrupt.  */
 299               && (!entry->chain || summaried != entry))
 300             {
 301               entry->chain = summaried;
 302               summaried = entry;
 303             }
 304           for (ix = 0; ix != n_counts; ix++)
 305             entry->counts[ix] += gcov_read_counter ();
 306         skip_merge:;
 307         }
 308       gcov_sync (offset, length);
 309       if ((is_error = gcov_is_error ()))
 310         {
 311           error (is_error < 0 ? "%qs has overflowed" : "%qs is corrupted",
 312                  da_file_name);
 313           htab_delete (counts_hash);
 314           break;
 315         }
 316     }
 317
 318   gcov_close ();
 319 }
 320
 321 /* Returns the counters for a particular tag.  */
 322
 323 gcov_type *
 324 get_coverage_counts (unsigned counter, unsigned expected,
 325                      const struct gcov_ctr_summary **summary)
 326 {
 327   counts_entry_t *entry, elt;
 328   gcov_unsigned_t checksum = -1;
 329
 330   /* No hash table, no counts.  */
 331   if (!counts_hash)
 332     {
 333       static int warned = 0;
 334
 335       if (!warned++)
 336         inform ((flag_guess_branch_prob
 337                  ? "file %s not found, execution counts estimated"
 338                  : "file %s not found, execution counts assumed to be zero"),
 339                 da_file_name);
 340       return NULL;
 341     }
 342
 343   elt.ident = current_function_funcdef_no + 1;
 344   elt.ctr = counter;
 345   entry = htab_find (counts_hash, &elt);
 346   if (!entry)
 347     {
 348       warning (0, "no coverage for function %qs found", IDENTIFIER_POINTER
 349                (DECL_ASSEMBLER_NAME (current_function_decl)));
 350       return NULL;
 351     }
 352
 353   checksum = compute_checksum ();
 354   if (entry->checksum != checksum
 355       || entry->summary.num != expected)
 356     {
 357       static int warned = 0;
 358       const char *id = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
 359                          (current_function_decl));
 360
 361       if (warn_coverage_mismatch)
 362         warning (OPT_Wcoverage_mismatch, "coverage mismatch for function "
 363                  "%qs while reading counter %qs", id, ctr_names[counter]);
 364       else
 365         error ("coverage mismatch for function %qs while reading counter %qs",
 366                id, ctr_names[counter]);
 367
 368       if (!inhibit_warnings)
 369         {
 370           if (entry->checksum != checksum)
 371             inform ("checksum is %x instead of %x", entry->checksum, checksum);
 372           else
 373             inform ("number of counters is %d instead of %d",
 374                     entry->summary.num, expected);
 375         }
 376
 377       if (warn_coverage_mismatch
 378           && !inhibit_warnings
 379           && !warned++)
 380         {
 381           inform ("coverage mismatch ignored due to -Wcoverage-mismatch");
 382           inform (flag_guess_branch_prob
 383                   ? "execution counts estimated"
 384                   : "execution counts assumed to be zero");
 385           if (!flag_guess_branch_prob)
 386             inform ("this can result in poorly optimized code");
 387         }
 388
 389       return NULL;
 390     }
 391
 392   if (summary)
 393     *summary = &entry->summary;
 394
 395   return entry->counts;
 396 }
 397
 398 /* Allocate NUM counters of type COUNTER. Returns nonzero if the
 399    allocation succeeded.  */
 400
 401 int
 402 coverage_counter_alloc (unsigned counter, unsigned num)
 403 {
 404   if (no_coverage)
 405     return 0;
 406
 407   if (!num)
 408     return 1;
 409
 410   if (!tree_ctr_tables[counter])
 411     {
 412       /* Generate and save a copy of this so it can be shared.  Leave
 413          the index type unspecified for now; it will be set after all
 414          functions have been compiled.  */
 415       char buf[20];
 416       tree gcov_type_node = get_gcov_type ();
 417       tree gcov_type_array_type
 418         = build_array_type (gcov_type_node, NULL_TREE);
 419       tree_ctr_tables[counter]
 420         = build_decl (VAR_DECL, NULL_TREE, gcov_type_array_type);
 421       TREE_STATIC (tree_ctr_tables[counter]) = 1;
 422       ASM_GENERATE_INTERNAL_LABEL (buf, "LPBX", counter + 1);
 423       DECL_NAME (tree_ctr_tables[counter]) = get_identifier (buf);
 424       DECL_ALIGN (tree_ctr_tables[counter]) = TYPE_ALIGN (gcov_type_node);
 425     }
 426   fn_b_ctrs[counter] = fn_n_ctrs[counter];
 427   fn_n_ctrs[counter] += num;
 428   fn_ctr_mask |= 1 << counter;
 429   return 1;
 430 }
 431
 432 /* Generate a tree to access COUNTER NO.  */
 433
 434 tree
 435 tree_coverage_counter_ref (unsigned counter, unsigned no)
 436 {
 437   tree gcov_type_node = get_gcov_type ();
 438
 439   gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]);
 440   no += prg_n_ctrs[counter] + fn_b_ctrs[counter];
 441
 442   /* "no" here is an array index, scaled to bytes later.  */
 443   return build4 (ARRAY_REF, gcov_type_node, tree_ctr_tables[counter],
 444                  build_int_cst (NULL_TREE, no), NULL, NULL);
 445 }
 446 \f
 447 /* Generate a checksum for a string.  CHKSUM is the current
 448    checksum.  */
 449
 450 static unsigned
 451 coverage_checksum_string (unsigned chksum, const char *string)
 452 {
 453   int i;
 454   char *dup = NULL;
 455
 456   /* Look for everything that looks if it were produced by
 457      get_file_function_name and zero out the second part
 458      that may result from flag_random_seed.  This is not critical
 459      as the checksums are used only for sanity checking.  */
 460   for (i = 0; string[i]; i++)
 461     {
 462       int offset = 0;
 463       if (!strncmp (string + i, "_GLOBAL__N_", 11))
 464       offset = 11;
 465       if (!strncmp (string + i, "_GLOBAL__", 9))
 466       offset = 9;
 467
 468       /* C++ namespaces do have scheme:
 469          _GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname
 470        since filename might contain extra underscores there seems
 471        to be no better chance then walk all possible offsets looking
 472        for magicnuber.  */
 473       if (offset)
 474         {
 475           for (i = i + offset; string[i]; i++)
 476             if (string[i]=='_')
 477               {
 478                 int y;
 479
 480                 for (y = 1; y < 9; y++)
 481                   if (!(string[i + y] >= '0' && string[i + y] <= '9')
 482                       && !(string[i + y] >= 'A' && string[i + y] <= 'F'))
 483                     break;
 484                 if (y != 9 || string[i + 9] != '_')
 485                   continue;
 486                 for (y = 10; y < 18; y++)
 487                   if (!(string[i + y] >= '0' && string[i + y] <= '9')
 488                       && !(string[i + y] >= 'A' && string[i + y] <= 'F'))
 489                     break;
 490                 if (y != 18)
 491                   continue;
 492                 if (!dup)
 493                   string = dup = xstrdup (string);
 494                 for (y = 10; y < 18; y++)
 495                   dup[i + y] = '0';
 496               }
 497           break;
 498         }
 499     }
 500
 501   chksum = crc32_string (chksum, string);
 502   if (dup)
 503     free (dup);
 504
 505   return chksum;
 506 }
 507
 508 /* Compute checksum for the current function.  We generate a CRC32.  */
 509
 510 static unsigned
 511 compute_checksum (void)
 512 {
 513   expanded_location xloc
 514     = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
 515   unsigned chksum = xloc.line;
 516
 517   chksum = coverage_checksum_string (chksum, xloc.file);
 518   chksum = coverage_checksum_string
 519     (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)));
 520
 521   return chksum;
 522 }
 523 \f
 524 /* Begin output to the graph file for the current function.
 525    Opens the output file, if not already done. Writes the
 526    function header, if not already done. Returns nonzero if data
 527    should be output.  */
 528
 529 int
 530 coverage_begin_output (void)
 531 {
 532   if (no_coverage)
 533     return 0;
 534
 535   if (!bbg_function_announced)
 536     {
 537       expanded_location xloc
 538         = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
 539       unsigned long offset;
 540
 541       if (!bbg_file_opened)
 542         {
 543           if (!gcov_open (bbg_file_name, -1))
 544             error ("cannot open %s", bbg_file_name);
 545           else
 546             {
 547               gcov_write_unsigned (GCOV_NOTE_MAGIC);
 548               gcov_write_unsigned (GCOV_VERSION);
 549               gcov_write_unsigned (local_tick);
 550             }
 551           bbg_file_opened = 1;
 552         }
 553
 554       /* Announce function */
 555       offset = gcov_write_tag (GCOV_TAG_FUNCTION);
 556       gcov_write_unsigned (current_function_funcdef_no + 1);
 557       gcov_write_unsigned (compute_checksum ());
 558       gcov_write_string (IDENTIFIER_POINTER
 559                          (DECL_ASSEMBLER_NAME (current_function_decl)));
 560       gcov_write_string (xloc.file);
 561       gcov_write_unsigned (xloc.line);
 562       gcov_write_length (offset);
 563
 564       bbg_function_announced = 1;
 565     }
 566   return !gcov_is_error ();
 567 }
 568
 569 /* Finish coverage data for the current function. Verify no output
 570    error has occurred.  Save function coverage counts.  */
 571
 572 void
 573 coverage_end_function (void)
 574 {
 575   unsigned i;
 576
 577   if (bbg_file_opened > 1 && gcov_is_error ())
 578     {
 579       warning (0, "error writing %qs", bbg_file_name);
 580       bbg_file_opened = -1;
 581     }
 582
 583   if (fn_ctr_mask)
 584     {
 585       struct function_list *item;
 586
 587       item = XNEW (struct function_list);
 588
 589       *functions_tail = item;
 590       functions_tail = &item->next;
 591
 592       item->next = 0;
 593       item->ident = current_function_funcdef_no + 1;
 594       item->checksum = compute_checksum ();
 595       for (i = 0; i != GCOV_COUNTERS; i++)
 596         {
 597           item->n_ctrs[i] = fn_n_ctrs[i];
 598           prg_n_ctrs[i] += fn_n_ctrs[i];
 599           fn_n_ctrs[i] = fn_b_ctrs[i] = 0;
 600         }
 601       prg_ctr_mask |= fn_ctr_mask;
 602       fn_ctr_mask = 0;
 603     }
 604   bbg_function_announced = 0;
 605 }
 606
 607 /* Creates the gcov_fn_info RECORD_TYPE.  */
 608
 609 static tree
 610 build_fn_info_type (unsigned int counters)
 611 {
 612   tree type = lang_hooks.types.make_type (RECORD_TYPE);
 613   tree field, fields;
 614   tree array_type;
 615
 616   /* ident */
 617   fields = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 618
 619   /* checksum */
 620   field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 621   TREE_CHAIN (field) = fields;
 622   fields = field;
 623
 624   array_type = build_int_cst (NULL_TREE, counters - 1);
 625   array_type = build_index_type (array_type);
 626   array_type = build_array_type (get_gcov_unsigned_t (), array_type);
 627
 628   /* counters */
 629   field = build_decl (FIELD_DECL, NULL_TREE, array_type);
 630   TREE_CHAIN (field) = fields;
 631   fields = field;
 632
 633   finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE);
 634
 635   return type;
 636 }
 637
 638 /* Creates a CONSTRUCTOR for a gcov_fn_info. FUNCTION is
 639    the function being processed and TYPE is the gcov_fn_info
 640    RECORD_TYPE.  */
 641
 642 static tree
 643 build_fn_info_value (const struct function_list *function, tree type)
 644 {
 645   tree value = NULL_TREE;
 646   tree fields = TYPE_FIELDS (type);
 647   unsigned ix;
 648   tree array_value = NULL_TREE;
 649
 650   /* ident */
 651   value = tree_cons (fields, build_int_cstu (get_gcov_unsigned_t (),
 652                                              function->ident), value);
 653   fields = TREE_CHAIN (fields);
 654
 655   /* checksum */
 656   value = tree_cons (fields, build_int_cstu (get_gcov_unsigned_t (),
 657                                              function->checksum), value);
 658   fields = TREE_CHAIN (fields);
 659
 660   /* counters */
 661   for (ix = 0; ix != GCOV_COUNTERS; ix++)
 662     if (prg_ctr_mask & (1 << ix))
 663       {
 664         tree counters = build_int_cstu (get_gcov_unsigned_t (),
 665                                         function->n_ctrs[ix]);
 666
 667         array_value = tree_cons (NULL_TREE, counters, array_value);
 668       }
 669
 670   /* FIXME: use build_constructor directly.  */
 671   array_value = build_constructor_from_list (TREE_TYPE (fields),
 672                                              nreverse (array_value));
 673   value = tree_cons (fields, array_value, value);
 674
 675   /* FIXME: use build_constructor directly.  */
 676   value = build_constructor_from_list (type, nreverse (value));
 677
 678   return value;
 679 }
 680
 681 /* Creates the gcov_ctr_info RECORD_TYPE.  */
 682
 683 static tree
 684 build_ctr_info_type (void)
 685 {
 686   tree type = lang_hooks.types.make_type (RECORD_TYPE);
 687   tree field, fields = NULL_TREE;
 688   tree gcov_ptr_type = build_pointer_type (get_gcov_type ());
 689   tree gcov_merge_fn_type;
 690
 691   /* counters */
 692   field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 693   TREE_CHAIN (field) = fields;
 694   fields = field;
 695
 696   /* values */
 697   field = build_decl (FIELD_DECL, NULL_TREE, gcov_ptr_type);
 698   TREE_CHAIN (field) = fields;
 699   fields = field;
 700
 701   /* merge */
 702   gcov_merge_fn_type =
 703     build_function_type_list (void_type_node,
 704                               gcov_ptr_type, get_gcov_unsigned_t (),
 705                               NULL_TREE);
 706   field = build_decl (FIELD_DECL, NULL_TREE,
 707                       build_pointer_type (gcov_merge_fn_type));
 708   TREE_CHAIN (field) = fields;
 709   fields = field;
 710
 711   finish_builtin_struct (type, "__gcov_ctr_info", fields, NULL_TREE);
 712
 713   return type;
 714 }
 715
 716 /* Creates a CONSTRUCTOR for a gcov_ctr_info. COUNTER is
 717    the counter being processed and TYPE is the gcov_ctr_info
 718    RECORD_TYPE.  */
 719
 720 static tree
 721 build_ctr_info_value (unsigned int counter, tree type)
 722 {
 723   tree value = NULL_TREE;
 724   tree fields = TYPE_FIELDS (type);
 725   tree fn;
 726
 727   /* counters */
 728   value = tree_cons (fields,
 729                      build_int_cstu (get_gcov_unsigned_t (),
 730                                      prg_n_ctrs[counter]),
 731                      value);
 732   fields = TREE_CHAIN (fields);
 733
 734   if (prg_n_ctrs[counter])
 735     {
 736       tree array_type;
 737
 738       array_type = build_int_cstu (get_gcov_unsigned_t (),
 739                                    prg_n_ctrs[counter] - 1);
 740       array_type = build_index_type (array_type);
 741       array_type = build_array_type (TREE_TYPE (TREE_TYPE (fields)),
 742                                      array_type);
 743
 744       TREE_TYPE (tree_ctr_tables[counter]) = array_type;
 745       DECL_SIZE (tree_ctr_tables[counter]) = TYPE_SIZE (array_type);
 746       DECL_SIZE_UNIT (tree_ctr_tables[counter]) = TYPE_SIZE_UNIT (array_type);
 747       assemble_variable (tree_ctr_tables[counter], 0, 0, 0);
 748
 749       value = tree_cons (fields,
 750                          build1 (ADDR_EXPR, TREE_TYPE (fields),
 751                                             tree_ctr_tables[counter]),
 752                          value);
 753     }
 754   else
 755     value = tree_cons (fields, null_pointer_node, value);
 756   fields = TREE_CHAIN (fields);
 757
 758   fn = build_decl (FUNCTION_DECL,
 759                    get_identifier (ctr_merge_functions[counter]),
 760                    TREE_TYPE (TREE_TYPE (fields)));
 761   DECL_EXTERNAL (fn) = 1;
 762   TREE_PUBLIC (fn) = 1;
 763   DECL_ARTIFICIAL (fn) = 1;
 764   TREE_NOTHROW (fn) = 1;
 765   value = tree_cons (fields,
 766                      build1 (ADDR_EXPR, TREE_TYPE (fields), fn),
 767                      value);
 768
 769   /* FIXME: use build_constructor directly.  */
 770   value = build_constructor_from_list (type, nreverse (value));
 771
 772   return value;
 773 }
 774
 775 /* Creates the gcov_info RECORD_TYPE and initializer for it. Returns a
 776    CONSTRUCTOR.  */
 777
 778 static tree
 779 build_gcov_info (void)
 780 {
 781   unsigned n_ctr_types, ix;
 782   tree type, const_type;
 783   tree fn_info_type, fn_info_value = NULL_TREE;
 784   tree fn_info_ptr_type;
 785   tree ctr_info_type, ctr_info_ary_type, ctr_info_value = NULL_TREE;
 786   tree field, fields = NULL_TREE;
 787   tree value = NULL_TREE;
 788   tree filename_string;
 789   char *filename;
 790   int filename_len;
 791   unsigned n_fns;
 792   const struct function_list *fn;
 793   tree string_type;
 794
 795   /* Count the number of active counters.  */
 796   for (n_ctr_types = 0, ix = 0; ix != GCOV_COUNTERS; ix++)
 797     if (prg_ctr_mask & (1 << ix))
 798       n_ctr_types++;
 799
 800   type = lang_hooks.types.make_type (RECORD_TYPE);
 801   const_type = build_qualified_type (type, TYPE_QUAL_CONST);
 802
 803   /* Version ident */
 804   field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 805   TREE_CHAIN (field) = fields;
 806   fields = field;
 807   value = tree_cons (field, build_int_cstu (TREE_TYPE (field), GCOV_VERSION),
 808                      value);
 809
 810   /* next -- NULL */
 811   field = build_decl (FIELD_DECL, NULL_TREE, build_pointer_type (const_type));
 812   TREE_CHAIN (field) = fields;
 813   fields = field;
 814   value = tree_cons (field, null_pointer_node, value);
 815
 816   /* stamp */
 817   field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 818   TREE_CHAIN (field) = fields;
 819   fields = field;
 820   value = tree_cons (field, build_int_cstu (TREE_TYPE (field), local_tick),
 821                      value);
 822
 823   /* Filename */
 824   string_type = build_pointer_type (build_qualified_type (char_type_node,
 825                                                     TYPE_QUAL_CONST));
 826   field = build_decl (FIELD_DECL, NULL_TREE, string_type);
 827   TREE_CHAIN (field) = fields;
 828   fields = field;
 829   filename = getpwd ();
 830   filename = (filename && da_file_name[0] != '/'
 831               ? concat (filename, "/", da_file_name, NULL)
 832               : da_file_name);
 833   filename_len = strlen (filename);
 834   filename_string = build_string (filename_len + 1, filename);
 835   if (filename != da_file_name)
 836     free (filename);
 837   TREE_TYPE (filename_string) = build_array_type
 838     (char_type_node, build_index_type
 839      (build_int_cst (NULL_TREE, filename_len)));
 840   value = tree_cons (field, build1 (ADDR_EXPR, string_type, filename_string),
 841                      value);
 842
 843   /* Build the fn_info type and initializer.  */
 844   fn_info_type = build_fn_info_type (n_ctr_types);
 845   fn_info_ptr_type = build_pointer_type (build_qualified_type
 846                                          (fn_info_type, TYPE_QUAL_CONST));
 847   for (fn = functions_head, n_fns = 0; fn; fn = fn->next, n_fns++)
 848     fn_info_value = tree_cons (NULL_TREE,
 849                                build_fn_info_value (fn, fn_info_type),
 850                                fn_info_value);
 851   if (n_fns)
 852     {
 853       tree array_type;
 854
 855       array_type = build_index_type (build_int_cst (NULL_TREE, n_fns - 1));
 856       array_type = build_array_type (fn_info_type, array_type);
 857
 858       /* FIXME: use build_constructor directly.  */
 859       fn_info_value = build_constructor_from_list (array_type,
 860                                                    nreverse (fn_info_value));
 861       fn_info_value = build1 (ADDR_EXPR, fn_info_ptr_type, fn_info_value);
 862     }
 863   else
 864     fn_info_value = null_pointer_node;
 865
 866   /* number of functions */
 867   field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 868   TREE_CHAIN (field) = fields;
 869   fields = field;
 870   value = tree_cons (field,
 871                      build_int_cstu (get_gcov_unsigned_t (), n_fns),
 872                      value);
 873
 874   /* fn_info table */
 875   field = build_decl (FIELD_DECL, NULL_TREE, fn_info_ptr_type);
 876   TREE_CHAIN (field) = fields;
 877   fields = field;
 878   value = tree_cons (field, fn_info_value, value);
 879
 880   /* counter_mask */
 881   field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 882   TREE_CHAIN (field) = fields;
 883   fields = field;
 884   value = tree_cons (field,
 885                      build_int_cstu (get_gcov_unsigned_t (), prg_ctr_mask),
 886                      value);
 887
 888   /* counters */
 889   ctr_info_type = build_ctr_info_type ();
 890   ctr_info_ary_type = build_index_type (build_int_cst (NULL_TREE,
 891                                                        n_ctr_types));
 892   ctr_info_ary_type = build_array_type (ctr_info_type, ctr_info_ary_type);
 893   for (ix = 0; ix != GCOV_COUNTERS; ix++)
 894     if (prg_ctr_mask & (1 << ix))
 895       ctr_info_value = tree_cons (NULL_TREE,
 896                                   build_ctr_info_value (ix, ctr_info_type),
 897                                   ctr_info_value);
 898   /* FIXME: use build_constructor directly.  */
 899   ctr_info_value = build_constructor_from_list (ctr_info_ary_type,
 900                                                 nreverse (ctr_info_value));
 901
 902   field = build_decl (FIELD_DECL, NULL_TREE, ctr_info_ary_type);
 903   TREE_CHAIN (field) = fields;
 904   fields = field;
 905   value = tree_cons (field, ctr_info_value, value);
 906
 907   finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE);
 908
 909   /* FIXME: use build_constructor directly.  */
 910   value = build_constructor_from_list (type, nreverse (value));
 911
 912   return value;
 913 }
 914
 915 /* Write out the structure which libgcov uses to locate all the
 916    counters.  The structures used here must match those defined in
 917    gcov-io.h.  Write out the constructor to call __gcov_init.  */
 918
 919 static void
 920 create_coverage (void)
 921 {
 922   tree gcov_info, gcov_init, body, t;
 923   char name_buf[32];
 924
 925   no_coverage = 1; /* Disable any further coverage.  */
 926
 927   if (!prg_ctr_mask)
 928     return;
 929
 930   t = build_gcov_info ();
 931
 932   gcov_info = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (t));
 933   TREE_STATIC (gcov_info) = 1;
 934   ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0);
 935   DECL_NAME (gcov_info) = get_identifier (name_buf);
 936   DECL_INITIAL (gcov_info) = t;
 937
 938   /* Build structure.  */
 939   assemble_variable (gcov_info, 0, 0, 0);
 940
 941   /* Build a decl for __gcov_init.  */
 942   t = build_pointer_type (TREE_TYPE (gcov_info));
 943   t = build_function_type_list (void_type_node, t, NULL);
 944   t = build_decl (FUNCTION_DECL, get_identifier ("__gcov_init"), t);
 945   TREE_PUBLIC (t) = 1;
 946   DECL_EXTERNAL (t) = 1;
 947   gcov_init = t;
 948
 949   /* Generate a call to __gcov_init(&gcov_info).  */
 950   body = NULL;
 951   t = build_fold_addr_expr (gcov_info);
 952   t = build_call_expr (gcov_init, 1, t);
 953   append_to_statement_list (t, &body);
 954
 955   /* Generate a constructor to run it.  */
 956   cgraph_build_static_cdtor ('I', body, DEFAULT_INIT_PRIORITY);
 957 }
 958 \f
 959 /* Perform file-level initialization. Read in data file, generate name
 960    of graph file.  */
 961
 962 void
 963 coverage_init (const char *filename)
 964 {
 965   int len = strlen (filename);
 966
 967   /* Name of da file.  */
 968   da_file_name = XNEWVEC (char, len + strlen (GCOV_DATA_SUFFIX) + 1);
 969   strcpy (da_file_name, filename);
 970   strcat (da_file_name, GCOV_DATA_SUFFIX);
 971
 972   /* Name of bbg file.  */
 973   bbg_file_name = XNEWVEC (char, len + strlen (GCOV_NOTE_SUFFIX) + 1);
 974   strcpy (bbg_file_name, filename);
 975   strcat (bbg_file_name, GCOV_NOTE_SUFFIX);
 976
 977   read_counts_file ();
 978 }
 979
 980 /* Performs file-level cleanup.  Close graph file, generate coverage
 981    variables and constructor.  */
 982
 983 void
 984 coverage_finish (void)
 985 {
 986   create_coverage ();
 987   if (bbg_file_opened)
 988     {
 989       int error = gcov_close ();
 990
 991       if (error)
 992         unlink (bbg_file_name);
 993       if (!local_tick)
 994         /* Only remove the da file, if we cannot stamp it. If we can
 995            stamp it, libgcov will DTRT.  */
 996         unlink (da_file_name);
 997     }
 998 }
 999
1000 #include "gt-coverage.h"