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 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 gcov_type_node = get_gcov_type ();
 396       tree domain_tree
 397         = build_index_type (build_int_cst (NULL_TREE, 1000)); /* replaced later */
 398       tree gcov_type_array_type
 399         = build_array_type (gcov_type_node, domain_tree);
 400       tree_ctr_tables[counter]
 401         = build_decl (VAR_DECL, NULL_TREE, gcov_type_array_type);
 402       TREE_STATIC (tree_ctr_tables[counter]) = 1;
 403       ASM_GENERATE_INTERNAL_LABEL (buf, "LPBX", counter + 1);
 404       DECL_NAME (tree_ctr_tables[counter]) = get_identifier (buf);
 405       DECL_ALIGN (tree_ctr_tables[counter]) = TYPE_ALIGN (gcov_type_node);
 406     }
 407   fn_b_ctrs[counter] = fn_n_ctrs[counter];
 408   fn_n_ctrs[counter] += num;
 409   fn_ctr_mask |= 1 << counter;
 410   return 1;
 411 }
 412
 413 /* Generate a tree to access COUNTER NO.  */
 414
 415 tree
 416 tree_coverage_counter_ref (unsigned counter, unsigned no)
 417 {
 418   tree gcov_type_node = get_gcov_type ();
 419   tree domain_type = TYPE_DOMAIN (TREE_TYPE (tree_ctr_tables[counter]));
 420
 421   gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]);
 422   no += prg_n_ctrs[counter] + fn_b_ctrs[counter];
 423
 424   /* "no" here is an array index, scaled to bytes later.  */
 425   return build4 (ARRAY_REF, gcov_type_node, tree_ctr_tables[counter],
 426                  fold_convert (domain_type,
 427                                build_int_cst (NULL_TREE, no)),
 428                  TYPE_MIN_VALUE (domain_type),
 429                  size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (gcov_type_node),
 430                              size_int (TYPE_ALIGN_UNIT (gcov_type_node))));
 431 }
 432 \f
 433 /* Generate a checksum for a string.  CHKSUM is the current
 434    checksum.  */
 435
 436 static unsigned
 437 coverage_checksum_string (unsigned chksum, const char *string)
 438 {
 439   int i;
 440   char *dup = NULL;
 441
 442   /* Look for everything that looks if it were produced by
 443      get_file_function_name_long and zero out the second part
 444      that may result from flag_random_seed.  This is not critical
 445      as the checksums are used only for sanity checking.  */
 446   for (i = 0; string[i]; i++)
 447     {
 448       int offset = 0;
 449       if (!strncmp (string + i, "_GLOBAL__N_", 11))
 450       offset = 11;
 451       if (!strncmp (string + i, "_GLOBAL__", 9))
 452       offset = 9;
 453
 454       /* C++ namespaces do have scheme:
 455          _GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname
 456        since filename might contain extra underscores there seems
 457        to be no better chance then walk all possible offsets looking
 458        for magicnuber.  */
 459       if (offset)
 460         {
 461           for (i = i + offset; string[i]; i++)
 462             if (string[i]=='_')
 463               {
 464                 int y;
 465
 466                 for (y = 1; y < 9; y++)
 467                   if (!(string[i + y] >= '0' && string[i + y] <= '9')
 468                       && !(string[i + y] >= 'A' && string[i + y] <= 'F'))
 469                     break;
 470                 if (y != 9 || string[i + 9] != '_')
 471                   continue;
 472                 for (y = 10; y < 18; y++)
 473                   if (!(string[i + y] >= '0' && string[i + y] <= '9')
 474                       && !(string[i + y] >= 'A' && string[i + y] <= 'F'))
 475                     break;
 476                 if (y != 18)
 477                   continue;
 478                 if (!dup)
 479                   string = dup = xstrdup (string);
 480                 for (y = 10; y < 18; y++)
 481                   dup[i + y] = '0';
 482               }
 483           break;
 484         }
 485     }
 486
 487   chksum = crc32_string (chksum, string);
 488   if (dup)
 489     free (dup);
 490
 491   return chksum;
 492 }
 493
 494 /* Compute checksum for the current function.  We generate a CRC32.  */
 495
 496 static unsigned
 497 compute_checksum (void)
 498 {
 499   expanded_location xloc
 500     = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
 501   unsigned chksum = xloc.line;
 502
 503   chksum = coverage_checksum_string (chksum, xloc.file);
 504   chksum = coverage_checksum_string
 505     (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)));
 506
 507   return chksum;
 508 }
 509 \f
 510 /* Begin output to the graph file for the current function.
 511    Opens the output file, if not already done. Writes the
 512    function header, if not already done. Returns nonzero if data
 513    should be output.  */
 514
 515 int
 516 coverage_begin_output (void)
 517 {
 518   if (no_coverage)
 519     return 0;
 520
 521   if (!bbg_function_announced)
 522     {
 523       expanded_location xloc
 524         = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
 525       unsigned long offset;
 526
 527       if (!bbg_file_opened)
 528         {
 529           if (!gcov_open (bbg_file_name, -1))
 530             error ("cannot open %s", bbg_file_name);
 531           else
 532             {
 533               gcov_write_unsigned (GCOV_NOTE_MAGIC);
 534               gcov_write_unsigned (GCOV_VERSION);
 535               gcov_write_unsigned (local_tick);
 536             }
 537           bbg_file_opened = 1;
 538         }
 539
 540       /* Announce function */
 541       offset = gcov_write_tag (GCOV_TAG_FUNCTION);
 542       gcov_write_unsigned (current_function_funcdef_no + 1);
 543       gcov_write_unsigned (compute_checksum ());
 544       gcov_write_string (IDENTIFIER_POINTER
 545                          (DECL_ASSEMBLER_NAME (current_function_decl)));
 546       gcov_write_string (xloc.file);
 547       gcov_write_unsigned (xloc.line);
 548       gcov_write_length (offset);
 549
 550       bbg_function_announced = 1;
 551     }
 552   return !gcov_is_error ();
 553 }
 554
 555 /* Finish coverage data for the current function. Verify no output
 556    error has occurred.  Save function coverage counts.  */
 557
 558 void
 559 coverage_end_function (void)
 560 {
 561   unsigned i;
 562
 563   if (bbg_file_opened > 1 && gcov_is_error ())
 564     {
 565       warning (0, "error writing %qs", bbg_file_name);
 566       bbg_file_opened = -1;
 567     }
 568
 569   if (fn_ctr_mask)
 570     {
 571       struct function_list *item;
 572
 573       item = XNEW (struct function_list);
 574
 575       *functions_tail = item;
 576       functions_tail = &item->next;
 577
 578       item->next = 0;
 579       item->ident = current_function_funcdef_no + 1;
 580       item->checksum = compute_checksum ();
 581       for (i = 0; i != GCOV_COUNTERS; i++)
 582         {
 583           item->n_ctrs[i] = fn_n_ctrs[i];
 584           prg_n_ctrs[i] += fn_n_ctrs[i];
 585           fn_n_ctrs[i] = fn_b_ctrs[i] = 0;
 586         }
 587       prg_ctr_mask |= fn_ctr_mask;
 588       fn_ctr_mask = 0;
 589     }
 590   bbg_function_announced = 0;
 591 }
 592
 593 /* Creates the gcov_fn_info RECORD_TYPE.  */
 594
 595 static tree
 596 build_fn_info_type (unsigned int counters)
 597 {
 598   tree type = lang_hooks.types.make_type (RECORD_TYPE);
 599   tree field, fields;
 600   tree array_type;
 601
 602   /* ident */
 603   fields = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 604
 605   /* checksum */
 606   field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 607   TREE_CHAIN (field) = fields;
 608   fields = field;
 609
 610   array_type = build_int_cst (NULL_TREE, counters - 1);
 611   array_type = build_index_type (array_type);
 612   array_type = build_array_type (get_gcov_unsigned_t (), array_type);
 613
 614   /* counters */
 615   field = build_decl (FIELD_DECL, NULL_TREE, array_type);
 616   TREE_CHAIN (field) = fields;
 617   fields = field;
 618
 619   finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE);
 620
 621   return type;
 622 }
 623
 624 /* Creates a CONSTRUCTOR for a gcov_fn_info. FUNCTION is
 625    the function being processed and TYPE is the gcov_fn_info
 626    RECORD_TYPE.  */
 627
 628 static tree
 629 build_fn_info_value (const struct function_list *function, tree type)
 630 {
 631   tree value = NULL_TREE;
 632   tree fields = TYPE_FIELDS (type);
 633   unsigned ix;
 634   tree array_value = NULL_TREE;
 635
 636   /* ident */
 637   value = tree_cons (fields, build_int_cstu (get_gcov_unsigned_t (),
 638                                              function->ident), value);
 639   fields = TREE_CHAIN (fields);
 640
 641   /* checksum */
 642   value = tree_cons (fields, build_int_cstu (get_gcov_unsigned_t (),
 643                                              function->checksum), value);
 644   fields = TREE_CHAIN (fields);
 645
 646   /* counters */
 647   for (ix = 0; ix != GCOV_COUNTERS; ix++)
 648     if (prg_ctr_mask & (1 << ix))
 649       {
 650         tree counters = build_int_cstu (get_gcov_unsigned_t (),
 651                                         function->n_ctrs[ix]);
 652
 653         array_value = tree_cons (NULL_TREE, counters, array_value);
 654       }
 655
 656   /* FIXME: use build_constructor directly.  */
 657   array_value = build_constructor_from_list (TREE_TYPE (fields),
 658                                              nreverse (array_value));
 659   value = tree_cons (fields, array_value, value);
 660
 661   /* FIXME: use build_constructor directly.  */
 662   value = build_constructor_from_list (type, nreverse (value));
 663
 664   return value;
 665 }
 666
 667 /* Creates the gcov_ctr_info RECORD_TYPE.  */
 668
 669 static tree
 670 build_ctr_info_type (void)
 671 {
 672   tree type = lang_hooks.types.make_type (RECORD_TYPE);
 673   tree field, fields = NULL_TREE;
 674   tree gcov_ptr_type = build_pointer_type (get_gcov_type ());
 675   tree gcov_merge_fn_type;
 676
 677   /* counters */
 678   field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 679   TREE_CHAIN (field) = fields;
 680   fields = field;
 681
 682   /* values */
 683   field = build_decl (FIELD_DECL, NULL_TREE, gcov_ptr_type);
 684   TREE_CHAIN (field) = fields;
 685   fields = field;
 686
 687   /* merge */
 688   gcov_merge_fn_type =
 689     build_function_type_list (void_type_node,
 690                               gcov_ptr_type, get_gcov_unsigned_t (),
 691                               NULL_TREE);
 692   field = build_decl (FIELD_DECL, NULL_TREE,
 693                       build_pointer_type (gcov_merge_fn_type));
 694   TREE_CHAIN (field) = fields;
 695   fields = field;
 696
 697   finish_builtin_struct (type, "__gcov_ctr_info", fields, NULL_TREE);
 698
 699   return type;
 700 }
 701
 702 /* Creates a CONSTRUCTOR for a gcov_ctr_info. COUNTER is
 703    the counter being processed and TYPE is the gcov_ctr_info
 704    RECORD_TYPE.  */
 705
 706 static tree
 707 build_ctr_info_value (unsigned int counter, tree type)
 708 {
 709   tree value = NULL_TREE;
 710   tree fields = TYPE_FIELDS (type);
 711   tree fn;
 712
 713   /* counters */
 714   value = tree_cons (fields,
 715                      build_int_cstu (get_gcov_unsigned_t (),
 716                                      prg_n_ctrs[counter]),
 717                      value);
 718   fields = TREE_CHAIN (fields);
 719
 720   if (prg_n_ctrs[counter])
 721     {
 722       tree array_type;
 723
 724       array_type = build_int_cstu (get_gcov_unsigned_t (),
 725                                    prg_n_ctrs[counter] - 1);
 726       array_type = build_index_type (array_type);
 727       array_type = build_array_type (TREE_TYPE (TREE_TYPE (fields)),
 728                                      array_type);
 729
 730       TREE_TYPE (tree_ctr_tables[counter]) = array_type;
 731       DECL_SIZE (tree_ctr_tables[counter]) = TYPE_SIZE (array_type);
 732       DECL_SIZE_UNIT (tree_ctr_tables[counter]) = TYPE_SIZE_UNIT (array_type);
 733       assemble_variable (tree_ctr_tables[counter], 0, 0, 0);
 734
 735       value = tree_cons (fields,
 736                          build1 (ADDR_EXPR, TREE_TYPE (fields),
 737                                             tree_ctr_tables[counter]),
 738                          value);
 739     }
 740   else
 741     value = tree_cons (fields, null_pointer_node, value);
 742   fields = TREE_CHAIN (fields);
 743
 744   fn = build_decl (FUNCTION_DECL,
 745                    get_identifier (ctr_merge_functions[counter]),
 746                    TREE_TYPE (TREE_TYPE (fields)));
 747   DECL_EXTERNAL (fn) = 1;
 748   TREE_PUBLIC (fn) = 1;
 749   DECL_ARTIFICIAL (fn) = 1;
 750   TREE_NOTHROW (fn) = 1;
 751   value = tree_cons (fields,
 752                      build1 (ADDR_EXPR, TREE_TYPE (fields), fn),
 753                      value);
 754
 755   /* FIXME: use build_constructor directly.  */
 756   value = build_constructor_from_list (type, nreverse (value));
 757
 758   return value;
 759 }
 760
 761 /* Creates the gcov_info RECORD_TYPE and initializer for it. Returns a
 762    CONSTRUCTOR.  */
 763
 764 static tree
 765 build_gcov_info (void)
 766 {
 767   unsigned n_ctr_types, ix;
 768   tree type, const_type;
 769   tree fn_info_type, fn_info_value = NULL_TREE;
 770   tree fn_info_ptr_type;
 771   tree ctr_info_type, ctr_info_ary_type, ctr_info_value = NULL_TREE;
 772   tree field, fields = NULL_TREE;
 773   tree value = NULL_TREE;
 774   tree filename_string;
 775   char *filename;
 776   int filename_len;
 777   unsigned n_fns;
 778   const struct function_list *fn;
 779   tree string_type;
 780
 781   /* Count the number of active counters.  */
 782   for (n_ctr_types = 0, ix = 0; ix != GCOV_COUNTERS; ix++)
 783     if (prg_ctr_mask & (1 << ix))
 784       n_ctr_types++;
 785
 786   type = lang_hooks.types.make_type (RECORD_TYPE);
 787   const_type = build_qualified_type (type, TYPE_QUAL_CONST);
 788
 789   /* Version ident */
 790   field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 791   TREE_CHAIN (field) = fields;
 792   fields = field;
 793   value = tree_cons (field, build_int_cstu (TREE_TYPE (field), GCOV_VERSION),
 794                      value);
 795
 796   /* next -- NULL */
 797   field = build_decl (FIELD_DECL, NULL_TREE, build_pointer_type (const_type));
 798   TREE_CHAIN (field) = fields;
 799   fields = field;
 800   value = tree_cons (field, null_pointer_node, value);
 801
 802   /* stamp */
 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), local_tick),
 807                      value);
 808
 809   /* Filename */
 810   string_type = build_pointer_type (build_qualified_type (char_type_node,
 811                                                     TYPE_QUAL_CONST));
 812   field = build_decl (FIELD_DECL, NULL_TREE, string_type);
 813   TREE_CHAIN (field) = fields;
 814   fields = field;
 815   filename = getpwd ();
 816   filename = (filename && da_file_name[0] != '/'
 817               ? concat (filename, "/", da_file_name, NULL)
 818               : da_file_name);
 819   filename_len = strlen (filename);
 820   filename_string = build_string (filename_len + 1, filename);
 821   if (filename != da_file_name)
 822     free (filename);
 823   TREE_TYPE (filename_string) = build_array_type
 824     (char_type_node, build_index_type
 825      (build_int_cst (NULL_TREE, filename_len)));
 826   value = tree_cons (field, build1 (ADDR_EXPR, string_type, filename_string),
 827                      value);
 828
 829   /* Build the fn_info type and initializer.  */
 830   fn_info_type = build_fn_info_type (n_ctr_types);
 831   fn_info_ptr_type = build_pointer_type (build_qualified_type
 832                                          (fn_info_type, TYPE_QUAL_CONST));
 833   for (fn = functions_head, n_fns = 0; fn; fn = fn->next, n_fns++)
 834     fn_info_value = tree_cons (NULL_TREE,
 835                                build_fn_info_value (fn, fn_info_type),
 836                                fn_info_value);
 837   if (n_fns)
 838     {
 839       tree array_type;
 840
 841       array_type = build_index_type (build_int_cst (NULL_TREE, n_fns - 1));
 842       array_type = build_array_type (fn_info_type, array_type);
 843
 844       /* FIXME: use build_constructor directly.  */
 845       fn_info_value = build_constructor_from_list (array_type,
 846                                                    nreverse (fn_info_value));
 847       fn_info_value = build1 (ADDR_EXPR, fn_info_ptr_type, fn_info_value);
 848     }
 849   else
 850     fn_info_value = null_pointer_node;
 851
 852   /* number of functions */
 853   field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 854   TREE_CHAIN (field) = fields;
 855   fields = field;
 856   value = tree_cons (field,
 857                      build_int_cstu (get_gcov_unsigned_t (), n_fns),
 858                      value);
 859
 860   /* fn_info table */
 861   field = build_decl (FIELD_DECL, NULL_TREE, fn_info_ptr_type);
 862   TREE_CHAIN (field) = fields;
 863   fields = field;
 864   value = tree_cons (field, fn_info_value, value);
 865
 866   /* counter_mask */
 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 (), prg_ctr_mask),
 872                      value);
 873
 874   /* counters */
 875   ctr_info_type = build_ctr_info_type ();
 876   ctr_info_ary_type = build_index_type (build_int_cst (NULL_TREE,
 877                                                        n_ctr_types));
 878   ctr_info_ary_type = build_array_type (ctr_info_type, ctr_info_ary_type);
 879   for (ix = 0; ix != GCOV_COUNTERS; ix++)
 880     if (prg_ctr_mask & (1 << ix))
 881       ctr_info_value = tree_cons (NULL_TREE,
 882                                   build_ctr_info_value (ix, ctr_info_type),
 883                                   ctr_info_value);
 884   /* FIXME: use build_constructor directly.  */
 885   ctr_info_value = build_constructor_from_list (ctr_info_ary_type,
 886                                                 nreverse (ctr_info_value));
 887
 888   field = build_decl (FIELD_DECL, NULL_TREE, ctr_info_ary_type);
 889   TREE_CHAIN (field) = fields;
 890   fields = field;
 891   value = tree_cons (field, ctr_info_value, value);
 892
 893   finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE);
 894
 895   /* FIXME: use build_constructor directly.  */
 896   value = build_constructor_from_list (type, nreverse (value));
 897
 898   return value;
 899 }
 900
 901 /* Write out the structure which libgcov uses to locate all the
 902    counters.  The structures used here must match those defined in
 903    gcov-io.h.  Write out the constructor to call __gcov_init.  */
 904
 905 static void
 906 create_coverage (void)
 907 {
 908   tree gcov_info, gcov_init, body, t;
 909   char name_buf[32];
 910
 911   no_coverage = 1; /* Disable any further coverage.  */
 912
 913   if (!prg_ctr_mask)
 914     return;
 915
 916   t = build_gcov_info ();
 917
 918   gcov_info = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (t));
 919   TREE_STATIC (gcov_info) = 1;
 920   ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0);
 921   DECL_NAME (gcov_info) = get_identifier (name_buf);
 922   DECL_INITIAL (gcov_info) = t;
 923
 924   /* Build structure.  */
 925   assemble_variable (gcov_info, 0, 0, 0);
 926
 927   /* Build a decl for __gcov_init.  */
 928   t = build_pointer_type (TREE_TYPE (gcov_info));
 929   t = build_function_type_list (void_type_node, t, NULL);
 930   t = build_decl (FUNCTION_DECL, get_identifier ("__gcov_init"), t);
 931   TREE_PUBLIC (t) = 1;
 932   DECL_EXTERNAL (t) = 1;
 933   gcov_init = t;
 934
 935   /* Generate a call to __gcov_init(&gcov_info).  */
 936   body = NULL;
 937   t = build_fold_addr_expr (gcov_info);
 938   t = tree_cons (NULL, t, NULL);
 939   t = build_function_call_expr (gcov_init, t);
 940   append_to_statement_list (t, &body);
 941
 942   /* Generate a constructor to run it.  */
 943   cgraph_build_static_cdtor ('I', body, DEFAULT_INIT_PRIORITY);
 944 }
 945 \f
 946 /* Perform file-level initialization. Read in data file, generate name
 947    of graph file.  */
 948
 949 void
 950 coverage_init (const char *filename)
 951 {
 952   int len = strlen (filename);
 953
 954   /* Name of da file.  */
 955   da_file_name = XNEWVEC (char, len + strlen (GCOV_DATA_SUFFIX) + 1);
 956   strcpy (da_file_name, filename);
 957   strcat (da_file_name, GCOV_DATA_SUFFIX);
 958
 959   /* Name of bbg file.  */
 960   bbg_file_name = XNEWVEC (char, len + strlen (GCOV_NOTE_SUFFIX) + 1);
 961   strcpy (bbg_file_name, filename);
 962   strcat (bbg_file_name, GCOV_NOTE_SUFFIX);
 963
 964   read_counts_file ();
 965 }
 966
 967 /* Performs file-level cleanup.  Close graph file, generate coverage
 968    variables and constructor.  */
 969
 970 void
 971 coverage_finish (void)
 972 {
 973   create_coverage ();
 974   if (bbg_file_opened)
 975     {
 976       int error = gcov_close ();
 977
 978       if (error)
 979         unlink (bbg_file_name);
 980       if (!local_tick)
 981         /* Only remove the da file, if we cannot stamp it. If we can
 982            stamp it, libgcov will DTRT.  */
 983         unlink (da_file_name);
 984     }
 985 }
 986
 987 #include "gt-coverage.h"