/* 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.
GBB_DATA_REFS (gbb) = drs;
GBB_CONDITIONS (gbb) = NULL;
GBB_CONDITION_CASES (gbb) = NULL;
- GBB_CLOOG_IV_TYPES (gbb) = NULL;
return 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));
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
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);
{
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);
}
{
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_delete_Constraint (cstr);
}
- value_clear (v);
+ mpz_clear (v);
ppl_delete_Coefficient (c);
PBB_ORIGINAL (pbb) = poly_scattering_copy (PBB_TRANSFORMED (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);
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);
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,
ppl_delete_Linear_Expression (common);
}
- value_clear (v);
+ mpz_clear (v);
ppl_delete_Coefficient (c);
ppl_delete_Linear_Expression (static_schedule);
}
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);
}
{
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);
| a [i * p] = ... */
gcc_assert (TREE_CODE (e) == INTEGER_CST);
- value_init (val);
- value_set_si (val, int_cst_value (e));
+ mpz_init (val);
+ mpz_set_si (val, int_cst_value (e));
add_value_to_dim (l, expr, val);
- value_clear (val);
+ mpz_clear (val);
}
}
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);
- value_set_si (val, 0);
+ mpz_init (val);
+ 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);
}
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;
{
if (c)
{
- Value val;
+ mpz_t val;
gcc_assert (host_integerp (TREE_OPERAND (e, 1), 0));
- value_init (val);
- value_set_si (val, int_cst_value (TREE_OPERAND (e, 1)));
- value_multiply (val, val, k);
+ mpz_init (val);
+ mpz_set_si (val, int_cst_value (TREE_OPERAND (e, 1)));
+ 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);
{
if (c)
{
- Value val;
+ mpz_t val;
gcc_assert (host_integerp (TREE_OPERAND (e, 0), 0));
- value_init (val);
- value_set_si (val, int_cst_value (TREE_OPERAND (e, 0)));
- value_multiply (val, val, k);
+ mpz_init (val);
+ mpz_set_si (val, int_cst_value (TREE_OPERAND (e, 0)));
+ 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);
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);
- value_set_si (minus_one, -1);
+ mpz_init (minus_one);
+ 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);
}
data_reference_p dr;
gimple stmt;
loop_p loop = GBB_BB (gbb)->loop_father;
- Value one;
+ mpz_t one;
- value_init (one);
- value_set_si (one, 1);
+ mpz_init (one);
+ 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++)
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
unsigned i;
sese region = SCOP_REGION (scop);
struct loop *loop;
- Value one;
+ mpz_t one;
- value_init (one);
- value_set_si (one, 1);
+ mpz_init (one);
+ 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++)
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++)
}
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);
- value_set_si (one, 1);
+ mpz_init (one);
+ 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);
if (estimated_loop_iterations (loop, true, &nit))
add_upper_bounds_from_estimated_nit (scop, nit, dim, ub_expr);
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));
t = scalar_evolution_in_region (region, loop, t);
gcc_assert (!automatically_generated_chrec_p (t));
- value_init (one);
- value_set_si (one, 1);
+ mpz_init (one);
+ mpz_set_si (one, 1);
scan_tree_for_params (region, t, res, one);
- value_clear (one);
+ mpz_clear (one);
return res;
}
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;
the left or the right side of the expression. */
if (code == LT_EXPR)
{
- value_init (v);
- value_set_si (v, 1);
+ mpz_init (v);
+ 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);
- value_set_si (v, 1);
+ mpz_init (v);
+ 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;
}
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_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_delete_Constraint (cstr);
}
- value_clear (v);
+ mpz_clear (v);
}
/* Add constrains representing the size of the accessed data to the
|| !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);
}
gimple stmt = gimple_build_assign (res, zero_dim_array);
tree arg = gimple_phi_arg_def (phi, 0);
+ /* 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);
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)
{
update_ssa (TODO_update_ssa);
#ifdef ENABLE_CHECKING
- verify_ssa (false);
- verify_loop_closed_ssa ();
+ verify_loop_closed_ssa (true);
#endif
FOR_EACH_BB (bb)
update_ssa (TODO_update_ssa);
#ifdef ENABLE_CHECKING
- verify_ssa (false);
- verify_loop_closed_ssa ();
+ verify_loop_closed_ssa (true);
#endif
}
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);
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);
{
unsigned int i;
gimple loop_phi;
- tree red;
+ tree red = NULL_TREE;
for (i = 0; VEC_iterate (gimple, in, i, loop_phi); i++)
{
gsi_commit_edge_inserts ();
update_ssa (TODO_update_ssa);
#ifdef ENABLE_CHECKING
- verify_ssa (false);
- verify_loop_closed_ssa ();
+ verify_loop_closed_ssa (true);
#endif
}
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,
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
OSDN Git Service
