gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld1_dup.c

   1 #include <arm_neon.h>
   2 #include "arm-neon-ref.h"
   3 #include "compute-ref-data.h"
   4
   5 /* Expected results.  */
   6 /* Chunk 0.  */
   7 VECT_VAR_DECL(expected0,int,8,8) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
   8                                         0xf0, 0xf0, 0xf0, 0xf0 };
   9 VECT_VAR_DECL(expected0,int,16,4) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
  10 VECT_VAR_DECL(expected0,int,32,2) [] = { 0xfffffff0, 0xfffffff0 };
  11 VECT_VAR_DECL(expected0,int,64,1) [] = { 0xfffffffffffffff0 };
  12 VECT_VAR_DECL(expected0,uint,8,8) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
  13                                          0xf0, 0xf0, 0xf0, 0xf0 };
  14 VECT_VAR_DECL(expected0,uint,16,4) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
  15 VECT_VAR_DECL(expected0,uint,32,2) [] = { 0xfffffff0, 0xfffffff0 };
  16 VECT_VAR_DECL(expected0,uint,64,1) [] = { 0xfffffffffffffff0 };
  17 VECT_VAR_DECL(expected0,poly,8,8) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
  18                                          0xf0, 0xf0, 0xf0, 0xf0 };
  19 VECT_VAR_DECL(expected0,poly,16,4) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
  20 VECT_VAR_DECL(expected0,hfloat,32,2) [] = { 0xc1800000, 0xc1800000 };
  21 VECT_VAR_DECL(expected0,int,8,16) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
  22                                          0xf0, 0xf0, 0xf0, 0xf0,
  23                                          0xf0, 0xf0, 0xf0, 0xf0,
  24                                          0xf0, 0xf0, 0xf0, 0xf0 };
  25 VECT_VAR_DECL(expected0,int,16,8) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0,
  26                                          0xfff0, 0xfff0, 0xfff0, 0xfff0 };
  27 VECT_VAR_DECL(expected0,int,32,4) [] = { 0xfffffff0, 0xfffffff0,
  28                                          0xfffffff0, 0xfffffff0 };
  29 VECT_VAR_DECL(expected0,int,64,2) [] = { 0xfffffffffffffff0,
  30                                          0xfffffffffffffff0 };
  31 VECT_VAR_DECL(expected0,uint,8,16) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
  32                                           0xf0, 0xf0, 0xf0, 0xf0,
  33                                           0xf0, 0xf0, 0xf0, 0xf0,
  34                                           0xf0, 0xf0, 0xf0, 0xf0 };
  35 VECT_VAR_DECL(expected0,uint,16,8) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0,
  36                                           0xfff0, 0xfff0, 0xfff0, 0xfff0 };
  37 VECT_VAR_DECL(expected0,uint,32,4) [] = { 0xfffffff0, 0xfffffff0,
  38                                           0xfffffff0, 0xfffffff0 };
  39 VECT_VAR_DECL(expected0,uint,64,2) [] = { 0xfffffffffffffff0,
  40                                           0xfffffffffffffff0 };
  41 VECT_VAR_DECL(expected0,poly,8,16) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
  42                                           0xf0, 0xf0, 0xf0, 0xf0,
  43                                           0xf0, 0xf0, 0xf0, 0xf0,
  44                                           0xf0, 0xf0, 0xf0, 0xf0 };
  45 VECT_VAR_DECL(expected0,poly,16,8) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0,
  46                                           0xfff0, 0xfff0, 0xfff0, 0xfff0 };
  47 VECT_VAR_DECL(expected0,hfloat,32,4) [] = { 0xc1800000, 0xc1800000,
  48                                             0xc1800000, 0xc1800000 };
  49
  50 /* Chunk 1.  */
  51 VECT_VAR_DECL(expected1,int,8,8) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
  52                                         0xf1, 0xf1, 0xf1, 0xf1 };
  53 VECT_VAR_DECL(expected1,int,16,4) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
  54 VECT_VAR_DECL(expected1,int,32,2) [] = { 0xfffffff1, 0xfffffff1 };
  55 VECT_VAR_DECL(expected1,int,64,1) [] = { 0xfffffffffffffff1 };
  56 VECT_VAR_DECL(expected1,uint,8,8) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
  57                                          0xf1, 0xf1, 0xf1, 0xf1 };
  58 VECT_VAR_DECL(expected1,uint,16,4) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
  59 VECT_VAR_DECL(expected1,uint,32,2) [] = { 0xfffffff1, 0xfffffff1 };
  60 VECT_VAR_DECL(expected1,uint,64,1) [] = { 0xfffffffffffffff1 };
  61 VECT_VAR_DECL(expected1,poly,8,8) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
  62                                          0xf1, 0xf1, 0xf1, 0xf1 };
  63 VECT_VAR_DECL(expected1,poly,16,4) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
  64 VECT_VAR_DECL(expected1,hfloat,32,2) [] = { 0xc1700000, 0xc1700000 };
  65 VECT_VAR_DECL(expected1,int,8,16) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
  66                                          0xf1, 0xf1, 0xf1, 0xf1,
  67                                          0xf1, 0xf1, 0xf1, 0xf1,
  68                                          0xf1, 0xf1, 0xf1, 0xf1 };
  69 VECT_VAR_DECL(expected1,int,16,8) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1,
  70                                          0xfff1, 0xfff1, 0xfff1, 0xfff1 };
  71 VECT_VAR_DECL(expected1,int,32,4) [] = { 0xfffffff1, 0xfffffff1,
  72                                          0xfffffff1, 0xfffffff1 };
  73 VECT_VAR_DECL(expected1,int,64,2) [] = { 0xfffffffffffffff1,
  74                                          0xfffffffffffffff1 };
  75 VECT_VAR_DECL(expected1,uint,8,16) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
  76                                           0xf1, 0xf1, 0xf1, 0xf1,
  77                                           0xf1, 0xf1, 0xf1, 0xf1,
  78                                           0xf1, 0xf1, 0xf1, 0xf1 };
  79 VECT_VAR_DECL(expected1,uint,16,8) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1,
  80                                           0xfff1, 0xfff1, 0xfff1, 0xfff1 };
  81 VECT_VAR_DECL(expected1,uint,32,4) [] = { 0xfffffff1, 0xfffffff1,
  82                                           0xfffffff1, 0xfffffff1 };
  83 VECT_VAR_DECL(expected1,uint,64,2) [] = { 0xfffffffffffffff1,
  84                                           0xfffffffffffffff1 };
  85 VECT_VAR_DECL(expected1,poly,8,16) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
  86                                           0xf1, 0xf1, 0xf1, 0xf1,
  87                                           0xf1, 0xf1, 0xf1, 0xf1,
  88                                           0xf1, 0xf1, 0xf1, 0xf1 };
  89 VECT_VAR_DECL(expected1,poly,16,8) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1,
  90                                           0xfff1, 0xfff1, 0xfff1, 0xfff1 };
  91 VECT_VAR_DECL(expected1,hfloat,32,4) [] = { 0xc1700000, 0xc1700000,
  92                                             0xc1700000, 0xc1700000 };
  93
  94 /* Chunk 2.  */
  95 VECT_VAR_DECL(expected2,int,8,8) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
  96                                         0xf2, 0xf2, 0xf2, 0xf2 };
  97 VECT_VAR_DECL(expected2,int,16,4) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
  98 VECT_VAR_DECL(expected2,int,32,2) [] = { 0xfffffff2, 0xfffffff2 };
  99 VECT_VAR_DECL(expected2,int,64,1) [] = { 0xfffffffffffffff2 };
 100 VECT_VAR_DECL(expected2,uint,8,8) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
 101                                          0xf2, 0xf2, 0xf2, 0xf2 };
 102 VECT_VAR_DECL(expected2,uint,16,4) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
 103 VECT_VAR_DECL(expected2,uint,32,2) [] = { 0xfffffff2, 0xfffffff2 };
 104 VECT_VAR_DECL(expected2,uint,64,1) [] = { 0xfffffffffffffff2 };
 105 VECT_VAR_DECL(expected2,poly,8,8) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
 106                                          0xf2, 0xf2, 0xf2, 0xf2 };
 107 VECT_VAR_DECL(expected2,poly,16,4) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
 108 VECT_VAR_DECL(expected2,hfloat,32,2) [] = { 0xc1600000, 0xc1600000 };
 109 VECT_VAR_DECL(expected2,int,8,16) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
 110                                          0xf2, 0xf2, 0xf2, 0xf2,
 111                                          0xf2, 0xf2, 0xf2, 0xf2,
 112                                          0xf2, 0xf2, 0xf2, 0xf2 };
 113 VECT_VAR_DECL(expected2,int,16,8) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2,
 114                                          0xfff2, 0xfff2, 0xfff2, 0xfff2 };
 115 VECT_VAR_DECL(expected2,int,32,4) [] = { 0xfffffff2, 0xfffffff2,
 116                                          0xfffffff2, 0xfffffff2 };
 117 VECT_VAR_DECL(expected2,int,64,2) [] = { 0xfffffffffffffff2,
 118                                          0xfffffffffffffff2 };
 119 VECT_VAR_DECL(expected2,uint,8,16) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
 120                                           0xf2, 0xf2, 0xf2, 0xf2,
 121                                           0xf2, 0xf2, 0xf2, 0xf2,
 122                                           0xf2, 0xf2, 0xf2, 0xf2 };
 123 VECT_VAR_DECL(expected2,uint,16,8) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2,
 124                                           0xfff2, 0xfff2, 0xfff2, 0xfff2 };
 125 VECT_VAR_DECL(expected2,uint,32,4) [] = { 0xfffffff2, 0xfffffff2,
 126                                           0xfffffff2, 0xfffffff2 };
 127 VECT_VAR_DECL(expected2,uint,64,2) [] = { 0xfffffffffffffff2,
 128                                           0xfffffffffffffff2 };
 129 VECT_VAR_DECL(expected2,poly,8,16) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
 130                                           0xf2, 0xf2, 0xf2, 0xf2,
 131                                           0xf2, 0xf2, 0xf2, 0xf2,
 132                                           0xf2, 0xf2, 0xf2, 0xf2 };
 133 VECT_VAR_DECL(expected2,poly,16,8) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2,
 134                                           0xfff2, 0xfff2, 0xfff2, 0xfff2 };
 135 VECT_VAR_DECL(expected2,hfloat,32,4) [] = { 0xc1600000, 0xc1600000,
 136                                             0xc1600000, 0xc1600000 };
 137
 138 #define TEST_MSG "VLD1_DUP/VLD1_DUPQ"
 139 void exec_vld1_dup (void)
 140 {
 141   int i;
 142
 143   /* Fill vector with buffer item #i.  */
 144 #define TEST_VLD1_DUP(VAR, BUF, Q, T1, T2, W, N)                        \
 145   VECT_VAR(VAR, T1, W, N) =                                             \
 146     vld1##Q##_dup_##T2##W(&VECT_VAR(BUF, T1, W, N)[i]);                 \
 147   vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(VAR, T1, W, N))
 148
 149   DECL_VARIABLE_ALL_VARIANTS(vector);
 150
 151   /* Try to read different places from the input buffer.  */
 152   for (i=0; i<3; i++) {
 153     clean_results ();
 154
 155     TEST_MACRO_ALL_VARIANTS_2_5(TEST_VLD1_DUP, vector, buffer_dup);
 156
 157     TEST_VLD1_DUP(vector, buffer_dup, , float, f, 32, 2);
 158     TEST_VLD1_DUP(vector, buffer_dup, q, float, f, 32, 4);
 159
 160     switch (i) {
 161     case 0:
 162       CHECK_RESULTS_NAMED (TEST_MSG, expected0, "");
 163       break;
 164     case 1:
 165       CHECK_RESULTS_NAMED (TEST_MSG, expected1, "");
 166       break;
 167     case 2:
 168       CHECK_RESULTS_NAMED (TEST_MSG, expected2, "");
 169       break;
 170     default:
 171       abort();
 172     }
 173   }
 174 }
 175
 176 int main (void)
 177 {
 178   exec_vld1_dup ();
 179   return 0;
 180 }