CbC/CbC_gcc: gcc/coverage.c comparison

comparison gcc/coverage.c @ 111:04ced10e8804

gcc 7

author	kono
date	Fri, 27 Oct 2017 22:46:09 +0900
parents	f6334be47118
children	84e7813d76e9

comparison

equal deleted inserted replaced

-:561a7518be6b
+:04ced10e8804
 /* Read and write coverage files, and associated functionality.
-Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998, 1999,
+Copyright (C) 1990-2017 Free Software Foundation, Inc.
-2000, 2001, 2003, 2004, 2005, 2007, 2008, 2009, 2010
-Free Software Foundation, Inc.
 Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
 based on some ideas from Dain Samples of UC Berkeley.
 Further mangling by Bob Manson, Cygnus Support.
 Further mangled by Nathan Sidwell, CodeSourcery
 #define GCOV_LINKAGE
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
-#include "tm.h"
+#include "backend.h"
+#include "target.h"
 #include "rtl.h"
 #include "tree.h"
-#include "flags.h"
+#include "tree-pass.h"
+#include "memmodel.h"
+#include "tm_p.h"
+#include "stringpool.h"
+#include "cgraph.h"
+#include "coverage.h"
+#include "diagnostic-core.h"
+#include "fold-const.h"
+#include "stor-layout.h"
 #include "output.h"
-#include "regs.h"
-#include "expr.h"
-#include "function.h"
-#include "basic-block.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 "context.h"
-#include "tree-pass.h"
+#include "pass_manager.h"
-#include "diagnostic-core.h"
 #include "intl.h"
+#include "params.h"
+#include "auto-profile.h"
 #include "gcov-io.c"
-struct function_list
+struct GTY((chain_next ("%h.next"))) coverage_data
 {
-struct function_list *next;	 /* next function */
+struct coverage_data *next;	 /* next function */
 unsigned ident;		 /* function ident */
-unsigned checksum;	         /* function checksum */
+unsigned lineno_checksum;	 /* function lineno checksum */
-unsigned n_ctrs[GCOV_COUNTERS];/* number of counters.  */
+unsigned cfg_checksum;	 /* function cfg checksum */
+tree fn_decl;			 /* the function decl */
+tree ctr_vars[GCOV_COUNTERS];	 /* counter variables.  */
 };
 /* Counts information for a function.  */
-typedef struct counts_entry
+struct counts_entry : pointer_hash <counts_entry>
 {
 /* We hash by  */
 unsigned ident;
 unsigned ctr;
 /* Store  */
-unsigned checksum;
+unsigned lineno_checksum;
+unsigned cfg_checksum;
 gcov_type *counts;
 struct gcov_ctr_summary summary;
-/* Workspace */
+/* hash_table support.  */
-struct counts_entry *chain;
+static inline hashval_t hash (const counts_entry *);
+static int equal (const counts_entry *, const counts_entry *);
-} counts_entry_t;
+static void remove (counts_entry *);
+};
-static struct function_list *functions_head = 0;
-static struct function_list **functions_tail = &functions_head;
+static GTY(()) struct coverage_data *functions_head = 0;
+static struct coverage_data **functions_tail = &functions_head;
 static unsigned no_coverage = 0;
 /* Cumulative counter information for whole program.  */
 static unsigned prg_ctr_mask; /* Mask of counter types generated.  */
-static unsigned prg_n_ctrs[GCOV_COUNTERS]; /* Total counters allocated.  */
 /* Counter information for current function.  */
 static unsigned fn_ctr_mask; /* Mask of counters used.  */
+static GTY(()) tree fn_v_ctrs[GCOV_COUNTERS];   /* counter variables.  */
 static unsigned fn_n_ctrs[GCOV_COUNTERS]; /* Counters allocated.  */
 static unsigned fn_b_ctrs[GCOV_COUNTERS]; /* Allocation base.  */
-/* Name of the output file for coverage output file.  */
+/* Coverage info VAR_DECL and function info type nodes.  */
+static GTY(()) tree gcov_info_var;
+static GTY(()) tree gcov_fn_info_type;
+static GTY(()) tree gcov_fn_info_ptr_type;
+/* Name of the notes (gcno) output file.  The "bbg" prefix is for
+historical reasons, when the notes file contained only the
+basic block graph notes.
+If this is NULL we're not writing to the notes file.  */
 static char *bbg_file_name;
-static unsigned bbg_file_opened;
-static int bbg_function_announced;
+/* File stamp for notes file.  */
+static unsigned bbg_file_stamp;
-/* Name of the count data file.  */
+/* Name of the count data (gcda) file.  */
 static char *da_file_name;
-/* Hash table of count data.  */
-static htab_t counts_hash = NULL;
-/* Trees representing the counter table arrays.  */
-static GTY(()) tree tree_ctr_tables[GCOV_COUNTERS];
 /* The names of merge functions for counters.  */
-static const char *const ctr_merge_functions[GCOV_COUNTERS] = GCOV_MERGE_FUNCTIONS;
+#define STR(str) #str
-static const char *const ctr_names[GCOV_COUNTERS] = GCOV_COUNTER_NAMES;
+#define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) STR(__gcov_merge ## FN_TYPE),
+static const char *const ctr_merge_functions[GCOV_COUNTERS] = {
+#include "gcov-counter.def"
+};
+#undef DEF_GCOV_COUNTER
+#undef STR
+#define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) NAME,
+static const char *const ctr_names[GCOV_COUNTERS] = {
+#include "gcov-counter.def"
+};
+#undef DEF_GCOV_COUNTER
 /* Forward declarations.  */
-static hashval_t htab_counts_entry_hash (const void *);
-static int htab_counts_entry_eq (const void *, const void *);
-static void htab_counts_entry_del (void *);
 static void read_counts_file (void);
-static unsigned compute_checksum (void);
+static tree build_var (tree, tree, int);
-static unsigned coverage_checksum_string (unsigned, const char *);
+static void build_fn_info_type (tree, unsigned, tree);
-static tree build_fn_info_type (unsigned);
+static void build_info_type (tree, tree);
-static tree build_fn_info_value (const struct function_list *, tree);
+static tree build_fn_info (const struct coverage_data *, tree, tree);
-static tree build_ctr_info_type (void);
+static tree build_info (tree, tree);
-static tree build_ctr_info_value (unsigned, tree);
+static bool coverage_obj_init (void);
-static tree build_gcov_info (void);
+static vec<constructor_elt, va_gc> *coverage_obj_fn
-static void create_coverage (void);
+(vec<constructor_elt, va_gc> *, tree, struct coverage_data const *);
+static void coverage_obj_finish (vec<constructor_elt, va_gc> *);
 /* Return the type node for gcov_type.  */
 tree
 get_gcov_type (void)
 {
-return lang_hooks.types.type_for_size (GCOV_TYPE_SIZE, false);
+scalar_int_mode mode
+= smallest_int_mode_for_size (LONG_LONG_TYPE_SIZE > 32 ? 64 : 32);
+return lang_hooks.types.type_for_mode (mode, 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);
+scalar_int_mode mode = smallest_int_mode_for_size (32);
+return lang_hooks.types.type_for_mode (mode, true);
 }
-static hashval_t
+inline hashval_t
-htab_counts_entry_hash (const void *of)
+counts_entry::hash (const counts_entry *entry)
 {
-const counts_entry_t *const entry = (const counts_entry_t *) of;
 return entry->ident * GCOV_COUNTERS + entry->ctr;
 }
-static int
+inline int
-htab_counts_entry_eq (const void *of1, const void *of2)
+counts_entry::equal (const counts_entry *entry1, const counts_entry *entry2)
 {
-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;
 }
-static void
+inline void
-htab_counts_entry_del (void *of)
+counts_entry::remove (counts_entry *entry)
 {
-counts_entry_t *const entry = (counts_entry_t *) of;
 free (entry->counts);
 free (entry);
 }
+/* Hash table of count data.  */
+static hash_table<counts_entry> *counts_hash;
 /* Read in the counts file, if available.  */
 static void
 read_counts_file (void)
 {
 gcov_unsigned_t fn_ident = 0;
-gcov_unsigned_t checksum = -1;
+struct gcov_summary summary;
-counts_entry_t *summaried = NULL;
+unsigned new_summary = 1;
-unsigned seen_summary = 0;
 gcov_unsigned_t tag;
 int is_error = 0;
+unsigned lineno_checksum = 0;
+unsigned cfg_checksum = 0;
 if (!gcov_open (da_file_name, 1))
 return;
 if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC))
 	       da_file_name, 4, v, 4, e);
 gcov_close ();
 return;
 }
-/* Read and discard the stamp.  */
+/* Read the stamp, used for creating a generation count.  */
-gcov_read_unsigned ();
+tag = gcov_read_unsigned ();
+bbg_file_stamp = crc32_unsigned (bbg_file_stamp, tag);
-counts_hash = htab_create (10,
-			     htab_counts_entry_hash, htab_counts_entry_eq,
+counts_hash = new hash_table<counts_entry> (10);
-			     htab_counts_entry_del);
 while ((tag = gcov_read_unsigned ()))
 {
 gcov_unsigned_t length;
 gcov_position_t offset;
 length = gcov_read_unsigned ();
 offset = gcov_position ();
 if (tag == GCOV_TAG_FUNCTION)
 	{
-	  fn_ident = gcov_read_unsigned ();
+	  if (length)
-	  checksum = gcov_read_unsigned ();
-	  if (seen_summary)
 	    {
-	      /* We have already seen a summary, this means that this
+	      fn_ident = gcov_read_unsigned ();
-		 new function begins a new set of program runs. We
+	      lineno_checksum = gcov_read_unsigned ();
-		 must unlink the summaried chain.  */
+	      cfg_checksum = gcov_read_unsigned ();
-	      counts_entry_t *entry, *chain;
-	      for (entry = summaried; entry; entry = chain)
-		{
-		  chain = entry->chain;
-		  entry->chain = NULL;
-		}
-	      summaried = NULL;
-	      seen_summary = 0;
 	    }
+	  else
+	    fn_ident = lineno_checksum = cfg_checksum = 0;
+	  new_summary = 1;
 	}
 else if (tag == GCOV_TAG_PROGRAM_SUMMARY)
 	{
-	  counts_entry_t *entry;
+	  struct gcov_summary sum;
-	  struct gcov_summary summary;
+	  unsigned ix;
-	  gcov_read_summary (&summary);
+	  if (new_summary)
-	  seen_summary = 1;
+	    memset (&summary, 0, sizeof (summary));
-	  for (entry = summaried; entry; entry = entry->chain)
+	  gcov_read_summary (&sum);
+	  for (ix = 0; ix != GCOV_COUNTERS_SUMMABLE; ix++)
 	    {
-	      struct gcov_ctr_summary *csum = &summary.ctrs[entry->ctr];
+	      summary.ctrs[ix].runs += sum.ctrs[ix].runs;
+	      summary.ctrs[ix].sum_all += sum.ctrs[ix].sum_all;
-	      entry->summary.runs += csum->runs;
+	      if (summary.ctrs[ix].run_max < sum.ctrs[ix].run_max)
-	      entry->summary.sum_all += csum->sum_all;
+		summary.ctrs[ix].run_max = sum.ctrs[ix].run_max;
-	      if (entry->summary.run_max < csum->run_max)
+	      summary.ctrs[ix].sum_max += sum.ctrs[ix].sum_max;
-		entry->summary.run_max = csum->run_max;
-	      entry->summary.sum_max += csum->sum_max;
 	    }
+if (new_summary)
+memcpy (summary.ctrs[GCOV_COUNTER_ARCS].histogram,
+sum.ctrs[GCOV_COUNTER_ARCS].histogram,
+sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
+else
+gcov_histogram_merge (summary.ctrs[GCOV_COUNTER_ARCS].histogram,
+sum.ctrs[GCOV_COUNTER_ARCS].histogram);
+	  new_summary = 0;
 	}
 else if (GCOV_TAG_IS_COUNTER (tag) && fn_ident)
 	{
-	  counts_entry_t **slot, *entry, elt;
+	  counts_entry **slot, *entry, elt;
 	  unsigned n_counts = GCOV_TAG_COUNTER_NUM (length);
 	  unsigned ix;
 	  elt.ident = fn_ident;
 	  elt.ctr = GCOV_COUNTER_FOR_TAG (tag);
-	  slot = (counts_entry_t **) htab_find_slot
+	  slot = counts_hash->find_slot (&elt, INSERT);
-	    (counts_hash, &elt, INSERT);
 	  entry = *slot;
 	  if (!entry)
 	    {
-	      *slot = entry = XCNEW (counts_entry_t);
+	      *slot = entry = XCNEW (counts_entry);
-	      entry->ident = elt.ident;
+	      entry->ident = fn_ident;
 	      entry->ctr = elt.ctr;
-	      entry->checksum = checksum;
+	      entry->lineno_checksum = lineno_checksum;
-	      entry->summary.num = n_counts;
+	      entry->cfg_checksum = cfg_checksum;
+if (elt.ctr < GCOV_COUNTERS_SUMMABLE)
+entry->summary = summary.ctrs[elt.ctr];
+entry->summary.num = n_counts;
 	      entry->counts = XCNEWVEC (gcov_type, n_counts);
 	    }
-	  else if (entry->checksum != checksum)
+	  else if (entry->lineno_checksum != lineno_checksum
+		   || entry->cfg_checksum != cfg_checksum)
 	    {
-	      error ("coverage mismatch for function %u while reading execution counters",
+	      error ("Profile data for function %u is corrupted", fn_ident);
-		     fn_ident);
+	      error ("checksum is (%x,%x) instead of (%x,%x)",
-	      error ("checksum is %x instead of %x", entry->checksum, checksum);
+		     entry->lineno_checksum, entry->cfg_checksum,
-	      htab_delete (counts_hash);
+		     lineno_checksum, cfg_checksum);
+	      delete counts_hash;
+	      counts_hash = NULL;
 	      break;
 	    }
 	  else if (entry->summary.num != n_counts)
 	    {
-	      error ("coverage mismatch for function %u while reading execution counters",
+	      error ("Profile data for function %u is corrupted", fn_ident);
-		     fn_ident);
 	      error ("number of counters is %d instead of %d", entry->summary.num, n_counts);
-	      htab_delete (counts_hash);
+	      delete counts_hash;
+	      counts_hash = NULL;
 	      break;
 	    }
 	  else if (elt.ctr >= GCOV_COUNTERS_SUMMABLE)
 	    {
 	      error ("cannot merge separate %s counters for function %u",
 		     ctr_names[elt.ctr], fn_ident);
 	      goto skip_merge;
 	    }
+	  else
-	  if (elt.ctr < GCOV_COUNTERS_SUMMABLE
-	      /* This should always be true for a just allocated entry,
-		 and always false for an existing one. Check this way, in
-		 case the gcov file is corrupt.  */
-	      && (!entry->chain || summaried != entry))
 	    {
-	      entry->chain = summaried;
+	      entry->summary.runs += summary.ctrs[elt.ctr].runs;
-	      summaried = entry;
+	      entry->summary.sum_all += summary.ctrs[elt.ctr].sum_all;
+	      if (entry->summary.run_max < summary.ctrs[elt.ctr].run_max)
+		entry->summary.run_max = summary.ctrs[elt.ctr].run_max;
+	      entry->summary.sum_max += summary.ctrs[elt.ctr].sum_max;
 	    }
 	  for (ix = 0; ix != n_counts; ix++)
 	    entry->counts[ix] += gcov_read_counter ();
 	skip_merge:;
 	}
 gcov_sync (offset, length);
 if ((is_error = gcov_is_error ()))
 	{
-	  error (is_error < 0 ? "%qs has overflowed" : "%qs is corrupted",
+	  error (is_error < 0
+		 ? G_("%qs has overflowed")
+		 : G_("%qs is corrupted"),
 		 da_file_name);
-	  htab_delete (counts_hash);
+	  delete counts_hash;
+	  counts_hash = NULL;
 	  break;
 	}
 }
 gcov_close ();
 /* Returns the counters for a particular tag.  */
 gcov_type *
 get_coverage_counts (unsigned counter, unsigned expected,
+unsigned cfg_checksum, unsigned lineno_checksum,
 		     const struct gcov_ctr_summary **summary)
 {
-counts_entry_t *entry, elt;
+counts_entry *entry, elt;
-gcov_unsigned_t checksum = -1;
 /* No hash table, no counts.  */
 if (!counts_hash)
 {
 static int warned = 0;
-if (!warned++)
+if (!warned++ && dump_enabled_p ())
-	inform (input_location, (flag_guess_branch_prob
+	dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, input_location,
-		 ? "file %s not found, execution counts estimated"
+(flag_guess_branch_prob
-		 : "file %s not found, execution counts assumed to be zero"),
+? "file %s not found, execution counts estimated\n"
-		da_file_name);
+: "file %s not found, execution counts assumed to "
+"be zero\n"),
+da_file_name);
 return NULL;
 }
+if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID))
 elt.ident = current_function_funcdef_no + 1;
+else
+{
+gcc_assert (coverage_node_map_initialized_p ());
+elt.ident = cgraph_node::get (cfun->decl)->profile_id;
+}
 elt.ctr = counter;
-entry = (counts_entry_t *) htab_find (counts_hash, &elt);
+entry = counts_hash->find (&elt);
-if (!entry)
+if (!entry || !entry->summary.num)
-{
+/* The function was not emitted, or is weak and not chosen in the
-warning (0, "no coverage for function %qE found",
+final executable.  Silently fail, because there's nothing we
-	       DECL_ASSEMBLER_NAME (current_function_decl));
+can do about it.  */
 return NULL;
-}
+if (entry->cfg_checksum != cfg_checksum
-checksum = compute_checksum ();
-if (entry->checksum != checksum
 || entry->summary.num != expected)
 {
 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 "
+		    "the control flow of function %qE does not match "
-		    "%qE while reading counter %qs", id, ctr_names[counter]);
+		    "its profile data (counter %qs)", id, ctr_names[counter]);
-if (warning_printed)
+if (warning_printed && dump_enabled_p ())
 	{
-	  if (entry->checksum != checksum)
+dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, input_location,
-	    inform (input_location, "checksum is %x instead of %x",
+"use -Wno-error=coverage-mismatch to tolerate "
-		    entry->checksum, checksum);
+"the mismatch but performance may drop if the "
-	  else
+"function is hot\n");
-	    inform (input_location, "number of counters is %d instead of %d",
-		    entry->summary.num, expected);
 	  if (!seen_error ()
 	      && !warned++)
 	    {
-	      inform (input_location, "coverage mismatch ignored");
+	      dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, input_location,
-	      inform (input_location, flag_guess_branch_prob
+"coverage mismatch ignored\n");
-		      ? G_("execution counts estimated")
+	      dump_printf (MSG_OPTIMIZED_LOCATIONS,
-		      : G_("execution counts assumed to be zero"));
+flag_guess_branch_prob
+? G_("execution counts estimated\n")
+: G_("execution counts assumed to be zero\n"));
 	      if (!flag_guess_branch_prob)
-		inform (input_location,
+		dump_printf (MSG_OPTIMIZED_LOCATIONS,
-			"this can result in poorly optimized code");
+"this can result in poorly optimized code\n");
 	    }
 	}
 return NULL;
 }
+else if (entry->lineno_checksum != lineno_checksum)
+{
+warning (OPT_Wcoverage_mismatch,
+"source locations for function %qE have changed,"
+	       " the profile data may be out of date",
+	       DECL_ASSEMBLER_NAME (current_function_decl));
+}
 if (summary)
 *summary = &entry->summary;
 return entry->counts;
 return 0;
 if (!num)
 return 1;
-if (!tree_ctr_tables[counter])
+if (!fn_v_ctrs[counter])
 {
-/* Generate and save a copy of this so it can be shared.  Leave
+tree array_type = build_array_type (get_gcov_type (), NULL_TREE);
-	 the index type unspecified for now; it will be set after all
-	 functions have been compiled.  */
+fn_v_ctrs[counter]
-char buf[20];
+	= build_var (current_function_decl, array_type, counter);
-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);
-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_ctr_mask |= 1 << counter;
 return 1;
 }
 /* Generate a tree to access COUNTER NO.  */
 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 += 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],
+return build4 (ARRAY_REF, gcov_type_node, fn_v_ctrs[counter],
-		 build_int_cst (NULL_TREE, no), NULL, NULL);
+		 build_int_cst (integer_type_node, 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];
+no += 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],
+				       fn_v_ctrs[counter],
-				       build_int_cst (NULL_TREE, no),
+				       build_int_cst (integer_type_node, no),
 				       NULL, NULL));
 }
 /* Generate a checksum for a string.  CHKSUM is the current
 checksum.  */
 static unsigned
 coverage_checksum_string (unsigned chksum, const char *string)
 	  break;
 	}
 }
 chksum = crc32_string (chksum, string);
-if (dup)
+free (dup);
-free (dup);
 return chksum;
 }
 /* Compute checksum for the current function.  We generate a CRC32.  */
-static unsigned
+unsigned
-compute_checksum (void)
+coverage_compute_lineno_checksum (void)
 {
 expanded_location xloc
 = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
 unsigned chksum = xloc.line;
-chksum = coverage_checksum_string (chksum, xloc.file);
+if (xloc.file)
+chksum = coverage_checksum_string (chksum, xloc.file);
 chksum = coverage_checksum_string
 (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)));
 return chksum;
 }
+/* Compute profile ID.  This is better to be unique in whole program.  */
+unsigned
+coverage_compute_profile_id (struct cgraph_node *n)
+{
+unsigned chksum;
+/* Externally visible symbols have unique name.  */
+if (TREE_PUBLIC (n->decl) || DECL_EXTERNAL (n->decl) || n->unique_name)
+{
+chksum = coverage_checksum_string
+	(0, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n->decl)));
+}
+else
+{
+expanded_location xloc
+	= expand_location (DECL_SOURCE_LOCATION (n->decl));
+bool use_name_only = (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID) == 0);
+chksum = (use_name_only ? 0 : xloc.line);
+if (xloc.file)
+	chksum = coverage_checksum_string (chksum, xloc.file);
+chksum = coverage_checksum_string
+	(chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n->decl)));
+if (!use_name_only && first_global_object_name)
+	chksum = coverage_checksum_string
+	  (chksum, first_global_object_name);
+chksum = coverage_checksum_string
+	(chksum, aux_base_name);
+}
+/* Non-negative integers are hopefully small enough to fit in all targets.
+Gcov file formats wants non-zero function IDs.  */
+chksum = chksum & 0x7fffffff;
+return chksum + (!chksum);
+}
+/* Compute cfg checksum for the function FN given as argument.
+The checksum is calculated carefully so that
+source code changes that doesn't affect the control flow graph
+won't change the checksum.
+This is to make the profile data useable across source code change.
+The downside of this is that the compiler may use potentially
+wrong profile data - that the source code change has non-trivial impact
+on the validity of profile data (e.g. the reversed condition)
+but the compiler won't detect the change and use the wrong profile data.  */
+unsigned
+coverage_compute_cfg_checksum (struct function *fn)
+{
+basic_block bb;
+unsigned chksum = n_basic_blocks_for_fn (fn);
+FOR_EACH_BB_FN (bb, fn)
+{
+edge e;
+edge_iterator ei;
+chksum = crc32_byte (chksum, bb->index);
+FOR_EACH_EDGE (e, ei, bb->succs)
+{
+chksum = crc32_byte (chksum, e->dest->index);
+}
+}
+return chksum;
+}
-/* Begin output to the graph file for the current function.
+/* Begin output to the notes file for the current function.
-Opens the output file, if not already done. Writes the
+Writes the function header. Returns nonzero if data should be output.  */
-function header, if not already done. Returns nonzero if data
-should be output.  */
 int
-coverage_begin_output (void)
+coverage_begin_function (unsigned lineno_checksum, unsigned cfg_checksum)
 {
+expanded_location xloc;
+unsigned long offset;
 /* 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)
+if (no_coverage || !bbg_file_name)
 return 0;
-if (!bbg_function_announced)
+xloc = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
-{
-expanded_location xloc
+/* Announce function */
-	= expand_location (DECL_SOURCE_LOCATION (current_function_decl));
+offset = gcov_write_tag (GCOV_TAG_FUNCTION);
-unsigned long offset;
+if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID))
+gcov_write_unsigned (current_function_funcdef_no + 1);
-if (!bbg_file_opened)
+else
-	{
+{
-	  if (!gcov_open (bbg_file_name, -1))
+gcc_assert (coverage_node_map_initialized_p ());
-	    error ("cannot open %s", bbg_file_name);
+gcov_write_unsigned (
-	  else
+cgraph_node::get (current_function_decl)->profile_id);
-	    {
+}
-	      gcov_write_unsigned (GCOV_NOTE_MAGIC);
-	      gcov_write_unsigned (GCOV_VERSION);
+gcov_write_unsigned (lineno_checksum);
-	      gcov_write_unsigned (local_tick);
+gcov_write_unsigned (cfg_checksum);
-	    }
+gcov_write_string (IDENTIFIER_POINTER
-	  bbg_file_opened = 1;
+		     (DECL_ASSEMBLER_NAME (current_function_decl)));
-	}
+gcov_write_filename (xloc.file);
+gcov_write_unsigned (xloc.line);
-/* Announce function */
+gcov_write_length (offset);
-offset = gcov_write_tag (GCOV_TAG_FUNCTION);
-gcov_write_unsigned (current_function_funcdef_no + 1);
-gcov_write_unsigned (compute_checksum ());
-gcov_write_string (IDENTIFIER_POINTER
-			 (DECL_ASSEMBLER_NAME (current_function_decl)));
-gcov_write_string (xloc.file);
-gcov_write_unsigned (xloc.line);
-gcov_write_length (offset);
-bbg_function_announced = 1;
-}
 return !gcov_is_error ();
 }
 /* Finish coverage data for the current function. Verify no output
 error has occurred.  Save function coverage counts.  */
 void
-coverage_end_function (void)
+coverage_end_function (unsigned lineno_checksum, unsigned cfg_checksum)
 {
 unsigned i;
-if (bbg_file_opened > 1 && gcov_is_error ())
+if (bbg_file_name && gcov_is_error ())
 {
 warning (0, "error writing %qs", bbg_file_name);
-bbg_file_opened = -1;
+unlink (bbg_file_name);
+bbg_file_name = NULL;
 }
 if (fn_ctr_mask)
 {
-struct function_list *item;
+struct coverage_data *item = 0;
-item = XNEW (struct function_list);
+item = ggc_alloc<coverage_data> ();
+if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID))
+	item->ident = current_function_funcdef_no + 1;
+else
+	{
+	  gcc_assert (coverage_node_map_initialized_p ());
+	  item->ident = cgraph_node::get (cfun->decl)->profile_id;
+	}
+item->lineno_checksum = lineno_checksum;
+item->cfg_checksum = cfg_checksum;
+item->fn_decl = current_function_decl;
+item->next = 0;
 *functions_tail = item;
 functions_tail = &item->next;
-item->next = 0;
-item->ident = current_function_funcdef_no + 1;
-item->checksum = compute_checksum ();
 for (i = 0; i != GCOV_COUNTERS; i++)
 	{
-	  item->n_ctrs[i] = fn_n_ctrs[i];
+	  tree var = fn_v_ctrs[i];
-	  prg_n_ctrs[i] += fn_n_ctrs[i];
-	  fn_n_ctrs[i] = fn_b_ctrs[i] = 0;
+	  if (item)
+	    item->ctr_vars[i] = var;
+	  if (var)
+	    {
+	      tree array_type = build_index_type (size_int (fn_n_ctrs[i] - 1));
+	      array_type = build_array_type (get_gcov_type (), array_type);
+	      TREE_TYPE (var) = array_type;
+	      DECL_SIZE (var) = TYPE_SIZE (array_type);
+	      DECL_SIZE_UNIT (var) = TYPE_SIZE_UNIT (array_type);
+	      varpool_node::finalize_decl (var);
+	    }
+	  fn_b_ctrs[i] = fn_n_ctrs[i] = 0;
+	  fn_v_ctrs[i] = NULL_TREE;
 	}
 prg_ctr_mask |= fn_ctr_mask;
 fn_ctr_mask = 0;
 }
-bbg_function_announced = 0;
+}
+/* Remove coverage file if opened.  */
+void
+coverage_remove_note_file (void)
+{
+if (bbg_file_name)
+{
+gcov_close ();
+unlink (bbg_file_name);
+}
+}
+/* Build a coverage variable of TYPE for function FN_DECL.  If COUNTER
+>= 0 it is a counter array, otherwise it is the function structure.  */
+static tree
+build_var (tree fn_decl, tree type, int counter)
+{
+tree var = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL_TREE, type);
+const char *fn_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn_decl));
+char *buf;
+size_t fn_name_len, len;
+fn_name = targetm.strip_name_encoding (fn_name);
+fn_name_len = strlen (fn_name);
+buf = XALLOCAVEC (char, fn_name_len + 8 + sizeof (int) * 3);
+if (counter < 0)
+strcpy (buf, "__gcov__");
+else
+sprintf (buf, "__gcov%u_", counter);
+len = strlen (buf);
+buf[len - 1] = symbol_table::symbol_suffix_separator ();
+memcpy (buf + len, fn_name, fn_name_len + 1);
+DECL_NAME (var) = get_identifier (buf);
+TREE_STATIC (var) = 1;
+TREE_ADDRESSABLE (var) = 1;
+DECL_NONALIASED (var) = 1;
+SET_DECL_ALIGN (var, TYPE_ALIGN (type));
+return var;
 }
 /* Creates the gcov_fn_info RECORD_TYPE.  */
-static tree
+static void
-build_fn_info_type (unsigned int counters)
+build_fn_info_type (tree type, unsigned counters, tree gcov_info_type)
 {
-tree type = lang_hooks.types.make_type (RECORD_TYPE);
+tree ctr_info = lang_hooks.types.make_type (RECORD_TYPE);
 tree field, fields;
 tree array_type;
-/* ident */
+gcc_assert (counters);
-fields = build_decl (BUILTINS_LOCATION,
-		       FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
+/* ctr_info::num */
+field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
-/* checksum */
+		      get_gcov_unsigned_t ());
-field = build_decl (BUILTINS_LOCATION,
+fields = field;
-		      FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
+/* ctr_info::values */
+field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
+		      build_pointer_type (get_gcov_type ()));
 DECL_CHAIN (field) = fields;
 fields = field;
-array_type = build_int_cst (NULL_TREE, counters - 1);
+finish_builtin_struct (ctr_info, "__gcov_ctr_info", fields, NULL_TREE);
-array_type = build_index_type (array_type);
-array_type = build_array_type (get_gcov_unsigned_t (), array_type);
+/* key */
+field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
-/* counters */
+		      build_pointer_type (build_qualified_type
-field = build_decl (BUILTINS_LOCATION,
+					  (gcov_info_type, TYPE_QUAL_CONST)));
-		      FIELD_DECL, NULL_TREE, array_type);
+fields = field;
+/* ident */
+field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
+		      get_gcov_unsigned_t ());
 DECL_CHAIN (field) = fields;
 fields = field;
+/* lineno_checksum */
+field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
+		      get_gcov_unsigned_t ());
+DECL_CHAIN (field) = fields;
+fields = field;
+/* cfg checksum */
+field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
+		      get_gcov_unsigned_t ());
+DECL_CHAIN (field) = fields;
+fields = field;
+array_type = build_index_type (size_int (counters - 1));
+array_type = build_array_type (ctr_info, array_type);
+/* counters */
+field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, array_type);
+DECL_CHAIN (field) = fields;
+fields = field;
 finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE);
+}
-return type;
-}
+/* Returns a CONSTRUCTOR for a gcov_fn_info.  DATA is
+the coverage data for the function and TYPE is the gcov_fn_info
-/* Creates a CONSTRUCTOR for a gcov_fn_info. FUNCTION is
+RECORD_TYPE.  KEY is the object file key.  */
-the function being processed and TYPE is the gcov_fn_info
-RECORD_TYPE.  */
 static tree
-build_fn_info_value (const struct function_list *function, tree type)
+build_fn_info (const struct coverage_data *data, tree type, tree key)
 {
 tree fields = TYPE_FIELDS (type);
+tree ctr_type;
 unsigned ix;
-VEC(constructor_elt,gc) *v1 = NULL;
+vec<constructor_elt, va_gc> *v1 = NULL;
-VEC(constructor_elt,gc) *v2 = NULL;
+vec<constructor_elt, va_gc> *v2 = NULL;
+/* key */
+CONSTRUCTOR_APPEND_ELT (v1, fields,
+			  build1 (ADDR_EXPR, TREE_TYPE (fields), key));
+fields = DECL_CHAIN (fields);
 /* ident */
 CONSTRUCTOR_APPEND_ELT (v1, fields,
 			  build_int_cstu (get_gcov_unsigned_t (),
-					  function->ident));
+					  data->ident));
 fields = DECL_CHAIN (fields);
-/* checksum */
+/* lineno_checksum */
 CONSTRUCTOR_APPEND_ELT (v1, fields,
 			  build_int_cstu (get_gcov_unsigned_t (),
-					  function->checksum));
+					  data->lineno_checksum));
 fields = DECL_CHAIN (fields);
+/* cfg_checksum */
+CONSTRUCTOR_APPEND_ELT (v1, fields,
+			  build_int_cstu (get_gcov_unsigned_t (),
+					  data->cfg_checksum));
+fields = DECL_CHAIN (fields);
 /* counters */
+ctr_type = TREE_TYPE (TREE_TYPE (fields));
 for (ix = 0; ix != GCOV_COUNTERS; ix++)
 if (prg_ctr_mask & (1 << ix))
-CONSTRUCTOR_APPEND_ELT (v2, NULL,
+{
-			      build_int_cstu (get_gcov_unsigned_t (),
+	vec<constructor_elt, va_gc> *ctr = NULL;
-					      function->n_ctrs[ix]));
+	tree var = data->ctr_vars[ix];
+	unsigned count = 0;
+	if (var)
+	  count
+	    = tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (var))))
+	    + 1;
+	CONSTRUCTOR_APPEND_ELT (ctr, TYPE_FIELDS (ctr_type),
+				build_int_cstu (get_gcov_unsigned_t (),
+						count));
+	if (var)
+	  CONSTRUCTOR_APPEND_ELT (ctr, DECL_CHAIN (TYPE_FIELDS (ctr_type)),
+				  build_fold_addr_expr (var));
+	CONSTRUCTOR_APPEND_ELT (v2, NULL, build_constructor (ctr_type, ctr));
+}
 CONSTRUCTOR_APPEND_ELT (v1, fields,
 			  build_constructor (TREE_TYPE (fields), v2));
 return build_constructor (type, v1);
 }
-/* Creates the gcov_ctr_info RECORD_TYPE.  */
+/* Create gcov_info struct.  TYPE is the incomplete RECORD_TYPE to be
+completed, and FN_INFO_PTR_TYPE is a pointer to the function info type.  */
-static tree
-build_ctr_info_type (void)
+static void
-{
+build_info_type (tree type, tree fn_info_ptr_type)
-tree type = lang_hooks.types.make_type (RECORD_TYPE);
+{
 tree field, fields = NULL_TREE;
-tree gcov_ptr_type = build_pointer_type (get_gcov_type ());
+tree merge_fn_type;
-tree gcov_merge_fn_type;
+/* Version ident */
-/* counters */
+field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
-field = build_decl (BUILTINS_LOCATION,
+		      get_gcov_unsigned_t ());
-		      FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
 DECL_CHAIN (field) = fields;
 fields = field;
-/* values */
+/* next pointer */
-field = build_decl (BUILTINS_LOCATION,
+field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
-		      FIELD_DECL, NULL_TREE, gcov_ptr_type);
+		      build_pointer_type (build_qualified_type
+					  (type, TYPE_QUAL_CONST)));
 DECL_CHAIN (field) = fields;
 fields = field;
-/* merge */
+/* stamp */
-gcov_merge_fn_type =
+field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
-build_function_type_list (void_type_node,
+		      get_gcov_unsigned_t ());
-			      gcov_ptr_type, get_gcov_unsigned_t (),
-			      NULL_TREE);
-field = build_decl (BUILTINS_LOCATION,
-		      FIELD_DECL, NULL_TREE,
-		      build_pointer_type (gcov_merge_fn_type));
 DECL_CHAIN (field) = fields;
 fields = field;
-finish_builtin_struct (type, "__gcov_ctr_info", fields, NULL_TREE);
+/* Filename */
+field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
-return type;
+		      build_pointer_type (build_qualified_type
-}
+					  (char_type_node, TYPE_QUAL_CONST)));
+DECL_CHAIN (field) = fields;
-/* Creates a CONSTRUCTOR for a gcov_ctr_info. COUNTER is
+fields = field;
-the counter being processed and TYPE is the gcov_ctr_info
-RECORD_TYPE.  */
+/* merge fn array */
+merge_fn_type
+= build_function_type_list (void_type_node,
+				build_pointer_type (get_gcov_type ()),
+				get_gcov_unsigned_t (), NULL_TREE);
+merge_fn_type
+= build_array_type (build_pointer_type (merge_fn_type),
+			build_index_type (size_int (GCOV_COUNTERS - 1)));
+field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
+		      merge_fn_type);
+DECL_CHAIN (field) = fields;
+fields = field;
+/* n_functions */
+field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
+		      get_gcov_unsigned_t ());
+DECL_CHAIN (field) = fields;
+fields = field;
+/* function_info pointer pointer */
+fn_info_ptr_type = build_pointer_type
+(build_qualified_type (fn_info_ptr_type, TYPE_QUAL_CONST));
+field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
+		      fn_info_ptr_type);
+DECL_CHAIN (field) = fields;
+fields = field;
+finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE);
+}
+/* Returns a CONSTRUCTOR for the gcov_info object.  INFO_TYPE is the
+gcov_info structure type, FN_ARY is the array of pointers to
+function info objects.  */
 static tree
-build_ctr_info_value (unsigned int counter, tree type)
+build_info (tree info_type, tree fn_ary)
 {
-tree fields = TYPE_FIELDS (type);
+tree info_fields = TYPE_FIELDS (info_type);
-tree fn;
+tree merge_fn_type, n_funcs;
-VEC(constructor_elt,gc) *v = NULL;
+unsigned ix;
-/* counters */
-CONSTRUCTOR_APPEND_ELT (v, fields,
-			  build_int_cstu (get_gcov_unsigned_t (),
-					  prg_n_ctrs[counter]));
-fields = DECL_CHAIN (fields);
-if (prg_n_ctrs[counter])
-{
-tree array_type;
-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);
-varpool_finalize_decl (tree_ctr_tables[counter]);
-CONSTRUCTOR_APPEND_ELT (v, fields,
-			      build1 (ADDR_EXPR, TREE_TYPE (fields),
-				      tree_ctr_tables[counter]));
-}
-else
-CONSTRUCTOR_APPEND_ELT (v, fields, null_pointer_node);
-fields = DECL_CHAIN (fields);
-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;
-DECL_ASSEMBLER_NAME (fn);  /* Initialize assembler name so we can stream out. */
-CONSTRUCTOR_APPEND_ELT (v, fields, build1 (ADDR_EXPR, TREE_TYPE (fields), fn));
-return build_constructor (type, v);
-}
-/* Creates the gcov_info RECORD_TYPE and initializer for it. Returns a
-CONSTRUCTOR.  */
-static tree
-build_gcov_info (void)
-{
-unsigned n_ctr_types, ix;
-tree type, const_type;
-tree fn_info_type, fn_info_value = NULL_TREE;
-tree fn_info_ptr_type;
-tree ctr_info_type, ctr_info_ary_type, ctr_info_value = NULL_TREE;
-tree field, fields = NULL_TREE;
 tree filename_string;
 int da_file_name_len;
-unsigned n_fns;
+vec<constructor_elt, va_gc> *v1 = NULL;
-const struct function_list *fn;
+vec<constructor_elt, va_gc> *v2 = NULL;
-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++)
-if (prg_ctr_mask & (1 << ix))
-n_ctr_types++;
-type = lang_hooks.types.make_type (RECORD_TYPE);
-const_type = build_qualified_type (type, TYPE_QUAL_CONST);
 /* Version ident */
-field = build_decl (BUILTINS_LOCATION,
+CONSTRUCTOR_APPEND_ELT (v1, info_fields,
-		      FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
+			  build_int_cstu (TREE_TYPE (info_fields),
-DECL_CHAIN (field) = fields;
+					  GCOV_VERSION));
-fields = field;
+info_fields = DECL_CHAIN (info_fields);
-CONSTRUCTOR_APPEND_ELT (v1, field,
-			  build_int_cstu (TREE_TYPE (field), GCOV_VERSION));
 /* next -- NULL */
-field = build_decl (BUILTINS_LOCATION,
+CONSTRUCTOR_APPEND_ELT (v1, info_fields, null_pointer_node);
-		      FIELD_DECL, NULL_TREE, build_pointer_type (const_type));
+info_fields = DECL_CHAIN (info_fields);
-DECL_CHAIN (field) = fields;
-fields = field;
-CONSTRUCTOR_APPEND_ELT (v1, field, null_pointer_node);
 /* stamp */
-field = build_decl (BUILTINS_LOCATION,
+CONSTRUCTOR_APPEND_ELT (v1, info_fields,
-		      FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
+			  build_int_cstu (TREE_TYPE (info_fields),
-DECL_CHAIN (field) = fields;
+					  bbg_file_stamp));
-fields = field;
+info_fields = DECL_CHAIN (info_fields);
-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 (BUILTINS_LOCATION,
-		      FIELD_DECL, NULL_TREE, string_type);
-DECL_CHAIN (field) = fields;
-fields = field;
 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
+(char_type_node, build_index_type (size_int (da_file_name_len)));
-(build_int_cst (NULL_TREE, da_file_name_len)));
+CONSTRUCTOR_APPEND_ELT (v1, info_fields,
-CONSTRUCTOR_APPEND_ELT (v1, field,
+			  build1 (ADDR_EXPR, TREE_TYPE (info_fields),
-			  build1 (ADDR_EXPR, string_type, filename_string));
+				  filename_string));
+info_fields = DECL_CHAIN (info_fields);
-/* Build the fn_info type and initializer.  */
-fn_info_type = build_fn_info_type (n_ctr_types);
+/* merge fn array -- NULL slots indicate unmeasured counters */
-fn_info_ptr_type = build_pointer_type (build_qualified_type
+merge_fn_type = TREE_TYPE (TREE_TYPE (info_fields));
-					 (fn_info_type, TYPE_QUAL_CONST));
-for (fn = functions_head, n_fns = 0; fn; fn = fn->next, n_fns++)
-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_cst (NULL_TREE, n_fns - 1));
-array_type = build_array_type (fn_info_type, array_type);
-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 (BUILTINS_LOCATION,
-		      FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
-DECL_CHAIN (field) = fields;
-fields = field;
-CONSTRUCTOR_APPEND_ELT (v1, field,
-			  build_int_cstu (get_gcov_unsigned_t (), n_fns));
-/* fn_info table */
-field = build_decl (BUILTINS_LOCATION,
-		      FIELD_DECL, NULL_TREE, fn_info_ptr_type);
-DECL_CHAIN (field) = fields;
-fields = field;
-CONSTRUCTOR_APPEND_ELT (v1, field, fn_info_value);
-/* counter_mask */
-field = build_decl (BUILTINS_LOCATION,
-		      FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
-DECL_CHAIN (field) = fields;
-fields = field;
-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_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))
+{
-CONSTRUCTOR_APPEND_ELT (v2, NULL_TREE,
+tree ptr = null_pointer_node;
-			      build_ctr_info_value (ix, ctr_info_type));
-ctr_info_value = build_constructor (ctr_info_ary_type, v2);
+if ((1u << ix) & prg_ctr_mask)
+	{
-field = build_decl (BUILTINS_LOCATION,
+	  tree merge_fn = build_decl (BUILTINS_LOCATION,
-		      FIELD_DECL, NULL_TREE, ctr_info_ary_type);
+				      FUNCTION_DECL,
-DECL_CHAIN (field) = fields;
+				      get_identifier (ctr_merge_functions[ix]),
-fields = field;
+				      TREE_TYPE (merge_fn_type));
-CONSTRUCTOR_APPEND_ELT (v1, field, ctr_info_value);
+	  DECL_EXTERNAL (merge_fn) = 1;
+	  TREE_PUBLIC (merge_fn) = 1;
-finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE);
+	  DECL_ARTIFICIAL (merge_fn) = 1;
+	  TREE_NOTHROW (merge_fn) = 1;
-return build_constructor (type, v1);
+	  /* Initialize assembler name so we can stream out. */
-}
+	  DECL_ASSEMBLER_NAME (merge_fn);
+	  ptr = build1 (ADDR_EXPR, merge_fn_type, merge_fn);
-/* Write out the structure which libgcov uses to locate all the
+	}
-counters.  The structures used here must match those defined in
+CONSTRUCTOR_APPEND_ELT (v2, NULL, ptr);
-gcov-io.h.  Write out the constructor to call __gcov_init.  */
+}
+CONSTRUCTOR_APPEND_ELT (v1, info_fields,
+			  build_constructor (TREE_TYPE (info_fields), v2));
+info_fields = DECL_CHAIN (info_fields);
+/* n_functions */
+n_funcs = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (fn_ary)));
+n_funcs = fold_build2 (PLUS_EXPR, TREE_TYPE (info_fields),
+			 n_funcs, size_one_node);
+CONSTRUCTOR_APPEND_ELT (v1, info_fields, n_funcs);
+info_fields = DECL_CHAIN (info_fields);
+/* functions */
+CONSTRUCTOR_APPEND_ELT (v1, info_fields,
+			  build1 (ADDR_EXPR, TREE_TYPE (info_fields), fn_ary));
+info_fields = DECL_CHAIN (info_fields);
+gcc_assert (!info_fields);
+return build_constructor (info_type, v1);
+}
+/* Generate the constructor function to call __gcov_init.  */
 static void
-create_coverage (void)
+build_init_ctor (tree gcov_info_type)
 {
-tree gcov_info, gcov_init, body, t;
+tree ctor, stmt, init_fn;
+/* Build a decl for __gcov_init.  */
+init_fn = build_pointer_type (gcov_info_type);
+init_fn = build_function_type_list (void_type_node, init_fn, NULL);
+init_fn = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
+			get_identifier ("__gcov_init"), init_fn);
+TREE_PUBLIC (init_fn) = 1;
+DECL_EXTERNAL (init_fn) = 1;
+DECL_ASSEMBLER_NAME (init_fn);
+/* Generate a call to __gcov_init(&gcov_info).  */
+ctor = NULL;
+stmt = build_fold_addr_expr (gcov_info_var);
+stmt = build_call_expr (init_fn, 1, stmt);
+append_to_statement_list (stmt, &ctor);
+/* Generate a constructor to run it.  */
+int priority = SUPPORTS_INIT_PRIORITY
+? MAX_RESERVED_INIT_PRIORITY: DEFAULT_INIT_PRIORITY;
+cgraph_build_static_cdtor ('I', ctor, priority);
+}
+/* Generate the destructor function to call __gcov_exit.  */
+static void
+build_gcov_exit_decl (void)
+{
+tree init_fn = build_function_type_list (void_type_node, void_type_node,
+					   NULL);
+init_fn = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
+			get_identifier ("__gcov_exit"), init_fn);
+TREE_PUBLIC (init_fn) = 1;
+DECL_EXTERNAL (init_fn) = 1;
+DECL_ASSEMBLER_NAME (init_fn);
+/* Generate a call to __gcov_exit ().  */
+tree dtor = NULL;
+tree stmt = build_call_expr (init_fn, 0);
+append_to_statement_list (stmt, &dtor);
+/* Generate a destructor to run it.  */
+int priority = SUPPORTS_INIT_PRIORITY
+? MAX_RESERVED_INIT_PRIORITY: DEFAULT_INIT_PRIORITY;
+cgraph_build_static_cdtor ('D', dtor, priority);
+}
+/* Create the gcov_info types and object.  Generate the constructor
+function to call __gcov_init.  Does not generate the initializer
+for the object.  Returns TRUE if coverage data is being emitted.  */
+static bool
+coverage_obj_init (void)
+{
+tree gcov_info_type;
+unsigned n_counters = 0;
+unsigned ix;
+struct coverage_data *fn;
+struct coverage_data **fn_prev;
 char name_buf[32];
 no_coverage = 1; /* Disable any further coverage.  */
 if (!prg_ctr_mask)
-return;
+return false;
-t = build_gcov_info ();
+if (symtab->dump_file)
+fprintf (symtab->dump_file, "Using data file %s\n", da_file_name);
-gcov_info = build_decl (BUILTINS_LOCATION,
-			  VAR_DECL, NULL_TREE, TREE_TYPE (t));
+/* Prune functions.  */
-TREE_STATIC (gcov_info) = 1;
+for (fn_prev = &functions_head; (fn = *fn_prev);)
+if (DECL_STRUCT_FUNCTION (fn->fn_decl))
+fn_prev = &fn->next;
+else
+/* The function is not being emitted, remove from list.  */
+*fn_prev = fn->next;
+if (functions_head == NULL)
+return false;
+for (ix = 0; ix != GCOV_COUNTERS; ix++)
+if ((1u << ix) & prg_ctr_mask)
+n_counters++;
+/* Build the info and fn_info types.  These are mutually recursive.  */
+gcov_info_type = lang_hooks.types.make_type (RECORD_TYPE);
+gcov_fn_info_type = lang_hooks.types.make_type (RECORD_TYPE);
+build_fn_info_type (gcov_fn_info_type, n_counters, gcov_info_type);
+gcov_info_type = lang_hooks.types.make_type (RECORD_TYPE);
+gcov_fn_info_ptr_type = build_pointer_type
+(build_qualified_type (gcov_fn_info_type, TYPE_QUAL_CONST));
+build_info_type (gcov_info_type, gcov_fn_info_ptr_type);
+/* Build the gcov info var, this is referred to in its own
+initializer.  */
+gcov_info_var = build_decl (BUILTINS_LOCATION,
+			      VAR_DECL, NULL_TREE, gcov_info_type);
+TREE_STATIC (gcov_info_var) = 1;
 ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0);
-DECL_NAME (gcov_info) = get_identifier (name_buf);
+DECL_NAME (gcov_info_var) = get_identifier (name_buf);
-DECL_INITIAL (gcov_info) = t;
+build_init_ctor (gcov_info_type);
-/* Build structure.  */
+build_gcov_exit_decl ();
-varpool_finalize_decl (gcov_info);
+return true;
-/* Build a decl for __gcov_init.  */
+}
-t = build_pointer_type (TREE_TYPE (gcov_info));
-t = build_function_type_list (void_type_node, t, NULL);
+/* Generate the coverage function info for FN and DATA.  Append a
-t = build_decl (BUILTINS_LOCATION,
+pointer to that object to CTOR and return the appended CTOR.  */
-		  FUNCTION_DECL, get_identifier ("__gcov_init"), t);
-TREE_PUBLIC (t) = 1;
+static vec<constructor_elt, va_gc> *
-DECL_EXTERNAL (t) = 1;
+coverage_obj_fn (vec<constructor_elt, va_gc> *ctor, tree fn,
-DECL_ASSEMBLER_NAME (t);  /* Initialize assembler name so we can stream out. */
+		 struct coverage_data const *data)
-gcov_init = t;
+{
+tree init = build_fn_info (data, gcov_fn_info_type, gcov_info_var);
-/* Generate a call to __gcov_init(&gcov_info).  */
+tree var = build_var (fn, gcov_fn_info_type, -1);
-body = NULL;
-t = build_fold_addr_expr (gcov_info);
+DECL_INITIAL (var) = init;
-t = build_call_expr (gcov_init, 1, t);
+varpool_node::finalize_decl (var);
-append_to_statement_list (t, &body);
+CONSTRUCTOR_APPEND_ELT (ctor, NULL,
-/* Generate a constructor to run it.  */
+			  build1 (ADDR_EXPR, gcov_fn_info_ptr_type, var));
-cgraph_build_static_cdtor ('I', body, DEFAULT_INIT_PRIORITY);
+return ctor;
 }
+/* Finalize the coverage data.  Generates the array of pointers to
+function objects from CTOR.  Generate the gcov_info initializer.  */
+static void
+coverage_obj_finish (vec<constructor_elt, va_gc> *ctor)
+{
+unsigned n_functions = vec_safe_length (ctor);
+tree fn_info_ary_type = build_array_type
+(build_qualified_type (gcov_fn_info_ptr_type, TYPE_QUAL_CONST),
+build_index_type (size_int (n_functions - 1)));
+tree fn_info_ary = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL_TREE,
+				 fn_info_ary_type);
+char name_buf[32];
+TREE_STATIC (fn_info_ary) = 1;
+ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 1);
+DECL_NAME (fn_info_ary) = get_identifier (name_buf);
+DECL_INITIAL (fn_info_ary) = build_constructor (fn_info_ary_type, ctor);
+varpool_node::finalize_decl (fn_info_ary);
+DECL_INITIAL (gcov_info_var)
+= build_info (TREE_TYPE (gcov_info_var), fn_info_ary);
+varpool_node::finalize_decl (gcov_info_var);
+}
 /* Perform file-level initialization. Read in data file, generate name
-of graph file.  */
+of notes file.  */
 void
 coverage_init (const char *filename)
 {
 int len = strlen (filename);
-/* + 1 for extra '/', in case prefix doesn't end with /.  */
+int prefix_len = 0;
-int prefix_len;
+/* Since coverage_init is invoked very early, before the pass
-if (profile_data_prefix == 0 && filename[0] != '/')
+manager, we need to set up the dumping explicitly. This is
+similar to the handling in finish_optimization_passes.  */
+int profile_pass_num =
+g->get_passes ()->get_pass_profile ()->static_pass_number;
+g->get_dumps ()->dump_start (profile_pass_num, NULL);
+if (!profile_data_prefix && !IS_ABSOLUTE_PATH (filename))
 profile_data_prefix = getpwd ();
-prefix_len = (profile_data_prefix) ? strlen (profile_data_prefix) + 1 : 0;
+if (profile_data_prefix)
+prefix_len = strlen (profile_data_prefix);
 /* Name of da file.  */
 da_file_name = XNEWVEC (char, len + strlen (GCOV_DATA_SUFFIX)
-			  + prefix_len + 1);
+			  + prefix_len + 2);
 if (profile_data_prefix)
 {
-strcpy (da_file_name, profile_data_prefix);
+memcpy (da_file_name, profile_data_prefix, prefix_len);
-da_file_name[prefix_len - 1] = '/';
+da_file_name[prefix_len++] = '/';
-da_file_name[prefix_len] = 0;
+}
-}
+memcpy (da_file_name + prefix_len, filename, len);
-else
+strcpy (da_file_name + prefix_len + len, GCOV_DATA_SUFFIX);
-da_file_name[0] = 0;
-strcat (da_file_name, filename);
+bbg_file_stamp = local_tick;
-strcat (da_file_name, GCOV_DATA_SUFFIX);
+if (flag_auto_profile)
+read_autofdo_file ();
+else if (flag_branch_probabilities)
+read_counts_file ();
 /* Name of bbg file.  */
-bbg_file_name = XNEWVEC (char, len + strlen (GCOV_NOTE_SUFFIX) + 1);
+if (flag_test_coverage && !flag_compare_debug)
-strcpy (bbg_file_name, filename);
+{
-strcat (bbg_file_name, GCOV_NOTE_SUFFIX);
+bbg_file_name = XNEWVEC (char, len + strlen (GCOV_NOTE_SUFFIX) + 1);
+memcpy (bbg_file_name, filename, len);
-if (flag_profile_use)
+strcpy (bbg_file_name + len, GCOV_NOTE_SUFFIX);
-read_counts_file ();
-}
+if (!gcov_open (bbg_file_name, -1))
+	{
-/* Performs file-level cleanup.  Close graph file, generate coverage
+	  error ("cannot open %s", bbg_file_name);
+	  bbg_file_name = NULL;
+	}
+else
+	{
+	  gcov_write_unsigned (GCOV_NOTE_MAGIC);
+	  gcov_write_unsigned (GCOV_VERSION);
+	  gcov_write_unsigned (bbg_file_stamp);
+	}
+}
+g->get_dumps ()->dump_finish (profile_pass_num);
+}
+/* Performs file-level cleanup.  Close notes file, generate coverage
 variables and constructor.  */
 void
 coverage_finish (void)
 {
-create_coverage ();
+if (bbg_file_name && gcov_close ())
-if (bbg_file_opened)
+unlink (bbg_file_name);
-{
-int error = gcov_close ();
+if (!flag_branch_probabilities && flag_test_coverage
+&& (!local_tick || local_tick == (unsigned)-1))
-if (error)
+/* Only remove the da file, if we're emitting coverage code and
-	unlink (bbg_file_name);
+cannot uniquely stamp it.  If we can stamp it, libgcov will DTRT.  */
-if (!local_tick)
+unlink (da_file_name);
-	/* Only remove the da file, if we cannot stamp it. If we can
-	   stamp it, libgcov will DTRT.  */
+if (coverage_obj_init ())
-	unlink (da_file_name);
+{
-}
+vec<constructor_elt, va_gc> *fn_ctor = NULL;
+struct coverage_data *fn;
+for (fn = functions_head; fn; fn = fn->next)
+	fn_ctor = coverage_obj_fn (fn_ctor, fn->fn_decl, fn);
+coverage_obj_finish (fn_ctor);
+}
+XDELETEVEC (da_file_name);
+da_file_name = NULL;
 }
 #include "gt-coverage.h"

Mercurial > hg > CbC > CbC_gcc

comparison gcc/coverage.c @ 111:04ced10e8804