gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vldX.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) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
   9                                               0xf4, 0xf5, 0xf6, 0xf7 };
  10 VECT_VAR_DECL(expected_vld2_0,int,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
  11 VECT_VAR_DECL(expected_vld2_0,int,32,2) [] = { 0xfffffff0, 0xfffffff1 };
  12 VECT_VAR_DECL(expected_vld2_0,int,64,1) [] = { 0xfffffffffffffff0 };
  13 VECT_VAR_DECL(expected_vld2_0,uint,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
  14                                                0xf4, 0xf5, 0xf6, 0xf7 };
  15 VECT_VAR_DECL(expected_vld2_0,uint,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
  16 VECT_VAR_DECL(expected_vld2_0,uint,32,2) [] = { 0xfffffff0, 0xfffffff1 };
  17 VECT_VAR_DECL(expected_vld2_0,uint,64,1) [] = { 0xfffffffffffffff0 };
  18 VECT_VAR_DECL(expected_vld2_0,poly,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
  19                                                0xf4, 0xf5, 0xf6, 0xf7 };
  20 VECT_VAR_DECL(expected_vld2_0,poly,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
  21 VECT_VAR_DECL(expected_vld2_0,hfloat,32,2) [] = { 0xc1800000, 0xc1700000 };
  22 VECT_VAR_DECL(expected_vld2_0,int,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
  23                                                0xf4, 0xf5, 0xf6, 0xf7,
  24                                                0xf8, 0xf9, 0xfa, 0xfb,
  25                                                0xfc, 0xfd, 0xfe, 0xff };
  26 VECT_VAR_DECL(expected_vld2_0,int,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
  27                                                0xfff4, 0xfff5, 0xfff6, 0xfff7 };
  28 VECT_VAR_DECL(expected_vld2_0,int,32,4) [] = { 0xfffffff0, 0xfffffff1,
  29                                                0xfffffff2, 0xfffffff3 };
  30 VECT_VAR_DECL(expected_vld2_0,int,64,2) [] = { 0x3333333333333333,
  31                                                0x3333333333333333 };
  32 VECT_VAR_DECL(expected_vld2_0,uint,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
  33                                                 0xf4, 0xf5, 0xf6, 0xf7,
  34                                                 0xf8, 0xf9, 0xfa, 0xfb,
  35                                                 0xfc, 0xfd, 0xfe, 0xff };
  36 VECT_VAR_DECL(expected_vld2_0,uint,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
  37                                                 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
  38 VECT_VAR_DECL(expected_vld2_0,uint,32,4) [] = { 0xfffffff0, 0xfffffff1,
  39                                                 0xfffffff2, 0xfffffff3 };
  40 VECT_VAR_DECL(expected_vld2_0,uint,64,2) [] = { 0x3333333333333333,
  41                                                 0x3333333333333333 };
  42 VECT_VAR_DECL(expected_vld2_0,poly,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
  43                                                 0xf4, 0xf5, 0xf6, 0xf7,
  44                                                 0xf8, 0xf9, 0xfa, 0xfb,
  45                                                 0xfc, 0xfd, 0xfe, 0xff };
  46 VECT_VAR_DECL(expected_vld2_0,poly,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
  47                                                 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
  48 VECT_VAR_DECL(expected_vld2_0,hfloat,32,4) [] = { 0xc1800000, 0xc1700000,
  49                                                   0xc1600000, 0xc1500000 };
  50
  51 /* vld2/chunk 1.  */
  52 VECT_VAR_DECL(expected_vld2_1,int,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
  53                                               0xfc, 0xfd, 0xfe, 0xff };
  54 VECT_VAR_DECL(expected_vld2_1,int,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
  55 VECT_VAR_DECL(expected_vld2_1,int,32,2) [] = { 0xfffffff2, 0xfffffff3 };
  56 VECT_VAR_DECL(expected_vld2_1,int,64,1) [] = { 0xfffffffffffffff1 };
  57 VECT_VAR_DECL(expected_vld2_1,uint,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
  58                                                0xfc, 0xfd, 0xfe, 0xff };
  59 VECT_VAR_DECL(expected_vld2_1,uint,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
  60 VECT_VAR_DECL(expected_vld2_1,uint,32,2) [] = { 0xfffffff2, 0xfffffff3 };
  61 VECT_VAR_DECL(expected_vld2_1,uint,64,1) [] = { 0xfffffffffffffff1 };
  62 VECT_VAR_DECL(expected_vld2_1,poly,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
  63                                                0xfc, 0xfd, 0xfe, 0xff };
  64 VECT_VAR_DECL(expected_vld2_1,poly,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
  65 VECT_VAR_DECL(expected_vld2_1,hfloat,32,2) [] = { 0xc1600000, 0xc1500000 };
  66 VECT_VAR_DECL(expected_vld2_1,int,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
  67                                                0x4, 0x5, 0x6, 0x7,
  68                                                0x8, 0x9, 0xa, 0xb,
  69                                                0xc, 0xd, 0xe, 0xf };
  70 VECT_VAR_DECL(expected_vld2_1,int,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
  71                                                0xfffc, 0xfffd, 0xfffe, 0xffff };
  72 VECT_VAR_DECL(expected_vld2_1,int,32,4) [] = { 0xfffffff4, 0xfffffff5,
  73                                                0xfffffff6, 0xfffffff7 };
  74 VECT_VAR_DECL(expected_vld2_1,int,64,2) [] = { 0x3333333333333333,
  75                                                0x3333333333333333 };
  76 VECT_VAR_DECL(expected_vld2_1,uint,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
  77                                                 0x4, 0x5, 0x6, 0x7,
  78                                                 0x8, 0x9, 0xa, 0xb,
  79                                                 0xc, 0xd, 0xe, 0xf };
  80 VECT_VAR_DECL(expected_vld2_1,uint,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
  81                                                 0xfffc, 0xfffd, 0xfffe, 0xffff };
  82 VECT_VAR_DECL(expected_vld2_1,uint,32,4) [] = { 0xfffffff4, 0xfffffff5,
  83                                                 0xfffffff6, 0xfffffff7 };
  84 VECT_VAR_DECL(expected_vld2_1,uint,64,2) [] = { 0x3333333333333333,
  85                                                 0x3333333333333333 };
  86 VECT_VAR_DECL(expected_vld2_1,poly,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
  87                                                 0x4, 0x5, 0x6, 0x7,
  88                                                 0x8, 0x9, 0xa, 0xb,
  89                                                 0xc, 0xd, 0xe, 0xf };
  90 VECT_VAR_DECL(expected_vld2_1,poly,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
  91                                                 0xfffc, 0xfffd, 0xfffe, 0xffff };
  92 VECT_VAR_DECL(expected_vld2_1,hfloat,32,4) [] = { 0xc1400000, 0xc1300000,
  93                                                   0xc1200000, 0xc1100000 };
  94
  95 /* vld3/chunk 0.  */
  96 VECT_VAR_DECL(expected_vld3_0,int,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
  97                                               0xf4, 0xf5, 0xf6, 0xf7 };
  98 VECT_VAR_DECL(expected_vld3_0,int,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
  99 VECT_VAR_DECL(expected_vld3_0,int,32,2) [] = { 0xfffffff0, 0xfffffff1 };
 100 VECT_VAR_DECL(expected_vld3_0,int,64,1) [] = { 0xfffffffffffffff0 };
 101 VECT_VAR_DECL(expected_vld3_0,uint,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
 102                                                0xf4, 0xf5, 0xf6, 0xf7 };
 103 VECT_VAR_DECL(expected_vld3_0,uint,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
 104 VECT_VAR_DECL(expected_vld3_0,uint,32,2) [] = { 0xfffffff0, 0xfffffff1 };
 105 VECT_VAR_DECL(expected_vld3_0,uint,64,1) [] = { 0xfffffffffffffff0 };
 106 VECT_VAR_DECL(expected_vld3_0,poly,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
 107                                                0xf4, 0xf5, 0xf6, 0xf7 };
 108 VECT_VAR_DECL(expected_vld3_0,poly,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
 109 VECT_VAR_DECL(expected_vld3_0,hfloat,32,2) [] = { 0xc1800000, 0xc1700000 };
 110 VECT_VAR_DECL(expected_vld3_0,int,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
 111                                                0xf4, 0xf5, 0xf6, 0xf7,
 112                                                0xf8, 0xf9, 0xfa, 0xfb,
 113                                                0xfc, 0xfd, 0xfe, 0xff };
 114 VECT_VAR_DECL(expected_vld3_0,int,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
 115                                                0xfff4, 0xfff5, 0xfff6, 0xfff7 };
 116 VECT_VAR_DECL(expected_vld3_0,int,32,4) [] = { 0xfffffff0, 0xfffffff1,
 117                                                0xfffffff2, 0xfffffff3 };
 118 VECT_VAR_DECL(expected_vld3_0,int,64,2) [] = { 0x3333333333333333,
 119                                                0x3333333333333333 };
 120 VECT_VAR_DECL(expected_vld3_0,uint,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
 121                                                 0xf4, 0xf5, 0xf6, 0xf7,
 122                                                 0xf8, 0xf9, 0xfa, 0xfb,
 123                                                 0xfc, 0xfd, 0xfe, 0xff };
 124 VECT_VAR_DECL(expected_vld3_0,uint,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
 125                                                 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
 126 VECT_VAR_DECL(expected_vld3_0,uint,32,4) [] = { 0xfffffff0, 0xfffffff1,
 127                                                 0xfffffff2, 0xfffffff3 };
 128 VECT_VAR_DECL(expected_vld3_0,uint,64,2) [] = { 0x3333333333333333,
 129                                                 0x3333333333333333 };
 130 VECT_VAR_DECL(expected_vld3_0,poly,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
 131                                                 0xf4, 0xf5, 0xf6, 0xf7,
 132                                                 0xf8, 0xf9, 0xfa, 0xfb,
 133                                                 0xfc, 0xfd, 0xfe, 0xff };
 134 VECT_VAR_DECL(expected_vld3_0,poly,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
 135                                                 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
 136 VECT_VAR_DECL(expected_vld3_0,hfloat,32,4) [] = { 0xc1800000, 0xc1700000,
 137                                                   0xc1600000, 0xc1500000 };
 138
 139 /* vld3/chunk 1.  */
 140 VECT_VAR_DECL(expected_vld3_1,int,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
 141                                               0xfc, 0xfd, 0xfe, 0xff };
 142 VECT_VAR_DECL(expected_vld3_1,int,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
 143 VECT_VAR_DECL(expected_vld3_1,int,32,2) [] = { 0xfffffff2, 0xfffffff3 };
 144 VECT_VAR_DECL(expected_vld3_1,int,64,1) [] = { 0xfffffffffffffff1 };
 145 VECT_VAR_DECL(expected_vld3_1,uint,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
 146                                                0xfc, 0xfd, 0xfe, 0xff };
 147 VECT_VAR_DECL(expected_vld3_1,uint,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
 148 VECT_VAR_DECL(expected_vld3_1,uint,32,2) [] = { 0xfffffff2, 0xfffffff3 };
 149 VECT_VAR_DECL(expected_vld3_1,uint,64,1) [] = { 0xfffffffffffffff1 };
 150 VECT_VAR_DECL(expected_vld3_1,poly,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
 151                                                0xfc, 0xfd, 0xfe, 0xff };
 152 VECT_VAR_DECL(expected_vld3_1,poly,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
 153 VECT_VAR_DECL(expected_vld3_1,hfloat,32,2) [] = { 0xc1600000, 0xc1500000 };
 154 VECT_VAR_DECL(expected_vld3_1,int,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
 155                                                0x4, 0x5, 0x6, 0x7,
 156                                                0x8, 0x9, 0xa, 0xb,
 157                                                0xc, 0xd, 0xe, 0xf };
 158 VECT_VAR_DECL(expected_vld3_1,int,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
 159                                                0xfffc, 0xfffd, 0xfffe, 0xffff };
 160 VECT_VAR_DECL(expected_vld3_1,int,32,4) [] = { 0xfffffff4, 0xfffffff5,
 161                                                0xfffffff6, 0xfffffff7 };
 162 VECT_VAR_DECL(expected_vld3_1,int,64,2) [] = { 0x3333333333333333,
 163                                                0x3333333333333333 };
 164 VECT_VAR_DECL(expected_vld3_1,uint,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
 165                                                 0x4, 0x5, 0x6, 0x7,
 166                                                 0x8, 0x9, 0xa, 0xb,
 167                                                 0xc, 0xd, 0xe, 0xf };
 168 VECT_VAR_DECL(expected_vld3_1,uint,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
 169                                                 0xfffc, 0xfffd, 0xfffe, 0xffff };
 170 VECT_VAR_DECL(expected_vld3_1,uint,32,4) [] = { 0xfffffff4, 0xfffffff5,
 171                                                 0xfffffff6, 0xfffffff7 };
 172 VECT_VAR_DECL(expected_vld3_1,uint,64,2) [] = { 0x3333333333333333,
 173                                                 0x3333333333333333 };
 174 VECT_VAR_DECL(expected_vld3_1,poly,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
 175                                                 0x4, 0x5, 0x6, 0x7,
 176                                                 0x8, 0x9, 0xa, 0xb,
 177                                                 0xc, 0xd, 0xe, 0xf };
 178 VECT_VAR_DECL(expected_vld3_1,poly,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
 179                                                 0xfffc, 0xfffd, 0xfffe, 0xffff };
 180 VECT_VAR_DECL(expected_vld3_1,hfloat,32,4) [] = { 0xc1400000, 0xc1300000,
 181                                                   0xc1200000, 0xc1100000 };
 182
 183 /* vld3/chunk 2.  */
 184 VECT_VAR_DECL(expected_vld3_2,int,8,8) [] = { 0x0, 0x1, 0x2, 0x3,
 185                                               0x4, 0x5, 0x6, 0x7 };
 186 VECT_VAR_DECL(expected_vld3_2,int,16,4) [] = { 0xfff8, 0xfff9,
 187                                                0xfffa, 0xfffb };
 188 VECT_VAR_DECL(expected_vld3_2,int,32,2) [] = { 0xfffffff4, 0xfffffff5 };
 189 VECT_VAR_DECL(expected_vld3_2,int,64,1) [] = { 0xfffffffffffffff2 };
 190 VECT_VAR_DECL(expected_vld3_2,uint,8,8) [] = { 0x0, 0x1, 0x2, 0x3,
 191                                                0x4, 0x5, 0x6, 0x7 };
 192 VECT_VAR_DECL(expected_vld3_2,uint,16,4) [] = { 0xfff8, 0xfff9,
 193                                                 0xfffa, 0xfffb };
 194 VECT_VAR_DECL(expected_vld3_2,uint,32,2) [] = { 0xfffffff4, 0xfffffff5 };
 195 VECT_VAR_DECL(expected_vld3_2,uint,64,1) [] = { 0xfffffffffffffff2 };
 196 VECT_VAR_DECL(expected_vld3_2,poly,8,8) [] = { 0x0, 0x1, 0x2, 0x3,
 197                                                0x4, 0x5, 0x6, 0x7 };
 198 VECT_VAR_DECL(expected_vld3_2,poly,16,4) [] = { 0xfff8, 0xfff9,
 199                                                 0xfffa, 0xfffb };
 200 VECT_VAR_DECL(expected_vld3_2,hfloat,32,2) [] = { 0xc1400000, 0xc1300000 };
 201 VECT_VAR_DECL(expected_vld3_2,int,8,16) [] = { 0x10, 0x11, 0x12, 0x13,
 202                                                0x14, 0x15, 0x16, 0x17,
 203                                                0x18, 0x19, 0x1a, 0x1b,
 204                                                0x1c, 0x1d, 0x1e, 0x1f };
 205 VECT_VAR_DECL(expected_vld3_2,int,16,8) [] = { 0x0, 0x1, 0x2, 0x3,
 206                                                0x4, 0x5, 0x6, 0x7 };
 207 VECT_VAR_DECL(expected_vld3_2,int,32,4) [] = { 0xfffffff8, 0xfffffff9,
 208                                                0xfffffffa, 0xfffffffb };
 209 VECT_VAR_DECL(expected_vld3_2,int,64,2) [] = { 0x3333333333333333,
 210                                                0x3333333333333333 };
 211 VECT_VAR_DECL(expected_vld3_2,uint,8,16) [] = { 0x10, 0x11, 0x12, 0x13,
 212                                                 0x14, 0x15, 0x16, 0x17,
 213                                                 0x18, 0x19, 0x1a, 0x1b,
 214                                                 0x1c, 0x1d, 0x1e, 0x1f };
 215 VECT_VAR_DECL(expected_vld3_2,uint,16,8) [] = { 0x0, 0x1, 0x2, 0x3,
 216                                                 0x4, 0x5, 0x6, 0x7 };
 217 VECT_VAR_DECL(expected_vld3_2,uint,32,4) [] = { 0xfffffff8, 0xfffffff9,
 218                                                 0xfffffffa, 0xfffffffb };
 219 VECT_VAR_DECL(expected_vld3_2,uint,64,2) [] = { 0x3333333333333333,
 220                                                 0x3333333333333333 };
 221 VECT_VAR_DECL(expected_vld3_2,poly,8,16) [] = { 0x10, 0x11, 0x12, 0x13,
 222                                                 0x14, 0x15, 0x16, 0x17,
 223                                                 0x18, 0x19, 0x1a, 0x1b,
 224                                                 0x1c, 0x1d, 0x1e, 0x1f };
 225 VECT_VAR_DECL(expected_vld3_2,poly,16,8) [] = { 0x0, 0x1, 0x2, 0x3,
 226                                                 0x4, 0x5, 0x6, 0x7 };
 227 VECT_VAR_DECL(expected_vld3_2,hfloat,32,4) [] = { 0xc1000000, 0xc0e00000,
 228                                                   0xc0c00000, 0xc0a00000 };
 229
 230 /* vld4/chunk 0.  */
 231 VECT_VAR_DECL(expected_vld4_0,int,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
 232                                               0xf4, 0xf5, 0xf6, 0xf7 };
 233 VECT_VAR_DECL(expected_vld4_0,int,16,4) [] = { 0xfff0, 0xfff1,
 234                                                0xfff2, 0xfff3 };
 235 VECT_VAR_DECL(expected_vld4_0,int,32,2) [] = { 0xfffffff0, 0xfffffff1 };
 236 VECT_VAR_DECL(expected_vld4_0,int,64,1) [] = { 0xfffffffffffffff0 };
 237 VECT_VAR_DECL(expected_vld4_0,uint,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
 238                                                0xf4, 0xf5, 0xf6, 0xf7 };
 239 VECT_VAR_DECL(expected_vld4_0,uint,16,4) [] = { 0xfff0, 0xfff1,
 240                                                 0xfff2, 0xfff3 };
 241 VECT_VAR_DECL(expected_vld4_0,uint,32,2) [] = { 0xfffffff0, 0xfffffff1 };
 242 VECT_VAR_DECL(expected_vld4_0,uint,64,1) [] = { 0xfffffffffffffff0 };
 243 VECT_VAR_DECL(expected_vld4_0,poly,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
 244                                                0xf4, 0xf5, 0xf6, 0xf7 };
 245 VECT_VAR_DECL(expected_vld4_0,poly,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
 246 VECT_VAR_DECL(expected_vld4_0,hfloat,32,2) [] = { 0xc1800000, 0xc1700000 };
 247 VECT_VAR_DECL(expected_vld4_0,int,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
 248                                                0xf4, 0xf5, 0xf6, 0xf7,
 249                                                0xf8, 0xf9, 0xfa, 0xfb,
 250                                                0xfc, 0xfd, 0xfe, 0xff };
 251 VECT_VAR_DECL(expected_vld4_0,int,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
 252                                                0xfff4, 0xfff5, 0xfff6, 0xfff7 };
 253 VECT_VAR_DECL(expected_vld4_0,int,32,4) [] = { 0xfffffff0, 0xfffffff1,
 254                                                0xfffffff2, 0xfffffff3 };
 255 VECT_VAR_DECL(expected_vld4_0,int,64,2) [] = { 0x3333333333333333,
 256                                                0x3333333333333333 };
 257 VECT_VAR_DECL(expected_vld4_0,uint,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
 258                                                 0xf4, 0xf5, 0xf6, 0xf7,
 259                                                 0xf8, 0xf9, 0xfa, 0xfb,
 260                                                 0xfc, 0xfd, 0xfe, 0xff };
 261 VECT_VAR_DECL(expected_vld4_0,uint,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
 262                                                 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
 263 VECT_VAR_DECL(expected_vld4_0,uint,32,4) [] = { 0xfffffff0, 0xfffffff1,
 264                                                 0xfffffff2, 0xfffffff3 };
 265 VECT_VAR_DECL(expected_vld4_0,uint,64,2) [] = { 0x3333333333333333,
 266                                                 0x3333333333333333 };
 267 VECT_VAR_DECL(expected_vld4_0,poly,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
 268                                                 0xf4, 0xf5, 0xf6, 0xf7,
 269                                                 0xf8, 0xf9, 0xfa, 0xfb,
 270                                                 0xfc, 0xfd, 0xfe, 0xff };
 271 VECT_VAR_DECL(expected_vld4_0,poly,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
 272                                                 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
 273 VECT_VAR_DECL(expected_vld4_0,hfloat,32,4) [] = { 0xc1800000, 0xc1700000,
 274                                                   0xc1600000, 0xc1500000 };
 275
 276 /* vld4/chunk 1.  */
 277 VECT_VAR_DECL(expected_vld4_1,int,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
 278                                               0xfc, 0xfd, 0xfe, 0xff };
 279 VECT_VAR_DECL(expected_vld4_1,int,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
 280 VECT_VAR_DECL(expected_vld4_1,int,32,2) [] = { 0xfffffff2, 0xfffffff3 };
 281 VECT_VAR_DECL(expected_vld4_1,int,64,1) [] = { 0xfffffffffffffff1 };
 282 VECT_VAR_DECL(expected_vld4_1,uint,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
 283                                                0xfc, 0xfd, 0xfe, 0xff };
 284 VECT_VAR_DECL(expected_vld4_1,uint,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
 285 VECT_VAR_DECL(expected_vld4_1,uint,32,2) [] = { 0xfffffff2, 0xfffffff3 };
 286 VECT_VAR_DECL(expected_vld4_1,uint,64,1) [] = { 0xfffffffffffffff1 };
 287 VECT_VAR_DECL(expected_vld4_1,poly,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
 288                                                0xfc, 0xfd, 0xfe, 0xff };
 289 VECT_VAR_DECL(expected_vld4_1,poly,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
 290 VECT_VAR_DECL(expected_vld4_1,hfloat,32,2) [] = { 0xc1600000, 0xc1500000 };
 291 VECT_VAR_DECL(expected_vld4_1,int,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
 292                                                0x4, 0x5, 0x6, 0x7,
 293                                                0x8, 0x9, 0xa, 0xb,
 294                                                0xc, 0xd, 0xe, 0xf };
 295 VECT_VAR_DECL(expected_vld4_1,int,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
 296                                                0xfffc, 0xfffd, 0xfffe, 0xffff };
 297 VECT_VAR_DECL(expected_vld4_1,int,32,4) [] = { 0xfffffff4, 0xfffffff5,
 298                                                0xfffffff6, 0xfffffff7 };
 299 VECT_VAR_DECL(expected_vld4_1,int,64,2) [] = { 0x3333333333333333,
 300                                                0x3333333333333333 };
 301 VECT_VAR_DECL(expected_vld4_1,uint,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
 302                                                 0x4, 0x5, 0x6, 0x7,
 303                                                 0x8, 0x9, 0xa, 0xb,
 304                                                 0xc, 0xd, 0xe, 0xf };
 305 VECT_VAR_DECL(expected_vld4_1,uint,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
 306                                                 0xfffc, 0xfffd, 0xfffe, 0xffff };
 307 VECT_VAR_DECL(expected_vld4_1,uint,32,4) [] = { 0xfffffff4, 0xfffffff5,
 308                                                 0xfffffff6, 0xfffffff7 };
 309 VECT_VAR_DECL(expected_vld4_1,uint,64,2) [] = { 0x3333333333333333,
 310                                                 0x3333333333333333 };
 311 VECT_VAR_DECL(expected_vld4_1,poly,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
 312                                                 0x4, 0x5, 0x6, 0x7,
 313                                                 0x8, 0x9, 0xa, 0xb,
 314                                                 0xc, 0xd, 0xe, 0xf };
 315 VECT_VAR_DECL(expected_vld4_1,poly,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
 316                                                 0xfffc, 0xfffd, 0xfffe, 0xffff };
 317 VECT_VAR_DECL(expected_vld4_1,hfloat,32,4) [] = { 0xc1400000, 0xc1300000,
 318                                                   0xc1200000, 0xc1100000 };
 319
 320 /* vld4/chunk 2.  */
 321 VECT_VAR_DECL(expected_vld4_2,int,8,8) [] = { 0x0, 0x1, 0x2, 0x3,
 322                                               0x4, 0x5, 0x6, 0x7 };
 323 VECT_VAR_DECL(expected_vld4_2,int,16,4) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb };
 324 VECT_VAR_DECL(expected_vld4_2,int,32,2) [] = { 0xfffffff4, 0xfffffff5 };
 325 VECT_VAR_DECL(expected_vld4_2,int,64,1) [] = { 0xfffffffffffffff2 };
 326 VECT_VAR_DECL(expected_vld4_2,uint,8,8) [] = { 0x0, 0x1, 0x2, 0x3,
 327                                                0x4, 0x5, 0x6, 0x7 };
 328 VECT_VAR_DECL(expected_vld4_2,uint,16,4) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb };
 329 VECT_VAR_DECL(expected_vld4_2,uint,32,2) [] = { 0xfffffff4, 0xfffffff5 };
 330 VECT_VAR_DECL(expected_vld4_2,uint,64,1) [] = { 0xfffffffffffffff2 };
 331 VECT_VAR_DECL(expected_vld4_2,poly,8,8) [] = { 0x0, 0x1, 0x2, 0x3,
 332                                                0x4, 0x5, 0x6, 0x7 };
 333 VECT_VAR_DECL(expected_vld4_2,poly,16,4) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb };
 334 VECT_VAR_DECL(expected_vld4_2,hfloat,32,2) [] = { 0xc1400000, 0xc1300000 };
 335 VECT_VAR_DECL(expected_vld4_2,int,8,16) [] = { 0x10, 0x11, 0x12, 0x13,
 336                                                0x14, 0x15, 0x16, 0x17,
 337                                                0x18, 0x19, 0x1a, 0x1b,
 338                                                0x1c, 0x1d, 0x1e, 0x1f };
 339 VECT_VAR_DECL(expected_vld4_2,int,16,8) [] = { 0x0, 0x1, 0x2, 0x3,
 340                                                0x4, 0x5, 0x6, 0x7 };
 341 VECT_VAR_DECL(expected_vld4_2,int,32,4) [] = { 0xfffffff8, 0xfffffff9,
 342                                                0xfffffffa, 0xfffffffb };
 343 VECT_VAR_DECL(expected_vld4_2,int,64,2) [] = { 0x3333333333333333,
 344                                                0x3333333333333333 };
 345 VECT_VAR_DECL(expected_vld4_2,uint,8,16) [] = { 0x10, 0x11, 0x12, 0x13,
 346                                                 0x14, 0x15, 0x16, 0x17,
 347                                                 0x18, 0x19, 0x1a, 0x1b,
 348                                                 0x1c, 0x1d, 0x1e, 0x1f };
 349 VECT_VAR_DECL(expected_vld4_2,uint,16,8) [] = { 0x0, 0x1, 0x2, 0x3,
 350                                                 0x4, 0x5, 0x6, 0x7 };
 351 VECT_VAR_DECL(expected_vld4_2,uint,32,4) [] = { 0xfffffff8, 0xfffffff9,
 352                                                 0xfffffffa, 0xfffffffb };
 353 VECT_VAR_DECL(expected_vld4_2,uint,64,2) [] = { 0x3333333333333333,
 354                                                 0x3333333333333333 };
 355 VECT_VAR_DECL(expected_vld4_2,poly,8,16) [] = { 0x10, 0x11, 0x12, 0x13,
 356                                                 0x14, 0x15, 0x16, 0x17,
 357                                                 0x18, 0x19, 0x1a, 0x1b,
 358                                                 0x1c, 0x1d, 0x1e, 0x1f };
 359 VECT_VAR_DECL(expected_vld4_2,poly,16,8) [] = { 0x0, 0x1, 0x2, 0x3,
 360                                                 0x4, 0x5, 0x6, 0x7 };
 361 VECT_VAR_DECL(expected_vld4_2,hfloat,32,4) [] = { 0xc1000000, 0xc0e00000,
 362                                                   0xc0c00000, 0xc0a00000 };
 363
 364 /* vld4/chunk 3.  */
 365 VECT_VAR_DECL(expected_vld4_3,int,8,8) [] = { 0x8, 0x9, 0xa, 0xb,
 366                                               0xc, 0xd, 0xe, 0xf };
 367 VECT_VAR_DECL(expected_vld4_3,int,16,4) [] = { 0xfffc, 0xfffd, 0xfffe, 0xffff };
 368 VECT_VAR_DECL(expected_vld4_3,int,32,2) [] = { 0xfffffff6, 0xfffffff7 };
 369 VECT_VAR_DECL(expected_vld4_3,int,64,1) [] = { 0xfffffffffffffff3 };
 370 VECT_VAR_DECL(expected_vld4_3,uint,8,8) [] = { 0x8, 0x9, 0xa, 0xb,
 371                                                0xc, 0xd, 0xe, 0xf };
 372 VECT_VAR_DECL(expected_vld4_3,uint,16,4) [] = { 0xfffc, 0xfffd, 0xfffe, 0xffff };
 373 VECT_VAR_DECL(expected_vld4_3,uint,32,2) [] = { 0xfffffff6, 0xfffffff7 };
 374 VECT_VAR_DECL(expected_vld4_3,uint,64,1) [] = { 0xfffffffffffffff3 };
 375 VECT_VAR_DECL(expected_vld4_3,poly,8,8) [] = { 0x8, 0x9, 0xa, 0xb,
 376                                                0xc, 0xd, 0xe, 0xf };
 377 VECT_VAR_DECL(expected_vld4_3,poly,16,4) [] = { 0xfffc, 0xfffd, 0xfffe, 0xffff };
 378 VECT_VAR_DECL(expected_vld4_3,hfloat,32,2) [] = { 0xc1200000, 0xc1100000 };
 379 VECT_VAR_DECL(expected_vld4_3,int,8,16) [] = { 0x20, 0x21, 0x22, 0x23,
 380                                                0x24, 0x25, 0x26, 0x27,
 381                                                0x28, 0x29, 0x2a, 0x2b,
 382                                                0x2c, 0x2d, 0x2e, 0x2f };
 383 VECT_VAR_DECL(expected_vld4_3,int,16,8) [] = { 0x8, 0x9, 0xa, 0xb,
 384                                                0xc, 0xd, 0xe, 0xf };
 385 VECT_VAR_DECL(expected_vld4_3,int,32,4) [] = { 0xfffffffc, 0xfffffffd,
 386                                                0xfffffffe, 0xffffffff };
 387 VECT_VAR_DECL(expected_vld4_3,int,64,2) [] = { 0x3333333333333333,
 388                                                0x3333333333333333 };
 389 VECT_VAR_DECL(expected_vld4_3,uint,8,16) [] = { 0x20, 0x21, 0x22, 0x23,
 390                                                 0x24, 0x25, 0x26, 0x27,
 391                                                 0x28, 0x29, 0x2a, 0x2b,
 392                                                 0x2c, 0x2d, 0x2e, 0x2f };
 393 VECT_VAR_DECL(expected_vld4_3,uint,16,8) [] = { 0x8, 0x9, 0xa, 0xb,
 394                                                 0xc, 0xd, 0xe, 0xf };
 395 VECT_VAR_DECL(expected_vld4_3,uint,32,4) [] = { 0xfffffffc, 0xfffffffd,
 396                                                 0xfffffffe, 0xffffffff };
 397 VECT_VAR_DECL(expected_vld4_3,uint,64,2) [] = { 0x3333333333333333,
 398                                                 0x3333333333333333 };
 399 VECT_VAR_DECL(expected_vld4_3,poly,8,16) [] = { 0x20, 0x21, 0x22, 0x23,
 400                                                 0x24, 0x25, 0x26, 0x27,
 401                                                 0x28, 0x29, 0x2a, 0x2b,
 402                                                 0x2c, 0x2d, 0x2e, 0x2f };
 403 VECT_VAR_DECL(expected_vld4_3,poly,16,8) [] = { 0x8, 0x9, 0xa, 0xb,
 404                                                 0xc, 0xd, 0xe, 0xf };
 405 VECT_VAR_DECL(expected_vld4_3,hfloat,32,4) [] = { 0xc0800000, 0xc0400000,
 406                                                   0xc0000000, 0xbf800000 };
 407
 408 void exec_vldX (void)
 409 {
 410   /* In this case, input variables are arrays of vectors.  */
 411 #define DECL_VLDX(T1, W, N, X)                                          \
 412   VECT_ARRAY_TYPE(T1, W, N, X) VECT_ARRAY_VAR(vector, T1, W, N, X);     \
 413   VECT_VAR_DECL(result_bis_##X, T1, W, N)[X * N]
 414
 415   /* We need to use a temporary result buffer (result_bis), because
 416      the one used for other tests is not large enough. A subset of the
 417      result data is moved from result_bis to result, and it is this
 418      subset which is used to check the actual behaviour. The next
 419      macro enables to move another chunk of data from result_bis to
 420      result.  */
 421 #define TEST_VLDX(Q, T1, T2, W, N, X)                                   \
 422   VECT_ARRAY_VAR(vector, T1, W, N, X) =                                 \
 423     /* Use dedicated init buffer, of size X */                          \
 424     vld##X##Q##_##T2##W(VECT_ARRAY_VAR(buffer_vld##X, T1, W, N, X));    \
 425   vst##X##Q##_##T2##W(VECT_VAR(result_bis_##X, T1, W, N),               \
 426                       VECT_ARRAY_VAR(vector, T1, W, N, X));             \
 427   memcpy(VECT_VAR(result, T1, W, N), VECT_VAR(result_bis_##X, T1, W, N), \
 428          sizeof(VECT_VAR(result, T1, W, N)));
 429
 430   /* Overwrite "result" with the contents of "result_bis"[Y].  */
 431 #define TEST_EXTRA_CHUNK(T1, W, N, X,Y)                 \
 432   memcpy(VECT_VAR(result, T1, W, N),                    \
 433          &(VECT_VAR(result_bis_##X, T1, W, N)[Y*N]),    \
 434          sizeof(VECT_VAR(result, T1, W, N)));
 435
 436   /* We need all variants in 64 bits, but there is no 64x2 variant.  */
 437 #define DECL_ALL_VLDX(X)                        \
 438   DECL_VLDX(int, 8, 8, X);                      \
 439   DECL_VLDX(int, 16, 4, X);                     \
 440   DECL_VLDX(int, 32, 2, X);                     \
 441   DECL_VLDX(int, 64, 1, X);                     \
 442   DECL_VLDX(uint, 8, 8, X);                     \
 443   DECL_VLDX(uint, 16, 4, X);                    \
 444   DECL_VLDX(uint, 32, 2, X);                    \
 445   DECL_VLDX(uint, 64, 1, X);                    \
 446   DECL_VLDX(poly, 8, 8, X);                     \
 447   DECL_VLDX(poly, 16, 4, X);                    \
 448   DECL_VLDX(float, 32, 2, X);                   \
 449   DECL_VLDX(int, 8, 16, X);                     \
 450   DECL_VLDX(int, 16, 8, X);                     \
 451   DECL_VLDX(int, 32, 4, X);                     \
 452   DECL_VLDX(uint, 8, 16, X);                    \
 453   DECL_VLDX(uint, 16, 8, X);                    \
 454   DECL_VLDX(uint, 32, 4, X);                    \
 455   DECL_VLDX(poly, 8, 16, X);                    \
 456   DECL_VLDX(poly, 16, 8, X);                    \
 457   DECL_VLDX(float, 32, 4, X)
 458
 459 #define TEST_ALL_VLDX(X)                        \
 460   TEST_VLDX(, int, s, 8, 8, X);                 \
 461   TEST_VLDX(, int, s, 16, 4, X);                \
 462   TEST_VLDX(, int, s, 32, 2, X);                \
 463   TEST_VLDX(, int, s, 64, 1, X);                \
 464   TEST_VLDX(, uint, u, 8, 8, X);                \
 465   TEST_VLDX(, uint, u, 16, 4, X);               \
 466   TEST_VLDX(, uint, u, 32, 2, X);               \
 467   TEST_VLDX(, uint, u, 64, 1, X);               \
 468   TEST_VLDX(, poly, p, 8, 8, X);                \
 469   TEST_VLDX(, poly, p, 16, 4, X);               \
 470   TEST_VLDX(, float, f, 32, 2, X);              \
 471   TEST_VLDX(q, int, s, 8, 16, X);               \
 472   TEST_VLDX(q, int, s, 16, 8, X);               \
 473   TEST_VLDX(q, int, s, 32, 4, X);               \
 474   TEST_VLDX(q, uint, u, 8, 16, X);              \
 475   TEST_VLDX(q, uint, u, 16, 8, X);              \
 476   TEST_VLDX(q, uint, u, 32, 4, X);              \
 477   TEST_VLDX(q, poly, p, 8, 16, X);              \
 478   TEST_VLDX(q, poly, p, 16, 8, X);              \
 479   TEST_VLDX(q, float, f, 32, 4, X)
 480
 481 #define TEST_ALL_EXTRA_CHUNKS(X, Y)             \
 482   TEST_EXTRA_CHUNK(int, 8, 8, X, Y);            \
 483   TEST_EXTRA_CHUNK(int, 16, 4, X, Y);           \
 484   TEST_EXTRA_CHUNK(int, 32, 2, X, Y);           \
 485   TEST_EXTRA_CHUNK(int, 64, 1, X, Y);           \
 486   TEST_EXTRA_CHUNK(uint, 8, 8, X, Y);           \
 487   TEST_EXTRA_CHUNK(uint, 16, 4, X, Y);          \
 488   TEST_EXTRA_CHUNK(uint, 32, 2, X, Y);          \
 489   TEST_EXTRA_CHUNK(uint, 64, 1, X, Y);          \
 490   TEST_EXTRA_CHUNK(poly, 8, 8, X, Y);           \
 491   TEST_EXTRA_CHUNK(poly, 16, 4, X, Y);          \
 492   TEST_EXTRA_CHUNK(float, 32, 2, X, Y);         \
 493   TEST_EXTRA_CHUNK(int, 8, 16, X, Y);           \
 494   TEST_EXTRA_CHUNK(int, 16, 8, X, Y);           \
 495   TEST_EXTRA_CHUNK(int, 32, 4, X, Y);           \
 496   TEST_EXTRA_CHUNK(uint, 8, 16, X, Y);          \
 497   TEST_EXTRA_CHUNK(uint, 16, 8, X, Y);          \
 498   TEST_EXTRA_CHUNK(uint, 32, 4, X, Y);          \
 499   TEST_EXTRA_CHUNK(poly, 8, 16, X, Y);          \
 500   TEST_EXTRA_CHUNK(poly, 16, 8, X, Y);          \
 501   TEST_EXTRA_CHUNK(float, 32, 4, X, Y)
 502
 503   DECL_ALL_VLDX(2);
 504   DECL_ALL_VLDX(3);
 505   DECL_ALL_VLDX(4);
 506
 507   /* Special input buffers of suitable size are needed for vld2/vld3/vld4.  */
 508   /* Input buffers for vld2, 1 of each size */
 509   VECT_ARRAY_INIT2(buffer_vld2, int, 8, 8);
 510   PAD(buffer_vld2_pad, int, 8, 8);
 511   VECT_ARRAY_INIT2(buffer_vld2, int, 16, 4);
 512   PAD(buffer_vld2_pad, int, 16, 4);
 513   VECT_ARRAY_INIT2(buffer_vld2, int, 32, 2);
 514   PAD(buffer_vld2_pad, int, 32, 2);
 515   VECT_ARRAY_INIT2(buffer_vld2, int, 64, 1);
 516   PAD(buffer_vld2_pad, int, 64, 1);
 517   VECT_ARRAY_INIT2(buffer_vld2, uint, 8, 8);
 518   PAD(buffer_vld2_pad, uint, 8, 8);
 519   VECT_ARRAY_INIT2(buffer_vld2, uint, 16, 4);
 520   PAD(buffer_vld2_pad, uint, 16, 4);
 521   VECT_ARRAY_INIT2(buffer_vld2, uint, 32, 2);
 522   PAD(buffer_vld2_pad, uint, 32, 2);
 523   VECT_ARRAY_INIT2(buffer_vld2, uint, 64, 1);
 524   PAD(buffer_vld2_pad, uint, 64, 1);
 525   VECT_ARRAY_INIT2(buffer_vld2, poly, 8, 8);
 526   PAD(buffer_vld2_pad, poly, 8, 8);
 527   VECT_ARRAY_INIT2(buffer_vld2, poly, 16, 4);
 528   PAD(buffer_vld2_pad, poly, 16, 4);
 529   VECT_ARRAY_INIT2(buffer_vld2, float, 32, 2);
 530   PAD(buffer_vld2_pad, float, 32, 2);
 531
 532   VECT_ARRAY_INIT2(buffer_vld2, int, 8, 16);
 533   PAD(buffer_vld2_pad, int, 8, 16);
 534   VECT_ARRAY_INIT2(buffer_vld2, int, 16, 8);
 535   PAD(buffer_vld2_pad, int, 16, 8);
 536   VECT_ARRAY_INIT2(buffer_vld2, int, 32, 4);
 537   PAD(buffer_vld2_pad, int, 32, 4);
 538   VECT_ARRAY_INIT2(buffer_vld2, int, 64, 2);
 539   PAD(buffer_vld2_pad, int, 64, 2);
 540   VECT_ARRAY_INIT2(buffer_vld2, uint, 8, 16);
 541   PAD(buffer_vld2_pad, uint, 8, 16);
 542   VECT_ARRAY_INIT2(buffer_vld2, uint, 16, 8);
 543   PAD(buffer_vld2_pad, uint, 16, 8);
 544   VECT_ARRAY_INIT2(buffer_vld2, uint, 32, 4);
 545   PAD(buffer_vld2_pad, uint, 32, 4);
 546   VECT_ARRAY_INIT2(buffer_vld2, uint, 64, 2);
 547   PAD(buffer_vld2_pad, uint, 64, 2);
 548   VECT_ARRAY_INIT2(buffer_vld2, poly, 8, 16);
 549   PAD(buffer_vld2_pad, poly, 8, 16);
 550   VECT_ARRAY_INIT2(buffer_vld2, poly, 16, 8);
 551   PAD(buffer_vld2_pad, poly, 16, 8);
 552   VECT_ARRAY_INIT2(buffer_vld2, float, 32, 4);
 553   PAD(buffer_vld2_pad, float, 32, 4);
 554
 555   /* Input buffers for vld3, 1 of each size */
 556   VECT_ARRAY_INIT3(buffer_vld3, int, 8, 8);
 557   PAD(buffer_vld3_pad, int, 8, 8);
 558   VECT_ARRAY_INIT3(buffer_vld3, int, 16, 4);
 559   PAD(buffer_vld3_pad, int, 16, 4);
 560   VECT_ARRAY_INIT3(buffer_vld3, int, 32, 2);
 561   PAD(buffer_vld3_pad, int, 32, 2);
 562   VECT_ARRAY_INIT3(buffer_vld3, int, 64, 1);
 563   PAD(buffer_vld3_pad, int, 64, 1);
 564   VECT_ARRAY_INIT3(buffer_vld3, uint, 8, 8);
 565   PAD(buffer_vld3_pad, uint, 8, 8);
 566   VECT_ARRAY_INIT3(buffer_vld3, uint, 16, 4);
 567   PAD(buffer_vld3_pad, uint, 16, 4);
 568   VECT_ARRAY_INIT3(buffer_vld3, uint, 32, 2);
 569   PAD(buffer_vld3_pad, uint, 32, 2);
 570   VECT_ARRAY_INIT3(buffer_vld3, uint, 64, 1);
 571   PAD(buffer_vld3_pad, uint, 64, 1);
 572   VECT_ARRAY_INIT3(buffer_vld3, poly, 8, 8);
 573   PAD(buffer_vld3_pad, poly, 8, 8);
 574   VECT_ARRAY_INIT3(buffer_vld3, poly, 16, 4);
 575   PAD(buffer_vld3_pad, poly, 16, 4);
 576   VECT_ARRAY_INIT3(buffer_vld3, float, 32, 2);
 577   PAD(buffer_vld3_pad, float, 32, 2);
 578
 579   VECT_ARRAY_INIT3(buffer_vld3, int, 8, 16);
 580   PAD(buffer_vld3_pad, int, 8, 16);
 581   VECT_ARRAY_INIT3(buffer_vld3, int, 16, 8);
 582   PAD(buffer_vld3_pad, int, 16, 8);
 583   VECT_ARRAY_INIT3(buffer_vld3, int, 32, 4);
 584   PAD(buffer_vld3_pad, int, 32, 4);
 585   VECT_ARRAY_INIT3(buffer_vld3, int, 64, 2);
 586   PAD(buffer_vld3_pad, int, 64, 2);
 587   VECT_ARRAY_INIT3(buffer_vld3, uint, 8, 16);
 588   PAD(buffer_vld3_pad, uint, 8, 16);
 589   VECT_ARRAY_INIT3(buffer_vld3, uint, 16, 8);
 590   PAD(buffer_vld3_pad, uint, 16, 8);
 591   VECT_ARRAY_INIT3(buffer_vld3, uint, 32, 4);
 592   PAD(buffer_vld3_pad, uint, 32, 4);
 593   VECT_ARRAY_INIT3(buffer_vld3, uint, 64, 2);
 594   PAD(buffer_vld3_pad, uint, 64, 2);
 595   VECT_ARRAY_INIT3(buffer_vld3, poly, 8, 16);
 596   PAD(buffer_vld3_pad, poly, 8, 16);
 597   VECT_ARRAY_INIT3(buffer_vld3, poly, 16, 8);
 598   PAD(buffer_vld3_pad, poly, 16, 8);
 599   VECT_ARRAY_INIT3(buffer_vld3, float, 32, 4);
 600   PAD(buffer_vld3_pad, float, 32, 4);
 601
 602   /* Input buffers for vld4, 1 of each size */
 603   VECT_ARRAY_INIT4(buffer_vld4, int, 8, 8);
 604   PAD(buffer_vld4_pad, int, 8, 8);
 605   VECT_ARRAY_INIT4(buffer_vld4, int, 16, 4);
 606   PAD(buffer_vld4_pad, int, 16, 4);
 607   VECT_ARRAY_INIT4(buffer_vld4, int, 32, 2);
 608   PAD(buffer_vld4_pad, int, 32, 2);
 609   VECT_ARRAY_INIT4(buffer_vld4, int, 64, 1);
 610   PAD(buffer_vld4_pad, int, 64, 1);
 611   VECT_ARRAY_INIT4(buffer_vld4, uint, 8, 8);
 612   PAD(buffer_vld4_pad, uint, 8, 8);
 613   VECT_ARRAY_INIT4(buffer_vld4, uint, 16, 4);
 614   PAD(buffer_vld4_pad, uint, 16, 4);
 615   VECT_ARRAY_INIT4(buffer_vld4, uint, 32, 2);
 616   PAD(buffer_vld4_pad, uint, 32, 2);
 617   VECT_ARRAY_INIT4(buffer_vld4, uint, 64, 1);
 618   PAD(buffer_vld4_pad, uint, 64, 1);
 619   VECT_ARRAY_INIT4(buffer_vld4, poly, 8, 8);
 620   PAD(buffer_vld4_pad, poly, 8, 8);
 621   VECT_ARRAY_INIT4(buffer_vld4, poly, 16, 4);
 622   PAD(buffer_vld4_pad, poly, 16, 4);
 623   VECT_ARRAY_INIT4(buffer_vld4, float, 32, 2);
 624   PAD(buffer_vld4_pad, float, 32, 2);
 625
 626   VECT_ARRAY_INIT4(buffer_vld4, int, 8, 16);
 627   PAD(buffer_vld4_pad, int, 8, 16);
 628   VECT_ARRAY_INIT4(buffer_vld4, int, 16, 8);
 629   PAD(buffer_vld4_pad, int, 16, 8);
 630   VECT_ARRAY_INIT4(buffer_vld4, int, 32, 4);
 631   PAD(buffer_vld4_pad, int, 32, 4);
 632   VECT_ARRAY_INIT4(buffer_vld4, int, 64, 2);
 633   PAD(buffer_vld4_pad, int, 64, 2);
 634   VECT_ARRAY_INIT4(buffer_vld4, uint, 8, 16);
 635   PAD(buffer_vld4_pad, uint, 8, 16);
 636   VECT_ARRAY_INIT4(buffer_vld4, uint, 16, 8);
 637   PAD(buffer_vld4_pad, uint, 16, 8);
 638   VECT_ARRAY_INIT4(buffer_vld4, uint, 32, 4);
 639   PAD(buffer_vld4_pad, uint, 32, 4);
 640   VECT_ARRAY_INIT4(buffer_vld4, uint, 64, 2);
 641   PAD(buffer_vld4_pad, uint, 64, 2);
 642   VECT_ARRAY_INIT4(buffer_vld4, poly, 8, 16);
 643   PAD(buffer_vld4_pad, poly, 8, 16);
 644   VECT_ARRAY_INIT4(buffer_vld4, poly, 16, 8);
 645   PAD(buffer_vld4_pad, poly, 16, 8);
 646   VECT_ARRAY_INIT4(buffer_vld4, float, 32, 4);
 647   PAD(buffer_vld4_pad, float, 32, 4);
 648
 649   /* Check vld2/vld2q.  */
 650   clean_results ();
 651 #define TEST_MSG "VLD2/VLD2Q"
 652   TEST_ALL_VLDX(2);
 653   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld2_0, "chunk 0");
 654
 655   TEST_ALL_EXTRA_CHUNKS(2, 1);
 656   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld2_1, "chunk 1");
 657
 658   /* Check vld3/vld3q.  */
 659   clean_results ();
 660 #undef TEST_MSG
 661 #define TEST_MSG "VLD3/VLD3Q"
 662   TEST_ALL_VLDX(3);
 663   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld3_0, "chunk 0");
 664
 665   TEST_ALL_EXTRA_CHUNKS(3, 1);
 666   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld3_1, "chunk 1");
 667
 668   TEST_ALL_EXTRA_CHUNKS(3, 2);
 669   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld3_2, "chunk 2");
 670
 671   /* Check vld4/vld4q.  */
 672   clean_results ();
 673 #undef TEST_MSG
 674 #define TEST_MSG "VLD4/VLD4Q"
 675   TEST_ALL_VLDX(4);
 676   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld4_0, "chunk 0");
 677
 678   TEST_ALL_EXTRA_CHUNKS(4, 1);
 679   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld4_1, "chunk 1");
 680
 681   TEST_ALL_EXTRA_CHUNKS(4, 2);
 682   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld4_2, "chunk 2");
 683
 684   TEST_ALL_EXTRA_CHUNKS(4, 3);
 685   CHECK_RESULTS_NAMED (TEST_MSG, expected_vld4_3, "chunk 3");
 686 }
 687
 688 int main (void)
 689 {
 690   exec_vldX ();
 691   return 0;
 692 }