CbC/CbC_gcc: gcc/graphite-sese-to-poly.c comparison

comparison gcc/graphite-sese-to-poly.c @ 63:b7f97abdc517 gcc-4.6-20100522

update gcc from gcc-4.5.0 to gcc-4.6

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Mon, 24 May 2010 12:47:05 +0900
parents	77e2b8dfacca
children	f6334be47118

comparison

equal deleted inserted replaced

-:3c8a44c06a95
+:b7f97abdc517
 /* Conversion of SESE regions to Polyhedra.
-Copyright (C) 2009 Free Software Foundation, Inc.
+Copyright (C) 2009, 2010 Free Software Foundation, Inc.
 Contributed by Sebastian Pop <sebastian.pop@amd.com>.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify
 loop = loop_containing_stmt (phi);
 if (simple_copy_phi_p (phi))
 {
-/* FIXME: PRE introduces phi nodes like these, for an example,
+/* PRE introduces phi nodes like these, for an example,
 	 see id-5.f in the fortran graphite testsuite:
 	 # prephitmp.85_265 = PHI <prephitmp.85_258(33), prephitmp.85_265(18)>
 */
 remove_simple_copy_phi (psi);
 bb->aux = gbb;
 GBB_BB (gbb) = bb;
 GBB_DATA_REFS (gbb) = drs;
 GBB_CONDITIONS (gbb) = NULL;
 GBB_CONDITION_CASES (gbb) = NULL;
-GBB_CLOOG_IV_TYPES (gbb) = NULL;
 return gbb;
 }
 static void
 /* Frees GBB.  */
 static void
 free_gimple_bb (struct gimple_bb *gbb)
 {
-if (GBB_CLOOG_IV_TYPES (gbb))
-htab_delete (GBB_CLOOG_IV_TYPES (gbb));
 free_data_refs_aux (GBB_DATA_REFS (gbb));
 free_data_refs (GBB_DATA_REFS (gbb));
 VEC_free (gimple, heap, GBB_CONDITIONS (gbb));
 VEC_free (gimple, heap, GBB_CONDITION_CASES (gbb));
 int nb_iterators = pbb_dim_iter_domain (pbb);
 int used_scattering_dimensions = nb_iterators * 2 + 1;
 int nb_params = scop_nb_params (scop);
 ppl_Coefficient_t c;
 ppl_dimension_type dim = scattering_dimensions + nb_iterators + nb_params;
-Value v;
+mpz_t v;
 gcc_assert (scattering_dimensions >= used_scattering_dimensions);
-value_init (v);
+mpz_init (v);
 ppl_new_Coefficient (&c);
 PBB_TRANSFORMED (pbb) = poly_scattering_new ();
 ppl_new_C_Polyhedron_from_space_dimension
 (&PBB_TRANSFORMED_SCATTERING (pbb), dim, 0);
 {
 ppl_Constraint_t cstr;
 ppl_Linear_Expression_t expr;
 ppl_new_Linear_Expression_with_dimension (&expr, dim);
-value_set_si (v, 1);
+mpz_set_si (v, 1);
 ppl_assign_Coefficient_from_mpz_t (c, v);
 ppl_Linear_Expression_add_to_coefficient (expr, i, c);
 /* Textual order inside this loop.  */
 if ((i % 2) == 0)
 	{
 	  ppl_Linear_Expression_coefficient (static_schedule, i / 2, c);
 	  ppl_Coefficient_to_mpz_t (c, v);
-	  value_oppose (v, v);
+	  mpz_neg (v, v);
 	  ppl_assign_Coefficient_from_mpz_t (c, v);
 	  ppl_Linear_Expression_add_to_inhomogeneous (expr, c);
 	}
 /* Iterations of this loop.  */
 else /* if ((i % 2) == 1) */
 	{
 	  int loop = (i - 1) / 2;
-	  value_set_si (v, -1);
+	  mpz_set_si (v, -1);
 	  ppl_assign_Coefficient_from_mpz_t (c, v);
 	  ppl_Linear_Expression_add_to_coefficient
 	    (expr, scattering_dimensions + loop, c);
 	}
 ppl_Polyhedron_add_constraint (PBB_TRANSFORMED_SCATTERING (pbb), cstr);
 ppl_delete_Linear_Expression (expr);
 ppl_delete_Constraint (cstr);
 }
-value_clear (v);
+mpz_clear (v);
 ppl_delete_Coefficient (c);
 PBB_ORIGINAL (pbb) = poly_scattering_copy (PBB_TRANSFORMED (pbb));
 }
 int i;
 poly_bb_p pbb;
 gimple_bb_p previous_gbb = NULL;
 ppl_Linear_Expression_t static_schedule;
 ppl_Coefficient_t c;
-Value v;
+mpz_t v;
-value_init (v);
+mpz_init (v);
 ppl_new_Coefficient (&c);
 ppl_new_Linear_Expression (&static_schedule);
 /* We have to start schedules at 0 on the first component and
 because we cannot compare_prefix_loops against a previous loop,
 prefix will be equal to zero, and that index will be
 incremented before copying.  */
-value_set_si (v, -1);
+mpz_set_si (v, -1);
 ppl_assign_Coefficient_from_mpz_t (c, v);
 ppl_Linear_Expression_add_to_coefficient (static_schedule, 0, c);
 for (i = 0; VEC_iterate (poly_bb_p, SCOP_BBS (scop), i, pbb); i++)
 {
 previous_gbb = gbb;
 ppl_new_Linear_Expression_with_dimension (&common, prefix + 1);
 ppl_assign_Linear_Expression_from_Linear_Expression (common,
 							   static_schedule);
-value_set_si (v, 1);
+mpz_set_si (v, 1);
 ppl_assign_Coefficient_from_mpz_t (c, v);
 ppl_Linear_Expression_add_to_coefficient (common, prefix, c);
 ppl_assign_Linear_Expression_from_Linear_Expression (static_schedule,
 							   common);
 build_pbb_scattering_polyhedrons (common, pbb, nb_scat_dims);
 ppl_delete_Linear_Expression (common);
 }
-value_clear (v);
+mpz_clear (v);
 ppl_delete_Coefficient (c);
 ppl_delete_Linear_Expression (static_schedule);
 }
 /* Add the value K to the dimension D of the linear expression EXPR.  */
 static void
 add_value_to_dim (ppl_dimension_type d, ppl_Linear_Expression_t expr,
-		  Value k)
+		  mpz_t k)
 {
-Value val;
+mpz_t val;
 ppl_Coefficient_t coef;
 ppl_new_Coefficient (&coef);
 ppl_Linear_Expression_coefficient (expr, d, coef);
-value_init (val);
+mpz_init (val);
 ppl_Coefficient_to_mpz_t (coef, val);
-value_addto (val, val, k);
+mpz_add (val, val, k);
 ppl_assign_Coefficient_from_mpz_t (coef, val);
 ppl_Linear_Expression_add_to_coefficient (expr, d, coef);
-value_clear (val);
+mpz_clear (val);
 ppl_delete_Coefficient (coef);
 }
 /* In the context of scop S, scan E, the right hand side of a scalar
 evolution function in loop VAR, and translate it to a linear
 {
 if (expr)
 {
 loop_p loop = get_loop (var);
 ppl_dimension_type l = sese_loop_depth (s, loop) - 1;
-Value val;
+mpz_t val;
 /* Scalar evolutions should happen in the sese region.  */
 gcc_assert (sese_loop_depth (s, loop) > 0);
 /* We can not deal with parametric strides like:
 |
 | for i:
 |   a [i * p] = ...   */
 gcc_assert (TREE_CODE (e) == INTEGER_CST);
-value_init (val);
+mpz_init (val);
-value_set_si (val, int_cst_value (e));
+mpz_set_si (val, int_cst_value (e));
 add_value_to_dim (l, expr, val);
-value_clear (val);
+mpz_clear (val);
 }
 }
 /* Scan the integer constant CST, and add it to the inhomogeneous part of the
 linear expression EXPR.  K is the multiplier of the constant.  */
 static void
-scan_tree_for_params_int (tree cst, ppl_Linear_Expression_t expr, Value k)
+scan_tree_for_params_int (tree cst, ppl_Linear_Expression_t expr, mpz_t k)
 {
-Value val;
+mpz_t val;
 ppl_Coefficient_t coef;
 int v = int_cst_value (cst);
-value_init (val);
+mpz_init (val);
-value_set_si (val, 0);
+mpz_set_si (val, 0);
 /* Necessary to not get "-1 = 2^n - 1". */
 if (v < 0)
-value_sub_int (val, val, -v);
+mpz_sub_ui (val, val, -v);
 else
-value_add_int (val, val, v);
+mpz_add_ui (val, val, v);
-value_multiply (val, val, k);
+mpz_mul (val, val, k);
 ppl_new_Coefficient (&coef);
 ppl_assign_Coefficient_from_mpz_t (coef, val);
 ppl_Linear_Expression_add_to_inhomogeneous (expr, coef);
-value_clear (val);
+mpz_clear (val);
 ppl_delete_Coefficient (coef);
 }
 /* When parameter NAME is in REGION, returns its index in SESE_PARAMS.
 Otherwise returns -1.  */
 represents the constant multiplier of an expression containing
 parameters.  */
 static void
 scan_tree_for_params (sese s, tree e, ppl_Linear_Expression_t c,
-		      Value k)
+		      mpz_t k)
 {
 if (e == chrec_dont_know)
 return;
 switch (TREE_CODE (e))
 case MULT_EXPR:
 if (chrec_contains_symbols (TREE_OPERAND (e, 0)))
 	{
 	  if (c)
 	    {
-	      Value val;
+	      mpz_t val;
 	      gcc_assert (host_integerp (TREE_OPERAND (e, 1), 0));
-	      value_init (val);
+	      mpz_init (val);
-	      value_set_si (val, int_cst_value (TREE_OPERAND (e, 1)));
+	      mpz_set_si (val, int_cst_value (TREE_OPERAND (e, 1)));
-	      value_multiply (val, val, k);
+	      mpz_mul (val, val, k);
 	      scan_tree_for_params (s, TREE_OPERAND (e, 0), c, val);
-	      value_clear (val);
+	      mpz_clear (val);
 	    }
 	  else
 	    scan_tree_for_params (s, TREE_OPERAND (e, 0), c, k);
 	}
 else
 	{
 	  if (c)
 	    {
-	      Value val;
+	      mpz_t val;
 	      gcc_assert (host_integerp (TREE_OPERAND (e, 0), 0));
-	      value_init (val);
+	      mpz_init (val);
-	      value_set_si (val, int_cst_value (TREE_OPERAND (e, 0)));
+	      mpz_set_si (val, int_cst_value (TREE_OPERAND (e, 0)));
-	      value_multiply (val, val, k);
+	      mpz_mul (val, val, k);
 	      scan_tree_for_params (s, TREE_OPERAND (e, 1), c, val);
-	      value_clear (val);
+	      mpz_clear (val);
 	    }
 	  else
 	    scan_tree_for_params (s, TREE_OPERAND (e, 1), c, k);
 	}
 break;
 	scan_tree_for_params (s, TREE_OPERAND (e, 0), tmp_expr, k);
 	if (c)
 	  {
 	    ppl_Coefficient_t coef;
-	    Value minus_one;
+	    mpz_t minus_one;
 	    ppl_subtract_Linear_Expression_from_Linear_Expression (c,
 								   tmp_expr);
 	    ppl_delete_Linear_Expression (tmp_expr);
-	    value_init (minus_one);
+	    mpz_init (minus_one);
-	    value_set_si (minus_one, -1);
+	    mpz_set_si (minus_one, -1);
 	    ppl_new_Coefficient_from_mpz_t (&coef, minus_one);
 	    ppl_Linear_Expression_add_to_inhomogeneous (c, coef);
-	    value_clear (minus_one);
+	    mpz_clear (minus_one);
 	    ppl_delete_Coefficient (coef);
 	  }
 	break;
 }
 int i;
 unsigned j;
 data_reference_p dr;
 gimple stmt;
 loop_p loop = GBB_BB (gbb)->loop_father;
-Value one;
+mpz_t one;
-value_init (one);
+mpz_init (one);
-value_set_si (one, 1);
+mpz_set_si (one, 1);
 /* Find parameters in the access functions of data references.  */
 for (i = 0; VEC_iterate (data_reference_p, GBB_DATA_REFS (gbb), i, dr); i++)
 for (j = 0; j < DR_NUM_DIMENSIONS (dr); j++)
 scan_tree_for_params (region, DR_ACCESS_FN (dr, j), NULL, one);
 scan_tree_for_params (region, lhs, NULL, one);
 scan_tree_for_params (region, rhs, NULL, one);
 }
-value_clear (one);
+mpz_clear (one);
 }
 /* Record the parameters used in the SCOP.  A variable is a parameter
 in a scop if it does not vary during the execution of that scop.  */
 {
 poly_bb_p pbb;
 unsigned i;
 sese region = SCOP_REGION (scop);
 struct loop *loop;
-Value one;
+mpz_t one;
-value_init (one);
+mpz_init (one);
-value_set_si (one, 1);
+mpz_set_si (one, 1);
 /* Find the parameters used in the loop bounds.  */
 for (i = 0; VEC_iterate (loop_p, SESE_LOOP_NEST (region), i, loop); i++)
 {
 tree nb_iters = number_of_latch_executions (loop);
 nb_iters = scalar_evolution_in_region (region, loop, nb_iters);
 scan_tree_for_params (region, nb_iters, NULL, one);
 }
-value_clear (one);
+mpz_clear (one);
 /* Find the parameters used in data accesses.  */
 for (i = 0; VEC_iterate (poly_bb_p, SCOP_BBS (scop), i, pbb); i++)
 find_params_in_bb (region, PBB_BLACK_BOX (pbb));
 static inline gimple_bb_p
 gbb_from_bb (basic_block bb)
 {
 return (gimple_bb_p) bb->aux;
+}
+/* Insert in the SCOP context constraints from the estimation of the
+number of iterations.  UB_EXPR is a linear expression describing
+the number of iterations in a loop.  This expression is bounded by
+the estimation NIT.  */
+static void
+add_upper_bounds_from_estimated_nit (scop_p scop, double_int nit,
+				     ppl_dimension_type dim,
+				     ppl_Linear_Expression_t ub_expr)
+{
+mpz_t val;
+ppl_Linear_Expression_t nb_iters_le;
+ppl_Polyhedron_t pol;
+ppl_Coefficient_t coef;
+ppl_Constraint_t ub;
+ppl_new_Linear_Expression_with_dimension (&ub_expr, dim);
+ppl_new_C_Polyhedron_from_space_dimension (&pol, dim, 0);
+ppl_new_Linear_Expression_from_Linear_Expression (&nb_iters_le,
+						    ub_expr);
+/* Construct the negated number of last iteration in VAL.  */
+mpz_init (val);
+mpz_set_double_int (val, nit, false);
+mpz_sub_ui (val, val, 1);
+mpz_neg (val, val);
+/* NB_ITERS_LE holds the number of last iteration in
+parametrical form.  Subtract estimated number of last
+iteration and assert that result is not positive.  */
+ppl_new_Coefficient_from_mpz_t (&coef, val);
+ppl_Linear_Expression_add_to_inhomogeneous (nb_iters_le, coef);
+ppl_delete_Coefficient (coef);
+ppl_new_Constraint (&ub, nb_iters_le,
+		      PPL_CONSTRAINT_TYPE_LESS_OR_EQUAL);
+ppl_Polyhedron_add_constraint (pol, ub);
+/* Remove all but last GDIM dimensions from POL to obtain
+only the constraints on the parameters.  */
+{
+graphite_dim_t gdim = scop_nb_params (scop);
+ppl_dimension_type *dims = XNEWVEC (ppl_dimension_type, dim - gdim);
+graphite_dim_t i;
+for (i = 0; i < dim - gdim; i++)
+dims[i] = i;
+ppl_Polyhedron_remove_space_dimensions (pol, dims, dim - gdim);
+XDELETEVEC (dims);
+}
+/* Add the constraints on the parameters to the SCoP context.  */
+{
+ppl_Pointset_Powerset_C_Polyhedron_t constraints_ps;
+ppl_new_Pointset_Powerset_C_Polyhedron_from_C_Polyhedron
+(&constraints_ps, pol);
+ppl_Pointset_Powerset_C_Polyhedron_intersection_assign
+(SCOP_CONTEXT (scop), constraints_ps);
+ppl_delete_Pointset_Powerset_C_Polyhedron (constraints_ps);
+}
+ppl_delete_Polyhedron (pol);
+ppl_delete_Linear_Expression (nb_iters_le);
+ppl_delete_Constraint (ub);
+mpz_clear (val);
 }
 /* Builds the constraint polyhedra for LOOP in SCOP.  OUTER_PH gives
 the constraints for the surrounding loops.  */
 ppl_delete_Linear_Expression (ub_expr);
 ppl_delete_Constraint (ub);
 }
 else if (!chrec_contains_undetermined (nb_iters))
 {
-Value one;
+mpz_t one;
 ppl_Constraint_t ub;
 ppl_Linear_Expression_t ub_expr;
 double_int nit;
-value_init (one);
+mpz_init (one);
-value_set_si (one, 1);
+mpz_set_si (one, 1);
 ppl_new_Linear_Expression_with_dimension (&ub_expr, dim);
 nb_iters = scalar_evolution_in_region (region, loop, nb_iters);
 scan_tree_for_params (SCOP_REGION (scop), nb_iters, ub_expr, one);
-value_clear (one);
+mpz_clear (one);
-/* N <= estimated_nb_iters
-	 FIXME: This is a workaround that should go away once we will
-	 have the PIP algorithm.  */
 if (estimated_loop_iterations (loop, true, &nit))
-	{
+	add_upper_bounds_from_estimated_nit (scop, nit, dim, ub_expr);
-	  Value val;
-	  ppl_Linear_Expression_t nb_iters_le;
-	  ppl_Polyhedron_t pol;
-	  graphite_dim_t n = scop_nb_params (scop);
-	  ppl_Coefficient_t coef;
-	  ppl_new_C_Polyhedron_from_space_dimension (&pol, dim, 0);
-	  ppl_new_Linear_Expression_from_Linear_Expression (&nb_iters_le,
-							    ub_expr);
-	  /* Construct the negated number of last iteration in VAL.  */
-	  value_init (val);
-	  mpz_set_double_int (val, nit, false);
-	  value_sub_int (val, val, 1);
-	  value_oppose (val, val);
-	  /* NB_ITERS_LE holds number of last iteration in parametrical form.
-	  Subtract estimated number of last iteration and assert that result
-	  is not positive.  */
-	  ppl_new_Coefficient_from_mpz_t (&coef, val);
-	  ppl_Linear_Expression_add_to_inhomogeneous (nb_iters_le, coef);
-	  ppl_delete_Coefficient (coef);
-	  ppl_new_Constraint (&ub, nb_iters_le,
-			      PPL_CONSTRAINT_TYPE_LESS_OR_EQUAL);
-	  ppl_Polyhedron_add_constraint (pol, ub);
-	  /* Remove all but last N dimensions from POL to obtain constraints
-	     on parameters.  */
-	    {
-	      ppl_dimension_type *dims = XNEWVEC (ppl_dimension_type, dim - n);
-	      graphite_dim_t i;
-	      for (i = 0; i < dim - n; i++)
-		dims[i] = i;
-	      ppl_Polyhedron_remove_space_dimensions (pol, dims, dim - n);
-	      XDELETEVEC (dims);
-	    }
-	  /* Add constraints on parameters to SCoP context.  */
-	    {
-	      ppl_Pointset_Powerset_C_Polyhedron_t constraints_ps;
-	      ppl_new_Pointset_Powerset_C_Polyhedron_from_C_Polyhedron
-	       (&constraints_ps, pol);
-	      ppl_Pointset_Powerset_C_Polyhedron_intersection_assign
-	       (SCOP_CONTEXT (scop), constraints_ps);
-	      ppl_delete_Pointset_Powerset_C_Polyhedron (constraints_ps);
-	    }
-	  ppl_delete_Polyhedron (pol);
-	  ppl_delete_Linear_Expression (nb_iters_le);
-	  ppl_delete_Constraint (ub);
-	  value_clear (val);
-	}
 /* loop_i <= expr_nb_iters */
 ppl_set_coef (ub_expr, nb, -1);
 ppl_new_Constraint (&ub, ub_expr, PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
 ppl_Polyhedron_add_constraint (ph, ub);
 /* Returns a linear expression for tree T evaluated in PBB.  */
 static ppl_Linear_Expression_t
 create_linear_expr_from_tree (poly_bb_p pbb, tree t)
 {
-Value one;
+mpz_t one;
 ppl_Linear_Expression_t res;
 ppl_dimension_type dim;
 sese region = SCOP_REGION (PBB_SCOP (pbb));
 loop_p loop = pbb_loop (pbb);
 ppl_new_Linear_Expression_with_dimension (&res, dim);
 t = scalar_evolution_in_region (region, loop, t);
 gcc_assert (!automatically_generated_chrec_p (t));
-value_init (one);
+mpz_init (one);
-value_set_si (one, 1);
+mpz_set_si (one, 1);
 scan_tree_for_params (region, t, res, one);
-value_clear (one);
+mpz_clear (one);
 return res;
 }
 /* Returns the ppl constraint type from the gimple tree code CODE.  */
 static void
 add_condition_to_domain (ppl_Pointset_Powerset_C_Polyhedron_t ps, gimple stmt,
 			 poly_bb_p pbb, enum tree_code code)
 {
-Value v;
+mpz_t v;
 ppl_Coefficient_t c;
 ppl_Linear_Expression_t left, right;
 ppl_Constraint_t cstr;
 enum ppl_enum_Constraint_Type type;
 /* If we have < or > expressions convert them to <= or >= by adding 1 to
 the left or the right side of the expression. */
 if (code == LT_EXPR)
 {
-value_init (v);
+mpz_init (v);
-value_set_si (v, 1);
+mpz_set_si (v, 1);
 ppl_new_Coefficient (&c);
 ppl_assign_Coefficient_from_mpz_t (c, v);
 ppl_Linear_Expression_add_to_inhomogeneous (left, c);
 ppl_delete_Coefficient (c);
-value_clear (v);
+mpz_clear (v);
 code = LE_EXPR;
 }
 else if (code == GT_EXPR)
 {
-value_init (v);
+mpz_init (v);
-value_set_si (v, 1);
+mpz_set_si (v, 1);
 ppl_new_Coefficient (&c);
 ppl_assign_Coefficient_from_mpz_t (c, v);
 ppl_Linear_Expression_add_to_inhomogeneous (right, c);
 ppl_delete_Coefficient (c);
-value_clear (v);
+mpz_clear (v);
 code = GE_EXPR;
 }
 type = ppl_constraint_type_from_tree_code (code);
 {
 ppl_Constraint_t cstr;
 ppl_Linear_Expression_t le;
 tree parameter = VEC_index (tree, SESE_PARAMS (SCOP_REGION (scop)), p);
 tree type = TREE_TYPE (parameter);
-tree lb, ub;
+tree lb = NULL_TREE;
+tree ub = NULL_TREE;
-/* Disabled until we fix CPU2006.  */
-return;
+if (POINTER_TYPE_P (type) || !TYPE_MIN_VALUE (type))
+lb = lower_bound_in_type (type, type);
-if (!INTEGRAL_TYPE_P (type))
+else
-return;
+lb = TYPE_MIN_VALUE (type);
-lb = TYPE_MIN_VALUE (type);
+if (POINTER_TYPE_P (type) || !TYPE_MAX_VALUE (type))
-ub = TYPE_MAX_VALUE (type);
+ub = upper_bound_in_type (type, type);
+else
+ub = TYPE_MAX_VALUE (type);
 if (lb)
 {
 ppl_new_Linear_Expression_with_dimension (&le, scop_nb_params (scop));
 ppl_set_coef (le, p, -1);
 			 ppl_dimension_type accessp_nb_dims,
 			 ppl_dimension_type dom_nb_dims,
 			 poly_bb_p pbb)
 {
 int i, nb_subscripts = DR_NUM_DIMENSIONS (dr);
-Value v;
+mpz_t v;
 scop_p scop = PBB_SCOP (pbb);
 sese region = SCOP_REGION (scop);
-value_init (v);
+mpz_init (v);
 for (i = 0; i < nb_subscripts; i++)
 {
 ppl_Linear_Expression_t fn, access;
 ppl_Constraint_t cstr;
 tree afn = DR_ACCESS_FN (dr, nb_subscripts - 1 - i);
 ppl_new_Linear_Expression_with_dimension (&fn, dom_nb_dims);
 ppl_new_Linear_Expression_with_dimension (&access, accessp_nb_dims);
-value_set_si (v, 1);
+mpz_set_si (v, 1);
 scan_tree_for_params (region, afn, fn, v);
 ppl_assign_Linear_Expression_from_Linear_Expression (access, fn);
 ppl_set_coef (access, subscript, -1);
 ppl_new_Constraint (&cstr, access, PPL_CONSTRAINT_TYPE_EQUAL);
 ppl_delete_Linear_Expression (fn);
 ppl_delete_Linear_Expression (access);
 ppl_delete_Constraint (cstr);
 }
-value_clear (v);
+mpz_clear (v);
 }
 /* Add constrains representing the size of the accessed data to the
 ACCESSES polyhedron.  ACCESSP_NB_DIMS is the dimension of the
 ACCESSES polyhedron, DOM_NB_DIMS is the dimension of the iteration
 {
 if (gimple_code (phi) != GIMPLE_PHI
 || !is_gimple_reg (gimple_phi_result (phi)))
 return false;
+/* Note that loop close phi nodes should have a single argument
+because we translated the representation into a canonical form
+before Graphite: see canonicalize_loop_closed_ssa_form.  */
 return (gimple_phi_num_args (phi) == 1);
 }
 /* Rewrite out of SSA the reduction phi node at PSI by creating a zero
 dimension array for it.  */
 tree zero_dim_array = create_zero_dim_array (var, "Close_Phi");
 gimple_stmt_iterator gsi = gsi_after_labels (gimple_bb (phi));
 gimple stmt = gimple_build_assign (res, zero_dim_array);
 tree arg = gimple_phi_arg_def (phi, 0);
-if (TREE_CODE (arg) == SSA_NAME)
+/* Note that loop close phi nodes should have a single argument
+because we translated the representation into a canonical form
+before Graphite: see canonicalize_loop_closed_ssa_form.  */
+gcc_assert (gimple_phi_num_args (phi) == 1);
+if (TREE_CODE (arg) == SSA_NAME
+&& !SSA_NAME_IS_DEFAULT_DEF (arg))
 insert_out_of_ssa_copy (zero_dim_array, arg);
 else
 insert_out_of_ssa_copy_on_edge (single_pred_edge (gimple_bb (phi)),
 				    zero_dim_array, arg);
 def_bb = gimple_bb (stmt);
 FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, def)
 if (def_bb != gimple_bb (use_stmt)
-	&& gimple_code (use_stmt) != GIMPLE_PHI)
+	&& gimple_code (use_stmt) != GIMPLE_PHI
+	&& !is_gimple_debug (use_stmt))
 {
 	if (!zero_dim_array)
 	  {
 	    zero_dim_array = create_zero_dim_array
 	      (SSA_NAME_VAR (def), "Cross_BB_scalar_dependence");
 	    rewrite_phi_out_of_ssa (&psi);
 	}
 update_ssa (TODO_update_ssa);
 #ifdef ENABLE_CHECKING
-verify_ssa (false);
+verify_loop_closed_ssa (true);
-verify_loop_closed_ssa ();
 #endif
 FOR_EACH_BB (bb)
 if (bb_in_sese_p (bb, region))
 for (psi = gsi_start_bb (bb); !gsi_end_p (psi); gsi_next (&psi))
 	rewrite_cross_bb_scalar_deps (region, &psi);
 update_ssa (TODO_update_ssa);
 #ifdef ENABLE_CHECKING
-verify_ssa (false);
+verify_loop_closed_ssa (true);
-verify_loop_closed_ssa ();
 #endif
 }
 /* Returns the number of pbbs that are in loops contained in SCOP.  */
 if (nb_data_writes_in_bb (bb) == 0)
 return bb;
 split_block (bb, stmt);
-if (gsi_one_before_end_p (gsi_start_bb (bb)))
+if (gsi_one_before_end_p (gsi_start_nondebug_bb (bb)))
 return bb;
 gsi = gsi_last_bb (bb);
 gsi_prev (&gsi);
 e = split_block (bb, gsi_stmt (gsi));
 gimple def, loop_phi;
 if (TREE_CODE (arg) != SSA_NAME)
 	return NULL;
+/* Note that loop close phi nodes should have a single argument
+	 because we translated the representation into a canonical form
+	 before Graphite: see canonicalize_loop_closed_ssa_form.  */
+gcc_assert (gimple_phi_num_args (stmt) == 1);
 def = SSA_NAME_DEF_STMT (arg);
 loop_phi = detect_commutative_reduction (def, in, out);
 if (loop_phi)
 	{
 force_gimple_operand (expr, &stmts, true, NULL);
 gsi_insert_seq_on_edge (edge_initial_value_for_loop_phi (loop_phi), stmts);
 }
+/* Removes the PHI node and resets all the debug stmts that are using
+the PHI_RESULT.  */
+static void
+remove_phi (gimple phi)
+{
+imm_use_iterator imm_iter;
+tree def;
+use_operand_p use_p;
+gimple_stmt_iterator gsi;
+VEC (gimple, heap) *update = VEC_alloc (gimple, heap, 3);
+unsigned int i;
+gimple stmt;
+def = PHI_RESULT (phi);
+FOR_EACH_IMM_USE_FAST (use_p, imm_iter, def)
+{
+stmt = USE_STMT (use_p);
+if (is_gimple_debug (stmt))
+	{
+	  gimple_debug_bind_reset_value (stmt);
+	  VEC_safe_push (gimple, heap, update, stmt);
+	}
+}
+for (i = 0; VEC_iterate (gimple, update, i, stmt); i++)
+update_stmt (stmt);
+VEC_free (gimple, heap, update);
+gsi = gsi_for_phi_node (phi);
+remove_phi_node (&gsi, false);
+}
 /* Rewrite out of SSA the reduction described by the loop phi nodes
 IN, and the close phi nodes OUT.  IN and OUT are structured by loop
 levels like this:
 IN: stmt, loop_n, ..., loop_0
 				     VEC (gimple, heap) *out,
 				     sbitmap reductions)
 {
 unsigned int i;
 gimple loop_phi;
-tree red;
+tree red = NULL_TREE;
-gimple_stmt_iterator gsi;
 for (i = 0; VEC_iterate (gimple, in, i, loop_phi); i++)
 {
 gimple close_phi = VEC_index (gimple, out, i);
 	{
 	  insert_copyout (red, close_phi);
 	  insert_copyin (red, loop_phi);
 	}
-gsi = gsi_for_phi_node (loop_phi);
+remove_phi (loop_phi);
-remove_phi_node (&gsi, false);
+remove_phi (close_phi);
-gsi = gsi_for_phi_node (close_phi);
-remove_phi_node (&gsi, false);
 }
 }
 /* Rewrites out of SSA a commutative reduction at CLOSE_PHI.  */
 rewrite_commutative_reductions_out_of_ssa_loop (loop, reductions);
 gsi_commit_edge_inserts ();
 update_ssa (TODO_update_ssa);
 #ifdef ENABLE_CHECKING
-verify_ssa (false);
+verify_loop_closed_ssa (true);
-verify_loop_closed_ssa ();
 #endif
 }
 /* A LOOP is in normal form for Graphite when it contains only one
 scalar phi node that defines the main induction variable of the
 gimple_seq stmts;
 edge exit = single_dom_exit (loop);
 bool known_niter = number_of_iterations_exit (loop, exit, &niter, false);
-/* At this point we should know the number of iterations,  */
+/* At this point we should know the number of iterations.  */
 gcc_assert (known_niter);
 nit = force_gimple_operand (unshare_expr (niter.niter), &stmts, true,
 			      NULL_TREE);
 if (stmts)
 gsi_insert_seq_on_edge_immediate (loop_preheader_edge (loop), stmts);
-loop->single_iv = canonicalize_loop_ivs (loop, &nit);
+loop->single_iv = canonicalize_loop_ivs (loop, &nit, false);
 }
 /* Rewrite all the loops of SCOP in normal form: one induction
 variable per loop.  */
 FOR_EACH_LOOP (li, loop, 0)
 if (loop_in_sese_p (loop, SCOP_REGION (scop)))
 graphite_loop_normal_form (loop);
 }
+/* Java does not initialize long_long_integer_type_node.  */
+#define my_long_long (long_long_integer_type_node ? long_long_integer_type_node : ssizetype)
+/* Can all ivs be represented by a signed integer?
+As CLooG might generate negative values in its expressions, signed loop ivs
+are required in the backend. */
+static bool
+scop_ivs_can_be_represented (scop_p scop)
+{
+loop_iterator li;
+loop_p loop;
+FOR_EACH_LOOP (li, loop, 0)
+{
+tree type;
+int precision;
+if (!loop_in_sese_p (loop, SCOP_REGION (scop)))
+	continue;
+if (!loop->single_iv)
+	continue;
+type = TREE_TYPE(loop->single_iv);
+precision = TYPE_PRECISION (type);
+if (TYPE_UNSIGNED (type)
+	  && precision >= TYPE_PRECISION (my_long_long))
+	return false;
+}
+return true;
+}
+#undef my_long_long
 /* Builds the polyhedral representation for a SESE region.  */
-bool
+void
 build_poly_scop (scop_p scop)
 {
 sese region = SCOP_REGION (scop);
 sbitmap reductions = sbitmap_alloc (last_basic_block * 2);
+graphite_dim_t max_dim;
 sbitmap_zero (reductions);
 rewrite_commutative_reductions_out_of_ssa (region, reductions);
 rewrite_reductions_out_of_ssa (scop);
 build_scop_bbs (scop, reductions);
 /* FIXME: This restriction is needed to avoid a problem in CLooG.
 Once CLooG is fixed, remove this guard.  Anyways, it makes no
 sense to optimize a scop containing only PBBs that do not belong
 to any loops.  */
 if (nb_pbbs_in_loops (scop) == 0)
-return false;
+return;
 scop_canonicalize_loops (scop);
+if (!scop_ivs_can_be_represented (scop))
+return;
 build_sese_loop_nests (region);
 build_sese_conditions (region);
 find_scop_parameters (scop);
+max_dim = PARAM_VALUE (PARAM_GRAPHITE_MAX_NB_SCOP_PARAMS);
+if (scop_nb_params (scop) > max_dim)
+return;
 build_scop_iteration_domain (scop);
 build_scop_context (scop);
 add_conditions_to_constraints (scop);
 scop_to_lst (scop);
 build_scop_scattering (scop);
 build_scop_drs (scop);
-return true;
+/* This SCoP has been translated to the polyhedral
+representation.  */
+POLY_SCOP_P (scop) = true;
 }
 /* Always return false.  Exercise the scop_to_clast function.  */
 void

Mercurial > hg > CbC > CbC_gcc

comparison gcc/graphite-sese-to-poly.c @ 63:b7f97abdc517 gcc-4.6-20100522