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

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