Bug Summary

File:polly/lib/External/isl/isl_range.c
Warning:line 411, column 2
Assigned value is garbage or undefined

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name isl_range.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/build-llvm/tools/polly/lib/External -I /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/polly/lib/External -I /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/polly/lib/External/pet/include -I /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/polly/lib/External/ppcg/include -I /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/polly/lib/External/ppcg/imath -I /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/build-llvm/tools/polly/lib/External/ppcg -I /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/polly/lib/External/isl -I /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/polly/lib/External/isl/include -I /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/polly/lib/External/isl/imath -I /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/build-llvm/tools/polly/lib/External/isl -I /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/build-llvm/tools/polly/include -I /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/build-llvm/tools/polly/lib/External/isl/include -I /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/polly/include -I /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/build-llvm/include -I /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/llvm/include -U NDEBUG -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=gnu99 -fconst-strings -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/build-llvm/tools/polly/lib/External -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da=. -ferror-limit 19 -fmessage-length 0 -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2020-01-02-185133-36554-1 -x c /build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/polly/lib/External/isl/isl_range.c
1#include <isl_ctx_private.h>
2#include <isl/val.h>
3#include <isl_constraint_private.h>
4#include <isl/set.h>
5#include <isl_polynomial_private.h>
6#include <isl_morph.h>
7#include <isl_range.h>
8
9struct range_data {
10 struct isl_bound *bound;
11 int *signs;
12 int sign;
13 int test_monotonicity;
14 int monotonicity;
15 int tight;
16 isl_qpolynomial *poly;
17 isl_pw_qpolynomial_fold *pwf;
18 isl_pw_qpolynomial_fold *pwf_tight;
19};
20
21static isl_stat propagate_on_domain(__isl_take isl_basic_set *bset,
22 __isl_take isl_qpolynomial *poly, struct range_data *data);
23
24/* Check whether the polynomial "poly" has sign "sign" over "bset",
25 * i.e., if sign == 1, check that the lower bound on the polynomial
26 * is non-negative and if sign == -1, check that the upper bound on
27 * the polynomial is non-positive.
28 */
29static int has_sign(__isl_keep isl_basic_set *bset,
30 __isl_keep isl_qpolynomial *poly, int sign, int *signs)
31{
32 struct range_data data_m;
33 unsigned nparam;
34 isl_space *dim;
35 isl_val *opt;
36 int r;
37 enum isl_fold type;
38
39 nparam = isl_basic_set_dim(bset, isl_dim_param);
40
41 bset = isl_basic_set_copy(bset);
42 poly = isl_qpolynomial_copy(poly);
43
44 bset = isl_basic_set_move_dims(bset, isl_dim_set, 0,
45 isl_dim_param, 0, nparam);
46 poly = isl_qpolynomial_move_dims(poly, isl_dim_in, 0,
47 isl_dim_param, 0, nparam);
48
49 dim = isl_qpolynomial_get_space(poly);
50 dim = isl_space_params(dim);
51 dim = isl_space_from_domain(dim);
52 dim = isl_space_add_dims(dim, isl_dim_out, 1);
53
54 data_m.test_monotonicity = 0;
55 data_m.signs = signs;
56 data_m.sign = -sign;
57 type = data_m.sign
17.1
Field 'sign' is < 0
 < 0 ? isl_fold_min : isl_fold_max;
18
←
'?' condition is true
→
58 data_m.pwf = isl_pw_qpolynomial_fold_zero(dim, type);
59 data_m.tight = 0;
60 data_m.pwf_tight = NULL((void*)0);
61
62 if (propagate_on_domain(bset, poly, &data_m) < 0)
19
←
Calling 'propagate_on_domain'
→
63 goto error;
64
65 if (sign > 0)
66 opt = isl_pw_qpolynomial_fold_min(data_m.pwf);
67 else
68 opt = isl_pw_qpolynomial_fold_max(data_m.pwf);
69
70 if (!opt)
71 r = -1;
72 else if (isl_val_is_nan(opt) ||
73 isl_val_is_infty(opt) ||
74 isl_val_is_neginfty(opt))
75 r = 0;
76 else
77 r = sign * isl_val_sgn(opt) >= 0;
78
79 isl_val_free(opt);
80
81 return r;
82error:
83 isl_pw_qpolynomial_fold_free(data_m.pwf);
84 return -1;
85}
86
87/* Return 1 if poly is monotonically increasing in the last set variable,
88 * -1 if poly is monotonically decreasing in the last set variable,
89 * 0 if no conclusion,
90 * -2 on error.
91 *
92 * We simply check the sign of p(x+1)-p(x)
93 */
94static int monotonicity(__isl_keep isl_basic_set *bset,
95 __isl_keep isl_qpolynomial *poly, struct range_data *data)
96{
97 isl_ctx *ctx;
98 isl_space *dim;
99 isl_qpolynomial *sub = NULL((void*)0);
100 isl_qpolynomial *diff = NULL((void*)0);
101 int result = 0;
102 int s;
103 unsigned nvar;
104
105 ctx = isl_qpolynomial_get_ctx(poly);
106 dim = isl_qpolynomial_get_domain_space(poly);
107
108 nvar = isl_basic_set_dim(bset, isl_dim_set);
109
110 sub = isl_qpolynomial_var_on_domain(isl_space_copy(dim), isl_dim_set, nvar - 1);
111 sub = isl_qpolynomial_add(sub,
112 isl_qpolynomial_rat_cst_on_domain(dim, ctx->one, ctx->one));
113
114 diff = isl_qpolynomial_substitute(isl_qpolynomial_copy(poly),
115 isl_dim_in, nvar - 1, 1, &sub);
116 diff = isl_qpolynomial_sub(diff, isl_qpolynomial_copy(poly));
117
118 s = has_sign(bset, diff, 1, data->signs);
17
←
Calling 'has_sign'
→
119 if (s < 0)
120 goto error;
121 if (s)
122 result = 1;
123 else {
124 s = has_sign(bset, diff, -1, data->signs);
125 if (s < 0)
126 goto error;
127 if (s)
128 result = -1;
129 }
130
131 isl_qpolynomial_free(diff);
132 isl_qpolynomial_free(sub);
133
134 return result;
135error:
136 isl_qpolynomial_free(diff);
137 isl_qpolynomial_free(sub);
138 return -2;
139}
140
141/* Return a positive ("sign" > 0) or negative ("sign" < 0) infinite polynomial
142 * with domain space "space".
143 */
144static __isl_give isl_qpolynomial *signed_infty(__isl_take isl_space *space,
145 int sign)
146{
147 if (sign > 0)
148 return isl_qpolynomial_infty_on_domain(space);
149 else
150 return isl_qpolynomial_neginfty_on_domain(space);
151}
152
153static __isl_give isl_qpolynomial *bound2poly(__isl_take isl_constraint *bound,
154 __isl_take isl_space *space, unsigned pos, int sign)
155{
156 if (!bound)
157 return signed_infty(space, sign);
158 isl_space_free(space);
159 return isl_qpolynomial_from_constraint(bound, isl_dim_set, pos);
160}
161
162static int bound_is_integer(__isl_take isl_constraint *bound, unsigned pos)
163{
164 isl_int c;
165 int is_int;
166
167 if (!bound)
168 return 1;
169
170 isl_int_init(c)isl_sioimath_init((c));
171 isl_constraint_get_coefficient(bound, isl_dim_set, pos, &c);
172 is_int = isl_int_is_one(c)(isl_sioimath_cmp_si(*(c), 1) == 0) || isl_int_is_negone(c)(isl_sioimath_cmp_si(*(c), -1) == 0);
173 isl_int_clear(c)isl_sioimath_clear((c));
174
175 return is_int;
176}
177
178struct isl_fixed_sign_data {
179 int *signs;
180 int sign;
181 isl_qpolynomial *poly;
182};
183
184/* Add term "term" to data->poly if it has sign data->sign.
185 * The sign is determined based on the signs of the parameters
186 * and variables in data->signs. The integer divisions, if
187 * any, are assumed to be non-negative.
188 */
189static isl_stat collect_fixed_sign_terms(__isl_take isl_term *term, void *user)
190{
191 struct isl_fixed_sign_data *data = (struct isl_fixed_sign_data *)user;
192 isl_int n;
193 int i;
194 int sign;
195 unsigned nparam;
196 unsigned nvar;
197
198 if (!term)
199 return isl_stat_error;
200
201 nparam = isl_term_dim(term, isl_dim_param);
202 nvar = isl_term_dim(term, isl_dim_set);
203
204 isl_int_init(n)isl_sioimath_init((n));
205
206 isl_term_get_num(term, &n);
207
208 sign = isl_int_sgn(n)isl_sioimath_sgn(*(n));
209 for (i = 0; i < nparam; ++i) {
210 if (data->signs[i] > 0)
211 continue;
212 if (isl_term_get_exp(term, isl_dim_param, i) % 2)
213 sign = -sign;
214 }
215 for (i = 0; i < nvar; ++i) {
216 if (data->signs[nparam + i] > 0)
217 continue;
218 if (isl_term_get_exp(term, isl_dim_set, i) % 2)
219 sign = -sign;
220 }
221
222 if (sign == data->sign) {
223 isl_qpolynomial *t = isl_qpolynomial_from_term(term);
224
225 data->poly = isl_qpolynomial_add(data->poly, t);
226 } else
227 isl_term_free(term);
228
229 isl_int_clear(n)isl_sioimath_clear((n));
230
231 return isl_stat_ok;
232}
233
234/* Construct and return a polynomial that consists of the terms
235 * in "poly" that have sign "sign". The integer divisions, if
236 * any, are assumed to be non-negative.
237 */
238__isl_give isl_qpolynomial *isl_qpolynomial_terms_of_sign(
239 __isl_keep isl_qpolynomial *poly, int *signs, int sign)
240{
241 isl_space *space;
242 struct isl_fixed_sign_data data = { signs, sign };
243
244 space = isl_qpolynomial_get_domain_space(poly);
245 data.poly = isl_qpolynomial_zero_on_domain(space);
246
247 if (isl_qpolynomial_foreach_term(poly, collect_fixed_sign_terms, &data) < 0)
248 goto error;
249
250 return data.poly;
251error:
252 isl_qpolynomial_free(data.poly);
253 return NULL((void*)0);
254}
255
256/* Helper function to add a guarded polynomial to either pwf_tight or pwf,
257 * depending on whether the result has been determined to be tight.
258 */
259static isl_stat add_guarded_poly(__isl_take isl_basic_set *bset,
260 __isl_take isl_qpolynomial *poly, struct range_data *data)
261{
262 enum isl_fold type = data->sign < 0 ? isl_fold_min : isl_fold_max;
263 isl_set *set;
264 isl_qpolynomial_fold *fold;
265 isl_pw_qpolynomial_fold *pwf;
266
267 bset = isl_basic_set_params(bset);
268 poly = isl_qpolynomial_project_domain_on_params(poly);
269
270 fold = isl_qpolynomial_fold_alloc(type, poly);
271 set = isl_set_from_basic_set(bset);
272 pwf = isl_pw_qpolynomial_fold_alloc(type, set, fold);
273 if (data->tight)
274 data->pwf_tight = isl_pw_qpolynomial_fold_fold(
275 data->pwf_tight, pwf);
276 else
277 data->pwf = isl_pw_qpolynomial_fold_fold(data->pwf, pwf);
278
279 return isl_stat_ok;
280}
281
282/* Plug in "sub" for the variable at position "pos" in "poly".
283 *
284 * If "sub" is an infinite polynomial and if the variable actually
285 * appears in "poly", then calling isl_qpolynomial_substitute
286 * to perform the substitution may result in a NaN result.
287 * In such cases, return positive or negative infinity instead,
288 * depending on whether an upper bound or a lower bound is being computed,
289 * and mark the result as not being tight.
290 */
291static __isl_give isl_qpolynomial *plug_in_at_pos(
292 __isl_take isl_qpolynomial *poly, int pos,
293 __isl_take isl_qpolynomial *sub, struct range_data *data)
294{
295 isl_bool involves, infty;
296
297 involves = isl_qpolynomial_involves_dims(poly, isl_dim_in, pos, 1);
298 if (involves < 0)
299 goto error;
300 if (!involves) {
301 isl_qpolynomial_free(sub);
302 return poly;
303 }
304
305 infty = isl_qpolynomial_is_infty(sub);
306 if (infty >= 0 && !infty)
307 infty = isl_qpolynomial_is_neginfty(sub);
308 if (infty < 0)
309 goto error;
310 if (infty) {
311 isl_space *space = isl_qpolynomial_get_domain_space(poly);
312 data->tight = 0;
313 isl_qpolynomial_free(poly);
314 isl_qpolynomial_free(sub);
315 return signed_infty(space, data->sign);
316 }
317
318 poly = isl_qpolynomial_substitute(poly, isl_dim_in, pos, 1, &sub);
319 isl_qpolynomial_free(sub);
320
321 return poly;
322error:
323 isl_qpolynomial_free(poly);
324 isl_qpolynomial_free(sub);
325 return NULL((void*)0);
326}
327
328/* Given a lower and upper bound on the final variable and constraints
329 * on the remaining variables where these bounds are active,
330 * eliminate the variable from data->poly based on these bounds.
331 * If the polynomial has been determined to be monotonic
332 * in the variable, then simply plug in the appropriate bound.
333 * If the current polynomial is tight and if this bound is integer,
334 * then the result is still tight. In all other cases, the results
335 * may not be tight.
336 * Otherwise, plug in the largest bound (in absolute value) in
337 * the positive terms (if an upper bound is wanted) or the negative terms
338 * (if a lower bounded is wanted) and the other bound in the other terms.
339 *
340 * If all variables have been eliminated, then record the result.
341 * Ohterwise, recurse on the next variable.
342 */
343static isl_stat propagate_on_bound_pair(__isl_take isl_constraint *lower,
344 __isl_take isl_constraint *upper, __isl_take isl_basic_set *bset,
345 void *user)
346{
347 struct range_data *data = (struct range_data *)user;
348 int save_tight = data->tight;
349 isl_qpolynomial *poly;
350 isl_stat r;
351 unsigned nvar;
352
353 nvar = isl_basic_set_dim(bset, isl_dim_set);
354
355 if (data->monotonicity) {
356 isl_qpolynomial *sub;
357 isl_space *dim = isl_qpolynomial_get_domain_space(data->poly);
358 if (data->monotonicity * data->sign > 0) {
359 if (data->tight)
360 data->tight = bound_is_integer(upper, nvar);
361 sub = bound2poly(upper, dim, nvar, 1);
362 isl_constraint_free(lower);
363 } else {
364 if (data->tight)
365 data->tight = bound_is_integer(lower, nvar);
366 sub = bound2poly(lower, dim, nvar, -1);
367 isl_constraint_free(upper);
368 }
369 poly = isl_qpolynomial_copy(data->poly);
370 poly = plug_in_at_pos(poly, nvar, sub, data);
371 poly = isl_qpolynomial_drop_dims(poly, isl_dim_in, nvar, 1);
372 } else {
373 isl_qpolynomial *l, *u;
374 isl_qpolynomial *pos, *neg;
375 isl_space *dim = isl_qpolynomial_get_domain_space(data->poly);
376 unsigned nparam = isl_basic_set_dim(bset, isl_dim_param);
377 int sign = data->sign * data->signs[nparam + nvar];
378
379 data->tight = 0;
380
381 u = bound2poly(upper, isl_space_copy(dim), nvar, 1);
382 l = bound2poly(lower, dim, nvar, -1);
383
384 pos = isl_qpolynomial_terms_of_sign(data->poly, data->signs, sign);
385 neg = isl_qpolynomial_terms_of_sign(data->poly, data->signs, -sign);
386
387 pos = plug_in_at_pos(pos, nvar, u, data);
388 neg = plug_in_at_pos(neg, nvar, l, data);
389
390 poly = isl_qpolynomial_add(pos, neg);
391 poly = isl_qpolynomial_drop_dims(poly, isl_dim_in, nvar, 1);
392 }
393
394 if (isl_basic_set_dim(bset, isl_dim_set) == 0)
395 r = add_guarded_poly(bset, poly, data);
396 else
397 r = propagate_on_domain(bset, poly, data);
398
399 data->tight = save_tight;
400
401 return r;
402}
403
404/* Recursively perform range propagation on the polynomial "poly"
405 * defined over the basic set "bset" and collect the results in "data".
406 */
407static isl_stat propagate_on_domain(__isl_take isl_basic_set *bset,
408 __isl_take isl_qpolynomial *poly, struct range_data *data)
409{
410 isl_ctx *ctx;
411 isl_qpolynomial *save_poly = data->poly;
20
←
Assigned value is garbage or undefined
412 int save_monotonicity = data->monotonicity;
413 unsigned d;
414
415 if (!bset || !poly)
6
←
Assuming 'bset' is non-null
→
7
←
Assuming 'poly' is non-null
→
8
←
Taking false branch
→
416 goto error;
417
418 ctx = isl_basic_set_get_ctx(bset);
419 d = isl_basic_set_dim(bset, isl_dim_set);
420 isl_assert(ctx, d >= 1, goto error)do { if (d >= 1) break; do { isl_handle_error(ctx, isl_error_unknown
, "Assertion \"" "d >= 1" "\" failed", "/build/llvm-toolchain-snapshot-10~+20200102111109+a2976c490da/polly/lib/External/isl/isl_range.c"
, 420); goto error; } while (0); } while (0);
9
←
Assuming 'd' is >= 1
→
10
←
Taking true branch
→
11
←
 Execution continues on line 422
→
421
422 if (isl_qpolynomial_is_cst(poly, NULL((void*)0), NULL((void*)0))) {
12
←
Assuming the condition is false
→
13
←
Taking false branch
→
423 bset = isl_basic_set_project_out(bset, isl_dim_set, 0, d);
424 poly = isl_qpolynomial_drop_dims(poly, isl_dim_in, 0, d);
425 return add_guarded_poly(bset, poly, data);
426 }
427
428 if (data->test_monotonicity)
14
←
Assuming field 'test_monotonicity' is not equal to 0
→
15
←
Taking true branch
→
429 data->monotonicity = monotonicity(bset, poly, data);
16
←
Calling 'monotonicity'
→
430 else
431 data->monotonicity = 0;
432 if (data->monotonicity < -1)
433 goto error;
434
435 data->poly = poly;
436 if (isl_basic_set_foreach_bound_pair(bset, isl_dim_set, d - 1,
437 &propagate_on_bound_pair, data) < 0)
438 goto error;
439
440 isl_basic_set_free(bset);
441 isl_qpolynomial_free(poly);
442 data->monotonicity = save_monotonicity;
443 data->poly = save_poly;
444
445 return isl_stat_ok;
446error:
447 isl_basic_set_free(bset);
448 isl_qpolynomial_free(poly);
449 data->monotonicity = save_monotonicity;
450 data->poly = save_poly;
451 return isl_stat_error;
452}
453
454static isl_stat basic_guarded_poly_bound(__isl_take isl_basic_set *bset,
455 void *user)
456{
457 struct range_data *data = (struct range_data *)user;
458 isl_ctx *ctx;
459 unsigned nparam = isl_basic_set_dim(bset, isl_dim_param);
460 unsigned dim = isl_basic_set_dim(bset, isl_dim_set);
461 isl_stat r;
462
463 data->signs = NULL((void*)0);
464
465 ctx = isl_basic_set_get_ctx(bset);
466 data->signs = isl_alloc_array(ctx, int,((int *)isl_malloc_or_die(ctx, (isl_basic_set_dim(bset, isl_dim_all
))*sizeof(int)))
467 isl_basic_set_dim(bset, isl_dim_all))((int *)isl_malloc_or_die(ctx, (isl_basic_set_dim(bset, isl_dim_all
))*sizeof(int)));
468
469 if (isl_basic_set_dims_get_sign(bset, isl_dim_set, 0, dim,
1
Assuming the condition is false
→
2
←
Taking false branch
→
470 data->signs + nparam) < 0)
471 goto error;
472 if (isl_basic_set_dims_get_sign(bset, isl_dim_param, 0, nparam,
3
←
Assuming the condition is false
→
4
←
Taking false branch
→
473 data->signs) < 0)
474 goto error;
475
476 r = propagate_on_domain(bset, isl_qpolynomial_copy(data->poly), data);
5
←
Calling 'propagate_on_domain'
→
477
478 free(data->signs);
479
480 return r;
481error:
482 free(data->signs);
483 isl_basic_set_free(bset);
484 return isl_stat_error;
485}
486
487static isl_stat qpolynomial_bound_on_domain_range(
488 __isl_take isl_basic_set *bset, __isl_take isl_qpolynomial *poly,
489 struct range_data *data)
490{
491 unsigned nparam = isl_basic_set_dim(bset, isl_dim_param);
492 unsigned nvar = isl_basic_set_dim(bset, isl_dim_set);
493 isl_set *set = NULL((void*)0);
494
495 if (!bset)
496 goto error;
497
498 if (nvar == 0)
499 return add_guarded_poly(bset, poly, data);
500
501 set = isl_set_from_basic_set(bset);
502 set = isl_set_split_dims(set, isl_dim_param, 0, nparam);
503 set = isl_set_split_dims(set, isl_dim_set, 0, nvar);
504
505 data->poly = poly;
506
507 data->test_monotonicity = 1;
508 if (isl_set_foreach_basic_set(set, &basic_guarded_poly_bound, data) < 0)
509 goto error;
510
511 isl_set_free(set);
512 isl_qpolynomial_free(poly);
513
514 return isl_stat_ok;
515error:
516 isl_set_free(set);
517 isl_qpolynomial_free(poly);
518 return isl_stat_error;
519}
520
521isl_stat isl_qpolynomial_bound_on_domain_range(__isl_take isl_basic_set *bset,
522 __isl_take isl_qpolynomial *poly, struct isl_bound *bound)
523{
524 struct range_data data;
525 isl_stat r;
526
527 data.pwf = bound->pwf;
528 data.pwf_tight = bound->pwf_tight;
529 data.tight = bound->check_tight;
530 if (bound->type == isl_fold_min)
531 data.sign = -1;
532 else
533 data.sign = 1;
534
535 r = qpolynomial_bound_on_domain_range(bset, poly, &data);
536
537 bound->pwf = data.pwf;
538 bound->pwf_tight = data.pwf_tight;
539
540 return r;
541}