Bug Summary

File:tools/polly/lib/External/isl/isl_int_sioimath.h
Warning:line 1162, column 4
Assigned value is garbage or undefined

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name isl_val.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/tools/polly/lib/External -I /build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External -I /build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/pet/include -I /build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/ppcg/include -I /build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/ppcg/imath -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/tools/polly/lib/External/ppcg -I /build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl -I /build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/include -I /build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/imath -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/tools/polly/lib/External/isl -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/tools/polly/include -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/tools/polly/lib/External/isl/include -I /build/llvm-toolchain-snapshot-8~svn350071/tools/polly/include -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn350071/include -U NDEBUG -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=gnu99 -fconst-strings -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/tools/polly/lib/External -fdebug-prefix-map=/build/llvm-toolchain-snapshot-8~svn350071=. -ferror-limit 19 -fmessage-length 0 -stack-protector 2 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-12-27-042839-1215-1 -x c /build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c -faddrsig

/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c

1/*
2 * Copyright 2013 Ecole Normale Superieure
3 *
4 * Use of this software is governed by the MIT license
5 *
6 * Written by Sven Verdoolaege,
7 * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
8 */
9
10#include <isl_int.h>
11#include <isl_ctx_private.h>
12#include <isl_val_private.h>
13
14#undef BASEval
15#define BASEval val
16
17#include <isl_list_templ.c>
18
19/* Allocate an isl_val object with indeterminate value.
20 */
21__isl_give isl_val *isl_val_alloc(isl_ctx *ctx)
22{
23 isl_val *v;
24
25 v = isl_alloc_type(ctx, struct isl_val)((struct isl_val *)isl_malloc_or_die(ctx, sizeof(struct isl_val
)))
;
26 if (!v)
27 return NULL((void*)0);
28
29 v->ctx = ctx;
30 isl_ctx_ref(ctx);
31 v->ref = 1;
32 isl_int_init(v->n)isl_sioimath_init((v->n));
33 isl_int_init(v->d)isl_sioimath_init((v->d));
34
35 return v;
36}
37
38/* Return a reference to an isl_val representing zero.
39 */
40__isl_give isl_val *isl_val_zero(isl_ctx *ctx)
41{
42 return isl_val_int_from_si(ctx, 0);
43}
44
45/* Return a reference to an isl_val representing one.
46 */
47__isl_give isl_val *isl_val_one(isl_ctx *ctx)
48{
49 return isl_val_int_from_si(ctx, 1);
50}
51
52/* Return a reference to an isl_val representing negative one.
53 */
54__isl_give isl_val *isl_val_negone(isl_ctx *ctx)
55{
56 return isl_val_int_from_si(ctx, -1);
57}
58
59/* Return a reference to an isl_val representing NaN.
60 */
61__isl_give isl_val *isl_val_nan(isl_ctx *ctx)
62{
63 isl_val *v;
64
65 v = isl_val_alloc(ctx);
66 if (!v)
67 return NULL((void*)0);
68
69 isl_int_set_si(v->n, 0)isl_sioimath_set_si((v->n), 0);
70 isl_int_set_si(v->d, 0)isl_sioimath_set_si((v->d), 0);
71
72 return v;
73}
74
75/* Change "v" into a NaN.
76 */
77__isl_give isl_val *isl_val_set_nan(__isl_take isl_val *v)
78{
79 if (!v)
80 return NULL((void*)0);
81 if (isl_val_is_nan(v))
82 return v;
83 v = isl_val_cow(v);
84 if (!v)
85 return NULL((void*)0);
86
87 isl_int_set_si(v->n, 0)isl_sioimath_set_si((v->n), 0);
88 isl_int_set_si(v->d, 0)isl_sioimath_set_si((v->d), 0);
89
90 return v;
91}
92
93/* Return a reference to an isl_val representing +infinity.
94 */
95__isl_give isl_val *isl_val_infty(isl_ctx *ctx)
96{
97 isl_val *v;
98
99 v = isl_val_alloc(ctx);
100 if (!v)
101 return NULL((void*)0);
102
103 isl_int_set_si(v->n, 1)isl_sioimath_set_si((v->n), 1);
104 isl_int_set_si(v->d, 0)isl_sioimath_set_si((v->d), 0);
105
106 return v;
107}
108
109/* Return a reference to an isl_val representing -infinity.
110 */
111__isl_give isl_val *isl_val_neginfty(isl_ctx *ctx)
112{
113 isl_val *v;
114
115 v = isl_val_alloc(ctx);
116 if (!v)
117 return NULL((void*)0);
118
119 isl_int_set_si(v->n, -1)isl_sioimath_set_si((v->n), -1);
120 isl_int_set_si(v->d, 0)isl_sioimath_set_si((v->d), 0);
121
122 return v;
123}
124
125/* Return a reference to an isl_val representing the integer "i".
126 */
127__isl_give isl_val *isl_val_int_from_si(isl_ctx *ctx, long i)
128{
129 isl_val *v;
130
131 v = isl_val_alloc(ctx);
132 if (!v)
133 return NULL((void*)0);
134
135 isl_int_set_si(v->n, i)isl_sioimath_set_si((v->n), i);
136 isl_int_set_si(v->d, 1)isl_sioimath_set_si((v->d), 1);
137
138 return v;
139}
140
141/* Change the value of "v" to be equal to the integer "i".
142 */
143__isl_give isl_val *isl_val_set_si(__isl_take isl_val *v, long i)
144{
145 if (!v)
146 return NULL((void*)0);
147 if (isl_val_is_int(v) && isl_int_cmp_si(v->n, i)isl_sioimath_cmp_si(*(v->n), i) == 0)
148 return v;
149 v = isl_val_cow(v);
150 if (!v)
151 return NULL((void*)0);
152
153 isl_int_set_si(v->n, i)isl_sioimath_set_si((v->n), i);
154 isl_int_set_si(v->d, 1)isl_sioimath_set_si((v->d), 1);
155
156 return v;
157}
158
159/* Change the value of "v" to be equal to zero.
160 */
161__isl_give isl_val *isl_val_set_zero(__isl_take isl_val *v)
162{
163 return isl_val_set_si(v, 0);
164}
165
166/* Return a reference to an isl_val representing the unsigned integer "u".
167 */
168__isl_give isl_val *isl_val_int_from_ui(isl_ctx *ctx, unsigned long u)
169{
170 isl_val *v;
171
172 v = isl_val_alloc(ctx);
173 if (!v)
174 return NULL((void*)0);
175
176 isl_int_set_ui(v->n, u)isl_sioimath_set_ui((v->n), u);
177 isl_int_set_si(v->d, 1)isl_sioimath_set_si((v->d), 1);
178
179 return v;
180}
181
182/* Return a reference to an isl_val representing the integer "n".
183 */
184__isl_give isl_val *isl_val_int_from_isl_int(isl_ctx *ctx, isl_int n)
185{
186 isl_val *v;
187
188 v = isl_val_alloc(ctx);
189 if (!v)
190 return NULL((void*)0);
191
192 isl_int_set(v->n, n)isl_sioimath_set((v->n), *(n));
193 isl_int_set_si(v->d, 1)isl_sioimath_set_si((v->d), 1);
194
195 return v;
196}
197
198/* Return a reference to an isl_val representing the rational value "n"/"d".
199 * Normalizing the isl_val (if needed) is left to the caller.
200 */
201__isl_give isl_val *isl_val_rat_from_isl_int(isl_ctx *ctx,
202 isl_int n, isl_int d)
203{
204 isl_val *v;
205
206 v = isl_val_alloc(ctx);
207 if (!v)
208 return NULL((void*)0);
209
210 isl_int_set(v->n, n)isl_sioimath_set((v->n), *(n));
211 isl_int_set(v->d, d)isl_sioimath_set((v->d), *(d));
212
213 return v;
214}
215
216/* Return a new reference to "v".
217 */
218__isl_give isl_val *isl_val_copy(__isl_keep isl_val *v)
219{
220 if (!v)
221 return NULL((void*)0);
222
223 v->ref++;
224 return v;
225}
226
227/* Return a fresh copy of "val".
228 */
229__isl_give isl_val *isl_val_dup(__isl_keep isl_val *val)
230{
231 isl_val *dup;
232
233 if (!val)
234 return NULL((void*)0);
235
236 dup = isl_val_alloc(isl_val_get_ctx(val));
237 if (!dup)
238 return NULL((void*)0);
239
240 isl_int_set(dup->n, val->n)isl_sioimath_set((dup->n), *(val->n));
241 isl_int_set(dup->d, val->d)isl_sioimath_set((dup->d), *(val->d));
242
243 return dup;
244}
245
246/* Return an isl_val that is equal to "val" and that has only
247 * a single reference.
248 */
249__isl_give isl_val *isl_val_cow(__isl_take isl_val *val)
250{
251 if (!val)
252 return NULL((void*)0);
253
254 if (val->ref == 1)
255 return val;
256 val->ref--;
257 return isl_val_dup(val);
258}
259
260/* Free "v" and return NULL.
261 */
262__isl_null isl_val *isl_val_free(__isl_take isl_val *v)
263{
264 if (!v)
265 return NULL((void*)0);
266
267 if (--v->ref > 0)
268 return NULL((void*)0);
269
270 isl_ctx_deref(v->ctx);
271 isl_int_clear(v->n)isl_sioimath_clear((v->n));
272 isl_int_clear(v->d)isl_sioimath_clear((v->d));
273 free(v);
274 return NULL((void*)0);
275}
276
277/* Extract the numerator of a rational value "v" as an integer.
278 *
279 * If "v" is not a rational value, then the result is undefined.
280 */
281long isl_val_get_num_si(__isl_keep isl_val *v)
282{
283 if (!v)
284 return 0;
285 if (!isl_val_is_rat(v))
286 isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 287); return 0; } while (0)
287 "expecting rational value", return 0)do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 287); return 0; } while (0)
;
288 if (!isl_int_fits_slong(v->n)isl_sioimath_fits_slong(*(v->n)))
289 isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "numerator too large"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 290); return 0; } while (0)
290 "numerator too large", return 0)do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "numerator too large"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 290); return 0; } while (0)
;
291 return isl_int_get_si(v->n)isl_sioimath_get_si(*(v->n));
292}
293
294/* Extract the numerator of a rational value "v" as an isl_int.
295 *
296 * If "v" is not a rational value, then the result is undefined.
297 */
298isl_stat isl_val_get_num_isl_int(__isl_keep isl_val *v, isl_int *n)
299{
300 if (!v)
301 return isl_stat_error;
302 if (!isl_val_is_rat(v))
303 isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 304); return isl_stat_error; } while (0)
304 "expecting rational value", return isl_stat_error)do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 304); return isl_stat_error; } while (0)
;
305 isl_int_set(*n, v->n)isl_sioimath_set((*n), *(v->n));
306 return isl_stat_ok;
307}
308
309/* Extract the denominator of a rational value "v" as an integer.
310 *
311 * If "v" is not a rational value, then the result is undefined.
312 */
313long isl_val_get_den_si(__isl_keep isl_val *v)
314{
315 if (!v)
316 return 0;
317 if (!isl_val_is_rat(v))
318 isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 319); return 0; } while (0)
319 "expecting rational value", return 0)do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 319); return 0; } while (0)
;
320 if (!isl_int_fits_slong(v->d)isl_sioimath_fits_slong(*(v->d)))
321 isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "denominator too large"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 322); return 0; } while (0)
322 "denominator too large", return 0)do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "denominator too large"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 322); return 0; } while (0)
;
323 return isl_int_get_si(v->d)isl_sioimath_get_si(*(v->d));
324}
325
326/* Extract the denominator of a rational value "v" as an isl_val.
327 *
328 * If "v" is not a rational value, then the result is undefined.
329 */
330__isl_give isl_val *isl_val_get_den_val(__isl_keep isl_val *v)
331{
332 if (!v)
333 return NULL((void*)0);
334 if (!isl_val_is_rat(v))
335 isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 336); return ((void*)0); } while (0)
336 "expecting rational value", return NULL)do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 336); return ((void*)0); } while (0)
;
337 return isl_val_int_from_isl_int(isl_val_get_ctx(v), v->d);
338}
339
340/* Return an approximation of "v" as a double.
341 */
342double isl_val_get_d(__isl_keep isl_val *v)
343{
344 if (!v)
345 return 0;
346 if (!isl_val_is_rat(v))
347 isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 348); return 0; } while (0)
348 "expecting rational value", return 0)do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "expecting rational value"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 348); return 0; } while (0)
;
349 return isl_int_get_d(v->n)isl_sioimath_get_d(*(v->n)) / isl_int_get_d(v->d)isl_sioimath_get_d(*(v->d));
350}
351
352/* Return the isl_ctx to which "val" belongs.
353 */
354isl_ctx *isl_val_get_ctx(__isl_keep isl_val *val)
355{
356 return val ? val->ctx : NULL((void*)0);
357}
358
359/* Return a hash value that digests "val".
360 */
361uint32_t isl_val_get_hash(__isl_keep isl_val *val)
362{
363 uint32_t hash;
364
365 if (!val)
1
Assuming 'val' is non-null
2
Taking false branch
366 return 0;
367
368 hash = isl_hash_init()(2166136261u);
369 hash = isl_int_hash(val->n, hash)isl_sioimath_hash(*(val->n), hash);
3
Calling 'isl_sioimath_hash'
370 hash = isl_int_hash(val->d, hash)isl_sioimath_hash(*(val->d), hash);
371
372 return hash;
373}
374
375/* Normalize "v".
376 *
377 * In particular, make sure that the denominator of a rational value
378 * is positive and the numerator and denominator do not have any
379 * common divisors.
380 *
381 * This function should not be called by an external user
382 * since it will only be given normalized values.
383 */
384__isl_give isl_val *isl_val_normalize(__isl_take isl_val *v)
385{
386 isl_ctx *ctx;
387
388 if (!v)
389 return NULL((void*)0);
390 if (isl_val_is_int(v))
391 return v;
392 if (!isl_val_is_rat(v))
393 return v;
394 if (isl_int_is_neg(v->d)(isl_sioimath_sgn(*(v->d)) < 0)) {
395 isl_int_neg(v->d, v->d)isl_sioimath_neg((v->d), *(v->d));
396 isl_int_neg(v->n, v->n)isl_sioimath_neg((v->n), *(v->n));
397 }
398 ctx = isl_val_get_ctx(v);
399 isl_int_gcd(ctx->normalize_gcd, v->n, v->d)isl_sioimath_gcd((ctx->normalize_gcd), *(v->n), *(v->
d))
;
400 if (isl_int_is_one(ctx->normalize_gcd)(isl_sioimath_cmp_si(*(ctx->normalize_gcd), 1) == 0))
401 return v;
402 isl_int_divexact(v->n, v->n, ctx->normalize_gcd)isl_sioimath_tdiv_q((v->n), *(v->n), *(ctx->normalize_gcd
))
;
403 isl_int_divexact(v->d, v->d, ctx->normalize_gcd)isl_sioimath_tdiv_q((v->d), *(v->d), *(ctx->normalize_gcd
))
;
404 return v;
405}
406
407/* Return the opposite of "v".
408 */
409__isl_give isl_val *isl_val_neg(__isl_take isl_val *v)
410{
411 if (!v)
412 return NULL((void*)0);
413 if (isl_val_is_nan(v))
414 return v;
415 if (isl_val_is_zero(v))
416 return v;
417
418 v = isl_val_cow(v);
419 if (!v)
420 return NULL((void*)0);
421 isl_int_neg(v->n, v->n)isl_sioimath_neg((v->n), *(v->n));
422
423 return v;
424}
425
426/* Return the inverse of "v".
427 */
428__isl_give isl_val *isl_val_inv(__isl_take isl_val *v)
429{
430 if (!v)
431 return NULL((void*)0);
432 if (isl_val_is_nan(v))
433 return v;
434 if (isl_val_is_zero(v)) {
435 isl_ctx *ctx = isl_val_get_ctx(v);
436 isl_val_free(v);
437 return isl_val_nan(ctx);
438 }
439 if (isl_val_is_infty(v) || isl_val_is_neginfty(v)) {
440 isl_ctx *ctx = isl_val_get_ctx(v);
441 isl_val_free(v);
442 return isl_val_zero(ctx);
443 }
444
445 v = isl_val_cow(v);
446 if (!v)
447 return NULL((void*)0);
448 isl_int_swap(v->n, v->d)isl_sioimath_swap((v->n), (v->d));
449
450 return isl_val_normalize(v);
451}
452
453/* Return the absolute value of "v".
454 */
455__isl_give isl_val *isl_val_abs(__isl_take isl_val *v)
456{
457 if (!v)
458 return NULL((void*)0);
459 if (isl_val_is_nan(v))
460 return v;
461 if (isl_val_is_nonneg(v))
462 return v;
463 return isl_val_neg(v);
464}
465
466/* Return the "floor" (greatest integer part) of "v".
467 * That is, return the result of rounding towards -infinity.
468 */
469__isl_give isl_val *isl_val_floor(__isl_take isl_val *v)
470{
471 if (!v)
472 return NULL((void*)0);
473 if (isl_val_is_int(v))
474 return v;
475 if (!isl_val_is_rat(v))
476 return v;
477
478 v = isl_val_cow(v);
479 if (!v)
480 return NULL((void*)0);
481 isl_int_fdiv_q(v->n, v->n, v->d)isl_sioimath_fdiv_q((v->n), *(v->n), *(v->d));
482 isl_int_set_si(v->d, 1)isl_sioimath_set_si((v->d), 1);
483
484 return v;
485}
486
487/* Return the "ceiling" of "v".
488 * That is, return the result of rounding towards +infinity.
489 */
490__isl_give isl_val *isl_val_ceil(__isl_take isl_val *v)
491{
492 if (!v)
493 return NULL((void*)0);
494 if (isl_val_is_int(v))
495 return v;
496 if (!isl_val_is_rat(v))
497 return v;
498
499 v = isl_val_cow(v);
500 if (!v)
501 return NULL((void*)0);
502 isl_int_cdiv_q(v->n, v->n, v->d)isl_sioimath_cdiv_q((v->n), *(v->n), *(v->d));
503 isl_int_set_si(v->d, 1)isl_sioimath_set_si((v->d), 1);
504
505 return v;
506}
507
508/* Truncate "v".
509 * That is, return the result of rounding towards zero.
510 */
511__isl_give isl_val *isl_val_trunc(__isl_take isl_val *v)
512{
513 if (!v)
514 return NULL((void*)0);
515 if (isl_val_is_int(v))
516 return v;
517 if (!isl_val_is_rat(v))
518 return v;
519
520 v = isl_val_cow(v);
521 if (!v)
522 return NULL((void*)0);
523 isl_int_tdiv_q(v->n, v->n, v->d)isl_sioimath_tdiv_q((v->n), *(v->n), *(v->d));
524 isl_int_set_si(v->d, 1)isl_sioimath_set_si((v->d), 1);
525
526 return v;
527}
528
529/* Return 2^v, where v is an integer (that is not too large).
530 */
531__isl_give isl_val *isl_val_pow2(__isl_take isl_val *v)
532{
533 unsigned long exp;
534 int neg;
535
536 v = isl_val_cow(v);
537 if (!v)
538 return NULL((void*)0);
539 if (!isl_val_is_int(v))
540 isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "can only compute integer powers"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 542); return isl_val_free(v); } while (0)
541 "can only compute integer powers",do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "can only compute integer powers"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 542); return isl_val_free(v); } while (0)
542 return isl_val_free(v))do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "can only compute integer powers"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 542); return isl_val_free(v); } while (0)
;
543 neg = isl_val_is_neg(v);
544 if (neg)
545 isl_int_neg(v->n, v->n)isl_sioimath_neg((v->n), *(v->n));
546 if (!isl_int_fits_ulong(v->n)isl_sioimath_fits_ulong(*(v->n)))
547 isl_die(isl_val_get_ctx(v), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "exponent too large"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 548); return isl_val_free(v); } while (0)
548 "exponent too large", return isl_val_free(v))do { isl_handle_error(isl_val_get_ctx(v), isl_error_invalid, "exponent too large"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 548); return isl_val_free(v); } while (0)
;
549 exp = isl_int_get_ui(v->n)isl_sioimath_get_ui(*(v->n));
550 if (neg) {
551 isl_int_mul_2exp(v->d, v->d, exp)isl_sioimath_mul_2exp((v->d), *(v->d), exp);
552 isl_int_set_si(v->n, 1)isl_sioimath_set_si((v->n), 1);
553 } else {
554 isl_int_mul_2exp(v->n, v->d, exp)isl_sioimath_mul_2exp((v->n), *(v->d), exp);
555 }
556
557 return v;
558}
559
560/* This is an alternative name for the function above.
561 */
562__isl_give isl_val *isl_val_2exp(__isl_take isl_val *v)
563{
564 return isl_val_pow2(v);
565}
566
567/* Return the minimum of "v1" and "v2".
568 */
569__isl_give isl_val *isl_val_min(__isl_take isl_val *v1, __isl_take isl_val *v2)
570{
571 if (!v1 || !v2)
572 goto error;
573
574 if (isl_val_is_nan(v1)) {
575 isl_val_free(v2);
576 return v1;
577 }
578 if (isl_val_is_nan(v2)) {
579 isl_val_free(v1);
580 return v2;
581 }
582 if (isl_val_le(v1, v2)) {
583 isl_val_free(v2);
584 return v1;
585 } else {
586 isl_val_free(v1);
587 return v2;
588 }
589error:
590 isl_val_free(v1);
591 isl_val_free(v2);
592 return NULL((void*)0);
593}
594
595/* Return the maximum of "v1" and "v2".
596 */
597__isl_give isl_val *isl_val_max(__isl_take isl_val *v1, __isl_take isl_val *v2)
598{
599 if (!v1 || !v2)
600 goto error;
601
602 if (isl_val_is_nan(v1)) {
603 isl_val_free(v2);
604 return v1;
605 }
606 if (isl_val_is_nan(v2)) {
607 isl_val_free(v1);
608 return v2;
609 }
610 if (isl_val_ge(v1, v2)) {
611 isl_val_free(v2);
612 return v1;
613 } else {
614 isl_val_free(v1);
615 return v2;
616 }
617error:
618 isl_val_free(v1);
619 isl_val_free(v2);
620 return NULL((void*)0);
621}
622
623/* Return the sum of "v1" and "v2".
624 */
625__isl_give isl_val *isl_val_add(__isl_take isl_val *v1, __isl_take isl_val *v2)
626{
627 if (!v1 || !v2)
628 goto error;
629 if (isl_val_is_nan(v1)) {
630 isl_val_free(v2);
631 return v1;
632 }
633 if (isl_val_is_nan(v2)) {
634 isl_val_free(v1);
635 return v2;
636 }
637 if ((isl_val_is_infty(v1) && isl_val_is_neginfty(v2)) ||
638 (isl_val_is_neginfty(v1) && isl_val_is_infty(v2))) {
639 isl_val_free(v2);
640 return isl_val_set_nan(v1);
641 }
642 if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
643 isl_val_free(v2);
644 return v1;
645 }
646 if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
647 isl_val_free(v1);
648 return v2;
649 }
650 if (isl_val_is_zero(v1)) {
651 isl_val_free(v1);
652 return v2;
653 }
654 if (isl_val_is_zero(v2)) {
655 isl_val_free(v2);
656 return v1;
657 }
658
659 v1 = isl_val_cow(v1);
660 if (!v1)
661 goto error;
662 if (isl_val_is_int(v1) && isl_val_is_int(v2))
663 isl_int_add(v1->n, v1->n, v2->n)isl_sioimath_add((v1->n), *(v1->n), *(v2->n));
664 else {
665 if (isl_int_eq(v1->d, v2->d)(isl_sioimath_cmp(*(v1->d), *(v2->d)) == 0))
666 isl_int_add(v1->n, v1->n, v2->n)isl_sioimath_add((v1->n), *(v1->n), *(v2->n));
667 else {
668 isl_int_mul(v1->n, v1->n, v2->d)isl_sioimath_mul((v1->n), *(v1->n), *(v2->d));
669 isl_int_addmul(v1->n, v2->n, v1->d)isl_sioimath_addmul((v1->n), *(v2->n), *(v1->d));
670 isl_int_mul(v1->d, v1->d, v2->d)isl_sioimath_mul((v1->d), *(v1->d), *(v2->d));
671 }
672 v1 = isl_val_normalize(v1);
673 }
674 isl_val_free(v2);
675 return v1;
676error:
677 isl_val_free(v1);
678 isl_val_free(v2);
679 return NULL((void*)0);
680}
681
682/* Return the sum of "v1" and "v2".
683 */
684__isl_give isl_val *isl_val_add_ui(__isl_take isl_val *v1, unsigned long v2)
685{
686 if (!v1)
687 return NULL((void*)0);
688 if (!isl_val_is_rat(v1))
689 return v1;
690 if (v2 == 0)
691 return v1;
692 v1 = isl_val_cow(v1);
693 if (!v1)
694 return NULL((void*)0);
695
696 isl_int_addmul_ui(v1->n, v1->d, v2)isl_sioimath_addmul_ui((v1->n), *(v1->d), v2);
697
698 return v1;
699}
700
701/* Subtract "v2" from "v1".
702 */
703__isl_give isl_val *isl_val_sub(__isl_take isl_val *v1, __isl_take isl_val *v2)
704{
705 if (!v1 || !v2)
706 goto error;
707 if (isl_val_is_nan(v1)) {
708 isl_val_free(v2);
709 return v1;
710 }
711 if (isl_val_is_nan(v2)) {
712 isl_val_free(v1);
713 return v2;
714 }
715 if ((isl_val_is_infty(v1) && isl_val_is_infty(v2)) ||
716 (isl_val_is_neginfty(v1) && isl_val_is_neginfty(v2))) {
717 isl_val_free(v2);
718 return isl_val_set_nan(v1);
719 }
720 if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
721 isl_val_free(v2);
722 return v1;
723 }
724 if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
725 isl_val_free(v1);
726 return isl_val_neg(v2);
727 }
728 if (isl_val_is_zero(v2)) {
729 isl_val_free(v2);
730 return v1;
731 }
732 if (isl_val_is_zero(v1)) {
733 isl_val_free(v1);
734 return isl_val_neg(v2);
735 }
736
737 v1 = isl_val_cow(v1);
738 if (!v1)
739 goto error;
740 if (isl_val_is_int(v1) && isl_val_is_int(v2))
741 isl_int_sub(v1->n, v1->n, v2->n)isl_sioimath_sub((v1->n), *(v1->n), *(v2->n));
742 else {
743 if (isl_int_eq(v1->d, v2->d)(isl_sioimath_cmp(*(v1->d), *(v2->d)) == 0))
744 isl_int_sub(v1->n, v1->n, v2->n)isl_sioimath_sub((v1->n), *(v1->n), *(v2->n));
745 else {
746 isl_int_mul(v1->n, v1->n, v2->d)isl_sioimath_mul((v1->n), *(v1->n), *(v2->d));
747 isl_int_submul(v1->n, v2->n, v1->d)isl_sioimath_submul((v1->n), *(v2->n), *(v1->d));
748 isl_int_mul(v1->d, v1->d, v2->d)isl_sioimath_mul((v1->d), *(v1->d), *(v2->d));
749 }
750 v1 = isl_val_normalize(v1);
751 }
752 isl_val_free(v2);
753 return v1;
754error:
755 isl_val_free(v1);
756 isl_val_free(v2);
757 return NULL((void*)0);
758}
759
760/* Subtract "v2" from "v1".
761 */
762__isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1, unsigned long v2)
763{
764 if (!v1)
765 return NULL((void*)0);
766 if (!isl_val_is_rat(v1))
767 return v1;
768 if (v2 == 0)
769 return v1;
770 v1 = isl_val_cow(v1);
771 if (!v1)
772 return NULL((void*)0);
773
774 isl_int_submul_ui(v1->n, v1->d, v2)isl_sioimath_submul_ui((v1->n), *(v1->d), v2);
775
776 return v1;
777}
778
779/* Return the product of "v1" and "v2".
780 */
781__isl_give isl_val *isl_val_mul(__isl_take isl_val *v1, __isl_take isl_val *v2)
782{
783 if (!v1 || !v2)
784 goto error;
785 if (isl_val_is_nan(v1)) {
786 isl_val_free(v2);
787 return v1;
788 }
789 if (isl_val_is_nan(v2)) {
790 isl_val_free(v1);
791 return v2;
792 }
793 if ((!isl_val_is_rat(v1) && isl_val_is_zero(v2)) ||
794 (isl_val_is_zero(v1) && !isl_val_is_rat(v2))) {
795 isl_val_free(v2);
796 return isl_val_set_nan(v1);
797 }
798 if (isl_val_is_zero(v1)) {
799 isl_val_free(v2);
800 return v1;
801 }
802 if (isl_val_is_zero(v2)) {
803 isl_val_free(v1);
804 return v2;
805 }
806 if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
807 if (isl_val_is_neg(v2))
808 v1 = isl_val_neg(v1);
809 isl_val_free(v2);
810 return v1;
811 }
812 if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
813 if (isl_val_is_neg(v1))
814 v2 = isl_val_neg(v2);
815 isl_val_free(v1);
816 return v2;
817 }
818
819 v1 = isl_val_cow(v1);
820 if (!v1)
821 goto error;
822 if (isl_val_is_int(v1) && isl_val_is_int(v2))
823 isl_int_mul(v1->n, v1->n, v2->n)isl_sioimath_mul((v1->n), *(v1->n), *(v2->n));
824 else {
825 isl_int_mul(v1->n, v1->n, v2->n)isl_sioimath_mul((v1->n), *(v1->n), *(v2->n));
826 isl_int_mul(v1->d, v1->d, v2->d)isl_sioimath_mul((v1->d), *(v1->d), *(v2->d));
827 v1 = isl_val_normalize(v1);
828 }
829 isl_val_free(v2);
830 return v1;
831error:
832 isl_val_free(v1);
833 isl_val_free(v2);
834 return NULL((void*)0);
835}
836
837/* Return the product of "v1" and "v2".
838 *
839 * This is a private copy of isl_val_mul for use in the generic
840 * isl_multi_*_scale_val instantiated for isl_val.
841 */
842__isl_give isl_val *isl_val_scale_val(__isl_take isl_val *v1,
843 __isl_take isl_val *v2)
844{
845 return isl_val_mul(v1, v2);
846}
847
848/* Return the product of "v1" and "v2".
849 */
850__isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1, unsigned long v2)
851{
852 if (!v1)
853 return NULL((void*)0);
854 if (isl_val_is_nan(v1))
855 return v1;
856 if (!isl_val_is_rat(v1)) {
857 if (v2 == 0)
858 v1 = isl_val_set_nan(v1);
859 return v1;
860 }
861 if (v2 == 1)
862 return v1;
863 v1 = isl_val_cow(v1);
864 if (!v1)
865 return NULL((void*)0);
866
867 isl_int_mul_ui(v1->n, v1->n, v2)isl_sioimath_mul_ui((v1->n), *(v1->n), v2);
868
869 return isl_val_normalize(v1);
870}
871
872/* Divide "v1" by "v2".
873 */
874__isl_give isl_val *isl_val_div(__isl_take isl_val *v1, __isl_take isl_val *v2)
875{
876 if (!v1 || !v2)
877 goto error;
878 if (isl_val_is_nan(v1)) {
879 isl_val_free(v2);
880 return v1;
881 }
882 if (isl_val_is_nan(v2)) {
883 isl_val_free(v1);
884 return v2;
885 }
886 if (isl_val_is_zero(v2) ||
887 (!isl_val_is_rat(v1) && !isl_val_is_rat(v2))) {
888 isl_val_free(v2);
889 return isl_val_set_nan(v1);
890 }
891 if (isl_val_is_zero(v1)) {
892 isl_val_free(v2);
893 return v1;
894 }
895 if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1)) {
896 if (isl_val_is_neg(v2))
897 v1 = isl_val_neg(v1);
898 isl_val_free(v2);
899 return v1;
900 }
901 if (isl_val_is_infty(v2) || isl_val_is_neginfty(v2)) {
902 isl_val_free(v2);
903 return isl_val_set_zero(v1);
904 }
905
906 v1 = isl_val_cow(v1);
907 if (!v1)
908 goto error;
909 if (isl_val_is_int(v2)) {
910 isl_int_mul(v1->d, v1->d, v2->n)isl_sioimath_mul((v1->d), *(v1->d), *(v2->n));
911 v1 = isl_val_normalize(v1);
912 } else {
913 isl_int_mul(v1->d, v1->d, v2->n)isl_sioimath_mul((v1->d), *(v1->d), *(v2->n));
914 isl_int_mul(v1->n, v1->n, v2->d)isl_sioimath_mul((v1->n), *(v1->n), *(v2->d));
915 v1 = isl_val_normalize(v1);
916 }
917 isl_val_free(v2);
918 return v1;
919error:
920 isl_val_free(v1);
921 isl_val_free(v2);
922 return NULL((void*)0);
923}
924
925/* Divide "v1" by "v2".
926 */
927__isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1, unsigned long v2)
928{
929 if (!v1)
930 return NULL((void*)0);
931 if (isl_val_is_nan(v1))
932 return v1;
933 if (v2 == 0)
934 return isl_val_set_nan(v1);
935 if (v2 == 1)
936 return v1;
937 if (isl_val_is_zero(v1))
938 return v1;
939 if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1))
940 return v1;
941 v1 = isl_val_cow(v1);
942 if (!v1)
943 return NULL((void*)0);
944
945 isl_int_mul_ui(v1->d, v1->d, v2)isl_sioimath_mul_ui((v1->d), *(v1->d), v2);
946
947 return isl_val_normalize(v1);
948}
949
950/* Divide "v1" by "v2".
951 *
952 * This is a private copy of isl_val_div for use in the generic
953 * isl_multi_*_scale_down_val instantiated for isl_val.
954 */
955__isl_give isl_val *isl_val_scale_down_val(__isl_take isl_val *v1,
956 __isl_take isl_val *v2)
957{
958 return isl_val_div(v1, v2);
959}
960
961/* Given two integer values "v1" and "v2", check if "v1" is divisible by "v2".
962 */
963isl_bool isl_val_is_divisible_by(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
964{
965 if (!v1 || !v2)
966 return isl_bool_error;
967
968 if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
969 isl_die(isl_val_get_ctx(v1), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v1), isl_error_invalid,
"expecting two integers", "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 970); return isl_bool_error; } while (0)
970 "expecting two integers", return isl_bool_error)do { isl_handle_error(isl_val_get_ctx(v1), isl_error_invalid,
"expecting two integers", "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 970); return isl_bool_error; } while (0)
;
971
972 return isl_int_is_divisible_by(v1->n, v2->n)isl_sioimath_is_divisible_by(*(v1->n), *(v2->n));
973}
974
975/* Given two integer values "v1" and "v2", return the residue of "v1"
976 * modulo "v2".
977 */
978__isl_give isl_val *isl_val_mod(__isl_take isl_val *v1, __isl_take isl_val *v2)
979{
980 if (!v1 || !v2)
981 goto error;
982 if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
983 isl_die(isl_val_get_ctx(v1), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v1), isl_error_invalid,
"expecting two integers", "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 984); goto error; } while (0)
984 "expecting two integers", goto error)do { isl_handle_error(isl_val_get_ctx(v1), isl_error_invalid,
"expecting two integers", "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 984); goto error; } while (0)
;
985 if (isl_val_is_nonneg(v1) && isl_val_lt(v1, v2)) {
986 isl_val_free(v2);
987 return v1;
988 }
989 v1 = isl_val_cow(v1);
990 if (!v1)
991 goto error;
992 isl_int_fdiv_r(v1->n, v1->n, v2->n)isl_sioimath_fdiv_r((v1->n), *(v1->n), *(v2->n));
993 isl_val_free(v2);
994 return v1;
995error:
996 isl_val_free(v1);
997 isl_val_free(v2);
998 return NULL((void*)0);
999}
1000
1001/* Given two integer values "v1" and "v2", return the residue of "v1"
1002 * modulo "v2".
1003 *
1004 * This is a private copy of isl_val_mod for use in the generic
1005 * isl_multi_*_mod_multi_val instantiated for isl_val.
1006 */
1007__isl_give isl_val *isl_val_mod_val(__isl_take isl_val *v1,
1008 __isl_take isl_val *v2)
1009{
1010 return isl_val_mod(v1, v2);
1011}
1012
1013/* Given two integer values, return their greatest common divisor.
1014 */
1015__isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1, __isl_take isl_val *v2)
1016{
1017 if (!v1 || !v2)
1018 goto error;
1019 if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
1020 isl_die(isl_val_get_ctx(v1), isl_error_invalid,do { isl_handle_error(isl_val_get_ctx(v1), isl_error_invalid,
"expecting two integers", "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 1021); goto error; } while (0)
1021 "expecting two integers", goto error)do { isl_handle_error(isl_val_get_ctx(v1), isl_error_invalid,
"expecting two integers", "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 1021); goto error; } while (0)
;
1022 if (isl_val_eq(v1, v2)) {
1023 isl_val_free(v2);
1024 return v1;
1025 }
1026 if (isl_val_is_one(v1)) {
1027 isl_val_free(v2);
1028 return v1;
1029 }
1030 if (isl_val_is_one(v2)) {
1031 isl_val_free(v1);
1032 return v2;
1033 }
1034 v1 = isl_val_cow(v1);
1035 if (!v1)
1036 goto error;
1037 isl_int_gcd(v1->n, v1->n, v2->n)isl_sioimath_gcd((v1->n), *(v1->n), *(v2->n));
1038 isl_val_free(v2);
1039 return v1;
1040error:
1041 isl_val_free(v1);
1042 isl_val_free(v2);
1043 return NULL((void*)0);
1044}
1045
1046/* Compute x, y and g such that g = gcd(a,b) and a*x+b*y = g.
1047 */
1048static void isl_int_gcdext(isl_int *g, isl_int *x, isl_int *y,
1049 isl_int a, isl_int b)
1050{
1051 isl_int d, tmp;
1052 isl_int a_copy, b_copy;
1053
1054 isl_int_init(a_copy)isl_sioimath_init((a_copy));
1055 isl_int_init(b_copy)isl_sioimath_init((b_copy));
1056 isl_int_init(d)isl_sioimath_init((d));
1057 isl_int_init(tmp)isl_sioimath_init((tmp));
1058 isl_int_set(a_copy, a)isl_sioimath_set((a_copy), *(a));
1059 isl_int_set(b_copy, b)isl_sioimath_set((b_copy), *(b));
1060 isl_int_abs(*g, a_copy)isl_sioimath_abs((*g), *(a_copy));
1061 isl_int_abs(d, b_copy)isl_sioimath_abs((d), *(b_copy));
1062 isl_int_set_si(*x, 1)isl_sioimath_set_si((*x), 1);
1063 isl_int_set_si(*y, 0)isl_sioimath_set_si((*y), 0);
1064 while (isl_int_is_pos(d)(isl_sioimath_sgn(*(d)) > 0)) {
1065 isl_int_fdiv_q(tmp, *g, d)isl_sioimath_fdiv_q((tmp), *(*g), *(d));
1066 isl_int_submul(*x, tmp, *y)isl_sioimath_submul((*x), *(tmp), *(*y));
1067 isl_int_submul(*g, tmp, d)isl_sioimath_submul((*g), *(tmp), *(d));
1068 isl_int_swap(*g, d)isl_sioimath_swap((*g), (d));
1069 isl_int_swap(*x, *y)isl_sioimath_swap((*x), (*y));
1070 }
1071 if (isl_int_is_zero(a_copy)(isl_sioimath_sgn(*(a_copy)) == 0))
1072 isl_int_set_si(*x, 0)isl_sioimath_set_si((*x), 0);
1073 else if (isl_int_is_neg(a_copy)(isl_sioimath_sgn(*(a_copy)) < 0))
1074 isl_int_neg(*x, *x)isl_sioimath_neg((*x), *(*x));
1075 if (isl_int_is_zero(b_copy)(isl_sioimath_sgn(*(b_copy)) == 0))
1076 isl_int_set_si(*y, 0)isl_sioimath_set_si((*y), 0);
1077 else {
1078 isl_int_mul(tmp, a_copy, *x)isl_sioimath_mul((tmp), *(a_copy), *(*x));
1079 isl_int_sub(tmp, *g, tmp)isl_sioimath_sub((tmp), *(*g), *(tmp));
1080 isl_int_divexact(*y, tmp, b_copy)isl_sioimath_tdiv_q((*y), *(tmp), *(b_copy));
1081 }
1082 isl_int_clear(d)isl_sioimath_clear((d));
1083 isl_int_clear(tmp)isl_sioimath_clear((tmp));
1084 isl_int_clear(a_copy)isl_sioimath_clear((a_copy));
1085 isl_int_clear(b_copy)isl_sioimath_clear((b_copy));
1086}
1087
1088/* Given two integer values v1 and v2, return their greatest common divisor g,
1089 * as well as two integers x and y such that x * v1 + y * v2 = g.
1090 */
1091__isl_give isl_val *isl_val_gcdext(__isl_take isl_val *v1,
1092 __isl_take isl_val *v2, __isl_give isl_val **x, __isl_give isl_val **y)
1093{
1094 isl_ctx *ctx;
1095 isl_val *a = NULL((void*)0), *b = NULL((void*)0);
1096
1097 if (!x && !y)
1098 return isl_val_gcd(v1, v2);
1099
1100 if (!v1 || !v2)
1101 goto error;
1102
1103 ctx = isl_val_get_ctx(v1);
1104 if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
1105 isl_die(ctx, isl_error_invalid,do { isl_handle_error(ctx, isl_error_invalid, "expecting two integers"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 1106); goto error; } while (0)
1106 "expecting two integers", goto error)do { isl_handle_error(ctx, isl_error_invalid, "expecting two integers"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_val.c"
, 1106); goto error; } while (0)
;
1107
1108 v1 = isl_val_cow(v1);
1109 a = isl_val_alloc(ctx);
1110 b = isl_val_alloc(ctx);
1111 if (!v1 || !a || !b)
1112 goto error;
1113 isl_int_gcdext(&v1->n, &a->n, &b->n, v1->n, v2->n);
1114 if (x) {
1115 isl_int_set_si(a->d, 1)isl_sioimath_set_si((a->d), 1);
1116 *x = a;
1117 } else
1118 isl_val_free(a);
1119 if (y) {
1120 isl_int_set_si(b->d, 1)isl_sioimath_set_si((b->d), 1);
1121 *y = b;
1122 } else
1123 isl_val_free(b);
1124 isl_val_free(v2);
1125 return v1;
1126error:
1127 isl_val_free(v1);
1128 isl_val_free(v2);
1129 isl_val_free(a);
1130 isl_val_free(b);
1131 if (x)
1132 *x = NULL((void*)0);
1133 if (y)
1134 *y = NULL((void*)0);
1135 return NULL((void*)0);
1136}
1137
1138/* Does "v" represent an integer value?
1139 */
1140isl_bool isl_val_is_int(__isl_keep isl_val *v)
1141{
1142 if (!v)
1143 return isl_bool_error;
1144
1145 return isl_int_is_one(v->d)(isl_sioimath_cmp_si(*(v->d), 1) == 0);
1146}
1147
1148/* Does "v" represent a rational value?
1149 */
1150isl_bool isl_val_is_rat(__isl_keep isl_val *v)
1151{
1152 if (!v)
1153 return isl_bool_error;
1154
1155 return !isl_int_is_zero(v->d)(isl_sioimath_sgn(*(v->d)) == 0);
1156}
1157
1158/* Does "v" represent NaN?
1159 */
1160isl_bool isl_val_is_nan(__isl_keep isl_val *v)
1161{
1162 if (!v)
1163 return isl_bool_error;
1164
1165 return isl_int_is_zero(v->n)(isl_sioimath_sgn(*(v->n)) == 0) && isl_int_is_zero(v->d)(isl_sioimath_sgn(*(v->d)) == 0);
1166}
1167
1168/* Does "v" represent +infinity?
1169 */
1170isl_bool isl_val_is_infty(__isl_keep isl_val *v)
1171{
1172 if (!v)
1173 return isl_bool_error;
1174
1175 return isl_int_is_pos(v->n)(isl_sioimath_sgn(*(v->n)) > 0) && isl_int_is_zero(v->d)(isl_sioimath_sgn(*(v->d)) == 0);
1176}
1177
1178/* Does "v" represent -infinity?
1179 */
1180isl_bool isl_val_is_neginfty(__isl_keep isl_val *v)
1181{
1182 if (!v)
1183 return isl_bool_error;
1184
1185 return isl_int_is_neg(v->n)(isl_sioimath_sgn(*(v->n)) < 0) && isl_int_is_zero(v->d)(isl_sioimath_sgn(*(v->d)) == 0);
1186}
1187
1188/* Does "v" represent the integer zero?
1189 */
1190isl_bool isl_val_is_zero(__isl_keep isl_val *v)
1191{
1192 if (!v)
1193 return isl_bool_error;
1194
1195 return isl_int_is_zero(v->n)(isl_sioimath_sgn(*(v->n)) == 0) && !isl_int_is_zero(v->d)(isl_sioimath_sgn(*(v->d)) == 0);
1196}
1197
1198/* Does "v" represent the integer one?
1199 */
1200isl_bool isl_val_is_one(__isl_keep isl_val *v)
1201{
1202 if (!v)
1203 return isl_bool_error;
1204
1205 if (isl_val_is_nan(v))
1206 return isl_bool_false;
1207
1208 return isl_int_eq(v->n, v->d)(isl_sioimath_cmp(*(v->n), *(v->d)) == 0);
1209}
1210
1211/* Does "v" represent the integer negative one?
1212 */
1213isl_bool isl_val_is_negone(__isl_keep isl_val *v)
1214{
1215 if (!v)
1216 return isl_bool_error;
1217
1218 return isl_int_is_neg(v->n)(isl_sioimath_sgn(*(v->n)) < 0) && isl_int_abs_eq(v->n, v->d)(isl_sioimath_abs_cmp(*(v->n), *(v->d)) == 0);
1219}
1220
1221/* Is "v" (strictly) positive?
1222 */
1223isl_bool isl_val_is_pos(__isl_keep isl_val *v)
1224{
1225 if (!v)
1226 return isl_bool_error;
1227
1228 return isl_int_is_pos(v->n)(isl_sioimath_sgn(*(v->n)) > 0);
1229}
1230
1231/* Is "v" (strictly) negative?
1232 */
1233isl_bool isl_val_is_neg(__isl_keep isl_val *v)
1234{
1235 if (!v)
1236 return isl_bool_error;
1237
1238 return isl_int_is_neg(v->n)(isl_sioimath_sgn(*(v->n)) < 0);
1239}
1240
1241/* Is "v" non-negative?
1242 */
1243isl_bool isl_val_is_nonneg(__isl_keep isl_val *v)
1244{
1245 if (!v)
1246 return isl_bool_error;
1247
1248 if (isl_val_is_nan(v))
1249 return isl_bool_false;
1250
1251 return isl_int_is_nonneg(v->n)(isl_sioimath_sgn(*(v->n)) >= 0);
1252}
1253
1254/* Is "v" non-positive?
1255 */
1256isl_bool isl_val_is_nonpos(__isl_keep isl_val *v)
1257{
1258 if (!v)
1259 return isl_bool_error;
1260
1261 if (isl_val_is_nan(v))
1262 return isl_bool_false;
1263
1264 return isl_int_is_nonpos(v->n)(isl_sioimath_sgn(*(v->n)) <= 0);
1265}
1266
1267/* Return the sign of "v".
1268 *
1269 * The sign of NaN is undefined.
1270 */
1271int isl_val_sgn(__isl_keep isl_val *v)
1272{
1273 if (!v)
1274 return 0;
1275 if (isl_val_is_zero(v))
1276 return 0;
1277 if (isl_val_is_pos(v))
1278 return 1;
1279 return -1;
1280}
1281
1282/* Is "v1" (strictly) less than "v2"?
1283 */
1284isl_bool isl_val_lt(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1285{
1286 isl_int t;
1287 isl_bool lt;
1288
1289 if (!v1 || !v2)
1290 return isl_bool_error;
1291 if (isl_val_is_int(v1) && isl_val_is_int(v2))
1292 return isl_int_lt(v1->n, v2->n)(isl_sioimath_cmp(*(v1->n), *(v2->n)) < 0);
1293 if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1294 return isl_bool_false;
1295 if (isl_val_eq(v1, v2))
1296 return isl_bool_false;
1297 if (isl_val_is_infty(v2))
1298 return isl_bool_true;
1299 if (isl_val_is_infty(v1))
1300 return isl_bool_false;
1301 if (isl_val_is_neginfty(v1))
1302 return isl_bool_true;
1303 if (isl_val_is_neginfty(v2))
1304 return isl_bool_false;
1305
1306 isl_int_init(t)isl_sioimath_init((t));
1307 isl_int_mul(t, v1->n, v2->d)isl_sioimath_mul((t), *(v1->n), *(v2->d));
1308 isl_int_submul(t, v2->n, v1->d)isl_sioimath_submul((t), *(v2->n), *(v1->d));
1309 lt = isl_int_is_neg(t)(isl_sioimath_sgn(*(t)) < 0);
1310 isl_int_clear(t)isl_sioimath_clear((t));
1311
1312 return lt;
1313}
1314
1315/* Is "v1" (strictly) greater than "v2"?
1316 */
1317isl_bool isl_val_gt(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1318{
1319 return isl_val_lt(v2, v1);
1320}
1321
1322/* Is "v" (strictly) greater than "i"?
1323 */
1324isl_bool isl_val_gt_si(__isl_keep isl_val *v, long i)
1325{
1326 isl_val *vi;
1327 isl_bool res;
1328
1329 if (!v)
1330 return isl_bool_error;
1331 if (isl_val_is_int(v))
1332 return isl_int_cmp_si(v->n, i)isl_sioimath_cmp_si(*(v->n), i) > 0;
1333 if (isl_val_is_nan(v))
1334 return isl_bool_false;
1335 if (isl_val_is_infty(v))
1336 return isl_bool_true;
1337 if (isl_val_is_neginfty(v))
1338 return isl_bool_false;
1339
1340 vi = isl_val_int_from_si(isl_val_get_ctx(v), i);
1341 res = isl_val_gt(v, vi);
1342 isl_val_free(vi);
1343
1344 return res;
1345}
1346
1347/* Is "v1" less than or equal to "v2"?
1348 */
1349isl_bool isl_val_le(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1350{
1351 isl_int t;
1352 isl_bool le;
1353
1354 if (!v1 || !v2)
1355 return isl_bool_error;
1356 if (isl_val_is_int(v1) && isl_val_is_int(v2))
1357 return isl_int_le(v1->n, v2->n)(isl_sioimath_cmp(*(v1->n), *(v2->n)) <= 0);
1358 if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1359 return isl_bool_false;
1360 if (isl_val_eq(v1, v2))
1361 return isl_bool_true;
1362 if (isl_val_is_infty(v2))
1363 return isl_bool_true;
1364 if (isl_val_is_infty(v1))
1365 return isl_bool_false;
1366 if (isl_val_is_neginfty(v1))
1367 return isl_bool_true;
1368 if (isl_val_is_neginfty(v2))
1369 return isl_bool_false;
1370
1371 isl_int_init(t)isl_sioimath_init((t));
1372 isl_int_mul(t, v1->n, v2->d)isl_sioimath_mul((t), *(v1->n), *(v2->d));
1373 isl_int_submul(t, v2->n, v1->d)isl_sioimath_submul((t), *(v2->n), *(v1->d));
1374 le = isl_int_is_nonpos(t)(isl_sioimath_sgn(*(t)) <= 0);
1375 isl_int_clear(t)isl_sioimath_clear((t));
1376
1377 return le;
1378}
1379
1380/* Is "v1" greater than or equal to "v2"?
1381 */
1382isl_bool isl_val_ge(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1383{
1384 return isl_val_le(v2, v1);
1385}
1386
1387/* How does "v" compare to "i"?
1388 *
1389 * Return 1 if v is greater, -1 if v is smaller and 0 if v is equal to i.
1390 *
1391 * If v is NaN (or NULL), then the result is undefined.
1392 */
1393int isl_val_cmp_si(__isl_keep isl_val *v, long i)
1394{
1395 isl_int t;
1396 int cmp;
1397
1398 if (!v)
1399 return 0;
1400 if (isl_val_is_int(v))
1401 return isl_int_cmp_si(v->n, i)isl_sioimath_cmp_si(*(v->n), i);
1402 if (isl_val_is_nan(v))
1403 return 0;
1404 if (isl_val_is_infty(v))
1405 return 1;
1406 if (isl_val_is_neginfty(v))
1407 return -1;
1408
1409 isl_int_init(t)isl_sioimath_init((t));
1410 isl_int_mul_si(t, v->d, i)isl_sioimath_mul_si((t), *(v->d), i);
1411 isl_int_sub(t, v->n, t)isl_sioimath_sub((t), *(v->n), *(t));
1412 cmp = isl_int_sgn(t)isl_sioimath_sgn(*(t));
1413 isl_int_clear(t)isl_sioimath_clear((t));
1414
1415 return cmp;
1416}
1417
1418/* Is "v1" equal to "v2"?
1419 */
1420isl_bool isl_val_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1421{
1422 if (!v1 || !v2)
1423 return isl_bool_error;
1424 if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1425 return isl_bool_false;
1426
1427 return isl_int_eq(v1->n, v2->n)(isl_sioimath_cmp(*(v1->n), *(v2->n)) == 0) && isl_int_eq(v1->d, v2->d)(isl_sioimath_cmp(*(v1->d), *(v2->d)) == 0);
1428}
1429
1430/* Is "v1" equal to "v2" in absolute value?
1431 */
1432isl_bool isl_val_abs_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1433{
1434 if (!v1 || !v2)
1435 return isl_bool_error;
1436 if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1437 return isl_bool_false;
1438
1439 return isl_int_abs_eq(v1->n, v2->n)(isl_sioimath_abs_cmp(*(v1->n), *(v2->n)) == 0) && isl_int_eq(v1->d, v2->d)(isl_sioimath_cmp(*(v1->d), *(v2->d)) == 0);
1440}
1441
1442/* Is "v1" different from "v2"?
1443 */
1444isl_bool isl_val_ne(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
1445{
1446 if (!v1 || !v2)
1447 return isl_bool_error;
1448 if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
1449 return isl_bool_false;
1450
1451 return isl_int_ne(v1->n, v2->n)(isl_sioimath_cmp(*(v1->n), *(v2->n)) != 0) || isl_int_ne(v1->d, v2->d)(isl_sioimath_cmp(*(v1->d), *(v2->d)) != 0);
1452}
1453
1454/* Print a textual representation of "v" onto "p".
1455 */
1456__isl_give isl_printer *isl_printer_print_val(__isl_take isl_printer *p,
1457 __isl_keep isl_val *v)
1458{
1459 int neg;
1460
1461 if (!p || !v)
1462 return isl_printer_free(p);
1463
1464 neg = isl_int_is_neg(v->n)(isl_sioimath_sgn(*(v->n)) < 0);
1465 if (neg) {
1466 p = isl_printer_print_str(p, "-");
1467 isl_int_neg(v->n, v->n)isl_sioimath_neg((v->n), *(v->n));
1468 }
1469 if (isl_int_is_zero(v->d)(isl_sioimath_sgn(*(v->d)) == 0)) {
1470 int sgn = isl_int_sgn(v->n)isl_sioimath_sgn(*(v->n));
1471 p = isl_printer_print_str(p, sgn < 0 ? "-infty" :
1472 sgn == 0 ? "NaN" : "infty");
1473 } else
1474 p = isl_printer_print_isl_int(p, v->n);
1475 if (neg)
1476 isl_int_neg(v->n, v->n)isl_sioimath_neg((v->n), *(v->n));
1477 if (!isl_int_is_zero(v->d)(isl_sioimath_sgn(*(v->d)) == 0) && !isl_int_is_one(v->d)(isl_sioimath_cmp_si(*(v->d), 1) == 0)) {
1478 p = isl_printer_print_str(p, "/");
1479 p = isl_printer_print_isl_int(p, v->d);
1480 }
1481
1482 return p;
1483}
1484
1485/* Is "val1" (obviously) equal to "val2"?
1486 *
1487 * This is a private copy of isl_val_eq for use in the generic
1488 * isl_multi_*_plain_is_equal instantiated for isl_val.
1489 */
1490int isl_val_plain_is_equal(__isl_keep isl_val *val1, __isl_keep isl_val *val2)
1491{
1492 return isl_val_eq(val1, val2);
1493}
1494
1495/* Does "v" have any non-zero coefficients
1496 * for any dimension in the given range?
1497 *
1498 * This function is only meant to be used in the generic isl_multi_*
1499 * functions which have to deal with base objects that have an associated
1500 * space. Since an isl_val does not have any coefficients, this function
1501 * always returns isl_bool_false.
1502 */
1503isl_bool isl_val_involves_dims(__isl_keep isl_val *v, enum isl_dim_type type,
1504 unsigned first, unsigned n)
1505{
1506 if (!v)
1507 return isl_bool_error;
1508
1509 return isl_bool_false;
1510}
1511
1512/* Insert "n" dimensions of type "type" at position "first".
1513 *
1514 * This function is only meant to be used in the generic isl_multi_*
1515 * functions which have to deal with base objects that have an associated
1516 * space. Since an isl_val does not have an associated space, this function
1517 * does not do anything.
1518 */
1519__isl_give isl_val *isl_val_insert_dims(__isl_take isl_val *v,
1520 enum isl_dim_type type, unsigned first, unsigned n)
1521{
1522 return v;
1523}
1524
1525/* Drop the "n" first dimensions of type "type" at position "first".
1526 *
1527 * This function is only meant to be used in the generic isl_multi_*
1528 * functions which have to deal with base objects that have an associated
1529 * space. Since an isl_val does not have an associated space, this function
1530 * does not do anything.
1531 */
1532__isl_give isl_val *isl_val_drop_dims(__isl_take isl_val *v,
1533 enum isl_dim_type type, unsigned first, unsigned n)
1534{
1535 return v;
1536}
1537
1538/* Change the name of the dimension of type "type" at position "pos" to "s".
1539 *
1540 * This function is only meant to be used in the generic isl_multi_*
1541 * functions which have to deal with base objects that have an associated
1542 * space. Since an isl_val does not have an associated space, this function
1543 * does not do anything.
1544 */
1545__isl_give isl_val *isl_val_set_dim_name(__isl_take isl_val *v,
1546 enum isl_dim_type type, unsigned pos, const char *s)
1547{
1548 return v;
1549}
1550
1551/* Return the space of "v".
1552 *
1553 * This function is only meant to be used in the generic isl_multi_*
1554 * functions which have to deal with base objects that have an associated
1555 * space. The conditions surrounding the call to this function make sure
1556 * that this function will never actually get called. We return a valid
1557 * space anyway, just in case.
1558 */
1559__isl_give isl_space *isl_val_get_space(__isl_keep isl_val *v)
1560{
1561 if (!v)
1562 return NULL((void*)0);
1563
1564 return isl_space_params_alloc(isl_val_get_ctx(v), 0);
1565}
1566
1567/* Reset the domain space of "v" to "space".
1568 *
1569 * This function is only meant to be used in the generic isl_multi_*
1570 * functions which have to deal with base objects that have an associated
1571 * space. Since an isl_val does not have an associated space, this function
1572 * does not do anything, apart from error handling and cleaning up memory.
1573 */
1574__isl_give isl_val *isl_val_reset_domain_space(__isl_take isl_val *v,
1575 __isl_take isl_space *space)
1576{
1577 if (!space)
1578 return isl_val_free(v);
1579 isl_space_free(space);
1580 return v;
1581}
1582
1583/* Align the parameters of "v" to those of "space".
1584 *
1585 * This function is only meant to be used in the generic isl_multi_*
1586 * functions which have to deal with base objects that have an associated
1587 * space. Since an isl_val does not have an associated space, this function
1588 * does not do anything, apart from error handling and cleaning up memory.
1589 * Note that the conditions surrounding the call to this function make sure
1590 * that this function will never actually get called.
1591 */
1592__isl_give isl_val *isl_val_align_params(__isl_take isl_val *v,
1593 __isl_take isl_space *space)
1594{
1595 if (!space)
1596 return isl_val_free(v);
1597 isl_space_free(space);
1598 return v;
1599}
1600
1601/* Reorder the dimensions of the domain of "v" according
1602 * to the given reordering.
1603 *
1604 * This function is only meant to be used in the generic isl_multi_*
1605 * functions which have to deal with base objects that have an associated
1606 * space. Since an isl_val does not have an associated space, this function
1607 * does not do anything, apart from error handling and cleaning up memory.
1608 */
1609__isl_give isl_val *isl_val_realign_domain(__isl_take isl_val *v,
1610 __isl_take isl_reordering *r)
1611{
1612 if (!r)
1613 return isl_val_free(v);
1614 isl_reordering_free(r);
1615 return v;
1616}
1617
1618/* Return an isl_val that is zero on "ls".
1619 *
1620 * This function is only meant to be used in the generic isl_multi_*
1621 * functions which have to deal with base objects that have an associated
1622 * space. Since an isl_val does not have an associated space, this function
1623 * simply returns a zero isl_val in the same context as "ls".
1624 */
1625__isl_give isl_val *isl_val_zero_on_domain(__isl_take isl_local_space *ls)
1626{
1627 isl_ctx *ctx;
1628
1629 if (!ls)
1630 return NULL((void*)0);
1631 ctx = isl_local_space_get_ctx(ls);
1632 isl_local_space_free(ls);
1633 return isl_val_zero(ctx);
1634}
1635
1636/* Do the parameters of "v" match those of "space"?
1637 *
1638 * This function is only meant to be used in the generic isl_multi_*
1639 * functions which have to deal with base objects that have an associated
1640 * space. Since an isl_val does not have an associated space, this function
1641 * simply returns true, except if "v" or "space" are NULL.
1642 */
1643isl_bool isl_val_matching_params(__isl_keep isl_val *v,
1644 __isl_keep isl_space *space)
1645{
1646 if (!v || !space)
1647 return isl_bool_error;
1648 return isl_bool_true;
1649}
1650
1651/* Check that the domain space of "v" matches "space".
1652 *
1653 * This function is only meant to be used in the generic isl_multi_*
1654 * functions which have to deal with base objects that have an associated
1655 * space. Since an isl_val does not have an associated space, this function
1656 * simply returns 0, except if "v" or "space" are NULL.
1657 */
1658isl_stat isl_val_check_match_domain_space(__isl_keep isl_val *v,
1659 __isl_keep isl_space *space)
1660{
1661 if (!v || !space)
1662 return isl_stat_error;
1663 return isl_stat_ok;
1664}
1665
1666#define isl_val_involves_nanisl_val_is_nan isl_val_is_nan
1667
1668#undef BASEval
1669#define BASEval val
1670
1671#define NO_DOMAIN
1672#define NO_IDENTITY
1673#define NO_FROM_BASE
1674#define NO_MOVE_DIMS
1675#include <isl_multi_no_explicit_domain.c>
1676#include <isl_multi_templ.c>
1677#include <isl_multi_dims.c>
1678
1679/* Apply "fn" to each of the elements of "mv" with as second argument "v".
1680 */
1681static __isl_give isl_multi_val *isl_multi_val_fn_val(
1682 __isl_take isl_multi_val *mv,
1683 __isl_give isl_val *(*fn)(__isl_take isl_val *v1,
1684 __isl_take isl_val *v2),
1685 __isl_take isl_val *v)
1686{
1687 int i;
1688
1689 mv = isl_multi_val_cow(mv);
1690 if (!mv || !v)
1691 goto error;
1692
1693 for (i = 0; i < mv->n; ++i) {
1694 mv->u.p[i] = fn(mv->u.p[i], isl_val_copy(v));
1695 if (!mv->u.p[i])
1696 goto error;
1697 }
1698
1699 isl_val_free(v);
1700 return mv;
1701error:
1702 isl_val_free(v);
1703 isl_multi_val_free(mv);
1704 return NULL((void*)0);
1705}
1706
1707/* Add "v" to each of the elements of "mv".
1708 */
1709__isl_give isl_multi_val *isl_multi_val_add_val(__isl_take isl_multi_val *mv,
1710 __isl_take isl_val *v)
1711{
1712 if (!v)
1713 return isl_multi_val_free(mv);
1714 if (isl_val_is_zero(v)) {
1715 isl_val_free(v);
1716 return mv;
1717 }
1718 return isl_multi_val_fn_val(mv, &isl_val_add, v);
1719}
1720
1721/* Reduce the elements of "mv" modulo "v".
1722 */
1723__isl_give isl_multi_val *isl_multi_val_mod_val(__isl_take isl_multi_val *mv,
1724 __isl_take isl_val *v)
1725{
1726 return isl_multi_val_fn_val(mv, &isl_val_mod, v);
1727}

/build/llvm-toolchain-snapshot-8~svn350071/tools/polly/lib/External/isl/isl_int_sioimath.h

1/*
2 * Copyright 2015 INRIA Paris-Rocquencourt
3 *
4 * Use of this software is governed by the MIT license
5 *
6 * Written by Michael Kruse, INRIA Paris-Rocquencourt,
7 * Domaine de Voluceau, Rocquenqourt, B.P. 105,
8 * 78153 Le Chesnay Cedex France
9 */
10#ifndef ISL_INT_SIOIMATH_H
11#define ISL_INT_SIOIMATH_H
12
13#include <inttypes.h>
14#include <limits.h>
15#include <stdint.h>
16#include <stdlib.h>
17
18#include <isl_imath.h>
19#include <isl/hash.h>
20
21#define ARRAY_SIZE(array)(sizeof(array)/sizeof(*array)) (sizeof(array)/sizeof(*array))
22
23/* Visual Studio before VS2015 does not support the inline keyword when
24 * compiling in C mode because it was introduced in C99 which it does not
25 * officially support. Instead, it has a proprietary extension using __inline.
26 */
27#if defined(_MSC_VER) && (_MSC_VER < 1900)
28#define inline __inline
29#endif
30
31/* The type to represent integers optimized for small values. It is either a
32 * pointer to an mp_int ( = mpz_t*; big representation) or an int32_t (small
33 * represenation) with a discriminator at the least significant bit. In big
34 * representation it will be always zero because of heap alignment. It is set
35 * to 1 for small representation and use the 32 most significant bits for the
36 * int32_t.
37 *
38 * Structure on 64 bit machines, with 8-byte aligment (3 bits):
39 *
40 * Big representation:
41 * MSB LSB
42 * |------------------------------------------------------------000
43 * | mpz_t* |
44 * | != NULL |
45 *
46 * Small representation:
47 * MSB 32 LSB
48 * |------------------------------|00000000000000000000000000000001
49 * | int32_t |
50 * | 2147483647 ... -2147483647 |
51 * ^
52 * |
53 * discriminator bit
54 *
55 * On 32 bit machines isl_sioimath type is blown up to 8 bytes, i.e.
56 * isl_sioimath is guaranteed to be at least 8 bytes. This is to ensure the
57 * int32_t can be hidden in that type without data loss. In the future we might
58 * optimize this to use 31 hidden bits in a 32 bit pointer. We may also use 63
59 * bits on 64 bit machines, but this comes with the cost of additional overflow
60 * checks because there is no standardized 128 bit integer we could expand to.
61 *
62 * We use native integer types and avoid union structures to avoid assumptions
63 * on the machine's endianness.
64 *
65 * This implementation makes the following assumptions:
66 * - long can represent any int32_t
67 * - mp_small is signed long
68 * - mp_usmall is unsigned long
69 * - adresses returned by malloc are aligned to 2-byte boundaries (leastmost
70 * bit is zero)
71 */
72#if UINT64_MAX(18446744073709551615UL) > UINTPTR_MAX(18446744073709551615UL)
73typedef uint64_t isl_sioimath;
74#else
75typedef uintptr_t isl_sioimath;
76#endif
77
78/* The negation of the smallest possible number in int32_t, INT32_MIN
79 * (0x80000000u, -2147483648), cannot be represented in an int32_t, therefore
80 * every operation that may produce this value needs to special-case it.
81 * The operations are:
82 * abs(INT32_MIN)
83 * -INT32_MIN (negation)
84 * -1 * INT32_MIN (multiplication)
85 * INT32_MIN/-1 (any division: divexact, fdiv, cdiv, tdiv)
86 * To avoid checking these cases, we exclude INT32_MIN from small
87 * representation.
88 */
89#define ISL_SIOIMATH_SMALL_MIN(-(2147483647)) (-INT32_MAX(2147483647))
90
91/* Largest possible number in small representation */
92#define ISL_SIOIMATH_SMALL_MAX(2147483647) INT32_MAX(2147483647)
93
94/* Used for function parameters the function modifies. */
95typedef isl_sioimath *isl_sioimath_ptr;
96
97/* Used for function parameters that are read-only. */
98typedef isl_sioimath isl_sioimath_src;
99
100/* Return whether the argument is stored in small representation.
101 */
102inline int isl_sioimath_is_small(isl_sioimath val)
103{
104 return val & 0x00000001;
105}
106
107/* Return whether the argument is stored in big representation.
108 */
109inline int isl_sioimath_is_big(isl_sioimath val)
110{
111 return !isl_sioimath_is_small(val);
112}
113
114/* Get the number of an isl_int in small representation. Result is undefined if
115 * val is not stored in that format.
116 */
117inline int32_t isl_sioimath_get_small(isl_sioimath val)
118{
119 return val >> 32;
120}
121
122/* Get the number of an in isl_int in big representation. Result is undefined if
123 * val is not stored in that format.
124 */
125inline mp_int isl_sioimath_get_big(isl_sioimath val)
126{
127 return (mp_int)(uintptr_t) val;
128}
129
130/* Return 1 if val is stored in small representation and store its value to
131 * small. We rely on the compiler to optimize the isl_sioimath_get_small such
132 * that the shift is moved into the branch that executes in case of small
133 * representation. If there is no such branch, then a single shift is still
134 * cheaper than introducing branching code.
135 */
136inline int isl_sioimath_decode_small(isl_sioimath val, int32_t *small)
137{
138 *small = isl_sioimath_get_small(val);
139 return isl_sioimath_is_small(val);
140}
141
142/* Return 1 if val is stored in big representation and store its value to big.
143 */
144inline int isl_sioimath_decode_big(isl_sioimath val, mp_int *big)
145{
146 *big = isl_sioimath_get_big(val);
147 return isl_sioimath_is_big(val);
148}
149
150/* Encode a small representation into an isl_int.
151 */
152inline isl_sioimath isl_sioimath_encode_small(int32_t val)
153{
154 return ((isl_sioimath) val) << 32 | 0x00000001;
155}
156
157/* Encode a big representation.
158 */
159inline isl_sioimath isl_sioimath_encode_big(mp_int val)
160{
161 return (isl_sioimath)(uintptr_t) val;
162}
163
164/* A common situation is to call an IMath function with at least one argument
165 * that is currently in small representation or an integer parameter, i.e. a big
166 * representation of the same number is required. Promoting the original
167 * argument comes with multiple problems, such as modifying a read-only
168 * argument, the responsibility of deallocation and the execution cost. Instead,
169 * we make a copy by 'faking' the IMath internal structure.
170 *
171 * We reserve the maximum number of required digits on the stack to avoid heap
172 * allocations.
173 *
174 * mp_digit can be uint32_t or uint16_t. This code must work for little and big
175 * endian digits. The structure for an uint64_t argument and 32-bit mp_digits is
176 * sketched below.
177 *
178 * |----------------------------|
179 * uint64_t
180 *
181 * |-------------||-------------|
182 * mp_digit mp_digit
183 * digits[1] digits[0]
184 * Most sig digit Least sig digit
185 */
186typedef struct {
187 mpz_t big;
188 mp_digit digits[(sizeof(uintmax_t) + sizeof(mp_digit) - 1) /
189 sizeof(mp_digit)];
190} isl_sioimath_scratchspace_t;
191
192/* Convert a native integer to IMath's digit representation. A native integer
193 * might be big- or little endian, but IMath always stores the least significant
194 * digit in the lowest array indices. memcpy therefore is not possible.
195 *
196 * We also have to consider that long and mp_digit can be of different sizes,
197 * depending on the compiler (LP64, LLP64) and IMath's USE_64BIT_WORDS. This
198 * macro should work for all of them.
199 *
200 * "used" is set to the number of written digits. It must be minimal (IMath
201 * checks zeroness using the used field), but always at least one. Also note
202 * that the result of num>>(sizeof(num)*CHAR_BIT) is undefined.
203 */
204#define ISL_SIOIMATH_TO_DIGITS(num, digits, used)do { int i = 0; do { (digits)[i] = ((num) >> (sizeof(mp_digit
) * 8 * i)); i += 1; if (i >= (sizeof(num) + sizeof(mp_digit
) - 1) / sizeof(mp_digit)) break; if (((num) >> (sizeof
(mp_digit) * 8 * i)) == 0) break; } while (1); (used) = i; } while
(0)
\
205 do { \
206 int i = 0; \
207 do { \
208 (digits)[i] = \
209 ((num) >> (sizeof(mp_digit) * CHAR_BIT8 * i)); \
210 i += 1; \
211 if (i >= (sizeof(num) + sizeof(mp_digit) - 1) / \
212 sizeof(mp_digit)) \
213 break; \
214 if (((num) >> (sizeof(mp_digit) * CHAR_BIT8 * i)) == 0) \
215 break; \
216 } while (1); \
217 (used) = i; \
218 } while (0)
219
220inline void isl_siomath_uint32_to_digits(uint32_t num, mp_digit *digits,
221 mp_size *used)
222{
223 ISL_SIOIMATH_TO_DIGITS(num, digits, *used)do { int i = 0; do { (digits)[i] = ((num) >> (sizeof(mp_digit
) * 8 * i)); i += 1; if (i >= (sizeof(num) + sizeof(mp_digit
) - 1) / sizeof(mp_digit)) break; if (((num) >> (sizeof
(mp_digit) * 8 * i)) == 0) break; } while (1); (*used) = i; }
while (0)
;
8
Taking true branch
9
Execution continues on line 223
10
Loop condition is false. Exiting loop
224}
225
226inline void isl_siomath_ulong_to_digits(unsigned long num, mp_digit *digits,
227 mp_size *used)
228{
229 ISL_SIOIMATH_TO_DIGITS(num, digits, *used)do { int i = 0; do { (digits)[i] = ((num) >> (sizeof(mp_digit
) * 8 * i)); i += 1; if (i >= (sizeof(num) + sizeof(mp_digit
) - 1) / sizeof(mp_digit)) break; if (((num) >> (sizeof
(mp_digit) * 8 * i)) == 0) break; } while (1); (*used) = i; }
while (0)
;
230}
231
232inline void isl_siomath_uint64_to_digits(uint64_t num, mp_digit *digits,
233 mp_size *used)
234{
235 ISL_SIOIMATH_TO_DIGITS(num, digits, *used)do { int i = 0; do { (digits)[i] = ((num) >> (sizeof(mp_digit
) * 8 * i)); i += 1; if (i >= (sizeof(num) + sizeof(mp_digit
) - 1) / sizeof(mp_digit)) break; if (((num) >> (sizeof
(mp_digit) * 8 * i)) == 0) break; } while (1); (*used) = i; }
while (0)
;
236}
237
238/* Get the IMath representation of an isl_int without modifying it.
239 * For the case it is not in big representation yet, pass some scratch space we
240 * can use to store the big representation in.
241 * In order to avoid requiring init and free on the scratch space, we directly
242 * modify the internal representation.
243 *
244 * The name derives from its indented use: getting the big representation of an
245 * input (src) argument.
246 */
247inline mp_int isl_sioimath_bigarg_src(isl_sioimath arg,
248 isl_sioimath_scratchspace_t *scratch)
249{
250 mp_int big;
251 int32_t small;
252 uint32_t num;
253
254 if (isl_sioimath_decode_big(arg, &big))
255 return big;
256
257 small = isl_sioimath_get_small(arg);
258 scratch->big.digits = scratch->digits;
259 scratch->big.alloc = ARRAY_SIZE(scratch->digits)(sizeof(scratch->digits)/sizeof(*scratch->digits));
260 if (small >= 0) {
261 scratch->big.sign = MP_ZPOS;
262 num = small;
263 } else {
264 scratch->big.sign = MP_NEG;
265 num = -small;
266 }
267
268 isl_siomath_uint32_to_digits(num, scratch->digits, &scratch->big.used);
269 return &scratch->big;
270}
271
272/* Create a temporary IMath mp_int for a signed long.
273 */
274inline mp_int isl_sioimath_siarg_src(signed long arg,
275 isl_sioimath_scratchspace_t *scratch)
276{
277 unsigned long num;
278
279 scratch->big.digits = scratch->digits;
280 scratch->big.alloc = ARRAY_SIZE(scratch->digits)(sizeof(scratch->digits)/sizeof(*scratch->digits));
281 if (arg >= 0) {
282 scratch->big.sign = MP_ZPOS;
283 num = arg;
284 } else {
285 scratch->big.sign = MP_NEG;
286 num = (arg == LONG_MIN(-9223372036854775807L -1L)) ? ((unsigned long) LONG_MAX9223372036854775807L) + 1 : -arg;
287 }
288
289 isl_siomath_ulong_to_digits(num, scratch->digits, &scratch->big.used);
290 return &scratch->big;
291}
292
293/* Create a temporary IMath mp_int for an int64_t.
294 */
295inline mp_int isl_sioimath_si64arg_src(int64_t arg,
296 isl_sioimath_scratchspace_t *scratch)
297{
298 uint64_t num;
299
300 scratch->big.digits = scratch->digits;
301 scratch->big.alloc = ARRAY_SIZE(scratch->digits)(sizeof(scratch->digits)/sizeof(*scratch->digits));
302 if (arg >= 0) {
303 scratch->big.sign = MP_ZPOS;
304 num = arg;
305 } else {
306 scratch->big.sign = MP_NEG;
307 num = (arg == INT64_MIN(-9223372036854775807L -1)) ? ((uint64_t) INT64_MAX(9223372036854775807L)) + 1 : -arg;
308 }
309
310 isl_siomath_uint64_to_digits(num, scratch->digits, &scratch->big.used);
311 return &scratch->big;
312}
313
314/* Create a temporary IMath mp_int for an unsigned long.
315 */
316inline mp_int isl_sioimath_uiarg_src(unsigned long arg,
317 isl_sioimath_scratchspace_t *scratch)
318{
319 scratch->big.digits = scratch->digits;
320 scratch->big.alloc = ARRAY_SIZE(scratch->digits)(sizeof(scratch->digits)/sizeof(*scratch->digits));
321 scratch->big.sign = MP_ZPOS;
322
323 isl_siomath_ulong_to_digits(arg, scratch->digits, &scratch->big.used);
324 return &scratch->big;
325}
326
327/* Ensure big representation. Does not preserve the current number.
328 * Callers may use the fact that the value _is_ preserved if the presentation
329 * was big before.
330 */
331inline mp_int isl_sioimath_reinit_big(isl_sioimath_ptr ptr)
332{
333 if (isl_sioimath_is_small(*ptr))
334 *ptr = isl_sioimath_encode_big(mp_int_alloc());
335 return isl_sioimath_get_big(*ptr);
336}
337
338/* Set ptr to a number in small representation.
339 */
340inline void isl_sioimath_set_small(isl_sioimath_ptr ptr, int32_t val)
341{
342 if (isl_sioimath_is_big(*ptr))
343 mp_int_free(isl_sioimath_get_big(*ptr));
344 *ptr = isl_sioimath_encode_small(val);
345}
346
347/* Set ptr to val, choosing small representation if possible.
348 */
349inline void isl_sioimath_set_int32(isl_sioimath_ptr ptr, int32_t val)
350{
351 if (ISL_SIOIMATH_SMALL_MIN(-(2147483647)) <= val && val <= ISL_SIOIMATH_SMALL_MAX(2147483647)) {
352 isl_sioimath_set_small(ptr, val);
353 return;
354 }
355
356 mp_int_init_value(isl_sioimath_reinit_big(ptr), val);
357}
358
359/* Assign an int64_t number using small representation if possible.
360 */
361inline void isl_sioimath_set_int64(isl_sioimath_ptr ptr, int64_t val)
362{
363 if (ISL_SIOIMATH_SMALL_MIN(-(2147483647)) <= val && val <= ISL_SIOIMATH_SMALL_MAX(2147483647)) {
364 isl_sioimath_set_small(ptr, val);
365 return;
366 }
367
368 isl_sioimath_scratchspace_t scratch;
369 mp_int_copy(isl_sioimath_si64arg_src(val, &scratch),
370 isl_sioimath_reinit_big(ptr));
371}
372
373/* Convert to big representation while preserving the current number.
374 */
375inline void isl_sioimath_promote(isl_sioimath_ptr dst)
376{
377 int32_t small;
378
379 if (isl_sioimath_is_big(*dst))
380 return;
381
382 small = isl_sioimath_get_small(*dst);
383 mp_int_set_value(isl_sioimath_reinit_big(dst), small);
384}
385
386/* Convert to small representation while preserving the current number. Does
387 * nothing if dst doesn't fit small representation.
388 */
389inline void isl_sioimath_try_demote(isl_sioimath_ptr dst)
390{
391 mp_small small;
392
393 if (isl_sioimath_is_small(*dst))
394 return;
395
396 if (mp_int_to_int(isl_sioimath_get_big(*dst), &small) != MP_OK)
397 return;
398
399 if (ISL_SIOIMATH_SMALL_MIN(-(2147483647)) <= small && small <= ISL_SIOIMATH_SMALL_MAX(2147483647))
400 isl_sioimath_set_small(dst, small);
401}
402
403/* Initialize an isl_int. The implicit value is 0 in small representation.
404 */
405inline void isl_sioimath_init(isl_sioimath_ptr dst)
406{
407 *dst = isl_sioimath_encode_small(0);
408}
409
410/* Free the resources taken by an isl_int.
411 */
412inline void isl_sioimath_clear(isl_sioimath_ptr dst)
413{
414 if (isl_sioimath_is_small(*dst))
415 return;
416
417 mp_int_free(isl_sioimath_get_big(*dst));
418}
419
420/* Copy the value of one isl_int to another.
421 */
422inline void isl_sioimath_set(isl_sioimath_ptr dst, isl_sioimath_src val)
423{
424 if (isl_sioimath_is_small(val)) {
425 isl_sioimath_set_small(dst, isl_sioimath_get_small(val));
426 return;
427 }
428
429 mp_int_copy(isl_sioimath_get_big(val), isl_sioimath_reinit_big(dst));
430}
431
432/* Store a signed long into an isl_int.
433 */
434inline void isl_sioimath_set_si(isl_sioimath_ptr dst, long val)
435{
436 if (ISL_SIOIMATH_SMALL_MIN(-(2147483647)) <= val && val <= ISL_SIOIMATH_SMALL_MAX(2147483647)) {
437 isl_sioimath_set_small(dst, val);
438 return;
439 }
440
441 mp_int_set_value(isl_sioimath_reinit_big(dst), val);
442}
443
444/* Store an unsigned long into an isl_int.
445 */
446inline void isl_sioimath_set_ui(isl_sioimath_ptr dst, unsigned long val)
447{
448 if (val <= ISL_SIOIMATH_SMALL_MAX(2147483647)) {
449 isl_sioimath_set_small(dst, val);
450 return;
451 }
452
453 mp_int_set_uvalue(isl_sioimath_reinit_big(dst), val);
454}
455
456/* Return whether a number can be represented by a signed long.
457 */
458inline int isl_sioimath_fits_slong(isl_sioimath_src val)
459{
460 mp_small dummy;
461
462 if (isl_sioimath_is_small(val))
463 return 1;
464
465 return mp_int_to_int(isl_sioimath_get_big(val), &dummy) == MP_OK;
466}
467
468/* Return a number as signed long. Result is undefined if the number cannot be
469 * represented as long.
470 */
471inline long isl_sioimath_get_si(isl_sioimath_src val)
472{
473 mp_small result;
474
475 if (isl_sioimath_is_small(val))
476 return isl_sioimath_get_small(val);
477
478 mp_int_to_int(isl_sioimath_get_big(val), &result);
479 return result;
480}
481
482/* Return whether a number can be represented as unsigned long.
483 */
484inline int isl_sioimath_fits_ulong(isl_sioimath_src val)
485{
486 mp_usmall dummy;
487
488 if (isl_sioimath_is_small(val))
489 return isl_sioimath_get_small(val) >= 0;
490
491 return mp_int_to_uint(isl_sioimath_get_big(val), &dummy) == MP_OK;
492}
493
494/* Return a number as unsigned long. Result is undefined if the number cannot be
495 * represented as unsigned long.
496 */
497inline unsigned long isl_sioimath_get_ui(isl_sioimath_src val)
498{
499 mp_usmall result;
500
501 if (isl_sioimath_is_small(val))
502 return isl_sioimath_get_small(val);
503
504 mp_int_to_uint(isl_sioimath_get_big(val), &result);
505 return result;
506}
507
508/* Return a number as floating point value.
509 */
510inline double isl_sioimath_get_d(isl_sioimath_src val)
511{
512 mp_int big;
513 double result = 0;
514 int i;
515
516 if (isl_sioimath_is_small(val))
517 return isl_sioimath_get_small(val);
518
519 big = isl_sioimath_get_big(val);
520 for (i = 0; i < big->used; ++i)
521 result = result * (double) ((uintmax_t) MP_DIGIT_MAX((4294967295U) * 1UL) + 1) +
522 (double) big->digits[i];
523
524 if (big->sign == MP_NEG)
525 result = -result;
526
527 return result;
528}
529
530/* Format a number as decimal string.
531 *
532 * The largest possible string from small representation is 12 characters
533 * ("-2147483647").
534 */
535inline char *isl_sioimath_get_str(isl_sioimath_src val)
536{
537 char *result;
538
539 if (isl_sioimath_is_small(val)) {
540 result = malloc(12);
541 snprintf(result, 12, "%" PRIi32"i", isl_sioimath_get_small(val));
542 return result;
543 }
544
545 return impz_get_str(NULL((void*)0), 10, isl_sioimath_get_big(val));
546}
547
548/* Return the absolute value.
549 */
550inline void isl_sioimath_abs(isl_sioimath_ptr dst, isl_sioimath_src arg)
551{
552 if (isl_sioimath_is_small(arg)) {
553 isl_sioimath_set_small(dst, labs(isl_sioimath_get_small(arg)));
554 return;
555 }
556
557 mp_int_abs(isl_sioimath_get_big(arg), isl_sioimath_reinit_big(dst));
558}
559
560/* Return the negation of a number.
561 */
562inline void isl_sioimath_neg(isl_sioimath_ptr dst, isl_sioimath_src arg)
563{
564 if (isl_sioimath_is_small(arg)) {
565 isl_sioimath_set_small(dst, -isl_sioimath_get_small(arg));
566 return;
567 }
568
569 mp_int_neg(isl_sioimath_get_big(arg), isl_sioimath_reinit_big(dst));
570}
571
572/* Swap two isl_ints.
573 *
574 * isl_sioimath can be copied bytewise; nothing depends on its address. It can
575 * also be stored in a CPU register.
576 */
577inline void isl_sioimath_swap(isl_sioimath_ptr lhs, isl_sioimath_ptr rhs)
578{
579 isl_sioimath tmp = *lhs;
580 *lhs = *rhs;
581 *rhs = tmp;
582}
583
584/* Add an unsigned long to the number.
585 *
586 * On LP64 unsigned long exceeds the range of an int64_t, therefore we check in
587 * advance whether small representation possibly overflows.
588 */
589inline void isl_sioimath_add_ui(isl_sioimath_ptr dst, isl_sioimath lhs,
590 unsigned long rhs)
591{
592 int32_t smalllhs;
593 isl_sioimath_scratchspace_t lhsscratch;
594
595 if (isl_sioimath_decode_small(lhs, &smalllhs) &&
596 (rhs <= (uint64_t) INT64_MAX(9223372036854775807L) - (uint64_t) ISL_SIOIMATH_SMALL_MAX(2147483647))) {
597 isl_sioimath_set_int64(dst, (int64_t) smalllhs + rhs);
598 return;
599 }
600
601 impz_add_ui(isl_sioimath_reinit_big(dst),
602 isl_sioimath_bigarg_src(lhs, &lhsscratch), rhs);
603 isl_sioimath_try_demote(dst);
604}
605
606/* Subtract an unsigned long.
607 *
608 * On LP64 unsigned long exceeds the range of an int64_t. If
609 * ISL_SIOIMATH_SMALL_MIN-rhs>=INT64_MIN we can do the calculation using int64_t
610 * without risking an overflow.
611 */
612inline void isl_sioimath_sub_ui(isl_sioimath_ptr dst, isl_sioimath lhs,
613 unsigned long rhs)
614{
615 int32_t smalllhs;
616 isl_sioimath_scratchspace_t lhsscratch;
617
618 if (isl_sioimath_decode_small(lhs, &smalllhs) &&
619 (rhs < (uint64_t) INT64_MIN(-9223372036854775807L -1) - (uint64_t) ISL_SIOIMATH_SMALL_MIN(-(2147483647)))) {
620 isl_sioimath_set_int64(dst, (int64_t) smalllhs - rhs);
621 return;
622 }
623
624 impz_sub_ui(isl_sioimath_reinit_big(dst),
625 isl_sioimath_bigarg_src(lhs, &lhsscratch), rhs);
626 isl_sioimath_try_demote(dst);
627}
628
629/* Sum of two isl_ints.
630 */
631inline void isl_sioimath_add(isl_sioimath_ptr dst, isl_sioimath_src lhs,
632 isl_sioimath_src rhs)
633{
634 isl_sioimath_scratchspace_t scratchlhs, scratchrhs;
635 int32_t smalllhs, smallrhs;
636
637 if (isl_sioimath_decode_small(lhs, &smalllhs) &&
638 isl_sioimath_decode_small(rhs, &smallrhs)) {
639 isl_sioimath_set_int64(
640 dst, (int64_t) smalllhs + (int64_t) smallrhs);
641 return;
642 }
643
644 mp_int_add(isl_sioimath_bigarg_src(lhs, &scratchlhs),
645 isl_sioimath_bigarg_src(rhs, &scratchrhs),
646 isl_sioimath_reinit_big(dst));
647 isl_sioimath_try_demote(dst);
648}
649
650/* Subtract two isl_ints.
651 */
652inline void isl_sioimath_sub(isl_sioimath_ptr dst, isl_sioimath_src lhs,
653 isl_sioimath_src rhs)
654{
655 isl_sioimath_scratchspace_t scratchlhs, scratchrhs;
656 int32_t smalllhs, smallrhs;
657
658 if (isl_sioimath_decode_small(lhs, &smalllhs) &&
659 isl_sioimath_decode_small(rhs, &smallrhs)) {
660 isl_sioimath_set_int64(
661 dst, (int64_t) smalllhs - (int64_t) smallrhs);
662 return;
663 }
664
665 mp_int_sub(isl_sioimath_bigarg_src(lhs, &scratchlhs),
666 isl_sioimath_bigarg_src(rhs, &scratchrhs),
667 isl_sioimath_reinit_big(dst));
668 isl_sioimath_try_demote(dst);
669}
670
671/* Multiply two isl_ints.
672 */
673inline void isl_sioimath_mul(isl_sioimath_ptr dst, isl_sioimath_src lhs,
674 isl_sioimath_src rhs)
675{
676 isl_sioimath_scratchspace_t scratchlhs, scratchrhs;
677 int32_t smalllhs, smallrhs;
678
679 if (isl_sioimath_decode_small(lhs, &smalllhs) &&
680 isl_sioimath_decode_small(rhs, &smallrhs)) {
681 isl_sioimath_set_int64(
682 dst, (int64_t) smalllhs * (int64_t) smallrhs);
683 return;
684 }
685
686 mp_int_mul(isl_sioimath_bigarg_src(lhs, &scratchlhs),
687 isl_sioimath_bigarg_src(rhs, &scratchrhs),
688 isl_sioimath_reinit_big(dst));
689 isl_sioimath_try_demote(dst);
690}
691
692/* Shift lhs by rhs bits to the left and store the result in dst. Effectively,
693 * this operation computes 'lhs * 2^rhs'.
694 */
695inline void isl_sioimath_mul_2exp(isl_sioimath_ptr dst, isl_sioimath lhs,
696 unsigned long rhs)
697{
698 isl_sioimath_scratchspace_t scratchlhs;
699 int32_t smalllhs;
700
701 if (isl_sioimath_decode_small(lhs, &smalllhs) && (rhs <= 32ul)) {
702 isl_sioimath_set_int64(dst, ((int64_t) smalllhs) << rhs);
703 return;
704 }
705
706 mp_int_mul_pow2(isl_sioimath_bigarg_src(lhs, &scratchlhs), rhs,
707 isl_sioimath_reinit_big(dst));
708}
709
710/* Multiply an isl_int and a signed long.
711 */
712inline void isl_sioimath_mul_si(isl_sioimath_ptr dst, isl_sioimath lhs,
713 signed long rhs)
714{
715 isl_sioimath_scratchspace_t scratchlhs, scratchrhs;
716 int32_t smalllhs;
717
718 if (isl_sioimath_decode_small(lhs, &smalllhs) && (rhs > LONG_MIN(-9223372036854775807L -1L)) &&
719 (labs(rhs) <= UINT32_MAX(4294967295U))) {
720 isl_sioimath_set_int64(dst, (int64_t) smalllhs * (int64_t) rhs);
721 return;
722 }
723
724 mp_int_mul(isl_sioimath_bigarg_src(lhs, &scratchlhs),
725 isl_sioimath_siarg_src(rhs, &scratchrhs),
726 isl_sioimath_reinit_big(dst));
727 isl_sioimath_try_demote(dst);
728}
729
730/* Multiply an isl_int and an unsigned long.
731 */
732inline void isl_sioimath_mul_ui(isl_sioimath_ptr dst, isl_sioimath lhs,
733 unsigned long rhs)
734{
735 isl_sioimath_scratchspace_t scratchlhs, scratchrhs;
736 int32_t smalllhs;
737
738 if (isl_sioimath_decode_small(lhs, &smalllhs) && (rhs <= UINT32_MAX(4294967295U))) {
739 isl_sioimath_set_int64(dst, (int64_t) smalllhs * (int64_t) rhs);
740 return;
741 }
742
743 mp_int_mul(isl_sioimath_bigarg_src(lhs, &scratchlhs),
744 isl_sioimath_uiarg_src(rhs, &scratchrhs),
745 isl_sioimath_reinit_big(dst));
746 isl_sioimath_try_demote(dst);
747}
748
749/* Compute the power of an isl_int to an unsigned long.
750 * Always let IMath do it; the result is unlikely to be small except in some
751 * special cases.
752 * Note: 0^0 == 1
753 */
754inline void isl_sioimath_pow_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
755 unsigned long rhs)
756{
757 isl_sioimath_scratchspace_t scratchlhs, scratchrhs;
758 int32_t smalllhs;
759
760 switch (rhs) {
761 case 0:
762 isl_sioimath_set_small(dst, 1);
763 return;
764 case 1:
765 isl_sioimath_set(dst, lhs);
766 return;
767 case 2:
768 isl_sioimath_mul(dst, lhs, lhs);
769 return;
770 }
771
772 if (isl_sioimath_decode_small(lhs, &smalllhs)) {
773 switch (smalllhs) {
774 case 0:
775 isl_sioimath_set_small(dst, 0);
776 return;
777 case 1:
778 isl_sioimath_set_small(dst, 1);
779 return;
780 case 2:
781 isl_sioimath_set_small(dst, 1);
782 isl_sioimath_mul_2exp(dst, *dst, rhs);
783 return;
784 default:
785 if ((MP_SMALL_MIN(-9223372036854775807L -1L) <= rhs) && (rhs <= MP_SMALL_MAX9223372036854775807L)) {
786 mp_int_expt_value(smalllhs, rhs,
787 isl_sioimath_reinit_big(dst));
788 isl_sioimath_try_demote(dst);
789 return;
790 }
791 }
792 }
793
794 mp_int_expt_full(isl_sioimath_bigarg_src(lhs, &scratchlhs),
795 isl_sioimath_uiarg_src(rhs, &scratchrhs),
796 isl_sioimath_reinit_big(dst));
797 isl_sioimath_try_demote(dst);
798}
799
800/* Fused multiply-add.
801 */
802inline void isl_sioimath_addmul(isl_sioimath_ptr dst, isl_sioimath_src lhs,
803 isl_sioimath_src rhs)
804{
805 isl_sioimath tmp;
806 isl_sioimath_init(&tmp);
807 isl_sioimath_mul(&tmp, lhs, rhs);
808 isl_sioimath_add(dst, *dst, tmp);
809 isl_sioimath_clear(&tmp);
810}
811
812/* Fused multiply-add with an unsigned long.
813 */
814inline void isl_sioimath_addmul_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
815 unsigned long rhs)
816{
817 isl_sioimath tmp;
818 isl_sioimath_init(&tmp);
819 isl_sioimath_mul_ui(&tmp, lhs, rhs);
820 isl_sioimath_add(dst, *dst, tmp);
821 isl_sioimath_clear(&tmp);
822}
823
824/* Fused multiply-subtract.
825 */
826inline void isl_sioimath_submul(isl_sioimath_ptr dst, isl_sioimath_src lhs,
827 isl_sioimath_src rhs)
828{
829 isl_sioimath tmp;
830 isl_sioimath_init(&tmp);
831 isl_sioimath_mul(&tmp, lhs, rhs);
832 isl_sioimath_sub(dst, *dst, tmp);
833 isl_sioimath_clear(&tmp);
834}
835
836/* Fused multiply-add with an unsigned long.
837 */
838inline void isl_sioimath_submul_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
839 unsigned long rhs)
840{
841 isl_sioimath tmp;
842 isl_sioimath_init(&tmp);
843 isl_sioimath_mul_ui(&tmp, lhs, rhs);
844 isl_sioimath_sub(dst, *dst, tmp);
845 isl_sioimath_clear(&tmp);
846}
847
848void isl_sioimath_gcd(isl_sioimath_ptr dst, isl_sioimath_src lhs,
849 isl_sioimath_src rhs);
850void isl_sioimath_lcm(isl_sioimath_ptr dst, isl_sioimath_src lhs,
851 isl_sioimath_src rhs);
852
853/* Divide lhs by rhs, rounding to zero (Truncate).
854 */
855inline void isl_sioimath_tdiv_q(isl_sioimath_ptr dst, isl_sioimath_src lhs,
856 isl_sioimath_src rhs)
857{
858 isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
859 int32_t lhssmall, rhssmall;
860
861 if (isl_sioimath_decode_small(lhs, &lhssmall) &&
862 isl_sioimath_decode_small(rhs, &rhssmall)) {
863 isl_sioimath_set_small(dst, lhssmall / rhssmall);
864 return;
865 }
866
867 mp_int_div(isl_sioimath_bigarg_src(lhs, &lhsscratch),
868 isl_sioimath_bigarg_src(rhs, &rhsscratch),
869 isl_sioimath_reinit_big(dst), NULL((void*)0));
870 isl_sioimath_try_demote(dst);
871 return;
872}
873
874/* Divide lhs by an unsigned long rhs, rounding to zero (Truncate).
875 */
876inline void isl_sioimath_tdiv_q_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
877 unsigned long rhs)
878{
879 isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
880 int32_t lhssmall;
881
882 if (isl_sioimath_is_small(lhs) && (rhs <= (unsigned long) INT32_MAX(2147483647))) {
883 lhssmall = isl_sioimath_get_small(lhs);
884 isl_sioimath_set_small(dst, lhssmall / (int32_t) rhs);
885 return;
886 }
887
888 if (rhs <= MP_SMALL_MAX9223372036854775807L) {
889 mp_int_div_value(isl_sioimath_bigarg_src(lhs, &lhsscratch), rhs,
890 isl_sioimath_reinit_big(dst), NULL((void*)0));
891 isl_sioimath_try_demote(dst);
892 return;
893 }
894
895 mp_int_div(isl_sioimath_bigarg_src(lhs, &lhsscratch),
896 isl_sioimath_uiarg_src(rhs, &rhsscratch),
897 isl_sioimath_reinit_big(dst), NULL((void*)0));
898 isl_sioimath_try_demote(dst);
899}
900
901/* Divide lhs by rhs, rounding to positive infinity (Ceil).
902 */
903inline void isl_sioimath_cdiv_q(isl_sioimath_ptr dst, isl_sioimath_src lhs,
904 isl_sioimath_src rhs)
905{
906 int32_t lhssmall, rhssmall;
907 isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
908 int32_t q;
909
910 if (isl_sioimath_decode_small(lhs, &lhssmall) &&
911 isl_sioimath_decode_small(rhs, &rhssmall)) {
912 if ((lhssmall >= 0) && (rhssmall >= 0))
913 q = ((int64_t) lhssmall + (int64_t) rhssmall - 1) /
914 rhssmall;
915 else if ((lhssmall < 0) && (rhssmall < 0))
916 q = ((int64_t) lhssmall + (int64_t) rhssmall + 1) /
917 rhssmall;
918 else
919 q = lhssmall / rhssmall;
920 isl_sioimath_set_small(dst, q);
921 return;
922 }
923
924 impz_cdiv_q(isl_sioimath_reinit_big(dst),
925 isl_sioimath_bigarg_src(lhs, &lhsscratch),
926 isl_sioimath_bigarg_src(rhs, &rhsscratch));
927 isl_sioimath_try_demote(dst);
928}
929
930/* Compute the division of lhs by a rhs of type unsigned long, rounding towards
931 * positive infinity (Ceil).
932 */
933inline void isl_sioimath_cdiv_q_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
934 unsigned long rhs)
935{
936 isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
937 int32_t lhssmall, q;
938
939 if (isl_sioimath_decode_small(lhs, &lhssmall) && (rhs <= INT32_MAX(2147483647))) {
940 if (lhssmall >= 0)
941 q = ((int64_t) lhssmall + ((int64_t) rhs - 1)) /
942 (int64_t) rhs;
943 else
944 q = lhssmall / (int32_t) rhs;
945 isl_sioimath_set_small(dst, q);
946 return;
947 }
948
949 impz_cdiv_q(isl_sioimath_reinit_big(dst),
950 isl_sioimath_bigarg_src(lhs, &lhsscratch),
951 isl_sioimath_uiarg_src(rhs, &rhsscratch));
952 isl_sioimath_try_demote(dst);
953}
954
955/* Divide lhs by rhs, rounding to negative infinity (Floor).
956 */
957inline void isl_sioimath_fdiv_q(isl_sioimath_ptr dst, isl_sioimath_src lhs,
958 isl_sioimath_src rhs)
959{
960 isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
961 int32_t lhssmall, rhssmall;
962 int32_t q;
963
964 if (isl_sioimath_decode_small(lhs, &lhssmall) &&
965 isl_sioimath_decode_small(rhs, &rhssmall)) {
966 if ((lhssmall < 0) && (rhssmall >= 0))
967 q = ((int64_t) lhssmall - ((int64_t) rhssmall - 1)) /
968 rhssmall;
969 else if ((lhssmall >= 0) && (rhssmall < 0))
970 q = ((int64_t) lhssmall - ((int64_t) rhssmall + 1)) /
971 rhssmall;
972 else
973 q = lhssmall / rhssmall;
974 isl_sioimath_set_small(dst, q);
975 return;
976 }
977
978 impz_fdiv_q(isl_sioimath_reinit_big(dst),
979 isl_sioimath_bigarg_src(lhs, &lhsscratch),
980 isl_sioimath_bigarg_src(rhs, &rhsscratch));
981 isl_sioimath_try_demote(dst);
982}
983
984/* Compute the division of lhs by a rhs of type unsigned long, rounding towards
985 * negative infinity (Floor).
986 */
987inline void isl_sioimath_fdiv_q_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
988 unsigned long rhs)
989{
990 isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
991 int32_t lhssmall, q;
992
993 if (isl_sioimath_decode_small(lhs, &lhssmall) && (rhs <= INT32_MAX(2147483647))) {
994 if (lhssmall >= 0)
995 q = (uint32_t) lhssmall / rhs;
996 else
997 q = ((int64_t) lhssmall - ((int64_t) rhs - 1)) /
998 (int64_t) rhs;
999 isl_sioimath_set_small(dst, q);
1000 return;
1001 }
1002
1003 impz_fdiv_q(isl_sioimath_reinit_big(dst),
1004 isl_sioimath_bigarg_src(lhs, &lhsscratch),
1005 isl_sioimath_uiarg_src(rhs, &rhsscratch));
1006 isl_sioimath_try_demote(dst);
1007}
1008
1009/* Get the remainder of: lhs divided by rhs rounded towards negative infinite
1010 * (Floor).
1011 */
1012inline void isl_sioimath_fdiv_r(isl_sioimath_ptr dst, isl_sioimath_src lhs,
1013 isl_sioimath_src rhs)
1014{
1015 isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
1016 int64_t lhssmall, rhssmall;
1017 int32_t r;
1018
1019 if (isl_sioimath_is_small(lhs) && isl_sioimath_is_small(rhs)) {
1020 lhssmall = isl_sioimath_get_small(lhs);
1021 rhssmall = isl_sioimath_get_small(rhs);
1022 r = (rhssmall + lhssmall % rhssmall) % rhssmall;
1023 isl_sioimath_set_small(dst, r);
1024 return;
1025 }
1026
1027 impz_fdiv_r(isl_sioimath_reinit_big(dst),
1028 isl_sioimath_bigarg_src(lhs, &lhsscratch),
1029 isl_sioimath_bigarg_src(rhs, &rhsscratch));
1030 isl_sioimath_try_demote(dst);
1031}
1032
1033void isl_sioimath_read(isl_sioimath_ptr dst, const char *str);
1034
1035/* Return:
1036 * +1 for a positive number
1037 * -1 for a negative number
1038 * 0 if the number is zero
1039 */
1040inline int isl_sioimath_sgn(isl_sioimath_src arg)
1041{
1042 int32_t small;
1043
1044 if (isl_sioimath_decode_small(arg, &small))
1045 return (small > 0) - (small < 0);
1046
1047 return mp_int_compare_zero(isl_sioimath_get_big(arg));
1048}
1049
1050/* Return:
1051 * +1 if lhs > rhs
1052 * -1 if lhs < rhs
1053 * 0 if lhs = rhs
1054 */
1055inline int isl_sioimath_cmp(isl_sioimath_src lhs, isl_sioimath_src rhs)
1056{
1057 isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
1058 int32_t lhssmall, rhssmall;
1059
1060 if (isl_sioimath_decode_small(lhs, &lhssmall) &&
1061 isl_sioimath_decode_small(rhs, &rhssmall))
1062 return (lhssmall > rhssmall) - (lhssmall < rhssmall);
1063
1064 if (isl_sioimath_decode_small(rhs, &rhssmall))
1065 return mp_int_compare_value(
1066 isl_sioimath_bigarg_src(lhs, &lhsscratch), rhssmall);
1067
1068 if (isl_sioimath_decode_small(lhs, &lhssmall))
1069 return -mp_int_compare_value(
1070 isl_sioimath_bigarg_src(rhs, &rhsscratch), lhssmall);
1071
1072 return mp_int_compare(
1073 isl_sioimath_get_big(lhs), isl_sioimath_get_big(rhs));
1074}
1075
1076/* As isl_sioimath_cmp, but with signed long rhs.
1077 */
1078inline int isl_sioimath_cmp_si(isl_sioimath_src lhs, signed long rhs)
1079{
1080 int32_t lhssmall;
1081
1082 if (isl_sioimath_decode_small(lhs, &lhssmall))
1083 return (lhssmall > rhs) - (lhssmall < rhs);
1084
1085 return mp_int_compare_value(isl_sioimath_get_big(lhs), rhs);
1086}
1087
1088/* Return:
1089 * +1 if |lhs| > |rhs|
1090 * -1 if |lhs| < |rhs|
1091 * 0 if |lhs| = |rhs|
1092 */
1093inline int isl_sioimath_abs_cmp(isl_sioimath_src lhs, isl_sioimath_src rhs)
1094{
1095 isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
1096 int32_t lhssmall, rhssmall;
1097
1098 if (isl_sioimath_decode_small(lhs, &lhssmall) &&
1099 isl_sioimath_decode_small(rhs, &rhssmall)) {
1100 lhssmall = labs(lhssmall);
1101 rhssmall = labs(rhssmall);
1102 return (lhssmall > rhssmall) - (lhssmall < rhssmall);
1103 }
1104
1105 return mp_int_compare_unsigned(
1106 isl_sioimath_bigarg_src(lhs, &lhsscratch),
1107 isl_sioimath_bigarg_src(rhs, &rhsscratch));
1108}
1109
1110/* Return whether lhs is divisible by rhs.
1111 * In particular, can rhs be multiplied by some integer to result in lhs?
1112 * If rhs is zero, then this means lhs has to be zero too.
1113 */
1114inline int isl_sioimath_is_divisible_by(isl_sioimath_src lhs,
1115 isl_sioimath_src rhs)
1116{
1117 isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
1118 int32_t lhssmall, rhssmall;
1119 mpz_t rem;
1120 int cmp;
1121
1122 if (isl_sioimath_sgn(rhs) == 0)
1123 return isl_sioimath_sgn(lhs) == 0;
1124
1125 if (isl_sioimath_decode_small(lhs, &lhssmall) &&
1126 isl_sioimath_decode_small(rhs, &rhssmall))
1127 return lhssmall % rhssmall == 0;
1128
1129 if (isl_sioimath_decode_small(rhs, &rhssmall))
1130 return mp_int_divisible_value(
1131 isl_sioimath_bigarg_src(lhs, &lhsscratch), rhssmall);
1132
1133 mp_int_init(&rem);
1134 mp_int_div(isl_sioimath_bigarg_src(lhs, &lhsscratch),
1135 isl_sioimath_bigarg_src(rhs, &rhsscratch), NULL((void*)0), &rem);
1136 cmp = mp_int_compare_zero(&rem);
1137 mp_int_clear(&rem);
1138 return cmp == 0;
1139}
1140
1141/* Return a hash code of an isl_sioimath.
1142 * The hash code for a number in small and big representation must be identical
1143 * on the same machine because small representation if not obligatory if fits.
1144 */
1145inline uint32_t isl_sioimath_hash(isl_sioimath_src arg, uint32_t hash)
1146{
1147 int32_t small;
1148 int i;
1149 uint32_t num;
1150 mp_digit digits[(sizeof(uint32_t) + sizeof(mp_digit) - 1) /
1151 sizeof(mp_digit)];
1152 mp_size used;
1153 const unsigned char *digitdata = (const unsigned char *) &digits;
1154
1155 if (isl_sioimath_decode_small(arg, &small)) {
4
Assuming the condition is true
5
Taking true branch
1156 if (small < 0)
6
Taking false branch
1157 isl_hash_byte(hash, 0xFF)do { hash *= 16777619; hash ^= 0xFF; } while(0);
1158 num = labs(small);
1159
1160 isl_siomath_uint32_to_digits(num, digits, &used);
7
Calling 'isl_siomath_uint32_to_digits'
11
Returning from 'isl_siomath_uint32_to_digits'
1161 for (i = 0; i < used * sizeof(mp_digit); i += 1)
12
Loop condition is true. Entering loop body
14
Loop condition is true. Entering loop body
1162 isl_hash_byte(hash, digitdata[i])do { hash *= 16777619; hash ^= digitdata[i]; } while(0);
13
Loop condition is false. Exiting loop
15
Assigned value is garbage or undefined
1163 return hash;
1164 }
1165
1166 return isl_imath_hash(isl_sioimath_get_big(arg), hash);
1167}
1168
1169/* Return the number of digits in a number of the given base or more, i.e. the
1170 * string length without sign and null terminator.
1171 *
1172 * Current implementation for small representation returns the maximal number
1173 * of binary digits in that representation, which can be much larger than the
1174 * smallest possible solution.
1175 */
1176inline size_t isl_sioimath_sizeinbase(isl_sioimath_src arg, int base)
1177{
1178 int32_t small;
1179
1180 if (isl_sioimath_decode_small(arg, &small))
1181 return sizeof(int32_t) * CHAR_BIT8 - 1;
1182
1183 return impz_sizeinbase(isl_sioimath_get_big(arg), base);
1184}
1185
1186void isl_sioimath_print(FILE *out, isl_sioimath_src i, int width);
1187void isl_sioimath_dump(isl_sioimath_src arg);
1188
1189typedef isl_sioimath isl_int[1];
1190#define isl_int_init(i)isl_sioimath_init((i)) isl_sioimath_init((i))
1191#define isl_int_clear(i)isl_sioimath_clear((i)) isl_sioimath_clear((i))
1192
1193#define isl_int_set(r, i)isl_sioimath_set((r), *(i)) isl_sioimath_set((r), *(i))
1194#define isl_int_set_si(r, i)isl_sioimath_set_si((r), i) isl_sioimath_set_si((r), i)
1195#define isl_int_set_ui(r, i)isl_sioimath_set_ui((r), i) isl_sioimath_set_ui((r), i)
1196#define isl_int_fits_slong(r)isl_sioimath_fits_slong(*(r)) isl_sioimath_fits_slong(*(r))
1197#define isl_int_get_si(r)isl_sioimath_get_si(*(r)) isl_sioimath_get_si(*(r))
1198#define isl_int_fits_ulong(r)isl_sioimath_fits_ulong(*(r)) isl_sioimath_fits_ulong(*(r))
1199#define isl_int_get_ui(r)isl_sioimath_get_ui(*(r)) isl_sioimath_get_ui(*(r))
1200#define isl_int_get_d(r)isl_sioimath_get_d(*(r)) isl_sioimath_get_d(*(r))
1201#define isl_int_get_str(r)isl_sioimath_get_str(*(r)) isl_sioimath_get_str(*(r))
1202#define isl_int_abs(r, i)isl_sioimath_abs((r), *(i)) isl_sioimath_abs((r), *(i))
1203#define isl_int_neg(r, i)isl_sioimath_neg((r), *(i)) isl_sioimath_neg((r), *(i))
1204#define isl_int_swap(i, j)isl_sioimath_swap((i), (j)) isl_sioimath_swap((i), (j))
1205#define isl_int_swap_or_set(i, j)isl_sioimath_swap((i), (j)) isl_sioimath_swap((i), (j))
1206#define isl_int_add_ui(r, i, j)isl_sioimath_add_ui((r), *(i), j) isl_sioimath_add_ui((r), *(i), j)
1207#define isl_int_sub_ui(r, i, j)isl_sioimath_sub_ui((r), *(i), j) isl_sioimath_sub_ui((r), *(i), j)
1208
1209#define isl_int_add(r, i, j)isl_sioimath_add((r), *(i), *(j)) isl_sioimath_add((r), *(i), *(j))
1210#define isl_int_sub(r, i, j)isl_sioimath_sub((r), *(i), *(j)) isl_sioimath_sub((r), *(i), *(j))
1211#define isl_int_mul(r, i, j)isl_sioimath_mul((r), *(i), *(j)) isl_sioimath_mul((r), *(i), *(j))
1212#define isl_int_mul_2exp(r, i, j)isl_sioimath_mul_2exp((r), *(i), j) isl_sioimath_mul_2exp((r), *(i), j)
1213#define isl_int_mul_si(r, i, j)isl_sioimath_mul_si((r), *(i), j) isl_sioimath_mul_si((r), *(i), j)
1214#define isl_int_mul_ui(r, i, j)isl_sioimath_mul_ui((r), *(i), j) isl_sioimath_mul_ui((r), *(i), j)
1215#define isl_int_pow_ui(r, i, j)isl_sioimath_pow_ui((r), *(i), j) isl_sioimath_pow_ui((r), *(i), j)
1216#define isl_int_addmul(r, i, j)isl_sioimath_addmul((r), *(i), *(j)) isl_sioimath_addmul((r), *(i), *(j))
1217#define isl_int_addmul_ui(r, i, j)isl_sioimath_addmul_ui((r), *(i), j) isl_sioimath_addmul_ui((r), *(i), j)
1218#define isl_int_submul(r, i, j)isl_sioimath_submul((r), *(i), *(j)) isl_sioimath_submul((r), *(i), *(j))
1219#define isl_int_submul_ui(r, i, j)isl_sioimath_submul_ui((r), *(i), j) isl_sioimath_submul_ui((r), *(i), j)
1220
1221#define isl_int_gcd(r, i, j)isl_sioimath_gcd((r), *(i), *(j)) isl_sioimath_gcd((r), *(i), *(j))
1222#define isl_int_lcm(r, i, j)isl_sioimath_lcm((r), *(i), *(j)) isl_sioimath_lcm((r), *(i), *(j))
1223#define isl_int_divexact(r, i, j)isl_sioimath_tdiv_q((r), *(i), *(j)) isl_sioimath_tdiv_q((r), *(i), *(j))
1224#define isl_int_divexact_ui(r, i, j)isl_sioimath_tdiv_q_ui((r), *(i), j) isl_sioimath_tdiv_q_ui((r), *(i), j)
1225#define isl_int_tdiv_q(r, i, j)isl_sioimath_tdiv_q((r), *(i), *(j)) isl_sioimath_tdiv_q((r), *(i), *(j))
1226#define isl_int_cdiv_q(r, i, j)isl_sioimath_cdiv_q((r), *(i), *(j)) isl_sioimath_cdiv_q((r), *(i), *(j))
1227#define isl_int_cdiv_q_ui(r, i, j)isl_sioimath_cdiv_q_ui((r), *(i), j) isl_sioimath_cdiv_q_ui((r), *(i), j)
1228#define isl_int_fdiv_q(r, i, j)isl_sioimath_fdiv_q((r), *(i), *(j)) isl_sioimath_fdiv_q((r), *(i), *(j))
1229#define isl_int_fdiv_r(r, i, j)isl_sioimath_fdiv_r((r), *(i), *(j)) isl_sioimath_fdiv_r((r), *(i), *(j))
1230#define isl_int_fdiv_q_ui(r, i, j)isl_sioimath_fdiv_q_ui((r), *(i), j) isl_sioimath_fdiv_q_ui((r), *(i), j)
1231
1232#define isl_int_read(r, s)isl_sioimath_read((r), s) isl_sioimath_read((r), s)
1233#define isl_int_sgn(i)isl_sioimath_sgn(*(i)) isl_sioimath_sgn(*(i))
1234#define isl_int_cmp(i, j)isl_sioimath_cmp(*(i), *(j)) isl_sioimath_cmp(*(i), *(j))
1235#define isl_int_cmp_si(i, si)isl_sioimath_cmp_si(*(i), si) isl_sioimath_cmp_si(*(i), si)
1236#define isl_int_eq(i, j)(isl_sioimath_cmp(*(i), *(j)) == 0) (isl_sioimath_cmp(*(i), *(j)) == 0)
1237#define isl_int_ne(i, j)(isl_sioimath_cmp(*(i), *(j)) != 0) (isl_sioimath_cmp(*(i), *(j)) != 0)
1238#define isl_int_lt(i, j)(isl_sioimath_cmp(*(i), *(j)) < 0) (isl_sioimath_cmp(*(i), *(j)) < 0)
1239#define isl_int_le(i, j)(isl_sioimath_cmp(*(i), *(j)) <= 0) (isl_sioimath_cmp(*(i), *(j)) <= 0)
1240#define isl_int_gt(i, j)(isl_sioimath_cmp(*(i), *(j)) > 0) (isl_sioimath_cmp(*(i), *(j)) > 0)
1241#define isl_int_ge(i, j)(isl_sioimath_cmp(*(i), *(j)) >= 0) (isl_sioimath_cmp(*(i), *(j)) >= 0)
1242#define isl_int_abs_cmp(i, j)isl_sioimath_abs_cmp(*(i), *(j)) isl_sioimath_abs_cmp(*(i), *(j))
1243#define isl_int_abs_eq(i, j)(isl_sioimath_abs_cmp(*(i), *(j)) == 0) (isl_sioimath_abs_cmp(*(i), *(j)) == 0)
1244#define isl_int_abs_ne(i, j)(isl_sioimath_abs_cmp(*(i), *(j)) != 0) (isl_sioimath_abs_cmp(*(i), *(j)) != 0)
1245#define isl_int_abs_lt(i, j)(isl_sioimath_abs_cmp(*(i), *(j)) < 0) (isl_sioimath_abs_cmp(*(i), *(j)) < 0)
1246#define isl_int_abs_gt(i, j)(isl_sioimath_abs_cmp(*(i), *(j)) > 0) (isl_sioimath_abs_cmp(*(i), *(j)) > 0)
1247#define isl_int_abs_ge(i, j)(isl_sioimath_abs_cmp(*(i), *(j)) >= 0) (isl_sioimath_abs_cmp(*(i), *(j)) >= 0)
1248#define isl_int_is_divisible_by(i, j)isl_sioimath_is_divisible_by(*(i), *(j)) isl_sioimath_is_divisible_by(*(i), *(j))
1249
1250#define isl_int_hash(v, h)isl_sioimath_hash(*(v), h) isl_sioimath_hash(*(v), h)
1251#define isl_int_free_str(s)free(s) free(s)
1252#define isl_int_print(out, i, width)isl_sioimath_print(out, *(i), width) isl_sioimath_print(out, *(i), width)
1253
1254#endif /* ISL_INT_SIOIMATH_H */