[InstCombine] Add test cases for folds (X / C) cmp X and (X >> C) cmp X

Author: Poseydon42

llvm/test/Transforms/InstCombine/icmp-div-constant.ll

@@ -375,3 +375,120 @@ define i1 @sdiv_eq_smin_use(i32 %x, i32 %y) {
   %r = icmp eq i32 %d, -2147483648
   ret i1 %r
 }
+
+; Fold (X / C) cmp X into X ~cmp 0 (~cmp is the inverse predicate of cmp), for some C != 1
+; Alternative form of this fold is when division is replaced with logic right shift
+
+define i1 @sdiv_x_by_const_cmp_x(i32 %x) {
+; CHECK-LABEL: @sdiv_x_by_const_cmp_x(
+; CHECK-NEXT:    [[V:%.*]] = udiv i32 [[X:%.*]], 13
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 [[V]], [[X]]
+; CHECK-NEXT:    ret i1 [[TMP1]]
+;
+  %v = udiv i32 %x, 13
+  %r = icmp eq i32 %v, %x
+  ret i1 %r
+}
+
+define i1 @udiv_x_by_const_cmp_x(i32 %x) {
+; CHECK-LABEL: @udiv_x_by_const_cmp_x(
+; CHECK-NEXT:    [[TMP2:%.*]] = udiv i32 [[X:%.*]], 123
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp slt i32 [[TMP2]], [[X]]
+; CHECK-NEXT:    ret i1 [[TMP1]]
+;
+  %1 = udiv i32 %x, 123
+  %2 = icmp slt i32 %1, %x
+  ret i1 %2
+}
+
+; Same as above but with right shift instead of division (C != 0)
+
+define i1 @lshr_x_by_const_cmp_x(i32 %x) {
+; CHECK-LABEL: @lshr_x_by_const_cmp_x(
+; CHECK-NEXT:    [[V:%.*]] = lshr i32 [[X:%.*]], 1
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 [[V]], [[X]]
+; CHECK-NEXT:    ret i1 [[TMP1]]
+;
+  %v = lshr i32 %x, 1
+  %r = icmp eq i32 %v, %x
+  ret i1 %r
+}
+
+define <4 x i1> @lshr_by_const_cmp_sle_value(<4 x i32> %x) {
+; CHECK-LABEL: @lshr_by_const_cmp_sle_value(
+; CHECK-NEXT:    [[V:%.*]] = lshr <4 x i32> [[X:%.*]], <i32 3, i32 3, i32 3, i32 3>
+; CHECK-NEXT:    [[R:%.*]] = icmp sle <4 x i32> [[V]], [[X]]
+; CHECK-NEXT:    ret <4 x i1> [[R]]
+;
+  %v = lshr <4 x i32> %x, <i32 3, i32 3, i32 3, i32 3>
+  %r = icmp sle <4 x i32> %v, %x
+  ret <4 x i1> %r
+}
+
+define i1 @lshr_by_const_cmp_uge_value(i32 %x) {
+; CHECK-LABEL: @lshr_by_const_cmp_uge_value(
+; CHECK-NEXT:    [[V:%.*]] = lshr i32 [[X:%.*]], 3
+; CHECK-NEXT:    [[R:%.*]] = icmp sle i32 [[V]], [[X]]
+; CHECK-NEXT:    ret i1 [[R]]
+;
+  %v = lshr i32 %x, 3
+  %r = icmp sle i32 %v, %x
+  ret i1 %r
+}
+
+; Negative test - constant is 1
+
+define i1 @udiv_by_const_cmp_eq_value_neg(i32 %x) {
+; CHECK-LABEL: @udiv_by_const_cmp_eq_value_neg(
+; CHECK-NEXT:    ret i1 true
+;
+  %v = udiv i32 %x, 1
+  %r = icmp eq i32 %v, %x
+  ret i1 %r
+}
+
+define i1 @sdiv_by_const_cmp_eq_value_neg(i32 %x) {
+; CHECK-LABEL: @sdiv_by_const_cmp_eq_value_neg(
+; CHECK-NEXT:    ret i1 true
+;
+  %v = sdiv i32 %x, 1
+  %r = icmp eq i32 %v, %x
+  ret i1 %r
+}
+
+; Negative test - constant is 0
+
+define i1 @lshr_by_const_cmp_slt_value_neg(i32 %x) {
+; CHECK-LABEL: @lshr_by_const_cmp_slt_value_neg(
+; CHECK-NEXT:    ret i1 false
+;
+  %v = lshr i32 %x, 0
+  %r = icmp slt i32 %v, %x
+  ret i1 %r
+}
+
+; Negative test - unsigned predicate with sdiv
+
+define i1 @sdiv_by_const_cmp_ult_value_neg(i32 %x) {
+; CHECK-LABEL: @sdiv_by_const_cmp_ult_value_neg(
+; CHECK-NEXT:    [[V:%.*]] = sdiv i32 [[X:%.*]], 3
+; CHECK-NEXT:    [[R:%.*]] = icmp ult i32 [[V]], [[X]]
+; CHECK-NEXT:    ret i1 [[R]]
+;
+  %v = sdiv i32 %x, 3
+  %r = icmp ult i32 %v, %x
+  ret i1 %r
+}
+
+; Negative case - one of the components of a vector is 1
+
+define <4 x i1> @sdiv_by_const_cmp_sgt_value_neg(<4 x i32> %x) {
+; CHECK-LABEL: @sdiv_by_const_cmp_sgt_value_neg(
+; CHECK-NEXT:    [[V:%.*]] = sdiv <4 x i32> [[X:%.*]], <i32 1, i32 2, i32 3, i32 4>
+; CHECK-NEXT:    [[R:%.*]] = icmp sgt <4 x i32> [[V]], [[X]]
+; CHECK-NEXT:    ret <4 x i1> [[R]]
+;
+  %v = sdiv <4 x i32> %x, <i32 1, i32 2, i32 3, i32 4>
+  %r = icmp sgt <4 x i32> %v, %x
+  ret <4 x i1> %r
+}