gcc/testsuite/gcc.target/powerpc/m128-check.h

   1 #include <stdio.h>
   2
   3 #define NO_WARN_X86_INTRINSICS 1
   4
   5 #ifdef __ALTIVEC__
   6 #include <xmmintrin.h>
   7
   8 #ifdef __VSX_SSE2__
   9 #include <emmintrin.h>
  10
  11 typedef union
  12 {
  13   __m128i x;
  14   char a[16];
  15 } union128i_b;
  16
  17 typedef union
  18 {
  19   __m128i x;
  20   unsigned char a[16];
  21 } union128i_ub;
  22
  23 typedef union
  24 {
  25   __m128i x;
  26   short a[8];
  27 } union128i_w;
  28
  29 typedef union
  30 {
  31   __m128i x;
  32   unsigned short a[8];
  33 } union128i_uw;
  34
  35 typedef union
  36 {
  37   __m128i x;
  38   int a[4];
  39 } union128i_d;
  40
  41 typedef union
  42 {
  43   __m128i x;
  44   unsigned int a[4];
  45 } union128i_ud;
  46
  47 #if __VSX__
  48 typedef union
  49 {
  50   __m128i x;
  51   long long a[2];
  52 } union128i_q;
  53
  54 typedef union
  55 {
  56   __m128i x;
  57   unsigned long long a[2];
  58 } union128i_uq;
  59
  60
  61 typedef union
  62 {
  63   __m128d x;
  64   double a[2];
  65 } union128d;
  66 #endif
  67
  68 #endif
  69 typedef union
  70 {
  71   __m128  x;
  72   float a[4];
  73   int i[4];
  74 } union128;
  75
  76 #ifndef ARRAY_SIZE
  77 #define ARRAY_SIZE(A) (sizeof (A) / sizeof ((A)[0]))
  78 #endif
  79
  80 #ifdef DEBUG
  81 #define PRINTF printf
  82 #else
  83 #define PRINTF(...)
  84 #endif
  85
  86 #define CHECK_EXP(UINON_TYPE, VALUE_TYPE, FMT)          \
  87 static int                                              \
  88 __attribute__((optimize ("no-strict-aliasing")))        \
  89 __attribute__((noinline, unused))                       \
  90 check_##UINON_TYPE (UINON_TYPE u, const VALUE_TYPE *v)  \
  91 {                                                       \
  92   int i;                                                \
  93   int err = 0;                                          \
  94                                                         \
  95   for (i = 0; i < ARRAY_SIZE (u.a); i++)                \
  96     if (u.a[i] != v[i])                                 \
  97       {                                                 \
  98         err++;                                          \
  99         PRINTF ("%i: " FMT " != " FMT "\n",             \
 100                 i, v[i], u.a[i]);                       \
 101       }                                                 \
 102   return err;                                           \
 103 }
 104
 105 #ifdef __VSX_SSE2__
 106 CHECK_EXP (union128i_b, char, "%d")
 107 CHECK_EXP (union128i_ub, unsigned char, "%d")
 108 CHECK_EXP (union128i_w, short, "%d")
 109 CHECK_EXP (union128i_uw, unsigned short, "%d")
 110 CHECK_EXP (union128i_d, int, "0x%x")
 111 CHECK_EXP (union128i_ud, unsigned int, "0x%x")
 112 #ifdef __VSX__
 113 CHECK_EXP (union128i_q, long long, "0x%llx")
 114 CHECK_EXP (union128i_uq, unsigned long long, "0x%llx")
 115 CHECK_EXP (union128d, double, "%f")
 116 #endif
 117 #endif
 118
 119 CHECK_EXP (union128, float, "%f")
 120
 121 #define ESP_FLOAT 0.000001
 122 #define ESP_DOUBLE 0.000001
 123 #define CHECK_ARRAY(ARRAY, TYPE, FMT)                   \
 124 static int                                              \
 125 __attribute__((noinline, unused))                       \
 126 checkV##ARRAY (const TYPE *v, const TYPE *e, int n)     \
 127 {                                                       \
 128   int i;                                                \
 129   int err = 0;                                          \
 130                                                         \
 131   for (i = 0; i < n; i++)                               \
 132     if (v[i] != e[i])                                   \
 133       {                                                 \
 134         err++;                                          \
 135         PRINTF ("%i: " FMT " != " FMT "\n",             \
 136                 i, v[i], e[i]);                 \
 137       }                                                 \
 138   return err;                                           \
 139 }
 140
 141 CHECK_ARRAY(c, char, "0x%hhx")
 142 CHECK_ARRAY(s, short, "0x%hx")
 143 CHECK_ARRAY(i, int, "0x%x")
 144 CHECK_ARRAY(l, long long, "0x%llx")
 145 CHECK_ARRAY(uc, unsigned char, "0x%hhx")
 146 CHECK_ARRAY(us, unsigned short, "0x%hx")
 147 CHECK_ARRAY(ui, unsigned int, "0x%x")
 148 CHECK_ARRAY(ul, unsigned long long, "0x%llx")
 149
 150
 151
 152 #define CHECK_FP_ARRAY(ARRAY, TYPE, ESP, FMT)                   \
 153 static int                                              \
 154 __attribute__((noinline, unused))                       \
 155 checkV##ARRAY (const TYPE *v, const TYPE *e, int n)     \
 156 {                                                       \
 157   int i;                                                \
 158   int err = 0;                                          \
 159                                                         \
 160   for (i = 0; i < n; i++)                               \
 161     if (v[i] > (e[i] + (ESP)) || v[i] < (e[i] - (ESP))) \
 162     if (e[i] != v[i])                                   \
 163       {                                                 \
 164         err++;                                          \
 165         PRINTF ("%i: " FMT " != " FMT "\n",             \
 166                 i, v[i], e[i]);                 \
 167       }                                                 \
 168   return err;                                           \
 169 }
 170
 171 CHECK_FP_ARRAY (d, double, ESP_DOUBLE, "%f")
 172 CHECK_FP_ARRAY (f, float, ESP_FLOAT, "%f")
 173
 174 #ifdef NEED_IEEE754_FLOAT
 175 union ieee754_float
 176 {
 177    float d;
 178    struct
 179    {
 180       unsigned long frac : 23;
 181       unsigned exp : 8;
 182       unsigned sign : 1;
 183    } bits __attribute__((packed));
 184 };
 185 #endif
 186
 187 #ifdef NEED_IEEE754_DOUBLE
 188 union ieee754_double
 189 {
 190    double d;
 191    struct
 192    {
 193       unsigned long frac1 : 32;
 194       unsigned long frac0 : 20;
 195       unsigned exp : 11;
 196       unsigned sign : 1;
 197    } bits __attribute__((packed));
 198 };
 199 #endif
 200
 201 #define CHECK_FP_EXP(UINON_TYPE, VALUE_TYPE, ESP, FMT)          \
 202 static int                                                      \
 203 __attribute__((noinline, unused))                               \
 204 check_fp_##UINON_TYPE (UINON_TYPE u, const VALUE_TYPE *v)       \
 205 {                                                               \
 206   int i;                                                        \
 207   int err = 0;                                                  \
 208                                                                 \
 209   for (i = 0; i < ARRAY_SIZE (u.a); i++)                        \
 210     if (u.a[i] > (v[i] + (ESP)) || u.a[i] < (v[i] - (ESP)))     \
 211       {                                                         \
 212         err++;                                                  \
 213         PRINTF ("%i: " FMT " != " FMT "\n",                     \
 214                 i, v[i], u.a[i]);                               \
 215       }                                                         \
 216   return err;                                                   \
 217 }
 218
 219 CHECK_FP_EXP (union128, float, ESP_FLOAT, "%f")
 220 #ifdef __VSX_SSE2__
 221 CHECK_FP_EXP (union128d, double, ESP_DOUBLE, "%f")
 222 #endif
 223 #endif /* __ALTIVEC__ */