COMPILER_RT_ABI fp_t __floatditf(di_int a) { const int aWidth = sizeof a * CHAR_BIT; // Handle zero as a special case to protect clz if (a == 0) return fromRep(0); // All other cases begin by extracting the sign and absolute value of a rep_t sign = 0; du_int aAbs = (du_int)a; if (a < 0) { sign = signBit; aAbs = ~(du_int)a + 1U; } // Exponent of (fp_t)a is the width of abs(a). const int exponent = (aWidth - 1) - __builtin_clzll(aAbs); rep_t result; // Shift a into the significand field, rounding if it is a right-shift const int shift = significandBits - exponent; result = (rep_t)aAbs << shift ^ implicitBit; // Insert the exponent result += (rep_t)(exponent + exponentBias) << significandBits; // Insert the sign bit and return return fromRep(result | sign); }
COMPILER_RT_ABI fp_t __floatunsitf(unsigned int a) { const int aWidth = sizeof a * CHAR_BIT; // Handle zero as a special case to protect clz if (a == 0) return fromRep(0); // Exponent of (fp_t)a is the width of abs(a). const int exponent = (aWidth - 1) - __builtin_clz(a); rep_t result; // Shift a into the significand field and clear the implicit bit. const int shift = significandBits - exponent; result = (rep_t)a << shift ^ implicitBit; // Insert the exponent result += (rep_t)(exponent + exponentBias) << significandBits; return fromRep(result); }
// Subtraction; flip the sign bit of b and add. COMPILER_RT_ABI fp_t __subsf3(fp_t a, fp_t b) { return __addsf3(a, fromRep(toRep(b) ^ signBit)); }
COMPILER_RT_ABI fp_t __negdf2(fp_t a) { return fromRep(toRep(a) ^ signBit); }
fp_t __addsf3(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 - 1U >= infRep - 1U || bAbs - 1U >= infRep - 1U) { // 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) { // but 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 addition. const rep_t resultSign = aRep & signBit; const bool subtraction = (aRep ^ bRep) & signBit; // Shift the significands to give us round, guard and sticky, and or in 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 int align = aExponent - bExponent; if (align) { if (align < typeWidth) { const bool sticky = bSignificand << (typeWidth - align); bSignificand = bSignificand >> align | sticky; } else { bSignificand = 1; // sticky; b is known to be non-zero. } }
COMPILER_RT_ABI fp_t __muldf3(fp_t a, fp_t b) { const unsigned int aExponent = toRep(a) >> significandBits & maxExponent; const unsigned int bExponent = toRep(b) >> significandBits & maxExponent; const rep_t productSign = (toRep(a) ^ toRep(b)) & signBit; rep_t aSignificand = toRep(a) & significandMask; rep_t bSignificand = toRep(b) & significandMask; int scale = 0; // Detect if a or b is zero, denormal, infinity, or NaN. if (aExponent-1U >= maxExponent-1U || bExponent-1U >= maxExponent-1U) { const rep_t aAbs = toRep(a) & absMask; const rep_t bAbs = toRep(b) & absMask; // 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 * non-zero = +/- infinity if (bAbs) return fromRep(aAbs | productSign); // infinity * zero = NaN else return fromRep(qnanRep); } if (bAbs == infRep) { // non-zero * infinity = +/- infinity if (aAbs) return fromRep(bAbs | productSign); // zero * infinity = NaN else return fromRep(qnanRep); } // zero * anything = +/- zero if (!aAbs) return fromRep(productSign); // anything * zero = +/- zero if (!bAbs) return fromRep(productSign); // one or both of a or b is denormal, the other (if applicable) is a // normal number. Renormalize one or both of a and b, and set scale to // include the necessary exponent adjustment. if (aAbs < implicitBit) scale += normalize(&aSignificand); if (bAbs < implicitBit) scale += normalize(&bSignificand); } // Or in 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 |= implicitBit; bSignificand |= implicitBit; // Get the significand of a*b. Before multiplying the significands, shift // one of them left to left-align it in the field. Thus, the product will // have (exponentBits + 2) integral digits, all but two of which must be // zero. Normalizing this result is just a conditional left-shift by one // and bumping the exponent accordingly. rep_t productHi, productLo; wideMultiply(aSignificand, bSignificand << exponentBits, &productHi, &productLo); int productExponent = aExponent + bExponent - exponentBias + scale; // Normalize the significand, adjust exponent if needed. if (productHi & implicitBit) productExponent++; else wideLeftShift(&productHi, &productLo, 1); // If we have overflowed the type, return +/- infinity. if (productExponent >= maxExponent) return fromRep(infRep | productSign); if (productExponent <= 0) { // Result is denormal before rounding // // If the result is so small that it just underflows to zero, return // a zero of the appropriate sign. Mathematically there is no need to // handle this case separately, but we make it a special case to // simplify the shift logic. const unsigned int shift = 1U - (unsigned int)productExponent; if (shift >= typeWidth) return fromRep(productSign); // Otherwise, shift the significand of the result so that the round // bit is the high bit of productLo. wideRightShiftWithSticky(&productHi, &productLo, shift); } else { // Result is normal before rounding; insert the exponent. productHi &= significandMask; productHi |= (rep_t)productExponent << significandBits; } // Insert the sign of the result: productHi |= productSign; // Final rounding. The final result may overflow to infinity, or underflow // to zero, but those are the correct results in those cases. We use the // default IEEE-754 round-to-nearest, ties-to-even rounding mode. if (productLo > signBit) productHi++; if (productLo == signBit) productHi += productHi & 1; return fromRep(productHi); }