1
commit 2d8b7c6b43ee46fee978a57fa6877de49675f357
2
Author: Taj Muhammad Khan <taj.khan@lri.fr>
3
Date: Thu Dec 5 07:55:16 2013 +0530
5
Use isl_val instead of isl_int
7
isl is moving from the macro-based isl_int to a more generic
8
integer type isl_val, so CLooG does with this patch.
9
Authors are Uday Bondhugula, Taj Muhammad Khan and Cedric Bastoul.
11
diff --git a/include/cloog/isl/constraintset.h b/include/cloog/isl/constraintset.h
12
index c3c2eed..5d48cdb 100644
13
--- a/include/cloog/isl/constraintset.h
14
+++ b/include/cloog/isl/constraintset.h
15
@@ -27,6 +27,12 @@ CloogConstraintSet *cloog_constraint_set_from_isl_basic_set(struct isl_basic_set
16
CloogConstraint *cloog_constraint_from_isl_constraint(struct isl_constraint *constraint);
17
isl_constraint *cloog_constraint_to_isl(CloogConstraint *constraint);
19
+__isl_give isl_val *cloog_int_to_isl_val(isl_ctx* ctx, cloog_int_t c);
20
+void isl_val_to_cloog_int(__isl_keep isl_val *val, cloog_int_t *cint);
22
+__isl_give isl_val *cloog_constraint_coefficient_get_val(CloogConstraint *constraint,
25
#if defined(__cplusplus)
28
diff --git a/source/isl/constraints.c b/source/isl/constraints.c
29
index e860000..73d72df 100644
30
--- a/source/isl/constraints.c
31
+++ b/source/isl/constraints.c
33
#include <cloog/isl/backend.h>
37
+#include <isl/val_gmp.h>
40
#define ALLOC(type) (type*)malloc(sizeof(type))
41
#define ALLOCN(type,n) (type*)malloc((n)*sizeof(type))
43
+__isl_give isl_val *cloog_int_to_isl_val(isl_ctx* ctx, cloog_int_t c)
46
+#if defined(CLOOG_INT_INT)
47
+ v = isl_val_int_from_si(ctx, c);
48
+#elif defined(CLOOG_INT_LONG)
49
+ v = isl_val_int_from_si(ctx, c);
50
+#elif defined(CLOOG_INT_LONG_LONG)
51
+ v = isl_val_int_from_si(ctx, c);
52
+#elif defined(CLOOG_INT_GMP)
53
+ v = isl_val_int_from_gmp(ctx, c);
55
+#error "No integer type defined"
61
+ * CLooG'll be dealing in integers so we expect numerator/1 form
62
+ * from isl_val. Thus get numerator to assign to cloog_int
64
+void isl_val_to_cloog_int(__isl_keep isl_val *val, cloog_int_t *cint)
66
+ assert(isl_val_is_int(val));
67
+#if defined(CLOOG_INT_INT)
68
+ *cint = isl_val_get_num_si(val);
69
+#elif defined(CLOOG_INT_LONG)
70
+ *cint = isl_val_get_num_si(val);
71
+#elif defined(CLOOG_INT_LONG_LONG)
72
+ *cint = isl_val_get_num_si(val);
73
+#elif defined(CLOOG_INT_GMP)
74
+ isl_val_get_num_gmp(val, *cint);
76
+#error "No integer type defined"
81
CloogConstraintSet *cloog_constraint_set_from_isl_basic_set(struct isl_basic_set *bset)
83
return (CloogConstraintSet *)bset;
84
@@ -266,53 +306,65 @@ int cloog_equal_count(CloogEqualities *equal)
85
static int cloog_constraint_equal_type(CloogConstraint *cc, int level)
90
int type = EQTYPE_NONE;
91
struct isl_constraint *constraint = cloog_constraint_to_isl(cc);
94
- isl_constraint_get_constant(constraint, &c);
95
- if (!isl_int_is_zero(c))
96
+ c = isl_constraint_get_constant_val(constraint);
97
+ if (!isl_val_is_zero(c))
98
type = EQTYPE_CONSTANT;
99
- isl_constraint_get_coefficient(constraint, isl_dim_set, level - 1, &c);
100
- if (!isl_int_is_one(c) && !isl_int_is_negone(c))
102
+ c = isl_constraint_get_coefficient_val(constraint, isl_dim_set, level - 1);
103
+ if (!isl_val_is_one(c) && !isl_val_is_negone(c))
104
type = EQTYPE_EXAFFINE;
106
for (i = 0; i < isl_constraint_dim(constraint, isl_dim_param); ++i) {
107
- isl_constraint_get_coefficient(constraint, isl_dim_param, i, &c);
108
- if (isl_int_is_zero(c))
109
+ c = isl_constraint_get_coefficient_val(constraint, isl_dim_param, i);
110
+ if (isl_val_is_zero(c)){
113
- if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) ||
115
+ if ((!isl_val_is_one(c) && !isl_val_is_negone(c)) ||
116
type != EQTYPE_NONE) {
117
type = EQTYPE_EXAFFINE;
121
type = EQTYPE_PUREITEM;
124
for (i = 0; i < isl_constraint_dim(constraint, isl_dim_set); ++i) {
127
- isl_constraint_get_coefficient(constraint, isl_dim_set, i, &c);
128
- if (isl_int_is_zero(c))
129
+ c = isl_constraint_get_coefficient_val(constraint, isl_dim_set, i);
130
+ if (isl_val_is_zero(c)){
133
- if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) ||
135
+ if ((!isl_val_is_one(c) && !isl_val_is_negone(c)) ||
136
type != EQTYPE_NONE) {
137
type = EQTYPE_EXAFFINE;
141
type = EQTYPE_PUREITEM;
144
for (i = 0; i < isl_constraint_dim(constraint, isl_dim_div); ++i) {
145
- isl_constraint_get_coefficient(constraint, isl_dim_div, i, &c);
146
- if (isl_int_is_zero(c))
147
+ c = isl_constraint_get_coefficient_val(constraint, isl_dim_div, i);
148
+ if (isl_val_is_zero(c)){
151
- if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) ||
153
+ if ((!isl_val_is_one(c) && !isl_val_is_negone(c)) ||
154
type != EQTYPE_NONE) {
155
type = EQTYPE_EXAFFINE;
159
type = EQTYPE_PUREITEM;
164
if (type == EQTYPE_NONE)
165
type = EQTYPE_CONSTANT;
166
@@ -447,27 +499,31 @@ static struct clast_expr *div_expr(CloogConstraint *constraint, int pos,
169
unsigned dim = cloog_constraint_total_dimension(constraint);
172
struct clast_reduction *r;
173
struct clast_expr *e = NULL;
177
+ cloog_int_init(cint);
178
div = isl_constraint_get_div(cloog_constraint_to_isl(constraint), pos);
181
for (i = 0, nb_elts = 0; i < dim; ++i) {
182
struct cloog_isl_dim dim;
184
dim = constraint_cloog_dim_to_isl_dim(constraint, i);
185
if (dim.type == isl_dim_set)
186
dim.type = isl_dim_in;
187
- isl_aff_get_coefficient(div, dim.type, dim.pos, &c);
188
- if (!cloog_int_is_zero(c))
189
+ c = isl_aff_get_coefficient_val(div, dim.type, dim.pos);
190
+ if (!isl_val_is_zero(c))
195
- isl_aff_get_constant(div, &c);
196
- if (!cloog_int_is_zero(c))
197
+ c = isl_aff_get_constant_val(div);
198
+ if (!isl_val_is_zero(c))
202
r = new_clast_reduction(clast_red_sum, nb_elts);
203
for (i = 0, nb_elts = 0; i < dim; ++i) {
204
@@ -477,22 +533,35 @@ static struct clast_expr *div_expr(CloogConstraint *constraint, int pos,
205
dim = constraint_cloog_dim_to_isl_dim(constraint, i);
206
if (dim.type == isl_dim_set)
207
dim.type = isl_dim_in;
208
- isl_aff_get_coefficient(div, dim.type, dim.pos, &c);
209
- if (cloog_int_is_zero(c))
210
+ c = isl_aff_get_coefficient_val(div, dim.type, dim.pos);
211
+ if (isl_val_is_zero(c)){
216
v = cloog_constraint_variable_expr(constraint, 1 + i, names);
218
- r->elts[nb_elts++] = &new_clast_term(c, v)->expr;
219
+ /* We are interested only in the numerator */
220
+ cloog_int_set_si(cint, isl_val_get_num_si(c));
221
+ r->elts[nb_elts++] = &new_clast_term(cint, v)->expr;
226
+ c = isl_aff_get_constant_val(div);
227
+ if (!isl_val_is_zero(c)) {
228
+ /* We are interested only in the numerator */
229
+ cloog_int_set_si(cint, isl_val_get_num_si(c));
230
+ r->elts[nb_elts++] = &new_clast_term(cint, NULL)->expr;
232
- isl_aff_get_constant(div, &c);
233
- if (!cloog_int_is_zero(c))
234
- r->elts[nb_elts++] = &new_clast_term(c, NULL)->expr;
237
- isl_aff_get_denominator(div, &c);
238
- e = &new_clast_binary(clast_bin_fdiv, &r->expr, c)->expr;
239
+ c = isl_aff_get_denominator_val(div);
240
+ isl_val_to_cloog_int(c, &cint);
242
+ e = &new_clast_binary(clast_bin_fdiv, &r->expr, cint)->expr;
244
- cloog_int_clear(c);
245
+ cloog_int_clear(cint);
249
@@ -529,37 +598,34 @@ struct clast_expr *cloog_constraint_variable_expr(CloogConstraint *constraint,
251
int cloog_constraint_involves(CloogConstraint *constraint, int v)
258
- cloog_constraint_coefficient_get(constraint, v, &c);
259
- res = !isl_int_is_zero(c);
261
+ c = cloog_constraint_coefficient_get_val(constraint, v);
262
+ res = !isl_val_is_zero(c);
267
int cloog_constraint_is_lower_bound(CloogConstraint *constraint, int v)
274
- cloog_constraint_coefficient_get(constraint, v, &c);
275
- res = isl_int_is_pos(c);
277
+ c = cloog_constraint_coefficient_get_val(constraint, v);
278
+ res = isl_val_is_pos(c);
283
int cloog_constraint_is_upper_bound(CloogConstraint *constraint, int v)
290
- cloog_constraint_coefficient_get(constraint, v, &c);
291
- res = isl_int_is_neg(c);
293
+ c = cloog_constraint_coefficient_get_val(constraint, v);
294
+ res = isl_val_is_neg(c);
299
@@ -585,15 +651,37 @@ void cloog_constraint_coefficient_get(CloogConstraint *constraint,
301
struct cloog_isl_dim dim;
308
+ dim = constraint_cloog_dim_to_isl_dim(constraint, var);
309
+ c = cloog_constraint_to_isl(constraint);
310
+ ival = isl_constraint_get_coefficient_val(c, dim.type, dim.pos);
312
+ isl_val_to_cloog_int(ival, val);
313
+ isl_val_free(ival);
316
+isl_val *cloog_constraint_coefficient_get_val(CloogConstraint *constraint,
319
+ struct cloog_isl_dim dim;
327
dim = constraint_cloog_dim_to_isl_dim(constraint, var);
328
c = cloog_constraint_to_isl(constraint);
329
- isl_constraint_get_coefficient(c, dim.type, dim.pos, val);
330
+ val = isl_constraint_get_coefficient_val(c, dim.type, dim.pos);
336
void cloog_constraint_coefficient_set(CloogConstraint *constraint,
337
int var, cloog_int_t val)
339
@@ -604,14 +692,26 @@ void cloog_constraint_coefficient_set(CloogConstraint *constraint,
341
dim = constraint_cloog_dim_to_isl_dim(constraint, var);
342
c = cloog_constraint_to_isl(constraint);
343
- isl_constraint_set_coefficient(c, dim.type, dim.pos, val);
344
+ isl_constraint_set_coefficient_val(c, dim.type, dim.pos,
345
+ cloog_int_to_isl_val(isl_constraint_get_ctx(c), val));
348
void cloog_constraint_constant_get(CloogConstraint *constraint, cloog_int_t *val)
350
- isl_constraint_get_constant(cloog_constraint_to_isl(constraint), val);
352
+ ival = isl_constraint_get_constant_val(cloog_constraint_to_isl(constraint));
353
+ isl_val_to_cloog_int(ival, val);
354
+ isl_val_free(ival);
358
+__isl_give isl_val *cloog_constraint_constant_get_val(CloogConstraint *constraint)
360
+ return isl_constraint_get_constant_val(cloog_constraint_to_isl(constraint));
366
* Copy the coefficient of constraint c into dst in PolyLib order,
367
* i.e., first the coefficients of the variables, then the coefficients
368
@@ -700,15 +800,11 @@ CloogConstraintSet *cloog_constraint_set_for_reduction(CloogConstraint *upper,
370
static int add_constant_term(CloogConstraint *c, void *user)
372
- isl_int *bound = (isl_int *)user;
377
- cloog_constraint_constant_get(c, &v);
378
- isl_int_add(*bound, *bound, v);
379
+ isl_val **bound = (isl_val **)user;
383
+ v = cloog_constraint_constant_get_val(c);
384
+ *bound = isl_val_add(*bound, v);
388
@@ -822,11 +918,14 @@ CloogConstraintSet *cloog_constraint_set_reduce(CloogConstraintSet *constraints,
389
c = isl_constraint_set_coefficient_si(c, isl_dim_set, dim.pos, -1);
390
bset = isl_basic_set_add_constraint(bset, c);
392
- isl_int_set_si(*bound, 0);
393
+ cloog_int_set_si(*bound, 0);
394
+ isl_val *v = cloog_int_to_isl_val(isl_basic_set_get_ctx(bset), *bound);
395
constraints = cloog_constraint_set_from_isl_basic_set(bset);
396
cloog_constraint_set_foreach_constraint(constraints,
397
- add_constant_term, bound);
398
+ add_constant_term, &v);
399
+ isl_val_to_cloog_int(v, bound); //return the value to bound
402
isl_basic_set_free(orig);
403
return cloog_constraint_set_from_isl_basic_set(bset);
405
@@ -896,31 +995,27 @@ static isl_aff *extract_stride_offset(__isl_keep isl_constraint *c,
406
isl_space *dim = isl_constraint_get_space(c);
407
isl_local_space *ls = isl_local_space_from_space(dim);
408
isl_aff *offset = isl_aff_zero_on_domain(ls);
411
unsigned nparam, nvar;
415
nparam = isl_constraint_dim(c, isl_dim_param);
416
nvar = isl_constraint_dim(c, isl_dim_set);
418
for (i = 0; i < nparam; ++i) {
419
- isl_constraint_get_coefficient(c, isl_dim_param, i, &u);
420
- isl_int_mul(u, u, stride->factor);
421
- offset = isl_aff_set_coefficient(offset, isl_dim_param, i, u);
422
+ u = isl_constraint_get_coefficient_val(c, isl_dim_param, i);
423
+ u = isl_val_mul(u, cloog_int_to_isl_val(isl_constraint_get_ctx(c), stride->factor));
424
+ offset = isl_aff_set_coefficient_val(offset, isl_dim_param, i, u);
426
for (i = 0; i < nvar; ++i) {
429
- isl_constraint_get_coefficient(c, isl_dim_set, i, &u);
430
- isl_int_mul(u, u, stride->factor);
431
- offset = isl_aff_set_coefficient(offset, isl_dim_in, i, u);
432
+ u = isl_constraint_get_coefficient_val(c, isl_dim_set, i);
433
+ u = isl_val_mul(u, cloog_int_to_isl_val(isl_constraint_get_ctx(c), stride->factor));
434
+ offset = isl_aff_set_coefficient_val(offset, isl_dim_in, i, u);
436
- isl_constraint_get_constant(c, &u);
437
- isl_int_mul(u, u, stride->factor);
438
- offset = isl_aff_set_constant(offset, u);
441
+ u = isl_constraint_get_constant_val(c);
442
+ u = isl_val_mul(u, cloog_int_to_isl_val(isl_constraint_get_ctx(c), stride->factor));
443
+ offset = isl_aff_set_constant_val(offset, u);
447
@@ -953,9 +1048,9 @@ CloogConstraint *cloog_constraint_stride_lower_bound(CloogConstraint *c,
448
offset = extract_stride_offset(stride_c, level, stride);
450
lower = isl_aff_sub(lower, isl_aff_copy(offset));
451
- lower = isl_aff_scale_down(lower, stride->stride);
452
+ lower = isl_aff_scale_down_val(lower, cloog_int_to_isl_val(isl_constraint_get_ctx(stride_c), stride->stride));
453
lower = isl_aff_ceil(lower);
454
- lower = isl_aff_scale(lower, stride->stride);
455
+ lower = isl_aff_scale_val(lower, cloog_int_to_isl_val(isl_constraint_get_ctx(stride_c), stride->stride));
456
lower = isl_aff_add(lower, offset);
457
lower = isl_aff_neg(lower);
458
lower = isl_aff_add_coefficient_si(lower, isl_dim_in, level - 1, 1);
459
diff --git a/source/isl/domain.c b/source/isl/domain.c
460
index 620584d..dc81a96 100644
461
--- a/source/isl/domain.c
462
+++ b/source/isl/domain.c
464
#include <isl/list.h>
465
#include <isl/constraint.h>
469
+#include <isl/map.h>
470
+#include <isl/val.h>
471
+#include <isl/val_gmp.h>
474
#include <osl/macros.h>
475
@@ -510,15 +514,18 @@ static struct isl_constraint *isl_constraint_read_from_matrix(
477
constraint = isl_inequality_alloc(ls);
479
- for (j = 0; j < nvariables; ++j)
480
- isl_constraint_set_coefficient(constraint, isl_dim_out, j,
482
+ for (j = 0; j < nvariables; ++j) {
483
+ isl_val *val = cloog_int_to_isl_val(isl_constraint_get_ctx(constraint), row[1 + j]);
484
+ isl_constraint_set_coefficient_val(constraint, isl_dim_out, j, val);
487
- for (j = 0; j < nparam; ++j)
488
- isl_constraint_set_coefficient(constraint, isl_dim_param, j,
489
- row[1 + nvariables + j]);
490
+ for (j = 0; j < nparam; ++j) {
491
+ isl_val *val = cloog_int_to_isl_val(isl_constraint_get_ctx(constraint), row[1 + nvariables + j]);
492
+ isl_constraint_set_coefficient_val(constraint, isl_dim_param, j, val);
495
- isl_constraint_set_constant(constraint, row[1 + nvariables + nparam]);
496
+ isl_val *val = cloog_int_to_isl_val(isl_constraint_get_ctx(constraint), row[1 + nvariables + nparam]);
497
+ isl_constraint_set_constant_val(constraint, val);
501
@@ -631,7 +638,6 @@ CloogDomain *cloog_domain_from_osl_relation(CloogState *state,
507
* Converts an openscop scattering relation to a CLooG scattering.
508
* \param[in,out] state CLooG state.
509
@@ -779,10 +785,22 @@ int cloog_domain_is_otl(CloogDomain *domain, int level)
510
void cloog_domain_stride(CloogDomain *domain, int strided_level,
511
cloog_int_t *stride, cloog_int_t *offset)
514
isl_set *set = isl_set_from_cloog_domain(domain);
515
- isl_set_dim_residue_class(set, strided_level - 1, stride, offset);
516
- if (!isl_int_is_zero(*offset))
517
- isl_int_sub(*offset, *stride, *offset);
518
+ isl_val *stride_val = NULL;
519
+ isl_val *offset_val = NULL;
520
+ ret = isl_set_dim_residue_class_val(set, strided_level - 1, &stride_val, &offset_val);
522
+ cloog_die("failure to compute stride.\n");
523
+ isl_val_to_cloog_int(stride_val, stride);
524
+ isl_val_to_cloog_int(offset_val, offset);
526
+ if (!cloog_int_is_zero(*offset))
527
+ cloog_int_sub(*offset, *stride, *offset);
529
+ isl_val_free(stride_val);
530
+ isl_val_free(offset_val);
535
@@ -796,7 +814,7 @@ static int constraint_can_stride(__isl_take isl_constraint *c, void *user)
537
struct cloog_can_stride *ccs = (struct cloog_can_stride *)user;
543
if (isl_constraint_is_equality(c)) {
544
@@ -804,21 +822,22 @@ static int constraint_can_stride(__isl_take isl_constraint *c, void *user)
549
- isl_constraint_get_coefficient(c, isl_dim_set, ccs->level - 1, &v);
550
- if (isl_int_is_pos(v)) {
551
+ v = isl_constraint_get_coefficient_val(c, isl_dim_set, ccs->level - 1);
552
+ if (isl_val_is_pos(v)) {
553
n_div = isl_constraint_dim(c, isl_dim_div);
555
for (i = 0; i < n_div; ++i) {
556
- isl_constraint_get_coefficient(c, isl_dim_div, i, &v);
557
- if (!isl_int_is_zero(v))
559
+ v = isl_constraint_get_coefficient_val(c, isl_dim_div, i);
560
+ if (!isl_val_is_zero(v))
567
- isl_constraint_free(c);
570
+ isl_constraint_free(c);
574
@@ -903,7 +922,7 @@ struct cloog_stride_lower {
575
static int constraint_stride_lower(__isl_take isl_constraint *c, void *user)
577
struct cloog_stride_lower *csl = (struct cloog_stride_lower *)user;
580
isl_constraint *bound;
583
@@ -912,31 +931,31 @@ static int constraint_stride_lower(__isl_take isl_constraint *c, void *user)
588
- isl_constraint_get_coefficient(c, isl_dim_set, csl->level - 1, &v);
589
- if (!isl_int_is_pos(v)) {
591
+ v = isl_constraint_get_coefficient_val(c, isl_dim_set, csl->level - 1);
592
+ if (!isl_val_is_pos(v)) {
594
isl_constraint_free(c);
600
b = isl_constraint_get_bound(c, isl_dim_set, csl->level - 1);
603
- b = isl_aff_add_constant(b, csl->stride->offset);
604
- b = isl_aff_scale_down(b, csl->stride->stride);
605
+ b = isl_aff_add_constant_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(c), csl->stride->offset));
606
+ b = isl_aff_scale_down_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(c), csl->stride->stride));
607
b = isl_aff_floor(b);
608
- b = isl_aff_scale(b, csl->stride->stride);
609
- isl_int_neg(v, csl->stride->offset);
610
- b = isl_aff_add_constant(b, v);
611
+ b = isl_aff_scale_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(c), csl->stride->stride));
612
+ v = cloog_int_to_isl_val(isl_constraint_get_ctx(c), csl->stride->offset);
613
+ v = isl_val_neg(v);
614
+ b = isl_aff_add_constant_val(b, v);
615
b = isl_aff_add_coefficient_si(b, isl_dim_in, csl->level - 1, 1);
617
bound = isl_inequality_from_aff(b);
619
csl->bounds = isl_basic_set_add_constraint(csl->bounds, bound);
622
isl_constraint_free(c);
625
@@ -960,7 +979,7 @@ static int constraint_stride_lower(__isl_take isl_constraint *c, void *user)
626
static int constraint_stride_lower_c(__isl_take isl_constraint *c, void *user)
628
struct cloog_stride_lower *csl = (struct cloog_stride_lower *)user;
631
isl_constraint *bound;
632
isl_constraint *csl_c;
634
@@ -970,10 +989,9 @@ static int constraint_stride_lower_c(__isl_take isl_constraint *c, void *user)
639
- isl_constraint_get_coefficient(c, isl_dim_set, csl->level - 1, &v);
640
- if (!isl_int_is_pos(v)) {
642
+ v = isl_constraint_get_coefficient_val(c, isl_dim_set, csl->level - 1);
643
+ if (!isl_val_is_pos(v)) {
645
isl_constraint_free(c);
648
@@ -984,15 +1002,15 @@ static int constraint_stride_lower_c(__isl_take isl_constraint *c, void *user)
649
d = isl_constraint_get_aff(csl_c);
650
d = isl_aff_drop_dims(d, isl_dim_div, 0, isl_aff_dim(d, isl_dim_div));
651
d = isl_aff_set_coefficient_si(d, isl_dim_in, csl->level - 1, 0);
652
- d = isl_aff_scale(d, csl->stride->factor);
653
+ d = isl_aff_scale_val(d, cloog_int_to_isl_val(isl_constraint_get_ctx(csl_c), csl->stride->factor));
655
b = isl_constraint_get_bound(c, isl_dim_set, csl->level - 1);
658
b = isl_aff_add(b, isl_aff_copy(d));
659
- b = isl_aff_scale_down(b, csl->stride->stride);
660
+ b = isl_aff_scale_down_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(csl_c), csl->stride->stride));
661
b = isl_aff_floor(b);
662
- b = isl_aff_scale(b, csl->stride->stride);
663
+ b = isl_aff_scale_val(b, cloog_int_to_isl_val(isl_constraint_get_ctx(csl_c), csl->stride->stride));
664
b = isl_aff_sub(b, d);
665
b = isl_aff_add_coefficient_si(b, isl_dim_in, csl->level - 1, 1);
667
@@ -1000,7 +1018,7 @@ static int constraint_stride_lower_c(__isl_take isl_constraint *c, void *user)
669
csl->bounds = isl_basic_set_add_constraint(csl->bounds, bound);
673
isl_constraint_free(c);
676
@@ -1090,28 +1108,30 @@ struct cloog_bound_split {
677
static int constraint_bound_split(__isl_take isl_constraint *c, void *user)
679
struct cloog_bound_split *cbs = (struct cloog_bound_split *)user;
686
- isl_constraint_get_coefficient(c, isl_dim_set, cbs->level - 1, &v);
687
- if (!cbs->lower && isl_int_is_pos(v))
688
+ v = isl_constraint_get_coefficient_val(c, isl_dim_set, cbs->level - 1);
689
+ if (!cbs->lower && isl_val_is_pos(v))
690
cbs->lower = handle = 1;
691
- else if (!cbs->upper && isl_int_is_neg(v))
692
+ else if (!cbs->upper && isl_val_is_neg(v))
693
cbs->upper = handle = 1;
696
for (i = 0; i < isl_set_dim(cbs->set, isl_dim_param); ++i) {
697
- isl_constraint_get_coefficient(c, isl_dim_param, i, &v);
698
- if (isl_int_is_zero(v))
700
+ v = isl_constraint_get_coefficient_val(c, isl_dim_param, i);
701
+ if (isl_val_is_zero(v))
704
cbs->set = isl_set_split_dims(cbs->set,
705
isl_dim_param, i, 1);
709
- isl_constraint_free(c);
712
+ isl_constraint_free(c);
713
return (cbs->lower && cbs->upper) ? -1 : 0;
716
@@ -1203,7 +1223,7 @@ static int injective_scattering(CloogScatteringList *list)
717
* - scattdims is the total number of scattering dimentions.
719
int cloog_scattering_lazy_block(CloogScattering *s1, CloogScattering *s2,
720
- CloogScatteringList *scattering, int scattdims)
721
+ CloogScatteringList *scattering, int scattdims)
724
struct isl_space *dim;
725
@@ -1211,8 +1231,8 @@ int cloog_scattering_lazy_block(CloogScattering *s1, CloogScattering *s2,
726
struct isl_set *delta;
727
isl_map *map1 = isl_map_from_cloog_scattering(s1);
728
isl_map *map2 = isl_map_from_cloog_scattering(s2);
735
n_scat = isl_map_dim(map1, isl_dim_out);
736
@@ -1225,22 +1245,33 @@ int cloog_scattering_lazy_block(CloogScattering *s1, CloogScattering *s2,
737
rel = isl_map_apply_domain(rel, isl_map_copy(map1));
738
rel = isl_map_apply_range(rel, isl_map_copy(map2));
739
delta = isl_map_deltas(rel);
742
for (i = 0; i < n_scat; ++i) {
743
- fixed = isl_set_fast_dim_is_fixed(delta, i, &cst);
745
+ cst = isl_set_plain_get_val_if_fixed(delta, isl_dim_set, i);
749
- if (isl_int_is_zero(cst))
751
+ if (isl_val_is_zero(cst)){
754
- if (i + 1 < n_scat)
756
+ if (i + 1 < n_scat){
759
- if (!isl_int_is_one(cst))
761
+ if (!isl_val_is_one(cst)){
764
- if (!injective_scattering(scattering))
766
+ if (!injective_scattering(scattering)){
774
- isl_int_clear(cst);
778
@@ -1345,10 +1376,25 @@ CloogDomain *cloog_domain_simplify_union(CloogDomain *domain)
779
* If value is not NULL, then it is set to the constant value of dimension.
781
int cloog_scattering_lazy_isscalar(CloogScattering *scatt, int dimension,
782
- cloog_int_t *value)
783
+ cloog_int_t *value)
785
isl_map *map = isl_map_from_cloog_scattering(scatt);
786
- return isl_map_fast_is_fixed(map, isl_dim_out, dimension, value);
787
+ isl_val *v = isl_map_plain_get_val_if_fixed(map, isl_dim_out, dimension);
789
+ if (!isl_val_is_nan(v)){
791
+ isl_val_to_cloog_int(v, value);
806
@@ -1362,7 +1408,22 @@ int cloog_domain_lazy_isconstant(CloogDomain *domain, int dimension,
809
isl_set *set = isl_set_from_cloog_domain(domain);
810
- return isl_set_fast_dim_is_fixed(set, dimension, value);
811
+ isl_val *cst = isl_set_plain_get_val_if_fixed(set, isl_dim_set, dimension);
813
+ if (!isl_val_is_nan(cst)){
815
+ isl_val_to_cloog_int(cst, value);
830
@@ -1391,6 +1452,8 @@ CloogDomain *cloog_domain_cube(CloogState *state,
838
return cloog_domain_universe(state, dim);
839
@@ -1398,8 +1461,10 @@ CloogDomain *cloog_domain_cube(CloogState *state,
840
space = isl_space_set_alloc(state->backend->ctx, 0, dim);
841
cube = isl_set_universe(space);
842
for (i = 0; i < dim; ++i) {
843
- cube = isl_set_lower_bound(cube, isl_dim_set, i, min);
844
- cube = isl_set_upper_bound(cube, isl_dim_set, i, max);
845
+ min_v = cloog_int_to_isl_val(isl_set_get_ctx(cube), min);
846
+ max_v = cloog_int_to_isl_val(isl_set_get_ctx(cube), max);
847
+ cube = isl_set_lower_bound_val(cube, isl_dim_set, i, min_v);
848
+ cube = isl_set_upper_bound_val(cube, isl_dim_set, i, max_v);
851
return cloog_domain_from_isl_set(cube);
852
@@ -1595,7 +1660,7 @@ static void Euclid(cloog_int_t a, cloog_int_t b,
853
cloog_int_mul(tmp, tmp, d);
854
cloog_int_sub(c, c, tmp);
855
cloog_int_swap(c, d);
856
- cloog_int_swap(e, f);
857
+ cloog_int_swap(e, f);
859
cloog_int_set(*g, c);
860
if (cloog_int_is_zero(a))
861
@@ -1631,49 +1696,70 @@ static void Euclid(cloog_int_t a, cloog_int_t b,
862
static CloogStride *construct_stride(isl_constraint *c, int level)
865
- isl_int v, m, gcd, stride, factor;
866
+ isl_val *v, *m, *gcd, *stride;
867
+ isl_val *v_copy, *m_copy, *gcd_copy;
868
+ cloog_int_t c_v, c_m, c_gcd, c_stride, c_factor;
870
+ isl_ctx *ctx = isl_constraint_get_ctx(c);;
878
- isl_int_init(factor);
879
- isl_int_init(stride);
880
+ v = isl_constraint_get_coefficient_val(c, isl_dim_set, level - 1);
882
- isl_constraint_get_coefficient(c, isl_dim_set, level - 1, &v);
883
- sign = isl_int_sgn(v);
885
+ sign = isl_val_sgn(v);
886
+ m = isl_val_abs(v); /* *takes* v. */
888
- isl_int_set_si(gcd, 0);
889
+ gcd = isl_val_int_from_si(ctx, 0);
890
n = isl_constraint_dim(c, isl_dim_div);
891
for (i = 0; i < n; ++i) {
892
- isl_constraint_get_coefficient(c, isl_dim_div, i, &v);
893
- isl_int_gcd(gcd, gcd, v);
894
+ v = isl_constraint_get_coefficient_val(c, isl_dim_div, i);
895
+ gcd = isl_val_gcd(gcd, v);
898
- isl_int_gcd(v, m, gcd);
899
- isl_int_divexact(stride, gcd, v);
900
+ m_copy = isl_val_copy(m);
901
+ gcd_copy = isl_val_copy(gcd);
903
- if (isl_int_is_zero(stride) || isl_int_is_one(stride))
904
+ v = isl_val_gcd(m, gcd);
906
+ v_copy = isl_val_copy(v);
907
+ gcd = isl_val_copy(gcd_copy);
908
+ stride = isl_val_div(gcd, v);
910
+ if (isl_val_is_zero(stride) || isl_val_is_one(stride))
913
- Euclid(m, stride, &factor, &v, &gcd);
914
+ cloog_int_init(c_m);
915
+ cloog_int_init(c_stride);
916
+ cloog_int_init(c_v);
917
+ cloog_int_init(c_gcd);
918
+ cloog_int_init(c_factor);
920
+ isl_val_to_cloog_int(m_copy, &c_m);
921
+ isl_val_to_cloog_int(stride, &c_stride);
922
+ isl_val_to_cloog_int(v_copy, &c_v);
923
+ isl_val_to_cloog_int(gcd_copy, &c_gcd);
925
+ Euclid(c_m, c_stride, &c_factor, &c_v, &c_gcd);
927
- isl_int_neg(factor, factor);
928
+ cloog_int_neg(c_factor, c_factor);
930
c = isl_constraint_copy(c);
931
- s = cloog_stride_alloc_from_constraint(stride,
932
- cloog_constraint_from_isl_constraint(c), factor);
933
+ s = cloog_stride_alloc_from_constraint(c_stride,
934
+ cloog_constraint_from_isl_constraint(c), c_factor);
937
+ cloog_int_clear(c_m);
938
+ cloog_int_clear(c_stride);
939
+ cloog_int_clear(c_v);
940
+ cloog_int_clear(c_gcd);
941
+ cloog_int_clear(c_factor);
944
- isl_int_clear(stride);
945
- isl_int_clear(factor);
946
- isl_int_clear(gcd);
949
+ isl_val_free(stride);
950
+ isl_val_free(gcd_copy);
951
+ isl_val_free(m_copy);
952
+ isl_val_free(v_copy);
956
@@ -1694,7 +1780,7 @@ static int find_stride(__isl_take isl_constraint *c, void *user)
958
struct cloog_isl_find_stride_data *data;
963
if (!isl_constraint_is_equality(c)) {
964
isl_constraint_free(c);
965
@@ -1714,13 +1800,11 @@ static int find_stride(__isl_take isl_constraint *c, void *user)
971
- isl_constraint_get_coefficient(c, isl_dim_set, data->level - 1, &v);
972
- if (!isl_int_is_zero(v))
973
+ v = isl_constraint_get_coefficient_val(c, isl_dim_set, data->level - 1);
974
+ if (!isl_val_is_zero(v))
975
data->stride = construct_stride(c, data->level);
980
isl_constraint_free(c);
982
@@ -1769,7 +1853,7 @@ struct cloog_can_unroll {
991
@@ -1782,11 +1866,11 @@ struct cloog_can_unroll {
992
* with l the given lower bound and i the iterator identified by level.
994
static int is_valid_unrolling_lower_bound(struct cloog_can_unroll *ccu,
995
- __isl_keep isl_constraint *c, isl_int *v)
996
+ __isl_keep isl_constraint *c, isl_val **v)
1000
- enum isl_lp_result res;
1001
+ enum isl_lp_result;
1003
n_div = isl_constraint_dim(c, isl_dim_div);
1004
if (isl_constraint_involves_dims(c, isl_dim_div, 0, n_div))
1005
@@ -1796,15 +1880,19 @@ static int is_valid_unrolling_lower_bound(struct cloog_can_unroll *ccu,
1006
aff = isl_aff_ceil(aff);
1007
aff = isl_aff_neg(aff);
1008
aff = isl_aff_add_coefficient_si(aff, isl_dim_in, ccu->level - 1, 1);
1009
- res = isl_set_max(ccu->set, aff, v);
1010
+ *v = isl_set_max_val(ccu->set, aff);
1013
- if (res == isl_lp_unbounded)
1015
+ if (!*v || isl_val_is_nan(*v))
1016
+ cloog_die("Fail to decide about unrolling (cannot find max)");
1018
- assert(res == isl_lp_ok);
1019
+ if (isl_val_is_infty(*v) || isl_val_is_neginfty(*v)){
1025
- cloog_int_add_ui(*v, *v, 1);
1026
+ *v = isl_val_add_ui(*v, 1);
1030
@@ -1818,21 +1906,21 @@ static int is_valid_unrolling_lower_bound(struct cloog_can_unroll *ccu,
1031
static int constraint_can_unroll(__isl_take isl_constraint *c, void *user)
1033
struct cloog_can_unroll *ccu = (struct cloog_can_unroll *)user;
1038
- isl_int_init(count);
1039
- isl_constraint_get_coefficient(c, isl_dim_set, ccu->level - 1, &v);
1040
- if (isl_int_is_pos(v) &&
1041
- is_valid_unrolling_lower_bound(ccu, c, &count) &&
1042
- (!ccu->c || isl_int_lt(count, *ccu->n))) {
1044
+ isl_val *count = NULL;
1046
+ v = isl_constraint_get_coefficient_val(c, isl_dim_set, ccu->level - 1);
1047
+ if (isl_val_is_pos(v) &&
1048
+ is_valid_unrolling_lower_bound(ccu, c, &count) &&
1049
+ (!ccu->c || (isl_val_lt(count, ccu->n))) ) {
1050
isl_constraint_free(ccu->c);
1051
ccu->c = isl_constraint_copy(c);
1052
- isl_int_set(*ccu->n, count);
1054
+ isl_val_free(ccu->n);
1055
+ ccu->n = isl_val_copy(count);
1057
- isl_int_clear(count);
1059
+ isl_val_free(count);
1061
isl_constraint_free(c);
1064
@@ -1872,7 +1960,8 @@ int cloog_domain_can_unroll(CloogDomain *domain, int level, cloog_int_t *n,
1065
CloogConstraint **lb)
1067
isl_set *set = isl_set_from_cloog_domain(domain);
1068
- struct cloog_can_unroll ccu = { 1, level, NULL, set, n };
1069
+ isl_val *v = cloog_int_to_isl_val(isl_set_get_ctx(set), *n);
1070
+ struct cloog_can_unroll ccu = { 1, level, NULL, set, v };
1074
@@ -1887,6 +1976,11 @@ int cloog_domain_can_unroll(CloogDomain *domain, int level, cloog_int_t *n,
1076
*lb = cloog_constraint_from_isl_constraint(ccu.c);
1078
+ isl_val_to_cloog_int(ccu.n, n);
1079
+ /* Note: we have to free ccu.n and not v because v has been
1080
+ * freed and replaced in ccu during isl_set_foreach_basic_set
1082
+ isl_val_free(ccu.n);
1083
return ccu.can_unroll;
1086
@@ -1904,6 +1998,7 @@ CloogDomain *cloog_domain_fixed_offset(CloogDomain *domain,
1089
isl_set *set = isl_set_from_cloog_domain(domain);
1090
+ isl_ctx *ctx = isl_set_get_ctx(set);
1094
@@ -1911,7 +2006,7 @@ CloogDomain *cloog_domain_fixed_offset(CloogDomain *domain,
1095
aff = isl_constraint_get_bound(c, isl_dim_set, level - 1);
1096
aff = isl_aff_ceil(aff);
1097
aff = isl_aff_add_coefficient_si(aff, isl_dim_in, level - 1, -1);
1098
- aff = isl_aff_add_constant(aff, offset);
1099
+ aff = isl_aff_add_constant_val(aff, cloog_int_to_isl_val(ctx, offset));
1100
eq = isl_equality_from_aff(aff);
1101
set = isl_set_add_constraint(set, eq);
added
removed
debian/patches/cloog-isl-patch-2.diff
