isl_tab: keep track of isl_basic_map instead of isl_basic_set

diff --git a/isl_affine_hull.c b/isl_affine_hull.c
index 17dd7d8..6bdd279 100644 (file)
--- a/isl_affine_hull.c
+++ b/isl_affine_hull.c
@@ -254,9 +254,9 @@ static struct isl_vec *outside_point(struct isl_tab *tab, isl_int *eq, int up)
                return NULL;
        isl_int_set_si(sample->el[0], 1);
        isl_seq_combine(sample->el + 1,
-               ctx->one, tab->bset->sample->el + 1,
+               ctx->one, tab->bmap->sample->el + 1,
                up ? ctx->one : ctx->negone, eq + 1, dim);
-       if (isl_basic_set_contains(tab->bset, sample))
+       if (isl_basic_map_contains(tab->bmap, sample))
                return sample;
        isl_vec_free(sample);
        sample = NULL;
@@ -435,7 +435,13 @@ static struct isl_basic_set *uset_affine_hull_bounded(struct isl_basic_set *bset
        tab = isl_tab_from_basic_set(bset);
        if (!tab)
                goto error;
-       tab->bset = isl_basic_set_copy(bset);
+       if (tab->empty) {
+               isl_tab_free(tab);
+               isl_vec_free(sample);
+               return isl_basic_set_set_to_empty(bset);
+       }
+       if (isl_tab_track_bset(tab, isl_basic_set_copy(bset)) < 0)
+               goto error;
 
        if (!sample) {
                struct isl_tab_undo *snap;
@@ -443,8 +449,8 @@ static struct isl_basic_set *uset_affine_hull_bounded(struct isl_basic_set *bset
                sample = isl_tab_sample(tab);
                if (isl_tab_rollback(tab, snap) < 0)
                        goto error;
-               isl_vec_free(tab->bset->sample);
-               tab->bset->sample = isl_vec_copy(sample);
+               isl_vec_free(tab->bmap->sample);
+               tab->bmap->sample = isl_vec_copy(sample);
        }
 
        if (!sample)
@@ -540,7 +546,7 @@ struct isl_tab *isl_tab_detect_equalities(struct isl_tab *tab,
        isl_mat_free(tab->basis);
        tab->basis = NULL;
 
-       isl_assert(tab->mat->ctx, tab->bset, goto error);
+       isl_assert(tab->mat->ctx, tab->bmap, goto error);
        isl_assert(tab->mat->ctx, tab->samples, goto error);
        isl_assert(tab->mat->ctx, tab->samples->n_col == 1 + tab->n_var, goto error);
        isl_assert(tab->mat->ctx, tab->n_sample > tab->n_outside, goto error);
@@ -554,8 +560,8 @@ struct isl_tab *isl_tab_detect_equalities(struct isl_tab *tab,
 
        isl_seq_cpy(sample->el, tab->samples->row[tab->n_outside], sample->size);
 
-       isl_vec_free(tab->bset->sample);
-       tab->bset->sample = isl_vec_copy(sample);
+       isl_vec_free(tab->bmap->sample);
+       tab->bmap->sample = isl_vec_copy(sample);
 
        if (tab->n_unbounded == 0)
                hull = isl_basic_set_from_vec(isl_vec_copy(sample));

diff --git a/isl_sample.c b/isl_sample.c
index 83fbf4e..fc1ce92 100644 (file)
--- a/isl_sample.c
+++ b/isl_sample.c
@@ -271,8 +271,8 @@ static struct isl_mat *tab_equalities(struct isl_tab *tab)
        if (!tab)
                return NULL;
 
-       isl_assert(tab->mat->ctx, tab->bset, return NULL);
-       bset = tab->bset;
+       bset = isl_tab_peek_bset(tab);
+       isl_assert(tab->mat->ctx, bset, return NULL);
 
        n_eq = tab->n_var - tab->n_col + tab->n_dead;
        if (tab->empty || n_eq == 0)
@@ -561,13 +561,21 @@ static struct isl_vec *sample_bounded(struct isl_basic_set *bset)
        ctx = bset->ctx;
 
        tab = isl_tab_from_basic_set(bset);
+       if (tab && tab->empty) {
+               isl_tab_free(tab);
+               ISL_F_SET(bset, ISL_BASIC_SET_EMPTY);
+               sample = isl_vec_alloc(bset->ctx, 0);
+               isl_basic_set_free(bset);
+               return sample;
+       }
+
+       if (isl_tab_track_bset(tab, isl_basic_set_copy(bset)) < 0)
+               goto error;
        if (!ISL_F_ISSET(bset, ISL_BASIC_SET_NO_IMPLICIT))
                tab = isl_tab_detect_implicit_equalities(tab);
        if (!tab)
                goto error;
 
-       tab->bset = isl_basic_set_copy(bset);
-
        sample = isl_tab_sample(tab);
        if (!sample)
                goto error;
@@ -954,7 +962,7 @@ static int tab_shift_cone(struct isl_tab *tab,
        isl_int_init(v);
        if (!tab || !tab_cone || !U)
                goto error;
-       bset = tab_cone->bset;
+       bset = isl_tab_peek_bset(tab_cone);
        U = isl_mat_drop_cols(U, 0, tab->n_var - tab->n_unbounded);
        for (i = 0; i < bset->n_ineq; ++i) {
                int ok;

diff --git a/isl_tab.c b/isl_tab.c
index 23493e8..0666d6b 100644 (file)
--- a/isl_tab.c
+++ b/isl_tab.c
@@ -177,7 +177,7 @@ void isl_tab_free(struct isl_tab *tab)
        free_undo(tab);
        isl_mat_free(tab->mat);
        isl_vec_free(tab->dual);
-       isl_basic_set_free(tab->bset);
+       isl_basic_map_free(tab->bmap);
        free(tab->var);
        free(tab->con);
        free(tab->row_var);
@@ -1659,16 +1659,16 @@ int isl_tab_add_ineq(struct isl_tab *tab, isl_int *ineq)
 
        if (!tab)
                return -1;
-       if (tab->bset) {
-               struct isl_basic_set *bset = tab->bset;
+       if (tab->bmap) {
+               struct isl_basic_map *bmap = tab->bmap;
 
-               isl_assert(tab->mat->ctx, tab->n_eq == bset->n_eq, return -1);
+               isl_assert(tab->mat->ctx, tab->n_eq == bmap->n_eq, return -1);
                isl_assert(tab->mat->ctx,
-                           tab->n_con == bset->n_eq + bset->n_ineq, return -1);
-               tab->bset = isl_basic_set_add_ineq(tab->bset, ineq);
-               if (isl_tab_push(tab, isl_tab_undo_bset_ineq) < 0)
+                           tab->n_con == bmap->n_eq + bmap->n_ineq, return -1);
+               tab->bmap = isl_basic_map_add_ineq(tab->bmap, ineq);
+               if (isl_tab_push(tab, isl_tab_undo_bmap_ineq) < 0)
                        return -1;
-               if (!tab->bset)
+               if (!tab->bmap)
                        return -1;
        }
        if (tab->cone) {
@@ -1878,16 +1878,16 @@ struct isl_tab *isl_tab_add_eq(struct isl_tab *tab, isl_int *eq)
                return tab;
        }
 
-       if (tab->bset) {
-               tab->bset = isl_basic_set_add_ineq(tab->bset, eq);
-               if (isl_tab_push(tab, isl_tab_undo_bset_ineq) < 0)
+       if (tab->bmap) {
+               tab->bmap = isl_basic_map_add_ineq(tab->bmap, eq);
+               if (isl_tab_push(tab, isl_tab_undo_bmap_ineq) < 0)
                        goto error;
                isl_seq_neg(eq, eq, 1 + tab->n_var);
-               tab->bset = isl_basic_set_add_ineq(tab->bset, eq);
+               tab->bmap = isl_basic_map_add_ineq(tab->bmap, eq);
                isl_seq_neg(eq, eq, 1 + tab->n_var);
-               if (isl_tab_push(tab, isl_tab_undo_bset_ineq) < 0)
+               if (isl_tab_push(tab, isl_tab_undo_bmap_ineq) < 0)
                        goto error;
-               if (!tab->bset)
+               if (!tab->bmap)
                        goto error;
                if (add_zero_row(tab) < 0)
                        goto error;
@@ -2773,12 +2773,12 @@ static int perform_undo(struct isl_tab *tab, struct isl_tab_undo *undo)
        case isl_tab_undo_allocate:
        case isl_tab_undo_relax:
                return perform_undo_var(tab, undo);
-       case isl_tab_undo_bset_eq:
-               return isl_basic_set_free_equality(tab->bset, 1);
-       case isl_tab_undo_bset_ineq:
-               return isl_basic_set_free_inequality(tab->bset, 1);
-       case isl_tab_undo_bset_div:
-               if (isl_basic_set_free_div(tab->bset, 1) < 0)
+       case isl_tab_undo_bmap_eq:
+               return isl_basic_map_free_equality(tab->bmap, 1);
+       case isl_tab_undo_bmap_ineq:
+               return isl_basic_map_free_inequality(tab->bmap, 1);
+       case isl_tab_undo_bmap_div:
+               if (isl_basic_map_free_div(tab->bmap, 1) < 0)
                        return -1;
                if (tab->samples)
                        tab->samples->n_col--;
@@ -2926,6 +2926,36 @@ error:
        return isl_ineq_error;
 }
 
+int isl_tab_track_bmap(struct isl_tab *tab, __isl_take isl_basic_map *bmap)
+{
+       if (!tab || !bmap)
+               goto error;
+
+       isl_assert(tab->mat->ctx, tab->n_eq == bmap->n_eq, return -1);
+       isl_assert(tab->mat->ctx,
+                   tab->n_con == bmap->n_eq + bmap->n_ineq, return -1);
+
+       tab->bmap = bmap;
+
+       return 0;
+error:
+       isl_basic_map_free(bmap);
+       return -1;
+}
+
+int isl_tab_track_bset(struct isl_tab *tab, __isl_take isl_basic_set *bset)
+{
+       return isl_tab_track_bmap(tab, (isl_basic_map *)bset);
+}
+
+__isl_keep isl_basic_set *isl_tab_peek_bset(struct isl_tab *tab)
+{
+       if (!tab)
+               return NULL;
+
+       return (isl_basic_set *)tab->bmap;
+}
+
 void isl_tab_dump(struct isl_tab *tab, FILE *out, int indent)
 {
        unsigned r, c;
@@ -2998,6 +3028,6 @@ void isl_tab_dump(struct isl_tab *tab, FILE *out, int indent)
        isl_mat_dump(tab->mat, out, indent);
        tab->mat->n_row = r;
        tab->mat->n_col = c;
-       if (tab->bset)
-               isl_basic_set_dump(tab->bset, out, indent);
+       if (tab->bmap)
+               isl_basic_map_dump(tab->bmap, out, indent);
 }

diff --git a/isl_tab.h b/isl_tab.h
index bf9ef88..d5d9ff8 100644 (file)
--- a/isl_tab.h
+++ b/isl_tab.h
@@ -26,9 +26,9 @@ enum isl_tab_undo_type {
        isl_tab_undo_zero,
        isl_tab_undo_allocate,
        isl_tab_undo_relax,
-       isl_tab_undo_bset_ineq,
-       isl_tab_undo_bset_eq,
-       isl_tab_undo_bset_div,
+       isl_tab_undo_bmap_ineq,
+       isl_tab_undo_bmap_eq,
+       isl_tab_undo_bmap_div,
        isl_tab_undo_saved_basis,
        isl_tab_undo_drop_sample,
        isl_tab_undo_saved_samples,
@@ -141,7 +141,7 @@ struct isl_tab {
        struct isl_tab_undo *top;
 
        struct isl_vec *dual;
-       struct isl_basic_set *bset;
+       struct isl_basic_map *bmap;
 
        unsigned n_sample;
        unsigned n_outside;
@@ -186,6 +186,10 @@ struct isl_tab *isl_tab_add_valid_eq(struct isl_tab *tab, isl_int *eq) WARN_UNUS
 
 int isl_tab_freeze_constraint(struct isl_tab *tab, int con) WARN_UNUSED;
 
+int isl_tab_track_bmap(struct isl_tab *tab, __isl_take isl_basic_map *bmap) WARN_UNUSED;
+int isl_tab_track_bset(struct isl_tab *tab, __isl_take isl_basic_set *bset) WARN_UNUSED;
+__isl_keep isl_basic_set *isl_tab_peek_bset(struct isl_tab *tab);
+
 int isl_tab_is_equality(struct isl_tab *tab, int con);
 int isl_tab_is_redundant(struct isl_tab *tab, int con);
 

diff --git a/isl_tab_pip.c b/isl_tab_pip.c
index 8f3311c..c796505 100644 (file)
--- a/isl_tab_pip.c
+++ b/isl_tab_pip.c
@@ -1293,16 +1293,16 @@ static struct isl_tab *add_lexmin_eq(struct isl_tab *tab, isl_int *eq)
                }
        }
 
-       if (tab->bset) {
-               tab->bset = isl_basic_set_add_ineq(tab->bset, eq);
-               if (isl_tab_push(tab, isl_tab_undo_bset_ineq) < 0)
+       if (tab->bmap) {
+               tab->bmap = isl_basic_map_add_ineq(tab->bmap, eq);
+               if (isl_tab_push(tab, isl_tab_undo_bmap_ineq) < 0)
                        goto error;
                isl_seq_neg(eq, eq, 1 + tab->n_var);
-               tab->bset = isl_basic_set_add_ineq(tab->bset, eq);
+               tab->bmap = isl_basic_map_add_ineq(tab->bmap, eq);
                isl_seq_neg(eq, eq, 1 + tab->n_var);
-               if (isl_tab_push(tab, isl_tab_undo_bset_ineq) < 0)
+               if (isl_tab_push(tab, isl_tab_undo_bmap_ineq) < 0)
                        goto error;
-               if (!tab->bset)
+               if (!tab->bmap)
                        goto error;
        }
 
@@ -1321,11 +1321,11 @@ static struct isl_tab *add_lexmin_ineq(struct isl_tab *tab, isl_int *ineq)
 
        if (!tab)
                return NULL;
-       if (tab->bset) {
-               tab->bset = isl_basic_set_add_ineq(tab->bset, ineq);
-               if (isl_tab_push(tab, isl_tab_undo_bset_ineq) < 0)
+       if (tab->bmap) {
+               tab->bmap = isl_basic_map_add_ineq(tab->bmap, ineq);
+               if (isl_tab_push(tab, isl_tab_undo_bmap_ineq) < 0)
                        goto error;
-               if (!tab->bset)
+               if (!tab->bmap)
                        goto error;
        }
        r = isl_tab_add_row(tab, ineq);
@@ -1551,7 +1551,7 @@ static struct isl_tab *check_samples(struct isl_tab *tab, isl_int *ineq, int eq)
        if (!tab)
                return NULL;
 
-       isl_assert(tab->mat->ctx, tab->bset, goto error);
+       isl_assert(tab->mat->ctx, tab->bmap, goto error);
        isl_assert(tab->mat->ctx, tab->samples, goto error);
        isl_assert(tab->mat->ctx, tab->samples->n_col == 1 + tab->n_var, goto error);
 
@@ -1650,7 +1650,7 @@ static int tab_has_valid_sample(struct isl_tab *tab, isl_int *ineq, int eq)
        if (!tab)
                return -1;
 
-       isl_assert(tab->mat->ctx, tab->bset, return -1);
+       isl_assert(tab->mat->ctx, tab->bmap, return -1);
        isl_assert(tab->mat->ctx, tab->samples, return -1);
        isl_assert(tab->mat->ctx, tab->samples->n_col == 1 + tab->n_var, return -1);
 
@@ -1754,13 +1754,13 @@ static int context_tab_add_div(struct isl_tab *tab, struct isl_vec *div,
                               samples->row[i][samples->n_col - 1], div->el[0]);
        }
 
-       tab->bset = isl_basic_set_extend_dim(tab->bset,
-               isl_basic_set_get_dim(tab->bset), 1, 0, 2);
-       k = isl_basic_set_alloc_div(tab->bset);
+       tab->bmap = isl_basic_map_extend_dim(tab->bmap,
+               isl_basic_map_get_dim(tab->bmap), 1, 0, 2);
+       k = isl_basic_map_alloc_div(tab->bmap);
        if (k < 0)
                return -1;
-       isl_seq_cpy(tab->bset->div[k], div->el, div->size);
-       if (isl_tab_push(tab, isl_tab_undo_bset_div) < 0)
+       isl_seq_cpy(tab->bmap->div[k], div->el, div->size);
+       if (isl_tab_push(tab, isl_tab_undo_bmap_div) < 0)
                return -1;
 
        return k;
@@ -1806,12 +1806,12 @@ error:
 static int find_div(struct isl_tab *tab, isl_int *div, isl_int denom)
 {
        int i;
-       unsigned total = isl_basic_set_total_dim(tab->bset);
+       unsigned total = isl_basic_map_total_dim(tab->bmap);
 
-       for (i = 0; i < tab->bset->n_div; ++i) {
-               if (isl_int_ne(tab->bset->div[i][0], 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->bset->div[i] + 1, div, total))
+               if (!isl_seq_eq(tab->bmap->div[i] + 1, div, total))
                        continue;
                return i;
        }
@@ -2121,7 +2121,7 @@ static struct isl_basic_set *context_lex_peek_basic_set(
        struct isl_context_lex *clex = (struct isl_context_lex *)context;
        if (!clex->tab)
                return NULL;
-       return clex->tab->bset;
+       return isl_tab_peek_bset(clex->tab);
 }
 
 static struct isl_tab *context_lex_peek_tab(struct isl_context *context)
@@ -2458,7 +2458,8 @@ static struct isl_tab *context_tab_for_lexmin(struct isl_basic_set *bset)
        tab = tab_for_lexmin((struct isl_basic_map *)bset, NULL, 1, 0);
        if (!tab)
                goto error;
-       tab->bset = bset;
+       if (isl_tab_track_bset(tab, bset) < 0)
+               goto error;
        tab = isl_tab_init_samples(tab);
        return tab;
 error:
@@ -2511,7 +2512,7 @@ static struct isl_basic_set *context_gbr_peek_basic_set(
        struct isl_context_gbr *cgbr = (struct isl_context_gbr *)context;
        if (!cgbr->tab)
                return NULL;
-       return cgbr->tab->bset;
+       return isl_tab_peek_bset(cgbr->tab);
 }
 
 static struct isl_tab *context_gbr_peek_tab(struct isl_context *context)
@@ -2530,7 +2531,7 @@ static void gbr_init_shifted(struct isl_context_gbr *cgbr)
 {
        int i, j;
        struct isl_vec *cst;
-       struct isl_basic_set *bset = cgbr->tab->bset;
+       struct isl_basic_set *bset = isl_tab_peek_bset(cgbr->tab);
        unsigned dim = isl_basic_set_total_dim(bset);
 
        cst = isl_vec_alloc(cgbr->tab->mat->ctx, bset->n_ineq);
@@ -2594,7 +2595,7 @@ static struct isl_basic_set *drop_constant_terms(struct isl_basic_set *bset)
 
 static int use_shifted(struct isl_context_gbr *cgbr)
 {
-       return cgbr->tab->bset->n_eq == 0 && cgbr->tab->bset->n_div == 0;
+       return cgbr->tab->bmap->n_eq == 0 && cgbr->tab->bmap->n_div == 0;
 }
 
 static struct isl_vec *gbr_get_sample(struct isl_context_gbr *cgbr)
@@ -2616,10 +2617,12 @@ static struct isl_vec *gbr_get_sample(struct isl_context_gbr *cgbr)
        }
 
        if (!cgbr->cone) {
-               cgbr->cone = isl_tab_from_recession_cone(cgbr->tab->bset);
+               bset = isl_tab_peek_bset(cgbr->tab);
+               cgbr->cone = isl_tab_from_recession_cone(bset);
                if (!cgbr->cone)
                        return NULL;
-               cgbr->cone->bset = isl_basic_set_dup(cgbr->tab->bset);
+               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)
@@ -2651,13 +2654,13 @@ static struct isl_vec *gbr_get_sample(struct isl_context_gbr *cgbr)
                return sample;
        }
 
-       cone = isl_basic_set_dup(cgbr->cone->bset);
+       cone = isl_basic_set_dup(isl_tab_peek_bset(cgbr->cone));
        cone = drop_constant_terms(cone);
        cone = isl_basic_set_update_from_tab(cone, cgbr->cone);
        cone = isl_basic_set_underlying_set(cone);
        cone = isl_basic_set_gauss(cone, NULL);
 
-       bset = isl_basic_set_dup(cgbr->tab->bset);
+       bset = isl_basic_set_dup(isl_tab_peek_bset(cgbr->tab));
        bset = isl_basic_set_update_from_tab(bset, cgbr->tab);
        bset = isl_basic_set_underlying_set(bset);
        bset = isl_basic_set_gauss(bset, NULL);
@@ -2754,7 +2757,7 @@ static void add_gbr_ineq(struct isl_context_gbr *cgbr, isl_int *ineq)
        if (cgbr->shifted && !cgbr->shifted->empty && use_shifted(cgbr)) {
                int i;
                unsigned dim;
-               dim = isl_basic_set_total_dim(cgbr->tab->bset);
+               dim = isl_basic_map_total_dim(cgbr->tab->bmap);
 
                if (isl_tab_extend_cons(cgbr->shifted, 1) < 0)
                        goto error;
@@ -2915,20 +2918,20 @@ static void propagate_equalities(struct isl_context_gbr *cgbr,
        if (!eq)
                goto error;
 
-       if (isl_tab_extend_cons(tab, (cgbr->tab->bset->n_ineq - first)/2) < 0)
+       if (isl_tab_extend_cons(tab, (cgbr->tab->bmap->n_ineq - first)/2) < 0)
                goto error;
 
        isl_seq_clr(eq->el + 1 + tab->n_param,
                    tab->n_var - tab->n_param - tab->n_div);
-       for (i = first; i < cgbr->tab->bset->n_ineq; i += 2) {
+       for (i = first; i < cgbr->tab->bmap->n_ineq; i += 2) {
                int j;
                int r;
                struct isl_tab_undo *snap;
                snap = isl_tab_snap(tab);
 
-               isl_seq_cpy(eq->el, cgbr->tab->bset->ineq[i], 1 + tab->n_param);
+               isl_seq_cpy(eq->el, cgbr->tab->bmap->ineq[i], 1 + tab->n_param);
                isl_seq_cpy(eq->el + 1 + tab->n_var - tab->n_div,
-                           cgbr->tab->bset->ineq[i] + 1 + tab->n_param,
+                           cgbr->tab->bmap->ineq[i] + 1 + tab->n_param,
                            tab->n_div);
 
                r = isl_tab_add_row(tab, eq->el);
@@ -2973,16 +2976,18 @@ static int context_gbr_detect_equalities(struct isl_context *context,
        ctx = cgbr->tab->mat->ctx;
 
        if (!cgbr->cone) {
-               cgbr->cone = isl_tab_from_recession_cone(cgbr->tab->bset);
+               struct isl_basic_set *bset = isl_tab_peek_bset(cgbr->tab);
+               cgbr->cone = isl_tab_from_recession_cone(bset);
                if (!cgbr->cone)
                        goto error;
-               cgbr->cone->bset = isl_basic_set_dup(cgbr->tab->bset);
+               if (isl_tab_track_bset(cgbr->cone, isl_basic_set_dup(bset)) < 0)
+                       goto error;
        }
        cgbr->cone = isl_tab_detect_implicit_equalities(cgbr->cone);
 
-       n_ineq = cgbr->tab->bset->n_ineq;
+       n_ineq = cgbr->tab->bmap->n_ineq;
        cgbr->tab = isl_tab_detect_equalities(cgbr->tab, cgbr->cone);
-       if (cgbr->tab && cgbr->tab->bset->n_ineq > n_ineq)
+       if (cgbr->tab && cgbr->tab->bmap->n_ineq > n_ineq)
                propagate_equalities(cgbr, tab, n_ineq);
 
        return 0;
@@ -3012,13 +3017,13 @@ static int context_gbr_add_div(struct isl_context *context, struct isl_vec *div,
                if (isl_tab_allocate_var(cgbr->cone) <0)
                        return -1;
 
-               cgbr->cone->bset = isl_basic_set_extend_dim(cgbr->cone->bset,
-                       isl_basic_set_get_dim(cgbr->cone->bset), 1, 0, 2);
-               k = isl_basic_set_alloc_div(cgbr->cone->bset);
+               cgbr->cone->bmap = isl_basic_map_extend_dim(cgbr->cone->bmap,
+                       isl_basic_map_get_dim(cgbr->cone->bmap), 1, 0, 2);
+               k = isl_basic_map_alloc_div(cgbr->cone->bmap);
                if (k < 0)
                        return -1;
-               isl_seq_cpy(cgbr->cone->bset->div[k], div->el, div->size);
-               if (isl_tab_push(cgbr->cone, isl_tab_undo_bset_div) < 0)
+               isl_seq_cpy(cgbr->cone->bmap->div[k], div->el, div->size);
+               if (isl_tab_push(cgbr->cone, isl_tab_undo_bmap_div) < 0)
                        return -1;
        }
        return context_tab_add_div(cgbr->tab, div, nonneg);
@@ -3180,8 +3185,8 @@ static struct isl_context *isl_context_gbr_alloc(struct isl_basic_set *dom)
        cgbr->tab = isl_tab_init_samples(cgbr->tab);
        if (!cgbr->tab)
                goto error;
-       cgbr->tab->bset = isl_basic_set_cow(isl_basic_set_copy(dom));
-       if (!cgbr->tab->bset)
+       if (isl_tab_track_bset(cgbr->tab,
+                               isl_basic_set_cow(isl_basic_set_copy(dom))) < 0)
                goto error;
        check_gbr_integer_feasible(cgbr);