1 ; This test makes sure that these instructions are properly eliminated. 2 ; 3 ; RUN: opt < %s -instcombine -S | FileCheck %s 4 5 define i32 @test1(i32 %A) { 6 ; CHECK: @test1 7 ; CHECK: ret i32 %A 8 %B = shl i32 %A, 0 ; <i32> [#uses=1] 9 ret i32 %B 10 } 11 12 define i32 @test2(i8 %A) { 13 ; CHECK: @test2 14 ; CHECK: ret i32 0 15 %shift.upgrd.1 = zext i8 %A to i32 ; <i32> [#uses=1] 16 %B = shl i32 0, %shift.upgrd.1 ; <i32> [#uses=1] 17 ret i32 %B 18 } 19 20 define i32 @test3(i32 %A) { 21 ; CHECK: @test3 22 ; CHECK: ret i32 %A 23 %B = ashr i32 %A, 0 ; <i32> [#uses=1] 24 ret i32 %B 25 } 26 27 define i32 @test4(i8 %A) { 28 ; CHECK: @test4 29 ; CHECK: ret i32 0 30 %shift.upgrd.2 = zext i8 %A to i32 ; <i32> [#uses=1] 31 %B = ashr i32 0, %shift.upgrd.2 ; <i32> [#uses=1] 32 ret i32 %B 33 } 34 35 36 define i32 @test5(i32 %A) { 37 ; CHECK: @test5 38 ; CHECK: ret i32 undef 39 %B = lshr i32 %A, 32 ;; shift all bits out 40 ret i32 %B 41 } 42 43 define i32 @test5a(i32 %A) { 44 ; CHECK: @test5a 45 ; CHECK: ret i32 undef 46 %B = shl i32 %A, 32 ;; shift all bits out 47 ret i32 %B 48 } 49 50 define i32 @test5b() { 51 ; CHECK: @test5b 52 ; CHECK: ret i32 -1 53 %B = ashr i32 undef, 2 ;; top two bits must be equal, so not undef 54 ret i32 %B 55 } 56 57 define i32 @test5b2(i32 %A) { 58 ; CHECK: @test5b2 59 ; CHECK: ret i32 -1 60 %B = ashr i32 undef, %A ;; top %A bits must be equal, so not undef 61 ret i32 %B 62 } 63 64 define i32 @test6(i32 %A) { 65 ; CHECK: @test6 66 ; CHECK-NEXT: mul i32 %A, 6 67 ; CHECK-NEXT: ret i32 68 %B = shl i32 %A, 1 ;; convert to an mul instruction 69 %C = mul i32 %B, 3 70 ret i32 %C 71 } 72 73 define i32 @test6a(i32 %A) { 74 ; CHECK: @test6a 75 ; CHECK-NEXT: mul i32 %A, 6 76 ; CHECK-NEXT: ret i32 77 %B = mul i32 %A, 3 78 %C = shl i32 %B, 1 ;; convert to an mul instruction 79 ret i32 %C 80 } 81 82 define i32 @test7(i8 %A) { 83 ; CHECK: @test7 84 ; CHECK-NEXT: ret i32 -1 85 %shift.upgrd.3 = zext i8 %A to i32 86 %B = ashr i32 -1, %shift.upgrd.3 ;; Always equal to -1 87 ret i32 %B 88 } 89 90 ;; (A << 5) << 3 === A << 8 == 0 91 define i8 @test8(i8 %A) { 92 ; CHECK: @test8 93 ; CHECK: ret i8 0 94 %B = shl i8 %A, 5 ; <i8> [#uses=1] 95 %C = shl i8 %B, 3 ; <i8> [#uses=1] 96 ret i8 %C 97 } 98 99 ;; (A << 7) >> 7 === A & 1 100 define i8 @test9(i8 %A) { 101 ; CHECK: @test9 102 ; CHECK-NEXT: and i8 %A, 1 103 ; CHECK-NEXT: ret i8 104 %B = shl i8 %A, 7 ; <i8> [#uses=1] 105 %C = lshr i8 %B, 7 ; <i8> [#uses=1] 106 ret i8 %C 107 } 108 109 ;; This transformation is deferred to DAGCombine: 110 ;; (A >> 7) << 7 === A & 128 111 ;; The shl may be valuable to scalar evolution. 112 define i8 @test10(i8 %A) { 113 ; CHECK: @test10 114 ; CHECK-NEXT: and i8 %A, -128 115 ; CHECK-NEXT: ret i8 116 %B = lshr i8 %A, 7 ; <i8> [#uses=1] 117 %C = shl i8 %B, 7 ; <i8> [#uses=1] 118 ret i8 %C 119 } 120 121 ;; Allow the simplification when the lshr shift is exact. 122 define i8 @test10a(i8 %A) { 123 ; CHECK: @test10a 124 ; CHECK-NEXT: ret i8 %A 125 %B = lshr exact i8 %A, 7 126 %C = shl i8 %B, 7 127 ret i8 %C 128 } 129 130 ;; This transformation is deferred to DAGCombine: 131 ;; (A >> 3) << 4 === (A & 0x1F) << 1 132 ;; The shl may be valuable to scalar evolution. 133 define i8 @test11(i8 %A) { 134 ; CHECK: @test11 135 ; CHECK: shl i8 136 ; CHECK-NEXT: ret i8 137 %a = mul i8 %A, 3 ; <i8> [#uses=1] 138 %B = lshr i8 %a, 3 ; <i8> [#uses=1] 139 %C = shl i8 %B, 4 ; <i8> [#uses=1] 140 ret i8 %C 141 } 142 143 ;; Allow the simplification in InstCombine when the lshr shift is exact. 144 define i8 @test11a(i8 %A) { 145 ; CHECK: @test11a 146 ; CHECK-NEXT: mul i8 %A, 6 147 ; CHECK-NEXT: ret i8 148 %a = mul i8 %A, 3 149 %B = lshr exact i8 %a, 3 150 %C = shl i8 %B, 4 151 ret i8 %C 152 } 153 154 ;; This is deferred to DAGCombine unless %B is single-use. 155 ;; (A >> 8) << 8 === A & -256 156 define i32 @test12(i32 %A) { 157 ; CHECK: @test12 158 ; CHECK-NEXT: and i32 %A, -256 159 ; CHECK-NEXT: ret i32 160 %B = ashr i32 %A, 8 ; <i32> [#uses=1] 161 %C = shl i32 %B, 8 ; <i32> [#uses=1] 162 ret i32 %C 163 } 164 165 ;; This transformation is deferred to DAGCombine: 166 ;; (A >> 3) << 4 === (A & -8) * 2 167 ;; The shl may be valuable to scalar evolution. 168 define i8 @test13(i8 %A) { 169 ; CHECK: @test13 170 ; CHECK: shl i8 171 ; CHECK-NEXT: ret i8 172 %a = mul i8 %A, 3 ; <i8> [#uses=1] 173 %B = ashr i8 %a, 3 ; <i8> [#uses=1] 174 %C = shl i8 %B, 4 ; <i8> [#uses=1] 175 ret i8 %C 176 } 177 178 define i8 @test13a(i8 %A) { 179 ; CHECK: @test13a 180 ; CHECK-NEXT: mul i8 %A, 6 181 ; CHECK-NEXT: ret i8 182 %a = mul i8 %A, 3 183 %B = ashr exact i8 %a, 3 184 %C = shl i8 %B, 4 185 ret i8 %C 186 } 187 188 ;; D = ((B | 1234) << 4) === ((B << 4)|(1234 << 4) 189 define i32 @test14(i32 %A) { 190 ; CHECK: @test14 191 ; CHECK-NEXT: %B = and i32 %A, -19760 192 ; CHECK-NEXT: or i32 %B, 19744 193 ; CHECK-NEXT: ret i32 194 %B = lshr i32 %A, 4 ; <i32> [#uses=1] 195 %C = or i32 %B, 1234 ; <i32> [#uses=1] 196 %D = shl i32 %C, 4 ; <i32> [#uses=1] 197 ret i32 %D 198 } 199 200 ;; D = ((B | 1234) << 4) === ((B << 4)|(1234 << 4) 201 define i32 @test14a(i32 %A) { 202 ; CHECK: @test14a 203 ; CHECK-NEXT: and i32 %A, 77 204 ; CHECK-NEXT: ret i32 205 %B = shl i32 %A, 4 ; <i32> [#uses=1] 206 %C = and i32 %B, 1234 ; <i32> [#uses=1] 207 %D = lshr i32 %C, 4 ; <i32> [#uses=1] 208 ret i32 %D 209 } 210 211 define i32 @test15(i1 %C) { 212 ; CHECK: @test15 213 ; CHECK-NEXT: select i1 %C, i32 12, i32 4 214 ; CHECK-NEXT: ret i32 215 %A = select i1 %C, i32 3, i32 1 ; <i32> [#uses=1] 216 %V = shl i32 %A, 2 ; <i32> [#uses=1] 217 ret i32 %V 218 } 219 220 define i32 @test15a(i1 %C) { 221 ; CHECK: @test15a 222 ; CHECK-NEXT: select i1 %C, i32 512, i32 128 223 ; CHECK-NEXT: ret i32 224 %A = select i1 %C, i8 3, i8 1 ; <i8> [#uses=1] 225 %shift.upgrd.4 = zext i8 %A to i32 ; <i32> [#uses=1] 226 %V = shl i32 64, %shift.upgrd.4 ; <i32> [#uses=1] 227 ret i32 %V 228 } 229 230 define i1 @test16(i32 %X) { 231 ; CHECK: @test16 232 ; CHECK-NEXT: and i32 %X, 16 233 ; CHECK-NEXT: icmp ne i32 234 ; CHECK-NEXT: ret i1 235 %tmp.3 = ashr i32 %X, 4 236 %tmp.6 = and i32 %tmp.3, 1 237 %tmp.7 = icmp ne i32 %tmp.6, 0 238 ret i1 %tmp.7 239 } 240 241 define i1 @test17(i32 %A) { 242 ; CHECK: @test17 243 ; CHECK-NEXT: and i32 %A, -8 244 ; CHECK-NEXT: icmp eq i32 245 ; CHECK-NEXT: ret i1 246 %B = lshr i32 %A, 3 ; <i32> [#uses=1] 247 %C = icmp eq i32 %B, 1234 ; <i1> [#uses=1] 248 ret i1 %C 249 } 250 251 252 define i1 @test18(i8 %A) { 253 ; CHECK: @test18 254 ; CHECK: ret i1 false 255 256 %B = lshr i8 %A, 7 ; <i8> [#uses=1] 257 ;; false 258 %C = icmp eq i8 %B, 123 ; <i1> [#uses=1] 259 ret i1 %C 260 } 261 262 define i1 @test19(i32 %A) { 263 ; CHECK: @test19 264 ; CHECK-NEXT: icmp ult i32 %A, 4 265 ; CHECK-NEXT: ret i1 266 %B = ashr i32 %A, 2 ; <i32> [#uses=1] 267 ;; (X & -4) == 0 268 %C = icmp eq i32 %B, 0 ; <i1> [#uses=1] 269 ret i1 %C 270 } 271 272 273 define i1 @test19a(i32 %A) { 274 ; CHECK: @test19a 275 ; CHECK-NEXT: and i32 %A, -4 276 ; CHECK-NEXT: icmp eq i32 277 ; CHECK-NEXT: ret i1 278 %B = ashr i32 %A, 2 ; <i32> [#uses=1] 279 ;; (X & -4) == -4 280 %C = icmp eq i32 %B, -1 ; <i1> [#uses=1] 281 ret i1 %C 282 } 283 284 define i1 @test20(i8 %A) { 285 ; CHECK: @test20 286 ; CHECK: ret i1 false 287 %B = ashr i8 %A, 7 ; <i8> [#uses=1] 288 ;; false 289 %C = icmp eq i8 %B, 123 ; <i1> [#uses=1] 290 ret i1 %C 291 } 292 293 define i1 @test21(i8 %A) { 294 ; CHECK: @test21 295 ; CHECK-NEXT: and i8 %A, 15 296 ; CHECK-NEXT: icmp eq i8 297 ; CHECK-NEXT: ret i1 298 %B = shl i8 %A, 4 ; <i8> [#uses=1] 299 %C = icmp eq i8 %B, -128 ; <i1> [#uses=1] 300 ret i1 %C 301 } 302 303 define i1 @test22(i8 %A) { 304 ; CHECK: @test22 305 ; CHECK-NEXT: and i8 %A, 15 306 ; CHECK-NEXT: icmp eq i8 307 ; CHECK-NEXT: ret i1 308 %B = shl i8 %A, 4 ; <i8> [#uses=1] 309 %C = icmp eq i8 %B, 0 ; <i1> [#uses=1] 310 ret i1 %C 311 } 312 313 define i8 @test23(i32 %A) { 314 ; CHECK: @test23 315 ; CHECK-NEXT: trunc i32 %A to i8 316 ; CHECK-NEXT: ret i8 317 318 ;; casts not needed 319 %B = shl i32 %A, 24 ; <i32> [#uses=1] 320 %C = ashr i32 %B, 24 ; <i32> [#uses=1] 321 %D = trunc i32 %C to i8 ; <i8> [#uses=1] 322 ret i8 %D 323 } 324 325 define i8 @test24(i8 %X) { 326 ; CHECK: @test24 327 ; CHECK-NEXT: and i8 %X, 3 328 ; CHECK-NEXT: ret i8 329 %Y = and i8 %X, -5 ; <i8> [#uses=1] 330 %Z = shl i8 %Y, 5 ; <i8> [#uses=1] 331 %Q = ashr i8 %Z, 5 ; <i8> [#uses=1] 332 ret i8 %Q 333 } 334 335 define i32 @test25(i32 %tmp.2, i32 %AA) { 336 ; CHECK: @test25 337 ; CHECK-NEXT: and i32 %tmp.2, -131072 338 ; CHECK-NEXT: add i32 %{{[^,]*}}, %AA 339 ; CHECK-NEXT: and i32 %{{[^,]*}}, -131072 340 ; CHECK-NEXT: ret i32 341 %x = lshr i32 %AA, 17 ; <i32> [#uses=1] 342 %tmp.3 = lshr i32 %tmp.2, 17 ; <i32> [#uses=1] 343 %tmp.5 = add i32 %tmp.3, %x ; <i32> [#uses=1] 344 %tmp.6 = shl i32 %tmp.5, 17 ; <i32> [#uses=1] 345 ret i32 %tmp.6 346 } 347 348 ;; handle casts between shifts. 349 define i32 @test26(i32 %A) { 350 ; CHECK: @test26 351 ; CHECK-NEXT: and i32 %A, -2 352 ; CHECK-NEXT: ret i32 353 %B = lshr i32 %A, 1 ; <i32> [#uses=1] 354 %C = bitcast i32 %B to i32 ; <i32> [#uses=1] 355 %D = shl i32 %C, 1 ; <i32> [#uses=1] 356 ret i32 %D 357 } 358 359 360 define i1 @test27(i32 %x) nounwind { 361 ; CHECK: @test27 362 ; CHECK-NEXT: and i32 %x, 8 363 ; CHECK-NEXT: icmp ne i32 364 ; CHECK-NEXT: ret i1 365 %y = lshr i32 %x, 3 366 %z = trunc i32 %y to i1 367 ret i1 %z 368 } 369 370 define i8 @test28(i8 %x) { 371 entry: 372 ; CHECK: @test28 373 ; CHECK: icmp slt i8 %x, 0 374 ; CHECK-NEXT: br i1 375 %tmp1 = lshr i8 %x, 7 376 %cond1 = icmp ne i8 %tmp1, 0 377 br i1 %cond1, label %bb1, label %bb2 378 379 bb1: 380 ret i8 0 381 382 bb2: 383 ret i8 1 384 } 385 386 define i8 @test28a(i8 %x, i8 %y) { 387 entry: 388 ; This shouldn't be transformed. 389 ; CHECK: @test28a 390 ; CHECK: %tmp1 = lshr i8 %x, 7 391 ; CHECK: %cond1 = icmp eq i8 %tmp1, 0 392 ; CHECK: br i1 %cond1, label %bb2, label %bb1 393 %tmp1 = lshr i8 %x, 7 394 %cond1 = icmp ne i8 %tmp1, 0 395 br i1 %cond1, label %bb1, label %bb2 396 bb1: 397 ret i8 %tmp1 398 bb2: 399 %tmp2 = add i8 %tmp1, %y 400 ret i8 %tmp2 401 } 402 403 404 define i32 @test29(i64 %d18) { 405 entry: 406 %tmp916 = lshr i64 %d18, 32 407 %tmp917 = trunc i64 %tmp916 to i32 408 %tmp10 = lshr i32 %tmp917, 31 409 ret i32 %tmp10 410 ; CHECK: @test29 411 ; CHECK: %tmp916 = lshr i64 %d18, 63 412 ; CHECK: %tmp10 = trunc i64 %tmp916 to i32 413 } 414 415 416 define i32 @test30(i32 %A, i32 %B, i32 %C) { 417 %X = shl i32 %A, %C 418 %Y = shl i32 %B, %C 419 %Z = and i32 %X, %Y 420 ret i32 %Z 421 ; CHECK: @test30 422 ; CHECK: %X1 = and i32 %A, %B 423 ; CHECK: %Z = shl i32 %X1, %C 424 } 425 426 define i32 @test31(i32 %A, i32 %B, i32 %C) { 427 %X = lshr i32 %A, %C 428 %Y = lshr i32 %B, %C 429 %Z = or i32 %X, %Y 430 ret i32 %Z 431 ; CHECK: @test31 432 ; CHECK: %X1 = or i32 %A, %B 433 ; CHECK: %Z = lshr i32 %X1, %C 434 } 435 436 define i32 @test32(i32 %A, i32 %B, i32 %C) { 437 %X = ashr i32 %A, %C 438 %Y = ashr i32 %B, %C 439 %Z = xor i32 %X, %Y 440 ret i32 %Z 441 ; CHECK: @test32 442 ; CHECK: %X1 = xor i32 %A, %B 443 ; CHECK: %Z = ashr i32 %X1, %C 444 ; CHECK: ret i32 %Z 445 } 446 447 define i1 @test33(i32 %X) { 448 %tmp1 = shl i32 %X, 7 449 %tmp2 = icmp slt i32 %tmp1, 0 450 ret i1 %tmp2 451 ; CHECK: @test33 452 ; CHECK: %tmp1.mask = and i32 %X, 16777216 453 ; CHECK: %tmp2 = icmp ne i32 %tmp1.mask, 0 454 } 455 456 define i1 @test34(i32 %X) { 457 %tmp1 = lshr i32 %X, 7 458 %tmp2 = icmp slt i32 %tmp1, 0 459 ret i1 %tmp2 460 ; CHECK: @test34 461 ; CHECK: ret i1 false 462 } 463 464 define i1 @test35(i32 %X) { 465 %tmp1 = ashr i32 %X, 7 466 %tmp2 = icmp slt i32 %tmp1, 0 467 ret i1 %tmp2 468 ; CHECK: @test35 469 ; CHECK: %tmp2 = icmp slt i32 %X, 0 470 ; CHECK: ret i1 %tmp2 471 } 472 473 define i128 @test36(i128 %A, i128 %B) { 474 entry: 475 %tmp27 = shl i128 %A, 64 476 %tmp23 = shl i128 %B, 64 477 %ins = or i128 %tmp23, %tmp27 478 %tmp45 = lshr i128 %ins, 64 479 ret i128 %tmp45 480 481 ; CHECK: @test36 482 ; CHECK: %tmp231 = or i128 %B, %A 483 ; CHECK: %ins = and i128 %tmp231, 18446744073709551615 484 ; CHECK: ret i128 %ins 485 } 486 487 define i64 @test37(i128 %A, i32 %B) { 488 entry: 489 %tmp27 = shl i128 %A, 64 490 %tmp22 = zext i32 %B to i128 491 %tmp23 = shl i128 %tmp22, 96 492 %ins = or i128 %tmp23, %tmp27 493 %tmp45 = lshr i128 %ins, 64 494 %tmp46 = trunc i128 %tmp45 to i64 495 ret i64 %tmp46 496 497 ; CHECK: @test37 498 ; CHECK: %tmp23 = shl nuw nsw i128 %tmp22, 32 499 ; CHECK: %ins = or i128 %tmp23, %A 500 ; CHECK: %tmp46 = trunc i128 %ins to i64 501 } 502 503 define i32 @test38(i32 %x) nounwind readnone { 504 %rem = srem i32 %x, 32 505 %shl = shl i32 1, %rem 506 ret i32 %shl 507 ; CHECK: @test38 508 ; CHECK-NEXT: and i32 %x, 31 509 ; CHECK-NEXT: shl i32 1 510 ; CHECK-NEXT: ret i32 511 } 512 513 ; <rdar://problem/8756731> 514 ; CHECK: @test39 515 define i8 @test39(i32 %a0) { 516 entry: 517 %tmp4 = trunc i32 %a0 to i8 518 ; CHECK: and i8 %tmp49, 64 519 %tmp5 = shl i8 %tmp4, 5 520 %tmp48 = and i8 %tmp5, 32 521 %tmp49 = lshr i8 %tmp48, 5 522 %tmp50 = mul i8 %tmp49, 64 523 %tmp51 = xor i8 %tmp50, %tmp5 524 %tmp52 = and i8 %tmp51, -128 525 %tmp53 = lshr i8 %tmp52, 7 526 %tmp54 = mul i8 %tmp53, 16 527 ; CHECK: %0 = shl i8 %tmp4, 2 528 ; CHECK: %tmp54 = and i8 %0, 16 529 %tmp55 = xor i8 %tmp54, %tmp51 530 ; CHECK: ret i8 %tmp551 531 ret i8 %tmp55 532 } 533 534 ; PR9809 535 define i32 @test40(i32 %a, i32 %b) nounwind { 536 %shl1 = shl i32 1, %b 537 %shl2 = shl i32 %shl1, 2 538 %div = udiv i32 %a, %shl2 539 ret i32 %div 540 ; CHECK: @test40 541 ; CHECK-NEXT: add i32 %b, 2 542 ; CHECK-NEXT: lshr i32 %a 543 ; CHECK-NEXT: ret i32 544 } 545 546 define i32 @test41(i32 %a, i32 %b) nounwind { 547 %1 = shl i32 1, %b 548 %2 = shl i32 %1, 3 549 ret i32 %2 550 ; CHECK: @test41 551 ; CHECK-NEXT: shl i32 8, %b 552 ; CHECK-NEXT: ret i32 553 } 554 555 define i32 @test42(i32 %a, i32 %b) nounwind { 556 %div = lshr i32 4096, %b ; must be exact otherwise we'd divide by zero 557 %div2 = udiv i32 %a, %div 558 ret i32 %div2 559 ; CHECK: @test42 560 ; CHECK-NEXT: lshr exact i32 4096, %b 561 } 562 563 define i32 @test43(i32 %a, i32 %b) nounwind { 564 %div = shl i32 4096, %b ; must be exact otherwise we'd divide by zero 565 %div2 = udiv i32 %a, %div 566 ret i32 %div2 567 ; CHECK: @test43 568 ; CHECK-NEXT: add i32 %b, 12 569 ; CHECK-NEXT: lshr 570 ; CHECK-NEXT: ret 571 } 572 573 define i32 @test44(i32 %a) nounwind { 574 %y = shl nuw i32 %a, 1 575 %z = shl i32 %y, 4 576 ret i32 %z 577 ; CHECK: @test44 578 ; CHECK-NEXT: %y = shl i32 %a, 5 579 ; CHECK-NEXT: ret i32 %y 580 } 581 582 define i32 @test45(i32 %a) nounwind { 583 %y = lshr exact i32 %a, 1 584 %z = lshr i32 %y, 4 585 ret i32 %z 586 ; CHECK: @test45 587 ; CHECK-NEXT: %y = lshr i32 %a, 5 588 ; CHECK-NEXT: ret i32 %y 589 } 590 591 define i32 @test46(i32 %a) { 592 %y = ashr exact i32 %a, 3 593 %z = shl i32 %y, 1 594 ret i32 %z 595 ; CHECK: @test46 596 ; CHECK-NEXT: %z = ashr exact i32 %a, 2 597 ; CHECK-NEXT: ret i32 %z 598 } 599 600 define i32 @test47(i32 %a) { 601 %y = lshr exact i32 %a, 3 602 %z = shl i32 %y, 1 603 ret i32 %z 604 ; CHECK: @test47 605 ; CHECK-NEXT: %z = lshr exact i32 %a, 2 606 ; CHECK-NEXT: ret i32 %z 607 } 608 609 define i32 @test48(i32 %x) { 610 %A = lshr exact i32 %x, 1 611 %B = shl i32 %A, 3 612 ret i32 %B 613 ; CHECK: @test48 614 ; CHECK-NEXT: %B = shl i32 %x, 2 615 ; CHECK-NEXT: ret i32 %B 616 } 617 618 define i32 @test49(i32 %x) { 619 %A = ashr exact i32 %x, 1 620 %B = shl i32 %A, 3 621 ret i32 %B 622 ; CHECK: @test49 623 ; CHECK-NEXT: %B = shl i32 %x, 2 624 ; CHECK-NEXT: ret i32 %B 625 } 626 627 define i32 @test50(i32 %x) { 628 %A = shl nsw i32 %x, 1 629 %B = ashr i32 %A, 3 630 ret i32 %B 631 ; CHECK: @test50 632 ; CHECK-NEXT: %B = ashr i32 %x, 2 633 ; CHECK-NEXT: ret i32 %B 634 } 635 636 define i32 @test51(i32 %x) { 637 %A = shl nuw i32 %x, 1 638 %B = lshr i32 %A, 3 639 ret i32 %B 640 ; CHECK: @test51 641 ; CHECK-NEXT: %B = lshr i32 %x, 2 642 ; CHECK-NEXT: ret i32 %B 643 } 644 645 define i32 @test52(i32 %x) { 646 %A = shl nsw i32 %x, 3 647 %B = ashr i32 %A, 1 648 ret i32 %B 649 ; CHECK: @test52 650 ; CHECK-NEXT: %B = shl nsw i32 %x, 2 651 ; CHECK-NEXT: ret i32 %B 652 } 653 654 define i32 @test53(i32 %x) { 655 %A = shl nuw i32 %x, 3 656 %B = lshr i32 %A, 1 657 ret i32 %B 658 ; CHECK: @test53 659 ; CHECK-NEXT: %B = shl nuw i32 %x, 2 660 ; CHECK-NEXT: ret i32 %B 661 } 662 663 define i32 @test54(i32 %x) { 664 %shr2 = lshr i32 %x, 1 665 %shl = shl i32 %shr2, 4 666 %and = and i32 %shl, 16 667 ret i32 %and 668 ; CHECK: @test54 669 ; CHECK: shl i32 %x, 3 670 } 671 672 673 define i32 @test55(i32 %x) { 674 %shr2 = lshr i32 %x, 1 675 %shl = shl i32 %shr2, 4 676 %or = or i32 %shl, 8 677 ret i32 %or 678 ; CHECK: @test55 679 ; CHECK: shl i32 %x, 3 680 } 681 682 define i32 @test56(i32 %x) { 683 %shr2 = lshr i32 %x, 1 684 %shl = shl i32 %shr2, 4 685 %or = or i32 %shl, 7 686 ret i32 %or 687 ; CHECK: @test56 688 ; CHECK: shl i32 %shr2, 4 689 } 690 691 692 define i32 @test57(i32 %x) { 693 %shr = lshr i32 %x, 1 694 %shl = shl i32 %shr, 4 695 %and = and i32 %shl, 16 696 ret i32 %and 697 ; CHECK: @test57 698 ; CHECK: shl i32 %x, 3 699 } 700 701 define i32 @test58(i32 %x) { 702 %shr = lshr i32 %x, 1 703 %shl = shl i32 %shr, 4 704 %or = or i32 %shl, 8 705 ret i32 %or 706 ; CHECK: @test58 707 ; CHECK: shl i32 %x, 3 708 } 709 710 define i32 @test59(i32 %x) { 711 %shr = ashr i32 %x, 1 712 %shl = shl i32 %shr, 4 713 %or = or i32 %shl, 7 714 ret i32 %or 715 ; CHECK: @test59 716 ; CHECK: %shl = shl i32 %shr1, 4 717 } 718 719 720 define i32 @test60(i32 %x) { 721 %shr = ashr i32 %x, 4 722 %shl = shl i32 %shr, 1 723 %or = or i32 %shl, 1 724 ret i32 %or 725 ; CHECK: @test60 726 ; CHECK: ashr i32 %x, 3 727 } 728 729 730 define i32 @test61(i32 %x) { 731 %shr = ashr i32 %x, 4 732 %shl = shl i32 %shr, 1 733 %or = or i32 %shl, 2 734 ret i32 %or 735 ; CHECK: @test61 736 ; CHECK: ashr i32 %x, 4 737 } 738 739 ; propagate "exact" trait 740 define i32 @test62(i32 %x) { 741 %shr = ashr exact i32 %x, 4 742 %shl = shl i32 %shr, 1 743 %or = or i32 %shl, 1 744 ret i32 %or 745 ; CHECK: @test62 746 ; CHECK: ashr exact i32 %x, 3 747 } 748
