Bug Summary

File:tools/polly/lib/External/isl/isl_map.c
Warning:line 12766, column 3
Value stored to 'o_ma' is never read

Annotated Source Code

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#include <isl/deprecated/map_int.h>
47#include <isl/deprecated/set_int.h>
48
49#include <bset_to_bmap.c>
50#include <bset_from_bmap.c>
51#include <set_to_map.c>
52#include <set_from_map.c>
53
54static unsigned n(__isl_keep isl_space *dim, enum isl_dim_type type)
55{
56 switch (type) {
57 case isl_dim_param: return dim->nparam;
58 case isl_dim_in: return dim->n_in;
59 case isl_dim_out: return dim->n_out;
60 case isl_dim_all: return dim->nparam + dim->n_in + dim->n_out;
61 default: return 0;
62 }
63}
64
65static unsigned pos(__isl_keep isl_space *dim, enum isl_dim_type type)
66{
67 switch (type) {
68 case isl_dim_param: return 1;
69 case isl_dim_in: return 1 + dim->nparam;
70 case isl_dim_out: return 1 + dim->nparam + dim->n_in;
71 default: return 0;
72 }
73}
74
75unsigned isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
76 enum isl_dim_type type)
77{
78 if (!bmap)
79 return 0;
80 switch (type) {
81 case isl_dim_cst: return 1;
82 case isl_dim_param:
83 case isl_dim_in:
84 case isl_dim_out: return isl_space_dim(bmap->dim, type);
85 case isl_dim_div: return bmap->n_div;
86 case isl_dim_all: return isl_basic_map_total_dim(bmap);
87 default: return 0;
88 }
89}
90
91/* Return the space of "map".
92 */
93__isl_keep isl_space *isl_map_peek_space(__isl_keep const isl_map *map)
94{
95 return map ? map->dim : NULL((void*)0);
96}
97
98unsigned isl_map_dim(__isl_keep isl_map *map, enum isl_dim_type type)
99{
100 return map ? n(map->dim, type) : 0;
101}
102
103unsigned isl_set_dim(__isl_keep isl_setisl_map *set, enum isl_dim_type type)
104{
105 return set ? n(set->dim, type) : 0;
106}
107
108unsigned isl_basic_map_offset(struct isl_basic_map *bmap,
109 enum isl_dim_type type)
110{
111 isl_space *space;
112
113 if (!bmap)
114 return 0;
115
116 space = bmap->dim;
117 switch (type) {
118 case isl_dim_cst: return 0;
119 case isl_dim_param: return 1;
120 case isl_dim_in: return 1 + space->nparam;
121 case isl_dim_out: return 1 + space->nparam + space->n_in;
122 case isl_dim_div: return 1 + space->nparam + space->n_in +
123 space->n_out;
124 default: return 0;
125 }
126}
127
128unsigned isl_basic_set_offset(__isl_keep isl_basic_setisl_basic_map *bset,
129 enum isl_dim_type type)
130{
131 return isl_basic_map_offset(bset, type);
132}
133
134static unsigned map_offset(__isl_keep isl_map *map, enum isl_dim_type type)
135{
136 return pos(map->dim, type);
137}
138
139unsigned isl_basic_set_dim(__isl_keep isl_basic_setisl_basic_map *bset,
140 enum isl_dim_type type)
141{
142 return isl_basic_map_dim(bset, type);
143}
144
145unsigned isl_basic_set_n_dim(__isl_keep isl_basic_setisl_basic_map *bset)
146{
147 return isl_basic_set_dim(bset, isl_dim_set);
148}
149
150unsigned isl_basic_set_n_param(__isl_keep isl_basic_setisl_basic_map *bset)
151{
152 return isl_basic_set_dim(bset, isl_dim_param);
153}
154
155unsigned isl_basic_set_total_dim(__isl_keep const isl_basic_setisl_basic_map *bset)
156{
157 if (!bset)
158 return 0;
159 return isl_space_dim(bset->dim, isl_dim_all) + bset->n_div;
160}
161
162unsigned isl_set_n_dim(__isl_keep isl_setisl_map *set)
163{
164 return isl_set_dim(set, isl_dim_set);
165}
166
167unsigned isl_set_n_param(__isl_keep isl_setisl_map *set)
168{
169 return isl_set_dim(set, isl_dim_param);
170}
171
172unsigned isl_basic_map_n_in(__isl_keep const isl_basic_map *bmap)
173{
174 return bmap ? bmap->dim->n_in : 0;
175}
176
177unsigned isl_basic_map_n_out(__isl_keep const isl_basic_map *bmap)
178{
179 return bmap ? bmap->dim->n_out : 0;
180}
181
182unsigned isl_basic_map_n_param(__isl_keep const isl_basic_map *bmap)
183{
184 return bmap ? bmap->dim->nparam : 0;
185}
186
187unsigned isl_basic_map_n_div(__isl_keep const isl_basic_map *bmap)
188{
189 return bmap ? bmap->n_div : 0;
190}
191
192unsigned isl_basic_map_total_dim(__isl_keep const isl_basic_map *bmap)
193{
194 return bmap ? isl_space_dim(bmap->dim, isl_dim_all) + bmap->n_div : 0;
195}
196
197unsigned isl_map_n_in(__isl_keep const isl_map *map)
198{
199 return map ? map->dim->n_in : 0;
200}
201
202unsigned isl_map_n_out(__isl_keep const isl_map *map)
203{
204 return map ? map->dim->n_out : 0;
205}
206
207unsigned isl_map_n_param(__isl_keep const isl_map *map)
208{
209 return map ? map->dim->nparam : 0;
210}
211
212/* Do "bmap1" and "bmap2" have the same parameters?
213 */
214static isl_bool isl_basic_map_has_equal_params(__isl_keep isl_basic_map *bmap1,
215 __isl_keep isl_basic_map *bmap2)
216{
217 isl_space *space1, *space2;
218
219 space1 = isl_basic_map_peek_space(bmap1);
220 space2 = isl_basic_map_peek_space(bmap2);
221 return isl_space_has_equal_params(space1, space2);
222}
223
224/* Do "map1" and "map2" have the same parameters?
225 */
226isl_bool isl_map_has_equal_params(__isl_keep isl_map *map1,
227 __isl_keep isl_map *map2)
228{
229 isl_space *space1, *space2;
230
231 space1 = isl_map_peek_space(map1);
232 space2 = isl_map_peek_space(map2);
233 return isl_space_has_equal_params(space1, space2);
234}
235
236/* Do "map" and "set" have the same parameters?
237 */
238static isl_bool isl_map_set_has_equal_params(__isl_keep isl_map *map,
239 __isl_keep isl_setisl_map *set)
240{
241 return isl_map_has_equal_params(map, set_to_map(set));
242}
243
244isl_bool isl_map_compatible_domain(__isl_keep isl_map *map,
245 __isl_keep isl_setisl_map *set)
246{
247 isl_bool m;
248 if (!map || !set)
249 return isl_bool_error;
250 m = isl_map_has_equal_params(map, set_to_map(set));
251 if (m < 0 || !m)
252 return m;
253 return isl_space_tuple_is_equal(map->dim, isl_dim_in,
254 set->dim, isl_dim_set);
255}
256
257isl_bool isl_basic_map_compatible_domain(__isl_keep isl_basic_map *bmap,
258 __isl_keep isl_basic_setisl_basic_map *bset)
259{
260 isl_bool m;
261 if (!bmap || !bset)
262 return isl_bool_error;
263 m = isl_basic_map_has_equal_params(bmap, bset_to_bmap(bset));
264 if (m < 0 || !m)
265 return m;
266 return isl_space_tuple_is_equal(bmap->dim, isl_dim_in,
267 bset->dim, isl_dim_set);
268}
269
270isl_bool isl_map_compatible_range(__isl_keep isl_map *map,
271 __isl_keep isl_setisl_map *set)
272{
273 isl_bool m;
274 if (!map || !set)
275 return isl_bool_error;
276 m = isl_map_has_equal_params(map, set_to_map(set));
277 if (m < 0 || !m)
278 return m;
279 return isl_space_tuple_is_equal(map->dim, isl_dim_out,
280 set->dim, isl_dim_set);
281}
282
283isl_bool isl_basic_map_compatible_range(__isl_keep isl_basic_map *bmap,
284 __isl_keep isl_basic_setisl_basic_map *bset)
285{
286 isl_bool m;
287 if (!bmap || !bset)
288 return isl_bool_error;
289 m = isl_basic_map_has_equal_params(bmap, bset_to_bmap(bset));
290 if (m < 0 || !m)
291 return m;
292 return isl_space_tuple_is_equal(bmap->dim, isl_dim_out,
293 bset->dim, isl_dim_set);
294}
295
296isl_ctx *isl_basic_map_get_ctx(__isl_keep isl_basic_map *bmap)
297{
298 return bmap ? bmap->ctx : NULL((void*)0);
299}
300
301isl_ctx *isl_basic_set_get_ctx(__isl_keep isl_basic_setisl_basic_map *bset)
302{
303 return bset ? bset->ctx : NULL((void*)0);
304}
305
306isl_ctx *isl_map_get_ctx(__isl_keep isl_map *map)
307{
308 return map ? map->ctx : NULL((void*)0);
309}
310
311isl_ctx *isl_set_get_ctx(__isl_keep isl_setisl_map *set)
312{
313 return set ? set->ctx : NULL((void*)0);
314}
315
316/* Return the space of "bmap".
317 */
318__isl_keep isl_space *isl_basic_map_peek_space(
319 __isl_keep const isl_basic_map *bmap)
320{
321 return bmap ? bmap->dim : NULL((void*)0);
322}
323
324/* Return the space of "bset".
325 */
326__isl_keep isl_space *isl_basic_set_peek_space(__isl_keep isl_basic_setisl_basic_map *bset)
327{
328 return isl_basic_map_peek_space(bset_to_bmap(bset));
329}
330
331__isl_give isl_space *isl_basic_map_get_space(__isl_keep isl_basic_map *bmap)
332{
333 return isl_space_copy(isl_basic_map_peek_space(bmap));
334}
335
336__isl_give isl_space *isl_basic_set_get_space(__isl_keep isl_basic_setisl_basic_map *bset)
337{
338 return isl_basic_map_get_space(bset_to_bmap(bset));
339}
340
341/* Extract the divs in "bmap" as a matrix.
342 */
343__isl_give isl_mat *isl_basic_map_get_divs(__isl_keep isl_basic_map *bmap)
344{
345 int i;
346 isl_ctx *ctx;
347 isl_mat *div;
348 unsigned total;
349 unsigned cols;
350
351 if (!bmap)
352 return NULL((void*)0);
353
354 ctx = isl_basic_map_get_ctx(bmap);
355 total = isl_space_dim(bmap->dim, isl_dim_all);
356 cols = 1 + 1 + total + bmap->n_div;
357 div = isl_mat_alloc(ctx, bmap->n_div, cols);
358 if (!div)
359 return NULL((void*)0);
360
361 for (i = 0; i < bmap->n_div; ++i)
362 isl_seq_cpy(div->row[i], bmap->div[i], cols);
363
364 return div;
365}
366
367/* Extract the divs in "bset" as a matrix.
368 */
369__isl_give isl_mat *isl_basic_set_get_divs(__isl_keep isl_basic_setisl_basic_map *bset)
370{
371 return isl_basic_map_get_divs(bset);
372}
373
374__isl_give isl_local_space *isl_basic_map_get_local_space(
375 __isl_keep isl_basic_map *bmap)
376{
377 isl_mat *div;
378
379 if (!bmap)
380 return NULL((void*)0);
381
382 div = isl_basic_map_get_divs(bmap);
383 return isl_local_space_alloc_div(isl_space_copy(bmap->dim), div);
384}
385
386__isl_give isl_local_space *isl_basic_set_get_local_space(
387 __isl_keep isl_basic_setisl_basic_map *bset)
388{
389 return isl_basic_map_get_local_space(bset);
390}
391
392/* For each known div d = floor(f/m), add the constraints
393 *
394 * f - m d >= 0
395 * -(f-(m-1)) + m d >= 0
396 *
397 * Do not finalize the result.
398 */
399static __isl_give isl_basic_map *add_known_div_constraints(
400 __isl_take isl_basic_map *bmap)
401{
402 int i;
403 unsigned n_div;
404
405 if (!bmap)
406 return NULL((void*)0);
407 n_div = isl_basic_map_dim(bmap, isl_dim_div);
408 if (n_div == 0)
409 return bmap;
410 bmap = isl_basic_map_cow(bmap);
411 bmap = isl_basic_map_extend_constraints(bmap, 0, 2 * n_div);
412 if (!bmap)
413 return NULL((void*)0);
414 for (i = 0; i < n_div; ++i) {
415 if (isl_int_is_zero(bmap->div[i][0])(isl_sioimath_sgn(*(bmap->div[i][0])) == 0))
416 continue;
417 if (isl_basic_map_add_div_constraints(bmap, i) < 0)
418 return isl_basic_map_free(bmap);
419 }
420
421 return bmap;
422}
423
424__isl_give isl_basic_map *isl_basic_map_from_local_space(
425 __isl_take isl_local_space *ls)
426{
427 int i;
428 int n_div;
429 isl_basic_map *bmap;
430
431 if (!ls)
432 return NULL((void*)0);
433
434 n_div = isl_local_space_dim(ls, isl_dim_div);
435 bmap = isl_basic_map_alloc_space(isl_local_space_get_space(ls),
436 n_div, 0, 2 * n_div);
437
438 for (i = 0; i < n_div; ++i)
439 if (isl_basic_map_alloc_div(bmap) < 0)
440 goto error;
441
442 for (i = 0; i < n_div; ++i)
443 isl_seq_cpy(bmap->div[i], ls->div->row[i], ls->div->n_col);
444 bmap = add_known_div_constraints(bmap);
445
446 isl_local_space_free(ls);
447 return bmap;
448error:
449 isl_local_space_free(ls);
450 isl_basic_map_free(bmap);
451 return NULL((void*)0);
452}
453
454__isl_give isl_basic_setisl_basic_map *isl_basic_set_from_local_space(
455 __isl_take isl_local_space *ls)
456{
457 return isl_basic_map_from_local_space(ls);
458}
459
460__isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map)
461{
462 return isl_space_copy(isl_map_peek_space(map));
463}
464
465__isl_give isl_space *isl_set_get_space(__isl_keep isl_setisl_map *set)
466{
467 if (!set)
468 return NULL((void*)0);
469 return isl_space_copy(set->dim);
470}
471
472__isl_give isl_basic_map *isl_basic_map_set_tuple_name(
473 __isl_take isl_basic_map *bmap, enum isl_dim_type type, const char *s)
474{
475 bmap = isl_basic_map_cow(bmap);
476 if (!bmap)
477 return NULL((void*)0);
478 bmap->dim = isl_space_set_tuple_name(bmap->dim, type, s);
479 if (!bmap->dim)
480 goto error;
481 bmap = isl_basic_map_finalize(bmap);
482 return bmap;
483error:
484 isl_basic_map_free(bmap);
485 return NULL((void*)0);
486}
487
488__isl_give isl_basic_setisl_basic_map *isl_basic_set_set_tuple_name(
489 __isl_take isl_basic_setisl_basic_map *bset, const char *s)
490{
491 return isl_basic_map_set_tuple_name(bset, isl_dim_set, s);
492}
493
494const char *isl_basic_map_get_tuple_name(__isl_keep isl_basic_map *bmap,
495 enum isl_dim_type type)
496{
497 return bmap ? isl_space_get_tuple_name(bmap->dim, type) : NULL((void*)0);
498}
499
500__isl_give isl_map *isl_map_set_tuple_name(__isl_take isl_map *map,
501 enum isl_dim_type type, const char *s)
502{
503 int i;
504
505 map = isl_map_cow(map);
506 if (!map)
507 return NULL((void*)0);
508
509 map->dim = isl_space_set_tuple_name(map->dim, type, s);
510 if (!map->dim)
511 goto error;
512
513 for (i = 0; i < map->n; ++i) {
514 map->p[i] = isl_basic_map_set_tuple_name(map->p[i], type, s);
515 if (!map->p[i])
516 goto error;
517 }
518
519 return map;
520error:
521 isl_map_free(map);
522 return NULL((void*)0);
523}
524
525/* Replace the identifier of the tuple of type "type" by "id".
526 */
527__isl_give isl_basic_map *isl_basic_map_set_tuple_id(
528 __isl_take isl_basic_map *bmap,
529 enum isl_dim_type type, __isl_take isl_id *id)
530{
531 bmap = isl_basic_map_cow(bmap);
532 if (!bmap)
533 goto error;
534 bmap->dim = isl_space_set_tuple_id(bmap->dim, type, id);
535 if (!bmap->dim)
536 return isl_basic_map_free(bmap);
537 bmap = isl_basic_map_finalize(bmap);
538 return bmap;
539error:
540 isl_id_free(id);
541 return NULL((void*)0);
542}
543
544/* Replace the identifier of the tuple by "id".
545 */
546__isl_give isl_basic_setisl_basic_map *isl_basic_set_set_tuple_id(
547 __isl_take isl_basic_setisl_basic_map *bset, __isl_take isl_id *id)
548{
549 return isl_basic_map_set_tuple_id(bset, isl_dim_set, id);
550}
551
552/* Does the input or output tuple have a name?
553 */
554isl_bool isl_map_has_tuple_name(__isl_keep isl_map *map, enum isl_dim_type type)
555{
556 return map ? isl_space_has_tuple_name(map->dim, type) : isl_bool_error;
557}
558
559const char *isl_map_get_tuple_name(__isl_keep isl_map *map,
560 enum isl_dim_type type)
561{
562 return map ? isl_space_get_tuple_name(map->dim, type) : NULL((void*)0);
563}
564
565__isl_give isl_setisl_map *isl_set_set_tuple_name(__isl_take isl_setisl_map *set,
566 const char *s)
567{
568 return set_from_map(isl_map_set_tuple_name(set_to_map(set),
569 isl_dim_set, s));
570}
571
572__isl_give isl_map *isl_map_set_tuple_id(__isl_take isl_map *map,
573 enum isl_dim_type type, __isl_take isl_id *id)
574{
575 map = isl_map_cow(map);
576 if (!map)
577 goto error;
578
579 map->dim = isl_space_set_tuple_id(map->dim, type, id);
580
581 return isl_map_reset_space(map, isl_space_copy(map->dim));
582error:
583 isl_id_free(id);
584 return NULL((void*)0);
585}
586
587__isl_give isl_setisl_map *isl_set_set_tuple_id(__isl_take isl_setisl_map *set,
588 __isl_take isl_id *id)
589{
590 return isl_map_set_tuple_id(set, isl_dim_set, id);
591}
592
593__isl_give isl_map *isl_map_reset_tuple_id(__isl_take isl_map *map,
594 enum isl_dim_type type)
595{
596 map = isl_map_cow(map);
597 if (!map)
598 return NULL((void*)0);
599
600 map->dim = isl_space_reset_tuple_id(map->dim, type);
601
602 return isl_map_reset_space(map, isl_space_copy(map->dim));
603}
604
605__isl_give isl_setisl_map *isl_set_reset_tuple_id(__isl_take isl_setisl_map *set)
606{
607 return isl_map_reset_tuple_id(set, isl_dim_set);
608}
609
610isl_bool isl_map_has_tuple_id(__isl_keep isl_map *map, enum isl_dim_type type)
611{
612 return map ? isl_space_has_tuple_id(map->dim, type) : isl_bool_error;
613}
614
615__isl_give isl_id *isl_map_get_tuple_id(__isl_keep isl_map *map,
616 enum isl_dim_type type)
617{
618 return map ? isl_space_get_tuple_id(map->dim, type) : NULL((void*)0);
619}
620
621isl_bool isl_set_has_tuple_id(__isl_keep isl_setisl_map *set)
622{
623 return isl_map_has_tuple_id(set, isl_dim_set);
624}
625
626__isl_give isl_id *isl_set_get_tuple_id(__isl_keep isl_setisl_map *set)
627{
628 return isl_map_get_tuple_id(set, isl_dim_set);
629}
630
631/* Does the set tuple have a name?
632 */
633isl_bool isl_set_has_tuple_name(__isl_keep isl_setisl_map *set)
634{
635 if (!set)
636 return isl_bool_error;
637 return isl_space_has_tuple_name(set->dim, isl_dim_set);
638}
639
640
641const char *isl_basic_set_get_tuple_name(__isl_keep isl_basic_setisl_basic_map *bset)
642{
643 return bset ? isl_space_get_tuple_name(bset->dim, isl_dim_set) : NULL((void*)0);
644}
645
646const char *isl_set_get_tuple_name(__isl_keep isl_setisl_map *set)
647{
648 return set ? isl_space_get_tuple_name(set->dim, isl_dim_set) : NULL((void*)0);
649}
650
651const char *isl_basic_map_get_dim_name(__isl_keep isl_basic_map *bmap,
652 enum isl_dim_type type, unsigned pos)
653{
654 return bmap ? isl_space_get_dim_name(bmap->dim, type, pos) : NULL((void*)0);
655}
656
657const char *isl_basic_set_get_dim_name(__isl_keep isl_basic_setisl_basic_map *bset,
658 enum isl_dim_type type, unsigned pos)
659{
660 return bset ? isl_space_get_dim_name(bset->dim, type, pos) : NULL((void*)0);
661}
662
663/* Does the given dimension have a name?
664 */
665isl_bool isl_map_has_dim_name(__isl_keep isl_map *map,
666 enum isl_dim_type type, unsigned pos)
667{
668 if (!map)
669 return isl_bool_error;
670 return isl_space_has_dim_name(map->dim, type, pos);
671}
672
673const char *isl_map_get_dim_name(__isl_keep isl_map *map,
674 enum isl_dim_type type, unsigned pos)
675{
676 return map ? isl_space_get_dim_name(map->dim, type, pos) : NULL((void*)0);
677}
678
679const char *isl_set_get_dim_name(__isl_keep isl_setisl_map *set,
680 enum isl_dim_type type, unsigned pos)
681{
682 return set ? isl_space_get_dim_name(set->dim, type, pos) : NULL((void*)0);
683}
684
685/* Does the given dimension have a name?
686 */
687isl_bool isl_set_has_dim_name(__isl_keep isl_setisl_map *set,
688 enum isl_dim_type type, unsigned pos)
689{
690 if (!set)
691 return isl_bool_error;
692 return isl_space_has_dim_name(set->dim, type, pos);
693}
694
695__isl_give isl_basic_map *isl_basic_map_set_dim_name(
696 __isl_take isl_basic_map *bmap,
697 enum isl_dim_type type, unsigned pos, const char *s)
698{
699 bmap = isl_basic_map_cow(bmap);
700 if (!bmap)
701 return NULL((void*)0);
702 bmap->dim = isl_space_set_dim_name(bmap->dim, type, pos, s);
703 if (!bmap->dim)
704 goto error;
705 return isl_basic_map_finalize(bmap);
706error:
707 isl_basic_map_free(bmap);
708 return NULL((void*)0);
709}
710
711__isl_give isl_map *isl_map_set_dim_name(__isl_take isl_map *map,
712 enum isl_dim_type type, unsigned pos, const char *s)
713{
714 int i;
715
716 map = isl_map_cow(map);
717 if (!map)
718 return NULL((void*)0);
719
720 map->dim = isl_space_set_dim_name(map->dim, type, pos, s);
721 if (!map->dim)
722 goto error;
723
724 for (i = 0; i < map->n; ++i) {
725 map->p[i] = isl_basic_map_set_dim_name(map->p[i], type, pos, s);
726 if (!map->p[i])
727 goto error;
728 }
729
730 return map;
731error:
732 isl_map_free(map);
733 return NULL((void*)0);
734}
735
736__isl_give isl_basic_setisl_basic_map *isl_basic_set_set_dim_name(
737 __isl_take isl_basic_setisl_basic_map *bset,
738 enum isl_dim_type type, unsigned pos, const char *s)
739{
740 return bset_from_bmap(isl_basic_map_set_dim_name(bset_to_bmap(bset),
741 type, pos, s));
742}
743
744__isl_give isl_setisl_map *isl_set_set_dim_name(__isl_take isl_setisl_map *set,
745 enum isl_dim_type type, unsigned pos, const char *s)
746{
747 return set_from_map(isl_map_set_dim_name(set_to_map(set),
748 type, pos, s));
749}
750
751isl_bool isl_basic_map_has_dim_id(__isl_keep isl_basic_map *bmap,
752 enum isl_dim_type type, unsigned pos)
753{
754 if (!bmap)
755 return isl_bool_error;
756 return isl_space_has_dim_id(bmap->dim, type, pos);
757}
758
759__isl_give isl_id *isl_basic_set_get_dim_id(__isl_keep isl_basic_setisl_basic_map *bset,
760 enum isl_dim_type type, unsigned pos)
761{
762 return bset ? isl_space_get_dim_id(bset->dim, type, pos) : NULL((void*)0);
763}
764
765isl_bool isl_map_has_dim_id(__isl_keep isl_map *map,
766 enum isl_dim_type type, unsigned pos)
767{
768 return map ? isl_space_has_dim_id(map->dim, type, pos) : isl_bool_error;
769}
770
771__isl_give isl_id *isl_map_get_dim_id(__isl_keep isl_map *map,
772 enum isl_dim_type type, unsigned pos)
773{
774 return map ? isl_space_get_dim_id(map->dim, type, pos) : NULL((void*)0);
775}
776
777isl_bool isl_set_has_dim_id(__isl_keep isl_setisl_map *set,
778 enum isl_dim_type type, unsigned pos)
779{
780 return isl_map_has_dim_id(set, type, pos);
781}
782
783__isl_give isl_id *isl_set_get_dim_id(__isl_keep isl_setisl_map *set,
784 enum isl_dim_type type, unsigned pos)
785{
786 return isl_map_get_dim_id(set, type, pos);
787}
788
789__isl_give isl_map *isl_map_set_dim_id(__isl_take isl_map *map,
790 enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
791{
792 map = isl_map_cow(map);
793 if (!map)
794 goto error;
795
796 map->dim = isl_space_set_dim_id(map->dim, type, pos, id);
797
798 return isl_map_reset_space(map, isl_space_copy(map->dim));
799error:
800 isl_id_free(id);
801 return NULL((void*)0);
802}
803
804__isl_give isl_setisl_map *isl_set_set_dim_id(__isl_take isl_setisl_map *set,
805 enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
806{
807 return isl_map_set_dim_id(set, type, pos, id);
808}
809
810int isl_map_find_dim_by_id(__isl_keep isl_map *map, enum isl_dim_type type,
811 __isl_keep isl_id *id)
812{
813 if (!map)
814 return -1;
815 return isl_space_find_dim_by_id(map->dim, type, id);
816}
817
818int isl_set_find_dim_by_id(__isl_keep isl_setisl_map *set, enum isl_dim_type type,
819 __isl_keep isl_id *id)
820{
821 return isl_map_find_dim_by_id(set, type, id);
822}
823
824/* Return the position of the dimension of the given type and name
825 * in "bmap".
826 * Return -1 if no such dimension can be found.
827 */
828int isl_basic_map_find_dim_by_name(__isl_keep isl_basic_map *bmap,
829 enum isl_dim_type type, const char *name)
830{
831 if (!bmap)
832 return -1;
833 return isl_space_find_dim_by_name(bmap->dim, type, name);
834}
835
836int isl_map_find_dim_by_name(__isl_keep isl_map *map, enum isl_dim_type type,
837 const char *name)
838{
839 if (!map)
840 return -1;
841 return isl_space_find_dim_by_name(map->dim, type, name);
842}
843
844int isl_set_find_dim_by_name(__isl_keep isl_setisl_map *set, enum isl_dim_type type,
845 const char *name)
846{
847 return isl_map_find_dim_by_name(set, type, name);
848}
849
850/* Check whether equality i of bset is a pure stride constraint
851 * on a single dimension, i.e., of the form
852 *
853 * v = k e
854 *
855 * with k a constant and e an existentially quantified variable.
856 */
857isl_bool isl_basic_set_eq_is_stride(__isl_keep isl_basic_setisl_basic_map *bset, int i)
858{
859 unsigned nparam;
860 unsigned d;
861 unsigned n_div;
862 int pos1;
863 int pos2;
864
865 if (!bset)
866 return isl_bool_error;
867
868 if (!isl_int_is_zero(bset->eq[i][0])(isl_sioimath_sgn(*(bset->eq[i][0])) == 0))
869 return isl_bool_false;
870
871 nparam = isl_basic_set_dim(bset, isl_dim_param);
872 d = isl_basic_set_dim(bset, isl_dim_set);
873 n_div = isl_basic_set_dim(bset, isl_dim_div);
874
875 if (isl_seq_first_non_zero(bset->eq[i] + 1, nparam) != -1)
876 return isl_bool_false;
877 pos1 = isl_seq_first_non_zero(bset->eq[i] + 1 + nparam, d);
878 if (pos1 == -1)
879 return isl_bool_false;
880 if (isl_seq_first_non_zero(bset->eq[i] + 1 + nparam + pos1 + 1,
881 d - pos1 - 1) != -1)
882 return isl_bool_false;
883
884 pos2 = isl_seq_first_non_zero(bset->eq[i] + 1 + nparam + d, n_div);
885 if (pos2 == -1)
886 return isl_bool_false;
887 if (isl_seq_first_non_zero(bset->eq[i] + 1 + nparam + d + pos2 + 1,
888 n_div - pos2 - 1) != -1)
889 return isl_bool_false;
890 if (!isl_int_is_one(bset->eq[i][1 + nparam + pos1])(isl_sioimath_cmp_si(*(bset->eq[i][1 + nparam + pos1]), 1)
== 0)
&&
891 !isl_int_is_negone(bset->eq[i][1 + nparam + pos1])(isl_sioimath_cmp_si(*(bset->eq[i][1 + nparam + pos1]), -1
) == 0)
)
892 return isl_bool_false;
893
894 return isl_bool_true;
895}
896
897/* Reset the user pointer on all identifiers of parameters and tuples
898 * of the space of "map".
899 */
900__isl_give isl_map *isl_map_reset_user(__isl_take isl_map *map)
901{
902 isl_space *space;
903
904 space = isl_map_get_space(map);
905 space = isl_space_reset_user(space);
906 map = isl_map_reset_space(map, space);
907
908 return map;
909}
910
911/* Reset the user pointer on all identifiers of parameters and tuples
912 * of the space of "set".
913 */
914__isl_give isl_setisl_map *isl_set_reset_user(__isl_take isl_setisl_map *set)
915{
916 return isl_map_reset_user(set);
917}
918
919isl_bool isl_basic_map_is_rational(__isl_keep isl_basic_map *bmap)
920{
921 if (!bmap)
922 return isl_bool_error;
923 return ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)(!!(((bmap)->flags) & ((1 << 4))));
924}
925
926/* Has "map" been marked as a rational map?
927 * In particular, have all basic maps in "map" been marked this way?
928 * An empty map is not considered to be rational.
929 * Maps where only some of the basic maps are marked rational
930 * are not allowed.
931 */
932isl_bool isl_map_is_rational(__isl_keep isl_map *map)
933{
934 int i;
935 isl_bool rational;
936
937 if (!map)
938 return isl_bool_error;
939 if (map->n == 0)
940 return isl_bool_false;
941 rational = isl_basic_map_is_rational(map->p[0]);
942 if (rational < 0)
943 return rational;
944 for (i = 1; i < map->n; ++i) {
945 isl_bool rational_i;
946
947 rational_i = isl_basic_map_is_rational(map->p[i]);
948 if (rational_i < 0)
949 return rational_i;
950 if (rational != rational_i)
951 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 953); return isl_bool_error; } while (0)
952 "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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 953); return isl_bool_error; } while (0)
953 "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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 953); return isl_bool_error; } while (0)
;
954 }
955
956 return rational;
957}
958
959/* Has "set" been marked as a rational set?
960 * In particular, have all basic set in "set" been marked this way?
961 * An empty set is not considered to be rational.
962 * Sets where only some of the basic sets are marked rational
963 * are not allowed.
964 */
965isl_bool isl_set_is_rational(__isl_keep isl_setisl_map *set)
966{
967 return isl_map_is_rational(set);
968}
969
970int isl_basic_set_is_rational(__isl_keep isl_basic_setisl_basic_map *bset)
971{
972 return isl_basic_map_is_rational(bset);
973}
974
975/* Does "bmap" contain any rational points?
976 *
977 * If "bmap" has an equality for each dimension, equating the dimension
978 * to an integer constant, then it has no rational points, even if it
979 * is marked as rational.
980 */
981isl_bool isl_basic_map_has_rational(__isl_keep isl_basic_map *bmap)
982{
983 isl_bool has_rational = isl_bool_true;
984 unsigned total;
985
986 if (!bmap)
987 return isl_bool_error;
988 if (isl_basic_map_plain_is_empty(bmap))
989 return isl_bool_false;
990 if (!isl_basic_map_is_rational(bmap))
991 return isl_bool_false;
992 bmap = isl_basic_map_copy(bmap);
993 bmap = isl_basic_map_implicit_equalities(bmap);
994 if (!bmap)
995 return isl_bool_error;
996 total = isl_basic_map_total_dim(bmap);
997 if (bmap->n_eq == total) {
998 int i, j;
999 for (i = 0; i < bmap->n_eq; ++i) {
1000 j = isl_seq_first_non_zero(bmap->eq[i] + 1, total);
1001 if (j < 0)
1002 break;
1003 if (!isl_int_is_one(bmap->eq[i][1 + j])(isl_sioimath_cmp_si(*(bmap->eq[i][1 + j]), 1) == 0) &&
1004 !isl_int_is_negone(bmap->eq[i][1 + j])(isl_sioimath_cmp_si(*(bmap->eq[i][1 + j]), -1) == 0))
1005 break;
1006 j = isl_seq_first_non_zero(bmap->eq[i] + 1 + j + 1,
1007 total - j - 1);
1008 if (j >= 0)
1009 break;
1010 }
1011 if (i == bmap->n_eq)
1012 has_rational = isl_bool_false;
1013 }
1014 isl_basic_map_free(bmap);
1015
1016 return has_rational;
1017}
1018
1019/* Does "map" contain any rational points?
1020 */
1021isl_bool isl_map_has_rational(__isl_keep isl_map *map)
1022{
1023 int i;
1024 isl_bool has_rational;
1025
1026 if (!map)
1027 return isl_bool_error;
1028 for (i = 0; i < map->n; ++i) {
1029 has_rational = isl_basic_map_has_rational(map->p[i]);
1030 if (has_rational < 0 || has_rational)
1031 return has_rational;
1032 }
1033 return isl_bool_false;
1034}
1035
1036/* Does "set" contain any rational points?
1037 */
1038isl_bool isl_set_has_rational(__isl_keep isl_setisl_map *set)
1039{
1040 return isl_map_has_rational(set);
1041}
1042
1043/* Is this basic set a parameter domain?
1044 */
1045isl_bool isl_basic_set_is_params(__isl_keep isl_basic_setisl_basic_map *bset)
1046{
1047 if (!bset)
1048 return isl_bool_error;
1049 return isl_space_is_params(bset->dim);
1050}
1051
1052/* Is this set a parameter domain?
1053 */
1054isl_bool isl_set_is_params(__isl_keep isl_setisl_map *set)
1055{
1056 if (!set)
1057 return isl_bool_error;
1058 return isl_space_is_params(set->dim);
1059}
1060
1061/* Is this map actually a parameter domain?
1062 * Users should never call this function. Outside of isl,
1063 * a map can never be a parameter domain.
1064 */
1065isl_bool isl_map_is_params(__isl_keep isl_map *map)
1066{
1067 if (!map)
1068 return isl_bool_error;
1069 return isl_space_is_params(map->dim);
1070}
1071
1072static struct isl_basic_map *basic_map_init(struct isl_ctx *ctx,
1073 struct isl_basic_map *bmap, unsigned extra,
1074 unsigned n_eq, unsigned n_ineq)
1075{
1076 int i;
1077 size_t row_size = 1 + isl_space_dim(bmap->dim, isl_dim_all) + extra;
1078
1079 bmap->ctx = ctx;
1080 isl_ctx_ref(ctx);
1081
1082 bmap->block = isl_blk_alloc(ctx, (n_ineq + n_eq) * row_size);
1083 if (isl_blk_is_error(bmap->block))
1084 goto error;
1085
1086 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
*)))
;
1087 if ((n_ineq + n_eq) && !bmap->ineq)
1088 goto error;
1089
1090 if (extra == 0) {
1091 bmap->block2 = isl_blk_empty();
1092 bmap->div = NULL((void*)0);
1093 } else {
1094 bmap->block2 = isl_blk_alloc(ctx, extra * (1 + row_size));
1095 if (isl_blk_is_error(bmap->block2))
1096 goto error;
1097
1098 bmap->div = isl_alloc_array(ctx, isl_int *, extra)((isl_int * *)isl_malloc_or_die(ctx, (extra)*sizeof(isl_int *
)))
;
1099 if (!bmap->div)
1100 goto error;
1101 }
1102
1103 for (i = 0; i < n_ineq + n_eq; ++i)
1104 bmap->ineq[i] = bmap->block.data + i * row_size;
1105
1106 for (i = 0; i < extra; ++i)
1107 bmap->div[i] = bmap->block2.data + i * (1 + row_size);
1108
1109 bmap->ref = 1;
1110 bmap->flags = 0;
1111 bmap->c_size = n_eq + n_ineq;
1112 bmap->eq = bmap->ineq + n_ineq;
1113 bmap->extra = extra;
1114 bmap->n_eq = 0;
1115 bmap->n_ineq = 0;
1116 bmap->n_div = 0;
1117 bmap->sample = NULL((void*)0);
1118
1119 return bmap;
1120error:
1121 isl_basic_map_free(bmap);
1122 return NULL((void*)0);
1123}
1124
1125struct isl_basic_setisl_basic_map *isl_basic_set_alloc(struct isl_ctx *ctx,
1126 unsigned nparam, unsigned dim, unsigned extra,
1127 unsigned n_eq, unsigned n_ineq)
1128{
1129 struct isl_basic_map *bmap;
1130 isl_space *space;
1131
1132 space = isl_space_set_alloc(ctx, nparam, dim);
1133 if (!space)
1134 return NULL((void*)0);
1135
1136 bmap = isl_basic_map_alloc_space(space, extra, n_eq, n_ineq);
1137 return bset_from_bmap(bmap);
1138}
1139
1140struct isl_basic_setisl_basic_map *isl_basic_set_alloc_space(__isl_take isl_space *dim,
1141 unsigned extra, unsigned n_eq, unsigned n_ineq)
1142{
1143 struct isl_basic_map *bmap;
1144 if (!dim)
1145 return NULL((void*)0);
1146 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"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1146); goto error; } while (0); } while (0)
;
1147 bmap = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq);
1148 return bset_from_bmap(bmap);
1149error:
1150 isl_space_free(dim);
1151 return NULL((void*)0);
1152}
1153
1154struct isl_basic_map *isl_basic_map_alloc_space(__isl_take isl_space *dim,
1155 unsigned extra, unsigned n_eq, unsigned n_ineq)
1156{
1157 struct isl_basic_map *bmap;
1158
1159 if (!dim)
1160 return NULL((void*)0);
1161 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)))
;
1162 if (!bmap)
1163 goto error;
1164 bmap->dim = dim;
1165
1166 return basic_map_init(dim->ctx, bmap, extra, n_eq, n_ineq);
1167error:
1168 isl_space_free(dim);
1169 return NULL((void*)0);
1170}
1171
1172struct isl_basic_map *isl_basic_map_alloc(struct isl_ctx *ctx,
1173 unsigned nparam, unsigned in, unsigned out, unsigned extra,
1174 unsigned n_eq, unsigned n_ineq)
1175{
1176 struct isl_basic_map *bmap;
1177 isl_space *dim;
1178
1179 dim = isl_space_alloc(ctx, nparam, in, out);
1180 if (!dim)
1181 return NULL((void*)0);
1182
1183 bmap = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq);
1184 return bmap;
1185}
1186
1187static void dup_constraints(
1188 struct isl_basic_map *dst, struct isl_basic_map *src)
1189{
1190 int i;
1191 unsigned total = isl_basic_map_total_dim(src);
1192
1193 for (i = 0; i < src->n_eq; ++i) {
1194 int j = isl_basic_map_alloc_equality(dst);
1195 isl_seq_cpy(dst->eq[j], src->eq[i], 1+total);
1196 }
1197
1198 for (i = 0; i < src->n_ineq; ++i) {
1199 int j = isl_basic_map_alloc_inequality(dst);
1200 isl_seq_cpy(dst->ineq[j], src->ineq[i], 1+total);
1201 }
1202
1203 for (i = 0; i < src->n_div; ++i) {
1204 int j = isl_basic_map_alloc_div(dst);
1205 isl_seq_cpy(dst->div[j], src->div[i], 1+1+total);
1206 }
1207 ISL_F_SET(dst, ISL_BASIC_SET_FINAL)(((dst)->flags) |= ((1 << 0)));
1208}
1209
1210__isl_give isl_basic_map *isl_basic_map_dup(__isl_keep isl_basic_map *bmap)
1211{
1212 struct isl_basic_map *dup;
1213
1214 if (!bmap)
1215 return NULL((void*)0);
1216 dup = isl_basic_map_alloc_space(isl_space_copy(bmap->dim),
1217 bmap->n_div, bmap->n_eq, bmap->n_ineq);
1218 if (!dup)
1219 return NULL((void*)0);
1220 dup_constraints(dup, bmap);
1221 dup->flags = bmap->flags;
1222 dup->sample = isl_vec_copy(bmap->sample);
1223 return dup;
1224}
1225
1226struct isl_basic_setisl_basic_map *isl_basic_set_dup(struct isl_basic_setisl_basic_map *bset)
1227{
1228 struct isl_basic_map *dup;
1229
1230 dup = isl_basic_map_dup(bset_to_bmap(bset));
1231 return bset_from_bmap(dup);
1232}
1233
1234__isl_give isl_basic_setisl_basic_map *isl_basic_set_copy(__isl_keep isl_basic_setisl_basic_map *bset)
1235{
1236 if (!bset)
1237 return NULL((void*)0);
1238
1239 if (ISL_F_ISSET(bset, ISL_BASIC_SET_FINAL)(!!(((bset)->flags) & ((1 << 0))))) {
1240 bset->ref++;
1241 return bset;
1242 }
1243 return isl_basic_set_dup(bset);
1244}
1245
1246__isl_give isl_setisl_map *isl_set_copy(__isl_keep isl_setisl_map *set)
1247{
1248 if (!set)
1249 return NULL((void*)0);
1250
1251 set->ref++;
1252 return set;
1253}
1254
1255__isl_give isl_basic_map *isl_basic_map_copy(__isl_keep isl_basic_map *bmap)
1256{
1257 if (!bmap)
1258 return NULL((void*)0);
1259
1260 if (ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL)(!!(((bmap)->flags) & ((1 << 0))))) {
1261 bmap->ref++;
1262 return bmap;
1263 }
1264 bmap = isl_basic_map_dup(bmap);
1265 if (bmap)
1266 ISL_F_SET(bmap, ISL_BASIC_SET_FINAL)(((bmap)->flags) |= ((1 << 0)));
1267 return bmap;
1268}
1269
1270__isl_give isl_map *isl_map_copy(__isl_keep isl_map *map)
1271{
1272 if (!map)
1273 return NULL((void*)0);
1274
1275 map->ref++;
1276 return map;
1277}
1278
1279__isl_null isl_basic_map *isl_basic_map_free(__isl_take isl_basic_map *bmap)
1280{
1281 if (!bmap)
1282 return NULL((void*)0);
1283
1284 if (--bmap->ref > 0)
1285 return NULL((void*)0);
1286
1287 isl_ctx_deref(bmap->ctx);
1288 free(bmap->div);
1289 isl_blk_free(bmap->ctx, bmap->block2);
1290 free(bmap->ineq);
1291 isl_blk_free(bmap->ctx, bmap->block);
1292 isl_vec_free(bmap->sample);
1293 isl_space_free(bmap->dim);
1294 free(bmap);
1295
1296 return NULL((void*)0);
1297}
1298
1299__isl_null isl_basic_setisl_basic_map *isl_basic_set_free(__isl_take isl_basic_setisl_basic_map *bset)
1300{
1301 return isl_basic_map_free(bset_to_bmap(bset));
1302}
1303
1304static int room_for_con(struct isl_basic_map *bmap, unsigned n)
1305{
1306 return bmap->n_eq + bmap->n_ineq + n <= bmap->c_size;
1307}
1308
1309/* Check that "map" has only named parameters, reporting an error
1310 * if it does not.
1311 */
1312isl_stat isl_map_check_named_params(__isl_keep isl_map *map)
1313{
1314 return isl_space_check_named_params(isl_map_peek_space(map));
1315}
1316
1317/* Check that "bmap1" and "bmap2" have the same parameters,
1318 * reporting an error if they do not.
1319 */
1320static isl_stat isl_basic_map_check_equal_params(
1321 __isl_keep isl_basic_map *bmap1, __isl_keep isl_basic_map *bmap2)
1322{
1323 isl_bool match;
1324
1325 match = isl_basic_map_has_equal_params(bmap1, bmap2);
1326 if (match < 0)
1327 return isl_stat_error;
1328 if (!match)
1329 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1330); return isl_stat_error; } while (0)
1330 "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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1330); return isl_stat_error; } while (0)
;
1331 return isl_stat_ok;
1332}
1333
1334__isl_give isl_map *isl_map_align_params_map_map_and(
1335 __isl_take isl_map *map1, __isl_take isl_map *map2,
1336 __isl_give isl_map *(*fn)(__isl_take isl_map *map1,
1337 __isl_take isl_map *map2))
1338{
1339 if (!map1 || !map2)
1340 goto error;
1341 if (isl_map_has_equal_params(map1, map2))
1342 return fn(map1, map2);
1343 if (isl_map_check_named_params(map1) < 0)
1344 goto error;
1345 if (isl_map_check_named_params(map2) < 0)
1346 goto error;
1347 map1 = isl_map_align_params(map1, isl_map_get_space(map2));
1348 map2 = isl_map_align_params(map2, isl_map_get_space(map1));
1349 return fn(map1, map2);
1350error:
1351 isl_map_free(map1);
1352 isl_map_free(map2);
1353 return NULL((void*)0);
1354}
1355
1356isl_bool isl_map_align_params_map_map_and_test(__isl_keep isl_map *map1,
1357 __isl_keep isl_map *map2,
1358 isl_bool (*fn)(__isl_keep isl_map *map1, __isl_keep isl_map *map2))
1359{
1360 isl_bool r;
1361
1362 if (!map1 || !map2)
1363 return isl_bool_error;
1364 if (isl_map_has_equal_params(map1, map2))
1365 return fn(map1, map2);
1366 if (isl_map_check_named_params(map1) < 0)
1367 return isl_bool_error;
1368 if (isl_map_check_named_params(map2) < 0)
1369 return isl_bool_error;
1370 map1 = isl_map_copy(map1);
1371 map2 = isl_map_copy(map2);
1372 map1 = isl_map_align_params(map1, isl_map_get_space(map2));
1373 map2 = isl_map_align_params(map2, isl_map_get_space(map1));
1374 r = fn(map1, map2);
1375 isl_map_free(map1);
1376 isl_map_free(map2);
1377 return r;
1378}
1379
1380int isl_basic_map_alloc_equality(struct isl_basic_map *bmap)
1381{
1382 struct isl_ctx *ctx;
1383 if (!bmap)
1384 return -1;
1385 ctx = bmap->ctx;
1386 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1386); return -1; } while (0); } while (0)
;
1387 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1388); return -1; } while (0); } while (0)
1388 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1388); return -1; } while (0); } while (0)
;
1389 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
1390 ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT)(((bmap)->flags) &= ~((1 << 3)));
1391 ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT)(((bmap)->flags) &= ~((1 << 2)));
1392 ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES)(((bmap)->flags) &= ~((1 << 7)));
1393 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS)(((bmap)->flags) &= ~((1 << 6)));
1394 if ((bmap->eq - bmap->ineq) + bmap->n_eq == bmap->c_size) {
1395 isl_int *t;
1396 int j = isl_basic_map_alloc_inequality(bmap);
1397 if (j < 0)
1398 return -1;
1399 t = bmap->ineq[j];
1400 bmap->ineq[j] = bmap->ineq[bmap->n_ineq - 1];
1401 bmap->ineq[bmap->n_ineq - 1] = bmap->eq[-1];
1402 bmap->eq[-1] = t;
1403 bmap->n_eq++;
1404 bmap->n_ineq--;
1405 bmap->eq--;
1406 return 0;
1407 }
1408 isl_seq_clr(bmap->eq[bmap->n_eq] + 1 + isl_basic_map_total_dim(bmap),
1409 bmap->extra - bmap->n_div);
1410 return bmap->n_eq++;
1411}
1412
1413int isl_basic_set_alloc_equality(struct isl_basic_setisl_basic_map *bset)
1414{
1415 return isl_basic_map_alloc_equality(bset_to_bmap(bset));
1416}
1417
1418int isl_basic_map_free_equality(struct isl_basic_map *bmap, unsigned n)
1419{
1420 if (!bmap)
1421 return -1;
1422 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1422); return -1; } while (0); } while (0)
;
1423 bmap->n_eq -= n;
1424 return 0;
1425}
1426
1427int isl_basic_set_free_equality(struct isl_basic_setisl_basic_map *bset, unsigned n)
1428{
1429 return isl_basic_map_free_equality(bset_to_bmap(bset), n);
1430}
1431
1432int isl_basic_map_drop_equality(struct isl_basic_map *bmap, unsigned pos)
1433{
1434 isl_int *t;
1435 if (!bmap)
1436 return -1;
1437 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1437); return -1; } while (0); } while (0)
;
1438
1439 if (pos != bmap->n_eq - 1) {
1440 t = bmap->eq[pos];
1441 bmap->eq[pos] = bmap->eq[bmap->n_eq - 1];
1442 bmap->eq[bmap->n_eq - 1] = t;
1443 }
1444 bmap->n_eq--;
1445 return 0;
1446}
1447
1448/* Turn inequality "pos" of "bmap" into an equality.
1449 *
1450 * In particular, we move the inequality in front of the equalities
1451 * and move the last inequality in the position of the moved inequality.
1452 * Note that isl_tab_make_equalities_explicit depends on this particular
1453 * change in the ordering of the constraints.
1454 */
1455void isl_basic_map_inequality_to_equality(
1456 struct isl_basic_map *bmap, unsigned pos)
1457{
1458 isl_int *t;
1459
1460 t = bmap->ineq[pos];
1461 bmap->ineq[pos] = bmap->ineq[bmap->n_ineq - 1];
1462 bmap->ineq[bmap->n_ineq - 1] = bmap->eq[-1];
1463 bmap->eq[-1] = t;
1464 bmap->n_eq++;
1465 bmap->n_ineq--;
1466 bmap->eq--;
1467 ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT)(((bmap)->flags) &= ~((1 << 3)));
1468 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
1469 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS)(((bmap)->flags) &= ~((1 << 6)));
1470 ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES)(((bmap)->flags) &= ~((1 << 7)));
1471}
1472
1473static int room_for_ineq(struct isl_basic_map *bmap, unsigned n)
1474{
1475 return bmap->n_ineq + n <= bmap->eq - bmap->ineq;
1476}
1477
1478int isl_basic_map_alloc_inequality(__isl_keep isl_basic_map *bmap)
1479{
1480 struct isl_ctx *ctx;
1481 if (!bmap)
1482 return -1;
1483 ctx = bmap->ctx;
1484 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1484); return -1; } while (0); } while (0)
;
1485 ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT)(((bmap)->flags) &= ~((1 << 2)));
1486 ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT)(((bmap)->flags) &= ~((1 << 3)));
1487 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
1488 ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES)(((bmap)->flags) &= ~((1 << 7)));
1489 isl_seq_clr(bmap->ineq[bmap->n_ineq] +
1490 1 + isl_basic_map_total_dim(bmap),
1491 bmap->extra - bmap->n_div);
1492 return bmap->n_ineq++;
1493}
1494
1495int isl_basic_set_alloc_inequality(__isl_keep isl_basic_setisl_basic_map *bset)
1496{
1497 return isl_basic_map_alloc_inequality(bset_to_bmap(bset));
1498}
1499
1500int isl_basic_map_free_inequality(struct isl_basic_map *bmap, unsigned n)
1501{
1502 if (!bmap)
1503 return -1;
1504 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1504); return -1; } while (0); } while (0)
;
1505 bmap->n_ineq -= n;
1506 return 0;
1507}
1508
1509int isl_basic_set_free_inequality(struct isl_basic_setisl_basic_map *bset, unsigned n)
1510{
1511 return isl_basic_map_free_inequality(bset_to_bmap(bset), n);
1512}
1513
1514int isl_basic_map_drop_inequality(struct isl_basic_map *bmap, unsigned pos)
1515{
1516 isl_int *t;
1517 if (!bmap)
1518 return -1;
1519 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1519); return -1; } while (0); } while (0)
;
1520
1521 if (pos != bmap->n_ineq - 1) {
1522 t = bmap->ineq[pos];
1523 bmap->ineq[pos] = bmap->ineq[bmap->n_ineq - 1];
1524 bmap->ineq[bmap->n_ineq - 1] = t;
1525 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
1526 }
1527 bmap->n_ineq--;
1528 return 0;
1529}
1530
1531int isl_basic_set_drop_inequality(struct isl_basic_setisl_basic_map *bset, unsigned pos)
1532{
1533 return isl_basic_map_drop_inequality(bset_to_bmap(bset), pos);
1534}
1535
1536__isl_give isl_basic_map *isl_basic_map_add_eq(__isl_take isl_basic_map *bmap,
1537 isl_int *eq)
1538{
1539 int k;
1540
1541 bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
1542 if (!bmap)
1543 return NULL((void*)0);
1544 k = isl_basic_map_alloc_equality(bmap);
1545 if (k < 0)
1546 goto error;
1547 isl_seq_cpy(bmap->eq[k], eq, 1 + isl_basic_map_total_dim(bmap));
1548 return bmap;
1549error:
1550 isl_basic_map_free(bmap);
1551 return NULL((void*)0);
1552}
1553
1554__isl_give isl_basic_setisl_basic_map *isl_basic_set_add_eq(__isl_take isl_basic_setisl_basic_map *bset,
1555 isl_int *eq)
1556{
1557 return bset_from_bmap(isl_basic_map_add_eq(bset_to_bmap(bset), eq));
1558}
1559
1560__isl_give isl_basic_map *isl_basic_map_add_ineq(__isl_take isl_basic_map *bmap,
1561 isl_int *ineq)
1562{
1563 int k;
1564
1565 bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
1566 if (!bmap)
1567 return NULL((void*)0);
1568 k = isl_basic_map_alloc_inequality(bmap);
1569 if (k < 0)
1570 goto error;
1571 isl_seq_cpy(bmap->ineq[k], ineq, 1 + isl_basic_map_total_dim(bmap));
1572 return bmap;
1573error:
1574 isl_basic_map_free(bmap);
1575 return NULL((void*)0);
1576}
1577
1578__isl_give isl_basic_setisl_basic_map *isl_basic_set_add_ineq(__isl_take isl_basic_setisl_basic_map *bset,
1579 isl_int *ineq)
1580{
1581 return bset_from_bmap(isl_basic_map_add_ineq(bset_to_bmap(bset), ineq));
1582}
1583
1584int isl_basic_map_alloc_div(struct isl_basic_map *bmap)
1585{
1586 if (!bmap)
1587 return -1;
1588 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1588); return -1; } while (0); } while (0)
;
1589 isl_seq_clr(bmap->div[bmap->n_div] +
1590 1 + 1 + isl_basic_map_total_dim(bmap),
1591 bmap->extra - bmap->n_div);
1592 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS)(((bmap)->flags) &= ~((1 << 6)));
1593 return bmap->n_div++;
1594}
1595
1596int isl_basic_set_alloc_div(struct isl_basic_setisl_basic_map *bset)
1597{
1598 return isl_basic_map_alloc_div(bset_to_bmap(bset));
1599}
1600
1601/* Check that there are "n" dimensions of type "type" starting at "first"
1602 * in "bmap".
1603 */
1604static isl_stat isl_basic_map_check_range(__isl_keep isl_basic_map *bmap,
1605 enum isl_dim_type type, unsigned first, unsigned n)
1606{
1607 unsigned dim;
1608
1609 if (!bmap)
1610 return isl_stat_error;
1611 dim = isl_basic_map_dim(bmap, type);
1612 if (first + n > dim || first + n < first)
1613 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1615); return isl_stat_error; } while (0)
1614 "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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1615); return isl_stat_error; } while (0)
1615 return isl_stat_error)do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "position or range out of bounds", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1615); return isl_stat_error; } while (0)
;
1616 return isl_stat_ok;
1617}
1618
1619/* Insert an extra integer division, prescribed by "div", to "bmap"
1620 * at (integer division) position "pos".
1621 *
1622 * The integer division is first added at the end and then moved
1623 * into the right position.
1624 */
1625__isl_give isl_basic_map *isl_basic_map_insert_div(
1626 __isl_take isl_basic_map *bmap, int pos, __isl_keep isl_vec *div)
1627{
1628 int i, k;
1629
1630 bmap = isl_basic_map_cow(bmap);
1631 if (!bmap || !div)
1632 return isl_basic_map_free(bmap);
1633
1634 if (div->size != 1 + 1 + isl_basic_map_dim(bmap, isl_dim_all))
1635 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1636); return isl_basic_map_free(bmap); } while (0)
1636 "unexpected size", return isl_basic_map_free(bmap))do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "unexpected size", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1636); return isl_basic_map_free(bmap); } while (0)
;
1637 if (isl_basic_map_check_range(bmap, isl_dim_div, pos, 0) < 0)
1638 return isl_basic_map_free(bmap);
1639
1640 bmap = isl_basic_map_extend_space(bmap,
1641 isl_basic_map_get_space(bmap), 1, 0, 2);
1642 k = isl_basic_map_alloc_div(bmap);
1643 if (k < 0)
1644 return isl_basic_map_free(bmap);
1645 isl_seq_cpy(bmap->div[k], div->el, div->size);
1646 isl_int_set_si(bmap->div[k][div->size], 0)isl_sioimath_set_si((bmap->div[k][div->size]), 0);
1647
1648 for (i = k; i > pos; --i)
1649 isl_basic_map_swap_div(bmap, i, i - 1);
1650
1651 return bmap;
1652}
1653
1654isl_stat isl_basic_map_free_div(struct isl_basic_map *bmap, unsigned n)
1655{
1656 if (!bmap)
1657 return isl_stat_error;
1658 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1658); return isl_stat_error; } while (0); } while (0)
;
1659 bmap->n_div -= n;
1660 return isl_stat_ok;
1661}
1662
1663/* Copy constraint from src to dst, putting the vars of src at offset
1664 * dim_off in dst and the divs of src at offset div_off in dst.
1665 * If both sets are actually map, then dim_off applies to the input
1666 * variables.
1667 */
1668static void copy_constraint(struct isl_basic_map *dst_map, isl_int *dst,
1669 struct isl_basic_map *src_map, isl_int *src,
1670 unsigned in_off, unsigned out_off, unsigned div_off)
1671{
1672 unsigned src_nparam = isl_basic_map_dim(src_map, isl_dim_param);
1673 unsigned dst_nparam = isl_basic_map_dim(dst_map, isl_dim_param);
1674 unsigned src_in = isl_basic_map_dim(src_map, isl_dim_in);
1675 unsigned dst_in = isl_basic_map_dim(dst_map, isl_dim_in);
1676 unsigned src_out = isl_basic_map_dim(src_map, isl_dim_out);
1677 unsigned dst_out = isl_basic_map_dim(dst_map, isl_dim_out);
1678 isl_int_set(dst[0], src[0])isl_sioimath_set((dst[0]), *(src[0]));
1679 isl_seq_cpy(dst+1, src+1, isl_min(dst_nparam, src_nparam)((dst_nparam < src_nparam) ? (dst_nparam) : (src_nparam)));
1680 if (dst_nparam > src_nparam)
1681 isl_seq_clr(dst+1+src_nparam,
1682 dst_nparam - src_nparam);
1683 isl_seq_clr(dst+1+dst_nparam, in_off);
1684 isl_seq_cpy(dst+1+dst_nparam+in_off,
1685 src+1+src_nparam,
1686 isl_min(dst_in-in_off, src_in)((dst_in-in_off < src_in) ? (dst_in-in_off) : (src_in)));
1687 if (dst_in-in_off > src_in)
1688 isl_seq_clr(dst+1+dst_nparam+in_off+src_in,
1689 dst_in - in_off - src_in);
1690 isl_seq_clr(dst+1+dst_nparam+dst_in, out_off);
1691 isl_seq_cpy(dst+1+dst_nparam+dst_in+out_off,
1692 src+1+src_nparam+src_in,
1693 isl_min(dst_out-out_off, src_out)((dst_out-out_off < src_out) ? (dst_out-out_off) : (src_out
))
);
1694 if (dst_out-out_off > src_out)
1695 isl_seq_clr(dst+1+dst_nparam+dst_in+out_off+src_out,
1696 dst_out - out_off - src_out);
1697 isl_seq_clr(dst+1+dst_nparam+dst_in+dst_out, div_off);
1698 isl_seq_cpy(dst+1+dst_nparam+dst_in+dst_out+div_off,
1699 src+1+src_nparam+src_in+src_out,
1700 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))
);
1701 if (dst_map->n_div-div_off > src_map->n_div)
1702 isl_seq_clr(dst+1+dst_nparam+dst_in+dst_out+
1703 div_off+src_map->n_div,
1704 dst_map->n_div - div_off - src_map->n_div);
1705}
1706
1707static void copy_div(struct isl_basic_map *dst_map, isl_int *dst,
1708 struct isl_basic_map *src_map, isl_int *src,
1709 unsigned in_off, unsigned out_off, unsigned div_off)
1710{
1711 isl_int_set(dst[0], src[0])isl_sioimath_set((dst[0]), *(src[0]));
1712 copy_constraint(dst_map, dst+1, src_map, src+1, in_off, out_off, div_off);
1713}
1714
1715static __isl_give isl_basic_map *add_constraints(
1716 __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2,
1717 unsigned i_pos, unsigned o_pos)
1718{
1719 int i;
1720 unsigned div_off;
1721
1722 if (!bmap1 || !bmap2)
1723 goto error;
1724
1725 div_off = bmap1->n_div;
1726
1727 for (i = 0; i < bmap2->n_eq; ++i) {
1728 int i1 = isl_basic_map_alloc_equality(bmap1);
1729 if (i1 < 0)
1730 goto error;
1731 copy_constraint(bmap1, bmap1->eq[i1], bmap2, bmap2->eq[i],
1732 i_pos, o_pos, div_off);
1733 }
1734
1735 for (i = 0; i < bmap2->n_ineq; ++i) {
1736 int i1 = isl_basic_map_alloc_inequality(bmap1);
1737 if (i1 < 0)
1738 goto error;
1739 copy_constraint(bmap1, bmap1->ineq[i1], bmap2, bmap2->ineq[i],
1740 i_pos, o_pos, div_off);
1741 }
1742
1743 for (i = 0; i < bmap2->n_div; ++i) {
1744 int i1 = isl_basic_map_alloc_div(bmap1);
1745 if (i1 < 0)
1746 goto error;
1747 copy_div(bmap1, bmap1->div[i1], bmap2, bmap2->div[i],
1748 i_pos, o_pos, div_off);
1749 }
1750
1751 isl_basic_map_free(bmap2);
1752
1753 return bmap1;
1754
1755error:
1756 isl_basic_map_free(bmap1);
1757 isl_basic_map_free(bmap2);
1758 return NULL((void*)0);
1759}
1760
1761struct isl_basic_setisl_basic_map *isl_basic_set_add_constraints(struct isl_basic_setisl_basic_map *bset1,
1762 struct isl_basic_setisl_basic_map *bset2, unsigned pos)
1763{
1764 return bset_from_bmap(add_constraints(bset_to_bmap(bset1),
1765 bset_to_bmap(bset2), 0, pos));
1766}
1767
1768__isl_give isl_basic_map *isl_basic_map_extend_space(
1769 __isl_take isl_basic_map *base, __isl_take isl_space *dim,
1770 unsigned extra, unsigned n_eq, unsigned n_ineq)
1771{
1772 struct isl_basic_map *ext;
1773 unsigned flags;
1774 int dims_ok;
1775
1776 if (!dim)
1777 goto error;
1778
1779 if (!base)
1780 goto error;
1781
1782 dims_ok = isl_space_is_equal(base->dim, dim) &&
1783 base->extra >= base->n_div + extra;
1784
1785 if (dims_ok && room_for_con(base, n_eq + n_ineq) &&
1786 room_for_ineq(base, n_ineq)) {
1787 isl_space_free(dim);
1788 return base;
1789 }
1790
1791 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1791); goto error; } while (0); } while (0)
;
1792 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1792); goto error; } while (0); } while (0)
;
1793 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1793); goto error; } while (0); } while (0)
;
1794 extra += base->extra;
1795 n_eq += base->n_eq;
1796 n_ineq += base->n_ineq;
1797
1798 ext = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq);
1799 dim = NULL((void*)0);
1800 if (!ext)
1801 goto error;
1802
1803 if (dims_ok)
1804 ext->sample = isl_vec_copy(base->sample);
1805 flags = base->flags;
1806 ext = add_constraints(ext, base, 0, 0);
1807 if (ext) {
1808 ext->flags = flags;
1809 ISL_F_CLR(ext, ISL_BASIC_SET_FINAL)(((ext)->flags) &= ~((1 << 0)));
1810 }
1811
1812 return ext;
1813
1814error:
1815 isl_space_free(dim);
1816 isl_basic_map_free(base);
1817 return NULL((void*)0);
1818}
1819
1820struct isl_basic_setisl_basic_map *isl_basic_set_extend_space(struct isl_basic_setisl_basic_map *base,
1821 __isl_take isl_space *dim, unsigned extra,
1822 unsigned n_eq, unsigned n_ineq)
1823{
1824 return bset_from_bmap(isl_basic_map_extend_space(bset_to_bmap(base),
1825 dim, extra, n_eq, n_ineq));
1826}
1827
1828struct isl_basic_map *isl_basic_map_extend_constraints(
1829 struct isl_basic_map *base, unsigned n_eq, unsigned n_ineq)
1830{
1831 if (!base)
1832 return NULL((void*)0);
1833 return isl_basic_map_extend_space(base, isl_space_copy(base->dim),
1834 0, n_eq, n_ineq);
1835}
1836
1837struct isl_basic_map *isl_basic_map_extend(struct isl_basic_map *base,
1838 unsigned nparam, unsigned n_in, unsigned n_out, unsigned extra,
1839 unsigned n_eq, unsigned n_ineq)
1840{
1841 struct isl_basic_map *bmap;
1842 isl_space *dim;
1843
1844 if (!base)
1845 return NULL((void*)0);
1846 dim = isl_space_alloc(base->ctx, nparam, n_in, n_out);
1847 if (!dim)
1848 goto error;
1849
1850 bmap = isl_basic_map_extend_space(base, dim, extra, n_eq, n_ineq);
1851 return bmap;
1852error:
1853 isl_basic_map_free(base);
1854 return NULL((void*)0);
1855}
1856
1857struct isl_basic_setisl_basic_map *isl_basic_set_extend(struct isl_basic_setisl_basic_map *base,
1858 unsigned nparam, unsigned dim, unsigned extra,
1859 unsigned n_eq, unsigned n_ineq)
1860{
1861 return bset_from_bmap(isl_basic_map_extend(bset_to_bmap(base),
1862 nparam, 0, dim, extra, n_eq, n_ineq));
1863}
1864
1865struct isl_basic_setisl_basic_map *isl_basic_set_extend_constraints(
1866 struct isl_basic_setisl_basic_map *base, unsigned n_eq, unsigned n_ineq)
1867{
1868 isl_basic_map *bmap = bset_to_bmap(base);
1869 bmap = isl_basic_map_extend_constraints(bmap, n_eq, n_ineq);
1870 return bset_from_bmap(bmap);
1871}
1872
1873__isl_give isl_basic_setisl_basic_map *isl_basic_set_cow(__isl_take isl_basic_setisl_basic_map *bset)
1874{
1875 return bset_from_bmap(isl_basic_map_cow(bset_to_bmap(bset)));
1876}
1877
1878__isl_give isl_basic_map *isl_basic_map_cow(__isl_take isl_basic_map *bmap)
1879{
1880 if (!bmap)
1881 return NULL((void*)0);
1882
1883 if (bmap->ref > 1) {
1884 bmap->ref--;
1885 bmap = isl_basic_map_dup(bmap);
1886 }
1887 if (bmap) {
1888 ISL_F_CLR(bmap, ISL_BASIC_SET_FINAL)(((bmap)->flags) &= ~((1 << 0)));
1889 ISL_F_CLR(bmap, ISL_BASIC_MAP_REDUCED_COEFFICIENTS)(((bmap)->flags) &= ~((1 << 8)));
1890 }
1891 return bmap;
1892}
1893
1894/* Clear all cached information in "map", either because it is about
1895 * to be modified or because it is being freed.
1896 * Always return the same pointer that is passed in.
1897 * This is needed for the use in isl_map_free.
1898 */
1899static __isl_give isl_map *clear_caches(__isl_take isl_map *map)
1900{
1901 isl_basic_map_free(map->cached_simple_hull[0]);
1902 isl_basic_map_free(map->cached_simple_hull[1]);
1903 map->cached_simple_hull[0] = NULL((void*)0);
1904 map->cached_simple_hull[1] = NULL((void*)0);
1905 return map;
1906}
1907
1908__isl_give isl_setisl_map *isl_set_cow(__isl_take isl_setisl_map *set)
1909{
1910 return isl_map_cow(set);
1911}
1912
1913/* Return an isl_map that is equal to "map" and that has only
1914 * a single reference.
1915 *
1916 * If the original input already has only one reference, then
1917 * simply return it, but clear all cached information, since
1918 * it may be rendered invalid by the operations that will be
1919 * performed on the result.
1920 *
1921 * Otherwise, create a duplicate (without any cached information).
1922 */
1923__isl_give isl_map *isl_map_cow(__isl_take isl_map *map)
1924{
1925 if (!map)
1926 return NULL((void*)0);
1927
1928 if (map->ref == 1)
1929 return clear_caches(map);
1930 map->ref--;
1931 return isl_map_dup(map);
1932}
1933
1934static void swap_vars(struct isl_blk blk, isl_int *a,
1935 unsigned a_len, unsigned b_len)
1936{
1937 isl_seq_cpy(blk.data, a+a_len, b_len);
1938 isl_seq_cpy(blk.data+b_len, a, a_len);
1939 isl_seq_cpy(a, blk.data, b_len+a_len);
1940}
1941
1942static __isl_give isl_basic_map *isl_basic_map_swap_vars(
1943 __isl_take isl_basic_map *bmap, unsigned pos, unsigned n1, unsigned n2)
1944{
1945 int i;
1946 struct isl_blk blk;
1947
1948 if (!bmap)
1949 goto error;
1950
1951 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1952); goto error; } while (0); } while (0)
1952 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 1952); goto error; } while (0); } while (0)
;
1953
1954 if (n1 == 0 || n2 == 0)
1955 return bmap;
1956
1957 bmap = isl_basic_map_cow(bmap);
1958 if (!bmap)
1959 return NULL((void*)0);
1960
1961 blk = isl_blk_alloc(bmap->ctx, n1 + n2);
1962 if (isl_blk_is_error(blk))
1963 goto error;
1964
1965 for (i = 0; i < bmap->n_eq; ++i)
1966 swap_vars(blk,
1967 bmap->eq[i] + pos, n1, n2);
1968
1969 for (i = 0; i < bmap->n_ineq; ++i)
1970 swap_vars(blk,
1971 bmap->ineq[i] + pos, n1, n2);
1972
1973 for (i = 0; i < bmap->n_div; ++i)
1974 swap_vars(blk,
1975 bmap->div[i]+1 + pos, n1, n2);
1976
1977 isl_blk_free(bmap->ctx, blk);
1978
1979 ISL_F_CLR(bmap, ISL_BASIC_SET_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
1980 bmap = isl_basic_map_gauss(bmap, NULL((void*)0));
1981 return isl_basic_map_finalize(bmap);
1982error:
1983 isl_basic_map_free(bmap);
1984 return NULL((void*)0);
1985}
1986
1987__isl_give isl_basic_map *isl_basic_map_set_to_empty(
1988 __isl_take isl_basic_map *bmap)
1989{
1990 int i = 0;
1991 unsigned total;
1992 if (!bmap)
1993 goto error;
1994 total = isl_basic_map_total_dim(bmap);
1995 if (isl_basic_map_free_div(bmap, bmap->n_div) < 0)
1996 return isl_basic_map_free(bmap);
1997 isl_basic_map_free_inequality(bmap, bmap->n_ineq);
1998 if (bmap->n_eq > 0)
1999 isl_basic_map_free_equality(bmap, bmap->n_eq-1);
2000 else {
2001 i = isl_basic_map_alloc_equality(bmap);
2002 if (i < 0)
2003 goto error;
2004 }
2005 isl_int_set_si(bmap->eq[i][0], 1)isl_sioimath_set_si((bmap->eq[i][0]), 1);
2006 isl_seq_clr(bmap->eq[i]+1, total);
2007 ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY)(((bmap)->flags) |= ((1 << 1)));
2008 isl_vec_free(bmap->sample);
2009 bmap->sample = NULL((void*)0);
2010 return isl_basic_map_finalize(bmap);
2011error:
2012 isl_basic_map_free(bmap);
2013 return NULL((void*)0);
2014}
2015
2016struct isl_basic_setisl_basic_map *isl_basic_set_set_to_empty(struct isl_basic_setisl_basic_map *bset)
2017{
2018 return bset_from_bmap(isl_basic_map_set_to_empty(bset_to_bmap(bset)));
2019}
2020
2021__isl_give isl_basic_map *isl_basic_map_set_rational(
2022 __isl_take isl_basic_map *bmap)
2023{
2024 if (!bmap)
2025 return NULL((void*)0);
2026
2027 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)(!!(((bmap)->flags) & ((1 << 4)))))
2028 return bmap;
2029
2030 bmap = isl_basic_map_cow(bmap);
2031 if (!bmap)
2032 return NULL((void*)0);
2033
2034 ISL_F_SET(bmap, ISL_BASIC_MAP_RATIONAL)(((bmap)->flags) |= ((1 << 4)));
2035
2036 return isl_basic_map_finalize(bmap);
2037}
2038
2039__isl_give isl_basic_setisl_basic_map *isl_basic_set_set_rational(
2040 __isl_take isl_basic_setisl_basic_map *bset)
2041{
2042 return isl_basic_map_set_rational(bset);
2043}
2044
2045__isl_give isl_basic_setisl_basic_map *isl_basic_set_set_integral(
2046 __isl_take isl_basic_setisl_basic_map *bset)
2047{
2048 if (!bset)
2049 return NULL((void*)0);
2050
2051 if (!ISL_F_ISSET(bset, ISL_BASIC_MAP_RATIONAL)(!!(((bset)->flags) & ((1 << 4)))))
2052 return bset;
2053
2054 bset = isl_basic_set_cow(bset);
2055 if (!bset)
2056 return NULL((void*)0);
2057
2058 ISL_F_CLR(bset, ISL_BASIC_MAP_RATIONAL)(((bset)->flags) &= ~((1 << 4)));
2059
2060 return isl_basic_set_finalize(bset);
2061}
2062
2063__isl_give isl_map *isl_map_set_rational(__isl_take isl_map *map)
2064{
2065 int i;
2066
2067 map = isl_map_cow(map);
2068 if (!map)
2069 return NULL((void*)0);
2070 for (i = 0; i < map->n; ++i) {
2071 map->p[i] = isl_basic_map_set_rational(map->p[i]);
2072 if (!map->p[i])
2073 goto error;
2074 }
2075 return map;
2076error:
2077 isl_map_free(map);
2078 return NULL((void*)0);
2079}
2080
2081__isl_give isl_setisl_map *isl_set_set_rational(__isl_take isl_setisl_map *set)
2082{
2083 return isl_map_set_rational(set);
2084}
2085
2086/* Swap divs "a" and "b" in "bmap" (without modifying any of the constraints
2087 * of "bmap").
2088 */
2089static void swap_div(__isl_keep isl_basic_map *bmap, int a, int b)
2090{
2091 isl_int *t = bmap->div[a];
2092 bmap->div[a] = bmap->div[b];
2093 bmap->div[b] = t;
2094}
2095
2096/* Swap divs "a" and "b" in "bmap" and adjust the constraints and
2097 * div definitions accordingly.
2098 */
2099void isl_basic_map_swap_div(struct isl_basic_map *bmap, int a, int b)
2100{
2101 int i;
2102 unsigned off = isl_space_dim(bmap->dim, isl_dim_all);
2103
2104 swap_div(bmap, a, b);
2105
2106 for (i = 0; i < bmap->n_eq; ++i)
2107 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]))
;
2108
2109 for (i = 0; i < bmap->n_ineq; ++i)
2110 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]))
;
2111
2112 for (i = 0; i < bmap->n_div; ++i)
2113 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]))
;
2114 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
2115}
2116
2117/* Swap divs "a" and "b" in "bset" and adjust the constraints and
2118 * div definitions accordingly.
2119 */
2120void isl_basic_set_swap_div(__isl_keep isl_basic_setisl_basic_map *bset, int a, int b)
2121{
2122 isl_basic_map_swap_div(bset, a, b);
2123}
2124
2125static void constraint_drop_vars(isl_int *c, unsigned n, unsigned rem)
2126{
2127 isl_seq_cpy(c, c + n, rem);
2128 isl_seq_clr(c + rem, n);
2129}
2130
2131/* Drop n dimensions starting at first.
2132 *
2133 * In principle, this frees up some extra variables as the number
2134 * of columns remains constant, but we would have to extend
2135 * the div array too as the number of rows in this array is assumed
2136 * to be equal to extra.
2137 */
2138struct isl_basic_setisl_basic_map *isl_basic_set_drop_dims(
2139 struct isl_basic_setisl_basic_map *bset, unsigned first, unsigned n)
2140{
2141 return isl_basic_map_drop(bset_to_bmap(bset), isl_dim_set, first, n);
2142}
2143
2144/* Move "n" divs starting at "first" to the end of the list of divs.
2145 */
2146static struct isl_basic_map *move_divs_last(struct isl_basic_map *bmap,
2147 unsigned first, unsigned n)
2148{
2149 isl_int **div;
2150 int i;
2151
2152 if (first + n == bmap->n_div)
2153 return bmap;
2154
2155 div = isl_alloc_array(bmap->ctx, isl_int *, n)((isl_int * *)isl_malloc_or_die(bmap->ctx, (n)*sizeof(isl_int
*)))
;
2156 if (!div)
2157 goto error;
2158 for (i = 0; i < n; ++i)
2159 div[i] = bmap->div[first + i];
2160 for (i = 0; i < bmap->n_div - first - n; ++i)
2161 bmap->div[first + i] = bmap->div[first + n + i];
2162 for (i = 0; i < n; ++i)
2163 bmap->div[bmap->n_div - n + i] = div[i];
2164 free(div);
2165 return bmap;
2166error:
2167 isl_basic_map_free(bmap);
2168 return NULL((void*)0);
2169}
2170
2171/* Drop "n" dimensions of type "type" starting at "first".
2172 *
2173 * In principle, this frees up some extra variables as the number
2174 * of columns remains constant, but we would have to extend
2175 * the div array too as the number of rows in this array is assumed
2176 * to be equal to extra.
2177 */
2178__isl_give isl_basic_map *isl_basic_map_drop(__isl_take isl_basic_map *bmap,
2179 enum isl_dim_type type, unsigned first, unsigned n)
2180{
2181 int i;
2182 unsigned dim;
2183 unsigned offset;
2184 unsigned left;
2185
2186 if (!bmap)
2187 goto error;
2188
2189 dim = isl_basic_map_dim(bmap, type);
2190 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 2190); goto error; } while (0); } while (0)
;
2191
2192 if (n == 0 && !isl_space_is_named_or_nested(bmap->dim, type))
2193 return bmap;
2194
2195 bmap = isl_basic_map_cow(bmap);
2196 if (!bmap)
2197 return NULL((void*)0);
2198
2199 offset = isl_basic_map_offset(bmap, type) + first;
2200 left = isl_basic_map_total_dim(bmap) - (offset - 1) - n;
2201 for (i = 0; i < bmap->n_eq; ++i)
2202 constraint_drop_vars(bmap->eq[i]+offset, n, left);
2203
2204 for (i = 0; i < bmap->n_ineq; ++i)
2205 constraint_drop_vars(bmap->ineq[i]+offset, n, left);
2206
2207 for (i = 0; i < bmap->n_div; ++i)
2208 constraint_drop_vars(bmap->div[i]+1+offset, n, left);
2209
2210 if (type == isl_dim_div) {
2211 bmap = move_divs_last(bmap, first, n);
2212 if (!bmap)
2213 goto error;
2214 if (isl_basic_map_free_div(bmap, n) < 0)
2215 return isl_basic_map_free(bmap);
2216 } else
2217 bmap->dim = isl_space_drop_dims(bmap->dim, type, first, n);
2218 if (!bmap->dim)
2219 goto error;
2220
2221 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
2222 bmap = isl_basic_map_simplify(bmap);
2223 return isl_basic_map_finalize(bmap);
2224error:
2225 isl_basic_map_free(bmap);
2226 return NULL((void*)0);
2227}
2228
2229__isl_give isl_basic_setisl_basic_map *isl_basic_set_drop(__isl_take isl_basic_setisl_basic_map *bset,
2230 enum isl_dim_type type, unsigned first, unsigned n)
2231{
2232 return bset_from_bmap(isl_basic_map_drop(bset_to_bmap(bset),
2233 type, first, n));
2234}
2235
2236__isl_give isl_map *isl_map_drop(__isl_take isl_map *map,
2237 enum isl_dim_type type, unsigned first, unsigned n)
2238{
2239 int i;
2240
2241 if (!map)
2242 goto error;
2243
2244 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 2244); goto error; } while (0); } while (0)
;
2245
2246 if (n == 0 && !isl_space_is_named_or_nested(map->dim, type))
2247 return map;
2248 map = isl_map_cow(map);
2249 if (!map)
2250 goto error;
2251 map->dim = isl_space_drop_dims(map->dim, type, first, n);
2252 if (!map->dim)
2253 goto error;
2254
2255 for (i = 0; i < map->n; ++i) {
2256 map->p[i] = isl_basic_map_drop(map->p[i], type, first, n);
2257 if (!map->p[i])
2258 goto error;
2259 }
2260 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
2261
2262 return map;
2263error:
2264 isl_map_free(map);
2265 return NULL((void*)0);
2266}
2267
2268__isl_give isl_setisl_map *isl_set_drop(__isl_take isl_setisl_map *set,
2269 enum isl_dim_type type, unsigned first, unsigned n)
2270{
2271 return set_from_map(isl_map_drop(set_to_map(set), type, first, n));
2272}
2273
2274/*
2275 * We don't cow, as the div is assumed to be redundant.
2276 */
2277__isl_give isl_basic_map *isl_basic_map_drop_div(
2278 __isl_take isl_basic_map *bmap, unsigned div)
2279{
2280 int i;
2281 unsigned pos;
2282
2283 if (!bmap)
2284 goto error;
2285
2286 pos = 1 + isl_space_dim(bmap->dim, isl_dim_all) + div;
2287
2288 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 2288); goto error; } while (0); } while (0)
;
2289
2290 for (i = 0; i < bmap->n_eq; ++i)
2291 constraint_drop_vars(bmap->eq[i]+pos, 1, bmap->extra-div-1);
2292
2293 for (i = 0; i < bmap->n_ineq; ++i) {
2294 if (!isl_int_is_zero(bmap->ineq[i][pos])(isl_sioimath_sgn(*(bmap->ineq[i][pos])) == 0)) {
2295 isl_basic_map_drop_inequality(bmap, i);
2296 --i;
2297 continue;
2298 }
2299 constraint_drop_vars(bmap->ineq[i]+pos, 1, bmap->extra-div-1);
2300 }
2301
2302 for (i = 0; i < bmap->n_div; ++i)
2303 constraint_drop_vars(bmap->div[i]+1+pos, 1, bmap->extra-div-1);
2304
2305 if (div != bmap->n_div - 1) {
2306 int j;
2307 isl_int *t = bmap->div[div];
2308
2309 for (j = div; j < bmap->n_div - 1; ++j)
2310 bmap->div[j] = bmap->div[j+1];
2311
2312 bmap->div[bmap->n_div - 1] = t;
2313 }
2314 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
2315 if (isl_basic_map_free_div(bmap, 1) < 0)
2316 return isl_basic_map_free(bmap);
2317
2318 return bmap;
2319error:
2320 isl_basic_map_free(bmap);
2321 return NULL((void*)0);
2322}
2323
2324/* Eliminate the specified n dimensions starting at first from the
2325 * constraints, without removing the dimensions from the space.
2326 * If the set is rational, the dimensions are eliminated using Fourier-Motzkin.
2327 */
2328__isl_give isl_map *isl_map_eliminate(__isl_take isl_map *map,
2329 enum isl_dim_type type, unsigned first, unsigned n)
2330{
2331 int i;
2332
2333 if (!map)
2334 return NULL((void*)0);
2335 if (n == 0)
2336 return map;
2337
2338 if (first + n > isl_map_dim(map, type) || first + n < first)
2339 isl_die(map->ctx, isl_error_invalid,do { isl_handle_error(map->ctx, isl_error_invalid, "index out of bounds"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 2340); goto error; } while (0)
2340 "index out of bounds", goto error)do { isl_handle_error(map->ctx, isl_error_invalid, "index out of bounds"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 2340); goto error; } while (0)
;
2341
2342 map = isl_map_cow(map);
2343 if (!map)
2344 return NULL((void*)0);
2345
2346 for (i = 0; i < map->n; ++i) {
2347 map->p[i] = isl_basic_map_eliminate(map->p[i], type, first, n);
2348 if (!map->p[i])
2349 goto error;
2350 }
2351 return map;
2352error:
2353 isl_map_free(map);
2354 return NULL((void*)0);
2355}
2356
2357/* Eliminate the specified n dimensions starting at first from the
2358 * constraints, without removing the dimensions from the space.
2359 * If the set is rational, the dimensions are eliminated using Fourier-Motzkin.
2360 */
2361__isl_give isl_setisl_map *isl_set_eliminate(__isl_take isl_setisl_map *set,
2362 enum isl_dim_type type, unsigned first, unsigned n)
2363{
2364 return set_from_map(isl_map_eliminate(set_to_map(set), type, first, n));
2365}
2366
2367/* Eliminate the specified n dimensions starting at first from the
2368 * constraints, without removing the dimensions from the space.
2369 * If the set is rational, the dimensions are eliminated using Fourier-Motzkin.
2370 */
2371__isl_give isl_setisl_map *isl_set_eliminate_dims(__isl_take isl_setisl_map *set,
2372 unsigned first, unsigned n)
2373{
2374 return isl_set_eliminate(set, isl_dim_set, first, n);
2375}
2376
2377__isl_give isl_basic_map *isl_basic_map_remove_divs(
2378 __isl_take isl_basic_map *bmap)
2379{
2380 if (!bmap)
2381 return NULL((void*)0);
2382 bmap = isl_basic_map_eliminate_vars(bmap,
2383 isl_space_dim(bmap->dim, isl_dim_all), bmap->n_div);
2384 if (!bmap)
2385 return NULL((void*)0);
2386 bmap->n_div = 0;
2387 return isl_basic_map_finalize(bmap);
2388}
2389
2390__isl_give isl_basic_setisl_basic_map *isl_basic_set_remove_divs(
2391 __isl_take isl_basic_setisl_basic_map *bset)
2392{
2393 return bset_from_bmap(isl_basic_map_remove_divs(bset_to_bmap(bset)));
2394}
2395
2396__isl_give isl_map *isl_map_remove_divs(__isl_take isl_map *map)
2397{
2398 int i;
2399
2400 if (!map)
2401 return NULL((void*)0);
2402 if (map->n == 0)
2403 return map;
2404
2405 map = isl_map_cow(map);
2406 if (!map)
2407 return NULL((void*)0);
2408
2409 for (i = 0; i < map->n; ++i) {
2410 map->p[i] = isl_basic_map_remove_divs(map->p[i]);
2411 if (!map->p[i])
2412 goto error;
2413 }
2414 return map;
2415error:
2416 isl_map_free(map);
2417 return NULL((void*)0);
2418}
2419
2420__isl_give isl_setisl_map *isl_set_remove_divs(__isl_take isl_setisl_map *set)
2421{
2422 return isl_map_remove_divs(set);
2423}
2424
2425__isl_give isl_basic_map *isl_basic_map_remove_dims(
2426 __isl_take isl_basic_map *bmap, enum isl_dim_type type,
2427 unsigned first, unsigned n)
2428{
2429 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
2430 return isl_basic_map_free(bmap);
2431 if (n == 0 && !isl_space_is_named_or_nested(bmap->dim, type))
2432 return bmap;
2433 bmap = isl_basic_map_eliminate_vars(bmap,
2434 isl_basic_map_offset(bmap, type) - 1 + first, n);
2435 if (!bmap)
2436 return bmap;
2437 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY)(!!(((bmap)->flags) & ((1 << 1)))) && type == isl_dim_div)
2438 return bmap;
2439 bmap = isl_basic_map_drop(bmap, type, first, n);
2440 return bmap;
2441}
2442
2443/* Return true if the definition of the given div (recursively) involves
2444 * any of the given variables.
2445 */
2446static isl_bool div_involves_vars(__isl_keep isl_basic_map *bmap, int div,
2447 unsigned first, unsigned n)
2448{
2449 int i;
2450 unsigned div_offset = isl_basic_map_offset(bmap, isl_dim_div);
2451
2452 if (isl_int_is_zero(bmap->div[div][0])(isl_sioimath_sgn(*(bmap->div[div][0])) == 0))
2453 return isl_bool_false;
2454 if (isl_seq_first_non_zero(bmap->div[div] + 1 + first, n) >= 0)
2455 return isl_bool_true;
2456
2457 for (i = bmap->n_div - 1; i >= 0; --i) {
2458 isl_bool involves;
2459
2460 if (isl_int_is_zero(bmap->div[div][1 + div_offset + i])(isl_sioimath_sgn(*(bmap->div[div][1 + div_offset + i])) ==
0)
)
2461 continue;
2462 involves = div_involves_vars(bmap, i, first, n);
2463 if (involves < 0 || involves)
2464 return involves;
2465 }
2466
2467 return isl_bool_false;
2468}
2469
2470/* Try and add a lower and/or upper bound on "div" to "bmap"
2471 * based on inequality "i".
2472 * "total" is the total number of variables (excluding the divs).
2473 * "v" is a temporary object that can be used during the calculations.
2474 * If "lb" is set, then a lower bound should be constructed.
2475 * If "ub" is set, then an upper bound should be constructed.
2476 *
2477 * The calling function has already checked that the inequality does not
2478 * reference "div", but we still need to check that the inequality is
2479 * of the right form. We'll consider the case where we want to construct
2480 * a lower bound. The construction of upper bounds is similar.
2481 *
2482 * Let "div" be of the form
2483 *
2484 * q = floor((a + f(x))/d)
2485 *
2486 * We essentially check if constraint "i" is of the form
2487 *
2488 * b + f(x) >= 0
2489 *
2490 * so that we can use it to derive a lower bound on "div".
2491 * However, we allow a slightly more general form
2492 *
2493 * b + g(x) >= 0
2494 *
2495 * with the condition that the coefficients of g(x) - f(x) are all
2496 * divisible by d.
2497 * Rewriting this constraint as
2498 *
2499 * 0 >= -b - g(x)
2500 *
2501 * adding a + f(x) to both sides and dividing by d, we obtain
2502 *
2503 * (a + f(x))/d >= (a-b)/d + (f(x)-g(x))/d
2504 *
2505 * Taking the floor on both sides, we obtain
2506 *
2507 * q >= floor((a-b)/d) + (f(x)-g(x))/d
2508 *
2509 * or
2510 *
2511 * (g(x)-f(x))/d + ceil((b-a)/d) + q >= 0
2512 *
2513 * In the case of an upper bound, we construct the constraint
2514 *
2515 * (g(x)+f(x))/d + floor((b+a)/d) - q >= 0
2516 *
2517 */
2518static __isl_give isl_basic_map *insert_bounds_on_div_from_ineq(
2519 __isl_take isl_basic_map *bmap, int div, int i,
2520 unsigned total, isl_int v, int lb, int ub)
2521{
2522 int j;
2523
2524 for (j = 0; (lb || ub) && j < total + bmap->n_div; ++j) {
2525 if (lb) {
2526 isl_int_sub(v, bmap->ineq[i][1 + j],isl_sioimath_sub((v), *(bmap->ineq[i][1 + j]), *(bmap->
div[div][1 + 1 + j]))
2527 bmap->div[div][1 + 1 + j])isl_sioimath_sub((v), *(bmap->ineq[i][1 + j]), *(bmap->
div[div][1 + 1 + j]))
;
2528 lb = isl_int_is_divisible_by(v, bmap->div[div][0])isl_sioimath_is_divisible_by(*(v), *(bmap->div[div][0]));
2529 }
2530 if (ub) {
2531 isl_int_add(v, bmap->ineq[i][1 + j],isl_sioimath_add((v), *(bmap->ineq[i][1 + j]), *(bmap->
div[div][1 + 1 + j]))
2532 bmap->div[div][1 + 1 + j])isl_sioimath_add((v), *(bmap->ineq[i][1 + j]), *(bmap->
div[div][1 + 1 + j]))
;
2533 ub = isl_int_is_divisible_by(v, bmap->div[div][0])isl_sioimath_is_divisible_by(*(v), *(bmap->div[div][0]));
2534 }
2535 }
2536 if (!lb && !ub)
2537 return bmap;
2538
2539 bmap = isl_basic_map_cow(bmap);
2540 bmap = isl_basic_map_extend_constraints(bmap, 0, lb + ub);
2541 if (lb) {
2542 int k = isl_basic_map_alloc_inequality(bmap);
2543 if (k < 0)
2544 goto error;
2545 for (j = 0; j < 1 + total + bmap->n_div; ++j) {
2546 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]))
2547 bmap->div[div][1 + j])isl_sioimath_sub((bmap->ineq[k][j]), *(bmap->ineq[i][j]
), *(bmap->div[div][1 + j]))
;
2548 isl_int_cdiv_q(bmap->ineq[k][j],isl_sioimath_cdiv_q((bmap->ineq[k][j]), *(bmap->ineq[k]
[j]), *(bmap->div[div][0]))
2549 bmap->ineq[k][j], bmap->div[div][0])isl_sioimath_cdiv_q((bmap->ineq[k][j]), *(bmap->ineq[k]
[j]), *(bmap->div[div][0]))
;
2550 }
2551 isl_int_set_si(bmap->ineq[k][1 + total + div], 1)isl_sioimath_set_si((bmap->ineq[k][1 + total + div]), 1);
2552 }
2553 if (ub) {
2554 int k = isl_basic_map_alloc_inequality(bmap);
2555 if (k < 0)
2556 goto error;
2557 for (j = 0; j < 1 + total + bmap->n_div; ++j) {
2558 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]))
2559 bmap->div[div][1 + j])isl_sioimath_add((bmap->ineq[k][j]), *(bmap->ineq[i][j]
), *(bmap->div[div][1 + j]))
;
2560 isl_int_fdiv_q(bmap->ineq[k][j],isl_sioimath_fdiv_q((bmap->ineq[k][j]), *(bmap->ineq[k]
[j]), *(bmap->div[div][0]))
2561 bmap->ineq[k][j], bmap->div[div][0])isl_sioimath_fdiv_q((bmap->ineq[k][j]), *(bmap->ineq[k]
[j]), *(bmap->div[div][0]))
;
2562 }
2563 isl_int_set_si(bmap->ineq[k][1 + total + div], -1)isl_sioimath_set_si((bmap->ineq[k][1 + total + div]), -1);
2564 }
2565
2566 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
2567 return bmap;
2568error:
2569 isl_basic_map_free(bmap);
2570 return NULL((void*)0);
2571}
2572
2573/* This function is called right before "div" is eliminated from "bmap"
2574 * using Fourier-Motzkin.
2575 * Look through the constraints of "bmap" for constraints on the argument
2576 * of the integer division and use them to construct constraints on the
2577 * integer division itself. These constraints can then be combined
2578 * during the Fourier-Motzkin elimination.
2579 * Note that it is only useful to introduce lower bounds on "div"
2580 * if "bmap" already contains upper bounds on "div" as the newly
2581 * introduce lower bounds can then be combined with the pre-existing
2582 * upper bounds. Similarly for upper bounds.
2583 * We therefore first check if "bmap" contains any lower and/or upper bounds
2584 * on "div".
2585 *
2586 * It is interesting to note that the introduction of these constraints
2587 * can indeed lead to more accurate results, even when compared to
2588 * deriving constraints on the argument of "div" from constraints on "div".
2589 * Consider, for example, the set
2590 *
2591 * { [i,j,k] : 3 + i + 2j >= 0 and 2 * [(i+2j)/4] <= k }
2592 *
2593 * The second constraint can be rewritten as
2594 *
2595 * 2 * [(-i-2j+3)/4] + k >= 0
2596 *
2597 * from which we can derive
2598 *
2599 * -i - 2j + 3 >= -2k
2600 *
2601 * or
2602 *
2603 * i + 2j <= 3 + 2k
2604 *
2605 * Combined with the first constraint, we obtain
2606 *
2607 * -3 <= 3 + 2k or k >= -3
2608 *
2609 * If, on the other hand we derive a constraint on [(i+2j)/4] from
2610 * the first constraint, we obtain
2611 *
2612 * [(i + 2j)/4] >= [-3/4] = -1
2613 *
2614 * Combining this constraint with the second constraint, we obtain
2615 *
2616 * k >= -2
2617 */
2618static __isl_give isl_basic_map *insert_bounds_on_div(
2619 __isl_take isl_basic_map *bmap, int div)
2620{
2621 int i;
2622 int check_lb, check_ub;
2623 isl_int v;
2624 unsigned total;
2625
2626 if (!bmap)
2627 return NULL((void*)0);
2628
2629 if (isl_int_is_zero(bmap->div[div][0])(isl_sioimath_sgn(*(bmap->div[div][0])) == 0))
2630 return bmap;
2631
2632 total = isl_space_dim(bmap->dim, isl_dim_all);
2633
2634 check_lb = 0;
2635 check_ub = 0;
2636 for (i = 0; (!check_lb || !check_ub) && i < bmap->n_ineq; ++i) {
2637 int s = isl_int_sgn(bmap->ineq[i][1 + total + div])isl_sioimath_sgn(*(bmap->ineq[i][1 + total + div]));
2638 if (s > 0)
2639 check_ub = 1;
2640 if (s < 0)
2641 check_lb = 1;
2642 }
2643
2644 if (!check_lb && !check_ub)
2645 return bmap;
2646
2647 isl_int_init(v)isl_sioimath_init((v));
2648
2649 for (i = 0; bmap && i < bmap->n_ineq; ++i) {
2650 if (!isl_int_is_zero(bmap->ineq[i][1 + total + div])(isl_sioimath_sgn(*(bmap->ineq[i][1 + total + div])) == 0))
2651 continue;
2652
2653 bmap = insert_bounds_on_div_from_ineq(bmap, div, i, total, v,
2654 check_lb, check_ub);
2655 }
2656
2657 isl_int_clear(v)isl_sioimath_clear((v));
2658
2659 return bmap;
2660}
2661
2662/* Remove all divs (recursively) involving any of the given dimensions
2663 * in their definitions.
2664 */
2665__isl_give isl_basic_map *isl_basic_map_remove_divs_involving_dims(
2666 __isl_take isl_basic_map *bmap,
2667 enum isl_dim_type type, unsigned first, unsigned n)
2668{
2669 int i;
2670
2671 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
2672 return isl_basic_map_free(bmap);
2673 first += isl_basic_map_offset(bmap, type);
2674
2675 for (i = bmap->n_div - 1; i >= 0; --i) {
2676 isl_bool involves;
2677
2678 involves = div_involves_vars(bmap, i, first, n);
2679 if (involves < 0)
2680 return isl_basic_map_free(bmap);
2681 if (!involves)
2682 continue;
2683 bmap = insert_bounds_on_div(bmap, i);
2684 bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1);
2685 if (!bmap)
2686 return NULL((void*)0);
2687 i = bmap->n_div;
2688 }
2689
2690 return bmap;
2691}
2692
2693__isl_give isl_basic_setisl_basic_map *isl_basic_set_remove_divs_involving_dims(
2694 __isl_take isl_basic_setisl_basic_map *bset,
2695 enum isl_dim_type type, unsigned first, unsigned n)
2696{
2697 return isl_basic_map_remove_divs_involving_dims(bset, type, first, n);
2698}
2699
2700__isl_give isl_map *isl_map_remove_divs_involving_dims(__isl_take isl_map *map,
2701 enum isl_dim_type type, unsigned first, unsigned n)
2702{
2703 int i;
2704
2705 if (!map)
2706 return NULL((void*)0);
2707 if (map->n == 0)
2708 return map;
2709
2710 map = isl_map_cow(map);
2711 if (!map)
2712 return NULL((void*)0);
2713
2714 for (i = 0; i < map->n; ++i) {
2715 map->p[i] = isl_basic_map_remove_divs_involving_dims(map->p[i],
2716 type, first, n);
2717 if (!map->p[i])
2718 goto error;
2719 }
2720 return map;
2721error:
2722 isl_map_free(map);
2723 return NULL((void*)0);
2724}
2725
2726__isl_give isl_setisl_map *isl_set_remove_divs_involving_dims(__isl_take isl_setisl_map *set,
2727 enum isl_dim_type type, unsigned first, unsigned n)
2728{
2729 return set_from_map(isl_map_remove_divs_involving_dims(set_to_map(set),
2730 type, first, n));
2731}
2732
2733/* Does the description of "bmap" depend on the specified dimensions?
2734 * We also check whether the dimensions appear in any of the div definitions.
2735 * In principle there is no need for this check. If the dimensions appear
2736 * in a div definition, they also appear in the defining constraints of that
2737 * div.
2738 */
2739isl_bool isl_basic_map_involves_dims(__isl_keep isl_basic_map *bmap,
2740 enum isl_dim_type type, unsigned first, unsigned n)
2741{
2742 int i;
2743
2744 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
2745 return isl_bool_error;
2746
2747 first += isl_basic_map_offset(bmap, type);
2748 for (i = 0; i < bmap->n_eq; ++i)
2749 if (isl_seq_first_non_zero(bmap->eq[i] + first, n) >= 0)
2750 return isl_bool_true;
2751 for (i = 0; i < bmap->n_ineq; ++i)
2752 if (isl_seq_first_non_zero(bmap->ineq[i] + first, n) >= 0)
2753 return isl_bool_true;
2754 for (i = 0; i < bmap->n_div; ++i) {
2755 if (isl_int_is_zero(bmap->div[i][0])(isl_sioimath_sgn(*(bmap->div[i][0])) == 0))
2756 continue;
2757 if (isl_seq_first_non_zero(bmap->div[i] + 1 + first, n) >= 0)
2758 return isl_bool_true;
2759 }
2760
2761 return isl_bool_false;
2762}
2763
2764isl_bool isl_map_involves_dims(__isl_keep isl_map *map,
2765 enum isl_dim_type type, unsigned first, unsigned n)
2766{
2767 int i;
2768
2769 if (!map)
2770 return isl_bool_error;
2771
2772 if (first + n > isl_map_dim(map, type))
2773 isl_die(map->ctx, isl_error_invalid,do { isl_handle_error(map->ctx, isl_error_invalid, "index out of bounds"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 2774); return isl_bool_error; } while (0)
2774 "index out of bounds", return isl_bool_error)do { isl_handle_error(map->ctx, isl_error_invalid, "index out of bounds"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 2774); return isl_bool_error; } while (0)
;
2775
2776 for (i = 0; i < map->n; ++i) {
2777 isl_bool involves = isl_basic_map_involves_dims(map->p[i],
2778 type, first, n);
2779 if (involves < 0 || involves)
2780 return involves;
2781 }
2782
2783 return isl_bool_false;
2784}
2785
2786isl_bool isl_basic_set_involves_dims(__isl_keep isl_basic_setisl_basic_map *bset,
2787 enum isl_dim_type type, unsigned first, unsigned n)
2788{
2789 return isl_basic_map_involves_dims(bset, type, first, n);
2790}
2791
2792isl_bool isl_set_involves_dims(__isl_keep isl_setisl_map *set,
2793 enum isl_dim_type type, unsigned first, unsigned n)
2794{
2795 return isl_map_involves_dims(set, type, first, n);
2796}
2797
2798/* Drop all constraints in bmap that involve any of the dimensions
2799 * first to first+n-1.
2800 */
2801static __isl_give isl_basic_map *isl_basic_map_drop_constraints_involving(
2802 __isl_take isl_basic_map *bmap, unsigned first, unsigned n)
2803{
2804 int i;
2805
2806 if (n == 0)
2807 return bmap;
2808
2809 bmap = isl_basic_map_cow(bmap);
2810
2811 if (!bmap)
2812 return NULL((void*)0);
2813
2814 for (i = bmap->n_eq - 1; i >= 0; --i) {
2815 if (isl_seq_first_non_zero(bmap->eq[i] + 1 + first, n) == -1)
2816 continue;
2817 isl_basic_map_drop_equality(bmap, i);
2818 }
2819
2820 for (i = bmap->n_ineq - 1; i >= 0; --i) {
2821 if (isl_seq_first_non_zero(bmap->ineq[i] + 1 + first, n) == -1)
2822 continue;
2823 isl_basic_map_drop_inequality(bmap, i);
2824 }
2825
2826 bmap = isl_basic_map_add_known_div_constraints(bmap);
2827 return bmap;
2828}
2829
2830/* Drop all constraints in bset that involve any of the dimensions
2831 * first to first+n-1.
2832 */
2833__isl_give isl_basic_setisl_basic_map *isl_basic_set_drop_constraints_involving(
2834 __isl_take isl_basic_setisl_basic_map *bset, unsigned first, unsigned n)
2835{
2836 return isl_basic_map_drop_constraints_involving(bset, first, n);
2837}
2838
2839/* Drop all constraints in bmap that do not involve any of the dimensions
2840 * first to first + n - 1 of the given type.
2841 */
2842__isl_give isl_basic_map *isl_basic_map_drop_constraints_not_involving_dims(
2843 __isl_take isl_basic_map *bmap,
2844 enum isl_dim_type type, unsigned first, unsigned n)
2845{
2846 int i;
2847
2848 if (n == 0) {
2849 isl_space *space = isl_basic_map_get_space(bmap);
2850 isl_basic_map_free(bmap);
2851 return isl_basic_map_universe(space);
2852 }
2853 bmap = isl_basic_map_cow(bmap);
2854 if (!bmap)
2855 return NULL((void*)0);
2856
2857 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
2858 return isl_basic_map_free(bmap);
2859
2860 first += isl_basic_map_offset(bmap, type) - 1;
2861
2862 for (i = bmap->n_eq - 1; i >= 0; --i) {
2863 if (isl_seq_first_non_zero(bmap->eq[i] + 1 + first, n) != -1)
2864 continue;
2865 isl_basic_map_drop_equality(bmap, i);
2866 }
2867
2868 for (i = bmap->n_ineq - 1; i >= 0; --i) {
2869 if (isl_seq_first_non_zero(bmap->ineq[i] + 1 + first, n) != -1)
2870 continue;
2871 isl_basic_map_drop_inequality(bmap, i);
2872 }
2873
2874 bmap = isl_basic_map_add_known_div_constraints(bmap);
2875 return bmap;
2876}
2877
2878/* Drop all constraints in bset that do not involve any of the dimensions
2879 * first to first + n - 1 of the given type.
2880 */
2881__isl_give isl_basic_setisl_basic_map *isl_basic_set_drop_constraints_not_involving_dims(
2882 __isl_take isl_basic_setisl_basic_map *bset,
2883 enum isl_dim_type type, unsigned first, unsigned n)
2884{
2885 return isl_basic_map_drop_constraints_not_involving_dims(bset,
2886 type, first, n);
2887}
2888
2889/* Drop all constraints in bmap that involve any of the dimensions
2890 * first to first + n - 1 of the given type.
2891 */
2892__isl_give isl_basic_map *isl_basic_map_drop_constraints_involving_dims(
2893 __isl_take isl_basic_map *bmap,
2894 enum isl_dim_type type, unsigned first, unsigned n)
2895{
2896 if (!bmap)
2897 return NULL((void*)0);
2898 if (n == 0)
2899 return bmap;
2900
2901 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
2902 return isl_basic_map_free(bmap);
2903
2904 bmap = isl_basic_map_remove_divs_involving_dims(bmap, type, first, n);
2905 first += isl_basic_map_offset(bmap, type) - 1;
2906 return isl_basic_map_drop_constraints_involving(bmap, first, n);
2907}
2908
2909/* Drop all constraints in bset that involve any of the dimensions
2910 * first to first + n - 1 of the given type.
2911 */
2912__isl_give isl_basic_setisl_basic_map *isl_basic_set_drop_constraints_involving_dims(
2913 __isl_take isl_basic_setisl_basic_map *bset,
2914 enum isl_dim_type type, unsigned first, unsigned n)
2915{
2916 return isl_basic_map_drop_constraints_involving_dims(bset,
2917 type, first, n);
2918}
2919
2920/* Drop constraints from "map" by applying "drop" to each basic map.
2921 */
2922static __isl_give isl_map *drop_constraints(__isl_take isl_map *map,
2923 enum isl_dim_type type, unsigned first, unsigned n,
2924 __isl_give isl_basic_map *(*drop)(__isl_take isl_basic_map *bmap,
2925 enum isl_dim_type type, unsigned first, unsigned n))
2926{
2927 int i;
2928 unsigned dim;
2929
2930 if (!map)
2931 return NULL((void*)0);
2932
2933 dim = isl_map_dim(map, type);
2934 if (first + n > dim || first + n < first)
2935 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 2936); return isl_map_free(map); } while (0)
2936 "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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 2936); return isl_map_free(map); } while (0)
;
2937
2938 map = isl_map_cow(map);
2939 if (!map)
2940 return NULL((void*)0);
2941
2942 for (i = 0; i < map->n; ++i) {
2943 map->p[i] = drop(map->p[i], type, first, n);
2944 if (!map->p[i])
2945 return isl_map_free(map);
2946 }
2947
2948 if (map->n > 1)
2949 ISL_F_CLR(map, ISL_MAP_DISJOINT)(((map)->flags) &= ~((1 << 0)));
2950
2951 return map;
2952}
2953
2954/* Drop all constraints in map that involve any of the dimensions
2955 * first to first + n - 1 of the given type.
2956 */
2957__isl_give isl_map *isl_map_drop_constraints_involving_dims(
2958 __isl_take isl_map *map,
2959 enum isl_dim_type type, unsigned first, unsigned n)
2960{
2961 if (n == 0)
2962 return map;
2963 return drop_constraints(map, type, first, n,
2964 &isl_basic_map_drop_constraints_involving_dims);
2965}
2966
2967/* Drop all constraints in "map" that do not involve any of the dimensions
2968 * first to first + n - 1 of the given type.
2969 */
2970__isl_give isl_map *isl_map_drop_constraints_not_involving_dims(
2971 __isl_take isl_map *map,
2972 enum isl_dim_type type, unsigned first, unsigned n)
2973{
2974 if (n == 0) {
2975 isl_space *space = isl_map_get_space(map);
2976 isl_map_free(map);
2977 return isl_map_universe(space);
2978 }
2979 return drop_constraints(map, type, first, n,
2980 &isl_basic_map_drop_constraints_not_involving_dims);
2981}
2982
2983/* Drop all constraints in set that involve any of the dimensions
2984 * first to first + n - 1 of the given type.
2985 */
2986__isl_give isl_setisl_map *isl_set_drop_constraints_involving_dims(
2987 __isl_take isl_setisl_map *set,
2988 enum isl_dim_type type, unsigned first, unsigned n)
2989{
2990 return isl_map_drop_constraints_involving_dims(set, type, first, n);
2991}
2992
2993/* Drop all constraints in "set" that do not involve any of the dimensions
2994 * first to first + n - 1 of the given type.
2995 */
2996__isl_give isl_setisl_map *isl_set_drop_constraints_not_involving_dims(
2997 __isl_take isl_setisl_map *set,
2998 enum isl_dim_type type, unsigned first, unsigned n)
2999{
3000 return isl_map_drop_constraints_not_involving_dims(set, type, first, n);
3001}
3002
3003/* Does local variable "div" of "bmap" have a complete explicit representation?
3004 * Having a complete explicit representation requires not only
3005 * an explicit representation, but also that all local variables
3006 * that appear in this explicit representation in turn have
3007 * a complete explicit representation.
3008 */
3009isl_bool isl_basic_map_div_is_known(__isl_keep isl_basic_map *bmap, int div)
3010{
3011 int i;
3012 unsigned div_offset = isl_basic_map_offset(bmap, isl_dim_div);
3013 isl_bool marked;
3014
3015 marked = isl_basic_map_div_is_marked_unknown(bmap, div);
3016 if (marked < 0 || marked)
3017 return isl_bool_not(marked);
3018
3019 for (i = bmap->n_div - 1; i >= 0; --i) {
3020 isl_bool known;
3021
3022 if (isl_int_is_zero(bmap->div[div][1 + div_offset + i])(isl_sioimath_sgn(*(bmap->div[div][1 + div_offset + i])) ==
0)
)
3023 continue;
3024 known = isl_basic_map_div_is_known(bmap, i);
3025 if (known < 0 || !known)
3026 return known;
3027 }
3028
3029 return isl_bool_true;
3030}
3031
3032/* Remove all divs that are unknown or defined in terms of unknown divs.
3033 */
3034__isl_give isl_basic_map *isl_basic_map_remove_unknown_divs(
3035 __isl_take isl_basic_map *bmap)
3036{
3037 int i;
3038
3039 if (!bmap)
3040 return NULL((void*)0);
3041
3042 for (i = bmap->n_div - 1; i >= 0; --i) {
3043 if (isl_basic_map_div_is_known(bmap, i))
3044 continue;
3045 bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1);
3046 if (!bmap)
3047 return NULL((void*)0);
3048 i = bmap->n_div;
3049 }
3050
3051 return bmap;
3052}
3053
3054/* Remove all divs that are unknown or defined in terms of unknown divs.
3055 */
3056__isl_give isl_basic_setisl_basic_map *isl_basic_set_remove_unknown_divs(
3057 __isl_take isl_basic_setisl_basic_map *bset)
3058{
3059 return isl_basic_map_remove_unknown_divs(bset);
3060}
3061
3062__isl_give isl_map *isl_map_remove_unknown_divs(__isl_take isl_map *map)
3063{
3064 int i;
3065
3066 if (!map)
3067 return NULL((void*)0);
3068 if (map->n == 0)
3069 return map;
3070
3071 map = isl_map_cow(map);
3072 if (!map)
3073 return NULL((void*)0);
3074
3075 for (i = 0; i < map->n; ++i) {
3076 map->p[i] = isl_basic_map_remove_unknown_divs(map->p[i]);
3077 if (!map->p[i])
3078 goto error;
3079 }
3080 return map;
3081error:
3082 isl_map_free(map);
3083 return NULL((void*)0);
3084}
3085
3086__isl_give isl_setisl_map *isl_set_remove_unknown_divs(__isl_take isl_setisl_map *set)
3087{
3088 return set_from_map(isl_map_remove_unknown_divs(set_to_map(set)));
3089}
3090
3091__isl_give isl_basic_setisl_basic_map *isl_basic_set_remove_dims(
3092 __isl_take isl_basic_setisl_basic_map *bset,
3093 enum isl_dim_type type, unsigned first, unsigned n)
3094{
3095 isl_basic_map *bmap = bset_to_bmap(bset);
3096 bmap = isl_basic_map_remove_dims(bmap, type, first, n);
3097 return bset_from_bmap(bmap);
3098}
3099
3100__isl_give isl_map *isl_map_remove_dims(__isl_take isl_map *map,
3101 enum isl_dim_type type, unsigned first, unsigned n)
3102{
3103 int i;
3104
3105 if (n == 0)
3106 return map;
3107
3108 map = isl_map_cow(map);
3109 if (!map)
3110 return NULL((void*)0);
3111 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3111); goto error; } while (0); } while (0)
;
3112
3113 for (i = 0; i < map->n; ++i) {
3114 map->p[i] = isl_basic_map_eliminate_vars(map->p[i],
3115 isl_basic_map_offset(map->p[i], type) - 1 + first, n);
3116 if (!map->p[i])
3117 goto error;
3118 }
3119 map = isl_map_drop(map, type, first, n);
3120 return map;
3121error:
3122 isl_map_free(map);
3123 return NULL((void*)0);
3124}
3125
3126__isl_give isl_setisl_map *isl_set_remove_dims(__isl_take isl_setisl_map *bset,
3127 enum isl_dim_type type, unsigned first, unsigned n)
3128{
3129 return set_from_map(isl_map_remove_dims(set_to_map(bset),
3130 type, first, n));
3131}
3132
3133/* Project out n inputs starting at first using Fourier-Motzkin */
3134struct isl_map *isl_map_remove_inputs(struct isl_map *map,
3135 unsigned first, unsigned n)
3136{
3137 return isl_map_remove_dims(map, isl_dim_in, first, n);
3138}
3139
3140static void dump_term(struct isl_basic_map *bmap,
3141 isl_int c, int pos, FILE *out)
3142{
3143 const char *name;
3144 unsigned in = isl_basic_map_dim(bmap, isl_dim_in);
3145 unsigned dim = in + isl_basic_map_dim(bmap, isl_dim_out);
3146 unsigned nparam = isl_basic_map_dim(bmap, isl_dim_param);
3147 if (!pos)
3148 isl_int_print(out, c, 0)isl_sioimath_print(out, *(c), 0);
3149 else {
3150 if (!isl_int_is_one(c)(isl_sioimath_cmp_si(*(c), 1) == 0))
3151 isl_int_print(out, c, 0)isl_sioimath_print(out, *(c), 0);
3152 if (pos < 1 + nparam) {
3153 name = isl_space_get_dim_name(bmap->dim,
3154 isl_dim_param, pos - 1);
3155 if (name)
3156 fprintf(out, "%s", name);
3157 else
3158 fprintf(out, "p%d", pos - 1);
3159 } else if (pos < 1 + nparam + in)
3160 fprintf(out, "i%d", pos - 1 - nparam);
3161 else if (pos < 1 + nparam + dim)
3162 fprintf(out, "o%d", pos - 1 - nparam - in);
3163 else
3164 fprintf(out, "e%d", pos - 1 - nparam - dim);
3165 }
3166}
3167
3168static void dump_constraint_sign(struct isl_basic_map *bmap, isl_int *c,
3169 int sign, FILE *out)
3170{
3171 int i;
3172 int first;
3173 unsigned len = 1 + isl_basic_map_total_dim(bmap);
3174 isl_int v;
3175
3176 isl_int_init(v)isl_sioimath_init((v));
3177 for (i = 0, first = 1; i < len; ++i) {
3178 if (isl_int_sgn(c[i])isl_sioimath_sgn(*(c[i])) * sign <= 0)
3179 continue;
3180 if (!first)
3181 fprintf(out, " + ");
3182 first = 0;
3183 isl_int_abs(v, c[i])isl_sioimath_abs((v), *(c[i]));
3184 dump_term(bmap, v, i, out);
3185 }
3186 isl_int_clear(v)isl_sioimath_clear((v));
3187 if (first)
3188 fprintf(out, "0");
3189}
3190
3191static void dump_constraint(struct isl_basic_map *bmap, isl_int *c,
3192 const char *op, FILE *out, int indent)
3193{
3194 int i;
3195
3196 fprintf(out, "%*s", indent, "");
3197
3198 dump_constraint_sign(bmap, c, 1, out);
3199 fprintf(out, " %s ", op);
3200 dump_constraint_sign(bmap, c, -1, out);
3201
3202 fprintf(out, "\n");
3203
3204 for (i = bmap->n_div; i < bmap->extra; ++i) {
3205 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)
)
3206 continue;
3207 fprintf(out, "%*s", indent, "");
3208 fprintf(out, "ERROR: unused div coefficient not zero\n");
3209 abort();
3210 }
3211}
3212
3213static void dump_constraints(struct isl_basic_map *bmap,
3214 isl_int **c, unsigned n,
3215 const char *op, FILE *out, int indent)
3216{
3217 int i;
3218
3219 for (i = 0; i < n; ++i)
3220 dump_constraint(bmap, c[i], op, out, indent);
3221}
3222
3223static void dump_affine(struct isl_basic_map *bmap, isl_int *exp, FILE *out)
3224{
3225 int j;
3226 int first = 1;
3227 unsigned total = isl_basic_map_total_dim(bmap);
3228
3229 for (j = 0; j < 1 + total; ++j) {
3230 if (isl_int_is_zero(exp[j])(isl_sioimath_sgn(*(exp[j])) == 0))
3231 continue;
3232 if (!first && isl_int_is_pos(exp[j])(isl_sioimath_sgn(*(exp[j])) > 0))
3233 fprintf(out, "+");
3234 dump_term(bmap, exp[j], j, out);
3235 first = 0;
3236 }
3237}
3238
3239static void dump(struct isl_basic_map *bmap, FILE *out, int indent)
3240{
3241 int i;
3242
3243 dump_constraints(bmap, bmap->eq, bmap->n_eq, "=", out, indent);
3244 dump_constraints(bmap, bmap->ineq, bmap->n_ineq, ">=", out, indent);
3245
3246 for (i = 0; i < bmap->n_div; ++i) {
3247 fprintf(out, "%*s", indent, "");
3248 fprintf(out, "e%d = [(", i);
3249 dump_affine(bmap, bmap->div[i]+1, out);
3250 fprintf(out, ")/");
3251 isl_int_print(out, bmap->div[i][0], 0)isl_sioimath_print(out, *(bmap->div[i][0]), 0);
3252 fprintf(out, "]\n");
3253 }
3254}
3255
3256void isl_basic_set_print_internal(struct isl_basic_setisl_basic_map *bset,
3257 FILE *out, int indent)
3258{
3259 if (!bset) {
3260 fprintf(out, "null basic set\n");
3261 return;
3262 }
3263
3264 fprintf(out, "%*s", indent, "");
3265 fprintf(out, "ref: %d, nparam: %d, dim: %d, extra: %d, flags: %x\n",
3266 bset->ref, bset->dim->nparam, bset->dim->n_out,
3267 bset->extra, bset->flags);
3268 dump(bset_to_bmap(bset), out, indent);
3269}
3270
3271void isl_basic_map_print_internal(struct isl_basic_map *bmap,
3272 FILE *out, int indent)
3273{
3274 if (!bmap) {
3275 fprintf(out, "null basic map\n");
3276 return;
3277 }
3278
3279 fprintf(out, "%*s", indent, "");
3280 fprintf(out, "ref: %d, nparam: %d, in: %d, out: %d, extra: %d, "
3281 "flags: %x, n_name: %d\n",
3282 bmap->ref,
3283 bmap->dim->nparam, bmap->dim->n_in, bmap->dim->n_out,
3284 bmap->extra, bmap->flags, bmap->dim->n_id);
3285 dump(bmap, out, indent);
3286}
3287
3288int isl_inequality_negate(struct isl_basic_map *bmap, unsigned pos)
3289{
3290 unsigned total;
3291 if (!bmap)
3292 return -1;
3293 total = isl_basic_map_total_dim(bmap);
3294 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3294); return -1; } while (0); } while (0)
;
3295 isl_seq_neg(bmap->ineq[pos], bmap->ineq[pos], 1 + total);
3296 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)
;
3297 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
3298 return 0;
3299}
3300
3301__isl_give isl_setisl_map *isl_set_alloc_space(__isl_take isl_space *space, int n,
3302 unsigned flags)
3303{
3304 if (!space)
3305 return NULL((void*)0);
3306 if (isl_space_dim(space, isl_dim_in) != 0)
3307 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3308); goto error; } while (0)
3308 "set cannot have input dimensions", goto error)do { isl_handle_error(isl_space_get_ctx(space), isl_error_invalid
, "set cannot have input dimensions", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3308); goto error; } while (0)
;
3309 return isl_map_alloc_space(space, n, flags);
3310error:
3311 isl_space_free(space);
3312 return NULL((void*)0);
3313}
3314
3315/* Make sure "map" has room for at least "n" more basic maps.
3316 */
3317__isl_give isl_map *isl_map_grow(__isl_take isl_map *map, int n)
3318{
3319 int i;
3320 struct isl_map *grown = NULL((void*)0);
3321
3322 if (!map)
3323 return NULL((void*)0);
3324 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3324); goto error; } while (0); } while (0)
;
3325 if (map->n + n <= map->size)
3326 return map;
3327 grown = isl_map_alloc_space(isl_map_get_space(map), map->n + n, map->flags);
3328 if (!grown)
3329 goto error;
3330 for (i = 0; i < map->n; ++i) {
3331 grown->p[i] = isl_basic_map_copy(map->p[i]);
3332 if (!grown->p[i])
3333 goto error;
3334 grown->n++;
3335 }
3336 isl_map_free(map);
3337 return grown;
3338error:
3339 isl_map_free(grown);
3340 isl_map_free(map);
3341 return NULL((void*)0);
3342}
3343
3344/* Make sure "set" has room for at least "n" more basic sets.
3345 */
3346struct isl_setisl_map *isl_set_grow(struct isl_setisl_map *set, int n)
3347{
3348 return set_from_map(isl_map_grow(set_to_map(set), n));
3349}
3350
3351__isl_give isl_setisl_map *isl_set_from_basic_set(__isl_take isl_basic_setisl_basic_map *bset)
3352{
3353 return isl_map_from_basic_map(bset);
3354}
3355
3356__isl_give isl_map *isl_map_from_basic_map(__isl_take isl_basic_map *bmap)
3357{
3358 struct isl_map *map;
3359
3360 if (!bmap)
3361 return NULL((void*)0);
3362
3363 map = isl_map_alloc_space(isl_space_copy(bmap->dim), 1, ISL_MAP_DISJOINT(1 << 0));
3364 return isl_map_add_basic_map(map, bmap);
3365}
3366
3367__isl_give isl_setisl_map *isl_set_add_basic_set(__isl_take isl_setisl_map *set,
3368 __isl_take isl_basic_setisl_basic_map *bset)
3369{
3370 return set_from_map(isl_map_add_basic_map(set_to_map(set),
3371 bset_to_bmap(bset)));
3372}
3373
3374__isl_null isl_setisl_map *isl_set_free(__isl_take isl_setisl_map *set)
3375{
3376 return isl_map_free(set);
3377}
3378
3379void isl_set_print_internal(struct isl_setisl_map *set, FILE *out, int indent)
3380{
3381 int i;
3382
3383 if (!set) {
3384 fprintf(out, "null set\n");
3385 return;
3386 }
3387
3388 fprintf(out, "%*s", indent, "");
3389 fprintf(out, "ref: %d, n: %d, nparam: %d, dim: %d, flags: %x\n",
3390 set->ref, set->n, set->dim->nparam, set->dim->n_out,
3391 set->flags);
3392 for (i = 0; i < set->n; ++i) {
3393 fprintf(out, "%*s", indent, "");
3394 fprintf(out, "basic set %d:\n", i);
3395 isl_basic_set_print_internal(set->p[i], out, indent+4);
3396 }
3397}
3398
3399void isl_map_print_internal(struct isl_map *map, FILE *out, int indent)
3400{
3401 int i;
3402
3403 if (!map) {
3404 fprintf(out, "null map\n");
3405 return;
3406 }
3407
3408 fprintf(out, "%*s", indent, "");
3409 fprintf(out, "ref: %d, n: %d, nparam: %d, in: %d, out: %d, "
3410 "flags: %x, n_name: %d\n",
3411 map->ref, map->n, map->dim->nparam, map->dim->n_in,
3412 map->dim->n_out, map->flags, map->dim->n_id);
3413 for (i = 0; i < map->n; ++i) {
3414 fprintf(out, "%*s", indent, "");
3415 fprintf(out, "basic map %d:\n", i);
3416 isl_basic_map_print_internal(map->p[i], out, indent+4);
3417 }
3418}
3419
3420__isl_give isl_basic_map *isl_basic_map_intersect_domain(
3421 __isl_take isl_basic_map *bmap, __isl_take isl_basic_setisl_basic_map *bset)
3422{
3423 struct isl_basic_map *bmap_domain;
3424
3425 if (isl_basic_map_check_equal_params(bmap, bset_to_bmap(bset)) < 0)
3426 goto error;
3427
3428 if (isl_space_dim(bset->dim, isl_dim_set) != 0)
3429 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3430); goto error; } while (0); } while (0)
3430 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3430); goto error; } while (0); } while (0)
;
3431
3432 bmap = isl_basic_map_cow(bmap);
3433 if (!bmap)
3434 goto error;
3435 bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim),
3436 bset->n_div, bset->n_eq, bset->n_ineq);
3437 bmap_domain = isl_basic_map_from_domain(bset);
3438 bmap = add_constraints(bmap, bmap_domain, 0, 0);
3439
3440 bmap = isl_basic_map_simplify(bmap);
3441 return isl_basic_map_finalize(bmap);
3442error:
3443 isl_basic_map_free(bmap);
3444 isl_basic_set_free(bset);
3445 return NULL((void*)0);
3446}
3447
3448/* Check that the space of "bset" is the same as that of the range of "bmap".
3449 */
3450static isl_stat isl_basic_map_check_compatible_range(
3451 __isl_keep isl_basic_map *bmap, __isl_keep isl_basic_setisl_basic_map *bset)
3452{
3453 isl_bool ok;
3454
3455 ok = isl_basic_map_compatible_range(bmap, bset);
3456 if (ok < 0)
3457 return isl_stat_error;
3458 if (!ok)
3459 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3460); return isl_stat_error; } while (0)
3460 "incompatible spaces", return isl_stat_error)do { isl_handle_error(isl_basic_set_get_ctx(bset), isl_error_invalid
, "incompatible spaces", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3460); return isl_stat_error; } while (0)
;
3461
3462 return isl_stat_ok;
3463}
3464
3465__isl_give isl_basic_map *isl_basic_map_intersect_range(
3466 __isl_take isl_basic_map *bmap, __isl_take isl_basic_setisl_basic_map *bset)
3467{
3468 struct isl_basic_map *bmap_range;
3469
3470 if (isl_basic_map_check_equal_params(bmap, bset_to_bmap(bset)) < 0)
3471 goto error;
3472
3473 if (isl_space_dim(bset->dim, isl_dim_set) != 0 &&
3474 isl_basic_map_check_compatible_range(bmap, bset) < 0)
3475 goto error;
3476
3477 if (isl_basic_set_plain_is_universe(bset)) {
3478 isl_basic_set_free(bset);
3479 return bmap;
3480 }
3481
3482 bmap = isl_basic_map_cow(bmap);
3483 if (!bmap)
3484 goto error;
3485 bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim),
3486 bset->n_div, bset->n_eq, bset->n_ineq);
3487 bmap_range = bset_to_bmap(bset);
3488 bmap = add_constraints(bmap, bmap_range, 0, 0);
3489
3490 bmap = isl_basic_map_simplify(bmap);
3491 return isl_basic_map_finalize(bmap);
3492error:
3493 isl_basic_map_free(bmap);
3494 isl_basic_set_free(bset);
3495 return NULL((void*)0);
3496}
3497
3498isl_bool isl_basic_map_contains(__isl_keep isl_basic_map *bmap,
3499 __isl_keep isl_vec *vec)
3500{
3501 int i;
3502 unsigned total;
3503 isl_int s;
3504
3505 if (!bmap || !vec)
3506 return isl_bool_error;
3507
3508 total = 1 + isl_basic_map_total_dim(bmap);
3509 if (total != vec->size)
3510 return isl_bool_false;
3511
3512 isl_int_init(s)isl_sioimath_init((s));
3513
3514 for (i = 0; i < bmap->n_eq; ++i) {
3515 isl_seq_inner_product(vec->el, bmap->eq[i], total, &s);
3516 if (!isl_int_is_zero(s)(isl_sioimath_sgn(*(s)) == 0)) {
3517 isl_int_clear(s)isl_sioimath_clear((s));
3518 return isl_bool_false;
3519 }
3520 }
3521
3522 for (i = 0; i < bmap->n_ineq; ++i) {
3523 isl_seq_inner_product(vec->el, bmap->ineq[i], total, &s);
3524 if (isl_int_is_neg(s)(isl_sioimath_sgn(*(s)) < 0)) {
3525 isl_int_clear(s)isl_sioimath_clear((s));
3526 return isl_bool_false;
3527 }
3528 }
3529
3530 isl_int_clear(s)isl_sioimath_clear((s));
3531
3532 return isl_bool_true;
3533}
3534
3535isl_bool isl_basic_set_contains(__isl_keep isl_basic_setisl_basic_map *bset,
3536 __isl_keep isl_vec *vec)
3537{
3538 return isl_basic_map_contains(bset_to_bmap(bset), vec);
3539}
3540
3541__isl_give isl_basic_map *isl_basic_map_intersect(
3542 __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
3543{
3544 struct isl_vec *sample = NULL((void*)0);
3545
3546 if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
3547 goto error;
3548 if (isl_space_dim(bmap1->dim, isl_dim_all) ==
3549 isl_space_dim(bmap1->dim, isl_dim_param) &&
3550 isl_space_dim(bmap2->dim, isl_dim_all) !=
3551 isl_space_dim(bmap2->dim, isl_dim_param))
3552 return isl_basic_map_intersect(bmap2, bmap1);
3553
3554 if (isl_space_dim(bmap2->dim, isl_dim_all) !=
3555 isl_space_dim(bmap2->dim, isl_dim_param))
3556 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"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3557); goto error; } while (0); } while (0)
3557 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"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3557); goto error; } while (0); } while (0)
;
3558
3559 if (isl_basic_map_plain_is_empty(bmap1)) {
3560 isl_basic_map_free(bmap2);
3561 return bmap1;
3562 }
3563 if (isl_basic_map_plain_is_empty(bmap2)) {
3564 isl_basic_map_free(bmap1);
3565 return bmap2;
3566 }
3567
3568 if (bmap1->sample &&
3569 isl_basic_map_contains(bmap1, bmap1->sample) > 0 &&
3570 isl_basic_map_contains(bmap2, bmap1->sample) > 0)
3571 sample = isl_vec_copy(bmap1->sample);
3572 else if (bmap2->sample &&
3573 isl_basic_map_contains(bmap1, bmap2->sample) > 0 &&
3574 isl_basic_map_contains(bmap2, bmap2->sample) > 0)
3575 sample = isl_vec_copy(bmap2->sample);
3576
3577 bmap1 = isl_basic_map_cow(bmap1);
3578 if (!bmap1)
3579 goto error;
3580 bmap1 = isl_basic_map_extend_space(bmap1, isl_space_copy(bmap1->dim),
3581 bmap2->n_div, bmap2->n_eq, bmap2->n_ineq);
3582 bmap1 = add_constraints(bmap1, bmap2, 0, 0);
3583
3584 if (!bmap1)
3585 isl_vec_free(sample);
3586 else if (sample) {
3587 isl_vec_free(bmap1->sample);
3588 bmap1->sample = sample;
3589 }
3590
3591 bmap1 = isl_basic_map_simplify(bmap1);
3592 return isl_basic_map_finalize(bmap1);
3593error:
3594 if (sample)
3595 isl_vec_free(sample);
3596 isl_basic_map_free(bmap1);
3597 isl_basic_map_free(bmap2);
3598 return NULL((void*)0);
3599}
3600
3601struct isl_basic_setisl_basic_map *isl_basic_set_intersect(
3602 struct isl_basic_setisl_basic_map *bset1, struct isl_basic_setisl_basic_map *bset2)
3603{
3604 return bset_from_bmap(isl_basic_map_intersect(bset_to_bmap(bset1),
3605 bset_to_bmap(bset2)));
3606}
3607
3608__isl_give isl_basic_setisl_basic_map *isl_basic_set_intersect_params(
3609 __isl_take isl_basic_setisl_basic_map *bset1, __isl_take isl_basic_setisl_basic_map *bset2)
3610{
3611 return isl_basic_set_intersect(bset1, bset2);
3612}
3613
3614/* Special case of isl_map_intersect, where both map1 and map2
3615 * are convex, without any divs and such that either map1 or map2
3616 * contains a single constraint. This constraint is then simply
3617 * added to the other map.
3618 */
3619static __isl_give isl_map *map_intersect_add_constraint(
3620 __isl_take isl_map *map1, __isl_take isl_map *map2)
3621{
3622 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"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3622); goto error; } while (0); } while (0)
;
3623 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"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3623); goto error; } while (0); } while (0)
;
3624 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3624); goto error; } while (0); } while (0)
;
3625 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3625); goto error; } while (0); } while (0)
;
3626
3627 if (map2->p[0]->n_eq + map2->p[0]->n_ineq != 1)
3628 return isl_map_intersect(map2, map1);
3629
3630 map1 = isl_map_cow(map1);
3631 if (!map1)
3632 goto error;
3633 if (isl_map_plain_is_empty(map1)) {
3634 isl_map_free(map2);
3635 return map1;
3636 }
3637 map1->p[0] = isl_basic_map_cow(map1->p[0]);
3638 if (map2->p[0]->n_eq == 1)
3639 map1->p[0] = isl_basic_map_add_eq(map1->p[0], map2->p[0]->eq[0]);
3640 else
3641 map1->p[0] = isl_basic_map_add_ineq(map1->p[0],
3642 map2->p[0]->ineq[0]);
3643
3644 map1->p[0] = isl_basic_map_simplify(map1->p[0]);
3645 map1->p[0] = isl_basic_map_finalize(map1->p[0]);
3646 if (!map1->p[0])
3647 goto error;
3648
3649 if (isl_basic_map_plain_is_empty(map1->p[0])) {
3650 isl_basic_map_free(map1->p[0]);
3651 map1->n = 0;
3652 }
3653
3654 isl_map_free(map2);
3655
3656 return map1;
3657error:
3658 isl_map_free(map1);
3659 isl_map_free(map2);
3660 return NULL((void*)0);
3661}
3662
3663/* map2 may be either a parameter domain or a map living in the same
3664 * space as map1.
3665 */
3666static __isl_give isl_map *map_intersect_internal(__isl_take isl_map *map1,
3667 __isl_take isl_map *map2)
3668{
3669 unsigned flags = 0;
3670 isl_map *result;
3671 int i, j;
3672
3673 if (!map1 || !map2)
3674 goto error;
3675
3676 if ((isl_map_plain_is_empty(map1) ||
3677 isl_map_plain_is_universe(map2)) &&
3678 isl_space_is_equal(map1->dim, map2->dim)) {
3679 isl_map_free(map2);
3680 return map1;
3681 }
3682 if ((isl_map_plain_is_empty(map2) ||
3683 isl_map_plain_is_universe(map1)) &&
3684 isl_space_is_equal(map1->dim, map2->dim)) {
3685 isl_map_free(map1);
3686 return map2;
3687 }
3688
3689 if (map1->n == 1 && map2->n == 1 &&
3690 map1->p[0]->n_div == 0 && map2->p[0]->n_div == 0 &&
3691 isl_space_is_equal(map1->dim, map2->dim) &&
3692 (map1->p[0]->n_eq + map1->p[0]->n_ineq == 1 ||
3693 map2->p[0]->n_eq + map2->p[0]->n_ineq == 1))
3694 return map_intersect_add_constraint(map1, map2);
3695
3696 if (isl_space_dim(map2->dim, isl_dim_all) !=
3697 isl_space_dim(map2->dim, isl_dim_param))
3698 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"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3699); goto error; } while (0); } while (0)
3699 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"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3699); goto error; } while (0); } while (0)
;
3700
3701 if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT)(!!(((map1)->flags) & ((1 << 0)))) &&
3702 ISL_F_ISSET(map2, ISL_MAP_DISJOINT)(!!(((map2)->flags) & ((1 << 0)))))
3703 ISL_FL_SET(flags, ISL_MAP_DISJOINT)((flags) |= ((1 << 0)));
3704
3705 result = isl_map_alloc_space(isl_space_copy(map1->dim),
3706 map1->n * map2->n, flags);
3707 if (!result)
3708 goto error;
3709 for (i = 0; i < map1->n; ++i)
3710 for (j = 0; j < map2->n; ++j) {
3711 struct isl_basic_map *part;
3712 part = isl_basic_map_intersect(
3713 isl_basic_map_copy(map1->p[i]),
3714 isl_basic_map_copy(map2->p[j]));
3715 if (isl_basic_map_is_empty(part) < 0)
3716 part = isl_basic_map_free(part);
3717 result = isl_map_add_basic_map(result, part);
3718 if (!result)
3719 goto error;
3720 }
3721 isl_map_free(map1);
3722 isl_map_free(map2);
3723 return result;
3724error:
3725 isl_map_free(map1);
3726 isl_map_free(map2);
3727 return NULL((void*)0);
3728}
3729
3730static __isl_give isl_map *map_intersect(__isl_take isl_map *map1,
3731 __isl_take isl_map *map2)
3732{
3733 if (!map1 || !map2)
3734 goto error;
3735 if (!isl_space_is_equal(map1->dim, map2->dim))
3736 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3737); goto error; } while (0)
3737 "spaces don't match", goto error)do { isl_handle_error(isl_map_get_ctx(map1), isl_error_invalid
, "spaces don't match", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3737); goto error; } while (0)
;
3738 return map_intersect_internal(map1, map2);
3739error:
3740 isl_map_free(map1);
3741 isl_map_free(map2);
3742 return NULL((void*)0);
3743}
3744
3745__isl_give isl_map *isl_map_intersect(__isl_take isl_map *map1,
3746 __isl_take isl_map *map2)
3747{
3748 return isl_map_align_params_map_map_and(map1, map2, &map_intersect);
3749}
3750
3751struct isl_setisl_map *isl_set_intersect(struct isl_setisl_map *set1, struct isl_setisl_map *set2)
3752{
3753 return set_from_map(isl_map_intersect(set_to_map(set1),
3754 set_to_map(set2)));
3755}
3756
3757/* map_intersect_internal accepts intersections
3758 * with parameter domains, so we can just call that function.
3759 */
3760static __isl_give isl_map *map_intersect_params(__isl_take isl_map *map,
3761 __isl_take isl_setisl_map *params)
3762{
3763 return map_intersect_internal(map, params);
3764}
3765
3766__isl_give isl_map *isl_map_intersect_params(__isl_take isl_map *map1,
3767 __isl_take isl_map *map2)
3768{
3769 return isl_map_align_params_map_map_and(map1, map2, &map_intersect_params);
3770}
3771
3772__isl_give isl_setisl_map *isl_set_intersect_params(__isl_take isl_setisl_map *set,
3773 __isl_take isl_setisl_map *params)
3774{
3775 return isl_map_intersect_params(set, params);
3776}
3777
3778__isl_give isl_basic_map *isl_basic_map_reverse(__isl_take isl_basic_map *bmap)
3779{
3780 isl_space *space;
3781 unsigned pos, n1, n2;
3782
3783 if (!bmap)
3784 return NULL((void*)0);
3785 bmap = isl_basic_map_cow(bmap);
3786 if (!bmap)
3787 return NULL((void*)0);
3788 space = isl_space_reverse(isl_space_copy(bmap->dim));
3789 pos = isl_basic_map_offset(bmap, isl_dim_in);
3790 n1 = isl_basic_map_dim(bmap, isl_dim_in);
3791 n2 = isl_basic_map_dim(bmap, isl_dim_out);
3792 bmap = isl_basic_map_swap_vars(bmap, pos, n1, n2);
3793 return isl_basic_map_reset_space(bmap, space);
3794}
3795
3796static __isl_give isl_basic_map *basic_map_space_reset(
3797 __isl_take isl_basic_map *bmap, enum isl_dim_type type)
3798{
3799 isl_space *space;
3800
3801 if (!bmap)
3802 return NULL((void*)0);
3803 if (!isl_space_is_named_or_nested(bmap->dim, type))
3804 return bmap;
3805
3806 space = isl_basic_map_get_space(bmap);
3807 space = isl_space_reset(space, type);
3808 bmap = isl_basic_map_reset_space(bmap, space);
3809 return bmap;
3810}
3811
3812__isl_give isl_basic_map *isl_basic_map_insert_dims(
3813 __isl_take isl_basic_map *bmap, enum isl_dim_type type,
3814 unsigned pos, unsigned n)
3815{
3816 isl_bool rational;
3817 isl_space *res_dim;
3818 struct isl_basic_map *res;
3819 struct isl_dim_map *dim_map;
3820 unsigned total, off;
3821 enum isl_dim_type t;
3822
3823 if (n == 0)
3824 return basic_map_space_reset(bmap, type);
3825
3826 if (!bmap)
3827 return NULL((void*)0);
3828
3829 res_dim = isl_space_insert_dims(isl_basic_map_get_space(bmap), type, pos, n);
3830
3831 total = isl_basic_map_total_dim(bmap) + n;
3832 dim_map = isl_dim_map_alloc(bmap->ctx, total);
3833 off = 0;
3834 for (t = isl_dim_param; t <= isl_dim_out; ++t) {
3835 if (t != type) {
3836 isl_dim_map_dim(dim_map, bmap->dim, t, off);
3837 } else {
3838 unsigned size = isl_basic_map_dim(bmap, t);
3839 isl_dim_map_dim_range(dim_map, bmap->dim, t,
3840 0, pos, off);
3841 isl_dim_map_dim_range(dim_map, bmap->dim, t,
3842 pos, size - pos, off + pos + n);
3843 }
3844 off += isl_space_dim(res_dim, t);
3845 }
3846 isl_dim_map_div(dim_map, bmap, off);
3847
3848 res = isl_basic_map_alloc_space(res_dim,
3849 bmap->n_div, bmap->n_eq, bmap->n_ineq);
3850 rational = isl_basic_map_is_rational(bmap);
3851 if (rational < 0)
3852 res = isl_basic_map_free(res);
3853 if (rational)
3854 res = isl_basic_map_set_rational(res);
3855 if (isl_basic_map_plain_is_empty(bmap)) {
3856 isl_basic_map_free(bmap);
3857 free(dim_map);
3858 return isl_basic_map_set_to_empty(res);
3859 }
3860 res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
3861 return isl_basic_map_finalize(res);
3862}
3863
3864__isl_give isl_basic_setisl_basic_map *isl_basic_set_insert_dims(
3865 __isl_take isl_basic_setisl_basic_map *bset,
3866 enum isl_dim_type type, unsigned pos, unsigned n)
3867{
3868 return isl_basic_map_insert_dims(bset, type, pos, n);
3869}
3870
3871__isl_give isl_basic_map *isl_basic_map_add_dims(__isl_take isl_basic_map *bmap,
3872 enum isl_dim_type type, unsigned n)
3873{
3874 if (!bmap)
3875 return NULL((void*)0);
3876 return isl_basic_map_insert_dims(bmap, type,
3877 isl_basic_map_dim(bmap, type), n);
3878}
3879
3880__isl_give isl_basic_setisl_basic_map *isl_basic_set_add_dims(__isl_take isl_basic_setisl_basic_map *bset,
3881 enum isl_dim_type type, unsigned n)
3882{
3883 if (!bset)
3884 return NULL((void*)0);
3885 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3885); goto error; } while (0); } while (0)
;
3886 return isl_basic_map_add_dims(bset, type, n);
3887error:
3888 isl_basic_set_free(bset);
3889 return NULL((void*)0);
3890}
3891
3892static __isl_give isl_map *map_space_reset(__isl_take isl_map *map,
3893 enum isl_dim_type type)
3894{
3895 isl_space *space;
3896
3897 if (!map || !isl_space_is_named_or_nested(map->dim, type))
3898 return map;
3899
3900 space = isl_map_get_space(map);
3901 space = isl_space_reset(space, type);
3902 map = isl_map_reset_space(map, space);
3903 return map;
3904}
3905
3906__isl_give isl_map *isl_map_insert_dims(__isl_take isl_map *map,
3907 enum isl_dim_type type, unsigned pos, unsigned n)
3908{
3909 int i;
3910
3911 if (n == 0)
3912 return map_space_reset(map, type);
3913
3914 map = isl_map_cow(map);
3915 if (!map)
3916 return NULL((void*)0);
3917
3918 map->dim = isl_space_insert_dims(map->dim, type, pos, n);
3919 if (!map->dim)
3920 goto error;
3921
3922 for (i = 0; i < map->n; ++i) {
3923 map->p[i] = isl_basic_map_insert_dims(map->p[i], type, pos, n);
3924 if (!map->p[i])
3925 goto error;
3926 }
3927
3928 return map;
3929error:
3930 isl_map_free(map);
3931 return NULL((void*)0);
3932}
3933
3934__isl_give isl_setisl_map *isl_set_insert_dims(__isl_take isl_setisl_map *set,
3935 enum isl_dim_type type, unsigned pos, unsigned n)
3936{
3937 return isl_map_insert_dims(set, type, pos, n);
3938}
3939
3940__isl_give isl_map *isl_map_add_dims(__isl_take isl_map *map,
3941 enum isl_dim_type type, unsigned n)
3942{
3943 if (!map)
3944 return NULL((void*)0);
3945 return isl_map_insert_dims(map, type, isl_map_dim(map, type), n);
3946}
3947
3948__isl_give isl_setisl_map *isl_set_add_dims(__isl_take isl_setisl_map *set,
3949 enum isl_dim_type type, unsigned n)
3950{
3951 if (!set)
3952 return NULL((void*)0);
3953 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3953); goto error; } while (0); } while (0)
;
3954 return set_from_map(isl_map_add_dims(set_to_map(set), type, n));
3955error:
3956 isl_set_free(set);
3957 return NULL((void*)0);
3958}
3959
3960__isl_give isl_basic_map *isl_basic_map_move_dims(
3961 __isl_take isl_basic_map *bmap,
3962 enum isl_dim_type dst_type, unsigned dst_pos,
3963 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
3964{
3965 struct isl_dim_map *dim_map;
3966 struct isl_basic_map *res;
3967 enum isl_dim_type t;
3968 unsigned total, off;
3969
3970 if (!bmap)
3971 return NULL((void*)0);
3972 if (n == 0) {
3973 bmap = isl_basic_map_reset(bmap, src_type);
3974 bmap = isl_basic_map_reset(bmap, dst_type);
3975 return bmap;
3976 }
3977
3978 if (isl_basic_map_check_range(bmap, src_type, src_pos, n) < 0)
3979 return isl_basic_map_free(bmap);
3980
3981 if (dst_type == src_type && dst_pos == src_pos)
3982 return bmap;
3983
3984 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 3984); goto error; } while (0); } while (0)
;
3985
3986 if (pos(bmap->dim, dst_type) + dst_pos ==
3987 pos(bmap->dim, src_type) + src_pos +
3988 ((src_type < dst_type) ? n : 0)) {
3989 bmap = isl_basic_map_cow(bmap);
3990 if (!bmap)
3991 return NULL((void*)0);
3992
3993 bmap->dim = isl_space_move_dims(bmap->dim, dst_type, dst_pos,
3994 src_type, src_pos, n);
3995 if (!bmap->dim)
3996 goto error;
3997
3998 bmap = isl_basic_map_finalize(bmap);
3999
4000 return bmap;
4001 }
4002
4003 total = isl_basic_map_total_dim(bmap);
4004 dim_map = isl_dim_map_alloc(bmap->ctx, total);
4005
4006 off = 0;
4007 for (t = isl_dim_param; t <= isl_dim_out; ++t) {
4008 unsigned size = isl_space_dim(bmap->dim, t);
4009 if (t == dst_type) {
4010 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4011 0, dst_pos, off);
4012 off += dst_pos;
4013 isl_dim_map_dim_range(dim_map, bmap->dim, src_type,
4014 src_pos, n, off);
4015 off += n;
4016 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4017 dst_pos, size - dst_pos, off);
4018 off += size - dst_pos;
4019 } else if (t == src_type) {
4020 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4021 0, src_pos, off);
4022 off += src_pos;
4023 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4024 src_pos + n, size - src_pos - n, off);
4025 off += size - src_pos - n;
4026 } else {
4027 isl_dim_map_dim(dim_map, bmap->dim, t, off);
4028 off += size;
4029 }
4030 }
4031 isl_dim_map_div(dim_map, bmap, off);
4032
4033 res = isl_basic_map_alloc_space(isl_basic_map_get_space(bmap),
4034 bmap->n_div, bmap->n_eq, bmap->n_ineq);
4035 bmap = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
4036 if (!bmap)
4037 goto error;
4038
4039 bmap->dim = isl_space_move_dims(bmap->dim, dst_type, dst_pos,
4040 src_type, src_pos, n);
4041 if (!bmap->dim)
4042 goto error;
4043
4044 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED)(((bmap)->flags) &= ~((1 << 5)));
4045 bmap = isl_basic_map_gauss(bmap, NULL((void*)0));
4046 bmap = isl_basic_map_finalize(bmap);
4047
4048 return bmap;
4049error:
4050 isl_basic_map_free(bmap);
4051 return NULL((void*)0);
4052}
4053
4054__isl_give isl_basic_setisl_basic_map *isl_basic_set_move_dims(__isl_take isl_basic_setisl_basic_map *bset,
4055 enum isl_dim_type dst_type, unsigned dst_pos,
4056 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
4057{
4058 isl_basic_map *bmap = bset_to_bmap(bset);
4059 bmap = isl_basic_map_move_dims(bmap, dst_type, dst_pos,
4060 src_type, src_pos, n);
4061 return bset_from_bmap(bmap);
4062}
4063
4064__isl_give isl_setisl_map *isl_set_move_dims(__isl_take isl_setisl_map *set,
4065 enum isl_dim_type dst_type, unsigned dst_pos,
4066 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
4067{
4068 if (!set)
4069 return NULL((void*)0);
4070 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4070); goto error; } while (0); } while (0)
;
4071 return set_from_map(isl_map_move_dims(set_to_map(set),
4072 dst_type, dst_pos, src_type, src_pos, n));
4073error:
4074 isl_set_free(set);
4075 return NULL((void*)0);
4076}
4077
4078__isl_give isl_map *isl_map_move_dims(__isl_take isl_map *map,
4079 enum isl_dim_type dst_type, unsigned dst_pos,
4080 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
4081{
4082 int i;
4083
4084 if (!map)
4085 return NULL((void*)0);
4086 if (n == 0) {
4087 map = isl_map_reset(map, src_type);
4088 map = isl_map_reset(map, dst_type);
4089 return map;
4090 }
4091
4092 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4093); goto error; } while (0); } while (0)
4093 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4093); goto error; } while (0); } while (0)
;
4094
4095 if (dst_type == src_type && dst_pos == src_pos)
4096 return map;
4097
4098 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4098); goto error; } while (0); } while (0)
;
4099
4100 map = isl_map_cow(map);
4101 if (!map)
4102 return NULL((void*)0);
4103
4104 map->dim = isl_space_move_dims(map->dim, dst_type, dst_pos, src_type, src_pos, n);
4105 if (!map->dim)
4106 goto error;
4107
4108 for (i = 0; i < map->n; ++i) {
4109 map->p[i] = isl_basic_map_move_dims(map->p[i],
4110 dst_type, dst_pos,
4111 src_type, src_pos, n);
4112 if (!map->p[i])
4113 goto error;
4114 }
4115
4116 return map;
4117error:
4118 isl_map_free(map);
4119 return NULL((void*)0);
4120}
4121
4122/* Move the specified dimensions to the last columns right before
4123 * the divs. Don't change the dimension specification of bmap.
4124 * That's the responsibility of the caller.
4125 */
4126static __isl_give isl_basic_map *move_last(__isl_take isl_basic_map *bmap,
4127 enum isl_dim_type type, unsigned first, unsigned n)
4128{
4129 struct isl_dim_map *dim_map;
4130 struct isl_basic_map *res;
4131 enum isl_dim_type t;
4132 unsigned total, off;
4133
4134 if (!bmap)
4135 return NULL((void*)0);
4136 if (pos(bmap->dim, type) + first + n ==
4137 1 + isl_space_dim(bmap->dim, isl_dim_all))
4138 return bmap;
4139
4140 total = isl_basic_map_total_dim(bmap);
4141 dim_map = isl_dim_map_alloc(bmap->ctx, total);
4142
4143 off = 0;
4144 for (t = isl_dim_param; t <= isl_dim_out; ++t) {
4145 unsigned size = isl_space_dim(bmap->dim, t);
4146 if (t == type) {
4147 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4148 0, first, off);
4149 off += first;
4150 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4151 first, n, total - bmap->n_div - n);
4152 isl_dim_map_dim_range(dim_map, bmap->dim, t,
4153 first + n, size - (first + n), off);
4154 off += size - (first + n);
4155 } else {
4156 isl_dim_map_dim(dim_map, bmap->dim, t, off);
4157 off += size;
4158 }
4159 }
4160 isl_dim_map_div(dim_map, bmap, off + n);
4161
4162 res = isl_basic_map_alloc_space(isl_basic_map_get_space(bmap),
4163 bmap->n_div, bmap->n_eq, bmap->n_ineq);
4164 res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
4165 return res;
4166}
4167
4168/* Insert "n" rows in the divs of "bmap".
4169 *
4170 * The number of columns is not changed, which means that the last
4171 * dimensions of "bmap" are being reintepreted as the new divs.
4172 * The space of "bmap" is not adjusted, however, which means
4173 * that "bmap" is left in an inconsistent state. Removing "n" dimensions
4174 * from the space of "bmap" is the responsibility of the caller.
4175 */
4176static __isl_give isl_basic_map *insert_div_rows(__isl_take isl_basic_map *bmap,
4177 int n)
4178{
4179 int i;
4180 size_t row_size;
4181 isl_int **new_div;
4182 isl_int *old;
4183
4184 bmap = isl_basic_map_cow(bmap);
4185 if (!bmap)
4186 return NULL((void*)0);
4187
4188 row_size = 1 + isl_space_dim(bmap->dim, isl_dim_all) + bmap->extra;
4189 old = bmap->block2.data;
4190 bmap->block2 = isl_blk_extend(bmap->ctx, bmap->block2,
4191 (bmap->extra + n) * (1 + row_size));
4192 if (!bmap->block2.data)
4193 return isl_basic_map_free(bmap);
4194 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 *)))
;
4195 if (!new_div)
4196 return isl_basic_map_free(bmap);
4197 for (i = 0; i < n; ++i) {
4198 new_div[i] = bmap->block2.data +
4199 (bmap->extra + i) * (1 + row_size);
4200 isl_seq_clr(new_div[i], 1 + row_size);
4201 }
4202 for (i = 0; i < bmap->extra; ++i)
4203 new_div[n + i] = bmap->block2.data + (bmap->div[i] - old);
4204 free(bmap->div);
4205 bmap->div = new_div;
4206 bmap->n_div += n;
4207 bmap->extra += n;
4208
4209 return bmap;
4210}
4211
4212/* Drop constraints from "bmap" that only involve the variables
4213 * of "type" in the range [first, first + n] that are not related
4214 * to any of the variables outside that interval.
4215 * These constraints cannot influence the values for the variables
4216 * outside the interval, except in case they cause "bmap" to be empty.
4217 * Only drop the constraints if "bmap" is known to be non-empty.
4218 */
4219static __isl_give isl_basic_map *drop_irrelevant_constraints(
4220 __isl_take isl_basic_map *bmap, enum isl_dim_type type,
4221 unsigned first, unsigned n)
4222{
4223 int i;
4224 int *groups;
4225 unsigned dim, n_div;
4226 isl_bool non_empty;
4227
4228 non_empty = isl_basic_map_plain_is_non_empty(bmap);
4229 if (non_empty < 0)
4230 return isl_basic_map_free(bmap);
4231 if (!non_empty)
4232 return bmap;
4233
4234 dim = isl_basic_map_dim(bmap, isl_dim_all);
4235 n_div = isl_basic_map_dim(bmap, isl_dim_div);
4236 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)))
;
4237 if (!groups)
4238 return isl_basic_map_free(bmap);
4239 first += isl_basic_map_offset(bmap, type) - 1;
4240 for (i = 0; i < first; ++i)
4241 groups[i] = -1;
4242 for (i = first + n; i < dim - n_div; ++i)
4243 groups[i] = -1;
4244
4245 bmap = isl_basic_map_drop_unrelated_constraints(bmap, groups);
4246
4247 return bmap;
4248}
4249
4250/* Turn the n dimensions of type type, starting at first
4251 * into existentially quantified variables.
4252 *
4253 * If a subset of the projected out variables are unrelated
4254 * to any of the variables that remain, then the constraints
4255 * involving this subset are simply dropped first.
4256 */
4257__isl_give isl_basic_map *isl_basic_map_project_out(
4258 __isl_take isl_basic_map *bmap,
4259 enum isl_dim_type type, unsigned first, unsigned n)
4260{
4261 isl_bool empty;
4262
4263 if (n == 0)
4264 return basic_map_space_reset(bmap, type);
4265 if (type == isl_dim_div)
4266 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4268); return isl_basic_map_free(bmap); } while (0)
4267 "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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4268); return isl_basic_map_free(bmap); } while (0)
4268 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4268); return isl_basic_map_free(bmap); } while (0)
;
4269
4270 empty = isl_basic_map_plain_is_empty(bmap);
4271 if (empty < 0)
4272 return isl_basic_map_free(bmap);
4273 if (empty)
4274 bmap = isl_basic_map_set_to_empty(bmap);
4275
4276 bmap = drop_irrelevant_constraints(bmap, type, first, n);
4277 if (!bmap)
4278 return NULL((void*)0);
4279
4280 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)(!!(((bmap)->flags) & ((1 << 4)))))
4281 return isl_basic_map_remove_dims(bmap, type, first, n);
4282
4283 if (isl_basic_map_check_range(bmap, type, first, n) < 0)
4284 return isl_basic_map_free(bmap);
4285
4286 bmap = move_last(bmap, type, first, n);
4287 bmap = isl_basic_map_cow(bmap);
4288 bmap = insert_div_rows(bmap, n);
4289 if (!bmap)
4290 return NULL((void*)0);
4291
4292 bmap->dim = isl_space_drop_dims(bmap->dim, type, first, n);
4293 if (!bmap->dim)
4294 goto error;
4295 bmap = isl_basic_map_simplify(bmap);
4296 bmap = isl_basic_map_drop_redundant_divs(bmap);
4297 return isl_basic_map_finalize(bmap);
4298error:
4299 isl_basic_map_free(bmap);
4300 return NULL((void*)0);
4301}
4302
4303/* Turn the n dimensions of type type, starting at first
4304 * into existentially quantified variables.
4305 */
4306struct isl_basic_setisl_basic_map *isl_basic_set_project_out(struct isl_basic_setisl_basic_map *bset,
4307 enum isl_dim_type type, unsigned first, unsigned n)
4308{
4309 return bset_from_bmap(isl_basic_map_project_out(bset_to_bmap(bset),
4310 type, first, n));
4311}
4312
4313/* Turn the n dimensions of type type, starting at first
4314 * into existentially quantified variables.
4315 */
4316__isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
4317 enum isl_dim_type type, unsigned first, unsigned n)
4318{
4319 int i;
4320
4321 if (!map)
4322 return NULL((void*)0);
4323
4324 if (n == 0)
4325 return map_space_reset(map, type);
4326
4327 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4327); goto error; } while (0); } while (0)
;
4328
4329 map = isl_map_cow(map);
4330 if (!map)
4331 return NULL((void*)0);
4332
4333 map->dim = isl_space_drop_dims(map->dim, type, first, n);
4334 if (!map->dim)
4335 goto error;
4336
4337 for (i = 0; i < map->n; ++i) {
4338 map->p[i] = isl_basic_map_project_out(map->p[i], type, first, n);
4339 if (!map->p[i])
4340 goto error;
4341 }
4342
4343 return map;
4344error:
4345 isl_map_free(map);
4346 return NULL((void*)0);
4347}
4348
4349/* Turn the n dimensions of type type, starting at first
4350 * into existentially quantified variables.
4351 */
4352__isl_give isl_setisl_map *isl_set_project_out(__isl_take isl_setisl_map *set,
4353 enum isl_dim_type type, unsigned first, unsigned n)
4354{
4355 return set_from_map(isl_map_project_out(set_to_map(set),
4356 type, first, n));
4357}
4358
4359/* Return a map that projects the elements in "set" onto their
4360 * "n" set dimensions starting at "first".
4361 * "type" should be equal to isl_dim_set.
4362 */
4363__isl_give isl_map *isl_set_project_onto_map(__isl_take isl_setisl_map *set,
4364 enum isl_dim_type type, unsigned first, unsigned n)
4365{
4366 int i;
4367 int dim;
4368 isl_map *map;
4369
4370 if (!set)
4371 return NULL((void*)0);
4372 if (type != isl_dim_set)
4373 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4374); goto error; } while (0)
4374 "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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4374); goto error; } while (0)
;
4375 dim = isl_set_dim(set, isl_dim_set);
4376 if (first + n > dim || first + n < first)
4377 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4378); goto error; } while (0)
4378 "index out of bounds", goto error)do { isl_handle_error(isl_set_get_ctx(set), isl_error_invalid
, "index out of bounds", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4378); goto error; } while (0)
;
4379
4380 map = isl_map_from_domain(set);
4381 map = isl_map_add_dims(map, isl_dim_out, n);
4382 for (i = 0; i < n; ++i)
4383 map = isl_map_equate(map, isl_dim_in, first + i,
4384 isl_dim_out, i);
4385 return map;
4386error:
4387 isl_set_free(set);
4388 return NULL((void*)0);
4389}
4390
4391static struct isl_basic_map *add_divs(struct isl_basic_map *bmap, unsigned n)
4392{
4393 int i, j;
4394
4395 for (i = 0; i < n; ++i) {
4396 j = isl_basic_map_alloc_div(bmap);
4397 if (j < 0)
4398 goto error;
4399 isl_seq_clr(bmap->div[j], 1+1+isl_basic_map_total_dim(bmap));
4400 }
4401 return bmap;
4402error:
4403 isl_basic_map_free(bmap);
4404 return NULL((void*)0);
4405}
4406
4407struct isl_basic_map *isl_basic_map_apply_range(
4408 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
4409{
4410 isl_space *dim_result = NULL((void*)0);
4411 struct isl_basic_map *bmap;
4412 unsigned n_in, n_out, n, nparam, total, pos;
4413 struct isl_dim_map *dim_map1, *dim_map2;
4414
4415 if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
4416 goto error;
4417 if (!isl_space_tuple_is_equal(bmap1->dim, isl_dim_out,
4418 bmap2->dim, isl_dim_in))
4419 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4420); goto error; } while (0)
4420 "spaces don't match", goto error)do { isl_handle_error(isl_basic_map_get_ctx(bmap1), isl_error_invalid
, "spaces don't match", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4420); goto error; } while (0)
;
4421
4422 dim_result = isl_space_join(isl_space_copy(bmap1->dim),
4423 isl_space_copy(bmap2->dim));
4424
4425 n_in = isl_basic_map_dim(bmap1, isl_dim_in);
4426 n_out = isl_basic_map_dim(bmap2, isl_dim_out);
4427 n = isl_basic_map_dim(bmap1, isl_dim_out);
4428 nparam = isl_basic_map_dim(bmap1, isl_dim_param);
4429
4430 total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + n;
4431 dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
4432 dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
4433 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
4434 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0);
4435 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
4436 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_in);
4437 isl_dim_map_div(dim_map1, bmap1, pos += n_out);
4438 isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
4439 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
4440 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
4441
4442 bmap = isl_basic_map_alloc_space(dim_result,
4443 bmap1->n_div + bmap2->n_div + n,
4444 bmap1->n_eq + bmap2->n_eq,
4445 bmap1->n_ineq + bmap2->n_ineq);
4446 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
4447 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
4448 bmap = add_divs(bmap, n);
4449 bmap = isl_basic_map_simplify(bmap);
4450 bmap = isl_basic_map_drop_redundant_divs(bmap);
4451 return isl_basic_map_finalize(bmap);
4452error:
4453 isl_basic_map_free(bmap1);
4454 isl_basic_map_free(bmap2);
4455 return NULL((void*)0);
4456}
4457
4458struct isl_basic_setisl_basic_map *isl_basic_set_apply(
4459 struct isl_basic_setisl_basic_map *bset, struct isl_basic_map *bmap)
4460{
4461 if (!bset || !bmap)
4462 goto error;
4463
4464 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4465); goto error; } while (0); } while (0)
4465 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4465); goto error; } while (0); } while (0)
;
4466
4467 return bset_from_bmap(isl_basic_map_apply_range(bset_to_bmap(bset),
4468 bmap));
4469error:
4470 isl_basic_set_free(bset);
4471 isl_basic_map_free(bmap);
4472 return NULL((void*)0);
4473}
4474
4475struct isl_basic_map *isl_basic_map_apply_domain(
4476 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
4477{
4478 if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
4479 goto error;
4480 if (!isl_space_tuple_is_equal(bmap1->dim, isl_dim_in,
4481 bmap2->dim, isl_dim_in))
4482 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4483); goto error; } while (0)
4483 "spaces don't match", goto error)do { isl_handle_error(isl_basic_map_get_ctx(bmap1), isl_error_invalid
, "spaces don't match", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4483); goto error; } while (0)
;
4484
4485 bmap1 = isl_basic_map_reverse(bmap1);
4486 bmap1 = isl_basic_map_apply_range(bmap1, bmap2);
4487 return isl_basic_map_reverse(bmap1);
4488error:
4489 isl_basic_map_free(bmap1);
4490 isl_basic_map_free(bmap2);
4491 return NULL((void*)0);
4492}
4493
4494/* Given two basic maps A -> f(A) and B -> g(B), construct a basic map
4495 * A \cap B -> f(A) + f(B)
4496 */
4497__isl_give isl_basic_map *isl_basic_map_sum(__isl_take isl_basic_map *bmap1,
4498 __isl_take isl_basic_map *bmap2)
4499{
4500 unsigned n_in, n_out, nparam, total, pos;
4501 struct isl_basic_map *bmap = NULL((void*)0);
4502 struct isl_dim_map *dim_map1, *dim_map2;
4503 int i;
4504
4505 if (!bmap1 || !bmap2)
4506 goto error;
4507
4508 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"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4509); goto error; } while (0); } while (0)
4509 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"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4509); goto error; } while (0); } while (0)
;
4510
4511 nparam = isl_basic_map_dim(bmap1, isl_dim_param);
4512 n_in = isl_basic_map_dim(bmap1, isl_dim_in);
4513 n_out = isl_basic_map_dim(bmap1, isl_dim_out);
4514
4515 total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + 2 * n_out;
4516 dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
4517 dim_map2 = isl_dim_map_alloc(bmap2->ctx, total);
4518 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0);
4519 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos);
4520 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam);
4521 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
4522 isl_dim_map_div(dim_map1, bmap1, pos += n_in + n_out);
4523 isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
4524 isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
4525 isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_out);
4526
4527 bmap = isl_basic_map_alloc_space(isl_space_copy(bmap1->dim),
4528 bmap1->n_div + bmap2->n_div + 2 * n_out,
4529 bmap1->n_eq + bmap2->n_eq + n_out,
4530 bmap1->n_ineq + bmap2->n_ineq);
4531 for (i = 0; i < n_out; ++i) {
4532 int j = isl_basic_map_alloc_equality(bmap);
4533 if (j < 0)
4534 goto error;
4535 isl_seq_clr(bmap->eq[j], 1+total);
4536 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);
4537 isl_int_set_si(bmap->eq[j][1+pos+i], 1)isl_sioimath_set_si((bmap->eq[j][1+pos+i]), 1);
4538 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);
4539 }
4540 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
4541 bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
4542 bmap = add_divs(bmap, 2 * n_out);
4543
4544 bmap = isl_basic_map_simplify(bmap);
4545 return isl_basic_map_finalize(bmap);
4546error:
4547 isl_basic_map_free(bmap);
4548 isl_basic_map_free(bmap1);
4549 isl_basic_map_free(bmap2);
4550 return NULL((void*)0);
4551}
4552
4553/* Given two maps A -> f(A) and B -> g(B), construct a map
4554 * A \cap B -> f(A) + f(B)
4555 */
4556__isl_give isl_map *isl_map_sum(__isl_take isl_map *map1,
4557 __isl_take isl_map *map2)
4558{
4559 struct isl_map *result;
4560 int i, j;
4561
4562 if (!map1 || !map2)
4563 goto error;
4564
4565 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"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4565); goto error; } while (0); } while (0)
;
4566
4567 result = isl_map_alloc_space(isl_space_copy(map1->dim),
4568 map1->n * map2->n, 0);
4569 if (!result)
4570 goto error;
4571 for (i = 0; i < map1->n; ++i)
4572 for (j = 0; j < map2->n; ++j) {
4573 struct isl_basic_map *part;
4574 part = isl_basic_map_sum(
4575 isl_basic_map_copy(map1->p[i]),
4576 isl_basic_map_copy(map2->p[j]));
4577 if (isl_basic_map_is_empty(part))
4578 isl_basic_map_free(part);
4579 else
4580 result = isl_map_add_basic_map(result, part);
4581 if (!result)
4582 goto error;
4583 }
4584 isl_map_free(map1);
4585 isl_map_free(map2);
4586 return result;
4587error:
4588 isl_map_free(map1);
4589 isl_map_free(map2);
4590 return NULL((void*)0);
4591}
4592
4593__isl_give isl_setisl_map *isl_set_sum(__isl_take isl_setisl_map *set1,
4594 __isl_take isl_setisl_map *set2)
4595{
4596 return set_from_map(isl_map_sum(set_to_map(set1), set_to_map(set2)));
4597}
4598
4599/* Given a basic map A -> f(A), construct A -> -f(A).
4600 */
4601__isl_give isl_basic_map *isl_basic_map_neg(__isl_take isl_basic_map *bmap)
4602{
4603 int i, j;
4604 unsigned off, n;
4605
4606 bmap = isl_basic_map_cow(bmap);
4607 if (!bmap)
4608 return NULL((void*)0);
4609
4610 n = isl_basic_map_dim(bmap, isl_dim_out);
4611 off = isl_basic_map_offset(bmap, isl_dim_out);
4612 for (i = 0; i < bmap->n_eq; ++i)
4613 for (j = 0; j < n; ++j)
4614 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]))
;
4615 for (i = 0; i < bmap->n_ineq; ++i)
4616 for (j = 0; j < n; ++j)
4617 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]))
;
4618 for (i = 0; i < bmap->n_div; ++i)
4619 for (j = 0; j < n; ++j)
4620 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]))
;
4621 bmap = isl_basic_map_gauss(bmap, NULL((void*)0));
4622 return isl_basic_map_finalize(bmap);
4623}
4624
4625__isl_give isl_basic_setisl_basic_map *isl_basic_set_neg(__isl_take isl_basic_setisl_basic_map *bset)
4626{
4627 return isl_basic_map_neg(bset);
4628}
4629
4630/* Given a map A -> f(A), construct A -> -f(A).
4631 */
4632__isl_give isl_map *isl_map_neg(__isl_take isl_map *map)
4633{
4634 int i;
4635
4636 map = isl_map_cow(map);
4637 if (!map)
4638 return NULL((void*)0);
4639
4640 for (i = 0; i < map->n; ++i) {
4641 map->p[i] = isl_basic_map_neg(map->p[i]);
4642 if (!map->p[i])
4643 goto error;
4644 }
4645
4646 return map;
4647error:
4648 isl_map_free(map);
4649 return NULL((void*)0);
4650}
4651
4652__isl_give isl_setisl_map *isl_set_neg(__isl_take isl_setisl_map *set)
4653{
4654 return set_from_map(isl_map_neg(set_to_map(set)));
4655}
4656
4657/* Given a basic map A -> f(A) and an integer d, construct a basic map
4658 * A -> floor(f(A)/d).
4659 */
4660__isl_give isl_basic_map *isl_basic_map_floordiv(__isl_take isl_basic_map *bmap,
4661 isl_int d)
4662{
4663 unsigned n_in, n_out, nparam, total, pos;
4664 struct isl_basic_map *result = NULL((void*)0);
4665 struct isl_dim_map *dim_map;
4666 int i;
4667
4668 if (!bmap)
4669 return NULL((void*)0);
4670
4671 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4672 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4673 n_out = isl_basic_map_dim(bmap, isl_dim_out);
4674
4675 total = nparam + n_in + n_out + bmap->n_div + n_out;
4676 dim_map = isl_dim_map_alloc(bmap->ctx, total);
4677 isl_dim_map_dim(dim_map, bmap->dim, isl_dim_param, pos = 0);
4678 isl_dim_map_dim(dim_map, bmap->dim, isl_dim_in, pos += nparam);
4679 isl_dim_map_div(dim_map, bmap, pos += n_in + n_out);
4680 isl_dim_map_dim(dim_map, bmap->dim, isl_dim_out, pos += bmap->n_div);
4681
4682 result = isl_basic_map_alloc_space(isl_space_copy(bmap->dim),
4683 bmap->n_div + n_out,
4684 bmap->n_eq, bmap->n_ineq + 2 * n_out);
4685 result = isl_basic_map_add_constraints_dim_map(result, bmap, dim_map);
4686 result = add_divs(result, n_out);
4687 for (i = 0; i < n_out; ++i) {
4688 int j;
4689 j = isl_basic_map_alloc_inequality(result);
4690 if (j < 0)
4691 goto error;
4692 isl_seq_clr(result->ineq[j], 1+total);
4693 isl_int_neg(result->ineq[j][1+nparam+n_in+i], d)isl_sioimath_neg((result->ineq[j][1+nparam+n_in+i]), *(d));
4694 isl_int_set_si(result->ineq[j][1+pos+i], 1)isl_sioimath_set_si((result->ineq[j][1+pos+i]), 1);
4695 j = isl_basic_map_alloc_inequality(result);
4696 if (j < 0)
4697 goto error;
4698 isl_seq_clr(result->ineq[j], 1+total);
4699 isl_int_set(result->ineq[j][1+nparam+n_in+i], d)isl_sioimath_set((result->ineq[j][1+nparam+n_in+i]), *(d));
4700 isl_int_set_si(result->ineq[j][1+pos+i], -1)isl_sioimath_set_si((result->ineq[j][1+pos+i]), -1);
4701 isl_int_sub_ui(result->ineq[j][0], d, 1)isl_sioimath_sub_ui((result->ineq[j][0]), *(d), 1);
4702 }
4703
4704 result = isl_basic_map_simplify(result);
4705 return isl_basic_map_finalize(result);
4706error:
4707 isl_basic_map_free(result);
4708 return NULL((void*)0);
4709}
4710
4711/* Given a map A -> f(A) and an integer d, construct a map
4712 * A -> floor(f(A)/d).
4713 */
4714__isl_give isl_map *isl_map_floordiv(__isl_take isl_map *map, isl_int d)
4715{
4716 int i;
4717
4718 map = isl_map_cow(map);
4719 if (!map)
4720 return NULL((void*)0);
4721
4722 ISL_F_CLR(map, ISL_MAP_DISJOINT)(((map)->flags) &= ~((1 << 0)));
4723 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
4724 for (i = 0; i < map->n; ++i) {
4725 map->p[i] = isl_basic_map_floordiv(map->p[i], d);
4726 if (!map->p[i])
4727 goto error;
4728 }
4729
4730 return map;
4731error:
4732 isl_map_free(map);
4733 return NULL((void*)0);
4734}
4735
4736/* Given a map A -> f(A) and an integer d, construct a map
4737 * A -> floor(f(A)/d).
4738 */
4739__isl_give isl_map *isl_map_floordiv_val(__isl_take isl_map *map,
4740 __isl_take isl_val *d)
4741{
4742 if (!map || !d)
4743 goto error;
4744 if (!isl_val_is_int(d))
4745 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"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4746); goto error; } while (0)
4746 "expecting integer denominator", goto error)do { isl_handle_error(isl_val_get_ctx(d), isl_error_invalid, "expecting integer denominator"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 4746); goto error; } while (0)
;
4747 map = isl_map_floordiv(map, d->n);
4748 isl_val_free(d);
4749 return map;
4750error:
4751 isl_map_free(map);
4752 isl_val_free(d);
4753 return NULL((void*)0);
4754}
4755
4756static __isl_give isl_basic_map *var_equal(__isl_take isl_basic_map *bmap,
4757 unsigned pos)
4758{
4759 int i;
4760 unsigned nparam;
4761 unsigned n_in;
4762
4763 i = isl_basic_map_alloc_equality(bmap);
4764 if (i < 0)
4765 goto error;
4766 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4767 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4768 isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap));
4769 isl_int_set_si(bmap->eq[i][1+nparam+pos], -1)isl_sioimath_set_si((bmap->eq[i][1+nparam+pos]), -1);
4770 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);
4771 return isl_basic_map_finalize(bmap);
4772error:
4773 isl_basic_map_free(bmap);
4774 return NULL((void*)0);
4775}
4776
4777/* Add a constraint to "bmap" expressing i_pos < o_pos
4778 */
4779static __isl_give isl_basic_map *var_less(__isl_take isl_basic_map *bmap,
4780 unsigned pos)
4781{
4782 int i;
4783 unsigned nparam;
4784 unsigned n_in;
4785
4786 i = isl_basic_map_alloc_inequality(bmap);
4787 if (i < 0)
4788 goto error;
4789 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4790 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4791 isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
4792 isl_int_set_si(bmap->ineq[i][0], -1)isl_sioimath_set_si((bmap->ineq[i][0]), -1);
4793 isl_int_set_si(bmap->ineq[i][1+nparam+pos], -1)isl_sioimath_set_si((bmap->ineq[i][1+nparam+pos]), -1);
4794 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);
4795 return isl_basic_map_finalize(bmap);
4796error:
4797 isl_basic_map_free(bmap);
4798 return NULL((void*)0);
4799}
4800
4801/* Add a constraint to "bmap" expressing i_pos <= o_pos
4802 */
4803static __isl_give isl_basic_map *var_less_or_equal(
4804 __isl_take isl_basic_map *bmap, unsigned pos)
4805{
4806 int i;
4807 unsigned nparam;
4808 unsigned n_in;
4809
4810 i = isl_basic_map_alloc_inequality(bmap);
4811 if (i < 0)
4812 goto error;
4813 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4814 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4815 isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
4816 isl_int_set_si(bmap->ineq[i][1+nparam+pos], -1)isl_sioimath_set_si((bmap->ineq[i][1+nparam+pos]), -1);
4817 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);
4818 return isl_basic_map_finalize(bmap);
4819error:
4820 isl_basic_map_free(bmap);
4821 return NULL((void*)0);
4822}
4823
4824/* Add a constraint to "bmap" expressing i_pos > o_pos
4825 */
4826static __isl_give isl_basic_map *var_more(__isl_take isl_basic_map *bmap,
4827 unsigned pos)
4828{
4829 int i;
4830 unsigned nparam;
4831 unsigned n_in;
4832
4833 i = isl_basic_map_alloc_inequality(bmap);
4834 if (i < 0)
4835 goto error;
4836 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4837 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4838 isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
4839 isl_int_set_si(bmap->ineq[i][0], -1)isl_sioimath_set_si((bmap->ineq[i][0]), -1);
4840 isl_int_set_si(bmap->ineq[i][1+nparam+pos], 1)isl_sioimath_set_si((bmap->ineq[i][1+nparam+pos]), 1);
4841 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
)
;
4842 return isl_basic_map_finalize(bmap);
4843error:
4844 isl_basic_map_free(bmap);
4845 return NULL((void*)0);
4846}
4847
4848/* Add a constraint to "bmap" expressing i_pos >= o_pos
4849 */
4850static __isl_give isl_basic_map *var_more_or_equal(
4851 __isl_take isl_basic_map *bmap, unsigned pos)
4852{
4853 int i;
4854 unsigned nparam;
4855 unsigned n_in;
4856
4857 i = isl_basic_map_alloc_inequality(bmap);
4858 if (i < 0)
4859 goto error;
4860 nparam = isl_basic_map_dim(bmap, isl_dim_param);
4861 n_in = isl_basic_map_dim(bmap, isl_dim_in);
4862 isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
4863 isl_int_set_si(bmap->ineq[i][1+nparam+pos], 1)isl_sioimath_set_si((bmap->ineq[i][1+nparam+pos]), 1);
4864 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
)
;
4865 return isl_basic_map_finalize(bmap);
4866error:
4867 isl_basic_map_free(bmap);
4868 return NULL((void*)0);
4869}
4870
4871__isl_give isl_basic_map *isl_basic_map_equal(
4872 __isl_take isl_space *dim, unsigned n_equal)
4873{
4874 int i;
4875 struct isl_basic_map *bmap;
4876 bmap = isl_basic_map_alloc_space(dim, 0, n_equal, 0);
4877 if (!bmap)
4878 return NULL((void*)0);
4879 for (i = 0; i < n_equal && bmap; ++i)
4880 bmap = var_equal(bmap, i);
4881 return isl_basic_map_finalize(bmap);
4882}
4883
4884/* Return a relation on of dimension "dim" expressing i_[0..pos] << o_[0..pos]
4885 */
4886__isl_give isl_basic_map *isl_basic_map_less_at(__isl_take isl_space *dim,
4887 unsigned pos)
4888{
4889 int i;
4890 struct isl_basic_map *bmap;
4891 bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
4892 if (!bmap)
4893 return NULL((void*)0);
4894 for (i = 0; i < pos && bmap; ++i)
4895 bmap = var_equal(bmap, i);
4896 if (bmap)
4897 bmap = var_less(bmap, pos);
4898 return isl_basic_map_finalize(bmap);
4899}
4900
4901/* Return a relation on "dim" expressing i_[0..pos] <<= o_[0..pos]
4902 */
4903__isl_give isl_basic_map *isl_basic_map_less_or_equal_at(
4904 __isl_take isl_space *dim, unsigned pos)
4905{
4906 int i;
4907 isl_basic_map *bmap;
4908
4909 bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
4910 for (i = 0; i < pos; ++i)
4911 bmap = var_equal(bmap, i);
4912 bmap = var_less_or_equal(bmap, pos);
4913 return isl_basic_map_finalize(bmap);
4914}
4915
4916/* Return a relation on "dim" expressing i_pos > o_pos
4917 */
4918__isl_give isl_basic_map *isl_basic_map_more_at(__isl_take isl_space *dim,
4919 unsigned pos)
4920{
4921 int i;
4922 struct isl_basic_map *bmap;
4923 bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
4924 if (!bmap)
4925 return NULL((void*)0);
4926 for (i = 0; i < pos && bmap; ++i)
4927 bmap = var_equal(bmap, i);
4928 if (bmap)
4929 bmap = var_more(bmap, pos);
4930 return isl_basic_map_finalize(bmap);
4931}
4932
4933/* Return a relation on "dim" expressing i_[0..pos] >>= o_[0..pos]
4934 */
4935__isl_give isl_basic_map *isl_basic_map_more_or_equal_at(
4936 __isl_take isl_space *dim, unsigned pos)
4937{
4938 int i;
4939 isl_basic_map *bmap;
4940
4941 bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
4942 for (i = 0; i < pos; ++i)
4943 bmap = var_equal(bmap, i);
4944 bmap = var_more_or_equal(bmap, pos);
4945 return isl_basic_map_finalize(bmap);
4946}
4947
4948static __isl_give isl_map *map_lex_lte_first(__isl_take isl_space *dims,
4949 unsigned n, int equal)
4950{
4951 struct isl_map *map;
4952 int i;
4953
4954 if (n == 0 && equal)
4955 return isl_map_universe(dims);
4956
4957 map = isl_map_alloc_space(isl_space_copy(dims), n, ISL_MAP_DISJOINT(1 << 0));
4958
4959 for (i = 0; i + 1 < n; ++i)
4960 map = isl_map_add_basic_map(map,
4961 isl_basic_map_less_at(isl_space_copy(dims), i));
4962 if (n > 0) {
4963 if (equal)
4964 map = isl_map_add_basic_map(map,
4965 isl_basic_map_less_or_equal_at(dims, n - 1));
4966 else
4967 map = isl_map_add_basic_map(map,
4968 isl_basic_map_less_at(dims, n - 1));
4969 } else
4970 isl_space_free(dims);
4971
4972 return map;
4973}
4974
4975static __isl_give isl_map *map_lex_lte(__isl_take isl_space *dims, int equal)
4976{
4977 if (!dims)
4978 return NULL((void*)0);
4979 return map_lex_lte_first(dims, dims->n_out, equal);
4980}
4981
4982__isl_give isl_map *isl_map_lex_lt_first(__isl_take isl_space *dim, unsigned n)
4983{
4984 return map_lex_lte_first(dim, n, 0);
4985}
4986
4987__isl_give isl_map *isl_map_lex_le_first(__isl_take isl_space *dim, unsigned n)
4988{
4989 return map_lex_lte_first(dim, n, 1);
4990}
4991
4992__isl_give isl_map *isl_map_lex_lt(__isl_take isl_space *set_dim)
4993{
4994 return map_lex_lte(isl_space_map_from_set(set_dim), 0);
4995}
4996
4997__isl_give isl_map *isl_map_lex_le(__isl_take isl_space *set_dim)
4998{
4999 return map_lex_lte(isl_space_map_from_set(set_dim), 1);
5000}
5001
5002static __isl_give isl_map *map_lex_gte_first(__isl_take isl_space *dims,
5003 unsigned n, int equal)
5004{
5005 struct isl_map *map;
5006 int i;
5007
5008 if (n == 0 && equal)
5009 return isl_map_universe(dims);
5010
5011 map = isl_map_alloc_space(isl_space_copy(dims), n, ISL_MAP_DISJOINT(1 << 0));
5012
5013 for (i = 0; i + 1 < n; ++i)
5014 map = isl_map_add_basic_map(map,
5015 isl_basic_map_more_at(isl_space_copy(dims), i));
5016 if (n > 0) {
5017 if (equal)
5018 map = isl_map_add_basic_map(map,
5019 isl_basic_map_more_or_equal_at(dims, n - 1));
5020 else
5021 map = isl_map_add_basic_map(map,
5022 isl_basic_map_more_at(dims, n - 1));
5023 } else
5024 isl_space_free(dims);
5025
5026 return map;
5027}
5028
5029static __isl_give isl_map *map_lex_gte(__isl_take isl_space *dims, int equal)
5030{
5031 if (!dims)
5032 return NULL((void*)0);
5033 return map_lex_gte_first(dims, dims->n_out, equal);
5034}
5035
5036__isl_give isl_map *isl_map_lex_gt_first(__isl_take isl_space *dim, unsigned n)
5037{
5038 return map_lex_gte_first(dim, n, 0);
5039}
5040
5041__isl_give isl_map *isl_map_lex_ge_first(__isl_take isl_space *dim, unsigned n)
5042{
5043 return map_lex_gte_first(dim, n, 1);
5044}
5045
5046__isl_give isl_map *isl_map_lex_gt(__isl_take isl_space *set_dim)
5047{
5048 return map_lex_gte(isl_space_map_from_set(set_dim), 0);
5049}
5050
5051__isl_give isl_map *isl_map_lex_ge(__isl_take isl_space *set_dim)
5052{
5053 return map_lex_gte(isl_space_map_from_set(set_dim), 1);
5054}
5055
5056__isl_give isl_map *isl_set_lex_le_set(__isl_take isl_setisl_map *set1,
5057 __isl_take isl_setisl_map *set2)
5058{
5059 isl_map *map;
5060 map = isl_map_lex_le(isl_set_get_space(set1));
5061 map = isl_map_intersect_domain(map, set1);
5062 map = isl_map_intersect_range(map, set2);
5063 return map;
5064}
5065
5066__isl_give isl_map *isl_set_lex_lt_set(__isl_take isl_setisl_map *set1,
5067 __isl_take isl_setisl_map *set2)
5068{
5069 isl_map *map;
5070 map = isl_map_lex_lt(isl_set_get_space(set1));
5071 map = isl_map_intersect_domain(map, set1);
5072 map = isl_map_intersect_range(map, set2);
5073 return map;
5074}
5075
5076__isl_give isl_map *isl_set_lex_ge_set(__isl_take isl_setisl_map *set1,
5077 __isl_take isl_setisl_map *set2)
5078{
5079 isl_map *map;
5080 map = isl_map_lex_ge(isl_set_get_space(set1));
5081 map = isl_map_intersect_domain(map, set1);
5082 map = isl_map_intersect_range(map, set2);
5083 return map;
5084}
5085
5086__isl_give isl_map *isl_set_lex_gt_set(__isl_take isl_setisl_map *set1,
5087 __isl_take isl_setisl_map *set2)
5088{
5089 isl_map *map;
5090 map = isl_map_lex_gt(isl_set_get_space(set1));
5091 map = isl_map_intersect_domain(map, set1);
5092 map = isl_map_intersect_range(map, set2);
5093 return map;
5094}
5095
5096__isl_give isl_map *isl_map_lex_le_map(__isl_take isl_map *map1,
5097 __isl_take isl_map *map2)
5098{
5099 isl_map *map;
5100 map = isl_map_lex_le(isl_space_range(isl_map_get_space(map1)));
5101 map = isl_map_apply_domain(map, isl_map_reverse(map1));
5102 map = isl_map_apply_range(map, isl_map_reverse(map2));
5103 return map;
5104}
5105
5106__isl_give isl_map *isl_map_lex_lt_map(__isl_take isl_map *map1,
5107 __isl_take isl_map *map2)
5108{
5109 isl_map *map;
5110 map = isl_map_lex_lt(isl_space_range(isl_map_get_space(map1)));
5111 map = isl_map_apply_domain(map, isl_map_reverse(map1));
5112 map = isl_map_apply_range(map, isl_map_reverse(map2));
5113 return map;
5114}
5115
5116__isl_give isl_map *isl_map_lex_ge_map(__isl_take isl_map *map1,
5117 __isl_take isl_map *map2)
5118{
5119 isl_map *map;
5120 map = isl_map_lex_ge(isl_space_range(isl_map_get_space(map1)));
5121 map = isl_map_apply_domain(map, isl_map_reverse(map1));
5122 map = isl_map_apply_range(map, isl_map_reverse(map2));
5123 return map;
5124}
5125
5126__isl_give isl_map *isl_map_lex_gt_map(__isl_take isl_map *map1,
5127 __isl_take isl_map *map2)
5128{
5129 isl_map *map;
5130 map = isl_map_lex_gt(isl_space_range(isl_map_get_space(map1)));
5131 map = isl_map_apply_domain(map, isl_map_reverse(map1));
5132 map = isl_map_apply_range(map, isl_map_reverse(map2));
5133 return map;
5134}
5135
5136/* For a div d = floor(f/m), add the constraint
5137 *
5138 * f - m d >= 0
5139 */
5140static isl_stat add_upper_div_constraint(__isl_keep isl_basic_map *bmap,
5141 unsigned pos, isl_int *div)
5142{
5143 int i;
5144 unsigned total = isl_basic_map_total_dim(bmap);
5145
5146 i = isl_basic_map_alloc_inequality(bmap);
5147 if (i < 0)
5148 return isl_stat_error;
5149 isl_seq_cpy(bmap->ineq[i], div + 1, 1 + total);
5150 isl_int_neg(bmap->ineq[i][1 + pos], div[0])isl_sioimath_neg((bmap->ineq[i][1 + pos]), *(div[0]));
5151
5152 return isl_stat_ok;
5153}
5154
5155/* For a div d = floor(f/m), add the constraint
5156 *
5157 * -(f-(m-1)) + m d >= 0
5158 */
5159static isl_stat add_lower_div_constraint(__isl_keep isl_basic_map *bmap,
5160 unsigned pos, isl_int *div)
5161{
5162 int i;
5163 unsigned total = isl_basic_map_total_dim(bmap);
5164
5165 i = isl_basic_map_alloc_inequality(bmap);
5166 if (i < 0)
5167 return isl_stat_error;
5168 isl_seq_neg(bmap->ineq[i], div + 1, 1 + total);
5169 isl_int_set(bmap->ineq[i][1 + pos], div[0])isl_sioimath_set((bmap->ineq[i][1 + pos]), *(div[0]));
5170 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]))
;
5171 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)
;
5172
5173 return isl_stat_ok;
5174}
5175
5176/* For a div d = floor(f/m), add the constraints
5177 *
5178 * f - m d >= 0
5179 * -(f-(m-1)) + m d >= 0
5180 *
5181 * Note that the second constraint is the negation of
5182 *
5183 * f - m d >= m
5184 */
5185int isl_basic_map_add_div_constraints_var(__isl_keep isl_basic_map *bmap,
5186 unsigned pos, isl_int *div)
5187{
5188 if (add_upper_div_constraint(bmap, pos, div) < 0)
5189 return -1;
5190 if (add_lower_div_constraint(bmap, pos, div) < 0)
5191 return -1;
5192 return 0;
5193}
5194
5195int isl_basic_set_add_div_constraints_var(__isl_keep isl_basic_setisl_basic_map *bset,
5196 unsigned pos, isl_int *div)
5197{
5198 return isl_basic_map_add_div_constraints_var(bset_to_bmap(bset),
5199 pos, div);
5200}
5201
5202int isl_basic_map_add_div_constraints(struct isl_basic_map *bmap, unsigned div)
5203{
5204 unsigned total = isl_basic_map_total_dim(bmap);
5205 unsigned div_pos = total - bmap->n_div + div;
5206
5207 return isl_basic_map_add_div_constraints_var(bmap, div_pos,
5208 bmap->div[div]);
5209}
5210
5211/* For each known div d = floor(f/m), add the constraints
5212 *
5213 * f - m d >= 0
5214 * -(f-(m-1)) + m d >= 0
5215 *
5216 * Remove duplicate constraints in case of some these div constraints
5217 * already appear in "bmap".
5218 */
5219__isl_give isl_basic_map *isl_basic_map_add_known_div_constraints(
5220 __isl_take isl_basic_map *bmap)
5221{
5222 unsigned n_div;
5223
5224 if (!bmap)
5225 return NULL((void*)0);
5226 n_div = isl_basic_map_dim(bmap, isl_dim_div);
5227 if (n_div == 0)
5228 return bmap;
5229
5230 bmap = add_known_div_constraints(bmap);
5231 bmap = isl_basic_map_remove_duplicate_constraints(bmap, NULL((void*)0), 0);
5232 bmap = isl_basic_map_finalize(bmap);
5233 return bmap;
5234}
5235
5236/* Add the div constraint of sign "sign" for div "div" of "bmap".
5237 *
5238 * In particular, if this div is of the form d = floor(f/m),
5239 * then add the constraint
5240 *
5241 * f - m d >= 0
5242 *
5243 * if sign < 0 or the constraint
5244 *
5245 * -(f-(m-1)) + m d >= 0
5246 *
5247 * if sign > 0.
5248 */
5249int isl_basic_map_add_div_constraint(__isl_keep isl_basic_map *bmap,
5250 unsigned div, int sign)
5251{
5252 unsigned total;
5253 unsigned div_pos;
5254
5255 if (!bmap)
5256 return -1;
5257
5258 total = isl_basic_map_total_dim(bmap);
5259 div_pos = total - bmap->n_div + div;
5260
5261 if (sign < 0)
5262 return add_upper_div_constraint(bmap, div_pos, bmap->div[div]);
5263 else
5264 return add_lower_div_constraint(bmap, div_pos, bmap->div[div]);
5265}
5266
5267struct isl_basic_setisl_basic_map *isl_basic_map_underlying_set(
5268 struct isl_basic_map *bmap)
5269{
5270 if (!bmap)
5271 goto error;
5272 if (bmap->dim->nparam == 0 && bmap->dim->n_in == 0 &&
5273 bmap->n_div == 0 &&
5274 !isl_space_is_named_or_nested(bmap->dim, isl_dim_in) &&
5275 !isl_space_is_named_or_nested(bmap->dim, isl_dim_out))
5276 return bset_from_bmap(bmap);
5277 bmap = isl_basic_map_cow(bmap);
5278 if (!bmap)
5279 goto error;
5280 bmap->dim = isl_space_underlying(bmap->dim, bmap->n_div);
5281 if (!bmap->dim)
5282 goto error;
5283 bmap->extra -= bmap->n_div;
5284 bmap->n_div = 0;
5285 bmap = isl_basic_map_finalize(bmap);
5286 return bset_from_bmap(bmap);
5287error:
5288 isl_basic_map_free(bmap);
5289 return NULL((void*)0);
5290}
5291
5292__isl_give isl_basic_setisl_basic_map *isl_basic_set_underlying_set(
5293 __isl_take isl_basic_setisl_basic_map *bset)
5294{
5295 return isl_basic_map_underlying_set(bset_to_bmap(bset));
5296}
5297
5298/* Replace each element in "list" by the result of applying
5299 * isl_basic_map_underlying_set to the element.
5300 */
5301__isl_give isl_basic_set_listisl_basic_map_list *isl_basic_map_list_underlying_set(
5302 __isl_take isl_basic_map_list *list)
5303{
5304 int i, n;
5305
5306 if (!list)
5307 return NULL((void*)0);
5308
5309 n = isl_basic_map_list_n_basic_map(list);
5310 for (i = 0; i < n; ++i) {
5311 isl_basic_map *bmap;
5312 isl_basic_setisl_basic_map *bset;
5313
5314 bmap = isl_basic_map_list_get_basic_map(list, i);
5315 bset = isl_basic_set_underlying_set(bmap);
5316 list = isl_basic_set_list_set_basic_set(list, i, bset);
5317 }
5318
5319 return list;
5320}
5321
5322struct isl_basic_map *isl_basic_map_overlying_set(
5323 struct isl_basic_setisl_basic_map *bset, struct isl_basic_map *like)
5324{
5325 struct isl_basic_map *bmap;
5326 struct isl_ctx *ctx;
5327 unsigned total;
5328 int i;
5329
5330 if (!bset || !like)
5331 goto error;
5332 ctx = bset->ctx;
5333 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"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 5333); goto error; } while (0); } while (0)
;
5334 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 5334); goto error; } while (0); } while (0)
;
5335 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"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 5336); goto error; } while (0); } while (0)
5336 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"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 5336); goto error; } while (0); } while (0)
;
5337 if (like->n_div == 0) {
5338 isl_space *space = isl_basic_map_get_space(like);
5339 isl_basic_map_free(like);
5340 return isl_basic_map_reset_space(bset, space);
5341 }
5342 bset = isl_basic_set_cow(bset);
5343 if (!bset)
5344 goto error;
5345 total = bset->dim->n_out + bset->extra;
5346 bmap = bset_to_bmap(bset);
5347 isl_space_free(bmap->dim);
5348 bmap->dim = isl_space_copy(like->dim);
5349 if (!bmap->dim)
5350 goto error;
5351 bmap->n_div = like->n_div;
5352 bmap->extra += like->n_div;
5353 if (bmap->extra) {
5354 unsigned ltotal;
5355 isl_int **div;
5356 ltotal = total - bmap->extra + like->extra;
5357 if (ltotal > total)
5358 ltotal = total;
5359 bmap->block2 = isl_blk_extend(ctx, bmap->block2,
5360 bmap->extra * (1 + 1 + total));
5361 if (isl_blk_is_error(bmap->block2))
5362 goto error;
5363 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 *)))
;
5364 if (!div)
5365 goto error;
5366 bmap->div = div;
5367 for (i = 0; i < bmap->extra; ++i)
5368 bmap->div[i] = bmap->block2.data + i * (1 + 1 + total);
5369 for (i = 0; i < like->n_div; ++i) {
5370 isl_seq_cpy(bmap->div[i], like->div[i], 1 + 1 + ltotal);
5371 isl_seq_clr(bmap->div[i]+1+1+ltotal, total - ltotal);
5372 }
5373 bmap = isl_basic_map_add_known_div_constraints(bmap);
5374 }
5375 isl_basic_map_free(like);
5376 bmap = isl_basic_map_simplify(bmap);
5377 bmap = isl_basic_map_finalize(bmap);
5378 return bmap;
5379error:
5380 isl_basic_map_free(like);
5381 isl_basic_set_free(bset);
5382 return NULL((void*)0);
5383}
5384
5385struct isl_basic_setisl_basic_map *isl_basic_set_from_underlying_set(
5386 struct isl_basic_setisl_basic_map *bset, struct isl_basic_setisl_basic_map *like)
5387{
5388 return bset_from_bmap(isl_basic_map_overlying_set(bset,
5389 bset_to_bmap(like)));
5390}
5391
5392struct isl_setisl_map *isl_map_underlying_set(struct isl_map *map)
5393{
5394 int i;
5395
5396 map = isl_map_cow(map);
5397 if (!map)
5398 return NULL((void*)0);
5399 map->dim = isl_space_cow(map->dim);
5400 if (!map->dim)
5401 goto error;
5402
5403 for (i = 1; i < map->n; ++i)
5404 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"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 5405); goto error; } while (0); } while (0)
5405 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"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 5405); goto error; } while (0); } while (0)
;
5406 for (i = 0; i < map->n; ++i) {
5407 map->p[i] = bset_to_bmap(
5408 isl_basic_map_underlying_set(map->p[i]));
5409 if (!map->p[i])
5410 goto error;
5411 }
5412 if (map->n == 0)
5413 map->dim = isl_space_underlying(map->dim, 0);
5414 else {
5415 isl_space_free(map->dim);
5416 map->dim = isl_space_copy(map->p[0]->dim);
5417 }
5418 if (!map->dim)
5419 goto error;
5420 return set_from_map(map);
5421error:
5422 isl_map_free(map);
5423 return NULL((void*)0);
5424}
5425
5426/* Replace the space of "bmap" by "space".
5427 *
5428 * If the space of "bmap" is identical to "space" (including the identifiers
5429 * of the input and output dimensions), then simply return the original input.
5430 */
5431__isl_give isl_basic_map *isl_basic_map_reset_space(
5432 __isl_take isl_basic_map *bmap, __isl_take isl_space *space)
5433{
5434 isl_bool equal;
5435 isl_space *bmap_space;
5436
5437 bmap_space = isl_basic_map_peek_space(bmap);
5438 equal = isl_space_is_equal(bmap_space, space);
5439 if (equal >= 0 && equal)
5440 equal = isl_space_has_equal_ids(bmap_space, space);
5441 if (equal < 0)
5442 goto error;
5443 if (equal) {
5444 isl_space_free(space);
5445 return bmap;
5446 }
5447 bmap = isl_basic_map_cow(bmap);
5448 if (!bmap || !space)
5449 goto error;
5450
5451 isl_space_free(bmap->dim);
5452 bmap->dim = space;
5453
5454 bmap = isl_basic_map_finalize(bmap);
5455
5456 return bmap;
5457error:
5458 isl_basic_map_free(bmap);
5459 isl_space_free(space);
5460 return NULL((void*)0);
5461}
5462
5463__isl_give isl_basic_setisl_basic_map *isl_basic_set_reset_space(
5464 __isl_take isl_basic_setisl_basic_map *bset, __isl_take isl_space *dim)
5465{
5466 return bset_from_bmap(isl_basic_map_reset_space(bset_to_bmap(bset),
5467 dim));
5468}
5469
5470__isl_give isl_map *isl_map_reset_space(__isl_take isl_map *map,
5471 __isl_take isl_space *dim)
5472{
5473 int i;
5474
5475 map = isl_map_cow(map);
5476 if (!map || !dim)
5477 goto error;
5478
5479 for (i = 0; i < map->n; ++i) {
5480 map->p[i] = isl_basic_map_reset_space(map->p[i],
5481 isl_space_copy(dim));
5482 if (!map->p[i])
5483 goto error;
5484 }
5485 isl_space_free(map->dim);
5486 map->dim = dim;
5487
5488 return map;
5489error:
5490 isl_map_free(map);
5491 isl_space_free(dim);
5492 return NULL((void*)0);
5493}
5494
5495__isl_give isl_setisl_map *isl_set_reset_space(__isl_take isl_setisl_map *set,
5496 __isl_take isl_space *dim)
5497{
5498 return set_from_map(isl_map_reset_space(set_to_map(set), dim));
5499}
5500
5501/* Compute the parameter domain of the given basic set.
5502 */
5503__isl_give isl_basic_setisl_basic_map *isl_basic_set_params(__isl_take isl_basic_setisl_basic_map *bset)
5504{
5505 isl_bool is_params;
5506 isl_space *space;
5507 unsigned n;
5508
5509 is_params = isl_basic_set_is_params(bset);
5510 if (is_params < 0)
5511 return isl_basic_set_free(bset);
5512 if (is_params)
5513 return bset;
5514
5515 n = isl_basic_set_dim(bset, isl_dim_set);
5516 bset = isl_basic_set_project_out(bset, isl_dim_set, 0, n);
5517 space = isl_basic_set_get_space(bset);
5518 space = isl_space_params(space);
5519 bset = isl_basic_set_reset_space(bset, space);
5520 return bset;
5521}
5522
5523/* Construct a zero-dimensional basic set with the given parameter domain.
5524 */
5525__isl_give isl_basic_setisl_basic_map *isl_basic_set_from_params(
5526 __isl_take isl_basic_setisl_basic_map *bset)
5527{
5528 isl_space *space;
5529 space = isl_basic_set_get_space(bset);
5530 space = isl_space_set_from_params(space);
5531 bset = isl_basic_set_reset_space(bset, space);
5532 return bset;
5533}
5534
5535/* Compute the parameter domain of the given set.
5536 */
5537__isl_give isl_setisl_map *isl_set_params(__isl_take isl_setisl_map *set)
5538{
5539 isl_space *space;
5540 unsigned n;
5541
5542 if (isl_set_is_params(set))
5543 return set;
5544
5545 n = isl_set_dim(set, isl_dim_set);
5546 set = isl_set_project_out(set, isl_dim_set, 0, n);
5547 space = isl_set_get_space(set);
5548 space = isl_space_params(space);
5549 set = isl_set_reset_space(set, space);
5550 return set;
5551}
5552
5553/* Construct a zero-dimensional set with the given parameter domain.
5554 */
5555__isl_give isl_setisl_map *isl_set_from_params(__isl_take isl_setisl_map *set)
5556{
5557 isl_space *space;
5558 space = isl_set_get_space(set);
5559 space = isl_space_set_from_params(space);
5560 set = isl_set_reset_space(set, space);
5561 return set;
5562}
5563
5564/* Compute the parameter domain of the given map.
5565 */
5566__isl_give isl_setisl_map *isl_map_params(__isl_take isl_map *map)
5567{
5568 isl_space *space;
5569 unsigned n;
5570
5571 n = isl_map_dim(map, isl_dim_in);
5572 map = isl_map_project_out(map, isl_dim_in, 0, n);
5573 n = isl_map_dim(map, isl_dim_out);
5574 map = isl_map_project_out(map, isl_dim_out, 0, n);
5575 space = isl_map_get_space(map);
5576 space = isl_space_params(space);
5577 map = isl_map_reset_space(map, space);
5578 return map;
5579}
5580
5581struct isl_basic_setisl_basic_map *isl_basic_map_domain(struct isl_basic_map *bmap)
5582{
5583 isl_space *space;
5584 unsigned n_out;
5585
5586 if (!bmap)
5587 return NULL((void*)0);
5588 space = isl_space_domain(isl_basic_map_get_space(bmap));
5589
5590 n_out = isl_basic_map_dim(bmap, isl_dim_out);
5591 bmap = isl_basic_map_project_out(bmap, isl_dim_out, 0, n_out);
5592
5593 return isl_basic_map_reset_space(bmap, space);
5594}
5595
5596isl_bool isl_basic_map_may_be_set(__isl_keep isl_basic_map *bmap)
5597{
5598 if (!bmap)
5599 return isl_bool_error;
5600 return isl_space_may_be_set(bmap->dim);
5601}
5602
5603/* Is this basic map actually a set?
5604 * Users should never call this function. Outside of isl,
5605 * the type should indicate whether something is a set or a map.
5606 */
5607isl_bool isl_basic_map_is_set(__isl_keep isl_basic_map *bmap)
5608{
5609 if (!bmap)
5610 return isl_bool_error;
5611 return isl_space_is_set(bmap->dim);
5612}
5613
5614struct isl_basic_setisl_basic_map *isl_basic_map_range(struct isl_basic_map *bmap)
5615{
5616 isl_bool is_set;
5617
5618 is_set = isl_basic_map_is_set(bmap);
5619 if (is_set < 0)
5620 goto error;
5621 if (is_set)
5622 return bmap;
5623 return isl_basic_map_domain(isl_basic_map_reverse(bmap));
5624error:
5625 isl_basic_map_free(bmap);
5626 return NULL((void*)0);
5627}
5628
5629__isl_give isl_basic_map *isl_basic_map_domain_map(
5630 __isl_take isl_basic_map *bmap)
5631{
5632 int i;
5633 isl_space *dim;
5634 isl_basic_map *domain;
5635 int nparam, n_in, n_out;
5636
5637 nparam = isl_basic_map_dim(bmap, isl_dim_param);
5638 n_in = isl_basic_map_dim(bmap, isl_dim_in);
5639 n_out = isl_basic_map_dim(bmap, isl_dim_out);
5640
5641 dim = isl_space_from_range(isl_space_domain(isl_basic_map_get_space(bmap)));
5642 domain = isl_basic_map_universe(dim);
5643
5644 bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
5645 bmap = isl_basic_map_apply_range(bmap, domain);
5646 bmap = isl_basic_map_extend_constraints(bmap, n_in, 0);
5647
5648 for (i = 0; i < n_in; ++i)
5649 bmap = isl_basic_map_equate(bmap, isl_dim_in, i,
5650 isl_dim_out, i);
5651
5652 bmap = isl_basic_map_gauss(bmap, NULL((void*)0));
5653 return isl_basic_map_finalize(bmap);
5654}
5655
5656__isl_give isl_basic_map *isl_basic_map_range_map(
5657 __isl_take isl_basic_map *bmap)
5658{
5659 int i;
5660 isl_space *dim;
5661 isl_basic_map *range;
5662 int nparam, n_in, n_out;
5663
5664 nparam = isl_basic_map_dim(bmap, isl_dim_param);
5665 n_in = isl_basic_map_dim(bmap, isl_dim_in);
5666 n_out = isl_basic_map_dim(bmap, isl_dim_out);
5667
5668 dim = isl_space_from_range(isl_space_range(isl_basic_map_get_space(bmap)));
5669 range = isl_basic_map_universe(dim);
5670
5671 bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
5672 bmap = isl_basic_map_apply_range(bmap, range);
5673 bmap = isl_basic_map_extend_constraints(bmap, n_out, 0);
5674
5675 for (i = 0; i < n_out; ++i)
5676 bmap = isl_basic_map_equate(bmap, isl_dim_in, n_in + i,
5677 isl_dim_out, i);
5678
5679 bmap = isl_basic_map_gauss(bmap, NULL((void*)0));
5680 return isl_basic_map_finalize(bmap);
5681}
5682
5683int isl_map_may_be_set(__isl_keep isl_map *map)
5684{
5685 if (!map)
5686 return -1;
5687 return isl_space_may_be_set(map->dim);
5688}
5689
5690/* Is this map actually a set?
5691 * Users should never call this function. Outside of isl,
5692 * the type should indicate whether something is a set or a map.
5693 */
5694isl_bool isl_map_is_set(__isl_keep isl_map *map)
5695{
5696 if (!map)
5697 return isl_bool_error;
5698 return isl_space_is_set(map->dim);
5699}
5700
5701__isl_give isl_setisl_map *isl_map_range(__isl_take isl_map *map)
5702{
5703 int i;
5704 isl_bool is_set;
5705 struct isl_setisl_map *set;
5706
5707 is_set = isl_map_is_set(map);
5708 if (is_set < 0)
5709 goto error;
5710 if (is_set)
5711 return set_from_map(map);
5712
5713 map = isl_map_cow(map);
5714 if (!map)
5715 goto error;
5716
5717 set = set_from_map(map);
5718 set->dim = isl_space_range(set->dim);
5719 if (!set->dim)
5720 goto error;
5721 for (i = 0; i < map->n; ++i) {
5722 set->p[i] = isl_basic_map_range(map->p[i]);
5723 if (!set->p[i])
5724 goto error;
5725 }
5726 ISL_F_CLR(set, ISL_MAP_DISJOINT)(((set)->flags) &= ~((1 << 0)));
5727 ISL_F_CLR(set, ISL_SET_NORMALIZED)(((set)->flags) &= ~((1 << 1)));
5728 return set;
5729error:
5730 isl_map_free(map);
5731 return NULL((void*)0);
5732}
5733
5734__isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map)
5735{
5736 int i;
5737
5738 map = isl_map_cow(map);
5739 if (!map)
5740 return NULL((void*)0);
5741
5742 map->dim = isl_space_domain_map(map->dim);
5743 if (!map->dim)
5744 goto error;
5745 for (i = 0; i < map->n; ++i) {
5746 map->p[i] = isl_basic_map_domain_map(map->p[i]);
5747 if (!map->p[i])
5748 goto error;
5749 }
5750 ISL_F_CLR(map, ISL_MAP_DISJOINT)(((map)->flags) &= ~((1 << 0)));
5751 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
5752 return map;
5753error:
5754 isl_map_free(map);
5755 return NULL((void*)0);
5756}
5757
5758__isl_give isl_map *isl_map_range_map(__isl_take isl_map *map)
5759{
5760 int i;
5761 isl_space *range_dim;
5762
5763 map = isl_map_cow(map);
5764 if (!map)
5765 return NULL((void*)0);
5766
5767 range_dim = isl_space_range(isl_map_get_space(map));
5768 range_dim = isl_space_from_range(range_dim);
5769 map->dim = isl_space_from_domain(isl_space_wrap(map->dim));
5770 map->dim = isl_space_join(map->dim, range_dim);
5771 if (!map->dim)
5772 goto error;
5773 for (i = 0; i < map->n; ++i) {
5774 map->p[i] = isl_basic_map_range_map(map->p[i]);
5775 if (!map->p[i])
5776 goto error;
5777 }
5778 ISL_F_CLR(map, ISL_MAP_DISJOINT)(((map)->flags) &= ~((1 << 0)));
5779 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
5780 return map;
5781error:
5782 isl_map_free(map);
5783 return NULL((void*)0);
5784}
5785
5786/* Given a wrapped map of the form A[B -> C],
5787 * return the map A[B -> C] -> B.
5788 */
5789__isl_give isl_map *isl_set_wrapped_domain_map(__isl_take isl_setisl_map *set)
5790{
5791 isl_id *id;
5792 isl_map *map;
5793
5794 if (!set)
5795 return NULL((void*)0);
5796 if (!isl_set_has_tuple_id(set))
5797 return isl_map_domain_map(isl_set_unwrap(set));
5798
5799 id = isl_set_get_tuple_id(set);
5800 map = isl_map_domain_map(isl_set_unwrap(set));
5801 map = isl_map_set_tuple_id(map, isl_dim_in, id);
5802
5803 return map;
5804}
5805
5806__isl_give isl_basic_map *isl_basic_map_from_domain(
5807 __isl_take isl_basic_setisl_basic_map *bset)
5808{
5809 return isl_basic_map_reverse(isl_basic_map_from_range(bset));
5810}
5811
5812__isl_give isl_basic_map *isl_basic_map_from_range(
5813 __isl_take isl_basic_setisl_basic_map *bset)
5814{
5815 isl_space *space;
5816 space = isl_basic_set_get_space(bset);
5817 space = isl_space_from_range(space);
5818 bset = isl_basic_set_reset_space(bset, space);
5819 return bset_to_bmap(bset);
5820}
5821
5822/* Create a relation with the given set as range.
5823 * The domain of the created relation is a zero-dimensional
5824 * flat anonymous space.
5825 */
5826__isl_give isl_map *isl_map_from_range(__isl_take isl_setisl_map *set)
5827{
5828 isl_space *space;
5829 space = isl_set_get_space(set);
5830 space = isl_space_from_range(space);
5831 set = isl_set_reset_space(set, space);
5832 return set_to_map(set);
5833}
5834
5835/* Create a relation with the given set as domain.
5836 * The range of the created relation is a zero-dimensional
5837 * flat anonymous space.
5838 */
5839__isl_give isl_map *isl_map_from_domain(__isl_take isl_setisl_map *set)
5840{
5841 return isl_map_reverse(isl_map_from_range(set));
5842}
5843
5844__isl_give isl_basic_map *isl_basic_map_from_domain_and_range(
5845 __isl_take isl_basic_setisl_basic_map *domain, __isl_take isl_basic_setisl_basic_map *range)
5846{
5847 return isl_basic_map_apply_range(isl_basic_map_reverse(domain), range);
5848}
5849
5850__isl_give isl_map *isl_map_from_domain_and_range(__isl_take isl_setisl_map *domain,
5851 __isl_take isl_setisl_map *range)
5852{
5853 return isl_map_apply_range(isl_map_reverse(domain), range);
5854}
5855
5856/* Return a newly allocated isl_map with given space and flags and
5857 * room for "n" basic maps.
5858 * Make sure that all cached information is cleared.
5859 */
5860__isl_give isl_map *isl_map_alloc_space(__isl_take isl_space *space, int n,
5861 unsigned flags)
5862{
5863 struct isl_map *map;
5864
5865 if (!space)
5866 return NULL((void*)0);
5867 if (n < 0)
5868 isl_die(space->ctx, isl_error_internal,do { isl_handle_error(space->ctx, isl_error_internal, "negative number of basic maps"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 5869); goto error; } while (0)
5869 "negative number of basic maps", goto error)do { isl_handle_error(space->ctx, isl_error_internal, "negative number of basic maps"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 5869); goto error; } while (0)
;
5870 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 *)))
5871 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 *)))
5872 (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 *)))
;
5873 if (!map)
5874 goto error;
5875
5876 map->ctx = space->ctx;
5877 isl_ctx_ref(map->ctx);
5878 map->ref = 1;
5879 map->size = n;
5880 map->n = 0;
5881 map->dim = space;
5882 map->flags = flags;
5883 return map;
5884error:
5885 isl_space_free(space);
5886 return NULL((void*)0);
5887}
5888
5889__isl_give isl_basic_map *isl_basic_map_empty(__isl_take isl_space *dim)
5890{
5891 struct isl_basic_map *bmap;
5892 bmap = isl_basic_map_alloc_space(dim, 0, 1, 0);
5893 bmap = isl_basic_map_set_to_empty(bmap);
5894 return bmap;
5895}
5896
5897__isl_give isl_basic_setisl_basic_map *isl_basic_set_empty(__isl_take isl_space *dim)
5898{
5899 struct isl_basic_setisl_basic_map *bset;
5900 bset = isl_basic_set_alloc_space(dim, 0, 1, 0);
5901 bset = isl_basic_set_set_to_empty(bset);
5902 return bset;
5903}
5904
5905__isl_give isl_basic_map *isl_basic_map_universe(__isl_take isl_space *dim)
5906{
5907 struct isl_basic_map *bmap;
5908 bmap = isl_basic_map_alloc_space(dim, 0, 0, 0);
5909 bmap = isl_basic_map_finalize(bmap);
5910 return bmap;
5911}
5912
5913__isl_give isl_basic_setisl_basic_map *isl_basic_set_universe(__isl_take isl_space *dim)
5914{
5915 struct isl_basic_setisl_basic_map *bset;
5916 bset = isl_basic_set_alloc_space(dim, 0, 0, 0);
5917 bset = isl_basic_set_finalize(bset);
5918 return bset;
5919}
5920
5921__isl_give isl_basic_map *isl_basic_map_nat_universe(__isl_take isl_space *dim)
5922{
5923 int i;
5924 unsigned total = isl_space_dim(dim, isl_dim_all);
5925 isl_basic_map *bmap;
5926
5927 bmap= isl_basic_map_alloc_space(dim, 0, 0, total);
5928 for (i = 0; i < total; ++i) {
5929 int k = isl_basic_map_alloc_inequality(bmap);
5930 if (k < 0)
5931 goto error;
5932 isl_seq_clr(bmap->ineq[k], 1 + total);
5933 isl_int_set_si(bmap->ineq[k][1 + i], 1)isl_sioimath_set_si((bmap->ineq[k][1 + i]), 1);
5934 }
5935 return bmap;
5936error:
5937 isl_basic_map_free(bmap);
5938 return NULL((void*)0);
5939}
5940
5941__isl_give isl_basic_setisl_basic_map *isl_basic_set_nat_universe(__isl_take isl_space *dim)
5942{
5943 return isl_basic_map_nat_universe(dim);
5944}
5945
5946__isl_give isl_map *isl_map_nat_universe(__isl_take isl_space *dim)
5947{
5948 return isl_map_from_basic_map(isl_basic_map_nat_universe(dim));
5949}
5950
5951__isl_give isl_setisl_map *isl_set_nat_universe(__isl_take isl_space *dim)
5952{
5953 return isl_map_nat_universe(dim);
5954}
5955
5956__isl_give isl_map *isl_map_empty(__isl_take isl_space *dim)
5957{
5958 return isl_map_alloc_space(dim, 0, ISL_MAP_DISJOINT(1 << 0));
5959}
5960
5961__isl_give isl_setisl_map *isl_set_empty(__isl_take isl_space *dim)
5962{
5963 return isl_set_alloc_space(dim, 0, ISL_MAP_DISJOINT(1 << 0));
5964}
5965
5966__isl_give isl_map *isl_map_universe(__isl_take isl_space *dim)
5967{
5968 struct isl_map *map;
5969 if (!dim)
5970 return NULL((void*)0);
5971 map = isl_map_alloc_space(isl_space_copy(dim), 1, ISL_MAP_DISJOINT(1 << 0));
5972 map = isl_map_add_basic_map(map, isl_basic_map_universe(dim));
5973 return map;
5974}
5975
5976__isl_give isl_setisl_map *isl_set_universe(__isl_take isl_space *dim)
5977{
5978 struct isl_setisl_map *set;
5979 if (!dim)
5980 return NULL((void*)0);
5981 set = isl_set_alloc_space(isl_space_copy(dim), 1, ISL_MAP_DISJOINT(1 << 0));
5982 set = isl_set_add_basic_set(set, isl_basic_set_universe(dim));
5983 return set;
5984}
5985
5986struct isl_map *isl_map_dup(struct isl_map *map)
5987{
5988 int i;
5989 struct isl_map *dup;
5990
5991 if (!map)
5992 return NULL((void*)0);
5993 dup = isl_map_alloc_space(isl_space_copy(map->dim), map->n, map->flags);
5994 for (i = 0; i < map->n; ++i)
5995 dup = isl_map_add_basic_map(dup, isl_basic_map_copy(map->p[i]));
5996 return dup;
5997}
5998
5999__isl_give isl_map *isl_map_add_basic_map(__isl_take isl_map *map,
6000 __isl_take isl_basic_map *bmap)
6001{
6002 if (!bmap || !map)
6003 goto error;
6004 if (isl_basic_map_plain_is_empty(bmap)) {
6005 isl_basic_map_free(bmap);
6006 return map;
6007 }
6008 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",
"/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6008); goto error; } while (0); } while (0)
;
6009 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6009); goto error; } while (0); } while (0)
;
6010 map->p[map->n] = bmap;
6011 map->n++;
6012 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
6013 return map;
6014error:
6015 if (map)
6016 isl_map_free(map);
6017 if (bmap)
6018 isl_basic_map_free(bmap);
6019 return NULL((void*)0);
6020}
6021
6022__isl_null isl_map *isl_map_free(__isl_take isl_map *map)
6023{
6024 int i;
6025
6026 if (!map)
6027 return NULL((void*)0);
6028
6029 if (--map->ref > 0)
6030 return NULL((void*)0);
6031
6032 clear_caches(map);
6033 isl_ctx_deref(map->ctx);
6034 for (i = 0; i < map->n; ++i)
6035 isl_basic_map_free(map->p[i]);
6036 isl_space_free(map->dim);
6037 free(map);
6038
6039 return NULL((void*)0);
6040}
6041
6042static struct isl_basic_map *isl_basic_map_fix_pos_si(
6043 struct isl_basic_map *bmap, unsigned pos, int value)
6044{
6045 int j;
6046
6047 bmap = isl_basic_map_cow(bmap);
6048 bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
6049 j = isl_basic_map_alloc_equality(bmap);
6050 if (j < 0)
6051 goto error;
6052 isl_seq_clr(bmap->eq[j] + 1, isl_basic_map_total_dim(bmap));
6053 isl_int_set_si(bmap->eq[j][pos], -1)isl_sioimath_set_si((bmap->eq[j][pos]), -1);
6054 isl_int_set_si(bmap->eq[j][0], value)isl_sioimath_set_si((bmap->eq[j][0]), value);
6055 bmap = isl_basic_map_simplify(bmap);
6056 return isl_basic_map_finalize(bmap);
6057error:
6058 isl_basic_map_free(bmap);
6059 return NULL((void*)0);
6060}
6061
6062static __isl_give isl_basic_map *isl_basic_map_fix_pos(
6063 __isl_take isl_basic_map *bmap, unsigned pos, isl_int value)
6064{
6065 int j;
6066
6067 bmap = isl_basic_map_cow(bmap);
6068 bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
6069 j = isl_basic_map_alloc_equality(bmap);
6070 if (j < 0)
6071 goto error;
6072 isl_seq_clr(bmap->eq[j] + 1, isl_basic_map_total_dim(bmap));
6073 isl_int_set_si(bmap->eq[j][pos], -1)isl_sioimath_set_si((bmap->eq[j][pos]), -1);
6074 isl_int_set(bmap->eq[j][0], value)isl_sioimath_set((bmap->eq[j][0]), *(value));
6075 bmap = isl_basic_map_simplify(bmap);
6076 return isl_basic_map_finalize(bmap);
6077error:
6078 isl_basic_map_free(bmap);
6079 return NULL((void*)0);
6080}
6081
6082__isl_give isl_basic_map *isl_basic_map_fix_si(__isl_take isl_basic_map *bmap,
6083 enum isl_dim_type type, unsigned pos, int value)
6084{
6085 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
6086 return isl_basic_map_free(bmap);
6087 return isl_basic_map_fix_pos_si(bmap,
6088 isl_basic_map_offset(bmap, type) + pos, value);
6089}
6090
6091__isl_give isl_basic_map *isl_basic_map_fix(__isl_take isl_basic_map *bmap,
6092 enum isl_dim_type type, unsigned pos, isl_int value)
6093{
6094 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
6095 return isl_basic_map_free(bmap);
6096 return isl_basic_map_fix_pos(bmap,
6097 isl_basic_map_offset(bmap, type) + pos, value);
6098}
6099
6100/* Fix the value of the variable at position "pos" of type "type" of "bmap"
6101 * to be equal to "v".
6102 */
6103__isl_give isl_basic_map *isl_basic_map_fix_val(__isl_take isl_basic_map *bmap,
6104 enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
6105{
6106 if (!bmap || !v)
6107 goto error;
6108 if (!isl_val_is_int(v))
6109 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6110); goto error; } while (0)
6110 "expecting integer value", goto error)do { isl_handle_error(isl_basic_map_get_ctx(bmap), isl_error_invalid
, "expecting integer value", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6110); goto error; } while (0)
;
6111 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
6112 goto error;
6113 pos += isl_basic_map_offset(bmap, type);
6114 bmap = isl_basic_map_fix_pos(bmap, pos, v->n);
6115 isl_val_free(v);
6116 return bmap;
6117error:
6118 isl_basic_map_free(bmap);
6119 isl_val_free(v);
6120 return NULL((void*)0);
6121}
6122
6123/* Fix the value of the variable at position "pos" of type "type" of "bset"
6124 * to be equal to "v".
6125 */
6126__isl_give isl_basic_setisl_basic_map *isl_basic_set_fix_val(__isl_take isl_basic_setisl_basic_map *bset,
6127 enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
6128{
6129 return isl_basic_map_fix_val(bset, type, pos, v);
6130}
6131
6132struct isl_basic_setisl_basic_map *isl_basic_set_fix_si(struct isl_basic_setisl_basic_map *bset,
6133 enum isl_dim_type type, unsigned pos, int value)
6134{
6135 return bset_from_bmap(isl_basic_map_fix_si(bset_to_bmap(bset),
6136 type, pos, value));
6137}
6138
6139__isl_give isl_basic_setisl_basic_map *isl_basic_set_fix(__isl_take isl_basic_setisl_basic_map *bset,
6140 enum isl_dim_type type, unsigned pos, isl_int value)
6141{
6142 return bset_from_bmap(isl_basic_map_fix(bset_to_bmap(bset),
6143 type, pos, value));
6144}
6145
6146struct isl_basic_map *isl_basic_map_fix_input_si(struct isl_basic_map *bmap,
6147 unsigned input, int value)
6148{
6149 return isl_basic_map_fix_si(bmap, isl_dim_in, input, value);
6150}
6151
6152struct isl_basic_setisl_basic_map *isl_basic_set_fix_dim_si(struct isl_basic_setisl_basic_map *bset,
6153 unsigned dim, int value)
6154{
6155 return bset_from_bmap(isl_basic_map_fix_si(bset_to_bmap(bset),
6156 isl_dim_set, dim, value));
6157}
6158
6159static int remove_if_empty(__isl_keep isl_map *map, int i)
6160{
6161 int empty = isl_basic_map_plain_is_empty(map->p[i]);
6162
6163 if (empty < 0)
6164 return -1;
6165 if (!empty)
6166 return 0;
6167
6168 isl_basic_map_free(map->p[i]);
6169 if (i != map->n - 1) {
6170 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
6171 map->p[i] = map->p[map->n - 1];
6172 }
6173 map->n--;
6174
6175 return 0;
6176}
6177
6178/* Perform "fn" on each basic map of "map", where we may not be holding
6179 * the only reference to "map".
6180 * In particular, "fn" should be a semantics preserving operation
6181 * that we want to apply to all copies of "map". We therefore need
6182 * to be careful not to modify "map" in a way that breaks "map"
6183 * in case anything goes wrong.
6184 */
6185__isl_give isl_map *isl_map_inline_foreach_basic_map(__isl_take isl_map *map,
6186 __isl_give isl_basic_map *(*fn)(__isl_take isl_basic_map *bmap))
6187{
6188 struct isl_basic_map *bmap;
6189 int i;
6190
6191 if (!map)
6192 return NULL((void*)0);
6193
6194 for (i = map->n - 1; i >= 0; --i) {
6195 bmap = isl_basic_map_copy(map->p[i]);
6196 bmap = fn(bmap);
6197 if (!bmap)
6198 goto error;
6199 isl_basic_map_free(map->p[i]);
6200 map->p[i] = bmap;
6201 if (remove_if_empty(map, i) < 0)
6202 goto error;
6203 }
6204
6205 return map;
6206error:
6207 isl_map_free(map);
6208 return NULL((void*)0);
6209}
6210
6211__isl_give isl_map *isl_map_fix_si(__isl_take isl_map *map,
6212 enum isl_dim_type type, unsigned pos, int value)
6213{
6214 int i;
6215
6216 map = isl_map_cow(map);
6217 if (!map)
6218 return NULL((void*)0);
6219
6220 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6220); goto error; } while (0); } while (0)
;
6221 for (i = map->n - 1; i >= 0; --i) {
6222 map->p[i] = isl_basic_map_fix_si(map->p[i], type, pos, value);
6223 if (remove_if_empty(map, i) < 0)
6224 goto error;
6225 }
6226 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
6227 return map;
6228error:
6229 isl_map_free(map);
6230 return NULL((void*)0);
6231}
6232
6233__isl_give isl_setisl_map *isl_set_fix_si(__isl_take isl_setisl_map *set,
6234 enum isl_dim_type type, unsigned pos, int value)
6235{
6236 return set_from_map(isl_map_fix_si(set_to_map(set), type, pos, value));
6237}
6238
6239__isl_give isl_map *isl_map_fix(__isl_take isl_map *map,
6240 enum isl_dim_type type, unsigned pos, isl_int value)
6241{
6242 int i;
6243
6244 map = isl_map_cow(map);
6245 if (!map)
6246 return NULL((void*)0);
6247
6248 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6248); goto error; } while (0); } while (0)
;
6249 for (i = 0; i < map->n; ++i) {
6250 map->p[i] = isl_basic_map_fix(map->p[i], type, pos, value);
6251 if (!map->p[i])
6252 goto error;
6253 }
6254 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
6255 return map;
6256error:
6257 isl_map_free(map);
6258 return NULL((void*)0);
6259}
6260
6261__isl_give isl_setisl_map *isl_set_fix(__isl_take isl_setisl_map *set,
6262 enum isl_dim_type type, unsigned pos, isl_int value)
6263{
6264 return set_from_map(isl_map_fix(set_to_map(set), type, pos, value));
6265}
6266
6267/* Fix the value of the variable at position "pos" of type "type" of "map"
6268 * to be equal to "v".
6269 */
6270__isl_give isl_map *isl_map_fix_val(__isl_take isl_map *map,
6271 enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
6272{
6273 int i;
6274
6275 map = isl_map_cow(map);
6276 if (!map || !v)
6277 goto error;
6278
6279 if (!isl_val_is_int(v))
6280 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6281); goto error; } while (0)
6281 "expecting integer value", goto error)do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "expecting integer value", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6281); goto error; } while (0)
;
6282 if (pos >= isl_map_dim(map, type))
6283 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6284); goto error; } while (0)
6284 "index out of bounds", goto error)do { isl_handle_error(isl_map_get_ctx(map), isl_error_invalid
, "index out of bounds", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6284); goto error; } while (0)
;
6285 for (i = map->n - 1; i >= 0; --i) {
6286 map->p[i] = isl_basic_map_fix_val(map->p[i], type, pos,
6287 isl_val_copy(v));
6288 if (remove_if_empty(map, i) < 0)
6289 goto error;
6290 }
6291 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
6292 isl_val_free(v);
6293 return map;
6294error:
6295 isl_map_free(map);
6296 isl_val_free(v);
6297 return NULL((void*)0);
6298}
6299
6300/* Fix the value of the variable at position "pos" of type "type" of "set"
6301 * to be equal to "v".
6302 */
6303__isl_give isl_setisl_map *isl_set_fix_val(__isl_take isl_setisl_map *set,
6304 enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
6305{
6306 return isl_map_fix_val(set, type, pos, v);
6307}
6308
6309struct isl_map *isl_map_fix_input_si(struct isl_map *map,
6310 unsigned input, int value)
6311{
6312 return isl_map_fix_si(map, isl_dim_in, input, value);
6313}
6314
6315struct isl_setisl_map *isl_set_fix_dim_si(struct isl_setisl_map *set, unsigned dim, int value)
6316{
6317 return set_from_map(isl_map_fix_si(set_to_map(set),
6318 isl_dim_set, dim, value));
6319}
6320
6321static __isl_give isl_basic_map *basic_map_bound_si(
6322 __isl_take isl_basic_map *bmap,
6323 enum isl_dim_type type, unsigned pos, int value, int upper)
6324{
6325 int j;
6326
6327 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
6328 return isl_basic_map_free(bmap);
6329 pos += isl_basic_map_offset(bmap, type);
6330 bmap = isl_basic_map_cow(bmap);
6331 bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
6332 j = isl_basic_map_alloc_inequality(bmap);
6333 if (j < 0)
6334 goto error;
6335 isl_seq_clr(bmap->ineq[j], 1 + isl_basic_map_total_dim(bmap));
6336 if (upper) {
6337 isl_int_set_si(bmap->ineq[j][pos], -1)isl_sioimath_set_si((bmap->ineq[j][pos]), -1);
6338 isl_int_set_si(bmap->ineq[j][0], value)isl_sioimath_set_si((bmap->ineq[j][0]), value);
6339 } else {
6340 isl_int_set_si(bmap->ineq[j][pos], 1)isl_sioimath_set_si((bmap->ineq[j][pos]), 1);
6341 isl_int_set_si(bmap->ineq[j][0], -value)isl_sioimath_set_si((bmap->ineq[j][0]), -value);
6342 }
6343 bmap = isl_basic_map_simplify(bmap);
6344 return isl_basic_map_finalize(bmap);
6345error:
6346 isl_basic_map_free(bmap);
6347 return NULL((void*)0);
6348}
6349
6350__isl_give isl_basic_map *isl_basic_map_lower_bound_si(
6351 __isl_take isl_basic_map *bmap,
6352 enum isl_dim_type type, unsigned pos, int value)
6353{
6354 return basic_map_bound_si(bmap, type, pos, value, 0);
6355}
6356
6357/* Constrain the values of the given dimension to be no greater than "value".
6358 */
6359__isl_give isl_basic_map *isl_basic_map_upper_bound_si(
6360 __isl_take isl_basic_map *bmap,
6361 enum isl_dim_type type, unsigned pos, int value)
6362{
6363 return basic_map_bound_si(bmap, type, pos, value, 1);
6364}
6365
6366static __isl_give isl_map *map_bound_si(__isl_take isl_map *map,
6367 enum isl_dim_type type, unsigned pos, int value, int upper)
6368{
6369 int i;
6370
6371 map = isl_map_cow(map);
6372 if (!map)
6373 return NULL((void*)0);
6374
6375 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6375); goto error; } while (0); } while (0)
;
6376 for (i = 0; i < map->n; ++i) {
6377 map->p[i] = basic_map_bound_si(map->p[i],
6378 type, pos, value, upper);
6379 if (!map->p[i])
6380 goto error;
6381 }
6382 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
6383 return map;
6384error:
6385 isl_map_free(map);
6386 return NULL((void*)0);
6387}
6388
6389__isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map,
6390 enum isl_dim_type type, unsigned pos, int value)
6391{
6392 return map_bound_si(map, type, pos, value, 0);
6393}
6394
6395__isl_give isl_map *isl_map_upper_bound_si(__isl_take isl_map *map,
6396 enum isl_dim_type type, unsigned pos, int value)
6397{
6398 return map_bound_si(map, type, pos, value, 1);
6399}
6400
6401__isl_give isl_setisl_map *isl_set_lower_bound_si(__isl_take isl_setisl_map *set,
6402 enum isl_dim_type type, unsigned pos, int value)
6403{
6404 return set_from_map(isl_map_lower_bound_si(set_to_map(set),
6405 type, pos, value));
6406}
6407
6408__isl_give isl_setisl_map *isl_set_upper_bound_si(__isl_take isl_setisl_map *set,
6409 enum isl_dim_type type, unsigned pos, int value)
6410{
6411 return isl_map_upper_bound_si(set, type, pos, value);
6412}
6413
6414/* Bound the given variable of "bmap" from below (or above is "upper"
6415 * is set) to "value".
6416 */
6417static __isl_give isl_basic_map *basic_map_bound(
6418 __isl_take isl_basic_map *bmap,
6419 enum isl_dim_type type, unsigned pos, isl_int value, int upper)
6420{
6421 int j;
6422
6423 if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
6424 return isl_basic_map_free(bmap);
6425 pos += isl_basic_map_offset(bmap, type);
6426 bmap = isl_basic_map_cow(bmap);
6427 bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
6428 j = isl_basic_map_alloc_inequality(bmap);
6429 if (j < 0)
6430 goto error;
6431 isl_seq_clr(bmap->ineq[j], 1 + isl_basic_map_total_dim(bmap));
6432 if (upper) {
6433 isl_int_set_si(bmap->ineq[j][pos], -1)isl_sioimath_set_si((bmap->ineq[j][pos]), -1);
6434 isl_int_set(bmap->ineq[j][0], value)isl_sioimath_set((bmap->ineq[j][0]), *(value));
6435 } else {
6436 isl_int_set_si(bmap->ineq[j][pos], 1)isl_sioimath_set_si((bmap->ineq[j][pos]), 1);
6437 isl_int_neg(bmap->ineq[j][0], value)isl_sioimath_neg((bmap->ineq[j][0]), *(value));
6438 }
6439 bmap = isl_basic_map_simplify(bmap);
6440 return isl_basic_map_finalize(bmap);
6441error:
6442 isl_basic_map_free(bmap);
6443 return NULL((void*)0);
6444}
6445
6446/* Bound the given variable of "map" from below (or above is "upper"
6447 * is set) to "value".
6448 */
6449static __isl_give isl_map *map_bound(__isl_take isl_map *map,
6450 enum isl_dim_type type, unsigned pos, isl_int value, int upper)
6451{
6452 int i;
6453
6454 map = isl_map_cow(map);
6455 if (!map)
6456 return NULL((void*)0);
6457
6458 if (pos >= isl_map_dim(map, type))
6459 isl_die(map->ctx, isl_error_invalid,do { isl_handle_error(map->ctx, isl_error_invalid, "index out of bounds"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6460); goto error; } while (0)
6460 "index out of bounds", goto error)do { isl_handle_error(map->ctx, isl_error_invalid, "index out of bounds"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6460); goto error; } while (0)
;
6461 for (i = map->n - 1; i >= 0; --i) {
6462 map->p[i] = basic_map_bound(map->p[i], type, pos, value, upper);
6463 if (remove_if_empty(map, i) < 0)
6464 goto error;
6465 }
6466 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
6467 return map;
6468error:
6469 isl_map_free(map);
6470 return NULL((void*)0);
6471}
6472
6473__isl_give isl_map *isl_map_lower_bound(__isl_take isl_map *map,
6474 enum isl_dim_type type, unsigned pos, isl_int value)
6475{
6476 return map_bound(map, type, pos, value, 0);
6477}
6478
6479__isl_give isl_map *isl_map_upper_bound(__isl_take isl_map *map,
6480 enum isl_dim_type type, unsigned pos, isl_int value)
6481{
6482 return map_bound(map, type, pos, value, 1);
6483}
6484
6485__isl_give isl_setisl_map *isl_set_lower_bound(__isl_take isl_setisl_map *set,
6486 enum isl_dim_type type, unsigned pos, isl_int value)
6487{
6488 return isl_map_lower_bound(set, type, pos, value);
6489}
6490
6491__isl_give isl_setisl_map *isl_set_upper_bound(__isl_take isl_setisl_map *set,
6492 enum isl_dim_type type, unsigned pos, isl_int value)
6493{
6494 return isl_map_upper_bound(set, type, pos, value);
6495}
6496
6497/* Force the values of the variable at position "pos" of type "type" of "set"
6498 * to be no smaller than "value".
6499 */
6500__isl_give isl_setisl_map *isl_set_lower_bound_val(__isl_take isl_setisl_map *set,
6501 enum isl_dim_type type, unsigned pos, __isl_take isl_val *value)
6502{
6503 if (!value)
6504 goto error;
6505 if (!isl_val_is_int(value))
6506 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6507); goto error; } while (0)
6507 "expecting integer value", goto error)do { isl_handle_error(isl_set_get_ctx(set), isl_error_invalid
, "expecting integer value", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6507); goto error; } while (0)
;
6508 set = isl_set_lower_bound(set, type, pos, value->n);
6509 isl_val_free(value);
6510 return set;
6511error:
6512 isl_val_free(value);
6513 isl_set_free(set);
6514 return NULL((void*)0);
6515}
6516
6517/* Force the values of the variable at position "pos" of type "type" of "set"
6518 * to be no greater than "value".
6519 */
6520__isl_give isl_setisl_map *isl_set_upper_bound_val(__isl_take isl_setisl_map *set,
6521 enum isl_dim_type type, unsigned pos, __isl_take isl_val *value)
6522{
6523 if (!value)
6524 goto error;
6525 if (!isl_val_is_int(value))
6526 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6527); goto error; } while (0)
6527 "expecting integer value", goto error)do { isl_handle_error(isl_set_get_ctx(set), isl_error_invalid
, "expecting integer value", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6527); goto error; } while (0)
;
6528 set = isl_set_upper_bound(set, type, pos, value->n);
6529 isl_val_free(value);
6530 return set;
6531error:
6532 isl_val_free(value);
6533 isl_set_free(set);
6534 return NULL((void*)0);
6535}
6536
6537__isl_give isl_map *isl_map_reverse(__isl_take isl_map *map)
6538{
6539 int i;
6540
6541 map = isl_map_cow(map);
6542 if (!map)
6543 return NULL((void*)0);
6544
6545 map->dim = isl_space_reverse(map->dim);
6546 if (!map->dim)
6547 goto error;
6548 for (i = 0; i < map->n; ++i) {
6549 map->p[i] = isl_basic_map_reverse(map->p[i]);
6550 if (!map->p[i])
6551 goto error;
6552 }
6553 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
6554 return map;
6555error:
6556 isl_map_free(map);
6557 return NULL((void*)0);
6558}
6559
6560#undef TYPEisl_map
6561#define TYPEisl_map isl_pw_multi_aff
6562#undef SUFFIX
6563#define SUFFIX _pw_multi_aff
6564#undef EMPTYisl_map_empty
6565#define EMPTYisl_map_empty isl_pw_multi_aff_empty
6566#undef ADDisl_map_union_disjoint
6567#define ADDisl_map_union_disjoint isl_pw_multi_aff_union_add
6568#include "isl_map_lexopt_templ.c"
6569
6570/* Given a map "map", compute the lexicographically minimal
6571 * (or maximal) image element for each domain element in dom,
6572 * in the form of an isl_pw_multi_aff.
6573 * If "empty" is not NULL, then set *empty to those elements in dom that
6574 * do not have an image element.
6575 * If "flags" includes ISL_OPT_FULL, then "dom" is NULL and the optimum
6576 * should be computed over the domain of "map". "empty" is also NULL
6577 * in this case.
6578 *
6579 * We first compute the lexicographically minimal or maximal element
6580 * in the first basic map. This results in a partial solution "res"
6581 * and a subset "todo" of dom that still need to be handled.
6582 * We then consider each of the remaining maps in "map" and successively
6583 * update both "res" and "todo".
6584 * If "empty" is NULL, then the todo sets are not needed and therefore
6585 * also not computed.
6586 */
6587static __isl_give isl_pw_multi_aff *isl_map_partial_lexopt_aligned_pw_multi_aff(
6588 __isl_take isl_map *map, __isl_take isl_setisl_map *dom,
6589 __isl_give isl_setisl_map **empty, unsigned flags)
6590{
6591 int i;
6592 int full;
6593 isl_pw_multi_aff *res;
6594 isl_setisl_map *todo;
6595
6596 full = ISL_FL_ISSET(flags, ISL_OPT_FULL)(!!((flags) & ((1 << 1))));
6597 if (!map || (!full && !dom))
6598 goto error;
6599
6600 if (isl_map_plain_is_empty(map)) {
6601 if (empty)
6602 *empty = dom;
6603 else
6604 isl_set_free(dom);
6605 return isl_pw_multi_aff_from_map(map);
6606 }
6607
6608 res = basic_map_partial_lexopt_pw_multi_aff(
6609 isl_basic_map_copy(map->p[0]),
6610 isl_set_copy(dom), empty, flags);
6611
6612 if (empty)
6613 todo = *empty;
6614 for (i = 1; i < map->n; ++i) {
6615 isl_pw_multi_aff *res_i;
6616
6617 res_i = basic_map_partial_lexopt_pw_multi_aff(
6618 isl_basic_map_copy(map->p[i]),
6619 isl_set_copy(dom), empty, flags);
6620
6621 if (ISL_FL_ISSET(flags, ISL_OPT_MAX)(!!((flags) & ((1 << 0)))))
6622 res = isl_pw_multi_aff_union_lexmax(res, res_i);
6623 else
6624 res = isl_pw_multi_aff_union_lexmin(res, res_i);
6625
6626 if (empty)
6627 todo = isl_set_intersect(todo, *empty);
6628 }
6629
6630 isl_set_free(dom);
6631 isl_map_free(map);
6632
6633 if (empty)
6634 *empty = todo;
6635
6636 return res;
6637error:
6638 if (empty)
6639 *empty = NULL((void*)0);
6640 isl_set_free(dom);
6641 isl_map_free(map);
6642 return NULL((void*)0);
6643}
6644
6645#undef TYPEisl_map
6646#define TYPEisl_map isl_map
6647#undef SUFFIX
6648#define SUFFIX
6649#undef EMPTYisl_map_empty
6650#define EMPTYisl_map_empty isl_map_empty
6651#undef ADDisl_map_union_disjoint
6652#define ADDisl_map_union_disjoint isl_map_union_disjoint
6653#include "isl_map_lexopt_templ.c"
6654
6655/* Given a map "map", compute the lexicographically minimal
6656 * (or maximal) image element for each domain element in "dom",
6657 * in the form of an isl_map.
6658 * If "empty" is not NULL, then set *empty to those elements in "dom" that
6659 * do not have an image element.
6660 * If "flags" includes ISL_OPT_FULL, then "dom" is NULL and the optimum
6661 * should be computed over the domain of "map". "empty" is also NULL
6662 * in this case.
6663 *
6664 * If the input consists of more than one disjunct, then first
6665 * compute the desired result in the form of an isl_pw_multi_aff and
6666 * then convert that into an isl_map.
6667 *
6668 * This function used to have an explicit implementation in terms
6669 * of isl_maps, but it would continually intersect the domains of
6670 * partial results with the complement of the domain of the next
6671 * partial solution, potentially leading to an explosion in the number
6672 * of disjuncts if there are several disjuncts in the input.
6673 * An even earlier implementation of this function would look for
6674 * better results in the domain of the partial result and for extra
6675 * results in the complement of this domain, which would lead to
6676 * even more splintering.
6677 */
6678static __isl_give isl_map *isl_map_partial_lexopt_aligned(
6679 __isl_take isl_map *map, __isl_take isl_setisl_map *dom,
6680 __isl_give isl_setisl_map **empty, unsigned flags)
6681{
6682 int full;
6683 struct isl_map *res;
6684 isl_pw_multi_aff *pma;
6685
6686 full = ISL_FL_ISSET(flags, ISL_OPT_FULL)(!!((flags) & ((1 << 1))));
6687 if (!map || (!full && !dom))
6688 goto error;
6689
6690 if (isl_map_plain_is_empty(map)) {
6691 if (empty)
6692 *empty = dom;
6693 else
6694 isl_set_free(dom);
6695 return map;
6696 }
6697
6698 if (map->n == 1) {
6699 res = basic_map_partial_lexopt(isl_basic_map_copy(map->p[0]),
6700 dom, empty, flags);
6701 isl_map_free(map);
6702 return res;
6703 }
6704
6705 pma = isl_map_partial_lexopt_aligned_pw_multi_aff(map, dom, empty,
6706 flags);
6707 return isl_map_from_pw_multi_aff(pma);
6708error:
6709 if (empty)
6710 *empty = NULL((void*)0);
6711 isl_set_free(dom);
6712 isl_map_free(map);
6713 return NULL((void*)0);
6714}
6715
6716__isl_give isl_map *isl_map_partial_lexmax(
6717 __isl_take isl_map *map, __isl_take isl_setisl_map *dom,
6718 __isl_give isl_setisl_map **empty)
6719{
6720 return isl_map_partial_lexopt(map, dom, empty, ISL_OPT_MAX(1 << 0));
6721}
6722
6723__isl_give isl_map *isl_map_partial_lexmin(
6724 __isl_take isl_map *map, __isl_take isl_setisl_map *dom,
6725 __isl_give isl_setisl_map **empty)
6726{
6727 return isl_map_partial_lexopt(map, dom, empty, 0);
6728}
6729
6730__isl_give isl_setisl_map *isl_set_partial_lexmin(
6731 __isl_take isl_setisl_map *set, __isl_take isl_setisl_map *dom,
6732 __isl_give isl_setisl_map **empty)
6733{
6734 return set_from_map(isl_map_partial_lexmin(set_to_map(set),
6735 dom, empty));
6736}
6737
6738__isl_give isl_setisl_map *isl_set_partial_lexmax(
6739 __isl_take isl_setisl_map *set, __isl_take isl_setisl_map *dom,
6740 __isl_give isl_setisl_map **empty)
6741{
6742 return set_from_map(isl_map_partial_lexmax(set_to_map(set),
6743 dom, empty));
6744}
6745
6746/* Compute the lexicographic minimum (or maximum if "flags" includes
6747 * ISL_OPT_MAX) of "bset" over its parametric domain.
6748 */
6749__isl_give isl_setisl_map *isl_basic_set_lexopt(__isl_take isl_basic_setisl_basic_map *bset,
6750 unsigned flags)
6751{
6752 return isl_basic_map_lexopt(bset, flags);
6753}
6754
6755__isl_give isl_map *isl_basic_map_lexmax(__isl_take isl_basic_map *bmap)
6756{
6757 return isl_basic_map_lexopt(bmap, ISL_OPT_MAX(1 << 0));
6758}
6759
6760__isl_give isl_setisl_map *isl_basic_set_lexmin(__isl_take isl_basic_setisl_basic_map *bset)
6761{
6762 return set_from_map(isl_basic_map_lexmin(bset_to_bmap(bset)));
6763}
6764
6765__isl_give isl_setisl_map *isl_basic_set_lexmax(__isl_take isl_basic_setisl_basic_map *bset)
6766{
6767 return set_from_map(isl_basic_map_lexmax(bset_to_bmap(bset)));
6768}
6769
6770/* Compute the lexicographic minimum of "bset" over its parametric domain
6771 * for the purpose of quantifier elimination.
6772 * That is, find an explicit representation for all the existentially
6773 * quantified variables in "bset" by computing their lexicographic
6774 * minimum.
6775 */
6776static __isl_give isl_setisl_map *isl_basic_set_lexmin_compute_divs(
6777 __isl_take isl_basic_setisl_basic_map *bset)
6778{
6779 return isl_basic_set_lexopt(bset, ISL_OPT_QE(1 << 2));
6780}
6781
6782/* Extract the first and only affine expression from list
6783 * and then add it to *pwaff with the given dom.
6784 * This domain is known to be disjoint from other domains
6785 * because of the way isl_basic_map_foreach_lexmax works.
6786 */
6787static isl_stat update_dim_opt(__isl_take isl_basic_setisl_basic_map *dom,
6788 __isl_take isl_aff_list *list, void *user)
6789{
6790 isl_ctx *ctx = isl_basic_set_get_ctx(dom);
6791 isl_aff *aff;
6792 isl_pw_aff **pwaff = user;
6793 isl_pw_aff *pwaff_i;
6794
6795 if (!list)
6796 goto error;
6797 if (isl_aff_list_n_aff(list) != 1)
6798 isl_die(ctx, isl_error_internal,do { isl_handle_error(ctx, isl_error_internal, "expecting single element list"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6799); goto error; } while (0)
6799 "expecting single element list", goto error)do { isl_handle_error(ctx, isl_error_internal, "expecting single element list"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6799); goto error; } while (0)
;
6800
6801 aff = isl_aff_list_get_aff(list, 0);
6802 pwaff_i = isl_pw_aff_alloc(isl_set_from_basic_set(dom), aff);
6803
6804 *pwaff = isl_pw_aff_add_disjoint(*pwaff, pwaff_i);
6805
6806 isl_aff_list_free(list);
6807
6808 return isl_stat_ok;
6809error:
6810 isl_basic_set_free(dom);
6811 isl_aff_list_free(list);
6812 return isl_stat_error;
6813}
6814
6815/* Given a basic map with one output dimension, compute the minimum or
6816 * maximum of that dimension as an isl_pw_aff.
6817 *
6818 * The isl_pw_aff is constructed by having isl_basic_map_foreach_lexopt
6819 * call update_dim_opt on each leaf of the result.
6820 */
6821static __isl_give isl_pw_aff *basic_map_dim_opt(__isl_keep isl_basic_map *bmap,
6822 int max)
6823{
6824 isl_space *dim = isl_basic_map_get_space(bmap);
6825 isl_pw_aff *pwaff;
6826 isl_stat r;
6827
6828 dim = isl_space_from_domain(isl_space_domain(dim));
6829 dim = isl_space_add_dims(dim, isl_dim_out, 1);
6830 pwaff = isl_pw_aff_empty(dim);
6831
6832 r = isl_basic_map_foreach_lexopt(bmap, max, &update_dim_opt, &pwaff);
6833 if (r < 0)
6834 return isl_pw_aff_free(pwaff);
6835
6836 return pwaff;
6837}
6838
6839/* Compute the minimum or maximum of the given output dimension
6840 * as a function of the parameters and the input dimensions,
6841 * but independently of the other output dimensions.
6842 *
6843 * We first project out the other output dimension and then compute
6844 * the "lexicographic" maximum in each basic map, combining the results
6845 * using isl_pw_aff_union_max.
6846 */
6847static __isl_give isl_pw_aff *map_dim_opt(__isl_take isl_map *map, int pos,
6848 int max)
6849{
6850 int i;
6851 isl_pw_aff *pwaff;
6852 unsigned n_out;
6853
6854 n_out = isl_map_dim(map, isl_dim_out);
6855 map = isl_map_project_out(map, isl_dim_out, pos + 1, n_out - (pos + 1));
6856 map = isl_map_project_out(map, isl_dim_out, 0, pos);
6857 if (!map)
6858 return NULL((void*)0);
6859
6860 if (map->n == 0) {
6861 isl_space *dim = isl_map_get_space(map);
6862 isl_map_free(map);
6863 return isl_pw_aff_empty(dim);
6864 }
6865
6866 pwaff = basic_map_dim_opt(map->p[0], max);
6867 for (i = 1; i < map->n; ++i) {
6868 isl_pw_aff *pwaff_i;
6869
6870 pwaff_i = basic_map_dim_opt(map->p[i], max);
6871 pwaff = isl_pw_aff_union_opt(pwaff, pwaff_i, max);
6872 }
6873
6874 isl_map_free(map);
6875
6876 return pwaff;
6877}
6878
6879/* Compute the minimum of the given output dimension as a function of the
6880 * parameters and input dimensions, but independently of
6881 * the other output dimensions.
6882 */
6883__isl_give isl_pw_aff *isl_map_dim_min(__isl_take isl_map *map, int pos)
6884{
6885 return map_dim_opt(map, pos, 0);
6886}
6887
6888/* Compute the maximum of the given output dimension as a function of the
6889 * parameters and input dimensions, but independently of
6890 * the other output dimensions.
6891 */
6892__isl_give isl_pw_aff *isl_map_dim_max(__isl_take isl_map *map, int pos)
6893{
6894 return map_dim_opt(map, pos, 1);
6895}
6896
6897/* Compute the minimum or maximum of the given set dimension
6898 * as a function of the parameters,
6899 * but independently of the other set dimensions.
6900 */
6901static __isl_give isl_pw_aff *set_dim_opt(__isl_take isl_setisl_map *set, int pos,
6902 int max)
6903{
6904 return map_dim_opt(set, pos, max);
6905}
6906
6907/* Compute the maximum of the given set dimension as a function of the
6908 * parameters, but independently of the other set dimensions.
6909 */
6910__isl_give isl_pw_aff *isl_set_dim_max(__isl_take isl_setisl_map *set, int pos)
6911{
6912 return set_dim_opt(set, pos, 1);
6913}
6914
6915/* Compute the minimum of the given set dimension as a function of the
6916 * parameters, but independently of the other set dimensions.
6917 */
6918__isl_give isl_pw_aff *isl_set_dim_min(__isl_take isl_setisl_map *set, int pos)
6919{
6920 return set_dim_opt(set, pos, 0);
6921}
6922
6923/* Apply a preimage specified by "mat" on the parameters of "bset".
6924 * bset is assumed to have only parameters and divs.
6925 */
6926static __isl_give isl_basic_setisl_basic_map *basic_set_parameter_preimage(
6927 __isl_take isl_basic_setisl_basic_map *bset, __isl_take isl_mat *mat)
6928{
6929 unsigned nparam;
6930
6931 if (!bset || !mat)
6932 goto error;
6933
6934 bset->dim = isl_space_cow(bset->dim);
6935 if (!bset->dim)
6936 goto error;
6937
6938 nparam = isl_basic_set_dim(bset, isl_dim_param);
6939
6940 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6940); goto error; } while (0); } while (0)
;
6941
6942 bset->dim->nparam = 0;
6943 bset->dim->n_out = nparam;
6944 bset = isl_basic_set_preimage(bset, mat);
6945 if (bset) {
6946 bset->dim->nparam = bset->dim->n_out;
6947 bset->dim->n_out = 0;
6948 }
6949 return bset;
6950error:
6951 isl_mat_free(mat);
6952 isl_basic_set_free(bset);
6953 return NULL((void*)0);
6954}
6955
6956/* Apply a preimage specified by "mat" on the parameters of "set".
6957 * set is assumed to have only parameters and divs.
6958 */
6959static __isl_give isl_setisl_map *set_parameter_preimage(__isl_take isl_setisl_map *set,
6960 __isl_take isl_mat *mat)
6961{
6962 isl_space *space;
6963 unsigned nparam;
6964
6965 if (!set || !mat)
6966 goto error;
6967
6968 nparam = isl_set_dim(set, isl_dim_param);
6969
6970 if (mat->n_row != 1 + nparam)
6971 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6972); goto error; } while (0)
6972 "unexpected number of rows", goto error)do { isl_handle_error(isl_set_get_ctx(set), isl_error_internal
, "unexpected number of rows", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 6972); goto error; } while (0)
;
6973
6974 space = isl_set_get_space(set);
6975 space = isl_space_move_dims(space, isl_dim_set, 0,
6976 isl_dim_param, 0, nparam);
6977 set = isl_set_reset_space(set, space);
6978 set = isl_set_preimage(set, mat);
6979 nparam = isl_set_dim(set, isl_dim_out);
6980 space = isl_set_get_space(set);
6981 space = isl_space_move_dims(space, isl_dim_param, 0,
6982 isl_dim_out, 0, nparam);
6983 set = isl_set_reset_space(set, space);
6984 return set;
6985error:
6986 isl_mat_free(mat);
6987 isl_set_free(set);
6988 return NULL((void*)0);
6989}
6990
6991/* Intersect the basic set "bset" with the affine space specified by the
6992 * equalities in "eq".
6993 */
6994static __isl_give isl_basic_setisl_basic_map *basic_set_append_equalities(
6995 __isl_take isl_basic_setisl_basic_map *bset, __isl_take isl_mat *eq)
6996{
6997 int i, k;
6998 unsigned len;
6999
7000 if (!bset || !eq)
7001 goto error;
7002
7003 bset = isl_basic_set_extend_space(bset, isl_space_copy(bset->dim), 0,
7004 eq->n_row, 0);
7005 if (!bset)
7006 goto error;
7007
7008 len = 1 + isl_space_dim(bset->dim, isl_dim_all) + bset->extra;
7009 for (i = 0; i < eq->n_row; ++i) {
7010 k = isl_basic_set_alloc_equality(bset);
7011 if (k < 0)
7012 goto error;
7013 isl_seq_cpy(bset->eq[k], eq->row[i], eq->n_col);
7014 isl_seq_clr(bset->eq[k] + eq->n_col, len - eq->n_col);
7015 }
7016 isl_mat_free(eq);
7017
7018 bset = isl_basic_set_gauss(bset, NULL((void*)0));
7019 bset = isl_basic_set_finalize(bset);
7020
7021 return bset;
7022error:
7023 isl_mat_free(eq);
7024 isl_basic_set_free(bset);
7025 return NULL((void*)0);
7026}
7027
7028/* Intersect the set "set" with the affine space specified by the
7029 * equalities in "eq".
7030 */
7031static struct isl_setisl_map *set_append_equalities(struct isl_setisl_map *set,
7032 struct isl_mat *eq)
7033{
7034 int i;
7035
7036 if (!set || !eq)
7037 goto error;
7038
7039 for (i = 0; i < set->n; ++i) {
7040 set->p[i] = basic_set_append_equalities(set->p[i],
7041 isl_mat_copy(eq));
7042 if (!set->p[i])
7043 goto error;
7044 }
7045 isl_mat_free(eq);
7046 return set;
7047error:
7048 isl_mat_free(eq);
7049 isl_set_free(set);
7050 return NULL((void*)0);
7051}
7052
7053/* Given a basic set "bset" that only involves parameters and existentially
7054 * quantified variables, return the index of the first equality
7055 * that only involves parameters. If there is no such equality then
7056 * return bset->n_eq.
7057 *
7058 * This function assumes that isl_basic_set_gauss has been called on "bset".
7059 */
7060static int first_parameter_equality(__isl_keep isl_basic_setisl_basic_map *bset)
7061{
7062 int i, j;
7063 unsigned nparam, n_div;
7064
7065 if (!bset)
7066 return -1;
7067
7068 nparam = isl_basic_set_dim(bset, isl_dim_param);
7069 n_div = isl_basic_set_dim(bset, isl_dim_div);
7070
7071 for (i = 0, j = n_div - 1; i < bset->n_eq && j >= 0; --j) {
7072 if (!isl_int_is_zero(bset->eq[i][1 + nparam + j])(isl_sioimath_sgn(*(bset->eq[i][1 + nparam + j])) == 0))
7073 ++i;
7074 }
7075
7076 return i;
7077}
7078
7079/* Compute an explicit representation for the existentially quantified
7080 * variables in "bset" by computing the "minimal value" of the set
7081 * variables. Since there are no set variables, the computation of
7082 * the minimal value essentially computes an explicit representation
7083 * of the non-empty part(s) of "bset".
7084 *
7085 * The input only involves parameters and existentially quantified variables.
7086 * All equalities among parameters have been removed.
7087 *
7088 * Since the existentially quantified variables in the result are in general
7089 * going to be different from those in the input, we first replace
7090 * them by the minimal number of variables based on their equalities.
7091 * This should simplify the parametric integer programming.
7092 */
7093static __isl_give isl_setisl_map *base_compute_divs(__isl_take isl_basic_setisl_basic_map *bset)
7094{
7095 isl_morph *morph1, *morph2;
7096 isl_setisl_map *set;
7097 unsigned n;
7098
7099 if (!bset)
7100 return NULL((void*)0);
7101 if (bset->n_eq == 0)
7102 return isl_basic_set_lexmin_compute_divs(bset);
7103
7104 morph1 = isl_basic_set_parameter_compression(bset);
7105 bset = isl_morph_basic_set(isl_morph_copy(morph1), bset);
7106 bset = isl_basic_set_lift(bset);
7107 morph2 = isl_basic_set_variable_compression(bset, isl_dim_set);
7108 bset = isl_morph_basic_set(morph2, bset);
7109 n = isl_basic_set_dim(bset, isl_dim_set);
7110 bset = isl_basic_set_project_out(bset, isl_dim_set, 0, n);
7111
7112 set = isl_basic_set_lexmin_compute_divs(bset);
7113
7114 set = isl_morph_set(isl_morph_inverse(morph1), set);
7115
7116 return set;
7117}
7118
7119/* Project the given basic set onto its parameter domain, possibly introducing
7120 * new, explicit, existential variables in the constraints.
7121 * The input has parameters and (possibly implicit) existential variables.
7122 * The output has the same parameters, but only
7123 * explicit existentially quantified variables.
7124 *
7125 * The actual projection is performed by pip, but pip doesn't seem
7126 * to like equalities very much, so we first remove the equalities
7127 * among the parameters by performing a variable compression on
7128 * the parameters. Afterward, an inverse transformation is performed
7129 * and the equalities among the parameters are inserted back in.
7130 *
7131 * The variable compression on the parameters may uncover additional
7132 * equalities that were only implicit before. We therefore check
7133 * if there are any new parameter equalities in the result and
7134 * if so recurse. The removal of parameter equalities is required
7135 * for the parameter compression performed by base_compute_divs.
7136 */
7137static struct isl_setisl_map *parameter_compute_divs(struct isl_basic_setisl_basic_map *bset)
7138{
7139 int i;
7140 struct isl_mat *eq;
7141 struct isl_mat *T, *T2;
7142 struct isl_setisl_map *set;
7143 unsigned nparam;
7144
7145 bset = isl_basic_set_cow(bset);
7146 if (!bset)
7147 return NULL((void*)0);
7148
7149 if (bset->n_eq == 0)
7150 return base_compute_divs(bset);
7151
7152 bset = isl_basic_set_gauss(bset, NULL((void*)0));
7153 if (!bset)
7154 return NULL((void*)0);
7155 if (isl_basic_set_plain_is_empty(bset))
7156 return isl_set_from_basic_set(bset);
7157
7158 i = first_parameter_equality(bset);
7159 if (i == bset->n_eq)
7160 return base_compute_divs(bset);
7161
7162 nparam = isl_basic_set_dim(bset, isl_dim_param);
7163 eq = isl_mat_sub_alloc6(bset->ctx, bset->eq, i, bset->n_eq - i,
7164 0, 1 + nparam);
7165 eq = isl_mat_cow(eq);
7166 T = isl_mat_variable_compression(isl_mat_copy(eq), &T2);
7167 if (T && T->n_col == 0) {
7168 isl_mat_free(T);
7169 isl_mat_free(T2);
7170 isl_mat_free(eq);
7171 bset = isl_basic_set_set_to_empty(bset);
7172 return isl_set_from_basic_set(bset);
7173 }
7174 bset = basic_set_parameter_preimage(bset, T);
7175
7176 i = first_parameter_equality(bset);
7177 if (!bset)
7178 set = NULL((void*)0);
7179 else if (i == bset->n_eq)
7180 set = base_compute_divs(bset);
7181 else
7182 set = parameter_compute_divs(bset);
7183 set = set_parameter_preimage(set, T2);
7184 set = set_append_equalities(set, eq);
7185 return set;
7186}
7187
7188/* Insert the divs from "ls" before those of "bmap".
7189 *
7190 * The number of columns is not changed, which means that the last
7191 * dimensions of "bmap" are being reintepreted as the divs from "ls".
7192 * The caller is responsible for removing the same number of dimensions
7193 * from the space of "bmap".
7194 */
7195static __isl_give isl_basic_map *insert_divs_from_local_space(
7196 __isl_take isl_basic_map *bmap, __isl_keep isl_local_space *ls)
7197{
7198 int i;
7199 int n_div;
7200 int old_n_div;
7201
7202 n_div = isl_local_space_dim(ls, isl_dim_div);
7203 if (n_div == 0)
7204 return bmap;
7205
7206 old_n_div = bmap->n_div;
7207 bmap = insert_div_rows(bmap, n_div);
7208 if (!bmap)
7209 return NULL((void*)0);
7210
7211 for (i = 0; i < n_div; ++i) {
7212 isl_seq_cpy(bmap->div[i], ls->div->row[i], ls->div->n_col);
7213 isl_seq_clr(bmap->div[i] + ls->div->n_col, old_n_div);
7214 }
7215
7216 return bmap;
7217}
7218
7219/* Replace the space of "bmap" by the space and divs of "ls".
7220 *
7221 * If "ls" has any divs, then we simplify the result since we may
7222 * have discovered some additional equalities that could simplify
7223 * the div expressions.
7224 */
7225static __isl_give isl_basic_map *basic_replace_space_by_local_space(
7226 __isl_take isl_basic_map *bmap, __isl_take isl_local_space *ls)
7227{
7228 int n_div;
7229
7230 bmap = isl_basic_map_cow(bmap);
7231 if (!bmap || !ls)
7232 goto error;
7233
7234 n_div = isl_local_space_dim(ls, isl_dim_div);
7235 bmap = insert_divs_from_local_space(bmap, ls);
7236 if (!bmap)
7237 goto error;
7238
7239 isl_space_free(bmap->dim);
7240 bmap->dim = isl_local_space_get_space(ls);
7241 if (!bmap->dim)
7242 goto error;
7243
7244 isl_local_space_free(ls);
7245 if (n_div > 0)
7246 bmap = isl_basic_map_simplify(bmap);
7247 bmap = isl_basic_map_finalize(bmap);
7248 return bmap;
7249error:
7250 isl_basic_map_free(bmap);
7251 isl_local_space_free(ls);
7252 return NULL((void*)0);
7253}
7254
7255/* Replace the space of "map" by the space and divs of "ls".
7256 */
7257static __isl_give isl_map *replace_space_by_local_space(__isl_take isl_map *map,
7258 __isl_take isl_local_space *ls)
7259{
7260 int i;
7261
7262 map = isl_map_cow(map);
7263 if (!map || !ls)
7264 goto error;
7265
7266 for (i = 0; i < map->n; ++i) {
7267 map->p[i] = basic_replace_space_by_local_space(map->p[i],
7268 isl_local_space_copy(ls));
7269 if (!map->p[i])
7270 goto error;
7271 }
7272 isl_space_free(map->dim);
7273 map->dim = isl_local_space_get_space(ls);
7274 if (!map->dim)
7275 goto error;
7276
7277 isl_local_space_free(ls);
7278 return map;
7279error:
7280 isl_local_space_free(ls);
7281 isl_map_free(map);
7282 return NULL((void*)0);
7283}
7284
7285/* Compute an explicit representation for the existentially
7286 * quantified variables for which do not know any explicit representation yet.
7287 *
7288 * We first sort the existentially quantified variables so that the
7289 * existentially quantified variables for which we already have an explicit
7290 * representation are placed before those for which we do not.
7291 * The input dimensions, the output dimensions and the existentially
7292 * quantified variables for which we already have an explicit
7293 * representation are then turned into parameters.
7294 * compute_divs returns a map with the same parameters and
7295 * no input or output dimensions and the dimension specification
7296 * is reset to that of the input, including the existentially quantified
7297 * variables for which we already had an explicit representation.
7298 */
7299static struct isl_map *compute_divs(struct isl_basic_map *bmap)
7300{
7301 struct isl_basic_setisl_basic_map *bset;
7302 struct isl_setisl_map *set;
7303 struct isl_map *map;
7304 isl_space *dim;
7305 isl_local_space *ls;
7306 unsigned nparam;
7307 unsigned n_in;
7308 unsigned n_out;
7309 int n_known;
7310 int i;
7311
7312 bmap = isl_basic_map_sort_divs(bmap);
7313 bmap = isl_basic_map_cow(bmap);
7314 if (!bmap)
7315 return NULL((void*)0);
7316
7317 n_known = isl_basic_map_first_unknown_div(bmap);
7318 if (n_known < 0)
7319 return isl_map_from_basic_map(isl_basic_map_free(bmap));
7320
7321 nparam = isl_basic_map_dim(bmap, isl_dim_param);
7322 n_in = isl_basic_map_dim(bmap, isl_dim_in);
7323 n_out = isl_basic_map_dim(bmap, isl_dim_out);
7324 dim = isl_space_set_alloc(bmap->ctx,
7325 nparam + n_in + n_out + n_known, 0);
7326 if (!dim)
7327 goto error;
7328
7329 ls = isl_basic_map_get_local_space(bmap);
7330 ls = isl_local_space_drop_dims(ls, isl_dim_div,
7331 n_known, bmap->n_div - n_known);
7332 if (n_known > 0) {
7333 for (i = n_known; i < bmap->n_div; ++i)
7334 swap_div(bmap, i - n_known, i);
7335 bmap->n_div -= n_known;
7336 bmap->extra -= n_known;
7337 }
7338 bmap = isl_basic_map_reset_space(bmap, dim);
7339 bset = bset_from_bmap(bmap);
7340
7341 set = parameter_compute_divs(bset);
7342 map = set_to_map(set);
7343 map = replace_space_by_local_space(map, ls);
7344
7345 return map;
7346error:
7347 isl_basic_map_free(bmap);
7348 return NULL((void*)0);
7349}
7350
7351/* Remove the explicit representation of local variable "div",
7352 * if there is any.
7353 */
7354__isl_give isl_basic_map *isl_basic_map_mark_div_unknown(
7355 __isl_take isl_basic_map *bmap, int div)
7356{
7357 isl_bool unknown;
7358
7359 unknown = isl_basic_map_div_is_marked_unknown(bmap, div);
7360 if (unknown < 0)
7361 return isl_basic_map_free(bmap);
7362 if (unknown)
7363 return bmap;
7364
7365 bmap = isl_basic_map_cow(bmap);
7366 if (!bmap)
7367 return NULL((void*)0);
7368 isl_int_set_si(bmap->div[div][0], 0)isl_sioimath_set_si((bmap->div[div][0]), 0);
7369 return bmap;
7370}
7371
7372/* Is local variable "div" of "bmap" marked as not having an explicit
7373 * representation?
7374 * Note that even if "div" is not marked in this way and therefore
7375 * has an explicit representation, this representation may still
7376 * depend (indirectly) on other local variables that do not
7377 * have an explicit representation.
7378 */
7379isl_bool isl_basic_map_div_is_marked_unknown(__isl_keep isl_basic_map *bmap,
7380 int div)
7381{
7382 if (isl_basic_map_check_range(bmap, isl_dim_div, div, 1) < 0)
7383 return isl_bool_error;
7384 return isl_int_is_zero(bmap->div[div][0])(isl_sioimath_sgn(*(bmap->div[div][0])) == 0);
7385}
7386
7387/* Return the position of the first local variable that does not
7388 * have an explicit representation.
7389 * Return the total number of local variables if they all have
7390 * an explicit representation.
7391 * Return -1 on error.
7392 */
7393int isl_basic_map_first_unknown_div(__isl_keep isl_basic_map *bmap)
7394{
7395 int i;
7396
7397 if (!bmap)
7398 return -1;
7399
7400 for (i = 0; i < bmap->n_div; ++i) {
7401 if (!isl_basic_map_div_is_known(bmap, i))
7402 return i;
7403 }
7404 return bmap->n_div;
7405}
7406
7407/* Return the position of the first local variable that does not
7408 * have an explicit representation.
7409 * Return the total number of local variables if they all have
7410 * an explicit representation.
7411 * Return -1 on error.
7412 */
7413int isl_basic_set_first_unknown_div(__isl_keep isl_basic_setisl_basic_map *bset)
7414{
7415 return isl_basic_map_first_unknown_div(bset);
7416}
7417
7418/* Does "bmap" have an explicit representation for all local variables?
7419 */
7420isl_bool isl_basic_map_divs_known(__isl_keep isl_basic_map *bmap)
7421{
7422 int first, n;
7423
7424 n = isl_basic_map_dim(bmap, isl_dim_div);
7425 first = isl_basic_map_first_unknown_div(bmap);
7426 if (first < 0)
7427 return isl_bool_error;
7428 return first == n;
7429}
7430
7431/* Do all basic maps in "map" have an explicit representation
7432 * for all local variables?
7433 */
7434isl_bool isl_map_divs_known(__isl_keep isl_map *map)
7435{
7436 int i;
7437
7438 if (!map)
7439 return isl_bool_error;
7440
7441 for (i = 0; i < map->n; ++i) {
7442 int known = isl_basic_map_divs_known(map->p[i]);
7443 if (known <= 0)
7444 return known;
7445 }
7446
7447 return isl_bool_true;
7448}
7449
7450/* If bmap contains any unknown divs, then compute explicit
7451 * expressions for them. However, this computation may be
7452 * quite expensive, so first try to remove divs that aren't
7453 * strictly needed.
7454 */
7455__isl_give isl_map *isl_basic_map_compute_divs(__isl_take isl_basic_map *bmap)
7456{
7457 int known;
7458 struct isl_map *map;
7459
7460 known = isl_basic_map_divs_known(bmap);
7461 if (known < 0)
7462 goto error;
7463 if (known)
7464 return isl_map_from_basic_map(bmap);
7465
7466 bmap = isl_basic_map_drop_redundant_divs(bmap);
7467
7468 known = isl_basic_map_divs_known(bmap);
7469 if (known < 0)
7470 goto error;
7471 if (known)
7472 return isl_map_from_basic_map(bmap);
7473
7474 map = compute_divs(bmap);
7475 return map;
7476error:
7477 isl_basic_map_free(bmap);
7478 return NULL((void*)0);
7479}
7480
7481__isl_give isl_map *isl_map_compute_divs(__isl_take isl_map *map)
7482{
7483 int i;
7484 int known;
7485 struct isl_map *res;
7486
7487 if (!map)
7488 return NULL((void*)0);
7489 if (map->n == 0)
7490 return map;
7491
7492 known = isl_map_divs_known(map);
7493 if (known < 0) {
7494 isl_map_free(map);
7495 return NULL((void*)0);
7496 }
7497 if (known)
7498 return map;
7499
7500 res = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[0]));
7501 for (i = 1 ; i < map->n; ++i) {
7502 struct isl_map *r2;
7503 r2 = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[i]));
7504 if (ISL_F_ISSET(map, ISL_MAP_DISJOINT)(!!(((map)->flags) & ((1 << 0)))))
7505 res = isl_map_union_disjoint(res, r2);
7506 else
7507 res = isl_map_union(res, r2);
7508 }
7509 isl_map_free(map);
7510
7511 return res;
7512}
7513
7514struct isl_setisl_map *isl_basic_set_compute_divs(struct isl_basic_setisl_basic_map *bset)
7515{
7516 return set_from_map(isl_basic_map_compute_divs(bset_to_bmap(bset)));
7517}
7518
7519struct isl_setisl_map *isl_set_compute_divs(struct isl_setisl_map *set)
7520{
7521 return set_from_map(isl_map_compute_divs(set_to_map(set)));
7522}
7523
7524__isl_give isl_setisl_map *isl_map_domain(__isl_take isl_map *map)
7525{
7526 int i;
7527 struct isl_setisl_map *set;
7528
7529 if (!map)
7530 goto error;
7531
7532 map = isl_map_cow(map);
7533 if (!map)
7534 return NULL((void*)0);
7535
7536 set = set_from_map(map);
7537 set->dim = isl_space_domain(set->dim);
7538 if (!set->dim)
7539 goto error;
7540 for (i = 0; i < map->n; ++i) {
7541 set->p[i] = isl_basic_map_domain(map->p[i]);
7542 if (!set->p[i])
7543 goto error;
7544 }
7545 ISL_F_CLR(set, ISL_MAP_DISJOINT)(((set)->flags) &= ~((1 << 0)));
7546 ISL_F_CLR(set, ISL_SET_NORMALIZED)(((set)->flags) &= ~((1 << 1)));
7547 return set;
7548error:
7549 isl_map_free(map);
7550 return NULL((void*)0);
7551}
7552
7553/* Return the union of "map1" and "map2", where we assume for now that
7554 * "map1" and "map2" are disjoint. Note that the basic maps inside
7555 * "map1" or "map2" may not be disjoint from each other.
7556 * Also note that this function is also called from isl_map_union,
7557 * which takes care of handling the situation where "map1" and "map2"
7558 * may not be disjoint.
7559 *
7560 * If one of the inputs is empty, we can simply return the other input.
7561 * Similarly, if one of the inputs is universal, then it is equal to the union.
7562 */
7563static __isl_give isl_map *map_union_disjoint(__isl_take isl_map *map1,
7564 __isl_take isl_map *map2)
7565{
7566 int i;
7567 unsigned flags = 0;
7568 struct isl_map *map = NULL((void*)0);
7569 int is_universe;
7570
7571 if (!map1 || !map2)
7572 goto error;
7573
7574 if (!isl_space_is_equal(map1->dim, map2->dim))
7575 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 7576); goto error; } while (0)
7576 "spaces don't match", goto error)do { isl_handle_error(isl_map_get_ctx(map1), isl_error_invalid
, "spaces don't match", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 7576); goto error; } while (0)
;
7577
7578 if (map1->n == 0) {
7579 isl_map_free(map1);
7580 return map2;
7581 }
7582 if (map2->n == 0) {
7583 isl_map_free(map2);
7584 return map1;
7585 }
7586
7587 is_universe = isl_map_plain_is_universe(map1);
7588 if (is_universe < 0)
7589 goto error;
7590 if (is_universe) {
7591 isl_map_free(map2);
7592 return map1;
7593 }
7594
7595 is_universe = isl_map_plain_is_universe(map2);
7596 if (is_universe < 0)
7597 goto error;
7598 if (is_universe) {
7599 isl_map_free(map1);
7600 return map2;
7601 }
7602
7603 if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT)(!!(((map1)->flags) & ((1 << 0)))) &&
7604 ISL_F_ISSET(map2, ISL_MAP_DISJOINT)(!!(((map2)->flags) & ((1 << 0)))))
7605 ISL_FL_SET(flags, ISL_MAP_DISJOINT)((flags) |= ((1 << 0)));
7606
7607 map = isl_map_alloc_space(isl_space_copy(map1->dim),
7608 map1->n + map2->n, flags);
7609 if (!map)
7610 goto error;
7611 for (i = 0; i < map1->n; ++i) {
7612 map = isl_map_add_basic_map(map,
7613 isl_basic_map_copy(map1->p[i]));
7614 if (!map)
7615 goto error;
7616 }
7617 for (i = 0; i < map2->n; ++i) {
7618 map = isl_map_add_basic_map(map,
7619 isl_basic_map_copy(map2->p[i]));
7620 if (!map)
7621 goto error;
7622 }
7623 isl_map_free(map1);
7624 isl_map_free(map2);
7625 return map;
7626error:
7627 isl_map_free(map);
7628 isl_map_free(map1);
7629 isl_map_free(map2);
7630 return NULL((void*)0);
7631}
7632
7633/* Return the union of "map1" and "map2", where "map1" and "map2" are
7634 * guaranteed to be disjoint by the caller.
7635 *
7636 * Note that this functions is called from within isl_map_make_disjoint,
7637 * so we have to be careful not to touch the constraints of the inputs
7638 * in any way.
7639 */
7640__isl_give isl_map *isl_map_union_disjoint(__isl_take isl_map *map1,
7641 __isl_take isl_map *map2)
7642{
7643 return isl_map_align_params_map_map_and(map1, map2, &map_union_disjoint);
7644}
7645
7646/* Return the union of "map1" and "map2", where "map1" and "map2" may
7647 * not be disjoint. The parameters are assumed to have been aligned.
7648 *
7649 * We currently simply call map_union_disjoint, the internal operation
7650 * of which does not really depend on the inputs being disjoint.
7651 * If the result contains more than one basic map, then we clear
7652 * the disjoint flag since the result may contain basic maps from
7653 * both inputs and these are not guaranteed to be disjoint.
7654 *
7655 * As a special case, if "map1" and "map2" are obviously equal,
7656 * then we simply return "map1".
7657 */
7658static __isl_give isl_map *map_union_aligned(__isl_take isl_map *map1,
7659 __isl_take isl_map *map2)
7660{
7661 int equal;
7662
7663 if (!map1 || !map2)
7664 goto error;
7665
7666 equal = isl_map_plain_is_equal(map1, map2);
7667 if (equal < 0)
7668 goto error;
7669 if (equal) {
7670 isl_map_free(map2);
7671 return map1;
7672 }
7673
7674 map1 = map_union_disjoint(map1, map2);
7675 if (!map1)
7676 return NULL((void*)0);
7677 if (map1->n > 1)
7678 ISL_F_CLR(map1, ISL_MAP_DISJOINT)(((map1)->flags) &= ~((1 << 0)));
7679 return map1;
7680error:
7681 isl_map_free(map1);
7682 isl_map_free(map2);
7683 return NULL((void*)0);
7684}
7685
7686/* Return the union of "map1" and "map2", where "map1" and "map2" may
7687 * not be disjoint.
7688 */
7689__isl_give isl_map *isl_map_union(__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_aligned);
7693}
7694
7695struct isl_setisl_map *isl_set_union_disjoint(
7696 struct isl_setisl_map *set1, struct isl_setisl_map *set2)
7697{
7698 return set_from_map(isl_map_union_disjoint(set_to_map(set1),
7699 set_to_map(set2)));
7700}
7701
7702struct isl_setisl_map *isl_set_union(struct isl_setisl_map *set1, struct isl_setisl_map *set2)
7703{
7704 return set_from_map(isl_map_union(set_to_map(set1), set_to_map(set2)));
7705}
7706
7707/* Apply "fn" to pairs of elements from "map" and "set" and collect
7708 * the results.
7709 *
7710 * "map" and "set" are assumed to be compatible and non-NULL.
7711 */
7712static __isl_give isl_map *map_intersect_set(__isl_take isl_map *map,
7713 __isl_take isl_setisl_map *set,
7714 __isl_give isl_basic_map *fn(__isl_take isl_basic_map *bmap,
7715 __isl_take isl_basic_setisl_basic_map *bset))
7716{
7717 unsigned flags = 0;
7718 struct isl_map *result;
7719 int i, j;
7720
7721 if (isl_set_plain_is_universe(set)) {
7722 isl_set_free(set);
7723 return map;
7724 }
7725
7726 if (ISL_F_ISSET(map, ISL_MAP_DISJOINT)(!!(((map)->flags) & ((1 << 0)))) &&
7727 ISL_F_ISSET(set, ISL_MAP_DISJOINT)(!!(((set)->flags) & ((1 << 0)))))
7728 ISL_FL_SET(flags, ISL_MAP_DISJOINT)((flags) |= ((1 << 0)));
7729
7730 result = isl_map_alloc_space(isl_space_copy(map->dim),
7731 map->n * set->n, flags);
7732 for (i = 0; result && i < map->n; ++i)
7733 for (j = 0; j < set->n; ++j) {
7734 result = isl_map_add_basic_map(result,
7735 fn(isl_basic_map_copy(map->p[i]),
7736 isl_basic_set_copy(set->p[j])));
7737 if (!result)
7738 break;
7739 }
7740
7741 isl_map_free(map);
7742 isl_set_free(set);
7743 return result;
7744}
7745
7746static __isl_give isl_map *map_intersect_range(__isl_take isl_map *map,
7747 __isl_take isl_setisl_map *set)
7748{
7749 isl_bool ok;
7750
7751 ok = isl_map_compatible_range(map, set);
7752 if (ok < 0)
7753 goto error;
7754 if (!ok)
7755 isl_die(set->ctx, isl_error_invalid,do { isl_handle_error(set->ctx, isl_error_invalid, "incompatible spaces"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 7756); goto error; } while (0)
7756 "incompatible spaces", goto error)do { isl_handle_error(set->ctx, isl_error_invalid, "incompatible spaces"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 7756); goto error; } while (0)
;
7757
7758 return map_intersect_set(map, set, &isl_basic_map_intersect_range);
7759error:
7760 isl_map_free(map);
7761 isl_set_free(set);
7762 return NULL((void*)0);
7763}
7764
7765__isl_give isl_map *isl_map_intersect_range(__isl_take isl_map *map,
7766 __isl_take isl_setisl_map *set)
7767{
7768 return isl_map_align_params_map_map_and(map, set, &map_intersect_range);
7769}
7770
7771static __isl_give isl_map *map_intersect_domain(__isl_take isl_map *map,
7772 __isl_take isl_setisl_map *set)
7773{
7774 isl_bool ok;
7775
7776 ok = isl_map_compatible_domain(map, set);
7777 if (ok < 0)
7778 goto error;
7779 if (!ok)
7780 isl_die(set->ctx, isl_error_invalid,do { isl_handle_error(set->ctx, isl_error_invalid, "incompatible spaces"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 7781); goto error; } while (0)
7781 "incompatible spaces", goto error)do { isl_handle_error(set->ctx, isl_error_invalid, "incompatible spaces"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 7781); goto error; } while (0)
;
7782
7783 return map_intersect_set(map, set, &isl_basic_map_intersect_domain);
7784error:
7785 isl_map_free(map);
7786 isl_set_free(set);
7787 return NULL((void*)0);
7788}
7789
7790__isl_give isl_map *isl_map_intersect_domain(__isl_take isl_map *map,
7791 __isl_take isl_setisl_map *set)
7792{
7793 return isl_map_align_params_map_map_and(map, set,
7794 &map_intersect_domain);
7795}
7796
7797static __isl_give isl_map *map_apply_domain(__isl_take isl_map *map1,
7798 __isl_take isl_map *map2)
7799{
7800 if (!map1 || !map2)
7801 goto error;
7802 map1 = isl_map_reverse(map1);
7803 map1 = isl_map_apply_range(map1, map2);
7804 return isl_map_reverse(map1);
7805error:
7806 isl_map_free(map1);
7807 isl_map_free(map2);
7808 return NULL((void*)0);
7809}
7810
7811__isl_give isl_map *isl_map_apply_domain(__isl_take isl_map *map1,
7812 __isl_take isl_map *map2)
7813{
7814 return isl_map_align_params_map_map_and(map1, map2, &map_apply_domain);
7815}
7816
7817static __isl_give isl_map *map_apply_range(__isl_take isl_map *map1,
7818 __isl_take isl_map *map2)
7819{
7820 isl_space *dim_result;
7821 struct isl_map *result;
7822 int i, j;
7823
7824 if (!map1 || !map2)
7825 goto error;
7826
7827 dim_result = isl_space_join(isl_space_copy(map1->dim),
7828 isl_space_copy(map2->dim));
7829
7830 result = isl_map_alloc_space(dim_result, map1->n * map2->n, 0);
7831 if (!result)
7832 goto error;
7833 for (i = 0; i < map1->n; ++i)
7834 for (j = 0; j < map2->n; ++j) {
7835 result = isl_map_add_basic_map(result,
7836 isl_basic_map_apply_range(
7837 isl_basic_map_copy(map1->p[i]),
7838 isl_basic_map_copy(map2->p[j])));
7839 if (!result)
7840 goto error;
7841 }
7842 isl_map_free(map1);
7843 isl_map_free(map2);
7844 if (result && result->n <= 1)
7845 ISL_F_SET(result, ISL_MAP_DISJOINT)(((result)->flags) |= ((1 << 0)));
7846 return result;
7847error:
7848 isl_map_free(map1);
7849 isl_map_free(map2);
7850 return NULL((void*)0);
7851}
7852
7853__isl_give isl_map *isl_map_apply_range(__isl_take isl_map *map1,
7854 __isl_take isl_map *map2)
7855{
7856 return isl_map_align_params_map_map_and(map1, map2, &map_apply_range);
7857}
7858
7859/*
7860 * returns range - domain
7861 */
7862__isl_give isl_basic_setisl_basic_map *isl_basic_map_deltas(__isl_take isl_basic_map *bmap)
7863{
7864 isl_space *target_space;
7865 struct isl_basic_setisl_basic_map *bset;
7866 unsigned dim;
7867 unsigned nparam;
7868 int i;
7869
7870 if (!bmap)
7871 goto error;
7872 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 7874); goto error; } while (0); } while (0)
7873 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 7874); goto error; } while (0); } while (0)
7874 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 7874); goto error; } while (0); } while (0)
;
7875 target_space = isl_space_domain(isl_basic_map_get_space(bmap));
7876 dim = isl_basic_map_dim(bmap, isl_dim_in);
7877 nparam = isl_basic_map_dim(bmap, isl_dim_param);
7878 bmap = isl_basic_map_from_range(isl_basic_map_wrap(bmap));
7879 bmap = isl_basic_map_add_dims(bmap, isl_dim_in, dim);
7880 bmap = isl_basic_map_extend_constraints(bmap, dim, 0);
7881 for (i = 0; i < dim; ++i) {
7882 int j = isl_basic_map_alloc_equality(bmap);
7883 if (j < 0) {
7884 bmap = isl_basic_map_free(bmap);
7885 break;
7886 }
7887 isl_seq_clr(bmap->eq[j], 1 + isl_basic_map_total_dim(bmap));
7888 isl_int_set_si(bmap->eq[j][1+nparam+i], 1)isl_sioimath_set_si((bmap->eq[j][1+nparam+i]), 1);
7889 isl_int_set_si(bmap->eq[j][1+nparam+dim+i], 1)isl_sioimath_set_si((bmap->eq[j][1+nparam+dim+i]), 1);
7890 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);
7891 }
7892 bset = isl_basic_map_domain(bmap);
7893 bset = isl_basic_set_reset_space(bset, target_space);
7894 return bset;
7895error:
7896 isl_basic_map_free(bmap);
7897 return NULL((void*)0);
7898}
7899
7900/*
7901 * returns range - domain
7902 */
7903__isl_give isl_setisl_map *isl_map_deltas(__isl_take isl_map *map)
7904{
7905 int i;
7906 isl_space *dim;
7907 struct isl_setisl_map *result;
7908
7909 if (!map)
7910 return NULL((void*)0);
7911
7912 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 7914); goto error; } while (0); } while (0)
7913 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 7914); goto error; } while (0); } while (0)
7914 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 7914); goto error; } while (0); } while (0)
;
7915 dim = isl_map_get_space(map);
7916 dim = isl_space_domain(dim);
7917 result = isl_set_alloc_space(dim, map->n, 0);
7918 if (!result)
7919 goto error;
7920 for (i = 0; i < map->n; ++i)
7921 result = isl_set_add_basic_set(result,
7922 isl_basic_map_deltas(isl_basic_map_copy(map->p[i])));
7923 isl_map_free(map);
7924 return result;
7925error:
7926 isl_map_free(map);
7927 return NULL((void*)0);
7928}
7929
7930/*
7931 * returns [domain -> range] -> range - domain
7932 */
7933__isl_give isl_basic_map *isl_basic_map_deltas_map(
7934 __isl_take isl_basic_map *bmap)
7935{
7936 int i, k;
7937 isl_space *dim;
7938 isl_basic_map *domain;
7939 int nparam, n;
7940 unsigned total;
7941
7942 if (!isl_space_tuple_is_equal(bmap->dim, isl_dim_in,
7943 bmap->dim, isl_dim_out))
7944 isl_die(bmap->ctx, isl_error_invalid,do { isl_handle_error(bmap->ctx, isl_error_invalid, "domain and range don't match"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 7945); goto error; } while (0)
7945 "domain and range don't match", goto error)do { isl_handle_error(bmap->ctx, isl_error_invalid, "domain and range don't match"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 7945); goto error; } while (0)
;
7946
7947 nparam = isl_basic_map_dim(bmap, isl_dim_param);
7948 n = isl_basic_map_dim(bmap, isl_dim_in);
7949
7950 dim = isl_space_from_range(isl_space_domain(isl_basic_map_get_space(bmap)));
7951 domain = isl_basic_map_universe(dim);
7952
7953 bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
7954 bmap = isl_basic_map_apply_range(bmap, domain);
7955 bmap = isl_basic_map_extend_constraints(bmap, n, 0);
7956
7957 total = isl_basic_map_total_dim(bmap);
7958
7959 for (i = 0; i < n; ++i) {
7960 k = isl_basic_map_alloc_equality(bmap);
7961 if (k < 0)
7962 goto error;
7963 isl_seq_clr(bmap->eq[k], 1 + total);
7964 isl_int_set_si(bmap->eq[k][1 + nparam + i], 1)isl_sioimath_set_si((bmap->eq[k][1 + nparam + i]), 1);
7965 isl_int_set_si(bmap->eq[k][1 + nparam + n + i], -1)isl_sioimath_set_si((bmap->eq[k][1 + nparam + n + i]), -1);
7966 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)
;
7967 }
7968
7969 bmap = isl_basic_map_gauss(bmap, NULL((void*)0));
7970 return isl_basic_map_finalize(bmap);
7971error:
7972 isl_basic_map_free(bmap);
7973 return NULL((void*)0);
7974}
7975
7976/*
7977 * returns [domain -> range] -> range - domain
7978 */
7979__isl_give isl_map *isl_map_deltas_map(__isl_take isl_map *map)
7980{
7981 int i;
7982 isl_space *domain_dim;
7983
7984 if (!map)
7985 return NULL((void*)0);
7986
7987 if (!isl_space_tuple_is_equal(map->dim, isl_dim_in,
7988 map->dim, isl_dim_out))
7989 isl_die(map->ctx, isl_error_invalid,do { isl_handle_error(map->ctx, isl_error_invalid, "domain and range don't match"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 7990); goto error; } while (0)
7990 "domain and range don't match", goto error)do { isl_handle_error(map->ctx, isl_error_invalid, "domain and range don't match"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 7990); goto error; } while (0)
;
7991
7992 map = isl_map_cow(map);
7993 if (!map)
7994 return NULL((void*)0);
7995
7996 domain_dim = isl_space_from_range(isl_space_domain(isl_map_get_space(map)));
7997 map->dim = isl_space_from_domain(isl_space_wrap(map->dim));
7998 map->dim = isl_space_join(map->dim, domain_dim);
7999 if (!map->dim)
8000 goto error;
8001 for (i = 0; i < map->n; ++i) {
8002 map->p[i] = isl_basic_map_deltas_map(map->p[i]);
8003 if (!map->p[i])
8004 goto error;
8005 }
8006 ISL_F_CLR(map, ISL_MAP_NORMALIZED)(((map)->flags) &= ~((1 << 1)));
8007 return map;
8008error:
8009 isl_map_free(map);
8010 return NULL((void*)0);
8011}
8012
8013static __isl_give isl_basic_map *basic_map_identity(__isl_take isl_space *dims)
8014{
8015 struct isl_basic_map *bmap;
8016 unsigned nparam;
8017 unsigned dim;
8018 int i;
8019
8020 if (!dims)
8021 return NULL((void*)0);
8022
8023 nparam = dims->nparam;
8024 dim = dims->n_out;
8025 bmap = isl_basic_map_alloc_space(dims, 0, dim, 0);
8026 if (!bmap)
8027 goto error;
8028
8029 for (i = 0; i < dim; ++i) {
8030 int j = isl_basic_map_alloc_equality(bmap);
8031 if (j < 0)
8032 goto error;
8033 isl_seq_clr(bmap->eq[j], 1 + isl_basic_map_total_dim(bmap));
8034 isl_int_set_si(bmap->eq[j][1+nparam+i], 1)isl_sioimath_set_si((bmap->eq[j][1+nparam+i]), 1);
8035 isl_int_set_si(bmap->eq[j][1+nparam+dim+i], -1)isl_sioimath_set_si((bmap->eq[j][1+nparam+dim+i]), -1);
8036 }
8037 return isl_basic_map_finalize(bmap);
8038error:
8039 isl_basic_map_free(bmap);
8040 return NULL((void*)0);
8041}
8042
8043__isl_give isl_basic_map *isl_basic_map_identity(__isl_take isl_space *dim)
8044{
8045 if (!dim)
8046 return NULL((void*)0);
8047 if (dim->n_in != dim->n_out)
8048 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 8050); goto error; } while (0)
8049 "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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 8050); goto error; } while (0)
8050 "the same", goto error)do { isl_handle_error(dim->ctx, isl_error_invalid, "number of input and output dimensions needs to be "
"the same", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 8050); goto error; } while (0)
;
8051 return basic_map_identity(dim);
8052error:
8053 isl_space_free(dim);
8054 return NULL((void*)0);
8055}
8056
8057__isl_give isl_map *isl_map_identity(__isl_take isl_space *dim)
8058{
8059 return isl_map_from_basic_map(isl_basic_map_identity(dim));
8060}
8061
8062__isl_give isl_map *isl_set_identity(__isl_take isl_setisl_map *set)
8063{
8064 isl_space *dim = isl_set_get_space(set);
8065 isl_map *id;
8066 id = isl_map_identity(isl_space_map_from_set(dim));
8067 return isl_map_intersect_range(id, set);
8068}
8069
8070/* Construct a basic set with all set dimensions having only non-negative
8071 * values.
8072 */
8073__isl_give isl_basic_setisl_basic_map *isl_basic_set_positive_orthant(
8074 __isl_take isl_space *space)
8075{
8076 int i;
8077 unsigned nparam;
8078 unsigned dim;
8079 struct isl_basic_setisl_basic_map *bset;
8080
8081 if (!space)
8082 return NULL((void*)0);
8083 nparam = space->nparam;
8084 dim = space->n_out;
8085 bset = isl_basic_set_alloc_space(space, 0, 0, dim);
8086 if (!bset)
8087 return NULL((void*)0);
8088 for (i = 0; i < dim; ++i) {
8089 int k = isl_basic_set_alloc_inequality(bset);
8090 if (k < 0)
8091 goto error;
8092 isl_seq_clr(bset->ineq[k], 1 + isl_basic_set_total_dim(bset));
8093 isl_int_set_si(bset->ineq[k][1 + nparam + i], 1)isl_sioimath_set_si((bset->ineq[k][1 + nparam + i]), 1);
8094 }
8095 return bset;
8096error:
8097 isl_basic_set_free(bset);
8098 return NULL((void*)0);
8099}
8100
8101/* Construct the half-space x_pos >= 0.
8102 */
8103static __isl_give isl_basic_setisl_basic_map *nonneg_halfspace(__isl_take isl_space *dim,
8104 int pos)
8105{
8106 int k;
8107 isl_basic_setisl_basic_map *nonneg;
8108
8109 nonneg = isl_basic_set_alloc_space(dim, 0, 0, 1);
8110 k = isl_basic_set_alloc_inequality(nonneg);
8111 if (k < 0)
8112 goto error;
8113 isl_seq_clr(nonneg->ineq[k], 1 + isl_basic_set_total_dim(nonneg));
8114 isl_int_set_si(nonneg->ineq[k][pos], 1)isl_sioimath_set_si((nonneg->ineq[k][pos]), 1);
8115
8116 return isl_basic_set_finalize(nonneg);
8117error:
8118 isl_basic_set_free(nonneg);
8119 return NULL((void*)0);
8120}
8121
8122/* Construct the half-space x_pos <= -1.
8123 */
8124static __isl_give isl_basic_setisl_basic_map *neg_halfspace(__isl_take isl_space *dim, int pos)
8125{
8126 int k;
8127 isl_basic_setisl_basic_map *neg;
8128
8129 neg = isl_basic_set_alloc_space(dim, 0, 0, 1);
8130 k = isl_basic_set_alloc_inequality(neg);
8131 if (k < 0)
8132 goto error;
8133 isl_seq_clr(neg->ineq[k], 1 + isl_basic_set_total_dim(neg));
8134 isl_int_set_si(neg->ineq[k][0], -1)isl_sioimath_set_si((neg->ineq[k][0]), -1);
8135 isl_int_set_si(neg->ineq[k][pos], -1)isl_sioimath_set_si((neg->ineq[k][pos]), -1);
8136
8137 return isl_basic_set_finalize(neg);
8138error:
8139 isl_basic_set_free(neg);
8140 return NULL((void*)0);
8141}
8142
8143__isl_give isl_setisl_map *isl_set_split_dims(__isl_take isl_setisl_map *set,
8144 enum isl_dim_type type, unsigned first, unsigned n)
8145{
8146 int i;
8147 unsigned offset;
8148 isl_basic_setisl_basic_map *nonneg;
8149 isl_basic_setisl_basic_map *neg;
8150
8151 if (!set)
8152 return NULL((void*)0);
8153 if (n == 0)
8154 return set;
8155
8156 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", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/polly/lib/External/isl/isl_map.c"
, 8156); goto error; } while (0); } while (0)
;
8157
8158 offset = pos(set->dim, type);
8159 for (i = 0; i < n; ++i) {
8160 nonneg = nonneg_halfspace(isl_set_get_space(set),
8161 offset + first + i);
8162 neg = neg_halfspace(isl_set_get_space(set), offset + first + i);
8163
8164 set = isl_set_intersect(set, isl_basic_set_union(nonneg, neg));
8165 }
8166
8167 return set;
8168error:
8169 isl_set_free(set);
8170 return NULL((void*)0);
8171}
8172
8173static isl_stat foreach_orthant(__isl_take isl_setisl_map *set, int *signs, int first,
8174 int len,
8175 isl_stat (*fn)(__isl_take isl_setisl_map *orthant, int *signs, void *user),
8176 void *user)
8177{
8178 isl_setisl_map *half;
8179
8180 if (!set)
8181 return isl_stat_error;
8182 if (isl_set_plain_is_empty(set)) {
8183 isl_set_free(set);
8184 return isl_stat_ok;
8185 }
8186 if (first == len)
8187 return fn(set, signs, user);
8188
8189 signs[first] = 1;
8190 half = isl_set_from_basic_set(nonneg_halfspace(isl_set_get_space(set),
8191 1 + first));
8192 half = isl_set_intersect(half, isl_set_copy(set));
8193 if (foreach_orthant(half, signs, first + 1, len, fn, user) < 0)
8194 goto error;
8195
8196 signs[first] = -1;
8197 half = isl_set_from_basic_set(neg_halfspace(isl_set_get_space(set),
8198 1 + first));
8199 half = isl_set_intersect(half, set);
8200 return foreach_orthant(half, signs, first + 1, len, fn, user);
8201error:
8202 isl_set_free(set);
8203 return isl_stat_error;
8204}
8205
8206/* Call "fn" on the intersections of "set" with each of the orthants
8207 * (except for obviously empty intersections). The orthant is identified
8208 * by the signs array, with each entry having value 1 or -1 according
8209 * to the sign of the corresponding variable.
8210 */
8211isl_stat isl_set_foreach_orthant(__isl_keep isl_setisl_map *set,
8212 isl_stat (*fn)(__isl_take isl_setisl_map *orthant, int *signs, void *user),
8213 void *user)
8214{
8215 unsigned nparam;
8216 unsigned nvar;
8217 int *signs;
8218 isl_stat r;
8219
8220 if (!set)
8221 return isl_stat_error;
8222 if (isl_set_plain_is_empty(set))
8223 return isl_stat_ok;
8224
8225 nparam = isl_set_dim(set, isl_dim_param);
8226 nvar = isl_set_dim(set, isl_dim_set);
8227
8228 signs = isl_alloc_array(set->ctx, int, nparam + nvar)((int *)isl_malloc_or_die(set->ctx, (nparam + nvar)*sizeof
(int)))
;
8229
8230 r = foreach_orthant(isl_set_copy(set), signs, 0, nparam + nvar,
8231 fn, user);
8232
8233 free(signs);
8234
8235 return r;
8236}
8237
8238isl_bool isl_set_is_equal(__isl_keep isl_setisl_map *set1, __isl_keep isl_setisl_map *set2)
8239{
8240 return isl_map_is_equal(set_to_map(set1), set_to_map(set2));
8241}
8242
8243isl_bool isl_basic_map_is_subset(__isl_keep isl_basic_map *bmap1,
8244 __isl_keep isl_basic_map *bmap2)
8245{
8246 int is_subset;
8247 struct isl_map *map1;
8248 struct isl_map *map2;
8249
8250 if (!bmap1 || !bmap2)
8251 return isl_bool_error;
8252
8253 map1 = isl_map_from_basic_map(isl_basic_map_copy(bmap1));
8254 map2 = isl_map_from_basic_map(isl_basic_map_copy(bmap2));
8255
8256 is_subset = isl_map_is_subset(map1, map2);
8257
8258 isl_map_free(map1);
8259 isl_map_free(map2);
8260
8261 return is_subset;
8262}
8263
8264isl_bool isl_basic_set_is_subset(__isl_keep isl_basic_setisl_basic_map *bset1,
8265 __isl_keep isl_basic_setisl_basic_map *bset2)
8266{
8267 return isl_basic_map_is_subset(bset1, bset2);
8268}
8269
8270isl_bool isl_basic_map_is_equal(__isl_keep isl_basic_map *bmap1,
8271 __isl_keep isl_basic_map *bmap2)
8272{
8273 isl_bool is_subset;
8274
8275 if (!bmap1 || !bmap2)
8276 return isl_bool_error;
8277 is_subset = isl_basic_map_is_subset(bmap1, bmap2);
8278 if (is_subset != isl_bool_true)
8279 return is_subset;
8280 is_subset = isl_basic_map_is_subset(bmap2, bmap1);
8281 return is_subset;
8282}
8283
8284isl_bool isl_basic_set_is_equal(__isl_keep isl_basic_setisl_basic_map *bset1,
8285 __isl_keep isl_basic_setisl_basic_map *bset2)
8286{
8287 return isl_basic_map_is_equal(
8288 bset_to_bmap(bset1), bset_to_bmap(bset2));
8289}
8290
8291isl_bool isl_map_is_empty(__isl_keep isl_map *map)
8292{
8293 int i;
8294 int is_empty;
8295
8296 if (!map)
8297 return isl_bool_error;
8298 for (i = 0; i < map->n; ++i) {
8299 is_empty = isl_basic_map_is_empty(map->p[i]);
8300 if (is_empty < 0)
8301 return isl_bool_error;
8302 if (!is_empty)
8303 return isl_bool_false;
8304 }
8305 return isl_bool_true;
8306}
8307
8308isl_bool isl_map_plain_is_empty(__isl_keep isl_map *map)
8309{
8310 return map ? map->n == 0 : isl_bool_error;
8311}
8312
8313isl_bool isl_set_plain_is_empty(__isl_keep isl_setisl_map *set)
8314{
8315 return set ? set->n == 0 : isl_bool_error;
8316}
8317
8318isl_bool isl_set_is_empty(__isl_keep isl_setisl_map *set)
8319{
8320 return isl_map_is_empty(set_to_map(set));
8321}
8322
8323isl_bool isl_map_has_equal_space(__isl_keep isl_map *map1,
8324 __isl_keep isl_map *map2)
8325{
8326 if (!map1 || !map2)
8327 return isl_bool_error;
8328
8329 return isl_space_is_equal(map1->dim, map2->dim);
8330}
8331
8332isl_bool isl_set_has_equal_space(__isl_keep isl_setisl_map *set1,
8333 __isl_keep isl_setisl_map *set2)
8334{
8335 if (!set1 || !set2)
8336 return isl_bool_error;
8337
8338 return isl_space_is_equal(set1->dim, set2->dim);
8339}
8340
8341static isl_bool map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
8342{
8343 isl_bool is_subset;
8344
8345 if (!map1 || !map2)
8346 return isl_bool_error;
8347 is_subset = isl_map_is_subset(map1, map2);
8348 if (is_subset != isl_bool_true)
8349 return is_subset;
8350 is_subset = isl_map_is_subset(map2, map1);
8351 return is_subset;
8352}
8353
8354/* Is "map1" equal to "map2"?
8355 *
8356 * First check if they are obviously equal.
8357 * If not, then perform a more detailed analysis.
8358 */
8359isl_bool isl_map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
8360{
8361 isl_bool equal;
8362
8363 equal = isl_map_plain_is_equal(map1, map2);
8364 if (equal < 0 || equal)
8365 return equal;
8366 return isl_map_align_params_map_map_and_test(map1, map2, &map_is_equal);
8367}
8368
8369isl_bool isl_basic_map_is_strict_subset(
8370 struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
8371{
8372 isl_bool is_subset;
8373
8374 if (!bmap1 || !bmap2)
8375 return isl_bool_error;
8376 is_subset = isl_basic_map_is_subset(bmap1, bmap2);
8377 if (is_subset != isl_bool_true)
8378 return is_subset;
8379 is_subset = isl_basic_map_is_subset(bmap2, bmap1);
8380 if (is_subset == isl_bool_error)
8381 return is_subset;
8382 return !is_subset;
8383}
8384
8385isl_bool isl_map_is_strict_subset(__isl_keep isl_map *map1,
8386 __isl_keep isl_map *map2)
8387{
8388 isl_bool is_subset;
8389
8390 if (!map1 || !map2)
8391 return isl_bool_error;
8392 is_subset = isl_map_is_subset(map1, map2);
8393 if (is_subset != isl_bool_true)
8394 return is_subset;
8395 is_subset = isl_map_is_subset(map2, map1);
8396 if (is_subset == isl_bool_error)
8397 return is_subset;
8398 return !is_subset;
8399}
8400
8401isl_bool isl_set_is_strict_subset(__isl_keep isl_setisl_map *set1,
8402 __isl_keep isl_setisl_map *set2)
8403{
8404 return isl_map_is_strict_subset(set_to_map(set1), set_to_map(set2));
8405}
8406
8407/* Is "bmap" obviously equal to the universe with the same space?
8408 *
8409 * That is, does it not have any constraints?
8410 */
8411isl_bool isl_basic_map_plain_is_universe(__isl_keep isl_basic_map *bmap)
8412{
8413 if (!bmap)
8414 return isl_bool_error;
8415 return bmap->n_eq == 0 && bmap->n_ineq == 0;
8416}
8417
8418/* Is "bset" obviously equal to the universe with the same space?
8419 */
8420isl_bool isl_basic_set_plain_is_universe(__isl_keep isl_basic_setisl_basic_map *bset)
8421{
8422 return isl_basic_map_plain_is_universe(bset);
8423}
8424
8425/* If "c" does not involve any existentially quantified variables,
8426 * then set *univ to false and abort
8427 */
8428static isl_stat involves_divs(__isl_take isl_constraint *c, void *user)
8429{
8430 isl_bool *univ = user;
8431 unsigned n;
8432
8433 n = isl_constraint_dim(c, isl_dim_div);
8434 *univ = isl_constraint_involves_dims(c, isl_dim_div, 0, n);
8435 isl_constraint_free(c);
8436 if (*univ < 0 || !*univ)
8437 return isl_stat_error;
8438 return isl_stat_ok;
8439}
8440
8441/* Is "bmap" equal to the universe with the same space?
8442 *
8443 * First check if it is obviously equal to the universe.
8444 * If not and if there are any constraints not involving
8445 * existentially quantified variables, then it is certainly
8446 * not equal to the universe.
8447 * Otherwise, check if the universe is a subset of "bmap".
8448 */
8449isl_bool isl_basic_map_is_universe(__isl_keep isl_basic_map *bmap)
8450{
8451 isl_bool univ;
8452 isl_basic_map *test;
8453
8454 univ = isl_basic_map_plain_is_universe(bmap);
8455 if (univ < 0 || univ)
8456 return univ;
8457 if (isl_basic_map_dim(bmap, isl_dim_div) == 0)
8458 return isl_bool_false;
8459 univ = isl_bool_true;
8460 if (isl_basic_map_foreach_constraint(bmap, &involves_divs, &univ) < 0 &&
8461 univ)
8462 return isl_bool_error;
8463 if (univ < 0 || !univ)
8464 return univ;
8465 test = isl_basic_map_universe(isl_basic_map_get_space(bmap));
8466 univ = isl_basic_map_is_subset(test, bmap);
8467 isl_basic_map_free(test);
8468 return univ;
8469}
8470
8471/* Is "bset" equal to the universe with the same space?
8472 */
8473isl_bool isl_basic_set_is_universe(__isl_keep isl_basic_setisl_basic_map *bset)
8474{
8475 return isl_basic_map_is_universe(bset);
8476}
8477
8478isl_bool isl_map_plain_is_universe(__isl_keep isl_map *map)
8479{
8480 int i;
8481
8482 if (!map)
8483 return isl_bool_error;
8484
8485 for (i = 0; i < map->n; ++i) {
8486 isl_bool r = isl_basic_map_plain_is_universe(map->p[i]);
8487 if (r < 0 || r)
8488 return r;
8489 }
8490
8491 return isl_bool_false;
8492}
8493
8494isl_bool isl_set_plain_is_universe(__isl_keep isl_setisl_map *set)
8495{
8496 return isl_map_plain_is_universe(set_to_map(set));
8497}
8498
8499isl_bool isl_basic_map_is_empty(__isl_keep isl_basic_map *bmap)
8500{
8501 struct isl_basic_setisl_basic_map *bset = NULL((void*)0);
8502 struct isl_vec *sample = NULL((void*)0);
8503 isl_bool empty, non_empty;
8504
8505 if (!bmap)
8506 return isl_bool_error;
8507
8508 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY)(!!(((bmap)->flags) & ((1 << 1)))))
8509 return isl_bool_true;
8510
8511 if (isl_basic_map_plain_is_universe(bmap))
8512 return isl_bool_false;
8513
8514 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)(!!(((bmap)->flags) & ((1 << 4))))) {
8515 struct isl_basic_map *copy = isl_basic_map_copy(bmap);
8516 copy = isl_basic_map_remove_redundancies(copy);
8517 empty = isl_basic_map_plain_is_empty(copy);
8518 isl_basic_map_free(copy);
8519 return empty;
8520 }
8521
8522 non_empty = isl_basic_map_plain_is_non_empty(bmap);
8523 if (non_empty < 0)
8524 return isl_bool_error;
8525 if (non_empty)
8526 return isl_bool_false;
8527 isl_vec_free(bmap->sample);
8528 bmap->sample = NULL((void*)0);
8529 bset = isl_basic_map_underlying_set(isl_basic_map_copy(bmap));
8530 if (!bset)
8531 return isl_bool_error;
8532 sample = isl_basic_set_sample_vec(bset);
8533 if (!sample)
8534 return isl_bool_error;
8535 empty = sample->size == 0;
8536 isl_vec_free(bmap->sample);
8537 bmap->sample = sample;
8538 if (empty)
8539 ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY)(((bmap)->flags) |= ((1 << 1)));
8540
8541 return empty;
8542}
8543
8544isl_bool isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap)
8545{
8546 if (!bmap)
8547 return isl_bool_error;
8548 return ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY)(!!(((bmap)->flags) & ((1 << 1))));
8549}
8550
8551isl_bool isl_basic_set_plain_is_empty(__isl_keep isl_basic_setisl_basic_map *bset)
8552{
8553 if (!bset)
8554 return isl_bool_error;
8555 return ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY)(!!(((bset)->flags) & ((1 << 1))));
8556}
8557
8558/* Is "bmap" known to be non-empty?<