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, 136 insertions, 108 deletions

diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c
index 2ac1c11..fbfcbf2 100644
--- a/gcc/tree-ssa.c
+++ b/gcc/tree-ssa.c
@@ -37,7 +37,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "bitmap.h"
 #include "pointer-set.h"
 #include "tree-flow.h"
-#include "tree-gimple.h"
+#include "gimple.h"
 #include "tree-inline.h"
 #include "varray.h"
 #include "timevar.h"
@@ -171,19 +171,23 @@ redirect_edge_var_map_destroy (void)
 edge
 ssa_redirect_edge (edge e, basic_block dest)
 {
-  tree phi;
+  gimple_stmt_iterator gsi;
+  gimple phi;
 
   redirect_edge_var_map_clear (e);
 
   /* Remove the appropriate PHI arguments in E's destination block.  */
-  for (phi = phi_nodes (e->dest); phi; phi = PHI_CHAIN (phi))
+  for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      tree def = PHI_ARG_DEF (phi, e->dest_idx);
+      tree def;
+
+      phi = gsi_stmt (gsi);
+      def = gimple_phi_arg_def (phi, e->dest_idx);
 
       if (def == NULL_TREE)
 	continue;
 
-      redirect_edge_var_map_add (e, PHI_RESULT (phi), def);
+      redirect_edge_var_map_add (e, gimple_phi_result (phi), def);
     }
 
   e = redirect_edge_succ_nodup (e, dest);
@@ -191,26 +195,31 @@ ssa_redirect_edge (edge e, basic_block dest)
   return e;
 }
 
+
 /* Add PHI arguments queued in PENDING_STMT list on edge E to edge
    E->dest.  */
 
 void
 flush_pending_stmts (edge e)
 {
-  tree phi;
+  gimple phi;
   edge_var_map_vector v;
   edge_var_map *vm;
   int i;
+  gimple_stmt_iterator gsi;
 
   v = redirect_edge_var_map_vector (e);
   if (!v)
     return;
 
-  for (phi = phi_nodes (e->dest), i = 0;
-       phi && VEC_iterate (edge_var_map, v, i, vm);
-       phi = PHI_CHAIN (phi), i++)
+  for (gsi = gsi_start_phis (e->dest), i = 0;
+       !gsi_end_p (gsi) && VEC_iterate (edge_var_map, v, i, vm);
+       gsi_next (&gsi), i++)
     {
-      tree def = redirect_edge_var_map_def (vm);
+      tree def;
+
+      phi = gsi_stmt (gsi);
+      def = redirect_edge_var_map_def (vm);
       add_phi_arg (phi, def, e);
     }
 
@@ -256,7 +265,7 @@ verify_ssa_name (tree ssa_name, bool is_virtual)
     }
 
   if (SSA_NAME_IS_DEFAULT_DEF (ssa_name)
-      && !IS_EMPTY_STMT (SSA_NAME_DEF_STMT (ssa_name)))
+      && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name)))
     {
       error ("found a default name with a non-empty defining statement");
       return true;
@@ -279,7 +288,7 @@ verify_ssa_name (tree ssa_name, bool is_virtual)
 
 static bool
 verify_def (basic_block bb, basic_block *definition_block, tree ssa_name,
-	    tree stmt, bool is_virtual)
+	    gimple stmt, bool is_virtual)
 {
   if (verify_ssa_name (ssa_name, is_virtual))
     goto err;
@@ -297,9 +306,9 @@ verify_def (basic_block bb, basic_block *definition_block, tree ssa_name,
     {
       error ("SSA_NAME_DEF_STMT is wrong");
       fprintf (stderr, "Expected definition statement:\n");
-      print_generic_stmt (stderr, SSA_NAME_DEF_STMT (ssa_name), TDF_VOPS);
+      print_gimple_stmt (stderr, SSA_NAME_DEF_STMT (ssa_name), 4, TDF_VOPS);
       fprintf (stderr, "\nActual definition statement:\n");
-      print_generic_stmt (stderr, stmt, TDF_VOPS);
+      print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
       goto err;
     }
 
@@ -309,7 +318,7 @@ err:
   fprintf (stderr, "while verifying SSA_NAME ");
   print_generic_expr (stderr, ssa_name, 0);
   fprintf (stderr, " in statement\n");
-  print_generic_stmt (stderr, stmt, TDF_VOPS);
+  print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
 
   return true;
 }
@@ -331,7 +340,7 @@ err:
 
 static bool
 verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
-	    tree stmt, bool check_abnormal, bitmap names_defined_in_bb)
+	    gimple stmt, bool check_abnormal, bitmap names_defined_in_bb)
 {
   bool err = false;
   tree ssa_name = USE_FROM_PTR (use_p);
@@ -342,7 +351,7 @@ verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
 
   TREE_VISITED (ssa_name) = 1;
 
-  if (IS_EMPTY_STMT (SSA_NAME_DEF_STMT (ssa_name))
+  if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name))
       && SSA_NAME_IS_DEFAULT_DEF (ssa_name))
     ; /* Default definitions have empty statements.  Nothing to do.  */
   else if (!def_bb)
@@ -381,9 +390,9 @@ verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
     }
   else
     {
-      tree listvar ;
+      tree listvar;
       if (use_p->prev->use == NULL)
-	listvar = use_p->prev->stmt;
+	listvar = use_p->prev->loc.ssa_name;
       else
 	listvar = USE_FROM_PTR (use_p->prev);
       if (listvar != ssa_name)
@@ -398,7 +407,7 @@ verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
       fprintf (stderr, "for SSA_NAME: ");
       print_generic_expr (stderr, ssa_name, TDF_VOPS);
       fprintf (stderr, " in statement:\n");
-      print_generic_stmt (stderr, stmt, TDF_VOPS);
+      print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
     }
 
   return err;
@@ -414,11 +423,11 @@ verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
       definition of SSA_NAME.  */
 
 static bool
-verify_phi_args (tree phi, basic_block bb, basic_block *definition_block)
+verify_phi_args (gimple phi, basic_block bb, basic_block *definition_block)
 {
   edge e;
   bool err = false;
-  unsigned i, phi_num_args = PHI_NUM_ARGS (phi);
+  size_t i, phi_num_args = gimple_phi_num_args (phi);
 
   if (EDGE_COUNT (bb->preds) != phi_num_args)
     {
@@ -429,7 +438,7 @@ verify_phi_args (tree phi, basic_block bb, basic_block *definition_block)
 
   for (i = 0; i < phi_num_args; i++)
     {
-      use_operand_p op_p = PHI_ARG_DEF_PTR (phi, i);
+      use_operand_p op_p = gimple_phi_arg_imm_use_ptr (phi, i);
       tree op = USE_FROM_PTR (op_p);
 
       e = EDGE_PRED (bb, i);
@@ -451,7 +460,7 @@ verify_phi_args (tree phi, basic_block bb, basic_block *definition_block)
 
       if (TREE_CODE (op) == SSA_NAME)
 	{
-	  err = verify_ssa_name (op, !is_gimple_reg (PHI_RESULT (phi)));
+	  err = verify_ssa_name (op, !is_gimple_reg (gimple_phi_result (phi)));
 	  err |= verify_use (e->src, definition_block[SSA_NAME_VERSION (op)],
 			     op_p, phi, e->flags & EDGE_ABNORMAL, NULL);
 	}
@@ -475,7 +484,7 @@ error:
   if (err)
     {
       fprintf (stderr, "for PHI node\n");
-      print_generic_stmt (stderr, phi, TDF_VOPS|TDF_MEMSYMS);
+      print_gimple_stmt (stderr, phi, 0, TDF_VOPS|TDF_MEMSYMS);
     }
 
 
@@ -735,13 +744,13 @@ verify_ssa (bool check_modified_stmt)
       tree name = ssa_name (i);
       if (name)
 	{
-	  tree stmt;
+	  gimple stmt;
 	  TREE_VISITED (name) = 0;
 
 	  stmt = SSA_NAME_DEF_STMT (name);
-	  if (!IS_EMPTY_STMT (stmt))
+	  if (!gimple_nop_p (stmt))
 	    {
-	      basic_block bb = bb_for_stmt (stmt);
+	      basic_block bb = gimple_bb (stmt);
 	      verify_def (bb, definition_block,
 			  name, stmt, !is_gimple_reg (name));
 
@@ -756,9 +765,9 @@ verify_ssa (bool check_modified_stmt)
   FOR_EACH_BB (bb)
     {
       edge e;
-      tree phi;
+      gimple phi;
       edge_iterator ei;
-      block_stmt_iterator bsi;
+      gimple_stmt_iterator gsi;
 
       /* Make sure that all edges have a clear 'aux' field.  */
       FOR_EACH_EDGE (e, ei, bb->preds)
@@ -772,45 +781,46 @@ verify_ssa (bool check_modified_stmt)
 	}
 
       /* Verify the arguments for every PHI node in the block.  */
-      for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
+      for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
+	  phi = gsi_stmt (gsi);
 	  if (verify_phi_args (phi, bb, definition_block))
 	    goto err;
 
 	  bitmap_set_bit (names_defined_in_bb,
-			  SSA_NAME_VERSION (PHI_RESULT (phi)));
+			  SSA_NAME_VERSION (gimple_phi_result (phi)));
 	}
 
       /* Now verify all the uses and vuses in every statement of the block.  */
-      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);
 	  use_operand_p use_p;
 
-	  if (check_modified_stmt && stmt_modified_p (stmt))
+	  if (check_modified_stmt && gimple_modified_p (stmt))
 	    {
 	      error ("stmt (%p) marked modified after optimization pass: ",
 		     (void *)stmt);
-	      print_generic_stmt (stderr, stmt, TDF_VOPS);
+	      print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
 	      goto err;
 	    }
 
-	  if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
-	      && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) != SSA_NAME)
+	  if (is_gimple_assign (stmt)
+	      && TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME)
 	    {
 	      tree lhs, base_address;
 
-	      lhs = GIMPLE_STMT_OPERAND (stmt, 0);
+	      lhs = gimple_assign_lhs (stmt);
 	      base_address = get_base_address (lhs);
 
 	      if (base_address
 		  && gimple_aliases_computed_p (cfun)
 		  && SSA_VAR_P (base_address)
-		  && !stmt_ann (stmt)->has_volatile_ops
+		  && !gimple_has_volatile_ops (stmt)
 		  && ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF))
 		{
 		  error ("statement makes a memory store, but has no VDEFS");
-		  print_generic_stmt (stderr, stmt, TDF_VOPS);
+		  print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
 		  goto err;
 		}
 	    }
@@ -820,7 +830,7 @@ verify_ssa (bool check_modified_stmt)
 	      if (verify_ssa_name (op, true))
 		{
 		  error ("in statement");
-		  print_generic_stmt (stderr, stmt, TDF_VOPS|TDF_MEMSYMS);
+		  print_gimple_stmt (stderr, stmt, 0, TDF_VOPS|TDF_MEMSYMS);
 		  goto err;
 		}
 	    }
@@ -830,7 +840,7 @@ verify_ssa (bool check_modified_stmt)
 	      if (verify_ssa_name (op, false))
 		{
 		  error ("in statement");
-		  print_generic_stmt (stderr, stmt, TDF_VOPS|TDF_MEMSYMS);
+		  print_gimple_stmt (stderr, stmt, 0, TDF_VOPS|TDF_MEMSYMS);
 		  goto err;
 		}
 	    }
@@ -951,7 +961,7 @@ delete_tree_ssa (void)
 {
   size_t i;
   basic_block bb;
-  block_stmt_iterator bsi;
+  gimple_stmt_iterator gsi;
   referenced_var_iterator rvi;
   tree var;
 
@@ -967,17 +977,32 @@ delete_tree_ssa (void)
       release_ssa_name (var);
     }
 
-  /* Remove annotations from every tree in the function.  */
+  /* FIXME.  This may not be necessary.  We will release all this
+     memory en masse in free_ssa_operands.  This clearing used to be
+     necessary to avoid problems with the inliner, but it may not be
+     needed anymore.  */
   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);
-	  stmt_ann_t ann = get_stmt_ann (stmt);
+	  gimple stmt = gsi_stmt (gsi);
+
+	  if (gimple_has_ops (stmt))
+	    {
+	      gimple_set_def_ops (stmt, NULL);
+	      gimple_set_use_ops (stmt, NULL);
+	      gimple_set_addresses_taken (stmt, NULL);
+	    }
+
+	  if (gimple_has_mem_ops (stmt))
+	    {
+	      gimple_set_vdef_ops (stmt, NULL);
+	      gimple_set_vuse_ops (stmt, NULL);
+	      BITMAP_FREE (stmt->gsmem.membase.stores);
+	      BITMAP_FREE (stmt->gsmem.membase.loads);
+	    }
 
-	  free_ssa_operands (&ann->operands);
-	  ann->addresses_taken = 0;
-	  mark_stmt_modified (stmt);
+	  gimple_set_modified (stmt, true);
 	}
       set_phi_nodes (bb, NULL);
     }
@@ -1001,7 +1026,8 @@ delete_tree_ssa (void)
 
   fini_ssanames ();
   fini_phinodes ();
-  /* we no longer maintain the SSA operand cache at this point.  */
+
+  /* We no longer maintain the SSA operand cache at this point.  */
   if (ssa_operands_active ())
     fini_ssa_operands ();
 
@@ -1209,12 +1235,9 @@ tree_ssa_useless_type_conversion (tree expr)
   if (CONVERT_EXPR_P (expr)
       || TREE_CODE (expr) == VIEW_CONVERT_EXPR
       || TREE_CODE (expr) == NON_LVALUE_EXPR)
-    /* FIXME: Use of GENERIC_TREE_TYPE here is a temporary measure to work
-       around known bugs with GIMPLE_MODIFY_STMTs appearing in places
-       they shouldn't.  See PR 30391.  */
     return useless_type_conversion_p
       (TREE_TYPE (expr),
-       GENERIC_TREE_TYPE (TREE_OPERAND (expr, 0)));
+       TREE_TYPE (TREE_OPERAND (expr, 0)));
 
   return false;
 }
@@ -1238,33 +1261,33 @@ static bool
 walk_use_def_chains_1 (tree var, walk_use_def_chains_fn fn, void *data,
 		       struct pointer_set_t *visited, bool is_dfs)
 {
-  tree def_stmt;
+  gimple def_stmt;
 
   if (pointer_set_insert (visited, var))
     return false;
 
   def_stmt = SSA_NAME_DEF_STMT (var);
 
-  if (TREE_CODE (def_stmt) != PHI_NODE)
+  if (gimple_code (def_stmt) != GIMPLE_PHI)
     {
       /* If we reached the end of the use-def chain, call FN.  */
       return fn (var, def_stmt, data);
     }
   else
     {
-      int i;
+      size_t i;
 
       /* When doing a breadth-first search, call FN before following the
 	 use-def links for each argument.  */
       if (!is_dfs)
-	for (i = 0; i < PHI_NUM_ARGS (def_stmt); i++)
-	  if (fn (PHI_ARG_DEF (def_stmt, i), def_stmt, data))
+	for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
+	  if (fn (gimple_phi_arg_def (def_stmt, i), def_stmt, data))
 	    return true;
 
       /* Follow use-def links out of each PHI argument.  */
-      for (i = 0; i < PHI_NUM_ARGS (def_stmt); i++)
+      for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
 	{
-	  tree arg = PHI_ARG_DEF (def_stmt, i);
+	  tree arg = gimple_phi_arg_def (def_stmt, i);
 
 	  /* ARG may be NULL for newly introduced PHI nodes.  */
 	  if (arg
@@ -1276,8 +1299,8 @@ walk_use_def_chains_1 (tree var, walk_use_def_chains_fn fn, void *data,
       /* When doing a depth-first search, call FN after following the
 	 use-def links for each argument.  */
       if (is_dfs)
-	for (i = 0; i < PHI_NUM_ARGS (def_stmt); i++)
-	  if (fn (PHI_ARG_DEF (def_stmt, i), def_stmt, data))
+	for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
+	  if (fn (gimple_phi_arg_def (def_stmt, i), def_stmt, data))
 	    return true;
     }
   
@@ -1310,7 +1333,7 @@ void
 walk_use_def_chains (tree var, walk_use_def_chains_fn fn, void *data,
                      bool is_dfs)
 {
-  tree def_stmt;
+  gimple def_stmt;
 
   gcc_assert (TREE_CODE (var) == SSA_NAME);
 
@@ -1318,7 +1341,7 @@ walk_use_def_chains (tree var, walk_use_def_chains_fn fn, void *data,
 
   /* We only need to recurse if the reaching definition comes from a PHI
      node.  */
-  if (TREE_CODE (def_stmt) != PHI_NODE)
+  if (gimple_code (def_stmt) != GIMPLE_PHI)
     (*fn) (var, def_stmt, data);
   else
     {
@@ -1345,7 +1368,7 @@ ssa_undefined_value_p (tree t)
     return false;
 
   /* The value is undefined iff its definition statement is empty.  */
-  return IS_EMPTY_STMT (SSA_NAME_DEF_STMT (t));
+  return gimple_nop_p (SSA_NAME_DEF_STMT (t));
 }
 
 /* Emit warnings for uninitialized variables.  This is done in two passes.
@@ -1370,8 +1393,8 @@ static void
 warn_uninit (tree t, const char *gmsgid, void *data)
 {
   tree var = SSA_NAME_VAR (t);
-  tree context = (tree) data;
-  location_t *locus;
+  gimple context = (gimple) data;
+  location_t location;
   expanded_location xloc, floc;
 
   if (!ssa_undefined_value_p (t))
@@ -1382,11 +1405,11 @@ warn_uninit (tree t, const char *gmsgid, void *data)
   if (TREE_NO_WARNING (var))
     return;
 
-  locus = (context != NULL && EXPR_HAS_LOCATION (context)
-	   ? EXPR_LOCUS (context)
-	   : &DECL_SOURCE_LOCATION (var));
-  warning_at (*locus, OPT_Wuninitialized, gmsgid, var);
-  xloc = expand_location (*locus);
+  location = (context != NULL && gimple_has_location (context))
+	     ? gimple_location (context)
+	     : DECL_SOURCE_LOCATION (var);
+  warning_at (location, OPT_Wuninitialized, gmsgid, var);
+  xloc = expand_location (location);
   floc = expand_location (DECL_SOURCE_LOCATION (cfun->decl));
   if (xloc.file != floc.file
       || xloc.line < floc.line
@@ -1397,7 +1420,7 @@ warn_uninit (tree t, const char *gmsgid, void *data)
 }
 
 struct walk_data {
-  tree stmt;
+  gimple stmt;
   bool always_executed;
 };
 
@@ -1407,7 +1430,8 @@ struct walk_data {
 static tree
 warn_uninitialized_var (tree *tp, int *walk_subtrees, void *data_)
 {
-  struct walk_data *data = (struct walk_data *)data_;
+  struct walk_stmt_info *wi = (struct walk_stmt_info *) data_;
+  struct walk_data *data = (struct walk_data *) wi->info;
   tree t = *tp;
 
   switch (TREE_CODE (t))
@@ -1446,17 +1470,17 @@ warn_uninitialized_var (tree *tp, int *walk_subtrees, void *data_)
    and warn about them.  */
 
 static void
-warn_uninitialized_phi (tree phi)
+warn_uninitialized_phi (gimple phi)
 {
-  int i, n = PHI_NUM_ARGS (phi);
+  size_t i, n = gimple_phi_num_args (phi);
 
   /* Don't look at memory tags.  */
-  if (!is_gimple_reg (PHI_RESULT (phi)))
+  if (!is_gimple_reg (gimple_phi_result (phi)))
     return;
 
   for (i = 0; i < n; ++i)
     {
-      tree op = PHI_ARG_DEF (phi, i);
+      tree op = gimple_phi_arg_def (phi, i);
       if (TREE_CODE (op) == SSA_NAME)
 	warn_uninit (op, "%qD may be used uninitialized in this function",
 		     NULL);
@@ -1466,7 +1490,7 @@ warn_uninitialized_phi (tree phi)
 static unsigned int
 execute_early_warn_uninitialized (void)
 {
-  block_stmt_iterator bsi;
+  gimple_stmt_iterator gsi;
   basic_block bb;
   struct walk_data data;
 
@@ -1476,12 +1500,14 @@ execute_early_warn_uninitialized (void)
     {
       data.always_executed = dominated_by_p (CDI_POST_DOMINATORS,
 					     single_succ (ENTRY_BLOCK_PTR), bb);
-      for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
-        {
-	  data.stmt = bsi_stmt (bsi);
-	  walk_tree (bsi_stmt_ptr (bsi), warn_uninitialized_var,
-		     &data, NULL);
-        }
+      for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+	{
+	  struct walk_stmt_info wi;
+	  data.stmt = gsi_stmt (gsi);
+	  memset (&wi, 0, sizeof (wi));
+	  wi.info = &data;
+	  walk_gimple_op (gsi_stmt (gsi), warn_uninitialized_var, &wi);
+	}
     }
   return 0;
 }
@@ -1490,7 +1516,7 @@ static unsigned int
 execute_late_warn_uninitialized (void)
 {
   basic_block bb;
-  tree phi;
+  gimple_stmt_iterator gsi;
 
   /* Re-do the plain uninitialized variable check, as optimization may have
      straightened control flow.  Do this first so that we don't accidentally
@@ -1498,8 +1524,9 @@ execute_late_warn_uninitialized (void)
   execute_early_warn_uninitialized ();
 
   FOR_EACH_BB (bb)
-    for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
-      warn_uninitialized_phi (phi);
+    for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+      warn_uninitialized_phi (gsi_stmt (gsi));
+
   return 0;
 }
 
@@ -1554,32 +1581,33 @@ execute_update_addresses_taken (void)
 {
   tree var;
   referenced_var_iterator rvi;
-  block_stmt_iterator bsi;
+  gimple_stmt_iterator gsi;
   basic_block bb;
   bitmap addresses_taken = BITMAP_ALLOC (NULL);
   bitmap vars_updated = BITMAP_ALLOC (NULL);
   bool update_vops = false;
-  tree phi;
 
   /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
      the function body.  */
   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))
 	{
-	  stmt_ann_t s_ann = stmt_ann (bsi_stmt (bsi));
-
-	  if (s_ann->addresses_taken)
-	    bitmap_ior_into (addresses_taken, s_ann->addresses_taken);
+	  bitmap taken = gimple_addresses_taken (gsi_stmt (gsi));
+	  if (taken)
+	    bitmap_ior_into (addresses_taken, taken);
 	}
-      for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
+
+      for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  unsigned i, phi_num_args = PHI_NUM_ARGS (phi);
-	  for (i = 0; i < phi_num_args; i++)
+	  size_t i;
+	  gimple phi = gsi_stmt (gsi);
+
+	  for (i = 0; i < gimple_phi_num_args (phi); i++)
 	    {
 	      tree op = PHI_ARG_DEF (phi, i), var;
 	      if (TREE_CODE (op) == ADDR_EXPR
-		  && (var = get_base_address (TREE_OPERAND (op, 0))) != NULL_TREE
+		  && (var = get_base_address (TREE_OPERAND (op, 0))) != NULL
 		  && DECL_P (var))
 		bitmap_set_bit (addresses_taken, DECL_UID (var));
 	    }
@@ -1611,14 +1639,14 @@ execute_update_addresses_taken (void)
      variables.  */
   if (update_vops)
     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);
 
-	  if ((LOADED_SYMS (stmt)
-	       && bitmap_intersect_p (LOADED_SYMS (stmt), vars_updated))
-	      || (STORED_SYMS (stmt)
-		  && bitmap_intersect_p (STORED_SYMS (stmt), vars_updated)))
+	  if ((gimple_loaded_syms (stmt)
+	       && bitmap_intersect_p (gimple_loaded_syms (stmt), vars_updated))
+	      || (gimple_stored_syms (stmt)
+		  && bitmap_intersect_p (gimple_stored_syms (stmt), vars_updated)))
 	    update_stmt (stmt);
 	}
   BITMAP_FREE (addresses_taken);