Bug Summary

File:tools/polly/lib/External/isl/isl_map.c
Warning:line 7837, column 5
Use of memory after it is freed

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)
22
Assuming 'bmap' is non-null
23
Taking false branch
1258 return NULL((void*)0);
1259
1260 if (ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL)(!!(((bmap)->flags) & ((1 << 0))))) {
24
Taking true branch
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)
38
Taking false branch
1282 return NULL((void*)0);
1283
1284 if (--bmap->ref > 0)
39
Assuming the condition is false
40
Taking false branch
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);
41
Memory is released
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)
6
Taking false branch
1340 goto error;
1341 if (isl_map_has_equal_params(map1, map2))
7
Assuming the condition is false
8
Taking false branch
1342 return fn(map1, map2);
1343 if (isl_map_check_named_params(map1) < 0)
9
Assuming the condition is false
10
Taking false branch
1344 goto error;
1345 if (isl_map_check_named_params(map2) < 0)
11
Assuming the condition is false
12
Taking false branch
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);
13
Calling 'map_apply_range'
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)
35
Taking true branch
4416 goto error;
36
Control jumps to line 4453
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);
37
Calling 'isl_basic_map_free'
42
Returning; memory was released via 1st parameter
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)
14
Assuming 'map2' is non-null
15
Taking false branch
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)
16
Taking false branch
7832 goto error;
7833 for (i = 0; i < map1->n; ++i)
17
Assuming the condition is true
18
Loop condition is true. Entering loop body
7834 for (j = 0; j < map2->n; ++j) {
19
Assuming the condition is true
20
Loop condition is true. Entering loop body
28
Assuming the condition is true
29
Loop condition is true. Entering loop body
32
Assuming the condition is true
33
Loop condition is true. Entering loop body
46
Assuming the condition is true
47
Loop condition is true. Entering loop body
7835 result = isl_map_add_basic_map(result,
7836 isl_basic_map_apply_range(
34
Calling 'isl_basic_map_apply_range'
43
Returning; memory was released via 1st parameter
7837 isl_basic_map_copy(map1->p[i]),
21
Calling 'isl_basic_map_copy'
25
Returning from 'isl_basic_map_copy'
48
Use of memory after it is freed
7838 isl_basic_map_copy(map2->p[j])));
7839 if (!result)
26
Assuming 'result' is non-null
27
Taking false branch
30
Assuming 'result' is non-null
31
Taking false branch
44
Assuming 'result' is non-null
45
Taking false branch
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);
5
Calling 'isl_map_align_params_map_map_and'
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