1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py 2; RUN: opt < %s -passes=instsimplify -S | FileCheck %s 3target datalayout = "p:32:32-p1:64:64" 4 5declare void @llvm.assume(i1) 6 7define i1 @ptrtoint() { 8; CHECK-LABEL: @ptrtoint( 9; CHECK-NEXT: ret i1 false 10; 11 %a = alloca i8 12 %tmp = ptrtoint ptr %a to i32 13 %r = icmp eq i32 %tmp, 0 14 ret i1 %r 15} 16 17define i1 @bitcast() { 18; CHECK-LABEL: @bitcast( 19; CHECK-NEXT: ret i1 false 20; 21 %a = alloca i32 22 %b = alloca i64 23 %cmp = icmp eq ptr %a, %b 24 ret i1 %cmp 25} 26 27define i1 @gep() { 28; CHECK-LABEL: @gep( 29; CHECK-NEXT: ret i1 false 30; 31 %a = alloca [3 x i8], align 8 32 %cmp = icmp eq ptr %a, null 33 ret i1 %cmp 34} 35 36define i1 @gep2() { 37; CHECK-LABEL: @gep2( 38; CHECK-NEXT: ret i1 true 39; 40 %a = alloca [3 x i8], align 8 41 %cmp = icmp eq ptr %a, %a 42 ret i1 %cmp 43} 44 45; PR11238 46%gept = type { i32, i32 } 47@gepy = global %gept zeroinitializer, align 8 48@gepz = extern_weak global %gept 49 50define i1 @gep3() { 51; CHECK-LABEL: @gep3( 52; CHECK-NEXT: ret i1 false 53; 54 %x = alloca %gept, align 8 55 %b = getelementptr %gept, ptr %x, i64 0, i32 1 56 %equal = icmp eq ptr %x, %b 57 ret i1 %equal 58} 59 60define i1 @gep4() { 61; CHECK-LABEL: @gep4( 62; CHECK-NEXT: ret i1 false 63; 64 %x = alloca %gept, align 8 65 %b = getelementptr %gept, ptr @gepy, i64 0, i32 1 66 %equal = icmp eq ptr @gepy, %b 67 ret i1 %equal 68} 69 70@a = common global [1 x i32] zeroinitializer, align 4 71 72define i1 @PR31262() { 73; CHECK-LABEL: @PR31262( 74; CHECK-NEXT: ret i1 true 75; 76 %idx = getelementptr inbounds [1 x i32], ptr @a, i64 0, i64 undef 77 %cmp = icmp uge ptr %idx, @a 78 ret i1 %cmp 79} 80 81define i1 @gep5() { 82; CHECK-LABEL: @gep5( 83; CHECK-NEXT: ret i1 false 84; 85 %x = alloca %gept, align 8 86 %a = getelementptr inbounds %gept, ptr %x, i64 0, i32 1 87 %equal = icmp eq ptr %a, @gepy 88 ret i1 %equal 89} 90 91define i1 @gep6(ptr %x) { 92; Same as @gep3 but potentially null. 93; CHECK-LABEL: @gep6( 94; CHECK-NEXT: ret i1 false 95; 96 %b = getelementptr %gept, ptr %x, i64 0, i32 1 97 %equal = icmp eq ptr %x, %b 98 ret i1 %equal 99} 100 101define i1 @gep7(ptr %x) { 102; CHECK-LABEL: @gep7( 103; CHECK-NEXT: [[EQUAL:%.*]] = icmp eq ptr [[X:%.*]], @gepz 104; CHECK-NEXT: ret i1 [[EQUAL]] 105; 106 %equal = icmp eq ptr %x, @gepz 107 ret i1 %equal 108} 109 110define i1 @gep8(ptr %x) { 111; CHECK-LABEL: @gep8( 112; CHECK-NEXT: [[A:%.*]] = getelementptr [[GEPT:%.*]], ptr [[X:%.*]], i32 1 113; CHECK-NEXT: [[B:%.*]] = getelementptr [[GEPT]], ptr [[X]], i32 -1 114; CHECK-NEXT: [[EQUAL:%.*]] = icmp ugt ptr [[A]], [[B]] 115; CHECK-NEXT: ret i1 [[EQUAL]] 116; 117 %a = getelementptr %gept, ptr %x, i32 1 118 %b = getelementptr %gept, ptr %x, i32 -1 119 %equal = icmp ugt ptr %a, %b 120 ret i1 %equal 121} 122 123define i1 @gep9(ptr %ptr) { 124; CHECK-LABEL: @gep9( 125; CHECK-NEXT: entry: 126; CHECK-NEXT: ret i1 true 127; 128entry: 129 %first2 = getelementptr inbounds i8, ptr %ptr, i32 1 130 %first3 = getelementptr inbounds i8, ptr %first2, i32 2 131 %first4 = getelementptr inbounds i8, ptr %first3, i32 4 132 %last1 = getelementptr inbounds i8, ptr %first2, i32 48 133 %last2 = getelementptr inbounds i8, ptr %last1, i32 8 134 %last3 = getelementptr inbounds i8, ptr %last2, i32 -4 135 %last4 = getelementptr inbounds i8, ptr %last3, i32 -4 136 %first.int = ptrtoint ptr %first4 to i32 137 %last.int = ptrtoint ptr %last4 to i32 138 %cmp = icmp ne i32 %last.int, %first.int 139 ret i1 %cmp 140} 141 142define i1 @gep10(ptr %ptr) { 143; CHECK-LABEL: @gep10( 144; CHECK-NEXT: entry: 145; CHECK-NEXT: ret i1 true 146; 147entry: 148 %first1 = getelementptr inbounds i8, ptr %ptr, i32 -2 149 %first2 = getelementptr inbounds i8, ptr %first1, i32 44 150 %last1 = getelementptr inbounds i8, ptr %ptr, i32 48 151 %last2 = getelementptr inbounds i8, ptr %last1, i32 -6 152 %first.int = ptrtoint ptr %first2 to i32 153 %last.int = ptrtoint ptr %last2 to i32 154 %cmp = icmp eq i32 %last.int, %first.int 155 ret i1 %cmp 156} 157 158define i1 @gep11(ptr %ptr) { 159; CHECK-LABEL: @gep11( 160; CHECK-NEXT: entry: 161; CHECK-NEXT: ret i1 true 162; 163entry: 164 %first1 = getelementptr inbounds i8, ptr %ptr, i32 -2 165 %last1 = getelementptr inbounds i8, ptr %ptr, i32 48 166 %last2 = getelementptr inbounds i8, ptr %last1, i32 -6 167 %cmp = icmp ult ptr %first1, %last2 168 ret i1 %cmp 169} 170 171define i1 @gep12(ptr %ptr) { 172; CHECK-LABEL: @gep12( 173; CHECK-NEXT: entry: 174; CHECK-NEXT: [[FIRST1:%.*]] = getelementptr inbounds i8, ptr [[PTR:%.*]], i32 -2 175; CHECK-NEXT: [[LAST1:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i32 48 176; CHECK-NEXT: [[LAST2:%.*]] = getelementptr inbounds i8, ptr [[LAST1]], i32 -6 177; CHECK-NEXT: [[CMP:%.*]] = icmp slt ptr [[FIRST1]], [[LAST2]] 178; CHECK-NEXT: ret i1 [[CMP]] 179; 180entry: 181 %first1 = getelementptr inbounds i8, ptr %ptr, i32 -2 182 %last1 = getelementptr inbounds i8, ptr %ptr, i32 48 183 %last2 = getelementptr inbounds i8, ptr %last1, i32 -6 184 %cmp = icmp slt ptr %first1, %last2 185 ret i1 %cmp 186} 187 188define i1 @gep13(ptr %ptr) { 189; CHECK-LABEL: @gep13( 190; CHECK-NEXT: ret i1 false 191; 192; We can prove this GEP is non-null because it is inbounds. 193 %x = getelementptr inbounds i8, ptr %ptr, i32 1 194 %cmp = icmp eq ptr %x, null 195 ret i1 %cmp 196} 197 198define i1 @gep13_no_null_opt(ptr %ptr) #0 { 199; We can't prove this GEP is non-null. 200; CHECK-LABEL: @gep13_no_null_opt( 201; CHECK-NEXT: [[X:%.*]] = getelementptr inbounds i8, ptr [[PTR:%.*]], i32 1 202; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[X]], null 203; CHECK-NEXT: ret i1 [[CMP]] 204; 205 %x = getelementptr inbounds i8, ptr %ptr, i32 1 206 %cmp = icmp eq ptr %x, null 207 ret i1 %cmp 208} 209 210define i1 @gep14(ptr %ptr) { 211; CHECK-LABEL: @gep14( 212; CHECK-NEXT: [[X:%.*]] = getelementptr inbounds { {}, i8 }, ptr [[PTR:%.*]], i32 0, i32 1 213; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[X]], null 214; CHECK-NEXT: ret i1 [[CMP]] 215; 216; We can't simplify this because the offset of one in the GEP actually doesn't 217; move the pointer. 218 %x = getelementptr inbounds { {}, i8 }, ptr %ptr, i32 0, i32 1 219 %cmp = icmp eq ptr %x, null 220 ret i1 %cmp 221} 222 223define i1 @gep15(ptr %ptr, i32 %y) { 224; CHECK-LABEL: @gep15( 225; CHECK-NEXT: ret i1 false 226; 227; We can prove this GEP is non-null even though there is a user value, as we 228; would necessarily violate inbounds on one side or the other. 229 %x = getelementptr inbounds { {}, [4 x {i8, i8}]}, ptr %ptr, i32 0, i32 1, i32 %y, i32 1 230 %cmp = icmp eq ptr %x, null 231 ret i1 %cmp 232} 233 234define i1 @gep15_no_null_opt(ptr %ptr, i32 %y) #0 { 235; We can't prove this GEP is non-null. 236; CHECK-LABEL: @gep15_no_null_opt( 237; CHECK-NEXT: [[X:%.*]] = getelementptr inbounds { {}, [4 x { i8, i8 }] }, ptr [[PTR:%.*]], i32 0, i32 1, i32 [[Y:%.*]], i32 1 238; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[X]], null 239; CHECK-NEXT: ret i1 [[CMP]] 240; 241 %x = getelementptr inbounds { {}, [4 x {i8, i8}]}, ptr %ptr, i32 0, i32 1, i32 %y, i32 1 242 %cmp = icmp eq ptr %x, null 243 ret i1 %cmp 244} 245 246define i1 @gep16(ptr %ptr, i32 %a) { 247; CHECK-LABEL: @gep16( 248; CHECK-NEXT: ret i1 false 249; 250; We can prove this GEP is non-null because it is inbounds and because we know 251; %b is non-zero even though we don't know its value. 252 %b = or i32 %a, 1 253 %x = getelementptr inbounds i8, ptr %ptr, i32 %b 254 %cmp = icmp eq ptr %x, null 255 ret i1 %cmp 256} 257 258define i1 @gep16_no_null_opt(ptr %ptr, i32 %a) #0 { 259; We can't prove this GEP is non-null. 260; CHECK-LABEL: @gep16_no_null_opt( 261; CHECK-NEXT: [[B:%.*]] = or i32 [[A:%.*]], 1 262; CHECK-NEXT: [[X:%.*]] = getelementptr inbounds i8, ptr [[PTR:%.*]], i32 [[B]] 263; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[X]], null 264; CHECK-NEXT: ret i1 [[CMP]] 265; 266 %b = or i32 %a, 1 267 %x = getelementptr inbounds i8, ptr %ptr, i32 %b 268 %cmp = icmp eq ptr %x, null 269 ret i1 %cmp 270} 271 272define i1 @gep17() { 273; CHECK-LABEL: @gep17( 274; CHECK-NEXT: ret i1 true 275; 276 %alloca = alloca i32, align 4 277 %gep1 = getelementptr inbounds i32, ptr %alloca, i32 1 278 %pti1 = ptrtoint ptr %gep1 to i32 279 %gep2 = getelementptr inbounds [4 x i8], ptr %alloca, i32 0, i32 1 280 %pti2 = ptrtoint ptr %gep2 to i32 281 %cmp = icmp ugt i32 %pti1, %pti2 282 ret i1 %cmp 283} 284 285; Negative test: GEP inbounds may cross sign boundary. 286define i1 @gep_same_base_constant_indices(ptr %a) { 287; CHECK-LABEL: @gep_same_base_constant_indices( 288; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds i8, ptr [[A:%.*]], i64 1 289; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 10 290; CHECK-NEXT: [[CMP:%.*]] = icmp slt ptr [[ARRAYIDX1]], [[ARRAYIDX2]] 291; CHECK-NEXT: ret i1 [[CMP]] 292; 293 %arrayidx1 = getelementptr inbounds i8, ptr %a, i64 1 294 %arrayidx2 = getelementptr inbounds i8, ptr %a, i64 10 295 %cmp = icmp slt ptr %arrayidx1, %arrayidx2 296 ret i1 %cmp 297} 298 299define i1 @zext(i32 %x) { 300; CHECK-LABEL: @zext( 301; CHECK-NEXT: ret i1 true 302; 303 %e1 = zext i32 %x to i64 304 %e2 = zext i32 %x to i64 305 %r = icmp eq i64 %e1, %e2 306 ret i1 %r 307} 308 309define i1 @zext2(i1 %x) { 310; CHECK-LABEL: @zext2( 311; CHECK-NEXT: ret i1 [[X:%.*]] 312; 313 %e = zext i1 %x to i32 314 %c = icmp ne i32 %e, 0 315 ret i1 %c 316} 317 318define i1 @zext3() { 319; CHECK-LABEL: @zext3( 320; CHECK-NEXT: ret i1 true 321; 322 %e = zext i1 1 to i32 323 %c = icmp ne i32 %e, 0 324 ret i1 %c 325} 326 327define i1 @sext(i32 %x) { 328; CHECK-LABEL: @sext( 329; CHECK-NEXT: ret i1 true 330; 331 %e1 = sext i32 %x to i64 332 %e2 = sext i32 %x to i64 333 %r = icmp eq i64 %e1, %e2 334 ret i1 %r 335} 336 337define i1 @sext2(i1 %x) { 338; CHECK-LABEL: @sext2( 339; CHECK-NEXT: ret i1 [[X:%.*]] 340; 341 %e = sext i1 %x to i32 342 %c = icmp ne i32 %e, 0 343 ret i1 %c 344} 345 346define i1 @sext3() { 347; CHECK-LABEL: @sext3( 348; CHECK-NEXT: ret i1 true 349; 350 %e = sext i1 1 to i32 351 %c = icmp ne i32 %e, 0 352 ret i1 %c 353} 354 355define i1 @add(i32 %x, i32 %y) { 356; CHECK-LABEL: @add( 357; CHECK-NEXT: ret i1 false 358; 359 %l = lshr i32 %x, 1 360 %q = lshr i32 %y, 1 361 %r = or i32 %q, 1 362 %s = add i32 %l, %r 363 %c = icmp eq i32 %s, 0 364 ret i1 %c 365} 366 367define i1 @addv(<2 x i32> %x, <2 x i32> %y) { 368; CHECK-LABEL: @addv( 369; CHECK-NEXT: ret i1 false 370; 371 %l = lshr <2 x i32> %x, <i32 1, i32 0> 372 %q = lshr <2 x i32> %y, <i32 1, i32 0> 373 %r = or <2 x i32> %q, <i32 1, i32 0> 374 %s = add <2 x i32> %l, %r 375 %e = extractelement <2 x i32> %s, i32 0 376 %c = icmp eq i32 %e, 0 377 ret i1 %c 378} 379 380define i1 @add2(i8 %x, i8 %y) { 381; CHECK-LABEL: @add2( 382; CHECK-NEXT: ret i1 false 383; 384 %l = or i8 %x, 128 385 %r = or i8 %y, 129 386 %s = add i8 %l, %r 387 %c = icmp eq i8 %s, 0 388 ret i1 %c 389} 390 391define i1 @add2v(<2 x i8> %x, <2 x i8> %y) { 392; CHECK-LABEL: @add2v( 393; CHECK-NEXT: ret i1 false 394; 395 %l = or <2 x i8> %x, <i8 0, i8 128> 396 %r = or <2 x i8> %y, <i8 0, i8 129> 397 %s = add <2 x i8> %l, %r 398 %e = extractelement <2 x i8> %s, i32 1 399 %c = icmp eq i8 %e, 0 400 ret i1 %c 401} 402 403define i1 @add3(i8 %x, i8 %y) { 404; CHECK-LABEL: @add3( 405; CHECK-NEXT: [[L:%.*]] = zext i8 [[X:%.*]] to i32 406; CHECK-NEXT: [[R:%.*]] = zext i8 [[Y:%.*]] to i32 407; CHECK-NEXT: [[S:%.*]] = add i32 [[L]], [[R]] 408; CHECK-NEXT: [[C:%.*]] = icmp eq i32 [[S]], 0 409; CHECK-NEXT: ret i1 [[C]] 410; 411 %l = zext i8 %x to i32 412 %r = zext i8 %y to i32 413 %s = add i32 %l, %r 414 %c = icmp eq i32 %s, 0 415 ret i1 %c 416} 417 418define i1 @add4(i32 %x, i32 %y) { 419; CHECK-LABEL: @add4( 420; CHECK-NEXT: ret i1 true 421; 422 %z = add nsw i32 %y, 1 423 %s1 = add nsw i32 %x, %y 424 %s2 = add nsw i32 %x, %z 425 %c = icmp slt i32 %s1, %s2 426 ret i1 %c 427} 428 429define i1 @add5(i32 %x, i32 %y) { 430; CHECK-LABEL: @add5( 431; CHECK-NEXT: ret i1 true 432; 433 %z = add nuw i32 %y, 1 434 %s1 = add nuw i32 %x, %z 435 %s2 = add nuw i32 %x, %y 436 %c = icmp ugt i32 %s1, %s2 437 ret i1 %c 438} 439 440define i1 @add6(i64 %A, i64 %B) { 441; CHECK-LABEL: @add6( 442; CHECK-NEXT: ret i1 true 443; 444 %s1 = add i64 %A, %B 445 %s2 = add i64 %B, %A 446 %cmp = icmp eq i64 %s1, %s2 447 ret i1 %cmp 448} 449 450define i1 @addpowtwo(i32 %x, i32 %y) { 451; CHECK-LABEL: @addpowtwo( 452; CHECK-NEXT: ret i1 false 453; 454 %l = lshr i32 %x, 1 455 %r = shl i32 1, %y 456 %s = add i32 %l, %r 457 %c = icmp eq i32 %s, 0 458 ret i1 %c 459} 460 461define i1 @addpowtwov(<2 x i32> %x, <2 x i32> %y) { 462; CHECK-LABEL: @addpowtwov( 463; CHECK-NEXT: [[L:%.*]] = lshr <2 x i32> [[X:%.*]], <i32 1, i32 0> 464; CHECK-NEXT: [[R:%.*]] = shl <2 x i32> <i32 1, i32 0>, [[Y:%.*]] 465; CHECK-NEXT: [[S:%.*]] = add <2 x i32> [[L]], [[R]] 466; CHECK-NEXT: [[E:%.*]] = extractelement <2 x i32> [[S]], i32 0 467; CHECK-NEXT: [[C:%.*]] = icmp eq i32 [[E]], 0 468; CHECK-NEXT: ret i1 [[C]] 469; 470 %l = lshr <2 x i32> %x, <i32 1, i32 0> 471 %r = shl <2 x i32> <i32 1, i32 0>, %y 472 %s = add <2 x i32> %l, %r 473 %e = extractelement <2 x i32> %s, i32 0 474 %c = icmp eq i32 %e, 0 475 ret i1 %c 476} 477 478define i1 @or(i32 %x) { 479; CHECK-LABEL: @or( 480; CHECK-NEXT: ret i1 false 481; 482 %o = or i32 %x, 1 483 %c = icmp eq i32 %o, 0 484 ret i1 %c 485} 486 487; Do not simplify if we cannot guarantee that the ConstantExpr is a non-zero 488; constant. 489@GV = common global ptr null 490define i1 @or_constexp(i32 %x) { 491; CHECK-LABEL: @or_constexp( 492; CHECK-NEXT: entry: 493; CHECK-NEXT: [[O:%.*]] = or i32 [[X:%.*]], and (i32 ptrtoint (ptr @GV to i32), i32 32) 494; CHECK-NEXT: [[C:%.*]] = icmp eq i32 [[O]], 0 495; CHECK-NEXT: ret i1 [[C]] 496; 497entry: 498 %0 = and i32 ptrtoint (ptr @GV to i32), 32 499 %o = or i32 %x, %0 500 %c = icmp eq i32 %o, 0 501 ret i1 %c 502} 503 504define i1 @shl1(i32 %x) { 505; CHECK-LABEL: @shl1( 506; CHECK-NEXT: ret i1 false 507; 508 %s = shl i32 1, %x 509 %c = icmp eq i32 %s, 0 510 ret i1 %c 511} 512 513define i1 @lshr1(i32 %x) { 514; CHECK-LABEL: @lshr1( 515; CHECK-NEXT: ret i1 false 516; 517 %s = lshr i32 -1, %x 518 %c = icmp eq i32 %s, 0 519 ret i1 %c 520} 521 522define i1 @lshr3(i32 %x) { 523; CHECK-LABEL: @lshr3( 524; CHECK-NEXT: ret i1 true 525; 526 %s = lshr i32 %x, %x 527 %c = icmp eq i32 %s, 0 528 ret i1 %c 529} 530 531define i1 @lshr4(i32 %X, i32 %Y) { 532; CHECK-LABEL: @lshr4( 533; CHECK-NEXT: ret i1 true 534; 535 %A = lshr i32 %X, %Y 536 %C = icmp ule i32 %A, %X 537 ret i1 %C 538} 539 540define i1 @lshr5(i32 %X, i32 %Y) { 541; CHECK-LABEL: @lshr5( 542; CHECK-NEXT: ret i1 false 543; 544 %A = lshr i32 %X, %Y 545 %C = icmp ugt i32 %A, %X 546 ret i1 %C 547} 548 549define i1 @lshr6(i32 %X, i32 %Y) { 550; CHECK-LABEL: @lshr6( 551; CHECK-NEXT: ret i1 false 552; 553 %A = lshr i32 %X, %Y 554 %C = icmp ult i32 %X, %A 555 ret i1 %C 556} 557 558define i1 @lshr7(i32 %X, i32 %Y) { 559; CHECK-LABEL: @lshr7( 560; CHECK-NEXT: ret i1 true 561; 562 %A = lshr i32 %X, %Y 563 %C = icmp uge i32 %X, %A 564 ret i1 %C 565} 566 567define i1 @lshr_nonzero_eq(i32 %x) { 568; CHECK-LABEL: @lshr_nonzero_eq( 569; CHECK-NEXT: [[X_NE_0:%.*]] = icmp ne i32 [[X:%.*]], 0 570; CHECK-NEXT: call void @llvm.assume(i1 [[X_NE_0]]) 571; CHECK-NEXT: ret i1 false 572; 573 %x_ne_0 = icmp ne i32 %x, 0 574 call void @llvm.assume(i1 %x_ne_0) 575 %lhs = lshr i32 %x, 1 576 %cmp = icmp eq i32 %lhs, %x 577 ret i1 %cmp 578} 579 580define i1 @lshr_nonzero_uge(i32 %x) { 581; CHECK-LABEL: @lshr_nonzero_uge( 582; CHECK-NEXT: [[X_NE_0:%.*]] = icmp ne i32 [[X:%.*]], 0 583; CHECK-NEXT: call void @llvm.assume(i1 [[X_NE_0]]) 584; CHECK-NEXT: ret i1 false 585; 586 %x_ne_0 = icmp ne i32 %x, 0 587 call void @llvm.assume(i1 %x_ne_0) 588 %lhs = lshr i32 %x, 1 589 %cmp = icmp uge i32 %lhs, %x 590 ret i1 %cmp 591} 592 593define i1 @lshr_nonzero_ne(i32 %x) { 594; CHECK-LABEL: @lshr_nonzero_ne( 595; CHECK-NEXT: [[X_NE_0:%.*]] = icmp ne i32 [[X:%.*]], 0 596; CHECK-NEXT: call void @llvm.assume(i1 [[X_NE_0]]) 597; CHECK-NEXT: ret i1 true 598; 599 %x_ne_0 = icmp ne i32 %x, 0 600 call void @llvm.assume(i1 %x_ne_0) 601 %lhs = lshr i32 %x, 1 602 %cmp = icmp ne i32 %lhs, %x 603 ret i1 %cmp 604} 605 606define i1 @lshr_nonzero_ult(i32 %x) { 607; CHECK-LABEL: @lshr_nonzero_ult( 608; CHECK-NEXT: [[X_NE_0:%.*]] = icmp ne i32 [[X:%.*]], 0 609; CHECK-NEXT: call void @llvm.assume(i1 [[X_NE_0]]) 610; CHECK-NEXT: ret i1 true 611; 612 %x_ne_0 = icmp ne i32 %x, 0 613 call void @llvm.assume(i1 %x_ne_0) 614 %lhs = lshr i32 %x, 1 615 %cmp = icmp ult i32 %lhs, %x 616 ret i1 %cmp 617} 618 619; Negative test - unknown shift amount 620define i1 @lshr_nonzero_neg_unknown(i32 %x, i32 %c) { 621; CHECK-LABEL: @lshr_nonzero_neg_unknown( 622; CHECK-NEXT: [[X_NE_0:%.*]] = icmp ne i32 [[X:%.*]], 0 623; CHECK-NEXT: call void @llvm.assume(i1 [[X_NE_0]]) 624; CHECK-NEXT: [[LHS:%.*]] = lshr i32 [[X]], [[C:%.*]] 625; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[LHS]], [[X]] 626; CHECK-NEXT: ret i1 [[CMP]] 627; 628 %x_ne_0 = icmp ne i32 %x, 0 629 call void @llvm.assume(i1 %x_ne_0) 630 %lhs = lshr i32 %x, %c 631 %cmp = icmp ult i32 %lhs, %x 632 ret i1 %cmp 633} 634 635; Negative test - x may be zero 636define i1 @lshr_nonzero_neg_maybe_zero(i32 %x) { 637; CHECK-LABEL: @lshr_nonzero_neg_maybe_zero( 638; CHECK-NEXT: [[LHS:%.*]] = lshr i32 [[X:%.*]], 1 639; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[LHS]], [[X]] 640; CHECK-NEXT: ret i1 [[CMP]] 641; 642 %lhs = lshr i32 %x, 1 643 %cmp = icmp ult i32 %lhs, %x 644 ret i1 %cmp 645} 646 647; Negative test - signed pred 648define i1 @lshr_nonzero_neg_signed(i32 %x, i32 %c) { 649; CHECK-LABEL: @lshr_nonzero_neg_signed( 650; CHECK-NEXT: [[X_NE_0:%.*]] = icmp ne i32 [[X:%.*]], 0 651; CHECK-NEXT: call void @llvm.assume(i1 [[X_NE_0]]) 652; CHECK-NEXT: [[LHS:%.*]] = lshr i32 [[X]], 1 653; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[LHS]], [[X]] 654; CHECK-NEXT: ret i1 [[CMP]] 655; 656 %x_ne_0 = icmp ne i32 %x, 0 657 call void @llvm.assume(i1 %x_ne_0) 658 %lhs = lshr i32 %x, 1 659 %cmp = icmp slt i32 %lhs, %x 660 ret i1 %cmp 661} 662 663define i1 @ashr1(i32 %x) { 664; CHECK-LABEL: @ashr1( 665; CHECK-NEXT: ret i1 false 666; 667 %s = ashr i32 -1, %x 668 %c = icmp eq i32 %s, 0 669 ret i1 %c 670} 671 672define i1 @ashr3(i32 %x) { 673; CHECK-LABEL: @ashr3( 674; CHECK-NEXT: ret i1 true 675; 676 %s = ashr i32 %x, %x 677 %c = icmp eq i32 %s, 0 678 ret i1 %c 679} 680 681define i1 @select1(i1 %cond) { 682; CHECK-LABEL: @select1( 683; CHECK-NEXT: ret i1 [[COND:%.*]] 684; 685 %s = select i1 %cond, i32 1, i32 0 686 %c = icmp eq i32 %s, 1 687 ret i1 %c 688} 689 690define i1 @select2(i1 %cond) { 691; CHECK-LABEL: @select2( 692; CHECK-NEXT: ret i1 [[COND:%.*]] 693; 694 %x = zext i1 %cond to i32 695 %s = select i1 %cond, i32 %x, i32 0 696 %c = icmp ne i32 %s, 0 697 ret i1 %c 698} 699 700define i1 @select3(i1 %cond) { 701; CHECK-LABEL: @select3( 702; CHECK-NEXT: ret i1 [[COND:%.*]] 703; 704 %x = zext i1 %cond to i32 705 %s = select i1 %cond, i32 1, i32 %x 706 %c = icmp ne i32 %s, 0 707 ret i1 %c 708} 709 710define i1 @select4(i1 %cond) { 711; CHECK-LABEL: @select4( 712; CHECK-NEXT: ret i1 [[COND:%.*]] 713; 714 %invert = xor i1 %cond, 1 715 %s = select i1 %invert, i32 0, i32 1 716 %c = icmp ne i32 %s, 0 717 ret i1 %c 718} 719 720define i1 @select5(i32 %x) { 721; CHECK-LABEL: @select5( 722; CHECK-NEXT: ret i1 false 723; 724 %c = icmp eq i32 %x, 0 725 %s = select i1 %c, i32 1, i32 %x 726 %c2 = icmp eq i32 %s, 0 727 ret i1 %c2 728} 729 730define i1 @select6(i32 %x) { 731; CHECK-LABEL: @select6( 732; CHECK-NEXT: [[C:%.*]] = icmp sgt i32 [[X:%.*]], 0 733; CHECK-NEXT: [[S:%.*]] = select i1 [[C]], i32 [[X]], i32 4 734; CHECK-NEXT: [[C2:%.*]] = icmp eq i32 [[S]], 0 735; CHECK-NEXT: ret i1 [[C2]] 736; 737 %c = icmp sgt i32 %x, 0 738 %s = select i1 %c, i32 %x, i32 4 739 %c2 = icmp eq i32 %s, 0 740 ret i1 %c2 741} 742 743define i1 @urem1(i32 %X, i32 %Y) { 744; CHECK-LABEL: @urem1( 745; CHECK-NEXT: ret i1 true 746; 747 %A = urem i32 %X, %Y 748 %B = icmp ult i32 %A, %Y 749 ret i1 %B 750} 751 752define i1 @urem2(i32 %X, i32 %Y) { 753; CHECK-LABEL: @urem2( 754; CHECK-NEXT: ret i1 false 755; 756 %A = urem i32 %X, %Y 757 %B = icmp eq i32 %A, %Y 758 ret i1 %B 759} 760 761define i1 @urem4(i32 %X) { 762; CHECK-LABEL: @urem4( 763; CHECK-NEXT: [[A:%.*]] = urem i32 [[X:%.*]], 15 764; CHECK-NEXT: [[B:%.*]] = icmp ult i32 [[A]], 10 765; CHECK-NEXT: ret i1 [[B]] 766; 767 %A = urem i32 %X, 15 768 %B = icmp ult i32 %A, 10 769 ret i1 %B 770} 771 772define i1 @urem5(i16 %X, i32 %Y) { 773; CHECK-LABEL: @urem5( 774; CHECK-NEXT: [[A:%.*]] = zext i16 [[X:%.*]] to i32 775; CHECK-NEXT: [[B:%.*]] = urem i32 [[A]], [[Y:%.*]] 776; CHECK-NEXT: [[C:%.*]] = icmp slt i32 [[B]], [[Y]] 777; CHECK-NEXT: ret i1 [[C]] 778; 779 %A = zext i16 %X to i32 780 %B = urem i32 %A, %Y 781 %C = icmp slt i32 %B, %Y 782 ret i1 %C 783} 784 785define i1 @urem6(i32 %X, i32 %Y) { 786; CHECK-LABEL: @urem6( 787; CHECK-NEXT: ret i1 true 788; 789 %A = urem i32 %X, %Y 790 %B = icmp ugt i32 %Y, %A 791 ret i1 %B 792} 793 794define i1 @urem7(i32 %X) { 795; CHECK-LABEL: @urem7( 796; CHECK-NEXT: [[A:%.*]] = urem i32 1, [[X:%.*]] 797; CHECK-NEXT: [[B:%.*]] = icmp sgt i32 [[A]], [[X]] 798; CHECK-NEXT: ret i1 [[B]] 799; 800 %A = urem i32 1, %X 801 %B = icmp sgt i32 %A, %X 802 ret i1 %B 803} 804 805define i1 @urem8(i8 %X, i8 %Y) { 806; CHECK-LABEL: @urem8( 807; CHECK-NEXT: ret i1 true 808; 809 %A = urem i8 %X, %Y 810 %B = icmp ule i8 %A, %X 811 ret i1 %B 812} 813 814define i1 @urem9(i8 %X, i8 %Y) { 815; CHECK-LABEL: @urem9( 816; CHECK-NEXT: ret i1 false 817; 818 %A = urem i8 %X, %Y 819 %B = icmp ugt i8 %A, %X 820 ret i1 %B 821} 822 823define i1 @urem10(i8 %X, i8 %Y) { 824; CHECK-LABEL: @urem10( 825; CHECK-NEXT: ret i1 true 826; 827 %A = urem i8 %X, %Y 828 %B = icmp uge i8 %X, %A 829 ret i1 %B 830} 831 832define i1 @urem11(i8 %X, i8 %Y) { 833; CHECK-LABEL: @urem11( 834; CHECK-NEXT: ret i1 false 835; 836 %A = urem i8 %X, %Y 837 %B = icmp ult i8 %X, %A 838 ret i1 %B 839} 840 841; PR9343 #15 842define i1 @srem2(i16 %X, i32 %Y) { 843; CHECK-LABEL: @srem2( 844; CHECK-NEXT: ret i1 false 845; 846 %A = zext i16 %X to i32 847 %B = add nsw i32 %A, 1 848 %C = srem i32 %B, %Y 849 %D = icmp slt i32 %C, 0 850 ret i1 %D 851} 852 853define i1 @srem2v(<2 x i16> %X, <2 x i32> %Y) { 854; CHECK-LABEL: @srem2v( 855; CHECK-NEXT: ret i1 false 856; 857 %A = zext <2 x i16> %X to <2 x i32> 858 %B = add nsw <2 x i32> %A, <i32 1, i32 0> 859 %C = srem <2 x i32> %B, %Y 860 %D = extractelement <2 x i32> %C, i32 0 861 %E = icmp slt i32 %D, 0 862 ret i1 %E 863} 864 865define i1 @srem3(i16 %X, i32 %Y) { 866; CHECK-LABEL: @srem3( 867; CHECK-NEXT: ret i1 false 868; 869 %A = zext i16 %X to i32 870 %B = or i32 2147483648, %A 871 %C = sub nsw i32 1, %B 872 %D = srem i32 %C, %Y 873 %E = icmp slt i32 %D, 0 874 ret i1 %E 875} 876 877define i1 @srem3v(<2 x i16> %X, <2 x i32> %Y) { 878; CHECK-LABEL: @srem3v( 879; CHECK-NEXT: ret i1 false 880; 881 %A = zext <2 x i16> %X to <2 x i32> 882 %B = or <2 x i32> <i32 1, i32 2147483648>, %A 883 %C = sub nsw <2 x i32> <i32 0, i32 1>, %B 884 %D = srem <2 x i32> %C, %Y 885 %E = extractelement <2 x i32> %C, i32 1 886 %F = icmp slt i32 %E, 0 887 ret i1 %F 888} 889 890define i1 @udiv2(i32 %Z) { 891; CHECK-LABEL: @udiv2( 892; CHECK-NEXT: ret i1 true 893; 894 %A = udiv exact i32 10, %Z 895 %B = udiv exact i32 20, %Z 896 %C = icmp ult i32 %A, %B 897 ret i1 %C 898} 899 900; Exact sdiv and equality preds can simplify. 901 902define i1 @sdiv_exact_equality(i32 %Z) { 903; CHECK-LABEL: @sdiv_exact_equality( 904; CHECK-NEXT: ret i1 false 905; 906 %A = sdiv exact i32 10, %Z 907 %B = sdiv exact i32 20, %Z 908 %C = icmp eq i32 %A, %B 909 ret i1 %C 910} 911 912; But not other preds: PR32949 - https://bugs.llvm.org/show_bug.cgi?id=32949 913 914define i1 @sdiv_exact_not_equality(i32 %Z) { 915; CHECK-LABEL: @sdiv_exact_not_equality( 916; CHECK-NEXT: [[A:%.*]] = sdiv exact i32 10, [[Z:%.*]] 917; CHECK-NEXT: [[B:%.*]] = sdiv exact i32 20, [[Z]] 918; CHECK-NEXT: [[C:%.*]] = icmp ult i32 [[A]], [[B]] 919; CHECK-NEXT: ret i1 [[C]] 920; 921 %A = sdiv exact i32 10, %Z 922 %B = sdiv exact i32 20, %Z 923 %C = icmp ult i32 %A, %B 924 ret i1 %C 925} 926 927define i1 @udiv3(i32 %X, i32 %Y) { 928; CHECK-LABEL: @udiv3( 929; CHECK-NEXT: ret i1 false 930; 931 %A = udiv i32 %X, %Y 932 %C = icmp ugt i32 %A, %X 933 ret i1 %C 934} 935 936define i1 @udiv4(i32 %X, i32 %Y) { 937; CHECK-LABEL: @udiv4( 938; CHECK-NEXT: ret i1 true 939; 940 %A = udiv i32 %X, %Y 941 %C = icmp ule i32 %A, %X 942 ret i1 %C 943} 944 945; PR11340 946define i1 @udiv6(i32 %X) nounwind { 947; CHECK-LABEL: @udiv6( 948; CHECK-NEXT: [[A:%.*]] = udiv i32 1, [[X:%.*]] 949; CHECK-NEXT: [[C:%.*]] = icmp eq i32 [[A]], 0 950; CHECK-NEXT: ret i1 [[C]] 951; 952 %A = udiv i32 1, %X 953 %C = icmp eq i32 %A, 0 954 ret i1 %C 955} 956 957define i1 @udiv7(i32 %X, i32 %Y) { 958; CHECK-LABEL: @udiv7( 959; CHECK-NEXT: ret i1 false 960; 961 %A = udiv i32 %X, %Y 962 %C = icmp ult i32 %X, %A 963 ret i1 %C 964} 965 966define i1 @udiv8(i32 %X, i32 %Y) { 967; CHECK-LABEL: @udiv8( 968; CHECK-NEXT: ret i1 true 969; 970 %A = udiv i32 %X, %Y 971 %C = icmp uge i32 %X, %A 972 ret i1 %C 973} 974 975define i1 @udiv_nonzero_eq(i32 %x) { 976; CHECK-LABEL: @udiv_nonzero_eq( 977; CHECK-NEXT: [[X_NE_0:%.*]] = icmp ne i32 [[X:%.*]], 0 978; CHECK-NEXT: call void @llvm.assume(i1 [[X_NE_0]]) 979; CHECK-NEXT: ret i1 false 980; 981 %x_ne_0 = icmp ne i32 %x, 0 982 call void @llvm.assume(i1 %x_ne_0) 983 %lhs = udiv i32 %x, 3 984 %cmp = icmp eq i32 %lhs, %x 985 ret i1 %cmp 986} 987 988define i1 @udiv_nonzero_uge(i32 %x) { 989; CHECK-LABEL: @udiv_nonzero_uge( 990; CHECK-NEXT: [[X_NE_0:%.*]] = icmp ne i32 [[X:%.*]], 0 991; CHECK-NEXT: call void @llvm.assume(i1 [[X_NE_0]]) 992; CHECK-NEXT: ret i1 false 993; 994 %x_ne_0 = icmp ne i32 %x, 0 995 call void @llvm.assume(i1 %x_ne_0) 996 %lhs = udiv i32 %x, 3 997 %cmp = icmp uge i32 %lhs, %x 998 ret i1 %cmp 999} 1000 1001define i1 @udiv_nonzero_ne(i32 %x) { 1002; CHECK-LABEL: @udiv_nonzero_ne( 1003; CHECK-NEXT: [[X_NE_0:%.*]] = icmp ne i32 [[X:%.*]], 0 1004; CHECK-NEXT: call void @llvm.assume(i1 [[X_NE_0]]) 1005; CHECK-NEXT: ret i1 true 1006; 1007 %x_ne_0 = icmp ne i32 %x, 0 1008 call void @llvm.assume(i1 %x_ne_0) 1009 %lhs = udiv i32 %x, 3 1010 %cmp = icmp ne i32 %lhs, %x 1011 ret i1 %cmp 1012} 1013 1014define i1 @udiv_nonzero_ult(i32 %x) { 1015; CHECK-LABEL: @udiv_nonzero_ult( 1016; CHECK-NEXT: [[X_NE_0:%.*]] = icmp ne i32 [[X:%.*]], 0 1017; CHECK-NEXT: call void @llvm.assume(i1 [[X_NE_0]]) 1018; CHECK-NEXT: ret i1 true 1019; 1020 %x_ne_0 = icmp ne i32 %x, 0 1021 call void @llvm.assume(i1 %x_ne_0) 1022 %lhs = udiv i32 %x, 3 1023 %cmp = icmp ult i32 %lhs, %x 1024 ret i1 %cmp 1025} 1026 1027; Negative test - unknown divisor 1028define i1 @udiv_nonzero_neg_unknown(i32 %x, i32 %c) { 1029; CHECK-LABEL: @udiv_nonzero_neg_unknown( 1030; CHECK-NEXT: [[X_NE_0:%.*]] = icmp ne i32 [[X:%.*]], 0 1031; CHECK-NEXT: call void @llvm.assume(i1 [[X_NE_0]]) 1032; CHECK-NEXT: [[LHS:%.*]] = udiv i32 [[X]], [[C:%.*]] 1033; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[LHS]], [[X]] 1034; CHECK-NEXT: ret i1 [[CMP]] 1035; 1036 %x_ne_0 = icmp ne i32 %x, 0 1037 call void @llvm.assume(i1 %x_ne_0) 1038 %lhs = udiv i32 %x, %c 1039 %cmp = icmp ult i32 %lhs, %x 1040 ret i1 %cmp 1041} 1042 1043; Negative test - x may be zero 1044define i1 @udiv_nonzero_neg_maybe_zero(i32 %x) { 1045; CHECK-LABEL: @udiv_nonzero_neg_maybe_zero( 1046; CHECK-NEXT: [[LHS:%.*]] = udiv i32 [[X:%.*]], 3 1047; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[LHS]], [[X]] 1048; CHECK-NEXT: ret i1 [[CMP]] 1049; 1050 %lhs = udiv i32 %x, 3 1051 %cmp = icmp ult i32 %lhs, %x 1052 ret i1 %cmp 1053} 1054 1055; Negative test - signed pred 1056define i1 @udiv_nonzero_neg_signed(i32 %x) { 1057; CHECK-LABEL: @udiv_nonzero_neg_signed( 1058; CHECK-NEXT: [[X_NE_0:%.*]] = icmp ne i32 [[X:%.*]], 0 1059; CHECK-NEXT: call void @llvm.assume(i1 [[X_NE_0]]) 1060; CHECK-NEXT: [[LHS:%.*]] = udiv i32 [[X]], 3 1061; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[LHS]], [[X]] 1062; CHECK-NEXT: ret i1 [[CMP]] 1063; 1064 %x_ne_0 = icmp ne i32 %x, 0 1065 call void @llvm.assume(i1 %x_ne_0) 1066 %lhs = udiv i32 %x, 3 1067 %cmp = icmp slt i32 %lhs, %x 1068 ret i1 %cmp 1069} 1070 1071; Square of a non-zero number is non-zero if there is no overflow. 1072define i1 @mul1(i32 %X) { 1073; CHECK-LABEL: @mul1( 1074; CHECK-NEXT: ret i1 false 1075; 1076 %Y = or i32 %X, 1 1077 %M = mul nuw i32 %Y, %Y 1078 %C = icmp eq i32 %M, 0 1079 ret i1 %C 1080} 1081 1082define i1 @mul1v(<2 x i32> %X) { 1083; CHECK-LABEL: @mul1v( 1084; CHECK-NEXT: ret i1 false 1085; 1086 %Y = or <2 x i32> %X, <i32 1, i32 0> 1087 %M = mul nuw <2 x i32> %Y, %Y 1088 %E = extractelement <2 x i32> %M, i32 0 1089 %C = icmp eq i32 %E, 0 1090 ret i1 %C 1091} 1092 1093; Square of a non-zero number is positive if there is no signed overflow. 1094define i1 @mul2(i32 %X) { 1095; CHECK-LABEL: @mul2( 1096; CHECK-NEXT: ret i1 true 1097; 1098 %Y = or i32 %X, 1 1099 %M = mul nsw i32 %Y, %Y 1100 %C = icmp sgt i32 %M, 0 1101 ret i1 %C 1102} 1103 1104define i1 @mul2v(<2 x i32> %X) { 1105; CHECK-LABEL: @mul2v( 1106; CHECK-NEXT: ret i1 true 1107; 1108 %Y = or <2 x i32> %X, <i32 0, i32 1> 1109 %M = mul nsw <2 x i32> %Y, %Y 1110 %E = extractelement <2 x i32> %M, i32 1 1111 %C = icmp sgt i32 %E, 0 1112 ret i1 %C 1113} 1114 1115; Product of non-negative numbers is non-negative if there is no signed overflow. 1116define i1 @mul3(i32 %X, i32 %Y) { 1117; CHECK-LABEL: @mul3( 1118; CHECK-NEXT: ret i1 true 1119; 1120 %XX = mul nsw i32 %X, %X 1121 %YY = mul nsw i32 %Y, %Y 1122 %M = mul nsw i32 %XX, %YY 1123 %C = icmp sge i32 %M, 0 1124 ret i1 %C 1125} 1126 1127define <2 x i1> @mul3v(<2 x i32> %X, <2 x i32> %Y) { 1128; CHECK-LABEL: @mul3v( 1129; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> 1130; 1131 %XX = mul nsw <2 x i32> %X, %X 1132 %YY = mul nsw <2 x i32> %Y, %Y 1133 %M = mul nsw <2 x i32> %XX, %YY 1134 %C = icmp sge <2 x i32> %M, zeroinitializer 1135 ret <2 x i1> %C 1136} 1137 1138define <2 x i1> @vectorselect1(<2 x i1> %cond) { 1139; CHECK-LABEL: @vectorselect1( 1140; CHECK-NEXT: ret <2 x i1> [[COND:%.*]] 1141; 1142 %invert = xor <2 x i1> %cond, <i1 1, i1 1> 1143 %s = select <2 x i1> %invert, <2 x i32> <i32 0, i32 0>, <2 x i32> <i32 1, i32 1> 1144 %c = icmp ne <2 x i32> %s, <i32 0, i32 0> 1145 ret <2 x i1> %c 1146} 1147 1148; PR11948 1149define <2 x i1> @vectorselectcrash(i32 %arg1) { 1150; CHECK-LABEL: @vectorselectcrash( 1151; CHECK-NEXT: [[TOBOOL40:%.*]] = icmp ne i32 [[ARG1:%.*]], 0 1152; CHECK-NEXT: [[COND43:%.*]] = select i1 [[TOBOOL40]], <2 x i16> <i16 -5, i16 66>, <2 x i16> <i16 46, i16 1> 1153; CHECK-NEXT: [[CMP45:%.*]] = icmp ugt <2 x i16> [[COND43]], <i16 73, i16 21> 1154; CHECK-NEXT: ret <2 x i1> [[CMP45]] 1155; 1156 %tobool40 = icmp ne i32 %arg1, 0 1157 %cond43 = select i1 %tobool40, <2 x i16> <i16 -5, i16 66>, <2 x i16> <i16 46, i16 1> 1158 %cmp45 = icmp ugt <2 x i16> %cond43, <i16 73, i16 21> 1159 ret <2 x i1> %cmp45 1160} 1161 1162; PR12013 1163define i1 @alloca_compare(i64 %idx) { 1164; CHECK-LABEL: @alloca_compare( 1165; CHECK-NEXT: ret i1 false 1166; 1167 %sv = alloca { i32, i32, [124 x i32] } 1168 %1 = getelementptr inbounds { i32, i32, [124 x i32] }, ptr %sv, i32 0, i32 2, i64 %idx 1169 %2 = icmp eq ptr %1, null 1170 ret i1 %2 1171} 1172 1173define i1 @alloca_compare_no_null_opt(i64 %idx) #0 { 1174; CHECK-LABEL: @alloca_compare_no_null_opt( 1175; CHECK-NEXT: [[SV:%.*]] = alloca { i32, i32, [124 x i32] }, align 8 1176; CHECK-NEXT: [[CMP:%.*]] = getelementptr inbounds { i32, i32, [124 x i32] }, ptr [[SV]], i32 0, i32 2, i64 [[IDX:%.*]] 1177; CHECK-NEXT: [[X:%.*]] = icmp eq ptr [[CMP]], null 1178; CHECK-NEXT: ret i1 [[X]] 1179; 1180 %sv = alloca { i32, i32, [124 x i32] } 1181 %cmp = getelementptr inbounds { i32, i32, [124 x i32] }, ptr %sv, i32 0, i32 2, i64 %idx 1182 %X = icmp eq ptr %cmp, null 1183 ret i1 %X 1184} 1185; PR12075 1186define i1 @infinite_gep() { 1187; CHECK-LABEL: @infinite_gep( 1188; CHECK-NEXT: ret i1 true 1189; CHECK: unreachableblock: 1190; CHECK-NEXT: [[X:%.*]] = getelementptr i32, ptr [[X]], i32 1 1191; CHECK-NEXT: [[Y:%.*]] = icmp eq ptr [[X]], null 1192; CHECK-NEXT: ret i1 [[Y]] 1193; 1194 ret i1 1 1195 1196unreachableblock: 1197 %X = getelementptr i32, ptr%X, i32 1 1198 %Y = icmp eq ptr %X, null 1199 ret i1 %Y 1200} 1201 1202; It's not valid to fold a comparison of an argument with an alloca, even though 1203; that's tempting. An argument can't *alias* an alloca, however the aliasing rule 1204; relies on restrictions against guessing an object's address and dereferencing. 1205; There are no restrictions against guessing an object's address and comparing. 1206 1207define i1 @alloca_argument_compare(ptr %arg) { 1208; CHECK-LABEL: @alloca_argument_compare( 1209; CHECK-NEXT: [[ALLOC:%.*]] = alloca i64, align 8 1210; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[ARG:%.*]], [[ALLOC]] 1211; CHECK-NEXT: ret i1 [[CMP]] 1212; 1213 %alloc = alloca i64 1214 %cmp = icmp eq ptr %arg, %alloc 1215 ret i1 %cmp 1216} 1217 1218; As above, but with the operands reversed. 1219 1220define i1 @alloca_argument_compare_swapped(ptr %arg) { 1221; CHECK-LABEL: @alloca_argument_compare_swapped( 1222; CHECK-NEXT: [[ALLOC:%.*]] = alloca i64, align 8 1223; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[ALLOC]], [[ARG:%.*]] 1224; CHECK-NEXT: ret i1 [[CMP]] 1225; 1226 %alloc = alloca i64 1227 %cmp = icmp eq ptr %alloc, %arg 1228 ret i1 %cmp 1229} 1230 1231; Don't assume that a noalias argument isn't equal to a global variable's 1232; address. This is an example where AliasAnalysis' NoAlias concept is 1233; different from actual pointer inequality. 1234 1235@y = external global i32 1236define zeroext i1 @external_compare(ptr noalias %x) { 1237; CHECK-LABEL: @external_compare( 1238; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[X:%.*]], @y 1239; CHECK-NEXT: ret i1 [[CMP]] 1240; 1241 %cmp = icmp eq ptr %x, @y 1242 ret i1 %cmp 1243} 1244 1245define i1 @alloca_gep(i64 %a, i64 %b) { 1246; CHECK-LABEL: @alloca_gep( 1247; CHECK-NEXT: ret i1 false 1248; 1249; We can prove this GEP is non-null because it is inbounds and the pointer 1250; is non-null. 1251 %strs = alloca [1000 x [1001 x i8]], align 16 1252 %x = getelementptr inbounds [1000 x [1001 x i8]], ptr %strs, i64 0, i64 %a, i64 %b 1253 %cmp = icmp eq ptr %x, null 1254 ret i1 %cmp 1255} 1256 1257define i1 @alloca_gep_no_null_opt(i64 %a, i64 %b) #0 { 1258; CHECK-LABEL: @alloca_gep_no_null_opt( 1259; CHECK-NEXT: [[STRS:%.*]] = alloca [1000 x [1001 x i8]], align 16 1260; CHECK-NEXT: [[X:%.*]] = getelementptr inbounds [1000 x [1001 x i8]], ptr [[STRS]], i64 0, i64 [[A:%.*]], i64 [[B:%.*]] 1261; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[X]], null 1262; CHECK-NEXT: ret i1 [[CMP]] 1263; 1264; We can't prove this GEP is non-null. 1265 %strs = alloca [1000 x [1001 x i8]], align 16 1266 %x = getelementptr inbounds [1000 x [1001 x i8]], ptr %strs, i64 0, i64 %a, i64 %b 1267 %cmp = icmp eq ptr %x, null 1268 ret i1 %cmp 1269} 1270 1271define i1 @non_inbounds_gep_compare(ptr %a) { 1272; CHECK-LABEL: @non_inbounds_gep_compare( 1273; CHECK-NEXT: ret i1 true 1274; 1275; Equality compares with non-inbounds GEPs can be folded. 1276 %x = getelementptr i64, ptr %a, i64 42 1277 %y = getelementptr inbounds i64, ptr %x, i64 -42 1278 %z = getelementptr i64, ptr %a, i64 -42 1279 %w = getelementptr inbounds i64, ptr %z, i64 42 1280 %cmp = icmp eq ptr %y, %w 1281 ret i1 %cmp 1282} 1283 1284define i1 @non_inbounds_gep_compare2(ptr %a) { 1285; CHECK-LABEL: @non_inbounds_gep_compare2( 1286; CHECK-NEXT: ret i1 true 1287; 1288; Equality compares with non-inbounds GEPs can be folded. 1289 %x = getelementptr i64, ptr %a, i64 4294967297 1290 %y = getelementptr i64, ptr %a, i64 1 1291 %cmp = icmp eq ptr %y, %y 1292 ret i1 %cmp 1293} 1294 1295define i1 @compare_always_true_slt(i16 %a) { 1296; CHECK-LABEL: @compare_always_true_slt( 1297; CHECK-NEXT: ret i1 true 1298; 1299 %t1 = zext i16 %a to i32 1300 %t2 = sub i32 0, %t1 1301 %t3 = icmp slt i32 %t2, 1 1302 ret i1 %t3 1303} 1304 1305define <2 x i1> @compare_always_true_slt_splat(<2 x i16> %a) { 1306; CHECK-LABEL: @compare_always_true_slt_splat( 1307; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> 1308; 1309 %t1 = zext <2 x i16> %a to <2 x i32> 1310 %t2 = sub <2 x i32> zeroinitializer, %t1 1311 %t3 = icmp slt <2 x i32> %t2, <i32 1, i32 1> 1312 ret <2 x i1> %t3 1313} 1314 1315define i1 @compare_always_true_sle(i16 %a) { 1316; CHECK-LABEL: @compare_always_true_sle( 1317; CHECK-NEXT: ret i1 true 1318; 1319 %t1 = zext i16 %a to i32 1320 %t2 = sub i32 0, %t1 1321 %t3 = icmp sle i32 %t2, 0 1322 ret i1 %t3 1323} 1324 1325define <2 x i1> @compare_always_true_sle_splat(<2 x i16> %a) { 1326; CHECK-LABEL: @compare_always_true_sle_splat( 1327; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> 1328; 1329 %t1 = zext <2 x i16> %a to <2 x i32> 1330 %t2 = sub <2 x i32> zeroinitializer, %t1 1331 %t3 = icmp sle <2 x i32> %t2, zeroinitializer 1332 ret <2 x i1> %t3 1333} 1334 1335define i1 @compare_always_false_sgt(i16 %a) { 1336; CHECK-LABEL: @compare_always_false_sgt( 1337; CHECK-NEXT: ret i1 false 1338; 1339 %t1 = zext i16 %a to i32 1340 %t2 = sub i32 0, %t1 1341 %t3 = icmp sgt i32 %t2, 0 1342 ret i1 %t3 1343} 1344 1345define <2 x i1> @compare_always_false_sgt_splat(<2 x i16> %a) { 1346; CHECK-LABEL: @compare_always_false_sgt_splat( 1347; CHECK-NEXT: ret <2 x i1> zeroinitializer 1348; 1349 %t1 = zext <2 x i16> %a to <2 x i32> 1350 %t2 = sub <2 x i32> zeroinitializer, %t1 1351 %t3 = icmp sgt <2 x i32> %t2, zeroinitializer 1352 ret <2 x i1> %t3 1353} 1354 1355define i1 @compare_always_false_sge(i16 %a) { 1356; CHECK-LABEL: @compare_always_false_sge( 1357; CHECK-NEXT: ret i1 false 1358; 1359 %t1 = zext i16 %a to i32 1360 %t2 = sub i32 0, %t1 1361 %t3 = icmp sge i32 %t2, 1 1362 ret i1 %t3 1363} 1364 1365define <2 x i1> @compare_always_false_sge_splat(<2 x i16> %a) { 1366; CHECK-LABEL: @compare_always_false_sge_splat( 1367; CHECK-NEXT: ret <2 x i1> zeroinitializer 1368; 1369 %t1 = zext <2 x i16> %a to <2 x i32> 1370 %t2 = sub <2 x i32> zeroinitializer, %t1 1371 %t3 = icmp sge <2 x i32> %t2, <i32 1, i32 1> 1372 ret <2 x i1> %t3 1373} 1374 1375define i1 @compare_always_false_eq(i16 %a) { 1376; CHECK-LABEL: @compare_always_false_eq( 1377; CHECK-NEXT: ret i1 false 1378; 1379 %t1 = zext i16 %a to i32 1380 %t2 = sub i32 0, %t1 1381 %t3 = icmp eq i32 %t2, 1 1382 ret i1 %t3 1383} 1384 1385define <2 x i1> @compare_always_false_eq_splat(<2 x i16> %a) { 1386; CHECK-LABEL: @compare_always_false_eq_splat( 1387; CHECK-NEXT: ret <2 x i1> zeroinitializer 1388; 1389 %t1 = zext <2 x i16> %a to <2 x i32> 1390 %t2 = sub <2 x i32> zeroinitializer, %t1 1391 %t3 = icmp eq <2 x i32> %t2, <i32 1, i32 1> 1392 ret <2 x i1> %t3 1393} 1394 1395define i1 @compare_always_true_ne(i16 %a) { 1396; CHECK-LABEL: @compare_always_true_ne( 1397; CHECK-NEXT: ret i1 true 1398; 1399 %t1 = zext i16 %a to i32 1400 %t2 = sub i32 0, %t1 1401 %t3 = icmp ne i32 %t2, 1 1402 ret i1 %t3 1403} 1404 1405define <2 x i1> @compare_always_true_ne_splat(<2 x i16> %a) { 1406; CHECK-LABEL: @compare_always_true_ne_splat( 1407; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> 1408; 1409 %t1 = zext <2 x i16> %a to <2 x i32> 1410 %t2 = sub <2 x i32> zeroinitializer, %t1 1411 %t3 = icmp ne <2 x i32> %t2, <i32 1, i32 1> 1412 ret <2 x i1> %t3 1413} 1414 1415define i1 @lshr_ugt_false(i32 %a) { 1416; CHECK-LABEL: @lshr_ugt_false( 1417; CHECK-NEXT: ret i1 false 1418; 1419 %shr = lshr i32 1, %a 1420 %cmp = icmp ugt i32 %shr, 1 1421 ret i1 %cmp 1422} 1423 1424define i1 @nonnull_arg(ptr nonnull %i) { 1425; CHECK-LABEL: @nonnull_arg( 1426; CHECK-NEXT: ret i1 false 1427; 1428 %cmp = icmp eq ptr %i, null 1429 ret i1 %cmp 1430} 1431 1432define i1 @nonnull_arg_no_null_opt(ptr nonnull %i) #0 { 1433; CHECK-LABEL: @nonnull_arg_no_null_opt( 1434; CHECK-NEXT: ret i1 false 1435; 1436 %cmp = icmp eq ptr %i, null 1437 ret i1 %cmp 1438} 1439 1440define i1 @nonnull_deref_arg(ptr dereferenceable(4) %i) { 1441; CHECK-LABEL: @nonnull_deref_arg( 1442; CHECK-NEXT: ret i1 false 1443; 1444 %cmp = icmp eq ptr %i, null 1445 ret i1 %cmp 1446} 1447 1448define i1 @nonnull_deref_arg_no_null_opt(ptr dereferenceable(4) %i) #0 { 1449; CHECK-LABEL: @nonnull_deref_arg_no_null_opt( 1450; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[I:%.*]], null 1451; CHECK-NEXT: ret i1 [[CMP]] 1452; 1453 %cmp = icmp eq ptr %i, null 1454 ret i1 %cmp 1455} 1456define i1 @nonnull_deref_as_arg(ptr addrspace(1) dereferenceable(4) %i) { 1457; CHECK-LABEL: @nonnull_deref_as_arg( 1458; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr addrspace(1) [[I:%.*]], null 1459; CHECK-NEXT: ret i1 [[CMP]] 1460; 1461 %cmp = icmp eq ptr addrspace(1) %i, null 1462 ret i1 %cmp 1463} 1464 1465declare nonnull ptr @returns_nonnull_helper() 1466define i1 @returns_nonnull() { 1467; CHECK-LABEL: @returns_nonnull( 1468; CHECK-NEXT: [[CALL:%.*]] = call nonnull ptr @returns_nonnull_helper() 1469; CHECK-NEXT: ret i1 false 1470; 1471 %call = call nonnull ptr @returns_nonnull_helper() 1472 %cmp = icmp eq ptr %call, null 1473 ret i1 %cmp 1474} 1475 1476declare dereferenceable(4) ptr @returns_nonnull_deref_helper() 1477define i1 @returns_nonnull_deref() { 1478; CHECK-LABEL: @returns_nonnull_deref( 1479; CHECK-NEXT: [[CALL:%.*]] = call dereferenceable(4) ptr @returns_nonnull_deref_helper() 1480; CHECK-NEXT: ret i1 false 1481; 1482 %call = call dereferenceable(4) ptr @returns_nonnull_deref_helper() 1483 %cmp = icmp eq ptr %call, null 1484 ret i1 %cmp 1485} 1486 1487define i1 @returns_nonnull_deref_no_null_opt () #0 { 1488; CHECK-LABEL: @returns_nonnull_deref_no_null_opt( 1489; CHECK-NEXT: [[CALL:%.*]] = call dereferenceable(4) ptr @returns_nonnull_deref_helper() 1490; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[CALL]], null 1491; CHECK-NEXT: ret i1 [[CMP]] 1492; 1493 %call = call dereferenceable(4) ptr @returns_nonnull_deref_helper() 1494 %cmp = icmp eq ptr %call, null 1495 ret i1 %cmp 1496} 1497 1498declare dereferenceable(4) ptr addrspace(1) @returns_nonnull_deref_as_helper() 1499define i1 @returns_nonnull_as_deref() { 1500; CHECK-LABEL: @returns_nonnull_as_deref( 1501; CHECK-NEXT: [[CALL:%.*]] = call dereferenceable(4) ptr addrspace(1) @returns_nonnull_deref_as_helper() 1502; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr addrspace(1) [[CALL]], null 1503; CHECK-NEXT: ret i1 [[CMP]] 1504; 1505 %call = call dereferenceable(4) ptr addrspace(1) @returns_nonnull_deref_as_helper() 1506 %cmp = icmp eq ptr addrspace(1) %call, null 1507 ret i1 %cmp 1508} 1509 1510define i1 @nonnull_load(ptr %addr) { 1511; CHECK-LABEL: @nonnull_load( 1512; CHECK-NEXT: ret i1 false 1513; 1514 %ptr = load ptr, ptr %addr, !nonnull !{} 1515 %cmp = icmp eq ptr %ptr, null 1516 ret i1 %cmp 1517} 1518 1519define i1 @nonnull_load_as_outer(ptr addrspace(1) %addr) { 1520; CHECK-LABEL: @nonnull_load_as_outer( 1521; CHECK-NEXT: ret i1 false 1522; 1523 %ptr = load ptr, ptr addrspace(1) %addr, !nonnull !{} 1524 %cmp = icmp eq ptr %ptr, null 1525 ret i1 %cmp 1526} 1527define i1 @nonnull_load_as_inner(ptr %addr) { 1528; CHECK-LABEL: @nonnull_load_as_inner( 1529; CHECK-NEXT: ret i1 false 1530; 1531 %ptr = load ptr addrspace(1), ptr %addr, !nonnull !{} 1532 %cmp = icmp eq ptr addrspace(1) %ptr, null 1533 ret i1 %cmp 1534} 1535 1536; If a bit is known to be zero for A and known to be one for B, 1537; then A and B cannot be equal. 1538define i1 @icmp_eq_const(i32 %a) { 1539; CHECK-LABEL: @icmp_eq_const( 1540; CHECK-NEXT: ret i1 false 1541; 1542 %b = mul nsw i32 %a, -2 1543 %c = icmp eq i32 %b, 1 1544 ret i1 %c 1545} 1546 1547define <2 x i1> @icmp_eq_const_vec(<2 x i32> %a) { 1548; CHECK-LABEL: @icmp_eq_const_vec( 1549; CHECK-NEXT: ret <2 x i1> zeroinitializer 1550; 1551 %b = mul nsw <2 x i32> %a, <i32 -2, i32 -2> 1552 %c = icmp eq <2 x i32> %b, <i32 1, i32 1> 1553 ret <2 x i1> %c 1554} 1555 1556define i1 @icmp_ne_const(i32 %a) { 1557; CHECK-LABEL: @icmp_ne_const( 1558; CHECK-NEXT: ret i1 true 1559; 1560 %b = mul nsw i32 %a, -2 1561 %c = icmp ne i32 %b, 1 1562 ret i1 %c 1563} 1564 1565define <2 x i1> @icmp_ne_const_vec(<2 x i32> %a) { 1566; CHECK-LABEL: @icmp_ne_const_vec( 1567; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> 1568; 1569 %b = mul nsw <2 x i32> %a, <i32 -2, i32 -2> 1570 %c = icmp ne <2 x i32> %b, <i32 1, i32 1> 1571 ret <2 x i1> %c 1572} 1573 1574define i1 @icmp_sdiv_int_min(i32 %a) { 1575; CHECK-LABEL: @icmp_sdiv_int_min( 1576; CHECK-NEXT: [[DIV:%.*]] = sdiv i32 -2147483648, [[A:%.*]] 1577; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[DIV]], -1073741824 1578; CHECK-NEXT: ret i1 [[CMP]] 1579; 1580 %div = sdiv i32 -2147483648, %a 1581 %cmp = icmp ne i32 %div, -1073741824 1582 ret i1 %cmp 1583 1584} 1585 1586define i1 @icmp_sdiv_pr20288(i64 %a) { 1587; CHECK-LABEL: @icmp_sdiv_pr20288( 1588; CHECK-NEXT: [[DIV:%.*]] = sdiv i64 [[A:%.*]], -8589934592 1589; CHECK-NEXT: [[CMP:%.*]] = icmp ne i64 [[DIV]], 1073741824 1590; CHECK-NEXT: ret i1 [[CMP]] 1591; 1592 %div = sdiv i64 %a, -8589934592 1593 %cmp = icmp ne i64 %div, 1073741824 1594 ret i1 %cmp 1595 1596} 1597 1598define i1 @icmp_sdiv_neg1(i64 %a) { 1599; CHECK-LABEL: @icmp_sdiv_neg1( 1600; CHECK-NEXT: [[DIV:%.*]] = sdiv i64 [[A:%.*]], -1 1601; CHECK-NEXT: [[CMP:%.*]] = icmp ne i64 [[DIV]], 1073741824 1602; CHECK-NEXT: ret i1 [[CMP]] 1603; 1604 %div = sdiv i64 %a, -1 1605 %cmp = icmp ne i64 %div, 1073741824 1606 ret i1 %cmp 1607 1608} 1609 1610define i1 @icmp_known_bits(i4 %x, i4 %y) { 1611; CHECK-LABEL: @icmp_known_bits( 1612; CHECK-NEXT: ret i1 false 1613; 1614 %and1 = and i4 %y, -7 1615 %and2 = and i4 %x, -7 1616 %or1 = or i4 %and1, 2 1617 %or2 = or i4 %and2, 2 1618 %add = add i4 %or1, %or2 1619 %cmp = icmp eq i4 %add, 0 1620 ret i1 %cmp 1621} 1622 1623define i1 @icmp_known_bits_vec(<2 x i4> %x, <2 x i4> %y) { 1624; CHECK-LABEL: @icmp_known_bits_vec( 1625; CHECK-NEXT: ret i1 false 1626; 1627 %and1 = and <2 x i4> %y, <i4 -7, i4 -1> 1628 %and2 = and <2 x i4> %x, <i4 -7, i4 -1> 1629 %or1 = or <2 x i4> %and1, <i4 2, i4 2> 1630 %or2 = or <2 x i4> %and2, <i4 2, i4 2> 1631 %add = add <2 x i4> %or1, %or2 1632 %ext = extractelement <2 x i4> %add,i32 0 1633 %cmp = icmp eq i4 %ext, 0 1634 ret i1 %cmp 1635} 1636 1637define i1 @icmp_shl_nuw_1(i64 %a) { 1638; CHECK-LABEL: @icmp_shl_nuw_1( 1639; CHECK-NEXT: ret i1 true 1640; 1641 %shl = shl nuw i64 1, %a 1642 %cmp = icmp ne i64 %shl, 0 1643 ret i1 %cmp 1644} 1645 1646define i1 @icmp_shl_1_V_ugt_2147483648(i32 %V) { 1647; CHECK-LABEL: @icmp_shl_1_V_ugt_2147483648( 1648; CHECK-NEXT: ret i1 false 1649; 1650 %shl = shl i32 1, %V 1651 %cmp = icmp ugt i32 %shl, 2147483648 1652 ret i1 %cmp 1653} 1654 1655define <2 x i1> @icmp_shl_1_ugt_signmask(<2 x i8> %V) { 1656; CHECK-LABEL: @icmp_shl_1_ugt_signmask( 1657; CHECK-NEXT: ret <2 x i1> zeroinitializer 1658; 1659 %shl = shl <2 x i8> <i8 1, i8 1>, %V 1660 %cmp = icmp ugt <2 x i8> %shl, <i8 128, i8 128> 1661 ret <2 x i1> %cmp 1662} 1663 1664define <2 x i1> @icmp_shl_1_ugt_signmask_undef(<2 x i8> %V) { 1665; CHECK-LABEL: @icmp_shl_1_ugt_signmask_undef( 1666; CHECK-NEXT: ret <2 x i1> zeroinitializer 1667; 1668 %shl = shl <2 x i8> <i8 1, i8 1>, %V 1669 %cmp = icmp ugt <2 x i8> %shl, <i8 128, i8 undef> 1670 ret <2 x i1> %cmp 1671} 1672 1673define <2 x i1> @icmp_shl_1_ugt_signmask_undef2(<2 x i8> %V) { 1674; CHECK-LABEL: @icmp_shl_1_ugt_signmask_undef2( 1675; CHECK-NEXT: ret <2 x i1> zeroinitializer 1676; 1677 %shl = shl <2 x i8> <i8 1, i8 undef>, %V 1678 %cmp = icmp ugt <2 x i8> %shl, <i8 undef, i8 128> 1679 ret <2 x i1> %cmp 1680} 1681 1682define i1 @icmp_shl_1_V_ule_2147483648(i32 %V) { 1683; CHECK-LABEL: @icmp_shl_1_V_ule_2147483648( 1684; CHECK-NEXT: ret i1 true 1685; 1686 %shl = shl i32 1, %V 1687 %cmp = icmp ule i32 %shl, 2147483648 1688 ret i1 %cmp 1689} 1690 1691define <2 x i1> @icmp_shl_1_ule_signmask(<2 x i8> %V) { 1692; CHECK-LABEL: @icmp_shl_1_ule_signmask( 1693; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> 1694; 1695 %shl = shl <2 x i8> <i8 1, i8 1>, %V 1696 %cmp = icmp ule <2 x i8> %shl, <i8 128, i8 128> 1697 ret <2 x i1> %cmp 1698} 1699 1700define <2 x i1> @icmp_shl_1_ule_signmask_undef(<2 x i8> %V) { 1701; CHECK-LABEL: @icmp_shl_1_ule_signmask_undef( 1702; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> 1703; 1704 %shl = shl <2 x i8> <i8 1, i8 1>, %V 1705 %cmp = icmp ule <2 x i8> %shl, <i8 128, i8 undef> 1706 ret <2 x i1> %cmp 1707} 1708 1709define <2 x i1> @icmp_shl_1_ule_signmask_undef2(<2 x i8> %V) { 1710; CHECK-LABEL: @icmp_shl_1_ule_signmask_undef2( 1711; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> 1712; 1713 %shl = shl <2 x i8> <i8 1, i8 undef>, %V 1714 %cmp = icmp ule <2 x i8> %shl, <i8 undef, i8 128> 1715 ret <2 x i1> %cmp 1716} 1717 1718define i1 @shl_1_cmp_eq_nonpow2(i32 %x) { 1719; CHECK-LABEL: @shl_1_cmp_eq_nonpow2( 1720; CHECK-NEXT: ret i1 false 1721; 1722 %s = shl i32 1, %x 1723 %c = icmp eq i32 %s, 31 1724 ret i1 %c 1725} 1726 1727define <2 x i1> @shl_1_cmp_eq_nonpow2_splat(<2 x i32> %x) { 1728; CHECK-LABEL: @shl_1_cmp_eq_nonpow2_splat( 1729; CHECK-NEXT: ret <2 x i1> zeroinitializer 1730; 1731 %s = shl <2 x i32> <i32 1, i32 1>, %x 1732 %c = icmp eq <2 x i32> %s, <i32 31, i32 31> 1733 ret <2 x i1> %c 1734} 1735 1736define <2 x i1> @shl_1_cmp_eq_nonpow2_splat_undef(<2 x i32> %x) { 1737; CHECK-LABEL: @shl_1_cmp_eq_nonpow2_splat_undef( 1738; CHECK-NEXT: ret <2 x i1> zeroinitializer 1739; 1740 %s = shl <2 x i32> <i32 1, i32 1>, %x 1741 %c = icmp eq <2 x i32> %s, <i32 31, i32 undef> 1742 ret <2 x i1> %c 1743} 1744 1745define i1 @shl_1_cmp_ne_nonpow2(i32 %x) { 1746; CHECK-LABEL: @shl_1_cmp_ne_nonpow2( 1747; CHECK-NEXT: ret i1 true 1748; 1749 %s = shl i32 1, %x 1750 %c = icmp ne i32 %s, 42 1751 ret i1 %c 1752} 1753 1754define <2 x i1> @shl_1_cmp_ne_nonpow2_splat(<2 x i32> %x) { 1755; CHECK-LABEL: @shl_1_cmp_ne_nonpow2_splat( 1756; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> 1757; 1758 %s = shl <2 x i32> <i32 1, i32 1>, %x 1759 %c = icmp ne <2 x i32> %s, <i32 42, i32 42> 1760 ret <2 x i1> %c 1761} 1762 1763define <2 x i1> @shl_1_cmp_ne_nonpow2_splat_undef(<2 x i32> %x) { 1764; CHECK-LABEL: @shl_1_cmp_ne_nonpow2_splat_undef( 1765; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> 1766; 1767 %s = shl <2 x i32> <i32 undef, i32 1>, %x 1768 %c = icmp ne <2 x i32> %s, <i32 42, i32 undef> 1769 ret <2 x i1> %c 1770} 1771 1772define i1 @shl_pow2_cmp_eq_nonpow2(i32 %x) { 1773; CHECK-LABEL: @shl_pow2_cmp_eq_nonpow2( 1774; CHECK-NEXT: ret i1 false 1775; 1776 %s = shl i32 4, %x 1777 %c = icmp eq i32 %s, 31 1778 ret i1 %c 1779} 1780 1781define <2 x i1> @shl_pow21_cmp_ne_nonpow2_splat_undef(<2 x i32> %x) { 1782; CHECK-LABEL: @shl_pow21_cmp_ne_nonpow2_splat_undef( 1783; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> 1784; 1785 %s = shl <2 x i32> <i32 undef, i32 4>, %x 1786 %c = icmp ne <2 x i32> %s, <i32 31, i32 undef> 1787 ret <2 x i1> %c 1788} 1789 1790; Negative test - overflowing shift could be zero. 1791 1792define i1 @shl_pow2_cmp_ne_zero(i32 %x) { 1793; CHECK-LABEL: @shl_pow2_cmp_ne_zero( 1794; CHECK-NEXT: [[S:%.*]] = shl i32 16, [[X:%.*]] 1795; CHECK-NEXT: [[C:%.*]] = icmp ne i32 [[S]], 0 1796; CHECK-NEXT: ret i1 [[C]] 1797; 1798 %s = shl i32 16, %x 1799 %c = icmp ne i32 %s, 0 1800 ret i1 %c 1801} 1802 1803; Negative test - overflowing shift could be zero. 1804 1805define <2 x i1> @shl_pow2_cmp_ne_zero_splat(<2 x i32> %x) { 1806; CHECK-LABEL: @shl_pow2_cmp_ne_zero_splat( 1807; CHECK-NEXT: [[S:%.*]] = shl <2 x i32> <i32 16, i32 16>, [[X:%.*]] 1808; CHECK-NEXT: [[C:%.*]] = icmp ne <2 x i32> [[S]], zeroinitializer 1809; CHECK-NEXT: ret <2 x i1> [[C]] 1810; 1811 %s = shl <2 x i32> <i32 16, i32 16>, %x 1812 %c = icmp ne <2 x i32> %s, zeroinitializer 1813 ret <2 x i1> %c 1814} 1815 1816define i1 @shl_pow2_cmp_eq_zero_nuw(i32 %x) { 1817; CHECK-LABEL: @shl_pow2_cmp_eq_zero_nuw( 1818; CHECK-NEXT: ret i1 false 1819; 1820 %s = shl nuw i32 16, %x 1821 %c = icmp eq i32 %s, 0 1822 ret i1 %c 1823} 1824 1825define <2 x i1> @shl_pow2_cmp_ne_zero_nuw_splat_undef(<2 x i32> %x) { 1826; CHECK-LABEL: @shl_pow2_cmp_ne_zero_nuw_splat_undef( 1827; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> 1828; 1829 %s = shl nuw <2 x i32> <i32 16, i32 undef>, %x 1830 %c = icmp ne <2 x i32> %s, <i32 undef, i32 0> 1831 ret <2 x i1> %c 1832} 1833 1834define i1 @shl_pow2_cmp_ne_zero_nsw(i32 %x) { 1835; CHECK-LABEL: @shl_pow2_cmp_ne_zero_nsw( 1836; CHECK-NEXT: ret i1 true 1837; 1838 %s = shl nsw i32 16, %x 1839 %c = icmp ne i32 %s, 0 1840 ret i1 %c 1841} 1842 1843define <2 x i1> @shl_pow2_cmp_eq_zero_nsw_splat_undef(<2 x i32> %x) { 1844; CHECK-LABEL: @shl_pow2_cmp_eq_zero_nsw_splat_undef( 1845; CHECK-NEXT: ret <2 x i1> zeroinitializer 1846; 1847 %s = shl nsw <2 x i32> <i32 undef, i32 16>, %x 1848 %c = icmp eq <2 x i32> %s, <i32 0, i32 undef> 1849 ret <2 x i1> %c 1850} 1851 1852define i1 @tautological1(i32 %A, i32 %B) { 1853; CHECK-LABEL: @tautological1( 1854; CHECK-NEXT: ret i1 false 1855; 1856 %C = and i32 %A, %B 1857 %D = icmp ugt i32 %C, %A 1858 ret i1 %D 1859} 1860 1861define i1 @tautological2(i32 %A, i32 %B) { 1862; CHECK-LABEL: @tautological2( 1863; CHECK-NEXT: ret i1 true 1864; 1865 %C = and i32 %A, %B 1866 %D = icmp ule i32 %C, %A 1867 ret i1 %D 1868} 1869 1870define i1 @tautological3(i32 %A, i32 %B) { 1871; CHECK-LABEL: @tautological3( 1872; CHECK-NEXT: ret i1 true 1873; 1874 %C = or i32 %A, %B 1875 %D = icmp ule i32 %A, %C 1876 ret i1 %D 1877} 1878 1879define i1 @tautological4(i32 %A, i32 %B) { 1880; CHECK-LABEL: @tautological4( 1881; CHECK-NEXT: ret i1 false 1882; 1883 %C = or i32 %A, %B 1884 %D = icmp ugt i32 %A, %C 1885 ret i1 %D 1886} 1887 1888define i1 @tautological5(i32 %A, i32 %B) { 1889; CHECK-LABEL: @tautological5( 1890; CHECK-NEXT: ret i1 false 1891; 1892 %C = or i32 %A, %B 1893 %D = icmp ult i32 %C, %A 1894 ret i1 %D 1895} 1896 1897define i1 @tautological6(i32 %A, i32 %B) { 1898; CHECK-LABEL: @tautological6( 1899; CHECK-NEXT: ret i1 true 1900; 1901 %C = or i32 %A, %B 1902 %D = icmp uge i32 %C, %A 1903 ret i1 %D 1904} 1905 1906define i1 @tautological7(i32 %A, i32 %B) { 1907; CHECK-LABEL: @tautological7( 1908; CHECK-NEXT: ret i1 true 1909; 1910 %C = and i32 %A, %B 1911 %D = icmp uge i32 %A, %C 1912 ret i1 %D 1913} 1914 1915define i1 @tautological8(i32 %A, i32 %B) { 1916; CHECK-LABEL: @tautological8( 1917; CHECK-NEXT: ret i1 false 1918; 1919 %C = and i32 %A, %B 1920 %D = icmp ult i32 %A, %C 1921 ret i1 %D 1922} 1923 1924declare void @helper_i1(i1) 1925; Series of tests for icmp s[lt|ge] (or A, B), A and icmp s[gt|le] A, (or A, B) 1926define void @icmp_slt_sge_or(i32 %Ax, i32 %Bx) { 1927; 'p' for positive, 'n' for negative, 'x' for potentially either. 1928; %D is 'icmp slt (or A, B), A' 1929; %E is 'icmp sge (or A, B), A' making it the not of %D 1930; %F is 'icmp sgt A, (or A, B)' making it the same as %D 1931; %G is 'icmp sle A, (or A, B)' making it the not of %D 1932; CHECK-LABEL: @icmp_slt_sge_or( 1933; CHECK-NEXT: [[APOS:%.*]] = and i32 [[AX:%.*]], 2147483647 1934; CHECK-NEXT: [[BNEG:%.*]] = or i32 [[BX:%.*]], -2147483648 1935; CHECK-NEXT: [[CPX:%.*]] = or i32 [[APOS]], [[BX]] 1936; CHECK-NEXT: [[DPX:%.*]] = icmp slt i32 [[CPX]], [[APOS]] 1937; CHECK-NEXT: [[EPX:%.*]] = icmp sge i32 [[CPX]], [[APOS]] 1938; CHECK-NEXT: [[FPX:%.*]] = icmp sgt i32 [[APOS]], [[CPX]] 1939; CHECK-NEXT: [[GPX:%.*]] = icmp sle i32 [[APOS]], [[CPX]] 1940; CHECK-NEXT: [[CXX:%.*]] = or i32 [[AX]], [[BX]] 1941; CHECK-NEXT: [[DXX:%.*]] = icmp slt i32 [[CXX]], [[AX]] 1942; CHECK-NEXT: [[EXX:%.*]] = icmp sge i32 [[CXX]], [[AX]] 1943; CHECK-NEXT: [[FXX:%.*]] = icmp sgt i32 [[AX]], [[CXX]] 1944; CHECK-NEXT: [[GXX:%.*]] = icmp sle i32 [[AX]], [[CXX]] 1945; CHECK-NEXT: [[CXN:%.*]] = or i32 [[AX]], [[BNEG]] 1946; CHECK-NEXT: [[DXN:%.*]] = icmp slt i32 [[CXN]], [[AX]] 1947; CHECK-NEXT: [[EXN:%.*]] = icmp sge i32 [[CXN]], [[AX]] 1948; CHECK-NEXT: [[FXN:%.*]] = icmp sgt i32 [[AX]], [[CXN]] 1949; CHECK-NEXT: [[GXN:%.*]] = icmp sle i32 [[AX]], [[CXN]] 1950; CHECK-NEXT: call void @helper_i1(i1 false) 1951; CHECK-NEXT: call void @helper_i1(i1 true) 1952; CHECK-NEXT: call void @helper_i1(i1 false) 1953; CHECK-NEXT: call void @helper_i1(i1 true) 1954; CHECK-NEXT: call void @helper_i1(i1 [[DPX]]) 1955; CHECK-NEXT: call void @helper_i1(i1 [[EPX]]) 1956; CHECK-NEXT: call void @helper_i1(i1 [[FPX]]) 1957; CHECK-NEXT: call void @helper_i1(i1 [[GPX]]) 1958; CHECK-NEXT: call void @helper_i1(i1 true) 1959; CHECK-NEXT: call void @helper_i1(i1 false) 1960; CHECK-NEXT: call void @helper_i1(i1 true) 1961; CHECK-NEXT: call void @helper_i1(i1 false) 1962; CHECK-NEXT: call void @helper_i1(i1 false) 1963; CHECK-NEXT: call void @helper_i1(i1 true) 1964; CHECK-NEXT: call void @helper_i1(i1 false) 1965; CHECK-NEXT: call void @helper_i1(i1 true) 1966; CHECK-NEXT: call void @helper_i1(i1 [[DXX]]) 1967; CHECK-NEXT: call void @helper_i1(i1 [[EXX]]) 1968; CHECK-NEXT: call void @helper_i1(i1 [[FXX]]) 1969; CHECK-NEXT: call void @helper_i1(i1 [[GXX]]) 1970; CHECK-NEXT: call void @helper_i1(i1 [[DXN]]) 1971; CHECK-NEXT: call void @helper_i1(i1 [[EXN]]) 1972; CHECK-NEXT: call void @helper_i1(i1 [[FXN]]) 1973; CHECK-NEXT: call void @helper_i1(i1 [[GXN]]) 1974; CHECK-NEXT: call void @helper_i1(i1 false) 1975; CHECK-NEXT: call void @helper_i1(i1 true) 1976; CHECK-NEXT: call void @helper_i1(i1 false) 1977; CHECK-NEXT: call void @helper_i1(i1 true) 1978; CHECK-NEXT: call void @helper_i1(i1 false) 1979; CHECK-NEXT: call void @helper_i1(i1 true) 1980; CHECK-NEXT: call void @helper_i1(i1 false) 1981; CHECK-NEXT: call void @helper_i1(i1 true) 1982; CHECK-NEXT: call void @helper_i1(i1 false) 1983; CHECK-NEXT: call void @helper_i1(i1 true) 1984; CHECK-NEXT: call void @helper_i1(i1 false) 1985; CHECK-NEXT: call void @helper_i1(i1 true) 1986; CHECK-NEXT: ret void 1987; 1988 %Aneg = or i32 %Ax, 2147483648 1989 %Apos = and i32 %Ax, 2147483647 1990 %Bneg = or i32 %Bx, 2147483648 1991 %Bpos = and i32 %Bx, 2147483647 1992 1993 %Cpp = or i32 %Apos, %Bpos 1994 %Dpp = icmp slt i32 %Cpp, %Apos 1995 %Epp = icmp sge i32 %Cpp, %Apos 1996 %Fpp = icmp sgt i32 %Apos, %Cpp 1997 %Gpp = icmp sle i32 %Apos, %Cpp 1998 %Cpx = or i32 %Apos, %Bx 1999 %Dpx = icmp slt i32 %Cpx, %Apos 2000 %Epx = icmp sge i32 %Cpx, %Apos 2001 %Fpx = icmp sgt i32 %Apos, %Cpx 2002 %Gpx = icmp sle i32 %Apos, %Cpx 2003 %Cpn = or i32 %Apos, %Bneg 2004 %Dpn = icmp slt i32 %Cpn, %Apos 2005 %Epn = icmp sge i32 %Cpn, %Apos 2006 %Fpn = icmp sgt i32 %Apos, %Cpn 2007 %Gpn = icmp sle i32 %Apos, %Cpn 2008 2009 %Cxp = or i32 %Ax, %Bpos 2010 %Dxp = icmp slt i32 %Cxp, %Ax 2011 %Exp = icmp sge i32 %Cxp, %Ax 2012 %Fxp = icmp sgt i32 %Ax, %Cxp 2013 %Gxp = icmp sle i32 %Ax, %Cxp 2014 %Cxx = or i32 %Ax, %Bx 2015 %Dxx = icmp slt i32 %Cxx, %Ax 2016 %Exx = icmp sge i32 %Cxx, %Ax 2017 %Fxx = icmp sgt i32 %Ax, %Cxx 2018 %Gxx = icmp sle i32 %Ax, %Cxx 2019 %Cxn = or i32 %Ax, %Bneg 2020 %Dxn = icmp slt i32 %Cxn, %Ax 2021 %Exn = icmp sge i32 %Cxn, %Ax 2022 %Fxn = icmp sgt i32 %Ax, %Cxn 2023 %Gxn = icmp sle i32 %Ax, %Cxn 2024 2025 %Cnp = or i32 %Aneg, %Bpos 2026 %Dnp = icmp slt i32 %Cnp, %Aneg 2027 %Enp = icmp sge i32 %Cnp, %Aneg 2028 %Fnp = icmp sgt i32 %Aneg, %Cnp 2029 %Gnp = icmp sle i32 %Aneg, %Cnp 2030 %Cnx = or i32 %Aneg, %Bx 2031 %Dnx = icmp slt i32 %Cnx, %Aneg 2032 %Enx = icmp sge i32 %Cnx, %Aneg 2033 %Fnx = icmp sgt i32 %Aneg, %Cnx 2034 %Gnx = icmp sle i32 %Aneg, %Cnx 2035 %Cnn = or i32 %Aneg, %Bneg 2036 %Dnn = icmp slt i32 %Cnn, %Aneg 2037 %Enn = icmp sge i32 %Cnn, %Aneg 2038 %Fnn = icmp sgt i32 %Aneg, %Cnn 2039 %Gnn = icmp sle i32 %Aneg, %Cnn 2040 2041 call void @helper_i1(i1 %Dpp) 2042 call void @helper_i1(i1 %Epp) 2043 call void @helper_i1(i1 %Fpp) 2044 call void @helper_i1(i1 %Gpp) 2045 call void @helper_i1(i1 %Dpx) 2046 call void @helper_i1(i1 %Epx) 2047 call void @helper_i1(i1 %Fpx) 2048 call void @helper_i1(i1 %Gpx) 2049 call void @helper_i1(i1 %Dpn) 2050 call void @helper_i1(i1 %Epn) 2051 call void @helper_i1(i1 %Fpn) 2052 call void @helper_i1(i1 %Gpn) 2053 call void @helper_i1(i1 %Dxp) 2054 call void @helper_i1(i1 %Exp) 2055 call void @helper_i1(i1 %Fxp) 2056 call void @helper_i1(i1 %Gxp) 2057 call void @helper_i1(i1 %Dxx) 2058 call void @helper_i1(i1 %Exx) 2059 call void @helper_i1(i1 %Fxx) 2060 call void @helper_i1(i1 %Gxx) 2061 call void @helper_i1(i1 %Dxn) 2062 call void @helper_i1(i1 %Exn) 2063 call void @helper_i1(i1 %Fxn) 2064 call void @helper_i1(i1 %Gxn) 2065 call void @helper_i1(i1 %Dnp) 2066 call void @helper_i1(i1 %Enp) 2067 call void @helper_i1(i1 %Fnp) 2068 call void @helper_i1(i1 %Gnp) 2069 call void @helper_i1(i1 %Dnx) 2070 call void @helper_i1(i1 %Enx) 2071 call void @helper_i1(i1 %Fnx) 2072 call void @helper_i1(i1 %Gnx) 2073 call void @helper_i1(i1 %Dnn) 2074 call void @helper_i1(i1 %Enn) 2075 call void @helper_i1(i1 %Fnn) 2076 call void @helper_i1(i1 %Gnn) 2077 ret void 2078} 2079 2080define i1 @constant_fold_inttoptr_null() { 2081; CHECK-LABEL: @constant_fold_inttoptr_null( 2082; CHECK-NEXT: ret i1 false 2083; 2084 %x = icmp eq ptr inttoptr (i64 32 to ptr), null 2085 ret i1 %x 2086} 2087 2088define i1 @constant_fold_null_inttoptr() { 2089; CHECK-LABEL: @constant_fold_null_inttoptr( 2090; CHECK-NEXT: ret i1 false 2091; 2092 %x = icmp eq ptr null, inttoptr (i64 32 to ptr) 2093 ret i1 %x 2094} 2095 2096define i1 @cmp_through_addrspacecast(ptr addrspace(1) %p1) { 2097; CHECK-LABEL: @cmp_through_addrspacecast( 2098; CHECK-NEXT: ret i1 true 2099; 2100 %p0 = addrspacecast ptr addrspace(1) %p1 to ptr 2101 %p0.1 = getelementptr inbounds i32, ptr %p0, i64 1 2102 %cmp = icmp ne ptr %p0, %p0.1 2103 ret i1 %cmp 2104} 2105 2106; Test simplifications for: icmp (X+Y), (X+Z) -> icmp Y,Z 2107; Test the overflow check when the RHS has NSW set and constant Z is greater 2108; than Y, then we know X+Y also can't overflow. 2109 2110define i1 @icmp_nsw_1(i32 %V) { 2111; CHECK-LABEL: @icmp_nsw_1( 2112; CHECK-NEXT: ret i1 true 2113; 2114 %add5 = add i32 %V, 5 2115 %add6 = add nsw i32 %V, 6 2116 %s1 = sext i32 %add5 to i64 2117 %s2 = sext i32 %add6 to i64 2118 %cmp = icmp slt i64 %s1, %s2 2119 ret i1 %cmp 2120} 2121 2122define i1 @icmp_nsw_2(i32 %V) { 2123; CHECK-LABEL: @icmp_nsw_2( 2124; CHECK-NEXT: ret i1 true 2125; 2126 %add5 = add i32 %V, 5 2127 %add6 = add nsw i32 %V, 6 2128 %cmp = icmp slt i32 %add5, %add6 2129 ret i1 %cmp 2130} 2131 2132define i1 @icmp_nsw_commute(i32 %V) { 2133; CHECK-LABEL: @icmp_nsw_commute( 2134; CHECK-NEXT: ret i1 true 2135; 2136 %add5 = add i32 5, %V 2137 %add6 = add nsw i32 %V, 6 2138 %cmp = icmp slt i32 %add5, %add6 2139 ret i1 %cmp 2140} 2141 2142define i1 @icmp_nsw_commute2(i32 %V) { 2143; CHECK-LABEL: @icmp_nsw_commute2( 2144; CHECK-NEXT: ret i1 true 2145; 2146 %add5 = add i32 %V, 5 2147 %add6 = add nsw i32 6, %V 2148 %cmp = icmp slt i32 %add5, %add6 2149 ret i1 %cmp 2150} 2151 2152define i1 @icmp_nsw_commute3(i32 %V) { 2153; CHECK-LABEL: @icmp_nsw_commute3( 2154; CHECK-NEXT: ret i1 true 2155; 2156 %add5 = add i32 5, %V 2157 %add6 = add nsw i32 6, %V 2158 %cmp = icmp slt i32 %add5, %add6 2159 ret i1 %cmp 2160} 2161 2162define i1 @icmp_nsw_22(i32 %V) { 2163; CHECK-LABEL: @icmp_nsw_22( 2164; CHECK-NEXT: ret i1 true 2165; 2166 %add5 = add nsw i32 %V, 5 2167 %add6 = add nsw i32 %V, 6 2168 %cmp = icmp slt i32 %add5, %add6 2169 ret i1 %cmp 2170} 2171 2172define i1 @icmp_nsw_23(i32 %V) { 2173; CHECK-LABEL: @icmp_nsw_23( 2174; CHECK-NEXT: [[ADD5:%.*]] = add nsw i32 [[V:%.*]], 5 2175; CHECK-NEXT: [[ADD6:%.*]] = add i32 [[V]], 6 2176; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[ADD5]], [[ADD6]] 2177; CHECK-NEXT: ret i1 [[CMP]] 2178; 2179 %add5 = add nsw i32 %V, 5 2180 %add6 = add i32 %V, 6 2181 %cmp = icmp slt i32 %add5, %add6 2182 ret i1 %cmp 2183} 2184 2185define i1 @icmp_nsw_false(i32 %V) { 2186; CHECK-LABEL: @icmp_nsw_false( 2187; CHECK-NEXT: ret i1 false 2188; 2189 %add5 = add nsw i32 %V, 6 2190 %add6 = add i32 %V, 5 2191 %cmp = icmp slt i32 %add5, %add6 2192 ret i1 %cmp 2193} 2194 2195define i1 @icmp_nsw_false_2(i32 %V) { 2196; CHECK-LABEL: @icmp_nsw_false_2( 2197; CHECK-NEXT: ret i1 false 2198; 2199 %add5 = add nsw i32 %V, 6 2200 %add6 = add nsw i32 %V, 5 2201 %cmp = icmp slt i32 %add5, %add6 2202 ret i1 %cmp 2203} 2204 2205define i1 @icmp_nsw_false_3(i32 %V) { 2206; CHECK-LABEL: @icmp_nsw_false_3( 2207; CHECK-NEXT: [[ADD5:%.*]] = add nsw i32 [[V:%.*]], 5 2208; CHECK-NEXT: [[ADD6:%.*]] = add i32 [[V]], 5 2209; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[ADD5]], [[ADD6]] 2210; CHECK-NEXT: ret i1 [[CMP]] 2211; 2212 %add5 = add nsw i32 %V, 5 2213 %add6 = add i32 %V, 5 2214 %cmp = icmp slt i32 %add5, %add6 2215 ret i1 %cmp 2216} 2217 2218define i1 @icmp_nsw_false_4(i32 %V) { 2219; CHECK-LABEL: @icmp_nsw_false_4( 2220; CHECK-NEXT: [[ADD5:%.*]] = add i32 [[V:%.*]], 6 2221; CHECK-NEXT: [[ADD6:%.*]] = add nsw i32 [[V]], 5 2222; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[ADD5]], [[ADD6]] 2223; CHECK-NEXT: ret i1 [[CMP]] 2224; 2225 %add5 = add i32 %V, 6 2226 %add6 = add nsw i32 %V, 5 2227 %cmp = icmp slt i32 %add5, %add6 2228 ret i1 %cmp 2229} 2230 2231define i1 @icmp_nsw_false_5(i8 %V) { 2232; CHECK-LABEL: @icmp_nsw_false_5( 2233; CHECK-NEXT: [[ADD:%.*]] = add i8 [[V:%.*]], 121 2234; CHECK-NEXT: [[ADDNSW:%.*]] = add nsw i8 [[V]], -104 2235; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[ADD]], [[ADDNSW]] 2236; CHECK-NEXT: ret i1 [[CMP]] 2237; 2238 %add = add i8 %V, 121 2239 %addnsw = add nsw i8 %V, -104 2240 %cmp = icmp slt i8 %add, %addnsw 2241 ret i1 %cmp 2242} 2243 2244define i1 @icmp_nsw_i8(i8 %V) { 2245; CHECK-LABEL: @icmp_nsw_i8( 2246; CHECK-NEXT: ret i1 true 2247; 2248 %add5 = add i8 %V, 5 2249 %add6 = add nsw i8 %V, 6 2250 %cmp = icmp slt i8 %add5, %add6 2251 ret i1 %cmp 2252} 2253 2254define i1 @icmp_nsw_i16(i16 %V) { 2255; CHECK-LABEL: @icmp_nsw_i16( 2256; CHECK-NEXT: ret i1 true 2257; 2258 %add5 = add i16 %V, 0 2259 %add6 = add nsw i16 %V, 1 2260 %cmp = icmp slt i16 %add5, %add6 2261 ret i1 %cmp 2262} 2263 2264define i1 @icmp_nsw_i64(i64 %V) { 2265; CHECK-LABEL: @icmp_nsw_i64( 2266; CHECK-NEXT: ret i1 true 2267; 2268 %add5 = add i64 %V, 5 2269 %add6 = add nsw i64 %V, 6 2270 %cmp = icmp slt i64 %add5, %add6 2271 ret i1 %cmp 2272} 2273 2274define <4 x i1> @icmp_nsw_vec(<4 x i32> %V) { 2275; CHECK-LABEL: @icmp_nsw_vec( 2276; CHECK-NEXT: ret <4 x i1> <i1 true, i1 true, i1 true, i1 true> 2277; 2278 %add5 = add <4 x i32> %V, <i32 5, i32 5, i32 5, i32 5> 2279 %add6 = add nsw <4 x i32> %V, <i32 6, i32 6, i32 6, i32 6> 2280 %cmp = icmp slt <4 x i32> %add5, %add6 2281 ret <4 x i1> %cmp 2282} 2283 2284define i1 @icmp_nsw_3(i32 %V) { 2285; CHECK-LABEL: @icmp_nsw_3( 2286; CHECK-NEXT: [[ADD5:%.*]] = add i32 [[V:%.*]], 5 2287; CHECK-NEXT: [[ADD5_2:%.*]] = add nsw i32 [[V]], 5 2288; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[ADD5]], [[ADD5_2]] 2289; CHECK-NEXT: ret i1 [[CMP]] 2290; 2291 %add5 = add i32 %V, 5 2292 %add5_2 = add nsw i32 %V, 5 2293 %cmp = icmp slt i32 %add5, %add5_2 2294 ret i1 %cmp 2295} 2296 2297define i1 @icmp_nsw_4(i32 %V) { 2298; CHECK-LABEL: @icmp_nsw_4( 2299; CHECK-NEXT: [[ADD5:%.*]] = add i32 [[V:%.*]], 5 2300; CHECK-NEXT: [[ADD4:%.*]] = add nsw i32 [[V]], 4 2301; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[ADD5]], [[ADD4]] 2302; CHECK-NEXT: ret i1 [[CMP]] 2303; 2304 %add5 = add i32 %V, 5 2305 %add4 = add nsw i32 %V, 4 2306 %cmp = icmp slt i32 %add5, %add4 2307 ret i1 %cmp 2308} 2309 2310define i1 @icmp_nsw_5(i32 %V) { 2311; CHECK-LABEL: @icmp_nsw_5( 2312; CHECK-NEXT: [[ADD5:%.*]] = add nsw i32 [[V:%.*]], 5 2313; CHECK-NEXT: [[ADD6:%.*]] = add i32 [[V]], 6 2314; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[ADD5]], [[ADD6]] 2315; CHECK-NEXT: ret i1 [[CMP]] 2316; 2317 %add5 = add nsw i32 %V, 5 2318 %add6 = add i32 %V, 6 2319 %cmp = icmp slt i32 %add5, %add6 2320 ret i1 %cmp 2321} 2322 2323define i1 @icmp_nsw_7(i32 %V, i32 %arg) { 2324; CHECK-LABEL: @icmp_nsw_7( 2325; CHECK-NEXT: [[ADD5:%.*]] = add i32 [[V:%.*]], 5 2326; CHECK-NEXT: [[ADDARG:%.*]] = add nsw i32 [[V]], [[ARG:%.*]] 2327; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[ADD5]], [[ADDARG]] 2328; CHECK-NEXT: ret i1 [[CMP]] 2329; 2330 %add5 = add i32 %V, 5 2331 %addarg = add nsw i32 %V, %arg 2332 %cmp = icmp slt i32 %add5, %addarg 2333 ret i1 %cmp 2334} 2335 2336define i1 @icmp_nsw_8(i32 %V, i32 %arg) { 2337; CHECK-LABEL: @icmp_nsw_8( 2338; CHECK-NEXT: [[ADDARG:%.*]] = add i32 [[V:%.*]], [[ARG:%.*]] 2339; CHECK-NEXT: [[ADD6:%.*]] = add nsw i32 [[V]], 5 2340; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[ADDARG]], [[ADD6]] 2341; CHECK-NEXT: ret i1 [[CMP]] 2342; 2343 %addarg = add i32 %V, %arg 2344 %add6 = add nsw i32 %V, 5 2345 %cmp = icmp slt i32 %addarg, %add6 2346 ret i1 %cmp 2347} 2348 2349define i1 @icmp_nsw_9(i32 %V1, i32 %V2) { 2350; CHECK-LABEL: @icmp_nsw_9( 2351; CHECK-NEXT: [[ADD_V1:%.*]] = add i32 [[V1:%.*]], 5 2352; CHECK-NEXT: [[ADD_V2:%.*]] = add nsw i32 [[V2:%.*]], 6 2353; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[ADD_V1]], [[ADD_V2]] 2354; CHECK-NEXT: ret i1 [[CMP]] 2355; 2356 %add_V1 = add i32 %V1, 5 2357 %add_V2 = add nsw i32 %V2, 6 2358 %cmp = icmp slt i32 %add_V1, %add_V2 2359 ret i1 %cmp 2360} 2361 2362define i1 @icmp_nsw_10(i32 %V) { 2363; CHECK-LABEL: @icmp_nsw_10( 2364; CHECK-NEXT: [[ADD5:%.*]] = add i32 [[V:%.*]], 5 2365; CHECK-NEXT: [[ADD6:%.*]] = add nsw i32 [[V]], 6 2366; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 [[ADD6]], [[ADD5]] 2367; CHECK-NEXT: ret i1 [[CMP]] 2368; 2369 %add5 = add i32 %V, 5 2370 %add6 = add nsw i32 %V, 6 2371 %cmp = icmp sgt i32 %add6, %add5 2372 ret i1 %cmp 2373} 2374 2375define i1 @icmp_nsw_11(i32 %V) { 2376; CHECK-LABEL: @icmp_nsw_11( 2377; CHECK-NEXT: [[ADD5:%.*]] = add i32 [[V:%.*]], -125 2378; CHECK-NEXT: [[ADD6:%.*]] = add nsw i32 [[V]], -99 2379; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[ADD5]], [[ADD6]] 2380; CHECK-NEXT: ret i1 [[CMP]] 2381; 2382 %add5 = add i32 %V, -125 2383 %add6 = add nsw i32 %V, -99 2384 %cmp = icmp slt i32 %add5, %add6 2385 ret i1 %cmp 2386} 2387 2388define i1 @icmp_nsw_nonpos(i32 %V) { 2389; CHECK-LABEL: @icmp_nsw_nonpos( 2390; CHECK-NEXT: ret i1 false 2391; 2392 %add5 = add i32 %V, 0 2393 %add6 = add nsw i32 %V, -1 2394 %cmp = icmp slt i32 %add5, %add6 2395 ret i1 %cmp 2396} 2397 2398define i1 @icmp_nsw_nonpos2(i32 %V) { 2399; CHECK-LABEL: @icmp_nsw_nonpos2( 2400; CHECK-NEXT: [[ADD5:%.*]] = add i32 [[V:%.*]], 1 2401; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[ADD5]], [[V]] 2402; CHECK-NEXT: ret i1 [[CMP]] 2403; 2404 %add5 = add i32 %V, 1 2405 %add6 = add nsw i32 %V, 0 2406 %cmp = icmp slt i32 %add5, %add6 2407 ret i1 %cmp 2408} 2409 2410declare i11 @llvm.ctpop.i11(i11) 2411declare i73 @llvm.ctpop.i73(i73) 2412declare <2 x i13> @llvm.ctpop.v2i13(<2 x i13>) 2413 2414define i1 @ctpop_sgt_bitwidth(i11 %x) { 2415; CHECK-LABEL: @ctpop_sgt_bitwidth( 2416; CHECK-NEXT: ret i1 false 2417; 2418 %pop = call i11 @llvm.ctpop.i11(i11 %x) 2419 %cmp = icmp sgt i11 %pop, 11 2420 ret i1 %cmp 2421} 2422 2423define i1 @ctpop_sle_minus1(i11 %x) { 2424; CHECK-LABEL: @ctpop_sle_minus1( 2425; CHECK-NEXT: ret i1 false 2426; 2427 %pop = call i11 @llvm.ctpop.i11(i11 %x) 2428 %cmp = icmp sle i11 %pop, -1 2429 ret i1 %cmp 2430} 2431 2432define i1 @ctpop_ugt_bitwidth(i73 %x) { 2433; CHECK-LABEL: @ctpop_ugt_bitwidth( 2434; CHECK-NEXT: ret i1 false 2435; 2436 %pop = call i73 @llvm.ctpop.i73(i73 %x) 2437 %cmp = icmp ugt i73 %pop, 73 2438 ret i1 %cmp 2439} 2440 2441; Negative test - does not simplify, but instcombine could reduce this. 2442 2443define i1 @ctpop_ugt_bitwidth_minus1(i73 %x) { 2444; CHECK-LABEL: @ctpop_ugt_bitwidth_minus1( 2445; CHECK-NEXT: [[POP:%.*]] = call i73 @llvm.ctpop.i73(i73 [[X:%.*]]) 2446; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i73 [[POP]], 72 2447; CHECK-NEXT: ret i1 [[CMP]] 2448; 2449 %pop = call i73 @llvm.ctpop.i73(i73 %x) 2450 %cmp = icmp ugt i73 %pop, 72 2451 ret i1 %cmp 2452} 2453 2454define <2 x i1> @ctpop_sgt_bitwidth_splat(<2 x i13> %x) { 2455; CHECK-LABEL: @ctpop_sgt_bitwidth_splat( 2456; CHECK-NEXT: ret <2 x i1> zeroinitializer 2457; 2458 %pop = call <2 x i13> @llvm.ctpop.v2i13(<2 x i13> %x) 2459 %cmp = icmp sgt <2 x i13> %pop, <i13 13, i13 13> 2460 ret <2 x i1> %cmp 2461} 2462 2463define i1 @ctpop_ult_plus1_bitwidth(i11 %x) { 2464; CHECK-LABEL: @ctpop_ult_plus1_bitwidth( 2465; CHECK-NEXT: ret i1 true 2466; 2467 %pop = call i11 @llvm.ctpop.i11(i11 %x) 2468 %cmp = icmp ult i11 %pop, 12 2469 ret i1 %cmp 2470} 2471 2472define i1 @ctpop_ne_big_bitwidth(i73 %x) { 2473; CHECK-LABEL: @ctpop_ne_big_bitwidth( 2474; CHECK-NEXT: ret i1 true 2475; 2476 %pop = call i73 @llvm.ctpop.i73(i73 %x) 2477 %cmp = icmp ne i73 %pop, 75 2478 ret i1 %cmp 2479} 2480 2481define <2 x i1> @ctpop_slt_bitwidth_plus1_splat(<2 x i13> %x) { 2482; CHECK-LABEL: @ctpop_slt_bitwidth_plus1_splat( 2483; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> 2484; 2485 %pop = call <2 x i13> @llvm.ctpop.v2i13(<2 x i13> %x) 2486 %cmp = icmp slt <2 x i13> %pop, <i13 14, i13 14> 2487 ret <2 x i1> %cmp 2488} 2489 2490; Negative test - does not simplify, but instcombine could reduce this. 2491 2492define <2 x i1> @ctpop_slt_bitwidth_splat(<2 x i13> %x) { 2493; CHECK-LABEL: @ctpop_slt_bitwidth_splat( 2494; CHECK-NEXT: [[POP:%.*]] = call <2 x i13> @llvm.ctpop.v2i13(<2 x i13> [[X:%.*]]) 2495; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i13> [[POP]], <i13 13, i13 13> 2496; CHECK-NEXT: ret <2 x i1> [[CMP]] 2497; 2498 %pop = call <2 x i13> @llvm.ctpop.v2i13(<2 x i13> %x) 2499 %cmp = icmp slt <2 x i13> %pop, <i13 13, i13 13> 2500 ret <2 x i1> %cmp 2501} 2502 2503declare i11 @llvm.ctlz.i11(i11) 2504declare i73 @llvm.ctlz.i73(i73) 2505declare <2 x i13> @llvm.ctlz.v2i13(<2 x i13>) 2506 2507define i1 @ctlz_sgt_bitwidth(i11 %x) { 2508; CHECK-LABEL: @ctlz_sgt_bitwidth( 2509; CHECK-NEXT: ret i1 false 2510; 2511 %pop = call i11 @llvm.ctlz.i11(i11 %x) 2512 %cmp = icmp sgt i11 %pop, 11 2513 ret i1 %cmp 2514} 2515 2516define i1 @ctlz_sle_minus1(i11 %x) { 2517; CHECK-LABEL: @ctlz_sle_minus1( 2518; CHECK-NEXT: ret i1 false 2519; 2520 %pop = call i11 @llvm.ctlz.i11(i11 %x) 2521 %cmp = icmp sle i11 %pop, -1 2522 ret i1 %cmp 2523} 2524 2525define i1 @ctlz_ugt_bitwidth(i73 %x) { 2526; CHECK-LABEL: @ctlz_ugt_bitwidth( 2527; CHECK-NEXT: ret i1 false 2528; 2529 %pop = call i73 @llvm.ctlz.i73(i73 %x) 2530 %cmp = icmp ugt i73 %pop, 73 2531 ret i1 %cmp 2532} 2533 2534; Negative test - does not simplify, but instcombine could reduce this. 2535 2536define i1 @ctlz_ugt_bitwidth_minus1(i73 %x) { 2537; CHECK-LABEL: @ctlz_ugt_bitwidth_minus1( 2538; CHECK-NEXT: [[POP:%.*]] = call i73 @llvm.ctlz.i73(i73 [[X:%.*]], i1 false) 2539; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i73 [[POP]], 72 2540; CHECK-NEXT: ret i1 [[CMP]] 2541; 2542 %pop = call i73 @llvm.ctlz.i73(i73 %x) 2543 %cmp = icmp ugt i73 %pop, 72 2544 ret i1 %cmp 2545} 2546 2547define <2 x i1> @ctlz_sgt_bitwidth_splat(<2 x i13> %x) { 2548; CHECK-LABEL: @ctlz_sgt_bitwidth_splat( 2549; CHECK-NEXT: ret <2 x i1> zeroinitializer 2550; 2551 %pop = call <2 x i13> @llvm.ctlz.v2i13(<2 x i13> %x) 2552 %cmp = icmp sgt <2 x i13> %pop, <i13 13, i13 13> 2553 ret <2 x i1> %cmp 2554} 2555 2556define i1 @ctlz_ult_plus1_bitwidth(i11 %x) { 2557; CHECK-LABEL: @ctlz_ult_plus1_bitwidth( 2558; CHECK-NEXT: ret i1 true 2559; 2560 %pop = call i11 @llvm.ctlz.i11(i11 %x) 2561 %cmp = icmp ult i11 %pop, 12 2562 ret i1 %cmp 2563} 2564 2565define i1 @ctlz_ne_big_bitwidth(i73 %x) { 2566; CHECK-LABEL: @ctlz_ne_big_bitwidth( 2567; CHECK-NEXT: ret i1 true 2568; 2569 %pop = call i73 @llvm.ctlz.i73(i73 %x) 2570 %cmp = icmp ne i73 %pop, 75 2571 ret i1 %cmp 2572} 2573 2574define <2 x i1> @ctlz_slt_bitwidth_plus1_splat(<2 x i13> %x) { 2575; CHECK-LABEL: @ctlz_slt_bitwidth_plus1_splat( 2576; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> 2577; 2578 %pop = call <2 x i13> @llvm.ctlz.v2i13(<2 x i13> %x) 2579 %cmp = icmp slt <2 x i13> %pop, <i13 14, i13 14> 2580 ret <2 x i1> %cmp 2581} 2582 2583; Negative test - does not simplify, but instcombine could reduce this. 2584 2585define <2 x i1> @ctlz_slt_bitwidth_splat(<2 x i13> %x) { 2586; CHECK-LABEL: @ctlz_slt_bitwidth_splat( 2587; CHECK-NEXT: [[POP:%.*]] = call <2 x i13> @llvm.ctlz.v2i13(<2 x i13> [[X:%.*]], i1 false) 2588; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i13> [[POP]], <i13 13, i13 13> 2589; CHECK-NEXT: ret <2 x i1> [[CMP]] 2590; 2591 %pop = call <2 x i13> @llvm.ctlz.v2i13(<2 x i13> %x) 2592 %cmp = icmp slt <2 x i13> %pop, <i13 13, i13 13> 2593 ret <2 x i1> %cmp 2594} 2595 2596declare i11 @llvm.cttz.i11(i11) 2597declare i73 @llvm.cttz.i73(i73) 2598declare <2 x i13> @llvm.cttz.v2i13(<2 x i13>) 2599 2600define i1 @cttz_sgt_bitwidth(i11 %x) { 2601; CHECK-LABEL: @cttz_sgt_bitwidth( 2602; CHECK-NEXT: ret i1 false 2603; 2604 %pop = call i11 @llvm.cttz.i11(i11 %x) 2605 %cmp = icmp sgt i11 %pop, 11 2606 ret i1 %cmp 2607} 2608 2609define i1 @cttz_sle_minus1(i11 %x) { 2610; CHECK-LABEL: @cttz_sle_minus1( 2611; CHECK-NEXT: ret i1 false 2612; 2613 %pop = call i11 @llvm.cttz.i11(i11 %x) 2614 %cmp = icmp sle i11 %pop, -1 2615 ret i1 %cmp 2616} 2617 2618define i1 @cttz_ugt_bitwidth(i73 %x) { 2619; CHECK-LABEL: @cttz_ugt_bitwidth( 2620; CHECK-NEXT: ret i1 false 2621; 2622 %pop = call i73 @llvm.cttz.i73(i73 %x) 2623 %cmp = icmp ugt i73 %pop, 73 2624 ret i1 %cmp 2625} 2626 2627; Negative test - does not simplify, but instcombine could reduce this. 2628 2629define i1 @cttz_ugt_bitwidth_minus1(i73 %x) { 2630; CHECK-LABEL: @cttz_ugt_bitwidth_minus1( 2631; CHECK-NEXT: [[POP:%.*]] = call i73 @llvm.cttz.i73(i73 [[X:%.*]], i1 false) 2632; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i73 [[POP]], 72 2633; CHECK-NEXT: ret i1 [[CMP]] 2634; 2635 %pop = call i73 @llvm.cttz.i73(i73 %x) 2636 %cmp = icmp ugt i73 %pop, 72 2637 ret i1 %cmp 2638} 2639 2640define <2 x i1> @cttz_sgt_bitwidth_splat(<2 x i13> %x) { 2641; CHECK-LABEL: @cttz_sgt_bitwidth_splat( 2642; CHECK-NEXT: ret <2 x i1> zeroinitializer 2643; 2644 %pop = call <2 x i13> @llvm.cttz.v2i13(<2 x i13> %x) 2645 %cmp = icmp sgt <2 x i13> %pop, <i13 13, i13 13> 2646 ret <2 x i1> %cmp 2647} 2648 2649define i1 @cttz_ult_plus1_bitwidth(i11 %x) { 2650; CHECK-LABEL: @cttz_ult_plus1_bitwidth( 2651; CHECK-NEXT: ret i1 true 2652; 2653 %pop = call i11 @llvm.cttz.i11(i11 %x) 2654 %cmp = icmp ult i11 %pop, 12 2655 ret i1 %cmp 2656} 2657 2658define i1 @cttz_ne_big_bitwidth(i73 %x) { 2659; CHECK-LABEL: @cttz_ne_big_bitwidth( 2660; CHECK-NEXT: ret i1 true 2661; 2662 %pop = call i73 @llvm.cttz.i73(i73 %x) 2663 %cmp = icmp ne i73 %pop, 75 2664 ret i1 %cmp 2665} 2666 2667define <2 x i1> @cttz_slt_bitwidth_plus1_splat(<2 x i13> %x) { 2668; CHECK-LABEL: @cttz_slt_bitwidth_plus1_splat( 2669; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> 2670; 2671 %pop = call <2 x i13> @llvm.cttz.v2i13(<2 x i13> %x) 2672 %cmp = icmp slt <2 x i13> %pop, <i13 14, i13 14> 2673 ret <2 x i1> %cmp 2674} 2675 2676; Negative test - does not simplify, but instcombine could reduce this. 2677 2678define <2 x i1> @cttz_slt_bitwidth_splat(<2 x i13> %x) { 2679; CHECK-LABEL: @cttz_slt_bitwidth_splat( 2680; CHECK-NEXT: [[POP:%.*]] = call <2 x i13> @llvm.cttz.v2i13(<2 x i13> [[X:%.*]], i1 false) 2681; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i13> [[POP]], <i13 13, i13 13> 2682; CHECK-NEXT: ret <2 x i1> [[CMP]] 2683; 2684 %pop = call <2 x i13> @llvm.cttz.v2i13(<2 x i13> %x) 2685 %cmp = icmp slt <2 x i13> %pop, <i13 13, i13 13> 2686 ret <2 x i1> %cmp 2687} 2688 2689; A zero sized alloca *can* be equal to another alloca 2690define i1 @zero_sized_alloca1() { 2691; CHECK-LABEL: @zero_sized_alloca1( 2692; CHECK-NEXT: [[A:%.*]] = alloca i32, i32 0, align 4 2693; CHECK-NEXT: [[B:%.*]] = alloca i32, i32 0, align 4 2694; CHECK-NEXT: [[RES:%.*]] = icmp ne ptr [[A]], [[B]] 2695; CHECK-NEXT: ret i1 [[RES]] 2696; 2697 %a = alloca i32, i32 0 2698 %b = alloca i32, i32 0 2699 %res = icmp ne ptr %a, %b 2700 ret i1 %res 2701} 2702 2703define i1 @zero_sized_alloca2() { 2704; CHECK-LABEL: @zero_sized_alloca2( 2705; CHECK-NEXT: [[A:%.*]] = alloca i32, i32 0, align 4 2706; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4 2707; CHECK-NEXT: [[RES:%.*]] = icmp ne ptr [[A]], [[B]] 2708; CHECK-NEXT: ret i1 [[RES]] 2709; 2710 %a = alloca i32, i32 0 2711 %b = alloca i32 2712 %res = icmp ne ptr %a, %b 2713 ret i1 %res 2714} 2715 2716define i1 @scalar_vectors_are_non_empty() { 2717; CHECK-LABEL: @scalar_vectors_are_non_empty( 2718; CHECK-NEXT: ret i1 true 2719; 2720 %a = alloca <vscale x 2 x i32> 2721 %b = alloca <vscale x 2 x i32> 2722 %res = icmp ne ptr %a, %b 2723 ret i1 %res 2724} 2725 2726; Never equal 2727define i1 @byval_args_inequal(ptr byval(i32) %a, ptr byval(i32) %b) { 2728; CHECK-LABEL: @byval_args_inequal( 2729; CHECK-NEXT: ret i1 true 2730; 2731 %res = icmp ne ptr %a, %b 2732 ret i1 %res 2733} 2734 2735; Arguments can be adjacent on the stack 2736define i1 @neg_args_adjacent(ptr byval(i32) %a, ptr byval(i32) %b) { 2737; CHECK-LABEL: @neg_args_adjacent( 2738; CHECK-NEXT: [[A_OFF:%.*]] = getelementptr i32, ptr [[A:%.*]], i32 1 2739; CHECK-NEXT: [[RES:%.*]] = icmp ne ptr [[A_OFF]], [[B:%.*]] 2740; CHECK-NEXT: ret i1 [[RES]] 2741; 2742 %a.off = getelementptr i32, ptr %a, i32 1 2743 %res = icmp ne ptr %a.off, %b 2744 ret i1 %res 2745} 2746 2747; Never equal 2748define i1 @test_byval_alloca_inequal(ptr byval(i32) %a) { 2749; CHECK-LABEL: @test_byval_alloca_inequal( 2750; CHECK-NEXT: ret i1 true 2751; 2752 %b = alloca i32 2753 %res = icmp ne ptr %a, %b 2754 ret i1 %res 2755} 2756 2757; Byval argument can be immediately before alloca, and crossing 2758; over is allowed. 2759define i1 @neg_byval_alloca_adjacent(ptr byval(i32) %a) { 2760; CHECK-LABEL: @neg_byval_alloca_adjacent( 2761; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4 2762; CHECK-NEXT: [[A_OFF:%.*]] = getelementptr i32, ptr [[A:%.*]], i32 1 2763; CHECK-NEXT: [[RES:%.*]] = icmp ne ptr [[A_OFF]], [[B]] 2764; CHECK-NEXT: ret i1 [[RES]] 2765; 2766 %b = alloca i32 2767 %a.off = getelementptr i32, ptr %a, i32 1 2768 %res = icmp ne ptr %a.off, %b 2769 ret i1 %res 2770} 2771 2772@A = global i32 0 2773@B = global i32 0 2774@A.alias = alias i32, ptr @A 2775 2776define i1 @globals_inequal() { 2777; CHECK-LABEL: @globals_inequal( 2778; CHECK-NEXT: ret i1 true 2779; 2780 %res = icmp ne ptr @A, @B 2781 ret i1 %res 2782} 2783 2784; TODO: Never equal 2785define i1 @globals_offset_inequal() { 2786; CHECK-LABEL: @globals_offset_inequal( 2787; CHECK-NEXT: ret i1 icmp ne (ptr getelementptr inbounds (i8, ptr @A, i32 1), ptr getelementptr inbounds (i8, ptr @B, i32 1)) 2788; 2789 %a.off = getelementptr i8, ptr @A, i32 1 2790 %b.off = getelementptr i8, ptr @B, i32 1 2791 %res = icmp ne ptr %a.off, %b.off 2792 ret i1 %res 2793} 2794 2795 2796; Never equal 2797define i1 @test_byval_global_inequal(ptr byval(i32) %a) { 2798; CHECK-LABEL: @test_byval_global_inequal( 2799; CHECK-NEXT: ret i1 true 2800; 2801 %b = alloca i32 2802 %res = icmp ne ptr %a, @B 2803 ret i1 %res 2804} 2805 2806 2807define i1 @neg_global_alias() { 2808; CHECK-LABEL: @neg_global_alias( 2809; CHECK-NEXT: ret i1 icmp ne (ptr @A, ptr @A.alias) 2810; 2811 %res = icmp ne ptr @A, @A.alias 2812 ret i1 %res 2813} 2814 2815; TODO: Add coverage for global aliases, link once, etc.. 2816 2817 2818attributes #0 = { null_pointer_is_valid } 2819