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