Various smaller improvements and bugfixes.
llvm-svn: 236932
External/isl/isl_convex_hull.c
External/isl/isl_ctx.c
External/isl/isl_deprecated.c
- External/isl/isl_dim.c
External/isl/isl_dim_map.c
External/isl/isl_equalities.c
External/isl/isl_factorization.c
Tobias Grosser
Alexandre Isoard
Andreas Kloeckner
+Michael Kruse
Sebastian Pop
Louis-Noel Pouchet
Uday Kumar Reddy
+version: 0.14.1
+date: Thu Apr 9 12:57:23 CEST 2015
+changes:
+ - fix bug in affine expression normalization
+ - fix handling of conditional validity constraints
+---
version: 0.14
date: Sat Oct 25 16:08:47 CEST 2014
changes:
isl_ctx.c \
isl_ctx_private.h \
isl_deprecated.c \
- isl_dim.c \
isl_dim_map.h \
isl_dim_map.c \
isl_equalities.c \
include/isl/band.h \
include/isl/constraint.h \
include/isl/ctx.h \
- include/isl/dim.h \
include/isl/flow.h \
include/isl/id.h \
include/isl/id_to_ast_expr.h \
isl_vec_free(sample);
}
isl_int_divexact_ui(lp->opt_denom, lp->opt_denom, 2);
- if (res != isl_lp_ok)
+ if (res < 0)
return -1;
+ if (res != isl_lp_ok)
+ isl_die(lp->ctx, isl_error_internal,
+ "unexpected missing (bounded) solution", return -1);
return 0;
}
unsigned dim;
struct isl_ctx *ctx;
struct isl_mat *B;
- int unbounded;
int i;
GBR_LP *lp = NULL;
GBR_type F_old, alpha, F_new;
GBR_lp_set_obj(lp, B->row[1+i]+1, dim);
ctx->stats->gbr_solved_lps++;
- unbounded = GBR_lp_solve(lp);
- isl_assert(ctx, !unbounded, goto error);
+ if (GBR_lp_solve(lp) < 0)
+ goto error;
GBR_lp_get_obj_val(lp, &F[i]);
if (GBR_lt(F[i], one)) {
if (i+1 == tab->n_zero) {
GBR_lp_set_obj(lp, B->row[1+i+1]+1, dim);
ctx->stats->gbr_solved_lps++;
- unbounded = GBR_lp_solve(lp);
- isl_assert(ctx, !unbounded, goto error);
+ if (GBR_lp_solve(lp) < 0)
+ goto error;
GBR_lp_get_obj_val(lp, &F_new);
fixed = GBR_lp_is_fixed(lp);
GBR_set_ui(alpha, 0);
row = GBR_lp_add_row(lp, B->row[1+i]+1, dim);
GBR_lp_set_obj(lp, B->row[1+i+1]+1, dim);
ctx->stats->gbr_solved_lps++;
- unbounded = GBR_lp_solve(lp);
- isl_assert(ctx, !unbounded, goto error);
+ if (GBR_lp_solve(lp) < 0)
+ goto error;
GBR_lp_get_obj_val(lp, &F_new);
fixed = GBR_lp_is_fixed(lp);
tmp, B->row[1+i]+1, dim);
GBR_lp_set_obj(lp, b_tmp->el, dim);
ctx->stats->gbr_solved_lps++;
- unbounded = GBR_lp_solve(lp);
- isl_assert(ctx, !unbounded, goto error);
+ if (GBR_lp_solve(lp) < 0)
+ goto error;
GBR_lp_get_obj_val(lp, &mu_F[j]);
mu_fixed[j] = GBR_lp_is_fixed(lp);
if (i > 0)
#include <isl/ast_build.h>
#include <isl/options.h>
#include <isl/set.h>
+#include <isl/union_set.h>
+#include <isl/union_map.h>
#include <isl/stream.h>
#include <isl/schedule_node.h>
-AC_INIT([isl], [0.14], [isl-development@googlegroups.com])
+AC_INIT([isl], [0.14.1], [isl-development@googlegroups.com])
AC_CONFIG_AUX_DIR([.])
AC_CONFIG_MACRO_DIR([m4])
AM_INIT_AUTOMAKE([foreign])
m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
AC_SUBST(versioninfo)
-versioninfo=14:0:1
+versioninfo=14:1:1
if test "x$prefix" != "xNONE"; then
prefix_wd=`cd $prefix && pwd`
}
#endif
-#include <isl/dim.h>
-
#endif
}
#endif
-#include <isl/dim.h>
-
#endif
+++ /dev/null
-#ifndef ISL_DIM_H
-#define ISL_DIM_H
-
-#include <isl/space.h>
-#include <isl/local_space.h>
-#include <isl/aff_type.h>
-#include <isl/constraint.h>
-#include <isl/map_type.h>
-#include <isl/set_type.h>
-#include <isl/point.h>
-#include <isl/union_map.h>
-#include <isl/union_set.h>
-#include <isl/polynomial_type.h>
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-#define isl_dim isl_space
-
-ISL_DEPRECATED
-isl_ctx *isl_dim_get_ctx(__isl_keep isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_alloc(isl_ctx *ctx,
- unsigned nparam, unsigned n_in, unsigned n_out);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_set_alloc(isl_ctx *ctx,
- unsigned nparam, unsigned dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_copy(__isl_keep isl_space *dim);
-ISL_DEPRECATED
-void isl_dim_free(__isl_take isl_space *dim);
-
-ISL_DEPRECATED
-unsigned isl_dim_size(__isl_keep isl_space *dim, enum isl_dim_type type);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_set_dim_id(__isl_take isl_space *dim,
- enum isl_dim_type type, unsigned pos, __isl_take isl_id *id);
-ISL_DEPRECATED
-int isl_dim_has_dim_id(__isl_keep isl_space *dim,
- enum isl_dim_type type, unsigned pos);
-ISL_DEPRECATED
-__isl_give isl_id *isl_dim_get_dim_id(__isl_keep isl_space *dim,
- enum isl_dim_type type, unsigned pos);
-
-ISL_DEPRECATED
-int isl_dim_find_dim_by_id(__isl_keep isl_space *dim,
- enum isl_dim_type type, __isl_keep isl_id *id);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_set_tuple_id(__isl_take isl_space *dim,
- enum isl_dim_type type, __isl_take isl_id *id);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_reset_tuple_id(__isl_take isl_space *dim,
- enum isl_dim_type type);
-ISL_DEPRECATED
-int isl_dim_has_tuple_id(__isl_keep isl_space *dim, enum isl_dim_type type);
-ISL_DEPRECATED
-__isl_give isl_id *isl_dim_get_tuple_id(__isl_keep isl_space *dim,
- enum isl_dim_type type);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_set_name(__isl_take isl_space *dim,
- enum isl_dim_type type, unsigned pos, __isl_keep const char *name);
-ISL_DEPRECATED
-__isl_keep const char *isl_dim_get_name(__isl_keep isl_space *dim,
- enum isl_dim_type type, unsigned pos);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_set_tuple_name(__isl_take isl_space *dim,
- enum isl_dim_type type, const char *s);
-ISL_DEPRECATED
-const char *isl_dim_get_tuple_name(__isl_keep isl_space *dim,
- enum isl_dim_type type);
-
-ISL_DEPRECATED
-int isl_dim_is_wrapping(__isl_keep isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_wrap(__isl_take isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_unwrap(__isl_take isl_space *dim);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_domain(__isl_take isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_from_domain(__isl_take isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_range(__isl_take isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_from_range(__isl_take isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_reverse(__isl_take isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_join(__isl_take isl_space *left,
- __isl_take isl_space *right);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_align_params(__isl_take isl_space *dim1,
- __isl_take isl_space *dim2);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_insert(__isl_take isl_space *dim,
- enum isl_dim_type type, unsigned pos, unsigned n);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_add(__isl_take isl_space *dim,
- enum isl_dim_type type, unsigned n);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_drop(__isl_take isl_space *dim,
- enum isl_dim_type type, unsigned first, unsigned n);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_move(__isl_take isl_space *dim,
- enum isl_dim_type dst_type, unsigned dst_pos,
- enum isl_dim_type src_type, unsigned src_pos, unsigned n);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_map_from_set(
- __isl_take isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_zip(__isl_take isl_space *dim);
-
-ISL_DEPRECATED
-__isl_give isl_local_space *isl_local_space_from_dim(
- __isl_take isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_local_space_get_dim(
- __isl_keep isl_local_space *ls);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_aff_get_dim(__isl_keep isl_aff *aff);
-ISL_DEPRECATED
-__isl_give isl_space *isl_pw_aff_get_dim(__isl_keep isl_pw_aff *pwaff);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_constraint_get_dim(
- __isl_keep isl_constraint *constraint);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_basic_map_get_dim(__isl_keep isl_basic_map *bmap);
-ISL_DEPRECATED
-__isl_give isl_space *isl_map_get_dim(__isl_keep isl_map *map);
-ISL_DEPRECATED
-__isl_give isl_space *isl_union_map_get_dim(__isl_keep isl_union_map *umap);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_basic_set_get_dim(__isl_keep isl_basic_set *bset);
-ISL_DEPRECATED
-__isl_give isl_space *isl_set_get_dim(__isl_keep isl_set *set);
-ISL_DEPRECATED
-__isl_give isl_space *isl_union_set_get_dim(__isl_keep isl_union_set *uset);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_point_get_dim(__isl_keep isl_point *pnt);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_qpolynomial_get_dim(__isl_keep isl_qpolynomial *qp);
-ISL_DEPRECATED
-__isl_give isl_space *isl_pw_qpolynomial_get_dim(
- __isl_keep isl_pw_qpolynomial *pwqp);
-ISL_DEPRECATED
-__isl_give isl_space *isl_qpolynomial_fold_get_dim(
- __isl_keep isl_qpolynomial_fold *fold);
-ISL_DEPRECATED
-__isl_give isl_space *isl_pw_qpolynomial_fold_get_dim(
- __isl_keep isl_pw_qpolynomial_fold *pwf);
-ISL_DEPRECATED
-__isl_give isl_space *isl_union_pw_qpolynomial_get_dim(
- __isl_keep isl_union_pw_qpolynomial *upwqp);
-ISL_DEPRECATED
-__isl_give isl_space *isl_union_pw_qpolynomial_fold_get_dim(
- __isl_keep isl_union_pw_qpolynomial_fold *upwf);
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif
}
#endif
-#include <isl/dim.h>
-
#endif
}
#endif
-#include <isl/dim.h>
-
#endif
}
#endif
-#include <isl/dim.h>
-
#endif
}
#endif
-#include <isl/dim.h>
-
#endif
#define ISL_UNION_MAP_H
#include <isl/space.h>
+#include <isl/aff_type.h>
#include <isl/map_type.h>
#include <isl/union_map_type.h>
#include <isl/printer.h>
}
#endif
-#include <isl/dim.h>
-
#endif
}
#endif
-#include <isl/dim.h>
-
#endif
#include <isl/map.h>
#include <isl/aff.h>
+#include <isl/constraint.h>
#include <isl/map.h>
+#include <isl/union_set.h>
+#include <isl/union_map.h>
#include <isl_ast_build_private.h>
#include <isl_ast_private.h>
* B.P. 105 - 78153 Le Chesnay, France
*/
+#include <isl/constraint.h>
#include <isl/ilp.h>
#include <isl_ast_build_expr.h>
#include <isl_ast_private.h>
#include <limits.h>
#include <isl/aff.h>
+#include <isl/constraint.h>
#include <isl/set.h>
#include <isl/ilp.h>
+#include <isl/union_set.h>
#include <isl/union_map.h>
#include <isl/schedule_node.h>
#include <isl_sort.h>
if (info[j].ineq[l] != STATUS_CUT)
continue;
stat = status_in(info[j].bmap->ineq[l], info[i].tab);
+ if (stat < 0)
+ return isl_change_error;
if (stat != STATUS_VALID)
break;
}
isl_seq_neg(bmap->eq[k], bmap->eq[k], 1 + dim);
stat = status_in(bmap->eq[k], tab);
isl_seq_neg(bmap->eq[k], bmap->eq[k], 1 + dim);
+ if (stat < 0)
+ return -1;
if (stat != STATUS_VALID)
return 0;
stat = status_in(bmap->eq[k], tab);
+ if (stat < 0)
+ return -1;
if (stat != STATUS_VALID)
return 0;
}
if (info->ineq[k] == STATUS_REDUNDANT)
continue;
stat = status_in(bmap->ineq[k], tab);
+ if (stat < 0)
+ return -1;
if (stat != STATUS_VALID)
return 0;
}
unsigned n_eq = info[i].bmap->n_eq;
unsigned total = isl_basic_map_total_dim(info[i].bmap);
int r;
+ int super;
if (isl_tab_extend_cons(info[i].tab, 1 + info[j].bmap->n_ineq) < 0)
return isl_change_error;
return isl_change_error;
}
- if (contains(&info[j], info[i].tab))
+ super = contains(&info[j], info[i].tab);
+ if (super < 0)
+ return isl_change_error;
+ if (super)
return fuse(i, j, info, NULL, 0, 0);
if (isl_tab_rollback(info[i].tab, snap) < 0)
if (isl_tab_select_facet(info[i].tab, n_eq + k) < 0)
return isl_change_error;
super = contains(&info[j], info[i].tab);
+ if (super < 0)
+ return isl_change_error;
if (super) {
int l;
unsigned total;
return list;
error:
+ isl_aff_free(aff_nan);
isl_local_space_free(ls);
isl_basic_set_free(wrap_hull);
isl_aff_list_free(list);
list = set_up_substitutions(info[i].bmap, info[j].bmap, hull_j);
if (!list)
- goto error;
+ return isl_change_error;
if (isl_aff_list_n_aff(list) < n_div_i)
change = isl_change_none;
else
+++ /dev/null
-#include <isl/dim.h>
-#include <isl/aff.h>
-#include <isl/map.h>
-#include <isl/set.h>
-#include <isl/polynomial.h>
-
-isl_ctx *isl_dim_get_ctx(__isl_keep isl_space *dim)
-{
- return isl_space_get_ctx(dim);
-}
-
-__isl_give isl_space *isl_dim_alloc(isl_ctx *ctx,
- unsigned nparam, unsigned n_in, unsigned n_out)
-{
- return isl_space_alloc(ctx, nparam, n_in, n_out);
-}
-__isl_give isl_space *isl_dim_set_alloc(isl_ctx *ctx,
- unsigned nparam, unsigned dim)
-{
- return isl_space_set_alloc(ctx, nparam, dim);
-}
-__isl_give isl_space *isl_dim_copy(__isl_keep isl_space *dim)
-{
- return isl_space_copy(dim);
-}
-void isl_dim_free(__isl_take isl_space *dim)
-{
- isl_space_free(dim);
-}
-
-unsigned isl_dim_size(__isl_keep isl_space *dim, enum isl_dim_type type)
-{
- return isl_space_dim(dim, type);
-}
-
-__isl_give isl_space *isl_dim_set_dim_id(__isl_take isl_space *dim,
- enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
-{
- return isl_space_set_dim_id(dim, type, pos, id);
-}
-int isl_dim_has_dim_id(__isl_keep isl_space *dim,
- enum isl_dim_type type, unsigned pos)
-{
- return isl_space_has_dim_id(dim, type, pos);
-}
-__isl_give isl_id *isl_dim_get_dim_id(__isl_keep isl_space *dim,
- enum isl_dim_type type, unsigned pos)
-{
- return isl_space_get_dim_id(dim, type, pos);
-}
-
-int isl_dim_find_dim_by_id(__isl_keep isl_space *dim,
- enum isl_dim_type type, __isl_keep isl_id *id)
-{
- return isl_space_find_dim_by_id(dim, type, id);
-}
-
-__isl_give isl_space *isl_dim_set_tuple_id(__isl_take isl_space *dim,
- enum isl_dim_type type, __isl_take isl_id *id)
-{
- return isl_space_set_tuple_id(dim, type, id);
-}
-__isl_give isl_space *isl_dim_reset_tuple_id(__isl_take isl_space *dim,
- enum isl_dim_type type)
-{
- return isl_space_reset_tuple_id(dim, type);
-}
-int isl_dim_has_tuple_id(__isl_keep isl_space *dim, enum isl_dim_type type)
-{
- return isl_space_has_tuple_id(dim, type);
-}
-__isl_give isl_id *isl_dim_get_tuple_id(__isl_keep isl_space *dim,
- enum isl_dim_type type)
-{
- return isl_space_get_tuple_id(dim, type);
-}
-
-__isl_give isl_space *isl_dim_set_name(__isl_take isl_space *dim,
- enum isl_dim_type type, unsigned pos, __isl_keep const char *name)
-{
- return isl_space_set_dim_name(dim, type, pos, name);
-}
-__isl_keep const char *isl_dim_get_name(__isl_keep isl_space *dim,
- enum isl_dim_type type, unsigned pos)
-{
- return isl_space_get_dim_name(dim, type, pos);
-}
-
-__isl_give isl_space *isl_dim_set_tuple_name(__isl_take isl_space *dim,
- enum isl_dim_type type, const char *s)
-{
- return isl_space_set_tuple_name(dim, type, s);
-}
-const char *isl_dim_get_tuple_name(__isl_keep isl_space *dim,
- enum isl_dim_type type)
-{
- return isl_space_get_tuple_name(dim, type);
-}
-
-int isl_dim_is_wrapping(__isl_keep isl_space *dim)
-{
- return isl_space_is_wrapping(dim);
-}
-__isl_give isl_space *isl_dim_wrap(__isl_take isl_space *dim)
-{
- return isl_space_wrap(dim);
-}
-__isl_give isl_space *isl_dim_unwrap(__isl_take isl_space *dim)
-{
- return isl_space_unwrap(dim);
-}
-
-__isl_give isl_space *isl_dim_domain(__isl_take isl_space *dim)
-{
- return isl_space_domain(dim);
-}
-__isl_give isl_space *isl_dim_from_domain(__isl_take isl_space *dim)
-{
- return isl_space_from_domain(dim);
-}
-__isl_give isl_space *isl_dim_range(__isl_take isl_space *dim)
-{
- return isl_space_range(dim);
-}
-__isl_give isl_space *isl_dim_from_range(__isl_take isl_space *dim)
-{
- return isl_space_from_range(dim);
-}
-__isl_give isl_space *isl_dim_reverse(__isl_take isl_space *dim)
-{
- return isl_space_reverse(dim);
-}
-__isl_give isl_space *isl_dim_join(__isl_take isl_space *left,
- __isl_take isl_space *right)
-{
- return isl_space_join(left, right);
-}
-__isl_give isl_space *isl_dim_align_params(__isl_take isl_space *dim1,
- __isl_take isl_space *dim2)
-{
- return isl_space_align_params(dim1, dim2);
-}
-__isl_give isl_space *isl_dim_insert(__isl_take isl_space *dim,
- enum isl_dim_type type, unsigned pos, unsigned n)
-{
- return isl_space_insert_dims(dim, type, pos, n);
-}
-__isl_give isl_space *isl_dim_add(__isl_take isl_space *dim,
- enum isl_dim_type type, unsigned n)
-{
- return isl_space_add_dims(dim, type, n);
-}
-__isl_give isl_space *isl_dim_drop(__isl_take isl_space *dim,
- enum isl_dim_type type, unsigned first, unsigned n)
-{
- return isl_space_drop_dims(dim, type, first, n);
-}
-__isl_give isl_space *isl_dim_move(__isl_take isl_space *dim,
- enum isl_dim_type dst_type, unsigned dst_pos,
- enum isl_dim_type src_type, unsigned src_pos, unsigned n)
-{
- return isl_space_move_dims(dim, dst_type, dst_pos, src_type, src_pos, n);
-}
-__isl_give isl_space *isl_dim_map_from_set(__isl_take isl_space *dim)
-{
- return isl_space_map_from_set(dim);
-}
-__isl_give isl_space *isl_dim_zip(__isl_take isl_space *dim)
-{
- return isl_space_zip(dim);
-}
-
-__isl_give isl_local_space *isl_local_space_from_dim(
- __isl_take isl_space *dim)
-{
- return isl_local_space_from_space(dim);
-}
-__isl_give isl_space *isl_local_space_get_dim(
- __isl_keep isl_local_space *ls)
-{
- return isl_local_space_get_space(ls);
-}
-
-__isl_give isl_space *isl_aff_get_dim(__isl_keep isl_aff *aff)
-{
- return isl_aff_get_space(aff);
-}
-__isl_give isl_space *isl_pw_aff_get_dim(__isl_keep isl_pw_aff *pwaff)
-{
- return isl_pw_aff_get_space(pwaff);
-}
-
-__isl_give isl_space *isl_constraint_get_dim(
- __isl_keep isl_constraint *constraint)
-{
- return isl_constraint_get_space(constraint);
-}
-
-__isl_give isl_space *isl_basic_map_get_dim(__isl_keep isl_basic_map *bmap)
-{
- return isl_basic_map_get_space(bmap);
-}
-__isl_give isl_space *isl_map_get_dim(__isl_keep isl_map *map)
-{
- return isl_map_get_space(map);
-}
-__isl_give isl_space *isl_union_map_get_dim(__isl_keep isl_union_map *umap)
-{
- return isl_union_map_get_space(umap);
-}
-
-__isl_give isl_space *isl_basic_set_get_dim(__isl_keep isl_basic_set *bset)
-{
- return isl_basic_set_get_space(bset);
-}
-__isl_give isl_space *isl_set_get_dim(__isl_keep isl_set *set)
-{
- return isl_set_get_space(set);
-}
-__isl_give isl_space *isl_union_set_get_dim(__isl_keep isl_union_set *uset)
-{
- return isl_union_set_get_space(uset);
-}
-
-__isl_give isl_space *isl_point_get_dim(__isl_keep isl_point *pnt)
-{
- return isl_point_get_space(pnt);
-}
-
-__isl_give isl_space *isl_qpolynomial_get_dim(__isl_keep isl_qpolynomial *qp)
-{
- return isl_qpolynomial_get_space(qp);
-}
-__isl_give isl_space *isl_pw_qpolynomial_get_dim(
- __isl_keep isl_pw_qpolynomial *pwqp)
-{
- return isl_pw_qpolynomial_get_space(pwqp);
-}
-__isl_give isl_space *isl_qpolynomial_fold_get_dim(
- __isl_keep isl_qpolynomial_fold *fold)
-{
- return isl_qpolynomial_fold_get_space(fold);
-}
-__isl_give isl_space *isl_pw_qpolynomial_fold_get_dim(
- __isl_keep isl_pw_qpolynomial_fold *pwf)
-{
- return isl_pw_qpolynomial_fold_get_space(pwf);
-}
-__isl_give isl_space *isl_union_pw_qpolynomial_get_dim(
- __isl_keep isl_union_pw_qpolynomial *upwqp)
-{
- return isl_union_pw_qpolynomial_get_space(upwqp);
-}
-__isl_give isl_space *isl_union_pw_qpolynomial_fold_get_dim(
- __isl_keep isl_union_pw_qpolynomial_fold *upwf)
-{
- return isl_union_pw_qpolynomial_fold_get_space(upwf);
-}
#include <isl/set.h>
#include <isl/map.h>
+#include <isl/union_set.h>
+#include <isl/union_map.h>
#include <isl/flow.h>
#include <isl/schedule_node.h>
#include <isl_sort.h>
{
int i;
+ if (!data->sink)
+ return;
+
for (i = 0; i < data->n_sink; ++i) {
isl_map_free(data->sink[i].access);
isl_schedule_node_free(data->sink[i].node);
return NULL;
}
+/* Determine the sign of the constant quasipolynomial "qp".
+ *
+ * Return
+ * -1 if qp <= 0
+ * 1 if qp >= 0
+ * 0 if unknown
+ *
+ * For qp == 0, we can return either -1 or 1. In practice, we return 1.
+ * For qp == NaN, the sign is undefined, so we return 0.
+ */
static int isl_qpolynomial_cst_sign(__isl_keep isl_qpolynomial *qp)
{
struct isl_upoly_cst *cst;
+ if (isl_qpolynomial_is_nan(qp))
+ return 0;
+
cst = isl_upoly_as_cst(qp->upoly);
if (!cst)
return 0;
for (i = 0; i < fold2->n; ++i) {
for (j = n1 - 1; j >= 0; --j) {
isl_qpolynomial *d;
- int sgn;
+ int sgn, equal;
+ equal = isl_qpolynomial_plain_is_equal(res->qp[j],
+ fold2->qp[i]);
+ if (equal < 0)
+ goto error;
+ if (equal)
+ break;
d = isl_qpolynomial_sub(
isl_qpolynomial_copy(res->qp[j]),
isl_qpolynomial_copy(fold2->qp[i]));
#include <isl_stream_private.h>
#include <isl/obj.h>
#include "isl_polynomial_private.h"
+#include <isl/union_set.h>
#include <isl/union_map.h>
#include <isl_mat_private.h>
#include <isl_aff_private.h>
#include <isl_ctx_private.h>
#include <isl_map_private.h>
#include <isl_blk.h>
+#include <isl/constraint.h>
#include "isl_space_private.h"
#include "isl_equalities.h"
#include <isl_lp_private.h>
int i, cmp;
unsigned total;
+ if (!bmap1 || !bmap2)
+ return -1;
+
if (bmap1 == bmap2)
return 0;
if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_RATIONAL) !=
#include <isl/map.h>
+#include <isl/union_map.h>
#undef EL
#define EL isl_basic_map
int k, h, l;
isl_ctx *ctx;
- if (!bset)
- return NULL;
+ if (!bset || !context)
+ return bset;
size = round_up(4 * (context->n_ineq+1) / 3 - 1);
if (size == 0)
* opposite inequalities that can be replaced by an equality.
* We therefore call isl_basic_map_detect_inequality_pairs,
* which checks for such pairs of inequalities as well as eliminate_divs_eq
- * if such a pair was found.
+ * and isl_basic_map_gauss if such a pair was found.
*/
__isl_give isl_basic_map *isl_basic_map_reduce_coefficients(
__isl_take isl_basic_map *bmap)
int progress = 0;
bmap = isl_basic_map_detect_inequality_pairs(bmap, &progress);
- if (progress)
+ if (progress) {
bmap = eliminate_divs_eq(bmap, &progress);
+ bmap = isl_basic_map_gauss(bmap, NULL);
+ }
}
return bmap;
return sdc.diff;
}
+/* Return an empty map living in the same space as "map1" and "map2".
+ */
+static __isl_give isl_map *replace_pair_by_empty( __isl_take isl_map *map1,
+ __isl_take isl_map *map2)
+{
+ isl_space *space;
+
+ space = isl_map_get_space(map1);
+ isl_map_free(map1);
+ isl_map_free(map2);
+ return isl_map_empty(space);
+}
+
/* Return the set difference between map1 and map2.
* (U_i A_i) \ (U_j B_j) is computed as U_i (A_i \ (U_j B_j))
*
+ * If "map1" and "map2" are obviously equal to each other,
+ * then return an empty map in the same space.
+ *
* If "map1" and "map2" are disjoint, then simply return "map1".
*/
static __isl_give isl_map *map_subtract( __isl_take isl_map *map1,
__isl_take isl_map *map2)
{
int i;
- int disjoint;
+ int equal, disjoint;
struct isl_map *diff;
if (!map1 || !map2)
isl_assert(map1->ctx, isl_space_is_equal(map1->dim, map2->dim), goto error);
+ equal = isl_map_plain_is_equal(map1, map2);
+ if (equal < 0)
+ goto error;
+ if (equal)
+ return replace_pair_by_empty(map1, map2);
+
disjoint = isl_map_is_disjoint(map1, map2);
if (disjoint < 0)
goto error;
#include <isl/aff.h>
#include <isl/set.h>
#include <isl/map.h>
+#include <isl/union_set.h>
+#include <isl/union_map.h>
#include <isl/polynomial.h>
#include <isl/schedule.h>
#include <isl/obj.h>
#include <isl_mat_private.h>
#include <isl_vec_private.h>
#include <isl/set.h>
+#include <isl/union_set.h>
#include <isl_seq.h>
#include <isl_tab.h>
#include <isl_dim_map.h>
#include <isl/set.h>
+#include <isl/union_set.h>
#undef EL
#define EL isl_basic_set
__isl_give isl_space *isl_space_add_dims(__isl_take isl_space *dim,
enum isl_dim_type type, unsigned n)
{
+ dim = isl_space_reset(dim, type);
if (!dim)
return NULL;
- dim = isl_space_reset(dim, type);
switch (type) {
case isl_dim_param:
dim = isl_space_extend(dim,
static void sol_map_add_empty(struct isl_sol_map *sol,
struct isl_basic_set *bset)
{
- if (!bset)
+ if (!bset || !sol->empty)
goto error;
- isl_assert(bset->ctx, sol->empty, goto error);
sol->empty = isl_set_grow(sol->empty, 1);
bset = isl_basic_set_simplify(bset);
sample = isl_tab_sample(cgbr->tab);
- if (isl_tab_rollback(cgbr->tab, snap) < 0) {
+ if (!sample || isl_tab_rollback(cgbr->tab, snap) < 0) {
isl_vec_free(sample);
return NULL;
}
struct isl_gbr_tab_undo *snap = (struct isl_gbr_tab_undo *)save;
if (!snap)
goto error;
- if (isl_tab_rollback(cgbr->tab, snap->tab_snap) < 0) {
- isl_tab_free(cgbr->tab);
- cgbr->tab = NULL;
- }
+ if (isl_tab_rollback(cgbr->tab, snap->tab_snap) < 0)
+ goto error;
if (snap->shifted_snap) {
if (isl_tab_rollback(cgbr->shifted, snap->shifted_snap) < 0)
static void sol_pma_add_empty(struct isl_sol_pma *sol,
__isl_take isl_basic_set *bset)
{
- if (!bset)
+ if (!bset || !sol->empty)
goto error;
- isl_assert(bset->ctx, sol->empty, goto error);
sol->empty = isl_set_grow(sol->empty, 1);
bset = isl_basic_set_simplify(bset);
#include <isl/flow.h>
#include <isl_constraint_private.h>
#include <isl/polynomial.h>
+#include <isl/union_set.h>
#include <isl/union_map.h>
#include <isl_factorization.h>
#include <isl/schedule.h>
return 0;
}
-void test_read(struct isl_ctx *ctx)
+static int test_read(isl_ctx *ctx)
{
char *filename;
FILE *input;
- struct isl_basic_set *bset1, *bset2;
+ isl_basic_set *bset1, *bset2;
const char *str = "{[y]: Exists ( alpha : 2alpha = y)}";
+ int equal;
filename = get_filename(ctx, "set", "omega");
assert(filename);
bset1 = isl_basic_set_read_from_file(ctx, input);
bset2 = isl_basic_set_read_from_str(ctx, str);
- assert(isl_basic_set_is_equal(bset1, bset2) == 1);
+ equal = isl_basic_set_is_equal(bset1, bset2);
isl_basic_set_free(bset1);
isl_basic_set_free(bset2);
free(filename);
fclose(input);
+
+ if (equal < 0)
+ return -1;
+ if (!equal)
+ isl_die(ctx, isl_error_unknown,
+ "read sets not equal", return -1);
+
+ return 0;
}
-void test_bounded(struct isl_ctx *ctx)
+static int test_bounded(isl_ctx *ctx)
{
isl_set *set;
int bounded;
set = isl_set_read_from_str(ctx, "[n] -> {[i] : 0 <= i <= n }");
bounded = isl_set_is_bounded(set);
- assert(bounded);
isl_set_free(set);
+ if (bounded < 0)
+ return -1;
+ if (!bounded)
+ isl_die(ctx, isl_error_unknown,
+ "set not considered bounded", return -1);
+
set = isl_set_read_from_str(ctx, "{[n, i] : 0 <= i <= n }");
bounded = isl_set_is_bounded(set);
assert(!bounded);
isl_set_free(set);
+ if (bounded < 0)
+ return -1;
+ if (bounded)
+ isl_die(ctx, isl_error_unknown,
+ "set considered bounded", return -1);
+
set = isl_set_read_from_str(ctx, "[n] -> {[i] : i <= n }");
bounded = isl_set_is_bounded(set);
- assert(!bounded);
isl_set_free(set);
+
+ if (bounded < 0)
+ return -1;
+ if (bounded)
+ isl_die(ctx, isl_error_unknown,
+ "set considered bounded", return -1);
+
+ return 0;
}
/* Construct the basic set { [i] : 5 <= i <= N } */
-void test_construction(struct isl_ctx *ctx)
+static int test_construction(isl_ctx *ctx)
{
isl_int v;
isl_space *dim;
isl_local_space *ls;
- struct isl_basic_set *bset;
- struct isl_constraint *c;
+ isl_basic_set *bset;
+ isl_constraint *c;
isl_int_init(v);
isl_basic_set_free(bset);
isl_int_clear(v);
+
+ return 0;
}
-void test_dim(struct isl_ctx *ctx)
+static int test_dim(isl_ctx *ctx)
{
const char *str;
isl_map *map1, *map2;
+ int equal;
map1 = isl_map_read_from_str(ctx,
"[n] -> { [i] -> [j] : exists (a = [i/10] : i - 10a <= n ) }");
map1 = isl_map_add_dims(map1, isl_dim_in, 1);
map2 = isl_map_read_from_str(ctx,
"[n] -> { [i,k] -> [j] : exists (a = [i/10] : i - 10a <= n ) }");
- assert(isl_map_is_equal(map1, map2));
+ equal = isl_map_is_equal(map1, map2);
isl_map_free(map2);
map1 = isl_map_project_out(map1, isl_dim_in, 0, 1);
map2 = isl_map_read_from_str(ctx, "[n] -> { [i] -> [j] : n >= 0 }");
- assert(isl_map_is_equal(map1, map2));
+ if (equal >= 0 && equal)
+ equal = isl_map_is_equal(map1, map2);
isl_map_free(map1);
isl_map_free(map2);
+ if (equal < 0)
+ return -1;
+ if (!equal)
+ isl_die(ctx, isl_error_unknown,
+ "unexpected result", return -1);
+
str = "[n] -> { [i] -> [] : exists a : 0 <= i <= n and i = 2 a }";
map1 = isl_map_read_from_str(ctx, str);
str = "{ [i] -> [j] : exists a : 0 <= i <= j and i = 2 a }";
map2 = isl_map_read_from_str(ctx, str);
map1 = isl_map_move_dims(map1, isl_dim_out, 0, isl_dim_param, 0, 1);
- assert(isl_map_is_equal(map1, map2));
-
+ equal = isl_map_is_equal(map1, map2);
isl_map_free(map1);
isl_map_free(map2);
+
+ if (equal < 0)
+ return -1;
+ if (!equal)
+ isl_die(ctx, isl_error_unknown,
+ "unexpected result", return -1);
+
+ return 0;
}
struct {
fclose(input);
}
-void test_application(struct isl_ctx *ctx)
+static int test_application(isl_ctx *ctx)
{
test_application_case(ctx, "application");
test_application_case(ctx, "application2");
+
+ return 0;
}
void test_affine_hull_case(struct isl_ctx *ctx, const char *name)
"{ [x, y] : 1 = 0 }" },
};
-void test_convex_hull_algo(struct isl_ctx *ctx, int convex)
+static int test_convex_hull_algo(isl_ctx *ctx, int convex)
{
int i;
int orig_convex = ctx->opt->convex;
for (i = 0; i < ARRAY_SIZE(convex_hull_tests); ++i) {
isl_set *set1, *set2;
+ int equal;
set1 = isl_set_read_from_str(ctx, convex_hull_tests[i].set);
set2 = isl_set_read_from_str(ctx, convex_hull_tests[i].hull);
set1 = isl_set_from_basic_set(isl_set_convex_hull(set1));
- assert(isl_set_is_equal(set1, set2));
+ equal = isl_set_is_equal(set1, set2);
isl_set_free(set1);
isl_set_free(set2);
+
+ if (equal < 0)
+ return -1;
+ if (!equal)
+ isl_die(ctx, isl_error_unknown,
+ "unexpected convex hull", return -1);
}
ctx->opt->convex = orig_convex;
+
+ return 0;
}
-void test_convex_hull(struct isl_ctx *ctx)
+static int test_convex_hull(isl_ctx *ctx)
{
- test_convex_hull_algo(ctx, ISL_CONVEX_HULL_FM);
- test_convex_hull_algo(ctx, ISL_CONVEX_HULL_WRAP);
+ if (test_convex_hull_algo(ctx, ISL_CONVEX_HULL_FM) < 0)
+ return -1;
+ if (test_convex_hull_algo(ctx, ISL_CONVEX_HULL_WRAP) < 0)
+ return -1;
+ return 0;
}
void test_gist_case(struct isl_ctx *ctx, const char *name)
"n <= 2147483647 and t0 <= 31 and t0 >= 0 and i0 >= 11 and "
"i0 >= 96 - 3t0 and i0 <= 95 + n - 3t0 and i0 <= 7 + n and "
"i8 >= -40 + i0 and i8 <= -10 + i0)) }" },
+ { 0, "{ [i0, i1, i2] : "
+ "(exists (e0, e1 = floor((i0)/32), e2 = floor((i1)/32): "
+ "32e1 = i0 and 32e2 = i1 and i1 >= -31 + i0 and "
+ "i1 <= 31 + i0 and i2 >= -30 + i0 and i2 >= -30 + i1 and "
+ "32e0 >= -30 + i0 and 32e0 >= -30 + i1 and "
+ "32e0 >= -31 + i2 and 32e0 <= 30 + i2 and 32e0 <= 31 + i1 and "
+ "32e0 <= 31 + i0)) or "
+ "i0 >= 0 }" },
};
/* A specialized coalescing test case that would result
return 0;
}
-void test_closure(struct isl_ctx *ctx)
+static int test_closure(isl_ctx *ctx)
{
const char *str;
isl_set *dom;
map = isl_map_transitive_closure(map, NULL);
assert(map);
isl_map_free(map);
+
+ return 0;
}
-void test_lex(struct isl_ctx *ctx)
+static int test_lex(struct isl_ctx *ctx)
{
isl_space *dim;
isl_map *map;
+ int empty;
dim = isl_space_set_alloc(ctx, 0, 0);
map = isl_map_lex_le(dim);
- assert(!isl_map_is_empty(map));
+ empty = isl_map_is_empty(map);
isl_map_free(map);
+
+ if (empty < 0)
+ return -1;
+ if (empty)
+ isl_die(ctx, isl_error_unknown,
+ "expecting non-empty result", return -1);
+
+ return 0;
}
static int test_lexmin(struct isl_ctx *ctx)
return 0;
}
-void test_dep(struct isl_ctx *ctx)
+static int test_dep(struct isl_ctx *ctx)
{
const char *str;
isl_space *dim;
isl_map_free(mm.must);
isl_map_free(mm.may);
isl_flow_free(flow);
+
+ return 0;
}
/* Check that the dependence analysis proceeds without errors.
return 0;
}
-void test_bijective_case(struct isl_ctx *ctx, const char *str, int bijective)
+struct {
+ const char *str;
+ int bijective;
+} bijective_tests[] = {
+ { "[N,M]->{[i,j] -> [i]}", 0 },
+ { "[N,M]->{[i,j] -> [i] : j=i}", 1 },
+ { "[N,M]->{[i,j] -> [i] : j=0}", 1 },
+ { "[N,M]->{[i,j] -> [i] : j=N}", 1 },
+ { "[N,M]->{[i,j] -> [j,i]}", 1 },
+ { "[N,M]->{[i,j] -> [i+j]}", 0 },
+ { "[N,M]->{[i,j] -> []}", 0 },
+ { "[N,M]->{[i,j] -> [i,j,N]}", 1 },
+ { "[N,M]->{[i,j] -> [2i]}", 0 },
+ { "[N,M]->{[i,j] -> [i,i]}", 0 },
+ { "[N,M]->{[i,j] -> [2i,i]}", 0 },
+ { "[N,M]->{[i,j] -> [2i,j]}", 1 },
+ { "[N,M]->{[i,j] -> [x,y] : 2x=i & y =j}", 1 },
+};
+
+static int test_bijective(struct isl_ctx *ctx)
{
isl_map *map;
+ int i;
+ int bijective;
- map = isl_map_read_from_str(ctx, str);
- if (bijective)
- assert(isl_map_is_bijective(map));
- else
- assert(!isl_map_is_bijective(map));
- isl_map_free(map);
-}
+ for (i = 0; i < ARRAY_SIZE(bijective_tests); ++i) {
+ map = isl_map_read_from_str(ctx, bijective_tests[i].str);
+ bijective = isl_map_is_bijective(map);
+ isl_map_free(map);
+ if (bijective < 0)
+ return -1;
+ if (bijective_tests[i].bijective && !bijective)
+ isl_die(ctx, isl_error_internal,
+ "map not detected as bijective", return -1);
+ if (!bijective_tests[i].bijective && bijective)
+ isl_die(ctx, isl_error_internal,
+ "map detected as bijective", return -1);
+ }
-void test_bijective(struct isl_ctx *ctx)
-{
- test_bijective_case(ctx, "[N,M]->{[i,j] -> [i]}", 0);
- test_bijective_case(ctx, "[N,M]->{[i,j] -> [i] : j=i}", 1);
- test_bijective_case(ctx, "[N,M]->{[i,j] -> [i] : j=0}", 1);
- test_bijective_case(ctx, "[N,M]->{[i,j] -> [i] : j=N}", 1);
- test_bijective_case(ctx, "[N,M]->{[i,j] -> [j,i]}", 1);
- test_bijective_case(ctx, "[N,M]->{[i,j] -> [i+j]}", 0);
- test_bijective_case(ctx, "[N,M]->{[i,j] -> []}", 0);
- test_bijective_case(ctx, "[N,M]->{[i,j] -> [i,j,N]}", 1);
- test_bijective_case(ctx, "[N,M]->{[i,j] -> [2i]}", 0);
- test_bijective_case(ctx, "[N,M]->{[i,j] -> [i,i]}", 0);
- test_bijective_case(ctx, "[N,M]->{[i,j] -> [2i,i]}", 0);
- test_bijective_case(ctx, "[N,M]->{[i,j] -> [2i,j]}", 1);
- test_bijective_case(ctx, "[N,M]->{[i,j] -> [x,y] : 2x=i & y =j}", 1);
+ return 0;
}
/* Inputs for isl_pw_qpolynomial_gist tests.
return 0;
}
-void test_split_periods(isl_ctx *ctx)
+static int test_split_periods(isl_ctx *ctx)
{
const char *str;
isl_pw_qpolynomial *pwqp;
pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
pwqp = isl_pw_qpolynomial_split_periods(pwqp, 2);
- assert(pwqp);
isl_pw_qpolynomial_free(pwqp);
+
+ if (!pwqp)
+ return -1;
+
+ return 0;
}
-void test_union(isl_ctx *ctx)
+static int test_union(isl_ctx *ctx)
{
const char *str;
isl_union_set *uset1, *uset2;
isl_union_map *umap1, *umap2;
+ int equal;
str = "{ [i] : 0 <= i <= 1 }";
uset1 = isl_union_set_read_from_str(ctx, str);
umap1 = isl_union_map_read_from_str(ctx, str);
umap2 = isl_union_set_lex_gt_union_set(isl_union_set_copy(uset1), uset1);
- assert(isl_union_map_is_equal(umap1, umap2));
+ equal = isl_union_map_is_equal(umap1, umap2);
isl_union_map_free(umap1);
isl_union_map_free(umap2);
+ if (equal < 0)
+ return -1;
+ if (!equal)
+ isl_die(ctx, isl_error_unknown, "union maps not equal",
+ return -1);
+
str = "{ A[i] -> B[i]; B[i] -> C[i]; A[0] -> C[1] }";
umap1 = isl_union_map_read_from_str(ctx, str);
str = "{ A[i]; B[i] }";
uset2 = isl_union_map_domain(umap1);
- assert(isl_union_set_is_equal(uset1, uset2));
+ equal = isl_union_set_is_equal(uset1, uset2);
isl_union_set_free(uset1);
isl_union_set_free(uset2);
+
+ if (equal < 0)
+ return -1;
+ if (!equal)
+ isl_die(ctx, isl_error_unknown, "union sets not equal",
+ return -1);
+
+ return 0;
+}
+
+/* Check that computing a bound of a non-zero polynomial over an unbounded
+ * domain does not produce a rational value.
+ * Ideally, we want the value to be infinity, but we accept NaN for now.
+ * We certainly do not want to obtain the value zero.
+ */
+static int test_bound_unbounded_domain(isl_ctx *ctx)
+{
+ const char *str;
+ isl_set *dom;
+ isl_point *pnt;
+ isl_pw_qpolynomial *pwqp;
+ isl_pw_qpolynomial_fold *pwf;
+ isl_val *v;
+ int is_rat;
+
+ str = "{ [m,n] -> -m * n }";
+ pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
+ pwf = isl_pw_qpolynomial_bound(pwqp, isl_fold_max, NULL);
+ dom = isl_pw_qpolynomial_fold_domain(isl_pw_qpolynomial_fold_copy(pwf));
+ pnt = isl_set_sample_point(dom);
+ v = isl_pw_qpolynomial_fold_eval(pwf, pnt);
+ is_rat = isl_val_is_rat(v);
+ isl_val_free(v);
+
+ if (is_rat < 0)
+ return -1;
+ if (is_rat)
+ isl_die(ctx, isl_error_unknown,
+ "unexpected rational value", return -1);
+
+ return 0;
}
-void test_bound(isl_ctx *ctx)
+static int test_bound(isl_ctx *ctx)
{
const char *str;
+ unsigned dim;
isl_pw_qpolynomial *pwqp;
isl_pw_qpolynomial_fold *pwf;
+ if (test_bound_unbounded_domain(ctx) < 0)
+ return -1;
+
str = "{ [[a, b, c, d] -> [e]] -> 0 }";
pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
pwf = isl_pw_qpolynomial_bound(pwqp, isl_fold_max, NULL);
- assert(isl_pw_qpolynomial_fold_dim(pwf, isl_dim_in) == 4);
+ dim = isl_pw_qpolynomial_fold_dim(pwf, isl_dim_in);
isl_pw_qpolynomial_fold_free(pwf);
+ if (dim != 4)
+ isl_die(ctx, isl_error_unknown, "unexpected input dimension",
+ return -1);
str = "{ [[x]->[x]] -> 1 : exists a : x = 2 a }";
pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
pwf = isl_pw_qpolynomial_bound(pwqp, isl_fold_max, NULL);
- assert(isl_pw_qpolynomial_fold_dim(pwf, isl_dim_in) == 1);
+ dim = isl_pw_qpolynomial_fold_dim(pwf, isl_dim_in);
isl_pw_qpolynomial_fold_free(pwf);
+ if (dim != 1)
+ isl_die(ctx, isl_error_unknown, "unexpected input dimension",
+ return -1);
+
+ return 0;
}
-void test_lift(isl_ctx *ctx)
+static int test_lift(isl_ctx *ctx)
{
const char *str;
isl_basic_map *bmap;
bmap = isl_basic_map_from_range(bset);
bset = isl_basic_map_domain(bmap);
isl_basic_set_free(bset);
+
+ return 0;
}
struct {
{ "min", &test_min },
{ "gist", &test_gist },
{ "piecewise quasi-polynomials", &test_pwqp },
+ { "lift", &test_lift },
+ { "bound", &test_bound },
+ { "union", &test_union },
+ { "split periods", &test_split_periods },
+ { "lexicographic order", &test_lex },
+ { "bijectivity", &test_bijective },
+ { "dataflow analysis", &test_dep },
+ { "reading", &test_read },
+ { "bounded", &test_bounded },
+ { "construction", &test_construction },
+ { "dimension manipulation", &test_dim },
+ { "map application", &test_application },
+ { "convex hull", &test_convex_hull },
+ { "transitive closure", &test_closure },
};
int main(int argc, char **argv)
if (tests[i].fn(ctx) < 0)
goto error;
}
- test_lift(ctx);
- test_bound(ctx);
- test_union(ctx);
- test_split_periods(ctx);
- test_lex(ctx);
- test_bijective(ctx);
- test_dep(ctx);
- test_read(ctx);
- test_bounded(ctx);
- test_construction(ctx);
- test_dim(ctx);
- test_application(ctx);
- test_convex_hull(ctx);
- test_closure(ctx);
isl_ctx_free(ctx);
return 0;
error:
bmap = isl_basic_map_alloc_space(dim, 0, 1, 1);
if (exactly) {
k = isl_basic_map_alloc_equality(bmap);
+ if (k < 0)
+ goto error;
c = bmap->eq[k];
} else {
k = isl_basic_map_alloc_inequality(bmap);
+ if (k < 0)
+ goto error;
c = bmap->ineq[k];
}
- if (k < 0)
- goto error;
isl_seq_clr(c, 1 + isl_basic_map_total_dim(bmap));
isl_int_set_si(c[0], -length);
isl_int_set_si(c[1 + nparam + d - 1], -1);
continue;
if (eq && p != MIXED) {
k = isl_basic_map_alloc_equality(path);
+ if (k < 0)
+ goto error;
path_c = path->eq[k];
} else {
k = isl_basic_map_alloc_inequality(path);
+ if (k < 0)
+ goto error;
path_c = path->ineq[k];
}
- if (k < 0)
- goto error;
isl_seq_clr(path_c, 1 + isl_basic_map_total_dim(path));
if (p == PURE_VAR) {
isl_seq_cpy(path_c + off,
unsigned d;
int i, j, n;
+ if (!map)
+ goto error;
+
d = isl_map_dim(map, isl_dim_in);
path = isl_map_identity(isl_space_copy(dim));
isl_set *i;
int no_overlap;
+ if (!set1 || !set2)
+ return -1;
+
if (!isl_space_tuple_is_equal(set1->dim, isl_dim_set,
set2->dim, isl_dim_set))
return 0;
struct isl_set *range = NULL;
struct isl_map *app = NULL;
struct isl_map *path = NULL;
+ int overlaps;
domain = isl_map_domain(isl_map_copy(map));
domain = isl_set_coalesce(domain);
range = isl_map_range(isl_map_copy(map));
range = isl_set_coalesce(range);
- if (!isl_set_overlaps(domain, range)) {
+ overlaps = isl_set_overlaps(domain, range);
+ if (overlaps < 0 || !overlaps) {
isl_set_free(domain);
isl_set_free(range);
isl_space_free(dim);
+ if (overlaps < 0)
+ map = NULL;
map = isl_map_copy(map);
map = isl_map_add_dims(map, isl_dim_in, 1);
map = isl_map_add_dims(map, isl_dim_out, 1);
External/isl/isl_convex_hull.c \
External/isl/isl_ctx.c \
External/isl/isl_deprecated.c \
- External/isl/isl_dim.c \
External/isl/isl_dim_map.c \
External/isl/isl_equalities.c \
External/isl/isl_factorization.c \
ret void
}
-; VALUE: region: 'S1 => exit.3' in function 'sequential_writes':
+; VALUE-LABEL: region: 'S1 => exit.3' in function 'sequential_writes':
; VALUE: RAW dependences:
; VALUE: { }
; VALUE: WAR dependences:
; VALUE: Stmt_S1[i0] -> Stmt_S3[i0] : i0 >= 10 and i0 <= 99
; VALUE: }
-; MEMORY: region: 'S1 => exit.3' in function 'sequential_writes':
+; MEMORY-LABEL: region: 'S1 => exit.3' in function 'sequential_writes':
; MEMORY: RAW dependences:
; MEMORY: { }
; MEMORY: WAR dependences:
ret void
}
-; VALUE: region: 'S1 => exit.3' in function 'read_after_writes':
+; VALUE-LABEL: region: 'S1 => exit.3' in function 'read_after_writes':
; VALUE: RAW dependences:
; VALUE: {
; VALUE: Stmt_S2[i0] -> Stmt_S3[i0] : i0 >= 0 and i0 <= 9;
; VALUE: { }
; VALUE: WAW dependences:
; VALUE: {
-; VALUE: Stmt_S1[i0] -> Stmt_S2[i0] : i0 >= 0 and i0 <= 9
+; VALUE: Stmt_S1[i0] -> Stmt_S2[i0] : i0 <= 9 and i0 >= 0
; VALUE: }
-; MEMORY: region: 'S1 => exit.3' in function 'read_after_writes':
+; MEMORY-LABEL: region: 'S1 => exit.3' in function 'read_after_writes':
; MEMORY: RAW dependences:
; MEMORY: {
; MEMORY: Stmt_S2[i0] -> Stmt_S3[i0] : i0 <= 9 and i0 >= 0;
ret void
}
-; VALUE: region: 'S1 => exit.3' in function 'write_after_read':
+; VALUE-LABEL: region: 'S1 => exit.3' in function 'write_after_read':
; VALUE: RAW dependences:
; VALUE: {
; VALUE: }
; VALUE: }
; VALUE: WAW dependences:
; VALUE: {
-; VALUE: Stmt_S2[i0] -> Stmt_S3[i0] : i0 >= 0 and i0 <= 9
+; VALUE: Stmt_S2[i0] -> Stmt_S3[i0] : i0 <= 9 and i0 >= 0
; VALUE: }
-; MEMORY: region: 'S1 => exit.3' in function 'write_after_read':
+; MEMORY-LABEL: region: 'S1 => exit.3' in function 'write_after_read':
; MEMORY: RAW dependences:
; MEMORY: {
; MEMORY: }
projects / platform / upstream / llvm.git / commitdiff