diff --git a/gcc/ChangeLog.graphite b/gcc/ChangeLog.graphite
index 3774b46..7498956 100644
--- a/gcc/ChangeLog.graphite
+++ b/gcc/ChangeLog.graphite
@@ -1,5 +1,52 @@
 2010-07-15  Sebastian Pop  <sebastian.pop@amd.com>
 
+	* graphite-clast-to-gimple.c (debug_clast_name_index): Removed.
+	(debug_clast_name_indexes_1): Removed.
+	(debug_clast_name_indexes): Removed.
+	(pbb_to_depth_to_oldiv): Removed.
+	(build_iv_mapping): Replace the use of rename_map with iv_map.
+	(translate_clast_user): Remove uses of rename_map.  Allocate and
+	free iv_map.
+	(translate_clast_for_loop): Remove uses of rename_map.
+	(translate_clast_for): Same.
+	(translate_clast_guard): Same.
+	(translate_clast): Same.
+	(gloog): Same.
+	* graphite-clast-to-gimple.h (debug_clast_name_indexes): Removed.
+	* graphite-sese-to-poly.c (scev_analyzable_p): Moved...
+	* sese.c (set_rename): Now static.
+	(rename_variables_in_stmt): Removed.
+	(rename_uses): New.
+	(is_parameter): Removed.
+	(is_iv): Removed.
+	(expand_scalar_variables_call): Removed.
+	(expand_scalar_variables_ssa_name): Removed.
+	(expand_scalar_variables_expr): Removed.
+	(expand_scalar_variables_stmt): Removed.
+	(expand_scalar_variables): Removed.
+	(rename_variables): Removed.
+	(remove_condition): Removed.
+	(get_true_edge_from_guard_bb): Removed.
+	(get_false_edge_from_guard_bb): Removed.
+	(struct igp): Removed.
+	(default_before_guard): Removed.
+	(convert_for_phi_arg): Removed.
+	(add_guard_exit_phis): Removed.
+	(insert_guard_phis): Removed.
+	(graphite_copy_stmts_from_block): Now also uses iv_map and a
+	region.  Do not copy conditions.  Do not copy induction variables.
+	Call rename_uses.
+	(copy_bb_and_scalar_dependences): Allocate a local rename_map for
+	the translated statement.  Use the iv_map for the induction
+	variable renaming.
+	* sese.h (copy_bb_and_scalar_dependences): Update declaration.
+	(set_rename): Removed declaration.
+	(scev_analyzable_p): ...here.
+	* tree-chrec.c (chrec_apply_map): New.
+	* tree-chrec.h (chrec_apply_map): Declared.
+
+2010-07-15  Sebastian Pop  <sebastian.pop@amd.com>
+
 	* graphite-clast-to-gimple.c (translate_clast_for_loop): Do not call
 	insert_loop_close_phis.
 	* sese.c (name_defined_in_loop_p): Removed.
diff --git a/gcc/graphite-clast-to-gimple.c b/gcc/graphite-clast-to-gimple.c
index 042857f..4d30daf 100644
--- a/gcc/graphite-clast-to-gimple.c
+++ b/gcc/graphite-clast-to-gimple.c
@@ -130,32 +130,6 @@ save_clast_name_index (htab_t index_table, const char *name, int index)
     }
 }
 
-/* Print to stderr the element ELT.  */
-
-static inline void
-debug_clast_name_index (clast_name_index_p elt)
-{
-  fprintf (stderr, "(index = %d, name = %s)\n", elt->index, elt->name);
-}
-
-/* Helper function for debug_rename_map.  */
-
-static inline int
-debug_clast_name_indexes_1 (void **slot, void *s ATTRIBUTE_UNUSED)
-{
-  struct clast_name_index *entry = (struct clast_name_index *) *slot;
-  debug_clast_name_index (entry);
-  return 1;
-}
-
-/* Print to stderr all the elements of MAP.  */
-
-DEBUG_FUNCTION void
-debug_clast_name_indexes (htab_t map)
-{
-  htab_traverse (map, debug_clast_name_indexes_1, NULL);
-}
-
 /* Computes a hash function for database element ELT.  */
 
 static inline hashval_t
@@ -175,20 +149,6 @@ eq_clast_name_indexes (const void *e1, const void *e2)
   return (elt1->name == elt2->name);
 }
 
-
-/* For a given loop DEPTH in the loop nest of the original black box
-   PBB, return the old induction variable associated to that loop.  */
-
-static inline tree
-pbb_to_depth_to_oldiv (poly_bb_p pbb, int depth)
-{
-  gimple_bb_p gbb = PBB_BLACK_BOX (pbb);
-  sese region = SCOP_REGION (PBB_SCOP (pbb));
-  loop_p loop = gbb_loop_at_index (gbb, region, depth);
-
-  return loop->single_iv;
-}
-
 /* For a given scattering dimension, return the new induction variable
    associated to it.  */
 
@@ -820,34 +780,36 @@ graphite_create_new_loop (sese region, edge entry_edge,
   return loop;
 }
 
-/* Inserts in RENAME_MAP a tuple (OLD_NAME, NEW_NAME) for the induction
-   variables of the loops around GBB in SESE.  */
+/* Inserts in iv_map a tuple (OLD_LOOP->num, NEW_NAME) for the
+   induction variables of the loops around GBB in SESE.  */
 
 static void
-build_iv_mapping (htab_t rename_map, sese region,
+build_iv_mapping (VEC (tree, heap) *iv_map, sese region,
 		  VEC (tree, heap) *newivs, htab_t newivs_index,
 		  struct clast_user_stmt *user_stmt,
 		  htab_t params_index)
 {
   struct clast_stmt *t;
-  int index = 0;
+  int depth = 0;
   CloogStatement *cs = user_stmt->statement;
   poly_bb_p pbb = (poly_bb_p) cloog_statement_usr (cs);
+  gimple_bb_p gbb = PBB_BLACK_BOX (pbb);
 
-  for (t = user_stmt->substitutions; t; t = t->next, index++)
+  for (t = user_stmt->substitutions; t; t = t->next, depth++)
     {
       struct clast_expr *expr = (struct clast_expr *)
        ((struct clast_assignment *)t)->RHS;
       tree type = gcc_type_for_clast_expr (expr, region, newivs,
 					   newivs_index, params_index);
-      tree old_name = pbb_to_depth_to_oldiv (pbb, index);
-      tree e = clast_to_gcc_expression (type, expr, region, newivs,
-					newivs_index, params_index);
-      set_rename (rename_map, old_name, e);
+      tree new_name = clast_to_gcc_expression (type, expr, region, newivs,
+					       newivs_index, params_index);
+      loop_p old_loop = gbb_loop_at_index (gbb, region, depth);
+
+      VEC_replace (tree, iv_map, old_loop->num, new_name);
     }
 }
 
-/* Construct bb_pbb_def with BB and PBB. */
+/* Construct bb_pbb_def with BB and PBB.  */
 
 static bb_pbb_def *
 new_bb_pbb_def (basic_block bb, poly_bb_p pbb)
@@ -930,38 +892,39 @@ dependency_in_loop_p (loop_p loop, htab_t bb_pbb_mapping, int level)
   return false;
 }
 
-static edge
-translate_clast (sese, loop_p, struct clast_stmt *, edge, htab_t,
-		 VEC (tree, heap) **, htab_t, htab_t, int, htab_t);
-
 /* Translates a clast user statement STMT to gimple.
 
    - REGION is the sese region we used to generate the scop.
    - NEXT_E is the edge where new generated code should be attached.
    - CONTEXT_LOOP is the loop in which the generated code will be placed
-   - RENAME_MAP contains a set of tuples of new names associated to
-     the original variables names.
    - BB_PBB_MAPPING is is a basic_block and it's related poly_bb_p mapping.
    - PARAMS_INDEX connects the cloog parameters with the gimple parameters in
      the sese region.  */
 static edge
 translate_clast_user (sese region, struct clast_user_stmt *stmt, edge next_e,
-		      htab_t rename_map, VEC (tree, heap) **newivs,
+		      VEC (tree, heap) **newivs,
 		      htab_t newivs_index, htab_t bb_pbb_mapping,
 		      htab_t params_index)
 {
-  gimple_bb_p gbb;
+  int i, nb_loops;
   basic_block new_bb;
   poly_bb_p pbb = (poly_bb_p) cloog_statement_usr (stmt->statement);
-  gbb = PBB_BLACK_BOX (pbb);
+  gimple_bb_p gbb = PBB_BLACK_BOX (pbb);
+  VEC (tree, heap) *iv_map;
 
   if (GBB_BB (gbb) == ENTRY_BLOCK_PTR)
     return next_e;
 
-  build_iv_mapping (rename_map, region, *newivs, newivs_index, stmt,
-		    params_index);
+  nb_loops = number_of_loops ();
+  iv_map = VEC_alloc (tree, heap, nb_loops);
+  for (i = 0; i < nb_loops; i++)
+    VEC_quick_push (tree, iv_map, NULL_TREE);
+
+  build_iv_mapping (iv_map, region, *newivs, newivs_index, stmt, params_index);
   next_e = copy_bb_and_scalar_dependences (GBB_BB (gbb), region,
-					   next_e, rename_map);
+					   next_e, iv_map);
+  VEC_free (tree, heap, iv_map);
+
   new_bb = next_e->src;
   mark_bb_with_pbb (pbb, new_bb, bb_pbb_mapping);
   update_ssa (TODO_update_ssa);
@@ -1011,20 +974,21 @@ graphite_create_new_loop_guard (sese region, edge entry_edge,
   return exit_edge;
 }
 
+static edge
+translate_clast (sese, loop_p, struct clast_stmt *, edge,
+		 VEC (tree, heap) **, htab_t, htab_t, int, htab_t);
 
 /* Create the loop for a clast for statement.
 
    - REGION is the sese region we used to generate the scop.
    - NEXT_E is the edge where new generated code should be attached.
-   - RENAME_MAP contains a set of tuples of new names associated to
-     the original variables names.
    - BB_PBB_MAPPING is is a basic_block and it's related poly_bb_p mapping.
    - PARAMS_INDEX connects the cloog parameters with the gimple parameters in
      the sese region.  */
 static edge
 translate_clast_for_loop (sese region, loop_p context_loop,
 			  struct clast_for *stmt, edge next_e,
-			  htab_t rename_map, VEC (tree, heap) **newivs,
+			  VEC (tree, heap) **newivs,
 			  htab_t newivs_index, htab_t bb_pbb_mapping,
 			  int level, htab_t params_index)
 {
@@ -1040,7 +1004,7 @@ translate_clast_for_loop (sese region, loop_p context_loop,
   last_e = single_succ_edge (split_edge (last_e));
 
   /* Translate the body of the loop.  */
-  next_e = translate_clast (region, loop, stmt->body, to_body, rename_map,
+  next_e = translate_clast (region, loop, stmt->body, to_body,
 			    newivs, newivs_index, bb_pbb_mapping, level + 1,
 			    params_index);
   redirect_edge_succ_nodup (next_e, after);
@@ -1060,14 +1024,12 @@ translate_clast_for_loop (sese region, loop_p context_loop,
 
    - REGION is the sese region we used to generate the scop.
    - NEXT_E is the edge where new generated code should be attached.
-   - RENAME_MAP contains a set of tuples of new names associated to
-     the original variables names.
    - BB_PBB_MAPPING is is a basic_block and it's related poly_bb_p mapping.
    - PARAMS_INDEX connects the cloog parameters with the gimple parameters in
      the sese region.  */
 static edge
 translate_clast_for (sese region, loop_p context_loop, struct clast_for *stmt,
-		     edge next_e, htab_t rename_map, VEC (tree, heap) **newivs,
+		     edge next_e, VEC (tree, heap) **newivs,
 		     htab_t newivs_index, htab_t bb_pbb_mapping, int level,
 		     htab_t params_index)
 {
@@ -1075,8 +1037,7 @@ translate_clast_for (sese region, loop_p context_loop, struct clast_for *stmt,
 						newivs_index, params_index);
   edge true_e = get_true_edge_from_guard_bb (next_e->dest);
 
-  translate_clast_for_loop (region, context_loop, stmt, true_e,
-			    rename_map, newivs,
+  translate_clast_for_loop (region, context_loop, stmt, true_e, newivs,
 			    newivs_index, bb_pbb_mapping, level,
 			    params_index);
   return last_e;
@@ -1087,15 +1048,13 @@ translate_clast_for (sese region, loop_p context_loop, struct clast_for *stmt,
    - REGION is the sese region we used to generate the scop.
    - NEXT_E is the edge where new generated code should be attached.
    - CONTEXT_LOOP is the loop in which the generated code will be placed
-   - RENAME_MAP contains a set of tuples of new names associated to
-     the original variables names.
    - BB_PBB_MAPPING is is a basic_block and it's related poly_bb_p mapping.
    - PARAMS_INDEX connects the cloog parameters with the gimple parameters in
      the sese region.  */
 static edge
 translate_clast_guard (sese region, loop_p context_loop,
 		       struct clast_guard *stmt, edge next_e,
-		       htab_t rename_map, VEC (tree, heap) **newivs,
+		       VEC (tree, heap) **newivs,
 		       htab_t newivs_index, htab_t bb_pbb_mapping, int level,
 		       htab_t params_index)
 {
@@ -1104,7 +1063,7 @@ translate_clast_guard (sese region, loop_p context_loop,
   edge true_e = get_true_edge_from_guard_bb (next_e->dest);
 
   translate_clast (region, context_loop, stmt->then, true_e,
-		   rename_map, newivs, newivs_index, bb_pbb_mapping,
+		   newivs, newivs_index, bb_pbb_mapping,
 		   level, params_index);
   return last_e;
 }
@@ -1114,12 +1073,10 @@ translate_clast_guard (sese region, loop_p context_loop,
 
    - NEXT_E is the edge where new generated code should be attached.
    - CONTEXT_LOOP is the loop in which the generated code will be placed
-   - RENAME_MAP contains a set of tuples of new names associated to
-     the original variables names.
    - BB_PBB_MAPPING is is a basic_block and it's related poly_bb_p mapping.  */
 static edge
 translate_clast (sese region, loop_p context_loop, struct clast_stmt *stmt,
-		 edge next_e, htab_t rename_map, VEC (tree, heap) **newivs,
+		 edge next_e, VEC (tree, heap) **newivs,
 		 htab_t newivs_index, htab_t bb_pbb_mapping, int level,
 		 htab_t params_index)
 {
@@ -1131,25 +1088,25 @@ translate_clast (sese region, loop_p context_loop, struct clast_stmt *stmt,
 
   else if (CLAST_STMT_IS_A (stmt, stmt_user))
     next_e = translate_clast_user (region, (struct clast_user_stmt *) stmt,
-				   next_e, rename_map, newivs, newivs_index,
+				   next_e, newivs, newivs_index,
 				   bb_pbb_mapping, params_index);
 
   else if (CLAST_STMT_IS_A (stmt, stmt_for))
     next_e = translate_clast_for (region, context_loop,
 				  (struct clast_for *) stmt, next_e,
-				  rename_map, newivs, newivs_index,
+				  newivs, newivs_index,
 				  bb_pbb_mapping, level, params_index);
 
   else if (CLAST_STMT_IS_A (stmt, stmt_guard))
     next_e = translate_clast_guard (region, context_loop,
 				    (struct clast_guard *) stmt, next_e,
-				    rename_map, newivs, newivs_index,
+				    newivs, newivs_index,
 				    bb_pbb_mapping, level, params_index);
 
   else if (CLAST_STMT_IS_A (stmt, stmt_block))
     next_e = translate_clast (region, context_loop,
 			      ((struct clast_block *) stmt)->body,
-			      next_e, rename_map, newivs, newivs_index,
+			      next_e, newivs, newivs_index,
 			      bb_pbb_mapping, level, params_index);
   else
     gcc_unreachable();
@@ -1158,7 +1115,7 @@ translate_clast (sese region, loop_p context_loop, struct clast_stmt *stmt,
   graphite_verify ();
 
   return translate_clast (region, context_loop, stmt->next, next_e,
-			  rename_map, newivs, newivs_index,
+			  newivs, newivs_index,
 			  bb_pbb_mapping, level, params_index);
 }
 
@@ -1485,7 +1442,7 @@ gloog (scop_p scop, htab_t bb_pbb_mapping)
   loop_p context_loop;
   sese region = SCOP_REGION (scop);
   ifsese if_region = NULL;
-  htab_t rename_map, newivs_index, params_index;
+  htab_t newivs_index, params_index;
   cloog_prog_clast pc;
 
   timevar_push (TV_GRAPHITE_CODE_GEN);
@@ -1512,7 +1469,6 @@ gloog (scop_p scop, htab_t bb_pbb_mapping)
   graphite_verify ();
 
   context_loop = SESE_ENTRY (region)->src->loop_father;
-  rename_map = htab_create (10, rename_map_elt_info, eq_rename_map_elts, free);
   newivs_index = htab_create (10, clast_name_index_elt_info,
 			      eq_clast_name_indexes, free);
   params_index = htab_create (10, clast_name_index_elt_info,
@@ -1522,7 +1478,7 @@ gloog (scop_p scop, htab_t bb_pbb_mapping)
 
   translate_clast (region, context_loop, pc.stmt,
 		   if_region->true_region->entry,
-		   rename_map, &newivs, newivs_index,
+		   &newivs, newivs_index,
 		   bb_pbb_mapping, 1, params_index);
   graphite_verify ();
   scev_reset_htab ();
@@ -1536,7 +1492,6 @@ gloog (scop_p scop, htab_t bb_pbb_mapping)
   free (if_region->region);
   free (if_region);
 
-  htab_delete (rename_map);
   htab_delete (newivs_index);
   htab_delete (params_index);
   VEC_free (tree, heap, newivs);
diff --git a/gcc/graphite-clast-to-gimple.h b/gcc/graphite-clast-to-gimple.h
index c90cfc0..fbb4efa 100644
--- a/gcc/graphite-clast-to-gimple.h
+++ b/gcc/graphite-clast-to-gimple.h
@@ -40,7 +40,6 @@ extern bool gloog (scop_p, htab_t);
 extern cloog_prog_clast scop_to_clast (scop_p);
 extern void debug_clast_stmt (struct clast_stmt *);
 extern void print_clast_stmt (FILE *, struct clast_stmt *);
-extern void debug_clast_name_indexes (htab_t);
 
 /* Hash function for data base element BB_PBB.  */
 
diff --git a/gcc/graphite-sese-to-poly.c b/gcc/graphite-sese-to-poly.c
index c186dd1..6e09532 100644
--- a/gcc/graphite-sese-to-poly.c
+++ b/gcc/graphite-sese-to-poly.c
@@ -2332,20 +2332,6 @@ rewrite_reductions_out_of_ssa (scop_p scop)
 #endif
 }
 
-/* Return true when DEF can be analyzed in REGION by the scalar
-   evolution analyzer.  */
-
-static bool
-scev_analyzable_p (tree def, sese region)
-{
-  gimple stmt = SSA_NAME_DEF_STMT (def);
-  loop_p loop = loop_containing_stmt (stmt);
-  tree scev = scalar_evolution_in_region (region, loop, def);
-
-  return !chrec_contains_undetermined (scev)
-    && TREE_CODE (scev) != SSA_NAME;
-}
-
 /* Rewrite the scalar dependence of DEF used in USE_STMT with a memory
    read from ZERO_DIM_ARRAY.  */
 
diff --git a/gcc/sese.c b/gcc/sese.c
index e0c06da..913ac4d 100644
--- a/gcc/sese.c
+++ b/gcc/sese.c
@@ -394,6 +394,38 @@ sese_insert_phis_for_liveouts (sese region, basic_block bb,
   update_ssa (TODO_update_ssa);
 }
 
+/* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag set.  */
+
+edge
+get_true_edge_from_guard_bb (basic_block bb)
+{
+  edge e;
+  edge_iterator ei;
+
+  FOR_EACH_EDGE (e, ei, bb->succs)
+    if (e->flags & EDGE_TRUE_VALUE)
+      return e;
+
+  gcc_unreachable ();
+  return NULL;
+}
+
+/* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag cleared.  */
+
+edge
+get_false_edge_from_guard_bb (basic_block bb)
+{
+  edge e;
+  edge_iterator ei;
+
+  FOR_EACH_EDGE (e, ei, bb->succs)
+    if (!(e->flags & EDGE_TRUE_VALUE))
+      return e;
+
+  gcc_unreachable ();
+  return NULL;
+}
+
 /* Returns the expression associated to OLD_NAME in RENAME_MAP.  */
 
 static tree
@@ -409,12 +441,12 @@ get_rename (htab_t rename_map, tree old_name)
   if (slot && *slot)
     return ((rename_map_elt) *slot)->expr;
 
-  return old_name;
+  return NULL_TREE;
 }
 
 /* Register in RENAME_MAP the rename tuple (OLD_NAME, EXPR).  */
 
-void
+static void
 set_rename (htab_t rename_map, tree old_name, tree expr)
 {
   struct rename_map_elt_s tmp;
@@ -435,579 +467,101 @@ set_rename (htab_t rename_map, tree old_name, tree expr)
   *slot = new_rename_map_elt (old_name, expr);
 }
 
-/* Rename the SSA_NAMEs used in STMT and that appear in RENAME_MAP.  */
+/* Renames the scalar uses of the statement COPY, using the
+   substitution map RENAME_MAP, inserting the gimplification code at
+   GSI_TGT, for the translation REGION, with the original copied
+   statement in LOOP, and using the induction variable renaming map
+   IV_MAP.  */
 
 static void
-rename_variables_in_stmt (gimple stmt, htab_t rename_map, gimple_stmt_iterator *insert_gsi)
+rename_uses (gimple copy, htab_t rename_map, gimple_stmt_iterator *gsi_tgt,
+	     sese region, loop_p loop, VEC (tree, heap) *iv_map)
 {
-  ssa_op_iter iter;
   use_operand_p use_p;
+  ssa_op_iter op_iter;
 
-  FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES)
+  FOR_EACH_SSA_USE_OPERAND (use_p, copy, op_iter, SSA_OP_ALL_USES)
     {
-      tree use = USE_FROM_PTR (use_p);
-      tree expr, type_use, type_expr;
+      tree old_name = USE_FROM_PTR (use_p);
+      tree new_expr, scev;
       gimple_seq stmts;
 
-      if (TREE_CODE (use) != SSA_NAME)
-	continue;
-
-      expr = get_rename (rename_map, use);
-      if (use == expr)
+      if (TREE_CODE (old_name) != SSA_NAME
+	  || !is_gimple_reg (old_name)
+	  || SSA_NAME_IS_DEFAULT_DEF (old_name))
 	continue;
 
-      type_use = TREE_TYPE (use);
-      type_expr = TREE_TYPE (expr);
-
-      if (type_use != type_expr
-	  || (TREE_CODE (expr) != SSA_NAME
-	      && is_gimple_reg (use)))
+      new_expr = get_rename (rename_map, old_name);
+      if (new_expr)
 	{
-	  tree var;
+	  tree type_old_name = TREE_TYPE (old_name);
+	  tree type_new_expr = TREE_TYPE (new_expr);
 
-	  if (is_gimple_debug (stmt))
+	  if (type_old_name != type_new_expr
+	      || (TREE_CODE (new_expr) != SSA_NAME
+		  && is_gimple_reg (old_name)))
 	    {
-	      if (gimple_debug_bind_p (stmt))
-		gimple_debug_bind_reset_value (stmt);
-	      else
-		gcc_unreachable ();
-
-	      break;
-	    }
-
-	  var = create_tmp_var (type_use, "var");
-
-	  if (type_use != type_expr)
-	    expr = fold_convert (type_use, expr);
-
-	  expr = build2 (MODIFY_EXPR, type_use, var, expr);
-	  expr = force_gimple_operand (expr, &stmts, true, NULL);
-	  gsi_insert_seq_before (insert_gsi, stmts, GSI_SAME_STMT);
-	}
-
-      replace_exp (use_p, expr);
-    }
-
-  update_stmt (stmt);
-}
-
-/* Returns true if NAME is a parameter of SESE.  */
-
-static bool
-is_parameter (sese region, tree name)
-{
-  int i;
-  tree p;
-
-  for (i = 0; VEC_iterate (tree, SESE_PARAMS (region), i, p); i++)
-    if (p == name)
-      return true;
-
-  return false;
-}
-
-/* Returns true if NAME is an induction variable.  */
-
-static bool
-is_iv (tree name)
-{
-  return gimple_code (SSA_NAME_DEF_STMT (name)) == GIMPLE_PHI;
-}
-
-static void expand_scalar_variables_stmt (gimple, basic_block, sese,
-					  htab_t, gimple_stmt_iterator *);
-static tree
-expand_scalar_variables_expr (tree, tree, enum tree_code, tree, basic_block,
-			      sese, htab_t, gimple_stmt_iterator *);
-
-static tree
-expand_scalar_variables_call (gimple stmt, basic_block bb, sese region,
-			      htab_t rename_map, gimple_stmt_iterator *gsi)
-{
-  int i, nargs = gimple_call_num_args (stmt);
-  VEC (tree, gc) *args = VEC_alloc (tree, gc, nargs);
-  tree fn_type = TREE_TYPE (gimple_call_fn (stmt));
-  tree fn = gimple_call_fndecl (stmt);
-  tree call_expr, var, lhs;
-  gimple call;
-
-  for (i = 0; i < nargs; i++)
-    {
-      tree arg = gimple_call_arg (stmt, i);
-      tree t = TREE_TYPE (arg);
-
-      var = create_tmp_var (t, "var");
-      arg = expand_scalar_variables_expr (t, arg, TREE_CODE (arg), NULL,
-					  bb, region, rename_map, gsi);
-      arg = build2 (MODIFY_EXPR, t, var, arg);
-      arg = force_gimple_operand_gsi (gsi, arg, true, NULL,
-				      true, GSI_SAME_STMT);
-      VEC_quick_push (tree, args, arg);
-    }
-
-  lhs = gimple_call_lhs (stmt);
-  var = create_tmp_var (TREE_TYPE (lhs), "var");
-  call_expr = build_call_vec (fn_type, fn, args);
-  call = gimple_build_call_from_tree (call_expr);
-  var = make_ssa_name (var, call);
-  gimple_call_set_lhs (call, var);
-  gsi_insert_before (gsi, call, GSI_SAME_STMT);
-
-  return var;
-}
-
-/* Copies at GSI all the scalar computations on which the ssa_name OP0
-   depends on in the SESE: these are all the scalar variables used in
-   the definition of OP0, that are defined outside BB and still in the
-   SESE, i.e. not a parameter of the SESE.  The expression that is
-   returned contains only induction variables from the generated code:
-   RENAME_MAP contains the induction variables renaming mapping, and is used
-   to translate the names of induction variables.  */
-
-static tree
-expand_scalar_variables_ssa_name (tree type, tree op0, basic_block bb,
-				  sese region, htab_t rename_map,
-				  gimple_stmt_iterator *gsi)
-{
-  gimple def_stmt;
-  tree new_op;
-
-  if (is_parameter (region, op0)
-      || is_iv (op0))
-    return fold_convert (type, get_rename (rename_map, op0));
-
-  def_stmt = SSA_NAME_DEF_STMT (op0);
-
-  /* Check whether we already have a rename for OP0.  */
-  new_op = get_rename (rename_map, op0);
-
-  if (new_op != op0
-      && gimple_bb (SSA_NAME_DEF_STMT (new_op)) == bb)
-    return fold_convert (type, new_op);
-
-  if (gimple_bb (def_stmt) == bb)
-    {
-      /* If the defining statement is in the basic block already
-	 we do not need to create a new expression for it, we
-	 only need to ensure its operands are expanded.  */
-      expand_scalar_variables_stmt (def_stmt, bb, region, rename_map, gsi);
-      return fold_convert (type, new_op);
-    }
-  else
-    {
-      if (!gimple_bb (def_stmt)
-	  || !bb_in_sese_p (gimple_bb (def_stmt), region))
-	return fold_convert (type, new_op);
-
-      switch (gimple_code (def_stmt))
-	{
-	case GIMPLE_ASSIGN:
-	  {
-	    tree var0 = gimple_assign_rhs1 (def_stmt);
-	    enum tree_code subcode = gimple_assign_rhs_code (def_stmt);
-	    tree var1 = gimple_assign_rhs2 (def_stmt);
-	    tree type = gimple_expr_type (def_stmt);
-
-	    return expand_scalar_variables_expr (type, var0, subcode, var1, bb,
-						 region, rename_map, gsi);
-	  }
-
-	case GIMPLE_CALL:
-	  return expand_scalar_variables_call (def_stmt, bb, region, rename_map, gsi);
-
-	default:
-	  gcc_unreachable ();
-	  return new_op;
-	}
-    }
-}
-
-/* Copies at GSI all the scalar computations on which the expression
-   OP0 CODE OP1 depends on in the SESE: these are all the scalar
-   variables used in OP0 and OP1, defined outside BB and still defined
-   in the SESE, i.e. not a parameter of the SESE.  The expression that
-   is returned contains only induction variables from the generated
-   code: RENAME_MAP contains the induction variables renaming mapping, and is
-   used to translate the names of induction variables.  */
-
-static tree
-expand_scalar_variables_expr (tree type, tree op0, enum tree_code code,
-			      tree op1, basic_block bb, sese region,
-			      htab_t rename_map, gimple_stmt_iterator *gsi)
-{
-  if (TREE_CODE_CLASS (code) == tcc_constant
-      || TREE_CODE_CLASS (code) == tcc_declaration)
-    return op0;
-
-  /* For data references we have to duplicate also its memory
-     indexing.  */
-  if (TREE_CODE_CLASS (code) == tcc_reference)
-    {
-      switch (code)
-	{
-	case REALPART_EXPR:
-	case IMAGPART_EXPR:
-	  {
-	    tree op = TREE_OPERAND (op0, 0);
-	    tree res = expand_scalar_variables_expr
-	      (type, op, TREE_CODE (op), NULL, bb, region, rename_map, gsi);
-	    return build1 (code, type, res);
-	  }
-
-	case INDIRECT_REF:
-	  {
-	    tree old_name = TREE_OPERAND (op0, 0);
-	    tree expr = expand_scalar_variables_ssa_name
-	      (type, old_name, bb, region, rename_map, gsi);
-
-	    if (TREE_CODE (expr) != SSA_NAME
-		&& is_gimple_reg (old_name))
-	      {
-		tree type = TREE_TYPE (old_name);
-		tree var = create_tmp_var (type, "var");
-
-		expr = build2 (MODIFY_EXPR, type, var, expr);
-		expr = force_gimple_operand_gsi (gsi, expr, true, NULL,
-						 true, GSI_SAME_STMT);
-	      }
-
-	    return fold_build1 (code, type, expr);
-	  }
-
-	case ARRAY_REF:
-	  {
-	    tree op00 = TREE_OPERAND (op0, 0);
-	    tree op01 = TREE_OPERAND (op0, 1);
-	    tree op02 = TREE_OPERAND (op0, 2);
-	    tree op03 = TREE_OPERAND (op0, 3);
-	    tree base = expand_scalar_variables_expr
-	      (TREE_TYPE (op00), op00, TREE_CODE (op00), NULL, bb, region,
-	       rename_map, gsi);
-	    tree subscript = expand_scalar_variables_expr
-	      (TREE_TYPE (op01), op01, TREE_CODE (op01), NULL, bb, region,
-	       rename_map, gsi);
-
-	    return build4 (ARRAY_REF, type, base, subscript, op02, op03);
-	  }
-
-	case COMPONENT_REF:
-	  return op0;
-
-	default:
-	  /* The above cases should catch everything.  */
-	  gcc_unreachable ();
-	}
-    }
-
-  if (TREE_CODE_CLASS (code) == tcc_unary)
-    {
-      tree op0_type = TREE_TYPE (op0);
-      enum tree_code op0_code = TREE_CODE (op0);
-      tree op0_expr = expand_scalar_variables_expr (op0_type, op0, op0_code,
-						    NULL, bb, region, rename_map, gsi);
-
-      return fold_build1 (code, type, op0_expr);
-    }
-
-  if (TREE_CODE_CLASS (code) == tcc_binary
-      || TREE_CODE_CLASS (code) == tcc_comparison)
-    {
-      tree op0_type = TREE_TYPE (op0);
-      enum tree_code op0_code = TREE_CODE (op0);
-      tree op0_expr = expand_scalar_variables_expr (op0_type, op0, op0_code,
-						    NULL, bb, region, rename_map, gsi);
-      tree op1_type = TREE_TYPE (op1);
-      enum tree_code op1_code = TREE_CODE (op1);
-      tree op1_expr = expand_scalar_variables_expr (op1_type, op1, op1_code,
-						    NULL, bb, region, rename_map, gsi);
-
-      return fold_build2 (code, type, op0_expr, op1_expr);
-    }
-
-  if (code == SSA_NAME)
-    return expand_scalar_variables_ssa_name (type, op0, bb, region, rename_map, gsi);
-
-  if (code == ADDR_EXPR)
-    {
-      tree op00 = TREE_OPERAND (op0, 0);
-
-      if (handled_component_p (op00)
-	  && TREE_CODE (op00) == ARRAY_REF)
-	{
-	  tree e = expand_scalar_variables_expr (TREE_TYPE (op00), op00,
-						 TREE_CODE (op00),
-						 NULL, bb, region, rename_map, gsi);
-	  return fold_build1 (code, TREE_TYPE (op0), e);
-	}
-
-      return op0;
-    }
-
-  gcc_unreachable ();
-  return NULL;
-}
-
-/* Copies at the beginning of BB all the scalar computations on which
-   STMT depends on in the SESE: these are all the scalar variables used
-   in STMT, defined outside BB and still defined in the SESE, i.e. not a
-   parameter of the SESE.  The expression that is returned contains
-   only induction variables from the generated code: RENAME_MAP contains the
-   induction variables renaming mapping, and is used to translate the
-   names of induction variables.  */
-
-static void
-expand_scalar_variables_stmt (gimple stmt, basic_block bb, sese region,
-			      htab_t rename_map, gimple_stmt_iterator *gsi)
-{
-  ssa_op_iter iter;
-  use_operand_p use_p;
-
-  FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES)
-    {
-      tree use = USE_FROM_PTR (use_p);
-      tree type = TREE_TYPE (use);
-      enum tree_code code = TREE_CODE (use);
-      tree use_expr;
-
-      if (!is_gimple_reg (use))
-	continue;
-
-      /* Don't expand USE if we already have a rename for it.  */
-      use_expr = get_rename (rename_map, use);
-      if (use_expr != use)
-	continue;
+	      tree var;
 
-      use_expr = expand_scalar_variables_expr (type, use, code, NULL, bb,
-					       region, rename_map, gsi);
-      use_expr = fold_convert (type, use_expr);
+	      if (is_gimple_debug (copy))
+		{
+		  if (gimple_debug_bind_p (copy))
+		    gimple_debug_bind_reset_value (copy);
+		  else
+		    gcc_unreachable ();
 
-      if (use_expr == use)
-	continue;
+		  break;
+		}
 
-      if (is_gimple_debug (stmt))
-	{
-	  if (gimple_debug_bind_p (stmt))
-	    gimple_debug_bind_reset_value (stmt);
-	  else
-	    gcc_unreachable ();
+	      var = create_tmp_var (type_old_name, "var");
 
-	  break;
-	}
+	      if (type_old_name != type_new_expr)
+		new_expr = fold_convert (type_old_name, new_expr);
 
-      if (TREE_CODE (use_expr) != SSA_NAME)
-	{
-	  tree var = create_tmp_var (type, "var");
+	      new_expr = build2 (MODIFY_EXPR, type_old_name, var, new_expr);
+	      new_expr = force_gimple_operand (new_expr, &stmts, true, NULL);
+	      gsi_insert_seq_before (gsi_tgt, stmts, GSI_SAME_STMT);
+	    }
 
-	  use_expr = build2 (MODIFY_EXPR, type, var, use_expr);
-	  use_expr = force_gimple_operand_gsi (gsi, use_expr, true, NULL,
-					       true, GSI_SAME_STMT);
+	  replace_exp (use_p, new_expr);
+	  continue;
 	}
 
-      replace_exp (use_p, use_expr);
-    }
-
-  update_stmt (stmt);
-}
-
-/* Copies at the beginning of BB all the scalar computations on which
-   BB depends on in the SESE: these are all the scalar variables used
-   in BB, defined outside BB and still defined in the SESE, i.e. not a
-   parameter of the SESE.  The expression that is returned contains
-   only induction variables from the generated code: RENAME_MAP contains the
-   induction variables renaming mapping, and is used to translate the
-   names of induction variables.  */
-
-static void
-expand_scalar_variables (basic_block bb, sese region, htab_t rename_map)
-{
-  gimple_stmt_iterator gsi;
-
-  for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi);)
-    {
-      gimple stmt = gsi_stmt (gsi);
-      expand_scalar_variables_stmt (stmt, bb, region, rename_map, &gsi);
-      gsi_next (&gsi);
-    }
-}
-
-/* Rename all the SSA_NAMEs from block BB according to the RENAME_MAP.  */
-
-static void
-rename_variables (basic_block bb, htab_t rename_map)
-{
-  gimple_stmt_iterator gsi;
-  gimple_stmt_iterator insert_gsi = gsi_start_bb (bb);
-
-  for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi))
-    rename_variables_in_stmt (gsi_stmt (gsi), rename_map, &insert_gsi);
-}
-
-/* Remove condition from BB.  */
-
-static void
-remove_condition (basic_block bb)
-{
-  gimple last = last_stmt (bb);
-
-  if (last && gimple_code (last) == GIMPLE_COND)
-    {
-      gimple_stmt_iterator gsi = gsi_last_bb (bb);
-      gsi_remove (&gsi, true);
-    }
-}
-
-/* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag set.  */
-
-edge
-get_true_edge_from_guard_bb (basic_block bb)
-{
-  edge e;
-  edge_iterator ei;
-
-  FOR_EACH_EDGE (e, ei, bb->succs)
-    if (e->flags & EDGE_TRUE_VALUE)
-      return e;
-
-  gcc_unreachable ();
-  return NULL;
-}
-
-/* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag cleared.  */
-
-edge
-get_false_edge_from_guard_bb (basic_block bb)
-{
-  edge e;
-  edge_iterator ei;
-
-  FOR_EACH_EDGE (e, ei, bb->succs)
-    if (!(e->flags & EDGE_TRUE_VALUE))
-      return e;
-
-  gcc_unreachable ();
-  return NULL;
-}
-
-/* Helper structure for htab_traverse in insert_guard_phis.  */
+      scev = scalar_evolution_in_region (region, loop, old_name);
 
-struct igp {
-  basic_block bb;
-  edge true_edge, false_edge;
-  htab_t before_guard;
-};
+      /* At this point we should know the exact scev for each
+	 scalar SSA_NAME used in the scop: all the other scalar
+	 SSA_NAMEs should have been translated out of SSA using
+	 arrays with one element.  */
+      gcc_assert (!chrec_contains_undetermined (scev));
 
-/* Return the default name that is before the guard.  */
+      new_expr = chrec_apply_map (scev, iv_map);
 
-static tree
-default_before_guard (htab_t before_guard, tree old_name)
-{
-  tree res = get_rename (before_guard, old_name);
+      /* The apply should produce an expression tree containing
+	 the uses of the new induction variables.  We should be
+	 able to use new_expr instead of the old_name in the newly
+	 generated loop nest.  */
+      gcc_assert (!chrec_contains_undetermined (new_expr)
+		  && !tree_contains_chrecs (new_expr, NULL));
 
-  if (res == old_name)
-    {
-      if (is_gimple_reg (res))
-	return fold_convert (TREE_TYPE (res), integer_zero_node);
-      return gimple_default_def (cfun, SSA_NAME_VAR (res));
+      /* Replace the old_name with the new_expr.  */
+      new_expr = force_gimple_operand (new_expr, &stmts, true, NULL);
+      gsi_insert_seq_before (gsi_tgt, stmts, GSI_SAME_STMT);
+      replace_exp (use_p, new_expr);
+      set_rename (rename_map, old_name, new_expr);
     }
-
-  return res;
 }
 
-/* Prepares EXPR to be a good phi argument when the phi result is
-   RES.  Insert needed statements on edge E.  */
-
-static tree
-convert_for_phi_arg (tree expr, tree res, edge e)
-{
-  tree type = TREE_TYPE (res);
-
-  if (TREE_TYPE (expr) != type)
-    expr = fold_convert (type, expr);
-
-  if (TREE_CODE (expr) != SSA_NAME
-      && !is_gimple_min_invariant (expr))
-    {
-      tree var = create_tmp_var (type, "var");
-      gimple_seq stmts;
-
-      expr = build2 (MODIFY_EXPR, type, var, expr);
-      expr = force_gimple_operand (expr, &stmts, true, NULL);
-      gsi_insert_seq_on_edge_immediate (e, stmts);
-    }
-
-  return expr;
-}
-
-/* Helper function for htab_traverse in insert_guard_phis.  */
-
-static int
-add_guard_exit_phis (void **slot, void *s)
-{
-  struct rename_map_elt_s *entry = (struct rename_map_elt_s *) *slot;
-  struct igp *i = (struct igp *) s;
-  basic_block bb = i->bb;
-  edge true_edge = i->true_edge;
-  edge false_edge = i->false_edge;
-  tree res = entry->old_name;
-  tree name1 = entry->expr;
-  tree name2 = default_before_guard (i->before_guard, res);
-  gimple phi;
-
-  /* Nothing to be merged if the name before the guard is the same as
-     the one after.  */
-  if (name1 == name2)
-    return 1;
-
-  name1 = convert_for_phi_arg (name1, res, true_edge);
-  name2 = convert_for_phi_arg (name2, res, false_edge);
-
-  phi = create_phi_node (res, bb);
-  res = create_new_def_for (gimple_phi_result (phi), phi,
-			    gimple_phi_result_ptr (phi));
-
-  add_phi_arg (phi, name1, true_edge, UNKNOWN_LOCATION);
-  add_phi_arg (phi, name2, false_edge, UNKNOWN_LOCATION);
-
-  entry->expr = res;
-  *slot = entry;
-  return 1;
-}
-
-/* Iterate over RENAME_MAP and get tuples of the form (OLD, NAME1).
-   If there is a correspondent tuple (OLD, NAME2) in BEFORE_GUARD,
-   with NAME1 different than NAME2, then insert in BB the phi node:
-
-   | RES = phi (NAME1 (on TRUE_EDGE), NAME2 (on FALSE_EDGE))"
-
-   if there is no tuple for OLD in BEFORE_GUARD, insert
-
-   | RES = phi (NAME1 (on TRUE_EDGE),
-   |            DEFAULT_DEFINITION of NAME1 (on FALSE_EDGE))".
-
-   Finally register in RENAME_MAP the tuple (OLD, RES).  */
-
-void
-insert_guard_phis (basic_block bb, edge true_edge, edge false_edge,
-		   htab_t before_guard, htab_t rename_map)
-{
-  struct igp i;
-  i.bb = bb;
-  i.true_edge = true_edge;
-  i.false_edge = false_edge;
-  i.before_guard = before_guard;
-
-  update_ssa (TODO_update_ssa);
-  htab_traverse (rename_map, add_guard_exit_phis, &i);
-  update_ssa (TODO_update_ssa);
-}
-
-/* Create a duplicate of the basic block BB.  NOTE: This does not
-   preserve SSA form.  */
+/* Duplicates the statements of basic block BB into basic block NEW_BB
+   and compute the new induction variables according to the IV_MAP.  */
 
 static void
-graphite_copy_stmts_from_block (basic_block bb, basic_block new_bb, htab_t rename_map)
+graphite_copy_stmts_from_block (basic_block bb, basic_block new_bb,
+				htab_t rename_map,
+				VEC (tree, heap) *iv_map, sese region)
 {
   gimple_stmt_iterator gsi, gsi_tgt;
+  loop_p loop = bb->loop_father;
 
   gsi_tgt = gsi_start_bb (new_bb);
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
@@ -1016,8 +570,19 @@ graphite_copy_stmts_from_block (basic_block bb, basic_block new_bb, htab_t renam
       ssa_op_iter op_iter;
       gimple stmt = gsi_stmt (gsi);
       gimple copy;
+      tree lhs;
+
+      /* Do not copy labels or conditions.  */
+      if (gimple_code (stmt) == GIMPLE_LABEL
+	  || gimple_code (stmt) == GIMPLE_COND)
+	continue;
 
-      if (gimple_code (stmt) == GIMPLE_LABEL)
+      /* Do not copy induction variables.  */
+      if (is_gimple_assign (stmt)
+	  && (lhs = gimple_assign_lhs (stmt))
+	  && TREE_CODE (lhs) == SSA_NAME
+	  && is_gimple_reg (lhs)
+	  && scev_analyzable_p (lhs, region))
 	continue;
 
       /* Create a new copy of STMT and duplicate STMT's virtual
@@ -1032,11 +597,15 @@ graphite_copy_stmts_from_block (basic_block bb, basic_block new_bb, htab_t renam
       /* Create new names for all the definitions created by COPY and
 	 add replacement mappings for each new name.  */
       FOR_EACH_SSA_DEF_OPERAND (def_p, copy, op_iter, SSA_OP_ALL_DEFS)
-	{
-	  tree old_name = DEF_FROM_PTR (def_p);
-	  tree new_name = create_new_def_for (old_name, copy, def_p);
+ 	{
+ 	  tree old_name = DEF_FROM_PTR (def_p);
+ 	  tree new_name = create_new_def_for (old_name, copy, def_p);
 	  set_rename (rename_map, old_name, new_name);
-	}
+ 	}
+
+      rename_uses (copy, rename_map, &gsi_tgt, region, loop, iv_map);
+
+      update_stmt (copy);
     }
 }
 
@@ -1046,16 +615,16 @@ graphite_copy_stmts_from_block (basic_block bb, basic_block new_bb, htab_t renam
 
 edge
 copy_bb_and_scalar_dependences (basic_block bb, sese region,
-				edge next_e, htab_t rename_map)
+				edge next_e, VEC (tree, heap) *iv_map)
 {
   basic_block new_bb = split_edge (next_e);
+  htab_t rename_map = htab_create (10, rename_map_elt_info,
+				   eq_rename_map_elts, free);
 
   next_e = single_succ_edge (new_bb);
-  graphite_copy_stmts_from_block (bb, new_bb, rename_map);
-  remove_condition (new_bb);
+  graphite_copy_stmts_from_block (bb, new_bb, rename_map, iv_map, region);
   remove_phi_nodes (new_bb);
-  expand_scalar_variables (new_bb, region, rename_map);
-  rename_variables (new_bb, rename_map);
+  htab_delete (rename_map);
 
   return next_e;
 }
diff --git a/gcc/sese.h b/gcc/sese.h
index d0d829f..1502cbe 100644
--- a/gcc/sese.h
+++ b/gcc/sese.h
@@ -56,7 +56,8 @@ extern sese new_sese (edge, edge);
 extern void free_sese (sese);
 extern void sese_insert_phis_for_liveouts (sese, basic_block, edge, edge);
 extern void build_sese_loop_nests (sese);
-extern edge copy_bb_and_scalar_dependences (basic_block, sese, edge, htab_t);
+extern edge copy_bb_and_scalar_dependences (basic_block, sese, edge,
+					    VEC (tree, heap) *);
 extern struct loop *outermost_loop_in_sese (sese, basic_block);
 extern void insert_loop_close_phis (htab_t, loop_p);
 extern void insert_guard_phis (basic_block, edge, edge, htab_t, htab_t);
@@ -261,7 +262,6 @@ DEF_VEC_ALLOC_P (rename_map_elt, heap);
 extern void debug_rename_map (htab_t);
 extern hashval_t rename_map_elt_info (const void *);
 extern int eq_rename_map_elts (const void *, const void *);
-extern void set_rename (htab_t, tree, tree);
 
 /* Constructs a new SCEV_INFO_STR structure for VAR and INSTANTIATED_BELOW.  */
 
@@ -386,4 +386,19 @@ nb_common_loops (sese region, gimple_bb_p gbb1, gimple_bb_p gbb2)
   return sese_loop_depth (region, common);
 }
 
+/* Return true when DEF can be analyzed in REGION by the scalar
+   evolution analyzer.  */
+
+static inline bool
+scev_analyzable_p (tree def, sese region)
+{
+  gimple stmt = SSA_NAME_DEF_STMT (def);
+  loop_p loop = loop_containing_stmt (stmt);
+  tree scev = scalar_evolution_in_region (region, loop, def);
+
+  return !chrec_contains_undetermined (scev)
+    && TREE_CODE (scev) != SSA_NAME
+    && evolution_function_is_affine_p (scev);
+}
+
 #endif
diff --git a/gcc/tree-chrec.c b/gcc/tree-chrec.c
index 2d15285..c92b6b9 100644
--- a/gcc/tree-chrec.c
+++ b/gcc/tree-chrec.c
@@ -632,6 +632,23 @@ chrec_apply (unsigned var,
   return res;
 }
 
+/* For a given CHREC and an induction variable map IV_MAP that maps
+   (loop->num, expr) for every loop number of the current_loops an
+   expression, calls chrec_apply when the expression is not NULL.  */
+
+tree
+chrec_apply_map (tree chrec, VEC (tree, heap) *iv_map)
+{
+  int i;
+  tree expr;
+
+  for (i = 0; VEC_iterate (tree, iv_map, i, expr); i++)
+    if (expr)
+      chrec = chrec_apply (i, chrec, expr);
+
+  return chrec;
+}
+
 /* Replaces the initial condition in CHREC with INIT_COND.  */
 
 tree
diff --git a/gcc/tree-chrec.h b/gcc/tree-chrec.h
index fcff93a..eb60ac9 100644
--- a/gcc/tree-chrec.h
+++ b/gcc/tree-chrec.h
@@ -64,6 +64,7 @@ extern tree chrec_convert_aggressive (tree, tree);
 
 /* Operations.  */
 extern tree chrec_apply (unsigned, tree, tree);
+extern tree chrec_apply_map (tree, VEC (tree, heap) *);
 extern tree chrec_replace_initial_condition (tree, tree);
 extern tree initial_condition (tree);
 extern tree initial_condition_in_loop_num (tree, unsigned);
