git.oblomov.eu Git - linux-2.6/blob - arch/powerpc/include/asm/sfp-machine.h

   1 /* Machine-dependent software floating-point definitions.  PPC version.
   2    Copyright (C) 1997 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If
  17    not, write to the Free Software Foundation, Inc.,
  18    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19
  20    Actually, this is a PPC (32bit) version, written based on the
  21    i386, sparc, and sparc64 versions, by me,
  22    Peter Maydell (pmaydell@chiark.greenend.org.uk).
  23    Comments are by and large also mine, although they may be inaccurate.
  24
  25    In picking out asm fragments I've gone with the lowest common
  26    denominator, which also happens to be the hardware I have :->
  27    That is, a SPARC without hardware multiply and divide.
  28  */
  29
  30 /* basic word size definitions */
  31 #define _FP_W_TYPE_SIZE         32
  32 #define _FP_W_TYPE              unsigned long
  33 #define _FP_WS_TYPE             signed long
  34 #define _FP_I_TYPE              long
  35
  36 #define __ll_B                  ((UWtype) 1 << (W_TYPE_SIZE / 2))
  37 #define __ll_lowpart(t)         ((UWtype) (t) & (__ll_B - 1))
  38 #define __ll_highpart(t)        ((UWtype) (t) >> (W_TYPE_SIZE / 2))
  39
  40 /* You can optionally code some things like addition in asm. For
  41  * example, i386 defines __FP_FRAC_ADD_2 as asm. If you don't
  42  * then you get a fragment of C code [if you change an #ifdef 0
  43  * in op-2.h] or a call to add_ssaaaa (see below).
  44  * Good places to look for asm fragments to use are gcc and glibc.
  45  * gcc's longlong.h is useful.
  46  */
  47
  48 /* We need to know how to multiply and divide. If the host word size
  49  * is >= 2*fracbits you can use FP_MUL_MEAT_n_imm(t,R,X,Y) which
  50  * codes the multiply with whatever gcc does to 'a * b'.
  51  * _FP_MUL_MEAT_n_wide(t,R,X,Y,f) is used when you have an asm
  52  * function that can multiply two 1W values and get a 2W result.
  53  * Otherwise you're stuck with _FP_MUL_MEAT_n_hard(t,R,X,Y) which
  54  * does bitshifting to avoid overflow.
  55  * For division there is FP_DIV_MEAT_n_imm(t,R,X,Y,f) for word size
  56  * >= 2*fracbits, where f is either _FP_DIV_HELP_imm or
  57  * _FP_DIV_HELP_ldiv (see op-1.h).
  58  * _FP_DIV_MEAT_udiv() is if you have asm to do 2W/1W => (1W, 1W).
  59  * [GCC and glibc have longlong.h which has the asm macro udiv_qrnnd
  60  * to do this.]
  61  * In general, 'n' is the number of words required to hold the type,
  62  * and 't' is either S, D or Q for single/double/quad.
  63  *           -- PMM
  64  */
  65 /* Example: SPARC64:
  66  * #define _FP_MUL_MEAT_S(R,X,Y)        _FP_MUL_MEAT_1_imm(S,R,X,Y)
  67  * #define _FP_MUL_MEAT_D(R,X,Y)        _FP_MUL_MEAT_1_wide(D,R,X,Y,umul_ppmm)
  68  * #define _FP_MUL_MEAT_Q(R,X,Y)        _FP_MUL_MEAT_2_wide(Q,R,X,Y,umul_ppmm)
  69  *
  70  * #define _FP_DIV_MEAT_S(R,X,Y)        _FP_DIV_MEAT_1_imm(S,R,X,Y,_FP_DIV_HELP_imm)
  71  * #define _FP_DIV_MEAT_D(R,X,Y)        _FP_DIV_MEAT_1_udiv(D,R,X,Y)
  72  * #define _FP_DIV_MEAT_Q(R,X,Y)        _FP_DIV_MEAT_2_udiv_64(Q,R,X,Y)
  73  *
  74  * Example: i386:
  75  * #define _FP_MUL_MEAT_S(R,X,Y)   _FP_MUL_MEAT_1_wide(S,R,X,Y,_i386_mul_32_64)
  76  * #define _FP_MUL_MEAT_D(R,X,Y)   _FP_MUL_MEAT_2_wide(D,R,X,Y,_i386_mul_32_64)
  77  *
  78  * #define _FP_DIV_MEAT_S(R,X,Y)   _FP_DIV_MEAT_1_udiv(S,R,X,Y,_i386_div_64_32)
  79  * #define _FP_DIV_MEAT_D(R,X,Y)   _FP_DIV_MEAT_2_udiv_64(D,R,X,Y)
  80  */
  81
  82 #define _FP_MUL_MEAT_S(R,X,Y)   _FP_MUL_MEAT_1_wide(_FP_WFRACBITS_S,R,X,Y,umul_ppmm)
  83 #define _FP_MUL_MEAT_D(R,X,Y)   _FP_MUL_MEAT_2_wide(_FP_WFRACBITS_D,R,X,Y,umul_ppmm)
  84
  85 #define _FP_DIV_MEAT_S(R,X,Y)   _FP_DIV_MEAT_1_udiv_norm(S,R,X,Y)
  86 #define _FP_DIV_MEAT_D(R,X,Y)   _FP_DIV_MEAT_2_udiv(D,R,X,Y)
  87
  88 /* These macros define what NaN looks like. They're supposed to expand to
  89  * a comma-separated set of 32bit unsigned ints that encode NaN.
  90  */
  91 #define _FP_NANFRAC_S           ((_FP_QNANBIT_S << 1) - 1)
  92 #define _FP_NANFRAC_D           ((_FP_QNANBIT_D << 1) - 1), -1
  93 #define _FP_NANFRAC_Q           ((_FP_QNANBIT_Q << 1) - 1), -1, -1, -1
  94 #define _FP_NANSIGN_S           0
  95 #define _FP_NANSIGN_D           0
  96 #define _FP_NANSIGN_Q           0
  97
  98 #define _FP_KEEPNANFRACP 1
  99
 100 /* Exception flags.  We use the bit positions of the appropriate bits
 101    in the FPSCR, which also correspond to the FE_* bits.  This makes
 102    everything easier ;-).  */
 103 #define FP_EX_INVALID         (1 << (31 - 2))
 104 #define FP_EX_INVALID_SNAN      EFLAG_VXSNAN
 105 #define FP_EX_INVALID_ISI       EFLAG_VXISI
 106 #define FP_EX_INVALID_IDI       EFLAG_VXIDI
 107 #define FP_EX_INVALID_ZDZ       EFLAG_VXZDZ
 108 #define FP_EX_INVALID_IMZ       EFLAG_VXIMZ
 109 #define FP_EX_OVERFLOW        (1 << (31 - 3))
 110 #define FP_EX_UNDERFLOW       (1 << (31 - 4))
 111 #define FP_EX_DIVZERO         (1 << (31 - 5))
 112 #define FP_EX_INEXACT         (1 << (31 - 6))
 113
 114 /*
 115  * If one NaN is signaling and the other is not,
 116  * we choose that one, otherwise we choose X.
 117  */
 118 #define _FP_CHOOSENAN(fs, wc, R, X, Y, OP)                      \
 119   do {                                                          \
 120     if ((_FP_FRAC_HIGH_RAW_##fs(Y) & _FP_QNANBIT_##fs)          \
 121         && !(_FP_FRAC_HIGH_RAW_##fs(X) & _FP_QNANBIT_##fs))     \
 122       {                                                         \
 123         R##_s = X##_s;                                          \
 124         _FP_FRAC_COPY_##wc(R,X);                                \
 125       }                                                         \
 126     else                                                        \
 127       {                                                         \
 128         R##_s = Y##_s;                                          \
 129         _FP_FRAC_COPY_##wc(R,Y);                                \
 130       }                                                         \
 131     R##_c = FP_CLS_NAN;                                         \
 132   } while (0)
 133
 134
 135 #include <linux/kernel.h>
 136 #include <linux/sched.h>
 137
 138 #define __FPU_FPSCR     (current->thread.fpscr.val)
 139
 140 /* We only actually write to the destination register
 141  * if exceptions signalled (if any) will not trap.
 142  */
 143 #define __FPU_ENABLED_EXC \
 144 ({                                              \
 145         (__FPU_FPSCR >> 3) & 0x1f;      \
 146 })
 147
 148 #define __FPU_TRAP_P(bits) \
 149         ((__FPU_ENABLED_EXC & (bits)) != 0)
 150
 151 #define __FP_PACK_S(val,X)                      \
 152 ({  int __exc = _FP_PACK_CANONICAL(S,1,X);      \
 153     if(!__exc || !__FPU_TRAP_P(__exc))          \
 154         _FP_PACK_RAW_1_P(S,val,X);              \
 155     __exc;                                      \
 156 })
 157
 158 #define __FP_PACK_D(val,X)                      \
 159    do {                                                                 \
 160         _FP_PACK_CANONICAL(D, 2, X);                                    \
 161         if (!FP_CUR_EXCEPTIONS || !__FPU_TRAP_P(FP_CUR_EXCEPTIONS))     \
 162                 _FP_PACK_RAW_2_P(D, val, X);                            \
 163    } while (0)
 164
 165 #define __FP_PACK_DS(val,X)                                                     \
 166    do {                                                                         \
 167            FP_DECL_S(__X);                                                      \
 168            FP_CONV(S, D, 1, 2, __X, X);                                         \
 169            _FP_PACK_CANONICAL(S, 1, __X);                                       \
 170            if (!FP_CUR_EXCEPTIONS || !__FPU_TRAP_P(FP_CUR_EXCEPTIONS)) {        \
 171                    _FP_UNPACK_CANONICAL(S, 1, __X);                             \
 172                    FP_CONV(D, S, 2, 1, X, __X);                                 \
 173                    _FP_PACK_CANONICAL(D, 2, X);                                 \
 174                    if (!FP_CUR_EXCEPTIONS || !__FPU_TRAP_P(FP_CUR_EXCEPTIONS))  \
 175                    _FP_PACK_RAW_2_P(D, val, X);                                 \
 176            }                                                                    \
 177    } while (0)
 178
 179 /* Obtain the current rounding mode. */
 180 #define FP_ROUNDMODE                    \
 181 ({                                      \
 182         __FPU_FPSCR & 0x3;              \
 183 })
 184
 185 /* the asm fragments go here: all these are taken from glibc-2.0.5's
 186  * stdlib/longlong.h
 187  */
 188
 189 #include <linux/types.h>
 190 #include <asm/byteorder.h>
 191
 192 /* add_ssaaaa is used in op-2.h and should be equivalent to
 193  * #define add_ssaaaa(sh,sl,ah,al,bh,bl) (sh = ah+bh+ (( sl = al+bl) < al))
 194  * add_ssaaaa(high_sum, low_sum, high_addend_1, low_addend_1,
 195  * high_addend_2, low_addend_2) adds two UWtype integers, composed by
 196  * HIGH_ADDEND_1 and LOW_ADDEND_1, and HIGH_ADDEND_2 and LOW_ADDEND_2
 197  * respectively.  The result is placed in HIGH_SUM and LOW_SUM.  Overflow
 198  * (i.e. carry out) is not stored anywhere, and is lost.
 199  */
 200 #define add_ssaaaa(sh, sl, ah, al, bh, bl)                              \
 201   do {                                                                  \
 202     if (__builtin_constant_p (bh) && (bh) == 0)                         \
 203       __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{aze|addze} %0,%2"           \
 204              : "=r" ((USItype)(sh)),                                    \
 205                "=&r" ((USItype)(sl))                                    \
 206              : "%r" ((USItype)(ah)),                                    \
 207                "%r" ((USItype)(al)),                                    \
 208                "rI" ((USItype)(bl)));                                   \
 209     else if (__builtin_constant_p (bh) && (bh) ==~(USItype) 0)          \
 210       __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{ame|addme} %0,%2"           \
 211              : "=r" ((USItype)(sh)),                                    \
 212                "=&r" ((USItype)(sl))                                    \
 213              : "%r" ((USItype)(ah)),                                    \
 214                "%r" ((USItype)(al)),                                    \
 215                "rI" ((USItype)(bl)));                                   \
 216     else                                                                \
 217       __asm__ ("{a%I5|add%I5c} %1,%4,%5\n\t{ae|adde} %0,%2,%3"          \
 218              : "=r" ((USItype)(sh)),                                    \
 219                "=&r" ((USItype)(sl))                                    \
 220              : "%r" ((USItype)(ah)),                                    \
 221                "r" ((USItype)(bh)),                                     \
 222                "%r" ((USItype)(al)),                                    \
 223                "rI" ((USItype)(bl)));                                   \
 224   } while (0)
 225
 226 /* sub_ddmmss is used in op-2.h and udivmodti4.c and should be equivalent to
 227  * #define sub_ddmmss(sh, sl, ah, al, bh, bl) (sh = ah-bh - ((sl = al-bl) > al))
 228  * sub_ddmmss(high_difference, low_difference, high_minuend, low_minuend,
 229  * high_subtrahend, low_subtrahend) subtracts two two-word UWtype integers,
 230  * composed by HIGH_MINUEND_1 and LOW_MINUEND_1, and HIGH_SUBTRAHEND_2 and
 231  * LOW_SUBTRAHEND_2 respectively.  The result is placed in HIGH_DIFFERENCE
 232  * and LOW_DIFFERENCE.  Overflow (i.e. carry out) is not stored anywhere,
 233  * and is lost.
 234  */
 235 #define sub_ddmmss(sh, sl, ah, al, bh, bl)                              \
 236   do {                                                                  \
 237     if (__builtin_constant_p (ah) && (ah) == 0)                         \
 238       __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfze|subfze} %0,%2"       \
 239                : "=r" ((USItype)(sh)),                                  \
 240                  "=&r" ((USItype)(sl))                                  \
 241                : "r" ((USItype)(bh)),                                   \
 242                  "rI" ((USItype)(al)),                                  \
 243                  "r" ((USItype)(bl)));                                  \
 244     else if (__builtin_constant_p (ah) && (ah) ==~(USItype) 0)          \
 245       __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfme|subfme} %0,%2"       \
 246                : "=r" ((USItype)(sh)),                                  \
 247                  "=&r" ((USItype)(sl))                                  \
 248                : "r" ((USItype)(bh)),                                   \
 249                  "rI" ((USItype)(al)),                                  \
 250                  "r" ((USItype)(bl)));                                  \
 251     else if (__builtin_constant_p (bh) && (bh) == 0)                    \
 252       __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{ame|addme} %0,%2"         \
 253                : "=r" ((USItype)(sh)),                                  \
 254                  "=&r" ((USItype)(sl))                                  \
 255                : "r" ((USItype)(ah)),                                   \
 256                  "rI" ((USItype)(al)),                                  \
 257                  "r" ((USItype)(bl)));                                  \
 258     else if (__builtin_constant_p (bh) && (bh) ==~(USItype) 0)          \
 259       __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{aze|addze} %0,%2"         \
 260                : "=r" ((USItype)(sh)),                                  \
 261                  "=&r" ((USItype)(sl))                                  \
 262                : "r" ((USItype)(ah)),                                   \
 263                  "rI" ((USItype)(al)),                                  \
 264                  "r" ((USItype)(bl)));                                  \
 265     else                                                                \
 266       __asm__ ("{sf%I4|subf%I4c} %1,%5,%4\n\t{sfe|subfe} %0,%3,%2"      \
 267                : "=r" ((USItype)(sh)),                                  \
 268                  "=&r" ((USItype)(sl))                                  \
 269                : "r" ((USItype)(ah)),                                   \
 270                  "r" ((USItype)(bh)),                                   \
 271                  "rI" ((USItype)(al)),                                  \
 272                  "r" ((USItype)(bl)));                                  \
 273   } while (0)
 274
 275 /* asm fragments for mul and div */
 276
 277 /* umul_ppmm(high_prod, low_prod, multipler, multiplicand) multiplies two
 278  * UWtype integers MULTIPLER and MULTIPLICAND, and generates a two UWtype
 279  * word product in HIGH_PROD and LOW_PROD.
 280  */
 281 #define umul_ppmm(ph, pl, m0, m1)                                       \
 282   do {                                                                  \
 283     USItype __m0 = (m0), __m1 = (m1);                                   \
 284     __asm__ ("mulhwu %0,%1,%2"                                          \
 285              : "=r" ((USItype)(ph))                                     \
 286              : "%r" (__m0),                                             \
 287                "r" (__m1));                                             \
 288     (pl) = __m0 * __m1;                                                 \
 289   } while (0)
 290
 291 /* udiv_qrnnd(quotient, remainder, high_numerator, low_numerator,
 292  * denominator) divides a UDWtype, composed by the UWtype integers
 293  * HIGH_NUMERATOR and LOW_NUMERATOR, by DENOMINATOR and places the quotient
 294  * in QUOTIENT and the remainder in REMAINDER.  HIGH_NUMERATOR must be less
 295  * than DENOMINATOR for correct operation.  If, in addition, the most
 296  * significant bit of DENOMINATOR must be 1, then the pre-processor symbol
 297  * UDIV_NEEDS_NORMALIZATION is defined to 1.
 298  */
 299 #define udiv_qrnnd(q, r, n1, n0, d)                                     \
 300   do {                                                                  \
 301     UWtype __d1, __d0, __q1, __q0, __r1, __r0, __m;                     \
 302     __d1 = __ll_highpart (d);                                           \
 303     __d0 = __ll_lowpart (d);                                            \
 304                                                                         \
 305     __r1 = (n1) % __d1;                                                 \
 306     __q1 = (n1) / __d1;                                                 \
 307     __m = (UWtype) __q1 * __d0;                                         \
 308     __r1 = __r1 * __ll_B | __ll_highpart (n0);                          \
 309     if (__r1 < __m)                                                     \
 310       {                                                                 \
 311         __q1--, __r1 += (d);                                            \
 312         if (__r1 >= (d)) /* we didn't get carry when adding to __r1 */  \
 313           if (__r1 < __m)                                               \
 314             __q1--, __r1 += (d);                                        \
 315       }                                                                 \
 316     __r1 -= __m;                                                        \
 317                                                                         \
 318     __r0 = __r1 % __d1;                                                 \
 319     __q0 = __r1 / __d1;                                                 \
 320     __m = (UWtype) __q0 * __d0;                                         \
 321     __r0 = __r0 * __ll_B | __ll_lowpart (n0);                           \
 322     if (__r0 < __m)                                                     \
 323       {                                                                 \
 324         __q0--, __r0 += (d);                                            \
 325         if (__r0 >= (d))                                                \
 326           if (__r0 < __m)                                               \
 327             __q0--, __r0 += (d);                                        \
 328       }                                                                 \
 329     __r0 -= __m;                                                        \
 330                                                                         \
 331     (q) = (UWtype) __q1 * __ll_B | __q0;                                \
 332     (r) = __r0;                                                         \
 333   } while (0)
 334
 335 #define UDIV_NEEDS_NORMALIZATION 1
 336
 337 #define abort()                                                         \
 338         return 0
 339
 340 #ifdef __BIG_ENDIAN
 341 #define __BYTE_ORDER __BIG_ENDIAN
 342 #else
 343 #define __BYTE_ORDER __LITTLE_ENDIAN
 344 #endif
 345
 346 /* Exception flags. */
 347 #define EFLAG_INVALID           (1 << (31 - 2))
 348 #define EFLAG_OVERFLOW          (1 << (31 - 3))
 349 #define EFLAG_UNDERFLOW         (1 << (31 - 4))
 350 #define EFLAG_DIVZERO           (1 << (31 - 5))
 351 #define EFLAG_INEXACT           (1 << (31 - 6))
 352
 353 #define EFLAG_VXSNAN            (1 << (31 - 7))
 354 #define EFLAG_VXISI             (1 << (31 - 8))
 355 #define EFLAG_VXIDI             (1 << (31 - 9))
 356 #define EFLAG_VXZDZ             (1 << (31 - 10))
 357 #define EFLAG_VXIMZ             (1 << (31 - 11))
 358 #define EFLAG_VXVC              (1 << (31 - 12))
 359 #define EFLAG_VXSOFT            (1 << (31 - 21))
 360 #define EFLAG_VXSQRT            (1 << (31 - 22))
 361 #define EFLAG_VXCVI             (1 << (31 - 23))