gcc/fixed-value.c

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