test/CodeGen/arm_neon_intrinsics.c

   1 // RUN: %clang_cc1 -triple thumbv7s-apple-darwin -target-abi apcs-gnu\
   2 // RUN:  -target-cpu swift -ffreestanding -Os -S -o - %s\
   3 // RUN:  | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-SWIFT
   4 // RUN: %clang_cc1 -triple armv8-linux-gnu \
   5 // RUN:  -target-cpu cortex-a57 -mfloat-abi soft -ffreestanding -Os -S -o - %s\
   6 // RUN:  | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-A57
   7
   8 // REQUIRES: long_tests
   9
  10 #include <arm_neon.h>
  11
  12 // CHECK-LABEL: test_vaba_s8
  13 // CHECK: vaba.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
  14 int8x8_t test_vaba_s8(int8x8_t a, int8x8_t b, int8x8_t c) {
  15   return vaba_s8(a, b, c);
  16 }
  17
  18 // CHECK-LABEL: test_vaba_s16
  19 // CHECK: vaba.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
  20 int16x4_t test_vaba_s16(int16x4_t a, int16x4_t b, int16x4_t c) {
  21   return vaba_s16(a, b, c);
  22 }
  23
  24 // CHECK-LABEL: test_vaba_s32
  25 // CHECK: vaba.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
  26 int32x2_t test_vaba_s32(int32x2_t a, int32x2_t b, int32x2_t c) {
  27   return vaba_s32(a, b, c);
  28 }
  29
  30 // CHECK-LABEL: test_vaba_u8
  31 // CHECK: vaba.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
  32 uint8x8_t test_vaba_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) {
  33   return vaba_u8(a, b, c);
  34 }
  35
  36 // CHECK-LABEL: test_vaba_u16
  37 // CHECK: vaba.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
  38 uint16x4_t test_vaba_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) {
  39   return vaba_u16(a, b, c);
  40 }
  41
  42 // CHECK-LABEL: test_vaba_u32
  43 // CHECK: vaba.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
  44 uint32x2_t test_vaba_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) {
  45   return vaba_u32(a, b, c);
  46 }
  47
  48 // CHECK-LABEL: test_vabaq_s8
  49 // CHECK: vaba.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
  50 int8x16_t test_vabaq_s8(int8x16_t a, int8x16_t b, int8x16_t c) {
  51   return vabaq_s8(a, b, c);
  52 }
  53
  54 // CHECK-LABEL: test_vabaq_s16
  55 // CHECK: vaba.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
  56 int16x8_t test_vabaq_s16(int16x8_t a, int16x8_t b, int16x8_t c) {
  57   return vabaq_s16(a, b, c);
  58 }
  59
  60 // CHECK-LABEL: test_vabaq_s32
  61 // CHECK: vaba.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
  62 int32x4_t test_vabaq_s32(int32x4_t a, int32x4_t b, int32x4_t c) {
  63   return vabaq_s32(a, b, c);
  64 }
  65
  66 // CHECK-LABEL: test_vabaq_u8
  67 // CHECK: vaba.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
  68 uint8x16_t test_vabaq_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) {
  69   return vabaq_u8(a, b, c);
  70 }
  71
  72 // CHECK-LABEL: test_vabaq_u16
  73 // CHECK: vaba.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
  74 uint16x8_t test_vabaq_u16(uint16x8_t a, uint16x8_t b, uint16x8_t c) {
  75   return vabaq_u16(a, b, c);
  76 }
  77
  78 // CHECK-LABEL: test_vabaq_u32
  79 // CHECK: vaba.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
  80 uint32x4_t test_vabaq_u32(uint32x4_t a, uint32x4_t b, uint32x4_t c) {
  81   return vabaq_u32(a, b, c);
  82 }
  83
  84
  85 // CHECK-LABEL: test_vabal_s8
  86 // CHECK: vabal.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
  87 int16x8_t test_vabal_s8(int16x8_t a, int8x8_t b, int8x8_t c) {
  88   return vabal_s8(a, b, c);
  89 }
  90
  91 // CHECK-LABEL: test_vabal_s16
  92 // CHECK: vabal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
  93 int32x4_t test_vabal_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
  94   return vabal_s16(a, b, c);
  95 }
  96
  97 // CHECK-LABEL: test_vabal_s32
  98 // CHECK: vabal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
  99 int64x2_t test_vabal_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
 100   return vabal_s32(a, b, c);
 101 }
 102
 103 // CHECK-LABEL: test_vabal_u8
 104 // CHECK: vabal.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 105 uint16x8_t test_vabal_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) {
 106   return vabal_u8(a, b, c);
 107 }
 108
 109 // CHECK-LABEL: test_vabal_u16
 110 // CHECK: vabal.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 111 uint32x4_t test_vabal_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) {
 112   return vabal_u16(a, b, c);
 113 }
 114
 115 // CHECK-LABEL: test_vabal_u32
 116 // CHECK: vabal.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 117 uint64x2_t test_vabal_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) {
 118   return vabal_u32(a, b, c);
 119 }
 120
 121
 122 // CHECK-LABEL: test_vabd_s8
 123 // CHECK: vabd.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 124 int8x8_t test_vabd_s8(int8x8_t a, int8x8_t b) {
 125   return vabd_s8(a, b);
 126 }
 127
 128 // CHECK-LABEL: test_vabd_s16
 129 // CHECK: vabd.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 130 int16x4_t test_vabd_s16(int16x4_t a, int16x4_t b) {
 131   return vabd_s16(a, b);
 132 }
 133
 134 // CHECK-LABEL: test_vabd_s32
 135 // CHECK: vabd.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 136 int32x2_t test_vabd_s32(int32x2_t a, int32x2_t b) {
 137   return vabd_s32(a, b);
 138 }
 139
 140 // CHECK-LABEL: test_vabd_u8
 141 // CHECK: vabd.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 142 uint8x8_t test_vabd_u8(uint8x8_t a, uint8x8_t b) {
 143   return vabd_u8(a, b);
 144 }
 145
 146 // CHECK-LABEL: test_vabd_u16
 147 // CHECK: vabd.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 148 uint16x4_t test_vabd_u16(uint16x4_t a, uint16x4_t b) {
 149   return vabd_u16(a, b);
 150 }
 151
 152 // CHECK-LABEL: test_vabd_u32
 153 // CHECK: vabd.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 154 uint32x2_t test_vabd_u32(uint32x2_t a, uint32x2_t b) {
 155   return vabd_u32(a, b);
 156 }
 157
 158 // CHECK-LABEL: test_vabd_f32
 159 // CHECK: vabd.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 160 float32x2_t test_vabd_f32(float32x2_t a, float32x2_t b) {
 161   return vabd_f32(a, b);
 162 }
 163
 164 // CHECK-LABEL: test_vabdq_s8
 165 // CHECK: vabd.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 166 int8x16_t test_vabdq_s8(int8x16_t a, int8x16_t b) {
 167   return vabdq_s8(a, b);
 168 }
 169
 170 // CHECK-LABEL: test_vabdq_s16
 171 // CHECK: vabd.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 172 int16x8_t test_vabdq_s16(int16x8_t a, int16x8_t b) {
 173   return vabdq_s16(a, b);
 174 }
 175
 176 // CHECK-LABEL: test_vabdq_s32
 177 // CHECK: vabd.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 178 int32x4_t test_vabdq_s32(int32x4_t a, int32x4_t b) {
 179   return vabdq_s32(a, b);
 180 }
 181
 182 // CHECK-LABEL: test_vabdq_u8
 183 // CHECK: vabd.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 184 uint8x16_t test_vabdq_u8(uint8x16_t a, uint8x16_t b) {
 185   return vabdq_u8(a, b);
 186 }
 187
 188 // CHECK-LABEL: test_vabdq_u16
 189 // CHECK: vabd.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 190 uint16x8_t test_vabdq_u16(uint16x8_t a, uint16x8_t b) {
 191   return vabdq_u16(a, b);
 192 }
 193
 194 // CHECK-LABEL: test_vabdq_u32
 195 // CHECK: vabd.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 196 uint32x4_t test_vabdq_u32(uint32x4_t a, uint32x4_t b) {
 197   return vabdq_u32(a, b);
 198 }
 199
 200 // CHECK-LABEL: test_vabdq_f32
 201 // CHECK: vabd.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 202 float32x4_t test_vabdq_f32(float32x4_t a, float32x4_t b) {
 203   return vabdq_f32(a, b);
 204 }
 205
 206
 207 // CHECK-LABEL: test_vabdl_s8
 208 // CHECK: vabdl.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 209 int16x8_t test_vabdl_s8(int8x8_t a, int8x8_t b) {
 210   return vabdl_s8(a, b);
 211 }
 212
 213 // CHECK-LABEL: test_vabdl_s16
 214 // CHECK: vabdl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 215 int32x4_t test_vabdl_s16(int16x4_t a, int16x4_t b) {
 216   return vabdl_s16(a, b);
 217 }
 218
 219 // CHECK-LABEL: test_vabdl_s32
 220 // CHECK: vabdl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 221 int64x2_t test_vabdl_s32(int32x2_t a, int32x2_t b) {
 222   return vabdl_s32(a, b);
 223 }
 224
 225 // CHECK-LABEL: test_vabdl_u8
 226 // CHECK: vabdl.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 227 uint16x8_t test_vabdl_u8(uint8x8_t a, uint8x8_t b) {
 228   return vabdl_u8(a, b);
 229 }
 230
 231 // CHECK-LABEL: test_vabdl_u16
 232 // CHECK: vabdl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 233 uint32x4_t test_vabdl_u16(uint16x4_t a, uint16x4_t b) {
 234   return vabdl_u16(a, b);
 235 }
 236
 237 // CHECK-LABEL: test_vabdl_u32
 238 // CHECK: vabdl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 239 uint64x2_t test_vabdl_u32(uint32x2_t a, uint32x2_t b) {
 240   return vabdl_u32(a, b);
 241 }
 242
 243
 244 // CHECK-LABEL: test_vabs_s8
 245 // CHECK: vabs.s8 d{{[0-9]+}}, d{{[0-9]+}}
 246 int8x8_t test_vabs_s8(int8x8_t a) {
 247   return vabs_s8(a);
 248 }
 249
 250 // CHECK-LABEL: test_vabs_s16
 251 // CHECK: vabs.s16 d{{[0-9]+}}, d{{[0-9]+}}
 252 int16x4_t test_vabs_s16(int16x4_t a) {
 253   return vabs_s16(a);
 254 }
 255
 256 // CHECK-LABEL: test_vabs_s32
 257 // CHECK: vabs.s32 d{{[0-9]+}}, d{{[0-9]+}}
 258 int32x2_t test_vabs_s32(int32x2_t a) {
 259   return vabs_s32(a);
 260 }
 261
 262 // CHECK-LABEL: test_vabs_f32
 263 // CHECK: vabs.f32 d{{[0-9]+}}, d{{[0-9]+}}
 264 float32x2_t test_vabs_f32(float32x2_t a) {
 265   return vabs_f32(a);
 266 }
 267
 268 // CHECK-LABEL: test_vabsq_s8
 269 // CHECK: vabs.s8 q{{[0-9]+}}, q{{[0-9]+}}
 270 int8x16_t test_vabsq_s8(int8x16_t a) {
 271   return vabsq_s8(a);
 272 }
 273
 274 // CHECK-LABEL: test_vabsq_s16
 275 // CHECK: vabs.s16 q{{[0-9]+}}, q{{[0-9]+}}
 276 int16x8_t test_vabsq_s16(int16x8_t a) {
 277   return vabsq_s16(a);
 278 }
 279
 280 // CHECK-LABEL: test_vabsq_s32
 281 // CHECK: vabs.s32 q{{[0-9]+}}, q{{[0-9]+}}
 282 int32x4_t test_vabsq_s32(int32x4_t a) {
 283   return vabsq_s32(a);
 284 }
 285
 286 // CHECK-LABEL: test_vabsq_f32
 287 // CHECK: vabs.f32 q{{[0-9]+}}, q{{[0-9]+}}
 288 float32x4_t test_vabsq_f32(float32x4_t a) {
 289   return vabsq_f32(a);
 290 }
 291
 292
 293 // CHECK-LABEL: test_vadd_s8
 294 // CHECK: vadd.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 295 int8x8_t test_vadd_s8(int8x8_t a, int8x8_t b) {
 296   return vadd_s8(a, b);
 297 }
 298
 299 // CHECK-LABEL: test_vadd_s16
 300 // CHECK: vadd.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 301 int16x4_t test_vadd_s16(int16x4_t a, int16x4_t b) {
 302   return vadd_s16(a, b);
 303 }
 304
 305 // CHECK-LABEL: test_vadd_s32
 306 // CHECK: vadd.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 307 int32x2_t test_vadd_s32(int32x2_t a, int32x2_t b) {
 308   return vadd_s32(a, b);
 309 }
 310
 311 // CHECK-LABEL: test_vadd_s64
 312 // CHECK: vadd.i64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 313 int64x1_t test_vadd_s64(int64x1_t a, int64x1_t b) {
 314   return vadd_s64(a, b);
 315 }
 316
 317 // CHECK-LABEL: test_vadd_f32
 318 // CHECK: vadd.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 319 float32x2_t test_vadd_f32(float32x2_t a, float32x2_t b) {
 320   return vadd_f32(a, b);
 321 }
 322
 323 // CHECK-LABEL: test_vadd_u8
 324 // CHECK: vadd.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 325 uint8x8_t test_vadd_u8(uint8x8_t a, uint8x8_t b) {
 326   return vadd_u8(a, b);
 327 }
 328
 329 // CHECK-LABEL: test_vadd_u16
 330 // CHECK: vadd.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 331 uint16x4_t test_vadd_u16(uint16x4_t a, uint16x4_t b) {
 332   return vadd_u16(a, b);
 333 }
 334
 335 // CHECK-LABEL: test_vadd_u32
 336 // CHECK: vadd.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 337 uint32x2_t test_vadd_u32(uint32x2_t a, uint32x2_t b) {
 338   return vadd_u32(a, b);
 339 }
 340
 341 // CHECK-LABEL: test_vadd_u64
 342 // CHECK: vadd.i64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 343 uint64x1_t test_vadd_u64(uint64x1_t a, uint64x1_t b) {
 344   return vadd_u64(a, b);
 345 }
 346
 347 // CHECK-LABEL: test_vaddq_s8
 348 // CHECK: vadd.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 349 int8x16_t test_vaddq_s8(int8x16_t a, int8x16_t b) {
 350   return vaddq_s8(a, b);
 351 }
 352
 353 // CHECK-LABEL: test_vaddq_s16
 354 // CHECK: vadd.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 355 int16x8_t test_vaddq_s16(int16x8_t a, int16x8_t b) {
 356   return vaddq_s16(a, b);
 357 }
 358
 359 // CHECK-LABEL: test_vaddq_s32
 360 // CHECK: vadd.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 361 int32x4_t test_vaddq_s32(int32x4_t a, int32x4_t b) {
 362   return vaddq_s32(a, b);
 363 }
 364
 365 // CHECK-LABEL: test_vaddq_s64
 366 // CHECK: vadd.i64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 367 int64x2_t test_vaddq_s64(int64x2_t a, int64x2_t b) {
 368   return vaddq_s64(a, b);
 369 }
 370
 371 // CHECK-LABEL: test_vaddq_f32
 372 // CHECK: vadd.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 373 float32x4_t test_vaddq_f32(float32x4_t a, float32x4_t b) {
 374   return vaddq_f32(a, b);
 375 }
 376
 377 // CHECK-LABEL: test_vaddq_u8
 378 // CHECK: vadd.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 379 uint8x16_t test_vaddq_u8(uint8x16_t a, uint8x16_t b) {
 380   return vaddq_u8(a, b);
 381 }
 382
 383 // CHECK-LABEL: test_vaddq_u16
 384 // CHECK: vadd.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 385 uint16x8_t test_vaddq_u16(uint16x8_t a, uint16x8_t b) {
 386   return vaddq_u16(a, b);
 387 }
 388
 389 // CHECK-LABEL: test_vaddq_u32
 390 // CHECK: vadd.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 391 uint32x4_t test_vaddq_u32(uint32x4_t a, uint32x4_t b) {
 392   return vaddq_u32(a, b);
 393 }
 394
 395 // CHECK-LABEL: test_vaddq_u64
 396 // CHECK: vadd.i64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 397 uint64x2_t test_vaddq_u64(uint64x2_t a, uint64x2_t b) {
 398   return vaddq_u64(a, b);
 399 }
 400
 401
 402 // CHECK-LABEL: test_vaddhn_s16
 403 // CHECK: vaddhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 404 int8x8_t test_vaddhn_s16(int16x8_t a, int16x8_t b) {
 405   return vaddhn_s16(a, b);
 406 }
 407
 408 // CHECK-LABEL: test_vaddhn_s32
 409 // CHECK: vaddhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 410 int16x4_t test_vaddhn_s32(int32x4_t a, int32x4_t b) {
 411   return vaddhn_s32(a, b);
 412 }
 413
 414 // CHECK-LABEL: test_vaddhn_s64
 415 // CHECK: vaddhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 416 int32x2_t test_vaddhn_s64(int64x2_t a, int64x2_t b) {
 417   return vaddhn_s64(a, b);
 418 }
 419
 420 // CHECK-LABEL: test_vaddhn_u16
 421 // CHECK: vaddhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 422 uint8x8_t test_vaddhn_u16(uint16x8_t a, uint16x8_t b) {
 423   return vaddhn_u16(a, b);
 424 }
 425
 426 // CHECK-LABEL: test_vaddhn_u32
 427 // CHECK: vaddhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 428 uint16x4_t test_vaddhn_u32(uint32x4_t a, uint32x4_t b) {
 429   return vaddhn_u32(a, b);
 430 }
 431
 432 // CHECK-LABEL: test_vaddhn_u64
 433 // CHECK: vaddhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 434 uint32x2_t test_vaddhn_u64(uint64x2_t a, uint64x2_t b) {
 435   return vaddhn_u64(a, b);
 436 }
 437
 438
 439 // CHECK-LABEL: test_vaddl_s8
 440 // CHECK: vaddl.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 441 int16x8_t test_vaddl_s8(int8x8_t a, int8x8_t b) {
 442   return vaddl_s8(a, b);
 443 }
 444
 445 // CHECK-LABEL: test_vaddl_s16
 446 // CHECK: vaddl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 447 int32x4_t test_vaddl_s16(int16x4_t a, int16x4_t b) {
 448   return vaddl_s16(a, b);
 449 }
 450
 451 // CHECK-LABEL: test_vaddl_s32
 452 // CHECK: vaddl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 453 int64x2_t test_vaddl_s32(int32x2_t a, int32x2_t b) {
 454   return vaddl_s32(a, b);
 455 }
 456
 457 // CHECK-LABEL: test_vaddl_u8
 458 // CHECK: vaddl.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 459 uint16x8_t test_vaddl_u8(uint8x8_t a, uint8x8_t b) {
 460   return vaddl_u8(a, b);
 461 }
 462
 463 // CHECK-LABEL: test_vaddl_u16
 464 // CHECK: vaddl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 465 uint32x4_t test_vaddl_u16(uint16x4_t a, uint16x4_t b) {
 466   return vaddl_u16(a, b);
 467 }
 468
 469 // CHECK-LABEL: test_vaddl_u32
 470 // CHECK: vaddl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 471 uint64x2_t test_vaddl_u32(uint32x2_t a, uint32x2_t b) {
 472   return vaddl_u32(a, b);
 473 }
 474
 475
 476 // CHECK-LABEL: test_vaddw_s8
 477 // CHECK: vaddw.s8 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}
 478 int16x8_t test_vaddw_s8(int16x8_t a, int8x8_t b) {
 479   return vaddw_s8(a, b);
 480 }
 481
 482 // CHECK-LABEL: test_vaddw_s16
 483 // CHECK: vaddw.s16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}
 484 int32x4_t test_vaddw_s16(int32x4_t a, int16x4_t b) {
 485   return vaddw_s16(a, b);
 486 }
 487
 488 // CHECK-LABEL: test_vaddw_s32
 489 // CHECK: vaddw.s32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}
 490 int64x2_t test_vaddw_s32(int64x2_t a, int32x2_t b) {
 491   return vaddw_s32(a, b);
 492 }
 493
 494 // CHECK-LABEL: test_vaddw_u8
 495 // CHECK: vaddw.u8 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}
 496 uint16x8_t test_vaddw_u8(uint16x8_t a, uint8x8_t b) {
 497   return vaddw_u8(a, b);
 498 }
 499
 500 // CHECK-LABEL: test_vaddw_u16
 501 // CHECK: vaddw.u16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}
 502 uint32x4_t test_vaddw_u16(uint32x4_t a, uint16x4_t b) {
 503   return vaddw_u16(a, b);
 504 }
 505
 506 // CHECK-LABEL: test_vaddw_u32
 507 // CHECK: vaddw.u32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}
 508 uint64x2_t test_vaddw_u32(uint64x2_t a, uint32x2_t b) {
 509   return vaddw_u32(a, b);
 510 }
 511
 512
 513 // CHECK-LABEL: test_vand_s8
 514 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 515 int8x8_t test_vand_s8(int8x8_t a, int8x8_t b) {
 516   return vand_s8(a, b);
 517 }
 518
 519 // CHECK-LABEL: test_vand_s16
 520 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 521 int16x4_t test_vand_s16(int16x4_t a, int16x4_t b) {
 522   return vand_s16(a, b);
 523 }
 524
 525 // CHECK-LABEL: test_vand_s32
 526 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 527 int32x2_t test_vand_s32(int32x2_t a, int32x2_t b) {
 528   return vand_s32(a, b);
 529 }
 530
 531 // CHECK-LABEL: test_vand_s64
 532 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 533 int64x1_t test_vand_s64(int64x1_t a, int64x1_t b) {
 534   return vand_s64(a, b);
 535 }
 536
 537 // CHECK-LABEL: test_vand_u8
 538 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 539 uint8x8_t test_vand_u8(uint8x8_t a, uint8x8_t b) {
 540   return vand_u8(a, b);
 541 }
 542
 543 // CHECK-LABEL: test_vand_u16
 544 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 545 uint16x4_t test_vand_u16(uint16x4_t a, uint16x4_t b) {
 546   return vand_u16(a, b);
 547 }
 548
 549 // CHECK-LABEL: test_vand_u32
 550 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 551 uint32x2_t test_vand_u32(uint32x2_t a, uint32x2_t b) {
 552   return vand_u32(a, b);
 553 }
 554
 555 // CHECK-LABEL: test_vand_u64
 556 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 557 uint64x1_t test_vand_u64(uint64x1_t a, uint64x1_t b) {
 558   return vand_u64(a, b);
 559 }
 560
 561 // CHECK-LABEL: test_vandq_s8
 562 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 563 int8x16_t test_vandq_s8(int8x16_t a, int8x16_t b) {
 564   return vandq_s8(a, b);
 565 }
 566
 567 // CHECK-LABEL: test_vandq_s16
 568 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 569 int16x8_t test_vandq_s16(int16x8_t a, int16x8_t b) {
 570   return vandq_s16(a, b);
 571 }
 572
 573 // CHECK-LABEL: test_vandq_s32
 574 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 575 int32x4_t test_vandq_s32(int32x4_t a, int32x4_t b) {
 576   return vandq_s32(a, b);
 577 }
 578
 579 // CHECK-LABEL: test_vandq_s64
 580 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 581 int64x2_t test_vandq_s64(int64x2_t a, int64x2_t b) {
 582   return vandq_s64(a, b);
 583 }
 584
 585 // CHECK-LABEL: test_vandq_u8
 586 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 587 uint8x16_t test_vandq_u8(uint8x16_t a, uint8x16_t b) {
 588   return vandq_u8(a, b);
 589 }
 590
 591 // CHECK-LABEL: test_vandq_u16
 592 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 593 uint16x8_t test_vandq_u16(uint16x8_t a, uint16x8_t b) {
 594   return vandq_u16(a, b);
 595 }
 596
 597 // CHECK-LABEL: test_vandq_u32
 598 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 599 uint32x4_t test_vandq_u32(uint32x4_t a, uint32x4_t b) {
 600   return vandq_u32(a, b);
 601 }
 602
 603 // CHECK-LABEL: test_vandq_u64
 604 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 605 uint64x2_t test_vandq_u64(uint64x2_t a, uint64x2_t b) {
 606   return vandq_u64(a, b);
 607 }
 608
 609
 610 // CHECK-LABEL: test_vbic_s8
 611 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 612 int8x8_t test_vbic_s8(int8x8_t a, int8x8_t b) {
 613   return vbic_s8(a, b);
 614 }
 615
 616 // CHECK-LABEL: test_vbic_s16
 617 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 618 int16x4_t test_vbic_s16(int16x4_t a, int16x4_t b) {
 619   return vbic_s16(a, b);
 620 }
 621
 622 // CHECK-LABEL: test_vbic_s32
 623 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 624 int32x2_t test_vbic_s32(int32x2_t a, int32x2_t b) {
 625   return vbic_s32(a, b);
 626 }
 627
 628 // CHECK-LABEL: test_vbic_s64
 629 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 630 int64x1_t test_vbic_s64(int64x1_t a, int64x1_t b) {
 631   return vbic_s64(a, b);
 632 }
 633
 634 // CHECK-LABEL: test_vbic_u8
 635 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 636 uint8x8_t test_vbic_u8(uint8x8_t a, uint8x8_t b) {
 637   return vbic_u8(a, b);
 638 }
 639
 640 // CHECK-LABEL: test_vbic_u16
 641 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 642 uint16x4_t test_vbic_u16(uint16x4_t a, uint16x4_t b) {
 643   return vbic_u16(a, b);
 644 }
 645
 646 // CHECK-LABEL: test_vbic_u32
 647 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 648 uint32x2_t test_vbic_u32(uint32x2_t a, uint32x2_t b) {
 649   return vbic_u32(a, b);
 650 }
 651
 652 // CHECK-LABEL: test_vbic_u64
 653 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 654 uint64x1_t test_vbic_u64(uint64x1_t a, uint64x1_t b) {
 655   return vbic_u64(a, b);
 656 }
 657
 658 // CHECK-LABEL: test_vbicq_s8
 659 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 660 int8x16_t test_vbicq_s8(int8x16_t a, int8x16_t b) {
 661   return vbicq_s8(a, b);
 662 }
 663
 664 // CHECK-LABEL: test_vbicq_s16
 665 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 666 int16x8_t test_vbicq_s16(int16x8_t a, int16x8_t b) {
 667   return vbicq_s16(a, b);
 668 }
 669
 670 // CHECK-LABEL: test_vbicq_s32
 671 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 672 int32x4_t test_vbicq_s32(int32x4_t a, int32x4_t b) {
 673   return vbicq_s32(a, b);
 674 }
 675
 676 // CHECK-LABEL: test_vbicq_s64
 677 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 678 int64x2_t test_vbicq_s64(int64x2_t a, int64x2_t b) {
 679   return vbicq_s64(a, b);
 680 }
 681
 682 // CHECK-LABEL: test_vbicq_u8
 683 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 684 uint8x16_t test_vbicq_u8(uint8x16_t a, uint8x16_t b) {
 685   return vbicq_u8(a, b);
 686 }
 687
 688 // CHECK-LABEL: test_vbicq_u16
 689 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 690 uint16x8_t test_vbicq_u16(uint16x8_t a, uint16x8_t b) {
 691   return vbicq_u16(a, b);
 692 }
 693
 694 // CHECK-LABEL: test_vbicq_u32
 695 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 696 uint32x4_t test_vbicq_u32(uint32x4_t a, uint32x4_t b) {
 697   return vbicq_u32(a, b);
 698 }
 699
 700 // CHECK-LABEL: test_vbicq_u64
 701 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 702 uint64x2_t test_vbicq_u64(uint64x2_t a, uint64x2_t b) {
 703   return vbicq_u64(a, b);
 704 }
 705
 706
 707 // CHECK-LABEL: test_vbsl_s8
 708 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 709 int8x8_t test_vbsl_s8(uint8x8_t a, int8x8_t b, int8x8_t c) {
 710   return vbsl_s8(a, b, c);
 711 }
 712
 713 // CHECK-LABEL: test_vbsl_s16
 714 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 715 int16x4_t test_vbsl_s16(uint16x4_t a, int16x4_t b, int16x4_t c) {
 716   return vbsl_s16(a, b, c);
 717 }
 718
 719 // CHECK-LABEL: test_vbsl_s32
 720 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 721 int32x2_t test_vbsl_s32(uint32x2_t a, int32x2_t b, int32x2_t c) {
 722   return vbsl_s32(a, b, c);
 723 }
 724
 725 // CHECK-LABEL: test_vbsl_s64
 726 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 727 int64x1_t test_vbsl_s64(uint64x1_t a, int64x1_t b, int64x1_t c) {
 728   return vbsl_s64(a, b, c);
 729 }
 730
 731 // CHECK-LABEL: test_vbsl_u8
 732 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 733 uint8x8_t test_vbsl_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) {
 734   return vbsl_u8(a, b, c);
 735 }
 736
 737 // CHECK-LABEL: test_vbsl_u16
 738 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 739 uint16x4_t test_vbsl_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) {
 740   return vbsl_u16(a, b, c);
 741 }
 742
 743 // CHECK-LABEL: test_vbsl_u32
 744 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 745 uint32x2_t test_vbsl_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) {
 746   return vbsl_u32(a, b, c);
 747 }
 748
 749 // CHECK-LABEL: test_vbsl_u64
 750 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 751 uint64x1_t test_vbsl_u64(uint64x1_t a, uint64x1_t b, uint64x1_t c) {
 752   return vbsl_u64(a, b, c);
 753 }
 754
 755 // CHECK-LABEL: test_vbsl_f32
 756 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 757 float32x2_t test_vbsl_f32(uint32x2_t a, float32x2_t b, float32x2_t c) {
 758   return vbsl_f32(a, b, c);
 759 }
 760
 761 // CHECK-LABEL: test_vbsl_p8
 762 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 763 poly8x8_t test_vbsl_p8(uint8x8_t a, poly8x8_t b, poly8x8_t c) {
 764   return vbsl_p8(a, b, c);
 765 }
 766
 767 // CHECK-LABEL: test_vbsl_p16
 768 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 769 poly16x4_t test_vbsl_p16(uint16x4_t a, poly16x4_t b, poly16x4_t c) {
 770   return vbsl_p16(a, b, c);
 771 }
 772
 773 // CHECK-LABEL: test_vbslq_s8
 774 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 775 int8x16_t test_vbslq_s8(uint8x16_t a, int8x16_t b, int8x16_t c) {
 776   return vbslq_s8(a, b, c);
 777 }
 778
 779 // CHECK-LABEL: test_vbslq_s16
 780 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 781 int16x8_t test_vbslq_s16(uint16x8_t a, int16x8_t b, int16x8_t c) {
 782   return vbslq_s16(a, b, c);
 783 }
 784
 785 // CHECK-LABEL: test_vbslq_s32
 786 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 787 int32x4_t test_vbslq_s32(uint32x4_t a, int32x4_t b, int32x4_t c) {
 788   return vbslq_s32(a, b, c);
 789 }
 790
 791 // CHECK-LABEL: test_vbslq_s64
 792 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 793 int64x2_t test_vbslq_s64(uint64x2_t a, int64x2_t b, int64x2_t c) {
 794   return vbslq_s64(a, b, c);
 795 }
 796
 797 // CHECK-LABEL: test_vbslq_u8
 798 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 799 uint8x16_t test_vbslq_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) {
 800   return vbslq_u8(a, b, c);
 801 }
 802
 803 // CHECK-LABEL: test_vbslq_u16
 804 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 805 uint16x8_t test_vbslq_u16(uint16x8_t a, uint16x8_t b, uint16x8_t c) {
 806   return vbslq_u16(a, b, c);
 807 }
 808
 809 // CHECK-LABEL: test_vbslq_u32
 810 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 811 uint32x4_t test_vbslq_u32(uint32x4_t a, uint32x4_t b, uint32x4_t c) {
 812   return vbslq_u32(a, b, c);
 813 }
 814
 815 // CHECK-LABEL: test_vbslq_u64
 816 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 817 uint64x2_t test_vbslq_u64(uint64x2_t a, uint64x2_t b, uint64x2_t c) {
 818   return vbslq_u64(a, b, c);
 819 }
 820
 821 // CHECK-LABEL: test_vbslq_f32
 822 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 823 float32x4_t test_vbslq_f32(uint32x4_t a, float32x4_t b, float32x4_t c) {
 824   return vbslq_f32(a, b, c);
 825 }
 826
 827 // CHECK-LABEL: test_vbslq_p8
 828 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 829 poly8x16_t test_vbslq_p8(uint8x16_t a, poly8x16_t b, poly8x16_t c) {
 830   return vbslq_p8(a, b, c);
 831 }
 832
 833 // CHECK-LABEL: test_vbslq_p16
 834 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 835 poly16x8_t test_vbslq_p16(uint16x8_t a, poly16x8_t b, poly16x8_t c) {
 836   return vbslq_p16(a, b, c);
 837 }
 838
 839
 840 // CHECK-LABEL: test_vcage_f32
 841 // CHECK: vacge.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 842 uint32x2_t test_vcage_f32(float32x2_t a, float32x2_t b) {
 843   return vcage_f32(a, b);
 844 }
 845
 846 // CHECK-LABEL: test_vcageq_f32
 847 // CHECK: vacge.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 848 uint32x4_t test_vcageq_f32(float32x4_t a, float32x4_t b) {
 849   return vcageq_f32(a, b);
 850 }
 851
 852
 853 // CHECK-LABEL: test_vcagt_f32
 854 // CHECK: vacgt.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 855 uint32x2_t test_vcagt_f32(float32x2_t a, float32x2_t b) {
 856   return vcagt_f32(a, b);
 857 }
 858
 859 // CHECK-LABEL: test_vcagtq_f32
 860 // CHECK: vacgt.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 861 uint32x4_t test_vcagtq_f32(float32x4_t a, float32x4_t b) {
 862   return vcagtq_f32(a, b);
 863 }
 864
 865
 866 // CHECK-LABEL: test_vcale_f32
 867 // CHECK: vacge.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 868 uint32x2_t test_vcale_f32(float32x2_t a, float32x2_t b) {
 869   return vcale_f32(a, b);
 870 }
 871
 872 // CHECK-LABEL: test_vcaleq_f32
 873 // CHECK: vacge.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 874 uint32x4_t test_vcaleq_f32(float32x4_t a, float32x4_t b) {
 875   return vcaleq_f32(a, b);
 876 }
 877
 878
 879 // CHECK-LABEL: test_vcalt_f32
 880 // CHECK: vacgt.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 881 uint32x2_t test_vcalt_f32(float32x2_t a, float32x2_t b) {
 882   return vcalt_f32(a, b);
 883 }
 884
 885 // CHECK-LABEL: test_vcaltq_f32
 886 // CHECK: vacgt.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 887 uint32x4_t test_vcaltq_f32(float32x4_t a, float32x4_t b) {
 888   return vcaltq_f32(a, b);
 889 }
 890
 891
 892 // CHECK-LABEL: test_vceq_s8
 893 // CHECK: vceq.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 894 uint8x8_t test_vceq_s8(int8x8_t a, int8x8_t b) {
 895   return vceq_s8(a, b);
 896 }
 897
 898 // CHECK-LABEL: test_vceq_s16
 899 // CHECK: vceq.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 900 uint16x4_t test_vceq_s16(int16x4_t a, int16x4_t b) {
 901   return vceq_s16(a, b);
 902 }
 903
 904 // CHECK-LABEL: test_vceq_s32
 905 // CHECK: vceq.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 906 uint32x2_t test_vceq_s32(int32x2_t a, int32x2_t b) {
 907   return vceq_s32(a, b);
 908 }
 909
 910 // CHECK-LABEL: test_vceq_f32
 911 // CHECK: vceq.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 912 uint32x2_t test_vceq_f32(float32x2_t a, float32x2_t b) {
 913   return vceq_f32(a, b);
 914 }
 915
 916 // CHECK-LABEL: test_vceq_u8
 917 // CHECK: vceq.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 918 uint8x8_t test_vceq_u8(uint8x8_t a, uint8x8_t b) {
 919   return vceq_u8(a, b);
 920 }
 921
 922 // CHECK-LABEL: test_vceq_u16
 923 // CHECK: vceq.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 924 uint16x4_t test_vceq_u16(uint16x4_t a, uint16x4_t b) {
 925   return vceq_u16(a, b);
 926 }
 927
 928 // CHECK-LABEL: test_vceq_u32
 929 // CHECK: vceq.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 930 uint32x2_t test_vceq_u32(uint32x2_t a, uint32x2_t b) {
 931   return vceq_u32(a, b);
 932 }
 933
 934 // CHECK-LABEL: test_vceq_p8
 935 // CHECK: vceq.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 936 uint8x8_t test_vceq_p8(poly8x8_t a, poly8x8_t b) {
 937   return vceq_p8(a, b);
 938 }
 939
 940 // CHECK-LABEL: test_vceqq_s8
 941 // CHECK: vceq.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 942 uint8x16_t test_vceqq_s8(int8x16_t a, int8x16_t b) {
 943   return vceqq_s8(a, b);
 944 }
 945
 946 // CHECK-LABEL: test_vceqq_s16
 947 // CHECK: vceq.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 948 uint16x8_t test_vceqq_s16(int16x8_t a, int16x8_t b) {
 949   return vceqq_s16(a, b);
 950 }
 951
 952 // CHECK-LABEL: test_vceqq_s32
 953 // CHECK: vceq.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 954 uint32x4_t test_vceqq_s32(int32x4_t a, int32x4_t b) {
 955   return vceqq_s32(a, b);
 956 }
 957
 958 // CHECK-LABEL: test_vceqq_f32
 959 // CHECK: vceq.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 960 uint32x4_t test_vceqq_f32(float32x4_t a, float32x4_t b) {
 961   return vceqq_f32(a, b);
 962 }
 963
 964 // CHECK-LABEL: test_vceqq_u8
 965 // CHECK: vceq.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 966 uint8x16_t test_vceqq_u8(uint8x16_t a, uint8x16_t b) {
 967   return vceqq_u8(a, b);
 968 }
 969
 970 // CHECK-LABEL: test_vceqq_u16
 971 // CHECK: vceq.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 972 uint16x8_t test_vceqq_u16(uint16x8_t a, uint16x8_t b) {
 973   return vceqq_u16(a, b);
 974 }
 975
 976 // CHECK-LABEL: test_vceqq_u32
 977 // CHECK: vceq.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 978 uint32x4_t test_vceqq_u32(uint32x4_t a, uint32x4_t b) {
 979   return vceqq_u32(a, b);
 980 }
 981
 982 // CHECK-LABEL: test_vceqq_p8
 983 // CHECK: vceq.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
 984 uint8x16_t test_vceqq_p8(poly8x16_t a, poly8x16_t b) {
 985   return vceqq_p8(a, b);
 986 }
 987
 988
 989 // CHECK-LABEL: test_vcge_s8
 990 // CHECK: vcge.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 991 uint8x8_t test_vcge_s8(int8x8_t a, int8x8_t b) {
 992   return vcge_s8(a, b);
 993 }
 994
 995 // CHECK-LABEL: test_vcge_s16
 996 // CHECK: vcge.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
 997 uint16x4_t test_vcge_s16(int16x4_t a, int16x4_t b) {
 998   return vcge_s16(a, b);
 999 }
1000
1001 // CHECK-LABEL: test_vcge_s32
1002 // CHECK: vcge.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1003 uint32x2_t test_vcge_s32(int32x2_t a, int32x2_t b) {
1004   return vcge_s32(a, b);
1005 }
1006
1007 // CHECK-LABEL: test_vcge_f32
1008 // CHECK: vcge.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1009 uint32x2_t test_vcge_f32(float32x2_t a, float32x2_t b) {
1010   return vcge_f32(a, b);
1011 }
1012
1013 // CHECK-LABEL: test_vcge_u8
1014 // CHECK: vcge.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1015 uint8x8_t test_vcge_u8(uint8x8_t a, uint8x8_t b) {
1016   return vcge_u8(a, b);
1017 }
1018
1019 // CHECK-LABEL: test_vcge_u16
1020 // CHECK: vcge.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1021 uint16x4_t test_vcge_u16(uint16x4_t a, uint16x4_t b) {
1022   return vcge_u16(a, b);
1023 }
1024
1025 // CHECK-LABEL: test_vcge_u32
1026 // CHECK: vcge.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1027 uint32x2_t test_vcge_u32(uint32x2_t a, uint32x2_t b) {
1028   return vcge_u32(a, b);
1029 }
1030
1031 // CHECK-LABEL: test_vcgeq_s8
1032 // CHECK: vcge.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1033 uint8x16_t test_vcgeq_s8(int8x16_t a, int8x16_t b) {
1034   return vcgeq_s8(a, b);
1035 }
1036
1037 // CHECK-LABEL: test_vcgeq_s16
1038 // CHECK: vcge.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1039 uint16x8_t test_vcgeq_s16(int16x8_t a, int16x8_t b) {
1040   return vcgeq_s16(a, b);
1041 }
1042
1043 // CHECK-LABEL: test_vcgeq_s32
1044 // CHECK: vcge.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1045 uint32x4_t test_vcgeq_s32(int32x4_t a, int32x4_t b) {
1046   return vcgeq_s32(a, b);
1047 }
1048
1049 // CHECK-LABEL: test_vcgeq_f32
1050 // CHECK: vcge.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1051 uint32x4_t test_vcgeq_f32(float32x4_t a, float32x4_t b) {
1052   return vcgeq_f32(a, b);
1053 }
1054
1055 // CHECK-LABEL: test_vcgeq_u8
1056 // CHECK: vcge.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1057 uint8x16_t test_vcgeq_u8(uint8x16_t a, uint8x16_t b) {
1058   return vcgeq_u8(a, b);
1059 }
1060
1061 // CHECK-LABEL: test_vcgeq_u16
1062 // CHECK: vcge.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1063 uint16x8_t test_vcgeq_u16(uint16x8_t a, uint16x8_t b) {
1064   return vcgeq_u16(a, b);
1065 }
1066
1067 // CHECK-LABEL: test_vcgeq_u32
1068 // CHECK: vcge.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1069 uint32x4_t test_vcgeq_u32(uint32x4_t a, uint32x4_t b) {
1070   return vcgeq_u32(a, b);
1071 }
1072
1073
1074 // CHECK-LABEL: test_vcgt_s8
1075 // CHECK: vcgt.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1076 uint8x8_t test_vcgt_s8(int8x8_t a, int8x8_t b) {
1077   return vcgt_s8(a, b);
1078 }
1079
1080 // CHECK-LABEL: test_vcgt_s16
1081 // CHECK: vcgt.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1082 uint16x4_t test_vcgt_s16(int16x4_t a, int16x4_t b) {
1083   return vcgt_s16(a, b);
1084 }
1085
1086 // CHECK-LABEL: test_vcgt_s32
1087 // CHECK: vcgt.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1088 uint32x2_t test_vcgt_s32(int32x2_t a, int32x2_t b) {
1089   return vcgt_s32(a, b);
1090 }
1091
1092 // CHECK-LABEL: test_vcgt_f32
1093 // CHECK: vcgt.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1094 uint32x2_t test_vcgt_f32(float32x2_t a, float32x2_t b) {
1095   return vcgt_f32(a, b);
1096 }
1097
1098 // CHECK-LABEL: test_vcgt_u8
1099 // CHECK: vcgt.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1100 uint8x8_t test_vcgt_u8(uint8x8_t a, uint8x8_t b) {
1101   return vcgt_u8(a, b);
1102 }
1103
1104 // CHECK-LABEL: test_vcgt_u16
1105 // CHECK: vcgt.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1106 uint16x4_t test_vcgt_u16(uint16x4_t a, uint16x4_t b) {
1107   return vcgt_u16(a, b);
1108 }
1109
1110 // CHECK-LABEL: test_vcgt_u32
1111 // CHECK: vcgt.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1112 uint32x2_t test_vcgt_u32(uint32x2_t a, uint32x2_t b) {
1113   return vcgt_u32(a, b);
1114 }
1115
1116 // CHECK-LABEL: test_vcgtq_s8
1117 // CHECK: vcgt.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1118 uint8x16_t test_vcgtq_s8(int8x16_t a, int8x16_t b) {
1119   return vcgtq_s8(a, b);
1120 }
1121
1122 // CHECK-LABEL: test_vcgtq_s16
1123 // CHECK: vcgt.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1124 uint16x8_t test_vcgtq_s16(int16x8_t a, int16x8_t b) {
1125   return vcgtq_s16(a, b);
1126 }
1127
1128 // CHECK-LABEL: test_vcgtq_s32
1129 // CHECK: vcgt.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1130 uint32x4_t test_vcgtq_s32(int32x4_t a, int32x4_t b) {
1131   return vcgtq_s32(a, b);
1132 }
1133
1134 // CHECK-LABEL: test_vcgtq_f32
1135 // CHECK: vcgt.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1136 uint32x4_t test_vcgtq_f32(float32x4_t a, float32x4_t b) {
1137   return vcgtq_f32(a, b);
1138 }
1139
1140 // CHECK-LABEL: test_vcgtq_u8
1141 // CHECK: vcgt.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1142 uint8x16_t test_vcgtq_u8(uint8x16_t a, uint8x16_t b) {
1143   return vcgtq_u8(a, b);
1144 }
1145
1146 // CHECK-LABEL: test_vcgtq_u16
1147 // CHECK: vcgt.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1148 uint16x8_t test_vcgtq_u16(uint16x8_t a, uint16x8_t b) {
1149   return vcgtq_u16(a, b);
1150 }
1151
1152 // CHECK-LABEL: test_vcgtq_u32
1153 // CHECK: vcgt.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1154 uint32x4_t test_vcgtq_u32(uint32x4_t a, uint32x4_t b) {
1155   return vcgtq_u32(a, b);
1156 }
1157
1158
1159 // CHECK-LABEL: test_vcle_s8
1160 // CHECK: vcge.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1161 uint8x8_t test_vcle_s8(int8x8_t a, int8x8_t b) {
1162   return vcle_s8(a, b);
1163 }
1164
1165 // CHECK-LABEL: test_vcle_s16
1166 // CHECK: vcge.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1167 uint16x4_t test_vcle_s16(int16x4_t a, int16x4_t b) {
1168   return vcle_s16(a, b);
1169 }
1170
1171 // CHECK-LABEL: test_vcle_s32
1172 // CHECK: vcge.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1173 uint32x2_t test_vcle_s32(int32x2_t a, int32x2_t b) {
1174   return vcle_s32(a, b);
1175 }
1176
1177 // CHECK-LABEL: test_vcle_f32
1178 // CHECK: vcge.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1179 uint32x2_t test_vcle_f32(float32x2_t a, float32x2_t b) {
1180   return vcle_f32(a, b);
1181 }
1182
1183 // CHECK-LABEL: test_vcle_u8
1184 // CHECK: vcge.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1185 uint8x8_t test_vcle_u8(uint8x8_t a, uint8x8_t b) {
1186   return vcle_u8(a, b);
1187 }
1188
1189 // CHECK-LABEL: test_vcle_u16
1190 // CHECK: vcge.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1191 uint16x4_t test_vcle_u16(uint16x4_t a, uint16x4_t b) {
1192   return vcle_u16(a, b);
1193 }
1194
1195 // CHECK-LABEL: test_vcle_u32
1196 // CHECK: vcge.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1197 uint32x2_t test_vcle_u32(uint32x2_t a, uint32x2_t b) {
1198   return vcle_u32(a, b);
1199 }
1200
1201 // CHECK-LABEL: test_vcleq_s8
1202 // CHECK: vcge.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1203 uint8x16_t test_vcleq_s8(int8x16_t a, int8x16_t b) {
1204   return vcleq_s8(a, b);
1205 }
1206
1207 // CHECK-LABEL: test_vcleq_s16
1208 // CHECK: vcge.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1209 uint16x8_t test_vcleq_s16(int16x8_t a, int16x8_t b) {
1210   return vcleq_s16(a, b);
1211 }
1212
1213 // CHECK-LABEL: test_vcleq_s32
1214 // CHECK: vcge.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1215 uint32x4_t test_vcleq_s32(int32x4_t a, int32x4_t b) {
1216   return vcleq_s32(a, b);
1217 }
1218
1219 // CHECK-LABEL: test_vcleq_f32
1220 // CHECK: vcge.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1221 uint32x4_t test_vcleq_f32(float32x4_t a, float32x4_t b) {
1222   return vcleq_f32(a, b);
1223 }
1224
1225 // CHECK-LABEL: test_vcleq_u8
1226 // CHECK: vcge.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1227 uint8x16_t test_vcleq_u8(uint8x16_t a, uint8x16_t b) {
1228   return vcleq_u8(a, b);
1229 }
1230
1231 // CHECK-LABEL: test_vcleq_u16
1232 // CHECK: vcge.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1233 uint16x8_t test_vcleq_u16(uint16x8_t a, uint16x8_t b) {
1234   return vcleq_u16(a, b);
1235 }
1236
1237 // CHECK-LABEL: test_vcleq_u32
1238 // CHECK: vcge.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1239 uint32x4_t test_vcleq_u32(uint32x4_t a, uint32x4_t b) {
1240   return vcleq_u32(a, b);
1241 }
1242
1243
1244 // CHECK-LABEL: test_vcls_s8
1245 // CHECK: vcls.s8 d{{[0-9]+}}, d{{[0-9]+}}
1246 int8x8_t test_vcls_s8(int8x8_t a) {
1247   return vcls_s8(a);
1248 }
1249
1250 // CHECK-LABEL: test_vcls_s16
1251 // CHECK: vcls.s16 d{{[0-9]+}}, d{{[0-9]+}}
1252 int16x4_t test_vcls_s16(int16x4_t a) {
1253   return vcls_s16(a);
1254 }
1255
1256 // CHECK-LABEL: test_vcls_s32
1257 // CHECK: vcls.s32 d{{[0-9]+}}, d{{[0-9]+}}
1258 int32x2_t test_vcls_s32(int32x2_t a) {
1259   return vcls_s32(a);
1260 }
1261
1262 // CHECK-LABEL: test_vclsq_s8
1263 // CHECK: vcls.s8 q{{[0-9]+}}, q{{[0-9]+}}
1264 int8x16_t test_vclsq_s8(int8x16_t a) {
1265   return vclsq_s8(a);
1266 }
1267
1268 // CHECK-LABEL: test_vclsq_s16
1269 // CHECK: vcls.s16 q{{[0-9]+}}, q{{[0-9]+}}
1270 int16x8_t test_vclsq_s16(int16x8_t a) {
1271   return vclsq_s16(a);
1272 }
1273
1274 // CHECK-LABEL: test_vclsq_s32
1275 // CHECK: vcls.s32 q{{[0-9]+}}, q{{[0-9]+}}
1276 int32x4_t test_vclsq_s32(int32x4_t a) {
1277   return vclsq_s32(a);
1278 }
1279
1280
1281 // CHECK-LABEL: test_vclt_s8
1282 // CHECK: vcgt.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1283 uint8x8_t test_vclt_s8(int8x8_t a, int8x8_t b) {
1284   return vclt_s8(a, b);
1285 }
1286
1287 // CHECK-LABEL: test_vclt_s16
1288 // CHECK: vcgt.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1289 uint16x4_t test_vclt_s16(int16x4_t a, int16x4_t b) {
1290   return vclt_s16(a, b);
1291 }
1292
1293 // CHECK-LABEL: test_vclt_s32
1294 // CHECK: vcgt.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1295 uint32x2_t test_vclt_s32(int32x2_t a, int32x2_t b) {
1296   return vclt_s32(a, b);
1297 }
1298
1299 // CHECK-LABEL: test_vclt_f32
1300 // CHECK: vcgt.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1301 uint32x2_t test_vclt_f32(float32x2_t a, float32x2_t b) {
1302   return vclt_f32(a, b);
1303 }
1304
1305 // CHECK-LABEL: test_vclt_u8
1306 // CHECK: vcgt.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1307 uint8x8_t test_vclt_u8(uint8x8_t a, uint8x8_t b) {
1308   return vclt_u8(a, b);
1309 }
1310
1311 // CHECK-LABEL: test_vclt_u16
1312 // CHECK: vcgt.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1313 uint16x4_t test_vclt_u16(uint16x4_t a, uint16x4_t b) {
1314   return vclt_u16(a, b);
1315 }
1316
1317 // CHECK-LABEL: test_vclt_u32
1318 // CHECK: vcgt.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1319 uint32x2_t test_vclt_u32(uint32x2_t a, uint32x2_t b) {
1320   return vclt_u32(a, b);
1321 }
1322
1323 // CHECK-LABEL: test_vcltq_s8
1324 // CHECK: vcgt.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1325 uint8x16_t test_vcltq_s8(int8x16_t a, int8x16_t b) {
1326   return vcltq_s8(a, b);
1327 }
1328
1329 // CHECK-LABEL: test_vcltq_s16
1330 // CHECK: vcgt.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1331 uint16x8_t test_vcltq_s16(int16x8_t a, int16x8_t b) {
1332   return vcltq_s16(a, b);
1333 }
1334
1335 // CHECK-LABEL: test_vcltq_s32
1336 // CHECK: vcgt.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1337 uint32x4_t test_vcltq_s32(int32x4_t a, int32x4_t b) {
1338   return vcltq_s32(a, b);
1339 }
1340
1341 // CHECK-LABEL: test_vcltq_f32
1342 // CHECK: vcgt.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1343 uint32x4_t test_vcltq_f32(float32x4_t a, float32x4_t b) {
1344   return vcltq_f32(a, b);
1345 }
1346
1347 // CHECK-LABEL: test_vcltq_u8
1348 // CHECK: vcgt.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1349 uint8x16_t test_vcltq_u8(uint8x16_t a, uint8x16_t b) {
1350   return vcltq_u8(a, b);
1351 }
1352
1353 // CHECK-LABEL: test_vcltq_u16
1354 // CHECK: vcgt.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1355 uint16x8_t test_vcltq_u16(uint16x8_t a, uint16x8_t b) {
1356   return vcltq_u16(a, b);
1357 }
1358
1359 // CHECK-LABEL: test_vcltq_u32
1360 // CHECK: vcgt.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
1361 uint32x4_t test_vcltq_u32(uint32x4_t a, uint32x4_t b) {
1362   return vcltq_u32(a, b);
1363 }
1364
1365
1366 // CHECK-LABEL: test_vclz_s8
1367 // CHECK: vclz.i8 d{{[0-9]+}}, d{{[0-9]+}}
1368 int8x8_t test_vclz_s8(int8x8_t a) {
1369   return vclz_s8(a);
1370 }
1371
1372 // CHECK-LABEL: test_vclz_s16
1373 // CHECK: vclz.i16 d{{[0-9]+}}, d{{[0-9]+}}
1374 int16x4_t test_vclz_s16(int16x4_t a) {
1375   return vclz_s16(a);
1376 }
1377
1378 // CHECK-LABEL: test_vclz_s32
1379 // CHECK: vclz.i32 d{{[0-9]+}}, d{{[0-9]+}}
1380 int32x2_t test_vclz_s32(int32x2_t a) {
1381   return vclz_s32(a);
1382 }
1383
1384 // CHECK-LABEL: test_vclz_u8
1385 // CHECK: vclz.i8 d{{[0-9]+}}, d{{[0-9]+}}
1386 uint8x8_t test_vclz_u8(uint8x8_t a) {
1387   return vclz_u8(a);
1388 }
1389
1390 // CHECK-LABEL: test_vclz_u16
1391 // CHECK: vclz.i16 d{{[0-9]+}}, d{{[0-9]+}}
1392 uint16x4_t test_vclz_u16(uint16x4_t a) {
1393   return vclz_u16(a);
1394 }
1395
1396 // CHECK-LABEL: test_vclz_u32
1397 // CHECK: vclz.i32 d{{[0-9]+}}, d{{[0-9]+}}
1398 uint32x2_t test_vclz_u32(uint32x2_t a) {
1399   return vclz_u32(a);
1400 }
1401
1402 // CHECK-LABEL: test_vclzq_s8
1403 // CHECK: vclz.i8 q{{[0-9]+}}, q{{[0-9]+}}
1404 int8x16_t test_vclzq_s8(int8x16_t a) {
1405   return vclzq_s8(a);
1406 }
1407
1408 // CHECK-LABEL: test_vclzq_s16
1409 // CHECK: vclz.i16 q{{[0-9]+}}, q{{[0-9]+}}
1410 int16x8_t test_vclzq_s16(int16x8_t a) {
1411   return vclzq_s16(a);
1412 }
1413
1414 // CHECK-LABEL: test_vclzq_s32
1415 // CHECK: vclz.i32 q{{[0-9]+}}, q{{[0-9]+}}
1416 int32x4_t test_vclzq_s32(int32x4_t a) {
1417   return vclzq_s32(a);
1418 }
1419
1420 // CHECK-LABEL: test_vclzq_u8
1421 // CHECK: vclz.i8 q{{[0-9]+}}, q{{[0-9]+}}
1422 uint8x16_t test_vclzq_u8(uint8x16_t a) {
1423   return vclzq_u8(a);
1424 }
1425
1426 // CHECK-LABEL: test_vclzq_u16
1427 // CHECK: vclz.i16 q{{[0-9]+}}, q{{[0-9]+}}
1428 uint16x8_t test_vclzq_u16(uint16x8_t a) {
1429   return vclzq_u16(a);
1430 }
1431
1432 // CHECK-LABEL: test_vclzq_u32
1433 // CHECK: vclz.i32 q{{[0-9]+}}, q{{[0-9]+}}
1434 uint32x4_t test_vclzq_u32(uint32x4_t a) {
1435   return vclzq_u32(a);
1436 }
1437
1438
1439 // CHECK-LABEL: test_vcnt_u8
1440 // CHECK: vcnt.8 d{{[0-9]+}}, d{{[0-9]+}}
1441 uint8x8_t test_vcnt_u8(uint8x8_t a) {
1442   return vcnt_u8(a);
1443 }
1444
1445 // CHECK-LABEL: test_vcnt_s8
1446 // CHECK: vcnt.8 d{{[0-9]+}}, d{{[0-9]+}}
1447 int8x8_t test_vcnt_s8(int8x8_t a) {
1448   return vcnt_s8(a);
1449 }
1450
1451 // CHECK-LABEL: test_vcnt_p8
1452 // CHECK: vcnt.8 d{{[0-9]+}}, d{{[0-9]+}}
1453 poly8x8_t test_vcnt_p8(poly8x8_t a) {
1454   return vcnt_p8(a);
1455 }
1456
1457 // CHECK-LABEL: test_vcntq_u8
1458 // CHECK: vcnt.8 q{{[0-9]+}}, q{{[0-9]+}}
1459 uint8x16_t test_vcntq_u8(uint8x16_t a) {
1460   return vcntq_u8(a);
1461 }
1462
1463 // CHECK-LABEL: test_vcntq_s8
1464 // CHECK: vcnt.8 q{{[0-9]+}}, q{{[0-9]+}}
1465 int8x16_t test_vcntq_s8(int8x16_t a) {
1466   return vcntq_s8(a);
1467 }
1468
1469 // CHECK-LABEL: test_vcntq_p8
1470 // CHECK: vcnt.8 q{{[0-9]+}}, q{{[0-9]+}}
1471 poly8x16_t test_vcntq_p8(poly8x16_t a) {
1472   return vcntq_p8(a);
1473 }
1474
1475
1476 // CHECK-LABEL: test_vcombine_s8
1477 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1478 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1479 int8x16_t test_vcombine_s8(int8x8_t a, int8x8_t b) {
1480   return vcombine_s8(a, b);
1481 }
1482
1483 // CHECK-LABEL: test_vcombine_s16
1484 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1485 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1486 int16x8_t test_vcombine_s16(int16x4_t a, int16x4_t b) {
1487   return vcombine_s16(a, b);
1488 }
1489
1490 // CHECK-LABEL: test_vcombine_s32
1491 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1492 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1493 int32x4_t test_vcombine_s32(int32x2_t a, int32x2_t b) {
1494   return vcombine_s32(a, b);
1495 }
1496
1497 // CHECK-LABEL: test_vcombine_s64
1498 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1499 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1500 int64x2_t test_vcombine_s64(int64x1_t a, int64x1_t b) {
1501   return vcombine_s64(a, b);
1502 }
1503
1504 // CHECK-LABEL: test_vcombine_f16
1505 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1506 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1507 float16x8_t test_vcombine_f16(float16x4_t a, float16x4_t b) {
1508   return vcombine_f16(a, b);
1509 }
1510
1511 // CHECK-LABEL: test_vcombine_f32
1512 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1513 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1514 float32x4_t test_vcombine_f32(float32x2_t a, float32x2_t b) {
1515   return vcombine_f32(a, b);
1516 }
1517
1518 // CHECK-LABEL: test_vcombine_u8
1519 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1520 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1521 uint8x16_t test_vcombine_u8(uint8x8_t a, uint8x8_t b) {
1522   return vcombine_u8(a, b);
1523 }
1524
1525 // CHECK-LABEL: test_vcombine_u16
1526 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1527 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1528 uint16x8_t test_vcombine_u16(uint16x4_t a, uint16x4_t b) {
1529   return vcombine_u16(a, b);
1530 }
1531
1532 // CHECK-LABEL: test_vcombine_u32
1533 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1534 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1535 uint32x4_t test_vcombine_u32(uint32x2_t a, uint32x2_t b) {
1536   return vcombine_u32(a, b);
1537 }
1538
1539 // CHECK-LABEL: test_vcombine_u64
1540 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1541 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1542 uint64x2_t test_vcombine_u64(uint64x1_t a, uint64x1_t b) {
1543   return vcombine_u64(a, b);
1544 }
1545
1546 // CHECK-LABEL: test_vcombine_p8
1547 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1548 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1549 poly8x16_t test_vcombine_p8(poly8x8_t a, poly8x8_t b) {
1550   return vcombine_p8(a, b);
1551 }
1552
1553 // CHECK-LABEL: test_vcombine_p16
1554 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1555 // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}}
1556 poly16x8_t test_vcombine_p16(poly16x4_t a, poly16x4_t b) {
1557   return vcombine_p16(a, b);
1558 }
1559
1560
1561 // CHECK-LABEL: test_vcreate_s8
1562 // CHECK: vmov [[REG:d[0-9]+]], r0, r1
1563 // CHECK: vclz.i8 d{{[0-9]+}}, [[REG]]
1564 int8x8_t test_vcreate_s8(uint64_t a) {
1565   return vclz_s8(vcreate_s8(a));
1566 }
1567
1568 // CHECK-LABEL: test_vcreate_s16
1569 // CHECK: vmov [[REG:d[0-9]+]], r0, r1
1570 // CHECK: vclz.i16 d{{[0-9]+}}, [[REG]]
1571 int16x4_t test_vcreate_s16(uint64_t a) {
1572   return vclz_s16(vcreate_s16(a));
1573 }
1574
1575 // CHECK-LABEL: test_vcreate_s32
1576 // CHECK: vmov [[REG:d[0-9]+]], r0, r1
1577 // CHECK: vclz.i32 d{{[0-9]+}}, [[REG]]
1578 int32x2_t test_vcreate_s32(uint64_t a) {
1579   return vclz_s32(vcreate_s32(a));
1580 }
1581
1582 // CHECK-LABEL: test_vcreate_f16
1583 float16x4_t test_vcreate_f16(uint64_t a) {
1584   return vcreate_f16(a);
1585 }
1586
1587 // CHECK-LABEL: test_vcreate_f32
1588 float32x2_t test_vcreate_f32(uint64_t a) {
1589   return vcreate_f32(a);
1590 }
1591
1592 // CHECK-LABEL: test_vcreate_u8
1593 // CHECK: vmov [[REG:d[0-9]+]], r0, r1
1594 // CHECK: vclz.i8 d{{[0-9]+}}, [[REG]]
1595 uint8x8_t test_vcreate_u8(uint64_t a) {
1596   return vclz_s8(vcreate_u8(a));
1597 }
1598
1599 // CHECK-LABEL: test_vcreate_u16
1600 // CHECK: vmov [[REG:d[0-9]+]], r0, r1
1601 // CHECK: vclz.i16 d{{[0-9]+}}, [[REG]]
1602 uint16x4_t test_vcreate_u16(uint64_t a) {
1603   return vclz_s16(vcreate_u16(a));
1604 }
1605
1606 // CHECK-LABEL: test_vcreate_u32
1607 // CHECK: vmov [[REG:d[0-9]+]], r0, r1
1608 // CHECK: vclz.i32 d{{[0-9]+}}, [[REG]]
1609 uint32x2_t test_vcreate_u32(uint64_t a) {
1610   return vclz_s32(vcreate_u32(a));
1611 }
1612
1613
1614 // We have two ways of lowering that.  Either with one 'vmov d, r, r' or
1615 // with two 'vmov d[],r'.  LLVM does the latter. We may want to be less
1616 // strict about the matching pattern if it starts causing problem.
1617 // CHECK-LABEL: test_vcreate_u64
1618 // CHECK: vmov.32 [[REG:d[0-9]+]][0], r0
1619 // CHECK: vmov.32 [[REG]][1], r1
1620 uint64x1_t test_vcreate_u64(uint64_t a) {
1621   uint64x1_t tmp = vcreate_u64(a);
1622   return vadd_u64(tmp, tmp);
1623
1624 }
1625
1626 // CHECK-LABEL: test_vcreate_p8
1627 // CHECK: vmov [[REG:d[0-9]+]], r0, r1
1628 // CHECK: vcnt.8 d{{[0-9]+}}, [[REG]]
1629 poly8x8_t test_vcreate_p8(uint64_t a) {
1630   return vcnt_p8(vcreate_p8(a));
1631 }
1632
1633 // CHECK-LABEL: test_vcreate_p16
1634 // CHECK: vmov [[REG:d[0-9]+]], r0, r1
1635 poly16x4_t test_vcreate_p16(uint64_t a) {
1636   poly16x4_t tmp = vcreate_p16(a);
1637   return vbsl_p16(tmp, tmp, tmp);
1638 }
1639
1640 // CHECK-LABEL: test_vcreate_s64
1641 // CHECK: vmov.32 [[REG:d[0-9]+]][0], r0
1642 // CHECK: vmov.32 [[REG]][1], r1
1643 int64x1_t test_vcreate_s64(uint64_t a) {
1644   int64x1_t tmp = vcreate_s64(a);
1645   return vadd_s64(tmp, tmp);
1646 }
1647
1648
1649 // CHECK-LABEL: test_vcvt_f16_f32
1650 // CHECK: vcvt.f16.f32 d{{[0-9]+}}, q{{[0-9]+}}
1651 float16x4_t test_vcvt_f16_f32(float32x4_t a) {
1652   return vcvt_f16_f32(a);
1653 }
1654
1655
1656 // CHECK-LABEL: test_vcvt_f32_s32
1657 // CHECK: vcvt.f32.s32 d{{[0-9]+}}, d{{[0-9]+}}
1658 float32x2_t test_vcvt_f32_s32(int32x2_t a) {
1659   return vcvt_f32_s32(a);
1660 }
1661
1662 // CHECK-LABEL: test_vcvt_f32_u32
1663 // CHECK: vcvt.f32.u32 d{{[0-9]+}}, d{{[0-9]+}}
1664 float32x2_t test_vcvt_f32_u32(uint32x2_t a) {
1665   return vcvt_f32_u32(a);
1666 }
1667
1668 // CHECK-LABEL: test_vcvtq_f32_s32
1669 // CHECK: vcvt.f32.s32 q{{[0-9]+}}, q{{[0-9]+}}
1670 float32x4_t test_vcvtq_f32_s32(int32x4_t a) {
1671   return vcvtq_f32_s32(a);
1672 }
1673
1674 // CHECK-LABEL: test_vcvtq_f32_u32
1675 // CHECK: vcvt.f32.u32 q{{[0-9]+}}, q{{[0-9]+}}
1676 float32x4_t test_vcvtq_f32_u32(uint32x4_t a) {
1677   return vcvtq_f32_u32(a);
1678 }
1679
1680
1681 // CHECK-LABEL: test_vcvt_f32_f16
1682 // CHECK: vcvt.f32.f16
1683 float32x4_t test_vcvt_f32_f16(float16x4_t a) {
1684   return vcvt_f32_f16(a);
1685 }
1686
1687
1688 // CHECK-LABEL: test_vcvt_n_f32_s32
1689 // CHECK: vcvt.f32.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
1690 float32x2_t test_vcvt_n_f32_s32(int32x2_t a) {
1691   return vcvt_n_f32_s32(a, 1);
1692 }
1693
1694 // CHECK-LABEL: test_vcvt_n_f32_u32
1695 // CHECK: vcvt.f32.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
1696 float32x2_t test_vcvt_n_f32_u32(uint32x2_t a) {
1697   return vcvt_n_f32_u32(a, 1);
1698 }
1699
1700 // CHECK-LABEL: test_vcvtq_n_f32_s32
1701 // CHECK: vcvt.f32.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
1702 float32x4_t test_vcvtq_n_f32_s32(int32x4_t a) {
1703   return vcvtq_n_f32_s32(a, 3);
1704 }
1705
1706 // CHECK-LABEL: test_vcvtq_n_f32_u32
1707 // CHECK: vcvt.f32.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
1708 float32x4_t test_vcvtq_n_f32_u32(uint32x4_t a) {
1709   return vcvtq_n_f32_u32(a, 3);
1710 }
1711
1712
1713 // CHECK-LABEL: test_vcvt_n_s32_f32
1714 // CHECK: vcvt.s32.f32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
1715 int32x2_t test_vcvt_n_s32_f32(float32x2_t a) {
1716   return vcvt_n_s32_f32(a, 1);
1717 }
1718
1719 // CHECK-LABEL: test_vcvtq_n_s32_f32
1720 // CHECK: vcvt.s32.f32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
1721 int32x4_t test_vcvtq_n_s32_f32(float32x4_t a) {
1722   return vcvtq_n_s32_f32(a, 3);
1723 }
1724
1725
1726 // CHECK-LABEL: test_vcvt_n_u32_f32
1727 // CHECK: vcvt.u32.f32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
1728 uint32x2_t test_vcvt_n_u32_f32(float32x2_t a) {
1729   return vcvt_n_u32_f32(a, 1);
1730 }
1731
1732 // CHECK-LABEL: test_vcvtq_n_u32_f32
1733 // CHECK: vcvt.u32.f32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
1734 uint32x4_t test_vcvtq_n_u32_f32(float32x4_t a) {
1735   return vcvtq_n_u32_f32(a, 3);
1736 }
1737
1738
1739 // CHECK-LABEL: test_vcvt_s32_f32
1740 // CHECK: vcvt.s32.f32 d{{[0-9]+}}, d{{[0-9]+}}
1741 int32x2_t test_vcvt_s32_f32(float32x2_t a) {
1742   return vcvt_s32_f32(a);
1743 }
1744
1745 // CHECK-LABEL: test_vcvtq_s32_f32
1746 // CHECK: vcvt.s32.f32 q{{[0-9]+}}, q{{[0-9]+}}
1747 int32x4_t test_vcvtq_s32_f32(float32x4_t a) {
1748   return vcvtq_s32_f32(a);
1749 }
1750
1751
1752 // CHECK-LABEL: test_vcvt_u32_f32
1753 // CHECK: vcvt.u32.f32 d{{[0-9]+}}, d{{[0-9]+}}
1754 uint32x2_t test_vcvt_u32_f32(float32x2_t a) {
1755   return vcvt_u32_f32(a);
1756 }
1757
1758 // CHECK-LABEL: test_vcvtq_u32_f32
1759 // CHECK: vcvt.u32.f32 q{{[0-9]+}}, q{{[0-9]+}}
1760 uint32x4_t test_vcvtq_u32_f32(float32x4_t a) {
1761   return vcvtq_u32_f32(a);
1762 }
1763
1764
1765 // CHECK-LABEL: test_vdup_lane_u8
1766 // CHECK: vdup.8 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1767 uint8x8_t test_vdup_lane_u8(uint8x8_t a) {
1768   return vdup_lane_u8(a, 7);
1769 }
1770
1771 // CHECK-LABEL: test_vdup_lane_u16
1772 // CHECK: vdup.16 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1773 uint16x4_t test_vdup_lane_u16(uint16x4_t a) {
1774   return vdup_lane_u16(a, 3);
1775 }
1776
1777 // CHECK-LABEL: test_vdup_lane_u32
1778 // CHECK: vdup.32 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1779 uint32x2_t test_vdup_lane_u32(uint32x2_t a) {
1780   return vdup_lane_u32(a, 1);
1781 }
1782
1783 // CHECK-LABEL: test_vdup_lane_s8
1784 // CHECK: vdup.8 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1785 int8x8_t test_vdup_lane_s8(int8x8_t a) {
1786   return vdup_lane_s8(a, 7);
1787 }
1788
1789 // CHECK-LABEL: test_vdup_lane_s16
1790 // CHECK: vdup.16 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1791 int16x4_t test_vdup_lane_s16(int16x4_t a) {
1792   return vdup_lane_s16(a, 3);
1793 }
1794
1795 // CHECK-LABEL: test_vdup_lane_s32
1796 // CHECK: vdup.32 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1797 int32x2_t test_vdup_lane_s32(int32x2_t a) {
1798   return vdup_lane_s32(a, 1);
1799 }
1800
1801 // CHECK-LABEL: test_vdup_lane_p8
1802 // CHECK: vdup.8 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1803 poly8x8_t test_vdup_lane_p8(poly8x8_t a) {
1804   return vdup_lane_p8(a, 7);
1805 }
1806
1807 // CHECK-LABEL: test_vdup_lane_p16
1808 // CHECK: vdup.16 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1809 poly16x4_t test_vdup_lane_p16(poly16x4_t a) {
1810   return vdup_lane_p16(a, 3);
1811 }
1812
1813 // CHECK-LABEL: test_vdup_lane_f32
1814 // CHECK: vdup.32 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1815 float32x2_t test_vdup_lane_f32(float32x2_t a) {
1816   return vdup_lane_f32(a, 1);
1817 }
1818
1819 // CHECK-LABEL: test_vdupq_lane_u8
1820 // CHECK: vdup.8 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1821 uint8x16_t test_vdupq_lane_u8(uint8x8_t a) {
1822   return vdupq_lane_u8(a, 7);
1823 }
1824
1825 // CHECK-LABEL: test_vdupq_lane_u16
1826 // CHECK: vdup.16 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1827 uint16x8_t test_vdupq_lane_u16(uint16x4_t a) {
1828   return vdupq_lane_u16(a, 3);
1829 }
1830
1831 // CHECK-LABEL: test_vdupq_lane_u32
1832 // CHECK: vdup.32 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1833 uint32x4_t test_vdupq_lane_u32(uint32x2_t a) {
1834   return vdupq_lane_u32(a, 1);
1835 }
1836
1837 // CHECK-LABEL: test_vdupq_lane_s8
1838 // CHECK: vdup.8 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1839 int8x16_t test_vdupq_lane_s8(int8x8_t a) {
1840   return vdupq_lane_s8(a, 7);
1841 }
1842
1843 // CHECK-LABEL: test_vdupq_lane_s16
1844 // CHECK: vdup.16 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1845 int16x8_t test_vdupq_lane_s16(int16x4_t a) {
1846   return vdupq_lane_s16(a, 3);
1847 }
1848
1849 // CHECK-LABEL: test_vdupq_lane_s32
1850 // CHECK: vdup.32 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1851 int32x4_t test_vdupq_lane_s32(int32x2_t a) {
1852   return vdupq_lane_s32(a, 1);
1853 }
1854
1855 // CHECK-LABEL: test_vdupq_lane_p8
1856 // CHECK: vdup.8 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1857 poly8x16_t test_vdupq_lane_p8(poly8x8_t a) {
1858   return vdupq_lane_p8(a, 7);
1859 }
1860
1861 // CHECK-LABEL: test_vdupq_lane_p16
1862 // CHECK: vdup.16 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1863 poly16x8_t test_vdupq_lane_p16(poly16x4_t a) {
1864   return vdupq_lane_p16(a, 3);
1865 }
1866
1867 // CHECK-LABEL: test_vdupq_lane_f32
1868 // CHECK: vdup.32 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
1869 float32x4_t test_vdupq_lane_f32(float32x2_t a) {
1870   return vdupq_lane_f32(a, 1);
1871 }
1872
1873 // CHECK-LABEL: test_vdup_lane_s64
1874 int64x1_t test_vdup_lane_s64(int64x1_t a) {
1875   return vdup_lane_s64(a, 0);
1876 }
1877
1878 // CHECK-LABEL: test_vdup_lane_u64
1879 uint64x1_t test_vdup_lane_u64(uint64x1_t a) {
1880   return vdup_lane_u64(a, 0);
1881 }
1882
1883 // CHECK-LABEL: test_vdupq_lane_s64
1884 // CHECK: {{vmov|vdup}}
1885 int64x2_t test_vdupq_lane_s64(int64x1_t a) {
1886   return vdupq_lane_s64(a, 0);
1887 }
1888
1889 // CHECK-LABEL: test_vdupq_lane_u64
1890 // CHECK: {{vmov|vdup}}
1891 uint64x2_t test_vdupq_lane_u64(uint64x1_t a) {
1892   return vdupq_lane_u64(a, 0);
1893 }
1894
1895
1896 // CHECK-LABEL: test_vdup_n_u8
1897 // CHECK: vmov
1898 uint8x8_t test_vdup_n_u8(uint8_t a) {
1899   return vdup_n_u8(a);
1900 }
1901
1902 // CHECK-LABEL: test_vdup_n_u16
1903 // CHECK: vmov
1904 uint16x4_t test_vdup_n_u16(uint16_t a) {
1905   return vdup_n_u16(a);
1906 }
1907
1908 // CHECK-LABEL: test_vdup_n_u32
1909 // CHECK: mov
1910 uint32x2_t test_vdup_n_u32(uint32_t a) {
1911   return vdup_n_u32(a);
1912 }
1913
1914 // CHECK-LABEL: test_vdup_n_s8
1915 // CHECK: vmov
1916 int8x8_t test_vdup_n_s8(int8_t a) {
1917   return vdup_n_s8(a);
1918 }
1919
1920 // CHECK-LABEL: test_vdup_n_s16
1921 // CHECK: vmov
1922 int16x4_t test_vdup_n_s16(int16_t a) {
1923   return vdup_n_s16(a);
1924 }
1925
1926 // CHECK-LABEL: test_vdup_n_s32
1927 // CHECK: mov
1928 int32x2_t test_vdup_n_s32(int32_t a) {
1929   return vdup_n_s32(a);
1930 }
1931
1932 // CHECK-LABEL: test_vdup_n_p8
1933 // CHECK: vmov
1934 poly8x8_t test_vdup_n_p8(poly8_t a) {
1935   return vdup_n_p8(a);
1936 }
1937
1938 // CHECK-LABEL: test_vdup_n_p16
1939 // CHECK: vmov
1940 poly16x4_t test_vdup_n_p16(poly16_t a) {
1941   return vdup_n_p16(a);
1942 }
1943
1944 // CHECK-LABEL: test_vdup_n_f16
1945 // CHECK: vld1.16 {{{d[0-9]+\[\]}}}
1946 float16x4_t test_vdup_n_f16(float16_t *a) {
1947   return vdup_n_f16(*a);
1948 }
1949
1950 // CHECK-LABEL: test_vdup_n_f32
1951 // CHECK: mov
1952 float32x2_t test_vdup_n_f32(float32_t a) {
1953   return vdup_n_f32(a);
1954 }
1955
1956 // CHECK-LABEL: test_vdupq_n_u8
1957 // CHECK: vmov
1958 uint8x16_t test_vdupq_n_u8(uint8_t a) {
1959   return vdupq_n_u8(a);
1960 }
1961
1962 // CHECK-LABEL: test_vdupq_n_u16
1963 // CHECK: vmov
1964 uint16x8_t test_vdupq_n_u16(uint16_t a) {
1965   return vdupq_n_u16(a);
1966 }
1967
1968 // CHECK-LABEL: test_vdupq_n_u32
1969 // CHECK: vmov
1970 uint32x4_t test_vdupq_n_u32(uint32_t a) {
1971   return vdupq_n_u32(a);
1972 }
1973
1974 // CHECK-LABEL: test_vdupq_n_s8
1975 // CHECK: vmov
1976 int8x16_t test_vdupq_n_s8(int8_t a) {
1977   return vdupq_n_s8(a);
1978 }
1979
1980 // CHECK-LABEL: test_vdupq_n_s16
1981 // CHECK: vmov
1982 int16x8_t test_vdupq_n_s16(int16_t a) {
1983   return vdupq_n_s16(a);
1984 }
1985
1986 // CHECK-LABEL: test_vdupq_n_s32
1987 // CHECK: vmov
1988 int32x4_t test_vdupq_n_s32(int32_t a) {
1989   return vdupq_n_s32(a);
1990 }
1991
1992 // CHECK-LABEL: test_vdupq_n_p8
1993 // CHECK: vmov
1994 poly8x16_t test_vdupq_n_p8(poly8_t a) {
1995   return vdupq_n_p8(a);
1996 }
1997
1998 // CHECK-LABEL: test_vdupq_n_p16
1999 // CHECK: vmov
2000 poly16x8_t test_vdupq_n_p16(poly16_t a) {
2001   return vdupq_n_p16(a);
2002 }
2003
2004 // CHECK-LABEL: test_vdupq_n_f16
2005 // CHECK: vld1.16 {{{d[0-9]+\[\], d[0-9]+\[\]}}}
2006 float16x8_t test_vdupq_n_f16(float16_t *a) {
2007   return vdupq_n_f16(*a);
2008 }
2009
2010 // CHECK-LABEL: test_vdupq_n_f32
2011 // CHECK: vmov
2012 float32x4_t test_vdupq_n_f32(float32_t a) {
2013   return vdupq_n_f32(a);
2014 }
2015
2016 // CHECK-LABEL: test_vdup_n_s64
2017 // CHECK: vmov
2018 int64x1_t test_vdup_n_s64(int64_t a) {
2019   int64x1_t tmp = vdup_n_s64(a);
2020   return vadd_s64(tmp, tmp);
2021 }
2022
2023 // CHECK-LABEL: test_vdup_n_u64
2024 // CHECK: vmov
2025 uint64x1_t test_vdup_n_u64(uint64_t a) {
2026   int64x1_t tmp = vdup_n_u64(a);
2027   return vadd_s64(tmp, tmp);
2028
2029 }
2030
2031 // CHECK-LABEL: test_vdupq_n_s64
2032 // CHECK: vmov
2033 int64x2_t test_vdupq_n_s64(int64_t a) {
2034   int64x2_t tmp = vdupq_n_s64(a);
2035   return vaddq_s64(tmp, tmp);
2036 }
2037
2038 // CHECK-LABEL: test_vdupq_n_u64
2039 // CHECK: vmov
2040 uint64x2_t test_vdupq_n_u64(uint64_t a) {
2041   int64x2_t tmp = vdupq_n_u64(a);
2042   return vaddq_u64(tmp, tmp);
2043 }
2044
2045
2046 // CHECK-LABEL: test_veor_s8
2047 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2048 int8x8_t test_veor_s8(int8x8_t a, int8x8_t b) {
2049   return veor_s8(a, b);
2050 }
2051
2052 // CHECK-LABEL: test_veor_s16
2053 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2054 int16x4_t test_veor_s16(int16x4_t a, int16x4_t b) {
2055   return veor_s16(a, b);
2056 }
2057
2058 // CHECK-LABEL: test_veor_s32
2059 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2060 int32x2_t test_veor_s32(int32x2_t a, int32x2_t b) {
2061   return veor_s32(a, b);
2062 }
2063
2064 // CHECK-LABEL: test_veor_s64
2065 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2066 int64x1_t test_veor_s64(int64x1_t a, int64x1_t b) {
2067   return veor_s64(a, b);
2068 }
2069
2070 // CHECK-LABEL: test_veor_u8
2071 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2072 uint8x8_t test_veor_u8(uint8x8_t a, uint8x8_t b) {
2073   return veor_u8(a, b);
2074 }
2075
2076 // CHECK-LABEL: test_veor_u16
2077 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2078 uint16x4_t test_veor_u16(uint16x4_t a, uint16x4_t b) {
2079   return veor_u16(a, b);
2080 }
2081
2082 // CHECK-LABEL: test_veor_u32
2083 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2084 uint32x2_t test_veor_u32(uint32x2_t a, uint32x2_t b) {
2085   return veor_u32(a, b);
2086 }
2087
2088 // CHECK-LABEL: test_veor_u64
2089 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2090 uint64x1_t test_veor_u64(uint64x1_t a, uint64x1_t b) {
2091   return veor_u64(a, b);
2092 }
2093
2094 // CHECK-LABEL: test_veorq_s8
2095 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2096 int8x16_t test_veorq_s8(int8x16_t a, int8x16_t b) {
2097   return veorq_s8(a, b);
2098 }
2099
2100 // CHECK-LABEL: test_veorq_s16
2101 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2102 int16x8_t test_veorq_s16(int16x8_t a, int16x8_t b) {
2103   return veorq_s16(a, b);
2104 }
2105
2106 // CHECK-LABEL: test_veorq_s32
2107 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2108 int32x4_t test_veorq_s32(int32x4_t a, int32x4_t b) {
2109   return veorq_s32(a, b);
2110 }
2111
2112 // CHECK-LABEL: test_veorq_s64
2113 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2114 int64x2_t test_veorq_s64(int64x2_t a, int64x2_t b) {
2115   return veorq_s64(a, b);
2116 }
2117
2118 // CHECK-LABEL: test_veorq_u8
2119 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2120 uint8x16_t test_veorq_u8(uint8x16_t a, uint8x16_t b) {
2121   return veorq_u8(a, b);
2122 }
2123
2124 // CHECK-LABEL: test_veorq_u16
2125 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2126 uint16x8_t test_veorq_u16(uint16x8_t a, uint16x8_t b) {
2127   return veorq_u16(a, b);
2128 }
2129
2130 // CHECK-LABEL: test_veorq_u32
2131 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2132 uint32x4_t test_veorq_u32(uint32x4_t a, uint32x4_t b) {
2133   return veorq_u32(a, b);
2134 }
2135
2136 // CHECK-LABEL: test_veorq_u64
2137 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2138 uint64x2_t test_veorq_u64(uint64x2_t a, uint64x2_t b) {
2139   return veorq_u64(a, b);
2140 }
2141
2142
2143 // CHECK-LABEL: test_vext_s8
2144 // CHECK: vext.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
2145 int8x8_t test_vext_s8(int8x8_t a, int8x8_t b) {
2146   return vext_s8(a, b, 7);
2147 }
2148
2149 // CHECK-LABEL: test_vext_u8
2150 // CHECK: vext.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
2151 uint8x8_t test_vext_u8(uint8x8_t a, uint8x8_t b) {
2152   return vext_u8(a, b, 7);
2153 }
2154
2155 // CHECK-LABEL: test_vext_p8
2156 // CHECK: vext.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
2157 poly8x8_t test_vext_p8(poly8x8_t a, poly8x8_t b) {
2158   return vext_p8(a, b, 7);
2159 }
2160
2161 // CHECK-LABEL: test_vext_s16
2162 // CHECK: vext.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
2163 int16x4_t test_vext_s16(int16x4_t a, int16x4_t b) {
2164   return vext_s16(a, b, 3);
2165 }
2166
2167 // CHECK-LABEL: test_vext_u16
2168 // CHECK: vext.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
2169 uint16x4_t test_vext_u16(uint16x4_t a, uint16x4_t b) {
2170   return vext_u16(a, b, 3);
2171 }
2172
2173 // CHECK-LABEL: test_vext_p16
2174 // CHECK: vext.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
2175 poly16x4_t test_vext_p16(poly16x4_t a, poly16x4_t b) {
2176   return vext_p16(a, b, 3);
2177 }
2178
2179 // CHECK-LABEL: test_vext_s32
2180 // CHECK: vext.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
2181 int32x2_t test_vext_s32(int32x2_t a, int32x2_t b) {
2182   return vext_s32(a, b, 1);
2183 }
2184
2185 // CHECK-LABEL: test_vext_u32
2186 // CHECK: vext.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
2187 uint32x2_t test_vext_u32(uint32x2_t a, uint32x2_t b) {
2188   return vext_u32(a, b, 1);
2189 }
2190
2191 // CHECK-LABEL: test_vext_s64
2192 int64x1_t test_vext_s64(int64x1_t a, int64x1_t b) {
2193   return vext_s64(a, b, 0);
2194 }
2195
2196 // CHECK-LABEL: test_vext_u64
2197 uint64x1_t test_vext_u64(uint64x1_t a, uint64x1_t b) {
2198   return vext_u64(a, b, 0);
2199 }
2200
2201 // CHECK-LABEL: test_vext_f32
2202 // CHECK: vext.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
2203 float32x2_t test_vext_f32(float32x2_t a, float32x2_t b) {
2204   return vext_f32(a, b, 1);
2205 }
2206
2207 // CHECK-LABEL: test_vextq_s8
2208 // CHECK: vext.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
2209 int8x16_t test_vextq_s8(int8x16_t a, int8x16_t b) {
2210   return vextq_s8(a, b, 15);
2211 }
2212
2213 // CHECK-LABEL: test_vextq_u8
2214 // CHECK: vext.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
2215 uint8x16_t test_vextq_u8(uint8x16_t a, uint8x16_t b) {
2216   return vextq_u8(a, b, 15);
2217 }
2218
2219 // CHECK-LABEL: test_vextq_p8
2220 // CHECK: vext.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
2221 poly8x16_t test_vextq_p8(poly8x16_t a, poly8x16_t b) {
2222   return vextq_p8(a, b, 15);
2223 }
2224
2225 // CHECK-LABEL: test_vextq_s16
2226 // CHECK: vext.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
2227 int16x8_t test_vextq_s16(int16x8_t a, int16x8_t b) {
2228   return vextq_s16(a, b, 7);
2229 }
2230
2231 // CHECK-LABEL: test_vextq_u16
2232 // CHECK: vext.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
2233 uint16x8_t test_vextq_u16(uint16x8_t a, uint16x8_t b) {
2234   return vextq_u16(a, b, 7);
2235 }
2236
2237 // CHECK-LABEL: test_vextq_p16
2238 // CHECK: vext.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
2239 poly16x8_t test_vextq_p16(poly16x8_t a, poly16x8_t b) {
2240   return vextq_p16(a, b, 7);
2241 }
2242
2243 // CHECK-LABEL: test_vextq_s32
2244 // CHECK: vext.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
2245 int32x4_t test_vextq_s32(int32x4_t a, int32x4_t b) {
2246   return vextq_s32(a, b, 3);
2247 }
2248
2249 // CHECK-LABEL: test_vextq_u32
2250 // CHECK: vext.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
2251 uint32x4_t test_vextq_u32(uint32x4_t a, uint32x4_t b) {
2252   return vextq_u32(a, b, 3);
2253 }
2254
2255 // CHECK-LABEL: test_vextq_s64
2256 // CHECK: {{vmov|vdup}}
2257 int64x2_t test_vextq_s64(int64x2_t a, int64x2_t b) {
2258   return vextq_s64(a, b, 1);
2259 }
2260
2261 // CHECK-LABEL: test_vextq_u64
2262 // CHECK: {{vmov|vdup}}
2263 uint64x2_t test_vextq_u64(uint64x2_t a, uint64x2_t b) {
2264   return vextq_u64(a, b, 1);
2265 }
2266
2267 // CHECK-LABEL: test_vextq_f32
2268 // CHECK: vext.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
2269 float32x4_t test_vextq_f32(float32x4_t a, float32x4_t b) {
2270   return vextq_f32(a, b, 3);
2271 }
2272
2273
2274 // CHECK-LABEL: test_vfma_f32
2275 // CHECK: vfma.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2276 float32x2_t test_vfma_f32(float32x2_t a, float32x2_t b, float32x2_t c) {
2277   return vfma_f32(a, b, c);
2278 }
2279
2280 // CHECK-LABEL: test_vfmaq_f32
2281 // CHECK: vfma.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2282 float32x4_t test_vfmaq_f32(float32x4_t a, float32x4_t b, float32x4_t c) {
2283   return vfmaq_f32(a, b, c);
2284 }
2285
2286
2287 // CHECK-LABEL: test_vget_high_s8
2288 int8x8_t test_vget_high_s8(int8x16_t a) {
2289   return vget_high_s8(a);
2290 }
2291
2292 // CHECK-LABEL: test_vget_high_s16
2293 int16x4_t test_vget_high_s16(int16x8_t a) {
2294   return vget_high_s16(a);
2295 }
2296
2297 // CHECK-LABEL: test_vget_high_s32
2298 int32x2_t test_vget_high_s32(int32x4_t a) {
2299   return vget_high_s32(a);
2300 }
2301
2302 // CHECK-LABEL: test_vget_high_s64
2303 int64x1_t test_vget_high_s64(int64x2_t a) {
2304   return vget_high_s64(a);
2305 }
2306
2307 // CHECK-LABEL: test_vget_high_f16
2308 float16x4_t test_vget_high_f16(float16x8_t a) {
2309   return vget_high_f16(a);
2310 }
2311
2312 // CHECK-LABEL: test_vget_high_f32
2313 float32x2_t test_vget_high_f32(float32x4_t a) {
2314   return vget_high_f32(a);
2315 }
2316
2317 // CHECK-LABEL: test_vget_high_u8
2318 uint8x8_t test_vget_high_u8(uint8x16_t a) {
2319   return vget_high_u8(a);
2320 }
2321
2322 // CHECK-LABEL: test_vget_high_u16
2323 uint16x4_t test_vget_high_u16(uint16x8_t a) {
2324   return vget_high_u16(a);
2325 }
2326
2327 // CHECK-LABEL: test_vget_high_u32
2328 uint32x2_t test_vget_high_u32(uint32x4_t a) {
2329   return vget_high_u32(a);
2330 }
2331
2332 // CHECK-LABEL: test_vget_high_u64
2333 uint64x1_t test_vget_high_u64(uint64x2_t a) {
2334   return vget_high_u64(a);
2335 }
2336
2337 // CHECK-LABEL: test_vget_high_p8
2338 poly8x8_t test_vget_high_p8(poly8x16_t a) {
2339   return vget_high_p8(a);
2340 }
2341
2342 // CHECK-LABEL: test_vget_high_p16
2343 poly16x4_t test_vget_high_p16(poly16x8_t a) {
2344   return vget_high_p16(a);
2345 }
2346
2347
2348 // CHECK-LABEL: test_vget_lane_u8
2349 // CHECK: vmov
2350 uint8_t test_vget_lane_u8(uint8x8_t a) {
2351   return vget_lane_u8(a, 7);
2352 }
2353
2354 // CHECK-LABEL: test_vget_lane_u16
2355 // CHECK: vmov
2356 uint16_t test_vget_lane_u16(uint16x4_t a) {
2357   return vget_lane_u16(a, 3);
2358 }
2359
2360 // CHECK-LABEL: test_vget_lane_u32
2361 // CHECK: mov
2362 uint32_t test_vget_lane_u32(uint32x2_t a) {
2363   return vget_lane_u32(a, 1);
2364 }
2365
2366 // CHECK-LABEL: test_vget_lane_s8
2367 // CHECK: vmov
2368 int8_t test_vget_lane_s8(int8x8_t a) {
2369   return vget_lane_s8(a, 7);
2370 }
2371
2372 // CHECK-LABEL: test_vget_lane_s16
2373 // CHECK: vmov
2374 int16_t test_vget_lane_s16(int16x4_t a) {
2375   return vget_lane_s16(a, 3);
2376 }
2377
2378 // CHECK-LABEL: test_vget_lane_s32
2379 // CHECK: mov
2380 int32_t test_vget_lane_s32(int32x2_t a) {
2381   return vget_lane_s32(a, 1);
2382 }
2383
2384 // CHECK-LABEL: test_vget_lane_p8
2385 // CHECK: vmov
2386 poly8_t test_vget_lane_p8(poly8x8_t a) {
2387   return vget_lane_p8(a, 7);
2388 }
2389
2390 // CHECK-LABEL: test_vget_lane_p16
2391 // CHECK: vmov
2392 poly16_t test_vget_lane_p16(poly16x4_t a) {
2393   return vget_lane_p16(a, 3);
2394 }
2395
2396 // CHECK-LABEL: test_vget_lane_f32
2397 // CHECK: vmov
2398 float32_t test_vget_lane_f32(float32x2_t a) {
2399   return vget_lane_f32(a, 1);
2400 }
2401
2402 // CHECK-LABEL: test_vgetq_lane_u8
2403 // CHECK: vmov
2404 uint8_t test_vgetq_lane_u8(uint8x16_t a) {
2405   return vgetq_lane_u8(a, 15);
2406 }
2407
2408 // CHECK-LABEL: test_vgetq_lane_u16
2409 // CHECK: vmov
2410 uint16_t test_vgetq_lane_u16(uint16x8_t a) {
2411   return vgetq_lane_u16(a, 7);
2412 }
2413
2414 // CHECK-LABEL: test_vgetq_lane_u32
2415 // CHECK: vmov
2416 uint32_t test_vgetq_lane_u32(uint32x4_t a) {
2417   return vgetq_lane_u32(a, 3);
2418 }
2419
2420 // CHECK-LABEL: test_vgetq_lane_s8
2421 // CHECK: vmov
2422 int8_t test_vgetq_lane_s8(int8x16_t a) {
2423   return vgetq_lane_s8(a, 15);
2424 }
2425
2426 // CHECK-LABEL: test_vgetq_lane_s16
2427 // CHECK: vmov
2428 int16_t test_vgetq_lane_s16(int16x8_t a) {
2429   return vgetq_lane_s16(a, 7);
2430 }
2431
2432 // CHECK-LABEL: test_vgetq_lane_s32
2433 // CHECK: vmov
2434 int32_t test_vgetq_lane_s32(int32x4_t a) {
2435   return vgetq_lane_s32(a, 3);
2436 }
2437
2438 // CHECK-LABEL: test_vgetq_lane_p8
2439 // CHECK: vmov
2440 poly8_t test_vgetq_lane_p8(poly8x16_t a) {
2441   return vgetq_lane_p8(a, 15);
2442 }
2443
2444 // CHECK-LABEL: test_vgetq_lane_p16
2445 // CHECK: vmov
2446 poly16_t test_vgetq_lane_p16(poly16x8_t a) {
2447   return vgetq_lane_p16(a, 7);
2448 }
2449
2450 // CHECK-LABEL: test_vgetq_lane_f32
2451 // CHECK: vmov
2452 float32_t test_vgetq_lane_f32(float32x4_t a) {
2453   return vgetq_lane_f32(a, 3);
2454 }
2455
2456 // CHECK-LABEL: test_vget_lane_s64
2457 // The optimizer is able to remove all moves now.
2458 int64_t test_vget_lane_s64(int64x1_t a) {
2459   return vget_lane_s64(a, 0);
2460 }
2461
2462 // CHECK-LABEL: test_vget_lane_u64
2463 // The optimizer is able to remove all moves now.
2464 uint64_t test_vget_lane_u64(uint64x1_t a) {
2465   return vget_lane_u64(a, 0);
2466 }
2467
2468 // CHECK-LABEL: test_vgetq_lane_s64
2469 // CHECK: vmov
2470 int64_t test_vgetq_lane_s64(int64x2_t a) {
2471   return vgetq_lane_s64(a, 1);
2472 }
2473
2474 // CHECK-LABEL: test_vgetq_lane_u64
2475 // CHECK: vmov
2476 uint64_t test_vgetq_lane_u64(uint64x2_t a) {
2477   return vgetq_lane_u64(a, 1);
2478 }
2479
2480
2481 // CHECK-LABEL: test_vget_low_s8
2482 int8x8_t test_vget_low_s8(int8x16_t a) {
2483   return vget_low_s8(a);
2484 }
2485
2486 // CHECK-LABEL: test_vget_low_s16
2487 int16x4_t test_vget_low_s16(int16x8_t a) {
2488   return vget_low_s16(a);
2489 }
2490
2491 // CHECK-LABEL: test_vget_low_s32
2492 int32x2_t test_vget_low_s32(int32x4_t a) {
2493   return vget_low_s32(a);
2494 }
2495
2496 // CHECK-LABEL: test_vget_low_s64
2497 int64x1_t test_vget_low_s64(int64x2_t a) {
2498   return vget_low_s64(a);
2499 }
2500
2501 // CHECK-LABEL: test_vget_low_f16
2502 float16x4_t test_vget_low_f16(float16x8_t a) {
2503   return vget_low_f16(a);
2504 }
2505
2506 // CHECK-LABEL: test_vget_low_f32
2507 float32x2_t test_vget_low_f32(float32x4_t a) {
2508   return vget_low_f32(a);
2509 }
2510
2511 // CHECK-LABEL: test_vget_low_u8
2512 uint8x8_t test_vget_low_u8(uint8x16_t a) {
2513   return vget_low_u8(a);
2514 }
2515
2516 // CHECK-LABEL: test_vget_low_u16
2517 uint16x4_t test_vget_low_u16(uint16x8_t a) {
2518   return vget_low_u16(a);
2519 }
2520
2521 // CHECK-LABEL: test_vget_low_u32
2522 uint32x2_t test_vget_low_u32(uint32x4_t a) {
2523   return vget_low_u32(a);
2524 }
2525
2526 // CHECK-LABEL: test_vget_low_u64
2527 uint64x1_t test_vget_low_u64(uint64x2_t a) {
2528   return vget_low_u64(a);
2529 }
2530
2531 // CHECK-LABEL: test_vget_low_p8
2532 poly8x8_t test_vget_low_p8(poly8x16_t a) {
2533   return vget_low_p8(a);
2534 }
2535
2536 // CHECK-LABEL: test_vget_low_p16
2537 poly16x4_t test_vget_low_p16(poly16x8_t a) {
2538   return vget_low_p16(a);
2539 }
2540
2541
2542 // CHECK-LABEL: test_vhadd_s8
2543 // CHECK: vhadd.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2544 int8x8_t test_vhadd_s8(int8x8_t a, int8x8_t b) {
2545   return vhadd_s8(a, b);
2546 }
2547
2548 // CHECK-LABEL: test_vhadd_s16
2549 // CHECK: vhadd.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2550 int16x4_t test_vhadd_s16(int16x4_t a, int16x4_t b) {
2551   return vhadd_s16(a, b);
2552 }
2553
2554 // CHECK-LABEL: test_vhadd_s32
2555 // CHECK: vhadd.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2556 int32x2_t test_vhadd_s32(int32x2_t a, int32x2_t b) {
2557   return vhadd_s32(a, b);
2558 }
2559
2560 // CHECK-LABEL: test_vhadd_u8
2561 // CHECK: vhadd.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2562 uint8x8_t test_vhadd_u8(uint8x8_t a, uint8x8_t b) {
2563   return vhadd_u8(a, b);
2564 }
2565
2566 // CHECK-LABEL: test_vhadd_u16
2567 // CHECK: vhadd.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2568 uint16x4_t test_vhadd_u16(uint16x4_t a, uint16x4_t b) {
2569   return vhadd_u16(a, b);
2570 }
2571
2572 // CHECK-LABEL: test_vhadd_u32
2573 // CHECK: vhadd.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2574 uint32x2_t test_vhadd_u32(uint32x2_t a, uint32x2_t b) {
2575   return vhadd_u32(a, b);
2576 }
2577
2578 // CHECK-LABEL: test_vhaddq_s8
2579 // CHECK: vhadd.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2580 int8x16_t test_vhaddq_s8(int8x16_t a, int8x16_t b) {
2581   return vhaddq_s8(a, b);
2582 }
2583
2584 // CHECK-LABEL: test_vhaddq_s16
2585 // CHECK: vhadd.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2586 int16x8_t test_vhaddq_s16(int16x8_t a, int16x8_t b) {
2587   return vhaddq_s16(a, b);
2588 }
2589
2590 // CHECK-LABEL: test_vhaddq_s32
2591 // CHECK: vhadd.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2592 int32x4_t test_vhaddq_s32(int32x4_t a, int32x4_t b) {
2593   return vhaddq_s32(a, b);
2594 }
2595
2596 // CHECK-LABEL: test_vhaddq_u8
2597 // CHECK: vhadd.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2598 uint8x16_t test_vhaddq_u8(uint8x16_t a, uint8x16_t b) {
2599   return vhaddq_u8(a, b);
2600 }
2601
2602 // CHECK-LABEL: test_vhaddq_u16
2603 // CHECK: vhadd.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2604 uint16x8_t test_vhaddq_u16(uint16x8_t a, uint16x8_t b) {
2605   return vhaddq_u16(a, b);
2606 }
2607
2608 // CHECK-LABEL: test_vhaddq_u32
2609 // CHECK: vhadd.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2610 uint32x4_t test_vhaddq_u32(uint32x4_t a, uint32x4_t b) {
2611   return vhaddq_u32(a, b);
2612 }
2613
2614
2615 // CHECK-LABEL: test_vhsub_s8
2616 // CHECK: vhsub.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2617 int8x8_t test_vhsub_s8(int8x8_t a, int8x8_t b) {
2618   return vhsub_s8(a, b);
2619 }
2620
2621 // CHECK-LABEL: test_vhsub_s16
2622 // CHECK: vhsub.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2623 int16x4_t test_vhsub_s16(int16x4_t a, int16x4_t b) {
2624   return vhsub_s16(a, b);
2625 }
2626
2627 // CHECK-LABEL: test_vhsub_s32
2628 // CHECK: vhsub.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2629 int32x2_t test_vhsub_s32(int32x2_t a, int32x2_t b) {
2630   return vhsub_s32(a, b);
2631 }
2632
2633 // CHECK-LABEL: test_vhsub_u8
2634 // CHECK: vhsub.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2635 uint8x8_t test_vhsub_u8(uint8x8_t a, uint8x8_t b) {
2636   return vhsub_u8(a, b);
2637 }
2638
2639 // CHECK-LABEL: test_vhsub_u16
2640 // CHECK: vhsub.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2641 uint16x4_t test_vhsub_u16(uint16x4_t a, uint16x4_t b) {
2642   return vhsub_u16(a, b);
2643 }
2644
2645 // CHECK-LABEL: test_vhsub_u32
2646 // CHECK: vhsub.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
2647 uint32x2_t test_vhsub_u32(uint32x2_t a, uint32x2_t b) {
2648   return vhsub_u32(a, b);
2649 }
2650
2651 // CHECK-LABEL: test_vhsubq_s8
2652 // CHECK: vhsub.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2653 int8x16_t test_vhsubq_s8(int8x16_t a, int8x16_t b) {
2654   return vhsubq_s8(a, b);
2655 }
2656
2657 // CHECK-LABEL: test_vhsubq_s16
2658 // CHECK: vhsub.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2659 int16x8_t test_vhsubq_s16(int16x8_t a, int16x8_t b) {
2660   return vhsubq_s16(a, b);
2661 }
2662
2663 // CHECK-LABEL: test_vhsubq_s32
2664 // CHECK: vhsub.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2665 int32x4_t test_vhsubq_s32(int32x4_t a, int32x4_t b) {
2666   return vhsubq_s32(a, b);
2667 }
2668
2669 // CHECK-LABEL: test_vhsubq_u8
2670 // CHECK: vhsub.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2671 uint8x16_t test_vhsubq_u8(uint8x16_t a, uint8x16_t b) {
2672   return vhsubq_u8(a, b);
2673 }
2674
2675 // CHECK-LABEL: test_vhsubq_u16
2676 // CHECK: vhsub.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2677 uint16x8_t test_vhsubq_u16(uint16x8_t a, uint16x8_t b) {
2678   return vhsubq_u16(a, b);
2679 }
2680
2681 // CHECK-LABEL: test_vhsubq_u32
2682 // CHECK: vhsub.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
2683 uint32x4_t test_vhsubq_u32(uint32x4_t a, uint32x4_t b) {
2684   return vhsubq_u32(a, b);
2685 }
2686
2687
2688 // CHECK-LABEL: test_vld1q_u8
2689 // CHECK: vld1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
2690 uint8x16_t test_vld1q_u8(uint8_t const * a) {
2691   return vld1q_u8(a);
2692 }
2693
2694 // CHECK-LABEL: test_vld1q_u16
2695 // CHECK: vld1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
2696 uint16x8_t test_vld1q_u16(uint16_t const * a) {
2697   return vld1q_u16(a);
2698 }
2699
2700 // CHECK-LABEL: test_vld1q_u32
2701 // CHECK: vld1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
2702 uint32x4_t test_vld1q_u32(uint32_t const * a) {
2703   return vld1q_u32(a);
2704 }
2705
2706 // CHECK-LABEL: test_vld1q_u64
2707 // CHECK: vld1.64 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}]
2708 uint64x2_t test_vld1q_u64(uint64_t const * a) {
2709   return vld1q_u64(a);
2710 }
2711
2712 // CHECK-LABEL: test_vld1q_s8
2713 // CHECK: vld1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
2714 int8x16_t test_vld1q_s8(int8_t const * a) {
2715   return vld1q_s8(a);
2716 }
2717
2718 // CHECK-LABEL: test_vld1q_s16
2719 // CHECK: vld1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
2720 int16x8_t test_vld1q_s16(int16_t const * a) {
2721   return vld1q_s16(a);
2722 }
2723
2724 // CHECK-LABEL: test_vld1q_s32
2725 // CHECK: vld1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
2726 int32x4_t test_vld1q_s32(int32_t const * a) {
2727   return vld1q_s32(a);
2728 }
2729
2730 // CHECK-LABEL: test_vld1q_s64
2731 // CHECK: vld1.64 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}]
2732 int64x2_t test_vld1q_s64(int64_t const * a) {
2733   return vld1q_s64(a);
2734 }
2735
2736 // CHECK-LABEL: test_vld1q_f16
2737 // CHECK: vld1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
2738 float16x8_t test_vld1q_f16(float16_t const * a) {
2739   return vld1q_f16(a);
2740 }
2741
2742 // CHECK-LABEL: test_vld1q_f32
2743 // CHECK: vld1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
2744 float32x4_t test_vld1q_f32(float32_t const * a) {
2745   return vld1q_f32(a);
2746 }
2747
2748 // CHECK-LABEL: test_vld1q_p8
2749 // CHECK: vld1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
2750 poly8x16_t test_vld1q_p8(poly8_t const * a) {
2751   return vld1q_p8(a);
2752 }
2753
2754 // CHECK-LABEL: test_vld1q_p16
2755 // CHECK: vld1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
2756 poly16x8_t test_vld1q_p16(poly16_t const * a) {
2757   return vld1q_p16(a);
2758 }
2759
2760 // CHECK-LABEL: test_vld1_u8
2761 // CHECK: vld1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}]
2762 uint8x8_t test_vld1_u8(uint8_t const * a) {
2763   return vld1_u8(a);
2764 }
2765
2766 // CHECK-LABEL: test_vld1_u16
2767 // CHECK: vld1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}]
2768 uint16x4_t test_vld1_u16(uint16_t const * a) {
2769   return vld1_u16(a);
2770 }
2771
2772 // CHECK-LABEL: test_vld1_u32
2773 // CHECK: vld1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}]
2774 uint32x2_t test_vld1_u32(uint32_t const * a) {
2775   return vld1_u32(a);
2776 }
2777
2778 // CHECK-LABEL: test_vld1_u64
2779 // CHECK: vld1.64 {d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}]
2780 uint64x1_t test_vld1_u64(uint64_t const * a) {
2781   return vld1_u64(a);
2782 }
2783
2784 // CHECK-LABEL: test_vld1_s8
2785 // CHECK: vld1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}]
2786 int8x8_t test_vld1_s8(int8_t const * a) {
2787   return vld1_s8(a);
2788 }
2789
2790 // CHECK-LABEL: test_vld1_s16
2791 // CHECK: vld1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}]
2792 int16x4_t test_vld1_s16(int16_t const * a) {
2793   return vld1_s16(a);
2794 }
2795
2796 // CHECK-LABEL: test_vld1_s32
2797 // CHECK: vld1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}]
2798 int32x2_t test_vld1_s32(int32_t const * a) {
2799   return vld1_s32(a);
2800 }
2801
2802 // CHECK-LABEL: test_vld1_s64
2803 // CHECK: vld1.64 {d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}]
2804 int64x1_t test_vld1_s64(int64_t const * a) {
2805   return vld1_s64(a);
2806 }
2807
2808 // CHECK-LABEL: test_vld1_f16
2809 // CHECK: vld1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}]
2810 float16x4_t test_vld1_f16(float16_t const * a) {
2811   return vld1_f16(a);
2812 }
2813
2814 // CHECK-LABEL: test_vld1_f32
2815 // CHECK: vld1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}]
2816 float32x2_t test_vld1_f32(float32_t const * a) {
2817   return vld1_f32(a);
2818 }
2819
2820 // CHECK-LABEL: test_vld1_p8
2821 // CHECK: vld1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}]
2822 poly8x8_t test_vld1_p8(poly8_t const * a) {
2823   return vld1_p8(a);
2824 }
2825
2826 // CHECK-LABEL: test_vld1_p16
2827 // CHECK: vld1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}]
2828 poly16x4_t test_vld1_p16(poly16_t const * a) {
2829   return vld1_p16(a);
2830 }
2831
2832
2833 // CHECK-LABEL: test_vld1q_dup_u8
2834 // CHECK: vld1.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
2835 uint8x16_t test_vld1q_dup_u8(uint8_t const * a) {
2836   return vld1q_dup_u8(a);
2837 }
2838
2839 // CHECK-LABEL: test_vld1q_dup_u16
2840 // CHECK: vld1.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:16]
2841 uint16x8_t test_vld1q_dup_u16(uint16_t const * a) {
2842   return vld1q_dup_u16(a);
2843 }
2844
2845 // CHECK-LABEL: test_vld1q_dup_u32
2846 // CHECK: vld1.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:32]
2847 uint32x4_t test_vld1q_dup_u32(uint32_t const * a) {
2848   return vld1q_dup_u32(a);
2849 }
2850
2851 // CHECK-LABEL: test_vld1q_dup_u64
2852 // CHECK: {{ldr|vldr|vmov}}
2853 uint64x2_t test_vld1q_dup_u64(uint64_t const * a) {
2854   return vld1q_dup_u64(a);
2855 }
2856
2857 // CHECK-LABEL: test_vld1q_dup_s8
2858 // CHECK: vld1.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
2859 int8x16_t test_vld1q_dup_s8(int8_t const * a) {
2860   return vld1q_dup_s8(a);
2861 }
2862
2863 // CHECK-LABEL: test_vld1q_dup_s16
2864 // CHECK: vld1.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:16]
2865 int16x8_t test_vld1q_dup_s16(int16_t const * a) {
2866   return vld1q_dup_s16(a);
2867 }
2868
2869 // CHECK-LABEL: test_vld1q_dup_s32
2870 // CHECK: vld1.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:32]
2871 int32x4_t test_vld1q_dup_s32(int32_t const * a) {
2872   return vld1q_dup_s32(a);
2873 }
2874
2875 // CHECK-LABEL: test_vld1q_dup_s64
2876 // CHECK: {{ldr|vldr|vmov}}
2877 int64x2_t test_vld1q_dup_s64(int64_t const * a) {
2878   return vld1q_dup_s64(a);
2879 }
2880
2881 // CHECK-LABEL: test_vld1q_dup_f16
2882 // CHECK: vld1.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:16]
2883 float16x8_t test_vld1q_dup_f16(float16_t const * a) {
2884   return vld1q_dup_f16(a);
2885 }
2886
2887 // CHECK-LABEL: test_vld1q_dup_f32
2888 // CHECK: vld1.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:32]
2889 float32x4_t test_vld1q_dup_f32(float32_t const * a) {
2890   return vld1q_dup_f32(a);
2891 }
2892
2893 // CHECK-LABEL: test_vld1q_dup_p8
2894 // CHECK: vld1.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
2895 poly8x16_t test_vld1q_dup_p8(poly8_t const * a) {
2896   return vld1q_dup_p8(a);
2897 }
2898
2899 // CHECK-LABEL: test_vld1q_dup_p16
2900 // CHECK: vld1.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:16]
2901 poly16x8_t test_vld1q_dup_p16(poly16_t const * a) {
2902   return vld1q_dup_p16(a);
2903 }
2904
2905 // CHECK-LABEL: test_vld1_dup_u8
2906 // CHECK: vld1.8 {d{{[0-9]+}}[]}, [r{{[0-9]+}}]
2907 uint8x8_t test_vld1_dup_u8(uint8_t const * a) {
2908   return vld1_dup_u8(a);
2909 }
2910
2911 // CHECK-LABEL: test_vld1_dup_u16
2912 // CHECK: vld1.16 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:16]
2913 uint16x4_t test_vld1_dup_u16(uint16_t const * a) {
2914   return vld1_dup_u16(a);
2915 }
2916
2917 // CHECK-LABEL: test_vld1_dup_u32
2918 // CHECK: vld1.32 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:32]
2919 uint32x2_t test_vld1_dup_u32(uint32_t const * a) {
2920   return vld1_dup_u32(a);
2921 }
2922
2923 // CHECK-LABEL: test_vld1_dup_u64
2924 // CHECK: {{ldr|vldr|vmov}}
2925 uint64x1_t test_vld1_dup_u64(uint64_t const * a) {
2926   return vld1_dup_u64(a);
2927 }
2928
2929 // CHECK-LABEL: test_vld1_dup_s8
2930 // CHECK: vld1.8 {d{{[0-9]+}}[]}, [r{{[0-9]+}}]
2931 int8x8_t test_vld1_dup_s8(int8_t const * a) {
2932   return vld1_dup_s8(a);
2933 }
2934
2935 // CHECK-LABEL: test_vld1_dup_s16
2936 // CHECK: vld1.16 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:16]
2937 int16x4_t test_vld1_dup_s16(int16_t const * a) {
2938   return vld1_dup_s16(a);
2939 }
2940
2941 // CHECK-LABEL: test_vld1_dup_s32
2942 // CHECK: vld1.32 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:32]
2943 int32x2_t test_vld1_dup_s32(int32_t const * a) {
2944   return vld1_dup_s32(a);
2945 }
2946
2947 // CHECK-LABEL: test_vld1_dup_s64
2948 // CHECK: {{ldr|vldr|vmov}}
2949 int64x1_t test_vld1_dup_s64(int64_t const * a) {
2950   return vld1_dup_s64(a);
2951 }
2952
2953 // CHECK-LABEL: test_vld1_dup_f16
2954 // CHECK: vld1.16 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:16]
2955 float16x4_t test_vld1_dup_f16(float16_t const * a) {
2956   return vld1_dup_f16(a);
2957 }
2958
2959 // CHECK-LABEL: test_vld1_dup_f32
2960 // CHECK: vld1.32 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:32]
2961 float32x2_t test_vld1_dup_f32(float32_t const * a) {
2962   return vld1_dup_f32(a);
2963 }
2964
2965 // CHECK-LABEL: test_vld1_dup_p8
2966 // CHECK: vld1.8 {d{{[0-9]+}}[]}, [r{{[0-9]+}}]
2967 poly8x8_t test_vld1_dup_p8(poly8_t const * a) {
2968   return vld1_dup_p8(a);
2969 }
2970
2971 // CHECK-LABEL: test_vld1_dup_p16
2972 // CHECK: vld1.16 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:16]
2973 poly16x4_t test_vld1_dup_p16(poly16_t const * a) {
2974   return vld1_dup_p16(a);
2975 }
2976
2977
2978 // CHECK-LABEL: test_vld1q_lane_u8
2979 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
2980 uint8x16_t test_vld1q_lane_u8(uint8_t const * a, uint8x16_t b) {
2981   return vld1q_lane_u8(a, b, 15);
2982 }
2983
2984 // CHECK-LABEL: test_vld1q_lane_u16
2985 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16]
2986 uint16x8_t test_vld1q_lane_u16(uint16_t const * a, uint16x8_t b) {
2987   return vld1q_lane_u16(a, b, 7);
2988 }
2989
2990 // CHECK-LABEL: test_vld1q_lane_u32
2991 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32]
2992 uint32x4_t test_vld1q_lane_u32(uint32_t const * a, uint32x4_t b) {
2993   return vld1q_lane_u32(a, b, 3);
2994 }
2995
2996 // CHECK-LABEL: test_vld1q_lane_u64
2997 // CHECK: {{ldr|vldr|vmov}}
2998 uint64x2_t test_vld1q_lane_u64(uint64_t const * a, uint64x2_t b) {
2999   return vld1q_lane_u64(a, b, 1);
3000 }
3001
3002 // CHECK-LABEL: test_vld1q_lane_s8
3003 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3004 int8x16_t test_vld1q_lane_s8(int8_t const * a, int8x16_t b) {
3005   return vld1q_lane_s8(a, b, 15);
3006 }
3007
3008 // CHECK-LABEL: test_vld1q_lane_s16
3009 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16]
3010 int16x8_t test_vld1q_lane_s16(int16_t const * a, int16x8_t b) {
3011   return vld1q_lane_s16(a, b, 7);
3012 }
3013
3014 // CHECK-LABEL: test_vld1q_lane_s32
3015 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32]
3016 int32x4_t test_vld1q_lane_s32(int32_t const * a, int32x4_t b) {
3017   return vld1q_lane_s32(a, b, 3);
3018 }
3019
3020 // CHECK-LABEL: test_vld1q_lane_s64
3021 // CHECK: {{ldr|vldr|vmov}}
3022 int64x2_t test_vld1q_lane_s64(int64_t const * a, int64x2_t b) {
3023   return vld1q_lane_s64(a, b, 1);
3024 }
3025
3026 // CHECK-LABEL: test_vld1q_lane_f16
3027 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16]
3028 float16x8_t test_vld1q_lane_f16(float16_t const * a, float16x8_t b) {
3029   return vld1q_lane_f16(a, b, 7);
3030 }
3031
3032 // CHECK-LABEL: test_vld1q_lane_f32
3033 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32]
3034 float32x4_t test_vld1q_lane_f32(float32_t const * a, float32x4_t b) {
3035   return vld1q_lane_f32(a, b, 3);
3036 }
3037
3038 // CHECK-LABEL: test_vld1q_lane_p8
3039 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3040 poly8x16_t test_vld1q_lane_p8(poly8_t const * a, poly8x16_t b) {
3041   return vld1q_lane_p8(a, b, 15);
3042 }
3043
3044 // CHECK-LABEL: test_vld1q_lane_p16
3045 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16]
3046 poly16x8_t test_vld1q_lane_p16(poly16_t const * a, poly16x8_t b) {
3047   return vld1q_lane_p16(a, b, 7);
3048 }
3049
3050 // CHECK-LABEL: test_vld1_lane_u8
3051 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3052 uint8x8_t test_vld1_lane_u8(uint8_t const * a, uint8x8_t b) {
3053   return vld1_lane_u8(a, b, 7);
3054 }
3055
3056 // CHECK-LABEL: test_vld1_lane_u16
3057 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16]
3058 uint16x4_t test_vld1_lane_u16(uint16_t const * a, uint16x4_t b) {
3059   return vld1_lane_u16(a, b, 3);
3060 }
3061
3062 // CHECK-LABEL: test_vld1_lane_u32
3063 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32]
3064 uint32x2_t test_vld1_lane_u32(uint32_t const * a, uint32x2_t b) {
3065   return vld1_lane_u32(a, b, 1);
3066 }
3067
3068 // CHECK-LABEL: test_vld1_lane_u64
3069 // CHECK: {{ldr|vldr|vmov}}
3070 uint64x1_t test_vld1_lane_u64(uint64_t const * a, uint64x1_t b) {
3071   return vld1_lane_u64(a, b, 0);
3072 }
3073
3074 // CHECK-LABEL: test_vld1_lane_s8
3075 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3076 int8x8_t test_vld1_lane_s8(int8_t const * a, int8x8_t b) {
3077   return vld1_lane_s8(a, b, 7);
3078 }
3079
3080 // CHECK-LABEL: test_vld1_lane_s16
3081 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16]
3082 int16x4_t test_vld1_lane_s16(int16_t const * a, int16x4_t b) {
3083   return vld1_lane_s16(a, b, 3);
3084 }
3085
3086 // CHECK-LABEL: test_vld1_lane_s32
3087 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32]
3088 int32x2_t test_vld1_lane_s32(int32_t const * a, int32x2_t b) {
3089   return vld1_lane_s32(a, b, 1);
3090 }
3091
3092 // CHECK-LABEL: test_vld1_lane_s64
3093 // CHECK: {{ldr|vldr|vmov}}
3094 int64x1_t test_vld1_lane_s64(int64_t const * a, int64x1_t b) {
3095   return vld1_lane_s64(a, b, 0);
3096 }
3097
3098 // CHECK-LABEL: test_vld1_lane_f16
3099 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16]
3100 float16x4_t test_vld1_lane_f16(float16_t const * a, float16x4_t b) {
3101   return vld1_lane_f16(a, b, 3);
3102 }
3103
3104 // CHECK-LABEL: test_vld1_lane_f32
3105 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32]
3106 float32x2_t test_vld1_lane_f32(float32_t const * a, float32x2_t b) {
3107   return vld1_lane_f32(a, b, 1);
3108 }
3109
3110 // CHECK-LABEL: test_vld1_lane_p8
3111 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3112 poly8x8_t test_vld1_lane_p8(poly8_t const * a, poly8x8_t b) {
3113   return vld1_lane_p8(a, b, 7);
3114 }
3115
3116 // CHECK-LABEL: test_vld1_lane_p16
3117 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16]
3118 poly16x4_t test_vld1_lane_p16(poly16_t const * a, poly16x4_t b) {
3119   return vld1_lane_p16(a, b, 3);
3120 }
3121
3122
3123 // CHECK-LABEL: test_vld2q_u8
3124 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3125 uint8x16x2_t test_vld2q_u8(uint8_t const * a) {
3126   return vld2q_u8(a);
3127 }
3128
3129 // CHECK-LABEL: test_vld2q_u16
3130 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3131 uint16x8x2_t test_vld2q_u16(uint16_t const * a) {
3132   return vld2q_u16(a);
3133 }
3134
3135 // CHECK-LABEL: test_vld2q_u32
3136 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3137 uint32x4x2_t test_vld2q_u32(uint32_t const * a) {
3138   return vld2q_u32(a);
3139 }
3140
3141 // CHECK-LABEL: test_vld2q_s8
3142 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3143 int8x16x2_t test_vld2q_s8(int8_t const * a) {
3144   return vld2q_s8(a);
3145 }
3146
3147 // CHECK-LABEL: test_vld2q_s16
3148 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3149 int16x8x2_t test_vld2q_s16(int16_t const * a) {
3150   return vld2q_s16(a);
3151 }
3152
3153 // CHECK-LABEL: test_vld2q_s32
3154 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3155 int32x4x2_t test_vld2q_s32(int32_t const * a) {
3156   return vld2q_s32(a);
3157 }
3158
3159 // CHECK-LABEL: test_vld2q_f16
3160 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3161 float16x8x2_t test_vld2q_f16(float16_t const * a) {
3162   return vld2q_f16(a);
3163 }
3164
3165 // CHECK-LABEL: test_vld2q_f32
3166 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3167 float32x4x2_t test_vld2q_f32(float32_t const * a) {
3168   return vld2q_f32(a);
3169 }
3170
3171 // CHECK-LABEL: test_vld2q_p8
3172 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3173 poly8x16x2_t test_vld2q_p8(poly8_t const * a) {
3174   return vld2q_p8(a);
3175 }
3176
3177 // CHECK-LABEL: test_vld2q_p16
3178 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3179 poly16x8x2_t test_vld2q_p16(poly16_t const * a) {
3180   return vld2q_p16(a);
3181 }
3182
3183 // CHECK-LABEL: test_vld2_u8
3184 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3185 uint8x8x2_t test_vld2_u8(uint8_t const * a) {
3186   return vld2_u8(a);
3187 }
3188
3189 // CHECK-LABEL: test_vld2_u16
3190 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3191 uint16x4x2_t test_vld2_u16(uint16_t const * a) {
3192   return vld2_u16(a);
3193 }
3194
3195 // CHECK-LABEL: test_vld2_u32
3196 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3197 uint32x2x2_t test_vld2_u32(uint32_t const * a) {
3198   return vld2_u32(a);
3199 }
3200
3201 // CHECK-LABEL: test_vld2_u64
3202 // CHECK: vld1.64
3203 uint64x1x2_t test_vld2_u64(uint64_t const * a) {
3204   return vld2_u64(a);
3205 }
3206
3207 // CHECK-LABEL: test_vld2_s8
3208 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3209 int8x8x2_t test_vld2_s8(int8_t const * a) {
3210   return vld2_s8(a);
3211 }
3212
3213 // CHECK-LABEL: test_vld2_s16
3214 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3215 int16x4x2_t test_vld2_s16(int16_t const * a) {
3216   return vld2_s16(a);
3217 }
3218
3219 // CHECK-LABEL: test_vld2_s32
3220 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3221 int32x2x2_t test_vld2_s32(int32_t const * a) {
3222   return vld2_s32(a);
3223 }
3224
3225 // CHECK-LABEL: test_vld2_s64
3226 // CHECK: vld1.64
3227 int64x1x2_t test_vld2_s64(int64_t const * a) {
3228   return vld2_s64(a);
3229 }
3230
3231 // CHECK-LABEL: test_vld2_f16
3232 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3233 float16x4x2_t test_vld2_f16(float16_t const * a) {
3234   return vld2_f16(a);
3235 }
3236
3237 // CHECK-LABEL: test_vld2_f32
3238 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3239 float32x2x2_t test_vld2_f32(float32_t const * a) {
3240   return vld2_f32(a);
3241 }
3242
3243 // CHECK-LABEL: test_vld2_p8
3244 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3245 poly8x8x2_t test_vld2_p8(poly8_t const * a) {
3246   return vld2_p8(a);
3247 }
3248
3249 // CHECK-LABEL: test_vld2_p16
3250 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3251 poly16x4x2_t test_vld2_p16(poly16_t const * a) {
3252   return vld2_p16(a);
3253 }
3254
3255
3256 // CHECK-LABEL: test_vld2_dup_u8
3257 // CHECK: vld2.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3258 uint8x8x2_t test_vld2_dup_u8(uint8_t const * a) {
3259   return vld2_dup_u8(a);
3260 }
3261
3262 // CHECK-LABEL: test_vld2_dup_u16
3263 // CHECK: vld2.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3264 uint16x4x2_t test_vld2_dup_u16(uint16_t const * a) {
3265   return vld2_dup_u16(a);
3266 }
3267
3268 // CHECK-LABEL: test_vld2_dup_u32
3269 // CHECK: vld2.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3270 uint32x2x2_t test_vld2_dup_u32(uint32_t const * a) {
3271   return vld2_dup_u32(a);
3272 }
3273
3274 // CHECK-LABEL: test_vld2_dup_u64
3275 // CHECK: vld1.64
3276 uint64x1x2_t test_vld2_dup_u64(uint64_t const * a) {
3277   return vld2_dup_u64(a);
3278 }
3279
3280 // CHECK-LABEL: test_vld2_dup_s8
3281 // CHECK: vld2.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3282 int8x8x2_t test_vld2_dup_s8(int8_t const * a) {
3283   return vld2_dup_s8(a);
3284 }
3285
3286 // CHECK-LABEL: test_vld2_dup_s16
3287 // CHECK: vld2.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3288 int16x4x2_t test_vld2_dup_s16(int16_t const * a) {
3289   return vld2_dup_s16(a);
3290 }
3291
3292 // CHECK-LABEL: test_vld2_dup_s32
3293 // CHECK: vld2.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3294 int32x2x2_t test_vld2_dup_s32(int32_t const * a) {
3295   return vld2_dup_s32(a);
3296 }
3297
3298 // CHECK-LABEL: test_vld2_dup_s64
3299 // CHECK: vld1.64
3300 int64x1x2_t test_vld2_dup_s64(int64_t const * a) {
3301   return vld2_dup_s64(a);
3302 }
3303
3304 // CHECK-LABEL: test_vld2_dup_f16
3305 // CHECK: vld2.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3306 float16x4x2_t test_vld2_dup_f16(float16_t const * a) {
3307   return vld2_dup_f16(a);
3308 }
3309
3310 // CHECK-LABEL: test_vld2_dup_f32
3311 // CHECK: vld2.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3312 float32x2x2_t test_vld2_dup_f32(float32_t const * a) {
3313   return vld2_dup_f32(a);
3314 }
3315
3316 // CHECK-LABEL: test_vld2_dup_p8
3317 // CHECK: vld2.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3318 poly8x8x2_t test_vld2_dup_p8(poly8_t const * a) {
3319   return vld2_dup_p8(a);
3320 }
3321
3322 // CHECK-LABEL: test_vld2_dup_p16
3323 // CHECK: vld2.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3324 poly16x4x2_t test_vld2_dup_p16(poly16_t const * a) {
3325   return vld2_dup_p16(a);
3326 }
3327
3328
3329 // CHECK-LABEL: test_vld2q_lane_u16
3330 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3331 uint16x8x2_t test_vld2q_lane_u16(uint16_t const * a, uint16x8x2_t b) {
3332   return vld2q_lane_u16(a, b, 7);
3333 }
3334
3335 // CHECK-LABEL: test_vld2q_lane_u32
3336 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3337 uint32x4x2_t test_vld2q_lane_u32(uint32_t const * a, uint32x4x2_t b) {
3338   return vld2q_lane_u32(a, b, 3);
3339 }
3340
3341 // CHECK-LABEL: test_vld2q_lane_s16
3342 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3343 int16x8x2_t test_vld2q_lane_s16(int16_t const * a, int16x8x2_t b) {
3344   return vld2q_lane_s16(a, b, 7);
3345 }
3346
3347 // CHECK-LABEL: test_vld2q_lane_s32
3348 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3349 int32x4x2_t test_vld2q_lane_s32(int32_t const * a, int32x4x2_t b) {
3350   return vld2q_lane_s32(a, b, 3);
3351 }
3352
3353 // CHECK-LABEL: test_vld2q_lane_f16
3354 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3355 float16x8x2_t test_vld2q_lane_f16(float16_t const * a, float16x8x2_t b) {
3356   return vld2q_lane_f16(a, b, 7);
3357 }
3358
3359 // CHECK-LABEL: test_vld2q_lane_f32
3360 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3361 float32x4x2_t test_vld2q_lane_f32(float32_t const * a, float32x4x2_t b) {
3362   return vld2q_lane_f32(a, b, 3);
3363 }
3364
3365 // CHECK-LABEL: test_vld2q_lane_p16
3366 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3367 poly16x8x2_t test_vld2q_lane_p16(poly16_t const * a, poly16x8x2_t b) {
3368   return vld2q_lane_p16(a, b, 7);
3369 }
3370
3371 // CHECK-LABEL: test_vld2_lane_u8
3372 // CHECK: vld2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3373 uint8x8x2_t test_vld2_lane_u8(uint8_t const * a, uint8x8x2_t b) {
3374   return vld2_lane_u8(a, b, 7);
3375 }
3376
3377 // CHECK-LABEL: test_vld2_lane_u16
3378 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3379 uint16x4x2_t test_vld2_lane_u16(uint16_t const * a, uint16x4x2_t b) {
3380   return vld2_lane_u16(a, b, 3);
3381 }
3382
3383 // CHECK-LABEL: test_vld2_lane_u32
3384 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3385 uint32x2x2_t test_vld2_lane_u32(uint32_t const * a, uint32x2x2_t b) {
3386   return vld2_lane_u32(a, b, 1);
3387 }
3388
3389 // CHECK-LABEL: test_vld2_lane_s8
3390 // CHECK: vld2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3391 int8x8x2_t test_vld2_lane_s8(int8_t const * a, int8x8x2_t b) {
3392   return vld2_lane_s8(a, b, 7);
3393 }
3394
3395 // CHECK-LABEL: test_vld2_lane_s16
3396 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3397 int16x4x2_t test_vld2_lane_s16(int16_t const * a, int16x4x2_t b) {
3398   return vld2_lane_s16(a, b, 3);
3399 }
3400
3401 // CHECK-LABEL: test_vld2_lane_s32
3402 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3403 int32x2x2_t test_vld2_lane_s32(int32_t const * a, int32x2x2_t b) {
3404   return vld2_lane_s32(a, b, 1);
3405 }
3406
3407 // CHECK-LABEL: test_vld2_lane_f16
3408 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3409 float16x4x2_t test_vld2_lane_f16(float16_t const * a, float16x4x2_t b) {
3410   return vld2_lane_f16(a, b, 3);
3411 }
3412
3413 // CHECK-LABEL: test_vld2_lane_f32
3414 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3415 float32x2x2_t test_vld2_lane_f32(float32_t const * a, float32x2x2_t b) {
3416   return vld2_lane_f32(a, b, 1);
3417 }
3418
3419 // CHECK-LABEL: test_vld2_lane_p8
3420 // CHECK: vld2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3421 poly8x8x2_t test_vld2_lane_p8(poly8_t const * a, poly8x8x2_t b) {
3422   return vld2_lane_p8(a, b, 7);
3423 }
3424
3425 // CHECK-LABEL: test_vld2_lane_p16
3426 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3427 poly16x4x2_t test_vld2_lane_p16(poly16_t const * a, poly16x4x2_t b) {
3428   return vld2_lane_p16(a, b, 3);
3429 }
3430
3431
3432 // CHECK-LABEL: test_vld3q_u8
3433 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3434 uint8x16x3_t test_vld3q_u8(uint8_t const * a) {
3435   return vld3q_u8(a);
3436 }
3437
3438 // CHECK-LABEL: test_vld3q_u16
3439 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3440 uint16x8x3_t test_vld3q_u16(uint16_t const * a) {
3441   return vld3q_u16(a);
3442 }
3443
3444 // CHECK-LABEL: test_vld3q_u32
3445 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3446 uint32x4x3_t test_vld3q_u32(uint32_t const * a) {
3447   return vld3q_u32(a);
3448 }
3449
3450 // CHECK-LABEL: test_vld3q_s8
3451 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3452 int8x16x3_t test_vld3q_s8(int8_t const * a) {
3453   return vld3q_s8(a);
3454 }
3455
3456 // CHECK-LABEL: test_vld3q_s16
3457 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3458 int16x8x3_t test_vld3q_s16(int16_t const * a) {
3459   return vld3q_s16(a);
3460 }
3461
3462 // CHECK-LABEL: test_vld3q_s32
3463 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3464 int32x4x3_t test_vld3q_s32(int32_t const * a) {
3465   return vld3q_s32(a);
3466 }
3467
3468 // CHECK-LABEL: test_vld3q_f16
3469 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3470 float16x8x3_t test_vld3q_f16(float16_t const * a) {
3471   return vld3q_f16(a);
3472 }
3473
3474 // CHECK-LABEL: test_vld3q_f32
3475 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3476 float32x4x3_t test_vld3q_f32(float32_t const * a) {
3477   return vld3q_f32(a);
3478 }
3479
3480 // CHECK-LABEL: test_vld3q_p8
3481 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3482 poly8x16x3_t test_vld3q_p8(poly8_t const * a) {
3483   return vld3q_p8(a);
3484 }
3485
3486 // CHECK-LABEL: test_vld3q_p16
3487 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3488 poly16x8x3_t test_vld3q_p16(poly16_t const * a) {
3489   return vld3q_p16(a);
3490 }
3491
3492 // CHECK-LABEL: test_vld3_u8
3493 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3494 uint8x8x3_t test_vld3_u8(uint8_t const * a) {
3495   return vld3_u8(a);
3496 }
3497
3498 // CHECK-LABEL: test_vld3_u16
3499 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3500 uint16x4x3_t test_vld3_u16(uint16_t const * a) {
3501   return vld3_u16(a);
3502 }
3503
3504 // CHECK-LABEL: test_vld3_u32
3505 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3506 uint32x2x3_t test_vld3_u32(uint32_t const * a) {
3507   return vld3_u32(a);
3508 }
3509
3510 // CHECK-LABEL: test_vld3_u64
3511 // CHECK: vld1.64
3512 uint64x1x3_t test_vld3_u64(uint64_t const * a) {
3513   return vld3_u64(a);
3514 }
3515
3516 // CHECK-LABEL: test_vld3_s8
3517 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3518 int8x8x3_t test_vld3_s8(int8_t const * a) {
3519   return vld3_s8(a);
3520 }
3521
3522 // CHECK-LABEL: test_vld3_s16
3523 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3524 int16x4x3_t test_vld3_s16(int16_t const * a) {
3525   return vld3_s16(a);
3526 }
3527
3528 // CHECK-LABEL: test_vld3_s32
3529 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3530 int32x2x3_t test_vld3_s32(int32_t const * a) {
3531   return vld3_s32(a);
3532 }
3533
3534 // CHECK-LABEL: test_vld3_s64
3535 // CHECK: vld1.64
3536 int64x1x3_t test_vld3_s64(int64_t const * a) {
3537   return vld3_s64(a);
3538 }
3539
3540 // CHECK-LABEL: test_vld3_f16
3541 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3542 float16x4x3_t test_vld3_f16(float16_t const * a) {
3543   return vld3_f16(a);
3544 }
3545
3546 // CHECK-LABEL: test_vld3_f32
3547 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3548 float32x2x3_t test_vld3_f32(float32_t const * a) {
3549   return vld3_f32(a);
3550 }
3551
3552 // CHECK-LABEL: test_vld3_p8
3553 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3554 poly8x8x3_t test_vld3_p8(poly8_t const * a) {
3555   return vld3_p8(a);
3556 }
3557
3558 // CHECK-LABEL: test_vld3_p16
3559 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3560 poly16x4x3_t test_vld3_p16(poly16_t const * a) {
3561   return vld3_p16(a);
3562 }
3563
3564
3565 // CHECK-LABEL: test_vld3_dup_u8
3566 // CHECK: vld3.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3567 uint8x8x3_t test_vld3_dup_u8(uint8_t const * a) {
3568   return vld3_dup_u8(a);
3569 }
3570
3571 // CHECK-LABEL: test_vld3_dup_u16
3572 // CHECK: vld3.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3573 uint16x4x3_t test_vld3_dup_u16(uint16_t const * a) {
3574   return vld3_dup_u16(a);
3575 }
3576
3577 // CHECK-LABEL: test_vld3_dup_u32
3578 // CHECK: vld3.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3579 uint32x2x3_t test_vld3_dup_u32(uint32_t const * a) {
3580   return vld3_dup_u32(a);
3581 }
3582
3583 // CHECK-LABEL: test_vld3_dup_u64
3584 // CHECK: vld1.64
3585 uint64x1x3_t test_vld3_dup_u64(uint64_t const * a) {
3586   return vld3_dup_u64(a);
3587 }
3588
3589 // CHECK-LABEL: test_vld3_dup_s8
3590 // CHECK: vld3.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3591 int8x8x3_t test_vld3_dup_s8(int8_t const * a) {
3592   return vld3_dup_s8(a);
3593 }
3594
3595 // CHECK-LABEL: test_vld3_dup_s16
3596 // CHECK: vld3.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3597 int16x4x3_t test_vld3_dup_s16(int16_t const * a) {
3598   return vld3_dup_s16(a);
3599 }
3600
3601 // CHECK-LABEL: test_vld3_dup_s32
3602 // CHECK: vld3.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3603 int32x2x3_t test_vld3_dup_s32(int32_t const * a) {
3604   return vld3_dup_s32(a);
3605 }
3606
3607 // CHECK-LABEL: test_vld3_dup_s64
3608 // CHECK: vld1.64
3609 int64x1x3_t test_vld3_dup_s64(int64_t const * a) {
3610   return vld3_dup_s64(a);
3611 }
3612
3613 // CHECK-LABEL: test_vld3_dup_f16
3614 // CHECK: vld3.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3615 float16x4x3_t test_vld3_dup_f16(float16_t const * a) {
3616   return vld3_dup_f16(a);
3617 }
3618
3619 // CHECK-LABEL: test_vld3_dup_f32
3620 // CHECK: vld3.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3621 float32x2x3_t test_vld3_dup_f32(float32_t const * a) {
3622   return vld3_dup_f32(a);
3623 }
3624
3625 // CHECK-LABEL: test_vld3_dup_p8
3626 // CHECK: vld3.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3627 poly8x8x3_t test_vld3_dup_p8(poly8_t const * a) {
3628   return vld3_dup_p8(a);
3629 }
3630
3631 // CHECK-LABEL: test_vld3_dup_p16
3632 // CHECK: vld3.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3633 poly16x4x3_t test_vld3_dup_p16(poly16_t const * a) {
3634   return vld3_dup_p16(a);
3635 }
3636
3637
3638 // CHECK-LABEL: test_vld3q_lane_u16
3639 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
3640 uint16x8x3_t test_vld3q_lane_u16(uint16_t const * a, uint16x8x3_t b) {
3641   return vld3q_lane_u16(a, b, 7);
3642 }
3643
3644 // CHECK-LABEL: test_vld3q_lane_u32
3645 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
3646 uint32x4x3_t test_vld3q_lane_u32(uint32_t const * a, uint32x4x3_t b) {
3647   return vld3q_lane_u32(a, b, 3);
3648 }
3649
3650 // CHECK-LABEL: test_vld3q_lane_s16
3651 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
3652 int16x8x3_t test_vld3q_lane_s16(int16_t const * a, int16x8x3_t b) {
3653   return vld3q_lane_s16(a, b, 7);
3654 }
3655
3656 // CHECK-LABEL: test_vld3q_lane_s32
3657 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
3658 int32x4x3_t test_vld3q_lane_s32(int32_t const * a, int32x4x3_t b) {
3659   return vld3q_lane_s32(a, b, 3);
3660 }
3661
3662 // CHECK-LABEL: test_vld3q_lane_f16
3663 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
3664 float16x8x3_t test_vld3q_lane_f16(float16_t const * a, float16x8x3_t b) {
3665   return vld3q_lane_f16(a, b, 7);
3666 }
3667
3668 // CHECK-LABEL: test_vld3q_lane_f32
3669 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
3670 float32x4x3_t test_vld3q_lane_f32(float32_t const * a, float32x4x3_t b) {
3671   return vld3q_lane_f32(a, b, 3);
3672 }
3673
3674 // CHECK-LABEL: test_vld3q_lane_p16
3675 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
3676 poly16x8x3_t test_vld3q_lane_p16(poly16_t const * a, poly16x8x3_t b) {
3677   return vld3q_lane_p16(a, b, 7);
3678 }
3679
3680 // CHECK-LABEL: test_vld3_lane_u8
3681 // CHECK: vld3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3682 uint8x8x3_t test_vld3_lane_u8(uint8_t const * a, uint8x8x3_t b) {
3683   return vld3_lane_u8(a, b, 7);
3684 }
3685
3686 // CHECK-LABEL: test_vld3_lane_u16
3687 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3688 uint16x4x3_t test_vld3_lane_u16(uint16_t const * a, uint16x4x3_t b) {
3689   return vld3_lane_u16(a, b, 3);
3690 }
3691
3692 // CHECK-LABEL: test_vld3_lane_u32
3693 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3694 uint32x2x3_t test_vld3_lane_u32(uint32_t const * a, uint32x2x3_t b) {
3695   return vld3_lane_u32(a, b, 1);
3696 }
3697
3698 // CHECK-LABEL: test_vld3_lane_s8
3699 // CHECK: vld3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3700 int8x8x3_t test_vld3_lane_s8(int8_t const * a, int8x8x3_t b) {
3701   return vld3_lane_s8(a, b, 7);
3702 }
3703
3704 // CHECK-LABEL: test_vld3_lane_s16
3705 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3706 int16x4x3_t test_vld3_lane_s16(int16_t const * a, int16x4x3_t b) {
3707   return vld3_lane_s16(a, b, 3);
3708 }
3709
3710 // CHECK-LABEL: test_vld3_lane_s32
3711 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3712 int32x2x3_t test_vld3_lane_s32(int32_t const * a, int32x2x3_t b) {
3713   return vld3_lane_s32(a, b, 1);
3714 }
3715
3716 // CHECK-LABEL: test_vld3_lane_f16
3717 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3718 float16x4x3_t test_vld3_lane_f16(float16_t const * a, float16x4x3_t b) {
3719   return vld3_lane_f16(a, b, 3);
3720 }
3721
3722 // CHECK-LABEL: test_vld3_lane_f32
3723 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3724 float32x2x3_t test_vld3_lane_f32(float32_t const * a, float32x2x3_t b) {
3725   return vld3_lane_f32(a, b, 1);
3726 }
3727
3728 // CHECK-LABEL: test_vld3_lane_p8
3729 // CHECK: vld3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3730 poly8x8x3_t test_vld3_lane_p8(poly8_t const * a, poly8x8x3_t b) {
3731   return vld3_lane_p8(a, b, 7);
3732 }
3733
3734 // CHECK-LABEL: test_vld3_lane_p16
3735 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3736 poly16x4x3_t test_vld3_lane_p16(poly16_t const * a, poly16x4x3_t b) {
3737   return vld3_lane_p16(a, b, 3);
3738 }
3739
3740
3741 // CHECK-LABEL: test_vld4q_u8
3742 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3743 uint8x16x4_t test_vld4q_u8(uint8_t const * a) {
3744   return vld4q_u8(a);
3745 }
3746
3747 // CHECK-LABEL: test_vld4q_u16
3748 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3749 uint16x8x4_t test_vld4q_u16(uint16_t const * a) {
3750   return vld4q_u16(a);
3751 }
3752
3753 // CHECK-LABEL: test_vld4q_u32
3754 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3755 uint32x4x4_t test_vld4q_u32(uint32_t const * a) {
3756   return vld4q_u32(a);
3757 }
3758
3759 // CHECK-LABEL: test_vld4q_s8
3760 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3761 int8x16x4_t test_vld4q_s8(int8_t const * a) {
3762   return vld4q_s8(a);
3763 }
3764
3765 // CHECK-LABEL: test_vld4q_s16
3766 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3767 int16x8x4_t test_vld4q_s16(int16_t const * a) {
3768   return vld4q_s16(a);
3769 }
3770
3771 // CHECK-LABEL: test_vld4q_s32
3772 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3773 int32x4x4_t test_vld4q_s32(int32_t const * a) {
3774   return vld4q_s32(a);
3775 }
3776
3777 // CHECK-LABEL: test_vld4q_f16
3778 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3779 float16x8x4_t test_vld4q_f16(float16_t const * a) {
3780   return vld4q_f16(a);
3781 }
3782
3783 // CHECK-LABEL: test_vld4q_f32
3784 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3785 float32x4x4_t test_vld4q_f32(float32_t const * a) {
3786   return vld4q_f32(a);
3787 }
3788
3789 // CHECK-LABEL: test_vld4q_p8
3790 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3791 poly8x16x4_t test_vld4q_p8(poly8_t const * a) {
3792   return vld4q_p8(a);
3793 }
3794
3795 // CHECK-LABEL: test_vld4q_p16
3796 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
3797 poly16x8x4_t test_vld4q_p16(poly16_t const * a) {
3798   return vld4q_p16(a);
3799 }
3800
3801 // CHECK-LABEL: test_vld4_u8
3802 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3803 uint8x8x4_t test_vld4_u8(uint8_t const * a) {
3804   return vld4_u8(a);
3805 }
3806
3807 // CHECK-LABEL: test_vld4_u16
3808 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3809 uint16x4x4_t test_vld4_u16(uint16_t const * a) {
3810   return vld4_u16(a);
3811 }
3812
3813 // CHECK-LABEL: test_vld4_u32
3814 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3815 uint32x2x4_t test_vld4_u32(uint32_t const * a) {
3816   return vld4_u32(a);
3817 }
3818
3819 // CHECK-LABEL: test_vld4_u64
3820 // CHECK: vld1.64
3821 uint64x1x4_t test_vld4_u64(uint64_t const * a) {
3822   return vld4_u64(a);
3823 }
3824
3825 // CHECK-LABEL: test_vld4_s8
3826 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3827 int8x8x4_t test_vld4_s8(int8_t const * a) {
3828   return vld4_s8(a);
3829 }
3830
3831 // CHECK-LABEL: test_vld4_s16
3832 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3833 int16x4x4_t test_vld4_s16(int16_t const * a) {
3834   return vld4_s16(a);
3835 }
3836
3837 // CHECK-LABEL: test_vld4_s32
3838 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3839 int32x2x4_t test_vld4_s32(int32_t const * a) {
3840   return vld4_s32(a);
3841 }
3842
3843 // CHECK-LABEL: test_vld4_s64
3844 // CHECK: vld1.64
3845 int64x1x4_t test_vld4_s64(int64_t const * a) {
3846   return vld4_s64(a);
3847 }
3848
3849 // CHECK-LABEL: test_vld4_f16
3850 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3851 float16x4x4_t test_vld4_f16(float16_t const * a) {
3852   return vld4_f16(a);
3853 }
3854
3855 // CHECK-LABEL: test_vld4_f32
3856 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3857 float32x2x4_t test_vld4_f32(float32_t const * a) {
3858   return vld4_f32(a);
3859 }
3860
3861 // CHECK-LABEL: test_vld4_p8
3862 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3863 poly8x8x4_t test_vld4_p8(poly8_t const * a) {
3864   return vld4_p8(a);
3865 }
3866
3867 // CHECK-LABEL: test_vld4_p16
3868 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
3869 poly16x4x4_t test_vld4_p16(poly16_t const * a) {
3870   return vld4_p16(a);
3871 }
3872
3873
3874 // CHECK-LABEL: test_vld4_dup_u8
3875 // CHECK: vld4.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3876 uint8x8x4_t test_vld4_dup_u8(uint8_t const * a) {
3877   return vld4_dup_u8(a);
3878 }
3879
3880 // CHECK-LABEL: test_vld4_dup_u16
3881 // CHECK: vld4.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3882 uint16x4x4_t test_vld4_dup_u16(uint16_t const * a) {
3883   return vld4_dup_u16(a);
3884 }
3885
3886 // CHECK-LABEL: test_vld4_dup_u32
3887 // CHECK: vld4.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3888 uint32x2x4_t test_vld4_dup_u32(uint32_t const * a) {
3889   return vld4_dup_u32(a);
3890 }
3891
3892 // CHECK-LABEL: test_vld4_dup_u64
3893 // CHECK: vld1.64
3894 uint64x1x4_t test_vld4_dup_u64(uint64_t const * a) {
3895   return vld4_dup_u64(a);
3896 }
3897
3898 // CHECK-LABEL: test_vld4_dup_s8
3899 // CHECK: vld4.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3900 int8x8x4_t test_vld4_dup_s8(int8_t const * a) {
3901   return vld4_dup_s8(a);
3902 }
3903
3904 // CHECK-LABEL: test_vld4_dup_s16
3905 // CHECK: vld4.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3906 int16x4x4_t test_vld4_dup_s16(int16_t const * a) {
3907   return vld4_dup_s16(a);
3908 }
3909
3910 // CHECK-LABEL: test_vld4_dup_s32
3911 // CHECK: vld4.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3912 int32x2x4_t test_vld4_dup_s32(int32_t const * a) {
3913   return vld4_dup_s32(a);
3914 }
3915
3916 // CHECK-LABEL: test_vld4_dup_s64
3917 // CHECK: vld1.64
3918 int64x1x4_t test_vld4_dup_s64(int64_t const * a) {
3919   return vld4_dup_s64(a);
3920 }
3921
3922 // CHECK-LABEL: test_vld4_dup_f16
3923 // CHECK: vld4.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3924 float16x4x4_t test_vld4_dup_f16(float16_t const * a) {
3925   return vld4_dup_f16(a);
3926 }
3927
3928 // CHECK-LABEL: test_vld4_dup_f32
3929 // CHECK: vld4.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3930 float32x2x4_t test_vld4_dup_f32(float32_t const * a) {
3931   return vld4_dup_f32(a);
3932 }
3933
3934 // CHECK-LABEL: test_vld4_dup_p8
3935 // CHECK: vld4.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3936 poly8x8x4_t test_vld4_dup_p8(poly8_t const * a) {
3937   return vld4_dup_p8(a);
3938 }
3939
3940 // CHECK-LABEL: test_vld4_dup_p16
3941 // CHECK: vld4.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}]
3942 poly16x4x4_t test_vld4_dup_p16(poly16_t const * a) {
3943   return vld4_dup_p16(a);
3944 }
3945
3946
3947 // CHECK-LABEL: test_vld4q_lane_u16
3948 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
3949 uint16x8x4_t test_vld4q_lane_u16(uint16_t const * a, uint16x8x4_t b) {
3950   return vld4q_lane_u16(a, b, 7);
3951 }
3952
3953 // CHECK-LABEL: test_vld4q_lane_u32
3954 // CHECK: vld4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
3955 uint32x4x4_t test_vld4q_lane_u32(uint32_t const * a, uint32x4x4_t b) {
3956   return vld4q_lane_u32(a, b, 3);
3957 }
3958
3959 // CHECK-LABEL: test_vld4q_lane_s16
3960 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
3961 int16x8x4_t test_vld4q_lane_s16(int16_t const * a, int16x8x4_t b) {
3962   return vld4q_lane_s16(a, b, 7);
3963 }
3964
3965 // CHECK-LABEL: test_vld4q_lane_s32
3966 // CHECK: vld4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
3967 int32x4x4_t test_vld4q_lane_s32(int32_t const * a, int32x4x4_t b) {
3968   return vld4q_lane_s32(a, b, 3);
3969 }
3970
3971 // CHECK-LABEL: test_vld4q_lane_f16
3972 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
3973 float16x8x4_t test_vld4q_lane_f16(float16_t const * a, float16x8x4_t b) {
3974   return vld4q_lane_f16(a, b, 7);
3975 }
3976
3977 // CHECK-LABEL: test_vld4q_lane_f32
3978 // CHECK: vld4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
3979 float32x4x4_t test_vld4q_lane_f32(float32_t const * a, float32x4x4_t b) {
3980   return vld4q_lane_f32(a, b, 3);
3981 }
3982
3983 // CHECK-LABEL: test_vld4q_lane_p16
3984 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
3985 poly16x8x4_t test_vld4q_lane_p16(poly16_t const * a, poly16x8x4_t b) {
3986   return vld4q_lane_p16(a, b, 7);
3987 }
3988
3989 // CHECK-LABEL: test_vld4_lane_u8
3990 // CHECK: vld4.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3991 uint8x8x4_t test_vld4_lane_u8(uint8_t const * a, uint8x8x4_t b) {
3992   return vld4_lane_u8(a, b, 7);
3993 }
3994
3995 // CHECK-LABEL: test_vld4_lane_u16
3996 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
3997 uint16x4x4_t test_vld4_lane_u16(uint16_t const * a, uint16x4x4_t b) {
3998   return vld4_lane_u16(a, b, 3);
3999 }
4000
4001 // CHECK-LABEL: test_vld4_lane_u32
4002 // CHECK: vld4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
4003 uint32x2x4_t test_vld4_lane_u32(uint32_t const * a, uint32x2x4_t b) {
4004   return vld4_lane_u32(a, b, 1);
4005 }
4006
4007 // CHECK-LABEL: test_vld4_lane_s8
4008 // CHECK: vld4.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
4009 int8x8x4_t test_vld4_lane_s8(int8_t const * a, int8x8x4_t b) {
4010   return vld4_lane_s8(a, b, 7);
4011 }
4012
4013 // CHECK-LABEL: test_vld4_lane_s16
4014 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
4015 int16x4x4_t test_vld4_lane_s16(int16_t const * a, int16x4x4_t b) {
4016   return vld4_lane_s16(a, b, 3);
4017 }
4018
4019 // CHECK-LABEL: test_vld4_lane_s32
4020 // CHECK: vld4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
4021 int32x2x4_t test_vld4_lane_s32(int32_t const * a, int32x2x4_t b) {
4022   return vld4_lane_s32(a, b, 1);
4023 }
4024
4025 // CHECK-LABEL: test_vld4_lane_f16
4026 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
4027 float16x4x4_t test_vld4_lane_f16(float16_t const * a, float16x4x4_t b) {
4028   return vld4_lane_f16(a, b, 3);
4029 }
4030
4031 // CHECK-LABEL: test_vld4_lane_f32
4032 // CHECK: vld4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
4033 float32x2x4_t test_vld4_lane_f32(float32_t const * a, float32x2x4_t b) {
4034   return vld4_lane_f32(a, b, 1);
4035 }
4036
4037 // CHECK-LABEL: test_vld4_lane_p8
4038 // CHECK: vld4.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
4039 poly8x8x4_t test_vld4_lane_p8(poly8_t const * a, poly8x8x4_t b) {
4040   return vld4_lane_p8(a, b, 7);
4041 }
4042
4043 // CHECK-LABEL: test_vld4_lane_p16
4044 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
4045 poly16x4x4_t test_vld4_lane_p16(poly16_t const * a, poly16x4x4_t b) {
4046   return vld4_lane_p16(a, b, 3);
4047 }
4048
4049
4050 // CHECK-LABEL: test_vmax_s8
4051 // CHECK: vmax.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4052 int8x8_t test_vmax_s8(int8x8_t a, int8x8_t b) {
4053   return vmax_s8(a, b);
4054 }
4055
4056 // CHECK-LABEL: test_vmax_s16
4057 // CHECK: vmax.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4058 int16x4_t test_vmax_s16(int16x4_t a, int16x4_t b) {
4059   return vmax_s16(a, b);
4060 }
4061
4062 // CHECK-LABEL: test_vmax_s32
4063 // CHECK: vmax.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4064 int32x2_t test_vmax_s32(int32x2_t a, int32x2_t b) {
4065   return vmax_s32(a, b);
4066 }
4067
4068 // CHECK-LABEL: test_vmax_u8
4069 // CHECK: vmax.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4070 uint8x8_t test_vmax_u8(uint8x8_t a, uint8x8_t b) {
4071   return vmax_u8(a, b);
4072 }
4073
4074 // CHECK-LABEL: test_vmax_u16
4075 // CHECK: vmax.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4076 uint16x4_t test_vmax_u16(uint16x4_t a, uint16x4_t b) {
4077   return vmax_u16(a, b);
4078 }
4079
4080 // CHECK-LABEL: test_vmax_u32
4081 // CHECK: vmax.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4082 uint32x2_t test_vmax_u32(uint32x2_t a, uint32x2_t b) {
4083   return vmax_u32(a, b);
4084 }
4085
4086 // CHECK-LABEL: test_vmax_f32
4087 // CHECK: vmax.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4088 float32x2_t test_vmax_f32(float32x2_t a, float32x2_t b) {
4089   return vmax_f32(a, b);
4090 }
4091
4092 // CHECK-LABEL: test_vmaxq_s8
4093 // CHECK: vmax.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4094 int8x16_t test_vmaxq_s8(int8x16_t a, int8x16_t b) {
4095   return vmaxq_s8(a, b);
4096 }
4097
4098 // CHECK-LABEL: test_vmaxq_s16
4099 // CHECK: vmax.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4100 int16x8_t test_vmaxq_s16(int16x8_t a, int16x8_t b) {
4101   return vmaxq_s16(a, b);
4102 }
4103
4104 // CHECK-LABEL: test_vmaxq_s32
4105 // CHECK: vmax.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4106 int32x4_t test_vmaxq_s32(int32x4_t a, int32x4_t b) {
4107   return vmaxq_s32(a, b);
4108 }
4109
4110 // CHECK-LABEL: test_vmaxq_u8
4111 // CHECK: vmax.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4112 uint8x16_t test_vmaxq_u8(uint8x16_t a, uint8x16_t b) {
4113   return vmaxq_u8(a, b);
4114 }
4115
4116 // CHECK-LABEL: test_vmaxq_u16
4117 // CHECK: vmax.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4118 uint16x8_t test_vmaxq_u16(uint16x8_t a, uint16x8_t b) {
4119   return vmaxq_u16(a, b);
4120 }
4121
4122 // CHECK-LABEL: test_vmaxq_u32
4123 // CHECK: vmax.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4124 uint32x4_t test_vmaxq_u32(uint32x4_t a, uint32x4_t b) {
4125   return vmaxq_u32(a, b);
4126 }
4127
4128 // CHECK-LABEL: test_vmaxq_f32
4129 // CHECK: vmax.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4130 float32x4_t test_vmaxq_f32(float32x4_t a, float32x4_t b) {
4131   return vmaxq_f32(a, b);
4132 }
4133
4134
4135 // CHECK-LABEL: test_vmin_s8
4136 // CHECK: vmin.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4137 int8x8_t test_vmin_s8(int8x8_t a, int8x8_t b) {
4138   return vmin_s8(a, b);
4139 }
4140
4141 // CHECK-LABEL: test_vmin_s16
4142 // CHECK: vmin.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4143 int16x4_t test_vmin_s16(int16x4_t a, int16x4_t b) {
4144   return vmin_s16(a, b);
4145 }
4146
4147 // CHECK-LABEL: test_vmin_s32
4148 // CHECK: vmin.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4149 int32x2_t test_vmin_s32(int32x2_t a, int32x2_t b) {
4150   return vmin_s32(a, b);
4151 }
4152
4153 // CHECK-LABEL: test_vmin_u8
4154 // CHECK: vmin.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4155 uint8x8_t test_vmin_u8(uint8x8_t a, uint8x8_t b) {
4156   return vmin_u8(a, b);
4157 }
4158
4159 // CHECK-LABEL: test_vmin_u16
4160 // CHECK: vmin.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4161 uint16x4_t test_vmin_u16(uint16x4_t a, uint16x4_t b) {
4162   return vmin_u16(a, b);
4163 }
4164
4165 // CHECK-LABEL: test_vmin_u32
4166 // CHECK: vmin.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4167 uint32x2_t test_vmin_u32(uint32x2_t a, uint32x2_t b) {
4168   return vmin_u32(a, b);
4169 }
4170
4171 // CHECK-LABEL: test_vmin_f32
4172 // CHECK: vmin.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4173 float32x2_t test_vmin_f32(float32x2_t a, float32x2_t b) {
4174   return vmin_f32(a, b);
4175 }
4176
4177 // CHECK-LABEL: test_vminq_s8
4178 // CHECK: vmin.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4179 int8x16_t test_vminq_s8(int8x16_t a, int8x16_t b) {
4180   return vminq_s8(a, b);
4181 }
4182
4183 // CHECK-LABEL: test_vminq_s16
4184 // CHECK: vmin.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4185 int16x8_t test_vminq_s16(int16x8_t a, int16x8_t b) {
4186   return vminq_s16(a, b);
4187 }
4188
4189 // CHECK-LABEL: test_vminq_s32
4190 // CHECK: vmin.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4191 int32x4_t test_vminq_s32(int32x4_t a, int32x4_t b) {
4192   return vminq_s32(a, b);
4193 }
4194
4195 // CHECK-LABEL: test_vminq_u8
4196 // CHECK: vmin.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4197 uint8x16_t test_vminq_u8(uint8x16_t a, uint8x16_t b) {
4198   return vminq_u8(a, b);
4199 }
4200
4201 // CHECK-LABEL: test_vminq_u16
4202 // CHECK: vmin.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4203 uint16x8_t test_vminq_u16(uint16x8_t a, uint16x8_t b) {
4204   return vminq_u16(a, b);
4205 }
4206
4207 // CHECK-LABEL: test_vminq_u32
4208 // CHECK: vmin.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4209 uint32x4_t test_vminq_u32(uint32x4_t a, uint32x4_t b) {
4210   return vminq_u32(a, b);
4211 }
4212
4213 // CHECK-LABEL: test_vminq_f32
4214 // CHECK: vmin.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4215 float32x4_t test_vminq_f32(float32x4_t a, float32x4_t b) {
4216   return vminq_f32(a, b);
4217 }
4218
4219
4220 // CHECK-LABEL: test_vmla_s8
4221 // CHECK: vmla.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4222 int8x8_t test_vmla_s8(int8x8_t a, int8x8_t b, int8x8_t c) {
4223   return vmla_s8(a, b, c);
4224 }
4225
4226 // CHECK-LABEL: test_vmla_s16
4227 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4228 int16x4_t test_vmla_s16(int16x4_t a, int16x4_t b, int16x4_t c) {
4229   return vmla_s16(a, b, c);
4230 }
4231
4232 // CHECK-LABEL: test_vmla_s32
4233 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4234 int32x2_t test_vmla_s32(int32x2_t a, int32x2_t b, int32x2_t c) {
4235   return vmla_s32(a, b, c);
4236 }
4237
4238 // CHECK-LABEL: test_vmla_f32
4239 // CHECK-SWIFT: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4240 // CHECK-SWIFT: vadd.f32
4241 // CHECK-A57: vmla.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4242 float32x2_t test_vmla_f32(float32x2_t a, float32x2_t b, float32x2_t c) {
4243   return vmla_f32(a, b, c);
4244 }
4245
4246 // CHECK-LABEL: test_vmla_u8
4247 // CHECK: vmla.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4248 uint8x8_t test_vmla_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) {
4249   return vmla_u8(a, b, c);
4250 }
4251
4252 // CHECK-LABEL: test_vmla_u16
4253 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4254 uint16x4_t test_vmla_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) {
4255   return vmla_u16(a, b, c);
4256 }
4257
4258 // CHECK-LABEL: test_vmla_u32
4259 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4260 uint32x2_t test_vmla_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) {
4261   return vmla_u32(a, b, c);
4262 }
4263
4264 // CHECK-LABEL: test_vmlaq_s8
4265 // CHECK: vmla.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4266 int8x16_t test_vmlaq_s8(int8x16_t a, int8x16_t b, int8x16_t c) {
4267   return vmlaq_s8(a, b, c);
4268 }
4269
4270 // CHECK-LABEL: test_vmlaq_s16
4271 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4272 int16x8_t test_vmlaq_s16(int16x8_t a, int16x8_t b, int16x8_t c) {
4273   return vmlaq_s16(a, b, c);
4274 }
4275
4276 // CHECK-LABEL: test_vmlaq_s32
4277 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4278 int32x4_t test_vmlaq_s32(int32x4_t a, int32x4_t b, int32x4_t c) {
4279   return vmlaq_s32(a, b, c);
4280 }
4281
4282 // CHECK-LABEL: test_vmlaq_f32
4283 // CHECK-SWIFT: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4284 // CHECK-SWIFT: vadd.f32
4285 // CHECK-A57: vmla.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4286 float32x4_t test_vmlaq_f32(float32x4_t a, float32x4_t b, float32x4_t c) {
4287   return vmlaq_f32(a, b, c);
4288 }
4289
4290 // CHECK-LABEL: test_vmlaq_u8
4291 // CHECK: vmla.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4292 uint8x16_t test_vmlaq_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) {
4293   return vmlaq_u8(a, b, c);
4294 }
4295
4296 // CHECK-LABEL: test_vmlaq_u16
4297 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4298 uint16x8_t test_vmlaq_u16(uint16x8_t a, uint16x8_t b, uint16x8_t c) {
4299   return vmlaq_u16(a, b, c);
4300 }
4301
4302 // CHECK-LABEL: test_vmlaq_u32
4303 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4304 uint32x4_t test_vmlaq_u32(uint32x4_t a, uint32x4_t b, uint32x4_t c) {
4305   return vmlaq_u32(a, b, c);
4306 }
4307
4308
4309 // CHECK-LABEL: test_vmlal_s8
4310 // CHECK: vmlal.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4311 int16x8_t test_vmlal_s8(int16x8_t a, int8x8_t b, int8x8_t c) {
4312   return vmlal_s8(a, b, c);
4313 }
4314
4315 // CHECK-LABEL: test_vmlal_s16
4316 // CHECK: vmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4317 int32x4_t test_vmlal_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
4318   return vmlal_s16(a, b, c);
4319 }
4320
4321 // CHECK-LABEL: test_vmlal_s32
4322 // CHECK: vmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4323 int64x2_t test_vmlal_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
4324   return vmlal_s32(a, b, c);
4325 }
4326
4327 // CHECK-LABEL: test_vmlal_u8
4328 // CHECK: vmlal.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4329 uint16x8_t test_vmlal_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) {
4330   return vmlal_u8(a, b, c);
4331 }
4332
4333 // CHECK-LABEL: test_vmlal_u16
4334 // CHECK: vmlal.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4335 uint32x4_t test_vmlal_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) {
4336   return vmlal_u16(a, b, c);
4337 }
4338
4339 // CHECK-LABEL: test_vmlal_u32
4340 // CHECK: vmlal.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4341 uint64x2_t test_vmlal_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) {
4342   return vmlal_u32(a, b, c);
4343 }
4344
4345
4346 // CHECK-LABEL: test_vmlal_lane_s16
4347 // CHECK: vmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4348 int32x4_t test_vmlal_lane_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
4349   return vmlal_lane_s16(a, b, c, 3);
4350 }
4351
4352 // CHECK-LABEL: test_vmlal_lane_s32
4353 // CHECK: vmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4354 int64x2_t test_vmlal_lane_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
4355   return vmlal_lane_s32(a, b, c, 1);
4356 }
4357
4358 // CHECK-LABEL: test_vmlal_lane_u16
4359 // CHECK: vmlal.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4360 uint32x4_t test_vmlal_lane_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) {
4361   return vmlal_lane_u16(a, b, c, 3);
4362 }
4363
4364 // CHECK-LABEL: test_vmlal_lane_u32
4365 // CHECK: vmlal.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4366 uint64x2_t test_vmlal_lane_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) {
4367   return vmlal_lane_u32(a, b, c, 1);
4368 }
4369
4370
4371 // CHECK-LABEL: test_vmlal_n_s16
4372 // CHECK: vmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4373 int32x4_t test_vmlal_n_s16(int32x4_t a, int16x4_t b, int16_t c) {
4374   return vmlal_n_s16(a, b, c);
4375 }
4376
4377 // CHECK-LABEL: test_vmlal_n_s32
4378 // CHECK: vmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4379 int64x2_t test_vmlal_n_s32(int64x2_t a, int32x2_t b, int32_t c) {
4380   return vmlal_n_s32(a, b, c);
4381 }
4382
4383 // CHECK-LABEL: test_vmlal_n_u16
4384 // CHECK: vmlal.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4385 uint32x4_t test_vmlal_n_u16(uint32x4_t a, uint16x4_t b, uint16_t c) {
4386   return vmlal_n_u16(a, b, c);
4387 }
4388
4389 // CHECK-LABEL: test_vmlal_n_u32
4390 // CHECK: vmlal.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4391 uint64x2_t test_vmlal_n_u32(uint64x2_t a, uint32x2_t b, uint32_t c) {
4392   return vmlal_n_u32(a, b, c);
4393 }
4394
4395
4396 // CHECK-LABEL: test_vmla_lane_s16
4397 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4398 int16x4_t test_vmla_lane_s16(int16x4_t a, int16x4_t b, int16x4_t c) {
4399   return vmla_lane_s16(a, b, c, 3);
4400 }
4401
4402 // CHECK-LABEL: test_vmla_lane_s32
4403 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4404 int32x2_t test_vmla_lane_s32(int32x2_t a, int32x2_t b, int32x2_t c) {
4405   return vmla_lane_s32(a, b, c, 1);
4406 }
4407
4408 // CHECK-LABEL: test_vmla_lane_u16
4409 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4410 uint16x4_t test_vmla_lane_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) {
4411   return vmla_lane_u16(a, b, c, 3);
4412 }
4413
4414 // CHECK-LABEL: test_vmla_lane_u32
4415 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4416 uint32x2_t test_vmla_lane_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) {
4417   return vmla_lane_u32(a, b, c, 1);
4418 }
4419
4420 // CHECK-LABEL: test_vmla_lane_f32
4421 // CHECK-SWIFT: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4422 // CHECK-SWIFT: vadd.f32
4423 // CHECK-A57: vmla.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4424 float32x2_t test_vmla_lane_f32(float32x2_t a, float32x2_t b, float32x2_t c) {
4425   return vmla_lane_f32(a, b, c, 1);
4426 }
4427
4428 // CHECK-LABEL: test_vmlaq_lane_s16
4429 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4430 int16x8_t test_vmlaq_lane_s16(int16x8_t a, int16x8_t b, int16x4_t c) {
4431   return vmlaq_lane_s16(a, b, c, 3);
4432 }
4433
4434 // CHECK-LABEL: test_vmlaq_lane_s32
4435 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4436 int32x4_t test_vmlaq_lane_s32(int32x4_t a, int32x4_t b, int32x2_t c) {
4437   return vmlaq_lane_s32(a, b, c, 1);
4438 }
4439
4440 // CHECK-LABEL: test_vmlaq_lane_u16
4441 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4442 uint16x8_t test_vmlaq_lane_u16(uint16x8_t a, uint16x8_t b, uint16x4_t c) {
4443   return vmlaq_lane_u16(a, b, c, 3);
4444 }
4445
4446 // CHECK-LABEL: test_vmlaq_lane_u32
4447 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4448 uint32x4_t test_vmlaq_lane_u32(uint32x4_t a, uint32x4_t b, uint32x2_t c) {
4449   return vmlaq_lane_u32(a, b, c, 1);
4450 }
4451
4452 // CHECK-LABEL: test_vmlaq_lane_f32
4453 // CHECK-SWIFT: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4454 // CHECK-SWIFT: vadd.f32
4455 // CHECK-A57: vmla.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4456 float32x4_t test_vmlaq_lane_f32(float32x4_t a, float32x4_t b, float32x2_t c) {
4457   return vmlaq_lane_f32(a, b, c, 1);
4458 }
4459
4460
4461 // CHECK-LABEL: test_vmla_n_s16
4462 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4463 int16x4_t test_vmla_n_s16(int16x4_t a, int16x4_t b, int16_t c) {
4464   return vmla_n_s16(a, b, c);
4465 }
4466
4467 // CHECK-LABEL: test_vmla_n_s32
4468 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4469 int32x2_t test_vmla_n_s32(int32x2_t a, int32x2_t b, int32_t c) {
4470   return vmla_n_s32(a, b, c);
4471 }
4472
4473 // CHECK-LABEL: test_vmla_n_u16
4474 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4475 uint16x4_t test_vmla_n_u16(uint16x4_t a, uint16x4_t b, uint16_t c) {
4476   return vmla_n_u16(a, b, c);
4477 }
4478
4479 // CHECK-LABEL: test_vmla_n_u32
4480 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4481 uint32x2_t test_vmla_n_u32(uint32x2_t a, uint32x2_t b, uint32_t c) {
4482   return vmla_n_u32(a, b, c);
4483 }
4484
4485 // CHECK-LABEL: test_vmla_n_f32
4486 // CHECK-SWIFT: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4487 // CHECK-SWIFT: vadd.f32
4488 // CHECK-A57: vmla.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4489 float32x2_t test_vmla_n_f32(float32x2_t a, float32x2_t b, float32_t c) {
4490   return vmla_n_f32(a, b, c);
4491 }
4492
4493 // CHECK-LABEL: test_vmlaq_n_s16
4494 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4495 int16x8_t test_vmlaq_n_s16(int16x8_t a, int16x8_t b, int16_t c) {
4496   return vmlaq_n_s16(a, b, c);
4497 }
4498
4499 // CHECK-LABEL: test_vmlaq_n_s32
4500 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4501 int32x4_t test_vmlaq_n_s32(int32x4_t a, int32x4_t b, int32_t c) {
4502   return vmlaq_n_s32(a, b, c);
4503 }
4504
4505 // CHECK-LABEL: test_vmlaq_n_u16
4506 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4507 uint16x8_t test_vmlaq_n_u16(uint16x8_t a, uint16x8_t b, uint16_t c) {
4508   return vmlaq_n_u16(a, b, c);
4509 }
4510
4511 // CHECK-LABEL: test_vmlaq_n_u32
4512 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4513 uint32x4_t test_vmlaq_n_u32(uint32x4_t a, uint32x4_t b, uint32_t c) {
4514   return vmlaq_n_u32(a, b, c);
4515 }
4516
4517 // CHECK-LABEL: test_vmlaq_n_f32
4518 // CHECK-SWIFT: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[0]
4519 // CHECK-SWIFT: vadd.f32
4520 // CHECK-A57: vld1.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]},
4521 // CHECK-A57: vmla.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4522 float32x4_t test_vmlaq_n_f32(float32x4_t a, float32x4_t b, float32_t c) {
4523   return vmlaq_n_f32(a, b, c);
4524 }
4525
4526
4527 // CHECK-LABEL: test_vmls_s8
4528 // CHECK: vmls.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4529 int8x8_t test_vmls_s8(int8x8_t a, int8x8_t b, int8x8_t c) {
4530   return vmls_s8(a, b, c);
4531 }
4532
4533 // CHECK-LABEL: test_vmls_s16
4534 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4535 int16x4_t test_vmls_s16(int16x4_t a, int16x4_t b, int16x4_t c) {
4536   return vmls_s16(a, b, c);
4537 }
4538
4539 // CHECK-LABEL: test_vmls_s32
4540 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4541 int32x2_t test_vmls_s32(int32x2_t a, int32x2_t b, int32x2_t c) {
4542   return vmls_s32(a, b, c);
4543 }
4544
4545 // CHECK-LABEL: test_vmls_f32
4546 // CHECK-SWIFT: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4547 // CHECK-SWIFT: vsub.f32
4548 // CHECK-A57: vmls.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4549 float32x2_t test_vmls_f32(float32x2_t a, float32x2_t b, float32x2_t c) {
4550   return vmls_f32(a, b, c);
4551 }
4552
4553 // CHECK-LABEL: test_vmls_u8
4554 // CHECK: vmls.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4555 uint8x8_t test_vmls_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) {
4556   return vmls_u8(a, b, c);
4557 }
4558
4559 // CHECK-LABEL: test_vmls_u16
4560 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4561 uint16x4_t test_vmls_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) {
4562   return vmls_u16(a, b, c);
4563 }
4564
4565 // CHECK-LABEL: test_vmls_u32
4566 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4567 uint32x2_t test_vmls_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) {
4568   return vmls_u32(a, b, c);
4569 }
4570
4571 // CHECK-LABEL: test_vmlsq_s8
4572 // CHECK: vmls.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4573 int8x16_t test_vmlsq_s8(int8x16_t a, int8x16_t b, int8x16_t c) {
4574   return vmlsq_s8(a, b, c);
4575 }
4576
4577 // CHECK-LABEL: test_vmlsq_s16
4578 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4579 int16x8_t test_vmlsq_s16(int16x8_t a, int16x8_t b, int16x8_t c) {
4580   return vmlsq_s16(a, b, c);
4581 }
4582
4583 // CHECK-LABEL: test_vmlsq_s32
4584 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4585 int32x4_t test_vmlsq_s32(int32x4_t a, int32x4_t b, int32x4_t c) {
4586   return vmlsq_s32(a, b, c);
4587 }
4588
4589 // CHECK-LABEL: test_vmlsq_f32
4590 // CHECK-SWIFT: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4591 // CHECK-SWIFT: vsub.f32
4592 // CHECK-A57: vmls.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4593 float32x4_t test_vmlsq_f32(float32x4_t a, float32x4_t b, float32x4_t c) {
4594   return vmlsq_f32(a, b, c);
4595 }
4596
4597 // CHECK-LABEL: test_vmlsq_u8
4598 // CHECK: vmls.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4599 uint8x16_t test_vmlsq_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) {
4600   return vmlsq_u8(a, b, c);
4601 }
4602
4603 // CHECK-LABEL: test_vmlsq_u16
4604 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4605 uint16x8_t test_vmlsq_u16(uint16x8_t a, uint16x8_t b, uint16x8_t c) {
4606   return vmlsq_u16(a, b, c);
4607 }
4608
4609 // CHECK-LABEL: test_vmlsq_u32
4610 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4611 uint32x4_t test_vmlsq_u32(uint32x4_t a, uint32x4_t b, uint32x4_t c) {
4612   return vmlsq_u32(a, b, c);
4613 }
4614
4615
4616 // CHECK-LABEL: test_vmlsl_s8
4617 // CHECK: vmlsl.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4618 int16x8_t test_vmlsl_s8(int16x8_t a, int8x8_t b, int8x8_t c) {
4619   return vmlsl_s8(a, b, c);
4620 }
4621
4622 // CHECK-LABEL: test_vmlsl_s16
4623 // CHECK: vmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4624 int32x4_t test_vmlsl_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
4625   return vmlsl_s16(a, b, c);
4626 }
4627
4628 // CHECK-LABEL: test_vmlsl_s32
4629 // CHECK: vmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4630 int64x2_t test_vmlsl_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
4631   return vmlsl_s32(a, b, c);
4632 }
4633
4634 // CHECK-LABEL: test_vmlsl_u8
4635 // CHECK: vmlsl.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4636 uint16x8_t test_vmlsl_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) {
4637   return vmlsl_u8(a, b, c);
4638 }
4639
4640 // CHECK-LABEL: test_vmlsl_u16
4641 // CHECK: vmlsl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4642 uint32x4_t test_vmlsl_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) {
4643   return vmlsl_u16(a, b, c);
4644 }
4645
4646 // CHECK-LABEL: test_vmlsl_u32
4647 // CHECK: vmlsl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4648 uint64x2_t test_vmlsl_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) {
4649   return vmlsl_u32(a, b, c);
4650 }
4651
4652
4653 // CHECK-LABEL: test_vmlsl_lane_s16
4654 // CHECK: vmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4655 int32x4_t test_vmlsl_lane_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
4656   return vmlsl_lane_s16(a, b, c, 3);
4657 }
4658
4659 // CHECK-LABEL: test_vmlsl_lane_s32
4660 // CHECK: vmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4661 int64x2_t test_vmlsl_lane_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
4662   return vmlsl_lane_s32(a, b, c, 1);
4663 }
4664
4665 // CHECK-LABEL: test_vmlsl_lane_u16
4666 // CHECK: vmlsl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4667 uint32x4_t test_vmlsl_lane_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) {
4668   return vmlsl_lane_u16(a, b, c, 3);
4669 }
4670
4671 // CHECK-LABEL: test_vmlsl_lane_u32
4672 // CHECK: vmlsl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4673 uint64x2_t test_vmlsl_lane_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) {
4674   return vmlsl_lane_u32(a, b, c, 1);
4675 }
4676
4677
4678 // CHECK-LABEL: test_vmlsl_n_s16
4679 // CHECK: vmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4680 int32x4_t test_vmlsl_n_s16(int32x4_t a, int16x4_t b, int16_t c) {
4681   return vmlsl_n_s16(a, b, c);
4682 }
4683
4684 // CHECK-LABEL: test_vmlsl_n_s32
4685 // CHECK: vmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4686 int64x2_t test_vmlsl_n_s32(int64x2_t a, int32x2_t b, int32_t c) {
4687   return vmlsl_n_s32(a, b, c);
4688 }
4689
4690 // CHECK-LABEL: test_vmlsl_n_u16
4691 // CHECK: vmlsl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4692 uint32x4_t test_vmlsl_n_u16(uint32x4_t a, uint16x4_t b, uint16_t c) {
4693   return vmlsl_n_u16(a, b, c);
4694 }
4695
4696 // CHECK-LABEL: test_vmlsl_n_u32
4697 // CHECK: vmlsl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4698 uint64x2_t test_vmlsl_n_u32(uint64x2_t a, uint32x2_t b, uint32_t c) {
4699   return vmlsl_n_u32(a, b, c);
4700 }
4701
4702
4703 // CHECK-LABEL: test_vmls_lane_s16
4704 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4705 int16x4_t test_vmls_lane_s16(int16x4_t a, int16x4_t b, int16x4_t c) {
4706   return vmls_lane_s16(a, b, c, 3);
4707 }
4708
4709 // CHECK-LABEL: test_vmls_lane_s32
4710 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4711 int32x2_t test_vmls_lane_s32(int32x2_t a, int32x2_t b, int32x2_t c) {
4712   return vmls_lane_s32(a, b, c, 1);
4713 }
4714
4715 // CHECK-LABEL: test_vmls_lane_u16
4716 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4717 uint16x4_t test_vmls_lane_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) {
4718   return vmls_lane_u16(a, b, c, 3);
4719 }
4720
4721 // CHECK-LABEL: test_vmls_lane_u32
4722 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4723 uint32x2_t test_vmls_lane_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) {
4724   return vmls_lane_u32(a, b, c, 1);
4725 }
4726
4727 // CHECK-LABEL: test_vmls_lane_f32
4728 // CHECK-SWIFT: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4729 // CHECK-SWIFT: vsub.f32
4730 // CHECK-A57: vmls.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4731 float32x2_t test_vmls_lane_f32(float32x2_t a, float32x2_t b, float32x2_t c) {
4732   return vmls_lane_f32(a, b, c, 1);
4733 }
4734
4735 // CHECK-LABEL: test_vmlsq_lane_s16
4736 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4737 int16x8_t test_vmlsq_lane_s16(int16x8_t a, int16x8_t b, int16x4_t c) {
4738   return vmlsq_lane_s16(a, b, c, 3);
4739 }
4740
4741 // CHECK-LABEL: test_vmlsq_lane_s32
4742 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4743 int32x4_t test_vmlsq_lane_s32(int32x4_t a, int32x4_t b, int32x2_t c) {
4744   return vmlsq_lane_s32(a, b, c, 1);
4745 }
4746
4747 // CHECK-LABEL: test_vmlsq_lane_u16
4748 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4749 uint16x8_t test_vmlsq_lane_u16(uint16x8_t a, uint16x8_t b, uint16x4_t c) {
4750   return vmlsq_lane_u16(a, b, c, 3);
4751 }
4752
4753 // CHECK-LABEL: test_vmlsq_lane_u32
4754 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4755 uint32x4_t test_vmlsq_lane_u32(uint32x4_t a, uint32x4_t b, uint32x2_t c) {
4756   return vmlsq_lane_u32(a, b, c, 1);
4757 }
4758
4759 // CHECK-LABEL: test_vmlsq_lane_f32
4760 // CHECK-SWIFT: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4761 // CHECK-SWIFT: vsub.f32
4762 // CHECK-A57: vmls.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
4763 float32x4_t test_vmlsq_lane_f32(float32x4_t a, float32x4_t b, float32x2_t c) {
4764   return vmlsq_lane_f32(a, b, c, 1);
4765 }
4766
4767
4768 // CHECK-LABEL: test_vmls_n_s16
4769 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4770 int16x4_t test_vmls_n_s16(int16x4_t a, int16x4_t b, int16_t c) {
4771   return vmls_n_s16(a, b, c);
4772 }
4773
4774 // CHECK-LABEL: test_vmls_n_s32
4775 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4776 int32x2_t test_vmls_n_s32(int32x2_t a, int32x2_t b, int32_t c) {
4777   return vmls_n_s32(a, b, c);
4778 }
4779
4780 // CHECK-LABEL: test_vmls_n_u16
4781 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4782 uint16x4_t test_vmls_n_u16(uint16x4_t a, uint16x4_t b, uint16_t c) {
4783   return vmls_n_u16(a, b, c);
4784 }
4785
4786 // CHECK-LABEL: test_vmls_n_u32
4787 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4788 uint32x2_t test_vmls_n_u32(uint32x2_t a, uint32x2_t b, uint32_t c) {
4789   return vmls_n_u32(a, b, c);
4790 }
4791
4792 // CHECK-LABEL: test_vmls_n_f32
4793 // CHECK-SWIFT: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4794 // CHECK-SWIFT: vsub.f32
4795 // CHECK-A57: vmls.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
4796 float32x2_t test_vmls_n_f32(float32x2_t a, float32x2_t b, float32_t c) {
4797   return vmls_n_f32(a, b, c);
4798 }
4799
4800 // CHECK-LABEL: test_vmlsq_n_s16
4801 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4802 int16x8_t test_vmlsq_n_s16(int16x8_t a, int16x8_t b, int16_t c) {
4803   return vmlsq_n_s16(a, b, c);
4804 }
4805
4806 // CHECK-LABEL: test_vmlsq_n_s32
4807 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4808 int32x4_t test_vmlsq_n_s32(int32x4_t a, int32x4_t b, int32_t c) {
4809   return vmlsq_n_s32(a, b, c);
4810 }
4811
4812 // CHECK-LABEL: test_vmlsq_n_u16
4813 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4814 uint16x8_t test_vmlsq_n_u16(uint16x8_t a, uint16x8_t b, uint16_t c) {
4815   return vmlsq_n_u16(a, b, c);
4816 }
4817
4818 // CHECK-LABEL: test_vmlsq_n_u32
4819 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4820 uint32x4_t test_vmlsq_n_u32(uint32x4_t a, uint32x4_t b, uint32_t c) {
4821   return vmlsq_n_u32(a, b, c);
4822 }
4823
4824 // CHECK-LABEL: test_vmlsq_n_f32
4825 // CHECK-SWIFT: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[0]
4826 // CHECK-SWIFT: vsub.f32
4827 // CHECK-A57: vmls.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
4828 float32x4_t test_vmlsq_n_f32(float32x4_t a, float32x4_t b, float32_t c) {
4829   return vmlsq_n_f32(a, b, c);
4830 }
4831
4832
4833 // CHECK-LABEL: test_vmovl_s8
4834 // CHECK: vmovl.s8 q{{[0-9]+}}, d{{[0-9]+}}
4835 int16x8_t test_vmovl_s8(int8x8_t a) {
4836   return vmovl_s8(a);
4837 }
4838
4839 // CHECK-LABEL: test_vmovl_s16
4840 // CHECK: vmovl.s16 q{{[0-9]+}}, d{{[0-9]+}}
4841 int32x4_t test_vmovl_s16(int16x4_t a) {
4842   return vmovl_s16(a);
4843 }
4844
4845 // CHECK-LABEL: test_vmovl_s32
4846 // CHECK: vmovl.s32 q{{[0-9]+}}, d{{[0-9]+}}
4847 int64x2_t test_vmovl_s32(int32x2_t a) {
4848   return vmovl_s32(a);
4849 }
4850
4851 // CHECK-LABEL: test_vmovl_u8
4852 // CHECK: vmovl.u8 q{{[0-9]+}}, d{{[0-9]+}}
4853 uint16x8_t test_vmovl_u8(uint8x8_t a) {
4854   return vmovl_u8(a);
4855 }
4856
4857 // CHECK-LABEL: test_vmovl_u16
4858 // CHECK: vmovl.u16 q{{[0-9]+}}, d{{[0-9]+}}
4859 uint32x4_t test_vmovl_u16(uint16x4_t a) {
4860   return vmovl_u16(a);
4861 }
4862
4863 // CHECK-LABEL: test_vmovl_u32
4864 // CHECK: vmovl.u32 q{{[0-9]+}}, d{{[0-9]+}}
4865 uint64x2_t test_vmovl_u32(uint32x2_t a) {
4866   return vmovl_u32(a);
4867 }
4868
4869
4870 // CHECK-LABEL: test_vmovn_s16
4871 // CHECK: vmovn.i16 d{{[0-9]+}}, q{{[0-9]+}}
4872 int8x8_t test_vmovn_s16(int16x8_t a) {
4873   return vmovn_s16(a);
4874 }
4875
4876 // CHECK-LABEL: test_vmovn_s32
4877 // CHECK: vmovn.i32 d{{[0-9]+}}, q{{[0-9]+}}
4878 int16x4_t test_vmovn_s32(int32x4_t a) {
4879   return vmovn_s32(a);
4880 }
4881
4882 // CHECK-LABEL: test_vmovn_s64
4883 // CHECK: vmovn.i64 d{{[0-9]+}}, q{{[0-9]+}}
4884 int32x2_t test_vmovn_s64(int64x2_t a) {
4885   return vmovn_s64(a);
4886 }
4887
4888 // CHECK-LABEL: test_vmovn_u16
4889 // CHECK: vmovn.i16 d{{[0-9]+}}, q{{[0-9]+}}
4890 uint8x8_t test_vmovn_u16(uint16x8_t a) {
4891   return vmovn_u16(a);
4892 }
4893
4894 // CHECK-LABEL: test_vmovn_u32
4895 // CHECK: vmovn.i32 d{{[0-9]+}}, q{{[0-9]+}}
4896 uint16x4_t test_vmovn_u32(uint32x4_t a) {
4897   return vmovn_u32(a);
4898 }
4899
4900 // CHECK-LABEL: test_vmovn_u64
4901 // CHECK: vmovn.i64 d{{[0-9]+}}, q{{[0-9]+}}
4902 uint32x2_t test_vmovn_u64(uint64x2_t a) {
4903   return vmovn_u64(a);
4904 }
4905
4906
4907 // CHECK-LABEL: test_vmov_n_u8
4908 // CHECK: vmov {{r[0-9]+}}
4909 uint8x8_t test_vmov_n_u8(uint8_t a) {
4910   return vmov_n_u8(a);
4911 }
4912
4913 // CHECK-LABEL: test_vmov_n_u16
4914 // CHECK: vmov {{r[0-9]+}}
4915 uint16x4_t test_vmov_n_u16(uint16_t a) {
4916   return vmov_n_u16(a);
4917 }
4918
4919 // CHECK-LABEL: test_vmov_n_u32
4920 // CHECK: mov {{r[0-9]+}}
4921 uint32x2_t test_vmov_n_u32(uint32_t a) {
4922   return vmov_n_u32(a);
4923 }
4924
4925 // CHECK-LABEL: test_vmov_n_s8
4926 // CHECK: vmov {{r[0-9]+}}
4927 int8x8_t test_vmov_n_s8(int8_t a) {
4928   return vmov_n_s8(a);
4929 }
4930
4931 // CHECK-LABEL: test_vmov_n_s16
4932 // CHECK: vmov {{r[0-9]+}}
4933 int16x4_t test_vmov_n_s16(int16_t a) {
4934   return vmov_n_s16(a);
4935 }
4936
4937 // CHECK-LABEL: test_vmov_n_s32
4938 // CHECK: mov {{r[0-9]+}}
4939 int32x2_t test_vmov_n_s32(int32_t a) {
4940   return vmov_n_s32(a);
4941 }
4942
4943 // CHECK-LABEL: test_vmov_n_p8
4944 // CHECK: vmov {{r[0-9]+}}
4945 poly8x8_t test_vmov_n_p8(poly8_t a) {
4946   return vmov_n_p8(a);
4947 }
4948
4949 // CHECK-LABEL: test_vmov_n_p16
4950 // CHECK: vmov {{r[0-9]+}}
4951 poly16x4_t test_vmov_n_p16(poly16_t a) {
4952   return vmov_n_p16(a);
4953 }
4954
4955 // CHECK-LABEL: test_vmov_n_f16
4956 // CHECK: vld1.16 {{{d[0-9]+\[\]}}}
4957 float16x4_t test_vmov_n_f16(float16_t *a) {
4958   return vmov_n_f16(*a);
4959 }
4960
4961 // CHECK-LABEL: test_vmov_n_f32
4962 // CHECK: mov {{r[0-9]+}}
4963 float32x2_t test_vmov_n_f32(float32_t a) {
4964   return vmov_n_f32(a);
4965 }
4966
4967 // CHECK-LABEL: test_vmovq_n_u8
4968 // CHECK: vmov {{r[0-9]+}}
4969 uint8x16_t test_vmovq_n_u8(uint8_t a) {
4970   return vmovq_n_u8(a);
4971 }
4972
4973 // CHECK-LABEL: test_vmovq_n_u16
4974 // CHECK: vmov {{r[0-9]+}}
4975 uint16x8_t test_vmovq_n_u16(uint16_t a) {
4976   return vmovq_n_u16(a);
4977 }
4978
4979 // CHECK-LABEL: test_vmovq_n_u32
4980 // CHECK: vmov {{r[0-9]+}}
4981 uint32x4_t test_vmovq_n_u32(uint32_t a) {
4982   return vmovq_n_u32(a);
4983 }
4984
4985 // CHECK-LABEL: test_vmovq_n_s8
4986 // CHECK: vmov {{r[0-9]+}}
4987 int8x16_t test_vmovq_n_s8(int8_t a) {
4988   return vmovq_n_s8(a);
4989 }
4990
4991 // CHECK-LABEL: test_vmovq_n_s16
4992 // CHECK: vmov {{r[0-9]+}}
4993 int16x8_t test_vmovq_n_s16(int16_t a) {
4994   return vmovq_n_s16(a);
4995 }
4996
4997 // CHECK-LABEL: test_vmovq_n_s32
4998 // CHECK: vmov {{r[0-9]+}}
4999 int32x4_t test_vmovq_n_s32(int32_t a) {
5000   return vmovq_n_s32(a);
5001 }
5002
5003 // CHECK-LABEL: test_vmovq_n_p8
5004 // CHECK: vmov {{r[0-9]+}}
5005 poly8x16_t test_vmovq_n_p8(poly8_t a) {
5006   return vmovq_n_p8(a);
5007 }
5008
5009 // CHECK-LABEL: test_vmovq_n_p16
5010 // CHECK: vmov {{r[0-9]+}}
5011 poly16x8_t test_vmovq_n_p16(poly16_t a) {
5012   return vmovq_n_p16(a);
5013 }
5014
5015 // CHECK-LABEL: test_vmovq_n_f16
5016 // CHECK: vld1.16 {{{d[0-9]+\[\], d[0-9]+\[\]}}}
5017 float16x8_t test_vmovq_n_f16(float16_t *a) {
5018   return vmovq_n_f16(*a);
5019 }
5020
5021 // CHECK-LABEL: test_vmovq_n_f32
5022 // CHECK: vmov {{r[0-9]+}}
5023 float32x4_t test_vmovq_n_f32(float32_t a) {
5024   return vmovq_n_f32(a);
5025 }
5026
5027 // CHECK-LABEL: test_vmov_n_s64
5028 // CHECK: vmov.32 [[REG:d[0-9]+]][0], r0
5029 // CHECK: vmov.32 [[REG]][1], r1
5030 int64x1_t test_vmov_n_s64(int64_t a) {
5031   int64x1_t tmp = vmov_n_s64(a);
5032   return vadd_s64(tmp, tmp);
5033 }
5034
5035 // CHECK-LABEL: test_vmov_n_u64
5036 // CHECK: vmov.32 [[REG:d[0-9]+]][0], r0
5037 // CHECK: vmov.32 [[REG]][1], r1
5038 uint64x1_t test_vmov_n_u64(uint64_t a) {
5039   uint64x1_t tmp = vmov_n_u64(a);
5040   return vadd_u64(tmp, tmp);
5041 }
5042
5043 // CHECK-LABEL: test_vmovq_n_s64
5044 // CHECK: vmov {{r[0-9]+}}
5045 int64x2_t test_vmovq_n_s64(int64_t a) {
5046   return vmovq_n_s64(a);
5047 }
5048
5049 // CHECK-LABEL: test_vmovq_n_u64
5050 // CHECK: vmov {{r[0-9]+}}
5051 uint64x2_t test_vmovq_n_u64(uint64_t a) {
5052   return vmovq_n_u64(a);
5053 }
5054
5055
5056 // CHECK-LABEL: test_vmul_s8
5057 // CHECK: vmul.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5058 int8x8_t test_vmul_s8(int8x8_t a, int8x8_t b) {
5059   return vmul_s8(a, b);
5060 }
5061
5062 // CHECK-LABEL: test_vmul_s16
5063 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5064 int16x4_t test_vmul_s16(int16x4_t a, int16x4_t b) {
5065   return vmul_s16(a, b);
5066 }
5067
5068 // CHECK-LABEL: test_vmul_s32
5069 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5070 int32x2_t test_vmul_s32(int32x2_t a, int32x2_t b) {
5071   return vmul_s32(a, b);
5072 }
5073
5074 // CHECK-LABEL: test_vmul_f32
5075 // CHECK: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5076 float32x2_t test_vmul_f32(float32x2_t a, float32x2_t b) {
5077   return vmul_f32(a, b);
5078 }
5079
5080 // CHECK-LABEL: test_vmul_u8
5081 // CHECK: vmul.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5082 uint8x8_t test_vmul_u8(uint8x8_t a, uint8x8_t b) {
5083   return vmul_u8(a, b);
5084 }
5085
5086 // CHECK-LABEL: test_vmul_u16
5087 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5088 uint16x4_t test_vmul_u16(uint16x4_t a, uint16x4_t b) {
5089   return vmul_u16(a, b);
5090 }
5091
5092 // CHECK-LABEL: test_vmul_u32
5093 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5094 uint32x2_t test_vmul_u32(uint32x2_t a, uint32x2_t b) {
5095   return vmul_u32(a, b);
5096 }
5097
5098 // CHECK-LABEL: test_vmulq_s8
5099 // CHECK: vmul.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5100 int8x16_t test_vmulq_s8(int8x16_t a, int8x16_t b) {
5101   return vmulq_s8(a, b);
5102 }
5103
5104 // CHECK-LABEL: test_vmulq_s16
5105 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5106 int16x8_t test_vmulq_s16(int16x8_t a, int16x8_t b) {
5107   return vmulq_s16(a, b);
5108 }
5109
5110 // CHECK-LABEL: test_vmulq_s32
5111 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5112 int32x4_t test_vmulq_s32(int32x4_t a, int32x4_t b) {
5113   return vmulq_s32(a, b);
5114 }
5115
5116 // CHECK-LABEL: test_vmulq_f32
5117 // CHECK: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5118 float32x4_t test_vmulq_f32(float32x4_t a, float32x4_t b) {
5119   return vmulq_f32(a, b);
5120 }
5121
5122 // CHECK-LABEL: test_vmulq_u8
5123 // CHECK: vmul.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5124 uint8x16_t test_vmulq_u8(uint8x16_t a, uint8x16_t b) {
5125   return vmulq_u8(a, b);
5126 }
5127
5128 // CHECK-LABEL: test_vmulq_u16
5129 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5130 uint16x8_t test_vmulq_u16(uint16x8_t a, uint16x8_t b) {
5131   return vmulq_u16(a, b);
5132 }
5133
5134 // CHECK-LABEL: test_vmulq_u32
5135 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5136 uint32x4_t test_vmulq_u32(uint32x4_t a, uint32x4_t b) {
5137   return vmulq_u32(a, b);
5138 }
5139
5140
5141 // CHECK-LABEL: test_vmull_s8
5142 // CHECK: vmull.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5143 int16x8_t test_vmull_s8(int8x8_t a, int8x8_t b) {
5144   return vmull_s8(a, b);
5145 }
5146
5147 // CHECK-LABEL: test_vmull_s16
5148 // CHECK: vmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5149 int32x4_t test_vmull_s16(int16x4_t a, int16x4_t b) {
5150   return vmull_s16(a, b);
5151 }
5152
5153 // CHECK-LABEL: test_vmull_s32
5154 // CHECK: vmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5155 int64x2_t test_vmull_s32(int32x2_t a, int32x2_t b) {
5156   return vmull_s32(a, b);
5157 }
5158
5159 // CHECK-LABEL: test_vmull_u8
5160 // CHECK: vmull.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5161 uint16x8_t test_vmull_u8(uint8x8_t a, uint8x8_t b) {
5162   return vmull_u8(a, b);
5163 }
5164
5165 // CHECK-LABEL: test_vmull_u16
5166 // CHECK: vmull.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5167 uint32x4_t test_vmull_u16(uint16x4_t a, uint16x4_t b) {
5168   return vmull_u16(a, b);
5169 }
5170
5171 // CHECK-LABEL: test_vmull_u32
5172 // CHECK: vmull.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5173 uint64x2_t test_vmull_u32(uint32x2_t a, uint32x2_t b) {
5174   return vmull_u32(a, b);
5175 }
5176
5177 // CHECK-LABEL: test_vmull_p8
5178 // CHECK: vmull.p8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5179 poly16x8_t test_vmull_p8(poly8x8_t a, poly8x8_t b) {
5180   return vmull_p8(a, b);
5181 }
5182
5183
5184 // CHECK-LABEL: test_vmull_lane_s16
5185 // CHECK: vmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
5186 int32x4_t test_vmull_lane_s16(int16x4_t a, int16x4_t b) {
5187   return vmull_lane_s16(a, b, 3);
5188 }
5189
5190 // CHECK-LABEL: test_vmull_lane_s32
5191 // CHECK: vmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
5192 int64x2_t test_vmull_lane_s32(int32x2_t a, int32x2_t b) {
5193   return vmull_lane_s32(a, b, 1);
5194 }
5195
5196 // CHECK-LABEL: test_vmull_lane_u16
5197 // CHECK: vmull.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
5198 uint32x4_t test_vmull_lane_u16(uint16x4_t a, uint16x4_t b) {
5199   return vmull_lane_u16(a, b, 3);
5200 }
5201
5202 // CHECK-LABEL: test_vmull_lane_u32
5203 // CHECK: vmull.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
5204 uint64x2_t test_vmull_lane_u32(uint32x2_t a, uint32x2_t b) {
5205   return vmull_lane_u32(a, b, 1);
5206 }
5207
5208
5209 // CHECK-LABEL: test_vmull_n_s16
5210 // CHECK: vmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5211 int32x4_t test_vmull_n_s16(int16x4_t a, int16_t b) {
5212   return vmull_n_s16(a, b);
5213 }
5214
5215 // CHECK-LABEL: test_vmull_n_s32
5216 // CHECK: vmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5217 int64x2_t test_vmull_n_s32(int32x2_t a, int32_t b) {
5218   return vmull_n_s32(a, b);
5219 }
5220
5221 // CHECK-LABEL: test_vmull_n_u16
5222 // CHECK: vmull.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5223 uint32x4_t test_vmull_n_u16(uint16x4_t a, uint16_t b) {
5224   return vmull_n_u16(a, b);
5225 }
5226
5227 // CHECK-LABEL: test_vmull_n_u32
5228 // CHECK: vmull.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5229 uint64x2_t test_vmull_n_u32(uint32x2_t a, uint32_t b) {
5230   return vmull_n_u32(a, b);
5231 }
5232
5233
5234 // CHECK-LABEL: test_vmul_p8
5235 // CHECK: vmul.p8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5236 poly8x8_t test_vmul_p8(poly8x8_t a, poly8x8_t b) {
5237   return vmul_p8(a, b);
5238 }
5239
5240 // CHECK-LABEL: test_vmulq_p8
5241 // CHECK: vmul.p8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5242 poly8x16_t test_vmulq_p8(poly8x16_t a, poly8x16_t b) {
5243   return vmulq_p8(a, b);
5244 }
5245
5246
5247 // CHECK-LABEL: test_vmul_lane_s16
5248 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
5249 int16x4_t test_vmul_lane_s16(int16x4_t a, int16x4_t b) {
5250   return vmul_lane_s16(a, b, 3);
5251 }
5252
5253 // CHECK-LABEL: test_vmul_lane_s32
5254 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
5255 int32x2_t test_vmul_lane_s32(int32x2_t a, int32x2_t b) {
5256   return vmul_lane_s32(a, b, 1);
5257 }
5258
5259 // CHECK-LABEL: test_vmul_lane_f32
5260 // CHECK: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
5261 float32x2_t test_vmul_lane_f32(float32x2_t a, float32x2_t b) {
5262   return vmul_lane_f32(a, b, 1);
5263 }
5264
5265 // CHECK-LABEL: test_vmul_lane_u16
5266 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
5267 uint16x4_t test_vmul_lane_u16(uint16x4_t a, uint16x4_t b) {
5268   return vmul_lane_u16(a, b, 3);
5269 }
5270
5271 // CHECK-LABEL: test_vmul_lane_u32
5272 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
5273 uint32x2_t test_vmul_lane_u32(uint32x2_t a, uint32x2_t b) {
5274   return vmul_lane_u32(a, b, 1);
5275 }
5276
5277 // CHECK-LABEL: test_vmulq_lane_s16
5278 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
5279 int16x8_t test_vmulq_lane_s16(int16x8_t a, int16x4_t b) {
5280   return vmulq_lane_s16(a, b, 3);
5281 }
5282
5283 // CHECK-LABEL: test_vmulq_lane_s32
5284 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
5285 int32x4_t test_vmulq_lane_s32(int32x4_t a, int32x2_t b) {
5286   return vmulq_lane_s32(a, b, 1);
5287 }
5288
5289 // CHECK-LABEL: test_vmulq_lane_f32
5290 // CHECK: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
5291 float32x4_t test_vmulq_lane_f32(float32x4_t a, float32x2_t b) {
5292   return vmulq_lane_f32(a, b, 1);
5293 }
5294
5295 // CHECK-LABEL: test_vmulq_lane_u16
5296 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
5297 uint16x8_t test_vmulq_lane_u16(uint16x8_t a, uint16x4_t b) {
5298   return vmulq_lane_u16(a, b, 3);
5299 }
5300
5301 // CHECK-LABEL: test_vmulq_lane_u32
5302 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
5303 uint32x4_t test_vmulq_lane_u32(uint32x4_t a, uint32x2_t b) {
5304   return vmulq_lane_u32(a, b, 1);
5305 }
5306
5307
5308 // CHECK-LABEL: test_vmul_n_s16
5309 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5310 int16x4_t test_vmul_n_s16(int16x4_t a, int16_t b) {
5311   return vmul_n_s16(a, b);
5312 }
5313
5314 // CHECK-LABEL: test_vmul_n_s32
5315 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5316 int32x2_t test_vmul_n_s32(int32x2_t a, int32_t b) {
5317   return vmul_n_s32(a, b);
5318 }
5319
5320 // CHECK-LABEL: test_vmul_n_f32
5321 // CHECK: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5322 float32x2_t test_vmul_n_f32(float32x2_t a, float32_t b) {
5323   return vmul_n_f32(a, b);
5324 }
5325
5326 // CHECK-LABEL: test_vmul_n_u16
5327 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5328 uint16x4_t test_vmul_n_u16(uint16x4_t a, uint16_t b) {
5329   return vmul_n_u16(a, b);
5330 }
5331
5332 // CHECK-LABEL: test_vmul_n_u32
5333 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5334 uint32x2_t test_vmul_n_u32(uint32x2_t a, uint32_t b) {
5335   return vmul_n_u32(a, b);
5336 }
5337
5338 // CHECK-LABEL: test_vmulq_n_s16
5339 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5340 int16x8_t test_vmulq_n_s16(int16x8_t a, int16_t b) {
5341   return vmulq_n_s16(a, b);
5342 }
5343
5344 // CHECK-LABEL: test_vmulq_n_s32
5345 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5346 int32x4_t test_vmulq_n_s32(int32x4_t a, int32_t b) {
5347   return vmulq_n_s32(a, b);
5348 }
5349
5350 // CHECK-LABEL: test_vmulq_n_f32
5351 // CHECK: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[0]
5352 float32x4_t test_vmulq_n_f32(float32x4_t a, float32_t b) {
5353   return vmulq_n_f32(a, b);
5354 }
5355
5356 // CHECK-LABEL: test_vmulq_n_u16
5357 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5358 uint16x8_t test_vmulq_n_u16(uint16x8_t a, uint16_t b) {
5359   return vmulq_n_u16(a, b);
5360 }
5361
5362 // CHECK-LABEL: test_vmulq_n_u32
5363 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5364 uint32x4_t test_vmulq_n_u32(uint32x4_t a, uint32_t b) {
5365   return vmulq_n_u32(a, b);
5366 }
5367
5368
5369 // CHECK-LABEL: test_vmvn_s8
5370 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}}
5371 int8x8_t test_vmvn_s8(int8x8_t a) {
5372   return vmvn_s8(a);
5373 }
5374
5375 // CHECK-LABEL: test_vmvn_s16
5376 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}}
5377 int16x4_t test_vmvn_s16(int16x4_t a) {
5378   return vmvn_s16(a);
5379 }
5380
5381 // CHECK-LABEL: test_vmvn_s32
5382 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}}
5383 int32x2_t test_vmvn_s32(int32x2_t a) {
5384   return vmvn_s32(a);
5385 }
5386
5387 // CHECK-LABEL: test_vmvn_u8
5388 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}}
5389 uint8x8_t test_vmvn_u8(uint8x8_t a) {
5390   return vmvn_u8(a);
5391 }
5392
5393 // CHECK-LABEL: test_vmvn_u16
5394 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}}
5395 uint16x4_t test_vmvn_u16(uint16x4_t a) {
5396   return vmvn_u16(a);
5397 }
5398
5399 // CHECK-LABEL: test_vmvn_u32
5400 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}}
5401 uint32x2_t test_vmvn_u32(uint32x2_t a) {
5402   return vmvn_u32(a);
5403 }
5404
5405 // CHECK-LABEL: test_vmvn_p8
5406 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}}
5407 poly8x8_t test_vmvn_p8(poly8x8_t a) {
5408   return vmvn_p8(a);
5409 }
5410
5411 // CHECK-LABEL: test_vmvnq_s8
5412 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}}
5413 int8x16_t test_vmvnq_s8(int8x16_t a) {
5414   return vmvnq_s8(a);
5415 }
5416
5417 // CHECK-LABEL: test_vmvnq_s16
5418 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}}
5419 int16x8_t test_vmvnq_s16(int16x8_t a) {
5420   return vmvnq_s16(a);
5421 }
5422
5423 // CHECK-LABEL: test_vmvnq_s32
5424 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}}
5425 int32x4_t test_vmvnq_s32(int32x4_t a) {
5426   return vmvnq_s32(a);
5427 }
5428
5429 // CHECK-LABEL: test_vmvnq_u8
5430 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}}
5431 uint8x16_t test_vmvnq_u8(uint8x16_t a) {
5432   return vmvnq_u8(a);
5433 }
5434
5435 // CHECK-LABEL: test_vmvnq_u16
5436 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}}
5437 uint16x8_t test_vmvnq_u16(uint16x8_t a) {
5438   return vmvnq_u16(a);
5439 }
5440
5441 // CHECK-LABEL: test_vmvnq_u32
5442 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}}
5443 uint32x4_t test_vmvnq_u32(uint32x4_t a) {
5444   return vmvnq_u32(a);
5445 }
5446
5447 // CHECK-LABEL: test_vmvnq_p8
5448 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}}
5449 poly8x16_t test_vmvnq_p8(poly8x16_t a) {
5450   return vmvnq_p8(a);
5451 }
5452
5453
5454 // CHECK-LABEL: test_vneg_s8
5455 // CHECK: vneg.s8 d{{[0-9]+}}, d{{[0-9]+}}
5456 int8x8_t test_vneg_s8(int8x8_t a) {
5457   return vneg_s8(a);
5458 }
5459
5460 // CHECK-LABEL: test_vneg_s16
5461 // CHECK: vneg.s16 d{{[0-9]+}}, d{{[0-9]+}}
5462 int16x4_t test_vneg_s16(int16x4_t a) {
5463   return vneg_s16(a);
5464 }
5465
5466 // CHECK-LABEL: test_vneg_s32
5467 // CHECK: vneg.s32 d{{[0-9]+}}, d{{[0-9]+}}
5468 int32x2_t test_vneg_s32(int32x2_t a) {
5469   return vneg_s32(a);
5470 }
5471
5472 // CHECK-LABEL: test_vneg_f32
5473 // CHECK: vneg.f32 d{{[0-9]+}}, d{{[0-9]+}}
5474 float32x2_t test_vneg_f32(float32x2_t a) {
5475   return vneg_f32(a);
5476 }
5477
5478 // CHECK-LABEL: test_vnegq_s8
5479 // CHECK: vneg.s8 q{{[0-9]+}}, q{{[0-9]+}}
5480 int8x16_t test_vnegq_s8(int8x16_t a) {
5481   return vnegq_s8(a);
5482 }
5483
5484 // CHECK-LABEL: test_vnegq_s16
5485 // CHECK: vneg.s16 q{{[0-9]+}}, q{{[0-9]+}}
5486 int16x8_t test_vnegq_s16(int16x8_t a) {
5487   return vnegq_s16(a);
5488 }
5489
5490 // CHECK-LABEL: test_vnegq_s32
5491 // CHECK: vneg.s32 q{{[0-9]+}}, q{{[0-9]+}}
5492 int32x4_t test_vnegq_s32(int32x4_t a) {
5493   return vnegq_s32(a);
5494 }
5495
5496 // CHECK-LABEL: test_vnegq_f32
5497 // CHECK: vneg.f32 q{{[0-9]+}}, q{{[0-9]+}}
5498 float32x4_t test_vnegq_f32(float32x4_t a) {
5499   return vnegq_f32(a);
5500 }
5501
5502
5503 // CHECK-LABEL: test_vorn_s8
5504 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5505 int8x8_t test_vorn_s8(int8x8_t a, int8x8_t b) {
5506   return vorn_s8(a, b);
5507 }
5508
5509 // CHECK-LABEL: test_vorn_s16
5510 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5511 int16x4_t test_vorn_s16(int16x4_t a, int16x4_t b) {
5512   return vorn_s16(a, b);
5513 }
5514
5515 // CHECK-LABEL: test_vorn_s32
5516 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5517 int32x2_t test_vorn_s32(int32x2_t a, int32x2_t b) {
5518   return vorn_s32(a, b);
5519 }
5520
5521 // CHECK-LABEL: test_vorn_s64
5522 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5523 int64x1_t test_vorn_s64(int64x1_t a, int64x1_t b) {
5524   return vorn_s64(a, b);
5525 }
5526
5527 // CHECK-LABEL: test_vorn_u8
5528 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5529 uint8x8_t test_vorn_u8(uint8x8_t a, uint8x8_t b) {
5530   return vorn_u8(a, b);
5531 }
5532
5533 // CHECK-LABEL: test_vorn_u16
5534 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5535 uint16x4_t test_vorn_u16(uint16x4_t a, uint16x4_t b) {
5536   return vorn_u16(a, b);
5537 }
5538
5539 // CHECK-LABEL: test_vorn_u32
5540 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5541 uint32x2_t test_vorn_u32(uint32x2_t a, uint32x2_t b) {
5542   return vorn_u32(a, b);
5543 }
5544
5545 // CHECK-LABEL: test_vorn_u64
5546 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5547 uint64x1_t test_vorn_u64(uint64x1_t a, uint64x1_t b) {
5548   return vorn_u64(a, b);
5549 }
5550
5551 // CHECK-LABEL: test_vornq_s8
5552 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5553 int8x16_t test_vornq_s8(int8x16_t a, int8x16_t b) {
5554   return vornq_s8(a, b);
5555 }
5556
5557 // CHECK-LABEL: test_vornq_s16
5558 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5559 int16x8_t test_vornq_s16(int16x8_t a, int16x8_t b) {
5560   return vornq_s16(a, b);
5561 }
5562
5563 // CHECK-LABEL: test_vornq_s32
5564 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5565 int32x4_t test_vornq_s32(int32x4_t a, int32x4_t b) {
5566   return vornq_s32(a, b);
5567 }
5568
5569 // CHECK-LABEL: test_vornq_s64
5570 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5571 int64x2_t test_vornq_s64(int64x2_t a, int64x2_t b) {
5572   return vornq_s64(a, b);
5573 }
5574
5575 // CHECK-LABEL: test_vornq_u8
5576 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5577 uint8x16_t test_vornq_u8(uint8x16_t a, uint8x16_t b) {
5578   return vornq_u8(a, b);
5579 }
5580
5581 // CHECK-LABEL: test_vornq_u16
5582 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5583 uint16x8_t test_vornq_u16(uint16x8_t a, uint16x8_t b) {
5584   return vornq_u16(a, b);
5585 }
5586
5587 // CHECK-LABEL: test_vornq_u32
5588 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5589 uint32x4_t test_vornq_u32(uint32x4_t a, uint32x4_t b) {
5590   return vornq_u32(a, b);
5591 }
5592
5593 // CHECK-LABEL: test_vornq_u64
5594 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5595 uint64x2_t test_vornq_u64(uint64x2_t a, uint64x2_t b) {
5596   return vornq_u64(a, b);
5597 }
5598
5599
5600 // CHECK-LABEL: test_vorr_s8
5601 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5602 int8x8_t test_vorr_s8(int8x8_t a, int8x8_t b) {
5603   return vorr_s8(a, b);
5604 }
5605
5606 // CHECK-LABEL: test_vorr_s16
5607 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5608 int16x4_t test_vorr_s16(int16x4_t a, int16x4_t b) {
5609   return vorr_s16(a, b);
5610 }
5611
5612 // CHECK-LABEL: test_vorr_s32
5613 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5614 int32x2_t test_vorr_s32(int32x2_t a, int32x2_t b) {
5615   return vorr_s32(a, b);
5616 }
5617
5618 // CHECK-LABEL: test_vorr_s64
5619 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5620 int64x1_t test_vorr_s64(int64x1_t a, int64x1_t b) {
5621   return vorr_s64(a, b);
5622 }
5623
5624 // CHECK-LABEL: test_vorr_u8
5625 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5626 uint8x8_t test_vorr_u8(uint8x8_t a, uint8x8_t b) {
5627   return vorr_u8(a, b);
5628 }
5629
5630 // CHECK-LABEL: test_vorr_u16
5631 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5632 uint16x4_t test_vorr_u16(uint16x4_t a, uint16x4_t b) {
5633   return vorr_u16(a, b);
5634 }
5635
5636 // CHECK-LABEL: test_vorr_u32
5637 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5638 uint32x2_t test_vorr_u32(uint32x2_t a, uint32x2_t b) {
5639   return vorr_u32(a, b);
5640 }
5641
5642 // CHECK-LABEL: test_vorr_u64
5643 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5644 uint64x1_t test_vorr_u64(uint64x1_t a, uint64x1_t b) {
5645   return vorr_u64(a, b);
5646 }
5647
5648 // CHECK-LABEL: test_vorrq_s8
5649 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5650 int8x16_t test_vorrq_s8(int8x16_t a, int8x16_t b) {
5651   return vorrq_s8(a, b);
5652 }
5653
5654 // CHECK-LABEL: test_vorrq_s16
5655 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5656 int16x8_t test_vorrq_s16(int16x8_t a, int16x8_t b) {
5657   return vorrq_s16(a, b);
5658 }
5659
5660 // CHECK-LABEL: test_vorrq_s32
5661 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5662 int32x4_t test_vorrq_s32(int32x4_t a, int32x4_t b) {
5663   return vorrq_s32(a, b);
5664 }
5665
5666 // CHECK-LABEL: test_vorrq_s64
5667 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5668 int64x2_t test_vorrq_s64(int64x2_t a, int64x2_t b) {
5669   return vorrq_s64(a, b);
5670 }
5671
5672 // CHECK-LABEL: test_vorrq_u8
5673 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5674 uint8x16_t test_vorrq_u8(uint8x16_t a, uint8x16_t b) {
5675   return vorrq_u8(a, b);
5676 }
5677
5678 // CHECK-LABEL: test_vorrq_u16
5679 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5680 uint16x8_t test_vorrq_u16(uint16x8_t a, uint16x8_t b) {
5681   return vorrq_u16(a, b);
5682 }
5683
5684 // CHECK-LABEL: test_vorrq_u32
5685 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5686 uint32x4_t test_vorrq_u32(uint32x4_t a, uint32x4_t b) {
5687   return vorrq_u32(a, b);
5688 }
5689
5690 // CHECK-LABEL: test_vorrq_u64
5691 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
5692 uint64x2_t test_vorrq_u64(uint64x2_t a, uint64x2_t b) {
5693   return vorrq_u64(a, b);
5694 }
5695
5696
5697 // CHECK-LABEL: test_vpadal_s8
5698 // CHECK: vpadal.s8 d{{[0-9]+}}, d{{[0-9]+}}
5699 int16x4_t test_vpadal_s8(int16x4_t a, int8x8_t b) {
5700   return vpadal_s8(a, b);
5701 }
5702
5703 // CHECK-LABEL: test_vpadal_s16
5704 // CHECK: vpadal.s16 d{{[0-9]+}}, d{{[0-9]+}}
5705 int32x2_t test_vpadal_s16(int32x2_t a, int16x4_t b) {
5706   return vpadal_s16(a, b);
5707 }
5708
5709 // CHECK-LABEL: test_vpadal_s32
5710 // CHECK: vpadal.s32 d{{[0-9]+}}, d{{[0-9]+}}
5711 int64x1_t test_vpadal_s32(int64x1_t a, int32x2_t b) {
5712   return vpadal_s32(a, b);
5713 }
5714
5715 // CHECK-LABEL: test_vpadal_u8
5716 // CHECK: vpadal.u8 d{{[0-9]+}}, d{{[0-9]+}}
5717 uint16x4_t test_vpadal_u8(uint16x4_t a, uint8x8_t b) {
5718   return vpadal_u8(a, b);
5719 }
5720
5721 // CHECK-LABEL: test_vpadal_u16
5722 // CHECK: vpadal.u16 d{{[0-9]+}}, d{{[0-9]+}}
5723 uint32x2_t test_vpadal_u16(uint32x2_t a, uint16x4_t b) {
5724   return vpadal_u16(a, b);
5725 }
5726
5727 // CHECK-LABEL: test_vpadal_u32
5728 // CHECK: vpadal.u32 d{{[0-9]+}}, d{{[0-9]+}}
5729 uint64x1_t test_vpadal_u32(uint64x1_t a, uint32x2_t b) {
5730   return vpadal_u32(a, b);
5731 }
5732
5733 // CHECK-LABEL: test_vpadalq_s8
5734 // CHECK: vpadal.s8 q{{[0-9]+}}, q{{[0-9]+}}
5735 int16x8_t test_vpadalq_s8(int16x8_t a, int8x16_t b) {
5736   return vpadalq_s8(a, b);
5737 }
5738
5739 // CHECK-LABEL: test_vpadalq_s16
5740 // CHECK: vpadal.s16 q{{[0-9]+}}, q{{[0-9]+}}
5741 int32x4_t test_vpadalq_s16(int32x4_t a, int16x8_t b) {
5742   return vpadalq_s16(a, b);
5743 }
5744
5745 // CHECK-LABEL: test_vpadalq_s32
5746 // CHECK: vpadal.s32 q{{[0-9]+}}, q{{[0-9]+}}
5747 int64x2_t test_vpadalq_s32(int64x2_t a, int32x4_t b) {
5748   return vpadalq_s32(a, b);
5749 }
5750
5751 // CHECK-LABEL: test_vpadalq_u8
5752 // CHECK: vpadal.u8 q{{[0-9]+}}, q{{[0-9]+}}
5753 uint16x8_t test_vpadalq_u8(uint16x8_t a, uint8x16_t b) {
5754   return vpadalq_u8(a, b);
5755 }
5756
5757 // CHECK-LABEL: test_vpadalq_u16
5758 // CHECK: vpadal.u16 q{{[0-9]+}}, q{{[0-9]+}}
5759 uint32x4_t test_vpadalq_u16(uint32x4_t a, uint16x8_t b) {
5760   return vpadalq_u16(a, b);
5761 }
5762
5763 // CHECK-LABEL: test_vpadalq_u32
5764 // CHECK: vpadal.u32 q{{[0-9]+}}, q{{[0-9]+}}
5765 uint64x2_t test_vpadalq_u32(uint64x2_t a, uint32x4_t b) {
5766   return vpadalq_u32(a, b);
5767 }
5768
5769
5770 // CHECK-LABEL: test_vpadd_s8
5771 // CHECK: vpadd.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5772 int8x8_t test_vpadd_s8(int8x8_t a, int8x8_t b) {
5773   return vpadd_s8(a, b);
5774 }
5775
5776 // CHECK-LABEL: test_vpadd_s16
5777 // CHECK: vpadd.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5778 int16x4_t test_vpadd_s16(int16x4_t a, int16x4_t b) {
5779   return vpadd_s16(a, b);
5780 }
5781
5782 // CHECK-LABEL: test_vpadd_s32
5783 // CHECK: vpadd.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5784 int32x2_t test_vpadd_s32(int32x2_t a, int32x2_t b) {
5785   return vpadd_s32(a, b);
5786 }
5787
5788 // CHECK-LABEL: test_vpadd_u8
5789 // CHECK: vpadd.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5790 uint8x8_t test_vpadd_u8(uint8x8_t a, uint8x8_t b) {
5791   return vpadd_u8(a, b);
5792 }
5793
5794 // CHECK-LABEL: test_vpadd_u16
5795 // CHECK: vpadd.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5796 uint16x4_t test_vpadd_u16(uint16x4_t a, uint16x4_t b) {
5797   return vpadd_u16(a, b);
5798 }
5799
5800 // CHECK-LABEL: test_vpadd_u32
5801 // CHECK: vpadd.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5802 uint32x2_t test_vpadd_u32(uint32x2_t a, uint32x2_t b) {
5803   return vpadd_u32(a, b);
5804 }
5805
5806 // CHECK-LABEL: test_vpadd_f32
5807 // CHECK: vpadd.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5808 float32x2_t test_vpadd_f32(float32x2_t a, float32x2_t b) {
5809   return vpadd_f32(a, b);
5810 }
5811
5812
5813 // CHECK-LABEL: test_vpaddl_s8
5814 // CHECK: vpaddl.s8 d{{[0-9]+}}, d{{[0-9]+}}
5815 int16x4_t test_vpaddl_s8(int8x8_t a) {
5816   return vpaddl_s8(a);
5817 }
5818
5819 // CHECK-LABEL: test_vpaddl_s16
5820 // CHECK: vpaddl.s16 d{{[0-9]+}}, d{{[0-9]+}}
5821 int32x2_t test_vpaddl_s16(int16x4_t a) {
5822   return vpaddl_s16(a);
5823 }
5824
5825 // CHECK-LABEL: test_vpaddl_s32
5826 // CHECK: vpaddl.s32 d{{[0-9]+}}, d{{[0-9]+}}
5827 int64x1_t test_vpaddl_s32(int32x2_t a) {
5828   return vpaddl_s32(a);
5829 }
5830
5831 // CHECK-LABEL: test_vpaddl_u8
5832 // CHECK: vpaddl.u8 d{{[0-9]+}}, d{{[0-9]+}}
5833 uint16x4_t test_vpaddl_u8(uint8x8_t a) {
5834   return vpaddl_u8(a);
5835 }
5836
5837 // CHECK-LABEL: test_vpaddl_u16
5838 // CHECK: vpaddl.u16 d{{[0-9]+}}, d{{[0-9]+}}
5839 uint32x2_t test_vpaddl_u16(uint16x4_t a) {
5840   return vpaddl_u16(a);
5841 }
5842
5843 // CHECK-LABEL: test_vpaddl_u32
5844 // CHECK: vpaddl.u32 d{{[0-9]+}}, d{{[0-9]+}}
5845 uint64x1_t test_vpaddl_u32(uint32x2_t a) {
5846   return vpaddl_u32(a);
5847 }
5848
5849 // CHECK-LABEL: test_vpaddlq_s8
5850 // CHECK: vpaddl.s8 q{{[0-9]+}}, q{{[0-9]+}}
5851 int16x8_t test_vpaddlq_s8(int8x16_t a) {
5852   return vpaddlq_s8(a);
5853 }
5854
5855 // CHECK-LABEL: test_vpaddlq_s16
5856 // CHECK: vpaddl.s16 q{{[0-9]+}}, q{{[0-9]+}}
5857 int32x4_t test_vpaddlq_s16(int16x8_t a) {
5858   return vpaddlq_s16(a);
5859 }
5860
5861 // CHECK-LABEL: test_vpaddlq_s32
5862 // CHECK: vpaddl.s32 q{{[0-9]+}}, q{{[0-9]+}}
5863 int64x2_t test_vpaddlq_s32(int32x4_t a) {
5864   return vpaddlq_s32(a);
5865 }
5866
5867 // CHECK-LABEL: test_vpaddlq_u8
5868 // CHECK: vpaddl.u8 q{{[0-9]+}}, q{{[0-9]+}}
5869 uint16x8_t test_vpaddlq_u8(uint8x16_t a) {
5870   return vpaddlq_u8(a);
5871 }
5872
5873 // CHECK-LABEL: test_vpaddlq_u16
5874 // CHECK: vpaddl.u16 q{{[0-9]+}}, q{{[0-9]+}}
5875 uint32x4_t test_vpaddlq_u16(uint16x8_t a) {
5876   return vpaddlq_u16(a);
5877 }
5878
5879 // CHECK-LABEL: test_vpaddlq_u32
5880 // CHECK: vpaddl.u32 q{{[0-9]+}}, q{{[0-9]+}}
5881 uint64x2_t test_vpaddlq_u32(uint32x4_t a) {
5882   return vpaddlq_u32(a);
5883 }
5884
5885
5886 // CHECK-LABEL: test_vpmax_s8
5887 // CHECK: vpmax.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5888 int8x8_t test_vpmax_s8(int8x8_t a, int8x8_t b) {
5889   return vpmax_s8(a, b);
5890 }
5891
5892 // CHECK-LABEL: test_vpmax_s16
5893 // CHECK: vpmax.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5894 int16x4_t test_vpmax_s16(int16x4_t a, int16x4_t b) {
5895   return vpmax_s16(a, b);
5896 }
5897
5898 // CHECK-LABEL: test_vpmax_s32
5899 // CHECK: vpmax.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5900 int32x2_t test_vpmax_s32(int32x2_t a, int32x2_t b) {
5901   return vpmax_s32(a, b);
5902 }
5903
5904 // CHECK-LABEL: test_vpmax_u8
5905 // CHECK: vpmax.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5906 uint8x8_t test_vpmax_u8(uint8x8_t a, uint8x8_t b) {
5907   return vpmax_u8(a, b);
5908 }
5909
5910 // CHECK-LABEL: test_vpmax_u16
5911 // CHECK: vpmax.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5912 uint16x4_t test_vpmax_u16(uint16x4_t a, uint16x4_t b) {
5913   return vpmax_u16(a, b);
5914 }
5915
5916 // CHECK-LABEL: test_vpmax_u32
5917 // CHECK: vpmax.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5918 uint32x2_t test_vpmax_u32(uint32x2_t a, uint32x2_t b) {
5919   return vpmax_u32(a, b);
5920 }
5921
5922 // CHECK-LABEL: test_vpmax_f32
5923 // CHECK: vpmax.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5924 float32x2_t test_vpmax_f32(float32x2_t a, float32x2_t b) {
5925   return vpmax_f32(a, b);
5926 }
5927
5928
5929 // CHECK-LABEL: test_vpmin_s8
5930 // CHECK: vpmin.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5931 int8x8_t test_vpmin_s8(int8x8_t a, int8x8_t b) {
5932   return vpmin_s8(a, b);
5933 }
5934
5935 // CHECK-LABEL: test_vpmin_s16
5936 // CHECK: vpmin.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5937 int16x4_t test_vpmin_s16(int16x4_t a, int16x4_t b) {
5938   return vpmin_s16(a, b);
5939 }
5940
5941 // CHECK-LABEL: test_vpmin_s32
5942 // CHECK: vpmin.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5943 int32x2_t test_vpmin_s32(int32x2_t a, int32x2_t b) {
5944   return vpmin_s32(a, b);
5945 }
5946
5947 // CHECK-LABEL: test_vpmin_u8
5948 // CHECK: vpmin.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5949 uint8x8_t test_vpmin_u8(uint8x8_t a, uint8x8_t b) {
5950   return vpmin_u8(a, b);
5951 }
5952
5953 // CHECK-LABEL: test_vpmin_u16
5954 // CHECK: vpmin.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5955 uint16x4_t test_vpmin_u16(uint16x4_t a, uint16x4_t b) {
5956   return vpmin_u16(a, b);
5957 }
5958
5959 // CHECK-LABEL: test_vpmin_u32
5960 // CHECK: vpmin.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5961 uint32x2_t test_vpmin_u32(uint32x2_t a, uint32x2_t b) {
5962   return vpmin_u32(a, b);
5963 }
5964
5965 // CHECK-LABEL: test_vpmin_f32
5966 // CHECK: vpmin.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
5967 float32x2_t test_vpmin_f32(float32x2_t a, float32x2_t b) {
5968   return vpmin_f32(a, b);
5969 }
5970
5971
5972 // CHECK-LABEL: test_vqabs_s8
5973 // CHECK: vqabs.s8 d{{[0-9]+}}, d{{[0-9]+}}
5974 int8x8_t test_vqabs_s8(int8x8_t a) {
5975   return vqabs_s8(a);
5976 }
5977
5978 // CHECK-LABEL: test_vqabs_s16
5979 // CHECK: vqabs.s16 d{{[0-9]+}}, d{{[0-9]+}}
5980 int16x4_t test_vqabs_s16(int16x4_t a) {
5981   return vqabs_s16(a);
5982 }
5983
5984 // CHECK-LABEL: test_vqabs_s32
5985 // CHECK: vqabs.s32 d{{[0-9]+}}, d{{[0-9]+}}
5986 int32x2_t test_vqabs_s32(int32x2_t a) {
5987   return vqabs_s32(a);
5988 }
5989
5990 // CHECK-LABEL: test_vqabsq_s8
5991 // CHECK: vqabs.s8 q{{[0-9]+}}, q{{[0-9]+}}
5992 int8x16_t test_vqabsq_s8(int8x16_t a) {
5993   return vqabsq_s8(a);
5994 }
5995
5996 // CHECK-LABEL: test_vqabsq_s16
5997 // CHECK: vqabs.s16 q{{[0-9]+}}, q{{[0-9]+}}
5998 int16x8_t test_vqabsq_s16(int16x8_t a) {
5999   return vqabsq_s16(a);
6000 }
6001
6002 // CHECK-LABEL: test_vqabsq_s32
6003 // CHECK: vqabs.s32 q{{[0-9]+}}, q{{[0-9]+}}
6004 int32x4_t test_vqabsq_s32(int32x4_t a) {
6005   return vqabsq_s32(a);
6006 }
6007
6008
6009 // CHECK-LABEL: test_vqadd_s8
6010 // CHECK: vqadd.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6011 int8x8_t test_vqadd_s8(int8x8_t a, int8x8_t b) {
6012   return vqadd_s8(a, b);
6013 }
6014
6015 // CHECK-LABEL: test_vqadd_s16
6016 // CHECK: vqadd.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6017 int16x4_t test_vqadd_s16(int16x4_t a, int16x4_t b) {
6018   return vqadd_s16(a, b);
6019 }
6020
6021 // CHECK-LABEL: test_vqadd_s32
6022 // CHECK: vqadd.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6023 int32x2_t test_vqadd_s32(int32x2_t a, int32x2_t b) {
6024   return vqadd_s32(a, b);
6025 }
6026
6027 // CHECK-LABEL: test_vqadd_s64
6028 // CHECK: vqadd.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6029 int64x1_t test_vqadd_s64(int64x1_t a, int64x1_t b) {
6030   return vqadd_s64(a, b);
6031 }
6032
6033 // CHECK-LABEL: test_vqadd_u8
6034 // CHECK: vqadd.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6035 uint8x8_t test_vqadd_u8(uint8x8_t a, uint8x8_t b) {
6036   return vqadd_u8(a, b);
6037 }
6038
6039 // CHECK-LABEL: test_vqadd_u16
6040 // CHECK: vqadd.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6041 uint16x4_t test_vqadd_u16(uint16x4_t a, uint16x4_t b) {
6042   return vqadd_u16(a, b);
6043 }
6044
6045 // CHECK-LABEL: test_vqadd_u32
6046 // CHECK: vqadd.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6047 uint32x2_t test_vqadd_u32(uint32x2_t a, uint32x2_t b) {
6048   return vqadd_u32(a, b);
6049 }
6050
6051 // CHECK-LABEL: test_vqadd_u64
6052 // CHECK: vqadd.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6053 uint64x1_t test_vqadd_u64(uint64x1_t a, uint64x1_t b) {
6054   return vqadd_u64(a, b);
6055 }
6056
6057 // CHECK-LABEL: test_vqaddq_s8
6058 // CHECK: vqadd.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6059 int8x16_t test_vqaddq_s8(int8x16_t a, int8x16_t b) {
6060   return vqaddq_s8(a, b);
6061 }
6062
6063 // CHECK-LABEL: test_vqaddq_s16
6064 // CHECK: vqadd.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6065 int16x8_t test_vqaddq_s16(int16x8_t a, int16x8_t b) {
6066   return vqaddq_s16(a, b);
6067 }
6068
6069 // CHECK-LABEL: test_vqaddq_s32
6070 // CHECK: vqadd.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6071 int32x4_t test_vqaddq_s32(int32x4_t a, int32x4_t b) {
6072   return vqaddq_s32(a, b);
6073 }
6074
6075 // CHECK-LABEL: test_vqaddq_s64
6076 // CHECK: vqadd.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6077 int64x2_t test_vqaddq_s64(int64x2_t a, int64x2_t b) {
6078   return vqaddq_s64(a, b);
6079 }
6080
6081 // CHECK-LABEL: test_vqaddq_u8
6082 // CHECK: vqadd.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6083 uint8x16_t test_vqaddq_u8(uint8x16_t a, uint8x16_t b) {
6084   return vqaddq_u8(a, b);
6085 }
6086
6087 // CHECK-LABEL: test_vqaddq_u16
6088 // CHECK: vqadd.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6089 uint16x8_t test_vqaddq_u16(uint16x8_t a, uint16x8_t b) {
6090   return vqaddq_u16(a, b);
6091 }
6092
6093 // CHECK-LABEL: test_vqaddq_u32
6094 // CHECK: vqadd.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6095 uint32x4_t test_vqaddq_u32(uint32x4_t a, uint32x4_t b) {
6096   return vqaddq_u32(a, b);
6097 }
6098
6099 // CHECK-LABEL: test_vqaddq_u64
6100 // CHECK: vqadd.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6101 uint64x2_t test_vqaddq_u64(uint64x2_t a, uint64x2_t b) {
6102   return vqaddq_u64(a, b);
6103 }
6104
6105
6106 // CHECK-LABEL: test_vqdmlal_s16
6107 // CHECK: vqdmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6108 int32x4_t test_vqdmlal_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
6109   return vqdmlal_s16(a, b, c);
6110 }
6111
6112 // CHECK-LABEL: test_vqdmlal_s32
6113 // CHECK: vqdmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6114 int64x2_t test_vqdmlal_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
6115   return vqdmlal_s32(a, b, c);
6116 }
6117
6118
6119 // CHECK-LABEL: test_vqdmlal_lane_s16
6120 // CHECK: vqdmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
6121 int32x4_t test_vqdmlal_lane_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
6122   return vqdmlal_lane_s16(a, b, c, 3);
6123 }
6124
6125 // CHECK-LABEL: test_vqdmlal_lane_s32
6126 // CHECK: vqdmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
6127 int64x2_t test_vqdmlal_lane_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
6128   return vqdmlal_lane_s32(a, b, c, 1);
6129 }
6130
6131
6132 // CHECK-LABEL: test_vqdmlal_n_s16
6133 // CHECK: vqdmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6134 int32x4_t test_vqdmlal_n_s16(int32x4_t a, int16x4_t b, int16_t c) {
6135   return vqdmlal_n_s16(a, b, c);
6136 }
6137
6138 // CHECK-LABEL: test_vqdmlal_n_s32
6139 // CHECK: vqdmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6140 int64x2_t test_vqdmlal_n_s32(int64x2_t a, int32x2_t b, int32_t c) {
6141   return vqdmlal_n_s32(a, b, c);
6142 }
6143
6144
6145 // CHECK-LABEL: test_vqdmlsl_s16
6146 // CHECK: vqdmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6147 int32x4_t test_vqdmlsl_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
6148   return vqdmlsl_s16(a, b, c);
6149 }
6150
6151 // CHECK-LABEL: test_vqdmlsl_s32
6152 // CHECK: vqdmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6153 int64x2_t test_vqdmlsl_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
6154   return vqdmlsl_s32(a, b, c);
6155 }
6156
6157
6158 // CHECK-LABEL: test_vqdmlsl_lane_s16
6159 // CHECK: vqdmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
6160 int32x4_t test_vqdmlsl_lane_s16(int32x4_t a, int16x4_t b, int16x4_t c) {
6161   return vqdmlsl_lane_s16(a, b, c, 3);
6162 }
6163
6164 // CHECK-LABEL: test_vqdmlsl_lane_s32
6165 // CHECK: vqdmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
6166 int64x2_t test_vqdmlsl_lane_s32(int64x2_t a, int32x2_t b, int32x2_t c) {
6167   return vqdmlsl_lane_s32(a, b, c, 1);
6168 }
6169
6170
6171 // CHECK-LABEL: test_vqdmlsl_n_s16
6172 // CHECK: vqdmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6173 int32x4_t test_vqdmlsl_n_s16(int32x4_t a, int16x4_t b, int16_t c) {
6174   return vqdmlsl_n_s16(a, b, c);
6175 }
6176
6177 // CHECK-LABEL: test_vqdmlsl_n_s32
6178 // CHECK: vqdmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6179 int64x2_t test_vqdmlsl_n_s32(int64x2_t a, int32x2_t b, int32_t c) {
6180   return vqdmlsl_n_s32(a, b, c);
6181 }
6182
6183
6184 // CHECK-LABEL: test_vqdmulh_s16
6185 // CHECK: vqdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6186 int16x4_t test_vqdmulh_s16(int16x4_t a, int16x4_t b) {
6187   return vqdmulh_s16(a, b);
6188 }
6189
6190 // CHECK-LABEL: test_vqdmulh_s32
6191 // CHECK: vqdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6192 int32x2_t test_vqdmulh_s32(int32x2_t a, int32x2_t b) {
6193   return vqdmulh_s32(a, b);
6194 }
6195
6196 // CHECK-LABEL: test_vqdmulhq_s16
6197 // CHECK: vqdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6198 int16x8_t test_vqdmulhq_s16(int16x8_t a, int16x8_t b) {
6199   return vqdmulhq_s16(a, b);
6200 }
6201
6202 // CHECK-LABEL: test_vqdmulhq_s32
6203 // CHECK: vqdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6204 int32x4_t test_vqdmulhq_s32(int32x4_t a, int32x4_t b) {
6205   return vqdmulhq_s32(a, b);
6206 }
6207
6208
6209 // CHECK-LABEL: test_vqdmulh_lane_s16
6210 // CHECK: vqdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
6211 int16x4_t test_vqdmulh_lane_s16(int16x4_t a, int16x4_t b) {
6212   return vqdmulh_lane_s16(a, b, 3);
6213 }
6214
6215 // CHECK-LABEL: test_vqdmulh_lane_s32
6216 // CHECK: vqdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
6217 int32x2_t test_vqdmulh_lane_s32(int32x2_t a, int32x2_t b) {
6218   return vqdmulh_lane_s32(a, b, 1);
6219 }
6220
6221 // CHECK-LABEL: test_vqdmulhq_lane_s16
6222 // CHECK: vqdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
6223 int16x8_t test_vqdmulhq_lane_s16(int16x8_t a, int16x4_t b) {
6224   return vqdmulhq_lane_s16(a, b, 3);
6225 }
6226
6227 // CHECK-LABEL: test_vqdmulhq_lane_s32
6228 // CHECK: vqdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
6229 int32x4_t test_vqdmulhq_lane_s32(int32x4_t a, int32x2_t b) {
6230   return vqdmulhq_lane_s32(a, b, 1);
6231 }
6232
6233
6234 // CHECK-LABEL: test_vqdmulh_n_s16
6235 // CHECK: vqdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6236 int16x4_t test_vqdmulh_n_s16(int16x4_t a, int16_t b) {
6237   return vqdmulh_n_s16(a, b);
6238 }
6239
6240 // CHECK-LABEL: test_vqdmulh_n_s32
6241 // CHECK: vqdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6242 int32x2_t test_vqdmulh_n_s32(int32x2_t a, int32_t b) {
6243   return vqdmulh_n_s32(a, b);
6244 }
6245
6246 // CHECK-LABEL: test_vqdmulhq_n_s16
6247 // CHECK: vqdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6248 int16x8_t test_vqdmulhq_n_s16(int16x8_t a, int16_t b) {
6249   return vqdmulhq_n_s16(a, b);
6250 }
6251
6252 // CHECK-LABEL: test_vqdmulhq_n_s32
6253 // CHECK: vqdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6254 int32x4_t test_vqdmulhq_n_s32(int32x4_t a, int32_t b) {
6255   return vqdmulhq_n_s32(a, b);
6256 }
6257
6258
6259 // CHECK-LABEL: test_vqdmull_s16
6260 // CHECK: vqdmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6261 int32x4_t test_vqdmull_s16(int16x4_t a, int16x4_t b) {
6262   return vqdmull_s16(a, b);
6263 }
6264
6265 // CHECK-LABEL: test_vqdmull_s32
6266 // CHECK: vqdmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6267 int64x2_t test_vqdmull_s32(int32x2_t a, int32x2_t b) {
6268   return vqdmull_s32(a, b);
6269 }
6270
6271
6272 // CHECK-LABEL: test_vqdmull_lane_s16
6273 // CHECK: vqdmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
6274 int32x4_t test_vqdmull_lane_s16(int16x4_t a, int16x4_t b) {
6275   return vqdmull_lane_s16(a, b, 3);
6276 }
6277
6278 // CHECK-LABEL: test_vqdmull_lane_s32
6279 // CHECK: vqdmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
6280 int64x2_t test_vqdmull_lane_s32(int32x2_t a, int32x2_t b) {
6281   return vqdmull_lane_s32(a, b, 1);
6282 }
6283
6284
6285 // CHECK-LABEL: test_vqdmull_n_s16
6286 // CHECK: vqdmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6287 int32x4_t test_vqdmull_n_s16(int16x4_t a, int16_t b) {
6288   return vqdmull_n_s16(a, b);
6289 }
6290
6291 // CHECK-LABEL: test_vqdmull_n_s32
6292 // CHECK: vqdmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6293 int64x2_t test_vqdmull_n_s32(int32x2_t a, int32_t b) {
6294   return vqdmull_n_s32(a, b);
6295 }
6296
6297
6298 // CHECK-LABEL: test_vqmovn_s16
6299 // CHECK: vqmovn.s16 d{{[0-9]+}}, q{{[0-9]+}}
6300 int8x8_t test_vqmovn_s16(int16x8_t a) {
6301   return vqmovn_s16(a);
6302 }
6303
6304 // CHECK-LABEL: test_vqmovn_s32
6305 // CHECK: vqmovn.s32 d{{[0-9]+}}, q{{[0-9]+}}
6306 int16x4_t test_vqmovn_s32(int32x4_t a) {
6307   return vqmovn_s32(a);
6308 }
6309
6310 // CHECK-LABEL: test_vqmovn_s64
6311 // CHECK: vqmovn.s64 d{{[0-9]+}}, q{{[0-9]+}}
6312 int32x2_t test_vqmovn_s64(int64x2_t a) {
6313   return vqmovn_s64(a);
6314 }
6315
6316 // CHECK-LABEL: test_vqmovn_u16
6317 // CHECK: vqmovn.u16 d{{[0-9]+}}, q{{[0-9]+}}
6318 uint8x8_t test_vqmovn_u16(uint16x8_t a) {
6319   return vqmovn_u16(a);
6320 }
6321
6322 // CHECK-LABEL: test_vqmovn_u32
6323 // CHECK: vqmovn.u32 d{{[0-9]+}}, q{{[0-9]+}}
6324 uint16x4_t test_vqmovn_u32(uint32x4_t a) {
6325   return vqmovn_u32(a);
6326 }
6327
6328 // CHECK-LABEL: test_vqmovn_u64
6329 // CHECK: vqmovn.u64 d{{[0-9]+}}, q{{[0-9]+}}
6330 uint32x2_t test_vqmovn_u64(uint64x2_t a) {
6331   return vqmovn_u64(a);
6332 }
6333
6334
6335 // CHECK-LABEL: test_vqmovun_s16
6336 // CHECK: vqmovun.s16 d{{[0-9]+}}, q{{[0-9]+}}
6337 uint8x8_t test_vqmovun_s16(int16x8_t a) {
6338   return vqmovun_s16(a);
6339 }
6340
6341 // CHECK-LABEL: test_vqmovun_s32
6342 // CHECK: vqmovun.s32 d{{[0-9]+}}, q{{[0-9]+}}
6343 uint16x4_t test_vqmovun_s32(int32x4_t a) {
6344   return vqmovun_s32(a);
6345 }
6346
6347 // CHECK-LABEL: test_vqmovun_s64
6348 // CHECK: vqmovun.s64 d{{[0-9]+}}, q{{[0-9]+}}
6349 uint32x2_t test_vqmovun_s64(int64x2_t a) {
6350   return vqmovun_s64(a);
6351 }
6352
6353
6354 // CHECK-LABEL: test_vqneg_s8
6355 // CHECK: vqneg.s8 d{{[0-9]+}}, d{{[0-9]+}}
6356 int8x8_t test_vqneg_s8(int8x8_t a) {
6357   return vqneg_s8(a);
6358 }
6359
6360 // CHECK-LABEL: test_vqneg_s16
6361 // CHECK: vqneg.s16 d{{[0-9]+}}, d{{[0-9]+}}
6362 int16x4_t test_vqneg_s16(int16x4_t a) {
6363   return vqneg_s16(a);
6364 }
6365
6366 // CHECK-LABEL: test_vqneg_s32
6367 // CHECK: vqneg.s32 d{{[0-9]+}}, d{{[0-9]+}}
6368 int32x2_t test_vqneg_s32(int32x2_t a) {
6369   return vqneg_s32(a);
6370 }
6371
6372 // CHECK-LABEL: test_vqnegq_s8
6373 // CHECK: vqneg.s8 q{{[0-9]+}}, q{{[0-9]+}}
6374 int8x16_t test_vqnegq_s8(int8x16_t a) {
6375   return vqnegq_s8(a);
6376 }
6377
6378 // CHECK-LABEL: test_vqnegq_s16
6379 // CHECK: vqneg.s16 q{{[0-9]+}}, q{{[0-9]+}}
6380 int16x8_t test_vqnegq_s16(int16x8_t a) {
6381   return vqnegq_s16(a);
6382 }
6383
6384 // CHECK-LABEL: test_vqnegq_s32
6385 // CHECK: vqneg.s32 q{{[0-9]+}}, q{{[0-9]+}}
6386 int32x4_t test_vqnegq_s32(int32x4_t a) {
6387   return vqnegq_s32(a);
6388 }
6389
6390
6391 // CHECK-LABEL: test_vqrdmulh_s16
6392 // CHECK: vqrdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6393 int16x4_t test_vqrdmulh_s16(int16x4_t a, int16x4_t b) {
6394   return vqrdmulh_s16(a, b);
6395 }
6396
6397 // CHECK-LABEL: test_vqrdmulh_s32
6398 // CHECK: vqrdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6399 int32x2_t test_vqrdmulh_s32(int32x2_t a, int32x2_t b) {
6400   return vqrdmulh_s32(a, b);
6401 }
6402
6403 // CHECK-LABEL: test_vqrdmulhq_s16
6404 // CHECK: vqrdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6405 int16x8_t test_vqrdmulhq_s16(int16x8_t a, int16x8_t b) {
6406   return vqrdmulhq_s16(a, b);
6407 }
6408
6409 // CHECK-LABEL: test_vqrdmulhq_s32
6410 // CHECK: vqrdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6411 int32x4_t test_vqrdmulhq_s32(int32x4_t a, int32x4_t b) {
6412   return vqrdmulhq_s32(a, b);
6413 }
6414
6415
6416 // CHECK-LABEL: test_vqrdmulh_lane_s16
6417 // CHECK: vqrdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
6418 int16x4_t test_vqrdmulh_lane_s16(int16x4_t a, int16x4_t b) {
6419   return vqrdmulh_lane_s16(a, b, 3);
6420 }
6421
6422 // CHECK-LABEL: test_vqrdmulh_lane_s32
6423 // CHECK: vqrdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
6424 int32x2_t test_vqrdmulh_lane_s32(int32x2_t a, int32x2_t b) {
6425   return vqrdmulh_lane_s32(a, b, 1);
6426 }
6427
6428 // CHECK-LABEL: test_vqrdmulhq_lane_s16
6429 // CHECK: vqrdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
6430 int16x8_t test_vqrdmulhq_lane_s16(int16x8_t a, int16x4_t b) {
6431   return vqrdmulhq_lane_s16(a, b, 3);
6432 }
6433
6434 // CHECK-LABEL: test_vqrdmulhq_lane_s32
6435 // CHECK: vqrdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}]
6436 int32x4_t test_vqrdmulhq_lane_s32(int32x4_t a, int32x2_t b) {
6437   return vqrdmulhq_lane_s32(a, b, 1);
6438 }
6439
6440
6441 // CHECK-LABEL: test_vqrdmulh_n_s16
6442 // CHECK: vqrdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6443 int16x4_t test_vqrdmulh_n_s16(int16x4_t a, int16_t b) {
6444   return vqrdmulh_n_s16(a, b);
6445 }
6446
6447 // CHECK-LABEL: test_vqrdmulh_n_s32
6448 // CHECK: vqrdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6449 int32x2_t test_vqrdmulh_n_s32(int32x2_t a, int32_t b) {
6450   return vqrdmulh_n_s32(a, b);
6451 }
6452
6453 // CHECK-LABEL: test_vqrdmulhq_n_s16
6454 // CHECK: vqrdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6455 int16x8_t test_vqrdmulhq_n_s16(int16x8_t a, int16_t b) {
6456   return vqrdmulhq_n_s16(a, b);
6457 }
6458
6459 // CHECK-LABEL: test_vqrdmulhq_n_s32
6460 // CHECK: vqrdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6461 int32x4_t test_vqrdmulhq_n_s32(int32x4_t a, int32_t b) {
6462   return vqrdmulhq_n_s32(a, b);
6463 }
6464
6465
6466 // CHECK-LABEL: test_vqrshl_s8
6467 // CHECK: vqrshl.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6468 int8x8_t test_vqrshl_s8(int8x8_t a, int8x8_t b) {
6469   return vqrshl_s8(a, b);
6470 }
6471
6472 // CHECK-LABEL: test_vqrshl_s16
6473 // CHECK: vqrshl.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6474 int16x4_t test_vqrshl_s16(int16x4_t a, int16x4_t b) {
6475   return vqrshl_s16(a, b);
6476 }
6477
6478 // CHECK-LABEL: test_vqrshl_s32
6479 // CHECK: vqrshl.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6480 int32x2_t test_vqrshl_s32(int32x2_t a, int32x2_t b) {
6481   return vqrshl_s32(a, b);
6482 }
6483
6484 // CHECK-LABEL: test_vqrshl_s64
6485 // CHECK: vqrshl.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6486 int64x1_t test_vqrshl_s64(int64x1_t a, int64x1_t b) {
6487   return vqrshl_s64(a, b);
6488 }
6489
6490 // CHECK-LABEL: test_vqrshl_u8
6491 // CHECK: vqrshl.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6492 uint8x8_t test_vqrshl_u8(uint8x8_t a, int8x8_t b) {
6493   return vqrshl_u8(a, b);
6494 }
6495
6496 // CHECK-LABEL: test_vqrshl_u16
6497 // CHECK: vqrshl.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6498 uint16x4_t test_vqrshl_u16(uint16x4_t a, int16x4_t b) {
6499   return vqrshl_u16(a, b);
6500 }
6501
6502 // CHECK-LABEL: test_vqrshl_u32
6503 // CHECK: vqrshl.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6504 uint32x2_t test_vqrshl_u32(uint32x2_t a, int32x2_t b) {
6505   return vqrshl_u32(a, b);
6506 }
6507
6508 // CHECK-LABEL: test_vqrshl_u64
6509 // CHECK: vqrshl.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6510 uint64x1_t test_vqrshl_u64(uint64x1_t a, int64x1_t b) {
6511   return vqrshl_u64(a, b);
6512 }
6513
6514 // CHECK-LABEL: test_vqrshlq_s8
6515 // CHECK: vqrshl.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6516 int8x16_t test_vqrshlq_s8(int8x16_t a, int8x16_t b) {
6517   return vqrshlq_s8(a, b);
6518 }
6519
6520 // CHECK-LABEL: test_vqrshlq_s16
6521 // CHECK: vqrshl.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6522 int16x8_t test_vqrshlq_s16(int16x8_t a, int16x8_t b) {
6523   return vqrshlq_s16(a, b);
6524 }
6525
6526 // CHECK-LABEL: test_vqrshlq_s32
6527 // CHECK: vqrshl.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6528 int32x4_t test_vqrshlq_s32(int32x4_t a, int32x4_t b) {
6529   return vqrshlq_s32(a, b);
6530 }
6531
6532 // CHECK-LABEL: test_vqrshlq_s64
6533 // CHECK: vqrshl.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6534 int64x2_t test_vqrshlq_s64(int64x2_t a, int64x2_t b) {
6535   return vqrshlq_s64(a, b);
6536 }
6537
6538 // CHECK-LABEL: test_vqrshlq_u8
6539 // CHECK: vqrshl.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6540 uint8x16_t test_vqrshlq_u8(uint8x16_t a, int8x16_t b) {
6541   return vqrshlq_u8(a, b);
6542 }
6543
6544 // CHECK-LABEL: test_vqrshlq_u16
6545 // CHECK: vqrshl.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6546 uint16x8_t test_vqrshlq_u16(uint16x8_t a, int16x8_t b) {
6547   return vqrshlq_u16(a, b);
6548 }
6549
6550 // CHECK-LABEL: test_vqrshlq_u32
6551 // CHECK: vqrshl.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6552 uint32x4_t test_vqrshlq_u32(uint32x4_t a, int32x4_t b) {
6553   return vqrshlq_u32(a, b);
6554 }
6555
6556 // CHECK-LABEL: test_vqrshlq_u64
6557 // CHECK: vqrshl.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6558 uint64x2_t test_vqrshlq_u64(uint64x2_t a, int64x2_t b) {
6559   return vqrshlq_u64(a, b);
6560 }
6561
6562
6563 // CHECK-LABEL: test_vqrshrn_n_s16
6564 // CHECK: vqrshrn.s16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6565 int8x8_t test_vqrshrn_n_s16(int16x8_t a) {
6566   return vqrshrn_n_s16(a, 1);
6567 }
6568
6569 // CHECK-LABEL: test_vqrshrn_n_s32
6570 // CHECK: vqrshrn.s32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6571 int16x4_t test_vqrshrn_n_s32(int32x4_t a) {
6572   return vqrshrn_n_s32(a, 1);
6573 }
6574
6575 // CHECK-LABEL: test_vqrshrn_n_s64
6576 // CHECK: vqrshrn.s64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6577 int32x2_t test_vqrshrn_n_s64(int64x2_t a) {
6578   return vqrshrn_n_s64(a, 1);
6579 }
6580
6581 // CHECK-LABEL: test_vqrshrn_n_u16
6582 // CHECK: vqrshrn.u16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6583 uint8x8_t test_vqrshrn_n_u16(uint16x8_t a) {
6584   return vqrshrn_n_u16(a, 1);
6585 }
6586
6587 // CHECK-LABEL: test_vqrshrn_n_u32
6588 // CHECK: vqrshrn.u32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6589 uint16x4_t test_vqrshrn_n_u32(uint32x4_t a) {
6590   return vqrshrn_n_u32(a, 1);
6591 }
6592
6593 // CHECK-LABEL: test_vqrshrn_n_u64
6594 // CHECK: vqrshrn.u64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6595 uint32x2_t test_vqrshrn_n_u64(uint64x2_t a) {
6596   return vqrshrn_n_u64(a, 1);
6597 }
6598
6599
6600 // CHECK-LABEL: test_vqrshrun_n_s16
6601 // CHECK: vqrshrun.s16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6602 uint8x8_t test_vqrshrun_n_s16(int16x8_t a) {
6603   return vqrshrun_n_s16(a, 1);
6604 }
6605
6606 // CHECK-LABEL: test_vqrshrun_n_s32
6607 // CHECK: vqrshrun.s32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6608 uint16x4_t test_vqrshrun_n_s32(int32x4_t a) {
6609   return vqrshrun_n_s32(a, 1);
6610 }
6611
6612 // CHECK-LABEL: test_vqrshrun_n_s64
6613 // CHECK: vqrshrun.s64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6614 uint32x2_t test_vqrshrun_n_s64(int64x2_t a) {
6615   return vqrshrun_n_s64(a, 1);
6616 }
6617
6618
6619 // CHECK-LABEL: test_vqshl_s8
6620 // CHECK: vqshl.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6621 int8x8_t test_vqshl_s8(int8x8_t a, int8x8_t b) {
6622   return vqshl_s8(a, b);
6623 }
6624
6625 // CHECK-LABEL: test_vqshl_s16
6626 // CHECK: vqshl.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6627 int16x4_t test_vqshl_s16(int16x4_t a, int16x4_t b) {
6628   return vqshl_s16(a, b);
6629 }
6630
6631 // CHECK-LABEL: test_vqshl_s32
6632 // CHECK: vqshl.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6633 int32x2_t test_vqshl_s32(int32x2_t a, int32x2_t b) {
6634   return vqshl_s32(a, b);
6635 }
6636
6637 // CHECK-LABEL: test_vqshl_s64
6638 // CHECK: vqshl.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6639 int64x1_t test_vqshl_s64(int64x1_t a, int64x1_t b) {
6640   return vqshl_s64(a, b);
6641 }
6642
6643 // CHECK-LABEL: test_vqshl_u8
6644 // CHECK: vqshl.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6645 uint8x8_t test_vqshl_u8(uint8x8_t a, int8x8_t b) {
6646   return vqshl_u8(a, b);
6647 }
6648
6649 // CHECK-LABEL: test_vqshl_u16
6650 // CHECK: vqshl.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6651 uint16x4_t test_vqshl_u16(uint16x4_t a, int16x4_t b) {
6652   return vqshl_u16(a, b);
6653 }
6654
6655 // CHECK-LABEL: test_vqshl_u32
6656 // CHECK: vqshl.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6657 uint32x2_t test_vqshl_u32(uint32x2_t a, int32x2_t b) {
6658   return vqshl_u32(a, b);
6659 }
6660
6661 // CHECK-LABEL: test_vqshl_u64
6662 // CHECK: vqshl.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6663 uint64x1_t test_vqshl_u64(uint64x1_t a, int64x1_t b) {
6664   return vqshl_u64(a, b);
6665 }
6666
6667 // CHECK-LABEL: test_vqshlq_s8
6668 // CHECK: vqshl.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6669 int8x16_t test_vqshlq_s8(int8x16_t a, int8x16_t b) {
6670   return vqshlq_s8(a, b);
6671 }
6672
6673 // CHECK-LABEL: test_vqshlq_s16
6674 // CHECK: vqshl.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6675 int16x8_t test_vqshlq_s16(int16x8_t a, int16x8_t b) {
6676   return vqshlq_s16(a, b);
6677 }
6678
6679 // CHECK-LABEL: test_vqshlq_s32
6680 // CHECK: vqshl.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6681 int32x4_t test_vqshlq_s32(int32x4_t a, int32x4_t b) {
6682   return vqshlq_s32(a, b);
6683 }
6684
6685 // CHECK-LABEL: test_vqshlq_s64
6686 // CHECK: vqshl.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6687 int64x2_t test_vqshlq_s64(int64x2_t a, int64x2_t b) {
6688   return vqshlq_s64(a, b);
6689 }
6690
6691 // CHECK-LABEL: test_vqshlq_u8
6692 // CHECK: vqshl.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6693 uint8x16_t test_vqshlq_u8(uint8x16_t a, int8x16_t b) {
6694   return vqshlq_u8(a, b);
6695 }
6696
6697 // CHECK-LABEL: test_vqshlq_u16
6698 // CHECK: vqshl.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6699 uint16x8_t test_vqshlq_u16(uint16x8_t a, int16x8_t b) {
6700   return vqshlq_u16(a, b);
6701 }
6702
6703 // CHECK-LABEL: test_vqshlq_u32
6704 // CHECK: vqshl.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6705 uint32x4_t test_vqshlq_u32(uint32x4_t a, int32x4_t b) {
6706   return vqshlq_u32(a, b);
6707 }
6708
6709 // CHECK-LABEL: test_vqshlq_u64
6710 // CHECK: vqshl.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6711 uint64x2_t test_vqshlq_u64(uint64x2_t a, int64x2_t b) {
6712   return vqshlq_u64(a, b);
6713 }
6714
6715
6716 // CHECK-LABEL: test_vqshlu_n_s8
6717 // CHECK: vqshlu.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
6718 uint8x8_t test_vqshlu_n_s8(int8x8_t a) {
6719   return vqshlu_n_s8(a, 1);
6720 }
6721
6722 // CHECK-LABEL: test_vqshlu_n_s16
6723 // CHECK: vqshlu.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
6724 uint16x4_t test_vqshlu_n_s16(int16x4_t a) {
6725   return vqshlu_n_s16(a, 1);
6726 }
6727
6728 // CHECK-LABEL: test_vqshlu_n_s32
6729 // CHECK: vqshlu.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
6730 uint32x2_t test_vqshlu_n_s32(int32x2_t a) {
6731   return vqshlu_n_s32(a, 1);
6732 }
6733
6734 // CHECK-LABEL: test_vqshlu_n_s64
6735 // CHECK: vqshlu.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
6736 uint64x1_t test_vqshlu_n_s64(int64x1_t a) {
6737   return vqshlu_n_s64(a, 1);
6738 }
6739
6740 // CHECK-LABEL: test_vqshluq_n_s8
6741 // CHECK: vqshlu.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6742 uint8x16_t test_vqshluq_n_s8(int8x16_t a) {
6743   return vqshluq_n_s8(a, 1);
6744 }
6745
6746 // CHECK-LABEL: test_vqshluq_n_s16
6747 // CHECK: vqshlu.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6748 uint16x8_t test_vqshluq_n_s16(int16x8_t a) {
6749   return vqshluq_n_s16(a, 1);
6750 }
6751
6752 // CHECK-LABEL: test_vqshluq_n_s32
6753 // CHECK: vqshlu.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6754 uint32x4_t test_vqshluq_n_s32(int32x4_t a) {
6755   return vqshluq_n_s32(a, 1);
6756 }
6757
6758 // CHECK-LABEL: test_vqshluq_n_s64
6759 // CHECK: vqshlu.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6760 uint64x2_t test_vqshluq_n_s64(int64x2_t a) {
6761   return vqshluq_n_s64(a, 1);
6762 }
6763
6764
6765 // CHECK-LABEL: test_vqshl_n_s8
6766 // CHECK: vqshl.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
6767 int8x8_t test_vqshl_n_s8(int8x8_t a) {
6768   return vqshl_n_s8(a, 1);
6769 }
6770
6771 // CHECK-LABEL: test_vqshl_n_s16
6772 // CHECK: vqshl.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
6773 int16x4_t test_vqshl_n_s16(int16x4_t a) {
6774   return vqshl_n_s16(a, 1);
6775 }
6776
6777 // CHECK-LABEL: test_vqshl_n_s32
6778 // CHECK: vqshl.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
6779 int32x2_t test_vqshl_n_s32(int32x2_t a) {
6780   return vqshl_n_s32(a, 1);
6781 }
6782
6783 // CHECK-LABEL: test_vqshl_n_s64
6784 // CHECK: vqshl.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
6785 int64x1_t test_vqshl_n_s64(int64x1_t a) {
6786   return vqshl_n_s64(a, 1);
6787 }
6788
6789 // CHECK-LABEL: test_vqshl_n_u8
6790 // CHECK: vqshl.u8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
6791 uint8x8_t test_vqshl_n_u8(uint8x8_t a) {
6792   return vqshl_n_u8(a, 1);
6793 }
6794
6795 // CHECK-LABEL: test_vqshl_n_u16
6796 // CHECK: vqshl.u16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
6797 uint16x4_t test_vqshl_n_u16(uint16x4_t a) {
6798   return vqshl_n_u16(a, 1);
6799 }
6800
6801 // CHECK-LABEL: test_vqshl_n_u32
6802 // CHECK: vqshl.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
6803 uint32x2_t test_vqshl_n_u32(uint32x2_t a) {
6804   return vqshl_n_u32(a, 1);
6805 }
6806
6807 // CHECK-LABEL: test_vqshl_n_u64
6808 // CHECK: vqshl.u64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
6809 uint64x1_t test_vqshl_n_u64(uint64x1_t a) {
6810   return vqshl_n_u64(a, 1);
6811 }
6812
6813 // CHECK-LABEL: test_vqshlq_n_s8
6814 // CHECK: vqshl.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6815 int8x16_t test_vqshlq_n_s8(int8x16_t a) {
6816   return vqshlq_n_s8(a, 1);
6817 }
6818
6819 // CHECK-LABEL: test_vqshlq_n_s16
6820 // CHECK: vqshl.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6821 int16x8_t test_vqshlq_n_s16(int16x8_t a) {
6822   return vqshlq_n_s16(a, 1);
6823 }
6824
6825 // CHECK-LABEL: test_vqshlq_n_s32
6826 // CHECK: vqshl.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6827 int32x4_t test_vqshlq_n_s32(int32x4_t a) {
6828   return vqshlq_n_s32(a, 1);
6829 }
6830
6831 // CHECK-LABEL: test_vqshlq_n_s64
6832 // CHECK: vqshl.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6833 int64x2_t test_vqshlq_n_s64(int64x2_t a) {
6834   return vqshlq_n_s64(a, 1);
6835 }
6836
6837 // CHECK-LABEL: test_vqshlq_n_u8
6838 // CHECK: vqshl.u8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6839 uint8x16_t test_vqshlq_n_u8(uint8x16_t a) {
6840   return vqshlq_n_u8(a, 1);
6841 }
6842
6843 // CHECK-LABEL: test_vqshlq_n_u16
6844 // CHECK: vqshl.u16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6845 uint16x8_t test_vqshlq_n_u16(uint16x8_t a) {
6846   return vqshlq_n_u16(a, 1);
6847 }
6848
6849 // CHECK-LABEL: test_vqshlq_n_u32
6850 // CHECK: vqshl.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6851 uint32x4_t test_vqshlq_n_u32(uint32x4_t a) {
6852   return vqshlq_n_u32(a, 1);
6853 }
6854
6855 // CHECK-LABEL: test_vqshlq_n_u64
6856 // CHECK: vqshl.u64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6857 uint64x2_t test_vqshlq_n_u64(uint64x2_t a) {
6858   return vqshlq_n_u64(a, 1);
6859 }
6860
6861
6862 // CHECK-LABEL: test_vqshrn_n_s16
6863 // CHECK: vqshrn.s16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6864 int8x8_t test_vqshrn_n_s16(int16x8_t a) {
6865   return vqshrn_n_s16(a, 1);
6866 }
6867
6868 // CHECK-LABEL: test_vqshrn_n_s32
6869 // CHECK: vqshrn.s32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6870 int16x4_t test_vqshrn_n_s32(int32x4_t a) {
6871   return vqshrn_n_s32(a, 1);
6872 }
6873
6874 // CHECK-LABEL: test_vqshrn_n_s64
6875 // CHECK: vqshrn.s64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6876 int32x2_t test_vqshrn_n_s64(int64x2_t a) {
6877   return vqshrn_n_s64(a, 1);
6878 }
6879
6880 // CHECK-LABEL: test_vqshrn_n_u16
6881 // CHECK: vqshrn.u16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6882 uint8x8_t test_vqshrn_n_u16(uint16x8_t a) {
6883   return vqshrn_n_u16(a, 1);
6884 }
6885
6886 // CHECK-LABEL: test_vqshrn_n_u32
6887 // CHECK: vqshrn.u32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6888 uint16x4_t test_vqshrn_n_u32(uint32x4_t a) {
6889   return vqshrn_n_u32(a, 1);
6890 }
6891
6892 // CHECK-LABEL: test_vqshrn_n_u64
6893 // CHECK: vqshrn.u64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6894 uint32x2_t test_vqshrn_n_u64(uint64x2_t a) {
6895   return vqshrn_n_u64(a, 1);
6896 }
6897
6898
6899 // CHECK-LABEL: test_vqshrun_n_s16
6900 // CHECK: vqshrun.s16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6901 uint8x8_t test_vqshrun_n_s16(int16x8_t a) {
6902   return vqshrun_n_s16(a, 1);
6903 }
6904
6905 // CHECK-LABEL: test_vqshrun_n_s32
6906 // CHECK: vqshrun.s32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6907 uint16x4_t test_vqshrun_n_s32(int32x4_t a) {
6908   return vqshrun_n_s32(a, 1);
6909 }
6910
6911 // CHECK-LABEL: test_vqshrun_n_s64
6912 // CHECK: vqshrun.s64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
6913 uint32x2_t test_vqshrun_n_s64(int64x2_t a) {
6914   return vqshrun_n_s64(a, 1);
6915 }
6916
6917
6918 // CHECK-LABEL: test_vqsub_s8
6919 // CHECK: vqsub.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6920 int8x8_t test_vqsub_s8(int8x8_t a, int8x8_t b) {
6921   return vqsub_s8(a, b);
6922 }
6923
6924 // CHECK-LABEL: test_vqsub_s16
6925 // CHECK: vqsub.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6926 int16x4_t test_vqsub_s16(int16x4_t a, int16x4_t b) {
6927   return vqsub_s16(a, b);
6928 }
6929
6930 // CHECK-LABEL: test_vqsub_s32
6931 // CHECK: vqsub.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6932 int32x2_t test_vqsub_s32(int32x2_t a, int32x2_t b) {
6933   return vqsub_s32(a, b);
6934 }
6935
6936 // CHECK-LABEL: test_vqsub_s64
6937 // CHECK: vqsub.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6938 int64x1_t test_vqsub_s64(int64x1_t a, int64x1_t b) {
6939   return vqsub_s64(a, b);
6940 }
6941
6942 // CHECK-LABEL: test_vqsub_u8
6943 // CHECK: vqsub.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6944 uint8x8_t test_vqsub_u8(uint8x8_t a, uint8x8_t b) {
6945   return vqsub_u8(a, b);
6946 }
6947
6948 // CHECK-LABEL: test_vqsub_u16
6949 // CHECK: vqsub.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6950 uint16x4_t test_vqsub_u16(uint16x4_t a, uint16x4_t b) {
6951   return vqsub_u16(a, b);
6952 }
6953
6954 // CHECK-LABEL: test_vqsub_u32
6955 // CHECK: vqsub.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6956 uint32x2_t test_vqsub_u32(uint32x2_t a, uint32x2_t b) {
6957   return vqsub_u32(a, b);
6958 }
6959
6960 // CHECK-LABEL: test_vqsub_u64
6961 // CHECK: vqsub.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
6962 uint64x1_t test_vqsub_u64(uint64x1_t a, uint64x1_t b) {
6963   return vqsub_u64(a, b);
6964 }
6965
6966 // CHECK-LABEL: test_vqsubq_s8
6967 // CHECK: vqsub.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6968 int8x16_t test_vqsubq_s8(int8x16_t a, int8x16_t b) {
6969   return vqsubq_s8(a, b);
6970 }
6971
6972 // CHECK-LABEL: test_vqsubq_s16
6973 // CHECK: vqsub.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6974 int16x8_t test_vqsubq_s16(int16x8_t a, int16x8_t b) {
6975   return vqsubq_s16(a, b);
6976 }
6977
6978 // CHECK-LABEL: test_vqsubq_s32
6979 // CHECK: vqsub.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6980 int32x4_t test_vqsubq_s32(int32x4_t a, int32x4_t b) {
6981   return vqsubq_s32(a, b);
6982 }
6983
6984 // CHECK-LABEL: test_vqsubq_s64
6985 // CHECK: vqsub.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6986 int64x2_t test_vqsubq_s64(int64x2_t a, int64x2_t b) {
6987   return vqsubq_s64(a, b);
6988 }
6989
6990 // CHECK-LABEL: test_vqsubq_u8
6991 // CHECK: vqsub.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6992 uint8x16_t test_vqsubq_u8(uint8x16_t a, uint8x16_t b) {
6993   return vqsubq_u8(a, b);
6994 }
6995
6996 // CHECK-LABEL: test_vqsubq_u16
6997 // CHECK: vqsub.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
6998 uint16x8_t test_vqsubq_u16(uint16x8_t a, uint16x8_t b) {
6999   return vqsubq_u16(a, b);
7000 }
7001
7002 // CHECK-LABEL: test_vqsubq_u32
7003 // CHECK: vqsub.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
7004 uint32x4_t test_vqsubq_u32(uint32x4_t a, uint32x4_t b) {
7005   return vqsubq_u32(a, b);
7006 }
7007
7008 // CHECK-LABEL: test_vqsubq_u64
7009 // CHECK: vqsub.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
7010 uint64x2_t test_vqsubq_u64(uint64x2_t a, uint64x2_t b) {
7011   return vqsubq_u64(a, b);
7012 }
7013
7014
7015 // CHECK-LABEL: test_vraddhn_s16
7016 // CHECK: vraddhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
7017 int8x8_t test_vraddhn_s16(int16x8_t a, int16x8_t b) {
7018   return vraddhn_s16(a, b);
7019 }
7020
7021 // CHECK-LABEL: test_vraddhn_s32
7022 // CHECK: vraddhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
7023 int16x4_t test_vraddhn_s32(int32x4_t a, int32x4_t b) {
7024   return vraddhn_s32(a, b);
7025 }
7026
7027 // CHECK-LABEL: test_vraddhn_s64
7028 // CHECK: vraddhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
7029 int32x2_t test_vraddhn_s64(int64x2_t a, int64x2_t b) {
7030   return vraddhn_s64(a, b);
7031 }
7032
7033 // CHECK-LABEL: test_vraddhn_u16
7034 // CHECK: vraddhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
7035 uint8x8_t test_vraddhn_u16(uint16x8_t a, uint16x8_t b) {
7036   return vraddhn_u16(a, b);
7037 }
7038
7039 // CHECK-LABEL: test_vraddhn_u32
7040 // CHECK: vraddhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
7041 uint16x4_t test_vraddhn_u32(uint32x4_t a, uint32x4_t b) {
7042   return vraddhn_u32(a, b);
7043 }
7044
7045 // CHECK-LABEL: test_vraddhn_u64
7046 // CHECK: vraddhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
7047 uint32x2_t test_vraddhn_u64(uint64x2_t a, uint64x2_t b) {
7048   return vraddhn_u64(a, b);
7049 }
7050
7051
7052 // CHECK-LABEL: test_vrecpe_f32
7053 // CHECK: vrecpe.f32 d{{[0-9]+}}, d{{[0-9]+}}
7054 float32x2_t test_vrecpe_f32(float32x2_t a) {
7055   return vrecpe_f32(a);
7056 }
7057
7058 // CHECK-LABEL: test_vrecpe_u32
7059 // CHECK: vrecpe.u32 d{{[0-9]+}}, d{{[0-9]+}}
7060 uint32x2_t test_vrecpe_u32(uint32x2_t a) {
7061   return vrecpe_u32(a);
7062 }
7063
7064 // CHECK-LABEL: test_vrecpeq_f32
7065 // CHECK: vrecpe.f32 q{{[0-9]+}}, q{{[0-9]+}}
7066 float32x4_t test_vrecpeq_f32(float32x4_t a) {
7067   return vrecpeq_f32(a);
7068 }
7069
7070 // CHECK-LABEL: test_vrecpeq_u32
7071 // CHECK: vrecpe.u32 q{{[0-9]+}}, q{{[0-9]+}}
7072 uint32x4_t test_vrecpeq_u32(uint32x4_t a) {
7073   return vrecpeq_u32(a);
7074 }
7075
7076
7077 // CHECK-LABEL: test_vrecps_f32
7078 // CHECK: vrecps.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
7079 float32x2_t test_vrecps_f32(float32x2_t a, float32x2_t b) {
7080   return vrecps_f32(a, b);
7081 }
7082
7083 // CHECK-LABEL: test_vrecpsq_f32
7084 // CHECK: vrecps.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
7085 float32x4_t test_vrecpsq_f32(float32x4_t a, float32x4_t b) {
7086   return vrecpsq_f32(a, b);
7087 }
7088
7089
7090 // CHECK-LABEL: test_vreinterpret_s8_s16
7091 int8x8_t test_vreinterpret_s8_s16(int16x4_t a) {
7092   return vreinterpret_s8_s16(a);
7093 }
7094
7095 // CHECK-LABEL: test_vreinterpret_s8_s32
7096 int8x8_t test_vreinterpret_s8_s32(int32x2_t a) {
7097   return vreinterpret_s8_s32(a);
7098 }
7099
7100 // CHECK-LABEL: test_vreinterpret_s8_s64
7101 int8x8_t test_vreinterpret_s8_s64(int64x1_t a) {
7102   return vreinterpret_s8_s64(a);
7103 }
7104
7105 // CHECK-LABEL: test_vreinterpret_s8_u8
7106 int8x8_t test_vreinterpret_s8_u8(uint8x8_t a) {
7107   return vreinterpret_s8_u8(a);
7108 }
7109
7110 // CHECK-LABEL: test_vreinterpret_s8_u16
7111 int8x8_t test_vreinterpret_s8_u16(uint16x4_t a) {
7112   return vreinterpret_s8_u16(a);
7113 }
7114
7115 // CHECK-LABEL: test_vreinterpret_s8_u32
7116 int8x8_t test_vreinterpret_s8_u32(uint32x2_t a) {
7117   return vreinterpret_s8_u32(a);
7118 }
7119
7120 // CHECK-LABEL: test_vreinterpret_s8_u64
7121 int8x8_t test_vreinterpret_s8_u64(uint64x1_t a) {
7122   return vreinterpret_s8_u64(a);
7123 }
7124
7125 // CHECK-LABEL: test_vreinterpret_s8_f16
7126 int8x8_t test_vreinterpret_s8_f16(float16x4_t a) {
7127   return vreinterpret_s8_f16(a);
7128 }
7129
7130 // CHECK-LABEL: test_vreinterpret_s8_f32
7131 int8x8_t test_vreinterpret_s8_f32(float32x2_t a) {
7132   return vreinterpret_s8_f32(a);
7133 }
7134
7135 // CHECK-LABEL: test_vreinterpret_s8_p8
7136 int8x8_t test_vreinterpret_s8_p8(poly8x8_t a) {
7137   return vreinterpret_s8_p8(a);
7138 }
7139
7140 // CHECK-LABEL: test_vreinterpret_s8_p16
7141 int8x8_t test_vreinterpret_s8_p16(poly16x4_t a) {
7142   return vreinterpret_s8_p16(a);
7143 }
7144
7145 // CHECK-LABEL: test_vreinterpret_s16_s8
7146 int16x4_t test_vreinterpret_s16_s8(int8x8_t a) {
7147   return vreinterpret_s16_s8(a);
7148 }
7149
7150 // CHECK-LABEL: test_vreinterpret_s16_s32
7151 int16x4_t test_vreinterpret_s16_s32(int32x2_t a) {
7152   return vreinterpret_s16_s32(a);
7153 }
7154
7155 // CHECK-LABEL: test_vreinterpret_s16_s64
7156 int16x4_t test_vreinterpret_s16_s64(int64x1_t a) {
7157   return vreinterpret_s16_s64(a);
7158 }
7159
7160 // CHECK-LABEL: test_vreinterpret_s16_u8
7161 int16x4_t test_vreinterpret_s16_u8(uint8x8_t a) {
7162   return vreinterpret_s16_u8(a);
7163 }
7164
7165 // CHECK-LABEL: test_vreinterpret_s16_u16
7166 int16x4_t test_vreinterpret_s16_u16(uint16x4_t a) {
7167   return vreinterpret_s16_u16(a);
7168 }
7169
7170 // CHECK-LABEL: test_vreinterpret_s16_u32
7171 int16x4_t test_vreinterpret_s16_u32(uint32x2_t a) {
7172   return vreinterpret_s16_u32(a);
7173 }
7174
7175 // CHECK-LABEL: test_vreinterpret_s16_u64
7176 int16x4_t test_vreinterpret_s16_u64(uint64x1_t a) {
7177   return vreinterpret_s16_u64(a);
7178 }
7179
7180 // CHECK-LABEL: test_vreinterpret_s16_f16
7181 int16x4_t test_vreinterpret_s16_f16(float16x4_t a) {
7182   return vreinterpret_s16_f16(a);
7183 }
7184
7185 // CHECK-LABEL: test_vreinterpret_s16_f32
7186 int16x4_t test_vreinterpret_s16_f32(float32x2_t a) {
7187   return vreinterpret_s16_f32(a);
7188 }
7189
7190 // CHECK-LABEL: test_vreinterpret_s16_p8
7191 int16x4_t test_vreinterpret_s16_p8(poly8x8_t a) {
7192   return vreinterpret_s16_p8(a);
7193 }
7194
7195 // CHECK-LABEL: test_vreinterpret_s16_p16
7196 int16x4_t test_vreinterpret_s16_p16(poly16x4_t a) {
7197   return vreinterpret_s16_p16(a);
7198 }
7199
7200 // CHECK-LABEL: test_vreinterpret_s32_s8
7201 int32x2_t test_vreinterpret_s32_s8(int8x8_t a) {
7202   return vreinterpret_s32_s8(a);
7203 }
7204
7205 // CHECK-LABEL: test_vreinterpret_s32_s16
7206 int32x2_t test_vreinterpret_s32_s16(int16x4_t a) {
7207   return vreinterpret_s32_s16(a);
7208 }
7209
7210 // CHECK-LABEL: test_vreinterpret_s32_s64
7211 int32x2_t test_vreinterpret_s32_s64(int64x1_t a) {
7212   return vreinterpret_s32_s64(a);
7213 }
7214
7215 // CHECK-LABEL: test_vreinterpret_s32_u8
7216 int32x2_t test_vreinterpret_s32_u8(uint8x8_t a) {
7217   return vreinterpret_s32_u8(a);
7218 }
7219
7220 // CHECK-LABEL: test_vreinterpret_s32_u16
7221 int32x2_t test_vreinterpret_s32_u16(uint16x4_t a) {
7222   return vreinterpret_s32_u16(a);
7223 }
7224
7225 // CHECK-LABEL: test_vreinterpret_s32_u32
7226 int32x2_t test_vreinterpret_s32_u32(uint32x2_t a) {
7227   return vreinterpret_s32_u32(a);
7228 }
7229
7230 // CHECK-LABEL: test_vreinterpret_s32_u64
7231 int32x2_t test_vreinterpret_s32_u64(uint64x1_t a) {
7232   return vreinterpret_s32_u64(a);
7233 }
7234
7235 // CHECK-LABEL: test_vreinterpret_s32_f16
7236 int32x2_t test_vreinterpret_s32_f16(float16x4_t a) {
7237   return vreinterpret_s32_f16(a);
7238 }
7239
7240 // CHECK-LABEL: test_vreinterpret_s32_f32
7241 int32x2_t test_vreinterpret_s32_f32(float32x2_t a) {
7242   return vreinterpret_s32_f32(a);
7243 }
7244
7245 // CHECK-LABEL: test_vreinterpret_s32_p8
7246 int32x2_t test_vreinterpret_s32_p8(poly8x8_t a) {
7247   return vreinterpret_s32_p8(a);
7248 }
7249
7250 // CHECK-LABEL: test_vreinterpret_s32_p16
7251 int32x2_t test_vreinterpret_s32_p16(poly16x4_t a) {
7252   return vreinterpret_s32_p16(a);
7253 }
7254
7255 // CHECK-LABEL: test_vreinterpret_s64_s8
7256 int64x1_t test_vreinterpret_s64_s8(int8x8_t a) {
7257   return vreinterpret_s64_s8(a);
7258 }
7259
7260 // CHECK-LABEL: test_vreinterpret_s64_s16
7261 int64x1_t test_vreinterpret_s64_s16(int16x4_t a) {
7262   return vreinterpret_s64_s16(a);
7263 }
7264
7265 // CHECK-LABEL: test_vreinterpret_s64_s32
7266 int64x1_t test_vreinterpret_s64_s32(int32x2_t a) {
7267   return vreinterpret_s64_s32(a);
7268 }
7269
7270 // CHECK-LABEL: test_vreinterpret_s64_u8
7271 int64x1_t test_vreinterpret_s64_u8(uint8x8_t a) {
7272   return vreinterpret_s64_u8(a);
7273 }
7274
7275 // CHECK-LABEL: test_vreinterpret_s64_u16
7276 int64x1_t test_vreinterpret_s64_u16(uint16x4_t a) {
7277   return vreinterpret_s64_u16(a);
7278 }
7279
7280 // CHECK-LABEL: test_vreinterpret_s64_u32
7281 int64x1_t test_vreinterpret_s64_u32(uint32x2_t a) {
7282   return vreinterpret_s64_u32(a);
7283 }
7284
7285 // CHECK-LABEL: test_vreinterpret_s64_u64
7286 int64x1_t test_vreinterpret_s64_u64(uint64x1_t a) {
7287   return vreinterpret_s64_u64(a);
7288 }
7289
7290 // CHECK-LABEL: test_vreinterpret_s64_f16
7291 int64x1_t test_vreinterpret_s64_f16(float16x4_t a) {
7292   return vreinterpret_s64_f16(a);
7293 }
7294
7295 // CHECK-LABEL: test_vreinterpret_s64_f32
7296 int64x1_t test_vreinterpret_s64_f32(float32x2_t a) {
7297   return vreinterpret_s64_f32(a);
7298 }
7299
7300 // CHECK-LABEL: test_vreinterpret_s64_p8
7301 int64x1_t test_vreinterpret_s64_p8(poly8x8_t a) {
7302   return vreinterpret_s64_p8(a);
7303 }
7304
7305 // CHECK-LABEL: test_vreinterpret_s64_p16
7306 int64x1_t test_vreinterpret_s64_p16(poly16x4_t a) {
7307   return vreinterpret_s64_p16(a);
7308 }
7309
7310 // CHECK-LABEL: test_vreinterpret_u8_s8
7311 uint8x8_t test_vreinterpret_u8_s8(int8x8_t a) {
7312   return vreinterpret_u8_s8(a);
7313 }
7314
7315 // CHECK-LABEL: test_vreinterpret_u8_s16
7316 uint8x8_t test_vreinterpret_u8_s16(int16x4_t a) {
7317   return vreinterpret_u8_s16(a);
7318 }
7319
7320 // CHECK-LABEL: test_vreinterpret_u8_s32
7321 uint8x8_t test_vreinterpret_u8_s32(int32x2_t a) {
7322   return vreinterpret_u8_s32(a);
7323 }
7324
7325 // CHECK-LABEL: test_vreinterpret_u8_s64
7326 uint8x8_t test_vreinterpret_u8_s64(int64x1_t a) {
7327   return vreinterpret_u8_s64(a);
7328 }
7329
7330 // CHECK-LABEL: test_vreinterpret_u8_u16
7331 uint8x8_t test_vreinterpret_u8_u16(uint16x4_t a) {
7332   return vreinterpret_u8_u16(a);
7333 }
7334
7335 // CHECK-LABEL: test_vreinterpret_u8_u32
7336 uint8x8_t test_vreinterpret_u8_u32(uint32x2_t a) {
7337   return vreinterpret_u8_u32(a);
7338 }
7339
7340 // CHECK-LABEL: test_vreinterpret_u8_u64
7341 uint8x8_t test_vreinterpret_u8_u64(uint64x1_t a) {
7342   return vreinterpret_u8_u64(a);
7343 }
7344
7345 // CHECK-LABEL: test_vreinterpret_u8_f16
7346 uint8x8_t test_vreinterpret_u8_f16(float16x4_t a) {
7347   return vreinterpret_u8_f16(a);
7348 }
7349
7350 // CHECK-LABEL: test_vreinterpret_u8_f32
7351 uint8x8_t test_vreinterpret_u8_f32(float32x2_t a) {
7352   return vreinterpret_u8_f32(a);
7353 }
7354
7355 // CHECK-LABEL: test_vreinterpret_u8_p8
7356 uint8x8_t test_vreinterpret_u8_p8(poly8x8_t a) {
7357   return vreinterpret_u8_p8(a);
7358 }
7359
7360 // CHECK-LABEL: test_vreinterpret_u8_p16
7361 uint8x8_t test_vreinterpret_u8_p16(poly16x4_t a) {
7362   return vreinterpret_u8_p16(a);
7363 }
7364
7365 // CHECK-LABEL: test_vreinterpret_u16_s8
7366 uint16x4_t test_vreinterpret_u16_s8(int8x8_t a) {
7367   return vreinterpret_u16_s8(a);
7368 }
7369
7370 // CHECK-LABEL: test_vreinterpret_u16_s16
7371 uint16x4_t test_vreinterpret_u16_s16(int16x4_t a) {
7372   return vreinterpret_u16_s16(a);
7373 }
7374
7375 // CHECK-LABEL: test_vreinterpret_u16_s32
7376 uint16x4_t test_vreinterpret_u16_s32(int32x2_t a) {
7377   return vreinterpret_u16_s32(a);
7378 }
7379
7380 // CHECK-LABEL: test_vreinterpret_u16_s64
7381 uint16x4_t test_vreinterpret_u16_s64(int64x1_t a) {
7382   return vreinterpret_u16_s64(a);
7383 }
7384
7385 // CHECK-LABEL: test_vreinterpret_u16_u8
7386 uint16x4_t test_vreinterpret_u16_u8(uint8x8_t a) {
7387   return vreinterpret_u16_u8(a);
7388 }
7389
7390 // CHECK-LABEL: test_vreinterpret_u16_u32
7391 uint16x4_t test_vreinterpret_u16_u32(uint32x2_t a) {
7392   return vreinterpret_u16_u32(a);
7393 }
7394
7395 // CHECK-LABEL: test_vreinterpret_u16_u64
7396 uint16x4_t test_vreinterpret_u16_u64(uint64x1_t a) {
7397   return vreinterpret_u16_u64(a);
7398 }
7399
7400 // CHECK-LABEL: test_vreinterpret_u16_f16
7401 uint16x4_t test_vreinterpret_u16_f16(float16x4_t a) {
7402   return vreinterpret_u16_f16(a);
7403 }
7404
7405 // CHECK-LABEL: test_vreinterpret_u16_f32
7406 uint16x4_t test_vreinterpret_u16_f32(float32x2_t a) {
7407   return vreinterpret_u16_f32(a);
7408 }
7409
7410 // CHECK-LABEL: test_vreinterpret_u16_p8
7411 uint16x4_t test_vreinterpret_u16_p8(poly8x8_t a) {
7412   return vreinterpret_u16_p8(a);
7413 }
7414
7415 // CHECK-LABEL: test_vreinterpret_u16_p16
7416 uint16x4_t test_vreinterpret_u16_p16(poly16x4_t a) {
7417   return vreinterpret_u16_p16(a);
7418 }
7419
7420 // CHECK-LABEL: test_vreinterpret_u32_s8
7421 uint32x2_t test_vreinterpret_u32_s8(int8x8_t a) {
7422   return vreinterpret_u32_s8(a);
7423 }
7424
7425 // CHECK-LABEL: test_vreinterpret_u32_s16
7426 uint32x2_t test_vreinterpret_u32_s16(int16x4_t a) {
7427   return vreinterpret_u32_s16(a);
7428 }
7429
7430 // CHECK-LABEL: test_vreinterpret_u32_s32
7431 uint32x2_t test_vreinterpret_u32_s32(int32x2_t a) {
7432   return vreinterpret_u32_s32(a);
7433 }
7434
7435 // CHECK-LABEL: test_vreinterpret_u32_s64
7436 uint32x2_t test_vreinterpret_u32_s64(int64x1_t a) {
7437   return vreinterpret_u32_s64(a);
7438 }
7439
7440 // CHECK-LABEL: test_vreinterpret_u32_u8
7441 uint32x2_t test_vreinterpret_u32_u8(uint8x8_t a) {
7442   return vreinterpret_u32_u8(a);
7443 }
7444
7445 // CHECK-LABEL: test_vreinterpret_u32_u16
7446 uint32x2_t test_vreinterpret_u32_u16(uint16x4_t a) {
7447   return vreinterpret_u32_u16(a);
7448 }
7449
7450 // CHECK-LABEL: test_vreinterpret_u32_u64
7451 uint32x2_t test_vreinterpret_u32_u64(uint64x1_t a) {
7452   return vreinterpret_u32_u64(a);
7453 }
7454
7455 // CHECK-LABEL: test_vreinterpret_u32_f16
7456 uint32x2_t test_vreinterpret_u32_f16(float16x4_t a) {
7457   return vreinterpret_u32_f16(a);
7458 }
7459
7460 // CHECK-LABEL: test_vreinterpret_u32_f32
7461 uint32x2_t test_vreinterpret_u32_f32(float32x2_t a) {
7462   return vreinterpret_u32_f32(a);
7463 }
7464
7465 // CHECK-LABEL: test_vreinterpret_u32_p8
7466 uint32x2_t test_vreinterpret_u32_p8(poly8x8_t a) {
7467   return vreinterpret_u32_p8(a);
7468 }
7469
7470 // CHECK-LABEL: test_vreinterpret_u32_p16
7471 uint32x2_t test_vreinterpret_u32_p16(poly16x4_t a) {
7472   return vreinterpret_u32_p16(a);
7473 }
7474
7475 // CHECK-LABEL: test_vreinterpret_u64_s8
7476 uint64x1_t test_vreinterpret_u64_s8(int8x8_t a) {
7477   return vreinterpret_u64_s8(a);
7478 }
7479
7480 // CHECK-LABEL: test_vreinterpret_u64_s16
7481 uint64x1_t test_vreinterpret_u64_s16(int16x4_t a) {
7482   return vreinterpret_u64_s16(a);
7483 }
7484
7485 // CHECK-LABEL: test_vreinterpret_u64_s32
7486 uint64x1_t test_vreinterpret_u64_s32(int32x2_t a) {
7487   return vreinterpret_u64_s32(a);
7488 }
7489
7490 // CHECK-LABEL: test_vreinterpret_u64_s64
7491 uint64x1_t test_vreinterpret_u64_s64(int64x1_t a) {
7492   return vreinterpret_u64_s64(a);
7493 }
7494
7495 // CHECK-LABEL: test_vreinterpret_u64_u8
7496 uint64x1_t test_vreinterpret_u64_u8(uint8x8_t a) {
7497   return vreinterpret_u64_u8(a);
7498 }
7499
7500 // CHECK-LABEL: test_vreinterpret_u64_u16
7501 uint64x1_t test_vreinterpret_u64_u16(uint16x4_t a) {
7502   return vreinterpret_u64_u16(a);
7503 }
7504
7505 // CHECK-LABEL: test_vreinterpret_u64_u32
7506 uint64x1_t test_vreinterpret_u64_u32(uint32x2_t a) {
7507   return vreinterpret_u64_u32(a);
7508 }
7509
7510 // CHECK-LABEL: test_vreinterpret_u64_f16
7511 uint64x1_t test_vreinterpret_u64_f16(float16x4_t a) {
7512   return vreinterpret_u64_f16(a);
7513 }
7514
7515 // CHECK-LABEL: test_vreinterpret_u64_f32
7516 uint64x1_t test_vreinterpret_u64_f32(float32x2_t a) {
7517   return vreinterpret_u64_f32(a);
7518 }
7519
7520 // CHECK-LABEL: test_vreinterpret_u64_p8
7521 uint64x1_t test_vreinterpret_u64_p8(poly8x8_t a) {
7522   return vreinterpret_u64_p8(a);
7523 }
7524
7525 // CHECK-LABEL: test_vreinterpret_u64_p16
7526 uint64x1_t test_vreinterpret_u64_p16(poly16x4_t a) {
7527   return vreinterpret_u64_p16(a);
7528 }
7529
7530 // CHECK-LABEL: test_vreinterpret_f16_s8
7531 float16x4_t test_vreinterpret_f16_s8(int8x8_t a) {
7532   return vreinterpret_f16_s8(a);
7533 }
7534
7535 // CHECK-LABEL: test_vreinterpret_f16_s16
7536 float16x4_t test_vreinterpret_f16_s16(int16x4_t a) {
7537   return vreinterpret_f16_s16(a);
7538 }
7539
7540 // CHECK-LABEL: test_vreinterpret_f16_s32
7541 float16x4_t test_vreinterpret_f16_s32(int32x2_t a) {
7542   return vreinterpret_f16_s32(a);
7543 }
7544
7545 // CHECK-LABEL: test_vreinterpret_f16_s64
7546 float16x4_t test_vreinterpret_f16_s64(int64x1_t a) {
7547   return vreinterpret_f16_s64(a);
7548 }
7549
7550 // CHECK-LABEL: test_vreinterpret_f16_u8
7551 float16x4_t test_vreinterpret_f16_u8(uint8x8_t a) {
7552   return vreinterpret_f16_u8(a);
7553 }
7554
7555 // CHECK-LABEL: test_vreinterpret_f16_u16
7556 float16x4_t test_vreinterpret_f16_u16(uint16x4_t a) {
7557   return vreinterpret_f16_u16(a);
7558 }
7559
7560 // CHECK-LABEL: test_vreinterpret_f16_u32
7561 float16x4_t test_vreinterpret_f16_u32(uint32x2_t a) {
7562   return vreinterpret_f16_u32(a);
7563 }
7564
7565 // CHECK-LABEL: test_vreinterpret_f16_u64
7566 float16x4_t test_vreinterpret_f16_u64(uint64x1_t a) {
7567   return vreinterpret_f16_u64(a);
7568 }
7569
7570 // CHECK-LABEL: test_vreinterpret_f16_f32
7571 float16x4_t test_vreinterpret_f16_f32(float32x2_t a) {
7572   return vreinterpret_f16_f32(a);
7573 }
7574
7575 // CHECK-LABEL: test_vreinterpret_f16_p8
7576 float16x4_t test_vreinterpret_f16_p8(poly8x8_t a) {
7577   return vreinterpret_f16_p8(a);
7578 }
7579
7580 // CHECK-LABEL: test_vreinterpret_f16_p16
7581 float16x4_t test_vreinterpret_f16_p16(poly16x4_t a) {
7582   return vreinterpret_f16_p16(a);
7583 }
7584
7585 // CHECK-LABEL: test_vreinterpret_f32_s8
7586 float32x2_t test_vreinterpret_f32_s8(int8x8_t a) {
7587   return vreinterpret_f32_s8(a);
7588 }
7589
7590 // CHECK-LABEL: test_vreinterpret_f32_s16
7591 float32x2_t test_vreinterpret_f32_s16(int16x4_t a) {
7592   return vreinterpret_f32_s16(a);
7593 }
7594
7595 // CHECK-LABEL: test_vreinterpret_f32_s32
7596 float32x2_t test_vreinterpret_f32_s32(int32x2_t a) {
7597   return vreinterpret_f32_s32(a);
7598 }
7599
7600 // CHECK-LABEL: test_vreinterpret_f32_s64
7601 float32x2_t test_vreinterpret_f32_s64(int64x1_t a) {
7602   return vreinterpret_f32_s64(a);
7603 }
7604
7605 // CHECK-LABEL: test_vreinterpret_f32_u8
7606 float32x2_t test_vreinterpret_f32_u8(uint8x8_t a) {
7607   return vreinterpret_f32_u8(a);
7608 }
7609
7610 // CHECK-LABEL: test_vreinterpret_f32_u16
7611 float32x2_t test_vreinterpret_f32_u16(uint16x4_t a) {
7612   return vreinterpret_f32_u16(a);
7613 }
7614
7615 // CHECK-LABEL: test_vreinterpret_f32_u32
7616 float32x2_t test_vreinterpret_f32_u32(uint32x2_t a) {
7617   return vreinterpret_f32_u32(a);
7618 }
7619
7620 // CHECK-LABEL: test_vreinterpret_f32_u64
7621 float32x2_t test_vreinterpret_f32_u64(uint64x1_t a) {
7622   return vreinterpret_f32_u64(a);
7623 }
7624
7625 // CHECK-LABEL: test_vreinterpret_f32_f16
7626 float32x2_t test_vreinterpret_f32_f16(float16x4_t a) {
7627   return vreinterpret_f32_f16(a);
7628 }
7629
7630 // CHECK-LABEL: test_vreinterpret_f32_p8
7631 float32x2_t test_vreinterpret_f32_p8(poly8x8_t a) {
7632   return vreinterpret_f32_p8(a);
7633 }
7634
7635 // CHECK-LABEL: test_vreinterpret_f32_p16
7636 float32x2_t test_vreinterpret_f32_p16(poly16x4_t a) {
7637   return vreinterpret_f32_p16(a);
7638 }
7639
7640 // CHECK-LABEL: test_vreinterpret_p8_s8
7641 poly8x8_t test_vreinterpret_p8_s8(int8x8_t a) {
7642   return vreinterpret_p8_s8(a);
7643 }
7644
7645 // CHECK-LABEL: test_vreinterpret_p8_s16
7646 poly8x8_t test_vreinterpret_p8_s16(int16x4_t a) {
7647   return vreinterpret_p8_s16(a);
7648 }
7649
7650 // CHECK-LABEL: test_vreinterpret_p8_s32
7651 poly8x8_t test_vreinterpret_p8_s32(int32x2_t a) {
7652   return vreinterpret_p8_s32(a);
7653 }
7654
7655 // CHECK-LABEL: test_vreinterpret_p8_s64
7656 poly8x8_t test_vreinterpret_p8_s64(int64x1_t a) {
7657   return vreinterpret_p8_s64(a);
7658 }
7659
7660 // CHECK-LABEL: test_vreinterpret_p8_u8
7661 poly8x8_t test_vreinterpret_p8_u8(uint8x8_t a) {
7662   return vreinterpret_p8_u8(a);
7663 }
7664
7665 // CHECK-LABEL: test_vreinterpret_p8_u16
7666 poly8x8_t test_vreinterpret_p8_u16(uint16x4_t a) {
7667   return vreinterpret_p8_u16(a);
7668 }
7669
7670 // CHECK-LABEL: test_vreinterpret_p8_u32
7671 poly8x8_t test_vreinterpret_p8_u32(uint32x2_t a) {
7672   return vreinterpret_p8_u32(a);
7673 }
7674
7675 // CHECK-LABEL: test_vreinterpret_p8_u64
7676 poly8x8_t test_vreinterpret_p8_u64(uint64x1_t a) {
7677   return vreinterpret_p8_u64(a);
7678 }
7679
7680 // CHECK-LABEL: test_vreinterpret_p8_f16
7681 poly8x8_t test_vreinterpret_p8_f16(float16x4_t a) {
7682   return vreinterpret_p8_f16(a);
7683 }
7684
7685 // CHECK-LABEL: test_vreinterpret_p8_f32
7686 poly8x8_t test_vreinterpret_p8_f32(float32x2_t a) {
7687   return vreinterpret_p8_f32(a);
7688 }
7689
7690 // CHECK-LABEL: test_vreinterpret_p8_p16
7691 poly8x8_t test_vreinterpret_p8_p16(poly16x4_t a) {
7692   return vreinterpret_p8_p16(a);
7693 }
7694
7695 // CHECK-LABEL: test_vreinterpret_p16_s8
7696 poly16x4_t test_vreinterpret_p16_s8(int8x8_t a) {
7697   return vreinterpret_p16_s8(a);
7698 }
7699
7700 // CHECK-LABEL: test_vreinterpret_p16_s16
7701 poly16x4_t test_vreinterpret_p16_s16(int16x4_t a) {
7702   return vreinterpret_p16_s16(a);
7703 }
7704
7705 // CHECK-LABEL: test_vreinterpret_p16_s32
7706 poly16x4_t test_vreinterpret_p16_s32(int32x2_t a) {
7707   return vreinterpret_p16_s32(a);
7708 }
7709
7710 // CHECK-LABEL: test_vreinterpret_p16_s64
7711 poly16x4_t test_vreinterpret_p16_s64(int64x1_t a) {
7712   return vreinterpret_p16_s64(a);
7713 }
7714
7715 // CHECK-LABEL: test_vreinterpret_p16_u8
7716 poly16x4_t test_vreinterpret_p16_u8(uint8x8_t a) {
7717   return vreinterpret_p16_u8(a);
7718 }
7719
7720 // CHECK-LABEL: test_vreinterpret_p16_u16
7721 poly16x4_t test_vreinterpret_p16_u16(uint16x4_t a) {
7722   return vreinterpret_p16_u16(a);
7723 }
7724
7725 // CHECK-LABEL: test_vreinterpret_p16_u32
7726 poly16x4_t test_vreinterpret_p16_u32(uint32x2_t a) {
7727   return vreinterpret_p16_u32(a);
7728 }
7729
7730 // CHECK-LABEL: test_vreinterpret_p16_u64
7731 poly16x4_t test_vreinterpret_p16_u64(uint64x1_t a) {
7732   return vreinterpret_p16_u64(a);
7733 }
7734
7735 // CHECK-LABEL: test_vreinterpret_p16_f16
7736 poly16x4_t test_vreinterpret_p16_f16(float16x4_t a) {
7737   return vreinterpret_p16_f16(a);
7738 }
7739
7740 // CHECK-LABEL: test_vreinterpret_p16_f32
7741 poly16x4_t test_vreinterpret_p16_f32(float32x2_t a) {
7742   return vreinterpret_p16_f32(a);
7743 }
7744
7745 // CHECK-LABEL: test_vreinterpret_p16_p8
7746 poly16x4_t test_vreinterpret_p16_p8(poly8x8_t a) {
7747   return vreinterpret_p16_p8(a);
7748 }
7749
7750 // CHECK-LABEL: test_vreinterpretq_s8_s16
7751 int8x16_t test_vreinterpretq_s8_s16(int16x8_t a) {
7752   return vreinterpretq_s8_s16(a);
7753 }
7754
7755 // CHECK-LABEL: test_vreinterpretq_s8_s32
7756 int8x16_t test_vreinterpretq_s8_s32(int32x4_t a) {
7757   return vreinterpretq_s8_s32(a);
7758 }
7759
7760 // CHECK-LABEL: test_vreinterpretq_s8_s64
7761 int8x16_t test_vreinterpretq_s8_s64(int64x2_t a) {
7762   return vreinterpretq_s8_s64(a);
7763 }
7764
7765 // CHECK-LABEL: test_vreinterpretq_s8_u8
7766 int8x16_t test_vreinterpretq_s8_u8(uint8x16_t a) {
7767   return vreinterpretq_s8_u8(a);
7768 }
7769
7770 // CHECK-LABEL: test_vreinterpretq_s8_u16
7771 int8x16_t test_vreinterpretq_s8_u16(uint16x8_t a) {
7772   return vreinterpretq_s8_u16(a);
7773 }
7774
7775 // CHECK-LABEL: test_vreinterpretq_s8_u32
7776 int8x16_t test_vreinterpretq_s8_u32(uint32x4_t a) {
7777   return vreinterpretq_s8_u32(a);
7778 }
7779
7780 // CHECK-LABEL: test_vreinterpretq_s8_u64
7781 int8x16_t test_vreinterpretq_s8_u64(uint64x2_t a) {
7782   return vreinterpretq_s8_u64(a);
7783 }
7784
7785 // CHECK-LABEL: test_vreinterpretq_s8_f16
7786 int8x16_t test_vreinterpretq_s8_f16(float16x8_t a) {
7787   return vreinterpretq_s8_f16(a);
7788 }
7789
7790 // CHECK-LABEL: test_vreinterpretq_s8_f32
7791 int8x16_t test_vreinterpretq_s8_f32(float32x4_t a) {
7792   return vreinterpretq_s8_f32(a);
7793 }
7794
7795 // CHECK-LABEL: test_vreinterpretq_s8_p8
7796 int8x16_t test_vreinterpretq_s8_p8(poly8x16_t a) {
7797   return vreinterpretq_s8_p8(a);
7798 }
7799
7800 // CHECK-LABEL: test_vreinterpretq_s8_p16
7801 int8x16_t test_vreinterpretq_s8_p16(poly16x8_t a) {
7802   return vreinterpretq_s8_p16(a);
7803 }
7804
7805 // CHECK-LABEL: test_vreinterpretq_s16_s8
7806 int16x8_t test_vreinterpretq_s16_s8(int8x16_t a) {
7807   return vreinterpretq_s16_s8(a);
7808 }
7809
7810 // CHECK-LABEL: test_vreinterpretq_s16_s32
7811 int16x8_t test_vreinterpretq_s16_s32(int32x4_t a) {
7812   return vreinterpretq_s16_s32(a);
7813 }
7814
7815 // CHECK-LABEL: test_vreinterpretq_s16_s64
7816 int16x8_t test_vreinterpretq_s16_s64(int64x2_t a) {
7817   return vreinterpretq_s16_s64(a);
7818 }
7819
7820 // CHECK-LABEL: test_vreinterpretq_s16_u8
7821 int16x8_t test_vreinterpretq_s16_u8(uint8x16_t a) {
7822   return vreinterpretq_s16_u8(a);
7823 }
7824
7825 // CHECK-LABEL: test_vreinterpretq_s16_u16
7826 int16x8_t test_vreinterpretq_s16_u16(uint16x8_t a) {
7827   return vreinterpretq_s16_u16(a);
7828 }
7829
7830 // CHECK-LABEL: test_vreinterpretq_s16_u32
7831 int16x8_t test_vreinterpretq_s16_u32(uint32x4_t a) {
7832   return vreinterpretq_s16_u32(a);
7833 }
7834
7835 // CHECK-LABEL: test_vreinterpretq_s16_u64
7836 int16x8_t test_vreinterpretq_s16_u64(uint64x2_t a) {
7837   return vreinterpretq_s16_u64(a);
7838 }
7839
7840 // CHECK-LABEL: test_vreinterpretq_s16_f16
7841 int16x8_t test_vreinterpretq_s16_f16(float16x8_t a) {
7842   return vreinterpretq_s16_f16(a);
7843 }
7844
7845 // CHECK-LABEL: test_vreinterpretq_s16_f32
7846 int16x8_t test_vreinterpretq_s16_f32(float32x4_t a) {
7847   return vreinterpretq_s16_f32(a);
7848 }
7849
7850 // CHECK-LABEL: test_vreinterpretq_s16_p8
7851 int16x8_t test_vreinterpretq_s16_p8(poly8x16_t a) {
7852   return vreinterpretq_s16_p8(a);
7853 }
7854
7855 // CHECK-LABEL: test_vreinterpretq_s16_p16
7856 int16x8_t test_vreinterpretq_s16_p16(poly16x8_t a) {
7857   return vreinterpretq_s16_p16(a);
7858 }
7859
7860 // CHECK-LABEL: test_vreinterpretq_s32_s8
7861 int32x4_t test_vreinterpretq_s32_s8(int8x16_t a) {
7862   return vreinterpretq_s32_s8(a);
7863 }
7864
7865 // CHECK-LABEL: test_vreinterpretq_s32_s16
7866 int32x4_t test_vreinterpretq_s32_s16(int16x8_t a) {
7867   return vreinterpretq_s32_s16(a);
7868 }
7869
7870 // CHECK-LABEL: test_vreinterpretq_s32_s64
7871 int32x4_t test_vreinterpretq_s32_s64(int64x2_t a) {
7872   return vreinterpretq_s32_s64(a);
7873 }
7874
7875 // CHECK-LABEL: test_vreinterpretq_s32_u8
7876 int32x4_t test_vreinterpretq_s32_u8(uint8x16_t a) {
7877   return vreinterpretq_s32_u8(a);
7878 }
7879
7880 // CHECK-LABEL: test_vreinterpretq_s32_u16
7881 int32x4_t test_vreinterpretq_s32_u16(uint16x8_t a) {
7882   return vreinterpretq_s32_u16(a);
7883 }
7884
7885 // CHECK-LABEL: test_vreinterpretq_s32_u32
7886 int32x4_t test_vreinterpretq_s32_u32(uint32x4_t a) {
7887   return vreinterpretq_s32_u32(a);
7888 }
7889
7890 // CHECK-LABEL: test_vreinterpretq_s32_u64
7891 int32x4_t test_vreinterpretq_s32_u64(uint64x2_t a) {
7892   return vreinterpretq_s32_u64(a);
7893 }
7894
7895 // CHECK-LABEL: test_vreinterpretq_s32_f16
7896 int32x4_t test_vreinterpretq_s32_f16(float16x8_t a) {
7897   return vreinterpretq_s32_f16(a);
7898 }
7899
7900 // CHECK-LABEL: test_vreinterpretq_s32_f32
7901 int32x4_t test_vreinterpretq_s32_f32(float32x4_t a) {
7902   return vreinterpretq_s32_f32(a);
7903 }
7904
7905 // CHECK-LABEL: test_vreinterpretq_s32_p8
7906 int32x4_t test_vreinterpretq_s32_p8(poly8x16_t a) {
7907   return vreinterpretq_s32_p8(a);
7908 }
7909
7910 // CHECK-LABEL: test_vreinterpretq_s32_p16
7911 int32x4_t test_vreinterpretq_s32_p16(poly16x8_t a) {
7912   return vreinterpretq_s32_p16(a);
7913 }
7914
7915 // CHECK-LABEL: test_vreinterpretq_s64_s8
7916 int64x2_t test_vreinterpretq_s64_s8(int8x16_t a) {
7917   return vreinterpretq_s64_s8(a);
7918 }
7919
7920 // CHECK-LABEL: test_vreinterpretq_s64_s16
7921 int64x2_t test_vreinterpretq_s64_s16(int16x8_t a) {
7922   return vreinterpretq_s64_s16(a);
7923 }
7924
7925 // CHECK-LABEL: test_vreinterpretq_s64_s32
7926 int64x2_t test_vreinterpretq_s64_s32(int32x4_t a) {
7927   return vreinterpretq_s64_s32(a);
7928 }
7929
7930 // CHECK-LABEL: test_vreinterpretq_s64_u8
7931 int64x2_t test_vreinterpretq_s64_u8(uint8x16_t a) {
7932   return vreinterpretq_s64_u8(a);
7933 }
7934
7935 // CHECK-LABEL: test_vreinterpretq_s64_u16
7936 int64x2_t test_vreinterpretq_s64_u16(uint16x8_t a) {
7937   return vreinterpretq_s64_u16(a);
7938 }
7939
7940 // CHECK-LABEL: test_vreinterpretq_s64_u32
7941 int64x2_t test_vreinterpretq_s64_u32(uint32x4_t a) {
7942   return vreinterpretq_s64_u32(a);
7943 }
7944
7945 // CHECK-LABEL: test_vreinterpretq_s64_u64
7946 int64x2_t test_vreinterpretq_s64_u64(uint64x2_t a) {
7947   return vreinterpretq_s64_u64(a);
7948 }
7949
7950 // CHECK-LABEL: test_vreinterpretq_s64_f16
7951 int64x2_t test_vreinterpretq_s64_f16(float16x8_t a) {
7952   return vreinterpretq_s64_f16(a);
7953 }
7954
7955 // CHECK-LABEL: test_vreinterpretq_s64_f32
7956 int64x2_t test_vreinterpretq_s64_f32(float32x4_t a) {
7957   return vreinterpretq_s64_f32(a);
7958 }
7959
7960 // CHECK-LABEL: test_vreinterpretq_s64_p8
7961 int64x2_t test_vreinterpretq_s64_p8(poly8x16_t a) {
7962   return vreinterpretq_s64_p8(a);
7963 }
7964
7965 // CHECK-LABEL: test_vreinterpretq_s64_p16
7966 int64x2_t test_vreinterpretq_s64_p16(poly16x8_t a) {
7967   return vreinterpretq_s64_p16(a);
7968 }
7969
7970 // CHECK-LABEL: test_vreinterpretq_u8_s8
7971 uint8x16_t test_vreinterpretq_u8_s8(int8x16_t a) {
7972   return vreinterpretq_u8_s8(a);
7973 }
7974
7975 // CHECK-LABEL: test_vreinterpretq_u8_s16
7976 uint8x16_t test_vreinterpretq_u8_s16(int16x8_t a) {
7977   return vreinterpretq_u8_s16(a);
7978 }
7979
7980 // CHECK-LABEL: test_vreinterpretq_u8_s32
7981 uint8x16_t test_vreinterpretq_u8_s32(int32x4_t a) {
7982   return vreinterpretq_u8_s32(a);
7983 }
7984
7985 // CHECK-LABEL: test_vreinterpretq_u8_s64
7986 uint8x16_t test_vreinterpretq_u8_s64(int64x2_t a) {
7987   return vreinterpretq_u8_s64(a);
7988 }
7989
7990 // CHECK-LABEL: test_vreinterpretq_u8_u16
7991 uint8x16_t test_vreinterpretq_u8_u16(uint16x8_t a) {
7992   return vreinterpretq_u8_u16(a);
7993 }
7994
7995 // CHECK-LABEL: test_vreinterpretq_u8_u32
7996 uint8x16_t test_vreinterpretq_u8_u32(uint32x4_t a) {
7997   return vreinterpretq_u8_u32(a);
7998 }
7999
8000 // CHECK-LABEL: test_vreinterpretq_u8_u64
8001 uint8x16_t test_vreinterpretq_u8_u64(uint64x2_t a) {
8002   return vreinterpretq_u8_u64(a);
8003 }
8004
8005 // CHECK-LABEL: test_vreinterpretq_u8_f16
8006 uint8x16_t test_vreinterpretq_u8_f16(float16x8_t a) {
8007   return vreinterpretq_u8_f16(a);
8008 }
8009
8010 // CHECK-LABEL: test_vreinterpretq_u8_f32
8011 uint8x16_t test_vreinterpretq_u8_f32(float32x4_t a) {
8012   return vreinterpretq_u8_f32(a);
8013 }
8014
8015 // CHECK-LABEL: test_vreinterpretq_u8_p8
8016 uint8x16_t test_vreinterpretq_u8_p8(poly8x16_t a) {
8017   return vreinterpretq_u8_p8(a);
8018 }
8019
8020 // CHECK-LABEL: test_vreinterpretq_u8_p16
8021 uint8x16_t test_vreinterpretq_u8_p16(poly16x8_t a) {
8022   return vreinterpretq_u8_p16(a);
8023 }
8024
8025 // CHECK-LABEL: test_vreinterpretq_u16_s8
8026 uint16x8_t test_vreinterpretq_u16_s8(int8x16_t a) {
8027   return vreinterpretq_u16_s8(a);
8028 }
8029
8030 // CHECK-LABEL: test_vreinterpretq_u16_s16
8031 uint16x8_t test_vreinterpretq_u16_s16(int16x8_t a) {
8032   return vreinterpretq_u16_s16(a);
8033 }
8034
8035 // CHECK-LABEL: test_vreinterpretq_u16_s32
8036 uint16x8_t test_vreinterpretq_u16_s32(int32x4_t a) {
8037   return vreinterpretq_u16_s32(a);
8038 }
8039
8040 // CHECK-LABEL: test_vreinterpretq_u16_s64
8041 uint16x8_t test_vreinterpretq_u16_s64(int64x2_t a) {
8042   return vreinterpretq_u16_s64(a);
8043 }
8044
8045 // CHECK-LABEL: test_vreinterpretq_u16_u8
8046 uint16x8_t test_vreinterpretq_u16_u8(uint8x16_t a) {
8047   return vreinterpretq_u16_u8(a);
8048 }
8049
8050 // CHECK-LABEL: test_vreinterpretq_u16_u32
8051 uint16x8_t test_vreinterpretq_u16_u32(uint32x4_t a) {
8052   return vreinterpretq_u16_u32(a);
8053 }
8054
8055 // CHECK-LABEL: test_vreinterpretq_u16_u64
8056 uint16x8_t test_vreinterpretq_u16_u64(uint64x2_t a) {
8057   return vreinterpretq_u16_u64(a);
8058 }
8059
8060 // CHECK-LABEL: test_vreinterpretq_u16_f16
8061 uint16x8_t test_vreinterpretq_u16_f16(float16x8_t a) {
8062   return vreinterpretq_u16_f16(a);
8063 }
8064
8065 // CHECK-LABEL: test_vreinterpretq_u16_f32
8066 uint16x8_t test_vreinterpretq_u16_f32(float32x4_t a) {
8067   return vreinterpretq_u16_f32(a);
8068 }
8069
8070 // CHECK-LABEL: test_vreinterpretq_u16_p8
8071 uint16x8_t test_vreinterpretq_u16_p8(poly8x16_t a) {
8072   return vreinterpretq_u16_p8(a);
8073 }
8074
8075 // CHECK-LABEL: test_vreinterpretq_u16_p16
8076 uint16x8_t test_vreinterpretq_u16_p16(poly16x8_t a) {
8077   return vreinterpretq_u16_p16(a);
8078 }
8079
8080 // CHECK-LABEL: test_vreinterpretq_u32_s8
8081 uint32x4_t test_vreinterpretq_u32_s8(int8x16_t a) {
8082   return vreinterpretq_u32_s8(a);
8083 }
8084
8085 // CHECK-LABEL: test_vreinterpretq_u32_s16
8086 uint32x4_t test_vreinterpretq_u32_s16(int16x8_t a) {
8087   return vreinterpretq_u32_s16(a);
8088 }
8089
8090 // CHECK-LABEL: test_vreinterpretq_u32_s32
8091 uint32x4_t test_vreinterpretq_u32_s32(int32x4_t a) {
8092   return vreinterpretq_u32_s32(a);
8093 }
8094
8095 // CHECK-LABEL: test_vreinterpretq_u32_s64
8096 uint32x4_t test_vreinterpretq_u32_s64(int64x2_t a) {
8097   return vreinterpretq_u32_s64(a);
8098 }
8099
8100 // CHECK-LABEL: test_vreinterpretq_u32_u8
8101 uint32x4_t test_vreinterpretq_u32_u8(uint8x16_t a) {
8102   return vreinterpretq_u32_u8(a);
8103 }
8104
8105 // CHECK-LABEL: test_vreinterpretq_u32_u16
8106 uint32x4_t test_vreinterpretq_u32_u16(uint16x8_t a) {
8107   return vreinterpretq_u32_u16(a);
8108 }
8109
8110 // CHECK-LABEL: test_vreinterpretq_u32_u64
8111 uint32x4_t test_vreinterpretq_u32_u64(uint64x2_t a) {
8112   return vreinterpretq_u32_u64(a);
8113 }
8114
8115 // CHECK-LABEL: test_vreinterpretq_u32_f16
8116 uint32x4_t test_vreinterpretq_u32_f16(float16x8_t a) {
8117   return vreinterpretq_u32_f16(a);
8118 }
8119
8120 // CHECK-LABEL: test_vreinterpretq_u32_f32
8121 uint32x4_t test_vreinterpretq_u32_f32(float32x4_t a) {
8122   return vreinterpretq_u32_f32(a);
8123 }
8124
8125 // CHECK-LABEL: test_vreinterpretq_u32_p8
8126 uint32x4_t test_vreinterpretq_u32_p8(poly8x16_t a) {
8127   return vreinterpretq_u32_p8(a);
8128 }
8129
8130 // CHECK-LABEL: test_vreinterpretq_u32_p16
8131 uint32x4_t test_vreinterpretq_u32_p16(poly16x8_t a) {
8132   return vreinterpretq_u32_p16(a);
8133 }
8134
8135 // CHECK-LABEL: test_vreinterpretq_u64_s8
8136 uint64x2_t test_vreinterpretq_u64_s8(int8x16_t a) {
8137   return vreinterpretq_u64_s8(a);
8138 }
8139
8140 // CHECK-LABEL: test_vreinterpretq_u64_s16
8141 uint64x2_t test_vreinterpretq_u64_s16(int16x8_t a) {
8142   return vreinterpretq_u64_s16(a);
8143 }
8144
8145 // CHECK-LABEL: test_vreinterpretq_u64_s32
8146 uint64x2_t test_vreinterpretq_u64_s32(int32x4_t a) {
8147   return vreinterpretq_u64_s32(a);
8148 }
8149
8150 // CHECK-LABEL: test_vreinterpretq_u64_s64
8151 uint64x2_t test_vreinterpretq_u64_s64(int64x2_t a) {
8152   return vreinterpretq_u64_s64(a);
8153 }
8154
8155 // CHECK-LABEL: test_vreinterpretq_u64_u8
8156 uint64x2_t test_vreinterpretq_u64_u8(uint8x16_t a) {
8157   return vreinterpretq_u64_u8(a);
8158 }
8159
8160 // CHECK-LABEL: test_vreinterpretq_u64_u16
8161 uint64x2_t test_vreinterpretq_u64_u16(uint16x8_t a) {
8162   return vreinterpretq_u64_u16(a);
8163 }
8164
8165 // CHECK-LABEL: test_vreinterpretq_u64_u32
8166 uint64x2_t test_vreinterpretq_u64_u32(uint32x4_t a) {
8167   return vreinterpretq_u64_u32(a);
8168 }
8169
8170 // CHECK-LABEL: test_vreinterpretq_u64_f16
8171 uint64x2_t test_vreinterpretq_u64_f16(float16x8_t a) {
8172   return vreinterpretq_u64_f16(a);
8173 }
8174
8175 // CHECK-LABEL: test_vreinterpretq_u64_f32
8176 uint64x2_t test_vreinterpretq_u64_f32(float32x4_t a) {
8177   return vreinterpretq_u64_f32(a);
8178 }
8179
8180 // CHECK-LABEL: test_vreinterpretq_u64_p8
8181 uint64x2_t test_vreinterpretq_u64_p8(poly8x16_t a) {
8182   return vreinterpretq_u64_p8(a);
8183 }
8184
8185 // CHECK-LABEL: test_vreinterpretq_u64_p16
8186 uint64x2_t test_vreinterpretq_u64_p16(poly16x8_t a) {
8187   return vreinterpretq_u64_p16(a);
8188 }
8189
8190 // CHECK-LABEL: test_vreinterpretq_f16_s8
8191 float16x8_t test_vreinterpretq_f16_s8(int8x16_t a) {
8192   return vreinterpretq_f16_s8(a);
8193 }
8194
8195 // CHECK-LABEL: test_vreinterpretq_f16_s16
8196 float16x8_t test_vreinterpretq_f16_s16(int16x8_t a) {
8197   return vreinterpretq_f16_s16(a);
8198 }
8199
8200 // CHECK-LABEL: test_vreinterpretq_f16_s32
8201 float16x8_t test_vreinterpretq_f16_s32(int32x4_t a) {
8202   return vreinterpretq_f16_s32(a);
8203 }
8204
8205 // CHECK-LABEL: test_vreinterpretq_f16_s64
8206 float16x8_t test_vreinterpretq_f16_s64(int64x2_t a) {
8207   return vreinterpretq_f16_s64(a);
8208 }
8209
8210 // CHECK-LABEL: test_vreinterpretq_f16_u8
8211 float16x8_t test_vreinterpretq_f16_u8(uint8x16_t a) {
8212   return vreinterpretq_f16_u8(a);
8213 }
8214
8215 // CHECK-LABEL: test_vreinterpretq_f16_u16
8216 float16x8_t test_vreinterpretq_f16_u16(uint16x8_t a) {
8217   return vreinterpretq_f16_u16(a);
8218 }
8219
8220 // CHECK-LABEL: test_vreinterpretq_f16_u32
8221 float16x8_t test_vreinterpretq_f16_u32(uint32x4_t a) {
8222   return vreinterpretq_f16_u32(a);
8223 }
8224
8225 // CHECK-LABEL: test_vreinterpretq_f16_u64
8226 float16x8_t test_vreinterpretq_f16_u64(uint64x2_t a) {
8227   return vreinterpretq_f16_u64(a);
8228 }
8229
8230 // CHECK-LABEL: test_vreinterpretq_f16_f32
8231 float16x8_t test_vreinterpretq_f16_f32(float32x4_t a) {
8232   return vreinterpretq_f16_f32(a);
8233 }
8234
8235 // CHECK-LABEL: test_vreinterpretq_f16_p8
8236 float16x8_t test_vreinterpretq_f16_p8(poly8x16_t a) {
8237   return vreinterpretq_f16_p8(a);
8238 }
8239
8240 // CHECK-LABEL: test_vreinterpretq_f16_p16
8241 float16x8_t test_vreinterpretq_f16_p16(poly16x8_t a) {
8242   return vreinterpretq_f16_p16(a);
8243 }
8244
8245 // CHECK-LABEL: test_vreinterpretq_f32_s8
8246 float32x4_t test_vreinterpretq_f32_s8(int8x16_t a) {
8247   return vreinterpretq_f32_s8(a);
8248 }
8249
8250 // CHECK-LABEL: test_vreinterpretq_f32_s16
8251 float32x4_t test_vreinterpretq_f32_s16(int16x8_t a) {
8252   return vreinterpretq_f32_s16(a);
8253 }
8254
8255 // CHECK-LABEL: test_vreinterpretq_f32_s32
8256 float32x4_t test_vreinterpretq_f32_s32(int32x4_t a) {
8257   return vreinterpretq_f32_s32(a);
8258 }
8259
8260 // CHECK-LABEL: test_vreinterpretq_f32_s64
8261 float32x4_t test_vreinterpretq_f32_s64(int64x2_t a) {
8262   return vreinterpretq_f32_s64(a);
8263 }
8264
8265 // CHECK-LABEL: test_vreinterpretq_f32_u8
8266 float32x4_t test_vreinterpretq_f32_u8(uint8x16_t a) {
8267   return vreinterpretq_f32_u8(a);
8268 }
8269
8270 // CHECK-LABEL: test_vreinterpretq_f32_u16
8271 float32x4_t test_vreinterpretq_f32_u16(uint16x8_t a) {
8272   return vreinterpretq_f32_u16(a);
8273 }
8274
8275 // CHECK-LABEL: test_vreinterpretq_f32_u32
8276 float32x4_t test_vreinterpretq_f32_u32(uint32x4_t a) {
8277   return vreinterpretq_f32_u32(a);
8278 }
8279
8280 // CHECK-LABEL: test_vreinterpretq_f32_u64
8281 float32x4_t test_vreinterpretq_f32_u64(uint64x2_t a) {
8282   return vreinterpretq_f32_u64(a);
8283 }
8284
8285 // CHECK-LABEL: test_vreinterpretq_f32_f16
8286 float32x4_t test_vreinterpretq_f32_f16(float16x8_t a) {
8287   return vreinterpretq_f32_f16(a);
8288 }
8289
8290 // CHECK-LABEL: test_vreinterpretq_f32_p8
8291 float32x4_t test_vreinterpretq_f32_p8(poly8x16_t a) {
8292   return vreinterpretq_f32_p8(a);
8293 }
8294
8295 // CHECK-LABEL: test_vreinterpretq_f32_p16
8296 float32x4_t test_vreinterpretq_f32_p16(poly16x8_t a) {
8297   return vreinterpretq_f32_p16(a);
8298 }
8299
8300 // CHECK-LABEL: test_vreinterpretq_p8_s8
8301 poly8x16_t test_vreinterpretq_p8_s8(int8x16_t a) {
8302   return vreinterpretq_p8_s8(a);
8303 }
8304
8305 // CHECK-LABEL: test_vreinterpretq_p8_s16
8306 poly8x16_t test_vreinterpretq_p8_s16(int16x8_t a) {
8307   return vreinterpretq_p8_s16(a);
8308 }
8309
8310 // CHECK-LABEL: test_vreinterpretq_p8_s32
8311 poly8x16_t test_vreinterpretq_p8_s32(int32x4_t a) {
8312   return vreinterpretq_p8_s32(a);
8313 }
8314
8315 // CHECK-LABEL: test_vreinterpretq_p8_s64
8316 poly8x16_t test_vreinterpretq_p8_s64(int64x2_t a) {
8317   return vreinterpretq_p8_s64(a);
8318 }
8319
8320 // CHECK-LABEL: test_vreinterpretq_p8_u8
8321 poly8x16_t test_vreinterpretq_p8_u8(uint8x16_t a) {
8322   return vreinterpretq_p8_u8(a);
8323 }
8324
8325 // CHECK-LABEL: test_vreinterpretq_p8_u16
8326 poly8x16_t test_vreinterpretq_p8_u16(uint16x8_t a) {
8327   return vreinterpretq_p8_u16(a);
8328 }
8329
8330 // CHECK-LABEL: test_vreinterpretq_p8_u32
8331 poly8x16_t test_vreinterpretq_p8_u32(uint32x4_t a) {
8332   return vreinterpretq_p8_u32(a);
8333 }
8334
8335 // CHECK-LABEL: test_vreinterpretq_p8_u64
8336 poly8x16_t test_vreinterpretq_p8_u64(uint64x2_t a) {
8337   return vreinterpretq_p8_u64(a);
8338 }
8339
8340 // CHECK-LABEL: test_vreinterpretq_p8_f16
8341 poly8x16_t test_vreinterpretq_p8_f16(float16x8_t a) {
8342   return vreinterpretq_p8_f16(a);
8343 }
8344
8345 // CHECK-LABEL: test_vreinterpretq_p8_f32
8346 poly8x16_t test_vreinterpretq_p8_f32(float32x4_t a) {
8347   return vreinterpretq_p8_f32(a);
8348 }
8349
8350 // CHECK-LABEL: test_vreinterpretq_p8_p16
8351 poly8x16_t test_vreinterpretq_p8_p16(poly16x8_t a) {
8352   return vreinterpretq_p8_p16(a);
8353 }
8354
8355 // CHECK-LABEL: test_vreinterpretq_p16_s8
8356 poly16x8_t test_vreinterpretq_p16_s8(int8x16_t a) {
8357   return vreinterpretq_p16_s8(a);
8358 }
8359
8360 // CHECK-LABEL: test_vreinterpretq_p16_s16
8361 poly16x8_t test_vreinterpretq_p16_s16(int16x8_t a) {
8362   return vreinterpretq_p16_s16(a);
8363 }
8364
8365 // CHECK-LABEL: test_vreinterpretq_p16_s32
8366 poly16x8_t test_vreinterpretq_p16_s32(int32x4_t a) {
8367   return vreinterpretq_p16_s32(a);
8368 }
8369
8370 // CHECK-LABEL: test_vreinterpretq_p16_s64
8371 poly16x8_t test_vreinterpretq_p16_s64(int64x2_t a) {
8372   return vreinterpretq_p16_s64(a);
8373 }
8374
8375 // CHECK-LABEL: test_vreinterpretq_p16_u8
8376 poly16x8_t test_vreinterpretq_p16_u8(uint8x16_t a) {
8377   return vreinterpretq_p16_u8(a);
8378 }
8379
8380 // CHECK-LABEL: test_vreinterpretq_p16_u16
8381 poly16x8_t test_vreinterpretq_p16_u16(uint16x8_t a) {
8382   return vreinterpretq_p16_u16(a);
8383 }
8384
8385 // CHECK-LABEL: test_vreinterpretq_p16_u32
8386 poly16x8_t test_vreinterpretq_p16_u32(uint32x4_t a) {
8387   return vreinterpretq_p16_u32(a);
8388 }
8389
8390 // CHECK-LABEL: test_vreinterpretq_p16_u64
8391 poly16x8_t test_vreinterpretq_p16_u64(uint64x2_t a) {
8392   return vreinterpretq_p16_u64(a);
8393 }
8394
8395 // CHECK-LABEL: test_vreinterpretq_p16_f16
8396 poly16x8_t test_vreinterpretq_p16_f16(float16x8_t a) {
8397   return vreinterpretq_p16_f16(a);
8398 }
8399
8400 // CHECK-LABEL: test_vreinterpretq_p16_f32
8401 poly16x8_t test_vreinterpretq_p16_f32(float32x4_t a) {
8402   return vreinterpretq_p16_f32(a);
8403 }
8404
8405 // CHECK-LABEL: test_vreinterpretq_p16_p8
8406 poly16x8_t test_vreinterpretq_p16_p8(poly8x16_t a) {
8407   return vreinterpretq_p16_p8(a);
8408 }
8409
8410
8411 // CHECK-LABEL: test_vrev16_s8
8412 // CHECK: vrev16.8 d{{[0-9]+}}, d{{[0-9]+}}
8413 int8x8_t test_vrev16_s8(int8x8_t a) {
8414   return vrev16_s8(a);
8415 }
8416
8417 // CHECK-LABEL: test_vrev16_u8
8418 // CHECK: vrev16.8 d{{[0-9]+}}, d{{[0-9]+}}
8419 uint8x8_t test_vrev16_u8(uint8x8_t a) {
8420   return vrev16_u8(a);
8421 }
8422
8423 // CHECK-LABEL: test_vrev16_p8
8424 // CHECK: vrev16.8 d{{[0-9]+}}, d{{[0-9]+}}
8425 poly8x8_t test_vrev16_p8(poly8x8_t a) {
8426   return vrev16_p8(a);
8427 }
8428
8429 // CHECK-LABEL: test_vrev16q_s8
8430 // CHECK: vrev16.8 q{{[0-9]+}}, q{{[0-9]+}}
8431 int8x16_t test_vrev16q_s8(int8x16_t a) {
8432   return vrev16q_s8(a);
8433 }
8434
8435 // CHECK-LABEL: test_vrev16q_u8
8436 // CHECK: vrev16.8 q{{[0-9]+}}, q{{[0-9]+}}
8437 uint8x16_t test_vrev16q_u8(uint8x16_t a) {
8438   return vrev16q_u8(a);
8439 }
8440
8441 // CHECK-LABEL: test_vrev16q_p8
8442 // CHECK: vrev16.8 q{{[0-9]+}}, q{{[0-9]+}}
8443 poly8x16_t test_vrev16q_p8(poly8x16_t a) {
8444   return vrev16q_p8(a);
8445 }
8446
8447
8448 // CHECK-LABEL: test_vrev32_s8
8449 // CHECK: vrev32.8 d{{[0-9]+}}, d{{[0-9]+}}
8450 int8x8_t test_vrev32_s8(int8x8_t a) {
8451   return vrev32_s8(a);
8452 }
8453
8454 // CHECK-LABEL: test_vrev32_s16
8455 // CHECK: vrev32.16 d{{[0-9]+}}, d{{[0-9]+}}
8456 int16x4_t test_vrev32_s16(int16x4_t a) {
8457   return vrev32_s16(a);
8458 }
8459
8460 // CHECK-LABEL: test_vrev32_u8
8461 // CHECK: vrev32.8 d{{[0-9]+}}, d{{[0-9]+}}
8462 uint8x8_t test_vrev32_u8(uint8x8_t a) {
8463   return vrev32_u8(a);
8464 }
8465
8466 // CHECK-LABEL: test_vrev32_u16
8467 // CHECK: vrev32.16 d{{[0-9]+}}, d{{[0-9]+}}
8468 uint16x4_t test_vrev32_u16(uint16x4_t a) {
8469   return vrev32_u16(a);
8470 }
8471
8472 // CHECK-LABEL: test_vrev32_p8
8473 // CHECK: vrev32.8 d{{[0-9]+}}, d{{[0-9]+}}
8474 poly8x8_t test_vrev32_p8(poly8x8_t a) {
8475   return vrev32_p8(a);
8476 }
8477
8478 // CHECK-LABEL: test_vrev32_p16
8479 // CHECK: vrev32.16 d{{[0-9]+}}, d{{[0-9]+}}
8480 poly16x4_t test_vrev32_p16(poly16x4_t a) {
8481   return vrev32_p16(a);
8482 }
8483
8484 // CHECK-LABEL: test_vrev32q_s8
8485 // CHECK: vrev32.8 q{{[0-9]+}}, q{{[0-9]+}}
8486 int8x16_t test_vrev32q_s8(int8x16_t a) {
8487   return vrev32q_s8(a);
8488 }
8489
8490 // CHECK-LABEL: test_vrev32q_s16
8491 // CHECK: vrev32.16 q{{[0-9]+}}, q{{[0-9]+}}
8492 int16x8_t test_vrev32q_s16(int16x8_t a) {
8493   return vrev32q_s16(a);
8494 }
8495
8496 // CHECK-LABEL: test_vrev32q_u8
8497 // CHECK: vrev32.8 q{{[0-9]+}}, q{{[0-9]+}}
8498 uint8x16_t test_vrev32q_u8(uint8x16_t a) {
8499   return vrev32q_u8(a);
8500 }
8501
8502 // CHECK-LABEL: test_vrev32q_u16
8503 // CHECK: vrev32.16 q{{[0-9]+}}, q{{[0-9]+}}
8504 uint16x8_t test_vrev32q_u16(uint16x8_t a) {
8505   return vrev32q_u16(a);
8506 }
8507
8508 // CHECK-LABEL: test_vrev32q_p8
8509 // CHECK: vrev32.8 q{{[0-9]+}}, q{{[0-9]+}}
8510 poly8x16_t test_vrev32q_p8(poly8x16_t a) {
8511   return vrev32q_p8(a);
8512 }
8513
8514 // CHECK-LABEL: test_vrev32q_p16
8515 // CHECK: vrev32.16 q{{[0-9]+}}, q{{[0-9]+}}
8516 poly16x8_t test_vrev32q_p16(poly16x8_t a) {
8517   return vrev32q_p16(a);
8518 }
8519
8520
8521 // CHECK-LABEL: test_vrev64_s8
8522 // CHECK: vrev64.8 d{{[0-9]+}}, d{{[0-9]+}}
8523 int8x8_t test_vrev64_s8(int8x8_t a) {
8524   return vrev64_s8(a);
8525 }
8526
8527 // CHECK-LABEL: test_vrev64_s16
8528 // CHECK: vrev64.16 d{{[0-9]+}}, d{{[0-9]+}}
8529 int16x4_t test_vrev64_s16(int16x4_t a) {
8530   return vrev64_s16(a);
8531 }
8532
8533 // CHECK-LABEL: test_vrev64_s32
8534 // CHECK: vrev64.32 d{{[0-9]+}}, d{{[0-9]+}}
8535 int32x2_t test_vrev64_s32(int32x2_t a) {
8536   return vrev64_s32(a);
8537 }
8538
8539 // CHECK-LABEL: test_vrev64_u8
8540 // CHECK: vrev64.8 d{{[0-9]+}}, d{{[0-9]+}}
8541 uint8x8_t test_vrev64_u8(uint8x8_t a) {
8542   return vrev64_u8(a);
8543 }
8544
8545 // CHECK-LABEL: test_vrev64_u16
8546 // CHECK: vrev64.16 d{{[0-9]+}}, d{{[0-9]+}}
8547 uint16x4_t test_vrev64_u16(uint16x4_t a) {
8548   return vrev64_u16(a);
8549 }
8550
8551 // CHECK-LABEL: test_vrev64_u32
8552 // CHECK: vrev64.32 d{{[0-9]+}}, d{{[0-9]+}}
8553 uint32x2_t test_vrev64_u32(uint32x2_t a) {
8554   return vrev64_u32(a);
8555 }
8556
8557 // CHECK-LABEL: test_vrev64_p8
8558 // CHECK: vrev64.8 d{{[0-9]+}}, d{{[0-9]+}}
8559 poly8x8_t test_vrev64_p8(poly8x8_t a) {
8560   return vrev64_p8(a);
8561 }
8562
8563 // CHECK-LABEL: test_vrev64_p16
8564 // CHECK: vrev64.16 d{{[0-9]+}}, d{{[0-9]+}}
8565 poly16x4_t test_vrev64_p16(poly16x4_t a) {
8566   return vrev64_p16(a);
8567 }
8568
8569 // CHECK-LABEL: test_vrev64_f32
8570 // CHECK: vrev64.32 d{{[0-9]+}}, d{{[0-9]+}}
8571 float32x2_t test_vrev64_f32(float32x2_t a) {
8572   return vrev64_f32(a);
8573 }
8574
8575 // CHECK-LABEL: test_vrev64q_s8
8576 // CHECK: vrev64.8 q{{[0-9]+}}, q{{[0-9]+}}
8577 int8x16_t test_vrev64q_s8(int8x16_t a) {
8578   return vrev64q_s8(a);
8579 }
8580
8581 // CHECK-LABEL: test_vrev64q_s16
8582 // CHECK: vrev64.16 q{{[0-9]+}}, q{{[0-9]+}}
8583 int16x8_t test_vrev64q_s16(int16x8_t a) {
8584   return vrev64q_s16(a);
8585 }
8586
8587 // CHECK-LABEL: test_vrev64q_s32
8588 // CHECK: vrev64.32 q{{[0-9]+}}, q{{[0-9]+}}
8589 int32x4_t test_vrev64q_s32(int32x4_t a) {
8590   return vrev64q_s32(a);
8591 }
8592
8593 // CHECK-LABEL: test_vrev64q_u8
8594 // CHECK: vrev64.8 q{{[0-9]+}}, q{{[0-9]+}}
8595 uint8x16_t test_vrev64q_u8(uint8x16_t a) {
8596   return vrev64q_u8(a);
8597 }
8598
8599 // CHECK-LABEL: test_vrev64q_u16
8600 // CHECK: vrev64.16 q{{[0-9]+}}, q{{[0-9]+}}
8601 uint16x8_t test_vrev64q_u16(uint16x8_t a) {
8602   return vrev64q_u16(a);
8603 }
8604
8605 // CHECK-LABEL: test_vrev64q_u32
8606 // CHECK: vrev64.32 q{{[0-9]+}}, q{{[0-9]+}}
8607 uint32x4_t test_vrev64q_u32(uint32x4_t a) {
8608   return vrev64q_u32(a);
8609 }
8610
8611 // CHECK-LABEL: test_vrev64q_p8
8612 // CHECK: vrev64.8 q{{[0-9]+}}, q{{[0-9]+}}
8613 poly8x16_t test_vrev64q_p8(poly8x16_t a) {
8614   return vrev64q_p8(a);
8615 }
8616
8617 // CHECK-LABEL: test_vrev64q_p16
8618 // CHECK: vrev64.16 q{{[0-9]+}}, q{{[0-9]+}}
8619 poly16x8_t test_vrev64q_p16(poly16x8_t a) {
8620   return vrev64q_p16(a);
8621 }
8622
8623 // CHECK-LABEL: test_vrev64q_f32
8624 // CHECK: vrev64.32 q{{[0-9]+}}, q{{[0-9]+}}
8625 float32x4_t test_vrev64q_f32(float32x4_t a) {
8626   return vrev64q_f32(a);
8627 }
8628
8629
8630 // CHECK-LABEL: test_vrhadd_s8
8631 // CHECK: vrhadd.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
8632 int8x8_t test_vrhadd_s8(int8x8_t a, int8x8_t b) {
8633   return vrhadd_s8(a, b);
8634 }
8635
8636 // CHECK-LABEL: test_vrhadd_s16
8637 // CHECK: vrhadd.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
8638 int16x4_t test_vrhadd_s16(int16x4_t a, int16x4_t b) {
8639   return vrhadd_s16(a, b);
8640 }
8641
8642 // CHECK-LABEL: test_vrhadd_s32
8643 // CHECK: vrhadd.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
8644 int32x2_t test_vrhadd_s32(int32x2_t a, int32x2_t b) {
8645   return vrhadd_s32(a, b);
8646 }
8647
8648 // CHECK-LABEL: test_vrhadd_u8
8649 // CHECK: vrhadd.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
8650 uint8x8_t test_vrhadd_u8(uint8x8_t a, uint8x8_t b) {
8651   return vrhadd_u8(a, b);
8652 }
8653
8654 // CHECK-LABEL: test_vrhadd_u16
8655 // CHECK: vrhadd.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
8656 uint16x4_t test_vrhadd_u16(uint16x4_t a, uint16x4_t b) {
8657   return vrhadd_u16(a, b);
8658 }
8659
8660 // CHECK-LABEL: test_vrhadd_u32
8661 // CHECK: vrhadd.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
8662 uint32x2_t test_vrhadd_u32(uint32x2_t a, uint32x2_t b) {
8663   return vrhadd_u32(a, b);
8664 }
8665
8666 // CHECK-LABEL: test_vrhaddq_s8
8667 // CHECK: vrhadd.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
8668 int8x16_t test_vrhaddq_s8(int8x16_t a, int8x16_t b) {
8669   return vrhaddq_s8(a, b);
8670 }
8671
8672 // CHECK-LABEL: test_vrhaddq_s16
8673 // CHECK: vrhadd.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
8674 int16x8_t test_vrhaddq_s16(int16x8_t a, int16x8_t b) {
8675   return vrhaddq_s16(a, b);
8676 }
8677
8678 // CHECK-LABEL: test_vrhaddq_s32
8679 // CHECK: vrhadd.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
8680 int32x4_t test_vrhaddq_s32(int32x4_t a, int32x4_t b) {
8681   return vrhaddq_s32(a, b);
8682 }
8683
8684 // CHECK-LABEL: test_vrhaddq_u8
8685 // CHECK: vrhadd.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
8686 uint8x16_t test_vrhaddq_u8(uint8x16_t a, uint8x16_t b) {
8687   return vrhaddq_u8(a, b);
8688 }
8689
8690 // CHECK-LABEL: test_vrhaddq_u16
8691 // CHECK: vrhadd.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
8692 uint16x8_t test_vrhaddq_u16(uint16x8_t a, uint16x8_t b) {
8693   return vrhaddq_u16(a, b);
8694 }
8695
8696 // CHECK-LABEL: test_vrhaddq_u32
8697 // CHECK: vrhadd.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
8698 uint32x4_t test_vrhaddq_u32(uint32x4_t a, uint32x4_t b) {
8699   return vrhaddq_u32(a, b);
8700 }
8701
8702
8703 // CHECK-LABEL: test_vrshl_s8
8704 // CHECK: vrshl.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
8705 int8x8_t test_vrshl_s8(int8x8_t a, int8x8_t b) {
8706   return vrshl_s8(a, b);
8707 }
8708
8709 // CHECK-LABEL: test_vrshl_s16
8710 // CHECK: vrshl.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
8711 int16x4_t test_vrshl_s16(int16x4_t a, int16x4_t b) {
8712   return vrshl_s16(a, b);
8713 }
8714
8715 // CHECK-LABEL: test_vrshl_s32
8716 // CHECK: vrshl.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
8717 int32x2_t test_vrshl_s32(int32x2_t a, int32x2_t b) {
8718   return vrshl_s32(a, b);
8719 }
8720
8721 // CHECK-LABEL: test_vrshl_s64
8722 // CHECK: vrshl.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
8723 int64x1_t test_vrshl_s64(int64x1_t a, int64x1_t b) {
8724   return vrshl_s64(a, b);
8725 }
8726
8727 // CHECK-LABEL: test_vrshl_u8
8728 // CHECK: vrshl.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
8729 uint8x8_t test_vrshl_u8(uint8x8_t a, int8x8_t b) {
8730   return vrshl_u8(a, b);
8731 }
8732
8733 // CHECK-LABEL: test_vrshl_u16
8734 // CHECK: vrshl.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
8735 uint16x4_t test_vrshl_u16(uint16x4_t a, int16x4_t b) {
8736   return vrshl_u16(a, b);
8737 }
8738
8739 // CHECK-LABEL: test_vrshl_u32
8740 // CHECK: vrshl.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
8741 uint32x2_t test_vrshl_u32(uint32x2_t a, int32x2_t b) {
8742   return vrshl_u32(a, b);
8743 }
8744
8745 // CHECK-LABEL: test_vrshl_u64
8746 // CHECK: vrshl.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
8747 uint64x1_t test_vrshl_u64(uint64x1_t a, int64x1_t b) {
8748   return vrshl_u64(a, b);
8749 }
8750
8751 // CHECK-LABEL: test_vrshlq_s8
8752 // CHECK: vrshl.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
8753 int8x16_t test_vrshlq_s8(int8x16_t a, int8x16_t b) {
8754   return vrshlq_s8(a, b);
8755 }
8756
8757 // CHECK-LABEL: test_vrshlq_s16
8758 // CHECK: vrshl.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
8759 int16x8_t test_vrshlq_s16(int16x8_t a, int16x8_t b) {
8760   return vrshlq_s16(a, b);
8761 }
8762
8763 // CHECK-LABEL: test_vrshlq_s32
8764 // CHECK: vrshl.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
8765 int32x4_t test_vrshlq_s32(int32x4_t a, int32x4_t b) {
8766   return vrshlq_s32(a, b);
8767 }
8768
8769 // CHECK-LABEL: test_vrshlq_s64
8770 // CHECK: vrshl.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
8771 int64x2_t test_vrshlq_s64(int64x2_t a, int64x2_t b) {
8772   return vrshlq_s64(a, b);
8773 }
8774
8775 // CHECK-LABEL: test_vrshlq_u8
8776 // CHECK: vrshl.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
8777 uint8x16_t test_vrshlq_u8(uint8x16_t a, int8x16_t b) {
8778   return vrshlq_u8(a, b);
8779 }
8780
8781 // CHECK-LABEL: test_vrshlq_u16
8782 // CHECK: vrshl.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
8783 uint16x8_t test_vrshlq_u16(uint16x8_t a, int16x8_t b) {
8784   return vrshlq_u16(a, b);
8785 }
8786
8787 // CHECK-LABEL: test_vrshlq_u32
8788 // CHECK: vrshl.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
8789 uint32x4_t test_vrshlq_u32(uint32x4_t a, int32x4_t b) {
8790   return vrshlq_u32(a, b);
8791 }
8792
8793 // CHECK-LABEL: test_vrshlq_u64
8794 // CHECK: vrshl.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
8795 uint64x2_t test_vrshlq_u64(uint64x2_t a, int64x2_t b) {
8796   return vrshlq_u64(a, b);
8797 }
8798
8799
8800 // CHECK-LABEL: test_vrshrn_n_s16
8801 // CHECK: vrshrn.i16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
8802 int8x8_t test_vrshrn_n_s16(int16x8_t a) {
8803   return vrshrn_n_s16(a, 1);
8804 }
8805
8806 // CHECK-LABEL: test_vrshrn_n_s32
8807 // CHECK: vrshrn.i32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
8808 int16x4_t test_vrshrn_n_s32(int32x4_t a) {
8809   return vrshrn_n_s32(a, 1);
8810 }
8811
8812 // CHECK-LABEL: test_vrshrn_n_s64
8813 // CHECK: vrshrn.i64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
8814 int32x2_t test_vrshrn_n_s64(int64x2_t a) {
8815   return vrshrn_n_s64(a, 1);
8816 }
8817
8818 // CHECK-LABEL: test_vrshrn_n_u16
8819 // CHECK: vrshrn.i16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
8820 uint8x8_t test_vrshrn_n_u16(uint16x8_t a) {
8821   return vrshrn_n_u16(a, 1);
8822 }
8823
8824 // CHECK-LABEL: test_vrshrn_n_u32
8825 // CHECK: vrshrn.i32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
8826 uint16x4_t test_vrshrn_n_u32(uint32x4_t a) {
8827   return vrshrn_n_u32(a, 1);
8828 }
8829
8830 // CHECK-LABEL: test_vrshrn_n_u64
8831 // CHECK: vrshrn.i64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
8832 uint32x2_t test_vrshrn_n_u64(uint64x2_t a) {
8833   return vrshrn_n_u64(a, 1);
8834 }
8835
8836
8837 // CHECK-LABEL: test_vrshr_n_s8
8838 // CHECK: vrshr.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
8839 int8x8_t test_vrshr_n_s8(int8x8_t a) {
8840   return vrshr_n_s8(a, 1);
8841 }
8842
8843 // CHECK-LABEL: test_vrshr_n_s16
8844 // CHECK: vrshr.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
8845 int16x4_t test_vrshr_n_s16(int16x4_t a) {
8846   return vrshr_n_s16(a, 1);
8847 }
8848
8849 // CHECK-LABEL: test_vrshr_n_s32
8850 // CHECK: vrshr.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
8851 int32x2_t test_vrshr_n_s32(int32x2_t a) {
8852   return vrshr_n_s32(a, 1);
8853 }
8854
8855 // CHECK-LABEL: test_vrshr_n_s64
8856 // CHECK: vrshr.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
8857 int64x1_t test_vrshr_n_s64(int64x1_t a) {
8858   return vrshr_n_s64(a, 1);
8859 }
8860
8861 // CHECK-LABEL: test_vrshr_n_u8
8862 // CHECK: vrshr.u8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
8863 uint8x8_t test_vrshr_n_u8(uint8x8_t a) {
8864   return vrshr_n_u8(a, 1);
8865 }
8866
8867 // CHECK-LABEL: test_vrshr_n_u16
8868 // CHECK: vrshr.u16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
8869 uint16x4_t test_vrshr_n_u16(uint16x4_t a) {
8870   return vrshr_n_u16(a, 1);
8871 }
8872
8873 // CHECK-LABEL: test_vrshr_n_u32
8874 // CHECK: vrshr.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
8875 uint32x2_t test_vrshr_n_u32(uint32x2_t a) {
8876   return vrshr_n_u32(a, 1);
8877 }
8878
8879 // CHECK-LABEL: test_vrshr_n_u64
8880 // CHECK: vrshr.u64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
8881 uint64x1_t test_vrshr_n_u64(uint64x1_t a) {
8882   return vrshr_n_u64(a, 1);
8883 }
8884
8885 // CHECK-LABEL: test_vrshrq_n_s8
8886 // CHECK: vrshr.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
8887 int8x16_t test_vrshrq_n_s8(int8x16_t a) {
8888   return vrshrq_n_s8(a, 1);
8889 }
8890
8891 // CHECK-LABEL: test_vrshrq_n_s16
8892 // CHECK: vrshr.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
8893 int16x8_t test_vrshrq_n_s16(int16x8_t a) {
8894   return vrshrq_n_s16(a, 1);
8895 }
8896
8897 // CHECK-LABEL: test_vrshrq_n_s32
8898 // CHECK: vrshr.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
8899 int32x4_t test_vrshrq_n_s32(int32x4_t a) {
8900   return vrshrq_n_s32(a, 1);
8901 }
8902
8903 // CHECK-LABEL: test_vrshrq_n_s64
8904 // CHECK: vrshr.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
8905 int64x2_t test_vrshrq_n_s64(int64x2_t a) {
8906   return vrshrq_n_s64(a, 1);
8907 }
8908
8909 // CHECK-LABEL: test_vrshrq_n_u8
8910 // CHECK: vrshr.u8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
8911 uint8x16_t test_vrshrq_n_u8(uint8x16_t a) {
8912   return vrshrq_n_u8(a, 1);
8913 }
8914
8915 // CHECK-LABEL: test_vrshrq_n_u16
8916 // CHECK: vrshr.u16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
8917 uint16x8_t test_vrshrq_n_u16(uint16x8_t a) {
8918   return vrshrq_n_u16(a, 1);
8919 }
8920
8921 // CHECK-LABEL: test_vrshrq_n_u32
8922 // CHECK: vrshr.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
8923 uint32x4_t test_vrshrq_n_u32(uint32x4_t a) {
8924   return vrshrq_n_u32(a, 1);
8925 }
8926
8927 // CHECK-LABEL: test_vrshrq_n_u64
8928 // CHECK: vrshr.u64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
8929 uint64x2_t test_vrshrq_n_u64(uint64x2_t a) {
8930   return vrshrq_n_u64(a, 1);
8931 }
8932
8933
8934 // CHECK-LABEL: test_vrsqrte_f32
8935 // CHECK: vrsqrte.f32 d{{[0-9]+}}, d{{[0-9]+}}
8936 float32x2_t test_vrsqrte_f32(float32x2_t a) {
8937   return vrsqrte_f32(a);
8938 }
8939
8940 // CHECK-LABEL: test_vrsqrte_u32
8941 // CHECK: vrsqrte.u32 d{{[0-9]+}}, d{{[0-9]+}}
8942 uint32x2_t test_vrsqrte_u32(uint32x2_t a) {
8943   return vrsqrte_u32(a);
8944 }
8945
8946 // CHECK-LABEL: test_vrsqrteq_f32
8947 // CHECK: vrsqrte.f32 q{{[0-9]+}}, q{{[0-9]+}}
8948 float32x4_t test_vrsqrteq_f32(float32x4_t a) {
8949   return vrsqrteq_f32(a);
8950 }
8951
8952 // CHECK-LABEL: test_vrsqrteq_u32
8953 // CHECK: vrsqrte.u32 q{{[0-9]+}}, q{{[0-9]+}}
8954 uint32x4_t test_vrsqrteq_u32(uint32x4_t a) {
8955   return vrsqrteq_u32(a);
8956 }
8957
8958
8959 // CHECK-LABEL: test_vrsqrts_f32
8960 // CHECK: vrsqrts.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
8961 float32x2_t test_vrsqrts_f32(float32x2_t a, float32x2_t b) {
8962   return vrsqrts_f32(a, b);
8963 }
8964
8965 // CHECK-LABEL: test_vrsqrtsq_f32
8966 // CHECK: vrsqrts.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
8967 float32x4_t test_vrsqrtsq_f32(float32x4_t a, float32x4_t b) {
8968   return vrsqrtsq_f32(a, b);
8969 }
8970
8971
8972 // CHECK-LABEL: test_vrsra_n_s8
8973 // CHECK: vrsra.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
8974 int8x8_t test_vrsra_n_s8(int8x8_t a, int8x8_t b) {
8975   return vrsra_n_s8(a, b, 1);
8976 }
8977
8978 // CHECK-LABEL: test_vrsra_n_s16
8979 // CHECK: vrsra.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
8980 int16x4_t test_vrsra_n_s16(int16x4_t a, int16x4_t b) {
8981   return vrsra_n_s16(a, b, 1);
8982 }
8983
8984 // CHECK-LABEL: test_vrsra_n_s32
8985 // CHECK: vrsra.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
8986 int32x2_t test_vrsra_n_s32(int32x2_t a, int32x2_t b) {
8987   return vrsra_n_s32(a, b, 1);
8988 }
8989
8990 // CHECK-LABEL: test_vrsra_n_s64
8991 // CHECK: vrsra.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
8992 int64x1_t test_vrsra_n_s64(int64x1_t a, int64x1_t b) {
8993   return vrsra_n_s64(a, b, 1);
8994 }
8995
8996 // CHECK-LABEL: test_vrsra_n_u8
8997 // CHECK: vrsra.u8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
8998 uint8x8_t test_vrsra_n_u8(uint8x8_t a, uint8x8_t b) {
8999   return vrsra_n_u8(a, b, 1);
9000 }
9001
9002 // CHECK-LABEL: test_vrsra_n_u16
9003 // CHECK: vrsra.u16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9004 uint16x4_t test_vrsra_n_u16(uint16x4_t a, uint16x4_t b) {
9005   return vrsra_n_u16(a, b, 1);
9006 }
9007
9008 // CHECK-LABEL: test_vrsra_n_u32
9009 // CHECK: vrsra.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9010 uint32x2_t test_vrsra_n_u32(uint32x2_t a, uint32x2_t b) {
9011   return vrsra_n_u32(a, b, 1);
9012 }
9013
9014 // CHECK-LABEL: test_vrsra_n_u64
9015 // CHECK: vrsra.u64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9016 uint64x1_t test_vrsra_n_u64(uint64x1_t a, uint64x1_t b) {
9017   return vrsra_n_u64(a, b, 1);
9018 }
9019
9020 // CHECK-LABEL: test_vrsraq_n_s8
9021 // CHECK: vrsra.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9022 int8x16_t test_vrsraq_n_s8(int8x16_t a, int8x16_t b) {
9023   return vrsraq_n_s8(a, b, 1);
9024 }
9025
9026 // CHECK-LABEL: test_vrsraq_n_s16
9027 // CHECK: vrsra.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9028 int16x8_t test_vrsraq_n_s16(int16x8_t a, int16x8_t b) {
9029   return vrsraq_n_s16(a, b, 1);
9030 }
9031
9032 // CHECK-LABEL: test_vrsraq_n_s32
9033 // CHECK: vrsra.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9034 int32x4_t test_vrsraq_n_s32(int32x4_t a, int32x4_t b) {
9035   return vrsraq_n_s32(a, b, 1);
9036 }
9037
9038 // CHECK-LABEL: test_vrsraq_n_s64
9039 // CHECK: vrsra.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9040 int64x2_t test_vrsraq_n_s64(int64x2_t a, int64x2_t b) {
9041   return vrsraq_n_s64(a, b, 1);
9042 }
9043
9044 // CHECK-LABEL: test_vrsraq_n_u8
9045 // CHECK: vrsra.u8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9046 uint8x16_t test_vrsraq_n_u8(uint8x16_t a, uint8x16_t b) {
9047   return vrsraq_n_u8(a, b, 1);
9048 }
9049
9050 // CHECK-LABEL: test_vrsraq_n_u16
9051 // CHECK: vrsra.u16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9052 uint16x8_t test_vrsraq_n_u16(uint16x8_t a, uint16x8_t b) {
9053   return vrsraq_n_u16(a, b, 1);
9054 }
9055
9056 // CHECK-LABEL: test_vrsraq_n_u32
9057 // CHECK: vrsra.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9058 uint32x4_t test_vrsraq_n_u32(uint32x4_t a, uint32x4_t b) {
9059   return vrsraq_n_u32(a, b, 1);
9060 }
9061
9062 // CHECK-LABEL: test_vrsraq_n_u64
9063 // CHECK: vrsra.u64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9064 uint64x2_t test_vrsraq_n_u64(uint64x2_t a, uint64x2_t b) {
9065   return vrsraq_n_u64(a, b, 1);
9066 }
9067
9068
9069 // CHECK-LABEL: test_vrsubhn_s16
9070 // CHECK: vrsubhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
9071 int8x8_t test_vrsubhn_s16(int16x8_t a, int16x8_t b) {
9072   return vrsubhn_s16(a, b);
9073 }
9074
9075 // CHECK-LABEL: test_vrsubhn_s32
9076 // CHECK: vrsubhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
9077 int16x4_t test_vrsubhn_s32(int32x4_t a, int32x4_t b) {
9078   return vrsubhn_s32(a, b);
9079 }
9080
9081 // CHECK-LABEL: test_vrsubhn_s64
9082 // CHECK: vrsubhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
9083 int32x2_t test_vrsubhn_s64(int64x2_t a, int64x2_t b) {
9084   return vrsubhn_s64(a, b);
9085 }
9086
9087 // CHECK-LABEL: test_vrsubhn_u16
9088 // CHECK: vrsubhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
9089 uint8x8_t test_vrsubhn_u16(uint16x8_t a, uint16x8_t b) {
9090   return vrsubhn_u16(a, b);
9091 }
9092
9093 // CHECK-LABEL: test_vrsubhn_u32
9094 // CHECK: vrsubhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
9095 uint16x4_t test_vrsubhn_u32(uint32x4_t a, uint32x4_t b) {
9096   return vrsubhn_u32(a, b);
9097 }
9098
9099 // CHECK-LABEL: test_vrsubhn_u64
9100 // CHECK: vrsubhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
9101 uint32x2_t test_vrsubhn_u64(uint64x2_t a, uint64x2_t b) {
9102   return vrsubhn_u64(a, b);
9103 }
9104
9105
9106 // CHECK-LABEL: test_vset_lane_u8
9107 // CHECK: vmov
9108 uint8x8_t test_vset_lane_u8(uint8_t a, uint8x8_t b) {
9109   return vset_lane_u8(a, b, 7);
9110 }
9111
9112 // CHECK-LABEL: test_vset_lane_u16
9113 // CHECK: vmov
9114 uint16x4_t test_vset_lane_u16(uint16_t a, uint16x4_t b) {
9115   return vset_lane_u16(a, b, 3);
9116 }
9117
9118 // CHECK-LABEL: test_vset_lane_u32
9119 // CHECK: mov
9120 uint32x2_t test_vset_lane_u32(uint32_t a, uint32x2_t b) {
9121   return vset_lane_u32(a, b, 1);
9122 }
9123
9124 // CHECK-LABEL: test_vset_lane_s8
9125 // CHECK: vmov
9126 int8x8_t test_vset_lane_s8(int8_t a, int8x8_t b) {
9127   return vset_lane_s8(a, b, 7);
9128 }
9129
9130 // CHECK-LABEL: test_vset_lane_s16
9131 // CHECK: vmov
9132 int16x4_t test_vset_lane_s16(int16_t a, int16x4_t b) {
9133   return vset_lane_s16(a, b, 3);
9134 }
9135
9136 // CHECK-LABEL: test_vset_lane_s32
9137 // CHECK: mov
9138 int32x2_t test_vset_lane_s32(int32_t a, int32x2_t b) {
9139   return vset_lane_s32(a, b, 1);
9140 }
9141
9142 // CHECK-LABEL: test_vset_lane_p8
9143 // CHECK: vmov
9144 poly8x8_t test_vset_lane_p8(poly8_t a, poly8x8_t b) {
9145   return vset_lane_p8(a, b, 7);
9146 }
9147
9148 // CHECK-LABEL: test_vset_lane_p16
9149 // CHECK: vmov
9150 poly16x4_t test_vset_lane_p16(poly16_t a, poly16x4_t b) {
9151   return vset_lane_p16(a, b, 3);
9152 }
9153
9154 // CHECK-LABEL: test_vset_lane_f32
9155 // CHECK: mov
9156 float32x2_t test_vset_lane_f32(float32_t a, float32x2_t b) {
9157   return vset_lane_f32(a, b, 1);
9158 }
9159
9160 // CHECK-LABEL: test_vsetq_lane_u8
9161 // CHECK: vmov
9162 uint8x16_t test_vsetq_lane_u8(uint8_t a, uint8x16_t b) {
9163   return vsetq_lane_u8(a, b, 15);
9164 }
9165
9166 // CHECK-LABEL: test_vsetq_lane_u16
9167 // CHECK: vmov
9168 uint16x8_t test_vsetq_lane_u16(uint16_t a, uint16x8_t b) {
9169   return vsetq_lane_u16(a, b, 7);
9170 }
9171
9172 // CHECK-LABEL: test_vsetq_lane_u32
9173 // CHECK: vmov
9174 uint32x4_t test_vsetq_lane_u32(uint32_t a, uint32x4_t b) {
9175   return vsetq_lane_u32(a, b, 3);
9176 }
9177
9178 // CHECK-LABEL: test_vsetq_lane_s8
9179 // CHECK: vmov
9180 int8x16_t test_vsetq_lane_s8(int8_t a, int8x16_t b) {
9181   return vsetq_lane_s8(a, b, 15);
9182 }
9183
9184 // CHECK-LABEL: test_vsetq_lane_s16
9185 // CHECK: vmov
9186 int16x8_t test_vsetq_lane_s16(int16_t a, int16x8_t b) {
9187   return vsetq_lane_s16(a, b, 7);
9188 }
9189
9190 // CHECK-LABEL: test_vsetq_lane_s32
9191 // CHECK: vmov
9192 int32x4_t test_vsetq_lane_s32(int32_t a, int32x4_t b) {
9193   return vsetq_lane_s32(a, b, 3);
9194 }
9195
9196 // CHECK-LABEL: test_vsetq_lane_p8
9197 // CHECK: vmov
9198 poly8x16_t test_vsetq_lane_p8(poly8_t a, poly8x16_t b) {
9199   return vsetq_lane_p8(a, b, 15);
9200 }
9201
9202 // CHECK-LABEL: test_vsetq_lane_p16
9203 // CHECK: vmov
9204 poly16x8_t test_vsetq_lane_p16(poly16_t a, poly16x8_t b) {
9205   return vsetq_lane_p16(a, b, 7);
9206 }
9207
9208 // CHECK-LABEL: test_vsetq_lane_f32
9209 // CHECK: vmov
9210 float32x4_t test_vsetq_lane_f32(float32_t a, float32x4_t b) {
9211   return vsetq_lane_f32(a, b, 3);
9212 }
9213
9214 // CHECK-LABEL: test_vset_lane_s64
9215 // The optimizer is able to get rid of all moves now.
9216 int64x1_t test_vset_lane_s64(int64_t a, int64x1_t b) {
9217   return vset_lane_s64(a, b, 0);
9218 }
9219
9220 // CHECK-LABEL: test_vset_lane_u64
9221 // The optimizer is able to get rid of all moves now.
9222 uint64x1_t test_vset_lane_u64(uint64_t a, uint64x1_t b) {
9223   return vset_lane_u64(a, b, 0);
9224 }
9225
9226 // CHECK-LABEL: test_vsetq_lane_s64
9227 // CHECK: vmov
9228 int64x2_t test_vsetq_lane_s64(int64_t a, int64x2_t b) {
9229   return vsetq_lane_s64(a, b, 1);
9230 }
9231
9232 // CHECK-LABEL: test_vsetq_lane_u64
9233 // CHECK: vmov
9234 uint64x2_t test_vsetq_lane_u64(uint64_t a, uint64x2_t b) {
9235   return vsetq_lane_u64(a, b, 1);
9236 }
9237
9238
9239 // CHECK-LABEL: test_vshl_s8
9240 // CHECK: vshl.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
9241 int8x8_t test_vshl_s8(int8x8_t a, int8x8_t b) {
9242   return vshl_s8(a, b);
9243 }
9244
9245 // CHECK-LABEL: test_vshl_s16
9246 // CHECK: vshl.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
9247 int16x4_t test_vshl_s16(int16x4_t a, int16x4_t b) {
9248   return vshl_s16(a, b);
9249 }
9250
9251 // CHECK-LABEL: test_vshl_s32
9252 // CHECK: vshl.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
9253 int32x2_t test_vshl_s32(int32x2_t a, int32x2_t b) {
9254   return vshl_s32(a, b);
9255 }
9256
9257 // CHECK-LABEL: test_vshl_s64
9258 // CHECK: vshl.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
9259 int64x1_t test_vshl_s64(int64x1_t a, int64x1_t b) {
9260   return vshl_s64(a, b);
9261 }
9262
9263 // CHECK-LABEL: test_vshl_u8
9264 // CHECK: vshl.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
9265 uint8x8_t test_vshl_u8(uint8x8_t a, int8x8_t b) {
9266   return vshl_u8(a, b);
9267 }
9268
9269 // CHECK-LABEL: test_vshl_u16
9270 // CHECK: vshl.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
9271 uint16x4_t test_vshl_u16(uint16x4_t a, int16x4_t b) {
9272   return vshl_u16(a, b);
9273 }
9274
9275 // CHECK-LABEL: test_vshl_u32
9276 // CHECK: vshl.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
9277 uint32x2_t test_vshl_u32(uint32x2_t a, int32x2_t b) {
9278   return vshl_u32(a, b);
9279 }
9280
9281 // CHECK-LABEL: test_vshl_u64
9282 // CHECK: vshl.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
9283 uint64x1_t test_vshl_u64(uint64x1_t a, int64x1_t b) {
9284   return vshl_u64(a, b);
9285 }
9286
9287 // CHECK-LABEL: test_vshlq_s8
9288 // CHECK: vshl.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
9289 int8x16_t test_vshlq_s8(int8x16_t a, int8x16_t b) {
9290   return vshlq_s8(a, b);
9291 }
9292
9293 // CHECK-LABEL: test_vshlq_s16
9294 // CHECK: vshl.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
9295 int16x8_t test_vshlq_s16(int16x8_t a, int16x8_t b) {
9296   return vshlq_s16(a, b);
9297 }
9298
9299 // CHECK-LABEL: test_vshlq_s32
9300 // CHECK: vshl.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
9301 int32x4_t test_vshlq_s32(int32x4_t a, int32x4_t b) {
9302   return vshlq_s32(a, b);
9303 }
9304
9305 // CHECK-LABEL: test_vshlq_s64
9306 // CHECK: vshl.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
9307 int64x2_t test_vshlq_s64(int64x2_t a, int64x2_t b) {
9308   return vshlq_s64(a, b);
9309 }
9310
9311 // CHECK-LABEL: test_vshlq_u8
9312 // CHECK: vshl.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
9313 uint8x16_t test_vshlq_u8(uint8x16_t a, int8x16_t b) {
9314   return vshlq_u8(a, b);
9315 }
9316
9317 // CHECK-LABEL: test_vshlq_u16
9318 // CHECK: vshl.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
9319 uint16x8_t test_vshlq_u16(uint16x8_t a, int16x8_t b) {
9320   return vshlq_u16(a, b);
9321 }
9322
9323 // CHECK-LABEL: test_vshlq_u32
9324 // CHECK: vshl.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
9325 uint32x4_t test_vshlq_u32(uint32x4_t a, int32x4_t b) {
9326   return vshlq_u32(a, b);
9327 }
9328
9329 // CHECK-LABEL: test_vshlq_u64
9330 // CHECK: vshl.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
9331 uint64x2_t test_vshlq_u64(uint64x2_t a, int64x2_t b) {
9332   return vshlq_u64(a, b);
9333 }
9334
9335
9336 // CHECK-LABEL: test_vshll_n_s8
9337 // CHECK: vshll.s8 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9338 int16x8_t test_vshll_n_s8(int8x8_t a) {
9339   return vshll_n_s8(a, 1);
9340 }
9341
9342 // CHECK-LABEL: test_vshll_n_s16
9343 // CHECK: vshll.s16 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9344 int32x4_t test_vshll_n_s16(int16x4_t a) {
9345   return vshll_n_s16(a, 1);
9346 }
9347
9348 // CHECK-LABEL: test_vshll_n_s32
9349 // CHECK: vshll.s32 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9350 int64x2_t test_vshll_n_s32(int32x2_t a) {
9351   return vshll_n_s32(a, 1);
9352 }
9353
9354 // CHECK-LABEL: test_vshll_n_u8
9355 // CHECK: vshll.u8 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9356 uint16x8_t test_vshll_n_u8(uint8x8_t a) {
9357   return vshll_n_u8(a, 1);
9358 }
9359
9360 // CHECK-LABEL: test_vshll_n_u16
9361 // CHECK: vshll.u16 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9362 uint32x4_t test_vshll_n_u16(uint16x4_t a) {
9363   return vshll_n_u16(a, 1);
9364 }
9365
9366 // CHECK-LABEL: test_vshll_n_u32
9367 // CHECK: vshll.u32 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9368 uint64x2_t test_vshll_n_u32(uint32x2_t a) {
9369   return vshll_n_u32(a, 1);
9370 }
9371
9372
9373 // CHECK-LABEL: test_vshl_n_s8
9374 // CHECK: vshl.i8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9375 int8x8_t test_vshl_n_s8(int8x8_t a) {
9376   return vshl_n_s8(a, 1);
9377 }
9378
9379 // CHECK-LABEL: test_vshl_n_s16
9380 // CHECK: vshl.i16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9381 int16x4_t test_vshl_n_s16(int16x4_t a) {
9382   return vshl_n_s16(a, 1);
9383 }
9384
9385 // CHECK-LABEL: test_vshl_n_s32
9386 // CHECK: vshl.i32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9387 int32x2_t test_vshl_n_s32(int32x2_t a) {
9388   return vshl_n_s32(a, 1);
9389 }
9390
9391 // CHECK-LABEL: test_vshl_n_s64
9392 // CHECK: vshl.i64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9393 int64x1_t test_vshl_n_s64(int64x1_t a) {
9394   return vshl_n_s64(a, 1);
9395 }
9396
9397 // CHECK-LABEL: test_vshl_n_u8
9398 // CHECK: vshl.i8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9399 uint8x8_t test_vshl_n_u8(uint8x8_t a) {
9400   return vshl_n_u8(a, 1);
9401 }
9402
9403 // CHECK-LABEL: test_vshl_n_u16
9404 // CHECK: vshl.i16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9405 uint16x4_t test_vshl_n_u16(uint16x4_t a) {
9406   return vshl_n_u16(a, 1);
9407 }
9408
9409 // CHECK-LABEL: test_vshl_n_u32
9410 // CHECK: vshl.i32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9411 uint32x2_t test_vshl_n_u32(uint32x2_t a) {
9412   return vshl_n_u32(a, 1);
9413 }
9414
9415 // CHECK-LABEL: test_vshl_n_u64
9416 // CHECK: vshl.i64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9417 uint64x1_t test_vshl_n_u64(uint64x1_t a) {
9418   return vshl_n_u64(a, 1);
9419 }
9420
9421 // CHECK-LABEL: test_vshlq_n_s8
9422 // CHECK: vshl.i8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9423 int8x16_t test_vshlq_n_s8(int8x16_t a) {
9424   return vshlq_n_s8(a, 1);
9425 }
9426
9427 // CHECK-LABEL: test_vshlq_n_s16
9428 // CHECK: vshl.i16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9429 int16x8_t test_vshlq_n_s16(int16x8_t a) {
9430   return vshlq_n_s16(a, 1);
9431 }
9432
9433 // CHECK-LABEL: test_vshlq_n_s32
9434 // CHECK: vshl.i32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9435 int32x4_t test_vshlq_n_s32(int32x4_t a) {
9436   return vshlq_n_s32(a, 1);
9437 }
9438
9439 // CHECK-LABEL: test_vshlq_n_s64
9440 // CHECK: vshl.i64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9441 int64x2_t test_vshlq_n_s64(int64x2_t a) {
9442   return vshlq_n_s64(a, 1);
9443 }
9444
9445 // CHECK-LABEL: test_vshlq_n_u8
9446 // CHECK: vshl.i8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9447 uint8x16_t test_vshlq_n_u8(uint8x16_t a) {
9448   return vshlq_n_u8(a, 1);
9449 }
9450
9451 // CHECK-LABEL: test_vshlq_n_u16
9452 // CHECK: vshl.i16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9453 uint16x8_t test_vshlq_n_u16(uint16x8_t a) {
9454   return vshlq_n_u16(a, 1);
9455 }
9456
9457 // CHECK-LABEL: test_vshlq_n_u32
9458 // CHECK: vshl.i32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9459 uint32x4_t test_vshlq_n_u32(uint32x4_t a) {
9460   return vshlq_n_u32(a, 1);
9461 }
9462
9463 // CHECK-LABEL: test_vshlq_n_u64
9464 // CHECK: vshl.i64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9465 uint64x2_t test_vshlq_n_u64(uint64x2_t a) {
9466   return vshlq_n_u64(a, 1);
9467 }
9468
9469
9470 // CHECK-LABEL: test_vshrn_n_s16
9471 // CHECK: vshrn.i16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9472 int8x8_t test_vshrn_n_s16(int16x8_t a) {
9473   return vshrn_n_s16(a, 1);
9474 }
9475
9476 // CHECK-LABEL: test_vshrn_n_s32
9477 // CHECK: vshrn.i32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9478 int16x4_t test_vshrn_n_s32(int32x4_t a) {
9479   return vshrn_n_s32(a, 1);
9480 }
9481
9482 // CHECK-LABEL: test_vshrn_n_s64
9483 // CHECK: vshrn.i64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9484 int32x2_t test_vshrn_n_s64(int64x2_t a) {
9485   return vshrn_n_s64(a, 1);
9486 }
9487
9488 // CHECK-LABEL: test_vshrn_n_u16
9489 // CHECK: vshrn.i16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9490 uint8x8_t test_vshrn_n_u16(uint16x8_t a) {
9491   return vshrn_n_u16(a, 1);
9492 }
9493
9494 // CHECK-LABEL: test_vshrn_n_u32
9495 // CHECK: vshrn.i32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9496 uint16x4_t test_vshrn_n_u32(uint32x4_t a) {
9497   return vshrn_n_u32(a, 1);
9498 }
9499
9500 // CHECK-LABEL: test_vshrn_n_u64
9501 // CHECK: vshrn.i64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9502 uint32x2_t test_vshrn_n_u64(uint64x2_t a) {
9503   return vshrn_n_u64(a, 1);
9504 }
9505
9506
9507 // CHECK-LABEL: test_vshr_n_s8
9508 // CHECK: vshr.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9509 int8x8_t test_vshr_n_s8(int8x8_t a) {
9510   return vshr_n_s8(a, 1);
9511 }
9512
9513 // CHECK-LABEL: test_vshr_n_s16
9514 // CHECK: vshr.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9515 int16x4_t test_vshr_n_s16(int16x4_t a) {
9516   return vshr_n_s16(a, 1);
9517 }
9518
9519 // CHECK-LABEL: test_vshr_n_s32
9520 // CHECK: vshr.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9521 int32x2_t test_vshr_n_s32(int32x2_t a) {
9522   return vshr_n_s32(a, 1);
9523 }
9524
9525 // CHECK-LABEL: test_vshr_n_s64
9526 // CHECK: vshr.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9527 int64x1_t test_vshr_n_s64(int64x1_t a) {
9528   return vshr_n_s64(a, 1);
9529 }
9530
9531 // CHECK-LABEL: test_vshr_n_u8
9532 // CHECK: vshr.u8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9533 uint8x8_t test_vshr_n_u8(uint8x8_t a) {
9534   return vshr_n_u8(a, 1);
9535 }
9536
9537 // CHECK-LABEL: test_vshr_n_u16
9538 // CHECK: vshr.u16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9539 uint16x4_t test_vshr_n_u16(uint16x4_t a) {
9540   return vshr_n_u16(a, 1);
9541 }
9542
9543 // CHECK-LABEL: test_vshr_n_u32
9544 // CHECK: vshr.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9545 uint32x2_t test_vshr_n_u32(uint32x2_t a) {
9546   return vshr_n_u32(a, 1);
9547 }
9548
9549 // CHECK-LABEL: test_vshr_n_u64
9550 // CHECK: vshr.u64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9551 uint64x1_t test_vshr_n_u64(uint64x1_t a) {
9552   return vshr_n_u64(a, 1);
9553 }
9554
9555 // CHECK-LABEL: test_vshrq_n_s8
9556 // CHECK: vshr.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9557 int8x16_t test_vshrq_n_s8(int8x16_t a) {
9558   return vshrq_n_s8(a, 1);
9559 }
9560
9561 // CHECK-LABEL: test_vshrq_n_s16
9562 // CHECK: vshr.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9563 int16x8_t test_vshrq_n_s16(int16x8_t a) {
9564   return vshrq_n_s16(a, 1);
9565 }
9566
9567 // CHECK-LABEL: test_vshrq_n_s32
9568 // CHECK: vshr.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9569 int32x4_t test_vshrq_n_s32(int32x4_t a) {
9570   return vshrq_n_s32(a, 1);
9571 }
9572
9573 // CHECK-LABEL: test_vshrq_n_s64
9574 // CHECK: vshr.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9575 int64x2_t test_vshrq_n_s64(int64x2_t a) {
9576   return vshrq_n_s64(a, 1);
9577 }
9578
9579 // CHECK-LABEL: test_vshrq_n_u8
9580 // CHECK: vshr.u8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9581 uint8x16_t test_vshrq_n_u8(uint8x16_t a) {
9582   return vshrq_n_u8(a, 1);
9583 }
9584
9585 // CHECK-LABEL: test_vshrq_n_u16
9586 // CHECK: vshr.u16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9587 uint16x8_t test_vshrq_n_u16(uint16x8_t a) {
9588   return vshrq_n_u16(a, 1);
9589 }
9590
9591 // CHECK-LABEL: test_vshrq_n_u32
9592 // CHECK: vshr.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9593 uint32x4_t test_vshrq_n_u32(uint32x4_t a) {
9594   return vshrq_n_u32(a, 1);
9595 }
9596
9597 // CHECK-LABEL: test_vshrq_n_u64
9598 // CHECK: vshr.u64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9599 uint64x2_t test_vshrq_n_u64(uint64x2_t a) {
9600   return vshrq_n_u64(a, 1);
9601 }
9602
9603
9604 // CHECK-LABEL: test_vsli_n_s8
9605 // CHECK: vsli.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9606 int8x8_t test_vsli_n_s8(int8x8_t a, int8x8_t b) {
9607   return vsli_n_s8(a, b, 1);
9608 }
9609
9610 // CHECK-LABEL: test_vsli_n_s16
9611 // CHECK: vsli.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9612 int16x4_t test_vsli_n_s16(int16x4_t a, int16x4_t b) {
9613   return vsli_n_s16(a, b, 1);
9614 }
9615
9616 // CHECK-LABEL: test_vsli_n_s32
9617 // CHECK: vsli.32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9618 int32x2_t test_vsli_n_s32(int32x2_t a, int32x2_t b) {
9619   return vsli_n_s32(a, b, 1);
9620 }
9621
9622 // CHECK-LABEL: test_vsli_n_s64
9623 // CHECK: vsli.64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9624 int64x1_t test_vsli_n_s64(int64x1_t a, int64x1_t b) {
9625   return vsli_n_s64(a, b, 1);
9626 }
9627
9628 // CHECK-LABEL: test_vsli_n_u8
9629 // CHECK: vsli.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9630 uint8x8_t test_vsli_n_u8(uint8x8_t a, uint8x8_t b) {
9631   return vsli_n_u8(a, b, 1);
9632 }
9633
9634 // CHECK-LABEL: test_vsli_n_u16
9635 // CHECK: vsli.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9636 uint16x4_t test_vsli_n_u16(uint16x4_t a, uint16x4_t b) {
9637   return vsli_n_u16(a, b, 1);
9638 }
9639
9640 // CHECK-LABEL: test_vsli_n_u32
9641 // CHECK: vsli.32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9642 uint32x2_t test_vsli_n_u32(uint32x2_t a, uint32x2_t b) {
9643   return vsli_n_u32(a, b, 1);
9644 }
9645
9646 // CHECK-LABEL: test_vsli_n_u64
9647 // CHECK: vsli.64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9648 uint64x1_t test_vsli_n_u64(uint64x1_t a, uint64x1_t b) {
9649   return vsli_n_u64(a, b, 1);
9650 }
9651
9652 // CHECK-LABEL: test_vsli_n_p8
9653 // CHECK: vsli.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9654 poly8x8_t test_vsli_n_p8(poly8x8_t a, poly8x8_t b) {
9655   return vsli_n_p8(a, b, 1);
9656 }
9657
9658 // CHECK-LABEL: test_vsli_n_p16
9659 // CHECK: vsli.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9660 poly16x4_t test_vsli_n_p16(poly16x4_t a, poly16x4_t b) {
9661   return vsli_n_p16(a, b, 1);
9662 }
9663
9664 // CHECK-LABEL: test_vsliq_n_s8
9665 // CHECK: vsli.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9666 int8x16_t test_vsliq_n_s8(int8x16_t a, int8x16_t b) {
9667   return vsliq_n_s8(a, b, 1);
9668 }
9669
9670 // CHECK-LABEL: test_vsliq_n_s16
9671 // CHECK: vsli.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9672 int16x8_t test_vsliq_n_s16(int16x8_t a, int16x8_t b) {
9673   return vsliq_n_s16(a, b, 1);
9674 }
9675
9676 // CHECK-LABEL: test_vsliq_n_s32
9677 // CHECK: vsli.32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9678 int32x4_t test_vsliq_n_s32(int32x4_t a, int32x4_t b) {
9679   return vsliq_n_s32(a, b, 1);
9680 }
9681
9682 // CHECK-LABEL: test_vsliq_n_s64
9683 // CHECK: vsli.64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9684 int64x2_t test_vsliq_n_s64(int64x2_t a, int64x2_t b) {
9685   return vsliq_n_s64(a, b, 1);
9686 }
9687
9688 // CHECK-LABEL: test_vsliq_n_u8
9689 // CHECK: vsli.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9690 uint8x16_t test_vsliq_n_u8(uint8x16_t a, uint8x16_t b) {
9691   return vsliq_n_u8(a, b, 1);
9692 }
9693
9694 // CHECK-LABEL: test_vsliq_n_u16
9695 // CHECK: vsli.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9696 uint16x8_t test_vsliq_n_u16(uint16x8_t a, uint16x8_t b) {
9697   return vsliq_n_u16(a, b, 1);
9698 }
9699
9700 // CHECK-LABEL: test_vsliq_n_u32
9701 // CHECK: vsli.32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9702 uint32x4_t test_vsliq_n_u32(uint32x4_t a, uint32x4_t b) {
9703   return vsliq_n_u32(a, b, 1);
9704 }
9705
9706 // CHECK-LABEL: test_vsliq_n_u64
9707 // CHECK: vsli.64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9708 uint64x2_t test_vsliq_n_u64(uint64x2_t a, uint64x2_t b) {
9709   return vsliq_n_u64(a, b, 1);
9710 }
9711
9712 // CHECK-LABEL: test_vsliq_n_p8
9713 // CHECK: vsli.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9714 poly8x16_t test_vsliq_n_p8(poly8x16_t a, poly8x16_t b) {
9715   return vsliq_n_p8(a, b, 1);
9716 }
9717
9718 // CHECK-LABEL: test_vsliq_n_p16
9719 // CHECK: vsli.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9720 poly16x8_t test_vsliq_n_p16(poly16x8_t a, poly16x8_t b) {
9721   return vsliq_n_p16(a, b, 1);
9722 }
9723
9724
9725 // CHECK-LABEL: test_vsra_n_s8
9726 // CHECK: vsra.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9727 int8x8_t test_vsra_n_s8(int8x8_t a, int8x8_t b) {
9728   return vsra_n_s8(a, b, 1);
9729 }
9730
9731 // CHECK-LABEL: test_vsra_n_s16
9732 // CHECK: vsra.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9733 int16x4_t test_vsra_n_s16(int16x4_t a, int16x4_t b) {
9734   return vsra_n_s16(a, b, 1);
9735 }
9736
9737 // CHECK-LABEL: test_vsra_n_s32
9738 // CHECK: vsra.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9739 int32x2_t test_vsra_n_s32(int32x2_t a, int32x2_t b) {
9740   return vsra_n_s32(a, b, 1);
9741 }
9742
9743 // CHECK-LABEL: test_vsra_n_s64
9744 // CHECK: vsra.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9745 int64x1_t test_vsra_n_s64(int64x1_t a, int64x1_t b) {
9746   return vsra_n_s64(a, b, 1);
9747 }
9748
9749 // CHECK-LABEL: test_vsra_n_u8
9750 // CHECK: vsra.u8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9751 uint8x8_t test_vsra_n_u8(uint8x8_t a, uint8x8_t b) {
9752   return vsra_n_u8(a, b, 1);
9753 }
9754
9755 // CHECK-LABEL: test_vsra_n_u16
9756 // CHECK: vsra.u16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9757 uint16x4_t test_vsra_n_u16(uint16x4_t a, uint16x4_t b) {
9758   return vsra_n_u16(a, b, 1);
9759 }
9760
9761 // CHECK-LABEL: test_vsra_n_u32
9762 // CHECK: vsra.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9763 uint32x2_t test_vsra_n_u32(uint32x2_t a, uint32x2_t b) {
9764   return vsra_n_u32(a, b, 1);
9765 }
9766
9767 // CHECK-LABEL: test_vsra_n_u64
9768 // CHECK: vsra.u64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9769 uint64x1_t test_vsra_n_u64(uint64x1_t a, uint64x1_t b) {
9770   return vsra_n_u64(a, b, 1);
9771 }
9772
9773 // CHECK-LABEL: test_vsraq_n_s8
9774 // CHECK: vsra.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9775 int8x16_t test_vsraq_n_s8(int8x16_t a, int8x16_t b) {
9776   return vsraq_n_s8(a, b, 1);
9777 }
9778
9779 // CHECK-LABEL: test_vsraq_n_s16
9780 // CHECK: vsra.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9781 int16x8_t test_vsraq_n_s16(int16x8_t a, int16x8_t b) {
9782   return vsraq_n_s16(a, b, 1);
9783 }
9784
9785 // CHECK-LABEL: test_vsraq_n_s32
9786 // CHECK: vsra.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9787 int32x4_t test_vsraq_n_s32(int32x4_t a, int32x4_t b) {
9788   return vsraq_n_s32(a, b, 1);
9789 }
9790
9791 // CHECK-LABEL: test_vsraq_n_s64
9792 // CHECK: vsra.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9793 int64x2_t test_vsraq_n_s64(int64x2_t a, int64x2_t b) {
9794   return vsraq_n_s64(a, b, 1);
9795 }
9796
9797 // CHECK-LABEL: test_vsraq_n_u8
9798 // CHECK: vsra.u8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9799 uint8x16_t test_vsraq_n_u8(uint8x16_t a, uint8x16_t b) {
9800   return vsraq_n_u8(a, b, 1);
9801 }
9802
9803 // CHECK-LABEL: test_vsraq_n_u16
9804 // CHECK: vsra.u16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9805 uint16x8_t test_vsraq_n_u16(uint16x8_t a, uint16x8_t b) {
9806   return vsraq_n_u16(a, b, 1);
9807 }
9808
9809 // CHECK-LABEL: test_vsraq_n_u32
9810 // CHECK: vsra.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9811 uint32x4_t test_vsraq_n_u32(uint32x4_t a, uint32x4_t b) {
9812   return vsraq_n_u32(a, b, 1);
9813 }
9814
9815 // CHECK-LABEL: test_vsraq_n_u64
9816 // CHECK: vsra.u64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9817 uint64x2_t test_vsraq_n_u64(uint64x2_t a, uint64x2_t b) {
9818   return vsraq_n_u64(a, b, 1);
9819 }
9820
9821
9822 // CHECK-LABEL: test_vsri_n_s8
9823 // CHECK: vsri.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9824 int8x8_t test_vsri_n_s8(int8x8_t a, int8x8_t b) {
9825   return vsri_n_s8(a, b, 1);
9826 }
9827
9828 // CHECK-LABEL: test_vsri_n_s16
9829 // CHECK: vsri.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9830 int16x4_t test_vsri_n_s16(int16x4_t a, int16x4_t b) {
9831   return vsri_n_s16(a, b, 1);
9832 }
9833
9834 // CHECK-LABEL: test_vsri_n_s32
9835 // CHECK: vsri.32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9836 int32x2_t test_vsri_n_s32(int32x2_t a, int32x2_t b) {
9837   return vsri_n_s32(a, b, 1);
9838 }
9839
9840 // CHECK-LABEL: test_vsri_n_s64
9841 // CHECK: vsri.64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9842 int64x1_t test_vsri_n_s64(int64x1_t a, int64x1_t b) {
9843   return vsri_n_s64(a, b, 1);
9844 }
9845
9846 // CHECK-LABEL: test_vsri_n_u8
9847 // CHECK: vsri.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9848 uint8x8_t test_vsri_n_u8(uint8x8_t a, uint8x8_t b) {
9849   return vsri_n_u8(a, b, 1);
9850 }
9851
9852 // CHECK-LABEL: test_vsri_n_u16
9853 // CHECK: vsri.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9854 uint16x4_t test_vsri_n_u16(uint16x4_t a, uint16x4_t b) {
9855   return vsri_n_u16(a, b, 1);
9856 }
9857
9858 // CHECK-LABEL: test_vsri_n_u32
9859 // CHECK: vsri.32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9860 uint32x2_t test_vsri_n_u32(uint32x2_t a, uint32x2_t b) {
9861   return vsri_n_u32(a, b, 1);
9862 }
9863
9864 // CHECK-LABEL: test_vsri_n_u64
9865 // CHECK: vsri.64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9866 uint64x1_t test_vsri_n_u64(uint64x1_t a, uint64x1_t b) {
9867   return vsri_n_u64(a, b, 1);
9868 }
9869
9870 // CHECK-LABEL: test_vsri_n_p8
9871 // CHECK: vsri.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9872 poly8x8_t test_vsri_n_p8(poly8x8_t a, poly8x8_t b) {
9873   return vsri_n_p8(a, b, 1);
9874 }
9875
9876 // CHECK-LABEL: test_vsri_n_p16
9877 // CHECK: vsri.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}}
9878 poly16x4_t test_vsri_n_p16(poly16x4_t a, poly16x4_t b) {
9879   return vsri_n_p16(a, b, 1);
9880 }
9881
9882 // CHECK-LABEL: test_vsriq_n_s8
9883 // CHECK: vsri.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9884 int8x16_t test_vsriq_n_s8(int8x16_t a, int8x16_t b) {
9885   return vsriq_n_s8(a, b, 1);
9886 }
9887
9888 // CHECK-LABEL: test_vsriq_n_s16
9889 // CHECK: vsri.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9890 int16x8_t test_vsriq_n_s16(int16x8_t a, int16x8_t b) {
9891   return vsriq_n_s16(a, b, 1);
9892 }
9893
9894 // CHECK-LABEL: test_vsriq_n_s32
9895 // CHECK: vsri.32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9896 int32x4_t test_vsriq_n_s32(int32x4_t a, int32x4_t b) {
9897   return vsriq_n_s32(a, b, 1);
9898 }
9899
9900 // CHECK-LABEL: test_vsriq_n_s64
9901 // CHECK: vsri.64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9902 int64x2_t test_vsriq_n_s64(int64x2_t a, int64x2_t b) {
9903   return vsriq_n_s64(a, b, 1);
9904 }
9905
9906 // CHECK-LABEL: test_vsriq_n_u8
9907 // CHECK: vsri.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9908 uint8x16_t test_vsriq_n_u8(uint8x16_t a, uint8x16_t b) {
9909   return vsriq_n_u8(a, b, 1);
9910 }
9911
9912 // CHECK-LABEL: test_vsriq_n_u16
9913 // CHECK: vsri.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9914 uint16x8_t test_vsriq_n_u16(uint16x8_t a, uint16x8_t b) {
9915   return vsriq_n_u16(a, b, 1);
9916 }
9917
9918 // CHECK-LABEL: test_vsriq_n_u32
9919 // CHECK: vsri.32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9920 uint32x4_t test_vsriq_n_u32(uint32x4_t a, uint32x4_t b) {
9921   return vsriq_n_u32(a, b, 1);
9922 }
9923
9924 // CHECK-LABEL: test_vsriq_n_u64
9925 // CHECK: vsri.64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9926 uint64x2_t test_vsriq_n_u64(uint64x2_t a, uint64x2_t b) {
9927   return vsriq_n_u64(a, b, 1);
9928 }
9929
9930 // CHECK-LABEL: test_vsriq_n_p8
9931 // CHECK: vsri.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9932 poly8x16_t test_vsriq_n_p8(poly8x16_t a, poly8x16_t b) {
9933   return vsriq_n_p8(a, b, 1);
9934 }
9935
9936 // CHECK-LABEL: test_vsriq_n_p16
9937 // CHECK: vsri.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}}
9938 poly16x8_t test_vsriq_n_p16(poly16x8_t a, poly16x8_t b) {
9939   return vsriq_n_p16(a, b, 1);
9940 }
9941
9942
9943 // CHECK-LABEL: test_vst1q_u8
9944 // CHECK: vst1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
9945 void test_vst1q_u8(uint8_t * a, uint8x16_t b) {
9946   vst1q_u8(a, b);
9947 }
9948
9949 // CHECK-LABEL: test_vst1q_u16
9950 // CHECK: vst1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
9951 void test_vst1q_u16(uint16_t * a, uint16x8_t b) {
9952   vst1q_u16(a, b);
9953 }
9954
9955 // CHECK-LABEL: test_vst1q_u32
9956 // CHECK: vst1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
9957 void test_vst1q_u32(uint32_t * a, uint32x4_t b) {
9958   vst1q_u32(a, b);
9959 }
9960
9961 // CHECK-LABEL: test_vst1q_u64
9962 // CHECK: vst1.64 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}]
9963 void test_vst1q_u64(uint64_t * a, uint64x2_t b) {
9964   vst1q_u64(a, b);
9965 }
9966
9967 // CHECK-LABEL: test_vst1q_s8
9968 // CHECK: vst1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
9969 void test_vst1q_s8(int8_t * a, int8x16_t b) {
9970   vst1q_s8(a, b);
9971 }
9972
9973 // CHECK-LABEL: test_vst1q_s16
9974 // CHECK: vst1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
9975 void test_vst1q_s16(int16_t * a, int16x8_t b) {
9976   vst1q_s16(a, b);
9977 }
9978
9979 // CHECK-LABEL: test_vst1q_s32
9980 // CHECK: vst1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
9981 void test_vst1q_s32(int32_t * a, int32x4_t b) {
9982   vst1q_s32(a, b);
9983 }
9984
9985 // CHECK-LABEL: test_vst1q_s64
9986 // CHECK: vst1.64 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}]
9987 void test_vst1q_s64(int64_t * a, int64x2_t b) {
9988   vst1q_s64(a, b);
9989 }
9990
9991 // CHECK-LABEL: test_vst1q_f16
9992 // CHECK: vst1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
9993 void test_vst1q_f16(float16_t * a, float16x8_t b) {
9994   vst1q_f16(a, b);
9995 }
9996
9997 // CHECK-LABEL: test_vst1q_f32
9998 // CHECK: vst1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
9999 void test_vst1q_f32(float32_t * a, float32x4_t b) {
10000   vst1q_f32(a, b);
10001 }
10002
10003 // CHECK-LABEL: test_vst1q_p8
10004 // CHECK: vst1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10005 void test_vst1q_p8(poly8_t * a, poly8x16_t b) {
10006   vst1q_p8(a, b);
10007 }
10008
10009 // CHECK-LABEL: test_vst1q_p16
10010 // CHECK: vst1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10011 void test_vst1q_p16(poly16_t * a, poly16x8_t b) {
10012   vst1q_p16(a, b);
10013 }
10014
10015 // CHECK-LABEL: test_vst1_u8
10016 // CHECK: vst1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}]
10017 void test_vst1_u8(uint8_t * a, uint8x8_t b) {
10018   vst1_u8(a, b);
10019 }
10020
10021 // CHECK-LABEL: test_vst1_u16
10022 // CHECK: vst1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}]
10023 void test_vst1_u16(uint16_t * a, uint16x4_t b) {
10024   vst1_u16(a, b);
10025 }
10026
10027 // CHECK-LABEL: test_vst1_u32
10028 // CHECK: vst1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}]
10029 void test_vst1_u32(uint32_t * a, uint32x2_t b) {
10030   vst1_u32(a, b);
10031 }
10032
10033 // CHECK-LABEL: test_vst1_u64
10034 // CHECK: vst1.64 {d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}]
10035 void test_vst1_u64(uint64_t * a, uint64x1_t b) {
10036   vst1_u64(a, b);
10037 }
10038
10039 // CHECK-LABEL: test_vst1_s8
10040 // CHECK: vst1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}]
10041 void test_vst1_s8(int8_t * a, int8x8_t b) {
10042   vst1_s8(a, b);
10043 }
10044
10045 // CHECK-LABEL: test_vst1_s16
10046 // CHECK: vst1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}]
10047 void test_vst1_s16(int16_t * a, int16x4_t b) {
10048   vst1_s16(a, b);
10049 }
10050
10051 // CHECK-LABEL: test_vst1_s32
10052 // CHECK: vst1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}]
10053 void test_vst1_s32(int32_t * a, int32x2_t b) {
10054   vst1_s32(a, b);
10055 }
10056
10057 // CHECK-LABEL: test_vst1_s64
10058 // CHECK: vst1.64 {d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}]
10059 void test_vst1_s64(int64_t * a, int64x1_t b) {
10060   vst1_s64(a, b);
10061 }
10062
10063 // CHECK-LABEL: test_vst1_f16
10064 // CHECK: vst1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}]
10065 void test_vst1_f16(float16_t * a, float16x4_t b) {
10066   vst1_f16(a, b);
10067 }
10068
10069 // CHECK-LABEL: test_vst1_f32
10070 // CHECK: vst1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}]
10071 void test_vst1_f32(float32_t * a, float32x2_t b) {
10072   vst1_f32(a, b);
10073 }
10074
10075 // CHECK-LABEL: test_vst1_p8
10076 // CHECK: vst1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}]
10077 void test_vst1_p8(poly8_t * a, poly8x8_t b) {
10078   vst1_p8(a, b);
10079 }
10080
10081 // CHECK-LABEL: test_vst1_p16
10082 // CHECK: vst1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}]
10083 void test_vst1_p16(poly16_t * a, poly16x4_t b) {
10084   vst1_p16(a, b);
10085 }
10086
10087
10088 // CHECK-LABEL: test_vst1q_lane_u8
10089 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10090 void test_vst1q_lane_u8(uint8_t * a, uint8x16_t b) {
10091   vst1q_lane_u8(a, b, 15);
10092 }
10093
10094 // CHECK-LABEL: test_vst1q_lane_u16
10095 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16]
10096 void test_vst1q_lane_u16(uint16_t * a, uint16x8_t b) {
10097   vst1q_lane_u16(a, b, 7);
10098 }
10099
10100 // CHECK-LABEL: test_vst1q_lane_u32
10101 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32]
10102 void test_vst1q_lane_u32(uint32_t * a, uint32x4_t b) {
10103   vst1q_lane_u32(a, b, 3);
10104 }
10105
10106 // CHECK-LABEL: test_vst1q_lane_u64
10107 // CHECK: {{str|vstr|vmov}}
10108 void test_vst1q_lane_u64(uint64_t * a, uint64x2_t b) {
10109   vst1q_lane_u64(a, b, 1);
10110 }
10111
10112 // CHECK-LABEL: test_vst1q_lane_s8
10113 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10114 void test_vst1q_lane_s8(int8_t * a, int8x16_t b) {
10115   vst1q_lane_s8(a, b, 15);
10116 }
10117
10118 // CHECK-LABEL: test_vst1q_lane_s16
10119 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16]
10120 void test_vst1q_lane_s16(int16_t * a, int16x8_t b) {
10121   vst1q_lane_s16(a, b, 7);
10122 }
10123
10124 // CHECK-LABEL: test_vst1q_lane_s32
10125 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32]
10126 void test_vst1q_lane_s32(int32_t * a, int32x4_t b) {
10127   vst1q_lane_s32(a, b, 3);
10128 }
10129
10130 // CHECK-LABEL: test_vst1q_lane_s64
10131 // CHECK: {{str|vstr|vmov}}
10132 void test_vst1q_lane_s64(int64_t * a, int64x2_t b) {
10133   vst1q_lane_s64(a, b, 1);
10134 }
10135
10136 // CHECK-LABEL: test_vst1q_lane_f16
10137 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16]
10138 void test_vst1q_lane_f16(float16_t * a, float16x8_t b) {
10139   vst1q_lane_f16(a, b, 7);
10140 }
10141
10142 // CHECK-LABEL: test_vst1q_lane_f32
10143 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32]
10144 void test_vst1q_lane_f32(float32_t * a, float32x4_t b) {
10145   vst1q_lane_f32(a, b, 3);
10146 }
10147
10148 // CHECK-LABEL: test_vst1q_lane_p8
10149 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10150 void test_vst1q_lane_p8(poly8_t * a, poly8x16_t b) {
10151   vst1q_lane_p8(a, b, 15);
10152 }
10153
10154 // CHECK-LABEL: test_vst1q_lane_p16
10155 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16]
10156 void test_vst1q_lane_p16(poly16_t * a, poly16x8_t b) {
10157   vst1q_lane_p16(a, b, 7);
10158 }
10159
10160 // CHECK-LABEL: test_vst1_lane_u8
10161 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10162 void test_vst1_lane_u8(uint8_t * a, uint8x8_t b) {
10163   vst1_lane_u8(a, b, 7);
10164 }
10165
10166 // CHECK-LABEL: test_vst1_lane_u16
10167 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16]
10168 void test_vst1_lane_u16(uint16_t * a, uint16x4_t b) {
10169   vst1_lane_u16(a, b, 3);
10170 }
10171
10172 // CHECK-LABEL: test_vst1_lane_u32
10173 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32]
10174 void test_vst1_lane_u32(uint32_t * a, uint32x2_t b) {
10175   vst1_lane_u32(a, b, 1);
10176 }
10177
10178 // CHECK-LABEL: test_vst1_lane_u64
10179 // CHECK: {{str|vstr|vmov}}
10180 void test_vst1_lane_u64(uint64_t * a, uint64x1_t b) {
10181   vst1_lane_u64(a, b, 0);
10182 }
10183
10184 // CHECK-LABEL: test_vst1_lane_s8
10185 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10186 void test_vst1_lane_s8(int8_t * a, int8x8_t b) {
10187   vst1_lane_s8(a, b, 7);
10188 }
10189
10190 // CHECK-LABEL: test_vst1_lane_s16
10191 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16]
10192 void test_vst1_lane_s16(int16_t * a, int16x4_t b) {
10193   vst1_lane_s16(a, b, 3);
10194 }
10195
10196 // CHECK-LABEL: test_vst1_lane_s32
10197 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32]
10198 void test_vst1_lane_s32(int32_t * a, int32x2_t b) {
10199   vst1_lane_s32(a, b, 1);
10200 }
10201
10202 // CHECK-LABEL: test_vst1_lane_s64
10203 // CHECK: {{str|vstr|vmov}}
10204 void test_vst1_lane_s64(int64_t * a, int64x1_t b) {
10205   vst1_lane_s64(a, b, 0);
10206 }
10207
10208 // CHECK-LABEL: test_vst1_lane_f16
10209 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16]
10210 void test_vst1_lane_f16(float16_t * a, float16x4_t b) {
10211   vst1_lane_f16(a, b, 3);
10212 }
10213
10214 // CHECK-LABEL: test_vst1_lane_f32
10215 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32]
10216 void test_vst1_lane_f32(float32_t * a, float32x2_t b) {
10217   vst1_lane_f32(a, b, 1);
10218 }
10219
10220 // CHECK-LABEL: test_vst1_lane_p8
10221 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10222 void test_vst1_lane_p8(poly8_t * a, poly8x8_t b) {
10223   vst1_lane_p8(a, b, 7);
10224 }
10225
10226 // CHECK-LABEL: test_vst1_lane_p16
10227 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16]
10228 void test_vst1_lane_p16(poly16_t * a, poly16x4_t b) {
10229   vst1_lane_p16(a, b, 3);
10230 }
10231
10232
10233 // CHECK-LABEL: test_vst2q_u8
10234 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10235 void test_vst2q_u8(uint8_t * a, uint8x16x2_t b) {
10236   vst2q_u8(a, b);
10237 }
10238
10239 // CHECK-LABEL: test_vst2q_u16
10240 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10241 void test_vst2q_u16(uint16_t * a, uint16x8x2_t b) {
10242   vst2q_u16(a, b);
10243 }
10244
10245 // CHECK-LABEL: test_vst2q_u32
10246 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10247 void test_vst2q_u32(uint32_t * a, uint32x4x2_t b) {
10248   vst2q_u32(a, b);
10249 }
10250
10251 // CHECK-LABEL: test_vst2q_s8
10252 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10253 void test_vst2q_s8(int8_t * a, int8x16x2_t b) {
10254   vst2q_s8(a, b);
10255 }
10256
10257 // CHECK-LABEL: test_vst2q_s16
10258 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10259 void test_vst2q_s16(int16_t * a, int16x8x2_t b) {
10260   vst2q_s16(a, b);
10261 }
10262
10263 // CHECK-LABEL: test_vst2q_s32
10264 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10265 void test_vst2q_s32(int32_t * a, int32x4x2_t b) {
10266   vst2q_s32(a, b);
10267 }
10268
10269 // CHECK-LABEL: test_vst2q_f16
10270 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10271 void test_vst2q_f16(float16_t * a, float16x8x2_t b) {
10272   vst2q_f16(a, b);
10273 }
10274
10275 // CHECK-LABEL: test_vst2q_f32
10276 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10277 void test_vst2q_f32(float32_t * a, float32x4x2_t b) {
10278   vst2q_f32(a, b);
10279 }
10280
10281 // CHECK-LABEL: test_vst2q_p8
10282 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10283 void test_vst2q_p8(poly8_t * a, poly8x16x2_t b) {
10284   vst2q_p8(a, b);
10285 }
10286
10287 // CHECK-LABEL: test_vst2q_p16
10288 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10289 void test_vst2q_p16(poly16_t * a, poly16x8x2_t b) {
10290   vst2q_p16(a, b);
10291 }
10292
10293 // CHECK-LABEL: test_vst2_u8
10294 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10295 void test_vst2_u8(uint8_t * a, uint8x8x2_t b) {
10296   vst2_u8(a, b);
10297 }
10298
10299 // CHECK-LABEL: test_vst2_u16
10300 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10301 void test_vst2_u16(uint16_t * a, uint16x4x2_t b) {
10302   vst2_u16(a, b);
10303 }
10304
10305 // CHECK-LABEL: test_vst2_u32
10306 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10307 void test_vst2_u32(uint32_t * a, uint32x2x2_t b) {
10308   vst2_u32(a, b);
10309 }
10310
10311 // CHECK-LABEL: test_vst2_u64
10312 // CHECK: vst1.64
10313 void test_vst2_u64(uint64_t * a, uint64x1x2_t b) {
10314   vst2_u64(a, b);
10315 }
10316
10317 // CHECK-LABEL: test_vst2_s8
10318 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10319 void test_vst2_s8(int8_t * a, int8x8x2_t b) {
10320   vst2_s8(a, b);
10321 }
10322
10323 // CHECK-LABEL: test_vst2_s16
10324 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10325 void test_vst2_s16(int16_t * a, int16x4x2_t b) {
10326   vst2_s16(a, b);
10327 }
10328
10329 // CHECK-LABEL: test_vst2_s32
10330 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10331 void test_vst2_s32(int32_t * a, int32x2x2_t b) {
10332   vst2_s32(a, b);
10333 }
10334
10335 // CHECK-LABEL: test_vst2_s64
10336 // CHECK: vst1.64
10337 void test_vst2_s64(int64_t * a, int64x1x2_t b) {
10338   vst2_s64(a, b);
10339 }
10340
10341 // CHECK-LABEL: test_vst2_f16
10342 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10343 void test_vst2_f16(float16_t * a, float16x4x2_t b) {
10344   vst2_f16(a, b);
10345 }
10346
10347 // CHECK-LABEL: test_vst2_f32
10348 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10349 void test_vst2_f32(float32_t * a, float32x2x2_t b) {
10350   vst2_f32(a, b);
10351 }
10352
10353 // CHECK-LABEL: test_vst2_p8
10354 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10355 void test_vst2_p8(poly8_t * a, poly8x8x2_t b) {
10356   vst2_p8(a, b);
10357 }
10358
10359 // CHECK-LABEL: test_vst2_p16
10360 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10361 void test_vst2_p16(poly16_t * a, poly16x4x2_t b) {
10362   vst2_p16(a, b);
10363 }
10364
10365
10366 // CHECK-LABEL: test_vst2q_lane_u16
10367 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10368 void test_vst2q_lane_u16(uint16_t * a, uint16x8x2_t b) {
10369   vst2q_lane_u16(a, b, 7);
10370 }
10371
10372 // CHECK-LABEL: test_vst2q_lane_u32
10373 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10374 void test_vst2q_lane_u32(uint32_t * a, uint32x4x2_t b) {
10375   vst2q_lane_u32(a, b, 3);
10376 }
10377
10378 // CHECK-LABEL: test_vst2q_lane_s16
10379 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10380 void test_vst2q_lane_s16(int16_t * a, int16x8x2_t b) {
10381   vst2q_lane_s16(a, b, 7);
10382 }
10383
10384 // CHECK-LABEL: test_vst2q_lane_s32
10385 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10386 void test_vst2q_lane_s32(int32_t * a, int32x4x2_t b) {
10387   vst2q_lane_s32(a, b, 3);
10388 }
10389
10390 // CHECK-LABEL: test_vst2q_lane_f16
10391 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10392 void test_vst2q_lane_f16(float16_t * a, float16x8x2_t b) {
10393   vst2q_lane_f16(a, b, 7);
10394 }
10395
10396 // CHECK-LABEL: test_vst2q_lane_f32
10397 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10398 void test_vst2q_lane_f32(float32_t * a, float32x4x2_t b) {
10399   vst2q_lane_f32(a, b, 3);
10400 }
10401
10402 // CHECK-LABEL: test_vst2q_lane_p16
10403 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10404 void test_vst2q_lane_p16(poly16_t * a, poly16x8x2_t b) {
10405   vst2q_lane_p16(a, b, 7);
10406 }
10407
10408 // CHECK-LABEL: test_vst2_lane_u8
10409 // CHECK: vst2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10410 void test_vst2_lane_u8(uint8_t * a, uint8x8x2_t b) {
10411   vst2_lane_u8(a, b, 7);
10412 }
10413
10414 // CHECK-LABEL: test_vst2_lane_u16
10415 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10416 void test_vst2_lane_u16(uint16_t * a, uint16x4x2_t b) {
10417   vst2_lane_u16(a, b, 3);
10418 }
10419
10420 // CHECK-LABEL: test_vst2_lane_u32
10421 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10422 void test_vst2_lane_u32(uint32_t * a, uint32x2x2_t b) {
10423   vst2_lane_u32(a, b, 1);
10424 }
10425
10426 // CHECK-LABEL: test_vst2_lane_s8
10427 // CHECK: vst2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10428 void test_vst2_lane_s8(int8_t * a, int8x8x2_t b) {
10429   vst2_lane_s8(a, b, 7);
10430 }
10431
10432 // CHECK-LABEL: test_vst2_lane_s16
10433 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10434 void test_vst2_lane_s16(int16_t * a, int16x4x2_t b) {
10435   vst2_lane_s16(a, b, 3);
10436 }
10437
10438 // CHECK-LABEL: test_vst2_lane_s32
10439 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10440 void test_vst2_lane_s32(int32_t * a, int32x2x2_t b) {
10441   vst2_lane_s32(a, b, 1);
10442 }
10443
10444 // CHECK-LABEL: test_vst2_lane_f16
10445 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10446 void test_vst2_lane_f16(float16_t * a, float16x4x2_t b) {
10447   vst2_lane_f16(a, b, 3);
10448 }
10449
10450 // CHECK-LABEL: test_vst2_lane_f32
10451 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10452 void test_vst2_lane_f32(float32_t * a, float32x2x2_t b) {
10453   vst2_lane_f32(a, b, 1);
10454 }
10455
10456 // CHECK-LABEL: test_vst2_lane_p8
10457 // CHECK: vst2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10458 void test_vst2_lane_p8(poly8_t * a, poly8x8x2_t b) {
10459   vst2_lane_p8(a, b, 7);
10460 }
10461
10462 // CHECK-LABEL: test_vst2_lane_p16
10463 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10464 void test_vst2_lane_p16(poly16_t * a, poly16x4x2_t b) {
10465   vst2_lane_p16(a, b, 3);
10466 }
10467
10468
10469 // CHECK-LABEL: test_vst3q_u8
10470 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10471 void test_vst3q_u8(uint8_t * a, uint8x16x3_t b) {
10472   vst3q_u8(a, b);
10473 }
10474
10475 // CHECK-LABEL: test_vst3q_u16
10476 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10477 void test_vst3q_u16(uint16_t * a, uint16x8x3_t b) {
10478   vst3q_u16(a, b);
10479 }
10480
10481 // CHECK-LABEL: test_vst3q_u32
10482 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10483 void test_vst3q_u32(uint32_t * a, uint32x4x3_t b) {
10484   vst3q_u32(a, b);
10485 }
10486
10487 // CHECK-LABEL: test_vst3q_s8
10488 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10489 void test_vst3q_s8(int8_t * a, int8x16x3_t b) {
10490   vst3q_s8(a, b);
10491 }
10492
10493 // CHECK-LABEL: test_vst3q_s16
10494 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10495 void test_vst3q_s16(int16_t * a, int16x8x3_t b) {
10496   vst3q_s16(a, b);
10497 }
10498
10499 // CHECK-LABEL: test_vst3q_s32
10500 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10501 void test_vst3q_s32(int32_t * a, int32x4x3_t b) {
10502   vst3q_s32(a, b);
10503 }
10504
10505 // CHECK-LABEL: test_vst3q_f16
10506 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10507 void test_vst3q_f16(float16_t * a, float16x8x3_t b) {
10508   vst3q_f16(a, b);
10509 }
10510
10511 // CHECK-LABEL: test_vst3q_f32
10512 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10513 void test_vst3q_f32(float32_t * a, float32x4x3_t b) {
10514   vst3q_f32(a, b);
10515 }
10516
10517 // CHECK-LABEL: test_vst3q_p8
10518 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10519 void test_vst3q_p8(poly8_t * a, poly8x16x3_t b) {
10520   vst3q_p8(a, b);
10521 }
10522
10523 // CHECK-LABEL: test_vst3q_p16
10524 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10525 void test_vst3q_p16(poly16_t * a, poly16x8x3_t b) {
10526   vst3q_p16(a, b);
10527 }
10528
10529 // CHECK-LABEL: test_vst3_u8
10530 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10531 void test_vst3_u8(uint8_t * a, uint8x8x3_t b) {
10532   vst3_u8(a, b);
10533 }
10534
10535 // CHECK-LABEL: test_vst3_u16
10536 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10537 void test_vst3_u16(uint16_t * a, uint16x4x3_t b) {
10538   vst3_u16(a, b);
10539 }
10540
10541 // CHECK-LABEL: test_vst3_u32
10542 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10543 void test_vst3_u32(uint32_t * a, uint32x2x3_t b) {
10544   vst3_u32(a, b);
10545 }
10546
10547 // CHECK-LABEL: test_vst3_u64
10548 // CHECK: vst1.64
10549 void test_vst3_u64(uint64_t * a, uint64x1x3_t b) {
10550   vst3_u64(a, b);
10551 }
10552
10553 // CHECK-LABEL: test_vst3_s8
10554 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10555 void test_vst3_s8(int8_t * a, int8x8x3_t b) {
10556   vst3_s8(a, b);
10557 }
10558
10559 // CHECK-LABEL: test_vst3_s16
10560 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10561 void test_vst3_s16(int16_t * a, int16x4x3_t b) {
10562   vst3_s16(a, b);
10563 }
10564
10565 // CHECK-LABEL: test_vst3_s32
10566 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10567 void test_vst3_s32(int32_t * a, int32x2x3_t b) {
10568   vst3_s32(a, b);
10569 }
10570
10571 // CHECK-LABEL: test_vst3_s64
10572 // CHECK: vst1.64
10573 void test_vst3_s64(int64_t * a, int64x1x3_t b) {
10574   vst3_s64(a, b);
10575 }
10576
10577 // CHECK-LABEL: test_vst3_f16
10578 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10579 void test_vst3_f16(float16_t * a, float16x4x3_t b) {
10580   vst3_f16(a, b);
10581 }
10582
10583 // CHECK-LABEL: test_vst3_f32
10584 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10585 void test_vst3_f32(float32_t * a, float32x2x3_t b) {
10586   vst3_f32(a, b);
10587 }
10588
10589 // CHECK-LABEL: test_vst3_p8
10590 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10591 void test_vst3_p8(poly8_t * a, poly8x8x3_t b) {
10592   vst3_p8(a, b);
10593 }
10594
10595 // CHECK-LABEL: test_vst3_p16
10596 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10597 void test_vst3_p16(poly16_t * a, poly16x4x3_t b) {
10598   vst3_p16(a, b);
10599 }
10600
10601
10602 // CHECK-LABEL: test_vst3q_lane_u16
10603 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
10604 void test_vst3q_lane_u16(uint16_t * a, uint16x8x3_t b) {
10605   vst3q_lane_u16(a, b, 7);
10606 }
10607
10608 // CHECK-LABEL: test_vst3q_lane_u32
10609 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
10610 void test_vst3q_lane_u32(uint32_t * a, uint32x4x3_t b) {
10611   vst3q_lane_u32(a, b, 3);
10612 }
10613
10614 // CHECK-LABEL: test_vst3q_lane_s16
10615 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
10616 void test_vst3q_lane_s16(int16_t * a, int16x8x3_t b) {
10617   vst3q_lane_s16(a, b, 7);
10618 }
10619
10620 // CHECK-LABEL: test_vst3q_lane_s32
10621 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
10622 void test_vst3q_lane_s32(int32_t * a, int32x4x3_t b) {
10623   vst3q_lane_s32(a, b, 3);
10624 }
10625
10626 // CHECK-LABEL: test_vst3q_lane_f16
10627 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
10628 void test_vst3q_lane_f16(float16_t * a, float16x8x3_t b) {
10629   vst3q_lane_f16(a, b, 7);
10630 }
10631
10632 // CHECK-LABEL: test_vst3q_lane_f32
10633 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
10634 void test_vst3q_lane_f32(float32_t * a, float32x4x3_t b) {
10635   vst3q_lane_f32(a, b, 3);
10636 }
10637
10638 // CHECK-LABEL: test_vst3q_lane_p16
10639 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
10640 void test_vst3q_lane_p16(poly16_t * a, poly16x8x3_t b) {
10641   vst3q_lane_p16(a, b, 7);
10642 }
10643
10644 // CHECK-LABEL: test_vst3_lane_u8
10645 // CHECK: vst3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10646 void test_vst3_lane_u8(uint8_t * a, uint8x8x3_t b) {
10647   vst3_lane_u8(a, b, 7);
10648 }
10649
10650 // CHECK-LABEL: test_vst3_lane_u16
10651 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10652 void test_vst3_lane_u16(uint16_t * a, uint16x4x3_t b) {
10653   vst3_lane_u16(a, b, 3);
10654 }
10655
10656 // CHECK-LABEL: test_vst3_lane_u32
10657 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10658 void test_vst3_lane_u32(uint32_t * a, uint32x2x3_t b) {
10659   vst3_lane_u32(a, b, 1);
10660 }
10661
10662 // CHECK-LABEL: test_vst3_lane_s8
10663 // CHECK: vst3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10664 void test_vst3_lane_s8(int8_t * a, int8x8x3_t b) {
10665   vst3_lane_s8(a, b, 7);
10666 }
10667
10668 // CHECK-LABEL: test_vst3_lane_s16
10669 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10670 void test_vst3_lane_s16(int16_t * a, int16x4x3_t b) {
10671   vst3_lane_s16(a, b, 3);
10672 }
10673
10674 // CHECK-LABEL: test_vst3_lane_s32
10675 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10676 void test_vst3_lane_s32(int32_t * a, int32x2x3_t b) {
10677   vst3_lane_s32(a, b, 1);
10678 }
10679
10680 // CHECK-LABEL: test_vst3_lane_f16
10681 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10682 void test_vst3_lane_f16(float16_t * a, float16x4x3_t b) {
10683   vst3_lane_f16(a, b, 3);
10684 }
10685
10686 // CHECK-LABEL: test_vst3_lane_f32
10687 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10688 void test_vst3_lane_f32(float32_t * a, float32x2x3_t b) {
10689   vst3_lane_f32(a, b, 1);
10690 }
10691
10692 // CHECK-LABEL: test_vst3_lane_p8
10693 // CHECK: vst3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10694 void test_vst3_lane_p8(poly8_t * a, poly8x8x3_t b) {
10695   vst3_lane_p8(a, b, 7);
10696 }
10697
10698 // CHECK-LABEL: test_vst3_lane_p16
10699 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10700 void test_vst3_lane_p16(poly16_t * a, poly16x4x3_t b) {
10701   vst3_lane_p16(a, b, 3);
10702 }
10703
10704
10705 // CHECK-LABEL: test_vst4q_u8
10706 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10707 void test_vst4q_u8(uint8_t * a, uint8x16x4_t b) {
10708   vst4q_u8(a, b);
10709 }
10710
10711 // CHECK-LABEL: test_vst4q_u16
10712 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10713 void test_vst4q_u16(uint16_t * a, uint16x8x4_t b) {
10714   vst4q_u16(a, b);
10715 }
10716
10717 // CHECK-LABEL: test_vst4q_u32
10718 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10719 void test_vst4q_u32(uint32_t * a, uint32x4x4_t b) {
10720   vst4q_u32(a, b);
10721 }
10722
10723 // CHECK-LABEL: test_vst4q_s8
10724 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10725 void test_vst4q_s8(int8_t * a, int8x16x4_t b) {
10726   vst4q_s8(a, b);
10727 }
10728
10729 // CHECK-LABEL: test_vst4q_s16
10730 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10731 void test_vst4q_s16(int16_t * a, int16x8x4_t b) {
10732   vst4q_s16(a, b);
10733 }
10734
10735 // CHECK-LABEL: test_vst4q_s32
10736 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10737 void test_vst4q_s32(int32_t * a, int32x4x4_t b) {
10738   vst4q_s32(a, b);
10739 }
10740
10741 // CHECK-LABEL: test_vst4q_f16
10742 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10743 void test_vst4q_f16(float16_t * a, float16x8x4_t b) {
10744   vst4q_f16(a, b);
10745 }
10746
10747 // CHECK-LABEL: test_vst4q_f32
10748 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10749 void test_vst4q_f32(float32_t * a, float32x4x4_t b) {
10750   vst4q_f32(a, b);
10751 }
10752
10753 // CHECK-LABEL: test_vst4q_p8
10754 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10755 void test_vst4q_p8(poly8_t * a, poly8x16x4_t b) {
10756   vst4q_p8(a, b);
10757 }
10758
10759 // CHECK-LABEL: test_vst4q_p16
10760 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}
10761 void test_vst4q_p16(poly16_t * a, poly16x8x4_t b) {
10762   vst4q_p16(a, b);
10763 }
10764
10765 // CHECK-LABEL: test_vst4_u8
10766 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10767 void test_vst4_u8(uint8_t * a, uint8x8x4_t b) {
10768   vst4_u8(a, b);
10769 }
10770
10771 // CHECK-LABEL: test_vst4_u16
10772 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10773 void test_vst4_u16(uint16_t * a, uint16x4x4_t b) {
10774   vst4_u16(a, b);
10775 }
10776
10777 // CHECK-LABEL: test_vst4_u32
10778 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10779 void test_vst4_u32(uint32_t * a, uint32x2x4_t b) {
10780   vst4_u32(a, b);
10781 }
10782
10783 // CHECK-LABEL: test_vst4_u64
10784 // CHECK: vst1.64
10785 void test_vst4_u64(uint64_t * a, uint64x1x4_t b) {
10786   vst4_u64(a, b);
10787 }
10788
10789 // CHECK-LABEL: test_vst4_s8
10790 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10791 void test_vst4_s8(int8_t * a, int8x8x4_t b) {
10792   vst4_s8(a, b);
10793 }
10794
10795 // CHECK-LABEL: test_vst4_s16
10796 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10797 void test_vst4_s16(int16_t * a, int16x4x4_t b) {
10798   vst4_s16(a, b);
10799 }
10800
10801 // CHECK-LABEL: test_vst4_s32
10802 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10803 void test_vst4_s32(int32_t * a, int32x2x4_t b) {
10804   vst4_s32(a, b);
10805 }
10806
10807 // CHECK-LABEL: test_vst4_s64
10808 // CHECK: vst1.64
10809 void test_vst4_s64(int64_t * a, int64x1x4_t b) {
10810   vst4_s64(a, b);
10811 }
10812
10813 // CHECK-LABEL: test_vst4_f16
10814 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10815 void test_vst4_f16(float16_t * a, float16x4x4_t b) {
10816   vst4_f16(a, b);
10817 }
10818
10819 // CHECK-LABEL: test_vst4_f32
10820 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10821 void test_vst4_f32(float32_t * a, float32x2x4_t b) {
10822   vst4_f32(a, b);
10823 }
10824
10825 // CHECK-LABEL: test_vst4_p8
10826 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10827 void test_vst4_p8(poly8_t * a, poly8x8x4_t b) {
10828   vst4_p8(a, b);
10829 }
10830
10831 // CHECK-LABEL: test_vst4_p16
10832 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}]
10833 void test_vst4_p16(poly16_t * a, poly16x4x4_t b) {
10834   vst4_p16(a, b);
10835 }
10836
10837
10838 // CHECK-LABEL: test_vst4q_lane_u16
10839 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
10840 void test_vst4q_lane_u16(uint16_t * a, uint16x8x4_t b) {
10841   vst4q_lane_u16(a, b, 7);
10842 }
10843
10844 // CHECK-LABEL: test_vst4q_lane_u32
10845 // CHECK: vst4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
10846 void test_vst4q_lane_u32(uint32_t * a, uint32x4x4_t b) {
10847   vst4q_lane_u32(a, b, 3);
10848 }
10849
10850 // CHECK-LABEL: test_vst4q_lane_s16
10851 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
10852 void test_vst4q_lane_s16(int16_t * a, int16x8x4_t b) {
10853   vst4q_lane_s16(a, b, 7);
10854 }
10855
10856 // CHECK-LABEL: test_vst4q_lane_s32
10857 // CHECK: vst4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
10858 void test_vst4q_lane_s32(int32_t * a, int32x4x4_t b) {
10859   vst4q_lane_s32(a, b, 3);
10860 }
10861
10862 // CHECK-LABEL: test_vst4q_lane_f16
10863 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
10864 void test_vst4q_lane_f16(float16_t * a, float16x8x4_t b) {
10865   vst4q_lane_f16(a, b, 7);
10866 }
10867
10868 // CHECK-LABEL: test_vst4q_lane_f32
10869 // CHECK: vst4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
10870 void test_vst4q_lane_f32(float32_t * a, float32x4x4_t b) {
10871   vst4q_lane_f32(a, b, 3);
10872 }
10873
10874 // CHECK-LABEL: test_vst4q_lane_p16
10875 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}
10876 void test_vst4q_lane_p16(poly16_t * a, poly16x8x4_t b) {
10877   vst4q_lane_p16(a, b, 7);
10878 }
10879
10880 // CHECK-LABEL: test_vst4_lane_u8
10881 // CHECK: vst4.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10882 void test_vst4_lane_u8(uint8_t * a, uint8x8x4_t b) {
10883   vst4_lane_u8(a, b, 7);
10884 }
10885
10886 // CHECK-LABEL: test_vst4_lane_u16
10887 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10888 void test_vst4_lane_u16(uint16_t * a, uint16x4x4_t b) {
10889   vst4_lane_u16(a, b, 3);
10890 }
10891
10892 // CHECK-LABEL: test_vst4_lane_u32
10893 // CHECK: vst4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10894 void test_vst4_lane_u32(uint32_t * a, uint32x2x4_t b) {
10895   vst4_lane_u32(a, b, 1);
10896 }
10897
10898 // CHECK-LABEL: test_vst4_lane_s8
10899 // CHECK: vst4.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10900 void test_vst4_lane_s8(int8_t * a, int8x8x4_t b) {
10901   vst4_lane_s8(a, b, 7);
10902 }
10903
10904 // CHECK-LABEL: test_vst4_lane_s16
10905 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10906 void test_vst4_lane_s16(int16_t * a, int16x4x4_t b) {
10907   vst4_lane_s16(a, b, 3);
10908 }
10909
10910 // CHECK-LABEL: test_vst4_lane_s32
10911 // CHECK: vst4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10912 void test_vst4_lane_s32(int32_t * a, int32x2x4_t b) {
10913   vst4_lane_s32(a, b, 1);
10914 }
10915
10916 // CHECK-LABEL: test_vst4_lane_f16
10917 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10918 void test_vst4_lane_f16(float16_t * a, float16x4x4_t b) {
10919   vst4_lane_f16(a, b, 3);
10920 }
10921
10922 // CHECK-LABEL: test_vst4_lane_f32
10923 // CHECK: vst4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10924 void test_vst4_lane_f32(float32_t * a, float32x2x4_t b) {
10925   vst4_lane_f32(a, b, 1);
10926 }
10927
10928 // CHECK-LABEL: test_vst4_lane_p8
10929 // CHECK: vst4.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10930 void test_vst4_lane_p8(poly8_t * a, poly8x8x4_t b) {
10931   vst4_lane_p8(a, b, 7);
10932 }
10933
10934 // CHECK-LABEL: test_vst4_lane_p16
10935 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}]
10936 void test_vst4_lane_p16(poly16_t * a, poly16x4x4_t b) {
10937   vst4_lane_p16(a, b, 3);
10938 }
10939
10940
10941 // CHECK-LABEL: test_vsub_s8
10942 // CHECK: vsub.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
10943 int8x8_t test_vsub_s8(int8x8_t a, int8x8_t b) {
10944   return vsub_s8(a, b);
10945 }
10946
10947 // CHECK-LABEL: test_vsub_s16
10948 // CHECK: vsub.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
10949 int16x4_t test_vsub_s16(int16x4_t a, int16x4_t b) {
10950   return vsub_s16(a, b);
10951 }
10952
10953 // CHECK-LABEL: test_vsub_s32
10954 // CHECK: vsub.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
10955 int32x2_t test_vsub_s32(int32x2_t a, int32x2_t b) {
10956   return vsub_s32(a, b);
10957 }
10958
10959 // CHECK-LABEL: test_vsub_s64
10960 // CHECK: vsub.i64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
10961 int64x1_t test_vsub_s64(int64x1_t a, int64x1_t b) {
10962   return vsub_s64(a, b);
10963 }
10964
10965 // CHECK-LABEL: test_vsub_f32
10966 // CHECK: vsub.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
10967 float32x2_t test_vsub_f32(float32x2_t a, float32x2_t b) {
10968   return vsub_f32(a, b);
10969 }
10970
10971 // CHECK-LABEL: test_vsub_u8
10972 // CHECK: vsub.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
10973 uint8x8_t test_vsub_u8(uint8x8_t a, uint8x8_t b) {
10974   return vsub_u8(a, b);
10975 }
10976
10977 // CHECK-LABEL: test_vsub_u16
10978 // CHECK: vsub.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
10979 uint16x4_t test_vsub_u16(uint16x4_t a, uint16x4_t b) {
10980   return vsub_u16(a, b);
10981 }
10982
10983 // CHECK-LABEL: test_vsub_u32
10984 // CHECK: vsub.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
10985 uint32x2_t test_vsub_u32(uint32x2_t a, uint32x2_t b) {
10986   return vsub_u32(a, b);
10987 }
10988
10989 // CHECK-LABEL: test_vsub_u64
10990 // CHECK: vsub.i64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
10991 uint64x1_t test_vsub_u64(uint64x1_t a, uint64x1_t b) {
10992   return vsub_u64(a, b);
10993 }
10994
10995 // CHECK-LABEL: test_vsubq_s8
10996 // CHECK: vsub.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
10997 int8x16_t test_vsubq_s8(int8x16_t a, int8x16_t b) {
10998   return vsubq_s8(a, b);
10999 }
11000
11001 // CHECK-LABEL: test_vsubq_s16
11002 // CHECK: vsub.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11003 int16x8_t test_vsubq_s16(int16x8_t a, int16x8_t b) {
11004   return vsubq_s16(a, b);
11005 }
11006
11007 // CHECK-LABEL: test_vsubq_s32
11008 // CHECK: vsub.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11009 int32x4_t test_vsubq_s32(int32x4_t a, int32x4_t b) {
11010   return vsubq_s32(a, b);
11011 }
11012
11013 // CHECK-LABEL: test_vsubq_s64
11014 // CHECK: vsub.i64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11015 int64x2_t test_vsubq_s64(int64x2_t a, int64x2_t b) {
11016   return vsubq_s64(a, b);
11017 }
11018
11019 // CHECK-LABEL: test_vsubq_f32
11020 // CHECK: vsub.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11021 float32x4_t test_vsubq_f32(float32x4_t a, float32x4_t b) {
11022   return vsubq_f32(a, b);
11023 }
11024
11025 // CHECK-LABEL: test_vsubq_u8
11026 // CHECK: vsub.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11027 uint8x16_t test_vsubq_u8(uint8x16_t a, uint8x16_t b) {
11028   return vsubq_u8(a, b);
11029 }
11030
11031 // CHECK-LABEL: test_vsubq_u16
11032 // CHECK: vsub.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11033 uint16x8_t test_vsubq_u16(uint16x8_t a, uint16x8_t b) {
11034   return vsubq_u16(a, b);
11035 }
11036
11037 // CHECK-LABEL: test_vsubq_u32
11038 // CHECK: vsub.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11039 uint32x4_t test_vsubq_u32(uint32x4_t a, uint32x4_t b) {
11040   return vsubq_u32(a, b);
11041 }
11042
11043 // CHECK-LABEL: test_vsubq_u64
11044 // CHECK: vsub.i64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11045 uint64x2_t test_vsubq_u64(uint64x2_t a, uint64x2_t b) {
11046   return vsubq_u64(a, b);
11047 }
11048
11049
11050 // CHECK-LABEL: test_vsubhn_s16
11051 // CHECK: vsubhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11052 int8x8_t test_vsubhn_s16(int16x8_t a, int16x8_t b) {
11053   return vsubhn_s16(a, b);
11054 }
11055
11056 // CHECK-LABEL: test_vsubhn_s32
11057 // CHECK: vsubhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11058 int16x4_t test_vsubhn_s32(int32x4_t a, int32x4_t b) {
11059   return vsubhn_s32(a, b);
11060 }
11061
11062 // CHECK-LABEL: test_vsubhn_s64
11063 // CHECK: vsubhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11064 int32x2_t test_vsubhn_s64(int64x2_t a, int64x2_t b) {
11065   return vsubhn_s64(a, b);
11066 }
11067
11068 // CHECK-LABEL: test_vsubhn_u16
11069 // CHECK: vsubhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11070 uint8x8_t test_vsubhn_u16(uint16x8_t a, uint16x8_t b) {
11071   return vsubhn_u16(a, b);
11072 }
11073
11074 // CHECK-LABEL: test_vsubhn_u32
11075 // CHECK: vsubhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11076 uint16x4_t test_vsubhn_u32(uint32x4_t a, uint32x4_t b) {
11077   return vsubhn_u32(a, b);
11078 }
11079
11080 // CHECK-LABEL: test_vsubhn_u64
11081 // CHECK: vsubhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11082 uint32x2_t test_vsubhn_u64(uint64x2_t a, uint64x2_t b) {
11083   return vsubhn_u64(a, b);
11084 }
11085
11086
11087 // CHECK-LABEL: test_vsubl_s8
11088 // CHECK: vsubl.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
11089 int16x8_t test_vsubl_s8(int8x8_t a, int8x8_t b) {
11090   return vsubl_s8(a, b);
11091 }
11092
11093 // CHECK-LABEL: test_vsubl_s16
11094 // CHECK: vsubl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
11095 int32x4_t test_vsubl_s16(int16x4_t a, int16x4_t b) {
11096   return vsubl_s16(a, b);
11097 }
11098
11099 // CHECK-LABEL: test_vsubl_s32
11100 // CHECK: vsubl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
11101 int64x2_t test_vsubl_s32(int32x2_t a, int32x2_t b) {
11102   return vsubl_s32(a, b);
11103 }
11104
11105 // CHECK-LABEL: test_vsubl_u8
11106 // CHECK: vsubl.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
11107 uint16x8_t test_vsubl_u8(uint8x8_t a, uint8x8_t b) {
11108   return vsubl_u8(a, b);
11109 }
11110
11111 // CHECK-LABEL: test_vsubl_u16
11112 // CHECK: vsubl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
11113 uint32x4_t test_vsubl_u16(uint16x4_t a, uint16x4_t b) {
11114   return vsubl_u16(a, b);
11115 }
11116
11117 // CHECK-LABEL: test_vsubl_u32
11118 // CHECK: vsubl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
11119 uint64x2_t test_vsubl_u32(uint32x2_t a, uint32x2_t b) {
11120   return vsubl_u32(a, b);
11121 }
11122
11123
11124 // CHECK-LABEL: test_vsubw_s8
11125 // CHECK: vsubw.s8 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}
11126 int16x8_t test_vsubw_s8(int16x8_t a, int8x8_t b) {
11127   return vsubw_s8(a, b);
11128 }
11129
11130 // CHECK-LABEL: test_vsubw_s16
11131 // CHECK: vsubw.s16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}
11132 int32x4_t test_vsubw_s16(int32x4_t a, int16x4_t b) {
11133   return vsubw_s16(a, b);
11134 }
11135
11136 // CHECK-LABEL: test_vsubw_s32
11137 // CHECK: vsubw.s32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}
11138 int64x2_t test_vsubw_s32(int64x2_t a, int32x2_t b) {
11139   return vsubw_s32(a, b);
11140 }
11141
11142 // CHECK-LABEL: test_vsubw_u8
11143 // CHECK: vsubw.u8 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}
11144 uint16x8_t test_vsubw_u8(uint16x8_t a, uint8x8_t b) {
11145   return vsubw_u8(a, b);
11146 }
11147
11148 // CHECK-LABEL: test_vsubw_u16
11149 // CHECK: vsubw.u16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}
11150 uint32x4_t test_vsubw_u16(uint32x4_t a, uint16x4_t b) {
11151   return vsubw_u16(a, b);
11152 }
11153
11154 // CHECK-LABEL: test_vsubw_u32
11155 // CHECK: vsubw.u32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}
11156 uint64x2_t test_vsubw_u32(uint64x2_t a, uint32x2_t b) {
11157   return vsubw_u32(a, b);
11158 }
11159
11160
11161 // CHECK-LABEL: test_vtbl1_u8
11162 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}}
11163 uint8x8_t test_vtbl1_u8(uint8x8_t a, uint8x8_t b) {
11164   return vtbl1_u8(a, b);
11165 }
11166
11167 // CHECK-LABEL: test_vtbl1_s8
11168 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}}
11169 int8x8_t test_vtbl1_s8(int8x8_t a, int8x8_t b) {
11170   return vtbl1_s8(a, b);
11171 }
11172
11173 // CHECK-LABEL: test_vtbl1_p8
11174 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}}
11175 poly8x8_t test_vtbl1_p8(poly8x8_t a, uint8x8_t b) {
11176   return vtbl1_p8(a, b);
11177 }
11178
11179
11180 // CHECK-LABEL: test_vtbl2_u8
11181 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11182 uint8x8_t test_vtbl2_u8(uint8x8x2_t a, uint8x8_t b) {
11183   return vtbl2_u8(a, b);
11184 }
11185
11186 // CHECK-LABEL: test_vtbl2_s8
11187 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11188 int8x8_t test_vtbl2_s8(int8x8x2_t a, int8x8_t b) {
11189   return vtbl2_s8(a, b);
11190 }
11191
11192 // CHECK-LABEL: test_vtbl2_p8
11193 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11194 poly8x8_t test_vtbl2_p8(poly8x8x2_t a, uint8x8_t b) {
11195   return vtbl2_p8(a, b);
11196 }
11197
11198
11199 // CHECK-LABEL: test_vtbl3_u8
11200 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11201 uint8x8_t test_vtbl3_u8(uint8x8x3_t a, uint8x8_t b) {
11202   return vtbl3_u8(a, b);
11203 }
11204
11205 // CHECK-LABEL: test_vtbl3_s8
11206 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11207 int8x8_t test_vtbl3_s8(int8x8x3_t a, int8x8_t b) {
11208   return vtbl3_s8(a, b);
11209 }
11210
11211 // CHECK-LABEL: test_vtbl3_p8
11212 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11213 poly8x8_t test_vtbl3_p8(poly8x8x3_t a, uint8x8_t b) {
11214   return vtbl3_p8(a, b);
11215 }
11216
11217
11218 // CHECK-LABEL: test_vtbl4_u8
11219 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11220 uint8x8_t test_vtbl4_u8(uint8x8x4_t a, uint8x8_t b) {
11221   return vtbl4_u8(a, b);
11222 }
11223
11224 // CHECK-LABEL: test_vtbl4_s8
11225 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11226 int8x8_t test_vtbl4_s8(int8x8x4_t a, int8x8_t b) {
11227   return vtbl4_s8(a, b);
11228 }
11229
11230 // CHECK-LABEL: test_vtbl4_p8
11231 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11232 poly8x8_t test_vtbl4_p8(poly8x8x4_t a, uint8x8_t b) {
11233   return vtbl4_p8(a, b);
11234 }
11235
11236
11237 // CHECK-LABEL: test_vtbx1_u8
11238 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}}
11239 uint8x8_t test_vtbx1_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) {
11240   return vtbx1_u8(a, b, c);
11241 }
11242
11243 // CHECK-LABEL: test_vtbx1_s8
11244 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}}
11245 int8x8_t test_vtbx1_s8(int8x8_t a, int8x8_t b, int8x8_t c) {
11246   return vtbx1_s8(a, b, c);
11247 }
11248
11249 // CHECK-LABEL: test_vtbx1_p8
11250 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}}
11251 poly8x8_t test_vtbx1_p8(poly8x8_t a, poly8x8_t b, uint8x8_t c) {
11252   return vtbx1_p8(a, b, c);
11253 }
11254
11255
11256 // CHECK-LABEL: test_vtbx2_u8
11257 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11258 uint8x8_t test_vtbx2_u8(uint8x8_t a, uint8x8x2_t b, uint8x8_t c) {
11259   return vtbx2_u8(a, b, c);
11260 }
11261
11262 // CHECK-LABEL: test_vtbx2_s8
11263 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11264 int8x8_t test_vtbx2_s8(int8x8_t a, int8x8x2_t b, int8x8_t c) {
11265   return vtbx2_s8(a, b, c);
11266 }
11267
11268 // CHECK-LABEL: test_vtbx2_p8
11269 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11270 poly8x8_t test_vtbx2_p8(poly8x8_t a, poly8x8x2_t b, uint8x8_t c) {
11271   return vtbx2_p8(a, b, c);
11272 }
11273
11274
11275 // CHECK-LABEL: test_vtbx3_u8
11276 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11277 uint8x8_t test_vtbx3_u8(uint8x8_t a, uint8x8x3_t b, uint8x8_t c) {
11278   return vtbx3_u8(a, b, c);
11279 }
11280
11281 // CHECK-LABEL: test_vtbx3_s8
11282 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11283 int8x8_t test_vtbx3_s8(int8x8_t a, int8x8x3_t b, int8x8_t c) {
11284   return vtbx3_s8(a, b, c);
11285 }
11286
11287 // CHECK-LABEL: test_vtbx3_p8
11288 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11289 poly8x8_t test_vtbx3_p8(poly8x8_t a, poly8x8x3_t b, uint8x8_t c) {
11290   return vtbx3_p8(a, b, c);
11291 }
11292
11293
11294 // CHECK-LABEL: test_vtbx4_u8
11295 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11296 uint8x8_t test_vtbx4_u8(uint8x8_t a, uint8x8x4_t b, uint8x8_t c) {
11297   return vtbx4_u8(a, b, c);
11298 }
11299
11300 // CHECK-LABEL: test_vtbx4_s8
11301 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11302 int8x8_t test_vtbx4_s8(int8x8_t a, int8x8x4_t b, int8x8_t c) {
11303   return vtbx4_s8(a, b, c);
11304 }
11305
11306 // CHECK-LABEL: test_vtbx4_p8
11307 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}}
11308 poly8x8_t test_vtbx4_p8(poly8x8_t a, poly8x8x4_t b, uint8x8_t c) {
11309   return vtbx4_p8(a, b, c);
11310 }
11311
11312
11313 // CHECK-LABEL: test_vtrn_s8
11314 // CHECK: vtrn.8 d{{[0-9]+}}, d{{[0-9]+}}
11315 int8x8x2_t test_vtrn_s8(int8x8_t a, int8x8_t b) {
11316   return vtrn_s8(a, b);
11317 }
11318
11319 // CHECK-LABEL: test_vtrn_s16
11320 // CHECK: vtrn.16 d{{[0-9]+}}, d{{[0-9]+}}
11321 int16x4x2_t test_vtrn_s16(int16x4_t a, int16x4_t b) {
11322   return vtrn_s16(a, b);
11323 }
11324
11325 // CHECK-LABEL: test_vtrn_s32
11326 // CHECK: vtrn.32 d{{[0-9]+}}, d{{[0-9]+}}
11327 int32x2x2_t test_vtrn_s32(int32x2_t a, int32x2_t b) {
11328   return vtrn_s32(a, b);
11329 }
11330
11331 // CHECK-LABEL: test_vtrn_u8
11332 // CHECK: vtrn.8 d{{[0-9]+}}, d{{[0-9]+}}
11333 uint8x8x2_t test_vtrn_u8(uint8x8_t a, uint8x8_t b) {
11334   return vtrn_u8(a, b);
11335 }
11336
11337 // CHECK-LABEL: test_vtrn_u16
11338 // CHECK: vtrn.16 d{{[0-9]+}}, d{{[0-9]+}}
11339 uint16x4x2_t test_vtrn_u16(uint16x4_t a, uint16x4_t b) {
11340   return vtrn_u16(a, b);
11341 }
11342
11343 // CHECK-LABEL: test_vtrn_u32
11344 // CHECK: vtrn.32 d{{[0-9]+}}, d{{[0-9]+}}
11345 uint32x2x2_t test_vtrn_u32(uint32x2_t a, uint32x2_t b) {
11346   return vtrn_u32(a, b);
11347 }
11348
11349 // CHECK-LABEL: test_vtrn_f32
11350 // CHECK: vtrn.32 d{{[0-9]+}}, d{{[0-9]+}}
11351 float32x2x2_t test_vtrn_f32(float32x2_t a, float32x2_t b) {
11352   return vtrn_f32(a, b);
11353 }
11354
11355 // CHECK-LABEL: test_vtrn_p8
11356 // CHECK: vtrn.8 d{{[0-9]+}}, d{{[0-9]+}}
11357 poly8x8x2_t test_vtrn_p8(poly8x8_t a, poly8x8_t b) {
11358   return vtrn_p8(a, b);
11359 }
11360
11361 // CHECK-LABEL: test_vtrn_p16
11362 // CHECK: vtrn.16 d{{[0-9]+}}, d{{[0-9]+}}
11363 poly16x4x2_t test_vtrn_p16(poly16x4_t a, poly16x4_t b) {
11364   return vtrn_p16(a, b);
11365 }
11366
11367 // CHECK-LABEL: test_vtrnq_s8
11368 // CHECK: vtrn.8 q{{[0-9]+}}, q{{[0-9]+}}
11369 int8x16x2_t test_vtrnq_s8(int8x16_t a, int8x16_t b) {
11370   return vtrnq_s8(a, b);
11371 }
11372
11373 // CHECK-LABEL: test_vtrnq_s16
11374 // CHECK: vtrn.16 q{{[0-9]+}}, q{{[0-9]+}}
11375 int16x8x2_t test_vtrnq_s16(int16x8_t a, int16x8_t b) {
11376   return vtrnq_s16(a, b);
11377 }
11378
11379 // CHECK-LABEL: test_vtrnq_s32
11380 // CHECK: vtrn.32 q{{[0-9]+}}, q{{[0-9]+}}
11381 int32x4x2_t test_vtrnq_s32(int32x4_t a, int32x4_t b) {
11382   return vtrnq_s32(a, b);
11383 }
11384
11385 // CHECK-LABEL: test_vtrnq_u8
11386 // CHECK: vtrn.8 q{{[0-9]+}}, q{{[0-9]+}}
11387 uint8x16x2_t test_vtrnq_u8(uint8x16_t a, uint8x16_t b) {
11388   return vtrnq_u8(a, b);
11389 }
11390
11391 // CHECK-LABEL: test_vtrnq_u16
11392 // CHECK: vtrn.16 q{{[0-9]+}}, q{{[0-9]+}}
11393 uint16x8x2_t test_vtrnq_u16(uint16x8_t a, uint16x8_t b) {
11394   return vtrnq_u16(a, b);
11395 }
11396
11397 // CHECK-LABEL: test_vtrnq_u32
11398 // CHECK: vtrn.32 q{{[0-9]+}}, q{{[0-9]+}}
11399 uint32x4x2_t test_vtrnq_u32(uint32x4_t a, uint32x4_t b) {
11400   return vtrnq_u32(a, b);
11401 }
11402
11403 // CHECK-LABEL: test_vtrnq_f32
11404 // CHECK: vtrn.32 q{{[0-9]+}}, q{{[0-9]+}}
11405 float32x4x2_t test_vtrnq_f32(float32x4_t a, float32x4_t b) {
11406   return vtrnq_f32(a, b);
11407 }
11408
11409 // CHECK-LABEL: test_vtrnq_p8
11410 // CHECK: vtrn.8 q{{[0-9]+}}, q{{[0-9]+}}
11411 poly8x16x2_t test_vtrnq_p8(poly8x16_t a, poly8x16_t b) {
11412   return vtrnq_p8(a, b);
11413 }
11414
11415 // CHECK-LABEL: test_vtrnq_p16
11416 // CHECK: vtrn.16 q{{[0-9]+}}, q{{[0-9]+}}
11417 poly16x8x2_t test_vtrnq_p16(poly16x8_t a, poly16x8_t b) {
11418   return vtrnq_p16(a, b);
11419 }
11420
11421
11422 // CHECK-LABEL: test_vtst_s8
11423 // CHECK: vtst.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
11424 uint8x8_t test_vtst_s8(int8x8_t a, int8x8_t b) {
11425   return vtst_s8(a, b);
11426 }
11427
11428 // CHECK-LABEL: test_vtst_s16
11429 // CHECK: vtst.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
11430 uint16x4_t test_vtst_s16(int16x4_t a, int16x4_t b) {
11431   return vtst_s16(a, b);
11432 }
11433
11434 // CHECK-LABEL: test_vtst_s32
11435 // CHECK: vtst.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
11436 uint32x2_t test_vtst_s32(int32x2_t a, int32x2_t b) {
11437   return vtst_s32(a, b);
11438 }
11439
11440 // CHECK-LABEL: test_vtst_u8
11441 // CHECK: vtst.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
11442 uint8x8_t test_vtst_u8(uint8x8_t a, uint8x8_t b) {
11443   return vtst_u8(a, b);
11444 }
11445
11446 // CHECK-LABEL: test_vtst_u16
11447 // CHECK: vtst.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
11448 uint16x4_t test_vtst_u16(uint16x4_t a, uint16x4_t b) {
11449   return vtst_u16(a, b);
11450 }
11451
11452 // CHECK-LABEL: test_vtst_u32
11453 // CHECK: vtst.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
11454 uint32x2_t test_vtst_u32(uint32x2_t a, uint32x2_t b) {
11455   return vtst_u32(a, b);
11456 }
11457
11458 // CHECK-LABEL: test_vtst_p8
11459 // CHECK: vtst.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
11460 uint8x8_t test_vtst_p8(poly8x8_t a, poly8x8_t b) {
11461   return vtst_p8(a, b);
11462 }
11463
11464 // CHECK-LABEL: test_vtst_p16
11465 // CHECK: vtst.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
11466 uint16x4_t test_vtst_p16(poly16x4_t a, poly16x4_t b) {
11467   return vtst_p16(a, b);
11468 }
11469
11470 // CHECK-LABEL: test_vtstq_s8
11471 // CHECK: vtst.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11472 uint8x16_t test_vtstq_s8(int8x16_t a, int8x16_t b) {
11473   return vtstq_s8(a, b);
11474 }
11475
11476 // CHECK-LABEL: test_vtstq_s16
11477 // CHECK: vtst.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11478 uint16x8_t test_vtstq_s16(int16x8_t a, int16x8_t b) {
11479   return vtstq_s16(a, b);
11480 }
11481
11482 // CHECK-LABEL: test_vtstq_s32
11483 // CHECK: vtst.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11484 uint32x4_t test_vtstq_s32(int32x4_t a, int32x4_t b) {
11485   return vtstq_s32(a, b);
11486 }
11487
11488 // CHECK-LABEL: test_vtstq_u8
11489 // CHECK: vtst.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11490 uint8x16_t test_vtstq_u8(uint8x16_t a, uint8x16_t b) {
11491   return vtstq_u8(a, b);
11492 }
11493
11494 // CHECK-LABEL: test_vtstq_u16
11495 // CHECK: vtst.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11496 uint16x8_t test_vtstq_u16(uint16x8_t a, uint16x8_t b) {
11497   return vtstq_u16(a, b);
11498 }
11499
11500 // CHECK-LABEL: test_vtstq_u32
11501 // CHECK: vtst.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11502 uint32x4_t test_vtstq_u32(uint32x4_t a, uint32x4_t b) {
11503   return vtstq_u32(a, b);
11504 }
11505
11506 // CHECK-LABEL: test_vtstq_p8
11507 // CHECK: vtst.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11508 uint8x16_t test_vtstq_p8(poly8x16_t a, poly8x16_t b) {
11509   return vtstq_p8(a, b);
11510 }
11511
11512 // CHECK-LABEL: test_vtstq_p16
11513 // CHECK: vtst.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
11514 uint16x8_t test_vtstq_p16(poly16x8_t a, poly16x8_t b) {
11515   return vtstq_p16(a, b);
11516 }
11517
11518
11519 // CHECK-LABEL: test_vuzp_s8
11520 // CHECK: vuzp.8 d{{[0-9]+}}, d{{[0-9]+}}
11521 int8x8x2_t test_vuzp_s8(int8x8_t a, int8x8_t b) {
11522   return vuzp_s8(a, b);
11523 }
11524
11525 // CHECK-LABEL: test_vuzp_s16
11526 // CHECK: vuzp.16 d{{[0-9]+}}, d{{[0-9]+}}
11527 int16x4x2_t test_vuzp_s16(int16x4_t a, int16x4_t b) {
11528   return vuzp_s16(a, b);
11529 }
11530
11531 // CHECK-LABEL: test_vuzp_s32
11532 // CHECK: {{vtrn|vuzp}}.32 d{{[0-9]+}}, d{{[0-9]+}}
11533 int32x2x2_t test_vuzp_s32(int32x2_t a, int32x2_t b) {
11534   return vuzp_s32(a, b);
11535 }
11536
11537 // CHECK-LABEL: test_vuzp_u8
11538 // CHECK: vuzp.8 d{{[0-9]+}}, d{{[0-9]+}}
11539 uint8x8x2_t test_vuzp_u8(uint8x8_t a, uint8x8_t b) {
11540   return vuzp_u8(a, b);
11541 }
11542
11543 // CHECK-LABEL: test_vuzp_u16
11544 // CHECK: vuzp.16 d{{[0-9]+}}, d{{[0-9]+}}
11545 uint16x4x2_t test_vuzp_u16(uint16x4_t a, uint16x4_t b) {
11546   return vuzp_u16(a, b);
11547 }
11548
11549 // CHECK-LABEL: test_vuzp_u32
11550 // CHECK: {{vtrn|vuzp}}.32 d{{[0-9]+}}, d{{[0-9]+}}
11551 uint32x2x2_t test_vuzp_u32(uint32x2_t a, uint32x2_t b) {
11552   return vuzp_u32(a, b);
11553 }
11554
11555 // CHECK-LABEL: test_vuzp_f32
11556 // CHECK: {{vtrn|vuzp}}.32 d{{[0-9]+}}, d{{[0-9]+}}
11557 float32x2x2_t test_vuzp_f32(float32x2_t a, float32x2_t b) {
11558   return vuzp_f32(a, b);
11559 }
11560
11561 // CHECK-LABEL: test_vuzp_p8
11562 // CHECK: vuzp.8 d{{[0-9]+}}, d{{[0-9]+}}
11563 poly8x8x2_t test_vuzp_p8(poly8x8_t a, poly8x8_t b) {
11564   return vuzp_p8(a, b);
11565 }
11566
11567 // CHECK-LABEL: test_vuzp_p16
11568 // CHECK: vuzp.16 d{{[0-9]+}}, d{{[0-9]+}}
11569 poly16x4x2_t test_vuzp_p16(poly16x4_t a, poly16x4_t b) {
11570   return vuzp_p16(a, b);
11571 }
11572
11573 // CHECK-LABEL: test_vuzpq_s8
11574 // CHECK: vuzp.8 q{{[0-9]+}}, q{{[0-9]+}}
11575 int8x16x2_t test_vuzpq_s8(int8x16_t a, int8x16_t b) {
11576   return vuzpq_s8(a, b);
11577 }
11578
11579 // CHECK-LABEL: test_vuzpq_s16
11580 // CHECK: vuzp.16 q{{[0-9]+}}, q{{[0-9]+}}
11581 int16x8x2_t test_vuzpq_s16(int16x8_t a, int16x8_t b) {
11582   return vuzpq_s16(a, b);
11583 }
11584
11585 // CHECK-LABEL: test_vuzpq_s32
11586 // CHECK: {{vtrn|vuzp}}.32 q{{[0-9]+}}, q{{[0-9]+}}
11587 int32x4x2_t test_vuzpq_s32(int32x4_t a, int32x4_t b) {
11588   return vuzpq_s32(a, b);
11589 }
11590
11591 // CHECK-LABEL: test_vuzpq_u8
11592 // CHECK: vuzp.8 q{{[0-9]+}}, q{{[0-9]+}}
11593 uint8x16x2_t test_vuzpq_u8(uint8x16_t a, uint8x16_t b) {
11594   return vuzpq_u8(a, b);
11595 }
11596
11597 // CHECK-LABEL: test_vuzpq_u16
11598 // CHECK: vuzp.16 q{{[0-9]+}}, q{{[0-9]+}}
11599 uint16x8x2_t test_vuzpq_u16(uint16x8_t a, uint16x8_t b) {
11600   return vuzpq_u16(a, b);
11601 }
11602
11603 // CHECK-LABEL: test_vuzpq_u32
11604 // CHECK: {{vtrn|vuzp}}.32 q{{[0-9]+}}, q{{[0-9]+}}
11605 uint32x4x2_t test_vuzpq_u32(uint32x4_t a, uint32x4_t b) {
11606   return vuzpq_u32(a, b);
11607 }
11608
11609 // CHECK-LABEL: test_vuzpq_f32
11610 // CHECK: {{vtrn|vuzp}}.32 q{{[0-9]+}}, q{{[0-9]+}}
11611 float32x4x2_t test_vuzpq_f32(float32x4_t a, float32x4_t b) {
11612   return vuzpq_f32(a, b);
11613 }
11614
11615 // CHECK-LABEL: test_vuzpq_p8
11616 // CHECK: vuzp.8 q{{[0-9]+}}, q{{[0-9]+}}
11617 poly8x16x2_t test_vuzpq_p8(poly8x16_t a, poly8x16_t b) {
11618   return vuzpq_p8(a, b);
11619 }
11620
11621 // CHECK-LABEL: test_vuzpq_p16
11622 // CHECK: vuzp.16 q{{[0-9]+}}, q{{[0-9]+}}
11623 poly16x8x2_t test_vuzpq_p16(poly16x8_t a, poly16x8_t b) {
11624   return vuzpq_p16(a, b);
11625 }
11626
11627
11628 // CHECK-LABEL: test_vzip_s8
11629 // CHECK: vzip.8 d{{[0-9]+}}, d{{[0-9]+}}
11630 int8x8x2_t test_vzip_s8(int8x8_t a, int8x8_t b) {
11631   return vzip_s8(a, b);
11632 }
11633
11634 // CHECK-LABEL: test_vzip_s16
11635 // CHECK: vzip.16 d{{[0-9]+}}, d{{[0-9]+}}
11636 int16x4x2_t test_vzip_s16(int16x4_t a, int16x4_t b) {
11637   return vzip_s16(a, b);
11638 }
11639
11640 // CHECK-LABEL: test_vzip_s32
11641 // CHECK: {{vtrn|vzip}}.32 d{{[0-9]+}}, d{{[0-9]+}}
11642 int32x2x2_t test_vzip_s32(int32x2_t a, int32x2_t b) {
11643   return vzip_s32(a, b);
11644 }
11645
11646 // CHECK-LABEL: test_vzip_u8
11647 // CHECK: vzip.8 d{{[0-9]+}}, d{{[0-9]+}}
11648 uint8x8x2_t test_vzip_u8(uint8x8_t a, uint8x8_t b) {
11649   return vzip_u8(a, b);
11650 }
11651
11652 // CHECK-LABEL: test_vzip_u16
11653 // CHECK: vzip.16 d{{[0-9]+}}, d{{[0-9]+}}
11654 uint16x4x2_t test_vzip_u16(uint16x4_t a, uint16x4_t b) {
11655   return vzip_u16(a, b);
11656 }
11657
11658 // CHECK-LABEL: test_vzip_u32
11659 // CHECK: {{vtrn|vzip}}.32 d{{[0-9]+}}, d{{[0-9]+}}
11660 uint32x2x2_t test_vzip_u32(uint32x2_t a, uint32x2_t b) {
11661   return vzip_u32(a, b);
11662 }
11663
11664 // CHECK-LABEL: test_vzip_f32
11665 // CHECK: {{vtrn|vzip}}.32 d{{[0-9]+}}, d{{[0-9]+}}
11666 float32x2x2_t test_vzip_f32(float32x2_t a, float32x2_t b) {
11667   return vzip_f32(a, b);
11668 }
11669
11670 // CHECK-LABEL: test_vzip_p8
11671 // CHECK: vzip.8 d{{[0-9]+}}, d{{[0-9]+}}
11672 poly8x8x2_t test_vzip_p8(poly8x8_t a, poly8x8_t b) {
11673   return vzip_p8(a, b);
11674 }
11675
11676 // CHECK-LABEL: test_vzip_p16
11677 // CHECK: vzip.16 d{{[0-9]+}}, d{{[0-9]+}}
11678 poly16x4x2_t test_vzip_p16(poly16x4_t a, poly16x4_t b) {
11679   return vzip_p16(a, b);
11680 }
11681
11682 // CHECK-LABEL: test_vzipq_s8
11683 // CHECK: vzip.8 q{{[0-9]+}}, q{{[0-9]+}}
11684 int8x16x2_t test_vzipq_s8(int8x16_t a, int8x16_t b) {
11685   return vzipq_s8(a, b);
11686 }
11687
11688 // CHECK-LABEL: test_vzipq_s16
11689 // CHECK: vzip.16 q{{[0-9]+}}, q{{[0-9]+}}
11690 int16x8x2_t test_vzipq_s16(int16x8_t a, int16x8_t b) {
11691   return vzipq_s16(a, b);
11692 }
11693
11694 // CHECK-LABEL: test_vzipq_s32
11695 // CHECK: {{vtrn|vzip}}.32 q{{[0-9]+}}, q{{[0-9]+}}
11696 int32x4x2_t test_vzipq_s32(int32x4_t a, int32x4_t b) {
11697   return vzipq_s32(a, b);
11698 }
11699
11700 // CHECK-LABEL: test_vzipq_u8
11701 // CHECK: vzip.8 q{{[0-9]+}}, q{{[0-9]+}}
11702 uint8x16x2_t test_vzipq_u8(uint8x16_t a, uint8x16_t b) {
11703   return vzipq_u8(a, b);
11704 }
11705
11706 // CHECK-LABEL: test_vzipq_u16
11707 // CHECK: vzip.16 q{{[0-9]+}}, q{{[0-9]+}}
11708 uint16x8x2_t test_vzipq_u16(uint16x8_t a, uint16x8_t b) {
11709   return vzipq_u16(a, b);
11710 }
11711
11712 // CHECK-LABEL: test_vzipq_u32
11713 // CHECK: {{vtrn|vzip}}.32 q{{[0-9]+}}, q{{[0-9]+}}
11714 uint32x4x2_t test_vzipq_u32(uint32x4_t a, uint32x4_t b) {
11715   return vzipq_u32(a, b);
11716 }
11717
11718 // CHECK-LABEL: test_vzipq_f32
11719 // CHECK: {{vtrn|vzip}}.32 q{{[0-9]+}}, q{{[0-9]+}}
11720 float32x4x2_t test_vzipq_f32(float32x4_t a, float32x4_t b) {
11721   return vzipq_f32(a, b);
11722 }
11723
11724 // CHECK-LABEL: test_vzipq_p8
11725 // CHECK: vzip.8 q{{[0-9]+}}, q{{[0-9]+}}
11726 poly8x16x2_t test_vzipq_p8(poly8x16_t a, poly8x16_t b) {
11727   return vzipq_p8(a, b);
11728 }
11729
11730 // CHECK-LABEL: test_vzipq_p16
11731 // CHECK: vzip.16 q{{[0-9]+}}, q{{[0-9]+}}
11732 poly16x8x2_t test_vzipq_p16(poly16x8_t a, poly16x8_t b) {
11733   return vzipq_p16(a, b);
11734 }
11735
11736