This is an archive of the discontinued LLVM Phabricator instance.

Differential D144071

[ComplexLogicCombine] test result for all tests on the transform
AbandonedPublic

Authored by bcl5980 on Feb 14 2023, 10:52 PM.

Details

Reviewers
None

Diff Detail

Unit TestsFailed

TimeTest
60 msx64 debian > LLVM.Transforms/InstCombine::and-or-not.ll
90 msx64 debian > LLVM.Transforms/InstCombine::or-xor.ll
60 msx64 debian > LLVM.Transforms/InstCombine::xor2.ll
60,060 msx64 debian > MLIR.Examples/standalone::test.toy

Revision Contents

PathSize
llvm/
test/
Transforms/
InstCombine/
14 lines
18 lines
38 lines

Diff 497551

llvm/test/Transforms/InstCombine/and-or-not.ll

Show First 20 Lines • Show All 757 Lines • ▼ Show 20 Lines;
ret i4 %r ret i4 %r
} }
; TODO: This should simplify. ; TODO: This should simplify.
define i4 @simplify_and_common_op_use2(i4 %x, i4 %y, i4 %z) { define i4 @simplify_and_common_op_use2(i4 %x, i4 %y, i4 %z) {
; CHECK-LABEL: @simplify_and_common_op_use2( ; CHECK-LABEL: @simplify_and_common_op_use2(
; CHECK-NEXT: call void @use(i4 [[Y:%.*]]) ; CHECK-NEXT: call void @use(i4 [[Y:%.*]])
; CHECK-NEXT: [[TMP1:%.*]] = or i4 [[X:%.*]], [[Z:%.*]] ; CHECK-NEXT: ret i4 0
; CHECK-NEXT: [[XYZ:%.*]] = or i4 [[TMP1]], [[Y]]
; CHECK-NEXT: [[NOT_XYZ:%.*]] = xor i4 [[XYZ]], -1
; CHECK-NEXT: [[R:%.*]] = and i4 [[NOT_XYZ]], [[X]]
; CHECK-NEXT: ret i4 [[R]]
; ;
%xy = or i4 %y, %x %xy = or i4 %y, %x
call void @use(i4 %y) call void @use(i4 %y)
%xyz = or i4 %xy, %z %xyz = or i4 %xy, %z
%not_xyz = xor i4 %xyz, -1 %not_xyz = xor i4 %xyz, -1
%r = and i4 %not_xyz, %x %r = and i4 %not_xyz, %x
ret i4 %r ret i4 %r
} }
; TODO: This should simplify. ; TODO: This should simplify.
define i4 @simplify_and_common_op_use3(i4 %x, i4 %y, i4 %z) { define i4 @simplify_and_common_op_use3(i4 %x, i4 %y, i4 %z) {
; CHECK-LABEL: @simplify_and_common_op_use3( ; CHECK-LABEL: @simplify_and_common_op_use3(
; CHECK-NEXT: [[XY:%.*]] = or i4 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: call void @use(i4 [[Z:%.*]])
; CHECK-NEXT: [[XYZ:%.*]] = or i4 [[XY]], [[Z:%.*]] ; CHECK-NEXT: ret i4 0
; CHECK-NEXT: call void @use(i4 [[Z]])
; CHECK-NEXT: [[NOT_XYZ:%.*]] = xor i4 [[XYZ]], -1
; CHECK-NEXT: [[R:%.*]] = and i4 [[NOT_XYZ]], [[X]]
; CHECK-NEXT: ret i4 [[R]]
; ;
%xy = or i4 %x, %y %xy = or i4 %x, %y
%xyz = or i4 %xy, %z %xyz = or i4 %xy, %z
call void @use(i4 %z) call void @use(i4 %z)
%not_xyz = xor i4 %xyz, -1 %not_xyz = xor i4 %xyz, -1
%r = and i4 %not_xyz, %x %r = and i4 %not_xyz, %x
ret i4 %r ret i4 %r
} }
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/or-xor.ll

Show First 20 Lines • Show All 225 Lines • ▼ Show 20 Lines;
%z = or i32 %x, %xor %z = or i32 %x, %xor
ret i32 %z ret i32 %z
} }
; (A ^ B) | (~A ^ B) --> -1 ; (A ^ B) | (~A ^ B) --> -1
define i32 @test10(i32 %A, i32 %B) { define i32 @test10(i32 %A, i32 %B) {
; CHECK-LABEL: @test10( ; CHECK-LABEL: @test10(
; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B:%.*]], [[A:%.*]] ; CHECK-NEXT: ret i32 -1
; CHECK-NEXT: [[TMP1:%.*]] = xor i32 [[A]], [[B]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[OR:%.*]] = or i32 [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret i32 [[OR]]
; ;
%xor1 = xor i32 %B, %A %xor1 = xor i32 %B, %A
%not = xor i32 %A, -1 %not = xor i32 %A, -1
%xor2 = xor i32 %not, %B %xor2 = xor i32 %not, %B
%or = or i32 %xor1, %xor2 %or = or i32 %xor1, %xor2
ret i32 %or ret i32 %or
} }
define i32 @test10_commuted(i32 %A, i32 %B) { define i32 @test10_commuted(i32 %A, i32 %B) {
; CHECK-LABEL: @test10_commuted( ; CHECK-LABEL: @test10_commuted(
; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B:%.*]], [[A:%.*]] ; CHECK-NEXT: ret i32 -1
; CHECK-NEXT: [[TMP1:%.*]] = xor i32 [[A]], [[B]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[OR:%.*]] = or i32 [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret i32 [[OR]]
; ;
%xor1 = xor i32 %B, %A %xor1 = xor i32 %B, %A
%not = xor i32 %A, -1 %not = xor i32 %A, -1
%xor2 = xor i32 %not, %B %xor2 = xor i32 %not, %B
%or = or i32 %xor2, %xor1 %or = or i32 %xor2, %xor1
ret i32 %or ret i32 %or
} }
Show All 23 Lines;
%xor2 = xor i32 %not, %B %xor2 = xor i32 %not, %B
%or = or i32 %xor2, %xor1 %or = or i32 %xor2, %xor1
ret i32 %or ret i32 %or
} }
; (A ^ B) | ~(A ^ B) --> -1 ; (A ^ B) | ~(A ^ B) --> -1
define i32 @test10_canonical(i32 %A, i32 %B) { define i32 @test10_canonical(i32 %A, i32 %B) {
; CHECK-LABEL: @test10_canonical( ; CHECK-LABEL: @test10_canonical(
; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B:%.*]], [[A:%.*]] ; CHECK-NEXT: ret i32 -1
; CHECK-NEXT: [[XOR2:%.*]] = xor i32 [[A]], [[B]]
; CHECK-NEXT: [[NOT:%.*]] = xor i32 [[XOR2]], -1
; CHECK-NEXT: [[OR:%.*]] = or i32 [[XOR1]], [[NOT]]
; CHECK-NEXT: ret i32 [[OR]]
; ;
%xor1 = xor i32 %B, %A %xor1 = xor i32 %B, %A
%xor2 = xor i32 %A, %B %xor2 = xor i32 %A, %B
%not = xor i32 %xor2, -1 %not = xor i32 %xor2, -1
%or = or i32 %xor1, %not %or = or i32 %xor1, %not
ret i32 %or ret i32 %or
} }
▲ Show 20 Lines • Show All 752 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/xor2.ll

Show First 20 Lines • Show All 165 Lines • ▼ Show 20 Lines;
%xor = xor i32 %b, %c %xor = xor i32 %b, %c
%and = and i32 %c, %b %and = and i32 %c, %b
%xor2 = xor i32 %xor, %and %xor2 = xor i32 %xor, %and
ret i32 %xor2 ret i32 %xor2
} }
define i32 @test11(i32 %A, i32 %B) { define i32 @test11(i32 %A, i32 %B) {
; CHECK-LABEL: @test11( ; CHECK-LABEL: @test11(
; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B:%.*]], [[A:%.*]] ; CHECK-NEXT: ret i32 0
; CHECK-NEXT: [[TMP1:%.*]] = xor i32 [[A]], [[B]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[AND:%.*]] = and i32 [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret i32 [[AND]]
; ;
%xor1 = xor i32 %B, %A %xor1 = xor i32 %B, %A
%not = xor i32 %A, -1 %not = xor i32 %A, -1
%xor2 = xor i32 %not, %B %xor2 = xor i32 %not, %B
%and = and i32 %xor1, %xor2 %and = and i32 %xor1, %xor2
ret i32 %and ret i32 %and
} }
define i32 @test11b(i32 %A, i32 %B) { define i32 @test11b(i32 %A, i32 %B) {
; CHECK-LABEL: @test11b( ; CHECK-LABEL: @test11b(
; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B:%.*]], [[A:%.*]] ; CHECK-NEXT: ret i32 0
; CHECK-NEXT: [[TMP1:%.*]] = xor i32 [[A]], [[B]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[AND:%.*]] = and i32 [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret i32 [[AND]]
; ;
%xor1 = xor i32 %B, %A %xor1 = xor i32 %B, %A
%not = xor i32 %A, -1 %not = xor i32 %A, -1
%xor2 = xor i32 %not, %B %xor2 = xor i32 %not, %B
%and = and i32 %xor2, %xor1 %and = and i32 %xor2, %xor1
ret i32 %and ret i32 %and
} }
define i32 @test11c(i32 %A, i32 %B) { define i32 @test11c(i32 %A, i32 %B) {
; CHECK-LABEL: @test11c( ; CHECK-LABEL: @test11c(
; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: ret i32 0
; CHECK-NEXT: [[TMP1:%.*]] = xor i32 [[A]], [[B]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[AND:%.*]] = and i32 [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret i32 [[AND]]
; ;
%xor1 = xor i32 %A, %B %xor1 = xor i32 %A, %B
%not = xor i32 %A, -1 %not = xor i32 %A, -1
%xor2 = xor i32 %not, %B %xor2 = xor i32 %not, %B
%and = and i32 %xor1, %xor2 %and = and i32 %xor1, %xor2
ret i32 %and ret i32 %and
} }
define i32 @test11d(i32 %A, i32 %B) { define i32 @test11d(i32 %A, i32 %B) {
; CHECK-LABEL: @test11d( ; CHECK-LABEL: @test11d(
; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: ret i32 0
; CHECK-NEXT: [[TMP1:%.*]] = xor i32 [[A]], [[B]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[AND:%.*]] = and i32 [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret i32 [[AND]]
; ;
%xor1 = xor i32 %A, %B %xor1 = xor i32 %A, %B
%not = xor i32 %A, -1 %not = xor i32 %A, -1
%xor2 = xor i32 %not, %B %xor2 = xor i32 %not, %B
%and = and i32 %xor2, %xor1 %and = and i32 %xor2, %xor1
ret i32 %and ret i32 %and
} }
define i32 @test11e(i32 %A, i32 %B, i32 %C) { define i32 @test11e(i32 %A, i32 %B, i32 %C) {
; CHECK-LABEL: @test11e( ; CHECK-LABEL: @test11e(
; CHECK-NEXT: [[FORCE:%.*]] = mul i32 [[B:%.*]], [[C:%.*]] ; CHECK-NEXT: ret i32 0
; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[FORCE]], [[A:%.*]]
; CHECK-NEXT: [[TMP1:%.*]] = xor i32 [[FORCE]], [[A]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[AND:%.*]] = and i32 [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret i32 [[AND]]
; ;
%force = mul i32 %B, %C %force = mul i32 %B, %C
%xor1 = xor i32 %force, %A %xor1 = xor i32 %force, %A
%not = xor i32 %A, -1 %not = xor i32 %A, -1
%xor2 = xor i32 %force, %not %xor2 = xor i32 %force, %not
%and = and i32 %xor1, %xor2 %and = and i32 %xor1, %xor2
ret i32 %and ret i32 %and
} }
define i32 @test11f(i32 %A, i32 %B, i32 %C) { define i32 @test11f(i32 %A, i32 %B, i32 %C) {
; CHECK-LABEL: @test11f( ; CHECK-LABEL: @test11f(
; CHECK-NEXT: [[FORCE:%.*]] = mul i32 [[B:%.*]], [[C:%.*]] ; CHECK-NEXT: ret i32 0
; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[FORCE]], [[A:%.*]]
; CHECK-NEXT: [[TMP1:%.*]] = xor i32 [[FORCE]], [[A]]
; CHECK-NEXT: [[XOR2:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[AND:%.*]] = and i32 [[XOR1]], [[XOR2]]
; CHECK-NEXT: ret i32 [[AND]]
; ;
%force = mul i32 %B, %C %force = mul i32 %B, %C
%xor1 = xor i32 %force, %A %xor1 = xor i32 %force, %A
%not = xor i32 %A, -1 %not = xor i32 %A, -1
%xor2 = xor i32 %force, %not %xor2 = xor i32 %force, %not
%and = and i32 %xor2, %xor1 %and = and i32 %xor2, %xor1
ret i32 %and ret i32 %and
} }
▲ Show 20 Lines • Show All 481 Lines • Show Last 20 Lines