/* * Double_add: add two double precision values. */ dbl_fadd( dbl_floating_point *leftptr, dbl_floating_point *rightptr, dbl_floating_point *dstptr, unsigned int *status) { register unsigned int signless_upper_left, signless_upper_right, save; register unsigned int leftp1, leftp2, rightp1, rightp2, extent; register unsigned int resultp1 = 0, resultp2 = 0; register int result_exponent, right_exponent, diff_exponent; register int sign_save, jumpsize; register boolean inexact = FALSE; register boolean underflowtrap; /* Create local copies of the numbers */ Dbl_copyfromptr(leftptr,leftp1,leftp2); Dbl_copyfromptr(rightptr,rightp1,rightp2); /* A zero "save" helps discover equal operands (for later), * * and is used in swapping operands (if needed). */ Dbl_xortointp1(leftp1,rightp1,/*to*/save); /* * check first operand for NaN's or infinity */ if ((result_exponent = Dbl_exponent(leftp1)) == DBL_INFINITY_EXPONENT) { if (Dbl_iszero_mantissa(leftp1,leftp2)) { if (Dbl_isnotnan(rightp1,rightp2)) { if (Dbl_isinfinity(rightp1,rightp2) && save!=0) { /* * invalid since operands are opposite signed infinity's */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* * return infinity */ Dbl_copytoptr(leftp1,leftp2,dstptr); return(NOEXCEPTION); } } else { /* * is NaN; signaling or quiet? */ if (Dbl_isone_signaling(leftp1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(leftp1); } /* * is second operand a signaling NaN? */ else if (Dbl_is_signalingnan(rightp1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(rightp1); Dbl_copytoptr(rightp1,rightp2,dstptr); return(NOEXCEPTION); } /* * return quiet NaN */ Dbl_copytoptr(leftp1,leftp2,dstptr); return(NOEXCEPTION); } } /* End left NaN or Infinity processing */ /* * check second operand for NaN's or infinity */ if (Dbl_isinfinity_exponent(rightp1)) { if (Dbl_iszero_mantissa(rightp1,rightp2)) { /* return infinity */ Dbl_copytoptr(rightp1,rightp2,dstptr); return(NOEXCEPTION); } /* * is NaN; signaling or quiet? */ if (Dbl_isone_signaling(rightp1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(rightp1); } /* * return quiet NaN */ Dbl_copytoptr(rightp1,rightp2,dstptr); return(NOEXCEPTION); } /* End right NaN or Infinity processing */ /* Invariant: Must be dealing with finite numbers */ /* Compare operands by removing the sign */ Dbl_copytoint_exponentmantissap1(leftp1,signless_upper_left); Dbl_copytoint_exponentmantissap1(rightp1,signless_upper_right); /* sign difference selects add or sub operation. */ if(Dbl_ismagnitudeless(leftp2,rightp2,signless_upper_left,signless_upper_right)) { /* Set the left operand to the larger one by XOR swap * * First finish the first word using "save" */ Dbl_xorfromintp1(save,rightp1,/*to*/rightp1); Dbl_xorfromintp1(save,leftp1,/*to*/leftp1); Dbl_swap_lower(leftp2,rightp2); result_exponent = Dbl_exponent(leftp1); } /* Invariant: left is not smaller than right. */ if((right_exponent = Dbl_exponent(rightp1)) == 0) { /* Denormalized operands. First look for zeroes */ if(Dbl_iszero_mantissa(rightp1,rightp2)) { /* right is zero */ if(Dbl_iszero_exponentmantissa(leftp1,leftp2)) { /* Both operands are zeros */ if(Is_rounding_mode(ROUNDMINUS)) { Dbl_or_signs(leftp1,/*with*/rightp1); } else { Dbl_and_signs(leftp1,/*with*/rightp1); } } else { /* Left is not a zero and must be the result. Trapped * underflows are signaled if left is denormalized. Result * is always exact. */ if( (result_exponent == 0) && Is_underflowtrap_enabled() ) { /* need to normalize results mantissa */ sign_save = Dbl_signextendedsign(leftp1); Dbl_leftshiftby1(leftp1,leftp2); Dbl_normalize(leftp1,leftp2,result_exponent); Dbl_set_sign(leftp1,/*using*/sign_save); Dbl_setwrapped_exponent(leftp1,result_exponent,unfl); Dbl_copytoptr(leftp1,leftp2,dstptr); /* inexact = FALSE */ return(UNDERFLOWEXCEPTION); } } Dbl_copytoptr(leftp1,leftp2,dstptr); return(NOEXCEPTION); } /* Neither are zeroes */ Dbl_clear_sign(rightp1); /* Exponent is already cleared */ if(result_exponent == 0 ) { /* Both operands are denormalized. The result must be exact * and is simply calculated. A sum could become normalized and a * difference could cancel to a true zero. */ if( (/*signed*/int) save < 0 ) { Dbl_subtract(leftp1,leftp2,/*minus*/rightp1,rightp2, /*into*/resultp1,resultp2); if(Dbl_iszero_mantissa(resultp1,resultp2)) { if(Is_rounding_mode(ROUNDMINUS)) { Dbl_setone_sign(resultp1); } else { Dbl_setzero_sign(resultp1); } Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } } else { Dbl_addition(leftp1,leftp2,rightp1,rightp2, /*into*/resultp1,resultp2); if(Dbl_isone_hidden(resultp1)) { Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } } if(Is_underflowtrap_enabled()) { /* need to normalize result */ sign_save = Dbl_signextendedsign(resultp1); Dbl_leftshiftby1(resultp1,resultp2); Dbl_normalize(resultp1,resultp2,result_exponent); Dbl_set_sign(resultp1,/*using*/sign_save); Dbl_setwrapped_exponent(resultp1,result_exponent,unfl); Dbl_copytoptr(resultp1,resultp2,dstptr); /* inexact = FALSE */ return(UNDERFLOWEXCEPTION); } Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } right_exponent = 1; /* Set exponent to reflect different bias * with denomalized numbers. */ } else { Dbl_clear_signexponent_set_hidden(rightp1); } Dbl_clear_exponent_set_hidden(leftp1); diff_exponent = result_exponent - right_exponent; /* * Special case alignment of operands that would force alignment * beyond the extent of the extension. A further optimization * could special case this but only reduces the path length for this * infrequent case. */ if(diff_exponent > DBL_THRESHOLD) { diff_exponent = DBL_THRESHOLD; } /* Align right operand by shifting to right */ Dbl_right_align(/*operand*/rightp1,rightp2,/*shifted by*/diff_exponent, /*and lower to*/extent); /* Treat sum and difference of the operands separately. */ if( (/*signed*/int) save < 0 ) { /* * Difference of the two operands. Their can be no overflow. A * borrow can occur out of the hidden bit and force a post * normalization phase. */ Dbl_subtract_withextension(leftp1,leftp2,/*minus*/rightp1,rightp2, /*with*/extent,/*into*/resultp1,resultp2); if(Dbl_iszero_hidden(resultp1)) { /* Handle normalization */ /* A straight forward algorithm would now shift the result * and extension left until the hidden bit becomes one. Not * all of the extension bits need participate in the shift. * Only the two most significant bits (round and guard) are * needed. If only a single shift is needed then the guard * bit becomes a significant low order bit and the extension * must participate in the rounding. If more than a single * shift is needed, then all bits to the right of the guard * bit are zeros, and the guard bit may or may not be zero. */ sign_save = Dbl_signextendedsign(resultp1); Dbl_leftshiftby1_withextent(resultp1,resultp2,extent,resultp1,resultp2); /* Need to check for a zero result. The sign and exponent * fields have already been zeroed. The more efficient test * of the full object can be used. */ if(Dbl_iszero(resultp1,resultp2)) /* Must have been "x-x" or "x+(-x)". */ { if(Is_rounding_mode(ROUNDMINUS)) Dbl_setone_sign(resultp1); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } result_exponent--; /* Look to see if normalization is finished. */ if(Dbl_isone_hidden(resultp1)) { if(result_exponent==0) { /* Denormalized, exponent should be zero. Left operand * * was normalized, so extent (guard, round) was zero */ goto underflow; } else { /* No further normalization is needed. */ Dbl_set_sign(resultp1,/*using*/sign_save); Ext_leftshiftby1(extent); goto round; } } /* Check for denormalized, exponent should be zero. Left * * operand was normalized, so extent (guard, round) was zero */ if(!(underflowtrap = Is_underflowtrap_enabled()) && result_exponent==0) goto underflow; /* Shift extension to complete one bit of normalization and * update exponent. */ Ext_leftshiftby1(extent); /* Discover first one bit to determine shift amount. Use a * modified binary search. We have already shifted the result * one position right and still not found a one so the remainder * of the extension must be zero and simplifies rounding. */ /* Scan bytes */ while(Dbl_iszero_hiddenhigh7mantissa(resultp1)) { Dbl_leftshiftby8(resultp1,resultp2); if((result_exponent -= 8) <= 0 && !underflowtrap) goto underflow; } /* Now narrow it down to the nibble */ if(Dbl_iszero_hiddenhigh3mantissa(resultp1)) { /* The lower nibble contains the normalizing one */ Dbl_leftshiftby4(resultp1,resultp2); if((result_exponent -= 4) <= 0 && !underflowtrap) goto underflow; } /* Select case were first bit is set (already normalized) * otherwise select the proper shift. */ if((jumpsize = Dbl_hiddenhigh3mantissa(resultp1)) > 7) { /* Already normalized */ if(result_exponent <= 0) goto underflow; Dbl_set_sign(resultp1,/*using*/sign_save); Dbl_set_exponent(resultp1,/*using*/result_exponent); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } Dbl_sethigh4bits(resultp1,/*using*/sign_save); switch(jumpsize) { case 1: { Dbl_leftshiftby3(resultp1,resultp2); result_exponent -= 3; break; } case 2: case 3: { Dbl_leftshiftby2(resultp1,resultp2); result_exponent -= 2; break; } case 4: case 5: case 6: case 7: { Dbl_leftshiftby1(resultp1,resultp2); result_exponent -= 1; break; } } if(result_exponent > 0) { Dbl_set_exponent(resultp1,/*using*/result_exponent); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); /* Sign bit is already set */ } /* Fixup potential underflows */ underflow: if(Is_underflowtrap_enabled()) { Dbl_set_sign(resultp1,sign_save); Dbl_setwrapped_exponent(resultp1,result_exponent,unfl); Dbl_copytoptr(resultp1,resultp2,dstptr); /* inexact = FALSE */ return(UNDERFLOWEXCEPTION); } /* * Since we cannot get an inexact denormalized result, * we can now return. */ Dbl_fix_overshift(resultp1,resultp2,(1-result_exponent),extent); Dbl_clear_signexponent(resultp1); Dbl_set_sign(resultp1,sign_save); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* end if(hidden...)... */ /* Fall through and round */ } /* end if(save < 0)... */ else { /* Add magnitudes */ Dbl_addition(leftp1,leftp2,rightp1,rightp2,/*to*/resultp1,resultp2); if(Dbl_isone_hiddenoverflow(resultp1)) { /* Prenormalization required. */ Dbl_rightshiftby1_withextent(resultp2,extent,extent); Dbl_arithrightshiftby1(resultp1,resultp2); result_exponent++; } /* end if hiddenoverflow... */ } /* end else ...add magnitudes... */ /* Round the result. If the extension is all zeros,then the result is * exact. Otherwise round in the correct direction. No underflow is * possible. If a postnormalization is necessary, then the mantissa is * all zeros so no shift is needed. */ round: if(Ext_isnotzero(extent)) { inexact = TRUE; switch(Rounding_mode()) { case ROUNDNEAREST: /* The default. */ if(Ext_isone_sign(extent)) { /* at least 1/2 ulp */ if(Ext_isnotzero_lower(extent) || Dbl_isone_lowmantissap2(resultp2)) { /* either exactly half way and odd or more than 1/2ulp */ Dbl_increment(resultp1,resultp2); } } break; case ROUNDPLUS: if(Dbl_iszero_sign(resultp1)) { /* Round up positive results */ Dbl_increment(resultp1,resultp2); } break; case ROUNDMINUS: if(Dbl_isone_sign(resultp1)) { /* Round down negative results */ Dbl_increment(resultp1,resultp2); } case ROUNDZERO:; /* truncate is simple */ } /* end switch... */ if(Dbl_isone_hiddenoverflow(resultp1)) result_exponent++; } if(result_exponent == DBL_INFINITY_EXPONENT) { /* Overflow */ if(Is_overflowtrap_enabled()) { Dbl_setwrapped_exponent(resultp1,result_exponent,ovfl); Dbl_copytoptr(resultp1,resultp2,dstptr); if (inexact) if (Is_inexacttrap_enabled()) return(OVERFLOWEXCEPTION | INEXACTEXCEPTION); else Set_inexactflag(); return(OVERFLOWEXCEPTION); } else { inexact = TRUE; Set_overflowflag(); Dbl_setoverflow(resultp1,resultp2); } } else Dbl_set_exponent(resultp1,result_exponent); Dbl_copytoptr(resultp1,resultp2,dstptr); if(inexact) if(Is_inexacttrap_enabled()) return(INEXACTEXCEPTION); else Set_inexactflag(); return(NOEXCEPTION); }
/*ARGSUSED*/ int dbl_fsqrt(dbl_floating_point *srcptr, dbl_floating_point *dstptr, unsigned int *status) { register unsigned int srcp1, srcp2, resultp1, resultp2; register unsigned int newbitp1, newbitp2, sump1, sump2; register int src_exponent; register int guardbit = false, even_exponent; Dbl_copyfromptr(srcptr,srcp1,srcp2); /* * check source operand for NaN or infinity */ if ((src_exponent = Dbl_exponent(srcp1)) == DBL_INFINITY_EXPONENT) { /* * is signaling NaN? */ if (Dbl_isone_signaling(srcp1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(srcp1); } /* * Return quiet NaN or positive infinity. * Fall thru to negative test if negative infinity. */ if (Dbl_iszero_sign(srcp1) || Dbl_isnotzero_mantissa(srcp1,srcp2)) { Dbl_copytoptr(srcp1,srcp2,dstptr); return(NOEXCEPTION); } } /* * check for zero source operand */ if (Dbl_iszero_exponentmantissa(srcp1,srcp2)) { Dbl_copytoptr(srcp1,srcp2,dstptr); return(NOEXCEPTION); } /* * check for negative source operand */ if (Dbl_isone_sign(srcp1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_makequietnan(srcp1,srcp2); Dbl_copytoptr(srcp1,srcp2,dstptr); return(NOEXCEPTION); } /* * Generate result */ if (src_exponent > 0) { even_exponent = Dbl_hidden(srcp1); Dbl_clear_signexponent_set_hidden(srcp1); } else { /* normalize operand */ Dbl_clear_signexponent(srcp1); src_exponent++; Dbl_normalize(srcp1,srcp2,src_exponent); even_exponent = src_exponent & 1; } if (even_exponent) { /* exponent is even */ /* Add comment here. Explain why odd exponent needs correction */ Dbl_leftshiftby1(srcp1,srcp2); } /* * Add comment here. Explain following algorithm. * * Trust me, it works. * */ Dbl_setzero(resultp1,resultp2); Dbl_allp1(newbitp1) = 1 << (DBL_P - 32); Dbl_setzero_mantissap2(newbitp2); while (Dbl_isnotzero(newbitp1,newbitp2) && Dbl_isnotzero(srcp1,srcp2)) { Dbl_addition(resultp1,resultp2,newbitp1,newbitp2,sump1,sump2); if(Dbl_isnotgreaterthan(sump1,sump2,srcp1,srcp2)) { Dbl_leftshiftby1(newbitp1,newbitp2); /* update result */ Dbl_addition(resultp1,resultp2,newbitp1,newbitp2, resultp1,resultp2); Dbl_subtract(srcp1,srcp2,sump1,sump2,srcp1,srcp2); Dbl_rightshiftby2(newbitp1,newbitp2); } else { Dbl_rightshiftby1(newbitp1,newbitp2); } Dbl_leftshiftby1(srcp1,srcp2); } /* correct exponent for pre-shift */ if (even_exponent) { Dbl_rightshiftby1(resultp1,resultp2); } /* check for inexact */ if (Dbl_isnotzero(srcp1,srcp2)) { if (!even_exponent && Dbl_islessthan(resultp1,resultp2,srcp1,srcp2)) { Dbl_increment(resultp1,resultp2); } guardbit = Dbl_lowmantissap2(resultp2); Dbl_rightshiftby1(resultp1,resultp2); /* now round result */ switch (Rounding_mode()) { case ROUNDPLUS: Dbl_increment(resultp1,resultp2); break; case ROUNDNEAREST: /* stickybit is always true, so guardbit * is enough to determine rounding */ if (guardbit) { Dbl_increment(resultp1,resultp2); } break; } /* increment result exponent by 1 if mantissa overflowed */ if (Dbl_isone_hiddenoverflow(resultp1)) src_exponent+=2; if (Is_inexacttrap_enabled()) { Dbl_set_exponent(resultp1, ((src_exponent-DBL_BIAS)>>1)+DBL_BIAS); Dbl_copytoptr(resultp1,resultp2,dstptr); return(INEXACTEXCEPTION); } else Set_inexactflag(); }
int dbl_fdiv (dbl_floating_point * srcptr1, dbl_floating_point * srcptr2, dbl_floating_point * dstptr, unsigned int *status) { register unsigned int opnd1p1, opnd1p2, opnd2p1, opnd2p2; register unsigned int opnd3p1, opnd3p2, resultp1, resultp2; register int dest_exponent, count; register boolean inexact = FALSE, guardbit = FALSE, stickybit = FALSE; boolean is_tiny; Dbl_copyfromptr(srcptr1,opnd1p1,opnd1p2); Dbl_copyfromptr(srcptr2,opnd2p1,opnd2p2); /* * set sign bit of result */ if (Dbl_sign(opnd1p1) ^ Dbl_sign(opnd2p1)) Dbl_setnegativezerop1(resultp1); else Dbl_setzerop1(resultp1); /* * check first operand for NaN's or infinity */ if (Dbl_isinfinity_exponent(opnd1p1)) { if (Dbl_iszero_mantissa(opnd1p1,opnd1p2)) { if (Dbl_isnotnan(opnd2p1,opnd2p2)) { if (Dbl_isinfinity(opnd2p1,opnd2p2)) { /* * invalid since both operands * are infinity */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* * return infinity */ Dbl_setinfinity_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } } else { /* * is NaN; signaling or quiet? */ if (Dbl_isone_signaling(opnd1p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd1p1); } /* * is second operand a signaling NaN? */ else if (Dbl_is_signalingnan(opnd2p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd2p1); Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } /* * return quiet NaN */ Dbl_copytoptr(opnd1p1,opnd1p2,dstptr); return(NOEXCEPTION); } } /* * check second operand for NaN's or infinity */ if (Dbl_isinfinity_exponent(opnd2p1)) { if (Dbl_iszero_mantissa(opnd2p1,opnd2p2)) { /* * return zero */ Dbl_setzero_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* * is NaN; signaling or quiet? */ if (Dbl_isone_signaling(opnd2p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd2p1); } /* * return quiet NaN */ Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } /* * check for division by zero */ if (Dbl_iszero_exponentmantissa(opnd2p1,opnd2p2)) { if (Dbl_iszero_exponentmantissa(opnd1p1,opnd1p2)) { /* invalid since both operands are zero */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } if (Is_divisionbyzerotrap_enabled()) return(DIVISIONBYZEROEXCEPTION); Set_divisionbyzeroflag(); Dbl_setinfinity_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* * Generate exponent */ dest_exponent = Dbl_exponent(opnd1p1) - Dbl_exponent(opnd2p1) + DBL_BIAS; /* * Generate mantissa */ if (Dbl_isnotzero_exponent(opnd1p1)) { /* set hidden bit */ Dbl_clear_signexponent_set_hidden(opnd1p1); } else { /* check for zero */ if (Dbl_iszero_mantissa(opnd1p1,opnd1p2)) { Dbl_setzero_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* is denormalized, want to normalize */ Dbl_clear_signexponent(opnd1p1); Dbl_leftshiftby1(opnd1p1,opnd1p2); Dbl_normalize(opnd1p1,opnd1p2,dest_exponent); } /* opnd2 needs to have hidden bit set with msb in hidden bit */ if (Dbl_isnotzero_exponent(opnd2p1)) { Dbl_clear_signexponent_set_hidden(opnd2p1); } else { /* is denormalized; want to normalize */ Dbl_clear_signexponent(opnd2p1); Dbl_leftshiftby1(opnd2p1,opnd2p2); while (Dbl_iszero_hiddenhigh7mantissa(opnd2p1)) { dest_exponent+=8; Dbl_leftshiftby8(opnd2p1,opnd2p2); } if (Dbl_iszero_hiddenhigh3mantissa(opnd2p1)) { dest_exponent+=4; Dbl_leftshiftby4(opnd2p1,opnd2p2); } while (Dbl_iszero_hidden(opnd2p1)) { dest_exponent++; Dbl_leftshiftby1(opnd2p1,opnd2p2); } } /* Divide the source mantissas */ /* * A non-restoring divide algorithm is used. */ Twoword_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2); Dbl_setzero(opnd3p1,opnd3p2); for (count=1; count <= DBL_P && (opnd1p1 || opnd1p2); count++) { Dbl_leftshiftby1(opnd1p1,opnd1p2); Dbl_leftshiftby1(opnd3p1,opnd3p2); if (Dbl_iszero_sign(opnd1p1)) { Dbl_setone_lowmantissap2(opnd3p2); Twoword_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2); } else { Twoword_add(opnd1p1, opnd1p2, opnd2p1, opnd2p2); } } if (count <= DBL_P) { Dbl_leftshiftby1(opnd3p1,opnd3p2); Dbl_setone_lowmantissap2(opnd3p2); Dbl_leftshift(opnd3p1,opnd3p2,(DBL_P-count)); if (Dbl_iszero_hidden(opnd3p1)) { Dbl_leftshiftby1(opnd3p1,opnd3p2); dest_exponent--; } } else { if (Dbl_iszero_hidden(opnd3p1)) { /* need to get one more bit of result */ Dbl_leftshiftby1(opnd1p1,opnd1p2); Dbl_leftshiftby1(opnd3p1,opnd3p2); if (Dbl_iszero_sign(opnd1p1)) { Dbl_setone_lowmantissap2(opnd3p2); Twoword_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2); } else { Twoword_add(opnd1p1,opnd1p2,opnd2p1,opnd2p2); } dest_exponent--; } if (Dbl_iszero_sign(opnd1p1)) guardbit = TRUE; stickybit = Dbl_allp1(opnd1p1) || Dbl_allp2(opnd1p2); } inexact = guardbit | stickybit; /* * round result */ if (inexact && (dest_exponent > 0 || Is_underflowtrap_enabled())) { Dbl_clear_signexponent(opnd3p1); switch (Rounding_mode()) { case ROUNDPLUS: if (Dbl_iszero_sign(resultp1)) Dbl_increment(opnd3p1,opnd3p2); break; case ROUNDMINUS: if (Dbl_isone_sign(resultp1)) Dbl_increment(opnd3p1,opnd3p2); break; case ROUNDNEAREST: if (guardbit && (stickybit || Dbl_isone_lowmantissap2(opnd3p2))) { Dbl_increment(opnd3p1,opnd3p2); } } if (Dbl_isone_hidden(opnd3p1)) dest_exponent++; } Dbl_set_mantissa(resultp1,resultp2,opnd3p1,opnd3p2); /* * Test for overflow */ if (dest_exponent >= DBL_INFINITY_EXPONENT) { /* trap if OVERFLOWTRAP enabled */ if (Is_overflowtrap_enabled()) { /* * Adjust bias of result */ Dbl_setwrapped_exponent(resultp1,dest_exponent,ovfl); Dbl_copytoptr(resultp1,resultp2,dstptr); if (inexact) if (Is_inexacttrap_enabled()) return(OVERFLOWEXCEPTION | INEXACTEXCEPTION); else Set_inexactflag(); return(OVERFLOWEXCEPTION); } Set_overflowflag(); /* set result to infinity or largest number */ Dbl_setoverflow(resultp1,resultp2); inexact = TRUE; } /* * Test for underflow */ else if (dest_exponent <= 0) { /* trap if UNDERFLOWTRAP enabled */ if (Is_underflowtrap_enabled()) { /* * Adjust bias of result */ Dbl_setwrapped_exponent(resultp1,dest_exponent,unfl); Dbl_copytoptr(resultp1,resultp2,dstptr); if (inexact) if (Is_inexacttrap_enabled()) return(UNDERFLOWEXCEPTION | INEXACTEXCEPTION); else Set_inexactflag(); return(UNDERFLOWEXCEPTION); } /* Determine if should set underflow flag */ is_tiny = TRUE; if (dest_exponent == 0 && inexact) { switch (Rounding_mode()) { case ROUNDPLUS: if (Dbl_iszero_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); if (Dbl_isone_hiddenoverflow(opnd3p1)) is_tiny = FALSE; Dbl_decrement(opnd3p1,opnd3p2); } break; case ROUNDMINUS: if (Dbl_isone_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); if (Dbl_isone_hiddenoverflow(opnd3p1)) is_tiny = FALSE; Dbl_decrement(opnd3p1,opnd3p2); } break; case ROUNDNEAREST: if (guardbit && (stickybit || Dbl_isone_lowmantissap2(opnd3p2))) { Dbl_increment(opnd3p1,opnd3p2); if (Dbl_isone_hiddenoverflow(opnd3p1)) is_tiny = FALSE; Dbl_decrement(opnd3p1,opnd3p2); } break; } } /* * denormalize result or set to signed zero */ stickybit = inexact; Dbl_denormalize(opnd3p1,opnd3p2,dest_exponent,guardbit, stickybit,inexact); /* return rounded number */ if (inexact) { switch (Rounding_mode()) { case ROUNDPLUS: if (Dbl_iszero_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); } break; case ROUNDMINUS: if (Dbl_isone_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); } break; case ROUNDNEAREST: if (guardbit && (stickybit || Dbl_isone_lowmantissap2(opnd3p2))) { Dbl_increment(opnd3p1,opnd3p2); } break; } if (is_tiny) Set_underflowflag(); } Dbl_set_exponentmantissa(resultp1,resultp2,opnd3p1,opnd3p2); } else Dbl_set_exponent(resultp1,dest_exponent); Dbl_copytoptr(resultp1,resultp2,dstptr); /* check for inexact */ if (inexact) { if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION); else Set_inexactflag(); } return(NOEXCEPTION); }
int dbl_fmpy( dbl_floating_point *srcptr1, dbl_floating_point *srcptr2, dbl_floating_point *dstptr, unsigned int *status) { register unsigned int opnd1p1, opnd1p2, opnd2p1, opnd2p2; register unsigned int opnd3p1, opnd3p2, resultp1, resultp2; register int dest_exponent, count; register boolean inexact = FALSE, guardbit = FALSE, stickybit = FALSE; boolean is_tiny; Dbl_copyfromptr(srcptr1,opnd1p1,opnd1p2); Dbl_copyfromptr(srcptr2,opnd2p1,opnd2p2); /* * set sign bit of result */ if (Dbl_sign(opnd1p1) ^ Dbl_sign(opnd2p1)) Dbl_setnegativezerop1(resultp1); else Dbl_setzerop1(resultp1); /* * check first operand for NaN's or infinity */ if (Dbl_isinfinity_exponent(opnd1p1)) { if (Dbl_iszero_mantissa(opnd1p1,opnd1p2)) { if (Dbl_isnotnan(opnd2p1,opnd2p2)) { if (Dbl_iszero_exponentmantissa(opnd2p1,opnd2p2)) { /* * invalid since operands are infinity * and zero */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* * return infinity */ Dbl_setinfinity_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } } else { /* * is NaN; signaling or quiet? */ if (Dbl_isone_signaling(opnd1p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd1p1); } /* * is second operand a signaling NaN? */ else if (Dbl_is_signalingnan(opnd2p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd2p1); Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } /* * return quiet NaN */ Dbl_copytoptr(opnd1p1,opnd1p2,dstptr); return(NOEXCEPTION); } } /* * check second operand for NaN's or infinity */ if (Dbl_isinfinity_exponent(opnd2p1)) { if (Dbl_iszero_mantissa(opnd2p1,opnd2p2)) { if (Dbl_iszero_exponentmantissa(opnd1p1,opnd1p2)) { /* invalid since operands are zero & infinity */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(opnd2p1,opnd2p2); Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } /* * return infinity */ Dbl_setinfinity_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* * is NaN; signaling or quiet? */ if (Dbl_isone_signaling(opnd2p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd2p1); } /* * return quiet NaN */ Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } /* * Generate exponent */ dest_exponent = Dbl_exponent(opnd1p1) + Dbl_exponent(opnd2p1) -DBL_BIAS; /* * Generate mantissa */ if (Dbl_isnotzero_exponent(opnd1p1)) { /* set hidden bit */ Dbl_clear_signexponent_set_hidden(opnd1p1); } else { /* check for zero */ if (Dbl_iszero_mantissa(opnd1p1,opnd1p2)) { Dbl_setzero_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* is denormalized, adjust exponent */ Dbl_clear_signexponent(opnd1p1); Dbl_leftshiftby1(opnd1p1,opnd1p2); Dbl_normalize(opnd1p1,opnd1p2,dest_exponent); } /* opnd2 needs to have hidden bit set with msb in hidden bit */ if (Dbl_isnotzero_exponent(opnd2p1)) { Dbl_clear_signexponent_set_hidden(opnd2p1); } else { /* check for zero */ if (Dbl_iszero_mantissa(opnd2p1,opnd2p2)) { Dbl_setzero_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* is denormalized; want to normalize */ Dbl_clear_signexponent(opnd2p1); Dbl_leftshiftby1(opnd2p1,opnd2p2); Dbl_normalize(opnd2p1,opnd2p2,dest_exponent); } /* Multiply two source mantissas together */ /* make room for guard bits */ Dbl_leftshiftby7(opnd2p1,opnd2p2); Dbl_setzero(opnd3p1,opnd3p2); /* * Four bits at a time are inspected in each loop, and a * simple shift and add multiply algorithm is used. */ for (count=1;count<=DBL_P;count+=4) { stickybit |= Dlow4p2(opnd3p2); Dbl_rightshiftby4(opnd3p1,opnd3p2); if (Dbit28p2(opnd1p2)) { /* Twoword_add should be an ADDC followed by an ADD. */ Twoword_add(opnd3p1, opnd3p2, opnd2p1<<3 | opnd2p2>>29, opnd2p2<<3); } if (Dbit29p2(opnd1p2)) { Twoword_add(opnd3p1, opnd3p2, opnd2p1<<2 | opnd2p2>>30, opnd2p2<<2); } if (Dbit30p2(opnd1p2)) { Twoword_add(opnd3p1, opnd3p2, opnd2p1<<1 | opnd2p2>>31, opnd2p2<<1); } if (Dbit31p2(opnd1p2)) { Twoword_add(opnd3p1, opnd3p2, opnd2p1, opnd2p2); } Dbl_rightshiftby4(opnd1p1,opnd1p2); } if (Dbit3p1(opnd3p1)==0) { Dbl_leftshiftby1(opnd3p1,opnd3p2); } else { /* result mantissa >= 2. */ dest_exponent++; } /* check for denormalized result */ while (Dbit3p1(opnd3p1)==0) { Dbl_leftshiftby1(opnd3p1,opnd3p2); dest_exponent--; } /* * check for guard, sticky and inexact bits */ stickybit |= Dallp2(opnd3p2) << 25; guardbit = (Dallp2(opnd3p2) << 24) >> 31; inexact = guardbit | stickybit; /* align result mantissa */ Dbl_rightshiftby8(opnd3p1,opnd3p2); /* * round result */ if (inexact && (dest_exponent>0 || Is_underflowtrap_enabled())) { Dbl_clear_signexponent(opnd3p1); switch (Rounding_mode()) { case ROUNDPLUS: if (Dbl_iszero_sign(resultp1)) Dbl_increment(opnd3p1,opnd3p2); break; case ROUNDMINUS: if (Dbl_isone_sign(resultp1)) Dbl_increment(opnd3p1,opnd3p2); break; case ROUNDNEAREST: if (guardbit) { if (stickybit || Dbl_isone_lowmantissap2(opnd3p2)) Dbl_increment(opnd3p1,opnd3p2); } } if (Dbl_isone_hidden(opnd3p1)) dest_exponent++; } Dbl_set_mantissa(resultp1,resultp2,opnd3p1,opnd3p2); /* * Test for overflow */ if (dest_exponent >= DBL_INFINITY_EXPONENT) { /* trap if OVERFLOWTRAP enabled */ if (Is_overflowtrap_enabled()) { /* * Adjust bias of result */ Dbl_setwrapped_exponent(resultp1,dest_exponent,ovfl); Dbl_copytoptr(resultp1,resultp2,dstptr); if (inexact) if (Is_inexacttrap_enabled()) return (OVERFLOWEXCEPTION | INEXACTEXCEPTION); else Set_inexactflag(); return (OVERFLOWEXCEPTION); } inexact = TRUE; Set_overflowflag(); /* set result to infinity or largest number */ Dbl_setoverflow(resultp1,resultp2); } /* * Test for underflow */ else if (dest_exponent <= 0) { /* trap if UNDERFLOWTRAP enabled */ if (Is_underflowtrap_enabled()) { /* * Adjust bias of result */ Dbl_setwrapped_exponent(resultp1,dest_exponent,unfl); Dbl_copytoptr(resultp1,resultp2,dstptr); if (inexact) if (Is_inexacttrap_enabled()) return (UNDERFLOWEXCEPTION | INEXACTEXCEPTION); else Set_inexactflag(); return (UNDERFLOWEXCEPTION); } /* Determine if should set underflow flag */ is_tiny = TRUE; if (dest_exponent == 0 && inexact) { switch (Rounding_mode()) { case ROUNDPLUS: if (Dbl_iszero_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); if (Dbl_isone_hiddenoverflow(opnd3p1)) is_tiny = FALSE; Dbl_decrement(opnd3p1,opnd3p2); } break; case ROUNDMINUS: if (Dbl_isone_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); if (Dbl_isone_hiddenoverflow(opnd3p1)) is_tiny = FALSE; Dbl_decrement(opnd3p1,opnd3p2); } break; case ROUNDNEAREST: if (guardbit && (stickybit || Dbl_isone_lowmantissap2(opnd3p2))) { Dbl_increment(opnd3p1,opnd3p2); if (Dbl_isone_hiddenoverflow(opnd3p1)) is_tiny = FALSE; Dbl_decrement(opnd3p1,opnd3p2); } break; } } /* * denormalize result or set to signed zero */ stickybit = inexact; Dbl_denormalize(opnd3p1,opnd3p2,dest_exponent,guardbit, stickybit,inexact); /* return zero or smallest number */ if (inexact) { switch (Rounding_mode()) { case ROUNDPLUS: if (Dbl_iszero_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); } break; case ROUNDMINUS: if (Dbl_isone_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); } break; case ROUNDNEAREST: if (guardbit && (stickybit || Dbl_isone_lowmantissap2(opnd3p2))) { Dbl_increment(opnd3p1,opnd3p2); } break; } if (is_tiny) Set_underflowflag(); } Dbl_set_exponentmantissa(resultp1,resultp2,opnd3p1,opnd3p2); } else Dbl_set_exponent(resultp1,dest_exponent); /* check for inexact */ Dbl_copytoptr(resultp1,resultp2,dstptr); if (inexact) { if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION); else Set_inexactflag(); } return(NOEXCEPTION); }
int dbl_fdiv (dbl_floating_point * srcptr1, dbl_floating_point * srcptr2, dbl_floating_point * dstptr, unsigned int *status) { register unsigned int opnd1p1, opnd1p2, opnd2p1, opnd2p2; register unsigned int opnd3p1, opnd3p2, resultp1, resultp2; register int dest_exponent, count; register boolean inexact = FALSE, guardbit = FALSE, stickybit = FALSE; boolean is_tiny; Dbl_copyfromptr(srcptr1,opnd1p1,opnd1p2); Dbl_copyfromptr(srcptr2,opnd2p1,opnd2p2); /* */ if (Dbl_sign(opnd1p1) ^ Dbl_sign(opnd2p1)) Dbl_setnegativezerop1(resultp1); else Dbl_setzerop1(resultp1); /* */ if (Dbl_isinfinity_exponent(opnd1p1)) { if (Dbl_iszero_mantissa(opnd1p1,opnd1p2)) { if (Dbl_isnotnan(opnd2p1,opnd2p2)) { if (Dbl_isinfinity(opnd2p1,opnd2p2)) { /* */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* */ Dbl_setinfinity_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } } else { /* */ if (Dbl_isone_signaling(opnd1p1)) { /* */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* */ Set_invalidflag(); Dbl_set_quiet(opnd1p1); } /* */ else if (Dbl_is_signalingnan(opnd2p1)) { /* */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* */ Set_invalidflag(); Dbl_set_quiet(opnd2p1); Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } /* */ Dbl_copytoptr(opnd1p1,opnd1p2,dstptr); return(NOEXCEPTION); } } /* */ if (Dbl_isinfinity_exponent(opnd2p1)) { if (Dbl_iszero_mantissa(opnd2p1,opnd2p2)) { /* */ Dbl_setzero_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* */ if (Dbl_isone_signaling(opnd2p1)) { /* */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* */ Set_invalidflag(); Dbl_set_quiet(opnd2p1); } /* */ Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } /* */ if (Dbl_iszero_exponentmantissa(opnd2p1,opnd2p2)) { if (Dbl_iszero_exponentmantissa(opnd1p1,opnd1p2)) { /* */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } if (Is_divisionbyzerotrap_enabled()) return(DIVISIONBYZEROEXCEPTION); Set_divisionbyzeroflag(); Dbl_setinfinity_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* */ dest_exponent = Dbl_exponent(opnd1p1) - Dbl_exponent(opnd2p1) + DBL_BIAS; /* */ if (Dbl_isnotzero_exponent(opnd1p1)) { /* */ Dbl_clear_signexponent_set_hidden(opnd1p1); } else { /* */ if (Dbl_iszero_mantissa(opnd1p1,opnd1p2)) { Dbl_setzero_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* */ Dbl_clear_signexponent(opnd1p1); Dbl_leftshiftby1(opnd1p1,opnd1p2); Dbl_normalize(opnd1p1,opnd1p2,dest_exponent); } /* */ if (Dbl_isnotzero_exponent(opnd2p1)) { Dbl_clear_signexponent_set_hidden(opnd2p1); } else { /* */ Dbl_clear_signexponent(opnd2p1); Dbl_leftshiftby1(opnd2p1,opnd2p2); while (Dbl_iszero_hiddenhigh7mantissa(opnd2p1)) { dest_exponent+=8; Dbl_leftshiftby8(opnd2p1,opnd2p2); } if (Dbl_iszero_hiddenhigh3mantissa(opnd2p1)) { dest_exponent+=4; Dbl_leftshiftby4(opnd2p1,opnd2p2); } while (Dbl_iszero_hidden(opnd2p1)) { dest_exponent++; Dbl_leftshiftby1(opnd2p1,opnd2p2); } } /* */ /* */ Twoword_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2); Dbl_setzero(opnd3p1,opnd3p2); for (count=1; count <= DBL_P && (opnd1p1 || opnd1p2); count++) { Dbl_leftshiftby1(opnd1p1,opnd1p2); Dbl_leftshiftby1(opnd3p1,opnd3p2); if (Dbl_iszero_sign(opnd1p1)) { Dbl_setone_lowmantissap2(opnd3p2); Twoword_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2); } else { Twoword_add(opnd1p1, opnd1p2, opnd2p1, opnd2p2); } } if (count <= DBL_P) { Dbl_leftshiftby1(opnd3p1,opnd3p2); Dbl_setone_lowmantissap2(opnd3p2); Dbl_leftshift(opnd3p1,opnd3p2,(DBL_P-count)); if (Dbl_iszero_hidden(opnd3p1)) { Dbl_leftshiftby1(opnd3p1,opnd3p2); dest_exponent--; } } else { if (Dbl_iszero_hidden(opnd3p1)) { /* */ Dbl_leftshiftby1(opnd1p1,opnd1p2); Dbl_leftshiftby1(opnd3p1,opnd3p2); if (Dbl_iszero_sign(opnd1p1)) { Dbl_setone_lowmantissap2(opnd3p2); Twoword_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2); } else { Twoword_add(opnd1p1,opnd1p2,opnd2p1,opnd2p2); } dest_exponent--; } if (Dbl_iszero_sign(opnd1p1)) guardbit = TRUE; stickybit = Dbl_allp1(opnd1p1) || Dbl_allp2(opnd1p2); } inexact = guardbit | stickybit; /* */ if (inexact && (dest_exponent > 0 || Is_underflowtrap_enabled())) { Dbl_clear_signexponent(opnd3p1); switch (Rounding_mode()) { case ROUNDPLUS: if (Dbl_iszero_sign(resultp1)) Dbl_increment(opnd3p1,opnd3p2); break; case ROUNDMINUS: if (Dbl_isone_sign(resultp1)) Dbl_increment(opnd3p1,opnd3p2); break; case ROUNDNEAREST: if (guardbit && (stickybit || Dbl_isone_lowmantissap2(opnd3p2))) { Dbl_increment(opnd3p1,opnd3p2); } } if (Dbl_isone_hidden(opnd3p1)) dest_exponent++; } Dbl_set_mantissa(resultp1,resultp2,opnd3p1,opnd3p2); /* */ if (dest_exponent >= DBL_INFINITY_EXPONENT) { /* */ if (Is_overflowtrap_enabled()) { /* */ Dbl_setwrapped_exponent(resultp1,dest_exponent,ovfl); Dbl_copytoptr(resultp1,resultp2,dstptr); if (inexact) if (Is_inexacttrap_enabled()) return(OVERFLOWEXCEPTION | INEXACTEXCEPTION); else Set_inexactflag(); return(OVERFLOWEXCEPTION); } Set_overflowflag(); /* */ Dbl_setoverflow(resultp1,resultp2); inexact = TRUE; } /* */ else if (dest_exponent <= 0) { /* */ if (Is_underflowtrap_enabled()) { /* */ Dbl_setwrapped_exponent(resultp1,dest_exponent,unfl); Dbl_copytoptr(resultp1,resultp2,dstptr); if (inexact) if (Is_inexacttrap_enabled()) return(UNDERFLOWEXCEPTION | INEXACTEXCEPTION); else Set_inexactflag(); return(UNDERFLOWEXCEPTION); } /* */ is_tiny = TRUE; if (dest_exponent == 0 && inexact) { switch (Rounding_mode()) { case ROUNDPLUS: if (Dbl_iszero_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); if (Dbl_isone_hiddenoverflow(opnd3p1)) is_tiny = FALSE; Dbl_decrement(opnd3p1,opnd3p2); } break; case ROUNDMINUS: if (Dbl_isone_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); if (Dbl_isone_hiddenoverflow(opnd3p1)) is_tiny = FALSE; Dbl_decrement(opnd3p1,opnd3p2); } break; case ROUNDNEAREST: if (guardbit && (stickybit || Dbl_isone_lowmantissap2(opnd3p2))) { Dbl_increment(opnd3p1,opnd3p2); if (Dbl_isone_hiddenoverflow(opnd3p1)) is_tiny = FALSE; Dbl_decrement(opnd3p1,opnd3p2); } break; } } /* */ stickybit = inexact; Dbl_denormalize(opnd3p1,opnd3p2,dest_exponent,guardbit, stickybit,inexact); /* */ if (inexact) { switch (Rounding_mode()) { case ROUNDPLUS: if (Dbl_iszero_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); } break; case ROUNDMINUS: if (Dbl_isone_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); } break; case ROUNDNEAREST: if (guardbit && (stickybit || Dbl_isone_lowmantissap2(opnd3p2))) { Dbl_increment(opnd3p1,opnd3p2); } break; } if (is_tiny) Set_underflowflag(); } Dbl_set_exponentmantissa(resultp1,resultp2,opnd3p1,opnd3p2); } else Dbl_set_exponent(resultp1,dest_exponent); Dbl_copytoptr(resultp1,resultp2,dstptr); /* */ if (inexact) { if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION); else Set_inexactflag(); } return(NOEXCEPTION); }
int dbl_fmpyfadd( dbl_floating_point *src1ptr, dbl_floating_point *src2ptr, dbl_floating_point *src3ptr, unsigned int *status, dbl_floating_point *dstptr) { unsigned int opnd1p1, opnd1p2, opnd2p1, opnd2p2, opnd3p1, opnd3p2; register unsigned int tmpresp1, tmpresp2, tmpresp3, tmpresp4; unsigned int rightp1, rightp2, rightp3, rightp4; unsigned int resultp1, resultp2 = 0, resultp3 = 0, resultp4 = 0; register int mpy_exponent, add_exponent, count; boolean inexact = FALSE, is_tiny = FALSE; unsigned int signlessleft1, signlessright1, save; register int result_exponent, diff_exponent; int sign_save, jumpsize; Dbl_copyfromptr(src1ptr,opnd1p1,opnd1p2); Dbl_copyfromptr(src2ptr,opnd2p1,opnd2p2); Dbl_copyfromptr(src3ptr,opnd3p1,opnd3p2); if (Dbl_sign(opnd1p1) ^ Dbl_sign(opnd2p1)) Dbl_setnegativezerop1(resultp1); else Dbl_setzerop1(resultp1); mpy_exponent = Dbl_exponent(opnd1p1) + Dbl_exponent(opnd2p1) - DBL_BIAS; if (Dbl_isinfinity_exponent(opnd1p1)) { if (Dbl_iszero_mantissa(opnd1p1,opnd1p2)) { if (Dbl_isnotnan(opnd2p1,opnd2p2) && Dbl_isnotnan(opnd3p1,opnd3p2)) { if (Dbl_iszero_exponentmantissa(opnd2p1,opnd2p2)) { if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } if (Dbl_isinfinity(opnd3p1,opnd3p2) && (Dbl_sign(resultp1) ^ Dbl_sign(opnd3p1))) { if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } Dbl_setinfinity_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } } else { if (Dbl_isone_signaling(opnd1p1)) { if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Dbl_set_quiet(opnd1p1); } else if (Dbl_is_signalingnan(opnd2p1)) { if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Dbl_set_quiet(opnd2p1); Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } else if (Dbl_is_signalingnan(opnd3p1)) { if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Dbl_set_quiet(opnd3p1); Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(NOEXCEPTION); } Dbl_copytoptr(opnd1p1,opnd1p2,dstptr); return(NOEXCEPTION); } } if (Dbl_isinfinity_exponent(opnd2p1)) { if (Dbl_iszero_mantissa(opnd2p1,opnd2p2)) { if (Dbl_isnotnan(opnd3p1,opnd3p2)) { if (Dbl_iszero_exponentmantissa(opnd1p1,opnd1p2)) { if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(opnd2p1,opnd2p2); Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } if (Dbl_isinfinity(opnd3p1,opnd3p2) && (Dbl_sign(resultp1) ^ Dbl_sign(opnd3p1))) { if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } Dbl_setinfinity_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } } else { if (Dbl_isone_signaling(opnd2p1)) { if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Dbl_set_quiet(opnd2p1); } else if (Dbl_is_signalingnan(opnd3p1)) { if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Dbl_set_quiet(opnd3p1); Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(NOEXCEPTION); } Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } } if (Dbl_isinfinity_exponent(opnd3p1)) { if (Dbl_iszero_mantissa(opnd3p1,opnd3p2)) { Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(NOEXCEPTION); } else { if (Dbl_isone_signaling(opnd3p1)) { if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Dbl_set_quiet(opnd3p1); } Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(NOEXCEPTION); } } if (Dbl_isnotzero_exponent(opnd1p1)) { Dbl_clear_signexponent_set_hidden(opnd1p1); } else { if (Dbl_iszero_mantissa(opnd1p1,opnd1p2)) { if (Dbl_iszero_exponentmantissa(opnd3p1,opnd3p2)) { if (Is_rounding_mode(ROUNDMINUS)) { Dbl_or_signs(opnd3p1,resultp1); } else { Dbl_and_signs(opnd3p1,resultp1); } } else if (Dbl_iszero_exponent(opnd3p1) && Is_underflowtrap_enabled()) { sign_save = Dbl_signextendedsign(opnd3p1); result_exponent = 0; Dbl_leftshiftby1(opnd3p1,opnd3p2); Dbl_normalize(opnd3p1,opnd3p2,result_exponent); Dbl_set_sign(opnd3p1,sign_save); Dbl_setwrapped_exponent(opnd3p1,result_exponent, unfl); Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(OPC_2E_UNDERFLOWEXCEPTION); } Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(NOEXCEPTION); } Dbl_clear_signexponent(opnd1p1); Dbl_leftshiftby1(opnd1p1,opnd1p2); Dbl_normalize(opnd1p1,opnd1p2,mpy_exponent); } if (Dbl_isnotzero_exponent(opnd2p1)) { Dbl_clear_signexponent_set_hidden(opnd2p1); } else { if (Dbl_iszero_mantissa(opnd2p1,opnd2p2)) { if (Dbl_iszero_exponentmantissa(opnd3p1,opnd3p2)) { if (Is_rounding_mode(ROUNDMINUS)) { Dbl_or_signs(opnd3p1,resultp1); } else { Dbl_and_signs(opnd3p1,resultp1); } } else if (Dbl_iszero_exponent(opnd3p1) && Is_underflowtrap_enabled()) { sign_save = Dbl_signextendedsign(opnd3p1); result_exponent = 0; Dbl_leftshiftby1(opnd3p1,opnd3p2); Dbl_normalize(opnd3p1,opnd3p2,result_exponent); Dbl_set_sign(opnd3p1,sign_save); Dbl_setwrapped_exponent(opnd3p1,result_exponent, unfl); Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(OPC_2E_UNDERFLOWEXCEPTION); } Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(NOEXCEPTION); } Dbl_clear_signexponent(opnd2p1); Dbl_leftshiftby1(opnd2p1,opnd2p2); Dbl_normalize(opnd2p1,opnd2p2,mpy_exponent); } Dblext_setzero(tmpresp1,tmpresp2,tmpresp3,tmpresp4); for (count = DBL_P-1; count >= 0; count -= 4) { Dblext_rightshiftby4(tmpresp1,tmpresp2,tmpresp3,tmpresp4); if (Dbit28p2(opnd1p2)) { Fourword_add(tmpresp1, tmpresp2, tmpresp3, tmpresp4, opnd2p1<<3 | opnd2p2>>29, opnd2p2<<3, 0, 0); } if (Dbit29p2(opnd1p2)) { Fourword_add(tmpresp1, tmpresp2, tmpresp3, tmpresp4, opnd2p1<<2 | opnd2p2>>30, opnd2p2<<2, 0, 0); } if (Dbit30p2(opnd1p2)) { Fourword_add(tmpresp1, tmpresp2, tmpresp3, tmpresp4, opnd2p1<<1 | opnd2p2>>31, opnd2p2<<1, 0, 0); } if (Dbit31p2(opnd1p2)) { Fourword_add(tmpresp1, tmpresp2, tmpresp3, tmpresp4, opnd2p1, opnd2p2, 0, 0); } Dbl_rightshiftby4(opnd1p1,opnd1p2); } if (Is_dexthiddenoverflow(tmpresp1)) { mpy_exponent++; Dblext_rightshiftby1(tmpresp1,tmpresp2,tmpresp3,tmpresp4); } Dblext_set_sign(tmpresp1,Dbl_sign(resultp1)); add_exponent = Dbl_exponent(opnd3p1); if (add_exponent == 0) { if (Dbl_iszero_mantissa(opnd3p1,opnd3p2)) { result_exponent = mpy_exponent; Dblext_copy(tmpresp1,tmpresp2,tmpresp3,tmpresp4, resultp1,resultp2,resultp3,resultp4); sign_save = Dbl_signextendedsign(resultp1); goto round; } sign_save = Dbl_signextendedsign(opnd3p1); Dbl_clear_signexponent(opnd3p1); Dbl_leftshiftby1(opnd3p1,opnd3p2); Dbl_normalize(opnd3p1,opnd3p2,add_exponent); Dbl_set_sign(opnd3p1,sign_save); } else { Dbl_clear_exponent_set_hidden(opnd3p1); } Dbl_copyto_dblext(opnd3p1,opnd3p2,rightp1,rightp2,rightp3,rightp4); Dblext_xortointp1(tmpresp1,rightp1,save); Dblext_copytoint_exponentmantissap1(tmpresp1,signlessleft1); Dblext_copytoint_exponentmantissap1(rightp1,signlessright1); if (mpy_exponent < add_exponent || mpy_exponent == add_exponent && Dblext_ismagnitudeless(tmpresp2,rightp2,signlessleft1,signlessright1)){ Dblext_xorfromintp1(save,rightp1,rightp1); Dblext_xorfromintp1(save,tmpresp1,tmpresp1); Dblext_swap_lower(tmpresp2,tmpresp3,tmpresp4, rightp2,rightp3,rightp4); diff_exponent = add_exponent - mpy_exponent; result_exponent = add_exponent; } else { diff_exponent = mpy_exponent - add_exponent; result_exponent = mpy_exponent; } if (diff_exponent > DBLEXT_THRESHOLD) { diff_exponent = DBLEXT_THRESHOLD; } Dblext_clear_sign(rightp1); Dblext_right_align(rightp1,rightp2,rightp3,rightp4, diff_exponent); if ((int)save < 0) { Dblext_subtract(tmpresp1,tmpresp2,tmpresp3,tmpresp4, rightp1,rightp2,rightp3,rightp4, resultp1,resultp2,resultp3,resultp4); sign_save = Dbl_signextendedsign(resultp1); if (Dbl_iszero_hidden(resultp1)) { Dblext_leftshiftby1(resultp1,resultp2,resultp3, resultp4); if(Dblext_iszero(resultp1,resultp2,resultp3,resultp4)){ if (Is_rounding_mode(ROUNDMINUS)) Dbl_setone_sign(resultp1); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } result_exponent--; if (Dbl_isone_hidden(resultp1)) { goto round; } while (Dbl_iszero_hiddenhigh7mantissa(resultp1)) { Dblext_leftshiftby8(resultp1,resultp2,resultp3,resultp4); result_exponent -= 8; } if (Dbl_iszero_hiddenhigh3mantissa(resultp1)) { Dblext_leftshiftby4(resultp1,resultp2,resultp3,resultp4); result_exponent -= 4; } jumpsize = Dbl_hiddenhigh3mantissa(resultp1); if (jumpsize <= 7) switch(jumpsize) { case 1: Dblext_leftshiftby3(resultp1,resultp2,resultp3, resultp4); result_exponent -= 3; break; case 2: case 3: Dblext_leftshiftby2(resultp1,resultp2,resultp3, resultp4); result_exponent -= 2; break; case 4: case 5: case 6: case 7: Dblext_leftshiftby1(resultp1,resultp2,resultp3, resultp4); result_exponent -= 1; break; } } } else { Dblext_addition(tmpresp1,tmpresp2,tmpresp3,tmpresp4, rightp1,rightp2,rightp3,rightp4, resultp1,resultp2,resultp3,resultp4); sign_save = Dbl_signextendedsign(resultp1); if (Dbl_isone_hiddenoverflow(resultp1)) { Dblext_arithrightshiftby1(resultp1,resultp2,resultp3, resultp4); result_exponent++; } } round: if (result_exponent <= 0 && !Is_underflowtrap_enabled()) { Dblext_denormalize(resultp1,resultp2,resultp3,resultp4, result_exponent,is_tiny); } Dbl_set_sign(resultp1,sign_save); if (Dblext_isnotzero_mantissap3(resultp3) || Dblext_isnotzero_mantissap4(resultp4)) { inexact = TRUE; switch(Rounding_mode()) { case ROUNDNEAREST: if (Dblext_isone_highp3(resultp3)) { if (Dblext_isnotzero_low31p3(resultp3) || Dblext_isnotzero_mantissap4(resultp4) || Dblext_isone_lowp2(resultp2)) { Dbl_increment(resultp1,resultp2); } } break; case ROUNDPLUS: if (Dbl_iszero_sign(resultp1)) { Dbl_increment(resultp1,resultp2); } break; case ROUNDMINUS: if (Dbl_isone_sign(resultp1)) { Dbl_increment(resultp1,resultp2); } case ROUNDZERO:; } if (Dbl_isone_hiddenoverflow(resultp1)) result_exponent++; } if (result_exponent >= DBL_INFINITY_EXPONENT) { if (Is_overflowtrap_enabled()) { Dbl_setwrapped_exponent(resultp1,result_exponent,ovfl); Dbl_copytoptr(resultp1,resultp2,dstptr); if (inexact) if (Is_inexacttrap_enabled()) return (OPC_2E_OVERFLOWEXCEPTION | OPC_2E_INEXACTEXCEPTION); else Set_inexactflag(); return (OPC_2E_OVERFLOWEXCEPTION); } inexact = TRUE; Set_overflowflag(); Dbl_setoverflow(resultp1,resultp2); } else if (result_exponent <= 0) { if (Is_underflowtrap_enabled()) { Dbl_setwrapped_exponent(resultp1,result_exponent,unfl); Dbl_copytoptr(resultp1,resultp2,dstptr); if (inexact) if (Is_inexacttrap_enabled()) return (OPC_2E_UNDERFLOWEXCEPTION | OPC_2E_INEXACTEXCEPTION); else Set_inexactflag(); return(OPC_2E_UNDERFLOWEXCEPTION); } else if (inexact && is_tiny) Set_underflowflag(); } else Dbl_set_exponent(resultp1,result_exponent); Dbl_copytoptr(resultp1,resultp2,dstptr); if (inexact) if (Is_inexacttrap_enabled()) return(OPC_2E_INEXACTEXCEPTION); else Set_inexactflag(); return(NOEXCEPTION); }