llvm/test/Transforms/InstSimplify/compare.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -instsimplify -S | FileCheck %s
   3 target datalayout = "p:32:32-p1:64:64"
   4
   5 declare void @llvm.assume(i1)
   6
   7 define 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
  17 define 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
  29 define 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
  39 define 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
  55 define 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
  66 define 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
  79 define 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
  88 define 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
  99 define 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
 110 define 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
 122 define 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
 135 define i1 @gep9(i8* %ptr) {
 136 ; CHECK-LABEL: @gep9(
 137 ; CHECK-NEXT:  entry:
 138 ; CHECK-NEXT:    ret i1 true
 139 ;
 140 entry:
 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
 155 define i1 @gep10(i8* %ptr) {
 156 ; CHECK-LABEL: @gep10(
 157 ; CHECK-NEXT:  entry:
 158 ; CHECK-NEXT:    ret i1 true
 159 ;
 160 entry:
 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
 171 define i1 @gep11(i8* %ptr) {
 172 ; CHECK-LABEL: @gep11(
 173 ; CHECK-NEXT:  entry:
 174 ; CHECK-NEXT:    ret i1 true
 175 ;
 176 entry:
 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
 184 define 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 ;
 193 entry:
 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
 201 define 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
 211 define 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
 223 define 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
 236 define 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
 247 define 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
 259 define 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
 271 define 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
 285 define 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.
 300 define 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
 313 define 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
 323 define 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
 332 define 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
 341 define 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
 351 define 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
 360 define 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
 369 define 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
 381 define 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
 394 define 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
 405 define 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
 417 define 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
 432 define 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
 443 define 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
 454 define 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
 464 define 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
 475 define 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
 492 define 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
 504 define 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 ;
 511 entry:
 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
 518 define 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
 527 define 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
 536 define 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
 545 define 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
 554 define 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
 563 define 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
 572 define 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
 581 define 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
 594 define 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
 607 define 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
 620 define 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
 634 define 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
 650 define 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
 662 define 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
 677 define 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
 686 define 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
 695 define 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
 704 define 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
 714 define 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
 724 define 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
 734 define 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
 744 define 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
 757 define 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
 766 define 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
 775 define 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
 786 define 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
 799 define 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
 808 define 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
 819 define 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
 828 define 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
 837 define 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
 846 define 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
 856 define 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
 867 define 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
 879 define 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
 891 define 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
 904 define 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
 916 define 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
 928 define 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
 941 define 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
 950 define 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
 960 define 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
 971 define 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
 980 define 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
 989 define 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
1002 define 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
1015 define 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
1028 define 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
1042 define 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
1058 define 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
1070 define 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.
1086 define 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
1096 define 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.
1108 define 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
1118 define 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.
1130 define 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
1141 define <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
1152 define <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
1163 define <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
1177 define 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
1187 define 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
1200 define 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
1210 unreachableblock:
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
1221 define 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
1234 define 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
1250 define 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
1259 define 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
1271 define 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
1285 define 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
1298 define 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
1309 define 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
1319 define <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
1329 define 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
1339 define <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
1349 define 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
1359 define <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
1369 define 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
1379 define <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
1389 define 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
1399 define <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
1409 define 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
1419 define <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
1429 define 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
1438 define 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
1446 define 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
1454 define 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
1462 define 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 }
1470 define 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
1479 declare nonnull i32* @returns_nonnull_helper()
1480 define 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
1490 declare dereferenceable(4) i32* @returns_nonnull_deref_helper()
1491 define 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
1501 define 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
1512 declare dereferenceable(4) i32 addrspace(1)* @returns_nonnull_deref_as_helper()
1513 define 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
1524 define 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
1533 define 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 }
1541 define 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.
1552 define 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
1561 define <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
1570 define 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
1579 define <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
1588 define 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
1600 define 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
1612 define 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
1624 define 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
1637 define 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
1651 define 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
1660 define 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
1669 define <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
1678 define <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
1687 define <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
1696 define 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
1705 define <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
1714 define <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
1723 define <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
1732 define 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
1741 define <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
1750 define <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
1759 define 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
1768 define <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
1777 define <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
1786 define 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
1795 define <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
1806 define 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
1819 define <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
1830 define 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
1839 define <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
1848 define 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
1857 define <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
1866 define 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
1875 define 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
1884 define 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
1893 define 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
1902 define 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
1911 define 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
1920 define 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
1929 define 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
1938 declare 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)
1940 define 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
2094 define 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
2102 define 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
2110 define 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
2124 define 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
2136 define 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
2146 define 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
2156 define 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
2166 define 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
2176 define 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
2186 define 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
2199 define 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
2209 define 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
2219 define 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
2232 define 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
2245 define 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
2258 define 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
2268 define 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
2278 define 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
2288 define <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
2298 define 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
2311 define 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
2324 define 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
2337 define 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
2350 define 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
2363 define 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
2376 define 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
2389 define 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
2402 define 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
2412 define 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
2424 declare i11 @llvm.ctpop.i11(i11)
2425 declare i73 @llvm.ctpop.i73(i73)
2426 declare <2 x i13> @llvm.ctpop.v2i13(<2 x i13>)
2427
2428 define 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
2437 define 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
2446 define 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
2457 define 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
2468 define <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
2477 define 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
2486 define 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
2495 define <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
2506 define <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
2517 declare i11 @llvm.ctlz.i11(i11)
2518 declare i73 @llvm.ctlz.i73(i73)
2519 declare <2 x i13> @llvm.ctlz.v2i13(<2 x i13>)
2520
2521 define 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
2530 define 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
2539 define 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
2550 define 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
2561 define <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
2570 define 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
2579 define 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
2588 define <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
2599 define <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
2610 declare i11 @llvm.cttz.i11(i11)
2611 declare i73 @llvm.cttz.i73(i73)
2612 declare <2 x i13> @llvm.cttz.v2i13(<2 x i13>)
2613
2614 define 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
2623 define 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
2632 define 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
2643 define 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
2654 define <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
2663 define 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
2672 define 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
2681 define <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
2692 define <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
2703 attributes #0 = { null_pointer_is_valid }