isl_basic_map_extend_dim: move responsibility of cow'ing to the caller

Some callers, notably isl_basic_map_detect_equalities, want to
extend the basic map to add equalities that are implicit to the
basic map.  These equalities should be added to all copies,
so we definitely do not want to cow in such cases.

diff --git a/isl_affine_hull.c b/isl_affine_hull.c
index db4c7ea..e3794d1 100644 (file)
--- a/isl_affine_hull.c
+++ b/isl_affine_hull.c
@@ -246,6 +246,7 @@ static struct isl_basic_set *outside_point(struct isl_ctx *ctx,
        if (!slice)
                goto error;
        dim = isl_basic_set_n_dim(slice);
+       slice = isl_basic_set_cow(slice);
        slice = isl_basic_set_extend(slice, 0, dim, 0, 0, 1);
        k = isl_basic_set_alloc_inequality(slice);
        if (k < 0)

diff --git a/isl_constraint.c b/isl_constraint.c
index ad59345..8d38f97 100644 (file)
--- a/isl_constraint.c
+++ b/isl_constraint.c
@@ -213,6 +213,7 @@ struct isl_constraint *isl_constraint_add_div(struct isl_constraint *constraint,
        isl_assert(constraint->ctx,
            constraint->bmap->n_eq + constraint->bmap->n_ineq == 1, goto error);
 
+       constraint->bmap = isl_basic_map_cow(constraint->bmap);
        constraint->bmap = isl_basic_map_extend_dim(constraint->bmap,
                                isl_dim_copy(constraint->bmap->dim), 1, 0, 0);
        if (!constraint->bmap)
@@ -343,6 +344,7 @@ struct isl_basic_set *isl_basic_set_from_constraint(
        bset = isl_basic_set_align_divs(bset, constraint_bset);
        nparam = isl_basic_set_n_param(bset);
        dim = isl_basic_set_n_dim(bset);
+       bset = isl_basic_set_cow(bset);
        bset = isl_basic_set_extend(bset, nparam, dim, 0, 1, 1);
        if (isl_constraint_is_equality(constraint)) {
                k = isl_basic_set_alloc_equality(bset);

diff --git a/isl_convex_hull.c b/isl_convex_hull.c
index 02a6e34..8e964fa 100644 (file)
--- a/isl_convex_hull.c
+++ b/isl_convex_hull.c
@@ -296,6 +296,7 @@ static struct isl_basic_set *isl_basic_set_add_equality(struct isl_ctx *ctx,
        isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error);
        isl_assert(ctx, bset->n_div == 0, goto error);
        dim = isl_basic_set_n_dim(bset);
+       bset = isl_basic_set_cow(bset);
        bset = isl_basic_set_extend(bset, 0, dim, 0, 1, 0);
        i = isl_basic_set_alloc_equality(bset);
        if (i < 0)
@@ -694,9 +695,9 @@ static struct isl_basic_set *extend(struct isl_basic_set *hull,
                hull_facet = isl_basic_set_normalize_constraints(hull_facet);
                if (!facet)
                        goto error;
-               if (facet->n_ineq + hull->n_ineq > hull->c_size)
-                       hull = isl_basic_set_extend_dim(hull,
-                               isl_dim_copy(hull->dim), 0, 0, facet->n_ineq);
+               hull = isl_basic_set_cow(hull);
+               hull = isl_basic_set_extend_dim(hull,
+                       isl_dim_copy(hull->dim), 0, 0, facet->n_ineq);
                for (j = 0; j < facet->n_ineq; ++j) {
                        for (f = 0; f < hull_facet->n_ineq; ++f)
                                if (isl_seq_eq(facet->ineq[j],
@@ -1729,6 +1730,7 @@ static struct isl_basic_set *uset_simple_hull(struct isl_set *set)
        hull = isl_set_affine_hull(isl_set_copy(set));
        if (!hull)
                goto error;
+       hull = isl_basic_set_cow(hull),
        hull = isl_basic_set_extend_dim(hull, isl_dim_copy(hull->dim),
                                        0, 0, n_ineq);
        if (!hull)

diff --git a/isl_input_omega.c b/isl_input_omega.c
index 3b3ba04..c6ce108 100644 (file)
--- a/isl_input_omega.c
+++ b/isl_input_omega.c
@@ -174,6 +174,7 @@ static struct isl_basic_map *add_exists(struct isl_stream *s,
        if (!*v)
                goto error;
        extra = (*v)->n - n;
+       bmap = isl_basic_map_cow(bmap);
        bmap = isl_basic_map_extend_dim(bmap, isl_dim_copy(bmap->dim),
                        extra, 0, 0);
        total = isl_basic_map_total_dim(bmap);
@@ -215,6 +216,7 @@ static struct isl_basic_map *add_constraint(struct isl_stream *s,
        }
        isl_stream_push_token(s, tok);
 
+       bmap = isl_basic_map_cow(bmap);
        bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
        k = isl_basic_map_alloc_inequality(bmap);
        if (k < 0)

diff --git a/isl_map.c b/isl_map.c
index bb49e87..a5fdbd1 100644 (file)
--- a/isl_map.c
+++ b/isl_map.c
@@ -797,7 +797,6 @@ struct isl_basic_map *isl_basic_map_extend_dim(struct isl_basic_map *base,
        if (!dim)
                goto error;
 
-       base = isl_basic_map_cow(base);
        if (!base)
                goto error;
 
@@ -1529,6 +1528,7 @@ struct isl_basic_map *isl_basic_map_intersect_domain(
                isl_assert(bset->ctx,
                    isl_basic_map_compatible_domain(bmap, bset), goto error);
 
+       bmap = isl_basic_map_cow(bmap);
        bmap = isl_basic_map_extend_dim(bmap, isl_dim_copy(bmap->dim),
                        bset->n_div, bset->n_eq, bset->n_ineq);
        if (!bmap)
@@ -1560,6 +1560,7 @@ struct isl_basic_map *isl_basic_map_intersect_range(
                isl_assert(bset->ctx,
                    isl_basic_map_compatible_range(bmap, bset), goto error);
 
+       bmap = isl_basic_map_cow(bmap);
        bmap = isl_basic_map_extend_dim(bmap, isl_dim_copy(bmap->dim),
                        bset->n_div, bset->n_eq, bset->n_ineq);
        if (!bmap)
@@ -1638,6 +1639,7 @@ struct isl_basic_map *isl_basic_map_intersect(
            basic_map_contains(bmap2, bmap2->sample) > 0)
                sample = isl_vec_copy(bmap2->ctx, bmap2->sample);
 
+       bmap1 = isl_basic_map_cow(bmap1);
        bmap1 = isl_basic_map_extend_dim(bmap1, isl_dim_copy(bmap1->dim),
                        bmap2->n_div, bmap2->n_eq, bmap2->n_ineq);
        if (!bmap1)
@@ -3169,6 +3171,7 @@ struct isl_basic_set *isl_basic_map_deltas(struct isl_basic_map *bmap)
        nparam = isl_basic_map_n_param(bmap);
        isl_assert(bmap->ctx, dim == isl_basic_map_n_out(bmap), goto error);
        bset = isl_basic_set_from_basic_map(bmap);
+       bset = isl_basic_set_cow(bset);
        bset = isl_basic_set_extend(bset, nparam, 3*dim, 0, dim, 0);
        bset = isl_basic_set_swap_vars(bset, 2*dim);
        for (i = 0; i < dim; ++i) {
@@ -3557,6 +3560,7 @@ struct isl_basic_map *isl_basic_map_align_divs(
                isl_assert(src->ctx, !isl_int_is_zero(src->div[i][0]), goto error);
 
        src = order_divs(src);
+       dst = isl_basic_map_cow(dst);
        dst = isl_basic_map_extend_dim(dst, isl_dim_copy(dst->dim),
                        src->n_div, 0, 2 * src->n_div);
        if (!dst)
@@ -3898,6 +3902,7 @@ int isl_basic_set_compare_at(struct isl_basic_set *bset1,
        bmap2 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset2), dims);
        if (!bmap1 || !bmap2)
                goto error;
+       bmap1 = isl_basic_map_cow(bmap1);
        bmap1 = isl_basic_map_extend(bmap1, nparam,
                        pos, (dim1 - pos) + (dim2 - pos),
                        bmap2->n_div, bmap2->n_eq, bmap2->n_ineq);

diff --git a/isl_map_simplify.c b/isl_map_simplify.c
index 1fdb88f..c1ebcc6 100644 (file)
--- a/isl_map_simplify.c
+++ b/isl_map_simplify.c
@@ -1359,7 +1359,8 @@ static struct isl_basic_set *uset_gist(struct isl_basic_set *bset,
        if (bset->n_eq > 0)
                return uset_gist_set_eq(bset, context);
        bset = remove_shifted_constraints(bset, context);
-       combined = isl_basic_set_extend_constraints(isl_basic_set_copy(bset),
+       combined = isl_basic_set_cow(isl_basic_set_copy(bset));
+       combined = isl_basic_set_extend_constraints(combined,
                        context->n_eq, context->n_ineq);
        context = isl_basic_set_add_constraints(combined, context, 0);
        if (!context)