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.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@138207 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 140 insertions, 124 deletions

diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c
index c024b74e09c..1b5e92b5af3 100644
--- a/gcc/tree-data-ref.c
+++ b/gcc/tree-data-ref.c
@@ -186,7 +186,7 @@ dump_data_reference (FILE *outf,
   unsigned int i;
   
   fprintf (outf, "(Data Ref: \n  stmt: ");
-  print_generic_stmt (outf, DR_STMT (dr), 0);
+  print_gimple_stmt (outf, DR_STMT (dr), 0, 0);
   fprintf (outf, "  ref: ");
   print_generic_stmt (outf, DR_REF (dr), 0);
   fprintf (outf, "  base_object: ");
@@ -500,68 +500,65 @@ dump_ddrs (FILE *file, VEC (ddr_p, heap) *ddrs)
   fprintf (file, "\n\n");
 }
 
-/* Expresses EXP as VAR + OFF, where off is a constant.  The type of OFF
-   will be ssizetype.  */
+/* Helper function for split_constant_offset.  Expresses OP0 CODE OP1
+   (the type of the result is TYPE) as VAR + OFF, where OFF is a nonzero
+   constant of type ssizetype, and returns true.  If we cannot do this
+   with OFF nonzero, OFF and VAR are set to NULL_TREE instead and false
+   is returned.  */
 
-void
-split_constant_offset (tree exp, tree *var, tree *off)
+static bool
+split_constant_offset_1 (tree type, tree op0, enum tree_code code, tree op1,
+			 tree *var, tree *off)
 {
-  tree type = TREE_TYPE (exp), otype;
   tree var0, var1;
   tree off0, off1;
-  enum tree_code code;
+  enum tree_code ocode = code;
 
-  *var = exp;
-  STRIP_NOPS (exp);
-  otype = TREE_TYPE (exp);
-  code = TREE_CODE (exp);
+  *var = NULL_TREE;
+  *off = NULL_TREE;
 
   switch (code)
     {
     case INTEGER_CST:
       *var = build_int_cst (type, 0);
-      *off = fold_convert (ssizetype, exp);
-      return;
+      *off = fold_convert (ssizetype, op0);
+      return true;
 
     case POINTER_PLUS_EXPR:
-      code = PLUS_EXPR;
+      ocode = PLUS_EXPR;
       /* FALLTHROUGH */
     case PLUS_EXPR:
     case MINUS_EXPR:
-      split_constant_offset (TREE_OPERAND (exp, 0), &var0, &off0);
-      split_constant_offset (TREE_OPERAND (exp, 1), &var1, &off1);
-      *var = fold_convert (type, fold_build2 (TREE_CODE (exp), otype, 
-					      var0, var1));
-      *off = size_binop (code, off0, off1);
-      return;
+      split_constant_offset (op0, &var0, &off0);
+      split_constant_offset (op1, &var1, &off1);
+      *var = fold_build2 (code, type, var0, var1);
+      *off = size_binop (ocode, off0, off1);
+      return true;
 
     case MULT_EXPR:
-      off1 = TREE_OPERAND (exp, 1);
-      if (TREE_CODE (off1) != INTEGER_CST)
-	break;
+      if (TREE_CODE (op1) != INTEGER_CST)
+	return false;
 
-      split_constant_offset (TREE_OPERAND (exp, 0), &var0, &off0);
-      *var = fold_convert (type, fold_build2 (MULT_EXPR, otype,
-					      var0, off1));
-      *off = size_binop (MULT_EXPR, off0, fold_convert (ssizetype, off1));
-      return;
+      split_constant_offset (op0, &var0, &off0);
+      *var = fold_build2 (MULT_EXPR, type, var0, op1);
+      *off = size_binop (MULT_EXPR, off0, fold_convert (ssizetype, op1));
+      return true;
 
     case ADDR_EXPR:
       {
-	tree op, base, poffset;
+	tree base, poffset;
 	HOST_WIDE_INT pbitsize, pbitpos;
 	enum machine_mode pmode;
 	int punsignedp, pvolatilep;
 
-	op = TREE_OPERAND (exp, 0);
-	if (!handled_component_p (op))
-	  break;
+	if (!handled_component_p (op0))
+	  return false;
 
-	base = get_inner_reference (op, &pbitsize, &pbitpos, &poffset,
+	base = get_inner_reference (op0, &pbitsize, &pbitpos, &poffset,
 				    &pmode, &punsignedp, &pvolatilep, false);
 
 	if (pbitpos % BITS_PER_UNIT != 0)
-	  break;
+	  return false;
 	base = build_fold_addr_expr (base);
 	off0 = ssize_int (pbitpos / BITS_PER_UNIT);
 
@@ -595,40 +592,57 @@ split_constant_offset (tree exp, tree *var, tree *off)
 	while (POINTER_TYPE_P (type))
 	  type = TREE_TYPE (type);
 	if (int_size_in_bytes (type) < 0)
-	  break;
+	  return false;
 
 	*var = var0;
 	*off = off0;
-	return;
+	return true;
       }
 
     case SSA_NAME:
       {
-	tree def_stmt = SSA_NAME_DEF_STMT (exp);
-	if (TREE_CODE (def_stmt) == GIMPLE_MODIFY_STMT)
-	  {
-	    tree def_stmt_rhs = GIMPLE_STMT_OPERAND (def_stmt, 1);
+	gimple def_stmt = SSA_NAME_DEF_STMT (op0);
+	enum tree_code subcode;
 
-	    if (!TREE_SIDE_EFFECTS (def_stmt_rhs) 
-		&& EXPR_P (def_stmt_rhs)
-		&& !REFERENCE_CLASS_P (def_stmt_rhs)
-		&& !get_call_expr_in (def_stmt_rhs))
-	      {
-		split_constant_offset (def_stmt_rhs, &var0, &off0);
-		var0 = fold_convert (type, var0);
-		*var = var0;
-		*off = off0;
-		return;
-	      }
-	  }
-	break;
+	if (gimple_code (def_stmt) != GIMPLE_ASSIGN)
+	  return false;
+
+	var0 = gimple_assign_rhs1 (def_stmt);
+	subcode = gimple_assign_rhs_code (def_stmt);
+	var1 = gimple_assign_rhs2 (def_stmt);
+
+	return split_constant_offset_1 (type, var0, subcode, var1, var, off);
       }
 
     default:
-      break;
+      return false;
     }
+}
+
+/* Expresses EXP as VAR + OFF, where off is a constant.  The type of OFF
+   will be ssizetype.  */
+
+void
+split_constant_offset (tree exp, tree *var, tree *off)
+{
+  tree type = TREE_TYPE (exp), otype, op0, op1, e, o;
+  enum tree_code code;
 
+  *var = exp;
   *off = ssize_int (0);
+  STRIP_NOPS (exp);
+
+  if (automatically_generated_chrec_p (exp))
+    return;
+
+  otype = TREE_TYPE (exp);
+  code = TREE_CODE (exp);
+  extract_ops_from_tree (exp, &code, &op0, &op1);
+  if (split_constant_offset_1 (otype, op0, code, op1, &e, &o))
+    {
+      *var = fold_convert (type, e);
+      *off = o;
+    }
 }
 
 /* Returns the address ADDR of an object in a canonical shape (without nop
@@ -658,7 +672,7 @@ canonicalize_base_object_address (tree addr)
 void
 dr_analyze_innermost (struct data_reference *dr)
 {
-  tree stmt = DR_STMT (dr);
+  gimple stmt = DR_STMT (dr);
   struct loop *loop = loop_containing_stmt (stmt);
   tree ref = DR_REF (dr);
   HOST_WIDE_INT pbitsize, pbitpos;
@@ -729,7 +743,7 @@ dr_analyze_innermost (struct data_reference *dr)
 static void
 dr_analyze_indices (struct data_reference *dr, struct loop *nest)
 {
-  tree stmt = DR_STMT (dr);
+  gimple stmt = DR_STMT (dr);
   struct loop *loop = loop_containing_stmt (stmt);
   VEC (tree, heap) *access_fns = NULL;
   tree ref = unshare_expr (DR_REF (dr)), aref = ref, op;
@@ -773,7 +787,7 @@ dr_analyze_indices (struct data_reference *dr, struct loop *nest)
 static void
 dr_analyze_alias (struct data_reference *dr)
 {
-  tree stmt = DR_STMT (dr);
+  gimple stmt = DR_STMT (dr);
   tree ref = DR_REF (dr);
   tree base = get_base_address (ref), addr, smt = NULL_TREE;
   ssa_op_iter it;
@@ -834,7 +848,7 @@ free_data_ref (data_reference_p dr)
    loop nest in that the reference should be analyzed.  */
 
 struct data_reference *
-create_data_ref (struct loop *nest, tree memref, tree stmt, bool is_read)
+create_data_ref (struct loop *nest, tree memref, gimple stmt, bool is_read)
 {
   struct data_reference *dr;
 
@@ -1537,8 +1551,8 @@ analyze_ziv_subscript (tree chrec_a,
     fprintf (dump_file, "(analyze_ziv_subscript \n");
 
   type = signed_type_for_types (TREE_TYPE (chrec_a), TREE_TYPE (chrec_b));
-  chrec_a = chrec_convert (type, chrec_a, NULL_TREE);
-  chrec_b = chrec_convert (type, chrec_b, NULL_TREE);
+  chrec_a = chrec_convert (type, chrec_a, NULL);
+  chrec_b = chrec_convert (type, chrec_b, NULL);
   difference = chrec_fold_minus (type, chrec_a, chrec_b);
   
   switch (TREE_CODE (difference))
@@ -1668,8 +1682,8 @@ analyze_siv_subscript_cst_affine (tree chrec_a,
   tree type, difference, tmp;
 
   type = signed_type_for_types (TREE_TYPE (chrec_a), TREE_TYPE (chrec_b));
-  chrec_a = chrec_convert (type, chrec_a, NULL_TREE);
-  chrec_b = chrec_convert (type, chrec_b, NULL_TREE);
+  chrec_a = chrec_convert (type, chrec_a, NULL);
+  chrec_b = chrec_convert (type, chrec_b, NULL);
   difference = chrec_fold_minus (type, initial_condition (chrec_b), chrec_a);
   
   if (!chrec_is_positive (initial_condition (difference), &value0))
@@ -1875,7 +1889,7 @@ initialize_matrix_A (lambda_matrix A, tree chrec, unsigned index, int mult)
     case NOP_EXPR:
       {
 	tree op = initialize_matrix_A (A, TREE_OPERAND (chrec, 0), index, mult);
-	return chrec_convert (chrec_type (chrec), op, NULL_TREE);
+	return chrec_convert (chrec_type (chrec), op, NULL);
       }
 
     case INTEGER_CST:
@@ -2365,7 +2379,7 @@ can_use_analyze_subscript_affine_affine (tree *chrec_a, tree *chrec_b)
 
   type = chrec_type (*chrec_a);
   left_a = CHREC_LEFT (*chrec_a);
-  left_b = chrec_convert (type, CHREC_LEFT (*chrec_b), NULL_TREE);
+  left_b = chrec_convert (type, CHREC_LEFT (*chrec_b), NULL);
   diff = chrec_fold_minus (type, left_a, left_b);
 
   if (!evolution_function_is_constant_p (diff))
@@ -2376,7 +2390,7 @@ can_use_analyze_subscript_affine_affine (tree *chrec_a, tree *chrec_b)
 
   *chrec_a = build_polynomial_chrec (CHREC_VARIABLE (*chrec_a), 
 				     diff, CHREC_RIGHT (*chrec_a));
-  right_b = chrec_convert (type, CHREC_RIGHT (*chrec_b), NULL_TREE);
+  right_b = chrec_convert (type, CHREC_RIGHT (*chrec_b), NULL);
   *chrec_b = build_polynomial_chrec (CHREC_VARIABLE (*chrec_b),
 				     build_int_cst (type, 0),
 				     right_b);
@@ -2523,8 +2537,8 @@ analyze_miv_subscript (tree chrec_a,
     fprintf (dump_file, "(analyze_miv_subscript \n");
 
   type = signed_type_for_types (TREE_TYPE (chrec_a), TREE_TYPE (chrec_b));
-  chrec_a = chrec_convert (type, chrec_a, NULL_TREE);
-  chrec_b = chrec_convert (type, chrec_b, NULL_TREE);
+  chrec_a = chrec_convert (type, chrec_a, NULL);
+  chrec_b = chrec_convert (type, chrec_b, NULL);
   difference = chrec_fold_minus (type, chrec_a, chrec_b);
   
   if (eq_evolutions_p (chrec_a, chrec_b))
@@ -3474,8 +3488,8 @@ omega_setup_subscript (tree access_fun_a, tree access_fun_b,
   int eq;
   tree type = signed_type_for_types (TREE_TYPE (access_fun_a),
 				     TREE_TYPE (access_fun_b));
-  tree fun_a = chrec_convert (type, access_fun_a, NULL_TREE);
-  tree fun_b = chrec_convert (type, access_fun_b, NULL_TREE);
+  tree fun_a = chrec_convert (type, access_fun_a, NULL);
+  tree fun_b = chrec_convert (type, access_fun_b, NULL);
   tree difference = chrec_fold_minus (type, fun_a, fun_b);
 
   /* When the fun_a - fun_b is not constant, the dependence is not
@@ -3835,9 +3849,9 @@ compute_affine_dependence (struct data_dependence_relation *ddr,
     {
       fprintf (dump_file, "(compute_affine_dependence\n");
       fprintf (dump_file, "  (stmt_a = \n");
-      print_generic_expr (dump_file, DR_STMT (dra), 0);
+      print_gimple_stmt (dump_file, DR_STMT (dra), 0, 0);
       fprintf (dump_file, ")\n  (stmt_b = \n");
-      print_generic_expr (dump_file, DR_STMT (drb), 0);
+      print_gimple_stmt (dump_file, DR_STMT (drb), 0, 0);
       fprintf (dump_file, ")\n");
     }
 
@@ -3988,32 +4002,32 @@ compute_all_dependences (VEC (data_reference_p, heap) *datarefs,
    true if STMT clobbers memory, false otherwise.  */
 
 bool
-get_references_in_stmt (tree stmt, VEC (data_ref_loc, heap) **references)
+get_references_in_stmt (gimple stmt, VEC (data_ref_loc, heap) **references)
 {
   bool clobbers_memory = false;
   data_ref_loc *ref;
-  tree *op0, *op1, call;
+  tree *op0, *op1;
+  enum gimple_code stmt_code = gimple_code (stmt);
 
   *references = NULL;
 
   /* ASM_EXPR and CALL_EXPR may embed arbitrary side effects.
      Calls have side-effects, except those to const or pure
      functions.  */
-  call = get_call_expr_in (stmt);
-  if ((call
-       && !(call_expr_flags (call) & (ECF_CONST | ECF_PURE)))
-      || (TREE_CODE (stmt) == ASM_EXPR
-	  && ASM_VOLATILE_P (stmt)))
+  if ((stmt_code == GIMPLE_CALL
+       && !(gimple_call_flags (stmt) & (ECF_CONST | ECF_PURE)))
+      || (stmt_code == GIMPLE_ASM
+	  && gimple_asm_volatile_p (stmt)))
     clobbers_memory = true;
 
   if (ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
     return clobbers_memory;
 
-  if (TREE_CODE (stmt) ==  GIMPLE_MODIFY_STMT)
+  if (stmt_code == GIMPLE_ASSIGN)
     {
       tree base;
-      op0 = &GIMPLE_STMT_OPERAND (stmt, 0);
-      op1 = &GIMPLE_STMT_OPERAND (stmt, 1);
+      op0 = gimple_assign_lhs_ptr (stmt);
+      op1 = gimple_assign_rhs1_ptr (stmt);
 		
       if (DECL_P (*op1)
 	  || (REFERENCE_CLASS_P (*op1)
@@ -4033,14 +4047,13 @@ get_references_in_stmt (tree stmt, VEC (data_ref_loc, heap) **references)
 	  ref->is_read = false;
 	}
     }
-
-  if (call)
+  else if (stmt_code == GIMPLE_CALL)
     {
-      unsigned i, n = call_expr_nargs (call);
+      unsigned i, n = gimple_call_num_args (stmt);
 
       for (i = 0; i < n; i++)
 	{
-	  op0 = &CALL_EXPR_ARG (call, i);
+	  op0 = gimple_call_arg_ptr (stmt, i);
 
 	  if (DECL_P (*op0)
 	      || (REFERENCE_CLASS_P (*op0) && get_base_address (*op0)))
@@ -4060,7 +4073,7 @@ get_references_in_stmt (tree stmt, VEC (data_ref_loc, heap) **references)
    loop of the loop nest in that the references should be analyzed.  */
 
 static bool
-find_data_references_in_stmt (struct loop *nest, tree stmt,
+find_data_references_in_stmt (struct loop *nest, gimple stmt,
 			      VEC (data_reference_p, heap) **datarefs)
 {
   unsigned i;
@@ -4110,7 +4123,7 @@ find_data_references_in_loop (struct loop *loop,
 {
   basic_block bb, *bbs;
   unsigned int i;
-  block_stmt_iterator bsi;
+  gimple_stmt_iterator bsi;
 
   bbs = get_loop_body_in_dom_order (loop);
 
@@ -4118,9 +4131,9 @@ find_data_references_in_loop (struct loop *loop,
     {
       bb = bbs[i];
 
-      for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
+      for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	{
-	  tree stmt = bsi_stmt (bsi);
+	  gimple stmt = gsi_stmt (bsi);
 
 	  if (!find_data_references_in_stmt (loop, stmt, datarefs))
 	    {
@@ -4443,7 +4456,7 @@ dump_rdg_vertex (FILE *file, struct graph *rdg, int i)
       fprintf (file, " %d", e->dest);
 
   fprintf (file, ") \n");
-  print_generic_stmt (file, RDGV_STMT (v), TDF_VOPS|TDF_MEMSYMS);
+  print_gimple_stmt (file, RDGV_STMT (v), 0, TDF_VOPS|TDF_MEMSYMS);
   fprintf (file, ")\n");
 }
 
@@ -4579,14 +4592,14 @@ dot_rdg (struct graph *rdg)
 
 struct rdg_vertex_info GTY(())
 {
-  tree stmt;
+  gimple stmt;
   int index;
 };
 
 /* Returns the index of STMT in RDG.  */
 
 int
-rdg_vertex_for_stmt (struct graph *rdg, tree stmt)
+rdg_vertex_for_stmt (struct graph *rdg, gimple stmt)
 {
   struct rdg_vertex_info rvi, *slot;
 
@@ -4690,12 +4703,12 @@ create_rdg_edges (struct graph *rdg, VEC (ddr_p, heap) *ddrs)
 /* Build the vertices of the reduced dependence graph RDG.  */
 
 static void
-create_rdg_vertices (struct graph *rdg, VEC (tree, heap) *stmts)
+create_rdg_vertices (struct graph *rdg, VEC (gimple, heap) *stmts)
 {
   int i, j;
-  tree stmt;
+  gimple stmt;
 
-  for (i = 0; VEC_iterate (tree, stmts, i, stmt); i++)
+  for (i = 0; VEC_iterate (gimple, stmts, i, stmt); i++)
     {
       VEC (data_ref_loc, heap) *references;
       data_ref_loc *ref;
@@ -4717,7 +4730,7 @@ create_rdg_vertices (struct graph *rdg, VEC (tree, heap) *stmts)
 
       RDG_MEM_WRITE_STMT (rdg, i) = false;
       RDG_MEM_READS_STMT (rdg, i) = false;
-      if (TREE_CODE (stmt) == PHI_NODE)
+      if (gimple_code (stmt) == GIMPLE_PHI)
 	continue;
 
       get_references_in_stmt (stmt, &references);
@@ -4738,23 +4751,26 @@ create_rdg_vertices (struct graph *rdg, VEC (tree, heap) *stmts)
    identifying statements. */
 
 static void
-stmts_from_loop (struct loop *loop, VEC (tree, heap) **stmts)
+stmts_from_loop (struct loop *loop, VEC (gimple, heap) **stmts)
 {
   unsigned int i;
   basic_block *bbs = get_loop_body_in_dom_order (loop);
 
   for (i = 0; i < loop->num_nodes; i++)
     {
-      tree phi, stmt;
       basic_block bb = bbs[i];
-      block_stmt_iterator bsi;
+      gimple_stmt_iterator bsi;
+      gimple stmt;
 
-      for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
-	VEC_safe_push (tree, heap, *stmts, phi);
+      for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
+	VEC_safe_push (gimple, heap, *stmts, gsi_stmt (bsi));
 
-      for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
-	if (TREE_CODE (stmt = bsi_stmt (bsi)) != LABEL_EXPR)
-	  VEC_safe_push (tree, heap, *stmts, stmt);
+      for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
+	{
+	  stmt = gsi_stmt (bsi);
+	  if (gimple_code (stmt) != GIMPLE_LABEL)
+	    VEC_safe_push (gimple, heap, *stmts, stmt);
+	}
     }
 
   free (bbs);
@@ -4782,7 +4798,7 @@ hash_stmt_vertex_info (const void *elt)
 {
   const struct rdg_vertex_info *const rvi =
     (const struct rdg_vertex_info *) elt;
-  const_tree stmt = rvi->stmt;
+  gimple stmt = rvi->stmt;
 
   return htab_hash_pointer (stmt);
 }
@@ -4817,7 +4833,7 @@ build_rdg (struct loop *loop)
   struct graph *rdg = NULL;
   VEC (ddr_p, heap) *dependence_relations;
   VEC (data_reference_p, heap) *datarefs;
-  VEC (tree, heap) *stmts = VEC_alloc (tree, heap, nb_data_refs);
+  VEC (gimple, heap) *stmts = VEC_alloc (gimple, heap, nb_data_refs);
   
   dependence_relations = VEC_alloc (ddr_p, heap, nb_data_refs * nb_data_refs) ;
   datarefs = VEC_alloc (data_reference_p, heap, nb_data_refs);
@@ -4830,7 +4846,7 @@ build_rdg (struct loop *loop)
     goto end_rdg;
 
   stmts_from_loop (loop, &stmts);
-  rdg = new_graph (VEC_length (tree, stmts));
+  rdg = new_graph (VEC_length (gimple, stmts));
 
   rdg->indices = htab_create (nb_data_refs, hash_stmt_vertex_info,
 			      eq_stmt_vertex_info, hash_stmt_vertex_del);
@@ -4840,7 +4856,7 @@ build_rdg (struct loop *loop)
  end_rdg:
   free_dependence_relations (dependence_relations);
   free_data_refs (datarefs);
-  VEC_free (tree, heap, stmts);
+  VEC_free (gimple, heap, stmts);
 
   return rdg;
 }
@@ -4863,7 +4879,7 @@ free_rdg (struct graph *rdg)
    store to memory.  */
 
 void
-stores_from_loop (struct loop *loop, VEC (tree, heap) **stmts)
+stores_from_loop (struct loop *loop, VEC (gimple, heap) **stmts)
 {
   unsigned int i;
   basic_block *bbs = get_loop_body_in_dom_order (loop);
@@ -4871,11 +4887,11 @@ stores_from_loop (struct loop *loop, VEC (tree, heap) **stmts)
   for (i = 0; i < loop->num_nodes; i++)
     {
       basic_block bb = bbs[i];
-      block_stmt_iterator bsi;
+      gimple_stmt_iterator bsi;
 
-      for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
-	if (!ZERO_SSA_OPERANDS (bsi_stmt (bsi), SSA_OP_VDEF))
-	  VEC_safe_push (tree, heap, *stmts, bsi_stmt (bsi));
+      for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
+	if (!ZERO_SSA_OPERANDS (gsi_stmt (bsi), SSA_OP_VDEF))
+	  VEC_safe_push (gimple, heap, *stmts, gsi_stmt (bsi));
     }
 
   free (bbs);
@@ -4885,7 +4901,7 @@ stores_from_loop (struct loop *loop, VEC (tree, heap) **stmts)
    address or NULL_TREE if the base is not determined.  */
 
 static inline tree
-ref_base_address (tree stmt, data_ref_loc *ref)
+ref_base_address (gimple stmt, data_ref_loc *ref)
 {
   tree base = NULL_TREE;
   tree base_address;
@@ -4921,7 +4937,7 @@ ref_base_address (tree stmt, data_ref_loc *ref)
 bool
 rdg_defs_used_in_other_loops_p (struct graph *rdg, int v)
 {
-  tree stmt = RDG_STMT (rdg, v);
+  gimple stmt = RDG_STMT (rdg, v);
   struct loop *loop = loop_containing_stmt (stmt);
   use_operand_p imm_use_p;
   imm_use_iterator iterator;
@@ -4949,7 +4965,7 @@ rdg_defs_used_in_other_loops_p (struct graph *rdg, int v)
    ref_base_address is the same.  */
 
 bool
-have_similar_memory_accesses (tree s1, tree s2)
+have_similar_memory_accesses (gimple s1, gimple s2)
 {
   bool res = false;
   unsigned i, j;
@@ -4983,8 +4999,8 @@ have_similar_memory_accesses (tree s1, tree s2)
 static int
 have_similar_memory_accesses_1 (const void *s1, const void *s2)
 {
-  return have_similar_memory_accesses (CONST_CAST_TREE ((const_tree)s1),
-				       CONST_CAST_TREE ((const_tree)s2));
+  return have_similar_memory_accesses (CONST_CAST_GIMPLE ((const_gimple) s1),
+				       CONST_CAST_GIMPLE ((const_gimple) s2));
 }
 
 /* Helper function for the hashtab.  */
@@ -4992,7 +5008,7 @@ have_similar_memory_accesses_1 (const void *s1, const void *s2)
 static hashval_t
 ref_base_address_1 (const void *s)
 {
-  tree stmt = CONST_CAST_TREE((const_tree)s);
+  gimple stmt = CONST_CAST_GIMPLE ((const_gimple) s);
   unsigned i;
   VEC (data_ref_loc, heap) *refs;
   data_ref_loc *ref;
@@ -5014,21 +5030,21 @@ ref_base_address_1 (const void *s)
 /* Try to remove duplicated write data references from STMTS.  */
 
 void
-remove_similar_memory_refs (VEC (tree, heap) **stmts)
+remove_similar_memory_refs (VEC (gimple, heap) **stmts)
 {
   unsigned i;
-  tree stmt;
-  htab_t seen = htab_create (VEC_length (tree, *stmts), ref_base_address_1,
+  gimple stmt;
+  htab_t seen = htab_create (VEC_length (gimple, *stmts), ref_base_address_1,
 			     have_similar_memory_accesses_1, NULL);
 
-  for (i = 0; VEC_iterate (tree, *stmts, i, stmt); )
+  for (i = 0; VEC_iterate (gimple, *stmts, i, stmt); )
     {
       void **slot;
 
       slot = htab_find_slot (seen, stmt, INSERT);
 
       if (*slot)
-	VEC_ordered_remove (tree, *stmts, i);
+	VEC_ordered_remove (gimple, *stmts, i);
       else
 	{
 	  *slot = (void *) stmt;