clang/test/CodeGen/aarch64-neon-perm.c

   1 // RUN: %clang_cc1 -triple arm64-none-linux-gnu -target-feature +neon \
   2 // RUN: -disable-O0-optnone -emit-llvm -o - %s | opt -S -passes=mem2reg | FileCheck %s
   3
   4 // REQUIRES: aarch64-registered-target || arm-registered-target
   5
   6 #include <arm_neon.h>
   7
   8 // CHECK-LABEL: @test_vuzp1_s8(
   9 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
  10 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
  11 int8x8_t test_vuzp1_s8(int8x8_t a, int8x8_t b) {
  12   return vuzp1_s8(a, b);
  13 }
  14
  15 // CHECK-LABEL: @test_vuzp1q_s8(
  16 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
  17 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
  18 int8x16_t test_vuzp1q_s8(int8x16_t a, int8x16_t b) {
  19   return vuzp1q_s8(a, b);
  20 }
  21
  22 // CHECK-LABEL: @test_vuzp1_s16(
  23 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  24 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
  25 int16x4_t test_vuzp1_s16(int16x4_t a, int16x4_t b) {
  26   return vuzp1_s16(a, b);
  27 }
  28
  29 // CHECK-LABEL: @test_vuzp1q_s16(
  30 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
  31 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
  32 int16x8_t test_vuzp1q_s16(int16x8_t a, int16x8_t b) {
  33   return vuzp1q_s16(a, b);
  34 }
  35
  36 // CHECK-LABEL: @test_vuzp1_s32(
  37 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
  38 // CHECK:   ret <2 x i32> [[SHUFFLE_I]]
  39 int32x2_t test_vuzp1_s32(int32x2_t a, int32x2_t b) {
  40   return vuzp1_s32(a, b);
  41 }
  42
  43 // CHECK-LABEL: @test_vuzp1q_s32(
  44 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  45 // CHECK:   ret <4 x i32> [[SHUFFLE_I]]
  46 int32x4_t test_vuzp1q_s32(int32x4_t a, int32x4_t b) {
  47   return vuzp1q_s32(a, b);
  48 }
  49
  50 // CHECK-LABEL: @test_vuzp1q_s64(
  51 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 0, i32 2>
  52 // CHECK:   ret <2 x i64> [[SHUFFLE_I]]
  53 int64x2_t test_vuzp1q_s64(int64x2_t a, int64x2_t b) {
  54   return vuzp1q_s64(a, b);
  55 }
  56
  57 // CHECK-LABEL: @test_vuzp1_u8(
  58 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
  59 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
  60 uint8x8_t test_vuzp1_u8(uint8x8_t a, uint8x8_t b) {
  61   return vuzp1_u8(a, b);
  62 }
  63
  64 // CHECK-LABEL: @test_vuzp1q_u8(
  65 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
  66 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
  67 uint8x16_t test_vuzp1q_u8(uint8x16_t a, uint8x16_t b) {
  68   return vuzp1q_u8(a, b);
  69 }
  70
  71 // CHECK-LABEL: @test_vuzp1_u16(
  72 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  73 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
  74 uint16x4_t test_vuzp1_u16(uint16x4_t a, uint16x4_t b) {
  75   return vuzp1_u16(a, b);
  76 }
  77
  78 // CHECK-LABEL: @test_vuzp1q_u16(
  79 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
  80 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
  81 uint16x8_t test_vuzp1q_u16(uint16x8_t a, uint16x8_t b) {
  82   return vuzp1q_u16(a, b);
  83 }
  84
  85 // CHECK-LABEL: @test_vuzp1_u32(
  86 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
  87 // CHECK:   ret <2 x i32> [[SHUFFLE_I]]
  88 uint32x2_t test_vuzp1_u32(uint32x2_t a, uint32x2_t b) {
  89   return vuzp1_u32(a, b);
  90 }
  91
  92 // CHECK-LABEL: @test_vuzp1q_u32(
  93 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
  94 // CHECK:   ret <4 x i32> [[SHUFFLE_I]]
  95 uint32x4_t test_vuzp1q_u32(uint32x4_t a, uint32x4_t b) {
  96   return vuzp1q_u32(a, b);
  97 }
  98
  99 // CHECK-LABEL: @test_vuzp1q_u64(
 100 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 0, i32 2>
 101 // CHECK:   ret <2 x i64> [[SHUFFLE_I]]
 102 uint64x2_t test_vuzp1q_u64(uint64x2_t a, uint64x2_t b) {
 103   return vuzp1q_u64(a, b);
 104 }
 105
 106 // CHECK-LABEL: @test_vuzp1_f32(
 107 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 0, i32 2>
 108 // CHECK:   ret <2 x float> [[SHUFFLE_I]]
 109 float32x2_t test_vuzp1_f32(float32x2_t a, float32x2_t b) {
 110   return vuzp1_f32(a, b);
 111 }
 112
 113 // CHECK-LABEL: @test_vuzp1q_f32(
 114 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
 115 // CHECK:   ret <4 x float> [[SHUFFLE_I]]
 116 float32x4_t test_vuzp1q_f32(float32x4_t a, float32x4_t b) {
 117   return vuzp1q_f32(a, b);
 118 }
 119
 120 // CHECK-LABEL: @test_vuzp1q_f64(
 121 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x double> %a, <2 x double> %b, <2 x i32> <i32 0, i32 2>
 122 // CHECK:   ret <2 x double> [[SHUFFLE_I]]
 123 float64x2_t test_vuzp1q_f64(float64x2_t a, float64x2_t b) {
 124   return vuzp1q_f64(a, b);
 125 }
 126
 127 // CHECK-LABEL: @test_vuzp1_p8(
 128 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
 129 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
 130 poly8x8_t test_vuzp1_p8(poly8x8_t a, poly8x8_t b) {
 131   return vuzp1_p8(a, b);
 132 }
 133
 134 // CHECK-LABEL: @test_vuzp1q_p8(
 135 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
 136 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
 137 poly8x16_t test_vuzp1q_p8(poly8x16_t a, poly8x16_t b) {
 138   return vuzp1q_p8(a, b);
 139 }
 140
 141 // CHECK-LABEL: @test_vuzp1_p16(
 142 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
 143 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
 144 poly16x4_t test_vuzp1_p16(poly16x4_t a, poly16x4_t b) {
 145   return vuzp1_p16(a, b);
 146 }
 147
 148 // CHECK-LABEL: @test_vuzp1q_p16(
 149 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
 150 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
 151 poly16x8_t test_vuzp1q_p16(poly16x8_t a, poly16x8_t b) {
 152   return vuzp1q_p16(a, b);
 153 }
 154
 155 // CHECK-LABEL: @test_vuzp2_s8(
 156 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
 157 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
 158 int8x8_t test_vuzp2_s8(int8x8_t a, int8x8_t b) {
 159   return vuzp2_s8(a, b);
 160 }
 161
 162 // CHECK-LABEL: @test_vuzp2q_s8(
 163 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
 164 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
 165 int8x16_t test_vuzp2q_s8(int8x16_t a, int8x16_t b) {
 166   return vuzp2q_s8(a, b);
 167 }
 168
 169 // CHECK-LABEL: @test_vuzp2_s16(
 170 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
 171 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
 172 int16x4_t test_vuzp2_s16(int16x4_t a, int16x4_t b) {
 173   return vuzp2_s16(a, b);
 174 }
 175
 176 // CHECK-LABEL: @test_vuzp2q_s16(
 177 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
 178 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
 179 int16x8_t test_vuzp2q_s16(int16x8_t a, int16x8_t b) {
 180   return vuzp2q_s16(a, b);
 181 }
 182
 183 // CHECK-LABEL: @test_vuzp2_s32(
 184 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
 185 // CHECK:   ret <2 x i32> [[SHUFFLE_I]]
 186 int32x2_t test_vuzp2_s32(int32x2_t a, int32x2_t b) {
 187   return vuzp2_s32(a, b);
 188 }
 189
 190 // CHECK-LABEL: @test_vuzp2q_s32(
 191 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
 192 // CHECK:   ret <4 x i32> [[SHUFFLE_I]]
 193 int32x4_t test_vuzp2q_s32(int32x4_t a, int32x4_t b) {
 194   return vuzp2q_s32(a, b);
 195 }
 196
 197 // CHECK-LABEL: @test_vuzp2q_s64(
 198 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 1, i32 3>
 199 // CHECK:   ret <2 x i64> [[SHUFFLE_I]]
 200 int64x2_t test_vuzp2q_s64(int64x2_t a, int64x2_t b) {
 201   return vuzp2q_s64(a, b);
 202 }
 203
 204 // CHECK-LABEL: @test_vuzp2_u8(
 205 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
 206 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
 207 uint8x8_t test_vuzp2_u8(uint8x8_t a, uint8x8_t b) {
 208   return vuzp2_u8(a, b);
 209 }
 210
 211 // CHECK-LABEL: @test_vuzp2q_u8(
 212 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
 213 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
 214 uint8x16_t test_vuzp2q_u8(uint8x16_t a, uint8x16_t b) {
 215   return vuzp2q_u8(a, b);
 216 }
 217
 218 // CHECK-LABEL: @test_vuzp2_u16(
 219 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
 220 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
 221 uint16x4_t test_vuzp2_u16(uint16x4_t a, uint16x4_t b) {
 222   return vuzp2_u16(a, b);
 223 }
 224
 225 // CHECK-LABEL: @test_vuzp2q_u16(
 226 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
 227 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
 228 uint16x8_t test_vuzp2q_u16(uint16x8_t a, uint16x8_t b) {
 229   return vuzp2q_u16(a, b);
 230 }
 231
 232 // CHECK-LABEL: @test_vuzp2_u32(
 233 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
 234 // CHECK:   ret <2 x i32> [[SHUFFLE_I]]
 235 uint32x2_t test_vuzp2_u32(uint32x2_t a, uint32x2_t b) {
 236   return vuzp2_u32(a, b);
 237 }
 238
 239 // CHECK-LABEL: @test_vuzp2q_u32(
 240 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
 241 // CHECK:   ret <4 x i32> [[SHUFFLE_I]]
 242 uint32x4_t test_vuzp2q_u32(uint32x4_t a, uint32x4_t b) {
 243   return vuzp2q_u32(a, b);
 244 }
 245
 246 // CHECK-LABEL: @test_vuzp2q_u64(
 247 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 1, i32 3>
 248 // CHECK:   ret <2 x i64> [[SHUFFLE_I]]
 249 uint64x2_t test_vuzp2q_u64(uint64x2_t a, uint64x2_t b) {
 250   return vuzp2q_u64(a, b);
 251 }
 252
 253 // CHECK-LABEL: @test_vuzp2_f32(
 254 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 1, i32 3>
 255 // CHECK:   ret <2 x float> [[SHUFFLE_I]]
 256 float32x2_t test_vuzp2_f32(float32x2_t a, float32x2_t b) {
 257   return vuzp2_f32(a, b);
 258 }
 259
 260 // CHECK-LABEL: @test_vuzp2q_f32(
 261 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
 262 // CHECK:   ret <4 x float> [[SHUFFLE_I]]
 263 float32x4_t test_vuzp2q_f32(float32x4_t a, float32x4_t b) {
 264   return vuzp2q_f32(a, b);
 265 }
 266
 267 // CHECK-LABEL: @test_vuzp2q_f64(
 268 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x double> %a, <2 x double> %b, <2 x i32> <i32 1, i32 3>
 269 // CHECK:   ret <2 x double> [[SHUFFLE_I]]
 270 float64x2_t test_vuzp2q_f64(float64x2_t a, float64x2_t b) {
 271   return vuzp2q_f64(a, b);
 272 }
 273
 274 // CHECK-LABEL: @test_vuzp2_p8(
 275 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
 276 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
 277 poly8x8_t test_vuzp2_p8(poly8x8_t a, poly8x8_t b) {
 278   return vuzp2_p8(a, b);
 279 }
 280
 281 // CHECK-LABEL: @test_vuzp2q_p8(
 282 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
 283 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
 284 poly8x16_t test_vuzp2q_p8(poly8x16_t a, poly8x16_t b) {
 285   return vuzp2q_p8(a, b);
 286 }
 287
 288 // CHECK-LABEL: @test_vuzp2_p16(
 289 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
 290 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
 291 poly16x4_t test_vuzp2_p16(poly16x4_t a, poly16x4_t b) {
 292   return vuzp2_p16(a, b);
 293 }
 294
 295 // CHECK-LABEL: @test_vuzp2q_p16(
 296 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
 297 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
 298 poly16x8_t test_vuzp2q_p16(poly16x8_t a, poly16x8_t b) {
 299   return vuzp2q_p16(a, b);
 300 }
 301
 302 // CHECK-LABEL: @test_vzip1_s8(
 303 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
 304 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
 305 int8x8_t test_vzip1_s8(int8x8_t a, int8x8_t b) {
 306   return vzip1_s8(a, b);
 307 }
 308
 309 // CHECK-LABEL: @test_vzip1q_s8(
 310 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
 311 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
 312 int8x16_t test_vzip1q_s8(int8x16_t a, int8x16_t b) {
 313   return vzip1q_s8(a, b);
 314 }
 315
 316 // CHECK-LABEL: @test_vzip1_s16(
 317 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
 318 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
 319 int16x4_t test_vzip1_s16(int16x4_t a, int16x4_t b) {
 320   return vzip1_s16(a, b);
 321 }
 322
 323 // CHECK-LABEL: @test_vzip1q_s16(
 324 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
 325 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
 326 int16x8_t test_vzip1q_s16(int16x8_t a, int16x8_t b) {
 327   return vzip1q_s16(a, b);
 328 }
 329
 330 // CHECK-LABEL: @test_vzip1_s32(
 331 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
 332 // CHECK:   ret <2 x i32> [[SHUFFLE_I]]
 333 int32x2_t test_vzip1_s32(int32x2_t a, int32x2_t b) {
 334   return vzip1_s32(a, b);
 335 }
 336
 337 // CHECK-LABEL: @test_vzip1q_s32(
 338 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
 339 // CHECK:   ret <4 x i32> [[SHUFFLE_I]]
 340 int32x4_t test_vzip1q_s32(int32x4_t a, int32x4_t b) {
 341   return vzip1q_s32(a, b);
 342 }
 343
 344 // CHECK-LABEL: @test_vzip1q_s64(
 345 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 0, i32 2>
 346 // CHECK:   ret <2 x i64> [[SHUFFLE_I]]
 347 int64x2_t test_vzip1q_s64(int64x2_t a, int64x2_t b) {
 348   return vzip1q_s64(a, b);
 349 }
 350
 351 // CHECK-LABEL: @test_vzip1_u8(
 352 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
 353 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
 354 uint8x8_t test_vzip1_u8(uint8x8_t a, uint8x8_t b) {
 355   return vzip1_u8(a, b);
 356 }
 357
 358 // CHECK-LABEL: @test_vzip1q_u8(
 359 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
 360 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
 361 uint8x16_t test_vzip1q_u8(uint8x16_t a, uint8x16_t b) {
 362   return vzip1q_u8(a, b);
 363 }
 364
 365 // CHECK-LABEL: @test_vzip1_u16(
 366 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
 367 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
 368 uint16x4_t test_vzip1_u16(uint16x4_t a, uint16x4_t b) {
 369   return vzip1_u16(a, b);
 370 }
 371
 372 // CHECK-LABEL: @test_vzip1q_u16(
 373 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
 374 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
 375 uint16x8_t test_vzip1q_u16(uint16x8_t a, uint16x8_t b) {
 376   return vzip1q_u16(a, b);
 377 }
 378
 379 // CHECK-LABEL: @test_vzip1_u32(
 380 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
 381 // CHECK:   ret <2 x i32> [[SHUFFLE_I]]
 382 uint32x2_t test_vzip1_u32(uint32x2_t a, uint32x2_t b) {
 383   return vzip1_u32(a, b);
 384 }
 385
 386 // CHECK-LABEL: @test_vzip1q_u32(
 387 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
 388 // CHECK:   ret <4 x i32> [[SHUFFLE_I]]
 389 uint32x4_t test_vzip1q_u32(uint32x4_t a, uint32x4_t b) {
 390   return vzip1q_u32(a, b);
 391 }
 392
 393 // CHECK-LABEL: @test_vzip1q_u64(
 394 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 0, i32 2>
 395 // CHECK:   ret <2 x i64> [[SHUFFLE_I]]
 396 uint64x2_t test_vzip1q_u64(uint64x2_t a, uint64x2_t b) {
 397   return vzip1q_u64(a, b);
 398 }
 399
 400 // CHECK-LABEL: @test_vzip1_f32(
 401 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 0, i32 2>
 402 // CHECK:   ret <2 x float> [[SHUFFLE_I]]
 403 float32x2_t test_vzip1_f32(float32x2_t a, float32x2_t b) {
 404   return vzip1_f32(a, b);
 405 }
 406
 407 // CHECK-LABEL: @test_vzip1q_f32(
 408 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
 409 // CHECK:   ret <4 x float> [[SHUFFLE_I]]
 410 float32x4_t test_vzip1q_f32(float32x4_t a, float32x4_t b) {
 411   return vzip1q_f32(a, b);
 412 }
 413
 414 // CHECK-LABEL: @test_vzip1q_f64(
 415 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x double> %a, <2 x double> %b, <2 x i32> <i32 0, i32 2>
 416 // CHECK:   ret <2 x double> [[SHUFFLE_I]]
 417 float64x2_t test_vzip1q_f64(float64x2_t a, float64x2_t b) {
 418   return vzip1q_f64(a, b);
 419 }
 420
 421 // CHECK-LABEL: @test_vzip1_p8(
 422 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
 423 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
 424 poly8x8_t test_vzip1_p8(poly8x8_t a, poly8x8_t b) {
 425   return vzip1_p8(a, b);
 426 }
 427
 428 // CHECK-LABEL: @test_vzip1q_p8(
 429 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
 430 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
 431 poly8x16_t test_vzip1q_p8(poly8x16_t a, poly8x16_t b) {
 432   return vzip1q_p8(a, b);
 433 }
 434
 435 // CHECK-LABEL: @test_vzip1_p16(
 436 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
 437 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
 438 poly16x4_t test_vzip1_p16(poly16x4_t a, poly16x4_t b) {
 439   return vzip1_p16(a, b);
 440 }
 441
 442 // CHECK-LABEL: @test_vzip1q_p16(
 443 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
 444 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
 445 poly16x8_t test_vzip1q_p16(poly16x8_t a, poly16x8_t b) {
 446   return vzip1q_p16(a, b);
 447 }
 448
 449 // CHECK-LABEL: @test_vzip2_s8(
 450 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
 451 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
 452 int8x8_t test_vzip2_s8(int8x8_t a, int8x8_t b) {
 453   return vzip2_s8(a, b);
 454 }
 455
 456 // CHECK-LABEL: @test_vzip2q_s8(
 457 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
 458 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
 459 int8x16_t test_vzip2q_s8(int8x16_t a, int8x16_t b) {
 460   return vzip2q_s8(a, b);
 461 }
 462
 463 // CHECK-LABEL: @test_vzip2_s16(
 464 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
 465 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
 466 int16x4_t test_vzip2_s16(int16x4_t a, int16x4_t b) {
 467   return vzip2_s16(a, b);
 468 }
 469
 470 // CHECK-LABEL: @test_vzip2q_s16(
 471 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
 472 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
 473 int16x8_t test_vzip2q_s16(int16x8_t a, int16x8_t b) {
 474   return vzip2q_s16(a, b);
 475 }
 476
 477 // CHECK-LABEL: @test_vzip2_s32(
 478 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
 479 // CHECK:   ret <2 x i32> [[SHUFFLE_I]]
 480 int32x2_t test_vzip2_s32(int32x2_t a, int32x2_t b) {
 481   return vzip2_s32(a, b);
 482 }
 483
 484 // CHECK-LABEL: @test_vzip2q_s32(
 485 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
 486 // CHECK:   ret <4 x i32> [[SHUFFLE_I]]
 487 int32x4_t test_vzip2q_s32(int32x4_t a, int32x4_t b) {
 488   return vzip2q_s32(a, b);
 489 }
 490
 491 // CHECK-LABEL: @test_vzip2q_s64(
 492 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 1, i32 3>
 493 // CHECK:   ret <2 x i64> [[SHUFFLE_I]]
 494 int64x2_t test_vzip2q_s64(int64x2_t a, int64x2_t b) {
 495   return vzip2q_s64(a, b);
 496 }
 497
 498 // CHECK-LABEL: @test_vzip2_u8(
 499 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
 500 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
 501 uint8x8_t test_vzip2_u8(uint8x8_t a, uint8x8_t b) {
 502   return vzip2_u8(a, b);
 503 }
 504
 505 // CHECK-LABEL: @test_vzip2q_u8(
 506 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
 507 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
 508 uint8x16_t test_vzip2q_u8(uint8x16_t a, uint8x16_t b) {
 509   return vzip2q_u8(a, b);
 510 }
 511
 512 // CHECK-LABEL: @test_vzip2_u16(
 513 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
 514 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
 515 uint16x4_t test_vzip2_u16(uint16x4_t a, uint16x4_t b) {
 516   return vzip2_u16(a, b);
 517 }
 518
 519 // CHECK-LABEL: @test_vzip2q_u16(
 520 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
 521 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
 522 uint16x8_t test_vzip2q_u16(uint16x8_t a, uint16x8_t b) {
 523   return vzip2q_u16(a, b);
 524 }
 525
 526 // CHECK-LABEL: @test_vzip2_u32(
 527 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
 528 // CHECK:   ret <2 x i32> [[SHUFFLE_I]]
 529 uint32x2_t test_vzip2_u32(uint32x2_t a, uint32x2_t b) {
 530   return vzip2_u32(a, b);
 531 }
 532
 533 // CHECK-LABEL: @test_vzip2q_u32(
 534 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
 535 // CHECK:   ret <4 x i32> [[SHUFFLE_I]]
 536 uint32x4_t test_vzip2q_u32(uint32x4_t a, uint32x4_t b) {
 537   return vzip2q_u32(a, b);
 538 }
 539
 540 // CHECK-LABEL: @test_vzip2q_u64(
 541 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 1, i32 3>
 542 // CHECK:   ret <2 x i64> [[SHUFFLE_I]]
 543 uint64x2_t test_vzip2q_u64(uint64x2_t a, uint64x2_t b) {
 544   return vzip2q_u64(a, b);
 545 }
 546
 547 // CHECK-LABEL: @test_vzip2_f32(
 548 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 1, i32 3>
 549 // CHECK:   ret <2 x float> [[SHUFFLE_I]]
 550 float32x2_t test_vzip2_f32(float32x2_t a, float32x2_t b) {
 551   return vzip2_f32(a, b);
 552 }
 553
 554 // CHECK-LABEL: @test_vzip2q_f32(
 555 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
 556 // CHECK:   ret <4 x float> [[SHUFFLE_I]]
 557 float32x4_t test_vzip2q_f32(float32x4_t a, float32x4_t b) {
 558   return vzip2q_f32(a, b);
 559 }
 560
 561 // CHECK-LABEL: @test_vzip2q_f64(
 562 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x double> %a, <2 x double> %b, <2 x i32> <i32 1, i32 3>
 563 // CHECK:   ret <2 x double> [[SHUFFLE_I]]
 564 float64x2_t test_vzip2q_f64(float64x2_t a, float64x2_t b) {
 565   return vzip2q_f64(a, b);
 566 }
 567
 568 // CHECK-LABEL: @test_vzip2_p8(
 569 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
 570 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
 571 poly8x8_t test_vzip2_p8(poly8x8_t a, poly8x8_t b) {
 572   return vzip2_p8(a, b);
 573 }
 574
 575 // CHECK-LABEL: @test_vzip2q_p8(
 576 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
 577 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
 578 poly8x16_t test_vzip2q_p8(poly8x16_t a, poly8x16_t b) {
 579   return vzip2q_p8(a, b);
 580 }
 581
 582 // CHECK-LABEL: @test_vzip2_p16(
 583 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
 584 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
 585 poly16x4_t test_vzip2_p16(poly16x4_t a, poly16x4_t b) {
 586   return vzip2_p16(a, b);
 587 }
 588
 589 // CHECK-LABEL: @test_vzip2q_p16(
 590 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
 591 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
 592 poly16x8_t test_vzip2q_p16(poly16x8_t a, poly16x8_t b) {
 593   return vzip2q_p16(a, b);
 594 }
 595
 596 // CHECK-LABEL: @test_vtrn1_s8(
 597 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
 598 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
 599 int8x8_t test_vtrn1_s8(int8x8_t a, int8x8_t b) {
 600   return vtrn1_s8(a, b);
 601 }
 602
 603 // CHECK-LABEL: @test_vtrn1q_s8(
 604 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 2, i32 18, i32 4, i32 20, i32 6, i32 22, i32 8, i32 24, i32 10, i32 26, i32 12, i32 28, i32 14, i32 30>
 605 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
 606 int8x16_t test_vtrn1q_s8(int8x16_t a, int8x16_t b) {
 607   return vtrn1q_s8(a, b);
 608 }
 609
 610 // CHECK-LABEL: @test_vtrn1_s16(
 611 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
 612 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
 613 int16x4_t test_vtrn1_s16(int16x4_t a, int16x4_t b) {
 614   return vtrn1_s16(a, b);
 615 }
 616
 617 // CHECK-LABEL: @test_vtrn1q_s16(
 618 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
 619 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
 620 int16x8_t test_vtrn1q_s16(int16x8_t a, int16x8_t b) {
 621   return vtrn1q_s16(a, b);
 622 }
 623
 624 // CHECK-LABEL: @test_vtrn1_s32(
 625 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
 626 // CHECK:   ret <2 x i32> [[SHUFFLE_I]]
 627 int32x2_t test_vtrn1_s32(int32x2_t a, int32x2_t b) {
 628   return vtrn1_s32(a, b);
 629 }
 630
 631 // CHECK-LABEL: @test_vtrn1q_s32(
 632 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
 633 // CHECK:   ret <4 x i32> [[SHUFFLE_I]]
 634 int32x4_t test_vtrn1q_s32(int32x4_t a, int32x4_t b) {
 635   return vtrn1q_s32(a, b);
 636 }
 637
 638 // CHECK-LABEL: @test_vtrn1q_s64(
 639 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 0, i32 2>
 640 // CHECK:   ret <2 x i64> [[SHUFFLE_I]]
 641 int64x2_t test_vtrn1q_s64(int64x2_t a, int64x2_t b) {
 642   return vtrn1q_s64(a, b);
 643 }
 644
 645 // CHECK-LABEL: @test_vtrn1_u8(
 646 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
 647 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
 648 uint8x8_t test_vtrn1_u8(uint8x8_t a, uint8x8_t b) {
 649   return vtrn1_u8(a, b);
 650 }
 651
 652 // CHECK-LABEL: @test_vtrn1q_u8(
 653 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 2, i32 18, i32 4, i32 20, i32 6, i32 22, i32 8, i32 24, i32 10, i32 26, i32 12, i32 28, i32 14, i32 30>
 654 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
 655 uint8x16_t test_vtrn1q_u8(uint8x16_t a, uint8x16_t b) {
 656   return vtrn1q_u8(a, b);
 657 }
 658
 659 // CHECK-LABEL: @test_vtrn1_u16(
 660 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
 661 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
 662 uint16x4_t test_vtrn1_u16(uint16x4_t a, uint16x4_t b) {
 663   return vtrn1_u16(a, b);
 664 }
 665
 666 // CHECK-LABEL: @test_vtrn1q_u16(
 667 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
 668 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
 669 uint16x8_t test_vtrn1q_u16(uint16x8_t a, uint16x8_t b) {
 670   return vtrn1q_u16(a, b);
 671 }
 672
 673 // CHECK-LABEL: @test_vtrn1_u32(
 674 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
 675 // CHECK:   ret <2 x i32> [[SHUFFLE_I]]
 676 uint32x2_t test_vtrn1_u32(uint32x2_t a, uint32x2_t b) {
 677   return vtrn1_u32(a, b);
 678 }
 679
 680 // CHECK-LABEL: @test_vtrn1q_u32(
 681 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
 682 // CHECK:   ret <4 x i32> [[SHUFFLE_I]]
 683 uint32x4_t test_vtrn1q_u32(uint32x4_t a, uint32x4_t b) {
 684   return vtrn1q_u32(a, b);
 685 }
 686
 687 // CHECK-LABEL: @test_vtrn1q_u64(
 688 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 0, i32 2>
 689 // CHECK:   ret <2 x i64> [[SHUFFLE_I]]
 690 uint64x2_t test_vtrn1q_u64(uint64x2_t a, uint64x2_t b) {
 691   return vtrn1q_u64(a, b);
 692 }
 693
 694 // CHECK-LABEL: @test_vtrn1_f32(
 695 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 0, i32 2>
 696 // CHECK:   ret <2 x float> [[SHUFFLE_I]]
 697 float32x2_t test_vtrn1_f32(float32x2_t a, float32x2_t b) {
 698   return vtrn1_f32(a, b);
 699 }
 700
 701 // CHECK-LABEL: @test_vtrn1q_f32(
 702 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
 703 // CHECK:   ret <4 x float> [[SHUFFLE_I]]
 704 float32x4_t test_vtrn1q_f32(float32x4_t a, float32x4_t b) {
 705   return vtrn1q_f32(a, b);
 706 }
 707
 708 // CHECK-LABEL: @test_vtrn1q_f64(
 709 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x double> %a, <2 x double> %b, <2 x i32> <i32 0, i32 2>
 710 // CHECK:   ret <2 x double> [[SHUFFLE_I]]
 711 float64x2_t test_vtrn1q_f64(float64x2_t a, float64x2_t b) {
 712   return vtrn1q_f64(a, b);
 713 }
 714
 715 // CHECK-LABEL: @test_vtrn1_p8(
 716 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
 717 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
 718 poly8x8_t test_vtrn1_p8(poly8x8_t a, poly8x8_t b) {
 719   return vtrn1_p8(a, b);
 720 }
 721
 722 // CHECK-LABEL: @test_vtrn1q_p8(
 723 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 2, i32 18, i32 4, i32 20, i32 6, i32 22, i32 8, i32 24, i32 10, i32 26, i32 12, i32 28, i32 14, i32 30>
 724 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
 725 poly8x16_t test_vtrn1q_p8(poly8x16_t a, poly8x16_t b) {
 726   return vtrn1q_p8(a, b);
 727 }
 728
 729 // CHECK-LABEL: @test_vtrn1_p16(
 730 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
 731 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
 732 poly16x4_t test_vtrn1_p16(poly16x4_t a, poly16x4_t b) {
 733   return vtrn1_p16(a, b);
 734 }
 735
 736 // CHECK-LABEL: @test_vtrn1q_p16(
 737 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
 738 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
 739 poly16x8_t test_vtrn1q_p16(poly16x8_t a, poly16x8_t b) {
 740   return vtrn1q_p16(a, b);
 741 }
 742
 743 // CHECK-LABEL: @test_vtrn2_s8(
 744 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
 745 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
 746 int8x8_t test_vtrn2_s8(int8x8_t a, int8x8_t b) {
 747   return vtrn2_s8(a, b);
 748 }
 749
 750 // CHECK-LABEL: @test_vtrn2q_s8(
 751 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 17, i32 3, i32 19, i32 5, i32 21, i32 7, i32 23, i32 9, i32 25, i32 11, i32 27, i32 13, i32 29, i32 15, i32 31>
 752 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
 753 int8x16_t test_vtrn2q_s8(int8x16_t a, int8x16_t b) {
 754   return vtrn2q_s8(a, b);
 755 }
 756
 757 // CHECK-LABEL: @test_vtrn2_s16(
 758 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
 759 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
 760 int16x4_t test_vtrn2_s16(int16x4_t a, int16x4_t b) {
 761   return vtrn2_s16(a, b);
 762 }
 763
 764 // CHECK-LABEL: @test_vtrn2q_s16(
 765 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
 766 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
 767 int16x8_t test_vtrn2q_s16(int16x8_t a, int16x8_t b) {
 768   return vtrn2q_s16(a, b);
 769 }
 770
 771 // CHECK-LABEL: @test_vtrn2_s32(
 772 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
 773 // CHECK:   ret <2 x i32> [[SHUFFLE_I]]
 774 int32x2_t test_vtrn2_s32(int32x2_t a, int32x2_t b) {
 775   return vtrn2_s32(a, b);
 776 }
 777
 778 // CHECK-LABEL: @test_vtrn2q_s32(
 779 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
 780 // CHECK:   ret <4 x i32> [[SHUFFLE_I]]
 781 int32x4_t test_vtrn2q_s32(int32x4_t a, int32x4_t b) {
 782   return vtrn2q_s32(a, b);
 783 }
 784
 785 // CHECK-LABEL: @test_vtrn2q_s64(
 786 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 1, i32 3>
 787 // CHECK:   ret <2 x i64> [[SHUFFLE_I]]
 788 int64x2_t test_vtrn2q_s64(int64x2_t a, int64x2_t b) {
 789   return vtrn2q_s64(a, b);
 790 }
 791
 792 // CHECK-LABEL: @test_vtrn2_u8(
 793 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
 794 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
 795 uint8x8_t test_vtrn2_u8(uint8x8_t a, uint8x8_t b) {
 796   return vtrn2_u8(a, b);
 797 }
 798
 799 // CHECK-LABEL: @test_vtrn2q_u8(
 800 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 17, i32 3, i32 19, i32 5, i32 21, i32 7, i32 23, i32 9, i32 25, i32 11, i32 27, i32 13, i32 29, i32 15, i32 31>
 801 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
 802 uint8x16_t test_vtrn2q_u8(uint8x16_t a, uint8x16_t b) {
 803   return vtrn2q_u8(a, b);
 804 }
 805
 806 // CHECK-LABEL: @test_vtrn2_u16(
 807 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
 808 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
 809 uint16x4_t test_vtrn2_u16(uint16x4_t a, uint16x4_t b) {
 810   return vtrn2_u16(a, b);
 811 }
 812
 813 // CHECK-LABEL: @test_vtrn2q_u16(
 814 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
 815 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
 816 uint16x8_t test_vtrn2q_u16(uint16x8_t a, uint16x8_t b) {
 817   return vtrn2q_u16(a, b);
 818 }
 819
 820 // CHECK-LABEL: @test_vtrn2_u32(
 821 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
 822 // CHECK:   ret <2 x i32> [[SHUFFLE_I]]
 823 uint32x2_t test_vtrn2_u32(uint32x2_t a, uint32x2_t b) {
 824   return vtrn2_u32(a, b);
 825 }
 826
 827 // CHECK-LABEL: @test_vtrn2q_u32(
 828 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
 829 // CHECK:   ret <4 x i32> [[SHUFFLE_I]]
 830 uint32x4_t test_vtrn2q_u32(uint32x4_t a, uint32x4_t b) {
 831   return vtrn2q_u32(a, b);
 832 }
 833
 834 // CHECK-LABEL: @test_vtrn2q_u64(
 835 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 1, i32 3>
 836 // CHECK:   ret <2 x i64> [[SHUFFLE_I]]
 837 uint64x2_t test_vtrn2q_u64(uint64x2_t a, uint64x2_t b) {
 838   return vtrn2q_u64(a, b);
 839 }
 840
 841 // CHECK-LABEL: @test_vtrn2_f32(
 842 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 1, i32 3>
 843 // CHECK:   ret <2 x float> [[SHUFFLE_I]]
 844 float32x2_t test_vtrn2_f32(float32x2_t a, float32x2_t b) {
 845   return vtrn2_f32(a, b);
 846 }
 847
 848 // CHECK-LABEL: @test_vtrn2q_f32(
 849 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
 850 // CHECK:   ret <4 x float> [[SHUFFLE_I]]
 851 float32x4_t test_vtrn2q_f32(float32x4_t a, float32x4_t b) {
 852   return vtrn2q_f32(a, b);
 853 }
 854
 855 // CHECK-LABEL: @test_vtrn2q_f64(
 856 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <2 x double> %a, <2 x double> %b, <2 x i32> <i32 1, i32 3>
 857 // CHECK:   ret <2 x double> [[SHUFFLE_I]]
 858 float64x2_t test_vtrn2q_f64(float64x2_t a, float64x2_t b) {
 859   return vtrn2q_f64(a, b);
 860 }
 861
 862 // CHECK-LABEL: @test_vtrn2_p8(
 863 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
 864 // CHECK:   ret <8 x i8> [[SHUFFLE_I]]
 865 poly8x8_t test_vtrn2_p8(poly8x8_t a, poly8x8_t b) {
 866   return vtrn2_p8(a, b);
 867 }
 868
 869 // CHECK-LABEL: @test_vtrn2q_p8(
 870 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 17, i32 3, i32 19, i32 5, i32 21, i32 7, i32 23, i32 9, i32 25, i32 11, i32 27, i32 13, i32 29, i32 15, i32 31>
 871 // CHECK:   ret <16 x i8> [[SHUFFLE_I]]
 872 poly8x16_t test_vtrn2q_p8(poly8x16_t a, poly8x16_t b) {
 873   return vtrn2q_p8(a, b);
 874 }
 875
 876 // CHECK-LABEL: @test_vtrn2_p16(
 877 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
 878 // CHECK:   ret <4 x i16> [[SHUFFLE_I]]
 879 poly16x4_t test_vtrn2_p16(poly16x4_t a, poly16x4_t b) {
 880   return vtrn2_p16(a, b);
 881 }
 882
 883 // CHECK-LABEL: @test_vtrn2q_p16(
 884 // CHECK:   [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
 885 // CHECK:   ret <8 x i16> [[SHUFFLE_I]]
 886 poly16x8_t test_vtrn2q_p16(poly16x8_t a, poly16x8_t b) {
 887   return vtrn2q_p16(a, b);
 888 }
 889
 890 // CHECK-LABEL: @test_vuzp_s8(
 891 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int8x8x2_t, align 8
 892 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int8x8x2_t, align 8
 893 // CHECK:   [[VUZP_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
 894 // CHECK:   store <8 x i8> [[VUZP_I]], ptr [[RETVAL_I]]
 895 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
 896 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
 897 // CHECK:   store <8 x i8> [[VUZP1_I]], ptr [[TMP2]]
 898 // CHECK:   [[TMP5:%.*]] = load %struct.int8x8x2_t, ptr [[RETVAL_I]], align 8
 899 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.int8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
 900 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.int8x8x2_t [[TMP5]], 0
 901 // CHECK:   store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
 902 // CHECK:   [[TMP8:%.*]] = load %struct.int8x8x2_t, ptr [[RETVAL]], align 8
 903 // CHECK:   ret %struct.int8x8x2_t [[TMP8]]
 904 int8x8x2_t test_vuzp_s8(int8x8_t a, int8x8_t b) {
 905   return vuzp_s8(a, b);
 906 }
 907
 908 // CHECK-LABEL: @test_vuzp_s16(
 909 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int16x4x2_t, align 8
 910 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int16x4x2_t, align 8
 911 // CHECK:   [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
 912 // CHECK:   [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
 913 // CHECK:   [[VUZP_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
 914 // CHECK:   store <4 x i16> [[VUZP_I]], ptr [[RETVAL_I]]
 915 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
 916 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
 917 // CHECK:   store <4 x i16> [[VUZP1_I]], ptr [[TMP4]]
 918 // CHECK:   [[TMP7:%.*]] = load %struct.int16x4x2_t, ptr [[RETVAL_I]], align 8
 919 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.int16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
 920 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.int16x4x2_t [[TMP7]], 0
 921 // CHECK:   store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
 922 // CHECK:   [[TMP10:%.*]] = load %struct.int16x4x2_t, ptr [[RETVAL]], align 8
 923 // CHECK:   ret %struct.int16x4x2_t [[TMP10]]
 924 int16x4x2_t test_vuzp_s16(int16x4_t a, int16x4_t b) {
 925   return vuzp_s16(a, b);
 926 }
 927
 928 // CHECK-LABEL: @test_vuzp_s32(
 929 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int32x2x2_t, align 8
 930 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int32x2x2_t, align 8
 931 // CHECK:   [[TMP1:%.*]] = bitcast <2 x i32> %a to <8 x i8>
 932 // CHECK:   [[TMP2:%.*]] = bitcast <2 x i32> %b to <8 x i8>
 933 // CHECK:   [[VUZP_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
 934 // CHECK:   store <2 x i32> [[VUZP_I]], ptr [[RETVAL_I]]
 935 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <2 x i32>, ptr [[RETVAL_I]], i32 1
 936 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
 937 // CHECK:   store <2 x i32> [[VUZP1_I]], ptr [[TMP4]]
 938 // CHECK:   [[TMP7:%.*]] = load %struct.int32x2x2_t, ptr [[RETVAL_I]], align 8
 939 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.int32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
 940 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.int32x2x2_t [[TMP7]], 0
 941 // CHECK:   store [2 x <2 x i32>] [[TMP9]], ptr [[TMP8]], align 8
 942 // CHECK:   [[TMP10:%.*]] = load %struct.int32x2x2_t, ptr [[RETVAL]], align 8
 943 // CHECK:   ret %struct.int32x2x2_t [[TMP10]]
 944 int32x2x2_t test_vuzp_s32(int32x2_t a, int32x2_t b) {
 945   return vuzp_s32(a, b);
 946 }
 947
 948 // CHECK-LABEL: @test_vuzp_u8(
 949 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint8x8x2_t, align 8
 950 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint8x8x2_t, align 8
 951 // CHECK:   [[VUZP_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
 952 // CHECK:   store <8 x i8> [[VUZP_I]], ptr [[RETVAL_I]]
 953 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
 954 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
 955 // CHECK:   store <8 x i8> [[VUZP1_I]], ptr [[TMP2]]
 956 // CHECK:   [[TMP5:%.*]] = load %struct.uint8x8x2_t, ptr [[RETVAL_I]], align 8
 957 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.uint8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
 958 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.uint8x8x2_t [[TMP5]], 0
 959 // CHECK:   store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
 960 // CHECK:   [[TMP8:%.*]] = load %struct.uint8x8x2_t, ptr [[RETVAL]], align 8
 961 // CHECK:   ret %struct.uint8x8x2_t [[TMP8]]
 962 uint8x8x2_t test_vuzp_u8(uint8x8_t a, uint8x8_t b) {
 963   return vuzp_u8(a, b);
 964 }
 965
 966 // CHECK-LABEL: @test_vuzp_u16(
 967 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint16x4x2_t, align 8
 968 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint16x4x2_t, align 8
 969 // CHECK:   [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
 970 // CHECK:   [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
 971 // CHECK:   [[VUZP_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
 972 // CHECK:   store <4 x i16> [[VUZP_I]], ptr [[RETVAL_I]]
 973 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
 974 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
 975 // CHECK:   store <4 x i16> [[VUZP1_I]], ptr [[TMP4]]
 976 // CHECK:   [[TMP7:%.*]] = load %struct.uint16x4x2_t, ptr [[RETVAL_I]], align 8
 977 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.uint16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
 978 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.uint16x4x2_t [[TMP7]], 0
 979 // CHECK:   store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
 980 // CHECK:   [[TMP10:%.*]] = load %struct.uint16x4x2_t, ptr [[RETVAL]], align 8
 981 // CHECK:   ret %struct.uint16x4x2_t [[TMP10]]
 982 uint16x4x2_t test_vuzp_u16(uint16x4_t a, uint16x4_t b) {
 983   return vuzp_u16(a, b);
 984 }
 985
 986 // CHECK-LABEL: @test_vuzp_u32(
 987 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint32x2x2_t, align 8
 988 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint32x2x2_t, align 8
 989 // CHECK:   [[TMP1:%.*]] = bitcast <2 x i32> %a to <8 x i8>
 990 // CHECK:   [[TMP2:%.*]] = bitcast <2 x i32> %b to <8 x i8>
 991 // CHECK:   [[VUZP_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
 992 // CHECK:   store <2 x i32> [[VUZP_I]], ptr [[RETVAL_I]]
 993 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <2 x i32>, ptr [[RETVAL_I]], i32 1
 994 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
 995 // CHECK:   store <2 x i32> [[VUZP1_I]], ptr [[TMP4]]
 996 // CHECK:   [[TMP7:%.*]] = load %struct.uint32x2x2_t, ptr [[RETVAL_I]], align 8
 997 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.uint32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
 998 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.uint32x2x2_t [[TMP7]], 0
 999 // CHECK:   store [2 x <2 x i32>] [[TMP9]], ptr [[TMP8]], align 8
1000 // CHECK:   [[TMP10:%.*]] = load %struct.uint32x2x2_t, ptr [[RETVAL]], align 8
1001 // CHECK:   ret %struct.uint32x2x2_t [[TMP10]]
1002 uint32x2x2_t test_vuzp_u32(uint32x2_t a, uint32x2_t b) {
1003   return vuzp_u32(a, b);
1004 }
1005
1006 // CHECK-LABEL: @test_vuzp_f32(
1007 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.float32x2x2_t, align 8
1008 // CHECK:   [[RETVAL:%.*]] = alloca %struct.float32x2x2_t, align 8
1009 // CHECK:   [[TMP1:%.*]] = bitcast <2 x float> %a to <8 x i8>
1010 // CHECK:   [[TMP2:%.*]] = bitcast <2 x float> %b to <8 x i8>
1011 // CHECK:   [[VUZP_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 0, i32 2>
1012 // CHECK:   store <2 x float> [[VUZP_I]], ptr [[RETVAL_I]]
1013 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <2 x float>, ptr [[RETVAL_I]], i32 1
1014 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 1, i32 3>
1015 // CHECK:   store <2 x float> [[VUZP1_I]], ptr [[TMP4]]
1016 // CHECK:   [[TMP7:%.*]] = load %struct.float32x2x2_t, ptr [[RETVAL_I]], align 8
1017 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.float32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
1018 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.float32x2x2_t [[TMP7]], 0
1019 // CHECK:   store [2 x <2 x float>] [[TMP9]], ptr [[TMP8]], align 8
1020 // CHECK:   [[TMP10:%.*]] = load %struct.float32x2x2_t, ptr [[RETVAL]], align 8
1021 // CHECK:   ret %struct.float32x2x2_t [[TMP10]]
1022 float32x2x2_t test_vuzp_f32(float32x2_t a, float32x2_t b) {
1023   return vuzp_f32(a, b);
1024 }
1025
1026 // CHECK-LABEL: @test_vuzp_p8(
1027 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.poly8x8x2_t, align 8
1028 // CHECK:   [[RETVAL:%.*]] = alloca %struct.poly8x8x2_t, align 8
1029 // CHECK:   [[VUZP_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
1030 // CHECK:   store <8 x i8> [[VUZP_I]], ptr [[RETVAL_I]]
1031 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
1032 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
1033 // CHECK:   store <8 x i8> [[VUZP1_I]], ptr [[TMP2]]
1034 // CHECK:   [[TMP5:%.*]] = load %struct.poly8x8x2_t, ptr [[RETVAL_I]], align 8
1035 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.poly8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1036 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.poly8x8x2_t [[TMP5]], 0
1037 // CHECK:   store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
1038 // CHECK:   [[TMP8:%.*]] = load %struct.poly8x8x2_t, ptr [[RETVAL]], align 8
1039 // CHECK:   ret %struct.poly8x8x2_t [[TMP8]]
1040 poly8x8x2_t test_vuzp_p8(poly8x8_t a, poly8x8_t b) {
1041   return vuzp_p8(a, b);
1042 }
1043
1044 // CHECK-LABEL: @test_vuzp_p16(
1045 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.poly16x4x2_t, align 8
1046 // CHECK:   [[RETVAL:%.*]] = alloca %struct.poly16x4x2_t, align 8
1047 // CHECK:   [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
1048 // CHECK:   [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
1049 // CHECK:   [[VUZP_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
1050 // CHECK:   store <4 x i16> [[VUZP_I]], ptr [[RETVAL_I]]
1051 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
1052 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
1053 // CHECK:   store <4 x i16> [[VUZP1_I]], ptr [[TMP4]]
1054 // CHECK:   [[TMP7:%.*]] = load %struct.poly16x4x2_t, ptr [[RETVAL_I]], align 8
1055 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.poly16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1056 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.poly16x4x2_t [[TMP7]], 0
1057 // CHECK:   store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
1058 // CHECK:   [[TMP10:%.*]] = load %struct.poly16x4x2_t, ptr [[RETVAL]], align 8
1059 // CHECK:   ret %struct.poly16x4x2_t [[TMP10]]
1060 poly16x4x2_t test_vuzp_p16(poly16x4_t a, poly16x4_t b) {
1061   return vuzp_p16(a, b);
1062 }
1063
1064 // CHECK-LABEL: @test_vuzpq_s8(
1065 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int8x16x2_t, align 16
1066 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int8x16x2_t, align 16
1067 // CHECK:   [[VUZP_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
1068 // CHECK:   store <16 x i8> [[VUZP_I]], ptr [[RETVAL_I]]
1069 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1070 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
1071 // CHECK:   store <16 x i8> [[VUZP1_I]], ptr [[TMP2]]
1072 // CHECK:   [[TMP5:%.*]] = load %struct.int8x16x2_t, ptr [[RETVAL_I]], align 16
1073 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.int8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1074 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.int8x16x2_t [[TMP5]], 0
1075 // CHECK:   store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1076 // CHECK:   [[TMP8:%.*]] = load %struct.int8x16x2_t, ptr [[RETVAL]], align 16
1077 // CHECK:   ret %struct.int8x16x2_t [[TMP8]]
1078 int8x16x2_t test_vuzpq_s8(int8x16_t a, int8x16_t b) {
1079   return vuzpq_s8(a, b);
1080 }
1081
1082 // CHECK-LABEL: @test_vuzpq_s16(
1083 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int16x8x2_t, align 16
1084 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int16x8x2_t, align 16
1085 // CHECK:   [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1086 // CHECK:   [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1087 // CHECK:   [[VUZP_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
1088 // CHECK:   store <8 x i16> [[VUZP_I]], ptr [[RETVAL_I]]
1089 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1090 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
1091 // CHECK:   store <8 x i16> [[VUZP1_I]], ptr [[TMP4]]
1092 // CHECK:   [[TMP7:%.*]] = load %struct.int16x8x2_t, ptr [[RETVAL_I]], align 16
1093 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.int16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1094 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.int16x8x2_t [[TMP7]], 0
1095 // CHECK:   store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1096 // CHECK:   [[TMP10:%.*]] = load %struct.int16x8x2_t, ptr [[RETVAL]], align 16
1097 // CHECK:   ret %struct.int16x8x2_t [[TMP10]]
1098 int16x8x2_t test_vuzpq_s16(int16x8_t a, int16x8_t b) {
1099   return vuzpq_s16(a, b);
1100 }
1101
1102 // CHECK-LABEL: @test_vuzpq_s32(
1103 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int32x4x2_t, align 16
1104 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int32x4x2_t, align 16
1105 // CHECK:   [[TMP1:%.*]] = bitcast <4 x i32> %a to <16 x i8>
1106 // CHECK:   [[TMP2:%.*]] = bitcast <4 x i32> %b to <16 x i8>
1107 // CHECK:   [[VUZP_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
1108 // CHECK:   store <4 x i32> [[VUZP_I]], ptr [[RETVAL_I]]
1109 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x i32>, ptr [[RETVAL_I]], i32 1
1110 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
1111 // CHECK:   store <4 x i32> [[VUZP1_I]], ptr [[TMP4]]
1112 // CHECK:   [[TMP7:%.*]] = load %struct.int32x4x2_t, ptr [[RETVAL_I]], align 16
1113 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.int32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1114 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.int32x4x2_t [[TMP7]], 0
1115 // CHECK:   store [2 x <4 x i32>] [[TMP9]], ptr [[TMP8]], align 16
1116 // CHECK:   [[TMP10:%.*]] = load %struct.int32x4x2_t, ptr [[RETVAL]], align 16
1117 // CHECK:   ret %struct.int32x4x2_t [[TMP10]]
1118 int32x4x2_t test_vuzpq_s32(int32x4_t a, int32x4_t b) {
1119   return vuzpq_s32(a, b);
1120 }
1121
1122 // CHECK-LABEL: @test_vuzpq_u8(
1123 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint8x16x2_t, align 16
1124 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint8x16x2_t, align 16
1125 // CHECK:   [[VUZP_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
1126 // CHECK:   store <16 x i8> [[VUZP_I]], ptr [[RETVAL_I]]
1127 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1128 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
1129 // CHECK:   store <16 x i8> [[VUZP1_I]], ptr [[TMP2]]
1130 // CHECK:   [[TMP5:%.*]] = load %struct.uint8x16x2_t, ptr [[RETVAL_I]], align 16
1131 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.uint8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1132 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.uint8x16x2_t [[TMP5]], 0
1133 // CHECK:   store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1134 // CHECK:   [[TMP8:%.*]] = load %struct.uint8x16x2_t, ptr [[RETVAL]], align 16
1135 // CHECK:   ret %struct.uint8x16x2_t [[TMP8]]
1136 uint8x16x2_t test_vuzpq_u8(uint8x16_t a, uint8x16_t b) {
1137   return vuzpq_u8(a, b);
1138 }
1139
1140 // CHECK-LABEL: @test_vuzpq_u16(
1141 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint16x8x2_t, align 16
1142 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint16x8x2_t, align 16
1143 // CHECK:   [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1144 // CHECK:   [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1145 // CHECK:   [[VUZP_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
1146 // CHECK:   store <8 x i16> [[VUZP_I]], ptr [[RETVAL_I]]
1147 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1148 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
1149 // CHECK:   store <8 x i16> [[VUZP1_I]], ptr [[TMP4]]
1150 // CHECK:   [[TMP7:%.*]] = load %struct.uint16x8x2_t, ptr [[RETVAL_I]], align 16
1151 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.uint16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1152 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.uint16x8x2_t [[TMP7]], 0
1153 // CHECK:   store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1154 // CHECK:   [[TMP10:%.*]] = load %struct.uint16x8x2_t, ptr [[RETVAL]], align 16
1155 // CHECK:   ret %struct.uint16x8x2_t [[TMP10]]
1156 uint16x8x2_t test_vuzpq_u16(uint16x8_t a, uint16x8_t b) {
1157   return vuzpq_u16(a, b);
1158 }
1159
1160 // CHECK-LABEL: @test_vuzpq_u32(
1161 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint32x4x2_t, align 16
1162 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint32x4x2_t, align 16
1163 // CHECK:   [[TMP1:%.*]] = bitcast <4 x i32> %a to <16 x i8>
1164 // CHECK:   [[TMP2:%.*]] = bitcast <4 x i32> %b to <16 x i8>
1165 // CHECK:   [[VUZP_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
1166 // CHECK:   store <4 x i32> [[VUZP_I]], ptr [[RETVAL_I]]
1167 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x i32>, ptr [[RETVAL_I]], i32 1
1168 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
1169 // CHECK:   store <4 x i32> [[VUZP1_I]], ptr [[TMP4]]
1170 // CHECK:   [[TMP7:%.*]] = load %struct.uint32x4x2_t, ptr [[RETVAL_I]], align 16
1171 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.uint32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1172 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.uint32x4x2_t [[TMP7]], 0
1173 // CHECK:   store [2 x <4 x i32>] [[TMP9]], ptr [[TMP8]], align 16
1174 // CHECK:   [[TMP10:%.*]] = load %struct.uint32x4x2_t, ptr [[RETVAL]], align 16
1175 // CHECK:   ret %struct.uint32x4x2_t [[TMP10]]
1176 uint32x4x2_t test_vuzpq_u32(uint32x4_t a, uint32x4_t b) {
1177   return vuzpq_u32(a, b);
1178 }
1179
1180 // CHECK-LABEL: @test_vuzpq_f32(
1181 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.float32x4x2_t, align 16
1182 // CHECK:   [[RETVAL:%.*]] = alloca %struct.float32x4x2_t, align 16
1183 // CHECK:   [[TMP1:%.*]] = bitcast <4 x float> %a to <16 x i8>
1184 // CHECK:   [[TMP2:%.*]] = bitcast <4 x float> %b to <16 x i8>
1185 // CHECK:   [[VUZP_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
1186 // CHECK:   store <4 x float> [[VUZP_I]], ptr [[RETVAL_I]]
1187 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x float>, ptr [[RETVAL_I]], i32 1
1188 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
1189 // CHECK:   store <4 x float> [[VUZP1_I]], ptr [[TMP4]]
1190 // CHECK:   [[TMP7:%.*]] = load %struct.float32x4x2_t, ptr [[RETVAL_I]], align 16
1191 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.float32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1192 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.float32x4x2_t [[TMP7]], 0
1193 // CHECK:   store [2 x <4 x float>] [[TMP9]], ptr [[TMP8]], align 16
1194 // CHECK:   [[TMP10:%.*]] = load %struct.float32x4x2_t, ptr [[RETVAL]], align 16
1195 // CHECK:   ret %struct.float32x4x2_t [[TMP10]]
1196 float32x4x2_t test_vuzpq_f32(float32x4_t a, float32x4_t b) {
1197   return vuzpq_f32(a, b);
1198 }
1199
1200 // CHECK-LABEL: @test_vuzpq_p8(
1201 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.poly8x16x2_t, align 16
1202 // CHECK:   [[RETVAL:%.*]] = alloca %struct.poly8x16x2_t, align 16
1203 // CHECK:   [[VUZP_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
1204 // CHECK:   store <16 x i8> [[VUZP_I]], ptr [[RETVAL_I]]
1205 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1206 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
1207 // CHECK:   store <16 x i8> [[VUZP1_I]], ptr [[TMP2]]
1208 // CHECK:   [[TMP5:%.*]] = load %struct.poly8x16x2_t, ptr [[RETVAL_I]], align 16
1209 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.poly8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1210 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.poly8x16x2_t [[TMP5]], 0
1211 // CHECK:   store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1212 // CHECK:   [[TMP8:%.*]] = load %struct.poly8x16x2_t, ptr [[RETVAL]], align 16
1213 // CHECK:   ret %struct.poly8x16x2_t [[TMP8]]
1214 poly8x16x2_t test_vuzpq_p8(poly8x16_t a, poly8x16_t b) {
1215   return vuzpq_p8(a, b);
1216 }
1217
1218 // CHECK-LABEL: @test_vuzpq_p16(
1219 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.poly16x8x2_t, align 16
1220 // CHECK:   [[RETVAL:%.*]] = alloca %struct.poly16x8x2_t, align 16
1221 // CHECK:   [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1222 // CHECK:   [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1223 // CHECK:   [[VUZP_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
1224 // CHECK:   store <8 x i16> [[VUZP_I]], ptr [[RETVAL_I]]
1225 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1226 // CHECK:   [[VUZP1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
1227 // CHECK:   store <8 x i16> [[VUZP1_I]], ptr [[TMP4]]
1228 // CHECK:   [[TMP7:%.*]] = load %struct.poly16x8x2_t, ptr [[RETVAL_I]], align 16
1229 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.poly16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1230 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.poly16x8x2_t [[TMP7]], 0
1231 // CHECK:   store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1232 // CHECK:   [[TMP10:%.*]] = load %struct.poly16x8x2_t, ptr [[RETVAL]], align 16
1233 // CHECK:   ret %struct.poly16x8x2_t [[TMP10]]
1234 poly16x8x2_t test_vuzpq_p16(poly16x8_t a, poly16x8_t b) {
1235   return vuzpq_p16(a, b);
1236 }
1237
1238 // CHECK-LABEL: @test_vzip_s8(
1239 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int8x8x2_t, align 8
1240 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int8x8x2_t, align 8
1241 // CHECK:   [[VZIP_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
1242 // CHECK:   store <8 x i8> [[VZIP_I]], ptr [[RETVAL_I]]
1243 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
1244 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
1245 // CHECK:   store <8 x i8> [[VZIP1_I]], ptr [[TMP2]]
1246 // CHECK:   [[TMP5:%.*]] = load %struct.int8x8x2_t, ptr [[RETVAL_I]], align 8
1247 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.int8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1248 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.int8x8x2_t [[TMP5]], 0
1249 // CHECK:   store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
1250 // CHECK:   [[TMP8:%.*]] = load %struct.int8x8x2_t, ptr [[RETVAL]], align 8
1251 // CHECK:   ret %struct.int8x8x2_t [[TMP8]]
1252 int8x8x2_t test_vzip_s8(int8x8_t a, int8x8_t b) {
1253   return vzip_s8(a, b);
1254 }
1255
1256 // CHECK-LABEL: @test_vzip_s16(
1257 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int16x4x2_t, align 8
1258 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int16x4x2_t, align 8
1259 // CHECK:   [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
1260 // CHECK:   [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
1261 // CHECK:   [[VZIP_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
1262 // CHECK:   store <4 x i16> [[VZIP_I]], ptr [[RETVAL_I]]
1263 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
1264 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
1265 // CHECK:   store <4 x i16> [[VZIP1_I]], ptr [[TMP4]]
1266 // CHECK:   [[TMP7:%.*]] = load %struct.int16x4x2_t, ptr [[RETVAL_I]], align 8
1267 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.int16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1268 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.int16x4x2_t [[TMP7]], 0
1269 // CHECK:   store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
1270 // CHECK:   [[TMP10:%.*]] = load %struct.int16x4x2_t, ptr [[RETVAL]], align 8
1271 // CHECK:   ret %struct.int16x4x2_t [[TMP10]]
1272 int16x4x2_t test_vzip_s16(int16x4_t a, int16x4_t b) {
1273   return vzip_s16(a, b);
1274 }
1275
1276 // CHECK-LABEL: @test_vzip_s32(
1277 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int32x2x2_t, align 8
1278 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int32x2x2_t, align 8
1279 // CHECK:   [[TMP1:%.*]] = bitcast <2 x i32> %a to <8 x i8>
1280 // CHECK:   [[TMP2:%.*]] = bitcast <2 x i32> %b to <8 x i8>
1281 // CHECK:   [[VZIP_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
1282 // CHECK:   store <2 x i32> [[VZIP_I]], ptr [[RETVAL_I]]
1283 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <2 x i32>, ptr [[RETVAL_I]], i32 1
1284 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
1285 // CHECK:   store <2 x i32> [[VZIP1_I]], ptr [[TMP4]]
1286 // CHECK:   [[TMP7:%.*]] = load %struct.int32x2x2_t, ptr [[RETVAL_I]], align 8
1287 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.int32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
1288 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.int32x2x2_t [[TMP7]], 0
1289 // CHECK:   store [2 x <2 x i32>] [[TMP9]], ptr [[TMP8]], align 8
1290 // CHECK:   [[TMP10:%.*]] = load %struct.int32x2x2_t, ptr [[RETVAL]], align 8
1291 // CHECK:   ret %struct.int32x2x2_t [[TMP10]]
1292 int32x2x2_t test_vzip_s32(int32x2_t a, int32x2_t b) {
1293   return vzip_s32(a, b);
1294 }
1295
1296 // CHECK-LABEL: @test_vzip_u8(
1297 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint8x8x2_t, align 8
1298 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint8x8x2_t, align 8
1299 // CHECK:   [[VZIP_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
1300 // CHECK:   store <8 x i8> [[VZIP_I]], ptr [[RETVAL_I]]
1301 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
1302 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
1303 // CHECK:   store <8 x i8> [[VZIP1_I]], ptr [[TMP2]]
1304 // CHECK:   [[TMP5:%.*]] = load %struct.uint8x8x2_t, ptr [[RETVAL_I]], align 8
1305 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.uint8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1306 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.uint8x8x2_t [[TMP5]], 0
1307 // CHECK:   store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
1308 // CHECK:   [[TMP8:%.*]] = load %struct.uint8x8x2_t, ptr [[RETVAL]], align 8
1309 // CHECK:   ret %struct.uint8x8x2_t [[TMP8]]
1310 uint8x8x2_t test_vzip_u8(uint8x8_t a, uint8x8_t b) {
1311   return vzip_u8(a, b);
1312 }
1313
1314 // CHECK-LABEL: @test_vzip_u16(
1315 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint16x4x2_t, align 8
1316 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint16x4x2_t, align 8
1317 // CHECK:   [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
1318 // CHECK:   [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
1319 // CHECK:   [[VZIP_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
1320 // CHECK:   store <4 x i16> [[VZIP_I]], ptr [[RETVAL_I]]
1321 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
1322 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
1323 // CHECK:   store <4 x i16> [[VZIP1_I]], ptr [[TMP4]]
1324 // CHECK:   [[TMP7:%.*]] = load %struct.uint16x4x2_t, ptr [[RETVAL_I]], align 8
1325 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.uint16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1326 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.uint16x4x2_t [[TMP7]], 0
1327 // CHECK:   store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
1328 // CHECK:   [[TMP10:%.*]] = load %struct.uint16x4x2_t, ptr [[RETVAL]], align 8
1329 // CHECK:   ret %struct.uint16x4x2_t [[TMP10]]
1330 uint16x4x2_t test_vzip_u16(uint16x4_t a, uint16x4_t b) {
1331   return vzip_u16(a, b);
1332 }
1333
1334 // CHECK-LABEL: @test_vzip_u32(
1335 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint32x2x2_t, align 8
1336 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint32x2x2_t, align 8
1337 // CHECK:   [[TMP1:%.*]] = bitcast <2 x i32> %a to <8 x i8>
1338 // CHECK:   [[TMP2:%.*]] = bitcast <2 x i32> %b to <8 x i8>
1339 // CHECK:   [[VZIP_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
1340 // CHECK:   store <2 x i32> [[VZIP_I]], ptr [[RETVAL_I]]
1341 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <2 x i32>, ptr [[RETVAL_I]], i32 1
1342 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
1343 // CHECK:   store <2 x i32> [[VZIP1_I]], ptr [[TMP4]]
1344 // CHECK:   [[TMP7:%.*]] = load %struct.uint32x2x2_t, ptr [[RETVAL_I]], align 8
1345 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.uint32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
1346 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.uint32x2x2_t [[TMP7]], 0
1347 // CHECK:   store [2 x <2 x i32>] [[TMP9]], ptr [[TMP8]], align 8
1348 // CHECK:   [[TMP10:%.*]] = load %struct.uint32x2x2_t, ptr [[RETVAL]], align 8
1349 // CHECK:   ret %struct.uint32x2x2_t [[TMP10]]
1350 uint32x2x2_t test_vzip_u32(uint32x2_t a, uint32x2_t b) {
1351   return vzip_u32(a, b);
1352 }
1353
1354 // CHECK-LABEL: @test_vzip_f32(
1355 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.float32x2x2_t, align 8
1356 // CHECK:   [[RETVAL:%.*]] = alloca %struct.float32x2x2_t, align 8
1357 // CHECK:   [[TMP1:%.*]] = bitcast <2 x float> %a to <8 x i8>
1358 // CHECK:   [[TMP2:%.*]] = bitcast <2 x float> %b to <8 x i8>
1359 // CHECK:   [[VZIP_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 0, i32 2>
1360 // CHECK:   store <2 x float> [[VZIP_I]], ptr [[RETVAL_I]]
1361 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <2 x float>, ptr [[RETVAL_I]], i32 1
1362 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 1, i32 3>
1363 // CHECK:   store <2 x float> [[VZIP1_I]], ptr [[TMP4]]
1364 // CHECK:   [[TMP7:%.*]] = load %struct.float32x2x2_t, ptr [[RETVAL_I]], align 8
1365 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.float32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
1366 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.float32x2x2_t [[TMP7]], 0
1367 // CHECK:   store [2 x <2 x float>] [[TMP9]], ptr [[TMP8]], align 8
1368 // CHECK:   [[TMP10:%.*]] = load %struct.float32x2x2_t, ptr [[RETVAL]], align 8
1369 // CHECK:   ret %struct.float32x2x2_t [[TMP10]]
1370 float32x2x2_t test_vzip_f32(float32x2_t a, float32x2_t b) {
1371   return vzip_f32(a, b);
1372 }
1373
1374 // CHECK-LABEL: @test_vzip_p8(
1375 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.poly8x8x2_t, align 8
1376 // CHECK:   [[RETVAL:%.*]] = alloca %struct.poly8x8x2_t, align 8
1377 // CHECK:   [[VZIP_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
1378 // CHECK:   store <8 x i8> [[VZIP_I]], ptr [[RETVAL_I]]
1379 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
1380 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
1381 // CHECK:   store <8 x i8> [[VZIP1_I]], ptr [[TMP2]]
1382 // CHECK:   [[TMP5:%.*]] = load %struct.poly8x8x2_t, ptr [[RETVAL_I]], align 8
1383 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.poly8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1384 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.poly8x8x2_t [[TMP5]], 0
1385 // CHECK:   store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
1386 // CHECK:   [[TMP8:%.*]] = load %struct.poly8x8x2_t, ptr [[RETVAL]], align 8
1387 // CHECK:   ret %struct.poly8x8x2_t [[TMP8]]
1388 poly8x8x2_t test_vzip_p8(poly8x8_t a, poly8x8_t b) {
1389   return vzip_p8(a, b);
1390 }
1391
1392 // CHECK-LABEL: @test_vzip_p16(
1393 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.poly16x4x2_t, align 8
1394 // CHECK:   [[RETVAL:%.*]] = alloca %struct.poly16x4x2_t, align 8
1395 // CHECK:   [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
1396 // CHECK:   [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
1397 // CHECK:   [[VZIP_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
1398 // CHECK:   store <4 x i16> [[VZIP_I]], ptr [[RETVAL_I]]
1399 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
1400 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
1401 // CHECK:   store <4 x i16> [[VZIP1_I]], ptr [[TMP4]]
1402 // CHECK:   [[TMP7:%.*]] = load %struct.poly16x4x2_t, ptr [[RETVAL_I]], align 8
1403 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.poly16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1404 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.poly16x4x2_t [[TMP7]], 0
1405 // CHECK:   store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
1406 // CHECK:   [[TMP10:%.*]] = load %struct.poly16x4x2_t, ptr [[RETVAL]], align 8
1407 // CHECK:   ret %struct.poly16x4x2_t [[TMP10]]
1408 poly16x4x2_t test_vzip_p16(poly16x4_t a, poly16x4_t b) {
1409   return vzip_p16(a, b);
1410 }
1411
1412 // CHECK-LABEL: @test_vzipq_s8(
1413 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int8x16x2_t, align 16
1414 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int8x16x2_t, align 16
1415 // CHECK:   [[VZIP_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
1416 // CHECK:   store <16 x i8> [[VZIP_I]], ptr [[RETVAL_I]]
1417 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1418 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
1419 // CHECK:   store <16 x i8> [[VZIP1_I]], ptr [[TMP2]]
1420 // CHECK:   [[TMP5:%.*]] = load %struct.int8x16x2_t, ptr [[RETVAL_I]], align 16
1421 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.int8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1422 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.int8x16x2_t [[TMP5]], 0
1423 // CHECK:   store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1424 // CHECK:   [[TMP8:%.*]] = load %struct.int8x16x2_t, ptr [[RETVAL]], align 16
1425 // CHECK:   ret %struct.int8x16x2_t [[TMP8]]
1426 int8x16x2_t test_vzipq_s8(int8x16_t a, int8x16_t b) {
1427   return vzipq_s8(a, b);
1428 }
1429
1430 // CHECK-LABEL: @test_vzipq_s16(
1431 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int16x8x2_t, align 16
1432 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int16x8x2_t, align 16
1433 // CHECK:   [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1434 // CHECK:   [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1435 // CHECK:   [[VZIP_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
1436 // CHECK:   store <8 x i16> [[VZIP_I]], ptr [[RETVAL_I]]
1437 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1438 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
1439 // CHECK:   store <8 x i16> [[VZIP1_I]], ptr [[TMP4]]
1440 // CHECK:   [[TMP7:%.*]] = load %struct.int16x8x2_t, ptr [[RETVAL_I]], align 16
1441 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.int16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1442 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.int16x8x2_t [[TMP7]], 0
1443 // CHECK:   store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1444 // CHECK:   [[TMP10:%.*]] = load %struct.int16x8x2_t, ptr [[RETVAL]], align 16
1445 // CHECK:   ret %struct.int16x8x2_t [[TMP10]]
1446 int16x8x2_t test_vzipq_s16(int16x8_t a, int16x8_t b) {
1447   return vzipq_s16(a, b);
1448 }
1449
1450 // CHECK-LABEL: @test_vzipq_s32(
1451 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int32x4x2_t, align 16
1452 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int32x4x2_t, align 16
1453 // CHECK:   [[TMP1:%.*]] = bitcast <4 x i32> %a to <16 x i8>
1454 // CHECK:   [[TMP2:%.*]] = bitcast <4 x i32> %b to <16 x i8>
1455 // CHECK:   [[VZIP_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
1456 // CHECK:   store <4 x i32> [[VZIP_I]], ptr [[RETVAL_I]]
1457 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x i32>, ptr [[RETVAL_I]], i32 1
1458 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
1459 // CHECK:   store <4 x i32> [[VZIP1_I]], ptr [[TMP4]]
1460 // CHECK:   [[TMP7:%.*]] = load %struct.int32x4x2_t, ptr [[RETVAL_I]], align 16
1461 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.int32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1462 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.int32x4x2_t [[TMP7]], 0
1463 // CHECK:   store [2 x <4 x i32>] [[TMP9]], ptr [[TMP8]], align 16
1464 // CHECK:   [[TMP10:%.*]] = load %struct.int32x4x2_t, ptr [[RETVAL]], align 16
1465 // CHECK:   ret %struct.int32x4x2_t [[TMP10]]
1466 int32x4x2_t test_vzipq_s32(int32x4_t a, int32x4_t b) {
1467   return vzipq_s32(a, b);
1468 }
1469
1470 // CHECK-LABEL: @test_vzipq_u8(
1471 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint8x16x2_t, align 16
1472 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint8x16x2_t, align 16
1473 // CHECK:   [[VZIP_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
1474 // CHECK:   store <16 x i8> [[VZIP_I]], ptr [[RETVAL_I]]
1475 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1476 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
1477 // CHECK:   store <16 x i8> [[VZIP1_I]], ptr [[TMP2]]
1478 // CHECK:   [[TMP5:%.*]] = load %struct.uint8x16x2_t, ptr [[RETVAL_I]], align 16
1479 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.uint8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1480 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.uint8x16x2_t [[TMP5]], 0
1481 // CHECK:   store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1482 // CHECK:   [[TMP8:%.*]] = load %struct.uint8x16x2_t, ptr [[RETVAL]], align 16
1483 // CHECK:   ret %struct.uint8x16x2_t [[TMP8]]
1484 uint8x16x2_t test_vzipq_u8(uint8x16_t a, uint8x16_t b) {
1485   return vzipq_u8(a, b);
1486 }
1487
1488 // CHECK-LABEL: @test_vzipq_u16(
1489 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint16x8x2_t, align 16
1490 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint16x8x2_t, align 16
1491 // CHECK:   [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1492 // CHECK:   [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1493 // CHECK:   [[VZIP_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
1494 // CHECK:   store <8 x i16> [[VZIP_I]], ptr [[RETVAL_I]]
1495 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1496 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
1497 // CHECK:   store <8 x i16> [[VZIP1_I]], ptr [[TMP4]]
1498 // CHECK:   [[TMP7:%.*]] = load %struct.uint16x8x2_t, ptr [[RETVAL_I]], align 16
1499 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.uint16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1500 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.uint16x8x2_t [[TMP7]], 0
1501 // CHECK:   store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1502 // CHECK:   [[TMP10:%.*]] = load %struct.uint16x8x2_t, ptr [[RETVAL]], align 16
1503 // CHECK:   ret %struct.uint16x8x2_t [[TMP10]]
1504 uint16x8x2_t test_vzipq_u16(uint16x8_t a, uint16x8_t b) {
1505   return vzipq_u16(a, b);
1506 }
1507
1508 // CHECK-LABEL: @test_vzipq_u32(
1509 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint32x4x2_t, align 16
1510 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint32x4x2_t, align 16
1511 // CHECK:   [[TMP1:%.*]] = bitcast <4 x i32> %a to <16 x i8>
1512 // CHECK:   [[TMP2:%.*]] = bitcast <4 x i32> %b to <16 x i8>
1513 // CHECK:   [[VZIP_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
1514 // CHECK:   store <4 x i32> [[VZIP_I]], ptr [[RETVAL_I]]
1515 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x i32>, ptr [[RETVAL_I]], i32 1
1516 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
1517 // CHECK:   store <4 x i32> [[VZIP1_I]], ptr [[TMP4]]
1518 // CHECK:   [[TMP7:%.*]] = load %struct.uint32x4x2_t, ptr [[RETVAL_I]], align 16
1519 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.uint32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1520 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.uint32x4x2_t [[TMP7]], 0
1521 // CHECK:   store [2 x <4 x i32>] [[TMP9]], ptr [[TMP8]], align 16
1522 // CHECK:   [[TMP10:%.*]] = load %struct.uint32x4x2_t, ptr [[RETVAL]], align 16
1523 // CHECK:   ret %struct.uint32x4x2_t [[TMP10]]
1524 uint32x4x2_t test_vzipq_u32(uint32x4_t a, uint32x4_t b) {
1525   return vzipq_u32(a, b);
1526 }
1527
1528 // CHECK-LABEL: @test_vzipq_f32(
1529 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.float32x4x2_t, align 16
1530 // CHECK:   [[RETVAL:%.*]] = alloca %struct.float32x4x2_t, align 16
1531 // CHECK:   [[TMP1:%.*]] = bitcast <4 x float> %a to <16 x i8>
1532 // CHECK:   [[TMP2:%.*]] = bitcast <4 x float> %b to <16 x i8>
1533 // CHECK:   [[VZIP_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
1534 // CHECK:   store <4 x float> [[VZIP_I]], ptr [[RETVAL_I]]
1535 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x float>, ptr [[RETVAL_I]], i32 1
1536 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
1537 // CHECK:   store <4 x float> [[VZIP1_I]], ptr [[TMP4]]
1538 // CHECK:   [[TMP7:%.*]] = load %struct.float32x4x2_t, ptr [[RETVAL_I]], align 16
1539 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.float32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1540 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.float32x4x2_t [[TMP7]], 0
1541 // CHECK:   store [2 x <4 x float>] [[TMP9]], ptr [[TMP8]], align 16
1542 // CHECK:   [[TMP10:%.*]] = load %struct.float32x4x2_t, ptr [[RETVAL]], align 16
1543 // CHECK:   ret %struct.float32x4x2_t [[TMP10]]
1544 float32x4x2_t test_vzipq_f32(float32x4_t a, float32x4_t b) {
1545   return vzipq_f32(a, b);
1546 }
1547
1548 // CHECK-LABEL: @test_vzipq_p8(
1549 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.poly8x16x2_t, align 16
1550 // CHECK:   [[RETVAL:%.*]] = alloca %struct.poly8x16x2_t, align 16
1551 // CHECK:   [[VZIP_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
1552 // CHECK:   store <16 x i8> [[VZIP_I]], ptr [[RETVAL_I]]
1553 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1554 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
1555 // CHECK:   store <16 x i8> [[VZIP1_I]], ptr [[TMP2]]
1556 // CHECK:   [[TMP5:%.*]] = load %struct.poly8x16x2_t, ptr [[RETVAL_I]], align 16
1557 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.poly8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1558 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.poly8x16x2_t [[TMP5]], 0
1559 // CHECK:   store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1560 // CHECK:   [[TMP8:%.*]] = load %struct.poly8x16x2_t, ptr [[RETVAL]], align 16
1561 // CHECK:   ret %struct.poly8x16x2_t [[TMP8]]
1562 poly8x16x2_t test_vzipq_p8(poly8x16_t a, poly8x16_t b) {
1563   return vzipq_p8(a, b);
1564 }
1565
1566 // CHECK-LABEL: @test_vzipq_p16(
1567 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.poly16x8x2_t, align 16
1568 // CHECK:   [[RETVAL:%.*]] = alloca %struct.poly16x8x2_t, align 16
1569 // CHECK:   [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1570 // CHECK:   [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1571 // CHECK:   [[VZIP_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
1572 // CHECK:   store <8 x i16> [[VZIP_I]], ptr [[RETVAL_I]]
1573 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1574 // CHECK:   [[VZIP1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
1575 // CHECK:   store <8 x i16> [[VZIP1_I]], ptr [[TMP4]]
1576 // CHECK:   [[TMP7:%.*]] = load %struct.poly16x8x2_t, ptr [[RETVAL_I]], align 16
1577 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.poly16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1578 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.poly16x8x2_t [[TMP7]], 0
1579 // CHECK:   store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1580 // CHECK:   [[TMP10:%.*]] = load %struct.poly16x8x2_t, ptr [[RETVAL]], align 16
1581 // CHECK:   ret %struct.poly16x8x2_t [[TMP10]]
1582 poly16x8x2_t test_vzipq_p16(poly16x8_t a, poly16x8_t b) {
1583   return vzipq_p16(a, b);
1584 }
1585
1586 // CHECK-LABEL: @test_vtrn_s8(
1587 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int8x8x2_t, align 8
1588 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int8x8x2_t, align 8
1589 // CHECK:   [[VTRN_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
1590 // CHECK:   store <8 x i8> [[VTRN_I]], ptr [[RETVAL_I]]
1591 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
1592 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
1593 // CHECK:   store <8 x i8> [[VTRN1_I]], ptr [[TMP2]]
1594 // CHECK:   [[TMP5:%.*]] = load %struct.int8x8x2_t, ptr [[RETVAL_I]], align 8
1595 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.int8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1596 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.int8x8x2_t [[TMP5]], 0
1597 // CHECK:   store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
1598 // CHECK:   [[TMP8:%.*]] = load %struct.int8x8x2_t, ptr [[RETVAL]], align 8
1599 // CHECK:   ret %struct.int8x8x2_t [[TMP8]]
1600 int8x8x2_t test_vtrn_s8(int8x8_t a, int8x8_t b) {
1601   return vtrn_s8(a, b);
1602 }
1603
1604 // CHECK-LABEL: @test_vtrn_s16(
1605 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int16x4x2_t, align 8
1606 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int16x4x2_t, align 8
1607 // CHECK:   [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
1608 // CHECK:   [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
1609 // CHECK:   [[VTRN_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1610 // CHECK:   store <4 x i16> [[VTRN_I]], ptr [[RETVAL_I]]
1611 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
1612 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
1613 // CHECK:   store <4 x i16> [[VTRN1_I]], ptr [[TMP4]]
1614 // CHECK:   [[TMP7:%.*]] = load %struct.int16x4x2_t, ptr [[RETVAL_I]], align 8
1615 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.int16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1616 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.int16x4x2_t [[TMP7]], 0
1617 // CHECK:   store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
1618 // CHECK:   [[TMP10:%.*]] = load %struct.int16x4x2_t, ptr [[RETVAL]], align 8
1619 // CHECK:   ret %struct.int16x4x2_t [[TMP10]]
1620 int16x4x2_t test_vtrn_s16(int16x4_t a, int16x4_t b) {
1621   return vtrn_s16(a, b);
1622 }
1623
1624 // CHECK-LABEL: @test_vtrn_s32(
1625 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int32x2x2_t, align 8
1626 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int32x2x2_t, align 8
1627 // CHECK:   [[TMP1:%.*]] = bitcast <2 x i32> %a to <8 x i8>
1628 // CHECK:   [[TMP2:%.*]] = bitcast <2 x i32> %b to <8 x i8>
1629 // CHECK:   [[VTRN_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
1630 // CHECK:   store <2 x i32> [[VTRN_I]], ptr [[RETVAL_I]]
1631 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <2 x i32>, ptr [[RETVAL_I]], i32 1
1632 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
1633 // CHECK:   store <2 x i32> [[VTRN1_I]], ptr [[TMP4]]
1634 // CHECK:   [[TMP7:%.*]] = load %struct.int32x2x2_t, ptr [[RETVAL_I]], align 8
1635 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.int32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
1636 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.int32x2x2_t [[TMP7]], 0
1637 // CHECK:   store [2 x <2 x i32>] [[TMP9]], ptr [[TMP8]], align 8
1638 // CHECK:   [[TMP10:%.*]] = load %struct.int32x2x2_t, ptr [[RETVAL]], align 8
1639 // CHECK:   ret %struct.int32x2x2_t [[TMP10]]
1640 int32x2x2_t test_vtrn_s32(int32x2_t a, int32x2_t b) {
1641   return vtrn_s32(a, b);
1642 }
1643
1644 // CHECK-LABEL: @test_vtrn_u8(
1645 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint8x8x2_t, align 8
1646 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint8x8x2_t, align 8
1647 // CHECK:   [[VTRN_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
1648 // CHECK:   store <8 x i8> [[VTRN_I]], ptr [[RETVAL_I]]
1649 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
1650 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
1651 // CHECK:   store <8 x i8> [[VTRN1_I]], ptr [[TMP2]]
1652 // CHECK:   [[TMP5:%.*]] = load %struct.uint8x8x2_t, ptr [[RETVAL_I]], align 8
1653 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.uint8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1654 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.uint8x8x2_t [[TMP5]], 0
1655 // CHECK:   store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
1656 // CHECK:   [[TMP8:%.*]] = load %struct.uint8x8x2_t, ptr [[RETVAL]], align 8
1657 // CHECK:   ret %struct.uint8x8x2_t [[TMP8]]
1658 uint8x8x2_t test_vtrn_u8(uint8x8_t a, uint8x8_t b) {
1659   return vtrn_u8(a, b);
1660 }
1661
1662 // CHECK-LABEL: @test_vtrn_u16(
1663 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint16x4x2_t, align 8
1664 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint16x4x2_t, align 8
1665 // CHECK:   [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
1666 // CHECK:   [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
1667 // CHECK:   [[VTRN_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1668 // CHECK:   store <4 x i16> [[VTRN_I]], ptr [[RETVAL_I]]
1669 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
1670 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
1671 // CHECK:   store <4 x i16> [[VTRN1_I]], ptr [[TMP4]]
1672 // CHECK:   [[TMP7:%.*]] = load %struct.uint16x4x2_t, ptr [[RETVAL_I]], align 8
1673 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.uint16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1674 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.uint16x4x2_t [[TMP7]], 0
1675 // CHECK:   store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
1676 // CHECK:   [[TMP10:%.*]] = load %struct.uint16x4x2_t, ptr [[RETVAL]], align 8
1677 // CHECK:   ret %struct.uint16x4x2_t [[TMP10]]
1678 uint16x4x2_t test_vtrn_u16(uint16x4_t a, uint16x4_t b) {
1679   return vtrn_u16(a, b);
1680 }
1681
1682 // CHECK-LABEL: @test_vtrn_u32(
1683 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint32x2x2_t, align 8
1684 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint32x2x2_t, align 8
1685 // CHECK:   [[TMP1:%.*]] = bitcast <2 x i32> %a to <8 x i8>
1686 // CHECK:   [[TMP2:%.*]] = bitcast <2 x i32> %b to <8 x i8>
1687 // CHECK:   [[VTRN_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
1688 // CHECK:   store <2 x i32> [[VTRN_I]], ptr [[RETVAL_I]]
1689 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <2 x i32>, ptr [[RETVAL_I]], i32 1
1690 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
1691 // CHECK:   store <2 x i32> [[VTRN1_I]], ptr [[TMP4]]
1692 // CHECK:   [[TMP7:%.*]] = load %struct.uint32x2x2_t, ptr [[RETVAL_I]], align 8
1693 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.uint32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
1694 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.uint32x2x2_t [[TMP7]], 0
1695 // CHECK:   store [2 x <2 x i32>] [[TMP9]], ptr [[TMP8]], align 8
1696 // CHECK:   [[TMP10:%.*]] = load %struct.uint32x2x2_t, ptr [[RETVAL]], align 8
1697 // CHECK:   ret %struct.uint32x2x2_t [[TMP10]]
1698 uint32x2x2_t test_vtrn_u32(uint32x2_t a, uint32x2_t b) {
1699   return vtrn_u32(a, b);
1700 }
1701
1702 // CHECK-LABEL: @test_vtrn_f32(
1703 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.float32x2x2_t, align 8
1704 // CHECK:   [[RETVAL:%.*]] = alloca %struct.float32x2x2_t, align 8
1705 // CHECK:   [[TMP1:%.*]] = bitcast <2 x float> %a to <8 x i8>
1706 // CHECK:   [[TMP2:%.*]] = bitcast <2 x float> %b to <8 x i8>
1707 // CHECK:   [[VTRN_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 0, i32 2>
1708 // CHECK:   store <2 x float> [[VTRN_I]], ptr [[RETVAL_I]]
1709 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <2 x float>, ptr [[RETVAL_I]], i32 1
1710 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 1, i32 3>
1711 // CHECK:   store <2 x float> [[VTRN1_I]], ptr [[TMP4]]
1712 // CHECK:   [[TMP7:%.*]] = load %struct.float32x2x2_t, ptr [[RETVAL_I]], align 8
1713 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.float32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
1714 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.float32x2x2_t [[TMP7]], 0
1715 // CHECK:   store [2 x <2 x float>] [[TMP9]], ptr [[TMP8]], align 8
1716 // CHECK:   [[TMP10:%.*]] = load %struct.float32x2x2_t, ptr [[RETVAL]], align 8
1717 // CHECK:   ret %struct.float32x2x2_t [[TMP10]]
1718 float32x2x2_t test_vtrn_f32(float32x2_t a, float32x2_t b) {
1719   return vtrn_f32(a, b);
1720 }
1721
1722 // CHECK-LABEL: @test_vtrn_p8(
1723 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.poly8x8x2_t, align 8
1724 // CHECK:   [[RETVAL:%.*]] = alloca %struct.poly8x8x2_t, align 8
1725 // CHECK:   [[VTRN_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
1726 // CHECK:   store <8 x i8> [[VTRN_I]], ptr [[RETVAL_I]]
1727 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
1728 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
1729 // CHECK:   store <8 x i8> [[VTRN1_I]], ptr [[TMP2]]
1730 // CHECK:   [[TMP5:%.*]] = load %struct.poly8x8x2_t, ptr [[RETVAL_I]], align 8
1731 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.poly8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1732 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.poly8x8x2_t [[TMP5]], 0
1733 // CHECK:   store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
1734 // CHECK:   [[TMP8:%.*]] = load %struct.poly8x8x2_t, ptr [[RETVAL]], align 8
1735 // CHECK:   ret %struct.poly8x8x2_t [[TMP8]]
1736 poly8x8x2_t test_vtrn_p8(poly8x8_t a, poly8x8_t b) {
1737   return vtrn_p8(a, b);
1738 }
1739
1740 // CHECK-LABEL: @test_vtrn_p16(
1741 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.poly16x4x2_t, align 8
1742 // CHECK:   [[RETVAL:%.*]] = alloca %struct.poly16x4x2_t, align 8
1743 // CHECK:   [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
1744 // CHECK:   [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
1745 // CHECK:   [[VTRN_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1746 // CHECK:   store <4 x i16> [[VTRN_I]], ptr [[RETVAL_I]]
1747 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
1748 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
1749 // CHECK:   store <4 x i16> [[VTRN1_I]], ptr [[TMP4]]
1750 // CHECK:   [[TMP7:%.*]] = load %struct.poly16x4x2_t, ptr [[RETVAL_I]], align 8
1751 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.poly16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1752 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.poly16x4x2_t [[TMP7]], 0
1753 // CHECK:   store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
1754 // CHECK:   [[TMP10:%.*]] = load %struct.poly16x4x2_t, ptr [[RETVAL]], align 8
1755 // CHECK:   ret %struct.poly16x4x2_t [[TMP10]]
1756 poly16x4x2_t test_vtrn_p16(poly16x4_t a, poly16x4_t b) {
1757   return vtrn_p16(a, b);
1758 }
1759
1760 // CHECK-LABEL: @test_vtrnq_s8(
1761 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int8x16x2_t, align 16
1762 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int8x16x2_t, align 16
1763 // CHECK:   [[VTRN_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 2, i32 18, i32 4, i32 20, i32 6, i32 22, i32 8, i32 24, i32 10, i32 26, i32 12, i32 28, i32 14, i32 30>
1764 // CHECK:   store <16 x i8> [[VTRN_I]], ptr [[RETVAL_I]]
1765 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1766 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 17, i32 3, i32 19, i32 5, i32 21, i32 7, i32 23, i32 9, i32 25, i32 11, i32 27, i32 13, i32 29, i32 15, i32 31>
1767 // CHECK:   store <16 x i8> [[VTRN1_I]], ptr [[TMP2]]
1768 // CHECK:   [[TMP5:%.*]] = load %struct.int8x16x2_t, ptr [[RETVAL_I]], align 16
1769 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.int8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1770 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.int8x16x2_t [[TMP5]], 0
1771 // CHECK:   store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1772 // CHECK:   [[TMP8:%.*]] = load %struct.int8x16x2_t, ptr [[RETVAL]], align 16
1773 // CHECK:   ret %struct.int8x16x2_t [[TMP8]]
1774 int8x16x2_t test_vtrnq_s8(int8x16_t a, int8x16_t b) {
1775   return vtrnq_s8(a, b);
1776 }
1777
1778 // CHECK-LABEL: @test_vtrnq_s16(
1779 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int16x8x2_t, align 16
1780 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int16x8x2_t, align 16
1781 // CHECK:   [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1782 // CHECK:   [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1783 // CHECK:   [[VTRN_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
1784 // CHECK:   store <8 x i16> [[VTRN_I]], ptr [[RETVAL_I]]
1785 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1786 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
1787 // CHECK:   store <8 x i16> [[VTRN1_I]], ptr [[TMP4]]
1788 // CHECK:   [[TMP7:%.*]] = load %struct.int16x8x2_t, ptr [[RETVAL_I]], align 16
1789 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.int16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1790 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.int16x8x2_t [[TMP7]], 0
1791 // CHECK:   store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1792 // CHECK:   [[TMP10:%.*]] = load %struct.int16x8x2_t, ptr [[RETVAL]], align 16
1793 // CHECK:   ret %struct.int16x8x2_t [[TMP10]]
1794 int16x8x2_t test_vtrnq_s16(int16x8_t a, int16x8_t b) {
1795   return vtrnq_s16(a, b);
1796 }
1797
1798 // CHECK-LABEL: @test_vtrnq_s32(
1799 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.int32x4x2_t, align 16
1800 // CHECK:   [[RETVAL:%.*]] = alloca %struct.int32x4x2_t, align 16
1801 // CHECK:   [[TMP1:%.*]] = bitcast <4 x i32> %a to <16 x i8>
1802 // CHECK:   [[TMP2:%.*]] = bitcast <4 x i32> %b to <16 x i8>
1803 // CHECK:   [[VTRN_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1804 // CHECK:   store <4 x i32> [[VTRN_I]], ptr [[RETVAL_I]]
1805 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x i32>, ptr [[RETVAL_I]], i32 1
1806 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
1807 // CHECK:   store <4 x i32> [[VTRN1_I]], ptr [[TMP4]]
1808 // CHECK:   [[TMP7:%.*]] = load %struct.int32x4x2_t, ptr [[RETVAL_I]], align 16
1809 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.int32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1810 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.int32x4x2_t [[TMP7]], 0
1811 // CHECK:   store [2 x <4 x i32>] [[TMP9]], ptr [[TMP8]], align 16
1812 // CHECK:   [[TMP10:%.*]] = load %struct.int32x4x2_t, ptr [[RETVAL]], align 16
1813 // CHECK:   ret %struct.int32x4x2_t [[TMP10]]
1814 int32x4x2_t test_vtrnq_s32(int32x4_t a, int32x4_t b) {
1815   return vtrnq_s32(a, b);
1816 }
1817
1818 // CHECK-LABEL: @test_vtrnq_u8(
1819 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint8x16x2_t, align 16
1820 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint8x16x2_t, align 16
1821 // CHECK:   [[VTRN_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 2, i32 18, i32 4, i32 20, i32 6, i32 22, i32 8, i32 24, i32 10, i32 26, i32 12, i32 28, i32 14, i32 30>
1822 // CHECK:   store <16 x i8> [[VTRN_I]], ptr [[RETVAL_I]]
1823 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1824 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 17, i32 3, i32 19, i32 5, i32 21, i32 7, i32 23, i32 9, i32 25, i32 11, i32 27, i32 13, i32 29, i32 15, i32 31>
1825 // CHECK:   store <16 x i8> [[VTRN1_I]], ptr [[TMP2]]
1826 // CHECK:   [[TMP5:%.*]] = load %struct.uint8x16x2_t, ptr [[RETVAL_I]], align 16
1827 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.uint8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1828 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.uint8x16x2_t [[TMP5]], 0
1829 // CHECK:   store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1830 // CHECK:   [[TMP8:%.*]] = load %struct.uint8x16x2_t, ptr [[RETVAL]], align 16
1831 // CHECK:   ret %struct.uint8x16x2_t [[TMP8]]
1832 uint8x16x2_t test_vtrnq_u8(uint8x16_t a, uint8x16_t b) {
1833   return vtrnq_u8(a, b);
1834 }
1835
1836 // CHECK-LABEL: @test_vtrnq_u16(
1837 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint16x8x2_t, align 16
1838 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint16x8x2_t, align 16
1839 // CHECK:   [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1840 // CHECK:   [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1841 // CHECK:   [[VTRN_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
1842 // CHECK:   store <8 x i16> [[VTRN_I]], ptr [[RETVAL_I]]
1843 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1844 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
1845 // CHECK:   store <8 x i16> [[VTRN1_I]], ptr [[TMP4]]
1846 // CHECK:   [[TMP7:%.*]] = load %struct.uint16x8x2_t, ptr [[RETVAL_I]], align 16
1847 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.uint16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1848 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.uint16x8x2_t [[TMP7]], 0
1849 // CHECK:   store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1850 // CHECK:   [[TMP10:%.*]] = load %struct.uint16x8x2_t, ptr [[RETVAL]], align 16
1851 // CHECK:   ret %struct.uint16x8x2_t [[TMP10]]
1852 uint16x8x2_t test_vtrnq_u16(uint16x8_t a, uint16x8_t b) {
1853   return vtrnq_u16(a, b);
1854 }
1855
1856 // CHECK-LABEL: @test_vtrnq_u32(
1857 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.uint32x4x2_t, align 16
1858 // CHECK:   [[RETVAL:%.*]] = alloca %struct.uint32x4x2_t, align 16
1859 // CHECK:   [[TMP1:%.*]] = bitcast <4 x i32> %a to <16 x i8>
1860 // CHECK:   [[TMP2:%.*]] = bitcast <4 x i32> %b to <16 x i8>
1861 // CHECK:   [[VTRN_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1862 // CHECK:   store <4 x i32> [[VTRN_I]], ptr [[RETVAL_I]]
1863 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x i32>, ptr [[RETVAL_I]], i32 1
1864 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
1865 // CHECK:   store <4 x i32> [[VTRN1_I]], ptr [[TMP4]]
1866 // CHECK:   [[TMP7:%.*]] = load %struct.uint32x4x2_t, ptr [[RETVAL_I]], align 16
1867 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.uint32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1868 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.uint32x4x2_t [[TMP7]], 0
1869 // CHECK:   store [2 x <4 x i32>] [[TMP9]], ptr [[TMP8]], align 16
1870 // CHECK:   [[TMP10:%.*]] = load %struct.uint32x4x2_t, ptr [[RETVAL]], align 16
1871 // CHECK:   ret %struct.uint32x4x2_t [[TMP10]]
1872 uint32x4x2_t test_vtrnq_u32(uint32x4_t a, uint32x4_t b) {
1873   return vtrnq_u32(a, b);
1874 }
1875
1876 // CHECK-LABEL: @test_vtrnq_f32(
1877 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.float32x4x2_t, align 16
1878 // CHECK:   [[RETVAL:%.*]] = alloca %struct.float32x4x2_t, align 16
1879 // CHECK:   [[TMP1:%.*]] = bitcast <4 x float> %a to <16 x i8>
1880 // CHECK:   [[TMP2:%.*]] = bitcast <4 x float> %b to <16 x i8>
1881 // CHECK:   [[VTRN_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1882 // CHECK:   store <4 x float> [[VTRN_I]], ptr [[RETVAL_I]]
1883 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <4 x float>, ptr [[RETVAL_I]], i32 1
1884 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
1885 // CHECK:   store <4 x float> [[VTRN1_I]], ptr [[TMP4]]
1886 // CHECK:   [[TMP7:%.*]] = load %struct.float32x4x2_t, ptr [[RETVAL_I]], align 16
1887 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.float32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1888 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.float32x4x2_t [[TMP7]], 0
1889 // CHECK:   store [2 x <4 x float>] [[TMP9]], ptr [[TMP8]], align 16
1890 // CHECK:   [[TMP10:%.*]] = load %struct.float32x4x2_t, ptr [[RETVAL]], align 16
1891 // CHECK:   ret %struct.float32x4x2_t [[TMP10]]
1892 float32x4x2_t test_vtrnq_f32(float32x4_t a, float32x4_t b) {
1893   return vtrnq_f32(a, b);
1894 }
1895
1896 // CHECK-LABEL: @test_vtrnq_p8(
1897 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.poly8x16x2_t, align 16
1898 // CHECK:   [[RETVAL:%.*]] = alloca %struct.poly8x16x2_t, align 16
1899 // CHECK:   [[VTRN_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 2, i32 18, i32 4, i32 20, i32 6, i32 22, i32 8, i32 24, i32 10, i32 26, i32 12, i32 28, i32 14, i32 30>
1900 // CHECK:   store <16 x i8> [[VTRN_I]], ptr [[RETVAL_I]]
1901 // CHECK:   [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1902 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 17, i32 3, i32 19, i32 5, i32 21, i32 7, i32 23, i32 9, i32 25, i32 11, i32 27, i32 13, i32 29, i32 15, i32 31>
1903 // CHECK:   store <16 x i8> [[VTRN1_I]], ptr [[TMP2]]
1904 // CHECK:   [[TMP5:%.*]] = load %struct.poly8x16x2_t, ptr [[RETVAL_I]], align 16
1905 // CHECK:   [[TMP6:%.*]] = getelementptr inbounds %struct.poly8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1906 // CHECK:   [[TMP7:%.*]] = extractvalue %struct.poly8x16x2_t [[TMP5]], 0
1907 // CHECK:   store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1908 // CHECK:   [[TMP8:%.*]] = load %struct.poly8x16x2_t, ptr [[RETVAL]], align 16
1909 // CHECK:   ret %struct.poly8x16x2_t [[TMP8]]
1910 poly8x16x2_t test_vtrnq_p8(poly8x16_t a, poly8x16_t b) {
1911   return vtrnq_p8(a, b);
1912 }
1913
1914 // CHECK-LABEL: @test_vtrnq_p16(
1915 // CHECK:   [[RETVAL_I:%.*]] = alloca %struct.poly16x8x2_t, align 16
1916 // CHECK:   [[RETVAL:%.*]] = alloca %struct.poly16x8x2_t, align 16
1917 // CHECK:   [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1918 // CHECK:   [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1919 // CHECK:   [[VTRN_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
1920 // CHECK:   store <8 x i16> [[VTRN_I]], ptr [[RETVAL_I]]
1921 // CHECK:   [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1922 // CHECK:   [[VTRN1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
1923 // CHECK:   store <8 x i16> [[VTRN1_I]], ptr [[TMP4]]
1924 // CHECK:   [[TMP7:%.*]] = load %struct.poly16x8x2_t, ptr [[RETVAL_I]], align 16
1925 // CHECK:   [[TMP8:%.*]] = getelementptr inbounds %struct.poly16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1926 // CHECK:   [[TMP9:%.*]] = extractvalue %struct.poly16x8x2_t [[TMP7]], 0
1927 // CHECK:   store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1928 // CHECK:   [[TMP10:%.*]] = load %struct.poly16x8x2_t, ptr [[RETVAL]], align 16
1929 // CHECK:   ret %struct.poly16x8x2_t [[TMP10]]
1930 poly16x8x2_t test_vtrnq_p16(poly16x8_t a, poly16x8_t b) {
1931   return vtrnq_p16(a, b);
1932 }