isl_input.c: read_factor: fix read after free in error path
[isl.git] / isl_union_templ.c
blob8495cbf72dd3cef3974aadbf3d168a12a940aa9d
1 /*
2 * Copyright 2010 INRIA Saclay
4 * Use of this software is governed by the GNU LGPLv2.1 license
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 */
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)
16 struct UNION {
17 int ref;
18 isl_dim *dim;
20 struct isl_hash_table table;
23 __isl_give UNION *FN(UNION,cow)(__isl_take UNION *u);
25 isl_ctx *FN(UNION,get_ctx)(__isl_keep UNION *u)
27 return u ? u->dim->ctx : NULL;
30 __isl_give isl_dim *FN(UNION,get_dim)(__isl_keep UNION *u)
32 if (!u)
33 return NULL;
34 return isl_dim_copy(u->dim);
37 static __isl_give UNION *FN(UNION,alloc)(__isl_take isl_dim *dim, int size)
39 UNION *u;
41 u = isl_calloc_type(ctx, UNION);
42 if (!u)
43 return NULL;
45 u->ref = 1;
46 u->dim = dim;
47 if (isl_hash_table_init(dim->ctx, &u->table, size) < 0)
48 goto error;
50 return u;
51 error:
52 isl_dim_free(dim);
53 FN(UNION,free)(u);
54 return NULL;
57 __isl_give UNION *FN(UNION,zero)(__isl_take isl_dim *dim)
59 return FN(UNION,alloc)(dim, 16);
62 __isl_give UNION *FN(UNION,copy)(__isl_keep UNION *u)
64 if (!u)
65 return NULL;
67 u->ref++;
68 return u;
71 S(UNION,foreach_data)
73 int (*fn)(__isl_take PART *part, void *user);
74 void *user;
77 static int call_on_copy(void **entry, void *user)
79 PART *part = *entry;
80 S(UNION,foreach_data) *data = (S(UNION,foreach_data) *)user;
82 return data->fn(FN(PART,copy)(part), data->user);
85 int FN(FN(UNION,foreach),PARTS)(__isl_keep UNION *u,
86 int (*fn)(__isl_take PART *part, void *user), void *user)
88 S(UNION,foreach_data) data = { fn, user };
90 if (!u)
91 return -1;
93 return isl_hash_table_foreach(u->dim->ctx, &u->table,
94 &call_on_copy, &data);
97 static int has_dim(const void *entry, const void *val)
99 PART *part = (PART *)entry;
100 isl_dim *dim = (isl_dim *)val;
102 return isl_dim_equal(part->dim, dim);
105 __isl_give UNION *FN(FN(UNION,add),PARTS)(__isl_take UNION *u,
106 __isl_take PART *part)
108 uint32_t hash;
109 struct isl_hash_table_entry *entry;
111 u = FN(UNION,cow)(u);
113 if (!part || !u)
114 goto error;
116 isl_assert(u->dim->ctx, isl_dim_match(part->dim, isl_dim_param, u->dim,
117 isl_dim_param), goto error);
119 hash = isl_dim_get_hash(part->dim);
120 entry = isl_hash_table_find(u->dim->ctx, &u->table, hash,
121 &has_dim, part->dim, 1);
122 if (!entry)
123 goto error;
125 if (!entry->data)
126 entry->data = part;
127 else {
128 entry->data = FN(PART,add)(entry->data, FN(PART,copy)(part));
129 if (!entry->data)
130 goto error;
131 FN(PART,free)(part);
132 if (FN(PART,is_zero)(entry->data)) {
133 FN(PART,free)(entry->data);
134 isl_hash_table_remove(u->dim->ctx, &u->table, entry);
138 return u;
139 error:
140 FN(PART,free)(part);
141 FN(UNION,free)(u);
142 return NULL;
145 static int add_part(__isl_take PART *part, void *user)
147 UNION **u = (UNION **)user;
149 *u = FN(FN(UNION,add),PARTS)(*u, part);
151 return 0;
154 __isl_give UNION *FN(UNION,dup)(__isl_keep UNION *u)
156 UNION *dup;
158 if (!u)
159 return NULL;
161 dup = FN(UNION,zero)(isl_dim_copy(u->dim));
162 if (FN(FN(UNION,foreach),PARTS)(u, &add_part, &dup) < 0)
163 goto error;
164 return dup;
165 error:
166 FN(UNION,free)(dup);
167 return NULL;
170 __isl_give UNION *FN(UNION,cow)(__isl_take UNION *u)
172 if (!u)
173 return NULL;
175 if (u->ref == 1)
176 return u;
177 u->ref--;
178 return FN(UNION,dup)(u);
181 static int free_u_entry(void **entry, void *user)
183 PART *part = *entry;
184 FN(PART,free)(part);
185 return 0;
188 void FN(UNION,free)(__isl_take UNION *u)
190 if (!u)
191 return;
193 if (--u->ref > 0)
194 return;
196 isl_hash_table_foreach(u->dim->ctx, &u->table, &free_u_entry, NULL);
197 isl_hash_table_clear(&u->table);
198 isl_dim_free(u->dim);
199 free(u);
202 __isl_give UNION *FN(UNION,add)(__isl_take UNION *u1, __isl_take UNION *u2)
204 u1 = FN(UNION,cow)(u1);
206 if (!u1 || !u2)
207 goto error;
209 if (FN(FN(UNION,foreach),PARTS)(u2, &add_part, &u1) < 0)
210 goto error;
212 FN(UNION,free)(u2);
214 return u1;
215 error:
216 FN(UNION,free)(u1);
217 FN(UNION,free)(u2);
218 return NULL;
221 __isl_give UNION *FN(FN(UNION,from),PARTS)(__isl_take PART *part)
223 isl_dim *dim;
224 UNION *u;
226 if (!part)
227 return NULL;
229 dim = FN(PART,get_dim)(part);
230 dim = isl_dim_drop(dim, isl_dim_in, 0, isl_dim_size(dim, isl_dim_in));
231 dim = isl_dim_drop(dim, isl_dim_out, 0, isl_dim_size(dim, isl_dim_out));
232 u = FN(UNION,zero)(dim);
233 u = FN(FN(UNION,add),PARTS)(u, part);
235 return u;
238 S(UNION,match_bin_data) {
239 UNION *upwqp2;
240 UNION *res;
243 static __isl_give UNION *match_bin_op(__isl_take UNION *u1,
244 __isl_take UNION *u2, int (*fn)(void **, void *))
246 S(UNION,match_bin_data) data = { u2, NULL };
248 if (!u1 || !u2)
249 goto error;
251 data.res = FN(UNION,alloc)(isl_dim_copy(u1->dim), u1->table.n);
252 if (isl_hash_table_foreach(u1->dim->ctx, &u1->table, fn, &data) < 0)
253 goto error;
255 FN(UNION,free)(u1);
256 FN(UNION,free)(u2);
257 return data.res;
258 error:
259 FN(UNION,free)(u1);
260 FN(UNION,free)(u2);
261 FN(UNION,free)(data.res);
262 return NULL;
265 S(UNION,match_set_data) {
266 isl_union_set *uset;
267 UNION *res;
268 __isl_give PW *(*fn)(__isl_take PW*, __isl_take isl_set*);
271 static int set_has_dim(const void *entry, const void *val)
273 isl_set *set = (isl_set *)entry;
274 isl_dim *dim = (isl_dim *)val;
276 return isl_dim_equal(set->dim, dim);
279 static int match_set_entry(void **entry, void *user)
281 S(UNION,match_set_data) *data = user;
282 uint32_t hash;
283 struct isl_hash_table_entry *entry2;
284 isl_dim *dim;
285 PW *pw = *entry;
286 int empty;
288 hash = isl_dim_get_hash(pw->dim);
289 entry2 = isl_hash_table_find(data->uset->dim->ctx, &data->uset->table,
290 hash, &set_has_dim, pw->dim, 0);
291 if (!entry2)
292 return 0;
294 pw = FN(PW,copy)(pw);
295 pw = data->fn(pw, isl_set_copy(entry2->data));
297 empty = FN(PW,is_zero)(pw);
298 if (empty < 0) {
299 FN(PW,free)(pw);
300 return -1;
302 if (empty) {
303 FN(PW,free)(pw);
304 return 0;
307 data->res = FN(FN(UNION,add),PARTS)(data->res, pw);
309 return 0;
312 static __isl_give UNION *match_set_op(__isl_take UNION *u,
313 __isl_take isl_union_set *uset,
314 __isl_give PW *(*fn)(__isl_take PW*, __isl_take isl_set*))
316 S(UNION,match_set_data) data = { uset, NULL, fn };
318 if (!u || !uset)
319 goto error;
321 data.res = FN(UNION,alloc)(isl_dim_copy(u->dim), u->table.n);
322 if (isl_hash_table_foreach(u->dim->ctx, &u->table,
323 &match_set_entry, &data) < 0)
324 goto error;
326 FN(UNION,free)(u);
327 isl_union_set_free(uset);
328 return data.res;
329 error:
330 FN(UNION,free)(u);
331 isl_union_set_free(uset);
332 FN(UNION,free)(data.res);
333 return NULL;
336 __isl_give UNION *FN(UNION,intersect_domain)(__isl_take UNION *u,
337 __isl_take isl_union_set *uset)
339 return match_set_op(u, uset, &FN(PW,intersect_domain));
342 __isl_give UNION *FN(UNION,gist)(__isl_take UNION *u,
343 __isl_take isl_union_set *uset)
345 return match_set_op(u, uset, &FN(PW,gist));
348 __isl_give isl_qpolynomial *FN(UNION,eval)(__isl_take UNION *u,
349 __isl_take isl_point *pnt)
351 uint32_t hash;
352 struct isl_hash_table_entry *entry;
353 isl_qpolynomial *qp;
355 if (!u || !pnt)
356 goto error;
358 hash = isl_dim_get_hash(pnt->dim);
359 entry = isl_hash_table_find(u->dim->ctx, &u->table,
360 hash, &has_dim, pnt->dim, 0);
361 if (!entry) {
362 qp = isl_qpolynomial_zero(isl_dim_copy(pnt->dim));
363 isl_point_free(pnt);
364 } else {
365 qp = FN(PART,eval)(FN(PART,copy)(entry->data), pnt);
367 FN(UNION,free)(u);
368 return qp;
369 error:
370 FN(UNION,free)(u);
371 isl_point_free(pnt);
372 return NULL;
375 static int coalesce_entry(void **entry, void *user)
377 PW **pw = (PW **)entry;
379 *pw = FN(PW,coalesce)(*pw);
380 if (!*pw)
381 return -1;
383 return 0;
386 __isl_give UNION *FN(UNION,coalesce)(__isl_take UNION *u)
388 if (!u)
389 return NULL;
391 if (isl_hash_table_foreach(u->dim->ctx, &u->table,
392 &coalesce_entry, NULL) < 0)
393 goto error;
395 return u;
396 error:
397 FN(UNION,free)(u);
398 return NULL;
401 static int domain(__isl_take PART *part, void *user)
403 isl_union_set **uset = (isl_union_set **)user;
405 *uset = isl_union_set_add_set(*uset, FN(PART,domain)(part));
407 return 0;
410 __isl_give isl_union_set *FN(UNION,domain)(__isl_take UNION *u)
412 isl_union_set *uset;
414 uset = isl_union_set_empty(FN(UNION,get_dim)(u));
415 if (FN(FN(UNION,foreach),PARTS)(u, &domain, &uset) < 0)
416 goto error;
418 FN(UNION,free)(u);
420 return uset;
421 error:
422 isl_union_set_free(uset);
423 FN(UNION,free)(u);
424 return NULL;