X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Fcoverage.c;h=5ef4dddd81283053cac41994234bfd3fd20057f1;hp=888d5cde2c3bd388106de847f8fe468624125e63;hb=7ab483efddd3684078a9353c747b5c5e56464d20;hpb=c5344b58abd22c52e83e69147cad673f44c9edf4

diff --git a/gcc/coverage.c b/gcc/coverage.c
index 888d5cde2c3..5ef4dddd812 100644
--- a/gcc/coverage.c
+++ b/gcc/coverage.c
@@ -1,6 +1,7 @@
 /* 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.
+   2000, 2001, 2003, 2004, 2005, 2007, 2008 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.
@@ -10,7 +11,7 @@ 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
+Software Foundation; either version 3, or (at your option) any later
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
@@ -19,9 +20,8 @@ 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.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
 
 
 #define GCOV_LINKAGE
@@ -38,12 +38,16 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "expr.h"
 #include "function.h"
 #include "toplev.h"
+#include "tm_p.h"
 #include "ggc.h"
 #include "coverage.h"
 #include "langhooks.h"
 #include "hashtab.h"
 #include "tree-iterator.h"
 #include "cgraph.h"
+#include "tree-pass.h"
+#include "diagnostic.h"
+#include "intl.h"
 
 #include "gcov-io.c"
 
@@ -120,12 +124,27 @@ 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);
+
+/* Return the type node for gcov_type.  */
 
+tree
+get_gcov_type (void)
+{
+  return lang_hooks.types.type_for_size (GCOV_TYPE_SIZE, false);
+}
+
+/* Return the type node for gcov_unsigned_t.  */
+
+static tree
+get_gcov_unsigned_t (void)
+{
+  return lang_hooks.types.type_for_size (32, true);
+}
 
 static hashval_t
 htab_counts_entry_hash (const void *of)
 {
-  const counts_entry_t *entry = of;
+  const counts_entry_t *const entry = (const counts_entry_t *) of;
 
   return entry->ident * GCOV_COUNTERS + entry->ctr;
 }
@@ -133,8 +152,8 @@ htab_counts_entry_hash (const void *of)
 static int
 htab_counts_entry_eq (const void *of1, const void *of2)
 {
-  const counts_entry_t *entry1 = of1;
-  const counts_entry_t *entry2 = of2;
+  const counts_entry_t *const entry1 = (const counts_entry_t *) of1;
+  const counts_entry_t *const entry2 = (const counts_entry_t *) of2;
 
   return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
 }
@@ -142,7 +161,7 @@ htab_counts_entry_eq (const void *of1, const void *of2)
 static void
 htab_counts_entry_del (void *of)
 {
-  counts_entry_t *entry = of;
+  counts_entry_t *const entry = (counts_entry_t *) of;
 
   free (entry->counts);
   free (entry);
@@ -165,7 +184,7 @@ read_counts_file (void)
 
   if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC))
     {
-      warning ("`%s' is not a gcov data file", da_file_name);
+      warning (0, "%qs is not a gcov data file", da_file_name);
       gcov_close ();
       return;
     }
@@ -176,7 +195,7 @@ read_counts_file (void)
       GCOV_UNSIGNED2STRING (v, tag);
       GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
 
-      warning ("`%s' is version `%.*s', expected version `%.*s'",
+      warning (0, "%qs is version %q.*s, expected version %q.*s",
  	       da_file_name, 4, v, 4, e);
       gcov_close ();
       return;
@@ -184,7 +203,7 @@ read_counts_file (void)
 
   /* 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);
@@ -247,16 +266,16 @@ read_counts_file (void)
 	  entry = *slot;
 	  if (!entry)
 	    {
-	      *slot = entry = xcalloc (1, sizeof (counts_entry_t));
+	      *slot = entry = XCNEW (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));
+	      entry->counts = XCNEWVEC (gcov_type, n_counts);
 	    }
 	  else if (entry->checksum != checksum)
 	    {
-	      error ("coverage mismatch for function %u while reading execution counters.",
+	      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);
@@ -264,7 +283,7 @@ read_counts_file (void)
 	    }
 	  else if (entry->summary.num != n_counts)
 	    {
-	      error ("coverage mismatch for function %u while reading execution counters.",
+	      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);
@@ -292,14 +311,12 @@ read_counts_file (void)
 	}
       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);
+	{
+	  error (is_error < 0 ? "%qs has overflowed" : "%qs is corrupted",
+		 da_file_name);
+	  htab_delete (counts_hash);
+	  break;
+	}
     }
 
   gcov_close ();
@@ -320,7 +337,7 @@ get_coverage_counts (unsigned counter, unsigned expected,
       static int warned = 0;
 
       if (!warned++)
-	inform ((flag_guess_branch_prob
+	inform (input_location, (flag_guess_branch_prob
 		 ? "file %s not found, execution counts estimated"
 		 : "file %s not found, execution counts assumed to be zero"),
 		da_file_name);
@@ -329,30 +346,49 @@ get_coverage_counts (unsigned counter, unsigned expected,
 
   elt.ident = current_function_funcdef_no + 1;
   elt.ctr = counter;
-  entry = htab_find (counts_hash, &elt);
+  entry = (counts_entry_t *) htab_find (counts_hash, &elt);
   if (!entry)
     {
-      warning ("no coverage for function '%s' found.", IDENTIFIER_POINTER
-	       (DECL_ASSEMBLER_NAME (current_function_decl)));
-      return 0;
+      warning (0, "no coverage for function %qE found",
+	       DECL_ASSEMBLER_NAME (current_function_decl));
+      return NULL;
     }
 
   checksum = compute_checksum ();
-  if (entry->checksum != checksum)
+  if (entry->checksum != checksum
+      || 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 ("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;
+      static int warned = 0;
+      bool warning_printed = false;
+      tree id = DECL_ASSEMBLER_NAME (current_function_decl);
+
+      warning_printed = 
+	warning_at (input_location, OPT_Wcoverage_mismatch, 
+		    "coverage mismatch for function "
+		    "%qE while reading counter %qs", id, ctr_names[counter]);
+      if (warning_printed)
+	{
+	  if (entry->checksum != checksum)
+	    inform (input_location, "checksum is %x instead of %x",
+		    entry->checksum, checksum);
+	  else
+	    inform (input_location, "number of counters is %d instead of %d",
+		    entry->summary.num, expected);
+	  
+	  if (!(errorcount || sorrycount)
+	      && !warned++)
+	    {
+	      inform (input_location, "coverage mismatch ignored");
+	      inform (input_location, flag_guess_branch_prob
+		      ? G_("execution counts estimated")
+		      : G_("execution counts assumed to be zero"));
+	      if (!flag_guess_branch_prob)
+		inform (input_location,
+			"this can result in poorly optimized code");
+	    }
+	}
+
+      return NULL;
     }
 
   if (summary)
@@ -375,20 +411,23 @@ coverage_counter_alloc (unsigned counter, unsigned num)
 
   if (!tree_ctr_tables[counter])
     {
-      /* Generate and save a copy of this so it can be shared.  */
-      /* We don't know the size yet; make it big enough that nobody
-	 will make any clever transformation on it.  */
+      /* Generate and save a copy of this so it can be shared.  Leave
+	 the index type unspecified for now; it will be set after all
+	 functions have been compiled.  */
       char buf[20];
-      tree domain_tree
-        = build_index_type (build_int_2 (1000, 0)); /* replaced later */
+      tree gcov_type_node = get_gcov_type ();
       tree gcov_type_array_type
-        = build_array_type (GCOV_TYPE_NODE, domain_tree);
+        = build_array_type (gcov_type_node, NULL_TREE);
       tree_ctr_tables[counter]
-        = build_decl (VAR_DECL, NULL_TREE, gcov_type_array_type);
+        = build_decl (BUILTINS_LOCATION,
+		      VAR_DECL, NULL_TREE, gcov_type_array_type);
       TREE_STATIC (tree_ctr_tables[counter]) = 1;
       ASM_GENERATE_INTERNAL_LABEL (buf, "LPBX", counter + 1);
       DECL_NAME (tree_ctr_tables[counter]) = get_identifier (buf);
-      DECL_ALIGN (tree_ctr_tables[counter]) = TYPE_ALIGN (GCOV_TYPE_NODE);
+      DECL_ALIGN (tree_ctr_tables[counter]) = TYPE_ALIGN (gcov_type_node);
+
+      if (dump_file)
+	fprintf (dump_file, "Using data file %s\n", da_file_name);
     }
   fn_b_ctrs[counter] = fn_n_ctrs[counter];
   fn_n_ctrs[counter] += num;
@@ -396,50 +435,38 @@ coverage_counter_alloc (unsigned counter, unsigned num)
   return 1;
 }
 
-/* Generate a MEM rtl to access COUNTER NO.  */
+/* Generate a tree to access COUNTER NO.  */
 
-rtx
-rtl_coverage_counter_ref (unsigned counter, unsigned no)
+tree
+tree_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;
+  tree gcov_type_node = get_gcov_type ();
 
-  if (no >= fn_n_ctrs[counter] - fn_b_ctrs[counter])
-    abort ();
+  gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]);
   no += prg_n_ctrs[counter] + fn_b_ctrs[counter];
-  if (!ctr_labels[counter])
-      {
-        ctr_labels[counter] = gen_rtx_SYMBOL_REF (Pmode,
-			       ggc_strdup (IDENTIFIER_POINTER (DECL_NAME
-			       (tree_ctr_tables[counter]))));
-        SYMBOL_REF_FLAGS (ctr_labels[counter]) = SYMBOL_FLAG_LOCAL;
-      }
-  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;
+
+  /* "no" here is an array index, scaled to bytes later.  */
+  return build4 (ARRAY_REF, gcov_type_node, tree_ctr_tables[counter],
+		 build_int_cst (NULL_TREE, no), NULL, NULL);
 }
 
-/* Generate a tree to access COUNTER NO.  */
+/* Generate a tree to access the address of COUNTER NO.  */
 
 tree
-tree_coverage_counter_ref (unsigned counter, unsigned no)
+tree_coverage_counter_addr (unsigned counter, unsigned no)
 {
-  tree domain_type = TYPE_DOMAIN (TREE_TYPE (tree_ctr_tables[counter]));
+  tree gcov_type_node = get_gcov_type ();
 
-  if (no >= fn_n_ctrs[counter] - fn_b_ctrs[counter])
-    abort ();
+  gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]);
   no += prg_n_ctrs[counter] + fn_b_ctrs[counter];
 
+  TREE_ADDRESSABLE (tree_ctr_tables[counter]) = 1;
+
   /* "no" here is an array index, scaled to bytes later.  */
-  return build (ARRAY_REF, GCOV_TYPE_NODE, tree_ctr_tables[counter],
-		fold_convert (domain_type, build_int_2 (no, 0)),
-		TYPE_MIN_VALUE (domain_type),
-		size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (GCOV_TYPE_NODE),
-			    size_int (TYPE_ALIGN (GCOV_TYPE_NODE))));
+  return build_fold_addr_expr (build4 (ARRAY_REF, gcov_type_node,
+				       tree_ctr_tables[counter],
+				       build_int_cst (NULL_TREE, no),
+				       NULL, NULL));
 }
 
 /* Generate a checksum for a string.  CHKSUM is the current
@@ -452,40 +479,48 @@ coverage_checksum_string (unsigned chksum, const char *string)
   char *dup = NULL;
 
   /* Look for everything that looks if it were produced by
-     get_file_function_name_long and zero out the second part
+     get_file_function_name 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++)
     {
+      int offset = 0;
+      if (!strncmp (string + i, "_GLOBAL__N_", 11))
+      offset = 11;
       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;
+      offset = 9;
+
+      /* C++ namespaces do have scheme:
+         _GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname
+       since filename might contain extra underscores there seems
+       to be no better chance then walk all possible offsets looking
+       for magicnumber.  */
+      if (offset)
+	{
+	  for (i = i + offset; string[i]; i++)
+	    if (string[i]=='_')
+	      {
+		int y;
+
+		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 (!dup)
+		  string = dup = xstrdup (string);
+		for (y = 10; y < 18; y++)
+		  dup[i + y] = '0';
+	      }
+	  break;
+	}
     }
 
   chksum = crc32_string (chksum, string);
@@ -519,7 +554,9 @@ compute_checksum (void)
 int
 coverage_begin_output (void)
 {
-  if (no_coverage)
+  /* We don't need to output .gcno file unless we're under -ftest-coverage
+     (e.g. -fprofile-arcs/generate/use don't need .gcno to work). */
+  if (no_coverage || !flag_test_coverage || flag_compare_debug)
     return 0;
 
   if (!bbg_function_announced)
@@ -566,7 +603,7 @@ coverage_end_function (void)
 
   if (bbg_file_opened > 1 && gcov_is_error ())
     {
-      warning ("error writing `%s'", bbg_file_name);
+      warning (0, "error writing %qs", bbg_file_name);
       bbg_file_opened = -1;
     }
 
@@ -574,7 +611,7 @@ coverage_end_function (void)
     {
       struct function_list *item;
 
-      item = xmalloc (sizeof (struct function_list));
+      item = XNEW (struct function_list);
 
       *functions_tail = item;
       functions_tail = &item->next;
@@ -604,18 +641,22 @@ build_fn_info_type (unsigned int counters)
   tree array_type;
 
   /* ident */
-  fields = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
+  fields = build_decl (BUILTINS_LOCATION,
+		       FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 
   /* checksum */
-  field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
+  field = build_decl (BUILTINS_LOCATION,
+		      FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
   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);
+  array_type = build_int_cst (NULL_TREE, counters - 1);
+  array_type = build_index_type (array_type);
+  array_type = build_array_type (get_gcov_unsigned_t (), array_type);
 
   /* counters */
-  field = build_decl (FIELD_DECL, NULL_TREE, array_type);
+  field = build_decl (BUILTINS_LOCATION,
+		      FIELD_DECL, NULL_TREE, array_type);
   TREE_CHAIN (field) = fields;
   fields = field;
 
@@ -631,41 +672,34 @@ build_fn_info_type (unsigned int counters)
 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;
+  VEC(constructor_elt,gc) *v1 = NULL;
+  VEC(constructor_elt,gc) *v2 = NULL;
 
   /* ident */
-  value = tree_cons (fields,
-		     convert (unsigned_intSI_type_node,
-			      build_int_2 (function->ident, 0)),
-		     value);
+  CONSTRUCTOR_APPEND_ELT (v1, fields,
+			  build_int_cstu (get_gcov_unsigned_t (),
+					  function->ident));
   fields = TREE_CHAIN (fields);
 
   /* checksum */
-  value = tree_cons (fields,
-		     convert (unsigned_intSI_type_node,
-			      build_int_2 (function->checksum, 0)),
-		     value);
+  CONSTRUCTOR_APPEND_ELT (v1, fields,
+			  build_int_cstu (get_gcov_unsigned_t (),
+					  function->checksum));
   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);
+      CONSTRUCTOR_APPEND_ELT (v2, NULL,
+			      build_int_cstu (get_gcov_unsigned_t (),
+					      function->n_ctrs[ix]));
 
-  value = build_constructor (type, nreverse (value));
+  CONSTRUCTOR_APPEND_ELT (v1, fields,
+			  build_constructor (TREE_TYPE (fields), v2));
 
-  return value;
+  return build_constructor (type, v1);
 }
 
 /* Creates the gcov_ctr_info RECORD_TYPE.  */
@@ -675,25 +709,28 @@ 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_ptr_type = build_pointer_type (get_gcov_type ());
   tree gcov_merge_fn_type;
 
   /* counters */
-  field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
+  field = build_decl (BUILTINS_LOCATION,
+		      FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
   TREE_CHAIN (field) = fields;
   fields = field;
 
   /* values */
-  field = build_decl (FIELD_DECL, NULL_TREE, gcov_ptr_type);
+  field = build_decl (BUILTINS_LOCATION,
+		      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,
+			      gcov_ptr_type, get_gcov_unsigned_t (),
 			      NULL_TREE);
-  field = build_decl (FIELD_DECL, NULL_TREE,
+  field = build_decl (BUILTINS_LOCATION,
+		      FIELD_DECL, NULL_TREE,
 		      build_pointer_type (gcov_merge_fn_type));
   TREE_CHAIN (field) = fields;
   fields = field;
@@ -710,53 +747,51 @@ build_ctr_info_type (void)
 static tree
 build_ctr_info_value (unsigned int counter, tree type)
 {
-  tree value = NULL_TREE;
   tree fields = TYPE_FIELDS (type);
   tree fn;
+  VEC(constructor_elt,gc) *v = NULL;
 
   /* counters */
-  value = tree_cons (fields,
-		     convert (unsigned_intSI_type_node,
-			      build_int_2 (prg_n_ctrs[counter], 0)),
-		     value);
+  CONSTRUCTOR_APPEND_ELT (v, fields,
+			  build_int_cstu (get_gcov_unsigned_t (),
+					  prg_n_ctrs[counter]));
   fields = TREE_CHAIN (fields);
 
   if (prg_n_ctrs[counter])
     {
       tree array_type;
 
-      array_type = build_index_type (build_int_2 (prg_n_ctrs[counter] - 1, 0));
+      array_type = build_int_cstu (get_gcov_unsigned_t (),
+				   prg_n_ctrs[counter] - 1);
+      array_type = build_index_type (array_type);
       array_type = build_array_type (TREE_TYPE (TREE_TYPE (fields)),
 				     array_type);
 
       TREE_TYPE (tree_ctr_tables[counter]) = array_type;
       DECL_SIZE (tree_ctr_tables[counter]) = TYPE_SIZE (array_type);
       DECL_SIZE_UNIT (tree_ctr_tables[counter]) = TYPE_SIZE_UNIT (array_type);
-      assemble_variable (tree_ctr_tables[counter], 0, 0, 0);
+      varpool_finalize_decl (tree_ctr_tables[counter]);
 
-      value = tree_cons (fields,
-			 build1 (ADDR_EXPR, TREE_TYPE (fields), 
-					    tree_ctr_tables[counter]),
-			 value);
+      CONSTRUCTOR_APPEND_ELT (v, fields,
+			      build1 (ADDR_EXPR, TREE_TYPE (fields),
+				      tree_ctr_tables[counter]));
     }
   else
-    value = tree_cons (fields, null_pointer_node, value);
+    CONSTRUCTOR_APPEND_ELT (v, fields, null_pointer_node);
   fields = TREE_CHAIN (fields);
 
-  fn = build_decl (FUNCTION_DECL,
+  fn = build_decl (BUILTINS_LOCATION,
+		   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);
+  DECL_ASSEMBLER_NAME (fn);  /* Initialize assembler name so we can stream out. */
+  CONSTRUCTOR_APPEND_ELT (v, fields, build1 (ADDR_EXPR, TREE_TYPE (fields), fn));
 
-  value = build_constructor (type, nreverse (value));
-
-  return value;
+  return build_constructor (type, v);
 }
 
 /* Creates the gcov_info RECORD_TYPE and initializer for it. Returns a
@@ -771,13 +806,13 @@ build_gcov_info (void)
   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;
+  int da_file_name_len;
   unsigned n_fns;
   const struct function_list *fn;
   tree string_type;
+  VEC(constructor_elt,gc) *v1 = NULL;
+  VEC(constructor_elt,gc) *v2 = NULL;
 
   /* Count the number of active counters.  */
   for (n_ctr_types = 0, ix = 0; ix != GCOV_COUNTERS; ix++)
@@ -788,113 +823,109 @@ build_gcov_info (void)
   const_type = build_qualified_type (type, TYPE_QUAL_CONST);
 
   /* Version ident */
-  field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
+  field = build_decl (BUILTINS_LOCATION,
+		      FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
   TREE_CHAIN (field) = fields;
   fields = field;
-  value = tree_cons (field, convert (unsigned_intSI_type_node,
-				     build_int_2 (GCOV_VERSION, 0)),
-		     value);
+  CONSTRUCTOR_APPEND_ELT (v1, field,
+			  build_int_cstu (TREE_TYPE (field), GCOV_VERSION));
 
   /* next -- NULL */
-  field = build_decl (FIELD_DECL, NULL_TREE, build_pointer_type (const_type));
+  field = build_decl (BUILTINS_LOCATION,
+		      FIELD_DECL, NULL_TREE, build_pointer_type (const_type));
   TREE_CHAIN (field) = fields;
   fields = field;
-  value = tree_cons (field, null_pointer_node, value);
+  CONSTRUCTOR_APPEND_ELT (v1, field, null_pointer_node);
 
   /* stamp */
-  field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
+  field = build_decl (BUILTINS_LOCATION,
+		      FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
   TREE_CHAIN (field) = fields;
   fields = field;
-  value = tree_cons (field, convert (unsigned_intSI_type_node,
-				     build_int_2 (local_tick, 0)),
-		     value);
+  CONSTRUCTOR_APPEND_ELT (v1, field,
+			  build_int_cstu (TREE_TYPE (field), local_tick));
 
   /* Filename */
   string_type = build_pointer_type (build_qualified_type (char_type_node,
 						    TYPE_QUAL_CONST));
-  field = build_decl (FIELD_DECL, NULL_TREE, string_type);
+  field = build_decl (BUILTINS_LOCATION,
+		      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);
+  da_file_name_len = strlen (da_file_name);
+  filename_string = build_string (da_file_name_len + 1, da_file_name);
+  TREE_TYPE (filename_string) = build_array_type
+    (char_type_node, build_index_type
+     (build_int_cst (NULL_TREE, da_file_name_len)));
+  CONSTRUCTOR_APPEND_ELT (v1, field,
+			  build1 (ADDR_EXPR, string_type, filename_string));
 
   /* 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);
+    CONSTRUCTOR_APPEND_ELT (v2, NULL_TREE,
+			    build_fn_info_value (fn, fn_info_type));
+
   if (n_fns)
     {
       tree array_type;
 
-      array_type = build_index_type (build_int_2 (n_fns - 1, 0));
+      array_type = build_index_type (build_int_cst (NULL_TREE, n_fns - 1));
       array_type = build_array_type (fn_info_type, array_type);
 
-      fn_info_value = build_constructor (array_type, nreverse (fn_info_value));
+      fn_info_value = build_constructor (array_type, v2);
       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);
+  field = build_decl (BUILTINS_LOCATION,
+		      FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
   TREE_CHAIN (field) = fields;
   fields = field;
-  value = tree_cons (field,
-		     convert (unsigned_type_node, build_int_2 (n_fns, 0)),
-		     value);
+  CONSTRUCTOR_APPEND_ELT (v1, field,
+			  build_int_cstu (get_gcov_unsigned_t (), n_fns));
 
   /* fn_info table */
-  field = build_decl (FIELD_DECL, NULL_TREE, fn_info_ptr_type);
+  field = build_decl (BUILTINS_LOCATION,
+		      FIELD_DECL, NULL_TREE, fn_info_ptr_type);
   TREE_CHAIN (field) = fields;
   fields = field;
-  value = tree_cons (field, fn_info_value, value);
+  CONSTRUCTOR_APPEND_ELT (v1, field, fn_info_value);
 
   /* counter_mask */
-  field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
+  field = build_decl (BUILTINS_LOCATION,
+		      FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
   TREE_CHAIN (field) = fields;
   fields = field;
-  value = tree_cons (field,
-		     convert (unsigned_type_node,
-			      build_int_2 (prg_ctr_mask, 0)),
-		     value);
+  CONSTRUCTOR_APPEND_ELT (v1, field, 
+			  build_int_cstu (get_gcov_unsigned_t (),
+					  prg_ctr_mask));
 
   /* 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_index_type (build_int_cst (NULL_TREE,
+						       n_ctr_types));
   ctr_info_ary_type = build_array_type (ctr_info_type, ctr_info_ary_type);
+  v2 = NULL;
   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));
+      CONSTRUCTOR_APPEND_ELT (v2, NULL_TREE,
+			      build_ctr_info_value (ix, ctr_info_type));
+  ctr_info_value = build_constructor (ctr_info_ary_type, v2);
 
-  field = build_decl (FIELD_DECL, NULL_TREE, ctr_info_ary_type);
+  field = build_decl (BUILTINS_LOCATION,
+		      FIELD_DECL, NULL_TREE, ctr_info_ary_type);
   TREE_CHAIN (field) = fields;
   fields = field;
-  value = tree_cons (field, ctr_info_value, value);
+  CONSTRUCTOR_APPEND_ELT (v1, field, ctr_info_value);
 
   finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE);
 
-  value = build_constructor (type, nreverse (value));
-
-  return value;
+  return build_constructor (type, v1);
 }
 
 /* Write out the structure which libgcov uses to locate all the
@@ -914,28 +945,30 @@ create_coverage (void)
 
   t = build_gcov_info ();
 
-  gcov_info = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (t));
+  gcov_info = build_decl (BUILTINS_LOCATION,
+			  VAR_DECL, NULL_TREE, TREE_TYPE (t));
   TREE_STATIC (gcov_info) = 1;
   ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0);
   DECL_NAME (gcov_info) = get_identifier (name_buf);
   DECL_INITIAL (gcov_info) = t;
 
   /* Build structure.  */
-  assemble_variable (gcov_info, 0, 0, 0);
+  varpool_finalize_decl (gcov_info);
 
   /* Build a decl for __gcov_init.  */
   t = build_pointer_type (TREE_TYPE (gcov_info));
   t = build_function_type_list (void_type_node, t, NULL);
-  t = build_decl (FUNCTION_DECL, get_identifier ("__gcov_init"), t);
+  t = build_decl (BUILTINS_LOCATION,
+		  FUNCTION_DECL, get_identifier ("__gcov_init"), t);
   TREE_PUBLIC (t) = 1;
   DECL_EXTERNAL (t) = 1;
+  DECL_ASSEMBLER_NAME (t);  /* Initialize assembler name so we can stream out. */
   gcov_init = t;
 
   /* Generate a call to __gcov_init(&gcov_info).  */
   body = NULL;
   t = build_fold_addr_expr (gcov_info);
-  t = tree_cons (NULL, t, NULL);
-  t = build_function_call_expr (gcov_init, t);
+  t = build_call_expr (gcov_init, 1, t);
   append_to_statement_list (t, &body);
 
   /* Generate a constructor to run it.  */
@@ -949,18 +982,36 @@ void
 coverage_init (const char *filename)
 {
   int len = strlen (filename);
+  /* + 1 for extra '/', in case prefix doesn't end with /.  */
+  int prefix_len;
+
+  if (profile_data_prefix == 0 && filename[0] != '/')
+    profile_data_prefix = getpwd ();
+
+  prefix_len = (profile_data_prefix) ? strlen (profile_data_prefix) + 1 : 0;
 
   /* Name of da file.  */
-  da_file_name = xmalloc (len + strlen (GCOV_DATA_SUFFIX) + 1);
-  strcpy (da_file_name, filename);
+  da_file_name = XNEWVEC (char, len + strlen (GCOV_DATA_SUFFIX)
+			  + prefix_len + 1);
+
+  if (profile_data_prefix)
+    {
+      strcpy (da_file_name, profile_data_prefix);
+      da_file_name[prefix_len - 1] = '/';
+      da_file_name[prefix_len] = 0;
+    }
+  else
+    da_file_name[0] = 0;
+  strcat (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);
+  bbg_file_name = XNEWVEC (char, len + strlen (GCOV_NOTE_SUFFIX) + 1);
   strcpy (bbg_file_name, filename);
   strcat (bbg_file_name, GCOV_NOTE_SUFFIX);
 
-  read_counts_file ();
+  if (flag_profile_use)
+    read_counts_file ();
 }
 
 /* Performs file-level cleanup.  Close graph file, generate coverage