gcc/testsuite/gcc.target/powerpc/p8vector-builtin-5.c

   1 /* { dg-do compile { target { powerpc*-*-* } } } */
   2 /* { dg-skip-if "" { powerpc*-*-darwin* } } */
   3 /* { dg-require-effective-target powerpc_p8vector_ok } */
   4 /* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
   5 /* { dg-options "-mcpu=power8 -O2 -ftree-vectorize -fvect-cost-model=dynamic -fno-unroll-loops -fno-unroll-all-loops" } */
   6
   7 #include <altivec.h>
   8
   9 #ifndef SIZE
  10 #define SIZE 1024
  11 #endif
  12
  13 #ifndef ALIGN
  14 #define ALIGN 32
  15 #endif
  16
  17 #ifndef ATTR_ALIGN
  18 #define ATTR_ALIGN __attribute__((__aligned__(ALIGN)))
  19 #endif
  20
  21 #define DOIT(TYPE, PREFIX)                                              \
  22 TYPE PREFIX ## _eqv_builtin (TYPE a, TYPE b)                            \
  23 {                                                                       \
  24   return vec_eqv (a, b);                                                \
  25 }                                                                       \
  26                                                                         \
  27 TYPE PREFIX ## _eqv_arith (TYPE a, TYPE b)                              \
  28 {                                                                       \
  29   return ~(a ^ b);                                                      \
  30 }                                                                       \
  31                                                                         \
  32 TYPE PREFIX ## _nand_builtin (TYPE a, TYPE b)                           \
  33 {                                                                       \
  34   return vec_nand (a, b);                                               \
  35 }                                                                       \
  36                                                                         \
  37 TYPE PREFIX ## _nand_arith1 (TYPE a, TYPE b)                            \
  38 {                                                                       \
  39   return ~(a & b);                                                      \
  40 }                                                                       \
  41                                                                         \
  42 TYPE PREFIX ## _nand_arith2 (TYPE a, TYPE b)                            \
  43 {                                                                       \
  44   return (~a) | (~b);                                                   \
  45 }                                                                       \
  46                                                                         \
  47 TYPE PREFIX ## _orc_builtin (TYPE a, TYPE b)                            \
  48 {                                                                       \
  49   return vec_orc (a, b);                                                \
  50 }                                                                       \
  51                                                                         \
  52 TYPE PREFIX ## _orc_arith1 (TYPE a, TYPE b)                             \
  53 {                                                                       \
  54   return (~ a) | b;                                                     \
  55 }                                                                       \
  56                                                                         \
  57 TYPE PREFIX ## _orc_arith2 (TYPE a, TYPE b)                             \
  58 {                                                                       \
  59   return a | (~ b);                                                     \
  60 }
  61
  62 #define DOIT_FLOAT(TYPE, PREFIX)                                        \
  63 TYPE PREFIX ## _eqv_builtin (TYPE a, TYPE b)                            \
  64 {                                                                       \
  65   return vec_eqv (a, b);                                                \
  66 }                                                                       \
  67                                                                         \
  68 TYPE PREFIX ## _nand_builtin (TYPE a, TYPE b)                           \
  69 {                                                                       \
  70   return vec_nand (a, b);                                               \
  71 }                                                                       \
  72                                                                         \
  73 TYPE PREFIX ## _orc_builtin (TYPE a, TYPE b)                            \
  74 {                                                                       \
  75   return vec_orc (a, b);                                                \
  76 }
  77
  78 typedef vector signed char              sign_char_vec;
  79 typedef vector short                    sign_short_vec;
  80 typedef vector int                      sign_int_vec;
  81 typedef vector long long                sign_llong_vec;
  82
  83 typedef vector unsigned char            uns_char_vec;
  84 typedef vector unsigned short           uns_short_vec;
  85 typedef vector unsigned int             uns_int_vec;
  86 typedef vector unsigned long long       uns_llong_vec;
  87
  88 typedef vector float                    float_vec;
  89 typedef vector double                   double_vec;
  90
  91 DOIT(sign_char_vec,     sign_char)
  92 DOIT(sign_short_vec,    sign_short)
  93 DOIT(sign_int_vec,      sign_int)
  94 DOIT(sign_llong_vec,    sign_llong)
  95
  96 DOIT(uns_char_vec,      uns_char)
  97 DOIT(uns_short_vec,     uns_short)
  98 DOIT(uns_int_vec,       uns_int)
  99 DOIT(uns_llong_vec,     uns_llong)
 100
 101 DOIT_FLOAT(float_vec,   float)
 102 DOIT_FLOAT(double_vec,  double)
 103
 104 /* { dg-final { scan-assembler-times "xxleqv"  18 } } */
 105 /* { dg-final { scan-assembler-times "xxlnand" 26 } } */
 106 /* { dg-final { scan-assembler-times "xxlorc"  26 } } */