2009-08-04 Tobias Burnus <burnus@net-b.de>

[pf3gnuchains/gcc-fork.git] / gcc / value-prof.c

diff --git a/gcc/value-prof.c b/gcc/value-prof.c
index 2603409..e7a8e0f 100644 (file)
--- a/gcc/value-prof.c
+++ b/gcc/value-prof.c
@@ -1,11 +1,12 @@
 /* Transformations based on profile information for values.
 /* Transformations based on profile information for values.

-   Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Free Software
+   Foundation, Inc.

 
 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
 
 This file is part of GCC.
 
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free

-Software Foundation; either version 2, or (at your option) any later
+Software Foundation; either version 3, or (at your option) any later

 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY


@@ -14,9 +15,8 @@ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 for more details.
 
 You should have received a copy of the GNU General Public License
 for more details.
 
 You should have received a copy of the GNU General Public License

-along with GCC; see the file COPYING.  If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */

 
 #include "config.h"
 #include "system.h"
 
 #include "config.h"
 #include "system.h"


@@ -40,15 +40,14 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "coverage.h"
 #include "tree.h"
 #include "gcov-io.h"
 #include "coverage.h"
 #include "tree.h"
 #include "gcov-io.h"

+#include "cgraph.h"
+#include "timevar.h"
+#include "tree-pass.h"
+#include "toplev.h"
+#include "pointer-set.h"

 
 static struct value_prof_hooks *value_prof_hooks;
 
 
 static struct value_prof_hooks *value_prof_hooks;
 

-/* This is the vector of histograms.  Created in find_values_to_profile.
-   During profile generation, freed by instrument_values.
-   During profile use, freed by value_profile_transformations.  */
-
-static histogram_values static_values = NULL;
-

 /* In this file value profile based optimizations are placed.  Currently the
    following optimizations are implemented (for more detailed descriptions
    see comments at value_profile_transformations):
 /* In this file value profile based optimizations are placed.  Currently the
    following optimizations are implemented (for more detailed descriptions
    see comments at value_profile_transformations):


@@ -59,6 +58,13 @@ static histogram_values static_values = NULL;
    2) Speculative prefetching.  If we are able to determine that the difference
       between addresses accessed by a memory reference is usually constant, we
       may add the prefetch instructions.
    2) Speculative prefetching.  If we are able to determine that the difference
       between addresses accessed by a memory reference is usually constant, we
       may add the prefetch instructions.

+      FIXME: This transformation was removed together with RTL based value
+      profiling.
+
+   3) Indirect/virtual call specialization. If we can determine most
+      common function callee in indirect/virtual call. We can use this
+      information to improve code effectiveness (especially info for
+      inliner).

 
    Every such optimization should add its requirements for profiled values to
    insn_values_to_profile function.  This function is called from branch_prob
 
    Every such optimization should add its requirements for profiled values to
    insn_values_to_profile function.  This function is called from branch_prob


@@ -66,1251 +72,1055 @@ static histogram_values static_values = NULL;
    compilation with -fprofile-arcs.  The optimization may then read the
    gathered data in the second compilation with -fbranch-probabilities.
 
    compilation with -fprofile-arcs.  The optimization may then read the
    gathered data in the second compilation with -fbranch-probabilities.
 

-   There are currently two versions, RTL-based and tree-based.  Over time
-   the RTL-based version may go away.  
-
-   In the RTL-based version, the measured data is appended as REG_VALUE_PROFILE 
-   note to the instrumented insn.  The argument to the note consists of an
-   EXPR_LIST where its members have the following meaning (from the first to 
-   the last):
-   
-   -- type of information gathered (HIST_TYPE*)
-   -- the expression that is profiled
-   -- list of counters starting from the first one.
-
-   In the tree-based version, the measured data is pointed to from the histograms
+   The measured data is pointed to from the histograms

    field of the statement annotation of the instrumented insns.  It is
    kept as a linked list of struct histogram_value_t's, which contain the
    same information as above.  */
 
    field of the statement annotation of the instrumented insns.  It is
    kept as a linked list of struct histogram_value_t's, which contain the
    same information as above.  */
 

-/* For speculative prefetching, the range in that we do not prefetch (because
-   we assume that it will be in cache anyway).  The asymmetry between min and
-   max range is trying to reflect the fact that the sequential prefetching
-   of the data is commonly done directly by hardware.  Nevertheless, these
-   values are just a guess and should of course be target-specific.  
-
-   FIXME:  There is no tree form of speculative prefetching as yet.

 
 

-   FIXME:  A better approach to instrumentation in the profile-generation
-   pass is to generate calls to magic library functions (to be added to
-   libgcc) rather than inline code.  This approach will probably be
-   necessary to get tree-based speculative prefetching working in a useful
-   fashion, as inline code bloats things so much the rest of the compiler has
-   serious problems dealing with it (judging from the rtl behavior).  */
+static tree gimple_divmod_fixed_value (gimple, tree, int, gcov_type, gcov_type);
+static tree gimple_mod_pow2 (gimple, int, gcov_type, gcov_type);
+static tree gimple_mod_subtract (gimple, int, int, int, gcov_type, gcov_type,
+                                gcov_type);
+static bool gimple_divmod_fixed_value_transform (gimple_stmt_iterator *);
+static bool gimple_mod_pow2_value_transform (gimple_stmt_iterator *);
+static bool gimple_mod_subtract_transform (gimple_stmt_iterator *);
+static bool gimple_stringops_transform (gimple_stmt_iterator *);
+static bool gimple_ic_transform (gimple);

 
 

-#ifndef NOPREFETCH_RANGE_MIN
-#define NOPREFETCH_RANGE_MIN (-16)
-#endif
-#ifndef NOPREFETCH_RANGE_MAX
-#define NOPREFETCH_RANGE_MAX 32
-#endif
+/* Allocate histogram value.  */

 
 

-static void rtl_divmod_values_to_profile (rtx, histogram_values *);
-#ifdef HAVE_prefetch
-static bool insn_prefetch_values_to_profile (rtx, histogram_values *);
-static int find_mem_reference_1 (rtx *, void *);
-static void find_mem_reference_2 (rtx, rtx, void *);
-static bool find_mem_reference (rtx, rtx *, int *);
-#endif
+static histogram_value
+gimple_alloc_histogram_value (struct function *fun ATTRIBUTE_UNUSED,
+                             enum hist_type type, gimple stmt, tree value)
+{
+   histogram_value hist = (histogram_value) xcalloc (1, sizeof (*hist));
+   hist->hvalue.value = value;
+   hist->hvalue.stmt = stmt;
+   hist->type = type;
+   return hist;
+}

 
 

-static void rtl_values_to_profile (rtx, histogram_values *);
-static rtx rtl_divmod_fixed_value (enum machine_mode, enum rtx_code, rtx, rtx,
-                                  rtx, gcov_type, int);
-static rtx rtl_mod_pow2 (enum machine_mode, enum rtx_code, rtx, rtx, rtx, int);
-static rtx rtl_mod_subtract (enum machine_mode, enum rtx_code, rtx, rtx, rtx,
-                            int, int, int);
-#ifdef HAVE_prefetch
-static rtx gen_speculative_prefetch (rtx, gcov_type, int);
-#endif
-static bool rtl_divmod_fixed_value_transform (rtx);
-static bool rtl_mod_pow2_value_transform (rtx);
-static bool rtl_mod_subtract_transform (rtx);
-#ifdef HAVE_prefetch
-static bool speculative_prefetching_transform (rtx);
-#endif
-static void tree_divmod_values_to_profile (tree, histogram_values *);
-static void tree_values_to_profile (tree, histogram_values *);
-static tree tree_divmod_fixed_value (tree, tree, tree, tree, 
-                                   tree, int, gcov_type, gcov_type);
-static tree tree_mod_pow2 (tree, tree, tree, tree, int, gcov_type, gcov_type);
-static tree tree_mod_subtract (tree, tree, tree, tree, int, int, int,
-                               gcov_type, gcov_type, gcov_type);
-static bool tree_divmod_fixed_value_transform (tree);
-static bool tree_mod_pow2_value_transform (tree);
-static bool tree_mod_subtract_transform (tree);
+/* Hash value for histogram.  */

 
 

-\f
-/* Find values inside INSN for that we want to measure histograms for
-   division/modulo optimization and stores them to VALUES.  */
-static void
-rtl_divmod_values_to_profile (rtx insn, histogram_values *values)
+static hashval_t
+histogram_hash (const void *x)

 {
 {

-  rtx set, set_src, op1, op2;
-  enum machine_mode mode;
-  histogram_value hist;
+  return htab_hash_pointer (((const_histogram_value)x)->hvalue.stmt);
+}

 
 

-  if (!INSN_P (insn))
-    return;
+/* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y.  */

 
 

-  set = single_set (insn);
-  if (!set)
-    return;
+static int
+histogram_eq (const void *x, const void *y)
+{
+  return ((const_histogram_value) x)->hvalue.stmt == (const_gimple) y;
+}

 
 

-  mode = GET_MODE (SET_DEST (set));
-  if (!INTEGRAL_MODE_P (mode))
-    return;
+/* Set histogram for STMT.  */

 
 

-  set_src = SET_SRC (set);
-  switch (GET_CODE (set_src))
+static void
+set_histogram_value (struct function *fun, gimple stmt, histogram_value hist)
+{
+  void **loc;
+  if (!hist && !VALUE_HISTOGRAMS (fun))
+    return;
+  if (!VALUE_HISTOGRAMS (fun))
+    VALUE_HISTOGRAMS (fun) = htab_create (1, histogram_hash,
+                                          histogram_eq, NULL);
+  loc = htab_find_slot_with_hash (VALUE_HISTOGRAMS (fun), stmt,
+                                  htab_hash_pointer (stmt),
+                                 hist ? INSERT : NO_INSERT);
+  if (!hist)

     {
     {

-    case DIV:
-    case MOD:
-    case UDIV:
-    case UMOD:
-      op1 = XEXP (set_src, 0);
-      op2 = XEXP (set_src, 1);
-      if (side_effects_p (op2))
-       return;
-
-      /* Check for a special case where the divisor is power of 2.  */
-      if ((GET_CODE (set_src) == UMOD) && !CONSTANT_P (op2))
-       {
-         hist = ggc_alloc (sizeof (*hist));
-         hist->hvalue.rtl.value = op2;
-         hist->hvalue.rtl.seq = NULL_RTX;
-         hist->hvalue.rtl.mode = mode;
-         hist->hvalue.rtl.insn = insn;
-         hist->type = HIST_TYPE_POW2;
-         hist->hdata.pow2.may_be_other = 1;
-         VEC_safe_push (histogram_value, *values, hist);
-       }
-
-      /* Check whether the divisor is not in fact a constant.  */
-      if (!CONSTANT_P (op2))
-       {
-         hist = ggc_alloc (sizeof (*hist));
-         hist->hvalue.rtl.value = op2;
-         hist->hvalue.rtl.mode = mode;
-         hist->hvalue.rtl.seq = NULL_RTX;
-         hist->hvalue.rtl.insn = insn;
-         hist->type = HIST_TYPE_SINGLE_VALUE;
-         VEC_safe_push (histogram_value, *values, hist);
-       }
-
-      /* For mod, check whether it is not often a noop (or replaceable by
-        a few subtractions).  */
-      if (GET_CODE (set_src) == UMOD && !side_effects_p (op1))
-       {
-         rtx tmp;
-
-         hist = ggc_alloc (sizeof (*hist));
-         start_sequence ();
-         tmp = simplify_gen_binary (DIV, mode, copy_rtx (op1), copy_rtx (op2));
-         hist->hvalue.rtl.value = force_operand (tmp, NULL_RTX);
-         hist->hvalue.rtl.seq = get_insns ();
-         end_sequence ();
-         hist->hvalue.rtl.mode = mode;
-         hist->hvalue.rtl.insn = insn;
-         hist->type = HIST_TYPE_INTERVAL;
-         hist->hdata.intvl.int_start = 0;
-         hist->hdata.intvl.steps = 2;
-         VEC_safe_push (histogram_value, *values, hist);
-       }
-      return;
-
-    default:
+      if (loc)
+       htab_clear_slot (VALUE_HISTOGRAMS (fun), loc);

       return;
     }
       return;
     }

+  *loc = hist;

 }
 
 }
 

-#ifdef HAVE_prefetch
-
-/* Called from find_mem_reference through for_each_rtx, finds a memory
-   reference.  I.e. if *EXPR is a MEM, the reference to this MEM is stored
-   to *RET and the traversing of the expression is interrupted by returning 1.
-   Otherwise 0 is returned.  */
+/* Get histogram list for STMT.  */

 
 

-static int
-find_mem_reference_1 (rtx *expr, void *ret)
+histogram_value
+gimple_histogram_value (struct function *fun, gimple stmt)

 {
 {

-  rtx *mem = ret;
-
-  if (GET_CODE (*expr) == MEM)
-    {
-      *mem = *expr;
-      return 1;
-    }
-  return 0;
+  if (!VALUE_HISTOGRAMS (fun))
+    return NULL;
+  return (histogram_value) htab_find_with_hash (VALUE_HISTOGRAMS (fun), stmt,
+                                               htab_hash_pointer (stmt));

 }
 
 }
 

-/* Called form find_mem_reference through note_stores to find out whether
-   the memory reference MEM is a store.  I.e. if EXPR == MEM, the variable
-   FMR2_WRITE is set to true.  */
+/* Add histogram for STMT.  */

 
 

-static int fmr2_write;
-static void
-find_mem_reference_2 (rtx expr, rtx pat ATTRIBUTE_UNUSED, void *mem)
+void
+gimple_add_histogram_value (struct function *fun, gimple stmt,
+                           histogram_value hist)

 {
 {

-  if (expr == mem)
-    fmr2_write = true;
+  hist->hvalue.next = gimple_histogram_value (fun, stmt);
+  set_histogram_value (fun, stmt, hist);

 }
 
 }
 

-/* Find a memory reference inside INSN, return it in MEM. Set WRITE to true
-   if it is a write of the mem.  Return false if no memory reference is found,
-   true otherwise.  */

 
 

-static bool
-find_mem_reference (rtx insn, rtx *mem, int *write)
-{
-  *mem = NULL_RTX;
-  for_each_rtx (&PATTERN (insn), find_mem_reference_1, mem);
+/* Remove histogram HIST from STMT's histogram list.  */

 
 

-  if (!*mem)
-    return false;
-  
-  fmr2_write = false;
-  note_stores (PATTERN (insn), find_mem_reference_2, *mem);
-  *write = fmr2_write;
-  return true;
+void
+gimple_remove_histogram_value (struct function *fun, gimple stmt,
+                              histogram_value hist)
+{
+  histogram_value hist2 = gimple_histogram_value (fun, stmt);
+  if (hist == hist2)
+    {
+      set_histogram_value (fun, stmt, hist->hvalue.next);
+    }
+  else
+    {
+      while (hist2->hvalue.next != hist)
+       hist2 = hist2->hvalue.next;
+      hist2->hvalue.next = hist->hvalue.next;
+    }
+  free (hist->hvalue.counters);
+#ifdef ENABLE_CHECKING
+  memset (hist, 0xab, sizeof (*hist));
+#endif
+  free (hist);

 }
 
 }
 

-/* Find values inside INSN for that we want to measure histograms for
-   a speculative prefetching.  Add them to the list VALUES.
-   Returns true if such we found any such value, false otherwise.  */

 
 

-static bool
-insn_prefetch_values_to_profile (rtx insn, histogram_values* values)
+/* Lookup histogram of type TYPE in the STMT.  */
+
+histogram_value
+gimple_histogram_value_of_type (struct function *fun, gimple stmt,
+                               enum hist_type type)

 {
 {

-  rtx mem, address;
-  int write;

   histogram_value hist;
   histogram_value hist;

-
-  /* It only makes sense to look for memory references in ordinary insns.  */
-  if (GET_CODE (insn) != INSN)
-    return false;
-
-  if (!find_mem_reference (insn, &mem, &write))
-    return false;
-
-  address = XEXP (mem, 0);
-  if (side_effects_p (address))
-    return false;
-      
-  if (CONSTANT_P (address))
-    return false;
-
-  hist = ggc_alloc (sizeof (*hist));
-  hist->hvalue.rtl.value = address;
-  hist->hvalue.rtl.mode = GET_MODE (address);
-  hist->hvalue.rtl.seq = NULL_RTX;
-  hist->hvalue.rtl.insn = insn;
-  hist->type = HIST_TYPE_CONST_DELTA;
-  VEC_safe_push (histogram_value, *values, hist);
-
-  return true;
+  for (hist = gimple_histogram_value (fun, stmt); hist;
+       hist = hist->hvalue.next)
+    if (hist->type == type)
+      return hist;
+  return NULL;

 }
 }

-#endif
-/* Find values inside INSN for that we want to measure histograms and adds
-   them to list VALUES (increasing the record of its length in N_VALUES).  */
-static void
-rtl_values_to_profile (rtx insn, histogram_values *values)
-{
-  if (flag_value_profile_transformations)
-    rtl_divmod_values_to_profile (insn, values);

 
 

-#ifdef HAVE_prefetch
-  if (flag_speculative_prefetching)
-    insn_prefetch_values_to_profile (insn, values);
-#endif
-}
+/* Dump information about HIST to DUMP_FILE.  */

 
 

-/* Find list of values for that we want to measure histograms.  */

 static void
 static void

-rtl_find_values_to_profile (histogram_values *values)
+dump_histogram_value (FILE *dump_file, histogram_value hist)

 {
 {

-  rtx insn;
-  unsigned i, libcall_level;
-
-  life_analysis (NULL, PROP_DEATH_NOTES);
-
-  *values = VEC_alloc (histogram_value, 0);
-  libcall_level = 0;
-  for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
-    rtl_values_to_profile (insn, values);
-  static_values = *values;
-
-  for (i = 0; i < VEC_length (histogram_value, *values); i++)
+  switch (hist->type)

     {
     {

-      histogram_value hist = VEC_index (histogram_value, *values, i);
+    case HIST_TYPE_INTERVAL:
+      fprintf (dump_file, "Interval counter range %d -- %d",
+              hist->hdata.intvl.int_start,
+              (hist->hdata.intvl.int_start
+               + hist->hdata.intvl.steps - 1));
+      if (hist->hvalue.counters)
+       {
+          unsigned int i;
+          fprintf(dump_file, " [");
+           for (i = 0; i < hist->hdata.intvl.steps; i++)
+            fprintf (dump_file, " %d:"HOST_WIDEST_INT_PRINT_DEC,
+                     hist->hdata.intvl.int_start + i,
+                     (HOST_WIDEST_INT) hist->hvalue.counters[i]);
+          fprintf (dump_file, " ] outside range:"HOST_WIDEST_INT_PRINT_DEC,
+                   (HOST_WIDEST_INT) hist->hvalue.counters[i]);
+       }
+      fprintf (dump_file, ".\n");
+      break;

 
 

-      switch (hist->type)
+    case HIST_TYPE_POW2:
+      fprintf (dump_file, "Pow2 counter ");
+      if (hist->hvalue.counters)

        {
        {

-       case HIST_TYPE_INTERVAL:
-         if (dump_file)
-           fprintf (dump_file,
-                    "Interval counter for insn %d, range %d -- %d.\n",
-                    INSN_UID ((rtx)hist->hvalue.rtl.insn),
-                    hist->hdata.intvl.int_start,
-                    (hist->hdata.intvl.int_start
-                     + hist->hdata.intvl.steps - 1));
-         hist->n_counters = hist->hdata.intvl.steps + 2;
-         break;
+          fprintf (dump_file, "pow2:"HOST_WIDEST_INT_PRINT_DEC
+                   " nonpow2:"HOST_WIDEST_INT_PRINT_DEC,
+                   (HOST_WIDEST_INT) hist->hvalue.counters[0],
+                   (HOST_WIDEST_INT) hist->hvalue.counters[1]);
+       }
+      fprintf (dump_file, ".\n");
+      break;

 
 

-       case HIST_TYPE_POW2:
-         if (dump_file)
-           fprintf (dump_file,
-                    "Pow2 counter for insn %d.\n",
-                    INSN_UID ((rtx)hist->hvalue.rtl.insn));
-         hist->n_counters 
-               = GET_MODE_BITSIZE (hist->hvalue.rtl.mode)
-                 +  (hist->hdata.pow2.may_be_other ? 1 : 0);
-         break;
+    case HIST_TYPE_SINGLE_VALUE:
+      fprintf (dump_file, "Single value ");
+      if (hist->hvalue.counters)
+       {
+          fprintf (dump_file, "value:"HOST_WIDEST_INT_PRINT_DEC
+                   " match:"HOST_WIDEST_INT_PRINT_DEC
+                   " wrong:"HOST_WIDEST_INT_PRINT_DEC,
+                   (HOST_WIDEST_INT) hist->hvalue.counters[0],
+                   (HOST_WIDEST_INT) hist->hvalue.counters[1],
+                   (HOST_WIDEST_INT) hist->hvalue.counters[2]);
+       }
+      fprintf (dump_file, ".\n");
+      break;

 
 

-       case HIST_TYPE_SINGLE_VALUE:
-         if (dump_file)
-           fprintf (dump_file,
-                    "Single value counter for insn %d.\n",
-                    INSN_UID ((rtx)hist->hvalue.rtl.insn));
-         hist->n_counters = 3;
-         break;
+    case HIST_TYPE_AVERAGE:
+      fprintf (dump_file, "Average value ");
+      if (hist->hvalue.counters)
+       {
+          fprintf (dump_file, "sum:"HOST_WIDEST_INT_PRINT_DEC
+                   " times:"HOST_WIDEST_INT_PRINT_DEC,
+                   (HOST_WIDEST_INT) hist->hvalue.counters[0],
+                   (HOST_WIDEST_INT) hist->hvalue.counters[1]);
+       }
+      fprintf (dump_file, ".\n");
+      break;

 
 

-       case HIST_TYPE_CONST_DELTA:
-         if (dump_file)
-           fprintf (dump_file,
-                    "Constant delta counter for insn %d.\n",
-                    INSN_UID ((rtx)hist->hvalue.rtl.insn));
-         hist->n_counters = 4;
-         break;
+    case HIST_TYPE_IOR:
+      fprintf (dump_file, "IOR value ");
+      if (hist->hvalue.counters)
+       {
+          fprintf (dump_file, "ior:"HOST_WIDEST_INT_PRINT_DEC,
+                   (HOST_WIDEST_INT) hist->hvalue.counters[0]);
+       }
+      fprintf (dump_file, ".\n");
+      break;

 
 

-       default:
-         gcc_unreachable ();
+    case HIST_TYPE_CONST_DELTA:
+      fprintf (dump_file, "Constant delta ");
+      if (hist->hvalue.counters)
+       {
+          fprintf (dump_file, "value:"HOST_WIDEST_INT_PRINT_DEC
+                   " match:"HOST_WIDEST_INT_PRINT_DEC
+                   " wrong:"HOST_WIDEST_INT_PRINT_DEC,
+                   (HOST_WIDEST_INT) hist->hvalue.counters[0],
+                   (HOST_WIDEST_INT) hist->hvalue.counters[1],
+                   (HOST_WIDEST_INT) hist->hvalue.counters[2]);

        }
        }

-    }
-  allocate_reg_info (max_reg_num (), FALSE, FALSE);
+      fprintf (dump_file, ".\n");
+      break;
+    case HIST_TYPE_INDIR_CALL:
+      fprintf (dump_file, "Indirect call ");
+      if (hist->hvalue.counters)
+       {
+          fprintf (dump_file, "value:"HOST_WIDEST_INT_PRINT_DEC
+                   " match:"HOST_WIDEST_INT_PRINT_DEC
+                   " all:"HOST_WIDEST_INT_PRINT_DEC,
+                   (HOST_WIDEST_INT) hist->hvalue.counters[0],
+                   (HOST_WIDEST_INT) hist->hvalue.counters[1],
+                   (HOST_WIDEST_INT) hist->hvalue.counters[2]);
+       }
+      fprintf (dump_file, ".\n");
+      break;
+   }

 }
 
 }
 

-/* Main entry point.  Finds REG_VALUE_PROFILE notes from profiler and uses
-   them to identify and exploit properties of values that are hard to analyze
-   statically.
+/* Dump all histograms attached to STMT to DUMP_FILE.  */

 
 

-   We do following transformations:
-
-   1)
+void
+dump_histograms_for_stmt (struct function *fun, FILE *dump_file, gimple stmt)
+{
+  histogram_value hist;
+  for (hist = gimple_histogram_value (fun, stmt); hist; hist = hist->hvalue.next)
+   dump_histogram_value (dump_file, hist);
+}

 
 

-   x = a / b;
+/* Remove all histograms associated with STMT.  */

 
 

-   where b is almost always a constant N is transformed to
+void
+gimple_remove_stmt_histograms (struct function *fun, gimple stmt)
+{
+  histogram_value val;
+  while ((val = gimple_histogram_value (fun, stmt)) != NULL)
+    gimple_remove_histogram_value (fun, stmt, val);
+}

 
 

-   if (b == N)
-     x = a / N;
-   else
-     x = a / b;
+/* Duplicate all histograms associates with OSTMT to STMT.  */

 
 

-   Analogically with %
+void
+gimple_duplicate_stmt_histograms (struct function *fun, gimple stmt,
+                                 struct function *ofun, gimple ostmt)
+{
+  histogram_value val;
+  for (val = gimple_histogram_value (ofun, ostmt); val != NULL; val = val->hvalue.next)
+    {
+      histogram_value new_val = gimple_alloc_histogram_value (fun, val->type, NULL, NULL);
+      memcpy (new_val, val, sizeof (*val));
+      new_val->hvalue.stmt = stmt;
+      new_val->hvalue.counters = XNEWVAR (gcov_type, sizeof (*new_val->hvalue.counters) * new_val->n_counters);
+      memcpy (new_val->hvalue.counters, val->hvalue.counters, sizeof (*new_val->hvalue.counters) * new_val->n_counters);
+      gimple_add_histogram_value (fun, stmt, new_val);
+    }
+}

 
 

-   2)

 
 

-   x = a % b
+/* Move all histograms associated with OSTMT to STMT.  */

 
 

-   where b is almost always a power of 2 and the division is unsigned
-   TODO -- handle signed case as well
+void
+gimple_move_stmt_histograms (struct function *fun, gimple stmt, gimple ostmt)
+{
+  histogram_value val = gimple_histogram_value (fun, ostmt);
+  if (val)
+    {
+      /* The following three statements can't be reordered,
+         because histogram hashtab relies on stmt field value
+        for finding the exact slot. */
+      set_histogram_value (fun, ostmt, NULL);
+      for (; val != NULL; val = val->hvalue.next)
+       val->hvalue.stmt = stmt;
+      set_histogram_value (fun, stmt, val);
+    }
+}

 
 

-   if ((b & (b - 1)) == 0)
-     x = a & (b - 1);
-   else
-     x = x % b;
+static bool error_found = false;

 
 

-   Note that when b = 0, no error will occur and x = a; this is correct,
-   as result of such operation is undefined.
+/* Helper function for verify_histograms.  For each histogram reachable via htab
+   walk verify that it was reached via statement walk.  */

 
 

-   3)
+static int
+visit_hist (void **slot, void *data)
+{
+  struct pointer_set_t *visited = (struct pointer_set_t *) data;
+  histogram_value hist = *(histogram_value *) slot;
+  if (!pointer_set_contains (visited, hist))
+    {
+      error ("Dead histogram");
+      dump_histogram_value (stderr, hist);
+      debug_gimple_stmt (hist->hvalue.stmt);
+      error_found = true;
+    }
+  return 1;
+}

 
 

-   x = a % b

 
 

-   where a is almost always less then b and the division is unsigned
-   TODO -- handle signed case as well
+/* Verify sanity of the histograms.  */

 
 

-   x = a;
-   if (x >= b)
-     x %= b;
+void
+verify_histograms (void)
+{
+  basic_block bb;
+  gimple_stmt_iterator gsi;
+  histogram_value hist;
+  struct pointer_set_t *visited_hists;

 
 

-   4)
+  error_found = false;
+  visited_hists = pointer_set_create ();
+  FOR_EACH_BB (bb)
+    for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+      {
+       gimple stmt = gsi_stmt (gsi);
+
+       for (hist = gimple_histogram_value (cfun, stmt); hist;
+            hist = hist->hvalue.next)
+         {
+           if (hist->hvalue.stmt != stmt)
+             {
+               error ("Histogram value statement does not correspond to "
+                      "the statement it is associated with");
+               debug_gimple_stmt (stmt);
+               dump_histogram_value (stderr, hist);
+               error_found = true;
+             }
+            pointer_set_insert (visited_hists, hist);
+         }
+      }
+  if (VALUE_HISTOGRAMS (cfun))
+    htab_traverse (VALUE_HISTOGRAMS (cfun), visit_hist, visited_hists);
+  pointer_set_destroy (visited_hists);
+  if (error_found)
+    internal_error ("verify_histograms failed");
+}

 
 

-   x = a % b
+/* Helper function for verify_histograms.  For each histogram reachable via htab
+   walk verify that it was reached via statement walk.  */

 
 

-   where a is almost always less then 2 * b and the division is unsigned
-   TODO -- handle signed case as well
+static int
+free_hist (void **slot, void *data ATTRIBUTE_UNUSED)
+{
+  histogram_value hist = *(histogram_value *) slot;
+  free (hist->hvalue.counters);
+#ifdef ENABLE_CHECKING
+  memset (hist, 0xab, sizeof (*hist));
+#endif
+  free (hist);
+  return 1;
+}

 
 

-   x = a;
-   if (x >= b)
-     x -= b;
-   if (x >= b)
-     x %= b;
+void
+free_histograms (void)
+{
+  if (VALUE_HISTOGRAMS (cfun))
+    {
+      htab_traverse (VALUE_HISTOGRAMS (cfun), free_hist, NULL);
+      htab_delete (VALUE_HISTOGRAMS (cfun));
+      VALUE_HISTOGRAMS (cfun) = NULL;
+    }
+}

 
 

-   It would be possible to continue analogically for K * b for other small
-   K's, but it is probably not useful.

 
 

-   5)
+/* The overall number of invocations of the counter should match
+   execution count of basic block.  Report it as error rather than
+   internal error as it might mean that user has misused the profile
+   somehow.  */

 
 

-   Read or write of mem[address], where the value of address changes usually
-   by a constant C != 0 between the following accesses to the computation; with
-   -fspeculative-prefetching we then add a prefetch of address + C before
-   the insn.  This handles prefetching of several interesting cases in addition
-   to a simple prefetching for addresses that are induction variables, e. g.
-   linked lists allocated sequentially (even in case they are processed
-   recursively).
+static bool
+check_counter (gimple stmt, const char * name,
+              gcov_type *count, gcov_type *all, gcov_type bb_count)
+{
+  if (*all != bb_count || *count > *all)
+    {
+      location_t locus;
+      locus = (stmt != NULL)
+              ? gimple_location (stmt)
+              : DECL_SOURCE_LOCATION (current_function_decl);
+      if (flag_profile_correction)
+        {
+         inform (locus, "Correcting inconsistent value profile: "
+                 "%s profiler overall count (%d) does not match BB count "
+                  "(%d)", name, (int)*all, (int)bb_count);
+         *all = bb_count;
+         if (*count > *all)
+            *count = *all;
+         return false;
+       }
+      else
+       {
+         error_at (locus, "Corrupted value profile: %s "
+                   "profiler overall count (%d) does not match BB count (%d)",
+                   name, (int)*all, (int)bb_count);
+         return true;
+       }
+    }

 
 

-   TODO -- we should also check whether there is not (usually) a small
-          difference with the adjacent memory references, so that we do
-          not issue overlapping prefetches.  Also we should employ some
-          heuristics to eliminate cases where prefetching evidently spoils
-          the code.
-       -- it should somehow cooperate with the loop optimizer prefetching
+  return false;
+}

 
 

-   TODO:

 
 

-   There are other useful cases that could be handled by a similar mechanism,
-   for example:
-   
-   for (i = 0; i < n; i++)
-     ...
-   
-   transform to (for constant N):
-   
-   if (n == N)
-     for (i = 0; i < N; i++)
-       ...
-   else
-     for (i = 0; i < n; i++)
-       ...
-   making unroller happy.  Since this may grow the code significantly,
-   we would have to be very careful here.  */
+/* GIMPLE based transformations. */

 
 static bool
 
 static bool

-rtl_value_profile_transformations (void)
+gimple_value_profile_transformations (void)

 {
 {

-  rtx insn, next;
-  int changed = false;
+  basic_block bb;
+  gimple_stmt_iterator gsi;
+  bool changed = false;

 
 

-  for (insn = get_insns (); insn; insn = next)
+  FOR_EACH_BB (bb)

     {
     {

-      next = NEXT_INSN (insn);
-
-      if (!INSN_P (insn))
-       continue;
-
-      /* Scan for insn carrying a histogram.  */
-      if (!find_reg_note (insn, REG_VALUE_PROFILE, 0))
-       continue;
-
-      /* Ignore cold areas -- we are growing a code.  */
-      if (!maybe_hot_bb_p (BLOCK_FOR_INSN (insn)))
-       continue;
-
-      if (dump_file)
+      for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))

        {
        {

-         fprintf (dump_file, "Trying transformations on insn %d\n",
-                  INSN_UID (insn));
-         print_rtl_single (dump_file, insn);
-       }
+         gimple stmt = gsi_stmt (gsi);
+         histogram_value th = gimple_histogram_value (cfun, stmt);
+         if (!th)
+           continue;

 
 

-      /* Transformations:  */
-      if (flag_value_profile_transformations
-         && (rtl_mod_subtract_transform (insn)
-             || rtl_divmod_fixed_value_transform (insn)
-             || rtl_mod_pow2_value_transform (insn)))
-       changed = true;
-#ifdef HAVE_prefetch
-      if (flag_speculative_prefetching
-         && speculative_prefetching_transform (insn))
-       changed = true;
-#endif
+         if (dump_file)
+           {
+             fprintf (dump_file, "Trying transformations on stmt ");
+             print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
+             dump_histograms_for_stmt (cfun, dump_file, stmt);
+           }
+
+         /* Transformations:  */
+         /* The order of things in this conditional controls which
+            transformation is used when more than one is applicable.  */
+         /* It is expected that any code added by the transformations
+            will be added before the current statement, and that the
+            current statement remain valid (although possibly
+            modified) upon return.  */
+         if (flag_value_profile_transformations
+             && (gimple_mod_subtract_transform (&gsi)
+                 || gimple_divmod_fixed_value_transform (&gsi)
+                 || gimple_mod_pow2_value_transform (&gsi)
+                 || gimple_stringops_transform (&gsi)
+                 || gimple_ic_transform (stmt)))
+           {
+             stmt = gsi_stmt (gsi);
+             changed = true;
+             /* Original statement may no longer be in the same block. */
+             if (bb != gimple_bb (stmt))
+               {
+                 bb = gimple_bb (stmt);
+                 gsi = gsi_for_stmt (stmt);
+               }
+           }
+        }

     }
 
   if (changed)
     {
     }
 
   if (changed)
     {

-      commit_edge_insertions ();
-      allocate_reg_info (max_reg_num (), FALSE, FALSE);
+      counts_to_freqs ();

     }
 
   return changed;
 }
 
     }
 
   return changed;
 }
 

-/* Generate code for transformation 1 (with MODE and OPERATION, operands OP1
-   and OP2, whose value is expected to be VALUE, result TARGET and
-   probability of taking the optimal path PROB).  */
-static rtx
-rtl_divmod_fixed_value (enum machine_mode mode, enum rtx_code operation,
-                       rtx target, rtx op1, rtx op2, gcov_type value,
-                       int prob)
-{
-  rtx tmp, tmp1, jump;
-  rtx neq_label = gen_label_rtx ();
-  rtx end_label = gen_label_rtx ();
-  rtx sequence;
-
-  start_sequence ();
-  
-  if (!REG_P (op2))
-    {
-      tmp = gen_reg_rtx (mode);
-      emit_move_insn (tmp, copy_rtx (op2));
-    }
-  else
-    tmp = op2;
-
-  do_compare_rtx_and_jump (tmp, GEN_INT (value), NE, 0, mode, NULL_RTX,
-                          NULL_RTX, neq_label);
-
-  /* Add branch probability to jump we just created.  */
-  jump = get_last_insn ();
-  REG_NOTES (jump) = gen_rtx_EXPR_LIST (REG_BR_PROB,
-                                       GEN_INT (REG_BR_PROB_BASE - prob),
-                                       REG_NOTES (jump));
-
-  tmp1 = simplify_gen_binary (operation, mode,
-                             copy_rtx (op1), GEN_INT (value));
-  tmp1 = force_operand (tmp1, target);
-  if (tmp1 != target)
-    emit_move_insn (copy_rtx (target), copy_rtx (tmp1));
-
-  emit_jump_insn (gen_jump (end_label));
-  emit_barrier ();
-
-  emit_label (neq_label);
-  tmp1 = simplify_gen_binary (operation, mode,
-                             copy_rtx (op1), copy_rtx (tmp));
-  tmp1 = force_operand (tmp1, target);
-  if (tmp1 != target)
-    emit_move_insn (copy_rtx (target), copy_rtx (tmp1));
-  
-  emit_label (end_label);

 
 

-  sequence = get_insns ();
-  end_sequence ();
-  rebuild_jump_labels (sequence);
-  return sequence;
-}
+/* Generate code for transformation 1 (with parent gimple assignment
+   STMT and probability of taking the optimal path PROB, which is
+   equivalent to COUNT/ALL within roundoff error).  This generates the
+   result into a temp and returns the temp; it does not replace or
+   alter the original STMT.  */

 
 

-/* Do transform 1) on INSN if applicable.  */
-static bool
-rtl_divmod_fixed_value_transform (rtx insn)
+static tree
+gimple_divmod_fixed_value (gimple stmt, tree value, int prob, gcov_type count,
+                          gcov_type all)

 {
 {

-  rtx set, set_src, set_dest, op1, op2, value, histogram;
-  enum rtx_code code;
-  enum machine_mode mode;
-  gcov_type val, count, all;
-  edge e;
-  int prob;
+  gimple stmt1, stmt2, stmt3;
+  tree tmp1, tmp2, tmpv;
+  gimple bb1end, bb2end, bb3end;
+  basic_block bb, bb2, bb3, bb4;
+  tree optype, op1, op2;
+  edge e12, e13, e23, e24, e34;
+  gimple_stmt_iterator gsi;

 
 

-  set = single_set (insn);
-  if (!set)
-    return false;
+  gcc_assert (is_gimple_assign (stmt)
+             && (gimple_assign_rhs_code (stmt) == TRUNC_DIV_EXPR
+                 || gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR));

 
 

-  set_src = SET_SRC (set);
-  set_dest = SET_DEST (set);
-  code = GET_CODE (set_src);
-  mode = GET_MODE (set_dest);
-  
-  if (code != DIV && code != MOD && code != UDIV && code != UMOD)
-    return false;
-  op1 = XEXP (set_src, false);
-  op2 = XEXP (set_src, 1);
-
-  for (histogram = REG_NOTES (insn);
-       histogram;
-       histogram = XEXP (histogram, 1))
-    if (REG_NOTE_KIND (histogram) == REG_VALUE_PROFILE
-       && XEXP (XEXP (histogram, 0), 0) == GEN_INT (HIST_TYPE_SINGLE_VALUE))
-      break;
+  optype = TREE_TYPE (gimple_assign_lhs (stmt));
+  op1 = gimple_assign_rhs1 (stmt);
+  op2 = gimple_assign_rhs2 (stmt);

 
 

-  if (!histogram)
-    return false;
+  bb = gimple_bb (stmt);
+  gsi = gsi_for_stmt (stmt);

 
 

-  histogram = XEXP (XEXP (histogram, 0), 1);
-  value = XEXP (histogram, 0);
-  histogram = XEXP (histogram, 1);
-  val = INTVAL (XEXP (histogram, 0));
-  histogram = XEXP (histogram, 1);
-  count = INTVAL (XEXP (histogram, 0));
-  histogram = XEXP (histogram, 1);
-  all = INTVAL (XEXP (histogram, 0));
+  tmpv = create_tmp_var (optype, "PROF");
+  tmp1 = create_tmp_var (optype, "PROF");
+  stmt1 = gimple_build_assign (tmpv, fold_convert (optype, value));
+  stmt2 = gimple_build_assign (tmp1, op2);
+  stmt3 = gimple_build_cond (NE_EXPR, tmp1, tmpv, NULL_TREE, NULL_TREE);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
+  gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
+  gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
+  bb1end = stmt3;

 
 

-  /* We require that count be at least half of all; this means
-     that for the transformation to fire the value must be constant
-     at least 50% of time (and 75% gives the guarantee of usage).  */
-  if (!rtx_equal_p (op2, value) || 2 * count < all)
-    return false;
+  tmp2 = create_tmp_var (optype, "PROF");
+  stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2,
+                                       op1, tmpv);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
+  bb2end = stmt1;

 
 

-  if (dump_file)
-    fprintf (dump_file, "Div/mod by constant transformation on insn %d\n",
-            INSN_UID (insn));
+  stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2,
+                                       op1, op2);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
+  bb3end = stmt1;

 
 

-  /* Compute probability of taking the optimal path.  */
-  prob = (count * REG_BR_PROB_BASE + all / 2) / all;
+  /* Fix CFG. */
+  /* Edge e23 connects bb2 to bb3, etc. */
+  e12 = split_block (bb, bb1end);
+  bb2 = e12->dest;
+  bb2->count = count;
+  e23 = split_block (bb2, bb2end);
+  bb3 = e23->dest;
+  bb3->count = all - count;
+  e34 = split_block (bb3, bb3end);
+  bb4 = e34->dest;
+  bb4->count = all;

 
 

-  e = split_block (BLOCK_FOR_INSN (insn), PREV_INSN (insn));
-  delete_insn (insn);
-  
-  insert_insn_on_edge (
-       rtl_divmod_fixed_value (mode, code, set_dest,
-                               op1, op2, val, prob), e);
+  e12->flags &= ~EDGE_FALLTHRU;
+  e12->flags |= EDGE_FALSE_VALUE;
+  e12->probability = prob;
+  e12->count = count;

 
 

-  return true;
-}
+  e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
+  e13->probability = REG_BR_PROB_BASE - prob;
+  e13->count = all - count;

 
 

-/* Generate code for transformation 2 (with MODE and OPERATION, operands OP1
-   and OP2, result TARGET and probability of taking the optimal path PROB).  */
-static rtx
-rtl_mod_pow2 (enum machine_mode mode, enum rtx_code operation, rtx target,
-             rtx op1, rtx op2, int prob)
-{
-  rtx tmp, tmp1, tmp2, tmp3, jump;
-  rtx neq_label = gen_label_rtx ();
-  rtx end_label = gen_label_rtx ();
-  rtx sequence;
-
-  start_sequence ();
-  
-  if (!REG_P (op2))
-    {
-      tmp = gen_reg_rtx (mode);
-      emit_move_insn (tmp, copy_rtx (op2));
-    }
-  else
-    tmp = op2;
-
-  tmp1 = expand_simple_binop (mode, PLUS, tmp, constm1_rtx, NULL_RTX,
-                             0, OPTAB_WIDEN);
-  tmp2 = expand_simple_binop (mode, AND, tmp, tmp1, NULL_RTX,
-                             0, OPTAB_WIDEN);
-  do_compare_rtx_and_jump (tmp2, const0_rtx, NE, 0, mode, NULL_RTX,
-                          NULL_RTX, neq_label);
-
-  /* Add branch probability to jump we just created.  */
-  jump = get_last_insn ();
-  REG_NOTES (jump) = gen_rtx_EXPR_LIST (REG_BR_PROB,
-                                       GEN_INT (REG_BR_PROB_BASE - prob),
-                                       REG_NOTES (jump));
-
-  tmp3 = expand_simple_binop (mode, AND, op1, tmp1, target,
-                             0, OPTAB_WIDEN);
-  if (tmp3 != target)
-    emit_move_insn (copy_rtx (target), tmp3);
-  emit_jump_insn (gen_jump (end_label));
-  emit_barrier ();
-
-  emit_label (neq_label);
-  tmp1 = simplify_gen_binary (operation, mode, copy_rtx (op1), copy_rtx (tmp));
-  tmp1 = force_operand (tmp1, target);
-  if (tmp1 != target)
-    emit_move_insn (target, tmp1);
+  remove_edge (e23);

   
   

-  emit_label (end_label);
+  e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
+  e24->probability = REG_BR_PROB_BASE;
+  e24->count = count;

 
 

-  sequence = get_insns ();
-  end_sequence ();
-  rebuild_jump_labels (sequence);
-  return sequence;
+  e34->probability = REG_BR_PROB_BASE;
+  e34->count = all - count;
+
+  return tmp2;

 }
 
 }
 

-/* Do transform 2) on INSN if applicable.  */
+
+/* Do transform 1) on INSN if applicable.  */
+

 static bool
 static bool

-rtl_mod_pow2_value_transform (rtx insn)
+gimple_divmod_fixed_value_transform (gimple_stmt_iterator *si)

 {
 {

-  rtx set, set_src, set_dest, op1, op2, value, histogram;
-  enum rtx_code code;
-  enum machine_mode mode;
-  gcov_type wrong_values, count;
-  edge e;
-  int i, all, prob;
-
-  set = single_set (insn);
-  if (!set)
+  histogram_value histogram;
+  enum tree_code code;
+  gcov_type val, count, all;
+  tree result, value, tree_val;
+  gcov_type prob;
+  gimple stmt;
+
+  stmt = gsi_stmt (*si);
+  if (gimple_code (stmt) != GIMPLE_ASSIGN)

     return false;
 
     return false;
 

-  set_src = SET_SRC (set);
-  set_dest = SET_DEST (set);
-  code = GET_CODE (set_src);
-  mode = GET_MODE (set_dest);
+  if (!INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_lhs (stmt))))
+    return false;
+
+  code = gimple_assign_rhs_code (stmt);

   
   

-  if (code != UMOD)
+  if (code != TRUNC_DIV_EXPR && code != TRUNC_MOD_EXPR)

     return false;
     return false;

-  op1 = XEXP (set_src, 0);
-  op2 = XEXP (set_src, 1);
-
-  for (histogram = REG_NOTES (insn);
-       histogram;
-       histogram = XEXP (histogram, 1))
-    if (REG_NOTE_KIND (histogram) == REG_VALUE_PROFILE
-       && XEXP (XEXP (histogram, 0), 0) == GEN_INT (HIST_TYPE_POW2))
-      break;

 
 

+  histogram = gimple_histogram_value_of_type (cfun, stmt,
+                                             HIST_TYPE_SINGLE_VALUE);

   if (!histogram)
     return false;
 
   if (!histogram)
     return false;
 

-  histogram = XEXP (XEXP (histogram, 0), 1);
-  value = XEXP (histogram, 0);
-  histogram = XEXP (histogram, 1);
-  wrong_values =INTVAL (XEXP (histogram, 0));
-  histogram = XEXP (histogram, 1);
-
-  count = 0;
-  for (i = 0; i < GET_MODE_BITSIZE (mode); i++)
-    {
-      count += INTVAL (XEXP (histogram, 0));
-      histogram = XEXP (histogram, 1);
-    }
+  value = histogram->hvalue.value;
+  val = histogram->hvalue.counters[0];
+  count = histogram->hvalue.counters[1];
+  all = histogram->hvalue.counters[2];
+  gimple_remove_histogram_value (cfun, stmt, histogram);

 
 

-  if (!rtx_equal_p (op2, value))
+  /* We require that count is at least half of all; this means
+     that for the transformation to fire the value must be constant
+     at least 50% of time (and 75% gives the guarantee of usage).  */
+  if (simple_cst_equal (gimple_assign_rhs2 (stmt), value) != 1
+      || 2 * count < all
+      || optimize_bb_for_size_p (gimple_bb (stmt)))

     return false;
 
     return false;
 

-  /* We require that we hit a power of two at least half of all evaluations.  */
-  if (count < wrong_values)
+  if (check_counter (stmt, "value", &count, &all, gimple_bb (stmt)->count))

     return false;
 
     return false;
 

-  if (dump_file)
-    fprintf (dump_file, "Mod power of 2 transformation on insn %d\n",
-            INSN_UID (insn));
-

   /* Compute probability of taking the optimal path.  */
   /* Compute probability of taking the optimal path.  */

-  all = count + wrong_values;
-  prob = (count * REG_BR_PROB_BASE + all / 2) / all;
-
-  e = split_block (BLOCK_FOR_INSN (insn), PREV_INSN (insn));
-  delete_insn (insn);
-  
-  insert_insn_on_edge (
-       rtl_mod_pow2 (mode, code, set_dest, op1, op2, prob), e);
-
-  return true;
-}
-
-/* Generate code for transformations 3 and 4 (with MODE and OPERATION,
-   operands OP1 and OP2, result TARGET, at most SUB subtractions, and
-   probability of taking the optimal path(s) PROB1 and PROB2).  */
-static rtx
-rtl_mod_subtract (enum machine_mode mode, enum rtx_code operation,
-                 rtx target, rtx op1, rtx op2, int sub, int prob1, int prob2)
-{
-  rtx tmp, tmp1, jump;
-  rtx end_label = gen_label_rtx ();
-  rtx sequence;
-  int i;
-
-  start_sequence ();
-  
-  if (!REG_P (op2))
-    {
-      tmp = gen_reg_rtx (mode);
-      emit_move_insn (tmp, copy_rtx (op2));
-    }
+  if (all > 0)
+    prob = (count * REG_BR_PROB_BASE + all / 2) / all;

   else
   else

-    tmp = op2;
+    prob = 0;

 
 

-  emit_move_insn (target, copy_rtx (op1));
-  do_compare_rtx_and_jump (target, tmp, LTU, 0, mode, NULL_RTX,
-                          NULL_RTX, end_label);
-
-  /* Add branch probability to jump we just created.  */
-  jump = get_last_insn ();
-  REG_NOTES (jump) = gen_rtx_EXPR_LIST (REG_BR_PROB,
-                                       GEN_INT (prob1), REG_NOTES (jump));
+  tree_val = build_int_cst_wide (get_gcov_type (),
+                                (unsigned HOST_WIDE_INT) val,
+                                val >> (HOST_BITS_PER_WIDE_INT - 1) >> 1);
+  result = gimple_divmod_fixed_value (stmt, tree_val, prob, count, all);

 
 

-  for (i = 0; i < sub; i++)
+  if (dump_file)

     {
     {

-      tmp1 = expand_simple_binop (mode, MINUS, target, tmp, target,
-                                 0, OPTAB_WIDEN);
-      if (tmp1 != target)
-       emit_move_insn (target, tmp1);
-      do_compare_rtx_and_jump (target, tmp, LTU, 0, mode, NULL_RTX,
-                              NULL_RTX, end_label);
-
-      /* Add branch probability to jump we just created.  */
-      jump = get_last_insn ();
-      REG_NOTES (jump) = gen_rtx_EXPR_LIST (REG_BR_PROB,
-                                           GEN_INT (prob2), REG_NOTES (jump));
+      fprintf (dump_file, "Div/mod by constant ");
+      print_generic_expr (dump_file, value, TDF_SLIM);
+      fprintf (dump_file, "=");
+      print_generic_expr (dump_file, tree_val, TDF_SLIM);
+      fprintf (dump_file, " transformation on insn ");
+      print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);

     }
 
     }
 

-  tmp1 = simplify_gen_binary (operation, mode, copy_rtx (target), copy_rtx (tmp));
-  tmp1 = force_operand (tmp1, target);
-  if (tmp1 != target)
-    emit_move_insn (target, tmp1);
-  
-  emit_label (end_label);
+  gimple_assign_set_rhs_from_tree (si, result);

 
 

-  sequence = get_insns ();
-  end_sequence ();
-  rebuild_jump_labels (sequence);
-  return sequence;
+  return true;

 }
 
 }
 

-/* Do transforms 3) and 4) on INSN if applicable.  */
-static bool
-rtl_mod_subtract_transform (rtx insn)
+/* Generate code for transformation 2 (with parent gimple assign STMT and
+   probability of taking the optimal path PROB, which is equivalent to COUNT/ALL
+   within roundoff error).  This generates the result into a temp and returns 
+   the temp; it does not replace or alter the original STMT.  */
+static tree
+gimple_mod_pow2 (gimple stmt, int prob, gcov_type count, gcov_type all)

 {
 {

-  rtx set, set_src, set_dest, op1, op2, histogram;
-  enum rtx_code code;
-  enum machine_mode mode;
-  gcov_type wrong_values, counts[2], count, all;
-  edge e;
-  int i, prob1, prob2;
-
-  set = single_set (insn);
-  if (!set)
-    return false;
+  gimple stmt1, stmt2, stmt3, stmt4;
+  tree tmp2, tmp3;
+  gimple bb1end, bb2end, bb3end;
+  basic_block bb, bb2, bb3, bb4;
+  tree optype, op1, op2;
+  edge e12, e13, e23, e24, e34;
+  gimple_stmt_iterator gsi;
+  tree result;

 
 

-  set_src = SET_SRC (set);
-  set_dest = SET_DEST (set);
-  code = GET_CODE (set_src);
-  mode = GET_MODE (set_dest);
-  
-  if (code != UMOD)
-    return false;
-  op1 = XEXP (set_src, 0);
-  op2 = XEXP (set_src, 1);
-
-  for (histogram = REG_NOTES (insn);
-       histogram;
-       histogram = XEXP (histogram, 1))
-    if (REG_NOTE_KIND (histogram) == REG_VALUE_PROFILE
-       && XEXP (XEXP (histogram, 0), 0) == GEN_INT (HIST_TYPE_INTERVAL))
-      break;
+  gcc_assert (is_gimple_assign (stmt)
+             && gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR);

 
 

-  if (!histogram)
-    return false;
+  optype = TREE_TYPE (gimple_assign_lhs (stmt));
+  op1 = gimple_assign_rhs1 (stmt);
+  op2 = gimple_assign_rhs2 (stmt);

 
 

-  histogram = XEXP (XEXP (histogram, 0), 1);
-  histogram = XEXP (histogram, 1);
+  bb = gimple_bb (stmt);
+  gsi = gsi_for_stmt (stmt);

 
 

-  all = 0;
-  for (i = 0; i < 2; i++)
-    {
-      counts[i] = INTVAL (XEXP (histogram, 0));
-      all += counts[i];
-      histogram = XEXP (histogram, 1);
-    }
-  wrong_values = INTVAL (XEXP (histogram, 0));
-  histogram = XEXP (histogram, 1);
-  wrong_values += INTVAL (XEXP (histogram, 0));
-  all += wrong_values;
+  result = create_tmp_var (optype, "PROF");
+  tmp2 = create_tmp_var (optype, "PROF");
+  tmp3 = create_tmp_var (optype, "PROF");
+  stmt2 = gimple_build_assign_with_ops (PLUS_EXPR, tmp2, op2,
+                                       build_int_cst (optype, -1));
+  stmt3 = gimple_build_assign_with_ops (BIT_AND_EXPR, tmp3, tmp2, op2);
+  stmt4 = gimple_build_cond (NE_EXPR, tmp3, build_int_cst (optype, 0),
+                            NULL_TREE, NULL_TREE);
+  gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
+  gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
+  gsi_insert_before (&gsi, stmt4, GSI_SAME_STMT);
+  bb1end = stmt4;

 
 

-  /* We require that we use just subtractions in at least 50% of all
-     evaluations.  */
-  count = 0;
-  for (i = 0; i < 2; i++)
-    {
-      count += counts[i];
-      if (count * 2 >= all)
-       break;
-    }
-  
-  if (i == 2)
-    return false;
+  /* tmp2 == op2-1 inherited from previous block.  */
+  stmt1 = gimple_build_assign_with_ops (BIT_AND_EXPR, result, op1, tmp2);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
+  bb2end = stmt1;

 
 

-  if (dump_file)
-    fprintf (dump_file, "Mod subtract transformation on insn %d\n",
-            INSN_UID (insn));
+  stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), result,
+                                       op1, op2);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
+  bb3end = stmt1;

 
 

-  /* Compute probability of taking the optimal path(s).  */
-  prob1 = (counts[0] * REG_BR_PROB_BASE + all / 2) / all;
-  prob2 = (counts[1] * REG_BR_PROB_BASE + all / 2) / all;
+  /* Fix CFG. */
+  /* Edge e23 connects bb2 to bb3, etc. */
+  e12 = split_block (bb, bb1end);
+  bb2 = e12->dest;
+  bb2->count = count;
+  e23 = split_block (bb2, bb2end);
+  bb3 = e23->dest;
+  bb3->count = all - count;
+  e34 = split_block (bb3, bb3end);
+  bb4 = e34->dest;
+  bb4->count = all;

 
 

-  e = split_block (BLOCK_FOR_INSN (insn), PREV_INSN (insn));
-  delete_insn (insn);
-  
-  insert_insn_on_edge (
-       rtl_mod_subtract (mode, code, set_dest,
-                         op1, op2, i, prob1, prob2), e);
+  e12->flags &= ~EDGE_FALLTHRU;
+  e12->flags |= EDGE_FALSE_VALUE;
+  e12->probability = prob;
+  e12->count = count;

 
 

-  return true;
-}
+  e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
+  e13->probability = REG_BR_PROB_BASE - prob;
+  e13->count = all - count;

 
 

-#ifdef HAVE_prefetch
-/* Generate code for transformation 5 for mem with ADDRESS and a constant
-   step DELTA.  WRITE is true if the reference is a store to mem.  */
+  remove_edge (e23);
+  
+  e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
+  e24->probability = REG_BR_PROB_BASE;
+  e24->count = count;

 
 

-static rtx
-gen_speculative_prefetch (rtx address, gcov_type delta, int write)
-{
-  rtx tmp;
-  rtx sequence;
-
-  /* TODO: we do the prefetching for just one iteration ahead, which
-     often is not enough.  */
-  start_sequence ();
-  if (offsettable_address_p (0, VOIDmode, address))
-    tmp = plus_constant (copy_rtx (address), delta);
-  else
-    {
-      tmp = simplify_gen_binary (PLUS, Pmode,
-                                copy_rtx (address), GEN_INT (delta));
-      tmp = force_operand (tmp, NULL);
-    }
-  if (! (*insn_data[(int)CODE_FOR_prefetch].operand[0].predicate)
-      (tmp, insn_data[(int)CODE_FOR_prefetch].operand[0].mode))
-    tmp = force_reg (Pmode, tmp);
-  emit_insn (gen_prefetch (tmp, GEN_INT (write), GEN_INT (3)));
-  sequence = get_insns ();
-  end_sequence ();
-
-  return sequence;
-}
+  e34->probability = REG_BR_PROB_BASE;
+  e34->count = all - count;

 
 

-/* Do transform 5) on INSN if applicable.  */
+  return result;
+}

 
 

+/* Do transform 2) on INSN if applicable.  */

 static bool
 static bool

-speculative_prefetching_transform (rtx insn)
+gimple_mod_pow2_value_transform (gimple_stmt_iterator *si)

 {
 {

-  rtx histogram, value;
-  gcov_type val, count, all;
-  edge e;
-  rtx mem, address;
-  int write;
+  histogram_value histogram;
+  enum tree_code code;
+  gcov_type count, wrong_values, all;
+  tree lhs_type, result, value;
+  gcov_type prob;
+  gimple stmt;

 
 

-  if (!maybe_hot_bb_p (BLOCK_FOR_INSN (insn)))
+  stmt = gsi_stmt (*si);
+  if (gimple_code (stmt) != GIMPLE_ASSIGN)

     return false;
 
     return false;
 

-  if (!find_mem_reference (insn, &mem, &write))
+  lhs_type = TREE_TYPE (gimple_assign_lhs (stmt));
+  if (!INTEGRAL_TYPE_P (lhs_type))

     return false;
 
     return false;
 

-  address = XEXP (mem, 0);
-  if (side_effects_p (address))
-    return false;
-      
-  if (CONSTANT_P (address))
+  code = gimple_assign_rhs_code (stmt);
+  
+  if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (lhs_type))

     return false;
 
     return false;
 

-  for (histogram = REG_NOTES (insn);
-       histogram;
-       histogram = XEXP (histogram, 1))
-    if (REG_NOTE_KIND (histogram) == REG_VALUE_PROFILE
-       && XEXP (XEXP (histogram, 0), 0) == GEN_INT (HIST_TYPE_CONST_DELTA))
-      break;
-
+  histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_POW2);

   if (!histogram)
     return false;
 
   if (!histogram)
     return false;
 

-  histogram = XEXP (XEXP (histogram, 0), 1);
-  value = XEXP (histogram, 0);
-  histogram = XEXP (histogram, 1);
-  /* Skip last value referenced.  */
-  histogram = XEXP (histogram, 1);
-  val = INTVAL (XEXP (histogram, 0));
-  histogram = XEXP (histogram, 1);
-  count = INTVAL (XEXP (histogram, 0));
-  histogram = XEXP (histogram, 1);
-  all = INTVAL (XEXP (histogram, 0));
-
-  /* With that few executions we do not really have a reason to optimize the
-     statement, and more importantly, the data about differences of addresses
-     are spoiled by the first item that had no previous value to compare
-     with.  */
-  if (all < 4)
-    return false;
+  value = histogram->hvalue.value;
+  wrong_values = histogram->hvalue.counters[0];
+  count = histogram->hvalue.counters[1];

 
 

-  /* We require that count be at least half of all; this means
-     that for the transformation to fire the value must be constant
-     at least 50% of time (and 75% gives the guarantee of usage).  */
-  if (!rtx_equal_p (address, value) || 2 * count < all)
-    return false;
+  gimple_remove_histogram_value (cfun, stmt, histogram);

 
 

-  /* If the difference is too small, it does not make too much sense to
-     prefetch, as the memory is probably already in cache.  */
-  if (val >= NOPREFETCH_RANGE_MIN && val <= NOPREFETCH_RANGE_MAX)
+  /* We require that we hit a power of 2 at least half of all evaluations.  */
+  if (simple_cst_equal (gimple_assign_rhs2 (stmt), value) != 1
+      || count < wrong_values
+      || optimize_bb_for_size_p (gimple_bb (stmt)))

     return false;
 
   if (dump_file)
     return false;
 
   if (dump_file)

-    fprintf (dump_file, "Speculative prefetching for insn %d\n",
-            INSN_UID (insn));
-
-  e = split_block (BLOCK_FOR_INSN (insn), PREV_INSN (insn));
-  
-  insert_insn_on_edge (gen_speculative_prefetch (address, val, write), e);
-
-  return true;
-}
-#endif  /* HAVE_prefetch */
-
-/* Tree based transformations. */
-static bool
-tree_value_profile_transformations (void)
-{
-  basic_block bb;
-  block_stmt_iterator bsi;
-  bool changed = false;
-
-  FOR_EACH_BB (bb)

     {
     {

-      /* Ignore cold areas -- we are enlarging the code.  */
-      if (!maybe_hot_bb_p (bb))
-       continue;
+      fprintf (dump_file, "Mod power of 2 transformation on insn ");
+      print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
+    }

 
 

-      for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
-       {
-         tree stmt = bsi_stmt (bsi);
-         stmt_ann_t ann = get_stmt_ann (stmt);
-         histogram_value th = ann->histograms;
-         if (!th)
-           continue;
+  /* Compute probability of taking the optimal path.  */
+  all = count + wrong_values;

 
 

-         if (dump_file)
-           {
-             fprintf (dump_file, "Trying transformations on insn ");
-             print_generic_stmt (dump_file, stmt, TDF_SLIM);
-           }
+  if (check_counter (stmt, "pow2", &count, &all, gimple_bb (stmt)->count))
+    return false;

 
 

-         /* Transformations:  */
-         /* The order of things in this conditional controls which
-            transformation is used when more than one is applicable.  */
-         /* It is expected that any code added by the transformations
-            will be added before the current statement, and that the
-            current statement remain valid (although possibly
-            modified) upon return.  */
-         if (flag_value_profile_transformations
-             && (tree_mod_subtract_transform (stmt)
-                 || tree_divmod_fixed_value_transform (stmt)
-                 || tree_mod_pow2_value_transform (stmt)))
-           {
-             changed = true;
-             /* Original statement may no longer be in the same block. */
-             bb = bb_for_stmt (stmt);
-           }
+  if (all > 0)
+    prob = (count * REG_BR_PROB_BASE + all / 2) / all;
+  else
+    prob = 0;

 
 

-         /* Free extra storage from compute_value_histograms.  */
-         while (th)
-           {
-             free (th->hvalue.tree.counters);
-             th = th->hvalue.tree.next;
-           }
-         ann->histograms = 0;
-        }
-    }
+  result = gimple_mod_pow2 (stmt, prob, count, all);

 
 

-  if (changed)
-    {
-      counts_to_freqs ();
-    }
+  gimple_assign_set_rhs_from_tree (si, result);

 
 

-  return changed;
+  return true;

 }
 
 }
 

-/* Generate code for transformation 1 (with OPERATION, operands OP1
-   and OP2, whose value is expected to be VALUE, parent modify-expr STMT and
-   probability of taking the optimal path PROB, which is equivalent to COUNT/ALL
-   within roundoff error).  This generates the result into a temp and returns 
-   the temp; it does not replace or alter the original STMT.  */
+/* Generate code for transformations 3 and 4 (with parent gimple assign STMT, and
+   NCOUNTS the number of cases to support.  Currently only NCOUNTS==0 or 1 is
+   supported and this is built into this interface.  The probabilities of taking
+   the optimal paths are PROB1 and PROB2, which are equivalent to COUNT1/ALL and
+   COUNT2/ALL respectively within roundoff error).  This generates the 
+   result into a temp and returns the temp; it does not replace or alter 
+   the original STMT.  */
+/* FIXME: Generalize the interface to handle NCOUNTS > 1.  */
+

 static tree
 static tree

-tree_divmod_fixed_value (tree stmt, tree operation, 
-                        tree op1, tree op2, tree value, int prob, gcov_type count,
-                        gcov_type all)
+gimple_mod_subtract (gimple stmt, int prob1, int prob2, int ncounts,
+                    gcov_type count1, gcov_type count2, gcov_type all)

 {
 {

-  tree stmt1, stmt2, stmt3;
-  tree tmp1, tmp2, tmpv;
-  tree label_decl1 = create_artificial_label ();
-  tree label_decl2 = create_artificial_label ();
-  tree label_decl3 = create_artificial_label ();
-  tree label1, label2, label3;
-  tree bb1end, bb2end, bb3end;
+  gimple stmt1, stmt2, stmt3;
+  tree tmp1;
+  gimple bb1end, bb2end = NULL, bb3end;

   basic_block bb, bb2, bb3, bb4;
   basic_block bb, bb2, bb3, bb4;

-  tree optype = TREE_TYPE (operation);
-  edge e12, e13, e23, e24, e34;
-  block_stmt_iterator bsi;
+  tree optype, op1, op2;
+  edge e12, e23 = 0, e24, e34, e14;
+  gimple_stmt_iterator gsi;
+  tree result;

 
 

-  bb = bb_for_stmt (stmt);
-  bsi = bsi_for_stmt (stmt);
+  gcc_assert (is_gimple_assign (stmt)
+             && gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR);

 
 

-  tmpv = create_tmp_var (optype, "PROF");
+  optype = TREE_TYPE (gimple_assign_lhs (stmt));
+  op1 = gimple_assign_rhs1 (stmt);
+  op2 = gimple_assign_rhs2 (stmt);
+
+  bb = gimple_bb (stmt);
+  gsi = gsi_for_stmt (stmt);
+
+  result = create_tmp_var (optype, "PROF");

   tmp1 = create_tmp_var (optype, "PROF");
   tmp1 = create_tmp_var (optype, "PROF");

-  stmt1 = build2 (MODIFY_EXPR, optype, tmpv, fold_convert (optype, value));
-  stmt2 = build2 (MODIFY_EXPR, optype, tmp1, op2);
-  stmt3 = build3 (COND_EXPR, void_type_node,
-           build2 (NE_EXPR, boolean_type_node, tmp1, tmpv),
-           build1 (GOTO_EXPR, void_type_node, label_decl2),
-           build1 (GOTO_EXPR, void_type_node, label_decl1));
-  bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
+  stmt1 = gimple_build_assign (result, op1);
+  stmt2 = gimple_build_assign (tmp1, op2);
+  stmt3 = gimple_build_cond (LT_EXPR, result, tmp1, NULL_TREE, NULL_TREE);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
+  gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
+  gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);

   bb1end = stmt3;
 
   bb1end = stmt3;
 

-  tmp2 = create_tmp_var (optype, "PROF");
-  label1 = build1 (LABEL_EXPR, void_type_node, label_decl1);
-  stmt1 = build2 (MODIFY_EXPR, optype, tmp2,
-                 build2 (TREE_CODE (operation), optype, op1, tmpv));
-  bsi_insert_before (&bsi, label1, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
-  bb2end = stmt1;
+  if (ncounts) /* Assumed to be 0 or 1 */
+    {
+      stmt1 = gimple_build_assign_with_ops (MINUS_EXPR, result, result, tmp1);
+      stmt2 = gimple_build_cond (LT_EXPR, result, tmp1, NULL_TREE, NULL_TREE);
+      gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
+      gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
+      bb2end = stmt2;
+    }

 
 

-  label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
-  stmt1 = build2 (MODIFY_EXPR, optype, tmp2,
-                 build2 (TREE_CODE (operation), optype, op1, op2));
-  bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
+  /* Fallback case. */
+  stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), result,
+                                       result, tmp1);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);

   bb3end = stmt1;
 
   bb3end = stmt1;
 

-  label3 = build1 (LABEL_EXPR, void_type_node, label_decl3);
-  bsi_insert_before (&bsi, label3, BSI_SAME_STMT);
-

   /* Fix CFG. */
   /* Edge e23 connects bb2 to bb3, etc. */
   /* Fix CFG. */
   /* Edge e23 connects bb2 to bb3, etc. */

+  /* However block 3 is optional; if it is not there, references
+     to 3 really refer to block 2. */

   e12 = split_block (bb, bb1end);
   bb2 = e12->dest;
   e12 = split_block (bb, bb1end);
   bb2 = e12->dest;

-  bb2->count = count;
-  e23 = split_block (bb2, bb2end);
-  bb3 = e23->dest;
-  bb3->count = all - count;
-  e34 = split_block (bb3, bb3end);
+  bb2->count = all - count1;
+    
+  if (ncounts) /* Assumed to be 0 or 1.  */
+    {
+      e23 = split_block (bb2, bb2end);
+      bb3 = e23->dest;
+      bb3->count = all - count1 - count2;
+    }
+
+  e34 = split_block (ncounts ? bb3 : bb2, bb3end);

   bb4 = e34->dest;
   bb4->count = all;
 
   e12->flags &= ~EDGE_FALLTHRU;
   e12->flags |= EDGE_FALSE_VALUE;
   bb4 = e34->dest;
   bb4->count = all;
 
   e12->flags &= ~EDGE_FALLTHRU;
   e12->flags |= EDGE_FALSE_VALUE;

-  e12->probability = prob;
-  e12->count = count;
+  e12->probability = REG_BR_PROB_BASE - prob1;
+  e12->count = all - count1;

 
 

-  e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
-  e13->probability = REG_BR_PROB_BASE - prob;
-  e13->count = all - count;
+  e14 = make_edge (bb, bb4, EDGE_TRUE_VALUE);
+  e14->probability = prob1;
+  e14->count = count1;

 
 

-  remove_edge (e23);
-  
-  e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
-  e24->probability = REG_BR_PROB_BASE;
-  e24->count = count;
+  if (ncounts)  /* Assumed to be 0 or 1.  */
+    {
+      e23->flags &= ~EDGE_FALLTHRU;
+      e23->flags |= EDGE_FALSE_VALUE;
+      e23->count = all - count1 - count2;
+      e23->probability = REG_BR_PROB_BASE - prob2;
+
+      e24 = make_edge (bb2, bb4, EDGE_TRUE_VALUE);
+      e24->probability = prob2;
+      e24->count = count2;
+    }

 
   e34->probability = REG_BR_PROB_BASE;
 
   e34->probability = REG_BR_PROB_BASE;

-  e34->count = all - count;
+  e34->count = all - count1 - count2;

 
 

-  return tmp2;
+  return result;

 }
 
 }
 

-/* Do transform 1) on INSN if applicable.  */
+
+/* Do transforms 3) and 4) on the statement pointed-to by SI if applicable.  */
+

 static bool
 static bool

-tree_divmod_fixed_value_transform (tree stmt)
+gimple_mod_subtract_transform (gimple_stmt_iterator *si)

 {
 {

-  stmt_ann_t ann = get_stmt_ann (stmt);

   histogram_value histogram;
   enum tree_code code;
   histogram_value histogram;
   enum tree_code code;

-  gcov_type val, count, all;
-  tree modify, op, op1, op2, result, value, tree_val;
-  int prob;
-
-  modify = stmt;
-  if (TREE_CODE (stmt) == RETURN_EXPR
-      && TREE_OPERAND (stmt, 0)
-      && TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
-    modify = TREE_OPERAND (stmt, 0);
-  if (TREE_CODE (modify) != MODIFY_EXPR)
+  gcov_type count, wrong_values, all;
+  tree lhs_type, result, value;
+  gcov_type prob1, prob2;
+  unsigned int i, steps;
+  gcov_type count1, count2;
+  gimple stmt;
+
+  stmt = gsi_stmt (*si);
+  if (gimple_code (stmt) != GIMPLE_ASSIGN)

     return false;
     return false;

-  op = TREE_OPERAND (modify, 1);
-  if (!INTEGRAL_TYPE_P (TREE_TYPE (op)))
+
+  lhs_type = TREE_TYPE (gimple_assign_lhs (stmt));
+  if (!INTEGRAL_TYPE_P (lhs_type))

     return false;
     return false;

-  code = TREE_CODE (op);
+
+  code = gimple_assign_rhs_code (stmt);

   
   

-  if (code != TRUNC_DIV_EXPR && code != TRUNC_MOD_EXPR)
+  if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (lhs_type))

     return false;
 
     return false;
 

-  op1 = TREE_OPERAND (op, 0);
-  op2 = TREE_OPERAND (op, 1);
-  if (!ann->histograms)
+  histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_INTERVAL);
+  if (!histogram)

     return false;
 
     return false;
 

-  for (histogram = ann->histograms; histogram; histogram = histogram->hvalue.tree.next)
-    if (histogram->type == HIST_TYPE_SINGLE_VALUE)
-      break;
+  value = histogram->hvalue.value;
+  all = 0;
+  wrong_values = 0;
+  for (i = 0; i < histogram->hdata.intvl.steps; i++)
+    all += histogram->hvalue.counters[i];

 
 

-  if (!histogram)
-    return false;
+  wrong_values += histogram->hvalue.counters[i];
+  wrong_values += histogram->hvalue.counters[i+1];
+  steps = histogram->hdata.intvl.steps;
+  all += wrong_values;
+  count1 = histogram->hvalue.counters[0];
+  count2 = histogram->hvalue.counters[1];

 
 

-  value = histogram->hvalue.tree.value;
-  val = histogram->hvalue.tree.counters[0];
-  count = histogram->hvalue.tree.counters[1];
-  all = histogram->hvalue.tree.counters[2];
+  /* Compute probability of taking the optimal path.  */
+  if (check_counter (stmt, "interval", &count1, &all, gimple_bb (stmt)->count))
+    {
+      gimple_remove_histogram_value (cfun, stmt, histogram);
+      return false;
+    }

 
 

-  /* We require that count is at least half of all; this means
-     that for the transformation to fire the value must be constant
-     at least 50% of time (and 75% gives the guarantee of usage).  */
-  if (simple_cst_equal (op2, value) != 1 || 2 * count < all)
+  if (flag_profile_correction && count1 + count2 > all)
+      all = count1 + count2;
+
+  gcc_assert (count1 + count2 <= all);
+
+  /* We require that we use just subtractions in at least 50% of all
+     evaluations.  */
+  count = 0;
+  for (i = 0; i < histogram->hdata.intvl.steps; i++)
+    {
+      count += histogram->hvalue.counters[i];
+      if (count * 2 >= all)
+       break;
+    }
+  if (i == steps
+      || optimize_bb_for_size_p (gimple_bb (stmt)))

     return false;
 
     return false;
 

+  gimple_remove_histogram_value (cfun, stmt, histogram);

   if (dump_file)
     {
   if (dump_file)
     {

-      fprintf (dump_file, "Div/mod by constant transformation on insn ");
-      print_generic_stmt (dump_file, stmt, TDF_SLIM);
+      fprintf (dump_file, "Mod subtract transformation on insn ");
+      print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);

     }
 
     }
 

-  /* Compute probability of taking the optimal path.  */
-  prob = (count * REG_BR_PROB_BASE + all / 2) / all;
+  /* Compute probability of taking the optimal path(s).  */
+  if (all > 0)
+    {
+      prob1 = (count1 * REG_BR_PROB_BASE + all / 2) / all;
+      prob2 = (count2 * REG_BR_PROB_BASE + all / 2) / all;
+    }
+  else
+    {
+      prob1 = prob2 = 0;
+    }
+
+  /* In practice, "steps" is always 2.  This interface reflects this,
+     and will need to be changed if "steps" can change.  */
+  result = gimple_mod_subtract (stmt, prob1, prob2, i, count1, count2, all);
+
+  gimple_assign_set_rhs_from_tree (si, result);
+
+  return true;
+}
+
+static struct cgraph_node** pid_map = NULL;
+
+/* Initialize map of pids (pid -> cgraph node) */
+
+static void 
+init_pid_map (void)
+{
+  struct cgraph_node *n;
+
+  if (pid_map != NULL)
+    return;
+
+  pid_map 
+    = (struct cgraph_node**) xmalloc (sizeof (struct cgraph_node*) * cgraph_max_pid);
+
+  for (n = cgraph_nodes; n; n = n->next)
+    {
+      if (n->pid != -1)
+       pid_map [n->pid] = n;
+    }
+}

 
 

-  tree_val = build_int_cst_wide (get_gcov_type (),
-                                val & 0xffffffffull, val >> 32);
-  result = tree_divmod_fixed_value (stmt, op, op1, op2, tree_val, prob, count, all);
+/* Return cgraph node for function with pid */

 
 

-  TREE_OPERAND (modify, 1) = result;
+static inline struct cgraph_node*
+find_func_by_pid (int  pid)
+{
+  init_pid_map ();

 
 

-  return true;
+  return pid_map [pid];

 }
 
 }
 

-/* Generate code for transformation 2 (with OPERATION, operands OP1
-   and OP2, parent modify-expr STMT and probability of taking the optimal 
-   path PROB, which is equivalent to COUNT/ALL within roundoff error).  
-   This generates the result into a temp and returns 
-   the temp; it does not replace or alter the original STMT.  */
-static tree
-tree_mod_pow2 (tree stmt, tree operation, tree op1, tree op2, int prob, 
-              gcov_type count, gcov_type all)
+/* Do transformation
+
+  if (actual_callee_address == address_of_most_common_function/method)
+    do direct call
+  else
+    old call
+ */
+
+static gimple
+gimple_ic (gimple stmt, gimple call, struct cgraph_node *direct_call, 
+          int prob, gcov_type count, gcov_type all)

 {
 {

-  tree stmt1, stmt2, stmt3, stmt4;
-  tree tmp1, tmp2, tmp3;
-  tree label_decl1 = create_artificial_label ();
-  tree label_decl2 = create_artificial_label ();
-  tree label_decl3 = create_artificial_label ();
-  tree label1, label2, label3;
-  tree bb1end, bb2end, bb3end;
+  gimple stmt1, stmt2, stmt3;
+  tree tmp1, tmpv, tmp;
+  gimple bb1end, bb2end, bb3end;

   basic_block bb, bb2, bb3, bb4;
   basic_block bb, bb2, bb3, bb4;

-  tree optype = TREE_TYPE (operation);
+  tree optype = build_pointer_type (void_type_node);

   edge e12, e13, e23, e24, e34;
   edge e12, e13, e23, e24, e34;

-  block_stmt_iterator bsi;
-  tree result = create_tmp_var (optype, "PROF");
+  gimple_stmt_iterator gsi;
+  int region;

 
 

-  bb = bb_for_stmt (stmt);
-  bsi = bsi_for_stmt (stmt);
+  bb = gimple_bb (stmt);
+  gsi = gsi_for_stmt (stmt);

 
 

+  tmpv = create_tmp_var (optype, "PROF");

   tmp1 = create_tmp_var (optype, "PROF");
   tmp1 = create_tmp_var (optype, "PROF");

-  tmp2 = create_tmp_var (optype, "PROF");
-  tmp3 = create_tmp_var (optype, "PROF");
-  stmt1 = build2 (MODIFY_EXPR, optype, tmp1, fold_convert (optype, op2));
-  stmt2 = build2 (MODIFY_EXPR, optype, tmp2, 
-                   build2 (PLUS_EXPR, optype, op2, integer_minus_one_node));
-  stmt3 = build2 (MODIFY_EXPR, optype, tmp3,
-                   build2 (BIT_AND_EXPR, optype, tmp2, tmp1));
-  stmt4 = build3 (COND_EXPR, void_type_node,
-           build2 (NE_EXPR, boolean_type_node, tmp3, integer_zero_node),
-           build1 (GOTO_EXPR, void_type_node, label_decl2),
-           build1 (GOTO_EXPR, void_type_node, label_decl1));
-  bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt4, BSI_SAME_STMT);
-  bb1end = stmt4;
+  stmt1 = gimple_build_assign (tmpv, unshare_expr (gimple_call_fn (call)));
+
+  tmp = fold_convert (optype, build_addr (direct_call->decl, 
+                                         current_function_decl));
+  stmt2 = gimple_build_assign (tmp1, tmp);
+  stmt3 = gimple_build_cond (NE_EXPR, tmp1, tmpv, NULL_TREE, NULL_TREE);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
+  gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
+  gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
+  bb1end = stmt3;

 
 

-  /* tmp2 == op2-1 inherited from previous block */
-  label1 = build1 (LABEL_EXPR, void_type_node, label_decl1);
-  stmt1 = build2 (MODIFY_EXPR, optype, result,
-                 build2 (BIT_AND_EXPR, optype, op1, tmp2));
-  bsi_insert_before (&bsi, label1, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
+  stmt1 = gimple_copy (stmt);
+  gimple_call_set_fndecl (stmt1, direct_call->decl);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);

   bb2end = stmt1;
   bb2end = stmt1;

-
-  label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
-  stmt1 = build2 (MODIFY_EXPR, optype, result,
-                 build2 (TREE_CODE (operation), optype, op1, op2));
-  bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
-  bb3end = stmt1;
-
-  label3 = build1 (LABEL_EXPR, void_type_node, label_decl3);
-  bsi_insert_before (&bsi, label3, BSI_SAME_STMT);
+  bb3end = stmt;

 
   /* Fix CFG. */
   /* Edge e23 connects bb2 to bb3, etc. */
 
   /* Fix CFG. */
   /* Edge e23 connects bb2 to bb3, etc. */


@@ -1338,283 +1148,351 @@ tree_mod_pow2 (tree stmt, tree operation, tree op1, tree op2, int prob,
   e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
   e24->probability = REG_BR_PROB_BASE;
   e24->count = count;
   e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
   e24->probability = REG_BR_PROB_BASE;
   e24->count = count;

-

   e34->probability = REG_BR_PROB_BASE;
   e34->count = all - count;
 
   e34->probability = REG_BR_PROB_BASE;
   e34->count = all - count;
 

-  return result;
+  /* Fix eh edges */
+  region = lookup_stmt_eh_region (stmt);
+  if (region >= 0 && stmt_could_throw_p (stmt1))
+    {
+      add_stmt_to_eh_region (stmt1, region);
+      make_eh_edges (stmt1);
+    }
+
+  if (region >= 0 && stmt_could_throw_p (stmt))
+    {
+      gimple_purge_dead_eh_edges (bb4);
+      make_eh_edges (stmt);
+    }
+
+  return stmt1;

 }
 
 }
 

-/* Do transform 2) on INSN if applicable.  */
+/*
+  For every checked indirect/virtual call determine if most common pid of
+  function/class method has probability more than 50%. If yes modify code of
+  this call to:
+ */
+

 static bool
 static bool

-tree_mod_pow2_value_transform (tree stmt)
+gimple_ic_transform (gimple stmt)

 {
 {

-  stmt_ann_t ann = get_stmt_ann (stmt);

   histogram_value histogram;
   histogram_value histogram;

-  enum tree_code code;
-  gcov_type count, wrong_values, all;
-  tree modify, op, op1, op2, result, value;
-  int prob;
-  unsigned int i;
-
-  modify = stmt;
-  if (TREE_CODE (stmt) == RETURN_EXPR
-      && TREE_OPERAND (stmt, 0)
-      && TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
-    modify = TREE_OPERAND (stmt, 0);
-  if (TREE_CODE (modify) != MODIFY_EXPR)
-    return false;
-  op = TREE_OPERAND (modify, 1);
-  if (!INTEGRAL_TYPE_P (TREE_TYPE (op)))
-    return false;
-  code = TREE_CODE (op);
+  gcov_type val, count, all, bb_all;
+  gcov_type prob;
+  tree callee;
+  gimple modify;
+  struct cgraph_node *direct_call;

   
   

-  if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (TREE_TYPE (op)))
+  if (gimple_code (stmt) != GIMPLE_CALL)

     return false;
 
     return false;
 

-  op1 = TREE_OPERAND (op, 0);
-  op2 = TREE_OPERAND (op, 1);
-  if (!ann->histograms)
-    return false;
+  callee = gimple_call_fn (stmt);

 
 

-  for (histogram = ann->histograms; histogram; histogram = histogram->hvalue.tree.next)
-    if (histogram->type == HIST_TYPE_POW2)
-      break;
+  if (TREE_CODE (callee) == FUNCTION_DECL)
+    return false;

 
 

+  histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_INDIR_CALL);

   if (!histogram)
     return false;
 
   if (!histogram)
     return false;
 

-  value = histogram->hvalue.tree.value;
-  wrong_values = histogram->hvalue.tree.counters[0];
-  count = 0;
-  for (i = 1; i <= TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (stmt))); i++)
-    count += histogram->hvalue.tree.counters[i];
+  val = histogram->hvalue.counters [0];
+  count = histogram->hvalue.counters [1];
+  all = histogram->hvalue.counters [2];
+  gimple_remove_histogram_value (cfun, stmt, histogram);

 
 

-  /* We require that we hit a power of 2 at least half of all evaluations.  */
-  if (simple_cst_equal (op2, value) != 1 || count < wrong_values)
+  if (4 * count <= 3 * all)
+    return false;
+
+  bb_all = gimple_bb (stmt)->count;
+  /* The order of CHECK_COUNTER calls is important - 
+     since check_counter can correct the third parameter
+     and we want to make count <= all <= bb_all. */
+  if ( check_counter (stmt, "ic", &all, &bb_all, bb_all)
+      || check_counter (stmt, "ic", &count, &all, all))
+    return false;
+
+  if (all > 0)
+    prob = (count * REG_BR_PROB_BASE + all / 2) / all;
+  else
+    prob = 0;
+  direct_call = find_func_by_pid ((int)val);
+
+  if (direct_call == NULL)

     return false;
 
     return false;
 

+  modify = gimple_ic (stmt, stmt, direct_call, prob, count, all);
+

   if (dump_file)
     {
   if (dump_file)
     {

-      fprintf (dump_file, "Mod power of 2 transformation on insn ");
-      print_generic_stmt (dump_file, stmt, TDF_SLIM);
+      fprintf (dump_file, "Indirect call -> direct call ");
+      print_generic_expr (dump_file, gimple_call_fn (stmt), TDF_SLIM);
+      fprintf (dump_file, "=> ");
+      print_generic_expr (dump_file, direct_call->decl, TDF_SLIM);
+      fprintf (dump_file, " transformation on insn ");
+      print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
+      fprintf (dump_file, " to ");
+      print_gimple_stmt (dump_file, modify, 0, TDF_SLIM);
+      fprintf (dump_file, "hist->count "HOST_WIDEST_INT_PRINT_DEC
+              " hist->all "HOST_WIDEST_INT_PRINT_DEC"\n", count, all);

     }
 
     }
 

-  /* Compute probability of taking the optimal path.  */
-  all = count + wrong_values;
-  prob = (count * REG_BR_PROB_BASE + all / 2) / all;
+  return true;
+}

 
 

-  result = tree_mod_pow2 (stmt, op, op1, op2, prob, count, all);
+/* Return true if the stringop CALL with FNDECL shall be profiled.  */
+static bool
+interesting_stringop_to_profile_p (tree fndecl, gimple call)
+{
+  enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);

 
 

-  TREE_OPERAND (modify, 1) = result;
+  if (fcode != BUILT_IN_MEMCPY && fcode != BUILT_IN_MEMPCPY
+      && fcode != BUILT_IN_MEMSET && fcode != BUILT_IN_BZERO)
+    return false;

 
 

-  return true;
+  switch (fcode)
+    {
+     case BUILT_IN_MEMCPY:
+     case BUILT_IN_MEMPCPY:
+       return validate_gimple_arglist (call, POINTER_TYPE, POINTER_TYPE,
+                                      INTEGER_TYPE, VOID_TYPE);
+     case BUILT_IN_MEMSET:
+       return validate_gimple_arglist (call, POINTER_TYPE, INTEGER_TYPE,
+                                     INTEGER_TYPE, VOID_TYPE);
+     case BUILT_IN_BZERO:
+       return validate_gimple_arglist (call, POINTER_TYPE, INTEGER_TYPE,
+                                      VOID_TYPE);
+     default:
+       gcc_unreachable ();
+    }

 }
 
 }
 

-/* Generate code for transformations 3 and 4 (with OPERATION, operands OP1
-   and OP2, parent modify-expr STMT, and NCOUNTS the number of cases to
-   support.  Currently only NCOUNTS==0 or 1 is supported and this is
-   built into this interface.  The probabilities of taking the optimal 
-   paths are PROB1 and PROB2, which are equivalent to COUNT1/ALL and
-   COUNT2/ALL respectively within roundoff error).  This generates the 
-   result into a temp and returns the temp; it does not replace or alter 
-   the original STMT.  */
-/* FIXME: Generalize the interface to handle NCOUNTS > 1.  */
-
-static tree
-tree_mod_subtract (tree stmt, tree operation, tree op1, tree op2, 
-                   int prob1, int prob2, int ncounts,
-                   gcov_type count1, gcov_type count2, gcov_type all)
+/* Convert   stringop (..., size)
+   into 
+   if (size == VALUE)
+     stringop (...., VALUE);
+   else
+     stringop (...., size);
+   assuming constant propagation of VALUE will happen later.
+*/
+static void
+gimple_stringop_fixed_value (gimple stmt, tree value, int prob, gcov_type count,
+                          gcov_type all)

 {
 {

-  tree stmt1, stmt2, stmt3;
-  tree tmp1;
-  tree label_decl1 = create_artificial_label ();
-  tree label_decl2 = create_artificial_label ();
-  tree label_decl3 = create_artificial_label ();
-  tree label1, label2, label3;
-  tree bb1end, bb2end = NULL_TREE, bb3end;
+  gimple stmt1, stmt2, stmt3;
+  tree tmp1, tmpv;
+  gimple bb1end, bb2end;

   basic_block bb, bb2, bb3, bb4;
   basic_block bb, bb2, bb3, bb4;

-  tree optype = TREE_TYPE (operation);
-  edge e12, e23 = 0, e24, e34, e14;
-  block_stmt_iterator bsi;
-  tree result = create_tmp_var (optype, "PROF");
-
-  bb = bb_for_stmt (stmt);
-  bsi = bsi_for_stmt (stmt);
+  edge e12, e13, e23, e24, e34;
+  gimple_stmt_iterator gsi;
+  tree blck_size = gimple_call_arg (stmt, 2);
+  tree optype = TREE_TYPE (blck_size);
+  int region;

 
 

-  tmp1 = create_tmp_var (optype, "PROF");
-  stmt1 = build2 (MODIFY_EXPR, optype, result, op1);
-  stmt2 = build2 (MODIFY_EXPR, optype, tmp1, op2);
-  stmt3 = build3 (COND_EXPR, void_type_node,
-           build2 (LT_EXPR, boolean_type_node, result, tmp1),
-           build1 (GOTO_EXPR, void_type_node, label_decl3),
-           build1 (GOTO_EXPR, void_type_node, 
-                   ncounts ? label_decl1 : label_decl2));
-  bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
-  bb1end = stmt3;
+  bb = gimple_bb (stmt);
+  gsi = gsi_for_stmt (stmt);

 
 

-  if (ncounts) /* Assumed to be 0 or 1 */
+  if (gsi_end_p (gsi))

     {
     {

-      label1 = build1 (LABEL_EXPR, void_type_node, label_decl1);
-      stmt1 = build2 (MODIFY_EXPR, optype, result,
-                     build2 (MINUS_EXPR, optype, result, tmp1));
-      stmt2 = build3 (COND_EXPR, void_type_node,
-               build2 (LT_EXPR, boolean_type_node, result, tmp1),
-               build1 (GOTO_EXPR, void_type_node, label_decl3),
-               build1 (GOTO_EXPR, void_type_node, label_decl2));
-      bsi_insert_before (&bsi, label1, BSI_SAME_STMT);
-      bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
-      bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
-      bb2end = stmt2;
+      edge_iterator ei;
+      for (ei = ei_start (bb->succs); (e34 = ei_safe_edge (ei)); )
+       if (!(e34->flags & EDGE_ABNORMAL))
+         break;

     }
     }

+  else
+    {
+      e34 = split_block (bb, stmt);
+      gsi = gsi_for_stmt (stmt);
+    }
+  bb4 = e34->dest;

 
 

-  /* Fallback case. */
-  label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
-  stmt1 = build2 (MODIFY_EXPR, optype, result,
-                   build2 (TREE_CODE (operation), optype, result, tmp1));
-  bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
-  bb3end = stmt1;
+  tmpv = create_tmp_var (optype, "PROF");
+  tmp1 = create_tmp_var (optype, "PROF");
+  stmt1 = gimple_build_assign (tmpv, fold_convert (optype, value));
+  stmt2 = gimple_build_assign (tmp1, blck_size);
+  stmt3 = gimple_build_cond (NE_EXPR, tmp1, tmpv, NULL_TREE, NULL_TREE);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
+  gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
+  gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
+  bb1end = stmt3;

 
 

-  label3 = build1 (LABEL_EXPR, void_type_node, label_decl3);
-  bsi_insert_before (&bsi, label3, BSI_SAME_STMT);
+  stmt1 = gimple_copy (stmt);
+  gimple_call_set_arg (stmt1, 2, value);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
+  region = lookup_stmt_eh_region (stmt);
+  if (region >= 0)
+    add_stmt_to_eh_region (stmt1, region);
+  bb2end = stmt1;

 
   /* Fix CFG. */
   /* Edge e23 connects bb2 to bb3, etc. */
 
   /* Fix CFG. */
   /* Edge e23 connects bb2 to bb3, etc. */

-  /* However block 3 is optional; if it is not there, references
-     to 3 really refer to block 2. */

   e12 = split_block (bb, bb1end);
   bb2 = e12->dest;
   e12 = split_block (bb, bb1end);
   bb2 = e12->dest;

-  bb2->count = all - count1;
-    
-  if (ncounts) /* Assumed to be 0 or 1.  */
-    {
-      e23 = split_block (bb2, bb2end);
-      bb3 = e23->dest;
-      bb3->count = all - count1 - count2;
-    }
-
-  e34 = split_block (ncounts ? bb3 : bb2, bb3end);
-  bb4 = e34->dest;
-  bb4->count = all;
+  bb2->count = count;
+  e23 = split_block (bb2, bb2end);
+  bb3 = e23->dest;
+  bb3->count = all - count;

 
   e12->flags &= ~EDGE_FALLTHRU;
   e12->flags |= EDGE_FALSE_VALUE;
 
   e12->flags &= ~EDGE_FALLTHRU;
   e12->flags |= EDGE_FALSE_VALUE;

-  e12->probability = REG_BR_PROB_BASE - prob1;
-  e12->count = count1;
-
-  e14 = make_edge (bb, bb4, EDGE_TRUE_VALUE);
-  e14->probability = prob1;
-  e14->count = all - count1;
+  e12->probability = prob;
+  e12->count = count;

 
 

-  if (ncounts)  /* Assumed to be 0 or 1.  */
-    {
-      e23->flags &= ~EDGE_FALLTHRU;
-      e23->flags |= EDGE_FALSE_VALUE;
-      e23->count = all - count1 - count2;
-      e23->probability = REG_BR_PROB_BASE - prob2;
+  e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
+  e13->probability = REG_BR_PROB_BASE - prob;
+  e13->count = all - count;

 
 

-      e24 = make_edge (bb2, bb4, EDGE_TRUE_VALUE);
-      e24->probability = prob2;
-      e24->count = count2;
-    }
+  remove_edge (e23);
+  
+  e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
+  e24->probability = REG_BR_PROB_BASE;
+  e24->count = count;

 
   e34->probability = REG_BR_PROB_BASE;
 
   e34->probability = REG_BR_PROB_BASE;

-  e34->count = all - count1 - count2;
-
-  return result;
+  e34->count = all - count;

 }
 
 }
 

-/* Do transforms 3) and 4) on INSN if applicable.  */
+/* Find values inside STMT for that we want to measure histograms for
+   division/modulo optimization.  */

 static bool
 static bool

-tree_mod_subtract_transform (tree stmt)
+gimple_stringops_transform (gimple_stmt_iterator *gsi)

 {
 {

-  stmt_ann_t ann = get_stmt_ann (stmt);
+  gimple stmt = gsi_stmt (*gsi);
+  tree fndecl;
+  tree blck_size;
+  enum built_in_function fcode;

   histogram_value histogram;
   histogram_value histogram;

-  enum tree_code code;
-  gcov_type count, wrong_values, all;
-  tree modify, op, op1, op2, result, value;
-  int prob1, prob2;
-  unsigned int i;
-
-  modify = stmt;
-  if (TREE_CODE (stmt) == RETURN_EXPR
-      && TREE_OPERAND (stmt, 0)
-      && TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
-    modify = TREE_OPERAND (stmt, 0);
-  if (TREE_CODE (modify) != MODIFY_EXPR)
+  gcov_type count, all, val;
+  tree value;
+  tree dest, src;
+  unsigned int dest_align, src_align;
+  gcov_type prob;
+  tree tree_val;
+
+  if (gimple_code (stmt) != GIMPLE_CALL)

     return false;
     return false;

-  op = TREE_OPERAND (modify, 1);
-  if (!INTEGRAL_TYPE_P (TREE_TYPE (op)))
+  fndecl = gimple_call_fndecl (stmt);
+  if (!fndecl)

     return false;
     return false;

-  code = TREE_CODE (op);
-  
-  if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (TREE_TYPE (op)))
+  fcode = DECL_FUNCTION_CODE (fndecl);
+  if (!interesting_stringop_to_profile_p (fndecl, stmt))

     return false;
 
     return false;
 

-  op1 = TREE_OPERAND (op, 0);
-  op2 = TREE_OPERAND (op, 1);
-  if (!ann->histograms)
+  if (fcode == BUILT_IN_BZERO)
+    blck_size = gimple_call_arg (stmt, 1);
+  else
+    blck_size = gimple_call_arg (stmt, 2);
+  if (TREE_CODE (blck_size) == INTEGER_CST)

     return false;
 
     return false;
 

-  for (histogram = ann->histograms; histogram; histogram = histogram->hvalue.tree.next)
-    if (histogram->type == HIST_TYPE_INTERVAL)
-      break;
-
+  histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_SINGLE_VALUE);

   if (!histogram)
     return false;
   if (!histogram)
     return false;

-
-  value = histogram->hvalue.tree.value;
-  all = 0;
-  wrong_values = 0;
-  for (i = 0; i < histogram->hdata.intvl.steps; i++)
-    all += histogram->hvalue.tree.counters[i];
-
-  wrong_values += histogram->hvalue.tree.counters[i];
-  wrong_values += histogram->hvalue.tree.counters[i+1];
-  all += wrong_values;
-
-  /* Sanity check. */
-  if (simple_cst_equal (op2, value) != 1)
+  value = histogram->hvalue.value;
+  val = histogram->hvalue.counters[0];
+  count = histogram->hvalue.counters[1];
+  all = histogram->hvalue.counters[2];
+  gimple_remove_histogram_value (cfun, stmt, histogram);
+  /* We require that count is at least half of all; this means
+     that for the transformation to fire the value must be constant
+     at least 80% of time.  */
+  if ((6 * count / 5) < all || optimize_bb_for_size_p (gimple_bb (stmt)))

     return false;
     return false;

-
-  /* We require that we use just subtractions in at least 50% of all
-     evaluations.  */
-  count = 0;
-  for (i = 0; i < histogram->hdata.intvl.steps; i++)
+  if (check_counter (stmt, "value", &count, &all, gimple_bb (stmt)->count))
+    return false;
+  if (all > 0)
+    prob = (count * REG_BR_PROB_BASE + all / 2) / all;
+  else
+    prob = 0;
+  dest = gimple_call_arg (stmt, 0);
+  dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
+  switch (fcode)

     {
     {

-      count += histogram->hvalue.tree.counters[i];
-      if (count * 2 >= all)
-       break;
+    case BUILT_IN_MEMCPY:
+    case BUILT_IN_MEMPCPY:
+      src = gimple_call_arg (stmt, 1);
+      src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
+      if (!can_move_by_pieces (val, MIN (dest_align, src_align)))
+       return false;
+      break;
+    case BUILT_IN_MEMSET:
+      if (!can_store_by_pieces (val, builtin_memset_read_str,
+                               gimple_call_arg (stmt, 1),
+                               dest_align, true))
+       return false;
+      break;
+    case BUILT_IN_BZERO:
+      if (!can_store_by_pieces (val, builtin_memset_read_str,
+                               integer_zero_node,
+                               dest_align, true))
+       return false;
+      break;
+    default:
+      gcc_unreachable ();

     }
     }

-  if (i == histogram->hdata.intvl.steps)
-    return false;
-
+  tree_val = build_int_cst_wide (get_gcov_type (),
+                                (unsigned HOST_WIDE_INT) val,
+                                val >> (HOST_BITS_PER_WIDE_INT - 1) >> 1);

   if (dump_file)
     {
   if (dump_file)
     {

-      fprintf (dump_file, "Mod subtract transformation on insn ");
-      print_generic_stmt (dump_file, stmt, TDF_SLIM);
+      fprintf (dump_file, "Single value %i stringop transformation on ",
+              (int)val);
+      print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);

     }
     }

-
-  /* Compute probability of taking the optimal path(s).  */
-  prob1 = (histogram->hvalue.tree.counters[0] * REG_BR_PROB_BASE + all / 2) / all;
-  prob2 = (histogram->hvalue.tree.counters[1] * REG_BR_PROB_BASE + all / 2) / all;
-
-  /* In practice, "steps" is always 2.  This interface reflects this,
-     and will need to be changed if "steps" can change.  */
-  result = tree_mod_subtract (stmt, op, op1, op2, prob1, prob2, i,
-                           histogram->hvalue.tree.counters[0], 
-                           histogram->hvalue.tree.counters[1], all);
-
-  TREE_OPERAND (modify, 1) = result;
-
+  gimple_stringop_fixed_value (stmt, tree_val, prob, count, all);
+  

   return true;
 }
   return true;
 }

-\f
-/* Connection to the outside world.  */
-/* Struct for IR-dependent hooks.  */
+
+void
+stringop_block_profile (gimple stmt, unsigned int *expected_align,
+                       HOST_WIDE_INT *expected_size)
+{
+  histogram_value histogram;
+  histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_AVERAGE);
+  if (!histogram)
+    *expected_size = -1;
+  else if (!histogram->hvalue.counters[1])
+    {
+      *expected_size = -1;
+      gimple_remove_histogram_value (cfun, stmt, histogram);
+    }
+  else
+    {
+      gcov_type size;
+      size = ((histogram->hvalue.counters[0]
+             + histogram->hvalue.counters[1] / 2)
+              / histogram->hvalue.counters[1]);
+      /* Even if we can hold bigger value in SIZE, INT_MAX
+        is safe "infinity" for code generation strategies.  */
+      if (size > INT_MAX)
+       size = INT_MAX;
+      *expected_size = size;
+      gimple_remove_histogram_value (cfun, stmt, histogram);
+    }
+  histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_IOR);
+  if (!histogram)
+    *expected_align = 0;
+  else if (!histogram->hvalue.counters[0])
+    {
+      gimple_remove_histogram_value (cfun, stmt, histogram);
+      *expected_align = 0;
+    }
+  else
+    {
+      gcov_type count;
+      int alignment;
+
+      count = histogram->hvalue.counters[0];
+      alignment = 1;
+      while (!(count & alignment)
+            && (alignment * 2 * BITS_PER_UNIT))
+       alignment <<= 1;
+      *expected_align = alignment * BITS_PER_UNIT;
+      gimple_remove_histogram_value (cfun, stmt, histogram);
+    }
+}
+

 struct value_prof_hooks {
   /* Find list of values for which we want to measure histograms.  */
   void (*find_values_to_profile) (histogram_values *);
 struct value_prof_hooks {
   /* Find list of values for which we want to measure histograms.  */
   void (*find_values_to_profile) (histogram_values *);


@@ -1623,83 +1501,57 @@ struct value_prof_hooks {
      statically.  See value-prof.c for more detail.  */
   bool (*value_profile_transformations) (void);  
 };
      statically.  See value-prof.c for more detail.  */
   bool (*value_profile_transformations) (void);  
 };

-
-/* Hooks for RTL-based versions (the only ones that currently work).  */
-static struct value_prof_hooks rtl_value_prof_hooks =
-{
-  rtl_find_values_to_profile,
-  rtl_value_profile_transformations
-};
-
-void 
-rtl_register_value_prof_hooks (void)
-{
-  value_prof_hooks = &rtl_value_prof_hooks;
-  gcc_assert (!ir_type ());
-}

 \f
 \f

-/* Find values inside INSN for that we want to measure histograms for
+/* Find values inside STMT for that we want to measure histograms for

    division/modulo optimization.  */
 static void
    division/modulo optimization.  */
 static void

-tree_divmod_values_to_profile (tree stmt, histogram_values *values)
+gimple_divmod_values_to_profile (gimple stmt, histogram_values *values)

 {
 {

-  tree op, op1, op2;
+  tree lhs, divisor, op0, type;

   histogram_value hist;
 
   histogram_value hist;
 

-  op = stmt;
-  if (TREE_CODE (stmt) == RETURN_EXPR 
-      && TREE_OPERAND (stmt, 0)
-      && TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
-    op = TREE_OPERAND (stmt, 0);
-
-  if (TREE_CODE (op) != MODIFY_EXPR)
+  if (gimple_code (stmt) != GIMPLE_ASSIGN)

     return;
     return;

-  if (!INTEGRAL_TYPE_P (TREE_TYPE (op)))
+
+  lhs = gimple_assign_lhs (stmt);
+  type = TREE_TYPE (lhs);
+  if (!INTEGRAL_TYPE_P (type))

     return;
     return;

-  op = TREE_OPERAND (op, 1);
-  switch (TREE_CODE (op))
+
+  switch (gimple_assign_rhs_code (stmt))

     {
     case TRUNC_DIV_EXPR:
     case TRUNC_MOD_EXPR:
     {
     case TRUNC_DIV_EXPR:
     case TRUNC_MOD_EXPR:

-      op1 = TREE_OPERAND (op, 0);
-      op2 = TREE_OPERAND (op, 1);
-
-      /* Check for a special case where the divisor is power(s) of 2.
-         This is more aggressive than the RTL version, under the
-        assumption that later phases will reduce / or % by power of 2
-        to something clever most of the time.  Signed or unsigned.  */
-      if (TREE_CODE (op2) != INTEGER_CST)
-       {
-         hist = ggc_alloc (sizeof (*hist));
-         hist->hvalue.tree.value = op2;
-         hist->hvalue.tree.stmt = stmt;
-         hist->type = HIST_TYPE_POW2;
-         hist->hdata.pow2.may_be_other = 1;
-         VEC_safe_push (histogram_value, *values, hist);
-       }
+      divisor = gimple_assign_rhs2 (stmt);
+      op0 = gimple_assign_rhs1 (stmt);

 
 

-      /* Check for the case where the divisor is the same value most
-        of the time.  */
-      if (TREE_CODE (op2) != INTEGER_CST)
-       {
-         hist = ggc_alloc (sizeof (*hist));
-         hist->hvalue.tree.value = op2;
-         hist->hvalue.tree.stmt = stmt;
-         hist->type = HIST_TYPE_SINGLE_VALUE;
-         VEC_safe_push (histogram_value, *values, hist);
-       }
+      VEC_reserve (histogram_value, heap, *values, 3);
+
+      if (is_gimple_reg (divisor))
+       /* Check for the case where the divisor is the same value most
+          of the time.  */
+       VEC_quick_push (histogram_value, *values,
+                       gimple_alloc_histogram_value (cfun,
+                                                     HIST_TYPE_SINGLE_VALUE,
+                                                     stmt, divisor));

 
       /* For mod, check whether it is not often a noop (or replaceable by
         a few subtractions).  */
 
       /* For mod, check whether it is not often a noop (or replaceable by
         a few subtractions).  */

-      if (TREE_CODE (op) == TRUNC_MOD_EXPR && TYPE_UNSIGNED (TREE_TYPE (op)))
+      if (gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR
+         && TYPE_UNSIGNED (type))

        {
        {

-         hist = ggc_alloc (sizeof (*hist));
-         hist->hvalue.tree.stmt = stmt;
-         hist->hvalue.tree.value = op2;
-         hist->type = HIST_TYPE_INTERVAL;
+          tree val;
+          /* Check for a special case where the divisor is power of 2.  */
+         VEC_quick_push (histogram_value, *values,
+                         gimple_alloc_histogram_value (cfun, HIST_TYPE_POW2,
+                                                       stmt, divisor));
+
+         val = build2 (TRUNC_DIV_EXPR, type, op0, divisor);
+         hist = gimple_alloc_histogram_value (cfun, HIST_TYPE_INTERVAL,
+                                              stmt, val);

          hist->hdata.intvl.int_start = 0;
          hist->hdata.intvl.steps = 2;
          hist->hdata.intvl.int_start = 0;
          hist->hdata.intvl.steps = 2;

-         VEC_safe_push (histogram_value, *values, hist);
+         VEC_quick_push (histogram_value, *values, hist);

        }
       return;
 
        }
       return;
 


@@ -1708,101 +1560,151 @@ tree_divmod_values_to_profile (tree stmt, histogram_values *values)
     }
 }
 
     }
 }
 

-/* Find values inside INSN for that we want to measure histograms and adds
-   them to list VALUES (increasing the record of its length in N_VALUES).  */
+/* Find calls inside STMT for that we want to measure histograms for 
+   indirect/virtual call optimization. */ 
+
+static void
+gimple_indirect_call_to_profile (gimple stmt, histogram_values *values)
+{
+  tree callee;
+
+  if (gimple_code (stmt) != GIMPLE_CALL
+      || gimple_call_fndecl (stmt) != NULL_TREE)
+    return;
+
+  callee = gimple_call_fn (stmt);
+
+  VEC_reserve (histogram_value, heap, *values, 3);
+
+  VEC_quick_push (histogram_value, *values, 
+                 gimple_alloc_histogram_value (cfun, HIST_TYPE_INDIR_CALL,
+                                               stmt, callee));
+
+  return;
+}
+
+/* Find values inside STMT for that we want to measure histograms for
+   string operations.  */
+static void
+gimple_stringops_values_to_profile (gimple stmt, histogram_values *values)
+{
+  tree fndecl;
+  tree blck_size;
+  tree dest;
+  enum built_in_function fcode;
+
+  if (gimple_code (stmt) != GIMPLE_CALL)
+    return;
+  fndecl = gimple_call_fndecl (stmt);
+  if (!fndecl)
+    return;
+  fcode = DECL_FUNCTION_CODE (fndecl);
+
+  if (!interesting_stringop_to_profile_p (fndecl, stmt))
+    return;
+
+  dest = gimple_call_arg (stmt, 0);
+  if (fcode == BUILT_IN_BZERO)
+    blck_size = gimple_call_arg (stmt, 1);
+  else
+    blck_size = gimple_call_arg (stmt, 2);
+
+  if (TREE_CODE (blck_size) != INTEGER_CST)
+    {
+      VEC_safe_push (histogram_value, heap, *values,
+                    gimple_alloc_histogram_value (cfun, HIST_TYPE_SINGLE_VALUE,
+                                                  stmt, blck_size));
+      VEC_safe_push (histogram_value, heap, *values,
+                    gimple_alloc_histogram_value (cfun, HIST_TYPE_AVERAGE,
+                                                  stmt, blck_size));
+    }
+  if (TREE_CODE (blck_size) != INTEGER_CST)
+    VEC_safe_push (histogram_value, heap, *values,
+                  gimple_alloc_histogram_value (cfun, HIST_TYPE_IOR,
+                                                stmt, dest));
+}
+
+/* Find values inside STMT for that we want to measure histograms and adds
+   them to list VALUES.  */
+

 static void
 static void

-tree_values_to_profile (tree stmt, histogram_values *values)
+gimple_values_to_profile (gimple stmt, histogram_values *values)

 {
   if (flag_value_profile_transformations)
 {
   if (flag_value_profile_transformations)

-    tree_divmod_values_to_profile (stmt, values);
+    {
+      gimple_divmod_values_to_profile (stmt, values);
+      gimple_stringops_values_to_profile (stmt, values);
+      gimple_indirect_call_to_profile (stmt, values);
+    }

 }
 
 static void
 }
 
 static void

-tree_find_values_to_profile (histogram_values *values)
+gimple_find_values_to_profile (histogram_values *values)

 {
   basic_block bb;
 {
   basic_block bb;

-  block_stmt_iterator bsi;
-  tree stmt;
-  unsigned int i;
+  gimple_stmt_iterator gsi;
+  unsigned i;
+  histogram_value hist = NULL;

 
 

-  *values = VEC_alloc (histogram_value, 0);
+  *values = NULL;

   FOR_EACH_BB (bb)
   FOR_EACH_BB (bb)

-    for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
-      {
-        tree stmt = bsi_stmt (bsi);
-        tree_values_to_profile (stmt, values);
-      }
-  static_values = *values;
+    for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+      gimple_values_to_profile (gsi_stmt (gsi), values);

   
   

-  for (i = 0; i < VEC_length (histogram_value, *values); i++)
+  for (i = 0; VEC_iterate (histogram_value, *values, i, hist); i++)

     {
     {

-      histogram_value hist = VEC_index (histogram_value, *values, i);
-

       switch (hist->type)
         {
        case HIST_TYPE_INTERVAL:
       switch (hist->type)
         {
        case HIST_TYPE_INTERVAL:

-         if (dump_file)
-           {
-             fprintf (dump_file, "Interval counter for tree ");
-             print_generic_expr (dump_file, hist->hvalue.tree.stmt, 
-                                 TDF_SLIM);
-             fprintf (dump_file, ", range %d -- %d.\n",
-                    hist->hdata.intvl.int_start,
-                    (hist->hdata.intvl.int_start
-                     + hist->hdata.intvl.steps - 1));
-           }

          hist->n_counters = hist->hdata.intvl.steps + 2;
          break;
 
        case HIST_TYPE_POW2:
          hist->n_counters = hist->hdata.intvl.steps + 2;
          break;
 
        case HIST_TYPE_POW2:

-         if (dump_file)
-           {
-             fprintf (dump_file, "Pow2 counter for insn ");
-             print_generic_expr (dump_file, hist->hvalue.tree.stmt, TDF_SLIM);
-             fprintf (dump_file, ".\n");
-           }
-         stmt = hist->hvalue.tree.stmt;
-         hist->n_counters 
-               = TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (stmt)))
-                 +  (hist->hdata.pow2.may_be_other ? 1 : 0);
+         hist->n_counters = 2;

          break;
 
        case HIST_TYPE_SINGLE_VALUE:
          break;
 
        case HIST_TYPE_SINGLE_VALUE:

-         if (dump_file)
-           {
-             fprintf (dump_file, "Single value counter for insn ");
-             print_generic_expr (dump_file, hist->hvalue.tree.stmt, TDF_SLIM);
-             fprintf (dump_file, ".\n");
-           }

          hist->n_counters = 3;
          break;
 
        case HIST_TYPE_CONST_DELTA:
          hist->n_counters = 3;
          break;
 
        case HIST_TYPE_CONST_DELTA:

-         if (dump_file)
-           {
-             fprintf (dump_file, "Constant delta counter for insn ");
-             print_generic_expr (dump_file, hist->hvalue.tree.stmt, TDF_SLIM);
-             fprintf (dump_file, ".\n");
-           }

          hist->n_counters = 4;
          break;
 
          hist->n_counters = 4;
          break;
 

+       case HIST_TYPE_INDIR_CALL:
+         hist->n_counters = 3;
+         break;
+
+       case HIST_TYPE_AVERAGE:
+         hist->n_counters = 2;
+         break;
+
+       case HIST_TYPE_IOR:
+         hist->n_counters = 1;
+         break;
+

        default:
        default:

-         abort ();
+         gcc_unreachable ();

        }
        }

+      if (dump_file)
+        {
+         fprintf (dump_file, "Stmt ");
+          print_gimple_stmt (dump_file, hist->hvalue.stmt, 0, TDF_SLIM);
+         dump_histogram_value (dump_file, hist);
+        }

     }
 }
 
     }
 }
 

-static struct value_prof_hooks tree_value_prof_hooks = {
-  tree_find_values_to_profile,
-  tree_value_profile_transformations
+static struct value_prof_hooks gimple_value_prof_hooks = {
+  gimple_find_values_to_profile,
+  gimple_value_profile_transformations

 };
 
 void
 };
 
 void

-tree_register_value_prof_hooks (void)
+gimple_register_value_prof_hooks (void)

 {
 {

-  value_prof_hooks = &tree_value_prof_hooks;
-  gcc_assert (ir_type ());
+  gcc_assert (current_ir_type () == IR_GIMPLE);
+  value_prof_hooks = &gimple_value_prof_hooks;

 }
 \f
 /* IR-independent entry points.  */
 }
 \f
 /* IR-independent entry points.  */


@@ -1815,7 +1717,6 @@ find_values_to_profile (histogram_values *values)
 bool
 value_profile_transformations (void)
 {
 bool
 value_profile_transformations (void)
 {

-  bool retval = (value_prof_hooks->value_profile_transformations) ();
-  VEC_free (histogram_value, static_values);
-  return retval;
+  return (value_prof_hooks->value_profile_transformations) ();

 }
 }

+\f