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