git.oblomov.eu Git - linux-2.6/blob - arch/parisc/math-emu/fcnvfx.c

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