Daily bump.

[pf3gnuchains/gcc-fork.git] / gcc / coverage.c

diff --git a/gcc/coverage.c b/gcc/coverage.c
index 1912c34..e04d22b 100644 (file)
--- 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,
 /* 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.
    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
 
 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
 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
 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
 
 
 #define GCOV_LINKAGE


@@ -38,12 +38,14 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "expr.h"
 #include "function.h"
 #include "toplev.h"
 #include "expr.h"
 #include "function.h"
 #include "toplev.h"

+#include "tm_p.h"

 #include "ggc.h"
 #include "ggc.h"

-#include "target.h"

 #include "coverage.h"
 #include "coverage.h"

-#include "libfuncs.h"

 #include "langhooks.h"
 #include "hashtab.h"
 #include "langhooks.h"
 #include "hashtab.h"

+#include "tree-iterator.h"
+#include "cgraph.h"
+#include "tree-pass.h"

 
 #include "gcov-io.c"
 
 
 #include "gcov-io.c"
 


@@ -96,7 +98,11 @@ static char *da_file_name;
 /* Hash table of count data.  */
 static htab_t counts_hash = NULL;
 
 /* Hash table of count data.  */
 static htab_t counts_hash = NULL;
 

-/* The names of the counter tables.  */
+/* Trees representing the counter table arrays.  */
+static GTY(()) tree tree_ctr_tables[GCOV_COUNTERS];
+
+/* The names of the counter tables.  Not used if we're
+   generating counters at tree level.  */

 static GTY(()) rtx ctr_labels[GCOV_COUNTERS];
 
 /* The names of merge functions for counters.  */
 static GTY(()) rtx ctr_labels[GCOV_COUNTERS];
 
 /* The names of merge functions for counters.  */


@@ -116,12 +122,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);
 static tree build_ctr_info_value (unsigned, tree);
 static tree build_gcov_info (void);
 static void create_coverage (void);

+\f
+/* 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);
+}

 \f
 static hashval_t
 htab_counts_entry_hash (const void *of)
 {
 \f
 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;
 }
 
   return entry->ident * GCOV_COUNTERS + entry->ctr;
 }


@@ -129,8 +150,8 @@ htab_counts_entry_hash (const void *of)
 static int
 htab_counts_entry_eq (const void *of1, const void *of2)
 {
 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;
 }
 
   return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
 }


@@ -138,7 +159,7 @@ htab_counts_entry_eq (const void *of1, const void *of2)
 static void
 htab_counts_entry_del (void *of)
 {
 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);
 
   free (entry->counts);
   free (entry);


@@ -161,7 +182,7 @@ read_counts_file (void)
 
   if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC))
     {
 
   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;
     }
       gcov_close ();
       return;
     }


@@ -172,7 +193,7 @@ read_counts_file (void)
       GCOV_UNSIGNED2STRING (v, tag);
       GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
 
       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;
               da_file_name, 4, v, 4, e);
       gcov_close ();
       return;


@@ -180,7 +201,7 @@ read_counts_file (void)
 
   /* Read and discard the stamp.  */
   gcov_read_unsigned ();
 
   /* 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);
   counts_hash = htab_create (10,
                             htab_counts_entry_hash, htab_counts_entry_eq,
                             htab_counts_entry_del);


@@ -243,16 +264,16 @@ read_counts_file (void)
          entry = *slot;
          if (!entry)
            {
          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->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)
            {
            }
          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);
                     fn_ident);
              error ("checksum is %x instead of %x", entry->checksum, checksum);
              htab_delete (counts_hash);


@@ -260,7 +281,7 @@ read_counts_file (void)
            }
          else if (entry->summary.num != n_counts)
            {
            }
          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);
                     fn_ident);
              error ("number of counters is %d instead of %d", entry->summary.num, n_counts);
              htab_delete (counts_hash);


@@ -288,14 +309,12 @@ read_counts_file (void)
        }
       gcov_sync (offset, length);
       if ((is_error = gcov_is_error ()))
        }
       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 ();
     }
 
   gcov_close ();


@@ -316,7 +335,7 @@ get_coverage_counts (unsigned counter, unsigned expected,
       static int warned = 0;
 
       if (!warned++)
       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);
                 ? "file %s not found, execution counts estimated"
                 : "file %s not found, execution counts assumed to be zero"),
                da_file_name);


@@ -325,30 +344,50 @@ get_coverage_counts (unsigned counter, unsigned expected,
 
   elt.ident = current_function_funcdef_no + 1;
   elt.ctr = counter;
 
   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)
     {
   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 ();
     }
 
   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)
+  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 ("number of counters is %d instead of %d", entry->summary.num, expected);
-      return 0;
+      static int warned = 0;
+      tree id = DECL_ASSEMBLER_NAME (current_function_decl);
+
+      if (warn_coverage_mismatch)
+       warning (OPT_Wcoverage_mismatch, "coverage mismatch for function "
+                "%qE while reading counter %qs", id, ctr_names[counter]);
+      else
+       error ("coverage mismatch for function %qE while reading counter %qs",
+              id, ctr_names[counter]);
+
+      if (!inhibit_warnings)
+       {
+         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 (warn_coverage_mismatch
+         && !inhibit_warnings
+         && !warned++)
+       {
+         inform (input_location, "coverage mismatch ignored due to -Wcoverage-mismatch");
+         inform (input_location, flag_guess_branch_prob
+                 ? "execution counts estimated"
+                 : "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)
     }
 
   if (summary)


@@ -369,14 +408,25 @@ coverage_counter_alloc (unsigned counter, unsigned num)
   if (!num)
     return 1;
 
   if (!num)
     return 1;
 

-  if (!ctr_labels[counter])
+  if (!tree_ctr_tables[counter])

     {
     {

-      /* Generate and save a copy of this so it can be shared.  */
+      /* 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];
       char buf[20];

-
+      tree gcov_type_node = get_gcov_type ();
+      tree gcov_type_array_type
+        = build_array_type (gcov_type_node, NULL_TREE);
+      tree_ctr_tables[counter]
+        = 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);
       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;
+      DECL_NAME (tree_ctr_tables[counter]) = get_identifier (buf);
+      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;
     }
   fn_b_ctrs[counter] = fn_n_ctrs[counter];
   fn_n_ctrs[counter] += num;


@@ -384,24 +434,38 @@ coverage_counter_alloc (unsigned counter, unsigned num)
   return 1;
 }
 
   return 1;
 }
 

-/* Generate a MEM rtl to access COUNTER NO.  */
+/* Generate a tree to access COUNTER NO.  */
+
+tree
+tree_coverage_counter_ref (unsigned counter, unsigned no)
+{
+  tree gcov_type_node = get_gcov_type ();
+
+  gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]);
+  no += prg_n_ctrs[counter] + fn_b_ctrs[counter];
+
+  /* "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 the address of COUNTER NO.  */

 
 

-rtx
-coverage_counter_ref (unsigned counter, unsigned no)
+tree
+tree_coverage_counter_addr (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];
   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;
+  TREE_ADDRESSABLE (tree_ctr_tables[counter]) = 1;
+
+  /* "no" here is an array index, scaled to bytes later.  */
+  return build_fold_addr_expr (build4 (ARRAY_REF, gcov_type_node,
+                                      tree_ctr_tables[counter],
+                                      build_int_cst (NULL_TREE, no),
+                                      NULL, NULL));

 }
 \f
 /* Generate a checksum for a string.  CHKSUM is the current
 }
 \f
 /* Generate a checksum for a string.  CHKSUM is the current


@@ -414,40 +478,48 @@ coverage_checksum_string (unsigned chksum, const char *string)
   char *dup = NULL;
 
   /* Look for everything that looks if it were produced by
   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++)
     {
      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))
       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);
     }
 
   chksum = crc32_string (chksum, string);


@@ -462,10 +534,11 @@ coverage_checksum_string (unsigned chksum, const char *string)
 static unsigned
 compute_checksum (void)
 {
 static unsigned
 compute_checksum (void)
 {

-  unsigned chksum = DECL_SOURCE_LINE (current_function_decl);
+  expanded_location xloc
+    = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
+  unsigned chksum = xloc.line;

 
 

-  chksum = coverage_checksum_string (chksum,
-                                    DECL_SOURCE_FILE (current_function_decl));
+  chksum = coverage_checksum_string (chksum, xloc.file);

   chksum = coverage_checksum_string
     (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)));
 
   chksum = coverage_checksum_string
     (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)));
 


@@ -480,13 +553,15 @@ compute_checksum (void)
 int
 coverage_begin_output (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)
     {
     return 0;
 
   if (!bbg_function_announced)
     {

-      const char *file = DECL_SOURCE_FILE (current_function_decl);
-      unsigned line = DECL_SOURCE_LINE (current_function_decl);
+      expanded_location xloc
+       = expand_location (DECL_SOURCE_LOCATION (current_function_decl));

       unsigned long offset;
 
       if (!bbg_file_opened)
       unsigned long offset;
 
       if (!bbg_file_opened)


@@ -508,8 +583,8 @@ coverage_begin_output (void)
       gcov_write_unsigned (compute_checksum ());
       gcov_write_string (IDENTIFIER_POINTER
                         (DECL_ASSEMBLER_NAME (current_function_decl)));
       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_string (xloc.file);
+      gcov_write_unsigned (xloc.line);

       gcov_write_length (offset);
 
       bbg_function_announced = 1;
       gcov_write_length (offset);
 
       bbg_function_announced = 1;


@@ -527,7 +602,7 @@ coverage_end_function (void)
 
   if (bbg_file_opened > 1 && gcov_is_error ())
     {
 
   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;
     }
 
       bbg_file_opened = -1;
     }
 


@@ -535,7 +610,7 @@ coverage_end_function (void)
     {
       struct function_list *item;
 
     {
       struct function_list *item;
 

-      item = xmalloc (sizeof (struct function_list));
+      item = XNEW (struct function_list);

 
       *functions_tail = item;
       functions_tail = &item->next;
 
       *functions_tail = item;
       functions_tail = &item->next;


@@ -565,18 +640,22 @@ build_fn_info_type (unsigned int counters)
   tree array_type;
 
   /* ident */
   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 */
 
   /* 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;
 
   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 */
 
   /* 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;
 
   TREE_CHAIN (field) = fields;
   fields = field;
 


@@ -598,33 +677,32 @@ build_fn_info_value (const struct function_list *function, tree type)
   tree array_value = NULL_TREE;
 
   /* ident */
   tree array_value = NULL_TREE;
 
   /* ident */

-  value = tree_cons (fields,
-                    convert (unsigned_intSI_type_node,
-                             build_int_2 (function->ident, 0)),
-                    value);
+  value = tree_cons (fields, build_int_cstu (get_gcov_unsigned_t (),
+                                            function->ident), value);

   fields = TREE_CHAIN (fields);
 
   /* checksum */
   fields = TREE_CHAIN (fields);
 
   /* checksum */

-  value = tree_cons (fields,
-                    convert (unsigned_intSI_type_node,
-                             build_int_2 (function->checksum, 0)),
-                    value);
+  value = tree_cons (fields, build_int_cstu (get_gcov_unsigned_t (),
+                                            function->checksum), value);

   fields = TREE_CHAIN (fields);
 
   /* counters */
   for (ix = 0; ix != GCOV_COUNTERS; ix++)
     if (prg_ctr_mask & (1 << ix))
       {
   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));
+       tree counters = build_int_cstu (get_gcov_unsigned_t (),
+                                       function->n_ctrs[ix]);

 
        array_value = tree_cons (NULL_TREE, counters, array_value);
       }
 
 
        array_value = tree_cons (NULL_TREE, counters, array_value);
       }
 

-  array_value = build_constructor (TREE_TYPE (fields), nreverse (array_value));
+  /* FIXME: use build_constructor directly.  */
+  array_value = build_constructor_from_list (TREE_TYPE (fields),
+                                            nreverse (array_value));

   value = tree_cons (fields, array_value, value);
 
   value = tree_cons (fields, array_value, value);
 

-  value = build_constructor (type, nreverse (value));
+  /* FIXME: use build_constructor directly.  */
+  value = build_constructor_from_list (type, nreverse (value));

 
   return value;
 }
 
   return value;
 }


@@ -636,25 +714,28 @@ build_ctr_info_type (void)
 {
   tree type = lang_hooks.types.make_type (RECORD_TYPE);
   tree field, fields = NULL_TREE;
 {
   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 */
   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 */
   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,
   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);
                              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;
                      build_pointer_type (gcov_merge_fn_type));
   TREE_CHAIN (field) = fields;
   fields = field;


@@ -677,44 +758,50 @@ build_ctr_info_value (unsigned int counter, tree type)
 
   /* counters */
   value = tree_cons (fields,
 
   /* counters */
   value = tree_cons (fields,

-                    convert (unsigned_intSI_type_node,
-                             build_int_2 (prg_n_ctrs[counter], 0)),
+                    build_int_cstu (get_gcov_unsigned_t (),
+                                    prg_n_ctrs[counter]),

                     value);
   fields = TREE_CHAIN (fields);
 
   if (prg_n_ctrs[counter])
     {
                     value);
   fields = TREE_CHAIN (fields);
 
   if (prg_n_ctrs[counter])
     {

-      tree array_type, array;
+      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);
 
       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);
+      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);
+      varpool_finalize_decl (tree_ctr_tables[counter]);

 
       value = tree_cons (fields,
 
       value = tree_cons (fields,

-                        build1 (ADDR_EXPR, TREE_TYPE (fields), array),
+                        build1 (ADDR_EXPR, TREE_TYPE (fields),
+                                           tree_ctr_tables[counter]),

                         value);
     }
   else
     value = tree_cons (fields, null_pointer_node, value);
   fields = TREE_CHAIN (fields);
 
                         value);
     }
   else
     value = tree_cons (fields, null_pointer_node, value);
   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;
                   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;

+  DECL_ASSEMBLER_NAME (fn);  /* Initialize assembler name so we can stream out. */

   value = tree_cons (fields,
                     build1 (ADDR_EXPR, TREE_TYPE (fields), fn),
                     value);
 
   value = tree_cons (fields,
                     build1 (ADDR_EXPR, TREE_TYPE (fields), fn),
                     value);
 

-  value = build_constructor (type, nreverse (value));
+  /* FIXME: use build_constructor directly.  */
+  value = build_constructor_from_list (type, nreverse (value));

 
   return value;
 }
 
   return value;
 }


@@ -733,8 +820,7 @@ build_gcov_info (void)
   tree field, fields = NULL_TREE;
   tree value = NULL_TREE;
   tree filename_string;
   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;
   unsigned n_fns;
   const struct function_list *fn;
   tree string_type;


@@ -748,44 +834,40 @@ build_gcov_info (void)
   const_type = build_qualified_type (type, TYPE_QUAL_CONST);
 
   /* Version ident */
   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;
   TREE_CHAIN (field) = fields;
   fields = field;

-  value = tree_cons (field, convert (unsigned_intSI_type_node,
-                                    build_int_2 (GCOV_VERSION, 0)),
+  value = tree_cons (field, build_int_cstu (TREE_TYPE (field), GCOV_VERSION),

                     value);
 
   /* next -- NULL */
                     value);
 
   /* 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);
 
   /* stamp */
   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);
+  field = build_decl (BUILTINS_LOCATION,
+                     FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());

   TREE_CHAIN (field) = fields;
   fields = field;
   TREE_CHAIN (field) = fields;
   fields = field;

-  value = tree_cons (field, convert (unsigned_intSI_type_node,
-                                    build_int_2 (local_tick, 0)),
+  value = tree_cons (field, build_int_cstu (TREE_TYPE (field), local_tick),

                     value);
 
   /* Filename */
   string_type = build_pointer_type (build_qualified_type (char_type_node,
                                                    TYPE_QUAL_CONST));
                     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);
+  field = build_decl (BUILTINS_LOCATION,
+                     FIELD_DECL, NULL_TREE, string_type);

   TREE_CHAIN (field) = fields;
   fields = field;
   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)));
+  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)));

   value = tree_cons (field, build1 (ADDR_EXPR, string_type, filename_string),
                     value);
 
   value = tree_cons (field, build1 (ADDR_EXPR, string_type, filename_string),
                     value);
 


@@ -801,58 +883,66 @@ build_gcov_info (void)
     {
       tree array_type;
 
     {
       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);
 
       array_type = build_array_type (fn_info_type, array_type);
 

-      fn_info_value = build_constructor (array_type, nreverse (fn_info_value));
+      /* FIXME: use build_constructor directly.  */
+      fn_info_value = build_constructor_from_list (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 */
       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,
   TREE_CHAIN (field) = fields;
   fields = field;
   value = tree_cons (field,

-                    convert (unsigned_type_node, build_int_2 (n_fns, 0)),
+                    build_int_cstu (get_gcov_unsigned_t (), n_fns),

                     value);
 
   /* fn_info table */
                     value);
 
   /* 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);
 
   /* counter_mask */
   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);
+  field = build_decl (BUILTINS_LOCATION,
+                     FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());

   TREE_CHAIN (field) = fields;
   fields = field;
   value = tree_cons (field,
   TREE_CHAIN (field) = fields;
   fields = field;
   value = tree_cons (field,

-                    convert (unsigned_type_node,
-                             build_int_2 (prg_ctr_mask, 0)),
+                    build_int_cstu (get_gcov_unsigned_t (), prg_ctr_mask),

                     value);
 
   /* counters */
   ctr_info_type = build_ctr_info_type ();
                     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_index_type (build_int_cst (NULL_TREE,
+                                                      n_ctr_types));

   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_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));
+  /* FIXME: use build_constructor directly.  */
+  ctr_info_value = build_constructor_from_list (ctr_info_ary_type,
+                                               nreverse (ctr_info_value));

 
 

-  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);
 
   finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE);
 
   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));
+  /* FIXME: use build_constructor directly.  */
+  value = build_constructor_from_list (type, nreverse (value));

 
   return value;
 }
 
   return value;
 }


@@ -864,69 +954,44 @@ build_gcov_info (void)
 static void
 create_coverage (void)
 {
 static void
 create_coverage (void)
 {

-  tree gcov_info, gcov_info_value;
-  char name[20];
-  char *ctor_name;
-  tree ctor;
-  rtx gcov_info_address;
+  tree gcov_info, gcov_init, body, t;
+  char name_buf[32];

 
   no_coverage = 1; /* Disable any further coverage.  */
 
   if (!prg_ctr_mask)
     return;
 
 
   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;
+  t = build_gcov_info ();

 
 

+  gcov_info = build_decl (BUILTINS_LOCATION,
+                         VAR_DECL, NULL_TREE, TREE_TYPE (t));

   TREE_STATIC (gcov_info) = 1;
   TREE_STATIC (gcov_info) = 1;

-  ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 0);
-  DECL_NAME (gcov_info) = get_identifier (name);
+  ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0);
+  DECL_NAME (gcov_info) = get_identifier (name_buf);
+  DECL_INITIAL (gcov_info) = t;

 
   /* Build structure.  */
 
   /* 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;
-
-  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);
+  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 (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 = build_call_expr (gcov_init, 1, t);
+  append_to_statement_list (t, &body);
+
+  /* Generate a constructor to run it.  */
+  cgraph_build_static_cdtor ('I', body, DEFAULT_INIT_PRIORITY);

 }
 \f
 /* Perform file-level initialization. Read in data file, generate name
 }
 \f
 /* Perform file-level initialization. Read in data file, generate name


@@ -936,18 +1001,36 @@ void
 coverage_init (const char *filename)
 {
   int len = strlen (filename);
 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.  */
 
   /* 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.  */
   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);
 
   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
 }
 
 /* Performs file-level cleanup.  Close graph file, generate coverage