gcc/

[pf3gnuchains/gcc-fork.git] / gcc / graphite-clast-to-gimple.c

diff --git a/gcc/graphite-clast-to-gimple.c b/gcc/graphite-clast-to-gimple.c
index b0e1a94..abf8877 100644 (file)
--- a/gcc/graphite-clast-to-gimple.c
+++ b/gcc/graphite-clast-to-gimple.c
@@ -1,5 +1,5 @@
 /* Translation of CLAST (CLooG AST) to Gimple.
 /* Translation of CLAST (CLooG AST) to Gimple.

-   Copyright (C) 2009, 2010 Free Software Foundation, Inc.
+   Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.

    Contributed by Sebastian Pop <sebastian.pop@amd.com>.
 
 This file is part of GCC.
    Contributed by Sebastian Pop <sebastian.pop@amd.com>.
 
 This file is part of GCC.


@@ -21,37 +21,28 @@ along with GCC; see the file COPYING3.  If not see
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"

-#include "tm.h"
-#include "ggc.h"
-#include "tree.h"
-#include "rtl.h"
-#include "basic-block.h"
-#include "diagnostic.h"
+#include "diagnostic-core.h"

 #include "tree-flow.h"
 #include "tree-flow.h"

-#include "toplev.h"

 #include "tree-dump.h"
 #include "tree-dump.h"

-#include "timevar.h"

 #include "cfgloop.h"
 #include "tree-chrec.h"
 #include "tree-data-ref.h"
 #include "tree-scalar-evolution.h"
 #include "cfgloop.h"
 #include "tree-chrec.h"
 #include "tree-data-ref.h"
 #include "tree-scalar-evolution.h"

-#include "tree-pass.h"
-#include "domwalk.h"
-#include "value-prof.h"
-#include "pointer-set.h"
-#include "gimple.h"
-#include "langhooks.h"

 #include "sese.h"
 
 #ifdef HAVE_cloog
 #include "cloog/cloog.h"
 #include "ppl_c.h"
 #include "sese.h"
 
 #ifdef HAVE_cloog
 #include "cloog/cloog.h"
 #include "ppl_c.h"

+#include "graphite-cloog-util.h"

 #include "graphite-ppl.h"
 #include "graphite-ppl.h"

-#include "graphite.h"

 #include "graphite-poly.h"
 #include "graphite-poly.h"

-#include "graphite-scop-detection.h"

 #include "graphite-clast-to-gimple.h"
 #include "graphite-dependences.h"
 #include "graphite-clast-to-gimple.h"
 #include "graphite-dependences.h"

+#include "graphite-cloog-compat.h"
+
+#ifndef CLOOG_LANGUAGE_C
+#define CLOOG_LANGUAGE_C LANGUAGE_C
+#endif

 
 /* This flag is set when an error occurred during the translation of
    CLAST to Gimple.  */
 
 /* This flag is set when an error occurred during the translation of
    CLAST to Gimple.  */


@@ -65,42 +56,94 @@ graphite_verify (void)
 #ifdef ENABLE_CHECKING
   verify_loop_structure ();
   verify_dominators (CDI_DOMINATORS);
 #ifdef ENABLE_CHECKING
   verify_loop_structure ();
   verify_dominators (CDI_DOMINATORS);

-  verify_dominators (CDI_POST_DOMINATORS);

   verify_loop_closed_ssa (true);
 #endif
 }
 
   verify_loop_closed_ssa (true);
 #endif
 }
 

-/* Stores the INDEX in a vector for a given clast NAME.  */
+/* Stores the INDEX in a vector and the loop nesting LEVEL for a given
+   clast NAME.  BOUND_ONE and BOUND_TWO represent the exact lower and
+   upper bounds that can be inferred from the polyhedral representation.  */

 
 typedef struct clast_name_index {
   int index;
 
 typedef struct clast_name_index {
   int index;

+  int level;
+  mpz_t bound_one, bound_two;

   const char *name;
 } *clast_name_index_p;
 
 /* Returns a pointer to a new element of type clast_name_index_p built
   const char *name;
 } *clast_name_index_p;
 
 /* Returns a pointer to a new element of type clast_name_index_p built

-   from NAME and INDEX.  */
+   from NAME, INDEX, LEVEL, BOUND_ONE, and BOUND_TWO.  */

 
 static inline clast_name_index_p
 
 static inline clast_name_index_p

-new_clast_name_index (const char *name, int index)
+new_clast_name_index (const char *name, int index, int level,
+                     mpz_t bound_one, mpz_t bound_two)

 {
   clast_name_index_p res = XNEW (struct clast_name_index);
 
   res->name = name;
 {
   clast_name_index_p res = XNEW (struct clast_name_index);
 
   res->name = name;

+  res->level = level;

   res->index = index;
   res->index = index;

+  mpz_init (res->bound_one);
+  mpz_init (res->bound_two);
+  mpz_set (res->bound_one, bound_one);
+  mpz_set (res->bound_two, bound_two);

   return res;
 }
 
   return res;
 }
 

+/* Free the memory taken by a clast_name_index struct.  */
+
+static void
+free_clast_name_index (void *ptr)
+{
+  struct clast_name_index *c = (struct clast_name_index *) ptr;
+  mpz_clear (c->bound_one);
+  mpz_clear (c->bound_two);
+  free (ptr);
+}
+
+/* For a given clast NAME, returns -1 if NAME is not in the
+   INDEX_TABLE, otherwise returns the loop level for the induction
+   variable NAME, or if it is a parameter, the parameter number in the
+   vector of parameters.  */
+
+static inline int
+clast_name_to_level (clast_name_p name, htab_t index_table)
+{
+  struct clast_name_index tmp;
+  PTR *slot;
+
+#ifdef CLOOG_ORG
+  gcc_assert (name->type == clast_expr_name);
+  tmp.name = ((const struct clast_name *) name)->name;
+#else
+  tmp.name = name;
+#endif
+
+  slot = htab_find_slot (index_table, &tmp, NO_INSERT);
+
+  if (slot && *slot)
+    return ((struct clast_name_index *) *slot)->level;
+
+  return -1;
+}
+

 /* For a given clast NAME, returns -1 if it does not correspond to any
    parameter, or otherwise, returns the index in the PARAMS or
    SCATTERING_DIMENSIONS vector.  */
 
 static inline int
 /* For a given clast NAME, returns -1 if it does not correspond to any
    parameter, or otherwise, returns the index in the PARAMS or
    SCATTERING_DIMENSIONS vector.  */
 
 static inline int

-clast_name_to_index (const char *name, htab_t index_table)
+clast_name_to_index (clast_name_p name, htab_t index_table)

 {
   struct clast_name_index tmp;
   PTR *slot;
 
 {
   struct clast_name_index tmp;
   PTR *slot;
 

+#ifdef CLOOG_ORG
+  gcc_assert (name->type == clast_expr_name);
+  tmp.name = ((const struct clast_name *) name)->name;
+#else

   tmp.name = name;
   tmp.name = name;

+#endif
+

   slot = htab_find_slot (index_table, &tmp, NO_INSERT);
 
   if (slot && *slot)
   slot = htab_find_slot (index_table, &tmp, NO_INSERT);
 
   if (slot && *slot)


@@ -109,50 +152,54 @@ clast_name_to_index (const char *name, htab_t index_table)
   return -1;
 }
 
   return -1;
 }
 

-/* Records in INDEX_TABLE the INDEX for NAME.  */
+/* For a given clast NAME, initializes the lower and upper bounds BOUND_ONE
+   and BOUND_TWO stored in the INDEX_TABLE.  Returns true when NAME has been
+   found in the INDEX_TABLE, false otherwise.  */

 
 

-static inline void
-save_clast_name_index (htab_t index_table, const char *name, int index)
+static inline bool
+clast_name_to_lb_ub (clast_name_p name, htab_t index_table, mpz_t bound_one,
+                    mpz_t bound_two)

 {
   struct clast_name_index tmp;
   PTR *slot;
 
 {
   struct clast_name_index tmp;
   PTR *slot;
 

+#ifdef CLOOG_ORG
+  gcc_assert (name->type == clast_expr_name);
+  tmp.name = ((const struct clast_name *) name)->name;
+#else

   tmp.name = name;
   tmp.name = name;

-  slot = htab_find_slot (index_table, &tmp, INSERT);
+#endif

 
 

-  if (slot)
-    {
-      if (*slot)
-       free (*slot);
+  slot = htab_find_slot (index_table, &tmp, NO_INSERT);

 
 

-      *slot = new_clast_name_index (name, index);
+  if (slot && *slot)
+    {
+      mpz_set (bound_one, ((struct clast_name_index *) *slot)->bound_one);
+      mpz_set (bound_two, ((struct clast_name_index *) *slot)->bound_two);
+      return true;

     }
     }

+
+  return false;

 }
 
 }
 

-/* Print to stderr the element ELT.  */
+/* Records in INDEX_TABLE the INDEX and LEVEL for NAME.  */

 
 static inline void
 
 static inline void

-debug_clast_name_index (clast_name_index_p elt)
+save_clast_name_index (htab_t index_table, const char *name,
+                      int index, int level, mpz_t bound_one, mpz_t bound_two)

 {
 {

-  fprintf (stderr, "(index = %d, name = %s)\n", elt->index, elt->name);
-}
-
-/* Helper function for debug_rename_map.  */
+  struct clast_name_index tmp;
+  PTR *slot;

 
 

-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;
-}
+  tmp.name = name;
+  slot = htab_find_slot (index_table, &tmp, INSERT);

 
 

-/* Print to stderr all the elements of MAP.  */
+  if (slot)
+    {
+      free (*slot);

 
 

-DEBUG_FUNCTION void
-debug_clast_name_indexes (htab_t map)
-{
-  htab_traverse (map, debug_clast_name_indexes_1, NULL);
+      *slot = new_clast_name_index (name, index, level, bound_one, bound_two);
+    }

 }
 
 /* Computes a hash function for database element ELT.  */
 }
 
 /* Computes a hash function for database element ELT.  */


@@ -174,121 +221,106 @@ eq_clast_name_indexes (const void *e1, const void *e2)
   return (elt1->name == elt2->name);
 }
 
   return (elt1->name == elt2->name);
 }
 

+\f

 
 

-/* 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.  */
+/* NEWIVS_INDEX binds CLooG's scattering name to the index of the tree
+   induction variable in NEWIVS.

 
 

-static inline tree
-newivs_to_depth_to_newiv (VEC (tree, heap) *newivs, int depth)
-{
-  return VEC_index (tree, newivs, depth);
-}
+   PARAMS_INDEX binds CLooG's parameter name to the index of the tree
+   parameter in PARAMS.  */

 
 

-\f
+typedef struct ivs_params {
+  VEC (tree, heap) *params, **newivs;
+  htab_t newivs_index, params_index;
+  sese region;
+} *ivs_params_p;

 
 /* Returns the tree variable from the name NAME that was given in
    Cloog representation.  */
 
 static tree
 
 /* Returns the tree variable from the name NAME that was given in
    Cloog representation.  */
 
 static tree

-clast_name_to_gcc (const char *name, sese region, VEC (tree, heap) *newivs,
-                  htab_t newivs_index, htab_t params_index)
+clast_name_to_gcc (clast_name_p name, ivs_params_p ip)

 {
   int index;
 {
   int index;

-  VEC (tree, heap) *params = SESE_PARAMS (region);

 
 

-  if (params && params_index)
+  if (ip->params && ip->params_index)

     {
     {

-      index = clast_name_to_index (name, params_index);
+      index = clast_name_to_index (name, ip->params_index);

 
       if (index >= 0)
 
       if (index >= 0)

-       return VEC_index (tree, params, index);
+       return VEC_index (tree, ip->params, index);

     }
 
     }
 

-  gcc_assert (newivs && newivs_index);
-  index = clast_name_to_index (name, newivs_index);
+  gcc_assert (*(ip->newivs) && ip->newivs_index);
+  index = clast_name_to_index (name, ip->newivs_index);

   gcc_assert (index >= 0);
 
   gcc_assert (index >= 0);
 

-  return newivs_to_depth_to_newiv (newivs, index);
+  return VEC_index (tree, *(ip->newivs), index);

 }
 
 }
 

-/* Returns the signed maximal precision type for expressions TYPE1 and TYPE2.  */
+/* Returns the maximal precision type for expressions TYPE1 and TYPE2.  */

 
 static tree
 
 static tree

-max_signed_precision_type (tree type1, tree type2)
+max_precision_type (tree type1, tree type2)

 {
 {

-  int p1 = TYPE_PRECISION (type1);
-  int p2 = TYPE_PRECISION (type2);
-  int precision;
+  enum machine_mode mode;
+  int p1, p2, precision;

   tree type;
 
   tree type;
 

+  if (POINTER_TYPE_P (type1))
+    return type1;
+
+  if (POINTER_TYPE_P (type2))
+    return type2;
+
+  if (TYPE_UNSIGNED (type1)
+      && TYPE_UNSIGNED (type2))
+    return TYPE_PRECISION (type1) > TYPE_PRECISION (type2) ? type1 : type2;
+
+  p1 = TYPE_PRECISION (type1);
+  p2 = TYPE_PRECISION (type2);
+

   if (p1 > p2)
     precision = TYPE_UNSIGNED (type1) ? p1 * 2 : p1;
   else
     precision = TYPE_UNSIGNED (type2) ? p2 * 2 : p2;
 
   if (p1 > p2)
     precision = TYPE_UNSIGNED (type1) ? p1 * 2 : p1;
   else
     precision = TYPE_UNSIGNED (type2) ? p2 * 2 : p2;
 

-  type = lang_hooks.types.type_for_size (precision, false);
-
-  if (!type)
+  if (precision > BITS_PER_WORD)

     {
       gloog_error = true;
       return integer_type_node;
     }
     {
       gloog_error = true;
       return integer_type_node;
     }

-  return type;
-}

 
 

-/* Returns the maximal precision type for expressions TYPE1 and TYPE2.  */
+  mode = smallest_mode_for_size (precision, MODE_INT);
+  precision = GET_MODE_PRECISION (mode);
+  type = build_nonstandard_integer_type (precision, false);

 
 

-static tree
-max_precision_type (tree type1, tree type2)
-{
-  if (POINTER_TYPE_P (type1))
-    return type1;
-
-  if (POINTER_TYPE_P (type2))
-    return type2;
-
-  if (!TYPE_UNSIGNED (type1)
-      || !TYPE_UNSIGNED (type2))
-    return max_signed_precision_type (type1, type2);
+  if (!type)
+    {
+      gloog_error = true;
+      return integer_type_node;
+    }

 
 

-  return TYPE_PRECISION (type1) > TYPE_PRECISION (type2) ? type1 : type2;
+  return type;

 }
 
 static tree
 }
 
 static tree

-clast_to_gcc_expression (tree, struct clast_expr *, sese, VEC (tree, heap) *,
-                        htab_t, htab_t);
+clast_to_gcc_expression (tree, struct clast_expr *, ivs_params_p);

 
 /* Converts a Cloog reduction expression R with reduction operation OP
    to a GCC expression tree of type TYPE.  */
 
 static tree
 clast_to_gcc_expression_red (tree type, enum tree_code op,
 
 /* Converts a Cloog reduction expression R with reduction operation OP
    to a GCC expression tree of type TYPE.  */
 
 static tree
 clast_to_gcc_expression_red (tree type, enum tree_code op,

-                            struct clast_reduction *r,
-                            sese region, VEC (tree, heap) *newivs,
-                            htab_t newivs_index, htab_t params_index)
+                            struct clast_reduction *r, ivs_params_p ip)

 {
   int i;
 {
   int i;

-  tree res = clast_to_gcc_expression (type, r->elts[0], region, newivs,
-                                     newivs_index, params_index);
+  tree res = clast_to_gcc_expression (type, r->elts[0], ip);

   tree operand_type = (op == POINTER_PLUS_EXPR) ? sizetype : type;
 
   for (i = 1; i < r->n; i++)
     {
   tree operand_type = (op == POINTER_PLUS_EXPR) ? sizetype : type;
 
   for (i = 1; i < r->n; i++)
     {

-      tree t = clast_to_gcc_expression (operand_type, r->elts[i], region,
-                                       newivs, newivs_index, params_index);
+      tree t = clast_to_gcc_expression (operand_type, r->elts[i], ip);

       res = fold_build2 (op, type, res, t);
     }
 
       res = fold_build2 (op, type, res, t);
     }
 


@@ -299,13 +331,11 @@ clast_to_gcc_expression_red (tree type, enum tree_code op,
    type TYPE.  */
 
 static tree
    type TYPE.  */
 
 static tree

-clast_to_gcc_expression (tree type, struct clast_expr *e,
-                        sese region, VEC (tree, heap) *newivs,
-                        htab_t newivs_index, htab_t params_index)
+clast_to_gcc_expression (tree type, struct clast_expr *e, ivs_params_p ip)

 {
   switch (e->type)
     {
 {
   switch (e->type)
     {

-    case expr_term:
+    case clast_expr_term:

       {
        struct clast_term *t = (struct clast_term *) e;
 
       {
        struct clast_term *t = (struct clast_term *) e;
 


@@ -313,11 +343,10 @@ clast_to_gcc_expression (tree type, struct clast_expr *e,
          {
            if (mpz_cmp_si (t->val, 1) == 0)
              {
          {
            if (mpz_cmp_si (t->val, 1) == 0)
              {

-               tree name = clast_name_to_gcc (t->var, region, newivs,
-                                              newivs_index, params_index);
+               tree name = clast_name_to_gcc (t->var, ip);

 
                if (POINTER_TYPE_P (TREE_TYPE (name)) != POINTER_TYPE_P (type))
 
                if (POINTER_TYPE_P (TREE_TYPE (name)) != POINTER_TYPE_P (type))

-                 name = fold_convert (sizetype, name);
+                 name = convert_to_ptrofftype (name);

 
                name = fold_convert (type, name);
                return name;
 
                name = fold_convert (type, name);
                return name;


@@ -325,11 +354,10 @@ clast_to_gcc_expression (tree type, struct clast_expr *e,
 
            else if (mpz_cmp_si (t->val, -1) == 0)
              {
 
            else if (mpz_cmp_si (t->val, -1) == 0)
              {

-               tree name = clast_name_to_gcc (t->var, region, newivs,
-                                              newivs_index, params_index);
+               tree name = clast_name_to_gcc (t->var, ip);

 
                if (POINTER_TYPE_P (TREE_TYPE (name)) != POINTER_TYPE_P (type))
 
                if (POINTER_TYPE_P (TREE_TYPE (name)) != POINTER_TYPE_P (type))

-                 name = fold_convert (sizetype, name);
+                 name = convert_to_ptrofftype (name);

 
                name = fold_convert (type, name);
 
 
                name = fold_convert (type, name);
 


@@ -337,12 +365,11 @@ clast_to_gcc_expression (tree type, struct clast_expr *e,
              }
            else
              {
              }
            else
              {

-               tree name = clast_name_to_gcc (t->var, region, newivs,
-                                              newivs_index, params_index);
+               tree name = clast_name_to_gcc (t->var, ip);

                tree cst = gmp_cst_to_tree (type, t->val);
 
                if (POINTER_TYPE_P (TREE_TYPE (name)) != POINTER_TYPE_P (type))
                tree cst = gmp_cst_to_tree (type, t->val);
 
                if (POINTER_TYPE_P (TREE_TYPE (name)) != POINTER_TYPE_P (type))

-                 name = fold_convert (sizetype, name);
+                 name = convert_to_ptrofftype (name);

 
                name = fold_convert (type, name);
 
 
                name = fold_convert (type, name);
 


@@ -357,7 +384,7 @@ clast_to_gcc_expression (tree type, struct clast_expr *e,
          return gmp_cst_to_tree (type, t->val);
       }
 
          return gmp_cst_to_tree (type, t->val);
       }
 

-    case expr_red:
+    case clast_expr_red:

       {
         struct clast_reduction *r = (struct clast_reduction *) e;
 
       {
         struct clast_reduction *r = (struct clast_reduction *) e;
 


@@ -366,17 +393,13 @@ clast_to_gcc_expression (tree type, struct clast_expr *e,
          case clast_red_sum:
            return clast_to_gcc_expression_red
              (type, POINTER_TYPE_P (type) ? POINTER_PLUS_EXPR : PLUS_EXPR,
          case clast_red_sum:
            return clast_to_gcc_expression_red
              (type, POINTER_TYPE_P (type) ? POINTER_PLUS_EXPR : PLUS_EXPR,

-              r, region, newivs, newivs_index, params_index);
+              r, ip);

 
          case clast_red_min:
 
          case clast_red_min:

-           return clast_to_gcc_expression_red (type, MIN_EXPR, r, region,
-                                               newivs, newivs_index,
-                                               params_index);
+           return clast_to_gcc_expression_red (type, MIN_EXPR, r, ip);

 
          case clast_red_max:
 
          case clast_red_max:

-           return clast_to_gcc_expression_red (type, MAX_EXPR, r, region,
-                                               newivs, newivs_index,
-                                               params_index);
+           return clast_to_gcc_expression_red (type, MAX_EXPR, r, ip);

 
          default:
            gcc_unreachable ();
 
          default:
            gcc_unreachable ();


@@ -384,12 +407,11 @@ clast_to_gcc_expression (tree type, struct clast_expr *e,
         break;
       }
 
         break;
       }
 

-    case expr_bin:
+    case clast_expr_bin:

       {
        struct clast_binary *b = (struct clast_binary *) e;
        struct clast_expr *lhs = (struct clast_expr *) b->LHS;
       {
        struct clast_binary *b = (struct clast_binary *) e;
        struct clast_expr *lhs = (struct clast_expr *) b->LHS;

-       tree tl = clast_to_gcc_expression (type, lhs, region, newivs,
-                                          newivs_index, params_index);
+       tree tl = clast_to_gcc_expression (type, lhs, ip);

        tree tr = gmp_cst_to_tree (type, b->RHS);
 
        switch (b->type)
        tree tr = gmp_cst_to_tree (type, b->RHS);
 
        switch (b->type)


@@ -418,79 +440,42 @@ clast_to_gcc_expression (tree type, struct clast_expr *e,
   return NULL_TREE;
 }
 
   return NULL_TREE;
 }
 

-/* Return the precision needed to represent the value VAL.  */
+/* Return a type that could represent the values between BOUND_ONE and
+   BOUND_TWO.  */

 
 

-static int
-precision_for_value (mpz_t val)
+static tree
+type_for_interval (mpz_t bound_one, mpz_t bound_two)

 {
 {

-  mpz_t x, y, two;
-  int precision;
-
-  value_init (x);
-  value_init (y);
-  value_init (two);
-  value_set_si (x, 2);
-  value_assign (y, val);
-  value_set_si (two, 2);
-  precision = 1;
-
-  if (value_neg_p (y))
-    value_oppose (y, y);
+  bool unsigned_p;
+  tree type;
+  enum machine_mode mode;
+  int wider_precision;
+  int precision = MAX (mpz_sizeinbase (bound_one, 2),
+                      mpz_sizeinbase (bound_two, 2));

 
 

-  while (value_gt (y, x))
+  if (precision > BITS_PER_WORD)

     {
     {

-      value_multiply (x, x, two);
-      precision++;
+      gloog_error = true;
+      return integer_type_node;

     }
 
     }
 

-  value_clear (x);
-  value_clear (y);
-  value_clear (two);
-
-  return precision;
-}
-
-/* Return the precision needed to represent the values between LOW and
-   UP.  */
-
-static int
-precision_for_interval (mpz_t low, mpz_t up)
-{
-  mpz_t diff;
-  int precision;
-
-  gcc_assert (value_le (low, up));
-
-  value_init (diff);
-  value_subtract (diff, up, low);
-  precision = precision_for_value (diff);
-  value_clear (diff);
-
-  return precision;
-}
-
-/* Return a type that could represent the integer value VAL, or
-   otherwise return NULL_TREE.  */
-
-static tree
-gcc_type_for_interval (mpz_t low, mpz_t up, tree old_type)
-{
-  bool unsigned_p = true;
-  int precision, prec_up, prec_int;
-  tree type;
+  if (mpz_cmp (bound_one, bound_two) <= 0)
+    unsigned_p = (mpz_sgn (bound_one) >= 0);
+  else
+    unsigned_p = (mpz_sgn (bound_two) >= 0);

 
 

-  gcc_assert (value_le (low, up));
+  mode = smallest_mode_for_size (precision, MODE_INT);
+  wider_precision = GET_MODE_PRECISION (mode);

 
 

-  /* Preserve the signedness of the old IV.  */
-  if ((old_type && !TYPE_UNSIGNED (old_type))
-      || value_neg_p (low))
+  /* As we want to generate signed types as much as possible, try to
+     fit the interval [bound_one, bound_two] in a signed type.  For example,
+     supposing that we have the interval [0, 100], instead of
+     generating unsigned char, we want to generate a signed char.  */
+  if (unsigned_p && precision < wider_precision)

     unsigned_p = false;
 
     unsigned_p = false;
 

-  prec_up = precision_for_value (up);
-  prec_int = precision_for_interval (low, up);
-  precision = prec_up > prec_int ? prec_up : prec_int;
+  type = build_nonstandard_integer_type (wider_precision, unsigned_p);

 
 

-  type = lang_hooks.types.type_for_size (precision, unsigned_p);

   if (!type)
     {
       gloog_error = true;
   if (!type)
     {
       gloog_error = true;


@@ -504,101 +489,177 @@ gcc_type_for_interval (mpz_t low, mpz_t up, tree old_type)
    otherwise return NULL_TREE.  */
 
 static tree
    otherwise return NULL_TREE.  */
 
 static tree

-gcc_type_for_value (mpz_t val)
+type_for_value (mpz_t val)

 {
 {

-  return gcc_type_for_interval (val, val, NULL_TREE);
+  return type_for_interval (val, val);

 }
 
 }
 

-/* Return the type for the clast_term T used in STMT.  */
+/* Return the type for the clast_term T.  Initializes BOUND_ONE and
+   BOUND_TWO to the bounds of the term.  */

 
 static tree
 
 static tree

-gcc_type_for_clast_term (struct clast_term *t,
-                        sese region, VEC (tree, heap) *newivs,
-                        htab_t newivs_index, htab_t params_index)
+type_for_clast_term (struct clast_term *t, ivs_params_p ip, mpz_t bound_one,
+                    mpz_t bound_two)

 {
 {

-  gcc_assert (t->expr.type == expr_term);
+  clast_name_p name = t->var;
+  bool found = false;
+
+  gcc_assert (t->expr.type == clast_expr_term);
+
+  if (!name)
+    {
+      mpz_set (bound_one, t->val);
+      mpz_set (bound_two, t->val);
+      return type_for_value (t->val);
+    }
+
+  if (ip->params && ip->params_index)
+    found = clast_name_to_lb_ub (name, ip->params_index, bound_one, bound_two);
+
+  if (!found)
+    {
+      gcc_assert (*(ip->newivs) && ip->newivs_index);
+      found = clast_name_to_lb_ub (name, ip->newivs_index,
+                                  bound_one, bound_two);
+      gcc_assert (found);
+    }

 
 

-  if (!t->var)
-    return gcc_type_for_value (t->val);
+  mpz_mul (bound_one, bound_one, t->val);
+  mpz_mul (bound_two, bound_two, t->val);

 
 

-  return TREE_TYPE (clast_name_to_gcc (t->var, region, newivs,
-                                      newivs_index, params_index));
+  return TREE_TYPE (clast_name_to_gcc (name, ip));

 }
 
 static tree
 }
 
 static tree

-gcc_type_for_clast_expr (struct clast_expr *, sese,
-                        VEC (tree, heap) *, htab_t, htab_t);
+type_for_clast_expr (struct clast_expr *, ivs_params_p, mpz_t, mpz_t);

 
 

-/* Return the type for the clast_reduction R used in STMT.  */
+/* Return the type for the clast_reduction R.  Initializes BOUND_ONE
+   and BOUND_TWO to the bounds of the reduction expression.  */

 
 static tree
 
 static tree

-gcc_type_for_clast_red (struct clast_reduction *r, sese region,
-                       VEC (tree, heap) *newivs,
-                       htab_t newivs_index, htab_t params_index)
+type_for_clast_red (struct clast_reduction *r, ivs_params_p ip,
+                   mpz_t bound_one, mpz_t bound_two)

 {
   int i;
 {
   int i;

-  tree type = NULL_TREE;
+  tree type = type_for_clast_expr (r->elts[0], ip, bound_one, bound_two);
+  mpz_t b1, b2, m1, m2;

 
   if (r->n == 1)
 
   if (r->n == 1)

-    return gcc_type_for_clast_expr (r->elts[0], region, newivs,
-                                   newivs_index, params_index);
+    return type;

 
 

-  switch (r->type)
-    {
-    case clast_red_sum:
-    case clast_red_min:
-    case clast_red_max:
-      type = gcc_type_for_clast_expr (r->elts[0], region, newivs,
-                                     newivs_index, params_index);
-      for (i = 1; i < r->n; i++)
-       type = max_precision_type (type, gcc_type_for_clast_expr
-                                  (r->elts[i], region, newivs,
-                                   newivs_index, params_index));
-
-      return type;
+  mpz_init (b1);
+  mpz_init (b2);
+  mpz_init (m1);
+  mpz_init (m2);

 
 

-    default:
-      break;
+  for (i = 1; i < r->n; i++)
+    {
+      tree t = type_for_clast_expr (r->elts[i], ip, b1, b2);
+      type = max_precision_type (type, t);
+
+      switch (r->type)
+       {
+       case clast_red_sum:
+         value_min (m1, bound_one, bound_two);
+         value_min (m2, b1, b2);
+         mpz_add (bound_one, m1, m2);
+
+         value_max (m1, bound_one, bound_two);
+         value_max (m2, b1, b2);
+         mpz_add (bound_two, m1, m2);
+         break;
+
+       case clast_red_min:
+         value_min (bound_one, bound_one, bound_two);
+         value_min (bound_two, b1, b2);
+         break;
+
+       case clast_red_max:
+         value_max (bound_one, bound_one, bound_two);
+         value_max (bound_two, b1, b2);
+         break;
+
+       default:
+         gcc_unreachable ();
+         break;
+       }

     }
 
     }
 

-  gcc_unreachable ();
-  return NULL_TREE;
+  mpz_clear (b1);
+  mpz_clear (b2);
+  mpz_clear (m1);
+  mpz_clear (m2);
+
+  /* Return a type that can represent the result of the reduction.  */
+  return max_precision_type (type, type_for_interval (bound_one, bound_two));

 }
 
 /* Return the type for the clast_binary B used in STMT.  */
 
 static tree
 }
 
 /* Return the type for the clast_binary B used in STMT.  */
 
 static tree

-gcc_type_for_clast_bin (struct clast_binary *b,
-                       sese region, VEC (tree, heap) *newivs,
-                       htab_t newivs_index, htab_t params_index)
+type_for_clast_bin (struct clast_binary *b, ivs_params_p ip, mpz_t bound_one,
+                   mpz_t bound_two)

 {
 {

-  tree l = gcc_type_for_clast_expr ((struct clast_expr *) b->LHS, region,
-                                   newivs, newivs_index, params_index);
-  tree r = gcc_type_for_value (b->RHS);
-  return max_signed_precision_type (l, r);
+  mpz_t one;
+  tree l = type_for_clast_expr ((struct clast_expr *) b->LHS, ip,
+                               bound_one, bound_two);
+  tree r = type_for_value (b->RHS);
+  tree type = max_precision_type (l, r);
+
+  switch (b->type)
+    {
+    case clast_bin_fdiv:
+      mpz_mdiv (bound_one, bound_one, b->RHS);
+      mpz_mdiv (bound_two, bound_two, b->RHS);
+      break;
+
+    case clast_bin_cdiv:
+      mpz_mdiv (bound_one, bound_one, b->RHS);
+      mpz_mdiv (bound_two, bound_two, b->RHS);
+      mpz_init (one);
+      mpz_add (bound_one, bound_one, one);
+      mpz_add (bound_two, bound_two, one);
+      mpz_clear (one);
+      break;
+
+    case clast_bin_div:
+      mpz_div (bound_one, bound_one, b->RHS);
+      mpz_div (bound_two, bound_two, b->RHS);
+      break;
+
+    case clast_bin_mod:
+      mpz_mod (bound_one, bound_one, b->RHS);
+      mpz_mod (bound_two, bound_two, b->RHS);
+      break;
+
+    default:
+      gcc_unreachable ();
+    }
+
+  /* Return a type that can represent the result of the reduction.  */
+  return max_precision_type (type, type_for_interval (bound_one, bound_two));

 }
 
 /* Returns the type for the CLAST expression E when used in statement
    STMT.  */
 
 static tree
 }
 
 /* Returns the type for the CLAST expression E when used in statement
    STMT.  */
 
 static tree

-gcc_type_for_clast_expr (struct clast_expr *e,
-                        sese region, VEC (tree, heap) *newivs,
-                        htab_t newivs_index, htab_t params_index)
+type_for_clast_expr (struct clast_expr *e, ivs_params_p ip, mpz_t bound_one,
+                    mpz_t bound_two)

 {
   switch (e->type)
     {
 {
   switch (e->type)
     {

-    case expr_term:
-      return gcc_type_for_clast_term ((struct clast_term *) e, region,
-                                     newivs, newivs_index, params_index);
+    case clast_expr_term:
+      return type_for_clast_term ((struct clast_term *) e, ip,
+                                 bound_one, bound_two);

 
 

-    case expr_red:
-      return gcc_type_for_clast_red ((struct clast_reduction *) e, region,
-                                    newivs, newivs_index, params_index);
+    case clast_expr_red:
+      return type_for_clast_red ((struct clast_reduction *) e, ip,
+                                bound_one, bound_two);

 
 

-    case expr_bin:
-      return gcc_type_for_clast_bin ((struct clast_binary *) e, region,
-                                    newivs, newivs_index, params_index);
+    case clast_expr_bin:
+      return type_for_clast_bin ((struct clast_binary *) e, ip,
+                                bound_one, bound_two);

 
     default:
       gcc_unreachable ();
 
     default:
       gcc_unreachable ();


@@ -610,32 +671,32 @@ gcc_type_for_clast_expr (struct clast_expr *e,
 /* Returns the type for the equation CLEQ.  */
 
 static tree
 /* Returns the type for the equation CLEQ.  */
 
 static tree

-gcc_type_for_clast_eq (struct clast_equation *cleq,
-                      sese region, VEC (tree, heap) *newivs,
-                      htab_t newivs_index, htab_t params_index)
+type_for_clast_eq (struct clast_equation *cleq, ivs_params_p ip)

 {
 {

-  tree l = gcc_type_for_clast_expr (cleq->LHS, region, newivs,
-                                   newivs_index, params_index);
-  tree r = gcc_type_for_clast_expr (cleq->RHS, region, newivs,
-                                   newivs_index, params_index);
+  mpz_t bound_one, bound_two;
+  tree l, r;
+
+  mpz_init (bound_one);
+  mpz_init (bound_two);
+
+  l = type_for_clast_expr (cleq->LHS, ip, bound_one, bound_two);
+  r = type_for_clast_expr (cleq->RHS, ip, bound_one, bound_two);
+
+  mpz_clear (bound_one);
+  mpz_clear (bound_two);

   return max_precision_type (l, r);
 }
 
 /* Translates a clast equation CLEQ to a tree.  */
 
 static tree
   return max_precision_type (l, r);
 }
 
 /* Translates a clast equation CLEQ to a tree.  */
 
 static tree

-graphite_translate_clast_equation (sese region,
-                                  struct clast_equation *cleq,
-                                  VEC (tree, heap) *newivs,
-                                  htab_t newivs_index, htab_t params_index)
+graphite_translate_clast_equation (struct clast_equation *cleq,
+                                  ivs_params_p ip)

 {
   enum tree_code comp;
 {
   enum tree_code comp;

-  tree type = gcc_type_for_clast_eq (cleq, region, newivs, newivs_index,
-                                    params_index);
-  tree lhs = clast_to_gcc_expression (type, cleq->LHS, region, newivs,
-                                     newivs_index, params_index);
-  tree rhs = clast_to_gcc_expression (type, cleq->RHS, region, newivs,
-                                     newivs_index, params_index);
+  tree type = type_for_clast_eq (cleq, ip);
+  tree lhs = clast_to_gcc_expression (type, cleq->LHS, ip);
+  tree rhs = clast_to_gcc_expression (type, cleq->RHS, ip);

 
   if (cleq->sign == 0)
     comp = EQ_EXPR;
 
   if (cleq->sign == 0)
     comp = EQ_EXPR;


@@ -652,18 +713,15 @@ graphite_translate_clast_equation (sese region,
 /* Creates the test for the condition in STMT.  */
 
 static tree
 /* Creates the test for the condition in STMT.  */
 
 static tree

-graphite_create_guard_cond_expr (sese region, struct clast_guard *stmt,
-                                VEC (tree, heap) *newivs,
-                                htab_t newivs_index, htab_t params_index)
+graphite_create_guard_cond_expr (struct clast_guard *stmt,
+                                ivs_params_p ip)

 {
   tree cond = NULL;
   int i;
 
   for (i = 0; i < stmt->n; i++)
     {
 {
   tree cond = NULL;
   int i;
 
   for (i = 0; i < stmt->n; i++)
     {

-      tree eq = graphite_translate_clast_equation (region, &stmt->eq[i],
-                                                  newivs, newivs_index,
-                                                  params_index);
+      tree eq = graphite_translate_clast_equation (&stmt->eq[i], ip);

 
       if (cond)
        cond = fold_build2 (TRUTH_AND_EXPR, TREE_TYPE (eq), cond, eq);
 
       if (cond)
        cond = fold_build2 (TRUTH_AND_EXPR, TREE_TYPE (eq), cond, eq);


@@ -677,17 +735,32 @@ graphite_create_guard_cond_expr (sese region, struct clast_guard *stmt,
 /* Creates a new if region corresponding to Cloog's guard.  */
 
 static edge
 /* Creates a new if region corresponding to Cloog's guard.  */
 
 static edge

-graphite_create_new_guard (sese region, edge entry_edge,
-                          struct clast_guard *stmt,
-                          VEC (tree, heap) *newivs,
-                          htab_t newivs_index, htab_t params_index)
+graphite_create_new_guard (edge entry_edge, struct clast_guard *stmt,
+                          ivs_params_p ip)

 {
 {

-  tree cond_expr = graphite_create_guard_cond_expr (region, stmt, newivs,
-                                                   newivs_index, params_index);
+  tree cond_expr = graphite_create_guard_cond_expr (stmt, ip);

   edge exit_edge = create_empty_if_region_on_edge (entry_edge, cond_expr);
   return exit_edge;
 }
 
   edge exit_edge = create_empty_if_region_on_edge (entry_edge, cond_expr);
   return exit_edge;
 }
 

+/* Compute the lower bound LOW and upper bound UP for the parameter
+   PARAM in scop SCOP based on the constraints in the context.  */
+
+static void
+compute_bounds_for_param (scop_p scop, int param, mpz_t low, mpz_t up)
+{
+  ppl_Linear_Expression_t le;
+
+  /* Prepare the linear expression corresponding to the parameter that
+     we want to maximize/minimize.  */
+  ppl_new_Linear_Expression_with_dimension (&le, scop_nb_params (scop));
+  ppl_set_coef (le, param, 1);
+
+  ppl_max_for_le_pointset (SCOP_CONTEXT (scop), le, up);
+  ppl_min_for_le_pointset (SCOP_CONTEXT (scop), le, low);
+  ppl_delete_Linear_Expression (le);
+}
+

 /* Compute the lower bound LOW and upper bound UP for the induction
    variable at LEVEL for the statement PBB, based on the transformed
    scattering of PBB: T|I|G|Cst, with T the scattering transform, I
 /* Compute the lower bound LOW and upper bound UP for the induction
    variable at LEVEL for the statement PBB, based on the transformed
    scattering of PBB: T|I|G|Cst, with T the scattering transform, I


@@ -708,62 +781,34 @@ compute_bounds_for_level (poly_bb_p pbb, int level, mpz_t low, mpz_t up)
       + pbb_dim_iter_domain (pbb) + pbb_nb_params (pbb);
 
     ppl_new_Linear_Expression_with_dimension (&le, dim);
       + pbb_dim_iter_domain (pbb) + pbb_nb_params (pbb);
 
     ppl_new_Linear_Expression_with_dimension (&le, dim);

-    ppl_set_coef (le, 2 * level + 1, 1);
+    ppl_set_coef (le, psct_dynamic_dim (pbb, level), 1);

   }
 
   ppl_max_for_le_pointset (ps, le, up);
   ppl_min_for_le_pointset (ps, le, low);
   }
 
   ppl_max_for_le_pointset (ps, le, up);
   ppl_min_for_le_pointset (ps, le, low);

+  ppl_delete_Linear_Expression (le);
+  ppl_delete_Pointset_Powerset_C_Polyhedron (ps);

 }
 
 }
 

-/* Compute the type for the induction variable at LEVEL for the
-   statement PBB, based on the transformed schedule of PBB.  OLD_TYPE
-   is the type of the old induction variable for that loop.  */
-
-static tree
-compute_type_for_level_1 (poly_bb_p pbb, int level, tree old_type)
-{
-  mpz_t low, up;
-  tree type;
-
-  value_init (low);
-  value_init (up);
-
-  compute_bounds_for_level (pbb, level, low, up);
-  type = gcc_type_for_interval (low, up, old_type);
-
-  value_clear (low);
-  value_clear (up);
-  return type;
-}
-
-/* Compute the type for the induction variable at LEVEL for the
-   statement PBB, based on the transformed schedule of PBB.  */
-
-static tree
-compute_type_for_level (poly_bb_p pbb, int level)
-{
-  tree oldiv = pbb_to_depth_to_oldiv (pbb, level);
-  tree type = TREE_TYPE (oldiv);
+/* Walks a CLAST and returns the first statement in the body of a
+   loop.

 
 

-  if (type && POINTER_TYPE_P (type))
-    {
-#ifdef ENABLE_CHECKING
-      tree ctype = compute_type_for_level_1 (pbb, level, type);
+   FIXME: This function should not be used to get a PBB in the STMT
+   loop in order to find out the iteration domain of the loop: the
+   counter example from Tobias is:

 
 

-      /* In the case of a pointer type, check that after the loop
-        transform, the lower and the upper bounds of the type fit the
-        oldiv pointer type.  */
-      gcc_assert (TYPE_PRECISION (type) >= TYPE_PRECISION (ctype)
-                 && integer_zerop (lower_bound_in_type (ctype, ctype)));
-#endif
-      return type;
-    }
+   | for (i = 0; i < 100; i++)
+   |   {
+   |     if (i == 0)
+   |       S1;
+   |     S2;
+   |   }

 
 

-  return compute_type_for_level_1 (pbb, level, type);
-}
+   This function would return S1 whose iteration domain contains only
+   one point "i = 0", whereas the iteration domain of S2 has 100 points.

 
 

-/* Walks a CLAST and returns the first statement in the body of a
-   loop.  */
+   This should be implemented using some functionality existing in
+   CLooG-ISL.  */

 
 static struct clast_user_stmt *
 clast_get_body_of_loop (struct clast_stmt *stmt)
 
 static struct clast_user_stmt *
 clast_get_body_of_loop (struct clast_stmt *stmt)


@@ -781,6 +826,9 @@ clast_get_body_of_loop (struct clast_stmt *stmt)
   if (CLAST_STMT_IS_A (stmt, stmt_block))
     return clast_get_body_of_loop (((struct clast_block *) stmt)->body);
 
   if (CLAST_STMT_IS_A (stmt, stmt_block))
     return clast_get_body_of_loop (((struct clast_block *) stmt)->body);
 

+  if (CLAST_STMT_IS_A (stmt, stmt_ass))
+    return clast_get_body_of_loop (stmt->next);
+

   gcc_unreachable ();
 }
 
   gcc_unreachable ();
 }
 


@@ -788,17 +836,21 @@ clast_get_body_of_loop (struct clast_stmt *stmt)
    from STMT_FOR.  */
 
 static tree
    from STMT_FOR.  */
 
 static tree

-gcc_type_for_iv_of_clast_loop (struct clast_for *stmt_for, int level,
-                              tree lb_type, tree ub_type)
+type_for_clast_for (struct clast_for *stmt_for, ivs_params_p ip)

 {
 {

-  struct clast_stmt *stmt = (struct clast_stmt *) stmt_for;
-  struct clast_user_stmt *body = clast_get_body_of_loop (stmt);
-  CloogStatement *cs = body->statement;
-  poly_bb_p pbb = (poly_bb_p) cloog_statement_usr (cs);
+  mpz_t bound_one, bound_two;
+  tree lb_type, ub_type;
+
+  mpz_init (bound_one);
+  mpz_init (bound_two);
+
+  lb_type = type_for_clast_expr (stmt_for->LB, ip, bound_one, bound_two);
+  ub_type = type_for_clast_expr (stmt_for->UB, ip, bound_one, bound_two);

 
 

-  return max_signed_precision_type (lb_type, max_precision_type
-                                   (ub_type, compute_type_for_level
-                                    (pbb, level - 1)));
+  mpz_clear (bound_one);
+  mpz_clear (bound_two);
+
+  return max_precision_type (lb_type, ub_type);

 }
 
 /* Creates a new LOOP corresponding to Cloog's STMT.  Inserts an
 }
 
 /* Creates a new LOOP corresponding to Cloog's STMT.  Inserts an


@@ -807,23 +859,19 @@ gcc_type_for_iv_of_clast_loop (struct clast_for *stmt_for, int level,
    becomes the child loop of the OUTER_LOOP.  NEWIVS_INDEX binds
    CLooG's scattering name to the induction variable created for the
    loop of STMT.  The new induction variable is inserted in the NEWIVS
    becomes the child loop of the OUTER_LOOP.  NEWIVS_INDEX binds
    CLooG's scattering name to the induction variable created for the
    loop of STMT.  The new induction variable is inserted in the NEWIVS

-   vector.  */
+   vector and is of type TYPE.  */

 
 static struct loop *
 
 static struct loop *

-graphite_create_new_loop (sese region, edge entry_edge,
-                         struct clast_for *stmt,
-                         loop_p outer, VEC (tree, heap) **newivs,
-                         htab_t newivs_index, htab_t params_index, int level)
+graphite_create_new_loop (edge entry_edge, struct clast_for *stmt,
+                         loop_p outer, tree type, tree lb, tree ub,
+                         int level, ivs_params_p ip)

 {
 {

-  tree lb_type = gcc_type_for_clast_expr (stmt->LB, region, *newivs,
-                                         newivs_index, params_index);
-  tree ub_type = gcc_type_for_clast_expr (stmt->UB, region, *newivs,
-                                         newivs_index, params_index);
-  tree type = gcc_type_for_iv_of_clast_loop (stmt, level, lb_type, ub_type);
-  tree lb = clast_to_gcc_expression (type, stmt->LB, region, *newivs,
-                                    newivs_index, params_index);
-  tree ub = clast_to_gcc_expression (type, stmt->UB, region, *newivs,
-                                    newivs_index, params_index);
+  mpz_t low, up;
+
+  struct clast_user_stmt *body
+    = clast_get_body_of_loop ((struct clast_stmt *) stmt);
+  poly_bb_p pbb = (poly_bb_p) cloog_statement_usr (body->statement);
+

   tree stride = gmp_cst_to_tree (type, stmt->stride);
   tree ivvar = create_tmp_var (type, "graphite_IV");
   tree iv, iv_after_increment;
   tree stride = gmp_cst_to_tree (type, stmt->stride);
   tree ivvar = create_tmp_var (type, "graphite_IV");
   tree iv, iv_after_increment;


@@ -833,61 +881,50 @@ graphite_create_new_loop (sese region, edge entry_edge,
 
   add_referenced_var (ivvar);
 
 
   add_referenced_var (ivvar);
 

-  save_clast_name_index (newivs_index, stmt->iterator,
-                        VEC_length (tree, *newivs));
-  VEC_safe_push (tree, heap, *newivs, iv);
+  mpz_init (low);
+  mpz_init (up);
+  compute_bounds_for_level (pbb, level, low, up);
+  save_clast_name_index (ip->newivs_index, stmt->iterator,
+                        VEC_length (tree, *(ip->newivs)), level, low, up);
+  mpz_clear (low);
+  mpz_clear (up);
+  VEC_safe_push (tree, heap, *(ip->newivs), iv);

   return loop;
 }
 
   return loop;
 }
 

-/* Inserts in 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
 
 static void

-build_iv_mapping (htab_t map, sese region,
-                 VEC (tree, heap) *newivs, htab_t newivs_index,
-                 struct clast_user_stmt *user_stmt,
-                 htab_t params_index)
+build_iv_mapping (VEC (tree, heap) *iv_map, struct clast_user_stmt *user_stmt,
+                 ivs_params_p ip)

 {
   struct clast_stmt *t;
 {
   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);
   CloogStatement *cs = user_stmt->statement;
   poly_bb_p pbb = (poly_bb_p) cloog_statement_usr (cs);

+  gimple_bb_p gbb = PBB_BLACK_BOX (pbb);
+  mpz_t bound_one, bound_two;

 
 

-  for (t = user_stmt->substitutions; t; t = t->next, index++)
+  mpz_init (bound_one);
+  mpz_init (bound_two);
+
+  for (t = user_stmt->substitutions; t; t = t->next, depth++)

     {
       struct clast_expr *expr = (struct clast_expr *)
        ((struct clast_assignment *)t)->RHS;
     {
       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 (map, old_name, e);
-    }
-}
-
-/* Helper function for htab_traverse.  */
-
-static int
-copy_renames (void **slot, void *s)
-{
-  struct rename_map_elt_s *entry = (struct rename_map_elt_s *) *slot;
-  htab_t res = (htab_t) s;
-  tree old_name = entry->old_name;
-  tree expr = entry->expr;
-  struct rename_map_elt_s tmp;
-  PTR *x;
-
-  tmp.old_name = old_name;
-  x = htab_find_slot (res, &tmp, INSERT);
+      tree type = type_for_clast_expr (expr, ip, bound_one, bound_two);
+      tree new_name = clast_to_gcc_expression (type, expr, ip);
+      loop_p old_loop = gbb_loop_at_index (gbb, ip->region, depth);

 
 

-  if (x && !*x)
-    *x = new_rename_map_elt (old_name, expr);
+      VEC_replace (tree, iv_map, old_loop->num, new_name);
+    }

 
 

-  return 1;
+  mpz_clear (bound_one);
+  mpz_clear (bound_two);

 }
 
 }
 

-/* 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)
 
 static bb_pbb_def *
 new_bb_pbb_def (basic_block bb, poly_bb_p pbb)


@@ -933,7 +970,7 @@ find_pbb_via_hash (htab_t bb_pbb_mapping, basic_block bb)
   return NULL;
 }
 
   return NULL;
 }
 

-/* Check data dependency in LOOP at scattering level LEVEL.
+/* Check data dependency in LOOP at level LEVEL.

    BB_PBB_MAPPING is a basic_block and it's related poly_bb_p
    mapping.  */
 
    BB_PBB_MAPPING is a basic_block and it's related poly_bb_p
    mapping.  */
 


@@ -970,38 +1007,35 @@ dependency_in_loop_p (loop_p loop, htab_t bb_pbb_mapping, int level)
   return false;
 }
 
   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.
 
 /* 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
    - 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.  */
+   - BB_PBB_MAPPING is is a basic_block and it's related poly_bb_p mapping.  */
+

 static edge
 static edge

-translate_clast_user (sese region, struct clast_user_stmt *stmt, edge next_e,
-                     htab_t rename_map, VEC (tree, heap) **newivs,
-                     htab_t newivs_index, htab_t bb_pbb_mapping,
-                     htab_t params_index)
+translate_clast_user (struct clast_user_stmt *stmt, edge next_e,
+                     htab_t bb_pbb_mapping, ivs_params_p ip)

 {
 {

-  gimple_bb_p gbb;
+  int i, nb_loops;

   basic_block new_bb;
   poly_bb_p pbb = (poly_bb_p) cloog_statement_usr (stmt->statement);
   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;
 
 
   if (GBB_BB (gbb) == ENTRY_BLOCK_PTR)
     return next_e;
 

-  build_iv_mapping (rename_map, region, *newivs, newivs_index, stmt,
-                   params_index);
-  next_e = copy_bb_and_scalar_dependences (GBB_BB (gbb), region,
-                                          next_e, rename_map);
+  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, stmt, ip);
+  next_e = copy_bb_and_scalar_dependences (GBB_BB (gbb), ip->region,
+                                          next_e, iv_map, &gloog_error);
+  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);
   new_bb = next_e->src;
   mark_bb_with_pbb (pbb, new_bb, bb_pbb_mapping);
   update_ssa (TODO_update_ssa);


@@ -1011,72 +1045,58 @@ translate_clast_user (sese region, struct clast_user_stmt *stmt, edge next_e,
 
 /* Creates a new if region protecting the loop to be executed, if the execution
    count is zero (lb > ub).  */
 
 /* Creates a new if region protecting the loop to be executed, if the execution
    count is zero (lb > ub).  */

+

 static edge
 static edge

-graphite_create_new_loop_guard (sese region, edge entry_edge,
-                               struct clast_for *stmt,
-                               VEC (tree, heap) *newivs,
-                               htab_t newivs_index, htab_t params_index)
+graphite_create_new_loop_guard (edge entry_edge, struct clast_for *stmt,
+                               tree *type, tree *lb, tree *ub,
+                               ivs_params_p ip)

 {
   tree cond_expr;
   edge exit_edge;
 {
   tree cond_expr;
   edge exit_edge;

-  tree lb_type = gcc_type_for_clast_expr (stmt->LB, region, newivs,
-                                         newivs_index, params_index);
-  tree ub_type = gcc_type_for_clast_expr (stmt->UB, region, newivs,
-                                         newivs_index, params_index);
-  tree type = max_precision_type (lb_type, ub_type);
-  tree lb = clast_to_gcc_expression (type, stmt->LB, region, newivs,
-                                    newivs_index, params_index);
-  tree ub = clast_to_gcc_expression (type, stmt->UB, region, newivs,
-                                    newivs_index, params_index);
-  tree ub_one;
-
-  /* Adding +1 and using LT_EXPR helps with loop latches that have a
-     loop iteration count of "PARAMETER - 1".  For PARAMETER == 0 this becomes
-     2^{32|64}, and the condition lb <= ub is true, even if we do not want this.
-     However lb < ub + 1 is false, as expected.  */
-  tree one;
-  mpz_t gmp_one;
-  
-  mpz_init (gmp_one);
-  mpz_set_si (gmp_one, 1);
-  one = gmp_cst_to_tree (type, gmp_one);
-  mpz_clear (gmp_one);
-
-  ub_one = fold_build2 (POINTER_TYPE_P (type) ? POINTER_PLUS_EXPR : PLUS_EXPR,
-                       type, ub, one);
-
-  /* When ub + 1 wraps around, use lb <= ub.  */
-  if (integer_zerop (ub_one))
-    cond_expr = fold_build2 (LE_EXPR, boolean_type_node, lb, ub);
+
+  *type = type_for_clast_for (stmt, ip);
+  *lb = clast_to_gcc_expression (*type, stmt->LB, ip);
+  *ub = clast_to_gcc_expression (*type, stmt->UB, ip);
+
+  /* When ub is simply a constant or a parameter, use lb <= ub.  */
+  if (TREE_CODE (*ub) == INTEGER_CST || TREE_CODE (*ub) == SSA_NAME)
+    cond_expr = fold_build2 (LE_EXPR, boolean_type_node, *lb, *ub);

   else
   else

-    cond_expr = fold_build2 (LT_EXPR, boolean_type_node, lb, ub_one);
+    {
+      tree one = (POINTER_TYPE_P (*type)
+                 ? convert_to_ptrofftype (integer_one_node)
+                 : fold_convert (*type, integer_one_node));
+      /* Adding +1 and using LT_EXPR helps with loop latches that have a
+        loop iteration count of "PARAMETER - 1".  For PARAMETER == 0 this becomes
+        2^k-1 due to integer overflow, and the condition lb <= ub is true,
+        even if we do not want this.  However lb < ub + 1 is false, as
+        expected.  */
+      tree ub_one = fold_build2 (POINTER_TYPE_P (*type) ? POINTER_PLUS_EXPR
+                                : PLUS_EXPR, *type, *ub, one);
+
+      cond_expr = fold_build2 (LT_EXPR, boolean_type_node, *lb, ub_one);
+    }

 
   exit_edge = create_empty_if_region_on_edge (entry_edge, cond_expr);
 
   return exit_edge;
 }
 
 
   exit_edge = create_empty_if_region_on_edge (entry_edge, cond_expr);
 
   return exit_edge;
 }
 

+static edge
+translate_clast (loop_p, struct clast_stmt *, edge, htab_t, int, ivs_params_p);

 
 /* Create the loop for a clast for statement.
 
 
 /* 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.
    - 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.  */
+   - BB_PBB_MAPPING is is a basic_block and it's related poly_bb_p mapping.  */
+

 static edge
 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,
-                         htab_t newivs_index, htab_t bb_pbb_mapping,
-                         int level, htab_t params_index)
+translate_clast_for_loop (loop_p context_loop, struct clast_for *stmt,
+                         edge next_e, htab_t bb_pbb_mapping, int level,
+                         tree type, tree lb, tree ub, ivs_params_p ip)

 {
 {

-  struct loop *loop = graphite_create_new_loop (region, next_e, stmt,
-                                               context_loop, newivs,
-                                               newivs_index, params_index,
-                                               level);
+  struct loop *loop = graphite_create_new_loop (next_e, stmt, context_loop,
+                                               type, lb, ub, level, ip);

   edge last_e = single_exit (loop);
   edge to_body = single_succ_edge (loop->header);
   basic_block after = to_body->dest;
   edge last_e = single_exit (loop);
   edge to_body = single_succ_edge (loop->header);
   basic_block after = to_body->dest;


@@ -1085,19 +1105,13 @@ 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.  */
   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,
-                           newivs, newivs_index, bb_pbb_mapping, level + 1,
-                           params_index);
+  next_e = translate_clast (loop, stmt->body, to_body, bb_pbb_mapping,
+                           level + 1, ip);

   redirect_edge_succ_nodup (next_e, after);
   set_immediate_dominator (CDI_DOMINATORS, next_e->dest, next_e->src);
 
   redirect_edge_succ_nodup (next_e, after);
   set_immediate_dominator (CDI_DOMINATORS, next_e->dest, next_e->src);
 

-   /* Remove from rename_map all the tuples containing variables
-      defined in loop's body.  */
-  insert_loop_close_phis (rename_map, loop);
-

   if (flag_loop_parallelize_all
   if (flag_loop_parallelize_all

-      && !dependency_in_loop_p (loop, bb_pbb_mapping,
-                               get_scattering_level (level)))
+      && !dependency_in_loop_p (loop, bb_pbb_mapping, level))

     loop->can_be_parallel = true;
 
   return last_e;
     loop->can_be_parallel = true;
 
   return last_e;


@@ -1107,82 +1121,77 @@ translate_clast_for_loop (sese region, loop_p context_loop,
    protecting the loop, if it is executed zero times.  In this guard we create
    the real loop structure.
 
    protecting the loop, if it is executed zero times.  In this guard we create
    the real loop structure.
 

-   - REGION is the sese region we used to generate the scop.

    - NEXT_E is the edge where new generated code should be attached.
    - 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.  */
+   - BB_PBB_MAPPING is is a basic_block and it's related poly_bb_p mapping.  */
+

 static edge
 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,
-                    htab_t newivs_index, htab_t bb_pbb_mapping, int level,
-                    htab_t params_index)
+translate_clast_for (loop_p context_loop, struct clast_for *stmt, edge next_e,
+                    htab_t bb_pbb_mapping, int level, ivs_params_p ip)

 {
 {

-  edge last_e = graphite_create_new_loop_guard (region, next_e, stmt, *newivs,
-                                               newivs_index, params_index);
-
+  tree type, lb, ub;
+  edge last_e = graphite_create_new_loop_guard (next_e, stmt, &type,
+                                               &lb, &ub, ip);

   edge true_e = get_true_edge_from_guard_bb (next_e->dest);
   edge true_e = get_true_edge_from_guard_bb (next_e->dest);

-  edge false_e = get_false_edge_from_guard_bb (next_e->dest);
-  edge exit_true_e = single_succ_edge (true_e->dest);
-  edge exit_false_e = single_succ_edge (false_e->dest);

 
 

-  htab_t before_guard = htab_create (10, rename_map_elt_info,
-                                    eq_rename_map_elts, free);
-  htab_traverse (rename_map, copy_renames, before_guard);
+  translate_clast_for_loop (context_loop, stmt, true_e, bb_pbb_mapping, level,
+                           type, lb, ub, ip);
+  return last_e;
+}
+
+/* Translates a clast assignment STMT to gimple.
+
+   - NEXT_E is the edge where new generated code should be attached.
+   - BB_PBB_MAPPING is is a basic_block and it's related poly_bb_p mapping.  */

 
 

-  next_e = translate_clast_for_loop (region, context_loop, stmt, true_e,
-                                    rename_map, newivs,
-                                    newivs_index, bb_pbb_mapping, level,
-                                    params_index);
+static edge
+translate_clast_assignment (struct clast_assignment *stmt, edge next_e,
+                           int level, ivs_params_p ip)
+{
+  gimple_seq stmts;
+  mpz_t bound_one, bound_two;
+  tree type, new_name, var;
+  edge res = single_succ_edge (split_edge (next_e));
+  struct clast_expr *expr = (struct clast_expr *) stmt->RHS;
+
+  mpz_init (bound_one);
+  mpz_init (bound_two);
+  type = type_for_clast_expr (expr, ip, bound_one, bound_two);
+  var = create_tmp_var (type, "graphite_var");
+  new_name = force_gimple_operand (clast_to_gcc_expression (type, expr, ip),
+                                  &stmts, true, var);
+  add_referenced_var (var);
+  if (stmts)
+    {
+      gsi_insert_seq_on_edge (next_e, stmts);
+      gsi_commit_edge_inserts ();
+    }

 
 

-  insert_guard_phis (last_e->src, exit_true_e, exit_false_e,
-                    before_guard, rename_map);
+  save_clast_name_index (ip->newivs_index, stmt->LHS,
+                        VEC_length (tree, *(ip->newivs)), level,
+                        bound_one, bound_two);
+  VEC_safe_push (tree, heap, *(ip->newivs), new_name);

 
 

-  htab_delete (before_guard);
+  mpz_clear (bound_one);
+  mpz_clear (bound_two);

 
 

-  return last_e;
+  return res;

 }
 
 /* Translates a clast guard statement STMT to gimple.
 
 }
 
 /* Translates a clast guard 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
    - 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.  */
+   - BB_PBB_MAPPING is is a basic_block and it's related poly_bb_p mapping.  */
+

 static edge
 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,
-                      htab_t newivs_index, htab_t bb_pbb_mapping, int level,
-                      htab_t params_index)
+translate_clast_guard (loop_p context_loop, struct clast_guard *stmt,
+                      edge next_e, htab_t bb_pbb_mapping, int level,
+                      ivs_params_p ip)

 {
 {

-  edge last_e = graphite_create_new_guard (region, next_e, stmt, *newivs,
-                                          newivs_index, params_index);
-
+  edge last_e = graphite_create_new_guard (next_e, stmt, ip);

   edge true_e = get_true_edge_from_guard_bb (next_e->dest);
   edge true_e = get_true_edge_from_guard_bb (next_e->dest);

-  edge false_e = get_false_edge_from_guard_bb (next_e->dest);
-  edge exit_true_e = single_succ_edge (true_e->dest);
-  edge exit_false_e = single_succ_edge (false_e->dest);
-
-  htab_t before_guard = htab_create (10, rename_map_elt_info,
-                                    eq_rename_map_elts, free);
-  htab_traverse (rename_map, copy_renames, before_guard);
-
-  next_e = translate_clast (region, context_loop, stmt->then, true_e,
-                           rename_map, newivs, newivs_index, bb_pbb_mapping,
-                           level, params_index);
-
-  insert_guard_phis (last_e->src, exit_true_e, exit_false_e,
-                    before_guard, rename_map);
-
-  htab_delete (before_guard);

 
 

+  translate_clast (context_loop, stmt->then, true_e, bb_pbb_mapping, level, ip);

   return last_e;
 }
 
   return last_e;
 }
 


@@ -1191,14 +1200,11 @@ 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
 
    - 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.  */
    - BB_PBB_MAPPING is is a basic_block and it's related poly_bb_p mapping.  */

+

 static edge
 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,
-                htab_t newivs_index, htab_t bb_pbb_mapping, int level,
-                htab_t params_index)
+translate_clast (loop_p context_loop, struct clast_stmt *stmt, edge next_e,
+                htab_t bb_pbb_mapping, int level, ivs_params_p ip)

 {
   if (!stmt)
     return next_e;
 {
   if (!stmt)
     return next_e;


@@ -1207,49 +1213,45 @@ translate_clast (sese region, loop_p context_loop, struct clast_stmt *stmt,
     ; /* Do nothing.  */
 
   else if (CLAST_STMT_IS_A (stmt, stmt_user))
     ; /* Do nothing.  */
 
   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,
-                                  bb_pbb_mapping, params_index);
+    next_e = translate_clast_user ((struct clast_user_stmt *) stmt,
+                                  next_e, bb_pbb_mapping, ip);

 
   else if (CLAST_STMT_IS_A (stmt, stmt_for))
 
   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,
-                                 bb_pbb_mapping, level, params_index);
+    next_e = translate_clast_for (context_loop, (struct clast_for *) stmt,
+                                 next_e, bb_pbb_mapping, level, ip);

 
   else if (CLAST_STMT_IS_A (stmt, stmt_guard))
 
   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,
-                                   bb_pbb_mapping, level, params_index);
+    next_e = translate_clast_guard (context_loop, (struct clast_guard *) stmt,
+                                   next_e, bb_pbb_mapping, level, ip);

 
   else if (CLAST_STMT_IS_A (stmt, stmt_block))
 
   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,
-                             bb_pbb_mapping, level, params_index);
+    next_e = translate_clast (context_loop, ((struct clast_block *) stmt)->body,
+                             next_e, bb_pbb_mapping, level, ip);
+
+  else if (CLAST_STMT_IS_A (stmt, stmt_ass))
+    next_e = translate_clast_assignment ((struct clast_assignment *) stmt,
+                                        next_e, level, ip);

   else
     gcc_unreachable();
 
   recompute_all_dominators ();
   graphite_verify ();
 
   else
     gcc_unreachable();
 
   recompute_all_dominators ();
   graphite_verify ();
 

-  return translate_clast (region, context_loop, stmt->next, next_e,
-                         rename_map, newivs, newivs_index,
-                         bb_pbb_mapping, level, params_index);
+  return translate_clast (context_loop, stmt->next, next_e, bb_pbb_mapping,
+                         level, ip);

 }
 
 /* Free the SCATTERING domain list.  */
 
 static void
 }
 
 /* Free the SCATTERING domain list.  */
 
 static void

-free_scattering (CloogDomainList *scattering)
+free_scattering (CloogScatteringList *scattering)

 {
   while (scattering)
     {
 {
   while (scattering)
     {

-      CloogDomain *dom = cloog_domain (scattering);
-      CloogDomainList *next = cloog_next_domain (scattering);
+      CloogScattering *dom = cloog_scattering (scattering);
+      CloogScatteringList *next = cloog_next_scattering (scattering);

 
 

-      cloog_domain_free (dom);
+      cloog_scattering_free (dom);

       free (scattering);
       scattering = next;
     }
       free (scattering);
       scattering = next;
     }


@@ -1275,7 +1277,7 @@ initialize_cloog_names (scop_p scop, CloogProgram *prog)
 
   for (i = 0; i < nb_parameters; i++)
     {
 
   for (i = 0; i < nb_parameters; i++)
     {

-      tree param = VEC_index (tree, SESE_PARAMS(region), i);
+      tree param = VEC_index (tree, SESE_PARAMS (region), i);

       const char *name = get_name (param);
       int len;
 
       const char *name = get_name (param);
       int len;
 


@@ -1316,31 +1318,59 @@ initialize_cloog_names (scop_p scop, CloogProgram *prog)
                              scattering);
 }
 
                              scattering);
 }
 

+/* Initialize a CLooG input file.  */
+
+static FILE *
+init_cloog_input_file (int scop_number)
+{
+  FILE *graphite_out_file;
+  int len = strlen (dump_base_name);
+  char *dumpname = XNEWVEC (char, len + 25);
+  char *s_scop_number = XNEWVEC (char, 15);
+
+  memcpy (dumpname, dump_base_name, len + 1);
+  strip_off_ending (dumpname, len);
+  sprintf (s_scop_number, ".%d", scop_number);
+  strcat (dumpname, s_scop_number);
+  strcat (dumpname, ".cloog");
+  graphite_out_file = fopen (dumpname, "w+b");
+
+  if (graphite_out_file == 0)
+    fatal_error ("can%'t open %s for writing: %m", dumpname);
+
+  free (dumpname);
+
+  return graphite_out_file;
+}
+

 /* Build cloog program for SCoP.  */
 
 static void
 /* Build cloog program for SCoP.  */
 
 static void

-build_cloog_prog (scop_p scop, CloogProgram *prog)
+build_cloog_prog (scop_p scop, CloogProgram *prog,
+                  CloogOptions *options)

 {
   int i;
   int max_nb_loops = scop_max_loop_depth (scop);
   poly_bb_p pbb;
   CloogLoop *loop_list = NULL;
   CloogBlockList *block_list = NULL;
 {
   int i;
   int max_nb_loops = scop_max_loop_depth (scop);
   poly_bb_p pbb;
   CloogLoop *loop_list = NULL;
   CloogBlockList *block_list = NULL;

-  CloogDomainList *scattering = NULL;
+  CloogScatteringList *scattering = NULL;

   int nbs = 2 * max_nb_loops + 1;
   int *scaldims;
 
   cloog_program_set_context
   int nbs = 2 * max_nb_loops + 1;
   int *scaldims;
 
   cloog_program_set_context

-    (prog, new_Cloog_Domain_from_ppl_Pointset_Powerset (SCOP_CONTEXT (scop)));
+    (prog, new_Cloog_Domain_from_ppl_Pointset_Powerset (SCOP_CONTEXT (scop),
+      scop_nb_params (scop), cloog_state));

   nbs = unify_scattering_dimensions (scop);
   scaldims = (int *) xmalloc (nbs * (sizeof (int)));
   cloog_program_set_nb_scattdims (prog, nbs);
   initialize_cloog_names (scop, prog);
 
   nbs = unify_scattering_dimensions (scop);
   scaldims = (int *) xmalloc (nbs * (sizeof (int)));
   cloog_program_set_nb_scattdims (prog, nbs);
   initialize_cloog_names (scop, prog);
 

-  for (i = 0; VEC_iterate (poly_bb_p, SCOP_BBS (scop), i, pbb); i++)
+  FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)

     {
       CloogStatement *stmt;
       CloogBlock *block;
     {
       CloogStatement *stmt;
       CloogBlock *block;

+      CloogDomain *dom;

 
       /* Dead code elimination: when the domain of a PBB is empty,
         don't generate code for the PBB.  */
 
       /* Dead code elimination: when the domain of a PBB is empty,
         don't generate code for the PBB.  */


@@ -1348,17 +1378,18 @@ build_cloog_prog (scop_p scop, CloogProgram *prog)
        continue;
 
       /* Build the new statement and its block.  */
        continue;
 
       /* Build the new statement and its block.  */

-      stmt = cloog_statement_alloc (pbb_index (pbb));
+      stmt = cloog_statement_alloc (cloog_state, pbb_index (pbb));
+      dom = new_Cloog_Domain_from_ppl_Pointset_Powerset (PBB_DOMAIN (pbb),
+                                                         scop_nb_params (scop),
+                                                         cloog_state);

       block = cloog_block_alloc (stmt, 0, NULL, pbb_dim_iter_domain (pbb));
       cloog_statement_set_usr (stmt, pbb);
 
       /* Build loop list.  */
       {
       block = cloog_block_alloc (stmt, 0, NULL, pbb_dim_iter_domain (pbb));
       cloog_statement_set_usr (stmt, pbb);
 
       /* Build loop list.  */
       {

-        CloogLoop *new_loop_list = cloog_loop_malloc ();
+        CloogLoop *new_loop_list = cloog_loop_malloc (cloog_state);

         cloog_loop_set_next (new_loop_list, loop_list);
         cloog_loop_set_next (new_loop_list, loop_list);

-        cloog_loop_set_domain
-         (new_loop_list,
-          new_Cloog_Domain_from_ppl_Pointset_Powerset (PBB_DOMAIN (pbb)));
+        cloog_loop_set_domain (new_loop_list, dom);

         cloog_loop_set_block (new_loop_list, block);
         loop_list = new_loop_list;
       }
         cloog_loop_set_block (new_loop_list, block);
         loop_list = new_loop_list;
       }


@@ -1375,16 +1406,18 @@ build_cloog_prog (scop_p scop, CloogProgram *prog)
       /* Build scattering list.  */
       {
         /* XXX: Replace with cloog_domain_list_alloc(), when available.  */
       /* Build scattering list.  */
       {
         /* XXX: Replace with cloog_domain_list_alloc(), when available.  */

-        CloogDomainList *new_scattering
-         = (CloogDomainList *) xmalloc (sizeof (CloogDomainList));
+        CloogScatteringList *new_scattering
+         = (CloogScatteringList *) xmalloc (sizeof (CloogScatteringList));

         ppl_Polyhedron_t scat;
         ppl_Polyhedron_t scat;

-       CloogDomain *dom;
+       CloogScattering *dom;

 
        scat = PBB_TRANSFORMED_SCATTERING (pbb);
 
        scat = PBB_TRANSFORMED_SCATTERING (pbb);

-       dom = new_Cloog_Domain_from_ppl_Polyhedron (scat);
+        dom = new_Cloog_Scattering_from_ppl_Polyhedron
+          (scat, scop_nb_params (scop), pbb_nb_scattering_transform (pbb),
+           cloog_state);

 
 

-        cloog_set_next_domain (new_scattering, scattering);
-        cloog_set_domain (new_scattering, dom);
+        cloog_set_next_scattering (new_scattering, scattering);
+        cloog_set_scattering (new_scattering, dom);

         scattering = new_scattering;
       }
     }
         scattering = new_scattering;
       }
     }


@@ -1398,10 +1431,21 @@ build_cloog_prog (scop_p scop, CloogProgram *prog)
   cloog_program_set_scaldims (prog, scaldims);
 
   /* Extract scalar dimensions to simplify the code generation problem.  */
   cloog_program_set_scaldims (prog, scaldims);
 
   /* Extract scalar dimensions to simplify the code generation problem.  */

-  cloog_program_extract_scalars (prog, scattering);
+  cloog_program_extract_scalars (prog, scattering, options);
+
+  /* Dump a .cloog input file, if requested.  This feature is only
+     enabled in the Graphite branch.  */
+  if (0)
+    {
+      static size_t file_scop_number = 0;
+      FILE *cloog_file = init_cloog_input_file (file_scop_number);
+
+      cloog_program_dump_cloog (cloog_file, prog, scattering);
+      ++file_scop_number;
+    }

 
   /* Apply scattering.  */
 
   /* Apply scattering.  */

-  cloog_program_scatter (prog, scattering);
+  cloog_program_scatter (prog, scattering, options);

   free_scattering (scattering);
 
   /* Iterators corresponding to scalar dimensions have to be extracted.  */
   free_scattering (scattering);
 
   /* Iterators corresponding to scalar dimensions have to be extracted.  */


@@ -1429,12 +1473,12 @@ build_cloog_prog (scop_p scop, CloogProgram *prog)
 static CloogOptions *
 set_cloog_options (void)
 {
 static CloogOptions *
 set_cloog_options (void)
 {

-  CloogOptions *options = cloog_options_malloc ();
+  CloogOptions *options = cloog_options_malloc (cloog_state);

 
   /* Change cloog output language to C.  If we do use FORTRAN instead, cloog
      will stop e.g. with "ERROR: unbounded loops not allowed in FORTRAN.", if
      we pass an incomplete program to cloog.  */
 
   /* Change cloog output language to C.  If we do use FORTRAN instead, cloog
      will stop e.g. with "ERROR: unbounded loops not allowed in FORTRAN.", if
      we pass an incomplete program to cloog.  */

-  options->language = LANGUAGE_C;
+  options->language = CLOOG_LANGUAGE_C;

 
   /* Enable complex equality spreading: removes dummy statements
      (assignments) in the generated code which repeats the
 
   /* Enable complex equality spreading: removes dummy statements
      (assignments) in the generated code which repeats the


@@ -1442,9 +1486,14 @@ set_cloog_options (void)
      GLooG.  */
   options->esp = 1;
 
      GLooG.  */
   options->esp = 1;
 

+#ifdef CLOOG_ORG
+  /* Silence CLooG to avoid failing tests due to debug output to stderr.  */
+  options->quiet = 1;
+#else

   /* Enable C pretty-printing mode: normalizes the substitution
      equations for statements.  */
   options->cpp = 1;
   /* Enable C pretty-printing mode: normalizes the substitution
      equations for statements.  */
   options->cpp = 1;

+#endif

 
   /* Allow cloog to build strides with a stride width different to one.
      This example has stride = 4:
 
   /* Allow cloog to build strides with a stride width different to one.
      This example has stride = 4:


@@ -1475,7 +1524,7 @@ print_clast_stmt (FILE *file, struct clast_stmt *stmt)
 {
   CloogOptions *options = set_cloog_options ();
 
 {
   CloogOptions *options = set_cloog_options ();
 

-  pprint (file, stmt, 0, options);
+  clast_pprint (file, stmt, 0, options);

   cloog_options_free (options);
 }
 
   cloog_options_free (options);
 }
 


@@ -1499,7 +1548,7 @@ scop_to_clast (scop_p scop)
 
   /* Connect new cloog prog generation to graphite.  */
   pc.prog = cloog_program_malloc ();
 
   /* Connect new cloog prog generation to graphite.  */
   pc.prog = cloog_program_malloc ();

-  build_cloog_prog (scop, pc.prog);
+  build_cloog_prog (scop, pc.prog, options);

   pc.prog = cloog_program_generate (pc.prog, options);
   pc.stmt = cloog_clast_create (pc.prog, options);
 
   pc.prog = cloog_program_generate (pc.prog, options);
   pc.stmt = cloog_clast_create (pc.prog, options);
 


@@ -1513,6 +1562,7 @@ void
 print_generated_program (FILE *file, scop_p scop)
 {
   CloogOptions *options = set_cloog_options ();
 print_generated_program (FILE *file, scop_p scop)
 {
   CloogOptions *options = set_cloog_options ();

+

   cloog_prog_clast pc = scop_to_clast (scop);
 
   fprintf (file, "       (prog: \n");
   cloog_prog_clast pc = scop_to_clast (scop);
 
   fprintf (file, "       (prog: \n");


@@ -1520,7 +1570,7 @@ print_generated_program (FILE *file, scop_p scop)
   fprintf (file, "       )\n");
 
   fprintf (file, "       (clast: \n");
   fprintf (file, "       )\n");
 
   fprintf (file, "       (clast: \n");

-  pprint (file, pc.stmt, 0, options);
+  clast_pprint (file, pc.stmt, 0, options);

   fprintf (file, "       )\n");
 
   cloog_options_free (options);
   fprintf (file, "       )\n");
 
   cloog_options_free (options);


@@ -1540,14 +1590,25 @@ debug_generated_program (scop_p scop)
    back from CLooG names to GCC trees.  */
 
 static void
    back from CLooG names to GCC trees.  */
 
 static void

-create_params_index (htab_t index_table, CloogProgram *prog) {
+create_params_index (scop_p scop, htab_t index_table, CloogProgram *prog) {

   CloogNames* names = cloog_program_names (prog);
   int nb_parameters = cloog_names_nb_parameters (names);
   char **parameters = cloog_names_parameters (names);
   int i;
   CloogNames* names = cloog_program_names (prog);
   int nb_parameters = cloog_names_nb_parameters (names);
   char **parameters = cloog_names_parameters (names);
   int i;

+  mpz_t bound_one, bound_two;
+
+  mpz_init (bound_one);
+  mpz_init (bound_two);

 
   for (i = 0; i < nb_parameters; i++)
 
   for (i = 0; i < nb_parameters; i++)

-    save_clast_name_index (index_table, parameters[i], i);
+    {
+      compute_bounds_for_param (scop, i, bound_one, bound_two);
+      save_clast_name_index (index_table, parameters[i], i, i,
+                            bound_one, bound_two);
+    }
+
+  mpz_clear (bound_one);
+  mpz_clear (bound_two);

 }
 
 /* GIMPLE Loop Generator: generates loops from STMT in GIMPLE form for
 }
 
 /* GIMPLE Loop Generator: generates loops from STMT in GIMPLE form for


@@ -1556,15 +1617,15 @@ create_params_index (htab_t index_table, CloogProgram *prog) {
 */
 
 bool
 */
 
 bool

-gloog (scop_p scop, VEC (scop_p, heap) *scops, htab_t bb_pbb_mapping)
+gloog (scop_p scop, htab_t bb_pbb_mapping)

 {
   VEC (tree, heap) *newivs = VEC_alloc (tree, heap, 10);
   loop_p context_loop;
   sese region = SCOP_REGION (scop);
   ifsese if_region = NULL;
 {
   VEC (tree, heap) *newivs = VEC_alloc (tree, heap, 10);
   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;
   cloog_prog_clast pc;

-  int i;
+  struct ivs_params ip;

 
   timevar_push (TV_GRAPHITE_CODE_GEN);
   gloog_error = false;
 
   timevar_push (TV_GRAPHITE_CODE_GEN);
   gloog_error = false;


@@ -1590,29 +1651,23 @@ gloog (scop_p scop, VEC (scop_p, heap) *scops, htab_t bb_pbb_mapping)
   graphite_verify ();
 
   context_loop = SESE_ENTRY (region)->src->loop_father;
   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,
   newivs_index = htab_create (10, clast_name_index_elt_info,

-                             eq_clast_name_indexes, free);
+                             eq_clast_name_indexes, free_clast_name_index);

   params_index = htab_create (10, clast_name_index_elt_info,
   params_index = htab_create (10, clast_name_index_elt_info,

-                             eq_clast_name_indexes, free);
+                             eq_clast_name_indexes, free_clast_name_index);

 
 

-  create_params_index (params_index, pc.prog);
+  create_params_index (scop, params_index, pc.prog);

 
 

-  translate_clast (region, context_loop, pc.stmt,
-                  if_region->true_region->entry,
-                  rename_map, &newivs, newivs_index,
-                  bb_pbb_mapping, 1, params_index);
-  graphite_verify ();
-  sese_adjust_liveout_phis (region, rename_map,
-                           if_region->region->exit->src,
-                           if_region->false_region->exit,
-                           if_region->true_region->exit);
-  scev_reset_htab ();
-  rename_nb_iterations (rename_map);
-
-  for (i = 0; VEC_iterate (scop_p, scops, i, scop); i++)
-    rename_sese_parameters (rename_map, SCOP_REGION (scop));
+  ip.newivs = &newivs;
+  ip.newivs_index = newivs_index;
+  ip.params = SESE_PARAMS (region);
+  ip.params_index = params_index;
+  ip.region = region;

 
 

+  translate_clast (context_loop, pc.stmt, if_region->true_region->entry,
+                  bb_pbb_mapping, 0, &ip);
+  graphite_verify ();
+  scev_reset ();

   recompute_all_dominators ();
   graphite_verify ();
 
   recompute_all_dominators ();
   graphite_verify ();
 


@@ -1623,7 +1678,6 @@ gloog (scop_p scop, VEC (scop_p, heap) *scops, htab_t bb_pbb_mapping)
   free (if_region->region);
   free (if_region);
 
   free (if_region->region);
   free (if_region);
 

-  htab_delete (rename_map);

   htab_delete (newivs_index);
   htab_delete (params_index);
   VEC_free (tree, heap, newivs);
   htab_delete (newivs_index);
   htab_delete (params_index);
   VEC_free (tree, heap, newivs);


@@ -1647,5 +1701,4 @@ gloog (scop_p scop, VEC (scop_p, heap) *scops, htab_t bb_pbb_mapping)
 
   return !gloog_error;
 }
 
   return !gloog_error;
 }

-

 #endif
 #endif