arch/parisc/math-emu/fcnvfx.c

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