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

   1 #include <arm_neon.h>
   2 #include "arm-neon-ref.h"
   3 #include "compute-ref-data.h"
   4
   5 /* Expected results.  */
   6
   7 /* vld2/chunk 0.  */
   8 VECT_VAR_DECL(expected_vld2_0,int,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
   9                                               0xaa, 0xaa, 0xaa, 0xaa };
  10 VECT_VAR_DECL(expected_vld2_0,int,16,4) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
  11 VECT_VAR_DECL(expected_vld2_0,int,32,2) [] = { 0xfffffff0, 0xfffffff1 };
  12 VECT_VAR_DECL(expected_vld2_0,int,64,1) [] = { 0x3333333333333333 };
  13 VECT_VAR_DECL(expected_vld2_0,uint,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
  14                                                0xaa, 0xaa, 0xaa, 0xaa };
  15 VECT_VAR_DECL(expected_vld2_0,uint,16,4) [] = { 0xaaaa, 0xaaaa,
  16                                                 0xaaaa, 0xaaaa };
  17 VECT_VAR_DECL(expected_vld2_0,uint,32,2) [] = { 0xaaaaaaaa, 0xaaaaaaaa };
  18 VECT_VAR_DECL(expected_vld2_0,uint,64,1) [] = { 0x3333333333333333 };
  19 VECT_VAR_DECL(expected_vld2_0,poly,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
  20                                                0xaa, 0xaa, 0xaa, 0xaa };
  21 VECT_VAR_DECL(expected_vld2_0,poly,16,4) [] = { 0xaaaa, 0xaaaa,
  22                                                 0xaaaa, 0xaaaa };
  23 VECT_VAR_DECL(expected_vld2_0,hfloat,32,2) [] = { 0xc1800000, 0xc1700000 };
  24 VECT_VAR_DECL(expected_vld2_0,int,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
  25                                                0x33, 0x33, 0x33, 0x33,
  26                                                0x33, 0x33, 0x33, 0x33,
  27                                                0x33, 0x33, 0x33, 0x33 };
  28 VECT_VAR_DECL(expected_vld2_0,int,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
  29                                                0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
  30 VECT_VAR_DECL(expected_vld2_0,int,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
  31                                                0xaaaaaaaa, 0xaaaaaaaa };
  32 VECT_VAR_DECL(expected_vld2_0,int,64,2) [] = { 0x3333333333333333,
  33                                                0x3333333333333333 };
  34 VECT_VAR_DECL(expected_vld2_0,uint,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
  35                                                 0x33, 0x33, 0x33, 0x33,
  36                                                 0x33, 0x33, 0x33, 0x33,
  37                                                 0x33, 0x33, 0x33, 0x33 };
  38 VECT_VAR_DECL(expected_vld2_0,uint,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
  39                                                 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
  40 VECT_VAR_DECL(expected_vld2_0,uint,32,4) [] = { 0xfffffff0, 0xfffffff1,
  41                                                 0xaaaaaaaa, 0xaaaaaaaa };
  42 VECT_VAR_DECL(expected_vld2_0,uint,64,2) [] = { 0x3333333333333333,
  43                                                 0x3333333333333333 };
  44 VECT_VAR_DECL(expected_vld2_0,poly,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
  45                                                 0x33, 0x33, 0x33, 0x33,
  46                                                 0x33, 0x33, 0x33, 0x33,
  47                                                 0x33, 0x33, 0x33, 0x33 };
  48 VECT_VAR_DECL(expected_vld2_0,poly,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
  49                                                 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
  50 VECT_VAR_DECL(expected_vld2_0,hfloat,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
  51                                                   0xaaaaaaaa, 0xaaaaaaaa };
  52
  53 /* vld2/chunk 1.  */
  54 VECT_VAR_DECL(expected_vld2_1,int,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
  55                                               0xaa, 0xaa, 0xf0, 0xf1 };
  56 VECT_VAR_DECL(expected_vld2_1,int,16,4) [] = { 0xfff0, 0xfff1, 0xaaaa, 0xaaaa };
  57 VECT_VAR_DECL(expected_vld2_1,int,32,2) [] = { 0xaaaaaaaa, 0xaaaaaaaa };
  58 VECT_VAR_DECL(expected_vld2_1,int,64,1) [] = { 0x3333333333333333 };
  59 VECT_VAR_DECL(expected_vld2_1,uint,8,8) [] = { 0xf0, 0xf1, 0xaa, 0xaa,
  60                                                0xaa, 0xaa, 0xaa, 0xaa };
  61 VECT_VAR_DECL(expected_vld2_1,uint,16,4) [] = { 0xaaaa, 0xaaaa, 0xfff0, 0xfff1 };
  62 VECT_VAR_DECL(expected_vld2_1,uint,32,2) [] = { 0xfffffff0, 0xfffffff1 };
  63 VECT_VAR_DECL(expected_vld2_1,uint,64,1) [] = { 0x3333333333333333 };
  64 VECT_VAR_DECL(expected_vld2_1,poly,8,8) [] = { 0xf0, 0xf1, 0xaa, 0xaa,
  65                                                0xaa, 0xaa, 0xaa, 0xaa };
  66 VECT_VAR_DECL(expected_vld2_1,poly,16,4) [] = { 0xaaaa, 0xaaaa, 0xfff0, 0xfff1 };
  67 VECT_VAR_DECL(expected_vld2_1,hfloat,32,2) [] = { 0xaaaaaaaa, 0xaaaaaaaa };
  68 VECT_VAR_DECL(expected_vld2_1,int,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
  69                                                0x33, 0x33, 0x33, 0x33,
  70                                                0x33, 0x33, 0x33, 0x33,
  71                                                0x33, 0x33, 0x33, 0x33 };
  72 VECT_VAR_DECL(expected_vld2_1,int,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
  73                                                0xfff0, 0xfff1, 0xaaaa, 0xaaaa };
  74 VECT_VAR_DECL(expected_vld2_1,int,32,4) [] = { 0xfffffff0, 0xfffffff1,
  75                                                0xaaaaaaaa, 0xaaaaaaaa };
  76 VECT_VAR_DECL(expected_vld2_1,int,64,2) [] = { 0x3333333333333333,
  77                                                0x3333333333333333 };
  78 VECT_VAR_DECL(expected_vld2_1,uint,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
  79                                                 0x33, 0x33, 0x33, 0x33,
  80                                                 0x33, 0x33, 0x33, 0x33,
  81                                                 0x33, 0x33, 0x33, 0x33 };
  82 VECT_VAR_DECL(expected_vld2_1,uint,16,8) [] = { 0xaaaa, 0xaaaa, 0xfff0, 0xfff1,
  83                                                 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
  84 VECT_VAR_DECL(expected_vld2_1,uint,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
  85                                                 0xaaaaaaaa, 0xaaaaaaaa };
  86 VECT_VAR_DECL(expected_vld2_1,uint,64,2) [] = { 0x3333333333333333,
  87                                                 0x3333333333333333 };
  88 VECT_VAR_DECL(expected_vld2_1,poly,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
  89                                                 0x33, 0x33, 0x33, 0x33,
  90                                                 0x33, 0x33, 0x33, 0x33,
  91                                                 0x33, 0x33, 0x33, 0x33 };
  92 VECT_VAR_DECL(expected_vld2_1,poly,16,8) [] = { 0xaaaa, 0xaaaa, 0xfff0, 0xfff1,
  93                                                 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
  94 VECT_VAR_DECL(expected_vld2_1,hfloat,32,4) [] = { 0xc1800000, 0xc1700000,
  95                                                   0xaaaaaaaa, 0xaaaaaaaa };
  96
  97 /* vld3/chunk 0.  */
  98 VECT_VAR_DECL(expected_vld3_0,int,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
  99                                               0xaa, 0xaa, 0xaa, 0xaa };
 100 VECT_VAR_DECL(expected_vld3_0,int,16,4) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 101 VECT_VAR_DECL(expected_vld3_0,int,32,2) [] = { 0xfffffff0, 0xfffffff1 };
 102 VECT_VAR_DECL(expected_vld3_0,int,64,1) [] = { 0x3333333333333333 };
 103 VECT_VAR_DECL(expected_vld3_0,uint,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 104                                                0xaa, 0xaa, 0xaa, 0xaa };
 105 VECT_VAR_DECL(expected_vld3_0,uint,16,4) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 106 VECT_VAR_DECL(expected_vld3_0,uint,32,2) [] = { 0xaaaaaaaa, 0xaaaaaaaa };
 107 VECT_VAR_DECL(expected_vld3_0,uint,64,1) [] = { 0x3333333333333333 };
 108 VECT_VAR_DECL(expected_vld3_0,poly,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 109                                                0xaa, 0xaa, 0xaa, 0xaa };
 110 VECT_VAR_DECL(expected_vld3_0,poly,16,4) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 111 VECT_VAR_DECL(expected_vld3_0,hfloat,32,2) [] = { 0xc1800000, 0xc1700000 };
 112 VECT_VAR_DECL(expected_vld3_0,int,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 113                                                0x33, 0x33, 0x33, 0x33,
 114                                                0x33, 0x33, 0x33, 0x33,
 115                                                0x33, 0x33, 0x33, 0x33 };
 116 VECT_VAR_DECL(expected_vld3_0,int,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 117                                                0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 118 VECT_VAR_DECL(expected_vld3_0,int,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
 119                                                0xaaaaaaaa, 0xaaaaaaaa };
 120 VECT_VAR_DECL(expected_vld3_0,int,64,2) [] = { 0x3333333333333333,
 121                                                0x3333333333333333 };
 122 VECT_VAR_DECL(expected_vld3_0,uint,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 123                                                 0x33, 0x33, 0x33, 0x33,
 124                                                 0x33, 0x33, 0x33, 0x33,
 125                                                 0x33, 0x33, 0x33, 0x33 };
 126 VECT_VAR_DECL(expected_vld3_0,uint,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 127                                                 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 128 VECT_VAR_DECL(expected_vld3_0,uint,32,4) [] = { 0xfffffff0, 0xfffffff1,
 129                                                 0xfffffff2, 0xaaaaaaaa };
 130 VECT_VAR_DECL(expected_vld3_0,uint,64,2) [] = { 0x3333333333333333,
 131                                                 0x3333333333333333 };
 132 VECT_VAR_DECL(expected_vld3_0,poly,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 133                                                 0x33, 0x33, 0x33, 0x33,
 134                                                 0x33, 0x33, 0x33, 0x33,
 135                                                 0x33, 0x33, 0x33, 0x33 };
 136 VECT_VAR_DECL(expected_vld3_0,poly,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 137                                                 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 138 VECT_VAR_DECL(expected_vld3_0,hfloat,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
 139                                                   0xaaaaaaaa, 0xaaaaaaaa };
 140
 141 /* vld3/chunk 1.  */
 142 VECT_VAR_DECL(expected_vld3_1,int,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 143                                               0xaa, 0xaa, 0xaa, 0xaa };
 144 VECT_VAR_DECL(expected_vld3_1,int,16,4) [] = { 0xaaaa, 0xaaaa, 0xfff0, 0xfff1 };
 145 VECT_VAR_DECL(expected_vld3_1,int,32,2) [] = { 0xfffffff2, 0xaaaaaaaa };
 146 VECT_VAR_DECL(expected_vld3_1,int,64,1) [] = { 0x3333333333333333 };
 147 VECT_VAR_DECL(expected_vld3_1,uint,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 148                                                0xf0, 0xf1, 0xf2, 0xaa };
 149 VECT_VAR_DECL(expected_vld3_1,uint,16,4) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 150 VECT_VAR_DECL(expected_vld3_1,uint,32,2) [] = { 0xaaaaaaaa, 0xfffffff0 };
 151 VECT_VAR_DECL(expected_vld3_1,uint,64,1) [] = { 0x3333333333333333 };
 152 VECT_VAR_DECL(expected_vld3_1,poly,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 153                                                0xf0, 0xf1, 0xf2, 0xaa };
 154 VECT_VAR_DECL(expected_vld3_1,poly,16,4) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 155 VECT_VAR_DECL(expected_vld3_1,hfloat,32,2) [] = { 0xc1600000, 0xaaaaaaaa };
 156 VECT_VAR_DECL(expected_vld3_1,int,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 157                                                0x33, 0x33, 0x33, 0x33,
 158                                                0x33, 0x33, 0x33, 0x33,
 159                                                0x33, 0x33, 0x33, 0x33 };
 160 VECT_VAR_DECL(expected_vld3_1,int,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 161                                                0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 162 VECT_VAR_DECL(expected_vld3_1,int,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
 163                                                0xfffffff0, 0xfffffff1 };
 164 VECT_VAR_DECL(expected_vld3_1,int,64,2) [] = { 0x3333333333333333,
 165                                                0x3333333333333333 };
 166 VECT_VAR_DECL(expected_vld3_1,uint,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 167                                                 0x33, 0x33, 0x33, 0x33,
 168                                                 0x33, 0x33, 0x33, 0x33,
 169                                                 0x33, 0x33, 0x33, 0x33 };
 170 VECT_VAR_DECL(expected_vld3_1,uint,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 171                                                 0xaaaa, 0xaaaa, 0xaaaa, 0xfff0 };
 172 VECT_VAR_DECL(expected_vld3_1,uint,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
 173                                                 0xaaaaaaaa, 0xaaaaaaaa };
 174 VECT_VAR_DECL(expected_vld3_1,uint,64,2) [] = { 0x3333333333333333,
 175                                                 0x3333333333333333 };
 176 VECT_VAR_DECL(expected_vld3_1,poly,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 177                                                 0x33, 0x33, 0x33, 0x33,
 178                                                 0x33, 0x33, 0x33, 0x33,
 179                                                 0x33, 0x33, 0x33, 0x33 };
 180 VECT_VAR_DECL(expected_vld3_1,poly,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 181                                                 0xaaaa, 0xaaaa, 0xaaaa, 0xfff0 };
 182 VECT_VAR_DECL(expected_vld3_1,hfloat,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
 183                                                   0xc1800000, 0xc1700000 };
 184
 185 /* vld3/chunk 2.  */
 186 VECT_VAR_DECL(expected_vld3_2,int,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 187                                               0xaa, 0xf0, 0xf1, 0xf2 };
 188 VECT_VAR_DECL(expected_vld3_2,int,16,4) [] = { 0xfff2, 0xaaaa, 0xaaaa, 0xaaaa };
 189 VECT_VAR_DECL(expected_vld3_2,int,32,2) [] = { 0xaaaaaaaa, 0xaaaaaaaa };
 190 VECT_VAR_DECL(expected_vld3_2,int,64,1) [] = { 0x3333333333333333 };
 191 VECT_VAR_DECL(expected_vld3_2,uint,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 192                                                0xaa, 0xaa, 0xaa, 0xaa };
 193 VECT_VAR_DECL(expected_vld3_2,uint,16,4) [] = { 0xaaaa, 0xfff0, 0xfff1, 0xfff2 };
 194 VECT_VAR_DECL(expected_vld3_2,uint,32,2) [] = { 0xfffffff1, 0xfffffff2 };
 195 VECT_VAR_DECL(expected_vld3_2,uint,64,1) [] = { 0x3333333333333333 };
 196 VECT_VAR_DECL(expected_vld3_2,poly,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 197                                                0xaa, 0xaa, 0xaa, 0xaa };
 198 VECT_VAR_DECL(expected_vld3_2,poly,16,4) [] = { 0xaaaa, 0xfff0, 0xfff1, 0xfff2 };
 199 VECT_VAR_DECL(expected_vld3_2,hfloat,32,2) [] = { 0xaaaaaaaa, 0xaaaaaaaa };
 200 VECT_VAR_DECL(expected_vld3_2,int,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 201                                                0x33, 0x33, 0x33, 0x33,
 202                                                0x33, 0x33, 0x33, 0x33,
 203                                                0x33, 0x33, 0x33, 0x33 };
 204 VECT_VAR_DECL(expected_vld3_2,int,16,8) [] = { 0xaaaa, 0xaaaa, 0xfff0, 0xfff1,
 205                                                0xfff2, 0xaaaa, 0xaaaa, 0xaaaa };
 206 VECT_VAR_DECL(expected_vld3_2,int,32,4) [] = { 0xfffffff2, 0xaaaaaaaa,
 207                                                0xaaaaaaaa, 0xaaaaaaaa };
 208 VECT_VAR_DECL(expected_vld3_2,int,64,2) [] = { 0x3333333333333333,
 209                                                0x3333333333333333 };
 210 VECT_VAR_DECL(expected_vld3_2,uint,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 211                                                 0x33, 0x33, 0x33, 0x33,
 212                                                 0x33, 0x33, 0x33, 0x33,
 213                                                 0x33, 0x33, 0x33, 0x33 };
 214 VECT_VAR_DECL(expected_vld3_2,uint,16,8) [] = { 0xfff1, 0xfff2, 0xaaaa, 0xaaaa,
 215                                                 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 216 VECT_VAR_DECL(expected_vld3_2,uint,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
 217                                                 0xaaaaaaaa, 0xaaaaaaaa };
 218 VECT_VAR_DECL(expected_vld3_2,uint,64,2) [] = { 0x3333333333333333,
 219                                                 0x3333333333333333 };
 220 VECT_VAR_DECL(expected_vld3_2,poly,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 221                                                 0x33, 0x33, 0x33, 0x33,
 222                                                 0x33, 0x33, 0x33, 0x33,
 223                                                 0x33, 0x33, 0x33, 0x33 };
 224 VECT_VAR_DECL(expected_vld3_2,poly,16,8) [] = { 0xfff1, 0xfff2, 0xaaaa, 0xaaaa,
 225                                                 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 226 VECT_VAR_DECL(expected_vld3_2,hfloat,32,4) [] = { 0xc1600000, 0xaaaaaaaa,
 227                                                   0xaaaaaaaa, 0xaaaaaaaa };
 228
 229 /* vld4/chunk 0.  */
 230 VECT_VAR_DECL(expected_vld4_0,int,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 231                                               0xaa, 0xaa, 0xaa, 0xaa };
 232 VECT_VAR_DECL(expected_vld4_0,int,16,4) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 233 VECT_VAR_DECL(expected_vld4_0,int,32,2) [] = { 0xfffffff0, 0xfffffff1 };
 234 VECT_VAR_DECL(expected_vld4_0,int,64,1) [] = { 0x3333333333333333 };
 235 VECT_VAR_DECL(expected_vld4_0,uint,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 236                                                0xaa, 0xaa, 0xaa, 0xaa };
 237 VECT_VAR_DECL(expected_vld4_0,uint,16,4) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 238 VECT_VAR_DECL(expected_vld4_0,uint,32,2) [] = { 0xaaaaaaaa, 0xaaaaaaaa };
 239 VECT_VAR_DECL(expected_vld4_0,uint,64,1) [] = { 0x3333333333333333 };
 240 VECT_VAR_DECL(expected_vld4_0,poly,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 241                                                0xaa, 0xaa, 0xaa, 0xaa };
 242 VECT_VAR_DECL(expected_vld4_0,poly,16,4) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 243 VECT_VAR_DECL(expected_vld4_0,hfloat,32,2) [] = { 0xc1800000, 0xc1700000 };
 244 VECT_VAR_DECL(expected_vld4_0,int,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 245                                                0x33, 0x33, 0x33, 0x33,
 246                                                0x33, 0x33, 0x33, 0x33,
 247                                                0x33, 0x33, 0x33, 0x33 };
 248 VECT_VAR_DECL(expected_vld4_0,int,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 249                                                0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 250 VECT_VAR_DECL(expected_vld4_0,int,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
 251                                                0xaaaaaaaa, 0xaaaaaaaa };
 252 VECT_VAR_DECL(expected_vld4_0,int,64,2) [] = { 0x3333333333333333,
 253                                                0x3333333333333333 };
 254 VECT_VAR_DECL(expected_vld4_0,uint,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 255                                                 0x33, 0x33, 0x33, 0x33,
 256                                                 0x33, 0x33, 0x33, 0x33,
 257                                                 0x33, 0x33, 0x33, 0x33 };
 258 VECT_VAR_DECL(expected_vld4_0,uint,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 259                                                 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 260 VECT_VAR_DECL(expected_vld4_0,uint,32,4) [] = { 0xfffffff0, 0xfffffff1,
 261                                                 0xfffffff2, 0xfffffff3 };
 262 VECT_VAR_DECL(expected_vld4_0,uint,64,2) [] = { 0x3333333333333333,
 263                                                 0x3333333333333333 };
 264 VECT_VAR_DECL(expected_vld4_0,poly,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 265                                                 0x33, 0x33, 0x33, 0x33,
 266                                                 0x33, 0x33, 0x33, 0x33,
 267                                                 0x33, 0x33, 0x33, 0x33 };
 268 VECT_VAR_DECL(expected_vld4_0,poly,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 269                                                 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 270 VECT_VAR_DECL(expected_vld4_0,hfloat,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
 271                                                   0xaaaaaaaa, 0xaaaaaaaa };
 272
 273 /* vld4/chunk 1.  */
 274 VECT_VAR_DECL(expected_vld4_1,int,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 275                                               0xaa, 0xaa, 0xaa, 0xaa };
 276 VECT_VAR_DECL(expected_vld4_1,int,16,4) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 277 VECT_VAR_DECL(expected_vld4_1,int,32,2) [] = { 0xfffffff2, 0xfffffff3 };
 278 VECT_VAR_DECL(expected_vld4_1,int,64,1) [] = { 0x3333333333333333 };
 279 VECT_VAR_DECL(expected_vld4_1,uint,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 280                                                0xaa, 0xaa, 0xaa, 0xaa };
 281 VECT_VAR_DECL(expected_vld4_1,uint,16,4) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 282 VECT_VAR_DECL(expected_vld4_1,uint,32,2) [] = { 0xaaaaaaaa, 0xaaaaaaaa };
 283 VECT_VAR_DECL(expected_vld4_1,uint,64,1) [] = { 0x3333333333333333 };
 284 VECT_VAR_DECL(expected_vld4_1,poly,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 285                                                0xaa, 0xaa, 0xaa, 0xaa };
 286 VECT_VAR_DECL(expected_vld4_1,poly,16,4) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 287 VECT_VAR_DECL(expected_vld4_1,hfloat,32,2) [] = { 0xc1600000, 0xc1500000 };
 288 VECT_VAR_DECL(expected_vld4_1,int,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 289                                                0x33, 0x33, 0x33, 0x33,
 290                                                0x33, 0x33, 0x33, 0x33,
 291                                                0x33, 0x33, 0x33, 0x33 };
 292 VECT_VAR_DECL(expected_vld4_1,int,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 293                                                0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 294 VECT_VAR_DECL(expected_vld4_1,int,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
 295                                                0xaaaaaaaa, 0xaaaaaaaa };
 296 VECT_VAR_DECL(expected_vld4_1,int,64,2) [] = { 0x3333333333333333,
 297                                                0x3333333333333333 };
 298 VECT_VAR_DECL(expected_vld4_1,uint,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 299                                                 0x33, 0x33, 0x33, 0x33,
 300                                                 0x33, 0x33, 0x33, 0x33,
 301                                                 0x33, 0x33, 0x33, 0x33 };
 302 VECT_VAR_DECL(expected_vld4_1,uint,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 303                                                 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 304 VECT_VAR_DECL(expected_vld4_1,uint,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
 305                                                 0xaaaaaaaa, 0xaaaaaaaa };
 306 VECT_VAR_DECL(expected_vld4_1,uint,64,2) [] = { 0x3333333333333333,
 307                                                 0x3333333333333333 };
 308 VECT_VAR_DECL(expected_vld4_1,poly,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 309                                                 0x33, 0x33, 0x33, 0x33,
 310                                                 0x33, 0x33, 0x33, 0x33,
 311                                                 0x33, 0x33, 0x33, 0x33 };
 312 VECT_VAR_DECL(expected_vld4_1,poly,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 313                                                 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 314 VECT_VAR_DECL(expected_vld4_1,hfloat,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
 315                                                   0xaaaaaaaa, 0xaaaaaaaa };
 316
 317 /* vld4/chunk 2.  */
 318 VECT_VAR_DECL(expected_vld4_2,int,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 319                                               0xaa, 0xaa, 0xaa, 0xaa };
 320 VECT_VAR_DECL(expected_vld4_2,int,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
 321 VECT_VAR_DECL(expected_vld4_2,int,32,2) [] = { 0xaaaaaaaa, 0xaaaaaaaa };
 322 VECT_VAR_DECL(expected_vld4_2,int,64,1) [] = { 0x3333333333333333 };
 323 VECT_VAR_DECL(expected_vld4_2,uint,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
 324                                                0xaa, 0xaa, 0xaa, 0xaa };
 325 VECT_VAR_DECL(expected_vld4_2,uint,16,4) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 326 VECT_VAR_DECL(expected_vld4_2,uint,32,2) [] = { 0xfffffff0, 0xfffffff1 };
 327 VECT_VAR_DECL(expected_vld4_2,uint,64,1) [] = { 0x3333333333333333 };
 328 VECT_VAR_DECL(expected_vld4_2,poly,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
 329                                                0xaa, 0xaa, 0xaa, 0xaa };
 330 VECT_VAR_DECL(expected_vld4_2,poly,16,4) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 331 VECT_VAR_DECL(expected_vld4_2,hfloat,32,2) [] = { 0xaaaaaaaa, 0xaaaaaaaa };
 332 VECT_VAR_DECL(expected_vld4_2,int,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 333                                                0x33, 0x33, 0x33, 0x33,
 334                                                0x33, 0x33, 0x33, 0x33,
 335                                                0x33, 0x33, 0x33, 0x33 };
 336 VECT_VAR_DECL(expected_vld4_2,int,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 337                                                0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 338 VECT_VAR_DECL(expected_vld4_2,int,32,4) [] = { 0xfffffff0, 0xfffffff1,
 339                                                0xfffffff2, 0xfffffff3 };
 340 VECT_VAR_DECL(expected_vld4_2,int,64,2) [] = { 0x3333333333333333,
 341                                                0x3333333333333333 };
 342 VECT_VAR_DECL(expected_vld4_2,uint,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 343                                                 0x33, 0x33, 0x33, 0x33,
 344                                                 0x33, 0x33, 0x33, 0x33,
 345                                                 0x33, 0x33, 0x33, 0x33 };
 346 VECT_VAR_DECL(expected_vld4_2,uint,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 347                                                 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
 348 VECT_VAR_DECL(expected_vld4_2,uint,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
 349                                                 0xaaaaaaaa, 0xaaaaaaaa };
 350 VECT_VAR_DECL(expected_vld4_2,uint,64,2) [] = { 0x3333333333333333,
 351                                                 0x3333333333333333 };
 352 VECT_VAR_DECL(expected_vld4_2,poly,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 353                                                 0x33, 0x33, 0x33, 0x33,
 354                                                 0x33, 0x33, 0x33, 0x33,
 355                                                 0x33, 0x33, 0x33, 0x33 };
 356 VECT_VAR_DECL(expected_vld4_2,poly,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 357                                                 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
 358 VECT_VAR_DECL(expected_vld4_2,hfloat,32,4) [] = { 0xc1800000, 0xc1700000,
 359                                                   0xc1600000, 0xc1500000 };
 360
 361 /* vld4/chunk 3.  */
 362 VECT_VAR_DECL(expected_vld4_3,int,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 363                                               0xf0, 0xf1, 0xf2, 0xf3 };
 364 VECT_VAR_DECL(expected_vld4_3,int,16,4) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 365 VECT_VAR_DECL(expected_vld4_3,int,32,2) [] = { 0xaaaaaaaa, 0xaaaaaaaa };
 366 VECT_VAR_DECL(expected_vld4_3,int,64,1) [] = { 0x3333333333333333 };
 367 VECT_VAR_DECL(expected_vld4_3,uint,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 368                                                0xaa, 0xaa, 0xaa, 0xaa };
 369 VECT_VAR_DECL(expected_vld4_3,uint,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
 370 VECT_VAR_DECL(expected_vld4_3,uint,32,2) [] = { 0xfffffff2, 0xfffffff3 };
 371 VECT_VAR_DECL(expected_vld4_3,uint,64,1) [] = { 0x3333333333333333 };
 372 VECT_VAR_DECL(expected_vld4_3,poly,8,8) [] = { 0xaa, 0xaa, 0xaa, 0xaa,
 373                                                0xaa, 0xaa, 0xaa, 0xaa };
 374 VECT_VAR_DECL(expected_vld4_3,poly,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
 375 VECT_VAR_DECL(expected_vld4_3,hfloat,32,2) [] = { 0xaaaaaaaa, 0xaaaaaaaa };
 376 VECT_VAR_DECL(expected_vld4_3,int,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 377                                                0x33, 0x33, 0x33, 0x33,
 378                                                0x33, 0x33, 0x33, 0x33,
 379                                                0x33, 0x33, 0x33, 0x33 };
 380 VECT_VAR_DECL(expected_vld4_3,int,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
 381                                                0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 382 VECT_VAR_DECL(expected_vld4_3,int,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
 383                                                0xaaaaaaaa, 0xaaaaaaaa };
 384 VECT_VAR_DECL(expected_vld4_3,int,64,2) [] = { 0x3333333333333333,
 385                                                0x3333333333333333 };
 386 VECT_VAR_DECL(expected_vld4_3,uint,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 387                                                 0x33, 0x33, 0x33, 0x33,
 388                                                 0x33, 0x33, 0x33, 0x33,
 389                                                 0x33, 0x33, 0x33, 0x33 };
 390 VECT_VAR_DECL(expected_vld4_3,uint,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 391                                                 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 392 VECT_VAR_DECL(expected_vld4_3,uint,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
 393                                                 0xaaaaaaaa, 0xaaaaaaaa };
 394 VECT_VAR_DECL(expected_vld4_3,uint,64,2) [] = { 0x3333333333333333,
 395                                                 0x3333333333333333 };
 396 VECT_VAR_DECL(expected_vld4_3,poly,8,16) [] = { 0x33, 0x33, 0x33, 0x33,
 397                                                 0x33, 0x33, 0x33, 0x33,
 398                                                 0x33, 0x33, 0x33, 0x33,
 399                                                 0x33, 0x33, 0x33, 0x33 };
 400 VECT_VAR_DECL(expected_vld4_3,poly,16,8) [] = { 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
 401                                                 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa };
 402 VECT_VAR_DECL(expected_vld4_3,hfloat,32,4) [] = { 0xaaaaaaaa, 0xaaaaaaaa,
 403                                                   0xaaaaaaaa, 0xaaaaaaaa };
 404
 405 /* Declare additional input buffers as needed.  */
 406 /* Input buffers for vld2_lane */
 407 VECT_VAR_DECL_INIT(buffer_vld2_lane, int, 8, 2);
 408 VECT_VAR_DECL_INIT(buffer_vld2_lane, int, 16, 2);
 409 VECT_VAR_DECL_INIT(buffer_vld2_lane, int, 32, 2);
 410 VECT_VAR_DECL_INIT(buffer_vld2_lane, int, 64, 2);
 411 VECT_VAR_DECL_INIT(buffer_vld2_lane, uint, 8, 2);
 412 VECT_VAR_DECL_INIT(buffer_vld2_lane, uint, 16, 2);
 413 VECT_VAR_DECL_INIT(buffer_vld2_lane, uint, 32, 2);
 414 VECT_VAR_DECL_INIT(buffer_vld2_lane, uint, 64, 2);
 415 VECT_VAR_DECL_INIT(buffer_vld2_lane, poly, 8, 2);
 416 VECT_VAR_DECL_INIT(buffer_vld2_lane, poly, 16, 2);
 417 VECT_VAR_DECL_INIT(buffer_vld2_lane, float, 32, 2);
 418
 419 /* Input buffers for vld3_lane */
 420 VECT_VAR_DECL_INIT(buffer_vld3_lane, int, 8, 3);
 421 VECT_VAR_DECL_INIT(buffer_vld3_lane, int, 16, 3);
 422 VECT_VAR_DECL_INIT(buffer_vld3_lane, int, 32, 3);
 423 VECT_VAR_DECL_INIT(buffer_vld3_lane, int, 64, 3);
 424 VECT_VAR_DECL_INIT(buffer_vld3_lane, uint, 8, 3);
 425 VECT_VAR_DECL_INIT(buffer_vld3_lane, uint, 16, 3);
 426 VECT_VAR_DECL_INIT(buffer_vld3_lane, uint, 32, 3);
 427 VECT_VAR_DECL_INIT(buffer_vld3_lane, uint, 64, 3);
 428 VECT_VAR_DECL_INIT(buffer_vld3_lane, poly, 8, 3);
 429 VECT_VAR_DECL_INIT(buffer_vld3_lane, poly, 16, 3);
 430 VECT_VAR_DECL_INIT(buffer_vld3_lane, float, 32, 3);
 431
 432 /* Input buffers for vld4_lane */
 433 VECT_VAR_DECL_INIT(buffer_vld4_lane, int, 8, 4);
 434 VECT_VAR_DECL_INIT(buffer_vld4_lane, int, 16, 4);
 435 VECT_VAR_DECL_INIT(buffer_vld4_lane, int, 32, 4);
 436 VECT_VAR_DECL_INIT(buffer_vld4_lane, int, 64, 4);
 437 VECT_VAR_DECL_INIT(buffer_vld4_lane, uint, 8, 4);
 438 VECT_VAR_DECL_INIT(buffer_vld4_lane, uint, 16, 4);
 439 VECT_VAR_DECL_INIT(buffer_vld4_lane, uint, 32, 4);
 440 VECT_VAR_DECL_INIT(buffer_vld4_lane, uint, 64, 4);
 441 VECT_VAR_DECL_INIT(buffer_vld4_lane, poly, 8, 4);
 442 VECT_VAR_DECL_INIT(buffer_vld4_lane, poly, 16, 4);
 443 VECT_VAR_DECL_INIT(buffer_vld4_lane, float, 32, 4);
 444
 445 void exec_vldX_lane (void)
 446 {
 447   /* In this case, input variables are arrays of vectors.  */
 448 #define DECL_VLDX_LANE(T1, W, N, X)                                     \
 449   VECT_ARRAY_TYPE(T1, W, N, X) VECT_ARRAY_VAR(vector, T1, W, N, X);     \
 450   VECT_ARRAY_TYPE(T1, W, N, X) VECT_ARRAY_VAR(vector_src, T1, W, N, X); \
 451   VECT_VAR_DECL(result_bis_##X, T1, W, N)[X * N]
 452
 453   /* We need to use a temporary result buffer (result_bis), because
 454      the one used for other tests is not large enough. A subset of the
 455      result data is moved from result_bis to result, and it is this
 456      subset which is used to check the actual behaviour. The next
 457      macro enables to move another chunk of data from result_bis to
 458      result.  */
 459   /* We also use another extra input buffer (buffer_src), which we
 460      fill with 0xAA, and which it used to load a vector from which we
 461      read a given lane.  */
 462 #define TEST_VLDX_LANE(Q, T1, T2, W, N, X, L)                           \
 463   memset (VECT_VAR(buffer_src, T1, W, N), 0xAA,                         \
 464           sizeof(VECT_VAR(buffer_src, T1, W, N)));                      \
 465                                                                         \
 466   VECT_ARRAY_VAR(vector_src, T1, W, N, X) =                             \
 467     vld##X##Q##_##T2##W(VECT_VAR(buffer_src, T1, W, N));                \
 468                                                                         \
 469   VECT_ARRAY_VAR(vector, T1, W, N, X) =                                 \
 470     /* Use dedicated init buffer, of size.  X */                        \
 471     vld##X##Q##_lane_##T2##W(VECT_VAR(buffer_vld##X##_lane, T1, W, X),  \
 472                              VECT_ARRAY_VAR(vector_src, T1, W, N, X),   \
 473                              L);                                        \
 474   vst##X##Q##_##T2##W(VECT_VAR(result_bis_##X, T1, W, N),               \
 475                       VECT_ARRAY_VAR(vector, T1, W, N, X));             \
 476   memcpy(VECT_VAR(result, T1, W, N), VECT_VAR(result_bis_##X, T1, W, N), \
 477          sizeof(VECT_VAR(result, T1, W, N)))
 478
 479   /* Overwrite "result" with the contents of "result_bis"[Y].  */
 480 #define TEST_EXTRA_CHUNK(T1, W, N, X, Y)                \
 481   memcpy(VECT_VAR(result, T1, W, N),                    \
 482          &(VECT_VAR(result_bis_##X, T1, W, N)[Y*N]),    \
 483          sizeof(VECT_VAR(result, T1, W, N)));
 484
 485   /* We need all variants in 64 bits, but there is no 64x2 variant.  */
 486 #define DECL_ALL_VLDX_LANE(X)                   \
 487   DECL_VLDX_LANE(int, 8, 8, X);                 \
 488   DECL_VLDX_LANE(int, 16, 4, X);                \
 489   DECL_VLDX_LANE(int, 32, 2, X);                \
 490   DECL_VLDX_LANE(uint, 8, 8, X);                \
 491   DECL_VLDX_LANE(uint, 16, 4, X);               \
 492   DECL_VLDX_LANE(uint, 32, 2, X);               \
 493   DECL_VLDX_LANE(poly, 8, 8, X);                \
 494   DECL_VLDX_LANE(poly, 16, 4, X);               \
 495   DECL_VLDX_LANE(int, 16, 8, X);                \
 496   DECL_VLDX_LANE(int, 32, 4, X);                \
 497   DECL_VLDX_LANE(uint, 16, 8, X);               \
 498   DECL_VLDX_LANE(uint, 32, 4, X);               \
 499   DECL_VLDX_LANE(poly, 16, 8, X);               \
 500   DECL_VLDX_LANE(float, 32, 2, X);              \
 501   DECL_VLDX_LANE(float, 32, 4, X)
 502
 503   /* Add some padding to try to catch out of bound accesses.  */
 504 #define ARRAY1(V, T, W, N) VECT_VAR_DECL(V,T,W,N)[1]={42}
 505 #define DUMMY_ARRAY(V, T, W, N, L) \
 506   VECT_VAR_DECL(V,T,W,N)[N*L]={0}; \
 507   ARRAY1(V##_pad,T,W,N)
 508
 509   /* Use the same lanes regardless of the size of the array (X), for
 510      simplicity.  */
 511 #define TEST_ALL_VLDX_LANE(X)                   \
 512   TEST_VLDX_LANE(, int, s, 8, 8, X, 7);         \
 513   TEST_VLDX_LANE(, int, s, 16, 4, X, 2);        \
 514   TEST_VLDX_LANE(, int, s, 32, 2, X, 0);        \
 515   TEST_VLDX_LANE(, uint, u, 8, 8, X, 4);        \
 516   TEST_VLDX_LANE(, uint, u, 16, 4, X, 3);       \
 517   TEST_VLDX_LANE(, uint, u, 32, 2, X, 1);       \
 518   TEST_VLDX_LANE(, poly, p, 8, 8, X, 4);        \
 519   TEST_VLDX_LANE(, poly, p, 16, 4, X, 3);       \
 520   TEST_VLDX_LANE(q, int, s, 16, 8, X, 6);       \
 521   TEST_VLDX_LANE(q, int, s, 32, 4, X, 2);       \
 522   TEST_VLDX_LANE(q, uint, u, 16, 8, X, 5);      \
 523   TEST_VLDX_LANE(q, uint, u, 32, 4, X, 0);      \
 524   TEST_VLDX_LANE(q, poly, p, 16, 8, X, 5);      \
 525   TEST_VLDX_LANE(, float, f, 32, 2, X, 0);      \
 526   TEST_VLDX_LANE(q, float, f, 32, 4, X, 2)
 527
 528 #define TEST_ALL_EXTRA_CHUNKS(X, Y)             \
 529   TEST_EXTRA_CHUNK(int, 8, 8, X, Y);            \
 530   TEST_EXTRA_CHUNK(int, 16, 4, X, Y);           \
 531   TEST_EXTRA_CHUNK(int, 32, 2, X, Y);           \
 532   TEST_EXTRA_CHUNK(uint, 8, 8, X, Y);           \
 533   TEST_EXTRA_CHUNK(uint, 16, 4, X, Y);          \
 534   TEST_EXTRA_CHUNK(uint, 32, 2, X, Y);          \
 535   TEST_EXTRA_CHUNK(poly, 8, 8, X, Y);           \
 536   TEST_EXTRA_CHUNK(poly, 16, 4, X, Y);          \
 537   TEST_EXTRA_CHUNK(int, 16, 8, X, Y);           \
 538   TEST_EXTRA_CHUNK(int, 32, 4, X, Y);           \
 539   TEST_EXTRA_CHUNK(uint, 16, 8, X, Y);          \
 540   TEST_EXTRA_CHUNK(uint, 32, 4, X, Y);          \
 541   TEST_EXTRA_CHUNK(poly, 16, 8, X, Y);          \
 542   TEST_EXTRA_CHUNK(float, 32, 2, X, Y);         \
 543   TEST_EXTRA_CHUNK(float, 32, 4, X, Y)
 544
 545   /* Declare the temporary buffers / variables.  */
 546   DECL_ALL_VLDX_LANE(2);
 547   DECL_ALL_VLDX_LANE(3);
 548   DECL_ALL_VLDX_LANE(4);
 549
 550   /* Define dummy input arrays, large enough for x4 vectors.  */
 551   DUMMY_ARRAY(buffer_src, int, 8, 8, 4);
 552   DUMMY_ARRAY(buffer_src, int, 16, 4, 4);
 553   DUMMY_ARRAY(buffer_src, int, 32, 2, 4);
 554   DUMMY_ARRAY(buffer_src, uint, 8, 8, 4);
 555   DUMMY_ARRAY(buffer_src, uint, 16, 4, 4);
 556   DUMMY_ARRAY(buffer_src, uint, 32, 2, 4);
 557   DUMMY_ARRAY(buffer_src, poly, 8, 8, 4);
 558   DUMMY_ARRAY(buffer_src, poly, 16, 4, 4);
 559   DUMMY_ARRAY(buffer_src, int, 16, 8, 4);
 560   DUMMY_ARRAY(buffer_src, int, 32, 4, 4);
 561   DUMMY_ARRAY(buffer_src, uint, 16, 8, 4);
 562   DUMMY_ARRAY(buffer_src, uint, 32, 4, 4);
 563   DUMMY_ARRAY(buffer_src, poly, 16, 8, 4);
 564   DUMMY_ARRAY(buffer_src, float, 32, 2, 4);
 565   DUMMY_ARRAY(buffer_src, float, 32, 4, 4);
 566
 567   /* Check vld2_lane/vld2q_lane.  */
 568   clean_results ();
 569 #define TEST_MSG "VLD2_LANE/VLD2Q_LANE"
 570   TEST_ALL_VLDX_LANE(2);
 571   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld2_0, " chunk 0");
 572
 573   TEST_ALL_EXTRA_CHUNKS(2, 1);
 574   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld2_1, " chunk 1");
 575
 576   /* Check vld3_lane/vld3q_lane.  */
 577   clean_results ();
 578 #undef TEST_MSG
 579 #define TEST_MSG "VLD3_LANE/VLD3Q_LANE"
 580   TEST_ALL_VLDX_LANE(3);
 581   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld3_0, " chunk 0");
 582
 583   TEST_ALL_EXTRA_CHUNKS(3, 1);
 584   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld3_1, " chunk 1");
 585
 586   TEST_ALL_EXTRA_CHUNKS(3, 2);
 587   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld3_2, " chunk 2");
 588
 589   /* Check vld4_lane/vld4q_lane.  */
 590   clean_results ();
 591 #undef TEST_MSG
 592 #define TEST_MSG "VLD4_LANE/VLD4Q_LANE"
 593   TEST_ALL_VLDX_LANE(4);
 594   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld4_0, " chunk 0");
 595
 596   TEST_ALL_EXTRA_CHUNKS(4, 1);
 597   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld4_1, " chunk 1");
 598   TEST_ALL_EXTRA_CHUNKS(4, 2);
 599
 600   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld4_2, " chunk 2");
 601
 602   TEST_ALL_EXTRA_CHUNKS(4, 3);
 603   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld4_3, " chunk 3");
 604 }
 605
 606 int main (void)
 607 {
 608   exec_vldX_lane ();
 609   return 0;
 610 }