llvm/test/Transforms/InstCombine/rem.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -instcombine -S | FileCheck %s
   3
   4 declare void @use(i32)
   5
   6 define i64 @rem_signed(i64 %x1, i64 %y2) {
   7 ; CHECK-LABEL: @rem_signed(
   8 ; CHECK-NEXT:    [[TMP1:%.*]] = srem i64 [[X1:%.*]], [[Y2:%.*]]
   9 ; CHECK-NEXT:    ret i64 [[TMP1]]
  10 ;
  11   %r = sdiv i64 %x1, %y2
  12   %r7 = mul i64 %r, %y2
  13   %r8 = sub i64 %x1, %r7
  14   ret i64 %r8
  15 }
  16
  17 define <4 x i32> @rem_signed_vec(<4 x i32> %t, <4 x i32> %u) {
  18 ; CHECK-LABEL: @rem_signed_vec(
  19 ; CHECK-NEXT:    [[TMP1:%.*]] = srem <4 x i32> [[T:%.*]], [[U:%.*]]
  20 ; CHECK-NEXT:    ret <4 x i32> [[TMP1]]
  21 ;
  22   %k = sdiv <4 x i32> %t, %u
  23   %l = mul <4 x i32> %k, %u
  24   %m = sub <4 x i32> %t, %l
  25   ret <4 x i32> %m
  26 }
  27
  28 define i64 @rem_unsigned(i64 %x1, i64 %y2) {
  29 ; CHECK-LABEL: @rem_unsigned(
  30 ; CHECK-NEXT:    [[TMP1:%.*]] = urem i64 [[X1:%.*]], [[Y2:%.*]]
  31 ; CHECK-NEXT:    ret i64 [[TMP1]]
  32 ;
  33   %r = udiv i64 %x1, %y2
  34   %r7 = mul i64 %r, %y2
  35   %r8 = sub i64 %x1, %r7
  36   ret i64 %r8
  37 }
  38
  39 ; PR28672 - https://llvm.org/bugs/show_bug.cgi?id=28672
  40
  41 define i8 @big_divisor(i8 %x) {
  42 ; CHECK-LABEL: @big_divisor(
  43 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i8 [[X:%.*]], -127
  44 ; CHECK-NEXT:    [[TMP2:%.*]] = add i8 [[X]], 127
  45 ; CHECK-NEXT:    [[REM:%.*]] = select i1 [[TMP1]], i8 [[X]], i8 [[TMP2]]
  46 ; CHECK-NEXT:    ret i8 [[REM]]
  47 ;
  48   %rem = urem i8 %x, 129
  49   ret i8 %rem
  50 }
  51
  52 define i5 @biggest_divisor(i5 %x) {
  53 ; CHECK-LABEL: @biggest_divisor(
  54 ; CHECK-NEXT:    [[DOTNOT:%.*]] = icmp eq i5 [[X:%.*]], -1
  55 ; CHECK-NEXT:    [[REM:%.*]] = select i1 [[DOTNOT]], i5 0, i5 [[X]]
  56 ; CHECK-NEXT:    ret i5 [[REM]]
  57 ;
  58   %rem = urem i5 %x, -1
  59   ret i5 %rem
  60 }
  61
  62 define i8 @urem_with_sext_bool_divisor(i1 %x, i8 %y) {
  63 ; CHECK-LABEL: @urem_with_sext_bool_divisor(
  64 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i8 [[Y:%.*]], -1
  65 ; CHECK-NEXT:    [[REM:%.*]] = select i1 [[TMP1]], i8 0, i8 [[Y]]
  66 ; CHECK-NEXT:    ret i8 [[REM]]
  67 ;
  68   %s = sext i1 %x to i8
  69   %rem = urem i8 %y, %s
  70   ret i8 %rem
  71 }
  72
  73 define <2 x i8> @urem_with_sext_bool_divisor_vec(<2 x i1> %x, <2 x i8> %y) {
  74 ; CHECK-LABEL: @urem_with_sext_bool_divisor_vec(
  75 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq <2 x i8> [[Y:%.*]], <i8 -1, i8 -1>
  76 ; CHECK-NEXT:    [[REM:%.*]] = select <2 x i1> [[TMP1]], <2 x i8> zeroinitializer, <2 x i8> [[Y]]
  77 ; CHECK-NEXT:    ret <2 x i8> [[REM]]
  78 ;
  79   %s = sext <2 x i1> %x to <2 x i8>
  80   %rem = urem <2 x i8> %y, %s
  81   ret <2 x i8> %rem
  82 }
  83
  84 define <2 x i4> @big_divisor_vec(<2 x i4> %x) {
  85 ; CHECK-LABEL: @big_divisor_vec(
  86 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult <2 x i4> [[X:%.*]], <i4 -3, i4 -3>
  87 ; CHECK-NEXT:    [[TMP2:%.*]] = add <2 x i4> [[X]], <i4 3, i4 3>
  88 ; CHECK-NEXT:    [[REM:%.*]] = select <2 x i1> [[TMP1]], <2 x i4> [[X]], <2 x i4> [[TMP2]]
  89 ; CHECK-NEXT:    ret <2 x i4> [[REM]]
  90 ;
  91   %rem = urem <2 x i4> %x, <i4 13, i4 13>
  92   ret <2 x i4> %rem
  93 }
  94
  95 define i8 @urem1(i8 %x, i8 %y) {
  96 ; CHECK-LABEL: @urem1(
  97 ; CHECK-NEXT:    [[TMP1:%.*]] = urem i8 [[X:%.*]], [[Y:%.*]]
  98 ; CHECK-NEXT:    ret i8 [[TMP1]]
  99 ;
 100   %A = udiv i8 %x, %y
 101   %B = mul i8 %A, %y
 102   %C = sub i8 %x, %B
 103   ret i8 %C
 104 }
 105
 106 define i8 @srem1(i8 %x, i8 %y) {
 107 ; CHECK-LABEL: @srem1(
 108 ; CHECK-NEXT:    [[TMP1:%.*]] = srem i8 [[X:%.*]], [[Y:%.*]]
 109 ; CHECK-NEXT:    ret i8 [[TMP1]]
 110 ;
 111   %A = sdiv i8 %x, %y
 112   %B = mul i8 %A, %y
 113   %C = sub i8 %x, %B
 114   ret i8 %C
 115 }
 116
 117 define i8 @urem2(i8 %x, i8 %y) {
 118 ; CHECK-LABEL: @urem2(
 119 ; CHECK-NEXT:    [[TMP1:%.*]] = urem i8 [[X:%.*]], [[Y:%.*]]
 120 ; CHECK-NEXT:    [[C:%.*]] = sub i8 0, [[TMP1]]
 121 ; CHECK-NEXT:    ret i8 [[C]]
 122 ;
 123   %A = udiv i8 %x, %y
 124   %B = mul i8 %A, %y
 125   %C = sub i8 %B, %x
 126   ret i8 %C
 127 }
 128
 129 define i8 @urem3(i8 %x) {
 130 ; CHECK-LABEL: @urem3(
 131 ; CHECK-NEXT:    [[TMP1:%.*]] = urem i8 [[X:%.*]], 3
 132 ; CHECK-NEXT:    [[B_NEG:%.*]] = sub i8 [[X]], [[TMP1]]
 133 ; CHECK-NEXT:    [[C:%.*]] = add i8 [[B_NEG]], [[X]]
 134 ; CHECK-NEXT:    ret i8 [[C]]
 135 ;
 136   %A = udiv i8 %x, 3
 137   %B = mul i8 %A, -3
 138   %C = sub i8 %x, %B
 139   ret i8 %C
 140 }
 141
 142 ; (((X / Y) * Y) / Y) -> X / Y
 143
 144 define i32 @sdiv_mul_sdiv(i32 %x, i32 %y) {
 145 ; CHECK-LABEL: @sdiv_mul_sdiv(
 146 ; CHECK-NEXT:    [[R:%.*]] = sdiv i32 [[X:%.*]], [[Y:%.*]]
 147 ; CHECK-NEXT:    ret i32 [[R]]
 148 ;
 149   %div = sdiv i32 %x, %y
 150   %mul = mul i32 %div, %y
 151   %r = sdiv i32 %mul, %y
 152   ret i32 %r
 153 }
 154
 155 ; (((X / Y) * Y) / Y) -> X / Y
 156
 157 define i32 @udiv_mul_udiv(i32 %x, i32 %y) {
 158 ; CHECK-LABEL: @udiv_mul_udiv(
 159 ; CHECK-NEXT:    [[R:%.*]] = udiv i32 [[X:%.*]], [[Y:%.*]]
 160 ; CHECK-NEXT:    ret i32 [[R]]
 161 ;
 162   %div = udiv i32 %x, %y
 163   %mul = mul i32 %div, %y
 164   %r = udiv i32 %mul, %y
 165   ret i32 %r
 166 }
 167
 168 define i32 @test1(i32 %A) {
 169 ; CHECK-LABEL: @test1(
 170 ; CHECK-NEXT:    ret i32 0
 171 ;
 172   %B = srem i32 %A, 1   ; ISA constant 0
 173   ret i32 %B
 174 }
 175
 176 define i32 @test3(i32 %A) {
 177 ; CHECK-LABEL: @test3(
 178 ; CHECK-NEXT:    [[B:%.*]] = and i32 [[A:%.*]], 7
 179 ; CHECK-NEXT:    ret i32 [[B]]
 180 ;
 181   %B = urem i32 %A, 8
 182   ret i32 %B
 183 }
 184
 185 define <2 x i32> @vec_power_of_2_constant_splat_divisor(<2 x i32> %A) {
 186 ; CHECK-LABEL: @vec_power_of_2_constant_splat_divisor(
 187 ; CHECK-NEXT:    [[B:%.*]] = and <2 x i32> [[A:%.*]], <i32 7, i32 7>
 188 ; CHECK-NEXT:    ret <2 x i32> [[B]]
 189 ;
 190   %B = urem <2 x i32> %A, <i32 8, i32 8>
 191   ret <2 x i32> %B
 192 }
 193
 194 define <2 x i19> @weird_vec_power_of_2_constant_splat_divisor(<2 x i19> %A) {
 195 ; CHECK-LABEL: @weird_vec_power_of_2_constant_splat_divisor(
 196 ; CHECK-NEXT:    [[B:%.*]] = and <2 x i19> [[A:%.*]], <i19 7, i19 7>
 197 ; CHECK-NEXT:    ret <2 x i19> [[B]]
 198 ;
 199   %B = urem <2 x i19> %A, <i19 8, i19 8>
 200   ret <2 x i19> %B
 201 }
 202
 203 define i1 @test3a(i32 %A) {
 204 ; CHECK-LABEL: @test3a(
 205 ; CHECK-NEXT:    [[TMP1:%.*]] = and i32 [[A:%.*]], 7
 206 ; CHECK-NEXT:    [[C:%.*]] = icmp ne i32 [[TMP1]], 0
 207 ; CHECK-NEXT:    ret i1 [[C]]
 208 ;
 209   %B = srem i32 %A, -8
 210   %C = icmp ne i32 %B, 0
 211   ret i1 %C
 212 }
 213
 214 define <2 x i1> @test3a_vec(<2 x i32> %A) {
 215 ; CHECK-LABEL: @test3a_vec(
 216 ; CHECK-NEXT:    [[TMP1:%.*]] = and <2 x i32> [[A:%.*]], <i32 7, i32 7>
 217 ; CHECK-NEXT:    [[C:%.*]] = icmp ne <2 x i32> [[TMP1]], zeroinitializer
 218 ; CHECK-NEXT:    ret <2 x i1> [[C]]
 219 ;
 220   %B = srem <2 x i32> %A, <i32 -8, i32 -8>
 221   %C = icmp ne <2 x i32> %B, zeroinitializer
 222   ret <2 x i1> %C
 223 }
 224
 225 define i32 @test4(i32 %X, i1 %C) {
 226 ; CHECK-LABEL: @test4(
 227 ; CHECK-NEXT:    [[TMP1:%.*]] = select i1 [[C:%.*]], i32 0, i32 7
 228 ; CHECK-NEXT:    [[R:%.*]] = and i32 [[TMP1]], [[X:%.*]]
 229 ; CHECK-NEXT:    ret i32 [[R]]
 230 ;
 231   %V = select i1 %C, i32 1, i32 8
 232   %R = urem i32 %X, %V
 233   ret i32 %R
 234 }
 235
 236 define i32 @test5(i32 %X, i8 %B) {
 237 ; CHECK-LABEL: @test5(
 238 ; CHECK-NEXT:    [[SHIFT_UPGRD_1:%.*]] = zext i8 [[B:%.*]] to i32
 239 ; CHECK-NEXT:    [[AMT:%.*]] = shl nuw i32 32, [[SHIFT_UPGRD_1]]
 240 ; CHECK-NEXT:    [[TMP1:%.*]] = add i32 [[AMT]], -1
 241 ; CHECK-NEXT:    [[V:%.*]] = and i32 [[TMP1]], [[X:%.*]]
 242 ; CHECK-NEXT:    ret i32 [[V]]
 243 ;
 244   %shift.upgrd.1 = zext i8 %B to i32
 245   %Amt = shl i32 32, %shift.upgrd.1
 246   %V = urem i32 %X, %Amt
 247   ret i32 %V
 248 }
 249
 250 define i32 @test6(i32 %A) {
 251 ; CHECK-LABEL: @test6(
 252 ; CHECK-NEXT:    ret i32 poison
 253 ;
 254   %B = srem i32 %A, 0   ;; undef
 255   ret i32 %B
 256 }
 257
 258 define i32 @test7(i32 %A) {
 259 ; CHECK-LABEL: @test7(
 260 ; CHECK-NEXT:    ret i32 0
 261 ;
 262   %B = mul i32 %A, 8
 263   %C = srem i32 %B, 4
 264   ret i32 %C
 265 }
 266
 267 define i32 @test8(i32 %A) {
 268 ; CHECK-LABEL: @test8(
 269 ; CHECK-NEXT:    ret i32 0
 270 ;
 271   %B = shl i32 %A, 4
 272   %C = srem i32 %B, 8
 273   ret i32 %C
 274 }
 275
 276 define i32 @test9(i32 %A) {
 277 ; CHECK-LABEL: @test9(
 278 ; CHECK-NEXT:    ret i32 0
 279 ;
 280   %B = mul i32 %A, 64
 281   %C = urem i32 %B, 32
 282   ret i32 %C
 283 }
 284
 285 define i32 @test10(i8 %c) {
 286 ; CHECK-LABEL: @test10(
 287 ; CHECK-NEXT:    ret i32 0
 288 ;
 289   %tmp.1 = zext i8 %c to i32
 290   %tmp.2 = mul i32 %tmp.1, 4
 291   %tmp.3 = sext i32 %tmp.2 to i64
 292   %tmp.5 = urem i64 %tmp.3, 4
 293   %tmp.6 = trunc i64 %tmp.5 to i32
 294   ret i32 %tmp.6
 295 }
 296
 297 define i32 @test11(i32 %i) {
 298 ; CHECK-LABEL: @test11(
 299 ; CHECK-NEXT:    ret i32 0
 300 ;
 301   %tmp.1 = and i32 %i, -2
 302   %tmp.3 = mul i32 %tmp.1, 2
 303   %tmp.5 = urem i32 %tmp.3, 4
 304   ret i32 %tmp.5
 305 }
 306
 307 define i32 @test12(i32 %i) {
 308 ; CHECK-LABEL: @test12(
 309 ; CHECK-NEXT:    ret i32 0
 310 ;
 311   %tmp.1 = and i32 %i, -4
 312   %tmp.5 = srem i32 %tmp.1, 2
 313   ret i32 %tmp.5
 314 }
 315
 316 define i32 @test13(i32 %i) {
 317 ; CHECK-LABEL: @test13(
 318 ; CHECK-NEXT:    ret i32 0
 319 ;
 320   %x = srem i32 %i, %i
 321   ret i32 %x
 322 }
 323
 324 define i64 @test14(i64 %x, i32 %y) {
 325 ; CHECK-LABEL: @test14(
 326 ; CHECK-NEXT:    [[SHL:%.*]] = shl i32 1, [[Y:%.*]]
 327 ; CHECK-NEXT:    [[ZEXT:%.*]] = zext i32 [[SHL]] to i64
 328 ; CHECK-NEXT:    [[TMP1:%.*]] = add nsw i64 [[ZEXT]], -1
 329 ; CHECK-NEXT:    [[UREM:%.*]] = and i64 [[TMP1]], [[X:%.*]]
 330 ; CHECK-NEXT:    ret i64 [[UREM]]
 331 ;
 332   %shl = shl i32 1, %y
 333   %zext = zext i32 %shl to i64
 334   %urem = urem i64 %x, %zext
 335   ret i64 %urem
 336 }
 337
 338 define i64 @test15(i32 %x, i32 %y) {
 339 ; CHECK-LABEL: @test15(
 340 ; CHECK-NEXT:    [[NOTMASK:%.*]] = shl nsw i32 -1, [[Y:%.*]]
 341 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[NOTMASK]], -1
 342 ; CHECK-NEXT:    [[TMP2:%.*]] = and i32 [[TMP1]], [[X:%.*]]
 343 ; CHECK-NEXT:    [[UREM:%.*]] = zext i32 [[TMP2]] to i64
 344 ; CHECK-NEXT:    ret i64 [[UREM]]
 345 ;
 346   %shl = shl i32 1, %y
 347   %zext0 = zext i32 %shl to i64
 348   %zext1 = zext i32 %x to i64
 349   %urem = urem i64 %zext1, %zext0
 350   ret i64 %urem
 351 }
 352
 353 define i32 @test16(i32 %x, i32 %y) {
 354 ; CHECK-LABEL: @test16(
 355 ; CHECK-NEXT:    [[SHR:%.*]] = lshr i32 [[Y:%.*]], 11
 356 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[SHR]], 4
 357 ; CHECK-NEXT:    [[TMP1:%.*]] = or i32 [[AND]], 3
 358 ; CHECK-NEXT:    [[REM:%.*]] = and i32 [[TMP1]], [[X:%.*]]
 359 ; CHECK-NEXT:    ret i32 [[REM]]
 360 ;
 361   %shr = lshr i32 %y, 11
 362   %and = and i32 %shr, 4
 363   %add = add i32 %and, 4
 364   %rem = urem i32 %x, %add
 365   ret i32 %rem
 366 }
 367
 368 define i32 @test17(i32 %X) {
 369 ; CHECK-LABEL: @test17(
 370 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp ne i32 [[X:%.*]], 1
 371 ; CHECK-NEXT:    [[A:%.*]] = zext i1 [[TMP1]] to i32
 372 ; CHECK-NEXT:    ret i32 [[A]]
 373 ;
 374   %A = urem i32 1, %X
 375   ret i32 %A
 376 }
 377
 378 define i32 @test18(i16 %x, i32 %y) {
 379 ; CHECK-LABEL: @test18(
 380 ; CHECK-NEXT:    [[TMP1:%.*]] = and i16 [[X:%.*]], 4
 381 ; CHECK-NEXT:    [[DOTNOT:%.*]] = icmp eq i16 [[TMP1]], 0
 382 ; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[DOTNOT]], i32 63, i32 31
 383 ; CHECK-NEXT:    [[TMP3:%.*]] = and i32 [[TMP2]], [[Y:%.*]]
 384 ; CHECK-NEXT:    ret i32 [[TMP3]]
 385 ;
 386   %1 = and i16 %x, 4
 387   %2 = icmp ne i16 %1, 0
 388   %3 = select i1 %2, i32 32, i32 64
 389   %4 = urem i32 %y, %3
 390   ret i32 %4
 391 }
 392
 393 define i32 @test19(i32 %x, i32 %y) {
 394 ; CHECK-LABEL: @test19(
 395 ; CHECK-NEXT:    [[A:%.*]] = shl i32 1, [[X:%.*]]
 396 ; CHECK-NEXT:    [[B:%.*]] = shl i32 1, [[Y:%.*]]
 397 ; CHECK-NEXT:    [[C:%.*]] = and i32 [[A]], [[B]]
 398 ; CHECK-NEXT:    [[D:%.*]] = add i32 [[C]], [[A]]
 399 ; CHECK-NEXT:    [[TMP1:%.*]] = add i32 [[D]], -1
 400 ; CHECK-NEXT:    [[E:%.*]] = and i32 [[TMP1]], [[Y]]
 401 ; CHECK-NEXT:    ret i32 [[E]]
 402 ;
 403   %A = shl i32 1, %x
 404   %B = shl i32 1, %y
 405   %C = and i32 %A, %B
 406   %D = add i32 %C, %A
 407   %E = urem i32 %y, %D
 408   ret i32 %E
 409 }
 410
 411 define i32 @test19_commutative0(i32 %x, i32 %y) {
 412 ; CHECK-LABEL: @test19_commutative0(
 413 ; CHECK-NEXT:    [[A:%.*]] = shl i32 1, [[X:%.*]]
 414 ; CHECK-NEXT:    [[B:%.*]] = shl i32 1, [[Y:%.*]]
 415 ; CHECK-NEXT:    [[C:%.*]] = and i32 [[B]], [[A]]
 416 ; CHECK-NEXT:    [[D:%.*]] = add i32 [[C]], [[A]]
 417 ; CHECK-NEXT:    [[TMP1:%.*]] = add i32 [[D]], -1
 418 ; CHECK-NEXT:    [[E:%.*]] = and i32 [[TMP1]], [[Y]]
 419 ; CHECK-NEXT:    ret i32 [[E]]
 420 ;
 421   %A = shl i32 1, %x
 422   %B = shl i32 1, %y
 423   %C = and i32 %B, %A ; swapped
 424   %D = add i32 %C, %A
 425   %E = urem i32 %y, %D
 426   ret i32 %E
 427 }
 428
 429 define i32 @test19_commutative1(i32 %x, i32 %y) {
 430 ; CHECK-LABEL: @test19_commutative1(
 431 ; CHECK-NEXT:    [[A:%.*]] = shl i32 1, [[X:%.*]]
 432 ; CHECK-NEXT:    [[B:%.*]] = shl i32 1, [[Y:%.*]]
 433 ; CHECK-NEXT:    [[C:%.*]] = and i32 [[A]], [[B]]
 434 ; CHECK-NEXT:    [[D:%.*]] = add i32 [[A]], [[C]]
 435 ; CHECK-NEXT:    [[TMP1:%.*]] = add i32 [[D]], -1
 436 ; CHECK-NEXT:    [[E:%.*]] = and i32 [[TMP1]], [[Y]]
 437 ; CHECK-NEXT:    ret i32 [[E]]
 438 ;
 439   %A = shl i32 1, %x
 440   %B = shl i32 1, %y
 441   %C = and i32 %A, %B
 442   %D = add i32 %A, %C ; swapped
 443   %E = urem i32 %y, %D
 444   ret i32 %E
 445 }
 446
 447 define i32 @test19_commutative2(i32 %x, i32 %y) {
 448 ; CHECK-LABEL: @test19_commutative2(
 449 ; CHECK-NEXT:    [[A:%.*]] = shl i32 1, [[X:%.*]]
 450 ; CHECK-NEXT:    [[B:%.*]] = shl i32 1, [[Y:%.*]]
 451 ; CHECK-NEXT:    [[C:%.*]] = and i32 [[B]], [[A]]
 452 ; CHECK-NEXT:    [[D:%.*]] = add i32 [[A]], [[C]]
 453 ; CHECK-NEXT:    [[TMP1:%.*]] = add i32 [[D]], -1
 454 ; CHECK-NEXT:    [[E:%.*]] = and i32 [[TMP1]], [[Y]]
 455 ; CHECK-NEXT:    ret i32 [[E]]
 456 ;
 457   %A = shl i32 1, %x
 458   %B = shl i32 1, %y
 459   %C = and i32 %B, %A ; swapped
 460   %D = add i32 %A, %C ; swapped
 461   %E = urem i32 %y, %D
 462   ret i32 %E
 463 }
 464
 465 define <2 x i64> @test20(<2 x i64> %X, <2 x i1> %C) {
 466 ; CHECK-LABEL: @test20(
 467 ; CHECK-NEXT:    [[R:%.*]] = select <2 x i1> [[C:%.*]], <2 x i64> <i64 1, i64 2>, <2 x i64> zeroinitializer
 468 ; CHECK-NEXT:    ret <2 x i64> [[R]]
 469 ;
 470   %V = select <2 x i1> %C, <2 x i64> <i64 1, i64 2>, <2 x i64> <i64 8, i64 9>
 471   %R = urem <2 x i64> %V, <i64 2, i64 3>
 472   ret <2 x i64> %R
 473 }
 474
 475 define i32 @test21(i1 %c0, i32* %p) {
 476 ; CHECK-LABEL: @test21(
 477 ; CHECK-NEXT:  entry:
 478 ; CHECK-NEXT:    br i1 [[C0:%.*]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 479 ; CHECK:       if.then:
 480 ; CHECK-NEXT:    [[V:%.*]] = load volatile i32, i32* [[P:%.*]], align 4
 481 ; CHECK-NEXT:    [[PHI_BO:%.*]] = srem i32 [[V]], 5
 482 ; CHECK-NEXT:    br label [[IF_END]]
 483 ; CHECK:       if.end:
 484 ; CHECK-NEXT:    [[LHS:%.*]] = phi i32 [ [[PHI_BO]], [[IF_THEN]] ], [ 0, [[ENTRY:%.*]] ]
 485 ; CHECK-NEXT:    ret i32 [[LHS]]
 486 ;
 487 entry:
 488   br i1 %c0, label %if.then, label %if.end
 489
 490 if.then:
 491   %v = load volatile i32, i32* %p
 492   br label %if.end
 493
 494 if.end:
 495   %lhs = phi i32 [ %v, %if.then ], [ 5, %entry ]
 496   %rem = srem i32 %lhs, 5
 497   ret i32 %rem
 498 }
 499
 500 @a = common global [5 x i16] zeroinitializer, align 2
 501 @b = common global i16 0, align 2
 502
 503 define i32 @pr27968_0(i1 %c0, i32* %p) {
 504 ; CHECK-LABEL: @pr27968_0(
 505 ; CHECK-NEXT:  entry:
 506 ; CHECK-NEXT:    br i1 [[C0:%.*]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 507 ; CHECK:       if.then:
 508 ; CHECK-NEXT:    [[V:%.*]] = load volatile i32, i32* [[P:%.*]], align 4
 509 ; CHECK-NEXT:    br label [[IF_END]]
 510 ; CHECK:       if.end:
 511 ; CHECK-NEXT:    br i1 icmp eq (i16* getelementptr inbounds ([5 x i16], [5 x i16]* @a, i64 0, i64 4), i16* @b), label [[REM_IS_SAFE:%.*]], label [[REM_IS_UNSAFE:%.*]]
 512 ; CHECK:       rem.is.safe:
 513 ; CHECK-NEXT:    ret i32 0
 514 ; CHECK:       rem.is.unsafe:
 515 ; CHECK-NEXT:    ret i32 0
 516 ;
 517 entry:
 518   br i1 %c0, label %if.then, label %if.end
 519
 520 if.then:
 521   %v = load volatile i32, i32* %p
 522   br label %if.end
 523
 524 if.end:
 525   %lhs = phi i32 [ %v, %if.then ], [ 5, %entry ]
 526   br i1 icmp eq (i16* getelementptr inbounds ([5 x i16], [5 x i16]* @a, i64 0, i64 4), i16* @b), label %rem.is.safe, label %rem.is.unsafe
 527
 528 rem.is.safe:
 529   %rem = srem i32 %lhs, zext (i1 icmp eq (i16* getelementptr inbounds ([5 x i16], [5 x i16]* @a, i64 0, i64 4), i16* @b) to i32)
 530   ret i32 %rem
 531
 532 rem.is.unsafe:
 533   ret i32 0
 534 }
 535
 536 define i32 @pr27968_1(i1 %c0, i1 %always_false, i32* %p) {
 537 ; CHECK-LABEL: @pr27968_1(
 538 ; CHECK-NEXT:  entry:
 539 ; CHECK-NEXT:    br i1 [[C0:%.*]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 540 ; CHECK:       if.then:
 541 ; CHECK-NEXT:    [[V:%.*]] = load volatile i32, i32* [[P:%.*]], align 4
 542 ; CHECK-NEXT:    br label [[IF_END]]
 543 ; CHECK:       if.end:
 544 ; CHECK-NEXT:    [[LHS:%.*]] = phi i32 [ [[V]], [[IF_THEN]] ], [ 5, [[ENTRY:%.*]] ]
 545 ; CHECK-NEXT:    br i1 [[ALWAYS_FALSE:%.*]], label [[REM_IS_SAFE:%.*]], label [[REM_IS_UNSAFE:%.*]]
 546 ; CHECK:       rem.is.safe:
 547 ; CHECK-NEXT:    [[REM:%.*]] = srem i32 [[LHS]], -2147483648
 548 ; CHECK-NEXT:    ret i32 [[REM]]
 549 ; CHECK:       rem.is.unsafe:
 550 ; CHECK-NEXT:    ret i32 0
 551 ;
 552 entry:
 553   br i1 %c0, label %if.then, label %if.end
 554
 555 if.then:
 556   %v = load volatile i32, i32* %p
 557   br label %if.end
 558
 559 if.end:
 560   %lhs = phi i32 [ %v, %if.then ], [ 5, %entry ]
 561   br i1 %always_false, label %rem.is.safe, label %rem.is.unsafe
 562
 563 rem.is.safe:
 564   %rem = srem i32 %lhs, -2147483648
 565   ret i32 %rem
 566
 567 rem.is.unsafe:
 568   ret i32 0
 569 }
 570
 571 define i32 @pr27968_2(i1 %c0, i32* %p) {
 572 ; CHECK-LABEL: @pr27968_2(
 573 ; CHECK-NEXT:  entry:
 574 ; CHECK-NEXT:    br i1 [[C0:%.*]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 575 ; CHECK:       if.then:
 576 ; CHECK-NEXT:    [[V:%.*]] = load volatile i32, i32* [[P:%.*]], align 4
 577 ; CHECK-NEXT:    br label [[IF_END]]
 578 ; CHECK:       if.end:
 579 ; CHECK-NEXT:    br i1 icmp eq (i16* getelementptr inbounds ([5 x i16], [5 x i16]* @a, i64 0, i64 4), i16* @b), label [[REM_IS_SAFE:%.*]], label [[REM_IS_UNSAFE:%.*]]
 580 ; CHECK:       rem.is.safe:
 581 ; CHECK-NEXT:    ret i32 0
 582 ; CHECK:       rem.is.unsafe:
 583 ; CHECK-NEXT:    ret i32 0
 584 ;
 585 entry:
 586   br i1 %c0, label %if.then, label %if.end
 587
 588 if.then:
 589   %v = load volatile i32, i32* %p
 590   br label %if.end
 591
 592 if.end:
 593   %lhs = phi i32 [ %v, %if.then ], [ 5, %entry ]
 594   br i1 icmp eq (i16* getelementptr inbounds ([5 x i16], [5 x i16]* @a, i64 0, i64 4), i16* @b), label %rem.is.safe, label %rem.is.unsafe
 595
 596 rem.is.safe:
 597   %rem = urem i32 %lhs, zext (i1 icmp eq (i16* getelementptr inbounds ([5 x i16], [5 x i16]* @a, i64 0, i64 4), i16* @b) to i32)
 598   ret i32 %rem
 599
 600 rem.is.unsafe:
 601   ret i32 0
 602 }
 603
 604 define i32 @pr27968_3(i1 %c0, i1 %always_false, i32* %p) {
 605 ; CHECK-LABEL: @pr27968_3(
 606 ; CHECK-NEXT:  entry:
 607 ; CHECK-NEXT:    br i1 [[C0:%.*]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 608 ; CHECK:       if.then:
 609 ; CHECK-NEXT:    [[V:%.*]] = load volatile i32, i32* [[P:%.*]], align 4
 610 ; CHECK-NEXT:    [[PHI_BO:%.*]] = and i32 [[V]], 2147483647
 611 ; CHECK-NEXT:    br label [[IF_END]]
 612 ; CHECK:       if.end:
 613 ; CHECK-NEXT:    [[LHS:%.*]] = phi i32 [ [[PHI_BO]], [[IF_THEN]] ], [ 5, [[ENTRY:%.*]] ]
 614 ; CHECK-NEXT:    br i1 [[ALWAYS_FALSE:%.*]], label [[REM_IS_SAFE:%.*]], label [[REM_IS_UNSAFE:%.*]]
 615 ; CHECK:       rem.is.safe:
 616 ; CHECK-NEXT:    ret i32 [[LHS]]
 617 ; CHECK:       rem.is.unsafe:
 618 ; CHECK-NEXT:    ret i32 0
 619 ;
 620 entry:
 621   br i1 %c0, label %if.then, label %if.end
 622
 623 if.then:
 624   %v = load volatile i32, i32* %p
 625   br label %if.end
 626
 627 if.end:
 628   %lhs = phi i32 [ %v, %if.then ], [ 5, %entry ]
 629   br i1 %always_false, label %rem.is.safe, label %rem.is.unsafe
 630
 631 rem.is.safe:
 632   %rem = urem i32 %lhs, -2147483648
 633   ret i32 %rem
 634
 635 rem.is.unsafe:
 636   ret i32 0
 637 }
 638
 639 define i32 @test22(i32 %A) {
 640 ; CHECK-LABEL: @test22(
 641 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[A:%.*]], 2147483647
 642 ; CHECK-NEXT:    [[MUL:%.*]] = urem i32 [[AND]], 2147483647
 643 ; CHECK-NEXT:    ret i32 [[MUL]]
 644 ;
 645   %and = and i32 %A, 2147483647
 646   %mul = srem i32 %and, 2147483647
 647   ret i32 %mul
 648 }
 649
 650 define <2 x i32> @test23(<2 x i32> %A) {
 651 ; CHECK-LABEL: @test23(
 652 ; CHECK-NEXT:    [[AND:%.*]] = and <2 x i32> [[A:%.*]], <i32 2147483647, i32 2147483647>
 653 ; CHECK-NEXT:    [[MUL:%.*]] = urem <2 x i32> [[AND]], <i32 2147483647, i32 2147483647>
 654 ; CHECK-NEXT:    ret <2 x i32> [[MUL]]
 655 ;
 656   %and = and <2 x i32> %A, <i32 2147483647, i32 2147483647>
 657   %mul = srem <2 x i32> %and, <i32 2147483647, i32 2147483647>
 658   ret <2 x i32> %mul
 659 }
 660
 661 define i1 @test24(i32 %A) {
 662 ; CHECK-LABEL: @test24(
 663 ; CHECK-NEXT:    [[B:%.*]] = and i32 [[A:%.*]], 2147483647
 664 ; CHECK-NEXT:    [[C:%.*]] = icmp ne i32 [[B]], 0
 665 ; CHECK-NEXT:    ret i1 [[C]]
 666 ;
 667   %B = urem i32 %A, 2147483648 ; signbit
 668   %C = icmp ne i32 %B, 0
 669   ret i1 %C
 670 }
 671
 672 define <2 x i1> @test24_vec(<2 x i32> %A) {
 673 ; CHECK-LABEL: @test24_vec(
 674 ; CHECK-NEXT:    [[B:%.*]] = and <2 x i32> [[A:%.*]], <i32 2147483647, i32 2147483647>
 675 ; CHECK-NEXT:    [[C:%.*]] = icmp ne <2 x i32> [[B]], zeroinitializer
 676 ; CHECK-NEXT:    ret <2 x i1> [[C]]
 677 ;
 678   %B = urem <2 x i32> %A, <i32 2147483648, i32 2147483648>
 679   %C = icmp ne <2 x i32> %B, zeroinitializer
 680   ret <2 x i1> %C
 681 }
 682
 683 define i1 @test25(i32 %A) {
 684 ; CHECK-LABEL: @test25(
 685 ; CHECK-NEXT:    [[TMP1:%.*]] = and i32 [[A:%.*]], 2147483647
 686 ; CHECK-NEXT:    [[C:%.*]] = icmp ne i32 [[TMP1]], 0
 687 ; CHECK-NEXT:    ret i1 [[C]]
 688 ;
 689   %B = srem i32 %A, 2147483648 ; signbit
 690   %C = icmp ne i32 %B, 0
 691   ret i1 %C
 692 }
 693
 694 define <2 x i1> @test25_vec(<2 x i32> %A) {
 695 ; CHECK-LABEL: @test25_vec(
 696 ; CHECK-NEXT:    [[TMP1:%.*]] = and <2 x i32> [[A:%.*]], <i32 2147483647, i32 2147483647>
 697 ; CHECK-NEXT:    [[C:%.*]] = icmp ne <2 x i32> [[TMP1]], zeroinitializer
 698 ; CHECK-NEXT:    ret <2 x i1> [[C]]
 699 ;
 700   %B = srem <2 x i32> %A, <i32 2147483648, i32 2147483648>
 701   %C = icmp ne <2 x i32> %B, zeroinitializer
 702   ret <2 x i1> %C
 703 }
 704
 705 define i1 @test26(i32 %A, i32 %B) {
 706 ; CHECK-LABEL: @test26(
 707 ; CHECK-NEXT:    [[NOTMASK:%.*]] = shl nsw i32 -1, [[B:%.*]]
 708 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[NOTMASK]], -1
 709 ; CHECK-NEXT:    [[TMP2:%.*]] = and i32 [[TMP1]], [[A:%.*]]
 710 ; CHECK-NEXT:    [[E:%.*]] = icmp ne i32 [[TMP2]], 0
 711 ; CHECK-NEXT:    ret i1 [[E]]
 712 ;
 713   %C = shl i32 1, %B ; not a constant
 714   %D = srem i32 %A, %C
 715   %E = icmp ne i32 %D, 0
 716   ret i1 %E
 717 }
 718
 719 define i1 @test27(i32 %A, i32* %remdst) {
 720 ; CHECK-LABEL: @test27(
 721 ; CHECK-NEXT:    [[B:%.*]] = srem i32 [[A:%.*]], -2147483648
 722 ; CHECK-NEXT:    store i32 [[B]], i32* [[REMDST:%.*]], align 1
 723 ; CHECK-NEXT:    [[C:%.*]] = icmp ne i32 [[B]], 0
 724 ; CHECK-NEXT:    ret i1 [[C]]
 725 ;
 726   %B = srem i32 %A, 2147483648 ; signbit
 727   store i32 %B, i32* %remdst, align 1 ; extra use of rem
 728   %C = icmp ne i32 %B, 0
 729   ret i1 %C
 730 }
 731
 732 define i1 @test28(i32 %A) {
 733 ; CHECK-LABEL: @test28(
 734 ; CHECK-NEXT:    [[TMP1:%.*]] = and i32 [[A:%.*]], 2147483647
 735 ; CHECK-NEXT:    [[C:%.*]] = icmp eq i32 [[TMP1]], 0
 736 ; CHECK-NEXT:    ret i1 [[C]]
 737 ;
 738   %B = srem i32 %A, 2147483648 ; signbit
 739   %C = icmp eq i32 %B, 0 ; another equality predicate
 740   ret i1 %C
 741 }
 742
 743 define i1 @positive_and_odd(i32 %A) {
 744 ; CHECK-LABEL: @positive_and_odd(
 745 ; CHECK-NEXT:    [[B:%.*]] = srem i32 [[A:%.*]], 2
 746 ; CHECK-NEXT:    [[C:%.*]] = icmp eq i32 [[B]], 1
 747 ; CHECK-NEXT:    ret i1 [[C]]
 748 ;
 749   %B = srem i32 %A, 2
 750   %C = icmp eq i32 %B, 1
 751   ret i1 %C
 752 }
 753
 754 define i1 @negative_and_odd(i32 %A) {
 755 ; CHECK-LABEL: @negative_and_odd(
 756 ; CHECK-NEXT:    [[B:%.*]] = srem i32 [[A:%.*]], 2
 757 ; CHECK-NEXT:    [[C:%.*]] = icmp eq i32 [[B]], -1
 758 ; CHECK-NEXT:    ret i1 [[C]]
 759 ;
 760   %B = srem i32 %A, 2
 761   %C = icmp eq i32 %B, -1
 762   ret i1 %C
 763 }
 764
 765 ; FP division-by-zero is not UB.
 766
 767 define double @PR34870(i1 %cond, double %x, double %y) {
 768 ; CHECK-LABEL: @PR34870(
 769 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[COND:%.*]], double [[Y:%.*]], double 0.000000e+00
 770 ; CHECK-NEXT:    [[FMOD:%.*]] = frem double [[X:%.*]], [[SEL]]
 771 ; CHECK-NEXT:    ret double [[FMOD]]
 772 ;
 773   %sel = select i1 %cond, double %y, double 0.0
 774   %fmod = frem double %x, %sel
 775   ret double %fmod
 776 }
 777
 778 define i32 @srem_constant_dividend_select_of_constants_divisor(i1 %b) {
 779 ; CHECK-LABEL: @srem_constant_dividend_select_of_constants_divisor(
 780 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[B:%.*]], i32 6, i32 0
 781 ; CHECK-NEXT:    ret i32 [[R]]
 782 ;
 783   %s = select i1 %b, i32 12, i32 -3
 784   %r = srem i32 42, %s
 785   ret i32 %r
 786 }
 787
 788 ; TODO: srem should still be replaced by select.
 789
 790 define i32 @srem_constant_dividend_select_of_constants_divisor_use(i1 %b) {
 791 ; CHECK-LABEL: @srem_constant_dividend_select_of_constants_divisor_use(
 792 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[B:%.*]], i32 12, i32 -3
 793 ; CHECK-NEXT:    call void @use(i32 [[S]])
 794 ; CHECK-NEXT:    [[R:%.*]] = srem i32 42, [[S]]
 795 ; CHECK-NEXT:    ret i32 [[R]]
 796 ;
 797   %s = select i1 %b, i32 12, i32 -3
 798   call void @use(i32 %s)
 799   %r = srem i32 42, %s
 800   ret i32 %r
 801 }
 802
 803 ; Rem-by-0 is immediate UB, so select is simplified.
 804
 805 define i32 @srem_constant_dividend_select_of_constants_divisor_0_arm(i1 %b) {
 806 ; CHECK-LABEL: @srem_constant_dividend_select_of_constants_divisor_0_arm(
 807 ; CHECK-NEXT:    ret i32 6
 808 ;
 809   %s = select i1 %b, i32 12, i32 0
 810   %r = srem i32 42, %s
 811   ret i32 %r
 812 }
 813
 814 ; negative test - not safe to speculate rem with variable divisor
 815
 816 define i32 @srem_constant_dividend_select_divisor1(i1 %b, i32 %x) {
 817 ; CHECK-LABEL: @srem_constant_dividend_select_divisor1(
 818 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[B:%.*]], i32 [[X:%.*]], i32 -3
 819 ; CHECK-NEXT:    [[R:%.*]] = srem i32 42, [[S]]
 820 ; CHECK-NEXT:    ret i32 [[R]]
 821 ;
 822   %s = select i1 %b, i32 %x, i32 -3
 823   %r = srem i32 42, %s
 824   ret i32 %r
 825 }
 826
 827 ; negative test - not safe to speculate rem with variable divisor
 828
 829 define i32 @srem_constant_dividend_select_divisor2(i1 %b, i32 %x) {
 830 ; CHECK-LABEL: @srem_constant_dividend_select_divisor2(
 831 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[B:%.*]], i32 12, i32 [[X:%.*]]
 832 ; CHECK-NEXT:    [[R:%.*]] = srem i32 42, [[S]]
 833 ; CHECK-NEXT:    ret i32 [[R]]
 834 ;
 835   %s = select i1 %b, i32 12, i32 %x
 836   %r = srem i32 42, %s
 837   ret i32 %r
 838 }
 839
 840 define <2 x i8> @srem_constant_dividend_select_of_constants_divisor_vec(i1 %b) {
 841 ; CHECK-LABEL: @srem_constant_dividend_select_of_constants_divisor_vec(
 842 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[B:%.*]], <2 x i8> <i8 6, i8 -2>, <2 x i8> <i8 2, i8 -2>
 843 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 844 ;
 845   %s = select i1 %b, <2 x i8> <i8 12, i8 -5>, <2 x i8> <i8 -4, i8 4>
 846   %r = srem <2 x i8> <i8 42, i8 -42>, %s
 847   ret <2 x i8> %r
 848 }
 849
 850 ; Rem-by-0 element is immediate UB, so select is simplified.
 851
 852 define <2 x i8> @srem_constant_dividend_select_of_constants_divisor_vec_ub1(i1 %b) {
 853 ; CHECK-LABEL: @srem_constant_dividend_select_of_constants_divisor_vec_ub1(
 854 ; CHECK-NEXT:    ret <2 x i8> <i8 2, i8 -2>
 855 ;
 856   %s = select i1 %b, <2 x i8> <i8 0, i8 -5>, <2 x i8> <i8 -4, i8 4>
 857   %r = srem <2 x i8> <i8 42, i8 -42>, %s
 858   ret <2 x i8> %r
 859 }
 860
 861 ; SMIN % -1 element is poison.
 862
 863 define <2 x i8> @srem_constant_dividend_select_of_constants_divisor_vec_ub2(i1 %b) {
 864 ; CHECK-LABEL: @srem_constant_dividend_select_of_constants_divisor_vec_ub2(
 865 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[B:%.*]], <2 x i8> <i8 6, i8 -3>, <2 x i8> <i8 2, i8 poison>
 866 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 867 ;
 868   %s = select i1 %b, <2 x i8> <i8 12, i8 -5>, <2 x i8> <i8 -4, i8 -1>
 869   %r = srem <2 x i8> <i8 42, i8 -128>, %s
 870   ret <2 x i8> %r
 871 }
 872
 873 ; negative test - must have constant dividend
 874
 875 define i32 @srem_select_of_constants_divisor(i1 %b, i32 %x) {
 876 ; CHECK-LABEL: @srem_select_of_constants_divisor(
 877 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[B:%.*]], i32 12, i32 -3
 878 ; CHECK-NEXT:    [[R:%.*]] = srem i32 [[X:%.*]], [[S]]
 879 ; CHECK-NEXT:    ret i32 [[R]]
 880 ;
 881   %s = select i1 %b, i32 12, i32 -3
 882   %r = srem i32 %x, %s
 883   ret i32 %r
 884 }
 885
 886 define i32 @urem_constant_dividend_select_of_constants_divisor(i1 %b) {
 887 ; CHECK-LABEL: @urem_constant_dividend_select_of_constants_divisor(
 888 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[B:%.*]], i32 6, i32 42
 889 ; CHECK-NEXT:    ret i32 [[R]]
 890 ;
 891   %s = select i1 %b, i32 12, i32 -3
 892   %r = urem i32 42, %s
 893   ret i32 %r
 894 }
 895
 896 ; TODO: urem should still be replaced by select.
 897
 898 define i32 @urem_constant_dividend_select_of_constants_divisor_use(i1 %b) {
 899 ; CHECK-LABEL: @urem_constant_dividend_select_of_constants_divisor_use(
 900 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[B:%.*]], i32 12, i32 -3
 901 ; CHECK-NEXT:    call void @use(i32 [[S]])
 902 ; CHECK-NEXT:    [[R:%.*]] = urem i32 42, [[S]]
 903 ; CHECK-NEXT:    ret i32 [[R]]
 904 ;
 905   %s = select i1 %b, i32 12, i32 -3
 906   call void @use(i32 %s)
 907   %r = urem i32 42, %s
 908   ret i32 %r
 909 }
 910
 911 ; Rem-by-0 is immediate UB, so select is simplified.
 912
 913 define i32 @urem_constant_dividend_select_of_constants_divisor_0_arm(i1 %b) {
 914 ; CHECK-LABEL: @urem_constant_dividend_select_of_constants_divisor_0_arm(
 915 ; CHECK-NEXT:    ret i32 6
 916 ;
 917   %s = select i1 %b, i32 12, i32 0
 918   %r = urem i32 42, %s
 919   ret i32 %r
 920 }
 921
 922 ; negative test - not safe to speculate rem with variable divisor
 923
 924 define i32 @urem_constant_dividend_select_divisor1(i1 %b, i32 %x) {
 925 ; CHECK-LABEL: @urem_constant_dividend_select_divisor1(
 926 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[B:%.*]], i32 [[X:%.*]], i32 -3
 927 ; CHECK-NEXT:    [[R:%.*]] = urem i32 42, [[S]]
 928 ; CHECK-NEXT:    ret i32 [[R]]
 929 ;
 930   %s = select i1 %b, i32 %x, i32 -3
 931   %r = urem i32 42, %s
 932   ret i32 %r
 933 }
 934
 935 ; negative test - not safe to speculate rem with variable divisor
 936
 937 define i32 @urem_constant_dividend_select_divisor2(i1 %b, i32 %x) {
 938 ; CHECK-LABEL: @urem_constant_dividend_select_divisor2(
 939 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[B:%.*]], i32 12, i32 [[X:%.*]]
 940 ; CHECK-NEXT:    [[R:%.*]] = urem i32 42, [[S]]
 941 ; CHECK-NEXT:    ret i32 [[R]]
 942 ;
 943   %s = select i1 %b, i32 12, i32 %x
 944   %r = urem i32 42, %s
 945   ret i32 %r
 946 }
 947
 948 define <2 x i8> @urem_constant_dividend_select_of_constants_divisor_vec(i1 %b) {
 949 ; CHECK-LABEL: @urem_constant_dividend_select_of_constants_divisor_vec(
 950 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[B:%.*]], <2 x i8> <i8 6, i8 -42>, <2 x i8> <i8 42, i8 2>
 951 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 952 ;
 953   %s = select i1 %b, <2 x i8> <i8 12, i8 -5>, <2 x i8> <i8 -4, i8 4>
 954   %r = urem <2 x i8> <i8 42, i8 -42>, %s
 955   ret <2 x i8> %r
 956 }
 957
 958 ; Rem-by-0 element is immediate UB, so select is simplified.
 959
 960 define <2 x i8> @urem_constant_dividend_select_of_constants_divisor_vec_ub1(i1 %b) {
 961 ; CHECK-LABEL: @urem_constant_dividend_select_of_constants_divisor_vec_ub1(
 962 ; CHECK-NEXT:    ret <2 x i8> <i8 42, i8 2>
 963 ;
 964   %s = select i1 %b, <2 x i8> <i8 0, i8 -5>, <2 x i8> <i8 -4, i8 4>
 965   %r = urem <2 x i8> <i8 42, i8 -42>, %s
 966   ret <2 x i8> %r
 967 }
 968
 969 ; There's no unsigned equivalent to "SMIN % -1", so this is just the usual constant folding.
 970
 971 define <2 x i8> @urem_constant_dividend_select_of_constants_divisor_vec_ub2(i1 %b) {
 972 ; CHECK-LABEL: @urem_constant_dividend_select_of_constants_divisor_vec_ub2(
 973 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[B:%.*]], <2 x i8> <i8 6, i8 -128>, <2 x i8> <i8 42, i8 -128>
 974 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 975 ;
 976   %s = select i1 %b, <2 x i8> <i8 12, i8 -5>, <2 x i8> <i8 -4, i8 -1>
 977   %r = urem <2 x i8> <i8 42, i8 -128>, %s
 978   ret <2 x i8> %r
 979 }
 980
 981 ; negative test - must have constant dividend
 982
 983 define i32 @urem_select_of_constants_divisor(i1 %b, i32 %x) {
 984 ; CHECK-LABEL: @urem_select_of_constants_divisor(
 985 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[B:%.*]], i32 12, i32 -3
 986 ; CHECK-NEXT:    [[R:%.*]] = urem i32 [[X:%.*]], [[S]]
 987 ; CHECK-NEXT:    ret i32 [[R]]
 988 ;
 989   %s = select i1 %b, i32 12, i32 -3
 990   %r = urem i32 %x, %s
 991   ret i32 %r
 992 }