1 /* Fixed-point arithmetic support.
2 Copyright (C) 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
19
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "tm.h"
24 #include "tree.h"
25 #include "diagnostic-core.h"
26
27 /* Compare two fixed objects for bitwise identity. */
28
29 bool
fixed_identical(const FIXED_VALUE_TYPE * a,const FIXED_VALUE_TYPE * b)30 fixed_identical (const FIXED_VALUE_TYPE *a, const FIXED_VALUE_TYPE *b)
31 {
32 return (a->mode == b->mode
33 && a->data.high == b->data.high
34 && a->data.low == b->data.low);
35 }
36
37 /* Calculate a hash value. */
38
39 unsigned int
fixed_hash(const FIXED_VALUE_TYPE * f)40 fixed_hash (const FIXED_VALUE_TYPE *f)
41 {
42 return (unsigned int) (f->data.low ^ f->data.high);
43 }
44
45 /* Define the enum code for the range of the fixed-point value. */
46 enum fixed_value_range_code {
47 FIXED_OK, /* The value is within the range. */
48 FIXED_UNDERFLOW, /* The value is less than the minimum. */
49 FIXED_GT_MAX_EPS, /* The value is greater than the maximum, but not equal
50 to the maximum plus the epsilon. */
51 FIXED_MAX_EPS /* The value equals the maximum plus the epsilon. */
52 };
53
54 /* Check REAL_VALUE against the range of the fixed-point mode.
55 Return FIXED_OK, if it is within the range.
56 FIXED_UNDERFLOW, if it is less than the minimum.
57 FIXED_GT_MAX_EPS, if it is greater than the maximum, but not equal to
58 the maximum plus the epsilon.
59 FIXED_MAX_EPS, if it is equal to the maximum plus the epsilon. */
60
61 static enum fixed_value_range_code
check_real_for_fixed_mode(REAL_VALUE_TYPE * real_value,enum machine_mode mode)62 check_real_for_fixed_mode (REAL_VALUE_TYPE *real_value, enum machine_mode mode)
63 {
64 REAL_VALUE_TYPE max_value, min_value, epsilon_value;
65
66 real_2expN (&max_value, GET_MODE_IBIT (mode), mode);
67 real_2expN (&epsilon_value, -GET_MODE_FBIT (mode), mode);
68
69 if (SIGNED_FIXED_POINT_MODE_P (mode))
70 min_value = real_value_negate (&max_value);
71 else
72 real_from_string (&min_value, "0.0");
73
74 if (real_compare (LT_EXPR, real_value, &min_value))
75 return FIXED_UNDERFLOW;
76 if (real_compare (EQ_EXPR, real_value, &max_value))
77 return FIXED_MAX_EPS;
78 real_arithmetic (&max_value, MINUS_EXPR, &max_value, &epsilon_value);
79 if (real_compare (GT_EXPR, real_value, &max_value))
80 return FIXED_GT_MAX_EPS;
81 return FIXED_OK;
82 }
83
84 /* Initialize from a decimal or hexadecimal string. */
85
86 void
fixed_from_string(FIXED_VALUE_TYPE * f,const char * str,enum machine_mode mode)87 fixed_from_string (FIXED_VALUE_TYPE *f, const char *str, enum machine_mode mode)
88 {
89 REAL_VALUE_TYPE real_value, fixed_value, base_value;
90 unsigned int fbit;
91 enum fixed_value_range_code temp;
92
93 f->mode = mode;
94 fbit = GET_MODE_FBIT (mode);
95
96 real_from_string (&real_value, str);
97 temp = check_real_for_fixed_mode (&real_value, f->mode);
98 /* We don't want to warn the case when the _Fract value is 1.0. */
99 if (temp == FIXED_UNDERFLOW
100 || temp == FIXED_GT_MAX_EPS
101 || (temp == FIXED_MAX_EPS && ALL_ACCUM_MODE_P (f->mode)))
102 warning (OPT_Woverflow,
103 "large fixed-point constant implicitly truncated to fixed-point type");
104 real_2expN (&base_value, fbit, mode);
105 real_arithmetic (&fixed_value, MULT_EXPR, &real_value, &base_value);
106 real_to_integer2 ((HOST_WIDE_INT *)&f->data.low, &f->data.high,
107 &fixed_value);
108
109 if (temp == FIXED_MAX_EPS && ALL_FRACT_MODE_P (f->mode))
110 {
111 /* From the spec, we need to evaluate 1 to the maximal value. */
112 f->data.low = -1;
113 f->data.high = -1;
114 f->data = double_int_ext (f->data,
115 GET_MODE_FBIT (f->mode)
116 + GET_MODE_IBIT (f->mode), 1);
117 }
118 else
119 f->data = double_int_ext (f->data,
120 SIGNED_FIXED_POINT_MODE_P (f->mode)
121 + GET_MODE_FBIT (f->mode)
122 + GET_MODE_IBIT (f->mode),
123 UNSIGNED_FIXED_POINT_MODE_P (f->mode));
124 }
125
126 /* Render F as a decimal floating point constant. */
127
128 void
fixed_to_decimal(char * str,const FIXED_VALUE_TYPE * f_orig,size_t buf_size)129 fixed_to_decimal (char *str, const FIXED_VALUE_TYPE *f_orig,
130 size_t buf_size)
131 {
132 REAL_VALUE_TYPE real_value, base_value, fixed_value;
133
134 real_2expN (&base_value, GET_MODE_FBIT (f_orig->mode), f_orig->mode);
135 real_from_integer (&real_value, VOIDmode, f_orig->data.low, f_orig->data.high,
136 UNSIGNED_FIXED_POINT_MODE_P (f_orig->mode));
137 real_arithmetic (&fixed_value, RDIV_EXPR, &real_value, &base_value);
138 real_to_decimal (str, &fixed_value, buf_size, 0, 1);
139 }
140
141 /* If SAT_P, saturate A to the maximum or the minimum, and save to *F based on
142 the machine mode MODE.
143 Do not modify *F otherwise.
144 This function assumes the width of double_int is greater than the width
145 of the fixed-point value (the sum of a possible sign bit, possible ibits,
146 and fbits).
147 Return true, if !SAT_P and overflow. */
148
149 static bool
fixed_saturate1(enum machine_mode mode,double_int a,double_int * f,bool sat_p)150 fixed_saturate1 (enum machine_mode mode, double_int a, double_int *f,
151 bool sat_p)
152 {
153 bool overflow_p = false;
154 bool unsigned_p = UNSIGNED_FIXED_POINT_MODE_P (mode);
155 int i_f_bits = GET_MODE_IBIT (mode) + GET_MODE_FBIT (mode);
156
157 if (unsigned_p) /* Unsigned type. */
158 {
159 double_int max;
160 max.low = -1;
161 max.high = -1;
162 max = double_int_ext (max, i_f_bits, 1);
163 if (double_int_cmp (a, max, 1) == 1)
164 {
165 if (sat_p)
166 *f = max;
167 else
168 overflow_p = true;
169 }
170 }
171 else /* Signed type. */
172 {
173 double_int max, min;
174 max.high = -1;
175 max.low = -1;
176 max = double_int_ext (max, i_f_bits, 1);
177 min.high = 0;
178 min.low = 1;
179 lshift_double (min.low, min.high, i_f_bits,
180 2 * HOST_BITS_PER_WIDE_INT,
181 &min.low, &min.high, 1);
182 min = double_int_ext (min, 1 + i_f_bits, 0);
183 if (double_int_cmp (a, max, 0) == 1)
184 {
185 if (sat_p)
186 *f = max;
187 else
188 overflow_p = true;
189 }
190 else if (double_int_cmp (a, min, 0) == -1)
191 {
192 if (sat_p)
193 *f = min;
194 else
195 overflow_p = true;
196 }
197 }
198 return overflow_p;
199 }
200
201 /* If SAT_P, saturate {A_HIGH, A_LOW} to the maximum or the minimum, and
202 save to *F based on the machine mode MODE.
203 Do not modify *F otherwise.
204 This function assumes the width of two double_int is greater than the width
205 of the fixed-point value (the sum of a possible sign bit, possible ibits,
206 and fbits).
207 Return true, if !SAT_P and overflow. */
208
209 static bool
fixed_saturate2(enum machine_mode mode,double_int a_high,double_int a_low,double_int * f,bool sat_p)210 fixed_saturate2 (enum machine_mode mode, double_int a_high, double_int a_low,
211 double_int *f, bool sat_p)
212 {
213 bool overflow_p = false;
214 bool unsigned_p = UNSIGNED_FIXED_POINT_MODE_P (mode);
215 int i_f_bits = GET_MODE_IBIT (mode) + GET_MODE_FBIT (mode);
216
217 if (unsigned_p) /* Unsigned type. */
218 {
219 double_int max_r, max_s;
220 max_r.high = 0;
221 max_r.low = 0;
222 max_s.high = -1;
223 max_s.low = -1;
224 max_s = double_int_ext (max_s, i_f_bits, 1);
225 if (double_int_cmp (a_high, max_r, 1) == 1
226 || (double_int_equal_p (a_high, max_r) &&
227 double_int_cmp (a_low, max_s, 1) == 1))
228 {
229 if (sat_p)
230 *f = max_s;
231 else
232 overflow_p = true;
233 }
234 }
235 else /* Signed type. */
236 {
237 double_int max_r, max_s, min_r, min_s;
238 max_r.high = 0;
239 max_r.low = 0;
240 max_s.high = -1;
241 max_s.low = -1;
242 max_s = double_int_ext (max_s, i_f_bits, 1);
243 min_r.high = -1;
244 min_r.low = -1;
245 min_s.high = 0;
246 min_s.low = 1;
247 lshift_double (min_s.low, min_s.high, i_f_bits,
248 2 * HOST_BITS_PER_WIDE_INT,
249 &min_s.low, &min_s.high, 1);
250 min_s = double_int_ext (min_s, 1 + i_f_bits, 0);
251 if (double_int_cmp (a_high, max_r, 0) == 1
252 || (double_int_equal_p (a_high, max_r) &&
253 double_int_cmp (a_low, max_s, 1) == 1))
254 {
255 if (sat_p)
256 *f = max_s;
257 else
258 overflow_p = true;
259 }
260 else if (double_int_cmp (a_high, min_r, 0) == -1
261 || (double_int_equal_p (a_high, min_r) &&
262 double_int_cmp (a_low, min_s, 1) == -1))
263 {
264 if (sat_p)
265 *f = min_s;
266 else
267 overflow_p = true;
268 }
269 }
270 return overflow_p;
271 }
272
273 /* Return the sign bit based on I_F_BITS. */
274
275 static inline int
get_fixed_sign_bit(double_int a,int i_f_bits)276 get_fixed_sign_bit (double_int a, int i_f_bits)
277 {
278 if (i_f_bits < HOST_BITS_PER_WIDE_INT)
279 return (a.low >> i_f_bits) & 1;
280 else
281 return (a.high >> (i_f_bits - HOST_BITS_PER_WIDE_INT)) & 1;
282 }
283
284 /* Calculate F = A + (SUBTRACT_P ? -B : B).
285 If SAT_P, saturate the result to the max or the min.
286 Return true, if !SAT_P and overflow. */
287
288 static bool
do_fixed_add(FIXED_VALUE_TYPE * f,const FIXED_VALUE_TYPE * a,const FIXED_VALUE_TYPE * b,bool subtract_p,bool sat_p)289 do_fixed_add (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
290 const FIXED_VALUE_TYPE *b, bool subtract_p, bool sat_p)
291 {
292 bool overflow_p = false;
293 bool unsigned_p;
294 double_int temp;
295 int i_f_bits;
296
297 /* This was a conditional expression but it triggered a bug in
298 Sun C 5.5. */
299 if (subtract_p)
300 temp = double_int_neg (b->data);
301 else
302 temp = b->data;
303
304 unsigned_p = UNSIGNED_FIXED_POINT_MODE_P (a->mode);
305 i_f_bits = GET_MODE_IBIT (a->mode) + GET_MODE_FBIT (a->mode);
306 f->mode = a->mode;
307 f->data = double_int_add (a->data, temp);
308 if (unsigned_p) /* Unsigned type. */
309 {
310 if (subtract_p) /* Unsigned subtraction. */
311 {
312 if (double_int_cmp (a->data, b->data, 1) == -1)
313 {
314 if (sat_p)
315 {
316 f->data.high = 0;
317 f->data.low = 0;
318 }
319 else
320 overflow_p = true;
321 }
322 }
323 else /* Unsigned addition. */
324 {
325 f->data = double_int_ext (f->data, i_f_bits, 1);
326 if (double_int_cmp (f->data, a->data, 1) == -1
327 || double_int_cmp (f->data, b->data, 1) == -1)
328 {
329 if (sat_p)
330 {
331 f->data.high = -1;
332 f->data.low = -1;
333 }
334 else
335 overflow_p = true;
336 }
337 }
338 }
339 else /* Signed type. */
340 {
341 if ((!subtract_p
342 && (get_fixed_sign_bit (a->data, i_f_bits)
343 == get_fixed_sign_bit (b->data, i_f_bits))
344 && (get_fixed_sign_bit (a->data, i_f_bits)
345 != get_fixed_sign_bit (f->data, i_f_bits)))
346 || (subtract_p
347 && (get_fixed_sign_bit (a->data, i_f_bits)
348 != get_fixed_sign_bit (b->data, i_f_bits))
349 && (get_fixed_sign_bit (a->data, i_f_bits)
350 != get_fixed_sign_bit (f->data, i_f_bits))))
351 {
352 if (sat_p)
353 {
354 f->data.low = 1;
355 f->data.high = 0;
356 lshift_double (f->data.low, f->data.high, i_f_bits,
357 2 * HOST_BITS_PER_WIDE_INT,
358 &f->data.low, &f->data.high, 1);
359 if (get_fixed_sign_bit (a->data, i_f_bits) == 0)
360 {
361 double_int one;
362 one.low = 1;
363 one.high = 0;
364 f->data = double_int_sub (f->data, one);
365 }
366 }
367 else
368 overflow_p = true;
369 }
370 }
371 f->data = double_int_ext (f->data, (!unsigned_p) + i_f_bits, unsigned_p);
372 return overflow_p;
373 }
374
375 /* Calculate F = A * B.
376 If SAT_P, saturate the result to the max or the min.
377 Return true, if !SAT_P and overflow. */
378
379 static bool
do_fixed_multiply(FIXED_VALUE_TYPE * f,const FIXED_VALUE_TYPE * a,const FIXED_VALUE_TYPE * b,bool sat_p)380 do_fixed_multiply (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
381 const FIXED_VALUE_TYPE *b, bool sat_p)
382 {
383 bool overflow_p = false;
384 bool unsigned_p = UNSIGNED_FIXED_POINT_MODE_P (a->mode);
385 int i_f_bits = GET_MODE_IBIT (a->mode) + GET_MODE_FBIT (a->mode);
386 f->mode = a->mode;
387 if (GET_MODE_PRECISION (f->mode) <= HOST_BITS_PER_WIDE_INT)
388 {
389 f->data = double_int_mul (a->data, b->data);
390 lshift_double (f->data.low, f->data.high,
391 (-GET_MODE_FBIT (f->mode)),
392 2 * HOST_BITS_PER_WIDE_INT,
393 &f->data.low, &f->data.high, !unsigned_p);
394 overflow_p = fixed_saturate1 (f->mode, f->data, &f->data, sat_p);
395 }
396 else
397 {
398 /* The result of multiplication expands to two double_int. */
399 double_int a_high, a_low, b_high, b_low;
400 double_int high_high, high_low, low_high, low_low;
401 double_int r, s, temp1, temp2;
402 int carry = 0;
403
404 /* Decompose a and b to four double_int. */
405 a_high.low = a->data.high;
406 a_high.high = 0;
407 a_low.low = a->data.low;
408 a_low.high = 0;
409 b_high.low = b->data.high;
410 b_high.high = 0;
411 b_low.low = b->data.low;
412 b_low.high = 0;
413
414 /* Perform four multiplications. */
415 low_low = double_int_mul (a_low, b_low);
416 low_high = double_int_mul (a_low, b_high);
417 high_low = double_int_mul (a_high, b_low);
418 high_high = double_int_mul (a_high, b_high);
419
420 /* Accumulate four results to {r, s}. */
421 temp1.high = high_low.low;
422 temp1.low = 0;
423 s = double_int_add (low_low, temp1);
424 if (double_int_cmp (s, low_low, 1) == -1
425 || double_int_cmp (s, temp1, 1) == -1)
426 carry ++; /* Carry */
427 temp1.high = s.high;
428 temp1.low = s.low;
429 temp2.high = low_high.low;
430 temp2.low = 0;
431 s = double_int_add (temp1, temp2);
432 if (double_int_cmp (s, temp1, 1) == -1
433 || double_int_cmp (s, temp2, 1) == -1)
434 carry ++; /* Carry */
435
436 temp1.low = high_low.high;
437 temp1.high = 0;
438 r = double_int_add (high_high, temp1);
439 temp1.low = low_high.high;
440 temp1.high = 0;
441 r = double_int_add (r, temp1);
442 temp1.low = carry;
443 temp1.high = 0;
444 r = double_int_add (r, temp1);
445
446 /* We need to subtract b from r, if a < 0. */
447 if (!unsigned_p && a->data.high < 0)
448 r = double_int_sub (r, b->data);
449 /* We need to subtract a from r, if b < 0. */
450 if (!unsigned_p && b->data.high < 0)
451 r = double_int_sub (r, a->data);
452
453 /* Shift right the result by FBIT. */
454 if (GET_MODE_FBIT (f->mode) == 2 * HOST_BITS_PER_WIDE_INT)
455 {
456 s.low = r.low;
457 s.high = r.high;
458 if (unsigned_p)
459 {
460 r.low = 0;
461 r.high = 0;
462 }
463 else
464 {
465 r.low = -1;
466 r.high = -1;
467 }
468 f->data.low = s.low;
469 f->data.high = s.high;
470 }
471 else
472 {
473 lshift_double (s.low, s.high,
474 (-GET_MODE_FBIT (f->mode)),
475 2 * HOST_BITS_PER_WIDE_INT,
476 &s.low, &s.high, 0);
477 lshift_double (r.low, r.high,
478 (2 * HOST_BITS_PER_WIDE_INT
479 - GET_MODE_FBIT (f->mode)),
480 2 * HOST_BITS_PER_WIDE_INT,
481 &f->data.low, &f->data.high, 0);
482 f->data.low = f->data.low | s.low;
483 f->data.high = f->data.high | s.high;
484 s.low = f->data.low;
485 s.high = f->data.high;
486 lshift_double (r.low, r.high,
487 (-GET_MODE_FBIT (f->mode)),
488 2 * HOST_BITS_PER_WIDE_INT,
489 &r.low, &r.high, !unsigned_p);
490 }
491
492 overflow_p = fixed_saturate2 (f->mode, r, s, &f->data, sat_p);
493 }
494
495 f->data = double_int_ext (f->data, (!unsigned_p) + i_f_bits, unsigned_p);
496 return overflow_p;
497 }
498
499 /* Calculate F = A / B.
500 If SAT_P, saturate the result to the max or the min.
501 Return true, if !SAT_P and overflow. */
502
503 static bool
do_fixed_divide(FIXED_VALUE_TYPE * f,const FIXED_VALUE_TYPE * a,const FIXED_VALUE_TYPE * b,bool sat_p)504 do_fixed_divide (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
505 const FIXED_VALUE_TYPE *b, bool sat_p)
506 {
507 bool overflow_p = false;
508 bool unsigned_p = UNSIGNED_FIXED_POINT_MODE_P (a->mode);
509 int i_f_bits = GET_MODE_IBIT (a->mode) + GET_MODE_FBIT (a->mode);
510 f->mode = a->mode;
511 if (GET_MODE_PRECISION (f->mode) <= HOST_BITS_PER_WIDE_INT)
512 {
513 lshift_double (a->data.low, a->data.high,
514 GET_MODE_FBIT (f->mode),
515 2 * HOST_BITS_PER_WIDE_INT,
516 &f->data.low, &f->data.high, !unsigned_p);
517 f->data = double_int_div (f->data, b->data, unsigned_p, TRUNC_DIV_EXPR);
518 overflow_p = fixed_saturate1 (f->mode, f->data, &f->data, sat_p);
519 }
520 else
521 {
522 double_int pos_a, pos_b, r, s;
523 double_int quo_r, quo_s, mod, temp;
524 int num_of_neg = 0;
525 int i;
526
527 /* If a < 0, negate a. */
528 if (!unsigned_p && a->data.high < 0)
529 {
530 pos_a = double_int_neg (a->data);
531 num_of_neg ++;
532 }
533 else
534 pos_a = a->data;
535
536 /* If b < 0, negate b. */
537 if (!unsigned_p && b->data.high < 0)
538 {
539 pos_b = double_int_neg (b->data);
540 num_of_neg ++;
541 }
542 else
543 pos_b = b->data;
544
545 /* Left shift pos_a to {r, s} by FBIT. */
546 if (GET_MODE_FBIT (f->mode) == 2 * HOST_BITS_PER_WIDE_INT)
547 {
548 r = pos_a;
549 s.high = 0;
550 s.low = 0;
551 }
552 else
553 {
554 lshift_double (pos_a.low, pos_a.high,
555 GET_MODE_FBIT (f->mode),
556 2 * HOST_BITS_PER_WIDE_INT,
557 &s.low, &s.high, 0);
558 lshift_double (pos_a.low, pos_a.high,
559 - (2 * HOST_BITS_PER_WIDE_INT
560 - GET_MODE_FBIT (f->mode)),
561 2 * HOST_BITS_PER_WIDE_INT,
562 &r.low, &r.high, 0);
563 }
564
565 /* Divide r by pos_b to quo_r. The remainder is in mod. */
566 div_and_round_double (TRUNC_DIV_EXPR, 1, r.low, r.high, pos_b.low,
567 pos_b.high, &quo_r.low, &quo_r.high, &mod.low,
568 &mod.high);
569
570 quo_s.high = 0;
571 quo_s.low = 0;
572
573 for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; i++)
574 {
575 /* Record the leftmost bit of mod. */
576 int leftmost_mod = (mod.high < 0);
577
578 /* Shift left mod by 1 bit. */
579 lshift_double (mod.low, mod.high, 1, 2 * HOST_BITS_PER_WIDE_INT,
580 &mod.low, &mod.high, 0);
581
582 /* Test the leftmost bit of s to add to mod. */
583 if (s.high < 0)
584 mod.low += 1;
585
586 /* Shift left quo_s by 1 bit. */
587 lshift_double (quo_s.low, quo_s.high, 1, 2 * HOST_BITS_PER_WIDE_INT,
588 &quo_s.low, &quo_s.high, 0);
589
590 /* Try to calculate (mod - pos_b). */
591 temp = double_int_sub (mod, pos_b);
592
593 if (leftmost_mod == 1 || double_int_cmp (mod, pos_b, 1) != -1)
594 {
595 quo_s.low += 1;
596 mod = temp;
597 }
598
599 /* Shift left s by 1 bit. */
600 lshift_double (s.low, s.high, 1, 2 * HOST_BITS_PER_WIDE_INT,
601 &s.low, &s.high, 0);
602
603 }
604
605 if (num_of_neg == 1)
606 {
607 quo_s = double_int_neg (quo_s);
608 if (quo_s.high == 0 && quo_s.low == 0)
609 quo_r = double_int_neg (quo_r);
610 else
611 {
612 quo_r.low = ~quo_r.low;
613 quo_r.high = ~quo_r.high;
614 }
615 }
616
617 f->data = quo_s;
618 overflow_p = fixed_saturate2 (f->mode, quo_r, quo_s, &f->data, sat_p);
619 }
620
621 f->data = double_int_ext (f->data, (!unsigned_p) + i_f_bits, unsigned_p);
622 return overflow_p;
623 }
624
625 /* Calculate F = A << B if LEFT_P. Otherwise, F = A >> B.
626 If SAT_P, saturate the result to the max or the min.
627 Return true, if !SAT_P and overflow. */
628
629 static bool
do_fixed_shift(FIXED_VALUE_TYPE * f,const FIXED_VALUE_TYPE * a,const FIXED_VALUE_TYPE * b,bool left_p,bool sat_p)630 do_fixed_shift (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a,
631 const FIXED_VALUE_TYPE *b, bool left_p, bool sat_p)
632 {
633 bool overflow_p = false;
634 bool unsigned_p = UNSIGNED_FIXED_POINT_MODE_P (a->mode);
635 int i_f_bits = GET_MODE_IBIT (a->mode) + GET_MODE_FBIT (a->mode);
636 f->mode = a->mode;
637
638 if (b->data.low == 0)
639 {
640 f->data = a->data;
641 return overflow_p;
642 }
643
644 if (GET_MODE_PRECISION (f->mode) <= HOST_BITS_PER_WIDE_INT || (!left_p))
645 {
646 lshift_double (a->data.low, a->data.high,
647 left_p ? b->data.low : (-b->data.low),
648 2 * HOST_BITS_PER_WIDE_INT,
649 &f->data.low, &f->data.high, !unsigned_p);
650 if (left_p) /* Only left shift saturates. */
651 overflow_p = fixed_saturate1 (f->mode, f->data, &f->data, sat_p);
652 }
653 else /* We need two double_int to store the left-shift result. */
654 {
655 double_int temp_high, temp_low;
656 if (b->data.low == 2 * HOST_BITS_PER_WIDE_INT)
657 {
658 temp_high = a->data;
659 temp_low.high = 0;
660 temp_low.low = 0;
661 }
662 else
663 {
664 lshift_double (a->data.low, a->data.high,
665 b->data.low,
666 2 * HOST_BITS_PER_WIDE_INT,
667 &temp_low.low, &temp_low.high, !unsigned_p);
668 /* Logical shift right to temp_high. */
669 lshift_double (a->data.low, a->data.high,
670 b->data.low - 2 * HOST_BITS_PER_WIDE_INT,
671 2 * HOST_BITS_PER_WIDE_INT,
672 &temp_high.low, &temp_high.high, 0);
673 }
674 if (!unsigned_p && a->data.high < 0) /* Signed-extend temp_high. */
675 temp_high = double_int_ext (temp_high, b->data.low, unsigned_p);
676 f->data = temp_low;
677 overflow_p = fixed_saturate2 (f->mode, temp_high, temp_low, &f->data,
678 sat_p);
679 }
680 f->data = double_int_ext (f->data, (!unsigned_p) + i_f_bits, unsigned_p);
681 return overflow_p;
682 }
683
684 /* Calculate F = -A.
685 If SAT_P, saturate the result to the max or the min.
686 Return true, if !SAT_P and overflow. */
687
688 static bool
do_fixed_neg(FIXED_VALUE_TYPE * f,const FIXED_VALUE_TYPE * a,bool sat_p)689 do_fixed_neg (FIXED_VALUE_TYPE *f, const FIXED_VALUE_TYPE *a, bool sat_p)
690 {
691 bool overflow_p = false;
692 bool unsigned_p = UNSIGNED_FIXED_POINT_MODE_P (a->mode);
693 int i_f_bits = GET_MODE_IBIT (a->mode) + GET_MODE_FBIT (a->mode);
694 f->mode = a->mode;
695 f->data = double_int_neg (a->data);
696 f->data = double_int_ext (f->data, (!unsigned_p) + i_f_bits, unsigned_p);
697
698 if (unsigned_p) /* Unsigned type. */
699 {
700 if (f->data.low != 0 || f->data.high != 0)
701 {
702 if (sat_p)
703 {
704 f->data.low = 0;
705 f->data.high = 0;
706 }
707 else
708 overflow_p = true;
709 }
710 }
711 else /* Signed type. */
712 {
713 if (!(f->data.high == 0 && f->data.low == 0)
714 && f->data.high == a->data.high && f->data.low == a->data.low )
715 {
716 if (sat_p)
717 {
718 /* Saturate to the maximum by subtracting f->data by one. */
719 f->data.low = -1;
720 f->data.high = -1;
721 f->data = double_int_ext (f->data, i_f_bits, 1);
722 }
723 else
724 overflow_p = true;
725 }
726 }
727 return overflow_p;
728 }
729
730 /* Perform the binary or unary operation described by CODE.
731 Note that OP0 and OP1 must have the same mode for binary operators.
732 For a unary operation, leave OP1 NULL.
733 Return true, if !SAT_P and overflow. */
734
735 bool
fixed_arithmetic(FIXED_VALUE_TYPE * f,int icode,const FIXED_VALUE_TYPE * op0,const FIXED_VALUE_TYPE * op1,bool sat_p)736 fixed_arithmetic (FIXED_VALUE_TYPE *f, int icode, const FIXED_VALUE_TYPE *op0,
737 const FIXED_VALUE_TYPE *op1, bool sat_p)
738 {
739 switch (icode)
740 {
741 case NEGATE_EXPR:
742 return do_fixed_neg (f, op0, sat_p);
743 break;
744
745 case PLUS_EXPR:
746 gcc_assert (op0->mode == op1->mode);
747 return do_fixed_add (f, op0, op1, false, sat_p);
748 break;
749
750 case MINUS_EXPR:
751 gcc_assert (op0->mode == op1->mode);
752 return do_fixed_add (f, op0, op1, true, sat_p);
753 break;
754
755 case MULT_EXPR:
756 gcc_assert (op0->mode == op1->mode);
757 return do_fixed_multiply (f, op0, op1, sat_p);
758 break;
759
760 case TRUNC_DIV_EXPR:
761 gcc_assert (op0->mode == op1->mode);
762 return do_fixed_divide (f, op0, op1, sat_p);
763 break;
764
765 case LSHIFT_EXPR:
766 return do_fixed_shift (f, op0, op1, true, sat_p);
767 break;
768
769 case RSHIFT_EXPR:
770 return do_fixed_shift (f, op0, op1, false, sat_p);
771 break;
772
773 default:
774 gcc_unreachable ();
775 }
776 return false;
777 }
778
779 /* Compare fixed-point values by tree_code.
780 Note that OP0 and OP1 must have the same mode. */
781
782 bool
fixed_compare(int icode,const FIXED_VALUE_TYPE * op0,const FIXED_VALUE_TYPE * op1)783 fixed_compare (int icode, const FIXED_VALUE_TYPE *op0,
784 const FIXED_VALUE_TYPE *op1)
785 {
786 enum tree_code code = (enum tree_code) icode;
787 gcc_assert (op0->mode == op1->mode);
788
789 switch (code)
790 {
791 case NE_EXPR:
792 return !double_int_equal_p (op0->data, op1->data);
793
794 case EQ_EXPR:
795 return double_int_equal_p (op0->data, op1->data);
796
797 case LT_EXPR:
798 return double_int_cmp (op0->data, op1->data,
799 UNSIGNED_FIXED_POINT_MODE_P (op0->mode)) == -1;
800
801 case LE_EXPR:
802 return double_int_cmp (op0->data, op1->data,
803 UNSIGNED_FIXED_POINT_MODE_P (op0->mode)) != 1;
804
805 case GT_EXPR:
806 return double_int_cmp (op0->data, op1->data,
807 UNSIGNED_FIXED_POINT_MODE_P (op0->mode)) == 1;
808
809 case GE_EXPR:
810 return double_int_cmp (op0->data, op1->data,
811 UNSIGNED_FIXED_POINT_MODE_P (op0->mode)) != -1;
812
813 default:
814 gcc_unreachable ();
815 }
816 }
817
818 /* Extend or truncate to a new mode.
819 If SAT_P, saturate the result to the max or the min.
820 Return true, if !SAT_P and overflow. */
821
822 bool
fixed_convert(FIXED_VALUE_TYPE * f,enum machine_mode mode,const FIXED_VALUE_TYPE * a,bool sat_p)823 fixed_convert (FIXED_VALUE_TYPE *f, enum machine_mode mode,
824 const FIXED_VALUE_TYPE *a, bool sat_p)
825 {
826 bool overflow_p = false;
827 if (mode == a->mode)
828 {
829 *f = *a;
830 return overflow_p;
831 }
832
833 if (GET_MODE_FBIT (mode) > GET_MODE_FBIT (a->mode))
834 {
835 /* Left shift a to temp_high, temp_low based on a->mode. */
836 double_int temp_high, temp_low;
837 int amount = GET_MODE_FBIT (mode) - GET_MODE_FBIT (a->mode);
838 lshift_double (a->data.low, a->data.high,
839 amount,
840 2 * HOST_BITS_PER_WIDE_INT,
841 &temp_low.low, &temp_low.high,
842 SIGNED_FIXED_POINT_MODE_P (a->mode));
843 /* Logical shift right to temp_high. */
844 lshift_double (a->data.low, a->data.high,
845 amount - 2 * HOST_BITS_PER_WIDE_INT,
846 2 * HOST_BITS_PER_WIDE_INT,
847 &temp_high.low, &temp_high.high, 0);
848 if (SIGNED_FIXED_POINT_MODE_P (a->mode)
849 && a->data.high < 0) /* Signed-extend temp_high. */
850 temp_high = double_int_ext (temp_high, amount, 0);
851 f->mode = mode;
852 f->data = temp_low;
853 if (SIGNED_FIXED_POINT_MODE_P (a->mode) ==
854 SIGNED_FIXED_POINT_MODE_P (f->mode))
855 overflow_p = fixed_saturate2 (f->mode, temp_high, temp_low, &f->data,
856 sat_p);
857 else
858 {
859 /* Take care of the cases when converting between signed and
860 unsigned. */
861 if (SIGNED_FIXED_POINT_MODE_P (a->mode))
862 {
863 /* Signed -> Unsigned. */
864 if (a->data.high < 0)
865 {
866 if (sat_p)
867 {
868 f->data.low = 0; /* Set to zero. */
869 f->data.high = 0; /* Set to zero. */
870 }
871 else
872 overflow_p = true;
873 }
874 else
875 overflow_p = fixed_saturate2 (f->mode, temp_high, temp_low,
876 &f->data, sat_p);
877 }
878 else
879 {
880 /* Unsigned -> Signed. */
881 if (temp_high.high < 0)
882 {
883 if (sat_p)
884 {
885 /* Set to maximum. */
886 f->data.low = -1; /* Set to all ones. */
887 f->data.high = -1; /* Set to all ones. */
888 f->data = double_int_ext (f->data,
889 GET_MODE_FBIT (f->mode)
890 + GET_MODE_IBIT (f->mode),
891 1); /* Clear the sign. */
892 }
893 else
894 overflow_p = true;
895 }
896 else
897 overflow_p = fixed_saturate2 (f->mode, temp_high, temp_low,
898 &f->data, sat_p);
899 }
900 }
901 }
902 else
903 {
904 /* Right shift a to temp based on a->mode. */
905 double_int temp;
906 lshift_double (a->data.low, a->data.high,
907 GET_MODE_FBIT (mode) - GET_MODE_FBIT (a->mode),
908 2 * HOST_BITS_PER_WIDE_INT,
909 &temp.low, &temp.high,
910 SIGNED_FIXED_POINT_MODE_P (a->mode));
911 f->mode = mode;
912 f->data = temp;
913 if (SIGNED_FIXED_POINT_MODE_P (a->mode) ==
914 SIGNED_FIXED_POINT_MODE_P (f->mode))
915 overflow_p = fixed_saturate1 (f->mode, f->data, &f->data, sat_p);
916 else
917 {
918 /* Take care of the cases when converting between signed and
919 unsigned. */
920 if (SIGNED_FIXED_POINT_MODE_P (a->mode))
921 {
922 /* Signed -> Unsigned. */
923 if (a->data.high < 0)
924 {
925 if (sat_p)
926 {
927 f->data.low = 0; /* Set to zero. */
928 f->data.high = 0; /* Set to zero. */
929 }
930 else
931 overflow_p = true;
932 }
933 else
934 overflow_p = fixed_saturate1 (f->mode, f->data, &f->data,
935 sat_p);
936 }
937 else
938 {
939 /* Unsigned -> Signed. */
940 if (temp.high < 0)
941 {
942 if (sat_p)
943 {
944 /* Set to maximum. */
945 f->data.low = -1; /* Set to all ones. */
946 f->data.high = -1; /* Set to all ones. */
947 f->data = double_int_ext (f->data,
948 GET_MODE_FBIT (f->mode)
949 + GET_MODE_IBIT (f->mode),
950 1); /* Clear the sign. */
951 }
952 else
953 overflow_p = true;
954 }
955 else
956 overflow_p = fixed_saturate1 (f->mode, f->data, &f->data,
957 sat_p);
958 }
959 }
960 }
961
962 f->data = double_int_ext (f->data,
963 SIGNED_FIXED_POINT_MODE_P (f->mode)
964 + GET_MODE_FBIT (f->mode)
965 + GET_MODE_IBIT (f->mode),
966 UNSIGNED_FIXED_POINT_MODE_P (f->mode));
967 return overflow_p;
968 }
969
970 /* Convert to a new fixed-point mode from an integer.
971 If UNSIGNED_P, this integer is unsigned.
972 If SAT_P, saturate the result to the max or the min.
973 Return true, if !SAT_P and overflow. */
974
975 bool
fixed_convert_from_int(FIXED_VALUE_TYPE * f,enum machine_mode mode,double_int a,bool unsigned_p,bool sat_p)976 fixed_convert_from_int (FIXED_VALUE_TYPE *f, enum machine_mode mode,
977 double_int a, bool unsigned_p, bool sat_p)
978 {
979 bool overflow_p = false;
980 /* Left shift a to temp_high, temp_low. */
981 double_int temp_high, temp_low;
982 int amount = GET_MODE_FBIT (mode);
983 if (amount == 2 * HOST_BITS_PER_WIDE_INT)
984 {
985 temp_high = a;
986 temp_low.low = 0;
987 temp_low.high = 0;
988 }
989 else
990 {
991 lshift_double (a.low, a.high,
992 amount,
993 2 * HOST_BITS_PER_WIDE_INT,
994 &temp_low.low, &temp_low.high, 0);
995
996 /* Logical shift right to temp_high. */
997 lshift_double (a.low, a.high,
998 amount - 2 * HOST_BITS_PER_WIDE_INT,
999 2 * HOST_BITS_PER_WIDE_INT,
1000 &temp_high.low, &temp_high.high, 0);
1001 }
1002 if (!unsigned_p && a.high < 0) /* Signed-extend temp_high. */
1003 temp_high = double_int_ext (temp_high, amount, 0);
1004
1005 f->mode = mode;
1006 f->data = temp_low;
1007
1008 if (unsigned_p == UNSIGNED_FIXED_POINT_MODE_P (f->mode))
1009 overflow_p = fixed_saturate2 (f->mode, temp_high, temp_low, &f->data,
1010 sat_p);
1011 else
1012 {
1013 /* Take care of the cases when converting between signed and unsigned. */
1014 if (!unsigned_p)
1015 {
1016 /* Signed -> Unsigned. */
1017 if (a.high < 0)
1018 {
1019 if (sat_p)
1020 {
1021 f->data.low = 0; /* Set to zero. */
1022 f->data.high = 0; /* Set to zero. */
1023 }
1024 else
1025 overflow_p = true;
1026 }
1027 else
1028 overflow_p = fixed_saturate2 (f->mode, temp_high, temp_low,
1029 &f->data, sat_p);
1030 }
1031 else
1032 {
1033 /* Unsigned -> Signed. */
1034 if (temp_high.high < 0)
1035 {
1036 if (sat_p)
1037 {
1038 /* Set to maximum. */
1039 f->data.low = -1; /* Set to all ones. */
1040 f->data.high = -1; /* Set to all ones. */
1041 f->data = double_int_ext (f->data,
1042 GET_MODE_FBIT (f->mode)
1043 + GET_MODE_IBIT (f->mode),
1044 1); /* Clear the sign. */
1045 }
1046 else
1047 overflow_p = true;
1048 }
1049 else
1050 overflow_p = fixed_saturate2 (f->mode, temp_high, temp_low,
1051 &f->data, sat_p);
1052 }
1053 }
1054 f->data = double_int_ext (f->data,
1055 SIGNED_FIXED_POINT_MODE_P (f->mode)
1056 + GET_MODE_FBIT (f->mode)
1057 + GET_MODE_IBIT (f->mode),
1058 UNSIGNED_FIXED_POINT_MODE_P (f->mode));
1059 return overflow_p;
1060 }
1061
1062 /* Convert to a new fixed-point mode from a real.
1063 If SAT_P, saturate the result to the max or the min.
1064 Return true, if !SAT_P and overflow. */
1065
1066 bool
fixed_convert_from_real(FIXED_VALUE_TYPE * f,enum machine_mode mode,const REAL_VALUE_TYPE * a,bool sat_p)1067 fixed_convert_from_real (FIXED_VALUE_TYPE *f, enum machine_mode mode,
1068 const REAL_VALUE_TYPE *a, bool sat_p)
1069 {
1070 bool overflow_p = false;
1071 REAL_VALUE_TYPE real_value, fixed_value, base_value;
1072 bool unsigned_p = UNSIGNED_FIXED_POINT_MODE_P (mode);
1073 int i_f_bits = GET_MODE_IBIT (mode) + GET_MODE_FBIT (mode);
1074 unsigned int fbit = GET_MODE_FBIT (mode);
1075 enum fixed_value_range_code temp;
1076
1077 real_value = *a;
1078 f->mode = mode;
1079 real_2expN (&base_value, fbit, mode);
1080 real_arithmetic (&fixed_value, MULT_EXPR, &real_value, &base_value);
1081 real_to_integer2 ((HOST_WIDE_INT *)&f->data.low, &f->data.high, &fixed_value);
1082 temp = check_real_for_fixed_mode (&real_value, mode);
1083 if (temp == FIXED_UNDERFLOW) /* Minimum. */
1084 {
1085 if (sat_p)
1086 {
1087 if (unsigned_p)
1088 {
1089 f->data.low = 0;
1090 f->data.high = 0;
1091 }
1092 else
1093 {
1094 f->data.low = 1;
1095 f->data.high = 0;
1096 lshift_double (f->data.low, f->data.high, i_f_bits,
1097 2 * HOST_BITS_PER_WIDE_INT,
1098 &f->data.low, &f->data.high, 1);
1099 f->data = double_int_ext (f->data, 1 + i_f_bits, 0);
1100 }
1101 }
1102 else
1103 overflow_p = true;
1104 }
1105 else if (temp == FIXED_GT_MAX_EPS || temp == FIXED_MAX_EPS) /* Maximum. */
1106 {
1107 if (sat_p)
1108 {
1109 f->data.low = -1;
1110 f->data.high = -1;
1111 f->data = double_int_ext (f->data, i_f_bits, 1);
1112 }
1113 else
1114 overflow_p = true;
1115 }
1116 f->data = double_int_ext (f->data, (!unsigned_p) + i_f_bits, unsigned_p);
1117 return overflow_p;
1118 }
1119
1120 /* Convert to a new real mode from a fixed-point. */
1121
1122 void
real_convert_from_fixed(REAL_VALUE_TYPE * r,enum machine_mode mode,const FIXED_VALUE_TYPE * f)1123 real_convert_from_fixed (REAL_VALUE_TYPE *r, enum machine_mode mode,
1124 const FIXED_VALUE_TYPE *f)
1125 {
1126 REAL_VALUE_TYPE base_value, fixed_value, real_value;
1127
1128 real_2expN (&base_value, GET_MODE_FBIT (f->mode), f->mode);
1129 real_from_integer (&fixed_value, VOIDmode, f->data.low, f->data.high,
1130 UNSIGNED_FIXED_POINT_MODE_P (f->mode));
1131 real_arithmetic (&real_value, RDIV_EXPR, &fixed_value, &base_value);
1132 real_convert (r, mode, &real_value);
1133 }
1134
1135 /* Determine whether a fixed-point value F is negative. */
1136
1137 bool
fixed_isneg(const FIXED_VALUE_TYPE * f)1138 fixed_isneg (const FIXED_VALUE_TYPE *f)
1139 {
1140 if (SIGNED_FIXED_POINT_MODE_P (f->mode))
1141 {
1142 int i_f_bits = GET_MODE_IBIT (f->mode) + GET_MODE_FBIT (f->mode);
1143 int sign_bit = get_fixed_sign_bit (f->data, i_f_bits);
1144 if (sign_bit == 1)
1145 return true;
1146 }
1147
1148 return false;
1149 }
1150