src/video/math_private.h

   1 /*
   2  * ====================================================
   3  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
   4  *
   5  * Developed at SunPro, a Sun Microsystems, Inc. business.
   6  * Permission to use, copy, modify, and distribute this
   7  * software is freely granted, provided that this notice
   8  * is preserved.
   9  * ====================================================
  10  */
  11
  12 /*
  13  * from: @(#)fdlibm.h 5.1 93/09/24
  14  * $Id: math_private.h 1969 2006-02-24 09:57:14Z slouken $
  15  */
  16
  17 #ifndef _MATH_PRIVATE_H_
  18 #define _MATH_PRIVATE_H_
  19
  20 #include "SDL_name.h"
  21 #include "SDL_endian.h"
  22
  23 #define huge            really_big /* huge is a reserved keyword in VC++ 6.0 */
  24 #define u_int32_t       uint32_t
  25
  26 /* The original fdlibm code used statements like:
  27         n0 = ((*(int*)&one)>>29)^1;             * index of high word *
  28         ix0 = *(n0+(int*)&x);                   * high word of x *
  29         ix1 = *((1-n0)+(int*)&x);               * low word of x *
  30    to dig two 32 bit words out of the 64 bit IEEE floating point
  31    value.  That is non-ANSI, and, moreover, the gcc instruction
  32    scheduler gets it wrong.  We instead use the following macros.
  33    Unlike the original code, we determine the endianness at compile
  34    time, not at run time; I don't see much benefit to selecting
  35    endianness at run time.  */
  36
  37 /* A union which permits us to convert between a double and two 32 bit
  38    ints.  */
  39
  40 /*
  41  * Math on arm is special:
  42  * For FPA, float words are always big-endian.
  43  * For VFP, floats words follow the memory system mode.
  44  */
  45
  46 #if (SDL_BYTEORDER == SDL_BIG_ENDIAN) || \
  47     (!defined(__VFP_FP__) && (defined(__arm__) || defined(__thumb__)))
  48
  49 typedef union
  50 {
  51   double value;
  52   struct
  53   {
  54     u_int32_t msw;
  55     u_int32_t lsw;
  56   } parts;
  57 } ieee_double_shape_type;
  58
  59 #else
  60
  61 typedef union
  62 {
  63   double value;
  64   struct
  65   {
  66     u_int32_t lsw;
  67     u_int32_t msw;
  68   } parts;
  69 } ieee_double_shape_type;
  70
  71 #endif
  72
  73 /* Get two 32 bit ints from a double.  */
  74
  75 #define EXTRACT_WORDS(ix0,ix1,d)                                \
  76 do {                                                            \
  77   ieee_double_shape_type ew_u;                                  \
  78   ew_u.value = (d);                                             \
  79   (ix0) = ew_u.parts.msw;                                       \
  80   (ix1) = ew_u.parts.lsw;                                       \
  81 } while (0)
  82
  83 /* Get the more significant 32 bit int from a double.  */
  84
  85 #define GET_HIGH_WORD(i,d)                                      \
  86 do {                                                            \
  87   ieee_double_shape_type gh_u;                                  \
  88   gh_u.value = (d);                                             \
  89   (i) = gh_u.parts.msw;                                         \
  90 } while (0)
  91
  92 /* Get the less significant 32 bit int from a double.  */
  93
  94 #define GET_LOW_WORD(i,d)                                       \
  95 do {                                                            \
  96   ieee_double_shape_type gl_u;                                  \
  97   gl_u.value = (d);                                             \
  98   (i) = gl_u.parts.lsw;                                         \
  99 } while (0)
 100
 101 /* Set a double from two 32 bit ints.  */
 102
 103 #define INSERT_WORDS(d,ix0,ix1)                                 \
 104 do {                                                            \
 105   ieee_double_shape_type iw_u;                                  \
 106   iw_u.parts.msw = (ix0);                                       \
 107   iw_u.parts.lsw = (ix1);                                       \
 108   (d) = iw_u.value;                                             \
 109 } while (0)
 110
 111 /* Set the more significant 32 bits of a double from an int.  */
 112
 113 #define SET_HIGH_WORD(d,v)                                      \
 114 do {                                                            \
 115   ieee_double_shape_type sh_u;                                  \
 116   sh_u.value = (d);                                             \
 117   sh_u.parts.msw = (v);                                         \
 118   (d) = sh_u.value;                                             \
 119 } while (0)
 120
 121 /* Set the less significant 32 bits of a double from an int.  */
 122
 123 #define SET_LOW_WORD(d,v)                                       \
 124 do {                                                            \
 125   ieee_double_shape_type sl_u;                                  \
 126   sl_u.value = (d);                                             \
 127   sl_u.parts.lsw = (v);                                         \
 128   (d) = sl_u.value;                                             \
 129 } while (0)
 130
 131 /* A union which permits us to convert between a float and a 32 bit
 132    int.  */
 133
 134 typedef union
 135 {
 136   float value;
 137   u_int32_t word;
 138 } ieee_float_shape_type;
 139
 140 /* Get a 32 bit int from a float.  */
 141
 142 #define GET_FLOAT_WORD(i,d)                                     \
 143 do {                                                            \
 144   ieee_float_shape_type gf_u;                                   \
 145   gf_u.value = (d);                                             \
 146   (i) = gf_u.word;                                              \
 147 } while (0)
 148
 149 /* Set a float from a 32 bit int.  */
 150
 151 #define SET_FLOAT_WORD(d,i)                                     \
 152 do {                                                            \
 153   ieee_float_shape_type sf_u;                                   \
 154   sf_u.word = (i);                                              \
 155   (d) = sf_u.value;                                             \
 156 } while (0)
 157
 158
 159 #ifdef __STDC__
 160 static const double
 161 #else
 162 static double
 163 #endif
 164 zero    =  0.0,
 165 one     =  1.0,
 166 two     =  2.0,
 167 two53   =  9007199254740992.0,  /* 0x43400000, 0x00000000 */
 168 two54   =  1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
 169 twom54  =  5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */
 170 huge   = 1.0e+300,
 171 tiny   = 1.0e-300;
 172
 173 #endif /* _MATH_PRIVATE_H_ */