gcc/testsuite/gcc.target/avr/torture/builtin_insert_bits-1.c

   1 /* { dg-do run } */
   2
   3 #include <stdlib.h>
   4
   5 #define MASK_F(M)                                       \
   6   (0                                                    \
   7    | ((0xf == (0xf & ((M) >> (4*0)))) ? (1 << 0) : 0)   \
   8    | ((0xf == (0xf & ((M) >> (4*1)))) ? (1 << 1) : 0)   \
   9    | ((0xf == (0xf & ((M) >> (4*2)))) ? (1 << 2) : 0)   \
  10    | ((0xf == (0xf & ((M) >> (4*3)))) ? (1 << 3) : 0)   \
  11    | ((0xf == (0xf & ((M) >> (4*4)))) ? (1 << 4) : 0)   \
  12    | ((0xf == (0xf & ((M) >> (4*5)))) ? (1 << 5) : 0)   \
  13    | ((0xf == (0xf & ((M) >> (4*6)))) ? (1 << 6) : 0)   \
  14    | ((0xf == (0xf & ((M) >> (4*7)))) ? (1 << 7) : 0)   \
  15    | 0)
  16
  17 #define MASK_0_7(M)                                     \
  18   (0                                                    \
  19    | ((8 > (0xf & ((M) >> (4*0)))) ? (1 << 0) : 0)      \
  20    | ((8 > (0xf & ((M) >> (4*1)))) ? (1 << 1) : 0)      \
  21    | ((8 > (0xf & ((M) >> (4*2)))) ? (1 << 2) : 0)      \
  22    | ((8 > (0xf & ((M) >> (4*3)))) ? (1 << 3) : 0)      \
  23    | ((8 > (0xf & ((M) >> (4*4)))) ? (1 << 4) : 0)      \
  24    | ((8 > (0xf & ((M) >> (4*5)))) ? (1 << 5) : 0)      \
  25    | ((8 > (0xf & ((M) >> (4*6)))) ? (1 << 6) : 0)      \
  26    | ((8 > (0xf & ((M) >> (4*7)))) ? (1 << 7) : 0)      \
  27    | 0)
  28
  29 #define INSERT_BITS(M,B,V)                                              \
  30   (__extension__({                                                      \
  31       unsigned char _n, _r = 0;                                         \
  32       _n = 0xf & (M >> (4*0)); if (_n<8) _r |= (!!(B & (1 << _n))) << 0; \
  33       _n = 0xf & (M >> (4*1)); if (_n<8) _r |= (!!(B & (1 << _n))) << 1; \
  34       _n = 0xf & (M >> (4*2)); if (_n<8) _r |= (!!(B & (1 << _n))) << 2; \
  35       _n = 0xf & (M >> (4*3)); if (_n<8) _r |= (!!(B & (1 << _n))) << 3; \
  36       _n = 0xf & (M >> (4*4)); if (_n<8) _r |= (!!(B & (1 << _n))) << 4; \
  37       _n = 0xf & (M >> (4*5)); if (_n<8) _r |= (!!(B & (1 << _n))) << 5; \
  38       _n = 0xf & (M >> (4*6)); if (_n<8) _r |= (!!(B & (1 << _n))) << 6; \
  39       _n = 0xf & (M >> (4*7)); if (_n<8) _r |= (!!(B & (1 << _n))) << 7; \
  40       (unsigned char) ((V) & MASK_F(M)) | _r;                           \
  41     }))
  42
  43 #define MASK_USED(M) (MASK_F(M) | MASK_0_7(M))
  44
  45 #define TEST2(M,B,V)                                    \
  46   do {                                                  \
  47     __asm volatile (";" #M);                            \
  48     r1 = MASK_USED (M)                                  \
  49       & __builtin_avr_insert_bits (M,B,V);              \
  50     r2 = INSERT_BITS (M,B,V);                           \
  51     if (r1 != r2)                                       \
  52       abort ();                                         \
  53   } while(0)
  54
  55 #define TEST1(M,X)                                      \
  56   do {                                                  \
  57     TEST2 (M,X,0x00); TEST2 (M,0x00,X);                 \
  58     TEST2 (M,X,0xff); TEST2 (M,0xff,X);                 \
  59     TEST2 (M,X,0xaa); TEST2 (M,0xaa,X);                 \
  60     TEST2 (M,X,0xcc); TEST2 (M,0xcc,X);                 \
  61     TEST2 (M,X,0x96); TEST2 (M,0x96,X);                 \
  62   } while(0)
  63
  64
  65
  66 void test8 (void)
  67 {
  68   unsigned char r1, r2;
  69   unsigned char ib;
  70
  71   static const unsigned char V[] =
  72     {
  73       0, 0xaa, 0xcc, 0xf0, 0xff, 0x5b, 0x4d
  74     };
  75
  76   for (ib = 0; ib < sizeof (V) / sizeof (*V); ib++)
  77     {
  78       unsigned char b = V[ib];
  79
  80       TEST1 (0x76543210, b);
  81       TEST1 (0x3210ffff, b);
  82       TEST1 (0x67452301, b);
  83       TEST1 (0xf0f1f2f3, b);
  84       TEST1 (0xff10ff54, b);
  85       TEST1 (0x01234567, b);
  86       TEST1 (0xff765f32, b);
  87     }
  88 }
  89
  90 /****************************************************************/
  91
  92 int main()
  93 {
  94   test8();
  95
  96   exit(0);
  97 }