arch/parisc/math-emu/cnv_float.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * Linux/PA-RISC Project (http://www.parisc-linux.org/)
   4  *
   5  * Floating-point emulation code
   6  *  Copyright (C) 2001 Hewlett-Packard (Paul Bame) <bame@debian.org>
   7  */
   8
   9 #ifdef __NO_PA_HDRS
  10     PA header file -- do not include this header file for non-PA builds.
  11 #endif
  12
  13 /*
  14  * Some more constants
  15  */
  16 #define SGL_FX_MAX_EXP 30
  17 #define DBL_FX_MAX_EXP 62
  18 #define QUAD_FX_MAX_EXP 126
  19
  20 #define Dintp1(object) (object)
  21 #define Dintp2(object) (object)
  22
  23 #define Duintp1(object) (object)
  24 #define Duintp2(object) (object)
  25
  26 #define Qintp0(object) (object)
  27 #define Qintp1(object) (object)
  28 #define Qintp2(object) (object)
  29 #define Qintp3(object) (object)
  30
  31
  32 /*
  33  * These macros will be used specifically by the convert instructions.
  34  *
  35  *
  36  * Single format macros
  37  */
  38
  39 #define Sgl_to_dbl_exponent(src_exponent,dest)                  \
  40     Deposit_dexponent(dest,src_exponent+(DBL_BIAS-SGL_BIAS))
  41
  42 #define Sgl_to_dbl_mantissa(src_mantissa,destA,destB)   \
  43     Deposit_dmantissap1(destA,src_mantissa>>3);         \
  44     Dmantissap2(destB) = src_mantissa << 29
  45
  46 #define Sgl_isinexact_to_fix(sgl_value,exponent)        \
  47     ((exponent < (SGL_P - 1)) ?                         \
  48      (Sall(sgl_value) << (SGL_EXP_LENGTH + 1 + exponent)) : FALSE)
  49
  50 #define Int_isinexact_to_sgl(int_value) ((int_value << 33 - SGL_EXP_LENGTH) != 0)
  51
  52 #define Sgl_roundnearest_from_int(int_value,sgl_value)                  \
  53     if (int_value & 1<<(SGL_EXP_LENGTH - 2))   /* round bit */          \
  54         if (((int_value << 34 - SGL_EXP_LENGTH) != 0) || Slow(sgl_value)) \
  55                 Sall(sgl_value)++
  56
  57 #define Dint_isinexact_to_sgl(dint_valueA,dint_valueB)          \
  58     (((Dintp1(dint_valueA) << 33 - SGL_EXP_LENGTH) != 0) || Dintp2(dint_valueB))
  59
  60 #define Sgl_roundnearest_from_dint(dint_valueA,dint_valueB,sgl_value)   \
  61     if (Dintp1(dint_valueA) & 1<<(SGL_EXP_LENGTH - 2))                  \
  62         if (((Dintp1(dint_valueA) << 34 - SGL_EXP_LENGTH) != 0) ||      \
  63         Dintp2(dint_valueB) || Slow(sgl_value)) Sall(sgl_value)++
  64
  65 #define Dint_isinexact_to_dbl(dint_value)       \
  66     (Dintp2(dint_value) << 33 - DBL_EXP_LENGTH)
  67
  68 #define Dbl_roundnearest_from_dint(dint_opndB,dbl_opndA,dbl_opndB)      \
  69     if (Dintp2(dint_opndB) & 1<<(DBL_EXP_LENGTH - 2))                   \
  70        if ((Dintp2(dint_opndB) << 34 - DBL_EXP_LENGTH) || Dlowp2(dbl_opndB))  \
  71           if ((++Dallp2(dbl_opndB))==0) Dallp1(dbl_opndA)++
  72
  73 #define Sgl_isone_roundbit(sgl_value,exponent)                  \
  74     ((Sall(sgl_value) << (SGL_EXP_LENGTH + 1 + exponent)) >> 31)
  75
  76 #define Sgl_isone_stickybit(sgl_value,exponent)         \
  77     (exponent < (SGL_P - 2) ?                           \
  78      Sall(sgl_value) << (SGL_EXP_LENGTH + 2 + exponent) : FALSE)
  79
  80
  81 /*
  82  * Double format macros
  83  */
  84
  85 #define Dbl_to_sgl_exponent(src_exponent,dest)                  \
  86     dest = src_exponent + (SGL_BIAS - DBL_BIAS)
  87
  88 #define Dbl_to_sgl_mantissa(srcA,srcB,dest,inexact,guard,sticky,odd)    \
  89     Shiftdouble(Dmantissap1(srcA),Dmantissap2(srcB),29,dest);   \
  90     guard = Dbit3p2(srcB);                                      \
  91     sticky = Dallp2(srcB)<<4;                                   \
  92     inexact = guard | sticky;                                   \
  93     odd = Dbit2p2(srcB)
  94
  95 #define Dbl_to_sgl_denormalized(srcA,srcB,exp,dest,inexact,guard,sticky,odd,tiny) \
  96     Deposit_dexponent(srcA,1);                                          \
  97     tiny = TRUE;                                                        \
  98     if (exp >= -2) {                                                    \
  99         if (exp == 0) {                                                 \
 100             inexact = Dallp2(srcB) << 3;                                \
 101             guard = inexact >> 31;                                      \
 102             sticky = inexact << 1;                                      \
 103             Shiftdouble(Dmantissap1(srcA),Dmantissap2(srcB),29,dest);   \
 104             odd = dest << 31;                                           \
 105             if (inexact) {                                              \
 106                 switch(Rounding_mode()) {                               \
 107                     case ROUNDPLUS:                                     \
 108                         if (Dbl_iszero_sign(srcA)) {                    \
 109                             dest++;                                     \
 110                             if (Sgl_isone_hidden(dest)) \
 111                                 tiny = FALSE;                           \
 112                             dest--;                                     \
 113                         }                                               \
 114                         break;                                          \
 115                     case ROUNDMINUS:                                    \
 116                         if (Dbl_isone_sign(srcA)) {                     \
 117                             dest++;                                     \
 118                             if (Sgl_isone_hidden(dest)) \
 119                                 tiny = FALSE;                           \
 120                             dest--;                                     \
 121                         }                                               \
 122                         break;                                          \
 123                     case ROUNDNEAREST:                                  \
 124                         if (guard && (sticky || odd)) {                 \
 125                             dest++;                                     \
 126                             if (Sgl_isone_hidden(dest)) \
 127                                 tiny = FALSE;                           \
 128                             dest--;                                     \
 129                         }                                               \
 130                         break;                                          \
 131                 }                                                       \
 132             }                                                           \
 133                 /* shift right by one to get correct result */          \
 134                 guard = odd;                                            \
 135                 sticky = inexact;                                       \
 136                 inexact |= guard;                                       \
 137                 dest >>= 1;                                             \
 138                 Deposit_dsign(srcA,0);                                  \
 139                 Shiftdouble(Dallp1(srcA),Dallp2(srcB),30,dest);         \
 140                 odd = dest << 31;                                       \
 141         }                                                               \
 142         else {                                                          \
 143             inexact = Dallp2(srcB) << (2 + exp);                        \
 144             guard = inexact >> 31;                                      \
 145             sticky = inexact << 1;                                      \
 146             Deposit_dsign(srcA,0);                                      \
 147             if (exp == -2) dest = Dallp1(srcA);                         \
 148             else Variable_shift_double(Dallp1(srcA),Dallp2(srcB),30-exp,dest); \
 149             odd = dest << 31;                                           \
 150         }                                                               \
 151     }                                                                   \
 152     else {                                                              \
 153         Deposit_dsign(srcA,0);                                          \
 154         if (exp > (1 - SGL_P)) {                                        \
 155             dest = Dallp1(srcA) >> (- 2 - exp);                         \
 156             inexact = Dallp1(srcA) << (34 + exp);                       \
 157             guard = inexact >> 31;                                      \
 158             sticky = (inexact << 1) | Dallp2(srcB);                     \
 159             inexact |= Dallp2(srcB);                                    \
 160             odd = dest << 31;                                           \
 161         }                                                               \
 162         else {                                                          \
 163             dest = 0;                                                   \
 164             inexact = Dallp1(srcA) | Dallp2(srcB);                      \
 165             if (exp == (1 - SGL_P)) {                                   \
 166                 guard = Dhidden(srcA);                                  \
 167                 sticky = Dmantissap1(srcA) | Dallp2(srcB);              \
 168             }                                                           \
 169             else {                                                      \
 170                 guard = 0;                                              \
 171                 sticky = inexact;                                       \
 172             }                                                           \
 173             odd = 0;                                                    \
 174         }                                                               \
 175     }                                                                   \
 176     exp = 0
 177
 178 #define Dbl_isinexact_to_fix(dbl_valueA,dbl_valueB,exponent)            \
 179     (exponent < (DBL_P-33) ?                                            \
 180      Dallp2(dbl_valueB) || Dallp1(dbl_valueA) << (DBL_EXP_LENGTH+1+exponent) : \
 181      (exponent < (DBL_P-1) ? Dallp2(dbl_valueB) << (exponent + (33-DBL_P)) :   \
 182       FALSE))
 183
 184 #define Dbl_isoverflow_to_int(exponent,dbl_valueA,dbl_valueB)           \
 185     ((exponent > SGL_FX_MAX_EXP + 1) || Dsign(dbl_valueA)==0 ||         \
 186      Dmantissap1(dbl_valueA)!=0 || (Dallp2(dbl_valueB)>>21)!=0 )
 187
 188 #define Dbl_isone_roundbit(dbl_valueA,dbl_valueB,exponent)              \
 189     ((exponent < (DBL_P - 33) ?                                         \
 190       Dallp1(dbl_valueA) >> ((30 - DBL_EXP_LENGTH) - exponent) :        \
 191       Dallp2(dbl_valueB) >> ((DBL_P - 2) - exponent)) & 1)
 192
 193 #define Dbl_isone_stickybit(dbl_valueA,dbl_valueB,exponent)             \
 194     (exponent < (DBL_P-34) ?                                            \
 195      (Dallp2(dbl_valueB) || Dallp1(dbl_valueA)<<(DBL_EXP_LENGTH+2+exponent)) : \
 196      (exponent<(DBL_P-2) ? (Dallp2(dbl_valueB) << (exponent + (34-DBL_P))) : \
 197       FALSE))
 198
 199
 200 /* Int macros */
 201
 202 #define Int_from_sgl_mantissa(sgl_value,exponent)       \
 203     Sall(sgl_value) =                           \
 204         (unsigned)(Sall(sgl_value) << SGL_EXP_LENGTH)>>(31 - exponent)
 205
 206 #define Int_from_dbl_mantissa(dbl_valueA,dbl_valueB,exponent)   \
 207     Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),22,Dallp1(dbl_valueA)); \
 208     if (exponent < 31) Dallp1(dbl_valueA) >>= 30 - exponent;    \
 209     else Dallp1(dbl_valueA) <<= 1
 210
 211 #define Int_negate(int_value) int_value = -int_value
 212
 213
 214 /* Dint macros */
 215
 216 #define Dint_from_sgl_mantissa(sgl_value,exponent,dresultA,dresultB)    \
 217     {Sall(sgl_value) <<= SGL_EXP_LENGTH;  /*  left-justify  */          \
 218     if (exponent <= 31) {                                               \
 219         Dintp1(dresultA) = 0;                                           \
 220         Dintp2(dresultB) = (unsigned)Sall(sgl_value) >> (31 - exponent); \
 221     }                                                                   \
 222     else {                                                              \
 223         Dintp1(dresultA) = Sall(sgl_value) >> (63 - exponent);          \
 224         Dintp2(dresultB) = Sall(sgl_value) << (exponent - 31);          \
 225     }}
 226
 227
 228 #define Dint_from_dbl_mantissa(dbl_valueA,dbl_valueB,exponent,destA,destB) \
 229     {if (exponent < 32) {                                               \
 230         Dintp1(destA) = 0;                                              \
 231         if (exponent <= 20)                                             \
 232             Dintp2(destB) = Dallp1(dbl_valueA) >> 20-exponent;          \
 233         else Variable_shift_double(Dallp1(dbl_valueA),Dallp2(dbl_valueB), \
 234              52-exponent,Dintp2(destB));                                        \
 235     }                                                                   \
 236     else {                                                              \
 237         if (exponent <= 52) {                                           \
 238             Dintp1(destA) = Dallp1(dbl_valueA) >> 52-exponent;          \
 239             if (exponent == 52) Dintp2(destB) = Dallp2(dbl_valueB);     \
 240             else Variable_shift_double(Dallp1(dbl_valueA),Dallp2(dbl_valueB), \
 241             52-exponent,Dintp2(destB));                                 \
 242         }                                                               \
 243         else {                                                          \
 244             Variable_shift_double(Dallp1(dbl_valueA),Dallp2(dbl_valueB), \
 245             84-exponent,Dintp1(destA));                                 \
 246             Dintp2(destB) = Dallp2(dbl_valueB) << exponent-52;          \
 247         }                                                               \
 248     }}
 249
 250 #define Dint_setzero(dresultA,dresultB)         \
 251     Dintp1(dresultA) = 0;       \
 252     Dintp2(dresultB) = 0
 253
 254 #define Dint_setone_sign(dresultA,dresultB)             \
 255     Dintp1(dresultA) = ~Dintp1(dresultA);               \
 256     if ((Dintp2(dresultB) = -Dintp2(dresultB)) == 0) Dintp1(dresultA)++
 257
 258 #define Dint_set_minint(dresultA,dresultB)              \
 259     Dintp1(dresultA) = (unsigned int)1<<31;             \
 260     Dintp2(dresultB) = 0
 261
 262 #define Dint_isone_lowp2(dresultB)  (Dintp2(dresultB) & 01)
 263
 264 #define Dint_increment(dresultA,dresultB)               \
 265     if ((++Dintp2(dresultB))==0) Dintp1(dresultA)++
 266
 267 #define Dint_decrement(dresultA,dresultB)               \
 268     if ((Dintp2(dresultB)--)==0) Dintp1(dresultA)--
 269
 270 #define Dint_negate(dresultA,dresultB)                  \
 271     Dintp1(dresultA) = ~Dintp1(dresultA);               \
 272     if ((Dintp2(dresultB) = -Dintp2(dresultB))==0) Dintp1(dresultA)++
 273
 274 #define Dint_copyfromptr(src,destA,destB) \
 275      Dintp1(destA) = src->wd0;          \
 276      Dintp2(destB) = src->wd1
 277 #define Dint_copytoptr(srcA,srcB,dest)  \
 278     dest->wd0 = Dintp1(srcA);           \
 279     dest->wd1 = Dintp2(srcB)
 280
 281
 282 /* other macros  */
 283
 284 #define Find_ms_one_bit(value, position)        \
 285     {                                           \
 286         int var;                                \
 287         for (var=8; var >=1; var >>= 1) {       \
 288             if (value >> 32 - position)         \
 289                 position -= var;                \
 290                 else position += var;           \
 291         }                                       \
 292         if ((value >> 32 - position) == 0)      \
 293             position--;                         \
 294         else position -= 2;                     \
 295     }
 296
 297
 298 /*
 299  * Unsigned int macros
 300  */
 301 #define Duint_copyfromptr(src,destA,destB) \
 302     Dint_copyfromptr(src,destA,destB)
 303 #define Duint_copytoptr(srcA,srcB,dest) \
 304     Dint_copytoptr(srcA,srcB,dest)
 305
 306 #define Suint_isinexact_to_sgl(int_value) \
 307     (int_value << 32 - SGL_EXP_LENGTH)
 308
 309 #define Sgl_roundnearest_from_suint(suint_value,sgl_value)              \
 310     if (suint_value & 1<<(SGL_EXP_LENGTH - 1))   /* round bit */        \
 311         if ((suint_value << 33 - SGL_EXP_LENGTH) || Slow(sgl_value))    \
 312                 Sall(sgl_value)++
 313
 314 #define Duint_isinexact_to_sgl(duint_valueA,duint_valueB)       \
 315     ((Duintp1(duint_valueA) << 32 - SGL_EXP_LENGTH) || Duintp2(duint_valueB))
 316
 317 #define Sgl_roundnearest_from_duint(duint_valueA,duint_valueB,sgl_value) \
 318     if (Duintp1(duint_valueA) & 1<<(SGL_EXP_LENGTH - 1))                \
 319         if ((Duintp1(duint_valueA) << 33 - SGL_EXP_LENGTH) ||           \
 320         Duintp2(duint_valueB) || Slow(sgl_value)) Sall(sgl_value)++
 321
 322 #define Duint_isinexact_to_dbl(duint_value)     \
 323     (Duintp2(duint_value) << 32 - DBL_EXP_LENGTH)
 324
 325 #define Dbl_roundnearest_from_duint(duint_opndB,dbl_opndA,dbl_opndB)    \
 326     if (Duintp2(duint_opndB) & 1<<(DBL_EXP_LENGTH - 1))                 \
 327        if ((Duintp2(duint_opndB) << 33 - DBL_EXP_LENGTH) || Dlowp2(dbl_opndB)) \
 328           if ((++Dallp2(dbl_opndB))==0) Dallp1(dbl_opndA)++
 329
 330 #define Suint_from_sgl_mantissa(src,exponent,result)    \
 331     Sall(result) = (unsigned)(Sall(src) << SGL_EXP_LENGTH)>>(31 - exponent)
 332
 333 #define Sgl_isinexact_to_unsigned(sgl_value,exponent)   \
 334     Sgl_isinexact_to_fix(sgl_value,exponent)
 335
 336 #define Duint_from_sgl_mantissa(sgl_value,exponent,dresultA,dresultB)   \
 337   {unsigned int val = Sall(sgl_value) << SGL_EXP_LENGTH;                \
 338     if (exponent <= 31) {                                               \
 339         Dintp1(dresultA) = 0;                                           \
 340         Dintp2(dresultB) = val >> (31 - exponent);                      \
 341     }                                                                   \
 342     else {                                                              \
 343         Dintp1(dresultA) = val >> (63 - exponent);                      \
 344         Dintp2(dresultB) = exponent <= 62 ? val << (exponent - 31) : 0; \
 345     }                                                                   \
 346   }
 347
 348 #define Duint_setzero(dresultA,dresultB)        \
 349     Dint_setzero(dresultA,dresultB)
 350
 351 #define Duint_increment(dresultA,dresultB) Dint_increment(dresultA,dresultB)
 352
 353 #define Duint_isone_lowp2(dresultB)  Dint_isone_lowp2(dresultB)
 354
 355 #define Suint_from_dbl_mantissa(srcA,srcB,exponent,dest) \
 356     Shiftdouble(Dallp1(srcA),Dallp2(srcB),21,dest); \
 357     dest = (unsigned)dest >> 31 - exponent
 358
 359 #define Dbl_isinexact_to_unsigned(dbl_valueA,dbl_valueB,exponent) \
 360     Dbl_isinexact_to_fix(dbl_valueA,dbl_valueB,exponent)
 361
 362 #define Duint_from_dbl_mantissa(dbl_valueA,dbl_valueB,exponent,destA,destB) \
 363     Dint_from_dbl_mantissa(dbl_valueA,dbl_valueB,exponent,destA,destB)