libgcc/fixed-bit.c

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