1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Linux/PA-RISC Project (http://www.parisc-linux.org/) 4 * 5 * Floating-point emulation code 6 * Copyright (C) 2001 Hewlett-Packard (Paul Bame) <bame@debian.org> 7 */ 8 /* 9 * BEGIN_DESC 10 * 11 * File: 12 * @(#) pa/spmath/dfdiv.c $Revision: 1.1 $ 13 * 14 * Purpose: 15 * Double Precision Floating-point Divide 16 * 17 * External Interfaces: 18 * dbl_fdiv(srcptr1,srcptr2,dstptr,status) 19 * 20 * Internal Interfaces: 21 * 22 * Theory: 23 * <<please update with a overview of the operation of this file>> 24 * 25 * END_DESC 26 */ 27 28 29 #include "float.h" 30 #include "dbl_float.h" 31 32 /* 33 * Double Precision Floating-point Divide 34 */ 35 36 int 37 dbl_fdiv (dbl_floating_point * srcptr1, dbl_floating_point * srcptr2, 38 dbl_floating_point * dstptr, unsigned int *status) 39 { 40 register unsigned int opnd1p1, opnd1p2, opnd2p1, opnd2p2; 41 register unsigned int opnd3p1, opnd3p2, resultp1, resultp2; 42 register int dest_exponent, count; 43 register boolean inexact = FALSE, guardbit = FALSE, stickybit = FALSE; 44 boolean is_tiny; 45 46 Dbl_copyfromptr(srcptr1,opnd1p1,opnd1p2); 47 Dbl_copyfromptr(srcptr2,opnd2p1,opnd2p2); 48 /* 49 * set sign bit of result 50 */ 51 if (Dbl_sign(opnd1p1) ^ Dbl_sign(opnd2p1)) 52 Dbl_setnegativezerop1(resultp1); 53 else Dbl_setzerop1(resultp1); 54 /* 55 * check first operand for NaN's or infinity 56 */ 57 if (Dbl_isinfinity_exponent(opnd1p1)) { 58 if (Dbl_iszero_mantissa(opnd1p1,opnd1p2)) { 59 if (Dbl_isnotnan(opnd2p1,opnd2p2)) { 60 if (Dbl_isinfinity(opnd2p1,opnd2p2)) { 61 /* 62 * invalid since both operands 63 * are infinity 64 */ 65 if (Is_invalidtrap_enabled()) 66 return(INVALIDEXCEPTION); 67 Set_invalidflag(); 68 Dbl_makequietnan(resultp1,resultp2); 69 Dbl_copytoptr(resultp1,resultp2,dstptr); 70 return(NOEXCEPTION); 71 } 72 /* 73 * return infinity 74 */ 75 Dbl_setinfinity_exponentmantissa(resultp1,resultp2); 76 Dbl_copytoptr(resultp1,resultp2,dstptr); 77 return(NOEXCEPTION); 78 } 79 } 80 else { 81 /* 82 * is NaN; signaling or quiet? 83 */ 84 if (Dbl_isone_signaling(opnd1p1)) { 85 /* trap if INVALIDTRAP enabled */ 86 if (Is_invalidtrap_enabled()) 87 return(INVALIDEXCEPTION); 88 /* make NaN quiet */ 89 Set_invalidflag(); 90 Dbl_set_quiet(opnd1p1); 91 } 92 /* 93 * is second operand a signaling NaN? 94 */ 95 else if (Dbl_is_signalingnan(opnd2p1)) { 96 /* trap if INVALIDTRAP enabled */ 97 if (Is_invalidtrap_enabled()) 98 return(INVALIDEXCEPTION); 99 /* make NaN quiet */ 100 Set_invalidflag(); 101 Dbl_set_quiet(opnd2p1); 102 Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); 103 return(NOEXCEPTION); 104 } 105 /* 106 * return quiet NaN 107 */ 108 Dbl_copytoptr(opnd1p1,opnd1p2,dstptr); 109 return(NOEXCEPTION); 110 } 111 } 112 /* 113 * check second operand for NaN's or infinity 114 */ 115 if (Dbl_isinfinity_exponent(opnd2p1)) { 116 if (Dbl_iszero_mantissa(opnd2p1,opnd2p2)) { 117 /* 118 * return zero 119 */ 120 Dbl_setzero_exponentmantissa(resultp1,resultp2); 121 Dbl_copytoptr(resultp1,resultp2,dstptr); 122 return(NOEXCEPTION); 123 } 124 /* 125 * is NaN; signaling or quiet? 126 */ 127 if (Dbl_isone_signaling(opnd2p1)) { 128 /* trap if INVALIDTRAP enabled */ 129 if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); 130 /* make NaN quiet */ 131 Set_invalidflag(); 132 Dbl_set_quiet(opnd2p1); 133 } 134 /* 135 * return quiet NaN 136 */ 137 Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); 138 return(NOEXCEPTION); 139 } 140 /* 141 * check for division by zero 142 */ 143 if (Dbl_iszero_exponentmantissa(opnd2p1,opnd2p2)) { 144 if (Dbl_iszero_exponentmantissa(opnd1p1,opnd1p2)) { 145 /* invalid since both operands are zero */ 146 if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); 147 Set_invalidflag(); 148 Dbl_makequietnan(resultp1,resultp2); 149 Dbl_copytoptr(resultp1,resultp2,dstptr); 150 return(NOEXCEPTION); 151 } 152 if (Is_divisionbyzerotrap_enabled()) 153 return(DIVISIONBYZEROEXCEPTION); 154 Set_divisionbyzeroflag(); 155 Dbl_setinfinity_exponentmantissa(resultp1,resultp2); 156 Dbl_copytoptr(resultp1,resultp2,dstptr); 157 return(NOEXCEPTION); 158 } 159 /* 160 * Generate exponent 161 */ 162 dest_exponent = Dbl_exponent(opnd1p1) - Dbl_exponent(opnd2p1) + DBL_BIAS; 163 164 /* 165 * Generate mantissa 166 */ 167 if (Dbl_isnotzero_exponent(opnd1p1)) { 168 /* set hidden bit */ 169 Dbl_clear_signexponent_set_hidden(opnd1p1); 170 } 171 else { 172 /* check for zero */ 173 if (Dbl_iszero_mantissa(opnd1p1,opnd1p2)) { 174 Dbl_setzero_exponentmantissa(resultp1,resultp2); 175 Dbl_copytoptr(resultp1,resultp2,dstptr); 176 return(NOEXCEPTION); 177 } 178 /* is denormalized, want to normalize */ 179 Dbl_clear_signexponent(opnd1p1); 180 Dbl_leftshiftby1(opnd1p1,opnd1p2); 181 Dbl_normalize(opnd1p1,opnd1p2,dest_exponent); 182 } 183 /* opnd2 needs to have hidden bit set with msb in hidden bit */ 184 if (Dbl_isnotzero_exponent(opnd2p1)) { 185 Dbl_clear_signexponent_set_hidden(opnd2p1); 186 } 187 else { 188 /* is denormalized; want to normalize */ 189 Dbl_clear_signexponent(opnd2p1); 190 Dbl_leftshiftby1(opnd2p1,opnd2p2); 191 while (Dbl_iszero_hiddenhigh7mantissa(opnd2p1)) { 192 dest_exponent+=8; 193 Dbl_leftshiftby8(opnd2p1,opnd2p2); 194 } 195 if (Dbl_iszero_hiddenhigh3mantissa(opnd2p1)) { 196 dest_exponent+=4; 197 Dbl_leftshiftby4(opnd2p1,opnd2p2); 198 } 199 while (Dbl_iszero_hidden(opnd2p1)) { 200 dest_exponent++; 201 Dbl_leftshiftby1(opnd2p1,opnd2p2); 202 } 203 } 204 205 /* Divide the source mantissas */ 206 207 /* 208 * A non-restoring divide algorithm is used. 209 */ 210 Twoword_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2); 211 Dbl_setzero(opnd3p1,opnd3p2); 212 for (count=1; count <= DBL_P && (opnd1p1 || opnd1p2); count++) { 213 Dbl_leftshiftby1(opnd1p1,opnd1p2); 214 Dbl_leftshiftby1(opnd3p1,opnd3p2); 215 if (Dbl_iszero_sign(opnd1p1)) { 216 Dbl_setone_lowmantissap2(opnd3p2); 217 Twoword_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2); 218 } 219 else { 220 Twoword_add(opnd1p1, opnd1p2, opnd2p1, opnd2p2); 221 } 222 } 223 if (count <= DBL_P) { 224 Dbl_leftshiftby1(opnd3p1,opnd3p2); 225 Dbl_setone_lowmantissap2(opnd3p2); 226 Dbl_leftshift(opnd3p1,opnd3p2,(DBL_P-count)); 227 if (Dbl_iszero_hidden(opnd3p1)) { 228 Dbl_leftshiftby1(opnd3p1,opnd3p2); 229 dest_exponent--; 230 } 231 } 232 else { 233 if (Dbl_iszero_hidden(opnd3p1)) { 234 /* need to get one more bit of result */ 235 Dbl_leftshiftby1(opnd1p1,opnd1p2); 236 Dbl_leftshiftby1(opnd3p1,opnd3p2); 237 if (Dbl_iszero_sign(opnd1p1)) { 238 Dbl_setone_lowmantissap2(opnd3p2); 239 Twoword_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2); 240 } 241 else { 242 Twoword_add(opnd1p1,opnd1p2,opnd2p1,opnd2p2); 243 } 244 dest_exponent--; 245 } 246 if (Dbl_iszero_sign(opnd1p1)) guardbit = TRUE; 247 stickybit = Dbl_allp1(opnd1p1) || Dbl_allp2(opnd1p2); 248 } 249 inexact = guardbit | stickybit; 250 251 /* 252 * round result 253 */ 254 if (inexact && (dest_exponent > 0 || Is_underflowtrap_enabled())) { 255 Dbl_clear_signexponent(opnd3p1); 256 switch (Rounding_mode()) { 257 case ROUNDPLUS: 258 if (Dbl_iszero_sign(resultp1)) 259 Dbl_increment(opnd3p1,opnd3p2); 260 break; 261 case ROUNDMINUS: 262 if (Dbl_isone_sign(resultp1)) 263 Dbl_increment(opnd3p1,opnd3p2); 264 break; 265 case ROUNDNEAREST: 266 if (guardbit && (stickybit || 267 Dbl_isone_lowmantissap2(opnd3p2))) { 268 Dbl_increment(opnd3p1,opnd3p2); 269 } 270 } 271 if (Dbl_isone_hidden(opnd3p1)) dest_exponent++; 272 } 273 Dbl_set_mantissa(resultp1,resultp2,opnd3p1,opnd3p2); 274 275 /* 276 * Test for overflow 277 */ 278 if (dest_exponent >= DBL_INFINITY_EXPONENT) { 279 /* trap if OVERFLOWTRAP enabled */ 280 if (Is_overflowtrap_enabled()) { 281 /* 282 * Adjust bias of result 283 */ 284 Dbl_setwrapped_exponent(resultp1,dest_exponent,ovfl); 285 Dbl_copytoptr(resultp1,resultp2,dstptr); 286 if (inexact) 287 if (Is_inexacttrap_enabled()) 288 return(OVERFLOWEXCEPTION | INEXACTEXCEPTION); 289 else Set_inexactflag(); 290 return(OVERFLOWEXCEPTION); 291 } 292 Set_overflowflag(); 293 /* set result to infinity or largest number */ 294 Dbl_setoverflow(resultp1,resultp2); 295 inexact = TRUE; 296 } 297 /* 298 * Test for underflow 299 */ 300 else if (dest_exponent <= 0) { 301 /* trap if UNDERFLOWTRAP enabled */ 302 if (Is_underflowtrap_enabled()) { 303 /* 304 * Adjust bias of result 305 */ 306 Dbl_setwrapped_exponent(resultp1,dest_exponent,unfl); 307 Dbl_copytoptr(resultp1,resultp2,dstptr); 308 if (inexact) 309 if (Is_inexacttrap_enabled()) 310 return(UNDERFLOWEXCEPTION | INEXACTEXCEPTION); 311 else Set_inexactflag(); 312 return(UNDERFLOWEXCEPTION); 313 } 314 315 /* Determine if should set underflow flag */ 316 is_tiny = TRUE; 317 if (dest_exponent == 0 && inexact) { 318 switch (Rounding_mode()) { 319 case ROUNDPLUS: 320 if (Dbl_iszero_sign(resultp1)) { 321 Dbl_increment(opnd3p1,opnd3p2); 322 if (Dbl_isone_hiddenoverflow(opnd3p1)) 323 is_tiny = FALSE; 324 Dbl_decrement(opnd3p1,opnd3p2); 325 } 326 break; 327 case ROUNDMINUS: 328 if (Dbl_isone_sign(resultp1)) { 329 Dbl_increment(opnd3p1,opnd3p2); 330 if (Dbl_isone_hiddenoverflow(opnd3p1)) 331 is_tiny = FALSE; 332 Dbl_decrement(opnd3p1,opnd3p2); 333 } 334 break; 335 case ROUNDNEAREST: 336 if (guardbit && (stickybit || 337 Dbl_isone_lowmantissap2(opnd3p2))) { 338 Dbl_increment(opnd3p1,opnd3p2); 339 if (Dbl_isone_hiddenoverflow(opnd3p1)) 340 is_tiny = FALSE; 341 Dbl_decrement(opnd3p1,opnd3p2); 342 } 343 break; 344 } 345 } 346 347 /* 348 * denormalize result or set to signed zero 349 */ 350 stickybit = inexact; 351 Dbl_denormalize(opnd3p1,opnd3p2,dest_exponent,guardbit, 352 stickybit,inexact); 353 354 /* return rounded number */ 355 if (inexact) { 356 switch (Rounding_mode()) { 357 case ROUNDPLUS: 358 if (Dbl_iszero_sign(resultp1)) { 359 Dbl_increment(opnd3p1,opnd3p2); 360 } 361 break; 362 case ROUNDMINUS: 363 if (Dbl_isone_sign(resultp1)) { 364 Dbl_increment(opnd3p1,opnd3p2); 365 } 366 break; 367 case ROUNDNEAREST: 368 if (guardbit && (stickybit || 369 Dbl_isone_lowmantissap2(opnd3p2))) { 370 Dbl_increment(opnd3p1,opnd3p2); 371 } 372 break; 373 } 374 if (is_tiny) Set_underflowflag(); 375 } 376 Dbl_set_exponentmantissa(resultp1,resultp2,opnd3p1,opnd3p2); 377 } 378 else Dbl_set_exponent(resultp1,dest_exponent); 379 Dbl_copytoptr(resultp1,resultp2,dstptr); 380 381 /* check for inexact */ 382 if (inexact) { 383 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION); 384 else Set_inexactflag(); 385 } 386 return(NOEXCEPTION); 387 } 388