summaryloggraphiclog1graphiclog2commitcommitdifftreerefseditfork
rawpatchinlineside by side (parent: 6fdd979)
rawpatchinlineside by side (parent: 6fdd979)
| author | Sven Verdoolaege <sven.verdoolaege@gmail.com> | |
| Mon, 16 Oct 2017 13:08:00 +0000 (16 15:08 +0200) | ||
| committer | Sven Verdoolaege <sven.verdoolaege@gmail.com> | |
| Sun, 4 Mar 2018 14:36:00 +0000 (4 15:36 +0100) |
In particular, only consider the field representing the pieces
to be valid when the number of base expressions is greater than zero.
Since the field is only used to access a base expression,
it is never used when the number of base expression is zero.
Making this condition more explicit allows the field
to overlap with the domain of a zero-dimensional expression,
which will be introduced in an upcoming commit.
Signed-off-by: Sven Verdoolaege <sven.verdoolaege@gmail.com>
to be valid when the number of base expressions is greater than zero.
Since the field is only used to access a base expression,
it is never used when the number of base expression is zero.
Making this condition more explicit allows the field
to overlap with the domain of a zero-dimensional expression,
which will be introduced in an upcoming commit.
Signed-off-by: Sven Verdoolaege <sven.verdoolaege@gmail.com>
14 files changed:
diff --git a/isl_aff.c b/isl_aff.c
--- a/isl_aff.c
+++ b/isl_aff.c
return isl_bool_error;
for (i = 0; i < mpa->n; ++i) {
- isl_bool is_cst = isl_pw_aff_is_cst(mpa->p[i]);
+ isl_bool is_cst = isl_pw_aff_is_cst(mpa->u.p[i]);
if (is_cst < 0 || !is_cst)
return is_cst;
}
goto error;
for (i = 0; i < maff->n; ++i) {
- maff->p[i] = isl_aff_substitute_equalities(maff->p[i],
+ maff->u.p[i] = isl_aff_substitute_equalities(maff->u.p[i],
isl_basic_set_copy(eq));
- if (!maff->p[i])
+ if (!maff->u.p[i])
goto error;
}
return NULL;
for (i = 0; i < maff->n; ++i) {
- maff->p[i] = isl_aff_scale(maff->p[i], f);
- if (!maff->p[i])
+ maff->u.p[i] = isl_aff_scale(maff->u.p[i], f);
+ if (!maff->u.p[i])
return isl_multi_aff_free(maff);
}
type = isl_dim_set;
for (i = 0; i < maff->n; ++i) {
- maff->p[i] = isl_aff_substitute(maff->p[i], type, pos, subs);
- if (!maff->p[i])
+ maff->u.p[i] = isl_aff_substitute(maff->u.p[i],
+ type, pos, subs);
+ if (!maff->u.p[i])
return isl_multi_aff_free(maff);
}
if (isl_int_is_zero(src[offset]))
continue;
- isl_int_set(c1, ma->p[i]->v->el[0]);
+ isl_int_set(c1, ma->u.p[i]->v->el[0]);
isl_int_mul(c2, f, src[offset]);
isl_int_gcd(g, c1, c2);
isl_int_divexact(c1, c1, g);
o_dst = has_denom;
o_src = 1;
isl_seq_combine(dst + o_dst, c1, dst + o_dst,
- c2, ma->p[i]->v->el + o_src, 1 + n_param);
+ c2, ma->u.p[i]->v->el + o_src, 1 + n_param);
o_dst += 1 + n_param;
o_src += 1 + n_param;
isl_seq_scale(dst + o_dst, dst + o_dst, c1, n_before);
o_dst += n_before;
isl_seq_combine(dst + o_dst, c1, dst + o_dst,
- c2, ma->p[i]->v->el + o_src, n_in);
+ c2, ma->u.p[i]->v->el + o_src, n_in);
o_dst += n_in;
o_src += n_in;
isl_seq_scale(dst + o_dst, dst + o_dst, c1, n_after);
o_dst += n_after;
isl_seq_combine(dst + o_dst, c1, dst + o_dst,
- c2, ma->p[i]->v->el + o_src, n_div_ma);
+ c2, ma->u.p[i]->v->el + o_src, n_div_ma);
o_dst += n_div_ma;
o_src += n_div_ma;
isl_seq_scale(dst + o_dst, dst + o_dst, c1, n_div_bmap);
goto error;
n_div_aff = isl_aff_dim(aff, isl_dim_div);
- n_div_ma = ma->n ? isl_aff_dim(ma->p[0], isl_dim_div) : 0;
+ n_div_ma = ma->n ? isl_aff_dim(ma->u.p[0], isl_dim_div) : 0;
ls = isl_aff_get_domain_local_space(aff);
ls = isl_local_space_preimage_multi_aff(ls, isl_multi_aff_copy(ma));
isl_multi_aff_get_space(ma1));
for (i = 0; i < ma1->n; ++i) {
- ma1->p[i] = isl_aff_pullback_multi_aff(ma1->p[i],
+ ma1->u.p[i] = isl_aff_pullback_multi_aff(ma1->u.p[i],
isl_multi_aff_copy(ma2));
- if (!ma1->p[i])
+ if (!ma1->u.p[i])
goto error;
}
return NULL;
for (i = 1; i < maff->n; ++i)
- maff->p[0] = isl_aff_align_divs(maff->p[0], maff->p[i]);
+ maff->u.p[0] = isl_aff_align_divs(maff->u.p[0], maff->u.p[i]);
for (i = 1; i < maff->n; ++i) {
- maff->p[i] = isl_aff_align_divs(maff->p[i], maff->p[0]);
- if (!maff->p[i])
+ maff->u.p[i] = isl_aff_align_divs(maff->u.p[i], maff->u.p[0]);
+ if (!maff->u.p[i])
return isl_multi_aff_free(maff);
}
if (!maff)
return NULL;
- n_div = isl_aff_dim(maff->p[0], isl_dim_div);
+ n_div = isl_aff_dim(maff->u.p[0], isl_dim_div);
space = isl_multi_aff_get_space(maff);
space = isl_space_lift(isl_space_domain(space), n_div);
space = isl_space_extend_domain_with_range(space,
@@ -5833,14 +5834,14 @@ __isl_give isl_multi_aff *isl_multi_aff_lift(__isl_take isl_multi_aff *maff,
maff->space = space;
if (ls) {
- *ls = isl_aff_get_domain_local_space(maff->p[0]);
+ *ls = isl_aff_get_domain_local_space(maff->u.p[0]);
if (!*ls)
return isl_multi_aff_free(maff);
}
for (i = 0; i < maff->n; ++i) {
- maff->p[i] = isl_aff_lift(maff->p[i]);
- if (!maff->p[i])
+ maff->u.p[i] = isl_aff_lift(maff->u.p[i]);
+ if (!maff->u.p[i])
goto error;
}
isl_pw_aff *pa;
isl_map *map_i;
- pa = isl_pw_aff_copy(mpa->p[i]);
+ pa = isl_pw_aff_copy(mpa->u.p[i]);
map_i = map_from_pw_aff(pa);
map = isl_map_flat_range_product(map, map_i);
return equal;
for (i = 0; i < mpa1->n; ++i) {
- equal = isl_pw_aff_is_equal(mpa1->p[i], mpa2->p[i]);
+ equal = isl_pw_aff_is_equal(mpa1->u.p[i], mpa2->u.p[i]);
if (equal < 0 || !equal)
return equal;
}
@@ -6723,9 +6724,9 @@ static __isl_give isl_multi_pw_aff *isl_multi_pw_aff_pullback_multi_aff_aligned(
goto error;
for (i = 0; i < mpa->n; ++i) {
- mpa->p[i] = isl_pw_aff_pullback_multi_aff(mpa->p[i],
+ mpa->u.p[i] = isl_pw_aff_pullback_multi_aff(mpa->u.p[i],
isl_multi_aff_copy(ma));
- if (!mpa->p[i])
+ if (!mpa->u.p[i])
goto error;
}
isl_multi_pw_aff_get_space(mpa));
for (i = 0; i < mpa->n; ++i) {
- mpa->p[i] = isl_pw_aff_pullback_pw_multi_aff_aligned(mpa->p[i],
- isl_pw_multi_aff_copy(pma));
- if (!mpa->p[i])
+ mpa->u.p[i] = isl_pw_aff_pullback_pw_multi_aff_aligned(
+ mpa->u.p[i], isl_pw_multi_aff_copy(pma));
+ if (!mpa->u.p[i])
goto error;
}
isl_multi_pw_aff_get_space(mpa1));
for (i = 0; i < mpa1->n; ++i) {
- mpa1->p[i] = isl_pw_aff_pullback_multi_pw_aff_aligned(
- mpa1->p[i], isl_multi_pw_aff_copy(mpa2));
- if (!mpa1->p[i])
+ mpa1->u.p[i] = isl_pw_aff_pullback_multi_pw_aff_aligned(
+ mpa1->u.p[i], isl_multi_pw_aff_copy(mpa2));
+ if (!mpa1->u.p[i])
goto error;
}
diff --git a/isl_local_space.c b/isl_local_space.c
--- a/isl_local_space.c
+++ b/isl_local_space.c
"spaces don't match", goto error);
n_div_ls = isl_local_space_dim(ls, isl_dim_div);
- n_div_ma = ma->n ? isl_aff_dim(ma->p[0], isl_dim_div) : 0;
+ n_div_ma = ma->n ? isl_aff_dim(ma->u.p[0], isl_dim_div) : 0;
space = isl_space_domain(isl_multi_aff_get_space(ma));
res = isl_local_space_alloc(space, n_div_ma + n_div_ls);
if (n_div_ma) {
isl_mat_free(res->div);
- res->div = isl_mat_copy(ma->p[0]->ls->div);
+ res->div = isl_mat_copy(ma->u.p[0]->ls->div);
res->div = isl_mat_add_zero_cols(res->div, n_div_ls);
res->div = isl_mat_add_rows(res->div, n_div_ls);
if (!res->div)
diff --git a/isl_map.c b/isl_map.c
--- a/isl_map.c
+++ b/isl_map.c
isl_aff *aff;
isl_basic_map *bmap_i;
- aff = isl_aff_copy(maff->p[i]);
+ aff = isl_aff_copy(maff->u.p[i]);
bmap_i = isl_basic_map_from_aff2(aff, rational);
bmap = isl_basic_map_flat_range_product(bmap, bmap_i);
if (n_div == 0)
return 0;
- ls = isl_aff_get_domain_local_space(ma->p[0]);
+ ls = isl_aff_get_domain_local_space(ma->u.p[0]);
if (!ls)
return -1;
int strides = 0;
for (i = 0; i < ma->n; ++i)
- if (!isl_int_is_one(ma->p[i]->v->el[0]))
+ if (!isl_int_is_one(ma->u.p[i]->v->el[0]))
strides++;
return strides;
for (i = 0; i < ma->n; ++i) {
int o_bmap = 0, o_ma = 1;
- if (isl_int_is_one(ma->p[i]->v->el[0]))
+ if (isl_int_is_one(ma->u.p[i]->v->el[0]))
continue;
div = isl_basic_map_alloc_div(bmap);
k = isl_basic_map_alloc_equality(bmap);
goto error;
isl_int_set_si(bmap->div[div][0], 0);
isl_seq_cpy(bmap->eq[k] + o_bmap,
- ma->p[i]->v->el + o_ma, 1 + n_param);
+ ma->u.p[i]->v->el + o_ma, 1 + n_param);
o_bmap += 1 + n_param;
o_ma += 1 + n_param;
isl_seq_clr(bmap->eq[k] + o_bmap, n_before);
o_bmap += n_before;
isl_seq_cpy(bmap->eq[k] + o_bmap,
- ma->p[i]->v->el + o_ma, n_in);
+ ma->u.p[i]->v->el + o_ma, n_in);
o_bmap += n_in;
o_ma += n_in;
isl_seq_clr(bmap->eq[k] + o_bmap, n_after);
o_bmap += n_after;
isl_seq_cpy(bmap->eq[k] + o_bmap,
- ma->p[i]->v->el + o_ma, n_div_ma);
+ ma->u.p[i]->v->el + o_ma, n_div_ma);
o_bmap += n_div_ma;
o_ma += n_div_ma;
isl_seq_clr(bmap->eq[k] + o_bmap, 1 + total - o_bmap);
- isl_int_neg(bmap->eq[k][1 + total], ma->p[i]->v->el[0]);
+ isl_int_neg(bmap->eq[k][1 + total], ma->u.p[i]->v->el[0]);
total++;
}
n_after = 0;
}
n_div_bmap = isl_basic_map_dim(bmap, isl_dim_div);
- n_div_ma = ma->n ? isl_aff_dim(ma->p[0], isl_dim_div) : 0;
+ n_div_ma = ma->n ? isl_aff_dim(ma->u.p[0], isl_dim_div) : 0;
space = isl_multi_aff_get_domain_space(ma);
space = isl_space_set(isl_basic_map_get_space(bmap), type, space);
--- a/isl_multi_apply_templ.c
+++ b/isl_multi_apply_templ.c
goto error;
for (i = 0; i < multi->n; ++i) {
- multi->p[i] = fn(multi->p[i], FN(APPLY_DOM,copy)(set));
- if (!multi->p[i])
+ multi->u.p[i] = fn(multi->u.p[i], FN(APPLY_DOM,copy)(set));
+ if (!multi->u.p[i])
goto error;
}
diff --git a/isl_multi_cmp.c b/isl_multi_cmp.c
--- a/isl_multi_cmp.c
+++ b/isl_multi_cmp.c
return cmp;
for (i = 0; i < multi1->n; ++i) {
- cmp = FN(EL,plain_cmp)(multi1->p[i], multi2->p[i]);
+ cmp = FN(EL,plain_cmp)(multi1->u.p[i], multi2->u.p[i]);
if (cmp != 0)
return cmp;
}
diff --git a/isl_multi_coalesce.c b/isl_multi_coalesce.c
--- a/isl_multi_coalesce.c
+++ b/isl_multi_coalesce.c
return NULL;
for (i = 0; i < multi->n; ++i) {
- EL *el = FN(EL,copy)(multi->p[i]);
+ EL *el = FN(EL,copy)(multi->u.p[i]);
el = FN(EL,coalesce)(el);
if (!el)
return FN(MULTI(BASE),free)(multi);
- FN(EL,free)(multi->p[i]);
- multi->p[i] = el;
+ FN(EL,free)(multi->u.p[i]);
+ multi->u.p[i] = el;
}
return multi;
diff --git a/isl_multi_dims.c b/isl_multi_dims.c
--- a/isl_multi_dims.c
+++ b/isl_multi_dims.c
for (i = 0; i < multi->n; ++i) {
isl_bool involves;
- involves = FN(EL,involves_dims)(multi->p[i], type, first, n);
+ involves = FN(EL,involves_dims)(multi->u.p[i], type, first, n);
if (involves < 0 || involves)
return involves;
}
return FN(MULTI(BASE),free)(multi);
for (i = 0; i < multi->n; ++i) {
- multi->p[i] = FN(EL,insert_dims)(multi->p[i], type, first, n);
- if (!multi->p[i])
+ multi->u.p[i] = FN(EL,insert_dims)(multi->u.p[i],
+ type, first, n);
+ if (!multi->u.p[i])
return FN(MULTI(BASE),free)(multi);
}
diff --git a/isl_multi_floor.c b/isl_multi_floor.c
--- a/isl_multi_floor.c
+++ b/isl_multi_floor.c
return NULL;
for (i = 0; i < multi->n; ++i) {
- multi->p[i] = FN(EL,floor)(multi->p[i]);
- if (!multi->p[i])
+ multi->u.p[i] = FN(EL,floor)(multi->u.p[i]);
+ if (!multi->u.p[i])
return FN(MULTI(BASE),free)(multi);
}
diff --git a/isl_multi_hash.c b/isl_multi_hash.c
--- a/isl_multi_hash.c
+++ b/isl_multi_hash.c
hash = isl_hash_init();
for (i = 0; i < multi->n; ++i) {
uint32_t el_hash;
- el_hash = FN(EL,get_hash)(multi->p[i]);
+ el_hash = FN(EL,get_hash)(multi->u.p[i]);
isl_hash_hash(hash, el_hash);
}
diff --git a/isl_multi_templ.c b/isl_multi_templ.c
--- a/isl_multi_templ.c
+++ b/isl_multi_templ.c
for (i = 0; i < multi->n; ++i)
dup = FN(FN(MULTI(BASE),set),BASE)(dup, i,
- FN(EL,copy)(multi->p[i]));
+ FN(EL,copy)(multi->u.p[i]));
return dup;
}
isl_space_free(multi->space);
for (i = 0; i < multi->n; ++i)
- FN(EL,free)(multi->p[i]);
+ FN(EL,free)(multi->u.p[i]);
free(multi);
return NULL;
if (type == isl_dim_out)
return multi;
for (i = 0; i < multi->n; ++i) {
- multi->p[i] = FN(EL,set_dim_name)(multi->p[i], type, pos, s);
- if (!multi->p[i])
+ multi->u.p[i] = FN(EL,set_dim_name)(multi->u.p[i],
+ type, pos, s);
+ if (!multi->u.p[i])
return FN(MULTI(BASE),free)(multi);
}
if (pos < 0 || pos >= multi->n)
isl_die(ctx, isl_error_invalid,
"index out of bounds", return NULL);
- return FN(EL,copy)(multi->p[pos]);
+ return FN(EL,copy)(multi->u.p[pos]);
}
__isl_give MULTI(BASE) *FN(FN(MULTI(BASE),set),BASE)(
isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
"index out of bounds", goto error);
- FN(EL,free)(multi->p[pos]);
- multi->p[pos] = el;
+ FN(EL,free)(multi->u.p[pos]);
+ multi->u.p[pos] = el;
isl_space_free(multi_space);
isl_space_free(el_space);
goto error;
for (i = 0; i < multi->n; ++i) {
- multi->p[i] = FN(EL,reset_domain_space)(multi->p[i],
+ multi->u.p[i] = FN(EL,reset_domain_space)(multi->u.p[i],
isl_space_copy(domain));
- if (!multi->p[i])
+ if (!multi->u.p[i])
goto error;
}
isl_space_free(domain);
goto error;
for (i = 0; i < multi->n; ++i) {
- multi->p[i] = FN(EL,realign_domain)(multi->p[i],
+ multi->u.p[i] = FN(EL,realign_domain)(multi->u.p[i],
isl_reordering_copy(exp));
- if (!multi->p[i])
+ if (!multi->u.p[i])
goto error;
}
if (type == isl_dim_out) {
for (i = 0; i < n; ++i)
- FN(EL,free)(multi->p[first + i]);
+ FN(EL,free)(multi->u.p[first + i]);
for (i = first; i + n < multi->n; ++i)
- multi->p[i] = multi->p[i + n];
+ multi->u.p[i] = multi->u.p[i + n];
multi->n -= n;
return multi;
}
for (i = 0; i < multi->n; ++i) {
- multi->p[i] = FN(EL,drop_dims)(multi->p[i], type, first, n);
- if (!multi->p[i])
+ multi->u.p[i] = FN(EL,drop_dims)(multi->u.p[i], type, first, n);
+ if (!multi->u.p[i])
return FN(MULTI(BASE),free)(multi);
}
"spaces don't match", goto error);
for (i = 0; i < multi1->n; ++i) {
- multi1->p[i] = fn(multi1->p[i], FN(EL,copy)(multi2->p[i]));
- if (!multi1->p[i])
+ multi1->u.p[i] = fn(multi1->u.p[i],
+ FN(EL,copy)(multi2->u.p[i]));
+ if (!multi1->u.p[i])
goto error;
}
@@ -1115,8 +1117,9 @@ __isl_give MULTI(BASE) *FN(MULTI(BASE),scale_val)(__isl_take MULTI(BASE) *multi,
return NULL;
for (i = 0; i < multi->n; ++i) {
- multi->p[i] = FN(EL,scale_val)(multi->p[i], isl_val_copy(v));
- if (!multi->p[i])
+ multi->u.p[i] = FN(EL,scale_val)(multi->u.p[i],
+ isl_val_copy(v));
+ if (!multi->u.p[i])
goto error;
}
return NULL;
for (i = 0; i < multi->n; ++i) {
- multi->p[i] = FN(EL,scale_down_val)(multi->p[i],
+ multi->u.p[i] = FN(EL,scale_down_val)(multi->u.p[i],
isl_val_copy(v));
- if (!multi->p[i])
+ if (!multi->u.p[i])
goto error;
}
isl_val *v;
v = isl_multi_val_get_val(mv, i);
- multi->p[i] = FN(EL,scale_val)(multi->p[i], v);
- if (!multi->p[i])
+ multi->u.p[i] = FN(EL,scale_val)(multi->u.p[i], v);
+ if (!multi->u.p[i])
goto error;
}
isl_val *v;
v = isl_multi_val_get_val(mv, i);
- multi->p[i] = FN(EL,scale_down_val)(multi->p[i], v);
- if (!multi->p[i])
+ multi->u.p[i] = FN(EL,scale_down_val)(multi->u.p[i], v);
+ if (!multi->u.p[i])
goto error;
}
isl_val *v;
v = isl_multi_val_get_val(mv, i);
- multi->p[i] = FN(EL,mod_val)(multi->p[i], v);
- if (!multi->p[i])
+ multi->u.p[i] = FN(EL,mod_val)(multi->u.p[i], v);
+ if (!multi->u.p[i])
goto error;
}
@@ -1322,9 +1325,10 @@ __isl_give MULTI(BASE) *FN(MULTI(BASE),move_dims)(__isl_take MULTI(BASE) *multi,
return FN(MULTI(BASE),free)(multi);
for (i = 0; i < multi->n; ++i) {
- multi->p[i] = FN(EL,move_dims)(multi->p[i], dst_type, dst_pos,
+ multi->u.p[i] = FN(EL,move_dims)(multi->u.p[i],
+ dst_type, dst_pos,
src_type, src_pos, n);
- if (!multi->p[i])
+ if (!multi->u.p[i])
return FN(MULTI(BASE),free)(multi);
}
return equal;
for (i = 0; i < multi1->n; ++i) {
- equal = FN(EL,plain_is_equal)(multi1->p[i], multi2->p[i]);
+ equal = FN(EL,plain_is_equal)(multi1->u.p[i], multi2->u.p[i]);
if (equal < 0 || !equal)
return equal;
}
return isl_bool_false;
for (i = 0; i < multi->n; ++i) {
- isl_bool has_nan = FN(EL,involves_nan)(multi->p[i]);
+ isl_bool has_nan = FN(EL,involves_nan)(multi->u.p[i]);
if (has_nan < 0 || has_nan)
return has_nan;
}
return NULL;
for (i = 0; i < multi->n; ++i) {
- multi->p[i] = FN(EL,neg)(multi->p[i]);
- if (!multi->p[i])
+ multi->u.p[i] = FN(EL,neg)(multi->u.p[i]);
+ if (!multi->u.p[i])
return FN(MULTI(BASE),free)(multi);
}
diff --git a/isl_multi_templ.h b/isl_multi_templ.h
--- a/isl_multi_templ.h
+++ b/isl_multi_templ.h
#include <isl_multi_macro.h>
+/* A multiple expression with base expressions of type EL.
+ *
+ * "space" is the space in which the multiple expression lives.
+ * "n" is the number of base expression and is equal
+ * to the output or set dimension of "space".
+ * "p" is an array of size "n" of base expressions.
+ * The array is only accessible when n > 0.
+ */
struct MULTI(BASE) {
int ref;
isl_space *space;
int n;
- EL *p[1];
+ struct {
+ EL *p[1];
+ } u;
};
__isl_give MULTI(BASE) *CAT(MULTI(BASE),_alloc)(__isl_take isl_space *space);
diff --git a/isl_output.c b/isl_output.c
--- a/isl_output.c
+++ b/isl_output.c
isl_multi_aff *ma = data->user;
if (data->type == isl_dim_out)
- p = print_aff_body(p, ma->p[pos]);
+ p = print_aff_body(p, ma->u.p[pos]);
else
p = print_name(data->space, p, data->type, pos, data->latex);
p = isl_printer_print_str(p, "(");
p = print_set_c(p, space, pma->p[i].set);
p = isl_printer_print_str(p, ") ? (");
- p = print_aff_c(p, pma->p[i].maff->p[0]);
+ p = print_aff_c(p, pma->p[i].maff->u.p[0]);
p = isl_printer_print_str(p, ") : ");
}
isl_space_free(space);
- return print_aff_c(p, pma->p[pma->n - 1].maff->p[0]);
+ return print_aff_c(p, pma->p[pma->n - 1].maff->u.p[0]);
}
static __isl_give isl_printer *print_pw_multi_aff_c(__isl_take isl_printer *p,
if (data->type != isl_dim_out)
return print_name(data->space, p, data->type, pos, data->latex);
- pa = mpa->p[pos];
+ pa = mpa->u.p[pos];
if (pa->n == 0)
return isl_printer_print_str(p, "(0 : false)");
isl_multi_val *mv = data->user;
if (data->type == isl_dim_out)
- return isl_printer_print_val(p, mv->p[pos]);
+ return isl_printer_print_val(p, mv->u.p[pos]);
else
return print_name(data->space, p, data->type, pos, data->latex);
}
diff --git a/isl_tab_pip.c b/isl_tab_pip.c
--- a/isl_tab_pip.c
+++ b/isl_tab_pip.c
pos = isl_multi_aff_dim(maff, isl_dim_in) - 1;
for (i = 0; i < maff->n; ++i)
- if (isl_aff_involves_dims(maff->p[i], isl_dim_in, pos, 1))
+ if (isl_aff_involves_dims(maff->u.p[i], isl_dim_in, pos, 1))
return 1;
return 0;
diff --git a/isl_val.c b/isl_val.c
--- a/isl_val.c
+++ b/isl_val.c
goto error;
for (i = 0; i < mv->n; ++i) {
- mv->p[i] = fn(mv->p[i], isl_val_copy(v));
- if (!mv->p[i])
+ mv->u.p[i] = fn(mv->u.p[i], isl_val_copy(v));
+ if (!mv->u.p[i])
goto error;
}