hide isl_basic_set internals

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

diff --git a/isl_tab_pip.c b/isl_tab_pip.c
index f868290..acf6ead 100644 (file)
--- a/isl_tab_pip.c
+++ b/isl_tab_pip.c
@@ -8,9 +8,10 @@
  */
 
 #include "isl_map_private.h"
-#include "isl_seq.h"
+#include <isl/seq.h>
 #include "isl_tab.h"
 #include "isl_sample.h"
+#include <isl_mat_private.h>
 
 /*
  * The implementation of parametric integer linear programming in this file
@@ -448,17 +449,17 @@ static void sol_add(struct isl_sol *sol, struct isl_tab *tab)
 
                isl_seq_clr(mat->row[1 + row], mat->n_col);
                if (!tab->var[i].is_row) {
-                       /* no unbounded */
-                       isl_assert(mat->ctx, !tab->M, goto error2);
+                       if (tab->M)
+                               isl_die(mat->ctx, isl_error_invalid,
+                                       "unbounded optimum", goto error2);
                        continue;
                }
 
                r = tab->var[i].index;
-               /* no unbounded */
-               if (tab->M)
-                       isl_assert(mat->ctx, isl_int_eq(tab->mat->row[r][2],
-                                                       tab->mat->row[r][0]),
-                                   goto error2);
+               if (tab->M &&
+                   isl_int_ne(tab->mat->row[r][2], tab->mat->row[r][0]))
+                       isl_die(mat->ctx, isl_error_invalid,
+                               "unbounded optimum", goto error2);
                isl_int_gcd(m, mat->row[0][0], tab->mat->row[r][0]);
                isl_int_divexact(m, tab->mat->row[r][0], m);
                scale_rows(mat, m, 1 + row);
@@ -494,7 +495,7 @@ error2:
 error:
        isl_basic_set_free(bset);
        isl_mat_free(mat);
-       sol_free(sol);
+       sol->error = 1;
 }
 
 struct isl_sol_map {
@@ -505,6 +506,8 @@ struct isl_sol_map {
 
 static void sol_map_free(struct isl_sol_map *sol_map)
 {
+       if (!sol_map)
+               return;
        if (sol_map->sol.context)
                sol_map->sol.context->op->free(sol_map->sol.context);
        isl_map_free(sol_map->map);
@@ -1084,8 +1087,11 @@ static int first_neg(struct isl_tab *tab)
                for (row = tab->n_redundant; row < tab->n_row; ++row) {
                        if (!isl_tab_var_from_row(tab, row)->is_nonneg)
                                continue;
-                       if (isl_int_is_neg(tab->mat->row[row][2]))
-                               return row;
+                       if (!isl_int_is_neg(tab->mat->row[row][2]))
+                               continue;
+                       if (tab->row_sign)
+                               tab->row_sign[row] = isl_tab_row_neg;
+                       return row;
                }
        for (row = tab->n_redundant; row < tab->n_row; ++row) {
                if (!isl_tab_var_from_row(tab, row)->is_nonneg)
@@ -1217,8 +1223,6 @@ static struct isl_tab *add_lexmin_valid_eq(struct isl_tab *tab, isl_int *eq)
                if (isl_tab_kill_col(tab, i) < 0)
                        goto error;
                tab->n_eq++;
-
-               tab = restore_lexmin(tab);
        }
 
        return tab;
@@ -1785,7 +1789,7 @@ static int find_div(struct isl_tab *tab, isl_int *div, isl_int denom)
        for (i = 0; i < tab->bmap->n_div; ++i) {
                if (isl_int_ne(tab->bmap->div[i][0], denom))
                        continue;
-               if (!isl_seq_eq(tab->bmap->div[i] + 1, div, total))
+               if (!isl_seq_eq(tab->bmap->div[i] + 1, div, 1 + total))
                        continue;
                return i;
        }
@@ -1985,6 +1989,8 @@ static struct isl_tab *tab_for_lexmin(struct isl_basic_map *bmap,
                if (!tab || tab->empty)
                        return tab;
        }
+       if (bmap->n_eq)
+               tab = restore_lexmin(tab);
        for (i = 0; i < bmap->n_ineq; ++i) {
                if (max)
                        isl_seq_neg(bmap->ineq[i] + 1 + tab->n_param,
@@ -2175,10 +2181,11 @@ static enum isl_tab_row_sign tab_ineq_sign(struct isl_tab *tab, isl_int *ineq,
        int i;
        int sgn;
        isl_int tmp;
-       int res = isl_tab_row_unknown;
+       enum isl_tab_row_sign res = isl_tab_row_unknown;
 
-       isl_assert(tab->mat->ctx, tab->samples, return 0);
-       isl_assert(tab->mat->ctx, tab->samples->n_col == 1 + tab->n_var, return 0);
+       isl_assert(tab->mat->ctx, tab->samples, return isl_tab_row_unknown);
+       isl_assert(tab->mat->ctx, tab->samples->n_col == 1 + tab->n_var,
+                       return isl_tab_row_unknown);
 
        isl_int_init(tmp);
        for (i = tab->n_outside; i < tab->n_sample; ++i) {
@@ -2272,7 +2279,7 @@ static int context_lex_best_split(struct isl_context *context,
                return -1;
        r = best_split(tab, clex->tab);
 
-       if (isl_tab_rollback(clex->tab, snap) < 0)
+       if (r >= 0 && isl_tab_rollback(clex->tab, snap) < 0)
                return -1;
 
        return r;
@@ -2380,6 +2387,9 @@ static struct isl_tab *context_lex_detect_nonnegative_parameters(
        struct isl_context_lex *clex = (struct isl_context_lex *)context;
        struct isl_tab_undo *snap;
 
+       if (!tab)
+               return NULL;
+
        snap = isl_tab_snap(clex->tab);
        if (isl_tab_push_basis(clex->tab) < 0)
                goto error;
@@ -2484,6 +2494,8 @@ static struct isl_tab *context_gbr_detect_nonnegative_parameters(
        struct isl_context *context, struct isl_tab *tab)
 {
        struct isl_context_gbr *cgbr = (struct isl_context_gbr *)context;
+       if (!tab)
+               return NULL;
        return tab_detect_nonnegative_parameters(tab, cgbr->tab);
 }
 
@@ -2599,14 +2611,13 @@ static struct isl_vec *gbr_get_sample(struct isl_context_gbr *cgbr)
 
        if (!cgbr->cone) {
                bset = isl_tab_peek_bset(cgbr->tab);
-               cgbr->cone = isl_tab_from_recession_cone(bset);
+               cgbr->cone = isl_tab_from_recession_cone(bset, 0);
                if (!cgbr->cone)
                        return NULL;
                if (isl_tab_track_bset(cgbr->cone, isl_basic_set_dup(bset)) < 0)
                        return NULL;
        }
-       cgbr->cone = isl_tab_detect_implicit_equalities(cgbr->cone);
-       if (!cgbr->cone)
+       if (isl_tab_detect_implicit_equalities(cgbr->cone) < 0)
                return NULL;
 
        if (cgbr->cone->n_dead == cgbr->cone->n_col) {
@@ -2617,10 +2628,9 @@ static struct isl_vec *gbr_get_sample(struct isl_context_gbr *cgbr)
                        if (cgbr->tab->basis->n_col != 1 + cgbr->tab->n_var) {
                                isl_mat_free(cgbr->tab->basis);
                                cgbr->tab->basis = NULL;
-                       } else {
-                               cgbr->tab->n_zero = 0;
-                               cgbr->tab->n_unbounded = 0;
                        }
+                       cgbr->tab->n_zero = 0;
+                       cgbr->tab->n_unbounded = 0;
                }
 
                snap = isl_tab_snap(cgbr->tab);
@@ -2688,7 +2698,8 @@ static struct isl_tab *add_gbr_eq(struct isl_tab *tab, isl_int *eq)
        if (isl_tab_extend_cons(tab, 2) < 0)
                goto error;
 
-       tab = isl_tab_add_eq(tab, eq);
+       if (isl_tab_add_eq(tab, eq) < 0)
+               goto error;
 
        return tab;
 error:
@@ -2706,7 +2717,8 @@ static void context_gbr_add_eq(struct isl_context *context, isl_int *eq,
        if (cgbr->cone && cgbr->cone->n_col != cgbr->cone->n_dead) {
                if (isl_tab_extend_cons(cgbr->cone, 2) < 0)
                        goto error;
-               cgbr->cone = isl_tab_add_eq(cgbr->cone, eq);
+               if (isl_tab_add_eq(cgbr->cone, eq) < 0)
+                       goto error;
        }
 
        if (check) {
@@ -2965,13 +2977,14 @@ static int context_gbr_detect_equalities(struct isl_context *context,
 
        if (!cgbr->cone) {
                struct isl_basic_set *bset = isl_tab_peek_bset(cgbr->tab);
-               cgbr->cone = isl_tab_from_recession_cone(bset);
+               cgbr->cone = isl_tab_from_recession_cone(bset, 0);
                if (!cgbr->cone)
                        goto error;
                if (isl_tab_track_bset(cgbr->cone, isl_basic_set_dup(bset)) < 0)
                        goto error;
        }
-       cgbr->cone = isl_tab_detect_implicit_equalities(cgbr->cone);
+       if (isl_tab_detect_implicit_equalities(cgbr->cone) < 0)
+               goto error;
 
        n_ineq = cgbr->tab->bmap->n_ineq;
        cgbr->tab = isl_tab_detect_equalities(cgbr->tab, cgbr->cone);
@@ -3027,7 +3040,7 @@ static int context_gbr_best_split(struct isl_context *context,
        snap = isl_tab_snap(cgbr->tab);
        r = best_split(tab, cgbr->tab);
 
-       if (isl_tab_rollback(cgbr->tab, snap) < 0)
+       if (r >= 0 && isl_tab_rollback(cgbr->tab, snap) < 0)
                return -1;
 
        return r;
@@ -3205,9 +3218,12 @@ static struct isl_context *isl_context_alloc(struct isl_basic_set *dom)
 static struct isl_sol_map *sol_map_init(struct isl_basic_map *bmap,
        struct isl_basic_set *dom, int track_empty, int max)
 {
-       struct isl_sol_map *sol_map;
+       struct isl_sol_map *sol_map = NULL;
 
-       sol_map = isl_calloc_type(bset->ctx, struct isl_sol_map);
+       if (!bmap)
+               goto error;
+
+       sol_map = isl_calloc_type(bmap->ctx, struct isl_sol_map);
        if (!sol_map)
                goto error;
 
@@ -3347,7 +3363,7 @@ static enum isl_tab_row_sign row_sign(struct isl_tab *tab,
        struct isl_sol *sol, int row)
 {
        struct isl_vec *ineq = NULL;
-       int res = isl_tab_row_unknown;
+       enum isl_tab_row_sign res = isl_tab_row_unknown;
        int critical;
        int strict;
        int row2;
@@ -3411,7 +3427,7 @@ static enum isl_tab_row_sign row_sign(struct isl_tab *tab,
        return res;
 error:
        isl_vec_free(ineq);
-       return 0;
+       return isl_tab_row_unknown;
 }
 
 static void find_solutions(struct isl_sol *sol, struct isl_tab *tab);
@@ -3446,7 +3462,8 @@ static void find_in_pos(struct isl_sol *sol, struct isl_tab *tab, isl_int *ineq)
 
        find_solutions(sol, tab);
 
-       sol->context->op->restore(sol->context, saved);
+       if (!sol->error)
+               sol->context->op->restore(sol->context, saved);
        return;
 error:
        sol->error = 1;
@@ -3461,7 +3478,7 @@ static void no_sol_in_strict(struct isl_sol *sol,
        int empty;
        void *saved;
 
-       if (!sol->context)
+       if (!sol->context || sol->error)
                goto error;
        saved = sol->context->op->save(sol->context);
 
@@ -3595,7 +3612,7 @@ static void find_solutions(struct isl_sol *sol, struct isl_tab *tab)
        for (; tab && !tab->empty; tab = restore_lexmin(tab)) {
                int flags;
                int row;
-               int sgn;
+               enum isl_tab_row_sign sgn;
                int split = -1;
                int n_split = 0;
 
@@ -3638,7 +3655,8 @@ static void find_solutions(struct isl_sol *sol, struct isl_tab *tab)
                        row = split;
                        isl_seq_neg(ineq->el, ineq->el, ineq->size);
                        isl_int_sub_ui(ineq->el[0], ineq->el[0], 1);
-                       context->op->add_ineq(context, ineq->el, 0, 1);
+                       if (!sol->error)
+                               context->op->add_ineq(context, ineq->el, 0, 1);
                        isl_vec_free(ineq);
                        if (sol->error)
                                goto error;
@@ -3668,6 +3686,8 @@ static void find_solutions(struct isl_sol *sol, struct isl_tab *tab)
                        if (d < 0)
                                goto error;
                        ineq = ineq_for_div(context->op->peek_basic_set(context), d);
+                       if (!ineq)
+                               goto error;
                        sol_inc_level(sol);
                        no_sol_in_strict(sol, tab, ineq);
                        isl_seq_neg(ineq->el, ineq->el, ineq->size);
@@ -3689,7 +3709,7 @@ done:
        return;
 error:
        isl_tab_free(tab);
-       sol_free(sol);
+       sol->error = 1;
 }
 
 /* Compute the lexicographic minimum of the set represented by the main
@@ -3707,6 +3727,9 @@ static void find_solutions_main(struct isl_sol *sol, struct isl_tab *tab)
 {
        int row;
 
+       if (!tab)
+               goto error;
+
        sol->level = 0;
 
        for (row = tab->n_redundant; row < tab->n_row; ++row) {
@@ -3725,6 +3748,8 @@ static void find_solutions_main(struct isl_sol *sol, struct isl_tab *tab)
                                + tab->n_param - (tab->n_var - tab->n_div);
 
                eq = isl_vec_alloc(tab->mat->ctx, 1+tab->n_param+tab->n_div);
+               if (!eq)
+                       goto error;
                get_row_parameter_line(tab, row, eq->el);
                isl_int_neg(eq->el[1 + p], tab->mat->row[row][0]);
                eq = isl_vec_normalize(eq);
@@ -3758,7 +3783,7 @@ static void find_solutions_main(struct isl_sol *sol, struct isl_tab *tab)
        return;
 error:
        isl_tab_free(tab);
-       sol_free(sol);
+       sol->error = 1;
 }
 
 static void sol_map_find_solutions(struct isl_sol_map *sol_map,
@@ -3871,7 +3896,7 @@ struct isl_map *isl_tab_basic_map_partial_lexopt(
        if (empty)
                *empty = NULL;
        if (!bmap || !dom)
-               goto error;
+               goto error2;
 
        isl_assert(bmap->ctx,
            isl_basic_map_compatible_domain(bmap, dom), goto error);
@@ -3910,6 +3935,8 @@ struct isl_map *isl_tab_basic_map_partial_lexopt(
        sol_free(&sol_map->sol);
        isl_basic_map_free(bmap);
        return result;
+error2:
+       isl_basic_set_free(dom);
 error:
        sol_free(&sol_map->sol);
        isl_basic_map_free(bmap);
@@ -3985,7 +4012,7 @@ static struct isl_sol_for *sol_for_init(struct isl_basic_map *bmap, int max,
        struct isl_dim *dom_dim;
        struct isl_basic_set *dom = NULL;
 
-       sol_for = isl_calloc_type(bset->ctx, struct isl_sol_for);
+       sol_for = isl_calloc_type(bmap->ctx, struct isl_sol_for);
        if (!sol_for)
                goto error;