This is an archive of the discontinued LLVM Phabricator instance.

Differential D156347

[InstCombine] Tests for D156026 (Contracting x^2 + 2*x*y + y^2 to (x + y)^2 (integer))
ClosedPublic

Authored by rainerzufalldererste on Jul 26 2023, 10:09 AM.

Details

Reviewers
nikic
Commits
rGc52280b6103a: [InstCombine] Tests for D156026 (Contracting x^2 + 2*x*y + y^2 to (x + y)^2)…

Diff Detail

Event Timeline

rainerzufalldererste created this revision.Jul 26 2023, 10:09 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 26 2023, 10:09 AM
Herald added subscribers: mstorsjo, StephenFan. · View Herald Transcript
rainerzufalldererste requested review of this revision.Jul 26 2023, 10:09 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 26 2023, 10:09 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
rainerzufalldererste added a child revision: D156026: [InstCombine] Contracting x^2 + 2*x*y + y^2 to (x + y)^2 (integer).Jul 26 2023, 10:09 AM
Harbormaster completed remote builds in B248302: Diff 544418.Jul 26 2023, 2:47 PM
nikic added a comment.Jul 27 2023, 2:02 AM

Not sure if this is what you intended, but since there's been no further response to the other Revision, I'll presume that this is the correct cause of action.

This is right. Can you please rebase https://reviews.llvm.org/D156026 on top of this patch now? It will then only show test diffs relative to this patch.

rainerzufalldererste added a comment.Jul 30 2023, 3:52 AM

Any ideas, what these failed UnitTests are about? Adding a bunch of tests to one particular file shouldn't break random other things imo. Or am I missing something?
Or are CodeGen/error-stmt-in-non-affine-region.ll, CodeGen/large-numbers-in-boundary-context.ll or SemaTemplate/instantiate-function-1.mm somehow related to this change?

nikic added a comment.Jul 30 2023, 5:18 AM

Sometimes there are pre-existing failures on the master branch. You can generally ignore any failures that aren't obviously related to your change.

rainerzufalldererste updated this revision to Diff 545850.Jul 31 2023, 4:12 PM
rainerzufalldererste edited the summary of this revision. (Show Details)

Adding more tests for different parameter orders

rainerzufalldererste added a comment.Jul 31 2023, 4:14 PM

Just noticed that I accidentally removed the FIXME comments, but since this isn't intended to be committed directly, I guess it's not that big of a deal. Otherwise, please let me know.

Harbormaster completed remote builds in B249342: Diff 545850.Jul 31 2023, 4:54 PM
This revision was not accepted when it landed; it landed in state Needs Review.Aug 9 2023, 5:13 AM
Closed by commit rGc52280b6103a: [InstCombine] Tests for D156026 (Contracting x^2 + 2*x*y + y^2 to (x + y)^2)… (authored by rainerzufalldererste, committed by nikic). · Explain Why
This revision was automatically updated to reflect the committed changes.
nikic added a commit: rGc52280b6103a: [InstCombine] Tests for D156026 (Contracting x^2 + 2*x*y + y^2 to (x + y)^2)….

Revision Contents

PathSize
llvm/
test/
Transforms/
InstCombine/
647 lines

Diff 544418

llvm/test/Transforms/InstCombine/add.ll

Show First 20 Lines • Show All 3,090 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ret i32 [[ADD]] ; CHECK-NEXT: ret i32 [[ADD]]
; ;
%zext = zext i1 %a to i32 %zext = zext i1 %a to i32
%sext = sext i1 %b to i32 %sext = sext i1 %b to i32
%add = add i32 %zext, %sext %add = add i32 %zext, %sext
ret i32 %add ret i32 %add
} }
; FIXME: Should be changed by new optimization.
define i32 @add_reduce_sqr_sum_nsw(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_nsw(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWO_A:%.*]] = shl i32 [[A]], 1
; CHECK-NEXT: [[TWO_A_PLUS_B:%.*]] = add i32 [[TWO_A]], [[B:%.*]]
; CHECK-NEXT: [[MUL:%.*]] = mul i32 [[TWO_A_PLUS_B]], [[B]]
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[MUL]], [[A_SQ]]
; CHECK-NEXT: ret i32 [[ADD]]
;
%a_sq = mul nsw i32 %a, %a
%two_a = shl i32 %a, 1
%two_a_plus_b = add i32 %two_a, %b
%mul = mul i32 %two_a_plus_b, %b
%add = add i32 %mul, %a_sq
ret i32 %add
}
; FIXME: Should be changed by new optimization.
define i32 @add_reduce_sqr_sum_u(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_u(
; CHECK-NEXT: [[A_SQ:%.*]] = mul i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWO_A:%.*]] = shl i32 [[A]], 1
; CHECK-NEXT: [[TWO_A_PLUS_B:%.*]] = add i32 [[TWO_A]], [[B:%.*]]
; CHECK-NEXT: [[MUL:%.*]] = mul i32 [[TWO_A_PLUS_B]], [[B]]
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[MUL]], [[A_SQ]]
; CHECK-NEXT: ret i32 [[ADD]]
;
%a_sq = mul i32 %a, %a
%two_a = shl i32 %a, 1
%two_a_plus_b = add i32 %two_a, %b
%mul = mul i32 %two_a_plus_b, %b
%add = add i32 %mul, %a_sq
ret i32 %add
}
; FIXME: Should be changed by new optimization.
define i32 @add_reduce_sqr_sum_nuw(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_nuw(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nuw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWO_A:%.*]] = shl i32 [[A]], 1
; CHECK-NEXT: [[TWO_A_PLUS_B:%.*]] = add i32 [[TWO_A]], [[B:%.*]]
; CHECK-NEXT: [[MUL:%.*]] = mul nuw i32 [[TWO_A_PLUS_B]], [[B]]
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[MUL]], [[A_SQ]]
; CHECK-NEXT: ret i32 [[ADD]]
;
%a_sq = mul nuw i32 %a, %a
%two_a = mul i32 %a, 2
%two_a_plus_b = add i32 %two_a, %b
%mul = mul nuw i32 %two_a_plus_b, %b
%add = add i32 %mul, %a_sq
ret i32 %add
}
; FIXME: Should be changed by new optimization.
define i32 @add_reduce_sqr_sum_order2(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_order2(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWOA:%.*]] = shl i32 [[A]], 1
; CHECK-NEXT: [[TWOAB1:%.*]] = add i32 [[TWOA]], [[B:%.*]]
; CHECK-NEXT: [[TWOAB_B2:%.*]] = mul i32 [[TWOAB1]], [[B]]
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[A_SQ]], [[TWOAB_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_sq = mul nsw i32 %a, %a
%twoa = mul i32 %a, 2
%twoab = mul i32 %twoa, %b
%b_sq = mul i32 %b, %b
%twoab_b2 = add i32 %twoab, %b_sq
%ab2 = add i32 %a_sq, %twoab_b2
ret i32 %ab2
}
; FIXME: Should be changed by new optimization.
define i32 @add_reduce_sqr_sum_order2_flipped(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_order2_flipped(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWOA:%.*]] = shl i32 [[A]], 1
; CHECK-NEXT: [[TWOAB1:%.*]] = add i32 [[TWOA]], [[B:%.*]]
; CHECK-NEXT: [[TWOAB_B2:%.*]] = mul i32 [[TWOAB1]], [[B]]
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[TWOAB_B2]], [[A_SQ]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_sq = mul nsw i32 %a, %a
%twoa = mul i32 %a, 2
%twoab = mul i32 %twoa, %b
%b_sq = mul i32 %b, %b
%twoab_b2 = add i32 %twoab, %b_sq
%ab2 = add i32 %twoab_b2, %a_sq
ret i32 %ab2
}
; FIXME: Should be changed by new optimization.
define i32 @add_reduce_sqr_sum_order3(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_order3(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWOA:%.*]] = shl i32 [[A]], 1
; CHECK-NEXT: [[TWOAB:%.*]] = mul i32 [[TWOA]], [[B:%.*]]
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_sq = mul nsw i32 %a, %a
%twoa = mul i32 %a, 2
%twoab = mul i32 %twoa, %b
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
%ab2 = add i32 %twoab, %a2_b2
ret i32 %ab2
}
; FIXME: Should be changed by new optimization.
define i32 @add_reduce_sqr_sum_order3_flipped(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_order3_flipped(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWOA:%.*]] = shl i32 [[A]], 1
; CHECK-NEXT: [[TWOAB:%.*]] = mul i32 [[TWOA]], [[B:%.*]]
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[A2_B2]], [[TWOAB]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_sq = mul nsw i32 %a, %a
%twoa = mul i32 %a, 2
%twoab = mul i32 %twoa, %b
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
%ab2 = add i32 %a2_b2, %twoab
ret i32 %ab2
}
; FIXME: Should be changed by new optimization.
define i32 @add_reduce_sqr_sum_order4(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_order4(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[AB:%.*]] = mul i32 [[A]], [[B:%.*]]
; CHECK-NEXT: [[TWOAB:%.*]] = shl i32 [[AB]], 1
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_sq = mul nsw i32 %a, %a
%ab = mul i32 %a, %b
%twoab = mul i32 %ab, 2
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
%ab2 = add i32 %twoab, %a2_b2
ret i32 %ab2
}
; FIXME: Should be changed by new optimization.
define i32 @add_reduce_sqr_sum_order4_flipped(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_order4_flipped(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[AB:%.*]] = mul i32 [[A]], [[B:%.*]]
; CHECK-NEXT: [[TWOAB:%.*]] = shl i32 [[AB]], 1
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[A2_B2]], [[TWOAB]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_sq = mul nsw i32 %a, %a
%ab = mul i32 %a, %b
%twoab = mul i32 %ab, 2
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
%ab2 = add i32 %a2_b2, %twoab
ret i32 %ab2
}
; FIXME: Should be changed by new optimization.
define i32 @add_reduce_sqr_sum_order5(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_order5(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWOB:%.*]] = shl i32 [[B:%.*]], 1
; CHECK-NEXT: [[TWOAB:%.*]] = mul i32 [[TWOB]], [[A]]
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_sq = mul nsw i32 %a, %a
%twob = mul i32 %b, 2
%twoab = mul i32 %twob, %a
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
%ab2 = add i32 %twoab, %a2_b2
ret i32 %ab2
}
; FIXME: Should be changed by new optimization.
define i32 @add_reduce_sqr_sum_order5_flipped(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_order5_flipped(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWOB:%.*]] = shl i32 [[B:%.*]], 1
; CHECK-NEXT: [[TWOAB:%.*]] = mul i32 [[TWOB]], [[A]]
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[A2_B2]], [[TWOAB]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_sq = mul nsw i32 %a, %a
%twob = mul i32 %b, 2
%twoab = mul i32 %twob, %a
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
%ab2 = add i32 %a2_b2, %twoab
ret i32 %ab2
}
define i32 @add_reduce_sqr_sum_not_one_use(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_not_one_use(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWO_A:%.*]] = shl i32 [[A]], 1
; CHECK-NEXT: [[TWO_A_PLUS_B:%.*]] = add i32 [[TWO_A]], [[B:%.*]]
; CHECK-NEXT: [[MUL:%.*]] = mul i32 [[TWO_A_PLUS_B]], [[B]]
; CHECK-NEXT: tail call void @fake_func(i32 [[MUL]])
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[MUL]], [[A_SQ]]
; CHECK-NEXT: ret i32 [[ADD]]
;
%a_sq = mul nsw i32 %a, %a
%two_a = shl i32 %a, 1
%two_a_plus_b = add i32 %two_a, %b
%mul = mul i32 %two_a_plus_b, %b
tail call void @fake_func (i32 %mul)
%add = add i32 %mul, %a_sq
ret i32 %add
}
define i32 @add_reduce_sqr_sum_not_one_use2(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_not_one_use2(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWO_A:%.*]] = shl i32 [[A]], 1
; CHECK-NEXT: [[TWO_A_PLUS_B:%.*]] = add i32 [[TWO_A]], [[B:%.*]]
; CHECK-NEXT: [[MUL:%.*]] = mul i32 [[TWO_A_PLUS_B]], [[B]]
; CHECK-NEXT: tail call void @fake_func(i32 [[A_SQ]])
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[MUL]], [[A_SQ]]
; CHECK-NEXT: ret i32 [[ADD]]
;
%a_sq = mul nsw i32 %a, %a
%two_a = shl i32 %a, 1
%two_a_plus_b = add i32 %two_a, %b
%mul = mul i32 %two_a_plus_b, %b
tail call void @fake_func (i32 %a_sq)
%add = add i32 %mul, %a_sq
ret i32 %add
}
define i32 @add_reduce_sqr_sum_order2_not_one_use(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_order2_not_one_use(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWOA:%.*]] = shl i32 [[A]], 1
; CHECK-NEXT: [[TWOAB1:%.*]] = add i32 [[TWOA]], [[B:%.*]]
; CHECK-NEXT: [[TWOAB_B2:%.*]] = mul i32 [[TWOAB1]], [[B]]
; CHECK-NEXT: tail call void @fake_func(i32 [[TWOAB_B2]])
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[A_SQ]], [[TWOAB_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_sq = mul nsw i32 %a, %a
%twoa = mul i32 %a, 2
%twoab = mul i32 %twoa, %b
%b_sq = mul i32 %b, %b
%twoab_b2 = add i32 %twoab, %b_sq
tail call void @fake_func (i32 %twoab_b2)
%ab2 = add i32 %a_sq, %twoab_b2
ret i32 %ab2
}
define i32 @add_reduce_sqr_sum_order2_not_one_use2(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_order2_not_one_use2(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWOA:%.*]] = shl i32 [[A]], 1
; CHECK-NEXT: [[TWOAB1:%.*]] = add i32 [[TWOA]], [[B:%.*]]
; CHECK-NEXT: [[TWOAB_B2:%.*]] = mul i32 [[TWOAB1]], [[B]]
; CHECK-NEXT: tail call void @fake_func(i32 [[A_SQ]])
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[A_SQ]], [[TWOAB_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_sq = mul nsw i32 %a, %a
%twoa = mul i32 %a, 2
%twoab = mul i32 %twoa, %b
%b_sq = mul i32 %b, %b
%twoab_b2 = add i32 %twoab, %b_sq
tail call void @fake_func (i32 %a_sq)
%ab2 = add i32 %a_sq, %twoab_b2
ret i32 %ab2
}
define i32 @add_reduce_sqr_sum_order3_not_one_use(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_order3_not_one_use(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWOA:%.*]] = shl i32 [[A]], 1
; CHECK-NEXT: [[TWOAB:%.*]] = mul i32 [[TWOA]], [[B:%.*]]
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: tail call void @fake_func(i32 [[TWOAB]])
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_sq = mul nsw i32 %a, %a
%twoa = mul i32 %a, 2
%twoab = mul i32 %twoa, %b
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
tail call void @fake_func (i32 %twoab)
%ab2 = add i32 %twoab, %a2_b2
ret i32 %ab2
}
define i32 @add_reduce_sqr_sum_order3_not_one_use2(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_order3_not_one_use2(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWOA:%.*]] = shl i32 [[A]], 1
; CHECK-NEXT: [[TWOAB:%.*]] = mul i32 [[TWOA]], [[B:%.*]]
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: tail call void @fake_func(i32 [[A2_B2]])
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_sq = mul nsw i32 %a, %a
%twoa = mul i32 %a, 2
%twoab = mul i32 %twoa, %b
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
tail call void @fake_func (i32 %a2_b2)
%ab2 = add i32 %twoab, %a2_b2
ret i32 %ab2
}
define i32 @add_reduce_sqr_sum_order4_not_one_use(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_order4_not_one_use(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[AB:%.*]] = mul i32 [[A]], [[B:%.*]]
; CHECK-NEXT: [[TWOAB:%.*]] = shl i32 [[AB]], 1
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: tail call void @fake_func(i32 [[TWOAB]])
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_sq = mul nsw i32 %a, %a
%ab = mul i32 %a, %b
%twoab = mul i32 %ab, 2
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
tail call void @fake_func (i32 %twoab)
%ab2 = add i32 %twoab, %a2_b2
ret i32 %ab2
}
define i32 @add_reduce_sqr_sum_order4_not_one_use2(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_order4_not_one_use2(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[AB:%.*]] = mul i32 [[A]], [[B:%.*]]
; CHECK-NEXT: [[TWOAB:%.*]] = shl i32 [[AB]], 1
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: tail call void @fake_func(i32 [[A2_B2]])
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_sq = mul nsw i32 %a, %a
%ab = mul i32 %a, %b
%twoab = mul i32 %ab, 2
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
tail call void @fake_func (i32 %a2_b2)
%ab2 = add i32 %twoab, %a2_b2
ret i32 %ab2
}
define i32 @add_reduce_sqr_sum_order5_not_one_use(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_order5_not_one_use(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWOB:%.*]] = shl i32 [[B:%.*]], 1
; CHECK-NEXT: [[TWOAB:%.*]] = mul i32 [[TWOB]], [[A]]
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: tail call void @fake_func(i32 [[TWOAB]])
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_sq = mul nsw i32 %a, %a
%twob = mul i32 %b, 2
%twoab = mul i32 %twob, %a
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
tail call void @fake_func (i32 %twoab)
%ab2 = add i32 %twoab, %a2_b2
ret i32 %ab2
}
define i32 @add_reduce_sqr_sum_order5_not_one_use2(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_order5_not_one_use2(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWOB:%.*]] = shl i32 [[B:%.*]], 1
; CHECK-NEXT: [[TWOAB:%.*]] = mul i32 [[TWOB]], [[A]]
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: tail call void @fake_func(i32 [[A2_B2]])
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_sq = mul nsw i32 %a, %a
%twob = mul i32 %b, 2
%twoab = mul i32 %twob, %a
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
tail call void @fake_func (i32 %a2_b2)
%ab2 = add i32 %twoab, %a2_b2
ret i32 %ab2
}
define i32 @add_reduce_sqr_sum_invalid0(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_invalid0(
; CHECK-NEXT: [[TWO_A:%.*]] = shl i32 [[A:%.*]], 1
; CHECK-NEXT: [[TWO_A_PLUS_B:%.*]] = add i32 [[TWO_A]], [[B:%.*]]
; CHECK-NEXT: [[MUL1:%.*]] = add i32 [[TWO_A_PLUS_B]], [[A]]
; CHECK-NEXT: [[ADD:%.*]] = mul i32 [[MUL1]], [[B]]
; CHECK-NEXT: ret i32 [[ADD]]
;
%not_a_sq = mul nsw i32 %a, %b
%two_a = shl i32 %a, 1
%two_a_plus_b = add i32 %two_a, %b
%mul = mul i32 %two_a_plus_b, %b
%add = add i32 %mul, %not_a_sq
ret i32 %add
}
define i32 @add_reduce_sqr_sum_invalid1(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_invalid1(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[NOT_TWO_A_PLUS_B:%.*]] = mul i32 [[A]], 3
; CHECK-NEXT: [[MUL:%.*]] = mul i32 [[NOT_TWO_A_PLUS_B]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[MUL]], [[A_SQ]]
; CHECK-NEXT: ret i32 [[ADD]]
;
%a_sq = mul nsw i32 %a, %a
%two_a = shl i32 %a, 1
%not_two_a_plus_b = add i32 %two_a, %a
%mul = mul i32 %not_two_a_plus_b, %b
%add = add i32 %mul, %a_sq
ret i32 %add
}
define i32 @add_reduce_sqr_sum_invalid2(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_invalid2(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[NOT_TWO_A:%.*]] = shl i32 [[A]], 2
; CHECK-NEXT: [[TWO_A_PLUS_B:%.*]] = add i32 [[NOT_TWO_A]], [[B:%.*]]
; CHECK-NEXT: [[MUL:%.*]] = mul i32 [[TWO_A_PLUS_B]], [[B]]
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[MUL]], [[A_SQ]]
; CHECK-NEXT: ret i32 [[ADD]]
;
%a_sq = mul nsw i32 %a, %a
%not_two_a = shl i32 %a, 2
%two_a_plus_b = add i32 %not_two_a, %b
%mul = mul i32 %two_a_plus_b, %b
%add = add i32 %mul, %a_sq
ret i32 %add
}
define i32 @add_reduce_sqr_sum_invalid3(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_invalid3(
; CHECK-NEXT: [[TWO_A_PLUS_B:%.*]] = mul i32 [[B:%.*]], 3
; CHECK-NEXT: [[MUL1:%.*]] = add i32 [[TWO_A_PLUS_B]], [[A:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = mul i32 [[MUL1]], [[A]]
; CHECK-NEXT: ret i32 [[ADD]]
;
%a_sq = mul nsw i32 %a, %a
%not_two_a = shl i32 %b, 1
%two_a_plus_b = add i32 %not_two_a, %b
%mul = mul i32 %two_a_plus_b, %a
%add = add i32 %mul, %a_sq
ret i32 %add
}
define i32 @add_reduce_sqr_sum_invalid4(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_invalid4(
; CHECK-NEXT: [[A_SQ:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWO_A_PLUS_B:%.*]] = mul i32 [[B:%.*]], 3
; CHECK-NEXT: [[MUL:%.*]] = mul i32 [[TWO_A_PLUS_B]], [[B]]
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[MUL]], [[A_SQ]]
; CHECK-NEXT: ret i32 [[ADD]]
;
%a_sq = mul nsw i32 %a, %a
%not_two_a = shl i32 %b, 1
%two_a_plus_b = add i32 %not_two_a, %b
%mul = mul i32 %two_a_plus_b, %b
%add = add i32 %mul, %a_sq
ret i32 %add
}
define i32 @add_reduce_sqr_sum_varB_invalid0(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_varB_invalid0(
; CHECK-NEXT: [[NOT_A_B:%.*]] = mul nsw i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[TWOAB:%.*]] = shl nuw i32 [[NOT_A_B]], 1
; CHECK-NEXT: [[A_SQ:%.*]] = mul i32 [[A]], [[A]]
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B:%.*]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%not_a_b = mul nsw i32 %a, %a
%twoab = mul i32 %not_a_b, 2
%a_sq = mul i32 %a, %a
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
%ab2 = add i32 %twoab, %a2_b2
ret i32 %ab2
}
define i32 @add_reduce_sqr_sum_varB_invalid1(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_varB_invalid1(
; CHECK-NEXT: [[NOT_A_B:%.*]] = mul nsw i32 [[B:%.*]], [[B]]
; CHECK-NEXT: [[TWOAB:%.*]] = shl nuw i32 [[NOT_A_B]], 1
; CHECK-NEXT: [[A_SQ:%.*]] = mul i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%not_a_b = mul nsw i32 %b, %b
%twoab = mul i32 %not_a_b, 2
%a_sq = mul i32 %a, %a
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
%ab2 = add i32 %twoab, %a2_b2
ret i32 %ab2
}
define i32 @add_reduce_sqr_sum_varB_invalid2(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_varB_invalid2(
; CHECK-NEXT: [[A_B:%.*]] = mul nsw i32 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[NOT_TWOAB:%.*]] = shl i32 [[A_B]], 2
; CHECK-NEXT: [[A_SQ:%.*]] = mul i32 [[A]], [[A]]
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[NOT_TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_b = mul nsw i32 %a, %b
%not_twoab = mul i32 %a_b, 4
%a_sq = mul i32 %a, %a
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
%ab2 = add i32 %not_twoab, %a2_b2
ret i32 %ab2
}
define i32 @add_reduce_sqr_sum_varB_invalid3(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_varB_invalid3(
; CHECK-NEXT: [[A_B:%.*]] = mul nsw i32 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[TWOAB:%.*]] = shl i32 [[A_B]], 1
; CHECK-NEXT: [[B_SQ1:%.*]] = add i32 [[A]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = mul i32 [[B_SQ1]], [[B]]
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_b = mul nsw i32 %a, %b
%twoab = mul i32 %a_b, 2
%not_a_sq = mul i32 %b, %a
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %not_a_sq, %b_sq
%ab2 = add i32 %twoab, %a2_b2
ret i32 %ab2
}
define i32 @add_reduce_sqr_sum_varB_invalid4(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_varB_invalid4(
; CHECK-NEXT: [[A_B:%.*]] = mul nsw i32 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[TWOAB:%.*]] = shl i32 [[A_B]], 1
; CHECK-NEXT: [[NOT_B_SQ1:%.*]] = add i32 [[A]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = mul i32 [[NOT_B_SQ1]], [[A]]
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%a_b = mul nsw i32 %a, %b
%twoab = mul i32 %a_b, 2
%a_sq = mul i32 %a, %a
%not_b_sq = mul i32 %b, %a
%a2_b2 = add i32 %a_sq, %not_b_sq
%ab2 = add i32 %twoab, %a2_b2
ret i32 %ab2
}
define i32 @add_reduce_sqr_sum_varC_invalid0(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_varC_invalid0(
; CHECK-NEXT: [[NOT_TWOA:%.*]] = shl nsw i32 [[B:%.*]], 1
; CHECK-NEXT: [[TWOAB:%.*]] = mul i32 [[NOT_TWOA]], [[B]]
; CHECK-NEXT: [[A_SQ:%.*]] = mul i32 [[A:%.*]], [[A]]
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%not_twoa = mul nsw i32 %b, 2
%twoab = mul i32 %not_twoa, %b
%a_sq = mul i32 %a, %a
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
%ab2 = add i32 %twoab, %a2_b2
ret i32 %ab2
}
define i32 @add_reduce_sqr_sum_varC_invalid1(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_varC_invalid1(
; CHECK-NEXT: [[NOT_TWOA:%.*]] = shl nsw i32 [[A:%.*]], 2
; CHECK-NEXT: [[TWOAB:%.*]] = mul i32 [[NOT_TWOA]], [[B:%.*]]
; CHECK-NEXT: [[A_SQ:%.*]] = mul i32 [[A]], [[A]]
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%not_twoa = mul nsw i32 %a, 4
%twoab = mul i32 %not_twoa, %b
%a_sq = mul i32 %a, %a
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
%ab2 = add i32 %twoab, %a2_b2
ret i32 %ab2
}
define i32 @add_reduce_sqr_sum_varC_invalid2(i32 %a, i32 %b) {
; CHECK-LABEL: @add_reduce_sqr_sum_varC_invalid2(
; CHECK-NEXT: [[TWOA:%.*]] = shl nsw i32 [[A:%.*]], 1
; CHECK-NEXT: [[NOT_TWOAB:%.*]] = mul i32 [[TWOA]], [[A]]
; CHECK-NEXT: [[A_SQ:%.*]] = mul i32 [[A]], [[A]]
; CHECK-NEXT: [[B_SQ:%.*]] = mul i32 [[B:%.*]], [[B]]
; CHECK-NEXT: [[A2_B2:%.*]] = add i32 [[A_SQ]], [[B_SQ]]
; CHECK-NEXT: [[AB2:%.*]] = add i32 [[NOT_TWOAB]], [[A2_B2]]
; CHECK-NEXT: ret i32 [[AB2]]
;
%twoa = mul nsw i32 %a, 2
%not_twoab = mul i32 %twoa, %a
%a_sq = mul i32 %a, %a
%b_sq = mul i32 %b, %b
%a2_b2 = add i32 %a_sq, %b_sq
%ab2 = add i32 %not_twoab, %a2_b2
ret i32 %ab2
}
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
declare void @fake_func(i32)