; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=instsimplify -S | FileCheck %s

define i32 @zero_dividend(i32 %A) {
; CHECK-LABEL: @zero_dividend(
; CHECK-NEXT:    ret i32 0
;
  %B = urem i32 0, %A
  ret i32 %B
}

define <2 x i32> @zero_dividend_vector(<2 x i32> %A) {
; CHECK-LABEL: @zero_dividend_vector(
; CHECK-NEXT:    ret <2 x i32> zeroinitializer
;
  %B = srem <2 x i32> zeroinitializer, %A
  ret <2 x i32> %B
}

define <2 x i32> @zero_dividend_vector_poison_elt(<2 x i32> %A) {
; CHECK-LABEL: @zero_dividend_vector_poison_elt(
; CHECK-NEXT:    ret <2 x i32> zeroinitializer
;
  %B = urem <2 x i32> <i32 poison, i32 0>, %A
  ret <2 x i32> %B
}

; Division-by-zero is poison. UB in any vector lane means the whole op is poison.

define <2 x i8> @srem_zero_elt_vec_constfold(<2 x i8> %x) {
; CHECK-LABEL: @srem_zero_elt_vec_constfold(
; CHECK-NEXT:    ret <2 x i8> <i8 poison, i8 2>
;
  %rem = srem <2 x i8> <i8 1, i8 2>, <i8 0, i8 -42>
  ret <2 x i8> %rem
}

define <2 x i8> @urem_zero_elt_vec_constfold(<2 x i8> %x) {
; CHECK-LABEL: @urem_zero_elt_vec_constfold(
; CHECK-NEXT:    ret <2 x i8> <i8 1, i8 poison>
;
  %rem = urem <2 x i8> <i8 1, i8 2>, <i8 42, i8 0>
  ret <2 x i8> %rem
}

define <2 x i8> @srem_zero_elt_vec(<2 x i8> %x) {
; CHECK-LABEL: @srem_zero_elt_vec(
; CHECK-NEXT:    [[REM:%.*]] = srem <2 x i8> [[X:%.*]], <i8 -42, i8 0>
; CHECK-NEXT:    ret <2 x i8> [[REM]]
;
  %rem = srem <2 x i8> %x, <i8 -42, i8 0>
  ret <2 x i8> %rem
}

define <2 x i8> @urem_zero_elt_vec(<2 x i8> %x) {
; CHECK-LABEL: @urem_zero_elt_vec(
; CHECK-NEXT:    [[REM:%.*]] = urem <2 x i8> [[X:%.*]], <i8 0, i8 42>
; CHECK-NEXT:    ret <2 x i8> [[REM]]
;
  %rem = urem <2 x i8> %x, <i8 0, i8 42>
  ret <2 x i8> %rem
}

define <2 x i8> @srem_undef_elt_vec(<2 x i8> %x) {
; CHECK-LABEL: @srem_undef_elt_vec(
; CHECK-NEXT:    [[REM:%.*]] = srem <2 x i8> [[X:%.*]], <i8 -42, i8 undef>
; CHECK-NEXT:    ret <2 x i8> [[REM]]
;
  %rem = srem <2 x i8> %x, <i8 -42, i8 undef>
  ret <2 x i8> %rem
}

define <2 x i8> @urem_undef_elt_vec(<2 x i8> %x) {
; CHECK-LABEL: @urem_undef_elt_vec(
; CHECK-NEXT:    [[REM:%.*]] = urem <2 x i8> [[X:%.*]], <i8 undef, i8 42>
; CHECK-NEXT:    ret <2 x i8> [[REM]]
;
  %rem = urem <2 x i8> %x, <i8 undef, i8 42>
  ret <2 x i8> %rem
}

; Division-by-zero is undef. UB in any vector lane means the whole op is undef.
; Thus, we can simplify this: if any element of 'y' is 0, we can do anything.
; Therefore, assume that all elements of 'y' must be 1.

define <2 x i1> @srem_bool_vec(<2 x i1> %x, <2 x i1> %y) {
; CHECK-LABEL: @srem_bool_vec(
; CHECK-NEXT:    ret <2 x i1> zeroinitializer
;
  %rem = srem <2 x i1> %x, %y
  ret <2 x i1> %rem
}

define <2 x i1> @urem_bool_vec(<2 x i1> %x, <2 x i1> %y) {
; CHECK-LABEL: @urem_bool_vec(
; CHECK-NEXT:    ret <2 x i1> zeroinitializer
;
  %rem = urem <2 x i1> %x, %y
  ret <2 x i1> %rem
}

define <2 x i32> @zext_bool_urem_divisor_vec(<2 x i1> %x, <2 x i32> %y) {
; CHECK-LABEL: @zext_bool_urem_divisor_vec(
; CHECK-NEXT:    ret <2 x i32> zeroinitializer
;
  %ext = zext <2 x i1> %x to <2 x i32>
  %r = urem <2 x i32> %y, %ext
  ret <2 x i32> %r
}

define i32 @zext_bool_srem_divisor(i1 %x, i32 %y) {
; CHECK-LABEL: @zext_bool_srem_divisor(
; CHECK-NEXT:    ret i32 0
;
  %ext = zext i1 %x to i32
  %r = srem i32 %y, %ext
  ret i32 %r
}

define i32 @select1(i32 %x, i1 %b) {
; CHECK-LABEL: @select1(
; CHECK-NEXT:    ret i32 0
;
  %rhs = select i1 %b, i32 %x, i32 1
  %rem = srem i32 %x, %rhs
  ret i32 %rem
}

define i32 @select2(i32 %x, i1 %b) {
; CHECK-LABEL: @select2(
; CHECK-NEXT:    ret i32 0
;
  %rhs = select i1 %b, i32 %x, i32 1
  %rem = urem i32 %x, %rhs
  ret i32 %rem
}

define i32 @rem1(i32 %x, i32 %n) {
; CHECK-LABEL: @rem1(
; CHECK-NEXT:    [[MOD:%.*]] = srem i32 [[X:%.*]], [[N:%.*]]
; CHECK-NEXT:    ret i32 [[MOD]]
;
  %mod = srem i32 %x, %n
  %mod1 = srem i32 %mod, %n
  ret i32 %mod1
}

define i32 @rem2(i32 %x, i32 %n) {
; CHECK-LABEL: @rem2(
; CHECK-NEXT:    [[MOD:%.*]] = urem i32 [[X:%.*]], [[N:%.*]]
; CHECK-NEXT:    ret i32 [[MOD]]
;
  %mod = urem i32 %x, %n
  %mod1 = urem i32 %mod, %n
  ret i32 %mod1
}

define i32 @rem3(i32 %x, i32 %n) {
; CHECK-LABEL: @rem3(
; CHECK-NEXT:    [[MOD:%.*]] = srem i32 [[X:%.*]], [[N:%.*]]
; CHECK-NEXT:    [[MOD1:%.*]] = urem i32 [[MOD]], [[N]]
; CHECK-NEXT:    ret i32 [[MOD1]]
;
  %mod = srem i32 %x, %n
  %mod1 = urem i32 %mod, %n
  ret i32 %mod1
}

define i32 @urem_dividend_known_smaller_than_constant_divisor(i32 %x) {
; CHECK-LABEL: @urem_dividend_known_smaller_than_constant_divisor(
; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 250
; CHECK-NEXT:    ret i32 [[AND]]
;
  %and = and i32 %x, 250
  %r = urem i32 %and, 251
  ret i32 %r
}

define i32 @not_urem_dividend_known_smaller_than_constant_divisor(i32 %x) {
; CHECK-LABEL: @not_urem_dividend_known_smaller_than_constant_divisor(
; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 251
; CHECK-NEXT:    [[R:%.*]] = urem i32 [[AND]], 251
; CHECK-NEXT:    ret i32 [[R]]
;
  %and = and i32 %x, 251
  %r = urem i32 %and, 251
  ret i32 %r
}

define i8 @urem_dividend_known_smaller_than_constant_divisor2(i1 %b) {
; CHECK-LABEL: @urem_dividend_known_smaller_than_constant_divisor2(
; CHECK-NEXT:    [[T0:%.*]] = zext i1 [[B:%.*]] to i8
; CHECK-NEXT:    [[XOR:%.*]] = xor i8 [[T0]], 12
; CHECK-NEXT:    ret i8 [[XOR]]
;
  %t0 = zext i1 %b to i8
  %xor = xor i8 %t0, 12
  %r = urem i8 %xor, 14
  ret i8 %r
}

; negative test - dividend can equal 13

define i8 @not_urem_dividend_known_smaller_than_constant_divisor2(i1 %b) {
; CHECK-LABEL: @not_urem_dividend_known_smaller_than_constant_divisor2(
; CHECK-NEXT:    [[T0:%.*]] = zext i1 [[B:%.*]] to i8
; CHECK-NEXT:    [[XOR:%.*]] = xor i8 [[T0]], 12
; CHECK-NEXT:    [[R:%.*]] = urem i8 [[XOR]], 13
; CHECK-NEXT:    ret i8 [[R]]
;
  %t0 = zext i1 %b to i8
  %xor = xor i8 %t0, 12
  %r = urem i8 %xor, 13
  ret i8 %r
}

define i32 @urem_constant_dividend_known_smaller_than_divisor(i32 %x) {
; CHECK-LABEL: @urem_constant_dividend_known_smaller_than_divisor(
; CHECK-NEXT:    ret i32 250
;
  %or = or i32 %x, 251
  %r = urem i32 250, %or
  ret i32 %r
}

define i32 @not_urem_constant_dividend_known_smaller_than_divisor(i32 %x) {
; CHECK-LABEL: @not_urem_constant_dividend_known_smaller_than_divisor(
; CHECK-NEXT:    [[OR:%.*]] = or i32 [[X:%.*]], 251
; CHECK-NEXT:    [[R:%.*]] = urem i32 251, [[OR]]
; CHECK-NEXT:    ret i32 [[R]]
;
  %or = or i32 %x, 251
  %r = urem i32 251, %or
  ret i32 %r
}

; This would require computing known bits on both x and y. Is it worth doing?

define i32 @urem_dividend_known_smaller_than_divisor(i32 %x, i32 %y) {
; CHECK-LABEL: @urem_dividend_known_smaller_than_divisor(
; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 250
; CHECK-NEXT:    [[OR:%.*]] = or i32 [[Y:%.*]], 251
; CHECK-NEXT:    [[R:%.*]] = urem i32 [[AND]], [[OR]]
; CHECK-NEXT:    ret i32 [[R]]
;
  %and = and i32 %x, 250
  %or = or i32 %y, 251
  %r = urem i32 %and, %or
  ret i32 %r
}

define i32 @not_urem_dividend_known_smaller_than_divisor(i32 %x, i32 %y) {
; CHECK-LABEL: @not_urem_dividend_known_smaller_than_divisor(
; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], 251
; CHECK-NEXT:    [[OR:%.*]] = or i32 [[Y:%.*]], 251
; CHECK-NEXT:    [[R:%.*]] = urem i32 [[AND]], [[OR]]
; CHECK-NEXT:    ret i32 [[R]]
;
  %and = and i32 %x, 251
  %or = or i32 %y, 251
  %r = urem i32 %and, %or
  ret i32 %r
}

declare i32 @external()

define i32 @rem4() {
; CHECK-LABEL: @rem4(
; CHECK-NEXT:    [[CALL:%.*]] = call i32 @external(), !range [[RNG0:![0-9]+]]
; CHECK-NEXT:    ret i32 [[CALL]]
;
  %call = call i32 @external() , !range !0
  %urem = urem i32 %call, 3
  ret i32 %urem
}

!0 = !{i32 0, i32 3}

define i32 @rem5(i32 %x, i32 %y) {
; CHECK-LABEL: @rem5(
; CHECK-NEXT:    ret i32 0
;
  %shl = shl nsw i32 %x, %y
  %mod = srem i32 %shl, %x
  ret i32 %mod
}

define <2 x i32> @rem6(<2 x i32> %x, <2 x i32> %y) {
; CHECK-LABEL: @rem6(
; CHECK-NEXT:    ret <2 x i32> zeroinitializer
;
  %shl = shl nsw <2 x i32> %x, %y
  %mod = srem <2 x i32> %shl, %x
  ret <2 x i32> %mod
}

; make sure the previous fold doesn't take place for wrapped shifts

define i32 @rem7(i32 %x, i32 %y) {
; CHECK-LABEL: @rem7(
; CHECK-NEXT:    [[SHL:%.*]] = shl i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT:    [[MOD:%.*]] = srem i32 [[SHL]], [[X]]
; CHECK-NEXT:    ret i32 [[MOD]]
;
  %shl = shl i32 %x, %y
  %mod = srem i32 %shl, %x
  ret i32 %mod
}

define i32 @rem8(i32 %x, i32 %y) {
; CHECK-LABEL: @rem8(
; CHECK-NEXT:    ret i32 0
;
  %shl = shl nuw i32 %x, %y
  %mod = urem i32 %shl, %x
  ret i32 %mod
}

define <2 x i32> @rem9(<2 x i32> %x, <2 x i32> %y) {
; CHECK-LABEL: @rem9(
; CHECK-NEXT:    ret <2 x i32> zeroinitializer
;
  %shl = shl nuw <2 x i32> %x, %y
  %mod = urem <2 x i32> %shl, %x
  ret <2 x i32> %mod
}

; make sure the previous fold doesn't take place for wrapped shifts

define i32 @rem10(i32 %x, i32 %y) {
; CHECK-LABEL: @rem10(
; CHECK-NEXT:    [[SHL:%.*]] = shl i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT:    [[MOD:%.*]] = urem i32 [[SHL]], [[X]]
; CHECK-NEXT:    ret i32 [[MOD]]
;
  %shl = shl i32 %x, %y
  %mod = urem i32 %shl, %x
  ret i32 %mod
}

define i32 @srem_with_sext_bool_divisor(i1 %x, i32 %y) {
; CHECK-LABEL: @srem_with_sext_bool_divisor(
; CHECK-NEXT:    ret i32 0
;
  %s = sext i1 %x to i32
  %r = srem i32 %y, %s
  ret i32 %r
}

define <2 x i32> @srem_with_sext_bool_divisor_vec(<2 x i1> %x, <2 x i32> %y) {
; CHECK-LABEL: @srem_with_sext_bool_divisor_vec(
; CHECK-NEXT:    ret <2 x i32> zeroinitializer
;
  %s = sext <2 x i1> %x to <2 x i32>
  %r = srem <2 x i32> %y, %s
  ret <2 x i32> %r
}

define i8 @srem_minusone_divisor() {
; CHECK-LABEL: @srem_minusone_divisor(
; CHECK-NEXT:    ret i8 poison
;
  %v = srem i8 -128, -1
  ret i8 %v
}

define i32 @srem_of_mul_nsw(i32 %x, i32 %y) {
; CHECK-LABEL: @srem_of_mul_nsw(
; CHECK-NEXT:    ret i32 0
;
  %mul = mul nsw i32 %x, %y
  %mod = srem i32 %mul, %y
  ret i32 %mod
}

; Verify that the optimization kicks in for:
;   - Y * X % Y as well as X * Y % Y
;   - vector types
define <2 x i32> @srem_of_mul_nsw_vec_commuted(<2 x i32> %x, <2 x i32> %y) {
; CHECK-LABEL: @srem_of_mul_nsw_vec_commuted(
; CHECK-NEXT:    ret <2 x i32> zeroinitializer
;
  %mul = mul nsw <2 x i32> %y, %x
  %mod = srem <2 x i32> %mul, %y
  ret <2 x i32> %mod
}

define i32 @srem_of_mul_nuw(i32 %x, i32 %y) {
; CHECK-LABEL: @srem_of_mul_nuw(
; CHECK-NEXT:    [[MUL:%.*]] = mul nuw i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT:    [[MOD:%.*]] = srem i32 [[MUL]], [[Y]]
; CHECK-NEXT:    ret i32 [[MOD]]
;
  %mul = mul nuw i32 %x, %y
  %mod = srem i32 %mul, %y
  ret i32 %mod
}

define i32 @srem_of_mul(i32 %x, i32 %y) {
; CHECK-LABEL: @srem_of_mul(
; CHECK-NEXT:    [[MUL:%.*]] = mul i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT:    [[MOD:%.*]] = srem i32 [[MUL]], [[Y]]
; CHECK-NEXT:    ret i32 [[MOD]]
;
  %mul = mul i32 %x, %y
  %mod = srem i32 %mul, %y
  ret i32 %mod
}

define i32 @urem_of_mul_nsw(i32 %x, i32 %y) {
; CHECK-LABEL: @urem_of_mul_nsw(
; CHECK-NEXT:    [[MUL:%.*]] = mul nsw i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT:    [[MOD:%.*]] = urem i32 [[MUL]], [[Y]]
; CHECK-NEXT:    ret i32 [[MOD]]
;
  %mul = mul nsw i32 %x, %y
  %mod = urem i32 %mul, %y
  ret i32 %mod
}

define i32 @urem_of_mul_nuw(i32 %x, i32 %y) {
; CHECK-LABEL: @urem_of_mul_nuw(
; CHECK-NEXT:    ret i32 0
;
  %mul = mul nuw i32 %x, %y
  %mod = urem i32 %mul, %y
  ret i32 %mod
}

define <2 x i32> @srem_of_mul_nuw_vec_commuted(<2 x i32> %x, <2 x i32> %y) {
; CHECK-LABEL: @srem_of_mul_nuw_vec_commuted(
; CHECK-NEXT:    ret <2 x i32> zeroinitializer
;
  %mul = mul nuw <2 x i32> %y, %x
  %mod = urem <2 x i32> %mul, %y
  ret <2 x i32> %mod
}

define i32 @urem_of_mul(i32 %x, i32 %y) {
; CHECK-LABEL: @urem_of_mul(
; CHECK-NEXT:    [[MUL:%.*]] = mul i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT:    [[MOD:%.*]] = urem i32 [[MUL]], [[Y]]
; CHECK-NEXT:    ret i32 [[MOD]]
;
  %mul = mul i32 %x, %y
  %mod = urem i32 %mul, %y
  ret i32 %mod
}

define i4 @srem_mul_sdiv(i4 %x, i4 %y) {
; CHECK-LABEL: @srem_mul_sdiv(
; CHECK-NEXT:    ret i4 0
;
  %d = sdiv i4 %x, %y
  %mul = mul i4 %d, %y
  %mod = srem i4 %mul, %y
  ret i4 %mod
}

define i8 @srem_mul_udiv(i8 %x, i8 %y) {
; CHECK-LABEL: @srem_mul_udiv(
; CHECK-NEXT:    [[D:%.*]] = udiv i8 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT:    [[MUL:%.*]] = mul i8 [[D]], [[Y]]
; CHECK-NEXT:    [[MOD:%.*]] = srem i8 [[MUL]], [[Y]]
; CHECK-NEXT:    ret i8 [[MOD]]
;
  %d = udiv i8 %x, %y
  %mul = mul i8 %d, %y
  %mod = srem i8 %mul, %y
  ret i8 %mod
}

define <3 x i7> @urem_mul_udiv_vec_commuted(<3 x i7> %x, <3 x i7> %y) {
; CHECK-LABEL: @urem_mul_udiv_vec_commuted(
; CHECK-NEXT:    ret <3 x i7> zeroinitializer
;
  %d = udiv <3 x i7> %x, %y
  %mul = mul <3 x i7> %y, %d
  %mod = urem <3 x i7> %mul, %y
  ret <3 x i7> %mod
}

define i8 @urem_mul_sdiv(i8 %x, i8 %y) {
; CHECK-LABEL: @urem_mul_sdiv(
; CHECK-NEXT:    [[D:%.*]] = sdiv i8 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT:    [[MUL:%.*]] = mul i8 [[Y]], [[D]]
; CHECK-NEXT:    [[MOD:%.*]] = urem i8 [[MUL]], [[Y]]
; CHECK-NEXT:    ret i8 [[MOD]]
;
  %d = sdiv i8 %x, %y
  %mul = mul i8 %y, %d
  %mod = urem i8 %mul, %y
  ret i8 %mod
}

define <2 x i8> @simplfy_srem_of_mul(<2 x i8> %x) {
; CHECK-LABEL: @simplfy_srem_of_mul(
; CHECK-NEXT:    ret <2 x i8> zeroinitializer
;
  %mul = mul nsw <2 x i8> %x, <i8 20, i8 10>
  %r = srem <2 x i8> %mul, <i8 5, i8 5>
  ret <2 x i8> %r
}

define <2 x i8> @simplfy_srem_of_mul_fail_bad_mod(<2 x i8> %x) {
; CHECK-LABEL: @simplfy_srem_of_mul_fail_bad_mod(
; CHECK-NEXT:    [[MUL:%.*]] = mul nsw <2 x i8> [[X:%.*]], <i8 20, i8 11>
; CHECK-NEXT:    [[R:%.*]] = srem <2 x i8> [[MUL]], splat (i8 5)
; CHECK-NEXT:    ret <2 x i8> [[R]]
;
  %mul = mul nsw <2 x i8> %x, <i8 20, i8 11>
  %r = srem <2 x i8> %mul, <i8 5, i8 5>
  ret <2 x i8> %r
}

define i8 @simplfy_urem_of_mul(i8 %x) {
; CHECK-LABEL: @simplfy_urem_of_mul(
; CHECK-NEXT:    ret i8 0
;
  %mul = mul nuw i8 %x, 30
  %r = urem i8 %mul, 10
  ret i8 %r
}

define i8 @simplfy_urem_of_mul_fail_bad_flag(i8 %x) {
; CHECK-LABEL: @simplfy_urem_of_mul_fail_bad_flag(
; CHECK-NEXT:    [[MUL:%.*]] = mul nsw i8 [[X:%.*]], 30
; CHECK-NEXT:    [[R:%.*]] = urem i8 [[MUL]], 10
; CHECK-NEXT:    ret i8 [[R]]
;
  %mul = mul nsw i8 %x, 30
  %r = urem i8 %mul, 10
  ret i8 %r
}

define i8 @simplfy_urem_of_mul_fail_bad_mod(i8 %x) {
; CHECK-LABEL: @simplfy_urem_of_mul_fail_bad_mod(
; CHECK-NEXT:    [[MUL:%.*]] = mul nuw i8 [[X:%.*]], 31
; CHECK-NEXT:    [[R:%.*]] = urem i8 [[MUL]], 10
; CHECK-NEXT:    ret i8 [[R]]
;
  %mul = mul nuw i8 %x, 31
  %r = urem i8 %mul, 10
  ret i8 %r
}