libgcc/fixed-bit.c

   1 /* This is a software fixed-point library.
   2    Copyright (C) 2007-2019 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 Under Section 7 of GPL version 3, you are granted additional
  17 permissions described in the GCC Runtime Library Exception, version
  18 3.1, as published by the Free Software Foundation.
  19
  20 You should have received a copy of the GNU General Public License and
  21 a copy of the GCC Runtime Library Exception along with this program;
  22 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25 /* This implements fixed-point arithmetic.
  26
  27    Contributed by Chao-ying Fu  <fu@mips.com>.  */
  28
  29 /* To use this file, we need to define one of the following:
  30    QQ_MODE, UQQ_MODE, HQ_MODE, UHQ_MODE, SQ_MODE, USQ_MODE, DQ_MODE, UDQ_MODE,
  31    TQ_MODE, UTQ_MODE, HA_MODE, UHA_MODE, SA_MODE, USA_MODE, DA_MODE, UDA_MODE,
  32    TA_MODE, UTA_MODE.
  33    Then, all operators for this machine mode will be created.
  34
  35    Or, we need to define FROM_* TO_* for conversions from one mode to another
  36    mode.  The mode could be one of the following:
  37    Fract: QQ, UQQ, HQ, UHQ, SQ, USQ, DQ, UDQ, TQ, UTQ
  38    Accum: HA, UHA, SA, USA, DA, UDA, TA, UTA
  39    Signed integer: QI, HI, SI, DI, TI
  40    Unsigned integer: UQI, UHI, USI, UDI, UTI
  41    Floating-point: SF, DF
  42    Ex: If we define FROM_QQ and TO_SI, the conversion from QQ to SI is
  43    generated.  */
  44
  45 #include "tconfig.h"
  46 #include "tsystem.h"
  47 #include "coretypes.h"
  48 #include "tm.h"
  49 #include "libgcc_tm.h"
  50
  51 #ifndef MIN_UNITS_PER_WORD
  52 #define MIN_UNITS_PER_WORD UNITS_PER_WORD
  53 #endif
  54
  55 #include "fixed-bit.h"
  56
  57 #if defined(FIXED_ADD) && defined(L_add)
  58 FIXED_C_TYPE
  59 FIXED_ADD (FIXED_C_TYPE a, FIXED_C_TYPE b)
  60 {
  61   FIXED_C_TYPE c;
  62   INT_C_TYPE x, y, z;
  63   memcpy (&x, &a, FIXED_SIZE);
  64   memcpy (&y, &b, FIXED_SIZE);
  65   z = x + y;
  66 #if HAVE_PADDING_BITS
  67   z = z << PADDING_BITS;
  68   z = z >> PADDING_BITS;
  69 #endif
  70   memcpy (&c, &z, FIXED_SIZE);
  71   return c;
  72 }
  73 #endif /* FIXED_ADD */
  74
  75 #if defined(FIXED_SSADD) && defined(L_ssadd)
  76 FIXED_C_TYPE
  77 FIXED_SSADD (FIXED_C_TYPE a, FIXED_C_TYPE b)
  78 {
  79   FIXED_C_TYPE c;
  80   INT_C_TYPE x, y, z;
  81   memcpy (&x, &a, FIXED_SIZE);
  82   memcpy (&y, &b, FIXED_SIZE);
  83   z = x + (UINT_C_TYPE) y;
  84   if ((((x ^ y) >> I_F_BITS) & 1) == 0)
  85     {
  86       if (((z ^ x) >> I_F_BITS) & 1)
  87         {
  88           z = ((UINT_C_TYPE) 1) << I_F_BITS;
  89           if (x >= 0)
  90             z -= (UINT_C_TYPE) 1;
  91         }
  92     }
  93 #if HAVE_PADDING_BITS
  94   z = z << PADDING_BITS;
  95   z = z >> PADDING_BITS;
  96 #endif
  97   memcpy (&c, &z, FIXED_SIZE);
  98   return c;
  99 }
 100 #endif /* FIXED_SSADD */
 101
 102 #if defined(FIXED_USADD) && defined(L_usadd)
 103 FIXED_C_TYPE
 104 FIXED_USADD (FIXED_C_TYPE a, FIXED_C_TYPE b)
 105 {
 106   FIXED_C_TYPE c;
 107   INT_C_TYPE x, y, z;
 108   memcpy (&x, &a, FIXED_SIZE);
 109   memcpy (&y, &b, FIXED_SIZE);
 110   z = x + y;
 111 #if HAVE_PADDING_BITS
 112   z = z << PADDING_BITS;
 113   z = z >> PADDING_BITS;
 114 #endif
 115   if (z < x || z < y) /* max */
 116     {
 117        z = -1;
 118 #if HAVE_PADDING_BITS
 119        z = z << PADDING_BITS;
 120        z = z >> PADDING_BITS;
 121 #endif
 122     }
 123   memcpy (&c, &z, FIXED_SIZE);
 124   return c;
 125 }
 126 #endif /* FIXED_USADD */
 127
 128 #if defined(FIXED_SUB) && defined(L_sub)
 129 FIXED_C_TYPE
 130 FIXED_SUB (FIXED_C_TYPE a, FIXED_C_TYPE b)
 131 {
 132   FIXED_C_TYPE c;
 133   INT_C_TYPE x, y, z;
 134   memcpy (&x, &a, FIXED_SIZE);
 135   memcpy (&y, &b, FIXED_SIZE);
 136   z = x - y;
 137 #if HAVE_PADDING_BITS
 138   z = z << PADDING_BITS;
 139   z = z >> PADDING_BITS;
 140 #endif
 141   memcpy (&c, &z, FIXED_SIZE);
 142   return c;
 143 }
 144 #endif /* FIXED_SUB */
 145
 146 #if defined(FIXED_SSSUB) && defined(L_sssub)
 147 FIXED_C_TYPE
 148 FIXED_SSSUB (FIXED_C_TYPE a, FIXED_C_TYPE b)
 149 {
 150   FIXED_C_TYPE c;
 151   INT_C_TYPE x, y, z;
 152   memcpy (&x, &a, FIXED_SIZE);
 153   memcpy (&y, &b, FIXED_SIZE);
 154   z = x - (UINT_C_TYPE) y;
 155   if (((x ^ y) >> I_F_BITS) & 1)
 156     {
 157       if (((z ^ x) >> I_F_BITS) & 1)
 158         {
 159           z = ((UINT_C_TYPE) 1) << I_F_BITS;
 160           if (x >= 0)
 161             z -= (UINT_C_TYPE) 1;
 162         }
 163     }
 164 #if HAVE_PADDING_BITS
 165   z = z << PADDING_BITS;
 166   z = z >> PADDING_BITS;
 167 #endif
 168   memcpy (&c, &z, FIXED_SIZE);
 169   return c;
 170 }
 171 #endif /* FIXED_SSSUB */
 172
 173 #if defined(FIXED_USSUB) && defined(L_ussub)
 174 FIXED_C_TYPE
 175 FIXED_USSUB (FIXED_C_TYPE a, FIXED_C_TYPE b)
 176 {
 177   FIXED_C_TYPE c;
 178   INT_C_TYPE x, y, z;
 179   memcpy (&x, &a, FIXED_SIZE);
 180   memcpy (&y, &b, FIXED_SIZE);
 181   z = x - y;
 182   if (x < y)
 183     z = 0;
 184 #if HAVE_PADDING_BITS
 185   z = z << PADDING_BITS;
 186   z = z >> PADDING_BITS;
 187 #endif
 188   memcpy (&c, &z, FIXED_SIZE);
 189   return c;
 190 }
 191 #endif /* FIXED_USSUB */
 192
 193 #if defined(FIXED_SATURATE1) && defined(L_saturate1)
 194 void
 195 FIXED_SATURATE1 (DINT_C_TYPE *a)
 196 {
 197   DINT_C_TYPE max, min;
 198   max = (DINT_C_TYPE)1 << I_F_BITS;
 199   max = max - 1;
 200 #if MODE_UNSIGNED == 0
 201   min = (DINT_C_TYPE)1 << (2 * FIXED_WIDTH - 1);
 202   min = min >> (2 * FIXED_WIDTH - 1 - I_F_BITS);
 203 #else
 204   min = 0;
 205 #endif
 206   if (*a > max)
 207     *a = max;
 208   else if (*a < min)
 209     *a = min;
 210 }
 211 #endif /* FIXED_SATURATE1 */
 212
 213 #if defined(FIXED_SATURATE2) && defined(L_saturate2)
 214 void
 215 FIXED_SATURATE2 (INT_C_TYPE *high, INT_C_TYPE *low)
 216 {
 217   INT_C_TYPE r_max, s_max, r_min, s_min;
 218   r_max = 0;
 219 #if (MODE_UNSIGNED == 0) || HAVE_PADDING_BITS
 220   s_max = (INT_C_TYPE)1 << I_F_BITS;
 221   s_max = s_max - 1;
 222 #else
 223   s_max = -1;
 224 #endif
 225 #if MODE_UNSIGNED == 0
 226   r_min = -1;
 227   s_min = (INT_C_TYPE)1 << (FIXED_WIDTH - 1);
 228   s_min = s_min >> (FIXED_WIDTH - 1 - I_F_BITS);
 229 #else
 230   r_min = 0;
 231   s_min = 0;
 232 #endif
 233
 234   if (*high > r_max
 235       || (*high == r_max && (UINT_C_TYPE)(*low) > (UINT_C_TYPE)s_max))
 236     {
 237       *high = r_max;
 238       *low = s_max;
 239     }
 240   else if (*high < r_min ||
 241            (*high == r_min && (UINT_C_TYPE)(*low) < (UINT_C_TYPE)s_min))
 242     {
 243       *high = r_min;
 244       *low = s_min;
 245     }
 246 }
 247 #endif /* FIXED_SATURATE2 */
 248
 249 #if defined(FIXED_MULHELPER) && defined(L_mulhelper)
 250 FIXED_C_TYPE
 251 FIXED_MULHELPER (FIXED_C_TYPE a, FIXED_C_TYPE b, word_type satp)
 252 {
 253   FIXED_C_TYPE c;
 254   INT_C_TYPE x, y;
 255
 256 #if defined (DINT_C_TYPE)
 257   INT_C_TYPE z;
 258   DINT_C_TYPE dx, dy, dz;
 259   memcpy (&x, &a, FIXED_SIZE);
 260   memcpy (&y, &b, FIXED_SIZE);
 261   dx = (DINT_C_TYPE) x;
 262   dy = (DINT_C_TYPE) y;
 263   dz = dx * dy;
 264   /* Round the result by adding (1 << (FBITS -1)).  */
 265   dz += ((DINT_C_TYPE) 1 << (FBITS - 1));
 266   dz = dz >> FBITS;
 267   if (satp)
 268     FIXED_SATURATE1 (&dz);
 269
 270   z = (INT_C_TYPE) dz;
 271 #if HAVE_PADDING_BITS
 272   z = z << PADDING_BITS;
 273   z = z >> PADDING_BITS;
 274 #endif
 275   memcpy (&c, &z, FIXED_SIZE);
 276   return c;
 277
 278 #else /* No DINT_C_TYPE */
 279   /* The result of multiplication expands to two INT_C_TYPE.  */
 280   INTunion aa, bb;
 281   INTunion a_high, a_low, b_high, b_low;
 282   INTunion high_high, high_low, low_high, low_low;
 283   INTunion r, s, temp1, temp2;
 284   INT_C_TYPE carry = 0;
 285   INT_C_TYPE z;
 286
 287   memcpy (&x, &a, FIXED_SIZE);
 288   memcpy (&y, &b, FIXED_SIZE);
 289
 290   /* Decompose a and b.  */
 291   aa.ll = x;
 292   bb.ll = y;
 293
 294   a_high.s.low = aa.s.high;
 295   a_high.s.high = 0;
 296   a_low.s.low = aa.s.low;
 297   a_low.s.high = 0;
 298   b_high.s.low = bb.s.high;
 299   b_high.s.high = 0;
 300   b_low.s.low = bb.s.low;
 301   b_low.s.high = 0;
 302
 303   /* Perform four multiplications.  */
 304   low_low.ll = a_low.ll * b_low.ll;
 305   low_high.ll = a_low.ll * b_high.ll;
 306   high_low.ll = a_high.ll * b_low.ll;
 307   high_high.ll = a_high.ll * b_high.ll;
 308
 309   /* Accumulate four results to {r, s}.  */
 310   temp1.s.high = high_low.s.low;
 311   temp1.s.low = 0;
 312   s.ll = low_low.ll + temp1.ll;
 313   if ((UINT_C_TYPE) s.ll < (UINT_C_TYPE) low_low.ll
 314       || (UINT_C_TYPE) s.ll < (UINT_C_TYPE) temp1.ll)
 315     carry ++; /* Carry.  */
 316   temp1.ll = s.ll;
 317   temp2.s.high = low_high.s.low;
 318   temp2.s.low = 0;
 319   s.ll = temp1.ll + temp2.ll;
 320   if ((UINT_C_TYPE) s.ll < (UINT_C_TYPE) temp1.ll
 321       || (UINT_C_TYPE) s.ll < (UINT_C_TYPE) temp2.ll)
 322     carry ++; /* Carry.  */
 323
 324   temp1.s.low = high_low.s.high;
 325   temp1.s.high = 0;
 326   r.ll = high_high.ll + temp1.ll;
 327   temp1.s.low = low_high.s.high;
 328   temp1.s.high = 0;
 329   r.ll = r.ll + temp1.ll + carry;
 330
 331 #if MODE_UNSIGNED == 0
 332   /* For signed types, we need to add neg(y) to r, if x < 0.  */
 333   if (x < 0)
 334     r.ll = r.ll - y;
 335   /* We need to add neg(x) to r, if y < 0.  */
 336   if (y < 0)
 337     r.ll = r.ll - x;
 338 #endif
 339
 340   /* Round the result by adding (1 << (FBITS -1)).  */
 341   temp1.ll = s.ll;
 342   s.ll += ((INT_C_TYPE) 1 << (FBITS -1));
 343   if ((UINT_C_TYPE) s.ll < (UINT_C_TYPE) temp1.ll
 344       || (UINT_C_TYPE) s.ll < (UINT_C_TYPE) ((INT_C_TYPE) 1 << (FBITS -1)))
 345     r.ll += 1;
 346
 347   /* Shift right the result by FBITS.  */
 348 #if FBITS == FIXED_WIDTH
 349   /* This happens only for unsigned types without any padding bits.
 350      So, it is safe to set r.ll to 0 as it is logically shifted right.  */
 351   s.ll = r.ll;
 352   r.ll = 0;
 353 #else
 354   s.ll = ((UINT_C_TYPE)s.ll) >> FBITS;
 355   temp1.ll = r.ll << (FIXED_WIDTH - FBITS);
 356   s.ll = s.ll | temp1.ll;
 357   r.ll = r.ll >> FBITS;
 358 #endif
 359
 360   if (satp)
 361     FIXED_SATURATE2 (&r.ll, &s.ll);
 362
 363   z = (INT_C_TYPE) s.ll;
 364 #if HAVE_PADDING_BITS
 365   z = z << PADDING_BITS;
 366   z = z >> PADDING_BITS;
 367 #endif
 368   memcpy (&c, &z, FIXED_SIZE);
 369   return c;
 370 #endif
 371 }
 372 #endif /* FIXED_MULHELPER */
 373
 374 #if defined(FIXED_MUL) && defined(L_mul)
 375 FIXED_C_TYPE
 376 FIXED_MUL (FIXED_C_TYPE a, FIXED_C_TYPE b)
 377 {
 378   return FIXED_MULHELPER (a, b, 0);
 379 }
 380 #endif /* FIXED_MUL */
 381
 382 #if defined(FIXED_SSMUL) && defined(L_ssmul)
 383 FIXED_C_TYPE
 384 FIXED_SSMUL (FIXED_C_TYPE a, FIXED_C_TYPE b)
 385 {
 386   return FIXED_MULHELPER (a, b, 1);
 387 }
 388 #endif /* FIXED_SSMUL */
 389
 390 #if defined(FIXED_USMUL) && defined(L_usmul)
 391 FIXED_C_TYPE
 392 FIXED_USMUL (FIXED_C_TYPE a, FIXED_C_TYPE b)
 393 {
 394   return FIXED_MULHELPER (a, b, 1);
 395 }
 396 #endif /* FIXED_USMUL */
 397
 398 #if defined(FIXED_DIVHELPER) && defined(L_divhelper)
 399 FIXED_C_TYPE
 400 FIXED_DIVHELPER (FIXED_C_TYPE a, FIXED_C_TYPE b, word_type satp)
 401 {
 402   FIXED_C_TYPE c;
 403   INT_C_TYPE x, y;
 404   INT_C_TYPE z;
 405
 406 #if defined (DINT_C_TYPE)
 407   DINT_C_TYPE dx, dy, dz;
 408   memcpy (&x, &a, FIXED_SIZE);
 409   memcpy (&y, &b, FIXED_SIZE);
 410   dx = (DINT_C_TYPE) x;
 411   dy = (DINT_C_TYPE) y;
 412   dx = dx << FBITS;
 413   dz = dx / dy;
 414   if (satp)
 415     FIXED_SATURATE1 (&dz);
 416   z = (INT_C_TYPE) dz;
 417 #if HAVE_PADDING_BITS
 418   z = z << PADDING_BITS;
 419   z = z >> PADDING_BITS;
 420 #endif
 421   memcpy (&c, &z, FIXED_SIZE);
 422   return c;
 423
 424 #else /* No DINT_C_TYPE */
 425   INT_C_TYPE pos_a, pos_b, r, s;
 426   INT_C_TYPE quo_r, quo_s, mod, temp;
 427   word_type i;
 428 #if MODE_UNSIGNED == 0
 429   word_type num_of_neg = 0;
 430 #endif
 431
 432   memcpy (&x, &a, FIXED_SIZE);
 433   memcpy (&y, &b, FIXED_SIZE);
 434   pos_a = x;
 435   pos_b = y;
 436
 437 #if MODE_UNSIGNED == 0
 438   /* If a < 0, negate a.  */
 439   if (pos_a < 0)
 440     {
 441       pos_a = -pos_a;
 442       num_of_neg ++;
 443     }
 444   /* If b < 0, negate b.  */
 445   if (pos_b < 0)
 446     {
 447       pos_b = -pos_b;
 448       num_of_neg ++;
 449     }
 450 #endif
 451
 452   /* Left shift pos_a to {r, s} by FBITS.  */
 453 #if FBITS == FIXED_WIDTH
 454   /* This happens only for unsigned types without any padding bits.  */
 455   r = pos_a;
 456   s = 0;
 457 #else
 458   s = pos_a << FBITS;
 459   r = pos_a >> (FIXED_WIDTH - FBITS);
 460 #endif
 461
 462   /* Unsigned divide r by pos_b to quo_r.  The remainder is in mod.  */
 463   quo_r = (UINT_C_TYPE)r / (UINT_C_TYPE)pos_b;
 464   mod = (UINT_C_TYPE)r % (UINT_C_TYPE)pos_b;
 465   quo_s = 0;
 466
 467   for (i = 0; i < FIXED_WIDTH; i++)
 468     {
 469       /* Record the leftmost bit of mod.  */
 470       word_type leftmost_mode = (mod >> (FIXED_WIDTH - 1)) & 1;
 471       /* Shift left mod by 1 bit.  */
 472       mod = mod << 1;
 473       /* Test the leftmost bit of s to add to mod.  */
 474       if ((s >> (FIXED_WIDTH - 1)) & 1)
 475         mod ++;
 476       /* Shift left quo_s by 1 bit.  */
 477       quo_s = quo_s << 1;
 478       /* Try to calculate (mod - pos_b).  */
 479       temp = mod - pos_b;
 480       if (leftmost_mode || (UINT_C_TYPE)mod >= (UINT_C_TYPE)pos_b)
 481         {
 482           quo_s ++;
 483           mod = temp;
 484         }
 485       /* Shift left s by 1 bit.  */
 486       s = s << 1;
 487     }
 488
 489 #if MODE_UNSIGNED == 0
 490     if (num_of_neg == 1)
 491       {
 492         quo_s = -quo_s;
 493         if (quo_s == 0)
 494           quo_r = -quo_r;
 495         else
 496           quo_r = ~quo_r;
 497       }
 498 #endif
 499   if (satp)
 500     FIXED_SATURATE2 (&quo_r, &quo_s);
 501   z = quo_s;
 502 #if HAVE_PADDING_BITS
 503   z = z << PADDING_BITS;
 504   z = z >> PADDING_BITS;
 505 #endif
 506   memcpy (&c, &z, FIXED_SIZE);
 507   return c;
 508 #endif
 509 }
 510 #endif /* FIXED_DIVHELPER */
 511
 512 #if defined(FIXED_DIV) && defined(L_div)
 513 FIXED_C_TYPE
 514 FIXED_DIV (FIXED_C_TYPE a, FIXED_C_TYPE b)
 515 {
 516   return FIXED_DIVHELPER (a, b, 0);
 517 }
 518 #endif /* FIXED_DIV */
 519
 520
 521 #if defined(FIXED_UDIV) && defined(L_udiv)
 522 FIXED_C_TYPE
 523 FIXED_UDIV (FIXED_C_TYPE a, FIXED_C_TYPE b)
 524 {
 525   return FIXED_DIVHELPER (a, b, 0);
 526 }
 527 #endif /* FIXED_UDIV */
 528
 529 #if defined(FIXED_SSDIV) && defined(L_ssdiv)
 530 FIXED_C_TYPE
 531 FIXED_SSDIV (FIXED_C_TYPE a, FIXED_C_TYPE b)
 532 {
 533   return FIXED_DIVHELPER (a, b, 1);
 534 }
 535 #endif /* FIXED_SSDIV */
 536
 537 #if defined(FIXED_USDIV) && defined(L_usdiv)
 538 FIXED_C_TYPE
 539 FIXED_USDIV (FIXED_C_TYPE a, FIXED_C_TYPE b)
 540 {
 541   return FIXED_DIVHELPER (a, b, 1);
 542 }
 543 #endif /* FIXED_USDIV */
 544
 545 #if defined(FIXED_NEG) && defined(L_neg)
 546 FIXED_C_TYPE
 547 FIXED_NEG (FIXED_C_TYPE a)
 548 {
 549   FIXED_C_TYPE c;
 550   INT_C_TYPE x, z;
 551   memcpy (&x, &a, FIXED_SIZE);
 552   z = -x;
 553 #if HAVE_PADDING_BITS
 554   z = z << PADDING_BITS;
 555   z = z >> PADDING_BITS;
 556 #endif
 557   memcpy (&c, &z, FIXED_SIZE);
 558   return c;
 559 }
 560 #endif /* FIXED_NEG */
 561
 562 #if defined(FIXED_SSNEG) && defined(L_ssneg)
 563 FIXED_C_TYPE
 564 FIXED_SSNEG (FIXED_C_TYPE a)
 565 {
 566   FIXED_C_TYPE c;
 567   INT_C_TYPE x, y, z;
 568   memcpy (&y, &a, FIXED_SIZE);
 569   x = 0;
 570   z = x - (UINT_C_TYPE) y;
 571   if (((x ^ y) >> I_F_BITS) & 1)
 572     {
 573       if (((z ^ x) >> I_F_BITS) & 1)
 574         z = (((UINT_C_TYPE) 1) << I_F_BITS) - 1;
 575     }
 576 #if HAVE_PADDING_BITS
 577   z = z << PADDING_BITS;
 578   z = z >> PADDING_BITS;
 579 #endif
 580   memcpy (&c, &z, FIXED_SIZE);
 581   return c;
 582 }
 583 #endif /* FIXED_SSNEG */
 584
 585 #if defined(FIXED_USNEG) && defined(L_usneg)
 586 FIXED_C_TYPE
 587 FIXED_USNEG (FIXED_C_TYPE a __attribute__ ((__unused__)))
 588 {
 589   FIXED_C_TYPE c;
 590   INT_C_TYPE z;
 591   z = 0;
 592   memcpy (&c, &z, FIXED_SIZE);
 593   return c;
 594 }
 595 #endif /* FIXED_USNEG */
 596
 597 #if defined(FIXED_ASHLHELPER) && defined(L_ashlhelper)
 598 FIXED_C_TYPE
 599 FIXED_ASHLHELPER (FIXED_C_TYPE a, word_type b, word_type satp)
 600 {
 601   FIXED_C_TYPE c;
 602   INT_C_TYPE x, z;
 603
 604 #if defined (DINT_C_TYPE)
 605   DINT_C_TYPE dx, dz;
 606   memcpy (&x, &a, FIXED_SIZE);
 607   dx = (DINT_C_TYPE) x;
 608   if (b >= FIXED_WIDTH)
 609     dz = dx << FIXED_WIDTH;
 610   else
 611     dz = dx << b;
 612   if (satp)
 613     FIXED_SATURATE1 (&dz);
 614   z = (INT_C_TYPE) dz;
 615 #if HAVE_PADDING_BITS
 616   z = z << PADDING_BITS;
 617   z = z >> PADDING_BITS;
 618 #endif
 619   memcpy (&c, &z, FIXED_SIZE);
 620   return c;
 621
 622 #else /* No DINT_C_TYPE */
 623   INT_C_TYPE r, s;
 624   memcpy (&x, &a, FIXED_SIZE);
 625   /* We need to shift left x by b bits to {r, s}.  */
 626   if (b >= FIXED_WIDTH)
 627     {
 628       r = b;
 629       s = 0;
 630     }
 631   else
 632     {
 633       s = x << b;
 634       r = x >> (FIXED_WIDTH - b);
 635     }
 636   if (satp)
 637     FIXED_SATURATE2 (&r, &s);
 638   z = s;
 639 #if HAVE_PADDING_BITS
 640   z = z << PADDING_BITS;
 641   z = z >> PADDING_BITS;
 642 #endif
 643   memcpy (&c, &z, FIXED_SIZE);
 644   return c;
 645 #endif
 646 }
 647 #endif /* FIXED_ASHLHELPER */
 648
 649 #if defined(FIXED_ASHL) && defined(L_ashl)
 650 FIXED_C_TYPE
 651 FIXED_ASHL (FIXED_C_TYPE a, word_type b)
 652 {
 653   return FIXED_ASHLHELPER (a, b, 0);
 654 }
 655 #endif /* FIXED_ASHL */
 656
 657 #if defined(FIXED_ASHR) && defined(L_ashr)
 658 FIXED_C_TYPE
 659 FIXED_ASHR (FIXED_C_TYPE a, word_type b)
 660 {
 661   FIXED_C_TYPE c;
 662   INT_C_TYPE x, z;
 663   memcpy (&x, &a, FIXED_SIZE);
 664   z = x >> b;
 665 #if HAVE_PADDING_BITS
 666   z = z << PADDING_BITS;
 667   z = z >> PADDING_BITS;
 668 #endif
 669   memcpy (&c, &z, FIXED_SIZE);
 670   return c;
 671 }
 672 #endif /* FIXED_ASHR */
 673
 674 #if defined(FIXED_LSHR) && defined(L_lshr)
 675 FIXED_C_TYPE
 676 FIXED_LSHR (FIXED_C_TYPE a, word_type b)
 677 {
 678   FIXED_C_TYPE c;
 679   INT_C_TYPE x, z;
 680   memcpy (&x, &a, FIXED_SIZE);
 681   z = x >> b;
 682 #if HAVE_PADDING_BITS
 683   z = z << PADDING_BITS;
 684   z = z >> PADDING_BITS;
 685 #endif
 686   memcpy (&c, &z, FIXED_SIZE);
 687   return c;
 688 }
 689 #endif /* FIXED_LSHR */
 690
 691 #if defined(FIXED_SSASHL) && defined(L_ssashl)
 692 FIXED_C_TYPE
 693 FIXED_SSASHL (FIXED_C_TYPE a, word_type b)
 694 {
 695   return FIXED_ASHLHELPER (a, b, 1);
 696 }
 697 #endif /* FIXED_SSASHL */
 698
 699 #if defined(FIXED_USASHL) && defined(L_usashl)
 700 FIXED_C_TYPE
 701 FIXED_USASHL (FIXED_C_TYPE a, word_type b)
 702 {
 703   return FIXED_ASHLHELPER (a, b, 1);
 704 }
 705 #endif /* FIXED_USASHL */
 706
 707 #if defined(FIXED_CMP) && defined(L_cmp)
 708 word_type
 709 FIXED_CMP (FIXED_C_TYPE a, FIXED_C_TYPE b)
 710 {
 711   INT_C_TYPE x, y;
 712   memcpy (&x, &a, FIXED_SIZE);
 713   memcpy (&y, &b, FIXED_SIZE);
 714
 715   if (x < y)
 716     return 0;
 717   else if (x > y)
 718     return 2;
 719
 720   return 1;
 721 }
 722 #endif /* FIXED_CMP */
 723
 724 /* Fixed -> Fixed.  */
 725 #if defined(FRACT) && defined(L_fract) && FROM_TYPE == 4 && TO_TYPE == 4
 726 TO_FIXED_C_TYPE
 727 FRACT (FROM_FIXED_C_TYPE a)
 728 {
 729   TO_FIXED_C_TYPE c;
 730   FROM_INT_C_TYPE x;
 731   TO_INT_C_TYPE z;
 732   int shift_amount;
 733   memcpy (&x, &a, FROM_FIXED_SIZE);
 734 #if TO_FBITS > FROM_FBITS  /* Need left shift.  */
 735   shift_amount = TO_FBITS - FROM_FBITS;
 736   z = (TO_INT_C_TYPE) x;
 737   z = z << shift_amount;
 738 #else /* TO_FBITS <= FROM_FBITS.  Need right Shift.  */
 739   shift_amount = FROM_FBITS - TO_FBITS;
 740   x = x >> shift_amount;
 741   z = (TO_INT_C_TYPE) x;
 742 #endif /* TO_FBITS > FROM_FBITS  */
 743
 744 #if TO_HAVE_PADDING_BITS
 745   z = z << TO_PADDING_BITS;
 746   z = z >> TO_PADDING_BITS;
 747 #endif
 748   memcpy (&c, &z, TO_FIXED_SIZE);
 749   return c;
 750 }
 751 #endif /* FRACT && FROM_TYPE == 4 && TO_TYPE == 4  */
 752
 753 /* Fixed -> Fixed with saturation.  */
 754 #if defined(SATFRACT) && defined(L_satfract) && FROM_TYPE == 4 && TO_TYPE == 4
 755 TO_FIXED_C_TYPE
 756 SATFRACT (FROM_FIXED_C_TYPE a)
 757 {
 758   TO_FIXED_C_TYPE c;
 759   TO_INT_C_TYPE z;
 760   FROM_INT_C_TYPE x;
 761 #if FROM_MODE_UNSIGNED == 0
 762   BIG_SINT_C_TYPE high, low;
 763   BIG_SINT_C_TYPE max_high, max_low;
 764 #if TO_MODE_UNSIGNED == 0
 765   BIG_SINT_C_TYPE min_high, min_low;
 766 #endif
 767 #else
 768   BIG_UINT_C_TYPE high, low;
 769   BIG_UINT_C_TYPE max_high, max_low;
 770 #endif
 771 #if TO_FBITS > FROM_FBITS
 772   BIG_UINT_C_TYPE utemp;
 773 #endif
 774 #if TO_MODE_UNSIGNED == 0
 775   BIG_SINT_C_TYPE stemp;
 776 #endif
 777 #if TO_FBITS != FROM_FBITS
 778   int shift_amount;
 779 #endif
 780   memcpy (&x, &a, FROM_FIXED_SIZE);
 781
 782   /* Step 1. We need to store x to {high, low}.  */
 783 #if FROM_MODE_UNSIGNED == 0
 784   low = (BIG_SINT_C_TYPE) x;
 785   if (x < 0)
 786     high = -1;
 787   else
 788     high = 0;
 789 #else
 790   low = (BIG_UINT_C_TYPE) x;
 791   high = 0;
 792 #endif
 793
 794   /* Step 2. We need to shift {high, low}.  */
 795 #if TO_FBITS > FROM_FBITS /* Left shift.  */
 796   shift_amount = TO_FBITS - FROM_FBITS;
 797   utemp = (BIG_UINT_C_TYPE) low;
 798   utemp = utemp >> (BIG_WIDTH - shift_amount);
 799   high = ((BIG_UINT_C_TYPE)(high << shift_amount)) | utemp;
 800   low = low << shift_amount;
 801 #elif TO_FBITS < FROM_FBITS /* Right shift.  */
 802   shift_amount = FROM_FBITS - TO_FBITS;
 803   low = low >> shift_amount;
 804 #endif
 805
 806   /* Step 3. Compare {high, low} with max and  min of TO_FIXED_C_TYPE.  */
 807   max_high = 0;
 808 #if BIG_WIDTH > TO_FIXED_WIDTH || TO_MODE_UNSIGNED == 0 || TO_HAVE_PADDING_BITS
 809   max_low = (BIG_UINT_C_TYPE)1 << TO_I_F_BITS;
 810   max_low = max_low - 1;
 811 #else
 812   max_low = -1;
 813 #endif
 814
 815 #if TO_MODE_UNSIGNED == 0
 816   stemp = (BIG_SINT_C_TYPE)1 << (BIG_WIDTH - 1);
 817   stemp = stemp >> (BIG_WIDTH - 1 - TO_I_F_BITS);
 818 #if FROM_MODE_UNSIGNED == 0
 819   min_high = -1;
 820   min_low = stemp;
 821 #endif
 822 #endif
 823
 824 #if FROM_MODE_UNSIGNED == 0 && TO_MODE_UNSIGNED == 0
 825   /* Signed -> Signed.  */
 826   if ((BIG_SINT_C_TYPE) high > (BIG_SINT_C_TYPE) max_high
 827       || ((BIG_SINT_C_TYPE) high == (BIG_SINT_C_TYPE) max_high
 828           && (BIG_UINT_C_TYPE) low > (BIG_UINT_C_TYPE) max_low))
 829     low = max_low; /* Maximum.  */
 830   else if ((BIG_SINT_C_TYPE) high < (BIG_SINT_C_TYPE) min_high
 831            || ((BIG_SINT_C_TYPE) high == (BIG_SINT_C_TYPE) min_high
 832                && (BIG_UINT_C_TYPE) low < (BIG_UINT_C_TYPE) min_low))
 833     low = min_low; /* Minimum.  */
 834 #elif FROM_MODE_UNSIGNED == 1 && TO_MODE_UNSIGNED == 1
 835   /* Unigned -> Unsigned.  */
 836   if ((BIG_UINT_C_TYPE) high > (BIG_UINT_C_TYPE) max_high
 837       || ((BIG_UINT_C_TYPE) high == (BIG_UINT_C_TYPE) max_high
 838           && (BIG_UINT_C_TYPE) low > (BIG_UINT_C_TYPE) max_low))
 839     low = max_low; /* Maximum.  */
 840 #elif FROM_MODE_UNSIGNED == 0 && TO_MODE_UNSIGNED == 1
 841   /* Signed -> Unsigned.  */
 842   if (x < 0)
 843     low = 0; /* Minimum.  */
 844   else if ((BIG_UINT_C_TYPE) high > (BIG_UINT_C_TYPE) max_high
 845            || ((BIG_UINT_C_TYPE) high == (BIG_UINT_C_TYPE) max_high
 846                && (BIG_UINT_C_TYPE) low > (BIG_UINT_C_TYPE) max_low))
 847     low = max_low; /* Maximum.  */
 848 #elif FROM_MODE_UNSIGNED == 1 && TO_MODE_UNSIGNED == 0
 849   /* Unsigned -> Signed.  */
 850   if ((BIG_SINT_C_TYPE) high < 0)
 851     low = max_low; /* Maximum.  */
 852   else if ((BIG_SINT_C_TYPE) high > (BIG_SINT_C_TYPE) max_high
 853            || ((BIG_SINT_C_TYPE) high == (BIG_SINT_C_TYPE) max_high
 854                && (BIG_UINT_C_TYPE) low > (BIG_UINT_C_TYPE) max_low))
 855     low = max_low; /* Maximum.  */
 856 #endif
 857
 858   /* Step 4. Store the result.  */
 859   z = (TO_INT_C_TYPE) low;
 860 #if TO_HAVE_PADDING_BITS
 861   z = z << TO_PADDING_BITS;
 862   z = z >> TO_PADDING_BITS;
 863 #endif
 864   memcpy (&c, &z, TO_FIXED_SIZE);
 865   return c;
 866 }
 867 #endif /* defined(SATFRACT) && FROM_TYPE == 4 && TO_TYPE == 4  */
 868
 869 /* Fixed -> Int.  */
 870 #if defined(FRACT) && defined(L_fract) && FROM_TYPE == 4 && TO_TYPE == 1
 871 TO_INT_C_TYPE
 872 FRACT (FROM_FIXED_C_TYPE a)
 873 {
 874   FROM_INT_C_TYPE x;
 875   TO_INT_C_TYPE z;
 876   FROM_INT_C_TYPE i = 0;
 877   memcpy (&x, &a, FROM_FIXED_SIZE);
 878
 879 #if FROM_MODE_UNSIGNED == 0
 880   if (x < 0)
 881     {
 882 #if FROM_FIXED_WIDTH == FROM_FBITS
 883       if (x != 0)
 884         i = 1;
 885 #else
 886       if (((FROM_INT_C_TYPE)(x << (FROM_FIXED_WIDTH - FROM_FBITS))) != 0)
 887         i = 1;
 888 #endif
 889     }
 890 #endif
 891
 892 #if FROM_FIXED_WIDTH == FROM_FBITS
 893   x = 0;
 894 #else
 895   x = x >> FROM_FBITS;
 896 #endif
 897   x = x + i;
 898   z = (TO_INT_C_TYPE) x;
 899   return z;
 900 }
 901 #endif /* defined(FRACT) && FROM_TYPE == 4 && TO_TYPE == 1  */
 902
 903 /* Fixed -> Unsigned int.  */
 904 #if defined(FRACTUNS) && defined(L_fractuns) && FROM_TYPE == 4 && TO_TYPE == 2
 905 TO_INT_C_TYPE
 906 FRACTUNS (FROM_FIXED_C_TYPE a)
 907 {
 908   FROM_INT_C_TYPE x;
 909   TO_INT_C_TYPE z;
 910   FROM_INT_C_TYPE i = 0;
 911   memcpy (&x, &a, FROM_FIXED_SIZE);
 912
 913 #if FROM_MODE_UNSIGNED == 0
 914   if (x < 0)
 915     {
 916 #if FROM_FIXED_WIDTH == FROM_FBITS
 917       if (x != 0)
 918         i = 1;
 919 #else
 920       if (((FROM_INT_C_TYPE)(x << (FROM_FIXED_WIDTH - FROM_FBITS))) != 0)
 921         i = 1;
 922 #endif
 923     }
 924 #endif
 925
 926 #if FROM_FIXED_WIDTH == FROM_FBITS
 927   x = 0;
 928 #else
 929   x = x >> FROM_FBITS;
 930 #endif
 931   x = x + i;
 932   z = (TO_INT_C_TYPE) x;
 933   return z;
 934 }
 935 #endif /* defined(FRACTUNS) && FROM_TYPE == 4 && TO_TYPE == 2  */
 936
 937 /* Int -> Fixed.  */
 938 #if defined(FRACT) && defined(L_fract) && FROM_TYPE == 1 && TO_TYPE == 4
 939 TO_FIXED_C_TYPE
 940 FRACT (FROM_INT_C_TYPE a)
 941 {
 942   TO_FIXED_C_TYPE c;
 943   TO_INT_C_TYPE z;
 944   z = (TO_INT_C_TYPE) a;
 945 #if TO_FIXED_WIDTH == TO_FBITS
 946   z = 0;
 947 #else
 948   z = z << TO_FBITS;
 949 #endif
 950 #if TO_HAVE_PADDING_BITS
 951   z = z << TO_PADDING_BITS;
 952   z = z >> TO_PADDING_BITS;
 953 #endif
 954   memcpy (&c, &z, TO_FIXED_SIZE);
 955   return c;
 956 }
 957 #endif /* defined(FRACT) && FROM_TYPE == 1 && TO_TYPE == 4  */
 958
 959 /* Signed int -> Fixed with saturation.  */
 960 #if defined(SATFRACT) && defined(L_satfract) && FROM_TYPE == 1 && TO_TYPE == 4
 961 TO_FIXED_C_TYPE
 962 SATFRACT (FROM_INT_C_TYPE a)
 963 {
 964   TO_FIXED_C_TYPE c;
 965   TO_INT_C_TYPE z;
 966   FROM_INT_C_TYPE x = a;
 967   BIG_SINT_C_TYPE high, low;
 968   BIG_SINT_C_TYPE max_high, max_low;
 969 #if TO_MODE_UNSIGNED == 0
 970   BIG_SINT_C_TYPE min_high, min_low;
 971   BIG_SINT_C_TYPE stemp;
 972 #endif
 973 #if BIG_WIDTH != TO_FBITS
 974   BIG_UINT_C_TYPE utemp;
 975   int shift_amount;
 976 #endif
 977
 978   /* Step 1. We need to store x to {high, low}.  */
 979   low = (BIG_SINT_C_TYPE) x;
 980   if (x < 0)
 981     high = -1;
 982   else
 983     high = 0;
 984
 985   /* Step 2. We need to left shift {high, low}.  */
 986 #if BIG_WIDTH == TO_FBITS
 987   high = low;
 988   low = 0;
 989 #else
 990   shift_amount = TO_FBITS;
 991   utemp = (BIG_UINT_C_TYPE) low;
 992   utemp = utemp >> (BIG_WIDTH - shift_amount);
 993   high = ((BIG_UINT_C_TYPE)(high << shift_amount)) | utemp;
 994   low = low << shift_amount;
 995 #endif
 996
 997   /* Step 3. Compare {high, low} with max and  min of TO_FIXED_C_TYPE.  */
 998   max_high = 0;
 999 #if BIG_WIDTH > TO_FIXED_WIDTH || TO_MODE_UNSIGNED == 0 || TO_HAVE_PADDING_BITS
1000   max_low = (BIG_UINT_C_TYPE)1 << TO_I_F_BITS;
1001   max_low = max_low - 1;
1002 #else
1003   max_low = -1;
1004 #endif
1005
1006 #if TO_MODE_UNSIGNED == 0
1007   min_high = -1;
1008   stemp = (BIG_SINT_C_TYPE)1 << (BIG_WIDTH - 1);
1009   stemp = stemp >> (BIG_WIDTH - 1 - TO_I_F_BITS);
1010   min_low = stemp;
1011
1012   /* Signed -> Signed.  */
1013   if ((BIG_SINT_C_TYPE) high > (BIG_SINT_C_TYPE) max_high
1014       || ((BIG_SINT_C_TYPE) high == (BIG_SINT_C_TYPE) max_high
1015           && (BIG_UINT_C_TYPE) low > (BIG_UINT_C_TYPE) max_low))
1016     low = max_low; /* Maximum.  */
1017   else if ((BIG_SINT_C_TYPE) high < (BIG_SINT_C_TYPE) min_high
1018            || ((BIG_SINT_C_TYPE) high == (BIG_SINT_C_TYPE) min_high
1019                && (BIG_UINT_C_TYPE) low < (BIG_UINT_C_TYPE) min_low))
1020     low = min_low; /* Minimum.  */
1021 #else
1022   /* Signed -> Unsigned.  */
1023   if (x < 0)
1024     low = 0; /* Minimum.  */
1025   else if ((BIG_UINT_C_TYPE) high > (BIG_UINT_C_TYPE) max_high
1026            || ((BIG_UINT_C_TYPE) high == (BIG_UINT_C_TYPE) max_high
1027                && (BIG_UINT_C_TYPE) low > (BIG_UINT_C_TYPE) max_low))
1028     low = max_low; /* Maximum.  */
1029 #endif
1030
1031   /* Step 4. Store the result.  */
1032   z = (TO_INT_C_TYPE) low;
1033 #if TO_HAVE_PADDING_BITS
1034   z = z << TO_PADDING_BITS;
1035   z = z >> TO_PADDING_BITS;
1036 #endif
1037   memcpy (&c, &z, TO_FIXED_SIZE);
1038   return c;
1039 }
1040 #endif /* defined(SATFRACT) && FROM_TYPE == 1 && TO_TYPE == 4  */
1041
1042 /* Unsigned int -> Fixed.  */
1043 #if defined(FRACTUNS) && defined(L_fractuns) &&FROM_TYPE == 2 && TO_TYPE == 4
1044 TO_FIXED_C_TYPE
1045 FRACTUNS (FROM_INT_C_TYPE a)
1046 {
1047   TO_FIXED_C_TYPE c;
1048   TO_INT_C_TYPE z;
1049   z = (TO_INT_C_TYPE) a;
1050 #if TO_FIXED_WIDTH == TO_FBITS
1051   z = 0;
1052 #else
1053   z = z << TO_FBITS;
1054 #endif
1055 #if TO_HAVE_PADDING_BITS
1056   z = z << TO_PADDING_BITS;
1057   z = z >> TO_PADDING_BITS;
1058 #endif
1059   memcpy (&c, &z, TO_FIXED_SIZE);
1060   return c;
1061 }
1062 #endif /* defined(FRACTUNS) && FROM_TYPE == 2 && TO_TYPE == 4  */
1063
1064 /* Unsigned int -> Fixed with saturation.  */
1065 #if defined(SATFRACTUNS) && defined(L_satfractuns) && FROM_TYPE == 2 && TO_TYPE == 4
1066 TO_FIXED_C_TYPE
1067 SATFRACTUNS (FROM_INT_C_TYPE a)
1068 {
1069   TO_FIXED_C_TYPE c;
1070   TO_INT_C_TYPE z;
1071   FROM_INT_C_TYPE x = a;
1072   BIG_UINT_C_TYPE high, low;
1073   BIG_UINT_C_TYPE max_high, max_low;
1074 #if BIG_WIDTH != TO_FBITS
1075   BIG_UINT_C_TYPE utemp;
1076   int shift_amount;
1077 #endif
1078
1079   /* Step 1. We need to store x to {high, low}.  */
1080   low = (BIG_UINT_C_TYPE) x;
1081   high = 0;
1082
1083   /* Step 2. We need to left shift {high, low}.  */
1084 #if BIG_WIDTH == TO_FBITS
1085   high = low;
1086   low = 0;
1087 #else
1088   shift_amount = TO_FBITS;
1089   utemp = (BIG_UINT_C_TYPE) low;
1090   utemp = utemp >> (BIG_WIDTH - shift_amount);
1091   high = ((BIG_UINT_C_TYPE)(high << shift_amount)) | utemp;
1092   low = low << shift_amount;
1093 #endif
1094
1095   /* Step 3. Compare {high, low} with max and  min of TO_FIXED_C_TYPE.  */
1096   max_high = 0;
1097 #if BIG_WIDTH > TO_FIXED_WIDTH || TO_MODE_UNSIGNED == 0 || TO_HAVE_PADDING_BITS
1098   max_low = (BIG_UINT_C_TYPE)1 << TO_I_F_BITS;
1099   max_low = max_low - 1;
1100 #else
1101   max_low = -1;
1102 #endif
1103
1104 #if TO_MODE_UNSIGNED == 1
1105   /* Unigned -> Unsigned.  */
1106   if ((BIG_UINT_C_TYPE) high > (BIG_UINT_C_TYPE) max_high
1107       || ((BIG_UINT_C_TYPE) high == (BIG_UINT_C_TYPE) max_high
1108           && (BIG_UINT_C_TYPE) low > (BIG_UINT_C_TYPE) max_low))
1109     low = max_low; /* Maximum.  */
1110 #else
1111   /* Unsigned -> Signed.  */
1112   if ((BIG_SINT_C_TYPE) high < 0)
1113     low = max_low; /* Maximum.  */
1114   else if ((BIG_SINT_C_TYPE) high > (BIG_SINT_C_TYPE) max_high
1115            || ((BIG_SINT_C_TYPE) high == (BIG_SINT_C_TYPE) max_high
1116                && (BIG_UINT_C_TYPE) low > (BIG_UINT_C_TYPE) max_low))
1117     low = max_low; /* Maximum.  */
1118 #endif
1119
1120   /* Step 4. Store the result.  */
1121   z = (TO_INT_C_TYPE) low;
1122 #if TO_HAVE_PADDING_BITS
1123   z = z << TO_PADDING_BITS;
1124   z = z >> TO_PADDING_BITS;
1125 #endif
1126   memcpy (&c, &z, TO_FIXED_SIZE);
1127   return c;
1128 }
1129 #endif /* defined(SATFRACTUNS) && FROM_TYPE == 2 && TO_TYPE == 4  */
1130
1131 /* Fixed -> Float.  */
1132 #if defined(FRACT) && defined(L_fract) && FROM_TYPE == 4 && TO_TYPE == 3
1133 TO_FLOAT_C_TYPE
1134 FRACT (FROM_FIXED_C_TYPE a)
1135 {
1136   FROM_INT_C_TYPE x;
1137   TO_FLOAT_C_TYPE z;
1138   memcpy (&x, &a, FROM_FIXED_SIZE);
1139   z = (TO_FLOAT_C_TYPE) x;
1140   z = z / BASE;
1141   return z;
1142 }
1143 #endif /* defined(FRACT) && FROM_TYPE == 4 && TO_TYPE == 3  */
1144
1145 /* Float -> Fixed.  */
1146 #if defined(FRACT) && defined(L_fract) && FROM_TYPE == 3 && TO_TYPE == 4
1147 TO_FIXED_C_TYPE
1148 FRACT (FROM_FLOAT_C_TYPE a)
1149 {
1150   FROM_FLOAT_C_TYPE temp;
1151   TO_INT_C_TYPE z;
1152   TO_FIXED_C_TYPE c;
1153
1154   temp = a * BASE;
1155   z = (TO_INT_C_TYPE) temp;
1156 #if TO_HAVE_PADDING_BITS
1157   z = z << TO_PADDING_BITS;
1158   z = z >> TO_PADDING_BITS;
1159 #endif
1160   memcpy (&c, &z, TO_FIXED_SIZE);
1161   return c;
1162 }
1163 #endif /* defined(FRACT) && FROM_TYPE == 3 && TO_TYPE == 4  */
1164
1165 /* Float -> Fixed with saturation.  */
1166 #if defined(SATFRACT) && defined(L_satfract) && FROM_TYPE == 3 && TO_TYPE == 4
1167 TO_FIXED_C_TYPE
1168 SATFRACT (FROM_FLOAT_C_TYPE a)
1169 {
1170   FROM_FLOAT_C_TYPE temp;
1171   TO_INT_C_TYPE z;
1172   TO_FIXED_C_TYPE c;
1173
1174   if (a >= FIXED_MAX)
1175     {
1176 #if TO_MODE_UNSIGNED == 0 || TO_HAVE_PADDING_BITS
1177       z = (TO_INT_C_TYPE)1 << TO_I_F_BITS;
1178       z = z - 1;
1179 #else
1180       z = -1;
1181 #endif
1182     }
1183   else if (a <= FIXED_MIN)
1184     {
1185 #if TO_MODE_UNSIGNED == 0
1186       z = (TO_INT_C_TYPE)1 << TO_I_F_BITS;
1187 #else
1188       z = 0;
1189 #endif
1190     }
1191   else
1192     {
1193       temp = a * BASE;
1194       z = (TO_INT_C_TYPE) temp;
1195     }
1196
1197 #if TO_HAVE_PADDING_BITS
1198   z = z << TO_PADDING_BITS;
1199   z = z >> TO_PADDING_BITS;
1200 #endif
1201   memcpy (&c, &z, TO_FIXED_SIZE);
1202   return c;
1203 }
1204 #endif /* defined(SATFRACT) && FROM_TYPE == 3 && TO_TYPE == 4  */
1205