llvm/test/Transforms/InstSimplify/select.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
   3
   4 define i1 @bool_true_or_false(i1 %cond) {
   5 ; CHECK-LABEL: @bool_true_or_false(
   6 ; CHECK-NEXT:    ret i1 [[COND:%.*]]
   7 ;
   8   %s = select i1 %cond, i1 true, i1 false
   9   ret i1 %s
  10 }
  11
  12 define i1 @cond_constexpr_bool_true_or_false(i1 %cond) {
  13 ; CHECK-LABEL: @cond_constexpr_bool_true_or_false(
  14 ; CHECK-NEXT:    ret i1 ptrtoint (ptr @cond_constexpr_bool_true_or_false to i1)
  15 ;
  16   %s = select i1 ptrtoint (ptr @cond_constexpr_bool_true_or_false to i1), i1 true, i1 false
  17   ret i1 %s
  18 }
  19
  20 define <2 x i1> @bool_true_or_false_vec(<2 x i1> %cond) {
  21 ; CHECK-LABEL: @bool_true_or_false_vec(
  22 ; CHECK-NEXT:    ret <2 x i1> [[COND:%.*]]
  23 ;
  24   %s = select <2 x i1> %cond, <2 x i1> <i1 true, i1 true>, <2 x i1> zeroinitializer
  25   ret <2 x i1> %s
  26 }
  27
  28 define <2 x i1> @bool_true_or_false_vec_undef(<2 x i1> %cond) {
  29 ; CHECK-LABEL: @bool_true_or_false_vec_undef(
  30 ; CHECK-NEXT:    ret <2 x i1> [[COND:%.*]]
  31 ;
  32   %s = select <2 x i1> %cond, <2 x i1> <i1 undef, i1 true>, <2 x i1> <i1 false, i1 undef>
  33   ret <2 x i1> %s
  34 }
  35
  36 define i32 @cond_is_false(i32 %A, i32 %B) {
  37 ; CHECK-LABEL: @cond_is_false(
  38 ; CHECK-NEXT:    ret i32 [[B:%.*]]
  39 ;
  40   %C = select i1 false, i32 %A, i32 %B
  41   ret i32 %C
  42 }
  43
  44 define i32 @cond_is_true(i32 %A, i32 %B) {
  45 ; CHECK-LABEL: @cond_is_true(
  46 ; CHECK-NEXT:    ret i32 [[A:%.*]]
  47 ;
  48   %C = select i1 true, i32 %A, i32 %B
  49   ret i32 %C
  50 }
  51
  52 define i32 @equal_arms(i1 %cond, i32 %x) {
  53 ; CHECK-LABEL: @equal_arms(
  54 ; CHECK-NEXT:    ret i32 [[X:%.*]]
  55 ;
  56   %V = select i1 %cond, i32 %x, i32 %x
  57   ret i32 %V
  58 }
  59
  60 define <2 x i32> @equal_arms_vec(<2 x i1> %cond, <2 x i32> %x) {
  61 ; CHECK-LABEL: @equal_arms_vec(
  62 ; CHECK-NEXT:    ret <2 x i32> [[X:%.*]]
  63 ;
  64   %V = select <2 x i1> %cond, <2 x i32> %x, <2 x i32> %x
  65   ret <2 x i32> %V
  66 }
  67
  68 define <2 x i32> @equal_arms_vec_undef(<2 x i1> %cond) {
  69 ; CHECK-LABEL: @equal_arms_vec_undef(
  70 ; CHECK-NEXT:    ret <2 x i32> <i32 42, i32 42>
  71 ;
  72   %V = select <2 x i1> %cond, <2 x i32> <i32 42, i32 undef>, <2 x i32> <i32 undef, i32 42>
  73   ret <2 x i32> %V
  74 }
  75
  76 define <3 x float> @equal_arms_vec_less_undef(<3 x i1> %cond) {
  77 ; CHECK-LABEL: @equal_arms_vec_less_undef(
  78 ; CHECK-NEXT:    ret <3 x float> <float 4.200000e+01, float 4.200000e+01, float 4.300000e+01>
  79 ;
  80   %V = select <3 x i1> %cond, <3 x float> <float 42.0, float undef, float 43.0>, <3 x float> <float 42.0, float 42.0, float 43.0>
  81   ret <3 x float> %V
  82 }
  83
  84 define <3 x float> @equal_arms_vec_more_undef(<3 x i1> %cond) {
  85 ; CHECK-LABEL: @equal_arms_vec_more_undef(
  86 ; CHECK-NEXT:    ret <3 x float> <float 4.200000e+01, float undef, float 4.300000e+01>
  87 ;
  88   %V = select <3 x i1> %cond, <3 x float> <float 42.0, float undef, float undef>, <3 x float> <float undef, float undef, float 43.0>
  89   ret <3 x float> %V
  90 }
  91
  92 define <2 x i8> @vsel_tvec(<2 x i8> %x, <2 x i8> %y) {
  93 ; CHECK-LABEL: @vsel_tvec(
  94 ; CHECK-NEXT:    ret <2 x i8> [[X:%.*]]
  95 ;
  96   %s = select <2 x i1><i1 true, i1 true>, <2 x i8> %x, <2 x i8> %y
  97   ret <2 x i8> %s
  98 }
  99
 100 define <2 x i8> @vsel_fvec(<2 x i8> %x, <2 x i8> %y) {
 101 ; CHECK-LABEL: @vsel_fvec(
 102 ; CHECK-NEXT:    ret <2 x i8> [[Y:%.*]]
 103 ;
 104   %s = select <2 x i1><i1 false, i1 false>, <2 x i8> %x, <2 x i8> %y
 105   ret <2 x i8> %s
 106 }
 107
 108 define <2 x i8> @vsel_mixedvec() {
 109 ; CHECK-LABEL: @vsel_mixedvec(
 110 ; CHECK-NEXT:    ret <2 x i8> <i8 0, i8 3>
 111 ;
 112   %s = select <2 x i1><i1 true, i1 false>, <2 x i8> <i8 0, i8 1>, <2 x i8> <i8 2, i8 3>
 113   ret <2 x i8> %s
 114 }
 115
 116 define <3 x i8> @vsel_undef_true_op(<3 x i8> %x, <3 x i8> %y) {
 117 ; CHECK-LABEL: @vsel_undef_true_op(
 118 ; CHECK-NEXT:    ret <3 x i8> [[X:%.*]]
 119 ;
 120   %s = select <3 x i1><i1 1, i1 undef, i1 1>, <3 x i8> %x, <3 x i8> %y
 121   ret <3 x i8> %s
 122 }
 123
 124 define <3 x i4> @vsel_undef_false_op(<3 x i4> %x, <3 x i4> %y) {
 125 ; CHECK-LABEL: @vsel_undef_false_op(
 126 ; CHECK-NEXT:    ret <3 x i4> [[Y:%.*]]
 127 ;
 128   %s = select <3 x i1><i1 0, i1 undef, i1 undef>, <3 x i4> %x, <3 x i4> %y
 129   ret <3 x i4> %s
 130 }
 131
 132 define i32 @test1(i32 %x) {
 133 ; CHECK-LABEL: @test1(
 134 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 135 ;
 136   %and = and i32 %x, 1
 137   %cmp = icmp eq i32 %and, 0
 138   %and1 = and i32 %x, -2
 139   %and1.x = select i1 %cmp, i32 %and1, i32 %x
 140   ret i32 %and1.x
 141 }
 142
 143 define i32 @test2(i32 %x) {
 144 ; CHECK-LABEL: @test2(
 145 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 146 ;
 147   %and = and i32 %x, 1
 148   %cmp = icmp ne i32 %and, 0
 149   %and1 = and i32 %x, -2
 150   %and1.x = select i1 %cmp, i32 %x, i32 %and1
 151   ret i32 %and1.x
 152 }
 153
 154 define i32 @test3(i32 %x) {
 155 ; CHECK-LABEL: @test3(
 156 ; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[X:%.*]], -2
 157 ; CHECK-NEXT:    ret i32 [[AND1]]
 158 ;
 159   %and = and i32 %x, 1
 160   %cmp = icmp ne i32 %and, 0
 161   %and1 = and i32 %x, -2
 162   %and1.x = select i1 %cmp, i32 %and1, i32 %x
 163   ret i32 %and1.x
 164 }
 165
 166 define i32 @test4(i32 %X) {
 167 ; CHECK-LABEL: @test4(
 168 ; CHECK-NEXT:    [[OR:%.*]] = or i32 [[X:%.*]], -2147483648
 169 ; CHECK-NEXT:    ret i32 [[OR]]
 170 ;
 171   %cmp = icmp slt i32 %X, 0
 172   %or = or i32 %X, -2147483648
 173   %cond = select i1 %cmp, i32 %X, i32 %or
 174   ret i32 %cond
 175 }
 176
 177 ; Same as above, but the compare isn't canonical
 178 define i32 @test4noncanon(i32 %X) {
 179 ; CHECK-LABEL: @test4noncanon(
 180 ; CHECK-NEXT:    [[OR:%.*]] = or i32 [[X:%.*]], -2147483648
 181 ; CHECK-NEXT:    ret i32 [[OR]]
 182 ;
 183   %cmp = icmp sle i32 %X, -1
 184   %or = or i32 %X, -2147483648
 185   %cond = select i1 %cmp, i32 %X, i32 %or
 186   ret i32 %cond
 187 }
 188
 189 define i32 @test5(i32 %X) {
 190 ; CHECK-LABEL: @test5(
 191 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 192 ;
 193   %cmp = icmp slt i32 %X, 0
 194   %or = or i32 %X, -2147483648
 195   %cond = select i1 %cmp, i32 %or, i32 %X
 196   ret i32 %cond
 197 }
 198
 199 define i32 @test6(i32 %X) {
 200 ; CHECK-LABEL: @test6(
 201 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 2147483647
 202 ; CHECK-NEXT:    ret i32 [[AND]]
 203 ;
 204   %cmp = icmp slt i32 %X, 0
 205   %and = and i32 %X, 2147483647
 206   %cond = select i1 %cmp, i32 %and, i32 %X
 207   ret i32 %cond
 208 }
 209
 210 define i32 @test7(i32 %X) {
 211 ; CHECK-LABEL: @test7(
 212 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 213 ;
 214   %cmp = icmp slt i32 %X, 0
 215   %and = and i32 %X, 2147483647
 216   %cond = select i1 %cmp, i32 %X, i32 %and
 217   ret i32 %cond
 218 }
 219
 220 define i32 @test8(i32 %X) {
 221 ; CHECK-LABEL: @test8(
 222 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 223 ;
 224   %cmp = icmp sgt i32 %X, -1
 225   %or = or i32 %X, -2147483648
 226   %cond = select i1 %cmp, i32 %X, i32 %or
 227   ret i32 %cond
 228 }
 229
 230 define i32 @test9(i32 %X) {
 231 ; CHECK-LABEL: @test9(
 232 ; CHECK-NEXT:    [[OR:%.*]] = or i32 [[X:%.*]], -2147483648
 233 ; CHECK-NEXT:    ret i32 [[OR]]
 234 ;
 235   %cmp = icmp sgt i32 %X, -1
 236   %or = or i32 %X, -2147483648
 237   %cond = select i1 %cmp, i32 %or, i32 %X
 238   ret i32 %cond
 239 }
 240
 241 ; Same as above, but the compare isn't canonical
 242 define i32 @test9noncanon(i32 %X) {
 243 ; CHECK-LABEL: @test9noncanon(
 244 ; CHECK-NEXT:    [[OR:%.*]] = or i32 [[X:%.*]], -2147483648
 245 ; CHECK-NEXT:    ret i32 [[OR]]
 246 ;
 247   %cmp = icmp sge i32 %X, 0
 248   %or = or i32 %X, -2147483648
 249   %cond = select i1 %cmp, i32 %or, i32 %X
 250   ret i32 %cond
 251 }
 252
 253 define i32 @test10(i32 %X) {
 254 ; CHECK-LABEL: @test10(
 255 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 256 ;
 257   %cmp = icmp sgt i32 %X, -1
 258   %and = and i32 %X, 2147483647
 259   %cond = select i1 %cmp, i32 %and, i32 %X
 260   ret i32 %cond
 261 }
 262
 263 define i32 @test11(i32 %X) {
 264 ; CHECK-LABEL: @test11(
 265 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 2147483647
 266 ; CHECK-NEXT:    ret i32 [[AND]]
 267 ;
 268   %cmp = icmp sgt i32 %X, -1
 269   %and = and i32 %X, 2147483647
 270   %cond = select i1 %cmp, i32 %X, i32 %and
 271   ret i32 %cond
 272 }
 273
 274 define <2 x i8> @test11vec(<2 x i8> %X) {
 275 ; CHECK-LABEL: @test11vec(
 276 ; CHECK-NEXT:    [[AND:%.*]] = and <2 x i8> [[X:%.*]], <i8 127, i8 127>
 277 ; CHECK-NEXT:    ret <2 x i8> [[AND]]
 278 ;
 279   %cmp = icmp sgt <2 x i8> %X, <i8 -1, i8 -1>
 280   %and = and <2 x i8> %X, <i8 127, i8 127>
 281   %sel = select <2 x i1> %cmp, <2 x i8> %X, <2 x i8> %and
 282   ret <2 x i8> %sel
 283 }
 284
 285 define i32 @test12(i32 %X) {
 286 ; CHECK-LABEL: @test12(
 287 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 3
 288 ; CHECK-NEXT:    ret i32 [[AND]]
 289 ;
 290   %cmp = icmp ult i32 %X, 4
 291   %and = and i32 %X, 3
 292   %cond = select i1 %cmp, i32 %X, i32 %and
 293   ret i32 %cond
 294 }
 295
 296 ; Same as above, but the compare isn't canonical
 297 define i32 @test12noncanon(i32 %X) {
 298 ; CHECK-LABEL: @test12noncanon(
 299 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 3
 300 ; CHECK-NEXT:    ret i32 [[AND]]
 301 ;
 302   %cmp = icmp ule i32 %X, 3
 303   %and = and i32 %X, 3
 304   %cond = select i1 %cmp, i32 %X, i32 %and
 305   ret i32 %cond
 306 }
 307
 308 define i32 @test13(i32 %X) {
 309 ; CHECK-LABEL: @test13(
 310 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 3
 311 ; CHECK-NEXT:    ret i32 [[AND]]
 312 ;
 313   %cmp = icmp ugt i32 %X, 3
 314   %and = and i32 %X, 3
 315   %cond = select i1 %cmp, i32 %and, i32 %X
 316   ret i32 %cond
 317 }
 318
 319 ; Same as above, but the compare isn't canonical
 320 define i32 @test13noncanon(i32 %X) {
 321 ; CHECK-LABEL: @test13noncanon(
 322 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 3
 323 ; CHECK-NEXT:    ret i32 [[AND]]
 324 ;
 325   %cmp = icmp uge i32 %X, 4
 326   %and = and i32 %X, 3
 327   %cond = select i1 %cmp, i32 %and, i32 %X
 328   ret i32 %cond
 329 }
 330
 331 define i32 @select_icmp_and_8_eq_0_or_8(i32 %x) {
 332 ; CHECK-LABEL: @select_icmp_and_8_eq_0_or_8(
 333 ; CHECK-NEXT:    [[OR:%.*]] = or i32 [[X:%.*]], 8
 334 ; CHECK-NEXT:    ret i32 [[OR]]
 335 ;
 336   %and = and i32 %x, 8
 337   %cmp = icmp eq i32 %and, 0
 338   %or = or i32 %x, 8
 339   %sel = select i1 %cmp, i32 %or, i32 %x
 340   ret i32 %sel
 341 }
 342
 343 define i32 @select_icmp_and_8_eq_0_or_8_alt(i32 %x) {
 344 ; CHECK-LABEL: @select_icmp_and_8_eq_0_or_8_alt(
 345 ; CHECK-NEXT:    [[OR:%.*]] = or i32 [[X:%.*]], 8
 346 ; CHECK-NEXT:    ret i32 [[OR]]
 347 ;
 348   %and = and i32 %x, 8
 349   %cmp = icmp ne i32 %and, 0
 350   %or = or i32 %x, 8
 351   %sel = select i1 %cmp, i32 %x, i32 %or
 352   ret i32 %sel
 353 }
 354
 355 define i32 @select_icmp_and_8_ne_0_or_8(i32 %x) {
 356 ; CHECK-LABEL: @select_icmp_and_8_ne_0_or_8(
 357 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 358 ;
 359   %and = and i32 %x, 8
 360   %cmp = icmp ne i32 %and, 0
 361   %or = or i32 %x, 8
 362   %sel = select i1 %cmp, i32 %or, i32 %x
 363   ret i32 %sel
 364 }
 365
 366 define i32 @select_icmp_and_8_ne_0_or_8_alt(i32 %x) {
 367 ; CHECK-LABEL: @select_icmp_and_8_ne_0_or_8_alt(
 368 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 369 ;
 370   %and = and i32 %x, 8
 371   %cmp = icmp eq i32 %and, 0
 372   %or = or i32 %x, 8
 373   %sel = select i1 %cmp, i32 %x, i32 %or
 374   ret i32 %sel
 375 }
 376
 377 define i32 @select_icmp_and_8_eq_0_and_not_8(i32 %x) {
 378 ; CHECK-LABEL: @select_icmp_and_8_eq_0_and_not_8(
 379 ; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[X:%.*]], -9
 380 ; CHECK-NEXT:    ret i32 [[AND1]]
 381 ;
 382   %and = and i32 %x, 8
 383   %cmp = icmp eq i32 %and, 0
 384   %and1 = and i32 %x, -9
 385   %sel = select i1 %cmp, i32 %x, i32 %and1
 386   ret i32 %sel
 387 }
 388
 389 define i32 @select_icmp_and_8_eq_0_and_not_8_alt(i32 %x) {
 390 ; CHECK-LABEL: @select_icmp_and_8_eq_0_and_not_8_alt(
 391 ; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[X:%.*]], -9
 392 ; CHECK-NEXT:    ret i32 [[AND1]]
 393 ;
 394   %and = and i32 %x, 8
 395   %cmp = icmp ne i32 %and, 0
 396   %and1 = and i32 %x, -9
 397   %sel = select i1 %cmp, i32 %and1, i32 %x
 398   ret i32 %sel
 399 }
 400
 401 define i32 @select_icmp_and_8_ne_0_and_not_8(i32 %x) {
 402 ; CHECK-LABEL: @select_icmp_and_8_ne_0_and_not_8(
 403 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 404 ;
 405   %and = and i32 %x, 8
 406   %cmp = icmp ne i32 %and, 0
 407   %and1 = and i32 %x, -9
 408   %sel = select i1 %cmp, i32 %x, i32 %and1
 409   ret i32 %sel
 410 }
 411
 412 define i32 @select_icmp_and_8_ne_0_and_not_8_alt(i32 %x) {
 413 ; CHECK-LABEL: @select_icmp_and_8_ne_0_and_not_8_alt(
 414 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 415 ;
 416   %and = and i32 %x, 8
 417   %cmp = icmp eq i32 %and, 0
 418   %and1 = and i32 %x, -9
 419   %sel = select i1 %cmp, i32 %and1, i32 %x
 420   ret i32 %sel
 421 }
 422
 423 ; PR28466: https://llvm.org/bugs/show_bug.cgi?id=28466
 424 ; Each of the previous 8 patterns has a variant that replaces the
 425 ; 'and' with a 'trunc' and the icmp eq/ne with icmp slt/sgt.
 426
 427 define i32 @select_icmp_trunc_8_ne_0_or_128(i32 %x) {
 428 ; CHECK-LABEL: @select_icmp_trunc_8_ne_0_or_128(
 429 ; CHECK-NEXT:    [[OR:%.*]] = or i32 [[X:%.*]], 128
 430 ; CHECK-NEXT:    ret i32 [[OR]]
 431 ;
 432   %trunc = trunc i32 %x to i8
 433   %cmp = icmp sgt i8 %trunc, -1
 434   %or = or i32 %x, 128
 435   %sel = select i1 %cmp, i32 %or, i32 %x
 436   ret i32 %sel
 437 }
 438
 439 define i32 @select_icmp_trunc_8_ne_0_or_128_alt(i32 %x) {
 440 ; CHECK-LABEL: @select_icmp_trunc_8_ne_0_or_128_alt(
 441 ; CHECK-NEXT:    [[OR:%.*]] = or i32 [[X:%.*]], 128
 442 ; CHECK-NEXT:    ret i32 [[OR]]
 443 ;
 444   %trunc = trunc i32 %x to i8
 445   %cmp = icmp slt i8 %trunc, 0
 446   %or = or i32 %x, 128
 447   %sel = select i1 %cmp, i32 %x, i32 %or
 448   ret i32 %sel
 449 }
 450
 451 define i32 @select_icmp_trunc_8_eq_0_or_128(i32 %x) {
 452 ; CHECK-LABEL: @select_icmp_trunc_8_eq_0_or_128(
 453 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 454 ;
 455   %trunc = trunc i32 %x to i8
 456   %cmp = icmp slt i8 %trunc, 0
 457   %or = or i32 %x, 128
 458   %sel = select i1 %cmp, i32 %or, i32 %x
 459   ret i32 %sel
 460 }
 461
 462 define i32 @select_icmp_trunc_8_eq_0_or_128_alt(i32 %x) {
 463 ; CHECK-LABEL: @select_icmp_trunc_8_eq_0_or_128_alt(
 464 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 465 ;
 466   %trunc = trunc i32 %x to i8
 467   %cmp = icmp sgt i8 %trunc, -1
 468   %or = or i32 %x, 128
 469   %sel = select i1 %cmp, i32 %x, i32 %or
 470   ret i32 %sel
 471 }
 472
 473 define i32 @select_icmp_trunc_8_eq_0_and_not_8(i32 %x) {
 474 ; CHECK-LABEL: @select_icmp_trunc_8_eq_0_and_not_8(
 475 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], -9
 476 ; CHECK-NEXT:    ret i32 [[AND]]
 477 ;
 478   %trunc = trunc i32 %x to i4
 479   %cmp = icmp sgt i4 %trunc, -1
 480   %and = and i32 %x, -9
 481   %sel = select i1 %cmp, i32 %x, i32 %and
 482   ret i32 %sel
 483 }
 484
 485 define i32 @select_icmp_trunc_8_eq_0_and_not_8_alt(i32 %x) {
 486 ; CHECK-LABEL: @select_icmp_trunc_8_eq_0_and_not_8_alt(
 487 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], -9
 488 ; CHECK-NEXT:    ret i32 [[AND]]
 489 ;
 490   %trunc = trunc i32 %x to i4
 491   %cmp = icmp slt i4 %trunc, 0
 492   %and = and i32 %x, -9
 493   %sel = select i1 %cmp, i32 %and, i32 %x
 494   ret i32 %sel
 495 }
 496
 497 define i32 @select_icmp_trunc_8_ne_0_and_not_8(i32 %x) {
 498 ; CHECK-LABEL: @select_icmp_trunc_8_ne_0_and_not_8(
 499 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 500 ;
 501   %trunc = trunc i32 %x to i4
 502   %cmp = icmp slt i4 %trunc, 0
 503   %and = and i32 %x, -9
 504   %sel = select i1 %cmp, i32 %x, i32 %and
 505   ret i32 %sel
 506 }
 507
 508 define i32 @select_icmp_trunc_8_ne_0_and_not_8_alt(i32 %x) {
 509 ; CHECK-LABEL: @select_icmp_trunc_8_ne_0_and_not_8_alt(
 510 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 511 ;
 512   %trunc = trunc i32 %x to i4
 513   %cmp = icmp sgt i4 %trunc, -1
 514   %and = and i32 %x, -9
 515   %sel = select i1 %cmp, i32 %and, i32 %x
 516   ret i32 %sel
 517 }
 518
 519 ; Make sure that at least a few of the same patterns are repeated with vector types.
 520
 521 define <2 x i32> @select_icmp_and_8_ne_0_and_not_8_vec(<2 x i32> %x) {
 522 ; CHECK-LABEL: @select_icmp_and_8_ne_0_and_not_8_vec(
 523 ; CHECK-NEXT:    ret <2 x i32> [[X:%.*]]
 524 ;
 525   %and = and <2 x i32> %x, <i32 8, i32 8>
 526   %cmp = icmp ne <2 x i32> %and, zeroinitializer
 527   %and1 = and <2 x i32> %x, <i32 -9, i32 -9>
 528   %sel = select <2 x i1> %cmp, <2 x i32> %x, <2 x i32> %and1
 529   ret <2 x i32> %sel
 530 }
 531
 532 define <2 x i32> @select_icmp_trunc_8_ne_0_and_not_8_alt_vec(<2 x i32> %x) {
 533 ; CHECK-LABEL: @select_icmp_trunc_8_ne_0_and_not_8_alt_vec(
 534 ; CHECK-NEXT:    ret <2 x i32> [[X:%.*]]
 535 ;
 536   %trunc = trunc <2 x i32> %x to <2 x i4>
 537   %cmp = icmp sgt <2 x i4> %trunc, <i4 -1, i4 -1>
 538   %and = and <2 x i32> %x, <i32 -9, i32 -9>
 539   %sel = select <2 x i1> %cmp, <2 x i32> %and, <2 x i32> %x
 540   ret <2 x i32> %sel
 541 }
 542
 543 ; Insert a bit from x into y? This should be possible in InstCombine, but not InstSimplify?
 544
 545 define i32 @select_icmp_x_and_8_eq_0_y_and_not_8(i32 %x, i32 %y) {
 546 ; CHECK-LABEL: @select_icmp_x_and_8_eq_0_y_and_not_8(
 547 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 8
 548 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[AND]], 0
 549 ; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[Y:%.*]], -9
 550 ; CHECK-NEXT:    [[Y_AND1:%.*]] = select i1 [[CMP]], i32 [[Y]], i32 [[AND1]]
 551 ; CHECK-NEXT:    ret i32 [[Y_AND1]]
 552 ;
 553   %and = and i32 %x, 8
 554   %cmp = icmp eq i32 %and, 0
 555   %and1 = and i32 %y, -9
 556   %y.and1 = select i1 %cmp, i32 %y, i32 %and1
 557   ret i32 %y.and1
 558 }
 559
 560 define i64 @select_icmp_x_and_8_eq_0_y64_and_not_8(i32 %x, i64 %y) {
 561 ; CHECK-LABEL: @select_icmp_x_and_8_eq_0_y64_and_not_8(
 562 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 8
 563 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[AND]], 0
 564 ; CHECK-NEXT:    [[AND1:%.*]] = and i64 [[Y:%.*]], -9
 565 ; CHECK-NEXT:    [[Y_AND1:%.*]] = select i1 [[CMP]], i64 [[Y]], i64 [[AND1]]
 566 ; CHECK-NEXT:    ret i64 [[Y_AND1]]
 567 ;
 568   %and = and i32 %x, 8
 569   %cmp = icmp eq i32 %and, 0
 570   %and1 = and i64 %y, -9
 571   %y.and1 = select i1 %cmp, i64 %y, i64 %and1
 572   ret i64 %y.and1
 573 }
 574
 575 define i64 @select_icmp_x_and_8_ne_0_y64_and_not_8(i32 %x, i64 %y) {
 576 ; CHECK-LABEL: @select_icmp_x_and_8_ne_0_y64_and_not_8(
 577 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 8
 578 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[AND]], 0
 579 ; CHECK-NEXT:    [[AND1:%.*]] = and i64 [[Y:%.*]], -9
 580 ; CHECK-NEXT:    [[AND1_Y:%.*]] = select i1 [[CMP]], i64 [[AND1]], i64 [[Y]]
 581 ; CHECK-NEXT:    ret i64 [[AND1_Y]]
 582 ;
 583   %and = and i32 %x, 8
 584   %cmp = icmp eq i32 %and, 0
 585   %and1 = and i64 %y, -9
 586   %and1.y = select i1 %cmp, i64 %and1, i64 %y
 587   ret i64 %and1.y
 588 }
 589
 590 ; Don't crash on a pointer or aggregate type.
 591
 592 define ptr @select_icmp_pointers(ptr %x, ptr %y) {
 593 ; CHECK-LABEL: @select_icmp_pointers(
 594 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt ptr [[X:%.*]], null
 595 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[CMP]], ptr [[X]], ptr [[Y:%.*]]
 596 ; CHECK-NEXT:    ret ptr [[SEL]]
 597 ;
 598   %cmp = icmp slt ptr %x, null
 599   %sel = select i1 %cmp, ptr %x, ptr %y
 600   ret ptr %sel
 601 }
 602
 603 ; If the condition is known, we don't need to select, but we're not
 604 ; doing this fold here to avoid compile-time cost.
 605
 606 declare void @llvm.assume(i1)
 607
 608 define i8 @assume_sel_cond(i1 %cond, i8 %x, i8 %y) {
 609 ; CHECK-LABEL: @assume_sel_cond(
 610 ; CHECK-NEXT:    call void @llvm.assume(i1 [[COND:%.*]])
 611 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[COND]], i8 [[X:%.*]], i8 [[Y:%.*]]
 612 ; CHECK-NEXT:    ret i8 [[SEL]]
 613 ;
 614   call void @llvm.assume(i1 %cond)
 615   %sel = select i1 %cond, i8 %x, i8 %y
 616   ret i8 %sel
 617 }
 618
 619 define i8 @do_not_assume_sel_cond(i1 %cond, i8 %x, i8 %y) {
 620 ; CHECK-LABEL: @do_not_assume_sel_cond(
 621 ; CHECK-NEXT:    [[NOTCOND:%.*]] = icmp eq i1 [[COND:%.*]], false
 622 ; CHECK-NEXT:    call void @llvm.assume(i1 [[NOTCOND]])
 623 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[COND]], i8 [[X:%.*]], i8 [[Y:%.*]]
 624 ; CHECK-NEXT:    ret i8 [[SEL]]
 625 ;
 626   %notcond = icmp eq i1 %cond, false
 627   call void @llvm.assume(i1 %notcond)
 628   %sel = select i1 %cond, i8 %x, i8 %y
 629   ret i8 %sel
 630 }
 631
 632 define ptr @select_icmp_eq_0_gep_operand(ptr %base, i64 %n) {
 633 ; CHECK-LABEL: @select_icmp_eq_0_gep_operand(
 634 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr i32, ptr [[BASE:%.*]], i64 [[N:%.*]]
 635 ; CHECK-NEXT:    ret ptr [[GEP]]
 636 ;
 637   %cond = icmp eq i64 %n, 0
 638   %gep = getelementptr i32, ptr %base, i64 %n
 639   %r = select i1 %cond, ptr %base, ptr %gep
 640   ret ptr %r
 641 }
 642
 643 define ptr @select_icmp_ne_0_gep_operand(ptr %base, i64 %n) {
 644 ; CHECK-LABEL: @select_icmp_ne_0_gep_operand(
 645 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr i32, ptr [[BASE:%.*]], i64 [[N:%.*]]
 646 ; CHECK-NEXT:    ret ptr [[GEP]]
 647 ;
 648   %cond = icmp ne i64 %n, 0
 649   %gep = getelementptr i32, ptr %base, i64 %n
 650   %r = select i1 %cond, ptr %gep, ptr %base
 651   ret ptr %r
 652 }
 653
 654 define i1 @and_cmps(i32 %x) {
 655 ; CHECK-LABEL: @and_cmps(
 656 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i32 [[X:%.*]], 92
 657 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i32 [[X]], 11
 658 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMP1]], i1 [[CMP2]], i1 false
 659 ; CHECK-NEXT:    ret i1 [[R]]
 660 ;
 661   %cmp1 = icmp slt i32 %x, 92
 662   %cmp2 = icmp slt i32 %x, 11
 663   %r = select i1 %cmp1, i1 %cmp2, i1 false
 664   ret i1 %r
 665 }
 666
 667 define <2 x i1> @and_cmps_vector(<2 x i32> %x) {
 668 ; CHECK-LABEL: @and_cmps_vector(
 669 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt <2 x i32> [[X:%.*]], <i32 92, i32 92>
 670 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt <2 x i32> [[X]], <i32 11, i32 11>
 671 ; CHECK-NEXT:    [[R:%.*]] = select <2 x i1> [[CMP1]], <2 x i1> [[CMP2]], <2 x i1> zeroinitializer
 672 ; CHECK-NEXT:    ret <2 x i1> [[R]]
 673 ;
 674   %cmp1 = icmp slt <2 x i32> %x, <i32 92, i32 92>
 675   %cmp2 = icmp slt <2 x i32> %x, <i32 11, i32 11>
 676   %r = select <2 x i1> %cmp1, <2 x i1> %cmp2, <2 x i1> <i1 false, i1 false>
 677   ret <2 x i1> %r
 678 }
 679
 680 define i1 @or_cmps(float %x) {
 681 ; CHECK-LABEL: @or_cmps(
 682 ; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno float [[X:%.*]], 4.200000e+01
 683 ; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno float [[X]], 5.200000e+01
 684 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMP1]], i1 true, i1 [[CMP2]]
 685 ; CHECK-NEXT:    ret i1 [[R]]
 686 ;
 687   %cmp1 = fcmp uno float %x, 42.0
 688   %cmp2 = fcmp uno float %x, 52.0
 689   %r = select i1 %cmp1, i1 true, i1 %cmp2
 690   ret i1 %r
 691 }
 692
 693 define <2 x i1> @or_logic_vector(<2 x i1> %x, <2 x i1> %y) {
 694 ; CHECK-LABEL: @or_logic_vector(
 695 ; CHECK-NEXT:    ret <2 x i1> [[X:%.*]]
 696 ;
 697   %a = and <2 x i1> %x, %y
 698   %r = select <2 x i1> %x, <2 x i1> <i1 true, i1 true>, <2 x i1> %a
 699   ret <2 x i1> %r
 700 }
 701
 702 define i1 @and_not_cmps(i32 %x) {
 703 ; CHECK-LABEL: @and_not_cmps(
 704 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i32 [[X:%.*]], 92
 705 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i32 [[X]], 11
 706 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMP1]], i1 false, i1 [[CMP2]]
 707 ; CHECK-NEXT:    ret i1 [[R]]
 708 ;
 709   %cmp1 = icmp slt i32 %x, 92
 710   %cmp2 = icmp slt i32 %x, 11
 711   %r = select i1 %cmp1, i1 false, i1 %cmp2
 712   ret i1 %r
 713 }
 714
 715 define i1 @or_not_cmps(i32 %x) {
 716 ; CHECK-LABEL: @or_not_cmps(
 717 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i32 [[X:%.*]], 92
 718 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i32 [[X]], 11
 719 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMP1]], i1 [[CMP2]], i1 true
 720 ; CHECK-NEXT:    ret i1 [[R]]
 721 ;
 722   %cmp1 = icmp slt i32 %x, 92
 723   %cmp2 = icmp slt i32 %x, 11
 724   %r = select i1 %cmp1, i1 %cmp2, i1 true
 725   ret i1 %r
 726 }
 727
 728 define i8 @and_cmps_wrong_type(i32 %x) {
 729 ; CHECK-LABEL: @and_cmps_wrong_type(
 730 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i32 [[X:%.*]], 92
 731 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i32 [[X]], 11
 732 ; CHECK-NEXT:    [[S:%.*]] = sext i1 [[CMP2]] to i8
 733 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMP1]], i8 [[S]], i8 0
 734 ; CHECK-NEXT:    ret i8 [[R]]
 735 ;
 736   %cmp1 = icmp slt i32 %x, 92
 737   %cmp2 = icmp slt i32 %x, 11
 738   %s = sext i1 %cmp2 to i8
 739   %r = select i1 %cmp1, i8 %s, i8 0
 740   ret i8 %r
 741 }
 742
 743 define i1 @y_might_be_poison(float %x, float %y) {
 744 ; CHECK-LABEL: @y_might_be_poison(
 745 ; CHECK-NEXT:    [[C1:%.*]] = fcmp ord float 0.000000e+00, [[X:%.*]]
 746 ; CHECK-NEXT:    [[C2:%.*]] = fcmp ord float [[X]], [[Y:%.*]]
 747 ; CHECK-NEXT:    [[C3:%.*]] = select i1 [[C1]], i1 [[C2]], i1 false
 748 ; CHECK-NEXT:    ret i1 [[C3]]
 749 ;
 750   %c1 = fcmp ord float 0.0, %x
 751   %c2 = fcmp ord float %x, %y
 752   %c3 = select i1 %c1, i1 %c2, i1 false
 753   ret i1 %c3
 754 }
 755
 756 ; Negative tests to ensure we don't remove selects with undef true/false values.
 757 ; See https://bugs.llvm.org/show_bug.cgi?id=31633
 758 ; https://lists.llvm.org/pipermail/llvm-dev/2016-October/106182.html
 759 ; https://reviews.llvm.org/D83360
 760 define i32 @false_undef(i1 %cond, i32 %x) {
 761 ; CHECK-LABEL: @false_undef(
 762 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[COND:%.*]], i32 [[X:%.*]], i32 undef
 763 ; CHECK-NEXT:    ret i32 [[S]]
 764 ;
 765   %s = select i1 %cond, i32 %x, i32 undef
 766   ret i32 %s
 767 }
 768
 769 define i32 @true_undef(i1 %cond, i32 %x) {
 770 ; CHECK-LABEL: @true_undef(
 771 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[COND:%.*]], i32 undef, i32 [[X:%.*]]
 772 ; CHECK-NEXT:    ret i32 [[S]]
 773 ;
 774   %s = select i1 %cond, i32 undef, i32 %x
 775   ret i32 %s
 776 }
 777
 778 define <2 x i32> @false_undef_vec(i1 %cond, <2 x i32> %x) {
 779 ; CHECK-LABEL: @false_undef_vec(
 780 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[COND:%.*]], <2 x i32> [[X:%.*]], <2 x i32> undef
 781 ; CHECK-NEXT:    ret <2 x i32> [[S]]
 782 ;
 783   %s = select i1 %cond, <2 x i32> %x, <2 x i32> undef
 784   ret <2 x i32> %s
 785 }
 786
 787 define <2 x i32> @true_undef_vec(i1 %cond, <2 x i32> %x) {
 788 ; CHECK-LABEL: @true_undef_vec(
 789 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[COND:%.*]], <2 x i32> undef, <2 x i32> [[X:%.*]]
 790 ; CHECK-NEXT:    ret <2 x i32> [[S]]
 791 ;
 792   %s = select i1 %cond, <2 x i32> undef, <2 x i32> %x
 793   ret <2 x i32> %s
 794 }
 795
 796 ; These can be folded because the other value is guaranteed not to be poison.
 797 define i32 @false_undef_true_constant(i1 %cond) {
 798 ; CHECK-LABEL: @false_undef_true_constant(
 799 ; CHECK-NEXT:    ret i32 10
 800 ;
 801   %s = select i1 %cond, i32 10, i32 undef
 802   ret i32 %s
 803 }
 804
 805 define i32 @true_undef_false_constant(i1 %cond) {
 806 ; CHECK-LABEL: @true_undef_false_constant(
 807 ; CHECK-NEXT:    ret i32 20
 808 ;
 809   %s = select i1 %cond, i32 undef, i32 20
 810   ret i32 %s
 811 }
 812
 813 define <2 x i32> @false_undef_true_constant_vec(i1 %cond) {
 814 ; CHECK-LABEL: @false_undef_true_constant_vec(
 815 ; CHECK-NEXT:    ret <2 x i32> <i32 42, i32 -42>
 816 ;
 817   %s = select i1 %cond, <2 x i32> <i32 42, i32 -42>, <2 x i32> undef
 818   ret <2 x i32> %s
 819 }
 820
 821 define <2 x i32> @true_undef_false_constant_vec(i1 %cond) {
 822 ; CHECK-LABEL: @true_undef_false_constant_vec(
 823 ; CHECK-NEXT:    ret <2 x i32> <i32 -42, i32 42>
 824 ;
 825   %s = select i1 %cond, <2 x i32> undef, <2 x i32> <i32 -42, i32 42>
 826   ret <2 x i32> %s
 827 }
 828
 829 ; If one input is undef and the other is freeze, we can fold it to the freeze.
 830 define i32 @false_undef_true_freeze(i1 %cond, i32 %x) {
 831 ; CHECK-LABEL: @false_undef_true_freeze(
 832 ; CHECK-NEXT:    [[XF:%.*]] = freeze i32 [[X:%.*]]
 833 ; CHECK-NEXT:    ret i32 [[XF]]
 834 ;
 835   %xf = freeze i32 %x
 836   %s = select i1 %cond, i32 %xf, i32 undef
 837   ret i32 %s
 838 }
 839
 840 define i32 @false_undef_false_freeze(i1 %cond, i32 %x) {
 841 ; CHECK-LABEL: @false_undef_false_freeze(
 842 ; CHECK-NEXT:    [[XF:%.*]] = freeze i32 [[X:%.*]]
 843 ; CHECK-NEXT:    ret i32 [[XF]]
 844 ;
 845   %xf = freeze i32 %x
 846   %s = select i1 %cond, i32 undef, i32 %xf
 847   ret i32 %s
 848 }
 849
 850 @g = external global i32, align 1
 851
 852 define <2 x i32> @false_undef_true_constextpr_vec(i1 %cond) {
 853 ; CHECK-LABEL: @false_undef_true_constextpr_vec(
 854 ; CHECK-NEXT:    ret <2 x i32> <i32 ptrtoint (ptr @g to i32), i32 ptrtoint (ptr @g to i32)>
 855 ;
 856   %s = select i1 %cond, <2 x i32> <i32 undef, i32 ptrtoint (ptr @g to i32)>, <2 x i32> <i32 ptrtoint (ptr @g to i32), i32 undef>
 857   ret <2 x i32> %s
 858 }
 859
 860 define i32 @all_constant_true_undef() {
 861 ; CHECK-LABEL: @all_constant_true_undef(
 862 ; CHECK-NEXT:    ret i32 1
 863 ;
 864   %s = select i1 ptrtoint (ptr @all_constant_true_undef to i1), i32 undef, i32 1
 865   ret i32 %s
 866 }
 867
 868 define float @all_constant_false_undef() {
 869 ; CHECK-LABEL: @all_constant_false_undef(
 870 ; CHECK-NEXT:    ret float 1.000000e+00
 871 ;
 872   %s = select i1 ptrtoint (ptr @all_constant_false_undef to i1), float undef, float 1.0
 873   ret float %s
 874 }
 875
 876 define <2 x i32> @all_constant_true_undef_vec() {
 877 ; CHECK-LABEL: @all_constant_true_undef_vec(
 878 ; CHECK-NEXT:    ret <2 x i32> <i32 1, i32 -1>
 879 ;
 880   %s = select i1 ptrtoint (ptr @all_constant_true_undef_vec to i1), <2 x i32> undef, <2 x i32> <i32 1, i32 -1>
 881   ret <2 x i32> %s
 882 }
 883
 884 define <2 x float> @all_constant_false_undef_vec() {
 885 ; CHECK-LABEL: @all_constant_false_undef_vec(
 886 ; CHECK-NEXT:    ret <2 x float> <float 1.000000e+00, float -1.000000e+00>
 887 ;
 888   %s = select i1 ptrtoint (ptr @all_constant_false_undef_vec to i1), <2 x float> undef, <2 x float> <float 1.0, float -1.0>
 889   ret <2 x float> %s
 890 }
 891
 892 ; Negative tests. Don't fold if the non-undef operand is a constexpr.
 893 define i32 @all_constant_false_undef_true_constexpr() {
 894 ; CHECK-LABEL: @all_constant_false_undef_true_constexpr(
 895 ; CHECK-NEXT:    ret i32 ptrtoint (ptr @all_constant_false_undef_true_constexpr to i32)
 896 ;
 897   %s = select i1 ptrtoint (ptr @all_constant_false_undef_true_constexpr to i1), i32 ptrtoint (ptr @all_constant_false_undef_true_constexpr to i32), i32 undef
 898   ret i32 %s
 899 }
 900
 901 define i32 @all_constant_true_undef_false_constexpr() {
 902 ; CHECK-LABEL: @all_constant_true_undef_false_constexpr(
 903 ; CHECK-NEXT:    ret i32 ptrtoint (ptr @all_constant_true_undef_false_constexpr to i32)
 904 ;
 905   %s = select i1 ptrtoint (ptr @all_constant_true_undef_false_constexpr to i1), i32 undef, i32 ptrtoint (ptr @all_constant_true_undef_false_constexpr to i32)
 906   ret i32 %s
 907 }
 908
 909 ; Negative tests. Don't fold if the non-undef operand is a vector containing a constexpr.
 910 define <2 x i32> @all_constant_false_undef_true_constexpr_vec() {
 911 ; CHECK-LABEL: @all_constant_false_undef_true_constexpr_vec(
 912 ; CHECK-NEXT:    ret <2 x i32> <i32 ptrtoint (ptr @all_constant_false_undef_true_constexpr_vec to i32), i32 -1>
 913 ;
 914   %s = select i1 ptrtoint (ptr @all_constant_false_undef_true_constexpr_vec to i1), <2 x i32> <i32 ptrtoint (ptr @all_constant_false_undef_true_constexpr_vec to i32), i32 -1>, <2 x i32> undef
 915   ret <2 x i32> %s
 916 }
 917
 918 define <2 x i32> @all_constant_true_undef_false_constexpr_vec() {
 919 ; CHECK-LABEL: @all_constant_true_undef_false_constexpr_vec(
 920 ; CHECK-NEXT:    ret <2 x i32> <i32 -1, i32 ptrtoint (ptr @all_constant_true_undef_false_constexpr_vec to i32)>
 921 ;
 922   %s = select i1 ptrtoint (ptr @all_constant_true_undef_false_constexpr_vec to i1), <2 x i32> undef, <2 x i32><i32 -1, i32 ptrtoint (ptr @all_constant_true_undef_false_constexpr_vec to i32)>
 923   ret <2 x i32> %s
 924 }
 925
 926 define i1 @expand_binop_undef(i32 %x, i32 %y) {
 927 ; CHECK-LABEL: @expand_binop_undef(
 928 ; CHECK-NEXT:    [[CMP9_NOT_1:%.*]] = icmp eq i32 [[X:%.*]], [[Y:%.*]]
 929 ; CHECK-NEXT:    [[CMP15:%.*]] = icmp slt i32 [[X]], [[Y]]
 930 ; CHECK-NEXT:    [[SPEC_SELECT39:%.*]] = select i1 [[CMP9_NOT_1]], i1 undef, i1 [[CMP15]]
 931 ; CHECK-NEXT:    [[SPEC_SELECT40:%.*]] = xor i1 [[CMP9_NOT_1]], true
 932 ; CHECK-NEXT:    [[SPEC_SELECT:%.*]] = and i1 [[SPEC_SELECT39]], [[SPEC_SELECT40]]
 933 ; CHECK-NEXT:    ret i1 [[SPEC_SELECT]]
 934 ;
 935   %cmp9.not.1 = icmp eq i32 %x, %y
 936   %cmp15 = icmp slt i32 %x, %y
 937   %spec.select39 = select i1 %cmp9.not.1, i1 undef, i1 %cmp15
 938   %spec.select40 = xor i1 %cmp9.not.1, 1
 939   %spec.select  = and i1 %spec.select39, %spec.select40
 940   ret i1 %spec.select
 941 }
 942
 943 define i32 @pr47322_more_poisonous_replacement(i32 %arg) {
 944 ; CHECK-LABEL: @pr47322_more_poisonous_replacement(
 945 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[ARG:%.*]], 0
 946 ; CHECK-NEXT:    [[TRAILING:%.*]] = call i32 @llvm.cttz.i32(i32 [[ARG]], i1 immarg true)
 947 ; CHECK-NEXT:    [[SHIFTED:%.*]] = lshr i32 [[ARG]], [[TRAILING]]
 948 ; CHECK-NEXT:    [[R1_SROA_0_1:%.*]] = select i1 [[CMP]], i32 0, i32 [[SHIFTED]]
 949 ; CHECK-NEXT:    ret i32 [[R1_SROA_0_1]]
 950 ;
 951   %cmp = icmp eq i32 %arg, 0
 952   %trailing = call i32 @llvm.cttz.i32(i32 %arg, i1 immarg true)
 953   %shifted = lshr i32 %arg, %trailing
 954   %r1.sroa.0.1 = select i1 %cmp, i32 0, i32 %shifted
 955   ret i32 %r1.sroa.0.1
 956 }
 957 declare i32 @llvm.cttz.i32(i32, i1 immarg)
 958
 959 ; Partial undef scalable vectors should be ignored.
 960 define <vscale x 2 x i1> @ignore_scalable_undef(<vscale x 2 x i1> %cond) {
 961 ; CHECK-LABEL: @ignore_scalable_undef(
 962 ; CHECK-NEXT:    ret <vscale x 2 x i1> insertelement (<vscale x 2 x i1> undef, i1 true, i32 0)
 963 ;
 964   %vec = insertelement <vscale x 2 x i1> undef, i1 true, i32 0
 965   %s = select <vscale x 2 x i1> %cond, <vscale x 2 x i1> undef, <vscale x 2 x i1> %vec
 966   ret <vscale x 2 x i1> %s
 967 }
 968
 969 define i32 @select_neutral_add_rhs(i32 %x, i32 %y) {
 970 ; CHECK-LABEL: @select_neutral_add_rhs(
 971 ; CHECK-NEXT:    [[ADD:%.*]] = add i32 [[X:%.*]], [[Y:%.*]]
 972 ; CHECK-NEXT:    ret i32 [[ADD]]
 973 ;
 974   %cmp = icmp ne i32 %y, 0
 975   %add = add i32 %x, %y
 976   %sel = select i1 %cmp, i32 %add, i32 %x
 977   ret i32 %sel
 978 }
 979
 980 define i32 @select_neutral_add_lhs(i32 %x, i32 %y) {
 981 ; CHECK-LABEL: @select_neutral_add_lhs(
 982 ; CHECK-NEXT:    [[ADD:%.*]] = add i32 [[Y:%.*]], [[X:%.*]]
 983 ; CHECK-NEXT:    ret i32 [[ADD]]
 984 ;
 985   %cmp = icmp ne i32 %y, 0
 986   %add = add i32 %y, %x
 987   %sel = select i1 %cmp, i32 %add, i32 %x
 988   ret i32 %sel
 989 }
 990
 991 define <2 x i32> @select_neutral_add_rhs_vec(<2 x i32> %x, <2 x i32> %y) {
 992 ; CHECK-LABEL: @select_neutral_add_rhs_vec(
 993 ; CHECK-NEXT:    [[ADD:%.*]] = add <2 x i32> [[X:%.*]], [[Y:%.*]]
 994 ; CHECK-NEXT:    ret <2 x i32> [[ADD]]
 995 ;
 996   %cmp = icmp ne <2 x i32> %y, zeroinitializer
 997   %add = add <2 x i32> %x, %y
 998   %sel = select <2 x i1> %cmp, <2 x i32> %add, <2 x i32> %x
 999   ret <2 x i32> %sel
1000 }
1001
1002 define <2 x i32> @select_neutral_add_lhs_vec(<2 x i32> %x, <2 x i32> %y) {
1003 ; CHECK-LABEL: @select_neutral_add_lhs_vec(
1004 ; CHECK-NEXT:    [[ADD:%.*]] = add <2 x i32> [[Y:%.*]], [[X:%.*]]
1005 ; CHECK-NEXT:    ret <2 x i32> [[ADD]]
1006 ;
1007   %cmp = icmp ne <2 x i32> %y, zeroinitializer
1008   %add = add <2 x i32> %y, %x
1009   %sel = select <2 x i1> %cmp, <2 x i32> %add, <2 x i32> %x
1010   ret <2 x i32> %sel
1011 }
1012
1013 define i32 @select_neutral_sub_rhs(i32 %x, i32 %y) {
1014 ; CHECK-LABEL: @select_neutral_sub_rhs(
1015 ; CHECK-NEXT:    [[ADD:%.*]] = sub i32 [[X:%.*]], [[Y:%.*]]
1016 ; CHECK-NEXT:    ret i32 [[ADD]]
1017 ;
1018   %cmp = icmp ne i32 %y, 0
1019   %add = sub i32 %x, %y
1020   %sel = select i1 %cmp, i32 %add, i32 %x
1021   ret i32 %sel
1022 }
1023
1024 define i32 @select_neutral_sub_lhs(i32 %x, i32 %y) {
1025 ; CHECK-LABEL: @select_neutral_sub_lhs(
1026 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[Y:%.*]], 0
1027 ; CHECK-NEXT:    [[ADD:%.*]] = sub i32 [[Y]], [[X:%.*]]
1028 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[CMP]], i32 [[ADD]], i32 [[X]]
1029 ; CHECK-NEXT:    ret i32 [[SEL]]
1030 ;
1031   %cmp = icmp ne i32 %y, 0
1032   %add = sub i32 %y, %x
1033   %sel = select i1 %cmp, i32 %add, i32 %x
1034   ret i32 %sel
1035 }
1036
1037 define i32 @select_ctpop_zero(i32 %x) {
1038 ; CHECK-LABEL: @select_ctpop_zero(
1039 ; CHECK-NEXT:    [[T1:%.*]] = call i32 @llvm.ctpop.i32(i32 [[X:%.*]])
1040 ; CHECK-NEXT:    ret i32 [[T1]]
1041 ;
1042   %t0 = icmp eq i32 %x, 0
1043   %t1 = call i32 @llvm.ctpop.i32(i32 %x)
1044   %sel = select i1 %t0, i32 0, i32 %t1
1045   ret i32 %sel
1046 }
1047
1048 ; FIXME: This is safe to fold.
1049 define <2 x i32> @select_ctpop_zero_vec(<2 x i32> %x) {
1050 ; CHECK-LABEL: @select_ctpop_zero_vec(
1051 ; CHECK-NEXT:    [[T0:%.*]] = icmp eq <2 x i32> [[X:%.*]], zeroinitializer
1052 ; CHECK-NEXT:    [[T1:%.*]] = call <2 x i32> @llvm.ctpop.v2i32(<2 x i32> [[X]])
1053 ; CHECK-NEXT:    [[SEL:%.*]] = select <2 x i1> [[T0]], <2 x i32> zeroinitializer, <2 x i32> [[T1]]
1054 ; CHECK-NEXT:    ret <2 x i32> [[SEL]]
1055 ;
1056   %t0 = icmp eq <2 x i32> %x, zeroinitializer
1057   %t1 = call <2 x i32> @llvm.ctpop.v2i32(<2 x i32> %x)
1058   %sel = select <2 x i1> %t0, <2 x i32> zeroinitializer, <2 x i32> %t1
1059   ret <2 x i32> %sel
1060 }
1061
1062 ; Negative test: Cannot fold due to cross-lane intrinsic.
1063 define <2 x i32> @select_vector_reverse(<2 x i32> %x) {
1064 ; CHECK-LABEL: @select_vector_reverse(
1065 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x i32> [[X:%.*]], zeroinitializer
1066 ; CHECK-NEXT:    [[REV:%.*]] = call <2 x i32> @llvm.experimental.vector.reverse.v2i32(<2 x i32> [[X]])
1067 ; CHECK-NEXT:    [[SEL:%.*]] = select <2 x i1> [[CMP]], <2 x i32> zeroinitializer, <2 x i32> [[REV]]
1068 ; CHECK-NEXT:    ret <2 x i32> [[SEL]]
1069 ;
1070   %cmp = icmp eq <2 x i32> %x, zeroinitializer
1071   %rev = call <2 x i32> @llvm.experimental.vector.reverse.v2i32(<2 x i32> %x)
1072   %sel = select <2 x i1> %cmp, <2 x i32> zeroinitializer, <2 x i32> %rev
1073   ret <2 x i32> %sel
1074 }
1075
1076 declare i32 @llvm.ctpop.i32(i32)
1077 declare <2 x i32> @llvm.ctpop.v2i32(<2 x i32>)
1078 declare <2 x i32> @llvm.experimental.vector.reverse.v2i32(<2 x i32>)
1079
1080 define <2 x i32> @vec_select_no_equivalence(<2 x i32> %x, <2 x i32> %y) {
1081 ; CHECK-LABEL: @vec_select_no_equivalence(
1082 ; CHECK-NEXT:    [[X10:%.*]] = shufflevector <2 x i32> [[X:%.*]], <2 x i32> undef, <2 x i32> <i32 1, i32 0>
1083 ; CHECK-NEXT:    [[COND:%.*]] = icmp eq <2 x i32> [[X]], zeroinitializer
1084 ; CHECK-NEXT:    [[S:%.*]] = select <2 x i1> [[COND]], <2 x i32> [[X10]], <2 x i32> zeroinitializer
1085 ; CHECK-NEXT:    ret <2 x i32> [[S]]
1086 ;
1087   %x10 = shufflevector <2 x i32> %x, <2 x i32> undef, <2 x i32> <i32 1, i32 0>
1088   %cond = icmp eq <2 x i32> %x, zeroinitializer
1089   %s = select <2 x i1> %cond, <2 x i32> %x10, <2 x i32> zeroinitializer
1090   ret <2 x i32> %s
1091 }
1092
1093 define i8 @select_eq_xor_recursive(i8 %a, i8 %b) {
1094 ; CHECK-LABEL: @select_eq_xor_recursive(
1095 ; CHECK-NEXT:    [[XOR:%.*]] = xor i8 [[A:%.*]], [[B:%.*]]
1096 ; CHECK-NEXT:    [[INV:%.*]] = xor i8 [[XOR]], -1
1097 ; CHECK-NEXT:    ret i8 [[INV]]
1098 ;
1099   %xor = xor i8 %a, %b
1100   %inv = xor i8 %xor, -1
1101   %cmp = icmp eq i8 %a, %b
1102   %sel = select i1 %cmp, i8 -1, i8 %inv
1103   ret i8 %sel
1104 }
1105
1106 define i8 @select_eq_xor_recursive2(i8 %a, i8 %b) {
1107 ; CHECK-LABEL: @select_eq_xor_recursive2(
1108 ; CHECK-NEXT:    [[XOR:%.*]] = xor i8 [[A:%.*]], [[B:%.*]]
1109 ; CHECK-NEXT:    [[INV:%.*]] = xor i8 [[XOR]], -1
1110 ; CHECK-NEXT:    [[ADD:%.*]] = add i8 [[INV]], 10
1111 ; CHECK-NEXT:    ret i8 [[ADD]]
1112 ;
1113   %xor = xor i8 %a, %b
1114   %inv = xor i8 %xor, -1
1115   %add = add i8 %inv, 10
1116   %cmp = icmp eq i8 %a, %b
1117   %sel = select i1 %cmp, i8 9, i8 %add
1118   ret i8 %sel
1119 }
1120
1121 define i8 @select_eq_xor_recursive3(i8 %a, i8 %b) {
1122 ; CHECK-LABEL: @select_eq_xor_recursive3(
1123 ; CHECK-NEXT:    [[XOR:%.*]] = xor i8 [[A:%.*]], [[B:%.*]]
1124 ; CHECK-NEXT:    [[INV:%.*]] = xor i8 [[XOR]], -1
1125 ; CHECK-NEXT:    [[ADD:%.*]] = add i8 [[INV]], 10
1126 ; CHECK-NEXT:    [[MUL:%.*]] = mul i8 [[ADD]], 3
1127 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[A]], [[B]]
1128 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[CMP]], i8 9, i8 [[MUL]]
1129 ; CHECK-NEXT:    ret i8 [[SEL]]
1130 ;
1131   %xor = xor i8 %a, %b
1132   %inv = xor i8 %xor, -1
1133   %add = add i8 %inv, 10
1134   %mul = mul i8 %add, 3
1135   %cmp = icmp eq i8 %a, %b
1136   %sel = select i1 %cmp, i8 9, i8 %mul
1137   ret i8 %sel
1138 }
1139
1140 ; Cannot drop select, because this would propagate poison from %a.
1141 define i8 @select_eq_xor_recursive_propagates_poison(i8 %a, i8 %b) {
1142 ; CHECK-LABEL: @select_eq_xor_recursive_propagates_poison(
1143 ; CHECK-NEXT:    [[XOR1:%.*]] = add i8 [[A:%.*]], [[B:%.*]]
1144 ; CHECK-NEXT:    [[XOR2:%.*]] = xor i8 [[A]], [[XOR1]]
1145 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[B]], 0
1146 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[CMP]], i8 0, i8 [[XOR2]]
1147 ; CHECK-NEXT:    ret i8 [[SEL]]
1148 ;
1149   %xor1 = add i8 %a, %b
1150   %xor2 = xor i8 %a, %xor1
1151   %cmp = icmp eq i8 %b, 0
1152   %sel = select i1 %cmp, i8 0, i8 %xor2
1153   ret i8 %sel
1154 }
1155
1156 define i8 @select_eq_and_recursive(i8 %a) {
1157 ; CHECK-LABEL: @select_eq_and_recursive(
1158 ; CHECK-NEXT:    [[NEG:%.*]] = sub i8 0, [[A:%.*]]
1159 ; CHECK-NEXT:    [[AND:%.*]] = and i8 [[NEG]], [[A]]
1160 ; CHECK-NEXT:    [[ADD:%.*]] = add i8 [[AND]], 1
1161 ; CHECK-NEXT:    ret i8 [[ADD]]
1162 ;
1163   %neg = sub i8 0, %a
1164   %and = and i8 %neg, %a
1165   %add = add i8 %and, 1
1166   %cmp = icmp eq i8 %a, 0
1167   %sel = select i1 %cmp, i8 1, i8 %add
1168   ret i8 %sel
1169 }
1170
1171 ; Cannot drop select, because this would propagate poison from %b.
1172 define i8 @select_eq_and_recursive_propagates_poison(i8 %a, i8 %b) {
1173 ; CHECK-LABEL: @select_eq_and_recursive_propagates_poison(
1174 ; CHECK-NEXT:    [[NEG:%.*]] = sub i8 [[B:%.*]], [[A:%.*]]
1175 ; CHECK-NEXT:    [[AND:%.*]] = and i8 [[NEG]], [[A]]
1176 ; CHECK-NEXT:    [[ADD:%.*]] = add i8 [[AND]], 1
1177 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[A]], 0
1178 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[CMP]], i8 1, i8 [[ADD]]
1179 ; CHECK-NEXT:    ret i8 [[SEL]]
1180 ;
1181   %neg = sub i8 %b, %a
1182   %and = and i8 %neg, %a
1183   %add = add i8 %and, 1
1184   %cmp = icmp eq i8 %a, 0
1185   %sel = select i1 %cmp, i8 1, i8 %add
1186   ret i8 %sel
1187 }
1188
1189 define i8 @select_eq_xor_recursive_allow_refinement(i8 %a, i8 %b) {
1190 ; CHECK-LABEL: @select_eq_xor_recursive_allow_refinement(
1191 ; CHECK-NEXT:    ret i8 0
1192 ;
1193   %xor1 = add i8 %a, %b
1194   %xor2 = xor i8 %a, %xor1
1195   %cmp = icmp eq i8 %b, 0
1196   %sel = select i1 %cmp, i8 %xor2, i8 0
1197   ret i8 %sel
1198 }
1199
1200 define i8 @select_eq_mul_absorber(i8 %x, i8 noundef %y) {
1201 ; CHECK-LABEL: @select_eq_mul_absorber(
1202 ; CHECK-NEXT:    [[ADD:%.*]] = add i8 [[X:%.*]], -1
1203 ; CHECK-NEXT:    [[MUL:%.*]] = mul i8 [[ADD]], [[Y:%.*]]
1204 ; CHECK-NEXT:    ret i8 [[MUL]]
1205 ;
1206   %cmp = icmp eq i8 %x, 1
1207   %add = add i8 %x, -1
1208   %mul = mul i8 %add, %y
1209   %sel = select i1 %cmp, i8 0, i8 %mul
1210   ret i8 %sel
1211 }
1212
1213 define i8 @select_eq_mul_not_absorber(i8 %x, i8 noundef %y) {
1214 ; CHECK-LABEL: @select_eq_mul_not_absorber(
1215 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[X:%.*]], 0
1216 ; CHECK-NEXT:    [[ADD:%.*]] = add i8 [[X]], -1
1217 ; CHECK-NEXT:    [[MUL:%.*]] = mul i8 [[ADD]], [[Y:%.*]]
1218 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[CMP]], i8 0, i8 [[MUL]]
1219 ; CHECK-NEXT:    ret i8 [[SEL]]
1220 ;
1221   %cmp = icmp eq i8 %x, 0
1222   %add = add i8 %x, -1
1223   %mul = mul i8 %add, %y
1224   %sel = select i1 %cmp, i8 0, i8 %mul
1225   ret i8 %sel
1226 }
1227
1228 ; Vector to scalar options should be treated as lane-crossing.
1229 define <2 x i8> @select_eq_vector_insert_extract(<2 x i8> %a, <2 x i8> %b) {
1230 ; CHECK-LABEL: @select_eq_vector_insert_extract(
1231 ; CHECK-NEXT:    [[EXTRACT0:%.*]] = extractelement <2 x i8> [[A:%.*]], i64 0
1232 ; CHECK-NEXT:    [[EXTRACT1:%.*]] = extractelement <2 x i8> [[A]], i64 1
1233 ; CHECK-NEXT:    [[INSERT0:%.*]] = insertelement <2 x i8> poison, i8 [[EXTRACT1]], i64 0
1234 ; CHECK-NEXT:    [[INSERT1:%.*]] = insertelement <2 x i8> [[INSERT0]], i8 [[EXTRACT0]], i64 1
1235 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x i8> [[A]], zeroinitializer
1236 ; CHECK-NEXT:    [[SEL:%.*]] = select <2 x i1> [[CMP]], <2 x i8> [[INSERT1]], <2 x i8> zeroinitializer
1237 ; CHECK-NEXT:    ret <2 x i8> [[SEL]]
1238 ;
1239   %extract0 = extractelement <2 x i8> %a, i64 0
1240   %extract1 = extractelement <2 x i8> %a, i64 1
1241   %insert0 = insertelement <2 x i8> poison, i8 %extract1, i64 0
1242   %insert1 = insertelement <2 x i8> %insert0, i8 %extract0, i64 1
1243   %cmp = icmp eq <2 x i8> %a, zeroinitializer
1244   %sel = select <2 x i1> %cmp, <2 x i8> %insert1, <2 x i8> zeroinitializer
1245   ret <2 x i8> %sel
1246 }
1247
1248 define i32 @poison(i32 %x, i32 %y) {
1249 ; CHECK-LABEL: @poison(
1250 ; CHECK-NEXT:    ret i32 [[X:%.*]]
1251 ;
1252   %v = select i1 undef, i32 %x, i32 %y
1253   ret i32 %v
1254 }
1255
1256 define i32 @poison2(i1 %cond, i32 %x) {
1257 ; CHECK-LABEL: @poison2(
1258 ; CHECK-NEXT:    ret i32 [[X:%.*]]
1259 ;
1260   %v = select i1 %cond, i32 poison, i32 %x
1261   ret i32 %v
1262 }
1263
1264 define i32 @poison3(i1 %cond, i32 %x) {
1265 ; CHECK-LABEL: @poison3(
1266 ; CHECK-NEXT:    ret i32 [[X:%.*]]
1267 ;
1268   %v = select i1 %cond, i32 %x, i32 poison
1269   ret i32 %v
1270 }
1271
1272 define <2 x i32> @poison4(<2 x i1> %cond, <2 x i32> %x) {
1273 ; CHECK-LABEL: @poison4(
1274 ; CHECK-NEXT:    ret <2 x i32> [[X:%.*]]
1275 ;
1276   %v = select <2 x i1> %cond, <2 x i32> %x, <2 x i32> poison
1277   ret <2 x i32> %v
1278 }
1279
1280 ; 0 is the absorber constant for 'and'.
1281 ; The 'select' can't block extra poison because both sides of 'and' have 'x' operand.
1282
1283 define i8 @replace_false_op_eq_neg_and(i8 %x) {
1284 ; CHECK-LABEL: @replace_false_op_eq_neg_and(
1285 ; CHECK-NEXT:    [[NEG:%.*]] = sub i8 0, [[X:%.*]]
1286 ; CHECK-NEXT:    [[AND:%.*]] = and i8 [[NEG]], [[X]]
1287 ; CHECK-NEXT:    ret i8 [[AND]]
1288 ;
1289   %eq0 = icmp eq i8 %x, 0
1290   %neg = sub i8 0, %x
1291   %and = and i8 %neg, %x
1292   %sel = select i1 %eq0, i8 0, i8 %and
1293   ret i8 %sel
1294 }
1295
1296 ; same as above, but commute 'and'
1297
1298 define i8 @replace_false_op_eq_neg_and_commute(i8 %x) {
1299 ; CHECK-LABEL: @replace_false_op_eq_neg_and_commute(
1300 ; CHECK-NEXT:    [[NEG:%.*]] = sub i8 0, [[X:%.*]]
1301 ; CHECK-NEXT:    [[AND:%.*]] = and i8 [[X]], [[NEG]]
1302 ; CHECK-NEXT:    ret i8 [[AND]]
1303 ;
1304   %eq0 = icmp eq i8 %x, 0
1305   %neg = sub i8 0, %x
1306   %and = and i8 %x, %neg
1307   %sel = select i1 %eq0, i8 0, i8 %and
1308   ret i8 %sel
1309 }
1310
1311 ; same as above, but swap 'select'
1312
1313 define i8 @replace_false_op_ne_neg_and(i8 %x) {
1314 ; CHECK-LABEL: @replace_false_op_ne_neg_and(
1315 ; CHECK-NEXT:    [[NEG:%.*]] = sub i8 0, [[X:%.*]]
1316 ; CHECK-NEXT:    [[AND:%.*]] = and i8 [[NEG]], [[X]]
1317 ; CHECK-NEXT:    ret i8 [[AND]]
1318 ;
1319   %ne0 = icmp ne i8 %x, 0
1320   %neg = sub i8 0, %x
1321   %and = and i8 %neg, %x
1322   %sel = select i1 %ne0, i8 %and, i8 0
1323   ret i8 %sel
1324 }
1325
1326 ; same as above, but commute 'and' and swap 'select'
1327
1328 define i8 @replace_false_op_ne_neg_and_commute(i8 %x) {
1329 ; CHECK-LABEL: @replace_false_op_ne_neg_and_commute(
1330 ; CHECK-NEXT:    [[NEG:%.*]] = sub i8 0, [[X:%.*]]
1331 ; CHECK-NEXT:    [[AND:%.*]] = and i8 [[X]], [[NEG]]
1332 ; CHECK-NEXT:    ret i8 [[AND]]
1333 ;
1334   %ne0 = icmp ne i8 %x, 0
1335   %neg = sub i8 0, %x
1336   %and = and i8 %x, %neg
1337   %sel = select i1 %ne0, i8 %and, i8 0
1338   ret i8 %sel
1339 }
1340
1341 ; the first binop can be anything as long as it has the common operand
1342
1343 define i8 @replace_false_op_eq_dec_and(i8 %x) {
1344 ; CHECK-LABEL: @replace_false_op_eq_dec_and(
1345 ; CHECK-NEXT:    [[DEC:%.*]] = add i8 [[X:%.*]], -1
1346 ; CHECK-NEXT:    [[AND:%.*]] = and i8 [[DEC]], [[X]]
1347 ; CHECK-NEXT:    ret i8 [[AND]]
1348 ;
1349   %eq0 = icmp eq i8 %x, 0
1350   %dec = add i8 %x, -1
1351   %and = and i8 %dec, %x
1352   %sel = select i1 %eq0, i8 0, i8 %and
1353   ret i8 %sel
1354 }
1355
1356 ; mul has the same absorber constant - "0"
1357
1358 define i8 @replace_false_op_eq_add_mul(i8 %x) {
1359 ; CHECK-LABEL: @replace_false_op_eq_add_mul(
1360 ; CHECK-NEXT:    [[ADD:%.*]] = add i8 [[X:%.*]], 42
1361 ; CHECK-NEXT:    [[MUL:%.*]] = mul i8 [[ADD]], [[X]]
1362 ; CHECK-NEXT:    ret i8 [[MUL]]
1363 ;
1364   %eq0 = icmp eq i8 %x, 0
1365   %add = add i8 %x, 42
1366   %mul = mul i8 %add, %x
1367   %sel = select i1 %eq0, i8 0, i8 %mul
1368   ret i8 %sel
1369 }
1370
1371 ; or has a different absorber constant = "-1"
1372
1373 define i8 @replace_false_op_eq_shl_or(i8 %x) {
1374 ; CHECK-LABEL: @replace_false_op_eq_shl_or(
1375 ; CHECK-NEXT:    [[SHL:%.*]] = shl i8 [[X:%.*]], 3
1376 ; CHECK-NEXT:    [[OR:%.*]] = or i8 [[X]], [[SHL]]
1377 ; CHECK-NEXT:    ret i8 [[OR]]
1378 ;
1379   %eq0 = icmp eq i8 %x, -1
1380   %shl = shl i8 %x, 3
1381   %or = or i8 %x, %shl
1382   %sel = select i1 %eq0, i8 -1, i8 %or
1383   ret i8 %sel
1384 }
1385
1386 ; negative test - wrong cmp predicate
1387
1388 define i8 @replace_false_op_sgt_neg_and(i8 %x) {
1389 ; CHECK-LABEL: @replace_false_op_sgt_neg_and(
1390 ; CHECK-NEXT:    [[EQ0:%.*]] = icmp sgt i8 [[X:%.*]], 0
1391 ; CHECK-NEXT:    [[NEG:%.*]] = sub i8 0, [[X]]
1392 ; CHECK-NEXT:    [[AND:%.*]] = and i8 [[NEG]], [[X]]
1393 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[EQ0]], i8 0, i8 [[AND]]
1394 ; CHECK-NEXT:    ret i8 [[SEL]]
1395 ;
1396   %eq0 = icmp sgt i8 %x, 0
1397   %neg = sub i8 0, %x
1398   %and = and i8 %neg, %x
1399   %sel = select i1 %eq0, i8 0, i8 %and
1400   ret i8 %sel
1401 }
1402
1403 ; negative test - the binop must use a compare operand
1404
1405 define i8 @replace_false_op_eq_shl_or_wrong_cmp_op(i8 %x, i8 %y) {
1406 ; CHECK-LABEL: @replace_false_op_eq_shl_or_wrong_cmp_op(
1407 ; CHECK-NEXT:    [[EQ0:%.*]] = icmp eq i8 [[Y:%.*]], -1
1408 ; CHECK-NEXT:    [[SHL:%.*]] = shl i8 [[X:%.*]], 3
1409 ; CHECK-NEXT:    [[OR:%.*]] = or i8 [[X]], [[SHL]]
1410 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[EQ0]], i8 -1, i8 [[OR]]
1411 ; CHECK-NEXT:    ret i8 [[SEL]]
1412 ;
1413   %eq0 = icmp eq i8 %y, -1
1414   %shl = shl i8 %x, 3
1415   %or = or i8 %x, %shl
1416   %sel = select i1 %eq0, i8 -1, i8 %or
1417   ret i8 %sel
1418 }
1419
1420 ; negative test - can't have extra source of potential poison
1421
1422 define i8 @replace_false_op_eq_neg_and_leak1(i8 %x, i8 %y) {
1423 ; CHECK-LABEL: @replace_false_op_eq_neg_and_leak1(
1424 ; CHECK-NEXT:    [[EQ0:%.*]] = icmp eq i8 [[X:%.*]], 0
1425 ; CHECK-NEXT:    [[NEG:%.*]] = sub i8 0, [[Y:%.*]]
1426 ; CHECK-NEXT:    [[AND:%.*]] = and i8 [[NEG]], [[X]]
1427 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[EQ0]], i8 0, i8 [[AND]]
1428 ; CHECK-NEXT:    ret i8 [[SEL]]
1429 ;
1430   %eq0 = icmp eq i8 %x, 0
1431   %neg = sub i8 0, %y
1432   %and = and i8 %neg, %x
1433   %sel = select i1 %eq0, i8 0, i8 %and
1434   ret i8 %sel
1435 }
1436
1437 ; negative test - can't have extra source of potential poison
1438
1439 define i8 @replace_false_op_eq_neg_and_leak2(i8 %x, i8 %y) {
1440 ; CHECK-LABEL: @replace_false_op_eq_neg_and_leak2(
1441 ; CHECK-NEXT:    [[EQ0:%.*]] = icmp eq i8 [[X:%.*]], 0
1442 ; CHECK-NEXT:    [[NEG:%.*]] = sub i8 0, [[X]]
1443 ; CHECK-NEXT:    [[AND:%.*]] = and i8 [[NEG]], [[Y:%.*]]
1444 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[EQ0]], i8 0, i8 [[AND]]
1445 ; CHECK-NEXT:    ret i8 [[SEL]]
1446 ;
1447   %eq0 = icmp eq i8 %x, 0
1448   %neg = sub i8 0, %x
1449   %and = and i8 %neg, %y
1450   %sel = select i1 %eq0, i8 0, i8 %and
1451   ret i8 %sel
1452 }
1453
1454 ; negative test - can't have extra source of potential poison
1455
1456 define i8 @replace_false_op_eq_add_mul_leak3(i8 %x, i8 %y) {
1457 ; CHECK-LABEL: @replace_false_op_eq_add_mul_leak3(
1458 ; CHECK-NEXT:    [[EQ0:%.*]] = icmp eq i8 [[X:%.*]], 0
1459 ; CHECK-NEXT:    [[ADD:%.*]] = add i8 [[X]], [[Y:%.*]]
1460 ; CHECK-NEXT:    [[MUL:%.*]] = mul i8 [[ADD]], [[X]]
1461 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[EQ0]], i8 0, i8 [[MUL]]
1462 ; CHECK-NEXT:    ret i8 [[SEL]]
1463 ;
1464   %eq0 = icmp eq i8 %x, 0
1465   %add = add i8 %x, %y
1466   %mul = mul i8 %add, %x
1467   %sel = select i1 %eq0, i8 0, i8 %mul
1468   ret i8 %sel
1469 }
1470
1471 ; negative test - can't have extra source of potential poison
1472
1473 define i8 @replace_false_op_eq_shl_or_leak4(i8 %x, i8 %y) {
1474 ; CHECK-LABEL: @replace_false_op_eq_shl_or_leak4(
1475 ; CHECK-NEXT:    [[EQ0:%.*]] = icmp eq i8 [[X:%.*]], -1
1476 ; CHECK-NEXT:    [[SHL:%.*]] = shl i8 [[Y:%.*]], [[X]]
1477 ; CHECK-NEXT:    [[OR:%.*]] = or i8 [[X]], [[SHL]]
1478 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[EQ0]], i8 -1, i8 [[OR]]
1479 ; CHECK-NEXT:    ret i8 [[SEL]]
1480 ;
1481   %eq0 = icmp eq i8 %x, -1
1482   %shl = shl i8 %y, %x
1483   %or = or i8 %x, %shl
1484   %sel = select i1 %eq0, i8 -1, i8 %or
1485   ret i8 %sel
1486 }
1487
1488 ; negative test - wrong cmp constant
1489
1490 define i8 @replace_false_op_eq42_neg_and(i8 %x) {
1491 ; CHECK-LABEL: @replace_false_op_eq42_neg_and(
1492 ; CHECK-NEXT:    [[EQ42:%.*]] = icmp eq i8 [[X:%.*]], 42
1493 ; CHECK-NEXT:    [[NEG:%.*]] = sub i8 0, [[X]]
1494 ; CHECK-NEXT:    [[AND:%.*]] = and i8 [[NEG]], [[X]]
1495 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[EQ42]], i8 0, i8 [[AND]]
1496 ; CHECK-NEXT:    ret i8 [[SEL]]
1497 ;
1498   %eq42 = icmp eq i8 %x, 42
1499   %neg = sub i8 0, %x
1500   %and = and i8 %neg, %x
1501   %sel = select i1 %eq42, i8 0, i8 %and
1502   ret i8 %sel
1503 }
1504
1505 define ptr @select_op_replacement_in_phi(ptr %head) {
1506 ; CHECK-LABEL: @select_op_replacement_in_phi(
1507 ; CHECK-NEXT:  entry:
1508 ; CHECK-NEXT:    br label [[LOOP:%.*]]
1509 ; CHECK:       loop:
1510 ; CHECK-NEXT:    [[CURRENT:%.*]] = phi ptr [ [[HEAD:%.*]], [[ENTRY:%.*]] ], [ [[NEXT:%.*]], [[LATCH:%.*]] ]
1511 ; CHECK-NEXT:    [[PREV:%.*]] = phi ptr [ null, [[ENTRY]] ], [ [[CURRENT]], [[LATCH]] ]
1512 ; CHECK-NEXT:    [[CURRENT_NULL:%.*]] = icmp eq ptr [[CURRENT]], null
1513 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[CURRENT_NULL]], ptr [[PREV]], ptr null
1514 ; CHECK-NEXT:    br i1 [[CURRENT_NULL]], label [[EXIT:%.*]], label [[LATCH]]
1515 ; CHECK:       latch:
1516 ; CHECK-NEXT:    [[NEXT]] = load ptr, ptr [[CURRENT]], align 8
1517 ; CHECK-NEXT:    br label [[LOOP]]
1518 ; CHECK:       exit:
1519 ; CHECK-NEXT:    ret ptr [[SEL]]
1520 ;
1521 entry:
1522   br label %loop
1523
1524 loop:
1525   %current = phi ptr [ %head, %entry ], [ %next, %latch ]
1526   %prev = phi ptr [ null, %entry ], [ %current, %latch ]
1527   %current.null = icmp eq ptr %current, null
1528   %sel = select i1 %current.null, ptr %prev, ptr null
1529   br i1 %current.null, label %exit, label %latch
1530
1531 latch:
1532   %next = load ptr, ptr %current
1533   br label %loop
1534
1535 exit:
1536   ret ptr %sel
1537 }
1538
1539 define i8 @select_sub_cmp(i8 %0, i8 %1) {
1540 ; CHECK-LABEL: @select_sub_cmp(
1541 ; CHECK-NEXT:    [[TMP3:%.*]] = sub nsw i8 [[TMP1:%.*]], [[TMP0:%.*]]
1542 ; CHECK-NEXT:    ret i8 [[TMP3]]
1543 ;
1544   %3 = icmp eq i8 %1, %0
1545   %4 = sub nsw i8 %1, %0
1546   %5 = select i1 %3, i8 0, i8 %4
1547   ret i8 %5
1548 }
1549
1550 define <2 x i8> @select_sub_cmp_vec(<2 x i8> %0, <2 x i8> %1) {
1551 ; CHECK-LABEL: @select_sub_cmp_vec(
1552 ; CHECK-NEXT:    [[TMP3:%.*]] = sub nsw <2 x i8> [[TMP1:%.*]], [[TMP0:%.*]]
1553 ; CHECK-NEXT:    ret <2 x i8> [[TMP3]]
1554 ;
1555   %3 = icmp eq <2 x i8> %1, %0
1556   %4 = sub nsw <2 x i8> %1, %0
1557   %5 = select <2 x i1> %3, <2 x i8> <i8 0, i8 0>, <2 x i8> %4
1558   ret <2 x i8> %5
1559 }
1560
1561 define i8 @select_sub_cmp_swap(i8 %0, i8 %1) {
1562 ; CHECK-LABEL: @select_sub_cmp_swap(
1563 ; CHECK-NEXT:    [[TMP3:%.*]] = sub nsw i8 [[TMP0:%.*]], [[TMP1:%.*]]
1564 ; CHECK-NEXT:    ret i8 [[TMP3]]
1565 ;
1566   %3 = icmp eq i8 %1, %0
1567   %4 = sub nsw i8 %0, %1
1568   %5 = select i1 %3, i8 0, i8 %4
1569   ret i8 %5
1570 }
1571
1572 define <2 x i8> @select_sub_cmp_vec_swap(<2 x i8> %0, <2 x i8> %1) {
1573 ; CHECK-LABEL: @select_sub_cmp_vec_swap(
1574 ; CHECK-NEXT:    [[TMP3:%.*]] = sub nsw <2 x i8> [[TMP0:%.*]], [[TMP1:%.*]]
1575 ; CHECK-NEXT:    ret <2 x i8> [[TMP3]]
1576 ;
1577   %3 = icmp eq <2 x i8> %1, %0
1578   %4 = sub nsw <2 x i8> %0, %1
1579   %5 = select <2 x i1> %3, <2 x i8> <i8 0, i8 0>, <2 x i8> %4
1580   ret <2 x i8> %5
1581 }
1582
1583 ; negative test
1584 define i8 @select_sub_cmp_nonzero(i8 %0, i8 %1) {
1585 ; CHECK-LABEL: @select_sub_cmp_nonzero(
1586 ; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i8 [[TMP1:%.*]], [[TMP0:%.*]]
1587 ; CHECK-NEXT:    [[TMP4:%.*]] = sub nsw i8 [[TMP1]], [[TMP0]]
1588 ; CHECK-NEXT:    [[TMP5:%.*]] = select i1 [[TMP3]], i8 42, i8 [[TMP4]]
1589 ; CHECK-NEXT:    ret i8 [[TMP5]]
1590 ;
1591   %3 = icmp eq i8 %1, %0
1592   %4 = sub nsw i8 %1, %0
1593   %5 = select i1 %3, i8 42, i8 %4
1594   ret i8 %5
1595 }
1596
1597 ; X == Y ? 0 : X ^ Y --> X ^ Y, https://alive2.llvm.org/ce/z/cykffE
1598 define i8 @select_xor_cmp(i8 %0, i8 %1) {
1599 ; CHECK-LABEL: @select_xor_cmp(
1600 ; CHECK-NEXT:    [[TMP3:%.*]] = xor i8 [[TMP1:%.*]], [[TMP0:%.*]]
1601 ; CHECK-NEXT:    ret i8 [[TMP3]]
1602 ;
1603   %3 = icmp eq i8 %1, %0
1604   %4 = xor i8 %1, %0
1605   %5 = select i1 %3, i8 0, i8 %4
1606   ret i8 %5
1607 }
1608
1609 define <2 x i8> @select_xor_cmp_vec(<2 x i8> %0, <2 x i8> %1) {
1610 ; CHECK-LABEL: @select_xor_cmp_vec(
1611 ; CHECK-NEXT:    [[TMP3:%.*]] = xor <2 x i8> [[TMP1:%.*]], [[TMP0:%.*]]
1612 ; CHECK-NEXT:    ret <2 x i8> [[TMP3]]
1613 ;
1614   %3 = icmp eq <2 x i8> %1, %0
1615   %4 = xor <2 x i8> %1, %0
1616   %5 = select <2 x i1> %3, <2 x i8> <i8 0, i8 0>, <2 x i8> %4
1617   ret <2 x i8> %5
1618 }
1619
1620 define i8 @select_xor_cmp_swap(i8 %0, i8 %1) {
1621 ; CHECK-LABEL: @select_xor_cmp_swap(
1622 ; CHECK-NEXT:    [[TMP3:%.*]] = xor i8 [[TMP0:%.*]], [[TMP1:%.*]]
1623 ; CHECK-NEXT:    ret i8 [[TMP3]]
1624 ;
1625   %3 = icmp eq i8 %1, %0
1626   %4 = xor i8 %0, %1
1627   %5 = select i1 %3, i8 0, i8 %4
1628   ret i8 %5
1629 }
1630
1631 define <2 x i8> @select_xor_cmp_vec_swap(<2 x i8> %0, <2 x i8> %1) {
1632 ; CHECK-LABEL: @select_xor_cmp_vec_swap(
1633 ; CHECK-NEXT:    [[TMP3:%.*]] = xor <2 x i8> [[TMP0:%.*]], [[TMP1:%.*]]
1634 ; CHECK-NEXT:    ret <2 x i8> [[TMP3]]
1635 ;
1636   %3 = icmp eq <2 x i8> %1, %0
1637   %4 = xor <2 x i8> %0, %1
1638   %5 = select <2 x i1> %3, <2 x i8> <i8 0, i8 0>, <2 x i8> %4
1639   ret <2 x i8> %5
1640 }
1641
1642 ; Negative test: the xor operands are not %0 and %1
1643 define i8 @select_xor_cmp_unmatched_operands(i8 %0, i8 %1, i8 %c) {
1644 ; CHECK-LABEL: @select_xor_cmp_unmatched_operands(
1645 ; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i8 [[TMP1:%.*]], [[TMP0:%.*]]
1646 ; CHECK-NEXT:    [[TMP4:%.*]] = xor i8 [[TMP1]], [[C:%.*]]
1647 ; CHECK-NEXT:    [[TMP5:%.*]] = select i1 [[TMP3]], i8 0, i8 [[TMP4]]
1648 ; CHECK-NEXT:    ret i8 [[TMP5]]
1649 ;
1650   %3 = icmp eq i8 %1, %0
1651   %4 = xor i8 %1, %c
1652   %5 = select i1 %3, i8 0, i8 %4
1653   ret i8 %5
1654 }