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