test/CodeGen/AArch64/arm64-big-endian-bitconverts.ll

   1 ; RUN: llc -mtriple aarch64_be < %s -aarch64-load-store-opt=false -O1 -o - | FileCheck %s
   2 ; RUN: llc -mtriple aarch64_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, 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>, <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>, <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>, <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>, <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>, <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, 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>, <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>, <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>, <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>, <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>, <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, 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, 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>, <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>, <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>, <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>, <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, 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, 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>, <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>, <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>, <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>, <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, 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, 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>, <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>, <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>, <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>, <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, 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, 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>, <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>, <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>, <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>, <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, 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, 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>, <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>, <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>, <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>, <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>, <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>, <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>, <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>, <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>, <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>, <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, 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>, <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>, <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>, <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>, <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>, <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, 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>, <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>, <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>, <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>, <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>, <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, 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>, <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>, <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>, <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>, <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>, <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, 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>, <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>, <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>, <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>, <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>, <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, 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>, <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>, <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>, <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>, <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>, <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, 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>, <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>, <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>, <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>, <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>, <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 }