1  /* { dg-do run } */
       2  /* { dg-require-effective-target avx2 } */
       3  /* { dg-options "-O2 -mavx2" } */
       4  
       5  #include <string.h>
       6  #include "ssse3-vals.h"
       7  #include "avx2-check.h"
       8  
       9  /* Test the 256-bit form */
      10  static void
      11  avx2_test_palignr256 (__m256i t1, __m256i t2, unsigned int imm, __m256i * r)
      12  {
      13    switch (imm)
      14      {
      15      case 0:
      16        *r = _mm256_alignr_epi8 (t1, t2, 0);
      17        break;
      18      case 1:
      19        *r = _mm256_alignr_epi8 (t1, t2, 1);
      20        break;
      21      case 2:
      22        *r = _mm256_alignr_epi8 (t1, t2, 2);
      23        break;
      24      case 3:
      25        *r = _mm256_alignr_epi8 (t1, t2, 3);
      26        break;
      27      case 4:
      28        *r = _mm256_alignr_epi8 (t1, t2, 4);
      29        break;
      30      case 5:
      31        *r = _mm256_alignr_epi8 (t1, t2, 5);
      32        break;
      33      case 6:
      34        *r = _mm256_alignr_epi8 (t1, t2, 6);
      35        break;
      36      case 7:
      37        *r = _mm256_alignr_epi8 (t1, t2, 7);
      38        break;
      39      case 8:
      40        *r = _mm256_alignr_epi8 (t1, t2, 8);
      41        break;
      42      case 9:
      43        *r = _mm256_alignr_epi8 (t1, t2, 9);
      44        break;
      45      case 10:
      46        *r = _mm256_alignr_epi8 (t1, t2, 10);
      47        break;
      48      case 11:
      49        *r = _mm256_alignr_epi8 (t1, t2, 11);
      50        break;
      51      case 12:
      52        *r = _mm256_alignr_epi8 (t1, t2, 12);
      53        break;
      54      case 13:
      55        *r = _mm256_alignr_epi8 (t1, t2, 13);
      56        break;
      57      case 14:
      58        *r = _mm256_alignr_epi8 (t1, t2, 14);
      59        break;
      60      case 15:
      61        *r = _mm256_alignr_epi8 (t1, t2, 15);
      62        break;
      63      case 16:
      64        *r = _mm256_alignr_epi8 (t1, t2, 16);
      65        break;
      66      case 17:
      67        *r = _mm256_alignr_epi8 (t1, t2, 17);
      68        break;
      69      case 18:
      70        *r = _mm256_alignr_epi8 (t1, t2, 18);
      71        break;
      72      case 19:
      73        *r = _mm256_alignr_epi8 (t1, t2, 19);
      74        break;
      75      case 20:
      76        *r = _mm256_alignr_epi8 (t1, t2, 20);
      77        break;
      78      case 21:
      79        *r = _mm256_alignr_epi8 (t1, t2, 21);
      80        break;
      81      case 22:
      82        *r = _mm256_alignr_epi8 (t1, t2, 22);
      83        break;
      84      case 23:
      85        *r = _mm256_alignr_epi8 (t1, t2, 23);
      86        break;
      87      case 24:
      88        *r = _mm256_alignr_epi8 (t1, t2, 24);
      89        break;
      90      case 25:
      91        *r = _mm256_alignr_epi8 (t1, t2, 25);
      92        break;
      93      case 26:
      94        *r = _mm256_alignr_epi8 (t1, t2, 26);
      95        break;
      96      case 27:
      97        *r = _mm256_alignr_epi8 (t1, t2, 27);
      98        break;
      99      case 28:
     100        *r = _mm256_alignr_epi8 (t1, t2, 28);
     101        break;
     102      case 29:
     103        *r = _mm256_alignr_epi8 (t1, t2, 29);
     104        break;
     105      case 30:
     106        *r = _mm256_alignr_epi8 (t1, t2, 30);
     107        break;
     108      case 31:
     109        *r = _mm256_alignr_epi8 (t1, t2, 31);
     110        break;
     111      default:
     112        *r = _mm256_alignr_epi8 (t1, t2, 32);
     113        break;
     114      }
     115  }
     116  
     117  /* Routine to manually compute the results */
     118  static void
     119  compute_correct_result_256 (int *i1, int *i2, unsigned int imm, int *r)
     120  {
     121    char buf[32];
     122    char *bout = (char *) r;
     123    int i;
     124  
     125    /* Fill lowers 128 bit of ymm */
     126    memcpy (&buf[0], i2, 16);
     127    memcpy (&buf[16], i1, 16);
     128  
     129    for (i = 0; i < 16; i++)
     130      if (imm >= 32 || imm + i >= 32)
     131        bout[i] = 0;
     132      else
     133        bout[i] = buf[imm + i];
     134  
     135    /* Fill higher 128 bit of ymm */
     136    bout += 16;
     137    memcpy (&buf[0], i2 + 4, 16);
     138    memcpy (&buf[16], i1 + 4, 16);
     139  
     140    for (i = 0; i < 16; i++)
     141      if (imm >= 32 || imm + i >= 32)
     142        bout[i] = 0;
     143      else
     144        bout[i] = buf[imm + i];
     145  }
     146  
     147  static void
     148  avx2_test (void)
     149  {
     150    int i;
     151    int ck[8];
     152    int r[8];
     153    unsigned int imm;
     154    int fail = 0;
     155  
     156    union256i_q s1, s2, d;
     157  
     158    for (i = 0; i < 256; i += 16)
     159      for (imm = 0; imm < 100; imm++)
     160        {
     161  	/* Recompute the results for 256-bits */
     162  	compute_correct_result_256 (&vals[i + 0], &vals[i + 8], imm, ck);
     163  
     164  	s1.x = _mm256_loadu_si256 ((__m256i *) & vals[i + 0]);
     165  	s2.x = _mm256_loadu_si256 ((__m256i *) & vals[i + 8]);
     166  
     167  	/* Run the 256-bit tests */
     168  	avx2_test_palignr256 (s1.x, s2.x, imm, &d.x);
     169  
     170  	_mm256_storeu_si256 ((__m256i *) r, d.x);
     171  
     172  	fail += checkVi (r, ck, 8);
     173        }
     174  
     175    if (fail != 0)
     176      abort ();
     177  }