This is an archive of the discontinued LLVM Phabricator instance.

Differential D157289

[InstCombine] Fold (-a >> b) and/or/xor (~a >> b) into (-a and/or/xor ~a) >> b tests
ClosedPublic

Authored by kitaisreal on Aug 7 2023, 8:19 AM.

Details

Reviewers
nikic
goldstein.w.n
Commits
rGf5130a578eb7: [InstCombine] Fold (-a >> b) and/or/xor (~a >> b) into (-a and/or/xor ~a) >> b…
Summary

Precommit tests for D157290.

Diff Detail

Unit TestsFailed

TimeTest
60,030 msx64 debian > MLIR.Examples/standalone::test.toy

Event Timeline

kitaisreal created this revision.Aug 7 2023, 8:19 AM
Herald added a subscriber: StephenFan. · View Herald TranscriptAug 7 2023, 8:19 AM
kitaisreal requested review of this revision.Aug 7 2023, 8:19 AM
Herald added a subscriber: llvm-commits. · View Herald TranscriptAug 7 2023, 8:19 AM
kitaisreal added a child revision: D157290: [InstCombine] Fold (-a >> b) and/or/xor (~a >> b) into (-a and/or/xor ~a) >> b.Aug 7 2023, 8:26 AM
kitaisreal edited the summary of this revision. (Show Details)
Harbormaster completed remote builds in B250798: Diff 547802.Aug 7 2023, 10:46 AM
kitaisreal updated this revision to Diff 549612.Aug 12 2023, 8:04 AM

Updated tests.

kitaisreal retitled this revision from [InstCombine] Fold (-a >> b) and/or (~a >> b) into (-a and/or ~a) >> b tests to [InstCombine] Fold (-a >> b) and/or/xor (~a >> b) into (-a and/or/xor ~a) >> b tests.Aug 12 2023, 8:04 AM
Harbormaster completed remote builds in B252110: Diff 549612.Aug 12 2023, 10:53 AM
kitaisreal updated this revision to Diff 549639.Aug 12 2023, 11:32 AM

Updated tests.

Harbormaster completed remote builds in B252132: Diff 549639.Aug 12 2023, 2:36 PM
kitaisreal updated this revision to Diff 549704.Aug 13 2023, 8:38 AM

Updated tests.

Harbormaster completed remote builds in B252186: Diff 549704.Aug 13 2023, 9:36 AM
nikic added inline comments.Aug 14 2023, 3:13 AM
llvm/test/Transforms/InstCombine/binop-and-shifts.ll
568

All of these tests have ashr(xor) rather than xor(ashr) as the input. However, the latter is what it gets canonicalized to. It would be better to directly use the latter form, so it's clearer what the transform operates on.

We should also adjust the proofs accordingly, e.g. https://alive2.llvm.org/ce/z/Dds-Nw has the xor in the position the transform looks for it.

902

I think this could use two more negative tests:

  • Something other than -1 as the xor constant.
  • A binop for which this is not valid, e.g. add instead of and/or/xor.
kitaisreal updated this revision to Diff 549947.Aug 14 2023, 8:06 AM

Updated tests.

kitaisreal marked 2 inline comments as done.Aug 14 2023, 8:07 AM
Harbormaster completed remote builds in B252364: Diff 549947.Aug 14 2023, 10:31 AM
kitaisreal added a comment.Aug 16 2023, 6:06 AM

@nikic I updated tests could you please accept this and D157290 ?

nikic accepted this revision.Aug 16 2023, 6:08 AM

LG

This revision is now accepted and ready to land.Aug 16 2023, 6:08 AM
This revision was landed with ongoing or failed builds.Aug 21 2023, 2:50 AM
Closed by commit rGf5130a578eb7: [InstCombine] Fold (-a >> b) and/or/xor (~a >> b) into (-a and/or/xor ~a) >> b… (authored by kitaisreal). · Explain Why
This revision was automatically updated to reflect the committed changes.
kitaisreal added a commit: rGf5130a578eb7: [InstCombine] Fold (-a >> b) and/or/xor (~a >> b) into (-a and/or/xor ~a) >> b….

Revision Contents

PathSize
llvm/
test/
Transforms/
InstCombine/
398 lines

Diff 549639

llvm/test/Transforms/InstCombine/binop-and-shifts.ll

Show First 20 Lines • Show All 543 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ret i8 [[BW1]] ; CHECK-NEXT: ret i8 [[BW1]]
; ;
%shift1 = shl i8 %x, 1 %shift1 = shl i8 %x, 1
%shift2 = lshr i8 %y, 1 %shift2 = lshr i8 %y, 1
%bw2 = add i8 %shift2, 123 %bw2 = add i8 %shift2, 123
%bw1 = and i8 %shift1, %bw2 %bw1 = and i8 %shift1, %bw2
ret i8 %bw1 ret i8 %bw1
} }
; Fold (-x >> y) & ((x >> y) ^ -1) -> (-x & ~x) >> y
define i8 @and_ashr_not(i8 %x, i8 %y) {
; CHECK-LABEL: @and_ashr_not(
; CHECK-NEXT: [[MUL:%.*]] = mul i8 [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = ashr i8 [[MUL]], [[Y:%.*]]
; CHECK-NEXT: [[NOT_NOT:%.*]] = ashr i8 [[X]], [[Y]]
; CHECK-NEXT: [[SHR1:%.*]] = xor i8 [[NOT_NOT]], -1
; CHECK-NEXT: [[AND:%.*]] = and i8 [[SHR]], [[SHR1]]
; CHECK-NEXT: ret i8 [[AND]]
;
%mul = mul i8 %x, %x
%shr = ashr i8 %mul, %y
%not = xor i8 %x, -1
%shr1 = ashr i8 %not, %y
%and = and i8 %shr, %shr1
nikicUnsubmitted
Done
ReplyInline Actions

All of these tests have ashr(xor) rather than xor(ashr) as the input. However, the latter is what it gets canonicalized to. It would be better to directly use the latter form, so it's clearer what the transform operates on.

We should also adjust the proofs accordingly, e.g. https://alive2.llvm.org/ce/z/Dds-Nw has the xor in the position the transform looks for it.

nikic: All of these tests have `ashr(xor)` rather than `xor(ashr)` as the input. However, the latter…
ret i8 %and
}
define i8 @and_ashr_not_commuted(i8 %x, i8 %y) {
; CHECK-LABEL: @and_ashr_not_commuted(
; CHECK-NEXT: [[MUL:%.*]] = mul i8 [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = ashr i8 [[MUL]], [[Y:%.*]]
; CHECK-NEXT: [[NOT_NOT:%.*]] = ashr i8 [[X]], [[Y]]
; CHECK-NEXT: [[SHR1:%.*]] = xor i8 [[NOT_NOT]], -1
; CHECK-NEXT: [[AND:%.*]] = and i8 [[SHR]], [[SHR1]]
; CHECK-NEXT: ret i8 [[AND]]
;
%mul = mul i8 %x, %x
%shr = ashr i8 %mul, %y
%not = xor i8 %x, -1
%shr1 = ashr i8 %not, %y
%and = and i8 %shr1, %shr
ret i8 %and
}
define i8 @and_ashr_not_fail_1(i8 %x, i8 %y) {
; CHECK-LABEL: @and_ashr_not_fail_1(
; CHECK-NEXT: [[MUL:%.*]] = mul i8 [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = ashr i8 [[MUL]], [[Y:%.*]]
; CHECK-NEXT: [[NOT:%.*]] = xor i8 [[X]], -1
; CHECK-NEXT: [[SHR1:%.*]] = lshr i8 [[NOT]], [[Y]]
; CHECK-NEXT: [[AND:%.*]] = and i8 [[SHR]], [[SHR1]]
; CHECK-NEXT: ret i8 [[AND]]
;
%mul = mul i8 %x, %x
%shr = ashr i8 %mul, %y
%not = xor i8 %x, -1
%shr1 = lshr i8 %not, %y
%and = and i8 %shr, %shr1
ret i8 %and
}
define i8 @and_ashr_not_fail_2(i8 %x, i8 %y) {
; CHECK-LABEL: @and_ashr_not_fail_2(
; CHECK-NEXT: [[MUL:%.*]] = mul i8 [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = lshr i8 [[MUL]], [[Y:%.*]]
; CHECK-NEXT: [[NOT_NOT:%.*]] = ashr i8 [[X]], [[Y]]
; CHECK-NEXT: [[SHR1:%.*]] = xor i8 [[NOT_NOT]], -1
; CHECK-NEXT: [[AND:%.*]] = and i8 [[SHR]], [[SHR1]]
; CHECK-NEXT: ret i8 [[AND]]
;
%mul = mul i8 %x, %x
%shr = lshr i8 %mul, %y
%not = xor i8 %x, -1
%shr1 = ashr i8 %not, %y
%and = and i8 %shr, %shr1
ret i8 %and
}
define <4 x i8> @and_ashr_not_vec(<4 x i8> %x, <4 x i8> %y) {
; CHECK-LABEL: @and_ashr_not_vec(
; CHECK-NEXT: [[MUL:%.*]] = mul <4 x i8> [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = ashr <4 x i8> [[MUL]], [[Y:%.*]]
; CHECK-NEXT: [[NOT_NOT:%.*]] = ashr <4 x i8> [[X]], [[Y]]
; CHECK-NEXT: [[SHR1:%.*]] = xor <4 x i8> [[NOT_NOT]], <i8 -1, i8 -1, i8 -1, i8 -1>
; CHECK-NEXT: [[AND:%.*]] = and <4 x i8> [[SHR]], [[SHR1]]
; CHECK-NEXT: ret <4 x i8> [[AND]]
;
%mul = mul <4 x i8> %x, %x
%shr = ashr <4 x i8> %mul, %y
%not = xor <4 x i8> %x, <i8 -1, i8 -1, i8 -1, i8 -1>
%shr1 = ashr <4 x i8> %not, %y
%and = and <4 x i8> %shr, %shr1
ret <4 x i8> %and
}
define <4 x i8> @and_ashr_not_vec_commuted(<4 x i8> %x, <4 x i8> %y) {
; CHECK-LABEL: @and_ashr_not_vec_commuted(
; CHECK-NEXT: [[MUL:%.*]] = mul <4 x i8> [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = ashr <4 x i8> [[MUL]], [[Y:%.*]]
; CHECK-NEXT: [[NOT_NOT:%.*]] = ashr <4 x i8> [[X]], [[Y]]
; CHECK-NEXT: [[SHR1:%.*]] = xor <4 x i8> [[NOT_NOT]], <i8 -1, i8 -1, i8 -1, i8 -1>
; CHECK-NEXT: [[AND:%.*]] = and <4 x i8> [[SHR]], [[SHR1]]
; CHECK-NEXT: ret <4 x i8> [[AND]]
;
%mul = mul <4 x i8> %x, %x
%shr = ashr <4 x i8> %mul, %y
%not = xor <4 x i8> %x, <i8 -1, i8 -1, i8 -1, i8 -1>
%shr1 = ashr <4 x i8> %not, %y
%and = and <4 x i8> %shr1, %shr
ret <4 x i8> %and
}
define <4 x i8> @and_ashr_not_vec_undef_1(<4 x i8> %x, <4 x i8> %y) {
; CHECK-LABEL: @and_ashr_not_vec_undef_1(
; CHECK-NEXT: [[MUL:%.*]] = mul <4 x i8> [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = ashr <4 x i8> [[MUL]], [[Y:%.*]]
; CHECK-NEXT: [[NOT_NOT:%.*]] = ashr <4 x i8> [[X]], [[Y]]
; CHECK-NEXT: [[SHR1:%.*]] = xor <4 x i8> [[NOT_NOT]], <i8 -1, i8 -1, i8 -1, i8 -1>
; CHECK-NEXT: [[AND:%.*]] = and <4 x i8> [[SHR]], [[SHR1]]
; CHECK-NEXT: ret <4 x i8> [[AND]]
;
%mul = mul <4 x i8> %x, %x
%shr = ashr <4 x i8> %mul, %y
%not = xor <4 x i8> %x, <i8 -1, i8 undef, i8 undef, i8 undef>
%shr1 = ashr <4 x i8> %not, %y
%and = and <4 x i8> %shr, %shr1
ret <4 x i8> %and
}
define <4 x i8> @and_ashr_not_vec_undef_2(<4 x i8> %x, <4 x i8> %y) {
; CHECK-LABEL: @and_ashr_not_vec_undef_2(
; CHECK-NEXT: ret <4 x i8> zeroinitializer
;
%mul = mul <4 x i8> %x, %x
%shr = ashr <4 x i8> %mul, %y
%not = xor <4 x i8> %x, <i8 undef, i8 undef, i8 undef, i8 undef>
%shr1 = ashr <4 x i8> %not, %y
%and = and <4 x i8> %shr, %shr1
ret <4 x i8> %and
}
; Fold (-x >> y) | ((x >> y) ^ -1) -> (-x | ~x) >> y
define i8 @or_ashr_not(i8 %x, i8 %y) {
; CHECK-LABEL: @or_ashr_not(
; CHECK-NEXT: [[MUL:%.*]] = mul i8 [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = ashr i8 [[MUL]], [[Y:%.*]]
; CHECK-NEXT: [[NOT_NOT:%.*]] = ashr i8 [[X]], [[Y]]
; CHECK-NEXT: [[SHR1:%.*]] = xor i8 [[NOT_NOT]], -1
; CHECK-NEXT: [[OR:%.*]] = or i8 [[SHR]], [[SHR1]]
; CHECK-NEXT: ret i8 [[OR]]
;
%mul = mul i8 %x, %x
%shr = ashr i8 %mul, %y
%not = xor i8 %x, -1
%shr1 = ashr i8 %not, %y
%or = or i8 %shr, %shr1
ret i8 %or
}
define i8 @or_ashr_not_commuted(i8 %x, i8 %y) {
; CHECK-LABEL: @or_ashr_not_commuted(
; CHECK-NEXT: [[MUL:%.*]] = mul i8 [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = ashr i8 [[MUL]], [[Y:%.*]]
; CHECK-NEXT: [[NOT_NOT:%.*]] = ashr i8 [[X]], [[Y]]
; CHECK-NEXT: [[SHR1:%.*]] = xor i8 [[NOT_NOT]], -1
; CHECK-NEXT: [[OR:%.*]] = or i8 [[SHR]], [[SHR1]]
; CHECK-NEXT: ret i8 [[OR]]
;
%mul = mul i8 %x, %x
%shr = ashr i8 %mul, %y
%not = xor i8 %x, -1
%shr1 = ashr i8 %not, %y
%or = or i8 %shr1, %shr
ret i8 %or
}
define i8 @or_ashr_not_fail_1(i8 %x, i8 %y) {
; CHECK-LABEL: @or_ashr_not_fail_1(
; CHECK-NEXT: [[MUL:%.*]] = mul i8 [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = ashr i8 [[MUL]], [[Y:%.*]]
; CHECK-NEXT: [[NOT:%.*]] = xor i8 [[X]], -1
; CHECK-NEXT: [[SHR1:%.*]] = lshr i8 [[NOT]], [[Y]]
; CHECK-NEXT: [[OR:%.*]] = or i8 [[SHR]], [[SHR1]]
; CHECK-NEXT: ret i8 [[OR]]
;
%mul = mul i8 %x, %x
%shr = ashr i8 %mul, %y
%not = xor i8 %x, -1
%shr1 = lshr i8 %not, %y
%or = or i8 %shr, %shr1
ret i8 %or
}
define i8 @or_ashr_not_fail_2(i8 %x, i8 %y) {
; CHECK-LABEL: @or_ashr_not_fail_2(
; CHECK-NEXT: [[MUL:%.*]] = mul i8 [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = lshr i8 [[MUL]], [[Y:%.*]]
; CHECK-NEXT: [[NOT_NOT:%.*]] = ashr i8 [[X]], [[Y]]
; CHECK-NEXT: [[SHR1:%.*]] = xor i8 [[NOT_NOT]], -1
; CHECK-NEXT: [[OR:%.*]] = or i8 [[SHR]], [[SHR1]]
; CHECK-NEXT: ret i8 [[OR]]
;
%mul = mul i8 %x, %x
%shr = lshr i8 %mul, %y
%not = xor i8 %x, -1
%shr1 = ashr i8 %not, %y
%or = or i8 %shr, %shr1
ret i8 %or
}
define <4 x i8> @or_ashr_not_vec(<4 x i8> %x, <4 x i8> %y) {
; CHECK-LABEL: @or_ashr_not_vec(
; CHECK-NEXT: [[MUL:%.*]] = mul <4 x i8> [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = ashr <4 x i8> [[MUL]], [[Y:%.*]]
; CHECK-NEXT: [[NOT_NOT:%.*]] = ashr <4 x i8> [[X]], [[Y]]
; CHECK-NEXT: [[SHR1:%.*]] = xor <4 x i8> [[NOT_NOT]], <i8 -1, i8 -1, i8 -1, i8 -1>
; CHECK-NEXT: [[OR:%.*]] = or <4 x i8> [[SHR]], [[SHR1]]
; CHECK-NEXT: ret <4 x i8> [[OR]]
;
%mul = mul <4 x i8> %x, %x
%shr = ashr <4 x i8> %mul, %y
%not = xor <4 x i8> %x, <i8 -1, i8 -1, i8 -1, i8 -1>
%shr1 = ashr <4 x i8> %not, %y
%or = or <4 x i8> %shr, %shr1
ret <4 x i8> %or
}
define <4 x i8> @or_ashr_not_vec_commuted(<4 x i8> %x, <4 x i8> %y) {
; CHECK-LABEL: @or_ashr_not_vec_commuted(
; CHECK-NEXT: [[MUL:%.*]] = mul <4 x i8> [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = ashr <4 x i8> [[MUL]], [[Y:%.*]]
; CHECK-NEXT: [[NOT_NOT:%.*]] = ashr <4 x i8> [[X]], [[Y]]
; CHECK-NEXT: [[SHR1:%.*]] = xor <4 x i8> [[NOT_NOT]], <i8 -1, i8 -1, i8 -1, i8 -1>
; CHECK-NEXT: [[OR:%.*]] = or <4 x i8> [[SHR]], [[SHR1]]
; CHECK-NEXT: ret <4 x i8> [[OR]]
;
%mul = mul <4 x i8> %x, %x
%shr = ashr <4 x i8> %mul, %y
%not = xor <4 x i8> %x, <i8 -1, i8 -1, i8 -1, i8 -1>
%shr1 = ashr <4 x i8> %not, %y
%or = or <4 x i8> %shr1, %shr
ret <4 x i8> %or
}
define <4 x i8> @or_ashr_not_vec_undef_1(<4 x i8> %x, <4 x i8> %y) {
; CHECK-LABEL: @or_ashr_not_vec_undef_1(
; CHECK-NEXT: [[MUL:%.*]] = mul <4 x i8> [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = ashr <4 x i8> [[MUL]], [[Y:%.*]]
; CHECK-NEXT: [[NOT_NOT:%.*]] = ashr <4 x i8> [[X]], [[Y]]
; CHECK-NEXT: [[SHR1:%.*]] = xor <4 x i8> [[NOT_NOT]], <i8 -1, i8 -1, i8 -1, i8 -1>
; CHECK-NEXT: [[OR:%.*]] = or <4 x i8> [[SHR]], [[SHR1]]
; CHECK-NEXT: ret <4 x i8> [[OR]]
;
%mul = mul <4 x i8> %x, %x
%shr = ashr <4 x i8> %mul, %y
%not = xor <4 x i8> %x, <i8 -1, i8 undef, i8 undef, i8 undef>
%shr1 = ashr <4 x i8> %not, %y
%or = or <4 x i8> %shr, %shr1
ret <4 x i8> %or
}
define <4 x i8> @or_ashr_not_vec_undef_2(<4 x i8> %x, <4 x i8> %y) {
; CHECK-LABEL: @or_ashr_not_vec_undef_2(
; CHECK-NEXT: [[MUL:%.*]] = mul <4 x i8> [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = ashr <4 x i8> [[MUL]], [[Y:%.*]]
; CHECK-NEXT: ret <4 x i8> [[SHR]]
;
%mul = mul <4 x i8> %x, %x
%shr = ashr <4 x i8> %mul, %y
%not = xor <4 x i8> %x, <i8 undef, i8 undef, i8 undef, i8 undef>
%shr1 = ashr <4 x i8> %not, %y
%or = or <4 x i8> %shr, %shr1
ret <4 x i8> %or
}
; Fold (-x >> y) ^ ((x >> y) ^ -1) -> (-x ^ ~x) >> y
define i8 @xor_ashr_not(i8 %x, i8 %y) {
; CHECK-LABEL: @xor_ashr_not(
; CHECK-NEXT: [[MUL:%.*]] = mul i8 [[X:%.*]], [[X]]
; CHECK-NEXT: [[NOT_NOT1:%.*]] = xor i8 [[MUL]], [[X]]
; CHECK-NEXT: [[TMP1:%.*]] = ashr i8 [[NOT_NOT1]], [[Y:%.*]]
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[TMP1]], -1
; CHECK-NEXT: ret i8 [[XOR]]
;
%mul = mul i8 %x, %x
%shr = ashr i8 %mul, %y
%not = xor i8 %x, -1
%shr1 = ashr i8 %not, %y
%xor = xor i8 %shr, %shr1
ret i8 %xor
}
define i8 @xor_ashr_not_commuted(i8 %x, i8 %y) {
; CHECK-LABEL: @xor_ashr_not_commuted(
; CHECK-NEXT: [[MUL:%.*]] = mul i8 [[X:%.*]], [[X]]
; CHECK-NEXT: [[NOT_NOT1:%.*]] = xor i8 [[MUL]], [[X]]
; CHECK-NEXT: [[TMP1:%.*]] = ashr i8 [[NOT_NOT1]], [[Y:%.*]]
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[TMP1]], -1
; CHECK-NEXT: ret i8 [[XOR]]
;
%mul = mul i8 %x, %x
%shr = ashr i8 %mul, %y
%not = xor i8 %x, -1
%shr1 = ashr i8 %not, %y
%xor = xor i8 %shr1, %shr
ret i8 %xor
}
define i8 @xor_ashr_not_fail_1(i8 %x, i8 %y) {
; CHECK-LABEL: @xor_ashr_not_fail_1(
; CHECK-NEXT: [[MUL:%.*]] = mul i8 [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = ashr i8 [[MUL]], [[Y:%.*]]
; CHECK-NEXT: [[NOT:%.*]] = xor i8 [[X]], -1
; CHECK-NEXT: [[SHR1:%.*]] = lshr i8 [[NOT]], [[Y]]
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[SHR]], [[SHR1]]
; CHECK-NEXT: ret i8 [[XOR]]
;
%mul = mul i8 %x, %x
%shr = ashr i8 %mul, %y
%not = xor i8 %x, -1
%shr1 = lshr i8 %not, %y
%xor = xor i8 %shr, %shr1
ret i8 %xor
}
define i8 @xor_ashr_not_fail_2(i8 %x, i8 %y) {
; CHECK-LABEL: @xor_ashr_not_fail_2(
; CHECK-NEXT: [[MUL:%.*]] = mul i8 [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = lshr i8 [[MUL]], [[Y:%.*]]
; CHECK-NEXT: [[NOT_NOT:%.*]] = ashr i8 [[X]], [[Y]]
; CHECK-NEXT: [[TMP1:%.*]] = xor i8 [[NOT_NOT]], [[SHR]]
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[TMP1]], -1
; CHECK-NEXT: ret i8 [[XOR]]
;
%mul = mul i8 %x, %x
%shr = lshr i8 %mul, %y
%not = xor i8 %x, -1
%shr1 = ashr i8 %not, %y
%xor = xor i8 %shr, %shr1
ret i8 %xor
}
define <4 x i8> @xor_ashr_not_vec(<4 x i8> %x, <4 x i8> %y) {
; CHECK-LABEL: @xor_ashr_not_vec(
; CHECK-NEXT: [[MUL:%.*]] = mul <4 x i8> [[X:%.*]], [[X]]
; CHECK-NEXT: [[NOT_NOT1:%.*]] = xor <4 x i8> [[MUL]], [[X]]
; CHECK-NEXT: [[TMP1:%.*]] = ashr <4 x i8> [[NOT_NOT1]], [[Y:%.*]]
; CHECK-NEXT: [[XOR:%.*]] = xor <4 x i8> [[TMP1]], <i8 -1, i8 -1, i8 -1, i8 -1>
; CHECK-NEXT: ret <4 x i8> [[XOR]]
;
%mul = mul <4 x i8> %x, %x
%shr = ashr <4 x i8> %mul, %y
%not = xor <4 x i8> %x, <i8 -1, i8 -1, i8 -1, i8 -1>
%shr1 = ashr <4 x i8> %not, %y
%xor = xor <4 x i8> %shr, %shr1
ret <4 x i8> %xor
nikicUnsubmitted
Done
ReplyInline Actions

I think this could use two more negative tests:

  • Something other than -1 as the xor constant.
  • A binop for which this is not valid, e.g. add instead of and/or/xor.
nikic: I think this could use two more negative tests: * Something other than -1 as the xor constant.
}
define <4 x i8> @xor_ashr_not_vec_commuted(<4 x i8> %x, <4 x i8> %y) {
; CHECK-LABEL: @xor_ashr_not_vec_commuted(
; CHECK-NEXT: [[MUL:%.*]] = mul <4 x i8> [[X:%.*]], [[X]]
; CHECK-NEXT: [[NOT_NOT1:%.*]] = xor <4 x i8> [[MUL]], [[X]]
; CHECK-NEXT: [[TMP1:%.*]] = ashr <4 x i8> [[NOT_NOT1]], [[Y:%.*]]
; CHECK-NEXT: [[XOR:%.*]] = xor <4 x i8> [[TMP1]], <i8 -1, i8 -1, i8 -1, i8 -1>
; CHECK-NEXT: ret <4 x i8> [[XOR]]
;
%mul = mul <4 x i8> %x, %x
%shr = ashr <4 x i8> %mul, %y
%not = xor <4 x i8> %x, <i8 -1, i8 -1, i8 -1, i8 -1>
%shr1 = ashr <4 x i8> %not, %y
%xor = xor <4 x i8> %shr1, %shr
ret <4 x i8> %xor
}
define <4 x i8> @xor_ashr_not_vec_undef_1(<4 x i8> %x, <4 x i8> %y) {
; CHECK-LABEL: @xor_ashr_not_vec_undef_1(
; CHECK-NEXT: [[MUL:%.*]] = mul <4 x i8> [[X:%.*]], [[X]]
; CHECK-NEXT: [[NOT_NOT1:%.*]] = xor <4 x i8> [[MUL]], [[X]]
; CHECK-NEXT: [[TMP1:%.*]] = ashr <4 x i8> [[NOT_NOT1]], [[Y:%.*]]
; CHECK-NEXT: [[XOR:%.*]] = xor <4 x i8> [[TMP1]], <i8 -1, i8 -1, i8 -1, i8 -1>
; CHECK-NEXT: ret <4 x i8> [[XOR]]
;
%mul = mul <4 x i8> %x, %x
%shr = ashr <4 x i8> %mul, %y
%not = xor <4 x i8> %x, <i8 -1, i8 undef, i8 undef, i8 undef>
%shr1 = ashr <4 x i8> %not, %y
%xor = xor <4 x i8> %shr, %shr1
ret <4 x i8> %xor
}
define <4 x i8> @xor_ashr_not_vec_undef_2(<4 x i8> %x, <4 x i8> %y) {
; CHECK-LABEL: @xor_ashr_not_vec_undef_2(
; CHECK-NEXT: [[MUL:%.*]] = mul <4 x i8> [[X:%.*]], [[X]]
; CHECK-NEXT: [[SHR:%.*]] = ashr <4 x i8> [[MUL]], [[Y:%.*]]
; CHECK-NEXT: ret <4 x i8> [[SHR]]
;
%mul = mul <4 x i8> %x, %x
%shr = ashr <4 x i8> %mul, %y
%not = xor <4 x i8> %x, <i8 undef, i8 undef, i8 undef, i8 undef>
%shr1 = ashr <4 x i8> %not, %y
%xor = xor <4 x i8> %shr, %shr1
ret <4 x i8> %xor
}