Home | History | Annotate | Download | only in AArch64 
      1 ; RUN: llc -mtriple arm64_be < %s -aarch64-load-store-opt=false -O1 -o - | FileCheck %s
      2 ; RUN: llc -mtriple arm64_be < %s -aarch64-load-store-opt=false -O0 -fast-isel=true -o - | FileCheck %s
      3 
      4 ; CHECK-LABEL: test_i64_f64:
      5 define void @test_i64_f64(double* %p, i64* %q) {
      6 ; CHECK: ldr
      7 ; CHECK: str
      8     %1 = load double* %p
      9     %2 = fadd double %1, %1
     10     %3 = bitcast double %2 to i64
     11     %4 = add i64 %3, %3
     12     store i64 %4, i64* %q
     13     ret void
     14 }
     15 
     16 ; CHECK-LABEL: test_i64_v1i64:
     17 define void @test_i64_v1i64(<1 x i64>* %p, i64* %q) {
     18 ; CHECK: ldr
     19 ; CHECK: str
     20     %1 = load <1 x i64>* %p
     21     %2 = add <1 x i64> %1, %1
     22     %3 = bitcast <1 x i64> %2 to i64
     23     %4 = add i64 %3, %3
     24     store i64 %4, i64* %q
     25     ret void
     26 }
     27 
     28 ; CHECK-LABEL: test_i64_v2f32:
     29 define void @test_i64_v2f32(<2 x float>* %p, i64* %q) {
     30 ; CHECK: ld1 { v{{[0-9]+}}.2s }
     31 ; CHECK: rev64 v{{[0-9]+}}.2s
     32 ; CHECK: str
     33     %1 = load <2 x float>* %p
     34     %2 = fadd <2 x float> %1, %1
     35     %3 = bitcast <2 x float> %2 to i64
     36     %4 = add i64 %3, %3
     37     store i64 %4, i64* %q
     38     ret void
     39 }
     40 
     41 ; CHECK-LABEL: test_i64_v2i32:
     42 define void @test_i64_v2i32(<2 x i32>* %p, i64* %q) {
     43 ; CHECK: ld1 { v{{[0-9]+}}.2s }
     44 ; CHECK: rev64 v{{[0-9]+}}.2s
     45 ; CHECK: str
     46     %1 = load <2 x i32>* %p
     47     %2 = add <2 x i32> %1, %1
     48     %3 = bitcast <2 x i32> %2 to i64
     49     %4 = add i64 %3, %3
     50     store i64 %4, i64* %q
     51     ret void
     52 }
     53 
     54 ; CHECK-LABEL: test_i64_v4i16:
     55 define void @test_i64_v4i16(<4 x i16>* %p, i64* %q) {
     56 ; CHECK: ld1 { v{{[0-9]+}}.4h }
     57 ; CHECK: rev64 v{{[0-9]+}}.4h
     58 ; CHECK: str
     59     %1 = load <4 x i16>* %p
     60     %2 = add <4 x i16> %1, %1
     61     %3 = bitcast <4 x i16> %2 to i64
     62     %4 = add i64 %3, %3
     63     store i64 %4, i64* %q
     64     ret void
     65 }
     66 
     67 ; CHECK-LABEL: test_i64_v8i8:
     68 define void @test_i64_v8i8(<8 x i8>* %p, i64* %q) {
     69 ; CHECK: ld1 { v{{[0-9]+}}.8b }
     70 ; CHECK: rev64 v{{[0-9]+}}.8b
     71 ; CHECK: str
     72     %1 = load <8 x i8>* %p
     73     %2 = add <8 x i8> %1, %1
     74     %3 = bitcast <8 x i8> %2 to i64
     75     %4 = add i64 %3, %3
     76     store i64 %4, i64* %q
     77     ret void
     78 }
     79 
     80 ; CHECK-LABEL: test_f64_i64:
     81 define void @test_f64_i64(i64* %p, double* %q) {
     82 ; CHECK: ldr
     83 ; CHECK: str
     84     %1 = load i64* %p
     85     %2 = add i64 %1, %1
     86     %3 = bitcast i64 %2 to double
     87     %4 = fadd double %3, %3
     88     store double %4, double* %q
     89     ret void
     90 }
     91 
     92 ; CHECK-LABEL: test_f64_v1i64:
     93 define void @test_f64_v1i64(<1 x i64>* %p, double* %q) {
     94 ; CHECK: ldr
     95 ; CHECK: str
     96     %1 = load <1 x i64>* %p
     97     %2 = add <1 x i64> %1, %1
     98     %3 = bitcast <1 x i64> %2 to double
     99     %4 = fadd double %3, %3
    100     store double %4, double* %q
    101     ret void
    102 }
    103 
    104 ; CHECK-LABEL: test_f64_v2f32:
    105 define void @test_f64_v2f32(<2 x float>* %p, double* %q) {
    106 ; CHECK: ld1 { v{{[0-9]+}}.2s }
    107 ; CHECK: rev64 v{{[0-9]+}}.2s
    108 ; CHECK: str
    109     %1 = load <2 x float>* %p
    110     %2 = fadd <2 x float> %1, %1
    111     %3 = bitcast <2 x float> %2 to double
    112     %4 = fadd double %3, %3
    113     store double %4, double* %q
    114     ret void
    115 }
    116 
    117 ; CHECK-LABEL: test_f64_v2i32:
    118 define void @test_f64_v2i32(<2 x i32>* %p, double* %q) {
    119 ; CHECK: ld1 { v{{[0-9]+}}.2s }
    120 ; CHECK: rev64 v{{[0-9]+}}.2s
    121 ; CHECK: str
    122     %1 = load <2 x i32>* %p
    123     %2 = add <2 x i32> %1, %1
    124     %3 = bitcast <2 x i32> %2 to double
    125     %4 = fadd double %3, %3
    126     store double %4, double* %q
    127     ret void
    128 }
    129 
    130 ; CHECK-LABEL: test_f64_v4i16:
    131 define void @test_f64_v4i16(<4 x i16>* %p, double* %q) {
    132 ; CHECK: ld1 { v{{[0-9]+}}.4h }
    133 ; CHECK: rev64 v{{[0-9]+}}.4h
    134 ; CHECK: str
    135     %1 = load <4 x i16>* %p
    136     %2 = add <4 x i16> %1, %1
    137     %3 = bitcast <4 x i16> %2 to double
    138     %4 = fadd double %3, %3
    139     store double %4, double* %q
    140     ret void
    141 }
    142 
    143 ; CHECK-LABEL: test_f64_v8i8:
    144 define void @test_f64_v8i8(<8 x i8>* %p, double* %q) {
    145 ; CHECK: ld1 { v{{[0-9]+}}.8b }
    146 ; CHECK: rev64 v{{[0-9]+}}.8b
    147 ; CHECK: str
    148     %1 = load <8 x i8>* %p
    149     %2 = add <8 x i8> %1, %1
    150     %3 = bitcast <8 x i8> %2 to double
    151     %4 = fadd double %3, %3
    152     store double %4, double* %q
    153     ret void
    154 }
    155 
    156 ; CHECK-LABEL: test_v1i64_i64:
    157 define void @test_v1i64_i64(i64* %p, <1 x i64>* %q) {
    158 ; CHECK: ldr
    159 ; CHECK: str
    160     %1 = load i64* %p
    161     %2 = add i64 %1, %1
    162     %3 = bitcast i64 %2 to <1 x i64>
    163     %4 = add <1 x i64> %3, %3
    164     store <1 x i64> %4, <1 x i64>* %q
    165     ret void
    166 }
    167 
    168 ; CHECK-LABEL: test_v1i64_f64:
    169 define void @test_v1i64_f64(double* %p, <1 x i64>* %q) {
    170 ; CHECK: ldr
    171 ; CHECK: str
    172     %1 = load double* %p
    173     %2 = fadd double %1, %1
    174     %3 = bitcast double %2 to <1 x i64>
    175     %4 = add <1 x i64> %3, %3
    176     store <1 x i64> %4, <1 x i64>* %q
    177     ret void
    178 }
    179 
    180 ; CHECK-LABEL: test_v1i64_v2f32:
    181 define void @test_v1i64_v2f32(<2 x float>* %p, <1 x i64>* %q) {
    182 ; CHECK: ld1 { v{{[0-9]+}}.2s }
    183 ; CHECK: rev64 v{{[0-9]+}}.2s
    184 ; CHECK: str
    185     %1 = load <2 x float>* %p
    186     %2 = fadd <2 x float> %1, %1
    187     %3 = bitcast <2 x float> %2 to <1 x i64>
    188     %4 = add <1 x i64> %3, %3
    189     store <1 x i64> %4, <1 x i64>* %q
    190     ret void
    191 }
    192 
    193 ; CHECK-LABEL: test_v1i64_v2i32:
    194 define void @test_v1i64_v2i32(<2 x i32>* %p, <1 x i64>* %q) {
    195 ; CHECK: ld1 { v{{[0-9]+}}.2s }
    196 ; CHECK: rev64 v{{[0-9]+}}.2s
    197 ; CHECK: str
    198     %1 = load <2 x i32>* %p
    199     %2 = add <2 x i32> %1, %1
    200     %3 = bitcast <2 x i32> %2 to <1 x i64>
    201     %4 = add <1 x i64> %3, %3
    202     store <1 x i64> %4, <1 x i64>* %q
    203     ret void
    204 }
    205 
    206 ; CHECK-LABEL: test_v1i64_v4i16:
    207 define void @test_v1i64_v4i16(<4 x i16>* %p, <1 x i64>* %q) {
    208 ; CHECK: ld1 { v{{[0-9]+}}.4h }
    209 ; CHECK: rev64 v{{[0-9]+}}.4h
    210 ; CHECK: str
    211     %1 = load <4 x i16>* %p
    212     %2 = add <4 x i16> %1, %1
    213     %3 = bitcast <4 x i16> %2 to <1 x i64>
    214     %4 = add <1 x i64> %3, %3
    215     store <1 x i64> %4, <1 x i64>* %q
    216     ret void
    217 }
    218 
    219 ; CHECK-LABEL: test_v1i64_v8i8:
    220 define void @test_v1i64_v8i8(<8 x i8>* %p, <1 x i64>* %q) {
    221 ; CHECK: ld1 { v{{[0-9]+}}.8b }
    222 ; CHECK: rev64 v{{[0-9]+}}.8b
    223 ; CHECK: str
    224     %1 = load <8 x i8>* %p
    225     %2 = add <8 x i8> %1, %1
    226     %3 = bitcast <8 x i8> %2 to <1 x i64>
    227     %4 = add <1 x i64> %3, %3
    228     store <1 x i64> %4, <1 x i64>* %q
    229     ret void
    230 }
    231 
    232 ; CHECK-LABEL: test_v2f32_i64:
    233 define void @test_v2f32_i64(i64* %p, <2 x float>* %q) {
    234 ; CHECK: ldr
    235 ; CHECK: rev64 v{{[0-9]+}}.2s
    236 ; CHECK: st1 { v{{[0-9]+}}.2s }
    237     %1 = load i64* %p
    238     %2 = add i64 %1, %1
    239     %3 = bitcast i64 %2 to <2 x float>
    240     %4 = fadd <2 x float> %3, %3
    241     store <2 x float> %4, <2 x float>* %q
    242     ret void
    243 }
    244 
    245 ; CHECK-LABEL: test_v2f32_f64:
    246 define void @test_v2f32_f64(double* %p, <2 x float>* %q) {
    247 ; CHECK: ldr
    248 ; CHECK: rev64 v{{[0-9]+}}.2s
    249 ; CHECK: st1 { v{{[0-9]+}}.2s }
    250     %1 = load double* %p
    251     %2 = fadd double %1, %1
    252     %3 = bitcast double %2 to <2 x float>
    253     %4 = fadd <2 x float> %3, %3
    254     store <2 x float> %4, <2 x float>* %q
    255     ret void
    256 }
    257 
    258 ; CHECK-LABEL: test_v2f32_v1i64:
    259 define void @test_v2f32_v1i64(<1 x i64>* %p, <2 x float>* %q) {
    260 ; CHECK: ldr
    261 ; CHECK: rev64 v{{[0-9]+}}.2s
    262 ; CHECK: st1 { v{{[0-9]+}}.2s }
    263     %1 = load <1 x i64>* %p
    264     %2 = add <1 x i64> %1, %1
    265     %3 = bitcast <1 x i64> %2 to <2 x float>
    266     %4 = fadd <2 x float> %3, %3
    267     store <2 x float> %4, <2 x float>* %q
    268     ret void
    269 }
    270 
    271 ; CHECK-LABEL: test_v2f32_v2i32:
    272 define void @test_v2f32_v2i32(<2 x i32>* %p, <2 x float>* %q) {
    273 ; CHECK: ld1 { v{{[0-9]+}}.2s }
    274 ; CHECK: st1 { v{{[0-9]+}}.2s }
    275     %1 = load <2 x i32>* %p
    276     %2 = add <2 x i32> %1, %1
    277     %3 = bitcast <2 x i32> %2 to <2 x float>
    278     %4 = fadd <2 x float> %3, %3
    279     store <2 x float> %4, <2 x float>* %q
    280     ret void
    281 }
    282 
    283 ; CHECK-LABEL: test_v2f32_v4i16:
    284 define void @test_v2f32_v4i16(<4 x i16>* %p, <2 x float>* %q) {
    285 ; CHECK: ld1 { v{{[0-9]+}}.4h }
    286 ; CHECK: rev32 v{{[0-9]+}}.4h
    287 ; CHECK: st1 { v{{[0-9]+}}.2s }
    288     %1 = load <4 x i16>* %p
    289     %2 = add <4 x i16> %1, %1
    290     %3 = bitcast <4 x i16> %2 to <2 x float>
    291     %4 = fadd <2 x float> %3, %3
    292     store <2 x float> %4, <2 x float>* %q
    293     ret void
    294 }
    295 
    296 ; CHECK-LABEL: test_v2f32_v8i8:
    297 define void @test_v2f32_v8i8(<8 x i8>* %p, <2 x float>* %q) {
    298 ; CHECK: ld1 { v{{[0-9]+}}.8b }
    299 ; CHECK: rev32 v{{[0-9]+}}.8b
    300 ; CHECK: st1 { v{{[0-9]+}}.2s }
    301     %1 = load <8 x i8>* %p
    302     %2 = add <8 x i8> %1, %1
    303     %3 = bitcast <8 x i8> %2 to <2 x float>
    304     %4 = fadd <2 x float> %3, %3
    305     store <2 x float> %4, <2 x float>* %q
    306     ret void
    307 }
    308 
    309 ; CHECK-LABEL: test_v2i32_i64:
    310 define void @test_v2i32_i64(i64* %p, <2 x i32>* %q) {
    311 ; CHECK: ldr
    312 ; CHECK: rev64 v{{[0-9]+}}.2s
    313 ; CHECK: st1 { v{{[0-9]+}}.2s }
    314     %1 = load i64* %p
    315     %2 = add i64 %1, %1
    316     %3 = bitcast i64 %2 to <2 x i32>
    317     %4 = add <2 x i32> %3, %3
    318     store <2 x i32> %4, <2 x i32>* %q
    319     ret void
    320 }
    321 
    322 ; CHECK-LABEL: test_v2i32_f64:
    323 define void @test_v2i32_f64(double* %p, <2 x i32>* %q) {
    324 ; CHECK: ldr
    325 ; CHECK: rev64 v{{[0-9]+}}.2s
    326 ; CHECK: st1 { v{{[0-9]+}}.2s }
    327     %1 = load double* %p
    328     %2 = fadd double %1, %1
    329     %3 = bitcast double %2 to <2 x i32>
    330     %4 = add <2 x i32> %3, %3
    331     store <2 x i32> %4, <2 x i32>* %q
    332     ret void
    333 }
    334 
    335 ; CHECK-LABEL: test_v2i32_v1i64:
    336 define void @test_v2i32_v1i64(<1 x i64>* %p, <2 x i32>* %q) {
    337 ; CHECK: ldr
    338 ; CHECK: rev64 v{{[0-9]+}}.2s
    339 ; CHECK: st1 { v{{[0-9]+}}.2s }
    340     %1 = load <1 x i64>* %p
    341     %2 = add <1 x i64> %1, %1
    342     %3 = bitcast <1 x i64> %2 to <2 x i32>
    343     %4 = add <2 x i32> %3, %3
    344     store <2 x i32> %4, <2 x i32>* %q
    345     ret void
    346 }
    347 
    348 ; CHECK-LABEL: test_v2i32_v2f32:
    349 define void @test_v2i32_v2f32(<2 x float>* %p, <2 x i32>* %q) {
    350 ; CHECK: ld1 { v{{[0-9]+}}.2s }
    351 ; CHECK: st1 { v{{[0-9]+}}.2s }
    352     %1 = load <2 x float>* %p
    353     %2 = fadd <2 x float> %1, %1
    354     %3 = bitcast <2 x float> %2 to <2 x i32>
    355     %4 = add <2 x i32> %3, %3
    356     store <2 x i32> %4, <2 x i32>* %q
    357     ret void
    358 }
    359 
    360 ; CHECK-LABEL: test_v2i32_v4i16:
    361 define void @test_v2i32_v4i16(<4 x i16>* %p, <2 x i32>* %q) {
    362 ; CHECK: ld1 { v{{[0-9]+}}.4h }
    363 ; CHECK: rev32 v{{[0-9]+}}.4h
    364 ; CHECK: st1 { v{{[0-9]+}}.2s }
    365     %1 = load <4 x i16>* %p
    366     %2 = add <4 x i16> %1, %1
    367     %3 = bitcast <4 x i16> %2 to <2 x i32>
    368     %4 = add <2 x i32> %3, %3
    369     store <2 x i32> %4, <2 x i32>* %q
    370     ret void
    371 }
    372 
    373 ; CHECK-LABEL: test_v2i32_v8i8:
    374 define void @test_v2i32_v8i8(<8 x i8>* %p, <2 x i32>* %q) {
    375 ; CHECK: ld1 { v{{[0-9]+}}.8b }
    376 ; CHECK: rev32 v{{[0-9]+}}.8b
    377 ; CHECK: st1 { v{{[0-9]+}}.2s }
    378     %1 = load <8 x i8>* %p
    379     %2 = add <8 x i8> %1, %1
    380     %3 = bitcast <8 x i8> %2 to <2 x i32>
    381     %4 = add <2 x i32> %3, %3
    382     store <2 x i32> %4, <2 x i32>* %q
    383     ret void
    384 }
    385 
    386 ; CHECK-LABEL: test_v4i16_i64:
    387 define void @test_v4i16_i64(i64* %p, <4 x i16>* %q) {
    388 ; CHECK: ldr
    389 ; CHECK: rev64 v{{[0-9]+}}.4h
    390 ; CHECK: st1 { v{{[0-9]+}}.4h }
    391     %1 = load i64* %p
    392     %2 = add i64 %1, %1
    393     %3 = bitcast i64 %2 to <4 x i16>
    394     %4 = add <4 x i16> %3, %3
    395     store <4 x i16> %4, <4 x i16>* %q
    396     ret void
    397 }
    398 
    399 ; CHECK-LABEL: test_v4i16_f64:
    400 define void @test_v4i16_f64(double* %p, <4 x i16>* %q) {
    401 ; CHECK: ldr
    402 ; CHECK: rev64 v{{[0-9]+}}.4h
    403 ; CHECK: st1 { v{{[0-9]+}}.4h }
    404     %1 = load double* %p
    405     %2 = fadd double %1, %1
    406     %3 = bitcast double %2 to <4 x i16>
    407     %4 = add <4 x i16> %3, %3
    408     store <4 x i16> %4, <4 x i16>* %q
    409     ret void
    410 }
    411 
    412 ; CHECK-LABEL: test_v4i16_v1i64:
    413 define void @test_v4i16_v1i64(<1 x i64>* %p, <4 x i16>* %q) {
    414 ; CHECK: ldr
    415 ; CHECK: rev64 v{{[0-9]+}}.4h
    416 ; CHECK: st1 { v{{[0-9]+}}.4h }
    417     %1 = load <1 x i64>* %p
    418     %2 = add <1 x i64> %1, %1
    419     %3 = bitcast <1 x i64> %2 to <4 x i16>
    420     %4 = add <4 x i16> %3, %3
    421     store <4 x i16> %4, <4 x i16>* %q
    422     ret void
    423 }
    424 
    425 ; CHECK-LABEL: test_v4i16_v2f32:
    426 define void @test_v4i16_v2f32(<2 x float>* %p, <4 x i16>* %q) {
    427 ; CHECK: ld1 { v{{[0-9]+}}.2s }
    428 ; CHECK: rev32 v{{[0-9]+}}.4h
    429 ; CHECK: st1 { v{{[0-9]+}}.4h }
    430     %1 = load <2 x float>* %p
    431     %2 = fadd <2 x float> %1, %1
    432     %3 = bitcast <2 x float> %2 to <4 x i16>
    433     %4 = add <4 x i16> %3, %3
    434     store <4 x i16> %4, <4 x i16>* %q
    435     ret void
    436 }
    437 
    438 ; CHECK-LABEL: test_v4i16_v2i32:
    439 define void @test_v4i16_v2i32(<2 x i32>* %p, <4 x i16>* %q) {
    440 ; CHECK: ld1 { v{{[0-9]+}}.2s }
    441 ; CHECK: rev32 v{{[0-9]+}}.4h
    442 ; CHECK: st1 { v{{[0-9]+}}.4h }
    443     %1 = load <2 x i32>* %p
    444     %2 = add <2 x i32> %1, %1
    445     %3 = bitcast <2 x i32> %2 to <4 x i16>
    446     %4 = add <4 x i16> %3, %3
    447     store <4 x i16> %4, <4 x i16>* %q
    448     ret void
    449 }
    450 
    451 ; CHECK-LABEL: test_v4i16_v8i8:
    452 define void @test_v4i16_v8i8(<8 x i8>* %p, <4 x i16>* %q) {
    453 ; CHECK: ld1 { v{{[0-9]+}}.8b }
    454 ; CHECK: rev16 v{{[0-9]+}}.8b
    455 ; CHECK: st1 { v{{[0-9]+}}.4h }
    456     %1 = load <8 x i8>* %p
    457     %2 = add <8 x i8> %1, %1
    458     %3 = bitcast <8 x i8> %2 to <4 x i16>
    459     %4 = add <4 x i16> %3, %3
    460     store <4 x i16> %4, <4 x i16>* %q
    461     ret void
    462 }
    463 
    464 ; CHECK-LABEL: test_v8i8_i64:
    465 define void @test_v8i8_i64(i64* %p, <8 x i8>* %q) {
    466 ; CHECK: ldr
    467 ; CHECK: rev64 v{{[0-9]+}}.8b
    468 ; CHECK: st1 { v{{[0-9]+}}.8b }
    469     %1 = load i64* %p
    470     %2 = add i64 %1, %1
    471     %3 = bitcast i64 %2 to <8 x i8>
    472     %4 = add <8 x i8> %3, %3
    473     store <8 x i8> %4, <8 x i8>* %q
    474     ret void
    475 }
    476 
    477 ; CHECK-LABEL: test_v8i8_f64:
    478 define void @test_v8i8_f64(double* %p, <8 x i8>* %q) {
    479 ; CHECK: ldr
    480 ; CHECK: rev64 v{{[0-9]+}}.8b
    481 ; CHECK: st1 { v{{[0-9]+}}.8b }
    482     %1 = load double* %p
    483     %2 = fadd double %1, %1
    484     %3 = bitcast double %2 to <8 x i8>
    485     %4 = add <8 x i8> %3, %3
    486     store <8 x i8> %4, <8 x i8>* %q
    487     ret void
    488 }
    489 
    490 ; CHECK-LABEL: test_v8i8_v1i64:
    491 define void @test_v8i8_v1i64(<1 x i64>* %p, <8 x i8>* %q) {
    492 ; CHECK: ldr
    493 ; CHECK: rev64 v{{[0-9]+}}.8b
    494 ; CHECK: st1 { v{{[0-9]+}}.8b }
    495     %1 = load <1 x i64>* %p
    496     %2 = add <1 x i64> %1, %1
    497     %3 = bitcast <1 x i64> %2 to <8 x i8>
    498     %4 = add <8 x i8> %3, %3
    499     store <8 x i8> %4, <8 x i8>* %q
    500     ret void
    501 }
    502 
    503 ; CHECK-LABEL: test_v8i8_v2f32:
    504 define void @test_v8i8_v2f32(<2 x float>* %p, <8 x i8>* %q) {
    505 ; CHECK: ld1 { v{{[0-9]+}}.2s }
    506 ; CHECK: rev32 v{{[0-9]+}}.8b
    507 ; CHECK: st1 { v{{[0-9]+}}.8b }
    508     %1 = load <2 x float>* %p
    509     %2 = fadd <2 x float> %1, %1
    510     %3 = bitcast <2 x float> %2 to <8 x i8>
    511     %4 = add <8 x i8> %3, %3
    512     store <8 x i8> %4, <8 x i8>* %q
    513     ret void
    514 }
    515 
    516 ; CHECK-LABEL: test_v8i8_v2i32:
    517 define void @test_v8i8_v2i32(<2 x i32>* %p, <8 x i8>* %q) {
    518 ; CHECK: ld1 { v{{[0-9]+}}.2s }
    519 ; CHECK: rev32 v{{[0-9]+}}.8b
    520 ; CHECK: st1 { v{{[0-9]+}}.8b }
    521     %1 = load <2 x i32>* %p
    522     %2 = add <2 x i32> %1, %1
    523     %3 = bitcast <2 x i32> %2 to <8 x i8>
    524     %4 = add <8 x i8> %3, %3
    525     store <8 x i8> %4, <8 x i8>* %q
    526     ret void
    527 }
    528 
    529 ; CHECK-LABEL: test_v8i8_v4i16:
    530 define void @test_v8i8_v4i16(<4 x i16>* %p, <8 x i8>* %q) {
    531 ; CHECK: ld1 { v{{[0-9]+}}.4h }
    532 ; CHECK: rev16 v{{[0-9]+}}.8b
    533 ; CHECK: st1 { v{{[0-9]+}}.8b }
    534     %1 = load <4 x i16>* %p
    535     %2 = add <4 x i16> %1, %1
    536     %3 = bitcast <4 x i16> %2 to <8 x i8>
    537     %4 = add <8 x i8> %3, %3
    538     store <8 x i8> %4, <8 x i8>* %q
    539     ret void
    540 }
    541 
    542 ; CHECK-LABEL: test_f128_v2f64:
    543 define void @test_f128_v2f64(<2 x double>* %p, fp128* %q) {
    544 ; CHECK: ld1 { v{{[0-9]+}}.2d }
    545 ; CHECK: ext
    546 ; CHECK: str
    547     %1 = load <2 x double>* %p
    548     %2 = fadd <2 x double> %1, %1
    549     %3 = bitcast <2 x double> %2 to fp128
    550     %4 = fadd fp128 %3, %3
    551     store fp128 %4, fp128* %q
    552     ret void
    553 }
    554 
    555 ; CHECK-LABEL: test_f128_v2i64:
    556 define void @test_f128_v2i64(<2 x i64>* %p, fp128* %q) {
    557 ; CHECK: ld1 { v{{[0-9]+}}.2d }
    558 ; CHECK: ext
    559 ; CHECK: str
    560     %1 = load <2 x i64>* %p
    561     %2 = add <2 x i64> %1, %1
    562     %3 = bitcast <2 x i64> %2 to fp128
    563     %4 = fadd fp128 %3, %3
    564     store fp128 %4, fp128* %q
    565     ret void
    566 }
    567 
    568 ; CHECK-LABEL: test_f128_v4f32:
    569 define void @test_f128_v4f32(<4 x float>* %p, fp128* %q) {
    570 ; CHECK: ld1 { v{{[0-9]+}}.2d }
    571 ; CHECK: rev64 v{{[0-9]+}}.4s
    572 ; CHECK: rev64 v{{[0-9]+}}.4s
    573 ; CHECK: ext
    574 ; CHECK: str q
    575     %1 = load <4 x float>* %p
    576     %2 = fadd <4 x float> %1, %1
    577     %3 = bitcast <4 x float> %2 to fp128
    578     %4 = fadd fp128 %3, %3
    579     store fp128 %4, fp128* %q
    580     ret void
    581 }
    582 
    583 ; CHECK-LABEL: test_f128_v4i32:
    584 define void @test_f128_v4i32(<4 x i32>* %p, fp128* %q) {
    585 ; CHECK: ld1 { v{{[0-9]+}}.4s }
    586 ; CHECK: rev64 v{{[0-9]+}}.4s
    587 ; CHECK: ext
    588 ; CHECK: str
    589     %1 = load <4 x i32>* %p
    590     %2 = add <4 x i32> %1, %1
    591     %3 = bitcast <4 x i32> %2 to fp128
    592     %4 = fadd fp128 %3, %3
    593     store fp128 %4, fp128* %q
    594     ret void
    595 }
    596 
    597 ; CHECK-LABEL: test_f128_v8i16:
    598 define void @test_f128_v8i16(<8 x i16>* %p, fp128* %q) {
    599 ; CHECK: ld1 { v{{[0-9]+}}.8h }
    600 ; CHECK: rev64 v{{[0-9]+}}.8h
    601 ; CHECK: ext
    602 ; CHECK: str
    603     %1 = load <8 x i16>* %p
    604     %2 = add <8 x i16> %1, %1
    605     %3 = bitcast <8 x i16> %2 to fp128
    606     %4 = fadd fp128 %3, %3
    607     store fp128 %4, fp128* %q
    608     ret void
    609 }
    610 
    611 ; CHECK-LABEL: test_f128_v16i8:
    612 define void @test_f128_v16i8(<16 x i8>* %p, fp128* %q) {
    613 ; CHECK: ld1 { v{{[0-9]+}}.16b }
    614 ; CHECK: ext
    615 ; CHECK: str q
    616     %1 = load <16 x i8>* %p
    617     %2 = add <16 x i8> %1, %1
    618     %3 = bitcast <16 x i8> %2 to fp128
    619     %4 = fadd fp128 %3, %3
    620     store fp128 %4, fp128* %q
    621     ret void
    622 }
    623 
    624 ; CHECK-LABEL: test_v2f64_f128:
    625 define void @test_v2f64_f128(fp128* %p, <2 x double>* %q) {
    626 ; CHECK: ldr
    627 ; CHECK: ext
    628 ; CHECK: st1 { v{{[0-9]+}}.2d }
    629     %1 = load fp128* %p
    630     %2 = fadd fp128 %1, %1
    631     %3 = bitcast fp128 %2 to <2 x double>
    632     %4 = fadd <2 x double> %3, %3
    633     store <2 x double> %4, <2 x double>* %q
    634     ret void
    635 }
    636 
    637 ; CHECK-LABEL: test_v2f64_v2i64:
    638 define void @test_v2f64_v2i64(<2 x i64>* %p, <2 x double>* %q) {
    639 ; CHECK: ld1 { v{{[0-9]+}}.2d }
    640 ; CHECK: st1 { v{{[0-9]+}}.2d }
    641     %1 = load <2 x i64>* %p
    642     %2 = add <2 x i64> %1, %1
    643     %3 = bitcast <2 x i64> %2 to <2 x double>
    644     %4 = fadd <2 x double> %3, %3
    645     store <2 x double> %4, <2 x double>* %q
    646     ret void
    647 }
    648 
    649 ; CHECK-LABEL: test_v2f64_v4f32:
    650 define void @test_v2f64_v4f32(<4 x float>* %p, <2 x double>* %q) {
    651 ; CHECK: ld1 { v{{[0-9]+}}.2d }
    652 ; CHECK: rev64 v{{[0-9]+}}.4s
    653 ; CHECK: rev64 v{{[0-9]+}}.4s
    654 ; CHECK: st1 { v{{[0-9]+}}.2d }
    655     %1 = load <4 x float>* %p
    656     %2 = fadd <4 x float> %1, %1
    657     %3 = bitcast <4 x float> %2 to <2 x double>
    658     %4 = fadd <2 x double> %3, %3
    659     store <2 x double> %4, <2 x double>* %q
    660     ret void
    661 }
    662 
    663 ; CHECK-LABEL: test_v2f64_v4i32:
    664 define void @test_v2f64_v4i32(<4 x i32>* %p, <2 x double>* %q) {
    665 ; CHECK: ld1 { v{{[0-9]+}}.4s }
    666 ; CHECK: rev64 v{{[0-9]+}}.4s
    667 ; CHECK: st1 { v{{[0-9]+}}.2d }
    668     %1 = load <4 x i32>* %p
    669     %2 = add <4 x i32> %1, %1
    670     %3 = bitcast <4 x i32> %2 to <2 x double>
    671     %4 = fadd <2 x double> %3, %3
    672     store <2 x double> %4, <2 x double>* %q
    673     ret void
    674 }
    675 
    676 ; CHECK-LABEL: test_v2f64_v8i16:
    677 define void @test_v2f64_v8i16(<8 x i16>* %p, <2 x double>* %q) {
    678 ; CHECK: ld1 { v{{[0-9]+}}.8h }
    679 ; CHECK: rev64 v{{[0-9]+}}.8h
    680 ; CHECK: st1 { v{{[0-9]+}}.2d }
    681     %1 = load <8 x i16>* %p
    682     %2 = add <8 x i16> %1, %1
    683     %3 = bitcast <8 x i16> %2 to <2 x double>
    684     %4 = fadd <2 x double> %3, %3
    685     store <2 x double> %4, <2 x double>* %q
    686     ret void
    687 }
    688 
    689 ; CHECK-LABEL: test_v2f64_v16i8:
    690 define void @test_v2f64_v16i8(<16 x i8>* %p, <2 x double>* %q) {
    691 ; CHECK: ld1 { v{{[0-9]+}}.16b }
    692 ; CHECK: rev64 v{{[0-9]+}}.16b
    693 ; CHECK: st1 { v{{[0-9]+}}.2d }
    694     %1 = load <16 x i8>* %p
    695     %2 = add <16 x i8> %1, %1
    696     %3 = bitcast <16 x i8> %2 to <2 x double>
    697     %4 = fadd <2 x double> %3, %3
    698     store <2 x double> %4, <2 x double>* %q
    699     ret void
    700 }
    701 
    702 ; CHECK-LABEL: test_v2i64_f128:
    703 define void @test_v2i64_f128(fp128* %p, <2 x i64>* %q) {
    704 ; CHECK: ldr
    705 ; CHECK: ext
    706 ; CHECK: st1 { v{{[0-9]+}}.2d }
    707     %1 = load fp128* %p
    708     %2 = fadd fp128 %1, %1
    709     %3 = bitcast fp128 %2 to <2 x i64>
    710     %4 = add <2 x i64> %3, %3
    711     store <2 x i64> %4, <2 x i64>* %q
    712     ret void
    713 }
    714 
    715 ; CHECK-LABEL: test_v2i64_v2f64:
    716 define void @test_v2i64_v2f64(<2 x double>* %p, <2 x i64>* %q) {
    717 ; CHECK: ld1 { v{{[0-9]+}}.2d }
    718 ; CHECK: st1 { v{{[0-9]+}}.2d }
    719     %1 = load <2 x double>* %p
    720     %2 = fadd <2 x double> %1, %1
    721     %3 = bitcast <2 x double> %2 to <2 x i64>
    722     %4 = add <2 x i64> %3, %3
    723     store <2 x i64> %4, <2 x i64>* %q
    724     ret void
    725 }
    726 
    727 ; CHECK-LABEL: test_v2i64_v4f32:
    728 define void @test_v2i64_v4f32(<4 x float>* %p, <2 x i64>* %q) {
    729 ; CHECK: ld1 { v{{[0-9]+}}.2d }
    730 ; CHECK: rev64 v{{[0-9]+}}.4s
    731 ; CHECK: rev64 v{{[0-9]+}}.4s
    732 ; CHECK: st1 { v{{[0-9]+}}.2d }
    733     %1 = load <4 x float>* %p
    734     %2 = fadd <4 x float> %1, %1
    735     %3 = bitcast <4 x float> %2 to <2 x i64>
    736     %4 = add <2 x i64> %3, %3
    737     store <2 x i64> %4, <2 x i64>* %q
    738     ret void
    739 }
    740 
    741 ; CHECK-LABEL: test_v2i64_v4i32:
    742 define void @test_v2i64_v4i32(<4 x i32>* %p, <2 x i64>* %q) {
    743 ; CHECK: ld1 { v{{[0-9]+}}.4s }
    744 ; CHECK: rev64 v{{[0-9]+}}.4s
    745 ; CHECK: st1 { v{{[0-9]+}}.2d }
    746     %1 = load <4 x i32>* %p
    747     %2 = add <4 x i32> %1, %1
    748     %3 = bitcast <4 x i32> %2 to <2 x i64>
    749     %4 = add <2 x i64> %3, %3
    750     store <2 x i64> %4, <2 x i64>* %q
    751     ret void
    752 }
    753 
    754 ; CHECK-LABEL: test_v2i64_v8i16:
    755 define void @test_v2i64_v8i16(<8 x i16>* %p, <2 x i64>* %q) {
    756 ; CHECK: ld1 { v{{[0-9]+}}.8h }
    757 ; CHECK: rev64 v{{[0-9]+}}.8h
    758 ; CHECK: st1 { v{{[0-9]+}}.2d }
    759     %1 = load <8 x i16>* %p
    760     %2 = add <8 x i16> %1, %1
    761     %3 = bitcast <8 x i16> %2 to <2 x i64>
    762     %4 = add <2 x i64> %3, %3
    763     store <2 x i64> %4, <2 x i64>* %q
    764     ret void
    765 }
    766 
    767 ; CHECK-LABEL: test_v2i64_v16i8:
    768 define void @test_v2i64_v16i8(<16 x i8>* %p, <2 x i64>* %q) {
    769 ; CHECK: ld1 { v{{[0-9]+}}.16b }
    770 ; CHECK: rev64 v{{[0-9]+}}.16b
    771 ; CHECK: st1 { v{{[0-9]+}}.2d }
    772     %1 = load <16 x i8>* %p
    773     %2 = add <16 x i8> %1, %1
    774     %3 = bitcast <16 x i8> %2 to <2 x i64>
    775     %4 = add <2 x i64> %3, %3
    776     store <2 x i64> %4, <2 x i64>* %q
    777     ret void
    778 }
    779 
    780 ; CHECK-LABEL: test_v4f32_f128:
    781 define void @test_v4f32_f128(fp128* %p, <4 x float>* %q) {
    782 ; CHECK: ldr q
    783 ; CHECK: rev64 v{{[0-9]+}}.4s
    784 ; CHECK: ext
    785 ; CHECK: rev64 v{{[0-9]+}}.4s
    786 ; CHECK: st1 { v{{[0-9]+}}.2d }
    787     %1 = load fp128* %p
    788     %2 = fadd fp128 %1, %1
    789     %3 = bitcast fp128 %2 to <4 x float>
    790     %4 = fadd <4 x float> %3, %3
    791     store <4 x float> %4, <4 x float>* %q
    792     ret void
    793 }
    794 
    795 ; CHECK-LABEL: test_v4f32_v2f64:
    796 define void @test_v4f32_v2f64(<2 x double>* %p, <4 x float>* %q) {
    797 ; CHECK: ld1 { v{{[0-9]+}}.2d }
    798 ; CHECK: rev64 v{{[0-9]+}}.4s
    799 ; CHECK: rev64 v{{[0-9]+}}.4s
    800 ; CHECK: st1 { v{{[0-9]+}}.2d }
    801     %1 = load <2 x double>* %p
    802     %2 = fadd <2 x double> %1, %1
    803     %3 = bitcast <2 x double> %2 to <4 x float>
    804     %4 = fadd <4 x float> %3, %3
    805     store <4 x float> %4, <4 x float>* %q
    806     ret void
    807 }
    808 
    809 ; CHECK-LABEL: test_v4f32_v2i64:
    810 define void @test_v4f32_v2i64(<2 x i64>* %p, <4 x float>* %q) {
    811 ; CHECK: ld1 { v{{[0-9]+}}.2d }
    812 ; CHECK: rev64 v{{[0-9]+}}.4s
    813 ; CHECK: rev64 v{{[0-9]+}}.4s
    814 ; CHECK: st1 { v{{[0-9]+}}.2d }
    815     %1 = load <2 x i64>* %p
    816     %2 = add <2 x i64> %1, %1
    817     %3 = bitcast <2 x i64> %2 to <4 x float>
    818     %4 = fadd <4 x float> %3, %3
    819     store <4 x float> %4, <4 x float>* %q
    820     ret void
    821 }
    822 
    823 ; CHECK-LABEL: test_v4f32_v4i32:
    824 define void @test_v4f32_v4i32(<4 x i32>* %p, <4 x float>* %q) {
    825 ; CHECK: ld1 { v{{[0-9]+}}.4s }
    826 ; CHECK: rev64 v{{[0-9]+}}.4s
    827 ; CHECK: st1 { v{{[0-9]+}}.2d }
    828     %1 = load <4 x i32>* %p
    829     %2 = add <4 x i32> %1, %1
    830     %3 = bitcast <4 x i32> %2 to <4 x float>
    831     %4 = fadd <4 x float> %3, %3
    832     store <4 x float> %4, <4 x float>* %q
    833     ret void
    834 }
    835 
    836 ; CHECK-LABEL: test_v4f32_v8i16:
    837 define void @test_v4f32_v8i16(<8 x i16>* %p, <4 x float>* %q) {
    838 ; CHECK: ld1 { v{{[0-9]+}}.8h }
    839 ; CHECK: rev32 v{{[0-9]+}}.8h
    840 ; CHECK: rev64 v{{[0-9]+}}.4s
    841 ; CHECK: st1 { v{{[0-9]+}}.2d }
    842     %1 = load <8 x i16>* %p
    843     %2 = add <8 x i16> %1, %1
    844     %3 = bitcast <8 x i16> %2 to <4 x float>
    845     %4 = fadd <4 x float> %3, %3
    846     store <4 x float> %4, <4 x float>* %q
    847     ret void
    848 }
    849 
    850 ; CHECK-LABEL: test_v4f32_v16i8:
    851 define void @test_v4f32_v16i8(<16 x i8>* %p, <4 x float>* %q) {
    852 ; CHECK: ld1 { v{{[0-9]+}}.16b }
    853 ; CHECK: rev32 v{{[0-9]+}}.16b
    854 ; CHECK: rev64 v{{[0-9]+}}.4s
    855 ; CHECK: st1 { v{{[0-9]+}}.2d }
    856     %1 = load <16 x i8>* %p
    857     %2 = add <16 x i8> %1, %1
    858     %3 = bitcast <16 x i8> %2 to <4 x float>
    859     %4 = fadd <4 x float> %3, %3
    860     store <4 x float> %4, <4 x float>* %q
    861     ret void
    862 }
    863 
    864 ; CHECK-LABEL: test_v4i32_f128:
    865 define void @test_v4i32_f128(fp128* %p, <4 x i32>* %q) {
    866 ; CHECK: ldr
    867 ; CHECK: rev64 v{{[0-9]+}}.4s
    868 ; CHECK: ext
    869 ; CHECK: st1 { v{{[0-9]+}}.4s }
    870     %1 = load fp128* %p
    871     %2 = fadd fp128 %1, %1
    872     %3 = bitcast fp128 %2 to <4 x i32>
    873     %4 = add <4 x i32> %3, %3
    874     store <4 x i32> %4, <4 x i32>* %q
    875     ret void
    876 }
    877 
    878 ; CHECK-LABEL: test_v4i32_v2f64:
    879 define void @test_v4i32_v2f64(<2 x double>* %p, <4 x i32>* %q) {
    880 ; CHECK: ld1 { v{{[0-9]+}}.2d }
    881 ; CHECK: rev64 v{{[0-9]+}}.4s
    882 ; CHECK: st1 { v{{[0-9]+}}.4s }
    883     %1 = load <2 x double>* %p
    884     %2 = fadd <2 x double> %1, %1
    885     %3 = bitcast <2 x double> %2 to <4 x i32>
    886     %4 = add <4 x i32> %3, %3
    887     store <4 x i32> %4, <4 x i32>* %q
    888     ret void
    889 }
    890 
    891 ; CHECK-LABEL: test_v4i32_v2i64:
    892 define void @test_v4i32_v2i64(<2 x i64>* %p, <4 x i32>* %q) {
    893 ; CHECK: ld1 { v{{[0-9]+}}.2d }
    894 ; CHECK: rev64 v{{[0-9]+}}.4s
    895 ; CHECK: st1 { v{{[0-9]+}}.4s }
    896     %1 = load <2 x i64>* %p
    897     %2 = add <2 x i64> %1, %1
    898     %3 = bitcast <2 x i64> %2 to <4 x i32>
    899     %4 = add <4 x i32> %3, %3
    900     store <4 x i32> %4, <4 x i32>* %q
    901     ret void
    902 }
    903 
    904 ; CHECK-LABEL: test_v4i32_v4f32:
    905 define void @test_v4i32_v4f32(<4 x float>* %p, <4 x i32>* %q) {
    906 ; CHECK: ld1 { v{{[0-9]+}}.2d }
    907 ; CHECK: rev64 v{{[0-9]+}}.4s
    908 ; CHECK: st1 { v{{[0-9]+}}.4s }
    909     %1 = load <4 x float>* %p
    910     %2 = fadd <4 x float> %1, %1
    911     %3 = bitcast <4 x float> %2 to <4 x i32>
    912     %4 = add <4 x i32> %3, %3
    913     store <4 x i32> %4, <4 x i32>* %q
    914     ret void
    915 }
    916 
    917 ; CHECK-LABEL: test_v4i32_v8i16:
    918 define void @test_v4i32_v8i16(<8 x i16>* %p, <4 x i32>* %q) {
    919 ; CHECK: ld1 { v{{[0-9]+}}.8h }
    920 ; CHECK: rev32 v{{[0-9]+}}.8h
    921 ; CHECK: st1 { v{{[0-9]+}}.4s }
    922     %1 = load <8 x i16>* %p
    923     %2 = add <8 x i16> %1, %1
    924     %3 = bitcast <8 x i16> %2 to <4 x i32>
    925     %4 = add <4 x i32> %3, %3
    926     store <4 x i32> %4, <4 x i32>* %q
    927     ret void
    928 }
    929 
    930 ; CHECK-LABEL: test_v4i32_v16i8:
    931 define void @test_v4i32_v16i8(<16 x i8>* %p, <4 x i32>* %q) {
    932 ; CHECK: ld1 { v{{[0-9]+}}.16b }
    933 ; CHECK: rev32 v{{[0-9]+}}.16b
    934 ; CHECK: st1 { v{{[0-9]+}}.4s }
    935     %1 = load <16 x i8>* %p
    936     %2 = add <16 x i8> %1, %1
    937     %3 = bitcast <16 x i8> %2 to <4 x i32>
    938     %4 = add <4 x i32> %3, %3
    939     store <4 x i32> %4, <4 x i32>* %q
    940     ret void
    941 }
    942 
    943 ; CHECK-LABEL: test_v8i16_f128:
    944 define void @test_v8i16_f128(fp128* %p, <8 x i16>* %q) {
    945 ; CHECK: ldr
    946 ; CHECK: rev64 v{{[0-9]+}}.8h
    947 ; CHECK: ext
    948 ; CHECK: st1 { v{{[0-9]+}}.8h }
    949     %1 = load fp128* %p
    950     %2 = fadd fp128 %1, %1
    951     %3 = bitcast fp128 %2 to <8 x i16>
    952     %4 = add <8 x i16> %3, %3
    953     store <8 x i16> %4, <8 x i16>* %q
    954     ret void
    955 }
    956 
    957 ; CHECK-LABEL: test_v8i16_v2f64:
    958 define void @test_v8i16_v2f64(<2 x double>* %p, <8 x i16>* %q) {
    959 ; CHECK: ld1 { v{{[0-9]+}}.2d }
    960 ; CHECK: rev64 v{{[0-9]+}}.8h
    961 ; CHECK: st1 { v{{[0-9]+}}.8h }
    962     %1 = load <2 x double>* %p
    963     %2 = fadd <2 x double> %1, %1
    964     %3 = bitcast <2 x double> %2 to <8 x i16>
    965     %4 = add <8 x i16> %3, %3
    966     store <8 x i16> %4, <8 x i16>* %q
    967     ret void
    968 }
    969 
    970 ; CHECK-LABEL: test_v8i16_v2i64:
    971 define void @test_v8i16_v2i64(<2 x i64>* %p, <8 x i16>* %q) {
    972 ; CHECK: ld1 { v{{[0-9]+}}.2d }
    973 ; CHECK: rev64 v{{[0-9]+}}.8h
    974 ; CHECK: st1 { v{{[0-9]+}}.8h }
    975     %1 = load <2 x i64>* %p
    976     %2 = add <2 x i64> %1, %1
    977     %3 = bitcast <2 x i64> %2 to <8 x i16>
    978     %4 = add <8 x i16> %3, %3
    979     store <8 x i16> %4, <8 x i16>* %q
    980     ret void
    981 }
    982 
    983 ; CHECK-LABEL: test_v8i16_v4f32:
    984 define void @test_v8i16_v4f32(<4 x float>* %p, <8 x i16>* %q) {
    985 ; CHECK: ld1 { v{{[0-9]+}}.2d }
    986 ; CHECK: rev64 v{{[0-9]+}}.4s
    987 ; CHECK: rev32 v{{[0-9]+}}.8h
    988 ; CHECK: st1 { v{{[0-9]+}}.8h }
    989     %1 = load <4 x float>* %p
    990     %2 = fadd <4 x float> %1, %1
    991     %3 = bitcast <4 x float> %2 to <8 x i16>
    992     %4 = add <8 x i16> %3, %3
    993     store <8 x i16> %4, <8 x i16>* %q
    994     ret void
    995 }
    996 
    997 ; CHECK-LABEL: test_v8i16_v4i32:
    998 define void @test_v8i16_v4i32(<4 x i32>* %p, <8 x i16>* %q) {
    999 ; CHECK: ld1 { v{{[0-9]+}}.4s }
   1000 ; CHECK: rev32 v{{[0-9]+}}.8h
   1001 ; CHECK: st1 { v{{[0-9]+}}.8h }
   1002     %1 = load <4 x i32>* %p
   1003     %2 = add <4 x i32> %1, %1
   1004     %3 = bitcast <4 x i32> %2 to <8 x i16>
   1005     %4 = add <8 x i16> %3, %3
   1006     store <8 x i16> %4, <8 x i16>* %q
   1007     ret void
   1008 }
   1009 
   1010 ; CHECK-LABEL: test_v8i16_v16i8:
   1011 define void @test_v8i16_v16i8(<16 x i8>* %p, <8 x i16>* %q) {
   1012 ; CHECK: ld1 { v{{[0-9]+}}.16b }
   1013 ; CHECK: rev16 v{{[0-9]+}}.16b
   1014 ; CHECK: st1 { v{{[0-9]+}}.8h }
   1015     %1 = load <16 x i8>* %p
   1016     %2 = add <16 x i8> %1, %1
   1017     %3 = bitcast <16 x i8> %2 to <8 x i16>
   1018     %4 = add <8 x i16> %3, %3
   1019     store <8 x i16> %4, <8 x i16>* %q
   1020     ret void
   1021 }
   1022 
   1023 ; CHECK-LABEL: test_v16i8_f128:
   1024 define void @test_v16i8_f128(fp128* %p, <16 x i8>* %q) {
   1025 ; CHECK: ldr q
   1026 ; CHECK: rev64 v{{[0-9]+}}.16b
   1027 ; CHECK: ext
   1028 ; CHECK: st1 { v{{[0-9]+}}.16b }
   1029     %1 = load fp128* %p
   1030     %2 = fadd fp128 %1, %1
   1031     %3 = bitcast fp128 %2 to <16 x i8>
   1032     %4 = add <16 x i8> %3, %3
   1033     store <16 x i8> %4, <16 x i8>* %q
   1034     ret void
   1035 }
   1036 
   1037 ; CHECK-LABEL: test_v16i8_v2f64:
   1038 define void @test_v16i8_v2f64(<2 x double>* %p, <16 x i8>* %q) {
   1039 ; CHECK: ld1 { v{{[0-9]+}}.2d }
   1040 ; CHECK: rev64 v{{[0-9]+}}.16b
   1041 ; CHECK: st1 { v{{[0-9]+}}.16b }
   1042     %1 = load <2 x double>* %p
   1043     %2 = fadd <2 x double> %1, %1
   1044     %3 = bitcast <2 x double> %2 to <16 x i8>
   1045     %4 = add <16 x i8> %3, %3
   1046     store <16 x i8> %4, <16 x i8>* %q
   1047     ret void
   1048 }
   1049 
   1050 ; CHECK-LABEL: test_v16i8_v2i64:
   1051 define void @test_v16i8_v2i64(<2 x i64>* %p, <16 x i8>* %q) {
   1052 ; CHECK: ld1 { v{{[0-9]+}}.2d }
   1053 ; CHECK: rev64 v{{[0-9]+}}.16b
   1054 ; CHECK: st1 { v{{[0-9]+}}.16b }
   1055     %1 = load <2 x i64>* %p
   1056     %2 = add <2 x i64> %1, %1
   1057     %3 = bitcast <2 x i64> %2 to <16 x i8>
   1058     %4 = add <16 x i8> %3, %3
   1059     store <16 x i8> %4, <16 x i8>* %q
   1060     ret void
   1061 }
   1062 
   1063 ; CHECK-LABEL: test_v16i8_v4f32:
   1064 define void @test_v16i8_v4f32(<4 x float>* %p, <16 x i8>* %q) {
   1065 ; CHECK: ld1 { v{{[0-9]+}}.2d }
   1066 ; CHECK: rev64 v{{[0-9]+}}.4s
   1067 ; CHECK: rev32 v{{[0-9]+}}.16b
   1068 ; CHECK: st1 { v{{[0-9]+}}.16b }
   1069     %1 = load <4 x float>* %p
   1070     %2 = fadd <4 x float> %1, %1
   1071     %3 = bitcast <4 x float> %2 to <16 x i8>
   1072     %4 = add <16 x i8> %3, %3
   1073     store <16 x i8> %4, <16 x i8>* %q
   1074     ret void
   1075 }
   1076 
   1077 ; CHECK-LABEL: test_v16i8_v4i32:
   1078 define void @test_v16i8_v4i32(<4 x i32>* %p, <16 x i8>* %q) {
   1079 ; CHECK: ld1 { v{{[0-9]+}}.4s }
   1080 ; CHECK: rev32 v{{[0-9]+}}.16b
   1081 ; CHECK: st1 { v{{[0-9]+}}.16b }
   1082     %1 = load <4 x i32>* %p
   1083     %2 = add <4 x i32> %1, %1
   1084     %3 = bitcast <4 x i32> %2 to <16 x i8>
   1085     %4 = add <16 x i8> %3, %3
   1086     store <16 x i8> %4, <16 x i8>* %q
   1087     ret void
   1088 }
   1089 
   1090 ; CHECK-LABEL: test_v16i8_v8i16:
   1091 define void @test_v16i8_v8i16(<8 x i16>* %p, <16 x i8>* %q) {
   1092 ; CHECK: ld1 { v{{[0-9]+}}.8h }
   1093 ; CHECK: rev16 v{{[0-9]+}}.16b
   1094 ; CHECK: st1 { v{{[0-9]+}}.16b }
   1095     %1 = load <8 x i16>* %p
   1096     %2 = add <8 x i16> %1, %1
   1097     %3 = bitcast <8 x i16> %2 to <16 x i8>
   1098     %4 = add <16 x i8> %3, %3
   1099     store <16 x i8> %4, <16 x i8>* %q
   1100     ret void
   1101 }
   1102