gcc/testsuite/gcc.dg/vect/vect-early-break_75.c

   1 /* { dg-add-options vect_early_break } */
   2 /* { dg-require-effective-target vect_early_break_hw } */
   3 /* { dg-require-effective-target vect_int } */
   4
   5 /* { dg-additional-options "-O3" } */
   6 /* { dg-final { scan-tree-dump "LOOP VECTORIZED" "vect" { target { ! "x86_64-*-* i?86-*-* arm*-*-*" } } } } */
   7
   8 #include <limits.h>
   9 #include <assert.h>
  10
  11 #include "tree-vect.h"
  12
  13 #if __INT_MAX__ > 2147483647L
  14 # if __INT_MAX__ >= 9223372036854775807L
  15 #  define BITSIZEOF_INT 64
  16 # else
  17 #  define BITSIZEOF_INT 32
  18 # endif
  19 #else
  20 # if __INT_MAX__ >= 2147483647L
  21 #  define BITSIZEOF_INT 32
  22 # else
  23 #  define BITSIZEOF_INT 16
  24 # endif
  25 #endif
  26
  27 #if __LONG_MAX__ > 2147483647L
  28 # if __LONG_MAX__ >= 9223372036854775807L
  29 #  define BITSIZEOF_LONG 64
  30 # else
  31 #  define BITSIZEOF_LONG 32
  32 # endif
  33 #else
  34 # define BITSIZEOF_LONG 32
  35 #endif
  36
  37 #if __LONG_LONG_MAX__ > 2147483647L
  38 # if __LONG_LONG_MAX__ >= 9223372036854775807L
  39 #  define BITSIZEOF_LONG_LONG 64
  40 # else
  41 #  define BITSIZEOF_LONG_LONG 32
  42 # endif
  43 #else
  44 # define BITSIZEOF_LONG_LONG 32
  45 #endif
  46
  47 #define MAKE_FUNS(suffix, type)                                         \
  48 __attribute__((noinline)) \
  49 int my_ffs##suffix(type x) {                                            \
  50     int i;                                                              \
  51     if (x == 0)                                                         \
  52          return 0;                                                      \
  53     for (i = 0; i < CHAR_BIT * sizeof (type); i++)                      \
  54         if (x & ((type) 1  << i))                                       \
  55             break;                                                      \
  56     return i + 1;                                                       \
  57 }                                                                       \
  58                                                                         \
  59 int my_ctz##suffix(type x) {                                            \
  60     int i;                                                              \
  61     for (i = 0; i < CHAR_BIT * sizeof (type); i++)                      \
  62         if (x & ((type) 1  << i))                                       \
  63             break;                                                      \
  64     return i;                                                           \
  65 }                                                                       \
  66                                                                         \
  67 __attribute__((noinline)) \
  68 int my_clz##suffix(type x) {                                            \
  69     int i;                                                              \
  70     for (i = 0; i < CHAR_BIT * sizeof (type); i++)                      \
  71         if (x & ((type) 1 << ((CHAR_BIT * sizeof (type)) - i - 1)))     \
  72             break;                                                      \
  73     return i;                                                           \
  74 }                                                                       \
  75                                                                         \
  76 int my_clrsb##suffix(type x) {                                          \
  77     int i;                                                              \
  78     int leading = (x >> CHAR_BIT * sizeof (type) - 1) & 1;              \
  79     for (i = 1; i < CHAR_BIT * sizeof (type); i++)                      \
  80         if (((x >> ((CHAR_BIT * sizeof (type)) - i - 1)) & 1)           \
  81             != leading)                                                 \
  82             break;                                                      \
  83     return i - 1;                                                       \
  84 }                                                                       \
  85                                                                         \
  86 __attribute__((noinline)) \
  87 int my_popcount##suffix(type x) {                                       \
  88     int i;                                                              \
  89     int count = 0;                                                      \
  90     for (i = 0; i < CHAR_BIT * sizeof (type); i++)                      \
  91         if (x & ((type) 1 << i))                                        \
  92             count++;                                                    \
  93     return count;                                                       \
  94 }                                                                       \
  95                                                                         \
  96 __attribute__((noinline)) \
  97 int my_parity##suffix(type x) {                                         \
  98     int i;                                                              \
  99     int count = 0;                                                      \
 100     for (i = 0; i < CHAR_BIT * sizeof (type); i++)                      \
 101         if (x & ((type) 1 << i))                                        \
 102             count++;                                                    \
 103     return count & 1;                                                   \
 104 }
 105
 106 MAKE_FUNS (ll, unsigned long long);
 107
 108 extern void abort (void);
 109 extern void exit (int);
 110
 111 #define NUMS16                                  \
 112   {                                             \
 113     0x0000U,                                    \
 114     0x0001U,                                    \
 115     0x8000U,                                    \
 116     0x0002U,                                    \
 117     0x4000U,                                    \
 118     0x0100U,                                    \
 119     0x0080U,                                    \
 120     0xa5a5U,                                    \
 121     0x5a5aU,                                    \
 122     0xcafeU,                                    \
 123     0xffffU                                     \
 124   }
 125
 126 #define NUMS32                                  \
 127   {                                             \
 128     0x00000000UL,                               \
 129     0x00000001UL,                               \
 130     0x80000000UL,                               \
 131     0x00000002UL,                               \
 132     0x40000000UL,                               \
 133     0x00010000UL,                               \
 134     0x00008000UL,                               \
 135     0xa5a5a5a5UL,                               \
 136     0x5a5a5a5aUL,                               \
 137     0xcafe0000UL,                               \
 138     0x00cafe00UL,                               \
 139     0x0000cafeUL,                               \
 140     0xffffffffUL                                \
 141   }
 142
 143 #define NUMS64                                  \
 144   {                                             \
 145     0x0000000000000000ULL,                      \
 146     0x0000000000000001ULL,                      \
 147     0x8000000000000000ULL,                      \
 148     0x0000000000000002ULL,                      \
 149     0x4000000000000000ULL,                      \
 150     0x0000000100000000ULL,                      \
 151     0x0000000080000000ULL,                      \
 152     0xa5a5a5a5a5a5a5a5ULL,                      \
 153     0x5a5a5a5a5a5a5a5aULL,                      \
 154     0xcafecafe00000000ULL,                      \
 155     0x0000cafecafe0000ULL,                      \
 156     0x00000000cafecafeULL,                      \
 157     0xffffffffffffffffULL                       \
 158   }
 159
 160 unsigned int ints[] =
 161 #if BITSIZEOF_INT == 64
 162 NUMS64;
 163 #elif BITSIZEOF_INT == 32
 164 NUMS32;
 165 #else
 166 NUMS16;
 167 #endif
 168
 169 unsigned long longs[] =
 170 #if BITSIZEOF_LONG == 64
 171 NUMS64;
 172 #else
 173 NUMS32;
 174 #endif
 175
 176 unsigned long long longlongs[] =
 177 #if BITSIZEOF_LONG_LONG == 64
 178 NUMS64;
 179 #else
 180 NUMS32;
 181 #endif
 182
 183 #define N(table) (sizeof (table) / sizeof (table[0]))
 184
 185 int
 186 main (void)
 187 {
 188   int i;
 189
 190   check_vect ();
 191
 192 #pragma GCC novector
 193   for (i = 0; i < N(longlongs); i++)
 194     {
 195       if (__builtin_ffsll (longlongs[i]) != my_ffsll (longlongs[i]))
 196         abort ();
 197       if (longlongs[i] != 0
 198           && __builtin_clzll (longlongs[i]) != my_clzll (longlongs[i]))
 199         abort ();
 200       if (longlongs[i] != 0
 201           && __builtin_ctzll (longlongs[i]) != my_ctzll (longlongs[i]))
 202         abort ();
 203       if (__builtin_clrsbll (longlongs[i]) != my_clrsbll (longlongs[i]))
 204         abort ();
 205       if (__builtin_popcountll (longlongs[i]) != my_popcountll (longlongs[i]))
 206         abort ();
 207       if (__builtin_parityll (longlongs[i]) != my_parityll (longlongs[i]))
 208         abort ();
 209     }
 210
 211   /* Test constant folding.  */
 212
 213 #define TEST(x, suffix)                                                 \
 214   if (__builtin_ffs##suffix (x) != my_ffs##suffix (x))                  \
 215     abort ();                                                           \
 216
 217 #if BITSIZEOF_LONG_LONG == 64
 218   TEST(0x0000000000000000ULL, ll);
 219   TEST(0x0000000000000001ULL, ll);
 220   TEST(0x8000000000000000ULL, ll);
 221   TEST(0x0000000000000002ULL, ll);
 222   TEST(0x4000000000000000ULL, ll);
 223   TEST(0x0000000100000000ULL, ll);
 224   TEST(0x0000000080000000ULL, ll);
 225   TEST(0xa5a5a5a5a5a5a5a5ULL, ll);
 226   TEST(0x5a5a5a5a5a5a5a5aULL, ll);
 227   TEST(0xcafecafe00000000ULL, ll);
 228   TEST(0x0000cafecafe0000ULL, ll);
 229   TEST(0x00000000cafecafeULL, ll);
 230   TEST(0xffffffffffffffffULL, ll);
 231 #endif
 232
 233   exit (0);
 234 }