1 ; RUN: llc -mtriple=aarch64-linux-gnu -aarch64-atomic-cfg-tidy=0 -verify-machineinstrs -o - %s | FileCheck %s 2 3 ; This file contains tests for the AArch64 load/store optimizer. 4 5 %padding = type { i8*, i8*, i8*, i8* } 6 %s.byte = type { i8, i8 } 7 %s.halfword = type { i16, i16 } 8 %s.word = type { i32, i32 } 9 %s.doubleword = type { i64, i32 } 10 %s.quadword = type { fp128, i32 } 11 %s.float = type { float, i32 } 12 %s.double = type { double, i32 } 13 %struct.byte = type { %padding, %s.byte } 14 %struct.halfword = type { %padding, %s.halfword } 15 %struct.word = type { %padding, %s.word } 16 %struct.doubleword = type { %padding, %s.doubleword } 17 %struct.quadword = type { %padding, %s.quadword } 18 %struct.float = type { %padding, %s.float } 19 %struct.double = type { %padding, %s.double } 20 21 ; Check the following transform: 22 ; 23 ; (ldr|str) X, [x0, #32] 24 ; ... 25 ; add x0, x0, #32 26 ; -> 27 ; (ldr|str) X, [x0, #32]! 28 ; 29 ; with X being either w1, x1, s0, d0 or q0. 30 31 declare void @bar_byte(%s.byte*, i8) 32 33 define void @load-pre-indexed-byte(%struct.byte* %ptr) nounwind { 34 ; CHECK-LABEL: load-pre-indexed-byte 35 ; CHECK: ldrb w{{[0-9]+}}, [x{{[0-9]+}}, #32]! 36 entry: 37 %a = getelementptr inbounds %struct.byte, %struct.byte* %ptr, i64 0, i32 1, i32 0 38 %add = load i8, i8* %a, align 4 39 br label %bar 40 bar: 41 %c = getelementptr inbounds %struct.byte, %struct.byte* %ptr, i64 0, i32 1 42 tail call void @bar_byte(%s.byte* %c, i8 %add) 43 ret void 44 } 45 46 define void @store-pre-indexed-byte(%struct.byte* %ptr, i8 %val) nounwind { 47 ; CHECK-LABEL: store-pre-indexed-byte 48 ; CHECK: strb w{{[0-9]+}}, [x{{[0-9]+}}, #32]! 49 entry: 50 %a = getelementptr inbounds %struct.byte, %struct.byte* %ptr, i64 0, i32 1, i32 0 51 store i8 %val, i8* %a, align 4 52 br label %bar 53 bar: 54 %c = getelementptr inbounds %struct.byte, %struct.byte* %ptr, i64 0, i32 1 55 tail call void @bar_byte(%s.byte* %c, i8 %val) 56 ret void 57 } 58 59 declare void @bar_halfword(%s.halfword*, i16) 60 61 define void @load-pre-indexed-halfword(%struct.halfword* %ptr) nounwind { 62 ; CHECK-LABEL: load-pre-indexed-halfword 63 ; CHECK: ldrh w{{[0-9]+}}, [x{{[0-9]+}}, #32]! 64 entry: 65 %a = getelementptr inbounds %struct.halfword, %struct.halfword* %ptr, i64 0, i32 1, i32 0 66 %add = load i16, i16* %a, align 4 67 br label %bar 68 bar: 69 %c = getelementptr inbounds %struct.halfword, %struct.halfword* %ptr, i64 0, i32 1 70 tail call void @bar_halfword(%s.halfword* %c, i16 %add) 71 ret void 72 } 73 74 define void @store-pre-indexed-halfword(%struct.halfword* %ptr, i16 %val) nounwind { 75 ; CHECK-LABEL: store-pre-indexed-halfword 76 ; CHECK: strh w{{[0-9]+}}, [x{{[0-9]+}}, #32]! 77 entry: 78 %a = getelementptr inbounds %struct.halfword, %struct.halfword* %ptr, i64 0, i32 1, i32 0 79 store i16 %val, i16* %a, align 4 80 br label %bar 81 bar: 82 %c = getelementptr inbounds %struct.halfword, %struct.halfword* %ptr, i64 0, i32 1 83 tail call void @bar_halfword(%s.halfword* %c, i16 %val) 84 ret void 85 } 86 87 declare void @bar_word(%s.word*, i32) 88 89 define void @load-pre-indexed-word(%struct.word* %ptr) nounwind { 90 ; CHECK-LABEL: load-pre-indexed-word 91 ; CHECK: ldr w{{[0-9]+}}, [x{{[0-9]+}}, #32]! 92 entry: 93 %a = getelementptr inbounds %struct.word, %struct.word* %ptr, i64 0, i32 1, i32 0 94 %add = load i32, i32* %a, align 4 95 br label %bar 96 bar: 97 %c = getelementptr inbounds %struct.word, %struct.word* %ptr, i64 0, i32 1 98 tail call void @bar_word(%s.word* %c, i32 %add) 99 ret void 100 } 101 102 define void @store-pre-indexed-word(%struct.word* %ptr, i32 %val) nounwind { 103 ; CHECK-LABEL: store-pre-indexed-word 104 ; CHECK: str w{{[0-9]+}}, [x{{[0-9]+}}, #32]! 105 entry: 106 %a = getelementptr inbounds %struct.word, %struct.word* %ptr, i64 0, i32 1, i32 0 107 store i32 %val, i32* %a, align 4 108 br label %bar 109 bar: 110 %c = getelementptr inbounds %struct.word, %struct.word* %ptr, i64 0, i32 1 111 tail call void @bar_word(%s.word* %c, i32 %val) 112 ret void 113 } 114 115 declare void @bar_doubleword(%s.doubleword*, i64) 116 117 define void @load-pre-indexed-doubleword(%struct.doubleword* %ptr) nounwind { 118 ; CHECK-LABEL: load-pre-indexed-doubleword 119 ; CHECK: ldr x{{[0-9]+}}, [x{{[0-9]+}}, #32]! 120 entry: 121 %a = getelementptr inbounds %struct.doubleword, %struct.doubleword* %ptr, i64 0, i32 1, i32 0 122 %add = load i64, i64* %a, align 4 123 br label %bar 124 bar: 125 %c = getelementptr inbounds %struct.doubleword, %struct.doubleword* %ptr, i64 0, i32 1 126 tail call void @bar_doubleword(%s.doubleword* %c, i64 %add) 127 ret void 128 } 129 130 define void @store-pre-indexed-doubleword(%struct.doubleword* %ptr, i64 %val) nounwind { 131 ; CHECK-LABEL: store-pre-indexed-doubleword 132 ; CHECK: str x{{[0-9]+}}, [x{{[0-9]+}}, #32]! 133 entry: 134 %a = getelementptr inbounds %struct.doubleword, %struct.doubleword* %ptr, i64 0, i32 1, i32 0 135 store i64 %val, i64* %a, align 4 136 br label %bar 137 bar: 138 %c = getelementptr inbounds %struct.doubleword, %struct.doubleword* %ptr, i64 0, i32 1 139 tail call void @bar_doubleword(%s.doubleword* %c, i64 %val) 140 ret void 141 } 142 143 declare void @bar_quadword(%s.quadword*, fp128) 144 145 define void @load-pre-indexed-quadword(%struct.quadword* %ptr) nounwind { 146 ; CHECK-LABEL: load-pre-indexed-quadword 147 ; CHECK: ldr q{{[0-9]+}}, [x{{[0-9]+}}, #32]! 148 entry: 149 %a = getelementptr inbounds %struct.quadword, %struct.quadword* %ptr, i64 0, i32 1, i32 0 150 %add = load fp128, fp128* %a, align 4 151 br label %bar 152 bar: 153 %c = getelementptr inbounds %struct.quadword, %struct.quadword* %ptr, i64 0, i32 1 154 tail call void @bar_quadword(%s.quadword* %c, fp128 %add) 155 ret void 156 } 157 158 define void @store-pre-indexed-quadword(%struct.quadword* %ptr, fp128 %val) nounwind { 159 ; CHECK-LABEL: store-pre-indexed-quadword 160 ; CHECK: str q{{[0-9]+}}, [x{{[0-9]+}}, #32]! 161 entry: 162 %a = getelementptr inbounds %struct.quadword, %struct.quadword* %ptr, i64 0, i32 1, i32 0 163 store fp128 %val, fp128* %a, align 4 164 br label %bar 165 bar: 166 %c = getelementptr inbounds %struct.quadword, %struct.quadword* %ptr, i64 0, i32 1 167 tail call void @bar_quadword(%s.quadword* %c, fp128 %val) 168 ret void 169 } 170 171 declare void @bar_float(%s.float*, float) 172 173 define void @load-pre-indexed-float(%struct.float* %ptr) nounwind { 174 ; CHECK-LABEL: load-pre-indexed-float 175 ; CHECK: ldr s{{[0-9]+}}, [x{{[0-9]+}}, #32]! 176 entry: 177 %a = getelementptr inbounds %struct.float, %struct.float* %ptr, i64 0, i32 1, i32 0 178 %add = load float, float* %a, align 4 179 br label %bar 180 bar: 181 %c = getelementptr inbounds %struct.float, %struct.float* %ptr, i64 0, i32 1 182 tail call void @bar_float(%s.float* %c, float %add) 183 ret void 184 } 185 186 define void @store-pre-indexed-float(%struct.float* %ptr, float %val) nounwind { 187 ; CHECK-LABEL: store-pre-indexed-float 188 ; CHECK: str s{{[0-9]+}}, [x{{[0-9]+}}, #32]! 189 entry: 190 %a = getelementptr inbounds %struct.float, %struct.float* %ptr, i64 0, i32 1, i32 0 191 store float %val, float* %a, align 4 192 br label %bar 193 bar: 194 %c = getelementptr inbounds %struct.float, %struct.float* %ptr, i64 0, i32 1 195 tail call void @bar_float(%s.float* %c, float %val) 196 ret void 197 } 198 199 declare void @bar_double(%s.double*, double) 200 201 define void @load-pre-indexed-double(%struct.double* %ptr) nounwind { 202 ; CHECK-LABEL: load-pre-indexed-double 203 ; CHECK: ldr d{{[0-9]+}}, [x{{[0-9]+}}, #32]! 204 entry: 205 %a = getelementptr inbounds %struct.double, %struct.double* %ptr, i64 0, i32 1, i32 0 206 %add = load double, double* %a, align 4 207 br label %bar 208 bar: 209 %c = getelementptr inbounds %struct.double, %struct.double* %ptr, i64 0, i32 1 210 tail call void @bar_double(%s.double* %c, double %add) 211 ret void 212 } 213 214 define void @store-pre-indexed-double(%struct.double* %ptr, double %val) nounwind { 215 ; CHECK-LABEL: store-pre-indexed-double 216 ; CHECK: str d{{[0-9]+}}, [x{{[0-9]+}}, #32]! 217 entry: 218 %a = getelementptr inbounds %struct.double, %struct.double* %ptr, i64 0, i32 1, i32 0 219 store double %val, double* %a, align 4 220 br label %bar 221 bar: 222 %c = getelementptr inbounds %struct.double, %struct.double* %ptr, i64 0, i32 1 223 tail call void @bar_double(%s.double* %c, double %val) 224 ret void 225 } 226 227 ; Check the following transform: 228 ; 229 ; (ldp|stp) w1, w2 [x0, #32] 230 ; ... 231 ; add x0, x0, #32 232 ; -> 233 ; (ldp|stp) w1, w2, [x0, #32]! 234 ; 235 236 define void @load-pair-pre-indexed-word(%struct.word* %ptr) nounwind { 237 ; CHECK-LABEL: load-pair-pre-indexed-word 238 ; CHECK: ldp w{{[0-9]+}}, w{{[0-9]+}}, [x0, #32]! 239 ; CHECK-NOT: add x0, x0, #32 240 entry: 241 %a = getelementptr inbounds %struct.word, %struct.word* %ptr, i64 0, i32 1, i32 0 242 %a1 = load i32, i32* %a, align 4 243 %b = getelementptr inbounds %struct.word, %struct.word* %ptr, i64 0, i32 1, i32 1 244 %b1 = load i32, i32* %b, align 4 245 %add = add i32 %a1, %b1 246 br label %bar 247 bar: 248 %c = getelementptr inbounds %struct.word, %struct.word* %ptr, i64 0, i32 1 249 tail call void @bar_word(%s.word* %c, i32 %add) 250 ret void 251 } 252 253 define void @store-pair-pre-indexed-word(%struct.word* %ptr, i32 %val) nounwind { 254 ; CHECK-LABEL: store-pair-pre-indexed-word 255 ; CHECK: stp w{{[0-9]+}}, w{{[0-9]+}}, [x0, #32]! 256 ; CHECK-NOT: add x0, x0, #32 257 entry: 258 %a = getelementptr inbounds %struct.word, %struct.word* %ptr, i64 0, i32 1, i32 0 259 store i32 %val, i32* %a, align 4 260 %b = getelementptr inbounds %struct.word, %struct.word* %ptr, i64 0, i32 1, i32 1 261 store i32 %val, i32* %b, align 4 262 br label %bar 263 bar: 264 %c = getelementptr inbounds %struct.word, %struct.word* %ptr, i64 0, i32 1 265 tail call void @bar_word(%s.word* %c, i32 %val) 266 ret void 267 } 268 269 ; Check the following transform: 270 ; 271 ; add x8, x8, #16 272 ; ... 273 ; ldr X, [x8] 274 ; -> 275 ; ldr X, [x8, #16]! 276 ; 277 ; with X being either w0, x0, s0, d0 or q0. 278 279 %pre.struct.i32 = type { i32, i32, i32, i32, i32} 280 %pre.struct.i64 = type { i32, i64, i64, i64, i64} 281 %pre.struct.i128 = type { i32, <2 x i64>, <2 x i64>, <2 x i64>} 282 %pre.struct.float = type { i32, float, float, float} 283 %pre.struct.double = type { i32, double, double, double} 284 285 define i32 @load-pre-indexed-word2(%pre.struct.i32** %this, i1 %cond, 286 %pre.struct.i32* %load2) nounwind { 287 ; CHECK-LABEL: load-pre-indexed-word2 288 ; CHECK: ldr w{{[0-9]+}}, [x{{[0-9]+}}, #4]! 289 br i1 %cond, label %if.then, label %if.end 290 if.then: 291 %load1 = load %pre.struct.i32*, %pre.struct.i32** %this 292 %gep1 = getelementptr inbounds %pre.struct.i32, %pre.struct.i32* %load1, i64 0, i32 1 293 br label %return 294 if.end: 295 %gep2 = getelementptr inbounds %pre.struct.i32, %pre.struct.i32* %load2, i64 0, i32 2 296 br label %return 297 return: 298 %retptr = phi i32* [ %gep1, %if.then ], [ %gep2, %if.end ] 299 %ret = load i32, i32* %retptr 300 ret i32 %ret 301 } 302 303 define i64 @load-pre-indexed-doubleword2(%pre.struct.i64** %this, i1 %cond, 304 %pre.struct.i64* %load2) nounwind { 305 ; CHECK-LABEL: load-pre-indexed-doubleword2 306 ; CHECK: ldr x{{[0-9]+}}, [x{{[0-9]+}}, #8]! 307 br i1 %cond, label %if.then, label %if.end 308 if.then: 309 %load1 = load %pre.struct.i64*, %pre.struct.i64** %this 310 %gep1 = getelementptr inbounds %pre.struct.i64, %pre.struct.i64* %load1, i64 0, i32 1 311 br label %return 312 if.end: 313 %gep2 = getelementptr inbounds %pre.struct.i64, %pre.struct.i64* %load2, i64 0, i32 2 314 br label %return 315 return: 316 %retptr = phi i64* [ %gep1, %if.then ], [ %gep2, %if.end ] 317 %ret = load i64, i64* %retptr 318 ret i64 %ret 319 } 320 321 define <2 x i64> @load-pre-indexed-quadword2(%pre.struct.i128** %this, i1 %cond, 322 %pre.struct.i128* %load2) nounwind { 323 ; CHECK-LABEL: load-pre-indexed-quadword2 324 ; CHECK: ldr q{{[0-9]+}}, [x{{[0-9]+}}, #16]! 325 br i1 %cond, label %if.then, label %if.end 326 if.then: 327 %load1 = load %pre.struct.i128*, %pre.struct.i128** %this 328 %gep1 = getelementptr inbounds %pre.struct.i128, %pre.struct.i128* %load1, i64 0, i32 1 329 br label %return 330 if.end: 331 %gep2 = getelementptr inbounds %pre.struct.i128, %pre.struct.i128* %load2, i64 0, i32 2 332 br label %return 333 return: 334 %retptr = phi <2 x i64>* [ %gep1, %if.then ], [ %gep2, %if.end ] 335 %ret = load <2 x i64>, <2 x i64>* %retptr 336 ret <2 x i64> %ret 337 } 338 339 define float @load-pre-indexed-float2(%pre.struct.float** %this, i1 %cond, 340 %pre.struct.float* %load2) nounwind { 341 ; CHECK-LABEL: load-pre-indexed-float2 342 ; CHECK: ldr s{{[0-9]+}}, [x{{[0-9]+}}, #4]! 343 br i1 %cond, label %if.then, label %if.end 344 if.then: 345 %load1 = load %pre.struct.float*, %pre.struct.float** %this 346 %gep1 = getelementptr inbounds %pre.struct.float, %pre.struct.float* %load1, i64 0, i32 1 347 br label %return 348 if.end: 349 %gep2 = getelementptr inbounds %pre.struct.float, %pre.struct.float* %load2, i64 0, i32 2 350 br label %return 351 return: 352 %retptr = phi float* [ %gep1, %if.then ], [ %gep2, %if.end ] 353 %ret = load float, float* %retptr 354 ret float %ret 355 } 356 357 define double @load-pre-indexed-double2(%pre.struct.double** %this, i1 %cond, 358 %pre.struct.double* %load2) nounwind { 359 ; CHECK-LABEL: load-pre-indexed-double2 360 ; CHECK: ldr d{{[0-9]+}}, [x{{[0-9]+}}, #8]! 361 br i1 %cond, label %if.then, label %if.end 362 if.then: 363 %load1 = load %pre.struct.double*, %pre.struct.double** %this 364 %gep1 = getelementptr inbounds %pre.struct.double, %pre.struct.double* %load1, i64 0, i32 1 365 br label %return 366 if.end: 367 %gep2 = getelementptr inbounds %pre.struct.double, %pre.struct.double* %load2, i64 0, i32 2 368 br label %return 369 return: 370 %retptr = phi double* [ %gep1, %if.then ], [ %gep2, %if.end ] 371 %ret = load double, double* %retptr 372 ret double %ret 373 } 374 375 define i32 @load-pre-indexed-word3(%pre.struct.i32** %this, i1 %cond, 376 %pre.struct.i32* %load2) nounwind { 377 ; CHECK-LABEL: load-pre-indexed-word3 378 ; CHECK: ldr w{{[0-9]+}}, [x{{[0-9]+}}, #12]! 379 br i1 %cond, label %if.then, label %if.end 380 if.then: 381 %load1 = load %pre.struct.i32*, %pre.struct.i32** %this 382 %gep1 = getelementptr inbounds %pre.struct.i32, %pre.struct.i32* %load1, i64 0, i32 3 383 br label %return 384 if.end: 385 %gep2 = getelementptr inbounds %pre.struct.i32, %pre.struct.i32* %load2, i64 0, i32 4 386 br label %return 387 return: 388 %retptr = phi i32* [ %gep1, %if.then ], [ %gep2, %if.end ] 389 %ret = load i32, i32* %retptr 390 ret i32 %ret 391 } 392 393 define i64 @load-pre-indexed-doubleword3(%pre.struct.i64** %this, i1 %cond, 394 %pre.struct.i64* %load2) nounwind { 395 ; CHECK-LABEL: load-pre-indexed-doubleword3 396 ; CHECK: ldr x{{[0-9]+}}, [x{{[0-9]+}}, #16]! 397 br i1 %cond, label %if.then, label %if.end 398 if.then: 399 %load1 = load %pre.struct.i64*, %pre.struct.i64** %this 400 %gep1 = getelementptr inbounds %pre.struct.i64, %pre.struct.i64* %load1, i64 0, i32 2 401 br label %return 402 if.end: 403 %gep2 = getelementptr inbounds %pre.struct.i64, %pre.struct.i64* %load2, i64 0, i32 3 404 br label %return 405 return: 406 %retptr = phi i64* [ %gep1, %if.then ], [ %gep2, %if.end ] 407 %ret = load i64, i64* %retptr 408 ret i64 %ret 409 } 410 411 define <2 x i64> @load-pre-indexed-quadword3(%pre.struct.i128** %this, i1 %cond, 412 %pre.struct.i128* %load2) nounwind { 413 ; CHECK-LABEL: load-pre-indexed-quadword3 414 ; CHECK: ldr q{{[0-9]+}}, [x{{[0-9]+}}, #32]! 415 br i1 %cond, label %if.then, label %if.end 416 if.then: 417 %load1 = load %pre.struct.i128*, %pre.struct.i128** %this 418 %gep1 = getelementptr inbounds %pre.struct.i128, %pre.struct.i128* %load1, i64 0, i32 2 419 br label %return 420 if.end: 421 %gep2 = getelementptr inbounds %pre.struct.i128, %pre.struct.i128* %load2, i64 0, i32 3 422 br label %return 423 return: 424 %retptr = phi <2 x i64>* [ %gep1, %if.then ], [ %gep2, %if.end ] 425 %ret = load <2 x i64>, <2 x i64>* %retptr 426 ret <2 x i64> %ret 427 } 428 429 define float @load-pre-indexed-float3(%pre.struct.float** %this, i1 %cond, 430 %pre.struct.float* %load2) nounwind { 431 ; CHECK-LABEL: load-pre-indexed-float3 432 ; CHECK: ldr s{{[0-9]+}}, [x{{[0-9]+}}, #8]! 433 br i1 %cond, label %if.then, label %if.end 434 if.then: 435 %load1 = load %pre.struct.float*, %pre.struct.float** %this 436 %gep1 = getelementptr inbounds %pre.struct.float, %pre.struct.float* %load1, i64 0, i32 2 437 br label %return 438 if.end: 439 %gep2 = getelementptr inbounds %pre.struct.float, %pre.struct.float* %load2, i64 0, i32 3 440 br label %return 441 return: 442 %retptr = phi float* [ %gep1, %if.then ], [ %gep2, %if.end ] 443 %ret = load float, float* %retptr 444 ret float %ret 445 } 446 447 define double @load-pre-indexed-double3(%pre.struct.double** %this, i1 %cond, 448 %pre.struct.double* %load2) nounwind { 449 ; CHECK-LABEL: load-pre-indexed-double3 450 ; CHECK: ldr d{{[0-9]+}}, [x{{[0-9]+}}, #16]! 451 br i1 %cond, label %if.then, label %if.end 452 if.then: 453 %load1 = load %pre.struct.double*, %pre.struct.double** %this 454 %gep1 = getelementptr inbounds %pre.struct.double, %pre.struct.double* %load1, i64 0, i32 2 455 br label %return 456 if.end: 457 %gep2 = getelementptr inbounds %pre.struct.double, %pre.struct.double* %load2, i64 0, i32 3 458 br label %return 459 return: 460 %retptr = phi double* [ %gep1, %if.then ], [ %gep2, %if.end ] 461 %ret = load double, double* %retptr 462 ret double %ret 463 } 464 465 ; Check the following transform: 466 ; 467 ; add x8, x8, #16 468 ; ... 469 ; str X, [x8] 470 ; -> 471 ; str X, [x8, #16]! 472 ; 473 ; with X being either w0, x0, s0, d0 or q0. 474 475 define void @store-pre-indexed-word2(%pre.struct.i32** %this, i1 %cond, 476 %pre.struct.i32* %load2, 477 i32 %val) nounwind { 478 ; CHECK-LABEL: store-pre-indexed-word2 479 ; CHECK: str w{{[0-9]+}}, [x{{[0-9]+}}, #4]! 480 br i1 %cond, label %if.then, label %if.end 481 if.then: 482 %load1 = load %pre.struct.i32*, %pre.struct.i32** %this 483 %gep1 = getelementptr inbounds %pre.struct.i32, %pre.struct.i32* %load1, i64 0, i32 1 484 br label %return 485 if.end: 486 %gep2 = getelementptr inbounds %pre.struct.i32, %pre.struct.i32* %load2, i64 0, i32 2 487 br label %return 488 return: 489 %retptr = phi i32* [ %gep1, %if.then ], [ %gep2, %if.end ] 490 store i32 %val, i32* %retptr 491 ret void 492 } 493 494 define void @store-pre-indexed-doubleword2(%pre.struct.i64** %this, i1 %cond, 495 %pre.struct.i64* %load2, 496 i64 %val) nounwind { 497 ; CHECK-LABEL: store-pre-indexed-doubleword2 498 ; CHECK: str x{{[0-9]+}}, [x{{[0-9]+}}, #8]! 499 br i1 %cond, label %if.then, label %if.end 500 if.then: 501 %load1 = load %pre.struct.i64*, %pre.struct.i64** %this 502 %gep1 = getelementptr inbounds %pre.struct.i64, %pre.struct.i64* %load1, i64 0, i32 1 503 br label %return 504 if.end: 505 %gep2 = getelementptr inbounds %pre.struct.i64, %pre.struct.i64* %load2, i64 0, i32 2 506 br label %return 507 return: 508 %retptr = phi i64* [ %gep1, %if.then ], [ %gep2, %if.end ] 509 store i64 %val, i64* %retptr 510 ret void 511 } 512 513 define void @store-pre-indexed-quadword2(%pre.struct.i128** %this, i1 %cond, 514 %pre.struct.i128* %load2, 515 <2 x i64> %val) nounwind { 516 ; CHECK-LABEL: store-pre-indexed-quadword2 517 ; CHECK: str q{{[0-9]+}}, [x{{[0-9]+}}, #16]! 518 br i1 %cond, label %if.then, label %if.end 519 if.then: 520 %load1 = load %pre.struct.i128*, %pre.struct.i128** %this 521 %gep1 = getelementptr inbounds %pre.struct.i128, %pre.struct.i128* %load1, i64 0, i32 1 522 br label %return 523 if.end: 524 %gep2 = getelementptr inbounds %pre.struct.i128, %pre.struct.i128* %load2, i64 0, i32 2 525 br label %return 526 return: 527 %retptr = phi <2 x i64>* [ %gep1, %if.then ], [ %gep2, %if.end ] 528 store <2 x i64> %val, <2 x i64>* %retptr 529 ret void 530 } 531 532 define void @store-pre-indexed-float2(%pre.struct.float** %this, i1 %cond, 533 %pre.struct.float* %load2, 534 float %val) nounwind { 535 ; CHECK-LABEL: store-pre-indexed-float2 536 ; CHECK: str s{{[0-9]+}}, [x{{[0-9]+}}, #4]! 537 br i1 %cond, label %if.then, label %if.end 538 if.then: 539 %load1 = load %pre.struct.float*, %pre.struct.float** %this 540 %gep1 = getelementptr inbounds %pre.struct.float, %pre.struct.float* %load1, i64 0, i32 1 541 br label %return 542 if.end: 543 %gep2 = getelementptr inbounds %pre.struct.float, %pre.struct.float* %load2, i64 0, i32 2 544 br label %return 545 return: 546 %retptr = phi float* [ %gep1, %if.then ], [ %gep2, %if.end ] 547 store float %val, float* %retptr 548 ret void 549 } 550 551 define void @store-pre-indexed-double2(%pre.struct.double** %this, i1 %cond, 552 %pre.struct.double* %load2, 553 double %val) nounwind { 554 ; CHECK-LABEL: store-pre-indexed-double2 555 ; CHECK: str d{{[0-9]+}}, [x{{[0-9]+}}, #8]! 556 br i1 %cond, label %if.then, label %if.end 557 if.then: 558 %load1 = load %pre.struct.double*, %pre.struct.double** %this 559 %gep1 = getelementptr inbounds %pre.struct.double, %pre.struct.double* %load1, i64 0, i32 1 560 br label %return 561 if.end: 562 %gep2 = getelementptr inbounds %pre.struct.double, %pre.struct.double* %load2, i64 0, i32 2 563 br label %return 564 return: 565 %retptr = phi double* [ %gep1, %if.then ], [ %gep2, %if.end ] 566 store double %val, double* %retptr 567 ret void 568 } 569 570 define void @store-pre-indexed-word3(%pre.struct.i32** %this, i1 %cond, 571 %pre.struct.i32* %load2, 572 i32 %val) nounwind { 573 ; CHECK-LABEL: store-pre-indexed-word3 574 ; CHECK: str w{{[0-9]+}}, [x{{[0-9]+}}, #12]! 575 br i1 %cond, label %if.then, label %if.end 576 if.then: 577 %load1 = load %pre.struct.i32*, %pre.struct.i32** %this 578 %gep1 = getelementptr inbounds %pre.struct.i32, %pre.struct.i32* %load1, i64 0, i32 3 579 br label %return 580 if.end: 581 %gep2 = getelementptr inbounds %pre.struct.i32, %pre.struct.i32* %load2, i64 0, i32 4 582 br label %return 583 return: 584 %retptr = phi i32* [ %gep1, %if.then ], [ %gep2, %if.end ] 585 store i32 %val, i32* %retptr 586 ret void 587 } 588 589 define void @store-pre-indexed-doubleword3(%pre.struct.i64** %this, i1 %cond, 590 %pre.struct.i64* %load2, 591 i64 %val) nounwind { 592 ; CHECK-LABEL: store-pre-indexed-doubleword3 593 ; CHECK: str x{{[0-9]+}}, [x{{[0-9]+}}, #24]! 594 br i1 %cond, label %if.then, label %if.end 595 if.then: 596 %load1 = load %pre.struct.i64*, %pre.struct.i64** %this 597 %gep1 = getelementptr inbounds %pre.struct.i64, %pre.struct.i64* %load1, i64 0, i32 3 598 br label %return 599 if.end: 600 %gep2 = getelementptr inbounds %pre.struct.i64, %pre.struct.i64* %load2, i64 0, i32 4 601 br label %return 602 return: 603 %retptr = phi i64* [ %gep1, %if.then ], [ %gep2, %if.end ] 604 store i64 %val, i64* %retptr 605 ret void 606 } 607 608 define void @store-pre-indexed-quadword3(%pre.struct.i128** %this, i1 %cond, 609 %pre.struct.i128* %load2, 610 <2 x i64> %val) nounwind { 611 ; CHECK-LABEL: store-pre-indexed-quadword3 612 ; CHECK: str q{{[0-9]+}}, [x{{[0-9]+}}, #32]! 613 br i1 %cond, label %if.then, label %if.end 614 if.then: 615 %load1 = load %pre.struct.i128*, %pre.struct.i128** %this 616 %gep1 = getelementptr inbounds %pre.struct.i128, %pre.struct.i128* %load1, i64 0, i32 2 617 br label %return 618 if.end: 619 %gep2 = getelementptr inbounds %pre.struct.i128, %pre.struct.i128* %load2, i64 0, i32 3 620 br label %return 621 return: 622 %retptr = phi <2 x i64>* [ %gep1, %if.then ], [ %gep2, %if.end ] 623 store <2 x i64> %val, <2 x i64>* %retptr 624 ret void 625 } 626 627 define void @store-pre-indexed-float3(%pre.struct.float** %this, i1 %cond, 628 %pre.struct.float* %load2, 629 float %val) nounwind { 630 ; CHECK-LABEL: store-pre-indexed-float3 631 ; CHECK: str s{{[0-9]+}}, [x{{[0-9]+}}, #8]! 632 br i1 %cond, label %if.then, label %if.end 633 if.then: 634 %load1 = load %pre.struct.float*, %pre.struct.float** %this 635 %gep1 = getelementptr inbounds %pre.struct.float, %pre.struct.float* %load1, i64 0, i32 2 636 br label %return 637 if.end: 638 %gep2 = getelementptr inbounds %pre.struct.float, %pre.struct.float* %load2, i64 0, i32 3 639 br label %return 640 return: 641 %retptr = phi float* [ %gep1, %if.then ], [ %gep2, %if.end ] 642 store float %val, float* %retptr 643 ret void 644 } 645 646 define void @store-pre-indexed-double3(%pre.struct.double** %this, i1 %cond, 647 %pre.struct.double* %load2, 648 double %val) nounwind { 649 ; CHECK-LABEL: store-pre-indexed-double3 650 ; CHECK: str d{{[0-9]+}}, [x{{[0-9]+}}, #16]! 651 br i1 %cond, label %if.then, label %if.end 652 if.then: 653 %load1 = load %pre.struct.double*, %pre.struct.double** %this 654 %gep1 = getelementptr inbounds %pre.struct.double, %pre.struct.double* %load1, i64 0, i32 2 655 br label %return 656 if.end: 657 %gep2 = getelementptr inbounds %pre.struct.double, %pre.struct.double* %load2, i64 0, i32 3 658 br label %return 659 return: 660 %retptr = phi double* [ %gep1, %if.then ], [ %gep2, %if.end ] 661 store double %val, double* %retptr 662 ret void 663 } 664 665 ; Check the following transform: 666 ; 667 ; ldr X, [x20] 668 ; ... 669 ; add x20, x20, #32 670 ; -> 671 ; ldr X, [x20], #32 672 ; 673 ; with X being either w0, x0, s0, d0 or q0. 674 675 define void @load-post-indexed-byte(i8* %array, i64 %count) nounwind { 676 ; CHECK-LABEL: load-post-indexed-byte 677 ; CHECK: ldrb w{{[0-9]+}}, [x{{[0-9]+}}], #4 678 entry: 679 %gep1 = getelementptr i8, i8* %array, i64 2 680 br label %body 681 682 body: 683 %iv2 = phi i8* [ %gep3, %body ], [ %gep1, %entry ] 684 %iv = phi i64 [ %iv.next, %body ], [ %count, %entry ] 685 %gep2 = getelementptr i8, i8* %iv2, i64 -1 686 %load = load i8, i8* %gep2 687 call void @use-byte(i8 %load) 688 %load2 = load i8, i8* %iv2 689 call void @use-byte(i8 %load2) 690 %iv.next = add i64 %iv, -4 691 %gep3 = getelementptr i8, i8* %iv2, i64 4 692 %cond = icmp eq i64 %iv.next, 0 693 br i1 %cond, label %exit, label %body 694 695 exit: 696 ret void 697 } 698 699 define void @load-post-indexed-halfword(i16* %array, i64 %count) nounwind { 700 ; CHECK-LABEL: load-post-indexed-halfword 701 ; CHECK: ldrh w{{[0-9]+}}, [x{{[0-9]+}}], #8 702 entry: 703 %gep1 = getelementptr i16, i16* %array, i64 2 704 br label %body 705 706 body: 707 %iv2 = phi i16* [ %gep3, %body ], [ %gep1, %entry ] 708 %iv = phi i64 [ %iv.next, %body ], [ %count, %entry ] 709 %gep2 = getelementptr i16, i16* %iv2, i64 -1 710 %load = load i16, i16* %gep2 711 call void @use-halfword(i16 %load) 712 %load2 = load i16, i16* %iv2 713 call void @use-halfword(i16 %load2) 714 %iv.next = add i64 %iv, -4 715 %gep3 = getelementptr i16, i16* %iv2, i64 4 716 %cond = icmp eq i64 %iv.next, 0 717 br i1 %cond, label %exit, label %body 718 719 exit: 720 ret void 721 } 722 723 define void @load-post-indexed-word(i32* %array, i64 %count) nounwind { 724 ; CHECK-LABEL: load-post-indexed-word 725 ; CHECK: ldr w{{[0-9]+}}, [x{{[0-9]+}}], #16 726 entry: 727 %gep1 = getelementptr i32, i32* %array, i64 2 728 br label %body 729 730 body: 731 %iv2 = phi i32* [ %gep3, %body ], [ %gep1, %entry ] 732 %iv = phi i64 [ %iv.next, %body ], [ %count, %entry ] 733 %gep2 = getelementptr i32, i32* %iv2, i64 -1 734 %load = load i32, i32* %gep2 735 call void @use-word(i32 %load) 736 %load2 = load i32, i32* %iv2 737 call void @use-word(i32 %load2) 738 %iv.next = add i64 %iv, -4 739 %gep3 = getelementptr i32, i32* %iv2, i64 4 740 %cond = icmp eq i64 %iv.next, 0 741 br i1 %cond, label %exit, label %body 742 743 exit: 744 ret void 745 } 746 747 define void @load-post-indexed-doubleword(i64* %array, i64 %count) nounwind { 748 ; CHECK-LABEL: load-post-indexed-doubleword 749 ; CHECK: ldr x{{[0-9]+}}, [x{{[0-9]+}}], #32 750 entry: 751 %gep1 = getelementptr i64, i64* %array, i64 2 752 br label %body 753 754 body: 755 %iv2 = phi i64* [ %gep3, %body ], [ %gep1, %entry ] 756 %iv = phi i64 [ %iv.next, %body ], [ %count, %entry ] 757 %gep2 = getelementptr i64, i64* %iv2, i64 -1 758 %load = load i64, i64* %gep2 759 call void @use-doubleword(i64 %load) 760 %load2 = load i64, i64* %iv2 761 call void @use-doubleword(i64 %load2) 762 %iv.next = add i64 %iv, -4 763 %gep3 = getelementptr i64, i64* %iv2, i64 4 764 %cond = icmp eq i64 %iv.next, 0 765 br i1 %cond, label %exit, label %body 766 767 exit: 768 ret void 769 } 770 771 define void @load-post-indexed-quadword(<2 x i64>* %array, i64 %count) nounwind { 772 ; CHECK-LABEL: load-post-indexed-quadword 773 ; CHECK: ldr q{{[0-9]+}}, [x{{[0-9]+}}], #64 774 entry: 775 %gep1 = getelementptr <2 x i64>, <2 x i64>* %array, i64 2 776 br label %body 777 778 body: 779 %iv2 = phi <2 x i64>* [ %gep3, %body ], [ %gep1, %entry ] 780 %iv = phi i64 [ %iv.next, %body ], [ %count, %entry ] 781 %gep2 = getelementptr <2 x i64>, <2 x i64>* %iv2, i64 -1 782 %load = load <2 x i64>, <2 x i64>* %gep2 783 call void @use-quadword(<2 x i64> %load) 784 %load2 = load <2 x i64>, <2 x i64>* %iv2 785 call void @use-quadword(<2 x i64> %load2) 786 %iv.next = add i64 %iv, -4 787 %gep3 = getelementptr <2 x i64>, <2 x i64>* %iv2, i64 4 788 %cond = icmp eq i64 %iv.next, 0 789 br i1 %cond, label %exit, label %body 790 791 exit: 792 ret void 793 } 794 795 define void @load-post-indexed-float(float* %array, i64 %count) nounwind { 796 ; CHECK-LABEL: load-post-indexed-float 797 ; CHECK: ldr s{{[0-9]+}}, [x{{[0-9]+}}], #16 798 entry: 799 %gep1 = getelementptr float, float* %array, i64 2 800 br label %body 801 802 body: 803 %iv2 = phi float* [ %gep3, %body ], [ %gep1, %entry ] 804 %iv = phi i64 [ %iv.next, %body ], [ %count, %entry ] 805 %gep2 = getelementptr float, float* %iv2, i64 -1 806 %load = load float, float* %gep2 807 call void @use-float(float %load) 808 %load2 = load float, float* %iv2 809 call void @use-float(float %load2) 810 %iv.next = add i64 %iv, -4 811 %gep3 = getelementptr float, float* %iv2, i64 4 812 %cond = icmp eq i64 %iv.next, 0 813 br i1 %cond, label %exit, label %body 814 815 exit: 816 ret void 817 } 818 819 define void @load-post-indexed-double(double* %array, i64 %count) nounwind { 820 ; CHECK-LABEL: load-post-indexed-double 821 ; CHECK: ldr d{{[0-9]+}}, [x{{[0-9]+}}], #32 822 entry: 823 %gep1 = getelementptr double, double* %array, i64 2 824 br label %body 825 826 body: 827 %iv2 = phi double* [ %gep3, %body ], [ %gep1, %entry ] 828 %iv = phi i64 [ %iv.next, %body ], [ %count, %entry ] 829 %gep2 = getelementptr double, double* %iv2, i64 -1 830 %load = load double, double* %gep2 831 call void @use-double(double %load) 832 %load2 = load double, double* %iv2 833 call void @use-double(double %load2) 834 %iv.next = add i64 %iv, -4 835 %gep3 = getelementptr double, double* %iv2, i64 4 836 %cond = icmp eq i64 %iv.next, 0 837 br i1 %cond, label %exit, label %body 838 839 exit: 840 ret void 841 } 842 843 ; Check the following transform: 844 ; 845 ; str X, [x20] 846 ; ... 847 ; add x20, x20, #32 848 ; -> 849 ; str X, [x20], #32 850 ; 851 ; with X being either w0, x0, s0, d0 or q0. 852 853 define void @store-post-indexed-byte(i8* %array, i64 %count, i8 %val) nounwind { 854 ; CHECK-LABEL: store-post-indexed-byte 855 ; CHECK: strb w{{[0-9]+}}, [x{{[0-9]+}}], #4 856 entry: 857 %gep1 = getelementptr i8, i8* %array, i64 2 858 br label %body 859 860 body: 861 %iv2 = phi i8* [ %gep3, %body ], [ %gep1, %entry ] 862 %iv = phi i64 [ %iv.next, %body ], [ %count, %entry ] 863 %gep2 = getelementptr i8, i8* %iv2, i64 -1 864 %load = load i8, i8* %gep2 865 call void @use-byte(i8 %load) 866 store i8 %val, i8* %iv2 867 %iv.next = add i64 %iv, -4 868 %gep3 = getelementptr i8, i8* %iv2, i64 4 869 %cond = icmp eq i64 %iv.next, 0 870 br i1 %cond, label %exit, label %body 871 872 exit: 873 ret void 874 } 875 876 define void @store-post-indexed-halfword(i16* %array, i64 %count, i16 %val) nounwind { 877 ; CHECK-LABEL: store-post-indexed-halfword 878 ; CHECK: strh w{{[0-9]+}}, [x{{[0-9]+}}], #8 879 entry: 880 %gep1 = getelementptr i16, i16* %array, i64 2 881 br label %body 882 883 body: 884 %iv2 = phi i16* [ %gep3, %body ], [ %gep1, %entry ] 885 %iv = phi i64 [ %iv.next, %body ], [ %count, %entry ] 886 %gep2 = getelementptr i16, i16* %iv2, i64 -1 887 %load = load i16, i16* %gep2 888 call void @use-halfword(i16 %load) 889 store i16 %val, i16* %iv2 890 %iv.next = add i64 %iv, -4 891 %gep3 = getelementptr i16, i16* %iv2, i64 4 892 %cond = icmp eq i64 %iv.next, 0 893 br i1 %cond, label %exit, label %body 894 895 exit: 896 ret void 897 } 898 899 define void @store-post-indexed-word(i32* %array, i64 %count, i32 %val) nounwind { 900 ; CHECK-LABEL: store-post-indexed-word 901 ; CHECK: str w{{[0-9]+}}, [x{{[0-9]+}}], #16 902 entry: 903 %gep1 = getelementptr i32, i32* %array, i64 2 904 br label %body 905 906 body: 907 %iv2 = phi i32* [ %gep3, %body ], [ %gep1, %entry ] 908 %iv = phi i64 [ %iv.next, %body ], [ %count, %entry ] 909 %gep2 = getelementptr i32, i32* %iv2, i64 -1 910 %load = load i32, i32* %gep2 911 call void @use-word(i32 %load) 912 store i32 %val, i32* %iv2 913 %iv.next = add i64 %iv, -4 914 %gep3 = getelementptr i32, i32* %iv2, i64 4 915 %cond = icmp eq i64 %iv.next, 0 916 br i1 %cond, label %exit, label %body 917 918 exit: 919 ret void 920 } 921 922 define void @store-post-indexed-doubleword(i64* %array, i64 %count, i64 %val) nounwind { 923 ; CHECK-LABEL: store-post-indexed-doubleword 924 ; CHECK: str x{{[0-9]+}}, [x{{[0-9]+}}], #32 925 entry: 926 %gep1 = getelementptr i64, i64* %array, i64 2 927 br label %body 928 929 body: 930 %iv2 = phi i64* [ %gep3, %body ], [ %gep1, %entry ] 931 %iv = phi i64 [ %iv.next, %body ], [ %count, %entry ] 932 %gep2 = getelementptr i64, i64* %iv2, i64 -1 933 %load = load i64, i64* %gep2 934 call void @use-doubleword(i64 %load) 935 store i64 %val, i64* %iv2 936 %iv.next = add i64 %iv, -4 937 %gep3 = getelementptr i64, i64* %iv2, i64 4 938 %cond = icmp eq i64 %iv.next, 0 939 br i1 %cond, label %exit, label %body 940 941 exit: 942 ret void 943 } 944 945 define void @store-post-indexed-quadword(<2 x i64>* %array, i64 %count, <2 x i64> %val) nounwind { 946 ; CHECK-LABEL: store-post-indexed-quadword 947 ; CHECK: str q{{[0-9]+}}, [x{{[0-9]+}}], #64 948 entry: 949 %gep1 = getelementptr <2 x i64>, <2 x i64>* %array, i64 2 950 br label %body 951 952 body: 953 %iv2 = phi <2 x i64>* [ %gep3, %body ], [ %gep1, %entry ] 954 %iv = phi i64 [ %iv.next, %body ], [ %count, %entry ] 955 %gep2 = getelementptr <2 x i64>, <2 x i64>* %iv2, i64 -1 956 %load = load <2 x i64>, <2 x i64>* %gep2 957 call void @use-quadword(<2 x i64> %load) 958 store <2 x i64> %val, <2 x i64>* %iv2 959 %iv.next = add i64 %iv, -4 960 %gep3 = getelementptr <2 x i64>, <2 x i64>* %iv2, i64 4 961 %cond = icmp eq i64 %iv.next, 0 962 br i1 %cond, label %exit, label %body 963 964 exit: 965 ret void 966 } 967 968 define void @store-post-indexed-float(float* %array, i64 %count, float %val) nounwind { 969 ; CHECK-LABEL: store-post-indexed-float 970 ; CHECK: str s{{[0-9]+}}, [x{{[0-9]+}}], #16 971 entry: 972 %gep1 = getelementptr float, float* %array, i64 2 973 br label %body 974 975 body: 976 %iv2 = phi float* [ %gep3, %body ], [ %gep1, %entry ] 977 %iv = phi i64 [ %iv.next, %body ], [ %count, %entry ] 978 %gep2 = getelementptr float, float* %iv2, i64 -1 979 %load = load float, float* %gep2 980 call void @use-float(float %load) 981 store float %val, float* %iv2 982 %iv.next = add i64 %iv, -4 983 %gep3 = getelementptr float, float* %iv2, i64 4 984 %cond = icmp eq i64 %iv.next, 0 985 br i1 %cond, label %exit, label %body 986 987 exit: 988 ret void 989 } 990 991 define void @store-post-indexed-double(double* %array, i64 %count, double %val) nounwind { 992 ; CHECK-LABEL: store-post-indexed-double 993 ; CHECK: str d{{[0-9]+}}, [x{{[0-9]+}}], #32 994 entry: 995 %gep1 = getelementptr double, double* %array, i64 2 996 br label %body 997 998 body: 999 %iv2 = phi double* [ %gep3, %body ], [ %gep1, %entry ] 1000 %iv = phi i64 [ %iv.next, %body ], [ %count, %entry ] 1001 %gep2 = getelementptr double, double* %iv2, i64 -1 1002 %load = load double, double* %gep2 1003 call void @use-double(double %load) 1004 store double %val, double* %iv2 1005 %iv.next = add i64 %iv, -4 1006 %gep3 = getelementptr double, double* %iv2, i64 4 1007 %cond = icmp eq i64 %iv.next, 0 1008 br i1 %cond, label %exit, label %body 1009 1010 exit: 1011 ret void 1012 } 1013 1014 declare void @use-byte(i8) 1015 declare void @use-halfword(i16) 1016 declare void @use-word(i32) 1017 declare void @use-doubleword(i64) 1018 declare void @use-quadword(<2 x i64>) 1019 declare void @use-float(float) 1020 declare void @use-double(double) 1021 1022 ; Check the following transform: 1023 ; 1024 ; stp w0, [x20] 1025 ; ... 1026 ; add x20, x20, #32 1027 ; -> 1028 ; stp w0, [x20], #32 1029 1030 define void @store-pair-post-indexed-word() nounwind { 1031 ; CHECK-LABEL: store-pair-post-indexed-word 1032 ; CHECK: stp w{{[0-9]+}}, w{{[0-9]+}}, [sp], #16 1033 ; CHECK: ret 1034 %src = alloca { i32, i32 }, align 8 1035 %dst = alloca { i32, i32 }, align 8 1036 1037 %src.realp = getelementptr inbounds { i32, i32 }, { i32, i32 }* %src, i32 0, i32 0 1038 %src.real = load i32, i32* %src.realp 1039 %src.imagp = getelementptr inbounds { i32, i32 }, { i32, i32 }* %src, i32 0, i32 1 1040 %src.imag = load i32, i32* %src.imagp 1041 1042 %dst.realp = getelementptr inbounds { i32, i32 }, { i32, i32 }* %dst, i32 0, i32 0 1043 %dst.imagp = getelementptr inbounds { i32, i32 }, { i32, i32 }* %dst, i32 0, i32 1 1044 store i32 %src.real, i32* %dst.realp 1045 store i32 %src.imag, i32* %dst.imagp 1046 ret void 1047 } 1048 1049 define void @store-pair-post-indexed-doubleword() nounwind { 1050 ; CHECK-LABEL: store-pair-post-indexed-doubleword 1051 ; CHECK: stp x{{[0-9]+}}, x{{[0-9]+}}, [sp], #32 1052 ; CHECK: ret 1053 %src = alloca { i64, i64 }, align 8 1054 %dst = alloca { i64, i64 }, align 8 1055 1056 %src.realp = getelementptr inbounds { i64, i64 }, { i64, i64 }* %src, i32 0, i32 0 1057 %src.real = load i64, i64* %src.realp 1058 %src.imagp = getelementptr inbounds { i64, i64 }, { i64, i64 }* %src, i32 0, i32 1 1059 %src.imag = load i64, i64* %src.imagp 1060 1061 %dst.realp = getelementptr inbounds { i64, i64 }, { i64, i64 }* %dst, i32 0, i32 0 1062 %dst.imagp = getelementptr inbounds { i64, i64 }, { i64, i64 }* %dst, i32 0, i32 1 1063 store i64 %src.real, i64* %dst.realp 1064 store i64 %src.imag, i64* %dst.imagp 1065 ret void 1066 } 1067 1068 define void @store-pair-post-indexed-float() nounwind { 1069 ; CHECK-LABEL: store-pair-post-indexed-float 1070 ; CHECK: stp s{{[0-9]+}}, s{{[0-9]+}}, [sp], #16 1071 ; CHECK: ret 1072 %src = alloca { float, float }, align 8 1073 %dst = alloca { float, float }, align 8 1074 1075 %src.realp = getelementptr inbounds { float, float }, { float, float }* %src, i32 0, i32 0 1076 %src.real = load float, float* %src.realp 1077 %src.imagp = getelementptr inbounds { float, float }, { float, float }* %src, i32 0, i32 1 1078 %src.imag = load float, float* %src.imagp 1079 1080 %dst.realp = getelementptr inbounds { float, float }, { float, float }* %dst, i32 0, i32 0 1081 %dst.imagp = getelementptr inbounds { float, float }, { float, float }* %dst, i32 0, i32 1 1082 store float %src.real, float* %dst.realp 1083 store float %src.imag, float* %dst.imagp 1084 ret void 1085 } 1086 1087 define void @store-pair-post-indexed-double() nounwind { 1088 ; CHECK-LABEL: store-pair-post-indexed-double 1089 ; CHECK: stp d{{[0-9]+}}, d{{[0-9]+}}, [sp], #32 1090 ; CHECK: ret 1091 %src = alloca { double, double }, align 8 1092 %dst = alloca { double, double }, align 8 1093 1094 %src.realp = getelementptr inbounds { double, double }, { double, double }* %src, i32 0, i32 0 1095 %src.real = load double, double* %src.realp 1096 %src.imagp = getelementptr inbounds { double, double }, { double, double }* %src, i32 0, i32 1 1097 %src.imag = load double, double* %src.imagp 1098 1099 %dst.realp = getelementptr inbounds { double, double }, { double, double }* %dst, i32 0, i32 0 1100 %dst.imagp = getelementptr inbounds { double, double }, { double, double }* %dst, i32 0, i32 1 1101 store double %src.real, double* %dst.realp 1102 store double %src.imag, double* %dst.imagp 1103 ret void 1104 } 1105 1106 ; Check the following transform: 1107 ; 1108 ; (ldr|str) X, [x20] 1109 ; ... 1110 ; sub x20, x20, #16 1111 ; -> 1112 ; (ldr|str) X, [x20], #-16 1113 ; 1114 ; with X being either w0, x0, s0, d0 or q0. 1115 1116 define void @post-indexed-sub-word(i32* %a, i32* %b, i64 %count) nounwind { 1117 ; CHECK-LABEL: post-indexed-sub-word 1118 ; CHECK: ldr w{{[0-9]+}}, [x{{[0-9]+}}], #-8 1119 ; CHECK: str w{{[0-9]+}}, [x{{[0-9]+}}], #-8 1120 br label %for.body 1121 for.body: 1122 %phi1 = phi i32* [ %gep4, %for.body ], [ %b, %0 ] 1123 %phi2 = phi i32* [ %gep3, %for.body ], [ %a, %0 ] 1124 %i = phi i64 [ %dec.i, %for.body], [ %count, %0 ] 1125 %gep1 = getelementptr i32, i32* %phi1, i64 -1 1126 %load1 = load i32, i32* %gep1 1127 %gep2 = getelementptr i32, i32* %phi2, i64 -1 1128 store i32 %load1, i32* %gep2 1129 %load2 = load i32, i32* %phi1 1130 store i32 %load2, i32* %phi2 1131 %dec.i = add nsw i64 %i, -1 1132 %gep3 = getelementptr i32, i32* %phi2, i64 -2 1133 %gep4 = getelementptr i32, i32* %phi1, i64 -2 1134 %cond = icmp sgt i64 %dec.i, 0 1135 br i1 %cond, label %for.body, label %end 1136 end: 1137 ret void 1138 } 1139 1140 define void @post-indexed-sub-doubleword(i64* %a, i64* %b, i64 %count) nounwind { 1141 ; CHECK-LABEL: post-indexed-sub-doubleword 1142 ; CHECK: ldr x{{[0-9]+}}, [x{{[0-9]+}}], #-16 1143 ; CHECK: str x{{[0-9]+}}, [x{{[0-9]+}}], #-16 1144 br label %for.body 1145 for.body: 1146 %phi1 = phi i64* [ %gep4, %for.body ], [ %b, %0 ] 1147 %phi2 = phi i64* [ %gep3, %for.body ], [ %a, %0 ] 1148 %i = phi i64 [ %dec.i, %for.body], [ %count, %0 ] 1149 %gep1 = getelementptr i64, i64* %phi1, i64 -1 1150 %load1 = load i64, i64* %gep1 1151 %gep2 = getelementptr i64, i64* %phi2, i64 -1 1152 store i64 %load1, i64* %gep2 1153 %load2 = load i64, i64* %phi1 1154 store i64 %load2, i64* %phi2 1155 %dec.i = add nsw i64 %i, -1 1156 %gep3 = getelementptr i64, i64* %phi2, i64 -2 1157 %gep4 = getelementptr i64, i64* %phi1, i64 -2 1158 %cond = icmp sgt i64 %dec.i, 0 1159 br i1 %cond, label %for.body, label %end 1160 end: 1161 ret void 1162 } 1163 1164 define void @post-indexed-sub-quadword(<2 x i64>* %a, <2 x i64>* %b, i64 %count) nounwind { 1165 ; CHECK-LABEL: post-indexed-sub-quadword 1166 ; CHECK: ldr q{{[0-9]+}}, [x{{[0-9]+}}], #-32 1167 ; CHECK: str q{{[0-9]+}}, [x{{[0-9]+}}], #-32 1168 br label %for.body 1169 for.body: 1170 %phi1 = phi <2 x i64>* [ %gep4, %for.body ], [ %b, %0 ] 1171 %phi2 = phi <2 x i64>* [ %gep3, %for.body ], [ %a, %0 ] 1172 %i = phi i64 [ %dec.i, %for.body], [ %count, %0 ] 1173 %gep1 = getelementptr <2 x i64>, <2 x i64>* %phi1, i64 -1 1174 %load1 = load <2 x i64>, <2 x i64>* %gep1 1175 %gep2 = getelementptr <2 x i64>, <2 x i64>* %phi2, i64 -1 1176 store <2 x i64> %load1, <2 x i64>* %gep2 1177 %load2 = load <2 x i64>, <2 x i64>* %phi1 1178 store <2 x i64> %load2, <2 x i64>* %phi2 1179 %dec.i = add nsw i64 %i, -1 1180 %gep3 = getelementptr <2 x i64>, <2 x i64>* %phi2, i64 -2 1181 %gep4 = getelementptr <2 x i64>, <2 x i64>* %phi1, i64 -2 1182 %cond = icmp sgt i64 %dec.i, 0 1183 br i1 %cond, label %for.body, label %end 1184 end: 1185 ret void 1186 } 1187 1188 define void @post-indexed-sub-float(float* %a, float* %b, i64 %count) nounwind { 1189 ; CHECK-LABEL: post-indexed-sub-float 1190 ; CHECK: ldr s{{[0-9]+}}, [x{{[0-9]+}}], #-8 1191 ; CHECK: str s{{[0-9]+}}, [x{{[0-9]+}}], #-8 1192 br label %for.body 1193 for.body: 1194 %phi1 = phi float* [ %gep4, %for.body ], [ %b, %0 ] 1195 %phi2 = phi float* [ %gep3, %for.body ], [ %a, %0 ] 1196 %i = phi i64 [ %dec.i, %for.body], [ %count, %0 ] 1197 %gep1 = getelementptr float, float* %phi1, i64 -1 1198 %load1 = load float, float* %gep1 1199 %gep2 = getelementptr float, float* %phi2, i64 -1 1200 store float %load1, float* %gep2 1201 %load2 = load float, float* %phi1 1202 store float %load2, float* %phi2 1203 %dec.i = add nsw i64 %i, -1 1204 %gep3 = getelementptr float, float* %phi2, i64 -2 1205 %gep4 = getelementptr float, float* %phi1, i64 -2 1206 %cond = icmp sgt i64 %dec.i, 0 1207 br i1 %cond, label %for.body, label %end 1208 end: 1209 ret void 1210 } 1211 1212 define void @post-indexed-sub-double(double* %a, double* %b, i64 %count) nounwind { 1213 ; CHECK-LABEL: post-indexed-sub-double 1214 ; CHECK: ldr d{{[0-9]+}}, [x{{[0-9]+}}], #-16 1215 ; CHECK: str d{{[0-9]+}}, [x{{[0-9]+}}], #-16 1216 br label %for.body 1217 for.body: 1218 %phi1 = phi double* [ %gep4, %for.body ], [ %b, %0 ] 1219 %phi2 = phi double* [ %gep3, %for.body ], [ %a, %0 ] 1220 %i = phi i64 [ %dec.i, %for.body], [ %count, %0 ] 1221 %gep1 = getelementptr double, double* %phi1, i64 -1 1222 %load1 = load double, double* %gep1 1223 %gep2 = getelementptr double, double* %phi2, i64 -1 1224 store double %load1, double* %gep2 1225 %load2 = load double, double* %phi1 1226 store double %load2, double* %phi2 1227 %dec.i = add nsw i64 %i, -1 1228 %gep3 = getelementptr double, double* %phi2, i64 -2 1229 %gep4 = getelementptr double, double* %phi1, i64 -2 1230 %cond = icmp sgt i64 %dec.i, 0 1231 br i1 %cond, label %for.body, label %end 1232 end: 1233 ret void 1234 } 1235
