soft-fp/quad.h

   1 /* Software floating-point emulation.
   2    Definitions for IEEE Quad Precision.
   3    Copyright (C) 1997-2023 Free Software Foundation, Inc.
   4    This file is part of the GNU C Library.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    In addition to the permissions in the GNU Lesser General Public
  12    License, the Free Software Foundation gives you unlimited
  13    permission to link the compiled version of this file into
  14    combinations with other programs, and to distribute those
  15    combinations without any restriction coming from the use of this
  16    file.  (The Lesser General Public License restrictions do apply in
  17    other respects; for example, they cover modification of the file,
  18    and distribution when not linked into a combine executable.)
  19
  20    The GNU C Library is distributed in the hope that it will be useful,
  21    but WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23    Lesser General Public License for more details.
  24
  25    You should have received a copy of the GNU Lesser General Public
  26    License along with the GNU C Library; if not, see
  27    <https://www.gnu.org/licenses/>.  */
  28
  29 #ifndef SOFT_FP_QUAD_H
  30 #define SOFT_FP_QUAD_H  1
  31
  32 #if _FP_W_TYPE_SIZE < 32
  33 # error "Here's a nickel, kid. Go buy yourself a real computer."
  34 #endif
  35
  36 #if _FP_W_TYPE_SIZE < 64
  37 # define _FP_FRACTBITS_Q        (4*_FP_W_TYPE_SIZE)
  38 # define _FP_FRACTBITS_DW_Q     (8*_FP_W_TYPE_SIZE)
  39 #else
  40 # define _FP_FRACTBITS_Q                (2*_FP_W_TYPE_SIZE)
  41 # define _FP_FRACTBITS_DW_Q     (4*_FP_W_TYPE_SIZE)
  42 #endif
  43
  44 #define _FP_FRACBITS_Q          113
  45 #define _FP_FRACXBITS_Q         (_FP_FRACTBITS_Q - _FP_FRACBITS_Q)
  46 #define _FP_WFRACBITS_Q         (_FP_WORKBITS + _FP_FRACBITS_Q)
  47 #define _FP_WFRACXBITS_Q        (_FP_FRACTBITS_Q - _FP_WFRACBITS_Q)
  48 #define _FP_EXPBITS_Q           15
  49 #define _FP_EXPBIAS_Q           16383
  50 #define _FP_EXPMAX_Q            32767
  51
  52 #define _FP_QNANBIT_Q           \
  53         ((_FP_W_TYPE) 1 << (_FP_FRACBITS_Q-2) % _FP_W_TYPE_SIZE)
  54 #define _FP_QNANBIT_SH_Q                \
  55         ((_FP_W_TYPE) 1 << (_FP_FRACBITS_Q-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
  56 #define _FP_IMPLBIT_Q           \
  57         ((_FP_W_TYPE) 1 << (_FP_FRACBITS_Q-1) % _FP_W_TYPE_SIZE)
  58 #define _FP_IMPLBIT_SH_Q                \
  59         ((_FP_W_TYPE) 1 << (_FP_FRACBITS_Q-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
  60 #define _FP_OVERFLOW_Q          \
  61         ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_Q % _FP_W_TYPE_SIZE))
  62
  63 #define _FP_WFRACBITS_DW_Q      (2 * _FP_WFRACBITS_Q)
  64 #define _FP_WFRACXBITS_DW_Q     (_FP_FRACTBITS_DW_Q - _FP_WFRACBITS_DW_Q)
  65 #define _FP_HIGHBIT_DW_Q        \
  66   ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_DW_Q - 1) % _FP_W_TYPE_SIZE)
  67
  68 typedef float TFtype __attribute__ ((mode (TF)));
  69
  70 #if _FP_W_TYPE_SIZE < 64
  71
  72 union _FP_UNION_Q
  73 {
  74   TFtype flt;
  75   struct _FP_STRUCT_LAYOUT
  76   {
  77 # if __BYTE_ORDER == __BIG_ENDIAN
  78     unsigned sign : 1;
  79     unsigned exp : _FP_EXPBITS_Q;
  80     unsigned long frac3 : _FP_FRACBITS_Q - (_FP_IMPLBIT_Q != 0)-(_FP_W_TYPE_SIZE * 3);
  81     unsigned long frac2 : _FP_W_TYPE_SIZE;
  82     unsigned long frac1 : _FP_W_TYPE_SIZE;
  83     unsigned long frac0 : _FP_W_TYPE_SIZE;
  84 # else
  85     unsigned long frac0 : _FP_W_TYPE_SIZE;
  86     unsigned long frac1 : _FP_W_TYPE_SIZE;
  87     unsigned long frac2 : _FP_W_TYPE_SIZE;
  88     unsigned long frac3 : _FP_FRACBITS_Q - (_FP_IMPLBIT_Q != 0)-(_FP_W_TYPE_SIZE * 3);
  89     unsigned exp : _FP_EXPBITS_Q;
  90     unsigned sign : 1;
  91 # endif /* not bigendian */
  92   } bits;
  93 };
  94
  95
  96 # define FP_DECL_Q(X)           _FP_DECL (4, X)
  97 # define FP_UNPACK_RAW_Q(X, val)        _FP_UNPACK_RAW_4 (Q, X, (val))
  98 # define FP_UNPACK_RAW_QP(X, val)       _FP_UNPACK_RAW_4_P (Q, X, (val))
  99 # define FP_PACK_RAW_Q(val, X)  _FP_PACK_RAW_4 (Q, (val), X)
 100 # define FP_PACK_RAW_QP(val, X)                 \
 101   do                                            \
 102     {                                           \
 103       if (!FP_INHIBIT_RESULTS)                  \
 104         _FP_PACK_RAW_4_P (Q, (val), X);         \
 105     }                                           \
 106   while (0)
 107
 108 # define FP_UNPACK_Q(X, val)                    \
 109   do                                            \
 110     {                                           \
 111       _FP_UNPACK_RAW_4 (Q, X, (val));           \
 112       _FP_UNPACK_CANONICAL (Q, 4, X);           \
 113     }                                           \
 114   while (0)
 115
 116 # define FP_UNPACK_QP(X, val)                   \
 117   do                                            \
 118     {                                           \
 119       _FP_UNPACK_RAW_4_P (Q, X, (val));         \
 120       _FP_UNPACK_CANONICAL (Q, 4, X);           \
 121     }                                           \
 122   while (0)
 123
 124 # define FP_UNPACK_SEMIRAW_Q(X, val)            \
 125   do                                            \
 126     {                                           \
 127       _FP_UNPACK_RAW_4 (Q, X, (val));           \
 128       _FP_UNPACK_SEMIRAW (Q, 4, X);             \
 129     }                                           \
 130   while (0)
 131
 132 # define FP_UNPACK_SEMIRAW_QP(X, val)           \
 133   do                                            \
 134     {                                           \
 135       _FP_UNPACK_RAW_4_P (Q, X, (val));         \
 136       _FP_UNPACK_SEMIRAW (Q, 4, X);             \
 137     }                                           \
 138   while (0)
 139
 140 # define FP_PACK_Q(val, X)                      \
 141   do                                            \
 142     {                                           \
 143       _FP_PACK_CANONICAL (Q, 4, X);             \
 144       _FP_PACK_RAW_4 (Q, (val), X);             \
 145     }                                           \
 146   while (0)
 147
 148 # define FP_PACK_QP(val, X)                     \
 149   do                                            \
 150     {                                           \
 151       _FP_PACK_CANONICAL (Q, 4, X);             \
 152       if (!FP_INHIBIT_RESULTS)                  \
 153         _FP_PACK_RAW_4_P (Q, (val), X);         \
 154     }                                           \
 155   while (0)
 156
 157 # define FP_PACK_SEMIRAW_Q(val, X)              \
 158   do                                            \
 159     {                                           \
 160       _FP_PACK_SEMIRAW (Q, 4, X);               \
 161       _FP_PACK_RAW_4 (Q, (val), X);             \
 162     }                                           \
 163   while (0)
 164
 165 # define FP_PACK_SEMIRAW_QP(val, X)             \
 166   do                                            \
 167     {                                           \
 168       _FP_PACK_SEMIRAW (Q, 4, X);               \
 169       if (!FP_INHIBIT_RESULTS)                  \
 170         _FP_PACK_RAW_4_P (Q, (val), X);         \
 171     }                                           \
 172   while (0)
 173
 174 # define FP_ISSIGNAN_Q(X)               _FP_ISSIGNAN (Q, 4, X)
 175 # define FP_NEG_Q(R, X)                 _FP_NEG (Q, 4, R, X)
 176 # define FP_ADD_Q(R, X, Y)              _FP_ADD (Q, 4, R, X, Y)
 177 # define FP_SUB_Q(R, X, Y)              _FP_SUB (Q, 4, R, X, Y)
 178 # define FP_MUL_Q(R, X, Y)              _FP_MUL (Q, 4, R, X, Y)
 179 # define FP_DIV_Q(R, X, Y)              _FP_DIV (Q, 4, R, X, Y)
 180 # define FP_SQRT_Q(R, X)                _FP_SQRT (Q, 4, R, X)
 181 # define _FP_SQRT_MEAT_Q(R, S, T, X, Q) _FP_SQRT_MEAT_4 (R, S, T, X, (Q))
 182 # define FP_FMA_Q(R, X, Y, Z)           _FP_FMA (Q, 4, 8, R, X, Y, Z)
 183
 184 # define FP_CMP_Q(r, X, Y, un, ex)      _FP_CMP (Q, 4, (r), X, Y, (un), (ex))
 185 # define FP_CMP_EQ_Q(r, X, Y, ex)       _FP_CMP_EQ (Q, 4, (r), X, Y, (ex))
 186 # define FP_CMP_UNORD_Q(r, X, Y, ex)    _FP_CMP_UNORD (Q, 4, (r), X, Y, (ex))
 187
 188 # define FP_TO_INT_Q(r, X, rsz, rsg)    _FP_TO_INT (Q, 4, (r), X, (rsz), (rsg))
 189 # define FP_TO_INT_ROUND_Q(r, X, rsz, rsg)      \
 190   _FP_TO_INT_ROUND (Q, 4, (r), X, (rsz), (rsg))
 191 # define FP_FROM_INT_Q(X, r, rs, rt)    _FP_FROM_INT (Q, 4, X, (r), (rs), rt)
 192
 193 # define _FP_FRAC_HIGH_Q(X)     _FP_FRAC_HIGH_4 (X)
 194 # define _FP_FRAC_HIGH_RAW_Q(X) _FP_FRAC_HIGH_4 (X)
 195
 196 # define _FP_FRAC_HIGH_DW_Q(X)  _FP_FRAC_HIGH_8 (X)
 197
 198 #else   /* not _FP_W_TYPE_SIZE < 64 */
 199 union _FP_UNION_Q
 200 {
 201   TFtype flt /* __attribute__ ((mode (TF))) */ ;
 202   struct _FP_STRUCT_LAYOUT
 203   {
 204     _FP_W_TYPE a, b;
 205   } longs;
 206   struct _FP_STRUCT_LAYOUT
 207   {
 208 # if __BYTE_ORDER == __BIG_ENDIAN
 209     unsigned sign    : 1;
 210     unsigned exp     : _FP_EXPBITS_Q;
 211     _FP_W_TYPE frac1 : _FP_FRACBITS_Q - (_FP_IMPLBIT_Q != 0) - _FP_W_TYPE_SIZE;
 212     _FP_W_TYPE frac0 : _FP_W_TYPE_SIZE;
 213 # else
 214     _FP_W_TYPE frac0 : _FP_W_TYPE_SIZE;
 215     _FP_W_TYPE frac1 : _FP_FRACBITS_Q - (_FP_IMPLBIT_Q != 0) - _FP_W_TYPE_SIZE;
 216     unsigned exp     : _FP_EXPBITS_Q;
 217     unsigned sign    : 1;
 218 # endif
 219   } bits;
 220 };
 221
 222 # define FP_DECL_Q(X)           _FP_DECL (2, X)
 223 # define FP_UNPACK_RAW_Q(X, val)        _FP_UNPACK_RAW_2 (Q, X, (val))
 224 # define FP_UNPACK_RAW_QP(X, val)       _FP_UNPACK_RAW_2_P (Q, X, (val))
 225 # define FP_PACK_RAW_Q(val, X)  _FP_PACK_RAW_2 (Q, (val), X)
 226 # define FP_PACK_RAW_QP(val, X)                 \
 227   do                                            \
 228     {                                           \
 229       if (!FP_INHIBIT_RESULTS)                  \
 230         _FP_PACK_RAW_2_P (Q, (val), X);         \
 231     }                                           \
 232   while (0)
 233
 234 # define FP_UNPACK_Q(X, val)                    \
 235   do                                            \
 236     {                                           \
 237       _FP_UNPACK_RAW_2 (Q, X, (val));           \
 238       _FP_UNPACK_CANONICAL (Q, 2, X);           \
 239     }                                           \
 240   while (0)
 241
 242 # define FP_UNPACK_QP(X, val)                   \
 243   do                                            \
 244     {                                           \
 245       _FP_UNPACK_RAW_2_P (Q, X, (val));         \
 246       _FP_UNPACK_CANONICAL (Q, 2, X);           \
 247     }                                           \
 248   while (0)
 249
 250 # define FP_UNPACK_SEMIRAW_Q(X, val)            \
 251   do                                            \
 252     {                                           \
 253       _FP_UNPACK_RAW_2 (Q, X, (val));           \
 254       _FP_UNPACK_SEMIRAW (Q, 2, X);             \
 255     }                                           \
 256   while (0)
 257
 258 # define FP_UNPACK_SEMIRAW_QP(X, val)           \
 259   do                                            \
 260     {                                           \
 261       _FP_UNPACK_RAW_2_P (Q, X, (val));         \
 262       _FP_UNPACK_SEMIRAW (Q, 2, X);             \
 263     }                                           \
 264   while (0)
 265
 266 # define FP_PACK_Q(val, X)                      \
 267   do                                            \
 268     {                                           \
 269       _FP_PACK_CANONICAL (Q, 2, X);             \
 270       _FP_PACK_RAW_2 (Q, (val), X);             \
 271     }                                           \
 272   while (0)
 273
 274 # define FP_PACK_QP(val, X)                     \
 275   do                                            \
 276     {                                           \
 277       _FP_PACK_CANONICAL (Q, 2, X);             \
 278       if (!FP_INHIBIT_RESULTS)                  \
 279         _FP_PACK_RAW_2_P (Q, (val), X);         \
 280     }                                           \
 281   while (0)
 282
 283 # define FP_PACK_SEMIRAW_Q(val, X)              \
 284   do                                            \
 285     {                                           \
 286       _FP_PACK_SEMIRAW (Q, 2, X);               \
 287       _FP_PACK_RAW_2 (Q, (val), X);             \
 288     }                                           \
 289   while (0)
 290
 291 # define FP_PACK_SEMIRAW_QP(val, X)             \
 292   do                                            \
 293     {                                           \
 294       _FP_PACK_SEMIRAW (Q, 2, X);               \
 295       if (!FP_INHIBIT_RESULTS)                  \
 296         _FP_PACK_RAW_2_P (Q, (val), X);         \
 297     }                                           \
 298   while (0)
 299
 300 # define FP_ISSIGNAN_Q(X)               _FP_ISSIGNAN (Q, 2, X)
 301 # define FP_NEG_Q(R, X)                 _FP_NEG (Q, 2, R, X)
 302 # define FP_ADD_Q(R, X, Y)              _FP_ADD (Q, 2, R, X, Y)
 303 # define FP_SUB_Q(R, X, Y)              _FP_SUB (Q, 2, R, X, Y)
 304 # define FP_MUL_Q(R, X, Y)              _FP_MUL (Q, 2, R, X, Y)
 305 # define FP_DIV_Q(R, X, Y)              _FP_DIV (Q, 2, R, X, Y)
 306 # define FP_SQRT_Q(R, X)                _FP_SQRT (Q, 2, R, X)
 307 # define _FP_SQRT_MEAT_Q(R, S, T, X, Q) _FP_SQRT_MEAT_2 (R, S, T, X, (Q))
 308 # define FP_FMA_Q(R, X, Y, Z)           _FP_FMA (Q, 2, 4, R, X, Y, Z)
 309
 310 # define FP_CMP_Q(r, X, Y, un, ex)      _FP_CMP (Q, 2, (r), X, Y, (un), (ex))
 311 # define FP_CMP_EQ_Q(r, X, Y, ex)       _FP_CMP_EQ (Q, 2, (r), X, Y, (ex))
 312 # define FP_CMP_UNORD_Q(r, X, Y, ex)    _FP_CMP_UNORD (Q, 2, (r), X, Y, (ex))
 313
 314 # define FP_TO_INT_Q(r, X, rsz, rsg)    _FP_TO_INT (Q, 2, (r), X, (rsz), (rsg))
 315 # define FP_TO_INT_ROUND_Q(r, X, rsz, rsg)      \
 316   _FP_TO_INT_ROUND (Q, 2, (r), X, (rsz), (rsg))
 317 # define FP_FROM_INT_Q(X, r, rs, rt)    _FP_FROM_INT (Q, 2, X, (r), (rs), rt)
 318
 319 # define _FP_FRAC_HIGH_Q(X)     _FP_FRAC_HIGH_2 (X)
 320 # define _FP_FRAC_HIGH_RAW_Q(X) _FP_FRAC_HIGH_2 (X)
 321
 322 # define _FP_FRAC_HIGH_DW_Q(X)  _FP_FRAC_HIGH_4 (X)
 323
 324 #endif /* not _FP_W_TYPE_SIZE < 64 */
 325
 326 #endif /* !SOFT_FP_QUAD_H */