* sv.po: Update.

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

diff --git a/gcc/coverage.c b/gcc/coverage.c
index aaec5ed..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, 2005 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, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, 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, 51 Franklin Street, Fifth Floor, 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 "coverage.h"
 #include "langhooks.h"
 #include "hashtab.h"
 #include "tree-iterator.h"
 #include "cgraph.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 "gcov-io.c"
 
 
 #include "gcov-io.c"
 


@@ -140,7 +142,7 @@ get_gcov_unsigned_t (void)
 static hashval_t
 htab_counts_entry_hash (const void *of)
 {
 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;
 }


@@ -148,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;
 }


@@ -157,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);


@@ -199,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);


@@ -333,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);


@@ -342,11 +344,11 @@ 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 (0, "no coverage for function %qs found", IDENTIFIER_POINTER
-              (DECL_ASSEMBLER_NAME (current_function_decl)));
+      warning (0, "no coverage for function %qE found",
+              DECL_ASSEMBLER_NAME (current_function_decl));

       return NULL;
     }
 
       return NULL;
     }
 


@@ -355,22 +357,21 @@ get_coverage_counts (unsigned counter, unsigned expected,
       || entry->summary.num != expected)
     {
       static int warned = 0;
       || entry->summary.num != expected)
     {
       static int warned = 0;

-      const char *id = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
-                        (current_function_decl));
+      tree id = DECL_ASSEMBLER_NAME (current_function_decl);

 
       if (warn_coverage_mismatch)
        warning (OPT_Wcoverage_mismatch, "coverage mismatch for function "
 
       if (warn_coverage_mismatch)
        warning (OPT_Wcoverage_mismatch, "coverage mismatch for function "

-                "%qs while reading counter %qs", id, ctr_names[counter]);
+                "%qE while reading counter %qs", id, ctr_names[counter]);

       else
       else

-       error ("coverage mismatch for function %qs while reading counter %qs",
+       error ("coverage mismatch for function %qE while reading counter %qs",

               id, ctr_names[counter]);
 
       if (!inhibit_warnings)
        {
          if (entry->checksum != checksum)
               id, ctr_names[counter]);
 
       if (!inhibit_warnings)
        {
          if (entry->checksum != checksum)

-           inform ("checksum is %x instead of %x", entry->checksum, checksum);
+           inform (input_location, "checksum is %x instead of %x", entry->checksum, checksum);

          else
          else

-           inform ("number of counters is %d instead of %d",
+           inform (input_location, "number of counters is %d instead of %d",

                    entry->summary.num, expected);
        }
 
                    entry->summary.num, expected);
        }
 


@@ -378,12 +379,12 @@ get_coverage_counts (unsigned counter, unsigned expected,
          && !inhibit_warnings
          && !warned++)
        {
          && !inhibit_warnings
          && !warned++)
        {

-         inform ("coverage mismatch ignored due to -Wcoverage-mismatch");
-         inform (flag_guess_branch_prob
+         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)
                  ? "execution counts estimated"
                  : "execution counts assumed to be zero");
          if (!flag_guess_branch_prob)

-           inform ("this can result in poorly optimized code");
+           inform (input_location, "this can result in poorly optimized code");

        }
 
       return NULL;
        }
 
       return NULL;


@@ -417,11 +418,15 @@ coverage_counter_alloc (unsigned counter, unsigned num)
       tree gcov_type_array_type
         = build_array_type (gcov_type_node, NULL_TREE);
       tree_ctr_tables[counter]
       tree gcov_type_array_type
         = 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);
       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);

+
+      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;


@@ -443,6 +448,25 @@ tree_coverage_counter_ref (unsigned counter, unsigned no)
   return build4 (ARRAY_REF, gcov_type_node, tree_ctr_tables[counter],
                 build_int_cst (NULL_TREE, no), NULL, NULL);
 }
   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.  */
+
+tree
+tree_coverage_counter_addr (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];
+
+  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
    checksum.  */
 \f
 /* Generate a checksum for a string.  CHKSUM is the current
    checksum.  */


@@ -469,7 +493,7 @@ coverage_checksum_string (unsigned chksum, const char *string)
          _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
          _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 magicnuber.  */
+       for magicnumber.  */

       if (offset)
        {
          for (i = i + offset; string[i]; i++)
       if (offset)
        {
          for (i = i + offset; string[i]; i++)


@@ -529,7 +553,9 @@ 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)


@@ -614,10 +640,12 @@ build_fn_info_type (unsigned int counters)
   tree array_type;
 
   /* ident */
   tree array_type;
 
   /* ident */

-  fields = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
+  fields = build_decl (BUILTINS_LOCATION,
+                      FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());

 
   /* checksum */
 
   /* checksum */

-  field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
+  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;
 


@@ -626,7 +654,8 @@ build_fn_info_type (unsigned int counters)
   array_type = build_array_type (get_gcov_unsigned_t (), array_type);
 
   /* counters */
   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;
 
   TREE_CHAIN (field) = fields;
   fields = field;
 


@@ -689,12 +718,14 @@ build_ctr_info_type (void)
   tree gcov_merge_fn_type;
 
   /* counters */
   tree gcov_merge_fn_type;
 
   /* counters */

-  field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
+  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;
 
   TREE_CHAIN (field) = fields;
   fields = field;
 


@@ -703,7 +734,8 @@ build_ctr_info_type (void)
     build_function_type_list (void_type_node,
                              gcov_ptr_type, get_gcov_unsigned_t (),
                              NULL_TREE);
     build_function_type_list (void_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;
                      build_pointer_type (gcov_merge_fn_type));
   TREE_CHAIN (field) = fields;
   fields = field;


@@ -744,10 +776,10 @@ build_ctr_info_value (unsigned int counter, tree 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);
       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,
 
       value = tree_cons (fields,

-                        build1 (ADDR_EXPR, TREE_TYPE (fields), 
+                        build1 (ADDR_EXPR, TREE_TYPE (fields),

                                            tree_ctr_tables[counter]),
                         value);
     }
                                            tree_ctr_tables[counter]),
                         value);
     }


@@ -755,13 +787,15 @@ build_ctr_info_value (unsigned int counter, tree type)
     value = tree_cons (fields, null_pointer_node, value);
   fields = TREE_CHAIN (fields);
 
     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);


@@ -786,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;


@@ -801,20 +834,23 @@ 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, get_gcov_unsigned_t ());
+  field = build_decl (BUILTINS_LOCATION,
+                     FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());

   TREE_CHAIN (field) = fields;
   fields = field;
   value = tree_cons (field, build_int_cstu (TREE_TYPE (field), GCOV_VERSION),
                     value);
 
   /* next -- NULL */
   TREE_CHAIN (field) = fields;
   fields = field;
   value = tree_cons (field, build_int_cstu (TREE_TYPE (field), GCOV_VERSION),
                     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, get_gcov_unsigned_t ());
+  field = build_decl (BUILTINS_LOCATION,
+                     FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());

   TREE_CHAIN (field) = fields;
   fields = field;
   value = tree_cons (field, build_int_cstu (TREE_TYPE (field), local_tick),
   TREE_CHAIN (field) = fields;
   fields = field;
   value = tree_cons (field, build_int_cstu (TREE_TYPE (field), local_tick),


@@ -823,20 +859,15 @@ build_gcov_info (void)
   /* Filename */
   string_type = build_pointer_type (build_qualified_type (char_type_node,
                                                    TYPE_QUAL_CONST));
   /* 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);
+  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
   TREE_TYPE (filename_string) = build_array_type
     (char_type_node, build_index_type

-     (build_int_cst (NULL_TREE, filename_len)));
+     (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);
 


@@ -864,7 +895,8 @@ build_gcov_info (void)
     fn_info_value = null_pointer_node;
 
   /* number of functions */
     fn_info_value = null_pointer_node;
 
   /* number of functions */

-  field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
+  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,


@@ -872,13 +904,15 @@ build_gcov_info (void)
                     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, get_gcov_unsigned_t ());
+  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,


@@ -899,7 +933,8 @@ build_gcov_info (void)
   ctr_info_value = build_constructor_from_list (ctr_info_ary_type,
                                                nreverse (ctr_info_value));
 
   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);
   TREE_CHAIN (field) = fields;
   fields = field;
   value = tree_cons (field, ctr_info_value, value);


@@ -929,21 +964,24 @@ create_coverage (void)
 
   t = build_gcov_info ();
 
 
   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.  */
   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);
 
   /* 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;
   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).  */
   gcov_init = t;
 
   /* Generate a call to __gcov_init(&gcov_info).  */


@@ -963,10 +1001,27 @@ 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 = XNEWVEC (char, 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.  */


@@ -974,7 +1029,8 @@ coverage_init (const char *filename)
   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