arch/parisc/math-emu/fcnvfut.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/fcnvfut.c             $Revision: 1.1 $
  26  *
  27  *  Purpose:
  28  *      Floating-point to Unsigned Fixed-point Converts with Truncation
  29  *
  30  *  External Interfaces:
  31  *      dbl_to_dbl_fcnvfut(srcptr,nullptr,dstptr,status)
  32  *      dbl_to_sgl_fcnvfut(srcptr,nullptr,dstptr,status)
  33  *      sgl_to_dbl_fcnvfut(srcptr,nullptr,dstptr,status)
  34  *      sgl_to_sgl_fcnvfut(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 with Truncation     *
  52  ************************************************************************/
  53
  54 /*
  55  *  Convert single floating-point to single fixed-point format
  56  *  with truncated result
  57  */
  58 /*ARGSUSED*/
  59 int
  60 sgl_to_sgl_fcnvfut (sgl_floating_point * srcptr, unsigned int *nullptr,
  61                     unsigned int *dstptr, unsigned int *status)
  62 {
  63         register unsigned int src, result;
  64         register int src_exponent;
  65
  66         src = *srcptr;
  67         src_exponent = Sgl_exponent(src) - SGL_BIAS;
  68
  69         /*
  70          * Test for overflow
  71          */
  72         if (src_exponent > SGL_FX_MAX_EXP + 1) {
  73                 if (Sgl_isone_sign(src)) {
  74                         result = 0;
  75                 } else {
  76                         result = 0xffffffff;
  77                 }
  78                 if (Is_invalidtrap_enabled()) {
  79                         return(INVALIDEXCEPTION);
  80                 }
  81                 Set_invalidflag();
  82                 *dstptr = result;
  83                 return(NOEXCEPTION);
  84         }
  85         /*
  86          * Generate result
  87          */
  88         if (src_exponent >= 0) {
  89                 /*
  90                  * Check sign.
  91                  * If negative, trap unimplemented.
  92                  */
  93                 if (Sgl_isone_sign(src)) {
  94                         result = 0;
  95                         if (Is_invalidtrap_enabled()) {
  96                                 return(INVALIDEXCEPTION);
  97                         }
  98                         Set_invalidflag();
  99                         *dstptr = result;
 100                         return(NOEXCEPTION);
 101                 }
 102                 Sgl_clear_signexponent_set_hidden(src);
 103                 Suint_from_sgl_mantissa(src,src_exponent,result);
 104                 *dstptr = result;
 105
 106                 /* check for inexact */
 107                 if (Sgl_isinexact_to_unsigned(src,src_exponent)) {
 108                         if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
 109                         else Set_inexactflag();
 110                 }
 111         }
 112         else {
 113                 *dstptr = 0;
 114
 115                 /* check for inexact */
 116                 if (Sgl_isnotzero_exponentmantissa(src)) {
 117                         if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
 118                         else Set_inexactflag();
 119                 }
 120         }
 121         return(NOEXCEPTION);
 122 }
 123
 124 /*
 125  *  Single Floating-point to Double Unsigned Fixed
 126  */
 127 /*ARGSUSED*/
 128 int
 129 sgl_to_dbl_fcnvfut (sgl_floating_point * srcptr, unsigned int *nullptr,
 130                     dbl_unsigned * dstptr, unsigned int *status)
 131 {
 132         register int src_exponent;
 133         register unsigned int src, resultp1, resultp2;
 134
 135         src = *srcptr;
 136         src_exponent = Sgl_exponent(src) - SGL_BIAS;
 137
 138         /*
 139          * Test for overflow
 140          */
 141         if (src_exponent > DBL_FX_MAX_EXP + 1) {
 142                 if (Sgl_isone_sign(src)) {
 143                         resultp1 = resultp2 = 0;
 144                 } else {
 145                         resultp1 = resultp2 = 0xffffffff;
 146                 }
 147                 if (Is_invalidtrap_enabled()) {
 148                         return(INVALIDEXCEPTION);
 149                 }
 150                 Set_invalidflag();
 151                 Duint_copytoptr(resultp1,resultp2,dstptr);
 152                 return(NOEXCEPTION);
 153         }
 154         /*
 155          * Generate result
 156          */
 157         if (src_exponent >= 0) {
 158                 /*
 159                  * Check sign.
 160                  * If negative, trap unimplemented.
 161                  */
 162                 if (Sgl_isone_sign(src)) {
 163                         resultp1 = resultp2 = 0;
 164                         if (Is_invalidtrap_enabled()) {
 165                                 return(INVALIDEXCEPTION);
 166                         }
 167                         Set_invalidflag();
 168                         Duint_copytoptr(resultp1,resultp2,dstptr);
 169                         return(NOEXCEPTION);
 170                 }
 171                 Sgl_clear_signexponent_set_hidden(src);
 172                 Duint_from_sgl_mantissa(src,src_exponent,resultp1,resultp2);
 173                 Duint_copytoptr(resultp1,resultp2,dstptr);
 174
 175                 /* check for inexact */
 176                 if (Sgl_isinexact_to_unsigned(src,src_exponent)) {
 177                         if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
 178                         else Set_inexactflag();
 179                 }
 180         }
 181         else {
 182                 Duint_setzero(resultp1,resultp2);
 183                 Duint_copytoptr(resultp1,resultp2,dstptr);
 184
 185                 /* check for inexact */
 186                 if (Sgl_isnotzero_exponentmantissa(src)) {
 187                         if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
 188                         else Set_inexactflag();
 189                 }
 190         }
 191         return(NOEXCEPTION);
 192 }
 193
 194 /*
 195  *  Double Floating-point to Single Unsigned Fixed
 196  */
 197 /*ARGSUSED*/
 198 int
 199 dbl_to_sgl_fcnvfut (dbl_floating_point * srcptr, unsigned int *nullptr,
 200                     unsigned int *dstptr, unsigned int *status)
 201 {
 202         register unsigned int srcp1, srcp2, result;
 203         register int src_exponent;
 204
 205         Dbl_copyfromptr(srcptr,srcp1,srcp2);
 206         src_exponent = Dbl_exponent(srcp1) - DBL_BIAS;
 207
 208         /*
 209          * Test for overflow
 210          */
 211         if (src_exponent > SGL_FX_MAX_EXP + 1) {
 212                 if (Dbl_isone_sign(srcp1)) {
 213                         result = 0;
 214                 } else {
 215                         result = 0xffffffff;
 216                 }
 217                 if (Is_invalidtrap_enabled()) {
 218                         return(INVALIDEXCEPTION);
 219                 }
 220                 Set_invalidflag();
 221                 *dstptr = result;
 222                 return(NOEXCEPTION);
 223         }
 224         /*
 225          * Generate result
 226          */
 227         if (src_exponent >= 0) {
 228                 /*
 229                  * Check sign.
 230                  * If negative, trap unimplemented.
 231                  */
 232                 if (Dbl_isone_sign(srcp1)) {
 233                         result = 0;
 234                         if (Is_invalidtrap_enabled()) {
 235                                 return(INVALIDEXCEPTION);
 236                         }
 237                         Set_invalidflag();
 238                         *dstptr = result;
 239                         return(NOEXCEPTION);
 240                 }
 241                 Dbl_clear_signexponent_set_hidden(srcp1);
 242                 Suint_from_dbl_mantissa(srcp1,srcp2,src_exponent,result);
 243                 *dstptr = result;
 244
 245                 /* check for inexact */
 246                 if (Dbl_isinexact_to_unsigned(srcp1,srcp2,src_exponent)) {
 247                         if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
 248                         else Set_inexactflag();
 249                 }
 250         }
 251         else {
 252                 *dstptr = 0;
 253
 254                 /* check for inexact */
 255                 if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) {
 256                         if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
 257                         else Set_inexactflag();
 258                 }
 259         }
 260         return(NOEXCEPTION);
 261 }
 262
 263 /*
 264  *  Double Floating-point to Double Unsigned Fixed
 265  */
 266 /*ARGSUSED*/
 267 int
 268 dbl_to_dbl_fcnvfut (dbl_floating_point * srcptr, unsigned int *nullptr,
 269                     dbl_unsigned * dstptr, unsigned int *status)
 270 {
 271         register int src_exponent;
 272         register unsigned int srcp1, srcp2, resultp1, resultp2;
 273
 274         Dbl_copyfromptr(srcptr,srcp1,srcp2);
 275         src_exponent = Dbl_exponent(srcp1) - DBL_BIAS;
 276
 277         /*
 278          * Test for overflow
 279          */
 280         if (src_exponent > DBL_FX_MAX_EXP + 1) {
 281                 if (Dbl_isone_sign(srcp1)) {
 282                         resultp1 = resultp2 = 0;
 283                 } else {
 284                         resultp1 = resultp2 = 0xffffffff;
 285                 }
 286                 if (Is_invalidtrap_enabled()) {
 287                         return(INVALIDEXCEPTION);
 288                 }
 289                 Set_invalidflag();
 290                 Duint_copytoptr(resultp1,resultp2,dstptr);
 291                 return(NOEXCEPTION);
 292         }
 293         /*
 294          * Generate result
 295          */
 296         if (src_exponent >= 0) {
 297                 /*
 298                  * Check sign.
 299                  * If negative, trap unimplemented.
 300                  */
 301                 if (Dbl_isone_sign(srcp1)) {
 302                         resultp1 = resultp2 = 0;
 303                         if (Is_invalidtrap_enabled()) {
 304                                 return(INVALIDEXCEPTION);
 305                         }
 306                         Set_invalidflag();
 307                         Duint_copytoptr(resultp1,resultp2,dstptr);
 308                         return(NOEXCEPTION);
 309                 }
 310                 Dbl_clear_signexponent_set_hidden(srcp1);
 311                 Duint_from_dbl_mantissa(srcp1,srcp2,src_exponent,
 312                   resultp1,resultp2);
 313                 Duint_copytoptr(resultp1,resultp2,dstptr);
 314
 315                 /* check for inexact */
 316                 if (Dbl_isinexact_to_unsigned(srcp1,srcp2,src_exponent)) {
 317                         if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
 318                         else Set_inexactflag();
 319                 }
 320         }
 321         else {
 322                 Duint_setzero(resultp1,resultp2);
 323                 Duint_copytoptr(resultp1,resultp2,dstptr);
 324
 325                 /* check for inexact */
 326                 if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) {
 327                         if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
 328                         else Set_inexactflag();
 329                 }
 330         }
 331         return(NOEXCEPTION);
 332 }