[InstrSimplify] add testcases for fold sdiv if two operands are negatived and non-overflow

[shchenz]

Summary

We add folding support for add instruction in D49216.

we should also fold for sdiv instruction if sdiv's two operands are negatived leverage new added interface isKnownNegation() in D49216. for example:

define i32 @negated_operand(i32 %x) {
  %negx = sub nsw i32 0, %x
  %div = sdiv i32 %negx, %x
  ret i32 %div
}

can be folded to

define i32 @negated_operand(i32 %x) {
  ret i32 -1
}

Note: we must ensure sdiv two operands are non-overflow. Otherwise, the optimization is not right.
Result from Alive:
testing transform:

%sub = sub i8 0, %x
%div = sdiv i8 %x, %sub

=>

%div = i8 -1

testing result:
ERROR: Mismatch in values of i8 %div
Example:
%x i8 = 0x80 (128, -128)
%sub i8 = 0x80 (128, -128)
Source value: 0x01 (1)
Target value: 0xFF (255, -1)

[shchenz]

sub instruction to shift instruction for negation operands transformation is already done is trunk. Maybe we need to do some code refactor to let subsimplify function also call isKnownNegation().

[spatel]

LGTM. I think you can add testcases like this without pre-commit review. If there are questions about whether we have the proper test coverage, we can always answer that in the patch with the code change.

[spatel]

llvm/trunk/test/Transforms/InstCombine/sdiv.ll

1

Oops - I did not notice that we were doing an 'instsimplify' here. This file should be moved to test/Transforms/InstSimplify and the RUN line should be changed to only use -instsimplify.

llvm/trunk/test/Transforms/InstCombine/sdiv.ll

+; RUN: opt < %s -instcombine -S | FileCheck %s
+
+define i32 @negated_operand(i32 %x) {
+; CHECK-LABEL: @negated_operand(
+; CHECK-NEXT:    [[NEGX:%.*]] = sub nsw i32 0, [[X:%.*]]
+; CHECK-NEXT:    [[DIV:%.*]] = sdiv i32 [[NEGX]], [[X]]
+; CHECK-NEXT:    ret i32 [[DIV]]
+;
+  %negx = sub nsw i32 0, %x
+  %div = sdiv i32 %negx, %x
+  ret i32 %div
+}
+
+define <2 x i32> @negated_operand_commute_vec(<2 x i32> %x) {
+; CHECK-LABEL: @negated_operand_commute_vec(
+; CHECK-NEXT:    [[NEGX:%.*]] = sub nsw <2 x i32> zeroinitializer, [[X:%.*]]
+; CHECK-NEXT:    [[DIV:%.*]] = sdiv <2 x i32> [[NEGX]], [[X]]
+; CHECK-NEXT:    ret <2 x i32> [[DIV]]
+;
+  %negx = sub nsw <2 x i32> zeroinitializer, %x
+  %div = sdiv <2 x i32> %negx, %x
+  ret <2 x i32> %div
+}
+
+define i32 @knownnegation(i32 %x, i32 %y) {
+; CHECK-LABEL: @knownnegation(
+; CHECK-NEXT:    [[XY:%.*]] = sub nsw i32 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    [[YX:%.*]] = sub nsw i32 [[Y]], [[X]]
+; CHECK-NEXT:    [[DIV:%.*]] = sdiv i32 [[XY]], [[YX]]
+; CHECK-NEXT:    ret i32 [[DIV]]
+;
+  %xy = sub nsw i32 %x, %y
+  %yx = sub nsw i32 %y, %x
+  %div = sdiv i32 %xy, %yx
+  ret i32 %div
+}
+
+define <2 x i32> @knownnegation_commute_vec(<2 x i32> %x, <2 x i32> %y) {
+; CHECK-LABEL: @knownnegation_commute_vec(
+; CHECK-NEXT:    [[XY:%.*]] = sub nsw <2 x i32> [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    [[YX:%.*]] = sub nsw <2 x i32> [[Y]], [[X]]
+; CHECK-NEXT:    [[DIV:%.*]] = sdiv <2 x i32> [[XY]], [[YX]]
+; CHECK-NEXT:    ret <2 x i32> [[DIV]]
+;
+  %xy = sub nsw <2 x i32> %x, %y
+  %yx = sub nsw <2 x i32> %y, %x
+  %div = sdiv <2 x i32> %xy, %yx
+  ret <2 x i32> %div
+}