1/* 2 * Linux/PA-RISC Project (http://www.parisc-linux.org/) 3 * 4 * Floating-point emulation code 5 * Copyright (C) 2001 Hewlett-Packard (Paul Bame) <bame@debian.org> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2, or (at your option) 10 * any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21/* 22 * BEGIN_DESC 23 * 24 * File: 25 * @(#) pa/spmath/sfdiv.c $Revision: 1.1 $ 26 * 27 * Purpose: 28 * Single Precision Floating-point Divide 29 * 30 * External Interfaces: 31 * sgl_fdiv(srcptr1,srcptr2,dstptr,status) 32 * 33 * Internal Interfaces: 34 * 35 * Theory: 36 * <<please update with a overview of the operation of this file>> 37 * 38 * END_DESC 39*/ 40 41 42#include "float.h" 43#include "sgl_float.h" 44 45/* 46 * Single Precision Floating-point Divide 47 */ 48 49int 50sgl_fdiv (sgl_floating_point * srcptr1, sgl_floating_point * srcptr2, 51 sgl_floating_point * dstptr, unsigned int *status) 52{ 53 register unsigned int opnd1, opnd2, opnd3, result; 54 register int dest_exponent, count; 55 register boolean inexact = FALSE, guardbit = FALSE, stickybit = FALSE; 56 boolean is_tiny; 57 58 opnd1 = *srcptr1; 59 opnd2 = *srcptr2; 60 /* 61 * set sign bit of result 62 */ 63 if (Sgl_sign(opnd1) ^ Sgl_sign(opnd2)) Sgl_setnegativezero(result); 64 else Sgl_setzero(result); 65 /* 66 * check first operand for NaN's or infinity 67 */ 68 if (Sgl_isinfinity_exponent(opnd1)) { 69 if (Sgl_iszero_mantissa(opnd1)) { 70 if (Sgl_isnotnan(opnd2)) { 71 if (Sgl_isinfinity(opnd2)) { 72 /* 73 * invalid since both operands 74 * are infinity 75 */ 76 if (Is_invalidtrap_enabled()) 77 return(INVALIDEXCEPTION); 78 Set_invalidflag(); 79 Sgl_makequietnan(result); 80 *dstptr = result; 81 return(NOEXCEPTION); 82 } 83 /* 84 * return infinity 85 */ 86 Sgl_setinfinity_exponentmantissa(result); 87 *dstptr = result; 88 return(NOEXCEPTION); 89 } 90 } 91 else { 92 /* 93 * is NaN; signaling or quiet? 94 */ 95 if (Sgl_isone_signaling(opnd1)) { 96 /* trap if INVALIDTRAP enabled */ 97 if (Is_invalidtrap_enabled()) 98 return(INVALIDEXCEPTION); 99 /* make NaN quiet */ 100 Set_invalidflag(); 101 Sgl_set_quiet(opnd1); 102 } 103 /* 104 * is second operand a signaling NaN? 105 */ 106 else if (Sgl_is_signalingnan(opnd2)) { 107 /* trap if INVALIDTRAP enabled */ 108 if (Is_invalidtrap_enabled()) 109 return(INVALIDEXCEPTION); 110 /* make NaN quiet */ 111 Set_invalidflag(); 112 Sgl_set_quiet(opnd2); 113 *dstptr = opnd2; 114 return(NOEXCEPTION); 115 } 116 /* 117 * return quiet NaN 118 */ 119 *dstptr = opnd1; 120 return(NOEXCEPTION); 121 } 122 } 123 /* 124 * check second operand for NaN's or infinity 125 */ 126 if (Sgl_isinfinity_exponent(opnd2)) { 127 if (Sgl_iszero_mantissa(opnd2)) { 128 /* 129 * return zero 130 */ 131 Sgl_setzero_exponentmantissa(result); 132 *dstptr = result; 133 return(NOEXCEPTION); 134 } 135 /* 136 * is NaN; signaling or quiet? 137 */ 138 if (Sgl_isone_signaling(opnd2)) { 139 /* trap if INVALIDTRAP enabled */ 140 if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); 141 /* make NaN quiet */ 142 Set_invalidflag(); 143 Sgl_set_quiet(opnd2); 144 } 145 /* 146 * return quiet NaN 147 */ 148 *dstptr = opnd2; 149 return(NOEXCEPTION); 150 } 151 /* 152 * check for division by zero 153 */ 154 if (Sgl_iszero_exponentmantissa(opnd2)) { 155 if (Sgl_iszero_exponentmantissa(opnd1)) { 156 /* invalid since both operands are zero */ 157 if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); 158 Set_invalidflag(); 159 Sgl_makequietnan(result); 160 *dstptr = result; 161 return(NOEXCEPTION); 162 } 163 if (Is_divisionbyzerotrap_enabled()) 164 return(DIVISIONBYZEROEXCEPTION); 165 Set_divisionbyzeroflag(); 166 Sgl_setinfinity_exponentmantissa(result); 167 *dstptr = result; 168 return(NOEXCEPTION); 169 } 170 /* 171 * Generate exponent 172 */ 173 dest_exponent = Sgl_exponent(opnd1) - Sgl_exponent(opnd2) + SGL_BIAS; 174 175 /* 176 * Generate mantissa 177 */ 178 if (Sgl_isnotzero_exponent(opnd1)) { 179 /* set hidden bit */ 180 Sgl_clear_signexponent_set_hidden(opnd1); 181 } 182 else { 183 /* check for zero */ 184 if (Sgl_iszero_mantissa(opnd1)) { 185 Sgl_setzero_exponentmantissa(result); 186 *dstptr = result; 187 return(NOEXCEPTION); 188 } 189 /* is denormalized; want to normalize */ 190 Sgl_clear_signexponent(opnd1); 191 Sgl_leftshiftby1(opnd1); 192 Sgl_normalize(opnd1,dest_exponent); 193 } 194 /* opnd2 needs to have hidden bit set with msb in hidden bit */ 195 if (Sgl_isnotzero_exponent(opnd2)) { 196 Sgl_clear_signexponent_set_hidden(opnd2); 197 } 198 else { 199 /* is denormalized; want to normalize */ 200 Sgl_clear_signexponent(opnd2); 201 Sgl_leftshiftby1(opnd2); 202 while(Sgl_iszero_hiddenhigh7mantissa(opnd2)) { 203 Sgl_leftshiftby8(opnd2); 204 dest_exponent += 8; 205 } 206 if(Sgl_iszero_hiddenhigh3mantissa(opnd2)) { 207 Sgl_leftshiftby4(opnd2); 208 dest_exponent += 4; 209 } 210 while(Sgl_iszero_hidden(opnd2)) { 211 Sgl_leftshiftby1(opnd2); 212 dest_exponent += 1; 213 } 214 } 215 216 /* Divide the source mantissas */ 217 218 /* 219 * A non_restoring divide algorithm is used. 220 */ 221 Sgl_subtract(opnd1,opnd2,opnd1); 222 Sgl_setzero(opnd3); 223 for (count=1;count<=SGL_P && Sgl_all(opnd1);count++) { 224 Sgl_leftshiftby1(opnd1); 225 Sgl_leftshiftby1(opnd3); 226 if (Sgl_iszero_sign(opnd1)) { 227 Sgl_setone_lowmantissa(opnd3); 228 Sgl_subtract(opnd1,opnd2,opnd1); 229 } 230 else Sgl_addition(opnd1,opnd2,opnd1); 231 } 232 if (count <= SGL_P) { 233 Sgl_leftshiftby1(opnd3); 234 Sgl_setone_lowmantissa(opnd3); 235 Sgl_leftshift(opnd3,SGL_P-count); 236 if (Sgl_iszero_hidden(opnd3)) { 237 Sgl_leftshiftby1(opnd3); 238 dest_exponent--; 239 } 240 } 241 else { 242 if (Sgl_iszero_hidden(opnd3)) { 243 /* need to get one more bit of result */ 244 Sgl_leftshiftby1(opnd1); 245 Sgl_leftshiftby1(opnd3); 246 if (Sgl_iszero_sign(opnd1)) { 247 Sgl_setone_lowmantissa(opnd3); 248 Sgl_subtract(opnd1,opnd2,opnd1); 249 } 250 else Sgl_addition(opnd1,opnd2,opnd1); 251 dest_exponent--; 252 } 253 if (Sgl_iszero_sign(opnd1)) guardbit = TRUE; 254 stickybit = Sgl_all(opnd1); 255 } 256 inexact = guardbit | stickybit; 257 258 /* 259 * round result 260 */ 261 if (inexact && (dest_exponent > 0 || Is_underflowtrap_enabled())) { 262 Sgl_clear_signexponent(opnd3); 263 switch (Rounding_mode()) { 264 case ROUNDPLUS: 265 if (Sgl_iszero_sign(result)) 266 Sgl_increment_mantissa(opnd3); 267 break; 268 case ROUNDMINUS: 269 if (Sgl_isone_sign(result)) 270 Sgl_increment_mantissa(opnd3); 271 break; 272 case ROUNDNEAREST: 273 if (guardbit) { 274 if (stickybit || Sgl_isone_lowmantissa(opnd3)) 275 Sgl_increment_mantissa(opnd3); 276 } 277 } 278 if (Sgl_isone_hidden(opnd3)) dest_exponent++; 279 } 280 Sgl_set_mantissa(result,opnd3); 281 282 /* 283 * Test for overflow 284 */ 285 if (dest_exponent >= SGL_INFINITY_EXPONENT) { 286 /* trap if OVERFLOWTRAP enabled */ 287 if (Is_overflowtrap_enabled()) { 288 /* 289 * Adjust bias of result 290 */ 291 Sgl_setwrapped_exponent(result,dest_exponent,ovfl); 292 *dstptr = result; 293 if (inexact) 294 if (Is_inexacttrap_enabled()) 295 return(OVERFLOWEXCEPTION | INEXACTEXCEPTION); 296 else Set_inexactflag(); 297 return(OVERFLOWEXCEPTION); 298 } 299 Set_overflowflag(); 300 /* set result to infinity or largest number */ 301 Sgl_setoverflow(result); 302 inexact = TRUE; 303 } 304 /* 305 * Test for underflow 306 */ 307 else if (dest_exponent <= 0) { 308 /* trap if UNDERFLOWTRAP enabled */ 309 if (Is_underflowtrap_enabled()) { 310 /* 311 * Adjust bias of result 312 */ 313 Sgl_setwrapped_exponent(result,dest_exponent,unfl); 314 *dstptr = result; 315 if (inexact) 316 if (Is_inexacttrap_enabled()) 317 return(UNDERFLOWEXCEPTION | INEXACTEXCEPTION); 318 else Set_inexactflag(); 319 return(UNDERFLOWEXCEPTION); 320 } 321 322 /* Determine if should set underflow flag */ 323 is_tiny = TRUE; 324 if (dest_exponent == 0 && inexact) { 325 switch (Rounding_mode()) { 326 case ROUNDPLUS: 327 if (Sgl_iszero_sign(result)) { 328 Sgl_increment(opnd3); 329 if (Sgl_isone_hiddenoverflow(opnd3)) 330 is_tiny = FALSE; 331 Sgl_decrement(opnd3); 332 } 333 break; 334 case ROUNDMINUS: 335 if (Sgl_isone_sign(result)) { 336 Sgl_increment(opnd3); 337 if (Sgl_isone_hiddenoverflow(opnd3)) 338 is_tiny = FALSE; 339 Sgl_decrement(opnd3); 340 } 341 break; 342 case ROUNDNEAREST: 343 if (guardbit && (stickybit || 344 Sgl_isone_lowmantissa(opnd3))) { 345 Sgl_increment(opnd3); 346 if (Sgl_isone_hiddenoverflow(opnd3)) 347 is_tiny = FALSE; 348 Sgl_decrement(opnd3); 349 } 350 break; 351 } 352 } 353 354 /* 355 * denormalize result or set to signed zero 356 */ 357 stickybit = inexact; 358 Sgl_denormalize(opnd3,dest_exponent,guardbit,stickybit,inexact); 359 360 /* return rounded number */ 361 if (inexact) { 362 switch (Rounding_mode()) { 363 case ROUNDPLUS: 364 if (Sgl_iszero_sign(result)) { 365 Sgl_increment(opnd3); 366 } 367 break; 368 case ROUNDMINUS: 369 if (Sgl_isone_sign(result)) { 370 Sgl_increment(opnd3); 371 } 372 break; 373 case ROUNDNEAREST: 374 if (guardbit && (stickybit || 375 Sgl_isone_lowmantissa(opnd3))) { 376 Sgl_increment(opnd3); 377 } 378 break; 379 } 380 if (is_tiny) Set_underflowflag(); 381 } 382 Sgl_set_exponentmantissa(result,opnd3); 383 } 384 else Sgl_set_exponent(result,dest_exponent); 385 *dstptr = result; 386 /* check for inexact */ 387 if (inexact) { 388 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION); 389 else Set_inexactflag(); 390 } 391 return(NOEXCEPTION); 392} 393