/* Update "enforced" such that it only involves constraints that are
* also enforced by "graft".
*/
static __isl_give isl_basic_set *update_enforced(
__isl_take isl_basic_set *enforced, __isl_keep isl_ast_graft *graft,
int depth)
{
isl_basic_set *enforced_g;
enforced_g = isl_ast_graft_get_enforced(graft);
if (depth < isl_basic_set_dim(enforced_g, isl_dim_set))
enforced_g = isl_basic_set_eliminate(enforced_g,
isl_dim_set, depth, 1);
enforced_g = isl_basic_set_remove_unknown_divs(enforced_g);
enforced_g = isl_basic_set_align_params(enforced_g,
isl_basic_set_get_space(enforced));
enforced = isl_basic_set_align_params(enforced,
isl_basic_set_get_space(enforced_g));
enforced = isl_set_simple_hull(isl_basic_set_union(enforced,
enforced_g));
return enforced;
}
/**
* Reduce the modulo guard expressed by "constraints" using equalities
* found in outer nesting levels (stored in "equal").
* The modulo guard may be an equality or a pair of inequalities.
* In case of a pair of inequalities, *bound contains the bound on the
* corresponding modulo expression. If any reduction is performed
* then this bound is recomputed.
*
* "level" may not correspond to an existentially quantified variable.
*
* We first check if there are any equalities we can use. If not,
* there is again nothing to reduce.
* For the actual reduction, we use isl_basic_set_gist, but this
* function will only perform the reduction we want here if the
* the variable that imposes the modulo constraint has been projected
* out (i.e., turned into an existentially quantified variable).
* After the call to isl_basic_set_gist, we need to move the
* existential variable back into the position where the calling
* function expects it (assuming there are any constraints left).
* We do this by adding an equality between the given dimension and
* the existentially quantified variable.
*
* If there are no existentially quantified variables left, then
* we don't need to add this equality.
* If, on the other hand, the resulting basic set involves more
* than one existentially quantified variable, then the caller
* will not be able to handle the result, so we just return the
* original input instead.
*/
CloogConstraintSet *cloog_constraint_set_reduce(CloogConstraintSet *constraints,
int level, CloogEqualities *equal, int nb_par, cloog_int_t *bound)
{
int j;
isl_space *idim;
struct isl_basic_set *eq;
struct isl_basic_map *id;
struct cloog_isl_dim dim;
struct isl_constraint *c;
unsigned constraints_dim;
unsigned n_div;
isl_basic_set *bset, *orig;
bset = cloog_constraints_set_to_isl(constraints);
orig = isl_basic_set_copy(bset);
dim = set_cloog_dim_to_isl_dim(constraints, level - 1);
assert(dim.type == isl_dim_set);
eq = NULL;
for (j = 0; j < level - 1; ++j) {
isl_basic_set *bset_j;
if (equal->types[j] != EQTYPE_EXAFFINE)
continue;
bset_j = equality_to_basic_set(equal, j);
if (!eq)
eq = bset_j;
else
eq = isl_basic_set_intersect(eq, bset_j);
}
if (!eq) {
isl_basic_set_free(orig);
return cloog_constraint_set_from_isl_basic_set(bset);
}
idim = isl_space_map_from_set(isl_basic_set_get_space(bset));
id = isl_basic_map_identity(idim);
id = isl_basic_map_remove_dims(id, isl_dim_out, dim.pos, 1);
bset = isl_basic_set_apply(bset, isl_basic_map_copy(id));
bset = isl_basic_set_apply(bset, isl_basic_map_reverse(id));
constraints_dim = isl_basic_set_dim(bset, isl_dim_set);
eq = isl_basic_set_remove_dims(eq, isl_dim_set, constraints_dim,
isl_basic_set_dim(eq, isl_dim_set) - constraints_dim);
bset = isl_basic_set_gist(bset, eq);
n_div = isl_basic_set_dim(bset, isl_dim_div);
if (n_div > 1) {
isl_basic_set_free(bset);
return cloog_constraint_set_from_isl_basic_set(orig);
}
if (n_div < 1) {
isl_basic_set_free(orig);
return cloog_constraint_set_from_isl_basic_set(bset);
}
c = isl_equality_alloc(isl_basic_set_get_local_space(bset));
c = isl_constraint_set_coefficient_si(c, isl_dim_div, 0, 1);
c = isl_constraint_set_coefficient_si(c, isl_dim_set, dim.pos, -1);
bset = isl_basic_set_add_constraint(bset, c);
isl_int_set_si(*bound, 0);
constraints = cloog_constraint_set_from_isl_basic_set(bset);
cloog_constraint_set_foreach_constraint(constraints,
add_constant_term, bound);
isl_basic_set_free(orig);
return cloog_constraint_set_from_isl_basic_set(bset);
}
