backport: ChangeLog.tuples: ChangeLog from gimple-tuples-branch.

2008-07-28  Richard Guenther  <rguenther@suse.de>

	Merge from gimple-tuples-branch.

	* ChangeLog.tuples: ChangeLog from gimple-tuples-branch.
	* gimple.def: New file.
	* gsstruct.def: Likewise.
	* gimple-iterator.c: Likewise.
	* gimple-pretty-print.c: Likewise.
	* tree-gimple.c: Removed.  Merged into ...
	* gimple.c: ... here.  New file.
	* tree-gimple.h: Removed.  Merged into ...
	* gimple.h: ... here.  New file.

	* Makefile.in: Add dependencies on GIMPLE_H and tree-iterator.h.
	* configure.ac: Added support for ENABLE_GIMPLE_CHECKING and the
	--enable-checking=gimple flag.
	* config.in: Likewise.
	* configure: Regenerated.

	* tree-ssa-operands.h: Tuplified.
	* tree-vrp.c: Likewise.
	* tree-loop-linear.c: Likewise.
	* tree-into-ssa.c: Likewise.
	* tree-ssa-loop-im.c: Likewise.
	* tree-dump.c: Likewise.
	* tree-complex.c: Likewise.
	* cgraphbuild.c: Likewise.
	* tree-ssa-threadupdate.c: Likewise.
	* tree-ssa-loop-niter.c: Likewise.
	* tree-pretty-print.c: Likewise.
	* tracer.c: Likewise.
	* gengtype.c: Likewise.
	* tree-loop-distribution.c: Likewise.
	* tree-ssa-loop-unswitch.c: Likewise.
	* cgraph.c: Likewise.
	* cgraph.h: Likewise.
	* tree-ssa-loop-manip.c: Likewise.
	* value-prof.c: Likewise.
	* tree-ssa-loop-ch.c: Likewise.
	* tree-tailcall.c: Likewise.
	* value-prof.h: Likewise.
	* tree.c: Likewise.
	* tree.h: Likewise.
	* tree-pass.h: Likewise.
	* ipa-cp.c: Likewise.
	* tree-scalar-evolution.c: Likewise.
	* tree-scalar-evolution.h: Likewise.
	* target.h: Likewise.
	* lambda-mat.c: Likewise.
	* tree-phinodes.c: Likewise.
	* diagnostic.h: Likewise.
	* builtins.c: Likewise.
	* tree-ssa-alias-warnings.c: Likewise.
	* cfghooks.c: Likewise.
	* fold-const.c: Likewise.
	* cfghooks.h: Likewise.
	* omp-low.c: Likewise.
	* tree-ssa-dse.c: Likewise.
	* ipa-reference.c: Likewise.
	* tree-ssa-uncprop.c: Likewise.
	* toplev.c: Likewise.
	* tree-gimple.c: Likewise.
	* tree-gimple.h: Likewise.
	* tree-chrec.c: Likewise.
	* tree-chrec.h: Likewise.
	* tree-ssa-sccvn.c: Likewise.
	* tree-ssa-sccvn.h: Likewise.
	* cgraphunit.c: Likewise.
	* tree-ssa-copyrename.c: Likewise.
	* tree-ssa-ccp.c: Likewise.
	* tree-ssa-loop-ivopts.c: Likewise.
	* tree-nomudflap.c: Likewise.
	* tree-call-cdce.c: Likewise.
	* ipa-pure-const.c: Likewise.
	* c-format.c: Likewise.
	* tree-stdarg.c: Likewise.
	* tree-ssa-math-opts.c: Likewise.
	* tree-ssa-dom.c: Likewise.
	* tree-nrv.c: Likewise.
	* tree-ssa-propagate.c: Likewise.
	* ipa-utils.c: Likewise.
	* tree-ssa-propagate.h: Likewise.
	* tree-ssa-alias.c: Likewise.
	* gimple-low.c: Likewise.
	* tree-ssa-sink.c: Likewise.
	* ipa-inline.c: Likewise.
	* c-semantics.c: Likewise.
	* dwarf2out.c: Likewise.
	* expr.c: Likewise.
	* tree-ssa-loop-ivcanon.c: Likewise.
	* predict.c: Likewise.
	* tree-ssa-loop.c: Likewise.
	* tree-parloops.c: Likewise.
	* tree-ssa-address.c: Likewise.
	* tree-ssa-ifcombine.c: Likewise.
	* matrix-reorg.c: Likewise.
	* c-decl.c: Likewise.
	* tree-eh.c: Likewise.
	* c-pretty-print.c: Likewise.
	* lambda-trans.c: Likewise.
	* function.c: Likewise.
	* langhooks.c: Likewise.
	* ebitmap.h: Likewise.
	* tree-vectorizer.c: Likewise.
	* function.h: Likewise.
	* langhooks.h: Likewise.
	* tree-vectorizer.h: Likewise.
	* ipa-type-escape.c: Likewise.
	* ipa-type-escape.h: Likewise.
	* domwalk.c: Likewise.
	* tree-if-conv.c: Likewise.
	* profile.c: Likewise.
	* domwalk.h: Likewise.
	* tree-data-ref.c: Likewise.
	* tree-data-ref.h: Likewise.
	* tree-flow-inline.h: Likewise.
	* tree-affine.c: Likewise.
	* tree-vect-analyze.c: Likewise.
	* c-typeck.c: Likewise.
	* gimplify.c: Likewise.
	* coretypes.h: Likewise.
	* tree-ssa-phiopt.c: Likewise.
	* calls.c: Likewise.
	* tree-ssa-coalesce.c: Likewise.
	* tree.def: Likewise.
	* tree-dfa.c: Likewise.
	* except.c: Likewise.
	* except.h: Likewise.
	* cfgexpand.c: Likewise.
	* tree-cfgcleanup.c: Likewise.
	* tree-ssa-pre.c: Likewise.
	* tree-ssa-live.c: Likewise.
	* tree-sra.c: Likewise.
	* tree-ssa-live.h: Likewise.
	* tree-predcom.c: Likewise.
	* lambda.h: Likewise.
	* tree-mudflap.c: Likewise.
	* ipa-prop.c: Likewise.
	* print-tree.c: Likewise.
	* tree-ssa-copy.c: Likewise.
	* ipa-prop.h: Likewise.
	* tree-ssa-forwprop.c: Likewise.
	* ggc-page.c: Likewise.
	* c-omp.c: Likewise.
	* tree-ssa-dce.c: Likewise.
	* tree-vect-patterns.c: Likewise.
	* tree-ssa-ter.c: Likewise.
	* tree-nested.c: Likewise.
	* tree-ssa.c: Likewise.
	* lambda-code.c: Likewise.
	* tree-ssa-loop-prefetch.c: Likewise.
	* tree-inline.c: Likewise.
	* tree-inline.h: Likewise.
	* tree-iterator.c: Likewise.
	* tree-optimize.c: Likewise.
	* tree-ssa-phiprop.c: Likewise.
	* tree-vect-transform.c: Likewise.
	* tree-object-size.c: Likewise.
	* tree-outof-ssa.c: Likewise.
	* cfgloop.c: Likewise.
	* system.h: Likewise.
	* tree-profile.c: Likewise.
	* cfgloop.h: Likewise.
	* c-gimplify.c: Likewise.
	* c-common.c: Likewise.
	* tree-vect-generic.c: Likewise.
	* tree-flow.h: Likewise.
	* c-common.h: Likewise.
	* basic-block.h: Likewise.
	* tree-ssa-structalias.c: Likewise.
	* tree-switch-conversion.c: Likewise.
	* tree-ssa-structalias.h: Likewise.
	* tree-cfg.c: Likewise.
	* passes.c: Likewise.
	* ipa-struct-reorg.c: Likewise.
	* ipa-struct-reorg.h: Likewise.
	* tree-ssa-reassoc.c: Likewise.
	* cfgrtl.c: Likewise.
	* varpool.c: Likewise.
	* stmt.c: Likewise.
	* tree-ssanames.c: Likewise.
	* tree-ssa-threadedge.c: Likewise.
	* langhooks-def.h: Likewise.
	* tree-ssa-operands.c: Likewise.
	* config/alpha/alpha.c: Likewise.
	* config/frv/frv.c: Likewise.
	* config/s390/s390.c: Likewise.
	* config/m32c/m32c.c: Likewise.
	* config/m32c/m32c-protos.h: Likewise.
	* config/spu/spu.c: Likewise.
	* config/sparc/sparc.c: Likewise.
	* config/i386/i386.c: Likewise.
	* config/sh/sh.c: Likewise.
	* config/xtensa/xtensa.c: Likewise.
	* config/stormy16/stormy16.c: Likewise.
	* config/ia64/ia64.c: Likewise.
	* config/rs6000/rs6000.c: Likewise.
	* config/pa/pa.c: Likewise.
	* config/mips/mips.c: Likewise.

From-SVN: r138207

1 files changed, 364 insertions, 375 deletions

diff --git a/gcc/value-prof.c b/gcc/value-prof.c
index a16e7d48378..b94a3f96b47 100644
--- a/gcc/value-prof.c
+++ b/gcc/value-prof.c
@@ -78,22 +78,21 @@ static struct value_prof_hooks *value_prof_hooks;
    same information as above.  */
 
 
-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);
-static bool tree_stringops_transform (block_stmt_iterator *);
-static bool tree_ic_transform (tree);
+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);
 
 /* Allocate histogram value.  */
 
 static histogram_value
 gimple_alloc_histogram_value (struct function *fun ATTRIBUTE_UNUSED,
-			      enum hist_type type, tree stmt, tree value)
+			      enum hist_type type, gimple stmt, tree value)
 {
    histogram_value hist = (histogram_value) xcalloc (1, sizeof (*hist));
    hist->hvalue.value = value;
@@ -115,13 +114,13 @@ histogram_hash (const void *x)
 static int
 histogram_eq (const void *x, const void *y)
 {
-  return ((const_histogram_value) x)->hvalue.stmt == (const_tree)y;
+  return ((const_histogram_value) x)->hvalue.stmt == (const_gimple) y;
 }
 
 /* Set histogram for STMT.  */
 
 static void
-set_histogram_value (struct function *fun, tree stmt, histogram_value hist)
+set_histogram_value (struct function *fun, gimple stmt, histogram_value hist)
 {
   void **loc;
   if (!hist && !VALUE_HISTOGRAMS (fun))
@@ -144,7 +143,7 @@ set_histogram_value (struct function *fun, tree stmt, histogram_value hist)
 /* Get histogram list for STMT.  */
 
 histogram_value
-gimple_histogram_value (struct function *fun, tree stmt)
+gimple_histogram_value (struct function *fun, gimple stmt)
 {
   if (!VALUE_HISTOGRAMS (fun))
     return NULL;
@@ -155,16 +154,19 @@ gimple_histogram_value (struct function *fun, tree stmt)
 /* Add histogram for STMT.  */
 
 void
-gimple_add_histogram_value (struct function *fun, tree stmt, histogram_value hist)
+gimple_add_histogram_value (struct function *fun, gimple stmt,
+			    histogram_value hist)
 {
   hist->hvalue.next = gimple_histogram_value (fun, stmt);
   set_histogram_value (fun, stmt, hist);
 }
 
+
 /* Remove histogram HIST from STMT's histogram list.  */
 
 void
-gimple_remove_histogram_value (struct function *fun, tree stmt, histogram_value hist)
+gimple_remove_histogram_value (struct function *fun, gimple stmt,
+			       histogram_value hist)
 {
   histogram_value hist2 = gimple_histogram_value (fun, stmt);
   if (hist == hist2)
@@ -184,13 +186,16 @@ gimple_remove_histogram_value (struct function *fun, tree stmt, histogram_value
   free (hist);
 }
 
+
 /* Lookup histogram of type TYPE in the STMT.  */
 
 histogram_value
-gimple_histogram_value_of_type (struct function *fun, tree stmt, enum hist_type type)
+gimple_histogram_value_of_type (struct function *fun, gimple stmt,
+				enum hist_type type)
 {
   histogram_value hist;
-  for (hist = gimple_histogram_value (fun, stmt); hist; hist = hist->hvalue.next)
+  for (hist = gimple_histogram_value (fun, stmt); hist;
+       hist = hist->hvalue.next)
     if (hist->type == type)
       return hist;
   return NULL;
@@ -302,7 +307,7 @@ dump_histogram_value (FILE *dump_file, histogram_value hist)
 /* Dump all histograms attached to STMT to DUMP_FILE.  */
 
 void
-dump_histograms_for_stmt (struct function *fun, FILE *dump_file, tree stmt)
+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)
@@ -312,7 +317,7 @@ dump_histograms_for_stmt (struct function *fun, FILE *dump_file, tree stmt)
 /* Remove all histograms associated with STMT.  */
 
 void
-gimple_remove_stmt_histograms (struct function *fun, tree stmt)
+gimple_remove_stmt_histograms (struct function *fun, gimple stmt)
 {
   histogram_value val;
   while ((val = gimple_histogram_value (fun, stmt)) != NULL)
@@ -322,8 +327,8 @@ gimple_remove_stmt_histograms (struct function *fun, tree stmt)
 /* Duplicate all histograms associates with OSTMT to STMT.  */
 
 void
-gimple_duplicate_stmt_histograms (struct function *fun, tree stmt,
-				  struct function *ofun, tree ostmt)
+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)
@@ -341,7 +346,7 @@ gimple_duplicate_stmt_histograms (struct function *fun, tree stmt,
 /* Move all histograms associated with OSTMT to STMT.  */
 
 void
-gimple_move_stmt_histograms (struct function *fun, tree stmt, tree ostmt)
+gimple_move_stmt_histograms (struct function *fun, gimple stmt, gimple ostmt)
 {
   histogram_value val = gimple_histogram_value (fun, ostmt);
   if (val)
@@ -370,36 +375,38 @@ visit_hist (void **slot, void *data)
     {
       error ("Dead histogram");
       dump_histogram_value (stderr, hist);
-      debug_generic_stmt (hist->hvalue.stmt);
+      debug_gimple_stmt (hist->hvalue.stmt);
       error_found = true;
     }
   return 1;
 }
 
+
 /* Verify sanity of the histograms.  */
 
 void
 verify_histograms (void)
 {
   basic_block bb;
-  block_stmt_iterator bsi;
+  gimple_stmt_iterator gsi;
   histogram_value hist;
   struct pointer_set_t *visited_hists;
 
   error_found = false;
   visited_hists = pointer_set_create ();
   FOR_EACH_BB (bb)
-    for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
+    for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
       {
-	tree stmt = bsi_stmt (bsi);
+	gimple stmt = gsi_stmt (gsi);
 
-	for (hist = gimple_histogram_value (cfun, stmt); hist; hist = hist->hvalue.next)
+	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 statement"
-		       " it is associated with");
-		debug_generic_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;
 	      }
@@ -439,38 +446,45 @@ free_histograms (void)
     }
 }
 
-/* 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.  */
+
+/* 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.  */
+
 static bool
-check_counter (tree stmt, const char * name, gcov_type all, gcov_type bb_count)
+check_counter (gimple stmt, const char *name, gcov_type all, gcov_type bb_count)
 {
   if (all != bb_count)
     {
-      location_t * locus;
-      locus = (stmt != NULL && EXPR_HAS_LOCATION (stmt)
-	       ? EXPR_LOCUS (stmt)
-	       : &DECL_SOURCE_LOCATION (current_function_decl));
-      error ("%HCorrupted value profile: %s profiler overall count (%d) does not match BB count (%d)",
-	     locus, name, (int)all, (int)bb_count);
+      location_t locus;
+      locus = (stmt != NULL)
+	       ? gimple_location (stmt)
+	       : DECL_SOURCE_LOCATION (current_function_decl);
+      error ("%HCorrupted value profile: %s profiler overall count (%d) "
+	     "does not match BB count (%d)", &locus, name, (int)all,
+	     (int)bb_count);
       return true;
     }
+
   return false;
 }
 
-/* Tree based transformations. */
+
+/* GIMPLE based transformations. */
+
 static bool
-tree_value_profile_transformations (void)
+gimple_value_profile_transformations (void)
 {
   basic_block bb;
-  block_stmt_iterator bsi;
+  gimple_stmt_iterator gsi;
   bool changed = false;
 
   FOR_EACH_BB (bb)
     {
-      for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
+      for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  tree stmt = bsi_stmt (bsi);
+	  gimple stmt = gsi_stmt (gsi);
 	  histogram_value th = gimple_histogram_value (cfun, stmt);
 	  if (!th)
 	    continue;
@@ -478,7 +492,7 @@ tree_value_profile_transformations (void)
 	  if (dump_file)
 	    {
 	      fprintf (dump_file, "Trying transformations on stmt ");
-	      print_generic_stmt (dump_file, stmt, TDF_SLIM);
+	      print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
 	      dump_histograms_for_stmt (cfun, dump_file, stmt);
 	    }
 
@@ -490,19 +504,19 @@ tree_value_profile_transformations (void)
 	     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)
-		  || tree_stringops_transform (&bsi)
-		  || tree_ic_transform (stmt)))
+	      && (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 = bsi_stmt (bsi);
+	      stmt = gsi_stmt (gsi);
 	      changed = true;
 	      /* Original statement may no longer be in the same block. */
-	      if (bb != bb_for_stmt (stmt))
+	      if (bb != gimple_bb (stmt))
 		{
-	          bb = bb_for_stmt (stmt);
-		  bsi = bsi_for_stmt (stmt);
+	          bb = gimple_bb (stmt);
+		  gsi = gsi_for_stmt (stmt);
 		}
 	    }
         }
@@ -516,57 +530,61 @@ tree_value_profile_transformations (void)
   return changed;
 }
 
-/* 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 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.  */
+
 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_divmod_fixed_value (gimple stmt, tree value, int prob, gcov_type count,
+			   gcov_type all)
 {
-  tree stmt1, stmt2, stmt3;
+  gimple stmt1, stmt2, stmt3, label1, label2;
   tree tmp1, tmp2, tmpv;
   tree label_decl1 = create_artificial_label ();
   tree label_decl2 = create_artificial_label ();
-  tree label1, label2;
-  tree bb1end, bb2end, bb3end;
+  gimple bb1end, bb2end, bb3end;
   basic_block bb, bb2, bb3, bb4;
-  tree optype = TREE_TYPE (operation);
+  tree optype, op1, op2;
   edge e12, e13, e23, e24, e34;
-  block_stmt_iterator bsi;
+  gimple_stmt_iterator gsi;
+
+  gcc_assert (is_gimple_assign (stmt)
+	      && (gimple_assign_rhs_code (stmt) == TRUNC_DIV_EXPR
+		  || gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR));
+
+  optype = TREE_TYPE (gimple_assign_lhs (stmt));
+  op1 = gimple_assign_rhs1 (stmt);
+  op2 = gimple_assign_rhs2 (stmt);
 
-  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");
-  stmt1 = build_gimple_modify_stmt (tmpv, fold_convert (optype, value));
-  stmt2 = build_gimple_modify_stmt (tmp1, op2);
-  stmt3 = build3 (COND_EXPR, void_type_node,
-	    build2 (NE_EXPR, boolean_type_node, tmp1, tmpv),
-	    NULL_TREE, NULL_TREE);
-  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 (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;
 
   tmp2 = create_tmp_var (optype, "PROF");
-  label1 = build1 (LABEL_EXPR, void_type_node, label_decl1);
-  stmt1 = build_gimple_modify_stmt (tmp2,
-				    build2 (TREE_CODE (operation), optype,
-					    op1, tmpv));
-  bsi_insert_before (&bsi, label1, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
+  label1 = gimple_build_label (label_decl1);
+  stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2,
+					op1, tmpv);
+  gsi_insert_before (&gsi, label1, GSI_SAME_STMT);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
   bb2end = stmt1;
 
-  label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
-  stmt1 = build_gimple_modify_stmt (tmp2,
-				    build2 (TREE_CODE (operation), optype,
-					    op1, op2));
-  bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
+  label2 = gimple_build_label (label_decl2);
+  stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2,
+					op1, op2);
+  gsi_insert_before (&gsi, label2, GSI_SAME_STMT);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
   bb3end = stmt1;
 
   /* Fix CFG. */
@@ -602,35 +620,33 @@ tree_divmod_fixed_value (tree stmt, tree operation,
   return tmp2;
 }
 
+
 /* Do transform 1) on INSN if applicable.  */
+
 static bool
-tree_divmod_fixed_value_transform (tree stmt)
+gimple_divmod_fixed_value_transform (gimple_stmt_iterator *si)
 {
   histogram_value histogram;
   enum tree_code code;
   gcov_type val, count, all;
-  tree modify, op, op1, op2, result, value, tree_val;
+  tree result, value, tree_val;
   gcov_type prob;
+  gimple stmt;
 
-  modify = stmt;
-  if (TREE_CODE (stmt) == RETURN_EXPR
-      && TREE_OPERAND (stmt, 0)
-      && TREE_CODE (TREE_OPERAND (stmt, 0)) == GIMPLE_MODIFY_STMT)
-    modify = TREE_OPERAND (stmt, 0);
-  if (TREE_CODE (modify) != GIMPLE_MODIFY_STMT)
+  stmt = gsi_stmt (*si);
+  if (gimple_code (stmt) != GIMPLE_ASSIGN)
     return false;
-  op = GIMPLE_STMT_OPERAND (modify, 1);
-  if (!INTEGRAL_TYPE_P (TREE_TYPE (op)))
+
+  if (!INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_lhs (stmt))))
     return false;
-  code = TREE_CODE (op);
+
+  code = gimple_assign_rhs_code (stmt);
   
   if (code != TRUNC_DIV_EXPR && code != TRUNC_MOD_EXPR)
     return false;
 
-  op1 = TREE_OPERAND (op, 0);
-  op2 = TREE_OPERAND (op, 1);
-
-  histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_SINGLE_VALUE);
+  histogram = gimple_histogram_value_of_type (cfun, stmt,
+					      HIST_TYPE_SINGLE_VALUE);
   if (!histogram)
     return false;
 
@@ -643,11 +659,12 @@ tree_divmod_fixed_value_transform (tree stmt)
   /* 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
-      || !maybe_hot_bb_p (bb_for_stmt (stmt)))
+  if (simple_cst_equal (gimple_assign_rhs2 (stmt), value) != 1
+      || 2 * count < all
+      || !maybe_hot_bb_p (gimple_bb (stmt)))
     return false;
 
-  if (check_counter (stmt, "value", all, bb_for_stmt (stmt)->count))
+  if (check_counter (stmt, "value", all, gimple_bb (stmt)->count))
     return false;
 
   /* Compute probability of taking the optimal path.  */
@@ -659,7 +676,7 @@ tree_divmod_fixed_value_transform (tree stmt)
   tree_val = build_int_cst_wide (get_gcov_type (),
 				 (unsigned HOST_WIDE_INT) val,
 				 val >> (HOST_BITS_PER_WIDE_INT - 1) >> 1);
-  result = tree_divmod_fixed_value (stmt, op, op1, op2, tree_val, prob, count, all);
+  result = gimple_divmod_fixed_value (stmt, tree_val, prob, count, all);
 
   if (dump_file)
     {
@@ -668,68 +685,68 @@ tree_divmod_fixed_value_transform (tree stmt)
       fprintf (dump_file, "=");
       print_generic_expr (dump_file, tree_val, TDF_SLIM);
       fprintf (dump_file, " transformation on insn ");
-      print_generic_stmt (dump_file, stmt, TDF_SLIM);
+      print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
     }
 
-  GIMPLE_STMT_OPERAND (modify, 1) = result;
+  gimple_assign_set_rhs_from_tree (si, result);
 
   return true;
 }
 
-/* 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 
+/* 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
-tree_mod_pow2 (tree stmt, tree operation, tree op1, tree op2, int prob, 
-	       gcov_type count, gcov_type all)
+gimple_mod_pow2 (gimple stmt, int prob, gcov_type count, gcov_type all)
 {
-  tree stmt1, stmt2, stmt3, stmt4;
+  gimple stmt1, stmt2, stmt3, stmt4;
   tree tmp2, tmp3;
   tree label_decl1 = create_artificial_label ();
   tree label_decl2 = create_artificial_label ();
-  tree label1, label2;
-  tree bb1end, bb2end, bb3end;
+  gimple label1, label2;
+  gimple bb1end, bb2end, bb3end;
   basic_block bb, bb2, bb3, bb4;
-  tree optype = TREE_TYPE (operation);
+  tree optype, op1, op2;
   edge e12, e13, e23, e24, e34;
-  block_stmt_iterator bsi;
-  tree result = create_tmp_var (optype, "PROF");
+  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);
 
+  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");
   tmp2 = create_tmp_var (optype, "PROF");
   tmp3 = create_tmp_var (optype, "PROF");
-  stmt2 = build_gimple_modify_stmt (tmp2, 
-				    build2 (PLUS_EXPR, optype, op2,
-					    build_int_cst (optype, -1)));
-  stmt3 = build_gimple_modify_stmt (tmp3,
-				    build2 (BIT_AND_EXPR, optype, tmp2, op2));
-  stmt4 = build3 (COND_EXPR, void_type_node,
-		  build2 (NE_EXPR, boolean_type_node,
-			  tmp3, build_int_cst (optype, 0)),
-		  NULL_TREE, NULL_TREE);
-  bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt4, BSI_SAME_STMT);
+  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;
 
-  /* tmp2 == op2-1 inherited from previous block */
-  label1 = build1 (LABEL_EXPR, void_type_node, label_decl1);
-  stmt1 = build_gimple_modify_stmt (result,
-				    build2 (BIT_AND_EXPR, optype, op1, tmp2));
-  bsi_insert_before (&bsi, label1, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
+  /* tmp2 == op2-1 inherited from previous block.  */
+  label1 = gimple_build_label (label_decl1);
+  stmt1 = gimple_build_assign_with_ops (BIT_AND_EXPR, result, op1, tmp2);
+  gsi_insert_before (&gsi, label1, GSI_SAME_STMT);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
   bb2end = stmt1;
 
-  label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
-  stmt1 = build_gimple_modify_stmt (result,
-				    build2 (TREE_CODE (operation), optype,
-					    op1, op2));
-  bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
+  label2 = gimple_build_label (label_decl2);
+  stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), result,
+					op1, op2);
+  gsi_insert_before (&gsi, label2, GSI_SAME_STMT);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
   bb3end = stmt1;
 
   /* Fix CFG. */
@@ -767,32 +784,28 @@ tree_mod_pow2 (tree stmt, tree operation, tree op1, tree op2, int prob,
 
 /* Do transform 2) on INSN if applicable.  */
 static bool
-tree_mod_pow2_value_transform (tree stmt)
+gimple_mod_pow2_value_transform (gimple_stmt_iterator *si)
 {
   histogram_value histogram;
   enum tree_code code;
   gcov_type count, wrong_values, all;
-  tree modify, op, op1, op2, result, value;
+  tree lhs_type, result, value;
   gcov_type prob;
+  gimple stmt;
 
-  modify = stmt;
-  if (TREE_CODE (stmt) == RETURN_EXPR
-      && TREE_OPERAND (stmt, 0)
-      && TREE_CODE (TREE_OPERAND (stmt, 0)) == GIMPLE_MODIFY_STMT)
-    modify = TREE_OPERAND (stmt, 0);
-  if (TREE_CODE (modify) != GIMPLE_MODIFY_STMT)
+  stmt = gsi_stmt (*si);
+  if (gimple_code (stmt) != GIMPLE_ASSIGN)
     return false;
-  op = GIMPLE_STMT_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;
-  code = TREE_CODE (op);
+
+  code = gimple_assign_rhs_code (stmt);
   
-  if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (TREE_TYPE (op)))
+  if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (lhs_type))
     return false;
 
-  op1 = TREE_OPERAND (op, 0);
-  op2 = TREE_OPERAND (op, 1);
-
   histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_POW2);
   if (!histogram)
     return false;
@@ -804,20 +817,21 @@ tree_mod_pow2_value_transform (tree stmt)
   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
-      || !maybe_hot_bb_p (bb_for_stmt (stmt)))
+  if (simple_cst_equal (gimple_assign_rhs2 (stmt), value) != 1
+      || count < wrong_values
+      || !maybe_hot_bb_p (gimple_bb (stmt)))
     return false;
 
   if (dump_file)
     {
       fprintf (dump_file, "Mod power of 2 transformation on insn ");
-      print_generic_stmt (dump_file, stmt, TDF_SLIM);
+      print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
     }
 
   /* Compute probability of taking the optimal path.  */
   all = count + wrong_values;
 
-  if (check_counter (stmt, "pow2", all, bb_for_stmt (stmt)->count))
+  if (check_counter (stmt, "pow2", all, gimple_bb (stmt)->count))
     return false;
 
   if (all > 0)
@@ -825,81 +839,80 @@ tree_mod_pow2_value_transform (tree stmt)
   else
     prob = 0;
 
-  result = tree_mod_pow2 (stmt, op, op1, op2, prob, count, all);
+  result = gimple_mod_pow2 (stmt, prob, count, all);
 
-  GIMPLE_STMT_OPERAND (modify, 1) = result;
+  gimple_assign_set_rhs_from_tree (si, result);
 
   return true;
 }
 
-/* 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
+/* 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
-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)
+gimple_mod_subtract (gimple stmt, int prob1, int prob2, int ncounts,
+		     gcov_type count1, gcov_type count2, gcov_type all)
 {
-  tree stmt1, stmt2, stmt3;
+  gimple 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 label1, label2, label3;
+  gimple bb1end, bb2end = NULL, bb3end;
   basic_block bb, bb2, bb3, bb4;
-  tree optype = TREE_TYPE (operation);
+  tree optype, op1, op2;
   edge e12, e23 = 0, e24, e34, e14;
-  block_stmt_iterator bsi;
-  tree result = create_tmp_var (optype, "PROF");
+  gimple_stmt_iterator gsi;
+  tree result;
+
+  gcc_assert (is_gimple_assign (stmt)
+	      && gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR);
 
-  bb = bb_for_stmt (stmt);
-  bsi = bsi_for_stmt (stmt);
+  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");
-  stmt1 = build_gimple_modify_stmt (result, op1);
-  stmt2 = build_gimple_modify_stmt (tmp1, op2);
-  stmt3 = build3 (COND_EXPR, void_type_node,
-	    build2 (LT_EXPR, boolean_type_node, result, tmp1),
-	    NULL_TREE, NULL_TREE);
-  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;
 
   if (ncounts)	/* Assumed to be 0 or 1 */
     {
-      label1 = build1 (LABEL_EXPR, void_type_node, label_decl1);
-      stmt1 = build_gimple_modify_stmt (result,
-					build2 (MINUS_EXPR, optype,
-						result, tmp1));
-      stmt2 = build3 (COND_EXPR, void_type_node,
-		build2 (LT_EXPR, boolean_type_node, result, tmp1),
-		NULL_TREE, NULL_TREE);
-      bsi_insert_before (&bsi, label1, BSI_SAME_STMT);
-      bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
-      bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
+      label1 = gimple_build_label (label_decl1);
+      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, label1, GSI_SAME_STMT);
+      gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
+      gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
       bb2end = stmt2;
     }
 
   /* Fallback case. */
-  label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
-  stmt1 = build_gimple_modify_stmt (result,
-				    build2 (TREE_CODE (operation), optype,
-					    result, tmp1));
-  bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
+  label2 = gimple_build_label (label_decl2);
+  stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), result,
+					result, tmp1);
+  gsi_insert_before (&gsi, label2, GSI_SAME_STMT);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
   bb3end = stmt1;
 
-  label3 = build1 (LABEL_EXPR, void_type_node, label_decl3);
-  bsi_insert_before (&bsi, label3, BSI_SAME_STMT);
+  label3 = gimple_build_label (label_decl3);
+  gsi_insert_before (&gsi, label3, GSI_SAME_STMT);
 
   /* Fix CFG. */
   /* Edge e23 connects bb2 to bb3, etc. */
@@ -947,36 +960,34 @@ tree_mod_subtract (tree stmt, tree operation, tree op1, tree op2,
   return result;
 }
 
-/* Do transforms 3) and 4) on INSN if applicable.  */
+
+/* Do transforms 3) and 4) on the statement pointed-to by SI if applicable.  */
+
 static bool
-tree_mod_subtract_transform (tree stmt)
+gimple_mod_subtract_transform (gimple_stmt_iterator *si)
 {
   histogram_value histogram;
   enum tree_code code;
   gcov_type count, wrong_values, all;
-  tree modify, op, op1, op2, result, value;
+  tree lhs_type, result, value;
   gcov_type prob1, prob2;
   unsigned int i, steps;
   gcov_type count1, count2;
+  gimple stmt;
 
-  modify = stmt;
-  if (TREE_CODE (stmt) == RETURN_EXPR
-      && TREE_OPERAND (stmt, 0)
-      && TREE_CODE (TREE_OPERAND (stmt, 0)) == GIMPLE_MODIFY_STMT)
-    modify = TREE_OPERAND (stmt, 0);
-  if (TREE_CODE (modify) != GIMPLE_MODIFY_STMT)
+  stmt = gsi_stmt (*si);
+  if (gimple_code (stmt) != GIMPLE_ASSIGN)
     return false;
-  op = GIMPLE_STMT_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;
-  code = TREE_CODE (op);
+
+  code = gimple_assign_rhs_code (stmt);
   
-  if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (TREE_TYPE (op)))
+  if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (lhs_type))
     return false;
 
-  op1 = TREE_OPERAND (op, 0);
-  op2 = TREE_OPERAND (op, 1);
-
   histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_INTERVAL);
   if (!histogram)
     return false;
@@ -995,7 +1006,7 @@ tree_mod_subtract_transform (tree stmt)
   count2 = histogram->hvalue.counters[1];
 
   /* Compute probability of taking the optimal path.  */
-  if (check_counter (stmt, "interval", all, bb_for_stmt (stmt)->count))
+  if (check_counter (stmt, "interval", all, gimple_bb (stmt)->count))
     {
       gimple_remove_histogram_value (cfun, stmt, histogram);
       return false;
@@ -1011,14 +1022,14 @@ tree_mod_subtract_transform (tree stmt)
 	break;
     }
   if (i == steps
-      || !maybe_hot_bb_p (bb_for_stmt (stmt)))
+      || !maybe_hot_bb_p (gimple_bb (stmt)))
     return false;
 
   gimple_remove_histogram_value (cfun, stmt, histogram);
   if (dump_file)
     {
       fprintf (dump_file, "Mod subtract transformation on insn ");
-      print_generic_stmt (dump_file, stmt, TDF_SLIM);
+      print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
     }
 
   /* Compute probability of taking the optimal path(s).  */
@@ -1034,10 +1045,9 @@ tree_mod_subtract_transform (tree stmt)
 
   /* 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,
-			      count1, count2, all);
+  result = gimple_mod_subtract (stmt, prob1, prob2, i, count1, count2, all);
 
-  GIMPLE_STMT_OPERAND (modify, 1) = result;
+  gimple_assign_set_rhs_from_tree (si, result);
 
   return true;
 }
@@ -1082,52 +1092,48 @@ find_func_by_pid (int	pid)
     old call
  */
 
-static tree
-tree_ic (tree stmt, tree call, struct cgraph_node* direct_call, 
-	 int prob, gcov_type count, gcov_type all)
+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;
+  gimple stmt1, stmt2, stmt3;
   tree tmp1, tmpv, tmp;
   tree label_decl1 = create_artificial_label ();
   tree label_decl2 = create_artificial_label ();
-  tree label1, label2;
-  tree bb1end, bb2end, bb3end;
-  tree new_call;
+  gimple label1, label2;
+  gimple bb1end, bb2end, bb3end;
   basic_block bb, bb2, bb3, bb4;
   tree optype = build_pointer_type (void_type_node);
   edge e12, e13, e23, e24, e34;
-  block_stmt_iterator bsi;
+  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");
-  stmt1 = build_gimple_modify_stmt (tmpv, 
-				    unshare_expr (CALL_EXPR_FN (call)));
+  stmt1 = gimple_build_assign (tmpv, unshare_expr (gimple_call_fn (call)));
+
   tmp = fold_convert (optype, build_addr (direct_call->decl, 
 					  current_function_decl));
-  stmt2 = build_gimple_modify_stmt (tmp1, tmp);
-  stmt3 = build3 (COND_EXPR, void_type_node,
-		  build2 (NE_EXPR, boolean_type_node, tmp1, tmpv),
-		  NULL_TREE, NULL_TREE);
-  bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
+  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;
 
-  label1 = build1 (LABEL_EXPR, void_type_node, label_decl1);
-  stmt1 = unshare_expr (stmt);
-  new_call = get_call_expr_in (stmt1);
-  CALL_EXPR_FN (new_call) = build_addr (direct_call->decl, 
-					current_function_decl);
-  bsi_insert_before (&bsi, label1, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
+  label1 = gimple_build_label (label_decl1);
+  stmt1 = gimple_copy (stmt);
+  gimple_call_set_fn (stmt,
+		      build_addr (direct_call->decl, current_function_decl));
+  gsi_insert_before (&gsi, label1, GSI_SAME_STMT);
+  gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
   bb2end = stmt1;
 
-  label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
-  bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
+  label2 = gimple_build_label (label_decl2);
+  gsi_insert_before (&gsi, label2, GSI_SAME_STMT);
   bb3end = stmt;
 
   /* Fix CFG. */
@@ -1161,15 +1167,15 @@ tree_ic (tree stmt, tree call, struct cgraph_node* direct_call,
 
   /* Fix eh edges */
   region = lookup_stmt_eh_region (stmt);
-  if (region >=0 && tree_could_throw_p (stmt1))
+  if (region >= 0 && stmt_could_throw_p (stmt1))
     {
       add_stmt_to_eh_region (stmt1, region);
       make_eh_edges (stmt1);
     }
 
-  if (region >=0 && tree_could_throw_p (stmt))
+  if (region >= 0 && stmt_could_throw_p (stmt))
     {
-      tree_purge_dead_eh_edges (bb4);
+      gimple_purge_dead_eh_edges (bb4);
       make_eh_edges (stmt);
     }
 
@@ -1183,22 +1189,21 @@ tree_ic (tree stmt, tree call, struct cgraph_node* direct_call,
  */
 
 static bool
-tree_ic_transform (tree stmt)
+gimple_ic_transform (gimple stmt)
 {
   histogram_value histogram;
   gcov_type val, count, all;
   gcov_type prob;
-  tree call, callee, modify;
+  tree callee;
+  gimple modify;
   struct cgraph_node *direct_call;
   
-  call = get_call_expr_in (stmt);
-
-  if (!call || TREE_CODE (call) != CALL_EXPR)
+  if (gimple_code (stmt) != GIMPLE_CALL)
     return false;
 
-  callee = CALL_EXPR_FN (call);
+  callee = gimple_call_fn (stmt);
 
-  if (TREE_CODE (callee) == ADDR_EXPR)
+  if (TREE_CODE (callee) == FUNCTION_DECL)
     return false;
 
   histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_INDIR_CALL);
@@ -1222,18 +1227,18 @@ tree_ic_transform (tree stmt)
   if (direct_call == NULL)
     return false;
 
-  modify = tree_ic (stmt, call, direct_call, prob, count, all);
+  modify = gimple_ic (stmt, stmt, direct_call, prob, count, all);
 
   if (dump_file)
     {
       fprintf (dump_file, "Indirect call -> direct call ");
-      print_generic_expr (dump_file, call, TDF_SLIM);
+      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_generic_stmt (dump_file, stmt, TDF_SLIM);
+      print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
       fprintf (dump_file, " to ");
-      print_generic_stmt (dump_file, modify, TDF_SLIM);
+      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);
     }
@@ -1243,7 +1248,7 @@ tree_ic_transform (tree stmt)
 
 /* Return true if the stringop CALL with FNDECL shall be profiled.  */
 static bool
-interesting_stringop_to_profile_p (tree fndecl, tree call)
+interesting_stringop_to_profile_p (tree fndecl, gimple call)
 {
   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
 
@@ -1255,16 +1260,14 @@ interesting_stringop_to_profile_p (tree fndecl, tree call)
     {
      case BUILT_IN_MEMCPY:
      case BUILT_IN_MEMPCPY:
-       return validate_arglist (call,
-				POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE,
-				VOID_TYPE);
+       return validate_gimple_arglist (call, POINTER_TYPE, POINTER_TYPE,
+				       INTEGER_TYPE, VOID_TYPE);
      case BUILT_IN_MEMSET:
-       return validate_arglist (call,
-				POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE,
-				VOID_TYPE);
+       return validate_gimple_arglist (call, POINTER_TYPE, INTEGER_TYPE,
+				      INTEGER_TYPE, VOID_TYPE);
      case BUILT_IN_BZERO:
-       return validate_arglist (call, POINTER_TYPE, INTEGER_TYPE,
-				VOID_TYPE);
+       return validate_gimple_arglist (call, POINTER_TYPE, INTEGER_TYPE,
+				       VOID_TYPE);
      default:
        gcc_unreachable ();
     }
@@ -1279,27 +1282,26 @@ interesting_stringop_to_profile_p (tree fndecl, tree call)
    assuming constant propagation of VALUE will happen later.
 */
 static void
-tree_stringop_fixed_value (tree stmt, tree value, int prob, gcov_type count,
+gimple_stringop_fixed_value (gimple stmt, tree value, int prob, gcov_type count,
 			   gcov_type all)
 {
-  tree stmt1, stmt2, stmt3;
+  gimple stmt1, stmt2, stmt3;
   tree tmp1, tmpv;
   tree label_decl1 = create_artificial_label ();
   tree label_decl2 = create_artificial_label ();
-  tree label1, label2;
-  tree bb1end, bb2end;
+  gimple label1, label2;
+  gimple bb1end, bb2end;
   basic_block bb, bb2, bb3, bb4;
   edge e12, e13, e23, e24, e34;
-  block_stmt_iterator bsi;
-  tree call = get_call_expr_in (stmt);
-  tree blck_size = CALL_EXPR_ARG (call, 2);
+  gimple_stmt_iterator gsi;
+  tree blck_size = gimple_call_arg (stmt, 2);
   tree optype = TREE_TYPE (blck_size);
   int region;
 
-  bb = bb_for_stmt (stmt);
-  bsi = bsi_for_stmt (stmt);
+  bb = gimple_bb (stmt);
+  gsi = gsi_for_stmt (stmt);
 
-  if (bsi_end_p (bsi))
+  if (gsi_end_p (gsi))
     {
       edge_iterator ei;
       for (ei = ei_start (bb->succs); (e34 = ei_safe_edge (ei)); )
@@ -1309,34 +1311,31 @@ tree_stringop_fixed_value (tree stmt, tree value, int prob, gcov_type count,
   else
     {
       e34 = split_block (bb, stmt);
-      bsi = bsi_for_stmt (stmt);
+      gsi = gsi_for_stmt (stmt);
     }
   bb4 = e34->dest;
 
   tmpv = create_tmp_var (optype, "PROF");
   tmp1 = create_tmp_var (optype, "PROF");
-  stmt1 = build_gimple_modify_stmt (tmpv, fold_convert (optype, value));
-  stmt2 = build_gimple_modify_stmt (tmp1, blck_size);
-  stmt3 = build3 (COND_EXPR, void_type_node,
-	    build2 (NE_EXPR, boolean_type_node, tmp1, tmpv),
-	    NULL_TREE, NULL_TREE);
-  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 (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;
 
-  label1 = build1 (LABEL_EXPR, void_type_node, label_decl1);
-  stmt1 = unshare_expr (stmt);
-  call = get_call_expr_in (stmt1);
-  CALL_EXPR_ARG (call, 2) = value;
-  bsi_insert_before (&bsi, label1, BSI_SAME_STMT);
-  bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
+  label1 = gimple_build_label (label_decl1);
+  stmt1 = gimple_copy (stmt);
+  gimple_call_set_arg (stmt1, 2, value);
+  gsi_insert_before (&gsi, label1, GSI_SAME_STMT);
+  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;
-  label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
-  bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
+  label2 = gimple_build_label (label_decl2);
+  gsi_insert_before (&gsi, label2, GSI_SAME_STMT);
 
   /* Fix CFG. */
   /* Edge e23 connects bb2 to bb3, etc. */
@@ -1369,10 +1368,9 @@ tree_stringop_fixed_value (tree stmt, tree value, int prob, gcov_type count,
 /* Find values inside STMT for that we want to measure histograms for
    division/modulo optimization.  */
 static bool
-tree_stringops_transform (block_stmt_iterator *bsi)
+gimple_stringops_transform (gimple_stmt_iterator *gsi)
 {
-  tree stmt = bsi_stmt (*bsi);
-  tree call = get_call_expr_in (stmt);
+  gimple stmt = gsi_stmt (*gsi);
   tree fndecl;
   tree blck_size;
   enum built_in_function fcode;
@@ -1384,19 +1382,19 @@ tree_stringops_transform (block_stmt_iterator *bsi)
   gcov_type prob;
   tree tree_val;
 
-  if (!call)
+  if (gimple_code (stmt) != GIMPLE_CALL)
     return false;
-  fndecl = get_callee_fndecl (call);
+  fndecl = gimple_call_fndecl (stmt);
   if (!fndecl)
     return false;
   fcode = DECL_FUNCTION_CODE (fndecl);
-  if (!interesting_stringop_to_profile_p (fndecl, call))
+  if (!interesting_stringop_to_profile_p (fndecl, stmt))
     return false;
 
   if (fcode == BUILT_IN_BZERO)
-    blck_size = CALL_EXPR_ARG (call, 1);
+    blck_size = gimple_call_arg (stmt, 1);
   else
-    blck_size = CALL_EXPR_ARG (call, 2);
+    blck_size = gimple_call_arg (stmt, 2);
   if (TREE_CODE (blck_size) == INTEGER_CST)
     return false;
 
@@ -1411,28 +1409,28 @@ tree_stringops_transform (block_stmt_iterator *bsi)
   /* 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 || !maybe_hot_bb_p (bb_for_stmt (stmt)))
+  if ((6 * count / 5) < all || !maybe_hot_bb_p (gimple_bb (stmt)))
     return false;
-  if (check_counter (stmt, "value", all, bb_for_stmt (stmt)->count))
+  if (check_counter (stmt, "value", all, gimple_bb (stmt)->count))
     return false;
   if (all > 0)
     prob = (count * REG_BR_PROB_BASE + all / 2) / all;
   else
     prob = 0;
-  dest = CALL_EXPR_ARG (call, 0);
+  dest = gimple_call_arg (stmt, 0);
   dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
   switch (fcode)
     {
     case BUILT_IN_MEMCPY:
     case BUILT_IN_MEMPCPY:
-      src = CALL_EXPR_ARG (call, 1);
+      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,
-				CALL_EXPR_ARG (call, 1),
+				gimple_call_arg (stmt, 1),
 				dest_align, true))
 	return false;
       break;
@@ -1452,15 +1450,15 @@ tree_stringops_transform (block_stmt_iterator *bsi)
     {
       fprintf (dump_file, "Single value %i stringop transformation on ",
 	       (int)val);
-      print_generic_stmt (dump_file, stmt, TDF_SLIM);
+      print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
     }
-  tree_stringop_fixed_value (stmt, tree_val, prob, count, all);
+  gimple_stringop_fixed_value (stmt, tree_val, prob, count, all);
   
   return true;
 }
 
 void
-stringop_block_profile (tree stmt, unsigned int *expected_align,
+stringop_block_profile (gimple stmt, unsigned int *expected_align,
 			HOST_WIDE_INT *expected_size)
 {
   histogram_value histogram;
@@ -1520,31 +1518,25 @@ struct value_prof_hooks {
 /* Find values inside STMT for that we want to measure histograms for
    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 assign, lhs, rhs, divisor, op0, type;
+  tree lhs, divisor, op0, type;
   histogram_value hist;
 
-  if (TREE_CODE (stmt) == RETURN_EXPR)
-    assign = TREE_OPERAND (stmt, 0);
-  else
-    assign = stmt;
-
-  if (!assign
-      || TREE_CODE (assign) != GIMPLE_MODIFY_STMT)
+  if (gimple_code (stmt) != GIMPLE_ASSIGN)
     return;
-  lhs = GIMPLE_STMT_OPERAND (assign, 0);
+
+  lhs = gimple_assign_lhs (stmt);
   type = TREE_TYPE (lhs);
   if (!INTEGRAL_TYPE_P (type))
     return;
 
-  rhs = GIMPLE_STMT_OPERAND (assign, 1);
-  switch (TREE_CODE (rhs))
+  switch (gimple_assign_rhs_code (stmt))
     {
     case TRUNC_DIV_EXPR:
     case TRUNC_MOD_EXPR:
-      divisor = TREE_OPERAND (rhs, 1);
-      op0 = TREE_OPERAND (rhs, 0);
+      divisor = gimple_assign_rhs2 (stmt);
+      op0 = gimple_assign_rhs1 (stmt);
 
       VEC_reserve (histogram_value, heap, *values, 3);
 
@@ -1552,12 +1544,13 @@ tree_divmod_values_to_profile (tree stmt, histogram_values *values)
 	/* 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,
+			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).  */
-      if (TREE_CODE (rhs) == TRUNC_MOD_EXPR
+      if (gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR
 	  && TYPE_UNSIGNED (type))
 	{
           tree val;
@@ -1584,19 +1577,16 @@ tree_divmod_values_to_profile (tree stmt, histogram_values *values)
    indirect/virtual call optimization. */ 
 
 static void
-tree_indirect_call_to_profile (tree stmt, histogram_values *values)
+gimple_indirect_call_to_profile (gimple stmt, histogram_values *values)
 {
-  tree			call;
-  tree			callee;
-
-  call = get_call_expr_in (stmt);
+  tree callee;
 
-  if (!call || TREE_CODE (call) != CALL_EXPR)
+  if (gimple_code (stmt) != GIMPLE_CALL)
     return;
 
-  callee = CALL_EXPR_FN (call);
+  callee = gimple_call_fn (stmt);
   
-  if (TREE_CODE (callee) == ADDR_EXPR)
+  if (TREE_CODE (callee) == FUNCTION_DECL)
     return;
 
   VEC_reserve (histogram_value, heap, *values, 3);
@@ -1611,29 +1601,28 @@ tree_indirect_call_to_profile (tree stmt, histogram_values *values)
 /* Find values inside STMT for that we want to measure histograms for
    string operations.  */
 static void
-tree_stringops_values_to_profile (tree stmt, histogram_values *values)
+gimple_stringops_values_to_profile (gimple stmt, histogram_values *values)
 {
-  tree call = get_call_expr_in (stmt);
   tree fndecl;
   tree blck_size;
   tree dest;
   enum built_in_function fcode;
 
-  if (!call)
+  if (gimple_code (stmt) != GIMPLE_CALL)
     return;
-  fndecl = get_callee_fndecl (call);
+  fndecl = gimple_call_fndecl (stmt);
   if (!fndecl)
     return;
   fcode = DECL_FUNCTION_CODE (fndecl);
 
-  if (!interesting_stringop_to_profile_p (fndecl, call))
+  if (!interesting_stringop_to_profile_p (fndecl, stmt))
     return;
 
-  dest = CALL_EXPR_ARG (call, 0);
+  dest = gimple_call_arg (stmt, 0);
   if (fcode == BUILT_IN_BZERO)
-    blck_size = CALL_EXPR_ARG (call, 1);
+    blck_size = gimple_call_arg (stmt, 1);
   else
-    blck_size = CALL_EXPR_ARG (call, 2);
+    blck_size = gimple_call_arg (stmt, 2);
 
   if (TREE_CODE (blck_size) != INTEGER_CST)
     {
@@ -1654,28 +1643,28 @@ tree_stringops_values_to_profile (tree stmt, histogram_values *values)
    them to list VALUES.  */
 
 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)
     {
-      tree_divmod_values_to_profile (stmt, values);
-      tree_stringops_values_to_profile (stmt, values);
-      tree_indirect_call_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
-tree_find_values_to_profile (histogram_values *values)
+gimple_find_values_to_profile (histogram_values *values)
 {
   basic_block bb;
-  block_stmt_iterator bsi;
+  gimple_stmt_iterator gsi;
   unsigned i;
   histogram_value hist = NULL;
 
   *values = NULL;
   FOR_EACH_BB (bb)
-    for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
-      tree_values_to_profile (bsi_stmt (bsi), 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; VEC_iterate (histogram_value, *values, i, hist); i++)
     {
@@ -1715,22 +1704,22 @@ tree_find_values_to_profile (histogram_values *values)
       if (dump_file)
         {
 	  fprintf (dump_file, "Stmt ");
-          print_generic_expr (dump_file, hist->hvalue.stmt, TDF_SLIM);
+          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
-tree_register_value_prof_hooks (void)
+gimple_register_value_prof_hooks (void)
 {
   gcc_assert (current_ir_type () == IR_GIMPLE);
-  value_prof_hooks = &tree_value_prof_hooks;
+  value_prof_hooks = &gimple_value_prof_hooks;
 }
 
 /* IR-independent entry points.  */