Subversion Repositories openrisc_2011-10-31

/* Copyright (C) 2007, 2009  Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free

Software Foundation; either version 3, or (at your option) any later

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

Under Section 7 of GPL version 3, you are granted additional

permissions described in the GCC Runtime Library Exception, version

3.1, as published by the Free Software Foundation.

You should have received a copy of the GNU General Public License and

a copy of the GCC Runtime Library Exception along with this program;

see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

<http://www.gnu.org/licenses/>.  */

#include "bid_internal.h"

/*****************************************************************************

 *  BID64 nextup

 ****************************************************************************/

#if DECIMAL_CALL_BY_REFERENCE

void

bid64_nextup (UINT64 * pres,

              UINT64 *

              px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) {

  UINT64 x = *px;

#else

UINT64

bid64_nextup (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM

              _EXC_INFO_PARAM) {

#endif

  UINT64 res;

  UINT64 x_sign;

  UINT64 x_exp;

  BID_UI64DOUBLE tmp1;

  int x_nr_bits;

  int q1, ind;

  UINT64 C1;                    // C1 represents x_signif (UINT64)

  // check for NaNs and infinities

  if ((x & MASK_NAN) == MASK_NAN) {     // check for NaN

    if ((x & 0x0003ffffffffffffull) > 999999999999999ull)

      x = x & 0xfe00000000000000ull;    // clear G6-G12 and the payload bits

    else

      x = x & 0xfe03ffffffffffffull;    // clear G6-G12

    if ((x & MASK_SNAN) == MASK_SNAN) { // SNaN

      // set invalid flag

      *pfpsf |= INVALID_EXCEPTION;

      // return quiet (SNaN)

      res = x & 0xfdffffffffffffffull;

    } else {    // QNaN

      res = x;

    }

    BID_RETURN (res);

  } else if ((x & MASK_INF) == MASK_INF) {      // check for Infinity

    if (!(x & 0x8000000000000000ull)) { // x is +inf

      res = 0x7800000000000000ull;

    } else {    // x is -inf

      res = 0xf7fb86f26fc0ffffull;      // -MAXFP = -999...99 * 10^emax

    }

    BID_RETURN (res);

  }

  // unpack the argument

  x_sign = x & MASK_SIGN;       // 0 for positive, MASK_SIGN for negative

  // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>

  if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {

    x_exp = (x & MASK_BINARY_EXPONENT2) >> 51;  // biased

    C1 = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;

    if (C1 > 9999999999999999ull) {     // non-canonical

      x_exp = 0;

      C1 = 0;

    }

  } else {

    x_exp = (x & MASK_BINARY_EXPONENT1) >> 53;  // biased

    C1 = x & MASK_BINARY_SIG1;

  }

  // check for zeros (possibly from non-canonical values)

  if (C1 == 0x0ull) {

    // x is 0

    res = 0x0000000000000001ull;        // MINFP = 1 * 10^emin

  } else {      // x is not special and is not zero

    if (x == 0x77fb86f26fc0ffffull) {

      // x = +MAXFP = 999...99 * 10^emax

      res = 0x7800000000000000ull;      // +inf

    } else if (x == 0x8000000000000001ull) {

      // x = -MINFP = 1...99 * 10^emin

      res = 0x8000000000000000ull;      // -0

    } else {    // -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp

      // can add/subtract 1 ulp to the significand

      // Note: we could check here if x >= 10^16 to speed up the case q1 =16 

      // q1 = nr. of decimal digits in x (1 <= q1 <= 54)

      //  determine first the nr. of bits in x

      if (C1 >= MASK_BINARY_OR2) {      // x >= 2^53

        // split the 64-bit value in two 32-bit halves to avoid rounding errors

        if (C1 >= 0x0000000100000000ull) {      // x >= 2^32

          tmp1.d = (double) (C1 >> 32); // exact conversion

          x_nr_bits =

            33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);

        } else {        // x < 2^32

          tmp1.d = (double) C1; // exact conversion

          x_nr_bits =

            1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);

        }

      } else {  // if x < 2^53

        tmp1.d = (double) C1;   // exact conversion

        x_nr_bits =

          1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);

      }

      q1 = nr_digits[x_nr_bits - 1].digits;

      if (q1 == 0) {

        q1 = nr_digits[x_nr_bits - 1].digits1;

        if (C1 >= nr_digits[x_nr_bits - 1].threshold_lo)

          q1++;

      }

      // if q1 < P16 then pad the significand with zeros

      if (q1 < P16) {

        if (x_exp > (UINT64) (P16 - q1)) {

          ind = P16 - q1;       // 1 <= ind <= P16 - 1

          // pad with P16 - q1 zeros, until exponent = emin

          // C1 = C1 * 10^ind

          C1 = C1 * ten2k64[ind];

          x_exp = x_exp - ind;

        } else {        // pad with zeros until the exponent reaches emin

          ind = x_exp;

          C1 = C1 * ten2k64[ind];

          x_exp = EXP_MIN;

        }

      }

      if (!x_sign) {    // x > 0

        // add 1 ulp (add 1 to the significand)

        C1++;

        if (C1 == 0x002386f26fc10000ull) {      // if  C1 = 10^16

          C1 = 0x00038d7ea4c68000ull;   // C1 = 10^15

          x_exp++;

        }

        // Ok, because MAXFP = 999...99 * 10^emax was caught already

      } else {  // x < 0

        // subtract 1 ulp (subtract 1 from the significand)

        C1--;

        if (C1 == 0x00038d7ea4c67fffull && x_exp != 0) { // if  C1 = 10^15 - 1

          C1 = 0x002386f26fc0ffffull;   // C1 = 10^16 - 1

          x_exp--;

        }

      }

      // assemble the result

      // if significand has 54 bits

      if (C1 & MASK_BINARY_OR2) {

        res =

          x_sign | (x_exp << 51) | MASK_STEERING_BITS | (C1 &

                                                         MASK_BINARY_SIG2);

      } else {  // significand fits in 53 bits

        res = x_sign | (x_exp << 53) | C1;

      }

    }   // end -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp

  }     // end x is not special and is not zero

  BID_RETURN (res);

}

/*****************************************************************************

 *  BID64 nextdown

 ****************************************************************************/

#if DECIMAL_CALL_BY_REFERENCE

void

bid64_nextdown (UINT64 * pres,

                UINT64 *

                px _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) {

  UINT64 x = *px;

#else

UINT64

bid64_nextdown (UINT64 x _EXC_FLAGS_PARAM _EXC_MASKS_PARAM

                _EXC_INFO_PARAM) {

#endif

  UINT64 res;

  UINT64 x_sign;

  UINT64 x_exp;

  BID_UI64DOUBLE tmp1;

  int x_nr_bits;

  int q1, ind;

  UINT64 C1;                    // C1 represents x_signif (UINT64)

  // check for NaNs and infinities

  if ((x & MASK_NAN) == MASK_NAN) {     // check for NaN 

    if ((x & 0x0003ffffffffffffull) > 999999999999999ull)

      x = x & 0xfe00000000000000ull;    // clear G6-G12 and the payload bits 

    else

      x = x & 0xfe03ffffffffffffull;    // clear G6-G12 

    if ((x & MASK_SNAN) == MASK_SNAN) { // SNaN 

      // set invalid flag

      *pfpsf |= INVALID_EXCEPTION;

      // return quiet (SNaN)

      res = x & 0xfdffffffffffffffull;

    } else {    // QNaN 

      res = x;

    }

    BID_RETURN (res);

  } else if ((x & MASK_INF) == MASK_INF) {      // check for Infinity

    if (x & 0x8000000000000000ull) {    // x is -inf

      res = 0xf800000000000000ull;

    } else {    // x is +inf

      res = 0x77fb86f26fc0ffffull;      // +MAXFP = +999...99 * 10^emax

    }

    BID_RETURN (res);

  }

  // unpack the argument

  x_sign = x & MASK_SIGN;       // 0 for positive, MASK_SIGN for negative

  // if steering bits are 11 (condition will be 0), then exponent is G[0:w+1] =>

  if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {

    x_exp = (x & MASK_BINARY_EXPONENT2) >> 51;  // biased

    C1 = (x & MASK_BINARY_SIG2) | MASK_BINARY_OR2;

    if (C1 > 9999999999999999ull) {     // non-canonical

      x_exp = 0;

      C1 = 0;

    }

  } else {

    x_exp = (x & MASK_BINARY_EXPONENT1) >> 53;  // biased

    C1 = x & MASK_BINARY_SIG1;

  }

  // check for zeros (possibly from non-canonical values)

  if (C1 == 0x0ull) {

    // x is 0

    res = 0x8000000000000001ull;        // -MINFP = -1 * 10^emin

  } else {      // x is not special and is not zero

    if (x == 0xf7fb86f26fc0ffffull) {

      // x = -MAXFP = -999...99 * 10^emax

      res = 0xf800000000000000ull;      // -inf

    } else if (x == 0x0000000000000001ull) {

      // x = +MINFP = 1...99 * 10^emin

      res = 0x0000000000000000ull;      // -0

    } else {    // -MAXFP + 1ulp <= x <= -MINFP OR MINFP + 1 ulp <= x <= MAXFP

      // can add/subtract 1 ulp to the significand

      // Note: we could check here if x >= 10^16 to speed up the case q1 =16 

      // q1 = nr. of decimal digits in x (1 <= q1 <= 16)

      //  determine first the nr. of bits in x

      if (C1 >= 0x0020000000000000ull) {        // x >= 2^53

        // split the 64-bit value in two 32-bit halves to avoid 

        // rounding errors

        if (C1 >= 0x0000000100000000ull) {      // x >= 2^32

          tmp1.d = (double) (C1 >> 32); // exact conversion

          x_nr_bits =

            33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);

        } else {        // x < 2^32

          tmp1.d = (double) C1; // exact conversion

          x_nr_bits =

            1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);

        }

      } else {  // if x < 2^53

        tmp1.d = (double) C1;   // exact conversion

        x_nr_bits =

          1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff);

      }

      q1 = nr_digits[x_nr_bits - 1].digits;

      if (q1 == 0) {

        q1 = nr_digits[x_nr_bits - 1].digits1;

        if (C1 >= nr_digits[x_nr_bits - 1].threshold_lo)

          q1++;

      }

      // if q1 < P16 then pad the significand with zeros

      if (q1 < P16) {

        if (x_exp > (UINT64) (P16 - q1)) {

          ind = P16 - q1;       // 1 <= ind <= P16 - 1

          // pad with P16 - q1 zeros, until exponent = emin

          // C1 = C1 * 10^ind

          C1 = C1 * ten2k64[ind];

          x_exp = x_exp - ind;

        } else {        // pad with zeros until the exponent reaches emin

          ind = x_exp;

          C1 = C1 * ten2k64[ind];

          x_exp = EXP_MIN;

        }

      }

      if (x_sign) {     // x < 0

        // add 1 ulp (add 1 to the significand)

        C1++;

        if (C1 == 0x002386f26fc10000ull) {      // if  C1 = 10^16

          C1 = 0x00038d7ea4c68000ull;   // C1 = 10^15

          x_exp++;

          // Ok, because -MAXFP = -999...99 * 10^emax was caught already

        }

      } else {  // x > 0

        // subtract 1 ulp (subtract 1 from the significand)

        C1--;

        if (C1 == 0x00038d7ea4c67fffull && x_exp != 0) { // if  C1 = 10^15 - 1

          C1 = 0x002386f26fc0ffffull;   // C1 = 10^16 - 1

          x_exp--;

        }

      }

      // assemble the result

      // if significand has 54 bits

      if (C1 & MASK_BINARY_OR2) {

        res =

          x_sign | (x_exp << 51) | MASK_STEERING_BITS | (C1 &

                                                         MASK_BINARY_SIG2);

      } else {  // significand fits in 53 bits

        res = x_sign | (x_exp << 53) | C1;

      }

    }   // end -MAXFP <= x <= -MINFP - 1 ulp OR MINFP <= x <= MAXFP - 1 ulp

  }     // end x is not special and is not zero

  BID_RETURN (res);

}

/*****************************************************************************

 *  BID64 nextafter

 ****************************************************************************/

#if DECIMAL_CALL_BY_REFERENCE

void

bid64_nextafter (UINT64 * pres, UINT64 * px,

                 UINT64 *

                 py _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) {

  UINT64 x = *px;

  UINT64 y = *py;

#else

UINT64

bid64_nextafter (UINT64 x,

                 UINT64 y _EXC_FLAGS_PARAM _EXC_MASKS_PARAM

                 _EXC_INFO_PARAM) {

#endif

  UINT64 res;

  UINT64 tmp1, tmp2;

  FPSC tmp_fpsf = 0;             // dummy fpsf for calls to comparison functions

  int res1, res2;

  // check for NaNs or infinities

  if (((x & MASK_SPECIAL) == MASK_SPECIAL) ||

      ((y & MASK_SPECIAL) == MASK_SPECIAL)) {

    // x is NaN or infinity or y is NaN or infinity

    if ((x & MASK_NAN) == MASK_NAN) {   // x is NAN

      if ((x & 0x0003ffffffffffffull) > 999999999999999ull)

        x = x & 0xfe00000000000000ull;  // clear G6-G12 and the payload bits

      else

        x = x & 0xfe03ffffffffffffull;  // clear G6-G12

      if ((x & MASK_SNAN) == MASK_SNAN) {       // x is SNAN

        // set invalid flag

        *pfpsf |= INVALID_EXCEPTION;

        // return quiet (x)

        res = x & 0xfdffffffffffffffull;

      } else {  // x is QNaN

        if ((y & MASK_SNAN) == MASK_SNAN) {     // y is SNAN

          // set invalid flag

          *pfpsf |= INVALID_EXCEPTION;

        }

        // return x

        res = x;

      }

      BID_RETURN (res);

    } else if ((y & MASK_NAN) == MASK_NAN) {    // y is NAN

      if ((y & 0x0003ffffffffffffull) > 999999999999999ull)

        y = y & 0xfe00000000000000ull;  // clear G6-G12 and the payload bits

      else

        y = y & 0xfe03ffffffffffffull;  // clear G6-G12

      if ((y & MASK_SNAN) == MASK_SNAN) {       // y is SNAN

        // set invalid flag

        *pfpsf |= INVALID_EXCEPTION;

        // return quiet (y)

        res = y & 0xfdffffffffffffffull;

      } else {  // y is QNaN

        // return y

        res = y;

      }

      BID_RETURN (res);

    } else {    // at least one is infinity

      if ((x & MASK_ANY_INF) == MASK_INF) {     // x = inf

        x = x & (MASK_SIGN | MASK_INF);

      }

      if ((y & MASK_ANY_INF) == MASK_INF) {     // y = inf

        y = y & (MASK_SIGN | MASK_INF);

      }

    }

  }

  // neither x nor y is NaN

  // if not infinity, check for non-canonical values x (treated as zero)

  if ((x & MASK_ANY_INF) != MASK_INF) { // x != inf

    // unpack x

    if ((x & MASK_STEERING_BITS) == MASK_STEERING_BITS) {

      // if the steering bits are 11 (condition will be 0), then

      // the exponent is G[0:w+1]

      if (((x & MASK_BINARY_SIG2) | MASK_BINARY_OR2) >

          9999999999999999ull) {

        // non-canonical

        x = (x & MASK_SIGN) | ((x & MASK_BINARY_EXPONENT2) << 2);

      }

    } else {    // if ((x & MASK_STEERING_BITS) != MASK_STEERING_BITS) x is unch.

      ; // canonical

    }

  }

  // no need to check for non-canonical y

  // neither x nor y is NaN

  tmp_fpsf = *pfpsf;    // save fpsf

#if DECIMAL_CALL_BY_REFERENCE

  bid64_quiet_equal (&res1, px,

                     py _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);

  bid64_quiet_greater (&res2, px,

                       py _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);

#else

  res1 =

    bid64_quiet_equal (x,

                       y _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);

  res2 =

    bid64_quiet_greater (x,

                         y _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);

#endif

  *pfpsf = tmp_fpsf;    // restore fpsf

  if (res1) {   // x = y

    // return x with the sign of y

    res = (y & 0x8000000000000000ull) | (x & 0x7fffffffffffffffull);

  } else if (res2) {    // x > y

#if DECIMAL_CALL_BY_REFERENCE

    bid64_nextdown (&res,

                    px _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);

#else

    res =

      bid64_nextdown (x _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);

#endif

  } else {      // x < y

#if DECIMAL_CALL_BY_REFERENCE

    bid64_nextup (&res, px _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);

#else

    res = bid64_nextup (x _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);

#endif

  }

  // if the operand x is finite but the result is infinite, signal

  // overflow and inexact

  if (((x & MASK_INF) != MASK_INF) && ((res & MASK_INF) == MASK_INF)) {

    // set the inexact flag

    *pfpsf |= INEXACT_EXCEPTION;

    // set the overflow flag

    *pfpsf |= OVERFLOW_EXCEPTION;

  }

  // if the result is in (-10^emin, 10^emin), and is different from the

  // operand x, signal underflow and inexact 

  tmp1 = 0x00038d7ea4c68000ull; // +100...0[16] * 10^emin

  tmp2 = res & 0x7fffffffffffffffull;

  tmp_fpsf = *pfpsf;    // save fpsf

#if DECIMAL_CALL_BY_REFERENCE

  bid64_quiet_greater (&res1, &tmp1,

                       &tmp2 _EXC_FLAGS_ARG _EXC_MASKS_ARG

                       _EXC_INFO_ARG);

  bid64_quiet_not_equal (&res2, &x,

                         &res _EXC_FLAGS_ARG _EXC_MASKS_ARG

                         _EXC_INFO_ARG);

#else

  res1 =

    bid64_quiet_greater (tmp1,

                         tmp2 _EXC_FLAGS_ARG _EXC_MASKS_ARG

                         _EXC_INFO_ARG);

  res2 =

    bid64_quiet_not_equal (x,

                           res _EXC_FLAGS_ARG _EXC_MASKS_ARG

                           _EXC_INFO_ARG);

#endif

  *pfpsf = tmp_fpsf;    // restore fpsf

  if (res1 && res2) {

    // if (bid64_quiet_greater (tmp1, tmp2, &tmp_fpsf) &&

    // bid64_quiet_not_equal (x, res, &tmp_fpsf)) {

    // set the inexact flag

    *pfpsf |= INEXACT_EXCEPTION;

    // set the underflow flag

    *pfpsf |= UNDERFLOW_EXCEPTION;

  }

  BID_RETURN (res);

}