Bug Summary

File:build/llvm-toolchain-snapshot-16~++20220929111209+ac2e2d659819/polly/lib/External/isl/isl_test.c
Warning:line 10879, column 2
Value stored to 'argc' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name isl_test.c -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 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-16~++20220929111209+ac2e2d659819/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-16/lib/clang/16.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/polly/lib/External -I /build/llvm-toolchain-snapshot-16~++20220929111209+ac2e2d659819/polly/lib/External -I /build/llvm-toolchain-snapshot-16~++20220929111209+ac2e2d659819/polly/lib/External/isl -I /build/llvm-toolchain-snapshot-16~++20220929111209+ac2e2d659819/polly/lib/External/isl/include -I /build/llvm-toolchain-snapshot-16~++20220929111209+ac2e2d659819/polly/lib/External/isl/imath -I tools/polly/lib/External/isl -I tools/polly/include -I /build/llvm-toolchain-snapshot-16~++20220929111209+ac2e2d659819/polly/lib/External/pet/include -I tools/polly/lib/External/isl/include -I /build/llvm-toolchain-snapshot-16~++20220929111209+ac2e2d659819/polly/include -I include -I /build/llvm-toolchain-snapshot-16~++20220929111209+ac2e2d659819/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/llvm-16/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-16~++20220929111209+ac2e2d659819/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/llvm-toolchain-snapshot-16~++20220929111209+ac2e2d659819/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-16~++20220929111209+ac2e2d659819/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-16~++20220929111209+ac2e2d659819/= -O2 -Wno-unused-command-line-argument -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-16~++20220929111209+ac2e2d659819/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-16~++20220929111209+ac2e2d659819/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-16~++20220929111209+ac2e2d659819/= -ferror-limit 19 -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-09-29-125212-15910-1 -x c /build/llvm-toolchain-snapshot-16~++20220929111209+ac2e2d659819/polly/lib/External/isl/isl_test.c
1/*
2 * Copyright 2008-2009 Katholieke Universiteit Leuven
3 * Copyright 2010 INRIA Saclay
4 * Copyright 2012-2013 Ecole Normale Superieure
5 * Copyright 2014 INRIA Rocquencourt
6 *
7 * Use of this software is governed by the MIT license
8 *
9 * Written by Sven Verdoolaege, K.U.Leuven, Departement
10 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
11 * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
12 * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France
13 * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
14 * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
15 * B.P. 105 - 78153 Le Chesnay, France
16 */
17
18#include <assert.h>
19#include <stdio.h>
20#include <limits.h>
21#include <isl_ctx_private.h>
22#include <isl_map_private.h>
23#include <isl_aff_private.h>
24#include <isl_space_private.h>
25#include <isl/id.h>
26#include <isl/set.h>
27#include <isl/flow.h>
28#include <isl_constraint_private.h>
29#include <isl/polynomial.h>
30#include <isl/union_set.h>
31#include <isl/union_map.h>
32#include <isl_factorization.h>
33#include <isl/schedule.h>
34#include <isl/schedule_node.h>
35#include <isl_options_private.h>
36#include <isl_vertices_private.h>
37#include <isl/ast_build.h>
38#include <isl/val.h>
39#include <isl/ilp.h>
40#include <isl_ast_build_expr.h>
41#include <isl/options.h>
42
43#include "isl_srcdir.c"
44
45#define ARRAY_SIZE(array)(sizeof(array)/sizeof(*array)) (sizeof(array)/sizeof(*array))
46
47static char *get_filename(isl_ctx *ctx, const char *name, const char *suffix) {
48 char *filename;
49 int length;
50 char *pattern = "%s/test_inputs/%s.%s";
51
52 length = strlen(pattern) - 6 + strlen(srcdir) + strlen(name)
53 + strlen(suffix) + 1;
54 filename = isl_alloc_array(ctx, char, length)((char *)isl_malloc_or_die(ctx, (length)*sizeof(char)));
55
56 if (!filename)
57 return NULL((void*)0);
58
59 sprintf(filename, pattern, srcdir, name, suffix)__builtin___sprintf_chk (filename, 2 - 1, __builtin_object_size
(filename, 2 > 1), pattern, srcdir, name, suffix)
;
60
61 return filename;
62}
63
64void test_parse_map(isl_ctx *ctx, const char *str)
65{
66 isl_map *map;
67
68 map = isl_map_read_from_str(ctx, str);
69 assert(map)((void) sizeof ((map) ? 1 : 0), __extension__ ({ if (map) ; else
__assert_fail ("map", "polly/lib/External/isl/isl_test.c", 69
, __extension__ __PRETTY_FUNCTION__); }))
;
70 isl_map_free(map);
71}
72
73int test_parse_map_equal(isl_ctx *ctx, const char *str, const char *str2)
74{
75 isl_map *map, *map2;
76 int equal;
77
78 map = isl_map_read_from_str(ctx, str);
79 map2 = isl_map_read_from_str(ctx, str2);
80 equal = isl_map_is_equal(map, map2);
81 isl_map_free(map);
82 isl_map_free(map2);
83
84 if (equal < 0)
85 return -1;
86 if (!equal)
87 isl_die(ctx, isl_error_unknown, "maps not equal",do { isl_handle_error(ctx, isl_error_unknown, "maps not equal"
, "polly/lib/External/isl/isl_test.c", 88); return -1; } while
(0)
88 return -1)do { isl_handle_error(ctx, isl_error_unknown, "maps not equal"
, "polly/lib/External/isl/isl_test.c", 88); return -1; } while
(0)
;
89
90 return 0;
91}
92
93void test_parse_pwqp(isl_ctx *ctx, const char *str)
94{
95 isl_pw_qpolynomial *pwqp;
96
97 pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
98 assert(pwqp)((void) sizeof ((pwqp) ? 1 : 0), __extension__ ({ if (pwqp) ;
else __assert_fail ("pwqp", "polly/lib/External/isl/isl_test.c"
, 98, __extension__ __PRETTY_FUNCTION__); }))
;
99 isl_pw_qpolynomial_free(pwqp);
100}
101
102static void test_parse_pwaff(isl_ctx *ctx, const char *str)
103{
104 isl_pw_aff *pwaff;
105
106 pwaff = isl_pw_aff_read_from_str(ctx, str);
107 assert(pwaff)((void) sizeof ((pwaff) ? 1 : 0), __extension__ ({ if (pwaff)
; else __assert_fail ("pwaff", "polly/lib/External/isl/isl_test.c"
, 107, __extension__ __PRETTY_FUNCTION__); }))
;
108 isl_pw_aff_free(pwaff);
109}
110
111/* Check that we can read an isl_multi_val from "str" without errors.
112 */
113static int test_parse_multi_val(isl_ctx *ctx, const char *str)
114{
115 isl_multi_val *mv;
116
117 mv = isl_multi_val_read_from_str(ctx, str);
118 isl_multi_val_free(mv);
119
120 return mv ? 0 : -1;
121}
122
123/* String descriptions of multi piecewise affine expressions
124 * that are used for testing printing and parsing.
125 */
126static const char *reparse_multi_pw_aff_tests[] = {
127 "{ A[x, y] -> [] : x + y >= 0 }",
128 "{ A[x, y] -> B[] : x + y >= 0 }",
129 "{ A[x, y] -> [x] : x + y >= 0 }",
130 "[N] -> { A[x, y] -> [x] : x + y <= N }",
131 "{ A[x, y] -> [x, y] : x + y >= 0 }",
132 "{ A[x, y] -> [(x : x >= 0), (y : y >= 0)] : x + y >= 0 }",
133 "[N] -> { [] : N >= 0 }",
134 "[N] -> { [] : N >= 0 }",
135 "[N] -> { [N] : N >= 0 }",
136 "[N] -> { [N, N + 1] : N >= 0 }",
137 "[N, M] -> { [(N : N >= 0), (M : M >= 0)] : N + M >= 0 }",
138 "{ [a] -> [b = a] }",
139 "{ [a] -> [b = a] : a >= 0 }",
140};
141
142#undef BASEunion_pw_aff
143#define BASEunion_pw_aff multi_pw_aff
144
145#include "check_reparse_templ.c"
146#include "check_reparse_test_templ.c"
147
148/* String descriptions that cannot be parsed
149 * as multi piecewise affine expressions.
150 */
151static const char *parse_multi_pw_aff_fail_tests[] = {
152 "{ [a] -> [b] : b = a }",
153 "{ [a] -> [b = a] : b >= 0 }",
154};
155
156#include "check_parse_fail_test_templ.c"
157
158/* String descriptions of piecewise multi affine expressions
159 * that are used for testing printing and parsing.
160 */
161static const char *reparse_pw_multi_aff_tests[] = {
162 "{ [x] -> [x] }",
163 "{ [x] -> [x % 4] }",
164 "{ [x] -> [x % 4] : x mod 3 = 1 }",
165 "{ [x, x] -> [x % 4] }",
166 "{ [x, x + 1] -> [x % 4] : x mod 3 = 1 }",
167 "{ [x, x mod 2] -> [x % 4] }",
168};
169
170#undef BASEunion_pw_aff
171#define BASEunion_pw_aff pw_multi_aff
172
173#include "check_reparse_templ.c"
174#include "check_reparse_test_templ.c"
175
176/* Test parsing of piecewise multi affine expressions by printing
177 * the expressions and checking that parsing the output results
178 * in the same expression.
179 * Do this for an expression converted from a map with an output
180 * dimension name that is equal to an automatically generated name, and
181 * a set of expressions parsed from strings.
182 */
183static isl_stat test_parse_pma(isl_ctx *ctx)
184{
185 isl_map *map;
186 isl_pw_multi_aff *pma;
187
188 map = isl_map_read_from_str(ctx, "{ [a, a] -> [i1 = a + 1] }");
189 pma = isl_pw_multi_aff_from_map(map);
190 if (check_reparse_pw_multi_aff(ctx, pma) < 0)
191 return isl_stat_error;
192
193 if (check_reparse_pw_multi_aff_tests(ctx) < 0)
194 return isl_stat_error;
195
196 return isl_stat_ok;
197}
198
199/* String descriptions that cannot be parsed
200 * as union piecewise multi affine expressions.
201 */
202static const char *parse_union_pw_multi_aff_fail_tests[] = {
203 "{ [a] -> [b] : b = a }",
204 "{ [a] -> [b = a] : b >= 0 }",
205};
206
207#undef BASEunion_pw_aff
208#define BASEunion_pw_aff union_pw_multi_aff
209
210#include "check_parse_fail_test_templ.c"
211
212/* Test parsing of union piecewise multi affine expressions.
213 *
214 * In particular, check some cases where parsing is supposed to fail.
215 */
216static isl_stat test_parse_upma(isl_ctx *ctx)
217{
218 if (check_parse_union_pw_multi_aff_fail_tests(ctx) < 0)
219 return isl_stat_error;
220
221 return isl_stat_ok;
222}
223
224/* Test parsing of multi piecewise affine expressions by printing
225 * the expressions and checking that parsing the output results
226 * in the same expression.
227 * Do this for a couple of manually constructed expressions,
228 * an expression converted from a map with an output dimension name
229 * that is equal to an automatically generated name, and
230 * a set of expressions parsed from strings.
231 *
232 * Additionally, check some cases where parsing is supposed to fail.
233 */
234static int test_parse_mpa(isl_ctx *ctx)
235{
236 isl_space *space;
237 isl_setisl_map *dom;
238 isl_map *map;
239 isl_pw_multi_aff *pma;
240 isl_multi_pw_aff *mpa;
241 isl_stat r;
242
243 space = isl_space_set_alloc(ctx, 0, 0);
244 space = isl_space_set_tuple_name(space, isl_dim_set, "A");
245 mpa = isl_multi_pw_aff_zero(space);
246 r = check_reparse_multi_pw_aff(ctx, mpa);
247 if (r < 0)
248 return -1;
249
250 space = isl_space_set_alloc(ctx, 1, 0);
251 space = isl_space_set_dim_name(space, isl_dim_param, 0, "N");
252 space = isl_space_set_tuple_name(space, isl_dim_set, "A");
253 dom = isl_set_universe(isl_space_params(isl_space_copy(space)));
254 dom = isl_set_lower_bound_si(dom, isl_dim_param, 0, 5);
255 mpa = isl_multi_pw_aff_zero(space);
256 mpa = isl_multi_pw_aff_intersect_domain(mpa, dom);
257 r = check_reparse_multi_pw_aff(ctx, mpa);
258 if (r < 0)
259 return -1;
260
261 map = isl_map_read_from_str(ctx, "{ [a, a] -> [i1 = a + 1] }");
262 pma = isl_pw_multi_aff_from_map(map);
263 mpa = isl_multi_pw_aff_from_pw_multi_aff(pma);
264 if (check_reparse_multi_pw_aff(ctx, mpa) < 0)
265 return -1;
266
267 if (check_reparse_multi_pw_aff_tests(ctx) < 0)
268 return -1;
269 if (check_parse_multi_pw_aff_fail_tests(ctx) < 0)
270 return -1;
271
272 return 0;
273}
274
275/* String descriptions of multi union piecewise affine expressions
276 * that are used for testing printing and parsing.
277 */
278static const char *reparse_multi_union_pw_aff_tests[] = {
279 "[]",
280 "A[]",
281 "A[B[] -> C[]]",
282 "(A[] : { S[x] : x > 0; T[y] : y >= 0 })",
283 "(A[] : { })",
284 "[N] -> (A[] : { })",
285 "[N] -> (A[] : { : N >= 0 })",
286 "[N] -> (A[] : { S[x] : x > N; T[y] : y >= 0 })",
287 "(A[] : [N] -> { S[x] : x > N; T[y] : y >= 0 })",
288 "A[{ S[x] -> [x + 1]; T[x] -> [x] }]",
289 "(A[{ S[x] -> [x + 1]; T[x] -> [x] }] : "
290 "{ S[x] : x > 0; T[y] : y >= 0 })",
291};
292
293#undef BASEunion_pw_aff
294#define BASEunion_pw_aff multi_union_pw_aff
295
296#include "check_reparse_templ.c"
297#include "check_reparse_test_templ.c"
298
299/* Test parsing of multi union piecewise affine expressions by printing
300 * the expressions and checking that parsing the output results
301 * in the same expression.
302 * Do this for a couple of manually constructed expressions and
303 * a set of expressions parsed from strings.
304 */
305static int test_parse_mupa(isl_ctx *ctx)
306{
307 isl_space *space;
308 isl_multi_union_pw_aff *mupa;
309 isl_setisl_map *dom;
310 isl_union_set *uset;
311 isl_stat r;
312
313 space = isl_space_set_alloc(ctx, 0, 0);
314 space = isl_space_set_tuple_name(space, isl_dim_set, "A");
315 mupa = isl_multi_union_pw_aff_zero(space);
316 r = check_reparse_multi_union_pw_aff(ctx, mupa);
317 if (r < 0)
318 return -1;
319
320 space = isl_space_set_alloc(ctx, 1, 0);
321 space = isl_space_set_dim_name(space, isl_dim_param, 0, "N");
322 space = isl_space_set_tuple_name(space, isl_dim_set, "A");
323 dom = isl_set_universe(space);
324 dom = isl_set_lower_bound_si(dom, isl_dim_param, 0, 5);
325 uset = isl_union_set_from_set(dom);
326 space = isl_space_set_alloc(ctx, 1, 0);
327 space = isl_space_set_dim_name(space, isl_dim_param, 0, "N");
328 space = isl_space_set_tuple_name(space, isl_dim_set, "B");
329 mupa = isl_multi_union_pw_aff_zero(space);
330 mupa = isl_multi_union_pw_aff_intersect_domain(mupa, uset);
331 r = check_reparse_multi_union_pw_aff(ctx, mupa);
332 if (r < 0)
333 return -1;
334
335 if (check_reparse_multi_union_pw_aff_tests(ctx) < 0)
336 return -1;
337
338 return 0;
339}
340
341/* Test parsing of multi expressions.
342 */
343static int test_parse_multi(isl_ctx *ctx)
344{
345 if (test_parse_mpa(ctx) < 0)
346 return -1;
347 if (test_parse_mupa(ctx) < 0)
348 return -1;
349
350 return 0;
351}
352
353/* Pairs of binary relation representations that should represent
354 * the same binary relations.
355 */
356struct {
357 const char *map1;
358 const char *map2;
359} parse_map_equal_tests[] = {
360 { "{ [x,y] : [([x/2]+y)/3] >= 1 }",
361 "{ [x, y] : 2y >= 6 - x }" },
362 { "{ [x,y] : x <= min(y, 2*y+3) }",
363 "{ [x,y] : x <= y, 2*y + 3 }" },
364 { "{ [x,y] : x >= min(y, 2*y+3) }",
365 "{ [x, y] : (y <= x and y >= -3) or (2y <= -3 + x and y <= -4) }" },
366 { "[n] -> { [c1] : c1>=0 and c1<=floord(n-4,3) }",
367 "[n] -> { [c1] : c1 >= 0 and 3c1 <= -4 + n }" },
368 { "{ [i,j] -> [i] : i < j; [i,j] -> [j] : j <= i }",
369 "{ [i,j] -> [min(i,j)] }" },
370 { "{ [i,j] : i != j }",
371 "{ [i,j] : i < j or i > j }" },
372 { "{ [i,j] : (i+1)*2 >= j }",
373 "{ [i, j] : j <= 2 + 2i }" },
374 { "{ [i] -> [i > 0 ? 4 : 5] }",
375 "{ [i] -> [5] : i <= 0; [i] -> [4] : i >= 1 }" },
376 { "[N=2,M] -> { [i=[(M+N)/4]] }",
377 "[N, M] -> { [i] : N = 2 and 4i <= 2 + M and 4i >= -1 + M }" },
378 { "{ [x] : x >= 0 }",
379 "{ [x] : x-0 >= 0 }" },
380 { "{ [i] : ((i > 10)) }",
381 "{ [i] : i >= 11 }" },
382 { "{ [i] -> [0] }",
383 "{ [i] -> [0 * i] }" },
384 { "{ [a] -> [b] : (not false) }",
385 "{ [a] -> [b] : true }" },
386 { "{ [i] : i/2 <= 5 }",
387 "{ [i] : i <= 10 }" },
388 { "{Sym=[n] [i] : i <= n }",
389 "[n] -> { [i] : i <= n }" },
390 { "{ [*] }",
391 "{ [a] }" },
392 { "{ [i] : 2*floor(i/2) = i }",
393 "{ [i] : exists a : i = 2 a }" },
394 { "{ [a] -> [b] : a = 5 implies b = 5 }",
395 "{ [a] -> [b] : a != 5 or b = 5 }" },
396 { "{ [a] -> [a - 1 : a > 0] }",
397 "{ [a] -> [a - 1] : a > 0 }" },
398 { "{ [a] -> [a - 1 : a > 0; a : a <= 0] }",
399 "{ [a] -> [a - 1] : a > 0; [a] -> [a] : a <= 0 }" },
400 { "{ [a] -> [(a) * 2 : a >= 0; 0 : a < 0] }",
401 "{ [a] -> [2a] : a >= 0; [a] -> [0] : a < 0 }" },
402 { "{ [a] -> [(a * 2) : a >= 0; 0 : a < 0] }",
403 "{ [a] -> [2a] : a >= 0; [a] -> [0] : a < 0 }" },
404 { "{ [a] -> [(a * 2 : a >= 0); 0 : a < 0] }",
405 "{ [a] -> [2a] : a >= 0; [a] -> [0] : a < 0 }" },
406 { "{ [a] -> [(a * 2 : a >= 0; 0 : a < 0)] }",
407 "{ [a] -> [2a] : a >= 0; [a] -> [0] : a < 0 }" },
408 { "{ [a,b] -> [i,j] : a,b << i,j }",
409 "{ [a,b] -> [i,j] : a < i or (a = i and b < j) }" },
410 { "{ [a,b] -> [i,j] : a,b <<= i,j }",
411 "{ [a,b] -> [i,j] : a < i or (a = i and b <= j) }" },
412 { "{ [a,b] -> [i,j] : a,b >> i,j }",
413 "{ [a,b] -> [i,j] : a > i or (a = i and b > j) }" },
414 { "{ [a,b] -> [i,j] : a,b >>= i,j }",
415 "{ [a,b] -> [i,j] : a > i or (a = i and b >= j) }" },
416 { "{ [n] -> [i] : exists (a, b, c: 8b <= i - 32a and "
417 "8b >= -7 + i - 32 a and b >= 0 and b <= 3 and "
418 "8c < n - 32a and i < n and c >= 0 and "
419 "c <= 3 and c >= -4a) }",
420 "{ [n] -> [i] : 0 <= i < n }" },
421 { "{ [x] -> [] : exists (a, b: 0 <= a <= 1 and 0 <= b <= 3 and "
422 "2b <= x - 8a and 2b >= -1 + x - 8a) }",
423 "{ [x] -> [] : 0 <= x <= 15 }" },
424 { "{ [x] -> [x] : }",
425 "{ [x] -> [x] }" },
426 { "{ [x=4:5] -> [x + 1] }",
427 "{ [x] -> [x + 1] : 4 <= x <= 5 }" },
428 { "{ [x=4:5] -> [x + 1 : x + 1] }",
429 "{ [x=4:5] -> [x + 1] }" },
430 { "{ [x] -> [x - 1 : x + 1] }",
431 "{ [x] -> [y] : x - 1 <= y <= x + 1 }" },
432 { "{ [x=4:] -> [x + 1] }",
433 "{ [x] -> [x + 1] : 4 <= x }" },
434 { "{ [x=:5] -> [x + 1] }",
435 "{ [x] -> [x + 1] : x <= 5 }" },
436 { "{ [x=:] -> [x + 1] }",
437 "{ [x] -> [x + 1] }" },
438 { "{ [:] -> [:] }",
439 "{ [x] -> [y] }" },
440 { "{ [x, x//4] }",
441 "{ [x, floor(x/4)] }" },
442 { "{ [10//4] }",
443 "{ [2] }" },
444};
445
446int test_parse(struct isl_ctx *ctx)
447{
448 int i;
449 isl_map *map, *map2;
450 const char *str, *str2;
451
452 if (test_parse_multi_val(ctx, "{ A[B[2] -> C[5, 7]] }") < 0)
453 return -1;
454 if (test_parse_multi_val(ctx, "[n] -> { [2] }") < 0)
455 return -1;
456 if (test_parse_multi_val(ctx, "{ A[4, infty, NaN, -1/2, 2/3] }") < 0)
457 return -1;
458 if (test_parse_multi(ctx) < 0)
459 return -1;
460 if (test_parse_pma(ctx) < 0)
461 return -1;
462 if (test_parse_upma(ctx) < 0)
463 return -1;
464
465 str = "{ [i] -> [-i] }";
466 map = isl_map_read_from_str(ctx, str);
467 assert(map)((void) sizeof ((map) ? 1 : 0), __extension__ ({ if (map) ; else
__assert_fail ("map", "polly/lib/External/isl/isl_test.c", 467
, __extension__ __PRETTY_FUNCTION__); }))
;
468 isl_map_free(map);
469
470 str = "{ A[i] -> L[([i/3])] }";
471 map = isl_map_read_from_str(ctx, str);
472 assert(map)((void) sizeof ((map) ? 1 : 0), __extension__ ({ if (map) ; else
__assert_fail ("map", "polly/lib/External/isl/isl_test.c", 472
, __extension__ __PRETTY_FUNCTION__); }))
;
473 isl_map_free(map);
474
475 test_parse_map(ctx, "{[[s] -> A[i]] -> [[s+1] -> A[i]]}");
476 test_parse_map(ctx, "{ [p1, y1, y2] -> [2, y1, y2] : "
477 "p1 = 1 && (y1 <= y2 || y2 = 0) }");
478
479 for (i = 0; i < ARRAY_SIZE(parse_map_equal_tests)(sizeof(parse_map_equal_tests)/sizeof(*parse_map_equal_tests)
)
; ++i) {
480 str = parse_map_equal_tests[i].map1;
481 str2 = parse_map_equal_tests[i].map2;
482 if (test_parse_map_equal(ctx, str, str2) < 0)
483 return -1;
484 }
485
486 str = "{[new,old] -> [new+1-2*[(new+1)/2],old+1-2*[(old+1)/2]]}";
487 map = isl_map_read_from_str(ctx, str);
488 str = "{ [new, old] -> [o0, o1] : "
489 "exists (e0 = [(-1 - new + o0)/2], e1 = [(-1 - old + o1)/2]: "
490 "2e0 = -1 - new + o0 and 2e1 = -1 - old + o1 and o0 >= 0 and "
491 "o0 <= 1 and o1 >= 0 and o1 <= 1) }";
492 map2 = isl_map_read_from_str(ctx, str);
493 assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__
({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)"
, "polly/lib/External/isl/isl_test.c", 493, __extension__ __PRETTY_FUNCTION__
); }))
;
494 isl_map_free(map);
495 isl_map_free(map2);
496
497 str = "{[new,old] -> [new+1-2*[(new+1)/2],old+1-2*[(old+1)/2]]}";
498 map = isl_map_read_from_str(ctx, str);
499 str = "{[new,old] -> [(new+1)%2,(old+1)%2]}";
500 map2 = isl_map_read_from_str(ctx, str);
501 assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__
({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)"
, "polly/lib/External/isl/isl_test.c", 501, __extension__ __PRETTY_FUNCTION__
); }))
;
502 isl_map_free(map);
503 isl_map_free(map2);
504
505 test_parse_pwqp(ctx, "{ [i] -> i + [ (i + [i/3])/2 ] }");
506 test_parse_map(ctx, "{ S1[i] -> [([i/10]),i%10] : 0 <= i <= 45 }");
507 test_parse_pwaff(ctx, "{ [i] -> [i + 1] : i > 0; [a] -> [a] : a < 0 }");
508 test_parse_pwqp(ctx, "{ [x] -> ([(x)/2] * [(x)/3]) }");
509 test_parse_pwaff(ctx, "{ [] -> [(100)] }");
510
511 return 0;
512}
513
514static int test_read(isl_ctx *ctx)
515{
516 char *filename;
517 FILE *input;
518 isl_basic_setisl_basic_map *bset1, *bset2;
519 const char *str = "{[y]: Exists ( alpha : 2alpha = y)}";
520 int equal;
521
522 filename = get_filename(ctx, "set", "omega");
523 assert(filename)((void) sizeof ((filename) ? 1 : 0), __extension__ ({ if (filename
) ; else __assert_fail ("filename", "polly/lib/External/isl/isl_test.c"
, 523, __extension__ __PRETTY_FUNCTION__); }))
;
524 input = fopen(filename, "r");
525 assert(input)((void) sizeof ((input) ? 1 : 0), __extension__ ({ if (input)
; else __assert_fail ("input", "polly/lib/External/isl/isl_test.c"
, 525, __extension__ __PRETTY_FUNCTION__); }))
;
526
527 bset1 = isl_basic_set_read_from_file(ctx, input);
528 bset2 = isl_basic_set_read_from_str(ctx, str);
529
530 equal = isl_basic_set_is_equal(bset1, bset2);
531
532 isl_basic_set_free(bset1);
533 isl_basic_set_free(bset2);
534 free(filename);
535
536 fclose(input);
537
538 if (equal < 0)
539 return -1;
540 if (!equal)
541 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "read sets not equal"
, "polly/lib/External/isl/isl_test.c", 542); return -1; } while
(0)
542 "read sets not equal", return -1)do { isl_handle_error(ctx, isl_error_unknown, "read sets not equal"
, "polly/lib/External/isl/isl_test.c", 542); return -1; } while
(0)
;
543
544 return 0;
545}
546
547static int test_bounded(isl_ctx *ctx)
548{
549 isl_setisl_map *set;
550 isl_bool bounded;
551
552 set = isl_set_read_from_str(ctx, "[n] -> {[i] : 0 <= i <= n }");
553 bounded = isl_set_is_bounded(set);
554 isl_set_free(set);
555
556 if (bounded < 0)
557 return -1;
558 if (!bounded)
559 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "set not considered bounded"
, "polly/lib/External/isl/isl_test.c", 560); return -1; } while
(0)
560 "set not considered bounded", return -1)do { isl_handle_error(ctx, isl_error_unknown, "set not considered bounded"
, "polly/lib/External/isl/isl_test.c", 560); return -1; } while
(0)
;
561
562 set = isl_set_read_from_str(ctx, "{[n, i] : 0 <= i <= n }");
563 bounded = isl_set_is_bounded(set);
564 assert(!bounded)((void) sizeof ((!bounded) ? 1 : 0), __extension__ ({ if (!bounded
) ; else __assert_fail ("!bounded", "polly/lib/External/isl/isl_test.c"
, 564, __extension__ __PRETTY_FUNCTION__); }))
;
565 isl_set_free(set);
566
567 if (bounded < 0)
568 return -1;
569 if (bounded)
570 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "set considered bounded"
, "polly/lib/External/isl/isl_test.c", 571); return -1; } while
(0)
571 "set considered bounded", return -1)do { isl_handle_error(ctx, isl_error_unknown, "set considered bounded"
, "polly/lib/External/isl/isl_test.c", 571); return -1; } while
(0)
;
572
573 set = isl_set_read_from_str(ctx, "[n] -> {[i] : i <= n }");
574 bounded = isl_set_is_bounded(set);
575 isl_set_free(set);
576
577 if (bounded < 0)
578 return -1;
579 if (bounded)
580 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "set considered bounded"
, "polly/lib/External/isl/isl_test.c", 581); return -1; } while
(0)
581 "set considered bounded", return -1)do { isl_handle_error(ctx, isl_error_unknown, "set considered bounded"
, "polly/lib/External/isl/isl_test.c", 581); return -1; } while
(0)
;
582
583 return 0;
584}
585
586/* Construct the basic set { [i] : 5 <= i <= N } */
587static int test_construction_1(isl_ctx *ctx)
588{
589 isl_space *space;
590 isl_local_space *ls;
591 isl_basic_setisl_basic_map *bset;
592 isl_constraint *c;
593
594 space = isl_space_set_alloc(ctx, 1, 1);
595 bset = isl_basic_set_universe(isl_space_copy(space));
596 ls = isl_local_space_from_space(space);
597
598 c = isl_constraint_alloc_inequality(isl_local_space_copy(ls));
599 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
600 c = isl_constraint_set_coefficient_si(c, isl_dim_param, 0, 1);
601 bset = isl_basic_set_add_constraint(bset, c);
602
603 c = isl_constraint_alloc_inequality(isl_local_space_copy(ls));
604 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
605 c = isl_constraint_set_constant_si(c, -5);
606 bset = isl_basic_set_add_constraint(bset, c);
607
608 isl_local_space_free(ls);
609 isl_basic_set_free(bset);
610
611 return 0;
612}
613
614/* Construct the basic set { [x] : -100 <= x <= 100 }
615 * using isl_basic_set_{lower,upper}_bound_val and
616 * check that it is equal the same basic set parsed from a string.
617 */
618static int test_construction_2(isl_ctx *ctx)
619{
620 isl_bool equal;
621 isl_val *v;
622 isl_space *space;
623 isl_basic_setisl_basic_map *bset1, *bset2;
624
625 v = isl_val_int_from_si(ctx, 100);
626 space = isl_space_set_alloc(ctx, 0, 1);
627 bset1 = isl_basic_set_universe(space);
628 bset1 = isl_basic_set_upper_bound_val(bset1, isl_dim_set, 0,
629 isl_val_copy(v));
630 bset1 = isl_basic_set_lower_bound_val(bset1, isl_dim_set, 0,
631 isl_val_neg(v));
632 bset2 = isl_basic_set_read_from_str(ctx, "{ [x] : -100 <= x <= 100 }");
633 equal = isl_basic_set_is_equal(bset1, bset2);
634 isl_basic_set_free(bset1);
635 isl_basic_set_free(bset2);
636
637 if (equal < 0)
638 return -1;
639 if (!equal)
640 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "failed construction"
, "polly/lib/External/isl/isl_test.c", 641); return -1; } while
(0)
641 "failed construction", return -1)do { isl_handle_error(ctx, isl_error_unknown, "failed construction"
, "polly/lib/External/isl/isl_test.c", 641); return -1; } while
(0)
;
642
643 return 0;
644}
645
646/* Basic tests for constructing basic sets.
647 */
648static int test_construction(isl_ctx *ctx)
649{
650 if (test_construction_1(ctx) < 0)
651 return -1;
652 if (test_construction_2(ctx) < 0)
653 return -1;
654 return 0;
655}
656
657static int test_dim(isl_ctx *ctx)
658{
659 const char *str;
660 isl_map *map1, *map2;
661 int equal;
662
663 map1 = isl_map_read_from_str(ctx,
664 "[n] -> { [i] -> [j] : exists (a = [i/10] : i - 10a <= n ) }");
665 map1 = isl_map_add_dims(map1, isl_dim_in, 1);
666 map2 = isl_map_read_from_str(ctx,
667 "[n] -> { [i,k] -> [j] : exists (a = [i/10] : i - 10a <= n ) }");
668 equal = isl_map_is_equal(map1, map2);
669 isl_map_free(map2);
670
671 map1 = isl_map_project_out(map1, isl_dim_in, 0, 1);
672 map2 = isl_map_read_from_str(ctx, "[n] -> { [i] -> [j] : n >= 0 }");
673 if (equal >= 0 && equal)
674 equal = isl_map_is_equal(map1, map2);
675
676 isl_map_free(map1);
677 isl_map_free(map2);
678
679 if (equal < 0)
680 return -1;
681 if (!equal)
682 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 683); return -1; } while
(0)
683 "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 683); return -1; } while
(0)
;
684
685 str = "[n] -> { [i] -> [] : exists a : 0 <= i <= n and i = 2 a }";
686 map1 = isl_map_read_from_str(ctx, str);
687 str = "{ [i] -> [j] : exists a : 0 <= i <= j and i = 2 a }";
688 map2 = isl_map_read_from_str(ctx, str);
689 map1 = isl_map_move_dims(map1, isl_dim_out, 0, isl_dim_param, 0, 1);
690 equal = isl_map_is_equal(map1, map2);
691 isl_map_free(map1);
692 isl_map_free(map2);
693
694 if (equal < 0)
695 return -1;
696 if (!equal)
697 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 698); return -1; } while
(0)
698 "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 698); return -1; } while
(0)
;
699
700 return 0;
701}
702
703#undef BASEunion_pw_aff
704#define BASEunion_pw_aff multi_val
705#include "isl_test_plain_equal_templ.c"
706
707#undef BASEunion_pw_aff
708#define BASEunion_pw_aff multi_aff
709#include "isl_test_plain_equal_templ.c"
710
711/* Check that "val" is equal to the value described by "str".
712 * If "str" is "NaN", then check for a NaN value explicitly.
713 */
714static isl_stat val_check_equal(__isl_keep isl_val *val, const char *str)
715{
716 isl_bool ok, is_nan;
717 isl_ctx *ctx;
718 isl_val *res;
719
720 if (!val)
721 return isl_stat_error;
722
723 ctx = isl_val_get_ctx(val);
724 res = isl_val_read_from_str(ctx, str);
725 is_nan = isl_val_is_nan(res);
726 if (is_nan < 0)
727 ok = isl_bool_error;
728 else if (is_nan)
729 ok = isl_val_is_nan(val);
730 else
731 ok = isl_val_eq(val, res);
732 isl_val_free(res);
733 if (ok < 0)
734 return isl_stat_error;
735 if (!ok)
736 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 737); return isl_stat_error
; } while (0)
737 "unexpected result", return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 737); return isl_stat_error
; } while (0)
;
738 return isl_stat_ok;
739}
740
741struct {
742 __isl_give isl_val *(*op)(__isl_take isl_val *v);
743 const char *arg;
744 const char *res;
745} val_un_tests[] = {
746 { &isl_val_neg, "0", "0" },
747 { &isl_val_abs, "0", "0" },
748 { &isl_val_pow2, "0", "1" },
749 { &isl_val_floor, "0", "0" },
750 { &isl_val_ceil, "0", "0" },
751 { &isl_val_neg, "1", "-1" },
752 { &isl_val_neg, "-1", "1" },
753 { &isl_val_neg, "1/2", "-1/2" },
754 { &isl_val_neg, "-1/2", "1/2" },
755 { &isl_val_neg, "infty", "-infty" },
756 { &isl_val_neg, "-infty", "infty" },
757 { &isl_val_neg, "NaN", "NaN" },
758 { &isl_val_abs, "1", "1" },
759 { &isl_val_abs, "-1", "1" },
760 { &isl_val_abs, "1/2", "1/2" },
761 { &isl_val_abs, "-1/2", "1/2" },
762 { &isl_val_abs, "infty", "infty" },
763 { &isl_val_abs, "-infty", "infty" },
764 { &isl_val_abs, "NaN", "NaN" },
765 { &isl_val_floor, "1", "1" },
766 { &isl_val_floor, "-1", "-1" },
767 { &isl_val_floor, "1/2", "0" },
768 { &isl_val_floor, "-1/2", "-1" },
769 { &isl_val_floor, "infty", "infty" },
770 { &isl_val_floor, "-infty", "-infty" },
771 { &isl_val_floor, "NaN", "NaN" },
772 { &isl_val_ceil, "1", "1" },
773 { &isl_val_ceil, "-1", "-1" },
774 { &isl_val_ceil, "1/2", "1" },
775 { &isl_val_ceil, "-1/2", "0" },
776 { &isl_val_ceil, "infty", "infty" },
777 { &isl_val_ceil, "-infty", "-infty" },
778 { &isl_val_ceil, "NaN", "NaN" },
779 { &isl_val_pow2, "-3", "1/8" },
780 { &isl_val_pow2, "-1", "1/2" },
781 { &isl_val_pow2, "1", "2" },
782 { &isl_val_pow2, "2", "4" },
783 { &isl_val_pow2, "3", "8" },
784 { &isl_val_inv, "1", "1" },
785 { &isl_val_inv, "2", "1/2" },
786 { &isl_val_inv, "1/2", "2" },
787 { &isl_val_inv, "-2", "-1/2" },
788 { &isl_val_inv, "-1/2", "-2" },
789 { &isl_val_inv, "0", "NaN" },
790 { &isl_val_inv, "NaN", "NaN" },
791 { &isl_val_inv, "infty", "0" },
792 { &isl_val_inv, "-infty", "0" },
793};
794
795/* Perform some basic tests of unary operations on isl_val objects.
796 */
797static int test_un_val(isl_ctx *ctx)
798{
799 int i;
800 isl_val *v;
801 __isl_give isl_val *(*fn)(__isl_take isl_val *v);
802
803 for (i = 0; i < ARRAY_SIZE(val_un_tests)(sizeof(val_un_tests)/sizeof(*val_un_tests)); ++i) {
804 isl_stat r;
805
806 v = isl_val_read_from_str(ctx, val_un_tests[i].arg);
807 fn = val_un_tests[i].op;
808 v = fn(v);
809 r = val_check_equal(v, val_un_tests[i].res);
810 isl_val_free(v);
811 if (r < 0)
812 return -1;
813 }
814
815 return 0;
816}
817
818struct {
819 __isl_give isl_val *(*fn)(__isl_take isl_val *v1,
820 __isl_take isl_val *v2);
821} val_bin_op[] = {
822 ['+'] = { &isl_val_add },
823 ['-'] = { &isl_val_sub },
824 ['*'] = { &isl_val_mul },
825 ['/'] = { &isl_val_div },
826 ['g'] = { &isl_val_gcd },
827 ['m'] = { &isl_val_min },
828 ['M'] = { &isl_val_max },
829};
830
831struct {
832 const char *arg1;
833 unsigned char op;
834 const char *arg2;
835 const char *res;
836} val_bin_tests[] = {
837 { "0", '+', "0", "0" },
838 { "1", '+', "0", "1" },
839 { "1", '+', "1", "2" },
840 { "1", '-', "1", "0" },
841 { "1", '*', "1", "1" },
842 { "1", '/', "1", "1" },
843 { "2", '*', "3", "6" },
844 { "2", '*', "1/2", "1" },
845 { "2", '*', "1/3", "2/3" },
846 { "2/3", '*', "3/5", "2/5" },
847 { "2/3", '*', "7/5", "14/15" },
848 { "2", '/', "1/2", "4" },
849 { "-2", '/', "-1/2", "4" },
850 { "-2", '/', "1/2", "-4" },
851 { "2", '/', "-1/2", "-4" },
852 { "2", '/', "2", "1" },
853 { "2", '/', "3", "2/3" },
854 { "2/3", '/', "5/3", "2/5" },
855 { "2/3", '/', "5/7", "14/15" },
856 { "0", '/', "0", "NaN" },
857 { "42", '/', "0", "NaN" },
858 { "-42", '/', "0", "NaN" },
859 { "infty", '/', "0", "NaN" },
860 { "-infty", '/', "0", "NaN" },
861 { "NaN", '/', "0", "NaN" },
862 { "0", '/', "NaN", "NaN" },
863 { "42", '/', "NaN", "NaN" },
864 { "-42", '/', "NaN", "NaN" },
865 { "infty", '/', "NaN", "NaN" },
866 { "-infty", '/', "NaN", "NaN" },
867 { "NaN", '/', "NaN", "NaN" },
868 { "0", '/', "infty", "0" },
869 { "42", '/', "infty", "0" },
870 { "-42", '/', "infty", "0" },
871 { "infty", '/', "infty", "NaN" },
872 { "-infty", '/', "infty", "NaN" },
873 { "NaN", '/', "infty", "NaN" },
874 { "0", '/', "-infty", "0" },
875 { "42", '/', "-infty", "0" },
876 { "-42", '/', "-infty", "0" },
877 { "infty", '/', "-infty", "NaN" },
878 { "-infty", '/', "-infty", "NaN" },
879 { "NaN", '/', "-infty", "NaN" },
880 { "1", '-', "1/3", "2/3" },
881 { "1/3", '+', "1/2", "5/6" },
882 { "1/2", '+', "1/2", "1" },
883 { "3/4", '-', "1/4", "1/2" },
884 { "1/2", '-', "1/3", "1/6" },
885 { "infty", '+', "42", "infty" },
886 { "infty", '+', "infty", "infty" },
887 { "42", '+', "infty", "infty" },
888 { "infty", '-', "infty", "NaN" },
889 { "infty", '*', "infty", "infty" },
890 { "infty", '*', "-infty", "-infty" },
891 { "-infty", '*', "infty", "-infty" },
892 { "-infty", '*', "-infty", "infty" },
893 { "0", '*', "infty", "NaN" },
894 { "1", '*', "infty", "infty" },
895 { "infty", '*', "0", "NaN" },
896 { "infty", '*', "42", "infty" },
897 { "42", '-', "infty", "-infty" },
898 { "infty", '+', "-infty", "NaN" },
899 { "4", 'g', "6", "2" },
900 { "5", 'g', "6", "1" },
901 { "42", 'm', "3", "3" },
902 { "42", 'M', "3", "42" },
903 { "3", 'm', "42", "3" },
904 { "3", 'M', "42", "42" },
905 { "42", 'm', "infty", "42" },
906 { "42", 'M', "infty", "infty" },
907 { "42", 'm', "-infty", "-infty" },
908 { "42", 'M', "-infty", "42" },
909 { "42", 'm', "NaN", "NaN" },
910 { "42", 'M', "NaN", "NaN" },
911 { "infty", 'm', "-infty", "-infty" },
912 { "infty", 'M', "-infty", "infty" },
913};
914
915/* Perform some basic tests of binary operations on isl_val objects.
916 */
917static int test_bin_val(isl_ctx *ctx)
918{
919 int i;
920 isl_val *v1, *v2, *res;
921 __isl_give isl_val *(*fn)(__isl_take isl_val *v1,
922 __isl_take isl_val *v2);
923 int ok;
924
925 for (i = 0; i < ARRAY_SIZE(val_bin_tests)(sizeof(val_bin_tests)/sizeof(*val_bin_tests)); ++i) {
926 v1 = isl_val_read_from_str(ctx, val_bin_tests[i].arg1);
927 v2 = isl_val_read_from_str(ctx, val_bin_tests[i].arg2);
928 res = isl_val_read_from_str(ctx, val_bin_tests[i].res);
929 fn = val_bin_op[val_bin_tests[i].op].fn;
930 v1 = fn(v1, v2);
931 if (isl_val_is_nan(res))
932 ok = isl_val_is_nan(v1);
933 else
934 ok = isl_val_eq(v1, res);
935 isl_val_free(v1);
936 isl_val_free(res);
937 if (ok < 0)
938 return -1;
939 if (!ok)
940 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 941); return -1; } while
(0)
941 "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 941); return -1; } while
(0)
;
942 }
943
944 return 0;
945}
946
947/* Perform some basic tests on isl_val objects.
948 */
949static int test_val(isl_ctx *ctx)
950{
951 if (test_un_val(ctx) < 0)
952 return -1;
953 if (test_bin_val(ctx) < 0)
954 return -1;
955 return 0;
956}
957
958/* Sets described using existentially quantified variables that
959 * can also be described without.
960 */
961static const char *elimination_tests[] = {
962 "{ [i,j] : 2 * [i/2] + 3 * [j/4] <= 10 and 2 i = j }",
963 "{ [m, w] : exists a : w - 2m - 5 <= 3a <= m - 2w }",
964 "{ [m, w] : exists a : w >= 0 and a < m and -1 + w <= a <= 2m - w }",
965};
966
967/* Check that redundant existentially quantified variables are
968 * getting removed.
969 */
970static int test_elimination(isl_ctx *ctx)
971{
972 int i;
973 isl_size n;
974 isl_basic_setisl_basic_map *bset;
975
976 for (i = 0; i < ARRAY_SIZE(elimination_tests)(sizeof(elimination_tests)/sizeof(*elimination_tests)); ++i) {
977 bset = isl_basic_set_read_from_str(ctx, elimination_tests[i]);
978 n = isl_basic_set_dim(bset, isl_dim_div);
979 isl_basic_set_free(bset);
980 if (n < 0)
981 return -1;
982 if (n != 0)
983 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "expecting no existentials"
, "polly/lib/External/isl/isl_test.c", 984); return -1; } while
(0)
984 "expecting no existentials", return -1)do { isl_handle_error(ctx, isl_error_unknown, "expecting no existentials"
, "polly/lib/External/isl/isl_test.c", 984); return -1; } while
(0)
;
985 }
986
987 return 0;
988}
989
990static int test_div(isl_ctx *ctx)
991{
992 const char *str;
993 int empty;
994 isl_space *space;
995 isl_setisl_map *set;
996 isl_local_space *ls;
997 struct isl_basic_setisl_basic_map *bset;
998 struct isl_constraint *c;
999
1000 /* test 1 */
1001 space = isl_space_set_alloc(ctx, 0, 3);
1002 bset = isl_basic_set_universe(isl_space_copy(space));
1003 ls = isl_local_space_from_space(space);
1004
1005 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1006 c = isl_constraint_set_constant_si(c, -1);
1007 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
1008 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 3);
1009 bset = isl_basic_set_add_constraint(bset, c);
1010
1011 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1012 c = isl_constraint_set_constant_si(c, 1);
1013 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1014 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 3);
1015 bset = isl_basic_set_add_constraint(bset, c);
1016
1017 bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 2);
1018
1019 assert(bset && bset->n_div == 1)((void) sizeof ((bset && bset->n_div == 1) ? 1 : 0
), __extension__ ({ if (bset && bset->n_div == 1) ;
else __assert_fail ("bset && bset->n_div == 1", "polly/lib/External/isl/isl_test.c"
, 1019, __extension__ __PRETTY_FUNCTION__); }))
;
1020 isl_local_space_free(ls);
1021 isl_basic_set_free(bset);
1022
1023 /* test 2 */
1024 space = isl_space_set_alloc(ctx, 0, 3);
1025 bset = isl_basic_set_universe(isl_space_copy(space));
1026 ls = isl_local_space_from_space(space);
1027
1028 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1029 c = isl_constraint_set_constant_si(c, 1);
1030 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1031 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 3);
1032 bset = isl_basic_set_add_constraint(bset, c);
1033
1034 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1035 c = isl_constraint_set_constant_si(c, -1);
1036 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
1037 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 3);
1038 bset = isl_basic_set_add_constraint(bset, c);
1039
1040 bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 2);
1041
1042 assert(bset && bset->n_div == 1)((void) sizeof ((bset && bset->n_div == 1) ? 1 : 0
), __extension__ ({ if (bset && bset->n_div == 1) ;
else __assert_fail ("bset && bset->n_div == 1", "polly/lib/External/isl/isl_test.c"
, 1042, __extension__ __PRETTY_FUNCTION__); }))
;
1043 isl_local_space_free(ls);
1044 isl_basic_set_free(bset);
1045
1046 /* test 3 */
1047 space = isl_space_set_alloc(ctx, 0, 3);
1048 bset = isl_basic_set_universe(isl_space_copy(space));
1049 ls = isl_local_space_from_space(space);
1050
1051 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1052 c = isl_constraint_set_constant_si(c, 1);
1053 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1054 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 3);
1055 bset = isl_basic_set_add_constraint(bset, c);
1056
1057 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1058 c = isl_constraint_set_constant_si(c, -3);
1059 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
1060 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 4);
1061 bset = isl_basic_set_add_constraint(bset, c);
1062
1063 bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 2);
1064
1065 assert(bset && bset->n_div == 1)((void) sizeof ((bset && bset->n_div == 1) ? 1 : 0
), __extension__ ({ if (bset && bset->n_div == 1) ;
else __assert_fail ("bset && bset->n_div == 1", "polly/lib/External/isl/isl_test.c"
, 1065, __extension__ __PRETTY_FUNCTION__); }))
;
1066 isl_local_space_free(ls);
1067 isl_basic_set_free(bset);
1068
1069 /* test 4 */
1070 space = isl_space_set_alloc(ctx, 0, 3);
1071 bset = isl_basic_set_universe(isl_space_copy(space));
1072 ls = isl_local_space_from_space(space);
1073
1074 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1075 c = isl_constraint_set_constant_si(c, 2);
1076 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1077 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 3);
1078 bset = isl_basic_set_add_constraint(bset, c);
1079
1080 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1081 c = isl_constraint_set_constant_si(c, -1);
1082 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
1083 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 6);
1084 bset = isl_basic_set_add_constraint(bset, c);
1085
1086 bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 2);
1087
1088 assert(isl_basic_set_is_empty(bset))((void) sizeof ((isl_basic_set_is_empty(bset)) ? 1 : 0), __extension__
({ if (isl_basic_set_is_empty(bset)) ; else __assert_fail ("isl_basic_set_is_empty(bset)"
, "polly/lib/External/isl/isl_test.c", 1088, __extension__ __PRETTY_FUNCTION__
); }))
;
1089 isl_local_space_free(ls);
1090 isl_basic_set_free(bset);
1091
1092 /* test 5 */
1093 space = isl_space_set_alloc(ctx, 0, 3);
1094 bset = isl_basic_set_universe(isl_space_copy(space));
1095 ls = isl_local_space_from_space(space);
1096
1097 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1098 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1099 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 3);
1100 bset = isl_basic_set_add_constraint(bset, c);
1101
1102 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1103 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
1104 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, -3);
1105 bset = isl_basic_set_add_constraint(bset, c);
1106
1107 bset = isl_basic_set_project_out(bset, isl_dim_set, 2, 1);
1108
1109 assert(bset && bset->n_div == 0)((void) sizeof ((bset && bset->n_div == 0) ? 1 : 0
), __extension__ ({ if (bset && bset->n_div == 0) ;
else __assert_fail ("bset && bset->n_div == 0", "polly/lib/External/isl/isl_test.c"
, 1109, __extension__ __PRETTY_FUNCTION__); }))
;
1110 isl_basic_set_free(bset);
1111 isl_local_space_free(ls);
1112
1113 /* test 6 */
1114 space = isl_space_set_alloc(ctx, 0, 3);
1115 bset = isl_basic_set_universe(isl_space_copy(space));
1116 ls = isl_local_space_from_space(space);
1117
1118 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1119 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1120 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 6);
1121 bset = isl_basic_set_add_constraint(bset, c);
1122
1123 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1124 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
1125 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, -3);
1126 bset = isl_basic_set_add_constraint(bset, c);
1127
1128 bset = isl_basic_set_project_out(bset, isl_dim_set, 2, 1);
1129
1130 assert(bset && bset->n_div == 1)((void) sizeof ((bset && bset->n_div == 1) ? 1 : 0
), __extension__ ({ if (bset && bset->n_div == 1) ;
else __assert_fail ("bset && bset->n_div == 1", "polly/lib/External/isl/isl_test.c"
, 1130, __extension__ __PRETTY_FUNCTION__); }))
;
1131 isl_basic_set_free(bset);
1132 isl_local_space_free(ls);
1133
1134 /* test 7 */
1135 /* This test is a bit tricky. We set up an equality
1136 * a + 3b + 3c = 6 e0
1137 * Normalization of divs creates _two_ divs
1138 * a = 3 e0
1139 * c - b - e0 = 2 e1
1140 * Afterwards e0 is removed again because it has coefficient -1
1141 * and we end up with the original equality and div again.
1142 * Perhaps we can avoid the introduction of this temporary div.
1143 */
1144 space = isl_space_set_alloc(ctx, 0, 4);
1145 bset = isl_basic_set_universe(isl_space_copy(space));
1146 ls = isl_local_space_from_space(space);
1147
1148 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1149 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1150 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, -3);
1151 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, -3);
1152 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 3, 6);
1153 bset = isl_basic_set_add_constraint(bset, c);
1154
1155 bset = isl_basic_set_project_out(bset, isl_dim_set, 3, 1);
1156
1157 /* Test disabled for now */
1158 /*
1159 assert(bset && bset->n_div == 1);
1160 */
1161 isl_local_space_free(ls);
1162 isl_basic_set_free(bset);
1163
1164 /* test 8 */
1165 space = isl_space_set_alloc(ctx, 0, 5);
1166 bset = isl_basic_set_universe(isl_space_copy(space));
1167 ls = isl_local_space_from_space(space);
1168
1169 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1170 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1171 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, -3);
1172 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 3, -3);
1173 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 4, 6);
1174 bset = isl_basic_set_add_constraint(bset, c);
1175
1176 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1177 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1178 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 1);
1179 c = isl_constraint_set_constant_si(c, 1);
1180 bset = isl_basic_set_add_constraint(bset, c);
1181
1182 bset = isl_basic_set_project_out(bset, isl_dim_set, 4, 1);
1183
1184 /* Test disabled for now */
1185 /*
1186 assert(bset && bset->n_div == 1);
1187 */
1188 isl_local_space_free(ls);
1189 isl_basic_set_free(bset);
1190
1191 /* test 9 */
1192 space = isl_space_set_alloc(ctx, 0, 4);
1193 bset = isl_basic_set_universe(isl_space_copy(space));
1194 ls = isl_local_space_from_space(space);
1195
1196 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1197 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
1198 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, -1);
1199 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, -2);
1200 bset = isl_basic_set_add_constraint(bset, c);
1201
1202 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1203 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1204 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 3, 3);
1205 c = isl_constraint_set_constant_si(c, 2);
1206 bset = isl_basic_set_add_constraint(bset, c);
1207
1208 bset = isl_basic_set_project_out(bset, isl_dim_set, 2, 2);
1209
1210 bset = isl_basic_set_fix_si(bset, isl_dim_set, 0, 2);
1211
1212 assert(!isl_basic_set_is_empty(bset))((void) sizeof ((!isl_basic_set_is_empty(bset)) ? 1 : 0), __extension__
({ if (!isl_basic_set_is_empty(bset)) ; else __assert_fail (
"!isl_basic_set_is_empty(bset)", "polly/lib/External/isl/isl_test.c"
, 1212, __extension__ __PRETTY_FUNCTION__); }))
;
1213
1214 isl_local_space_free(ls);
1215 isl_basic_set_free(bset);
1216
1217 /* test 10 */
1218 space = isl_space_set_alloc(ctx, 0, 3);
1219 bset = isl_basic_set_universe(isl_space_copy(space));
1220 ls = isl_local_space_from_space(space);
1221
1222 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
1223 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
1224 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, -2);
1225 bset = isl_basic_set_add_constraint(bset, c);
1226
1227 bset = isl_basic_set_project_out(bset, isl_dim_set, 2, 1);
1228
1229 bset = isl_basic_set_fix_si(bset, isl_dim_set, 0, 2);
1230
1231 isl_local_space_free(ls);
1232 isl_basic_set_free(bset);
1233
1234 str = "{ [i] : exists (e0, e1: 3e1 >= 1 + 2e0 and "
1235 "8e1 <= -1 + 5i - 5e0 and 2e1 >= 1 + 2i - 5e0) }";
1236 set = isl_set_read_from_str(ctx, str);
1237 set = isl_set_compute_divs(set);
1238 isl_set_free(set);
1239 if (!set)
1240 return -1;
1241
1242 if (test_elimination(ctx) < 0)
1243 return -1;
1244
1245 str = "{ [i,j,k] : 3 + i + 2j >= 0 and 2 * [(i+2j)/4] <= k }";
1246 set = isl_set_read_from_str(ctx, str);
1247 set = isl_set_remove_divs_involving_dims(set, isl_dim_set, 0, 2);
1248 set = isl_set_fix_si(set, isl_dim_set, 2, -3);
1249 empty = isl_set_is_empty(set);
1250 isl_set_free(set);
1251 if (empty < 0)
1252 return -1;
1253 if (!empty)
1254 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "result not as accurate as expected"
, "polly/lib/External/isl/isl_test.c", 1255); return -1; } while
(0)
1255 "result not as accurate as expected", return -1)do { isl_handle_error(ctx, isl_error_unknown, "result not as accurate as expected"
, "polly/lib/External/isl/isl_test.c", 1255); return -1; } while
(0)
;
1256
1257 return 0;
1258}
1259
1260void test_application_case(struct isl_ctx *ctx, const char *name)
1261{
1262 char *filename;
1263 FILE *input;
1264 struct isl_basic_setisl_basic_map *bset1, *bset2;
1265 struct isl_basic_map *bmap;
1266
1267 filename = get_filename(ctx, name, "omega");
1268 assert(filename)((void) sizeof ((filename) ? 1 : 0), __extension__ ({ if (filename
) ; else __assert_fail ("filename", "polly/lib/External/isl/isl_test.c"
, 1268, __extension__ __PRETTY_FUNCTION__); }))
;
1269 input = fopen(filename, "r");
1270 assert(input)((void) sizeof ((input) ? 1 : 0), __extension__ ({ if (input)
; else __assert_fail ("input", "polly/lib/External/isl/isl_test.c"
, 1270, __extension__ __PRETTY_FUNCTION__); }))
;
1271
1272 bset1 = isl_basic_set_read_from_file(ctx, input);
1273 bmap = isl_basic_map_read_from_file(ctx, input);
1274
1275 bset1 = isl_basic_set_apply(bset1, bmap);
1276
1277 bset2 = isl_basic_set_read_from_file(ctx, input);
1278
1279 assert(isl_basic_set_is_equal(bset1, bset2) == 1)((void) sizeof ((isl_basic_set_is_equal(bset1, bset2) == 1) ?
1 : 0), __extension__ ({ if (isl_basic_set_is_equal(bset1, bset2
) == 1) ; else __assert_fail ("isl_basic_set_is_equal(bset1, bset2) == 1"
, "polly/lib/External/isl/isl_test.c", 1279, __extension__ __PRETTY_FUNCTION__
); }))
;
1280
1281 isl_basic_set_free(bset1);
1282 isl_basic_set_free(bset2);
1283 free(filename);
1284
1285 fclose(input);
1286}
1287
1288static int test_application(isl_ctx *ctx)
1289{
1290 test_application_case(ctx, "application");
1291 test_application_case(ctx, "application2");
1292
1293 return 0;
1294}
1295
1296void test_affine_hull_case(struct isl_ctx *ctx, const char *name)
1297{
1298 char *filename;
1299 FILE *input;
1300 struct isl_basic_setisl_basic_map *bset1, *bset2;
1301
1302 filename = get_filename(ctx, name, "polylib");
1303 assert(filename)((void) sizeof ((filename) ? 1 : 0), __extension__ ({ if (filename
) ; else __assert_fail ("filename", "polly/lib/External/isl/isl_test.c"
, 1303, __extension__ __PRETTY_FUNCTION__); }))
;
1304 input = fopen(filename, "r");
1305 assert(input)((void) sizeof ((input) ? 1 : 0), __extension__ ({ if (input)
; else __assert_fail ("input", "polly/lib/External/isl/isl_test.c"
, 1305, __extension__ __PRETTY_FUNCTION__); }))
;
1306
1307 bset1 = isl_basic_set_read_from_file(ctx, input);
1308 bset2 = isl_basic_set_read_from_file(ctx, input);
1309
1310 bset1 = isl_basic_set_affine_hull(bset1);
1311
1312 assert(isl_basic_set_is_equal(bset1, bset2) == 1)((void) sizeof ((isl_basic_set_is_equal(bset1, bset2) == 1) ?
1 : 0), __extension__ ({ if (isl_basic_set_is_equal(bset1, bset2
) == 1) ; else __assert_fail ("isl_basic_set_is_equal(bset1, bset2) == 1"
, "polly/lib/External/isl/isl_test.c", 1312, __extension__ __PRETTY_FUNCTION__
); }))
;
1313
1314 isl_basic_set_free(bset1);
1315 isl_basic_set_free(bset2);
1316 free(filename);
1317
1318 fclose(input);
1319}
1320
1321/* Pairs of sets and the corresponding expected results of
1322 * isl_basic_set_recession_cone.
1323 */
1324struct {
1325 const char *set;
1326 const char *cone;
1327} recession_cone_tests[] = {
1328 { "{ [i] : 0 <= i <= 10 }", "{ [0] }" },
1329 { "{ [i] : 0 <= i }", "{ [i] : 0 <= i }" },
1330 { "{ [i] : i <= 10 }", "{ [i] : i <= 0 }" },
1331 { "{ [i] : false }", "{ [i] : false }" },
1332};
1333
1334/* Perform some basic isl_basic_set_recession_cone tests.
1335 */
1336static int test_recession_cone(struct isl_ctx *ctx)
1337{
1338 int i;
1339
1340 for (i = 0; i < ARRAY_SIZE(recession_cone_tests)(sizeof(recession_cone_tests)/sizeof(*recession_cone_tests)); ++i) {
1341 const char *str;
1342 isl_basic_setisl_basic_map *bset;
1343 isl_basic_setisl_basic_map *cone, *expected;
1344 isl_bool equal;
1345
1346 str = recession_cone_tests[i].set;
1347 bset = isl_basic_set_read_from_str(ctx, str);
1348 str = recession_cone_tests[i].cone;
1349 expected = isl_basic_set_read_from_str(ctx, str);
1350 cone = isl_basic_set_recession_cone(bset);
1351 equal = isl_basic_set_is_equal(cone, expected);
1352 isl_basic_set_free(cone);
1353 isl_basic_set_free(expected);
1354 if (equal < 0)
1355 return -1;
1356 if (!equal)
1357 isl_die(ctx, isl_error_unknown, "unexpected cone",do { isl_handle_error(ctx, isl_error_unknown, "unexpected cone"
, "polly/lib/External/isl/isl_test.c", 1358); return -1; } while
(0)
1358 return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected cone"
, "polly/lib/External/isl/isl_test.c", 1358); return -1; } while
(0)
;
1359 }
1360
1361 return 0;
1362}
1363
1364int test_affine_hull(struct isl_ctx *ctx)
1365{
1366 const char *str;
1367 isl_setisl_map *set;
1368 isl_basic_setisl_basic_map *bset, *bset2;
1369 isl_size n;
1370 isl_bool subset;
1371
1372 test_affine_hull_case(ctx, "affine2");
1373 test_affine_hull_case(ctx, "affine");
1374 test_affine_hull_case(ctx, "affine3");
1375
1376 str = "[m] -> { [i0] : exists (e0, e1: e1 <= 1 + i0 and "
1377 "m >= 3 and 4i0 <= 2 + m and e1 >= i0 and "
1378 "e1 >= 0 and e1 <= 2 and e1 >= 1 + 2e0 and "
1379 "2e1 <= 1 + m + 4e0 and 2e1 >= 2 - m + 4i0 - 4e0) }";
1380 set = isl_set_read_from_str(ctx, str);
1381 bset = isl_set_affine_hull(set);
1382 n = isl_basic_set_dim(bset, isl_dim_div);
1383 isl_basic_set_free(bset);
1384 if (n < 0)
1385 return -1;
1386 if (n != 0)
1387 isl_die(ctx, isl_error_unknown, "not expecting any divs",do { isl_handle_error(ctx, isl_error_unknown, "not expecting any divs"
, "polly/lib/External/isl/isl_test.c", 1388); return -1; } while
(0)
1388 return -1)do { isl_handle_error(ctx, isl_error_unknown, "not expecting any divs"
, "polly/lib/External/isl/isl_test.c", 1388); return -1; } while
(0)
;
1389
1390 /* Check that isl_map_affine_hull is not confused by
1391 * the reordering of divs in isl_map_align_divs.
1392 */
1393 str = "{ [a, b, c, 0] : exists (e0 = [(b)/32], e1 = [(c)/32]: "
1394 "32e0 = b and 32e1 = c); "
1395 "[a, 0, c, 0] : exists (e0 = [(c)/32]: 32e0 = c) }";
1396 set = isl_set_read_from_str(ctx, str);
1397 bset = isl_set_affine_hull(set);
1398 isl_basic_set_free(bset);
1399 if (!bset)
1400 return -1;
1401
1402 str = "{ [a] : exists e0, e1, e2: 32e1 = 31 + 31a + 31e0 and "
1403 "32e2 = 31 + 31e0 }";
1404 set = isl_set_read_from_str(ctx, str);
1405 bset = isl_set_affine_hull(set);
1406 str = "{ [a] : exists e : a = 32 e }";
1407 bset2 = isl_basic_set_read_from_str(ctx, str);
1408 subset = isl_basic_set_is_subset(bset, bset2);
1409 isl_basic_set_free(bset);
1410 isl_basic_set_free(bset2);
1411 if (subset < 0)
1412 return -1;
1413 if (!subset)
1414 isl_die(ctx, isl_error_unknown, "not as accurate as expected",do { isl_handle_error(ctx, isl_error_unknown, "not as accurate as expected"
, "polly/lib/External/isl/isl_test.c", 1415); return -1; } while
(0)
1415 return -1)do { isl_handle_error(ctx, isl_error_unknown, "not as accurate as expected"
, "polly/lib/External/isl/isl_test.c", 1415); return -1; } while
(0)
;
1416
1417 return 0;
1418}
1419
1420/* Test a special case of isl_set_plain_unshifted_simple_hull
1421 * where older versions of isl would include a redundant constraint
1422 * in the result.
1423 * Check that the result does not have any constraints.
1424 */
1425static isl_stat test_plain_unshifted_simple_hull_special(isl_ctx *ctx)
1426{
1427 const char *str;
1428 isl_bool is_universe;
1429 isl_setisl_map *set;
1430 isl_basic_setisl_basic_map *bset;
1431
1432 str = "{[x, y] : x = 0 or 2*((x+y)//2) <= y + 2 }";
1433 set = isl_set_read_from_str(ctx, str);
1434 bset = isl_set_plain_unshifted_simple_hull(set);
1435 is_universe = isl_basic_set_plain_is_universe(bset);
1436 isl_basic_set_free(bset);
1437
1438 if (is_universe < 0)
1439 return isl_stat_error;
1440 if (!is_universe)
1441 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "hull should not have any constraints"
, "polly/lib/External/isl/isl_test.c", 1443); return isl_stat_error
; } while (0)
1442 "hull should not have any constraints",do { isl_handle_error(ctx, isl_error_unknown, "hull should not have any constraints"
, "polly/lib/External/isl/isl_test.c", 1443); return isl_stat_error
; } while (0)
1443 return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "hull should not have any constraints"
, "polly/lib/External/isl/isl_test.c", 1443); return isl_stat_error
; } while (0)
;
1444
1445 return isl_stat_ok;
1446}
1447
1448/* Inputs for simple hull tests, consisting of
1449 * the specific simple hull function, the input set and the expected result.
1450 */
1451struct {
1452 __isl_give isl_basic_setisl_basic_map *(*fn)(__isl_take isl_setisl_map *set);
1453 const char *set;
1454 const char *hull;
1455} simple_hull_tests[] = {
1456 { &isl_set_plain_unshifted_simple_hull,
1457 "{ [i,j] : i >= 1 and j >= 1 or i >= 2 and j <= 10 }",
1458 "{ [i,j] : i >= 1 }" },
1459 { &isl_set_plain_unshifted_simple_hull,
1460 "{ [n,i,j,k] : (i mod 3 = 2 and j mod 4 = 2) or "
1461 "(j mod 4 = 2 and k mod 6 = n) }",
1462 "{ [n,i,j,k] : j mod 4 = 2 }" },
1463 { &isl_set_unshifted_simple_hull,
1464 "{ [0,x,y] : x <= -1; [1,x,y] : x <= y <= -x; [2,x,y] : x <= 1 }",
1465 "{ [t,x,y] : 0 <= t <= 2 and x <= 1 }" },
1466 { &isl_set_simple_hull,
1467 "{ [a, b] : b <= 0 and "
1468 "2*floor((-2*floor((b)/2))/5) >= a - floor((b)/2); "
1469 "[a, b] : a mod 2 = 0 }",
1470 "{ [a, b] }" },
1471};
1472
1473/* Basic tests for various simple hull functions.
1474 */
1475static int test_various_simple_hull(isl_ctx *ctx)
1476{
1477 int i;
1478 isl_setisl_map *set;
1479 isl_basic_setisl_basic_map *hull, *expected;
1480 isl_bool equal;
1481
1482 for (i = 0; i < ARRAY_SIZE(simple_hull_tests)(sizeof(simple_hull_tests)/sizeof(*simple_hull_tests)); ++i) {
1483 const char *str;
1484 str = simple_hull_tests[i].set;
1485 set = isl_set_read_from_str(ctx, str);
1486 str = simple_hull_tests[i].hull;
1487 expected = isl_basic_set_read_from_str(ctx, str);
1488 hull = simple_hull_tests[i].fn(set);
1489 equal = isl_basic_set_is_equal(hull, expected);
1490 isl_basic_set_free(hull);
1491 isl_basic_set_free(expected);
1492 if (equal < 0)
1493 return -1;
1494 if (!equal)
1495 isl_die(ctx, isl_error_unknown, "unexpected hull",do { isl_handle_error(ctx, isl_error_unknown, "unexpected hull"
, "polly/lib/External/isl/isl_test.c", 1496); return -1; } while
(0)
1496 return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected hull"
, "polly/lib/External/isl/isl_test.c", 1496); return -1; } while
(0)
;
1497 }
1498
1499 return 0;
1500}
1501
1502static int test_simple_hull(struct isl_ctx *ctx)
1503{
1504 const char *str;
1505 isl_setisl_map *set;
1506 isl_basic_setisl_basic_map *bset;
1507 isl_bool is_empty;
1508
1509 str = "{ [x, y] : 3y <= 2x and y >= -2 + 2x and 2y >= 2 - x;"
1510 "[y, x] : 3y <= 2x and y >= -2 + 2x and 2y >= 2 - x }";
1511 set = isl_set_read_from_str(ctx, str);
1512 bset = isl_set_simple_hull(set);
1513 is_empty = isl_basic_set_is_empty(bset);
1514 isl_basic_set_free(bset);
1515
1516 if (is_empty == isl_bool_error)
1517 return -1;
1518
1519 if (is_empty == isl_bool_false)
1520 isl_die(ctx, isl_error_unknown, "Empty set should be detected",do { isl_handle_error(ctx, isl_error_unknown, "Empty set should be detected"
, "polly/lib/External/isl/isl_test.c", 1521); return -1; } while
(0)
1521 return -1)do { isl_handle_error(ctx, isl_error_unknown, "Empty set should be detected"
, "polly/lib/External/isl/isl_test.c", 1521); return -1; } while
(0)
;
1522
1523 if (test_plain_unshifted_simple_hull_special(ctx) < 0)
1524 return -1;
1525 if (test_various_simple_hull(ctx) < 0)
1526 return -1;
1527
1528 return 0;
1529}
1530
1531/* Inputs for isl_set_get_simple_fixed_box_hull tests.
1532 * "set" is the input set.
1533 * "offset" is the expected box offset.
1534 * "size" is the expected box size.
1535 */
1536static struct {
1537 const char *set;
1538 const char *offset;
1539 const char *size;
1540} box_hull_tests[] = {
1541 { "{ S[x, y] : 0 <= x, y < 10 }", "{ S[0, 0] }", "{ S[10, 10] }" },
1542 { "[N] -> { S[x, y] : N <= x, y < N + 10 }",
1543 "[N] -> { S[N, N] }", "{ S[10, 10] }" },
1544 { "{ S[x, y] : 0 <= x + y, x - y < 10 }",
1545 "{ S[0, -4] }", "{ S[10, 9] }" },
1546 { "{ [i=0:10] : exists (e0, e1: 3e1 >= 1 + 2e0 and "
1547 "8e1 <= -1 + 5i - 5e0 and 2e1 >= 1 + 2i - 5e0) }",
1548 "{ [3] }", "{ [8] }" },
1549 { "[N] -> { [w = 0:17] : exists (e0: w < 2N and "
1550 "-1 + w <= e0 <= w and 2e0 >= N + w and w <= 2e0 <= 15 + w) }",
1551 "[N] -> { [N] }", "{ [9] }" },
1552};
1553
1554/* Perform basic isl_set_get_simple_fixed_box_hull tests.
1555 */
1556static int test_box_hull(struct isl_ctx *ctx)
1557{
1558 int i;
1559
1560 for (i = 0; i < ARRAY_SIZE(box_hull_tests)(sizeof(box_hull_tests)/sizeof(*box_hull_tests)); ++i) {
1561 const char *str;
1562 isl_stat r;
1563 isl_setisl_map *set;
1564 isl_multi_aff *offset;
1565 isl_multi_val *size;
1566 isl_fixed_box *box;
1567
1568 set = isl_set_read_from_str(ctx, box_hull_tests[i].set);
1569 box = isl_set_get_simple_fixed_box_hull(set);
1570 offset = isl_fixed_box_get_offset(box);
1571 size = isl_fixed_box_get_size(box);
1572 str = box_hull_tests[i].offset;
1573 r = multi_aff_check_plain_equal(offset, str);
1574 str = box_hull_tests[i].size;
1575 if (r >= 0)
1576 r = multi_val_check_plain_equal(size, str);
1577 isl_multi_aff_free(offset);
1578 isl_multi_val_free(size);
1579 isl_fixed_box_free(box);
1580 isl_set_free(set);
1581 if (r < 0)
1582 return -1;
1583 }
1584
1585 return 0;
1586}
1587
1588void test_convex_hull_case(struct isl_ctx *ctx, const char *name)
1589{
1590 char *filename;
1591 FILE *input;
1592 struct isl_basic_setisl_basic_map *bset1, *bset2;
1593 struct isl_setisl_map *set;
1594
1595 filename = get_filename(ctx, name, "polylib");
1596 assert(filename)((void) sizeof ((filename) ? 1 : 0), __extension__ ({ if (filename
) ; else __assert_fail ("filename", "polly/lib/External/isl/isl_test.c"
, 1596, __extension__ __PRETTY_FUNCTION__); }))
;
1597 input = fopen(filename, "r");
1598 assert(input)((void) sizeof ((input) ? 1 : 0), __extension__ ({ if (input)
; else __assert_fail ("input", "polly/lib/External/isl/isl_test.c"
, 1598, __extension__ __PRETTY_FUNCTION__); }))
;
1599
1600 bset1 = isl_basic_set_read_from_file(ctx, input);
1601 bset2 = isl_basic_set_read_from_file(ctx, input);
1602
1603 set = isl_basic_set_union(bset1, bset2);
1604 bset1 = isl_set_convex_hull(set);
1605
1606 bset2 = isl_basic_set_read_from_file(ctx, input);
1607
1608 assert(isl_basic_set_is_equal(bset1, bset2) == 1)((void) sizeof ((isl_basic_set_is_equal(bset1, bset2) == 1) ?
1 : 0), __extension__ ({ if (isl_basic_set_is_equal(bset1, bset2
) == 1) ; else __assert_fail ("isl_basic_set_is_equal(bset1, bset2) == 1"
, "polly/lib/External/isl/isl_test.c", 1608, __extension__ __PRETTY_FUNCTION__
); }))
;
1609
1610 isl_basic_set_free(bset1);
1611 isl_basic_set_free(bset2);
1612 free(filename);
1613
1614 fclose(input);
1615}
1616
1617struct {
1618 const char *set;
1619 const char *hull;
1620} convex_hull_tests[] = {
1621 { "{ [i0, i1, i2] : (i2 = 1 and i0 = 0 and i1 >= 0) or "
1622 "(i0 = 1 and i1 = 0 and i2 = 1) or "
1623 "(i0 = 0 and i1 = 0 and i2 = 0) }",
1624 "{ [i0, i1, i2] : i0 >= 0 and i2 >= i0 and i2 <= 1 and i1 >= 0 }" },
1625 { "[n] -> { [i0, i1, i0] : i0 <= -4 + n; "
1626 "[i0, i0, i2] : n = 6 and i0 >= 0 and i2 <= 7 - i0 and "
1627 "i2 <= 5 and i2 >= 4; "
1628 "[3, i1, 3] : n = 5 and i1 <= 2 and i1 >= 0 }",
1629 "[n] -> { [i0, i1, i2] : i2 <= -1 + n and 2i2 <= -6 + 3n - i0 and "
1630 "i2 <= 5 + i0 and i2 >= i0 }" },
1631 { "{ [x, y] : 3y <= 2x and y >= -2 + 2x and 2y >= 2 - x }",
1632 "{ [x, y] : 1 = 0 }" },
1633 { "{ [x, y, z] : 0 <= x, y, z <= 10; [x, y, 0] : x >= 0 and y > 0; "
1634 "[x, y, 0] : x >= 0 and y < 0 }",
1635 "{ [x, y, z] : x >= 0 and 0 <= z <= 10 }" },
1636 { "{ [a, b, c] : a <= 1 and -a < b <= 1 and 0 <= c <= 2 - a - b and "
1637 "c <= a; "
1638 "[0, 2, 0]; [3, 1, 0] }",
1639 "{ [a, b, c] : b > -a and 2b >= -1 + a and 0 <= c <= a and "
1640 "5c <= 6 - a - 3b }" },
1641};
1642
1643static int test_convex_hull_algo(isl_ctx *ctx, int convex)
1644{
1645 int i;
1646 int orig_convex = ctx->opt->convex;
1647 ctx->opt->convex = convex;
1648
1649 test_convex_hull_case(ctx, "convex0");
1650 test_convex_hull_case(ctx, "convex1");
1651 test_convex_hull_case(ctx, "convex2");
1652 test_convex_hull_case(ctx, "convex3");
1653 test_convex_hull_case(ctx, "convex4");
1654 test_convex_hull_case(ctx, "convex5");
1655 test_convex_hull_case(ctx, "convex6");
1656 test_convex_hull_case(ctx, "convex7");
1657 test_convex_hull_case(ctx, "convex8");
1658 test_convex_hull_case(ctx, "convex9");
1659 test_convex_hull_case(ctx, "convex10");
1660 test_convex_hull_case(ctx, "convex11");
1661 test_convex_hull_case(ctx, "convex12");
1662 test_convex_hull_case(ctx, "convex13");
1663 test_convex_hull_case(ctx, "convex14");
1664 test_convex_hull_case(ctx, "convex15");
1665
1666 for (i = 0; i < ARRAY_SIZE(convex_hull_tests)(sizeof(convex_hull_tests)/sizeof(*convex_hull_tests)); ++i) {
1667 isl_setisl_map *set1, *set2;
1668 int equal;
1669
1670 set1 = isl_set_read_from_str(ctx, convex_hull_tests[i].set);
1671 set2 = isl_set_read_from_str(ctx, convex_hull_tests[i].hull);
1672 set1 = isl_set_from_basic_set(isl_set_convex_hull(set1));
1673 equal = isl_set_is_equal(set1, set2);
1674 isl_set_free(set1);
1675 isl_set_free(set2);
1676
1677 if (equal < 0)
1678 return -1;
1679 if (!equal)
1680 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected convex hull"
, "polly/lib/External/isl/isl_test.c", 1681); return -1; } while
(0)
1681 "unexpected convex hull", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected convex hull"
, "polly/lib/External/isl/isl_test.c", 1681); return -1; } while
(0)
;
1682 }
1683
1684 ctx->opt->convex = orig_convex;
1685
1686 return 0;
1687}
1688
1689static int test_convex_hull(isl_ctx *ctx)
1690{
1691 if (test_convex_hull_algo(ctx, ISL_CONVEX_HULL_FM1) < 0)
1692 return -1;
1693 if (test_convex_hull_algo(ctx, ISL_CONVEX_HULL_WRAP0) < 0)
1694 return -1;
1695 return 0;
1696}
1697
1698/* Check that computing the gist of "map" with respect to "context"
1699 * does not make any copy of "map" get marked empty.
1700 * Earlier versions of isl would end up doing that.
1701 */
1702static isl_stat test_gist_empty_pair(isl_ctx *ctx, const char *map,
1703 const char *context)
1704{
1705 isl_map *m1, *m2, *m3;
1706 isl_bool empty_before, empty_after;
1707
1708 m1 = isl_map_read_from_str(ctx, map);
1709 m2 = isl_map_read_from_str(ctx, context);
1710 m3 = isl_map_copy(m1);
1711 empty_before = isl_map_is_empty(m3);
1712 m1 = isl_map_gist(m1, m2);
1713 empty_after = isl_map_is_empty(m3);
1714 isl_map_free(m1);
1715 isl_map_free(m3);
1716
1717 if (empty_before < 0 || empty_after < 0)
1718 return isl_stat_error;
1719 if (empty_before)
1720 isl_die(ctx, isl_error_unknown, "map should not be empty",do { isl_handle_error(ctx, isl_error_unknown, "map should not be empty"
, "polly/lib/External/isl/isl_test.c", 1721); return isl_stat_error
; } while (0)
1721 return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "map should not be empty"
, "polly/lib/External/isl/isl_test.c", 1721); return isl_stat_error
; } while (0)
;
1722 if (empty_after)
1723 isl_die(ctx, isl_error_unknown, "map should still not be empty",do { isl_handle_error(ctx, isl_error_unknown, "map should still not be empty"
, "polly/lib/External/isl/isl_test.c", 1724); return isl_stat_error
; } while (0)
1724 return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "map should still not be empty"
, "polly/lib/External/isl/isl_test.c", 1724); return isl_stat_error
; } while (0)
;
1725
1726 return isl_stat_ok;
1727}
1728
1729/* Check that computing a gist does not make any copy of the input
1730 * get marked empty.
1731 * Earlier versions of isl would end up doing that on some pairs of inputs.
1732 */
1733static isl_stat test_gist_empty(isl_ctx *ctx)
1734{
1735 const char *map, *context;
1736
1737 map = "{ [] -> [a, b, c] : 2b = 1 + a }";
1738 context = "{ [] -> [a, b, c] : 2c = 2 + a }";
1739 if (test_gist_empty_pair(ctx, map, context) < 0)
1740 return isl_stat_error;
1741 map = "{ [] -> [0, 0] }";
1742 context = "{ [] -> [a, b] : a > b }";
1743 if (test_gist_empty_pair(ctx, map, context) < 0)
1744 return isl_stat_error;
1745
1746 return isl_stat_ok;
1747}
1748
1749/* Inputs to isl_map_plain_gist_basic_map, along with the expected output.
1750 */
1751struct {
1752 const char *map;
1753 const char *context;
1754 const char *gist;
1755} plain_gist_tests[] = {
1756 { "{ [i] -> [j] : i >= 1 and j >= 1 or i >= 2 and j <= 10 }",
1757 "{ [i] -> [j] : i >= 1 }",
1758 "{ [i] -> [j] : j >= 1 or i >= 2 and j <= 10 }" },
1759 { "{ [n] -> [i,j,k] : (i mod 3 = 2 and j mod 4 = 2) or "
1760 "(j mod 4 = 2 and k mod 6 = n) }",
1761 "{ [n] -> [i,j,k] : j mod 4 = 2 }",
1762 "{ [n] -> [i,j,k] : (i mod 3 = 2) or (k mod 6 = n) }" },
1763 { "{ [i] -> [j] : i > j and (exists a,b : i <= 2a + 5b <= 2) }",
1764 "{ [i] -> [j] : i > j }",
1765 "{ [i] -> [j] : exists a,b : i <= 2a + 5b <= 2 }" },
1766};
1767
1768/* Basic tests for isl_map_plain_gist_basic_map.
1769 */
1770static int test_plain_gist(isl_ctx *ctx)
1771{
1772 int i;
1773
1774 for (i = 0; i < ARRAY_SIZE(plain_gist_tests)(sizeof(plain_gist_tests)/sizeof(*plain_gist_tests)); ++i) {
1775 const char *str;
1776 int equal;
1777 isl_map *map, *gist;
1778 isl_basic_map *context;
1779
1780 map = isl_map_read_from_str(ctx, plain_gist_tests[i].map);
1781 str = plain_gist_tests[i].context;
1782 context = isl_basic_map_read_from_str(ctx, str);
1783 map = isl_map_plain_gist_basic_map(map, context);
1784 gist = isl_map_read_from_str(ctx, plain_gist_tests[i].gist);
1785 equal = isl_map_is_equal(map, gist);
1786 isl_map_free(map);
1787 isl_map_free(gist);
1788 if (equal < 0)
1789 return -1;
1790 if (!equal)
1791 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "incorrect gist result"
, "polly/lib/External/isl/isl_test.c", 1792); return -1; } while
(0)
1792 "incorrect gist result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "incorrect gist result"
, "polly/lib/External/isl/isl_test.c", 1792); return -1; } while
(0)
;
1793 }
1794
1795 return 0;
1796}
1797
1798/* Inputs for isl_basic_set_gist tests that are expected to fail.
1799 */
1800struct {
1801 const char *set;
1802 const char *context;
1803} gist_fail_tests[] = {
1804 { "{ [i] : exists (e0, e1: 3e1 >= 1 + 2e0 and "
1805 "8e1 <= -1 + 5i - 5e0 and 2e1 >= 1 + 2i - 5e0) }",
1806 "{ [i] : i >= 0 }" },
1807};
1808
1809/* Check that isl_basic_set_gist fails (gracefully) when expected.
1810 * In particular, the user should be able to recover from the failure.
1811 */
1812static isl_stat test_gist_fail(struct isl_ctx *ctx)
1813{
1814 int i, n;
1815 int on_error;
1816
1817 on_error = isl_options_get_on_error(ctx);
1818 isl_options_set_on_error(ctx, ISL_ON_ERROR_CONTINUE1);
1819 n = ARRAY_SIZE(gist_fail_tests)(sizeof(gist_fail_tests)/sizeof(*gist_fail_tests));
1820 for (i = 0; i < n; ++i) {
1821 const char *str;
1822 isl_basic_setisl_basic_map *bset, *context;
1823
1824 bset = isl_basic_set_read_from_str(ctx, gist_fail_tests[i].set);
1825 str = gist_fail_tests[i].context;
1826 context = isl_basic_set_read_from_str(ctx, str);
1827 bset = isl_basic_set_gist(bset, context);
1828 isl_basic_set_free(bset);
1829 if (bset)
1830 break;
1831 }
1832 isl_options_set_on_error(ctx, on_error);
1833 if (i < n)
1834 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "operation not expected to succeed"
, "polly/lib/External/isl/isl_test.c", 1836); return isl_stat_error
; } while (0)
1835 "operation not expected to succeed",do { isl_handle_error(ctx, isl_error_unknown, "operation not expected to succeed"
, "polly/lib/External/isl/isl_test.c", 1836); return isl_stat_error
; } while (0)
1836 return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "operation not expected to succeed"
, "polly/lib/External/isl/isl_test.c", 1836); return isl_stat_error
; } while (0)
;
1837
1838 return isl_stat_ok;
1839}
1840
1841struct {
1842 const char *set;
1843 const char *context;
1844 const char *gist;
1845} gist_tests[] = {
1846 { "{ [1, -1, 3] }",
1847 "{ [1, b, 2 - b] : -1 <= b <= 2 }",
1848 "{ [a, -1, c] }" },
1849 { "{ [a, b, c] : a <= 15 and a >= 1 }",
1850 "{ [a, b, c] : exists (e0 = floor((-1 + a)/16): a >= 1 and "
1851 "c <= 30 and 32e0 >= -62 + 2a + 2b - c and b >= 0) }",
1852 "{ [a, b, c] : a <= 15 }" },
1853 { "{ : }", "{ : 1 = 0 }", "{ : }" },
1854 { "{ : 1 = 0 }", "{ : 1 = 0 }", "{ : }" },
1855 { "[M] -> { [x] : exists (e0 = floor((-2 + x)/3): 3e0 = -2 + x) }",
1856 "[M] -> { [3M] }" , "[M] -> { [x] : 1 = 0 }" },
1857 { "{ [m, n, a, b] : a <= 2147 + n }",
1858 "{ [m, n, a, b] : (m >= 1 and n >= 1 and a <= 2148 - m and "
1859 "b <= 2148 - n and b >= 0 and b >= 2149 - n - a) or "
1860 "(n >= 1 and a >= 0 and b <= 2148 - n - a and "
1861 "b >= 0) }",
1862 "{ [m, n, ku, kl] }" },
1863 { "{ [a, a, b] : a >= 10 }",
1864 "{ [a, b, c] : c >= a and c <= b and c >= 2 }",
1865 "{ [a, a, b] : a >= 10 }" },
1866 { "{ [i, j] : i >= 0 and i + j >= 0 }", "{ [i, j] : i <= 0 }",
1867 "{ [0, j] : j >= 0 }" },
1868 /* Check that no constraints on i6 are introduced in the gist */
1869 { "[t1] -> { [i4, i6] : exists (e0 = floor((1530 - 4t1 - 5i4)/20): "
1870 "20e0 <= 1530 - 4t1 - 5i4 and 20e0 >= 1511 - 4t1 - 5i4 and "
1871 "5e0 <= 381 - t1 and i4 <= 1) }",
1872 "[t1] -> { [i4, i6] : exists (e0 = floor((-t1 + i6)/5): "
1873 "5e0 = -t1 + i6 and i6 <= 6 and i6 >= 3) }",
1874 "[t1] -> { [i4, i6] : exists (e0 = floor((1530 - 4t1 - 5i4)/20): "
1875 "i4 <= 1 and 5e0 <= 381 - t1 and 20e0 <= 1530 - 4t1 - 5i4 and "
1876 "20e0 >= 1511 - 4t1 - 5i4) }" },
1877 /* Check that no constraints on i6 are introduced in the gist */
1878 { "[t1, t2] -> { [i4, i5, i6] : exists (e0 = floor((1 + i4)/2), "
1879 "e1 = floor((1530 - 4t1 - 5i4)/20), "
1880 "e2 = floor((-4t1 - 5i4 + 10*floor((1 + i4)/2))/20), "
1881 "e3 = floor((-1 + i4)/2): t2 = 0 and 2e3 = -1 + i4 and "
1882 "20e2 >= -19 - 4t1 - 5i4 + 10e0 and 5e2 <= 1 - t1 and "
1883 "2e0 <= 1 + i4 and 2e0 >= i4 and "
1884 "20e1 <= 1530 - 4t1 - 5i4 and "
1885 "20e1 >= 1511 - 4t1 - 5i4 and i4 <= 1 and "
1886 "5e1 <= 381 - t1 and 20e2 <= -4t1 - 5i4 + 10e0) }",
1887 "[t1, t2] -> { [i4, i5, i6] : exists (e0 = floor((-17 + i4)/2), "
1888 "e1 = floor((-t1 + i6)/5): 5e1 = -t1 + i6 and "
1889 "2e0 <= -17 + i4 and 2e0 >= -18 + i4 and "
1890 "10e0 <= -91 + 5i4 + 4i6 and "
1891 "10e0 >= -105 + 5i4 + 4i6) }",
1892 "[t1, t2] -> { [i4, i5, i6] : exists (e0 = floor((381 - t1)/5), "
1893 "e1 = floor((-1 + i4)/2): t2 = 0 and 2e1 = -1 + i4 and "
1894 "i4 <= 1 and 5e0 <= 381 - t1 and 20e0 >= 1511 - 4t1 - 5i4) }" },
1895 { "{ [0, 0, q, p] : -5 <= q <= 5 and p >= 0 }",
1896 "{ [a, b, q, p] : b >= 1 + a }",
1897 "{ [a, b, q, p] : false }" },
1898 { "[n] -> { [x] : x = n && x mod 32 = 0 }",
1899 "[n] -> { [x] : x mod 32 = 0 }",
1900 "[n] -> { [x = n] }" },
1901 { "{ [x] : x mod 6 = 0 }", "{ [x] : x mod 3 = 0 }",
1902 "{ [x] : x mod 2 = 0 }" },
1903 { "{ [x] : x mod 3200 = 0 }", "{ [x] : x mod 10000 = 0 }",
1904 "{ [x] : x mod 128 = 0 }" },
1905 { "{ [x] : x mod 3200 = 0 }", "{ [x] : x mod 10 = 0 }",
1906 "{ [x] : x mod 3200 = 0 }" },
1907 { "{ [a, b, c] : a mod 2 = 0 and a = c }",
1908 "{ [a, b, c] : b mod 2 = 0 and b = c }",
1909 "{ [a, b, c = a] }" },
1910 { "{ [a, b, c] : a mod 6 = 0 and a = c }",
1911 "{ [a, b, c] : b mod 2 = 0 and b = c }",
1912 "{ [a, b, c = a] : a mod 3 = 0 }" },
1913 { "{ [x] : 0 <= x <= 4 or 6 <= x <= 9 }",
1914 "{ [x] : 1 <= x <= 3 or 7 <= x <= 8 }",
1915 "{ [x] }" },
1916 { "{ [x,y] : x < 0 and 0 <= y <= 4 or x >= -2 and -x <= y <= 10 + x }",
1917 "{ [x,y] : 1 <= y <= 3 }",
1918 "{ [x,y] }" },
1919};
1920
1921/* Check that isl_set_gist behaves as expected.
1922 *
1923 * For the test cases in gist_tests, besides checking that the result
1924 * is as expected, also check that applying the gist operation does
1925 * not modify the input set (an earlier version of isl would do that) and
1926 * that the test case is consistent, i.e., that the gist has the same
1927 * intersection with the context as the input set.
1928 */
1929static int test_gist(struct isl_ctx *ctx)
1930{
1931 int i;
1932 const char *str;
1933 isl_basic_setisl_basic_map *bset1, *bset2;
1934 isl_map *map1, *map2;
1935 isl_bool equal;
1936 isl_size n_div;
1937
1938 for (i = 0; i < ARRAY_SIZE(gist_tests)(sizeof(gist_tests)/sizeof(*gist_tests)); ++i) {
1939 isl_bool equal_input, equal_intersection;
1940 isl_setisl_map *set1, *set2, *copy, *context;
1941
1942 set1 = isl_set_read_from_str(ctx, gist_tests[i].set);
1943 context = isl_set_read_from_str(ctx, gist_tests[i].context);
1944 copy = isl_set_copy(set1);
1945 set1 = isl_set_gist(set1, isl_set_copy(context));
1946 set2 = isl_set_read_from_str(ctx, gist_tests[i].gist);
1947 equal = isl_set_is_equal(set1, set2);
1948 isl_set_free(set1);
1949 set1 = isl_set_read_from_str(ctx, gist_tests[i].set);
1950 equal_input = isl_set_is_equal(set1, copy);
1951 isl_set_free(copy);
1952 set1 = isl_set_intersect(set1, isl_set_copy(context));
1953 set2 = isl_set_intersect(set2, context);
1954 equal_intersection = isl_set_is_equal(set1, set2);
1955 isl_set_free(set2);
1956 isl_set_free(set1);
1957 if (equal < 0 || equal_input < 0 || equal_intersection < 0)
1958 return -1;
1959 if (!equal)
1960 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "incorrect gist result"
, "polly/lib/External/isl/isl_test.c", 1961); return -1; } while
(0)
1961 "incorrect gist result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "incorrect gist result"
, "polly/lib/External/isl/isl_test.c", 1961); return -1; } while
(0)
;
1962 if (!equal_input)
1963 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "gist modified input"
, "polly/lib/External/isl/isl_test.c", 1964); return -1; } while
(0)
1964 "gist modified input", return -1)do { isl_handle_error(ctx, isl_error_unknown, "gist modified input"
, "polly/lib/External/isl/isl_test.c", 1964); return -1; } while
(0)
;
1965 if (!equal_input)
1966 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "inconsistent gist test case"
, "polly/lib/External/isl/isl_test.c", 1967); return -1; } while
(0)
1967 "inconsistent gist test case", return -1)do { isl_handle_error(ctx, isl_error_unknown, "inconsistent gist test case"
, "polly/lib/External/isl/isl_test.c", 1967); return -1; } while
(0)
;
1968 }
1969
1970 if (test_gist_fail(ctx) < 0)
1971 return -1;
1972
1973 str = "[p0, p2, p3, p5, p6, p10] -> { [] : "
1974 "exists (e0 = [(15 + p0 + 15p6 + 15p10)/16], e1 = [(p5)/8], "
1975 "e2 = [(p6)/128], e3 = [(8p2 - p5)/128], "
1976 "e4 = [(128p3 - p6)/4096]: 8e1 = p5 and 128e2 = p6 and "
1977 "128e3 = 8p2 - p5 and 4096e4 = 128p3 - p6 and p2 >= 0 and "
1978 "16e0 >= 16 + 16p6 + 15p10 and p2 <= 15 and p3 >= 0 and "
1979 "p3 <= 31 and p6 >= 128p3 and p5 >= 8p2 and p10 >= 0 and "
1980 "16e0 <= 15 + p0 + 15p6 + 15p10 and 16e0 >= p0 + 15p6 + 15p10 and "
1981 "p10 <= 15 and p10 <= -1 + p0 - p6) }";
1982 bset1 = isl_basic_set_read_from_str(ctx, str);
1983 str = "[p0, p2, p3, p5, p6, p10] -> { [] : exists (e0 = [(p5)/8], "
1984 "e1 = [(p6)/128], e2 = [(8p2 - p5)/128], "
1985 "e3 = [(128p3 - p6)/4096]: 8e0 = p5 and 128e1 = p6 and "
1986 "128e2 = 8p2 - p5 and 4096e3 = 128p3 - p6 and p5 >= -7 and "
1987 "p2 >= 0 and 8p2 <= -1 + p0 and p2 <= 15 and p3 >= 0 and "
1988 "p3 <= 31 and 128p3 <= -1 + p0 and p6 >= -127 and "
1989 "p5 <= -1 + p0 and p6 <= -1 + p0 and p6 >= 128p3 and "
1990 "p0 >= 1 and p5 >= 8p2 and p10 >= 0 and p10 <= 15 ) }";
1991 bset2 = isl_basic_set_read_from_str(ctx, str);
1992 bset1 = isl_basic_set_gist(bset1, bset2);
1993 assert(bset1 && bset1->n_div == 0)((void) sizeof ((bset1 && bset1->n_div == 0) ? 1 :
0), __extension__ ({ if (bset1 && bset1->n_div ==
0) ; else __assert_fail ("bset1 && bset1->n_div == 0"
, "polly/lib/External/isl/isl_test.c", 1993, __extension__ __PRETTY_FUNCTION__
); }))
;
1994 isl_basic_set_free(bset1);
1995
1996 /* Check that the integer divisions of the second disjunct
1997 * do not spread to the first disjunct.
1998 */
1999 str = "[t1] -> { S_0[] -> A[o0] : (exists (e0 = [(-t1 + o0)/16]: "
2000 "16e0 = -t1 + o0 and o0 >= 0 and o0 <= 15 and t1 >= 0)) or "
2001 "(exists (e0 = [(-1 + t1)/16], "
2002 "e1 = [(-16 + t1 - 16e0)/4294967296]: "
2003 "4294967296e1 = -16 + t1 - o0 - 16e0 and "
2004 "16e0 <= -1 + t1 and 16e0 >= -16 + t1 and o0 >= 0 and "
2005 "o0 <= 4294967295 and t1 <= -1)) }";
2006 map1 = isl_map_read_from_str(ctx, str);
2007 str = "[t1] -> { S_0[] -> A[o0] : t1 >= 0 and t1 <= 4294967295 }";
2008 map2 = isl_map_read_from_str(ctx, str);
2009 map1 = isl_map_gist(map1, map2);
2010 if (!map1)
2011 return -1;
2012 if (map1->n != 1)
2013 isl_die(ctx, isl_error_unknown, "expecting single disjunct",do { isl_handle_error(ctx, isl_error_unknown, "expecting single disjunct"
, "polly/lib/External/isl/isl_test.c", 2014); isl_map_free(map1
); return -1; } while (0)
2014 isl_map_free(map1); return -1)do { isl_handle_error(ctx, isl_error_unknown, "expecting single disjunct"
, "polly/lib/External/isl/isl_test.c", 2014); isl_map_free(map1
); return -1; } while (0)
;
2015 n_div = isl_basic_map_dim(map1->p[0], isl_dim_div);
2016 isl_map_free(map1);
2017 if (n_div < 0)
2018 return -1;
2019 if (n_div != 1)
2020 isl_die(ctx, isl_error_unknown, "expecting single div",do { isl_handle_error(ctx, isl_error_unknown, "expecting single div"
, "polly/lib/External/isl/isl_test.c", 2021); return -1; } while
(0)
2021 return -1)do { isl_handle_error(ctx, isl_error_unknown, "expecting single div"
, "polly/lib/External/isl/isl_test.c", 2021); return -1; } while
(0)
;
2022
2023 if (test_gist_empty(ctx) < 0)
2024 return -1;
2025 if (test_plain_gist(ctx) < 0)
2026 return -1;
2027
2028 return 0;
2029}
2030
2031int test_coalesce_set(isl_ctx *ctx, const char *str, int check_one)
2032{
2033 isl_setisl_map *set, *set2;
2034 int equal;
2035 int one;
2036
2037 set = isl_set_read_from_str(ctx, str);
2038 set = isl_set_coalesce(set);
2039 set2 = isl_set_read_from_str(ctx, str);
2040 equal = isl_set_is_equal(set, set2);
2041 one = set && set->n == 1;
2042 isl_set_free(set);
2043 isl_set_free(set2);
2044
2045 if (equal < 0)
2046 return -1;
2047 if (!equal)
2048 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "coalesced set not equal to input"
, "polly/lib/External/isl/isl_test.c", 2049); return -1; } while
(0)
2049 "coalesced set not equal to input", return -1)do { isl_handle_error(ctx, isl_error_unknown, "coalesced set not equal to input"
, "polly/lib/External/isl/isl_test.c", 2049); return -1; } while
(0)
;
2050 if (check_one && !one)
2051 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "coalesced set should not be a union"
, "polly/lib/External/isl/isl_test.c", 2052); return -1; } while
(0)
2052 "coalesced set should not be a union", return -1)do { isl_handle_error(ctx, isl_error_unknown, "coalesced set should not be a union"
, "polly/lib/External/isl/isl_test.c", 2052); return -1; } while
(0)
;
2053
2054 return 0;
2055}
2056
2057/* Inputs for coalescing tests with unbounded wrapping.
2058 * "str" is a string representation of the input set.
2059 * "single_disjunct" is set if we expect the result to consist of
2060 * a single disjunct.
2061 */
2062struct {
2063 int single_disjunct;
2064 const char *str;
2065} coalesce_unbounded_tests[] = {
2066 { 1, "{ [x,y,z] : y + 2 >= 0 and x - y + 1 >= 0 and "
2067 "-x - y + 1 >= 0 and -3 <= z <= 3;"
2068 "[x,y,z] : -x+z + 20 >= 0 and -x-z + 20 >= 0 and "
2069 "x-z + 20 >= 0 and x+z + 20 >= 0 and "
2070 "-10 <= y <= 0}" },
2071 { 1, "{ [x,y] : 0 <= x,y <= 10; [5,y]: 4 <= y <= 11 }" },
2072 { 1, "{ [x,0,0] : -5 <= x <= 5; [0,y,1] : -5 <= y <= 5 }" },
2073 { 1, "{ [x,y] : 0 <= x <= 10 and 0 >= y >= -1 and x+y >= 0; [0,1] }" },
2074 { 1, "{ [x,y] : (0 <= x,y <= 4) or (2 <= x,y <= 5 and x + y <= 9) }" },
2075 { 0, "{ [x, y, z] : 0 <= x,y,z <= 100 and 0 < z <= 2 + 2x + 2y; "
2076 "[x, y, 0] : x,y <= 100 and y <= 9 + 11x and x <= 9 + 11y }" },
2077 { 1, "{ [0:1, 0:1]; [0, 2:3] }" },
2078 { 1, "{ [0:1, 0:1]; [0, 2:3]; [1, -2:-1] }" },
2079 { 1, "{ [0:3, 0:1]; [1:2, 2:5] }" },
2080 { 1, "{ [0:3, 0:1]; [0:2, 2:5] }" },
2081 { 1, "{ [0:3, 0:1]; [1:3, 2:5] }" },
2082 { 0, "{ [0:3, 0:1]; [1:4, 2:5] }" },
2083 { 0, "{ [0:3, 0:1]; [1:5, 2:5] }" },
2084};
2085
2086/* Test the functionality of isl_set_coalesce with the bounded wrapping
2087 * option turned off.
2088 */
2089int test_coalesce_unbounded_wrapping(isl_ctx *ctx)
2090{
2091 int i;
2092 int r = 0;
2093 int bounded;
2094
2095 bounded = isl_options_get_coalesce_bounded_wrapping(ctx);
2096 isl_options_set_coalesce_bounded_wrapping(ctx, 0);
2097
2098 for (i = 0; i < ARRAY_SIZE(coalesce_unbounded_tests)(sizeof(coalesce_unbounded_tests)/sizeof(*coalesce_unbounded_tests
))
; ++i) {
2099 const char *str = coalesce_unbounded_tests[i].str;
2100 int check_one = coalesce_unbounded_tests[i].single_disjunct;
2101 if (test_coalesce_set(ctx, str, check_one) >= 0)
2102 continue;
2103 r = -1;
2104 break;
2105 }
2106
2107 isl_options_set_coalesce_bounded_wrapping(ctx, bounded);
2108
2109 return r;
2110}
2111
2112/* Inputs for coalescing tests.
2113 * "str" is a string representation of the input set.
2114 * "single_disjunct" is set if we expect the result to consist of
2115 * a single disjunct.
2116 */
2117struct {
2118 int single_disjunct;
2119 const char *str;
2120} coalesce_tests[] = {
2121 { 1, "{[x,y]: x >= 0 & x <= 10 & y >= 0 & y <= 10 or "
2122 "y >= x & x >= 2 & 5 >= y }" },
2123 { 1, "{[x,y]: y >= 0 & 2x + y <= 30 & y <= 10 & x >= 0 or "
2124 "x + y >= 10 & y <= x & x + y <= 20 & y >= 0}" },
2125 { 0, "{[x,y]: y >= 0 & 2x + y <= 30 & y <= 10 & x >= 0 or "
2126 "x + y >= 10 & y <= x & x + y <= 19 & y >= 0}" },
2127 { 1, "{[x,y]: y >= 0 & x <= 5 & y <= x or "
2128 "y >= 0 & x >= 6 & x <= 10 & y <= x}" },
2129 { 0, "{[x,y]: y >= 0 & x <= 5 & y <= x or "
2130 "y >= 0 & x >= 7 & x <= 10 & y <= x}" },
2131 { 0, "{[x,y]: y >= 0 & x <= 5 & y <= x or "
2132 "y >= 0 & x >= 6 & x <= 10 & y + 1 <= x}" },
2133 { 1, "{[x,y]: y >= 0 & x <= 5 & y <= x or y >= 0 & x = 6 & y <= 6}" },
2134 { 0, "{[x,y]: y >= 0 & x <= 5 & y <= x or y >= 0 & x = 7 & y <= 6}" },
2135 { 1, "{[x,y]: y >= 0 & x <= 5 & y <= x or y >= 0 & x = 6 & y <= 5}" },
2136 { 0, "{[x,y]: y >= 0 & x <= 5 & y <= x or y >= 0 & x = 6 & y <= 7}" },
2137 { 1, "[n] -> { [i] : i = 1 and n >= 2 or 2 <= i and i <= n }" },
2138 { 0, "{[x,y] : x >= 0 and y >= 0 or 0 <= y and y <= 5 and x = -1}" },
2139 { 1, "[n] -> { [i] : 1 <= i and i <= n - 1 or 2 <= i and i <= n }" },
2140 { 0, "[n] -> { [[i0] -> [o0]] : exists (e0 = [(i0)/4], e1 = [(o0)/4], "
2141 "e2 = [(n)/2], e3 = [(-2 + i0)/4], e4 = [(-2 + o0)/4], "
2142 "e5 = [(-2n + i0)/4]: 2e2 = n and 4e3 = -2 + i0 and "
2143 "4e4 = -2 + o0 and i0 >= 8 + 2n and o0 >= 2 + i0 and "
2144 "o0 <= 56 + 2n and o0 <= -12 + 4n and i0 <= 57 + 2n and "
2145 "i0 <= -11 + 4n and o0 >= 6 + 2n and 4e0 <= i0 and "
2146 "4e0 >= -3 + i0 and 4e1 <= o0 and 4e1 >= -3 + o0 and "
2147 "4e5 <= -2n + i0 and 4e5 >= -3 - 2n + i0);"
2148 "[[i0] -> [o0]] : exists (e0 = [(i0)/4], e1 = [(o0)/4], "
2149 "e2 = [(n)/2], e3 = [(-2 + i0)/4], e4 = [(-2 + o0)/4], "
2150 "e5 = [(-2n + i0)/4]: 2e2 = n and 4e3 = -2 + i0 and "
2151 "4e4 = -2 + o0 and 2e0 >= 3 + n and e0 <= -4 + n and "
2152 "2e0 <= 27 + n and e1 <= -4 + n and 2e1 <= 27 + n and "
2153 "2e1 >= 2 + n and e1 >= 1 + e0 and i0 >= 7 + 2n and "
2154 "i0 <= -11 + 4n and i0 <= 57 + 2n and 4e0 <= -2 + i0 and "
2155 "4e0 >= -3 + i0 and o0 >= 6 + 2n and o0 <= -11 + 4n and "
2156 "o0 <= 57 + 2n and 4e1 <= -2 + o0 and 4e1 >= -3 + o0 and "
2157 "4e5 <= -2n + i0 and 4e5 >= -3 - 2n + i0 ) }" },
2158 { 0, "[n, m] -> { [o0, o2, o3] : (o3 = 1 and o0 >= 1 + m and "
2159 "o0 <= n + m and o2 <= m and o0 >= 2 + n and o2 >= 3) or "
2160 "(o0 >= 2 + n and o0 >= 1 + m and o0 <= n + m and n >= 1 and "
2161 "o3 <= -1 + o2 and o3 >= 1 - m + o2 and o3 >= 2 and o3 <= n) }" },
2162 { 0, "[M, N] -> { [[i0, i1, i2, i3, i4, i5, i6] -> "
2163 "[o0, o1, o2, o3, o4, o5, o6]] : "
2164 "(o6 <= -4 + 2M - 2N + i0 + i1 - i2 + i6 - o0 - o1 + o2 and "
2165 "o3 <= -2 + i3 and o6 >= 2 + i0 + i3 + i6 - o0 - o3 and "
2166 "o6 >= 2 - M + N + i3 + i4 + i6 - o3 - o4 and o0 <= -1 + i0 and "
2167 "o4 >= 4 - 3M + 3N - i0 - i1 + i2 + 2i3 + i4 + o0 + o1 - o2 - 2o3 "
2168 "and o6 <= -3 + 2M - 2N + i3 + i4 - i5 + i6 - o3 - o4 + o5 and "
2169 "2o6 <= -5 + 5M - 5N + 2i0 + i1 - i2 - i5 + 2i6 - 2o0 - o1 + o2 + o5 "
2170 "and o6 >= 2i0 + i1 + i6 - 2o0 - o1 and "
2171 "3o6 <= -5 + 4M - 4N + 2i0 + i1 - i2 + 2i3 + i4 - i5 + 3i6 "
2172 "- 2o0 - o1 + o2 - 2o3 - o4 + o5) or "
2173 "(N >= 2 and o3 <= -1 + i3 and o0 <= -1 + i0 and "
2174 "o6 >= i3 + i6 - o3 and M >= 0 and "
2175 "2o6 >= 1 + i0 + i3 + 2i6 - o0 - o3 and "
2176 "o6 >= 1 - M + i0 + i6 - o0 and N >= 2M and o6 >= i0 + i6 - o0) }" },
2177 { 0, "[M, N] -> { [o0] : (o0 = 0 and M >= 1 and N >= 2) or "
2178 "(o0 = 0 and M >= 1 and N >= 2M and N >= 2 + M) or "
2179 "(o0 = 0 and M >= 2 and N >= 3) or "
2180 "(M = 0 and o0 = 0 and N >= 3) }" },
2181 { 0, "{ [i0, i1, i2, i3] : (i1 = 10i0 and i0 >= 1 and 10i0 <= 100 and "
2182 "i3 <= 9 + 10 i2 and i3 >= 1 + 10i2 and i3 >= 0) or "
2183 "(i1 <= 9 + 10i0 and i1 >= 1 + 10i0 and i2 >= 0 and "
2184 "i0 >= 0 and i1 <= 100 and i3 <= 9 + 10i2 and i3 >= 1 + 10i2) }" },
2185 { 0, "[M] -> { [i1] : (i1 >= 2 and i1 <= M) or (i1 = M and M >= 1) }" },
2186 { 0, "{[x,y] : x,y >= 0; [x,y] : 10 <= x <= 20 and y >= -1 }" },
2187 { 1, "{ [x, y] : (x >= 1 and y >= 1 and x <= 2 and y <= 2) or "
2188 "(y = 3 and x = 1) }" },
2189 { 1, "[M] -> { [i0, i1, i2, i3, i4] : (i1 >= 3 and i4 >= 2 + i2 and "
2190 "i2 >= 2 and i0 >= 2 and i3 >= 1 + i2 and i0 <= M and "
2191 "i1 <= M and i3 <= M and i4 <= M) or "
2192 "(i1 >= 2 and i4 >= 1 + i2 and i2 >= 2 and i0 >= 2 and "
2193 "i3 >= 1 + i2 and i0 <= M and i1 <= -1 + M and i3 <= M and "
2194 "i4 <= -1 + M) }" },
2195 { 1, "{ [x, y] : (x >= 0 and y >= 0 and x <= 10 and y <= 10) or "
2196 "(x >= 1 and y >= 1 and x <= 11 and y <= 11) }" },
2197 { 0, "{[x,0] : x >= 0; [x,1] : x <= 20}" },
2198 { 1, "{ [x, 1 - x] : 0 <= x <= 1; [0,0] }" },
2199 { 1, "{ [0,0]; [i,i] : 1 <= i <= 10 }" },
2200 { 0, "{ [0,0]; [i,j] : 1 <= i,j <= 10 }" },
2201 { 1, "{ [0,0]; [i,2i] : 1 <= i <= 10 }" },
2202 { 0, "{ [0,0]; [i,2i] : 2 <= i <= 10 }" },
2203 { 0, "{ [1,0]; [i,2i] : 1 <= i <= 10 }" },
2204 { 0, "{ [0,1]; [i,2i] : 1 <= i <= 10 }" },
2205 { 0, "{ [a, b] : exists e : 2e = a and "
2206 "a >= 0 and (a <= 3 or (b <= 0 and b >= -4 + a)) }" },
2207 { 0, "{ [i, j, i', j'] : i <= 2 and j <= 2 and "
2208 "j' >= -1 + 2i + j - 2i' and i' <= -1 + i and "
2209 "j >= 1 and j' <= i + j - i' and i >= 1; "
2210 "[1, 1, 1, 1] }" },
2211 { 1, "{ [i,j] : exists a,b : i = 2a and j = 3b; "
2212 "[i,j] : exists a : j = 3a }" },
2213 { 1, "{ [a, b, c] : (c <= 7 - b and b <= 1 and b >= 0 and "
2214 "c >= 3 + b and b <= 3 + 8a and b >= -26 + 8a and "
2215 "a >= 3) or "
2216 "(b <= 1 and c <= 7 and b >= 0 and c >= 4 + b and "
2217 "b <= 3 + 8a and b >= -26 + 8a and a >= 3) }" },
2218 { 1, "{ [a, 0, c] : c >= 1 and c <= 29 and c >= -1 + 8a and "
2219 "c <= 6 + 8a and a >= 3; "
2220 "[a, -1, c] : c >= 1 and c <= 30 and c >= 8a and "
2221 "c <= 7 + 8a and a >= 3 and a <= 4 }" },
2222 { 1, "{ [x,y] : 0 <= x <= 2 and y >= 0 and x + 2y <= 4; "
2223 "[x,0] : 3 <= x <= 4 }" },
2224 { 1, "{ [x,y] : 0 <= x <= 3 and y >= 0 and x + 3y <= 6; "
2225 "[x,0] : 4 <= x <= 5 }" },
2226 { 0, "{ [x,y] : 0 <= x <= 2 and y >= 0 and x + 2y <= 4; "
2227 "[x,0] : 3 <= x <= 5 }" },
2228 { 0, "{ [x,y] : 0 <= x <= 2 and y >= 0 and x + y <= 4; "
2229 "[x,0] : 3 <= x <= 4 }" },
2230 { 1, "{ [i0, i1] : i0 <= 122 and i0 >= 1 and 128i1 >= -249 + i0 and "
2231 "i1 <= 0; "
2232 "[i0, 0] : i0 >= 123 and i0 <= 124 }" },
2233 { 1, "{ [0,0]; [1,1] }" },
2234 { 1, "[n] -> { [k] : 16k <= -1 + n and k >= 1; [0] : n >= 2 }" },
2235 { 1, "{ [k, ii, k - ii] : ii >= -6 + k and ii <= 6 and ii >= 1 and "
2236 "ii <= k;"
2237 "[k, 0, k] : k <= 6 and k >= 1 }" },
2238 { 1, "{ [i,j] : i = 4 j and 0 <= i <= 100;"
2239 "[i,j] : 1 <= i <= 100 and i >= 4j + 1 and i <= 4j + 2 }" },
2240 { 1, "{ [x,y] : x % 2 = 0 and y % 2 = 0; [x,x] : x % 2 = 0 }" },
2241 { 1, "[n] -> { [1] : n >= 0;"
2242 "[x] : exists (e0 = floor((x)/2): x >= 2 and "
2243 "2e0 >= -1 + x and 2e0 <= x and 2e0 <= n) }" },
2244 { 1, "[n] -> { [x, y] : exists (e0 = floor((x)/2), e1 = floor((y)/3): "
2245 "3e1 = y and x >= 2 and 2e0 >= -1 + x and "
2246 "2e0 <= x and 2e0 <= n);"
2247 "[1, y] : exists (e0 = floor((y)/3): 3e0 = y and "
2248 "n >= 0) }" },
2249 { 1, "[t1] -> { [i0] : (exists (e0 = floor((63t1)/64): "
2250 "128e0 >= -134 + 127t1 and t1 >= 2 and "
2251 "64e0 <= 63t1 and 64e0 >= -63 + 63t1)) or "
2252 "t1 = 1 }" },
2253 { 1, "{ [i, i] : exists (e0 = floor((1 + 2i)/3): 3e0 <= 2i and "
2254 "3e0 >= -1 + 2i and i <= 9 and i >= 1);"
2255 "[0, 0] }" },
2256 { 1, "{ [t1] : exists (e0 = floor((-11 + t1)/2): 2e0 = -11 + t1 and "
2257 "t1 >= 13 and t1 <= 16);"
2258 "[t1] : t1 <= 15 and t1 >= 12 }" },
2259 { 1, "{ [x,y] : x = 3y and 0 <= y <= 2; [-3,-1] }" },
2260 { 1, "{ [x,y] : 2x = 3y and 0 <= y <= 4; [-3,-2] }" },
2261 { 0, "{ [x,y] : 2x = 3y and 0 <= y <= 4; [-2,-2] }" },
2262 { 0, "{ [x,y] : 2x = 3y and 0 <= y <= 4; [-3,-1] }" },
2263 { 1, "{ [i] : exists j : i = 4 j and 0 <= i <= 100;"
2264 "[i] : exists j : 1 <= i <= 100 and i >= 4j + 1 and "
2265 "i <= 4j + 2 }" },
2266 { 1, "{ [c0] : (exists (e0 : c0 - 1 <= 3e0 <= c0)) or "
2267 "(exists (e0 : 3e0 = -2 + c0)) }" },
2268 { 0, "[n, b0, t0] -> "
2269 "{ [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] : "
2270 "(exists (e0 = floor((-32b0 + i4)/1048576), "
2271 "e1 = floor((i8)/32): 1048576e0 = -32b0 + i4 and 32e1 = i8 and "
2272 "n <= 2147483647 and b0 <= 32767 and b0 >= 0 and "
2273 "32b0 <= -2 + n and t0 <= 31 and t0 >= 0 and i0 >= 8 + n and "
2274 "3i4 <= -96 + 3t0 + i0 and 3i4 >= -95 - n + 3t0 + i0 and "
2275 "i8 >= -157 + i0 - 4i4 and i8 >= 0 and "
2276 "i8 <= -33 + i0 - 4i4 and 3i8 <= -91 + 4n - i0)) or "
2277 "(exists (e0 = floor((-32b0 + i4)/1048576), "
2278 "e1 = floor((i8)/32): 1048576e0 = -32b0 + i4 and 32e1 = i8 and "
2279 "n <= 2147483647 and b0 <= 32767 and b0 >= 0 and "
2280 "32b0 <= -2 + n and t0 <= 31 and t0 >= 0 and i0 <= 7 + n and "
2281 "4i4 <= -3 + i0 and 3i4 <= -96 + 3t0 + i0 and "
2282 "3i4 >= -95 - n + 3t0 + i0 and i8 >= -157 + i0 - 4i4 and "
2283 "i8 >= 0 and i8 <= -4 + i0 - 3i4 and i8 <= -41 + i0));"
2284 "[i0, i1, i2, i3, 0, i5, i6, i7, i8, i9, i10, i11, i12] : "
2285 "(exists (e0 = floor((i8)/32): b0 = 0 and 32e0 = i8 and "
2286 "n <= 2147483647 and t0 <= 31 and t0 >= 0 and i0 >= 11 and "
2287 "i0 >= 96 - 3t0 and i0 <= 95 + n - 3t0 and i0 <= 7 + n and "
2288 "i8 >= -40 + i0 and i8 <= -10 + i0)) }" },
2289 { 0, "{ [i0, i1, i2] : "
2290 "(exists (e0, e1 = floor((i0)/32), e2 = floor((i1)/32): "
2291 "32e1 = i0 and 32e2 = i1 and i1 >= -31 + i0 and "
2292 "i1 <= 31 + i0 and i2 >= -30 + i0 and i2 >= -30 + i1 and "
2293 "32e0 >= -30 + i0 and 32e0 >= -30 + i1 and "
2294 "32e0 >= -31 + i2 and 32e0 <= 30 + i2 and 32e0 <= 31 + i1 and "
2295 "32e0 <= 31 + i0)) or "
2296 "i0 >= 0 }" },
2297 { 1, "{ [a, b, c] : 2b = 1 + a and 2c = 2 + a; [0, 0, 0] }" },
2298 { 1, "{ [a, a, b, c] : 32*floor((a)/32) = a and 2*floor((b)/2) = b and "
2299 "2*floor((c)/2) = c and 0 <= a <= 192;"
2300 "[224, 224, b, c] : 2*floor((b)/2) = b and 2*floor((c)/2) = c }"
2301 },
2302 { 1, "[n] -> { [a,b] : (exists e : 1 <= a <= 7e and 9e <= b <= n) or "
2303 "(0 <= a <= b <= n) }" },
2304 { 1, "{ [a, b] : 0 <= a <= 2 and b >= 0 and "
2305 "((0 < b <= 13) or (2*floor((a + b)/2) >= -5 + a + 2b)) }" },
2306 { 1, "{ [a] : (2 <= a <= 5) or (a mod 2 = 1 and 1 <= a <= 5) }" },
2307 { 1, "{ [a, b, c] : (b = -1 + a and 0 < a <= 3 and "
2308 "9*floor((-4a + 2c)/9) <= -3 - 4a + 2c) or "
2309 "(exists (e0 = floor((-16 + 2c)/9): a = 4 and "
2310 "b = 3 and 9e0 <= -19 + 2c)) }" },
2311 { 1, "{ [a, b, c] : (b = -1 + a and 0 < a <= 3 and "
2312 "9*floor((-4a + 2c)/9) <= -3 - 4a + 2c) or "
2313 "(a = 4 and b = 3 and "
2314 "9*floor((-16 + 2c)/9) <= -19 + 2c) }" },
2315 { 0, "{ [a, b, c] : (b <= 2 and b <= -2 + a) or "
2316 "(b = -1 + a and 0 < a <= 3 and "
2317 "9*floor((-4a + 2c)/9) <= -3 - 4a + 2c) or "
2318 "(exists (e0 = floor((-16 + 2c)/9): a = 4 and "
2319 "b = 3 and 9e0 <= -19 + 2c)) }" },
2320 { 1, "{ [y, x] : (x - y) mod 3 = 2 and 2 <= y <= 200 and 0 <= x <= 2;"
2321 "[1, 0] }" },
2322 { 1, "{ [x, y] : (x - y) mod 3 = 2 and 2 <= y <= 200 and 0 <= x <= 2;"
2323 "[0, 1] }" },
2324 { 1, "{ [1, y] : -1 <= y <= 1; [x, -x] : 0 <= x <= 1 }" },
2325 { 1, "{ [1, y] : 0 <= y <= 1; [x, -x] : 0 <= x <= 1 }" },
2326 { 1, "{ [x, y] : 0 <= x <= 10 and x - 4*floor(x/4) <= 1 and y <= 0; "
2327 "[x, y] : 0 <= x <= 10 and x - 4*floor(x/4) > 1 and y <= 0; "
2328 "[x, y] : 0 <= x <= 10 and x - 5*floor(x/5) <= 1 and 0 < y; "
2329 "[x, y] : 0 <= x <= 10 and x - 5*floor(x/5) > 1 and 0 < y }" },
2330 { 1, "{ [x, 0] : 0 <= x <= 10 and x mod 2 = 0; "
2331 "[x, 0] : 0 <= x <= 10 and x mod 2 = 1; "
2332 "[x, y] : 0 <= x <= 10 and 1 <= y <= 10 }" },
2333 { 1, "{ [a] : a <= 8 and "
2334 "(a mod 10 = 7 or a mod 10 = 8 or a mod 10 = 9) }" },
2335 { 1, "{ [x, y] : 2y = -x and x <= 0 or "
2336 "x <= -1 and 2y <= -x - 1 and 2y >= x - 1 }" },
2337 { 0, "{ [x, y] : 2y = -x and x <= 0 or "
2338 "x <= -2 and 2y <= -x - 1 and 2y >= x - 1 }" },
2339 { 1, "{ [a] : (a <= 0 and 3*floor((a)/3) = a) or "
2340 "(a < 0 and 3*floor((a)/3) < a) }" },
2341 { 1, "{ [a] : (a <= 0 and 3*floor((a)/3) = a) or "
2342 "(a < -1 and 3*floor((a)/3) < a) }" },
2343 { 1, "{ [a, b] : a <= 1024 and b >= 0 and "
2344 "((-31 - a + b <= 32*floor((-1 - a)/32) <= -33 + b and "
2345 "32*floor((-1 - a)/32) <= -16 + b + 16*floor((-1 - a)/16))"
2346 "or (2 <= a <= 15 and b < a)) }" },
2347 { 1, "{ [a] : a > 0 and ((16*floor((a)/16) < a and "
2348 "32*floor((a)/32) < a) or a <= 15) }" },
2349 { 1, "{ [a, b, c, d] : (-a + d) mod 64 = 0 and a <= 8 and b <= 1 and "
2350 "10 - a <= c <= 3 and d >= 5 and 9 - 64b <= d <= 70;"
2351 "[a, b = 1, c, d] : (-a + d) mod 64 = 0 and a <= 8 and c >= 4 and "
2352 "10 - a <= c <= 5 and 5 <= d <= 73 - c }" },
2353 { 1, "[n, m] -> { S_0[i] : (-n + i) mod 3 = 0 and m >= 3 + n and "
2354 "i >= n and 3*floor((2 + n + 2m)/3) <= n + 3m - i; "
2355 "S_0[n] : n <= m <= 2 + n }" },
2356 { 1, "{ [a, b] : exists (e0: 0 <= a <= 1 and b >= 0 and "
2357 "2e0 >= -5 + a + 2b and 2e0 >= -1 + a + b and "
2358 "2e0 <= a + b); "
2359 "[a, b] : exists (e0: 0 <= a <= 1 and 2e0 >= -5 + a + 2b and "
2360 "2e0 >= -1 - a + b and 2e0 <= -a + b and "
2361 "2e0 < -a + 2b) }" },
2362 { 1, "{ [i, j, i - 8j] : 8 <= i <= 63 and -7 + i <= 8j <= i; "
2363 "[i, 0, i] : 0 <= i <= 7 }" },
2364 { 1, "{ [a, b] : a >= 0 and 0 <= b <= 1 - a; [1, 1] }" },
2365 { 0, "{ [a, b] : a >= 0 and 0 <= b <= 1 - a; [0, 2] }" },
2366 { 0, "{ [a, b] : a >= 0 and 0 <= b <= 1 - a; [-1, 3] }" },
2367 { 1, "{ [a, b] : a, b >= 0 and a + 2b <= 2; [1, 1] }" },
2368 { 0, "{ [a, b] : a, b >= 0 and a + 2b <= 2; [2, 1] }" },
2369 { 0, "{ [a, c] : (2 + a) mod 4 = 0 or "
2370 "(c = 4 + a and 4 * floor((a)/4) = a and a >= 0 and a <= 4) or "
2371 "(c = 3 + a and 4 * floor((-1 + a)/4) = -1 + a and "
2372 "a > 0 and a <= 5) }" },
2373 { 1, "{ [1, 0, 0]; [a, b, c] : -1 <= -a < b <= 0 and 2c > b }" },
2374 { 0, "{ [j, a, l] : a mod 2 = 0 and j <= 29 and a >= 2 and "
2375 "2a <= -5 + j and 32j + 2a + 2 <= 4l < 33j; "
2376 "[j, 0, l] : 4 <= j <= 29 and -3 + 33j <= 4l <= 33j }" },
2377 { 0, "{ [0:1, 0:1]; [0, 2:3] }" },
2378 { 1, "{ [a] : (a = 0 or ((1 + a) mod 2 = 0 and 0 < a <= 15) or "
2379 "((a) mod 2 = 0 and 0 < a <= 15)) }" },
2380};
2381
2382/* A specialized coalescing test case that would result
2383 * in a segmentation fault or a failed assertion in earlier versions of isl.
2384 */
2385static int test_coalesce_special(struct isl_ctx *ctx)
2386{
2387 const char *str;
2388 isl_map *map1, *map2;
2389
2390 str = "[y] -> { [S_L220_OUT[] -> T7[]] -> "
2391 "[[S_L309_IN[] -> T11[]] -> ce_imag2[1, o1]] : "
2392 "(y = 201 and o1 <= 239 and o1 >= 212) or "
2393 "(exists (e0 = [(y)/3]: 3e0 = y and y <= 198 and y >= 3 and "
2394 "o1 <= 239 and o1 >= 212)) or "
2395 "(exists (e0 = [(y)/3]: 3e0 = y and y <= 201 and y >= 3 and "
2396 "o1 <= 241 and o1 >= 240));"
2397 "[S_L220_OUT[] -> T7[]] -> "
2398 "[[S_L309_IN[] -> T11[]] -> ce_imag2[0, o1]] : "
2399 "(y = 2 and o1 <= 241 and o1 >= 212) or "
2400 "(exists (e0 = [(-2 + y)/3]: 3e0 = -2 + y and y <= 200 and "
2401 "y >= 5 and o1 <= 241 and o1 >= 212)) }";
2402 map1 = isl_map_read_from_str(ctx, str);
2403 map1 = isl_map_align_divs_internal(map1);
2404 map1 = isl_map_coalesce(map1);
2405 str = "[y] -> { [S_L220_OUT[] -> T7[]] -> "
2406 "[[S_L309_IN[] -> T11[]] -> ce_imag2[o0, o1]] : "
2407 "exists (e0 = [(-1 - y + o0)/3]: 3e0 = -1 - y + o0 and "
2408 "y <= 201 and o0 <= 2 and o1 >= 212 and o1 <= 241 and "
2409 "o0 >= 3 - y and o0 <= -2 + y and o0 >= 0) }";
2410 map2 = isl_map_read_from_str(ctx, str);
2411 map2 = isl_map_union(map2, map1);
2412 map2 = isl_map_align_divs_internal(map2);
2413 map2 = isl_map_coalesce(map2);
2414 isl_map_free(map2);
2415 if (!map2)
2416 return -1;
2417
2418 return 0;
2419}
2420
2421/* Check that the union of the basic sets described by "str1" and "str2"
2422 * can be coalesced.
2423 * The explicit call to isl_basic_set_union prevents the implicit
2424 * equality constraints in the basic maps from being detected prior
2425 * to the call to isl_set_coalesce, at least at the point
2426 * where this function was introduced.
2427 */
2428static isl_stat test_coalesce_union(isl_ctx *ctx, const char *str1,
2429 const char *str2)
2430{
2431 isl_basic_setisl_basic_map *bset1, *bset2;
2432 isl_setisl_map *set;
2433
2434 bset1 = isl_basic_set_read_from_str(ctx, str1);
2435 bset2 = isl_basic_set_read_from_str(ctx, str2);
2436 set = isl_basic_set_union(bset1, bset2);
2437 set = isl_set_coalesce(set);
2438 isl_set_free(set);
2439
2440 return isl_stat_non_null(set);
2441}
2442
2443/* A specialized coalescing test case that would result in an assertion
2444 * in an earlier version of isl. Use test_coalesce_union with
2445 * an explicit call to isl_basic_set_union to prevent the implicit
2446 * equality constraints in the first basic map from being detected prior
2447 * to the call to isl_set_coalesce, at least at the point
2448 * where this test case was introduced.
2449 */
2450static isl_stat test_coalesce_special2(struct isl_ctx *ctx)
2451{
2452 const char *str1;
2453 const char *str2;
2454
2455 str1 = "{ [x, y] : x, y >= 0 and x + 2y <= 1 and 2x + y <= 1 }";
2456 str2 = "{ [x,0] : -1 <= x <= 1 and x mod 2 = 1 }";
2457 return test_coalesce_union(ctx, str1, str2);
2458}
2459
2460/* Check that calling isl_set_coalesce does not leave other sets
2461 * that may share some information with the input to isl_set_coalesce
2462 * in an inconsistent state.
2463 * In particular, older versions of isl would modify all copies
2464 * of the basic sets in the isl_set_coalesce input in a way
2465 * that could leave them in an inconsistent state.
2466 * The result of printing any other set containing one of these
2467 * basic sets would then result in an invalid set description.
2468 */
2469static int test_coalesce_special3(isl_ctx *ctx)
2470{
2471 const char *str;
2472 char *s;
2473 isl_setisl_map *set1, *set2;
2474 isl_printer *p;
2475
2476 set1 = isl_set_read_from_str(ctx, "{ [0, 0, 0] }");
2477 str = "{ [a, b, a + b] : a >= 0 and b >= 0 and 0 < a + b }";
2478 set2 = isl_set_read_from_str(ctx, str);
2479 set1 = isl_set_union(set1, isl_set_copy(set2));
2480 set1 = isl_set_coalesce(set1);
2481 isl_set_free(set1);
2482
2483 p = isl_printer_to_str(ctx);
2484 p = isl_printer_print_set(p, set2);
2485 isl_set_free(set2);
2486 s = isl_printer_get_str(p);
2487 isl_printer_free(p);
2488 set1 = isl_set_read_from_str(ctx, s);
2489 free(s);
2490 isl_set_free(set1);
2491
2492 if (!set1)
2493 return -1;
2494
2495 return 0;
2496}
2497
2498/* Check that calling isl_set_coalesce on the intersection of
2499 * the sets described by "s1" and "s2" does not leave other sets
2500 * that may share some information with the input to isl_set_coalesce
2501 * in an inconsistent state.
2502 * In particular, when isl_set_coalesce detects equality constraints,
2503 * it does not immediately perform Gaussian elimination on them,
2504 * but then it needs to ensure that it is performed at some point.
2505 * The input set has implicit equality constraints in the first disjunct.
2506 * It is constructed as an intersection, because otherwise
2507 * those equality constraints would already be detected during parsing.
2508 */
2509static isl_stat test_coalesce_intersection(isl_ctx *ctx,
2510 const char *s1, const char *s2)
2511{
2512 isl_setisl_map *set1, *set2;
2513
2514 set1 = isl_set_read_from_str(ctx, s1);
2515 set2 = isl_set_read_from_str(ctx, s2);
2516 set1 = isl_set_intersect(set1, set2);
2517 isl_set_free(isl_set_coalesce(isl_set_copy(set1)));
2518 set1 = isl_set_coalesce(set1);
2519 isl_set_free(set1);
2520
2521 if (!set1)
2522 return isl_stat_error;
2523
2524 return isl_stat_ok;
2525}
2526
2527/* Check that calling isl_set_coalesce does not leave other sets
2528 * that may share some information with the input to isl_set_coalesce
2529 * in an inconsistent state, for the case where one disjunct
2530 * is a subset of the other.
2531 */
2532static isl_stat test_coalesce_special4(isl_ctx *ctx)
2533{
2534 const char *s1, *s2;
2535
2536 s1 = "{ [a, b] : b <= 0 or a <= 1 }";
2537 s2 = "{ [a, b] : -1 <= -a < b }";
2538 return test_coalesce_intersection(ctx, s1, s2);
2539}
2540
2541/* Check that calling isl_set_coalesce does not leave other sets
2542 * that may share some information with the input to isl_set_coalesce
2543 * in an inconsistent state, for the case where two disjuncts
2544 * can be fused.
2545 */
2546static isl_stat test_coalesce_special5(isl_ctx *ctx)
2547{
2548 const char *s1, *s2;
2549
2550 s1 = "{ [a, b, c] : b <= 0 }";
2551 s2 = "{ [a, b, c] : -1 <= -a < b and (c >= 0 or c < 0) }";
2552 return test_coalesce_intersection(ctx, s1, s2);
2553}
2554
2555/* Check that calling isl_set_coalesce does not leave other sets
2556 * that may share some information with the input to isl_set_coalesce
2557 * in an inconsistent state, for the case where two disjuncts
2558 * can be fused and where both disjuncts have implicit equality constraints.
2559 */
2560static isl_stat test_coalesce_special6(isl_ctx *ctx)
2561{
2562 const char *s1, *s2;
2563
2564 s1 = "{ [a, b, c] : c <= 0 }";
2565 s2 = "{ [a, b, c] : 0 <= a <= b <= c or (0 <= b <= c and a > 0) }";
2566 return test_coalesce_intersection(ctx, s1, s2);
2567}
2568
2569/* A specialized coalescing test case that would result in an assertion failure
2570 * in an earlier version of isl. Use test_coalesce_union with
2571 * an explicit call to isl_basic_set_union to prevent the implicit
2572 * equality constraints in the basic maps from being detected prior
2573 * to the call to isl_set_coalesce, at least at the point
2574 * where this test case was introduced.
2575 */
2576static isl_stat test_coalesce_special7(isl_ctx *ctx)
2577{
2578 const char *str1;
2579 const char *str2;
2580
2581 str1 = "{ [a, b, c=0:17] : a <= 7 and 2b <= 11 - a and "
2582 "c <= -7 + 2a and 2c >= - 3 + 3a - 2b }";
2583 str2 = "{ [a, b, c] : c > -15a and c >= -7 + 2a and c < 0 and "
2584 "3c <= -5 + 5a - 3b and 2b >= 11 - a }";
2585 return test_coalesce_union(ctx, str1, str2);
2586}
2587
2588/* Test the functionality of isl_set_coalesce.
2589 * That is, check that the output is always equal to the input
2590 * and in some cases that the result consists of a single disjunct.
2591 */
2592static int test_coalesce(struct isl_ctx *ctx)
2593{
2594 int i;
2595
2596 for (i = 0; i < ARRAY_SIZE(coalesce_tests)(sizeof(coalesce_tests)/sizeof(*coalesce_tests)); ++i) {
2597 const char *str = coalesce_tests[i].str;
2598 int check_one = coalesce_tests[i].single_disjunct;
2599 if (test_coalesce_set(ctx, str, check_one) < 0)
2600 return -1;
2601 }
2602
2603 if (test_coalesce_unbounded_wrapping(ctx) < 0)
2604 return -1;
2605 if (test_coalesce_special(ctx) < 0)
2606 return -1;
2607 if (test_coalesce_special2(ctx) < 0)
2608 return -1;
2609 if (test_coalesce_special3(ctx) < 0)
2610 return -1;
2611 if (test_coalesce_special4(ctx) < 0)
2612 return -1;
2613 if (test_coalesce_special5(ctx) < 0)
2614 return -1;
2615 if (test_coalesce_special6(ctx) < 0)
2616 return -1;
2617 if (test_coalesce_special7(ctx) < 0)
2618 return -1;
2619
2620
2621 return 0;
2622}
2623
2624/* Construct a representation of the graph on the right of Figure 1
2625 * in "Computing the Transitive Closure of a Union of
2626 * Affine Integer Tuple Relations".
2627 */
2628static __isl_give isl_map *cocoa_fig_1_right_graph(isl_ctx *ctx)
2629{
2630 isl_setisl_map *dom;
2631 isl_map *up, *right;
2632
2633 dom = isl_set_read_from_str(ctx,
2634 "{ [x,y] : x >= 0 and -2 x + 3 y >= 0 and x <= 3 and "
2635 "2 x - 3 y + 3 >= 0 }");
2636 right = isl_map_read_from_str(ctx,
2637 "{ [x,y] -> [x2,y2] : x2 = x + 1 and y2 = y }");
2638 up = isl_map_read_from_str(ctx,
2639 "{ [x,y] -> [x2,y2] : x2 = x and y2 = y + 1 }");
2640 right = isl_map_intersect_domain(right, isl_set_copy(dom));
2641 right = isl_map_intersect_range(right, isl_set_copy(dom));
2642 up = isl_map_intersect_domain(up, isl_set_copy(dom));
2643 up = isl_map_intersect_range(up, dom);
2644 return isl_map_union(up, right);
2645}
2646
2647/* Construct a representation of the power of the graph
2648 * on the right of Figure 1 in "Computing the Transitive Closure of
2649 * a Union of Affine Integer Tuple Relations".
2650 */
2651static __isl_give isl_map *cocoa_fig_1_right_power(isl_ctx *ctx)
2652{
2653 return isl_map_read_from_str(ctx,
2654 "{ [1] -> [[0,0] -> [0,1]]; [2] -> [[0,0] -> [1,1]]; "
2655 " [1] -> [[0,1] -> [1,1]]; [1] -> [[2,2] -> [3,2]]; "
2656 " [2] -> [[2,2] -> [3,3]]; [1] -> [[3,2] -> [3,3]] }");
2657}
2658
2659/* Construct a representation of the transitive closure of the graph
2660 * on the right of Figure 1 in "Computing the Transitive Closure of
2661 * a Union of Affine Integer Tuple Relations".
2662 */
2663static __isl_give isl_map *cocoa_fig_1_right_tc(isl_ctx *ctx)
2664{
2665 return isl_set_unwrap(isl_map_range(cocoa_fig_1_right_power(ctx)));
2666}
2667
2668static int test_closure(isl_ctx *ctx)
2669{
2670 const char *str;
2671 isl_map *map, *map2;
2672 isl_bool exact, equal;
2673
2674 /* COCOA example 1 */
2675 map = isl_map_read_from_str(ctx,
2676 "[n] -> { [i,j] -> [i2,j2] : i2 = i + 1 and j2 = j + 1 and "
2677 "1 <= i and i < n and 1 <= j and j < n or "
2678 "i2 = i + 1 and j2 = j - 1 and "
2679 "1 <= i and i < n and 2 <= j and j <= n }");
2680 map = isl_map_power(map, &exact);
2681 assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact)
; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c"
, 2681, __extension__ __PRETTY_FUNCTION__); }))
;
2682 isl_map_free(map);
2683
2684 /* COCOA example 1 */
2685 map = isl_map_read_from_str(ctx,
2686 "[n] -> { [i,j] -> [i2,j2] : i2 = i + 1 and j2 = j + 1 and "
2687 "1 <= i and i < n and 1 <= j and j < n or "
2688 "i2 = i + 1 and j2 = j - 1 and "
2689 "1 <= i and i < n and 2 <= j and j <= n }");
2690 map = isl_map_transitive_closure(map, &exact);
2691 assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact)
; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c"
, 2691, __extension__ __PRETTY_FUNCTION__); }))
;
2692 map2 = isl_map_read_from_str(ctx,
2693 "[n] -> { [i,j] -> [i2,j2] : exists (k1,k2,k : "
2694 "1 <= i and i < n and 1 <= j and j <= n and "
2695 "2 <= i2 and i2 <= n and 1 <= j2 and j2 <= n and "
2696 "i2 = i + k1 + k2 and j2 = j + k1 - k2 and "
2697 "k1 >= 0 and k2 >= 0 and k1 + k2 = k and k >= 1 )}");
2698 assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__
({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)"
, "polly/lib/External/isl/isl_test.c", 2698, __extension__ __PRETTY_FUNCTION__
); }))
;
2699 isl_map_free(map2);
2700 isl_map_free(map);
2701
2702 map = isl_map_read_from_str(ctx,
2703 "[n] -> { [x] -> [y] : y = x + 1 and 0 <= x and x <= n and "
2704 " 0 <= y and y <= n }");
2705 map = isl_map_transitive_closure(map, &exact);
2706 map2 = isl_map_read_from_str(ctx,
2707 "[n] -> { [x] -> [y] : y > x and 0 <= x and x <= n and "
2708 " 0 <= y and y <= n }");
2709 assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__
({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)"
, "polly/lib/External/isl/isl_test.c", 2709, __extension__ __PRETTY_FUNCTION__
); }))
;
2710 isl_map_free(map2);
2711 isl_map_free(map);
2712
2713 /* COCOA example 2 */
2714 map = isl_map_read_from_str(ctx,
2715 "[n] -> { [i,j] -> [i2,j2] : i2 = i + 2 and j2 = j + 2 and "
2716 "1 <= i and i < n - 1 and 1 <= j and j < n - 1 or "
2717 "i2 = i + 2 and j2 = j - 2 and "
2718 "1 <= i and i < n - 1 and 3 <= j and j <= n }");
2719 map = isl_map_transitive_closure(map, &exact);
2720 assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact)
; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c"
, 2720, __extension__ __PRETTY_FUNCTION__); }))
;
2721 map2 = isl_map_read_from_str(ctx,
2722 "[n] -> { [i,j] -> [i2,j2] : exists (k1,k2,k : "
2723 "1 <= i and i < n - 1 and 1 <= j and j <= n and "
2724 "3 <= i2 and i2 <= n and 1 <= j2 and j2 <= n and "
2725 "i2 = i + 2 k1 + 2 k2 and j2 = j + 2 k1 - 2 k2 and "
2726 "k1 >= 0 and k2 >= 0 and k1 + k2 = k and k >= 1) }");
2727 assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__
({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)"
, "polly/lib/External/isl/isl_test.c", 2727, __extension__ __PRETTY_FUNCTION__
); }))
;
2728 isl_map_free(map);
2729 isl_map_free(map2);
2730
2731 /* COCOA Fig.2 left */
2732 map = isl_map_read_from_str(ctx,
2733 "[n] -> { [i,j] -> [i2,j2] : i2 = i + 2 and j2 = j and "
2734 "i <= 2 j - 3 and i <= n - 2 and j <= 2 i - 1 and "
2735 "j <= n or "
2736 "i2 = i and j2 = j + 2 and i <= 2 j - 1 and i <= n and "
2737 "j <= 2 i - 3 and j <= n - 2 or "
2738 "i2 = i + 1 and j2 = j + 1 and i <= 2 j - 1 and "
2739 "i <= n - 1 and j <= 2 i - 1 and j <= n - 1 }");
2740 map = isl_map_transitive_closure(map, &exact);
2741 assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact)
; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c"
, 2741, __extension__ __PRETTY_FUNCTION__); }))
;
2742 isl_map_free(map);
2743
2744 /* COCOA Fig.2 right */
2745 map = isl_map_read_from_str(ctx,
2746 "[n] -> { [i,j] -> [i2,j2] : i2 = i + 3 and j2 = j and "
2747 "i <= 2 j - 4 and i <= n - 3 and j <= 2 i - 1 and "
2748 "j <= n or "
2749 "i2 = i and j2 = j + 3 and i <= 2 j - 1 and i <= n and "
2750 "j <= 2 i - 4 and j <= n - 3 or "
2751 "i2 = i + 1 and j2 = j + 1 and i <= 2 j - 1 and "
2752 "i <= n - 1 and j <= 2 i - 1 and j <= n - 1 }");
2753 map = isl_map_power(map, &exact);
2754 assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact)
; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c"
, 2754, __extension__ __PRETTY_FUNCTION__); }))
;
2755 isl_map_free(map);
2756
2757 /* COCOA Fig.2 right */
2758 map = isl_map_read_from_str(ctx,
2759 "[n] -> { [i,j] -> [i2,j2] : i2 = i + 3 and j2 = j and "
2760 "i <= 2 j - 4 and i <= n - 3 and j <= 2 i - 1 and "
2761 "j <= n or "
2762 "i2 = i and j2 = j + 3 and i <= 2 j - 1 and i <= n and "
2763 "j <= 2 i - 4 and j <= n - 3 or "
2764 "i2 = i + 1 and j2 = j + 1 and i <= 2 j - 1 and "
2765 "i <= n - 1 and j <= 2 i - 1 and j <= n - 1 }");
2766 map = isl_map_transitive_closure(map, &exact);
2767 assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact)
; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c"
, 2767, __extension__ __PRETTY_FUNCTION__); }))
;
2768 map2 = isl_map_read_from_str(ctx,
2769 "[n] -> { [i,j] -> [i2,j2] : exists (k1,k2,k3,k : "
2770 "i <= 2 j - 1 and i <= n and j <= 2 i - 1 and "
2771 "j <= n and 3 + i + 2 j <= 3 n and "
2772 "3 + 2 i + j <= 3n and i2 <= 2 j2 -1 and i2 <= n and "
2773 "i2 <= 3 j2 - 4 and j2 <= 2 i2 -1 and j2 <= n and "
2774 "13 + 4 j2 <= 11 i2 and i2 = i + 3 k1 + k3 and "
2775 "j2 = j + 3 k2 + k3 and k1 >= 0 and k2 >= 0 and "
2776 "k3 >= 0 and k1 + k2 + k3 = k and k > 0) }");
2777 assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__
({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)"
, "polly/lib/External/isl/isl_test.c", 2777, __extension__ __PRETTY_FUNCTION__
); }))
;
2778 isl_map_free(map2);
2779 isl_map_free(map);
2780
2781 map = cocoa_fig_1_right_graph(ctx);
2782 map = isl_map_transitive_closure(map, &exact);
2783 assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact)
; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c"
, 2783, __extension__ __PRETTY_FUNCTION__); }))
;
2784 map2 = cocoa_fig_1_right_tc(ctx);
2785 assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__
({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)"
, "polly/lib/External/isl/isl_test.c", 2785, __extension__ __PRETTY_FUNCTION__
); }))
;
2786 isl_map_free(map2);
2787 isl_map_free(map);
2788
2789 map = cocoa_fig_1_right_graph(ctx);
2790 map = isl_map_power(map, &exact);
2791 map2 = cocoa_fig_1_right_power(ctx);
2792 equal = isl_map_is_equal(map, map2);
2793 isl_map_free(map2);
2794 isl_map_free(map);
2795 if (equal < 0)
2796 return -1;
2797 if (!exact)
2798 isl_die(ctx, isl_error_unknown, "power not exact", return -1)do { isl_handle_error(ctx, isl_error_unknown, "power not exact"
, "polly/lib/External/isl/isl_test.c", 2798); return -1; } while
(0)
;
2799 if (!equal)
2800 isl_die(ctx, isl_error_unknown, "unexpected power", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected power"
, "polly/lib/External/isl/isl_test.c", 2800); return -1; } while
(0)
;
2801
2802 /* COCOA Theorem 1 counter example */
2803 map = isl_map_read_from_str(ctx,
2804 "{ [i,j] -> [i2,j2] : i = 0 and 0 <= j and j <= 1 and "
2805 "i2 = 1 and j2 = j or "
2806 "i = 0 and j = 0 and i2 = 0 and j2 = 1 }");
2807 map = isl_map_transitive_closure(map, &exact);
2808 assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact)
; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c"
, 2808, __extension__ __PRETTY_FUNCTION__); }))
;
2809 isl_map_free(map);
2810
2811 map = isl_map_read_from_str(ctx,
2812 "[m,n] -> { [i,j] -> [i2,j2] : i2 = i and j2 = j + 2 and "
2813 "1 <= i,i2 <= n and 1 <= j,j2 <= m or "
2814 "i2 = i + 1 and 3 <= j2 - j <= 4 and "
2815 "1 <= i,i2 <= n and 1 <= j,j2 <= m }");
2816 map = isl_map_transitive_closure(map, &exact);
2817 assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact)
; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c"
, 2817, __extension__ __PRETTY_FUNCTION__); }))
;
2818 isl_map_free(map);
2819
2820 /* Kelly et al 1996, fig 12 */
2821 map = isl_map_read_from_str(ctx,
2822 "[n] -> { [i,j] -> [i2,j2] : i2 = i and j2 = j + 1 and "
2823 "1 <= i,j,j+1 <= n or "
2824 "j = n and j2 = 1 and i2 = i + 1 and "
2825 "1 <= i,i+1 <= n }");
2826 map = isl_map_transitive_closure(map, &exact);
2827 assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact)
; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c"
, 2827, __extension__ __PRETTY_FUNCTION__); }))
;
2828 map2 = isl_map_read_from_str(ctx,
2829 "[n] -> { [i,j] -> [i2,j2] : 1 <= j < j2 <= n and "
2830 "1 <= i <= n and i = i2 or "
2831 "1 <= i < i2 <= n and 1 <= j <= n and "
2832 "1 <= j2 <= n }");
2833 assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__
({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)"
, "polly/lib/External/isl/isl_test.c", 2833, __extension__ __PRETTY_FUNCTION__
); }))
;
2834 isl_map_free(map2);
2835 isl_map_free(map);
2836
2837 /* Omega's closure4 */
2838 map = isl_map_read_from_str(ctx,
2839 "[m,n] -> { [x,y] -> [x2,y2] : x2 = x and y2 = y + 1 and "
2840 "1 <= x,y <= 10 or "
2841 "x2 = x + 1 and y2 = y and "
2842 "1 <= x <= 20 && 5 <= y <= 15 }");
2843 map = isl_map_transitive_closure(map, &exact);
2844 assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact)
; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c"
, 2844, __extension__ __PRETTY_FUNCTION__); }))
;
2845 isl_map_free(map);
2846
2847 map = isl_map_read_from_str(ctx,
2848 "[n] -> { [x] -> [y]: 1 <= n <= y - x <= 10 }");
2849 map = isl_map_transitive_closure(map, &exact);
2850 assert(!exact)((void) sizeof ((!exact) ? 1 : 0), __extension__ ({ if (!exact
) ; else __assert_fail ("!exact", "polly/lib/External/isl/isl_test.c"
, 2850, __extension__ __PRETTY_FUNCTION__); }))
;
2851 map2 = isl_map_read_from_str(ctx,
2852 "[n] -> { [x] -> [y] : 1 <= n <= 10 and y >= n + x }");
2853 assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__
({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)"
, "polly/lib/External/isl/isl_test.c", 2853, __extension__ __PRETTY_FUNCTION__
); }))
;
2854 isl_map_free(map);
2855 isl_map_free(map2);
2856
2857 str = "[n, m] -> { [i0, i1, i2, i3] -> [o0, o1, o2, o3] : "
2858 "i3 = 1 and o0 = i0 and o1 = -1 + i1 and o2 = -1 + i2 and "
2859 "o3 = -2 + i2 and i1 <= -1 + i0 and i1 >= 1 - m + i0 and "
2860 "i1 >= 2 and i1 <= n and i2 >= 3 and i2 <= 1 + n and i2 <= m }";
2861 map = isl_map_read_from_str(ctx, str);
2862 map = isl_map_transitive_closure(map, &exact);
2863 assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact)
; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c"
, 2863, __extension__ __PRETTY_FUNCTION__); }))
;
2864 map2 = isl_map_read_from_str(ctx, str);
2865 assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__
({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)"
, "polly/lib/External/isl/isl_test.c", 2865, __extension__ __PRETTY_FUNCTION__
); }))
;
2866 isl_map_free(map);
2867 isl_map_free(map2);
2868
2869 str = "{[0] -> [1]; [2] -> [3]}";
2870 map = isl_map_read_from_str(ctx, str);
2871 map = isl_map_transitive_closure(map, &exact);
2872 assert(exact)((void) sizeof ((exact) ? 1 : 0), __extension__ ({ if (exact)
; else __assert_fail ("exact", "polly/lib/External/isl/isl_test.c"
, 2872, __extension__ __PRETTY_FUNCTION__); }))
;
2873 map2 = isl_map_read_from_str(ctx, str);
2874 assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__
({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)"
, "polly/lib/External/isl/isl_test.c", 2874, __extension__ __PRETTY_FUNCTION__
); }))
;
2875 isl_map_free(map);
2876 isl_map_free(map2);
2877
2878 str = "[n] -> { [[i0, i1, 1, 0, i0] -> [i5, 1]] -> "
2879 "[[i0, -1 + i1, 2, 0, i0] -> [-1 + i5, 2]] : "
2880 "exists (e0 = [(3 - n)/3]: i5 >= 2 and i1 >= 2 and "
2881 "3i0 <= -1 + n and i1 <= -1 + n and i5 <= -1 + n and "
2882 "3e0 >= 1 - n and 3e0 <= 2 - n and 3i0 >= -2 + n); "
2883 "[[i0, i1, 2, 0, i0] -> [i5, 1]] -> "
2884 "[[i0, i1, 1, 0, i0] -> [-1 + i5, 2]] : "
2885 "exists (e0 = [(3 - n)/3]: i5 >= 2 and i1 >= 1 and "
2886 "3i0 <= -1 + n and i1 <= -1 + n and i5 <= -1 + n and "
2887 "3e0 >= 1 - n and 3e0 <= 2 - n and 3i0 >= -2 + n); "
2888 "[[i0, i1, 1, 0, i0] -> [i5, 2]] -> "
2889 "[[i0, -1 + i1, 2, 0, i0] -> [i5, 1]] : "
2890 "exists (e0 = [(3 - n)/3]: i1 >= 2 and i5 >= 1 and "
2891 "3i0 <= -1 + n and i1 <= -1 + n and i5 <= -1 + n and "
2892 "3e0 >= 1 - n and 3e0 <= 2 - n and 3i0 >= -2 + n); "
2893 "[[i0, i1, 2, 0, i0] -> [i5, 2]] -> "
2894 "[[i0, i1, 1, 0, i0] -> [i5, 1]] : "
2895 "exists (e0 = [(3 - n)/3]: i5 >= 1 and i1 >= 1 and "
2896 "3i0 <= -1 + n and i1 <= -1 + n and i5 <= -1 + n and "
2897 "3e0 >= 1 - n and 3e0 <= 2 - n and 3i0 >= -2 + n) }";
2898 map = isl_map_read_from_str(ctx, str);
2899 map = isl_map_transitive_closure(map, NULL((void*)0));
2900 assert(map)((void) sizeof ((map) ? 1 : 0), __extension__ ({ if (map) ; else
__assert_fail ("map", "polly/lib/External/isl/isl_test.c", 2900
, __extension__ __PRETTY_FUNCTION__); }))
;
2901 isl_map_free(map);
2902
2903 return 0;
2904}
2905
2906/* Check that the actual result of a boolean operation is equal
2907 * to the expected result.
2908 */
2909static isl_stat check_bool(isl_ctx *ctx, isl_bool actual, isl_bool expected)
2910{
2911 if (actual != expected)
2912 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "incorrect boolean operation"
, "polly/lib/External/isl/isl_test.c", 2913); return isl_stat_error
; } while (0)
2913 "incorrect boolean operation", return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "incorrect boolean operation"
, "polly/lib/External/isl/isl_test.c", 2913); return isl_stat_error
; } while (0)
;
2914 return isl_stat_ok;
2915}
2916
2917/* Test operations on isl_bool values.
2918 *
2919 * This tests:
2920 *
2921 * isl_bool_not
2922 * isl_bool_ok
2923 */
2924static int test_isl_bool(isl_ctx *ctx)
2925{
2926 if (check_bool(ctx, isl_bool_not(isl_bool_true), isl_bool_false) < 0)
2927 return -1;
2928 if (check_bool(ctx, isl_bool_not(isl_bool_false), isl_bool_true) < 0)
2929 return -1;
2930 if (check_bool(ctx, isl_bool_not(isl_bool_error), isl_bool_error) < 0)
2931 return -1;
2932 if (check_bool(ctx, isl_bool_ok(0), isl_bool_false) < 0)
2933 return -1;
2934 if (check_bool(ctx, isl_bool_ok(1), isl_bool_true) < 0)
2935 return -1;
2936 if (check_bool(ctx, isl_bool_ok(-1), isl_bool_true) < 0)
2937 return -1;
2938 if (check_bool(ctx, isl_bool_ok(2), isl_bool_true) < 0)
2939 return -1;
2940 if (check_bool(ctx, isl_bool_ok(-2), isl_bool_true) < 0)
2941 return -1;
2942
2943 return 0;
2944}
2945
2946static int test_lex(struct isl_ctx *ctx)
2947{
2948 isl_space *space;
2949 isl_map *map;
2950 int empty;
2951
2952 space = isl_space_set_alloc(ctx, 0, 0);
2953 map = isl_map_lex_le(space);
2954 empty = isl_map_is_empty(map);
2955 isl_map_free(map);
2956
2957 if (empty < 0)
2958 return -1;
2959 if (empty)
2960 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "expecting non-empty result"
, "polly/lib/External/isl/isl_test.c", 2961); return -1; } while
(0)
2961 "expecting non-empty result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "expecting non-empty result"
, "polly/lib/External/isl/isl_test.c", 2961); return -1; } while
(0)
;
2962
2963 return 0;
2964}
2965
2966/* Inputs for isl_map_lexmin tests.
2967 * "map" is the input and "lexmin" is the expected result.
2968 */
2969struct {
2970 const char *map;
2971 const char *lexmin;
2972} lexmin_tests [] = {
2973 { "{ [x] -> [y] : x <= y <= 10; [x] -> [5] : -8 <= x <= 8 }",
2974 "{ [x] -> [5] : 6 <= x <= 8; "
2975 "[x] -> [x] : x <= 5 or (9 <= x <= 10) }" },
2976 { "{ [x] -> [y] : 4y = x or 4y = -1 + x or 4y = -2 + x }",
2977 "{ [x] -> [y] : 4y = x or 4y = -1 + x or 4y = -2 + x }" },
2978 { "{ [x] -> [y] : x = 4y; [x] -> [y] : x = 2y }",
2979 "{ [x] -> [y] : (4y = x and x >= 0) or "
2980 "(exists (e0 = [(x)/4], e1 = [(-2 + x)/4]: 2y = x and "
2981 "4e1 = -2 + x and 4e0 <= -1 + x and 4e0 >= -3 + x)) or "
2982 "(exists (e0 = [(x)/4]: 2y = x and 4e0 = x and x <= -4)) }" },
2983 { "{ T[a] -> S[b, c] : a = 4b-2c and c >= b }",
2984 "{ T[a] -> S[b, c] : 2b = a and 2c = a }" },
2985 /* Check that empty pieces are properly combined. */
2986 { "[K, N] -> { [x, y] -> [a, b] : K+2<=N<=K+4 and x>=4 and "
2987 "2N-6<=x<K+N and N-1<=a<=K+N-1 and N+b-6<=a<=2N-4 and "
2988 "b<=2N-3K+a and 3b<=4N-K+1 and b>=N and a>=x+1 }",
2989 "[K, N] -> { [x, y] -> [1 + x, N] : x >= -6 + 2N and "
2990 "x <= -5 + 2N and x >= -1 + 3K - N and x <= -2 + K + N and "
2991 "x >= 4 }" },
2992 { "{ [i, k, j] -> [a, b, c, d] : 8*floor((b)/8) = b and k <= 255 and "
2993 "a <= 255 and c <= 255 and d <= 255 - j and "
2994 "255 - j <= 7d <= 7 - i and 240d <= 239 + a and "
2995 "247d <= 247 + k - j and 247d <= 247 + k - b and "
2996 "247d <= 247 + i and 248 - b <= 248d <= c and "
2997 "254d >= i - a + b and 254d >= -a + b and "
2998 "255d >= -i + a - b and 1792d >= -63736 + 257b }",
2999 "{ [i, k, j] -> "
3000 "[-127762 + i + 502j, -62992 + 248j, 63240 - 248j, 255 - j] : "
3001 "k <= 255 and 7j >= 1778 + i and 246j >= 62738 - k and "
3002 "247j >= 62738 - i and 509j <= 129795 + i and "
3003 "742j >= 188724 - i; "
3004 "[0, k, j] -> [1, 0, 248, 1] : k <= 255 and 248 <= j <= 254, k }" },
3005 { "{ [a] -> [b] : 0 <= b <= 255 and -509 + a <= 512b < a and "
3006 "16*floor((8 + b)/16) <= 7 + b; "
3007 "[a] -> [1] }",
3008 "{ [a] -> [b = 1] : a >= 510 or a <= 0; "
3009 "[a] -> [b = 0] : 0 < a <= 509 }" },
3010 { "{ rat: [i] : 1 <= 2i <= 9 }", "{ rat: [i] : 2i = 1 }" },
3011 { "{ rat: [i] : 1 <= 2i <= 9 or i >= 10 }", "{ rat: [i] : 2i = 1 }" },
3012 { "{ rat: [i] : 21 <= 2i <= 29 or i = 5 }", "{ rat: [5] }" },
3013};
3014
3015static int test_lexmin(struct isl_ctx *ctx)
3016{
3017 int i;
3018 int equal;
3019 const char *str;
3020 isl_basic_map *bmap;
3021 isl_map *map, *map2;
3022 isl_setisl_map *set;
3023 isl_setisl_map *set2;
3024 isl_pw_multi_aff *pma;
3025
3026 str = "[p0, p1] -> { [] -> [] : "
3027 "exists (e0 = [(2p1)/3], e1, e2, e3 = [(3 - p1 + 3e0)/3], "
3028 "e4 = [(p1)/3], e5 = [(p1 + 3e4)/3]: "
3029 "3e0 >= -2 + 2p1 and 3e0 >= p1 and 3e3 >= 1 - p1 + 3e0 and "
3030 "3e0 <= 2p1 and 3e3 >= -2 + p1 and 3e3 <= -1 + p1 and p1 >= 3 and "
3031 "3e5 >= -2 + 2p1 and 3e5 >= p1 and 3e5 <= -1 + p1 + 3e4 and "
3032 "3e4 <= p1 and 3e4 >= -2 + p1 and e3 <= -1 + e0 and "
3033 "3e4 >= 6 - p1 + 3e1 and 3e1 >= p1 and 3e5 >= -2 + p1 + 3e4 and "
3034 "2e4 >= 3 - p1 + 2e1 and e4 <= e1 and 3e3 <= 2 - p1 + 3e0 and "
3035 "e5 >= 1 + e1 and 3e4 >= 6 - 2p1 + 3e1 and "
3036 "p0 >= 2 and p1 >= p0 and 3e2 >= p1 and 3e4 >= 6 - p1 + 3e2 and "
3037 "e2 <= e1 and e3 >= 1 and e4 <= e2) }";
3038 map = isl_map_read_from_str(ctx, str);
3039 map = isl_map_lexmin(map);
3040 isl_map_free(map);
3041 if (!map)
3042 return -1;
3043
3044 str = "[C] -> { [obj,a,b,c] : obj <= 38 a + 7 b + 10 c and "
3045 "a + b <= 1 and c <= 10 b and c <= C and a,b,c,C >= 0 }";
3046 set = isl_set_read_from_str(ctx, str);
3047 set = isl_set_lexmax(set);
3048 str = "[C] -> { [obj,a,b,c] : C = 8 }";
3049 set2 = isl_set_read_from_str(ctx, str);
3050 set = isl_set_intersect(set, set2);
3051 assert(!isl_set_is_empty(set))((void) sizeof ((!isl_set_is_empty(set)) ? 1 : 0), __extension__
({ if (!isl_set_is_empty(set)) ; else __assert_fail ("!isl_set_is_empty(set)"
, "polly/lib/External/isl/isl_test.c", 3051, __extension__ __PRETTY_FUNCTION__
); }))
;
3052 isl_set_free(set);
3053
3054 for (i = 0; i < ARRAY_SIZE(lexmin_tests)(sizeof(lexmin_tests)/sizeof(*lexmin_tests)); ++i) {
3055 map = isl_map_read_from_str(ctx, lexmin_tests[i].map);
3056 map = isl_map_lexmin(map);
3057 map2 = isl_map_read_from_str(ctx, lexmin_tests[i].lexmin);
3058 equal = isl_map_is_equal(map, map2);
3059 isl_map_free(map);
3060 isl_map_free(map2);
3061
3062 if (equal < 0)
3063 return -1;
3064 if (!equal)
3065 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 3066); return -1; } while
(0)
3066 "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 3066); return -1; } while
(0)
;
3067 }
3068
3069 str = "{ [i] -> [i', j] : j = i - 8i' and i' >= 0 and i' <= 7 and "
3070 " 8i' <= i and 8i' >= -7 + i }";
3071 bmap = isl_basic_map_read_from_str(ctx, str);
3072 pma = isl_basic_map_lexmin_pw_multi_aff(isl_basic_map_copy(bmap));
3073 map2 = isl_map_from_pw_multi_aff(pma);
3074 map = isl_map_from_basic_map(bmap);
3075 assert(isl_map_is_equal(map, map2))((void) sizeof ((isl_map_is_equal(map, map2)) ? 1 : 0), __extension__
({ if (isl_map_is_equal(map, map2)) ; else __assert_fail ("isl_map_is_equal(map, map2)"
, "polly/lib/External/isl/isl_test.c", 3075, __extension__ __PRETTY_FUNCTION__
); }))
;
3076 isl_map_free(map);
3077 isl_map_free(map2);
3078
3079 str = "[i] -> { [i', j] : j = i - 8i' and i' >= 0 and i' <= 7 and "
3080 " 8i' <= i and 8i' >= -7 + i }";
3081 set = isl_set_read_from_str(ctx, str);
3082 pma = isl_set_lexmin_pw_multi_aff(isl_set_copy(set));
3083 set2 = isl_set_from_pw_multi_aff(pma);
3084 equal = isl_set_is_equal(set, set2);
3085 isl_set_free(set);
3086 isl_set_free(set2);
3087 if (equal < 0)
3088 return -1;
3089 if (!equal)
3090 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected difference between set and "
"piecewise affine expression", "polly/lib/External/isl/isl_test.c"
, 3092); return -1; } while (0)
3091 "unexpected difference between set and "do { isl_handle_error(ctx, isl_error_unknown, "unexpected difference between set and "
"piecewise affine expression", "polly/lib/External/isl/isl_test.c"
, 3092); return -1; } while (0)
3092 "piecewise affine expression", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected difference between set and "
"piecewise affine expression", "polly/lib/External/isl/isl_test.c"
, 3092); return -1; } while (0)
;
3093
3094 return 0;
3095}
3096
3097/* Inputs for isl_pw_multi_aff_max_multi_val tests.
3098 * "pma" is the input.
3099 * "res" is the expected result.
3100 */
3101static struct {
3102 const char *pma;
3103 const char *res;
3104} opt_pw_tests[] = {
3105 { "{ [-1] -> [-1]; [1] -> [1] }", "{ [1] }" },
3106 { "{ [a, b] -> [floor((b - 2*floor((-a)/4))/5)] : "
3107 "0 <= a, b <= 100 and b mod 2 = 0}", "{ [30] }" },
3108 { "[N] -> { [i,j] -> A[i, -i, i + j] : 0 <= i,j <= N <= 10 }",
3109 "{ A[10, 0, 20] }" },
3110 { "[N] -> {A[N, -N, 2N] : 0 <= N }", "{ A[infty, 0, infty] }" },
3111};
3112
3113/* Perform basic isl_pw_multi_aff_max_multi_val tests.
3114 */
3115static isl_stat test_pw_max(struct isl_ctx *ctx)
3116{
3117 int i;
3118 isl_pw_multi_aff *pma;
3119 isl_multi_val *mv;
3120 isl_stat r;
3121
3122 for (i = 0; i < ARRAY_SIZE(opt_pw_tests)(sizeof(opt_pw_tests)/sizeof(*opt_pw_tests)); ++i) {
3123 pma = isl_pw_multi_aff_read_from_str(ctx, opt_pw_tests[i].pma);
3124 mv = isl_pw_multi_aff_max_multi_val(pma);
3125 r = multi_val_check_plain_equal(mv, opt_pw_tests[i].res);
3126 isl_multi_val_free(mv);
3127
3128 if (r < 0)
3129 return isl_stat_error;
3130 }
3131
3132 return isl_stat_ok;
3133}
3134
3135/* A specialized isl_set_min_val test case that would return the wrong result
3136 * in earlier versions of isl.
3137 * The explicit call to isl_basic_set_union prevents the second basic set
3138 * from being determined to be empty prior to the call to isl_set_min_val,
3139 * at least at the point where this test case was introduced.
3140 */
3141static int test_min_special(isl_ctx *ctx)
3142{
3143 const char *str;
3144 isl_basic_setisl_basic_map *bset1, *bset2;
3145 isl_setisl_map *set;
3146 isl_aff *obj;
3147 isl_val *res;
3148 int ok;
3149
3150 str = "{ [a, b] : a >= 2 and b >= 0 and 14 - a <= b <= 9 }";
3151 bset1 = isl_basic_set_read_from_str(ctx, str);
3152 str = "{ [a, b] : 1 <= a, b and a + b <= 1 }";
3153 bset2 = isl_basic_set_read_from_str(ctx, str);
3154 set = isl_basic_set_union(bset1, bset2);
3155 obj = isl_aff_read_from_str(ctx, "{ [a, b] -> [a] }");
3156
3157 res = isl_set_min_val(set, obj);
3158 ok = isl_val_cmp_si(res, 5) == 0;
3159
3160 isl_aff_free(obj);
3161 isl_set_free(set);
3162 isl_val_free(res);
3163
3164 if (!res)
3165 return -1;
3166 if (!ok)
3167 isl_die(ctx, isl_error_unknown, "unexpected minimum",do { isl_handle_error(ctx, isl_error_unknown, "unexpected minimum"
, "polly/lib/External/isl/isl_test.c", 3168); return -1; } while
(0)
3168 return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected minimum"
, "polly/lib/External/isl/isl_test.c", 3168); return -1; } while
(0)
;
3169
3170 return 0;
3171}
3172
3173/* A specialized isl_set_min_val test case that would return an error
3174 * in earlier versions of isl.
3175 */
3176static int test_min_special2(isl_ctx *ctx)
3177{
3178 const char *str;
3179 isl_basic_setisl_basic_map *bset;
3180 isl_aff *obj;
3181 isl_val *res;
3182
3183 str = "{ [i, j, k] : 2j = i and 2k = i + 1 and i >= 2 }";
3184 bset = isl_basic_set_read_from_str(ctx, str);
3185
3186 obj = isl_aff_read_from_str(ctx, "{ [i, j, k] -> [i] }");
3187
3188 res = isl_basic_set_max_val(bset, obj);
3189
3190 isl_basic_set_free(bset);
3191 isl_aff_free(obj);
3192 isl_val_free(res);
3193
3194 if (!res)
3195 return -1;
3196
3197 return 0;
3198}
3199
3200/* Check that the result of isl_set_min_multi_pw_aff
3201 * on the union of the sets with string descriptions "s1" and "s2"
3202 * consists of a single expression (on a single cell).
3203 */
3204static isl_stat check_single_expr_min(isl_ctx *ctx, const char *s1,
3205 const char *s2)
3206{
3207 isl_size n;
3208 isl_setisl_map *set1, *set2;
3209 isl_multi_pw_aff *mpa;
3210 isl_pw_multi_aff *pma;
3211
3212 set1 = isl_set_read_from_str(ctx, s1);
3213 set2 = isl_set_read_from_str(ctx, s2);
3214 set1 = isl_set_union(set1, set2);
3215 mpa = isl_set_min_multi_pw_aff(set1);
3216 pma = isl_pw_multi_aff_from_multi_pw_aff(mpa);
3217 n = isl_pw_multi_aff_n_piece(pma);
3218 isl_pw_multi_aff_free(pma);
3219
3220 if (n < 0)
3221 return isl_stat_error;
3222 if (n != 1)
3223 isl_die(ctx, isl_error_unknown, "expecting single expression",do { isl_handle_error(ctx, isl_error_unknown, "expecting single expression"
, "polly/lib/External/isl/isl_test.c", 3224); return isl_stat_error
; } while (0)
3224 return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "expecting single expression"
, "polly/lib/External/isl/isl_test.c", 3224); return isl_stat_error
; } while (0)
;
3225 return isl_stat_ok;
3226}
3227
3228/* A specialized isl_set_min_multi_pw_aff test that checks
3229 * that the minimum of 2N and 3N for N >= 0 is represented
3230 * by a single expression, without splitting off the special case N = 0.
3231 * Do this for both orderings.
3232 */
3233static int test_min_mpa(isl_ctx *ctx)
3234{
3235 const char *s1, *s2;
3236
3237 s1 = "[N=0:] -> { [1, 3N:] }";
3238 s2 = "[N=0:] -> { [10, 2N:] }";
3239 if (check_single_expr_min(ctx, s1, s2) < 0)
3240 return -1;
3241 if (check_single_expr_min(ctx, s2, s1) < 0)
3242 return -1;
3243
3244 return 0;
3245}
3246
3247struct {
3248 const char *set;
3249 const char *obj;
3250 __isl_give isl_val *(*fn)(__isl_keep isl_setisl_map *set,
3251 __isl_keep isl_aff *obj);
3252 const char *res;
3253} opt_tests[] = {
3254 { "{ [-1]; [1] }", "{ [x] -> [x] }", &isl_set_min_val, "-1" },
3255 { "{ [-1]; [1] }", "{ [x] -> [x] }", &isl_set_max_val, "1" },
3256 { "{ [a, b] : 0 <= a, b <= 100 and b mod 2 = 0}",
3257 "{ [a, b] -> [floor((b - 2*floor((-a)/4))/5)] }",
3258 &isl_set_max_val, "30" },
3259
3260};
3261
3262/* Perform basic isl_set_min_val and isl_set_max_val tests.
3263 * In particular, check the results on non-convex inputs.
3264 */
3265static int test_min(struct isl_ctx *ctx)
3266{
3267 int i;
3268 isl_setisl_map *set;
3269 isl_aff *obj;
3270 isl_val *val, *res;
3271 isl_bool ok;
3272
3273 for (i = 0; i < ARRAY_SIZE(opt_tests)(sizeof(opt_tests)/sizeof(*opt_tests)); ++i) {
3274 set = isl_set_read_from_str(ctx, opt_tests[i].set);
3275 obj = isl_aff_read_from_str(ctx, opt_tests[i].obj);
3276 res = isl_val_read_from_str(ctx, opt_tests[i].res);
3277 val = opt_tests[i].fn(set, obj);
3278 ok = isl_val_eq(res, val);
3279 isl_val_free(res);
3280 isl_val_free(val);
3281 isl_aff_free(obj);
3282 isl_set_free(set);
3283
3284 if (ok < 0)
3285 return -1;
3286 if (!ok)
3287 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected optimum"
, "polly/lib/External/isl/isl_test.c", 3288); return -1; } while
(0)
3288 "unexpected optimum", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected optimum"
, "polly/lib/External/isl/isl_test.c", 3288); return -1; } while
(0)
;
3289 }
3290
3291 if (test_pw_max(ctx) < 0)
3292 return -1;
3293 if (test_min_special(ctx) < 0)
3294 return -1;
3295 if (test_min_special2(ctx) < 0)
3296 return -1;
3297
3298 return 0;
3299}
3300
3301struct must_may {
3302 isl_map *must;
3303 isl_map *may;
3304};
3305
3306static isl_stat collect_must_may(__isl_take isl_map *dep, int must,
3307 void *dep_user, void *user)
3308{
3309 struct must_may *mm = (struct must_may *)user;
3310
3311 if (must)
3312 mm->must = isl_map_union(mm->must, dep);
3313 else
3314 mm->may = isl_map_union(mm->may, dep);
3315
3316 return isl_stat_ok;
3317}
3318
3319static int common_space(void *first, void *second)
3320{
3321 int depth = *(int *)first;
3322 return 2 * depth;
3323}
3324
3325static int map_is_equal(__isl_keep isl_map *map, const char *str)
3326{
3327 isl_map *map2;
3328 int equal;
3329
3330 if (!map)
3331 return -1;
3332
3333 map2 = isl_map_read_from_str(map->ctx, str);
3334 equal = isl_map_is_equal(map, map2);
3335 isl_map_free(map2);
3336
3337 return equal;
3338}
3339
3340static int map_check_equal(__isl_keep isl_map *map, const char *str)
3341{
3342 int equal;
3343
3344 equal = map_is_equal(map, str);
3345 if (equal < 0)
3346 return -1;
3347 if (!equal)
3348 isl_die(isl_map_get_ctx(map), isl_error_unknown,do { isl_handle_error(isl_map_get_ctx(map), isl_error_unknown
, "result not as expected", "polly/lib/External/isl/isl_test.c"
, 3349); return -1; } while (0)
3349 "result not as expected", return -1)do { isl_handle_error(isl_map_get_ctx(map), isl_error_unknown
, "result not as expected", "polly/lib/External/isl/isl_test.c"
, 3349); return -1; } while (0)
;
3350 return 0;
3351}
3352
3353/* Is "set" equal to the set described by "str"?
3354 */
3355static isl_bool set_is_equal(__isl_keep isl_setisl_map *set, const char *str)
3356{
3357 isl_setisl_map *set2;
3358 isl_bool equal;
3359
3360 if (!set)
3361 return isl_bool_error;
3362
3363 set2 = isl_set_read_from_str(isl_set_get_ctx(set), str);
3364 equal = isl_set_is_equal(set, set2);
3365 isl_set_free(set2);
3366
3367 return equal;
3368}
3369
3370/* Check that "set" is equal to the set described by "str".
3371 */
3372static isl_stat set_check_equal(__isl_keep isl_setisl_map *set, const char *str)
3373{
3374 isl_bool equal;
3375
3376 equal = set_is_equal(set, str);
3377 if (equal < 0)
3378 return isl_stat_error;
3379 if (!equal)
3380 isl_die(isl_set_get_ctx(set), isl_error_unknown,do { isl_handle_error(isl_set_get_ctx(set), isl_error_unknown
, "result not as expected", "polly/lib/External/isl/isl_test.c"
, 3381); return isl_stat_error; } while (0)
3381 "result not as expected", return isl_stat_error)do { isl_handle_error(isl_set_get_ctx(set), isl_error_unknown
, "result not as expected", "polly/lib/External/isl/isl_test.c"
, 3381); return isl_stat_error; } while (0)
;
3382 return isl_stat_ok;
3383}
3384
3385/* Is "uset" equal to the union set described by "str"?
3386 */
3387static isl_bool uset_is_equal(__isl_keep isl_union_set *uset, const char *str)
3388{
3389 isl_union_set *uset2;
3390 isl_bool equal;
3391
3392 if (!uset)
3393 return isl_bool_error;
3394
3395 uset2 = isl_union_set_read_from_str(isl_union_set_get_ctx(uset), str);
3396 equal = isl_union_set_is_equal(uset, uset2);
3397 isl_union_set_free(uset2);
3398
3399 return equal;
3400}
3401
3402/* Check that "uset" is equal to the union set described by "str".
3403 */
3404static isl_stat uset_check_equal(__isl_keep isl_union_set *uset,
3405 const char *str)
3406{
3407 isl_bool equal;
3408
3409 equal = uset_is_equal(uset, str);
3410 if (equal < 0)
3411 return isl_stat_error;
3412 if (!equal)
3413 isl_die(isl_union_set_get_ctx(uset), isl_error_unknown,do { isl_handle_error(isl_union_set_get_ctx(uset), isl_error_unknown
, "result not as expected", "polly/lib/External/isl/isl_test.c"
, 3414); return isl_stat_error; } while (0)
3414 "result not as expected", return isl_stat_error)do { isl_handle_error(isl_union_set_get_ctx(uset), isl_error_unknown
, "result not as expected", "polly/lib/External/isl/isl_test.c"
, 3414); return isl_stat_error; } while (0)
;
3415 return isl_stat_ok;
3416}
3417
3418static int test_dep(struct isl_ctx *ctx)
3419{
3420 const char *str;
3421 isl_space *space;
3422 isl_map *map;
3423 isl_access_info *ai;
3424 isl_flow *flow;
3425 int depth;
3426 struct must_may mm;
3427
3428 depth = 3;
3429
3430 str = "{ [2,i,0] -> [i] : 0 <= i <= 10 }";
3431 map = isl_map_read_from_str(ctx, str);
3432 ai = isl_access_info_alloc(map, &depth, &common_space, 2);
3433
3434 str = "{ [0,i,0] -> [i] : 0 <= i <= 10 }";
3435 map = isl_map_read_from_str(ctx, str);
3436 ai = isl_access_info_add_source(ai, map, 1, &depth);
3437
3438 str = "{ [1,i,0] -> [5] : 0 <= i <= 10 }";
3439 map = isl_map_read_from_str(ctx, str);
3440 ai = isl_access_info_add_source(ai, map, 1, &depth);
3441
3442 flow = isl_access_info_compute_flow(ai);
3443 space = isl_space_alloc(ctx, 0, 3, 3);
3444 mm.must = isl_map_empty(isl_space_copy(space));
3445 mm.may = isl_map_empty(space);
3446
3447 isl_flow_foreach(flow, collect_must_may, &mm);
3448
3449 str = "{ [0,i,0] -> [2,i,0] : (0 <= i <= 4) or (6 <= i <= 10); "
3450 " [1,10,0] -> [2,5,0] }";
3451 assert(map_is_equal(mm.must, str))((void) sizeof ((map_is_equal(mm.must, str)) ? 1 : 0), __extension__
({ if (map_is_equal(mm.must, str)) ; else __assert_fail ("map_is_equal(mm.must, str)"
, "polly/lib/External/isl/isl_test.c", 3451, __extension__ __PRETTY_FUNCTION__
); }))
;
3452 str = "{ [i,j,k] -> [l,m,n] : 1 = 0 }";
3453 assert(map_is_equal(mm.may, str))((void) sizeof ((map_is_equal(mm.may, str)) ? 1 : 0), __extension__
({ if (map_is_equal(mm.may, str)) ; else __assert_fail ("map_is_equal(mm.may, str)"
, "polly/lib/External/isl/isl_test.c", 3453, __extension__ __PRETTY_FUNCTION__
); }))
;
3454
3455 isl_map_free(mm.must);
3456 isl_map_free(mm.may);
3457 isl_flow_free(flow);
3458
3459
3460 str = "{ [2,i,0] -> [i] : 0 <= i <= 10 }";
3461 map = isl_map_read_from_str(ctx, str);
3462 ai = isl_access_info_alloc(map, &depth, &common_space, 2);
3463
3464 str = "{ [0,i,0] -> [i] : 0 <= i <= 10 }";
3465 map = isl_map_read_from_str(ctx, str);
3466 ai = isl_access_info_add_source(ai, map, 1, &depth);
3467
3468 str = "{ [1,i,0] -> [5] : 0 <= i <= 10 }";
3469 map = isl_map_read_from_str(ctx, str);
3470 ai = isl_access_info_add_source(ai, map, 0, &depth);
3471
3472 flow = isl_access_info_compute_flow(ai);
3473 space = isl_space_alloc(ctx, 0, 3, 3);
3474 mm.must = isl_map_empty(isl_space_copy(space));
3475 mm.may = isl_map_empty(space);
3476
3477 isl_flow_foreach(flow, collect_must_may, &mm);
3478
3479 str = "{ [0,i,0] -> [2,i,0] : (0 <= i <= 4) or (6 <= i <= 10) }";
3480 assert(map_is_equal(mm.must, str))((void) sizeof ((map_is_equal(mm.must, str)) ? 1 : 0), __extension__
({ if (map_is_equal(mm.must, str)) ; else __assert_fail ("map_is_equal(mm.must, str)"
, "polly/lib/External/isl/isl_test.c", 3480, __extension__ __PRETTY_FUNCTION__
); }))
;
3481 str = "{ [0,5,0] -> [2,5,0]; [1,i,0] -> [2,5,0] : 0 <= i <= 10 }";
3482 assert(map_is_equal(mm.may, str))((void) sizeof ((map_is_equal(mm.may, str)) ? 1 : 0), __extension__
({ if (map_is_equal(mm.may, str)) ; else __assert_fail ("map_is_equal(mm.may, str)"
, "polly/lib/External/isl/isl_test.c", 3482, __extension__ __PRETTY_FUNCTION__
); }))
;
3483
3484 isl_map_free(mm.must);
3485 isl_map_free(mm.may);
3486 isl_flow_free(flow);
3487
3488
3489 str = "{ [2,i,0] -> [i] : 0 <= i <= 10 }";
3490 map = isl_map_read_from_str(ctx, str);
3491 ai = isl_access_info_alloc(map, &depth, &common_space, 2);
3492
3493 str = "{ [0,i,0] -> [i] : 0 <= i <= 10 }";
3494 map = isl_map_read_from_str(ctx, str);
3495 ai = isl_access_info_add_source(ai, map, 0, &depth);
3496
3497 str = "{ [1,i,0] -> [5] : 0 <= i <= 10 }";
3498 map = isl_map_read_from_str(ctx, str);
3499 ai = isl_access_info_add_source(ai, map, 0, &depth);
3500
3501 flow = isl_access_info_compute_flow(ai);
3502 space = isl_space_alloc(ctx, 0, 3, 3);
3503 mm.must = isl_map_empty(isl_space_copy(space));
3504 mm.may = isl_map_empty(space);
3505
3506 isl_flow_foreach(flow, collect_must_may, &mm);
3507
3508 str = "{ [0,i,0] -> [2,i,0] : 0 <= i <= 10; "
3509 " [1,i,0] -> [2,5,0] : 0 <= i <= 10 }";
3510 assert(map_is_equal(mm.may, str))((void) sizeof ((map_is_equal(mm.may, str)) ? 1 : 0), __extension__
({ if (map_is_equal(mm.may, str)) ; else __assert_fail ("map_is_equal(mm.may, str)"
, "polly/lib/External/isl/isl_test.c", 3510, __extension__ __PRETTY_FUNCTION__
); }))
;
3511 str = "{ [i,j,k] -> [l,m,n] : 1 = 0 }";
3512 assert(map_is_equal(mm.must, str))((void) sizeof ((map_is_equal(mm.must, str)) ? 1 : 0), __extension__
({ if (map_is_equal(mm.must, str)) ; else __assert_fail ("map_is_equal(mm.must, str)"
, "polly/lib/External/isl/isl_test.c", 3512, __extension__ __PRETTY_FUNCTION__
); }))
;
3513
3514 isl_map_free(mm.must);
3515 isl_map_free(mm.may);
3516 isl_flow_free(flow);
3517
3518
3519 str = "{ [0,i,2] -> [i] : 0 <= i <= 10 }";
3520 map = isl_map_read_from_str(ctx, str);
3521 ai = isl_access_info_alloc(map, &depth, &common_space, 2);
3522
3523 str = "{ [0,i,0] -> [i] : 0 <= i <= 10 }";
3524 map = isl_map_read_from_str(ctx, str);
3525 ai = isl_access_info_add_source(ai, map, 0, &depth);
3526
3527 str = "{ [0,i,1] -> [5] : 0 <= i <= 10 }";
3528 map = isl_map_read_from_str(ctx, str);
3529 ai = isl_access_info_add_source(ai, map, 0, &depth);
3530
3531 flow = isl_access_info_compute_flow(ai);
3532 space = isl_space_alloc(ctx, 0, 3, 3);
3533 mm.must = isl_map_empty(isl_space_copy(space));
3534 mm.may = isl_map_empty(space);
3535
3536 isl_flow_foreach(flow, collect_must_may, &mm);
3537
3538 str = "{ [0,i,0] -> [0,i,2] : 0 <= i <= 10; "
3539 " [0,i,1] -> [0,5,2] : 0 <= i <= 5 }";
3540 assert(map_is_equal(mm.may, str))((void) sizeof ((map_is_equal(mm.may, str)) ? 1 : 0), __extension__
({ if (map_is_equal(mm.may, str)) ; else __assert_fail ("map_is_equal(mm.may, str)"
, "polly/lib/External/isl/isl_test.c", 3540, __extension__ __PRETTY_FUNCTION__
); }))
;
3541 str = "{ [i,j,k] -> [l,m,n] : 1 = 0 }";
3542 assert(map_is_equal(mm.must, str))((void) sizeof ((map_is_equal(mm.must, str)) ? 1 : 0), __extension__
({ if (map_is_equal(mm.must, str)) ; else __assert_fail ("map_is_equal(mm.must, str)"
, "polly/lib/External/isl/isl_test.c", 3542, __extension__ __PRETTY_FUNCTION__
); }))
;
3543
3544 isl_map_free(mm.must);
3545 isl_map_free(mm.may);
3546 isl_flow_free(flow);
3547
3548
3549 str = "{ [0,i,1] -> [i] : 0 <= i <= 10 }";
3550 map = isl_map_read_from_str(ctx, str);
3551 ai = isl_access_info_alloc(map, &depth, &common_space, 2);
3552
3553 str = "{ [0,i,0] -> [i] : 0 <= i <= 10 }";
3554 map = isl_map_read_from_str(ctx, str);
3555 ai = isl_access_info_add_source(ai, map, 0, &depth);
3556
3557 str = "{ [0,i,2] -> [5] : 0 <= i <= 10 }";
3558 map = isl_map_read_from_str(ctx, str);
3559 ai = isl_access_info_add_source(ai, map, 0, &depth);
3560
3561 flow = isl_access_info_compute_flow(ai);
3562 space = isl_space_alloc(ctx, 0, 3, 3);
3563 mm.must = isl_map_empty(isl_space_copy(space));
3564 mm.may = isl_map_empty(space);
3565
3566 isl_flow_foreach(flow, collect_must_may, &mm);
3567
3568 str = "{ [0,i,0] -> [0,i,1] : 0 <= i <= 10; "
3569 " [0,i,2] -> [0,5,1] : 0 <= i <= 4 }";
3570 assert(map_is_equal(mm.may, str))((void) sizeof ((map_is_equal(mm.may, str)) ? 1 : 0), __extension__
({ if (map_is_equal(mm.may, str)) ; else __assert_fail ("map_is_equal(mm.may, str)"
, "polly/lib/External/isl/isl_test.c", 3570, __extension__ __PRETTY_FUNCTION__
); }))
;
3571 str = "{ [i,j,k] -> [l,m,n] : 1 = 0 }";
3572 assert(map_is_equal(mm.must, str))((void) sizeof ((map_is_equal(mm.must, str)) ? 1 : 0), __extension__
({ if (map_is_equal(mm.must, str)) ; else __assert_fail ("map_is_equal(mm.must, str)"
, "polly/lib/External/isl/isl_test.c", 3572, __extension__ __PRETTY_FUNCTION__
); }))
;
3573
3574 isl_map_free(mm.must);
3575 isl_map_free(mm.may);
3576 isl_flow_free(flow);
3577
3578
3579 depth = 5;
3580
3581 str = "{ [1,i,0,0,0] -> [i,j] : 0 <= i <= 10 and 0 <= j <= 10 }";
3582 map = isl_map_read_from_str(ctx, str);
3583 ai = isl_access_info_alloc(map, &depth, &common_space, 1);
3584
3585 str = "{ [0,i,0,j,0] -> [i,j] : 0 <= i <= 10 and 0 <= j <= 10 }";
3586 map = isl_map_read_from_str(ctx, str);
3587 ai = isl_access_info_add_source(ai, map, 1, &depth);
3588
3589 flow = isl_access_info_compute_flow(ai);
3590 space = isl_space_alloc(ctx, 0, 5, 5);
3591 mm.must = isl_map_empty(isl_space_copy(space));
3592 mm.may = isl_map_empty(space);
3593
3594 isl_flow_foreach(flow, collect_must_may, &mm);
3595
3596 str = "{ [0,i,0,j,0] -> [1,i,0,0,0] : 0 <= i,j <= 10 }";
3597 assert(map_is_equal(mm.must, str))((void) sizeof ((map_is_equal(mm.must, str)) ? 1 : 0), __extension__
({ if (map_is_equal(mm.must, str)) ; else __assert_fail ("map_is_equal(mm.must, str)"
, "polly/lib/External/isl/isl_test.c", 3597, __extension__ __PRETTY_FUNCTION__
); }))
;
3598 str = "{ [0,0,0,0,0] -> [0,0,0,0,0] : 1 = 0 }";
3599 assert(map_is_equal(mm.may, str))((void) sizeof ((map_is_equal(mm.may, str)) ? 1 : 0), __extension__
({ if (map_is_equal(mm.may, str)) ; else __assert_fail ("map_is_equal(mm.may, str)"
, "polly/lib/External/isl/isl_test.c", 3599, __extension__ __PRETTY_FUNCTION__
); }))
;
3600
3601 isl_map_free(mm.must);
3602 isl_map_free(mm.may);
3603 isl_flow_free(flow);
3604
3605 return 0;
3606}
3607
3608/* Check that the dependence analysis proceeds without errors.
3609 * Earlier versions of isl would break down during the analysis
3610 * due to the use of the wrong spaces.
3611 */
3612static int test_flow(isl_ctx *ctx)
3613{
3614 const char *str;
3615 isl_union_map *access, *schedule;
3616 isl_union_map *must_dep, *may_dep;
3617 int r;
3618
3619 str = "{ S0[j] -> i[]; S1[j,i] -> i[]; S2[] -> i[]; S3[] -> i[] }";
3620 access = isl_union_map_read_from_str(ctx, str);
3621 str = "{ S0[j] -> [0,j,0,0] : 0 <= j < 10; "
3622 "S1[j,i] -> [0,j,1,i] : 0 <= j < i < 10; "
3623 "S2[] -> [1,0,0,0]; "
3624 "S3[] -> [-1,0,0,0] }";
3625 schedule = isl_union_map_read_from_str(ctx, str);
3626 r = isl_union_map_compute_flow(access, isl_union_map_copy(access),
3627 isl_union_map_copy(access), schedule,
3628 &must_dep, &may_dep, NULL((void*)0), NULL((void*)0));
3629 isl_union_map_free(may_dep);
3630 isl_union_map_free(must_dep);
3631
3632 return r;
3633}
3634
3635struct {
3636 const char *map;
3637 int sv;
3638} sv_tests[] = {
3639 { "[N] -> { [i] -> [f] : 0 <= i <= N and 0 <= i - 10 f <= 9 }", 1 },
3640 { "[N] -> { [i] -> [f] : 0 <= i <= N and 0 <= i - 10 f <= 10 }", 0 },
3641 { "{ [i] -> [3*floor(i/2) + 5*floor(i/3)] }", 1 },
3642 { "{ S1[i] -> [i] : 0 <= i <= 9; S2[i] -> [i] : 0 <= i <= 9 }", 1 },
3643 { "{ [i] -> S1[i] : 0 <= i <= 9; [i] -> S2[i] : 0 <= i <= 9 }", 0 },
3644 { "{ A[i] -> [i]; B[i] -> [i]; B[i] -> [i + 1] }", 0 },
3645 { "{ A[i] -> [i]; B[i] -> [i] : i < 0; B[i] -> [i + 1] : i > 0 }", 1 },
3646 { "{ A[i] -> [i]; B[i] -> A[i] : i < 0; B[i] -> [i + 1] : i > 0 }", 1 },
3647 { "{ A[i] -> [i]; B[i] -> [j] : i - 1 <= j <= i }", 0 },
3648};
3649
3650int test_sv(isl_ctx *ctx)
3651{
3652 isl_union_map *umap;
3653 int i;
3654 int sv;
3655
3656 for (i = 0; i < ARRAY_SIZE(sv_tests)(sizeof(sv_tests)/sizeof(*sv_tests)); ++i) {
3657 umap = isl_union_map_read_from_str(ctx, sv_tests[i].map);
3658 sv = isl_union_map_is_single_valued(umap);
3659 isl_union_map_free(umap);
3660 if (sv < 0)
3661 return -1;
3662 if (sv_tests[i].sv && !sv)
3663 isl_die(ctx, isl_error_internal,do { isl_handle_error(ctx, isl_error_internal, "map not detected as single valued"
, "polly/lib/External/isl/isl_test.c", 3664); return -1; } while
(0)
3664 "map not detected as single valued", return -1)do { isl_handle_error(ctx, isl_error_internal, "map not detected as single valued"
, "polly/lib/External/isl/isl_test.c", 3664); return -1; } while
(0)
;
3665 if (!sv_tests[i].sv && sv)
3666 isl_die(ctx, isl_error_internal,do { isl_handle_error(ctx, isl_error_internal, "map detected as single valued"
, "polly/lib/External/isl/isl_test.c", 3667); return -1; } while
(0)
3667 "map detected as single valued", return -1)do { isl_handle_error(ctx, isl_error_internal, "map detected as single valued"
, "polly/lib/External/isl/isl_test.c", 3667); return -1; } while
(0)
;
3668 }
3669
3670 return 0;
3671}
3672
3673struct {
3674 const char *str;
3675 int bijective;
3676} bijective_tests[] = {
3677 { "[N,M]->{[i,j] -> [i]}", 0 },
3678 { "[N,M]->{[i,j] -> [i] : j=i}", 1 },
3679 { "[N,M]->{[i,j] -> [i] : j=0}", 1 },
3680 { "[N,M]->{[i,j] -> [i] : j=N}", 1 },
3681 { "[N,M]->{[i,j] -> [j,i]}", 1 },
3682 { "[N,M]->{[i,j] -> [i+j]}", 0 },
3683 { "[N,M]->{[i,j] -> []}", 0 },
3684 { "[N,M]->{[i,j] -> [i,j,N]}", 1 },
3685 { "[N,M]->{[i,j] -> [2i]}", 0 },
3686 { "[N,M]->{[i,j] -> [i,i]}", 0 },
3687 { "[N,M]->{[i,j] -> [2i,i]}", 0 },
3688 { "[N,M]->{[i,j] -> [2i,j]}", 1 },
3689 { "[N,M]->{[i,j] -> [x,y] : 2x=i & y =j}", 1 },
3690};
3691
3692static int test_bijective(struct isl_ctx *ctx)
3693{
3694 isl_map *map;
3695 int i;
3696 int bijective;
3697
3698 for (i = 0; i < ARRAY_SIZE(bijective_tests)(sizeof(bijective_tests)/sizeof(*bijective_tests)); ++i) {
3699 map = isl_map_read_from_str(ctx, bijective_tests[i].str);
3700 bijective = isl_map_is_bijective(map);
3701 isl_map_free(map);
3702 if (bijective < 0)
3703 return -1;
3704 if (bijective_tests[i].bijective && !bijective)
3705 isl_die(ctx, isl_error_internal,do { isl_handle_error(ctx, isl_error_internal, "map not detected as bijective"
, "polly/lib/External/isl/isl_test.c", 3706); return -1; } while
(0)
3706 "map not detected as bijective", return -1)do { isl_handle_error(ctx, isl_error_internal, "map not detected as bijective"
, "polly/lib/External/isl/isl_test.c", 3706); return -1; } while
(0)
;
3707 if (!bijective_tests[i].bijective && bijective)
3708 isl_die(ctx, isl_error_internal,do { isl_handle_error(ctx, isl_error_internal, "map detected as bijective"
, "polly/lib/External/isl/isl_test.c", 3709); return -1; } while
(0)
3709 "map detected as bijective", return -1)do { isl_handle_error(ctx, isl_error_internal, "map detected as bijective"
, "polly/lib/External/isl/isl_test.c", 3709); return -1; } while
(0)
;
3710 }
3711
3712 return 0;
3713}
3714
3715/* Inputs for isl_pw_qpolynomial_gist tests.
3716 * "pwqp" is the input, "set" is the context and "gist" is the expected result.
3717 */
3718struct {
3719 const char *pwqp;
3720 const char *set;
3721 const char *gist;
3722} pwqp_gist_tests[] = {
3723 { "{ [i] -> i }", "{ [k] : exists a : k = 2a }", "{ [i] -> i }" },
3724 { "{ [i] -> i + [ (i + [i/3])/2 ] }", "{ [10] }", "{ [i] -> 16 }" },
3725 { "{ [i] -> ([(i)/2]) }", "{ [k] : exists a : k = 2a+1 }",
3726 "{ [i] -> -1/2 + 1/2 * i }" },
3727 { "{ [i] -> i^2 : i != 0 }", "{ [i] : i != 0 }", "{ [i] -> i^2 }" },
3728};
3729
3730/* Perform some basic isl_pw_qpolynomial_gist tests.
3731 */
3732static isl_stat test_pwqp_gist(isl_ctx *ctx)
3733{
3734 int i;
3735 const char *str;
3736 isl_setisl_map *set;
3737 isl_pw_qpolynomial *pwqp1, *pwqp2;
3738 isl_bool equal;
3739
3740 for (i = 0; i < ARRAY_SIZE(pwqp_gist_tests)(sizeof(pwqp_gist_tests)/sizeof(*pwqp_gist_tests)); ++i) {
3741 str = pwqp_gist_tests[i].pwqp;
3742 pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
3743 str = pwqp_gist_tests[i].set;
3744 set = isl_set_read_from_str(ctx, str);
3745 pwqp1 = isl_pw_qpolynomial_gist(pwqp1, set);
3746 str = pwqp_gist_tests[i].gist;
3747 pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str);
3748 pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2);
3749 equal = isl_pw_qpolynomial_is_zero(pwqp1);
3750 isl_pw_qpolynomial_free(pwqp1);
3751
3752 if (equal < 0)
3753 return isl_stat_error;
3754 if (!equal)
3755 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 3756); return isl_stat_error
; } while (0)
3756 "unexpected result", return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 3756); return isl_stat_error
; } while (0)
;
3757 }
3758
3759 return isl_stat_ok;
3760}
3761
3762/* Perform a basic isl_pw_qpolynomial_max test.
3763 */
3764static isl_stat test_pwqp_max(isl_ctx *ctx)
3765{
3766 const char *str;
3767 isl_pw_qpolynomial *pwqp;
3768 isl_val *v;
3769 int ok;
3770
3771 str = "{ [x=2:9, y] -> floor((x + 1)/4)^3 - floor((2x)/3)^2 }";
3772 pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
3773 v = isl_pw_qpolynomial_max(pwqp);
3774 ok = isl_val_cmp_si(v, -1) == 0;
3775 isl_val_free(v);
3776
3777 if (!v)
3778 return isl_stat_error;
3779 if (!ok)
3780 isl_die(ctx, isl_error_unknown, "unexpected maximum",do { isl_handle_error(ctx, isl_error_unknown, "unexpected maximum"
, "polly/lib/External/isl/isl_test.c", 3781); return isl_stat_error
; } while (0)
3781 return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "unexpected maximum"
, "polly/lib/External/isl/isl_test.c", 3781); return isl_stat_error
; } while (0)
;
3782
3783 return isl_stat_ok;
3784}
3785
3786static int test_pwqp(struct isl_ctx *ctx)
3787{
3788 const char *str;
3789 isl_setisl_map *set;
3790 isl_pw_qpolynomial *pwqp1, *pwqp2;
3791 int equal;
3792
3793 str = "{ [i,j,k] -> 1 + 9 * [i/5] + 7 * [j/11] + 4 * [k/13] }";
3794 pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
3795
3796 pwqp1 = isl_pw_qpolynomial_move_dims(pwqp1, isl_dim_param, 0,
3797 isl_dim_in, 1, 1);
3798
3799 str = "[j] -> { [i,k] -> 1 + 9 * [i/5] + 7 * [j/11] + 4 * [k/13] }";
3800 pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str);
3801
3802 pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2);
3803
3804 assert(isl_pw_qpolynomial_is_zero(pwqp1))((void) sizeof ((isl_pw_qpolynomial_is_zero(pwqp1)) ? 1 : 0),
__extension__ ({ if (isl_pw_qpolynomial_is_zero(pwqp1)) ; else
__assert_fail ("isl_pw_qpolynomial_is_zero(pwqp1)", "polly/lib/External/isl/isl_test.c"
, 3804, __extension__ __PRETTY_FUNCTION__); }))
;
3805
3806 isl_pw_qpolynomial_free(pwqp1);
3807
3808 if (test_pwqp_gist(ctx) < 0)
3809 return -1;
3810
3811 str = "{ [i] -> ([([i/2] + [i/2])/5]) }";
3812 pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
3813 str = "{ [i] -> ([(2 * [i/2])/5]) }";
3814 pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str);
3815
3816 pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2);
3817
3818 assert(isl_pw_qpolynomial_is_zero(pwqp1))((void) sizeof ((isl_pw_qpolynomial_is_zero(pwqp1)) ? 1 : 0),
__extension__ ({ if (isl_pw_qpolynomial_is_zero(pwqp1)) ; else
__assert_fail ("isl_pw_qpolynomial_is_zero(pwqp1)", "polly/lib/External/isl/isl_test.c"
, 3818, __extension__ __PRETTY_FUNCTION__); }))
;
3819
3820 isl_pw_qpolynomial_free(pwqp1);
3821
3822 str = "{ [x] -> ([x/2] + [(x+1)/2]) }";
3823 pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
3824 str = "{ [x] -> x }";
3825 pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str);
3826
3827 pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2);
3828
3829 assert(isl_pw_qpolynomial_is_zero(pwqp1))((void) sizeof ((isl_pw_qpolynomial_is_zero(pwqp1)) ? 1 : 0),
__extension__ ({ if (isl_pw_qpolynomial_is_zero(pwqp1)) ; else
__assert_fail ("isl_pw_qpolynomial_is_zero(pwqp1)", "polly/lib/External/isl/isl_test.c"
, 3829, __extension__ __PRETTY_FUNCTION__); }))
;
3830
3831 isl_pw_qpolynomial_free(pwqp1);
3832
3833 str = "{ [i] -> ([i/2]) : i >= 0; [i] -> ([i/3]) : i < 0 }";
3834 pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
3835 pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str);
3836 pwqp1 = isl_pw_qpolynomial_coalesce(pwqp1);
3837 pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2);
3838 assert(isl_pw_qpolynomial_is_zero(pwqp1))((void) sizeof ((isl_pw_qpolynomial_is_zero(pwqp1)) ? 1 : 0),
__extension__ ({ if (isl_pw_qpolynomial_is_zero(pwqp1)) ; else
__assert_fail ("isl_pw_qpolynomial_is_zero(pwqp1)", "polly/lib/External/isl/isl_test.c"
, 3838, __extension__ __PRETTY_FUNCTION__); }))
;
3839 isl_pw_qpolynomial_free(pwqp1);
3840
3841 str = "{ [a,b,a] -> (([(2*[a/3]+b)/5]) * ([(2*[a/3]+b)/5])) }";
3842 pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str);
3843 str = "{ [a,b,c] -> (([(2*[a/3]+b)/5]) * ([(2*[c/3]+b)/5])) }";
3844 pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
3845 set = isl_set_read_from_str(ctx, "{ [a,b,a] }");
3846 pwqp1 = isl_pw_qpolynomial_intersect_domain(pwqp1, set);
3847 equal = isl_pw_qpolynomial_plain_is_equal(pwqp1, pwqp2);
3848 isl_pw_qpolynomial_free(pwqp1);
3849 isl_pw_qpolynomial_free(pwqp2);
3850 if (equal < 0)
3851 return -1;
3852 if (!equal)
3853 isl_die(ctx, isl_error_unknown, "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 3853); return -1; } while
(0)
;
3854
3855 str = "{ [a,b,c] -> (([(2*[a/3]+1)/5]) * ([(2*[c/3]+1)/5])) : b = 1 }";
3856 pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str);
3857 str = "{ [a,b,c] -> (([(2*[a/3]+b)/5]) * ([(2*[c/3]+b)/5])) }";
3858 pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
3859 pwqp1 = isl_pw_qpolynomial_fix_val(pwqp1, isl_dim_set, 1,
3860 isl_val_one(ctx));
3861 equal = isl_pw_qpolynomial_plain_is_equal(pwqp1, pwqp2);
3862 isl_pw_qpolynomial_free(pwqp1);
3863 isl_pw_qpolynomial_free(pwqp2);
3864 if (equal < 0)
3865 return -1;
3866 if (!equal)
3867 isl_die(ctx, isl_error_unknown, "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 3867); return -1; } while
(0)
;
3868
3869 if (test_pwqp_max(ctx) < 0)
3870 return -1;
3871
3872 return 0;
3873}
3874
3875static int test_split_periods(isl_ctx *ctx)
3876{
3877 const char *str;
3878 isl_pw_qpolynomial *pwqp;
3879
3880 str = "{ [U,V] -> 1/3 * U + 2/3 * V - [(U + 2V)/3] + [U/2] : "
3881 "U + 2V + 3 >= 0 and - U -2V >= 0 and - U + 10 >= 0 and "
3882 "U >= 0; [U,V] -> U^2 : U >= 100 }";
3883 pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
3884
3885 pwqp = isl_pw_qpolynomial_split_periods(pwqp, 2);
3886
3887 isl_pw_qpolynomial_free(pwqp);
3888
3889 if (!pwqp)
3890 return -1;
3891
3892 return 0;
3893}
3894
3895static int test_union(isl_ctx *ctx)
3896{
3897 const char *str;
3898 isl_union_set *uset1, *uset2;
3899 isl_union_map *umap1, *umap2;
3900 int equal;
3901
3902 str = "{ [i] : 0 <= i <= 1 }";
3903 uset1 = isl_union_set_read_from_str(ctx, str);
3904 str = "{ [1] -> [0] }";
3905 umap1 = isl_union_map_read_from_str(ctx, str);
3906
3907 umap2 = isl_union_set_lex_gt_union_set(isl_union_set_copy(uset1), uset1);
3908 equal = isl_union_map_is_equal(umap1, umap2);
3909
3910 isl_union_map_free(umap1);
3911 isl_union_map_free(umap2);
3912
3913 if (equal < 0)
3914 return -1;
3915 if (!equal)
3916 isl_die(ctx, isl_error_unknown, "union maps not equal",do { isl_handle_error(ctx, isl_error_unknown, "union maps not equal"
, "polly/lib/External/isl/isl_test.c", 3917); return -1; } while
(0)
3917 return -1)do { isl_handle_error(ctx, isl_error_unknown, "union maps not equal"
, "polly/lib/External/isl/isl_test.c", 3917); return -1; } while
(0)
;
3918
3919 str = "{ A[i] -> B[i]; B[i] -> C[i]; A[0] -> C[1] }";
3920 umap1 = isl_union_map_read_from_str(ctx, str);
3921 str = "{ A[i]; B[i] }";
3922 uset1 = isl_union_set_read_from_str(ctx, str);
3923
3924 uset2 = isl_union_map_domain(umap1);
3925
3926 equal = isl_union_set_is_equal(uset1, uset2);
3927
3928 isl_union_set_free(uset1);
3929 isl_union_set_free(uset2);
3930
3931 if (equal < 0)
3932 return -1;
3933 if (!equal)
3934 isl_die(ctx, isl_error_unknown, "union sets not equal",do { isl_handle_error(ctx, isl_error_unknown, "union sets not equal"
, "polly/lib/External/isl/isl_test.c", 3935); return -1; } while
(0)
3935 return -1)do { isl_handle_error(ctx, isl_error_unknown, "union sets not equal"
, "polly/lib/External/isl/isl_test.c", 3935); return -1; } while
(0)
;
3936
3937 return 0;
3938}
3939
3940/* Inputs for basic isl_pw_qpolynomial_bound tests.
3941 * "type" is the type of bound that should be computed.
3942 * "poly" is a string representation of the input.
3943 * "bound" is a string representation of the expected result.
3944 * "tight" is set if the result is expected to be tight.
3945 */
3946static struct {
3947 int tight;
3948 enum isl_fold type;
3949 const char *poly;
3950 const char *bound;
3951} bound_tests[] = {
3952 /* Check that computing a bound of a non-zero polynomial
3953 * over an unbounded domain does not produce a rational value.
3954 * In particular, check that the upper bound is infinity.
3955 */
3956 { 0, isl_fold_max, "{ [m, n] -> -m * n }", "{ max(infty) }" },
3957 { 1, isl_fold_max, "{ [[a, b, c, d] -> [e]] -> 0 }",
3958 "{ [a, b, c, d] -> max(0) }" },
3959 { 1, isl_fold_max, "{ [[x] -> [x]] -> 1 : exists a : x = 2 a }",
3960 "{ [x] -> max(1) : x mod 2 = 0 }" },
3961 { 1, isl_fold_min, "{ [x=5:10] -> (x + 2)^2 }", "{ min(49) }" },
3962 { 1, isl_fold_max, "{ [0:10] -> 1 }", "{ max(1) }" },
3963 { 1, isl_fold_max, "{ [[m] -> [0:m]] -> m^2 }",
3964 "{ [m] -> max(m^2) : m >= 0 }" },
3965};
3966
3967/* Check that the bound computation can handle differences
3968 * in domain dimension names of the input polynomial and its domain.
3969 */
3970static isl_stat test_bound_space(isl_ctx *ctx)
3971{
3972 const char *str;
3973 isl_setisl_map *set;
3974 isl_pw_qpolynomial *pwqp;
3975 isl_pw_qpolynomial_fold *pwf;
3976
3977 str = "{ [[c] -> [c]] }";
3978 set = isl_set_read_from_str(ctx, str);
3979 str = "{ [[a] -> [b]] -> 1 }";
3980 pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
3981 pwqp = isl_pw_qpolynomial_intersect_domain(pwqp, set);
3982 pwf = isl_pw_qpolynomial_bound(pwqp, isl_fold_max, NULL((void*)0));
3983 isl_pw_qpolynomial_fold_free(pwf);
3984
3985 return isl_stat_non_null(pwf);
3986}
3987
3988/* Perform basic isl_pw_qpolynomial_bound tests.
3989 */
3990static int test_bound(isl_ctx *ctx)
3991{
3992 int i;
3993
3994 if (test_bound_space(ctx) < 0)
3995 return -1;
3996
3997 for (i = 0; i < ARRAY_SIZE(bound_tests)(sizeof(bound_tests)/sizeof(*bound_tests)); ++i) {
3998 const char *str;
3999 enum isl_fold type;
4000 isl_bool equal, tight;
4001 isl_pw_qpolynomial *pwqp;
4002 isl_pw_qpolynomial_fold *pwf1, *pwf2;
4003
4004 str = bound_tests[i].poly;
4005 pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
4006 type = bound_tests[i].type;
4007 pwf1 = isl_pw_qpolynomial_bound(pwqp, type, &tight);
4008 str = bound_tests[i].bound;
4009 pwf2 = isl_pw_qpolynomial_fold_read_from_str(ctx, str);
4010 equal = isl_pw_qpolynomial_fold_plain_is_equal(pwf1, pwf2);
4011 isl_pw_qpolynomial_fold_free(pwf2);
4012 isl_pw_qpolynomial_fold_free(pwf1);
4013 if (equal < 0)
4014 return -1;
4015 if (!equal)
4016 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "incorrect bound result"
, "polly/lib/External/isl/isl_test.c", 4017); return -1; } while
(0)
4017 "incorrect bound result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "incorrect bound result"
, "polly/lib/External/isl/isl_test.c", 4017); return -1; } while
(0)
;
4018 if (bound_tests[i].tight && !tight)
4019 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "bound unexpectedly not tight"
, "polly/lib/External/isl/isl_test.c", 4020); return -1; } while
(0)
4020 "bound unexpectedly not tight", return -1)do { isl_handle_error(ctx, isl_error_unknown, "bound unexpectedly not tight"
, "polly/lib/External/isl/isl_test.c", 4020); return -1; } while
(0)
;
4021 }
4022
4023 return 0;
4024}
4025
4026/* isl_set is defined to isl_map internally, so the corresponding elements
4027 * are isl_basic_map objects.
4028 */
4029#undef EL_BASEmap
4030#undef SET_BASEunion_map
4031#define EL_BASEmap basic_map
4032#define SET_BASEunion_map set
4033#include "isl_test_list_templ.c"
4034
4035#undef EL_BASEmap
4036#undef SET_BASEunion_map
4037#define EL_BASEmap basic_set
4038#define SET_BASEunion_map union_set
4039#include "isl_test_list_templ.c"
4040
4041#undef EL_BASEmap
4042#undef SET_BASEunion_map
4043#define EL_BASEmap set
4044#define SET_BASEunion_map union_set
4045#include "isl_test_list_templ.c"
4046
4047#undef EL_BASEmap
4048#undef SET_BASEunion_map
4049#define EL_BASEmap basic_map
4050#define SET_BASEunion_map map
4051#include "isl_test_list_templ.c"
4052
4053#undef EL_BASEmap
4054#undef SET_BASEunion_map
4055#define EL_BASEmap map
4056#define SET_BASEunion_map union_map
4057#include "isl_test_list_templ.c"
4058
4059/* Check that the conversion from isl objects to lists works as expected.
4060 */
4061static int test_get_list(isl_ctx *ctx)
4062{
4063 if (test_get_list_basic_map_from_set(ctx, "{ [0]; [2]; [3] }"))
4064 return -1;
4065 if (test_get_list_basic_set_from_union_set(ctx, "{ A[0]; B[2]; B[3] }"))
4066 return -1;
4067 if (test_get_list_set_from_union_set(ctx, "{ A[0]; A[2]; B[3] }"))
4068 return -1;
4069 if (test_get_list_basic_map_from_map(ctx,
4070 "{ [0] -> [0]; [2] -> [0]; [3] -> [0] }"))
4071 return -1;
4072 if (test_get_list_map_from_union_map(ctx,
4073 "{ A[0] -> [0]; A[2] -> [0]; B[3] -> [0] }"))
4074 return -1;
4075
4076 return 0;
4077}
4078
4079static int test_lift(isl_ctx *ctx)
4080{
4081 const char *str;
4082 isl_basic_map *bmap;
4083 isl_basic_setisl_basic_map *bset;
4084
4085 str = "{ [i0] : exists e0 : i0 = 4e0 }";
4086 bset = isl_basic_set_read_from_str(ctx, str);
4087 bset = isl_basic_set_lift(bset);
4088 bmap = isl_basic_map_from_range(bset);
4089 bset = isl_basic_map_domain(bmap);
4090 isl_basic_set_free(bset);
4091
4092 return 0;
4093}
4094
4095/* Check that isl_set_is_subset is not confused by identical
4096 * integer divisions.
4097 * The call to isl_set_normalize ensures that the equality constraints
4098 * a = b = 0 are discovered, turning e0 and e1 into identical
4099 * integer divisions. Any further simplification would remove
4100 * the duplicate integer divisions.
4101 */
4102static isl_stat test_subset_duplicate_integer_divisions(isl_ctx *ctx)
4103{
4104 const char *str;
4105 isl_bool is_subset;
4106 isl_setisl_map *set1, *set2;
4107
4108 str = "{ [a, b, c, d] : "
4109 "exists (e0 = floor((a + d)/4), e1 = floor((d)/4), "
4110 "e2 = floor((-a - d + 4 *floor((a + d)/4))/10), "
4111 "e3 = floor((-d + 4*floor((d)/4))/10): "
4112 "10e2 = -a - 2c - d + 4e0 and 10e3 = -2c - d + 4e1 and "
4113 "b >= 0 and a <= 0 and b <= a) }";
4114 set1 = isl_set_read_from_str(ctx, str);
4115 set2 = isl_set_read_from_str(ctx, str);
4116 set2 = isl_set_normalize(set2);
4117
4118 is_subset = isl_set_is_subset(set1, set2);
4119
4120 isl_set_free(set1);
4121 isl_set_free(set2);
4122
4123 if (is_subset < 0)
4124 return isl_stat_error;
4125 if (!is_subset)
4126 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "set is not considered to be a subset of itself"
, "polly/lib/External/isl/isl_test.c", 4128); return isl_stat_error
; } while (0)
4127 "set is not considered to be a subset of itself",do { isl_handle_error(ctx, isl_error_unknown, "set is not considered to be a subset of itself"
, "polly/lib/External/isl/isl_test.c", 4128); return isl_stat_error
; } while (0)
4128 return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "set is not considered to be a subset of itself"
, "polly/lib/External/isl/isl_test.c", 4128); return isl_stat_error
; } while (0)
;
4129
4130 return isl_stat_ok;
4131}
4132
4133struct {
4134 const char *set1;
4135 const char *set2;
4136 int subset;
4137} subset_tests[] = {
4138 { "{ [112, 0] }",
4139 "{ [i0, i1] : exists (e0 = [(i0 - i1)/16], e1: "
4140 "16e0 <= i0 - i1 and 16e0 >= -15 + i0 - i1 and "
4141 "16e1 <= i1 and 16e0 >= -i1 and 16e1 >= -i0 + i1) }", 1 },
4142 { "{ [65] }",
4143 "{ [i] : exists (e0 = [(255i)/256], e1 = [(127i + 65e0)/191], "
4144 "e2 = [(3i + 61e1)/65], e3 = [(52i + 12e2)/61], "
4145 "e4 = [(2i + e3)/3], e5 = [(4i + e3)/4], e6 = [(8i + e3)/12]: "
4146 "3e4 = 2i + e3 and 4e5 = 4i + e3 and 12e6 = 8i + e3 and "
4147 "i <= 255 and 64e3 >= -45 + 67i and i >= 0 and "
4148 "256e0 <= 255i and 256e0 >= -255 + 255i and "
4149 "191e1 <= 127i + 65e0 and 191e1 >= -190 + 127i + 65e0 and "
4150 "65e2 <= 3i + 61e1 and 65e2 >= -64 + 3i + 61e1 and "
4151 "61e3 <= 52i + 12e2 and 61e3 >= -60 + 52i + 12e2) }", 1 },
4152 { "{ [i] : 0 <= i <= 10 }", "{ rat: [i] : 0 <= i <= 10 }", 1 },
4153 { "{ rat: [i] : 0 <= i <= 10 }", "{ [i] : 0 <= i <= 10 }", 0 },
4154 { "{ rat: [0] }", "{ [i] : 0 <= i <= 10 }", 1 },
4155 { "{ rat: [(1)/2] }", "{ [i] : 0 <= i <= 10 }", 0 },
4156 { "{ [t, i] : (exists (e0 = [(2 + t)/4]: 4e0 <= 2 + t and "
4157 "4e0 >= -1 + t and i >= 57 and i <= 62 and "
4158 "4e0 <= 62 + t - i and 4e0 >= -61 + t + i and "
4159 "t >= 0 and t <= 511 and 4e0 <= -57 + t + i and "
4160 "4e0 >= 58 + t - i and i >= 58 + t and i >= 62 - t)) }",
4161 "{ [i0, i1] : (exists (e0 = [(4 + i0)/4]: 4e0 <= 62 + i0 - i1 and "
4162 "4e0 >= 1 + i0 and i0 >= 0 and i0 <= 511 and "
4163 "4e0 <= -57 + i0 + i1)) or "
4164 "(exists (e0 = [(2 + i0)/4]: 4e0 <= i0 and "
4165 "4e0 >= 58 + i0 - i1 and i0 >= 2 and i0 <= 511 and "
4166 "4e0 >= -61 + i0 + i1)) or "
4167 "(i1 <= 66 - i0 and i0 >= 2 and i1 >= 59 + i0) }", 1 },
4168 { "[a, b] -> { : a = 0 and b = -1 }", "[b, a] -> { : b >= -10 }", 1 },
4169};
4170
4171static int test_subset(isl_ctx *ctx)
4172{
4173 int i;
4174 isl_setisl_map *set1, *set2;
4175 int subset;
4176
4177 if (test_subset_duplicate_integer_divisions(ctx) < 0)
4178 return -1;
4179
4180 for (i = 0; i < ARRAY_SIZE(subset_tests)(sizeof(subset_tests)/sizeof(*subset_tests)); ++i) {
4181 set1 = isl_set_read_from_str(ctx, subset_tests[i].set1);
4182 set2 = isl_set_read_from_str(ctx, subset_tests[i].set2);
4183 subset = isl_set_is_subset(set1, set2);
4184 isl_set_free(set1);
4185 isl_set_free(set2);
4186 if (subset < 0)
4187 return -1;
4188 if (subset != subset_tests[i].subset)
4189 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "incorrect subset result"
, "polly/lib/External/isl/isl_test.c", 4190); return -1; } while
(0)
4190 "incorrect subset result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "incorrect subset result"
, "polly/lib/External/isl/isl_test.c", 4190); return -1; } while
(0)
;
4191 }
4192
4193 return 0;
4194}
4195
4196/* Perform a set subtraction with a set that has a non-obviously empty disjunct.
4197 * Older versions of isl would fail on such cases.
4198 */
4199static isl_stat test_subtract_empty(isl_ctx *ctx)
4200{
4201 const char *str;
4202 isl_setisl_map *s1, *s2;
4203
4204 s1 = isl_set_read_from_str(ctx, "{ [0] }");
4205 str = "{ [a] : (exists (e0, e1, e2: 1056e1 <= 32 + a - 33e0 and "
4206 "1089e1 >= a - 33e0 and 1089e1 <= 1 + a - 33e0 and "
4207 "33e2 >= -a + 33e0 + 1056e1 and "
4208 "33e2 < -2a + 66e0 + 2112e1)) or a = 0 }";
4209 s2 = isl_set_read_from_str(ctx, str);
4210 s1 = isl_set_subtract(s1, s2);
4211 isl_set_free(s1);
4212
4213 return isl_stat_non_null(s1);
4214}
4215
4216struct {
4217 const char *minuend;
4218 const char *subtrahend;
4219 const char *difference;
4220} subtract_domain_tests[] = {
4221 { "{ A[i] -> B[i] }", "{ A[i] }", "{ }" },
4222 { "{ A[i] -> B[i] }", "{ B[i] }", "{ A[i] -> B[i] }" },
4223 { "{ A[i] -> B[i] }", "{ A[i] : i > 0 }", "{ A[i] -> B[i] : i <= 0 }" },
4224};
4225
4226static int test_subtract(isl_ctx *ctx)
4227{
4228 int i;
4229 isl_union_map *umap1, *umap2;
4230 isl_union_pw_multi_aff *upma1, *upma2;
4231 isl_union_set *uset;
4232 int equal;
4233
4234 if (test_subtract_empty(ctx) < 0)
4235 return -1;
4236
4237 for (i = 0; i < ARRAY_SIZE(subtract_domain_tests)(sizeof(subtract_domain_tests)/sizeof(*subtract_domain_tests)
)
; ++i) {
4238 umap1 = isl_union_map_read_from_str(ctx,
4239 subtract_domain_tests[i].minuend);
4240 uset = isl_union_set_read_from_str(ctx,
4241 subtract_domain_tests[i].subtrahend);
4242 umap2 = isl_union_map_read_from_str(ctx,
4243 subtract_domain_tests[i].difference);
4244 umap1 = isl_union_map_subtract_domain(umap1, uset);
4245 equal = isl_union_map_is_equal(umap1, umap2);
4246 isl_union_map_free(umap1);
4247 isl_union_map_free(umap2);
4248 if (equal < 0)
4249 return -1;
4250 if (!equal)
4251 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "incorrect subtract domain result"
, "polly/lib/External/isl/isl_test.c", 4252); return -1; } while
(0)
4252 "incorrect subtract domain result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "incorrect subtract domain result"
, "polly/lib/External/isl/isl_test.c", 4252); return -1; } while
(0)
;
4253 }
4254
4255 for (i = 0; i < ARRAY_SIZE(subtract_domain_tests)(sizeof(subtract_domain_tests)/sizeof(*subtract_domain_tests)
)
; ++i) {
4256 upma1 = isl_union_pw_multi_aff_read_from_str(ctx,
4257 subtract_domain_tests[i].minuend);
4258 uset = isl_union_set_read_from_str(ctx,
4259 subtract_domain_tests[i].subtrahend);
4260 upma2 = isl_union_pw_multi_aff_read_from_str(ctx,
4261 subtract_domain_tests[i].difference);
4262 upma1 = isl_union_pw_multi_aff_subtract_domain(upma1, uset);
4263 equal = isl_union_pw_multi_aff_plain_is_equal(upma1, upma2);
4264 isl_union_pw_multi_aff_free(upma1);
4265 isl_union_pw_multi_aff_free(upma2);
4266 if (equal < 0)
4267 return -1;
4268 if (!equal)
4269 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "incorrect subtract domain result"
, "polly/lib/External/isl/isl_test.c", 4270); return -1; } while
(0)
4270 "incorrect subtract domain result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "incorrect subtract domain result"
, "polly/lib/External/isl/isl_test.c", 4270); return -1; } while
(0)
;
4271 }
4272
4273 return 0;
4274}
4275
4276/* Check that intersecting the empty basic set with another basic set
4277 * does not increase the number of constraints. In particular,
4278 * the empty basic set should maintain its canonical representation.
4279 */
4280static int test_intersect_1(isl_ctx *ctx)
4281{
4282 isl_size n1, n2;
4283 isl_basic_setisl_basic_map *bset1, *bset2;
4284
4285 bset1 = isl_basic_set_read_from_str(ctx, "{ [a,b,c] : 1 = 0 }");
4286 bset2 = isl_basic_set_read_from_str(ctx, "{ [1,2,3] }");
4287 n1 = isl_basic_set_n_constraint(bset1);
4288 bset1 = isl_basic_set_intersect(bset1, bset2);
4289 n2 = isl_basic_set_n_constraint(bset1);
4290 isl_basic_set_free(bset1);
4291 if (n1 < 0 || n2 < 0)
4292 return -1;
4293 if (n1 != n2)
4294 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "number of constraints of empty set changed"
, "polly/lib/External/isl/isl_test.c", 4296); return -1; } while
(0)
4295 "number of constraints of empty set changed",do { isl_handle_error(ctx, isl_error_unknown, "number of constraints of empty set changed"
, "polly/lib/External/isl/isl_test.c", 4296); return -1; } while
(0)
4296 return -1)do { isl_handle_error(ctx, isl_error_unknown, "number of constraints of empty set changed"
, "polly/lib/External/isl/isl_test.c", 4296); return -1; } while
(0)
;
4297
4298 return 0;
4299}
4300
4301/* Check that intersecting a set with itself does not cause
4302 * an explosion in the number of disjuncts.
4303 */
4304static isl_stat test_intersect_2(isl_ctx *ctx)
4305{
4306 int i;
4307 isl_setisl_map *set;
4308
4309 set = isl_set_read_from_str(ctx, "{ [x,y] : x >= 0 or y >= 0 }");
4310 for (i = 0; i < 100; ++i)
4311 set = isl_set_intersect(set, isl_set_copy(set));
4312 isl_set_free(set);
4313 if (!set)
4314 return isl_stat_error;
4315 return isl_stat_ok;
4316}
4317
4318/* Perform some intersection tests.
4319 */
4320static int test_intersect(isl_ctx *ctx)
4321{
4322 if (test_intersect_1(ctx) < 0)
4323 return -1;
4324 if (test_intersect_2(ctx) < 0)
4325 return -1;
4326
4327 return 0;
4328}
4329
4330int test_factorize(isl_ctx *ctx)
4331{
4332 const char *str;
4333 isl_basic_setisl_basic_map *bset;
4334 isl_factorizer *f;
4335
4336 str = "{ [i0, i1, i2, i3, i4, i5, i6, i7] : 3i5 <= 2 - 2i0 and "
4337 "i0 >= -2 and i6 >= 1 + i3 and i7 >= 0 and 3i5 >= -2i0 and "
4338 "2i4 <= i2 and i6 >= 1 + 2i0 + 3i1 and i4 <= -1 and "
4339 "i6 >= 1 + 2i0 + 3i5 and i6 <= 2 + 2i0 + 3i5 and "
4340 "3i5 <= 2 - 2i0 - i2 + 3i4 and i6 <= 2 + 2i0 + 3i1 and "
4341 "i0 <= -1 and i7 <= i2 + i3 - 3i4 - i6 and "
4342 "3i5 >= -2i0 - i2 + 3i4 }";
4343 bset = isl_basic_set_read_from_str(ctx, str);
4344 f = isl_basic_set_factorizer(bset);
4345 isl_basic_set_free(bset);
4346 isl_factorizer_free(f);
4347 if (!f)
4348 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "failed to construct factorizer"
, "polly/lib/External/isl/isl_test.c", 4349); return -1; } while
(0)
4349 "failed to construct factorizer", return -1)do { isl_handle_error(ctx, isl_error_unknown, "failed to construct factorizer"
, "polly/lib/External/isl/isl_test.c", 4349); return -1; } while
(0)
;
4350
4351 str = "{ [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] : "
4352 "i12 <= 2 + i0 - i11 and 2i8 >= -i4 and i11 >= i1 and "
4353 "3i5 <= -i2 and 2i11 >= -i4 - 2i7 and i11 <= 3 + i0 + 3i9 and "
4354 "i11 <= -i4 - 2i7 and i12 >= -i10 and i2 >= -2 and "
4355 "i11 >= i1 + 3i10 and i11 >= 1 + i0 + 3i9 and "
4356 "i11 <= 1 - i4 - 2i8 and 6i6 <= 6 - i2 and 3i6 >= 1 - i2 and "
4357 "i11 <= 2 + i1 and i12 <= i4 + i11 and i12 >= i0 - i11 and "
4358 "3i5 >= -2 - i2 and i12 >= -1 + i4 + i11 and 3i3 <= 3 - i2 and "
4359 "9i6 <= 11 - i2 + 6i5 and 3i3 >= 1 - i2 and "
4360 "9i6 <= 5 - i2 + 6i3 and i12 <= -1 and i2 <= 0 }";
4361 bset = isl_basic_set_read_from_str(ctx, str);
4362 f = isl_basic_set_factorizer(bset);
4363 isl_basic_set_free(bset);
4364 isl_factorizer_free(f);
4365 if (!f)
4366 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "failed to construct factorizer"
, "polly/lib/External/isl/isl_test.c", 4367); return -1; } while
(0)
4367 "failed to construct factorizer", return -1)do { isl_handle_error(ctx, isl_error_unknown, "failed to construct factorizer"
, "polly/lib/External/isl/isl_test.c", 4367); return -1; } while
(0)
;
4368
4369 return 0;
4370}
4371
4372static isl_stat check_injective(__isl_take isl_map *map, void *user)
4373{
4374 int *injective = user;
4375
4376 *injective = isl_map_is_injective(map);
4377 isl_map_free(map);
4378
4379 if (*injective < 0 || !*injective)
4380 return isl_stat_error;
4381
4382 return isl_stat_ok;
4383}
4384
4385int test_one_schedule(isl_ctx *ctx, const char *d, const char *w,
4386 const char *r, const char *s, int tilable, int parallel)
4387{
4388 int i;
4389 isl_union_set *D;
4390 isl_union_map *W, *R, *S;
4391 isl_union_map *empty;
4392 isl_union_map *dep_raw, *dep_war, *dep_waw, *dep;
4393 isl_union_map *validity, *proximity, *coincidence;
4394 isl_union_map *schedule;
4395 isl_union_map *test;
4396 isl_union_set *delta;
4397 isl_union_set *domain;
4398 isl_setisl_map *delta_set;
4399 isl_setisl_map *slice;
4400 isl_setisl_map *origin;
4401 isl_schedule_constraints *sc;
4402 isl_schedule *sched;
4403 int is_nonneg, is_parallel, is_tilable, is_injection, is_complete;
4404 isl_size n;
4405
4406 D = isl_union_set_read_from_str(ctx, d);
4407 W = isl_union_map_read_from_str(ctx, w);
4408 R = isl_union_map_read_from_str(ctx, r);
4409 S = isl_union_map_read_from_str(ctx, s);
4410
4411 W = isl_union_map_intersect_domain(W, isl_union_set_copy(D));
4412 R = isl_union_map_intersect_domain(R, isl_union_set_copy(D));
4413
4414 empty = isl_union_map_empty(isl_union_map_get_space(S));
4415 isl_union_map_compute_flow(isl_union_map_copy(R),
4416 isl_union_map_copy(W), empty,
4417 isl_union_map_copy(S),
4418 &dep_raw, NULL((void*)0), NULL((void*)0), NULL((void*)0));
4419 isl_union_map_compute_flow(isl_union_map_copy(W),
4420 isl_union_map_copy(W),
4421 isl_union_map_copy(R),
4422 isl_union_map_copy(S),
4423 &dep_waw, &dep_war, NULL((void*)0), NULL((void*)0));
4424
4425 dep = isl_union_map_union(dep_waw, dep_war);
4426 dep = isl_union_map_union(dep, dep_raw);
4427 validity = isl_union_map_copy(dep);
4428 coincidence = isl_union_map_copy(dep);
4429 proximity = isl_union_map_copy(dep);
4430
4431 sc = isl_schedule_constraints_on_domain(isl_union_set_copy(D));
4432 sc = isl_schedule_constraints_set_validity(sc, validity);
4433 sc = isl_schedule_constraints_set_coincidence(sc, coincidence);
4434 sc = isl_schedule_constraints_set_proximity(sc, proximity);
4435 sched = isl_schedule_constraints_compute_schedule(sc);
4436 schedule = isl_schedule_get_map(sched);
4437 isl_schedule_free(sched);
4438 isl_union_map_free(W);
4439 isl_union_map_free(R);
4440 isl_union_map_free(S);
4441
4442 is_injection = 1;
4443 isl_union_map_foreach_map(schedule, &check_injective, &is_injection);
4444
4445 domain = isl_union_map_domain(isl_union_map_copy(schedule));
4446 is_complete = isl_union_set_is_subset(D, domain);
4447 isl_union_set_free(D);
4448 isl_union_set_free(domain);
4449
4450 test = isl_union_map_reverse(isl_union_map_copy(schedule));
4451 test = isl_union_map_apply_range(test, dep);
4452 test = isl_union_map_apply_range(test, schedule);
4453
4454 delta = isl_union_map_deltas(test);
4455 n = isl_union_set_n_set(delta);
4456 if (n < 0) {
4457 isl_union_set_free(delta);
4458 return -1;
4459 }
4460 if (n == 0) {
4461 is_tilable = 1;
4462 is_parallel = 1;
4463 is_nonneg = 1;
4464 isl_union_set_free(delta);
4465 } else {
4466 isl_size dim;
4467
4468 delta_set = isl_set_from_union_set(delta);
4469
4470 slice = isl_set_universe(isl_set_get_space(delta_set));
4471 for (i = 0; i < tilable; ++i)
4472 slice = isl_set_lower_bound_si(slice, isl_dim_set, i, 0);
4473 is_tilable = isl_set_is_subset(delta_set, slice);
4474 isl_set_free(slice);
4475
4476 slice = isl_set_universe(isl_set_get_space(delta_set));
4477 for (i = 0; i < parallel; ++i)
4478 slice = isl_set_fix_si(slice, isl_dim_set, i, 0);
4479 is_parallel = isl_set_is_subset(delta_set, slice);
4480 isl_set_free(slice);
4481
4482 origin = isl_set_universe(isl_set_get_space(delta_set));
4483 dim = isl_set_dim(origin, isl_dim_set);
4484 if (dim < 0)
4485 origin = isl_set_free(origin);
4486 for (i = 0; i < dim; ++i)
4487 origin = isl_set_fix_si(origin, isl_dim_set, i, 0);
4488
4489 delta_set = isl_set_union(delta_set, isl_set_copy(origin));
4490 delta_set = isl_set_lexmin(delta_set);
4491
4492 is_nonneg = isl_set_is_equal(delta_set, origin);
4493
4494 isl_set_free(origin);
4495 isl_set_free(delta_set);
4496 }
4497
4498 if (is_nonneg < 0 || is_parallel < 0 || is_tilable < 0 ||
4499 is_injection < 0 || is_complete < 0)
4500 return -1;
4501 if (!is_complete)
4502 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "generated schedule incomplete"
, "polly/lib/External/isl/isl_test.c", 4503); return -1; } while
(0)
4503 "generated schedule incomplete", return -1)do { isl_handle_error(ctx, isl_error_unknown, "generated schedule incomplete"
, "polly/lib/External/isl/isl_test.c", 4503); return -1; } while
(0)
;
4504 if (!is_injection)
4505 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not injective on each statement"
, "polly/lib/External/isl/isl_test.c", 4507); return -1; } while
(0)
4506 "generated schedule not injective on each statement",do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not injective on each statement"
, "polly/lib/External/isl/isl_test.c", 4507); return -1; } while
(0)
4507 return -1)do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not injective on each statement"
, "polly/lib/External/isl/isl_test.c", 4507); return -1; } while
(0)
;
4508 if (!is_nonneg)
4509 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "negative dependences in generated schedule"
, "polly/lib/External/isl/isl_test.c", 4511); return -1; } while
(0)
4510 "negative dependences in generated schedule",do { isl_handle_error(ctx, isl_error_unknown, "negative dependences in generated schedule"
, "polly/lib/External/isl/isl_test.c", 4511); return -1; } while
(0)
4511 return -1)do { isl_handle_error(ctx, isl_error_unknown, "negative dependences in generated schedule"
, "polly/lib/External/isl/isl_test.c", 4511); return -1; } while
(0)
;
4512 if (!is_tilable)
4513 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not as tilable as expected"
, "polly/lib/External/isl/isl_test.c", 4515); return -1; } while
(0)
4514 "generated schedule not as tilable as expected",do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not as tilable as expected"
, "polly/lib/External/isl/isl_test.c", 4515); return -1; } while
(0)
4515 return -1)do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not as tilable as expected"
, "polly/lib/External/isl/isl_test.c", 4515); return -1; } while
(0)
;
4516 if (!is_parallel)
4517 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not as parallel as expected"
, "polly/lib/External/isl/isl_test.c", 4519); return -1; } while
(0)
4518 "generated schedule not as parallel as expected",do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not as parallel as expected"
, "polly/lib/External/isl/isl_test.c", 4519); return -1; } while
(0)
4519 return -1)do { isl_handle_error(ctx, isl_error_unknown, "generated schedule not as parallel as expected"
, "polly/lib/External/isl/isl_test.c", 4519); return -1; } while
(0)
;
4520
4521 return 0;
4522}
4523
4524/* Compute a schedule for the given instance set, validity constraints,
4525 * proximity constraints and context and return a corresponding union map
4526 * representation.
4527 */
4528static __isl_give isl_union_map *compute_schedule_with_context(isl_ctx *ctx,
4529 const char *domain, const char *validity, const char *proximity,
4530 const char *context)
4531{
4532 isl_setisl_map *con;
4533 isl_union_set *dom;
4534 isl_union_map *dep;
4535 isl_union_map *prox;
4536 isl_schedule_constraints *sc;
4537 isl_schedule *schedule;
4538 isl_union_map *sched;
4539
4540 con = isl_set_read_from_str(ctx, context);
4541 dom = isl_union_set_read_from_str(ctx, domain);
4542 dep = isl_union_map_read_from_str(ctx, validity);
4543 prox = isl_union_map_read_from_str(ctx, proximity);
4544 sc = isl_schedule_constraints_on_domain(dom);
4545 sc = isl_schedule_constraints_set_context(sc, con);
4546 sc = isl_schedule_constraints_set_validity(sc, dep);
4547 sc = isl_schedule_constraints_set_proximity(sc, prox);
4548 schedule = isl_schedule_constraints_compute_schedule(sc);
4549 sched = isl_schedule_get_map(schedule);
4550 isl_schedule_free(schedule);
4551
4552 return sched;
4553}
4554
4555/* Compute a schedule for the given instance set, validity constraints and
4556 * proximity constraints and return a corresponding union map representation.
4557 */
4558static __isl_give isl_union_map *compute_schedule(isl_ctx *ctx,
4559 const char *domain, const char *validity, const char *proximity)
4560{
4561 return compute_schedule_with_context(ctx, domain, validity, proximity,
4562 "{ : }");
4563}
4564
4565/* Check that a schedule can be constructed on the given domain
4566 * with the given validity and proximity constraints.
4567 */
4568static int test_has_schedule(isl_ctx *ctx, const char *domain,
4569 const char *validity, const char *proximity)
4570{
4571 isl_union_map *sched;
4572
4573 sched = compute_schedule(ctx, domain, validity, proximity);
4574 if (!sched)
4575 return -1;
4576
4577 isl_union_map_free(sched);
4578 return 0;
4579}
4580
4581int test_special_schedule(isl_ctx *ctx, const char *domain,
4582 const char *validity, const char *proximity, const char *expected_sched)
4583{
4584 isl_union_map *sched1, *sched2;
4585 int equal;
4586
4587 sched1 = compute_schedule(ctx, domain, validity, proximity);
4588 sched2 = isl_union_map_read_from_str(ctx, expected_sched);
4589
4590 equal = isl_union_map_is_equal(sched1, sched2);
4591 isl_union_map_free(sched1);
4592 isl_union_map_free(sched2);
4593
4594 if (equal < 0)
4595 return -1;
4596 if (!equal)
4597 isl_die(ctx, isl_error_unknown, "unexpected schedule",do { isl_handle_error(ctx, isl_error_unknown, "unexpected schedule"
, "polly/lib/External/isl/isl_test.c", 4598); return -1; } while
(0)
4598 return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected schedule"
, "polly/lib/External/isl/isl_test.c", 4598); return -1; } while
(0)
;
4599
4600 return 0;
4601}
4602
4603/* Check that the schedule map is properly padded, i.e., that the range
4604 * lives in a single space.
4605 */
4606static int test_padded_schedule(isl_ctx *ctx)
4607{
4608 const char *str;
4609 isl_union_set *D;
4610 isl_union_map *validity, *proximity;
4611 isl_schedule_constraints *sc;
4612 isl_schedule *sched;
4613 isl_union_map *umap;
4614 isl_union_set *range;
4615 isl_setisl_map *set;
4616
4617 str = "[N] -> { S0[i] : 0 <= i <= N; S1[i, j] : 0 <= i, j <= N }";
4618 D = isl_union_set_read_from_str(ctx, str);
4619 validity = isl_union_map_empty(isl_union_set_get_space(D));
4620 proximity = isl_union_map_copy(validity);
4621 sc = isl_schedule_constraints_on_domain(D);
4622 sc = isl_schedule_constraints_set_validity(sc, validity);
4623 sc = isl_schedule_constraints_set_proximity(sc, proximity);
4624 sched = isl_schedule_constraints_compute_schedule(sc);
4625 umap = isl_schedule_get_map(sched);
4626 isl_schedule_free(sched);
4627 range = isl_union_map_range(umap);
4628 set = isl_set_from_union_set(range);
4629 isl_set_free(set);
4630
4631 if (!set)
4632 return -1;
4633
4634 return 0;
4635}
4636
4637/* Check that conditional validity constraints are also taken into
4638 * account across bands.
4639 * In particular, try to make sure that live ranges D[1,0]->C[2,1] and
4640 * D[2,0]->C[3,0] are not local in the outer band of the generated schedule
4641 * and then check that the adjacent order constraint C[2,1]->D[2,0]
4642 * is enforced by the rest of the schedule.
4643 */
4644static int test_special_conditional_schedule_constraints(isl_ctx *ctx)
4645{
4646 const char *str;
4647 isl_union_set *domain;
4648 isl_union_map *validity, *proximity, *condition;
4649 isl_union_map *sink, *source, *dep;
4650 isl_schedule_constraints *sc;
4651 isl_schedule *schedule;
4652 isl_union_access_info *access;
4653 isl_union_flow *flow;
4654 int empty;
4655
4656 str = "[n] -> { C[k, i] : k <= -1 + n and i >= 0 and i <= -1 + k; "
4657 "A[k] : k >= 1 and k <= -1 + n; "
4658 "B[k, i] : k <= -1 + n and i >= 0 and i <= -1 + k; "
4659 "D[k, i] : k <= -1 + n and i >= 0 and i <= -1 + k }";
4660 domain = isl_union_set_read_from_str(ctx, str);
4661 sc = isl_schedule_constraints_on_domain(domain);
4662 str = "[n] -> { D[k, i] -> C[1 + k, k - i] : "
4663 "k <= -2 + n and i >= 1 and i <= -1 + k; "
4664 "D[k, i] -> C[1 + k, i] : "
4665 "k <= -2 + n and i >= 1 and i <= -1 + k; "
4666 "D[k, 0] -> C[1 + k, k] : k >= 1 and k <= -2 + n; "
4667 "D[k, 0] -> C[1 + k, 0] : k >= 1 and k <= -2 + n }";
4668 validity = isl_union_map_read_from_str(ctx, str);
4669 sc = isl_schedule_constraints_set_validity(sc, validity);
4670 str = "[n] -> { C[k, i] -> D[k, i] : "
4671 "0 <= i <= -1 + k and k <= -1 + n }";
4672 proximity = isl_union_map_read_from_str(ctx, str);
4673 sc = isl_schedule_constraints_set_proximity(sc, proximity);
4674 str = "[n] -> { [D[k, i] -> a[]] -> [C[1 + k, k - i] -> b[]] : "
4675 "i <= -1 + k and i >= 1 and k <= -2 + n; "
4676 "[B[k, i] -> c[]] -> [B[k, 1 + i] -> c[]] : "
4677 "k <= -1 + n and i >= 0 and i <= -2 + k }";
4678 condition = isl_union_map_read_from_str(ctx, str);
4679 str = "[n] -> { [B[k, i] -> e[]] -> [D[k, i] -> a[]] : "
4680 "i >= 0 and i <= -1 + k and k <= -1 + n; "
4681 "[C[k, i] -> b[]] -> [D[k', -1 + k - i] -> a[]] : "
4682 "i >= 0 and i <= -1 + k and k <= -1 + n and "
4683 "k' <= -1 + n and k' >= k - i and k' >= 1 + k; "
4684 "[C[k, i] -> b[]] -> [D[k, -1 + k - i] -> a[]] : "
4685 "i >= 0 and i <= -1 + k and k <= -1 + n; "
4686 "[B[k, i] -> c[]] -> [A[k'] -> d[]] : "
4687 "k <= -1 + n and i >= 0 and i <= -1 + k and "
4688 "k' >= 1 and k' <= -1 + n and k' >= 1 + k }";
4689 validity = isl_union_map_read_from_str(ctx, str);
4690 sc = isl_schedule_constraints_set_conditional_validity(sc, condition,
4691 validity);
4692 schedule = isl_schedule_constraints_compute_schedule(sc);
4693 str = "{ D[2,0] -> [] }";
4694 sink = isl_union_map_read_from_str(ctx, str);
4695 access = isl_union_access_info_from_sink(sink);
4696 str = "{ C[2,1] -> [] }";
4697 source = isl_union_map_read_from_str(ctx, str);
4698 access = isl_union_access_info_set_must_source(access, source);
4699 access = isl_union_access_info_set_schedule(access, schedule);
4700 flow = isl_union_access_info_compute_flow(access);
4701 dep = isl_union_flow_get_must_dependence(flow);
4702 isl_union_flow_free(flow);
4703 empty = isl_union_map_is_empty(dep);
4704 isl_union_map_free(dep);
4705
4706 if (empty < 0)
4707 return -1;
4708 if (empty)
4709 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "conditional validity not respected"
, "polly/lib/External/isl/isl_test.c", 4710); return -1; } while
(0)
4710 "conditional validity not respected", return -1)do { isl_handle_error(ctx, isl_error_unknown, "conditional validity not respected"
, "polly/lib/External/isl/isl_test.c", 4710); return -1; } while
(0)
;
4711
4712 return 0;
4713}
4714
4715/* Check that the test for violated conditional validity constraints
4716 * is not confused by domain compression.
4717 * In particular, earlier versions of isl would apply
4718 * a schedule on the compressed domains to the original domains,
4719 * resulting in a failure to detect that the default schedule
4720 * violates the conditional validity constraints.
4721 */
4722static int test_special_conditional_schedule_constraints_2(isl_ctx *ctx)
4723{
4724 const char *str;
4725 isl_bool empty;
4726 isl_union_set *domain;
4727 isl_union_map *validity, *condition;
4728 isl_schedule_constraints *sc;
4729 isl_schedule *schedule;
4730 isl_union_map *umap;
4731 isl_map *map, *ge;
4732
4733 str = "{ A[0, i] : 0 <= i <= 10; B[1, i] : 0 <= i <= 10 }";
4734 domain = isl_union_set_read_from_str(ctx, str);
4735 sc = isl_schedule_constraints_on_domain(domain);
4736 str = "{ B[1, i] -> A[0, i + 1] }";
4737 condition = isl_union_map_read_from_str(ctx, str);
4738 str = "{ A[0, i] -> B[1, i - 1] }";
4739 validity = isl_union_map_read_from_str(ctx, str);
4740 sc = isl_schedule_constraints_set_conditional_validity(sc, condition,
4741 isl_union_map_copy(validity));
4742 schedule = isl_schedule_constraints_compute_schedule(sc);
4743 umap = isl_schedule_get_map(schedule);
4744 isl_schedule_free(schedule);
4745 validity = isl_union_map_apply_domain(validity,
4746 isl_union_map_copy(umap));
4747 validity = isl_union_map_apply_range(validity, umap);
4748 map = isl_map_from_union_map(validity);
4749 ge = isl_map_lex_ge(isl_space_domain(isl_map_get_space(map)));
4750 map = isl_map_intersect(map, ge);
4751 empty = isl_map_is_empty(map);
4752 isl_map_free(map);
4753
4754 if (empty < 0)
4755 return -1;
4756 if (!empty)
4757 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "conditional validity constraints not satisfied"
, "polly/lib/External/isl/isl_test.c", 4759); return -1; } while
(0)
4758 "conditional validity constraints not satisfied",do { isl_handle_error(ctx, isl_error_unknown, "conditional validity constraints not satisfied"
, "polly/lib/External/isl/isl_test.c", 4759); return -1; } while
(0)
4759 return -1)do { isl_handle_error(ctx, isl_error_unknown, "conditional validity constraints not satisfied"
, "polly/lib/External/isl/isl_test.c", 4759); return -1; } while
(0)
;
4760
4761 return 0;
4762}
4763
4764/* Input for testing of schedule construction based on
4765 * conditional constraints.
4766 *
4767 * domain is the iteration domain
4768 * flow are the flow dependences, which determine the validity and
4769 * proximity constraints
4770 * condition are the conditions on the conditional validity constraints
4771 * conditional_validity are the conditional validity constraints
4772 * outer_band_n is the expected number of members in the outer band
4773 */
4774struct {
4775 const char *domain;
4776 const char *flow;
4777 const char *condition;
4778 const char *conditional_validity;
4779 int outer_band_n;
4780} live_range_tests[] = {
4781 /* Contrived example that illustrates that we need to keep
4782 * track of tagged condition dependences and
4783 * tagged conditional validity dependences
4784 * in isl_sched_edge separately.
4785 * In particular, the conditional validity constraints on A
4786 * cannot be satisfied,
4787 * but they can be ignored because there are no corresponding
4788 * condition constraints. However, we do have an additional
4789 * conditional validity constraint that maps to the same
4790 * dependence relation
4791 * as the condition constraint on B. If we did not make a distinction
4792 * between tagged condition and tagged conditional validity
4793 * dependences, then we
4794 * could end up treating this shared dependence as an condition
4795 * constraint on A, forcing a localization of the conditions,
4796 * which is impossible.
4797 */
4798 { "{ S[i] : 0 <= 1 < 100; T[i] : 0 <= 1 < 100 }",
4799 "{ S[i] -> S[i+1] : 0 <= i < 99 }",
4800 "{ [S[i] -> B[]] -> [S[i+1] -> B[]] : 0 <= i < 99 }",
4801 "{ [S[i] -> A[]] -> [T[i'] -> A[]] : 0 <= i', i < 100 and i != i';"
4802 "[T[i] -> A[]] -> [S[i'] -> A[]] : 0 <= i', i < 100 and i != i';"
4803 "[S[i] -> A[]] -> [S[i+1] -> A[]] : 0 <= i < 99 }",
4804 1
4805 },
4806 /* TACO 2013 Fig. 7 */
4807 { "[n] -> { S1[i,j] : 0 <= i,j < n; S2[i,j] : 0 <= i,j < n }",
4808 "[n] -> { S1[i,j] -> S2[i,j] : 0 <= i,j < n;"
4809 "S2[i,j] -> S2[i,j+1] : 0 <= i < n and 0 <= j < n - 1 }",
4810 "[n] -> { [S1[i,j] -> t[]] -> [S2[i,j] -> t[]] : 0 <= i,j < n;"
4811 "[S2[i,j] -> x1[]] -> [S2[i,j+1] -> x1[]] : "
4812 "0 <= i < n and 0 <= j < n - 1 }",
4813 "[n] -> { [S2[i,j] -> t[]] -> [S1[i,j'] -> t[]] : "
4814 "0 <= i < n and 0 <= j < j' < n;"
4815 "[S2[i,j] -> t[]] -> [S1[i',j'] -> t[]] : "
4816 "0 <= i < i' < n and 0 <= j,j' < n;"
4817 "[S2[i,j] -> x1[]] -> [S2[i,j'] -> x1[]] : "
4818 "0 <= i,j,j' < n and j < j' }",
4819 2
4820 },
4821 /* TACO 2013 Fig. 7, without tags */
4822 { "[n] -> { S1[i,j] : 0 <= i,j < n; S2[i,j] : 0 <= i,j < n }",
4823 "[n] -> { S1[i,j] -> S2[i,j] : 0 <= i,j < n;"
4824 "S2[i,j] -> S2[i,j+1] : 0 <= i < n and 0 <= j < n - 1 }",
4825 "[n] -> { S1[i,j] -> S2[i,j] : 0 <= i,j < n;"
4826 "S2[i,j] -> S2[i,j+1] : 0 <= i < n and 0 <= j < n - 1 }",
4827 "[n] -> { S2[i,j] -> S1[i,j'] : 0 <= i < n and 0 <= j < j' < n;"
4828 "S2[i,j] -> S1[i',j'] : 0 <= i < i' < n and 0 <= j,j' < n;"
4829 "S2[i,j] -> S2[i,j'] : 0 <= i,j,j' < n and j < j' }",
4830 1
4831 },
4832 /* TACO 2013 Fig. 12 */
4833 { "{ S1[i,0] : 0 <= i <= 1; S2[i,j] : 0 <= i <= 1 and 1 <= j <= 2;"
4834 "S3[i,3] : 0 <= i <= 1 }",
4835 "{ S1[i,0] -> S2[i,1] : 0 <= i <= 1;"
4836 "S2[i,1] -> S2[i,2] : 0 <= i <= 1;"
4837 "S2[i,2] -> S3[i,3] : 0 <= i <= 1 }",
4838 "{ [S1[i,0]->t[]] -> [S2[i,1]->t[]] : 0 <= i <= 1;"
4839 "[S2[i,1]->t[]] -> [S2[i,2]->t[]] : 0 <= i <= 1;"
4840 "[S2[i,2]->t[]] -> [S3[i,3]->t[]] : 0 <= i <= 1 }",
4841 "{ [S2[i,1]->t[]] -> [S2[i,2]->t[]] : 0 <= i <= 1;"
4842 "[S2[0,j]->t[]] -> [S2[1,j']->t[]] : 1 <= j,j' <= 2;"
4843 "[S2[0,j]->t[]] -> [S1[1,0]->t[]] : 1 <= j <= 2;"
4844 "[S3[0,3]->t[]] -> [S2[1,j]->t[]] : 1 <= j <= 2;"
4845 "[S3[0,3]->t[]] -> [S1[1,0]->t[]] }",
4846 1
4847 }
4848};
4849
4850/* Test schedule construction based on conditional constraints.
4851 * In particular, check the number of members in the outer band node
4852 * as an indication of whether tiling is possible or not.
4853 */
4854static int test_conditional_schedule_constraints(isl_ctx *ctx)
4855{
4856 int i;
4857 isl_union_set *domain;
4858 isl_union_map *condition;
4859 isl_union_map *flow;
4860 isl_union_map *validity;
4861 isl_schedule_constraints *sc;
4862 isl_schedule *schedule;
4863 isl_schedule_node *node;
4864 isl_size n_member;
4865
4866 if (test_special_conditional_schedule_constraints(ctx) < 0)
4867 return -1;
4868 if (test_special_conditional_schedule_constraints_2(ctx) < 0)
4869 return -1;
4870
4871 for (i = 0; i < ARRAY_SIZE(live_range_tests)(sizeof(live_range_tests)/sizeof(*live_range_tests)); ++i) {
4872 domain = isl_union_set_read_from_str(ctx,
4873 live_range_tests[i].domain);
4874 flow = isl_union_map_read_from_str(ctx,
4875 live_range_tests[i].flow);
4876 condition = isl_union_map_read_from_str(ctx,
4877 live_range_tests[i].condition);
4878 validity = isl_union_map_read_from_str(ctx,
4879 live_range_tests[i].conditional_validity);
4880 sc = isl_schedule_constraints_on_domain(domain);
4881 sc = isl_schedule_constraints_set_validity(sc,
4882 isl_union_map_copy(flow));
4883 sc = isl_schedule_constraints_set_proximity(sc, flow);
4884 sc = isl_schedule_constraints_set_conditional_validity(sc,
4885 condition, validity);
4886 schedule = isl_schedule_constraints_compute_schedule(sc);
4887 node = isl_schedule_get_root(schedule);
4888 while (node &&
4889 isl_schedule_node_get_type(node) != isl_schedule_node_band)
4890 node = isl_schedule_node_first_child(node);
4891 n_member = isl_schedule_node_band_n_member(node);
4892 isl_schedule_node_free(node);
4893 isl_schedule_free(schedule);
4894
4895 if (!schedule || n_member < 0)
4896 return -1;
4897 if (n_member != live_range_tests[i].outer_band_n)
4898 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected number of members in outer band"
, "polly/lib/External/isl/isl_test.c", 4900); return -1; } while
(0)
4899 "unexpected number of members in outer band",do { isl_handle_error(ctx, isl_error_unknown, "unexpected number of members in outer band"
, "polly/lib/External/isl/isl_test.c", 4900); return -1; } while
(0)
4900 return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected number of members in outer band"
, "polly/lib/External/isl/isl_test.c", 4900); return -1; } while
(0)
;
4901 }
4902 return 0;
4903}
4904
4905/* Check that the schedule computed for the given instance set and
4906 * dependence relation strongly satisfies the dependences.
4907 * In particular, check that no instance is scheduled before
4908 * or together with an instance on which it depends.
4909 * Earlier versions of isl would produce a schedule that
4910 * only weakly satisfies the dependences.
4911 */
4912static int test_strongly_satisfying_schedule(isl_ctx *ctx)
4913{
4914 const char *domain, *dep;
4915 isl_union_map *D, *schedule;
4916 isl_map *map, *ge;
4917 int empty;
4918
4919 domain = "{ B[i0, i1] : 0 <= i0 <= 1 and 0 <= i1 <= 11; "
4920 "A[i0] : 0 <= i0 <= 1 }";
4921 dep = "{ B[i0, i1] -> B[i0, 1 + i1] : 0 <= i0 <= 1 and 0 <= i1 <= 10; "
4922 "B[0, 11] -> A[1]; A[i0] -> B[i0, 0] : 0 <= i0 <= 1 }";
4923 schedule = compute_schedule(ctx, domain, dep, dep);
4924 D = isl_union_map_read_from_str(ctx, dep);
4925 D = isl_union_map_apply_domain(D, isl_union_map_copy(schedule));
4926 D = isl_union_map_apply_range(D, schedule);
4927 map = isl_map_from_union_map(D);
4928 ge = isl_map_lex_ge(isl_space_domain(isl_map_get_space(map)));
4929 map = isl_map_intersect(map, ge);
4930 empty = isl_map_is_empty(map);
4931 isl_map_free(map);
4932
4933 if (empty < 0)
4934 return -1;
4935 if (!empty)
4936 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "dependences not strongly satisfied"
, "polly/lib/External/isl/isl_test.c", 4937); return -1; } while
(0)
4937 "dependences not strongly satisfied", return -1)do { isl_handle_error(ctx, isl_error_unknown, "dependences not strongly satisfied"
, "polly/lib/External/isl/isl_test.c", 4937); return -1; } while
(0)
;
4938
4939 return 0;
4940}
4941
4942/* Compute a schedule for input where the instance set constraints
4943 * conflict with the context constraints.
4944 * Earlier versions of isl did not properly handle this situation.
4945 */
4946static int test_conflicting_context_schedule(isl_ctx *ctx)
4947{
4948 isl_union_map *schedule;
4949 const char *domain, *context;
4950
4951 domain = "[n] -> { A[] : n >= 0 }";
4952 context = "[n] -> { : n < 0 }";
4953 schedule = compute_schedule_with_context(ctx,
4954 domain, "{}", "{}", context);
4955 isl_union_map_free(schedule);
4956
4957 if (!schedule)
4958 return -1;
4959
4960 return 0;
4961}
4962
4963/* Check that a set of schedule constraints that only allow for
4964 * a coalescing schedule still produces a schedule even if the user
4965 * request a non-coalescing schedule. Earlier versions of isl
4966 * would not handle this case correctly.
4967 */
4968static int test_coalescing_schedule(isl_ctx *ctx)
4969{
4970 const char *domain, *dep;
4971 isl_union_set *I;
4972 isl_union_map *D;
4973 isl_schedule_constraints *sc;
4974 isl_schedule *schedule;
4975 int treat_coalescing;
4976
4977 domain = "{ S[a, b] : 0 <= a <= 1 and 0 <= b <= 1 }";
4978 dep = "{ S[a, b] -> S[a + b, 1 - b] }";
4979 I = isl_union_set_read_from_str(ctx, domain);
4980 D = isl_union_map_read_from_str(ctx, dep);
4981 sc = isl_schedule_constraints_on_domain(I);
4982 sc = isl_schedule_constraints_set_validity(sc, D);
4983 treat_coalescing = isl_options_get_schedule_treat_coalescing(ctx);
4984 isl_options_set_schedule_treat_coalescing(ctx, 1);
4985 schedule = isl_schedule_constraints_compute_schedule(sc);
4986 isl_options_set_schedule_treat_coalescing(ctx, treat_coalescing);
4987 isl_schedule_free(schedule);
4988 if (!schedule)
4989 return -1;
4990 return 0;
4991}
4992
4993/* Check that the scheduler does not perform any needless
4994 * compound skewing. Earlier versions of isl would compute
4995 * schedules in terms of transformed schedule coefficients and
4996 * would not accurately keep track of the sum of the original
4997 * schedule coefficients. It could then produce the schedule
4998 * S[t,i,j,k] -> [t, 2t + i, 2t + i + j, 2t + i + j + k]
4999 * for the input below instead of the schedule below.
5000 */
5001static int test_skewing_schedule(isl_ctx *ctx)
5002{
5003 const char *D, *V, *P, *S;
5004
5005 D = "[n] -> { S[t,i,j,k] : 0 <= t,i,j,k < n }";
5006 V = "[n] -> { S[t,i,j,k] -> S[t+1,a,b,c] : 0 <= t,i,j,k,a,b,c < n and "
5007 "-2 <= a-i <= 2 and -1 <= a-i + b-j <= 1 and "
5008 "-1 <= a-i + b-j + c-k <= 1 }";
5009 P = "{ }";
5010 S = "{ S[t,i,j,k] -> [t, 2t + i, t + i + j, 2t + k] }";
5011
5012 return test_special_schedule(ctx, D, V, P, S);
5013}
5014
5015int test_schedule(isl_ctx *ctx)
5016{
5017 const char *D, *W, *R, *V, *P, *S;
5018 int max_coincidence;
5019 int treat_coalescing;
5020
5021 /* Handle resulting schedule with zero bands. */
5022 if (test_one_schedule(ctx, "{[]}", "{}", "{}", "{[] -> []}", 0, 0) < 0)
5023 return -1;
5024
5025 /* Jacobi */
5026 D = "[T,N] -> { S1[t,i] : 1 <= t <= T and 2 <= i <= N - 1 }";
5027 W = "{ S1[t,i] -> a[t,i] }";
5028 R = "{ S1[t,i] -> a[t-1,i]; S1[t,i] -> a[t-1,i-1]; "
5029 "S1[t,i] -> a[t-1,i+1] }";
5030 S = "{ S1[t,i] -> [t,i] }";
5031 if (test_one_schedule(ctx, D, W, R, S, 2, 0) < 0)
5032 return -1;
5033
5034 /* Fig. 5 of CC2008 */
5035 D = "[N] -> { S_0[i, j] : i >= 0 and i <= -1 + N and j >= 2 and "
5036 "j <= -1 + N }";
5037 W = "[N] -> { S_0[i, j] -> a[i, j] : i >= 0 and i <= -1 + N and "
5038 "j >= 2 and j <= -1 + N }";
5039 R = "[N] -> { S_0[i, j] -> a[j, i] : i >= 0 and i <= -1 + N and "
5040 "j >= 2 and j <= -1 + N; "
5041 "S_0[i, j] -> a[i, -1 + j] : i >= 0 and i <= -1 + N and "
5042 "j >= 2 and j <= -1 + N }";
5043 S = "[N] -> { S_0[i, j] -> [0, i, 0, j, 0] }";
5044 if (test_one_schedule(ctx, D, W, R, S, 2, 0) < 0)
5045 return -1;
5046
5047 D = "{ S1[i] : 0 <= i <= 10; S2[i] : 0 <= i <= 9 }";
5048 W = "{ S1[i] -> a[i] }";
5049 R = "{ S2[i] -> a[i+1] }";
5050 S = "{ S1[i] -> [0,i]; S2[i] -> [1,i] }";
5051 if (test_one_schedule(ctx, D, W, R, S, 1, 1) < 0)
5052 return -1;
5053
5054 D = "{ S1[i] : 0 <= i < 10; S2[i] : 0 <= i < 10 }";
5055 W = "{ S1[i] -> a[i] }";
5056 R = "{ S2[i] -> a[9-i] }";
5057 S = "{ S1[i] -> [0,i]; S2[i] -> [1,i] }";
5058 if (test_one_schedule(ctx, D, W, R, S, 1, 1) < 0)
5059 return -1;
5060
5061 D = "[N] -> { S1[i] : 0 <= i < N; S2[i] : 0 <= i < N }";
5062 W = "{ S1[i] -> a[i] }";
5063 R = "[N] -> { S2[i] -> a[N-1-i] }";
5064 S = "{ S1[i] -> [0,i]; S2[i] -> [1,i] }";
5065 if (test_one_schedule(ctx, D, W, R, S, 1, 1) < 0)
5066 return -1;
5067
5068 D = "{ S1[i] : 0 < i < 10; S2[i] : 0 <= i < 10 }";
5069 W = "{ S1[i] -> a[i]; S2[i] -> b[i] }";
5070 R = "{ S2[i] -> a[i]; S1[i] -> b[i-1] }";
5071 S = "{ S1[i] -> [i,0]; S2[i] -> [i,1] }";
5072 if (test_one_schedule(ctx, D, W, R, S, 0, 0) < 0)
5073 return -1;
5074
5075 D = "[N] -> { S1[i] : 1 <= i <= N; S2[i,j] : 1 <= i,j <= N }";
5076 W = "{ S1[i] -> a[0,i]; S2[i,j] -> a[i,j] }";
5077 R = "{ S2[i,j] -> a[i-1,j] }";
5078 S = "{ S1[i] -> [0,i,0]; S2[i,j] -> [1,i,j] }";
5079 if (test_one_schedule(ctx, D, W, R, S, 2, 1) < 0)
5080 return -1;
5081
5082 D = "[N] -> { S1[i] : 1 <= i <= N; S2[i,j] : 1 <= i,j <= N }";
5083 W = "{ S1[i] -> a[i,0]; S2[i,j] -> a[i,j] }";
5084 R = "{ S2[i,j] -> a[i,j-1] }";
5085 S = "{ S1[i] -> [0,i,0]; S2[i,j] -> [1,i,j] }";
5086 if (test_one_schedule(ctx, D, W, R, S, 2, 1) < 0)
5087 return -1;
5088
5089 D = "[N] -> { S_0[]; S_1[i] : i >= 0 and i <= -1 + N; S_2[] }";
5090 W = "[N] -> { S_0[] -> a[0]; S_2[] -> b[0]; "
5091 "S_1[i] -> a[1 + i] : i >= 0 and i <= -1 + N }";
5092 R = "[N] -> { S_2[] -> a[N]; S_1[i] -> a[i] : i >= 0 and i <= -1 + N }";
5093 S = "[N] -> { S_1[i] -> [1, i, 0]; S_2[] -> [2, 0, 1]; "
5094 "S_0[] -> [0, 0, 0] }";
5095 if (test_one_schedule(ctx, D, W, R, S, 1, 0) < 0)
5096 return -1;
5097 ctx->opt->schedule_parametric = 0;
5098 if (test_one_schedule(ctx, D, W, R, S, 0, 0) < 0)
5099 return -1;
5100 ctx->opt->schedule_parametric = 1;
5101
5102 D = "[N] -> { S1[i] : 1 <= i <= N; S2[i] : 1 <= i <= N; "
5103 "S3[i,j] : 1 <= i,j <= N; S4[i] : 1 <= i <= N }";
5104 W = "{ S1[i] -> a[i,0]; S2[i] -> a[0,i]; S3[i,j] -> a[i,j] }";
5105 R = "[N] -> { S3[i,j] -> a[i-1,j]; S3[i,j] -> a[i,j-1]; "
5106 "S4[i] -> a[i,N] }";
5107 S = "{ S1[i] -> [0,i,0]; S2[i] -> [1,i,0]; S3[i,j] -> [2,i,j]; "
5108 "S4[i] -> [4,i,0] }";
5109 max_coincidence = isl_options_get_schedule_maximize_coincidence(ctx);
5110 isl_options_set_schedule_maximize_coincidence(ctx, 0);
5111 if (test_one_schedule(ctx, D, W, R, S, 2, 0) < 0)
5112 return -1;
5113 isl_options_set_schedule_maximize_coincidence(ctx, max_coincidence);
5114
5115 D = "[N] -> { S_0[i, j] : i >= 1 and i <= N and j >= 1 and j <= N }";
5116 W = "[N] -> { S_0[i, j] -> s[0] : i >= 1 and i <= N and j >= 1 and "
5117 "j <= N }";
5118 R = "[N] -> { S_0[i, j] -> s[0] : i >= 1 and i <= N and j >= 1 and "
5119 "j <= N; "
5120 "S_0[i, j] -> a[i, j] : i >= 1 and i <= N and j >= 1 and "
5121 "j <= N }";
5122 S = "[N] -> { S_0[i, j] -> [0, i, 0, j, 0] }";
5123 if (test_one_schedule(ctx, D, W, R, S, 0, 0) < 0)
5124 return -1;
5125
5126 D = "[N] -> { S_0[t] : t >= 0 and t <= -1 + N; "
5127 " S_2[t] : t >= 0 and t <= -1 + N; "
5128 " S_1[t, i] : t >= 0 and t <= -1 + N and i >= 0 and "
5129 "i <= -1 + N }";
5130 W = "[N] -> { S_0[t] -> a[t, 0] : t >= 0 and t <= -1 + N; "
5131 " S_2[t] -> b[t] : t >= 0 and t <= -1 + N; "
5132 " S_1[t, i] -> a[t, 1 + i] : t >= 0 and t <= -1 + N and "
5133 "i >= 0 and i <= -1 + N }";
5134 R = "[N] -> { S_1[t, i] -> a[t, i] : t >= 0 and t <= -1 + N and "
5135 "i >= 0 and i <= -1 + N; "
5136 " S_2[t] -> a[t, N] : t >= 0 and t <= -1 + N }";
5137 S = "[N] -> { S_2[t] -> [0, t, 2]; S_1[t, i] -> [0, t, 1, i, 0]; "
5138 " S_0[t] -> [0, t, 0] }";
5139
5140 if (test_one_schedule(ctx, D, W, R, S, 2, 1) < 0)
5141 return -1;
5142 ctx->opt->schedule_parametric = 0;
5143 if (test_one_schedule(ctx, D, W, R, S, 0, 0) < 0)
5144 return -1;
5145 ctx->opt->schedule_parametric = 1;
5146
5147 D = "[N] -> { S1[i,j] : 0 <= i,j < N; S2[i,j] : 0 <= i,j < N }";
5148 S = "{ S1[i,j] -> [0,i,j]; S2[i,j] -> [1,i,j] }";
5149 if (test_one_schedule(ctx, D, "{}", "{}", S, 2, 2) < 0)
5150 return -1;
5151
5152 D = "[M, N] -> { S_1[i] : i >= 0 and i <= -1 + M; "
5153 "S_0[i, j] : i >= 0 and i <= -1 + M and j >= 0 and j <= -1 + N }";
5154 W = "[M, N] -> { S_0[i, j] -> a[j] : i >= 0 and i <= -1 + M and "
5155 "j >= 0 and j <= -1 + N; "
5156 "S_1[i] -> b[0] : i >= 0 and i <= -1 + M }";
5157 R = "[M, N] -> { S_0[i, j] -> a[0] : i >= 0 and i <= -1 + M and "
5158 "j >= 0 and j <= -1 + N; "
5159 "S_1[i] -> b[0] : i >= 0 and i <= -1 + M }";
5160 S = "[M, N] -> { S_1[i] -> [1, i, 0]; S_0[i, j] -> [0, i, 0, j, 0] }";
5161 if (test_one_schedule(ctx, D, W, R, S, 0, 0) < 0)
5162 return -1;
5163
5164 D = "{ S_0[i] : i >= 0 }";
5165 W = "{ S_0[i] -> a[i] : i >= 0 }";
5166 R = "{ S_0[i] -> a[0] : i >= 0 }";
5167 S = "{ S_0[i] -> [0, i, 0] }";
5168 if (test_one_schedule(ctx, D, W, R, S, 0, 0) < 0)
5169 return -1;
5170
5171 D = "{ S_0[i] : i >= 0; S_1[i] : i >= 0 }";
5172 W = "{ S_0[i] -> a[i] : i >= 0; S_1[i] -> b[i] : i >= 0 }";
5173 R = "{ S_0[i] -> b[0] : i >= 0; S_1[i] -> a[i] : i >= 0 }";
5174 S = "{ S_1[i] -> [0, i, 1]; S_0[i] -> [0, i, 0] }";
5175 if (test_one_schedule(ctx, D, W, R, S, 0, 0) < 0)
5176 return -1;
5177
5178 D = "[n] -> { S_0[j, k] : j <= -1 + n and j >= 0 and "
5179 "k <= -1 + n and k >= 0 }";
5180 W = "[n] -> { S_0[j, k] -> B[j] : j <= -1 + n and j >= 0 and " "k <= -1 + n and k >= 0 }";
5181 R = "[n] -> { S_0[j, k] -> B[j] : j <= -1 + n and j >= 0 and "
5182 "k <= -1 + n and k >= 0; "
5183 "S_0[j, k] -> B[k] : j <= -1 + n and j >= 0 and "
5184 "k <= -1 + n and k >= 0; "
5185 "S_0[j, k] -> A[k] : j <= -1 + n and j >= 0 and "
5186 "k <= -1 + n and k >= 0 }";
5187 S = "[n] -> { S_0[j, k] -> [2, j, k] }";
5188 ctx->opt->schedule_outer_coincidence = 1;
5189 if (test_one_schedule(ctx, D, W, R, S, 0, 0) < 0)
5190 return -1;
5191 ctx->opt->schedule_outer_coincidence = 0;
5192
5193 D = "{Stmt_for_body24[i0, i1, i2, i3]:"
5194 "i0 >= 0 and i0 <= 1 and i1 >= 0 and i1 <= 6 and i2 >= 2 and "
5195 "i2 <= 6 - i1 and i3 >= 0 and i3 <= -1 + i2;"
5196 "Stmt_for_body24[i0, i1, 1, 0]:"
5197 "i0 >= 0 and i0 <= 1 and i1 >= 0 and i1 <= 5;"
5198 "Stmt_for_body7[i0, i1, i2]:"
5199 "i0 >= 0 and i0 <= 1 and i1 >= 0 and i1 <= 7 and i2 >= 0 and "
5200 "i2 <= 7 }";
5201
5202 V = "{Stmt_for_body24[0, i1, i2, i3] -> "
5203 "Stmt_for_body24[1, i1, i2, i3]:"
5204 "i3 >= 0 and i3 <= -1 + i2 and i1 >= 0 and i2 <= 6 - i1 and "
5205 "i2 >= 1;"
5206 "Stmt_for_body24[0, i1, i2, i3] -> "
5207 "Stmt_for_body7[1, 1 + i1 + i3, 1 + i1 + i2]:"
5208 "i3 <= -1 + i2 and i2 <= 6 - i1 and i2 >= 1 and i1 >= 0 and "
5209 "i3 >= 0;"
5210 "Stmt_for_body24[0, i1, i2, i3] ->"
5211 "Stmt_for_body7[1, i1, 1 + i1 + i3]:"
5212 "i3 >= 0 and i2 <= 6 - i1 and i1 >= 0 and i3 <= -1 + i2;"
5213 "Stmt_for_body7[0, i1, i2] -> Stmt_for_body7[1, i1, i2]:"
5214 "(i2 >= 1 + i1 and i2 <= 6 and i1 >= 0 and i1 <= 4) or "
5215 "(i2 >= 3 and i2 <= 7 and i1 >= 1 and i2 >= 1 + i1) or "
5216 "(i2 >= 0 and i2 <= i1 and i2 >= -7 + i1 and i1 <= 7);"
5217 "Stmt_for_body7[0, i1, 1 + i1] -> Stmt_for_body7[1, i1, 1 + i1]:"
5218 "i1 <= 6 and i1 >= 0;"
5219 "Stmt_for_body7[0, 0, 7] -> Stmt_for_body7[1, 0, 7];"
5220 "Stmt_for_body7[i0, i1, i2] -> "
5221 "Stmt_for_body24[i0, o1, -1 + i2 - o1, -1 + i1 - o1]:"
5222 "i0 >= 0 and i0 <= 1 and o1 >= 0 and i2 >= 1 + i1 and "
5223 "o1 <= -2 + i2 and i2 <= 7 and o1 <= -1 + i1;"
5224 "Stmt_for_body7[i0, i1, i2] -> "
5225 "Stmt_for_body24[i0, i1, o2, -1 - i1 + i2]:"
5226 "i0 >= 0 and i0 <= 1 and i1 >= 0 and o2 >= -i1 + i2 and "
5227 "o2 >= 1 and o2 <= 6 - i1 and i2 >= 1 + i1 }";
5228 P = V;
5229
5230 treat_coalescing = isl_options_get_schedule_treat_coalescing(ctx);
5231 isl_options_set_schedule_treat_coalescing(ctx, 0);
5232 if (test_has_schedule(ctx, D, V, P) < 0)
5233 return -1;
5234 isl_options_set_schedule_treat_coalescing(ctx, treat_coalescing);
5235
5236 D = "{ S_0[i, j] : i >= 1 and i <= 10 and j >= 1 and j <= 8 }";
5237 V = "{ S_0[i, j] -> S_0[i, 1 + j] : i >= 1 and i <= 10 and "
5238 "j >= 1 and j <= 7;"
5239 "S_0[i, j] -> S_0[1 + i, j] : i >= 1 and i <= 9 and "
5240 "j >= 1 and j <= 8 }";
5241 P = "{ }";
5242 S = "{ S_0[i, j] -> [i + j, i] }";
5243 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER1;
5244 if (test_special_schedule(ctx, D, V, P, S) < 0)
5245 return -1;
5246 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_ISL0;
5247
5248 /* Fig. 1 from Feautrier's "Some Efficient Solutions..." pt. 2, 1992 */
5249 D = "[N] -> { S_0[i, j] : i >= 0 and i <= -1 + N and "
5250 "j >= 0 and j <= -1 + i }";
5251 V = "[N] -> { S_0[i, j] -> S_0[i, 1 + j] : j <= -2 + i and "
5252 "i <= -1 + N and j >= 0;"
5253 "S_0[i, -1 + i] -> S_0[1 + i, 0] : i >= 1 and "
5254 "i <= -2 + N }";
5255 P = "{ }";
5256 S = "{ S_0[i, j] -> [i, j] }";
5257 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER1;
5258 if (test_special_schedule(ctx, D, V, P, S) < 0)
5259 return -1;
5260 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_ISL0;
5261
5262 /* Test both algorithms on a case with only proximity dependences. */
5263 D = "{ S[i,j] : 0 <= i <= 10 }";
5264 V = "{ }";
5265 P = "{ S[i,j] -> S[i+1,j] : 0 <= i,j <= 10 }";
5266 S = "{ S[i, j] -> [j, i] }";
5267 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER1;
5268 if (test_special_schedule(ctx, D, V, P, S) < 0)
5269 return -1;
5270 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_ISL0;
5271 if (test_special_schedule(ctx, D, V, P, S) < 0)
5272 return -1;
5273
5274 D = "{ A[a]; B[] }";
5275 V = "{}";
5276 P = "{ A[a] -> B[] }";
5277 if (test_has_schedule(ctx, D, V, P) < 0)
5278 return -1;
5279
5280 if (test_padded_schedule(ctx) < 0)
5281 return -1;
5282
5283 /* Check that check for progress is not confused by rational
5284 * solution.
5285 */
5286 D = "[N] -> { S0[i, j] : i >= 0 and i <= N and j >= 0 and j <= N }";
5287 V = "[N] -> { S0[i0, -1 + N] -> S0[2 + i0, 0] : i0 >= 0 and "
5288 "i0 <= -2 + N; "
5289 "S0[i0, i1] -> S0[i0, 1 + i1] : i0 >= 0 and "
5290 "i0 <= N and i1 >= 0 and i1 <= -1 + N }";
5291 P = "{}";
5292 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER1;
5293 if (test_has_schedule(ctx, D, V, P) < 0)
5294 return -1;
5295 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_ISL0;
5296
5297 /* Check that we allow schedule rows that are only non-trivial
5298 * on some full-dimensional domains.
5299 */
5300 D = "{ S1[j] : 0 <= j <= 1; S0[]; S2[k] : 0 <= k <= 1 }";
5301 V = "{ S0[] -> S1[j] : 0 <= j <= 1; S2[0] -> S0[];"
5302 "S1[j] -> S2[1] : 0 <= j <= 1 }";
5303 P = "{}";
5304 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER1;
5305 if (test_has_schedule(ctx, D, V, P) < 0)
5306 return -1;
5307 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_ISL0;
5308
5309 if (test_conditional_schedule_constraints(ctx) < 0)
5310 return -1;
5311
5312 if (test_strongly_satisfying_schedule(ctx) < 0)
5313 return -1;
5314
5315 if (test_conflicting_context_schedule(ctx) < 0)
5316 return -1;
5317
5318 if (test_coalescing_schedule(ctx) < 0)
5319 return -1;
5320 if (test_skewing_schedule(ctx) < 0)
5321 return -1;
5322
5323 return 0;
5324}
5325
5326/* Perform scheduling tests using the whole component scheduler.
5327 */
5328static int test_schedule_whole(isl_ctx *ctx)
5329{
5330 int whole;
5331 int r;
5332
5333 whole = isl_options_get_schedule_whole_component(ctx);
5334 isl_options_set_schedule_whole_component(ctx, 1);
5335 r = test_schedule(ctx);
5336 isl_options_set_schedule_whole_component(ctx, whole);
5337
5338 return r;
5339}
5340
5341/* Perform scheduling tests using the incremental scheduler.
5342 */
5343static int test_schedule_incremental(isl_ctx *ctx)
5344{
5345 int whole;
5346 int r;
5347
5348 whole = isl_options_get_schedule_whole_component(ctx);
5349 isl_options_set_schedule_whole_component(ctx, 0);
5350 r = test_schedule(ctx);
5351 isl_options_set_schedule_whole_component(ctx, whole);
5352
5353 return r;
5354}
5355
5356int test_plain_injective(isl_ctx *ctx, const char *str, int injective)
5357{
5358 isl_union_map *umap;
5359 int test;
5360
5361 umap = isl_union_map_read_from_str(ctx, str);
5362 test = isl_union_map_plain_is_injective(umap);
5363 isl_union_map_free(umap);
5364 if (test < 0)
5365 return -1;
5366 if (test == injective)
5367 return 0;
5368 if (injective)
5369 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "map not detected as injective"
, "polly/lib/External/isl/isl_test.c", 5370); return -1; } while
(0)
5370 "map not detected as injective", return -1)do { isl_handle_error(ctx, isl_error_unknown, "map not detected as injective"
, "polly/lib/External/isl/isl_test.c", 5370); return -1; } while
(0)
;
5371 else
5372 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "map detected as injective"
, "polly/lib/External/isl/isl_test.c", 5373); return -1; } while
(0)
5373 "map detected as injective", return -1)do { isl_handle_error(ctx, isl_error_unknown, "map detected as injective"
, "polly/lib/External/isl/isl_test.c", 5373); return -1; } while
(0)
;
5374}
5375
5376int test_injective(isl_ctx *ctx)
5377{
5378 const char *str;
5379
5380 if (test_plain_injective(ctx, "{S[i,j] -> A[0]; T[i,j] -> B[1]}", 0))
5381 return -1;
5382 if (test_plain_injective(ctx, "{S[] -> A[0]; T[] -> B[0]}", 1))
5383 return -1;
5384 if (test_plain_injective(ctx, "{S[] -> A[0]; T[] -> A[1]}", 1))
5385 return -1;
5386 if (test_plain_injective(ctx, "{S[] -> A[0]; T[] -> A[0]}", 0))
5387 return -1;
5388 if (test_plain_injective(ctx, "{S[i] -> A[i,0]; T[i] -> A[i,1]}", 1))
5389 return -1;
5390 if (test_plain_injective(ctx, "{S[i] -> A[i]; T[i] -> A[i]}", 0))
5391 return -1;
5392 if (test_plain_injective(ctx, "{S[] -> A[0,0]; T[] -> A[0,1]}", 1))
5393 return -1;
5394 if (test_plain_injective(ctx, "{S[] -> A[0,0]; T[] -> A[1,0]}", 1))
5395 return -1;
5396
5397 str = "{S[] -> A[0,0]; T[] -> A[0,1]; U[] -> A[1,0]}";
5398 if (test_plain_injective(ctx, str, 1))
5399 return -1;
5400 str = "{S[] -> A[0,0]; T[] -> A[0,1]; U[] -> A[0,0]}";
5401 if (test_plain_injective(ctx, str, 0))
5402 return -1;
5403
5404 return 0;
5405}
5406
5407#undef BASEunion_pw_aff
5408#define BASEunion_pw_aff aff
5409#include "isl_test_plain_equal_templ.c"
5410
5411#undef BASEunion_pw_aff
5412#define BASEunion_pw_aff pw_multi_aff
5413#include "isl_test_plain_equal_templ.c"
5414
5415#undef BASEunion_pw_aff
5416#define BASEunion_pw_aff union_pw_aff
5417#include "isl_test_plain_equal_templ.c"
5418
5419/* Basic tests on isl_union_pw_aff.
5420 *
5421 * In particular, check that isl_union_pw_aff_aff_on_domain
5422 * aligns the parameters of the input objects and
5423 * that isl_union_pw_aff_param_on_domain_id properly
5424 * introduces the parameter.
5425 */
5426static int test_upa(isl_ctx *ctx)
5427{
5428 const char *str;
5429 isl_id *id;
5430 isl_aff *aff;
5431 isl_union_set *domain;
5432 isl_union_pw_aff *upa;
5433 isl_stat ok;
5434
5435 aff = isl_aff_read_from_str(ctx, "[N] -> { [N] }");
5436 str = "[M] -> { A[i] : 0 <= i < M; B[] }";
5437 domain = isl_union_set_read_from_str(ctx, str);
5438 upa = isl_union_pw_aff_aff_on_domain(domain, aff);
5439 str = "[N, M] -> { A[i] -> [N] : 0 <= i < M; B[] -> [N] }";
5440 ok = union_pw_aff_check_plain_equal(upa, str);
5441 isl_union_pw_aff_free(upa);
5442 if (ok < 0)
5443 return -1;
5444
5445 id = isl_id_alloc(ctx, "N", NULL((void*)0));
5446 str = "[M] -> { A[i] : 0 <= i < M; B[] }";
5447 domain = isl_union_set_read_from_str(ctx, str);
5448 upa = isl_union_pw_aff_param_on_domain_id(domain, id);
5449 str = "[N, M] -> { A[i] -> [N] : 0 <= i < M; B[] -> [N] }";
5450 ok = union_pw_aff_check_plain_equal(upa, str);
5451 isl_union_pw_aff_free(upa);
5452 if (ok < 0)
5453 return -1;
5454
5455 return 0;
5456}
5457
5458struct {
5459 __isl_give isl_aff *(*fn)(__isl_take isl_aff *aff1,
5460 __isl_take isl_aff *aff2);
5461} aff_bin_op[] = {
5462 ['+'] = { &isl_aff_add },
5463 ['-'] = { &isl_aff_sub },
5464 ['*'] = { &isl_aff_mul },
5465 ['/'] = { &isl_aff_div },
5466};
5467
5468struct {
5469 const char *arg1;
5470 unsigned char op;
5471 const char *arg2;
5472 const char *res;
5473} aff_bin_tests[] = {
5474 { "{ [i] -> [i] }", '+', "{ [i] -> [i] }",
5475 "{ [i] -> [2i] }" },
5476 { "{ [i] -> [i] }", '-', "{ [i] -> [i] }",
5477 "{ [i] -> [0] }" },
5478 { "{ [i] -> [i] }", '*', "{ [i] -> [2] }",
5479 "{ [i] -> [2i] }" },
5480 { "{ [i] -> [2] }", '*', "{ [i] -> [i] }",
5481 "{ [i] -> [2i] }" },
5482 { "{ [i] -> [i] }", '/', "{ [i] -> [2] }",
5483 "{ [i] -> [i/2] }" },
5484 { "{ [i] -> [2i] }", '/', "{ [i] -> [2] }",
5485 "{ [i] -> [i] }" },
5486 { "{ [i] -> [i] }", '+', "{ [i] -> [NaN] }",
5487 "{ [i] -> [NaN] }" },
5488 { "{ [i] -> [i] }", '-', "{ [i] -> [NaN] }",
5489 "{ [i] -> [NaN] }" },
5490 { "{ [i] -> [i] }", '*', "{ [i] -> [NaN] }",
5491 "{ [i] -> [NaN] }" },
5492 { "{ [i] -> [2] }", '*', "{ [i] -> [NaN] }",
5493 "{ [i] -> [NaN] }" },
5494 { "{ [i] -> [i] }", '/', "{ [i] -> [NaN] }",
5495 "{ [i] -> [NaN] }" },
5496 { "{ [i] -> [2] }", '/', "{ [i] -> [NaN] }",
5497 "{ [i] -> [NaN] }" },
5498 { "{ [i] -> [NaN] }", '+', "{ [i] -> [i] }",
5499 "{ [i] -> [NaN] }" },
5500 { "{ [i] -> [NaN] }", '-', "{ [i] -> [i] }",
5501 "{ [i] -> [NaN] }" },
5502 { "{ [i] -> [NaN] }", '*', "{ [i] -> [2] }",
5503 "{ [i] -> [NaN] }" },
5504 { "{ [i] -> [NaN] }", '*', "{ [i] -> [i] }",
5505 "{ [i] -> [NaN] }" },
5506 { "{ [i] -> [NaN] }", '/', "{ [i] -> [2] }",
5507 "{ [i] -> [NaN] }" },
5508 { "{ [i] -> [NaN] }", '/', "{ [i] -> [i] }",
5509 "{ [i] -> [NaN] }" },
5510 { "{ [i] -> [i] }", '/', "{ [i] -> [0] }",
5511 "{ [i] -> [NaN] }" },
5512};
5513
5514/* Perform some basic tests of binary operations on isl_aff objects.
5515 */
5516static int test_bin_aff(isl_ctx *ctx)
5517{
5518 int i;
5519 isl_aff *aff1, *aff2, *res;
5520 __isl_give isl_aff *(*fn)(__isl_take isl_aff *aff1,
5521 __isl_take isl_aff *aff2);
5522 int ok;
5523
5524 for (i = 0; i < ARRAY_SIZE(aff_bin_tests)(sizeof(aff_bin_tests)/sizeof(*aff_bin_tests)); ++i) {
5525 aff1 = isl_aff_read_from_str(ctx, aff_bin_tests[i].arg1);
5526 aff2 = isl_aff_read_from_str(ctx, aff_bin_tests[i].arg2);
5527 res = isl_aff_read_from_str(ctx, aff_bin_tests[i].res);
5528 fn = aff_bin_op[aff_bin_tests[i].op].fn;
5529 aff1 = fn(aff1, aff2);
5530 if (isl_aff_is_nan(res))
5531 ok = isl_aff_is_nan(aff1);
5532 else
5533 ok = isl_aff_plain_is_equal(aff1, res);
5534 isl_aff_free(aff1);
5535 isl_aff_free(res);
5536 if (ok < 0)
5537 return -1;
5538 if (!ok)
5539 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 5540); return -1; } while
(0)
5540 "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 5540); return -1; } while
(0)
;
5541 }
5542
5543 return 0;
5544}
5545
5546struct {
5547 __isl_give isl_pw_aff *(*fn)(__isl_take isl_pw_aff *pa1,
5548 __isl_take isl_pw_aff *pa2);
5549} pw_aff_bin_op[] = {
5550 ['m'] = { &isl_pw_aff_min },
5551 ['M'] = { &isl_pw_aff_max },
5552};
5553
5554/* Inputs for binary isl_pw_aff operation tests.
5555 * "arg1" and "arg2" are the two arguments, "op" identifies the operation
5556 * defined by pw_aff_bin_op, and "res" is the expected result.
5557 */
5558struct {
5559 const char *arg1;
5560 unsigned char op;
5561 const char *arg2;
5562 const char *res;
5563} pw_aff_bin_tests[] = {
5564 { "{ [i] -> [i] }", 'm', "{ [i] -> [i] }",
5565 "{ [i] -> [i] }" },
5566 { "{ [i] -> [i] }", 'M', "{ [i] -> [i] }",
5567 "{ [i] -> [i] }" },
5568 { "{ [i] -> [i] }", 'm', "{ [i] -> [0] }",
5569 "{ [i] -> [i] : i <= 0; [i] -> [0] : i > 0 }" },
5570 { "{ [i] -> [i] }", 'M', "{ [i] -> [0] }",
5571 "{ [i] -> [i] : i >= 0; [i] -> [0] : i < 0 }" },
5572 { "{ [i] -> [i] }", 'm', "{ [i] -> [NaN] }",
5573 "{ [i] -> [NaN] }" },
5574 { "{ [i] -> [NaN] }", 'm', "{ [i] -> [i] }",
5575 "{ [i] -> [NaN] }" },
5576};
5577
5578/* Perform some basic tests of binary operations on isl_pw_aff objects.
5579 */
5580static int test_bin_pw_aff(isl_ctx *ctx)
5581{
5582 int i;
5583 isl_bool ok;
5584 isl_pw_aff *pa1, *pa2, *res;
5585
5586 for (i = 0; i < ARRAY_SIZE(pw_aff_bin_tests)(sizeof(pw_aff_bin_tests)/sizeof(*pw_aff_bin_tests)); ++i) {
5587 pa1 = isl_pw_aff_read_from_str(ctx, pw_aff_bin_tests[i].arg1);
5588 pa2 = isl_pw_aff_read_from_str(ctx, pw_aff_bin_tests[i].arg2);
5589 res = isl_pw_aff_read_from_str(ctx, pw_aff_bin_tests[i].res);
5590 pa1 = pw_aff_bin_op[pw_aff_bin_tests[i].op].fn(pa1, pa2);
5591 if (isl_pw_aff_involves_nan(res))
5592 ok = isl_pw_aff_involves_nan(pa1);
5593 else
5594 ok = isl_pw_aff_plain_is_equal(pa1, res);
5595 isl_pw_aff_free(pa1);
5596 isl_pw_aff_free(res);
5597 if (ok < 0)
5598 return -1;
5599 if (!ok)
5600 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 5601); return -1; } while
(0)
5601 "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 5601); return -1; } while
(0)
;
5602 }
5603
5604 return 0;
5605}
5606
5607/* Inputs for basic tests of test operations on
5608 * isl_union_pw_multi_aff objects.
5609 * "fn" is the function that is being tested.
5610 * "arg" is a string description of the input.
5611 * "res" is the expected result.
5612 */
5613static struct {
5614 isl_bool (*fn)(__isl_keep isl_union_pw_multi_aff *upma1);
5615 const char *arg;
5616 isl_bool res;
5617} upma_test_tests[] = {
5618 { &isl_union_pw_multi_aff_involves_nan, "{ A[] -> [0]; B[0] -> [1] }",
5619 isl_bool_false },
5620 { &isl_union_pw_multi_aff_involves_nan, "{ A[] -> [NaN]; B[0] -> [1] }",
5621 isl_bool_true },
5622 { &isl_union_pw_multi_aff_involves_nan, "{ A[] -> [0]; B[0] -> [NaN] }",
5623 isl_bool_true },
5624 { &isl_union_pw_multi_aff_involves_nan,
5625 "{ A[] -> [0]; B[0] -> [1, NaN, 5] }",
5626 isl_bool_true },
5627 { &isl_union_pw_multi_aff_involves_locals,
5628 "{ A[] -> [0]; B[0] -> [1] }",
5629 isl_bool_false },
5630 { &isl_union_pw_multi_aff_involves_locals,
5631 "{ A[] -> [0]; B[x] -> [1] : x mod 2 = 0 }",
5632 isl_bool_true },
5633 { &isl_union_pw_multi_aff_involves_locals,
5634 "{ A[] -> [0]; B[x] -> [x // 2] }",
5635 isl_bool_true },
5636 { &isl_union_pw_multi_aff_involves_locals,
5637 "{ A[i] -> [i // 2]; B[0] -> [1] }",
5638 isl_bool_true },
5639};
5640
5641/* Perform some basic tests of test operations on
5642 * isl_union_pw_multi_aff objects.
5643 */
5644static isl_stat test_upma_test(isl_ctx *ctx)
5645{
5646 int i;
5647 isl_union_pw_multi_aff *upma;
5648 isl_bool res;
5649
5650 for (i = 0; i < ARRAY_SIZE(upma_test_tests)(sizeof(upma_test_tests)/sizeof(*upma_test_tests)); ++i) {
5651 const char *str;
5652
5653 str = upma_test_tests[i].arg;
5654 upma = isl_union_pw_multi_aff_read_from_str(ctx, str);
5655 res = upma_test_tests[i].fn(upma);
5656 isl_union_pw_multi_aff_free(upma);
5657 if (res < 0)
5658 return isl_stat_error;
5659 if (res != upma_test_tests[i].res)
5660 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 5661); return isl_stat_error
; } while (0)
5661 "unexpected result", return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 5661); return isl_stat_error
; } while (0)
;
5662 }
5663
5664 return isl_stat_ok;
5665}
5666
5667struct {
5668 __isl_give isl_union_pw_multi_aff *(*fn)(
5669 __isl_take isl_union_pw_multi_aff *upma1,
5670 __isl_take isl_union_pw_multi_aff *upma2);
5671 const char *arg1;
5672 const char *arg2;
5673 const char *res;
5674} upma_bin_tests[] = {
5675 { &isl_union_pw_multi_aff_add, "{ A[] -> [0]; B[0] -> [1] }",
5676 "{ B[x] -> [2] : x >= 0 }", "{ B[0] -> [3] }" },
5677 { &isl_union_pw_multi_aff_union_add, "{ A[] -> [0]; B[0] -> [1] }",
5678 "{ B[x] -> [2] : x >= 0 }",
5679 "{ A[] -> [0]; B[0] -> [3]; B[x] -> [2] : x >= 1 }" },
5680 { &isl_union_pw_multi_aff_pullback_union_pw_multi_aff,
5681 "{ A[] -> B[0]; C[x] -> B[1] : x < 10; C[y] -> B[2] : y >= 10 }",
5682 "{ D[i] -> A[] : i < 0; D[i] -> C[i + 5] : i >= 0 }",
5683 "{ D[i] -> B[0] : i < 0; D[i] -> B[1] : 0 <= i < 5; "
5684 "D[i] -> B[2] : i >= 5 }" },
5685 { &isl_union_pw_multi_aff_union_add, "{ B[x] -> A[1] : x <= 0 }",
5686 "{ B[x] -> C[2] : x > 0 }",
5687 "{ B[x] -> A[1] : x <= 0; B[x] -> C[2] : x > 0 }" },
5688 { &isl_union_pw_multi_aff_union_add, "{ B[x] -> A[1] : x <= 0 }",
5689 "{ B[x] -> A[2] : x >= 0 }",
5690 "{ B[x] -> A[1] : x < 0; B[x] -> A[2] : x > 0; B[0] -> A[3] }" },
5691 {
5692 &isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff,
5693 "{ B[x] -> C[x + 2] }",
5694 "{ D[y] -> B[2y] }",
5695 "{ }" },
5696 {
5697 &isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff,
5698 "{ [A[x] -> B[x + 1]] -> C[x + 2] }",
5699 "{ D[y] -> B[2y] }",
5700 "{ }" },
5701 {
5702 &isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff,
5703 "{ [A[x] -> B[x + 1]] -> C[x + 2]; B[x] -> C[x + 2] }",
5704 "{ D[y] -> A[2y] }",
5705 "{ [D[y] -> B[2y + 1]] -> C[2y + 2] }" },
5706 {
5707 &isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff,
5708 "{ T[A[x] -> B[x + 1]] -> C[x + 2]; B[x] -> C[x + 2] }",
5709 "{ D[y] -> A[2y] }",
5710 "{ T[D[y] -> B[2y + 1]] -> C[2y + 2] }" },
5711};
5712
5713/* Perform some basic tests of binary operations on
5714 * isl_union_pw_multi_aff objects.
5715 */
5716static int test_bin_upma(isl_ctx *ctx)
5717{
5718 int i;
5719 isl_union_pw_multi_aff *upma1, *upma2, *res;
5720 int ok;
5721
5722 for (i = 0; i < ARRAY_SIZE(upma_bin_tests)(sizeof(upma_bin_tests)/sizeof(*upma_bin_tests)); ++i) {
5723 upma1 = isl_union_pw_multi_aff_read_from_str(ctx,
5724 upma_bin_tests[i].arg1);
5725 upma2 = isl_union_pw_multi_aff_read_from_str(ctx,
5726 upma_bin_tests[i].arg2);
5727 res = isl_union_pw_multi_aff_read_from_str(ctx,
5728 upma_bin_tests[i].res);
5729 upma1 = upma_bin_tests[i].fn(upma1, upma2);
5730 ok = isl_union_pw_multi_aff_plain_is_equal(upma1, res);
5731 isl_union_pw_multi_aff_free(upma1);
5732 isl_union_pw_multi_aff_free(res);
5733 if (ok < 0)
5734 return -1;
5735 if (!ok)
5736 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 5737); return -1; } while
(0)
5737 "unexpected result", return -1)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 5737); return -1; } while
(0)
;
5738 }
5739
5740 return 0;
5741}
5742
5743struct {
5744 __isl_give isl_union_pw_multi_aff *(*fn)(
5745 __isl_take isl_union_pw_multi_aff *upma1,
5746 __isl_take isl_union_pw_multi_aff *upma2);
5747 const char *arg1;
5748 const char *arg2;
5749} upma_bin_fail_tests[] = {
5750 { &isl_union_pw_multi_aff_union_add, "{ B[x] -> A[1] : x <= 0 }",
5751 "{ B[x] -> C[2] : x >= 0 }" },
5752};
5753
5754/* Perform some basic tests of binary operations on
5755 * isl_union_pw_multi_aff objects that are expected to fail.
5756 */
5757static int test_bin_upma_fail(isl_ctx *ctx)
5758{
5759 int i, n;
5760 isl_union_pw_multi_aff *upma1, *upma2;
5761 int on_error;
5762
5763 on_error = isl_options_get_on_error(ctx);
5764 isl_options_set_on_error(ctx, ISL_ON_ERROR_CONTINUE1);
5765 n = ARRAY_SIZE(upma_bin_fail_tests)(sizeof(upma_bin_fail_tests)/sizeof(*upma_bin_fail_tests));
5766 for (i = 0; i < n; ++i) {
5767 upma1 = isl_union_pw_multi_aff_read_from_str(ctx,
5768 upma_bin_fail_tests[i].arg1);
5769 upma2 = isl_union_pw_multi_aff_read_from_str(ctx,
5770 upma_bin_fail_tests[i].arg2);
5771 upma1 = upma_bin_fail_tests[i].fn(upma1, upma2);
5772 isl_union_pw_multi_aff_free(upma1);
5773 if (upma1)
5774 break;
5775 }
5776 isl_options_set_on_error(ctx, on_error);
5777 if (i < n)
5778 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "operation not expected to succeed"
, "polly/lib/External/isl/isl_test.c", 5779); return -1; } while
(0)
5779 "operation not expected to succeed", return -1)do { isl_handle_error(ctx, isl_error_unknown, "operation not expected to succeed"
, "polly/lib/External/isl/isl_test.c", 5779); return -1; } while
(0)
;
5780
5781 return 0;
5782}
5783
5784/* Inputs for basic tests of binary operations on
5785 * pairs of isl_union_pw_multi_aff and isl_union_set objects.
5786 * "fn" is the function that is being tested.
5787 * "arg1" and "arg2" are string descriptions of the inputs.
5788 * "res" is a string description of the expected result.
5789 */
5790struct {
5791 __isl_give isl_union_pw_multi_aff *(*fn)(
5792 __isl_take isl_union_pw_multi_aff *upma,
5793 __isl_take isl_union_set *uset);
5794 const char *arg1;
5795 const char *arg2;
5796 const char *res;
5797} upma_uset_tests[] = {
5798 { &isl_union_pw_multi_aff_intersect_domain_wrapped_range,
5799 "{ A[i] -> B[i] }", "{ B[0] }",
5800 "{ }" },
5801 { &isl_union_pw_multi_aff_intersect_domain_wrapped_domain,
5802 "{ [A[i] -> B[i]] -> C[i + 1] }", "{ A[1]; B[0] }",
5803 "{ [A[1] -> B[1]] -> C[2] }" },
5804 { &isl_union_pw_multi_aff_intersect_domain_wrapped_range,
5805 "{ [A[i] -> B[i]] -> C[i + 1] }", "{ A[1]; B[0] }",
5806 "{ [A[0] -> B[0]] -> C[1] }" },
5807 { &isl_union_pw_multi_aff_intersect_domain_wrapped_range,
5808 "{ [A[i] -> B[i]] -> C[i + 1] }", "[N] -> { B[N] }",
5809 "[N] -> { [A[N] -> B[N]] -> C[N + 1] }" },
5810 { &isl_union_pw_multi_aff_intersect_domain_wrapped_range,
5811 "[M] -> { [A[M] -> B[M]] -> C[M + 1] }", "[N] -> { B[N] }",
5812 "[N, M] -> { [A[N] -> B[N]] -> C[N + 1] : N = M }" },
5813 { &isl_union_pw_multi_aff_intersect_domain_wrapped_range,
5814 "{ [A[] -> B[]] -> C[]; N[A[] -> B[]] -> D[]; [B[] -> A[]] -> E[] }",
5815 "{ B[] }",
5816 "{ [A[] -> B[]] -> C[]; N[A[] -> B[]] -> D[] }" },
5817};
5818
5819/* Perform some basic tests of binary operations on
5820 * pairs of isl_union_pw_multi_aff and isl_union_set objects.
5821 */
5822static isl_stat test_upma_uset(isl_ctx *ctx)
5823{
5824 int i;
5825 isl_bool ok;
5826 isl_union_pw_multi_aff *upma, *res;
5827 isl_union_set *uset;
5828
5829 for (i = 0; i < ARRAY_SIZE(upma_uset_tests)(sizeof(upma_uset_tests)/sizeof(*upma_uset_tests)); ++i) {
5830 upma = isl_union_pw_multi_aff_read_from_str(ctx,
5831 upma_uset_tests[i].arg1);
5832 uset = isl_union_set_read_from_str(ctx,
5833 upma_uset_tests[i].arg2);
5834 res = isl_union_pw_multi_aff_read_from_str(ctx,
5835 upma_uset_tests[i].res);
5836 upma = upma_uset_tests[i].fn(upma, uset);
5837 ok = isl_union_pw_multi_aff_plain_is_equal(upma, res);
5838 isl_union_pw_multi_aff_free(upma);
5839 isl_union_pw_multi_aff_free(res);
5840 if (ok < 0)
5841 return isl_stat_error;
5842 if (!ok)
5843 isl_die(ctx, isl_error_unknown,do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 5844); return isl_stat_error
; } while (0)
5844 "unexpected result", return isl_stat_error)do { isl_handle_error(ctx, isl_error_unknown, "unexpected result"
, "polly/lib/External/isl/isl_test.c", 5844); return isl_stat_error
; } while (0)
;
5845 }
5846
5847 return isl_stat_ok;
5848}
5849
5850/* Inputs for basic tests of unary operations on isl_multi_pw_aff objects.
5851 * "fn" is the function that is tested.
5852 * "arg" is a string description of the input.
5853 * "res" is a string description of the expected result.
5854 */
5855struct {
5856 __isl_give isl_multi_pw_aff *(*fn)(__isl_take isl_multi_pw_aff *mpa);
5857 const char *arg;
5858 const char *res;
5859} mpa_un_tests[] = {
5860 { &isl_multi_pw_aff_range_factor_domain,
5861 "{ A[x] -> [B[(1 : x >= 5)] -> C[(2 : x <= 10)]] }",
5862 "{ A[x] -> B[(1 : x >= 5)] }" },
5863 { &isl_multi_pw_aff_range_factor_range,
5864 "{ A[x] -> [B[(1 : x >= 5)] -> C[(2 : x <= 10)]] }",
5865 "{ A[y] -> C[(2 : y <= 10)] }" },
5866 { &isl_multi_pw_aff_range_factor_domain,
5867 "{ A[x] -> [B[(1 : x >= 5)] -> C[]] }",
5868 "{ A[x] -> B[(1 : x >= 5)] }" },
5869 { &isl_multi_pw_aff_range_factor_range,
5870 "{ A[x] -> [B[(1 : x >= 5)] -> C[]] }",
5871 "{ A[y] -> C[] }" },
5872 { &isl_multi_pw_aff_range_factor_domain,
5873 "{ A[x] -> [B[] -> C[(2 : x <= 10)]] }",
5874 "{ A[x] -> B[] }" },
5875 { &isl_multi_pw_aff_range_factor_range,
5876 "{ A[x] -> [B[] -> C[(2 : x <= 10)]] }",
5877 "{ A[y] -> C[(2 : y <= 10)] }" },
5878 { &isl_multi_pw_aff_range_factor_domain,
5879 "{ A[x] -> [B[] -> C[]] }",
5880 "{ A[x] -> B[] }" },
5881 { &isl_multi_pw_aff_range_factor_range,
5882 "{ A[x] -> [B[] -> C[]] }",