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 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, 59 Temple Place - Suite 330, Boston, MA
  24 02111-1307, 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 ("%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 ("%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 = xcalloc (1, sizeof (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 = xcalloc (n_counts, sizeof (gcov_type));
 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 ("no coverage for function %qs found.", IDENTIFIER_POINTER
 349                (DECL_ASSEMBLER_NAME (current_function_decl)));
 350       return 0;
 351     }
 352
 353   checksum = compute_checksum ();
 354   if (entry->checksum != checksum)
 355     {
 356       error ("coverage mismatch for function %qs while reading counter %qs.",
 357              IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)),
 358              ctr_names[counter]);
 359       error ("checksum is %x instead of %x", entry->checksum, checksum);
 360       return 0;
 361     }
 362   else if (entry->summary.num != expected)
 363     {
 364       error ("coverage mismatch for function %qs while reading counter %qs.",
 365              IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)),
 366              ctr_names[counter]);
 367       error ("number of counters is %d instead of %d", entry->summary.num, expected);
 368       return 0;
 369     }
 370
 371   if (summary)
 372     *summary = &entry->summary;
 373
 374   return entry->counts;
 375 }
 376
 377 /* Allocate NUM counters of type COUNTER. Returns nonzero if the
 378    allocation succeeded.  */
 379
 380 int
 381 coverage_counter_alloc (unsigned counter, unsigned num)
 382 {
 383   if (no_coverage)
 384     return 0;
 385
 386   if (!num)
 387     return 1;
 388
 389   if (!tree_ctr_tables[counter])
 390     {
 391       /* Generate and save a copy of this so it can be shared.  */
 392       /* We don't know the size yet; make it big enough that nobody
 393          will make any clever transformation on it.  */
 394       char buf[20];
 395       tree domain_tree
 396         = build_index_type (build_int_cst (NULL_TREE, 1000)); /* replaced later */
 397       tree gcov_type_array_type
 398         = build_array_type (GCOV_TYPE_NODE, domain_tree);
 399       tree_ctr_tables[counter]
 400         = build_decl (VAR_DECL, NULL_TREE, gcov_type_array_type);
 401       TREE_STATIC (tree_ctr_tables[counter]) = 1;
 402       ASM_GENERATE_INTERNAL_LABEL (buf, "LPBX", counter + 1);
 403       DECL_NAME (tree_ctr_tables[counter]) = get_identifier (buf);
 404       DECL_ALIGN (tree_ctr_tables[counter]) = TYPE_ALIGN (GCOV_TYPE_NODE);
 405     }
 406   fn_b_ctrs[counter] = fn_n_ctrs[counter];
 407   fn_n_ctrs[counter] += num;
 408   fn_ctr_mask |= 1 << counter;
 409   return 1;
 410 }
 411
 412 /* Generate a MEM rtl to access COUNTER NO.  */
 413
 414 rtx
 415 rtl_coverage_counter_ref (unsigned counter, unsigned no)
 416 {
 417   enum machine_mode mode = mode_for_size (GCOV_TYPE_SIZE, MODE_INT, 0);
 418   rtx ref;
 419
 420   gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]);
 421   no += prg_n_ctrs[counter] + fn_b_ctrs[counter];
 422   if (!ctr_labels[counter])
 423       {
 424         ctr_labels[counter] = gen_rtx_SYMBOL_REF (Pmode,
 425                                ggc_strdup (IDENTIFIER_POINTER (DECL_NAME
 426                                (tree_ctr_tables[counter]))));
 427         SYMBOL_REF_FLAGS (ctr_labels[counter]) = SYMBOL_FLAG_LOCAL;
 428       }
 429   ref = plus_constant (ctr_labels[counter],
 430                        GCOV_TYPE_SIZE / BITS_PER_UNIT * no);
 431   ref = gen_rtx_MEM (mode, ref);
 432   set_mem_alias_set (ref, new_alias_set ());
 433   MEM_NOTRAP_P (ref) = 1;
 434
 435   return ref;
 436 }
 437
 438 /* Generate a tree to access COUNTER NO.  */
 439
 440 tree
 441 tree_coverage_counter_ref (unsigned counter, unsigned no)
 442 {
 443   tree domain_type = TYPE_DOMAIN (TREE_TYPE (tree_ctr_tables[counter]));
 444
 445   gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]);
 446   no += prg_n_ctrs[counter] + fn_b_ctrs[counter];
 447
 448   /* "no" here is an array index, scaled to bytes later.  */
 449   return build4 (ARRAY_REF, GCOV_TYPE_NODE, tree_ctr_tables[counter],
 450                  fold_convert (domain_type,
 451                                build_int_cst (NULL_TREE, no)),
 452                  TYPE_MIN_VALUE (domain_type),
 453                  size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (GCOV_TYPE_NODE),
 454                              size_int (TYPE_ALIGN_UNIT (GCOV_TYPE_NODE))));
 455 }
 456 \f
 457 /* Generate a checksum for a string.  CHKSUM is the current
 458    checksum.  */
 459
 460 static unsigned
 461 coverage_checksum_string (unsigned chksum, const char *string)
 462 {
 463   int i;
 464   char *dup = NULL;
 465
 466   /* Look for everything that looks if it were produced by
 467      get_file_function_name_long and zero out the second part
 468      that may result from flag_random_seed.  This is not critical
 469      as the checksums are used only for sanity checking.  */
 470   for (i = 0; string[i]; i++)
 471     {
 472       if (!strncmp (string + i, "_GLOBAL__", 9))
 473         for (i = i + 9; string[i]; i++)
 474           if (string[i]=='_')
 475             {
 476               int y;
 477               unsigned seed;
 478               int scan;
 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               scan = sscanf (string + i + 10, "%X", &seed);
 493               gcc_assert (scan);
 494               if (seed != crc32_string (0, flag_random_seed))
 495                 continue;
 496               string = dup = xstrdup (string);
 497               for (y = 10; y < 18; y++)
 498                 dup[i + y] = '0';
 499               break;
 500             }
 501       break;
 502     }
 503
 504   chksum = crc32_string (chksum, string);
 505   if (dup)
 506     free (dup);
 507
 508   return chksum;
 509 }
 510
 511 /* Compute checksum for the current function.  We generate a CRC32.  */
 512
 513 static unsigned
 514 compute_checksum (void)
 515 {
 516   expanded_location xloc
 517     = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
 518   unsigned chksum = xloc.line;
 519
 520   chksum = coverage_checksum_string (chksum, xloc.file);
 521   chksum = coverage_checksum_string
 522     (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)));
 523
 524   return chksum;
 525 }
 526 \f
 527 /* Begin output to the graph file for the current function.
 528    Opens the output file, if not already done. Writes the
 529    function header, if not already done. Returns nonzero if data
 530    should be output.  */
 531
 532 int
 533 coverage_begin_output (void)
 534 {
 535   if (no_coverage)
 536     return 0;
 537
 538   if (!bbg_function_announced)
 539     {
 540       expanded_location xloc
 541         = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
 542       unsigned long offset;
 543
 544       if (!bbg_file_opened)
 545         {
 546           if (!gcov_open (bbg_file_name, -1))
 547             error ("cannot open %s", bbg_file_name);
 548           else
 549             {
 550               gcov_write_unsigned (GCOV_NOTE_MAGIC);
 551               gcov_write_unsigned (GCOV_VERSION);
 552               gcov_write_unsigned (local_tick);
 553             }
 554           bbg_file_opened = 1;
 555         }
 556
 557       /* Announce function */
 558       offset = gcov_write_tag (GCOV_TAG_FUNCTION);
 559       gcov_write_unsigned (current_function_funcdef_no + 1);
 560       gcov_write_unsigned (compute_checksum ());
 561       gcov_write_string (IDENTIFIER_POINTER
 562                          (DECL_ASSEMBLER_NAME (current_function_decl)));
 563       gcov_write_string (xloc.file);
 564       gcov_write_unsigned (xloc.line);
 565       gcov_write_length (offset);
 566
 567       bbg_function_announced = 1;
 568     }
 569   return !gcov_is_error ();
 570 }
 571
 572 /* Finish coverage data for the current function. Verify no output
 573    error has occurred.  Save function coverage counts.  */
 574
 575 void
 576 coverage_end_function (void)
 577 {
 578   unsigned i;
 579
 580   if (bbg_file_opened > 1 && gcov_is_error ())
 581     {
 582       warning ("error writing %qs", bbg_file_name);
 583       bbg_file_opened = -1;
 584     }
 585
 586   if (fn_ctr_mask)
 587     {
 588       struct function_list *item;
 589
 590       item = xmalloc (sizeof (struct function_list));
 591
 592       *functions_tail = item;
 593       functions_tail = &item->next;
 594
 595       item->next = 0;
 596       item->ident = current_function_funcdef_no + 1;
 597       item->checksum = compute_checksum ();
 598       for (i = 0; i != GCOV_COUNTERS; i++)
 599         {
 600           item->n_ctrs[i] = fn_n_ctrs[i];
 601           prg_n_ctrs[i] += fn_n_ctrs[i];
 602           fn_n_ctrs[i] = fn_b_ctrs[i] = 0;
 603         }
 604       prg_ctr_mask |= fn_ctr_mask;
 605       fn_ctr_mask = 0;
 606     }
 607   bbg_function_announced = 0;
 608 }
 609
 610 /* Creates the gcov_fn_info RECORD_TYPE.  */
 611
 612 static tree
 613 build_fn_info_type (unsigned int counters)
 614 {
 615   tree type = lang_hooks.types.make_type (RECORD_TYPE);
 616   tree field, fields;
 617   tree array_type;
 618
 619   /* ident */
 620   fields = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 621
 622   /* checksum */
 623   field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 624   TREE_CHAIN (field) = fields;
 625   fields = field;
 626
 627   array_type = build_int_cst (NULL_TREE, counters - 1);
 628   array_type = build_index_type (array_type);
 629   array_type = build_array_type (unsigned_type_node, array_type);
 630
 631   /* counters */
 632   field = build_decl (FIELD_DECL, NULL_TREE, array_type);
 633   TREE_CHAIN (field) = fields;
 634   fields = field;
 635
 636   finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE);
 637
 638   return type;
 639 }
 640
 641 /* Creates a CONSTRUCTOR for a gcov_fn_info. FUNCTION is
 642    the function being processed and TYPE is the gcov_fn_info
 643    RECORD_TYPE.  */
 644
 645 static tree
 646 build_fn_info_value (const struct function_list *function, tree type)
 647 {
 648   tree value = NULL_TREE;
 649   tree fields = TYPE_FIELDS (type);
 650   unsigned ix;
 651   tree array_value = NULL_TREE;
 652
 653   /* ident */
 654   value = tree_cons (fields, build_int_cstu (get_gcov_unsigned_t (),
 655                                              function->ident), value);
 656   fields = TREE_CHAIN (fields);
 657
 658   /* checksum */
 659   value = tree_cons (fields, build_int_cstu (get_gcov_unsigned_t (),
 660                                              function->checksum), value);
 661   fields = TREE_CHAIN (fields);
 662
 663   /* counters */
 664   for (ix = 0; ix != GCOV_COUNTERS; ix++)
 665     if (prg_ctr_mask & (1 << ix))
 666       {
 667         tree counters = build_int_cstu (unsigned_type_node,
 668                                         function->n_ctrs[ix]);
 669
 670         array_value = tree_cons (NULL_TREE, counters, array_value);
 671       }
 672
 673   array_value = build_constructor (TREE_TYPE (fields), nreverse (array_value));
 674   value = tree_cons (fields, array_value, value);
 675
 676   value = build_constructor (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 (GCOV_TYPE_NODE);
 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, unsigned_type_node,
 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 (unsigned_type_node,
 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   value = build_constructor (type, nreverse (value));
 770
 771   return value;
 772 }
 773
 774 /* Creates the gcov_info RECORD_TYPE and initializer for it. Returns a
 775    CONSTRUCTOR.  */
 776
 777 static tree
 778 build_gcov_info (void)
 779 {
 780   unsigned n_ctr_types, ix;
 781   tree type, const_type;
 782   tree fn_info_type, fn_info_value = NULL_TREE;
 783   tree fn_info_ptr_type;
 784   tree ctr_info_type, ctr_info_ary_type, ctr_info_value = NULL_TREE;
 785   tree field, fields = NULL_TREE;
 786   tree value = NULL_TREE;
 787   tree filename_string;
 788   char *filename;
 789   int filename_len;
 790   unsigned n_fns;
 791   const struct function_list *fn;
 792   tree string_type;
 793
 794   /* Count the number of active counters.  */
 795   for (n_ctr_types = 0, ix = 0; ix != GCOV_COUNTERS; ix++)
 796     if (prg_ctr_mask & (1 << ix))
 797       n_ctr_types++;
 798
 799   type = lang_hooks.types.make_type (RECORD_TYPE);
 800   const_type = build_qualified_type (type, TYPE_QUAL_CONST);
 801
 802   /* Version ident */
 803   field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 804   TREE_CHAIN (field) = fields;
 805   fields = field;
 806   value = tree_cons (field, build_int_cstu (TREE_TYPE (field), GCOV_VERSION),
 807                      value);
 808
 809   /* next -- NULL */
 810   field = build_decl (FIELD_DECL, NULL_TREE, build_pointer_type (const_type));
 811   TREE_CHAIN (field) = fields;
 812   fields = field;
 813   value = tree_cons (field, null_pointer_node, value);
 814
 815   /* stamp */
 816   field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 817   TREE_CHAIN (field) = fields;
 818   fields = field;
 819   value = tree_cons (field, build_int_cstu (TREE_TYPE (field), local_tick),
 820                      value);
 821
 822   /* Filename */
 823   string_type = build_pointer_type (build_qualified_type (char_type_node,
 824                                                     TYPE_QUAL_CONST));
 825   field = build_decl (FIELD_DECL, NULL_TREE, string_type);
 826   TREE_CHAIN (field) = fields;
 827   fields = field;
 828   filename = getpwd ();
 829   filename = (filename && da_file_name[0] != '/'
 830               ? concat (filename, "/", da_file_name, NULL)
 831               : da_file_name);
 832   filename_len = strlen (filename);
 833   filename_string = build_string (filename_len + 1, filename);
 834   if (filename != da_file_name)
 835     free (filename);
 836   TREE_TYPE (filename_string) = build_array_type
 837     (char_type_node, build_index_type
 838      (build_int_cst (NULL_TREE, filename_len)));
 839   value = tree_cons (field, build1 (ADDR_EXPR, string_type, filename_string),
 840                      value);
 841
 842   /* Build the fn_info type and initializer.  */
 843   fn_info_type = build_fn_info_type (n_ctr_types);
 844   fn_info_ptr_type = build_pointer_type (build_qualified_type
 845                                          (fn_info_type, TYPE_QUAL_CONST));
 846   for (fn = functions_head, n_fns = 0; fn; fn = fn->next, n_fns++)
 847     fn_info_value = tree_cons (NULL_TREE,
 848                                build_fn_info_value (fn, fn_info_type),
 849                                fn_info_value);
 850   if (n_fns)
 851     {
 852       tree array_type;
 853
 854       array_type = build_index_type (build_int_cst (NULL_TREE, n_fns - 1));
 855       array_type = build_array_type (fn_info_type, array_type);
 856
 857       fn_info_value = build_constructor (array_type, nreverse (fn_info_value));
 858       fn_info_value = build1 (ADDR_EXPR, fn_info_ptr_type, fn_info_value);
 859     }
 860   else
 861     fn_info_value = null_pointer_node;
 862
 863   /* number of functions */
 864   field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
 865   TREE_CHAIN (field) = fields;
 866   fields = field;
 867   value = tree_cons (field,
 868                      build_int_cstu (unsigned_type_node, n_fns),
 869                      value);
 870
 871   /* fn_info table */
 872   field = build_decl (FIELD_DECL, NULL_TREE, fn_info_ptr_type);
 873   TREE_CHAIN (field) = fields;
 874   fields = field;
 875   value = tree_cons (field, fn_info_value, value);
 876
 877   /* counter_mask */
 878   field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
 879   TREE_CHAIN (field) = fields;
 880   fields = field;
 881   value = tree_cons (field,
 882                      build_int_cstu (unsigned_type_node, prg_ctr_mask),
 883                      value);
 884
 885   /* counters */
 886   ctr_info_type = build_ctr_info_type ();
 887   ctr_info_ary_type = build_index_type (build_int_cst (NULL_TREE,
 888                                                        n_ctr_types));
 889   ctr_info_ary_type = build_array_type (ctr_info_type, ctr_info_ary_type);
 890   for (ix = 0; ix != GCOV_COUNTERS; ix++)
 891     if (prg_ctr_mask & (1 << ix))
 892       ctr_info_value = tree_cons (NULL_TREE,
 893                                   build_ctr_info_value (ix, ctr_info_type),
 894                                   ctr_info_value);
 895   ctr_info_value = build_constructor (ctr_info_ary_type,
 896                                       nreverse (ctr_info_value));
 897
 898   field = build_decl (FIELD_DECL, NULL_TREE, ctr_info_ary_type);
 899   TREE_CHAIN (field) = fields;
 900   fields = field;
 901   value = tree_cons (field, ctr_info_value, value);
 902
 903   finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE);
 904
 905   value = build_constructor (type, nreverse (value));
 906
 907   return value;
 908 }
 909
 910 /* Write out the structure which libgcov uses to locate all the
 911    counters.  The structures used here must match those defined in
 912    gcov-io.h.  Write out the constructor to call __gcov_init.  */
 913
 914 static void
 915 create_coverage (void)
 916 {
 917   tree gcov_info, gcov_init, body, t;
 918   char name_buf[32];
 919
 920   no_coverage = 1; /* Disable any further coverage.  */
 921
 922   if (!prg_ctr_mask)
 923     return;
 924
 925   t = build_gcov_info ();
 926
 927   gcov_info = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (t));
 928   TREE_STATIC (gcov_info) = 1;
 929   ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0);
 930   DECL_NAME (gcov_info) = get_identifier (name_buf);
 931   DECL_INITIAL (gcov_info) = t;
 932
 933   /* Build structure.  */
 934   assemble_variable (gcov_info, 0, 0, 0);
 935
 936   /* Build a decl for __gcov_init.  */
 937   t = build_pointer_type (TREE_TYPE (gcov_info));
 938   t = build_function_type_list (void_type_node, t, NULL);
 939   t = build_decl (FUNCTION_DECL, get_identifier ("__gcov_init"), t);
 940   TREE_PUBLIC (t) = 1;
 941   DECL_EXTERNAL (t) = 1;
 942   gcov_init = t;
 943
 944   /* Generate a call to __gcov_init(&gcov_info).  */
 945   body = NULL;
 946   t = build_fold_addr_expr (gcov_info);
 947   t = tree_cons (NULL, t, NULL);
 948   t = build_function_call_expr (gcov_init, t);
 949   append_to_statement_list (t, &body);
 950
 951   /* Generate a constructor to run it.  */
 952   cgraph_build_static_cdtor ('I', body, DEFAULT_INIT_PRIORITY);
 953 }
 954 \f
 955 /* Perform file-level initialization. Read in data file, generate name
 956    of graph file.  */
 957
 958 void
 959 coverage_init (const char *filename)
 960 {
 961   int len = strlen (filename);
 962
 963   /* Name of da file.  */
 964   da_file_name = xmalloc (len + strlen (GCOV_DATA_SUFFIX) + 1);
 965   strcpy (da_file_name, filename);
 966   strcat (da_file_name, GCOV_DATA_SUFFIX);
 967
 968   /* Name of bbg file.  */
 969   bbg_file_name = xmalloc (len + strlen (GCOV_NOTE_SUFFIX) + 1);
 970   strcpy (bbg_file_name, filename);
 971   strcat (bbg_file_name, GCOV_NOTE_SUFFIX);
 972
 973   read_counts_file ();
 974 }
 975
 976 /* Performs file-level cleanup.  Close graph file, generate coverage
 977    variables and constructor.  */
 978
 979 void
 980 coverage_finish (void)
 981 {
 982   create_coverage ();
 983   if (bbg_file_opened)
 984     {
 985       int error = gcov_close ();
 986
 987       if (error)
 988         unlink (bbg_file_name);
 989       if (!local_tick)
 990         /* Only remove the da file, if we cannot stamp it. If we can
 991            stamp it, libgcov will DTRT.  */
 992         unlink (da_file_name);
 993     }
 994 }
 995
 996 #include "gt-coverage.h"