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