Simplify gcov_histogram as it's used only for ARCS counters.

diff --git a/gcc/auto-profile.c b/gcc/auto-profile.c
index e7944969ab0..197fa10e08c 100644
--- a/gcc/auto-profile.c
+++ b/gcc/auto-profile.c
@@ -318,8 +318,8 @@  static string_table *afdo_string_table;
 /* Store the AutoFDO source profile.  */
 static autofdo_source_profile *afdo_source_profile;
 
-/* gcov_ctr_summary structure to store the profile_info.  */
-static struct gcov_ctr_summary *afdo_profile_info;
+/* gcov_summary structure to store the profile_info.  */
+static gcov_summary *afdo_profile_info;
 
 /* Helper functions.  */
 
@@ -1682,8 +1682,7 @@  read_autofdo_file (void)
   if (auto_profile_file == NULL)
     auto_profile_file = DEFAULT_AUTO_PROFILE_FILE;
 
-  autofdo::afdo_profile_info = (struct gcov_ctr_summary *)xcalloc (
-      1, sizeof (struct gcov_ctr_summary));
+  autofdo::afdo_profile_info = XNEW (gcov_summary);
   autofdo::afdo_profile_info->runs = 1;
   autofdo::afdo_profile_info->sum_max = 0;
   autofdo::afdo_profile_info->sum_all = 0;
@@ -1713,7 +1712,7 @@  afdo_callsite_hot_enough_for_early_inline (struct cgraph_edge *edge)
   if (count > 0)
     {
       bool is_hot;
-      const struct gcov_ctr_summary *saved_profile_info = profile_info;
+      const gcov_summary *saved_profile_info = profile_info;
       /* At early inline stage, profile_info is not set yet. We need to
          temporarily set it to afdo_profile_info to calculate hotness.  */
       profile_info = autofdo::afdo_profile_info;
diff --git a/gcc/coverage.c b/gcc/coverage.c
index 32ef298a11f..9ff20636900 100644
--- a/gcc/coverage.c
+++ b/gcc/coverage.c
@@ -73,7 +73,7 @@  struct counts_entry : pointer_hash <counts_entry>
   unsigned lineno_checksum;
   unsigned cfg_checksum;
   gcov_type *counts;
-  struct gcov_ctr_summary summary;
+  gcov_summary summary;
 
   /* hash_table support.  */
   static inline hashval_t hash (const counts_entry *);
@@ -185,7 +185,7 @@  static void
 read_counts_file (void)
 {
   gcov_unsigned_t fn_ident = 0;
-  struct gcov_summary summary;
+  gcov_summary summary;
   unsigned new_summary = 1;
   gcov_unsigned_t tag;
   int is_error = 0;
@@ -241,27 +241,21 @@  read_counts_file (void)
       else if (tag == GCOV_TAG_PROGRAM_SUMMARY)
 	{
 	  struct gcov_summary sum;
-	  unsigned ix;
 
 	  if (new_summary)
 	    memset (&summary, 0, sizeof (summary));
 
 	  gcov_read_summary (&sum);
-	  for (ix = 0; ix != GCOV_COUNTERS_SUMMABLE; ix++)
-	    {
-	      summary.ctrs[ix].runs += sum.ctrs[ix].runs;
-	      summary.ctrs[ix].sum_all += sum.ctrs[ix].sum_all;
-	      if (summary.ctrs[ix].run_max < sum.ctrs[ix].run_max)
-		summary.ctrs[ix].run_max = sum.ctrs[ix].run_max;
-	      summary.ctrs[ix].sum_max += sum.ctrs[ix].sum_max;
-	    }
+	  summary.runs += sum.runs;
+	  summary.sum_all += sum.sum_all;
+	  if (summary.run_max < sum.run_max)
+	    summary.run_max = sum.run_max;
+	  summary.sum_max += sum.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);
+	    memcpy (summary.histogram, sum.histogram,
+		sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
           else
-            gcov_histogram_merge (summary.ctrs[GCOV_COUNTER_ARCS].histogram,
-                                  sum.ctrs[GCOV_COUNTER_ARCS].histogram);
+	    gcov_histogram_merge (summary.histogram, sum.histogram);
 	  new_summary = 0;
 	}
       else if (GCOV_TAG_IS_COUNTER (tag) && fn_ident)
@@ -282,8 +276,8 @@  read_counts_file (void)
 	      entry->ctr = elt.ctr;
 	      entry->lineno_checksum = lineno_checksum;
 	      entry->cfg_checksum = cfg_checksum;
-              if (elt.ctr < GCOV_COUNTERS_SUMMABLE)
-                entry->summary = summary.ctrs[elt.ctr];
+	      if (elt.ctr == GCOV_COUNTER_ARCS)
+		entry->summary = summary;
               entry->summary.num = n_counts;
 	      entry->counts = XCNEWVEC (gcov_type, n_counts);
 	    }
@@ -306,23 +300,16 @@  read_counts_file (void)
 	      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
 	    {
-	      entry->summary.runs += summary.ctrs[elt.ctr].runs;
-	      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;
+	      entry->summary.runs += summary.runs;
+	      entry->summary.sum_all += summary.sum_all;
+	      if (entry->summary.run_max < summary.run_max)
+		entry->summary.run_max = summary.run_max;
+	      entry->summary.sum_max += summary.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 ()))
@@ -345,7 +332,7 @@  read_counts_file (void)
 gcov_type *
 get_coverage_counts (unsigned counter, unsigned expected,
                      unsigned cfg_checksum, unsigned lineno_checksum,
-		     const struct gcov_ctr_summary **summary)
+		     const gcov_summary **summary)
 {
   counts_entry *entry, elt;
 
diff --git a/gcc/coverage.h b/gcc/coverage.h
index 689e39ee718..842d6952c16 100644
--- a/gcc/coverage.h
+++ b/gcc/coverage.h
@@ -54,7 +54,7 @@  extern gcov_type *get_coverage_counts (unsigned /*counter*/,
 				       unsigned /*expected*/,
 				       unsigned /*cfg_checksum*/,
 				       unsigned /*lineno_checksum*/,
-				       const struct gcov_ctr_summary **);
+				       const gcov_summary **);
 
 extern tree get_gcov_type (void);
 extern bool coverage_node_map_initialized_p (void);
diff --git a/gcc/gcov-dump.c b/gcc/gcov-dump.c
index ba432db51c7..1ac36e7440c 100644
--- a/gcc/gcov-dump.c
+++ b/gcc/gcov-dump.c
@@ -39,7 +39,7 @@  static void tag_lines (const char *, unsigned, unsigned, unsigned);
 static void tag_counters (const char *, unsigned, unsigned, unsigned);
 static void tag_summary (const char *, unsigned, unsigned, unsigned);
 static void dump_working_sets (const char *filename ATTRIBUTE_UNUSED,
-			       const struct gcov_ctr_summary *summary,
+			       const gcov_summary *summary,
 			       unsigned depth);
 extern int main (int, char **);
 
@@ -465,52 +465,47 @@  tag_summary (const char *filename ATTRIBUTE_UNUSED,
 	     unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED,
 	     unsigned depth)
 {
-  struct gcov_summary summary;
-  unsigned ix, h_ix;
+  gcov_summary summary;
+  unsigned h_ix;
   gcov_bucket_type *histo_bucket;
 
   gcov_read_summary (&summary);
   printf (" checksum=0x%08x", summary.checksum);
 
-  for (ix = 0; ix != GCOV_COUNTERS_SUMMABLE; ix++)
+  printf ("\n");
+  print_prefix (filename, depth, 0);
+  printf (VALUE_PADDING_PREFIX "counts=%u, runs=%u",
+	  summary.num, summary.runs);
+
+  printf (", sum_all=%" PRId64,
+	  (int64_t)summary.sum_all);
+  printf (", run_max=%" PRId64,
+	  (int64_t)summary.run_max);
+  printf (", sum_max=%" PRId64,
+	  (int64_t)summary.sum_max);
+  printf ("\n");
+  print_prefix (filename, depth, 0);
+  printf (VALUE_PADDING_PREFIX "counter histogram:");
+  for (h_ix = 0; h_ix < GCOV_HISTOGRAM_SIZE; h_ix++)
     {
+      histo_bucket = &summary.histogram[h_ix];
+      if (!histo_bucket->num_counters)
+	continue;
       printf ("\n");
       print_prefix (filename, depth, 0);
-      printf (VALUE_PADDING_PREFIX "counts=%u, runs=%u",
-	      summary.ctrs[ix].num, summary.ctrs[ix].runs);
-
-      printf (", sum_all=%" PRId64,
-	      (int64_t)summary.ctrs[ix].sum_all);
-      printf (", run_max=%" PRId64,
-	      (int64_t)summary.ctrs[ix].run_max);
-      printf (", sum_max=%" PRId64,
-	      (int64_t)summary.ctrs[ix].sum_max);
-      if (ix != GCOV_COUNTER_ARCS)
-        continue;
-      printf ("\n");
-      print_prefix (filename, depth, 0);
-      printf (VALUE_PADDING_PREFIX "counter histogram:");
-      for (h_ix = 0; h_ix < GCOV_HISTOGRAM_SIZE; h_ix++)
-        {
-	  histo_bucket = &summary.ctrs[ix].histogram[h_ix];
-	  if (!histo_bucket->num_counters)
-	    continue;
-	  printf ("\n");
-	  print_prefix (filename, depth, 0);
-	  printf (VALUE_PADDING_PREFIX VALUE_PREFIX "num counts=%u, "
-		  "min counter=%" PRId64 ", cum_counter=%" PRId64,
-		  h_ix, histo_bucket->num_counters,
-		  (int64_t)histo_bucket->min_value,
-		  (int64_t)histo_bucket->cum_value);
-        }
-      if (flag_dump_working_sets)
-	dump_working_sets (filename, &summary.ctrs[ix], depth);
+      printf (VALUE_PADDING_PREFIX VALUE_PREFIX "num counts=%u, "
+	      "min counter=%" PRId64 ", cum_counter=%" PRId64,
+	      h_ix, histo_bucket->num_counters,
+	      (int64_t)histo_bucket->min_value,
+	      (int64_t)histo_bucket->cum_value);
     }
+  if (flag_dump_working_sets)
+    dump_working_sets (filename, &summary, depth);
 }
 
 static void
 dump_working_sets (const char *filename ATTRIBUTE_UNUSED,
-		   const struct gcov_ctr_summary *summary,
+		   const gcov_summary *summary,
 		   unsigned depth)
 {
   gcov_working_set_t gcov_working_sets[NUM_GCOV_WORKING_SETS];
diff --git a/gcc/gcov-io.c b/gcc/gcov-io.c
index 3fe1e613ebc..e07ae76420b 100644
--- a/gcc/gcov-io.c
+++ b/gcc/gcov-io.c
@@ -446,8 +446,7 @@  gcov_write_tag_length (gcov_unsigned_t tag, gcov_unsigned_t length)
 GCOV_LINKAGE void
 gcov_write_summary (gcov_unsigned_t tag, const struct gcov_summary *summary)
 {
-  unsigned ix, h_ix, bv_ix, h_cnt = 0;
-  const struct gcov_ctr_summary *csum;
+  unsigned h_ix, bv_ix, h_cnt = 0;
   unsigned histo_bitvector[GCOV_HISTOGRAM_BITVECTOR_SIZE];
 
   /* Count number of non-zero histogram entries, and fill in a bit vector
@@ -455,38 +454,29 @@  gcov_write_summary (gcov_unsigned_t tag, const struct gcov_summary *summary)
      counters.  */
   for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
     histo_bitvector[bv_ix] = 0;
-  csum = &summary->ctrs[GCOV_COUNTER_ARCS];
   for (h_ix = 0; h_ix < GCOV_HISTOGRAM_SIZE; h_ix++)
-    if (csum->histogram[h_ix].num_counters)
+    if (summary->histogram[h_ix].num_counters)
       {
 	histo_bitvector[h_ix / 32] |= 1 << (h_ix % 32);
 	h_cnt++;
       }
   gcov_write_tag_length (tag, GCOV_TAG_SUMMARY_LENGTH (h_cnt));
   gcov_write_unsigned (summary->checksum);
-  for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++)
+
+  gcov_write_unsigned (summary->num);
+  gcov_write_unsigned (summary->runs);
+  gcov_write_counter (summary->sum_all);
+  gcov_write_counter (summary->run_max);
+  gcov_write_counter (summary->sum_max);
+  for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
+    gcov_write_unsigned (histo_bitvector[bv_ix]);
+  for (h_ix = 0; h_ix < GCOV_HISTOGRAM_SIZE; h_ix++)
     {
-      gcov_write_unsigned (csum->num);
-      gcov_write_unsigned (csum->runs);
-      gcov_write_counter (csum->sum_all);
-      gcov_write_counter (csum->run_max);
-      gcov_write_counter (csum->sum_max);
-      if (ix != GCOV_COUNTER_ARCS)
-        {
-          for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
-            gcov_write_unsigned (0);
-          continue;
-        }
-      for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
-        gcov_write_unsigned (histo_bitvector[bv_ix]);
-      for (h_ix = 0; h_ix < GCOV_HISTOGRAM_SIZE; h_ix++)
-        {
-          if (!csum->histogram[h_ix].num_counters)
-            continue;
-          gcov_write_unsigned (csum->histogram[h_ix].num_counters);
-          gcov_write_counter (csum->histogram[h_ix].min_value);
-          gcov_write_counter (csum->histogram[h_ix].cum_value);
-        }
+      if (!summary->histogram[h_ix].num_counters)
+	continue;
+      gcov_write_unsigned (summary->histogram[h_ix].num_counters);
+      gcov_write_counter (summary->histogram[h_ix].min_value);
+      gcov_write_counter (summary->histogram[h_ix].cum_value);
     }
 }
 #endif /* IN_LIBGCOV */
@@ -598,68 +588,64 @@  gcov_read_string (void)
 GCOV_LINKAGE void
 gcov_read_summary (struct gcov_summary *summary)
 {
-  unsigned ix, h_ix, bv_ix, h_cnt = 0;
-  struct gcov_ctr_summary *csum;
+  unsigned h_ix, bv_ix, h_cnt = 0;
   unsigned histo_bitvector[GCOV_HISTOGRAM_BITVECTOR_SIZE];
   unsigned cur_bitvector;
 
   summary->checksum = gcov_read_unsigned ();
-  for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++)
+  summary->num = gcov_read_unsigned ();
+  summary->runs = gcov_read_unsigned ();
+  summary->sum_all = gcov_read_counter ();
+  summary->run_max = gcov_read_counter ();
+  summary->sum_max = gcov_read_counter ();
+  memset (summary->histogram, 0,
+	  sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
+  for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
     {
-      csum->num = gcov_read_unsigned ();
-      csum->runs = gcov_read_unsigned ();
-      csum->sum_all = gcov_read_counter ();
-      csum->run_max = gcov_read_counter ();
-      csum->sum_max = gcov_read_counter ();
-      memset (csum->histogram, 0,
-              sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
-      for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
-        {
-          histo_bitvector[bv_ix] = gcov_read_unsigned ();
+      histo_bitvector[bv_ix] = gcov_read_unsigned ();
 #if IN_LIBGCOV
-          /* When building libgcov we don't include system.h, which includes
-             hwint.h (where popcount_hwi is declared). However, libgcov.a
-             is built by the bootstrapped compiler and therefore the builtins
-             are always available.  */
-          h_cnt += __builtin_popcount (histo_bitvector[bv_ix]);
+      /* When building libgcov we don't include system.h, which includes
+	 hwint.h (where popcount_hwi is declared). However, libgcov.a
+	 is built by the bootstrapped compiler and therefore the builtins
+	 are always available.  */
+      h_cnt += __builtin_popcount (histo_bitvector[bv_ix]);
 #else
-          h_cnt += popcount_hwi (histo_bitvector[bv_ix]);
+      h_cnt += popcount_hwi (histo_bitvector[bv_ix]);
 #endif
-        }
-      bv_ix = 0;
-      h_ix = 0;
-      cur_bitvector = 0;
-      while (h_cnt--)
-        {
-          /* Find the index corresponding to the next entry we will read in.
-             First find the next non-zero bitvector and re-initialize
-             the histogram index accordingly, then right shift and increment
-             the index until we find a set bit.  */
-          while (!cur_bitvector)
-            {
-              h_ix = bv_ix * 32;
-              if (bv_ix >= GCOV_HISTOGRAM_BITVECTOR_SIZE)
-                gcov_error ("corrupted profile info: summary histogram "
-                            "bitvector is corrupt");
-              cur_bitvector = histo_bitvector[bv_ix++];
-            }
-          while (!(cur_bitvector & 0x1))
-            {
-              h_ix++;
-              cur_bitvector >>= 1;
-            }
-          if (h_ix >= GCOV_HISTOGRAM_SIZE)
-            gcov_error ("corrupted profile info: summary histogram "
-                        "index is corrupt");
-
-          csum->histogram[h_ix].num_counters = gcov_read_unsigned ();
-          csum->histogram[h_ix].min_value = gcov_read_counter ();
-          csum->histogram[h_ix].cum_value = gcov_read_counter ();
-          /* Shift off the index we are done with and increment to the
-             corresponding next histogram entry.  */
-          cur_bitvector >>= 1;
-          h_ix++;
-        }
+    }
+  bv_ix = 0;
+  h_ix = 0;
+  cur_bitvector = 0;
+  while (h_cnt--)
+    {
+      /* Find the index corresponding to the next entry we will read in.
+	 First find the next non-zero bitvector and re-initialize
+	 the histogram index accordingly, then right shift and increment
+	 the index until we find a set bit.  */
+      while (!cur_bitvector)
+	{
+	  h_ix = bv_ix * 32;
+	  if (bv_ix >= GCOV_HISTOGRAM_BITVECTOR_SIZE)
+	    gcov_error ("corrupted profile info: summary histogram "
+			"bitvector is corrupt");
+	  cur_bitvector = histo_bitvector[bv_ix++];
+	}
+      while (!(cur_bitvector & 0x1))
+	{
+	  h_ix++;
+	  cur_bitvector >>= 1;
+	}
+      if (h_ix >= GCOV_HISTOGRAM_SIZE)
+	gcov_error ("corrupted profile info: summary histogram "
+		    "index is corrupt");
+
+      summary->histogram[h_ix].num_counters = gcov_read_unsigned ();
+      summary->histogram[h_ix].min_value = gcov_read_counter ();
+      summary->histogram[h_ix].cum_value = gcov_read_counter ();
+      /* Shift off the index we are done with and increment to the
+	 corresponding next histogram entry.  */
+      cur_bitvector >>= 1;
+      h_ix++;
     }
 }
 
@@ -921,7 +907,7 @@  static void gcov_histogram_merge (gcov_bucket_type *tgt_histo,
    the minimum counter value in that working set.  */
 
 GCOV_LINKAGE void
-compute_working_sets (const struct gcov_ctr_summary *summary,
+compute_working_sets (const gcov_summary *summary,
                       gcov_working_set_t *gcov_working_sets)
 {
   gcov_type working_set_cum_values[NUM_GCOV_WORKING_SETS];
diff --git a/gcc/gcov-io.h b/gcc/gcov-io.h
index d6389c48908..56391defab3 100644
--- a/gcc/gcov-io.h
+++ b/gcc/gcov-io.h
@@ -140,9 +140,8 @@  see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 		int32:lineno_checksum int32:cfg_checksum
 	present: header int32:present
 	counts: header int64:count*
-	summary: int32:checksum {count-summary}GCOV_COUNTERS_SUMMABLE
-	count-summary:	int32:num int32:runs int64:sum
-			int64:max int64:sum_max histogram
+	summary: int32:checksum int32:num int32:runs int64:sum
+		 int64:max int64:sum_max histogram
         histogram: {int32:bitvector}8 histogram-buckets*
         histogram-buckets: int32:num int64:min int64:sum
 
@@ -243,8 +242,7 @@  typedef uint64_t gcov_type_unsigned;
 #define GCOV_TAG_COUNTER_NUM(LENGTH) ((LENGTH) / 2)
 #define GCOV_TAG_OBJECT_SUMMARY  ((gcov_unsigned_t)0xa1000000) /* Obsolete */
 #define GCOV_TAG_PROGRAM_SUMMARY ((gcov_unsigned_t)0xa3000000)
-#define GCOV_TAG_SUMMARY_LENGTH(NUM)  \
-        (1 + GCOV_COUNTERS_SUMMABLE * (10 + 3 * 2) + (NUM) * 5)
+#define GCOV_TAG_SUMMARY_LENGTH(NUM) (1 + (10 + 3 * 2) + (NUM) * 5)
 #define GCOV_TAG_AFDO_FILE_NAMES ((gcov_unsigned_t)0xaa000000)
 #define GCOV_TAG_AFDO_FUNCTION ((gcov_unsigned_t)0xac000000)
 #define GCOV_TAG_AFDO_WORKING_SET ((gcov_unsigned_t)0xaf000000)
@@ -259,13 +257,10 @@  GCOV_COUNTERS
 };
 #undef DEF_GCOV_COUNTER
 
-/* Counters which can be summaried.  */
-#define GCOV_COUNTERS_SUMMABLE	(GCOV_COUNTER_ARCS + 1)
-
 /* The first of counters used for value profiling.  They must form a
    consecutive interval and their order must match the order of
    HIST_TYPEs in value-prof.h.  */
-#define GCOV_FIRST_VALUE_COUNTER GCOV_COUNTERS_SUMMABLE
+#define GCOV_FIRST_VALUE_COUNTER GCOV_COUNTER_V_INTERVAL
 
 /* The last of counters used for value profiling.  */
 #define GCOV_LAST_VALUE_COUNTER (GCOV_COUNTERS - 1)
@@ -337,23 +332,18 @@  typedef struct
    This is essentially a ceiling divide by 32 bits.  */
 #define GCOV_HISTOGRAM_BITVECTOR_SIZE (GCOV_HISTOGRAM_SIZE + 31) / 32
 
-/* Cumulative counter data.  */
-struct gcov_ctr_summary
-{
-  gcov_unsigned_t num;		/* number of counters.  */
-  gcov_unsigned_t runs;		/* number of program runs */
-  gcov_type sum_all;		/* sum of all counters accumulated.  */
-  gcov_type run_max;		/* maximum value on a single run.  */
-  gcov_type sum_max;    	/* sum of individual run max values.  */
-  gcov_bucket_type histogram[GCOV_HISTOGRAM_SIZE]; /* histogram of
-                                                      counter values.  */
-};
-
 /* Object & program summary record.  */
+
 struct gcov_summary
 {
-  gcov_unsigned_t checksum;	/* checksum of program */
-  struct gcov_ctr_summary ctrs[GCOV_COUNTERS_SUMMABLE];
+  gcov_unsigned_t checksum;	/* Checksum of program.  */
+  gcov_unsigned_t num;		/* Number of counters.  */
+  gcov_unsigned_t runs;		/* Number of program runs.  */
+  gcov_type sum_all;		/* Sum of all counters accumulated.  */
+  gcov_type run_max;		/* Maximum value on a single run.  */
+  gcov_type sum_max;    	/* Sum of individual run max values.  */
+  gcov_bucket_type histogram[GCOV_HISTOGRAM_SIZE]; /* Histogram of
+						      counter values.  */
 };
 
 #if !defined(inhibit_libc)
@@ -414,7 +404,7 @@  typedef struct gcov_working_set_info
   gcov_type min_counter;
 } gcov_working_set_t;
 
-GCOV_LINKAGE void compute_working_sets (const struct gcov_ctr_summary *summary,
+GCOV_LINKAGE void compute_working_sets (const gcov_summary *summary,
                                         gcov_working_set_t *gcov_working_sets);
 #endif
 
diff --git a/gcc/gcov.c b/gcc/gcov.c
index 6bbfe33ca33..f5969cc0d0a 100644
--- a/gcc/gcov.c
+++ b/gcc/gcov.c
@@ -1774,7 +1774,7 @@  read_count_file (void)
 	{
 	  struct gcov_summary summary;
 	  gcov_read_summary (&summary);
-	  object_runs += summary.ctrs[GCOV_COUNTER_ARCS].runs;
+	  object_runs += summary.runs;
 	  program_count++;
 	}
       else if (tag == GCOV_TAG_FUNCTION && !length)
diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c
index dcd5391012c..c3954520fd5 100644
--- a/gcc/lto-cgraph.c
+++ b/gcc/lto-cgraph.c
@@ -1652,7 +1652,7 @@  input_refs (struct lto_input_block *ib,
 }
 	    
 
-static struct gcov_ctr_summary lto_gcov_summary;
+static gcov_summary lto_gcov_summary;
 
 /* Input profile_info from IB.  */
 static void
@@ -1710,7 +1710,7 @@  merge_profile_summaries (struct lto_file_decl_data **file_data_vec)
   struct cgraph_node *node;
   struct cgraph_edge *edge;
   gcov_type saved_sum_all = 0;
-  gcov_ctr_summary *saved_profile_info = 0;
+  gcov_summary *saved_profile_info = 0;
   int saved_scale = 0;
 
   /* Find unit with maximal number of runs.  If we ever get serious about
diff --git a/gcc/lto-streamer.h b/gcc/lto-streamer.h
index d2006fad0ad..025929fe560 100644
--- a/gcc/lto-streamer.h
+++ b/gcc/lto-streamer.h
@@ -582,7 +582,7 @@  struct GTY(()) lto_file_decl_data
   vec<res_pair>  GTY((skip)) respairs;
   unsigned max_index;
 
-  struct gcov_ctr_summary GTY((skip)) profile_info;
+  gcov_summary GTY((skip)) profile_info;
 
   /* Map assigning declarations their resolutions.  */
   hash_map<tree, ld_plugin_symbol_resolution> * GTY((skip)) resolution_map;
diff --git a/gcc/profile.c b/gcc/profile.c
index 6fde0fd29d1..8ba6dc7baec 100644
--- a/gcc/profile.c
+++ b/gcc/profile.c
@@ -84,7 +84,7 @@  struct bb_profile_info {
 
 /* Counter summary from the last set of coverage counts read.  */
 
-const struct gcov_ctr_summary *profile_info;
+const gcov_summary *profile_info;
 
 /* Counter working set information computed from the current counter
    summary. Not initialized unless profile_info summary is non-NULL.  */
diff --git a/gcc/profile.h b/gcc/profile.h
index f710cf25ba5..6b37bb6f3df 100644
--- a/gcc/profile.h
+++ b/gcc/profile.h
@@ -75,6 +75,6 @@  extern void get_working_sets (void);
 
 /* Counter summary from the last set of coverage counts read by
    profile.c.  */
-extern const struct gcov_ctr_summary *profile_info;
+extern const struct gcov_summary *profile_info;
 
 #endif /* PROFILE_H */
diff --git a/libgcc/libgcov-driver.c b/libgcc/libgcov-driver.c
index b4f195b8259..a5bc76fd177 100644
--- a/libgcc/libgcov-driver.c
+++ b/libgcc/libgcov-driver.c
@@ -221,40 +221,24 @@  gcov_compute_histogram (struct gcov_info *list, struct gcov_summary *sum)
   struct gcov_info *gi_ptr;
   const struct gcov_fn_info *gfi_ptr;
   const struct gcov_ctr_info *ci_ptr;
-  struct gcov_ctr_summary *cs_ptr;
-  unsigned t_ix, f_ix, ctr_info_ix, ix;
+  unsigned f_ix, ix;
   int h_ix;
 
-  /* This currently only applies to arc counters.  */
-  t_ix = GCOV_COUNTER_ARCS;
-
   /* First check if there are any counts recorded for this counter.  */
-  cs_ptr = &(sum->ctrs[t_ix]);
-  if (!cs_ptr->num)
+  if (!sum->num)
     return;
 
   for (h_ix = 0; h_ix < GCOV_HISTOGRAM_SIZE; h_ix++)
     {
-      cs_ptr->histogram[h_ix].num_counters = 0;
-      cs_ptr->histogram[h_ix].min_value = cs_ptr->run_max;
-      cs_ptr->histogram[h_ix].cum_value = 0;
+      sum->histogram[h_ix].num_counters = 0;
+      sum->histogram[h_ix].min_value = sum->run_max;
+      sum->histogram[h_ix].cum_value = 0;
     }
 
   /* Walk through all the per-object structures and record each of
      the count values in histogram.  */
   for (gi_ptr = list; gi_ptr; gi_ptr = gi_ptr->next)
     {
-      if (!gi_ptr->merge[t_ix])
-        continue;
-
-      /* Find the appropriate index into the gcov_ctr_info array
-         for the counter we are currently working on based on the
-         existence of the merge function pointer for this object.  */
-      for (ix = 0, ctr_info_ix = 0; ix < t_ix; ix++)
-        {
-          if (gi_ptr->merge[ix])
-            ctr_info_ix++;
-        }
       for (f_ix = 0; f_ix != gi_ptr->n_functions; f_ix++)
         {
           gfi_ptr = gi_ptr->functions[f_ix];
@@ -262,9 +246,9 @@  gcov_compute_histogram (struct gcov_info *list, struct gcov_summary *sum)
           if (!gfi_ptr || gfi_ptr->key != gi_ptr)
             continue;
 
-          ci_ptr = &gfi_ptr->ctrs[ctr_info_ix];
-          for (ix = 0; ix < ci_ptr->num; ix++)
-            gcov_histogram_insert (cs_ptr->histogram, ci_ptr->values[ix]);
+	  ci_ptr = &gfi_ptr->ctrs[0];
+	  for (ix = 0; ix < ci_ptr->num; ix++)
+	    gcov_histogram_insert (sum->histogram, ci_ptr->values[ix]);
         }
     }
 }
@@ -287,10 +271,8 @@  compute_summary (struct gcov_info *list, struct gcov_summary *this_prg,
 {
   struct gcov_info *gi_ptr;
   const struct gcov_fn_info *gfi_ptr;
-  struct gcov_ctr_summary *cs_ptr;
   const struct gcov_ctr_info *ci_ptr;
   int f_ix;
-  unsigned t_ix;
   gcov_unsigned_t c_num;
   gcov_unsigned_t crc32 = 0;
 
@@ -319,25 +301,18 @@  compute_summary (struct gcov_info *list, struct gcov_summary *this_prg,
           if (!gfi_ptr)
             continue;
 
-          ci_ptr = gfi_ptr->ctrs;
-          for (t_ix = 0; t_ix != GCOV_COUNTERS_SUMMABLE; t_ix++)
-            {
-              if (!gi_ptr->merge[t_ix])
-                continue;
-
-              cs_ptr = &(this_prg->ctrs[t_ix]);
-              cs_ptr->num += ci_ptr->num;
-              crc32 = crc32_unsigned (crc32, ci_ptr->num);
-
-              for (c_num = 0; c_num < ci_ptr->num; c_num++)
-                {
-                  cs_ptr->sum_all += ci_ptr->values[c_num];
-                  if (cs_ptr->run_max < ci_ptr->values[c_num])
-                    cs_ptr->run_max = ci_ptr->values[c_num];
-                }
-              ci_ptr++;
-            }
-        }
+	  ci_ptr = gfi_ptr->ctrs;
+	  this_prg->num += ci_ptr->num;
+	  crc32 = crc32_unsigned (crc32, ci_ptr->num);
+
+	  for (c_num = 0; c_num < ci_ptr->num; c_num++)
+	    {
+	      this_prg->sum_all += ci_ptr->values[c_num];
+	      if (this_prg->run_max < ci_ptr->values[c_num])
+		this_prg->run_max = ci_ptr->values[c_num];
+	    }
+	  ci_ptr++;
+	}
     }
   gcov_compute_histogram (list, this_prg);
   return crc32;
@@ -407,9 +382,8 @@  merge_one_data (const char *filename,
       if (tmp.checksum != crc32)
         goto next_summary;
 
-      for (t_ix = 0; t_ix != GCOV_COUNTERS_SUMMABLE; t_ix++)
-        if (tmp.ctrs[t_ix].num != this_prg->ctrs[t_ix].num)
-          goto next_summary;
+      if (tmp.num != this_prg->num)
+	goto next_summary;
       *prg_p = tmp;
       *summary_pos_p = *eof_pos_p;
 
@@ -596,77 +570,60 @@  write_one_data (const struct gcov_info *gi_ptr,
    Return -1 on error. Return 0 on success.  */
 
 static int
-merge_summary (const char *filename, int run_counted,
-	       const struct gcov_info *gi_ptr, struct gcov_summary *prg,
+merge_summary (const char *filename __attribute__ ((unused)), int run_counted,
+	       struct gcov_summary *prg,
 	       struct gcov_summary *this_prg, gcov_unsigned_t crc32,
 	       struct gcov_summary *all_prg __attribute__ ((unused)))
 {
-  struct gcov_ctr_summary *cs_prg, *cs_tprg;
-  unsigned t_ix;
 #if !GCOV_LOCKED 
   /* summary for all instances of program.  */ 
-  struct gcov_ctr_summary *cs_all;
+  struct gcov_summary *cs_all;
 #endif 
 
-  /* Merge the summaries.  */
-  for (t_ix = 0; t_ix < GCOV_COUNTERS_SUMMABLE; t_ix++)
-    {
-      cs_prg = &(prg->ctrs[t_ix]);
-      cs_tprg = &(this_prg->ctrs[t_ix]);
-
-      if (gi_ptr->merge[t_ix])
-        {
-	  int first = !cs_prg->runs;
-
-	  if (!run_counted)
-	    cs_prg->runs++;
-          if (first)
-            cs_prg->num = cs_tprg->num;
-          cs_prg->sum_all += cs_tprg->sum_all;
-          if (cs_prg->run_max < cs_tprg->run_max)
-            cs_prg->run_max = cs_tprg->run_max;
-          cs_prg->sum_max += cs_tprg->run_max;
-          if (first)
-            memcpy (cs_prg->histogram, cs_tprg->histogram,
-                   sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
-          else
-            gcov_histogram_merge (cs_prg->histogram, cs_tprg->histogram);
-        }
-      else if (cs_prg->runs)
-        {
-          gcov_error ("profiling:%s:Merge mismatch for summary.\n",
-                      filename);
-          return -1;
-        }
+  /* Merge the summary.  */
+  int first = !prg->runs;
+
+  if (!run_counted)
+    prg->runs++;
+  if (first)
+    prg->num = this_prg->num;
+  prg->sum_all += this_prg->sum_all;
+  if (prg->run_max < this_prg->run_max)
+    prg->run_max = this_prg->run_max;
+  prg->sum_max += this_prg->run_max;
+  if (first)
+    memcpy (prg->histogram, this_prg->histogram,
+	    sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
+  else
+    gcov_histogram_merge (prg->histogram, this_prg->histogram);
 #if !GCOV_LOCKED
-      cs_all = &all_prg->ctrs[t_ix];
-      if (!cs_all->runs && cs_prg->runs)
-        {
-          cs_all->num = cs_prg->num;
-          cs_all->runs = cs_prg->runs;
-          cs_all->sum_all = cs_prg->sum_all;
-          cs_all->run_max = cs_prg->run_max;
-          cs_all->sum_max = cs_prg->sum_max;
-        }
-      else if (!all_prg->checksum
-               /* Don't compare the histograms, which may have slight
-                  variations depending on the order they were updated
-                  due to the truncating integer divides used in the
-                  merge.  */
-               && (cs_all->num != cs_prg->num
-                   || cs_all->runs != cs_prg->runs
-                   || cs_all->sum_all != cs_prg->sum_all
-                   || cs_all->run_max != cs_prg->run_max
-                   || cs_all->sum_max != cs_prg->sum_max))
-             {
-               gcov_error ("profiling:%s:Data file mismatch - some "
-                           "data files may have been concurrently "
-                           "updated without locking support\n", filename);
-               all_prg->checksum = ~0u;
-             }
-#endif
+  all = &all_prg->ctrs[t_ix];
+  if (!all->runs && prg->runs)
+    {
+      all->num = prg->num;
+      all->runs = prg->runs;
+      all->sum_all = prg->sum_all;
+      all->run_max = prg->run_max;
+      all->sum_max = prg->sum_max;
     }
-  
+  else if (!all_prg->checksum
+	   /* Don't compare the histograms, which may have slight
+	      variations depending on the order they were updated
+	      due to the truncating integer divides used in the
+	      merge.  */
+	   && (all->num != prg->num
+	       || all->runs != prg->runs
+	       || all->sum_all != prg->sum_all
+	       || all->run_max != prg->run_max
+	       || all->sum_max != prg->sum_max))
+    {
+      gcov_error ("profiling:%s:Data file mismatch - some "
+		  "data files may have been concurrently "
+		  "updated without locking support\n", filename);
+      all_prg->checksum = ~0u;
+    }
+#endif
+
   prg->checksum = crc32;
 
   return 0;
@@ -802,7 +759,7 @@  dump_one_gcov (struct gcov_info *gi_ptr, struct gcov_filename *gf,
       summary_pos = eof_pos;
     }
 
-  error = merge_summary (gf->filename, run_counted, gi_ptr, &prg, this_prg,
+  error = merge_summary (gf->filename, run_counted, &prg, this_prg,
 			 crc32, all_prg);
   if (error == -1)
     goto read_fatal;
diff --git a/libgcc/libgcov-util.c b/libgcc/libgcov-util.c
index 9cf56a82859..1d26176940b 100644
--- a/libgcc/libgcov-util.c
+++ b/libgcc/libgcov-util.c
@@ -930,24 +930,13 @@  compute_one_gcov (const struct gcov_info *gcov_info1,
   {
     for (f_ix = 0; f_ix < gcov_info->n_functions; f_ix++)
       {
-        unsigned t_ix;
         const struct gcov_fn_info *gfi_ptr = gcov_info->functions[f_ix];
         if (!gfi_ptr || gfi_ptr->key != gcov_info)
           continue;
         const struct gcov_ctr_info *ci_ptr = gfi_ptr->ctrs;
-        for (t_ix = 0; t_ix < GCOV_COUNTERS_SUMMABLE; t_ix++)
-          {
-            unsigned c_num;
-
-            if (!gcov_info->merge[t_ix])
-              continue;
-
-            for (c_num = 0; c_num < ci_ptr->num; c_num++)
-              {
-                cum_1 += ci_ptr->values[c_num] / sum;
-              }
-            ci_ptr++;
-          }
+	unsigned c_num;
+	for (c_num = 0; c_num < ci_ptr->num; c_num++)
+	  cum_1 += ci_ptr->values[c_num] / sum;
       }
     *cum_p = cum_1;
     return 0.0;
@@ -955,7 +944,6 @@  compute_one_gcov (const struct gcov_info *gcov_info1,
 
   for (f_ix = 0; f_ix < gcov_info1->n_functions; f_ix++)
     {
-      unsigned t_ix;
       double func_cum_1 = 0.0;
       double func_cum_2 = 0.0;
       double func_val = 0.0;
@@ -971,32 +959,24 @@  compute_one_gcov (const struct gcov_info *gcov_info1,
 
       const struct gcov_ctr_info *ci_ptr1 = gfi_ptr1->ctrs;
       const struct gcov_ctr_info *ci_ptr2 = gfi_ptr2->ctrs;
-      for (t_ix = 0; t_ix < GCOV_COUNTERS_SUMMABLE; t_ix++)
-        {
-          unsigned c_num;
+      unsigned c_num;
+      for (c_num = 0; c_num < ci_ptr1->num; c_num++)
+	{
+	  if (ci_ptr1->values[c_num] | ci_ptr2->values[c_num])
+	    {
+	      func_val += calculate_2_entries (ci_ptr1->values[c_num],
+					       ci_ptr2->values[c_num],
+					       sum_1, sum_2);
+
+	      func_cum_1 += ci_ptr1->values[c_num] / sum_1;
+	      func_cum_2 += ci_ptr2->values[c_num] / sum_2;
+	      nonzero = 1;
+	      if (ci_ptr1->values[c_num] / sum_1 >= overlap_hot_threshold
+		  || ci_ptr2->values[c_num] / sum_2 >= overlap_hot_threshold)
+		hot = 1;
+	    }
+	}
 
-          if (!gcov_info1->merge[t_ix])
-            continue;
-
-          for (c_num = 0; c_num < ci_ptr1->num; c_num++)
-            {
-              if (ci_ptr1->values[c_num] | ci_ptr2->values[c_num])
-                {
-                  func_val += calculate_2_entries (ci_ptr1->values[c_num],
-                                          ci_ptr2->values[c_num],
-                                          sum_1, sum_2);
-
-                  func_cum_1 += ci_ptr1->values[c_num] / sum_1;
-                  func_cum_2 += ci_ptr2->values[c_num] / sum_2;
-                  nonzero = 1;
-                  if (ci_ptr1->values[c_num] / sum_1 >= overlap_hot_threshold ||
-                      ci_ptr2->values[c_num] / sum_2 >= overlap_hot_threshold)
-                    hot = 1;
-                }
-            }
-          ci_ptr1++;
-          ci_ptr2++;
-        }
       ret += func_val;
       cum_1 += func_cum_1;
       cum_2 += func_cum_2;
@@ -1023,26 +1003,14 @@  gcov_info_count_all_cold (const struct gcov_info *gcov_info,
 
   for (f_ix = 0; f_ix < gcov_info->n_functions; f_ix++)
     {
-      unsigned t_ix;
       const struct gcov_fn_info *gfi_ptr = gcov_info->functions[f_ix];
 
       if (!gfi_ptr || gfi_ptr->key != gcov_info)
         continue;
       const struct gcov_ctr_info *ci_ptr = gfi_ptr->ctrs;
-      for (t_ix = 0; t_ix < GCOV_COUNTERS_SUMMABLE; t_ix++)
-        {
-          unsigned c_num;
-
-          if (!gcov_info->merge[t_ix])
-            continue;
-
-          for (c_num = 0; c_num < ci_ptr->num; c_num++)
-            {
-              if (ci_ptr->values[c_num] > threshold)
-                return false;
-            }
-          ci_ptr++;
-        }
+      for (unsigned c_num = 0; c_num < ci_ptr->num; c_num++)
+	if (ci_ptr->values[c_num] > threshold)
+	  return false;
     }
 
   return true;
@@ -1252,13 +1220,13 @@  calculate_overlap (struct gcov_info *gcov_list1,
   struct overlap_t *all_infos;
 
   compute_summary (gcov_list1, &this_prg, &max_length);
-  overlap_sum_1 = (double) (this_prg.ctrs[0].sum_all);
-  p1_sum_all = this_prg.ctrs[0].sum_all;
-  p1_run_max = this_prg.ctrs[0].run_max;
+  overlap_sum_1 = (double) (this_prg.sum_all);
+  p1_sum_all = this_prg.sum_all;
+  p1_run_max = this_prg.run_max;
   compute_summary (gcov_list2, &this_prg, &max_length);
-  overlap_sum_2 = (double) (this_prg.ctrs[0].sum_all);
-  p2_sum_all = this_prg.ctrs[0].sum_all;
-  p2_run_max = this_prg.ctrs[0].run_max;
+  overlap_sum_2 = (double) (this_prg.sum_all);
+  p2_sum_all = this_prg.sum_all;
+  p2_run_max = this_prg.run_max;
 
   for (gi_ptr = gcov_list1; gi_ptr; gi_ptr = gi_ptr->next)
     list1_cnt++;