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/fcnvfu.c $Revision: 1.1 $ 13 * 14 * Purpose: 15 * Floating-point to Unsigned Fixed-point Converts 16 * 17 * External Interfaces: 18 * dbl_to_dbl_fcnvfu(srcptr,_nullptr,dstptr,status) 19 * dbl_to_sgl_fcnvfu(srcptr,_nullptr,dstptr,status) 20 * sgl_to_dbl_fcnvfu(srcptr,_nullptr,dstptr,status) 21 * sgl_to_sgl_fcnvfu(srcptr,_nullptr,dstptr,status) 22 * 23 * Internal Interfaces: 24 * 25 * Theory: 26 * <<please update with a overview of the operation of this file>> 27 * 28 * END_DESC 29 */ 30 31 32 #include "float.h" 33 #include "sgl_float.h" 34 #include "dbl_float.h" 35 #include "cnv_float.h" 36 37 /************************************************************************ 38 * Floating-point to Unsigned Fixed-point Converts * 39 ************************************************************************/ 40 41 /* 42 * Single Floating-point to Single Unsigned Fixed 43 */ 44 /*ARGSUSED*/ 45 int 46 sgl_to_sgl_fcnvfu( 47 sgl_floating_point *srcptr, 48 unsigned int *_nullptr, 49 unsigned int *dstptr, 50 unsigned int *status) 51 { 52 register unsigned int src, result; 53 register int src_exponent; 54 register boolean inexact = FALSE; 55 56 src = *srcptr; 57 src_exponent = Sgl_exponent(src) - SGL_BIAS; 58 59 /* 60 * Test for overflow 61 */ 62 if (src_exponent > SGL_FX_MAX_EXP + 1) { 63 if (Sgl_isone_sign(src)) { 64 result = 0; 65 } else { 66 result = 0xffffffff; 67 } 68 if (Is_invalidtrap_enabled()) { 69 return(INVALIDEXCEPTION); 70 } 71 Set_invalidflag(); 72 *dstptr = result; 73 return(NOEXCEPTION); 74 } 75 /* 76 * Generate result 77 */ 78 if (src_exponent >= 0) { 79 /* 80 * Check sign. 81 * If negative, trap unimplemented. 82 */ 83 if (Sgl_isone_sign(src)) { 84 result = 0; 85 if (Is_invalidtrap_enabled()) { 86 return(INVALIDEXCEPTION); 87 } 88 Set_invalidflag(); 89 *dstptr = result; 90 return(NOEXCEPTION); 91 } 92 Sgl_clear_signexponent_set_hidden(src); 93 Suint_from_sgl_mantissa(src,src_exponent,result); 94 95 /* check for inexact */ 96 if (Sgl_isinexact_to_unsigned(src,src_exponent)) { 97 inexact = TRUE; 98 /* round result */ 99 switch (Rounding_mode()) { 100 case ROUNDPLUS: 101 result++; 102 break; 103 case ROUNDMINUS: /* never negative */ 104 break; 105 case ROUNDNEAREST: 106 if (Sgl_isone_roundbit(src,src_exponent) && 107 (Sgl_isone_stickybit(src,src_exponent) || 108 (result & 1))) { 109 result++; 110 } 111 break; 112 } 113 } 114 } else { 115 result = 0; 116 117 /* check for inexact */ 118 if (Sgl_isnotzero_exponentmantissa(src)) { 119 inexact = TRUE; 120 /* round result */ 121 switch (Rounding_mode()) { 122 case ROUNDPLUS: 123 if (Sgl_iszero_sign(src)) { 124 result++; 125 } 126 break; 127 case ROUNDMINUS: 128 if (Sgl_isone_sign(src)) { 129 result = 0; 130 if (Is_invalidtrap_enabled()) { 131 return(INVALIDEXCEPTION); 132 } 133 Set_invalidflag(); 134 inexact = FALSE; 135 } 136 break; 137 case ROUNDNEAREST: 138 if (src_exponent == -1 && 139 Sgl_isnotzero_mantissa(src)) { 140 if (Sgl_isone_sign(src)) { 141 result = 0; 142 if (Is_invalidtrap_enabled()) { 143 return(INVALIDEXCEPTION); 144 } 145 Set_invalidflag(); 146 inexact = FALSE; 147 } 148 else result++; 149 } 150 break; 151 } 152 } 153 } 154 *dstptr = result; 155 if (inexact) { 156 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION); 157 else Set_inexactflag(); 158 } 159 return(NOEXCEPTION); 160 } 161 162 /* 163 * Single Floating-point to Double Unsigned Fixed 164 */ 165 /*ARGSUSED*/ 166 int 167 sgl_to_dbl_fcnvfu( 168 sgl_floating_point *srcptr, 169 unsigned int *_nullptr, 170 dbl_unsigned *dstptr, 171 unsigned int *status) 172 { 173 register int src_exponent; 174 register unsigned int src, resultp1, resultp2; 175 register boolean inexact = FALSE; 176 177 src = *srcptr; 178 src_exponent = Sgl_exponent(src) - SGL_BIAS; 179 180 /* 181 * Test for overflow 182 */ 183 if (src_exponent > DBL_FX_MAX_EXP + 1) { 184 if (Sgl_isone_sign(src)) { 185 resultp1 = resultp2 = 0; 186 } else { 187 resultp1 = resultp2 = 0xffffffff; 188 } 189 if (Is_invalidtrap_enabled()) { 190 return(INVALIDEXCEPTION); 191 } 192 Set_invalidflag(); 193 Duint_copytoptr(resultp1,resultp2,dstptr); 194 return(NOEXCEPTION); 195 } 196 /* 197 * Generate result 198 */ 199 if (src_exponent >= 0) { 200 /* 201 * Check sign. 202 * If negative, trap unimplemented. 203 */ 204 if (Sgl_isone_sign(src)) { 205 resultp1 = resultp2 = 0; 206 if (Is_invalidtrap_enabled()) { 207 return(INVALIDEXCEPTION); 208 } 209 Set_invalidflag(); 210 Duint_copytoptr(resultp1,resultp2,dstptr); 211 return(NOEXCEPTION); 212 } 213 Sgl_clear_signexponent_set_hidden(src); 214 Duint_from_sgl_mantissa(src,src_exponent,resultp1,resultp2); 215 216 /* check for inexact */ 217 if (Sgl_isinexact_to_unsigned(src,src_exponent)) { 218 inexact = TRUE; 219 /* round result */ 220 switch (Rounding_mode()) { 221 case ROUNDPLUS: 222 Duint_increment(resultp1,resultp2); 223 break; 224 case ROUNDMINUS: /* never negative */ 225 break; 226 case ROUNDNEAREST: 227 if (Sgl_isone_roundbit(src,src_exponent) && 228 (Sgl_isone_stickybit(src,src_exponent) || 229 Duint_isone_lowp2(resultp2))) { 230 Duint_increment(resultp1,resultp2); 231 } 232 break; 233 } 234 } 235 } else { 236 Duint_setzero(resultp1,resultp2); 237 238 /* check for inexact */ 239 if (Sgl_isnotzero_exponentmantissa(src)) { 240 inexact = TRUE; 241 /* round result */ 242 switch (Rounding_mode()) { 243 case ROUNDPLUS: 244 if (Sgl_iszero_sign(src)) { 245 Duint_increment(resultp1,resultp2); 246 } 247 break; 248 case ROUNDMINUS: 249 if (Sgl_isone_sign(src)) { 250 resultp1 = resultp2 = 0; 251 if (Is_invalidtrap_enabled()) { 252 return(INVALIDEXCEPTION); 253 } 254 Set_invalidflag(); 255 inexact = FALSE; 256 } 257 break; 258 case ROUNDNEAREST: 259 if (src_exponent == -1 && 260 Sgl_isnotzero_mantissa(src)) { 261 if (Sgl_isone_sign(src)) { 262 resultp1 = 0; 263 resultp2 = 0; 264 if (Is_invalidtrap_enabled()) { 265 return(INVALIDEXCEPTION); 266 } 267 Set_invalidflag(); 268 inexact = FALSE; 269 } 270 else Duint_increment(resultp1,resultp2); 271 } 272 } 273 } 274 } 275 Duint_copytoptr(resultp1,resultp2,dstptr); 276 if (inexact) { 277 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION); 278 else Set_inexactflag(); 279 } 280 return(NOEXCEPTION); 281 } 282 283 /* 284 * Double Floating-point to Single Unsigned Fixed 285 */ 286 /*ARGSUSED*/ 287 int 288 dbl_to_sgl_fcnvfu (dbl_floating_point * srcptr, unsigned int *_nullptr, 289 unsigned int *dstptr, unsigned int *status) 290 { 291 register unsigned int srcp1, srcp2, result; 292 register int src_exponent; 293 register boolean inexact = FALSE; 294 295 Dbl_copyfromptr(srcptr,srcp1,srcp2); 296 src_exponent = Dbl_exponent(srcp1) - DBL_BIAS; 297 298 /* 299 * Test for overflow 300 */ 301 if (src_exponent > SGL_FX_MAX_EXP + 1) { 302 if (Dbl_isone_sign(srcp1)) { 303 result = 0; 304 } else { 305 result = 0xffffffff; 306 } 307 if (Is_invalidtrap_enabled()) { 308 return(INVALIDEXCEPTION); 309 } 310 Set_invalidflag(); 311 *dstptr = result; 312 return(NOEXCEPTION); 313 } 314 /* 315 * Generate result 316 */ 317 if (src_exponent >= 0) { 318 /* 319 * Check sign. 320 * If negative, trap unimplemented. 321 */ 322 if (Dbl_isone_sign(srcp1)) { 323 result = 0; 324 if (Is_invalidtrap_enabled()) { 325 return(INVALIDEXCEPTION); 326 } 327 Set_invalidflag(); 328 *dstptr = result; 329 return(NOEXCEPTION); 330 } 331 Dbl_clear_signexponent_set_hidden(srcp1); 332 Suint_from_dbl_mantissa(srcp1,srcp2,src_exponent,result); 333 334 /* check for inexact */ 335 if (Dbl_isinexact_to_unsigned(srcp1,srcp2,src_exponent)) { 336 inexact = TRUE; 337 /* round result */ 338 switch (Rounding_mode()) { 339 case ROUNDPLUS: 340 result++; 341 break; 342 case ROUNDMINUS: /* never negative */ 343 break; 344 case ROUNDNEAREST: 345 if(Dbl_isone_roundbit(srcp1,srcp2,src_exponent) && 346 (Dbl_isone_stickybit(srcp1,srcp2,src_exponent)|| 347 result&1)) 348 result++; 349 break; 350 } 351 /* check for overflow */ 352 if (result == 0) { 353 result = 0xffffffff; 354 if (Is_invalidtrap_enabled()) { 355 return(INVALIDEXCEPTION); 356 } 357 Set_invalidflag(); 358 *dstptr = result; 359 return(NOEXCEPTION); 360 } 361 } 362 } else { 363 result = 0; 364 365 /* check for inexact */ 366 if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) { 367 inexact = TRUE; 368 /* round result */ 369 switch (Rounding_mode()) { 370 case ROUNDPLUS: 371 if (Dbl_iszero_sign(srcp1)) result++; 372 break; 373 case ROUNDMINUS: 374 if (Dbl_isone_sign(srcp1)) { 375 result = 0; 376 if (Is_invalidtrap_enabled()) { 377 return(INVALIDEXCEPTION); 378 } 379 Set_invalidflag(); 380 inexact = FALSE; 381 } 382 break; 383 case ROUNDNEAREST: 384 if (src_exponent == -1 && 385 Dbl_isnotzero_mantissa(srcp1,srcp2)) 386 if (Dbl_isone_sign(srcp1)) { 387 result = 0; 388 if (Is_invalidtrap_enabled()) { 389 return(INVALIDEXCEPTION); 390 } 391 Set_invalidflag(); 392 inexact = FALSE; 393 } 394 else result++; 395 } 396 } 397 } 398 *dstptr = result; 399 if (inexact) { 400 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION); 401 else Set_inexactflag(); 402 } 403 return(NOEXCEPTION); 404 } 405 406 /* 407 * Double Floating-point to Double Unsigned Fixed 408 */ 409 /*ARGSUSED*/ 410 int 411 dbl_to_dbl_fcnvfu (dbl_floating_point * srcptr, unsigned int *_nullptr, 412 dbl_unsigned * dstptr, unsigned int *status) 413 { 414 register int src_exponent; 415 register unsigned int srcp1, srcp2, resultp1, resultp2; 416 register boolean inexact = FALSE; 417 418 Dbl_copyfromptr(srcptr,srcp1,srcp2); 419 src_exponent = Dbl_exponent(srcp1) - DBL_BIAS; 420 421 /* 422 * Test for overflow 423 */ 424 if (src_exponent > DBL_FX_MAX_EXP + 1) { 425 if (Dbl_isone_sign(srcp1)) { 426 resultp1 = resultp2 = 0; 427 } else { 428 resultp1 = resultp2 = 0xffffffff; 429 } 430 if (Is_invalidtrap_enabled()) { 431 return(INVALIDEXCEPTION); 432 } 433 Set_invalidflag(); 434 Duint_copytoptr(resultp1,resultp2,dstptr); 435 return(NOEXCEPTION); 436 } 437 438 /* 439 * Generate result 440 */ 441 if (src_exponent >= 0) { 442 /* 443 * Check sign. 444 * If negative, trap unimplemented. 445 */ 446 if (Dbl_isone_sign(srcp1)) { 447 resultp1 = resultp2 = 0; 448 if (Is_invalidtrap_enabled()) { 449 return(INVALIDEXCEPTION); 450 } 451 Set_invalidflag(); 452 Duint_copytoptr(resultp1,resultp2,dstptr); 453 return(NOEXCEPTION); 454 } 455 Dbl_clear_signexponent_set_hidden(srcp1); 456 Duint_from_dbl_mantissa(srcp1,srcp2,src_exponent,resultp1, 457 resultp2); 458 459 /* check for inexact */ 460 if (Dbl_isinexact_to_unsigned(srcp1,srcp2,src_exponent)) { 461 inexact = TRUE; 462 /* round result */ 463 switch (Rounding_mode()) { 464 case ROUNDPLUS: 465 Duint_increment(resultp1,resultp2); 466 break; 467 case ROUNDMINUS: /* never negative */ 468 break; 469 case ROUNDNEAREST: 470 if(Dbl_isone_roundbit(srcp1,srcp2,src_exponent)) 471 if(Dbl_isone_stickybit(srcp1,srcp2,src_exponent) || 472 Duint_isone_lowp2(resultp2)) 473 Duint_increment(resultp1,resultp2); 474 } 475 } 476 } else { 477 Duint_setzero(resultp1,resultp2); 478 479 /* check for inexact */ 480 if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) { 481 inexact = TRUE; 482 /* round result */ 483 switch (Rounding_mode()) { 484 case ROUNDPLUS: 485 if (Dbl_iszero_sign(srcp1)) { 486 Duint_increment(resultp1,resultp2); 487 } 488 break; 489 case ROUNDMINUS: 490 if (Dbl_isone_sign(srcp1)) { 491 resultp1 = resultp2 = 0; 492 if (Is_invalidtrap_enabled()) { 493 return(INVALIDEXCEPTION); 494 } 495 Set_invalidflag(); 496 inexact = FALSE; 497 } 498 break; 499 case ROUNDNEAREST: 500 if (src_exponent == -1 && 501 Dbl_isnotzero_mantissa(srcp1,srcp2)) 502 if (Dbl_iszero_sign(srcp1)) { 503 Duint_increment(resultp1,resultp2); 504 } else { 505 resultp1 = 0; 506 resultp2 = 0; 507 if (Is_invalidtrap_enabled()) { 508 return(INVALIDEXCEPTION); 509 } 510 Set_invalidflag(); 511 inexact = FALSE; 512 } 513 } 514 } 515 } 516 Duint_copytoptr(resultp1,resultp2,dstptr); 517 if (inexact) { 518 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION); 519 else Set_inexactflag(); 520 } 521 return(NOEXCEPTION); 522 } 523 524