kernel/arch/parisc/math-emu/frnd.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  *  Purpose:
  25  *      Single Floating-point Round to Integer
  26  *      Double Floating-point Round to Integer
  27  *      Quad Floating-point Round to Integer (returns unimplemented)
  28  *
  29  *  External Interfaces:
  30  *      dbl_frnd(srcptr,nullptr,dstptr,status)
  31  *      sgl_frnd(srcptr,nullptr,dstptr,status)
  32  *
  33  * END_DESC
  34 */
  35
  36
  37 #include "float.h"
  38 #include "sgl_float.h"
  39 #include "dbl_float.h"
  40 #include "cnv_float.h"
  41
  42 /*
  43  *  Single Floating-point Round to Integer
  44  */
  45
  46 /*ARGSUSED*/
  47 int
  48 sgl_frnd(sgl_floating_point *srcptr,
  49         unsigned int *nullptr,
  50         sgl_floating_point *dstptr,
  51         unsigned int *status)
  52 {
  53         register unsigned int src, result;
  54         register int src_exponent;
  55         register boolean inexact = FALSE;
  56
  57         src = *srcptr;
  58         /*
  59          * check source operand for NaN or infinity
  60          */
  61         if ((src_exponent = Sgl_exponent(src)) == SGL_INFINITY_EXPONENT) {
  62                 /*
  63                  * is signaling NaN?
  64                  */
  65                 if (Sgl_isone_signaling(src)) {
  66                         /* trap if INVALIDTRAP enabled */
  67                         if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION);
  68                         /* make NaN quiet */
  69                         Set_invalidflag();
  70                         Sgl_set_quiet(src);
  71                 }
  72                 /*
  73                  * return quiet NaN or infinity
  74                  */
  75                 *dstptr = src;
  76                 return(NOEXCEPTION);
  77         }
  78         /*
  79          * Need to round?
  80          */
  81         if ((src_exponent -= SGL_BIAS) >= SGL_P - 1) {
  82                 *dstptr = src;
  83                 return(NOEXCEPTION);
  84         }
  85         /*
  86          * Generate result
  87          */
  88         if (src_exponent >= 0) {
  89                 Sgl_clear_exponent_set_hidden(src);
  90                 result = src;
  91                 Sgl_rightshift(result,(SGL_P-1) - (src_exponent));
  92                 /* check for inexact */
  93                 if (Sgl_isinexact_to_fix(src,src_exponent)) {
  94                         inexact = TRUE;
  95                         /*  round result  */
  96                         switch (Rounding_mode()) {
  97                         case ROUNDPLUS:
  98                              if (Sgl_iszero_sign(src)) Sgl_increment(result);
  99                              break;
 100                         case ROUNDMINUS:
 101                              if (Sgl_isone_sign(src)) Sgl_increment(result);
 102                              break;
 103                         case ROUNDNEAREST:
 104                              if (Sgl_isone_roundbit(src,src_exponent))
 105                                 if (Sgl_isone_stickybit(src,src_exponent)
 106                                 || (Sgl_isone_lowmantissa(result)))
 107                                         Sgl_increment(result);
 108                         }
 109                 }
 110                 Sgl_leftshift(result,(SGL_P-1) - (src_exponent));
 111                 if (Sgl_isone_hiddenoverflow(result))
 112                         Sgl_set_exponent(result,src_exponent + (SGL_BIAS+1));
 113                 else Sgl_set_exponent(result,src_exponent + SGL_BIAS);
 114         }
 115         else {
 116                 result = src;           /* set sign */
 117                 Sgl_setzero_exponentmantissa(result);
 118                 /* check for inexact */
 119                 if (Sgl_isnotzero_exponentmantissa(src)) {
 120                         inexact = TRUE;
 121                         /*  round result  */
 122                         switch (Rounding_mode()) {
 123                         case ROUNDPLUS:
 124                              if (Sgl_iszero_sign(src))
 125                                 Sgl_set_exponent(result,SGL_BIAS);
 126                              break;
 127                         case ROUNDMINUS:
 128                              if (Sgl_isone_sign(src))
 129                                 Sgl_set_exponent(result,SGL_BIAS);
 130                              break;
 131                         case ROUNDNEAREST:
 132                              if (src_exponent == -1)
 133                                 if (Sgl_isnotzero_mantissa(src))
 134                                    Sgl_set_exponent(result,SGL_BIAS);
 135                         }
 136                 }
 137         }
 138         *dstptr = result;
 139         if (inexact) {
 140                 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
 141                 else Set_inexactflag();
 142         }
 143         return(NOEXCEPTION);
 144 }
 145
 146 /*
 147  *  Double Floating-point Round to Integer
 148  */
 149
 150 /*ARGSUSED*/
 151 int
 152 dbl_frnd(
 153         dbl_floating_point *srcptr,
 154         unsigned int *nullptr,
 155         dbl_floating_point *dstptr,
 156         unsigned int *status)
 157 {
 158         register unsigned int srcp1, srcp2, resultp1, resultp2;
 159         register int src_exponent;
 160         register boolean inexact = FALSE;
 161
 162         Dbl_copyfromptr(srcptr,srcp1,srcp2);
 163         /*
 164          * check source operand for NaN or infinity
 165          */
 166         if ((src_exponent = Dbl_exponent(srcp1)) == DBL_INFINITY_EXPONENT) {
 167                 /*
 168                  * is signaling NaN?
 169                  */
 170                 if (Dbl_isone_signaling(srcp1)) {
 171                         /* trap if INVALIDTRAP enabled */
 172                         if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION);
 173                         /* make NaN quiet */
 174                         Set_invalidflag();
 175                         Dbl_set_quiet(srcp1);
 176                 }
 177                 /*
 178                  * return quiet NaN or infinity
 179                  */
 180                 Dbl_copytoptr(srcp1,srcp2,dstptr);
 181                 return(NOEXCEPTION);
 182         }
 183         /*
 184          * Need to round?
 185          */
 186         if ((src_exponent -= DBL_BIAS) >= DBL_P - 1) {
 187                 Dbl_copytoptr(srcp1,srcp2,dstptr);
 188                 return(NOEXCEPTION);
 189         }
 190         /*
 191          * Generate result
 192          */
 193         if (src_exponent >= 0) {
 194                 Dbl_clear_exponent_set_hidden(srcp1);
 195                 resultp1 = srcp1;
 196                 resultp2 = srcp2;
 197                 Dbl_rightshift(resultp1,resultp2,(DBL_P-1) - (src_exponent));
 198                 /* check for inexact */
 199                 if (Dbl_isinexact_to_fix(srcp1,srcp2,src_exponent)) {
 200                         inexact = TRUE;
 201                         /*  round result  */
 202                         switch (Rounding_mode()) {
 203                         case ROUNDPLUS:
 204                              if (Dbl_iszero_sign(srcp1))
 205                                 Dbl_increment(resultp1,resultp2);
 206                              break;
 207                         case ROUNDMINUS:
 208                              if (Dbl_isone_sign(srcp1))
 209                                 Dbl_increment(resultp1,resultp2);
 210                              break;
 211                         case ROUNDNEAREST:
 212                              if (Dbl_isone_roundbit(srcp1,srcp2,src_exponent))
 213                               if (Dbl_isone_stickybit(srcp1,srcp2,src_exponent)
 214                                   || (Dbl_isone_lowmantissap2(resultp2)))
 215                                         Dbl_increment(resultp1,resultp2);
 216                         }
 217                 }
 218                 Dbl_leftshift(resultp1,resultp2,(DBL_P-1) - (src_exponent));
 219                 if (Dbl_isone_hiddenoverflow(resultp1))
 220                         Dbl_set_exponent(resultp1,src_exponent + (DBL_BIAS+1));
 221                 else Dbl_set_exponent(resultp1,src_exponent + DBL_BIAS);
 222         }
 223         else {
 224                 resultp1 = srcp1;  /* set sign */
 225                 Dbl_setzero_exponentmantissa(resultp1,resultp2);
 226                 /* check for inexact */
 227                 if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) {
 228                         inexact = TRUE;
 229                         /*  round result  */
 230                         switch (Rounding_mode()) {
 231                         case ROUNDPLUS:
 232                              if (Dbl_iszero_sign(srcp1))
 233                                 Dbl_set_exponent(resultp1,DBL_BIAS);
 234                              break;
 235                         case ROUNDMINUS:
 236                              if (Dbl_isone_sign(srcp1))
 237                                 Dbl_set_exponent(resultp1,DBL_BIAS);
 238                              break;
 239                         case ROUNDNEAREST:
 240                              if (src_exponent == -1)
 241                                 if (Dbl_isnotzero_mantissa(srcp1,srcp2))
 242                                    Dbl_set_exponent(resultp1,DBL_BIAS);
 243                         }
 244                 }
 245         }
 246         Dbl_copytoptr(resultp1,resultp2,dstptr);
 247         if (inexact) {
 248                 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
 249                 else Set_inexactflag();
 250         }
 251         return(NOEXCEPTION);
 252 }