isl_convex_hull.c: initial_facet_constraint: fix error handling

[platform/upstream/isl.git] / isl_convex_hull.c

diff --git a/isl_convex_hull.c b/isl_convex_hull.c
index cf3cfbf..75b0286 100644 (file)
--- a/isl_convex_hull.c
+++ b/isl_convex_hull.c
@@ -79,7 +79,7 @@ int isl_basic_set_constraint_is_redundant(struct isl_basic_set **bset,
                        (struct isl_basic_map **)bset, c, opt_n, opt_d);
 }
 
-/* Compute the convex hull of a basic map, by removing the redundant
+/* Remove redundant
  * constraints.  If the minimal value along the normal of a constraint
  * is the same if the constraint is removed, then the constraint is redundant.
  *
@@ -87,7 +87,8 @@ int isl_basic_set_constraint_is_redundant(struct isl_basic_set **bset,
  * corresponding equality and the checked if the dimension was that
  * of a facet.
  */
-struct isl_basic_map *isl_basic_map_convex_hull(struct isl_basic_map *bmap)
+__isl_give isl_basic_map *isl_basic_map_remove_redundancies(
+       __isl_take isl_basic_map *bmap)
 {
        struct isl_tab *tab;
 
@@ -118,10 +119,11 @@ error:
        return NULL;
 }
 
-struct isl_basic_set *isl_basic_set_convex_hull(struct isl_basic_set *bset)
+__isl_give isl_basic_set *isl_basic_set_remove_redundancies(
+       __isl_take isl_basic_set *bset)
 {
        return (struct isl_basic_set *)
-               isl_basic_map_convex_hull((struct isl_basic_map *)bset);
+               isl_basic_map_remove_redundancies((struct isl_basic_map *)bset);
 }
 
 /* Check if the set set is bound in the direction of the affine
@@ -381,6 +383,7 @@ isl_int *isl_set_wrap_facet(__isl_keep isl_set *set,
        isl_int *facet, isl_int *ridge)
 {
        int i;
+       isl_ctx *ctx;
        struct isl_mat *T = NULL;
        struct isl_basic_set *lp = NULL;
        struct isl_vec *obj;
@@ -388,11 +391,14 @@ isl_int *isl_set_wrap_facet(__isl_keep isl_set *set,
        isl_int num, den;
        unsigned dim;
 
+       if (!set)
+               return NULL;
+       ctx = set->ctx;
        set = isl_set_copy(set);
        set = isl_set_set_rational(set);
 
        dim = 1 + isl_set_n_dim(set);
-       T = isl_mat_alloc(set->ctx, 3, dim);
+       T = isl_mat_alloc(ctx, 3, dim);
        if (!T)
                goto error;
        isl_int_set_si(T->row[0][0], 1);
@@ -405,7 +411,7 @@ isl_int *isl_set_wrap_facet(__isl_keep isl_set *set,
        if (!set)
                goto error;
        lp = wrap_constraints(set);
-       obj = isl_vec_alloc(set->ctx, 1 + dim*set->n);
+       obj = isl_vec_alloc(ctx, 1 + dim*set->n);
        if (!obj)
                goto error;
        isl_int_set_si(obj->block.data[0], 0);
@@ -417,7 +423,7 @@ isl_int *isl_set_wrap_facet(__isl_keep isl_set *set,
        isl_int_init(num);
        isl_int_init(den);
        res = isl_basic_set_solve_lp(lp, 0,
-                           obj->block.data, set->ctx->one, &num, &den, NULL);
+                           obj->block.data, ctx->one, &num, &den, NULL);
        if (res == isl_lp_ok) {
                isl_int_neg(num, num);
                isl_seq_combine(facet, num, facet, den, ridge, dim);
@@ -427,7 +433,9 @@ isl_int *isl_set_wrap_facet(__isl_keep isl_set *set,
        isl_vec_free(obj);
        isl_basic_set_free(lp);
        isl_set_free(set);
-       isl_assert(set->ctx, res == isl_lp_ok || res == isl_lp_unbounded, 
+       if (res == isl_lp_error)
+               return NULL;
+       isl_assert(ctx, res == isl_lp_ok || res == isl_lp_unbounded, 
                   return NULL);
        return facet;
 error:
@@ -467,7 +475,9 @@ static __isl_give isl_mat *initial_facet_constraint(__isl_keep isl_set *set)
        isl_seq_clr(bounds->row[0], dim);
        isl_int_set_si(bounds->row[0][1 + dim - 1], 1);
        is_bound = uset_is_bound(set, bounds->row[0], 1 + dim);
-       isl_assert(set->ctx, is_bound == 1, goto error);
+       if (is_bound < 0)
+               goto error;
+       isl_assert(set->ctx, is_bound, goto error);
        isl_seq_normalize(set->ctx, bounds->row[0], 1 + dim);
        bounds->n_row = 1;
 
@@ -617,11 +627,13 @@ static struct isl_basic_set *extend(struct isl_basic_set *hull,
                hull_facet = isl_basic_set_add_equality(hull_facet, hull->ineq[i]);
                hull_facet = isl_basic_set_gauss(hull_facet, NULL);
                hull_facet = isl_basic_set_normalize_constraints(hull_facet);
-               if (!facet)
+               if (!facet || !hull_facet)
                        goto error;
                hull = isl_basic_set_cow(hull);
                hull = isl_basic_set_extend_dim(hull,
                        isl_dim_copy(hull->dim), 0, 0, facet->n_ineq);
+               if (!hull)
+                       goto error;
                for (j = 0; j < facet->n_ineq; ++j) {
                        for (f = 0; f < hull_facet->n_ineq; ++f)
                                if (isl_seq_eq(facet->ineq[j],
@@ -857,7 +869,7 @@ static struct isl_basic_set *convex_hull_pair_elim(struct isl_basic_set *bset1,
        }
        hull = isl_basic_set_set_rational(hull);
        hull = isl_basic_set_remove_dims(hull, dim, 2*(1+dim));
-       hull = isl_basic_set_convex_hull(hull);
+       hull = isl_basic_set_remove_redundancies(hull);
        isl_basic_set_free(bset1);
        isl_basic_set_free(bset2);
        return hull;
@@ -1802,6 +1814,9 @@ static struct isl_basic_set *uset_convex_hull_wrap_bounded(struct isl_set *set)
 {
        struct isl_basic_set *convex_hull = NULL;
 
+       if (!set)
+               goto error;
+
        if (isl_set_n_dim(set) == 0) {
                convex_hull = isl_basic_set_universe(isl_dim_copy(set->dim));
                isl_set_free(set);
@@ -1810,9 +1825,6 @@ static struct isl_basic_set *uset_convex_hull_wrap_bounded(struct isl_set *set)
        }
 
        set = isl_set_set_rational(set);
-
-       if (!set)
-               goto error;
        set = isl_set_coalesce(set);
        if (!set)
                goto error;
@@ -1885,6 +1897,8 @@ struct isl_basic_map *isl_map_convex_hull(struct isl_map *map)
 
        map = isl_map_detect_equalities(map);
        map = isl_map_align_divs(map);
+       if (!map)
+               goto error;
        model = isl_basic_map_copy(map->p[0]);
        set = isl_map_underlying_set(map);
        if (!set)
@@ -1901,6 +1915,8 @@ struct isl_basic_map *isl_map_convex_hull(struct isl_map *map)
        }
 
        convex_hull = isl_basic_map_overlying_set(bset, model);
+       if (!convex_hull)
+               return NULL;
 
        ISL_F_SET(convex_hull, ISL_BASIC_MAP_NO_IMPLICIT);
        ISL_F_SET(convex_hull, ISL_BASIC_MAP_ALL_EQUALITIES);
@@ -2273,7 +2289,7 @@ struct isl_basic_map *isl_map_simple_hull(struct isl_map *map)
        hull = isl_basic_map_overlying_set(bset, model);
 
        hull = isl_basic_map_intersect(hull, affine_hull);
-       hull = isl_basic_map_convex_hull(hull);
+       hull = isl_basic_map_remove_redundancies(hull);
        ISL_F_SET(hull, ISL_BASIC_MAP_NO_IMPLICIT);
        ISL_F_SET(hull, ISL_BASIC_MAP_ALL_EQUALITIES);