gcc/testsuite/gcc.target/powerpc/pr83677.c

   1 /* { dg-do run { target { powerpc*-*-* && { lp64 && p9vector_hw } } } } */
   2 /* { dg-options "-mdejagnu-cpu=power9 -O2 " } */
   3
   4 /* PR83677: This test case used to fail due to mis-generation of the
   5    xxpermr instruction.  It requires inlining to create enough register
   6    pressure that we generate xxpermr rather than vpermr.  */
   7
   8 #include <altivec.h>
   9
  10 void v_expand_u8(vector unsigned char* a, vector unsigned short* b0, vector unsigned short* b1)
  11 {
  12 #if __LITTLE_ENDIAN__
  13   *b0 = (vector unsigned short)vec_mergeh(*a, vec_splats((unsigned char)0));
  14   *b1 = (vector unsigned short)vec_mergel(*a, vec_splats((unsigned char)0));
  15 #else
  16   *b0 = (vector unsigned short)vec_mergeh(vec_splats((unsigned char)0), *a);
  17   *b1 = (vector unsigned short)vec_mergel(vec_splats((unsigned char)0), *a);
  18 #endif
  19 }
  20
  21 void v_expand_u16(vector unsigned short* a, vector unsigned int* b0, vector unsigned int* b1)
  22 {
  23 #if __LITTLE_ENDIAN__
  24     *b0 = (vector unsigned int)vec_mergeh(*a, vec_splats((unsigned short)0));
  25     *b1 = (vector unsigned int)vec_mergel(*a, vec_splats((unsigned short)0));
  26 #else
  27     *b0 = (vector unsigned int)vec_mergeh(vec_splats((unsigned short)0), *a);
  28     *b1 = (vector unsigned int)vec_mergel(vec_splats((unsigned short)0), *a);
  29 #endif
  30 }
  31
  32 void v_load_deinterleave_u8(unsigned char *ptr, vector unsigned char* a, vector unsigned char* b, vector unsigned char* c)
  33 {
  34     vector unsigned char v1 = vec_xl( 0, ptr);
  35     vector unsigned char v2 = vec_xl(16, ptr);
  36     vector unsigned char v3 = vec_xl(32, ptr);
  37
  38     static const vector unsigned char a12_perm = {0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 0, 0, 0, 0, 0};
  39     static const vector unsigned char a123_perm = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 17, 20, 23, 26, 29};
  40     *a = vec_perm(vec_perm(v1, v2, a12_perm), v3, a123_perm);
  41
  42     static const vector unsigned char b12_perm = {1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 0, 0, 0, 0, 0};
  43     static const vector unsigned char b123_perm = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 18, 21, 24, 27, 30};
  44     *b = vec_perm(vec_perm(v1, v2, b12_perm), v3, b123_perm);
  45
  46     static const vector unsigned char c12_perm = {2, 5, 8, 11, 14, 17, 20, 23, 26, 29, 0, 0, 0, 0, 0, 0};
  47     static const vector unsigned char c123_perm = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 19, 22, 25, 28, 31};
  48     *c = vec_perm(vec_perm(v1, v2, c12_perm), v3, c123_perm);
  49 }
  50
  51 void v_load_deinterleave_f32(float *ptr, vector float* a, vector float* b, vector float* c)
  52 {
  53     vector float v1 = vec_xl( 0, ptr);
  54     vector float v2 = vec_xl(16, ptr);
  55     vector float v3 = vec_xl(32, ptr);
  56
  57 #if __LITTLE_ENDIAN__
  58     vector float t1 = vec_sld(v3, v2, 8);
  59     vector float t2 = vec_sld(v1, v3, 8);
  60     vector float t3 = vec_sld(v2, v1, 8);
  61 #else
  62     vector float t1 = vec_sld(v2, v3, 8);
  63     vector float t2 = vec_sld(v3, v1, 8);
  64     vector float t3 = vec_sld(v1, v2, 8);
  65 #endif
  66
  67     static const vector unsigned char flp = {0, 1, 2, 3, 12, 13, 14, 15, 16, 17, 18, 19, 28, 29, 30, 31};
  68     *a = vec_perm(v1, t1, flp);
  69
  70     static const vector unsigned char flp2 = {28, 29, 30, 31, 0, 1, 2, 3, 12, 13, 14, 15, 16, 17, 18, 19};
  71     *b = vec_perm(v2, t2, flp2);
  72
  73     *c = vec_perm(t3, v3, flp);
  74 }
  75
  76 void v_store_interleave_f32(float *ptr, vector float a, vector float b, vector float c)
  77 {
  78     vector float hbc = vec_mergeh(b, c);
  79
  80     static const vector unsigned char ahbc = {0, 1, 2, 3, 16, 17, 18, 19, 20, 21, 22, 23, 4, 5, 6, 7};
  81     vec_xst(vec_perm(a, hbc, ahbc),  0, ptr);
  82
  83     vector float lab = vec_mergel(a, b);
  84 #if __LITTLE_ENDIAN__
  85     vec_xst(vec_sld(lab, hbc, 8), 16, ptr);
  86 #else
  87     vec_xst(vec_sld(hbc, lab, 8), 16, ptr);
  88 #endif
  89
  90     static const vector unsigned char clab = {8, 9, 10, 11, 24, 25, 26, 27, 28, 29, 30, 31, 12, 13, 14, 15};
  91     vec_xst(vec_perm(c, lab, clab), 32, ptr);
  92 }
  93
  94 vector float v_cvt_f32(vector unsigned int a)
  95 {
  96     return (vector float)vec_ctf(a, 0);
  97 }
  98
  99 void acc_simd_(const unsigned char* src, float* dst, const unsigned char* mask, int len)
 100 {
 101     int x = 0;
 102     const int cVectorWidth = 16;
 103
 104             for ( ; x <= len - cVectorWidth; x += cVectorWidth)
 105             {
 106                 vector unsigned char v_mask = vec_xl(0, mask + x);
 107                 v_mask = (vector unsigned char)vec_cmpeq(vec_splats((unsigned char)0), v_mask);
 108                 v_mask = (vector unsigned char)vec_nor(v_mask, v_mask);
 109                 vector unsigned char v_src0, v_src1, v_src2;
 110                 v_load_deinterleave_u8((unsigned char *)(src + (x * 3)), &v_src0, &v_src1, &v_src2);
 111                 v_src0 = v_src0 & v_mask;
 112                 v_src1 = v_src1 & v_mask;
 113                 v_src2 = v_src2 & v_mask;
 114
 115                 /* expand 16 uchar to 4 vectors which contains 4 uint */
 116                 vector unsigned short v_src00, v_src01, v_src10, v_src11, v_src20, v_src21;
 117                 v_expand_u8(&v_src0, &v_src00, &v_src01);
 118                 v_expand_u8(&v_src1, &v_src10, &v_src11);
 119                 v_expand_u8(&v_src2, &v_src20, &v_src21);
 120                 vector unsigned int v_src000, v_src001, v_src010, v_src011;
 121                 vector unsigned int v_src100, v_src101, v_src110, v_src111;
 122                 vector unsigned int v_src200, v_src201, v_src210, v_src211;
 123                 v_expand_u16(&v_src00, &v_src000, &v_src001);
 124                 v_expand_u16(&v_src01, &v_src010, &v_src011);
 125                 v_expand_u16(&v_src10, &v_src100, &v_src101);
 126                 v_expand_u16(&v_src11, &v_src110, &v_src111);
 127                 v_expand_u16(&v_src20, &v_src200, &v_src201);
 128                 v_expand_u16(&v_src21, &v_src210, &v_src211);
 129
 130                 vector float v_dst000, v_dst001, v_dst010, v_dst011;
 131                 vector float v_dst100, v_dst101, v_dst110, v_dst111;
 132                 vector float v_dst200, v_dst201, v_dst210, v_dst211;
 133                 v_load_deinterleave_f32(dst + (x * 3),        &v_dst000, &v_dst100, &v_dst200);
 134                 v_load_deinterleave_f32(dst + ((x + 4) * 3),  &v_dst001, &v_dst101, &v_dst201);
 135                 v_load_deinterleave_f32(dst + ((x + 8) * 3),  &v_dst010, &v_dst110, &v_dst210);
 136                 v_load_deinterleave_f32(dst + ((x + 12) * 3), &v_dst011, &v_dst111, &v_dst211);
 137
 138                 v_store_interleave_f32(dst + (x * 3),        vec_add(v_dst000, v_cvt_f32(v_src000)), vec_add(v_dst100, v_cvt_f32(v_src100)), vec_add(v_dst200, v_cvt_f32(v_src200)));
 139                 v_store_interleave_f32(dst + ((x + 4) * 3),  vec_add(v_dst001, v_cvt_f32(v_src001)), vec_add(v_dst101, v_cvt_f32(v_src101)), vec_add(v_dst201, v_cvt_f32(v_src201)));
 140                 v_store_interleave_f32(dst + ((x + 8) * 3),  vec_add(v_dst010, v_cvt_f32(v_src010)), vec_add(v_dst110, v_cvt_f32(v_src110)), vec_add(v_dst210, v_cvt_f32(v_src210)));
 141                 v_store_interleave_f32(dst + ((x + 12) * 3), vec_add(v_dst011, v_cvt_f32(v_src011)), vec_add(v_dst111, v_cvt_f32(v_src111)), vec_add(v_dst211, v_cvt_f32(v_src211)));
 142             }
 143     return;
 144 }
 145
 146 void acc_(const unsigned char* src, float* dst, const unsigned char* mask, int len)
 147 {
 148     int x = 0;
 149     src += (x * 3);
 150     dst += (x * 3);
 151     for( ; x < len; x++, src += 3, dst += 3 )
 152     {
 153         if( mask[x] ) /* if mask, R/G/B dst[] += src[] */
 154         {
 155             for( int k = 0; k < 3; k++ )
 156             {
 157                 dst[k] += src[k];
 158             }
 159         }
 160     }
 161     return;
 162 }
 163
 164 #define N 16
 165
 166 int main(int argc, char *argv[])
 167 {
 168     unsigned char __attribute__ ((aligned (16) )) mask[] = {0, 0, 0, 0,  0, 0, 0, 0,  0, 1, 0, 0,  1, 0, 0, 1};
 169     unsigned char __attribute__ ((aligned (16) )) src[3*N];
 170     float __attribute__ ((aligned (16) )) dst[3*N];
 171     float __attribute__ ((aligned (16) )) exp[3*N];
 172
 173     int i;
 174
 175     /* initialize src and dst */
 176     for (i=0; i<3*N; i++) src[i] = (unsigned char)(i*3);
 177     for (i=0; i<3*N; i++) {dst[i] = i * 1.0f; exp[i] = dst[i];}
 178
 179     acc_(src, exp, mask, N);
 180     acc_simd_(src, dst, mask, N);
 181
 182     for (i=0; i<N; i++)
 183     {
 184         if ((dst[3*i] != exp[3*i]) || (dst[3*i+1] != exp[3*i+1]) || (dst[3*i+2] != exp[3*i+2]))
 185           __builtin_abort ();
 186     }
 187
 188     return 0;
 189 }