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