Bug Summary

File:tools/polly/lib/External/isl/isl_map.c
Warning:line 3726, column 32
Access to field 'n_div' results in a dereference of a null pointer

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name isl_map.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -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 -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/polly/lib/External -I /build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External -I /build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/pet/include -I /build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/ppcg/include -I /build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/ppcg/imath -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/polly/lib/External/ppcg -I /build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl -I /build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/include -I /build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/imath -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/polly/lib/External/isl -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/polly/include -I /usr/include/jsoncpp -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/polly/lib/External/isl/include -I /build/llvm-toolchain-snapshot-7~svn329677/tools/polly/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn329677/include -U NDEBUG -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=gnu99 -fconst-strings -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/polly/lib/External -fdebug-prefix-map=/build/llvm-toolchain-snapshot-7~svn329677=. -ferror-limit 19 -fmessage-length 0 -stack-protector 2 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-04-11-031539-24776-1 -x c /build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c
1/*
2 * Copyright 2008-2009 Katholieke Universiteit Leuven
3 * Copyright 2010 INRIA Saclay
4 * Copyright 2012-2014 Ecole Normale Superieure
5 * Copyright 2014 INRIA Rocquencourt
6 * Copyright 2016 INRIA Paris
7 * Copyright 2016 Sven Verdoolaege
8 *
9 * Use of this software is governed by the MIT license
10 *
11 * Written by Sven Verdoolaege, K.U.Leuven, Departement
12 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
13 * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
14 * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France
15 * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
16 * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
17 * B.P. 105 - 78153 Le Chesnay, France
18 * and Centre de Recherche Inria de Paris, 2 rue Simone Iff - Voie DQ12,
19 * CS 42112, 75589 Paris Cedex 12, France
20 */
21
22#include <string.h>
23#include <isl_ctx_private.h>
24#include <isl_map_private.h>
25#include <isl_blk.h>
26#include <isl/constraint.h>
27#include "isl_space_private.h"
28#include "isl_equalities.h"
29#include <isl_lp_private.h>
30#include <isl_seq.h>
31#include <isl/set.h>
32#include <isl/map.h>
33#include <isl_reordering.h>
34#include "isl_sample.h"
35#include <isl_sort.h>
36#include "isl_tab.h"
37#include <isl/vec.h>
38#include <isl_mat_private.h>
39#include <isl_vec_private.h>
40#include <isl_dim_map.h>
41#include <isl_local_space_private.h>
42#include <isl_aff_private.h>
43#include <isl_options_private.h>
44#include <isl_morph.h>
45#include <isl_val_private.h>
46
47#include <bset_to_bmap.c>
48#include <bset_from_bmap.c>
49#include <set_to_map.c>
50#include <set_from_map.c>
51
52static unsigned n(__isl_keep isl_space *dim, enum isl_dim_type type)
53{
54 switch (type) {
55 case isl_dim_param: return dim->nparam;
56 case isl_dim_in: return dim->n_in;
57 case isl_dim_out: return dim->n_out;
58 case isl_dim_all: return dim->nparam + dim->n_in + dim->n_out;
59 default: return 0;
60 }
61}
62
63static unsigned pos(__isl_keep isl_space *dim, enum isl_dim_type type)
64{
65 switch (type) {
66 case isl_dim_param: return 1;
67 case isl_dim_in: return 1 + dim->nparam;
68 case isl_dim_out: return 1 + dim->nparam + dim->n_in;
69 default: return 0;
70 }
71}
72
73unsigned isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
74 enum isl_dim_type type)
75{
76 if (!bmap)
77 return 0;
78 switch (type) {
79 case isl_dim_cst: return 1;
80 case isl_dim_param:
81 case isl_dim_in:
82 case isl_dim_out: return isl_space_dim(bmap->dim, type);
83 case isl_dim_div: return bmap->n_div;
84 case isl_dim_all: return isl_basic_map_total_dim(bmap);
85 default: return 0;
86 }
87}
88
89/* Return the space of "map".
90 */
91__isl_keep isl_space *isl_map_peek_space(__isl_keep const isl_map *map)
92{
93 return map ? map->dim : NULL((void*)0);
94}
95
96unsigned isl_map_dim(__isl_keep isl_map *map, enum isl_dim_type type)
97{
98 return map ? n(map->dim, type) : 0;
99}
100
101unsigned isl_set_dim(__isl_keep isl_setisl_map *set, enum isl_dim_type type)
102{
103 return set ? n(set->dim, type) : 0;
104}
105
106unsigned isl_basic_map_offset(struct isl_basic_map *bmap,
107 enum isl_dim_type type)
108{
109 isl_space *space;
110
111 if (!bmap)
112 return 0;
113
114 space = bmap->dim;
115 switch (type) {
116 case isl_dim_cst: return 0;
117 case isl_dim_param: return 1;
118 case isl_dim_in: return 1 + space->nparam;
119 case isl_dim_out: return 1 + space->nparam + space->n_in;
120 case isl_dim_div: return 1 + space->nparam + space->n_in +
121 space->n_out;
122 default: return 0;
123 }
124}
125
126unsigned isl_basic_set_offset(__isl_keep isl_basic_setisl_basic_map *bset,
127 enum isl_dim_type type)
128{
129 return isl_basic_map_offset(bset, type);
130}
131
132static unsigned map_offset(__isl_keep isl_map *map, enum isl_dim_type type)
133{
134 return pos(map->dim, type);
135}
136
137unsigned isl_basic_set_dim(__isl_keep isl_basic_setisl_basic_map *bset,
138 enum isl_dim_type type)
139{
140 return isl_basic_map_dim(bset, type);
141}
142
143unsigned isl_basic_set_n_dim(__isl_keep isl_basic_setisl_basic_map *bset)
144{
145 return isl_basic_set_dim(bset, isl_dim_set);
146}
147
148unsigned isl_basic_set_n_param(__isl_keep isl_basic_setisl_basic_map *bset)
149{
150 return isl_basic_set_dim(bset, isl_dim_param);
151}
152
153unsigned isl_basic_set_total_dim(__isl_keep const isl_basic_setisl_basic_map *bset)
154{
155 if (!bset)
156 return 0;
157 return isl_space_dim(bset->dim, isl_dim_all) + bset->n_div;
158}
159
160unsigned isl_set_n_dim(__isl_keep isl_setisl_map *set)
161{
162 return isl_set_dim(set, isl_dim_set);
163}
164
165unsigned isl_set_n_param(__isl_keep isl_setisl_map *set)
166{
167 return isl_set_dim(set, isl_dim_param);
168}
169
170unsigned isl_basic_map_n_in(__isl_keep const isl_basic_map *bmap)
171{
172 return bmap ? bmap->dim->n_in : 0;
173}
174
175unsigned isl_basic_map_n_out(__isl_keep const isl_basic_map *bmap)
176{
177 return bmap ? bmap->dim->n_out : 0;
178}
179
180unsigned isl_basic_map_n_param(__isl_keep const isl_basic_map *bmap)
181{
182 return bmap ? bmap->dim->nparam : 0;
183}
184
185unsigned isl_basic_map_n_div(__isl_keep const isl_basic_map *bmap)
186{
187 return bmap ? bmap->n_div : 0;
188}
189
190unsigned isl_basic_map_total_dim(__isl_keep const isl_basic_map *bmap)
191{
192 return bmap ? isl_space_dim(bmap->dim, isl_dim_all) + bmap->n_div : 0;
193}
194
195unsigned isl_map_n_in(__isl_keep const isl_map *map)
196{
197 return map ? map->dim->n_in : 0;
198}
199
200unsigned isl_map_n_out(__isl_keep const isl_map *map)
201{
202 return map ? map->dim->n_out : 0;
203}
204
205unsigned isl_map_n_param(__isl_keep const isl_map *map)
206{
207 return map ? map->dim->nparam : 0;
208}
209
210/* Return the number of equality constraints in the description of "bmap".
211 * Return -1 on error.
212 */
213int isl_basic_map_n_equality(__isl_keep isl_basic_map *bmap)
214{
215 if (!bmap)
216 return -1;
217 return bmap->n_eq;
218}
219
220/* Return the number of equality constraints in the description of "bset".
221 * Return -1 on error.
222 */
223int isl_basic_set_n_equality(__isl_keep isl_basic_setisl_basic_map *bset)
224{
225 return isl_basic_map_n_equality(bset_to_bmap(bset));
226}
227
228/* Return the number of inequality constraints in the description of "bmap".
229 * Return -1 on error.
230 */
231int isl_basic_map_n_inequality(__isl_keep isl_basic_map *bmap)
232{
233 if (!bmap)
234 return -1;
235 return bmap->n_ineq;
236}
237
238/* Return the number of inequality constraints in the description of "bset".
239 * Return -1 on error.
240 */
241int isl_basic_set_n_inequality(__isl_keep isl_basic_setisl_basic_map *bset)
242{
243 return isl_basic_map_n_inequality(bset_to_bmap(bset));
244}
245
246/* Do "bmap1" and "bmap2" have the same parameters?
247 */
248static isl_bool isl_basic_map_has_equal_params(__isl_keep isl_basic_map *bmap1,
249 __isl_keep isl_basic_map *bmap2)
250{
251 isl_space *space1, *space2;
252
253 space1 = isl_basic_map_peek_space(bmap1);
254 space2 = isl_basic_map_peek_space(bmap2);
255 return isl_space_has_equal_params(space1, space2);
256}
257
258/* Do "map1" and "map2" have the same parameters?
259 */
260isl_bool isl_map_has_equal_params(__isl_keep isl_map *map1,
261 __isl_keep isl_map *map2)
262{
263 isl_space *space1, *space2;
264
265 space1 = isl_map_peek_space(map1);
266 space2 = isl_map_peek_space(map2);
267 return isl_space_has_equal_params(space1, space2);
268}
269
270/* Do "map" and "set" have the same parameters?
271 */
272static isl_bool isl_map_set_has_equal_params(__isl_keep isl_map *map,
273 __isl_keep isl_setisl_map *set)
274{
275 return isl_map_has_equal_params(map, set_to_map(set));
276}
277
278isl_bool isl_map_compatible_domain(__isl_keep isl_map *map,
279 __isl_keep isl_setisl_map *set)
280{
281 isl_bool m;
282 if (!map || !set)
283 return isl_bool_error;
284 m = isl_map_has_equal_params(map, set_to_map(set));
285 if (m < 0 || !m)
286 return m;
287 return isl_space_tuple_is_equal(map->dim, isl_dim_in,
288 set->dim, isl_dim_set);
289}
290
291isl_bool isl_basic_map_compatible_domain(__isl_keep isl_basic_map *bmap,
292 __isl_keep isl_basic_setisl_basic_map *bset)
293{
294 isl_bool m;
295 if (!bmap || !bset)
296 return isl_bool_error;
297 m = isl_basic_map_has_equal_params(bmap, bset_to_bmap(bset));
298 if (m < 0 || !m)
299 return m;
300 return isl_space_tuple_is_equal(bmap->dim, isl_dim_in,
301 bset->dim, isl_dim_set);
302}
303
304isl_bool isl_map_compatible_range(__isl_keep isl_map *map,
305 __isl_keep isl_setisl_map *set)
306{
307 isl_bool m;
308 if (!map || !set)
309 return isl_bool_error;
310 m = isl_map_has_equal_params(map, set_to_map(set));
311 if (m < 0 || !m)
312 return m;
313 return isl_space_tuple_is_equal(map->dim, isl_dim_out,
314 set->dim, isl_dim_set);
315}
316
317isl_bool isl_basic_map_compatible_range(__isl_keep isl_basic_map *bmap,
318 __isl_keep isl_basic_setisl_basic_map *bset)
319{
320 isl_bool m;
321 if (!bmap || !bset)
322 return isl_bool_error;
323 m = isl_basic_map_has_equal_params(bmap, bset_to_bmap(bset));
324 if (m < 0 || !m)
325 return m;
326 return isl_space_tuple_is_equal(bmap->dim, isl_dim_out,
327 bset->dim, isl_dim_set);
328}
329
330isl_ctx *isl_basic_map_get_ctx(__isl_keep isl_basic_map *bmap)
331{
332 return bmap ? bmap->ctx : NULL((void*)0);
333}
334
335isl_ctx *isl_basic_set_get_ctx(__isl_keep isl_basic_setisl_basic_map *bset)
336{
337 return bset ? bset->ctx : NULL((void*)0);
338}
339
340isl_ctx *isl_map_get_ctx(__isl_keep isl_map *map)
341{
342 return map ? map->ctx : NULL((void*)0);
343}
344
345isl_ctx *isl_set_get_ctx(__isl_keep isl_setisl_map *set)
346{
347 return set ? set->ctx : NULL((void*)0);
348}
349
350/* Return the space of "bmap".
351 */
352__isl_keep isl_space *isl_basic_map_peek_space(
353 __isl_keep const isl_basic_map *bmap)
354{
355 return bmap ? bmap->dim : NULL((void*)0);
356}
357
358/* Return the space of "bset".
359 */
360__isl_keep isl_space *isl_basic_set_peek_space(__isl_keep isl_basic_setisl_basic_map *bset)
361{
362 return isl_basic_map_peek_space(bset_to_bmap(bset));
363}
364
365__isl_give isl_space *isl_basic_map_get_space(__isl_keep isl_basic_map *bmap)
366{
367 return isl_space_copy(isl_basic_map_peek_space(bmap));
368}
369
370__isl_give isl_space *isl_basic_set_get_space(__isl_keep isl_basic_setisl_basic_map *bset)
371{
372 return isl_basic_map_get_space(bset_to_bmap(bset));
373}
374
375/* Extract the divs in "bmap" as a matrix.
376 */
377__isl_give isl_mat *isl_basic_map_get_divs(__isl_keep isl_basic_map *bmap)
378{
379 int i;
380 isl_ctx *ctx;
381 isl_mat *div;
382 unsigned total;
383 unsigned cols;
384
385 if (!bmap)
386 return NULL((void*)0);
387
388 ctx = isl_basic_map_get_ctx(bmap);
389 total = isl_space_dim(bmap->dim, isl_dim_all);
390 cols = 1 + 1 + total + bmap->n_div;
391 div = isl_mat_alloc(ctx, bmap->n_div, cols);
392 if (!div)
393 return NULL((void*)0);
394
395 for (i = 0; i < bmap->n_div; ++i)
396 isl_seq_cpy(div->row[i], bmap->div[i], cols);
397
398 return div;
399}
400
401/* Extract the divs in "bset" as a matrix.
402 */
403__isl_give isl_mat *isl_basic_set_get_divs(__isl_keep isl_basic_setisl_basic_map *bset)
404{
405 return isl_basic_map_get_divs(bset);
406}
407
408__isl_give isl_local_space *isl_basic_map_get_local_space(
409 __isl_keep isl_basic_map *bmap)
410{
411 isl_mat *div;
412
413 if (!bmap)
414 return NULL((void*)0);
415
416 div = isl_basic_map_get_divs(bmap);
417 return isl_local_space_alloc_div(isl_space_copy(bmap->dim), div);
418}
419
420__isl_give isl_local_space *isl_basic_set_get_local_space(
421 __isl_keep isl_basic_setisl_basic_map *bset)
422{
423 return isl_basic_map_get_local_space(bset);
424}
425
426/* For each known div d = floor(f/m), add the constraints
427 *
428 * f - m d >= 0
429 * -(f-(m-1)) + m d >= 0
430 *
431 * Do not finalize the result.
432 */
433static __isl_give isl_basic_map *add_known_div_constraints(
434 __isl_take isl_basic_map *bmap)
435{
436 int i;
437 unsigned n_div;
438
439 if (!bmap)
440 return NULL((void*)0);
441 n_div = isl_basic_map_dim(bmap, isl_dim_div);
442 if (n_div == 0)
443 return bmap;
444 bmap = isl_basic_map_cow(bmap);
445 bmap = isl_basic_map_extend_constraints(bmap, 0, 2 * n_div);
446 if (!bmap)
447 return NULL((void*)0);
448 for (i = 0; i < n_div; ++i) {
449 if (isl_int_is_zero(bmap->div[i][0])(isl_sioimath_sgn(*(bmap->div[i][0])) == 0))
450 continue;
451 if (isl_basic_map_add_div_constraints(bmap, i) < 0)
452 return isl_basic_map_free(bmap);
453 }
454
455 return bmap;
456}
457
458__isl_give isl_basic_map *isl_basic_map_from_local_space(
459 __isl_take isl_local_space *ls)
460{
461 int i;
462 int n_div;
463 isl_basic_map *bmap;
464
465 if (!ls)
466 return NULL((void*)0);
467
468 n_div = isl_local_space_dim(ls, isl_dim_div);
469 bmap = isl_basic_map_alloc_space(isl_local_space_get_space(ls),
470 n_div, 0, 2 * n_div);
471
472 for (i = 0; i < n_div; ++i)
473 if (isl_basic_map_alloc_div(bmap) < 0)
474 goto error;
475
476 for (i = 0; i < n_div; ++i)
477 isl_seq_cpy(bmap->div[i], ls->div->row[i], ls->div->n_col);
478 bmap = add_known_div_constraints(bmap);
479
480 isl_local_space_free(ls);
481 return bmap;
482error:
483 isl_local_space_free(ls);
484 isl_basic_map_free(bmap);
485 return NULL((void*)0);
486}
487
488__isl_give isl_basic_setisl_basic_map *isl_basic_set_from_local_space(
489 __isl_take isl_local_space *ls)
490{
491 return isl_basic_map_from_local_space(ls);
492}
493
494__isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map)
495{
496 return isl_space_copy(isl_map_peek_space(map));
497}
498
499__isl_give isl_space *isl_set_get_space(__isl_keep isl_setisl_map *set)
500{
501 if (!set)
502 return NULL((void*)0);
503 return isl_space_copy(set->dim);
504}
505
506__isl_give isl_basic_map *isl_basic_map_set_tuple_name(
507 __isl_take isl_basic_map *bmap, enum isl_dim_type type, const char *s)
508{
509 bmap = isl_basic_map_cow(bmap);
510 if (!bmap)
511 return NULL((void*)0);
512 bmap->dim = isl_space_set_tuple_name(bmap->dim, type, s);
513 if (!bmap->dim)
514 goto error;
515 bmap = isl_basic_map_finalize(bmap);
516 return bmap;
517error:
518 isl_basic_map_free(bmap);
519 return NULL((void*)0);
520}
521
522__isl_give isl_basic_setisl_basic_map *isl_basic_set_set_tuple_name(
523 __isl_take isl_basic_setisl_basic_map *bset, const char *s)
524{
525 return isl_basic_map_set_tuple_name(bset, isl_dim_set, s);
526}
527
528const char *isl_basic_map_get_tuple_name(__isl_keep isl_basic_map *bmap,
529 enum isl_dim_type type)
530{
531 return bmap ? isl_space_get_tuple_name(bmap->dim, type) : NULL((void*)0);
532}
533
534__isl_give isl_map *isl_map_set_tuple_name(__isl_take isl_map *map,
535 enum isl_dim_type type, const char *s)
536{
537 int i;
538
539 map = isl_map_cow(map);
540 if (!map)
541 return NULL((void*)0);
542
543 map->dim = isl_space_set_tuple_name(map->dim, type, s);
544 if (!map->dim)
545 goto error;
546
547 for (i = 0; i < map->n; ++i) {
548 map->p[i] = isl_basic_map_set_tuple_name(map->p[i], type, s);
549 if (!map->p[i])
550 goto error;
551 }
552
553 return map;
554error:
555 isl_map_free(map);
556 return NULL((void*)0);
557}
558
559/* Replace the identifier of the tuple of type "type" by "id".
560 */
561__isl_give isl_basic_map *isl_basic_map_set_tuple_id(
562 __isl_take isl_basic_map *bmap,
563 enum isl_dim_type type, __isl_take isl_id *id)
564{
565 bmap = isl_basic_map_cow(bmap);
566 if (!bmap)
567 goto error;
568 bmap->dim = isl_space_set_tuple_id(bmap->dim, type, id);
569 if (!bmap->dim)
570 return isl_basic_map_free(bmap);
571 bmap = isl_basic_map_finalize(bmap);
572 return bmap;
573error:
574 isl_id_free(id);
575 return NULL((void*)0);
576}
577
578/* Replace the identifier of the tuple by "id".
579 */
580__isl_give isl_basic_setisl_basic_map *isl_basic_set_set_tuple_id(
581 __isl_take isl_basic_setisl_basic_map *bset, __isl_take isl_id *id)
582{
583 return isl_basic_map_set_tuple_id(bset, isl_dim_set, id);
584}
585
586/* Does the input or output tuple have a name?
587 */
588isl_bool isl_map_has_tuple_name(__isl_keep isl_map *map, enum isl_dim_type type)
589{
590 return map ? isl_space_has_tuple_name(map->dim, type) : isl_bool_error;
591}
592
593const char *isl_map_get_tuple_name(__isl_keep isl_map *map,
594 enum isl_dim_type type)
595{
596 return map ? isl_space_get_tuple_name(map->dim, type) : NULL((void*)0);
597}
598
599__isl_give isl_setisl_map *isl_set_set_tuple_name(__isl_take isl_setisl_map *set,
600 const char *s)
601{
602 return set_from_map(isl_map_set_tuple_name(set_to_map(set),
603 isl_dim_set, s));
604}
605
606__isl_give isl_map *isl_map_set_tuple_id(__isl_take isl_map *map,
607 enum isl_dim_type type, __isl_take isl_id *id)
608{
609 map = isl_map_cow(map);
610 if (!map)
611 goto error;
612
613 map->dim = isl_space_set_tuple_id(map->dim, type, id);
614
615 return isl_map_reset_space(map, isl_space_copy(map->dim));
616error:
617 isl_id_free(id);
618 return NULL((void*)0);
619}
620
621__isl_give isl_setisl_map *isl_set_set_tuple_id(__isl_take isl_setisl_map *set,
622 __isl_take isl_id *id)
623{
624 return isl_map_set_tuple_id(set, isl_dim_set, id);
625}
626
627__isl_give isl_map *isl_map_reset_tuple_id(__isl_take isl_map *map,
628 enum isl_dim_type type)
629{
630 map = isl_map_cow(map);
631 if (!map)
632 return NULL((void*)0);
633
634 map->dim = isl_space_reset_tuple_id(map->dim, type);
635
636 return isl_map_reset_space(map, isl_space_copy(map->dim));
637}
638
639__isl_give isl_setisl_map *isl_set_reset_tuple_id(__isl_take isl_setisl_map *set)
640{
641 return isl_map_reset_tuple_id(set, isl_dim_set);
642}
643
644isl_bool isl_map_has_tuple_id(__isl_keep isl_map *map, enum isl_dim_type type)
645{
646 return map ? isl_space_has_tuple_id(map->dim, type) : isl_bool_error;
647}
648
649__isl_give isl_id *isl_map_get_tuple_id(__isl_keep isl_map *map,
650 enum isl_dim_type type)
651{
652 return map ? isl_space_get_tuple_id(map->dim, type) : NULL((void*)0);
653}
654
655isl_bool isl_set_has_tuple_id(__isl_keep isl_setisl_map *set)
656{
657 return isl_map_has_tuple_id(set, isl_dim_set);
658}
659
660__isl_give isl_id *isl_set_get_tuple_id(__isl_keep isl_setisl_map *set)
661{
662 return isl_map_get_tuple_id(set, isl_dim_set);
663}
664
665/* Does the set tuple have a name?
666 */
667isl_bool isl_set_has_tuple_name(__isl_keep isl_setisl_map *set)
668{
669 if (!set)
670 return isl_bool_error;
671 return isl_space_has_tuple_name(set->dim, isl_dim_set);
672}
673
674
675const char *isl_basic_set_get_tuple_name(__isl_keep isl_basic_setisl_basic_map *bset)
676{
677 return bset ? isl_space_get_tuple_name(bset->dim, isl_dim_set) : NULL((void*)0);
678}
679
680const char *isl_set_get_tuple_name(__isl_keep isl_setisl_map *set)
681{
682 return set ? isl_space_get_tuple_name(set->dim, isl_dim_set) : NULL((void*)0);
683}
684
685const char *isl_basic_map_get_dim_name(__isl_keep isl_basic_map *bmap,
686 enum isl_dim_type type, unsigned pos)
687{
688 return bmap ? isl_space_get_dim_name(bmap->dim, type, pos) : NULL((void*)0);
689}
690
691const char *isl_basic_set_get_dim_name(__isl_keep isl_basic_setisl_basic_map *bset,
692 enum isl_dim_type type, unsigned pos)
693{
694 return bset ? isl_space_get_dim_name(bset->dim, type, pos) : NULL((void*)0);
695}
696
697/* Does the given dimension have a name?
698 */
699isl_bool isl_map_has_dim_name(__isl_keep isl_map *map,
700 enum isl_dim_type type, unsigned pos)
701{
702 if (!map)
703 return isl_bool_error;
704 return isl_space_has_dim_name(map->dim, type, pos);
705}
706
707const char *isl_map_get_dim_name(__isl_keep isl_map *map,
708 enum isl_dim_type type, unsigned pos)
709{
710 return map ? isl_space_get_dim_name(map->dim, type, pos) : NULL((void*)0);
711}
712
713const char *isl_set_get_dim_name(__isl_keep isl_setisl_map *set,
714 enum isl_dim_type type, unsigned pos)
715{
716 return set ? isl_space_get_dim_name(set->dim, type, pos) : NULL((void*)0);
717}
718
719/* Does the given dimension have a name?
720 */
721isl_bool isl_set_has_dim_name(__isl_keep isl_setisl_map *set,
722 enum isl_dim_type type, unsigned pos)
723{
724 if (!set)
725 return isl_bool_error;
726 return isl_space_has_dim_name(set->dim, type, pos);
727}
728
729__isl_give isl_basic_map *isl_basic_map_set_dim_name(
730 __isl_take isl_basic_map *bmap,
731 enum isl_dim_type type, unsigned pos, const char *s)
732{
733 bmap = isl_basic_map_cow(bmap);
734 if (!bmap)
735 return NULL((void*)0);
736 bmap->dim = isl_space_set_dim_name(bmap->dim, type, pos, s);
737 if (!bmap->dim)
738 goto error;
739 return isl_basic_map_finalize(bmap);
740error:
741 isl_basic_map_free(bmap);
742 return NULL((void*)0);
743}
744
745__isl_give isl_map *isl_map_set_dim_name(__isl_take isl_map *map,
746 enum isl_dim_type type, unsigned pos, const char *s)
747{
748 int i;
749
750 map = isl_map_cow(map);
751 if (!map)
752 return NULL((void*)0);
753
754 map->dim = isl_space_set_dim_name(map->dim, type, pos, s);
755 if (!map->dim)
756 goto error;
757
758 for (i = 0; i < map->n; ++i) {
759 map->p[i] = isl_basic_map_set_dim_name(map->p[i], type, pos, s);
760 if (!map->p[i])
761 goto error;
762 }
763
764 return map;
765error:
766 isl_map_free(map);
767 return NULL((void*)0);
768}
769
770__isl_give isl_basic_setisl_basic_map *isl_basic_set_set_dim_name(
771 __isl_take isl_basic_setisl_basic_map *bset,
772 enum isl_dim_type type, unsigned pos, const char *s)
773{
774 return bset_from_bmap(isl_basic_map_set_dim_name(bset_to_bmap(bset),
775 type, pos, s));
776}
777
778__isl_give isl_setisl_map *isl_set_set_dim_name(__isl_take isl_setisl_map *set,
779 enum isl_dim_type type, unsigned pos, const char *s)
780{
781 return set_from_map(isl_map_set_dim_name(set_to_map(set),
782 type, pos, s));
783}
784
785isl_bool isl_basic_map_has_dim_id(__isl_keep isl_basic_map *bmap,
786 enum isl_dim_type type, unsigned pos)
787{
788 if (!bmap)
789 return isl_bool_error;
790 return isl_space_has_dim_id(bmap->dim, type, pos);
791}
792
793__isl_give isl_id *isl_basic_set_get_dim_id(__isl_keep isl_basic_setisl_basic_map *bset,
794 enum isl_dim_type type, unsigned pos)
795{
796 return bset ? isl_space_get_dim_id(bset->dim, type, pos) : NULL((void*)0);
797}
798
799isl_bool isl_map_has_dim_id(__isl_keep isl_map *map,
800 enum isl_dim_type type, unsigned pos)
801{
802 return map ? isl_space_has_dim_id(map->dim, type, pos) : isl_bool_error;
803}
804
805__isl_give isl_id *isl_map_get_dim_id(__isl_keep isl_map *map,
806 enum isl_dim_type type, unsigned pos)
807{
808 return map ? isl_space_get_dim_id(map->dim, type, pos) : NULL((void*)0);
809}
810
811isl_bool isl_set_has_dim_id(__isl_keep isl_setisl_map *set,
812 enum isl_dim_type type, unsigned pos)
813{
814 return isl_map_has_dim_id(set, type, pos);
815}
816
817__isl_give isl_id *isl_set_get_dim_id(__isl_keep isl_setisl_map *set,
818 enum isl_dim_type type, unsigned pos)
819{
820 return isl_map_get_dim_id(set, type, pos);
821}
822
823__isl_give isl_map *isl_map_set_dim_id(__isl_take isl_map *map,
824 enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
825{
826 map = isl_map_cow(map);
827 if (!map)
828 goto error;
829
830 map->dim = isl_space_set_dim_id(map->dim, type, pos, id);
831
832 return isl_map_reset_space(map, isl_space_copy(map->dim));
833error:
834 isl_id_free(id);
835 return NULL((void*)0);
836}
837
838__isl_give isl_setisl_map *isl_set_set_dim_id(__isl_take isl_setisl_map *set,
839 enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
840{
841 return isl_map_set_dim_id(set, type, pos, id);
842}
843
844int isl_map_find_dim_by_id(__isl_keep isl_map *map, enum isl_dim_type type,
845 __isl_keep isl_id *id)
846{
847 if (!map)
848 return -1;
849 return isl_space_find_dim_by_id(map->dim, type, id);
850}
851
852int isl_set_find_dim_by_id(__isl_keep isl_setisl_map *set, enum isl_dim_type type,
853 __isl_keep isl_id *id)
854{
855 return isl_map_find_dim_by_id(set, type, id);
856}
857
858/* Return the position of the dimension of the given type and name
859 * in "bmap".
860 * Return -1 if no such dimension can be found.
861 */
862int isl_basic_map_find_dim_by_name(__isl_keep isl_basic_map *bmap,
863 enum isl_dim_type type, const char *name)
864{
865 if (!bmap)
866 return -1;
867 return isl_space_find_dim_by_name(bmap->dim, type, name);
868}
869
870int isl_map_find_dim_by_name(__isl_keep isl_map *map, enum isl_dim_type type,
871 const char *name)
872{
873 if (!map)
874 return -1;
875 return isl_space_find_dim_by_name(map->dim, type, name);
876}
877
878int isl_set_find_dim_by_name(__isl_keep isl_setisl_map *set, enum isl_dim_type type,
879 const char *name)
880{
881 return isl_map_find_dim_by_name(set, type, name);
882}
883
884/* Check whether equality i of bset is a pure stride constraint
885 * on a single dimension, i.e., of the form
886 *
887 * v = k e
888 *
889 * with k a constant and e an existentially quantified variable.
890 */
891isl_bool isl_basic_set_eq_is_stride(__isl_keep isl_basic_setisl_basic_map *bset, int i)
892{
893 unsigned nparam;
894 unsigned d;
895 unsigned n_div;
896 int pos1;
897 int pos2;
898
899 if (!bset)
900 return isl_bool_error;
901
902 if (!isl_int_is_zero(bset->eq[i][0])(isl_sioimath_sgn(*(bset->eq[i][0])) == 0))
903 return isl_bool_false;
904
905 nparam = isl_basic_set_dim(bset, isl_dim_param);
906 d = isl_basic_set_dim(bset, isl_dim_set);
907 n_div = isl_basic_set_dim(bset, isl_dim_div);
908
909 if (isl_seq_first_non_zero(bset->eq[i] + 1, nparam) != -1)
910 return isl_bool_false;
911 pos1 = isl_seq_first_non_zero(bset->eq[i] + 1 + nparam, d);
912 if (pos1 == -1)
913 return isl_bool_false;
914 if (isl_seq_first_non_zero(bset->eq[i] + 1 + nparam + pos1 + 1,
915 d - pos1 - 1) != -1)
916 return isl_bool_false;
917
918 pos2 = isl_seq_first_non_zero(bset->eq[i] + 1 + nparam + d, n_div);
919 if (pos2 == -1)
920 return isl_bool_false;
921 if (isl_seq_first_non_zero(bset->eq[i] + 1 + nparam + d + pos2 + 1,
922 n_div - pos2 - 1) != -1)
923 return isl_bool_false;
924 if (!isl_int_is_one(bset->eq[i][1 + nparam + pos1])(isl_sioimath_cmp_si(*(bset->eq[i][1 + nparam + pos1]), 1)
== 0)
&&
925 !isl_int_is_negone(bset->eq[i][1 + nparam + pos1])(isl_sioimath_cmp_si(*(bset->eq[i][1 + nparam + pos1]), -1
) == 0)
)
926 return isl_bool_false;
927
928 return isl_bool_true;
929}
930
931/* Reset the user pointer on all identifiers of parameters and tuples
932 * of the space of "map".
933 */
934__isl_give isl_map *isl_map_reset_user(__isl_take isl_map *map)
935{
936 isl_space *space;
937
938 space = isl_map_get_space(map);
939 space = isl_space_reset_user(space);
940 map = isl_map_reset_space(map, space);
941
942 return map;
943}
944
945/* Reset the user pointer on all identifiers of parameters and tuples
946 * of the space of "set".
947 */
948__isl_give isl_setisl_map *isl_set_reset_user(__isl_take isl_setisl_map *set)
949{
950 return isl_map_reset_user(set);
951}
952
953isl_bool isl_basic_map_is_rational(__isl_keep isl_basic_map *bmap)
954{
955 if (!bmap)
956 return isl_bool_error;
957 return ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)(!!(((bmap)->flags) & ((1 << 4))));
958}
959
960/* Has "map" been marked as a rational map?
961 * In particular, have all basic maps in "map" been marked this way?
962 * An empty map is not considered to be rational.
963 * Maps where only some of the basic maps are marked rational
964 * are not allowed.
965 */
966isl_bool isl_map_is_rational(__isl_keep isl_map *map)
967{
968 int i;
969 isl_bool rational;
970
971 if (!map)
972 return isl_bool_error;
973 if (map->n == 0)
974 return isl_bool_false;
975 rational = isl_basic_map_is_rational(map->p[0]);
976 if (rational < 0)
977 return rational;
978 for (i = 1; i < map->n; ++i) {
979 isl_bool rational_i;
980
981 rational_i = isl_basic_map_is_rational(map->p[i]);
982 if (rational_i < 0)
983 return rational_i;
984 if (rational != rational_i)
985 isl_die(isl_map_get_ctx(map), isl_error_unsupported,do { isl_handle_error(isl_map_get_ctx(map), isl_error_unsupported
, "mixed rational and integer basic maps " "not supported", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 987); return isl_bool_error; } while (0)
986 "mixed rational and integer basic maps "do { isl_handle_error(isl_map_get_ctx(map), isl_error_unsupported
, "mixed rational and integer basic maps " "not supported", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 987); return isl_bool_error; } while (0)
987 "not supported", return isl_bool_error)do { isl_handle_error(isl_map_get_ctx(map), isl_error_unsupported
, "mixed rational and integer basic maps " "not supported", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 987); return isl_bool_error; } while (0)
;
988 }
989
990 return rational;
991}
992
993/* Has "set" been marked as a rational set?
994 * In particular, have all basic set in "set" been marked this way?
995 * An empty set is not considered to be rational.
996 * Sets where only some of the basic sets are marked rational
997 * are not allowed.
998 */
999isl_bool isl_set_is_rational(__isl_keep isl_setisl_map *set)
1000{
1001 return isl_map_is_rational(set);
1002}
1003
1004int isl_basic_set_is_rational(__isl_keep isl_basic_setisl_basic_map *bset)
1005{
1006 return isl_basic_map_is_rational(bset);
1007}
1008
1009/* Does "bmap" contain any rational points?
1010 *
1011 * If "bmap" has an equality for each dimension, equating the dimension
1012 * to an integer constant, then it has no rational points, even if it
1013 * is marked as rational.
1014 */
1015isl_bool isl_basic_map_has_rational(__isl_keep isl_basic_map *bmap)
1016{
1017 isl_bool has_rational = isl_bool_true;
1018 unsigned total;
1019
1020 if (!bmap)
1021 return isl_bool_error;
1022 if (isl_basic_map_plain_is_empty(bmap))
1023 return isl_bool_false;
1024 if (!isl_basic_map_is_rational(bmap))
1025 return isl_bool_false;
1026 bmap = isl_basic_map_copy(bmap);
1027 bmap = isl_basic_map_implicit_equalities(bmap);
1028 if (!bmap)
1029 return isl_bool_error;
1030 total = isl_basic_map_total_dim(bmap);
1031 if (bmap->n_eq == total) {
1032 int i, j;
1033 for (i = 0; i < bmap->n_eq; ++i) {
1034 j = isl_seq_first_non_zero(bmap->eq[i] + 1, total);
1035 if (j < 0)
1036 break;
1037 if (!isl_int_is_one(bmap->eq[i][1 + j])(isl_sioimath_cmp_si(*(bmap->eq[i][1 + j]), 1) == 0) &&
1038 !isl_int_is_negone(bmap->eq[i][1 + j])(isl_sioimath_cmp_si(*(bmap->eq[i][1 + j]), -1) == 0))
1039 break;
1040 j = isl_seq_first_non_zero(bmap->eq[i] + 1 + j + 1,
1041 total - j - 1);
1042 if (j >= 0)
1043 break;
1044 }
1045 if (i == bmap->n_eq)
1046 has_rational = isl_bool_false;
1047 }
1048 isl_basic_map_free(bmap);
1049
1050 return has_rational;
1051}
1052
1053/* Does "map" contain any rational points?
1054 */
1055isl_bool isl_map_has_rational(__isl_keep isl_map *map)
1056{
1057 int i;
1058 isl_bool has_rational;
1059
1060 if (!map)
1061 return isl_bool_error;
1062 for (i = 0; i < map->n; ++i) {
1063 has_rational = isl_basic_map_has_rational(map->p[i]);
1064 if (has_rational < 0 || has_rational)
1065 return has_rational;
1066 }
1067 return isl_bool_false;
1068}
1069
1070/* Does "set" contain any rational points?
1071 */
1072isl_bool isl_set_has_rational(__isl_keep isl_setisl_map *set)
1073{
1074 return isl_map_has_rational(set);
1075}
1076
1077/* Is this basic set a parameter domain?
1078 */
1079isl_bool isl_basic_set_is_params(__isl_keep isl_basic_setisl_basic_map *bset)
1080{
1081 if (!bset)
1082 return isl_bool_error;
1083 return isl_space_is_params(bset->dim);
1084}
1085
1086/* Is this set a parameter domain?
1087 */
1088isl_bool isl_set_is_params(__isl_keep isl_setisl_map *set)
1089{
1090 if (!set)
1091 return isl_bool_error;
1092 return isl_space_is_params(set->dim);
1093}
1094
1095/* Is this map actually a parameter domain?
1096 * Users should never call this function. Outside of isl,
1097 * a map can never be a parameter domain.
1098 */
1099isl_bool isl_map_is_params(__isl_keep isl_map *map)
1100{
1101 if (!map)
1102 return isl_bool_error;
1103 return isl_space_is_params(map->dim);
1104}
1105
1106static struct isl_basic_map *basic_map_init(struct isl_ctx *ctx,
1107 struct isl_basic_map *bmap, unsigned extra,
1108 unsigned n_eq, unsigned n_ineq)
1109{
1110 int i;
1111 size_t row_size = 1 + isl_space_dim(bmap->dim, isl_dim_all) + extra;
1112
1113 bmap->ctx = ctx;
1114 isl_ctx_ref(ctx);
1115
1116 bmap->block = isl_blk_alloc(ctx, (n_ineq + n_eq) * row_size);
1117 if (isl_blk_is_error(bmap->block))
1118 goto error;
1119
1120 bmap->ineq = isl_alloc_array(ctx, isl_int *, n_ineq + n_eq)((isl_int * *)isl_malloc_or_die(ctx, (n_ineq + n_eq)*sizeof(isl_int
*)))
;
1121 if ((n_ineq + n_eq) && !bmap->ineq)
1122 goto error;
1123
1124 if (extra == 0) {
1125 bmap->block2 = isl_blk_empty();
1126 bmap->div = NULL((void*)0);
1127 } else {
1128 bmap->block2 = isl_blk_alloc(ctx, extra * (1 + row_size));
1129 if (isl_blk_is_error(bmap->block2))
1130 goto error;
1131
1132 bmap->div = isl_alloc_array(ctx, isl_int *, extra)((isl_int * *)isl_malloc_or_die(ctx, (extra)*sizeof(isl_int *
)))
;
1133 if (!bmap->div)
1134 goto error;
1135 }
1136
1137 for (i = 0; i < n_ineq + n_eq; ++i)
1138 bmap->ineq[i] = bmap->block.data + i * row_size;
1139
1140 for (i = 0; i < extra; ++i)
1141 bmap->div[i] = bmap->block2.data + i * (1 + row_size);
1142
1143 bmap->ref = 1;
1144 bmap->flags = 0;
1145 bmap->c_size = n_eq + n_ineq;
1146 bmap->eq = bmap->ineq + n_ineq;
1147 bmap->extra = extra;
1148 bmap->n_eq = 0;
1149 bmap->n_ineq = 0;
1150 bmap->n_div = 0;
1151 bmap->sample = NULL((void*)0);
1152
1153 return bmap;
1154error:
1155 isl_basic_map_free(bmap);
1156 return NULL((void*)0);
1157}
1158
1159struct isl_basic_setisl_basic_map *isl_basic_set_alloc(struct isl_ctx *ctx,
1160 unsigned nparam, unsigned dim, unsigned extra,
1161 unsigned n_eq, unsigned n_ineq)
1162{
1163 struct isl_basic_map *bmap;
1164 isl_space *space;
1165
1166 space = isl_space_set_alloc(ctx, nparam, dim);
1167 if (!space)
1168 return NULL((void*)0);
1169
1170 bmap = isl_basic_map_alloc_space(space, extra, n_eq, n_ineq);
1171 return bset_from_bmap(bmap);
1172}
1173
1174__isl_give isl_basic_setisl_basic_map *isl_basic_set_alloc_space(__isl_take isl_space *dim,
1175 unsigned extra, unsigned n_eq, unsigned n_ineq)
1176{
1177 struct isl_basic_map *bmap;
1178 if (!dim)
1179 return NULL((void*)0);
1180 isl_assert(dim->ctx, dim->n_in == 0, goto error)do { if (dim->n_in == 0) break; do { isl_handle_error(dim->
ctx, isl_error_unknown, "Assertion \"" "dim->n_in == 0" "\" failed"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1180); goto error; } while (0); } while (0)
;
1181 bmap = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq);
1182 return bset_from_bmap(bmap);
1183error:
1184 isl_space_free(dim);
1185 return NULL((void*)0);
1186}
1187
1188struct isl_basic_map *isl_basic_map_alloc_space(__isl_take isl_space *dim,
1189 unsigned extra, unsigned n_eq, unsigned n_ineq)
1190{
1191 struct isl_basic_map *bmap;
1192
1193 if (!dim)
1194 return NULL((void*)0);
1195 bmap = isl_calloc_type(dim->ctx, struct isl_basic_map)((struct isl_basic_map *)isl_calloc_or_die(dim->ctx, 1, sizeof
(struct isl_basic_map)))
;
1196 if (!bmap)
1197 goto error;
1198 bmap->dim = dim;
1199
1200 return basic_map_init(dim->ctx, bmap, extra, n_eq, n_ineq);
1201error:
1202 isl_space_free(dim);
1203 return NULL((void*)0);
1204}
1205
1206struct isl_basic_map *isl_basic_map_alloc(struct isl_ctx *ctx,
1207 unsigned nparam, unsigned in, unsigned out, unsigned extra,
1208 unsigned n_eq, unsigned n_ineq)
1209{
1210 struct isl_basic_map *bmap;
1211 isl_space *dim;
1212
1213 dim = isl_space_alloc(ctx, nparam, in, out);
1214 if (!dim)
1215 return NULL((void*)0);
1216
1217 bmap = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq);
1218 return bmap;
1219}
1220
1221static void dup_constraints(
1222 struct isl_basic_map *dst, struct isl_basic_map *src)
1223{
1224 int i;
1225 unsigned total = isl_basic_map_total_dim(src);
1226
1227 for (i = 0; i < src->n_eq; ++i) {
1228 int j = isl_basic_map_alloc_equality(dst);
1229 isl_seq_cpy(dst->eq[j], src->eq[i], 1+total);
1230 }
1231
1232 for (i = 0; i < src->n_ineq; ++i) {
1233 int j = isl_basic_map_alloc_inequality(dst);
1234 isl_seq_cpy(dst->ineq[j], src->ineq[i], 1+total);
1235 }
1236
1237 for (i = 0; i < src->n_div; ++i) {
1238 int j = isl_basic_map_alloc_div(dst);
1239 isl_seq_cpy(dst->div[j], src->div[i], 1+1+total);
1240 }
1241 ISL_F_SET(dst, ISL_BASIC_SET_FINAL)(((dst)->flags) |= ((1 << 0)));
1242}
1243
1244__isl_give isl_basic_map *isl_basic_map_dup(__isl_keep isl_basic_map *bmap)
1245{
1246 struct isl_basic_map *dup;
1247
1248 if (!bmap)
1249 return NULL((void*)0);
1250 dup = isl_basic_map_alloc_space(isl_space_copy(bmap->dim),
1251 bmap->n_div, bmap->n_eq, bmap->n_ineq);
1252 if (!dup)
1253 return NULL((void*)0);
1254 dup_constraints(dup, bmap);
1255 dup->flags = bmap->flags;
1256 dup->sample = isl_vec_copy(bmap->sample);
1257 return dup;
1258}
1259
1260struct isl_basic_setisl_basic_map *isl_basic_set_dup(struct isl_basic_setisl_basic_map *bset)
1261{
1262 struct isl_basic_map *dup;
1263
1264 dup = isl_basic_map_dup(bset_to_bmap(bset));
1265 return bset_from_bmap(dup);
1266}
1267
1268__isl_give isl_basic_setisl_basic_map *isl_basic_set_copy(__isl_keep isl_basic_setisl_basic_map *bset)
1269{
1270 if (!bset)
1271 return NULL((void*)0);
1272
1273 if (ISL_F_ISSET(bset, ISL_BASIC_SET_FINAL)(!!(((bset)->flags) & ((1 << 0))))) {
1274 bset->ref++;
1275 return bset;
1276 }
1277 return isl_basic_set_dup(bset);
1278}
1279
1280__isl_give isl_setisl_map *isl_set_copy(__isl_keep isl_setisl_map *set)
1281{
1282 if (!set)
1283 return NULL((void*)0);
1284
1285 set->ref++;
1286 return set;
1287}
1288
1289__isl_give isl_basic_map *isl_basic_map_copy(__isl_keep isl_basic_map *bmap)
1290{
1291 if (!bmap)
1292 return NULL((void*)0);
1293
1294 if (ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL)(!!(((bmap)->flags) & ((1 << 0))))) {
1295 bmap->ref++;
1296 return bmap;
1297 }
1298 bmap = isl_basic_map_dup(bmap);
1299 if (bmap)
1300 ISL_F_SET(bmap, ISL_BASIC_SET_FINAL)(((bmap)->flags) |= ((1 << 0)));
1301 return bmap;
1302}
1303
1304__isl_give isl_map *isl_map_copy(__isl_keep isl_map *map)
1305{
1306 if (!map)
1307 return NULL((void*)0);
1308
1309 map->ref++;
1310 return map;
1311}
1312
1313__isl_null isl_basic_map *isl_basic_map_free(__isl_take isl_basic_map *bmap)
1314{
1315 if (!bmap)
1316 return NULL((void*)0);
1317
1318 if (--bmap->ref > 0)
1319 return NULL((void*)0);
1320
1321 isl_ctx_deref(bmap->ctx);
1322 free(bmap->div);
1323 isl_blk_free(bmap->ctx, bmap->block2);
1324 free(bmap->ineq);
1325 isl_blk_free(bmap->ctx, bmap->block);
1326 isl_vec_free(bmap->sample);
1327 isl_space_free(bmap->dim);
1328 free(bmap);
1329
1330 return NULL((void*)0);
1331}
1332
1333__isl_null isl_basic_setisl_basic_map *isl_basic_set_free(__isl_take isl_basic_setisl_basic_map *bset)
1334{
1335 return isl_basic_map_free(bset_to_bmap(bset));
1336}
1337
1338static int room_for_con(struct isl_basic_map *bmap, unsigned n)
1339{
1340 return bmap->n_eq + bmap->n_ineq + n <= bmap->c_size;
1341}
1342
1343/* Check that "map" has only named parameters, reporting an error
1344 * if it does not.
1345 */
1346isl_stat isl_map_check_named_params(__isl_keep isl_map *map)
1347{
1348 return isl_space_check_named_params(isl_map_peek_space(map));
1349}
1350
1351/* Check that "bmap1" and "bmap2" have the same parameters,
1352 * reporting an error if they do not.
1353 */
1354static isl_stat isl_basic_map_check_equal_params(
1355 __isl_keep isl_basic_map *bmap1, __isl_keep isl_basic_map *bmap2)
1356{
1357 isl_bool match;
1358
1359 match = isl_basic_map_has_equal_params(bmap1, bmap2);
1360 if (match < 0)
1361 return isl_stat_error;
1362 if (!match)
1363 isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid,do { isl_handle_error(isl_basic_map_get_ctx(bmap1), isl_error_invalid
, "parameters don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1364); return isl_stat_error; } while (0)
1364 "parameters don't match", return isl_stat_error)do { isl_handle_error(isl_basic_map_get_ctx(bmap1), isl_error_invalid
, "parameters don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1364); return isl_stat_error; } while (0)
;
1365 return isl_stat_ok;
1366}
1367
1368__isl_give isl_map *isl_map_align_params_map_map_and(
1369 __isl_take isl_map *map1, __isl_take isl_map *map2,
1370 __isl_give isl_map *(*fn)(__isl_take isl_map *map1,
1371 __isl_take isl_map *map2))
1372{
1373 if (!map1 || !map2)
4
Assuming 'map2' is non-null
5
Taking false branch
1374 goto error;
1375 if (isl_map_has_equal_params(map1, map2))
6
Assuming the condition is true
7
Taking true branch
1376 return fn(map1, map2);
8
Calling 'map_intersect'
1377 if (isl_map_check_named_params(map1) < 0)
1378 goto error;
1379 if (isl_map_check_named_params(map2) < 0)
1380 goto error;
1381 map1 = isl_map_align_params(map1, isl_map_get_space(map2));
1382 map2 = isl_map_align_params(map2, isl_map_get_space(map1));
1383 return fn(map1, map2);
1384error:
1385 isl_map_free(map1);
1386 isl_map_free(map2);
1387 return NULL((void*)0);
1388}
1389
1390isl_bool isl_map_align_params_map_map_and_test(__isl_keep isl_map *map1,
1391 __isl_keep isl_map *map2,
1392 isl_bool (*fn)(__isl_keep isl_map *map1, __isl_keep isl_map *map2))
1393{
1394 isl_bool r;
1395
1396 if (!map1 || !map2)
1397 return isl_bool_error;
1398 if (isl_map_has_equal_params(map1, map2))
1399 return fn(map1, map2);
1400 if (isl_map_check_named_params(map1) < 0)
1401 return isl_bool_error;
1402 if (isl_map_check_named_params(map2) < 0)
1403 return isl_bool_error;
1404 map1 = isl_map_copy(map1);
1405 map2 = isl_map_copy(map2);
1406 map1 = isl_map_align_params(map1, isl_map_get_space(map2));
1407 map2 = isl_map_align_params(map2, isl_map_get_space(map1));
1408 r = fn(map1, map2);
1409 isl_map_free(map1);
1410 isl_map_free(map2);
1411 return r;
1412}
1413
1414int isl_basic_map_alloc_equality(struct isl_basic_map *bmap)
1415{
1416 struct isl_ctx *ctx;
1417 if (!bmap)
1418 return -1;
1419 ctx = bmap->ctx;
1420 isl_assert(ctx, room_for_con(bmap, 1), return -1)do { if (room_for_con(bmap, 1)) break; do { isl_handle_error(
ctx, isl_error_unknown, "Assertion \"" "room_for_con(bmap, 1)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1420); return -1; } while (0); } while (0)
;
1421 isl_assert(ctx, (bmap->eq - bmap->ineq) + bmap->n_eq <= bmap->c_size,do { if ((bmap->eq - bmap->ineq) + bmap->n_eq <= bmap
->c_size) break; do { isl_handle_error(ctx, isl_error_unknown
, "Assertion \"" "(bmap->eq - bmap->ineq) + bmap->n_eq <= bmap->c_size"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1422); return -1; } while (0); } while (0)
1422 return -1)do { if ((bmap->eq - bmap->ineq) + bmap->n_eq <= bmap
->c_size) break; do { isl_handle_error(ctx, isl_error_unknown
, "Assertion \"" "(bmap->eq - bmap->ineq) + bmap->n_eq <= bmap->c_size"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1422); return -1; } while (0); } while (0)
;
1423 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
1424 ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT)(((bmap)->flags) &= ~((1 << 3)));
1425 ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT)(((bmap)->flags) &= ~((1 << 2)));
1426 ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES)(((bmap)->flags) &= ~((1 << 7)));
1427 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS)(((bmap)->flags) &= ~((1 << 6)));
1428 if ((bmap->eq - bmap->ineq) + bmap->n_eq == bmap->c_size) {
1429 isl_int *t;
1430 int j = isl_basic_map_alloc_inequality(bmap);
1431 if (j < 0)
1432 return -1;
1433 t = bmap->ineq[j];
1434 bmap->ineq[j] = bmap->ineq[bmap->n_ineq - 1];
1435 bmap->ineq[bmap->n_ineq - 1] = bmap->eq[-1];
1436 bmap->eq[-1] = t;
1437 bmap->n_eq++;
1438 bmap->n_ineq--;
1439 bmap->eq--;
1440 return 0;
1441 }
1442 isl_seq_clr(bmap->eq[bmap->n_eq] + 1 + isl_basic_map_total_dim(bmap),
1443 bmap->extra - bmap->n_div);
1444 return bmap->n_eq++;
1445}
1446
1447int isl_basic_set_alloc_equality(struct isl_basic_setisl_basic_map *bset)
1448{
1449 return isl_basic_map_alloc_equality(bset_to_bmap(bset));
1450}
1451
1452int isl_basic_map_free_equality(struct isl_basic_map *bmap, unsigned n)
1453{
1454 if (!bmap)
1455 return -1;
1456 isl_assert(bmap->ctx, n <= bmap->n_eq, return -1)do { if (n <= bmap->n_eq) break; do { isl_handle_error(
bmap->ctx, isl_error_unknown, "Assertion \"" "n <= bmap->n_eq"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1456); return -1; } while (0); } while (0)
;
1457 bmap->n_eq -= n;
1458 return 0;
1459}
1460
1461int isl_basic_set_free_equality(struct isl_basic_setisl_basic_map *bset, unsigned n)
1462{
1463 return isl_basic_map_free_equality(bset_to_bmap(bset), n);
1464}
1465
1466int isl_basic_map_drop_equality(struct isl_basic_map *bmap, unsigned pos)
1467{
1468 isl_int *t;
1469 if (!bmap)
1470 return -1;
1471 isl_assert(bmap->ctx, pos < bmap->n_eq, return -1)do { if (pos < bmap->n_eq) break; do { isl_handle_error
(bmap->ctx, isl_error_unknown, "Assertion \"" "pos < bmap->n_eq"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1471); return -1; } while (0); } while (0)
;
1472
1473 if (pos != bmap->n_eq - 1) {
1474 t = bmap->eq[pos];
1475 bmap->eq[pos] = bmap->eq[bmap->n_eq - 1];
1476 bmap->eq[bmap->n_eq - 1] = t;
1477 }
1478 bmap->n_eq--;
1479 return 0;
1480}
1481
1482/* Turn inequality "pos" of "bmap" into an equality.
1483 *
1484 * In particular, we move the inequality in front of the equalities
1485 * and move the last inequality in the position of the moved inequality.
1486 * Note that isl_tab_make_equalities_explicit depends on this particular
1487 * change in the ordering of the constraints.
1488 */
1489void isl_basic_map_inequality_to_equality(
1490 struct isl_basic_map *bmap, unsigned pos)
1491{
1492 isl_int *t;
1493
1494 t = bmap->ineq[pos];
1495 bmap->ineq[pos] = bmap->ineq[bmap->n_ineq - 1];
1496 bmap->ineq[bmap->n_ineq - 1] = bmap->eq[-1];
1497 bmap->eq[-1] = t;
1498 bmap->n_eq++;
1499 bmap->n_ineq--;
1500 bmap->eq--;
1501 ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT)(((bmap)->flags) &= ~((1 << 3)));
1502 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
1503 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS)(((bmap)->flags) &= ~((1 << 6)));
1504 ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES)(((bmap)->flags) &= ~((1 << 7)));
1505}
1506
1507static int room_for_ineq(struct isl_basic_map *bmap, unsigned n)
1508{
1509 return bmap->n_ineq + n <= bmap->eq - bmap->ineq;
1510}
1511
1512int isl_basic_map_alloc_inequality(__isl_keep isl_basic_map *bmap)
1513{
1514 struct isl_ctx *ctx;
1515 if (!bmap)
1516 return -1;
1517 ctx = bmap->ctx;
1518 isl_assert(ctx, room_for_ineq(bmap, 1), return -1)do { if (room_for_ineq(bmap, 1)) break; do { isl_handle_error
(ctx, isl_error_unknown, "Assertion \"" "room_for_ineq(bmap, 1)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1518); return -1; } while (0); } while (0)
;
1519 ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT)(((bmap)->flags) &= ~((1 << 2)));
1520 ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT)(((bmap)->flags) &= ~((1 << 3)));
1521 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
1522 ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES)(((bmap)->flags) &= ~((1 << 7)));
1523 isl_seq_clr(bmap->ineq[bmap->n_ineq] +
1524 1 + isl_basic_map_total_dim(bmap),
1525 bmap->extra - bmap->n_div);
1526 return bmap->n_ineq++;
1527}
1528
1529int isl_basic_set_alloc_inequality(__isl_keep isl_basic_setisl_basic_map *bset)
1530{
1531 return isl_basic_map_alloc_inequality(bset_to_bmap(bset));
1532}
1533
1534int isl_basic_map_free_inequality(struct isl_basic_map *bmap, unsigned n)
1535{
1536 if (!bmap)
1537 return -1;
1538 isl_assert(bmap->ctx, n <= bmap->n_ineq, return -1)do { if (n <= bmap->n_ineq) break; do { isl_handle_error
(bmap->ctx, isl_error_unknown, "Assertion \"" "n <= bmap->n_ineq"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1538); return -1; } while (0); } while (0)
;
1539 bmap->n_ineq -= n;
1540 return 0;
1541}
1542
1543int isl_basic_set_free_inequality(struct isl_basic_setisl_basic_map *bset, unsigned n)
1544{
1545 return isl_basic_map_free_inequality(bset_to_bmap(bset), n);
1546}
1547
1548int isl_basic_map_drop_inequality(struct isl_basic_map *bmap, unsigned pos)
1549{
1550 isl_int *t;
1551 if (!bmap)
1552 return -1;
1553 isl_assert(bmap->ctx, pos < bmap->n_ineq, return -1)do { if (pos < bmap->n_ineq) break; do { isl_handle_error
(bmap->ctx, isl_error_unknown, "Assertion \"" "pos < bmap->n_ineq"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1553); return -1; } while (0); } while (0)
;
1554
1555 if (pos != bmap->n_ineq - 1) {
1556 t = bmap->ineq[pos];
1557 bmap->ineq[pos] = bmap->ineq[bmap->n_ineq - 1];
1558 bmap->ineq[bmap->n_ineq - 1] = t;
1559 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
1560 }
1561 bmap->n_ineq--;
1562 return 0;
1563}
1564
1565int isl_basic_set_drop_inequality(struct isl_basic_setisl_basic_map *bset, unsigned pos)
1566{
1567 return isl_basic_map_drop_inequality(bset_to_bmap(bset), pos);
1568}
1569
1570__isl_give isl_basic_map *isl_basic_map_add_eq(__isl_take isl_basic_map *bmap,
1571 isl_int *eq)
1572{
1573 int k;
1574
1575 bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
1576 if (!bmap)
1577 return NULL((void*)0);
1578 k = isl_basic_map_alloc_equality(bmap);
1579 if (k < 0)
1580 goto error;
1581 isl_seq_cpy(bmap->eq[k], eq, 1 + isl_basic_map_total_dim(bmap));
1582 return bmap;
1583error:
1584 isl_basic_map_free(bmap);
1585 return NULL((void*)0);
1586}
1587
1588__isl_give isl_basic_setisl_basic_map *isl_basic_set_add_eq(__isl_take isl_basic_setisl_basic_map *bset,
1589 isl_int *eq)
1590{
1591 return bset_from_bmap(isl_basic_map_add_eq(bset_to_bmap(bset), eq));
1592}
1593
1594__isl_give isl_basic_map *isl_basic_map_add_ineq(__isl_take isl_basic_map *bmap,
1595 isl_int *ineq)
1596{
1597 int k;
1598
1599 bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
1600 if (!bmap)
1601 return NULL((void*)0);
1602 k = isl_basic_map_alloc_inequality(bmap);
1603 if (k < 0)
1604 goto error;
1605 isl_seq_cpy(bmap->ineq[k], ineq, 1 + isl_basic_map_total_dim(bmap));
1606 return bmap;
1607error:
1608 isl_basic_map_free(bmap);
1609 return NULL((void*)0);
1610}
1611
1612__isl_give isl_basic_setisl_basic_map *isl_basic_set_add_ineq(__isl_take isl_basic_setisl_basic_map *bset,
1613 isl_int *ineq)
1614{
1615 return bset_from_bmap(isl_basic_map_add_ineq(bset_to_bmap(bset), ineq));
1616}
1617
1618int isl_basic_map_alloc_div(struct isl_basic_map *bmap)
1619{
1620 if (!bmap)
1621 return -1;
1622 isl_assert(bmap->ctx, bmap->n_div < bmap->extra, return -1)do { if (bmap->n_div < bmap->extra) break; do { isl_handle_error
(bmap->ctx, isl_error_unknown, "Assertion \"" "bmap->n_div < bmap->extra"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1622); return -1; } while (0); } while (0)
;
1623 isl_seq_clr(bmap->div[bmap->n_div] +
1624 1 + 1 + isl_basic_map_total_dim(bmap),
1625 bmap->extra - bmap->n_div);
1626 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS)(((bmap)->flags) &= ~((1 << 6)));
1627 return bmap->n_div++;
1628}
1629
1630int isl_basic_set_alloc_div(struct isl_basic_setisl_basic_map *bset)
1631{
1632 return isl_basic_map_alloc_div(bset_to_bmap(bset));
1633}
1634
1635/* Check that there are "n" dimensions of type "type" starting at "first"
1636 * in "bmap".
1637 */
1638static isl_stat isl_basic_map_check_range(__isl_keep isl_basic_map *bmap,
1639 enum isl_dim_type type, unsigned first, unsigned n)
1640{
1641 unsigned dim;
1642
1643 if (!bmap)
1644 return isl_stat_error;
1645 dim = isl_basic_map_dim(bmap, type);
1646 if (first + n > dim || first + n < first)
1647 isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "position or range out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1649); return isl_stat_error; } while (0)
1648 "position or range out of bounds",do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "position or range out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1649); return isl_stat_error; } while (0)
1649 return isl_stat_error)do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "position or range out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1649); return isl_stat_error; } while (0)
;
1650 return isl_stat_ok;
1651}
1652
1653/* Insert an extra integer division, prescribed by "div", to "bmap"
1654 * at (integer division) position "pos".
1655 *
1656 * The integer division is first added at the end and then moved
1657 * into the right position.
1658 */
1659__isl_give isl_basic_map *isl_basic_map_insert_div(
1660 __isl_take isl_basic_map *bmap, int pos, __isl_keep isl_vec *div)
1661{
1662 int i, k;
1663
1664 bmap = isl_basic_map_cow(bmap);
1665 if (!bmap || !div)
1666 return isl_basic_map_free(bmap);
1667
1668 if (div->size != 1 + 1 + isl_basic_map_dim(bmap, isl_dim_all))
1669 isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "unexpected size", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1670); return isl_basic_map_free(bmap); } while (0)
1670 "unexpected size", return isl_basic_map_free(bmap))do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "unexpected size", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1670); return isl_basic_map_free(bmap); } while (0)
;
1671 if (isl_basic_map_check_range(bmap, isl_dim_div, pos, 0) < 0)
1672 return isl_basic_map_free(bmap);
1673
1674 bmap = isl_basic_map_extend_space(bmap,
1675 isl_basic_map_get_space(bmap), 1, 0, 2);
1676 k = isl_basic_map_alloc_div(bmap);
1677 if (k < 0)
1678 return isl_basic_map_free(bmap);
1679 isl_seq_cpy(bmap->div[k], div->el, div->size);
1680 isl_int_set_si(bmap->div[k][div->size], 0)isl_sioimath_set_si((bmap->div[k][div->size]), 0);
1681
1682 for (i = k; i > pos; --i)
1683 isl_basic_map_swap_div(bmap, i, i - 1);
1684
1685 return bmap;
1686}
1687
1688isl_stat isl_basic_map_free_div(struct isl_basic_map *bmap, unsigned n)
1689{
1690 if (!bmap)
1691 return isl_stat_error;
1692 isl_assert(bmap->ctx, n <= bmap->n_div, return isl_stat_error)do { if (n <= bmap->n_div) break; do { isl_handle_error
(bmap->ctx, isl_error_unknown, "Assertion \"" "n <= bmap->n_div"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1692); return isl_stat_error; } while (0); } while (0)
;
1693 bmap->n_div -= n;
1694 return isl_stat_ok;
1695}
1696
1697/* Copy constraint from src to dst, putting the vars of src at offset
1698 * dim_off in dst and the divs of src at offset div_off in dst.
1699 * If both sets are actually map, then dim_off applies to the input
1700 * variables.
1701 */
1702static void copy_constraint(struct isl_basic_map *dst_map, isl_int *dst,
1703 struct isl_basic_map *src_map, isl_int *src,
1704 unsigned in_off, unsigned out_off, unsigned div_off)
1705{
1706 unsigned src_nparam = isl_basic_map_dim(src_map, isl_dim_param);
1707 unsigned dst_nparam = isl_basic_map_dim(dst_map, isl_dim_param);
1708 unsigned src_in = isl_basic_map_dim(src_map, isl_dim_in);
1709 unsigned dst_in = isl_basic_map_dim(dst_map, isl_dim_in);
1710 unsigned src_out = isl_basic_map_dim(src_map, isl_dim_out);
1711 unsigned dst_out = isl_basic_map_dim(dst_map, isl_dim_out);
1712 isl_int_set(dst[0], src[0])isl_sioimath_set((dst[0]), *(src[0]));
1713 isl_seq_cpy(dst+1, src+1, isl_min(dst_nparam, src_nparam)((dst_nparam < src_nparam) ? (dst_nparam) : (src_nparam)));
1714 if (dst_nparam > src_nparam)
1715 isl_seq_clr(dst+1+src_nparam,
1716 dst_nparam - src_nparam);
1717 isl_seq_clr(dst+1+dst_nparam, in_off);
1718 isl_seq_cpy(dst+1+dst_nparam+in_off,
1719 src+1+src_nparam,
1720 isl_min(dst_in-in_off, src_in)((dst_in-in_off < src_in) ? (dst_in-in_off) : (src_in)));
1721 if (dst_in-in_off > src_in)
1722 isl_seq_clr(dst+1+dst_nparam+in_off+src_in,
1723 dst_in - in_off - src_in);
1724 isl_seq_clr(dst+1+dst_nparam+dst_in, out_off);
1725 isl_seq_cpy(dst+1+dst_nparam+dst_in+out_off,
1726 src+1+src_nparam+src_in,
1727 isl_min(dst_out-out_off, src_out)((dst_out-out_off < src_out) ? (dst_out-out_off) : (src_out
))
);
1728 if (dst_out-out_off > src_out)
1729 isl_seq_clr(dst+1+dst_nparam+dst_in+out_off+src_out,
1730 dst_out - out_off - src_out);
1731 isl_seq_clr(dst+1+dst_nparam+dst_in+dst_out, div_off);
1732 isl_seq_cpy(dst+1+dst_nparam+dst_in+dst_out+div_off,
1733 src+1+src_nparam+src_in+src_out,
1734 isl_min(dst_map->extra-div_off, src_map->n_div)((dst_map->extra-div_off < src_map->n_div) ? (dst_map
->extra-div_off) : (src_map->n_div))
);
1735 if (dst_map->n_div-div_off > src_map->n_div)
1736 isl_seq_clr(dst+1+dst_nparam+dst_in+dst_out+
1737 div_off+src_map->n_div,
1738 dst_map->n_div - div_off - src_map->n_div);
1739}
1740
1741static void copy_div(struct isl_basic_map *dst_map, isl_int *dst,
1742 struct isl_basic_map *src_map, isl_int *src,
1743 unsigned in_off, unsigned out_off, unsigned div_off)
1744{
1745 isl_int_set(dst[0], src[0])isl_sioimath_set((dst[0]), *(src[0]));
1746 copy_constraint(dst_map, dst+1, src_map, src+1, in_off, out_off, div_off);
1747}
1748
1749static __isl_give isl_basic_map *add_constraints(
1750 __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2,
1751 unsigned i_pos, unsigned o_pos)
1752{
1753 int i;
1754 unsigned div_off;
1755
1756 if (!bmap1 || !bmap2)
1757 goto error;
1758
1759 div_off = bmap1->n_div;
1760
1761 for (i = 0; i < bmap2->n_eq; ++i) {
1762 int i1 = isl_basic_map_alloc_equality(bmap1);
1763 if (i1 < 0)
1764 goto error;
1765 copy_constraint(bmap1, bmap1->eq[i1], bmap2, bmap2->eq[i],
1766 i_pos, o_pos, div_off);
1767 }
1768
1769 for (i = 0; i < bmap2->n_ineq; ++i) {
1770 int i1 = isl_basic_map_alloc_inequality(bmap1);
1771 if (i1 < 0)
1772 goto error;
1773 copy_constraint(bmap1, bmap1->ineq[i1], bmap2, bmap2->ineq[i],
1774 i_pos, o_pos, div_off);
1775 }
1776
1777 for (i = 0; i < bmap2->n_div; ++i) {
1778 int i1 = isl_basic_map_alloc_div(bmap1);
1779 if (i1 < 0)
1780 goto error;
1781 copy_div(bmap1, bmap1->div[i1], bmap2, bmap2->div[i],
1782 i_pos, o_pos, div_off);
1783 }
1784
1785 isl_basic_map_free(bmap2);
1786
1787 return bmap1;
1788
1789error:
1790 isl_basic_map_free(bmap1);
1791 isl_basic_map_free(bmap2);
1792 return NULL((void*)0);
1793}
1794
1795struct isl_basic_setisl_basic_map *isl_basic_set_add_constraints(struct isl_basic_setisl_basic_map *bset1,
1796 struct isl_basic_setisl_basic_map *bset2, unsigned pos)
1797{
1798 return bset_from_bmap(add_constraints(bset_to_bmap(bset1),
1799 bset_to_bmap(bset2), 0, pos));
1800}
1801
1802__isl_give isl_basic_map *isl_basic_map_extend_space(
1803 __isl_take isl_basic_map *base, __isl_take isl_space *dim,
1804 unsigned extra, unsigned n_eq, unsigned n_ineq)
1805{
1806 struct isl_basic_map *ext;
1807 unsigned flags;
1808 int dims_ok;
1809
1810 if (!dim)
1811 goto error;
1812
1813 if (!base)
1814 goto error;
1815
1816 dims_ok = isl_space_is_equal(base->dim, dim) &&
1817 base->extra >= base->n_div + extra;
1818
1819 if (dims_ok && room_for_con(base, n_eq + n_ineq) &&
1820 room_for_ineq(base, n_ineq)) {
1821 isl_space_free(dim);
1822 return base;
1823 }
1824
1825 isl_assert(base->ctx, base->dim->nparam <= dim->nparam, goto error)do { if (base->dim->nparam <= dim->nparam) break;
do { isl_handle_error(base->ctx, isl_error_unknown, "Assertion \""
"base->dim->nparam <= dim->nparam" "\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1825); goto error; } while (0); } while (0)
;
1826 isl_assert(base->ctx, base->dim->n_in <= dim->n_in, goto error)do { if (base->dim->n_in <= dim->n_in) break; do {
isl_handle_error(base->ctx, isl_error_unknown, "Assertion \""
"base->dim->n_in <= dim->n_in" "\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1826); goto error; } while (0); } while (0)
;
1827 isl_assert(base->ctx, base->dim->n_out <= dim->n_out, goto error)do { if (base->dim->n_out <= dim->n_out) break; do
{ isl_handle_error(base->ctx, isl_error_unknown, "Assertion \""
"base->dim->n_out <= dim->n_out" "\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1827); goto error; } while (0); } while (0)
;
1828 extra += base->extra;
1829 n_eq += base->n_eq;
1830 n_ineq += base->n_ineq;
1831
1832 ext = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq);
1833 dim = NULL((void*)0);
1834 if (!ext)
1835 goto error;
1836
1837 if (dims_ok)
1838 ext->sample = isl_vec_copy(base->sample);
1839 flags = base->flags;
1840 ext = add_constraints(ext, base, 0, 0);
1841 if (ext) {
1842 ext->flags = flags;
1843 ISL_F_CLR(ext, ISL_BASIC_SET_FINAL)(((ext)->flags) &= ~((1 << 0)));
1844 }
1845
1846 return ext;
1847
1848error:
1849 isl_space_free(dim);
1850 isl_basic_map_free(base);
1851 return NULL((void*)0);
1852}
1853
1854__isl_give isl_basic_setisl_basic_map *isl_basic_set_extend_space(
1855 __isl_take isl_basic_setisl_basic_map *base,
1856 __isl_take isl_space *dim, unsigned extra,
1857 unsigned n_eq, unsigned n_ineq)
1858{
1859 return bset_from_bmap(isl_basic_map_extend_space(bset_to_bmap(base),
1860 dim, extra, n_eq, n_ineq));
1861}
1862
1863struct isl_basic_map *isl_basic_map_extend_constraints(
1864 struct isl_basic_map *base, unsigned n_eq, unsigned n_ineq)
1865{
1866 if (!base)
1867 return NULL((void*)0);
1868 return isl_basic_map_extend_space(base, isl_space_copy(base->dim),
1869 0, n_eq, n_ineq);
1870}
1871
1872struct isl_basic_map *isl_basic_map_extend(struct isl_basic_map *base,
1873 unsigned nparam, unsigned n_in, unsigned n_out, unsigned extra,
1874 unsigned n_eq, unsigned n_ineq)
1875{
1876 struct isl_basic_map *bmap;
1877 isl_space *dim;
1878
1879 if (!base)
1880 return NULL((void*)0);
1881 dim = isl_space_alloc(base->ctx, nparam, n_in, n_out);
1882 if (!dim)
1883 goto error;
1884
1885 bmap = isl_basic_map_extend_space(base, dim, extra, n_eq, n_ineq);
1886 return bmap;
1887error:
1888 isl_basic_map_free(base);
1889 return NULL((void*)0);
1890}
1891
1892struct isl_basic_setisl_basic_map *isl_basic_set_extend(struct isl_basic_setisl_basic_map *base,
1893 unsigned nparam, unsigned dim, unsigned extra,
1894 unsigned n_eq, unsigned n_ineq)
1895{
1896 return bset_from_bmap(isl_basic_map_extend(bset_to_bmap(base),
1897 nparam, 0, dim, extra, n_eq, n_ineq));
1898}
1899
1900struct isl_basic_setisl_basic_map *isl_basic_set_extend_constraints(
1901 struct isl_basic_setisl_basic_map *base, unsigned n_eq, unsigned n_ineq)
1902{
1903 isl_basic_map *bmap = bset_to_bmap(base);
1904 bmap = isl_basic_map_extend_constraints(bmap, n_eq, n_ineq);
1905 return bset_from_bmap(bmap);
1906}
1907
1908__isl_give isl_basic_setisl_basic_map *isl_basic_set_cow(__isl_take isl_basic_setisl_basic_map *bset)
1909{
1910 return bset_from_bmap(isl_basic_map_cow(bset_to_bmap(bset)));
1911}
1912
1913__isl_give isl_basic_map *isl_basic_map_cow(__isl_take isl_basic_map *bmap)
1914{
1915 if (!bmap)
1916 return NULL((void*)0);
1917
1918 if (bmap->ref > 1) {
1919 bmap->ref--;
1920 bmap = isl_basic_map_dup(bmap);
1921 }
1922 if (bmap) {
1923 ISL_F_CLR(bmap, ISL_BASIC_SET_FINAL)(((bmap)->flags) &= ~((1 << 0)));
1924 ISL_F_CLR(bmap, ISL_BASIC_MAP_REDUCED_COEFFICIENTS)(((bmap)->flags) &= ~((1 << 8)));
1925 }
1926 return bmap;
1927}
1928
1929/* Clear all cached information in "map", either because it is about
1930 * to be modified or because it is being freed.
1931 * Always return the same pointer that is passed in.
1932 * This is needed for the use in isl_map_free.
1933 */
1934static __isl_give isl_map *clear_caches(__isl_take isl_map *map)
1935{
1936 isl_basic_map_free(map->cached_simple_hull[0]);
1937 isl_basic_map_free(map->cached_simple_hull[1]);
1938 map->cached_simple_hull[0] = NULL((void*)0);
1939 map->cached_simple_hull[1] = NULL((void*)0);
1940 return map;
1941}
1942
1943__isl_give isl_setisl_map *isl_set_cow(__isl_take isl_setisl_map *set)
1944{
1945 return isl_map_cow(set);
1946}
1947
1948/* Return an isl_map that is equal to "map" and that has only
1949 * a single reference.
1950 *
1951 * If the original input already has only one reference, then
1952 * simply return it, but clear all cached information, since
1953 * it may be rendered invalid by the operations that will be
1954 * performed on the result.
1955 *
1956 * Otherwise, create a duplicate (without any cached information).
1957 */
1958__isl_give isl_map *isl_map_cow(__isl_take isl_map *map)
1959{
1960 if (!map)
1961 return NULL((void*)0);
1962
1963 if (map->ref == 1)
1964 return clear_caches(map);
1965 map->ref--;
1966 return isl_map_dup(map);
1967}
1968
1969static void swap_vars(struct isl_blk blk, isl_int *a,
1970 unsigned a_len, unsigned b_len)
1971{
1972 isl_seq_cpy(blk.data, a+a_len, b_len);
1973 isl_seq_cpy(blk.data+b_len, a, a_len);
1974 isl_seq_cpy(a, blk.data, b_len+a_len);
1975}
1976
1977static __isl_give isl_basic_map *isl_basic_map_swap_vars(
1978 __isl_take isl_basic_map *bmap, unsigned pos, unsigned n1, unsigned n2)
1979{
1980 int i;
1981 struct isl_blk blk;
1982
1983 if (!bmap)
1984 goto error;
1985
1986 isl_assert(bmap->ctx,do { if (pos + n1 + n2 <= 1 + isl_basic_map_total_dim(bmap
)) break; do { isl_handle_error(bmap->ctx, isl_error_unknown
, "Assertion \"" "pos + n1 + n2 <= 1 + isl_basic_map_total_dim(bmap)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1987); goto error; } while (0); } while (0)
1987 pos + n1 + n2 <= 1 + isl_basic_map_total_dim(bmap), goto error)do { if (pos + n1 + n2 <= 1 + isl_basic_map_total_dim(bmap
)) break; do { isl_handle_error(bmap->ctx, isl_error_unknown
, "Assertion \"" "pos + n1 + n2 <= 1 + isl_basic_map_total_dim(bmap)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 1987); goto error; } while (0); } while (0)
;
1988
1989 if (n1 == 0 || n2 == 0)
1990 return bmap;
1991
1992 bmap = isl_basic_map_cow(bmap);
1993 if (!bmap)
1994 return NULL((void*)0);
1995
1996 blk = isl_blk_alloc(bmap->ctx, n1 + n2);
1997 if (isl_blk_is_error(blk))
1998 goto error;
1999
2000 for (i = 0; i < bmap->n_eq; ++i)
2001 swap_vars(blk,
2002 bmap->eq[i] + pos, n1, n2);
2003
2004 for (i = 0; i < bmap->n_ineq; ++i)
2005 swap_vars(blk,
2006 bmap->ineq[i] + pos, n1, n2);
2007
2008 for (i = 0; i < bmap->n_div; ++i)
2009 swap_vars(blk,
2010 bmap->div[i]+1 + pos, n1, n2);
2011
2012 isl_blk_free(bmap->ctx, blk);
2013
2014 ISL_F_CLR(bmap, ISL_BASIC_SET_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
2015 bmap = isl_basic_map_gauss(bmap, NULL((void*)0));
2016 return isl_basic_map_finalize(bmap);
2017error:
2018 isl_basic_map_free(bmap);
2019 return NULL((void*)0);
2020}
2021
2022__isl_give isl_basic_map *isl_basic_map_set_to_empty(
2023 __isl_take isl_basic_map *bmap)
2024{
2025 int i = 0;
2026 unsigned total;
2027 if (!bmap)
2028 goto error;
2029 total = isl_basic_map_total_dim(bmap);
2030 if (isl_basic_map_free_div(bmap, bmap->n_div) < 0)
2031 return isl_basic_map_free(bmap);
2032 isl_basic_map_free_inequality(bmap, bmap->n_ineq);
2033 if (bmap->n_eq > 0)
2034 isl_basic_map_free_equality(bmap, bmap->n_eq-1);
2035 else {
2036 i = isl_basic_map_alloc_equality(bmap);
2037 if (i < 0)
2038 goto error;
2039 }
2040 isl_int_set_si(bmap->eq[i][0], 1)isl_sioimath_set_si((bmap->eq[i][0]), 1);
2041 isl_seq_clr(bmap->eq[i]+1, total);
2042 ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY)(((bmap)->flags) |= ((1 << 1)));
2043 isl_vec_free(bmap->sample);
2044 bmap->sample = NULL((void*)0);
2045 return isl_basic_map_finalize(bmap);
2046error:
2047 isl_basic_map_free(bmap);
2048 return NULL((void*)0);
2049}
2050
2051__isl_give isl_basic_setisl_basic_map *isl_basic_set_set_to_empty(
2052 __isl_take isl_basic_setisl_basic_map *bset)
2053{
2054 return bset_from_bmap(isl_basic_map_set_to_empty(bset_to_bmap(bset)));
2055}
2056
2057__isl_give isl_basic_map *isl_basic_map_set_rational(
2058 __isl_take isl_basic_map *bmap)
2059{
2060 if (!bmap)
2061 return NULL((void*)0);
2062
2063 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)(!!(((bmap)->flags) & ((1 << 4)))))
2064 return bmap;
2065
2066 bmap = isl_basic_map_cow(bmap);
2067 if (!bmap)
2068 return NULL((void*)0);
2069
2070 ISL_F_SET(bmap, ISL_BASIC_MAP_RATIONAL)(((bmap)->flags) |= ((1 << 4)));
2071
2072 return isl_basic_map_finalize(bmap);
2073}
2074
2075__isl_give isl_basic_setisl_basic_map *isl_basic_set_set_rational(
2076 __isl_take isl_basic_setisl_basic_map *bset)
2077{
2078 return isl_basic_map_set_rational(bset);
2079}
2080
2081__isl_give isl_basic_setisl_basic_map *isl_basic_set_set_integral(
2082 __isl_take isl_basic_setisl_basic_map *bset)
2083{
2084 if (!bset)
2085 return NULL((void*)0);
2086
2087 if (!ISL_F_ISSET(bset, ISL_BASIC_MAP_RATIONAL)(!!(((bset)->flags) & ((1 << 4)))))
2088 return bset;
2089
2090 bset = isl_basic_set_cow(bset);
2091 if (!bset)
2092 return NULL((void*)0);
2093
2094 ISL_F_CLR(bset, ISL_BASIC_MAP_RATIONAL)(((bset)->flags) &= ~((1 << 4)));
2095
2096 return isl_basic_set_finalize(bset);
2097}
2098
2099__isl_give isl_map *isl_map_set_rational(__isl_take isl_map *map)
2100{
2101 int i;
2102
2103 map = isl_map_cow(map);
2104 if (!map)
2105 return NULL((void*)0);
2106 for (i = 0; i < map->n; ++i) {
2107 map->p[i] = isl_basic_map_set_rational(map->p[i]);
2108 if (!map->p[i])
2109 goto error;
2110 }
2111 return map;
2112error:
2113 isl_map_free(map);
2114 return NULL((void*)0);
2115}
2116
2117__isl_give isl_setisl_map *isl_set_set_rational(__isl_take isl_setisl_map *set)
2118{
2119 return isl_map_set_rational(set);
2120}
2121
2122/* Swap divs "a" and "b" in "bmap" (without modifying any of the constraints
2123 * of "bmap").
2124 */
2125static void swap_div(__isl_keep isl_basic_map *bmap, int a, int b)
2126{
2127 isl_int *t = bmap->div[a];
2128 bmap->div[a] = bmap->div[b];
2129 bmap->div[b] = t;
2130}
2131
2132/* Swap divs "a" and "b" in "bmap" and adjust the constraints and
2133 * div definitions accordingly.
2134 */
2135void isl_basic_map_swap_div(struct isl_basic_map *bmap, int a, int b)
2136{
2137 int i;
2138 unsigned off = isl_space_dim(bmap->dim, isl_dim_all);
2139
2140 swap_div(bmap, a, b);
2141
2142 for (i = 0; i < bmap->n_eq; ++i)
2143 isl_int_swap(bmap->eq[i][1+off+a], bmap->eq[i][1+off+b])isl_sioimath_swap((bmap->eq[i][1+off+a]), (bmap->eq[i][
1+off+b]))
;
2144
2145 for (i = 0; i < bmap->n_ineq; ++i)
2146 isl_int_swap(bmap->ineq[i][1+off+a], bmap->ineq[i][1+off+b])isl_sioimath_swap((bmap->ineq[i][1+off+a]), (bmap->ineq
[i][1+off+b]))
;
2147
2148 for (i = 0; i < bmap->n_div; ++i)
2149 isl_int_swap(bmap->div[i][1+1+off+a], bmap->div[i][1+1+off+b])isl_sioimath_swap((bmap->div[i][1+1+off+a]), (bmap->div
[i][1+1+off+b]))
;
2150 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
2151}
2152
2153/* Swap divs "a" and "b" in "bset" and adjust the constraints and
2154 * div definitions accordingly.
2155 */
2156void isl_basic_set_swap_div(__isl_keep isl_basic_setisl_basic_map *bset, int a, int b)
2157{
2158 isl_basic_map_swap_div(bset, a, b);
2159}
2160
2161static void constraint_drop_vars(isl_int *c, unsigned n, unsigned rem)
2162{
2163 isl_seq_cpy(c, c + n, rem);
2164 isl_seq_clr(c + rem, n);
2165}
2166
2167/* Drop n dimensions starting at first.
2168 *
2169 * In principle, this frees up some extra variables as the number
2170 * of columns remains constant, but we would have to extend
2171 * the div array too as the number of rows in this array is assumed
2172 * to be equal to extra.
2173 */
2174__isl_give isl_basic_setisl_basic_map *isl_basic_set_drop_dims(
2175 __isl_take isl_basic_setisl_basic_map *bset, unsigned first, unsigned n)
2176{
2177 return isl_basic_map_drop(bset_to_bmap(bset), isl_dim_set, first, n);
2178}
2179
2180/* Move "n" divs starting at "first" to the end of the list of divs.
2181 */
2182static struct isl_basic_map *move_divs_last(struct isl_basic_map *bmap,
2183 unsigned first, unsigned n)
2184{
2185 isl_int **div;
2186 int i;
2187
2188 if (first + n == bmap->n_div)
2189 return bmap;
2190
2191 div = isl_alloc_array(bmap->ctx, isl_int *, n)((isl_int * *)isl_malloc_or_die(bmap->ctx, (n)*sizeof(isl_int
*)))
;
2192 if (!div)
2193 goto error;
2194 for (i = 0; i < n; ++i)
2195 div[i] = bmap->div[first + i];
2196 for (i = 0; i < bmap->n_div - first - n; ++i)
2197 bmap->div[first + i] = bmap->div[first + n + i];
2198 for (i = 0; i < n; ++i)
2199 bmap->div[bmap->n_div - n + i] = div[i];
2200 free(div);
2201 return bmap;
2202error:
2203 isl_basic_map_free(bmap);
2204 return NULL((void*)0);
2205}
2206
2207/* Drop "n" dimensions of type "type" starting at "first".
2208 *
2209 * In principle, this frees up some extra variables as the number
2210 * of columns remains constant, but we would have to extend
2211 * the div array too as the number of rows in this array is assumed
2212 * to be equal to extra.
2213 */
2214__isl_give isl_basic_map *isl_basic_map_drop(__isl_take isl_basic_map *bmap,
2215 enum isl_dim_type type, unsigned first, unsigned n)
2216{
2217 int i;
2218 unsigned dim;
2219 unsigned offset;
2220 unsigned left;
2221
2222 if (!bmap)
2223 goto error;
2224
2225 dim = isl_basic_map_dim(bmap, type);
2226 isl_assert(bmap->ctx, first + n <= dim, goto error)do { if (first + n <= dim) break; do { isl_handle_error(bmap
->ctx, isl_error_unknown, "Assertion \"" "first + n <= dim"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 2226); goto error; } while (0); } while (0)
;
2227
2228 if (n == 0 && !isl_space_is_named_or_nested(bmap->dim, type))
2229 return bmap;
2230
2231 bmap = isl_basic_map_cow(bmap);
2232 if (!bmap)
2233 return NULL((void*)0);
2234
2235 offset = isl_basic_map_offset(bmap, type) + first;
2236 left = isl_basic_map_total_dim(bmap) - (offset - 1) - n;
2237 for (i = 0; i < bmap->n_eq; ++i)
2238 constraint_drop_vars(bmap->eq[i]+offset, n, left);
2239
2240 for (i = 0; i < bmap->n_ineq; ++i)
2241 constraint_drop_vars(bmap->ineq[i]+offset, n, left);
2242
2243 for (i = 0; i < bmap->n_div; ++i)
2244 constraint_drop_vars(bmap->div[i]+1+offset, n, left);
2245
2246 if (type == isl_dim_div) {
2247 bmap = move_divs_last(bmap, first, n);
2248 if (!bmap)
2249 goto error;
2250 if (isl_basic_map_free_div(bmap, n) < 0)
2251 return isl_basic_map_free(bmap);
2252 } else
2253 bmap->dim = isl_space_drop_dims(bmap->dim, type, first, n);
2254 if (!bmap->dim)
2255 goto error;
2256
2257 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
2258 bmap = isl_basic_map_simplify(bmap);
2259 return isl_basic_map_finalize(bmap);
2260error:
2261 isl_basic_map_free(bmap);
2262 return NULL((void*)0);
2263}
2264
2265__isl_give isl_basic_setisl_basic_map *isl_basic_set_drop(__isl_take isl_basic_setisl_basic_map *bset,
2266 enum isl_dim_type type, unsigned first, unsigned n)
2267{
2268 return bset_from_bmap(isl_basic_map_drop(bset_to_bmap(bset),
2269 type, first, n));
2270}
2271
2272__isl_give isl_map *isl_map_drop(__isl_take isl_map *map,
2273 enum isl_dim_type type, unsigned first, unsigned n)
2274{
2275 int i;
2276
2277 if (!map)
2278 goto error;
2279
2280 isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error)do { if (first + n <= isl_map_dim(map, type)) break; do { isl_handle_error
(map->ctx, isl_error_unknown, "Assertion \"" "first + n <= isl_map_dim(map, type)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 2280); goto error; } while (0); } while (0)
;
2281
2282 if (n == 0 && !isl_space_is_named_or_nested(map->dim, type))
2283 return map;
2284 map = isl_map_cow(map);
2285 if (!map)
2286 goto error;
2287 map->dim = isl_space_drop_dims(map->dim, type, first, n);
2288 if (!map->dim)
2289 goto error;
2290
2291 for (i = 0; i < map->n; ++i) {
2292 map->p[i] = isl_basic_map_drop(map->p[i], type, first, n);
2293 if (!map->p[i])
2294 goto error;
2295 }
2296 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
2297
2298 return map;
2299error:
2300 isl_map_free(map);
2301 return NULL((void*)0);
2302}
2303
2304__isl_give isl_setisl_map *isl_set_drop(__isl_take isl_setisl_map *set,
2305 enum isl_dim_type type, unsigned first, unsigned n)
2306{
2307 return set_from_map(isl_map_drop(set_to_map(set), type, first, n));
2308}
2309
2310/*
2311 * We don't cow, as the div is assumed to be redundant.
2312 */
2313__isl_give isl_basic_map *isl_basic_map_drop_div(
2314 __isl_take isl_basic_map *bmap, unsigned div)
2315{
2316 int i;
2317 unsigned pos;
2318
2319 if (!bmap)
2320 goto error;
2321
2322 pos = 1 + isl_space_dim(bmap->dim, isl_dim_all) + div;
2323
2324 isl_assert(bmap->ctx, div < bmap->n_div, goto error)do { if (div < bmap->n_div) break; do { isl_handle_error
(bmap->ctx, isl_error_unknown, "Assertion \"" "div < bmap->n_div"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 2324); goto error; } while (0); } while (0)
;
2325
2326 for (i = 0; i < bmap->n_eq; ++i)
2327 constraint_drop_vars(bmap->eq[i]+pos, 1, bmap->extra-div-1);
2328
2329 for (i = 0; i < bmap->n_ineq; ++i) {
2330 if (!isl_int_is_zero(bmap->ineq[i][pos])(isl_sioimath_sgn(*(bmap->ineq[i][pos])) == 0)) {
2331 isl_basic_map_drop_inequality(bmap, i);
2332 --i;
2333 continue;
2334 }
2335 constraint_drop_vars(bmap->ineq[i]+pos, 1, bmap->extra-div-1);
2336 }
2337
2338 for (i = 0; i < bmap->n_div; ++i)
2339 constraint_drop_vars(bmap->div[i]+1+pos, 1, bmap->extra-div-1);
2340
2341 if (div != bmap->n_div - 1) {
2342 int j;
2343 isl_int *t = bmap->div[div];
2344
2345 for (j = div; j < bmap->n_div - 1; ++j)
2346 bmap->div[j] = bmap->div[j+1];
2347
2348 bmap->div[bmap->n_div - 1] = t;
2349 }
2350 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
2351 if (isl_basic_map_free_div(bmap, 1) < 0)
2352 return isl_basic_map_free(bmap);
2353
2354 return bmap;
2355error:
2356 isl_basic_map_free(bmap);
2357 return NULL((void*)0);
2358}
2359
2360/* Eliminate the specified n dimensions starting at first from the
2361 * constraints, without removing the dimensions from the space.
2362 * If the set is rational, the dimensions are eliminated using Fourier-Motzkin.
2363 */
2364__isl_give isl_map *isl_map_eliminate(__isl_take isl_map *map,
2365 enum isl_dim_type type, unsigned first, unsigned n)
2366{
2367 int i;
2368
2369 if (!map)
2370 return NULL((void*)0);
2371 if (n == 0)
2372 return map;
2373
2374 if (first + n > isl_map_dim(map, type) || first + n < first)
2375 isl_die(map->ctx, isl_error_invalid,do { isl_handle_error(map->ctx, isl_error_invalid, "index out of bounds"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 2376); goto error; } while (0)
2376 "index out of bounds", goto error)do { isl_handle_error(map->ctx, isl_error_invalid, "index out of bounds"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 2376); goto error; } while (0)
;
2377
2378 map = isl_map_cow(map);
2379 if (!map)
2380 return NULL((void*)0);
2381
2382 for (i = 0; i < map->n; ++i) {
2383 map->p[i] = isl_basic_map_eliminate(map->p[i], type, first, n);
2384 if (!map->p[i])
2385 goto error;
2386 }
2387 return map;
2388error:
2389 isl_map_free(map);
2390 return NULL((void*)0);
2391}
2392
2393/* Eliminate the specified n dimensions starting at first from the
2394 * constraints, without removing the dimensions from the space.
2395 * If the set is rational, the dimensions are eliminated using Fourier-Motzkin.
2396 */
2397__isl_give isl_setisl_map *isl_set_eliminate(__isl_take isl_setisl_map *set,
2398 enum isl_dim_type type, unsigned first, unsigned n)
2399{
2400 return set_from_map(isl_map_eliminate(set_to_map(set), type, first, n));
2401}
2402
2403/* Eliminate the specified n dimensions starting at first from the
2404 * constraints, without removing the dimensions from the space.
2405 * If the set is rational, the dimensions are eliminated using Fourier-Motzkin.
2406 */
2407__isl_give isl_setisl_map *isl_set_eliminate_dims(__isl_take isl_setisl_map *set,
2408 unsigned first, unsigned n)
2409{
2410 return isl_set_eliminate(set, isl_dim_set, first, n);
2411}
2412
2413__isl_give isl_basic_map *isl_basic_map_remove_divs(
2414 __isl_take isl_basic_map *bmap)
2415{
2416 if (!bmap)
2417 return NULL((void*)0);
2418 bmap = isl_basic_map_eliminate_vars(bmap,
2419 isl_space_dim(bmap->dim, isl_dim_all), bmap->n_div);
2420 if (!bmap)
2421 return NULL((void*)0);
2422 bmap->n_div = 0;
2423 return isl_basic_map_finalize(bmap);
2424}
2425
2426__isl_give isl_basic_setisl_basic_map *isl_basic_set_remove_divs(
2427 __isl_take isl_basic_setisl_basic_map *bset)
2428{
2429 return bset_from_bmap(isl_basic_map_remove_divs(bset_to_bmap(bset)));
2430}
2431
2432__isl_give isl_map *isl_map_remove_divs(__isl_take isl_map *map)
2433{
2434 int i;
2435
2436 if (!map)
2437 return NULL((void*)0);
2438 if (map->n == 0)
2439 return map;
2440
2441 map = isl_map_cow(map);
2442 if (!map)
2443 return NULL((void*)0);
2444
2445 for (i = 0; i < map->n; ++i) {
2446 map->p[i] = isl_basic_map_remove_divs(map->p[i]);
2447 if (!map->p[i])
2448 goto error;
2449 }
2450 return map;
2451error:
2452 isl_map_free(map);
2453 return NULL((void*)0);
2454}
2455
2456__isl_give isl_setisl_map *isl_set_remove_divs(__isl_take isl_setisl_map *set)
2457{
2458 return isl_map_remove_divs(set);
2459}
2460
2461__isl_give isl_basic_map *isl_basic_map_remove_dims(
2462 __isl_take isl_basic_map *bmap, enum isl_dim_type type,
2463 unsigned first, unsigned n)
2464{
2465 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
2466 return isl_basic_map_free(bmap);
2467 if (n == 0 && !isl_space_is_named_or_nested(bmap->dim, type))
2468 return bmap;
2469 bmap = isl_basic_map_eliminate_vars(bmap,
2470 isl_basic_map_offset(bmap, type) - 1 + first, n);
2471 if (!bmap)
2472 return bmap;
2473 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY)(!!(((bmap)->flags) & ((1 << 1)))) && type == isl_dim_div)
2474 return bmap;
2475 bmap = isl_basic_map_drop(bmap, type, first, n);
2476 return bmap;
2477}
2478
2479/* Return true if the definition of the given div (recursively) involves
2480 * any of the given variables.
2481 */
2482static isl_bool div_involves_vars(__isl_keep isl_basic_map *bmap, int div,
2483 unsigned first, unsigned n)
2484{
2485 int i;
2486 unsigned div_offset = isl_basic_map_offset(bmap, isl_dim_div);
2487
2488 if (isl_int_is_zero(bmap->div[div][0])(isl_sioimath_sgn(*(bmap->div[div][0])) == 0))
2489 return isl_bool_false;
2490 if (isl_seq_first_non_zero(bmap->div[div] + 1 + first, n) >= 0)
2491 return isl_bool_true;
2492
2493 for (i = bmap->n_div - 1; i >= 0; --i) {
2494 isl_bool involves;
2495
2496 if (isl_int_is_zero(bmap->div[div][1 + div_offset + i])(isl_sioimath_sgn(*(bmap->div[div][1 + div_offset + i])) ==
0)
)
2497 continue;
2498 involves = div_involves_vars(bmap, i, first, n);
2499 if (involves < 0 || involves)
2500 return involves;
2501 }
2502
2503 return isl_bool_false;
2504}
2505
2506/* Try and add a lower and/or upper bound on "div" to "bmap"
2507 * based on inequality "i".
2508 * "total" is the total number of variables (excluding the divs).
2509 * "v" is a temporary object that can be used during the calculations.
2510 * If "lb" is set, then a lower bound should be constructed.
2511 * If "ub" is set, then an upper bound should be constructed.
2512 *
2513 * The calling function has already checked that the inequality does not
2514 * reference "div", but we still need to check that the inequality is
2515 * of the right form. We'll consider the case where we want to construct
2516 * a lower bound. The construction of upper bounds is similar.
2517 *
2518 * Let "div" be of the form
2519 *
2520 * q = floor((a + f(x))/d)
2521 *
2522 * We essentially check if constraint "i" is of the form
2523 *
2524 * b + f(x) >= 0
2525 *
2526 * so that we can use it to derive a lower bound on "div".
2527 * However, we allow a slightly more general form
2528 *
2529 * b + g(x) >= 0
2530 *
2531 * with the condition that the coefficients of g(x) - f(x) are all
2532 * divisible by d.
2533 * Rewriting this constraint as
2534 *
2535 * 0 >= -b - g(x)
2536 *
2537 * adding a + f(x) to both sides and dividing by d, we obtain
2538 *
2539 * (a + f(x))/d >= (a-b)/d + (f(x)-g(x))/d
2540 *
2541 * Taking the floor on both sides, we obtain
2542 *
2543 * q >= floor((a-b)/d) + (f(x)-g(x))/d
2544 *
2545 * or
2546 *
2547 * (g(x)-f(x))/d + ceil((b-a)/d) + q >= 0
2548 *
2549 * In the case of an upper bound, we construct the constraint
2550 *
2551 * (g(x)+f(x))/d + floor((b+a)/d) - q >= 0
2552 *
2553 */
2554static __isl_give isl_basic_map *insert_bounds_on_div_from_ineq(
2555 __isl_take isl_basic_map *bmap, int div, int i,
2556 unsigned total, isl_int v, int lb, int ub)
2557{
2558 int j;
2559
2560 for (j = 0; (lb || ub) && j < total + bmap->n_div; ++j) {
2561 if (lb) {
2562 isl_int_sub(v, bmap->ineq[i][1 + j],isl_sioimath_sub((v), *(bmap->ineq[i][1 + j]), *(bmap->
div[div][1 + 1 + j]))
2563 bmap->div[div][1 + 1 + j])isl_sioimath_sub((v), *(bmap->ineq[i][1 + j]), *(bmap->
div[div][1 + 1 + j]))
;
2564 lb = isl_int_is_divisible_by(v, bmap->div[div][0])isl_sioimath_is_divisible_by(*(v), *(bmap->div[div][0]));
2565 }
2566 if (ub) {
2567 isl_int_add(v, bmap->ineq[i][1 + j],isl_sioimath_add((v), *(bmap->ineq[i][1 + j]), *(bmap->
div[div][1 + 1 + j]))
2568 bmap->div[div][1 + 1 + j])isl_sioimath_add((v), *(bmap->ineq[i][1 + j]), *(bmap->
div[div][1 + 1 + j]))
;
2569 ub = isl_int_is_divisible_by(v, bmap->div[div][0])isl_sioimath_is_divisible_by(*(v), *(bmap->div[div][0]));
2570 }
2571 }
2572 if (!lb && !ub)
2573 return bmap;
2574
2575 bmap = isl_basic_map_cow(bmap);
2576 bmap = isl_basic_map_extend_constraints(bmap, 0, lb + ub);
2577 if (lb) {
2578 int k = isl_basic_map_alloc_inequality(bmap);
2579 if (k < 0)
2580 goto error;
2581 for (j = 0; j < 1 + total + bmap->n_div; ++j) {
2582 isl_int_sub(bmap->ineq[k][j], bmap->ineq[i][j],isl_sioimath_sub((bmap->ineq[k][j]), *(bmap->ineq[i][j]
), *(bmap->div[div][1 + j]))
2583 bmap->div[div][1 + j])isl_sioimath_sub((bmap->ineq[k][j]), *(bmap->ineq[i][j]
), *(bmap->div[div][1 + j]))
;
2584 isl_int_cdiv_q(bmap->ineq[k][j],isl_sioimath_cdiv_q((bmap->ineq[k][j]), *(bmap->ineq[k]
[j]), *(bmap->div[div][0]))
2585 bmap->ineq[k][j], bmap->div[div][0])isl_sioimath_cdiv_q((bmap->ineq[k][j]), *(bmap->ineq[k]
[j]), *(bmap->div[div][0]))
;
2586 }
2587 isl_int_set_si(bmap->ineq[k][1 + total + div], 1)isl_sioimath_set_si((bmap->ineq[k][1 + total + div]), 1);
2588 }
2589 if (ub) {
2590 int k = isl_basic_map_alloc_inequality(bmap);
2591 if (k < 0)
2592 goto error;
2593 for (j = 0; j < 1 + total + bmap->n_div; ++j) {
2594 isl_int_add(bmap->ineq[k][j], bmap->ineq[i][j],isl_sioimath_add((bmap->ineq[k][j]), *(bmap->ineq[i][j]
), *(bmap->div[div][1 + j]))
2595 bmap->div[div][1 + j])isl_sioimath_add((bmap->ineq[k][j]), *(bmap->ineq[i][j]
), *(bmap->div[div][1 + j]))
;
2596 isl_int_fdiv_q(bmap->ineq[k][j],isl_sioimath_fdiv_q((bmap->ineq[k][j]), *(bmap->ineq[k]
[j]), *(bmap->div[div][0]))
2597 bmap->ineq[k][j], bmap->div[div][0])isl_sioimath_fdiv_q((bmap->ineq[k][j]), *(bmap->ineq[k]
[j]), *(bmap->div[div][0]))
;
2598 }
2599 isl_int_set_si(bmap->ineq[k][1 + total + div], -1)isl_sioimath_set_si((bmap->ineq[k][1 + total + div]), -1);
2600 }
2601
2602 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
2603 return bmap;
2604error:
2605 isl_basic_map_free(bmap);
2606 return NULL((void*)0);
2607}
2608
2609/* This function is called right before "div" is eliminated from "bmap"
2610 * using Fourier-Motzkin.
2611 * Look through the constraints of "bmap" for constraints on the argument
2612 * of the integer division and use them to construct constraints on the
2613 * integer division itself. These constraints can then be combined
2614 * during the Fourier-Motzkin elimination.
2615 * Note that it is only useful to introduce lower bounds on "div"
2616 * if "bmap" already contains upper bounds on "div" as the newly
2617 * introduce lower bounds can then be combined with the pre-existing
2618 * upper bounds. Similarly for upper bounds.
2619 * We therefore first check if "bmap" contains any lower and/or upper bounds
2620 * on "div".
2621 *
2622 * It is interesting to note that the introduction of these constraints
2623 * can indeed lead to more accurate results, even when compared to
2624 * deriving constraints on the argument of "div" from constraints on "div".
2625 * Consider, for example, the set
2626 *
2627 * { [i,j,k] : 3 + i + 2j >= 0 and 2 * [(i+2j)/4] <= k }
2628 *
2629 * The second constraint can be rewritten as
2630 *
2631 * 2 * [(-i-2j+3)/4] + k >= 0
2632 *
2633 * from which we can derive
2634 *
2635 * -i - 2j + 3 >= -2k
2636 *
2637 * or
2638 *
2639 * i + 2j <= 3 + 2k
2640 *
2641 * Combined with the first constraint, we obtain
2642 *
2643 * -3 <= 3 + 2k or k >= -3
2644 *
2645 * If, on the other hand we derive a constraint on [(i+2j)/4] from
2646 * the first constraint, we obtain
2647 *
2648 * [(i + 2j)/4] >= [-3/4] = -1
2649 *
2650 * Combining this constraint with the second constraint, we obtain
2651 *
2652 * k >= -2
2653 */
2654static __isl_give isl_basic_map *insert_bounds_on_div(
2655 __isl_take isl_basic_map *bmap, int div)
2656{
2657 int i;
2658 int check_lb, check_ub;
2659 isl_int v;
2660 unsigned total;
2661
2662 if (!bmap)
2663 return NULL((void*)0);
2664
2665 if (isl_int_is_zero(bmap->div[div][0])(isl_sioimath_sgn(*(bmap->div[div][0])) == 0))
2666 return bmap;
2667
2668 total = isl_space_dim(bmap->dim, isl_dim_all);
2669
2670 check_lb = 0;
2671 check_ub = 0;
2672 for (i = 0; (!check_lb || !check_ub) && i < bmap->n_ineq; ++i) {
2673 int s = isl_int_sgn(bmap->ineq[i][1 + total + div])isl_sioimath_sgn(*(bmap->ineq[i][1 + total + div]));
2674 if (s > 0)
2675 check_ub = 1;
2676 if (s < 0)
2677 check_lb = 1;
2678 }
2679
2680 if (!check_lb && !check_ub)
2681 return bmap;
2682
2683 isl_int_init(v)isl_sioimath_init((v));
2684
2685 for (i = 0; bmap && i < bmap->n_ineq; ++i) {
2686 if (!isl_int_is_zero(bmap->ineq[i][1 + total + div])(isl_sioimath_sgn(*(bmap->ineq[i][1 + total + div])) == 0))
2687 continue;
2688
2689 bmap = insert_bounds_on_div_from_ineq(bmap, div, i, total, v,
2690 check_lb, check_ub);
2691 }
2692
2693 isl_int_clear(v)isl_sioimath_clear((v));
2694
2695 return bmap;
2696}
2697
2698/* Remove all divs (recursively) involving any of the given dimensions
2699 * in their definitions.
2700 */
2701__isl_give isl_basic_map *isl_basic_map_remove_divs_involving_dims(
2702 __isl_take isl_basic_map *bmap,
2703 enum isl_dim_type type, unsigned first, unsigned n)
2704{
2705 int i;
2706
2707 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
2708 return isl_basic_map_free(bmap);
2709 first += isl_basic_map_offset(bmap, type);
2710
2711 for (i = bmap->n_div - 1; i >= 0; --i) {
2712 isl_bool involves;
2713
2714 involves = div_involves_vars(bmap, i, first, n);
2715 if (involves < 0)
2716 return isl_basic_map_free(bmap);
2717 if (!involves)
2718 continue;
2719 bmap = insert_bounds_on_div(bmap, i);
2720 bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1);
2721 if (!bmap)
2722 return NULL((void*)0);
2723 i = bmap->n_div;
2724 }
2725
2726 return bmap;
2727}
2728
2729__isl_give isl_basic_setisl_basic_map *isl_basic_set_remove_divs_involving_dims(
2730 __isl_take isl_basic_setisl_basic_map *bset,
2731 enum isl_dim_type type, unsigned first, unsigned n)
2732{
2733 return isl_basic_map_remove_divs_involving_dims(bset, type, first, n);
2734}
2735
2736__isl_give isl_map *isl_map_remove_divs_involving_dims(__isl_take isl_map *map,
2737 enum isl_dim_type type, unsigned first, unsigned n)
2738{
2739 int i;
2740
2741 if (!map)
2742 return NULL((void*)0);
2743 if (map->n == 0)
2744 return map;
2745
2746 map = isl_map_cow(map);
2747 if (!map)
2748 return NULL((void*)0);
2749
2750 for (i = 0; i < map->n; ++i) {
2751 map->p[i] = isl_basic_map_remove_divs_involving_dims(map->p[i],
2752 type, first, n);
2753 if (!map->p[i])
2754 goto error;
2755 }
2756 return map;
2757error:
2758 isl_map_free(map);
2759 return NULL((void*)0);
2760}
2761
2762__isl_give isl_setisl_map *isl_set_remove_divs_involving_dims(__isl_take isl_setisl_map *set,
2763 enum isl_dim_type type, unsigned first, unsigned n)
2764{
2765 return set_from_map(isl_map_remove_divs_involving_dims(set_to_map(set),
2766 type, first, n));
2767}
2768
2769/* Does the description of "bmap" depend on the specified dimensions?
2770 * We also check whether the dimensions appear in any of the div definitions.
2771 * In principle there is no need for this check. If the dimensions appear
2772 * in a div definition, they also appear in the defining constraints of that
2773 * div.
2774 */
2775isl_bool isl_basic_map_involves_dims(__isl_keep isl_basic_map *bmap,
2776 enum isl_dim_type type, unsigned first, unsigned n)
2777{
2778 int i;
2779
2780 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
2781 return isl_bool_error;
2782
2783 first += isl_basic_map_offset(bmap, type);
2784 for (i = 0; i < bmap->n_eq; ++i)
2785 if (isl_seq_first_non_zero(bmap->eq[i] + first, n) >= 0)
2786 return isl_bool_true;
2787 for (i = 0; i < bmap->n_ineq; ++i)
2788 if (isl_seq_first_non_zero(bmap->ineq[i] + first, n) >= 0)
2789 return isl_bool_true;
2790 for (i = 0; i < bmap->n_div; ++i) {
2791 if (isl_int_is_zero(bmap->div[i][0])(isl_sioimath_sgn(*(bmap->div[i][0])) == 0))
2792 continue;
2793 if (isl_seq_first_non_zero(bmap->div[i] + 1 + first, n) >= 0)
2794 return isl_bool_true;
2795 }
2796
2797 return isl_bool_false;
2798}
2799
2800isl_bool isl_map_involves_dims(__isl_keep isl_map *map,
2801 enum isl_dim_type type, unsigned first, unsigned n)
2802{
2803 int i;
2804
2805 if (!map)
2806 return isl_bool_error;
2807
2808 if (first + n > isl_map_dim(map, type))
2809 isl_die(map->ctx, isl_error_invalid,do { isl_handle_error(map->ctx, isl_error_invalid, "index out of bounds"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 2810); return isl_bool_error; } while (0)
2810 "index out of bounds", return isl_bool_error)do { isl_handle_error(map->ctx, isl_error_invalid, "index out of bounds"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 2810); return isl_bool_error; } while (0)
;
2811
2812 for (i = 0; i < map->n; ++i) {
2813 isl_bool involves = isl_basic_map_involves_dims(map->p[i],
2814 type, first, n);
2815 if (involves < 0 || involves)
2816 return involves;
2817 }
2818
2819 return isl_bool_false;
2820}
2821
2822isl_bool isl_basic_set_involves_dims(__isl_keep isl_basic_setisl_basic_map *bset,
2823 enum isl_dim_type type, unsigned first, unsigned n)
2824{
2825 return isl_basic_map_involves_dims(bset, type, first, n);
2826}
2827
2828isl_bool isl_set_involves_dims(__isl_keep isl_setisl_map *set,
2829 enum isl_dim_type type, unsigned first, unsigned n)
2830{
2831 return isl_map_involves_dims(set, type, first, n);
2832}
2833
2834/* Drop all constraints in bmap that involve any of the dimensions
2835 * first to first+n-1.
2836 */
2837static __isl_give isl_basic_map *isl_basic_map_drop_constraints_involving(
2838 __isl_take isl_basic_map *bmap, unsigned first, unsigned n)
2839{
2840 int i;
2841
2842 if (n == 0)
2843 return bmap;
2844
2845 bmap = isl_basic_map_cow(bmap);
2846
2847 if (!bmap)
2848 return NULL((void*)0);
2849
2850 for (i = bmap->n_eq - 1; i >= 0; --i) {
2851 if (isl_seq_first_non_zero(bmap->eq[i] + 1 + first, n) == -1)
2852 continue;
2853 isl_basic_map_drop_equality(bmap, i);
2854 }
2855
2856 for (i = bmap->n_ineq - 1; i >= 0; --i) {
2857 if (isl_seq_first_non_zero(bmap->ineq[i] + 1 + first, n) == -1)
2858 continue;
2859 isl_basic_map_drop_inequality(bmap, i);
2860 }
2861
2862 bmap = isl_basic_map_add_known_div_constraints(bmap);
2863 return bmap;
2864}
2865
2866/* Drop all constraints in bset that involve any of the dimensions
2867 * first to first+n-1.
2868 */
2869__isl_give isl_basic_setisl_basic_map *isl_basic_set_drop_constraints_involving(
2870 __isl_take isl_basic_setisl_basic_map *bset, unsigned first, unsigned n)
2871{
2872 return isl_basic_map_drop_constraints_involving(bset, first, n);
2873}
2874
2875/* Drop all constraints in bmap that do not involve any of the dimensions
2876 * first to first + n - 1 of the given type.
2877 */
2878__isl_give isl_basic_map *isl_basic_map_drop_constraints_not_involving_dims(
2879 __isl_take isl_basic_map *bmap,
2880 enum isl_dim_type type, unsigned first, unsigned n)
2881{
2882 int i;
2883
2884 if (n == 0) {
2885 isl_space *space = isl_basic_map_get_space(bmap);
2886 isl_basic_map_free(bmap);
2887 return isl_basic_map_universe(space);
2888 }
2889 bmap = isl_basic_map_cow(bmap);
2890 if (!bmap)
2891 return NULL((void*)0);
2892
2893 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
2894 return isl_basic_map_free(bmap);
2895
2896 first += isl_basic_map_offset(bmap, type) - 1;
2897
2898 for (i = bmap->n_eq - 1; i >= 0; --i) {
2899 if (isl_seq_first_non_zero(bmap->eq[i] + 1 + first, n) != -1)
2900 continue;
2901 isl_basic_map_drop_equality(bmap, i);
2902 }
2903
2904 for (i = bmap->n_ineq - 1; i >= 0; --i) {
2905 if (isl_seq_first_non_zero(bmap->ineq[i] + 1 + first, n) != -1)
2906 continue;
2907 isl_basic_map_drop_inequality(bmap, i);
2908 }
2909
2910 bmap = isl_basic_map_add_known_div_constraints(bmap);
2911 return bmap;
2912}
2913
2914/* Drop all constraints in bset that do not involve any of the dimensions
2915 * first to first + n - 1 of the given type.
2916 */
2917__isl_give isl_basic_setisl_basic_map *isl_basic_set_drop_constraints_not_involving_dims(
2918 __isl_take isl_basic_setisl_basic_map *bset,
2919 enum isl_dim_type type, unsigned first, unsigned n)
2920{
2921 return isl_basic_map_drop_constraints_not_involving_dims(bset,
2922 type, first, n);
2923}
2924
2925/* Drop all constraints in bmap that involve any of the dimensions
2926 * first to first + n - 1 of the given type.
2927 */
2928__isl_give isl_basic_map *isl_basic_map_drop_constraints_involving_dims(
2929 __isl_take isl_basic_map *bmap,
2930 enum isl_dim_type type, unsigned first, unsigned n)
2931{
2932 if (!bmap)
2933 return NULL((void*)0);
2934 if (n == 0)
2935 return bmap;
2936
2937 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
2938 return isl_basic_map_free(bmap);
2939
2940 bmap = isl_basic_map_remove_divs_involving_dims(bmap, type, first, n);
2941 first += isl_basic_map_offset(bmap, type) - 1;
2942 return isl_basic_map_drop_constraints_involving(bmap, first, n);
2943}
2944
2945/* Drop all constraints in bset that involve any of the dimensions
2946 * first to first + n - 1 of the given type.
2947 */
2948__isl_give isl_basic_setisl_basic_map *isl_basic_set_drop_constraints_involving_dims(
2949 __isl_take isl_basic_setisl_basic_map *bset,
2950 enum isl_dim_type type, unsigned first, unsigned n)
2951{
2952 return isl_basic_map_drop_constraints_involving_dims(bset,
2953 type, first, n);
2954}
2955
2956/* Drop constraints from "map" by applying "drop" to each basic map.
2957 */
2958static __isl_give isl_map *drop_constraints(__isl_take isl_map *map,
2959 enum isl_dim_type type, unsigned first, unsigned n,
2960 __isl_give isl_basic_map *(*drop)(__isl_take isl_basic_map *bmap,
2961 enum isl_dim_type type, unsigned first, unsigned n))
2962{
2963 int i;
2964 unsigned dim;
2965
2966 if (!map)
2967 return NULL((void*)0);
2968
2969 dim = isl_map_dim(map, type);
2970 if (first + n > dim || first + n < first)
2971 isl_die(isl_map_get_ctx(map), isl_error_invalid,do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 2972); return isl_map_free(map); } while (0)
2972 "index out of bounds", return isl_map_free(map))do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 2972); return isl_map_free(map); } while (0)
;
2973
2974 map = isl_map_cow(map);
2975 if (!map)
2976 return NULL((void*)0);
2977
2978 for (i = 0; i < map->n; ++i) {
2979 map->p[i] = drop(map->p[i], type, first, n);
2980 if (!map->p[i])
2981 return isl_map_free(map);
2982 }
2983
2984 if (map->n > 1)
2985 ISL_F_CLR(map, ISL_MAP_DISJOINT)(((map)->flags) &= ~((1 << 0)));
2986
2987 return map;
2988}
2989
2990/* Drop all constraints in map that involve any of the dimensions
2991 * first to first + n - 1 of the given type.
2992 */
2993__isl_give isl_map *isl_map_drop_constraints_involving_dims(
2994 __isl_take isl_map *map,
2995 enum isl_dim_type type, unsigned first, unsigned n)
2996{
2997 if (n == 0)
2998 return map;
2999 return drop_constraints(map, type, first, n,
3000 &isl_basic_map_drop_constraints_involving_dims);
3001}
3002
3003/* Drop all constraints in "map" that do not involve any of the dimensions
3004 * first to first + n - 1 of the given type.
3005 */
3006__isl_give isl_map *isl_map_drop_constraints_not_involving_dims(
3007 __isl_take isl_map *map,
3008 enum isl_dim_type type, unsigned first, unsigned n)
3009{
3010 if (n == 0) {
3011 isl_space *space = isl_map_get_space(map);
3012 isl_map_free(map);
3013 return isl_map_universe(space);
3014 }
3015 return drop_constraints(map, type, first, n,
3016 &isl_basic_map_drop_constraints_not_involving_dims);
3017}
3018
3019/* Drop all constraints in set that involve any of the dimensions
3020 * first to first + n - 1 of the given type.
3021 */
3022__isl_give isl_setisl_map *isl_set_drop_constraints_involving_dims(
3023 __isl_take isl_setisl_map *set,
3024 enum isl_dim_type type, unsigned first, unsigned n)
3025{
3026 return isl_map_drop_constraints_involving_dims(set, type, first, n);
3027}
3028
3029/* Drop all constraints in "set" that do not involve any of the dimensions
3030 * first to first + n - 1 of the given type.
3031 */
3032__isl_give isl_setisl_map *isl_set_drop_constraints_not_involving_dims(
3033 __isl_take isl_setisl_map *set,
3034 enum isl_dim_type type, unsigned first, unsigned n)
3035{
3036 return isl_map_drop_constraints_not_involving_dims(set, type, first, n);
3037}
3038
3039/* Does local variable "div" of "bmap" have a complete explicit representation?
3040 * Having a complete explicit representation requires not only
3041 * an explicit representation, but also that all local variables
3042 * that appear in this explicit representation in turn have
3043 * a complete explicit representation.
3044 */
3045isl_bool isl_basic_map_div_is_known(__isl_keep isl_basic_map *bmap, int div)
3046{
3047 int i;
3048 unsigned div_offset = isl_basic_map_offset(bmap, isl_dim_div);
3049 isl_bool marked;
3050
3051 marked = isl_basic_map_div_is_marked_unknown(bmap, div);
3052 if (marked < 0 || marked)
3053 return isl_bool_not(marked);
3054
3055 for (i = bmap->n_div - 1; i >= 0; --i) {
3056 isl_bool known;
3057
3058 if (isl_int_is_zero(bmap->div[div][1 + div_offset + i])(isl_sioimath_sgn(*(bmap->div[div][1 + div_offset + i])) ==
0)
)
3059 continue;
3060 known = isl_basic_map_div_is_known(bmap, i);
3061 if (known < 0 || !known)
3062 return known;
3063 }
3064
3065 return isl_bool_true;
3066}
3067
3068/* Remove all divs that are unknown or defined in terms of unknown divs.
3069 */
3070__isl_give isl_basic_map *isl_basic_map_remove_unknown_divs(
3071 __isl_take isl_basic_map *bmap)
3072{
3073 int i;
3074
3075 if (!bmap)
3076 return NULL((void*)0);
3077
3078 for (i = bmap->n_div - 1; i >= 0; --i) {
3079 if (isl_basic_map_div_is_known(bmap, i))
3080 continue;
3081 bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1);
3082 if (!bmap)
3083 return NULL((void*)0);
3084 i = bmap->n_div;
3085 }
3086
3087 return bmap;
3088}
3089
3090/* Remove all divs that are unknown or defined in terms of unknown divs.
3091 */
3092__isl_give isl_basic_setisl_basic_map *isl_basic_set_remove_unknown_divs(
3093 __isl_take isl_basic_setisl_basic_map *bset)
3094{
3095 return isl_basic_map_remove_unknown_divs(bset);
3096}
3097
3098__isl_give isl_map *isl_map_remove_unknown_divs(__isl_take isl_map *map)
3099{
3100 int i;
3101
3102 if (!map)
3103 return NULL((void*)0);
3104 if (map->n == 0)
3105 return map;
3106
3107 map = isl_map_cow(map);
3108 if (!map)
3109 return NULL((void*)0);
3110
3111 for (i = 0; i < map->n; ++i) {
3112 map->p[i] = isl_basic_map_remove_unknown_divs(map->p[i]);
3113 if (!map->p[i])
3114 goto error;
3115 }
3116 return map;
3117error:
3118 isl_map_free(map);
3119 return NULL((void*)0);
3120}
3121
3122__isl_give isl_setisl_map *isl_set_remove_unknown_divs(__isl_take isl_setisl_map *set)
3123{
3124 return set_from_map(isl_map_remove_unknown_divs(set_to_map(set)));
3125}
3126
3127__isl_give isl_basic_setisl_basic_map *isl_basic_set_remove_dims(
3128 __isl_take isl_basic_setisl_basic_map *bset,
3129 enum isl_dim_type type, unsigned first, unsigned n)
3130{
3131 isl_basic_map *bmap = bset_to_bmap(bset);
3132 bmap = isl_basic_map_remove_dims(bmap, type, first, n);
3133 return bset_from_bmap(bmap);
3134}
3135
3136__isl_give isl_map *isl_map_remove_dims(__isl_take isl_map *map,
3137 enum isl_dim_type type, unsigned first, unsigned n)
3138{
3139 int i;
3140
3141 if (n == 0)
3142 return map;
3143
3144 map = isl_map_cow(map);
3145 if (!map)
3146 return NULL((void*)0);
3147 isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error)do { if (first + n <= isl_map_dim(map, type)) break; do { isl_handle_error
(map->ctx, isl_error_unknown, "Assertion \"" "first + n <= isl_map_dim(map, type)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3147); goto error; } while (0); } while (0)
;
3148
3149 for (i = 0; i < map->n; ++i) {
3150 map->p[i] = isl_basic_map_eliminate_vars(map->p[i],
3151 isl_basic_map_offset(map->p[i], type) - 1 + first, n);
3152 if (!map->p[i])
3153 goto error;
3154 }
3155 map = isl_map_drop(map, type, first, n);
3156 return map;
3157error:
3158 isl_map_free(map);
3159 return NULL((void*)0);
3160}
3161
3162__isl_give isl_setisl_map *isl_set_remove_dims(__isl_take isl_setisl_map *bset,
3163 enum isl_dim_type type, unsigned first, unsigned n)
3164{
3165 return set_from_map(isl_map_remove_dims(set_to_map(bset),
3166 type, first, n));
3167}
3168
3169/* Project out n inputs starting at first using Fourier-Motzkin */
3170struct isl_map *isl_map_remove_inputs(struct isl_map *map,
3171 unsigned first, unsigned n)
3172{
3173 return isl_map_remove_dims(map, isl_dim_in, first, n);
3174}
3175
3176static void dump_term(struct isl_basic_map *bmap,
3177 isl_int c, int pos, FILE *out)
3178{
3179 const char *name;
3180 unsigned in = isl_basic_map_dim(bmap, isl_dim_in);
3181 unsigned dim = in + isl_basic_map_dim(bmap, isl_dim_out);
3182 unsigned nparam = isl_basic_map_dim(bmap, isl_dim_param);
3183 if (!pos)
3184 isl_int_print(out, c, 0)isl_sioimath_print(out, *(c), 0);
3185 else {
3186 if (!isl_int_is_one(c)(isl_sioimath_cmp_si(*(c), 1) == 0))
3187 isl_int_print(out, c, 0)isl_sioimath_print(out, *(c), 0);
3188 if (pos < 1 + nparam) {
3189 name = isl_space_get_dim_name(bmap->dim,
3190 isl_dim_param, pos - 1);
3191 if (name)
3192 fprintf(out, "%s", name);
3193 else
3194 fprintf(out, "p%d", pos - 1);
3195 } else if (pos < 1 + nparam + in)
3196 fprintf(out, "i%d", pos - 1 - nparam);
3197 else if (pos < 1 + nparam + dim)
3198 fprintf(out, "o%d", pos - 1 - nparam - in);
3199 else
3200 fprintf(out, "e%d", pos - 1 - nparam - dim);
3201 }
3202}
3203
3204static void dump_constraint_sign(struct isl_basic_map *bmap, isl_int *c,
3205 int sign, FILE *out)
3206{
3207 int i;
3208 int first;
3209 unsigned len = 1 + isl_basic_map_total_dim(bmap);
3210 isl_int v;
3211
3212 isl_int_init(v)isl_sioimath_init((v));
3213 for (i = 0, first = 1; i < len; ++i) {
3214 if (isl_int_sgn(c[i])isl_sioimath_sgn(*(c[i])) * sign <= 0)
3215 continue;
3216 if (!first)
3217 fprintf(out, " + ");
3218 first = 0;
3219 isl_int_abs(v, c[i])isl_sioimath_abs((v), *(c[i]));
3220 dump_term(bmap, v, i, out);
3221 }
3222 isl_int_clear(v)isl_sioimath_clear((v));
3223 if (first)
3224 fprintf(out, "0");
3225}
3226
3227static void dump_constraint(struct isl_basic_map *bmap, isl_int *c,
3228 const char *op, FILE *out, int indent)
3229{
3230 int i;
3231
3232 fprintf(out, "%*s", indent, "");
3233
3234 dump_constraint_sign(bmap, c, 1, out);
3235 fprintf(out, " %s ", op);
3236 dump_constraint_sign(bmap, c, -1, out);
3237
3238 fprintf(out, "\n");
3239
3240 for (i = bmap->n_div; i < bmap->extra; ++i) {
3241 if (isl_int_is_zero(c[1+isl_space_dim(bmap->dim, isl_dim_all)+i])(isl_sioimath_sgn(*(c[1+isl_space_dim(bmap->dim, isl_dim_all
)+i])) == 0)
)
3242 continue;
3243 fprintf(out, "%*s", indent, "");
3244 fprintf(out, "ERROR: unused div coefficient not zero\n");
3245 abort();
3246 }
3247}
3248
3249static void dump_constraints(struct isl_basic_map *bmap,
3250 isl_int **c, unsigned n,
3251 const char *op, FILE *out, int indent)
3252{
3253 int i;
3254
3255 for (i = 0; i < n; ++i)
3256 dump_constraint(bmap, c[i], op, out, indent);
3257}
3258
3259static void dump_affine(struct isl_basic_map *bmap, isl_int *exp, FILE *out)
3260{
3261 int j;
3262 int first = 1;
3263 unsigned total = isl_basic_map_total_dim(bmap);
3264
3265 for (j = 0; j < 1 + total; ++j) {
3266 if (isl_int_is_zero(exp[j])(isl_sioimath_sgn(*(exp[j])) == 0))
3267 continue;
3268 if (!first && isl_int_is_pos(exp[j])(isl_sioimath_sgn(*(exp[j])) > 0))
3269 fprintf(out, "+");
3270 dump_term(bmap, exp[j], j, out);
3271 first = 0;
3272 }
3273}
3274
3275static void dump(struct isl_basic_map *bmap, FILE *out, int indent)
3276{
3277 int i;
3278
3279 dump_constraints(bmap, bmap->eq, bmap->n_eq, "=", out, indent);
3280 dump_constraints(bmap, bmap->ineq, bmap->n_ineq, ">=", out, indent);
3281
3282 for (i = 0; i < bmap->n_div; ++i) {
3283 fprintf(out, "%*s", indent, "");
3284 fprintf(out, "e%d = [(", i);
3285 dump_affine(bmap, bmap->div[i]+1, out);
3286 fprintf(out, ")/");
3287 isl_int_print(out, bmap->div[i][0], 0)isl_sioimath_print(out, *(bmap->div[i][0]), 0);
3288 fprintf(out, "]\n");
3289 }
3290}
3291
3292void isl_basic_set_print_internal(struct isl_basic_setisl_basic_map *bset,
3293 FILE *out, int indent)
3294{
3295 if (!bset) {
3296 fprintf(out, "null basic set\n");
3297 return;
3298 }
3299
3300 fprintf(out, "%*s", indent, "");
3301 fprintf(out, "ref: %d, nparam: %d, dim: %d, extra: %d, flags: %x\n",
3302 bset->ref, bset->dim->nparam, bset->dim->n_out,
3303 bset->extra, bset->flags);
3304 dump(bset_to_bmap(bset), out, indent);
3305}
3306
3307void isl_basic_map_print_internal(struct isl_basic_map *bmap,
3308 FILE *out, int indent)
3309{
3310 if (!bmap) {
3311 fprintf(out, "null basic map\n");
3312 return;
3313 }
3314
3315 fprintf(out, "%*s", indent, "");
3316 fprintf(out, "ref: %d, nparam: %d, in: %d, out: %d, extra: %d, "
3317 "flags: %x, n_name: %d\n",
3318 bmap->ref,
3319 bmap->dim->nparam, bmap->dim->n_in, bmap->dim->n_out,
3320 bmap->extra, bmap->flags, bmap->dim->n_id);
3321 dump(bmap, out, indent);
3322}
3323
3324int isl_inequality_negate(struct isl_basic_map *bmap, unsigned pos)
3325{
3326 unsigned total;
3327 if (!bmap)
3328 return -1;
3329 total = isl_basic_map_total_dim(bmap);
3330 isl_assert(bmap->ctx, pos < bmap->n_ineq, return -1)do { if (pos < bmap->n_ineq) break; do { isl_handle_error
(bmap->ctx, isl_error_unknown, "Assertion \"" "pos < bmap->n_ineq"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3330); return -1; } while (0); } while (0)
;
3331 isl_seq_neg(bmap->ineq[pos], bmap->ineq[pos], 1 + total);
3332 isl_int_sub_ui(bmap->ineq[pos][0], bmap->ineq[pos][0], 1)isl_sioimath_sub_ui((bmap->ineq[pos][0]), *(bmap->ineq[
pos][0]), 1)
;
3333 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
3334 return 0;
3335}
3336
3337__isl_give isl_setisl_map *isl_set_alloc_space(__isl_take isl_space *space, int n,
3338 unsigned flags)
3339{
3340 if (!space)
3341 return NULL((void*)0);
3342 if (isl_space_dim(space, isl_dim_in) != 0)
3343 isl_die(isl_space_get_ctx(space), isl_error_invalid,do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid
, "set cannot have input dimensions", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3344); goto error; } while (0)
3344 "set cannot have input dimensions", goto error)do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid
, "set cannot have input dimensions", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3344); goto error; } while (0)
;
3345 return isl_map_alloc_space(space, n, flags);
3346error:
3347 isl_space_free(space);
3348 return NULL((void*)0);
3349}
3350
3351/* Make sure "map" has room for at least "n" more basic maps.
3352 */
3353__isl_give isl_map *isl_map_grow(__isl_take isl_map *map, int n)
3354{
3355 int i;
3356 struct isl_map *grown = NULL((void*)0);
3357
3358 if (!map)
3359 return NULL((void*)0);
3360 isl_assert(map->ctx, n >= 0, goto error)do { if (n >= 0) break; do { isl_handle_error(map->ctx,
isl_error_unknown, "Assertion \"" "n >= 0" "\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3360); goto error; } while (0); } while (0)
;
3361 if (map->n + n <= map->size)
3362 return map;
3363 grown = isl_map_alloc_space(isl_map_get_space(map), map->n + n, map->flags);
3364 if (!grown)
3365 goto error;
3366 for (i = 0; i < map->n; ++i) {
3367 grown->p[i] = isl_basic_map_copy(map->p[i]);
3368 if (!grown->p[i])
3369 goto error;
3370 grown->n++;
3371 }
3372 isl_map_free(map);
3373 return grown;
3374error:
3375 isl_map_free(grown);
3376 isl_map_free(map);
3377 return NULL((void*)0);
3378}
3379
3380/* Make sure "set" has room for at least "n" more basic sets.
3381 */
3382struct isl_setisl_map *isl_set_grow(struct isl_setisl_map *set, int n)
3383{
3384 return set_from_map(isl_map_grow(set_to_map(set), n));
3385}
3386
3387__isl_give isl_setisl_map *isl_set_from_basic_set(__isl_take isl_basic_setisl_basic_map *bset)
3388{
3389 return isl_map_from_basic_map(bset);
3390}
3391
3392__isl_give isl_map *isl_map_from_basic_map(__isl_take isl_basic_map *bmap)
3393{
3394 struct isl_map *map;
3395
3396 if (!bmap)
3397 return NULL((void*)0);
3398
3399 map = isl_map_alloc_space(isl_space_copy(bmap->dim), 1, ISL_MAP_DISJOINT(1 << 0));
3400 return isl_map_add_basic_map(map, bmap);
3401}
3402
3403__isl_give isl_setisl_map *isl_set_add_basic_set(__isl_take isl_setisl_map *set,
3404 __isl_take isl_basic_setisl_basic_map *bset)
3405{
3406 return set_from_map(isl_map_add_basic_map(set_to_map(set),
3407 bset_to_bmap(bset)));
3408}
3409
3410__isl_null isl_setisl_map *isl_set_free(__isl_take isl_setisl_map *set)
3411{
3412 return isl_map_free(set);
3413}
3414
3415void isl_set_print_internal(struct isl_setisl_map *set, FILE *out, int indent)
3416{
3417 int i;
3418
3419 if (!set) {
3420 fprintf(out, "null set\n");
3421 return;
3422 }
3423
3424 fprintf(out, "%*s", indent, "");
3425 fprintf(out, "ref: %d, n: %d, nparam: %d, dim: %d, flags: %x\n",
3426 set->ref, set->n, set->dim->nparam, set->dim->n_out,
3427 set->flags);
3428 for (i = 0; i < set->n; ++i) {
3429 fprintf(out, "%*s", indent, "");
3430 fprintf(out, "basic set %d:\n", i);
3431 isl_basic_set_print_internal(set->p[i], out, indent+4);
3432 }
3433}
3434
3435void isl_map_print_internal(struct isl_map *map, FILE *out, int indent)
3436{
3437 int i;
3438
3439 if (!map) {
3440 fprintf(out, "null map\n");
3441 return;
3442 }
3443
3444 fprintf(out, "%*s", indent, "");
3445 fprintf(out, "ref: %d, n: %d, nparam: %d, in: %d, out: %d, "
3446 "flags: %x, n_name: %d\n",
3447 map->ref, map->n, map->dim->nparam, map->dim->n_in,
3448 map->dim->n_out, map->flags, map->dim->n_id);
3449 for (i = 0; i < map->n; ++i) {
3450 fprintf(out, "%*s", indent, "");
3451 fprintf(out, "basic map %d:\n", i);
3452 isl_basic_map_print_internal(map->p[i], out, indent+4);
3453 }
3454}
3455
3456__isl_give isl_basic_map *isl_basic_map_intersect_domain(
3457 __isl_take isl_basic_map *bmap, __isl_take isl_basic_setisl_basic_map *bset)
3458{
3459 struct isl_basic_map *bmap_domain;
3460
3461 if (isl_basic_map_check_equal_params(bmap, bset_to_bmap(bset)) < 0)
3462 goto error;
3463
3464 if (isl_space_dim(bset->dim, isl_dim_set) != 0)
3465 isl_assert(bset->ctx,do { if (isl_basic_map_compatible_domain(bmap, bset)) break; do
{ isl_handle_error(bset->ctx, isl_error_unknown, "Assertion \""
"isl_basic_map_compatible_domain(bmap, bset)" "\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3466); goto error; } while (0); } while (0)
3466 isl_basic_map_compatible_domain(bmap, bset), goto error)do { if (isl_basic_map_compatible_domain(bmap, bset)) break; do
{ isl_handle_error(bset->ctx, isl_error_unknown, "Assertion \""
"isl_basic_map_compatible_domain(bmap, bset)" "\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3466); goto error; } while (0); } while (0)
;
3467
3468 bmap = isl_basic_map_cow(bmap);
3469 if (!bmap)
3470 goto error;
3471 bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim),
3472 bset->n_div, bset->n_eq, bset->n_ineq);
3473 bmap_domain = isl_basic_map_from_domain(bset);
3474 bmap = add_constraints(bmap, bmap_domain, 0, 0);
3475
3476 bmap = isl_basic_map_simplify(bmap);
3477 return isl_basic_map_finalize(bmap);
3478error:
3479 isl_basic_map_free(bmap);
3480 isl_basic_set_free(bset);
3481 return NULL((void*)0);
3482}
3483
3484/* Check that the space of "bset" is the same as that of the range of "bmap".
3485 */
3486static isl_stat isl_basic_map_check_compatible_range(
3487 __isl_keep isl_basic_map *bmap, __isl_keep isl_basic_setisl_basic_map *bset)
3488{
3489 isl_bool ok;
3490
3491 ok = isl_basic_map_compatible_range(bmap, bset);
3492 if (ok < 0)
3493 return isl_stat_error;
3494 if (!ok)
3495 isl_die(isl_basic_set_get_ctx(bset), isl_error_invalid,do { isl_handle_error(isl_basic_set_get_ctx(bset), isl_error_invalid
, "incompatible spaces", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3496); return isl_stat_error; } while (0)
3496 "incompatible spaces", return isl_stat_error)do { isl_handle_error(isl_basic_set_get_ctx(bset), isl_error_invalid
, "incompatible spaces", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3496); return isl_stat_error; } while (0)
;
3497
3498 return isl_stat_ok;
3499}
3500
3501__isl_give isl_basic_map *isl_basic_map_intersect_range(
3502 __isl_take isl_basic_map *bmap, __isl_take isl_basic_setisl_basic_map *bset)
3503{
3504 struct isl_basic_map *bmap_range;
3505
3506 if (isl_basic_map_check_equal_params(bmap, bset_to_bmap(bset)) < 0)
3507 goto error;
3508
3509 if (isl_space_dim(bset->dim, isl_dim_set) != 0 &&
3510 isl_basic_map_check_compatible_range(bmap, bset) < 0)
3511 goto error;
3512
3513 if (isl_basic_set_plain_is_universe(bset)) {
3514 isl_basic_set_free(bset);
3515 return bmap;
3516 }
3517
3518 bmap = isl_basic_map_cow(bmap);
3519 if (!bmap)
3520 goto error;
3521 bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim),
3522 bset->n_div, bset->n_eq, bset->n_ineq);
3523 bmap_range = bset_to_bmap(bset);
3524 bmap = add_constraints(bmap, bmap_range, 0, 0);
3525
3526 bmap = isl_basic_map_simplify(bmap);
3527 return isl_basic_map_finalize(bmap);
3528error:
3529 isl_basic_map_free(bmap);
3530 isl_basic_set_free(bset);
3531 return NULL((void*)0);
3532}
3533
3534isl_bool isl_basic_map_contains(__isl_keep isl_basic_map *bmap,
3535 __isl_keep isl_vec *vec)
3536{
3537 int i;
3538 unsigned total;
3539 isl_int s;
3540
3541 if (!bmap || !vec)
3542 return isl_bool_error;
3543
3544 total = 1 + isl_basic_map_total_dim(bmap);
3545 if (total != vec->size)
3546 return isl_bool_false;
3547
3548 isl_int_init(s)isl_sioimath_init((s));
3549
3550 for (i = 0; i < bmap->n_eq; ++i) {
3551 isl_seq_inner_product(vec->el, bmap->eq[i], total, &s);
3552 if (!isl_int_is_zero(s)(isl_sioimath_sgn(*(s)) == 0)) {
3553 isl_int_clear(s)isl_sioimath_clear((s));
3554 return isl_bool_false;
3555 }
3556 }
3557
3558 for (i = 0; i < bmap->n_ineq; ++i) {
3559 isl_seq_inner_product(vec->el, bmap->ineq[i], total, &s);
3560 if (isl_int_is_neg(s)(isl_sioimath_sgn(*(s)) < 0)) {
3561 isl_int_clear(s)isl_sioimath_clear((s));
3562 return isl_bool_false;
3563 }
3564 }
3565
3566 isl_int_clear(s)isl_sioimath_clear((s));
3567
3568 return isl_bool_true;
3569}
3570
3571isl_bool isl_basic_set_contains(__isl_keep isl_basic_setisl_basic_map *bset,
3572 __isl_keep isl_vec *vec)
3573{
3574 return isl_basic_map_contains(bset_to_bmap(bset), vec);
3575}
3576
3577__isl_give isl_basic_map *isl_basic_map_intersect(
3578 __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
3579{
3580 struct isl_vec *sample = NULL((void*)0);
3581
3582 if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
3583 goto error;
3584 if (isl_space_dim(bmap1->dim, isl_dim_all) ==
3585 isl_space_dim(bmap1->dim, isl_dim_param) &&
3586 isl_space_dim(bmap2->dim, isl_dim_all) !=
3587 isl_space_dim(bmap2->dim, isl_dim_param))
3588 return isl_basic_map_intersect(bmap2, bmap1);
3589
3590 if (isl_space_dim(bmap2->dim, isl_dim_all) !=
3591 isl_space_dim(bmap2->dim, isl_dim_param))
3592 isl_assert(bmap1->ctx,do { if (isl_space_is_equal(bmap1->dim, bmap2->dim)) break
; do { isl_handle_error(bmap1->ctx, isl_error_unknown, "Assertion \""
"isl_space_is_equal(bmap1->dim, bmap2->dim)" "\" failed"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3593); goto error; } while (0); } while (0)
3593 isl_space_is_equal(bmap1->dim, bmap2->dim), goto error)do { if (isl_space_is_equal(bmap1->dim, bmap2->dim)) break
; do { isl_handle_error(bmap1->ctx, isl_error_unknown, "Assertion \""
"isl_space_is_equal(bmap1->dim, bmap2->dim)" "\" failed"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3593); goto error; } while (0); } while (0)
;
3594
3595 if (isl_basic_map_plain_is_empty(bmap1)) {
3596 isl_basic_map_free(bmap2);
3597 return bmap1;
3598 }
3599 if (isl_basic_map_plain_is_empty(bmap2)) {
3600 isl_basic_map_free(bmap1);
3601 return bmap2;
3602 }
3603
3604 if (bmap1->sample &&
3605 isl_basic_map_contains(bmap1, bmap1->sample) > 0 &&
3606 isl_basic_map_contains(bmap2, bmap1->sample) > 0)
3607 sample = isl_vec_copy(bmap1->sample);
3608 else if (bmap2->sample &&
3609 isl_basic_map_contains(bmap1, bmap2->sample) > 0 &&
3610 isl_basic_map_contains(bmap2, bmap2->sample) > 0)
3611 sample = isl_vec_copy(bmap2->sample);
3612
3613 bmap1 = isl_basic_map_cow(bmap1);
3614 if (!bmap1)
3615 goto error;
3616 bmap1 = isl_basic_map_extend_space(bmap1, isl_space_copy(bmap1->dim),
3617 bmap2->n_div, bmap2->n_eq, bmap2->n_ineq);
3618 bmap1 = add_constraints(bmap1, bmap2, 0, 0);
3619
3620 if (!bmap1)
3621 isl_vec_free(sample);
3622 else if (sample) {
3623 isl_vec_free(bmap1->sample);
3624 bmap1->sample = sample;
3625 }
3626
3627 bmap1 = isl_basic_map_simplify(bmap1);
3628 return isl_basic_map_finalize(bmap1);
3629error:
3630 if (sample)
3631 isl_vec_free(sample);
3632 isl_basic_map_free(bmap1);
3633 isl_basic_map_free(bmap2);
3634 return NULL((void*)0);
3635}
3636
3637struct isl_basic_setisl_basic_map *isl_basic_set_intersect(
3638 struct isl_basic_setisl_basic_map *bset1, struct isl_basic_setisl_basic_map *bset2)
3639{
3640 return bset_from_bmap(isl_basic_map_intersect(bset_to_bmap(bset1),
3641 bset_to_bmap(bset2)));
3642}
3643
3644__isl_give isl_basic_setisl_basic_map *isl_basic_set_intersect_params(
3645 __isl_take isl_basic_setisl_basic_map *bset1, __isl_take isl_basic_setisl_basic_map *bset2)
3646{
3647 return isl_basic_set_intersect(bset1, bset2);
3648}
3649
3650/* Special case of isl_map_intersect, where both map1 and map2
3651 * are convex, without any divs and such that either map1 or map2
3652 * contains a single constraint. This constraint is then simply
3653 * added to the other map.
3654 */
3655static __isl_give isl_map *map_intersect_add_constraint(
3656 __isl_take isl_map *map1, __isl_take isl_map *map2)
3657{
3658 isl_assert(map1->ctx, map1->n == 1, goto error)do { if (map1->n == 1) break; do { isl_handle_error(map1->
ctx, isl_error_unknown, "Assertion \"" "map1->n == 1" "\" failed"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3658); goto error; } while (0); } while (0)
;
3659 isl_assert(map2->ctx, map1->n == 1, goto error)do { if (map1->n == 1) break; do { isl_handle_error(map2->
ctx, isl_error_unknown, "Assertion \"" "map1->n == 1" "\" failed"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3659); goto error; } while (0); } while (0)
;
3660 isl_assert(map1->ctx, map1->p[0]->n_div == 0, goto error)do { if (map1->p[0]->n_div == 0) break; do { isl_handle_error
(map1->ctx, isl_error_unknown, "Assertion \"" "map1->p[0]->n_div == 0"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3660); goto error; } while (0); } while (0)
;
3661 isl_assert(map2->ctx, map1->p[0]->n_div == 0, goto error)do { if (map1->p[0]->n_div == 0) break; do { isl_handle_error
(map2->ctx, isl_error_unknown, "Assertion \"" "map1->p[0]->n_div == 0"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3661); goto error; } while (0); } while (0)
;
3662
3663 if (map2->p[0]->n_eq + map2->p[0]->n_ineq != 1)
3664 return isl_map_intersect(map2, map1);
3665
3666 map1 = isl_map_cow(map1);
3667 if (!map1)
3668 goto error;
3669 if (isl_map_plain_is_empty(map1)) {
3670 isl_map_free(map2);
3671 return map1;
3672 }
3673 map1->p[0] = isl_basic_map_cow(map1->p[0]);
3674 if (map2->p[0]->n_eq == 1)
3675 map1->p[0] = isl_basic_map_add_eq(map1->p[0], map2->p[0]->eq[0]);
3676 else
3677 map1->p[0] = isl_basic_map_add_ineq(map1->p[0],
3678 map2->p[0]->ineq[0]);
3679
3680 map1->p[0] = isl_basic_map_simplify(map1->p[0]);
3681 map1->p[0] = isl_basic_map_finalize(map1->p[0]);
3682 if (!map1->p[0])
3683 goto error;
3684
3685 if (isl_basic_map_plain_is_empty(map1->p[0])) {
3686 isl_basic_map_free(map1->p[0]);
3687 map1->n = 0;
3688 }
3689
3690 isl_map_free(map2);
3691
3692 return map1;
3693error:
3694 isl_map_free(map1);
3695 isl_map_free(map2);
3696 return NULL((void*)0);
3697}
3698
3699/* map2 may be either a parameter domain or a map living in the same
3700 * space as map1.
3701 */
3702static __isl_give isl_map *map_intersect_internal(__isl_take isl_map *map1,
3703 __isl_take isl_map *map2)
3704{
3705 unsigned flags = 0;
3706 isl_map *result;
3707 int i, j;
3708
3709 if (!map1 || !map2)
13
Taking false branch
3710 goto error;
3711
3712 if ((isl_map_plain_is_empty(map1) ||
25
Taking false branch
3713 isl_map_plain_is_universe(map2)) &&
14
Calling 'isl_map_plain_is_universe'
23
Returning from 'isl_map_plain_is_universe'
3714 isl_space_is_equal(map1->dim, map2->dim)) {
24
Assuming the condition is false
3715 isl_map_free(map2);
3716 return map1;
3717 }
3718 if ((isl_map_plain_is_empty(map2) ||
3719 isl_map_plain_is_universe(map1)) &&
3720 isl_space_is_equal(map1->dim, map2->dim)) {
3721 isl_map_free(map1);
3722 return map2;
3723 }
3724
3725 if (map1->n == 1 && map2->n == 1 &&
26
Assuming the condition is true
3726 map1->p[0]->n_div == 0 && map2->p[0]->n_div == 0 &&
27
Assuming the condition is true
28
Access to field 'n_div' results in a dereference of a null pointer
3727 isl_space_is_equal(map1->dim, map2->dim) &&
3728 (map1->p[0]->n_eq + map1->p[0]->n_ineq == 1 ||
3729 map2->p[0]->n_eq + map2->p[0]->n_ineq == 1))
3730 return map_intersect_add_constraint(map1, map2);
3731
3732 if (isl_space_dim(map2->dim, isl_dim_all) !=
3733 isl_space_dim(map2->dim, isl_dim_param))
3734 isl_assert(map1->ctx,do { if (isl_space_is_equal(map1->dim, map2->dim)) break
; do { isl_handle_error(map1->ctx, isl_error_unknown, "Assertion \""
"isl_space_is_equal(map1->dim, map2->dim)" "\" failed"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3735); goto error; } while (0); } while (0)
3735 isl_space_is_equal(map1->dim, map2->dim), goto error)do { if (isl_space_is_equal(map1->dim, map2->dim)) break
; do { isl_handle_error(map1->ctx, isl_error_unknown, "Assertion \""
"isl_space_is_equal(map1->dim, map2->dim)" "\" failed"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3735); goto error; } while (0); } while (0)
;
3736
3737 if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT)(!!(((map1)->flags) & ((1 << 0)))) &&
3738 ISL_F_ISSET(map2, ISL_MAP_DISJOINT)(!!(((map2)->flags) & ((1 << 0)))))
3739 ISL_FL_SET(flags, ISL_MAP_DISJOINT)((flags) |= ((1 << 0)));
3740
3741 result = isl_map_alloc_space(isl_space_copy(map1->dim),
3742 map1->n * map2->n, flags);
3743 if (!result)
3744 goto error;
3745 for (i = 0; i < map1->n; ++i)
3746 for (j = 0; j < map2->n; ++j) {
3747 struct isl_basic_map *part;
3748 part = isl_basic_map_intersect(
3749 isl_basic_map_copy(map1->p[i]),
3750 isl_basic_map_copy(map2->p[j]));
3751 if (isl_basic_map_is_empty(part) < 0)
3752 part = isl_basic_map_free(part);
3753 result = isl_map_add_basic_map(result, part);
3754 if (!result)
3755 goto error;
3756 }
3757 isl_map_free(map1);
3758 isl_map_free(map2);
3759 return result;
3760error:
3761 isl_map_free(map1);
3762 isl_map_free(map2);
3763 return NULL((void*)0);
3764}
3765
3766static __isl_give isl_map *map_intersect(__isl_take isl_map *map1,
3767 __isl_take isl_map *map2)
3768{
3769 if (!map1 || !map2)
9
Taking false branch
3770 goto error;
3771 if (!isl_space_is_equal(map1->dim, map2->dim))
10
Assuming the condition is false
11
Taking false branch
3772 isl_die(isl_map_get_ctx(map1), isl_error_invalid,do { isl_handle_error(isl_map_get_ctx(map1), isl_error_invalid
, "spaces don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3773); goto error; } while (0)
3773 "spaces don't match", goto error)do { isl_handle_error(isl_map_get_ctx(map1), isl_error_invalid
, "spaces don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3773); goto error; } while (0)
;
3774 return map_intersect_internal(map1, map2);
12
Calling 'map_intersect_internal'
3775error:
3776 isl_map_free(map1);
3777 isl_map_free(map2);
3778 return NULL((void*)0);
3779}
3780
3781__isl_give isl_map *isl_map_intersect(__isl_take isl_map *map1,
3782 __isl_take isl_map *map2)
3783{
3784 return isl_map_align_params_map_map_and(map1, map2, &map_intersect);
3
Calling 'isl_map_align_params_map_map_and'
3785}
3786
3787struct isl_setisl_map *isl_set_intersect(struct isl_setisl_map *set1, struct isl_setisl_map *set2)
3788{
3789 return set_from_map(isl_map_intersect(set_to_map(set1),
3790 set_to_map(set2)));
3791}
3792
3793/* map_intersect_internal accepts intersections
3794 * with parameter domains, so we can just call that function.
3795 */
3796static __isl_give isl_map *map_intersect_params(__isl_take isl_map *map,
3797 __isl_take isl_setisl_map *params)
3798{
3799 return map_intersect_internal(map, params);
3800}
3801
3802__isl_give isl_map *isl_map_intersect_params(__isl_take isl_map *map1,
3803 __isl_take isl_map *map2)
3804{
3805 return isl_map_align_params_map_map_and(map1, map2, &map_intersect_params);
3806}
3807
3808__isl_give isl_setisl_map *isl_set_intersect_params(__isl_take isl_setisl_map *set,
3809 __isl_take isl_setisl_map *params)
3810{
3811 return isl_map_intersect_params(set, params);
3812}
3813
3814__isl_give isl_basic_map *isl_basic_map_reverse(__isl_take isl_basic_map *bmap)
3815{
3816 isl_space *space;
3817 unsigned pos, n1, n2;
3818
3819 if (!bmap)
3820 return NULL((void*)0);
3821 bmap = isl_basic_map_cow(bmap);
3822 if (!bmap)
3823 return NULL((void*)0);
3824 space = isl_space_reverse(isl_space_copy(bmap->dim));
3825 pos = isl_basic_map_offset(bmap, isl_dim_in);
3826 n1 = isl_basic_map_dim(bmap, isl_dim_in);
3827 n2 = isl_basic_map_dim(bmap, isl_dim_out);
3828 bmap = isl_basic_map_swap_vars(bmap, pos, n1, n2);
3829 return isl_basic_map_reset_space(bmap, space);
3830}
3831
3832static __isl_give isl_basic_map *basic_map_space_reset(
3833 __isl_take isl_basic_map *bmap, enum isl_dim_type type)
3834{
3835 isl_space *space;
3836
3837 if (!bmap)
3838 return NULL((void*)0);
3839 if (!isl_space_is_named_or_nested(bmap->dim, type))
3840 return bmap;
3841
3842 space = isl_basic_map_get_space(bmap);
3843 space = isl_space_reset(space, type);
3844 bmap = isl_basic_map_reset_space(bmap, space);
3845 return bmap;
3846}
3847
3848__isl_give isl_basic_map *isl_basic_map_insert_dims(
3849 __isl_take isl_basic_map *bmap, enum isl_dim_type type,
3850 unsigned pos, unsigned n)
3851{
3852 isl_bool rational;
3853 isl_space *res_dim;
3854 struct isl_basic_map *res;
3855 struct isl_dim_map *dim_map;
3856 unsigned total, off;
3857 enum isl_dim_type t;
3858
3859 if (n == 0)
3860 return basic_map_space_reset(bmap, type);
3861
3862 if (!bmap)
3863 return NULL((void*)0);
3864
3865 res_dim = isl_space_insert_dims(isl_basic_map_get_space(bmap), type, pos, n);
3866
3867 total = isl_basic_map_total_dim(bmap) + n;
3868 dim_map = isl_dim_map_alloc(bmap->ctx, total);
3869 off = 0;
3870 for (t = isl_dim_param; t <= isl_dim_out; ++t) {
3871 if (t != type) {
3872 isl_dim_map_dim(dim_map, bmap->dim, t, off);
3873 } else {
3874 unsigned size = isl_basic_map_dim(bmap, t);
3875 isl_dim_map_dim_range(dim_map, bmap->dim, t,
3876 0, pos, off);
3877 isl_dim_map_dim_range(dim_map, bmap->dim, t,
3878 pos, size - pos, off + pos + n);
3879 }
3880 off += isl_space_dim(res_dim, t);
3881 }
3882 isl_dim_map_div(dim_map, bmap, off);
3883
3884 res = isl_basic_map_alloc_space(res_dim,
3885 bmap->n_div, bmap->n_eq, bmap->n_ineq);
3886 rational = isl_basic_map_is_rational(bmap);
3887 if (rational < 0)
3888 res = isl_basic_map_free(res);
3889 if (rational)
3890 res = isl_basic_map_set_rational(res);
3891 if (isl_basic_map_plain_is_empty(bmap)) {
3892 isl_basic_map_free(bmap);
3893 free(dim_map);
3894 return isl_basic_map_set_to_empty(res);
3895 }
3896 res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
3897 return isl_basic_map_finalize(res);
3898}
3899
3900__isl_give isl_basic_setisl_basic_map *isl_basic_set_insert_dims(
3901 __isl_take isl_basic_setisl_basic_map *bset,
3902 enum isl_dim_type type, unsigned pos, unsigned n)
3903{
3904 return isl_basic_map_insert_dims(bset, type, pos, n);
3905}
3906
3907__isl_give isl_basic_map *isl_basic_map_add_dims(__isl_take isl_basic_map *bmap,
3908 enum isl_dim_type type, unsigned n)
3909{
3910 if (!bmap)
3911 return NULL((void*)0);
3912 return isl_basic_map_insert_dims(bmap, type,
3913 isl_basic_map_dim(bmap, type), n);
3914}
3915
3916__isl_give isl_basic_setisl_basic_map *isl_basic_set_add_dims(__isl_take isl_basic_setisl_basic_map *bset,
3917 enum isl_dim_type type, unsigned n)
3918{
3919 if (!bset)
3920 return NULL((void*)0);
3921 isl_assert(bset->ctx, type != isl_dim_in, goto error)do { if (type != isl_dim_in) break; do { isl_handle_error(bset
->ctx, isl_error_unknown, "Assertion \"" "type != isl_dim_in"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3921); goto error; } while (0); } while (0)
;
3922 return isl_basic_map_add_dims(bset, type, n);
3923error:
3924 isl_basic_set_free(bset);
3925 return NULL((void*)0);
3926}
3927
3928static __isl_give isl_map *map_space_reset(__isl_take isl_map *map,
3929 enum isl_dim_type type)
3930{
3931 isl_space *space;
3932
3933 if (!map || !isl_space_is_named_or_nested(map->dim, type))
3934 return map;
3935
3936 space = isl_map_get_space(map);
3937 space = isl_space_reset(space, type);
3938 map = isl_map_reset_space(map, space);
3939 return map;
3940}
3941
3942__isl_give isl_map *isl_map_insert_dims(__isl_take isl_map *map,
3943 enum isl_dim_type type, unsigned pos, unsigned n)
3944{
3945 int i;
3946
3947 if (n == 0)
3948 return map_space_reset(map, type);
3949
3950 map = isl_map_cow(map);
3951 if (!map)
3952 return NULL((void*)0);
3953
3954 map->dim = isl_space_insert_dims(map->dim, type, pos, n);
3955 if (!map->dim)
3956 goto error;
3957
3958 for (i = 0; i < map->n; ++i) {
3959 map->p[i] = isl_basic_map_insert_dims(map->p[i], type, pos, n);
3960 if (!map->p[i])
3961 goto error;
3962 }
3963
3964 return map;
3965error:
3966 isl_map_free(map);
3967 return NULL((void*)0);
3968}
3969
3970__isl_give isl_setisl_map *isl_set_insert_dims(__isl_take isl_setisl_map *set,
3971 enum isl_dim_type type, unsigned pos, unsigned n)
3972{
3973 return isl_map_insert_dims(set, type, pos, n);
3974}
3975
3976__isl_give isl_map *isl_map_add_dims(__isl_take isl_map *map,
3977 enum isl_dim_type type, unsigned n)
3978{
3979 if (!map)
3980 return NULL((void*)0);
3981 return isl_map_insert_dims(map, type, isl_map_dim(map, type), n);
3982}
3983
3984__isl_give isl_setisl_map *isl_set_add_dims(__isl_take isl_setisl_map *set,
3985 enum isl_dim_type type, unsigned n)
3986{
3987 if (!set)
3988 return NULL((void*)0);
3989 isl_assert(set->ctx, type != isl_dim_in, goto error)do { if (type != isl_dim_in) break; do { isl_handle_error(set
->ctx, isl_error_unknown, "Assertion \"" "type != isl_dim_in"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 3989); goto error; } while (0); } while (0)
;
3990 return set_from_map(isl_map_add_dims(set_to_map(set), type, n));
3991error:
3992 isl_set_free(set);
3993 return NULL((void*)0);
3994}
3995
3996__isl_give isl_basic_map *isl_basic_map_move_dims(
3997 __isl_take isl_basic_map *bmap,
3998 enum isl_dim_type dst_type, unsigned dst_pos,
3999 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
4000{
4001 struct isl_dim_map *dim_map;
4002 struct isl_basic_map *res;
4003 enum isl_dim_type t;
4004 unsigned total, off;
4005
4006 if (!bmap)
4007 return NULL((void*)0);
4008 if (n == 0) {
4009 bmap = isl_basic_map_reset(bmap, src_type);
4010 bmap = isl_basic_map_reset(bmap, dst_type);
4011 return bmap;
4012 }
4013
4014 if (isl_basic_map_check_range(bmap, src_type, src_pos, n) < 0)
4015 return isl_basic_map_free(bmap);
4016
4017 if (dst_type == src_type && dst_pos == src_pos)
4018 return bmap;
4019
4020 isl_assert(bmap->ctx, dst_type != src_type, goto error)do { if (dst_type != src_type) break; do { isl_handle_error(bmap
->ctx, isl_error_unknown, "Assertion \"" "dst_type != src_type"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4020); goto error; } while (0); } while (0)
;
4021
4022 if (pos(bmap->dim, dst_type) + dst_pos ==
4023 pos(bmap->dim, src_type) + src_pos +
4024 ((src_type < dst_type) ? n : 0)) {
4025 bmap = isl_basic_map_cow(bmap);
4026 if (!bmap)
4027 return NULL((void*)0);
4028
4029 bmap->dim = isl_space_move_dims(bmap->dim, dst_type, dst_pos,
4030 src_type, src_pos, n);
4031 if (!bmap->dim)
4032 goto error;
4033
4034 bmap = isl_basic_map_finalize(bmap);
4035
4036 return bmap;
4037 }
4038
4039 total = isl_basic_map_total_dim(bmap);
4040 dim_map = isl_dim_map_alloc(bmap->ctx, total);
4041
4042 off = 0;
4043 for (t = isl_dim_param; t <= isl_dim_out; ++t) {
4044 unsigned size = isl_space_dim(bmap->dim, t);
4045 if (t == dst_type) {
4046 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4047 0, dst_pos, off);
4048 off += dst_pos;
4049 isl_dim_map_dim_range(dim_map, bmap->dim, src_type,
4050 src_pos, n, off);
4051 off += n;
4052 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4053 dst_pos, size - dst_pos, off);
4054 off += size - dst_pos;
4055 } else if (t == src_type) {
4056 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4057 0, src_pos, off);
4058 off += src_pos;
4059 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4060 src_pos + n, size - src_pos - n, off);
4061 off += size - src_pos - n;
4062 } else {
4063 isl_dim_map_dim(dim_map, bmap->dim, t, off);
4064 off += size;
4065 }
4066 }
4067 isl_dim_map_div(dim_map, bmap, off);
4068
4069 res = isl_basic_map_alloc_space(isl_basic_map_get_space(bmap),
4070 bmap->n_div, bmap->n_eq, bmap->n_ineq);
4071 bmap = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
4072 if (!bmap)
4073 goto error;
4074
4075 bmap->dim = isl_space_move_dims(bmap->dim, dst_type, dst_pos,
4076 src_type, src_pos, n);
4077 if (!bmap->dim)
4078 goto error;
4079
4080 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
4081 bmap = isl_basic_map_gauss(bmap, NULL((void*)0));
4082 bmap = isl_basic_map_finalize(bmap);
4083
4084 return bmap;
4085error:
4086 isl_basic_map_free(bmap);
4087 return NULL((void*)0);
4088}
4089
4090__isl_give isl_basic_setisl_basic_map *isl_basic_set_move_dims(__isl_take isl_basic_setisl_basic_map *bset,
4091 enum isl_dim_type dst_type, unsigned dst_pos,
4092 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
4093{
4094 isl_basic_map *bmap = bset_to_bmap(bset);
4095 bmap = isl_basic_map_move_dims(bmap, dst_type, dst_pos,
4096 src_type, src_pos, n);
4097 return bset_from_bmap(bmap);
4098}
4099
4100__isl_give isl_setisl_map *isl_set_move_dims(__isl_take isl_setisl_map *set,
4101 enum isl_dim_type dst_type, unsigned dst_pos,
4102 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
4103{
4104 if (!set)
4105 return NULL((void*)0);
4106 isl_assert(set->ctx, dst_type != isl_dim_in, goto error)do { if (dst_type != isl_dim_in) break; do { isl_handle_error
(set->ctx, isl_error_unknown, "Assertion \"" "dst_type != isl_dim_in"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4106); goto error; } while (0); } while (0)
;
4107 return set_from_map(isl_map_move_dims(set_to_map(set),
4108 dst_type, dst_pos, src_type, src_pos, n));
4109error:
4110 isl_set_free(set);
4111 return NULL((void*)0);
4112}
4113
4114__isl_give isl_map *isl_map_move_dims(__isl_take isl_map *map,
4115 enum isl_dim_type dst_type, unsigned dst_pos,
4116 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
4117{
4118 int i;
4119
4120 if (!map)
4121 return NULL((void*)0);
4122 if (n == 0) {
4123 map = isl_map_reset(map, src_type);
4124 map = isl_map_reset(map, dst_type);
4125 return map;
4126 }
4127
4128 isl_assert(map->ctx, src_pos + n <= isl_map_dim(map, src_type),do { if (src_pos + n <= isl_map_dim(map, src_type)) break;
do { isl_handle_error(map->ctx, isl_error_unknown, "Assertion \""
"src_pos + n <= isl_map_dim(map, src_type)" "\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4129); goto error; } while (0); } while (0)
4129 goto error)do { if (src_pos + n <= isl_map_dim(map, src_type)) break;
do { isl_handle_error(map->ctx, isl_error_unknown, "Assertion \""
"src_pos + n <= isl_map_dim(map, src_type)" "\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4129); goto error; } while (0); } while (0)
;
4130
4131 if (dst_type == src_type && dst_pos == src_pos)
4132 return map;
4133
4134 isl_assert(map->ctx, dst_type != src_type, goto error)do { if (dst_type != src_type) break; do { isl_handle_error(map
->ctx, isl_error_unknown, "Assertion \"" "dst_type != src_type"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4134); goto error; } while (0); } while (0)
;
4135
4136 map = isl_map_cow(map);
4137 if (!map)
4138 return NULL((void*)0);
4139
4140 map->dim = isl_space_move_dims(map->dim, dst_type, dst_pos, src_type, src_pos, n);
4141 if (!map->dim)
4142 goto error;
4143
4144 for (i = 0; i < map->n; ++i) {
4145 map->p[i] = isl_basic_map_move_dims(map->p[i],
4146 dst_type, dst_pos,
4147 src_type, src_pos, n);
4148 if (!map->p[i])
4149 goto error;
4150 }
4151
4152 return map;
4153error:
4154 isl_map_free(map);
4155 return NULL((void*)0);
4156}
4157
4158/* Move the specified dimensions to the last columns right before
4159 * the divs. Don't change the dimension specification of bmap.
4160 * That's the responsibility of the caller.
4161 */
4162static __isl_give isl_basic_map *move_last(__isl_take isl_basic_map *bmap,
4163 enum isl_dim_type type, unsigned first, unsigned n)
4164{
4165 struct isl_dim_map *dim_map;
4166 struct isl_basic_map *res;
4167 enum isl_dim_type t;
4168 unsigned total, off;
4169
4170 if (!bmap)
4171 return NULL((void*)0);
4172 if (pos(bmap->dim, type) + first + n ==
4173 1 + isl_space_dim(bmap->dim, isl_dim_all))
4174 return bmap;
4175
4176 total = isl_basic_map_total_dim(bmap);
4177 dim_map = isl_dim_map_alloc(bmap->ctx, total);
4178
4179 off = 0;
4180 for (t = isl_dim_param; t <= isl_dim_out; ++t) {
4181 unsigned size = isl_space_dim(bmap->dim, t);
4182 if (t == type) {
4183 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4184 0, first, off);
4185 off += first;
4186 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4187 first, n, total - bmap->n_div - n);
4188 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4189 first + n, size - (first + n), off);
4190 off += size - (first + n);
4191 } else {
4192 isl_dim_map_dim(dim_map, bmap->dim, t, off);
4193 off += size;
4194 }
4195 }
4196 isl_dim_map_div(dim_map, bmap, off + n);
4197
4198 res = isl_basic_map_alloc_space(isl_basic_map_get_space(bmap),
4199 bmap->n_div, bmap->n_eq, bmap->n_ineq);
4200 res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
4201 return res;
4202}
4203
4204/* Insert "n" rows in the divs of "bmap".
4205 *
4206 * The number of columns is not changed, which means that the last
4207 * dimensions of "bmap" are being reintepreted as the new divs.
4208 * The space of "bmap" is not adjusted, however, which means
4209 * that "bmap" is left in an inconsistent state. Removing "n" dimensions
4210 * from the space of "bmap" is the responsibility of the caller.
4211 */
4212static __isl_give isl_basic_map *insert_div_rows(__isl_take isl_basic_map *bmap,
4213 int n)
4214{
4215 int i;
4216 size_t row_size;
4217 isl_int **new_div;
4218 isl_int *old;
4219
4220 bmap = isl_basic_map_cow(bmap);
4221 if (!bmap)
4222 return NULL((void*)0);
4223
4224 row_size = 1 + isl_space_dim(bmap->dim, isl_dim_all) + bmap->extra;
4225 old = bmap->block2.data;
4226 bmap->block2 = isl_blk_extend(bmap->ctx, bmap->block2,
4227 (bmap->extra + n) * (1 + row_size));
4228 if (!bmap->block2.data)
4229 return isl_basic_map_free(bmap);
4230 new_div = isl_alloc_array(bmap->ctx, isl_int *, bmap->extra + n)((isl_int * *)isl_malloc_or_die(bmap->ctx, (bmap->extra
+ n)*sizeof(isl_int *)))
;
4231 if (!new_div)
4232 return isl_basic_map_free(bmap);
4233 for (i = 0; i < n; ++i) {
4234 new_div[i] = bmap->block2.data +
4235 (bmap->extra + i) * (1 + row_size);
4236 isl_seq_clr(new_div[i], 1 + row_size);
4237 }
4238 for (i = 0; i < bmap->extra; ++i)
4239 new_div[n + i] = bmap->block2.data + (bmap->div[i] - old);
4240 free(bmap->div);
4241 bmap->div = new_div;
4242 bmap->n_div += n;
4243 bmap->extra += n;
4244
4245 return bmap;
4246}
4247
4248/* Drop constraints from "bmap" that only involve the variables
4249 * of "type" in the range [first, first + n] that are not related
4250 * to any of the variables outside that interval.
4251 * These constraints cannot influence the values for the variables
4252 * outside the interval, except in case they cause "bmap" to be empty.
4253 * Only drop the constraints if "bmap" is known to be non-empty.
4254 */
4255static __isl_give isl_basic_map *drop_irrelevant_constraints(
4256 __isl_take isl_basic_map *bmap, enum isl_dim_type type,
4257 unsigned first, unsigned n)
4258{
4259 int i;
4260 int *groups;
4261 unsigned dim, n_div;
4262 isl_bool non_empty;
4263
4264 non_empty = isl_basic_map_plain_is_non_empty(bmap);
4265 if (non_empty < 0)
4266 return isl_basic_map_free(bmap);
4267 if (!non_empty)
4268 return bmap;
4269
4270 dim = isl_basic_map_dim(bmap, isl_dim_all);
4271 n_div = isl_basic_map_dim(bmap, isl_dim_div);
4272 groups = isl_calloc_array(isl_basic_map_get_ctx(bmap), int, dim)((int *)isl_calloc_or_die(isl_basic_map_get_ctx(bmap), dim, sizeof
(int)))
;
4273 if (!groups)
4274 return isl_basic_map_free(bmap);
4275 first += isl_basic_map_offset(bmap, type) - 1;
4276 for (i = 0; i < first; ++i)
4277 groups[i] = -1;
4278 for (i = first + n; i < dim - n_div; ++i)
4279 groups[i] = -1;
4280
4281 bmap = isl_basic_map_drop_unrelated_constraints(bmap, groups);
4282
4283 return bmap;
4284}
4285
4286/* Turn the n dimensions of type type, starting at first
4287 * into existentially quantified variables.
4288 *
4289 * If a subset of the projected out variables are unrelated
4290 * to any of the variables that remain, then the constraints
4291 * involving this subset are simply dropped first.
4292 */
4293__isl_give isl_basic_map *isl_basic_map_project_out(
4294 __isl_take isl_basic_map *bmap,
4295 enum isl_dim_type type, unsigned first, unsigned n)
4296{
4297 isl_bool empty;
4298
4299 if (n == 0)
4300 return basic_map_space_reset(bmap, type);
4301 if (type == isl_dim_div)
4302 isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "cannot project out existentially quantified variables", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4304); return isl_basic_map_free(bmap); } while (0)
4303 "cannot project out existentially quantified variables",do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "cannot project out existentially quantified variables", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4304); return isl_basic_map_free(bmap); } while (0)
4304 return isl_basic_map_free(bmap))do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "cannot project out existentially quantified variables", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4304); return isl_basic_map_free(bmap); } while (0)
;
4305
4306 empty = isl_basic_map_plain_is_empty(bmap);
4307 if (empty < 0)
4308 return isl_basic_map_free(bmap);
4309 if (empty)
4310 bmap = isl_basic_map_set_to_empty(bmap);
4311
4312 bmap = drop_irrelevant_constraints(bmap, type, first, n);
4313 if (!bmap)
4314 return NULL((void*)0);
4315
4316 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)(!!(((bmap)->flags) & ((1 << 4)))))
4317 return isl_basic_map_remove_dims(bmap, type, first, n);
4318
4319 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
4320 return isl_basic_map_free(bmap);
4321
4322 bmap = move_last(bmap, type, first, n);
4323 bmap = isl_basic_map_cow(bmap);
4324 bmap = insert_div_rows(bmap, n);
4325 if (!bmap)
4326 return NULL((void*)0);
4327
4328 bmap->dim = isl_space_drop_dims(bmap->dim, type, first, n);
4329 if (!bmap->dim)
4330 goto error;
4331 bmap = isl_basic_map_simplify(bmap);
4332 bmap = isl_basic_map_drop_redundant_divs(bmap);
4333 return isl_basic_map_finalize(bmap);
4334error:
4335 isl_basic_map_free(bmap);
4336 return NULL((void*)0);
4337}
4338
4339/* Turn the n dimensions of type type, starting at first
4340 * into existentially quantified variables.
4341 */
4342struct isl_basic_setisl_basic_map *isl_basic_set_project_out(struct isl_basic_setisl_basic_map *bset,
4343 enum isl_dim_type type, unsigned first, unsigned n)
4344{
4345 return bset_from_bmap(isl_basic_map_project_out(bset_to_bmap(bset),
4346 type, first, n));
4347}
4348
4349/* Turn the n dimensions of type type, starting at first
4350 * into existentially quantified variables.
4351 */
4352__isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
4353 enum isl_dim_type type, unsigned first, unsigned n)
4354{
4355 int i;
4356
4357 if (!map)
4358 return NULL((void*)0);
4359
4360 if (n == 0)
4361 return map_space_reset(map, type);
4362
4363 isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error)do { if (first + n <= isl_map_dim(map, type)) break; do { isl_handle_error
(map->ctx, isl_error_unknown, "Assertion \"" "first + n <= isl_map_dim(map, type)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4363); goto error; } while (0); } while (0)
;
4364
4365 map = isl_map_cow(map);
4366 if (!map)
4367 return NULL((void*)0);
4368
4369 map->dim = isl_space_drop_dims(map->dim, type, first, n);
4370 if (!map->dim)
4371 goto error;
4372
4373 for (i = 0; i < map->n; ++i) {
4374 map->p[i] = isl_basic_map_project_out(map->p[i], type, first, n);
4375 if (!map->p[i])
4376 goto error;
4377 }
4378
4379 return map;
4380error:
4381 isl_map_free(map);
4382 return NULL((void*)0);
4383}
4384
4385/* Turn the n dimensions of type type, starting at first
4386 * into existentially quantified variables.
4387 */
4388__isl_give isl_setisl_map *isl_set_project_out(__isl_take isl_setisl_map *set,
4389 enum isl_dim_type type, unsigned first, unsigned n)
4390{
4391 return set_from_map(isl_map_project_out(set_to_map(set),
4392 type, first, n));
4393}
4394
4395/* Return a map that projects the elements in "set" onto their
4396 * "n" set dimensions starting at "first".
4397 * "type" should be equal to isl_dim_set.
4398 */
4399__isl_give isl_map *isl_set_project_onto_map(__isl_take isl_setisl_map *set,
4400 enum isl_dim_type type, unsigned first, unsigned n)
4401{
4402 int i;
4403 int dim;
4404 isl_map *map;
4405
4406 if (!set)
4407 return NULL((void*)0);
4408 if (type != isl_dim_set)
4409 isl_die(isl_set_get_ctx(set), isl_error_invalid,do { isl_handle_error(isl_set_get_ctx(set), isl_error_invalid
, "only set dimensions can be projected out", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4410); goto error; } while (0)
4410 "only set dimensions can be projected out", goto error)do { isl_handle_error(isl_set_get_ctx(set), isl_error_invalid
, "only set dimensions can be projected out", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4410); goto error; } while (0)
;
4411 dim = isl_set_dim(set, isl_dim_set);
4412 if (first + n > dim || first + n < first)
4413 isl_die(isl_set_get_ctx(set), isl_error_invalid,do { isl_handle_error(isl_set_get_ctx(set), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4414); goto error; } while (0)
4414 "index out of bounds", goto error)do { isl_handle_error(isl_set_get_ctx(set), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4414); goto error; } while (0)
;
4415
4416 map = isl_map_from_domain(set);
4417 map = isl_map_add_dims(map, isl_dim_out, n);
4418 for (i = 0; i < n; ++i)
4419 map = isl_map_equate(map, isl_dim_in, first + i,
4420 isl_dim_out, i);
4421 return map;
4422error:
4423 isl_set_free(set);
4424 return NULL((void*)0);
4425}
4426
4427static struct isl_basic_map *add_divs(struct isl_basic_map *bmap, unsigned n)
4428{
4429 int i, j;
4430
4431 for (i = 0; i < n; ++i) {
4432 j = isl_basic_map_alloc_div(bmap);
4433 if (j < 0)
4434 goto error;
4435 isl_seq_clr(bmap->div[j], 1+1+isl_basic_map_total_dim(bmap));
4436 }
4437 return bmap;
4438error:
4439 isl_basic_map_free(bmap);
4440 return NULL((void*)0);
4441}
4442
4443struct isl_basic_map *isl_basic_map_apply_range(
4444 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
4445{
4446 isl_space *dim_result = NULL((void*)0);
4447 struct isl_basic_map *bmap;
4448 unsigned n_in, n_out, n, nparam, total, pos;
4449 struct isl_dim_map *dim_map1, *dim_map2;
4450
4451 if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
4452 goto error;
4453 if (!isl_space_tuple_is_equal(bmap1->dim, isl_dim_out,
4454 bmap2->dim, isl_dim_in))
4455 isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid,do { isl_handle_error(isl_basic_map_get_ctx(bmap1), isl_error_invalid
, "spaces don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4456); goto error; } while (0)
4456 "spaces don't match", goto error)do { isl_handle_error(isl_basic_map_get_ctx(bmap1), isl_error_invalid
, "spaces don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4456); goto error; } while (0)
;
4457
4458 dim_result = isl_space_join(isl_space_copy(bmap1->dim),
4459 isl_space_copy(bmap2->dim));
4460
4461 n_in = isl_basic_map_dim(bmap1, isl_dim_in);
4462 n_out = isl_basic_map_dim(bmap2, isl_dim_out);
4463 n = isl_basic_map_dim(bmap1, isl_dim_out);
4464 nparam = isl_basic_map_dim(bmap1, isl_dim_param);
4465
4466 total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + n;
4467 dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
4468 dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
4469 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
4470 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
4471 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
4472 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_in);
4473 isl_dim_map_div(dim_map1, bmap1, pos += n_out);
4474 isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
4475 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
4476 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
4477
4478 bmap = isl_basic_map_alloc_space(dim_result,
4479 bmap1->n_div + bmap2->n_div + n,
4480 bmap1->n_eq + bmap2->n_eq,
4481 bmap1->n_ineq + bmap2->n_ineq);
4482 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
4483 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
4484 bmap = add_divs(bmap, n);
4485 bmap = isl_basic_map_simplify(bmap);
4486 bmap = isl_basic_map_drop_redundant_divs(bmap);
4487 return isl_basic_map_finalize(bmap);
4488error:
4489 isl_basic_map_free(bmap1);
4490 isl_basic_map_free(bmap2);
4491 return NULL((void*)0);
4492}
4493
4494struct isl_basic_setisl_basic_map *isl_basic_set_apply(
4495 struct isl_basic_setisl_basic_map *bset, struct isl_basic_map *bmap)
4496{
4497 if (!bset || !bmap)
4498 goto error;
4499
4500 isl_assert(bset->ctx, isl_basic_map_compatible_domain(bmap, bset),do { if (isl_basic_map_compatible_domain(bmap, bset)) break; do
{ isl_handle_error(bset->ctx, isl_error_unknown, "Assertion \""
"isl_basic_map_compatible_domain(bmap, bset)" "\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4501); goto error; } while (0); } while (0)
4501 goto error)do { if (isl_basic_map_compatible_domain(bmap, bset)) break; do
{ isl_handle_error(bset->ctx, isl_error_unknown, "Assertion \""
"isl_basic_map_compatible_domain(bmap, bset)" "\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4501); goto error; } while (0); } while (0)
;
4502
4503 return bset_from_bmap(isl_basic_map_apply_range(bset_to_bmap(bset),
4504 bmap));
4505error:
4506 isl_basic_set_free(bset);
4507 isl_basic_map_free(bmap);
4508 return NULL((void*)0);
4509}
4510
4511struct isl_basic_map *isl_basic_map_apply_domain(
4512 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
4513{
4514 if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
4515 goto error;
4516 if (!isl_space_tuple_is_equal(bmap1->dim, isl_dim_in,
4517 bmap2->dim, isl_dim_in))
4518 isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid,do { isl_handle_error(isl_basic_map_get_ctx(bmap1), isl_error_invalid
, "spaces don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4519); goto error; } while (0)
4519 "spaces don't match", goto error)do { isl_handle_error(isl_basic_map_get_ctx(bmap1), isl_error_invalid
, "spaces don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4519); goto error; } while (0)
;
4520
4521 bmap1 = isl_basic_map_reverse(bmap1);
4522 bmap1 = isl_basic_map_apply_range(bmap1, bmap2);
4523 return isl_basic_map_reverse(bmap1);
4524error:
4525 isl_basic_map_free(bmap1);
4526 isl_basic_map_free(bmap2);
4527 return NULL((void*)0);
4528}
4529
4530/* Given two basic maps A -> f(A) and B -> g(B), construct a basic map
4531 * A \cap B -> f(A) + f(B)
4532 */
4533__isl_give isl_basic_map *isl_basic_map_sum(__isl_take isl_basic_map *bmap1,
4534 __isl_take isl_basic_map *bmap2)
4535{
4536 unsigned n_in, n_out, nparam, total, pos;
4537 struct isl_basic_map *bmap = NULL((void*)0);
4538 struct isl_dim_map *dim_map1, *dim_map2;
4539 int i;
4540
4541 if (!bmap1 || !bmap2)
4542 goto error;
4543
4544 isl_assert(bmap1->ctx, isl_space_is_equal(bmap1->dim, bmap2->dim),do { if (isl_space_is_equal(bmap1->dim, bmap2->dim)) break
; do { isl_handle_error(bmap1->ctx, isl_error_unknown, "Assertion \""
"isl_space_is_equal(bmap1->dim, bmap2->dim)" "\" failed"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4545); goto error; } while (0); } while (0)
4545 goto error)do { if (isl_space_is_equal(bmap1->dim, bmap2->dim)) break
; do { isl_handle_error(bmap1->ctx, isl_error_unknown, "Assertion \""
"isl_space_is_equal(bmap1->dim, bmap2->dim)" "\" failed"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4545); goto error; } while (0); } while (0)
;
4546
4547 nparam = isl_basic_map_dim(bmap1, isl_dim_param);
4548 n_in = isl_basic_map_dim(bmap1, isl_dim_in);
4549 n_out = isl_basic_map_dim(bmap1, isl_dim_out);
4550
4551 total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + 2 * n_out;
4552 dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
4553 dim_map2 = isl_dim_map_alloc(bmap2->ctx, total);
4554 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
4555 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos);
4556 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
4557 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
4558 isl_dim_map_div(dim_map1, bmap1, pos += n_in + n_out);
4559 isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
4560 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
4561 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_out);
4562
4563 bmap = isl_basic_map_alloc_space(isl_space_copy(bmap1->dim),
4564 bmap1->n_div + bmap2->n_div + 2 * n_out,
4565 bmap1->n_eq + bmap2->n_eq + n_out,
4566 bmap1->n_ineq + bmap2->n_ineq);
4567 for (i = 0; i < n_out; ++i) {
4568 int j = isl_basic_map_alloc_equality(bmap);
4569 if (j < 0)
4570 goto error;
4571 isl_seq_clr(bmap->eq[j], 1+total);
4572 isl_int_set_si(bmap->eq[j][1+nparam+n_in+i], -1)isl_sioimath_set_si((bmap->eq[j][1+nparam+n_in+i]), -1);
4573 isl_int_set_si(bmap->eq[j][1+pos+i], 1)isl_sioimath_set_si((bmap->eq[j][1+pos+i]), 1);
4574 isl_int_set_si(bmap->eq[j][1+pos-n_out+i], 1)isl_sioimath_set_si((bmap->eq[j][1+pos-n_out+i]), 1);
4575 }
4576 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
4577 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
4578 bmap = add_divs(bmap, 2 * n_out);
4579
4580 bmap = isl_basic_map_simplify(bmap);
4581 return isl_basic_map_finalize(bmap);
4582error:
4583 isl_basic_map_free(bmap);
4584 isl_basic_map_free(bmap1);
4585 isl_basic_map_free(bmap2);
4586 return NULL((void*)0);
4587}
4588
4589/* Given two maps A -> f(A) and B -> g(B), construct a map
4590 * A \cap B -> f(A) + f(B)
4591 */
4592__isl_give isl_map *isl_map_sum(__isl_take isl_map *map1,
4593 __isl_take isl_map *map2)
4594{
4595 struct isl_map *result;
4596 int i, j;
4597
4598 if (!map1 || !map2)
4599 goto error;
4600
4601 isl_assert(map1->ctx, isl_space_is_equal(map1->dim, map2->dim), goto error)do { if (isl_space_is_equal(map1->dim, map2->dim)) break
; do { isl_handle_error(map1->ctx, isl_error_unknown, "Assertion \""
"isl_space_is_equal(map1->dim, map2->dim)" "\" failed"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4601); goto error; } while (0); } while (0)
;
4602
4603 result = isl_map_alloc_space(isl_space_copy(map1->dim),
4604 map1->n * map2->n, 0);
4605 if (!result)
4606 goto error;
4607 for (i = 0; i < map1->n; ++i)
4608 for (j = 0; j < map2->n; ++j) {
4609 struct isl_basic_map *part;
4610 part = isl_basic_map_sum(
4611 isl_basic_map_copy(map1->p[i]),
4612 isl_basic_map_copy(map2->p[j]));
4613 if (isl_basic_map_is_empty(part))
4614 isl_basic_map_free(part);
4615 else
4616 result = isl_map_add_basic_map(result, part);
4617 if (!result)
4618 goto error;
4619 }
4620 isl_map_free(map1);
4621 isl_map_free(map2);
4622 return result;
4623error:
4624 isl_map_free(map1);
4625 isl_map_free(map2);
4626 return NULL((void*)0);
4627}
4628
4629__isl_give isl_setisl_map *isl_set_sum(__isl_take isl_setisl_map *set1,
4630 __isl_take isl_setisl_map *set2)
4631{
4632 return set_from_map(isl_map_sum(set_to_map(set1), set_to_map(set2)));
4633}
4634
4635/* Given a basic map A -> f(A), construct A -> -f(A).
4636 */
4637__isl_give isl_basic_map *isl_basic_map_neg(__isl_take isl_basic_map *bmap)
4638{
4639 int i, j;
4640 unsigned off, n;
4641
4642 bmap = isl_basic_map_cow(bmap);
4643 if (!bmap)
4644 return NULL((void*)0);
4645
4646 n = isl_basic_map_dim(bmap, isl_dim_out);
4647 off = isl_basic_map_offset(bmap, isl_dim_out);
4648 for (i = 0; i < bmap->n_eq; ++i)
4649 for (j = 0; j < n; ++j)
4650 isl_int_neg(bmap->eq[i][off+j], bmap->eq[i][off+j])isl_sioimath_neg((bmap->eq[i][off+j]), *(bmap->eq[i][off
+j]))
;
4651 for (i = 0; i < bmap->n_ineq; ++i)
4652 for (j = 0; j < n; ++j)
4653 isl_int_neg(bmap->ineq[i][off+j], bmap->ineq[i][off+j])isl_sioimath_neg((bmap->ineq[i][off+j]), *(bmap->ineq[i
][off+j]))
;
4654 for (i = 0; i < bmap->n_div; ++i)
4655 for (j = 0; j < n; ++j)
4656 isl_int_neg(bmap->div[i][1+off+j], bmap->div[i][1+off+j])isl_sioimath_neg((bmap->div[i][1+off+j]), *(bmap->div[i
][1+off+j]))
;
4657 bmap = isl_basic_map_gauss(bmap, NULL((void*)0));
4658 return isl_basic_map_finalize(bmap);
4659}
4660
4661__isl_give isl_basic_setisl_basic_map *isl_basic_set_neg(__isl_take isl_basic_setisl_basic_map *bset)
4662{
4663 return isl_basic_map_neg(bset);
4664}
4665
4666/* Given a map A -> f(A), construct A -> -f(A).
4667 */
4668__isl_give isl_map *isl_map_neg(__isl_take isl_map *map)
4669{
4670 int i;
4671
4672 map = isl_map_cow(map);
4673 if (!map)
4674 return NULL((void*)0);
4675
4676 for (i = 0; i < map->n; ++i) {
4677 map->p[i] = isl_basic_map_neg(map->p[i]);
4678 if (!map->p[i])
4679 goto error;
4680 }
4681
4682 return map;
4683error:
4684 isl_map_free(map);
4685 return NULL((void*)0);
4686}
4687
4688__isl_give isl_setisl_map *isl_set_neg(__isl_take isl_setisl_map *set)
4689{
4690 return set_from_map(isl_map_neg(set_to_map(set)));
4691}
4692
4693/* Given a basic map A -> f(A) and an integer d, construct a basic map
4694 * A -> floor(f(A)/d).
4695 */
4696__isl_give isl_basic_map *isl_basic_map_floordiv(__isl_take isl_basic_map *bmap,
4697 isl_int d)
4698{
4699 unsigned n_in, n_out, nparam, total, pos;
4700 struct isl_basic_map *result = NULL((void*)0);
4701 struct isl_dim_map *dim_map;
4702 int i;
4703
4704 if (!bmap)
4705 return NULL((void*)0);
4706
4707 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4708 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4709 n_out = isl_basic_map_dim(bmap, isl_dim_out);
4710
4711 total = nparam + n_in + n_out + bmap->n_div + n_out;
4712 dim_map = isl_dim_map_alloc(bmap->ctx, total);
4713 isl_dim_map_dim(dim_map, bmap->dim, isl_dim_param, pos = 0);
4714 isl_dim_map_dim(dim_map, bmap->dim, isl_dim_in, pos += nparam);
4715 isl_dim_map_div(dim_map, bmap, pos += n_in + n_out);
4716 isl_dim_map_dim(dim_map, bmap->dim, isl_dim_out, pos += bmap->n_div);
4717
4718 result = isl_basic_map_alloc_space(isl_space_copy(bmap->dim),
4719 bmap->n_div + n_out,
4720 bmap->n_eq, bmap->n_ineq + 2 * n_out);
4721 result = isl_basic_map_add_constraints_dim_map(result, bmap, dim_map);
4722 result = add_divs(result, n_out);
4723 for (i = 0; i < n_out; ++i) {
4724 int j;
4725 j = isl_basic_map_alloc_inequality(result);
4726 if (j < 0)
4727 goto error;
4728 isl_seq_clr(result->ineq[j], 1+total);
4729 isl_int_neg(result->ineq[j][1+nparam+n_in+i], d)isl_sioimath_neg((result->ineq[j][1+nparam+n_in+i]), *(d));
4730 isl_int_set_si(result->ineq[j][1+pos+i], 1)isl_sioimath_set_si((result->ineq[j][1+pos+i]), 1);
4731 j = isl_basic_map_alloc_inequality(result);
4732 if (j < 0)
4733 goto error;
4734 isl_seq_clr(result->ineq[j], 1+total);
4735 isl_int_set(result->ineq[j][1+nparam+n_in+i], d)isl_sioimath_set((result->ineq[j][1+nparam+n_in+i]), *(d));
4736 isl_int_set_si(result->ineq[j][1+pos+i], -1)isl_sioimath_set_si((result->ineq[j][1+pos+i]), -1);
4737 isl_int_sub_ui(result->ineq[j][0], d, 1)isl_sioimath_sub_ui((result->ineq[j][0]), *(d), 1);
4738 }
4739
4740 result = isl_basic_map_simplify(result);
4741 return isl_basic_map_finalize(result);
4742error:
4743 isl_basic_map_free(result);
4744 return NULL((void*)0);
4745}
4746
4747/* Given a map A -> f(A) and an integer d, construct a map
4748 * A -> floor(f(A)/d).
4749 */
4750__isl_give isl_map *isl_map_floordiv(__isl_take isl_map *map, isl_int d)
4751{
4752 int i;
4753
4754 map = isl_map_cow(map);
4755 if (!map)
4756 return NULL((void*)0);
4757
4758 ISL_F_CLR(map, ISL_MAP_DISJOINT)(((map)->flags) &= ~((1 << 0)));
4759 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
4760 for (i = 0; i < map->n; ++i) {
4761 map->p[i] = isl_basic_map_floordiv(map->p[i], d);
4762 if (!map->p[i])
4763 goto error;
4764 }
4765
4766 return map;
4767error:
4768 isl_map_free(map);
4769 return NULL((void*)0);
4770}
4771
4772/* Given a map A -> f(A) and an integer d, construct a map
4773 * A -> floor(f(A)/d).
4774 */
4775__isl_give isl_map *isl_map_floordiv_val(__isl_take isl_map *map,
4776 __isl_take isl_val *d)
4777{
4778 if (!map || !d)
4779 goto error;
4780 if (!isl_val_is_int(d))
4781 isl_die(isl_val_get_ctx(d), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(d), isl_error_invalid, "expecting integer denominator"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4782); goto error; } while (0)
4782 "expecting integer denominator", goto error)do { isl_handle_error(isl_val_get_ctx(d), isl_error_invalid, "expecting integer denominator"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 4782); goto error; } while (0)
;
4783 map = isl_map_floordiv(map, d->n);
4784 isl_val_free(d);
4785 return map;
4786error:
4787 isl_map_free(map);
4788 isl_val_free(d);
4789 return NULL((void*)0);
4790}
4791
4792static __isl_give isl_basic_map *var_equal(__isl_take isl_basic_map *bmap,
4793 unsigned pos)
4794{
4795 int i;
4796 unsigned nparam;
4797 unsigned n_in;
4798
4799 i = isl_basic_map_alloc_equality(bmap);
4800 if (i < 0)
4801 goto error;
4802 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4803 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4804 isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap));
4805 isl_int_set_si(bmap->eq[i][1+nparam+pos], -1)isl_sioimath_set_si((bmap->eq[i][1+nparam+pos]), -1);
4806 isl_int_set_si(bmap->eq[i][1+nparam+n_in+pos], 1)isl_sioimath_set_si((bmap->eq[i][1+nparam+n_in+pos]), 1);
4807 return isl_basic_map_finalize(bmap);
4808error:
4809 isl_basic_map_free(bmap);
4810 return NULL((void*)0);
4811}
4812
4813/* Add a constraint to "bmap" expressing i_pos < o_pos
4814 */
4815static __isl_give isl_basic_map *var_less(__isl_take isl_basic_map *bmap,
4816 unsigned pos)
4817{
4818 int i;
4819 unsigned nparam;
4820 unsigned n_in;
4821
4822 i = isl_basic_map_alloc_inequality(bmap);
4823 if (i < 0)
4824 goto error;
4825 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4826 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4827 isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
4828 isl_int_set_si(bmap->ineq[i][0], -1)isl_sioimath_set_si((bmap->ineq[i][0]), -1);
4829 isl_int_set_si(bmap->ineq[i][1+nparam+pos], -1)isl_sioimath_set_si((bmap->ineq[i][1+nparam+pos]), -1);
4830 isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], 1)isl_sioimath_set_si((bmap->ineq[i][1+nparam+n_in+pos]), 1);
4831 return isl_basic_map_finalize(bmap);
4832error:
4833 isl_basic_map_free(bmap);
4834 return NULL((void*)0);
4835}
4836
4837/* Add a constraint to "bmap" expressing i_pos <= o_pos
4838 */
4839static __isl_give isl_basic_map *var_less_or_equal(
4840 __isl_take isl_basic_map *bmap, unsigned pos)
4841{
4842 int i;
4843 unsigned nparam;
4844 unsigned n_in;
4845
4846 i = isl_basic_map_alloc_inequality(bmap);
4847 if (i < 0)
4848 goto error;
4849 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4850 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4851 isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
4852 isl_int_set_si(bmap->ineq[i][1+nparam+pos], -1)isl_sioimath_set_si((bmap->ineq[i][1+nparam+pos]), -1);
4853 isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], 1)isl_sioimath_set_si((bmap->ineq[i][1+nparam+n_in+pos]), 1);
4854 return isl_basic_map_finalize(bmap);
4855error:
4856 isl_basic_map_free(bmap);
4857 return NULL((void*)0);
4858}
4859
4860/* Add a constraint to "bmap" expressing i_pos > o_pos
4861 */
4862static __isl_give isl_basic_map *var_more(__isl_take isl_basic_map *bmap,
4863 unsigned pos)
4864{
4865 int i;
4866 unsigned nparam;
4867 unsigned n_in;
4868
4869 i = isl_basic_map_alloc_inequality(bmap);
4870 if (i < 0)
4871 goto error;
4872 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4873 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4874 isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
4875 isl_int_set_si(bmap->ineq[i][0], -1)isl_sioimath_set_si((bmap->ineq[i][0]), -1);
4876 isl_int_set_si(bmap->ineq[i][1+nparam+pos], 1)isl_sioimath_set_si((bmap->ineq[i][1+nparam+pos]), 1);
4877 isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], -1)isl_sioimath_set_si((bmap->ineq[i][1+nparam+n_in+pos]), -1
)
;
4878 return isl_basic_map_finalize(bmap);
4879error:
4880 isl_basic_map_free(bmap);
4881 return NULL((void*)0);
4882}
4883
4884/* Add a constraint to "bmap" expressing i_pos >= o_pos
4885 */
4886static __isl_give isl_basic_map *var_more_or_equal(
4887 __isl_take isl_basic_map *bmap, unsigned pos)
4888{
4889 int i;
4890 unsigned nparam;
4891 unsigned n_in;
4892
4893 i = isl_basic_map_alloc_inequality(bmap);
4894 if (i < 0)
4895 goto error;
4896 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4897 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4898 isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
4899 isl_int_set_si(bmap->ineq[i][1+nparam+pos], 1)isl_sioimath_set_si((bmap->ineq[i][1+nparam+pos]), 1);
4900 isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], -1)isl_sioimath_set_si((bmap->ineq[i][1+nparam+n_in+pos]), -1
)
;
4901 return isl_basic_map_finalize(bmap);
4902error:
4903 isl_basic_map_free(bmap);
4904 return NULL((void*)0);
4905}
4906
4907__isl_give isl_basic_map *isl_basic_map_equal(
4908 __isl_take isl_space *dim, unsigned n_equal)
4909{
4910 int i;
4911 struct isl_basic_map *bmap;
4912 bmap = isl_basic_map_alloc_space(dim, 0, n_equal, 0);
4913 if (!bmap)
4914 return NULL((void*)0);
4915 for (i = 0; i < n_equal && bmap; ++i)
4916 bmap = var_equal(bmap, i);
4917 return isl_basic_map_finalize(bmap);
4918}
4919
4920/* Return a relation on of dimension "dim" expressing i_[0..pos] << o_[0..pos]
4921 */
4922__isl_give isl_basic_map *isl_basic_map_less_at(__isl_take isl_space *dim,
4923 unsigned pos)
4924{
4925 int i;
4926 struct isl_basic_map *bmap;
4927 bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
4928 if (!bmap)
4929 return NULL((void*)0);
4930 for (i = 0; i < pos && bmap; ++i)
4931 bmap = var_equal(bmap, i);
4932 if (bmap)
4933 bmap = var_less(bmap, pos);
4934 return isl_basic_map_finalize(bmap);
4935}
4936
4937/* Return a relation on "dim" expressing i_[0..pos] <<= o_[0..pos]
4938 */
4939__isl_give isl_basic_map *isl_basic_map_less_or_equal_at(
4940 __isl_take isl_space *dim, unsigned pos)
4941{
4942 int i;
4943 isl_basic_map *bmap;
4944
4945 bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
4946 for (i = 0; i < pos; ++i)
4947 bmap = var_equal(bmap, i);
4948 bmap = var_less_or_equal(bmap, pos);
4949 return isl_basic_map_finalize(bmap);
4950}
4951
4952/* Return a relation on "dim" expressing i_pos > o_pos
4953 */
4954__isl_give isl_basic_map *isl_basic_map_more_at(__isl_take isl_space *dim,
4955 unsigned pos)
4956{
4957 int i;
4958 struct isl_basic_map *bmap;
4959 bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
4960 if (!bmap)
4961 return NULL((void*)0);
4962 for (i = 0; i < pos && bmap; ++i)
4963 bmap = var_equal(bmap, i);
4964 if (bmap)
4965 bmap = var_more(bmap, pos);
4966 return isl_basic_map_finalize(bmap);
4967}
4968
4969/* Return a relation on "dim" expressing i_[0..pos] >>= o_[0..pos]
4970 */
4971__isl_give isl_basic_map *isl_basic_map_more_or_equal_at(
4972 __isl_take isl_space *dim, unsigned pos)
4973{
4974 int i;
4975 isl_basic_map *bmap;
4976
4977 bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
4978 for (i = 0; i < pos; ++i)
4979 bmap = var_equal(bmap, i);
4980 bmap = var_more_or_equal(bmap, pos);
4981 return isl_basic_map_finalize(bmap);
4982}
4983
4984static __isl_give isl_map *map_lex_lte_first(__isl_take isl_space *dims,
4985 unsigned n, int equal)
4986{
4987 struct isl_map *map;
4988 int i;
4989
4990 if (n == 0 && equal)
4991 return isl_map_universe(dims);
4992
4993 map = isl_map_alloc_space(isl_space_copy(dims), n, ISL_MAP_DISJOINT(1 << 0));
4994
4995 for (i = 0; i + 1 < n; ++i)
4996 map = isl_map_add_basic_map(map,
4997 isl_basic_map_less_at(isl_space_copy(dims), i));
4998 if (n > 0) {
4999 if (equal)
5000 map = isl_map_add_basic_map(map,
5001 isl_basic_map_less_or_equal_at(dims, n - 1));
5002 else
5003 map = isl_map_add_basic_map(map,
5004 isl_basic_map_less_at(dims, n - 1));
5005 } else
5006 isl_space_free(dims);
5007
5008 return map;
5009}
5010
5011static __isl_give isl_map *map_lex_lte(__isl_take isl_space *dims, int equal)
5012{
5013 if (!dims)
5014 return NULL((void*)0);
5015 return map_lex_lte_first(dims, dims->n_out, equal);
5016}
5017
5018__isl_give isl_map *isl_map_lex_lt_first(__isl_take isl_space *dim, unsigned n)
5019{
5020 return map_lex_lte_first(dim, n, 0);
5021}
5022
5023__isl_give isl_map *isl_map_lex_le_first(__isl_take isl_space *dim, unsigned n)
5024{
5025 return map_lex_lte_first(dim, n, 1);
5026}
5027
5028__isl_give isl_map *isl_map_lex_lt(__isl_take isl_space *set_dim)
5029{
5030 return map_lex_lte(isl_space_map_from_set(set_dim), 0);
5031}
5032
5033__isl_give isl_map *isl_map_lex_le(__isl_take isl_space *set_dim)
5034{
5035 return map_lex_lte(isl_space_map_from_set(set_dim), 1);
5036}
5037
5038static __isl_give isl_map *map_lex_gte_first(__isl_take isl_space *dims,
5039 unsigned n, int equal)
5040{
5041 struct isl_map *map;
5042 int i;
5043
5044 if (n == 0 && equal)
5045 return isl_map_universe(dims);
5046
5047 map = isl_map_alloc_space(isl_space_copy(dims), n, ISL_MAP_DISJOINT(1 << 0));
5048
5049 for (i = 0; i + 1 < n; ++i)
5050 map = isl_map_add_basic_map(map,
5051 isl_basic_map_more_at(isl_space_copy(dims), i));
5052 if (n > 0) {
5053 if (equal)
5054 map = isl_map_add_basic_map(map,
5055 isl_basic_map_more_or_equal_at(dims, n - 1));
5056 else
5057 map = isl_map_add_basic_map(map,
5058 isl_basic_map_more_at(dims, n - 1));
5059 } else
5060 isl_space_free(dims);
5061
5062 return map;
5063}
5064
5065static __isl_give isl_map *map_lex_gte(__isl_take isl_space *dims, int equal)
5066{
5067 if (!dims)
5068 return NULL((void*)0);
5069 return map_lex_gte_first(dims, dims->n_out, equal);
5070}
5071
5072__isl_give isl_map *isl_map_lex_gt_first(__isl_take isl_space *dim, unsigned n)
5073{
5074 return map_lex_gte_first(dim, n, 0);
5075}
5076
5077__isl_give isl_map *isl_map_lex_ge_first(__isl_take isl_space *dim, unsigned n)
5078{
5079 return map_lex_gte_first(dim, n, 1);
5080}
5081
5082__isl_give isl_map *isl_map_lex_gt(__isl_take isl_space *set_dim)
5083{
5084 return map_lex_gte(isl_space_map_from_set(set_dim), 0);
5085}
5086
5087__isl_give isl_map *isl_map_lex_ge(__isl_take isl_space *set_dim)
5088{
5089 return map_lex_gte(isl_space_map_from_set(set_dim), 1);
5090}
5091
5092__isl_give isl_map *isl_set_lex_le_set(__isl_take isl_setisl_map *set1,
5093 __isl_take isl_setisl_map *set2)
5094{
5095 isl_map *map;
5096 map = isl_map_lex_le(isl_set_get_space(set1));
5097 map = isl_map_intersect_domain(map, set1);
5098 map = isl_map_intersect_range(map, set2);
5099 return map;
5100}
5101
5102__isl_give isl_map *isl_set_lex_lt_set(__isl_take isl_setisl_map *set1,
5103 __isl_take isl_setisl_map *set2)
5104{
5105 isl_map *map;
5106 map = isl_map_lex_lt(isl_set_get_space(set1));
5107 map = isl_map_intersect_domain(map, set1);
5108 map = isl_map_intersect_range(map, set2);
5109 return map;
5110}
5111
5112__isl_give isl_map *isl_set_lex_ge_set(__isl_take isl_setisl_map *set1,
5113 __isl_take isl_setisl_map *set2)
5114{
5115 isl_map *map;
5116 map = isl_map_lex_ge(isl_set_get_space(set1));
5117 map = isl_map_intersect_domain(map, set1);
5118 map = isl_map_intersect_range(map, set2);
5119 return map;
5120}
5121
5122__isl_give isl_map *isl_set_lex_gt_set(__isl_take isl_setisl_map *set1,
5123 __isl_take isl_setisl_map *set2)
5124{
5125 isl_map *map;
5126 map = isl_map_lex_gt(isl_set_get_space(set1));
5127 map = isl_map_intersect_domain(map, set1);
5128 map = isl_map_intersect_range(map, set2);
5129 return map;
5130}
5131
5132__isl_give isl_map *isl_map_lex_le_map(__isl_take isl_map *map1,
5133 __isl_take isl_map *map2)
5134{
5135 isl_map *map;
5136 map = isl_map_lex_le(isl_space_range(isl_map_get_space(map1)));
5137 map = isl_map_apply_domain(map, isl_map_reverse(map1));
5138 map = isl_map_apply_range(map, isl_map_reverse(map2));
5139 return map;
5140}
5141
5142__isl_give isl_map *isl_map_lex_lt_map(__isl_take isl_map *map1,
5143 __isl_take isl_map *map2)
5144{
5145 isl_map *map;
5146 map = isl_map_lex_lt(isl_space_range(isl_map_get_space(map1)));
5147 map = isl_map_apply_domain(map, isl_map_reverse(map1));
5148 map = isl_map_apply_range(map, isl_map_reverse(map2));
5149 return map;
5150}
5151
5152__isl_give isl_map *isl_map_lex_ge_map(__isl_take isl_map *map1,
5153 __isl_take isl_map *map2)
5154{
5155 isl_map *map;
5156 map = isl_map_lex_ge(isl_space_range(isl_map_get_space(map1)));
5157 map = isl_map_apply_domain(map, isl_map_reverse(map1));
5158 map = isl_map_apply_range(map, isl_map_reverse(map2));
5159 return map;
5160}
5161
5162__isl_give isl_map *isl_map_lex_gt_map(__isl_take isl_map *map1,
5163 __isl_take isl_map *map2)
5164{
5165 isl_map *map;
5166 map = isl_map_lex_gt(isl_space_range(isl_map_get_space(map1)));
5167 map = isl_map_apply_domain(map, isl_map_reverse(map1));
5168 map = isl_map_apply_range(map, isl_map_reverse(map2));
5169 return map;
5170}
5171
5172/* For a div d = floor(f/m), add the constraint
5173 *
5174 * f - m d >= 0
5175 */
5176static isl_stat add_upper_div_constraint(__isl_keep isl_basic_map *bmap,
5177 unsigned pos, isl_int *div)
5178{
5179 int i;
5180 unsigned total = isl_basic_map_total_dim(bmap);
5181
5182 i = isl_basic_map_alloc_inequality(bmap);
5183 if (i < 0)
5184 return isl_stat_error;
5185 isl_seq_cpy(bmap->ineq[i], div + 1, 1 + total);
5186 isl_int_neg(bmap->ineq[i][1 + pos], div[0])isl_sioimath_neg((bmap->ineq[i][1 + pos]), *(div[0]));
5187
5188 return isl_stat_ok;
5189}
5190
5191/* For a div d = floor(f/m), add the constraint
5192 *
5193 * -(f-(m-1)) + m d >= 0
5194 */
5195static isl_stat add_lower_div_constraint(__isl_keep isl_basic_map *bmap,
5196 unsigned pos, isl_int *div)
5197{
5198 int i;
5199 unsigned total = isl_basic_map_total_dim(bmap);
5200
5201 i = isl_basic_map_alloc_inequality(bmap);
5202 if (i < 0)
5203 return isl_stat_error;
5204 isl_seq_neg(bmap->ineq[i], div + 1, 1 + total);
5205 isl_int_set(bmap->ineq[i][1 + pos], div[0])isl_sioimath_set((bmap->ineq[i][1 + pos]), *(div[0]));
5206 isl_int_add(bmap->ineq[i][0], bmap->ineq[i][0], bmap->ineq[i][1 + pos])isl_sioimath_add((bmap->ineq[i][0]), *(bmap->ineq[i][0]
), *(bmap->ineq[i][1 + pos]))
;
5207 isl_int_sub_ui(bmap->ineq[i][0], bmap->ineq[i][0], 1)isl_sioimath_sub_ui((bmap->ineq[i][0]), *(bmap->ineq[i]
[0]), 1)
;
5208
5209 return isl_stat_ok;
5210}
5211
5212/* For a div d = floor(f/m), add the constraints
5213 *
5214 * f - m d >= 0
5215 * -(f-(m-1)) + m d >= 0
5216 *
5217 * Note that the second constraint is the negation of
5218 *
5219 * f - m d >= m
5220 */
5221int isl_basic_map_add_div_constraints_var(__isl_keep isl_basic_map *bmap,
5222 unsigned pos, isl_int *div)
5223{
5224 if (add_upper_div_constraint(bmap, pos, div) < 0)
5225 return -1;
5226 if (add_lower_div_constraint(bmap, pos, div) < 0)
5227 return -1;
5228 return 0;
5229}
5230
5231int isl_basic_set_add_div_constraints_var(__isl_keep isl_basic_setisl_basic_map *bset,
5232 unsigned pos, isl_int *div)
5233{
5234 return isl_basic_map_add_div_constraints_var(bset_to_bmap(bset),
5235 pos, div);
5236}
5237
5238int isl_basic_map_add_div_constraints(struct isl_basic_map *bmap, unsigned div)
5239{
5240 unsigned total = isl_basic_map_total_dim(bmap);
5241 unsigned div_pos = total - bmap->n_div + div;
5242
5243 return isl_basic_map_add_div_constraints_var(bmap, div_pos,
5244 bmap->div[div]);
5245}
5246
5247/* For each known div d = floor(f/m), add the constraints
5248 *
5249 * f - m d >= 0
5250 * -(f-(m-1)) + m d >= 0
5251 *
5252 * Remove duplicate constraints in case of some these div constraints
5253 * already appear in "bmap".
5254 */
5255__isl_give isl_basic_map *isl_basic_map_add_known_div_constraints(
5256 __isl_take isl_basic_map *bmap)
5257{
5258 unsigned n_div;
5259
5260 if (!bmap)
5261 return NULL((void*)0);
5262 n_div = isl_basic_map_dim(bmap, isl_dim_div);
5263 if (n_div == 0)
5264 return bmap;
5265
5266 bmap = add_known_div_constraints(bmap);
5267 bmap = isl_basic_map_remove_duplicate_constraints(bmap, NULL((void*)0), 0);
5268 bmap = isl_basic_map_finalize(bmap);
5269 return bmap;
5270}
5271
5272/* Add the div constraint of sign "sign" for div "div" of "bmap".
5273 *
5274 * In particular, if this div is of the form d = floor(f/m),
5275 * then add the constraint
5276 *
5277 * f - m d >= 0
5278 *
5279 * if sign < 0 or the constraint
5280 *
5281 * -(f-(m-1)) + m d >= 0
5282 *
5283 * if sign > 0.
5284 */
5285int isl_basic_map_add_div_constraint(__isl_keep isl_basic_map *bmap,
5286 unsigned div, int sign)
5287{
5288 unsigned total;
5289 unsigned div_pos;
5290
5291 if (!bmap)
5292 return -1;
5293
5294 total = isl_basic_map_total_dim(bmap);
5295 div_pos = total - bmap->n_div + div;
5296
5297 if (sign < 0)
5298 return add_upper_div_constraint(bmap, div_pos, bmap->div[div]);
5299 else
5300 return add_lower_div_constraint(bmap, div_pos, bmap->div[div]);
5301}
5302
5303__isl_give isl_basic_setisl_basic_map *isl_basic_map_underlying_set(
5304 __isl_take isl_basic_map *bmap)
5305{
5306 if (!bmap)
5307 goto error;
5308 if (bmap->dim->nparam == 0 && bmap->dim->n_in == 0 &&
5309 bmap->n_div == 0 &&
5310 !isl_space_is_named_or_nested(bmap->dim, isl_dim_in) &&
5311 !isl_space_is_named_or_nested(bmap->dim, isl_dim_out))
5312 return bset_from_bmap(bmap);
5313 bmap = isl_basic_map_cow(bmap);
5314 if (!bmap)
5315 goto error;
5316 bmap->dim = isl_space_underlying(bmap->dim, bmap->n_div);
5317 if (!bmap->dim)
5318 goto error;
5319 bmap->extra -= bmap->n_div;
5320 bmap->n_div = 0;
5321 bmap = isl_basic_map_finalize(bmap);
5322 return bset_from_bmap(bmap);
5323error:
5324 isl_basic_map_free(bmap);
5325 return NULL((void*)0);
5326}
5327
5328__isl_give isl_basic_setisl_basic_map *isl_basic_set_underlying_set(
5329 __isl_take isl_basic_setisl_basic_map *bset)
5330{
5331 return isl_basic_map_underlying_set(bset_to_bmap(bset));
5332}
5333
5334/* Replace each element in "list" by the result of applying
5335 * isl_basic_map_underlying_set to the element.
5336 */
5337__isl_give isl_basic_set_listisl_basic_map_list *isl_basic_map_list_underlying_set(
5338 __isl_take isl_basic_map_list *list)
5339{
5340 int i, n;
5341
5342 if (!list)
5343 return NULL((void*)0);
5344
5345 n = isl_basic_map_list_n_basic_map(list);
5346 for (i = 0; i < n; ++i) {
5347 isl_basic_map *bmap;
5348 isl_basic_setisl_basic_map *bset;
5349
5350 bmap = isl_basic_map_list_get_basic_map(list, i);
5351 bset = isl_basic_set_underlying_set(bmap);
5352 list = isl_basic_set_list_set_basic_set(list, i, bset);
5353 }
5354
5355 return list;
5356}
5357
5358__isl_give isl_basic_map *isl_basic_map_overlying_set(
5359 __isl_take isl_basic_setisl_basic_map *bset, __isl_take isl_basic_map *like)
5360{
5361 struct isl_basic_map *bmap;
5362 struct isl_ctx *ctx;
5363 unsigned total;
5364 int i;
5365
5366 if (!bset || !like)
5367 goto error;
5368 ctx = bset->ctx;
5369 isl_assert(ctx, bset->n_div == 0, goto error)do { if (bset->n_div == 0) break; do { isl_handle_error(ctx
, isl_error_unknown, "Assertion \"" "bset->n_div == 0" "\" failed"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 5369); goto error; } while (0); } while (0)
;
5370 isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error)do { if (isl_basic_set_n_param(bset) == 0) break; do { isl_handle_error
(ctx, isl_error_unknown, "Assertion \"" "isl_basic_set_n_param(bset) == 0"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 5370); goto error; } while (0); } while (0)
;
5371 isl_assert(ctx, bset->dim->n_out == isl_basic_map_total_dim(like),do { if (bset->dim->n_out == isl_basic_map_total_dim(like
)) break; do { isl_handle_error(ctx, isl_error_unknown, "Assertion \""
"bset->dim->n_out == isl_basic_map_total_dim(like)" "\" failed"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 5372); goto error; } while (0); } while (0)
5372 goto error)do { if (bset->dim->n_out == isl_basic_map_total_dim(like
)) break; do { isl_handle_error(ctx, isl_error_unknown, "Assertion \""
"bset->dim->n_out == isl_basic_map_total_dim(like)" "\" failed"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 5372); goto error; } while (0); } while (0)
;
5373 if (like->n_div == 0) {
5374 isl_space *space = isl_basic_map_get_space(like);
5375 isl_basic_map_free(like);
5376 return isl_basic_map_reset_space(bset, space);
5377 }
5378 bset = isl_basic_set_cow(bset);
5379 if (!bset)
5380 goto error;
5381 total = bset->dim->n_out + bset->extra;
5382 bmap = bset_to_bmap(bset);
5383 isl_space_free(bmap->dim);
5384 bmap->dim = isl_space_copy(like->dim);
5385 if (!bmap->dim)
5386 goto error;
5387 bmap->n_div = like->n_div;
5388 bmap->extra += like->n_div;
5389 if (bmap->extra) {
5390 unsigned ltotal;
5391 isl_int **div;
5392 ltotal = total - bmap->extra + like->extra;
5393 if (ltotal > total)
5394 ltotal = total;
5395 bmap->block2 = isl_blk_extend(ctx, bmap->block2,
5396 bmap->extra * (1 + 1 + total));
5397 if (isl_blk_is_error(bmap->block2))
5398 goto error;
5399 div = isl_realloc_array(ctx, bmap->div, isl_int *, bmap->extra)((isl_int * *)isl_realloc_or_die(ctx, bmap->div, (bmap->
extra)*sizeof(isl_int *)))
;
5400 if (!div)
5401 goto error;
5402 bmap->div = div;
5403 for (i = 0; i < bmap->extra; ++i)
5404 bmap->div[i] = bmap->block2.data + i * (1 + 1 + total);
5405 for (i = 0; i < like->n_div; ++i) {
5406 isl_seq_cpy(bmap->div[i], like->div[i], 1 + 1 + ltotal);
5407 isl_seq_clr(bmap->div[i]+1+1+ltotal, total - ltotal);
5408 }
5409 bmap = isl_basic_map_add_known_div_constraints(bmap);
5410 }
5411 isl_basic_map_free(like);
5412 bmap = isl_basic_map_simplify(bmap);
5413 bmap = isl_basic_map_finalize(bmap);
5414 return bmap;
5415error:
5416 isl_basic_map_free(like);
5417 isl_basic_set_free(bset);
5418 return NULL((void*)0);
5419}
5420
5421struct isl_basic_setisl_basic_map *isl_basic_set_from_underlying_set(
5422 struct isl_basic_setisl_basic_map *bset, struct isl_basic_setisl_basic_map *like)
5423{
5424 return bset_from_bmap(isl_basic_map_overlying_set(bset,
5425 bset_to_bmap(like)));
5426}
5427
5428__isl_give isl_setisl_map *isl_map_underlying_set(__isl_take isl_map *map)
5429{
5430 int i;
5431
5432 map = isl_map_cow(map);
5433 if (!map)
5434 return NULL((void*)0);
5435 map->dim = isl_space_cow(map->dim);
5436 if (!map->dim)
5437 goto error;
5438
5439 for (i = 1; i < map->n; ++i)
5440 isl_assert(map->ctx, map->p[0]->n_div == map->p[i]->n_div,do { if (map->p[0]->n_div == map->p[i]->n_div) break
; do { isl_handle_error(map->ctx, isl_error_unknown, "Assertion \""
"map->p[0]->n_div == map->p[i]->n_div" "\" failed"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 5441); goto error; } while (0); } while (0)
5441 goto error)do { if (map->p[0]->n_div == map->p[i]->n_div) break
; do { isl_handle_error(map->ctx, isl_error_unknown, "Assertion \""
"map->p[0]->n_div == map->p[i]->n_div" "\" failed"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 5441); goto error; } while (0); } while (0)
;
5442 for (i = 0; i < map->n; ++i) {
5443 map->p[i] = bset_to_bmap(
5444 isl_basic_map_underlying_set(map->p[i]));
5445 if (!map->p[i])
5446 goto error;
5447 }
5448 if (map->n == 0)
5449 map->dim = isl_space_underlying(map->dim, 0);
5450 else {
5451 isl_space_free(map->dim);
5452 map->dim = isl_space_copy(map->p[0]->dim);
5453 }
5454 if (!map->dim)
5455 goto error;
5456 return set_from_map(map);
5457error:
5458 isl_map_free(map);
5459 return NULL((void*)0);
5460}
5461
5462/* Replace the space of "bmap" by "space".
5463 *
5464 * If the space of "bmap" is identical to "space" (including the identifiers
5465 * of the input and output dimensions), then simply return the original input.
5466 */
5467__isl_give isl_basic_map *isl_basic_map_reset_space(
5468 __isl_take isl_basic_map *bmap, __isl_take isl_space *space)
5469{
5470 isl_bool equal;
5471 isl_space *bmap_space;
5472
5473 bmap_space = isl_basic_map_peek_space(bmap);
5474 equal = isl_space_is_equal(bmap_space, space);
5475 if (equal >= 0 && equal)
5476 equal = isl_space_has_equal_ids(bmap_space, space);
5477 if (equal < 0)
5478 goto error;
5479 if (equal) {
5480 isl_space_free(space);
5481 return bmap;
5482 }
5483 bmap = isl_basic_map_cow(bmap);
5484 if (!bmap || !space)
5485 goto error;
5486
5487 isl_space_free(bmap->dim);
5488 bmap->dim = space;
5489
5490 bmap = isl_basic_map_finalize(bmap);
5491
5492 return bmap;
5493error:
5494 isl_basic_map_free(bmap);
5495 isl_space_free(space);
5496 return NULL((void*)0);
5497}
5498
5499__isl_give isl_basic_setisl_basic_map *isl_basic_set_reset_space(
5500 __isl_take isl_basic_setisl_basic_map *bset, __isl_take isl_space *dim)
5501{
5502 return bset_from_bmap(isl_basic_map_reset_space(bset_to_bmap(bset),
5503 dim));
5504}
5505
5506__isl_give isl_map *isl_map_reset_space(__isl_take isl_map *map,
5507 __isl_take isl_space *dim)
5508{
5509 int i;
5510
5511 map = isl_map_cow(map);
5512 if (!map || !dim)
5513 goto error;
5514
5515 for (i = 0; i < map->n; ++i) {
5516 map->p[i] = isl_basic_map_reset_space(map->p[i],
5517 isl_space_copy(dim));
5518 if (!map->p[i])
5519 goto error;
5520 }
5521 isl_space_free(map->dim);
5522 map->dim = dim;
5523
5524 return map;
5525error:
5526 isl_map_free(map);
5527 isl_space_free(dim);
5528 return NULL((void*)0);
5529}
5530
5531__isl_give isl_setisl_map *isl_set_reset_space(__isl_take isl_setisl_map *set,
5532 __isl_take isl_space *dim)
5533{
5534 return set_from_map(isl_map_reset_space(set_to_map(set), dim));
5535}
5536
5537/* Compute the parameter domain of the given basic set.
5538 */
5539__isl_give isl_basic_setisl_basic_map *isl_basic_set_params(__isl_take isl_basic_setisl_basic_map *bset)
5540{
5541 isl_bool is_params;
5542 isl_space *space;
5543 unsigned n;
5544
5545 is_params = isl_basic_set_is_params(bset);
5546 if (is_params < 0)
5547 return isl_basic_set_free(bset);
5548 if (is_params)
5549 return bset;
5550
5551 n = isl_basic_set_dim(bset, isl_dim_set);
5552 bset = isl_basic_set_project_out(bset, isl_dim_set, 0, n);
5553 space = isl_basic_set_get_space(bset);
5554 space = isl_space_params(space);
5555 bset = isl_basic_set_reset_space(bset, space);
5556 return bset;
5557}
5558
5559/* Construct a zero-dimensional basic set with the given parameter domain.
5560 */
5561__isl_give isl_basic_setisl_basic_map *isl_basic_set_from_params(
5562 __isl_take isl_basic_setisl_basic_map *bset)
5563{
5564 isl_space *space;
5565 space = isl_basic_set_get_space(bset);
5566 space = isl_space_set_from_params(space);
5567 bset = isl_basic_set_reset_space(bset, space);
5568 return bset;
5569}
5570
5571/* Compute the parameter domain of the given set.
5572 */
5573__isl_give isl_setisl_map *isl_set_params(__isl_take isl_setisl_map *set)
5574{
5575 isl_space *space;
5576 unsigned n;
5577
5578 if (isl_set_is_params(set))
5579 return set;
5580
5581 n = isl_set_dim(set, isl_dim_set);
5582 set = isl_set_project_out(set, isl_dim_set, 0, n);
5583 space = isl_set_get_space(set);
5584 space = isl_space_params(space);
5585 set = isl_set_reset_space(set, space);
5586 return set;
5587}
5588
5589/* Construct a zero-dimensional set with the given parameter domain.
5590 */
5591__isl_give isl_setisl_map *isl_set_from_params(__isl_take isl_setisl_map *set)
5592{
5593 isl_space *space;
5594 space = isl_set_get_space(set);
5595 space = isl_space_set_from_params(space);
5596 set = isl_set_reset_space(set, space);
5597 return set;
5598}
5599
5600/* Compute the parameter domain of the given map.
5601 */
5602__isl_give isl_setisl_map *isl_map_params(__isl_take isl_map *map)
5603{
5604 isl_space *space;
5605 unsigned n;
5606
5607 n = isl_map_dim(map, isl_dim_in);
5608 map = isl_map_project_out(map, isl_dim_in, 0, n);
5609 n = isl_map_dim(map, isl_dim_out);
5610 map = isl_map_project_out(map, isl_dim_out, 0, n);
5611 space = isl_map_get_space(map);
5612 space = isl_space_params(space);
5613 map = isl_map_reset_space(map, space);
5614 return map;
5615}
5616
5617struct isl_basic_setisl_basic_map *isl_basic_map_domain(struct isl_basic_map *bmap)
5618{
5619 isl_space *space;
5620 unsigned n_out;
5621
5622 if (!bmap)
5623 return NULL((void*)0);
5624 space = isl_space_domain(isl_basic_map_get_space(bmap));
5625
5626 n_out = isl_basic_map_dim(bmap, isl_dim_out);
5627 bmap = isl_basic_map_project_out(bmap, isl_dim_out, 0, n_out);
5628
5629 return isl_basic_map_reset_space(bmap, space);
5630}
5631
5632isl_bool isl_basic_map_may_be_set(__isl_keep isl_basic_map *bmap)
5633{
5634 if (!bmap)
5635 return isl_bool_error;
5636 return isl_space_may_be_set(bmap->dim);
5637}
5638
5639/* Is this basic map actually a set?
5640 * Users should never call this function. Outside of isl,
5641 * the type should indicate whether something is a set or a map.
5642 */
5643isl_bool isl_basic_map_is_set(__isl_keep isl_basic_map *bmap)
5644{
5645 if (!bmap)
5646 return isl_bool_error;
5647 return isl_space_is_set(bmap->dim);
5648}
5649
5650struct isl_basic_setisl_basic_map *isl_basic_map_range(struct isl_basic_map *bmap)
5651{
5652 isl_bool is_set;
5653
5654 is_set = isl_basic_map_is_set(bmap);
5655 if (is_set < 0)
5656 goto error;
5657 if (is_set)
5658 return bmap;
5659 return isl_basic_map_domain(isl_basic_map_reverse(bmap));
5660error:
5661 isl_basic_map_free(bmap);
5662 return NULL((void*)0);
5663}
5664
5665__isl_give isl_basic_map *isl_basic_map_domain_map(
5666 __isl_take isl_basic_map *bmap)
5667{
5668 int i;
5669 isl_space *dim;
5670 isl_basic_map *domain;
5671 int nparam, n_in, n_out;
5672
5673 nparam = isl_basic_map_dim(bmap, isl_dim_param);
5674 n_in = isl_basic_map_dim(bmap, isl_dim_in);
5675 n_out = isl_basic_map_dim(bmap, isl_dim_out);
5676
5677 dim = isl_space_from_range(isl_space_domain(isl_basic_map_get_space(bmap)));
5678 domain = isl_basic_map_universe(dim);
5679
5680 bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
5681 bmap = isl_basic_map_apply_range(bmap, domain);
5682 bmap = isl_basic_map_extend_constraints(bmap, n_in, 0);
5683
5684 for (i = 0; i < n_in; ++i)
5685 bmap = isl_basic_map_equate(bmap, isl_dim_in, i,
5686 isl_dim_out, i);
5687
5688 bmap = isl_basic_map_gauss(bmap, NULL((void*)0));
5689 return isl_basic_map_finalize(bmap);
5690}
5691
5692__isl_give isl_basic_map *isl_basic_map_range_map(
5693 __isl_take isl_basic_map *bmap)
5694{
5695 int i;
5696 isl_space *dim;
5697 isl_basic_map *range;
5698 int nparam, n_in, n_out;
5699
5700 nparam = isl_basic_map_dim(bmap, isl_dim_param);
5701 n_in = isl_basic_map_dim(bmap, isl_dim_in);
5702 n_out = isl_basic_map_dim(bmap, isl_dim_out);
5703
5704 dim = isl_space_from_range(isl_space_range(isl_basic_map_get_space(bmap)));
5705 range = isl_basic_map_universe(dim);
5706
5707 bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
5708 bmap = isl_basic_map_apply_range(bmap, range);
5709 bmap = isl_basic_map_extend_constraints(bmap, n_out, 0);
5710
5711 for (i = 0; i < n_out; ++i)
5712 bmap = isl_basic_map_equate(bmap, isl_dim_in, n_in + i,
5713 isl_dim_out, i);
5714
5715 bmap = isl_basic_map_gauss(bmap, NULL((void*)0));
5716 return isl_basic_map_finalize(bmap);
5717}
5718
5719int isl_map_may_be_set(__isl_keep isl_map *map)
5720{
5721 if (!map)
5722 return -1;
5723 return isl_space_may_be_set(map->dim);
5724}
5725
5726/* Is this map actually a set?
5727 * Users should never call this function. Outside of isl,
5728 * the type should indicate whether something is a set or a map.
5729 */
5730isl_bool isl_map_is_set(__isl_keep isl_map *map)
5731{
5732 if (!map)
5733 return isl_bool_error;
5734 return isl_space_is_set(map->dim);
5735}
5736
5737__isl_give isl_setisl_map *isl_map_range(__isl_take isl_map *map)
5738{
5739 int i;
5740 isl_bool is_set;
5741 struct isl_setisl_map *set;
5742
5743 is_set = isl_map_is_set(map);
5744 if (is_set < 0)
5745 goto error;
5746 if (is_set)
5747 return set_from_map(map);
5748
5749 map = isl_map_cow(map);
5750 if (!map)
5751 goto error;
5752
5753 set = set_from_map(map);
5754 set->dim = isl_space_range(set->dim);
5755 if (!set->dim)
5756 goto error;
5757 for (i = 0; i < map->n; ++i) {
5758 set->p[i] = isl_basic_map_range(map->p[i]);
5759 if (!set->p[i])
5760 goto error;
5761 }
5762 ISL_F_CLR(set, ISL_MAP_DISJOINT)(((set)->flags) &= ~((1 << 0)));
5763 ISL_F_CLR(set, ISL_SET_NORMALIZED)(((set)->flags) &= ~((1 << 1)));
5764 return set;
5765error:
5766 isl_map_free(map);
5767 return NULL((void*)0);
5768}
5769
5770__isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map)
5771{
5772 int i;
5773
5774 map = isl_map_cow(map);
5775 if (!map)
5776 return NULL((void*)0);
5777
5778 map->dim = isl_space_domain_map(map->dim);
5779 if (!map->dim)
5780 goto error;
5781 for (i = 0; i < map->n; ++i) {
5782 map->p[i] = isl_basic_map_domain_map(map->p[i]);
5783 if (!map->p[i])
5784 goto error;
5785 }
5786 ISL_F_CLR(map, ISL_MAP_DISJOINT)(((map)->flags) &= ~((1 << 0)));
5787 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
5788 return map;
5789error:
5790 isl_map_free(map);
5791 return NULL((void*)0);
5792}
5793
5794__isl_give isl_map *isl_map_range_map(__isl_take isl_map *map)
5795{
5796 int i;
5797 isl_space *range_dim;
5798
5799 map = isl_map_cow(map);
5800 if (!map)
5801 return NULL((void*)0);
5802
5803 range_dim = isl_space_range(isl_map_get_space(map));
5804 range_dim = isl_space_from_range(range_dim);
5805 map->dim = isl_space_from_domain(isl_space_wrap(map->dim));
5806 map->dim = isl_space_join(map->dim, range_dim);
5807 if (!map->dim)
5808 goto error;
5809 for (i = 0; i < map->n; ++i) {
5810 map->p[i] = isl_basic_map_range_map(map->p[i]);
5811 if (!map->p[i])
5812 goto error;
5813 }
5814 ISL_F_CLR(map, ISL_MAP_DISJOINT)(((map)->flags) &= ~((1 << 0)));
5815 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
5816 return map;
5817error:
5818 isl_map_free(map);
5819 return NULL((void*)0);
5820}
5821
5822/* Given a wrapped map of the form A[B -> C],
5823 * return the map A[B -> C] -> B.
5824 */
5825__isl_give isl_map *isl_set_wrapped_domain_map(__isl_take isl_setisl_map *set)
5826{
5827 isl_id *id;
5828 isl_map *map;
5829
5830 if (!set)
5831 return NULL((void*)0);
5832 if (!isl_set_has_tuple_id(set))
5833 return isl_map_domain_map(isl_set_unwrap(set));
5834
5835 id = isl_set_get_tuple_id(set);
5836 map = isl_map_domain_map(isl_set_unwrap(set));
5837 map = isl_map_set_tuple_id(map, isl_dim_in, id);
5838
5839 return map;
5840}
5841
5842__isl_give isl_basic_map *isl_basic_map_from_domain(
5843 __isl_take isl_basic_setisl_basic_map *bset)
5844{
5845 return isl_basic_map_reverse(isl_basic_map_from_range(bset));
5846}
5847
5848__isl_give isl_basic_map *isl_basic_map_from_range(
5849 __isl_take isl_basic_setisl_basic_map *bset)
5850{
5851 isl_space *space;
5852 space = isl_basic_set_get_space(bset);
5853 space = isl_space_from_range(space);
5854 bset = isl_basic_set_reset_space(bset, space);
5855 return bset_to_bmap(bset);
5856}
5857
5858/* Create a relation with the given set as range.
5859 * The domain of the created relation is a zero-dimensional
5860 * flat anonymous space.
5861 */
5862__isl_give isl_map *isl_map_from_range(__isl_take isl_setisl_map *set)
5863{
5864 isl_space *space;
5865 space = isl_set_get_space(set);
5866 space = isl_space_from_range(space);
5867 set = isl_set_reset_space(set, space);
5868 return set_to_map(set);
5869}
5870
5871/* Create a relation with the given set as domain.
5872 * The range of the created relation is a zero-dimensional
5873 * flat anonymous space.
5874 */
5875__isl_give isl_map *isl_map_from_domain(__isl_take isl_setisl_map *set)
5876{
5877 return isl_map_reverse(isl_map_from_range(set));
5878}
5879
5880__isl_give isl_basic_map *isl_basic_map_from_domain_and_range(
5881 __isl_take isl_basic_setisl_basic_map *domain, __isl_take isl_basic_setisl_basic_map *range)
5882{
5883 return isl_basic_map_apply_range(isl_basic_map_reverse(domain), range);
5884}
5885
5886__isl_give isl_map *isl_map_from_domain_and_range(__isl_take isl_setisl_map *domain,
5887 __isl_take isl_setisl_map *range)
5888{
5889 return isl_map_apply_range(isl_map_reverse(domain), range);
5890}
5891
5892/* Return a newly allocated isl_map with given space and flags and
5893 * room for "n" basic maps.
5894 * Make sure that all cached information is cleared.
5895 */
5896__isl_give isl_map *isl_map_alloc_space(__isl_take isl_space *space, int n,
5897 unsigned flags)
5898{
5899 struct isl_map *map;
5900
5901 if (!space)
5902 return NULL((void*)0);
5903 if (n < 0)
5904 isl_die(space->ctx, isl_error_internal,do { isl_handle_error(space->ctx, isl_error_internal, "negative number of basic maps"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 5905); goto error; } while (0)
5905 "negative number of basic maps", goto error)do { isl_handle_error(space->ctx, isl_error_internal, "negative number of basic maps"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 5905); goto error; } while (0)
;
5906 map = isl_calloc(space->ctx, struct isl_map,((struct isl_map *)isl_calloc_or_die(space->ctx, 1, sizeof
(struct isl_map) + (n - 1) * sizeof(struct isl_basic_map *)))
5907 sizeof(struct isl_map) +((struct isl_map *)isl_calloc_or_die(space->ctx, 1, sizeof
(struct isl_map) + (n - 1) * sizeof(struct isl_basic_map *)))
5908 (n - 1) * sizeof(struct isl_basic_map *))((struct isl_map *)isl_calloc_or_die(space->ctx, 1, sizeof
(struct isl_map) + (n - 1) * sizeof(struct isl_basic_map *)))
;
5909 if (!map)
5910 goto error;
5911
5912 map->ctx = space->ctx;
5913 isl_ctx_ref(map->ctx);
5914 map->ref = 1;
5915 map->size = n;
5916 map->n = 0;
5917 map->dim = space;
5918 map->flags = flags;
5919 return map;
5920error:
5921 isl_space_free(space);
5922 return NULL((void*)0);
5923}
5924
5925__isl_give isl_basic_map *isl_basic_map_empty(__isl_take isl_space *space)
5926{
5927 struct isl_basic_map *bmap;
5928 bmap = isl_basic_map_alloc_space(space, 0, 1, 0);
5929 bmap = isl_basic_map_set_to_empty(bmap);
5930 return bmap;
5931}
5932
5933__isl_give isl_basic_setisl_basic_map *isl_basic_set_empty(__isl_take isl_space *space)
5934{
5935 struct isl_basic_setisl_basic_map *bset;
5936 bset = isl_basic_set_alloc_space(space, 0, 1, 0);
5937 bset = isl_basic_set_set_to_empty(bset);
5938 return bset;
5939}
5940
5941__isl_give isl_basic_map *isl_basic_map_universe(__isl_take isl_space *space)
5942{
5943 struct isl_basic_map *bmap;
5944 bmap = isl_basic_map_alloc_space(space, 0, 0, 0);
5945 bmap = isl_basic_map_finalize(bmap);
5946 return bmap;
5947}
5948
5949__isl_give isl_basic_setisl_basic_map *isl_basic_set_universe(__isl_take isl_space *space)
5950{
5951 struct isl_basic_setisl_basic_map *bset;
5952 bset = isl_basic_set_alloc_space(space, 0, 0, 0);
5953 bset = isl_basic_set_finalize(bset);
5954 return bset;
5955}
5956
5957__isl_give isl_basic_map *isl_basic_map_nat_universe(__isl_take isl_space *dim)
5958{
5959 int i;
5960 unsigned total = isl_space_dim(dim, isl_dim_all);
5961 isl_basic_map *bmap;
5962
5963 bmap= isl_basic_map_alloc_space(dim, 0, 0, total);
5964 for (i = 0; i < total; ++i) {
5965 int k = isl_basic_map_alloc_inequality(bmap);
5966 if (k < 0)
5967 goto error;
5968 isl_seq_clr(bmap->ineq[k], 1 + total);
5969 isl_int_set_si(bmap->ineq[k][1 + i], 1)isl_sioimath_set_si((bmap->ineq[k][1 + i]), 1);
5970 }
5971 return bmap;
5972error:
5973 isl_basic_map_free(bmap);
5974 return NULL((void*)0);
5975}
5976
5977__isl_give isl_basic_setisl_basic_map *isl_basic_set_nat_universe(__isl_take isl_space *dim)
5978{
5979 return isl_basic_map_nat_universe(dim);
5980}
5981
5982__isl_give isl_map *isl_map_nat_universe(__isl_take isl_space *dim)
5983{
5984 return isl_map_from_basic_map(isl_basic_map_nat_universe(dim));
5985}
5986
5987__isl_give isl_setisl_map *isl_set_nat_universe(__isl_take isl_space *dim)
5988{
5989 return isl_map_nat_universe(dim);
5990}
5991
5992__isl_give isl_map *isl_map_empty(__isl_take isl_space *space)
5993{
5994 return isl_map_alloc_space(space, 0, ISL_MAP_DISJOINT(1 << 0));
5995}
5996
5997__isl_give isl_setisl_map *isl_set_empty(__isl_take isl_space *space)
5998{
5999 return isl_set_alloc_space(space, 0, ISL_MAP_DISJOINT(1 << 0));
6000}
6001
6002__isl_give isl_map *isl_map_universe(__isl_take isl_space *space)
6003{
6004 struct isl_map *map;
6005 if (!space)
6006 return NULL((void*)0);
6007 map = isl_map_alloc_space(isl_space_copy(space), 1, ISL_MAP_DISJOINT(1 << 0));
6008 map = isl_map_add_basic_map(map, isl_basic_map_universe(space));
6009 return map;
6010}
6011
6012__isl_give isl_setisl_map *isl_set_universe(__isl_take isl_space *space)
6013{
6014 struct isl_setisl_map *set;
6015 if (!space)
6016 return NULL((void*)0);
6017 set = isl_set_alloc_space(isl_space_copy(space), 1, ISL_MAP_DISJOINT(1 << 0));
6018 set = isl_set_add_basic_set(set, isl_basic_set_universe(space));
6019 return set;
6020}
6021
6022struct isl_map *isl_map_dup(struct isl_map *map)
6023{
6024 int i;
6025 struct isl_map *dup;
6026
6027 if (!map)
6028 return NULL((void*)0);
6029 dup = isl_map_alloc_space(isl_space_copy(map->dim), map->n, map->flags);
6030 for (i = 0; i < map->n; ++i)
6031 dup = isl_map_add_basic_map(dup, isl_basic_map_copy(map->p[i]));
6032 return dup;
6033}
6034
6035__isl_give isl_map *isl_map_add_basic_map(__isl_take isl_map *map,
6036 __isl_take isl_basic_map *bmap)
6037{
6038 if (!bmap || !map)
6039 goto error;
6040 if (isl_basic_map_plain_is_empty(bmap)) {
6041 isl_basic_map_free(bmap);
6042 return map;
6043 }
6044 isl_assert(map->ctx, isl_space_is_equal(map->dim, bmap->dim), goto error)do { if (isl_space_is_equal(map->dim, bmap->dim)) break
; do { isl_handle_error(map->ctx, isl_error_unknown, "Assertion \""
"isl_space_is_equal(map->dim, bmap->dim)" "\" failed",
"/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6044); goto error; } while (0); } while (0)
;
6045 isl_assert(map->ctx, map->n < map->size, goto error)do { if (map->n < map->size) break; do { isl_handle_error
(map->ctx, isl_error_unknown, "Assertion \"" "map->n < map->size"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6045); goto error; } while (0); } while (0)
;
6046 map->p[map->n] = bmap;
6047 map->n++;
6048 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
6049 return map;
6050error:
6051 if (map)
6052 isl_map_free(map);
6053 if (bmap)
6054 isl_basic_map_free(bmap);
6055 return NULL((void*)0);
6056}
6057
6058__isl_null isl_map *isl_map_free(__isl_take isl_map *map)
6059{
6060 int i;
6061
6062 if (!map)
6063 return NULL((void*)0);
6064
6065 if (--map->ref > 0)
6066 return NULL((void*)0);
6067
6068 clear_caches(map);
6069 isl_ctx_deref(map->ctx);
6070 for (i = 0; i < map->n; ++i)
6071 isl_basic_map_free(map->p[i]);
6072 isl_space_free(map->dim);
6073 free(map);
6074
6075 return NULL((void*)0);
6076}
6077
6078static struct isl_basic_map *isl_basic_map_fix_pos_si(
6079 struct isl_basic_map *bmap, unsigned pos, int value)
6080{
6081 int j;
6082
6083 bmap = isl_basic_map_cow(bmap);
6084 bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
6085 j = isl_basic_map_alloc_equality(bmap);
6086 if (j < 0)
6087 goto error;
6088 isl_seq_clr(bmap->eq[j] + 1, isl_basic_map_total_dim(bmap));
6089 isl_int_set_si(bmap->eq[j][pos], -1)isl_sioimath_set_si((bmap->eq[j][pos]), -1);
6090 isl_int_set_si(bmap->eq[j][0], value)isl_sioimath_set_si((bmap->eq[j][0]), value);
6091 bmap = isl_basic_map_simplify(bmap);
6092 return isl_basic_map_finalize(bmap);
6093error:
6094 isl_basic_map_free(bmap);
6095 return NULL((void*)0);
6096}
6097
6098static __isl_give isl_basic_map *isl_basic_map_fix_pos(
6099 __isl_take isl_basic_map *bmap, unsigned pos, isl_int value)
6100{
6101 int j;
6102
6103 bmap = isl_basic_map_cow(bmap);
6104 bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
6105 j = isl_basic_map_alloc_equality(bmap);
6106 if (j < 0)
6107 goto error;
6108 isl_seq_clr(bmap->eq[j] + 1, isl_basic_map_total_dim(bmap));
6109 isl_int_set_si(bmap->eq[j][pos], -1)isl_sioimath_set_si((bmap->eq[j][pos]), -1);
6110 isl_int_set(bmap->eq[j][0], value)isl_sioimath_set((bmap->eq[j][0]), *(value));
6111 bmap = isl_basic_map_simplify(bmap);
6112 return isl_basic_map_finalize(bmap);
6113error:
6114 isl_basic_map_free(bmap);
6115 return NULL((void*)0);
6116}
6117
6118__isl_give isl_basic_map *isl_basic_map_fix_si(__isl_take isl_basic_map *bmap,
6119 enum isl_dim_type type, unsigned pos, int value)
6120{
6121 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
6122 return isl_basic_map_free(bmap);
6123 return isl_basic_map_fix_pos_si(bmap,
6124 isl_basic_map_offset(bmap, type) + pos, value);
6125}
6126
6127__isl_give isl_basic_map *isl_basic_map_fix(__isl_take isl_basic_map *bmap,
6128 enum isl_dim_type type, unsigned pos, isl_int value)
6129{
6130 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
6131 return isl_basic_map_free(bmap);
6132 return isl_basic_map_fix_pos(bmap,
6133 isl_basic_map_offset(bmap, type) + pos, value);
6134}
6135
6136/* Fix the value of the variable at position "pos" of type "type" of "bmap"
6137 * to be equal to "v".
6138 */
6139__isl_give isl_basic_map *isl_basic_map_fix_val(__isl_take isl_basic_map *bmap,
6140 enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
6141{
6142 if (!bmap || !v)
6143 goto error;
6144 if (!isl_val_is_int(v))
6145 isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "expecting integer value", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6146); goto error; } while (0)
6146 "expecting integer value", goto error)do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "expecting integer value", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6146); goto error; } while (0)
;
6147 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
6148 goto error;
6149 pos += isl_basic_map_offset(bmap, type);
6150 bmap = isl_basic_map_fix_pos(bmap, pos, v->n);
6151 isl_val_free(v);
6152 return bmap;
6153error:
6154 isl_basic_map_free(bmap);
6155 isl_val_free(v);
6156 return NULL((void*)0);
6157}
6158
6159/* Fix the value of the variable at position "pos" of type "type" of "bset"
6160 * to be equal to "v".
6161 */
6162__isl_give isl_basic_setisl_basic_map *isl_basic_set_fix_val(__isl_take isl_basic_setisl_basic_map *bset,
6163 enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
6164{
6165 return isl_basic_map_fix_val(bset, type, pos, v);
6166}
6167
6168struct isl_basic_setisl_basic_map *isl_basic_set_fix_si(struct isl_basic_setisl_basic_map *bset,
6169 enum isl_dim_type type, unsigned pos, int value)
6170{
6171 return bset_from_bmap(isl_basic_map_fix_si(bset_to_bmap(bset),
6172 type, pos, value));
6173}
6174
6175__isl_give isl_basic_setisl_basic_map *isl_basic_set_fix(__isl_take isl_basic_setisl_basic_map *bset,
6176 enum isl_dim_type type, unsigned pos, isl_int value)
6177{
6178 return bset_from_bmap(isl_basic_map_fix(bset_to_bmap(bset),
6179 type, pos, value));
6180}
6181
6182struct isl_basic_map *isl_basic_map_fix_input_si(struct isl_basic_map *bmap,
6183 unsigned input, int value)
6184{
6185 return isl_basic_map_fix_si(bmap, isl_dim_in, input, value);
6186}
6187
6188struct isl_basic_setisl_basic_map *isl_basic_set_fix_dim_si(struct isl_basic_setisl_basic_map *bset,
6189 unsigned dim, int value)
6190{
6191 return bset_from_bmap(isl_basic_map_fix_si(bset_to_bmap(bset),
6192 isl_dim_set, dim, value));
6193}
6194
6195static int remove_if_empty(__isl_keep isl_map *map, int i)
6196{
6197 int empty = isl_basic_map_plain_is_empty(map->p[i]);
6198
6199 if (empty < 0)
6200 return -1;
6201 if (!empty)
6202 return 0;
6203
6204 isl_basic_map_free(map->p[i]);
6205 if (i != map->n - 1) {
6206 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
6207 map->p[i] = map->p[map->n - 1];
6208 }
6209 map->n--;
6210
6211 return 0;
6212}
6213
6214/* Perform "fn" on each basic map of "map", where we may not be holding
6215 * the only reference to "map".
6216 * In particular, "fn" should be a semantics preserving operation
6217 * that we want to apply to all copies of "map". We therefore need
6218 * to be careful not to modify "map" in a way that breaks "map"
6219 * in case anything goes wrong.
6220 */
6221__isl_give isl_map *isl_map_inline_foreach_basic_map(__isl_take isl_map *map,
6222 __isl_give isl_basic_map *(*fn)(__isl_take isl_basic_map *bmap))
6223{
6224 struct isl_basic_map *bmap;
6225 int i;
6226
6227 if (!map)
6228 return NULL((void*)0);
6229
6230 for (i = map->n - 1; i >= 0; --i) {
6231 bmap = isl_basic_map_copy(map->p[i]);
6232 bmap = fn(bmap);
6233 if (!bmap)
6234 goto error;
6235 isl_basic_map_free(map->p[i]);
6236 map->p[i] = bmap;
6237 if (remove_if_empty(map, i) < 0)
6238 goto error;
6239 }
6240
6241 return map;
6242error:
6243 isl_map_free(map);
6244 return NULL((void*)0);
6245}
6246
6247__isl_give isl_map *isl_map_fix_si(__isl_take isl_map *map,
6248 enum isl_dim_type type, unsigned pos, int value)
6249{
6250 int i;
6251
6252 map = isl_map_cow(map);
6253 if (!map)
6254 return NULL((void*)0);
6255
6256 isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error)do { if (pos < isl_map_dim(map, type)) break; do { isl_handle_error
(map->ctx, isl_error_unknown, "Assertion \"" "pos < isl_map_dim(map, type)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6256); goto error; } while (0); } while (0)
;
6257 for (i = map->n - 1; i >= 0; --i) {
6258 map->p[i] = isl_basic_map_fix_si(map->p[i], type, pos, value);
6259 if (remove_if_empty(map, i) < 0)
6260 goto error;
6261 }
6262 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
6263 return map;
6264error:
6265 isl_map_free(map);
6266 return NULL((void*)0);
6267}
6268
6269__isl_give isl_setisl_map *isl_set_fix_si(__isl_take isl_setisl_map *set,
6270 enum isl_dim_type type, unsigned pos, int value)
6271{
6272 return set_from_map(isl_map_fix_si(set_to_map(set), type, pos, value));
6273}
6274
6275__isl_give isl_map *isl_map_fix(__isl_take isl_map *map,
6276 enum isl_dim_type type, unsigned pos, isl_int value)
6277{
6278 int i;
6279
6280 map = isl_map_cow(map);
6281 if (!map)
6282 return NULL((void*)0);
6283
6284 isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error)do { if (pos < isl_map_dim(map, type)) break; do { isl_handle_error
(map->ctx, isl_error_unknown, "Assertion \"" "pos < isl_map_dim(map, type)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6284); goto error; } while (0); } while (0)
;
6285 for (i = 0; i < map->n; ++i) {
6286 map->p[i] = isl_basic_map_fix(map->p[i], type, pos, value);
6287 if (!map->p[i])
6288 goto error;
6289 }
6290 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
6291 return map;
6292error:
6293 isl_map_free(map);
6294 return NULL((void*)0);
6295}
6296
6297__isl_give isl_setisl_map *isl_set_fix(__isl_take isl_setisl_map *set,
6298 enum isl_dim_type type, unsigned pos, isl_int value)
6299{
6300 return set_from_map(isl_map_fix(set_to_map(set), type, pos, value));
6301}
6302
6303/* Fix the value of the variable at position "pos" of type "type" of "map"
6304 * to be equal to "v".
6305 */
6306__isl_give isl_map *isl_map_fix_val(__isl_take isl_map *map,
6307 enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
6308{
6309 int i;
6310
6311 map = isl_map_cow(map);
6312 if (!map || !v)
6313 goto error;
6314
6315 if (!isl_val_is_int(v))
6316 isl_die(isl_map_get_ctx(map), isl_error_invalid,do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "expecting integer value", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6317); goto error; } while (0)
6317 "expecting integer value", goto error)do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "expecting integer value", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6317); goto error; } while (0)
;
6318 if (pos >= isl_map_dim(map, type))
6319 isl_die(isl_map_get_ctx(map), isl_error_invalid,do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6320); goto error; } while (0)
6320 "index out of bounds", goto error)do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6320); goto error; } while (0)
;
6321 for (i = map->n - 1; i >= 0; --i) {
6322 map->p[i] = isl_basic_map_fix_val(map->p[i], type, pos,
6323 isl_val_copy(v));
6324 if (remove_if_empty(map, i) < 0)
6325 goto error;
6326 }
6327 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
6328 isl_val_free(v);
6329 return map;
6330error:
6331 isl_map_free(map);
6332 isl_val_free(v);
6333 return NULL((void*)0);
6334}
6335
6336/* Fix the value of the variable at position "pos" of type "type" of "set"
6337 * to be equal to "v".
6338 */
6339__isl_give isl_setisl_map *isl_set_fix_val(__isl_take isl_setisl_map *set,
6340 enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
6341{
6342 return isl_map_fix_val(set, type, pos, v);
6343}
6344
6345struct isl_map *isl_map_fix_input_si(struct isl_map *map,
6346 unsigned input, int value)
6347{
6348 return isl_map_fix_si(map, isl_dim_in, input, value);
6349}
6350
6351struct isl_setisl_map *isl_set_fix_dim_si(struct isl_setisl_map *set, unsigned dim, int value)
6352{
6353 return set_from_map(isl_map_fix_si(set_to_map(set),
6354 isl_dim_set, dim, value));
6355}
6356
6357static __isl_give isl_basic_map *basic_map_bound_si(
6358 __isl_take isl_basic_map *bmap,
6359 enum isl_dim_type type, unsigned pos, int value, int upper)
6360{
6361 int j;
6362
6363 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
6364 return isl_basic_map_free(bmap);
6365 pos += isl_basic_map_offset(bmap, type);
6366 bmap = isl_basic_map_cow(bmap);
6367 bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
6368 j = isl_basic_map_alloc_inequality(bmap);
6369 if (j < 0)
6370 goto error;
6371 isl_seq_clr(bmap->ineq[j], 1 + isl_basic_map_total_dim(bmap));
6372 if (upper) {
6373 isl_int_set_si(bmap->ineq[j][pos], -1)isl_sioimath_set_si((bmap->ineq[j][pos]), -1);
6374 isl_int_set_si(bmap->ineq[j][0], value)isl_sioimath_set_si((bmap->ineq[j][0]), value);
6375 } else {
6376 isl_int_set_si(bmap->ineq[j][pos], 1)isl_sioimath_set_si((bmap->ineq[j][pos]), 1);
6377 isl_int_set_si(bmap->ineq[j][0], -value)isl_sioimath_set_si((bmap->ineq[j][0]), -value);
6378 }
6379 bmap = isl_basic_map_simplify(bmap);
6380 return isl_basic_map_finalize(bmap);
6381error:
6382 isl_basic_map_free(bmap);
6383 return NULL((void*)0);
6384}
6385
6386__isl_give isl_basic_map *isl_basic_map_lower_bound_si(
6387 __isl_take isl_basic_map *bmap,
6388 enum isl_dim_type type, unsigned pos, int value)
6389{
6390 return basic_map_bound_si(bmap, type, pos, value, 0);
6391}
6392
6393/* Constrain the values of the given dimension to be no greater than "value".
6394 */
6395__isl_give isl_basic_map *isl_basic_map_upper_bound_si(
6396 __isl_take isl_basic_map *bmap,
6397 enum isl_dim_type type, unsigned pos, int value)
6398{
6399 return basic_map_bound_si(bmap, type, pos, value, 1);
6400}
6401
6402static __isl_give isl_map *map_bound_si(__isl_take isl_map *map,
6403 enum isl_dim_type type, unsigned pos, int value, int upper)
6404{
6405 int i;
6406
6407 map = isl_map_cow(map);
6408 if (!map)
6409 return NULL((void*)0);
6410
6411 isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error)do { if (pos < isl_map_dim(map, type)) break; do { isl_handle_error
(map->ctx, isl_error_unknown, "Assertion \"" "pos < isl_map_dim(map, type)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6411); goto error; } while (0); } while (0)
;
6412 for (i = 0; i < map->n; ++i) {
6413 map->p[i] = basic_map_bound_si(map->p[i],
6414 type, pos, value, upper);
6415 if (!map->p[i])
6416 goto error;
6417 }
6418 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
6419 return map;
6420error:
6421 isl_map_free(map);
6422 return NULL((void*)0);
6423}
6424
6425__isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map,
6426 enum isl_dim_type type, unsigned pos, int value)
6427{
6428 return map_bound_si(map, type, pos, value, 0);
6429}
6430
6431__isl_give isl_map *isl_map_upper_bound_si(__isl_take isl_map *map,
6432 enum isl_dim_type type, unsigned pos, int value)
6433{
6434 return map_bound_si(map, type, pos, value, 1);
6435}
6436
6437__isl_give isl_setisl_map *isl_set_lower_bound_si(__isl_take isl_setisl_map *set,
6438 enum isl_dim_type type, unsigned pos, int value)
6439{
6440 return set_from_map(isl_map_lower_bound_si(set_to_map(set),
6441 type, pos, value));
6442}
6443
6444__isl_give isl_setisl_map *isl_set_upper_bound_si(__isl_take isl_setisl_map *set,
6445 enum isl_dim_type type, unsigned pos, int value)
6446{
6447 return isl_map_upper_bound_si(set, type, pos, value);
6448}
6449
6450/* Bound the given variable of "bmap" from below (or above is "upper"
6451 * is set) to "value".
6452 */
6453static __isl_give isl_basic_map *basic_map_bound(
6454 __isl_take isl_basic_map *bmap,
6455 enum isl_dim_type type, unsigned pos, isl_int value, int upper)
6456{
6457 int j;
6458
6459 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
6460 return isl_basic_map_free(bmap);
6461 pos += isl_basic_map_offset(bmap, type);
6462 bmap = isl_basic_map_cow(bmap);
6463 bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
6464 j = isl_basic_map_alloc_inequality(bmap);
6465 if (j < 0)
6466 goto error;
6467 isl_seq_clr(bmap->ineq[j], 1 + isl_basic_map_total_dim(bmap));
6468 if (upper) {
6469 isl_int_set_si(bmap->ineq[j][pos], -1)isl_sioimath_set_si((bmap->ineq[j][pos]), -1);
6470 isl_int_set(bmap->ineq[j][0], value)isl_sioimath_set((bmap->ineq[j][0]), *(value));
6471 } else {
6472 isl_int_set_si(bmap->ineq[j][pos], 1)isl_sioimath_set_si((bmap->ineq[j][pos]), 1);
6473 isl_int_neg(bmap->ineq[j][0], value)isl_sioimath_neg((bmap->ineq[j][0]), *(value));
6474 }
6475 bmap = isl_basic_map_simplify(bmap);
6476 return isl_basic_map_finalize(bmap);
6477error:
6478 isl_basic_map_free(bmap);
6479 return NULL((void*)0);
6480}
6481
6482/* Bound the given variable of "map" from below (or above is "upper"
6483 * is set) to "value".
6484 */
6485static __isl_give isl_map *map_bound(__isl_take isl_map *map,
6486 enum isl_dim_type type, unsigned pos, isl_int value, int upper)
6487{
6488 int i;
6489
6490 map = isl_map_cow(map);
6491 if (!map)
6492 return NULL((void*)0);
6493
6494 if (pos >= isl_map_dim(map, type))
6495 isl_die(map->ctx, isl_error_invalid,do { isl_handle_error(map->ctx, isl_error_invalid, "index out of bounds"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6496); goto error; } while (0)
6496 "index out of bounds", goto error)do { isl_handle_error(map->ctx, isl_error_invalid, "index out of bounds"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6496); goto error; } while (0)
;
6497 for (i = map->n - 1; i >= 0; --i) {
6498 map->p[i] = basic_map_bound(map->p[i], type, pos, value, upper);
6499 if (remove_if_empty(map, i) < 0)
6500 goto error;
6501 }
6502 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
6503 return map;
6504error:
6505 isl_map_free(map);
6506 return NULL((void*)0);
6507}
6508
6509__isl_give isl_map *isl_map_lower_bound(__isl_take isl_map *map,
6510 enum isl_dim_type type, unsigned pos, isl_int value)
6511{
6512 return map_bound(map, type, pos, value, 0);
6513}
6514
6515__isl_give isl_map *isl_map_upper_bound(__isl_take isl_map *map,
6516 enum isl_dim_type type, unsigned pos, isl_int value)
6517{
6518 return map_bound(map, type, pos, value, 1);
6519}
6520
6521__isl_give isl_setisl_map *isl_set_lower_bound(__isl_take isl_setisl_map *set,
6522 enum isl_dim_type type, unsigned pos, isl_int value)
6523{
6524 return isl_map_lower_bound(set, type, pos, value);
6525}
6526
6527__isl_give isl_setisl_map *isl_set_upper_bound(__isl_take isl_setisl_map *set,
6528 enum isl_dim_type type, unsigned pos, isl_int value)
6529{
6530 return isl_map_upper_bound(set, type, pos, value);
6531}
6532
6533/* Force the values of the variable at position "pos" of type "type" of "set"
6534 * to be no smaller than "value".
6535 */
6536__isl_give isl_setisl_map *isl_set_lower_bound_val(__isl_take isl_setisl_map *set,
6537 enum isl_dim_type type, unsigned pos, __isl_take isl_val *value)
6538{
6539 if (!value)
6540 goto error;
6541 if (!isl_val_is_int(value))
6542 isl_die(isl_set_get_ctx(set), isl_error_invalid,do { isl_handle_error(isl_set_get_ctx(set), isl_error_invalid
, "expecting integer value", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6543); goto error; } while (0)
6543 "expecting integer value", goto error)do { isl_handle_error(isl_set_get_ctx(set), isl_error_invalid
, "expecting integer value", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6543); goto error; } while (0)
;
6544 set = isl_set_lower_bound(set, type, pos, value->n);
6545 isl_val_free(value);
6546 return set;
6547error:
6548 isl_val_free(value);
6549 isl_set_free(set);
6550 return NULL((void*)0);
6551}
6552
6553/* Force the values of the variable at position "pos" of type "type" of "set"
6554 * to be no greater than "value".
6555 */
6556__isl_give isl_setisl_map *isl_set_upper_bound_val(__isl_take isl_setisl_map *set,
6557 enum isl_dim_type type, unsigned pos, __isl_take isl_val *value)
6558{
6559 if (!value)
6560 goto error;
6561 if (!isl_val_is_int(value))
6562 isl_die(isl_set_get_ctx(set), isl_error_invalid,do { isl_handle_error(isl_set_get_ctx(set), isl_error_invalid
, "expecting integer value", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6563); goto error; } while (0)
6563 "expecting integer value", goto error)do { isl_handle_error(isl_set_get_ctx(set), isl_error_invalid
, "expecting integer value", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6563); goto error; } while (0)
;
6564 set = isl_set_upper_bound(set, type, pos, value->n);
6565 isl_val_free(value);
6566 return set;
6567error:
6568 isl_val_free(value);
6569 isl_set_free(set);
6570 return NULL((void*)0);
6571}
6572
6573/* Bound the given variable of "bset" from below (or above is "upper"
6574 * is set) to "value".
6575 */
6576static __isl_give isl_basic_setisl_basic_map *isl_basic_set_bound(
6577 __isl_take isl_basic_setisl_basic_map *bset, enum isl_dim_type type, unsigned pos,
6578 isl_int value, int upper)
6579{
6580 return bset_from_bmap(basic_map_bound(bset_to_bmap(bset),
6581 type, pos, value, upper));
6582}
6583
6584/* Bound the given variable of "bset" from below (or above is "upper"
6585 * is set) to "value".
6586 */
6587static __isl_give isl_basic_setisl_basic_map *isl_basic_set_bound_val(
6588 __isl_take isl_basic_setisl_basic_map *bset, enum isl_dim_type type, unsigned pos,
6589 __isl_take isl_val *value, int upper)
6590{
6591 if (!value)
6592 goto error;
6593 if (!isl_val_is_int(value))
6594 isl_die(isl_basic_set_get_ctx(bset), isl_error_invalid,do { isl_handle_error(isl_basic_set_get_ctx(bset), isl_error_invalid
, "expecting integer value", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6595); goto error; } while (0)
6595 "expecting integer value", goto error)do { isl_handle_error(isl_basic_set_get_ctx(bset), isl_error_invalid
, "expecting integer value", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6595); goto error; } while (0)
;
6596 bset = isl_basic_set_bound(bset, type, pos, value->n, upper);
6597 isl_val_free(value);
6598 return bset;
6599error:
6600 isl_val_free(value);
6601 isl_basic_set_free(bset);
6602 return NULL((void*)0);
6603}
6604
6605/* Bound the given variable of "bset" from below to "value".
6606 */
6607__isl_give isl_basic_setisl_basic_map *isl_basic_set_lower_bound_val(
6608 __isl_take isl_basic_setisl_basic_map *bset, enum isl_dim_type type, unsigned pos,
6609 __isl_take isl_val *value)
6610{
6611 return isl_basic_set_bound_val(bset, type, pos, value, 0);
6612}
6613
6614/* Bound the given variable of "bset" from above to "value".
6615 */
6616__isl_give isl_basic_setisl_basic_map *isl_basic_set_upper_bound_val(
6617 __isl_take isl_basic_setisl_basic_map *bset, enum isl_dim_type type, unsigned pos,
6618 __isl_take isl_val *value)
6619{
6620 return isl_basic_set_bound_val(bset, type, pos, value, 1);
6621}
6622
6623__isl_give isl_map *isl_map_reverse(__isl_take isl_map *map)
6624{
6625 int i;
6626
6627 map = isl_map_cow(map);
6628 if (!map)
6629 return NULL((void*)0);
6630
6631 map->dim = isl_space_reverse(map->dim);
6632 if (!map->dim)
6633 goto error;
6634 for (i = 0; i < map->n; ++i) {
6635 map->p[i] = isl_basic_map_reverse(map->p[i]);
6636 if (!map->p[i])
6637 goto error;
6638 }
6639 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
6640 return map;
6641error:
6642 isl_map_free(map);
6643 return NULL((void*)0);
6644}
6645
6646#undef TYPEisl_map
6647#define TYPEisl_map isl_pw_multi_aff
6648#undef SUFFIX
6649#define SUFFIX _pw_multi_aff
6650#undef EMPTYisl_map_empty
6651#define EMPTYisl_map_empty isl_pw_multi_aff_empty
6652#undef ADDisl_map_union_disjoint
6653#define ADDisl_map_union_disjoint isl_pw_multi_aff_union_add
6654#include "isl_map_lexopt_templ.c"
6655
6656/* Given a map "map", compute the lexicographically minimal
6657 * (or maximal) image element for each domain element in dom,
6658 * in the form of an isl_pw_multi_aff.
6659 * If "empty" is not NULL, then set *empty to those elements in dom that
6660 * do not have an image element.
6661 * If "flags" includes ISL_OPT_FULL, then "dom" is NULL and the optimum
6662 * should be computed over the domain of "map". "empty" is also NULL
6663 * in this case.
6664 *
6665 * We first compute the lexicographically minimal or maximal element
6666 * in the first basic map. This results in a partial solution "res"
6667 * and a subset "todo" of dom that still need to be handled.
6668 * We then consider each of the remaining maps in "map" and successively
6669 * update both "res" and "todo".
6670 * If "empty" is NULL, then the todo sets are not needed and therefore
6671 * also not computed.
6672 */
6673static __isl_give isl_pw_multi_aff *isl_map_partial_lexopt_aligned_pw_multi_aff(
6674 __isl_take isl_map *map, __isl_take isl_setisl_map *dom,
6675 __isl_give isl_setisl_map **empty, unsigned flags)
6676{
6677 int i;
6678 int full;
6679 isl_pw_multi_aff *res;
6680 isl_setisl_map *todo;
6681
6682 full = ISL_FL_ISSET(flags, ISL_OPT_FULL)(!!((flags) & ((1 << 1))));
6683 if (!map || (!full && !dom))
6684 goto error;
6685
6686 if (isl_map_plain_is_empty(map)) {
6687 if (empty)
6688 *empty = dom;
6689 else
6690 isl_set_free(dom);
6691 return isl_pw_multi_aff_from_map(map);
6692 }
6693
6694 res = basic_map_partial_lexopt_pw_multi_aff(
6695 isl_basic_map_copy(map->p[0]),
6696 isl_set_copy(dom), empty, flags);
6697
6698 if (empty)
6699 todo = *empty;
6700 for (i = 1; i < map->n; ++i) {
6701 isl_pw_multi_aff *res_i;
6702
6703 res_i = basic_map_partial_lexopt_pw_multi_aff(
6704 isl_basic_map_copy(map->p[i]),
6705 isl_set_copy(dom), empty, flags);
6706
6707 if (ISL_FL_ISSET(flags, ISL_OPT_MAX)(!!((flags) & ((1 << 0)))))
6708 res = isl_pw_multi_aff_union_lexmax(res, res_i);
6709 else
6710 res = isl_pw_multi_aff_union_lexmin(res, res_i);
6711
6712 if (empty)
6713 todo = isl_set_intersect(todo, *empty);
6714 }
6715
6716 isl_set_free(dom);
6717 isl_map_free(map);
6718
6719 if (empty)
6720 *empty = todo;
6721
6722 return res;
6723error:
6724 if (empty)
6725 *empty = NULL((void*)0);
6726 isl_set_free(dom);
6727 isl_map_free(map);
6728 return NULL((void*)0);
6729}
6730
6731#undef TYPEisl_map
6732#define TYPEisl_map isl_map
6733#undef SUFFIX
6734#define SUFFIX
6735#undef EMPTYisl_map_empty
6736#define EMPTYisl_map_empty isl_map_empty
6737#undef ADDisl_map_union_disjoint
6738#define ADDisl_map_union_disjoint isl_map_union_disjoint
6739#include "isl_map_lexopt_templ.c"
6740
6741/* Given a map "map", compute the lexicographically minimal
6742 * (or maximal) image element for each domain element in "dom",
6743 * in the form of an isl_map.
6744 * If "empty" is not NULL, then set *empty to those elements in "dom" that
6745 * do not have an image element.
6746 * If "flags" includes ISL_OPT_FULL, then "dom" is NULL and the optimum
6747 * should be computed over the domain of "map". "empty" is also NULL
6748 * in this case.
6749 *
6750 * If the input consists of more than one disjunct, then first
6751 * compute the desired result in the form of an isl_pw_multi_aff and
6752 * then convert that into an isl_map.
6753 *
6754 * This function used to have an explicit implementation in terms
6755 * of isl_maps, but it would continually intersect the domains of
6756 * partial results with the complement of the domain of the next
6757 * partial solution, potentially leading to an explosion in the number
6758 * of disjuncts if there are several disjuncts in the input.
6759 * An even earlier implementation of this function would look for
6760 * better results in the domain of the partial result and for extra
6761 * results in the complement of this domain, which would lead to
6762 * even more splintering.
6763 */
6764static __isl_give isl_map *isl_map_partial_lexopt_aligned(
6765 __isl_take isl_map *map, __isl_take isl_setisl_map *dom,
6766 __isl_give isl_setisl_map **empty, unsigned flags)
6767{
6768 int full;
6769 struct isl_map *res;
6770 isl_pw_multi_aff *pma;
6771
6772 full = ISL_FL_ISSET(flags, ISL_OPT_FULL)(!!((flags) & ((1 << 1))));
6773 if (!map || (!full && !dom))
6774 goto error;
6775
6776 if (isl_map_plain_is_empty(map)) {
6777 if (empty)
6778 *empty = dom;
6779 else
6780 isl_set_free(dom);
6781 return map;
6782 }
6783
6784 if (map->n == 1) {
6785 res = basic_map_partial_lexopt(isl_basic_map_copy(map->p[0]),
6786 dom, empty, flags);
6787 isl_map_free(map);
6788 return res;
6789 }
6790
6791 pma = isl_map_partial_lexopt_aligned_pw_multi_aff(map, dom, empty,
6792 flags);
6793 return isl_map_from_pw_multi_aff(pma);
6794error:
6795 if (empty)
6796 *empty = NULL((void*)0);
6797 isl_set_free(dom);
6798 isl_map_free(map);
6799 return NULL((void*)0);
6800}
6801
6802__isl_give isl_map *isl_map_partial_lexmax(
6803 __isl_take isl_map *map, __isl_take isl_setisl_map *dom,
6804 __isl_give isl_setisl_map **empty)
6805{
6806 return isl_map_partial_lexopt(map, dom, empty, ISL_OPT_MAX(1 << 0));
6807}
6808
6809__isl_give isl_map *isl_map_partial_lexmin(
6810 __isl_take isl_map *map, __isl_take isl_setisl_map *dom,
6811 __isl_give isl_setisl_map **empty)
6812{
6813 return isl_map_partial_lexopt(map, dom, empty, 0);
6814}
6815
6816__isl_give isl_setisl_map *isl_set_partial_lexmin(
6817 __isl_take isl_setisl_map *set, __isl_take isl_setisl_map *dom,
6818 __isl_give isl_setisl_map **empty)
6819{
6820 return set_from_map(isl_map_partial_lexmin(set_to_map(set),
6821 dom, empty));
6822}
6823
6824__isl_give isl_setisl_map *isl_set_partial_lexmax(
6825 __isl_take isl_setisl_map *set, __isl_take isl_setisl_map *dom,
6826 __isl_give isl_setisl_map **empty)
6827{
6828 return set_from_map(isl_map_partial_lexmax(set_to_map(set),
6829 dom, empty));
6830}
6831
6832/* Compute the lexicographic minimum (or maximum if "flags" includes
6833 * ISL_OPT_MAX) of "bset" over its parametric domain.
6834 */
6835__isl_give isl_setisl_map *isl_basic_set_lexopt(__isl_take isl_basic_setisl_basic_map *bset,
6836 unsigned flags)
6837{
6838 return isl_basic_map_lexopt(bset, flags);
6839}
6840
6841__isl_give isl_map *isl_basic_map_lexmax(__isl_take isl_basic_map *bmap)
6842{
6843 return isl_basic_map_lexopt(bmap, ISL_OPT_MAX(1 << 0));
6844}
6845
6846__isl_give isl_setisl_map *isl_basic_set_lexmin(__isl_take isl_basic_setisl_basic_map *bset)
6847{
6848 return set_from_map(isl_basic_map_lexmin(bset_to_bmap(bset)));
6849}
6850
6851__isl_give isl_setisl_map *isl_basic_set_lexmax(__isl_take isl_basic_setisl_basic_map *bset)
6852{
6853 return set_from_map(isl_basic_map_lexmax(bset_to_bmap(bset)));
6854}
6855
6856/* Compute the lexicographic minimum of "bset" over its parametric domain
6857 * for the purpose of quantifier elimination.
6858 * That is, find an explicit representation for all the existentially
6859 * quantified variables in "bset" by computing their lexicographic
6860 * minimum.
6861 */
6862static __isl_give isl_setisl_map *isl_basic_set_lexmin_compute_divs(
6863 __isl_take isl_basic_setisl_basic_map *bset)
6864{
6865 return isl_basic_set_lexopt(bset, ISL_OPT_QE(1 << 2));
6866}
6867
6868/* Given a basic map with one output dimension, compute the minimum or
6869 * maximum of that dimension as an isl_pw_aff.
6870 *
6871 * Compute the optimum as a lexicographic optimum over the single
6872 * output dimension and extract the single isl_pw_aff from the result.
6873 */
6874static __isl_give isl_pw_aff *basic_map_dim_opt(__isl_keep isl_basic_map *bmap,
6875 int max)
6876{
6877 isl_pw_multi_aff *pma;
6878 isl_pw_aff *pwaff;
6879
6880 bmap = isl_basic_map_copy(bmap);
6881 pma = isl_basic_map_lexopt_pw_multi_aff(bmap, max ? ISL_OPT_MAX(1 << 0) : 0);
6882 pwaff = isl_pw_multi_aff_get_pw_aff(pma, 0);
6883 isl_pw_multi_aff_free(pma);
6884
6885 return pwaff;
6886}
6887
6888/* Compute the minimum or maximum of the given output dimension
6889 * as a function of the parameters and the input dimensions,
6890 * but independently of the other output dimensions.
6891 *
6892 * We first project out the other output dimension and then compute
6893 * the "lexicographic" maximum in each basic map, combining the results
6894 * using isl_pw_aff_union_max.
6895 */
6896static __isl_give isl_pw_aff *map_dim_opt(__isl_take isl_map *map, int pos,
6897 int max)
6898{
6899 int i;
6900 isl_pw_aff *pwaff;
6901 unsigned n_out;
6902
6903 n_out = isl_map_dim(map, isl_dim_out);
6904 map = isl_map_project_out(map, isl_dim_out, pos + 1, n_out - (pos + 1));
6905 map = isl_map_project_out(map, isl_dim_out, 0, pos);
6906 if (!map)
6907 return NULL((void*)0);
6908
6909 if (map->n == 0) {
6910 isl_space *dim = isl_map_get_space(map);
6911 isl_map_free(map);
6912 return isl_pw_aff_empty(dim);
6913 }
6914
6915 pwaff = basic_map_dim_opt(map->p[0], max);
6916 for (i = 1; i < map->n; ++i) {
6917 isl_pw_aff *pwaff_i;
6918
6919 pwaff_i = basic_map_dim_opt(map->p[i], max);
6920 pwaff = isl_pw_aff_union_opt(pwaff, pwaff_i, max);
6921 }
6922
6923 isl_map_free(map);
6924
6925 return pwaff;
6926}
6927
6928/* Compute the minimum of the given output dimension as a function of the
6929 * parameters and input dimensions, but independently of
6930 * the other output dimensions.
6931 */
6932__isl_give isl_pw_aff *isl_map_dim_min(__isl_take isl_map *map, int pos)
6933{
6934 return map_dim_opt(map, pos, 0);
6935}
6936
6937/* Compute the maximum of the given output dimension as a function of the
6938 * parameters and input dimensions, but independently of
6939 * the other output dimensions.
6940 */
6941__isl_give isl_pw_aff *isl_map_dim_max(__isl_take isl_map *map, int pos)
6942{
6943 return map_dim_opt(map, pos, 1);
6944}
6945
6946/* Compute the minimum or maximum of the given set dimension
6947 * as a function of the parameters,
6948 * but independently of the other set dimensions.
6949 */
6950static __isl_give isl_pw_aff *set_dim_opt(__isl_take isl_setisl_map *set, int pos,
6951 int max)
6952{
6953 return map_dim_opt(set, pos, max);
6954}
6955
6956/* Compute the maximum of the given set dimension as a function of the
6957 * parameters, but independently of the other set dimensions.
6958 */
6959__isl_give isl_pw_aff *isl_set_dim_max(__isl_take isl_setisl_map *set, int pos)
6960{
6961 return set_dim_opt(set, pos, 1);
6962}
6963
6964/* Compute the minimum of the given set dimension as a function of the
6965 * parameters, but independently of the other set dimensions.
6966 */
6967__isl_give isl_pw_aff *isl_set_dim_min(__isl_take isl_setisl_map *set, int pos)
6968{
6969 return set_dim_opt(set, pos, 0);
6970}
6971
6972/* Apply a preimage specified by "mat" on the parameters of "bset".
6973 * bset is assumed to have only parameters and divs.
6974 */
6975static __isl_give isl_basic_setisl_basic_map *basic_set_parameter_preimage(
6976 __isl_take isl_basic_setisl_basic_map *bset, __isl_take isl_mat *mat)
6977{
6978 unsigned nparam;
6979
6980 if (!bset || !mat)
6981 goto error;
6982
6983 bset->dim = isl_space_cow(bset->dim);
6984 if (!bset->dim)
6985 goto error;
6986
6987 nparam = isl_basic_set_dim(bset, isl_dim_param);
6988
6989 isl_assert(bset->ctx, mat->n_row == 1 + nparam, goto error)do { if (mat->n_row == 1 + nparam) break; do { isl_handle_error
(bset->ctx, isl_error_unknown, "Assertion \"" "mat->n_row == 1 + nparam"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 6989); goto error; } while (0); } while (0)
;
6990
6991 bset->dim->nparam = 0;
6992 bset->dim->n_out = nparam;
6993 bset = isl_basic_set_preimage(bset, mat);
6994 if (bset) {
6995 bset->dim->nparam = bset->dim->n_out;
6996 bset->dim->n_out = 0;
6997 }
6998 return bset;
6999error:
7000 isl_mat_free(mat);
7001 isl_basic_set_free(bset);
7002 return NULL((void*)0);
7003}
7004
7005/* Apply a preimage specified by "mat" on the parameters of "set".
7006 * set is assumed to have only parameters and divs.
7007 */
7008static __isl_give isl_setisl_map *set_parameter_preimage(__isl_take isl_setisl_map *set,
7009 __isl_take isl_mat *mat)
7010{
7011 isl_space *space;
7012 unsigned nparam;
7013
7014 if (!set || !mat)
7015 goto error;
7016
7017 nparam = isl_set_dim(set, isl_dim_param);
7018
7019 if (mat->n_row != 1 + nparam)
7020 isl_die(isl_set_get_ctx(set), isl_error_internal,do { isl_handle_error(isl_set_get_ctx(set), isl_error_internal
, "unexpected number of rows", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 7021); goto error; } while (0)
7021 "unexpected number of rows", goto error)do { isl_handle_error(isl_set_get_ctx(set), isl_error_internal
, "unexpected number of rows", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 7021); goto error; } while (0)
;
7022
7023 space = isl_set_get_space(set);
7024 space = isl_space_move_dims(space, isl_dim_set, 0,
7025 isl_dim_param, 0, nparam);
7026 set = isl_set_reset_space(set, space);
7027 set = isl_set_preimage(set, mat);
7028 nparam = isl_set_dim(set, isl_dim_out);
7029 space = isl_set_get_space(set);
7030 space = isl_space_move_dims(space, isl_dim_param, 0,
7031 isl_dim_out, 0, nparam);
7032 set = isl_set_reset_space(set, space);
7033 return set;
7034error:
7035 isl_mat_free(mat);
7036 isl_set_free(set);
7037 return NULL((void*)0);
7038}
7039
7040/* Intersect the basic set "bset" with the affine space specified by the
7041 * equalities in "eq".
7042 */
7043static __isl_give isl_basic_setisl_basic_map *basic_set_append_equalities(
7044 __isl_take isl_basic_setisl_basic_map *bset, __isl_take isl_mat *eq)
7045{
7046 int i, k;
7047 unsigned len;
7048
7049 if (!bset || !eq)
7050 goto error;
7051
7052 bset = isl_basic_set_extend_space(bset, isl_space_copy(bset->dim), 0,
7053 eq->n_row, 0);
7054 if (!bset)
7055 goto error;
7056
7057 len = 1 + isl_space_dim(bset->dim, isl_dim_all) + bset->extra;
7058 for (i = 0; i < eq->n_row; ++i) {
7059 k = isl_basic_set_alloc_equality(bset);
7060 if (k < 0)
7061 goto error;
7062 isl_seq_cpy(bset->eq[k], eq->row[i], eq->n_col);
7063 isl_seq_clr(bset->eq[k] + eq->n_col, len - eq->n_col);
7064 }
7065 isl_mat_free(eq);
7066
7067 bset = isl_basic_set_gauss(bset, NULL((void*)0));
7068 bset = isl_basic_set_finalize(bset);
7069
7070 return bset;
7071error:
7072 isl_mat_free(eq);
7073 isl_basic_set_free(bset);
7074 return NULL((void*)0);
7075}
7076
7077/* Intersect the set "set" with the affine space specified by the
7078 * equalities in "eq".
7079 */
7080static struct isl_setisl_map *set_append_equalities(struct isl_setisl_map *set,
7081 struct isl_mat *eq)
7082{
7083 int i;
7084
7085 if (!set || !eq)
7086 goto error;
7087
7088 for (i = 0; i < set->n; ++i) {
7089 set->p[i] = basic_set_append_equalities(set->p[i],
7090 isl_mat_copy(eq));
7091 if (!set->p[i])
7092 goto error;
7093 }
7094 isl_mat_free(eq);
7095 return set;
7096error:
7097 isl_mat_free(eq);
7098 isl_set_free(set);
7099 return NULL((void*)0);
7100}
7101
7102/* Given a basic set "bset" that only involves parameters and existentially
7103 * quantified variables, return the index of the first equality
7104 * that only involves parameters. If there is no such equality then
7105 * return bset->n_eq.
7106 *
7107 * This function assumes that isl_basic_set_gauss has been called on "bset".
7108 */
7109static int first_parameter_equality(__isl_keep isl_basic_setisl_basic_map *bset)
7110{
7111 int i, j;
7112 unsigned nparam, n_div;
7113
7114 if (!bset)
7115 return -1;
7116
7117 nparam = isl_basic_set_dim(bset, isl_dim_param);
7118 n_div = isl_basic_set_dim(bset, isl_dim_div);
7119
7120 for (i = 0, j = n_div - 1; i < bset->n_eq && j >= 0; --j) {
7121 if (!isl_int_is_zero(bset->eq[i][1 + nparam + j])(isl_sioimath_sgn(*(bset->eq[i][1 + nparam + j])) == 0))
7122 ++i;
7123 }
7124
7125 return i;
7126}
7127
7128/* Compute an explicit representation for the existentially quantified
7129 * variables in "bset" by computing the "minimal value" of the set
7130 * variables. Since there are no set variables, the computation of
7131 * the minimal value essentially computes an explicit representation
7132 * of the non-empty part(s) of "bset".
7133 *
7134 * The input only involves parameters and existentially quantified variables.
7135 * All equalities among parameters have been removed.
7136 *
7137 * Since the existentially quantified variables in the result are in general
7138 * going to be different from those in the input, we first replace
7139 * them by the minimal number of variables based on their equalities.
7140 * This should simplify the parametric integer programming.
7141 */
7142static __isl_give isl_setisl_map *base_compute_divs(__isl_take isl_basic_setisl_basic_map *bset)
7143{
7144 isl_morph *morph1, *morph2;
7145 isl_setisl_map *set;
7146 unsigned n;
7147
7148 if (!bset)
7149 return NULL((void*)0);
7150 if (bset->n_eq == 0)
7151 return isl_basic_set_lexmin_compute_divs(bset);
7152
7153 morph1 = isl_basic_set_parameter_compression(bset);
7154 bset = isl_morph_basic_set(isl_morph_copy(morph1), bset);
7155 bset = isl_basic_set_lift(bset);
7156 morph2 = isl_basic_set_variable_compression(bset, isl_dim_set);
7157 bset = isl_morph_basic_set(morph2, bset);
7158 n = isl_basic_set_dim(bset, isl_dim_set);
7159 bset = isl_basic_set_project_out(bset, isl_dim_set, 0, n);
7160
7161 set = isl_basic_set_lexmin_compute_divs(bset);
7162
7163 set = isl_morph_set(isl_morph_inverse(morph1), set);
7164
7165 return set;
7166}
7167
7168/* Project the given basic set onto its parameter domain, possibly introducing
7169 * new, explicit, existential variables in the constraints.
7170 * The input has parameters and (possibly implicit) existential variables.
7171 * The output has the same parameters, but only
7172 * explicit existentially quantified variables.
7173 *
7174 * The actual projection is performed by pip, but pip doesn't seem
7175 * to like equalities very much, so we first remove the equalities
7176 * among the parameters by performing a variable compression on
7177 * the parameters. Afterward, an inverse transformation is performed
7178 * and the equalities among the parameters are inserted back in.
7179 *
7180 * The variable compression on the parameters may uncover additional
7181 * equalities that were only implicit before. We therefore check
7182 * if there are any new parameter equalities in the result and
7183 * if so recurse. The removal of parameter equalities is required
7184 * for the parameter compression performed by base_compute_divs.
7185 */
7186static struct isl_setisl_map *parameter_compute_divs(struct isl_basic_setisl_basic_map *bset)
7187{
7188 int i;
7189 struct isl_mat *eq;
7190 struct isl_mat *T, *T2;
7191 struct isl_setisl_map *set;
7192 unsigned nparam;
7193
7194 bset = isl_basic_set_cow(bset);
7195 if (!bset)
7196 return NULL((void*)0);
7197
7198 if (bset->n_eq == 0)
7199 return base_compute_divs(bset);
7200
7201 bset = isl_basic_set_gauss(bset, NULL((void*)0));
7202 if (!bset)
7203 return NULL((void*)0);
7204 if (isl_basic_set_plain_is_empty(bset))
7205 return isl_set_from_basic_set(bset);
7206
7207 i = first_parameter_equality(bset);
7208 if (i == bset->n_eq)
7209 return base_compute_divs(bset);
7210
7211 nparam = isl_basic_set_dim(bset, isl_dim_param);
7212 eq = isl_mat_sub_alloc6(bset->ctx, bset->eq, i, bset->n_eq - i,
7213 0, 1 + nparam);
7214 eq = isl_mat_cow(eq);
7215 T = isl_mat_variable_compression(isl_mat_copy(eq), &T2);
7216 if (T && T->n_col == 0) {
7217 isl_mat_free(T);
7218 isl_mat_free(T2);
7219 isl_mat_free(eq);
7220 bset = isl_basic_set_set_to_empty(bset);
7221 return isl_set_from_basic_set(bset);
7222 }
7223 bset = basic_set_parameter_preimage(bset, T);
7224
7225 i = first_parameter_equality(bset);
7226 if (!bset)
7227 set = NULL((void*)0);
7228 else if (i == bset->n_eq)
7229 set = base_compute_divs(bset);
7230 else
7231 set = parameter_compute_divs(bset);
7232 set = set_parameter_preimage(set, T2);
7233 set = set_append_equalities(set, eq);
7234 return set;
7235}
7236
7237/* Insert the divs from "ls" before those of "bmap".
7238 *
7239 * The number of columns is not changed, which means that the last
7240 * dimensions of "bmap" are being reintepreted as the divs from "ls".
7241 * The caller is responsible for removing the same number of dimensions
7242 * from the space of "bmap".
7243 */
7244static __isl_give isl_basic_map *insert_divs_from_local_space(
7245 __isl_take isl_basic_map *bmap, __isl_keep isl_local_space *ls)
7246{
7247 int i;
7248 int n_div;
7249 int old_n_div;
7250
7251 n_div = isl_local_space_dim(ls, isl_dim_div);
7252 if (n_div == 0)
7253 return bmap;
7254
7255 old_n_div = bmap->n_div;
7256 bmap = insert_div_rows(bmap, n_div);
7257 if (!bmap)
7258 return NULL((void*)0);
7259
7260 for (i = 0; i < n_div; ++i) {
7261 isl_seq_cpy(bmap->div[i], ls->div->row[i], ls->div->n_col);
7262 isl_seq_clr(bmap->div[i] + ls->div->n_col, old_n_div);
7263 }
7264
7265 return bmap;
7266}
7267
7268/* Replace the space of "bmap" by the space and divs of "ls".
7269 *
7270 * If "ls" has any divs, then we simplify the result since we may
7271 * have discovered some additional equalities that could simplify
7272 * the div expressions.
7273 */
7274static __isl_give isl_basic_map *basic_replace_space_by_local_space(
7275 __isl_take isl_basic_map *bmap, __isl_take isl_local_space *ls)
7276{
7277 int n_div;
7278
7279 bmap = isl_basic_map_cow(bmap);
7280 if (!bmap || !ls)
7281 goto error;
7282
7283 n_div = isl_local_space_dim(ls, isl_dim_div);
7284 bmap = insert_divs_from_local_space(bmap, ls);
7285 if (!bmap)
7286 goto error;
7287
7288 isl_space_free(bmap->dim);
7289 bmap->dim = isl_local_space_get_space(ls);
7290 if (!bmap->dim)
7291 goto error;
7292
7293 isl_local_space_free(ls);
7294 if (n_div > 0)
7295 bmap = isl_basic_map_simplify(bmap);
7296 bmap = isl_basic_map_finalize(bmap);
7297 return bmap;
7298error:
7299 isl_basic_map_free(bmap);
7300 isl_local_space_free(ls);
7301 return NULL((void*)0);
7302}
7303
7304/* Replace the space of "map" by the space and divs of "ls".
7305 */
7306static __isl_give isl_map *replace_space_by_local_space(__isl_take isl_map *map,
7307 __isl_take isl_local_space *ls)
7308{
7309 int i;
7310
7311 map = isl_map_cow(map);
7312 if (!map || !ls)
7313 goto error;
7314
7315 for (i = 0; i < map->n; ++i) {
7316 map->p[i] = basic_replace_space_by_local_space(map->p[i],
7317 isl_local_space_copy(ls));
7318 if (!map->p[i])
7319 goto error;
7320 }
7321 isl_space_free(map->dim);
7322 map->dim = isl_local_space_get_space(ls);
7323 if (!map->dim)
7324 goto error;
7325
7326 isl_local_space_free(ls);
7327 return map;
7328error:
7329 isl_local_space_free(ls);
7330 isl_map_free(map);
7331 return NULL((void*)0);
7332}
7333
7334/* Compute an explicit representation for the existentially
7335 * quantified variables for which do not know any explicit representation yet.
7336 *
7337 * We first sort the existentially quantified variables so that the
7338 * existentially quantified variables for which we already have an explicit
7339 * representation are placed before those for which we do not.
7340 * The input dimensions, the output dimensions and the existentially
7341 * quantified variables for which we already have an explicit
7342 * representation are then turned into parameters.
7343 * compute_divs returns a map with the same parameters and
7344 * no input or output dimensions and the dimension specification
7345 * is reset to that of the input, including the existentially quantified
7346 * variables for which we already had an explicit representation.
7347 */
7348static struct isl_map *compute_divs(struct isl_basic_map *bmap)
7349{
7350 struct isl_basic_setisl_basic_map *bset;
7351 struct isl_setisl_map *set;
7352 struct isl_map *map;
7353 isl_space *dim;
7354 isl_local_space *ls;
7355 unsigned nparam;
7356 unsigned n_in;
7357 unsigned n_out;
7358 int n_known;
7359 int i;
7360
7361 bmap = isl_basic_map_sort_divs(bmap);
7362 bmap = isl_basic_map_cow(bmap);
7363 if (!bmap)
7364 return NULL((void*)0);
7365
7366 n_known = isl_basic_map_first_unknown_div(bmap);
7367 if (n_known < 0)
7368 return isl_map_from_basic_map(isl_basic_map_free(bmap));
7369
7370 nparam = isl_basic_map_dim(bmap, isl_dim_param);
7371 n_in = isl_basic_map_dim(bmap, isl_dim_in);
7372 n_out = isl_basic_map_dim(bmap, isl_dim_out);
7373 dim = isl_space_set_alloc(bmap->ctx,
7374 nparam + n_in + n_out + n_known, 0);
7375 if (!dim)
7376 goto error;
7377
7378 ls = isl_basic_map_get_local_space(bmap);
7379 ls = isl_local_space_drop_dims(ls, isl_dim_div,
7380 n_known, bmap->n_div - n_known);
7381 if (n_known > 0) {
7382 for (i = n_known; i < bmap->n_div; ++i)
7383 swap_div(bmap, i - n_known, i);
7384 bmap->n_div -= n_known;
7385 bmap->extra -= n_known;
7386 }
7387 bmap = isl_basic_map_reset_space(bmap, dim);
7388 bset = bset_from_bmap(bmap);
7389
7390 set = parameter_compute_divs(bset);
7391 map = set_to_map(set);
7392 map = replace_space_by_local_space(map, ls);
7393
7394 return map;
7395error:
7396 isl_basic_map_free(bmap);
7397 return NULL((void*)0);
7398}
7399
7400/* Remove the explicit representation of local variable "div",
7401 * if there is any.
7402 */
7403__isl_give isl_basic_map *isl_basic_map_mark_div_unknown(
7404 __isl_take isl_basic_map *bmap, int div)
7405{
7406 isl_bool unknown;
7407
7408 unknown = isl_basic_map_div_is_marked_unknown(bmap, div);
7409 if (unknown < 0)
7410 return isl_basic_map_free(bmap);
7411 if (unknown)
7412 return bmap;
7413
7414 bmap = isl_basic_map_cow(bmap);
7415 if (!bmap)
7416 return NULL((void*)0);
7417 isl_int_set_si(bmap->div[div][0], 0)isl_sioimath_set_si((bmap->div[div][0]), 0);
7418 return bmap;
7419}
7420
7421/* Is local variable "div" of "bmap" marked as not having an explicit
7422 * representation?
7423 * Note that even if "div" is not marked in this way and therefore
7424 * has an explicit representation, this representation may still
7425 * depend (indirectly) on other local variables that do not
7426 * have an explicit representation.
7427 */
7428isl_bool isl_basic_map_div_is_marked_unknown(__isl_keep isl_basic_map *bmap,
7429 int div)
7430{
7431 if (isl_basic_map_check_range(bmap, isl_dim_div, div, 1) < 0)
7432 return isl_bool_error;
7433 return isl_int_is_zero(bmap->div[div][0])(isl_sioimath_sgn(*(bmap->div[div][0])) == 0);
7434}
7435
7436/* Return the position of the first local variable that does not
7437 * have an explicit representation.
7438 * Return the total number of local variables if they all have
7439 * an explicit representation.
7440 * Return -1 on error.
7441 */
7442int isl_basic_map_first_unknown_div(__isl_keep isl_basic_map *bmap)
7443{
7444 int i;
7445
7446 if (!bmap)
7447 return -1;
7448
7449 for (i = 0; i < bmap->n_div; ++i) {
7450 if (!isl_basic_map_div_is_known(bmap, i))
7451 return i;
7452 }
7453 return bmap->n_div;
7454}
7455
7456/* Return the position of the first local variable that does not
7457 * have an explicit representation.
7458 * Return the total number of local variables if they all have
7459 * an explicit representation.
7460 * Return -1 on error.
7461 */
7462int isl_basic_set_first_unknown_div(__isl_keep isl_basic_setisl_basic_map *bset)
7463{
7464 return isl_basic_map_first_unknown_div(bset);
7465}
7466
7467/* Does "bmap" have an explicit representation for all local variables?
7468 */
7469isl_bool isl_basic_map_divs_known(__isl_keep isl_basic_map *bmap)
7470{
7471 int first, n;
7472
7473 n = isl_basic_map_dim(bmap, isl_dim_div);
7474 first = isl_basic_map_first_unknown_div(bmap);
7475 if (first < 0)
7476 return isl_bool_error;
7477 return first == n;
7478}
7479
7480/* Do all basic maps in "map" have an explicit representation
7481 * for all local variables?
7482 */
7483isl_bool isl_map_divs_known(__isl_keep isl_map *map)
7484{
7485 int i;
7486
7487 if (!map)
7488 return isl_bool_error;
7489
7490 for (i = 0; i < map->n; ++i) {
7491 int known = isl_basic_map_divs_known(map->p[i]);
7492 if (known <= 0)
7493 return known;
7494 }
7495
7496 return isl_bool_true;
7497}
7498
7499/* If bmap contains any unknown divs, then compute explicit
7500 * expressions for them. However, this computation may be
7501 * quite expensive, so first try to remove divs that aren't
7502 * strictly needed.
7503 */
7504__isl_give isl_map *isl_basic_map_compute_divs(__isl_take isl_basic_map *bmap)
7505{
7506 int known;
7507 struct isl_map *map;
7508
7509 known = isl_basic_map_divs_known(bmap);
7510 if (known < 0)
7511 goto error;
7512 if (known)
7513 return isl_map_from_basic_map(bmap);
7514
7515 bmap = isl_basic_map_drop_redundant_divs(bmap);
7516
7517 known = isl_basic_map_divs_known(bmap);
7518 if (known < 0)
7519 goto error;
7520 if (known)
7521 return isl_map_from_basic_map(bmap);
7522
7523 map = compute_divs(bmap);
7524 return map;
7525error:
7526 isl_basic_map_free(bmap);
7527 return NULL((void*)0);
7528}
7529
7530__isl_give isl_map *isl_map_compute_divs(__isl_take isl_map *map)
7531{
7532 int i;
7533 int known;
7534 struct isl_map *res;
7535
7536 if (!map)
7537 return NULL((void*)0);
7538 if (map->n == 0)
7539 return map;
7540
7541 known = isl_map_divs_known(map);
7542 if (known < 0) {
7543 isl_map_free(map);
7544 return NULL((void*)0);
7545 }
7546 if (known)
7547 return map;
7548
7549 res = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[0]));
7550 for (i = 1 ; i < map->n; ++i) {
7551 struct isl_map *r2;
7552 r2 = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[i]));
7553 if (ISL_F_ISSET(map, ISL_MAP_DISJOINT)(!!(((map)->flags) & ((1 << 0)))))
7554 res = isl_map_union_disjoint(res, r2);
7555 else
7556 res = isl_map_union(res, r2);
7557 }
7558 isl_map_free(map);
7559
7560 return res;
7561}
7562
7563__isl_give isl_setisl_map *isl_basic_set_compute_divs(__isl_take isl_basic_setisl_basic_map *bset)
7564{
7565 return set_from_map(isl_basic_map_compute_divs(bset_to_bmap(bset)));
7566}
7567
7568struct isl_setisl_map *isl_set_compute_divs(struct isl_setisl_map *set)
7569{
7570 return set_from_map(isl_map_compute_divs(set_to_map(set)));
7571}
7572
7573__isl_give isl_setisl_map *isl_map_domain(__isl_take isl_map *map)
7574{
7575 int i;
7576 struct isl_setisl_map *set;
7577
7578 if (!map)
7579 goto error;
7580
7581 map = isl_map_cow(map);
7582 if (!map)
7583 return NULL((void*)0);
7584
7585 set = set_from_map(map);
7586 set->dim = isl_space_domain(set->dim);
7587 if (!set->dim)
7588 goto error;
7589 for (i = 0; i < map->n; ++i) {
7590 set->p[i] = isl_basic_map_domain(map->p[i]);
7591 if (!set->p[i])
7592 goto error;
7593 }
7594 ISL_F_CLR(set, ISL_MAP_DISJOINT)(((set)->flags) &= ~((1 << 0)));
7595 ISL_F_CLR(set, ISL_SET_NORMALIZED)(((set)->flags) &= ~((1 << 1)));
7596 return set;
7597error:
7598 isl_map_free(map);
7599 return NULL((void*)0);
7600}
7601
7602/* Return the union of "map1" and "map2", where we assume for now that
7603 * "map1" and "map2" are disjoint. Note that the basic maps inside
7604 * "map1" or "map2" may not be disjoint from each other.
7605 * Also note that this function is also called from isl_map_union,
7606 * which takes care of handling the situation where "map1" and "map2"
7607 * may not be disjoint.
7608 *
7609 * If one of the inputs is empty, we can simply return the other input.
7610 * Similarly, if one of the inputs is universal, then it is equal to the union.
7611 */
7612static __isl_give isl_map *map_union_disjoint(__isl_take isl_map *map1,
7613 __isl_take isl_map *map2)
7614{
7615 int i;
7616 unsigned flags = 0;
7617 struct isl_map *map = NULL((void*)0);
7618 int is_universe;
7619
7620 if (!map1 || !map2)
7621 goto error;
7622
7623 if (!isl_space_is_equal(map1->dim, map2->dim))
7624 isl_die(isl_map_get_ctx(map1), isl_error_invalid,do { isl_handle_error(isl_map_get_ctx(map1), isl_error_invalid
, "spaces don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 7625); goto error; } while (0)
7625 "spaces don't match", goto error)do { isl_handle_error(isl_map_get_ctx(map1), isl_error_invalid
, "spaces don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 7625); goto error; } while (0)
;
7626
7627 if (map1->n == 0) {
7628 isl_map_free(map1);
7629 return map2;
7630 }
7631 if (map2->n == 0) {
7632 isl_map_free(map2);
7633 return map1;
7634 }
7635
7636 is_universe = isl_map_plain_is_universe(map1);
7637 if (is_universe < 0)
7638 goto error;
7639 if (is_universe) {
7640 isl_map_free(map2);
7641 return map1;
7642 }
7643
7644 is_universe = isl_map_plain_is_universe(map2);
7645 if (is_universe < 0)
7646 goto error;
7647 if (is_universe) {
7648 isl_map_free(map1);
7649 return map2;
7650 }
7651
7652 if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT)(!!(((map1)->flags) & ((1 << 0)))) &&
7653 ISL_F_ISSET(map2, ISL_MAP_DISJOINT)(!!(((map2)->flags) & ((1 << 0)))))
7654 ISL_FL_SET(flags, ISL_MAP_DISJOINT)((flags) |= ((1 << 0)));
7655
7656 map = isl_map_alloc_space(isl_space_copy(map1->dim),
7657 map1->n + map2->n, flags);
7658 if (!map)
7659 goto error;
7660 for (i = 0; i < map1->n; ++i) {
7661 map = isl_map_add_basic_map(map,
7662 isl_basic_map_copy(map1->p[i]));
7663 if (!map)
7664 goto error;
7665 }
7666 for (i = 0; i < map2->n; ++i) {
7667 map = isl_map_add_basic_map(map,
7668 isl_basic_map_copy(map2->p[i]));
7669 if (!map)
7670 goto error;
7671 }
7672 isl_map_free(map1);
7673 isl_map_free(map2);
7674 return map;
7675error:
7676 isl_map_free(map);
7677 isl_map_free(map1);
7678 isl_map_free(map2);
7679 return NULL((void*)0);
7680}
7681
7682/* Return the union of "map1" and "map2", where "map1" and "map2" are
7683 * guaranteed to be disjoint by the caller.
7684 *
7685 * Note that this functions is called from within isl_map_make_disjoint,
7686 * so we have to be careful not to touch the constraints of the inputs
7687 * in any way.
7688 */
7689__isl_give isl_map *isl_map_union_disjoint(__isl_take isl_map *map1,
7690 __isl_take isl_map *map2)
7691{
7692 return isl_map_align_params_map_map_and(map1, map2, &map_union_disjoint);
7693}
7694
7695/* Return the union of "map1" and "map2", where "map1" and "map2" may
7696 * not be disjoint. The parameters are assumed to have been aligned.
7697 *
7698 * We currently simply call map_union_disjoint, the internal operation
7699 * of which does not really depend on the inputs being disjoint.
7700 * If the result contains more than one basic map, then we clear
7701 * the disjoint flag since the result may contain basic maps from
7702 * both inputs and these are not guaranteed to be disjoint.
7703 *
7704 * As a special case, if "map1" and "map2" are obviously equal,
7705 * then we simply return "map1".
7706 */
7707static __isl_give isl_map *map_union_aligned(__isl_take isl_map *map1,
7708 __isl_take isl_map *map2)
7709{
7710 int equal;
7711
7712 if (!map1 || !map2)
7713 goto error;
7714
7715 equal = isl_map_plain_is_equal(map1, map2);
7716 if (equal < 0)
7717 goto error;
7718 if (equal) {
7719 isl_map_free(map2);
7720 return map1;
7721 }
7722
7723 map1 = map_union_disjoint(map1, map2);
7724 if (!map1)
7725 return NULL((void*)0);
7726 if (map1->n > 1)
7727 ISL_F_CLR(map1, ISL_MAP_DISJOINT)(((map1)->flags) &= ~((1 << 0)));
7728 return map1;
7729error:
7730 isl_map_free(map1);
7731 isl_map_free(map2);
7732 return NULL((void*)0);
7733}
7734
7735/* Return the union of "map1" and "map2", where "map1" and "map2" may
7736 * not be disjoint.
7737 */
7738__isl_give isl_map *isl_map_union(__isl_take isl_map *map1,
7739 __isl_take isl_map *map2)
7740{
7741 return isl_map_align_params_map_map_and(map1, map2, &map_union_aligned);
7742}
7743
7744__isl_give isl_setisl_map *isl_set_union_disjoint(
7745 __isl_take isl_setisl_map *set1, __isl_take isl_setisl_map *set2)
7746{
7747 return set_from_map(isl_map_union_disjoint(set_to_map(set1),
7748 set_to_map(set2)));
7749}
7750
7751struct isl_setisl_map *isl_set_union(struct isl_setisl_map *set1, struct isl_setisl_map *set2)
7752{
7753 return set_from_map(isl_map_union(set_to_map(set1), set_to_map(set2)));
7754}
7755
7756/* Apply "fn" to pairs of elements from "map" and "set" and collect
7757 * the results.
7758 *
7759 * "map" and "set" are assumed to be compatible and non-NULL.
7760 */
7761static __isl_give isl_map *map_intersect_set(__isl_take isl_map *map,
7762 __isl_take isl_setisl_map *set,
7763 __isl_give isl_basic_map *fn(__isl_take isl_basic_map *bmap,
7764 __isl_take isl_basic_setisl_basic_map *bset))
7765{
7766 unsigned flags = 0;
7767 struct isl_map *result;
7768 int i, j;
7769
7770 if (isl_set_plain_is_universe(set)) {
7771 isl_set_free(set);
7772 return map;
7773 }
7774
7775 if (ISL_F_ISSET(map, ISL_MAP_DISJOINT)(!!(((map)->flags) & ((1 << 0)))) &&
7776 ISL_F_ISSET(set, ISL_MAP_DISJOINT)(!!(((set)->flags) & ((1 << 0)))))
7777 ISL_FL_SET(flags, ISL_MAP_DISJOINT)((flags) |= ((1 << 0)));
7778
7779 result = isl_map_alloc_space(isl_space_copy(map->dim),
7780 map->n * set->n, flags);
7781 for (i = 0; result && i < map->n; ++i)
7782 for (j = 0; j < set->n; ++j) {
7783 result = isl_map_add_basic_map(result,
7784 fn(isl_basic_map_copy(map->p[i]),
7785 isl_basic_set_copy(set->p[j])));
7786 if (!result)
7787 break;
7788 }
7789
7790 isl_map_free(map);
7791 isl_set_free(set);
7792 return result;
7793}
7794
7795static __isl_give isl_map *map_intersect_range(__isl_take isl_map *map,
7796 __isl_take isl_setisl_map *set)
7797{
7798 isl_bool ok;
7799
7800 ok = isl_map_compatible_range(map, set);
7801 if (ok < 0)
7802 goto error;
7803 if (!ok)
7804 isl_die(set->ctx, isl_error_invalid,do { isl_handle_error(set->ctx, isl_error_invalid, "incompatible spaces"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 7805); goto error; } while (0)
7805 "incompatible spaces", goto error)do { isl_handle_error(set->ctx, isl_error_invalid, "incompatible spaces"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 7805); goto error; } while (0)
;
7806
7807 return map_intersect_set(map, set, &isl_basic_map_intersect_range);
7808error:
7809 isl_map_free(map);
7810 isl_set_free(set);
7811 return NULL((void*)0);
7812}
7813
7814__isl_give isl_map *isl_map_intersect_range(__isl_take isl_map *map,
7815 __isl_take isl_setisl_map *set)
7816{
7817 return isl_map_align_params_map_map_and(map, set, &map_intersect_range);
7818}
7819
7820static __isl_give isl_map *map_intersect_domain(__isl_take isl_map *map,
7821 __isl_take isl_setisl_map *set)
7822{
7823 isl_bool ok;
7824
7825 ok = isl_map_compatible_domain(map, set);
7826 if (ok < 0)
7827 goto error;
7828 if (!ok)
7829 isl_die(set->ctx, isl_error_invalid,do { isl_handle_error(set->ctx, isl_error_invalid, "incompatible spaces"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 7830); goto error; } while (0)
7830 "incompatible spaces", goto error)do { isl_handle_error(set->ctx, isl_error_invalid, "incompatible spaces"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 7830); goto error; } while (0)
;
7831
7832 return map_intersect_set(map, set, &isl_basic_map_intersect_domain);
7833error:
7834 isl_map_free(map);
7835 isl_set_free(set);
7836 return NULL((void*)0);
7837}
7838
7839__isl_give isl_map *isl_map_intersect_domain(__isl_take isl_map *map,
7840 __isl_take isl_setisl_map *set)
7841{
7842 return isl_map_align_params_map_map_and(map, set,
7843 &map_intersect_domain);
7844}
7845
7846/* Given a map "map" in a space [A -> B] -> C and a map "factor"
7847 * in the space B -> C, return the intersection.
7848 * The parameters are assumed to have been aligned.
7849 *
7850 * The map "factor" is first extended to a map living in the space
7851 * [A -> B] -> C and then a regular intersection is computed.
7852 */
7853static __isl_give isl_map *map_intersect_domain_factor_range(
7854 __isl_take isl_map *map, __isl_take isl_map *factor)
7855{
7856 isl_space *space;
7857 isl_map *ext_factor;
7858
7859 space = isl_space_domain_factor_domain(isl_map_get_space(map));
7860 ext_factor = isl_map_universe(space);
7861 ext_factor = isl_map_domain_product(ext_factor, factor);
7862 return map_intersect(map, ext_factor);
7863}
7864
7865/* Given a map "map" in a space [A -> B] -> C and a map "factor"
7866 * in the space B -> C, return the intersection.
7867 */
7868__isl_give isl_map *isl_map_intersect_domain_factor_range(
7869 __isl_take isl_map *map, __isl_take isl_map *factor)
7870{
7871 return isl_map_align_params_map_map_and(map, factor,
7872 &map_intersect_domain_factor_range);
7873}
7874
7875/* Given a map "map" in a space A -> [B -> C] and a map "factor"
7876 * in the space A -> C, return the intersection.
7877 *
7878 * The map "factor" is first extended to a map living in the space
7879 * A -> [B -> C] and then a regular intersection is computed.
7880 */
7881static __isl_give isl_map *map_intersect_range_factor_range(
7882 __isl_take isl_map *map, __isl_take isl_map *factor)
7883{
7884 isl_space *space;
7885 isl_map *ext_factor;
7886
7887 space = isl_space_range_factor_domain(isl_map_get_space(map));
7888 ext_factor = isl_map_universe(space);
7889 ext_factor = isl_map_range_product(ext_factor, factor);
7890 return isl_map_intersect(map, ext_factor);
7891}
7892
7893/* Given a map "map" in a space A -> [B -> C] and a map "factor"
7894 * in the space A -> C, return the intersection.
7895 */
7896__isl_give isl_map *isl_map_intersect_range_factor_range(
7897 __isl_take isl_map *map, __isl_take isl_map *factor)
7898{
7899 return isl_map_align_params_map_map_and(map, factor,
7900 &map_intersect_range_factor_range);
7901}
7902
7903static __isl_give isl_map *map_apply_domain(__isl_take isl_map *map1,
7904 __isl_take isl_map *map2)
7905{
7906 if (!map1 || !map2)
7907 goto error;
7908 map1 = isl_map_reverse(map1);
7909 map1 = isl_map_apply_range(map1, map2);
7910 return isl_map_reverse(map1);
7911error:
7912 isl_map_free(map1);
7913 isl_map_free(map2);
7914 return NULL((void*)0);
7915}
7916
7917__isl_give isl_map *isl_map_apply_domain(__isl_take isl_map *map1,
7918 __isl_take isl_map *map2)
7919{
7920 return isl_map_align_params_map_map_and(map1, map2, &map_apply_domain);
7921}
7922
7923static __isl_give isl_map *map_apply_range(__isl_take isl_map *map1,
7924 __isl_take isl_map *map2)
7925{
7926 isl_space *dim_result;
7927 struct isl_map *result;
7928 int i, j;
7929
7930 if (!map1 || !map2)
7931 goto error;
7932
7933 dim_result = isl_space_join(isl_space_copy(map1->dim),
7934 isl_space_copy(map2->dim));
7935
7936 result = isl_map_alloc_space(dim_result, map1->n * map2->n, 0);
7937 if (!result)
7938 goto error;
7939 for (i = 0; i < map1->n; ++i)
7940 for (j = 0; j < map2->n; ++j) {
7941 result = isl_map_add_basic_map(result,
7942 isl_basic_map_apply_range(
7943 isl_basic_map_copy(map1->p[i]),
7944 isl_basic_map_copy(map2->p[j])));
7945 if (!result)
7946 goto error;
7947 }
7948 isl_map_free(map1);
7949 isl_map_free(map2);
7950 if (result && result->n <= 1)
7951 ISL_F_SET(result, ISL_MAP_DISJOINT)(((result)->flags) |= ((1 << 0)));
7952 return result;
7953error:
7954 isl_map_free(map1);
7955 isl_map_free(map2);
7956 return NULL((void*)0);
7957}
7958
7959__isl_give isl_map *isl_map_apply_range(__isl_take isl_map *map1,
7960 __isl_take isl_map *map2)
7961{
7962 return isl_map_align_params_map_map_and(map1, map2, &map_apply_range);
7963}
7964
7965/*
7966 * returns range - domain
7967 */
7968__isl_give isl_basic_setisl_basic_map *isl_basic_map_deltas(__isl_take isl_basic_map *bmap)
7969{
7970 isl_space *target_space;
7971 struct isl_basic_setisl_basic_map *bset;
7972 unsigned dim;
7973 unsigned nparam;
7974 int i;
7975
7976 if (!bmap)
7977 goto error;
7978 isl_assert(bmap->ctx, isl_space_tuple_is_equal(bmap->dim, isl_dim_in,do { if (isl_space_tuple_is_equal(bmap->dim, isl_dim_in, bmap
->dim, isl_dim_out)) break; do { isl_handle_error(bmap->
ctx, isl_error_unknown, "Assertion \"" "isl_space_tuple_is_equal(bmap->dim, isl_dim_in, bmap->dim, isl_dim_out)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 7980); goto error; } while (0); } while (0)
7979 bmap->dim, isl_dim_out),do { if (isl_space_tuple_is_equal(bmap->dim, isl_dim_in, bmap
->dim, isl_dim_out)) break; do { isl_handle_error(bmap->
ctx, isl_error_unknown, "Assertion \"" "isl_space_tuple_is_equal(bmap->dim, isl_dim_in, bmap->dim, isl_dim_out)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 7980); goto error; } while (0); } while (0)
7980 goto error)do { if (isl_space_tuple_is_equal(bmap->dim, isl_dim_in, bmap
->dim, isl_dim_out)) break; do { isl_handle_error(bmap->
ctx, isl_error_unknown, "Assertion \"" "isl_space_tuple_is_equal(bmap->dim, isl_dim_in, bmap->dim, isl_dim_out)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 7980); goto error; } while (0); } while (0)
;
7981 target_space = isl_space_domain(isl_basic_map_get_space(bmap));
7982 dim = isl_basic_map_dim(bmap, isl_dim_in);
7983 nparam = isl_basic_map_dim(bmap, isl_dim_param);
7984 bmap = isl_basic_map_from_range(isl_basic_map_wrap(bmap));
7985 bmap = isl_basic_map_add_dims(bmap, isl_dim_in, dim);
7986 bmap = isl_basic_map_extend_constraints(bmap, dim, 0);
7987 for (i = 0; i < dim; ++i) {
7988 int j = isl_basic_map_alloc_equality(bmap);
7989 if (j < 0) {
7990 bmap = isl_basic_map_free(bmap);
7991 break;
7992 }
7993 isl_seq_clr(bmap->eq[j], 1 + isl_basic_map_total_dim(bmap));
7994 isl_int_set_si(bmap->eq[j][1+nparam+i], 1)isl_sioimath_set_si((bmap->eq[j][1+nparam+i]), 1);
7995 isl_int_set_si(bmap->eq[j][1+nparam+dim+i], 1)isl_sioimath_set_si((bmap->eq[j][1+nparam+dim+i]), 1);
7996 isl_int_set_si(bmap->eq[j][1+nparam+2*dim+i], -1)isl_sioimath_set_si((bmap->eq[j][1+nparam+2*dim+i]), -1);
7997 }
7998 bset = isl_basic_map_domain(bmap);
7999 bset = isl_basic_set_reset_space(bset, target_space);
8000 return bset;
8001error:
8002 isl_basic_map_free(bmap);
8003 return NULL((void*)0);
8004}
8005
8006/*
8007 * returns range - domain
8008 */
8009__isl_give isl_setisl_map *isl_map_deltas(__isl_take isl_map *map)
8010{
8011 int i;
8012 isl_space *dim;
8013 struct isl_setisl_map *result;
8014
8015 if (!map)
8016 return NULL((void*)0);
8017
8018 isl_assert(map->ctx, isl_space_tuple_is_equal(map->dim, isl_dim_in,do { if (isl_space_tuple_is_equal(map->dim, isl_dim_in, map
->dim, isl_dim_out)) break; do { isl_handle_error(map->
ctx, isl_error_unknown, "Assertion \"" "isl_space_tuple_is_equal(map->dim, isl_dim_in, map->dim, isl_dim_out)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8020); goto error; } while (0); } while (0)
8019 map->dim, isl_dim_out),do { if (isl_space_tuple_is_equal(map->dim, isl_dim_in, map
->dim, isl_dim_out)) break; do { isl_handle_error(map->
ctx, isl_error_unknown, "Assertion \"" "isl_space_tuple_is_equal(map->dim, isl_dim_in, map->dim, isl_dim_out)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8020); goto error; } while (0); } while (0)
8020 goto error)do { if (isl_space_tuple_is_equal(map->dim, isl_dim_in, map
->dim, isl_dim_out)) break; do { isl_handle_error(map->
ctx, isl_error_unknown, "Assertion \"" "isl_space_tuple_is_equal(map->dim, isl_dim_in, map->dim, isl_dim_out)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8020); goto error; } while (0); } while (0)
;
8021 dim = isl_map_get_space(map);
8022 dim = isl_space_domain(dim);
8023 result = isl_set_alloc_space(dim, map->n, 0);
8024 if (!result)
8025 goto error;
8026 for (i = 0; i < map->n; ++i)
8027 result = isl_set_add_basic_set(result,
8028 isl_basic_map_deltas(isl_basic_map_copy(map->p[i])));
8029 isl_map_free(map);
8030 return result;
8031error:
8032 isl_map_free(map);
8033 return NULL((void*)0);
8034}
8035
8036/*
8037 * returns [domain -> range] -> range - domain
8038 */
8039__isl_give isl_basic_map *isl_basic_map_deltas_map(
8040 __isl_take isl_basic_map *bmap)
8041{
8042 int i, k;
8043 isl_space *dim;
8044 isl_basic_map *domain;
8045 int nparam, n;
8046 unsigned total;
8047
8048 if (!isl_space_tuple_is_equal(bmap->dim, isl_dim_in,
8049 bmap->dim, isl_dim_out))
8050 isl_die(bmap->ctx, isl_error_invalid,do { isl_handle_error(bmap->ctx, isl_error_invalid, "domain and range don't match"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8051); goto error; } while (0)
8051 "domain and range don't match", goto error)do { isl_handle_error(bmap->ctx, isl_error_invalid, "domain and range don't match"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8051); goto error; } while (0)
;
8052
8053 nparam = isl_basic_map_dim(bmap, isl_dim_param);
8054 n = isl_basic_map_dim(bmap, isl_dim_in);
8055
8056 dim = isl_space_from_range(isl_space_domain(isl_basic_map_get_space(bmap)));
8057 domain = isl_basic_map_universe(dim);
8058
8059 bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
8060 bmap = isl_basic_map_apply_range(bmap, domain);
8061 bmap = isl_basic_map_extend_constraints(bmap, n, 0);
8062
8063 total = isl_basic_map_total_dim(bmap);
8064
8065 for (i = 0; i < n; ++i) {
8066 k = isl_basic_map_alloc_equality(bmap);
8067 if (k < 0)
8068 goto error;
8069 isl_seq_clr(bmap->eq[k], 1 + total);
8070 isl_int_set_si(bmap->eq[k][1 + nparam + i], 1)isl_sioimath_set_si((bmap->eq[k][1 + nparam + i]), 1);
8071 isl_int_set_si(bmap->eq[k][1 + nparam + n + i], -1)isl_sioimath_set_si((bmap->eq[k][1 + nparam + n + i]), -1);
8072 isl_int_set_si(bmap->eq[k][1 + nparam + n + n + i], 1)isl_sioimath_set_si((bmap->eq[k][1 + nparam + n + n + i]),
1)
;
8073 }
8074
8075 bmap = isl_basic_map_gauss(bmap, NULL((void*)0));
8076 return isl_basic_map_finalize(bmap);
8077error:
8078 isl_basic_map_free(bmap);
8079 return NULL((void*)0);
8080}
8081
8082/*
8083 * returns [domain -> range] -> range - domain
8084 */
8085__isl_give isl_map *isl_map_deltas_map(__isl_take isl_map *map)
8086{
8087 int i;
8088 isl_space *domain_dim;
8089
8090 if (!map)
8091 return NULL((void*)0);
8092
8093 if (!isl_space_tuple_is_equal(map->dim, isl_dim_in,
8094 map->dim, isl_dim_out))
8095 isl_die(map->ctx, isl_error_invalid,do { isl_handle_error(map->ctx, isl_error_invalid, "domain and range don't match"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8096); goto error; } while (0)
8096 "domain and range don't match", goto error)do { isl_handle_error(map->ctx, isl_error_invalid, "domain and range don't match"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8096); goto error; } while (0)
;
8097
8098 map = isl_map_cow(map);
8099 if (!map)
8100 return NULL((void*)0);
8101
8102 domain_dim = isl_space_from_range(isl_space_domain(isl_map_get_space(map)));
8103 map->dim = isl_space_from_domain(isl_space_wrap(map->dim));
8104 map->dim = isl_space_join(map->dim, domain_dim);
8105 if (!map->dim)
8106 goto error;
8107 for (i = 0; i < map->n; ++i) {
8108 map->p[i] = isl_basic_map_deltas_map(map->p[i]);
8109 if (!map->p[i])
8110 goto error;
8111 }
8112 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
8113 return map;
8114error:
8115 isl_map_free(map);
8116 return NULL((void*)0);
8117}
8118
8119static __isl_give isl_basic_map *basic_map_identity(__isl_take isl_space *dims)
8120{
8121 struct isl_basic_map *bmap;
8122 unsigned nparam;
8123 unsigned dim;
8124 int i;
8125
8126 if (!dims)
8127 return NULL((void*)0);
8128
8129 nparam = dims->nparam;
8130 dim = dims->n_out;
8131 bmap = isl_basic_map_alloc_space(dims, 0, dim, 0);
8132 if (!bmap)
8133 goto error;
8134
8135 for (i = 0; i < dim; ++i) {
8136 int j = isl_basic_map_alloc_equality(bmap);
8137 if (j < 0)
8138 goto error;
8139 isl_seq_clr(bmap->eq[j], 1 + isl_basic_map_total_dim(bmap));
8140 isl_int_set_si(bmap->eq[j][1+nparam+i], 1)isl_sioimath_set_si((bmap->eq[j][1+nparam+i]), 1);
8141 isl_int_set_si(bmap->eq[j][1+nparam+dim+i], -1)isl_sioimath_set_si((bmap->eq[j][1+nparam+dim+i]), -1);
8142 }
8143 return isl_basic_map_finalize(bmap);
8144error:
8145 isl_basic_map_free(bmap);
8146 return NULL((void*)0);
8147}
8148
8149__isl_give isl_basic_map *isl_basic_map_identity(__isl_take isl_space *dim)
8150{
8151 if (!dim)
8152 return NULL((void*)0);
8153 if (dim->n_in != dim->n_out)
8154 isl_die(dim->ctx, isl_error_invalid,do { isl_handle_error(dim->ctx, isl_error_invalid, "number of input and output dimensions needs to be "
"the same", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8156); goto error; } while (0)
8155 "number of input and output dimensions needs to be "do { isl_handle_error(dim->ctx, isl_error_invalid, "number of input and output dimensions needs to be "
"the same", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8156); goto error; } while (0)
8156 "the same", goto error)do { isl_handle_error(dim->ctx, isl_error_invalid, "number of input and output dimensions needs to be "
"the same", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8156); goto error; } while (0)
;
8157 return basic_map_identity(dim);
8158error:
8159 isl_space_free(dim);
8160 return NULL((void*)0);
8161}
8162
8163__isl_give isl_map *isl_map_identity(__isl_take isl_space *dim)
8164{
8165 return isl_map_from_basic_map(isl_basic_map_identity(dim));
8166}
8167
8168__isl_give isl_map *isl_set_identity(__isl_take isl_setisl_map *set)
8169{
8170 isl_space *dim = isl_set_get_space(set);
8171 isl_map *id;
8172 id = isl_map_identity(isl_space_map_from_set(dim));
8173 return isl_map_intersect_range(id, set);
8174}
8175
8176/* Construct a basic set with all set dimensions having only non-negative
8177 * values.
8178 */
8179__isl_give isl_basic_setisl_basic_map *isl_basic_set_positive_orthant(
8180 __isl_take isl_space *space)
8181{
8182 int i;
8183 unsigned nparam;
8184 unsigned dim;
8185 struct isl_basic_setisl_basic_map *bset;
8186
8187 if (!space)
8188 return NULL((void*)0);
8189 nparam = space->nparam;
8190 dim = space->n_out;
8191 bset = isl_basic_set_alloc_space(space, 0, 0, dim);
8192 if (!bset)
8193 return NULL((void*)0);
8194 for (i = 0; i < dim; ++i) {
8195 int k = isl_basic_set_alloc_inequality(bset);
8196 if (k < 0)
8197 goto error;
8198 isl_seq_clr(bset->ineq[k], 1 + isl_basic_set_total_dim(bset));
8199 isl_int_set_si(bset->ineq[k][1 + nparam + i], 1)isl_sioimath_set_si((bset->ineq[k][1 + nparam + i]), 1);
8200 }
8201 return bset;
8202error:
8203 isl_basic_set_free(bset);
8204 return NULL((void*)0);
8205}
8206
8207/* Construct the half-space x_pos >= 0.
8208 */
8209static __isl_give isl_basic_setisl_basic_map *nonneg_halfspace(__isl_take isl_space *dim,
8210 int pos)
8211{
8212 int k;
8213 isl_basic_setisl_basic_map *nonneg;
8214
8215 nonneg = isl_basic_set_alloc_space(dim, 0, 0, 1);
8216 k = isl_basic_set_alloc_inequality(nonneg);
8217 if (k < 0)
8218 goto error;
8219 isl_seq_clr(nonneg->ineq[k], 1 + isl_basic_set_total_dim(nonneg));
8220 isl_int_set_si(nonneg->ineq[k][pos], 1)isl_sioimath_set_si((nonneg->ineq[k][pos]), 1);
8221
8222 return isl_basic_set_finalize(nonneg);
8223error:
8224 isl_basic_set_free(nonneg);
8225 return NULL((void*)0);
8226}
8227
8228/* Construct the half-space x_pos <= -1.
8229 */
8230static __isl_give isl_basic_setisl_basic_map *neg_halfspace(__isl_take isl_space *dim, int pos)
8231{
8232 int k;
8233 isl_basic_setisl_basic_map *neg;
8234
8235 neg = isl_basic_set_alloc_space(dim, 0, 0, 1);
8236 k = isl_basic_set_alloc_inequality(neg);
8237 if (k < 0)
8238 goto error;
8239 isl_seq_clr(neg->ineq[k], 1 + isl_basic_set_total_dim(neg));
8240 isl_int_set_si(neg->ineq[k][0], -1)isl_sioimath_set_si((neg->ineq[k][0]), -1);
8241 isl_int_set_si(neg->ineq[k][pos], -1)isl_sioimath_set_si((neg->ineq[k][pos]), -1);
8242
8243 return isl_basic_set_finalize(neg);
8244error:
8245 isl_basic_set_free(neg);
8246 return NULL((void*)0);
8247}
8248
8249__isl_give isl_setisl_map *isl_set_split_dims(__isl_take isl_setisl_map *set,
8250 enum isl_dim_type type, unsigned first, unsigned n)
8251{
8252 int i;
8253 unsigned offset;
8254 isl_basic_setisl_basic_map *nonneg;
8255 isl_basic_setisl_basic_map *neg;
8256
8257 if (!set)
8258 return NULL((void*)0);
8259 if (n == 0)
8260 return set;
8261
8262 isl_assert(set->ctx, first + n <= isl_set_dim(set, type), goto error)do { if (first + n <= isl_set_dim(set, type)) break; do { isl_handle_error
(set->ctx, isl_error_unknown, "Assertion \"" "first + n <= isl_set_dim(set, type)"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8262); goto error; } while (0); } while (0)
;
8263
8264 offset = pos(set->dim, type);
8265 for (i = 0; i < n; ++i) {
8266 nonneg = nonneg_halfspace(isl_set_get_space(set),
8267 offset + first + i);
8268 neg = neg_halfspace(isl_set_get_space(set), offset + first + i);
8269
8270 set = isl_set_intersect(set, isl_basic_set_union(nonneg, neg));
8271 }
8272
8273 return set;
8274error:
8275 isl_set_free(set);
8276 return NULL((void*)0);
8277}
8278
8279static isl_stat foreach_orthant(__isl_take isl_setisl_map *set, int *signs, int first,
8280 int len,
8281 isl_stat (*fn)(__isl_take isl_setisl_map *orthant, int *signs, void *user),
8282 void *user)
8283{
8284 isl_setisl_map *half;
8285
8286 if (!set)
8287 return isl_stat_error;
8288 if (isl_set_plain_is_empty(set)) {
8289 isl_set_free(set);
8290 return isl_stat_ok;
8291 }
8292 if (first == len)
8293 return fn(set, signs, user);
8294
8295 signs[first] = 1;
8296 half = isl_set_from_basic_set(nonneg_halfspace(isl_set_get_space(set),
8297 1 + first));
8298 half = isl_set_intersect(half, isl_set_copy(set));
8299 if (foreach_orthant(half, signs, first + 1, len, fn, user) < 0)
8300 goto error;
8301
8302 signs[first] = -1;
8303 half = isl_set_from_basic_set(neg_halfspace(isl_set_get_space(set),
8304 1 + first));
8305 half = isl_set_intersect(half, set);
8306 return foreach_orthant(half, signs, first + 1, len, fn, user);
8307error:
8308 isl_set_free(set);
8309 return isl_stat_error;
8310}
8311
8312/* Call "fn" on the intersections of "set" with each of the orthants
8313 * (except for obviously empty intersections). The orthant is identified
8314 * by the signs array, with each entry having value 1 or -1 according
8315 * to the sign of the corresponding variable.
8316 */
8317isl_stat isl_set_foreach_orthant(__isl_keep isl_setisl_map *set,
8318 isl_stat (*fn)(__isl_take isl_setisl_map *orthant, int *signs, void *user),
8319 void *user)
8320{
8321 unsigned nparam;
8322 unsigned nvar;
8323 int *signs;
8324 isl_stat r;
8325
8326 if (!set)
8327 return isl_stat_error;
8328 if (isl_set_plain_is_empty(set))
8329 return isl_stat_ok;
8330
8331 nparam = isl_set_dim(set, isl_dim_param);
8332 nvar = isl_set_dim(set, isl_dim_set);
8333
8334 signs = isl_alloc_array(set->ctx, int, nparam + nvar)((int *)isl_malloc_or_die(set->ctx, (nparam + nvar)*sizeof
(int)))
;
8335
8336 r = foreach_orthant(isl_set_copy(set), signs, 0, nparam + nvar,
8337 fn, user);
8338
8339 free(signs);
8340
8341 return r;
8342}
8343
8344isl_bool isl_set_is_equal(__isl_keep isl_setisl_map *set1, __isl_keep isl_setisl_map *set2)
8345{
8346 return isl_map_is_equal(set_to_map(set1), set_to_map(set2));
8347}
8348
8349isl_bool isl_basic_map_is_subset(__isl_keep isl_basic_map *bmap1,
8350 __isl_keep isl_basic_map *bmap2)
8351{
8352 int is_subset;
8353 struct isl_map *map1;
8354 struct isl_map *map2;
8355
8356 if (!bmap1 || !bmap2)
8357 return isl_bool_error;
8358
8359 map1 = isl_map_from_basic_map(isl_basic_map_copy(bmap1));
8360 map2 = isl_map_from_basic_map(isl_basic_map_copy(bmap2));
8361
8362 is_subset = isl_map_is_subset(map1, map2);
8363
8364 isl_map_free(map1);
8365 isl_map_free(map2);
8366
8367 return is_subset;
8368}
8369
8370isl_bool isl_basic_set_is_subset(__isl_keep isl_basic_setisl_basic_map *bset1,
8371 __isl_keep isl_basic_setisl_basic_map *bset2)
8372{
8373 return isl_basic_map_is_subset(bset1, bset2);
8374}
8375
8376isl_bool isl_basic_map_is_equal(__isl_keep isl_basic_map *bmap1,
8377 __isl_keep isl_basic_map *bmap2)
8378{
8379 isl_bool is_subset;
8380
8381 if (!bmap1 || !bmap2)
8382 return isl_bool_error;
8383 is_subset = isl_basic_map_is_subset(bmap1, bmap2);
8384 if (is_subset != isl_bool_true)
8385 return is_subset;
8386 is_subset = isl_basic_map_is_subset(bmap2, bmap1);
8387 return is_subset;
8388}
8389
8390isl_bool isl_basic_set_is_equal(__isl_keep isl_basic_setisl_basic_map *bset1,
8391 __isl_keep isl_basic_setisl_basic_map *bset2)
8392{
8393 return isl_basic_map_is_equal(
8394 bset_to_bmap(bset1), bset_to_bmap(bset2));
8395}
8396
8397isl_bool isl_map_is_empty(__isl_keep isl_map *map)
8398{
8399 int i;
8400 int is_empty;
8401
8402 if (!map)
8403 return isl_bool_error;
8404 for (i = 0; i < map->n; ++i) {
8405 is_empty = isl_basic_map_is_empty(map->p[i]);
8406 if (is_empty < 0)
8407 return isl_bool_error;
8408 if (!is_empty)
8409 return isl_bool_false;
8410 }
8411 return isl_bool_true;
8412}
8413
8414isl_bool isl_map_plain_is_empty(__isl_keep isl_map *map)
8415{
8416 return map ? map->n == 0 : isl_bool_error;
8417}
8418
8419isl_bool isl_set_plain_is_empty(__isl_keep isl_setisl_map *set)
8420{
8421 return set ? set->n == 0 : isl_bool_error;
8422}
8423
8424isl_bool isl_set_is_empty(__isl_keep isl_setisl_map *set)
8425{
8426 return isl_map_is_empty(set_to_map(set));
8427}
8428
8429isl_bool isl_map_has_equal_space(__isl_keep isl_map *map1,
8430 __isl_keep isl_map *map2)
8431{
8432 if (!map1 || !map2)
8433 return isl_bool_error;
8434
8435 return isl_space_is_equal(map1->dim, map2->dim);
8436}
8437
8438isl_bool isl_set_has_equal_space(__isl_keep isl_setisl_map *set1,
8439 __isl_keep isl_setisl_map *set2)
8440{
8441 if (!set1 || !set2)
8442 return isl_bool_error;
8443
8444 return isl_space_is_equal(set1->dim, set2->dim);
8445}
8446
8447static isl_bool map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
8448{
8449 isl_bool is_subset;
8450
8451 if (!map1 || !map2)
8452 return isl_bool_error;
8453 is_subset = isl_map_is_subset(map1, map2);
8454 if (is_subset != isl_bool_true)
8455 return is_subset;
8456 is_subset = isl_map_is_subset(map2, map1);
8457 return is_subset;
8458}
8459
8460/* Is "map1" equal to "map2"?
8461 *
8462 * First check if they are obviously equal.
8463 * If not, then perform a more detailed analysis.
8464 */
8465isl_bool isl_map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
8466{
8467 isl_bool equal;
8468
8469 equal = isl_map_plain_is_equal(map1, map2);
8470 if (equal < 0 || equal)
8471 return equal;
8472 return isl_map_align_params_map_map_and_test(map1, map2, &map_is_equal);
8473}
8474
8475isl_bool isl_basic_map_is_strict_subset(
8476 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
8477{
8478 isl_bool is_subset;
8479
8480 if (!bmap1 || !bmap2)
8481 return isl_bool_error;
8482 is_subset = isl_basic_map_is_subset(bmap1, bmap2);
8483 if (is_subset != isl_bool_true)
8484 return is_subset;
8485 is_subset = isl_basic_map_is_subset(bmap2, bmap1);
8486 if (is_subset == isl_bool_error)
8487 return is_subset;
8488 return !is_subset;
8489}
8490
8491isl_bool isl_map_is_strict_subset(__isl_keep isl_map *map1,
8492 __isl_keep isl_map *map2)
8493{
8494 isl_bool is_subset;
8495
8496 if (!map1 || !map2)
8497 return isl_bool_error;
8498 is_subset = isl_map_is_subset(map1, map2);
8499 if (is_subset != isl_bool_true)
8500 return is_subset;
8501 is_subset = isl_map_is_subset(map2, map1);
8502 if (is_subset == isl_bool_error)
8503 return is_subset;
8504 return !is_subset;
8505}
8506
8507isl_bool isl_set_is_strict_subset(__isl_keep isl_setisl_map *set1,
8508 __isl_keep isl_setisl_map *set2)
8509{
8510 return isl_map_is_strict_subset(set_to_map(set1), set_to_map(set2));
8511}
8512
8513/* Is "bmap" obviously equal to the universe with the same space?
8514 *
8515 * That is, does it not have any constraints?
8516 */
8517isl_bool isl_basic_map_plain_is_universe(__isl_keep isl_basic_map *bmap)
8518{
8519 if (!bmap)
19
Assuming 'bmap' is null
20
Assuming pointer value is null
21
Taking true branch
8520 return isl_bool_error;
8521 return bmap->n_eq == 0 && bmap->n_ineq == 0;
8522}
8523
8524/* Is "bset" obviously equal to the universe with the same space?
8525 */
8526isl_bool isl_basic_set_plain_is_universe(__isl_keep isl_basic_setisl_basic_map *bset)
8527{
8528 return isl_basic_map_plain_is_universe(bset);
8529}
8530
8531/* If "c" does not involve any existentially quantified variables,
8532 * then set *univ to false and abort
8533 */
8534static isl_stat involves_divs(__isl_take isl_constraint *c, void *user)
8535{
8536 isl_bool *univ = user;
8537 unsigned n;
8538
8539 n = isl_constraint_dim(c, isl_dim_div);
8540 *univ = isl_constraint_involves_dims(c, isl_dim_div, 0, n);
8541 isl_constraint_free(c);
8542 if (*univ < 0 || !*univ)
8543 return isl_stat_error;
8544 return isl_stat_ok;
8545}
8546
8547/* Is "bmap" equal to the universe with the same space?
8548 *
8549 * First check if it is obviously equal to the universe.
8550 * If not and if there are any constraints not involving
8551 * existentially quantified variables, then it is certainly
8552 * not equal to the universe.
8553 * Otherwise, check if the universe is a subset of "bmap".
8554 */
8555isl_bool isl_basic_map_is_universe(__isl_keep isl_basic_map *bmap)
8556{
8557 isl_bool univ;
8558 isl_basic_map *test;
8559
8560 univ = isl_basic_map_plain_is_universe(bmap);
8561 if (univ < 0 || univ)
8562 return univ;
8563 if (isl_basic_map_dim(bmap, isl_dim_div) == 0)
8564 return isl_bool_false;
8565 univ = isl_bool_true;
8566 if (isl_basic_map_foreach_constraint(bmap, &involves_divs, &univ) < 0 &&
8567 univ)
8568 return isl_bool_error;
8569 if (univ < 0 || !univ)
8570 return univ;
8571 test = isl_basic_map_universe(isl_basic_map_get_space(bmap));
8572 univ = isl_basic_map_is_subset(test, bmap);
8573 isl_basic_map_free(test);
8574 return univ;
8575}
8576
8577/* Is "bset" equal to the universe with the same space?
8578 */
8579isl_bool isl_basic_set_is_universe(__isl_keep isl_basic_setisl_basic_map *bset)
8580{
8581 return isl_basic_map_is_universe(bset);
8582}
8583
8584isl_bool isl_map_plain_is_universe(__isl_keep isl_map *map)
8585{
8586 int i;
8587
8588 if (!map)
15
Taking false branch
8589 return isl_bool_error;
8590
8591 for (i = 0; i < map->n; ++i) {
16
Assuming the condition is true
17
Loop condition is true. Entering loop body
8592 isl_bool r = isl_basic_map_plain_is_universe(map->p[i]);
18
Calling 'isl_basic_map_plain_is_universe'
22
Returning from 'isl_basic_map_plain_is_universe'
8593 if (r < 0 || r)
8594 return r;
8595 }
8596
8597 return isl_bool_false;
8598}
8599
8600isl_bool isl_set_plain_is_universe(__isl_keep isl_setisl_map *set)
8601{
8602 return isl_map_plain_is_universe(set_to_map(set));
8603}
8604
8605isl_bool isl_basic_map_is_empty(__isl_keep isl_basic_map *bmap)
8606{
8607 struct isl_basic_setisl_basic_map *bset = NULL((void*)0);
8608 struct isl_vec *sample = NULL((void*)0);
8609 isl_bool empty, non_empty;
8610
8611 if (!bmap)
8612 return isl_bool_error;
8613
8614 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY)(!!(((bmap)->flags) & ((1 << 1)))))
8615 return isl_bool_true;
8616
8617 if (isl_basic_map_plain_is_universe(bmap))
8618 return isl_bool_false;
8619
8620 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)(!!(((bmap)->flags) & ((1 << 4))))) {
8621 struct isl_basic_map *copy = isl_basic_map_copy(bmap);
8622 copy = isl_basic_map_remove_redundancies(copy);
8623 empty = isl_basic_map_plain_is_empty(copy);
8624 isl_basic_map_free(copy);
8625 return empty;
8626 }
8627
8628 non_empty = isl_basic_map_plain_is_non_empty(bmap);
8629 if (non_empty < 0)
8630 return isl_bool_error;
8631 if (non_empty)
8632 return isl_bool_false;
8633 isl_vec_free(bmap->sample);
8634 bmap->sample = NULL((void*)0);
8635 bset = isl_basic_map_underlying_set(isl_basic_map_copy(bmap));
8636 if (!bset)
8637 return isl_bool_error;
8638 sample = isl_basic_set_sample_vec(bset);
8639 if (!sample)
8640 return isl_bool_error;
8641 empty = sample->size == 0;
8642 isl_vec_free(bmap->sample);
8643 bmap->sample = sample;
8644 if (empty)
8645 ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY)(((bmap)->flags) |= ((1 << 1)));
8646
8647 return empty;
8648}
8649
8650isl_bool isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap)
8651{
8652 if (!bmap)
8653 return isl_bool_error;
8654 return ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY)(!!(((bmap)->flags) & ((1 << 1))));
8655}
8656
8657isl_bool isl_basic_set_plain_is_empty(__isl_keep isl_basic_setisl_basic_map *bset)
8658{
8659 if (!bset)
8660 return isl_bool_error;
8661 return ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY)(!!(((bset)->flags) & ((1 << 1))));
8662}
8663
8664/* Is "bmap" known to be non-empty?
8665 *
8666 * That is, is the cached sample still valid?
8667 */
8668isl_bool isl_basic_map_plain_is_non_empty(__isl_keep isl_basic_map *bmap)
8669{
8670 unsigned total;
8671
8672 if (!bmap)
8673 return isl_bool_error;
8674 if (!bmap->sample)
8675 return isl_bool_false;
8676 total = 1 + isl_basic_map_total_dim(bmap);
8677 if (bmap->sample->size != total)
8678 return isl_bool_false;
8679 return isl_basic_map_contains(bmap, bmap->sample);
8680}
8681
8682isl_bool isl_basic_set_is_empty(__isl_keep isl_basic_setisl_basic_map *bset)
8683{
8684 return isl_basic_map_is_empty(bset_to_bmap(bset));
8685}
8686
8687__isl_give isl_map *isl_basic_map_union(__isl_take isl_basic_map *bmap1,
8688 __isl_take isl_basic_map *bmap2)
8689{
8690 struct isl_map *map;
8691 if (!bmap1 || !bmap2)
8692 goto error;
8693
8694 isl_assert(bmap1->ctx, isl_space_is_equal(bmap1->dim, bmap2->dim), goto error)do { if (isl_space_is_equal(bmap1->dim, bmap2->dim)) break
; do { isl_handle_error(bmap1->ctx, isl_error_unknown, "Assertion \""
"isl_space_is_equal(bmap1->dim, bmap2->dim)" "\" failed"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8694); goto error; } while (0); } while (0)
;
8695
8696 map = isl_map_alloc_space(isl_space_copy(bmap1->dim), 2, 0);
8697 if (!map)
8698 goto error;
8699 map = isl_map_add_basic_map(map, bmap1);
8700 map = isl_map_add_basic_map(map, bmap2);
8701 return map;
8702error:
8703 isl_basic_map_free(bmap1);
8704 isl_basic_map_free(bmap2);
8705 return NULL((void*)0);
8706}
8707
8708struct isl_setisl_map *isl_basic_set_union(
8709 struct isl_basic_setisl_basic_map *bset1, struct isl_basic_setisl_basic_map *bset2)
8710{
8711 return set_from_map(isl_basic_map_union(bset_to_bmap(bset1),
8712 bset_to_bmap(bset2)));
8713}
8714
8715/* Order divs such that any div only depends on previous divs */
8716__isl_give isl_basic_map *isl_basic_map_order_divs(
8717 __isl_take isl_basic_map *bmap)
8718{
8719 int i;
8720 unsigned off;
8721
8722 if (!bmap)
8723 return NULL((void*)0);
8724
8725 off = isl_space_dim(bmap->dim, isl_dim_all);
8726
8727 for (i = 0; i < bmap->n_div; ++i) {
8728 int pos;
8729 if (isl_int_is_zero(bmap->div[i][0])(isl_sioimath_sgn(*(bmap->div[i][0])) == 0))
8730 continue;
8731 pos = isl_seq_first_non_zero(bmap->div[i]+1+1+off+i,
8732 bmap->n_div-i);
8733 if (pos == -1)
8734 continue;
8735 if (pos == 0)
8736 isl_die(isl_basic_map_get_ctx(bmap), isl_error_internal,do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_internal
, "integer division depends on itself", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8738); return isl_basic_map_free(bmap); } while (0)
8737 "integer division depends on itself",do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_internal
, "integer division depends on itself", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8738); return isl_basic_map_free(bmap); } while (0)
8738 return isl_basic_map_free(bmap))do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_internal
, "integer division depends on itself", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8738); return isl_basic_map_free(bmap); } while (0)
;
8739 isl_basic_map_swap_div(bmap, i, i + pos);
8740 --i;
8741 }
8742 return bmap;
8743}
8744
8745struct isl_basic_setisl_basic_map *isl_basic_set_order_divs(struct isl_basic_setisl_basic_map *bset)
8746{
8747 return bset_from_bmap(isl_basic_map_order_divs(bset_to_bmap(bset)));
8748}
8749
8750__isl_give isl_map *isl_map_order_divs(__isl_take isl_map *map)
8751{
8752 int i;
8753
8754 if (!map)
8755 return 0;
8756
8757 for (i = 0; i < map->n; ++i) {
8758 map->p[i] = isl_basic_map_order_divs(map->p[i]);
8759 if (!map->p[i])
8760 goto error;
8761 }
8762
8763 return map;
8764error:
8765 isl_map_free(map);
8766 return NULL((void*)0);
8767}
8768
8769/* Sort the local variables of "bset".
8770 */
8771__isl_give isl_basic_setisl_basic_map *isl_basic_set_sort_divs(
8772 __isl_take isl_basic_setisl_basic_map *bset)
8773{
8774 return bset_from_bmap(isl_basic_map_sort_divs(bset_to_bmap(bset)));
8775}
8776
8777/* Apply the expansion computed by isl_merge_divs.
8778 * The expansion itself is given by "exp" while the resulting
8779 * list of divs is given by "div".
8780 *
8781 * Move the integer divisions of "bmap" into the right position
8782 * according to "exp" and then introduce the additional integer
8783 * divisions, adding div constraints.
8784 * The moving should be done first to avoid moving coefficients
8785 * in the definitions of the extra integer divisions.
8786 */
8787__isl_give isl_basic_map *isl_basic_map_expand_divs(
8788 __isl_take isl_basic_map *bmap, __isl_take isl_mat *div, int *exp)
8789{
8790 int i, j;
8791 int n_div;
8792
8793 bmap = isl_basic_map_cow(bmap);
8794 if (!bmap || !div)
8795 goto error;
8796
8797 if (div->n_row < bmap->n_div)
8798 isl_die(isl_mat_get_ctx(div), isl_error_invalid,do { isl_handle_error(isl_mat_get_ctx(div), isl_error_invalid
, "not an expansion", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8799); goto error; } while (0)
8799 "not an expansion", goto error)do { isl_handle_error(isl_mat_get_ctx(div), isl_error_invalid
, "not an expansion", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8799); goto error; } while (0)
;
8800
8801 n_div = bmap->n_div;
8802 bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim),
8803 div->n_row - n_div, 0,
8804 2 * (div->n_row - n_div));
8805
8806 for (i = n_div; i < div->n_row; ++i)
8807 if (isl_basic_map_alloc_div(bmap) < 0)
8808 goto error;
8809
8810 for (j = n_div - 1; j >= 0; --j) {
8811 if (exp[j] == j)
8812 break;
8813 isl_basic_map_swap_div(bmap, j, exp[j]);
8814 }
8815 j = 0;
8816 for (i = 0; i < div->n_row; ++i) {
8817 if (j < n_div && exp[j] == i) {
8818 j++;
8819 } else {
8820 isl_seq_cpy(bmap->div[i], div->row[i], div->n_col);
8821 if (isl_basic_map_div_is_marked_unknown(bmap, i))
8822 continue;
8823 if (isl_basic_map_add_div_constraints(bmap, i) < 0)
8824 goto error;
8825 }
8826 }
8827
8828 isl_mat_free(div);
8829 return bmap;
8830error:
8831 isl_basic_map_free(bmap);
8832 isl_mat_free(div);
8833 return NULL((void*)0);
8834}
8835
8836/* Apply the expansion computed by isl_merge_divs.
8837 * The expansion itself is given by "exp" while the resulting
8838 * list of divs is given by "div".
8839 */
8840__isl_give isl_basic_setisl_basic_map *isl_basic_set_expand_divs(
8841 __isl_take isl_basic_setisl_basic_map *bset, __isl_take isl_mat *div, int *exp)
8842{
8843 return isl_basic_map_expand_divs(bset, div, exp);
8844}
8845
8846/* Look for a div in dst that corresponds to the div "div" in src.
8847 * The divs before "div" in src and dst are assumed to be the same.
8848 *
8849 * Returns -1 if no corresponding div was found and the position
8850 * of the corresponding div in dst otherwise.
8851 */
8852static int find_div(__isl_keep isl_basic_map *dst,
8853 __isl_keep isl_basic_map *src, unsigned div)
8854{
8855 int i;
8856
8857 unsigned total = isl_space_dim(src->dim, isl_dim_all);
8858
8859 isl_assert(dst->ctx, div <= dst->n_div, return -1)do { if (div <= dst->n_div) break; do { isl_handle_error
(dst->ctx, isl_error_unknown, "Assertion \"" "div <= dst->n_div"
"\" failed", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8859); return -1; } while (0); } while (0)
;
8860 for (i = div; i < dst->n_div; ++i)
8861 if (isl_seq_eq(dst->div[i], src->div[div], 1+1+total+div) &&
8862 isl_seq_first_non_zero(dst->div[i]+1+1+total+div,
8863 dst->n_div - div) == -1)
8864 return i;
8865 return -1;
8866}
8867
8868/* Align the divs of "dst" to those of "src", adding divs from "src"
8869 * if needed. That is, make sure that the first src->n_div divs
8870 * of the result are equal to those of src.
8871 *
8872 * The result is not finalized as by design it will have redundant
8873 * divs if any divs from "src" were copied.
8874 */
8875__isl_give isl_basic_map *isl_basic_map_align_divs(
8876 __isl_take isl_basic_map *dst, __isl_keep isl_basic_map *src)
8877{
8878 int i;
8879 int known, extended;
8880 unsigned total;
8881
8882 if (!dst || !src)
8883 return isl_basic_map_free(dst);
8884
8885 if (src->n_div == 0)
8886 return dst;
8887
8888 known = isl_basic_map_divs_known(src);
8889 if (known < 0)
8890 return isl_basic_map_free(dst);
8891 if (!known)
8892 isl_die(isl_basic_map_get_ctx(src), isl_error_invalid,do { isl_handle_error(isl_basic_map_get_ctx(src), isl_error_invalid
, "some src divs are unknown", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8894); return isl_basic_map_free(dst); } while (0)
8893 "some src divs are unknown",do { isl_handle_error(isl_basic_map_get_ctx(src), isl_error_invalid
, "some src divs are unknown", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8894); return isl_basic_map_free(dst); } while (0)
8894 return isl_basic_map_free(dst))do { isl_handle_error(isl_basic_map_get_ctx(src), isl_error_invalid
, "some src divs are unknown", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 8894); return isl_basic_map_free(dst); } while (0)
;
8895
8896 src = isl_basic_map_order_divs(src);
8897
8898 extended = 0;
8899 total = isl_space_dim(src->dim, isl_dim_all);
8900 for (i = 0; i < src->n_div; ++i) {
8901 int j = find_div(dst, src, i);
8902 if (j < 0) {
8903 if (!extended) {
8904 int extra = src->n_div - i;
8905 dst = isl_basic_map_cow(dst);
8906 if (!dst)
8907 return NULL((void*)0);
8908 dst = isl_basic_map_extend_space(dst,
8909 isl_space_copy(dst->dim),
8910 extra, 0, 2 * extra);
8911 extended = 1;
8912 }
8913 j = isl_basic_map_alloc_div(dst);
8914 if (j < 0)
8915 return isl_basic_map_free(dst);
8916 isl_seq_cpy(dst->div[j], src->div[i], 1+1+total+i);
8917 isl_seq_clr(dst->div[j]+1+1+total+i, dst->n_div - i);
8918 if (isl_basic_map_add_div_constraints(dst, j) < 0)
8919 return isl_basic_map_free(dst);
8920 }
8921 if (j != i)
8922 isl_basic_map_swap_div(dst, i, j);
8923 }
8924 return dst;
8925}
8926
8927__isl_give isl_map *isl_map_align_divs_internal(__isl_take isl_map *map)
8928{
8929 int i;
8930
8931 if (!map)
8932 return NULL((void*)0);
8933 if (map->n == 0)
8934 return map;
8935 map = isl_map_compute_divs(map);
8936 map = isl_map_cow(map);
8937 if (!map)
8938 return NULL((void*)0);
8939
8940 for (i = 1; i < map->n; ++i)
8941 map->p[0] = isl_basic_map_align_divs(map->p[0], map->p[i]);
8942 for (i = 1; i < map->n; ++i) {
8943 map->p[i] = isl_basic_map_align_divs(map->p[i], map->p[0]);
8944 if (!map->p[i])
8945 return isl_map_free(map);
8946 }
8947
8948 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
8949 return map;
8950}
8951
8952__isl_give isl_map *isl_map_align_divs(__isl_take isl_map *map)
8953{
8954 return isl_map_align_divs_internal(map);
8955}
8956
8957struct isl_setisl_map *isl_set_align_divs(struct isl_setisl_map *set)
8958{
8959 return set_from_map(isl_map_align_divs_internal(set_to_map(set)));
8960}
8961
8962/* Align the divs of the basic maps in "map" to those
8963 * of the basic maps in "list", as well as to the other basic maps in "map".
8964 * The elements in "list" are assumed to have known divs.
8965 */
8966__isl_give isl_map *isl_map_align_divs_to_basic_map_list(
8967 __isl_take isl_map *map, __isl_keep isl_basic_map_list *list)
8968{
8969 int i, n;
8970
8971 map = isl_map_compute_divs(map);
8972 map = isl_map_cow(map);
8973 if (!map || !list)
8974 return isl_map_free(map);
8975 if (map->n == 0)
8976 return map;
8977
8978 n = isl_basic_map_list_n_basic_map(list);
8979 for (i = 0; i < n; ++i) {
8980 isl_basic_map *bmap;
8981
8982 bmap = isl_basic_map_list_get_basic_map(list, i);
8983 map->p[0] = isl_basic_map_align_divs(map->p[0], bmap);
8984 isl_basic_map_free(bmap);
8985 }
8986 if (!map->p[0])
8987 return isl_map_free(map);
8988
8989 return isl_map_align_divs_internal(map);
8990}
8991
8992/* Align the divs of each element of "list" to those of "bmap".
8993 * Both "bmap" and the elements of "list" are assumed to have known divs.
8994 */
8995__isl_give isl_basic_map_list *isl_basic_map_list_align_divs_to_basic_map(
8996 __isl_take isl_basic_map_list *list, __isl_keep isl_basic_map *bmap)
8997{
8998 int i, n;
8999
9000 if (!list || !bmap)
9001 return isl_basic_map_list_free(list);
9002
9003 n = isl_basic_map_list_n_basic_map(list);
9004 for (i = 0; i < n; ++i) {
9005 isl_basic_map *bmap_i;
9006
9007 bmap_i = isl_basic_map_list_get_basic_map(list, i);
9008 bmap_i = isl_basic_map_align_divs(bmap_i, bmap);
9009 list = isl_basic_map_list_set_basic_map(list, i, bmap_i);
9010 }
9011
9012 return list;
9013}
9014
9015static __isl_give isl_setisl_map *set_apply( __isl_take isl_setisl_map *set,
9016 __isl_take isl_map *map)
9017{
9018 isl_bool ok;
9019
9020 ok = isl_map_compatible_domain(map, set);
9021 if (ok < 0)
9022 goto error;
9023 if (!ok)
9024 isl_die(isl_set_get_ctx(set), isl_error_invalid,do { isl_handle_error(isl_set_get_ctx(set), isl_error_invalid
, "incompatible spaces", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 9025); goto error; } while (0)
9025 "incompatible spaces", goto error)do { isl_handle_error(isl_set_get_ctx(set), isl_error_invalid
, "incompatible spaces", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 9025); goto error; } while (0)
;
9026 map = isl_map_intersect_domain(map, set);
9027 set = isl_map_range(map);
9028 return set;
9029error:
9030 isl_set_free(set);
9031 isl_map_free(map);
9032 return NULL((void*)0);
9033}
9034
9035__isl_give isl_setisl_map *isl_set_apply( __isl_take isl_setisl_map *set,
9036 __isl_take isl_map *map)
9037{
9038 return isl_map_align_params_map_map_and(set, map, &set_apply);
9039}
9040
9041/* There is no need to cow as removing empty parts doesn't change
9042 * the meaning of the set.
9043 */
9044__isl_give isl_map *isl_map_remove_empty_parts(__isl_take isl_map *map)
9045{
9046 int i;
9047
9048 if (!map)
9049 return NULL((void*)0);
9050
9051 for (i = map->n - 1; i >= 0; --i)
9052 remove_if_empty(map, i);
9053
9054 return map;
9055}
9056
9057struct isl_setisl_map *isl_set_remove_empty_parts(struct isl_setisl_map *set)
9058{
9059 return set_from_map(isl_map_remove_empty_parts(set_to_map(set)));
9060}
9061
9062/* Given two basic sets bset1 and bset2, compute the maximal difference
9063 * between the values of dimension pos in bset1 and those in bset2
9064 * for any common value of the parameters and dimensions preceding pos.
9065 */
9066static enum isl_lp_result basic_set_maximal_difference_at(
9067 __isl_keep isl_basic_setisl_basic_map *bset1, __isl_keep isl_basic_setisl_basic_map *bset2,
9068 int pos, isl_int *opt)
9069{
9070 isl_basic_map *bmap1;
9071 isl_basic_map *bmap2;
9072 struct isl_ctx *ctx;
9073 struct isl_vec *obj;
9074 unsigned total;
9075 unsigned nparam;
9076 unsigned dim1;
9077 enum isl_lp_result res;
9078
9079 if (!bset1 || !bset2)
9080 return isl_lp_error;
9081
9082 nparam = isl_basic_set_n_param(bset1);
9083 dim1 = isl_basic_set_n_dim(bset1);
9084
9085 bmap1 = isl_basic_map_from_range(isl_basic_set_copy(bset1));
9086 bmap2 = isl_basic_map_from_range(isl_basic_set_copy(bset2));
9087 bmap1 = isl_basic_map_move_dims(bmap1, isl_dim_in, 0,
9088 isl_dim_out, 0, pos);
9089 bmap2 = isl_basic_map_move_dims(bmap2, isl_dim_in, 0,
9090 isl_dim_out, 0, pos);
9091 bmap1 = isl_basic_map_range_product(bmap1, bmap2);
9092 if (!bmap1)
9093 return isl_lp_error;
9094
9095 total = isl_basic_map_total_dim(bmap1);
9096 ctx = bmap1->ctx;
9097 obj = isl_vec_alloc(ctx, 1 + total);
9098 if (!obj)
9099 goto error;
9100 isl_seq_clr(obj->block.data, 1 + total);
9101 isl_int_set_si(obj->block.data[1+nparam+pos], 1)isl_sioimath_set_si((obj->block.data[1+nparam+pos]), 1);
9102 isl_int_set_si(obj->block.data[1+nparam+pos+(dim1-pos)], -1)isl_sioimath_set_si((obj->block.data[1+nparam+pos+(dim1-pos
)]), -1)
;
9103 res = isl_basic_map_solve_lp(bmap1, 1, obj->block.data, ctx->one,
9104 opt, NULL((void*)0), NULL((void*)0));
9105 isl_basic_map_free(bmap1);
9106 isl_vec_free(obj);
9107 return res;
9108error:
9109 isl_basic_map_free(bmap1);
9110 return isl_lp_error;
9111}
9112
9113/* Given two _disjoint_ basic sets bset1 and bset2, check whether
9114 * for any common value of the parameters and dimensions preceding pos
9115 * in both basic sets, the values of dimension pos in bset1 are
9116 * smaller or larger than those in bset2.
9117 *
9118 * Returns
9119 * 1 if bset1 follows bset2
9120 * -1 if bset1 precedes bset2
9121 * 0 if bset1 and bset2 are incomparable
9122 * -2 if some error occurred.
9123 */
9124int isl_basic_set_compare_at(struct isl_basic_setisl_basic_map *bset1,
9125 struct isl_basic_setisl_basic_map *bset2, int pos)
9126{
9127 isl_int opt;
9128 enum isl_lp_result res;
9129 int cmp;
9130
9131 isl_int_init(opt)isl_sioimath_init((opt));
9132
9133 res = basic_set_maximal_difference_at(bset1, bset2, pos, &opt);
9134
9135 if (res == isl_lp_empty)
9136 cmp = 0;
9137 else if ((res == isl_lp_ok && isl_int_is_pos(opt)(isl_sioimath_sgn(*(opt)) > 0)) ||
9138 res == isl_lp_unbounded)
9139 cmp = 1;
9140 else if (res == isl_lp_ok && isl_int_is_neg(opt)(isl_sioimath_sgn(*(opt)) < 0))
9141 cmp = -1;
9142 else
9143 cmp = -2;
9144
9145 isl_int_clear(opt)isl_sioimath_clear((opt));
9146 return cmp;
9147}
9148
9149/* Given two basic sets bset1 and bset2, check whether
9150 * for any common value of the parameters and dimensions preceding pos
9151 * there is a value of dimension pos in bset1 that is larger
9152 * than a value of the same dimension in bset2.
9153 *
9154 * Return
9155 * 1 if there exists such a pair
9156 * 0 if there is no such pair, but there is a pair of equal values
9157 * -1 otherwise
9158 * -2 if some error occurred.
9159 */
9160int isl_basic_set_follows_at(__isl_keep isl_basic_setisl_basic_map *bset1,
9161 __isl_keep isl_basic_setisl_basic_map *bset2, int pos)
9162{
9163 isl_int opt;
9164 enum isl_lp_result res;
9165 int cmp;
9166
9167 isl_int_init(opt)isl_sioimath_init((opt));
9168
9169 res = basic_set_maximal_difference_at(bset1, bset2, pos, &opt);
9170
9171 if (res == isl_lp_empty)
9172 cmp = -1;
9173 else if ((res == isl_lp_ok && isl_int_is_pos(opt)(isl_sioimath_sgn(*(opt)) > 0)) ||
9174 res == isl_lp_unbounded)
9175 cmp = 1;
9176 else if (res == isl_lp_ok && isl_int_is_neg(opt)(isl_sioimath_sgn(*(opt)) < 0))
9177 cmp = -1;
9178 else if (res == isl_lp_ok)
9179 cmp = 0;
9180 else
9181 cmp = -2;
9182
9183 isl_int_clear(opt)isl_sioimath_clear((opt));
9184 return cmp;
9185}
9186
9187/* Given two sets set1 and set2, check whether
9188 * for any common value of the parameters and dimensions preceding pos
9189 * there is a value of dimension pos in set1 that is larger
9190 * than a value of the same dimension in set2.
9191 *
9192 * Return
9193 * 1 if there exists such a pair
9194 * 0 if there is no such pair, but there is a pair of equal values
9195 * -1 otherwise
9196 * -2 if some error occurred.
9197 */
9198int isl_set_follows_at(__isl_keep isl_setisl_map *set1,
9199 __isl_keep isl_setisl_map *set2, int pos)
9200{
9201 int i, j;
9202 int follows = -1;
9203
9204 if (!set1 || !set2)
9205 return -2;
9206
9207 for (i = 0; i < set1->n; ++i)
9208 for (j = 0; j < set2->n; ++j) {
9209 int f;
9210 f = isl_basic_set_follows_at(set1->p[i], set2->p[j], pos);
9211 if (f == 1 || f == -2)
9212 return f;
9213 if (f > follows)
9214 follows = f;
9215 }
9216
9217 return follows;
9218}
9219
9220static isl_bool isl_basic_map_plain_has_fixed_var(
9221 __isl_keep isl_basic_map *bmap, unsigned pos, isl_int *val)
9222{
9223 int i;
9224 int d;
9225 unsigned total;
9226
9227 if (!bmap)
9228 return isl_bool_error;
9229 total = isl_basic_map_total_dim(bmap);
9230 for (i = 0, d = total-1; i < bmap->n_eq && d+1 > pos; ++i) {
9231 for (; d+1 > pos; --d)
9232 if (!isl_int_is_zero(bmap->eq[i][1+d])(isl_sioimath_sgn(*(bmap->eq[i][1+d])) == 0))
9233 break;
9234 if (d != pos)
9235 continue;
9236 if (isl_seq_first_non_zero(bmap->eq[i]+1, d) != -1)
9237 return isl_bool_false;
9238 if (isl_seq_first_non_zero(bmap->eq[i]+1+d+1, total-d-1) != -1)
9239 return isl_bool_false;
9240 if (!isl_int_is_one(bmap->eq[i][1+d])(isl_sioimath_cmp_si(*(bmap->eq[i][1+d]), 1) == 0))
9241 return isl_bool_false;
9242 if (val)
9243 isl_int_neg(*val, bmap->eq[i][0])isl_sioimath_neg((*val), *(bmap->eq[i][0]));
9244 return isl_bool_true;
9245 }
9246 return isl_bool_false;
9247}
9248
9249static isl_bool isl_map_plain_has_fixed_var(__isl_keep isl_map *map,
9250 unsigned pos, isl_int *val)
9251{
9252 int i;
9253 isl_int v;
9254 isl_int tmp;
9255 isl_bool fixed;
9256
9257 if (!map)
9258 return isl_bool_error;
9259 if (map->n == 0)
9260 return isl_bool_false;
9261 if (map->n == 1)
9262 return isl_basic_map_plain_has_fixed_var(map->p[0], pos, val);
9263 isl_int_init(v)isl_sioimath_init((v));
9264 isl_int_init(tmp)isl_sioimath_init((tmp));
9265 fixed = isl_basic_map_plain_has_fixed_var(map->p[0], pos, &v);
9266 for (i = 1; fixed == isl_bool_true && i < map->n; ++i) {
9267 fixed = isl_basic_map_plain_has_fixed_var(map->p[i], pos, &tmp);
9268 if (fixed == isl_bool_true && isl_int_ne(tmp, v)(isl_sioimath_cmp(*(tmp), *(v)) != 0))
9269 fixed = isl_bool_false;
9270 }
9271 if (val)
9272 isl_int_set(*val, v)isl_sioimath_set((*val), *(v));
9273 isl_int_clear(tmp)isl_sioimath_clear((tmp));
9274 isl_int_clear(v)isl_sioimath_clear((v));
9275 return fixed;
9276}
9277
9278static isl_bool isl_basic_set_plain_has_fixed_var(
9279 __isl_keep isl_basic_setisl_basic_map *bset, unsigned pos, isl_int *val)
9280{
9281 return isl_basic_map_plain_has_fixed_var(bset_to_bmap(bset),
9282 pos, val);
9283}
9284
9285isl_bool isl_basic_map_plain_is_fixed(__isl_keep isl_basic_map *bmap,
9286 enum isl_dim_type type, unsigned pos, isl_int *val)
9287{
9288 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
9289 return isl_bool_error;
9290 return isl_basic_map_plain_has_fixed_var(bmap,
9291 isl_basic_map_offset(bmap, type) - 1 + pos, val);
9292}
9293
9294/* If "bmap" obviously lies on a hyperplane where the given dimension
9295 * has a fixed value, then return that value.
9296 * Otherwise return NaN.
9297 */
9298__isl_give isl_val *isl_basic_map_plain_get_val_if_fixed(
9299 __isl_keep isl_basic_map *bmap,
9300 enum isl_dim_type type, unsigned pos)
9301{
9302 isl_ctx *ctx;
9303 isl_val *v;
9304 isl_bool fixed;
9305
9306 if (!bmap)
9307 return NULL((void*)0);
9308 ctx = isl_basic_map_get_ctx(bmap);
9309 v = isl_val_alloc(ctx);
9310 if (!v)
9311 return NULL((void*)0);
9312 fixed = isl_basic_map_plain_is_fixed(bmap, type, pos, &v->n);
9313 if (fixed < 0)
9314 return isl_val_free(v);
9315 if (fixed) {
9316 isl_int_set_si(v->d, 1)isl_sioimath_set_si((v->d), 1);
9317 return v;
9318 }
9319 isl_val_free(v);
9320 return isl_val_nan(ctx);
9321}
9322
9323isl_bool isl_map_plain_is_fixed(__isl_keep isl_map *map,
9324 enum isl_dim_type type, unsigned pos, isl_int *val)
9325{
9326 if (pos >= isl_map_dim(map, type))
9327 isl_die(isl_map_get_ctx(map), isl_error_invalid,do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "position out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 9328); return isl_bool_error; } while (0)
9328 "position out of bounds", return isl_bool_error)do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "position out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 9328); return isl_bool_error; } while (0)
;
9329 return isl_map_plain_has_fixed_var(map,
9330 map_offset(map, type) - 1 + pos, val);
9331}
9332
9333/* If "map" obviously lies on a hyperplane where the given dimension
9334 * has a fixed value, then return that value.
9335 * Otherwise return NaN.
9336 */
9337__isl_give isl_val *isl_map_plain_get_val_if_fixed(__isl_keep isl_map *map,
9338 enum isl_dim_type type, unsigned pos)
9339{
9340 isl_ctx *ctx;
9341 isl_val *v;
9342 isl_bool fixed;
9343
9344 if (!map)
9345 return NULL((void*)0);
9346 ctx = isl_map_get_ctx(map);
9347 v = isl_val_alloc(ctx);
9348 if (!v)
9349 return NULL((void*)0);
9350 fixed = isl_map_plain_is_fixed(map, type, pos, &v->n);
9351 if (fixed < 0)
9352 return isl_val_free(v);
9353 if (fixed) {
9354 isl_int_set_si(v->d, 1)isl_sioimath_set_si((v->d), 1);
9355 return v;
9356 }
9357 isl_val_free(v);
9358 return isl_val_nan(ctx);
9359}
9360
9361/* If "set" obviously lies on a hyperplane where the given dimension
9362 * has a fixed value, then return that value.
9363 * Otherwise return NaN.
9364 */
9365__isl_give isl_val *isl_set_plain_get_val_if_fixed(__isl_keep isl_setisl_map *set,
9366 enum isl_dim_type type, unsigned pos)
9367{
9368 return isl_map_plain_get_val_if_fixed(set, type, pos);
9369}
9370
9371/* Check if dimension dim has fixed value and if so and if val is not NULL,
9372 * then return this fixed value in *val.
9373 */
9374isl_bool isl_basic_set_plain_dim_is_fixed(__isl_keep isl_basic_setisl_basic_map *bset,
9375 unsigned dim, isl_int *val)
9376{
9377 return isl_basic_set_plain_has_fixed_var(bset,
9378 isl_basic_set_n_param(bset) + dim, val);
9379}
9380
9381/* Return -1 if the constraint "c1" should be sorted before "c2"
9382 * and 1 if it should be sorted after "c2".
9383 * Return 0 if the two constraints are the same (up to the constant term).
9384 *
9385 * In particular, if a constraint involves later variables than another
9386 * then it is sorted after this other constraint.
9387 * uset_gist depends on constraints without existentially quantified
9388 * variables sorting first.
9389 *
9390 * For constraints that have the same latest variable, those
9391 * with the same coefficient for this latest variable (first in absolute value
9392 * and then in actual value) are grouped together.
9393 * This is useful for detecting pairs of constraints that can
9394 * be chained in their printed representation.
9395 *
9396 * Finally, within a group, constraints are sorted according to
9397 * their coefficients (excluding the constant term).
9398 */
9399static int sort_constraint_cmp(const void *p1, const void *p2, void *arg)
9400{
9401 isl_int **c1 = (isl_int **) p1;
9402 isl_int **c2 = (isl_int **) p2;
9403 int l1, l2;
9404 unsigned size = *(unsigned *) arg;
9405 int cmp;
9406
9407 l1 = isl_seq_last_non_zero(*c1 + 1, size);
9408 l2 = isl_seq_last_non_zero(*c2 + 1, size);
9409
9410 if (l1 != l2)
9411 return l1 - l2;
9412
9413 cmp = isl_int_abs_cmp((*c1)[1 + l1], (*c2)[1 + l1])isl_sioimath_abs_cmp(*((*c1)[1 + l1]), *((*c2)[1 + l1]));
9414 if (cmp != 0)
9415 return cmp;
9416 cmp = isl_int_cmp((*c1)[1 + l1], (*c2)[1 + l1])isl_sioimath_cmp(*((*c1)[1 + l1]), *((*c2)[1 + l1]));
9417 if (cmp != 0)
9418 return -cmp;
9419
9420 return isl_seq_cmp(*c1 + 1, *c2 + 1, size);
9421}
9422
9423/* Return -1 if the constraint "c1" of "bmap" is sorted before "c2"
9424 * by isl_basic_map_sort_constraints, 1 if it is sorted after "c2"
9425 * and 0 if the two constraints are the same (up to the constant term).
9426 */
9427int isl_basic_map_constraint_cmp(__isl_keep isl_basic_map *bmap,
9428 isl_int *c1, isl_int *c2)
9429{
9430 unsigned total;
9431
9432 if (!bmap)
9433 return -2;
9434 total = isl_basic_map_total_dim(bmap);
9435 return sort_constraint_cmp(&c1, &c2, &total);
9436}
9437
9438__isl_give isl_basic_map *isl_basic_map_sort_constraints(
9439 __isl_take isl_basic_map *bmap)
9440{
9441 unsigned total;
9442
9443 if (!bmap)
9444 return NULL((void*)0);
9445 if (bmap->n_ineq == 0)
9446 return bmap;
9447 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED)(!!(((bmap)->flags) & ((1 << 5)))))
9448 return bmap;
9449 total = isl_basic_map_total_dim(bmap);
9450 if (isl_sort(bmap->ineq, bmap->n_ineq, sizeof(isl_int *),
9451 &sort_constraint_cmp, &total) < 0)
9452 return isl_basic_map_free(bmap);
9453 return bmap;
9454}
9455
9456__isl_give isl_basic_setisl_basic_map *isl_basic_set_sort_constraints(
9457 __isl_take isl_basic_setisl_basic_map *bset)
9458{
9459 isl_basic_map *bmap = bset_to_bmap(bset);
9460 return bset_from_bmap(isl_basic_map_sort_constraints(bmap));
9461}
9462
9463__isl_give isl_basic_map *isl_basic_map_normalize(
9464 __isl_take isl_basic_map *bmap)
9465{
9466 if (!bmap)
9467 return NULL((void*)0);
9468 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED)(!!(((bmap)->flags) & ((1 << 5)))))
9469 return bmap;
9470 bmap = isl_basic_map_remove_redundancies(bmap);
9471 bmap = isl_basic_map_sort_constraints(bmap);
9472 if (bmap)
9473 ISL_F_SET(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) |= ((1 << 5)));
9474 return bmap;
9475}
9476int isl_basic_map_plain_cmp(__isl_keep isl_basic_map *bmap1,
9477 __isl_keep isl_basic_map *bmap2)
9478{
9479 int i, cmp;
9480 unsigned total;
9481 isl_space *space1, *space2;
9482
9483 if (!bmap1 || !bmap2)
9484 return -1;
9485
9486 if (bmap1 == bmap2)
9487 return 0;
9488 space1 = isl_basic_map_peek_space(bmap1);
9489 space2 = isl_basic_map_peek_space(bmap2);
9490 cmp = isl_space_cmp(space1, space2);
9491 if (cmp)
9492 return cmp;
9493 if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_RATIONAL)(!!(((bmap1)->flags) & ((1 << 4)))) !=
9494 ISL_F_ISSET(bmap2, ISL_BASIC_MAP_RATIONAL)(!!(((bmap2)->flags) & ((1 << 4)))))
9495 return ISL_F_ISSET(bmap1, ISL_BASIC_MAP_RATIONAL)(!!(((bmap1)->flags) & ((1 << 4)))) ? -1 : 1;
9496 if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY)(!!(((bmap1)->flags) & ((1 << 1)))) &&
9497 ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY)(!!(((bmap2)->flags) & ((1 << 1)))))
9498 return 0;
9499 if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY)(!!(((bmap1)->flags) & ((1 << 1)))))
9500 return 1;
9501 if (ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY)(!!(((bmap2)->flags) & ((1 << 1)))))
9502 return -1;
9503 if (bmap1->n_eq != bmap2->n_eq)
9504 return bmap1->n_eq - bmap2->n_eq;
9505 if (bmap1->n_ineq != bmap2->n_ineq)
9506 return bmap1->n_ineq - bmap2->n_ineq;
9507 if (bmap1->n_div != bmap2->n_div)
9508 return bmap1->n_div - bmap2->n_div;
9509 total = isl_basic_map_total_dim(bmap1);
9510 for (i = 0; i < bmap1->n_eq; ++i) {
9511 cmp = isl_seq_cmp(bmap1->eq[i], bmap2->eq[i], 1+total);
9512 if (cmp)
9513 return cmp;
9514 }
9515 for (i = 0; i < bmap1->n_ineq; ++i) {
9516 cmp = isl_seq_cmp(bmap1->ineq[i], bmap2->ineq[i], 1+total);
9517 if (cmp)
9518 return cmp;
9519 }
9520 for (i = 0; i < bmap1->n_div; ++i) {
9521 cmp = isl_seq_cmp(bmap1->div[i], bmap2->div[i], 1+1+total);
9522 if (cmp)
9523 return cmp;
9524 }
9525 return 0;
9526}
9527
9528int isl_basic_set_plain_cmp(__isl_keep isl_basic_setisl_basic_map *bset1,
9529 __isl_keep isl_basic_setisl_basic_map *bset2)
9530{
9531 return isl_basic_map_plain_cmp(bset1, bset2);
9532}
9533
9534int isl_set_plain_cmp(__isl_keep isl_setisl_map *set1, __isl_keep isl_setisl_map *set2)
9535{
9536 int i, cmp;
9537
9538 if (set1 == set2)
9539 return 0;
9540 if (set1->n != set2->n)
9541 return set1->n - set2->n;
9542
9543 for (i = 0; i < set1->n; ++i) {
9544 cmp = isl_basic_set_plain_cmp(set1->p[i], set2->p[i]);
9545 if (cmp)
9546 return cmp;
9547 }
9548
9549 return 0;
9550}
9551
9552isl_bool isl_basic_map_plain_is_equal(__isl_keep isl_basic_map *bmap1,
9553 __isl_keep isl_basic_map *bmap2)
9554{
9555 if (!bmap1 || !bmap2)
9556 return isl_bool_error;
9557 return isl_basic_map_plain_cmp(bmap1, bmap2) == 0;
9558}
9559
9560isl_bool isl_basic_set_plain_is_equal(__isl_keep isl_basic_setisl_basic_map *bset1,
9561 __isl_keep isl_basic_setisl_basic_map *bset2)
9562{
9563 return isl_basic_map_plain_is_equal(bset_to_bmap(bset1),
9564 bset_to_bmap(bset2));
9565}
9566
9567static int qsort_bmap_cmp(const void *p1, const void *p2)
9568{
9569 isl_basic_map *bmap1 = *(isl_basic_map **) p1;
9570 isl_basic_map *bmap2 = *(isl_basic_map **) p2;
9571
9572 return isl_basic_map_plain_cmp(bmap1, bmap2);
9573}
9574
9575/* Sort the basic maps of "map" and remove duplicate basic maps.
9576 *
9577 * While removing basic maps, we make sure that the basic maps remain
9578 * sorted because isl_map_normalize expects the basic maps of the result
9579 * to be sorted.
9580 */
9581static __isl_give isl_map *sort_and_remove_duplicates(__isl_take isl_map *map)
9582{
9583 int i, j;
9584
9585 map = isl_map_remove_empty_parts(map);
9586 if (!map)
9587 return NULL((void*)0);
9588 qsort(map->p, map->n, sizeof(struct isl_basic_map *), qsort_bmap_cmp);
9589 for (i = map->n - 1; i >= 1; --i) {
9590 if (!isl_basic_map_plain_is_equal(map->p[i - 1], map->p[i]))
9591 continue;
9592 isl_basic_map_free(map->p[i-1]);
9593 for (j = i; j < map->n; ++j)
9594 map->p[j - 1] = map->p[j];
9595 map->n--;
9596 }
9597
9598 return map;
9599}
9600
9601/* Remove obvious duplicates among the basic maps of "map".
9602 *
9603 * Unlike isl_map_normalize, this function does not remove redundant
9604 * constraints and only removes duplicates that have exactly the same
9605 * constraints in the input. It does sort the constraints and
9606 * the basic maps to ease the detection of duplicates.
9607 *
9608 * If "map" has already been normalized or if the basic maps are
9609 * disjoint, then there can be no duplicates.
9610 */
9611__isl_give isl_map *isl_map_remove_obvious_duplicates(__isl_take isl_map *map)
9612{
9613 int i;
9614 isl_basic_map *bmap;
9615
9616 if (!map)
9617 return NULL((void*)0);
9618 if (map->n <= 1)
9619 return map;
9620 if (ISL_F_ISSET(map, ISL_MAP_NORMALIZED | ISL_MAP_DISJOINT)(!!(((map)->flags) & ((1 << 1) | (1 << 0))
))
)
9621 return map;
9622 for (i = 0; i < map->n; ++i) {
9623 bmap = isl_basic_map_copy(map->p[i]);
9624 bmap = isl_basic_map_sort_constraints(bmap);
9625 if (!bmap)
9626 return isl_map_free(map);
9627 isl_basic_map_free(map->p[i]);
9628 map->p[i] = bmap;
9629 }
9630
9631 map = sort_and_remove_duplicates(map);
9632 return map;
9633}
9634
9635/* We normalize in place, but if anything goes wrong we need
9636 * to return NULL, so we need to make sure we don't change the
9637 * meaning of any possible other copies of map.
9638 */
9639__isl_give isl_map *isl_map_normalize(__isl_take isl_map *map)
9640{
9641 int i;
9642 struct isl_basic_map *bmap;
9643
9644 if (!map)
9645 return NULL((void*)0);
9646 if (ISL_F_ISSET(map, ISL_MAP_NORMALIZED)(!!(((map)->flags) & ((1 << 1)))))
9647 return map;
9648 for (i = 0; i < map->n; ++i) {
9649 bmap = isl_basic_map_normalize(isl_basic_map_copy(map->p[i]));
9650 if (!bmap)
9651 goto error;
9652 isl_basic_map_free(map->p[i]);
9653 map->p[i] = bmap;
9654 }
9655
9656 map = sort_and_remove_duplicates(map);
9657 if (map)
9658 ISL_F_SET(map, ISL_MAP_NORMALIZED)(((map)->flags) |= ((1 << 1)));
9659 return map;
9660error:
9661 isl_map_free(map);
9662 return NULL((void*)0);
9663}
9664
9665struct isl_setisl_map *isl_set_normalize(struct isl_setisl_map *set)
9666{
9667 return set_from_map(isl_map_normalize(set_to_map(set)));
9668}
9669
9670isl_bool isl_map_plain_is_equal(__isl_keep isl_map *map1,
9671 __isl_keep isl_map *map2)
9672{
9673 int i;
9674 isl_bool equal;
9675
9676 if (!map1 || !map2)
9677 return isl_bool_error;
9678
9679 if (map1 == map2)
9680 return isl_bool_true;
9681 if (!isl_space_is_equal(map1->dim, map2->dim))
9682 return isl_bool_false;
9683
9684 map1 = isl_map_copy(map1);
9685 map2 = isl_map_copy(map2);
9686 map1 = isl_map_normalize(map1);
9687 map2 = isl_map_normalize(map2);
9688 if (!map1 || !map2)
9689 goto error;
9690 equal = map1->n == map2->n;
9691 for (i = 0; equal && i < map1->n; ++i) {
9692 equal = isl_basic_map_plain_is_equal(map1->p[i], map2->p[i]);
9693 if (equal < 0)
9694 goto error;
9695 }
9696 isl_map_free(map1);
9697 isl_map_free(map2);
9698 return equal;
9699error:
9700 isl_map_free(map1);
9701 isl_map_free(map2);
9702 return isl_bool_error;
9703}
9704
9705isl_bool isl_set_plain_is_equal(__isl_keep isl_setisl_map *set1,
9706 __isl_keep isl_setisl_map *set2)
9707{
9708 return isl_map_plain_is_equal(set_to_map(set1), set_to_map(set2));
9709}
9710
9711/* Return the basic maps in "map" as a list.
9712 */
9713__isl_give isl_basic_map_list *isl_map_get_basic_map_list(
9714 __isl_keep isl_map *map)
9715{
9716 int i;
9717 isl_ctx *ctx;
9718 isl_basic_map_list *list;
9719
9720 if (!map)
9721 return NULL((void*)0);
9722 ctx = isl_map_get_ctx(map);
9723 list = isl_basic_map_list_alloc(ctx, map->n);
9724
9725 for (i = 0; i < map->n; ++i) {
9726 isl_basic_map *bmap;
9727
9728 bmap = isl_basic_map_copy(map->p[i]);
9729 list = isl_basic_map_list_add(list, bmap);
9730 }
9731
9732 return list;
9733}
9734
9735/* Return the intersection of the elements in the non-empty list "list".
9736 * All elements are assumed to live in the same space.
9737 */
9738__isl_give isl_basic_map *isl_basic_map_list_intersect(
9739 __isl_take isl_basic_map_list *list)
9740{
9741 int i, n;
9742 isl_basic_map *bmap;
9743
9744 if (!list)
9745 return NULL((void*)0);
9746 n = isl_basic_map_list_n_basic_map(list);
9747 if (n < 1)
9748 isl_die(isl_basic_map_list_get_ctx(list), isl_error_invalid,do { isl_handle_error(isl_basic_map_list_get_ctx(list), isl_error_invalid
, "expecting non-empty list", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 9749); goto error; } while (0)
9749 "expecting non-empty list", goto error)do { isl_handle_error(isl_basic_map_list_get_ctx(list), isl_error_invalid
, "expecting non-empty list", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 9749); goto error; } while (0)
;
9750
9751 bmap = isl_basic_map_list_get_basic_map(list, 0);
9752 for (i = 1; i < n; ++i) {
9753 isl_basic_map *bmap_i;
9754
9755 bmap_i = isl_basic_map_list_get_basic_map(list, i);
9756 bmap = isl_basic_map_intersect(bmap, bmap_i);
9757 }
9758
9759 isl_basic_map_list_free(list);
9760 return bmap;
9761error:
9762 isl_basic_map_list_free(list);
9763 return NULL((void*)0);
9764}
9765
9766/* Return the intersection of the elements in the non-empty list "list".
9767 * All elements are assumed to live in the same space.
9768 */
9769__isl_give isl_basic_setisl_basic_map *isl_basic_set_list_intersect(
9770 __isl_take isl_basic_set_listisl_basic_map_list *list)
9771{
9772 return isl_basic_map_list_intersect(list);
9773}
9774
9775/* Return the union of the elements of "list".
9776 * The list is required to have at least one element.
9777 */
9778__isl_give isl_setisl_map *isl_basic_set_list_union(
9779 __isl_take isl_basic_set_listisl_basic_map_list *list)
9780{
9781 int i, n;
9782 isl_space *space;
9783 isl_basic_setisl_basic_map *bset;
9784 isl_setisl_map *set;
9785
9786 if (!list)
9787 return NULL((void*)0);
9788 n = isl_basic_set_list_n_basic_set(list);
9789 if (n < 1)
9790 isl_die(isl_basic_set_list_get_ctx(list), isl_error_invalid,do { isl_handle_error(isl_basic_set_list_get_ctx(list), isl_error_invalid
, "expecting non-empty list", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 9791); goto error; } while (0)
9791 "expecting non-empty list", goto error)do { isl_handle_error(isl_basic_set_list_get_ctx(list), isl_error_invalid
, "expecting non-empty list", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 9791); goto error; } while (0)
;
9792
9793 bset = isl_basic_set_list_get_basic_set(list, 0);
9794 space = isl_basic_set_get_space(bset);
9795 isl_basic_set_free(bset);
9796
9797 set = isl_set_alloc_space(space, n, 0);
9798 for (i = 0; i < n; ++i) {
9799 bset = isl_basic_set_list_get_basic_set(list, i);
9800 set = isl_set_add_basic_set(set, bset);
9801 }
9802
9803 isl_basic_set_list_free(list);
9804 return set;
9805error:
9806 isl_basic_set_list_free(list);
9807 return NULL((void*)0);
9808}
9809
9810/* Return the union of the elements in the non-empty list "list".
9811 * All elements are assumed to live in the same space.
9812 */
9813__isl_give isl_setisl_map *isl_set_list_union(__isl_take isl_set_listisl_map_list *list)
9814{
9815 int i, n;
9816 isl_setisl_map *set;
9817
9818 if (!list)
9819 return NULL((void*)0);
9820 n = isl_set_list_n_set(list);
9821 if (n < 1)
9822 isl_die(isl_set_list_get_ctx(list), isl_error_invalid,do { isl_handle_error(isl_set_list_get_ctx(list), isl_error_invalid
, "expecting non-empty list", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 9823); goto error; } while (0)
9823 "expecting non-empty list", goto error)do { isl_handle_error(isl_set_list_get_ctx(list), isl_error_invalid
, "expecting non-empty list", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 9823); goto error; } while (0)
;
9824
9825 set = isl_set_list_get_set(list, 0);
9826 for (i = 1; i < n; ++i) {
9827 isl_setisl_map *set_i;
9828
9829 set_i = isl_set_list_get_set(list, i);
9830 set = isl_set_union(set, set_i);
9831 }
9832
9833 isl_set_list_free(list);
9834 return set;
9835error:
9836 isl_set_list_free(list);
9837 return NULL((void*)0);
9838}
9839
9840__isl_give isl_basic_map *isl_basic_map_product(
9841 __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
9842{
9843 isl_space *dim_result = NULL((void*)0);
9844 struct isl_basic_map *bmap;
9845 unsigned in1, in2, out1, out2, nparam, total, pos;
9846 struct isl_dim_map *dim_map1, *dim_map2;
9847
9848 if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
9849 goto error;
9850 dim_result = isl_space_product(isl_space_copy(bmap1->dim),
9851 isl_space_copy(bmap2->dim));
9852
9853 in1 = isl_basic_map_dim(bmap1, isl_dim_in);
9854 in2 = isl_basic_map_dim(bmap2, isl_dim_in);
9855 out1 = isl_basic_map_dim(bmap1, isl_dim_out);
9856 out2 = isl_basic_map_dim(bmap2, isl_dim_out);
9857 nparam = isl_basic_map_dim(bmap1, isl_dim_param);
9858
9859 total = nparam + in1 + in2 + out1 + out2 + bmap1->n_div + bmap2->n_div;
9860 dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
9861 dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
9862 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
9863 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
9864 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
9865 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos += in1);
9866 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += in2);
9867 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += out1);
9868 isl_dim_map_div(dim_map1, bmap1, pos += out2);
9869 isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
9870
9871 bmap = isl_basic_map_alloc_space(dim_result,
9872 bmap1->n_div + bmap2->n_div,
9873 bmap1->n_eq + bmap2->n_eq,
9874 bmap1->n_ineq + bmap2->n_ineq);
9875 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
9876 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
9877 bmap = isl_basic_map_simplify(bmap);
9878 return isl_basic_map_finalize(bmap);
9879error:
9880 isl_basic_map_free(bmap1);
9881 isl_basic_map_free(bmap2);
9882 return NULL((void*)0);
9883}
9884
9885__isl_give isl_basic_map *isl_basic_map_flat_product(
9886 __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
9887{
9888 isl_basic_map *prod;
9889
9890 prod = isl_basic_map_product(bmap1, bmap2);
9891 prod = isl_basic_map_flatten(prod);
9892 return prod;
9893}
9894
9895__isl_give isl_basic_setisl_basic_map *isl_basic_set_flat_product(
9896 __isl_take isl_basic_setisl_basic_map *bset1, __isl_take isl_basic_setisl_basic_map *bset2)
9897{
9898 return isl_basic_map_flat_range_product(bset1, bset2);
9899}
9900
9901__isl_give isl_basic_map *isl_basic_map_domain_product(
9902 __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
9903{
9904 isl_space *space_result = NULL((void*)0);
9905 isl_basic_map *bmap;
9906 unsigned in1, in2, out, nparam, total, pos;
9907 struct isl_dim_map *dim_map1, *dim_map2;
9908
9909 if (!bmap1 || !bmap2)
9910 goto error;
9911
9912 space_result = isl_space_domain_product(isl_space_copy(bmap1->dim),
9913 isl_space_copy(bmap2->dim));
9914
9915 in1 = isl_basic_map_dim(bmap1, isl_dim_in);
9916 in2 = isl_basic_map_dim(bmap2, isl_dim_in);
9917 out = isl_basic_map_dim(bmap1, isl_dim_out);
9918 nparam = isl_basic_map_dim(bmap1, isl_dim_param);
9919
9920 total = nparam + in1 + in2 + out + bmap1->n_div + bmap2->n_div;
9921 dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
9922 dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
9923 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
9924 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
9925 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
9926 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos += in1);
9927 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += in2);
9928 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos);
9929 isl_dim_map_div(dim_map1, bmap1, pos += out);
9930 isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
9931
9932 bmap = isl_basic_map_alloc_space(space_result,
9933 bmap1->n_div + bmap2->n_div,
9934 bmap1->n_eq + bmap2->n_eq,
9935 bmap1->n_ineq + bmap2->n_ineq);
9936 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
9937 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
9938 bmap = isl_basic_map_simplify(bmap);
9939 return isl_basic_map_finalize(bmap);
9940error:
9941 isl_basic_map_free(bmap1);
9942 isl_basic_map_free(bmap2);
9943 return NULL((void*)0);
9944}
9945
9946__isl_give isl_basic_map *isl_basic_map_range_product(
9947 __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
9948{
9949 isl_bool rational;
9950 isl_space *dim_result = NULL((void*)0);
9951 isl_basic_map *bmap;
9952 unsigned in, out1, out2, nparam, total, pos;
9953 struct isl_dim_map *dim_map1, *dim_map2;
9954
9955 rational = isl_basic_map_is_rational(bmap1);
9956 if (rational >= 0 && rational)
9957 rational = isl_basic_map_is_rational(bmap2);
9958 if (!bmap1 || !bmap2 || rational < 0)
9959 goto error;
9960
9961 if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
9962 goto error;
9963
9964 dim_result = isl_space_range_product(isl_space_copy(bmap1->dim),
9965 isl_space_copy(bmap2->dim));
9966
9967 in = isl_basic_map_dim(bmap1, isl_dim_in);
9968 out1 = isl_basic_map_dim(bmap1, isl_dim_out);
9969 out2 = isl_basic_map_dim(bmap2, isl_dim_out);
9970 nparam = isl_basic_map_dim(bmap1, isl_dim_param);
9971
9972 total = nparam + in + out1 + out2 + bmap1->n_div + bmap2->n_div;
9973 dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
9974 dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
9975 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
9976 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
9977 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
9978 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
9979 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += in);
9980 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += out1);
9981 isl_dim_map_div(dim_map1, bmap1, pos += out2);
9982 isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
9983
9984 bmap = isl_basic_map_alloc_space(dim_result,
9985 bmap1->n_div + bmap2->n_div,
9986 bmap1->n_eq + bmap2->n_eq,
9987 bmap1->n_ineq + bmap2->n_ineq);
9988 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
9989 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
9990 if (rational)
9991 bmap = isl_basic_map_set_rational(bmap);
9992 bmap = isl_basic_map_simplify(bmap);
9993 return isl_basic_map_finalize(bmap);
9994error:
9995 isl_basic_map_free(bmap1);
9996 isl_basic_map_free(bmap2);
9997 return NULL((void*)0);
9998}
9999
10000__isl_give isl_basic_map *isl_basic_map_flat_range_product(
10001 __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
10002{
10003 isl_basic_map *prod;
10004
10005 prod = isl_basic_map_range_product(bmap1, bmap2);
10006 prod = isl_basic_map_flatten_range(prod);
10007 return prod;
10008}
10009
10010/* Apply "basic_map_product" to each pair of basic maps in "map1" and "map2"
10011 * and collect the results.
10012 * The result live in the space obtained by calling "space_product"
10013 * on the spaces of "map1" and "map2".
10014 * If "remove_duplicates" is set then the result may contain duplicates
10015 * (even if the inputs do not) and so we try and remove the obvious
10016 * duplicates.
10017 */
10018static __isl_give isl_map *map_product(__isl_take isl_map *map1,
10019 __isl_take isl_map *map2,
10020 __isl_give isl_space *(*space_product)(__isl_take isl_space *left,
10021 __isl_take isl_space *right),
10022 __isl_give isl_basic_map *(*basic_map_product)(
10023 __isl_take isl_basic_map *left,
10024 __isl_take isl_basic_map *right),
10025 int remove_duplicates)
10026{
10027 unsigned flags = 0;
10028 struct isl_map *result;
10029 int i, j;
10030 isl_bool m;
10031
10032 m = isl_map_has_equal_params(map1, map2);
10033 if (m < 0)
10034 goto error;
10035 if (!m)
10036 isl_die(isl_map_get_ctx(map1), isl_error_invalid,do { isl_handle_error(isl_map_get_ctx(map1), isl_error_invalid
, "parameters don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 10037); goto error; } while (0)
10037 "parameters don't match", goto error)do { isl_handle_error(isl_map_get_ctx(map1), isl_error_invalid
, "parameters don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 10037); goto error; } while (0)
;
10038
10039 if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT)(!!(((map1)->flags) & ((1 << 0)))) &&
10040 ISL_F_ISSET(map2, ISL_MAP_DISJOINT)(!!(((map2)->flags) & ((1 << 0)))))
10041 ISL_FL_SET(flags, ISL_MAP_DISJOINT)((flags) |= ((1 << 0)));
10042
10043 result = isl_map_alloc_space(space_product(isl_space_copy(map1->dim),
10044 isl_space_copy(map2->dim)),
10045 map1->n * map2->n, flags);
10046 if (!result)
10047 goto error;
10048 for (i = 0; i < map1->n; ++i)
10049 for (j = 0; j < map2->n; ++j) {
10050 struct isl_basic_map *part;
10051 part = basic_map_product(isl_basic_map_copy(map1->p[i]),
10052 isl_basic_map_copy(map2->p[j]));
10053 if (isl_basic_map_is_empty(part))
10054 isl_basic_map_free(part);
10055 else
10056 result = isl_map_add_basic_map(result, part);
10057 if (!result)
10058 goto error;
10059 }
10060 if (remove_duplicates)
10061 result = isl_map_remove_obvious_duplicates(result);
10062 isl_map_free(map1);
10063 isl_map_free(map2);
10064 return result;
10065error:
10066 isl_map_free(map1);
10067 isl_map_free(map2);
10068 return NULL((void*)0);
10069}
10070
10071/* Given two maps A -> B and C -> D, construct a map [A -> C] -> [B -> D]
10072 */
10073static __isl_give isl_map *map_product_aligned(__isl_take isl_map *map1,
10074 __isl_take isl_map *map2)
10075{
10076 return map_product(map1, map2, &isl_space_product,
10077 &isl_basic_map_product, 0);
10078}
10079
10080__isl_give isl_map *isl_map_product(__isl_take isl_map *map1,
10081 __isl_take isl_map *map2)
10082{
10083 return isl_map_align_params_map_map_and(map1, map2, &map_product_aligned);
10084}
10085
10086/* Given two maps A -> B and C -> D, construct a map (A, C) -> (B, D)
10087 */
10088__isl_give isl_map *isl_map_flat_product(__isl_take isl_map *map1,
10089 __isl_take isl_map *map2)
10090{
10091 isl_map *prod;
10092
10093 prod = isl_map_product(map1, map2);
10094 prod = isl_map_flatten(prod);
10095 return prod;
10096}
10097
10098/* Given two set A and B, construct its Cartesian product A x B.
10099 */
10100struct isl_setisl_map *isl_set_product(struct isl_setisl_map *set1, struct isl_setisl_map *set2)
10101{
10102 return isl_map_range_product(set1, set2);
10103}
10104
10105__isl_give isl_setisl_map *isl_set_flat_product(__isl_take isl_setisl_map *set1,
10106 __isl_take isl_setisl_map *set2)
10107{
10108 return isl_map_flat_range_product(set1, set2);
10109}
10110
10111/* Given two maps A -> B and C -> D, construct a map [A -> C] -> (B * D)
10112 */
10113static __isl_give isl_map *map_domain_product_aligned(__isl_take isl_map *map1,
10114 __isl_take isl_map *map2)
10115{
10116 return map_product(map1, map2, &isl_space_domain_product,
10117 &isl_basic_map_domain_product, 1);
10118}
10119
10120/* Given two maps A -> B and C -> D, construct a map (A * C) -> [B -> D]
10121 */
10122static __isl_give isl_map *map_range_product_aligned(__isl_take isl_map *map1,
10123 __isl_take isl_map *map2)
10124{
10125 return map_product(map1, map2, &isl_space_range_product,
10126 &isl_basic_map_range_product, 1);
10127}
10128
10129__isl_give isl_map *isl_map_domain_product(__isl_take isl_map *map1,
10130 __isl_take isl_map *map2)
10131{
10132 return isl_map_align_params_map_map_and(map1, map2,
10133 &map_domain_product_aligned);
10134}
10135
10136__isl_give isl_map *isl_map_range_product(__isl_take isl_map *map1,
10137 __isl_take isl_map *map2)
10138{
10139 return isl_map_align_params_map_map_and(map1, map2,
10140 &map_range_product_aligned);
10141}
10142
10143/* Given a map of the form [A -> B] -> [C -> D], return the map A -> C.
10144 */
10145__isl_give isl_map *isl_map_factor_domain(__isl_take isl_map *map)
10146{
10147 isl_space *space;
10148 int total1, keep1, total2, keep2;
10149
10150 if (!map)
10151 return NULL((void*)0);
10152 if (!isl_space_domain_is_wrapping(map->dim) ||
10153 !isl_space_range_is_wrapping(map->dim))
10154 isl_die(isl_map_get_ctx(map), isl_error_invalid,do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "not a product", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 10155); return isl_map_free(map); } while (0)
10155 "not a product", return isl_map_free(map))do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "not a product", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 10155); return isl_map_free(map); } while (0)
;
10156
10157 space = isl_map_get_space(map);
10158 total1 = isl_space_dim(space, isl_dim_in);
10159 total2 = isl_space_dim(space, isl_dim_out);
10160 space = isl_space_factor_domain(space);
10161 keep1 = isl_space_dim(space, isl_dim_in);
10162 keep2 = isl_space_dim(space, isl_dim_out);
10163 map = isl_map_project_out(map, isl_dim_in, keep1, total1 - keep1);
10164 map = isl_map_project_out(map, isl_dim_out, keep2, total2 - keep2);
10165 map = isl_map_reset_space(map, space);
10166
10167 return map;
10168}
10169
10170/* Given a map of the form [A -> B] -> [C -> D], return the map B -> D.
10171 */
10172__isl_give isl_map *isl_map_factor_range(__isl_take isl_map *map)
10173{
10174 isl_space *space;
10175 int total1, keep1, total2, keep2;
10176
10177 if (!map)
10178 return NULL((void*)0);
10179 if (!isl_space_domain_is_wrapping(map->dim) ||
10180 !isl_space_range_is_wrapping(map->dim))
10181 isl_die(isl_map_get_ctx(map), isl_error_invalid,do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "not a product", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 10182); return isl_map_free(map); } while (0)
10182 "not a product", return isl_map_free(map))do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "not a product", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 10182); return isl_map_free(map); } while (0)
;
10183
10184 space = isl_map_get_space(map);
10185 total1 = isl_space_dim(space, isl_dim_in);
10186 total2 = isl_space_dim(space, isl_dim_out);
10187 space = isl_space_factor_range(space);
10188 keep1 = isl_space_dim(space, isl_dim_in);
10189 keep2 = isl_space_dim(space, isl_dim_out);
10190 map = isl_map_project_out(map, isl_dim_in, 0, total1 - keep1);
10191 map = isl_map_project_out(map, isl_dim_out, 0, total2 - keep2);
10192 map = isl_map_reset_space(map, space);
10193
10194 return map;
10195}
10196
10197/* Given a map of the form [A -> B] -> C, return the map A -> C.
10198 */
10199__isl_give isl_map *isl_map_domain_factor_domain(__isl_take isl_map *map)
10200{
10201 isl_space *space;
10202 int total, keep;
10203
10204 if (!map)
10205 return NULL((void*)0);
10206 if (!isl_space_domain_is_wrapping(map->dim))
10207 isl_die(isl_map_get_ctx(map), isl_error_invalid,do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "domain is not a product", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 10208); return isl_map_free(map); } while (0)
10208 "domain is not a product", return isl_map_free(map))do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "domain is not a product", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 10208); return isl_map_free(map); } while (0)
;
10209
10210 space = isl_map_get_space(map);
10211 total = isl_space_dim(space, isl_dim_in);
10212 space = isl_space_domain_factor_domain(space);
10213 keep = isl_space_dim(space, isl_dim_in);
10214 map = isl_map_project_out(map, isl_dim_in, keep, total - keep);
10215 map = isl_map_reset_space(map, space);
10216
10217 return map;
10218}
10219
10220/* Given a map of the form [A -> B] -> C, return the map B -> C.
10221 */
10222__isl_give isl_map *isl_map_domain_factor_range(__isl_take isl_map *map)
10223{
10224 isl_space *space;
10225 int total, keep;
10226
10227 if (!map)
10228 return NULL((void*)0);
10229 if (!isl_space_domain_is_wrapping(map->dim))
10230 isl_die(isl_map_get_ctx(map), isl_error_invalid,do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "domain is not a product", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 10231); return isl_map_free(map); } while (0)
10231 "domain is not a product", return isl_map_free(map))do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "domain is not a product", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 10231); return isl_map_free(map); } while (0)
;
10232
10233 space = isl_map_get_space(map);
10234 total = isl_space_dim(space, isl_dim_in);
10235 space = isl_space_domain_factor_range(space);
10236 keep = isl_space_dim(space, isl_dim_in);
10237 map = isl_map_project_out(map, isl_dim_in, 0, total - keep);
10238 map = isl_map_reset_space(map, space);
10239
10240 return map;
10241}
10242
10243/* Given a map A -> [B -> C], extract the map A -> B.
10244 */
10245__isl_give isl_map *isl_map_range_factor_domain(__isl_take isl_map *map)
10246{
10247 isl_space *space;
10248 int total, keep;
10249
10250 if (!map)
10251 return NULL((void*)0);
10252 if (!isl_space_range_is_wrapping(map->dim))
10253 isl_die(isl_map_get_ctx(map), isl_error_invalid,do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "range is not a product", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 10254); return isl_map_free(map); } while (0)
10254 "range is not a product", return isl_map_free(map))do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "range is not a product", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 10254); return isl_map_free(map); } while (0)
;
10255
10256 space = isl_map_get_space(map);
10257 total = isl_space_dim(space, isl_dim_out);
10258 space = isl_space_range_factor_domain(space);
10259 keep = isl_space_dim(space, isl_dim_out);
10260 map = isl_map_project_out(map, isl_dim_out, keep, total - keep);
10261 map = isl_map_reset_space(map, space);
10262
10263 return map;
10264}
10265
10266/* Given a map A -> [B -> C], extract the map A -> C.
10267 */
10268__isl_give isl_map *isl_map_range_factor_range(__isl_take isl_map *map)
10269{
10270 isl_space *space;
10271 int total, keep;
10272
10273 if (!map)
10274 return NULL((void*)0);
10275 if (!isl_space_range_is_wrapping(map->dim))
10276 isl_die(isl_map_get_ctx(map), isl_error_invalid,do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "range is not a product", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 10277); return isl_map_free(map); } while (0)
10277 "range is not a product", return isl_map_free(map))do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "range is not a product", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 10277); return isl_map_free(map); } while (0)
;
10278
10279 space = isl_map_get_space(map);
10280 total = isl_space_dim(space, isl_dim_out);
10281 space = isl_space_range_factor_range(space);
10282 keep = isl_space_dim(space, isl_dim_out);
10283 map = isl_map_project_out(map, isl_dim_out, 0, total - keep);
10284 map = isl_map_reset_space(map, space);
10285
10286 return map;
10287}
10288
10289/* Given two maps A -> B and C -> D, construct a map (A, C) -> (B * D)
10290 */
10291__isl_give isl_map *isl_map_flat_domain_product(__isl_take isl_map *map1,
10292 __isl_take isl_map *map2)
10293{
10294 isl_map *prod;
10295
10296 prod = isl_map_domain_product(map1, map2);
10297 prod = isl_map_flatten_domain(prod);
10298 return prod;
10299}
10300
10301/* Given two maps A -> B and C -> D, construct a map (A * C) -> (B, D)
10302 */
10303__isl_give isl_map *isl_map_flat_range_product(__isl_take isl_map *map1,
10304 __isl_take isl_map *map2)
10305{
10306 isl_map *prod;
10307
10308 prod = isl_map_range_product(map1, map2);
10309 prod = isl_map_flatten_range(prod);
10310 return prod;
10311}
10312
10313uint32_t isl_basic_map_get_hash(__isl_keep isl_basic_map *bmap)
10314{
10315 int i;
10316 uint32_t hash = isl_hash_init()(2166136261u);
10317 unsigned total;
10318
10319 if (!bmap)
10320 return 0;
10321 bmap = isl_basic_map_copy(bmap);
10322 bmap = isl_basic_map_normalize(bmap);
10323 if (!bmap)
10324 return 0;
10325 total = isl_basic_map_total_dim(bmap);
10326 isl_hash_byte(hash, bmap->n_eq & 0xFF)do { hash *= 16777619; hash ^= bmap->n_eq & 0xFF; } while
(0)
;
10327 for (i = 0; i < bmap->n_eq; ++i) {
10328 uint32_t c_hash;
10329 c_hash = isl_seq_get_hash(bmap->eq[i], 1 + total);
10330 isl_hash_hash(hash, c_hash)do { do { hash *= 16777619; hash ^= (c_hash) & 0xFF; } while
(0); do { hash *= 16777619; hash ^= ((c_hash) >> 8) &
0xFF; } while(0); do { hash *= 16777619; hash ^= ((c_hash) >>
16) & 0xFF; } while(0); do { hash *= 16777619; hash ^= (
(c_hash) >> 24) & 0xFF; } while(0); } while(0)
;
10331 }
10332 isl_hash_byte(hash, bmap->n_ineq & 0xFF)do { hash *= 16777619; hash ^= bmap->n_ineq & 0xFF; } while
(0)
;
10333 for (i = 0; i < bmap->n_ineq; ++i) {
10334 uint32_t c_hash;
10335 c_hash = isl_seq_get_hash(bmap->ineq[i], 1 + total);
10336 isl_hash_hash(hash, c_hash)do { do { hash *= 16777619; hash ^= (c_hash) & 0xFF; } while
(0); do { hash *= 16777619; hash ^= ((c_hash) >> 8) &
0xFF; } while(0); do { hash *= 16777619; hash ^= ((c_hash) >>
16) & 0xFF; } while(0); do { hash *= 16777619; hash ^= (
(c_hash) >> 24) & 0xFF; } while(0); } while(0)
;
10337 }
10338 isl_hash_byte(hash, bmap->n_div & 0xFF)do { hash *= 16777619; hash ^= bmap->n_div & 0xFF; } while
(0)
;
10339 for (i = 0; i < bmap->n_div; ++i) {
10340 uint32_t c_hash;
10341 if (isl_int_is_zero(bmap->div[i][0])(isl_sioimath_sgn(*(bmap->div[i][0])) == 0))
10342 continue;
10343 isl_hash_byte(hash, i & 0xFF)do { hash *= 16777619; hash ^= i & 0xFF; } while(0);
10344 c_hash = isl_seq_get_hash(bmap->div[i], 1 + 1 + total);
10345 isl_hash_hash(hash, c_hash)do { do { hash *= 16777619; hash ^= (c_hash) & 0xFF; } while
(0); do { hash *= 16777619; hash ^= ((c_hash) >> 8) &
0xFF; } while(0); do { hash *= 16777619; hash ^= ((c_hash) >>
16) & 0xFF; } while(0); do { hash *= 16777619; hash ^= (
(c_hash) >> 24) & 0xFF; } while(0); } while(0)
;
10346 }
10347 isl_basic_map_free(bmap);
10348 return hash;
10349}
10350
10351uint32_t isl_basic_set_get_hash(__isl_keep isl_basic_setisl_basic_map *bset)
10352{
10353 return isl_basic_map_get_hash(bset_to_bmap(bset));
10354}
10355
10356uint32_t isl_map_get_hash(__isl_keep isl_map *map)
10357{
10358 int i;
10359 uint32_t hash;
10360
10361 if (!map)
10362 return 0;
10363 map = isl_map_copy(map);
10364 map = isl_map_normalize(map);
10365 if (!map)
10366 return 0;
10367
10368 hash = isl_hash_init()(2166136261u);
10369 for (i = 0; i < map->n; ++i) {
10370 uint32_t bmap_hash;
10371 bmap_hash = isl_basic_map_get_hash(map->p[i]);
10372 isl_hash_hash(hash, bmap_hash)do { do { hash *= 16777619; hash ^= (bmap_hash) & 0xFF; }
while(0); do { hash *= 16777619; hash ^= ((bmap_hash) >>
8) & 0xFF; } while(0); do { hash *= 16777619; hash ^= ((
bmap_hash) >> 16) & 0xFF; } while(0); do { hash *= 16777619
; hash ^= ((bmap_hash) >> 24) & 0xFF; } while(0); }
while(0)
;
10373 }
10374
10375 isl_map_free(map);
10376
10377 return hash;
10378}
10379
10380uint32_t isl_set_get_hash(__isl_keep isl_setisl_map *set)
10381{
10382 return isl_map_get_hash(set_to_map(set));
10383}
10384
10385/* Return the number of basic maps in the (current) representation of "map".
10386 */
10387int isl_map_n_basic_map(__isl_keep isl_map *map)
10388{
10389 return map ? map->n : 0;
10390}
10391
10392int isl_set_n_basic_set(__isl_keep isl_setisl_map *set)
10393{
10394 return set ? set->n : 0;
10395}
10396
10397isl_stat isl_map_foreach_basic_map(__isl_keep isl_map *map,
10398 isl_stat (*fn)(__isl_take isl_basic_map *bmap, void *user), void *user)
10399{
10400 int i;
10401
10402 if (!map)
10403 return isl_stat_error;
10404
10405 for (i = 0; i < map->n; ++i)
10406 if (fn(isl_basic_map_copy(map->p[i]), user) < 0)
10407 return isl_stat_error;
10408
10409 return isl_stat_ok;
10410}
10411
10412isl_stat isl_set_foreach_basic_set(__isl_keep isl_setisl_map *set,
10413 isl_stat (*fn)(__isl_take isl_basic_setisl_basic_map *bset, void *user), void *user)
10414{
10415 int i;
10416
10417 if (!set)
10418 return isl_stat_error;
10419
10420 for (i = 0; i < set->n; ++i)
10421 if (fn(isl_basic_set_copy(set->p[i]), user) < 0)
10422 return isl_stat_error;
10423
10424 return isl_stat_ok;
10425}
10426
10427/* Return a list of basic sets, the union of which is equal to "set".
10428 */
10429__isl_give isl_basic_set_listisl_basic_map_list *isl_set_get_basic_set_list(
10430 __isl_keep isl_setisl_map *set)
10431{
10432 int i;
10433 isl_basic_set_listisl_basic_map_list *list;
10434
10435 if (!set)
10436 return NULL((void*)0);
10437
10438 list = isl_basic_set_list_alloc(isl_set_get_ctx(set), set->n);
10439 for (i = 0; i < set->n; ++i) {
10440 isl_basic_setisl_basic_map *bset;
10441
10442 bset = isl_basic_set_copy(set->p[i]);
10443 list = isl_basic_set_list_add(list, bset);
10444 }
10445
10446 return list;
10447}
10448
10449__isl_give isl_basic_setisl_basic_map *isl_basic_set_lift(__isl_take isl_basic_setisl_basic_map *bset)
10450{
10451 isl_space *dim;
10452
10453 if (!bset)
10454 return NULL((void*)0);
10455
10456 bset = isl_basic_set_cow(bset);
10457 if (!bset)
10458 return NULL((void*)0);
10459
10460 dim = isl_basic_set_get_space(bset);
10461 dim = isl_space_lift(dim, bset->n_div);
10462 if (!dim)
10463 goto error;
10464 isl_space_free(bset->dim);
10465 bset->dim = dim;
10466 bset->extra -= bset->n_div;
10467 bset->n_div = 0;
10468
10469 bset = isl_basic_set_finalize(bset);
10470
10471 return bset;
10472error:
10473 isl_basic_set_free(bset);
10474 return NULL((void*)0);
10475}
10476
10477__isl_give isl_setisl_map *isl_set_lift(__isl_take isl_setisl_map *set)
10478{
10479 int i;
10480 isl_space *dim;
10481 unsigned n_div;
10482
10483 set = set_from_map(isl_map_align_divs_internal(set_to_map(set)));
10484
10485 if (!set)
10486 return NULL((void*)0);
10487
10488 set = isl_set_cow(set);
10489 if (!set)
10490 return NULL((void*)0);
10491
10492 n_div = set->p[0]->n_div;
10493 dim = isl_set_get_space(set);
10494 dim = isl_space_lift(dim, n_div);
10495 if (!dim)
10496 goto error;
10497 isl_space_free(set->dim);
10498 set->dim = dim;
10499
10500 for (i = 0; i < set->n; ++i) {
10501 set->p[i] = isl_basic_set_lift(set->p[i]);
10502 if (!set->p[i])
10503 goto error;
10504 }
10505
10506 return set;
10507error:
10508 isl_set_free(set);
10509 return NULL((void*)0);
10510}
10511
10512int isl_basic_set_size(__isl_keep isl_basic_setisl_basic_map *bset)
10513{
10514 unsigned dim;
10515 int size = 0;
10516
10517 if (!bset)
10518 return -1;
10519
10520 dim = isl_basic_set_total_dim(bset);
10521 size += bset->n_eq * (1 + dim);
10522 size += bset->n_ineq * (1 + dim);
10523 size += bset->n_div * (2 + dim);
10524
10525 return size;
10526}
10527
10528int isl_set_size(__isl_keep isl_setisl_map *set)
10529{
10530 int i;
10531 int size = 0;
10532
10533 if (!set)
10534 return -1;
10535
10536 for (i = 0; i < set->n; ++i)
10537 size += isl_basic_set_size(set->p[i]);
10538
10539 return size;
10540}
10541
10542/* Check if there is any lower bound (if lower == 0) and/or upper
10543 * bound (if upper == 0) on the specified dim.
10544 */
10545static isl_bool basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap,
10546 enum isl_dim_type type, unsigned pos, int lower, int upper)
10547{
10548 int i;
10549
10550 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
10551 return isl_bool_error;
10552
10553 pos += isl_basic_map_offset(bmap, type);
10554
10555 for (i = 0; i < bmap->n_div; ++i) {
10556 if (isl_int_is_zero(bmap->div[i][0])(isl_sioimath_sgn(*(bmap->div[i][0])) == 0))
10557 continue;
10558 if (!isl_int_is_zero(bmap->div[i][1 + pos])(isl_sioimath_sgn(*(bmap->div[i][1 + pos])) == 0))
10559 return isl_bool_true;
10560 }
10561
10562 for (i = 0; i < bmap->n_eq; ++i)
10563 if (!isl_int_is_zero(bmap->eq[i][pos])(isl_sioimath_sgn(*(bmap->eq[i][pos])) == 0))
10564 return isl_bool_true;
10565
10566 for (i = 0; i < bmap->n_ineq; ++i) {
10567 int sgn = isl_int_sgn(bmap->ineq[i][pos])isl_sioimath_sgn(*(bmap->ineq[i][pos]));
10568 if (sgn > 0)
10569 lower = 1;
10570 if (sgn < 0)
10571 upper = 1;
10572 }
10573
10574 return lower && upper;
10575}
10576
10577isl_bool isl_basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap,
10578 enum isl_dim_type type, unsigned pos)
10579{
10580 return basic_map_dim_is_bounded(bmap, type, pos, 0, 0);
10581}
10582
10583isl_bool isl_basic_map_dim_has_lower_bound(__isl_keep isl_basic_map *bmap,
10584 enum isl_dim_type type, unsigned pos)
10585{
10586 return basic_map_dim_is_bounded(bmap, type, pos, 0, 1);
10587}
10588
10589isl_bool isl_basic_map_dim_has_upper_bound(__isl_keep isl_basic_map *bmap,
10590 enum isl_dim_type type, unsigned pos)
10591{
10592 return basic_map_dim_is_bounded(bmap, type, pos, 1, 0);
10593}
10594
10595isl_bool isl_map_dim_is_bounded(__isl_keep isl_map *map,
10596 enum isl_dim_type type, unsigned pos)
10597{
10598 int i;
10599
10600 if (!map)
10601 return isl_bool_error;
10602
10603 for (i = 0; i < map->n; ++i) {
10604 isl_bool bounded;
10605 bounded = isl_basic_map_dim_is_bounded(map->p[i], type, pos);
10606 if (bounded < 0 || !bounded)
10607 return bounded;
10608 }
10609
10610 return isl_bool_true;
10611}
10612
10613/* Return true if the specified dim is involved in both an upper bound
10614 * and a lower bound.
10615 */
10616isl_bool isl_set_dim_is_bounded(__isl_keep isl_setisl_map *set,
10617 enum isl_dim_type type, unsigned pos)
10618{
10619 return isl_map_dim_is_bounded(set_to_map(set), type, pos);
10620}
10621
10622/* Does "map" have a bound (according to "fn") for any of its basic maps?
10623 */
10624static isl_bool has_any_bound(__isl_keep isl_map *map,
10625 enum isl_dim_type type, unsigned pos,
10626 isl_bool (*fn)(__isl_keep isl_basic_map *bmap,
10627 enum isl_dim_type type, unsigned pos))
10628{
10629 int i;
10630
10631 if (!map)
10632 return isl_bool_error;
10633
10634 for (i = 0; i < map->n; ++i) {
10635 isl_bool bounded;
10636 bounded = fn(map->p[i], type, pos);
10637 if (bounded < 0 || bounded)
10638 return bounded;
10639 }
10640
10641 return isl_bool_false;
10642}
10643
10644/* Return 1 if the specified dim is involved in any lower bound.
10645 */
10646isl_bool isl_set_dim_has_any_lower_bound(__isl_keep isl_setisl_map *set,
10647 enum isl_dim_type type, unsigned pos)
10648{
10649 return has_any_bound(set, type, pos,
10650 &isl_basic_map_dim_has_lower_bound);
10651}
10652
10653/* Return 1 if the specified dim is involved in any upper bound.
10654 */
10655isl_bool isl_set_dim_has_any_upper_bound(__isl_keep isl_setisl_map *set,
10656 enum isl_dim_type type, unsigned pos)
10657{
10658 return has_any_bound(set, type, pos,
10659 &isl_basic_map_dim_has_upper_bound);
10660}
10661
10662/* Does "map" have a bound (according to "fn") for all of its basic maps?
10663 */
10664static isl_bool has_bound(__isl_keep isl_map *map,
10665 enum isl_dim_type type, unsigned pos,
10666 isl_bool (*fn)(__isl_keep isl_basic_map *bmap,
10667 enum isl_dim_type type, unsigned pos))
10668{
10669 int i;
10670
10671 if (!map)
10672 return isl_bool_error;
10673
10674 for (i = 0; i < map->n; ++i) {
10675 isl_bool bounded;
10676 bounded = fn(map->p[i], type, pos);
10677 if (bounded < 0 || !bounded)
10678 return bounded;
10679 }
10680
10681 return isl_bool_true;
10682}
10683
10684/* Return 1 if the specified dim has a lower bound (in each of its basic sets).
10685 */
10686isl_bool isl_set_dim_has_lower_bound(__isl_keep isl_setisl_map *set,
10687 enum isl_dim_type type, unsigned pos)
10688{
10689 return has_bound(set, type, pos, &isl_basic_map_dim_has_lower_bound);
10690}
10691
10692/* Return 1 if the specified dim has an upper bound (in each of its basic sets).
10693 */
10694isl_bool isl_set_dim_has_upper_bound(__isl_keep isl_setisl_map *set,
10695 enum isl_dim_type type, unsigned pos)
10696{
10697 return has_bound(set, type, pos, &isl_basic_map_dim_has_upper_bound);
10698}
10699
10700/* For each of the "n" variables starting at "first", determine
10701 * the sign of the variable and put the results in the first "n"
10702 * elements of the array "signs".
10703 * Sign
10704 * 1 means that the variable is non-negative
10705 * -1 means that the variable is non-positive
10706 * 0 means the variable attains both positive and negative values.
10707 */
10708isl_stat isl_basic_set_vars_get_sign(__isl_keep isl_basic_setisl_basic_map *bset,
10709 unsigned first, unsigned n, int *signs)
10710{
10711 isl_vec *bound = NULL((void*)0);
10712 struct isl_tab *tab = NULL((void*)0);
10713 struct isl_tab_undo *snap;
10714 int i;
10715
10716 if (!bset || !signs)
10717 return isl_stat_error;
10718
10719 bound = isl_vec_alloc(bset->ctx, 1 + isl_basic_set_total_dim(bset));
10720 tab = isl_tab_from_basic_set(bset, 0);
10721 if (!bound || !tab)
10722 goto error;
10723
10724 isl_seq_clr(bound->el, bound->size);
10725 isl_int_set_si(bound->el[0], -1)isl_sioimath_set_si((bound->el[0]), -1);
10726
10727 snap = isl_tab_snap(tab);
10728 for (i = 0; i < n; ++i) {
10729 int empty;
10730
10731 isl_int_set_si(bound->el[1 + first + i], -1)isl_sioimath_set_si((bound->el[1 + first + i]), -1);
10732 if (isl_tab_add_ineq(tab, bound->el) < 0)
10733 goto error;
10734 empty = tab->empty;
10735 isl_int_set_si(bound->el[1 + first + i], 0)isl_sioimath_set_si((bound->el[1 + first + i]), 0);
10736 if (isl_tab_rollback(tab, snap) < 0)
10737 goto error;
10738
10739 if (empty) {
10740 signs[i] = 1;
10741 continue;
10742 }
10743
10744 isl_int_set_si(bound->el[1 + first + i], 1)isl_sioimath_set_si((bound->el[1 + first + i]), 1);
10745 if (isl_tab_add_ineq(tab, bound->el) < 0)
10746 goto error;
10747 empty = tab->empty;
10748 isl_int_set_si(bound->el[1 + first + i], 0)isl_sioimath_set_si((bound->el[1 + first + i]), 0);
10749 if (isl_tab_rollback(tab, snap) < 0)
10750 goto error;
10751
10752 signs[i] = empty ? -1 : 0;
10753 }
10754
10755 isl_tab_free(tab);
10756 isl_vec_free(bound);
10757 return isl_stat_ok;
10758error:
10759 isl_tab_free(tab);
10760 isl_vec_free(bound);
10761 return isl_stat_error;
10762}
10763
10764isl_stat isl_basic_set_dims_get_sign(__isl_keep isl_basic_setisl_basic_map *bset,
10765 enum isl_dim_type type, unsigned first, unsigned n, int *signs)
10766{
10767 if (!bset || !signs)
10768 return isl_stat_error;
10769 isl_assert(bset->ctx, first + n <= isl_basic_set_dim(bset, type),do { if (first + n <= isl_basic_set_dim(bset, type)) break
; do { isl_handle_error(bset->ctx, isl_error_unknown, "Assertion \""
"first + n <= isl_basic_set_dim(bset, type)" "\" failed",
"/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 10770); return isl_stat_error; } while (0); } while (0)
10770 return isl_stat_error)do { if (first + n <= isl_basic_set_dim(bset, type)) break
; do { isl_handle_error(bset->ctx, isl_error_unknown, "Assertion \""
"first + n <= isl_basic_set_dim(bset, type)" "\" failed",
"/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 10770); return isl_stat_error; } while (0); } while (0)
;
10771
10772 first += pos(bset->dim, type) - 1;
10773 return isl_basic_set_vars_get_sign(bset, first, n, signs);
10774}
10775
10776/* Is it possible for the integer division "div" to depend (possibly
10777 * indirectly) on any output dimensions?
10778 *
10779 * If the div is undefined, then we conservatively assume that it
10780 * may depend on them.
10781 * Otherwise, we check if it actually depends on them or on any integer
10782 * divisions that may depend on them.
10783 */
10784static isl_bool div_may_involve_output(__isl_keep isl_basic_map *bmap, int div)
10785{
10786 int i;
10787 unsigned n_out, o_out;
10788 unsigned n_div, o_div;
10789
10790 if (isl_int_is_zero(bmap->div[div][0])(isl_sioimath_sgn(*(bmap->div[div][0])) == 0))
10791 return isl_bool_true;
10792
10793 n_out = isl_basic_map_dim(bmap, isl_dim_out);
10794 o_out = isl_basic_map_offset(bmap, isl_dim_out);
10795
10796 if (isl_seq_first_non_zero(bmap->div[div] + 1 + o_out, n_out) != -1)
10797 return isl_bool_true;
10798
10799 n_div = isl_basic_map_dim(bmap, isl_dim_div);
10800 o_div = isl_basic_map_offset(bmap, isl_dim_div);
10801
10802 for (i = 0; i < n_div; ++i) {
10803 isl_bool may_involve;
10804
10805 if (isl_int_is_zero(bmap->div[div][1 + o_div + i])(isl_sioimath_sgn(*(bmap->div[div][1 + o_div + i])) == 0))
10806 continue;
10807 may_involve = div_may_involve_output(bmap, i);
10808 if (may_involve < 0 || may_involve)
10809 return may_involve;
10810 }
10811
10812 return isl_bool_false;
10813}
10814
10815/* Return the first integer division of "bmap" in the range
10816 * [first, first + n[ that may depend on any output dimensions and
10817 * that has a non-zero coefficient in "c" (where the first coefficient
10818 * in "c" corresponds to integer division "first").
10819 */
10820static int first_div_may_involve_output(__isl_keep isl_basic_map *bmap,
10821 isl_int *c, int first, int n)
10822{
10823 int k;
10824
10825 if (!bmap)
10826 return -1;
10827
10828 for (k = first; k < first + n; ++k) {
10829 isl_bool may_involve;
10830
10831 if (isl_int_is_zero(c[k])(isl_sioimath_sgn(*(c[k])) == 0))
10832 continue;
10833 may_involve = div_may_involve_output(bmap, k);
10834 if (may_involve < 0)
10835 return -1;
10836 if (may_involve)
10837 return k;
10838 }
10839
10840 return first + n;
10841}
10842
10843/* Look for a pair of inequality constraints in "bmap" of the form
10844 *
10845 * -l + i >= 0 or i >= l
10846 * and
10847 * n + l - i >= 0 or i <= l + n
10848 *
10849 * with n < "m" and i the output dimension at position "pos".
10850 * (Note that n >= 0 as otherwise the two constraints would conflict.)
10851 * Furthermore, "l" is only allowed to involve parameters, input dimensions
10852 * and earlier output dimensions, as well as integer divisions that do
10853 * not involve any of the output dimensions.
10854 *
10855 * Return the index of the first inequality constraint or bmap->n_ineq
10856 * if no such pair can be found.
10857 */
10858static int find_modulo_constraint_pair(__isl_keep isl_basic_map *bmap,
10859 int pos, isl_int m)
10860{
10861 int i, j;
10862 isl_ctx *ctx;
10863 unsigned total;
10864 unsigned n_div, o_div;
10865 unsigned n_out, o_out;
10866 int less;
10867
10868 if (!bmap)
10869 return -1;
10870
10871 ctx = isl_basic_map_get_ctx(bmap);
10872 total = isl_basic_map_total_dim(bmap);
10873 n_out = isl_basic_map_dim(bmap, isl_dim_out);
10874 o_out = isl_basic_map_offset(bmap, isl_dim_out);
10875 n_div = isl_basic_map_dim(bmap, isl_dim_div);
10876 o_div = isl_basic_map_offset(bmap, isl_dim_div);
10877 for (i = 0; i < bmap->n_ineq; ++i) {
10878 if (!isl_int_abs_eq(bmap->ineq[i][o_out + pos], ctx->one)(isl_sioimath_abs_cmp(*(bmap->ineq[i][o_out + pos]), *(ctx
->one)) == 0)
)
10879 continue;
10880 if (isl_seq_first_non_zero(bmap->ineq[i] + o_out + pos + 1,
10881 n_out - (pos + 1)) != -1)
10882 continue;
10883 if (first_div_may_involve_output(bmap, bmap->ineq[i] + o_div,
10884 0, n_div) < n_div)
10885 continue;
10886 for (j = i + 1; j < bmap->n_ineq; ++j) {
10887 if (!isl_int_abs_eq(bmap->ineq[j][o_out + pos],(isl_sioimath_abs_cmp(*(bmap->ineq[j][o_out + pos]), *(ctx
->one)) == 0)
10888 ctx->one)(isl_sioimath_abs_cmp(*(bmap->ineq[j][o_out + pos]), *(ctx
->one)) == 0)
)
10889 continue;
10890 if (!isl_seq_is_neg(bmap->ineq[i] + 1,
10891 bmap->ineq[j] + 1, total))
10892 continue;
10893 break;
10894 }
10895 if (j >= bmap->n_ineq)
10896 continue;
10897 isl_int_add(bmap->ineq[i][0],isl_sioimath_add((bmap->ineq[i][0]), *(bmap->ineq[i][0]
), *(bmap->ineq[j][0]))
10898 bmap->ineq[i][0], bmap->ineq[j][0])isl_sioimath_add((bmap->ineq[i][0]), *(bmap->ineq[i][0]
), *(bmap->ineq[j][0]))
;
10899 less = isl_int_abs_lt(bmap->ineq[i][0], m)(isl_sioimath_abs_cmp(*(bmap->ineq[i][0]), *(m)) < 0);
10900 isl_int_sub(bmap->ineq[i][0],isl_sioimath_sub((bmap->ineq[i][0]), *(bmap->ineq[i][0]
), *(bmap->ineq[j][0]))
10901 bmap->ineq[i][0], bmap->ineq[j][0])isl_sioimath_sub((bmap->ineq[i][0]), *(bmap->ineq[i][0]
), *(bmap->ineq[j][0]))
;
10902 if (!less)
10903 continue;
10904 if (isl_int_is_one(bmap->ineq[i][o_out + pos])(isl_sioimath_cmp_si(*(bmap->ineq[i][o_out + pos]), 1) == 0
)
)
10905 return i;
10906 else
10907 return j;
10908 }
10909
10910 return bmap->n_ineq;
10911}
10912
10913/* Return the index of the equality of "bmap" that defines
10914 * the output dimension "pos" in terms of earlier dimensions.
10915 * The equality may also involve integer divisions, as long
10916 * as those integer divisions are defined in terms of
10917 * parameters or input dimensions.
10918 * In this case, *div is set to the number of integer divisions and
10919 * *ineq is set to the number of inequality constraints (provided
10920 * div and ineq are not NULL).
10921 *
10922 * The equality may also involve a single integer division involving
10923 * the output dimensions (typically only output dimension "pos") as
10924 * long as the coefficient of output dimension "pos" is 1 or -1 and
10925 * there is a pair of constraints i >= l and i <= l + n, with i referring
10926 * to output dimension "pos", l an expression involving only earlier
10927 * dimensions and n smaller than the coefficient of the integer division
10928 * in the equality. In this case, the output dimension can be defined
10929 * in terms of a modulo expression that does not involve the integer division.
10930 * *div is then set to this single integer division and
10931 * *ineq is set to the index of constraint i >= l.
10932 *
10933 * Return bmap->n_eq if there is no such equality.
10934 * Return -1 on error.
10935 */
10936int isl_basic_map_output_defining_equality(__isl_keep isl_basic_map *bmap,
10937 int pos, int *div, int *ineq)
10938{
10939 int j, k, l;
10940 unsigned n_out, o_out;
10941 unsigned n_div, o_div;
10942
10943 if (!bmap)
10944 return -1;
10945
10946 n_out = isl_basic_map_dim(bmap, isl_dim_out);
10947 o_out = isl_basic_map_offset(bmap, isl_dim_out);
10948 n_div = isl_basic_map_dim(bmap, isl_dim_div);
10949 o_div = isl_basic_map_offset(bmap, isl_dim_div);
10950
10951 if (ineq)
10952 *ineq = bmap->n_ineq;
10953 if (div)
10954 *div = n_div;
10955 for (j = 0; j < bmap->n_eq; ++j) {
10956 if (isl_int_is_zero(bmap->eq[j][o_out + pos])(isl_sioimath_sgn(*(bmap->eq[j][o_out + pos])) == 0))
10957 continue;
10958 if (isl_seq_first_non_zero(bmap->eq[j] + o_out + pos + 1,
10959 n_out - (pos + 1)) != -1)
10960 continue;
10961 k = first_div_may_involve_output(bmap, bmap->eq[j] + o_div,
10962 0, n_div);
10963 if (k >= n_div)
10964 return j;
10965 if (!isl_int_is_one(bmap->eq[j][o_out + pos])(isl_sioimath_cmp_si(*(bmap->eq[j][o_out + pos]), 1) == 0) &&
10966 !isl_int_is_negone(bmap->eq[j][o_out + pos])(isl_sioimath_cmp_si(*(bmap->eq[j][o_out + pos]), -1) == 0
)
)
10967 continue;
10968 if (first_div_may_involve_output(bmap, bmap->eq[j] + o_div,
10969 k + 1, n_div - (k+1)) < n_div)
10970 continue;
10971 l = find_modulo_constraint_pair(bmap, pos,
10972 bmap->eq[j][o_div + k]);
10973 if (l < 0)
10974 return -1;
10975 if (l >= bmap->n_ineq)
10976 continue;
10977 if (div)
10978 *div = k;
10979 if (ineq)
10980 *ineq = l;
10981 return j;
10982 }
10983
10984 return bmap->n_eq;
10985}
10986
10987/* Check if the given basic map is obviously single-valued.
10988 * In particular, for each output dimension, check that there is
10989 * an equality that defines the output dimension in terms of
10990 * earlier dimensions.
10991 */
10992isl_bool isl_basic_map_plain_is_single_valued(__isl_keep isl_basic_map *bmap)
10993{
10994 int i;
10995 unsigned n_out;
10996
10997 if (!bmap)
10998 return isl_bool_error;
10999
11000 n_out = isl_basic_map_dim(bmap, isl_dim_out);
11001
11002 for (i = 0; i < n_out; ++i) {
11003 int eq;
11004
11005 eq = isl_basic_map_output_defining_equality(bmap, i,
11006 NULL((void*)0), NULL((void*)0));
11007 if (eq < 0)
11008 return isl_bool_error;
11009 if (eq >= bmap->n_eq)
11010 return isl_bool_false;
11011 }
11012
11013 return isl_bool_true;
11014}
11015
11016/* Check if the given basic map is single-valued.
11017 * We simply compute
11018 *
11019 * M \circ M^-1
11020 *
11021 * and check if the result is a subset of the identity mapping.
11022 */
11023isl_bool isl_basic_map_is_single_valued(__isl_keep isl_basic_map *bmap)
11024{
11025 isl_space *space;
11026 isl_basic_map *test;
11027 isl_basic_map *id;
11028 isl_bool sv;
11029
11030 sv = isl_basic_map_plain_is_single_valued(bmap);
11031 if (sv < 0 || sv)
11032 return sv;
11033
11034 test = isl_basic_map_reverse(isl_basic_map_copy(bmap));
11035 test = isl_basic_map_apply_range(test, isl_basic_map_copy(bmap));
11036
11037 space = isl_basic_map_get_space(bmap);
11038 space = isl_space_map_from_set(isl_space_range(space));
11039 id = isl_basic_map_identity(space);
11040
11041 sv = isl_basic_map_is_subset(test, id);
11042
11043 isl_basic_map_free(test);
11044 isl_basic_map_free(id);
11045
11046 return sv;
11047}
11048
11049/* Check if the given map is obviously single-valued.
11050 */
11051isl_bool isl_map_plain_is_single_valued(__isl_keep isl_map *map)
11052{
11053 if (!map)
11054 return isl_bool_error;
11055 if (map->n == 0)
11056 return isl_bool_true;
11057 if (map->n >= 2)
11058 return isl_bool_false;
11059
11060 return isl_basic_map_plain_is_single_valued(map->p[0]);
11061}
11062
11063/* Check if the given map is single-valued.
11064 * We simply compute
11065 *
11066 * M \circ M^-1
11067 *
11068 * and check if the result is a subset of the identity mapping.
11069 */
11070isl_bool isl_map_is_single_valued(__isl_keep isl_map *map)
11071{
11072 isl_space *dim;
11073 isl_map *test;
11074 isl_map *id;
11075 isl_bool sv;
11076
11077 sv = isl_map_plain_is_single_valued(map);
11078 if (sv < 0 || sv)
11079 return sv;
11080
11081 test = isl_map_reverse(isl_map_copy(map));
11082 test = isl_map_apply_range(test, isl_map_copy(map));
11083
11084 dim = isl_space_map_from_set(isl_space_range(isl_map_get_space(map)));
11085 id = isl_map_identity(dim);
11086
11087 sv = isl_map_is_subset(test, id);
11088
11089 isl_map_free(test);
11090 isl_map_free(id);
11091
11092 return sv;
11093}
11094
11095isl_bool isl_map_is_injective(__isl_keep isl_map *map)
11096{
11097 isl_bool in;
11098
11099 map = isl_map_copy(map);
11100 map = isl_map_reverse(map);
11101 in = isl_map_is_single_valued(map);
11102 isl_map_free(map);
11103
11104 return in;
11105}
11106
11107/* Check if the given map is obviously injective.
11108 */
11109isl_bool isl_map_plain_is_injective(__isl_keep isl_map *map)
11110{
11111 isl_bool in;
11112
11113 map = isl_map_copy(map);
11114 map = isl_map_reverse(map);
11115 in = isl_map_plain_is_single_valued(map);
11116 isl_map_free(map);
11117
11118 return in;
11119}
11120
11121isl_bool isl_map_is_bijective(__isl_keep isl_map *map)
11122{
11123 isl_bool sv;
11124
11125 sv = isl_map_is_single_valued(map);
11126 if (sv < 0 || !sv)
11127 return sv;
11128
11129 return isl_map_is_injective(map);
11130}
11131
11132isl_bool isl_set_is_singleton(__isl_keep isl_setisl_map *set)
11133{
11134 return isl_map_is_single_valued(set_to_map(set));
11135}
11136
11137/* Does "map" only map elements to themselves?
11138 *
11139 * If the domain and range spaces are different, then "map"
11140 * is considered not to be an identity relation, even if it is empty.
11141 * Otherwise, construct the maximal identity relation and
11142 * check whether "map" is a subset of this relation.
11143 */
11144isl_bool isl_map_is_identity(__isl_keep isl_map *map)
11145{
11146 isl_space *space;
11147 isl_map *id;
11148 isl_bool equal, is_identity;
11149
11150 space = isl_map_get_space(map);
11151 equal = isl_space_tuple_is_equal(space, isl_dim_in, space, isl_dim_out);
11152 isl_space_free(space);
11153 if (equal < 0 || !equal)
11154 return equal;
11155
11156 id = isl_map_identity(isl_map_get_space(map));
11157 is_identity = isl_map_is_subset(map, id);
11158 isl_map_free(id);
11159
11160 return is_identity;
11161}
11162
11163int isl_map_is_translation(__isl_keep isl_map *map)
11164{
11165 int ok;
11166 isl_setisl_map *delta;
11167
11168 delta = isl_map_deltas(isl_map_copy(map));
11169 ok = isl_set_is_singleton(delta);
11170 isl_set_free(delta);
11171
11172 return ok;
11173}
11174
11175static int unique(isl_int *p, unsigned pos, unsigned len)
11176{
11177 if (isl_seq_first_non_zero(p, pos) != -1)
11178 return 0;
11179 if (isl_seq_first_non_zero(p + pos + 1, len - pos - 1) != -1)
11180 return 0;
11181 return 1;
11182}
11183
11184isl_bool isl_basic_set_is_box(__isl_keep isl_basic_setisl_basic_map *bset)
11185{
11186 int i, j;
11187 unsigned nvar;
11188 unsigned ovar;
11189
11190 if (!bset)
11191 return isl_bool_error;
11192
11193 if (isl_basic_set_dim(bset, isl_dim_div) != 0)
11194 return isl_bool_false;
11195
11196 nvar = isl_basic_set_dim(bset, isl_dim_set);
11197 ovar = isl_space_offset(bset->dim, isl_dim_set);
11198 for (j = 0; j < nvar; ++j) {
11199 int lower = 0, upper = 0;
11200 for (i = 0; i < bset->n_eq; ++i) {
11201 if (isl_int_is_zero(bset->eq[i][1 + ovar + j])(isl_sioimath_sgn(*(bset->eq[i][1 + ovar + j])) == 0))
11202 continue;
11203 if (!unique(bset->eq[i] + 1 + ovar, j, nvar))
11204 return isl_bool_false;
11205 break;
11206 }
11207 if (i < bset->n_eq)
11208 continue;
11209 for (i = 0; i < bset->n_ineq; ++i) {
11210 if (isl_int_is_zero(bset->ineq[i][1 + ovar + j])(isl_sioimath_sgn(*(bset->ineq[i][1 + ovar + j])) == 0))
11211 continue;
11212 if (!unique(bset->ineq[i] + 1 + ovar, j, nvar))
11213 return isl_bool_false;
11214 if (isl_int_is_pos(bset->ineq[i][1 + ovar + j])(isl_sioimath_sgn(*(bset->ineq[i][1 + ovar + j])) > 0))
11215 lower = 1;
11216 else
11217 upper = 1;
11218 }
11219 if (!lower || !upper)
11220 return isl_bool_false;
11221 }
11222
11223 return isl_bool_true;
11224}
11225
11226isl_bool isl_set_is_box(__isl_keep isl_setisl_map *set)
11227{
11228 if (!set)
11229 return isl_bool_error;
11230 if (set->n != 1)
11231 return isl_bool_false;
11232
11233 return isl_basic_set_is_box(set->p[0]);
11234}
11235
11236isl_bool isl_basic_set_is_wrapping(__isl_keep isl_basic_setisl_basic_map *bset)
11237{
11238 if (!bset)
11239 return isl_bool_error;
11240
11241 return isl_space_is_wrapping(bset->dim);
11242}
11243
11244isl_bool isl_set_is_wrapping(__isl_keep isl_setisl_map *set)
11245{
11246 if (!set)
11247 return isl_bool_error;
11248
11249 return isl_space_is_wrapping(set->dim);
11250}
11251
11252/* Modify the space of "map" through a call to "change".
11253 * If "can_change" is set (not NULL), then first call it to check
11254 * if the modification is allowed, printing the error message "cannot_change"
11255 * if it is not.
11256 */
11257static __isl_give isl_map *isl_map_change_space(__isl_take isl_map *map,
11258 isl_bool (*can_change)(__isl_keep isl_map *map),
11259 const char *cannot_change,
11260 __isl_give isl_space *(*change)(__isl_take isl_space *space))
11261{
11262 isl_bool ok;
11263 isl_space *space;
11264
11265 if (!map)
11266 return NULL((void*)0);
11267
11268 ok = can_change ? can_change(map) : isl_bool_true;
11269 if (ok < 0)
11270 return isl_map_free(map);
11271 if (!ok)
11272 isl_die(isl_map_get_ctx(map), isl_error_invalid, cannot_change,do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, cannot_change, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11273); return isl_map_free(map); } while (0)
11273 return isl_map_free(map))do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, cannot_change, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11273); return isl_map_free(map); } while (0)
;
11274
11275 space = change(isl_map_get_space(map));
11276 map = isl_map_reset_space(map, space);
11277
11278 return map;
11279}
11280
11281/* Is the domain of "map" a wrapped relation?
11282 */
11283isl_bool isl_map_domain_is_wrapping(__isl_keep isl_map *map)
11284{
11285 if (!map)
11286 return isl_bool_error;
11287
11288 return isl_space_domain_is_wrapping(map->dim);
11289}
11290
11291/* Does "map" have a wrapped relation in both domain and range?
11292 */
11293isl_bool isl_map_is_product(__isl_keep isl_map *map)
11294{
11295 return isl_space_is_product(isl_map_peek_space(map));
11296}
11297
11298/* Is the range of "map" a wrapped relation?
11299 */
11300isl_bool isl_map_range_is_wrapping(__isl_keep isl_map *map)
11301{
11302 if (!map)
11303 return isl_bool_error;
11304
11305 return isl_space_range_is_wrapping(map->dim);
11306}
11307
11308__isl_give isl_basic_setisl_basic_map *isl_basic_map_wrap(__isl_take isl_basic_map *bmap)
11309{
11310 bmap = isl_basic_map_cow(bmap);
11311 if (!bmap)
11312 return NULL((void*)0);
11313
11314 bmap->dim = isl_space_wrap(bmap->dim);
11315 if (!bmap->dim)
11316 goto error;
11317
11318 bmap = isl_basic_map_finalize(bmap);
11319
11320 return bset_from_bmap(bmap);
11321error:
11322 isl_basic_map_free(bmap);
11323 return NULL((void*)0);
11324}
11325
11326/* Given a map A -> B, return the set (A -> B).
11327 */
11328__isl_give isl_setisl_map *isl_map_wrap(__isl_take isl_map *map)
11329{
11330 return isl_map_change_space(map, NULL((void*)0), NULL((void*)0), &isl_space_wrap);
11331}
11332
11333__isl_give isl_basic_map *isl_basic_set_unwrap(__isl_take isl_basic_setisl_basic_map *bset)
11334{
11335 bset = isl_basic_set_cow(bset);
11336 if (!bset)
11337 return NULL((void*)0);
11338
11339 bset->dim = isl_space_unwrap(bset->dim);
11340 if (!bset->dim)
11341 goto error;
11342
11343 bset = isl_basic_set_finalize(bset);
11344
11345 return bset_to_bmap(bset);
11346error:
11347 isl_basic_set_free(bset);
11348 return NULL((void*)0);
11349}
11350
11351/* Given a set (A -> B), return the map A -> B.
11352 * Error out if "set" is not of the form (A -> B).
11353 */
11354__isl_give isl_map *isl_set_unwrap(__isl_take isl_setisl_map *set)
11355{
11356 return isl_map_change_space(set, &isl_set_is_wrapping,
11357 "not a wrapping set", &isl_space_unwrap);
11358}
11359
11360__isl_give isl_basic_map *isl_basic_map_reset(__isl_take isl_basic_map *bmap,
11361 enum isl_dim_type type)
11362{
11363 if (!bmap)
11364 return NULL((void*)0);
11365
11366 if (!isl_space_is_named_or_nested(bmap->dim, type))
11367 return bmap;
11368
11369 bmap = isl_basic_map_cow(bmap);
11370 if (!bmap)
11371 return NULL((void*)0);
11372
11373 bmap->dim = isl_space_reset(bmap->dim, type);
11374 if (!bmap->dim)
11375 goto error;
11376
11377 bmap = isl_basic_map_finalize(bmap);
11378
11379 return bmap;
11380error:
11381 isl_basic_map_free(bmap);
11382 return NULL((void*)0);
11383}
11384
11385__isl_give isl_map *isl_map_reset(__isl_take isl_map *map,
11386 enum isl_dim_type type)
11387{
11388 int i;
11389
11390 if (!map)
11391 return NULL((void*)0);
11392
11393 if (!isl_space_is_named_or_nested(map->dim, type))
11394 return map;
11395
11396 map = isl_map_cow(map);
11397 if (!map)
11398 return NULL((void*)0);
11399
11400 for (i = 0; i < map->n; ++i) {
11401 map->p[i] = isl_basic_map_reset(map->p[i], type);
11402 if (!map->p[i])
11403 goto error;
11404 }
11405 map->dim = isl_space_reset(map->dim, type);
11406 if (!map->dim)
11407 goto error;
11408
11409 return map;
11410error:
11411 isl_map_free(map);
11412 return NULL((void*)0);
11413}
11414
11415__isl_give isl_basic_map *isl_basic_map_flatten(__isl_take isl_basic_map *bmap)
11416{
11417 if (!bmap)
11418 return NULL((void*)0);
11419
11420 if (!bmap->dim->nested[0] && !bmap->dim->nested[1])
11421 return bmap;
11422
11423 bmap = isl_basic_map_cow(bmap);
11424 if (!bmap)
11425 return NULL((void*)0);
11426
11427 bmap->dim = isl_space_flatten(bmap->dim);
11428 if (!bmap->dim)
11429 goto error;
11430
11431 bmap = isl_basic_map_finalize(bmap);
11432
11433 return bmap;
11434error:
11435 isl_basic_map_free(bmap);
11436 return NULL((void*)0);
11437}
11438
11439__isl_give isl_basic_setisl_basic_map *isl_basic_set_flatten(__isl_take isl_basic_setisl_basic_map *bset)
11440{
11441 return bset_from_bmap(isl_basic_map_flatten(bset_to_bmap(bset)));
11442}
11443
11444__isl_give isl_basic_map *isl_basic_map_flatten_domain(
11445 __isl_take isl_basic_map *bmap)
11446{
11447 if (!bmap)
11448 return NULL((void*)0);
11449
11450 if (!bmap->dim->nested[0])
11451 return bmap;
11452
11453 bmap = isl_basic_map_cow(bmap);
11454 if (!bmap)
11455 return NULL((void*)0);
11456
11457 bmap->dim = isl_space_flatten_domain(bmap->dim);
11458 if (!bmap->dim)
11459 goto error;
11460
11461 bmap = isl_basic_map_finalize(bmap);
11462
11463 return bmap;
11464error:
11465 isl_basic_map_free(bmap);
11466 return NULL((void*)0);
11467}
11468
11469__isl_give isl_basic_map *isl_basic_map_flatten_range(
11470 __isl_take isl_basic_map *bmap)
11471{
11472 if (!bmap)
11473 return NULL((void*)0);
11474
11475 if (!bmap->dim->nested[1])
11476 return bmap;
11477
11478 bmap = isl_basic_map_cow(bmap);
11479 if (!bmap)
11480 return NULL((void*)0);
11481
11482 bmap->dim = isl_space_flatten_range(bmap->dim);
11483 if (!bmap->dim)
11484 goto error;
11485
11486 bmap = isl_basic_map_finalize(bmap);
11487
11488 return bmap;
11489error:
11490 isl_basic_map_free(bmap);
11491 return NULL((void*)0);
11492}
11493
11494/* Remove any internal structure from the spaces of domain and range of "map".
11495 */
11496__isl_give isl_map *isl_map_flatten(__isl_take isl_map *map)
11497{
11498 if (!map)
11499 return NULL((void*)0);
11500
11501 if (!map->dim->nested[0] && !map->dim->nested[1])
11502 return map;
11503
11504 return isl_map_change_space(map, NULL((void*)0), NULL((void*)0), &isl_space_flatten);
11505}
11506
11507__isl_give isl_setisl_map *isl_set_flatten(__isl_take isl_setisl_map *set)
11508{
11509 return set_from_map(isl_map_flatten(set_to_map(set)));
11510}
11511
11512__isl_give isl_map *isl_set_flatten_map(__isl_take isl_setisl_map *set)
11513{
11514 isl_space *dim, *flat_dim;
11515 isl_map *map;
11516
11517 dim = isl_set_get_space(set);
11518 flat_dim = isl_space_flatten(isl_space_copy(dim));
11519 map = isl_map_identity(isl_space_join(isl_space_reverse(dim), flat_dim));
11520 map = isl_map_intersect_domain(map, set);
11521
11522 return map;
11523}
11524
11525/* Remove any internal structure from the space of the domain of "map".
11526 */
11527__isl_give isl_map *isl_map_flatten_domain(__isl_take isl_map *map)
11528{
11529 if (!map)
11530 return NULL((void*)0);
11531
11532 if (!map->dim->nested[0])
11533 return map;
11534
11535 return isl_map_change_space(map, NULL((void*)0), NULL((void*)0), &isl_space_flatten_domain);
11536}
11537
11538/* Remove any internal structure from the space of the range of "map".
11539 */
11540__isl_give isl_map *isl_map_flatten_range(__isl_take isl_map *map)
11541{
11542 if (!map)
11543 return NULL((void*)0);
11544
11545 if (!map->dim->nested[1])
11546 return map;
11547
11548 return isl_map_change_space(map, NULL((void*)0), NULL((void*)0), &isl_space_flatten_range);
11549}
11550
11551/* Reorder the dimensions of "bmap" according to the given dim_map
11552 * and set the dimension specification to "dim" and
11553 * perform Gaussian elimination on the result.
11554 */
11555__isl_give isl_basic_map *isl_basic_map_realign(__isl_take isl_basic_map *bmap,
11556 __isl_take isl_space *dim, __isl_take struct isl_dim_map *dim_map)
11557{
11558 isl_basic_map *res;
11559 unsigned flags;
11560
11561 bmap = isl_basic_map_cow(bmap);
11562 if (!bmap || !dim || !dim_map)
11563 goto error;
11564
11565 flags = bmap->flags;
11566 ISL_FL_CLR(flags, ISL_BASIC_MAP_FINAL)((flags) &= ~((1 << 0)));
11567 ISL_FL_CLR(flags, ISL_BASIC_MAP_NORMALIZED)((flags) &= ~((1 << 5)));
11568 ISL_FL_CLR(flags, ISL_BASIC_MAP_NORMALIZED_DIVS)((flags) &= ~((1 << 6)));
11569 res = isl_basic_map_alloc_space(dim,
11570 bmap->n_div, bmap->n_eq, bmap->n_ineq);
11571 res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
11572 if (res)
11573 res->flags = flags;
11574 res = isl_basic_map_gauss(res, NULL((void*)0));
11575 res = isl_basic_map_finalize(res);
11576 return res;
11577error:
11578 free(dim_map);
11579 isl_basic_map_free(bmap);
11580 isl_space_free(dim);
11581 return NULL((void*)0);
11582}
11583
11584/* Reorder the dimensions of "map" according to given reordering.
11585 */
11586__isl_give isl_map *isl_map_realign(__isl_take isl_map *map,
11587 __isl_take isl_reordering *r)
11588{
11589 int i;
11590 struct isl_dim_map *dim_map;
11591
11592 map = isl_map_cow(map);
11593 dim_map = isl_dim_map_from_reordering(r);
11594 if (!map || !r || !dim_map)
11595 goto error;
11596
11597 for (i = 0; i < map->n; ++i) {
11598 struct isl_dim_map *dim_map_i;
11599
11600 dim_map_i = isl_dim_map_extend(dim_map, map->p[i]);
11601
11602 map->p[i] = isl_basic_map_realign(map->p[i],
11603 isl_space_copy(r->dim), dim_map_i);
11604
11605 if (!map->p[i])
11606 goto error;
11607 }
11608
11609 map = isl_map_reset_space(map, isl_space_copy(r->dim));
11610
11611 isl_reordering_free(r);
11612 free(dim_map);
11613 return map;
11614error:
11615 free(dim_map);
11616 isl_map_free(map);
11617 isl_reordering_free(r);
11618 return NULL((void*)0);
11619}
11620
11621__isl_give isl_setisl_map *isl_set_realign(__isl_take isl_setisl_map *set,
11622 __isl_take isl_reordering *r)
11623{
11624 return set_from_map(isl_map_realign(set_to_map(set), r));
11625}
11626
11627__isl_give isl_map *isl_map_align_params(__isl_take isl_map *map,
11628 __isl_take isl_space *model)
11629{
11630 isl_ctx *ctx;
11631 isl_bool aligned;
11632
11633 if (!map || !model)
11634 goto error;
11635
11636 ctx = isl_space_get_ctx(model);
11637 if (!isl_space_has_named_params(model))
11638 isl_die(ctx, isl_error_invalid,do { isl_handle_error(ctx, isl_error_invalid, "model has unnamed parameters"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11639); goto error; } while (0)
11639 "model has unnamed parameters", goto error)do { isl_handle_error(ctx, isl_error_invalid, "model has unnamed parameters"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11639); goto error; } while (0)
;
11640 if (isl_map_check_named_params(map) < 0)
11641 goto error;
11642 aligned = isl_map_space_has_equal_params(map, model);
11643 if (aligned < 0)
11644 goto error;
11645 if (!aligned) {
11646 isl_reordering *exp;
11647
11648 model = isl_space_drop_dims(model, isl_dim_in,
11649 0, isl_space_dim(model, isl_dim_in));
11650 model = isl_space_drop_dims(model, isl_dim_out,
11651 0, isl_space_dim(model, isl_dim_out));
11652 exp = isl_parameter_alignment_reordering(map->dim, model);
11653 exp = isl_reordering_extend_space(exp, isl_map_get_space(map));
11654 map = isl_map_realign(map, exp);
11655 }
11656
11657 isl_space_free(model);
11658 return map;
11659error:
11660 isl_space_free(model);
11661 isl_map_free(map);
11662 return NULL((void*)0);
11663}
11664
11665__isl_give isl_setisl_map *isl_set_align_params(__isl_take isl_setisl_map *set,
11666 __isl_take isl_space *model)
11667{
11668 return isl_map_align_params(set, model);
11669}
11670
11671/* Align the parameters of "bmap" to those of "model", introducing
11672 * additional parameters if needed.
11673 */
11674__isl_give isl_basic_map *isl_basic_map_align_params(
11675 __isl_take isl_basic_map *bmap, __isl_take isl_space *model)
11676{
11677 isl_ctx *ctx;
11678 isl_bool equal_params;
11679
11680 if (!bmap || !model)
11681 goto error;
11682
11683 ctx = isl_space_get_ctx(model);
11684 if (!isl_space_has_named_params(model))
11685 isl_die(ctx, isl_error_invalid,do { isl_handle_error(ctx, isl_error_invalid, "model has unnamed parameters"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11686); goto error; } while (0)
11686 "model has unnamed parameters", goto error)do { isl_handle_error(ctx, isl_error_invalid, "model has unnamed parameters"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11686); goto error; } while (0)
;
11687 if (!isl_space_has_named_params(bmap->dim))
11688 isl_die(ctx, isl_error_invalid,do { isl_handle_error(ctx, isl_error_invalid, "relation has unnamed parameters"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11689); goto error; } while (0)
11689 "relation has unnamed parameters", goto error)do { isl_handle_error(ctx, isl_error_invalid, "relation has unnamed parameters"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11689); goto error; } while (0)
;
11690 equal_params = isl_space_has_equal_params(bmap->dim, model);
11691 if (equal_params < 0)
11692 goto error;
11693 if (!equal_params) {
11694 isl_reordering *exp;
11695 struct isl_dim_map *dim_map;
11696
11697 model = isl_space_drop_dims(model, isl_dim_in,
11698 0, isl_space_dim(model, isl_dim_in));
11699 model = isl_space_drop_dims(model, isl_dim_out,
11700 0, isl_space_dim(model, isl_dim_out));
11701 exp = isl_parameter_alignment_reordering(bmap->dim, model);
11702 exp = isl_reordering_extend_space(exp,
11703 isl_basic_map_get_space(bmap));
11704 dim_map = isl_dim_map_from_reordering(exp);
11705 bmap = isl_basic_map_realign(bmap,
11706 exp ? isl_space_copy(exp->dim) : NULL((void*)0),
11707 isl_dim_map_extend(dim_map, bmap));
11708 isl_reordering_free(exp);
11709 free(dim_map);
11710 }
11711
11712 isl_space_free(model);
11713 return bmap;
11714error:
11715 isl_space_free(model);
11716 isl_basic_map_free(bmap);
11717 return NULL((void*)0);
11718}
11719
11720/* Do "bset" and "space" have the same parameters?
11721 */
11722isl_bool isl_basic_set_space_has_equal_params(__isl_keep isl_basic_setisl_basic_map *bset,
11723 __isl_keep isl_space *space)
11724{
11725 isl_space *bset_space;
11726
11727 bset_space = isl_basic_set_peek_space(bset);
11728 return isl_space_has_equal_params(bset_space, space);
11729}
11730
11731/* Do "map" and "space" have the same parameters?
11732 */
11733isl_bool isl_map_space_has_equal_params(__isl_keep isl_map *map,
11734 __isl_keep isl_space *space)
11735{
11736 isl_space *map_space;
11737
11738 map_space = isl_map_peek_space(map);
11739 return isl_space_has_equal_params(map_space, space);
11740}
11741
11742/* Do "set" and "space" have the same parameters?
11743 */
11744isl_bool isl_set_space_has_equal_params(__isl_keep isl_setisl_map *set,
11745 __isl_keep isl_space *space)
11746{
11747 return isl_map_space_has_equal_params(set_to_map(set), space);
11748}
11749
11750/* Align the parameters of "bset" to those of "model", introducing
11751 * additional parameters if needed.
11752 */
11753__isl_give isl_basic_setisl_basic_map *isl_basic_set_align_params(
11754 __isl_take isl_basic_setisl_basic_map *bset, __isl_take isl_space *model)
11755{
11756 return isl_basic_map_align_params(bset, model);
11757}
11758
11759__isl_give isl_mat *isl_basic_map_equalities_matrix(
11760 __isl_keep isl_basic_map *bmap, enum isl_dim_type c1,
11761 enum isl_dim_type c2, enum isl_dim_type c3,
11762 enum isl_dim_type c4, enum isl_dim_type c5)
11763{
11764 enum isl_dim_type c[5] = { c1, c2, c3, c4, c5 };
11765 struct isl_mat *mat;
11766 int i, j, k;
11767 int pos;
11768
11769 if (!bmap)
11770 return NULL((void*)0);
11771 mat = isl_mat_alloc(bmap->ctx, bmap->n_eq,
11772 isl_basic_map_total_dim(bmap) + 1);
11773 if (!mat)
11774 return NULL((void*)0);
11775 for (i = 0; i < bmap->n_eq; ++i)
11776 for (j = 0, pos = 0; j < 5; ++j) {
11777 int off = isl_basic_map_offset(bmap, c[j]);
11778 for (k = 0; k < isl_basic_map_dim(bmap, c[j]); ++k) {
11779 isl_int_set(mat->row[i][pos],isl_sioimath_set((mat->row[i][pos]), *(bmap->eq[i][off +
k]))
11780 bmap->eq[i][off + k])isl_sioimath_set((mat->row[i][pos]), *(bmap->eq[i][off +
k]))
;
11781 ++pos;
11782 }
11783 }
11784
11785 return mat;
11786}
11787
11788__isl_give isl_mat *isl_basic_map_inequalities_matrix(
11789 __isl_keep isl_basic_map *bmap, enum isl_dim_type c1,
11790 enum isl_dim_type c2, enum isl_dim_type c3,
11791 enum isl_dim_type c4, enum isl_dim_type c5)
11792{
11793 enum isl_dim_type c[5] = { c1, c2, c3, c4, c5 };
11794 struct isl_mat *mat;
11795 int i, j, k;
11796 int pos;
11797
11798 if (!bmap)
11799 return NULL((void*)0);
11800 mat = isl_mat_alloc(bmap->ctx, bmap->n_ineq,
11801 isl_basic_map_total_dim(bmap) + 1);
11802 if (!mat)
11803 return NULL((void*)0);
11804 for (i = 0; i < bmap->n_ineq; ++i)
11805 for (j = 0, pos = 0; j < 5; ++j) {
11806 int off = isl_basic_map_offset(bmap, c[j]);
11807 for (k = 0; k < isl_basic_map_dim(bmap, c[j]); ++k) {
11808 isl_int_set(mat->row[i][pos],isl_sioimath_set((mat->row[i][pos]), *(bmap->ineq[i][off
+ k]))
11809 bmap->ineq[i][off + k])isl_sioimath_set((mat->row[i][pos]), *(bmap->ineq[i][off
+ k]))
;
11810 ++pos;
11811 }
11812 }
11813
11814 return mat;
11815}
11816
11817__isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
11818 __isl_take isl_space *dim,
11819 __isl_take isl_mat *eq, __isl_take isl_mat *ineq, enum isl_dim_type c1,
11820 enum isl_dim_type c2, enum isl_dim_type c3,
11821 enum isl_dim_type c4, enum isl_dim_type c5)
11822{
11823 enum isl_dim_type c[5] = { c1, c2, c3, c4, c5 };
11824 isl_basic_map *bmap;
11825 unsigned total;
11826 unsigned extra;
11827 int i, j, k, l;
11828 int pos;
11829
11830 if (!dim || !eq || !ineq)
11831 goto error;
11832
11833 if (eq->n_col != ineq->n_col)
11834 isl_die(dim->ctx, isl_error_invalid,do { isl_handle_error(dim->ctx, isl_error_invalid, "equalities and inequalities matrices should have "
"same number of columns", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11836); goto error; } while (0)
11835 "equalities and inequalities matrices should have "do { isl_handle_error(dim->ctx, isl_error_invalid, "equalities and inequalities matrices should have "
"same number of columns", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11836); goto error; } while (0)
11836 "same number of columns", goto error)do { isl_handle_error(dim->ctx, isl_error_invalid, "equalities and inequalities matrices should have "
"same number of columns", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11836); goto error; } while (0)
;
11837
11838 total = 1 + isl_space_dim(dim, isl_dim_all);
11839
11840 if (eq->n_col < total)
11841 isl_die(dim->ctx, isl_error_invalid,do { isl_handle_error(dim->ctx, isl_error_invalid, "number of columns too small"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11842); goto error; } while (0)
11842 "number of columns too small", goto error)do { isl_handle_error(dim->ctx, isl_error_invalid, "number of columns too small"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11842); goto error; } while (0)
;
11843
11844 extra = eq->n_col - total;
11845
11846 bmap = isl_basic_map_alloc_space(isl_space_copy(dim), extra,
11847 eq->n_row, ineq->n_row);
11848 if (!bmap)
11849 goto error;
11850 for (i = 0; i < extra; ++i) {
11851 k = isl_basic_map_alloc_div(bmap);
11852 if (k < 0)
11853 goto error;
11854 isl_int_set_si(bmap->div[k][0], 0)isl_sioimath_set_si((bmap->div[k][0]), 0);
11855 }
11856 for (i = 0; i < eq->n_row; ++i) {
11857 l = isl_basic_map_alloc_equality(bmap);
11858 if (l < 0)
11859 goto error;
11860 for (j = 0, pos = 0; j < 5; ++j) {
11861 int off = isl_basic_map_offset(bmap, c[j]);
11862 for (k = 0; k < isl_basic_map_dim(bmap, c[j]); ++k) {
11863 isl_int_set(bmap->eq[l][off + k],isl_sioimath_set((bmap->eq[l][off + k]), *(eq->row[i][pos
]))
11864 eq->row[i][pos])isl_sioimath_set((bmap->eq[l][off + k]), *(eq->row[i][pos
]))
;
11865 ++pos;
11866 }
11867 }
11868 }
11869 for (i = 0; i < ineq->n_row; ++i) {
11870 l = isl_basic_map_alloc_inequality(bmap);
11871 if (l < 0)
11872 goto error;
11873 for (j = 0, pos = 0; j < 5; ++j) {
11874 int off = isl_basic_map_offset(bmap, c[j]);
11875 for (k = 0; k < isl_basic_map_dim(bmap, c[j]); ++k) {
11876 isl_int_set(bmap->ineq[l][off + k],isl_sioimath_set((bmap->ineq[l][off + k]), *(ineq->row[
i][pos]))
11877 ineq->row[i][pos])isl_sioimath_set((bmap->ineq[l][off + k]), *(ineq->row[
i][pos]))
;
11878 ++pos;
11879 }
11880 }
11881 }
11882
11883 isl_space_free(dim);
11884 isl_mat_free(eq);
11885 isl_mat_free(ineq);
11886
11887 bmap = isl_basic_map_simplify(bmap);
11888 return isl_basic_map_finalize(bmap);
11889error:
11890 isl_space_free(dim);
11891 isl_mat_free(eq);
11892 isl_mat_free(ineq);
11893 return NULL((void*)0);
11894}
11895
11896__isl_give isl_mat *isl_basic_set_equalities_matrix(
11897 __isl_keep isl_basic_setisl_basic_map *bset, enum isl_dim_type c1,
11898 enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4)
11899{
11900 return isl_basic_map_equalities_matrix(bset_to_bmap(bset),
11901 c1, c2, c3, c4, isl_dim_in);
11902}
11903
11904__isl_give isl_mat *isl_basic_set_inequalities_matrix(
11905 __isl_keep isl_basic_setisl_basic_map *bset, enum isl_dim_type c1,
11906 enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4)
11907{
11908 return isl_basic_map_inequalities_matrix(bset_to_bmap(bset),
11909 c1, c2, c3, c4, isl_dim_in);
11910}
11911
11912__isl_give isl_basic_setisl_basic_map *isl_basic_set_from_constraint_matrices(
11913 __isl_take isl_space *dim,
11914 __isl_take isl_mat *eq, __isl_take isl_mat *ineq, enum isl_dim_type c1,
11915 enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4)
11916{
11917 isl_basic_map *bmap;
11918 bmap = isl_basic_map_from_constraint_matrices(dim, eq, ineq,
11919 c1, c2, c3, c4, isl_dim_in);
11920 return bset_from_bmap(bmap);
11921}
11922
11923isl_bool isl_basic_map_can_zip(__isl_keep isl_basic_map *bmap)
11924{
11925 if (!bmap)
11926 return isl_bool_error;
11927
11928 return isl_space_can_zip(bmap->dim);
11929}
11930
11931isl_bool isl_map_can_zip(__isl_keep isl_map *map)
11932{
11933 if (!map)
11934 return isl_bool_error;
11935
11936 return isl_space_can_zip(map->dim);
11937}
11938
11939/* Given a basic map (A -> B) -> (C -> D), return the corresponding basic map
11940 * (A -> C) -> (B -> D).
11941 */
11942__isl_give isl_basic_map *isl_basic_map_zip(__isl_take isl_basic_map *bmap)
11943{
11944 unsigned pos;
11945 unsigned n1;
11946 unsigned n2;
11947
11948 if (!bmap)
11949 return NULL((void*)0);
11950
11951 if (!isl_basic_map_can_zip(bmap))
11952 isl_die(bmap->ctx, isl_error_invalid,do { isl_handle_error(bmap->ctx, isl_error_invalid, "basic map cannot be zipped"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11953); goto error; } while (0)
11953 "basic map cannot be zipped", goto error)do { isl_handle_error(bmap->ctx, isl_error_invalid, "basic map cannot be zipped"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11953); goto error; } while (0)
;
11954 pos = isl_basic_map_offset(bmap, isl_dim_in) +
11955 isl_space_dim(bmap->dim->nested[0], isl_dim_in);
11956 n1 = isl_space_dim(bmap->dim->nested[0], isl_dim_out);
11957 n2 = isl_space_dim(bmap->dim->nested[1], isl_dim_in);
11958 bmap = isl_basic_map_cow(bmap);
11959 bmap = isl_basic_map_swap_vars(bmap, pos, n1, n2);
11960 if (!bmap)
11961 return NULL((void*)0);
11962 bmap->dim = isl_space_zip(bmap->dim);
11963 if (!bmap->dim)
11964 goto error;
11965 bmap = isl_basic_map_mark_final(bmap);
11966 return bmap;
11967error:
11968 isl_basic_map_free(bmap);
11969 return NULL((void*)0);
11970}
11971
11972/* Given a map (A -> B) -> (C -> D), return the corresponding map
11973 * (A -> C) -> (B -> D).
11974 */
11975__isl_give isl_map *isl_map_zip(__isl_take isl_map *map)
11976{
11977 int i;
11978
11979 if (!map)
11980 return NULL((void*)0);
11981
11982 if (!isl_map_can_zip(map))
11983 isl_die(map->ctx, isl_error_invalid, "map cannot be zipped",do { isl_handle_error(map->ctx, isl_error_invalid, "map cannot be zipped"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11984); goto error; } while (0)
11984 goto error)do { isl_handle_error(map->ctx, isl_error_invalid, "map cannot be zipped"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 11984); goto error; } while (0)
;
11985
11986 map = isl_map_cow(map);
11987 if (!map)
11988 return NULL((void*)0);
11989
11990 for (i = 0; i < map->n; ++i) {
11991 map->p[i] = isl_basic_map_zip(map->p[i]);
11992 if (!map->p[i])
11993 goto error;
11994 }
11995
11996 map->dim = isl_space_zip(map->dim);
11997 if (!map->dim)
11998 goto error;
11999
12000 return map;
12001error:
12002 isl_map_free(map);
12003 return NULL((void*)0);
12004}
12005
12006/* Can we apply isl_basic_map_curry to "bmap"?
12007 * That is, does it have a nested relation in its domain?
12008 */
12009isl_bool isl_basic_map_can_curry(__isl_keep isl_basic_map *bmap)
12010{
12011 if (!bmap)
12012 return isl_bool_error;
12013
12014 return isl_space_can_curry(bmap->dim);
12015}
12016
12017/* Can we apply isl_map_curry to "map"?
12018 * That is, does it have a nested relation in its domain?
12019 */
12020isl_bool isl_map_can_curry(__isl_keep isl_map *map)
12021{
12022 if (!map)
12023 return isl_bool_error;
12024
12025 return isl_space_can_curry(map->dim);
12026}
12027
12028/* Given a basic map (A -> B) -> C, return the corresponding basic map
12029 * A -> (B -> C).
12030 */
12031__isl_give isl_basic_map *isl_basic_map_curry(__isl_take isl_basic_map *bmap)
12032{
12033
12034 if (!bmap)
12035 return NULL((void*)0);
12036
12037 if (!isl_basic_map_can_curry(bmap))
12038 isl_die(bmap->ctx, isl_error_invalid,do { isl_handle_error(bmap->ctx, isl_error_invalid, "basic map cannot be curried"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12039); goto error; } while (0)
12039 "basic map cannot be curried", goto error)do { isl_handle_error(bmap->ctx, isl_error_invalid, "basic map cannot be curried"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12039); goto error; } while (0)
;
12040 bmap = isl_basic_map_cow(bmap);
12041 if (!bmap)
12042 return NULL((void*)0);
12043 bmap->dim = isl_space_curry(bmap->dim);
12044 if (!bmap->dim)
12045 goto error;
12046 bmap = isl_basic_map_mark_final(bmap);
12047 return bmap;
12048error:
12049 isl_basic_map_free(bmap);
12050 return NULL((void*)0);
12051}
12052
12053/* Given a map (A -> B) -> C, return the corresponding map
12054 * A -> (B -> C).
12055 */
12056__isl_give isl_map *isl_map_curry(__isl_take isl_map *map)
12057{
12058 return isl_map_change_space(map, &isl_map_can_curry,
12059 "map cannot be curried", &isl_space_curry);
12060}
12061
12062/* Can isl_map_range_curry be applied to "map"?
12063 * That is, does it have a nested relation in its range,
12064 * the domain of which is itself a nested relation?
12065 */
12066isl_bool isl_map_can_range_curry(__isl_keep isl_map *map)
12067{
12068 if (!map)
12069 return isl_bool_error;
12070
12071 return isl_space_can_range_curry(map->dim);
12072}
12073
12074/* Given a map A -> ((B -> C) -> D), return the corresponding map
12075 * A -> (B -> (C -> D)).
12076 */
12077__isl_give isl_map *isl_map_range_curry(__isl_take isl_map *map)
12078{
12079 return isl_map_change_space(map, &isl_map_can_range_curry,
12080 "map range cannot be curried",
12081 &isl_space_range_curry);
12082}
12083
12084/* Can we apply isl_basic_map_uncurry to "bmap"?
12085 * That is, does it have a nested relation in its domain?
12086 */
12087isl_bool isl_basic_map_can_uncurry(__isl_keep isl_basic_map *bmap)
12088{
12089 if (!bmap)
12090 return isl_bool_error;
12091
12092 return isl_space_can_uncurry(bmap->dim);
12093}
12094
12095/* Can we apply isl_map_uncurry to "map"?
12096 * That is, does it have a nested relation in its domain?
12097 */
12098isl_bool isl_map_can_uncurry(__isl_keep isl_map *map)
12099{
12100 if (!map)
12101 return isl_bool_error;
12102
12103 return isl_space_can_uncurry(map->dim);
12104}
12105
12106/* Given a basic map A -> (B -> C), return the corresponding basic map
12107 * (A -> B) -> C.
12108 */
12109__isl_give isl_basic_map *isl_basic_map_uncurry(__isl_take isl_basic_map *bmap)
12110{
12111
12112 if (!bmap)
12113 return NULL((void*)0);
12114
12115 if (!isl_basic_map_can_uncurry(bmap))
12116 isl_die(bmap->ctx, isl_error_invalid,do { isl_handle_error(bmap->ctx, isl_error_invalid, "basic map cannot be uncurried"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12118); return isl_basic_map_free(bmap); } while (0)
12117 "basic map cannot be uncurried",do { isl_handle_error(bmap->ctx, isl_error_invalid, "basic map cannot be uncurried"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12118); return isl_basic_map_free(bmap); } while (0)
12118 return isl_basic_map_free(bmap))do { isl_handle_error(bmap->ctx, isl_error_invalid, "basic map cannot be uncurried"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12118); return isl_basic_map_free(bmap); } while (0)
;
12119 bmap = isl_basic_map_cow(bmap);
12120 if (!bmap)
12121 return NULL((void*)0);
12122 bmap->dim = isl_space_uncurry(bmap->dim);
12123 if (!bmap->dim)
12124 return isl_basic_map_free(bmap);
12125 bmap = isl_basic_map_mark_final(bmap);
12126 return bmap;
12127}
12128
12129/* Given a map A -> (B -> C), return the corresponding map
12130 * (A -> B) -> C.
12131 */
12132__isl_give isl_map *isl_map_uncurry(__isl_take isl_map *map)
12133{
12134 return isl_map_change_space(map, &isl_map_can_uncurry,
12135 "map cannot be uncurried", &isl_space_uncurry);
12136}
12137
12138/* Construct a basic map mapping the domain of the affine expression
12139 * to a one-dimensional range prescribed by the affine expression.
12140 * If "rational" is set, then construct a rational basic map.
12141 *
12142 * A NaN affine expression cannot be converted to a basic map.
12143 */
12144static __isl_give isl_basic_map *isl_basic_map_from_aff2(
12145 __isl_take isl_aff *aff, int rational)
12146{
12147 int k;
12148 int pos;
12149 isl_bool is_nan;
12150 isl_local_space *ls;
12151 isl_basic_map *bmap = NULL((void*)0);
12152
12153 if (!aff)
12154 return NULL((void*)0);
12155 is_nan = isl_aff_is_nan(aff);
12156 if (is_nan < 0)
12157 goto error;
12158 if (is_nan)
12159 isl_die(isl_aff_get_ctx(aff), isl_error_invalid,do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid
, "cannot convert NaN", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12160); goto error; } while (0)
12160 "cannot convert NaN", goto error)do { isl_handle_error(isl_aff_get_ctx(aff), isl_error_invalid
, "cannot convert NaN", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12160); goto error; } while (0)
;
12161
12162 ls = isl_aff_get_local_space(aff);
12163 bmap = isl_basic_map_from_local_space(ls);
12164 bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
12165 k = isl_basic_map_alloc_equality(bmap);
12166 if (k < 0)
12167 goto error;
12168
12169 pos = isl_basic_map_offset(bmap, isl_dim_out);
12170 isl_seq_cpy(bmap->eq[k], aff->v->el + 1, pos);
12171 isl_int_neg(bmap->eq[k][pos], aff->v->el[0])isl_sioimath_neg((bmap->eq[k][pos]), *(aff->v->el[0]
))
;
12172 isl_seq_cpy(bmap->eq[k] + pos + 1, aff->v->el + 1 + pos,
12173 aff->v->size - (pos + 1));
12174
12175 isl_aff_free(aff);
12176 if (rational)
12177 bmap = isl_basic_map_set_rational(bmap);
12178 bmap = isl_basic_map_gauss(bmap, NULL((void*)0));
12179 bmap = isl_basic_map_finalize(bmap);
12180 return bmap;
12181error:
12182 isl_aff_free(aff);
12183 isl_basic_map_free(bmap);
12184 return NULL((void*)0);
12185}
12186
12187/* Construct a basic map mapping the domain of the affine expression
12188 * to a one-dimensional range prescribed by the affine expression.
12189 */
12190__isl_give isl_basic_map *isl_basic_map_from_aff(__isl_take isl_aff *aff)
12191{
12192 return isl_basic_map_from_aff2(aff, 0);
12193}
12194
12195/* Construct a map mapping the domain of the affine expression
12196 * to a one-dimensional range prescribed by the affine expression.
12197 */
12198__isl_give isl_map *isl_map_from_aff(__isl_take isl_aff *aff)
12199{
12200 isl_basic_map *bmap;
12201
12202 bmap = isl_basic_map_from_aff(aff);
12203 return isl_map_from_basic_map(bmap);
12204}
12205
12206/* Construct a basic map mapping the domain the multi-affine expression
12207 * to its range, with each dimension in the range equated to the
12208 * corresponding affine expression.
12209 * If "rational" is set, then construct a rational basic map.
12210 */
12211__isl_give isl_basic_map *isl_basic_map_from_multi_aff2(
12212 __isl_take isl_multi_aff *maff, int rational)
12213{
12214 int i;
12215 isl_space *space;
12216 isl_basic_map *bmap;
12217
12218 if (!maff)
12219 return NULL((void*)0);
12220
12221 if (isl_space_dim(maff->space, isl_dim_out) != maff->n)
12222 isl_die(isl_multi_aff_get_ctx(maff), isl_error_internal,do { isl_handle_error(isl_multi_aff_get_ctx(maff), isl_error_internal
, "invalid space", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12223); goto error; } while (0)
12223 "invalid space", goto error)do { isl_handle_error(isl_multi_aff_get_ctx(maff), isl_error_internal
, "invalid space", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12223); goto error; } while (0)
;
12224
12225 space = isl_space_domain(isl_multi_aff_get_space(maff));
12226 bmap = isl_basic_map_universe(isl_space_from_domain(space));
12227 if (rational)
12228 bmap = isl_basic_map_set_rational(bmap);
12229
12230 for (i = 0; i < maff->n; ++i) {
12231 isl_aff *aff;
12232 isl_basic_map *bmap_i;
12233
12234 aff = isl_aff_copy(maff->p[i]);
12235 bmap_i = isl_basic_map_from_aff2(aff, rational);
12236
12237 bmap = isl_basic_map_flat_range_product(bmap, bmap_i);
12238 }
12239
12240 bmap = isl_basic_map_reset_space(bmap, isl_multi_aff_get_space(maff));
12241
12242 isl_multi_aff_free(maff);
12243 return bmap;
12244error:
12245 isl_multi_aff_free(maff);
12246 return NULL((void*)0);
12247}
12248
12249/* Construct a basic map mapping the domain the multi-affine expression
12250 * to its range, with each dimension in the range equated to the
12251 * corresponding affine expression.
12252 */
12253__isl_give isl_basic_map *isl_basic_map_from_multi_aff(
12254 __isl_take isl_multi_aff *ma)
12255{
12256 return isl_basic_map_from_multi_aff2(ma, 0);
12257}
12258
12259/* Construct a map mapping the domain the multi-affine expression
12260 * to its range, with each dimension in the range equated to the
12261 * corresponding affine expression.
12262 */
12263__isl_give isl_map *isl_map_from_multi_aff(__isl_take isl_multi_aff *maff)
12264{
12265 isl_basic_map *bmap;
12266
12267 bmap = isl_basic_map_from_multi_aff(maff);
12268 return isl_map_from_basic_map(bmap);
12269}
12270
12271/* Construct a basic map mapping a domain in the given space to
12272 * to an n-dimensional range, with n the number of elements in the list,
12273 * where each coordinate in the range is prescribed by the
12274 * corresponding affine expression.
12275 * The domains of all affine expressions in the list are assumed to match
12276 * domain_dim.
12277 */
12278__isl_give isl_basic_map *isl_basic_map_from_aff_list(
12279 __isl_take isl_space *domain_dim, __isl_take isl_aff_list *list)
12280{
12281 int i;
12282 isl_space *dim;
12283 isl_basic_map *bmap;
12284
12285 if (!list)
12286 return NULL((void*)0);
12287
12288 dim = isl_space_from_domain(domain_dim);
12289 bmap = isl_basic_map_universe(dim);
12290
12291 for (i = 0; i < list->n; ++i) {
12292 isl_aff *aff;
12293 isl_basic_map *bmap_i;
12294
12295 aff = isl_aff_copy(list->p[i]);
12296 bmap_i = isl_basic_map_from_aff(aff);
12297
12298 bmap = isl_basic_map_flat_range_product(bmap, bmap_i);
12299 }
12300
12301 isl_aff_list_free(list);
12302 return bmap;
12303}
12304
12305__isl_give isl_setisl_map *isl_set_equate(__isl_take isl_setisl_map *set,
12306 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12307{
12308 return isl_map_equate(set, type1, pos1, type2, pos2);
12309}
12310
12311/* Construct a basic map where the given dimensions are equal to each other.
12312 */
12313static __isl_give isl_basic_map *equator(__isl_take isl_space *space,
12314 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12315{
12316 isl_basic_map *bmap = NULL((void*)0);
12317 int i;
12318
12319 if (!space)
12320 return NULL((void*)0);
12321
12322 if (pos1 >= isl_space_dim(space, type1))
12323 isl_die(isl_space_get_ctx(space), isl_error_invalid,do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12324); goto error; } while (0)
12324 "index out of bounds", goto error)do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12324); goto error; } while (0)
;
12325 if (pos2 >= isl_space_dim(space, type2))
12326 isl_die(isl_space_get_ctx(space), isl_error_invalid,do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12327); goto error; } while (0)
12327 "index out of bounds", goto error)do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12327); goto error; } while (0)
;
12328
12329 if (type1 == type2 && pos1 == pos2)
12330 return isl_basic_map_universe(space);
12331
12332 bmap = isl_basic_map_alloc_space(isl_space_copy(space), 0, 1, 0);
12333 i = isl_basic_map_alloc_equality(bmap);
12334 if (i < 0)
12335 goto error;
12336 isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap));
12337 pos1 += isl_basic_map_offset(bmap, type1);
12338 pos2 += isl_basic_map_offset(bmap, type2);
12339 isl_int_set_si(bmap->eq[i][pos1], -1)isl_sioimath_set_si((bmap->eq[i][pos1]), -1);
12340 isl_int_set_si(bmap->eq[i][pos2], 1)isl_sioimath_set_si((bmap->eq[i][pos2]), 1);
12341 bmap = isl_basic_map_finalize(bmap);
12342 isl_space_free(space);
12343 return bmap;
12344error:
12345 isl_space_free(space);
12346 isl_basic_map_free(bmap);
12347 return NULL((void*)0);
12348}
12349
12350/* Add a constraint imposing that the given two dimensions are equal.
12351 */
12352__isl_give isl_basic_map *isl_basic_map_equate(__isl_take isl_basic_map *bmap,
12353 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12354{
12355 isl_basic_map *eq;
12356
12357 eq = equator(isl_basic_map_get_space(bmap), type1, pos1, type2, pos2);
12358
12359 bmap = isl_basic_map_intersect(bmap, eq);
12360
12361 return bmap;
12362}
12363
12364/* Add a constraint imposing that the given two dimensions are equal.
12365 */
12366__isl_give isl_map *isl_map_equate(__isl_take isl_map *map,
12367 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12368{
12369 isl_basic_map *bmap;
12370
12371 bmap = equator(isl_map_get_space(map), type1, pos1, type2, pos2);
12372
12373 map = isl_map_intersect(map, isl_map_from_basic_map(bmap));
12374
12375 return map;
12376}
12377
12378/* Add a constraint imposing that the given two dimensions have opposite values.
12379 */
12380__isl_give isl_map *isl_map_oppose(__isl_take isl_map *map,
12381 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12382{
12383 isl_basic_map *bmap = NULL((void*)0);
12384 int i;
12385
12386 if (!map)
12387 return NULL((void*)0);
12388
12389 if (pos1 >= isl_map_dim(map, type1))
12390 isl_die(map->ctx, isl_error_invalid,do { isl_handle_error(map->ctx, isl_error_invalid, "index out of bounds"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12391); goto error; } while (0)
12391 "index out of bounds", goto error)do { isl_handle_error(map->ctx, isl_error_invalid, "index out of bounds"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12391); goto error; } while (0)
;
12392 if (pos2 >= isl_map_dim(map, type2))
12393 isl_die(map->ctx, isl_error_invalid,do { isl_handle_error(map->ctx, isl_error_invalid, "index out of bounds"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12394); goto error; } while (0)
12394 "index out of bounds", goto error)do { isl_handle_error(map->ctx, isl_error_invalid, "index out of bounds"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12394); goto error; } while (0)
;
12395
12396 bmap = isl_basic_map_alloc_space(isl_map_get_space(map), 0, 1, 0);
12397 i = isl_basic_map_alloc_equality(bmap);
12398 if (i < 0)
12399 goto error;
12400 isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap));
12401 pos1 += isl_basic_map_offset(bmap, type1);
12402 pos2 += isl_basic_map_offset(bmap, type2);
12403 isl_int_set_si(bmap->eq[i][pos1], 1)isl_sioimath_set_si((bmap->eq[i][pos1]), 1);
12404 isl_int_set_si(bmap->eq[i][pos2], 1)isl_sioimath_set_si((bmap->eq[i][pos2]), 1);
12405 bmap = isl_basic_map_finalize(bmap);
12406
12407 map = isl_map_intersect(map, isl_map_from_basic_map(bmap));
12408
12409 return map;
12410error:
12411 isl_basic_map_free(bmap);
12412 isl_map_free(map);
12413 return NULL((void*)0);
12414}
12415
12416/* Construct a constraint imposing that the value of the first dimension is
12417 * greater than or equal to that of the second.
12418 */
12419static __isl_give isl_constraint *constraint_order_ge(
12420 __isl_take isl_space *space, enum isl_dim_type type1, int pos1,
12421 enum isl_dim_type type2, int pos2)
12422{
12423 isl_constraint *c;
12424
12425 if (!space)
12426 return NULL((void*)0);
12427
12428 c = isl_constraint_alloc_inequality(isl_local_space_from_space(space));
12429
12430 if (pos1 >= isl_constraint_dim(c, type1))
12431 isl_die(isl_constraint_get_ctx(c), isl_error_invalid,do { isl_handle_error(isl_constraint_get_ctx(c), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12432); return isl_constraint_free(c); } while (0)
12432 "index out of bounds", return isl_constraint_free(c))do { isl_handle_error(isl_constraint_get_ctx(c), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12432); return isl_constraint_free(c); } while (0)
;
12433 if (pos2 >= isl_constraint_dim(c, type2))
12434 isl_die(isl_constraint_get_ctx(c), isl_error_invalid,do { isl_handle_error(isl_constraint_get_ctx(c), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12435); return isl_constraint_free(c); } while (0)
12435 "index out of bounds", return isl_constraint_free(c))do { isl_handle_error(isl_constraint_get_ctx(c), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12435); return isl_constraint_free(c); } while (0)
;
12436
12437 if (type1 == type2 && pos1 == pos2)
12438 return c;
12439
12440 c = isl_constraint_set_coefficient_si(c, type1, pos1, 1);
12441 c = isl_constraint_set_coefficient_si(c, type2, pos2, -1);
12442
12443 return c;
12444}
12445
12446/* Add a constraint imposing that the value of the first dimension is
12447 * greater than or equal to that of the second.
12448 */
12449__isl_give isl_basic_map *isl_basic_map_order_ge(__isl_take isl_basic_map *bmap,
12450 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12451{
12452 isl_constraint *c;
12453 isl_space *space;
12454
12455 if (type1 == type2 && pos1 == pos2)
12456 return bmap;
12457 space = isl_basic_map_get_space(bmap);
12458 c = constraint_order_ge(space, type1, pos1, type2, pos2);
12459 bmap = isl_basic_map_add_constraint(bmap, c);
12460
12461 return bmap;
12462}
12463
12464/* Add a constraint imposing that the value of the first dimension is
12465 * greater than or equal to that of the second.
12466 */
12467__isl_give isl_map *isl_map_order_ge(__isl_take isl_map *map,
12468 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12469{
12470 isl_constraint *c;
12471 isl_space *space;
12472
12473 if (type1 == type2 && pos1 == pos2)
12474 return map;
12475 space = isl_map_get_space(map);
12476 c = constraint_order_ge(space, type1, pos1, type2, pos2);
12477 map = isl_map_add_constraint(map, c);
12478
12479 return map;
12480}
12481
12482/* Add a constraint imposing that the value of the first dimension is
12483 * less than or equal to that of the second.
12484 */
12485__isl_give isl_map *isl_map_order_le(__isl_take isl_map *map,
12486 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12487{
12488 return isl_map_order_ge(map, type2, pos2, type1, pos1);
12489}
12490
12491/* Construct a basic map where the value of the first dimension is
12492 * greater than that of the second.
12493 */
12494static __isl_give isl_basic_map *greator(__isl_take isl_space *space,
12495 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12496{
12497 isl_basic_map *bmap = NULL((void*)0);
12498 int i;
12499
12500 if (!space)
12501 return NULL((void*)0);
12502
12503 if (pos1 >= isl_space_dim(space, type1))
12504 isl_die(isl_space_get_ctx(space), isl_error_invalid,do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12505); goto error; } while (0)
12505 "index out of bounds", goto error)do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12505); goto error; } while (0)
;
12506 if (pos2 >= isl_space_dim(space, type2))
12507 isl_die(isl_space_get_ctx(space), isl_error_invalid,do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12508); goto error; } while (0)
12508 "index out of bounds", goto error)do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid
, "index out of bounds", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12508); goto error; } while (0)
;
12509
12510 if (type1 == type2 && pos1 == pos2)
12511 return isl_basic_map_empty(space);
12512
12513 bmap = isl_basic_map_alloc_space(space, 0, 0, 1);
12514 i = isl_basic_map_alloc_inequality(bmap);
12515 if (i < 0)
12516 return isl_basic_map_free(bmap);
12517 isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
12518 pos1 += isl_basic_map_offset(bmap, type1);
12519 pos2 += isl_basic_map_offset(bmap, type2);
12520 isl_int_set_si(bmap->ineq[i][pos1], 1)isl_sioimath_set_si((bmap->ineq[i][pos1]), 1);
12521 isl_int_set_si(bmap->ineq[i][pos2], -1)isl_sioimath_set_si((bmap->ineq[i][pos2]), -1);
12522 isl_int_set_si(bmap->ineq[i][0], -1)isl_sioimath_set_si((bmap->ineq[i][0]), -1);
12523 bmap = isl_basic_map_finalize(bmap);
12524
12525 return bmap;
12526error:
12527 isl_space_free(space);
12528 isl_basic_map_free(bmap);
12529 return NULL((void*)0);
12530}
12531
12532/* Add a constraint imposing that the value of the first dimension is
12533 * greater than that of the second.
12534 */
12535__isl_give isl_basic_map *isl_basic_map_order_gt(__isl_take isl_basic_map *bmap,
12536 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12537{
12538 isl_basic_map *gt;
12539
12540 gt = greator(isl_basic_map_get_space(bmap), type1, pos1, type2, pos2);
12541
12542 bmap = isl_basic_map_intersect(bmap, gt);
12543
12544 return bmap;
12545}
12546
12547/* Add a constraint imposing that the value of the first dimension is
12548 * greater than that of the second.
12549 */
12550__isl_give isl_map *isl_map_order_gt(__isl_take isl_map *map,
12551 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12552{
12553 isl_basic_map *bmap;
12554
12555 bmap = greator(isl_map_get_space(map), type1, pos1, type2, pos2);
12556
12557 map = isl_map_intersect(map, isl_map_from_basic_map(bmap));
2
Calling 'isl_map_intersect'
12558
12559 return map;
12560}
12561
12562/* Add a constraint imposing that the value of the first dimension is
12563 * smaller than that of the second.
12564 */
12565__isl_give isl_map *isl_map_order_lt(__isl_take isl_map *map,
12566 enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
12567{
12568 return isl_map_order_gt(map, type2, pos2, type1, pos1);
1
Calling 'isl_map_order_gt'
12569}
12570
12571__isl_give isl_aff *isl_basic_map_get_div(__isl_keep isl_basic_map *bmap,
12572 int pos)
12573{
12574 isl_aff *div;
12575 isl_local_space *ls;
12576
12577 if (!bmap)
12578 return NULL((void*)0);
12579
12580 if (!isl_basic_map_divs_known(bmap))
12581 isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "some divs are unknown", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12582); return ((void*)0); } while (0)
12582 "some divs are unknown", return NULL)do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "some divs are unknown", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12582); return ((void*)0); } while (0)
;
12583
12584 ls = isl_basic_map_get_local_space(bmap);
12585 div = isl_local_space_get_div(ls, pos);
12586 isl_local_space_free(ls);
12587
12588 return div;
12589}
12590
12591__isl_give isl_aff *isl_basic_set_get_div(__isl_keep isl_basic_setisl_basic_map *bset,
12592 int pos)
12593{
12594 return isl_basic_map_get_div(bset, pos);
12595}
12596
12597/* Plug in "subs" for dimension "type", "pos" of "bset".
12598 *
12599 * Let i be the dimension to replace and let "subs" be of the form
12600 *
12601 * f/d
12602 *
12603 * Any integer division with a non-zero coefficient for i,
12604 *
12605 * floor((a i + g)/m)
12606 *
12607 * is replaced by
12608 *
12609 * floor((a f + d g)/(m d))
12610 *
12611 * Constraints of the form
12612 *
12613 * a i + g
12614 *
12615 * are replaced by
12616 *
12617 * a f + d g
12618 *
12619 * We currently require that "subs" is an integral expression.
12620 * Handling rational expressions may require us to add stride constraints
12621 * as we do in isl_basic_set_preimage_multi_aff.
12622 */
12623__isl_give isl_basic_setisl_basic_map *isl_basic_set_substitute(
12624 __isl_take isl_basic_setisl_basic_map *bset,
12625 enum isl_dim_type type, unsigned pos, __isl_keep isl_aff *subs)
12626{
12627 int i;
12628 isl_int v;
12629 isl_ctx *ctx;
12630
12631 if (bset && isl_basic_set_plain_is_empty(bset))
12632 return bset;
12633
12634 bset = isl_basic_set_cow(bset);
12635 if (!bset || !subs)
12636 goto error;
12637
12638 ctx = isl_basic_set_get_ctx(bset);
12639 if (!isl_space_is_equal(bset->dim, subs->ls->dim))
12640 isl_die(ctx, isl_error_invalid,do { isl_handle_error(ctx, isl_error_invalid, "spaces don't match"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12641); goto error; } while (0)
12641 "spaces don't match", goto error)do { isl_handle_error(ctx, isl_error_invalid, "spaces don't match"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12641); goto error; } while (0)
;
12642 if (isl_local_space_dim(subs->ls, isl_dim_div) != 0)
12643 isl_die(ctx, isl_error_unsupported,do { isl_handle_error(ctx, isl_error_unsupported, "cannot handle divs yet"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12644); goto error; } while (0)
12644 "cannot handle divs yet", goto error)do { isl_handle_error(ctx, isl_error_unsupported, "cannot handle divs yet"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12644); goto error; } while (0)
;
12645 if (!isl_int_is_one(subs->v->el[0])(isl_sioimath_cmp_si(*(subs->v->el[0]), 1) == 0))
12646 isl_die(ctx, isl_error_invalid,do { isl_handle_error(ctx, isl_error_invalid, "can only substitute integer expressions"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12647); goto error; } while (0)
12647 "can only substitute integer expressions", goto error)do { isl_handle_error(ctx, isl_error_invalid, "can only substitute integer expressions"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12647); goto error; } while (0)
;
12648
12649 pos += isl_basic_set_offset(bset, type);
12650
12651 isl_int_init(v)isl_sioimath_init((v));
12652
12653 for (i = 0; i < bset->n_eq; ++i) {
12654 if (isl_int_is_zero(bset->eq[i][pos])(isl_sioimath_sgn(*(bset->eq[i][pos])) == 0))
12655 continue;
12656 isl_int_set(v, bset->eq[i][pos])isl_sioimath_set((v), *(bset->eq[i][pos]));
12657 isl_int_set_si(bset->eq[i][pos], 0)isl_sioimath_set_si((bset->eq[i][pos]), 0);
12658 isl_seq_combine(bset->eq[i], subs->v->el[0], bset->eq[i],
12659 v, subs->v->el + 1, subs->v->size - 1);
12660 }
12661
12662 for (i = 0; i < bset->n_ineq; ++i) {
12663 if (isl_int_is_zero(bset->ineq[i][pos])(isl_sioimath_sgn(*(bset->ineq[i][pos])) == 0))
12664 continue;
12665 isl_int_set(v, bset->ineq[i][pos])isl_sioimath_set((v), *(bset->ineq[i][pos]));
12666 isl_int_set_si(bset->ineq[i][pos], 0)isl_sioimath_set_si((bset->ineq[i][pos]), 0);
12667 isl_seq_combine(bset->ineq[i], subs->v->el[0], bset->ineq[i],
12668 v, subs->v->el + 1, subs->v->size - 1);
12669 }
12670
12671 for (i = 0; i < bset->n_div; ++i) {
12672 if (isl_int_is_zero(bset->div[i][1 + pos])(isl_sioimath_sgn(*(bset->div[i][1 + pos])) == 0))
12673 continue;
12674 isl_int_set(v, bset->div[i][1 + pos])isl_sioimath_set((v), *(bset->div[i][1 + pos]));
12675 isl_int_set_si(bset->div[i][1 + pos], 0)isl_sioimath_set_si((bset->div[i][1 + pos]), 0);
12676 isl_seq_combine(bset->div[i] + 1,
12677 subs->v->el[0], bset->div[i] + 1,
12678 v, subs->v->el + 1, subs->v->size - 1);
12679 isl_int_mul(bset->div[i][0], bset->div[i][0], subs->v->el[0])isl_sioimath_mul((bset->div[i][0]), *(bset->div[i][0]),
*(subs->v->el[0]))
;
12680 }
12681
12682 isl_int_clear(v)isl_sioimath_clear((v));
12683
12684 bset = isl_basic_set_simplify(bset);
12685 return isl_basic_set_finalize(bset);
12686error:
12687 isl_basic_set_free(bset);
12688 return NULL((void*)0);
12689}
12690
12691/* Plug in "subs" for dimension "type", "pos" of "set".
12692 */
12693__isl_give isl_setisl_map *isl_set_substitute(__isl_take isl_setisl_map *set,
12694 enum isl_dim_type type, unsigned pos, __isl_keep isl_aff *subs)
12695{
12696 int i;
12697
12698 if (set && isl_set_plain_is_empty(set))
12699 return set;
12700
12701 set = isl_set_cow(set);
12702 if (!set || !subs)
12703 goto error;
12704
12705 for (i = set->n - 1; i >= 0; --i) {
12706 set->p[i] = isl_basic_set_substitute(set->p[i], type, pos, subs);
12707 if (remove_if_empty(set, i) < 0)
12708 goto error;
12709 }
12710
12711 return set;
12712error:
12713 isl_set_free(set);
12714 return NULL((void*)0);
12715}
12716
12717/* Check if the range of "ma" is compatible with the domain or range
12718 * (depending on "type") of "bmap".
12719 */
12720static isl_stat check_basic_map_compatible_range_multi_aff(
12721 __isl_keep isl_basic_map *bmap, enum isl_dim_type type,
12722 __isl_keep isl_multi_aff *ma)
12723{
12724 isl_bool m;
12725 isl_space *ma_space;
12726
12727 ma_space = isl_multi_aff_get_space(ma);
12728
12729 m = isl_space_has_equal_params(bmap->dim, ma_space);
12730 if (m < 0)
12731 goto error;
12732 if (!m)
12733 isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "parameters don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12734); goto error; } while (0)
12734 "parameters don't match", goto error)do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "parameters don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12734); goto error; } while (0)
;
12735 m = isl_space_tuple_is_equal(bmap->dim, type, ma_space, isl_dim_out);
12736 if (m < 0)
12737 goto error;
12738 if (!m)
12739 isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "spaces don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12740); goto error; } while (0)
12740 "spaces don't match", goto error)do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "spaces don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 12740); goto error; } while (0)
;
12741
12742 isl_space_free(ma_space);
12743 return isl_stat_ok;
12744error:
12745 isl_space_free(ma_space);
12746 return isl_stat_error;
12747}
12748
12749/* Copy the divs from "ma" to "bmap", adding zeros for the "n_before"
12750 * coefficients before the transformed range of dimensions,
12751 * the "n_after" coefficients after the transformed range of dimensions
12752 * and the coefficients of the other divs in "bmap".
12753 */
12754static int set_ma_divs(__isl_keep isl_basic_map *bmap,
12755 __isl_keep isl_multi_aff *ma, int n_before, int n_after, int n_div)
12756{
12757 int i;
12758 int n_param;
12759 int n_set;
12760 isl_local_space *ls;
12761
12762 if (n_div == 0)
12763 return 0;
12764
12765 ls = isl_aff_get_domain_local_space(ma->p[0]);
12766 if (!ls)
12767 return -1;
12768
12769 n_param = isl_local_space_dim(ls, isl_dim_param);
12770 n_set = isl_local_space_dim(ls, isl_dim_set);
12771 for (i = 0; i < n_div; ++i) {
12772 int o_bmap = 0, o_ls = 0;
12773
12774 isl_seq_cpy(bmap->div[i], ls->div->row[i], 1 + 1 + n_param);
12775 o_bmap += 1 + 1 + n_param;
12776 o_ls += 1 + 1 + n_param;
12777 isl_seq_clr(bmap->div[i] + o_bmap, n_before);
12778 o_bmap += n_before;
12779 isl_seq_cpy(bmap->div[i] + o_bmap,
12780 ls->div->row[i] + o_ls, n_set);
12781 o_bmap += n_set;
12782 o_ls += n_set;
12783 isl_seq_clr(bmap->div[i] + o_bmap, n_after);
12784 o_bmap += n_after;
12785 isl_seq_cpy(bmap->div[i] + o_bmap,
12786 ls->div->row[i] + o_ls, n_div);
12787 o_bmap += n_div;
12788 o_ls += n_div;
12789 isl_seq_clr(bmap->div[i] + o_bmap, bmap->n_div - n_div);
12790 if (isl_basic_map_add_div_constraints(bmap, i) < 0)
12791 goto error;
12792 }
12793
12794 isl_local_space_free(ls);
12795 return 0;
12796error:
12797 isl_local_space_free(ls);
12798 return -1;
12799}
12800
12801/* How many stride constraints does "ma" enforce?
12802 * That is, how many of the affine expressions have a denominator
12803 * different from one?
12804 */
12805static int multi_aff_strides(__isl_keep isl_multi_aff *ma)
12806{
12807 int i;
12808 int strides = 0;
12809
12810 for (i = 0; i < ma->n; ++i)
12811 if (!isl_int_is_one(ma->p[i]->v->el[0])(isl_sioimath_cmp_si(*(ma->p[i]->v->el[0]), 1) == 0))
12812 strides++;
12813
12814 return strides;
12815}
12816
12817/* For each affine expression in ma of the form
12818 *
12819 * x_i = (f_i y + h_i)/m_i
12820 *
12821 * with m_i different from one, add a constraint to "bmap"
12822 * of the form
12823 *
12824 * f_i y + h_i = m_i alpha_i
12825 *
12826 * with alpha_i an additional existentially quantified variable.
12827 *
12828 * The input variables of "ma" correspond to a subset of the variables
12829 * of "bmap". There are "n_before" variables in "bmap" before this
12830 * subset and "n_after" variables after this subset.
12831 * The integer divisions of the affine expressions in "ma" are assumed
12832 * to have been aligned. There are "n_div_ma" of them and
12833 * they appear first in "bmap", straight after the "n_after" variables.
12834 */
12835static __isl_give isl_basic_map *add_ma_strides(
12836 __isl_take isl_basic_map *bmap, __isl_keep isl_multi_aff *ma,
12837 int n_before, int n_after, int n_div_ma)
12838{
12839 int i, k;
12840 int div;
12841 int total;
12842 int n_param;
12843 int n_in;
12844
12845 total = isl_basic_map_total_dim(bmap);
12846 n_param = isl_multi_aff_dim(ma, isl_dim_param);
12847 n_in = isl_multi_aff_dim(ma, isl_dim_in);
12848 for (i = 0; i < ma->n; ++i) {
12849 int o_bmap = 0, o_ma = 1;
12850
12851 if (isl_int_is_one(ma->p[i]->v->el[0])(isl_sioimath_cmp_si(*(ma->p[i]->v->el[0]), 1) == 0))
12852 continue;
12853 div = isl_basic_map_alloc_div(bmap);
12854 k = isl_basic_map_alloc_equality(bmap);
12855 if (div < 0 || k < 0)
12856 goto error;
12857 isl_int_set_si(bmap->div[div][0], 0)isl_sioimath_set_si((bmap->div[div][0]), 0);
12858 isl_seq_cpy(bmap->eq[k] + o_bmap,
12859 ma->p[i]->v->el + o_ma, 1 + n_param);
12860 o_bmap += 1 + n_param;
12861 o_ma += 1 + n_param;
12862 isl_seq_clr(bmap->eq[k] + o_bmap, n_before);
12863 o_bmap += n_before;
12864 isl_seq_cpy(bmap->eq[k] + o_bmap,
12865 ma->p[i]->v->el + o_ma, n_in);
12866 o_bmap += n_in;
12867 o_ma += n_in;
12868 isl_seq_clr(bmap->eq[k] + o_bmap, n_after);
12869 o_bmap += n_after;
12870 isl_seq_cpy(bmap->eq[k] + o_bmap,
12871 ma->p[i]->v->el + o_ma, n_div_ma);
12872 o_bmap += n_div_ma;
12873 o_ma += n_div_ma;
12874 isl_seq_clr(bmap->eq[k] + o_bmap, 1 + total - o_bmap);
12875 isl_int_neg(bmap->eq[k][1 + total], ma->p[i]->v->el[0])isl_sioimath_neg((bmap->eq[k][1 + total]), *(ma->p[i]->
v->el[0]))
;
12876 total++;
12877 }
12878
12879 return bmap;
12880error:
12881 isl_basic_map_free(bmap);
12882 return NULL((void*)0);
12883}
12884
12885/* Replace the domain or range space (depending on "type) of "space" by "set".
12886 */
12887static __isl_give isl_space *isl_space_set(__isl_take isl_space *space,
12888 enum isl_dim_type type, __isl_take isl_space *set)
12889{
12890 if (type == isl_dim_in) {
12891 space = isl_space_range(space);
12892 space = isl_space_map_from_domain_and_range(set, space);
12893 } else {
12894 space = isl_space_domain(space);
12895 space = isl_space_map_from_domain_and_range(space, set);
12896 }
12897
12898 return space;
12899}
12900
12901/* Compute the preimage of the domain or range (depending on "type")
12902 * of "bmap" under the function represented by "ma".
12903 * In other words, plug in "ma" in the domain or range of "bmap".
12904 * The result is a basic map that lives in the same space as "bmap"
12905 * except that the domain or range has been replaced by
12906 * the domain space of "ma".
12907 *
12908 * If bmap is represented by
12909 *
12910 * A(p) + S u + B x + T v + C(divs) >= 0,
12911 *
12912 * where u and x are input and output dimensions if type == isl_dim_out
12913 * while x and v are input and output dimensions if type == isl_dim_in,
12914 * and ma is represented by
12915 *
12916 * x = D(p) + F(y) + G(divs')
12917 *
12918 * then the result is
12919 *
12920 * A(p) + B D(p) + S u + B F(y) + T v + B G(divs') + C(divs) >= 0
12921 *
12922 * The divs in the input set are similarly adjusted.
12923 * In particular
12924 *
12925 * floor((a_i(p) + s u + b_i x + t v + c_i(divs))/n_i)
12926 *
12927 * becomes
12928 *
12929 * floor((a_i(p) + b_i D(p) + s u + b_i F(y) + t v +
12930 * B_i G(divs') + c_i(divs))/n_i)
12931 *
12932 * If bmap is not a rational map and if F(y) involves any denominators
12933 *
12934 * x_i = (f_i y + h_i)/m_i
12935 *
12936 * then additional constraints are added to ensure that we only
12937 * map back integer points. That is we enforce
12938 *
12939 * f_i y + h_i = m_i alpha_i
12940 *
12941 * with alpha_i an additional existentially quantified variable.
12942 *
12943 * We first copy over the divs from "ma".
12944 * Then we add the modified constraints and divs from "bmap".
12945 * Finally, we add the stride constraints, if needed.
12946 */
12947__isl_give isl_basic_map *isl_basic_map_preimage_multi_aff(
12948 __isl_take isl_basic_map *bmap, enum isl_dim_type type,
12949 __isl_take isl_multi_aff *ma)
12950{
12951 int i, k;
12952 isl_space *space;
12953 isl_basic_map *res = NULL((void*)0);
12954 int n_before, n_after, n_div_bmap, n_div_ma;
12955 isl_int f, c1, c2, g;
12956 isl_bool rational;
12957 int strides;
12958
12959 isl_int_init(f)isl_sioimath_init((f));
12960 isl_int_init(c1)isl_sioimath_init((c1));
12961 isl_int_init(c2)isl_sioimath_init((c2));
12962 isl_int_init(g)isl_sioimath_init((g));
12963
12964 ma = isl_multi_aff_align_divs(ma);
12965 if (!bmap || !ma)
12966 goto error;
12967 if (check_basic_map_compatible_range_multi_aff(bmap, type, ma) < 0)
12968 goto error;
12969
12970 if (type == isl_dim_in) {
12971 n_before = 0;
12972 n_after = isl_basic_map_dim(bmap, isl_dim_out);
12973 } else {
12974 n_before = isl_basic_map_dim(bmap, isl_dim_in);
12975 n_after = 0;
12976 }
12977 n_div_bmap = isl_basic_map_dim(bmap, isl_dim_div);
12978 n_div_ma = ma->n ? isl_aff_dim(ma->p[0], isl_dim_div) : 0;
12979
12980 space = isl_multi_aff_get_domain_space(ma);
12981 space = isl_space_set(isl_basic_map_get_space(bmap), type, space);
12982 rational = isl_basic_map_is_rational(bmap);
12983 strides = rational ? 0 : multi_aff_strides(ma);
12984 res = isl_basic_map_alloc_space(space, n_div_ma + n_div_bmap + strides,
12985 bmap->n_eq + strides, bmap->n_ineq + 2 * n_div_ma);
12986 if (rational)
12987 res = isl_basic_map_set_rational(res);
12988
12989 for (i = 0; i < n_div_ma + n_div_bmap; ++i)
12990 if (isl_basic_map_alloc_div(res) < 0)
12991 goto error;
12992
12993 if (set_ma_divs(res, ma, n_before, n_after, n_div_ma) < 0)
12994 goto error;
12995
12996 for (i = 0; i < bmap->n_eq; ++i) {
12997 k = isl_basic_map_alloc_equality(res);
12998 if (k < 0)
12999 goto error;
13000 isl_seq_preimage(res->eq[k], bmap->eq[i], ma, n_before,
13001 n_after, n_div_ma, n_div_bmap, f, c1, c2, g, 0);
13002 }
13003
13004 for (i = 0; i < bmap->n_ineq; ++i) {
13005 k = isl_basic_map_alloc_inequality(res);
13006 if (k < 0)
13007 goto error;
13008 isl_seq_preimage(res->ineq[k], bmap->ineq[i], ma, n_before,
13009 n_after, n_div_ma, n_div_bmap, f, c1, c2, g, 0);
13010 }
13011
13012 for (i = 0; i < bmap->n_div; ++i) {
13013 if (isl_int_is_zero(bmap->div[i][0])(isl_sioimath_sgn(*(bmap->div[i][0])) == 0)) {
13014 isl_int_set_si(res->div[n_div_ma + i][0], 0)isl_sioimath_set_si((res->div[n_div_ma + i][0]), 0);
13015 continue;
13016 }
13017 isl_seq_preimage(res->div[n_div_ma + i], bmap->div[i], ma,
13018 n_before, n_after, n_div_ma, n_div_bmap,
13019 f, c1, c2, g, 1);
13020 }
13021
13022 if (strides)
13023 res = add_ma_strides(res, ma, n_before, n_after, n_div_ma);
13024
13025 isl_int_clear(f)isl_sioimath_clear((f));
13026 isl_int_clear(c1)isl_sioimath_clear((c1));
13027 isl_int_clear(c2)isl_sioimath_clear((c2));
13028 isl_int_clear(g)isl_sioimath_clear((g));
13029 isl_basic_map_free(bmap);
13030 isl_multi_aff_free(ma);
13031 res = isl_basic_map_simplify(res);
13032 return isl_basic_map_finalize(res);
13033error:
13034 isl_int_clear(f)isl_sioimath_clear((f));
13035 isl_int_clear(c1)isl_sioimath_clear((c1));
13036 isl_int_clear(c2)isl_sioimath_clear((c2));
13037 isl_int_clear(g)isl_sioimath_clear((g));
13038 isl_basic_map_free(bmap);
13039 isl_multi_aff_free(ma);
13040 isl_basic_map_free(res);
13041 return NULL((void*)0);
13042}
13043
13044/* Compute the preimage of "bset" under the function represented by "ma".
13045 * In other words, plug in "ma" in "bset". The result is a basic set
13046 * that lives in the domain space of "ma".
13047 */
13048__isl_give isl_basic_setisl_basic_map *isl_basic_set_preimage_multi_aff(
13049 __isl_take isl_basic_setisl_basic_map *bset, __isl_take isl_multi_aff *ma)
13050{
13051 return isl_basic_map_preimage_multi_aff(bset, isl_dim_set, ma);
13052}
13053
13054/* Compute the preimage of the domain of "bmap" under the function
13055 * represented by "ma".
13056 * In other words, plug in "ma" in the domain of "bmap".
13057 * The result is a basic map that lives in the same space as "bmap"
13058 * except that the domain has been replaced by the domain space of "ma".
13059 */
13060__isl_give isl_basic_map *isl_basic_map_preimage_domain_multi_aff(
13061 __isl_take isl_basic_map *bmap, __isl_take isl_multi_aff *ma)
13062{
13063 return isl_basic_map_preimage_multi_aff(bmap, isl_dim_in, ma);
13064}
13065
13066/* Compute the preimage of the range of "bmap" under the function
13067 * represented by "ma".
13068 * In other words, plug in "ma" in the range of "bmap".
13069 * The result is a basic map that lives in the same space as "bmap"
13070 * except that the range has been replaced by the domain space of "ma".
13071 */
13072__isl_give isl_basic_map *isl_basic_map_preimage_range_multi_aff(
13073 __isl_take isl_basic_map *bmap, __isl_take isl_multi_aff *ma)
13074{
13075 return isl_basic_map_preimage_multi_aff(bmap, isl_dim_out, ma);
13076}
13077
13078/* Check if the range of "ma" is compatible with the domain or range
13079 * (depending on "type") of "map".
13080 * Return isl_stat_error if anything is wrong.
13081 */
13082static isl_stat check_map_compatible_range_multi_aff(
13083 __isl_keep isl_map *map, enum isl_dim_type type,
13084 __isl_keep isl_multi_aff *ma)
13085{
13086 isl_bool m;
13087 isl_space *ma_space;
13088
13089 ma_space = isl_multi_aff_get_space(ma);
13090 m = isl_space_tuple_is_equal(map->dim, type, ma_space, isl_dim_out);
13091 isl_space_free(ma_space);
13092 if (m < 0)
13093 return isl_stat_error;
13094 if (!m)
13095 isl_die(isl_map_get_ctx(map), isl_error_invalid,do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "spaces don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 13096); return isl_stat_error; } while (0)
13096 "spaces don't match", return isl_stat_error)do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "spaces don't match", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 13096); return isl_stat_error; } while (0)
;
13097 return isl_stat_ok;
13098}
13099
13100/* Compute the preimage of the domain or range (depending on "type")
13101 * of "map" under the function represented by "ma".
13102 * In other words, plug in "ma" in the domain or range of "map".
13103 * The result is a map that lives in the same space as "map"
13104 * except that the domain or range has been replaced by
13105 * the domain space of "ma".
13106 *
13107 * The parameters are assumed to have been aligned.
13108 */
13109static __isl_give isl_map *map_preimage_multi_aff(__isl_take isl_map *map,
13110 enum isl_dim_type type, __isl_take isl_multi_aff *ma)
13111{
13112 int i;
13113 isl_space *space;
13114
13115 map = isl_map_cow(map);
13116 ma = isl_multi_aff_align_divs(ma);
13117 if (!map || !ma)
13118 goto error;
13119 if (check_map_compatible_range_multi_aff(map, type, ma) < 0)
13120 goto error;
13121
13122 for (i = 0; i < map->n; ++i) {
13123 map->p[i] = isl_basic_map_preimage_multi_aff(map->p[i], type,
13124 isl_multi_aff_copy(ma));
13125 if (!map->p[i])
13126 goto error;
13127 }
13128
13129 space = isl_multi_aff_get_domain_space(ma);
13130 space = isl_space_set(isl_map_get_space(map), type, space);
13131
13132 isl_space_free(map->dim);
13133 map->dim = space;
13134 if (!map->dim)
13135 goto error;
13136
13137 isl_multi_aff_free(ma);
13138 if (map->n > 1)
13139 ISL_F_CLR(map, ISL_MAP_DISJOINT)(((map)->flags) &= ~((1 << 0)));
13140 ISL_F_CLR(map, ISL_SET_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
13141 return map;
13142error:
13143 isl_multi_aff_free(ma);
13144 isl_map_free(map);
13145 return NULL((void*)0);
13146}
13147
13148/* Compute the preimage of the domain or range (depending on "type")
13149 * of "map" under the function represented by "ma".
13150 * In other words, plug in "ma" in the domain or range of "map".
13151 * The result is a map that lives in the same space as "map"
13152 * except that the domain or range has been replaced by
13153 * the domain space of "ma".
13154 */
13155__isl_give isl_map *isl_map_preimage_multi_aff(__isl_take isl_map *map,
13156 enum isl_dim_type type, __isl_take isl_multi_aff *ma)
13157{
13158 isl_bool aligned;
13159
13160 if (!map || !ma)
13161 goto error;
13162
13163 aligned = isl_map_space_has_equal_params(map, ma->space);
13164 if (aligned < 0)
13165 goto error;
13166 if (aligned)
13167 return map_preimage_multi_aff(map, type, ma);
13168
13169 if (isl_map_check_named_params(map) < 0)
13170 goto error;
13171 if (!isl_space_has_named_params(ma->space))
13172 isl_die(map->ctx, isl_error_invalid,do { isl_handle_error(map->ctx, isl_error_invalid, "unaligned unnamed parameters"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 13173); goto error; } while (0)
13173 "unaligned unnamed parameters", goto error)do { isl_handle_error(map->ctx, isl_error_invalid, "unaligned unnamed parameters"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 13173); goto error; } while (0)
;
13174 map = isl_map_align_params(map, isl_multi_aff_get_space(ma));
13175 ma = isl_multi_aff_align_params(ma, isl_map_get_space(map));
13176
13177 return map_preimage_multi_aff(map, type, ma);
13178error:
13179 isl_multi_aff_free(ma);
13180 return isl_map_free(map);
13181}
13182
13183/* Compute the preimage of "set" under the function represented by "ma".
13184 * In other words, plug in "ma" in "set". The result is a set
13185 * that lives in the domain space of "ma".
13186 */
13187__isl_give isl_setisl_map *isl_set_preimage_multi_aff(__isl_take isl_setisl_map *set,
13188 __isl_take isl_multi_aff *ma)
13189{
13190 return isl_map_preimage_multi_aff(set, isl_dim_set, ma);
13191}
13192
13193/* Compute the preimage of the domain of "map" under the function
13194 * represented by "ma".
13195 * In other words, plug in "ma" in the domain of "map".
13196 * The result is a map that lives in the same space as "map"
13197 * except that the domain has been replaced by the domain space of "ma".
13198 */
13199__isl_give isl_map *isl_map_preimage_domain_multi_aff(__isl_take isl_map *map,
13200 __isl_take isl_multi_aff *ma)
13201{
13202 return isl_map_preimage_multi_aff(map, isl_dim_in, ma);
13203}
13204
13205/* Compute the preimage of the range of "map" under the function
13206 * represented by "ma".
13207 * In other words, plug in "ma" in the range of "map".
13208 * The result is a map that lives in the same space as "map"
13209 * except that the range has been replaced by the domain space of "ma".
13210 */
13211__isl_give isl_map *isl_map_preimage_range_multi_aff(__isl_take isl_map *map,
13212 __isl_take isl_multi_aff *ma)
13213{
13214 return isl_map_preimage_multi_aff(map, isl_dim_out, ma);
13215}
13216
13217/* Compute the preimage of "map" under the function represented by "pma".
13218 * In other words, plug in "pma" in the domain or range of "map".
13219 * The result is a map that lives in the same space as "map",
13220 * except that the space of type "type" has been replaced by
13221 * the domain space of "pma".
13222 *
13223 * The parameters of "map" and "pma" are assumed to have been aligned.
13224 */
13225static __isl_give isl_map *isl_map_preimage_pw_multi_aff_aligned(
13226 __isl_take isl_map *map, enum isl_dim_type type,
13227 __isl_take isl_pw_multi_aff *pma)
13228{
13229 int i;
13230 isl_map *res;
13231
13232 if (!pma)
13233 goto error;
13234
13235 if (pma->n == 0) {
13236 isl_pw_multi_aff_free(pma);
13237 res = isl_map_empty(isl_map_get_space(map));
13238 isl_map_free(map);
13239 return res;
13240 }
13241
13242 res = isl_map_preimage_multi_aff(isl_map_copy(map), type,
13243 isl_multi_aff_copy(pma->p[0].maff));
13244 if (type == isl_dim_in)
13245 res = isl_map_intersect_domain(res,
13246 isl_map_copy(pma->p[0].set));
13247 else
13248 res = isl_map_intersect_range(res,
13249 isl_map_copy(pma->p[0].set));
13250
13251 for (i = 1; i < pma->n; ++i) {
13252 isl_map *res_i;
13253
13254 res_i = isl_map_preimage_multi_aff(isl_map_copy(map), type,
13255 isl_multi_aff_copy(pma->p[i].maff));
13256 if (type == isl_dim_in)
13257 res_i = isl_map_intersect_domain(res_i,
13258 isl_map_copy(pma->p[i].set));
13259 else
13260 res_i = isl_map_intersect_range(res_i,
13261 isl_map_copy(pma->p[i].set));
13262 res = isl_map_union(res, res_i);
13263 }
13264
13265 isl_pw_multi_aff_free(pma);
13266 isl_map_free(map);
13267 return res;
13268error:
13269 isl_pw_multi_aff_free(pma);
13270 isl_map_free(map);
13271 return NULL((void*)0);
13272}
13273
13274/* Compute the preimage of "map" under the function represented by "pma".
13275 * In other words, plug in "pma" in the domain or range of "map".
13276 * The result is a map that lives in the same space as "map",
13277 * except that the space of type "type" has been replaced by
13278 * the domain space of "pma".
13279 */
13280__isl_give isl_map *isl_map_preimage_pw_multi_aff(__isl_take isl_map *map,
13281 enum isl_dim_type type, __isl_take isl_pw_multi_aff *pma)
13282{
13283 isl_bool aligned;
13284
13285 if (!map || !pma)
13286 goto error;
13287
13288 aligned = isl_map_space_has_equal_params(map, pma->dim);
13289 if (aligned < 0)
13290 goto error;
13291 if (aligned)
13292 return isl_map_preimage_pw_multi_aff_aligned(map, type, pma);
13293
13294 if (isl_map_check_named_params(map) < 0)
13295 goto error;
13296 if (!isl_space_has_named_params(pma->dim))
13297 isl_die(map->ctx, isl_error_invalid,do { isl_handle_error(map->ctx, isl_error_invalid, "unaligned unnamed parameters"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 13298); goto error; } while (0)
13298 "unaligned unnamed parameters", goto error)do { isl_handle_error(map->ctx, isl_error_invalid, "unaligned unnamed parameters"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 13298); goto error; } while (0)
;
13299 map = isl_map_align_params(map, isl_pw_multi_aff_get_space(pma));
13300 pma = isl_pw_multi_aff_align_params(pma, isl_map_get_space(map));
13301
13302 return isl_map_preimage_pw_multi_aff_aligned(map, type, pma);
13303error:
13304 isl_pw_multi_aff_free(pma);
13305 return isl_map_free(map);
13306}
13307
13308/* Compute the preimage of "set" under the function represented by "pma".
13309 * In other words, plug in "pma" in "set". The result is a set
13310 * that lives in the domain space of "pma".
13311 */
13312__isl_give isl_setisl_map *isl_set_preimage_pw_multi_aff(__isl_take isl_setisl_map *set,
13313 __isl_take isl_pw_multi_aff *pma)
13314{
13315 return isl_map_preimage_pw_multi_aff(set, isl_dim_set, pma);
13316}
13317
13318/* Compute the preimage of the domain of "map" under the function
13319 * represented by "pma".
13320 * In other words, plug in "pma" in the domain of "map".
13321 * The result is a map that lives in the same space as "map",
13322 * except that domain space has been replaced by the domain space of "pma".
13323 */
13324__isl_give isl_map *isl_map_preimage_domain_pw_multi_aff(
13325 __isl_take isl_map *map, __isl_take isl_pw_multi_aff *pma)
13326{
13327 return isl_map_preimage_pw_multi_aff(map, isl_dim_in, pma);
13328}
13329
13330/* Compute the preimage of the range of "map" under the function
13331 * represented by "pma".
13332 * In other words, plug in "pma" in the range of "map".
13333 * The result is a map that lives in the same space as "map",
13334 * except that range space has been replaced by the domain space of "pma".
13335 */
13336__isl_give isl_map *isl_map_preimage_range_pw_multi_aff(
13337 __isl_take isl_map *map, __isl_take isl_pw_multi_aff *pma)
13338{
13339 return isl_map_preimage_pw_multi_aff(map, isl_dim_out, pma);
13340}
13341
13342/* Compute the preimage of "map" under the function represented by "mpa".
13343 * In other words, plug in "mpa" in the domain or range of "map".
13344 * The result is a map that lives in the same space as "map",
13345 * except that the space of type "type" has been replaced by
13346 * the domain space of "mpa".
13347 *
13348 * If the map does not involve any constraints that refer to the
13349 * dimensions of the substituted space, then the only possible
13350 * effect of "mpa" on the map is to map the space to a different space.
13351 * We create a separate isl_multi_aff to effectuate this change
13352 * in order to avoid spurious splitting of the map along the pieces
13353 * of "mpa".
13354 */
13355__isl_give isl_map *isl_map_preimage_multi_pw_aff(__isl_take isl_map *map,
13356 enum isl_dim_type type, __isl_take isl_multi_pw_aff *mpa)
13357{
13358 int n;
13359 isl_pw_multi_aff *pma;
13360
13361 if (!map || !mpa)
13362 goto error;
13363
13364 n = isl_map_dim(map, type);
13365 if (!isl_map_involves_dims(map, type, 0, n)) {
13366 isl_space *space;
13367 isl_multi_aff *ma;
13368
13369 space = isl_multi_pw_aff_get_space(mpa);
13370 isl_multi_pw_aff_free(mpa);
13371 ma = isl_multi_aff_zero(space);
13372 return isl_map_preimage_multi_aff(map, type, ma);
13373 }
13374
13375 pma = isl_pw_multi_aff_from_multi_pw_aff(mpa);
13376 return isl_map_preimage_pw_multi_aff(map, type, pma);
13377error:
13378 isl_map_free(map);
13379 isl_multi_pw_aff_free(mpa);
13380 return NULL((void*)0);
13381}
13382
13383/* Compute the preimage of "map" under the function represented by "mpa".
13384 * In other words, plug in "mpa" in the domain "map".
13385 * The result is a map that lives in the same space as "map",
13386 * except that domain space has been replaced by the domain space of "mpa".
13387 */
13388__isl_give isl_map *isl_map_preimage_domain_multi_pw_aff(
13389 __isl_take isl_map *map, __isl_take isl_multi_pw_aff *mpa)
13390{
13391 return isl_map_preimage_multi_pw_aff(map, isl_dim_in, mpa);
13392}
13393
13394/* Compute the preimage of "set" by the function represented by "mpa".
13395 * In other words, plug in "mpa" in "set".
13396 */
13397__isl_give isl_setisl_map *isl_set_preimage_multi_pw_aff(__isl_take isl_setisl_map *set,
13398 __isl_take isl_multi_pw_aff *mpa)
13399{
13400 return isl_map_preimage_multi_pw_aff(set, isl_dim_set, mpa);
13401}
13402
13403/* Return a copy of the equality constraints of "bset" as a matrix.
13404 */
13405__isl_give isl_mat *isl_basic_set_extract_equalities(
13406 __isl_keep isl_basic_setisl_basic_map *bset)
13407{
13408 isl_ctx *ctx;
13409 unsigned total;
13410
13411 if (!bset)
13412 return NULL((void*)0);
13413
13414 ctx = isl_basic_set_get_ctx(bset);
13415 total = 1 + isl_basic_set_dim(bset, isl_dim_all);
13416 return isl_mat_sub_alloc6(ctx, bset->eq, 0, bset->n_eq, 0, total);
13417}
13418
13419/* Are the "n" "coefficients" starting at "first" of the integer division
13420 * expressions at position "pos1" in "bmap1" and "pos2" in "bmap2" equal
13421 * to each other?
13422 * The "coefficient" at position 0 is the denominator.
13423 * The "coefficient" at position 1 is the constant term.
13424 */
13425isl_bool isl_basic_map_equal_div_expr_part(__isl_keep isl_basic_map *bmap1,
13426 int pos1, __isl_keep isl_basic_map *bmap2, int pos2,
13427 unsigned first, unsigned n)
13428{
13429 if (isl_basic_map_check_range(bmap1, isl_dim_div, pos1, 1) < 0)
13430 return isl_bool_error;
13431 if (isl_basic_map_check_range(bmap2, isl_dim_div, pos2, 1) < 0)
13432 return isl_bool_error;
13433 return isl_seq_eq(bmap1->div[pos1] + first,
13434 bmap2->div[pos2] + first, n);
13435}
13436
13437/* Are the integer division expressions at position "pos1" in "bmap1" and
13438 * "pos2" in "bmap2" equal to each other, except that the constant terms
13439 * are different?
13440 */
13441isl_bool isl_basic_map_equal_div_expr_except_constant(
13442 __isl_keep isl_basic_map *bmap1, int pos1,
13443 __isl_keep isl_basic_map *bmap2, int pos2)
13444{
13445 isl_bool equal;
13446 unsigned total;
13447
13448 if (!bmap1 || !bmap2)
13449 return isl_bool_error;
13450 total = isl_basic_map_total_dim(bmap1);
13451 if (total != isl_basic_map_total_dim(bmap2))
13452 isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid,do { isl_handle_error(isl_basic_map_get_ctx(bmap1), isl_error_invalid
, "incomparable div expressions", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 13453); return isl_bool_error; } while (0)
13453 "incomparable div expressions", return isl_bool_error)do { isl_handle_error(isl_basic_map_get_ctx(bmap1), isl_error_invalid
, "incomparable div expressions", "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 13453); return isl_bool_error; } while (0)
;
13454 equal = isl_basic_map_equal_div_expr_part(bmap1, pos1, bmap2, pos2,
13455 0, 1);
13456 if (equal < 0 || !equal)
13457 return equal;
13458 equal = isl_basic_map_equal_div_expr_part(bmap1, pos1, bmap2, pos2,
13459 1, 1);
13460 if (equal < 0 || equal)
13461 return isl_bool_not(equal);
13462 return isl_basic_map_equal_div_expr_part(bmap1, pos1, bmap2, pos2,
13463 2, total);
13464}
13465
13466/* Replace the numerator of the constant term of the integer division
13467 * expression at position "div" in "bmap" by "value".
13468 * The caller guarantees that this does not change the meaning
13469 * of the input.
13470 */
13471__isl_give isl_basic_map *isl_basic_map_set_div_expr_constant_num_si_inplace(
13472 __isl_take isl_basic_map *bmap, int div, int value)
13473{
13474 if (isl_basic_map_check_range(bmap, isl_dim_div, div, 1) < 0)
13475 return isl_basic_map_free(bmap);
13476
13477 isl_int_set_si(bmap->div[div][1], value)isl_sioimath_set_si((bmap->div[div][1]), value);
13478
13479 return bmap;
13480}
13481
13482/* Is the point "inner" internal to inequality constraint "ineq"
13483 * of "bset"?
13484 * The point is considered to be internal to the inequality constraint,
13485 * if it strictly lies on the positive side of the inequality constraint,
13486 * or if it lies on the constraint and the constraint is lexico-positive.
13487 */
13488static isl_bool is_internal(__isl_keep isl_vec *inner,
13489 __isl_keep isl_basic_setisl_basic_map *bset, int ineq)
13490{
13491 isl_ctx *ctx;
13492 int pos;
13493 unsigned total;
13494
13495 if (!inner || !bset)
13496 return isl_bool_error;
13497
13498 ctx = isl_basic_set_get_ctx(bset);
13499 isl_seq_inner_product(inner->el, bset->ineq[ineq], inner->size,
13500 &ctx->normalize_gcd);
13501 if (!isl_int_is_zero(ctx->normalize_gcd)(isl_sioimath_sgn(*(ctx->normalize_gcd)) == 0))
13502 return isl_int_is_nonneg(ctx->normalize_gcd)(isl_sioimath_sgn(*(ctx->normalize_gcd)) >= 0);
13503
13504 total = isl_basic_set_dim(bset, isl_dim_all);
13505 pos = isl_seq_first_non_zero(bset->ineq[ineq] + 1, total);
13506 return isl_int_is_pos(bset->ineq[ineq][1 + pos])(isl_sioimath_sgn(*(bset->ineq[ineq][1 + pos])) > 0);
13507}
13508
13509/* Tighten the inequality constraints of "bset" that are outward with respect
13510 * to the point "vec".
13511 * That is, tighten the constraints that are not satisfied by "vec".
13512 *
13513 * "vec" is a point internal to some superset S of "bset" that is used
13514 * to make the subsets of S disjoint, by tightening one half of the constraints
13515 * that separate two subsets. In particular, the constraints of S
13516 * are all satisfied by "vec" and should not be tightened.
13517 * Of the internal constraints, those that have "vec" on the outside
13518 * are tightened. The shared facet is included in the adjacent subset
13519 * with the opposite constraint.
13520 * For constraints that saturate "vec", this criterion cannot be used
13521 * to determine which of the two sides should be tightened.
13522 * Instead, the sign of the first non-zero coefficient is used
13523 * to make this choice. Note that this second criterion is never used
13524 * on the constraints of S since "vec" is interior to "S".
13525 */
13526__isl_give isl_basic_setisl_basic_map *isl_basic_set_tighten_outward(
13527 __isl_take isl_basic_setisl_basic_map *bset, __isl_keep isl_vec *vec)
13528{
13529 int j;
13530
13531 bset = isl_basic_set_cow(bset);
13532 if (!bset)
13533 return NULL((void*)0);
13534 for (j = 0; j < bset->n_ineq; ++j) {
13535 isl_bool internal;
13536
13537 internal = is_internal(vec, bset, j);
13538 if (internal < 0)
13539 return isl_basic_set_free(bset);
13540 if (internal)
13541 continue;
13542 isl_int_sub_ui(bset->ineq[j][0], bset->ineq[j][0], 1)isl_sioimath_sub_ui((bset->ineq[j][0]), *(bset->ineq[j]
[0]), 1)
;
13543 }
13544
13545 return bset;
13546}
13547
13548/* Replace the variables x of type "type" starting at "first" in "bmap"
13549 * by x' with x = M x' with M the matrix trans.
13550 * That is, replace the corresponding coefficients c by c M.
13551 *
13552 * The transformation matrix should be a square matrix.
13553 */
13554__isl_give isl_basic_map *isl_basic_map_transform_dims(
13555 __isl_take isl_basic_map *bmap, enum isl_dim_type type, unsigned first,
13556 __isl_take isl_mat *trans)
13557{
13558 unsigned pos;
13559
13560 bmap = isl_basic_map_cow(bmap);
13561 if (!bmap || !trans)
13562 goto error;
13563
13564 if (trans->n_row != trans->n_col)
13565 isl_die(trans->ctx, isl_error_invalid,do { isl_handle_error(trans->ctx, isl_error_invalid, "expecting square transformation matrix"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 13566); goto error; } while (0)
13566 "expecting square transformation matrix", goto error)do { isl_handle_error(trans->ctx, isl_error_invalid, "expecting square transformation matrix"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 13566); goto error; } while (0)
;
13567 if (first + trans->n_row > isl_basic_map_dim(bmap, type))
13568 isl_die(trans->ctx, isl_error_invalid,do { isl_handle_error(trans->ctx, isl_error_invalid, "oversized transformation matrix"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 13569); goto error; } while (0)
13569 "oversized transformation matrix", goto error)do { isl_handle_error(trans->ctx, isl_error_invalid, "oversized transformation matrix"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/polly/lib/External/isl/isl_map.c"
, 13569); goto error; } while (0)
;
13570
13571 pos = isl_basic_map_offset(bmap, type) + first;
13572
13573 if (isl_mat_sub_transform(bmap->eq, bmap->n_eq, pos,
13574 isl_mat_copy(trans)) < 0)
13575 goto error;
13576 if (isl_mat_sub_transform(bmap->ineq, bmap->n_ineq, pos,
13577 isl_mat_copy(trans)) < 0)
13578 goto error;
13579 if (isl_mat_sub_transform(bmap->div, bmap->n_div, 1 + pos,
13580 isl_mat_copy(trans)) < 0)
13581 goto error;
13582
13583 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
13584 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS)(((bmap)->flags) &= ~((1 << 6)));
13585
13586 isl_mat_free(trans);
13587 return bmap;
13588error:
13589 isl_mat_free(trans);
13590 isl_basic_map_free(bmap);
13591 return NULL((void*)0);
13592}
13593
13594/* Replace the variables x of type "type" starting at "first" in "bset"
13595 * by x' with x = M x' with M the matrix trans.
13596 * That is, replace the corresponding coefficients c by c M.
13597 *
13598 * The transformation matrix should be a square matrix.
13599 */
13600__isl_give isl_basic_setisl_basic_map *isl_basic_set_transform_dims(
13601 __isl_take isl_basic_setisl_basic_map *bset, enum isl_dim_type type, unsigned first,
13602 __isl_take isl_mat *trans)
13603{
13604 return isl_basic_map_transform_dims(bset, type, first, trans);
13605}