OSDN Git Service

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