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: 5define 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: 17define 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: 29define 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: 42define 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: 55define 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: 68define 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: 81define 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: 93define 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: 105define 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: 118define 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: 131define 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: 144define 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: 157define 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: 169define 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: 181define 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: 194define 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: 207define 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: 220define 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: 233define 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: 246define 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: 259define 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: 272define 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: 284define 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: 297define 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: 310define 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: 323define 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: 336define 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: 349define 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: 361define 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: 374define 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: 387define 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: 400define 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: 413define 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: 426define 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: 439define 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: 452define 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: 465define 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: 478define 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: 491define 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: 504define 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: 517define 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: 530define 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: 543define 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: 556define 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: 569define 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: 584define 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: 598define 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: 612define 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: 625define 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: 638define 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: 650define 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: 664define 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: 677define 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: 690define 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: 703define 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: 716define 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: 728define 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: 742define 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: 755define 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: 768define 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: 781define 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: 796define 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: 810define 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: 824define 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: 837define 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: 851define 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: 865define 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: 879define 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: 892define 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: 905define 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: 918define 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: 931define 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: 944define 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: 958define 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: 971define 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: 984define 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: 998define 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: 1011define 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: 1024define 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: 1038define 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: 1051define 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: 1064define 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: 1078define 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: 1091define 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} 1102