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 } 1102
