arch/parisc/math-emu/sfdiv.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/sfdiv.c               $Revision: 1.1 $
  26  *
  27  *  Purpose:
  28  *      Single Precision Floating-point Divide
  29  *
  30  *  External Interfaces:
  31  *      sgl_fdiv(srcptr1,srcptr2,dstptr,status)
  32  *
  33  *  Internal Interfaces:
  34  *
  35  *  Theory:
  36  *      <<please update with a overview of the operation of this file>>
  37  *
  38  * END_DESC
  39 */
  40
  41
  42 #include "float.h"
  43 #include "sgl_float.h"
  44
  45 /*
  46  *  Single Precision Floating-point Divide
  47  */
  48
  49 int
  50 sgl_fdiv (sgl_floating_point * srcptr1, sgl_floating_point * srcptr2,
  51           sgl_floating_point * dstptr, unsigned int *status)
  52 {
  53         register unsigned int opnd1, opnd2, opnd3, result;
  54         register int dest_exponent, count;
  55         register boolean inexact = FALSE, guardbit = FALSE, stickybit = FALSE;
  56         boolean is_tiny;
  57
  58         opnd1 = *srcptr1;
  59         opnd2 = *srcptr2;
  60         /*
  61          * set sign bit of result
  62          */
  63         if (Sgl_sign(opnd1) ^ Sgl_sign(opnd2)) Sgl_setnegativezero(result);
  64         else Sgl_setzero(result);
  65         /*
  66          * check first operand for NaN's or infinity
  67          */
  68         if (Sgl_isinfinity_exponent(opnd1)) {
  69                 if (Sgl_iszero_mantissa(opnd1)) {
  70                         if (Sgl_isnotnan(opnd2)) {
  71                                 if (Sgl_isinfinity(opnd2)) {
  72                                         /*
  73                                          * invalid since both operands
  74                                          * are infinity
  75                                          */
  76                                         if (Is_invalidtrap_enabled())
  77                                                 return(INVALIDEXCEPTION);
  78                                         Set_invalidflag();
  79                                         Sgl_makequietnan(result);
  80                                         *dstptr = result;
  81                                         return(NOEXCEPTION);
  82                                 }
  83                                 /*
  84                                  * return infinity
  85                                  */
  86                                 Sgl_setinfinity_exponentmantissa(result);
  87                                 *dstptr = result;
  88                                 return(NOEXCEPTION);
  89                         }
  90                 }
  91                 else {
  92                         /*
  93                          * is NaN; signaling or quiet?
  94                          */
  95                         if (Sgl_isone_signaling(opnd1)) {
  96                                 /* trap if INVALIDTRAP enabled */
  97                                 if (Is_invalidtrap_enabled())
  98                                         return(INVALIDEXCEPTION);
  99                                 /* make NaN quiet */
 100                                 Set_invalidflag();
 101                                 Sgl_set_quiet(opnd1);
 102                         }
 103                         /*
 104                          * is second operand a signaling NaN?
 105                          */
 106                         else if (Sgl_is_signalingnan(opnd2)) {
 107                                 /* trap if INVALIDTRAP enabled */
 108                                 if (Is_invalidtrap_enabled())
 109                                         return(INVALIDEXCEPTION);
 110                                 /* make NaN quiet */
 111                                 Set_invalidflag();
 112                                 Sgl_set_quiet(opnd2);
 113                                 *dstptr = opnd2;
 114                                 return(NOEXCEPTION);
 115                         }
 116                         /*
 117                          * return quiet NaN
 118                          */
 119                         *dstptr = opnd1;
 120                         return(NOEXCEPTION);
 121                 }
 122         }
 123         /*
 124          * check second operand for NaN's or infinity
 125          */
 126         if (Sgl_isinfinity_exponent(opnd2)) {
 127                 if (Sgl_iszero_mantissa(opnd2)) {
 128                         /*
 129                          * return zero
 130                          */
 131                         Sgl_setzero_exponentmantissa(result);
 132                         *dstptr = result;
 133                         return(NOEXCEPTION);
 134                 }
 135                 /*
 136                  * is NaN; signaling or quiet?
 137                  */
 138                 if (Sgl_isone_signaling(opnd2)) {
 139                         /* trap if INVALIDTRAP enabled */
 140                         if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION);
 141                         /* make NaN quiet */
 142                         Set_invalidflag();
 143                         Sgl_set_quiet(opnd2);
 144                 }
 145                 /*
 146                  * return quiet NaN
 147                  */
 148                 *dstptr = opnd2;
 149                 return(NOEXCEPTION);
 150         }
 151         /*
 152          * check for division by zero
 153          */
 154         if (Sgl_iszero_exponentmantissa(opnd2)) {
 155                 if (Sgl_iszero_exponentmantissa(opnd1)) {
 156                         /* invalid since both operands are zero */
 157                         if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION);
 158                         Set_invalidflag();
 159                         Sgl_makequietnan(result);
 160                         *dstptr = result;
 161                         return(NOEXCEPTION);
 162                 }
 163                 if (Is_divisionbyzerotrap_enabled())
 164                         return(DIVISIONBYZEROEXCEPTION);
 165                 Set_divisionbyzeroflag();
 166                 Sgl_setinfinity_exponentmantissa(result);
 167                 *dstptr = result;
 168                 return(NOEXCEPTION);
 169         }
 170         /*
 171          * Generate exponent
 172          */
 173         dest_exponent = Sgl_exponent(opnd1) - Sgl_exponent(opnd2) + SGL_BIAS;
 174
 175         /*
 176          * Generate mantissa
 177          */
 178         if (Sgl_isnotzero_exponent(opnd1)) {
 179                 /* set hidden bit */
 180                 Sgl_clear_signexponent_set_hidden(opnd1);
 181         }
 182         else {
 183                 /* check for zero */
 184                 if (Sgl_iszero_mantissa(opnd1)) {
 185                         Sgl_setzero_exponentmantissa(result);
 186                         *dstptr = result;
 187                         return(NOEXCEPTION);
 188                 }
 189                 /* is denormalized; want to normalize */
 190                 Sgl_clear_signexponent(opnd1);
 191                 Sgl_leftshiftby1(opnd1);
 192                 Sgl_normalize(opnd1,dest_exponent);
 193         }
 194         /* opnd2 needs to have hidden bit set with msb in hidden bit */
 195         if (Sgl_isnotzero_exponent(opnd2)) {
 196                 Sgl_clear_signexponent_set_hidden(opnd2);
 197         }
 198         else {
 199                 /* is denormalized; want to normalize */
 200                 Sgl_clear_signexponent(opnd2);
 201                 Sgl_leftshiftby1(opnd2);
 202                 while(Sgl_iszero_hiddenhigh7mantissa(opnd2)) {
 203                         Sgl_leftshiftby8(opnd2);
 204                         dest_exponent += 8;
 205                 }
 206                 if(Sgl_iszero_hiddenhigh3mantissa(opnd2)) {
 207                         Sgl_leftshiftby4(opnd2);
 208                         dest_exponent += 4;
 209                 }
 210                 while(Sgl_iszero_hidden(opnd2)) {
 211                         Sgl_leftshiftby1(opnd2);
 212                         dest_exponent += 1;
 213                 }
 214         }
 215
 216         /* Divide the source mantissas */
 217
 218         /*
 219          * A non_restoring divide algorithm is used.
 220          */
 221         Sgl_subtract(opnd1,opnd2,opnd1);
 222         Sgl_setzero(opnd3);
 223         for (count=1;count<=SGL_P && Sgl_all(opnd1);count++) {
 224                 Sgl_leftshiftby1(opnd1);
 225                 Sgl_leftshiftby1(opnd3);
 226                 if (Sgl_iszero_sign(opnd1)) {
 227                         Sgl_setone_lowmantissa(opnd3);
 228                         Sgl_subtract(opnd1,opnd2,opnd1);
 229                 }
 230                 else Sgl_addition(opnd1,opnd2,opnd1);
 231         }
 232         if (count <= SGL_P) {
 233                 Sgl_leftshiftby1(opnd3);
 234                 Sgl_setone_lowmantissa(opnd3);
 235                 Sgl_leftshift(opnd3,SGL_P-count);
 236                 if (Sgl_iszero_hidden(opnd3)) {
 237                         Sgl_leftshiftby1(opnd3);
 238                         dest_exponent--;
 239                 }
 240         }
 241         else {
 242                 if (Sgl_iszero_hidden(opnd3)) {
 243                         /* need to get one more bit of result */
 244                         Sgl_leftshiftby1(opnd1);
 245                         Sgl_leftshiftby1(opnd3);
 246                         if (Sgl_iszero_sign(opnd1)) {
 247                                 Sgl_setone_lowmantissa(opnd3);
 248                                 Sgl_subtract(opnd1,opnd2,opnd1);
 249                         }
 250                         else Sgl_addition(opnd1,opnd2,opnd1);
 251                         dest_exponent--;
 252                 }
 253                 if (Sgl_iszero_sign(opnd1)) guardbit = TRUE;
 254                 stickybit = Sgl_all(opnd1);
 255         }
 256         inexact = guardbit | stickybit;
 257
 258         /*
 259          * round result
 260          */
 261         if (inexact && (dest_exponent > 0 || Is_underflowtrap_enabled())) {
 262                 Sgl_clear_signexponent(opnd3);
 263                 switch (Rounding_mode()) {
 264                         case ROUNDPLUS:
 265                                 if (Sgl_iszero_sign(result))
 266                                         Sgl_increment_mantissa(opnd3);
 267                                 break;
 268                         case ROUNDMINUS:
 269                                 if (Sgl_isone_sign(result))
 270                                         Sgl_increment_mantissa(opnd3);
 271                                 break;
 272                         case ROUNDNEAREST:
 273                                 if (guardbit) {
 274                                 if (stickybit || Sgl_isone_lowmantissa(opnd3))
 275                                     Sgl_increment_mantissa(opnd3);
 276                                 }
 277                 }
 278                 if (Sgl_isone_hidden(opnd3)) dest_exponent++;
 279         }
 280         Sgl_set_mantissa(result,opnd3);
 281
 282         /*
 283          * Test for overflow
 284          */
 285         if (dest_exponent >= SGL_INFINITY_EXPONENT) {
 286                 /* trap if OVERFLOWTRAP enabled */
 287                 if (Is_overflowtrap_enabled()) {
 288                         /*
 289                          * Adjust bias of result
 290                          */
 291                         Sgl_setwrapped_exponent(result,dest_exponent,ovfl);
 292                         *dstptr = result;
 293                         if (inexact)
 294                             if (Is_inexacttrap_enabled())
 295                                 return(OVERFLOWEXCEPTION | INEXACTEXCEPTION);
 296                             else Set_inexactflag();
 297                         return(OVERFLOWEXCEPTION);
 298                 }
 299                 Set_overflowflag();
 300                 /* set result to infinity or largest number */
 301                 Sgl_setoverflow(result);
 302                 inexact = TRUE;
 303         }
 304         /*
 305          * Test for underflow
 306          */
 307         else if (dest_exponent <= 0) {
 308                 /* trap if UNDERFLOWTRAP enabled */
 309                 if (Is_underflowtrap_enabled()) {
 310                         /*
 311                          * Adjust bias of result
 312                          */
 313                         Sgl_setwrapped_exponent(result,dest_exponent,unfl);
 314                         *dstptr = result;
 315                         if (inexact)
 316                             if (Is_inexacttrap_enabled())
 317                                 return(UNDERFLOWEXCEPTION | INEXACTEXCEPTION);
 318                             else Set_inexactflag();
 319                         return(UNDERFLOWEXCEPTION);
 320                 }
 321
 322                 /* Determine if should set underflow flag */
 323                 is_tiny = TRUE;
 324                 if (dest_exponent == 0 && inexact) {
 325                         switch (Rounding_mode()) {
 326                         case ROUNDPLUS:
 327                                 if (Sgl_iszero_sign(result)) {
 328                                         Sgl_increment(opnd3);
 329                                         if (Sgl_isone_hiddenoverflow(opnd3))
 330                                             is_tiny = FALSE;
 331                                         Sgl_decrement(opnd3);
 332                                 }
 333                                 break;
 334                         case ROUNDMINUS:
 335                                 if (Sgl_isone_sign(result)) {
 336                                         Sgl_increment(opnd3);
 337                                         if (Sgl_isone_hiddenoverflow(opnd3))
 338                                             is_tiny = FALSE;
 339                                         Sgl_decrement(opnd3);
 340                                 }
 341                                 break;
 342                         case ROUNDNEAREST:
 343                                 if (guardbit && (stickybit ||
 344                                     Sgl_isone_lowmantissa(opnd3))) {
 345                                         Sgl_increment(opnd3);
 346                                         if (Sgl_isone_hiddenoverflow(opnd3))
 347                                             is_tiny = FALSE;
 348                                         Sgl_decrement(opnd3);
 349                                 }
 350                                 break;
 351                         }
 352                 }
 353
 354                 /*
 355                  * denormalize result or set to signed zero
 356                  */
 357                 stickybit = inexact;
 358                 Sgl_denormalize(opnd3,dest_exponent,guardbit,stickybit,inexact);
 359
 360                 /* return rounded number */
 361                 if (inexact) {
 362                         switch (Rounding_mode()) {
 363                         case ROUNDPLUS:
 364                                 if (Sgl_iszero_sign(result)) {
 365                                         Sgl_increment(opnd3);
 366                                 }
 367                                 break;
 368                         case ROUNDMINUS:
 369                                 if (Sgl_isone_sign(result))  {
 370                                         Sgl_increment(opnd3);
 371                                 }
 372                                 break;
 373                         case ROUNDNEAREST:
 374                                 if (guardbit && (stickybit ||
 375                                     Sgl_isone_lowmantissa(opnd3))) {
 376                                         Sgl_increment(opnd3);
 377                                 }
 378                                 break;
 379                         }
 380                         if (is_tiny) Set_underflowflag();
 381                 }
 382                 Sgl_set_exponentmantissa(result,opnd3);
 383         }
 384         else Sgl_set_exponent(result,dest_exponent);
 385         *dstptr = result;
 386         /* check for inexact */
 387         if (inexact) {
 388                 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
 389                 else  Set_inexactflag();
 390         }
 391         return(NOEXCEPTION);
 392 }