kit

fp_add_impl.inc (5980B)

---

 //===----- lib/fp_add_impl.inc - floaing point addition -----------*- C -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements soft-float addition with the IEEE-754 default rounding
 // (to nearest, ties to even).
 //
 //===----------------------------------------------------------------------===//
 
 #include "fp_lib.h"
 #include "fp_mode.h"
 
 #define __addXf3__ _FP_NAME(__addXf3__)
 
 #if defined SINGLE_PRECISION && !defined FP_ADD_SF_EMITTED
 #define FP_ADD_SF_EMITTED
 #define _FP_ADD_EMIT 1
 #elif defined DOUBLE_PRECISION && !defined FP_ADD_DF_EMITTED
 #define FP_ADD_DF_EMITTED
 #define _FP_ADD_EMIT 1
 #elif defined QUAD_PRECISION && !defined FP_ADD_TF_EMITTED
 #define FP_ADD_TF_EMITTED
 #define _FP_ADD_EMIT 1
 #endif
 
 #ifdef _FP_ADD_EMIT
 #undef _FP_ADD_EMIT
 
 static inline fp_t __addXf3__(fp_t a, fp_t b) {
   rep_t aRep = toRep(a);
   rep_t bRep = toRep(b);
   const rep_t aAbs = aRep & absMask;
   const rep_t bAbs = bRep & absMask;
 
   // Detect if a or b is zero, infinity, or NaN.
   if (aAbs - REP_C(1) >= infRep - REP_C(1) ||
       bAbs - REP_C(1) >= infRep - REP_C(1)) {
     // NaN + anything = qNaN
     if (aAbs > infRep)
       return fromRep(toRep(a) | quietBit);
     // anything + NaN = qNaN
     if (bAbs > infRep)
       return fromRep(toRep(b) | quietBit);
 
     if (aAbs == infRep) {
       // +/-infinity + -/+infinity = qNaN
       if ((toRep(a) ^ toRep(b)) == signBit)
         return fromRep(qnanRep);
       // +/-infinity + anything remaining = +/- infinity
       else
         return a;
     }
 
     // anything remaining + +/-infinity = +/-infinity
     if (bAbs == infRep)
       return b;
 
     // zero + anything = anything
     if (!aAbs) {
       // We need to get the sign right for zero + zero.
       if (!bAbs)
         return fromRep(toRep(a) & toRep(b));
       else
         return b;
     }
 
     // anything + zero = anything
     if (!bAbs)
       return a;
   }
 
   // Swap a and b if necessary so that a has the larger absolute value.
   if (bAbs > aAbs) {
     const rep_t temp = aRep;
     aRep = bRep;
     bRep = temp;
   }
 
   // Extract the exponent and significand from the (possibly swapped) a and b.
   int aExponent = aRep >> significandBits & maxExponent;
   int bExponent = bRep >> significandBits & maxExponent;
   rep_t aSignificand = aRep & significandMask;
   rep_t bSignificand = bRep & significandMask;
 
   // Normalize any denormals, and adjust the exponent accordingly.
   if (aExponent == 0)
     aExponent = normalize(&aSignificand);
   if (bExponent == 0)
     bExponent = normalize(&bSignificand);
 
   // The sign of the result is the sign of the larger operand, a.  If they
   // have opposite signs, we are performing a subtraction.  Otherwise, we
   // perform addition.
   const rep_t resultSign = aRep & signBit;
   const bool subtraction = (aRep ^ bRep) & signBit;
 
   // Shift the significands to give us round, guard and sticky, and set the
   // implicit significand bit.  If we fell through from the denormal path it
   // was already set by normalize( ), but setting it twice won't hurt
   // anything.
   aSignificand = (aSignificand | implicitBit) << 3;
   bSignificand = (bSignificand | implicitBit) << 3;
 
   // Shift the significand of b by the difference in exponents, with a sticky
   // bottom bit to get rounding correct.
   const unsigned int align = aExponent - bExponent;
   if (align) {
     if (align < typeWidth) {
       const bool sticky = (bSignificand << (typeWidth - align)) != 0;
       bSignificand = bSignificand >> align | sticky;
     } else {
       bSignificand = 1; // Set the sticky bit.  b is known to be non-zero.
     }
   }
   if (subtraction) {
     aSignificand -= bSignificand;
     // If a == -b, return +zero.
     if (aSignificand == 0)
       return fromRep(0);
 
     // If partial cancellation occured, we need to left-shift the result
     // and adjust the exponent.
     if (aSignificand < implicitBit << 3) {
       const int shift = rep_clz(aSignificand) - rep_clz(implicitBit << 3);
       aSignificand <<= shift;
       aExponent -= shift;
     }
   } else /* addition */ {
     aSignificand += bSignificand;
 
     // If the addition carried up, we need to right-shift the result and
     // adjust the exponent.
     if (aSignificand & implicitBit << 4) {
       const bool sticky = aSignificand & 1;
       aSignificand = aSignificand >> 1 | sticky;
       aExponent += 1;
     }
   }
 
   // If we have overflowed the type, return +/- infinity.
   if (aExponent >= maxExponent)
     return fromRep(infRep | resultSign);
 
   if (aExponent <= 0) {
     // The result is denormal before rounding.  The exponent is zero and we
     // need to shift the significand.
     const int shift = 1 - aExponent;
     const bool sticky = (aSignificand << (typeWidth - shift)) != 0;
     aSignificand = aSignificand >> shift | sticky;
     aExponent = 0;
   }
 
   // Low three bits are round, guard, and sticky.
   const int roundGuardSticky = aSignificand & 0x7;
 
   // Shift the significand into place, and mask off the implicit bit.
   rep_t result = aSignificand >> 3 & significandMask;
 
   // Insert the exponent and sign.
   result |= (rep_t)aExponent << significandBits;
   result |= resultSign;
 
   // Perform the final rounding.  The result may overflow to infinity, but
   // that is the correct result in that case.
   switch (__fe_getround()) {
   case CRT_FE_TONEAREST:
     if (roundGuardSticky > 0x4)
       result++;
     if (roundGuardSticky == 0x4)
       result += result & 1;
     break;
   case CRT_FE_DOWNWARD:
     if (resultSign && roundGuardSticky) result++;
     break;
   case CRT_FE_UPWARD:
     if (!resultSign && roundGuardSticky) result++;
     break;
   case CRT_FE_TOWARDZERO:
     break;
   }
   if (roundGuardSticky)
     __fe_raise_inexact();
   return fromRep(result);
 }
 
 #endif // _FP_ADD_EMIT