nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /*
2 * Copyright 2010 INRIA Saclay
3 *
4 * Use of this software is governed by the GNU LGPLv2.1 license
5 *
6 * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
7 * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
8 * 91893 Orsay, France
9 */
10  
11 #define xFN(TYPE,NAME) TYPE ## _ ## NAME
12 #define FN(TYPE,NAME) xFN(TYPE,NAME)
13 #define xS(TYPE,NAME) struct TYPE ## _ ## NAME
14 #define S(TYPE,NAME) xS(TYPE,NAME)
15  
16 struct UNION {
17 int ref;
18 #ifdef HAS_TYPE
19 enum isl_fold type;
20 #endif
21 isl_space *dim;
22  
23 struct isl_hash_table table;
24 };
25  
26 __isl_give UNION *FN(UNION,cow)(__isl_take UNION *u);
27  
28 isl_ctx *FN(UNION,get_ctx)(__isl_keep UNION *u)
29 {
30 return u ? u->dim->ctx : NULL;
31 }
32  
33 __isl_give isl_space *FN(UNION,get_space)(__isl_keep UNION *u)
34 {
35 if (!u)
36 return NULL;
37 return isl_space_copy(u->dim);
38 }
39  
40 #ifdef HAS_TYPE
41 static __isl_give UNION *FN(UNION,alloc)(__isl_take isl_space *dim,
42 enum isl_fold type, int size)
43 #else
44 static __isl_give UNION *FN(UNION,alloc)(__isl_take isl_space *dim, int size)
45 #endif
46 {
47 UNION *u;
48  
49 dim = isl_space_params(dim);
50 if (!dim)
51 return NULL;
52  
53 u = isl_calloc_type(dim->ctx, UNION);
54 if (!u)
55 return NULL;
56  
57 u->ref = 1;
58 #ifdef HAS_TYPE
59 u->type = type;
60 #endif
61 u->dim = dim;
62 if (isl_hash_table_init(dim->ctx, &u->table, size) < 0)
63 goto error;
64  
65 return u;
66 error:
67 isl_space_free(dim);
68 FN(UNION,free)(u);
69 return NULL;
70 }
71  
72 #ifdef HAS_TYPE
73 __isl_give UNION *FN(UNION,ZERO)(__isl_take isl_space *dim, enum isl_fold type)
74 {
75 return FN(UNION,alloc)(dim, type, 16);
76 }
77 #else
78 __isl_give UNION *FN(UNION,ZERO)(__isl_take isl_space *dim)
79 {
80 return FN(UNION,alloc)(dim, 16);
81 }
82 #endif
83  
84 __isl_give UNION *FN(UNION,copy)(__isl_keep UNION *u)
85 {
86 if (!u)
87 return NULL;
88  
89 u->ref++;
90 return u;
91 }
92  
93 S(UNION,foreach_data)
94 {
95 int (*fn)(__isl_take PART *part, void *user);
96 void *user;
97 };
98  
99 static int call_on_copy(void **entry, void *user)
100 {
101 PART *part = *entry;
102 S(UNION,foreach_data) *data = (S(UNION,foreach_data) *)user;
103  
104 return data->fn(FN(PART,copy)(part), data->user);
105 }
106  
107 int FN(FN(UNION,foreach),PARTS)(__isl_keep UNION *u,
108 int (*fn)(__isl_take PART *part, void *user), void *user)
109 {
110 S(UNION,foreach_data) data = { fn, user };
111  
112 if (!u)
113 return -1;
114  
115 return isl_hash_table_foreach(u->dim->ctx, &u->table,
116 &call_on_copy, &data);
117 }
118  
119 static int has_dim(const void *entry, const void *val)
120 {
121 PART *part = (PART *)entry;
122 isl_space *dim = (isl_space *)val;
123  
124 return isl_space_is_equal(part->dim, dim);
125 }
126  
127 __isl_give PART *FN(FN(UNION,extract),PARTS)(__isl_keep UNION *u,
128 __isl_take isl_space *dim)
129 {
130 uint32_t hash;
131 struct isl_hash_table_entry *entry;
132  
133 if (!u || !dim)
134 goto error;
135  
136 hash = isl_space_get_hash(dim);
137 entry = isl_hash_table_find(u->dim->ctx, &u->table, hash,
138 &has_dim, dim, 0);
139 if (!entry)
140 #ifdef HAS_TYPE
141 return FN(PART,ZERO)(dim, u->type);
142 #else
143 return FN(PART,ZERO)(dim);
144 #endif
145 isl_space_free(dim);
146 return FN(PART,copy)(entry->data);
147 error:
148 isl_space_free(dim);
149 return NULL;
150 }
151  
152 __isl_give UNION *FN(FN(UNION,add),PARTS)(__isl_take UNION *u,
153 __isl_take PART *part)
154 {
155 uint32_t hash;
156 struct isl_hash_table_entry *entry;
157  
158 if (!part)
159 goto error;
160  
161 if (DEFAULT_IS_ZERO && FN(PART,IS_ZERO)(part)) {
162 FN(PART,free)(part);
163 return u;
164 }
165  
166 u = FN(UNION,cow)(u);
167  
168 if (!u)
169 goto error;
170  
171 isl_assert(u->dim->ctx, isl_space_match(part->dim, isl_dim_param, u->dim,
172 isl_dim_param), goto error);
173  
174 hash = isl_space_get_hash(part->dim);
175 entry = isl_hash_table_find(u->dim->ctx, &u->table, hash,
176 &has_dim, part->dim, 1);
177 if (!entry)
178 goto error;
179  
180 if (!entry->data)
181 entry->data = part;
182 else {
183 entry->data = FN(PART,add)(entry->data, FN(PART,copy)(part));
184 if (!entry->data)
185 goto error;
186 FN(PART,free)(part);
187 if (DEFAULT_IS_ZERO && FN(PART,IS_ZERO)(entry->data)) {
188 FN(PART,free)(entry->data);
189 isl_hash_table_remove(u->dim->ctx, &u->table, entry);
190 }
191 }
192  
193 return u;
194 error:
195 FN(PART,free)(part);
196 FN(UNION,free)(u);
197 return NULL;
198 }
199  
200 static int add_part(__isl_take PART *part, void *user)
201 {
202 UNION **u = (UNION **)user;
203  
204 *u = FN(FN(UNION,add),PARTS)(*u, part);
205  
206 return 0;
207 }
208  
209 __isl_give UNION *FN(UNION,dup)(__isl_keep UNION *u)
210 {
211 UNION *dup;
212  
213 if (!u)
214 return NULL;
215  
216 #ifdef HAS_TYPE
217 dup = FN(UNION,ZERO)(isl_space_copy(u->dim), u->type);
218 #else
219 dup = FN(UNION,ZERO)(isl_space_copy(u->dim));
220 #endif
221 if (FN(FN(UNION,foreach),PARTS)(u, &add_part, &dup) < 0)
222 goto error;
223 return dup;
224 error:
225 FN(UNION,free)(dup);
226 return NULL;
227 }
228  
229 __isl_give UNION *FN(UNION,cow)(__isl_take UNION *u)
230 {
231 if (!u)
232 return NULL;
233  
234 if (u->ref == 1)
235 return u;
236 u->ref--;
237 return FN(UNION,dup)(u);
238 }
239  
240 static int free_u_entry(void **entry, void *user)
241 {
242 PART *part = *entry;
243 FN(PART,free)(part);
244 return 0;
245 }
246  
247 void *FN(UNION,free)(__isl_take UNION *u)
248 {
249 if (!u)
250 return NULL;
251  
252 if (--u->ref > 0)
253 return NULL;
254  
255 isl_hash_table_foreach(u->dim->ctx, &u->table, &free_u_entry, NULL);
256 isl_hash_table_clear(&u->table);
257 isl_space_free(u->dim);
258 free(u);
259 return NULL;
260 }
261  
262 S(UNION,align) {
263 isl_reordering *exp;
264 UNION *res;
265 };
266  
267 #ifdef ALIGN_DOMAIN
268 static int align_entry(__isl_take PART *part, void *user)
269 {
270 isl_reordering *exp;
271 S(UNION,align) *data = user;
272  
273 exp = isl_reordering_extend_space(isl_reordering_copy(data->exp),
274 FN(PART,get_domain_space)(part));
275  
276 data->res = FN(FN(UNION,add),PARTS)(data->res,
277 FN(PART,realign_domain)(part, exp));
278  
279 return 0;
280 }
281 #else
282 static int align_entry(__isl_take PART *part, void *user)
283 {
284 isl_reordering *exp;
285 S(UNION,align) *data = user;
286  
287 exp = isl_reordering_extend_space(isl_reordering_copy(data->exp),
288 FN(PART,get_space)(part));
289  
290 data->res = FN(FN(UNION,add),PARTS)(data->res,
291 FN(PART,realign)(part, exp));
292  
293 return 0;
294 }
295 #endif
296  
297 __isl_give UNION *FN(UNION,align_params)(__isl_take UNION *u,
298 __isl_take isl_space *model)
299 {
300 S(UNION,align) data = { NULL, NULL };
301  
302 if (!u || !model)
303 goto error;
304  
305 if (isl_space_match(u->dim, isl_dim_param, model, isl_dim_param)) {
306 isl_space_free(model);
307 return u;
308 }
309  
310 data.exp = isl_parameter_alignment_reordering(u->dim, model);
311 if (!data.exp)
312 goto error;
313  
314 #ifdef HAS_TYPE
315 data.res = FN(UNION,alloc)(isl_space_copy(data.exp->dim),
316 u->type, u->table.n);
317 #else
318 data.res = FN(UNION,alloc)(isl_space_copy(data.exp->dim), u->table.n);
319 #endif
320 if (FN(FN(UNION,foreach),PARTS)(u, &align_entry, &data) < 0)
321 goto error;
322  
323 isl_reordering_free(data.exp);
324 FN(UNION,free)(u);
325 isl_space_free(model);
326 return data.res;
327 error:
328 isl_reordering_free(data.exp);
329 FN(UNION,free)(u);
330 FN(UNION,free)(data.res);
331 isl_space_free(model);
332 return NULL;
333 }
334  
335 __isl_give UNION *FN(UNION,add)(__isl_take UNION *u1, __isl_take UNION *u2)
336 {
337 u1 = FN(UNION,align_params)(u1, FN(UNION,get_space)(u2));
338 u2 = FN(UNION,align_params)(u2, FN(UNION,get_space)(u1));
339  
340 u1 = FN(UNION,cow)(u1);
341  
342 if (!u1 || !u2)
343 goto error;
344  
345 if (FN(FN(UNION,foreach),PARTS)(u2, &add_part, &u1) < 0)
346 goto error;
347  
348 FN(UNION,free)(u2);
349  
350 return u1;
351 error:
352 FN(UNION,free)(u1);
353 FN(UNION,free)(u2);
354 return NULL;
355 }
356  
357 __isl_give UNION *FN(FN(UNION,from),PARTS)(__isl_take PART *part)
358 {
359 isl_space *dim;
360 UNION *u;
361  
362 if (!part)
363 return NULL;
364  
365 dim = FN(PART,get_space)(part);
366 dim = isl_space_drop_dims(dim, isl_dim_in, 0, isl_space_dim(dim, isl_dim_in));
367 dim = isl_space_drop_dims(dim, isl_dim_out, 0, isl_space_dim(dim, isl_dim_out));
368 #ifdef HAS_TYPE
369 u = FN(UNION,ZERO)(dim, part->type);
370 #else
371 u = FN(UNION,ZERO)(dim);
372 #endif
373 u = FN(FN(UNION,add),PARTS)(u, part);
374  
375 return u;
376 }
377  
378 S(UNION,match_bin_data) {
379 UNION *u2;
380 UNION *res;
381 __isl_give PART *(*fn)(__isl_take PART *, __isl_take PART *);
382 };
383  
384 /* Check if data->u2 has an element living in the same space as *entry.
385 * If so, call data->fn on the two elements and add the result to
386 * data->res.
387 */
388 static int match_bin_entry(void **entry, void *user)
389 {
390 S(UNION,match_bin_data) *data = user;
391 uint32_t hash;
392 struct isl_hash_table_entry *entry2;
393 isl_space *space;
394 PART *part = *entry;
395  
396 space = FN(PART,get_space)(part);
397 hash = isl_space_get_hash(space);
398 entry2 = isl_hash_table_find(data->u2->dim->ctx, &data->u2->table,
399 hash, &has_dim, space, 0);
400 isl_space_free(space);
401 if (!entry2)
402 return 0;
403  
404 part = FN(PART, copy)(part);
405 part = data->fn(part, FN(PART, copy)(entry2->data));
406  
407 if (DEFAULT_IS_ZERO) {
408 int empty;
409  
410 empty = FN(PART,IS_ZERO)(part);
411 if (empty < 0) {
412 FN(PART,free)(part);
413 return -1;
414 }
415 if (empty) {
416 FN(PART,free)(part);
417 return 0;
418 }
419 }
420  
421 data->res = FN(FN(UNION,add),PARTS)(data->res, part);
422  
423 return 0;
424 }
425  
426 /* This function is currently only used from isl_polynomial.c
427 * and not from isl_fold.c.
428 */
429 static __isl_give UNION *match_bin_op(__isl_take UNION *u1,
430 __isl_take UNION *u2,
431 __isl_give PART *(*fn)(__isl_take PART *, __isl_take PART *))
432 __attribute__ ((unused));
433 /* For each pair of elements in "u1" and "u2" living in the same space,
434 * call "fn" and collect the results.
435 */
436 static __isl_give UNION *match_bin_op(__isl_take UNION *u1,
437 __isl_take UNION *u2,
438 __isl_give PART *(*fn)(__isl_take PART *, __isl_take PART *))
439 {
440 S(UNION,match_bin_data) data = { NULL, NULL, fn };
441  
442 u1 = FN(UNION,align_params)(u1, FN(UNION,get_space)(u2));
443 u2 = FN(UNION,align_params)(u2, FN(UNION,get_space)(u1));
444  
445 if (!u1 || !u2)
446 goto error;
447  
448 data.u2 = u2;
449 #ifdef HAS_TYPE
450 data.res = FN(UNION,alloc)(isl_space_copy(u1->dim), u1->type, u1->table.n);
451 #else
452 data.res = FN(UNION,alloc)(isl_space_copy(u1->dim), u1->table.n);
453 #endif
454 if (isl_hash_table_foreach(u1->dim->ctx, &u1->table,
455 &match_bin_entry, &data) < 0)
456 goto error;
457  
458 FN(UNION,free)(u1);
459 FN(UNION,free)(u2);
460 return data.res;
461 error:
462 FN(UNION,free)(u1);
463 FN(UNION,free)(u2);
464 FN(UNION,free)(data.res);
465 return NULL;
466 }
467  
468 S(UNION,any_set_data) {
469 isl_set *set;
470 UNION *res;
471 __isl_give PW *(*fn)(__isl_take PW*, __isl_take isl_set*);
472 };
473  
474 static int any_set_entry(void **entry, void *user)
475 {
476 S(UNION,any_set_data) *data = user;
477 PW *pw = *entry;
478  
479 pw = FN(PW,copy)(pw);
480 pw = data->fn(pw, isl_set_copy(data->set));
481  
482 if (DEFAULT_IS_ZERO) {
483 int empty;
484  
485 empty = FN(PW,IS_ZERO)(pw);
486 if (empty < 0) {
487 FN(PW,free)(pw);
488 return -1;
489 }
490 if (empty) {
491 FN(PW,free)(pw);
492 return 0;
493 }
494 }
495  
496 data->res = FN(FN(UNION,add),PARTS)(data->res, pw);
497  
498 return 0;
499 }
500  
501 /* Update each element of "u" by calling "fn" on the element and "set".
502 */
503 static __isl_give UNION *any_set_op(__isl_take UNION *u,
504 __isl_take isl_set *set,
505 __isl_give PW *(*fn)(__isl_take PW*, __isl_take isl_set*))
506 {
507 S(UNION,any_set_data) data = { NULL, NULL, fn };
508  
509 u = FN(UNION,align_params)(u, isl_set_get_space(set));
510 set = isl_set_align_params(set, FN(UNION,get_space)(u));
511  
512 if (!u || !set)
513 goto error;
514  
515 data.set = set;
516 #ifdef HAS_TYPE
517 data.res = FN(UNION,alloc)(isl_space_copy(u->dim), u->type, u->table.n);
518 #else
519 data.res = FN(UNION,alloc)(isl_space_copy(u->dim), u->table.n);
520 #endif
521 if (isl_hash_table_foreach(u->dim->ctx, &u->table,
522 &any_set_entry, &data) < 0)
523 goto error;
524  
525 FN(UNION,free)(u);
526 isl_set_free(set);
527 return data.res;
528 error:
529 FN(UNION,free)(u);
530 isl_set_free(set);
531 FN(UNION,free)(data.res);
532 return NULL;
533 }
534  
535 /* Intersect the domain of "u" with the parameter domain "context".
536 */
537 __isl_give UNION *FN(UNION,intersect_params)(__isl_take UNION *u,
538 __isl_take isl_set *set)
539 {
540 return any_set_op(u, set, &FN(PW,intersect_params));
541 }
542  
543 /* Compute the gist of the domain of "u" with respect to
544 * the parameter domain "context".
545 */
546 __isl_give UNION *FN(UNION,gist_params)(__isl_take UNION *u,
547 __isl_take isl_set *set)
548 {
549 return any_set_op(u, set, &FN(PW,gist_params));
550 }
551  
552 S(UNION,match_domain_data) {
553 isl_union_set *uset;
554 UNION *res;
555 __isl_give PW *(*fn)(__isl_take PW*, __isl_take isl_set*);
556 };
557  
558 static int set_has_dim(const void *entry, const void *val)
559 {
560 isl_set *set = (isl_set *)entry;
561 isl_space *dim = (isl_space *)val;
562  
563 return isl_space_is_equal(set->dim, dim);
564 }
565  
566 /* Find the set in data->uset that live in the same space as the domain
567 * of *entry, apply data->fn to *entry and this set (if any), and add
568 * the result to data->res.
569 */
570 static int match_domain_entry(void **entry, void *user)
571 {
572 S(UNION,match_domain_data) *data = user;
573 uint32_t hash;
574 struct isl_hash_table_entry *entry2;
575 PW *pw = *entry;
576 isl_space *space;
577  
578 space = FN(PW,get_domain_space)(pw);
579 hash = isl_space_get_hash(space);
580 entry2 = isl_hash_table_find(data->uset->dim->ctx, &data->uset->table,
581 hash, &set_has_dim, space, 0);
582 isl_space_free(space);
583 if (!entry2)
584 return 0;
585  
586 pw = FN(PW,copy)(pw);
587 pw = data->fn(pw, isl_set_copy(entry2->data));
588  
589 if (DEFAULT_IS_ZERO) {
590 int empty;
591  
592 empty = FN(PW,IS_ZERO)(pw);
593 if (empty < 0) {
594 FN(PW,free)(pw);
595 return -1;
596 }
597 if (empty) {
598 FN(PW,free)(pw);
599 return 0;
600 }
601 }
602  
603 data->res = FN(FN(UNION,add),PARTS)(data->res, pw);
604  
605 return 0;
606 }
607  
608 /* Apply fn to each pair of PW in u and set in uset such that
609 * the set lives in the same space as the domain of PW
610 * and collect the results.
611 */
612 static __isl_give UNION *match_domain_op(__isl_take UNION *u,
613 __isl_take isl_union_set *uset,
614 __isl_give PW *(*fn)(__isl_take PW*, __isl_take isl_set*))
615 {
616 S(UNION,match_domain_data) data = { NULL, NULL, fn };
617  
618 u = FN(UNION,align_params)(u, isl_union_set_get_space(uset));
619 uset = isl_union_set_align_params(uset, FN(UNION,get_space)(u));
620  
621 if (!u || !uset)
622 goto error;
623  
624 data.uset = uset;
625 #ifdef HAS_TYPE
626 data.res = FN(UNION,alloc)(isl_space_copy(u->dim), u->type, u->table.n);
627 #else
628 data.res = FN(UNION,alloc)(isl_space_copy(u->dim), u->table.n);
629 #endif
630 if (isl_hash_table_foreach(u->dim->ctx, &u->table,
631 &match_domain_entry, &data) < 0)
632 goto error;
633  
634 FN(UNION,free)(u);
635 isl_union_set_free(uset);
636 return data.res;
637 error:
638 FN(UNION,free)(u);
639 isl_union_set_free(uset);
640 FN(UNION,free)(data.res);
641 return NULL;
642 }
643  
644 /* Intersect the domain of "u" with "uset".
645 * If "uset" is a parameters domain, then intersect the parameter
646 * domain of "u" with this set.
647 */
648 __isl_give UNION *FN(UNION,intersect_domain)(__isl_take UNION *u,
649 __isl_take isl_union_set *uset)
650 {
651 if (isl_union_set_is_params(uset))
652 return FN(UNION,intersect_params)(u,
653 isl_set_from_union_set(uset));
654 return match_domain_op(u, uset, &FN(PW,intersect_domain));
655 }
656  
657 __isl_give UNION *FN(UNION,gist)(__isl_take UNION *u,
658 __isl_take isl_union_set *uset)
659 {
660 if (isl_union_set_is_params(uset))
661 return FN(UNION,gist_params)(u, isl_set_from_union_set(uset));
662 return match_domain_op(u, uset, &FN(PW,gist));
663 }
664  
665 #ifndef NO_EVAL
666 __isl_give isl_qpolynomial *FN(UNION,eval)(__isl_take UNION *u,
667 __isl_take isl_point *pnt)
668 {
669 uint32_t hash;
670 struct isl_hash_table_entry *entry;
671 isl_space *space;
672 isl_qpolynomial *qp;
673  
674 if (!u || !pnt)
675 goto error;
676  
677 space = isl_space_copy(pnt->dim);
678 space = isl_space_from_domain(space);
679 space = isl_space_add_dims(space, isl_dim_out, 1);
680 if (!space)
681 goto error;
682 hash = isl_space_get_hash(space);
683 entry = isl_hash_table_find(u->dim->ctx, &u->table,
684 hash, &has_dim, space, 0);
685 isl_space_free(space);
686 if (!entry) {
687 qp = isl_qpolynomial_zero_on_domain(isl_space_copy(pnt->dim));
688 isl_point_free(pnt);
689 } else {
690 qp = FN(PART,eval)(FN(PART,copy)(entry->data), pnt);
691 }
692 FN(UNION,free)(u);
693 return qp;
694 error:
695 FN(UNION,free)(u);
696 isl_point_free(pnt);
697 return NULL;
698 }
699 #endif
700  
701 static int coalesce_entry(void **entry, void *user)
702 {
703 PW **pw = (PW **)entry;
704  
705 *pw = FN(PW,coalesce)(*pw);
706 if (!*pw)
707 return -1;
708  
709 return 0;
710 }
711  
712 __isl_give UNION *FN(UNION,coalesce)(__isl_take UNION *u)
713 {
714 if (!u)
715 return NULL;
716  
717 if (isl_hash_table_foreach(u->dim->ctx, &u->table,
718 &coalesce_entry, NULL) < 0)
719 goto error;
720  
721 return u;
722 error:
723 FN(UNION,free)(u);
724 return NULL;
725 }
726  
727 static int domain(__isl_take PART *part, void *user)
728 {
729 isl_union_set **uset = (isl_union_set **)user;
730  
731 *uset = isl_union_set_add_set(*uset, FN(PART,domain)(part));
732  
733 return 0;
734 }
735  
736 __isl_give isl_union_set *FN(UNION,domain)(__isl_take UNION *u)
737 {
738 isl_union_set *uset;
739  
740 uset = isl_union_set_empty(FN(UNION,get_space)(u));
741 if (FN(FN(UNION,foreach),PARTS)(u, &domain, &uset) < 0)
742 goto error;
743  
744 FN(UNION,free)(u);
745  
746 return uset;
747 error:
748 isl_union_set_free(uset);
749 FN(UNION,free)(u);
750 return NULL;
751 }
752  
753 static int mul_isl_int(void **entry, void *user)
754 {
755 PW **pw = (PW **)entry;
756 isl_int *v = user;
757  
758 *pw = FN(PW,mul_isl_int)(*pw, *v);
759 if (!*pw)
760 return -1;
761  
762 return 0;
763 }
764  
765 __isl_give UNION *FN(UNION,mul_isl_int)(__isl_take UNION *u, isl_int v)
766 {
767 if (isl_int_is_one(v))
768 return u;
769  
770 if (DEFAULT_IS_ZERO && u && isl_int_is_zero(v)) {
771 UNION *zero;
772 isl_space *dim = FN(UNION,get_space)(u);
773 #ifdef HAS_TYPE
774 zero = FN(UNION,ZERO)(dim, u->type);
775 #else
776 zero = FN(UNION,ZERO)(dim);
777 #endif
778 FN(UNION,free)(u);
779 return zero;
780 }
781  
782 u = FN(UNION,cow)(u);
783 if (!u)
784 return NULL;
785  
786 #ifdef HAS_TYPE
787 if (isl_int_is_neg(v))
788 u->type = isl_fold_type_negate(u->type);
789 #endif
790 if (isl_hash_table_foreach(u->dim->ctx, &u->table, &mul_isl_int, v) < 0)
791 goto error;
792  
793 return u;
794 error:
795 FN(UNION,free)(u);
796 return NULL;
797 }
798  
799 S(UNION,plain_is_equal_data)
800 {
801 UNION *u2;
802 int is_equal;
803 };
804  
805 static int plain_is_equal_entry(void **entry, void *user)
806 {
807 S(UNION,plain_is_equal_data) *data = user;
808 uint32_t hash;
809 struct isl_hash_table_entry *entry2;
810 PW *pw = *entry;
811  
812 hash = isl_space_get_hash(pw->dim);
813 entry2 = isl_hash_table_find(data->u2->dim->ctx, &data->u2->table,
814 hash, &has_dim, pw->dim, 0);
815 if (!entry2) {
816 data->is_equal = 0;
817 return -1;
818 }
819  
820 data->is_equal = FN(PW,plain_is_equal)(pw, entry2->data);
821 if (data->is_equal < 0 || !data->is_equal)
822 return -1;
823  
824 return 0;
825 }
826  
827 int FN(UNION,plain_is_equal)(__isl_keep UNION *u1, __isl_keep UNION *u2)
828 {
829 S(UNION,plain_is_equal_data) data = { NULL, 1 };
830  
831 if (!u1 || !u2)
832 return -1;
833 if (u1 == u2)
834 return 1;
835 if (u1->table.n != u2->table.n)
836 return 0;
837  
838 u1 = FN(UNION,copy)(u1);
839 u2 = FN(UNION,copy)(u2);
840 u1 = FN(UNION,align_params)(u1, FN(UNION,get_space)(u2));
841 u2 = FN(UNION,align_params)(u2, FN(UNION,get_space)(u1));
842 if (!u1 || !u2)
843 goto error;
844  
845 data.u2 = u2;
846 if (isl_hash_table_foreach(u1->dim->ctx, &u1->table,
847 &plain_is_equal_entry, &data) < 0 &&
848 data.is_equal)
849 goto error;
850  
851 FN(UNION,free)(u1);
852 FN(UNION,free)(u2);
853  
854 return data.is_equal;
855 error:
856 FN(UNION,free)(u1);
857 FN(UNION,free)(u2);
858 return -1;
859 }