| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/Linux/arch/parisc/math-emu/ (Linux Kernel Version 6.17.9©) Datei vom 24.10.2025 mit Größe 77 kB |
|
SSL fmpyfadd.c Sprache: C |
|||||||||||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later /* * Linux/PA-RISC Project (http://www.parisc-linux.org/) * * Floating-point emulation code * Copyright (C) 2001 Hewlett-Packard (Paul Bame) <bame@debian.org> */ /* * BEGIN_DESC * * File: * @(#) pa/spmath/fmpyfadd.c $Revision: 1.1 $ * * Purpose: * Double Floating-point Multiply Fused Add * Double Floating-point Multiply Negate Fused Add * Single Floating-point Multiply Fused Add * Single Floating-point Multiply Negate Fused Add * * External Interfaces: * dbl_fmpyfadd(src1ptr,src2ptr,src3ptr,status,dstptr) * dbl_fmpynfadd(src1ptr,src2ptr,src3ptr,status,dstptr) * sgl_fmpyfadd(src1ptr,src2ptr,src3ptr,status,dstptr) * sgl_fmpynfadd(src1ptr,src2ptr,src3ptr,status,dstptr) * * Internal Interfaces: * * Theory: * <<please update with a overview of the operation of this file>> * * END_DESC */ #include "float.h" #include "sgl_float.h" #include "dbl_float.h" /* * Double Floating-point Multiply Fused Add */ 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); /* * set sign bit of result of multiply */ if (Dbl_sign(opnd1p1) ^ Dbl_sign(opnd2p1)) Dbl_setnegativezerop1(resultp1); else Dbl_setzerop1(resultp1); /* * Generate multiply exponent */ mpy_exponent = Dbl_exponent(opnd1p1) + Dbl_exponent(opnd2p1) - DBL_BIAS; /* * check first operand for NaN's or infinity */ 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)) { /* * invalid since operands are infinity * and zero */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* * Check third operand for infinity with a * sign opposite of the multiply result */ if (Dbl_isinfinity(opnd3p1,opnd3p2) && (Dbl_sign(resultp1) ^ Dbl_sign(opnd3p1))) { /* * invalid since attempting a magnitude * subtraction of infinities */ if (Is_invalidtrap_enabled()) return(OPC_2E_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(OPC_2E_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(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd2p1); Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } /* * is third operand a signaling NaN? */ else if (Dbl_is_signalingnan(opnd3p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd3p1); Dbl_copytoptr(opnd3p1,opnd3p2,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_isnotnan(opnd3p1,opnd3p2)) { if (Dbl_iszero_exponentmantissa(opnd1p1,opnd1p2)) { /* * invalid since multiply operands are * zero & infinity */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(opnd2p1,opnd2p2); Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } /* * Check third operand for infinity with a * sign opposite of the multiply result */ if (Dbl_isinfinity(opnd3p1,opnd3p2) && (Dbl_sign(resultp1) ^ Dbl_sign(opnd3p1))) { /* * invalid since attempting a magnitude * subtraction of infinities */ if (Is_invalidtrap_enabled()) return(OPC_2E_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(opnd2p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd2p1); } /* * is third operand a signaling NaN? */ else if (Dbl_is_signalingnan(opnd3p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd3p1); Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(NOEXCEPTION); } /* * return quiet NaN */ Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } } /* * check third operand for NaN's or infinity */ if (Dbl_isinfinity_exponent(opnd3p1)) { if (Dbl_iszero_mantissa(opnd3p1,opnd3p2)) { /* return infinity */ Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(NOEXCEPTION); } else { /* * is NaN; signaling or quiet? */ if (Dbl_isone_signaling(opnd3p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd3p1); } /* * return quiet NaN */ Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(NOEXCEPTION); } } /* * Generate multiply 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)) { /* * Perform the add opnd3 with zero here. */ if (Dbl_iszero_exponentmantissa(opnd3p1,opnd3p2)) { if (Is_rounding_mode(ROUNDMINUS)) { Dbl_or_signs(opnd3p1,resultp1); } else { Dbl_and_signs(opnd3p1,resultp1); } } /* * Now let's check for trapped underflow case. */ else if (Dbl_iszero_exponent(opnd3p1) && Is_underflowtrap_enabled()) { /* need to normalize results mantissa */ sign_save = Dbl_signextendedsign(opnd3p1); result_exponent = 0; Dbl_leftshiftby1(opnd3p1,opnd3p2); Dbl_normalize(opnd3p1,opnd3p2,result_exponent); Dbl_set_sign(opnd3p1,/*using*/sign_save); Dbl_setwrapped_exponent(opnd3p1,result_exponent, unfl); Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); /* inexact = FALSE */ return(OPC_2E_UNDERFLOWEXCEPTION); } Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(NOEXCEPTION); } /* is denormalized, adjust exponent */ Dbl_clear_signexponent(opnd1p1); Dbl_leftshiftby1(opnd1p1,opnd1p2); Dbl_normalize(opnd1p1,opnd1p2,mpy_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)) { /* * Perform the add opnd3 with zero here. */ if (Dbl_iszero_exponentmantissa(opnd3p1,opnd3p2)) { if (Is_rounding_mode(ROUNDMINUS)) { Dbl_or_signs(opnd3p1,resultp1); } else { Dbl_and_signs(opnd3p1,resultp1); } } /* * Now let's check for trapped underflow case. */ else if (Dbl_iszero_exponent(opnd3p1) && Is_underflowtrap_enabled()) { /* need to normalize results mantissa */ sign_save = Dbl_signextendedsign(opnd3p1); result_exponent = 0; Dbl_leftshiftby1(opnd3p1,opnd3p2); Dbl_normalize(opnd3p1,opnd3p2,result_exponent); Dbl_set_sign(opnd3p1,/*using*/sign_save); Dbl_setwrapped_exponent(opnd3p1,result_exponent, unfl); Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); /* inexact = FALSE */ return(OPC_2E_UNDERFLOWEXCEPTION); } Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(NOEXCEPTION); } /* is denormalized; want to normalize */ Dbl_clear_signexponent(opnd2p1); Dbl_leftshiftby1(opnd2p1,opnd2p2); Dbl_normalize(opnd2p1,opnd2p2,mpy_exponent); } /* Multiply the first two source mantissas together */ /* * The intermediate result will be kept in tmpres, * which needs enough room for 106 bits of mantissa, * so lets call it a Double extended. */ Dblext_setzero(tmpresp1,tmpresp2,tmpresp3,tmpresp4); /* * Four bits at a time are inspected in each loop, and a * simple shift and add multiply algorithm is used. */ for (count = DBL_P-1; count >= 0; count -= 4) { Dblext_rightshiftby4(tmpresp1,tmpresp2,tmpresp3,tmpresp4); if (Dbit28p2(opnd1p2)) { /* Fourword_add should be an ADD followed by 3 ADDC's */ 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)) { /* result mantissa >= 2 (mantissa overflow) */ mpy_exponent++; Dblext_rightshiftby1(tmpresp1,tmpresp2,tmpresp3,tmpresp4); } /* * Restore the sign of the mpy result which was saved in resultp1. * The exponent will continue to be kept in mpy_exponent. */ Dblext_set_sign(tmpresp1,Dbl_sign(resultp1)); /* * No rounding is required, since the result of the multiply * is exact in the extended format. */ /* * Now we are ready to perform the add portion of the operation. * * The exponents need to be kept as integers for now, since the * multiply result might not fit into the exponent field. We * can't overflow or underflow because of this yet, since the * add could bring the final result back into range. */ add_exponent = Dbl_exponent(opnd3p1); /* * Check for denormalized or zero add operand. */ if (add_exponent == 0) { /* check for zero */ if (Dbl_iszero_mantissa(opnd3p1,opnd3p2)) { /* right is zero */ /* Left can't be zero and must be result. * * The final result is now in tmpres and mpy_exponent, * and needs to be rounded and squeezed back into * double precision format from double extended. */ result_exponent = mpy_exponent; Dblext_copy(tmpresp1,tmpresp2,tmpresp3,tmpresp4, resultp1,resultp2,resultp3,resultp4); sign_save = Dbl_signextendedsign(resultp1);/*save sign*/ goto round; } /* * Neither are zeroes. * Adjust exponent and normalize add operand. */ sign_save = Dbl_signextendedsign(opnd3p1); /* save sign */ Dbl_clear_signexponent(opnd3p1); Dbl_leftshiftby1(opnd3p1,opnd3p2); Dbl_normalize(opnd3p1,opnd3p2,add_exponent); Dbl_set_sign(opnd3p1,sign_save); /* restore sign */ } else { Dbl_clear_exponent_set_hidden(opnd3p1); } /* * Copy opnd3 to the double extended variable called right. */ Dbl_copyto_dblext(opnd3p1,opnd3p2,rightp1,rightp2,rightp3,rightp4); /* * A zero "save" helps discover equal operands (for later), * and is used in swapping operands (if needed). */ Dblext_xortointp1(tmpresp1,rightp1,/*to*/save); /* * Compare magnitude of operands. */ 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)){ /* * Set the left operand to the larger one by XOR swap. * First finish the first word "save". */ Dblext_xorfromintp1(save,rightp1,/*to*/rightp1); Dblext_xorfromintp1(save,tmpresp1,/*to*/tmpresp1); Dblext_swap_lower(tmpresp2,tmpresp3,tmpresp4, rightp2,rightp3,rightp4); /* also setup exponents used in rest of routine */ diff_exponent = add_exponent - mpy_exponent; result_exponent = add_exponent; } else { /* also setup exponents used in rest of routine */ diff_exponent = mpy_exponent - add_exponent; result_exponent = mpy_exponent; } /* Invariant: left is not smaller than right. */ /* * 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 > DBLEXT_THRESHOLD) { diff_exponent = DBLEXT_THRESHOLD; } /* Align right operand by shifting it to the right */ Dblext_clear_sign(rightp1); Dblext_right_align(rightp1,rightp2,rightp3,rightp4, /*shifted by*/diff_exponent); /* Treat sum and difference of the operands separately. */ if ((int)save < 0) { /* * Difference of the two operands. Overflow can occur if the * multiply overflowed. A borrow can occur out of the hidden * bit and force a post normalization phase. */ Dblext_subtract(tmpresp1,tmpresp2,tmpresp3,tmpresp4, rightp1,rightp2,rightp3,rightp4, resultp1,resultp2,resultp3,resultp4); sign_save = Dbl_signextendedsign(resultp1); if (Dbl_iszero_hidden(resultp1)) { /* Handle normalization */ /* A straightforward 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. */ Dblext_leftshiftby1(resultp1,resultp2,resultp3, resultp4); /* 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(Dblext_iszero(resultp1,resultp2,resultp3,resultp4)){ /* 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)) { /* No further normalization is needed */ goto round; } /* 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)) { Dblext_leftshiftby8(resultp1,resultp2,resultp3,resultp4); result_exponent -= 8; } /* Now narrow it down to the nibble */ if (Dbl_iszero_hiddenhigh3mantissa(resultp1)) { /* The lower nibble contains the * normalizing one */ Dblext_leftshiftby4(resultp1,resultp2,resultp3,resultp4); result_exponent -= 4; } /* Select case where first bit is set (already * normalized) otherwise select the proper shift. */ 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; } } /* end if (hidden...)... */ /* Fall through and round */ } /* end if (save < 0)... */ else { /* Add magnitudes */ Dblext_addition(tmpresp1,tmpresp2,tmpresp3,tmpresp4, rightp1,rightp2,rightp3,rightp4, /*to*/resultp1,resultp2,resultp3,resultp4); sign_save = Dbl_signextendedsign(resultp1); if (Dbl_isone_hiddenoverflow(resultp1)) { /* Prenormalization required. */ Dblext_arithrightshiftby1(resultp1,resultp2,resultp3, resultp4); result_exponent++; } /* end if hiddenoverflow... */ } /* end else ...add magnitudes... */ /* Round the result. If the extension and lower two words are * all zeros, then the result is exact. Otherwise round in the * correct direction. Underflow is possible. If a postnormalization * is necessary, then the mantissa is all zeros so no shift is needed. */ round: if (result_exponent <= 0 && !Is_underflowtrap_enabled()) { Dblext_denormalize(resultp1,resultp2,resultp3,resultp4, result_exponent,is_tiny); } Dbl_set_sign(resultp1,/*using*/sign_save); if (Dblext_isnotzero_mantissap3(resultp3) || Dblext_isnotzero_mantissap4(resultp4)) { inexact = TRUE; switch(Rounding_mode()) { case ROUNDNEAREST: /* The default. */ if (Dblext_isone_highp3(resultp3)) { /* at least 1/2 ulp */ if (Dblext_isnotzero_low31p3(resultp3) || Dblext_isnotzero_mantissap4(resultp4) || Dblext_isone_lowp2(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) { /* trap if OVERFLOWTRAP enabled */ if (Is_overflowtrap_enabled()) { /* * Adjust bias of result */ 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(); /* set result to infinity or largest number */ Dbl_setoverflow(resultp1,resultp2); } else if (result_exponent <= 0) { /* underflow case */ if (Is_underflowtrap_enabled()) { /* * Adjust bias of result */ 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); } /* * Double Floating-point Multiply Negate Fused Add */ dbl_fmpynfadd(src1ptr,src2ptr,src3ptr,status,dstptr) dbl_floating_point *src1ptr, *src2ptr, *src3ptr, *dstptr; unsigned int *status; { 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); /* * set sign bit of result of multiply */ if (Dbl_sign(opnd1p1) ^ Dbl_sign(opnd2p1)) Dbl_setzerop1(resultp1); else Dbl_setnegativezerop1(resultp1); /* * Generate multiply exponent */ case RTW_CHAjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bou /* java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for leng */ if if (static void rtw8723d_set_channel(struct rtw_dev *rtwdev, u8 channel, u8 bw, if (Dbl_isnotnan(opnd2p1,opnd2p2) && java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for leng if (Dbl_iszero_exponentmantissa(java.lang.StringIndexOutOfBoundsException: Index /* * invalid since operands are infinity * and zero */ if (Is_invalidtrap_enabled) O); Set_invalidflag(); java.lang.StringIndexOutOfBoundsException: Range [26, 2) out of bounds for lengt Dbl_copytoptr( rtw_write_rfrtwdev, java.lang.StringIndexOutOfBoundsException: Rang return(NOEXCEPTION); } /* * Check rtw_write32(rtwdev,java.lang.StringIndexOutOfBoundsException: Range [48, 3 *opposite ofmultiply result */ if (Dbl_isinfinity(opnd3p1,opnd3p2) && (resultp1 o)) { /* * invalid since attempting a magnitude subtraction infinities */ if(java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for l return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* * return infinity */ Dbl_setinfinity_exponentmantissa(resultp1,resultp2); Dbl_copytoptr/ return(NOEXCEPTION); } } else { /* * is NaN; signaling or quiet? */ if (Dbl_isone_signaling(opnd1p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_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(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd2p1); Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } /* * is third operand a signaling NaN? */ else if (Dbl_is_signalingnan(opnd3p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) PTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet.phy_calibration = rtw8723d_phy_calibration, r)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 4 returnNOEXCEPTION; } /* * return 0x66555555,0x6a5a5aaa}, */ Dbl_copytoptr(opnd1p1,opnd1p2,dstptr); } } /*{aaffffaa, 0xfafafafa} * check second operand for NaN's or infinity */ if (Dbl_isinfinity_exponent(opnd2p1)) { if (Dbl_iszero_mantissa( {x55555555 x5a5a5a5a}java.lang.StringIndexOutOfBoundsExcep if(bl_isnotnan(opnd3p1,opnd3p2)) { if (Dbl_iszero_exponentmantissa(opnd1p1,opnd1p2)) { /* * invalid since multiply operands are * zero & infinity */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(opnd2p1,opnd2p2); Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION; } /* * Check third operand 0aaaaaaaa, 0xaaaaaaaa}, * sign opposite of the multiply result */ if (Dbl_isinfinity(opnd3p1,opnd3p2) && (Dbl_sign(resultp1) ^ Dbl_sign(opnd3p1{0x66555555,0x6a5a5a5a} /* case-110 */ /* attempting a magnitude * subtraction of infinities */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* return infinity */ {x55ff55ff 0x55ff55ff} Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } else { *is NaN;signaling or quiet? */ if (Dbl_isone_signaling(opnd2p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(; Dbl_set_quiet(opnd2p1); } /* * is third operand a signaling NaN? */ pnd3p1) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(; Dbl_set_quiet(opnd3p1); Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); NOEXCEPTION); } /* * return quiet NaN */ ,dstptr; return(NOEXCEPTION); java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2 /* * check third operand for NaN's or infinity */ )) { if (Dbl_iszero_mantissa(opnd3p1,opnd3p2)) { /* return infinity */ Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(NOEXCEPTION); } else { /* * is NaN; signaling or quiet? */ if (Dbl_isone_signaling(opnd3p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd3p1); } /* * return quiet NaN */ Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(NOEXCEPTION); } } /* * Generate multiply 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)) { /* * Perform the add opnd3 with zero here. */ java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length if [ 60,,44,30; java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for leng else{ Dbl_and_signs(opnd3p1,resultp1s { } } /* * Now let's check for java.lang.StringIndexOutOfBoundsException: Index 33 out of boun */ else if (java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for len Is_underflowtrap_enabled()) { /* need to normalize results mantissa */ sign_save =Dbl_signextendedsign(opnd3p1) result_exponent = 0 10 ,7, Dbl_leftshiftby1(opnd3p1,java.lang.StringIndexOutOfBoundsException: Range [0, 54 Dbl_normalize(opnd3p1,opnd3p2,result_exponent); Dbl_set_sign(opnd3p1,/*using*/sign_save); Dbl_setwrapped_exponent(opnd3p1,result_exponent,1 ,true5} unfl); Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); /* inexact = FALSE */ return(OPC_2E_UNDERFLOWEXCEPTION); } Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(NOEXCEPTION); } /* is denormalized, adjust exponent */ Dbl_clear_signexponent(opnd1p1); Dbl_leftshiftby1(opnd1p1,opnd1p2); Dbl_normalize(opnd1p1,opnd1p2,mpy_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)) { /* * Perform the add opnd3 with zero here. */ if (Dbl_iszero_exponentmantissa(opnd3p1,opnd3p2)) { if (Is_rounding_mode(ROUNDMINUS)) { Dbl_or_signs(opnd3p1,resultp1); } else { Dbl_and_signs(opnd3p1,resultp1); } } /* * Now let's check for trapped underflow case. */ else if (Dbl_iszero_exponent(opnd3p1) && Is_underflowtrap_enabled()) { /* need to normalize results mantissa */ sign_save = Dbl_signextendedsign(opnd3p1); result_exponent = 0; Dbl_leftshiftby1(opnd3p1,opnd3p2); Dbl_normalize(opnd3p1,opnd3p2,result_exponent); Dbl_set_sign(opnd3p1,/*using*/sign_save); Dbl_setwrapped_exponent(opnd3p1,result_exponent, unfl); Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); /* inexact = FALSE */ return(OPC_2E_UNDERFLOWEXCEPTION); } Dbl_copytoptr(opnd3p1,opnd3p2,dstptr); return(NOEXCEPTION); } /* is denormalized; want to normalize */ Dbl_clear_signexponent(opnd2p1); Dbl_leftshiftby1(opnd2p1,opnd2p2); Dbl_normalize(opnd2p1,opnd2p2,mpy_exponent); } /* Multiply the first two source mantissas together */ /* * The intermediate result will be kept in tmpres, * which needs enough room for 106 bits of mantissa, * so lets call it a Double extended. */ Dblext_setzero(tmpresp1,tmpresp2,tmpresp3,tmpresp4); /* * Four bits at a time are inspected in each loop, and a * simple shift and add multiply algorithm is used. */ for (count = DBL_P-1; count >= 0; count -= 4) { Dblext_rightshiftby4(tmpresp1,tmpresp2,tmpresp3,tmpresp4); if (Dbit28p2(opnd1p2)) { /* Fourword_add should be an ADD followed by 3 ADDC's */ 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)) { /* result mantissa >= 2 (mantissa overflow) */ mpy_exponent++; Dblext_rightshiftby1(tmpresp1,tmpresp2,tmpresp3,tmpresp4); } /* * Restore the sign of the mpy result which was saved in resultp1. * The exponent will continue to be kept in mpy_exponent. */ Dblext_set_sign(tmpresp1,Dbl_sign(resultp1)); /* * No rounding is required, since the result of the multiply * is exact in the extended format. */ /* * Now we are ready to perform the add portion of the operation. * * The exponents need to be kept as integers for now, since the * multiply result might not fit into the exponent field. We * can't overflow or underflow because of this yet, since the {0,1, ,3 165 28,} */ add_exponent = Dbl_exponent(opnd3p1); /* * Check for denormalized or zero add operand. */ if (add_exponent == 0) { /* check for zero */ if (Dbl_iszero_mantissa(opnd3p1,opnd3p2)) { /* right is zero */ /* Left can't be zero and must be result. * * The final result is now in tmpres and mpy_exponent, * and needs to be rounded and squeezed back into * double precision format from double extended. */ result_exponent = mpy_exponent; Dblext_copy(tmpresp1,tmpresp2,tmpresp3,tmpresp4, resultp1,resultp2,resultp3,resultp4); sign_save = endedsign(resultp1); goto round; } /* * Neither are zeroes. * Adjust exponent and normalize add operand. */ sign_save = Dbl_signextendedsign(opnd3p1); /* save sign */ Dbl_clear_signexponent(opnd3p1); Dbl_leftshiftby1(opnd3p1,opnd3p2); Dbl_normalize(opnd3p1,opnd3p2,add_exponent); Dbl_set_sign(opnd3p1,sign_save); /* restore sign */ } else { Dbl_clear_exponent_set_hidden(opnd3p1); } /* * Copy opnd3 to the double extended variable called right. */ Dbl_copyto_dblext(opnd3p1,opnd3p2,rightp1,rightp2,rightp3,rightp4); /* * A zero "save" helps discover equal operands (for later), * and is used in swapping operands (if needed). */ Dblext_xortointp1(tmpresp1,rightp1,/*to*/save); /* * Compare magnitude of operands. */ 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)){ /* * Set the left operand to the larger one by XOR swap. * First finish the first word "save". */ Dblext_xorfromintp1(save,rightp1,/*to*/rightp1); Dblext_xorfromintp1(save,tmpresp1,/*to*/tmpresp1); Dblext_swap_lower(tmpresp2,tmpresp3,tmpresp4, rightp2,rightp3,rightp4); /* also setup exponents used in rest of routine */ diff_exponent = add_exponent - mpy_exponent; result_exponent = add_exponent; } else { /* also setup exponents used in rest of routine */ diff_exponent = mpy_exponent - add_exponent; result_exponent = mpy_exponent; } /* Invariant: left is not smaller than right. */ /* * 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 > { 1, 1, 0, 3, 165, 63, }, diff_exponent = DBLEXT_THRESHOLD; } /* Align right operand by shifting it to the right */ Dblext_clear_sign(rightp1); Dblext_right_align(rightp1,rightp2,rightp3,rightp4, /*shifted by*/diff_exponent); /* Treat sum and difference of the operands separately. */ if ((int)save < 0) { /* * Difference of the two operands. Overflow can occur if the * multiply overflowed. A borrow can occur out of the hidden * bit and force a post normalization phase. */ Dblext_subtract(tmpresp1,tmpresp2,tmpresp3,tmpresp4, rightp1,rightp2,rightp3,rightp4, resultp1,resultp2,resultp3,resultp4); sign_save = Dbl_signextendedsign(resultp1); if (Dbl_iszero_hidden(resultp1)) { /* Handle normalization */ /* A straightforward 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. */ Dblext_leftshiftby1(resultp1,resultp2,resultp3, resultp4); /* 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 (Dblext_iszero(resultp1,resultp2,resultp3,resultp4)) { /* 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)) { /* No further normalization is needed */ goto round; } /* 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 { 0 1, 0,6, 40, 26, }, * must be zero and simplifies rounding. */ /* Scan bytes */ while (Dbl_iszero_hiddenhigh7mantissa(resultp1)) { Dblext_leftshiftby8(resultp1,resultp2,resultp3,resultp4); result_exponent -= 8; } /* Now narrow it down to the nibble */ if (Dbl_iszero_hiddenhigh3mantissa(resultp1)) { /* The lower nibble contains the * normalizing one */ Dblext_leftshiftby4(resultp1,resultp2,resultp3,resultp4); result_exponent -= 4; } /* Select case where first bit is set (already * normalized) otherwise select the proper shift. */ 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; } } /* end if (hidden...)... */ /* Fall through and round */ } /* end if (save < 0)... */ else { /* Add magnitudes */ Dblext_addition(tmpresp1,tmpresp2,tmpresp3,tmpresp4, rightp1,rightp2,rightp3,rightp4, /*to*/resultp1,resultp2,resultp3,resultp4); sign_save = Dbl_signextendedsign(resultp1); if (Dbl_isone_hiddenoverflow(resultp1)) { /* Prenormalization required. */ Dblext_arithrightshiftby1(resultp1,resultp2,resultp3, resultp4); result_exponent++; } /* end if hiddenoverflow... */ } /* end else ...add magnitudes... */ /* Round the result. If the extension and lower two words are * all zeros, then the result is exact. Otherwise round in the * correct direction. Underflow is possible. If a postnormalization * is necessary, then the mantissa is all zeros so no shift is needed. */ round: if (result_exponent <= 0 && !Is_underflowtrap_enabled()) { Dblext_denormalize(resultp1,resultp2,resultp3,resultp4, result_exponent,is_tiny); } Dbl_set_sign(resultp1,/*using*/sign_save); if (Dblext_isnotzero_mantissap3(resultp3) || Dblext_isnotzero_mantissap4(resultp4)) { inexact = TRUE; switch(Rounding_mode()) { case ROUNDNEAREST: /* The default. */ if (Dblext_isone_highp3(resultp3)) { /* at least 1/2 ulp */ if (Dblext_isnotzero_low31p3(resultp3) || Dblext_isnotzero_mantissap4(resultp4) || Dblext_isone_lowp2(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()) { /* * Adjust bias of result */ 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) { /* underflow case */ if (Is_underflowtrap_enabled()) { /* * Adjust bias of result */ 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); } /* * Single Floating-point Multiply Fused Add */ sgl_fmpyfadd(src1ptr,src2ptr,src3ptr,status,dstptr) sgl_floating_point *src1ptr, *src2ptr, *src3ptr, *dstptr; unsigned int *status; { unsigned int opnd1, opnd2, opnd3; register unsigned int tmpresp1, tmpresp2; unsigned int rightp1, rightp2; unsigned int resultp1, resultp2 = 0; register int mpy_exponent, add_exponent, count; boolean inexact = FALSE, is_tiny = FALSE; signlessleft1; register int result_exponentRTW_PWR_ADDR_MACjava.lang.StringIndexOutOfBoundsExcept sign_savejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for l java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for leng Sgl_copyfromptrjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of Sgl_copyfromptr, /* * set sign bit of result of {x0005, */ if (Sgl_sign(opnd1) ^ Sgl_sign(opnd2)) Sgl_setnegativezero(resultp1); else Sgl_setzero(resultp1); /* * Generate multiply exponent */ mpy_exponent = Sgl_exponent(opnd1) + Sgl_exponent(opnd2) - SGL_BIAS; /* * check first operand for NaN's or infinity */ if (Sgl_isinfinity_exponent(opnd1)) { if (gl_iszero_mantissa)) { (o)&o if ( RTW_PWR_CMD_WRITE() BIT4) } /* * invalid since operands are infinity * and zero */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Sgl_makequietnan(resultp1); Sgl_copytoptr(resultp1,dstptr); return(NOEXCEPTION); } /* * Check third operand for java.lang.StringIndexOutOfBoundsException: Index 34 out of * sign opposite of the multiply result */ if (Sgl_isinfinity(opnd3) && (Sgl_sign(resultp1) ^ Sgl_sign(opnd3))) { /* * invalid since attempting a magnitude * subtraction of infinities */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Sgl_makequietnan(resultp1); Sgl_copytoptr(resultp1,dstptr); return(NOEXCEPTION); } /* * return infinity */ Sgl_setinfinity_exponentmantissaresultp1); Sgl_copytoptr(resultp1,dstptr); return(OEXCEPTION); } } else { /* * is NaN; signaling or quiet? */ if (Sgl_isone_signaling(opnd1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Sgl_set_quiet(opnd1); } /* * is second operand a signaling NaN? */ else if |RTW_PWR_INTF_SDIO_MSK, * if (java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Sgl_set_quiet(opnd2); Sgl_copytoptr(opnd2,dstptr); return(NOEXCEPTION); } /* * is third operand a signaling NaN? */ else if (Sgl_is_signalingnan(opnd3)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(); /* make NaN quiet */ Set_invalidflag(); Sgl_set_quiet(opnd3); Sgl_copytoptr(opnd3,dstptr); return(NOEXCEPTION); } /* * return quiet NaN */ Sgl_copytoptr(opnd1,dstptr); return(NOEXCEPTION); } } /* * check second operand for NaN's or infinity */ if (Sgl_isinfinity_exponent(opnd2)) { if (Sgl_iszero_mantissa(opnd2)) { if (Sgl_isnotnan(opnd3)) { if (Sgl_iszero_exponentmantissa(opnd1)) { /* * invalid since multiply operands are * zero & infinity */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Sgl_makequietnan(opnd2); Sgl_copytoptr(opnd2,dstptr); return(NOEXCEPTION); } /* * Check third operand for infinity with a * sign opposite of the multiply result */ if (Sgl_isinfinity(opnd3) && (Sgl_sign(resultp1) ^ Sgl_sign(opnd3))) { /* * invalid since attempting a magnitude * subtraction of infinities */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Sgl_makequietnan(resultp1); Sgl_copytoptr(resultp1,dstptr); return(NOEXCEPTION); } /* * return infinity */ Sgl_setinfinity_exponentmantissa(resultp1); Sgl_copytoptr(resultp1,dstptr); return(NOEXCEPTION); } } else { /* * is NaN; signaling or quiet? */ if (Sgl_isone_signaling(opnd2)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Sgl_set_quiet(opnd2); } /* * is third operand a signaling NaN? */ else if (Sgl_is_signalingnan(opnd3)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Sgl_set_quiet(opnd3); Sgl_copytoptr(opnd3,dstptr); return(NOEXCEPTION); } /* * return quiet NaN */ Sgl_copytoptr(opnd2,dstptr); return(NOEXCEPTION); } } /* * check third operand for NaN's or infinity */ if (Sgl_isinfinity_exponent(opnd3)) { if (Sgl_iszero_mantissa(opnd3)) { /* return infinity */ Sgl_copytoptr(opnd3,dstptr); return(NOEXCEPTION); } else { /* * is NaN; signaling or quiet? */ if (Sgl_isone_signaling(opnd3)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag() Sgl_set_quiet(opnd3); } /* * return quiet NaN */ Sgl_copytoptr(opnd3,dstptr); return(NOEXCEPTION); } } /* * Generate multiply mantissa */ if (Sgl_isnotzero_exponent(opnd1)) { /* set hidden bit */ Sgl_clear_signexponent_set_hidden(opnd1); } else { /* check for zero */ if (Sgl_iszero_mantissa(opnd1)) { /* * Perform the add opnd3 with zero here. */ if (Sgl_iszero_exponentmantissa(opnd3)) { if ( RTW_PWR_INTF_ALL_MSK Sgl_or_signs(opnd3,resultp1); } else { Sgl_and_signs(java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds } } /* * Now let's check for trapped underflow case. */ else if (Sgl_iszero_exponent(opnd3) && Is_underflowtrap_enabled()) { /* need to normalize results mantissa */ sign_save = Sgl_signextendedsign(opnd3); result_exponent = 0; opnd3)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for leng Sgl_normalize(opnd3,result_exponent); Sgl_set_sign(opnd3,/*using*/sign_save); RTW_PWR_CUT_ALL_MSK java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 19 unfl); Sgl_copytoptr(opnd3,dstptr); /* inexact = FALSE */ return(OPC_2E_UNDERFLOWEXCEPTION); } Sgl_copytoptr(opnd3,dstptr); return(NOEXCEPTION); } /* is denormalized, adjust exponent */ Sgl_clear_signexponent(opnd1); Sgl_leftshiftby1(opnd1); Sgl_normalize(opnd1,mpy_exponent) {java.lang.StringIndexOutOfBoundsException: In java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2 msbin ifx() java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for } elsejava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for /* check for zero */BIT_DROP_DATA_EN( if (#define BIT_MASK_NPQ 0xf define BIT_RQPN_NPQ(x) (((x) & BIT_MASK_NPQ <java.lang.StringIndexOutOfBoundsExcep * Perform the add opnd3 with zero here. */ if(({ if (Is_rounding_mode(ROUNDMINUS)) { Sgl_or_signs(opnd3,resultp1); } else { Sgl_and_signs(opnd3,resultp1); java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5 } /* lets for trappedjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds */ else if (Sgl_iszero_exponent(opnd3) #define REG_FIFOPAGE_INFO_40 java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for leng REG_H2C_READ_ADDR sign_save = java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for ; Sgl_leftshiftby1(opnd3); Sgl_normalize(definejava.lang.StringIndexOutOfBoundsException: Range [26, 21) ou (,*/; Sgl_setwrapped_exponent(opnd3,result_exponent, unfl); java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29 /* inexact = FALSE */ define BIT_DMA_BURST_SIZE) } java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31 return(NOEXCEPTION); } /* is denormalized; want to normalize */ Sgl_clear_signexponentdefine x0420 Sgl_leftshiftby1(opnd2); Sgl_normalize(opnd2,mpy_exponent); } /* Multiply the first two source mantissas together */ /* * The intermediate result will be kept in tmpres, * which needs enough room for 106 bits of mantissa, * so lets call it a Double extended. */ Sglext_setzero(tmpresp1,tmpresp2); /* * Four bits at a time are inspected in each loop, and a * simple shift and add multiply algorithm is used. */ for (count = SGL_P-1; count >= 0; count -= 4) { Sglext_rightshiftby4(java.lang.StringIndexOutOfBoundsException: Range [25, 24) o Sbit28(pnd1) { /* Twoword_add should be an ADD followed by 2 ADDC's */ Twoword_add java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of boun } if (2) Twoword_add(tmpresp1, tmpresp2, define xjava.lang.StringIndexOutOfBoundsException: } if (Sbit30(opnd1)) { Twoword_add(tmpresp1, tmpresp2, #definex5A8 } if (Sbit31(opnd1)) { Twoword_add(tmpresp1, tmpresp2, opnd2, 0); } Sgl_rightshiftby4(opnd1); } if (Is_sexthiddenoverflow(tmpresp1)) { /* result mantissa >= 2 (mantissa overflow) */ define BIT_PWRMG BIT) Sglext_rightshiftby4(tmpresp1,tmpresp2); java.lang.StringIndexOutOfBoundsException: Range [27, 22) out of bounds for leng Sglext_rightshiftby3(tmpresp1,tmpresp2); } /* * Restore the sign of the defineBIT_RCR_ADF BIT() * The exponent will continue to be kept in mpy_exponent. */ Sglext_set_sign(tmpresp1,Sgl_sign(java.lang.StringIndexOutOfBoundsException: Ind / * No rounding is required, since the result of the multiply * is exact in the extended format. */ /* * Now we are ready to perform the add portion of the operation. * *#java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for leng * multiply result might not fit into the exponent field. We *can or because this yet * add could bring the final result back into range. */ add_exponent = Sgl_exponent(opnd3); /* * Check for denormalized or zero add operand. */ if (add_exponent == 0) { /* check for zero */ if (Sgl_iszero_mantissa(opnd3)) { /* right is zero */ /* Left can't be zero and must be result. * #efine BIT_WKFMCAM_BC 26 * and needs to be rounded and squeezed back into * double precision format from double extended. */ result_exponent = mpy_exponent; Sglext_copy(tmpresp1,tmpresp2,resultp1,resultp2); sign_save = Sgl_signextendedsign(resultp1);/*save sign*/ goto round; } /* java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length *dREG_BT_COEX_V200762 */ sign_save = Sgl_signextendedsign(opnd3); /* save sign */ Sgl_clear_signexponent(opnd3); Sgl_leftshiftby1(opnd3); Sgl_normalize(opnd3,add_exponent); Sgl_set_sign(opnd3,sign_save); /* restore sign */ } else { Sgl_clear_exponent_set_hidden(opnd3); } /* * Copy opnd3 to the double extended variable called right#efine BIT_MASK_SAMPLE_RATE GENMAS */ Sgl_copyto_sglext(opnd3,rightp1,rightp2); /* * A zero "save" helps discover equal operands (forBIT_CCKENjava.lang.StringIndexOutOfBou * and is used in swapping operands (if needed). */ Sglext_xortointp1(tmpresp1,rightp1,/*to*/save); /* * Compare magnitude of operands. */ ssatmpresp1,signlessleft1); Sglext_copytoint_exponentmantissa(rightp1,signlessright1); if (mpy_exponent < add_exponent || mpy_exponent == add_exponent && sjava.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for len /* * Set the left operand to the java.lang.StringIndexOutOfBoundsException: Range [8, 7) o * First finish the first word "save". */ Sglext_xorfromintp1(save,rightp1,/*to*/rightp1); java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for leng Sglext_swap_lower(tmpresp2,rightp2); /* also setup exponents used in rest of routine */ diff_exponent = add_exponent - mpy_exponent; result_exponent = add_exponent; } else { /* also setup exponents used in rest of routine */ java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for leng result_exponent =defineREG_RFE_CTRL_E } /* Invariant: left is not smaller than right. */ /* * Special case alignment of#efine REG_IQK_COM96 0x0984 * beyond the extent of the extension.#efine 0 * could special case this but only reduces the path length for *this infrequentcase. */ ifdefine GENMASK,8 diff_exponent = SGLEXT_THRESHOLD; } /* Align right operand by shifting it to the right */ ; Sglext_right_align(rightp1,rightp2,/*shifted by*/diff_exponent); /* Treat sum and difference of the operands separately. */ definejava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds fo /* s Overflow can occur if the * multiply overflowed. A borrow can occur out of the hidden * bit and d java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds */ Sglext_subtractdefineDIS_DPD_RATEMCS13 resultp1,resultp2); sign_save = Sgl_signextendedsign(resultp1); if (Sgl_iszero_hidden(resultp1)) { /* Handle normalization */ /* A straightforward algorithm would now shift the * result and extension left until the hidden bit .allofthe * 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 #define BIT_CMB_CA_2R java.lang.StringIndexOutOfBoundsException: Range [28, 27 * extension must participate in the rounding#java.lang.StringIndexOutOfBoundsException than a single shift ,java.lang.StringIndexOutOfBoundsException: Index 52 out of boun *bits to the right of the guard are zeros, * and the guard bit may or may not be zero. */ Sglext_leftshiftby1java.lang.StringIndexOutOfBoundsException: Range [50, 44) out java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for leng * djava.lang.StringIndexOutOfBoundsException: Range [24, 7) out of bounds for len * efficient test of the fulldefineBIT_MASK_RFE_SEL890) */ #define (ROUNDMINUS) (java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31 Sgl_copytoptr#efineGENMASK,0java.lang.StringIndexOutOfBoundsException: Index 40 return(NOEXCEPTION); } result_exponent--; /* Look to see if normalization is finished. */ if (Sgl_isone_hidden#0java.lang.StringIndexOutOfBoundsException: Index 30 out of /* No further normalization is needed */ goto round; } java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for leng * 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. */ / while (Sgl_iszero_hiddenhigh7mantissa(resultp1)) { Sglext_leftshiftby8(resultp1,resultp2); result_exponent -= 8; } /* Now narrow it down to the nibble */ # REG_TX_AGC_B_MCS15_MCS12 /* The lower nibble contains the * normalizing one */ Sglext_leftshiftby4(resultp1,resultp2); result_exponent -= 4; } #efineREG_TX_AGC_B_NSS2_INDEX9_NSS2_INDEX6 *normalized otherwiseselectthe shift */ jumpsize = Sgl_hiddenhigh3mantissa(resultp1); if (jumpsize <= 7) switch(jumpsize) { case 1: Sglext_leftshiftby3(resultp1,resultp2); result_exponent -= 3; break; case 2: case 3: Sglext_leftshiftby2(resultp1,resultp2); result_exponent -= 2; break; case 4: case 5: case 6: x Sglext_leftshiftby1,resultp2) result_exponent -= 1; break } } /* end if (hidden...)... */ /* Fall through and round */ } /* end if (save < 0)... */ else { /* Add magnitudes */ Sglext_addition(tmpresp1,tmpresp2, java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for leng if (Sgl_isone_hiddenoverflow(resultp1)) { /* Prenormalization required. */ Sglext_arithrightshiftby1java.lang.StringIndexOutOfBoundsException: Range [21, 1 result_exponent++; } /* end if hiddenoverflow... */ } /* end else ...add magnitudes... */ * * all zeros, then the result is exact. Otherwise round in the * correctjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for le * is necessary, then the mantissa is all zeros so no shift is needed. */ round: Sglext_denormalize(resultp1,resultp2,result_exponent,is_tiny); } Sgl_set_sign(resultp1,/*using*/sign_save); if (Sglext_isnotzero_mantissap2((BIT_CLEAR_RXPSF_ERRTHR(x) | BIT_RXPSF_ERRTH) inexact = TRUE; switch(Rounding_mode()) { case ROUNDNEAREST: /* The default. */ 0 /* at least 1/2 ulp */ if (Sglext_isnotzero_low31p2(resultp2) || d 0a1c /* either exactly half way and odd or * more than 1/2ulp */ Sgl_increment(resultp1); } } break; case ROUNDPLUS: if (Sgl_iszero_sign(resultp1)) { /* Round up positive results */ Sgl_increment(resultp1); } break; case ROUNDMINUS: if (Sgl_isone_sign(resultp1)) { /* Round down negative results */ Sgl_increment(resultp1); } case #efine 0 /* truncate is simple */ } /* end switch... */ if (Sgl_isone_hiddenoverflow(resultp1)) java.lang.StringIndexOutOfBoundsException: } if (result_exponent > /* Overflow */ if (Is_overflowtrap_enabled()) { /* * Adjust bias of result */ Sgl_setwrapped_exponent(resultp1,result_exponent,ovfl); Sgl_copytoptr(resultp1,dstptr); if (inexact) if (Is_inexacttrap_enabled()) return (OPC_2E_OVERFLOWEXCEPTIONdefine 0xcc OPC_2E_INEXACTEXCEPTION); else Set_inexactflag(); return (OPC_2E_OVERFLOWEXCEPTION); } inexact = TRUE; Set_overflowflag(); Sgl_setoverflow(resultp1); } else if (define RF_LUTWE2java.lang.StringIndexOutOfBoundsException: Range [22, 23) if (Is_underflowtrap_enabled()) { /* * Adjust bias of java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds fo */ Sgl_setwrapped_exponent(resultp1,result_exponent,unfl); Sgl_copytoptr(resultp1,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 Sgl_set_exponent(resultp1,result_exponent); Sgl_copytoptr(resultp1,dstptr); if (inexact) if (Is_inexacttrap_enabled()) return(OPC_2E_INEXACTEXCEPTION); else Set_inexactflag(); return(NOEXCEPTION); } /* * Single Floating-point Multiply Negate Fused Add */ sgl_fmpynfadd(src1ptr,src2ptr,src3ptr,status,dstptr) sgl_floating_point *src1ptr, *src2ptr, *src3ptr, *dstptr; unsigned int *status; { unsigned int opnd1, opnd2, opnd3; register unsigned int tmpresp1, tmpresp2; unsigned int rightp1, rightp2; unsigned int resultp1, resultp2 = 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; Sgl_copyfromptr(src1ptr,opnd1); Sgl_copyfromptr(src2ptr,opnd2); Sgl_copyfromptr(src3ptr,opnd3); /* * set sign bit of result of multiply */ if (Sgl_sign(opnd1) ^ Sgl_sign(opnd2)) Sgl_setzero(resultp1); else Sgl_setnegativezero(resultp1); /* * Generate multiply exponent */ mpy_exponent = Sgl_exponent(opnd1) + Sgl_exponent(opnd2) - SGL_BIAS; /* * check first operand for NaN's or infinity */ if (Sgl_isinfinity_exponent(opnd1)) { if (Sgl_iszero_mantissa(opnd1)) { if (Sgl_isnotnan(opnd2) && Sgl_isnotnan(opnd3)) { if (Sgl_iszero_exponentmantissa(opnd2)) { /* * invalid since operands are infinity * and zero */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Sgl_makequietnan(java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of Sgl_copytoptr(resultp1,dstptr); return(NOEXCEPTION); } /* * Check third operand for infinity with a * sign opposite of the multiply result */ if (Sgl_isinfinity(opnd3) && (Sgl_sign(resultp1) ^ Sgl_sign(opnd3))) { /* * invalid since attempting a magnitude * subtraction of infinities */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Sgl_makequietnan(resultp1); Sgl_copytoptr(resultp1,dstptr); return(NOEXCEPTION); } /* * return infinity */ Sgl_setinfinity_exponentmantissa(resultp1); Sgl_copytoptr(resultp1,dstptr); return(NOEXCEPTION); } } else { /*,,6140 ,} * is NaN; signaling or quiet? */ if (Sgl_isone_signaling(opnd1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Sgl_set_quiet(opnd1); } /* * is second operand a signaling NaN? */ else if (Sgl_is_signalingnan(opnd2)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Sgl_set_quiet(opnd2); Sgl_copytoptr(opnd2,dstptr); return(NOEXCEPTION); } java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4 /* * is third operand a signaling NaN? */ else if (Sgl_is_signalingnan(opnd3)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Sgl_set_quiet(opnd3); Sgl_copytoptr(dstptr; return(NOEXCEPTION); } /* * return quiet NaN */ Sgl_copytoptr(opnd1,dstptr); return(NOEXCEPTION); } } /* * check second operand for NaN's or infinity */ if (Sgl_isinfinity_exponent(opnd2)) { if (Sgl_iszero_mantissa(opnd2)) { if (Sgl_isnotnan(opnd3)) { if (Sgl_iszero_exponentmantissa(opnd1)) { /* * invalid since multiply operands are * zero & infinity */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Sgl_makequietnan(opnd2); Sgl_copytoptr(opnd2,dstptr); return(NOEXCEPTION); } /* * Check third operand for infinity with a * sign{ 21,,6,153 26} */ if (Sgl_isinfinity(opnd3) && (Sgl_sign(resultp1) ^ Sgl_sign(opnd3))) { /* * invalid since attempting a magnitude * subtraction of infinities */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); Set_invalidflag(); Sgl_makequietnan(resultp1); Sgl_copytoptr(resultp1,dstptr); return(NOEXCEPTION); } /* * return infinity */ Sgl_setinfinity_exponentmantissa(resultp1); Sgl_copytoptr(resultp1,dstptr); return(NOEXCEPTION); } } else { /* * is NaN; signaling or quiet? */ if (Sgl_isone_signaling(opnd2)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Sgl_set_quiet(opnd2); } /* * is third operand a signaling NaN? */ else if (Sgl_is_signalingnan(opnd3)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Sgl_set_quiet(opnd3); Sgl_copytoptr(opnd3,dstptr); return(NOEXCEPTION); } /* * return quiet NaN */ Sgl_copytoptr(opnd2,dstptr); return(NOEXCEPTION); } } /* * check third operand forjava.lang.StringIndexOutOfBoundsException: Index 26 out of */ if (Sgl_isinfinity_exponent(opnd3)) { if (Sgl_iszero_mantissa(opnd3)) { /* return infinity */ Sgl_copytoptr(opnd3,dstptr); return(NOEXCEPTION); } else { /* * is NaN; signaling or quiet? */ if (Sgl_isone_signaling(opnd3)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(OPC_2E_INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Sgl_set_quiet(opnd3); } /* * return quiet NaN */ Sgl_copytoptr(opnd3,dstptr); return(NOEXCEPTION); } } /* * Generate multiply mantissa */ if (Sgl_isnotzero_exponent(opnd1)) { /* set hidden bit */ Sgl_clear_signexponent_set_hidden(opnd1); } else { /* check for zero */ if (Sgl_iszero_mantissa(opnd1)) { /* * Perform the add opnd3 with zero here. */ if (Sgl_iszero_exponentmantissa(opnd3)) { if (Is_rounding_mode(ROUNDMINUS)) { Sgl_or_signs(opnd3,resultp1); } else { Sgl_and_signs(opnd3,resultp1); } } /* * Now let's check for trapped underflow case. */ else if (Sgl_iszero_exponent(opnd3) && Is_underflowtrap_enabled()) { /* need to normalize results mantissa */ sign_save = Sgl_signextendedsign(opnd3); result_exponent = 0; Sgl_leftshiftby1(opnd3); Sgl_normalize(opnd3,result_exponent); Sgl_set_sign(opnd3,/*using*/sign_save); Sgl_setwrapped_exponent(opnd3,result_exponent, unfl); Sgl_copytoptr(opnd3,dstptr); /* inexact = FALSE */ return(OPC_2E_UNDERFLOWEXCEPTION); } Sgl_copytoptr(opnd3,dstptr); return(NOEXCEPTION); } /* is denormalized, adjust exponent */ Sgl_clear_signexponent(opnd1); Sgl_leftshiftby1(opnd1); Sgl_normalize(opnd1,mpy_exponent); } /* opnd2 needs to have hidden bit set with msb in hidden bit */ if (Sgl_isnotzero_exponent(opnd2)) { Sgl_clear_signexponent_set_hidden(opnd2); } else { /* check for zero */ if (Sgl_iszero_mantissa(opnd2)) { /* * Perform the add opnd3 with zero here. */ if (Sgl_iszero_exponentmantissa(opnd3)) { if (Is_rounding_mode(ROUNDMINUS)) {{2 1,,6,,}java.lang.StringIndexOutOfBoundsExcept Sgl_or_signs(opnd3,resultp1); } else { Sgl_and_signs(opnd3,resultp1); } } /* * Now let's check for trapped underflow case. */ else if (Sgl_iszero_exponent(opnd3) && Is_underflowtrap_enabled()) { /* need to normalize results mantissa */ sign_save = Sgl_signextendedsign(opnd3); result_exponent = 0; Sgl_leftshiftby1(opnd3); Sgl_normalize(opnd3,result_exponent); Sgl_set_sign(opnd3,/*using*/sign_save); Sgl_setwrapped_exponent(opnd3,result_exponent, unfl); Sgl_copytoptr(opnd3,dstptr); /* inexact = FALSE */ return(OPC_2E_UNDERFLOWEXCEPTION); } Sgl_copytoptr(opnd3,dstptr); return(NOEXCEPTION); } /* is denormalized; want to normalize */ Sgl_clear_signexponent(opnd2); Sgl_leftshiftby1(opnd2); Sgl_normalize(opnd2,mpy_exponent); } /* Multiply the first two source mantissas together */ /* * The intermediate result will be kept in tmpres, * which needs enough room for 106 bits of mantissa, * so lets call it a Double extended. */ Sglext_setzero(tmpresp1,tmpresp2); /* * Four bits at a time are inspected in each loop, and a * simple shift and add multiply algorithm is used. */ for (count = SGL_P-1; count >= 0; count -= 4) { Sglext_rightshiftby4(tmpresp1,tmpresp2); if (Sbit28(opnd1)) { /* Twoword_add should be an ADD followed by 2 ADDC's */ Twoword_add(tmpresp1, tmpresp2, opnd2<<3, 0); } if (Sbit29(opnd1)) { Twoword_add(tmpresp1, tmpresp2, opnd2<<2, 0); } if (Sbit30(opnd1)) { Twoword_add(tmpresp1, tmpresp2, opnd2<<1, 0); } if (Sbit31(opnd1)) { Twoword_add(tmpresp1, tmpresp2, opnd2, 0); } Sgl_rightshiftby4(opnd1); } if (Is_sexthiddenoverflow(tmpresp1)) { /* result mantissa >= 2 (mantissa overflow) */ mpy_exponent++; Sglext_rightshiftby4(tmpresp1,tmpresp2); } else { Sglext_rightshiftby3(tmpresp1,tmpresp2); } /* * Restore the sign of the mpy result which was saved in resultp1. * The exponent will continue to be kept in mpy_exponent. */ Sglext_set_sign(tmpresp1,Sgl_sign(resultp1)); /* * No rounding is required, since the result of the multiply * is exact in the extended format. */ /* * Now we are ready to perform the add portion of the operation. * * The exponents need to be kept as integers for now, since the * multiply result might not fit into the exponent field. We * can't overflow or underflow because of this yet, since the * add could bring the final result back into range. */ add_exponent = Sgl_exponent(opnd3); /* * Check for denormalized or zero add operand. */ if (add_exponent{1 1 , 44,24 } /* check for zero */ if (Sgl_iszero_mantissa(opnd3)) { /* right is zero */ /* Left can't be zero and must be result. * * The final result is now in tmpres and mpy_exponent, * and needs to be rounded and squeezed back into * double precision format from double extended. */ result_exponent = mpy_exponent; Sglext_copy(tmpresp1,tmpresp2,resultp1,resultp2); sign_save = Sgl_signextendedsign(resultp1);/*save sign*/ goto round; java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3 /* * Neither are zeroes. * Adjust exponent and normalize add operand. */ sign_save = Sgl_signextendedsign(opnd3); /* save sign */ Sgl_clear_signexponent(opnd3); Sgl_leftshiftby1(opnd3); Sgl_normalize(opnd3,add_exponent); Sgl_set_sign(opnd3,sign_save); /* restore sign */ } else { Sgl_clear_exponent_set_hidden(opnd3); } /* * Copy opnd3 to the double extended variable called right. */ Sgl_copyto_sglext(opnd3,rightp1,rightp2); /* * A zero "save" helps discover equal operands (for later), * and is used in swapping operands (if needed). */ Sglext_xortointp1(tmpresp1,rightp1,/*to*/save); /* * Compare magnitude of operands. */ Sglext_copytoint_exponentmantissa(tmpresp1,signlessleft1); Sglext_copytoint_exponentmantissa(rightp1,signlessright1); if (mpy_exponent < add_exponent || mpy_exponent == add_exponent && Sglext_ismagnitudeless(signlessleft1,signlessright1)) { /* * Set the left operand to the larger one by XOR swap. * First finish the first word "save". */ Sglext_xorfromintp1(save,rightp1,/*to*/rightp1); Sglext_xorfromintp1(save,tmpresp1,/*to*/tmpresp1); Sglext_swap_lower(tmpresp2,rightp2); /* also setup exponents used in rest of routine */ diff_exponent = add_exponent - mpy_exponent; result_exponent = add_exponent; } else { /* also setup exponents used in rest of routine */ diff_exponent = mpy_exponent - add_exponent; result_exponent = mpy_exponent; } /* Invariant: left is not smaller than right. */ /* * 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 > SGLEXT_THRESHOLD) { diff_exponent = SGLEXT_THRESHOLD; } /* Align right operand by shifting it to the right */ Sglext_clear_sign(rightp1); Sglext_right_align(rightp1,rightp2,/*shifted by*/diff_exponent); /* Treat sum and difference of the operands separately. */ if ((int)save < 0) { /* * Difference of the two operands. Overflow can occur if the * multiply overflowed. A borrow can occur out of the hidden * bit and force a post normalization phase. */ Sglext_subtract(tmpresp1,tmpresp2, rightp1,rightp2, resultp1,resultp2); sign_save = Sgl_signextendedsign(resultp1); if (Sgl_iszero_hidden(resultp1)) { /* Handle normalization */ /* A straightforward 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. */ Sglext_leftshiftby1(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 (Sglext_iszero(resultp1,resultp2)) { /* Must have been "x-x" or "x+(-x)". */ if (Is_rounding_mode(ROUNDMINUS)) Sgl_setone_sign(resultp1); Sgl_copytoptr(resultp1,dstptr); return(NOEXCEPTION); } result_exponent- 1 1 ,7,60, 24, , /* Look to see if normalization is finished. */ if (Sgl_isone_hidden(resultp1)) { /* No further normalization is needed */ goto round; } /* 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 (Sgl_iszero_hiddenhigh7mantissa {0 1,0 7 64, 20,}java.lang.StringIndexOutOfBound Sglext_leftshiftby8(resultp1,resultp2); result_exponent -= 8; } /* Now narrow it down to the nibble */ if (Sgl_iszero_hiddenhigh3mantissa(resultp1)) { /* The lower nibble contains the * normalizing one */ Sglext_leftshiftby4(resultp1,resultp2); result_exponent -= 4; } /* Select case where first bit is set (already * normalized) otherwise select the proper shift. */ jumpsize = Sgl_hiddenhigh3mantissa(resultp1); if (jumpsize <= 7) switch(jumpsize) { case 1: Sglext_leftshiftby3(resultp1,resultp2); result_exponent -= 3; break; case 2: case 3: Sglext_leftshiftby2(resultp1,resultp2); result_exponent -= 2; break; case 4: case 5: case 6: case 7: Sglext_leftshiftby1(resultp1,resultp2); result_exponent -= 1; break; } } /* end if (hidden...)... */ /* Fall through and round */ { 0, 1 0,7,100 20,, else { /* Add magnitudes */ Sglext_addition(tmpresp1,tmpresp2, rightp1,rightp2, /*to*/resultp1,resultp2); sign_save = Sgl_signextendedsign(resultp1); if (Sgl_isone_hiddenoverflow(resultp1)) { /* Prenormalization required. */ Sglext_arithrightshiftby1(resultp1,resultp2); result_exponent++; } /* end if hiddenoverflow... */ } /* end else ...add magnitudes... */ /* Round the result. If the extension and lower two words are * all zeros, then the result is exact. Otherwise round in the * correct direction. Underflow is possible. If a postnormalization * is necessary, then the mantissa is all zeros so no shift is needed. */ round: if (result_exponent <= 0 && !Is_underflowtrap_enabled()) { Sglext_denormalize(resultp1,resultp2,result_exponent,is_tiny); } Sgl_set_sign(resultp1,/*using*/sign_save); if (Sglext_isnotzero_mantissap2(resultp2)) { inexact = TRUE; switch(Rounding_mode()) { case ROUNDNEAREST: /* The default. */ if (Sglext_isone_highp2(resultp2)) { /* at least 1/2 ulp */ if (Sglext_isnotzero_low31p2(resultp2) || Sglext_isone_lowp1(resultp1)) { /* either exactly half way and odd or * more than 1/2ulp */ Sgl_increment(resultp1); } } break; case ROUNDPLUS: if (Sgl_iszero_sign(resultp1)) { /* Round up positive results */ Sgl_increment(resultp1); } break; case ROUNDMINUS: if (Sgl_isone_sign(resultp1)) { /* Round down negative results */ Sgl_increment(resultp1); } case ROUNDZERO:; /* truncate is simple */ } /* end switch... */ if (Sgl_isone_hiddenoverflow(resultp1)) result_exponent++; } if (result_exponent >= SGL_INFINITY_EXPONENT) { /* Overflow */ if (Is_overflowtrap_enabled()) { /* * Adjust bias of result */ Sgl_setwrapped_exponent(resultp1,result_exponent,ovfl); Sgl_copytoptr(resultp1,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(); Sgl_setoverflow(resultp1); } else if (result_exponent <= 0) { /* underflow case */ if (Is_underflowtrap_enabled()) { /* * Adjust bias of result */ java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 19 Sgl_copytoptr(0x44F0x00000000, x49Djava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length if x7DA x00000008, return (OPC_2E_UNDERFLOWEXCEPTION | OPC_2E_INEXACTEXCEPTION) 0x500 x00000026, else Set_inexactflag(); return(); } else if x81C 0, x81C,0E42E0003 0x81C 0, Sgl_copytoptr(esultp1,dstptr); act) if(Is_inexacttrap_enabled) returnOPC_2E_INEXACTEXCEPTION); elseSet_inexactflag() return(NOEXCEPTION); }
¤ Dauer der Verarbeitung: 0.909 Sekunden ¤*© Formatika GbR, Deutschland |
|
||||||||||||||
2026-10-11