Gcc 3.4.2 20040728.

1 files changed, 972 insertions, 0 deletions

diff --git a/contrib/gcc/coverage.c b/contrib/gcc/coverage.c
new file mode 100644
index 0000000..395c1e4
--- /dev/null
+++ b/contrib/gcc/coverage.c
@@ -0,0 +1,972 @@
+/* Read and write coverage files, and associated functionality.
+   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998, 1999,
+   2000, 2001, 2003, 2004 Free Software Foundation, Inc.
+   Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
+   based on some ideas from Dain Samples of UC Berkeley.
+   Further mangling by Bob Manson, Cygnus Support.
+   Further mangled by Nathan Sidwell, CodeSourcery
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING.  If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA.  */
+
+
+#define GCOV_LINKAGE
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "rtl.h"
+#include "tree.h"
+#include "flags.h"
+#include "output.h"
+#include "regs.h"
+#include "expr.h"
+#include "function.h"
+#include "toplev.h"
+#include "ggc.h"
+#include "target.h"
+#include "coverage.h"
+#include "libfuncs.h"
+#include "langhooks.h"
+#include "hashtab.h"
+
+#include "gcov-io.c"
+
+struct function_list
+{
+  struct function_list *next;	 /* next function */
+  unsigned ident;		 /* function ident */
+  unsigned checksum;	         /* function checksum */
+  unsigned n_ctrs[GCOV_COUNTERS];/* number of counters.  */
+};
+
+/* Counts information for a function.  */
+typedef struct counts_entry
+{
+  /* We hash by  */
+  unsigned ident;
+  unsigned ctr;
+
+  /* Store  */
+  unsigned checksum;
+  gcov_type *counts;
+  struct gcov_ctr_summary summary;
+
+  /* Workspace */
+  struct counts_entry *chain;
+
+} counts_entry_t;
+
+static struct function_list *functions_head = 0;
+static struct function_list **functions_tail = &functions_head;
+static unsigned no_coverage = 0;
+
+/* Cumulative counter information for whole program.  */
+static unsigned prg_ctr_mask; /* Mask of counter types generated.  */
+static unsigned prg_n_ctrs[GCOV_COUNTERS]; /* Total counters allocated.  */
+
+/* Counter information for current function.  */
+static unsigned fn_ctr_mask; /* Mask of counters used.  */
+static unsigned fn_n_ctrs[GCOV_COUNTERS]; /* Counters allocated.  */
+static unsigned fn_b_ctrs[GCOV_COUNTERS]; /* Allocation base.  */
+
+/* Name of the output file for coverage output file.  */
+static char *bbg_file_name;
+static unsigned bbg_file_opened;
+static int bbg_function_announced;
+
+/* Name of the count data file.  */
+static char *da_file_name;
+
+/* Hash table of count data.  */
+static htab_t counts_hash = NULL;
+
+/* The names of the counter tables.  */
+static GTY(()) rtx ctr_labels[GCOV_COUNTERS];
+
+/* The names of merge functions for counters.  */
+static const char *const ctr_merge_functions[GCOV_COUNTERS] = GCOV_MERGE_FUNCTIONS;
+static const char *const ctr_names[GCOV_COUNTERS] = GCOV_COUNTER_NAMES;
+
+/* Forward declarations.  */
+static hashval_t htab_counts_entry_hash (const void *);
+static int htab_counts_entry_eq (const void *, const void *);
+static void htab_counts_entry_del (void *);
+static void read_counts_file (void);
+static unsigned compute_checksum (void);
+static unsigned coverage_checksum_string (unsigned, const char *);
+static tree build_fn_info_type (unsigned);
+static tree build_fn_info_value (const struct function_list *, tree);
+static tree build_ctr_info_type (void);
+static tree build_ctr_info_value (unsigned, tree);
+static tree build_gcov_info (void);
+static void create_coverage (void);
+
+
+static hashval_t
+htab_counts_entry_hash (const void *of)
+{
+  const counts_entry_t *entry = of;
+
+  return entry->ident * GCOV_COUNTERS + entry->ctr;
+}
+
+static int
+htab_counts_entry_eq (const void *of1, const void *of2)
+{
+  const counts_entry_t *entry1 = of1;
+  const counts_entry_t *entry2 = of2;
+
+  return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
+}
+
+static void
+htab_counts_entry_del (void *of)
+{
+  counts_entry_t *entry = of;
+
+  free (entry->counts);
+  free (entry);
+}
+
+/* Read in the counts file, if available.  */
+
+static void
+read_counts_file (void)
+{
+  gcov_unsigned_t fn_ident = 0;
+  gcov_unsigned_t checksum = -1;
+  counts_entry_t *summaried = NULL;
+  unsigned seen_summary = 0;
+  gcov_unsigned_t tag;
+  int is_error = 0;
+
+  if (!gcov_open (da_file_name, 1))
+    return;
+
+  if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC))
+    {
+      warning ("`%s' is not a gcov data file", da_file_name);
+      gcov_close ();
+      return;
+    }
+  else if ((tag = gcov_read_unsigned ()) != GCOV_VERSION)
+    {
+      char v[4], e[4];
+
+      GCOV_UNSIGNED2STRING (v, tag);
+      GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
+
+      warning ("`%s' is version `%.4s', expected version `%.4s'",
+ 	       da_file_name, v, e);
+      gcov_close ();
+      return;
+    }
+
+  /* Read and discard the stamp.  */
+  gcov_read_unsigned ();
+  
+  counts_hash = htab_create (10,
+			     htab_counts_entry_hash, htab_counts_entry_eq,
+			     htab_counts_entry_del);
+  while ((tag = gcov_read_unsigned ()))
+    {
+      gcov_unsigned_t length;
+      gcov_position_t offset;
+
+      length = gcov_read_unsigned ();
+      offset = gcov_position ();
+      if (tag == GCOV_TAG_FUNCTION)
+	{
+	  fn_ident = gcov_read_unsigned ();
+	  checksum = gcov_read_unsigned ();
+	  if (seen_summary)
+	    {
+	      /* We have already seen a summary, this means that this
+		 new function begins a new set of program runs. We
+		 must unlink the summaried chain.  */
+	      counts_entry_t *entry, *chain;
+
+	      for (entry = summaried; entry; entry = chain)
+		{
+		  chain = entry->chain;
+		  entry->chain = NULL;
+		}
+	      summaried = NULL;
+	      seen_summary = 0;
+	    }
+	}
+      else if (tag == GCOV_TAG_PROGRAM_SUMMARY)
+	{
+	  counts_entry_t *entry;
+	  struct gcov_summary summary;
+
+	  gcov_read_summary (&summary);
+	  seen_summary = 1;
+	  for (entry = summaried; entry; entry = entry->chain)
+	    {
+	      struct gcov_ctr_summary *csum = &summary.ctrs[entry->ctr];
+
+	      entry->summary.runs += csum->runs;
+	      entry->summary.sum_all += csum->sum_all;
+	      if (entry->summary.run_max < csum->run_max)
+		entry->summary.run_max = csum->run_max;
+	      entry->summary.sum_max += csum->sum_max;
+	    }
+	}
+      else if (GCOV_TAG_IS_COUNTER (tag) && fn_ident)
+	{
+	  counts_entry_t **slot, *entry, elt;
+	  unsigned n_counts = GCOV_TAG_COUNTER_NUM (length);
+	  unsigned ix;
+
+	  elt.ident = fn_ident;
+	  elt.ctr = GCOV_COUNTER_FOR_TAG (tag);
+
+	  slot = (counts_entry_t **) htab_find_slot
+	    (counts_hash, &elt, INSERT);
+	  entry = *slot;
+	  if (!entry)
+	    {
+	      *slot = entry = xcalloc (1, sizeof (counts_entry_t));
+	      entry->ident = elt.ident;
+	      entry->ctr = elt.ctr;
+	      entry->checksum = checksum;
+	      entry->summary.num = n_counts;
+	      entry->counts = xcalloc (n_counts, sizeof (gcov_type));
+	    }
+	  else if (entry->checksum != checksum)
+	    {
+	      error ("coverage mismatch for function %u while reading execution counters.",
+		     fn_ident);
+	      error ("checksum is %x instead of %x", entry->checksum, checksum);
+	      htab_delete (counts_hash);
+	      break;
+	    }
+	  else if (entry->summary.num != n_counts)
+	    {
+	      error ("coverage mismatch for function %u while reading execution counters.",
+		     fn_ident);
+	      error ("number of counters is %d instead of %d", entry->summary.num, n_counts);
+	      htab_delete (counts_hash);
+	      break;
+	    }
+	  else if (elt.ctr >= GCOV_COUNTERS_SUMMABLE)
+	    {
+	      error ("cannot merge separate %s counters for function %u",
+		     ctr_names[elt.ctr], fn_ident);
+	      goto skip_merge;
+	    }
+
+	  if (elt.ctr < GCOV_COUNTERS_SUMMABLE
+	      /* This should always be true for a just allocated entry,
+		 and always false for an existing one. Check this way, in
+		 case the gcov file is corrupt.  */
+	      && (!entry->chain || summaried != entry))
+	    {
+	      entry->chain = summaried;
+	      summaried = entry;
+	    }
+	  for (ix = 0; ix != n_counts; ix++)
+	    entry->counts[ix] += gcov_read_counter ();
+	skip_merge:;
+	}
+      gcov_sync (offset, length);
+      if ((is_error = gcov_is_error ()))
+	break;
+    }
+
+  if (!gcov_is_eof ())
+    {
+      error (is_error < 0 ? "`%s' has overflowed" : "`%s' is corrupted",
+	     da_file_name);
+      htab_delete (counts_hash);
+    }
+
+  gcov_close ();
+}
+
+/* Returns the counters for a particular tag.  */
+
+gcov_type *
+get_coverage_counts (unsigned counter, unsigned expected,
+		     const struct gcov_ctr_summary **summary)
+{
+  counts_entry_t *entry, elt;
+  gcov_unsigned_t checksum = -1;
+
+  /* No hash table, no counts.  */
+  if (!counts_hash)
+    {
+      static int warned = 0;
+
+      if (!warned++)
+	inform ("file %s not found, execution counts assumed to be zero",
+		da_file_name);
+      return NULL;
+    }
+
+  elt.ident = current_function_funcdef_no + 1;
+  elt.ctr = counter;
+  entry = htab_find (counts_hash, &elt);
+  if (!entry)
+    {
+      warning ("no coverage for function '%s' found.", IDENTIFIER_POINTER
+	       (DECL_ASSEMBLER_NAME (current_function_decl)));
+      return 0;
+    }
+
+  checksum = compute_checksum ();
+  if (entry->checksum != checksum)
+    {
+      error ("coverage mismatch for function '%s' while reading counter '%s'.",
+	     IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)),
+	     ctr_names[counter]);
+      error ("checksum is %x instead of %x", entry->checksum, checksum);
+      return 0;
+    }
+  else if (entry->summary.num != expected)
+    {
+      error ("coverage mismatch for function '%s' while reading counter '%s'.",
+	     IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)),
+	     ctr_names[counter]);
+      error ("number of counters is %d instead of %d", entry->summary.num, expected);
+      return 0;
+    }
+
+  if (summary)
+    *summary = &entry->summary;
+
+  return entry->counts;
+}
+
+/* Allocate NUM counters of type COUNTER. Returns nonzero if the
+   allocation succeeded.  */
+
+int
+coverage_counter_alloc (unsigned counter, unsigned num)
+{
+  if (no_coverage)
+    return 0;
+
+  if (!num)
+    return 1;
+
+  if (!ctr_labels[counter])
+    {
+      /* Generate and save a copy of this so it can be shared.  */
+      char buf[20];
+
+      ASM_GENERATE_INTERNAL_LABEL (buf, "LPBX", counter + 1);
+      ctr_labels[counter] = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
+      SYMBOL_REF_FLAGS (ctr_labels[counter]) = SYMBOL_FLAG_LOCAL;
+    }
+  fn_b_ctrs[counter] = fn_n_ctrs[counter];
+  fn_n_ctrs[counter] += num;
+  fn_ctr_mask |= 1 << counter;
+  return 1;
+}
+
+/* Generate a MEM rtl to access COUNTER NO.  */
+
+rtx
+coverage_counter_ref (unsigned counter, unsigned no)
+{
+  unsigned gcov_size = tree_low_cst (TYPE_SIZE (GCOV_TYPE_NODE), 1);
+  enum machine_mode mode = mode_for_size (gcov_size, MODE_INT, 0);
+  rtx ref;
+
+  if (no >= fn_n_ctrs[counter] - fn_b_ctrs[counter])
+    abort ();
+  no += prg_n_ctrs[counter] + fn_b_ctrs[counter];
+  ref = plus_constant (ctr_labels[counter], gcov_size / BITS_PER_UNIT * no);
+  ref = gen_rtx_MEM (mode, ref);
+  set_mem_alias_set (ref, new_alias_set ());
+  MEM_NOTRAP_P (ref) = 1;
+
+  return ref;
+}
+
+/* Generate a checksum for a string.  CHKSUM is the current
+   checksum.  */
+
+static unsigned
+coverage_checksum_string (unsigned chksum, const char *string)
+{
+  int i;
+  char *dup = NULL;
+
+  /* Look for everything that looks if it were produced by
+     get_file_function_name_long and zero out the second part
+     that may result from flag_random_seed.  This is not critical
+     as the checksums are used only for sanity checking.  */
+  for (i = 0; string[i]; i++)
+    {
+      if (!strncmp (string + i, "_GLOBAL__", 9))
+	for (i = i + 9; string[i]; i++)
+	  if (string[i]=='_')
+	    {
+	      int y;
+	      unsigned seed;
+
+	      for (y = 1; y < 9; y++)
+		if (!(string[i + y] >= '0' && string[i + y] <= '9')
+		    && !(string[i + y] >= 'A' && string[i + y] <= 'F'))
+		  break;
+	      if (y != 9 || string[i + 9] != '_')
+		continue;
+	      for (y = 10; y < 18; y++)
+		if (!(string[i + y] >= '0' && string[i + y] <= '9')
+		    && !(string[i + y] >= 'A' && string[i + y] <= 'F'))
+		  break;
+	      if (y != 18)
+		continue;
+	      if (!sscanf (string + i + 10, "%X", &seed))
+		abort ();
+	      if (seed != crc32_string (0, flag_random_seed))
+		continue;
+	      string = dup = xstrdup (string);
+	      for (y = 10; y < 18; y++)
+		dup[i + y] = '0';
+	      break;
+	    }
+      break;
+    }
+
+  chksum = crc32_string (chksum, string);
+  if (dup)
+    free (dup);
+
+  return chksum;
+}
+
+/* Compute checksum for the current function.  We generate a CRC32.  */
+
+static unsigned
+compute_checksum (void)
+{
+  unsigned chksum = DECL_SOURCE_LINE (current_function_decl);
+
+  chksum = coverage_checksum_string (chksum,
+      				     DECL_SOURCE_FILE (current_function_decl));
+  chksum = coverage_checksum_string
+    (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)));
+
+  return chksum;
+}
+
+/* Begin output to the graph file for the current function.
+   Opens the output file, if not already done. Writes the
+   function header, if not already done. Returns nonzero if data
+   should be output.  */
+
+int
+coverage_begin_output (void)
+{
+  if (no_coverage)
+    return 0;
+
+  if (!bbg_function_announced)
+    {
+      const char *file = DECL_SOURCE_FILE (current_function_decl);
+      unsigned line = DECL_SOURCE_LINE (current_function_decl);
+      unsigned long offset;
+
+      if (!bbg_file_opened)
+	{
+	  if (!gcov_open (bbg_file_name, -1))
+	    error ("cannot open %s", bbg_file_name);
+	  else
+	    {
+	      gcov_write_unsigned (GCOV_NOTE_MAGIC);
+	      gcov_write_unsigned (GCOV_VERSION);
+	      gcov_write_unsigned (local_tick);
+	    }
+	  bbg_file_opened = 1;
+	}
+
+      /* Announce function */
+      offset = gcov_write_tag (GCOV_TAG_FUNCTION);
+      gcov_write_unsigned (current_function_funcdef_no + 1);
+      gcov_write_unsigned (compute_checksum ());
+      gcov_write_string (IDENTIFIER_POINTER
+			 (DECL_ASSEMBLER_NAME (current_function_decl)));
+      gcov_write_string (file);
+      gcov_write_unsigned (line);
+      gcov_write_length (offset);
+
+      bbg_function_announced = 1;
+    }
+  return !gcov_is_error ();
+}
+
+/* Finish coverage data for the current function. Verify no output
+   error has occurred.  Save function coverage counts.  */
+
+void
+coverage_end_function (void)
+{
+  unsigned i;
+
+  if (bbg_file_opened > 1 && gcov_is_error ())
+    {
+      warning ("error writing `%s'", bbg_file_name);
+      bbg_file_opened = -1;
+    }
+
+  if (fn_ctr_mask)
+    {
+      struct function_list *item;
+
+      item = xmalloc (sizeof (struct function_list));
+
+      *functions_tail = item;
+      functions_tail = &item->next;
+
+      item->next = 0;
+      item->ident = current_function_funcdef_no + 1;
+      item->checksum = compute_checksum ();
+      for (i = 0; i != GCOV_COUNTERS; i++)
+	{
+	  item->n_ctrs[i] = fn_n_ctrs[i];
+	  prg_n_ctrs[i] += fn_n_ctrs[i];
+	  fn_n_ctrs[i] = fn_b_ctrs[i] = 0;
+	}
+      prg_ctr_mask |= fn_ctr_mask;
+      fn_ctr_mask = 0;
+    }
+  bbg_function_announced = 0;
+}
+
+/* Creates the gcov_fn_info RECORD_TYPE.  */
+
+static tree
+build_fn_info_type (unsigned int counters)
+{
+  tree type = (*lang_hooks.types.make_type) (RECORD_TYPE);
+  tree field, fields;
+  tree array_type;
+
+  /* ident */
+  fields = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
+
+  /* checksum */
+  field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
+  TREE_CHAIN (field) = fields;
+  fields = field;
+
+  array_type = build_index_type (build_int_2 (counters - 1, 0));
+  array_type = build_array_type (unsigned_type_node, array_type);
+
+  /* counters */
+  field = build_decl (FIELD_DECL, NULL_TREE, array_type);
+  TREE_CHAIN (field) = fields;
+  fields = field;
+
+  finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE);
+
+  return type;
+}
+
+/* Creates a CONSTRUCTOR for a gcov_fn_info. FUNCTION is
+   the function being processed and TYPE is the gcov_fn_info
+   RECORD_TYPE.  */
+
+static tree
+build_fn_info_value (const struct function_list *function, tree type)
+{
+  tree value = NULL_TREE;
+  tree fields = TYPE_FIELDS (type);
+  unsigned ix;
+  tree array_value = NULL_TREE;
+
+  /* ident */
+  value = tree_cons (fields,
+		     convert (unsigned_intSI_type_node,
+			      build_int_2 (function->ident, 0)),
+		     value);
+  fields = TREE_CHAIN (fields);
+
+  /* checksum */
+  value = tree_cons (fields,
+		     convert (unsigned_intSI_type_node,
+			      build_int_2 (function->checksum, 0)),
+		     value);
+  fields = TREE_CHAIN (fields);
+
+  /* counters */
+  for (ix = 0; ix != GCOV_COUNTERS; ix++)
+    if (prg_ctr_mask & (1 << ix))
+      {
+	tree counters = convert (unsigned_type_node,
+				 build_int_2 (function->n_ctrs[ix], 0));
+
+	array_value = tree_cons (NULL_TREE, counters, array_value);
+      }
+
+  array_value = build_constructor (TREE_TYPE (fields), nreverse (array_value));
+  value = tree_cons (fields, array_value, value);
+
+  value = build_constructor (type, nreverse (value));
+
+  return value;
+}
+
+/* Creates the gcov_ctr_info RECORD_TYPE.  */
+
+static tree
+build_ctr_info_type (void)
+{
+  tree type = (*lang_hooks.types.make_type) (RECORD_TYPE);
+  tree field, fields = NULL_TREE;
+  tree gcov_ptr_type = build_pointer_type (GCOV_TYPE_NODE);
+  tree gcov_merge_fn_type;
+
+  /* counters */
+  field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
+  TREE_CHAIN (field) = fields;
+  fields = field;
+
+  /* values */
+  field = build_decl (FIELD_DECL, NULL_TREE, gcov_ptr_type);
+  TREE_CHAIN (field) = fields;
+  fields = field;
+
+  /* merge */
+  gcov_merge_fn_type =
+    build_function_type_list (void_type_node,
+			      gcov_ptr_type, unsigned_type_node,
+			      NULL_TREE);
+  field = build_decl (FIELD_DECL, NULL_TREE,
+		      build_pointer_type (gcov_merge_fn_type));
+  TREE_CHAIN (field) = fields;
+  fields = field;
+
+  finish_builtin_struct (type, "__gcov_ctr_info", fields, NULL_TREE);
+
+  return type;
+}
+
+/* Creates a CONSTRUCTOR for a gcov_ctr_info. COUNTER is
+   the counter being processed and TYPE is the gcov_ctr_info
+   RECORD_TYPE.  */
+
+static tree
+build_ctr_info_value (unsigned int counter, tree type)
+{
+  tree value = NULL_TREE;
+  tree fields = TYPE_FIELDS (type);
+  tree fn;
+
+  /* counters */
+  value = tree_cons (fields,
+		     convert (unsigned_intSI_type_node,
+			      build_int_2 (prg_n_ctrs[counter], 0)),
+		     value);
+  fields = TREE_CHAIN (fields);
+
+  if (prg_n_ctrs[counter])
+    {
+      tree array_type, array;
+
+      array_type = build_index_type (build_int_2 (prg_n_ctrs[counter] - 1, 0));
+      array_type = build_array_type (TREE_TYPE (TREE_TYPE (fields)),
+				     array_type);
+
+      array = build_decl (VAR_DECL, NULL_TREE, array_type);
+      TREE_STATIC (array) = 1;
+      DECL_NAME (array) = get_identifier (XSTR (ctr_labels[counter], 0));
+      assemble_variable (array, 0, 0, 0);
+
+      value = tree_cons (fields,
+			 build1 (ADDR_EXPR, TREE_TYPE (fields), array),
+			 value);
+    }
+  else
+    value = tree_cons (fields, null_pointer_node, value);
+  fields = TREE_CHAIN (fields);
+
+  fn = build_decl (FUNCTION_DECL,
+		   get_identifier (ctr_merge_functions[counter]),
+		   TREE_TYPE (TREE_TYPE (fields)));
+  DECL_EXTERNAL (fn) = 1;
+  TREE_PUBLIC (fn) = 1;
+  DECL_ARTIFICIAL (fn) = 1;
+  TREE_NOTHROW (fn) = 1;
+  value = tree_cons (fields,
+		     build1 (ADDR_EXPR, TREE_TYPE (fields), fn),
+		     value);
+
+  value = build_constructor (type, nreverse (value));
+
+  return value;
+}
+
+/* Creates the gcov_info RECORD_TYPE and initializer for it. Returns a
+   CONSTRUCTOR.  */
+
+static tree
+build_gcov_info (void)
+{
+  unsigned n_ctr_types, ix;
+  tree type, const_type;
+  tree fn_info_type, fn_info_value = NULL_TREE;
+  tree fn_info_ptr_type;
+  tree ctr_info_type, ctr_info_ary_type, ctr_info_value = NULL_TREE;
+  tree field, fields = NULL_TREE;
+  tree value = NULL_TREE;
+  tree filename_string;
+  char *filename;
+  int filename_len;
+  unsigned n_fns;
+  const struct function_list *fn;
+  tree string_type;
+
+  /* Count the number of active counters.  */
+  for (n_ctr_types = 0, ix = 0; ix != GCOV_COUNTERS; ix++)
+    if (prg_ctr_mask & (1 << ix))
+      n_ctr_types++;
+
+  type = (*lang_hooks.types.make_type) (RECORD_TYPE);
+  const_type = build_qualified_type (type, TYPE_QUAL_CONST);
+
+  /* Version ident */
+  field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
+  TREE_CHAIN (field) = fields;
+  fields = field;
+  value = tree_cons (field, convert (unsigned_intSI_type_node,
+				     build_int_2 (GCOV_VERSION, 0)),
+		     value);
+
+  /* next -- NULL */
+  field = build_decl (FIELD_DECL, NULL_TREE, build_pointer_type (const_type));
+  TREE_CHAIN (field) = fields;
+  fields = field;
+  value = tree_cons (field, null_pointer_node, value);
+
+  /* stamp */
+  field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
+  TREE_CHAIN (field) = fields;
+  fields = field;
+  value = tree_cons (field, convert (unsigned_intSI_type_node,
+				     build_int_2 (local_tick, 0)),
+		     value);
+
+  /* Filename */
+  string_type = build_pointer_type (build_qualified_type (char_type_node,
+						    TYPE_QUAL_CONST));
+  field = build_decl (FIELD_DECL, NULL_TREE, string_type);
+  TREE_CHAIN (field) = fields;
+  fields = field;
+  filename = getpwd ();
+  filename = (filename && da_file_name[0] != '/'
+	      ? concat (filename, "/", da_file_name, NULL)
+	      : da_file_name);
+  filename_len = strlen (filename);
+  filename_string = build_string (filename_len + 1, filename);
+  if (filename != da_file_name)
+    free (filename);
+  TREE_TYPE (filename_string) =
+	  build_array_type (char_type_node,
+			    build_index_type (build_int_2 (filename_len, 0)));
+  value = tree_cons (field, build1 (ADDR_EXPR, string_type, filename_string),
+		     value);
+
+  /* Build the fn_info type and initializer.  */
+  fn_info_type = build_fn_info_type (n_ctr_types);
+  fn_info_ptr_type = build_pointer_type (build_qualified_type
+					 (fn_info_type, TYPE_QUAL_CONST));
+  for (fn = functions_head, n_fns = 0; fn; fn = fn->next, n_fns++)
+    fn_info_value = tree_cons (NULL_TREE,
+			       build_fn_info_value (fn, fn_info_type),
+			       fn_info_value);
+  if (n_fns)
+    {
+      tree array_type;
+
+      array_type = build_index_type (build_int_2 (n_fns - 1, 0));
+      array_type = build_array_type (fn_info_type, array_type);
+
+      fn_info_value = build_constructor (array_type, nreverse (fn_info_value));
+      fn_info_value = build1 (ADDR_EXPR, fn_info_ptr_type, fn_info_value);
+    }
+  else
+    fn_info_value = null_pointer_node;
+
+  /* number of functions */
+  field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
+  TREE_CHAIN (field) = fields;
+  fields = field;
+  value = tree_cons (field,
+		     convert (unsigned_type_node, build_int_2 (n_fns, 0)),
+		     value);
+
+  /* fn_info table */
+  field = build_decl (FIELD_DECL, NULL_TREE, fn_info_ptr_type);
+  TREE_CHAIN (field) = fields;
+  fields = field;
+  value = tree_cons (field, fn_info_value, value);
+
+  /* counter_mask */
+  field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
+  TREE_CHAIN (field) = fields;
+  fields = field;
+  value = tree_cons (field,
+		     convert (unsigned_type_node,
+			      build_int_2 (prg_ctr_mask, 0)),
+		     value);
+
+  /* counters */
+  ctr_info_type = build_ctr_info_type ();
+  ctr_info_ary_type = build_index_type (build_int_2 (n_ctr_types, 0));
+  ctr_info_ary_type = build_array_type (ctr_info_type, ctr_info_ary_type);
+  for (ix = 0; ix != GCOV_COUNTERS; ix++)
+    if (prg_ctr_mask & (1 << ix))
+      ctr_info_value = tree_cons (NULL_TREE,
+				  build_ctr_info_value (ix, ctr_info_type),
+				  ctr_info_value);
+  ctr_info_value = build_constructor (ctr_info_ary_type,
+				      nreverse (ctr_info_value));
+
+  field = build_decl (FIELD_DECL, NULL_TREE, ctr_info_ary_type);
+  TREE_CHAIN (field) = fields;
+  fields = field;
+  value = tree_cons (field, ctr_info_value, value);
+
+  finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE);
+
+  value = build_constructor (type, nreverse (value));
+
+  return value;
+}
+
+/* Write out the structure which libgcov uses to locate all the
+   counters.  The structures used here must match those defined in
+   gcov-io.h.  Write out the constructor to call __gcov_init.  */
+
+static void
+create_coverage (void)
+{
+  tree gcov_info, gcov_info_value;
+  char name[20];
+  char *ctor_name;
+  tree ctor;
+  rtx gcov_info_address;
+
+  no_coverage = 1; /* Disable any further coverage.  */
+
+  if (!prg_ctr_mask)
+    return;
+
+  gcov_info_value = build_gcov_info ();
+
+  gcov_info = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (gcov_info_value));
+  DECL_INITIAL (gcov_info) = gcov_info_value;
+
+  TREE_STATIC (gcov_info) = 1;
+  ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 0);
+  DECL_NAME (gcov_info) = get_identifier (name);
+
+  /* Build structure.  */
+  assemble_variable (gcov_info, 0, 0, 0);
+
+  /* Build the constructor function to invoke __gcov_init.  */
+  ctor_name = concat (IDENTIFIER_POINTER (get_file_function_name ('I')),
+		      "_GCOV", NULL);
+  ctor = build_decl (FUNCTION_DECL, get_identifier (ctor_name),
+		     build_function_type (void_type_node, NULL_TREE));
+  free (ctor_name);
+  DECL_EXTERNAL (ctor) = 0;
+
+  /* It can be a static function as long as collect2 does not have
+     to scan the object file to find its ctor/dtor routine.  */
+  TREE_PUBLIC (ctor) = ! targetm.have_ctors_dtors;
+  TREE_USED (ctor) = 1;
+  DECL_RESULT (ctor) = build_decl (RESULT_DECL, NULL_TREE, void_type_node);
+  DECL_UNINLINABLE (ctor) = 1;
+
+  ctor = (*lang_hooks.decls.pushdecl) (ctor);
+  rest_of_decl_compilation (ctor, 0, 1, 0);
+  announce_function (ctor);
+  current_function_decl = ctor;
+  make_decl_rtl (ctor, NULL);
+  init_function_start (ctor);
+  expand_function_start (ctor, 0);
+  /* Actually generate the code to call __gcov_init.  */
+  gcov_info_address = force_reg (Pmode, XEXP (DECL_RTL (gcov_info), 0));
+  emit_library_call (gcov_init_libfunc, LCT_NORMAL, VOIDmode, 1,
+		     gcov_info_address, Pmode);
+
+  expand_function_end ();
+  /* Create a dummy BLOCK.  */
+  DECL_INITIAL (ctor) = make_node (BLOCK);
+  TREE_USED (DECL_INITIAL (ctor)) = 1;
+
+  rest_of_compilation (ctor);
+
+  if (! quiet_flag)
+    fflush (asm_out_file);
+  current_function_decl = NULL_TREE;
+
+  if (targetm.have_ctors_dtors)
+    (* targetm.asm_out.constructor) (XEXP (DECL_RTL (ctor), 0),
+				     DEFAULT_INIT_PRIORITY);
+}
+
+/* Perform file-level initialization. Read in data file, generate name
+   of graph file.  */
+
+void
+coverage_init (const char *filename)
+{
+  int len = strlen (filename);
+
+  /* Name of da file.  */
+  da_file_name = xmalloc (len + strlen (GCOV_DATA_SUFFIX) + 1);
+  strcpy (da_file_name, filename);
+  strcat (da_file_name, GCOV_DATA_SUFFIX);
+
+  /* Name of bbg file.  */
+  bbg_file_name = xmalloc (len + strlen (GCOV_NOTE_SUFFIX) + 1);
+  strcpy (bbg_file_name, filename);
+  strcat (bbg_file_name, GCOV_NOTE_SUFFIX);
+
+  read_counts_file ();
+}
+
+/* Performs file-level cleanup.  Close graph file, generate coverage
+   variables and constructor.  */
+
+void
+coverage_finish (void)
+{
+  create_coverage ();
+  if (bbg_file_opened)
+    {
+      int error = gcov_close ();
+
+      if (error)
+	unlink (bbg_file_name);
+      if (!local_tick)
+	/* Only remove the da file, if we cannot stamp it. If we can
+	   stamp it, libgcov will DTRT.  */
+	unlink (da_file_name);
+    }
+}
+
+#include "gt-coverage.h"