fpu/fprem.cc

   1 /*============================================================================
   2 This source file is an extension to the SoftFloat IEC/IEEE Floating-point
   3 Arithmetic Package, Release 2b, written for Bochs (x86 achitecture simulator)
   4 floating point emulation.
   5
   6 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
   7 been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
   8 RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
   9 AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
  10 COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
  11 EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
  12 INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
  13 OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
  14
  15 Derivative works are acceptable, even for commercial purposes, so long as
  16 (1) the source code for the derivative work includes prominent notice that
  17 the work is derivative, and (2) the source code includes prominent notice with
  18 these four paragraphs for those parts of this code that are retained.
  19 =============================================================================*/
  20
  21 /*============================================================================
  22  * Written for Bochs (x86 achitecture simulator) by
  23  *            Stanislav Shwartsman [sshwarts at sourceforge net]
  24  * ==========================================================================*/
  25
  26 #include "softfloatx80.h"
  27 #include "softfloat-round-pack.h"
  28 #define USE_estimateDiv128To64
  29 #include "softfloat-macros.h"
  30
  31 /* executes single exponent reduction cycle */
  32 static Bit64u remainder_kernel(Bit64u aSig0, Bit64u bSig, int expDiff, Bit64u *zSig0, Bit64u *zSig1)
  33 {
  34     Bit64u term0, term1;
  35     Bit64u aSig1 = 0;
  36
  37     shortShift128Left(aSig1, aSig0, expDiff, &aSig1, &aSig0);
  38     Bit64u q = estimateDiv128To64(aSig1, aSig0, bSig);
  39     mul64To128(bSig, q, &term0, &term1);
  40     sub128(aSig1, aSig0, term0, term1, zSig1, zSig0);
  41     while ((Bit64s)(*zSig1) < 0) {
  42         --q;
  43         add128(*zSig1, *zSig0, 0, bSig, zSig1, zSig0);
  44     }
  45     return q;
  46 }
  47
  48 static floatx80 do_fprem(floatx80 a, floatx80 b, Bit64u &q, int rounding_mode, float_status_t &status)
  49 {
  50     Bit32s aExp, bExp, zExp, expDiff;
  51     Bit64u aSig0, aSig1, bSig;
  52     int aSign;
  53     q = 0;
  54
  55     // handle unsupported extended double-precision floating encodings
  56     if (floatx80_is_unsupported(a) || floatx80_is_unsupported(b))
  57     {
  58         float_raise(status, float_flag_invalid);
  59         return floatx80_default_nan;
  60     }
  61
  62     aSig0 = extractFloatx80Frac(a);
  63     aExp = extractFloatx80Exp(a);
  64     aSign = extractFloatx80Sign(a);
  65     bSig = extractFloatx80Frac(b);
  66     bExp = extractFloatx80Exp(b);
  67
  68     if (aExp == 0x7FFF) {
  69         if ((Bit64u) (aSig0<<1)
  70              || ((bExp == 0x7FFF) && (Bit64u) (bSig<<1)))
  71         {
  72             return propagateFloatx80NaN(a, b, status);
  73         }
  74         goto invalid;
  75     }
  76     if (bExp == 0x7FFF) {
  77         if ((Bit64u) (bSig<<1)) return propagateFloatx80NaN(a, b, status);
  78         return a;
  79     }
  80     if (bExp == 0) {
  81         if (bSig == 0) {
  82  invalid:
  83             float_raise(status, float_flag_invalid);
  84             return floatx80_default_nan;
  85         }
  86         float_raise(status, float_flag_denormal);
  87         normalizeFloatx80Subnormal(bSig, &bExp, &bSig);
  88     }
  89     if (aExp == 0) {
  90         if ((Bit64u) (aSig0<<1) == 0) return a;
  91         float_raise(status, float_flag_denormal);
  92         normalizeFloatx80Subnormal(aSig0, &aExp, &aSig0);
  93     }
  94     expDiff = aExp - bExp;
  95     aSig1 = 0;
  96
  97     if (expDiff >= 64) {
  98         int n = (expDiff & 0x1f) | 0x20;
  99         remainder_kernel(aSig0, bSig, n, &aSig0, &aSig1);
 100         zExp = aExp - n;
 101         q = (Bit64u) -1;
 102     }
 103     else {
 104         zExp = bExp;
 105
 106         if (expDiff < 0) {
 107             if (expDiff < -1)
 108                return (a.fraction & BX_CONST64(0x8000000000000000)) ?
 109                     packFloatx80(aSign, aExp, aSig0) : a;
 110             shift128Right(aSig0, 0, 1, &aSig0, &aSig1);
 111             expDiff = 0;
 112         }
 113
 114         if (expDiff > 0) {
 115             q = remainder_kernel(aSig0, bSig, expDiff, &aSig0, &aSig1);
 116         }
 117         else {
 118             if (bSig <= aSig0) {
 119                aSig0 -= bSig;
 120                q = 1;
 121             }
 122         }
 123
 124         if (rounding_mode == float_round_nearest_even)
 125         {
 126             Bit64u term0, term1;
 127             shift128Right(bSig, 0, 1, &term0, &term1);
 128
 129             if (! lt128(aSig0, aSig1, term0, term1))
 130             {
 131                int lt = lt128(term0, term1, aSig0, aSig1);
 132                int eq = eq128(aSig0, aSig1, term0, term1);
 133
 134                if ((eq && (q & 1)) || lt) {
 135                   aSign = !aSign;
 136                   ++q;
 137                }
 138                if (lt) sub128(bSig, 0, aSig0, aSig1, &aSig0, &aSig1);
 139             }
 140         }
 141     }
 142
 143     return normalizeRoundAndPackFloatx80(80, aSign, zExp, aSig0, aSig1, status);
 144 }
 145
 146 /*----------------------------------------------------------------------------
 147 | Returns the remainder of the extended double-precision floating-point value
 148 | `a' with respect to the corresponding value `b'.  The operation is performed
 149 | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 150 *----------------------------------------------------------------------------*/
 151
 152 floatx80 floatx80_ieee754_remainder(floatx80 a, floatx80 b, Bit64u &q, float_status_t &status)
 153 {
 154     return do_fprem(a, b, q, float_round_nearest_even, status);
 155 }
 156
 157 /*----------------------------------------------------------------------------
 158 | Returns the remainder of the extended double-precision floating-point value
 159 | `a' with  respect to  the corresponding value `b'. Unlike previous function
 160 | the  function  does not compute  the remainder  specified  in  the IEC/IEEE
 161 | Standard  for Binary  Floating-Point  Arithmetic.  This  function  operates
 162 | differently  from the  previous  function in  the way  that it  rounds  the
 163 | quotient of 'a' divided by 'b' to an integer.
 164 *----------------------------------------------------------------------------*/
 165
 166 floatx80 floatx80_remainder(floatx80 a, floatx80 b, Bit64u &q, float_status_t &status)
 167 {
 168     return do_fprem(a, b, q, float_round_to_zero, status);
 169 }