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
 124 \f
 125 static hashval_t
 126 htab_counts_entry_hash (const void *of)
 127 {
 128   const counts_entry_t *entry = of;
 129
 130   return entry->ident * GCOV_COUNTERS + entry->ctr;
 131 }
 132
 133 static int
 134 htab_counts_entry_eq (const void *of1, const void *of2)
 135 {
 136   const counts_entry_t *entry1 = of1;
 137   const counts_entry_t *entry2 = of2;
 138
 139   return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
 140 }
 141
 142 static void
 143 htab_counts_entry_del (void *of)
 144 {
 145   counts_entry_t *entry = of;
 146
 147   free (entry->counts);
 148   free (entry);
 149 }
 150
 151 /* Read in the counts file, if available.  */
 152
 153 static void
 154 read_counts_file (void)
 155 {
 156   gcov_unsigned_t fn_ident = 0;
 157   gcov_unsigned_t checksum = -1;
 158   counts_entry_t *summaried = NULL;
 159   unsigned seen_summary = 0;
 160   gcov_unsigned_t tag;
 161   int is_error = 0;
 162
 163   if (!gcov_open (da_file_name, 1))
 164     return;
 165
 166   if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC))
 167     {
 168       warning ("`%s' is not a gcov data file", da_file_name);
 169       gcov_close ();
 170       return;
 171     }
 172   else if ((tag = gcov_read_unsigned ()) != GCOV_VERSION)
 173     {
 174       char v[4], e[4];
 175
 176       GCOV_UNSIGNED2STRING (v, tag);
 177       GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
 178
 179       warning ("`%s' is version `%.*s', expected version `%.*s'",
 180                da_file_name, 4, v, 4, e);
 181       gcov_close ();
 182       return;
 183     }
 184
 185   /* Read and discard the stamp.  */
 186   gcov_read_unsigned ();
 187
 188   counts_hash = htab_create (10,
 189                              htab_counts_entry_hash, htab_counts_entry_eq,
 190                              htab_counts_entry_del);
 191   while ((tag = gcov_read_unsigned ()))
 192     {
 193       gcov_unsigned_t length;
 194       gcov_position_t offset;
 195
 196       length = gcov_read_unsigned ();
 197       offset = gcov_position ();
 198       if (tag == GCOV_TAG_FUNCTION)
 199         {
 200           fn_ident = gcov_read_unsigned ();
 201           checksum = gcov_read_unsigned ();
 202           if (seen_summary)
 203             {
 204               /* We have already seen a summary, this means that this
 205                  new function begins a new set of program runs. We
 206                  must unlink the summaried chain.  */
 207               counts_entry_t *entry, *chain;
 208
 209               for (entry = summaried; entry; entry = chain)
 210                 {
 211                   chain = entry->chain;
 212                   entry->chain = NULL;
 213                 }
 214               summaried = NULL;
 215               seen_summary = 0;
 216             }
 217         }
 218       else if (tag == GCOV_TAG_PROGRAM_SUMMARY)
 219         {
 220           counts_entry_t *entry;
 221           struct gcov_summary summary;
 222
 223           gcov_read_summary (&summary);
 224           seen_summary = 1;
 225           for (entry = summaried; entry; entry = entry->chain)
 226             {
 227               struct gcov_ctr_summary *csum = &summary.ctrs[entry->ctr];
 228
 229               entry->summary.runs += csum->runs;
 230               entry->summary.sum_all += csum->sum_all;
 231               if (entry->summary.run_max < csum->run_max)
 232                 entry->summary.run_max = csum->run_max;
 233               entry->summary.sum_max += csum->sum_max;
 234             }
 235         }
 236       else if (GCOV_TAG_IS_COUNTER (tag) && fn_ident)
 237         {
 238           counts_entry_t **slot, *entry, elt;
 239           unsigned n_counts = GCOV_TAG_COUNTER_NUM (length);
 240           unsigned ix;
 241
 242           elt.ident = fn_ident;
 243           elt.ctr = GCOV_COUNTER_FOR_TAG (tag);
 244
 245           slot = (counts_entry_t **) htab_find_slot
 246             (counts_hash, &elt, INSERT);
 247           entry = *slot;
 248           if (!entry)
 249             {
 250               *slot = entry = xcalloc (1, sizeof (counts_entry_t));
 251               entry->ident = elt.ident;
 252               entry->ctr = elt.ctr;
 253               entry->checksum = checksum;
 254               entry->summary.num = n_counts;
 255               entry->counts = xcalloc (n_counts, sizeof (gcov_type));
 256             }
 257           else if (entry->checksum != checksum)
 258             {
 259               error ("coverage mismatch for function %u while reading execution counters.",
 260                      fn_ident);
 261               error ("checksum is %x instead of %x", entry->checksum, checksum);
 262               htab_delete (counts_hash);
 263               break;
 264             }
 265           else if (entry->summary.num != n_counts)
 266             {
 267               error ("coverage mismatch for function %u while reading execution counters.",
 268                      fn_ident);
 269               error ("number of counters is %d instead of %d", entry->summary.num, n_counts);
 270               htab_delete (counts_hash);
 271               break;
 272             }
 273           else if (elt.ctr >= GCOV_COUNTERS_SUMMABLE)
 274             {
 275               error ("cannot merge separate %s counters for function %u",
 276                      ctr_names[elt.ctr], fn_ident);
 277               goto skip_merge;
 278             }
 279
 280           if (elt.ctr < GCOV_COUNTERS_SUMMABLE
 281               /* This should always be true for a just allocated entry,
 282                  and always false for an existing one. Check this way, in
 283                  case the gcov file is corrupt.  */
 284               && (!entry->chain || summaried != entry))
 285             {
 286               entry->chain = summaried;
 287               summaried = entry;
 288             }
 289           for (ix = 0; ix != n_counts; ix++)
 290             entry->counts[ix] += gcov_read_counter ();
 291         skip_merge:;
 292         }
 293       gcov_sync (offset, length);
 294       if ((is_error = gcov_is_error ()))
 295         break;
 296     }
 297
 298   if (!gcov_is_eof ())
 299     {
 300       error (is_error < 0 ? "`%s' has overflowed" : "`%s' is corrupted",
 301              da_file_name);
 302       htab_delete (counts_hash);
 303     }
 304
 305   gcov_close ();
 306 }
 307
 308 /* Returns the counters for a particular tag.  */
 309
 310 gcov_type *
 311 get_coverage_counts (unsigned counter, unsigned expected,
 312                      const struct gcov_ctr_summary **summary)
 313 {
 314   counts_entry_t *entry, elt;
 315   gcov_unsigned_t checksum = -1;
 316
 317   /* No hash table, no counts.  */
 318   if (!counts_hash)
 319     {
 320       static int warned = 0;
 321
 322       if (!warned++)
 323         inform ((flag_guess_branch_prob
 324                  ? "file %s not found, execution counts estimated"
 325                  : "file %s not found, execution counts assumed to be zero"),
 326                 da_file_name);
 327       return NULL;
 328     }
 329
 330   elt.ident = current_function_funcdef_no + 1;
 331   elt.ctr = counter;
 332   entry = htab_find (counts_hash, &elt);
 333   if (!entry)
 334     {
 335       warning ("no coverage for function '%s' found.", IDENTIFIER_POINTER
 336                (DECL_ASSEMBLER_NAME (current_function_decl)));
 337       return 0;
 338     }
 339
 340   checksum = compute_checksum ();
 341   if (entry->checksum != checksum)
 342     {
 343       error ("coverage mismatch for function '%s' while reading counter '%s'.",
 344              IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)),
 345              ctr_names[counter]);
 346       error ("checksum is %x instead of %x", entry->checksum, checksum);
 347       return 0;
 348     }
 349   else if (entry->summary.num != expected)
 350     {
 351       error ("coverage mismatch for function '%s' while reading counter '%s'.",
 352              IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)),
 353              ctr_names[counter]);
 354       error ("number of counters is %d instead of %d", entry->summary.num, expected);
 355       return 0;
 356     }
 357
 358   if (summary)
 359     *summary = &entry->summary;
 360
 361   return entry->counts;
 362 }
 363
 364 /* Allocate NUM counters of type COUNTER. Returns nonzero if the
 365    allocation succeeded.  */
 366
 367 int
 368 coverage_counter_alloc (unsigned counter, unsigned num)
 369 {
 370   if (no_coverage)
 371     return 0;
 372
 373   if (!num)
 374     return 1;
 375
 376   if (!tree_ctr_tables[counter])
 377     {
 378       /* Generate and save a copy of this so it can be shared.  */
 379       /* We don't know the size yet; make it big enough that nobody
 380          will make any clever transformation on it.  */
 381       char buf[20];
 382       tree domain_tree
 383         = build_index_type (build_int_2 (1000, 0)); /* replaced later */
 384       tree gcov_type_array_type
 385         = build_array_type (GCOV_TYPE_NODE, domain_tree);
 386       tree_ctr_tables[counter]
 387         = build_decl (VAR_DECL, NULL_TREE, gcov_type_array_type);
 388       TREE_STATIC (tree_ctr_tables[counter]) = 1;
 389       ASM_GENERATE_INTERNAL_LABEL (buf, "LPBX", counter + 1);
 390       DECL_NAME (tree_ctr_tables[counter]) = get_identifier (buf);
 391       DECL_ALIGN (tree_ctr_tables[counter]) = TYPE_ALIGN (GCOV_TYPE_NODE);
 392     }
 393   fn_b_ctrs[counter] = fn_n_ctrs[counter];
 394   fn_n_ctrs[counter] += num;
 395   fn_ctr_mask |= 1 << counter;
 396   return 1;
 397 }
 398
 399 /* Generate a MEM rtl to access COUNTER NO.  */
 400
 401 rtx
 402 rtl_coverage_counter_ref (unsigned counter, unsigned no)
 403 {
 404   unsigned gcov_size = tree_low_cst (TYPE_SIZE (GCOV_TYPE_NODE), 1);
 405   enum machine_mode mode = mode_for_size (gcov_size, MODE_INT, 0);
 406   rtx ref;
 407
 408   if (no >= fn_n_ctrs[counter] - fn_b_ctrs[counter])
 409     abort ();
 410   no += prg_n_ctrs[counter] + fn_b_ctrs[counter];
 411   if (!ctr_labels[counter])
 412       {
 413         ctr_labels[counter] = gen_rtx_SYMBOL_REF (Pmode,
 414                                ggc_strdup (IDENTIFIER_POINTER (DECL_NAME
 415                                (tree_ctr_tables[counter]))));
 416         SYMBOL_REF_FLAGS (ctr_labels[counter]) = SYMBOL_FLAG_LOCAL;
 417       }
 418   ref = plus_constant (ctr_labels[counter], gcov_size / BITS_PER_UNIT * no);
 419   ref = gen_rtx_MEM (mode, ref);
 420   set_mem_alias_set (ref, new_alias_set ());
 421   MEM_NOTRAP_P (ref) = 1;
 422
 423   return ref;
 424 }
 425
 426 /* Generate a tree to access COUNTER NO.  */
 427
 428 tree
 429 tree_coverage_counter_ref (unsigned counter, unsigned no)
 430 {
 431   tree domain_type = TYPE_DOMAIN (TREE_TYPE (tree_ctr_tables[counter]));
 432
 433   if (no >= fn_n_ctrs[counter] - fn_b_ctrs[counter])
 434     abort ();
 435   no += prg_n_ctrs[counter] + fn_b_ctrs[counter];
 436
 437   /* "no" here is an array index, scaled to bytes later.  */
 438   return build (ARRAY_REF, GCOV_TYPE_NODE, tree_ctr_tables[counter],
 439                 fold_convert (domain_type, build_int_2 (no, 0)),
 440                 TYPE_MIN_VALUE (domain_type),
 441                 size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (GCOV_TYPE_NODE),
 442                             size_int (TYPE_ALIGN (GCOV_TYPE_NODE))));
 443 }
 444 \f
 445 /* Generate a checksum for a string.  CHKSUM is the current
 446    checksum.  */
 447
 448 static unsigned
 449 coverage_checksum_string (unsigned chksum, const char *string)
 450 {
 451   int i;
 452   char *dup = NULL;
 453
 454   /* Look for everything that looks if it were produced by
 455      get_file_function_name_long and zero out the second part
 456      that may result from flag_random_seed.  This is not critical
 457      as the checksums are used only for sanity checking.  */
 458   for (i = 0; string[i]; i++)
 459     {
 460       if (!strncmp (string + i, "_GLOBAL__", 9))
 461         for (i = i + 9; string[i]; i++)
 462           if (string[i]=='_')
 463             {
 464               int y;
 465               unsigned seed;
 466
 467               for (y = 1; y < 9; y++)
 468                 if (!(string[i + y] >= '0' && string[i + y] <= '9')
 469                     && !(string[i + y] >= 'A' && string[i + y] <= 'F'))
 470                   break;
 471               if (y != 9 || string[i + 9] != '_')
 472                 continue;
 473               for (y = 10; y < 18; y++)
 474                 if (!(string[i + y] >= '0' && string[i + y] <= '9')
 475                     && !(string[i + y] >= 'A' && string[i + y] <= 'F'))
 476                   break;
 477               if (y != 18)
 478                 continue;
 479               if (!sscanf (string + i + 10, "%X", &seed))
 480                 abort ();
 481               if (seed != crc32_string (0, flag_random_seed))
 482                 continue;
 483               string = dup = xstrdup (string);
 484               for (y = 10; y < 18; y++)
 485                 dup[i + y] = '0';
 486               break;
 487             }
 488       break;
 489     }
 490
 491   chksum = crc32_string (chksum, string);
 492   if (dup)
 493     free (dup);
 494
 495   return chksum;
 496 }
 497
 498 /* Compute checksum for the current function.  We generate a CRC32.  */
 499
 500 static unsigned
 501 compute_checksum (void)
 502 {
 503   expanded_location xloc
 504     = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
 505   unsigned chksum = xloc.line;
 506
 507   chksum = coverage_checksum_string (chksum, xloc.file);
 508   chksum = coverage_checksum_string
 509     (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)));
 510
 511   return chksum;
 512 }
 513 \f
 514 /* Begin output to the graph file for the current function.
 515    Opens the output file, if not already done. Writes the
 516    function header, if not already done. Returns nonzero if data
 517    should be output.  */
 518
 519 int
 520 coverage_begin_output (void)
 521 {
 522   if (no_coverage)
 523     return 0;
 524
 525   if (!bbg_function_announced)
 526     {
 527       expanded_location xloc
 528         = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
 529       unsigned long offset;
 530
 531       if (!bbg_file_opened)
 532         {
 533           if (!gcov_open (bbg_file_name, -1))
 534             error ("cannot open %s", bbg_file_name);
 535           else
 536             {
 537               gcov_write_unsigned (GCOV_NOTE_MAGIC);
 538               gcov_write_unsigned (GCOV_VERSION);
 539               gcov_write_unsigned (local_tick);
 540             }
 541           bbg_file_opened = 1;
 542         }
 543
 544       /* Announce function */
 545       offset = gcov_write_tag (GCOV_TAG_FUNCTION);
 546       gcov_write_unsigned (current_function_funcdef_no + 1);
 547       gcov_write_unsigned (compute_checksum ());
 548       gcov_write_string (IDENTIFIER_POINTER
 549                          (DECL_ASSEMBLER_NAME (current_function_decl)));
 550       gcov_write_string (xloc.file);
 551       gcov_write_unsigned (xloc.line);
 552       gcov_write_length (offset);
 553
 554       bbg_function_announced = 1;
 555     }
 556   return !gcov_is_error ();
 557 }
 558
 559 /* Finish coverage data for the current function. Verify no output
 560    error has occurred.  Save function coverage counts.  */
 561
 562 void
 563 coverage_end_function (void)
 564 {
 565   unsigned i;
 566
 567   if (bbg_file_opened > 1 && gcov_is_error ())
 568     {
 569       warning ("error writing `%s'", bbg_file_name);
 570       bbg_file_opened = -1;
 571     }
 572
 573   if (fn_ctr_mask)
 574     {
 575       struct function_list *item;
 576
 577       item = xmalloc (sizeof (struct function_list));
 578
 579       *functions_tail = item;
 580       functions_tail = &item->next;
 581
 582       item->next = 0;
 583       item->ident = current_function_funcdef_no + 1;
 584       item->checksum = compute_checksum ();
 585       for (i = 0; i != GCOV_COUNTERS; i++)
 586         {
 587           item->n_ctrs[i] = fn_n_ctrs[i];
 588           prg_n_ctrs[i] += fn_n_ctrs[i];
 589           fn_n_ctrs[i] = fn_b_ctrs[i] = 0;
 590         }
 591       prg_ctr_mask |= fn_ctr_mask;
 592       fn_ctr_mask = 0;
 593     }
 594   bbg_function_announced = 0;
 595 }
 596
 597 /* Creates the gcov_fn_info RECORD_TYPE.  */
 598
 599 static tree
 600 build_fn_info_type (unsigned int counters)
 601 {
 602   tree type = lang_hooks.types.make_type (RECORD_TYPE);
 603   tree field, fields;
 604   tree array_type;
 605
 606   /* ident */
 607   fields = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
 608
 609   /* checksum */
 610   field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
 611   TREE_CHAIN (field) = fields;
 612   fields = field;
 613
 614   array_type = build_index_type (build_int_2 (counters - 1, 0));
 615   array_type = build_array_type (unsigned_type_node, array_type);
 616
 617   /* counters */
 618   field = build_decl (FIELD_DECL, NULL_TREE, array_type);
 619   TREE_CHAIN (field) = fields;
 620   fields = field;
 621
 622   finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE);
 623
 624   return type;
 625 }
 626
 627 /* Creates a CONSTRUCTOR for a gcov_fn_info. FUNCTION is
 628    the function being processed and TYPE is the gcov_fn_info
 629    RECORD_TYPE.  */
 630
 631 static tree
 632 build_fn_info_value (const struct function_list *function, tree type)
 633 {
 634   tree value = NULL_TREE;
 635   tree fields = TYPE_FIELDS (type);
 636   unsigned ix;
 637   tree array_value = NULL_TREE;
 638
 639   /* ident */
 640   value = tree_cons (fields,
 641                      convert (unsigned_intSI_type_node,
 642                               build_int_2 (function->ident, 0)),
 643                      value);
 644   fields = TREE_CHAIN (fields);
 645
 646   /* checksum */
 647   value = tree_cons (fields,
 648                      convert (unsigned_intSI_type_node,
 649                               build_int_2 (function->checksum, 0)),
 650                      value);
 651   fields = TREE_CHAIN (fields);
 652
 653   /* counters */
 654   for (ix = 0; ix != GCOV_COUNTERS; ix++)
 655     if (prg_ctr_mask & (1 << ix))
 656       {
 657         tree counters = convert (unsigned_type_node,
 658                                  build_int_2 (function->n_ctrs[ix], 0));
 659
 660         array_value = tree_cons (NULL_TREE, counters, array_value);
 661       }
 662
 663   array_value = build_constructor (TREE_TYPE (fields), nreverse (array_value));
 664   value = tree_cons (fields, array_value, value);
 665
 666   value = build_constructor (type, nreverse (value));
 667
 668   return value;
 669 }
 670
 671 /* Creates the gcov_ctr_info RECORD_TYPE.  */
 672
 673 static tree
 674 build_ctr_info_type (void)
 675 {
 676   tree type = lang_hooks.types.make_type (RECORD_TYPE);
 677   tree field, fields = NULL_TREE;
 678   tree gcov_ptr_type = build_pointer_type (GCOV_TYPE_NODE);
 679   tree gcov_merge_fn_type;
 680
 681   /* counters */
 682   field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
 683   TREE_CHAIN (field) = fields;
 684   fields = field;
 685
 686   /* values */
 687   field = build_decl (FIELD_DECL, NULL_TREE, gcov_ptr_type);
 688   TREE_CHAIN (field) = fields;
 689   fields = field;
 690
 691   /* merge */
 692   gcov_merge_fn_type =
 693     build_function_type_list (void_type_node,
 694                               gcov_ptr_type, unsigned_type_node,
 695                               NULL_TREE);
 696   field = build_decl (FIELD_DECL, NULL_TREE,
 697                       build_pointer_type (gcov_merge_fn_type));
 698   TREE_CHAIN (field) = fields;
 699   fields = field;
 700
 701   finish_builtin_struct (type, "__gcov_ctr_info", fields, NULL_TREE);
 702
 703   return type;
 704 }
 705
 706 /* Creates a CONSTRUCTOR for a gcov_ctr_info. COUNTER is
 707    the counter being processed and TYPE is the gcov_ctr_info
 708    RECORD_TYPE.  */
 709
 710 static tree
 711 build_ctr_info_value (unsigned int counter, tree type)
 712 {
 713   tree value = NULL_TREE;
 714   tree fields = TYPE_FIELDS (type);
 715   tree fn;
 716
 717   /* counters */
 718   value = tree_cons (fields,
 719                      convert (unsigned_intSI_type_node,
 720                               build_int_2 (prg_n_ctrs[counter], 0)),
 721                      value);
 722   fields = TREE_CHAIN (fields);
 723
 724   if (prg_n_ctrs[counter])
 725     {
 726       tree array_type;
 727
 728       array_type = build_index_type (build_int_2 (prg_n_ctrs[counter] - 1, 0));
 729       array_type = build_array_type (TREE_TYPE (TREE_TYPE (fields)),
 730                                      array_type);
 731
 732       TREE_TYPE (tree_ctr_tables[counter]) = array_type;
 733       DECL_SIZE (tree_ctr_tables[counter]) = TYPE_SIZE (array_type);
 734       DECL_SIZE_UNIT (tree_ctr_tables[counter]) = TYPE_SIZE_UNIT (array_type);
 735       assemble_variable (tree_ctr_tables[counter], 0, 0, 0);
 736
 737       value = tree_cons (fields,
 738                          build1 (ADDR_EXPR, TREE_TYPE (fields),
 739                                             tree_ctr_tables[counter]),
 740                          value);
 741     }
 742   else
 743     value = tree_cons (fields, null_pointer_node, value);
 744   fields = TREE_CHAIN (fields);
 745
 746   fn = build_decl (FUNCTION_DECL,
 747                    get_identifier (ctr_merge_functions[counter]),
 748                    TREE_TYPE (TREE_TYPE (fields)));
 749   DECL_EXTERNAL (fn) = 1;
 750   TREE_PUBLIC (fn) = 1;
 751   DECL_ARTIFICIAL (fn) = 1;
 752   TREE_NOTHROW (fn) = 1;
 753   value = tree_cons (fields,
 754                      build1 (ADDR_EXPR, TREE_TYPE (fields), fn),
 755                      value);
 756
 757   value = build_constructor (type, nreverse (value));
 758
 759   return value;
 760 }
 761
 762 /* Creates the gcov_info RECORD_TYPE and initializer for it. Returns a
 763    CONSTRUCTOR.  */
 764
 765 static tree
 766 build_gcov_info (void)
 767 {
 768   unsigned n_ctr_types, ix;
 769   tree type, const_type;
 770   tree fn_info_type, fn_info_value = NULL_TREE;
 771   tree fn_info_ptr_type;
 772   tree ctr_info_type, ctr_info_ary_type, ctr_info_value = NULL_TREE;
 773   tree field, fields = NULL_TREE;
 774   tree value = NULL_TREE;
 775   tree filename_string;
 776   char *filename;
 777   int filename_len;
 778   unsigned n_fns;
 779   const struct function_list *fn;
 780   tree string_type;
 781
 782   /* Count the number of active counters.  */
 783   for (n_ctr_types = 0, ix = 0; ix != GCOV_COUNTERS; ix++)
 784     if (prg_ctr_mask & (1 << ix))
 785       n_ctr_types++;
 786
 787   type = lang_hooks.types.make_type (RECORD_TYPE);
 788   const_type = build_qualified_type (type, TYPE_QUAL_CONST);
 789
 790   /* Version ident */
 791   field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
 792   TREE_CHAIN (field) = fields;
 793   fields = field;
 794   value = tree_cons (field, convert (unsigned_intSI_type_node,
 795                                      build_int_2 (GCOV_VERSION, 0)),
 796                      value);
 797
 798   /* next -- NULL */
 799   field = build_decl (FIELD_DECL, NULL_TREE, build_pointer_type (const_type));
 800   TREE_CHAIN (field) = fields;
 801   fields = field;
 802   value = tree_cons (field, null_pointer_node, value);
 803
 804   /* stamp */
 805   field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
 806   TREE_CHAIN (field) = fields;
 807   fields = field;
 808   value = tree_cons (field, convert (unsigned_intSI_type_node,
 809                                      build_int_2 (local_tick, 0)),
 810                      value);
 811
 812   /* Filename */
 813   string_type = build_pointer_type (build_qualified_type (char_type_node,
 814                                                     TYPE_QUAL_CONST));
 815   field = build_decl (FIELD_DECL, NULL_TREE, string_type);
 816   TREE_CHAIN (field) = fields;
 817   fields = field;
 818   filename = getpwd ();
 819   filename = (filename && da_file_name[0] != '/'
 820               ? concat (filename, "/", da_file_name, NULL)
 821               : da_file_name);
 822   filename_len = strlen (filename);
 823   filename_string = build_string (filename_len + 1, filename);
 824   if (filename != da_file_name)
 825     free (filename);
 826   TREE_TYPE (filename_string) =
 827           build_array_type (char_type_node,
 828                             build_index_type (build_int_2 (filename_len, 0)));
 829   value = tree_cons (field, build1 (ADDR_EXPR, string_type, filename_string),
 830                      value);
 831
 832   /* Build the fn_info type and initializer.  */
 833   fn_info_type = build_fn_info_type (n_ctr_types);
 834   fn_info_ptr_type = build_pointer_type (build_qualified_type
 835                                          (fn_info_type, TYPE_QUAL_CONST));
 836   for (fn = functions_head, n_fns = 0; fn; fn = fn->next, n_fns++)
 837     fn_info_value = tree_cons (NULL_TREE,
 838                                build_fn_info_value (fn, fn_info_type),
 839                                fn_info_value);
 840   if (n_fns)
 841     {
 842       tree array_type;
 843
 844       array_type = build_index_type (build_int_2 (n_fns - 1, 0));
 845       array_type = build_array_type (fn_info_type, array_type);
 846
 847       fn_info_value = build_constructor (array_type, nreverse (fn_info_value));
 848       fn_info_value = build1 (ADDR_EXPR, fn_info_ptr_type, fn_info_value);
 849     }
 850   else
 851     fn_info_value = null_pointer_node;
 852
 853   /* number of functions */
 854   field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
 855   TREE_CHAIN (field) = fields;
 856   fields = field;
 857   value = tree_cons (field,
 858                      convert (unsigned_type_node, build_int_2 (n_fns, 0)),
 859                      value);
 860
 861   /* fn_info table */
 862   field = build_decl (FIELD_DECL, NULL_TREE, fn_info_ptr_type);
 863   TREE_CHAIN (field) = fields;
 864   fields = field;
 865   value = tree_cons (field, fn_info_value, value);
 866
 867   /* counter_mask */
 868   field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
 869   TREE_CHAIN (field) = fields;
 870   fields = field;
 871   value = tree_cons (field,
 872                      convert (unsigned_type_node,
 873                               build_int_2 (prg_ctr_mask, 0)),
 874                      value);
 875
 876   /* counters */
 877   ctr_info_type = build_ctr_info_type ();
 878   ctr_info_ary_type = build_index_type (build_int_2 (n_ctr_types, 0));
 879   ctr_info_ary_type = build_array_type (ctr_info_type, ctr_info_ary_type);
 880   for (ix = 0; ix != GCOV_COUNTERS; ix++)
 881     if (prg_ctr_mask & (1 << ix))
 882       ctr_info_value = tree_cons (NULL_TREE,
 883                                   build_ctr_info_value (ix, ctr_info_type),
 884                                   ctr_info_value);
 885   ctr_info_value = build_constructor (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   value = build_constructor (type, nreverse (value));
 896
 897   return value;
 898 }
 899
 900 /* Write out the structure which libgcov uses to locate all the
 901    counters.  The structures used here must match those defined in
 902    gcov-io.h.  Write out the constructor to call __gcov_init.  */
 903
 904 static void
 905 create_coverage (void)
 906 {
 907   tree gcov_info, gcov_init, body, t;
 908   char name_buf[32];
 909
 910   no_coverage = 1; /* Disable any further coverage.  */
 911
 912   if (!prg_ctr_mask)
 913     return;
 914
 915   t = build_gcov_info ();
 916
 917   gcov_info = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (t));
 918   TREE_STATIC (gcov_info) = 1;
 919   ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0);
 920   DECL_NAME (gcov_info) = get_identifier (name_buf);
 921   DECL_INITIAL (gcov_info) = t;
 922
 923   /* Build structure.  */
 924   assemble_variable (gcov_info, 0, 0, 0);
 925
 926   /* Build a decl for __gcov_init.  */
 927   t = build_pointer_type (TREE_TYPE (gcov_info));
 928   t = build_function_type_list (void_type_node, t, NULL);
 929   t = build_decl (FUNCTION_DECL, get_identifier ("__gcov_init"), t);
 930   TREE_PUBLIC (t) = 1;
 931   DECL_EXTERNAL (t) = 1;
 932   gcov_init = t;
 933
 934   /* Generate a call to __gcov_init(&gcov_info).  */
 935   body = NULL;
 936   t = build_fold_addr_expr (gcov_info);
 937   t = tree_cons (NULL, t, NULL);
 938   t = build_function_call_expr (gcov_init, t);
 939   append_to_statement_list (t, &body);
 940
 941   /* Generate a constructor to run it.  */
 942   cgraph_build_static_cdtor ('I', body);
 943 }
 944 \f
 945 /* Perform file-level initialization. Read in data file, generate name
 946    of graph file.  */
 947
 948 void
 949 coverage_init (const char *filename)
 950 {
 951   int len = strlen (filename);
 952
 953   /* Name of da file.  */
 954   da_file_name = xmalloc (len + strlen (GCOV_DATA_SUFFIX) + 1);
 955   strcpy (da_file_name, filename);
 956   strcat (da_file_name, GCOV_DATA_SUFFIX);
 957
 958   /* Name of bbg file.  */
 959   bbg_file_name = xmalloc (len + strlen (GCOV_NOTE_SUFFIX) + 1);
 960   strcpy (bbg_file_name, filename);
 961   strcat (bbg_file_name, GCOV_NOTE_SUFFIX);
 962
 963   read_counts_file ();
 964 }
 965
 966 /* Performs file-level cleanup.  Close graph file, generate coverage
 967    variables and constructor.  */
 968
 969 void
 970 coverage_finish (void)
 971 {
 972   create_coverage ();
 973   if (bbg_file_opened)
 974     {
 975       int error = gcov_close ();
 976
 977       if (error)
 978         unlink (bbg_file_name);
 979       if (!local_tick)
 980         /* Only remove the da file, if we cannot stamp it. If we can
 981            stamp it, libgcov will DTRT.  */
 982         unlink (da_file_name);
 983     }
 984 }
 985
 986 #include "gt-coverage.h"