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,020 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/
428 lines

Diff 549947

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, i8 %shamt) {
; CHECK-LABEL: @and_ashr_not(
; CHECK-NEXT: [[X_SHIFT:%.*]] = ashr i8 [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = ashr i8 [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor i8 [[Y_SHIFT]], -1
; CHECK-NEXT: [[AND:%.*]] = and i8 [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret i8 [[AND]]
;
%x.shift = ashr i8 %x, %shamt
%y.shift = ashr i8 %y, %shamt
%y.shift.not = xor i8 %y.shift, -1
%and = and i8 %x.shift, %y.shift.not
ret i8 %and
}
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…
define i8 @and_ashr_not_commuted(i8 %x, i8 %y, i8 %shamt) {
; CHECK-LABEL: @and_ashr_not_commuted(
; CHECK-NEXT: [[X_SHIFT:%.*]] = ashr i8 [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = ashr i8 [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor i8 [[Y_SHIFT]], -1
; CHECK-NEXT: [[AND:%.*]] = and i8 [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret i8 [[AND]]
;
%x.shift = ashr i8 %x, %shamt
%y.shift = ashr i8 %y, %shamt
%y.shift.not = xor i8 %y.shift, -1
%and = and i8 %y.shift.not, %x.shift
ret i8 %and
}
; Negative test: lshr instead of ashr
define i8 @and_ashr_not_fail_lshr_ashr(i8 %x, i8 %y, i8 %shamt) {
; CHECK-LABEL: @and_ashr_not_fail_lshr_ashr(
; CHECK-NEXT: [[X_SHIFT:%.*]] = lshr i8 [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = ashr i8 [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor i8 [[Y_SHIFT]], -1
; CHECK-NEXT: [[AND:%.*]] = and i8 [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret i8 [[AND]]
;
%x.shift = lshr i8 %x, %shamt
%y.shift = ashr i8 %y, %shamt
%y.shift.not = xor i8 %y.shift, -1
%and = and i8 %x.shift, %y.shift.not
ret i8 %and
}
; Negative test: lshr instead of ashr
define i8 @and_ashr_not_fail_ashr_lshr(i8 %x, i8 %y, i8 %shamt) {
; CHECK-LABEL: @and_ashr_not_fail_ashr_lshr(
; CHECK-NEXT: [[X_SHIFT:%.*]] = ashr i8 [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = lshr i8 [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor i8 [[Y_SHIFT]], -1
; CHECK-NEXT: [[AND:%.*]] = and i8 [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret i8 [[AND]]
;
%x.shift = ashr i8 %x, %shamt
%y.shift = lshr i8 %y, %shamt
%y.shift.not = xor i8 %y.shift, -1
%and = and i8 %x.shift, %y.shift.not
ret i8 %and
}
; Negative test: invalid xor constant
define i8 @and_ashr_not_fail_invalid_xor_constant(i8 %x, i8 %y, i8 %shamt) {
; CHECK-LABEL: @and_ashr_not_fail_invalid_xor_constant(
; CHECK-NEXT: [[X_SHIFT:%.*]] = ashr i8 [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = ashr i8 [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor i8 [[Y_SHIFT]], -2
; CHECK-NEXT: [[AND:%.*]] = and i8 [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret i8 [[AND]]
;
%x.shift = ashr i8 %x, %shamt
%y.shift = ashr i8 %y, %shamt
%y.shift.not = xor i8 %y.shift, -2
%and = and i8 %x.shift, %y.shift.not
ret i8 %and
}
define <4 x i8> @and_ashr_not_vec(<4 x i8> %x, <4 x i8> %y, <4 x i8> %shamt) {
; CHECK-LABEL: @and_ashr_not_vec(
; CHECK-NEXT: [[X_SHIFT:%.*]] = ashr <4 x i8> [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = ashr <4 x i8> [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor <4 x i8> [[Y_SHIFT]], <i8 -1, i8 -1, i8 -1, i8 -1>
; CHECK-NEXT: [[AND:%.*]] = and <4 x i8> [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret <4 x i8> [[AND]]
;
%x.shift = ashr <4 x i8> %x, %shamt
%y.shift = ashr <4 x i8> %y, %shamt
%y.shift.not = xor <4 x i8> %y.shift, <i8 -1, i8 -1, i8 -1, i8 -1>
%and = and <4 x i8> %x.shift, %y.shift.not
ret <4 x i8> %and
}
define <4 x i8> @and_ashr_not_vec_commuted(<4 x i8> %x, <4 x i8> %y, <4 x i8> %shamt) {
; CHECK-LABEL: @and_ashr_not_vec_commuted(
; CHECK-NEXT: [[X_SHIFT:%.*]] = ashr <4 x i8> [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = ashr <4 x i8> [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor <4 x i8> [[Y_SHIFT]], <i8 -1, i8 -1, i8 -1, i8 -1>
; CHECK-NEXT: [[AND:%.*]] = and <4 x i8> [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret <4 x i8> [[AND]]
;
%x.shift = ashr <4 x i8> %x, %shamt
%y.shift = ashr <4 x i8> %y, %shamt
%y.shift.not = xor <4 x i8> %y.shift, <i8 -1, i8 -1, i8 -1, i8 -1>
%and = and <4 x i8> %y.shift.not, %x.shift
ret <4 x i8> %and
}
define <4 x i8> @and_ashr_not_vec_undef_1(<4 x i8> %x, <4 x i8> %y, <4 x i8> %shamt) {
; CHECK-LABEL: @and_ashr_not_vec_undef_1(
; CHECK-NEXT: [[X_SHIFT:%.*]] = ashr <4 x i8> [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = ashr <4 x i8> [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor <4 x i8> [[Y_SHIFT]], <i8 -1, i8 undef, i8 undef, i8 undef>
; CHECK-NEXT: [[AND:%.*]] = and <4 x i8> [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret <4 x i8> [[AND]]
;
%x.shift = ashr <4 x i8> %x, %shamt
%y.shift = ashr <4 x i8> %y, %shamt
%y.shift.not = xor <4 x i8> %y.shift, <i8 -1, i8 undef, i8 undef, i8 undef>
%and = and <4 x i8> %x.shift, %y.shift.not
ret <4 x i8> %and
}
define <4 x i8> @and_ashr_not_vec_undef_2(<4 x i8> %x, <4 x i8> %y, <4 x i8> %shamt) {
; CHECK-LABEL: @and_ashr_not_vec_undef_2(
; CHECK-NEXT: ret <4 x i8> zeroinitializer
;
%x.shift = ashr <4 x i8> %x, %shamt
%y.shift = ashr <4 x i8> %y, %shamt
%y.shift.not = xor <4 x i8> %y.shift, <i8 undef, i8 undef, i8 undef, i8 undef>
%and = and <4 x i8> %x.shift, %y.shift.not
ret <4 x i8> %and
}
; Fold (-x >> y) | ((x >> y) ^ -1) -> (-x | ~x) >> y
define i8 @or_ashr_not(i8 %x, i8 %y, i8 %shamt) {
; CHECK-LABEL: @or_ashr_not(
; CHECK-NEXT: [[X_SHIFT:%.*]] = ashr i8 [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = ashr i8 [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor i8 [[Y_SHIFT]], -1
; CHECK-NEXT: [[OR:%.*]] = or i8 [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret i8 [[OR]]
;
%x.shift = ashr i8 %x, %shamt
%y.shift = ashr i8 %y, %shamt
%y.shift.not = xor i8 %y.shift, -1
%or = or i8 %x.shift, %y.shift.not
ret i8 %or
}
define i8 @or_ashr_not_commuted(i8 %x, i8 %y, i8 %shamt) {
; CHECK-LABEL: @or_ashr_not_commuted(
; CHECK-NEXT: [[X_SHIFT:%.*]] = ashr i8 [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = ashr i8 [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor i8 [[Y_SHIFT]], -1
; CHECK-NEXT: [[OR:%.*]] = or i8 [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret i8 [[OR]]
;
%x.shift = ashr i8 %x, %shamt
%y.shift = ashr i8 %y, %shamt
%y.shift.not = xor i8 %y.shift, -1
%or = or i8 %y.shift.not, %x.shift
ret i8 %or
}
; Negative test: lshr instead of ashr
define i8 @or_ashr_not_fail_lshr_ashr(i8 %x, i8 %y, i8 %shamt) {
; CHECK-LABEL: @or_ashr_not_fail_lshr_ashr(
; CHECK-NEXT: [[X_SHIFT:%.*]] = lshr i8 [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = ashr i8 [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor i8 [[Y_SHIFT]], -1
; CHECK-NEXT: [[OR:%.*]] = or i8 [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret i8 [[OR]]
;
%x.shift = lshr i8 %x, %shamt
%y.shift = ashr i8 %y, %shamt
%y.shift.not = xor i8 %y.shift, -1
%or = or i8 %x.shift, %y.shift.not
ret i8 %or
}
; Negative test: lshr instead of ashr
define i8 @or_ashr_not_fail_ashr_lshr(i8 %x, i8 %y, i8 %shamt) {
; CHECK-LABEL: @or_ashr_not_fail_ashr_lshr(
; CHECK-NEXT: [[X_SHIFT:%.*]] = ashr i8 [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = lshr i8 [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor i8 [[Y_SHIFT]], -1
; CHECK-NEXT: [[OR:%.*]] = or i8 [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret i8 [[OR]]
;
%x.shift = ashr i8 %x, %shamt
%y.shift = lshr i8 %y, %shamt
%y.shift.not = xor i8 %y.shift, -1
%or = or i8 %x.shift, %y.shift.not
ret i8 %or
}
; Negative test: invalid xor constant
define i8 @or_ashr_not_fail_invalid_xor_constant(i8 %x, i8 %y, i8 %shamt) {
; CHECK-LABEL: @or_ashr_not_fail_invalid_xor_constant(
; CHECK-NEXT: [[X_SHIFT:%.*]] = ashr i8 [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = ashr i8 [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor i8 [[Y_SHIFT]], -2
; CHECK-NEXT: [[OR:%.*]] = or i8 [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret i8 [[OR]]
;
%x.shift = ashr i8 %x, %shamt
%y.shift = ashr i8 %y, %shamt
%y.shift.not = xor i8 %y.shift, -2
%or = or i8 %x.shift, %y.shift.not
ret i8 %or
}
define <4 x i8> @or_ashr_not_vec(<4 x i8> %x, <4 x i8> %y, <4 x i8> %shamt) {
; CHECK-LABEL: @or_ashr_not_vec(
; CHECK-NEXT: [[X_SHIFT:%.*]] = ashr <4 x i8> [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = ashr <4 x i8> [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor <4 x i8> [[Y_SHIFT]], <i8 -1, i8 -1, i8 -1, i8 -1>
; CHECK-NEXT: [[OR:%.*]] = or <4 x i8> [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret <4 x i8> [[OR]]
;
%x.shift = ashr <4 x i8> %x, %shamt
%y.shift = ashr <4 x i8> %y, %shamt
%y.shift.not = xor <4 x i8> %y.shift, <i8 -1, i8 -1, i8 -1, i8 -1>
%or = or <4 x i8> %x.shift, %y.shift.not
ret <4 x i8> %or
}
define <4 x i8> @or_ashr_not_vec_commuted(<4 x i8> %x, <4 x i8> %y, <4 x i8> %shamt) {
; CHECK-LABEL: @or_ashr_not_vec_commuted(
; CHECK-NEXT: [[X_SHIFT:%.*]] = ashr <4 x i8> [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = ashr <4 x i8> [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor <4 x i8> [[Y_SHIFT]], <i8 -1, i8 -1, i8 -1, i8 -1>
; CHECK-NEXT: [[OR:%.*]] = or <4 x i8> [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret <4 x i8> [[OR]]
;
%x.shift = ashr <4 x i8> %x, %shamt
%y.shift = ashr <4 x i8> %y, %shamt
%y.shift.not = xor <4 x i8> %y.shift, <i8 -1, i8 -1, i8 -1, i8 -1>
%or = or <4 x i8> %y.shift.not, %x.shift
ret <4 x i8> %or
}
define <4 x i8> @or_ashr_not_vec_undef_1(<4 x i8> %x, <4 x i8> %y, <4 x i8> %shamt) {
; CHECK-LABEL: @or_ashr_not_vec_undef_1(
; CHECK-NEXT: [[X_SHIFT:%.*]] = ashr <4 x i8> [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = ashr <4 x i8> [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor <4 x i8> [[Y_SHIFT]], <i8 -1, i8 undef, i8 undef, i8 undef>
; CHECK-NEXT: [[OR:%.*]] = or <4 x i8> [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret <4 x i8> [[OR]]
;
%x.shift = ashr <4 x i8> %x, %shamt
%y.shift = ashr <4 x i8> %y, %shamt
%y.shift.not = xor <4 x i8> %y.shift, <i8 -1, i8 undef, i8 undef, i8 undef>
%or = or <4 x i8> %x.shift, %y.shift.not
ret <4 x i8> %or
}
define <4 x i8> @or_ashr_not_vec_undef_2(<4 x i8> %x, <4 x i8> %y, <4 x i8> %shamt) {
; CHECK-LABEL: @or_ashr_not_vec_undef_2(
; CHECK-NEXT: ret <4 x i8> <i8 -1, i8 -1, i8 -1, i8 -1>
;
%x.shift = ashr <4 x i8> %x, %shamt
%y.shift = ashr <4 x i8> %y, %shamt
%y.shift.not = xor <4 x i8> %y.shift, <i8 undef, i8 undef, i8 undef, i8 undef>
%or = or <4 x i8> %x.shift, %y.shift.not
ret <4 x i8> %or
}
; Fold (-x >> y) ^ ((x >> y) ^ -1) -> (-x ^ ~x) >> y
define i8 @xor_ashr_not(i8 %x, i8 %y, i8 %shamt) {
; CHECK-LABEL: @xor_ashr_not(
; CHECK-NEXT: [[Y_SHIFT1:%.*]] = xor i8 [[Y:%.*]], [[X:%.*]]
; CHECK-NEXT: [[TMP1:%.*]] = ashr i8 [[Y_SHIFT1]], [[SHAMT:%.*]]
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[TMP1]], -1
; CHECK-NEXT: ret i8 [[XOR]]
;
%x.shift = ashr i8 %x, %shamt
%y.shift = ashr i8 %y, %shamt
%y.shift.not = xor i8 %y.shift, -1
%xor = xor i8 %x.shift, %y.shift.not
ret i8 %xor
}
define i8 @xor_ashr_not_commuted(i8 %x, i8 %y, i8 %shamt) {
; CHECK-LABEL: @xor_ashr_not_commuted(
; CHECK-NEXT: [[Y_SHIFT1:%.*]] = xor i8 [[Y:%.*]], [[X:%.*]]
; CHECK-NEXT: [[TMP1:%.*]] = ashr i8 [[Y_SHIFT1]], [[SHAMT:%.*]]
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[TMP1]], -1
; CHECK-NEXT: ret i8 [[XOR]]
;
%x.shift = ashr i8 %x, %shamt
%y.shift = ashr i8 %y, %shamt
%y.shift.not = xor i8 %y.shift, -1
%xor = xor i8 %y.shift.not, %x.shift
ret i8 %xor
}
; Negative test: lshr instead of ashr
define i8 @xor_ashr_not_fail_lshr_ashr(i8 %x, i8 %y, i8 %shamt) {
; CHECK-LABEL: @xor_ashr_not_fail_lshr_ashr(
; CHECK-NEXT: [[X_SHIFT:%.*]] = lshr i8 [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = ashr i8 [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[TMP1:%.*]] = xor i8 [[Y_SHIFT]], [[X_SHIFT]]
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[TMP1]], -1
; CHECK-NEXT: ret i8 [[XOR]]
;
%x.shift = lshr i8 %x, %shamt
%y.shift = ashr i8 %y, %shamt
%y.shift.not = xor i8 %y.shift, -1
%xor = xor i8 %x.shift, %y.shift.not
ret i8 %xor
}
; Negative test: lshr instead of ashr
define i8 @xor_ashr_not_fail_ashr_lshr(i8 %x, i8 %y, i8 %shamt) {
; CHECK-LABEL: @xor_ashr_not_fail_ashr_lshr(
; CHECK-NEXT: [[X_SHIFT:%.*]] = ashr i8 [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = lshr i8 [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[TMP1:%.*]] = xor i8 [[Y_SHIFT]], [[X_SHIFT]]
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[TMP1]], -1
; CHECK-NEXT: ret i8 [[XOR]]
;
%x.shift = ashr i8 %x, %shamt
%y.shift = lshr i8 %y, %shamt
%y.shift.not = xor i8 %y.shift, -1
%xor = xor i8 %x.shift, %y.shift.not
ret i8 %xor
}
; Negative test: invalid xor constant
define i8 @xor_ashr_not_fail_invalid_xor_constant(i8 %x, i8 %y, i8 %shamt) {
; CHECK-LABEL: @xor_ashr_not_fail_invalid_xor_constant(
; CHECK-NEXT: [[Y_SHIFT1:%.*]] = xor i8 [[Y:%.*]], [[X:%.*]]
; CHECK-NEXT: [[TMP1:%.*]] = ashr i8 [[Y_SHIFT1]], [[SHAMT:%.*]]
; CHECK-NEXT: [[XOR:%.*]] = xor i8 [[TMP1]], -2
; CHECK-NEXT: ret 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.
;
%x.shift = ashr i8 %x, %shamt
%y.shift = ashr i8 %y, %shamt
%y.shift.not = xor i8 %y.shift, -2
%xor = xor i8 %x.shift, %y.shift.not
ret i8 %xor
}
define <4 x i8> @xor_ashr_not_vec(<4 x i8> %x, <4 x i8> %y, <4 x i8> %shamt) {
; CHECK-LABEL: @xor_ashr_not_vec(
; CHECK-NEXT: [[Y_SHIFT1:%.*]] = xor <4 x i8> [[Y:%.*]], [[X:%.*]]
; CHECK-NEXT: [[TMP1:%.*]] = ashr <4 x i8> [[Y_SHIFT1]], [[SHAMT:%.*]]
; CHECK-NEXT: [[XOR:%.*]] = xor <4 x i8> [[TMP1]], <i8 -1, i8 -1, i8 -1, i8 -1>
; CHECK-NEXT: ret <4 x i8> [[XOR]]
;
%x.shift = ashr <4 x i8> %x, %shamt
%y.shift = ashr <4 x i8> %y, %shamt
%y.shift.not = xor <4 x i8> %y.shift, <i8 -1, i8 -1, i8 -1, i8 -1>
%xor = xor <4 x i8> %x.shift, %y.shift.not
ret <4 x i8> %xor
}
define <4 x i8> @xor_ashr_not_vec_commuted(<4 x i8> %x, <4 x i8> %y, <4 x i8> %shamt) {
; CHECK-LABEL: @xor_ashr_not_vec_commuted(
; CHECK-NEXT: [[Y_SHIFT1:%.*]] = xor <4 x i8> [[Y:%.*]], [[X:%.*]]
; CHECK-NEXT: [[TMP1:%.*]] = ashr <4 x i8> [[Y_SHIFT1]], [[SHAMT:%.*]]
; CHECK-NEXT: [[XOR:%.*]] = xor <4 x i8> [[TMP1]], <i8 -1, i8 -1, i8 -1, i8 -1>
; CHECK-NEXT: ret <4 x i8> [[XOR]]
;
%x.shift = ashr <4 x i8> %x, %shamt
%y.shift = ashr <4 x i8> %y, %shamt
%y.shift.not = xor <4 x i8> %y.shift, <i8 -1, i8 -1, i8 -1, i8 -1>
%xor = xor <4 x i8> %y.shift.not, %x.shift
ret <4 x i8> %xor
}
define <4 x i8> @xor_ashr_not_vec_undef_1(<4 x i8> %x, <4 x i8> %y, <4 x i8> %shamt) {
; CHECK-LABEL: @xor_ashr_not_vec_undef_1(
; CHECK-NEXT: [[Y_SHIFT1:%.*]] = xor <4 x i8> [[Y:%.*]], [[X:%.*]]
; CHECK-NEXT: [[TMP1:%.*]] = ashr <4 x i8> [[Y_SHIFT1]], [[SHAMT:%.*]]
; CHECK-NEXT: [[XOR:%.*]] = xor <4 x i8> [[TMP1]], <i8 -1, i8 undef, i8 undef, i8 undef>
; CHECK-NEXT: ret <4 x i8> [[XOR]]
;
%x.shift = ashr <4 x i8> %x, %shamt
%y.shift = ashr <4 x i8> %y, %shamt
%y.shift.not = xor <4 x i8> %y.shift, <i8 -1, i8 undef, i8 undef, i8 undef>
%xor = xor <4 x i8> %x.shift, %y.shift.not
ret <4 x i8> %xor
}
define <4 x i8> @xor_ashr_not_vec_undef_2(<4 x i8> %x, <4 x i8> %y, <4 x i8> %shamt) {
; CHECK-LABEL: @xor_ashr_not_vec_undef_2(
; CHECK-NEXT: ret <4 x i8> undef
;
%x.shift = ashr <4 x i8> %x, %shamt
%y.shift = ashr <4 x i8> %y, %shamt
%y.shift.not = xor <4 x i8> %y.shift, <i8 undef, i8 undef, i8 undef, i8 undef>
%xor = xor <4 x i8> %x.shift, %y.shift.not
ret <4 x i8> %xor
}
; Negative test: invalid binop
define i8 @binop_ashr_not_fail_invalid_binop(i8 %x, i8 %y, i8 %shamt) {
; CHECK-LABEL: @binop_ashr_not_fail_invalid_binop(
; CHECK-NEXT: [[X_SHIFT:%.*]] = ashr i8 [[X:%.*]], [[SHAMT:%.*]]
; CHECK-NEXT: [[Y_SHIFT:%.*]] = ashr i8 [[Y:%.*]], [[SHAMT]]
; CHECK-NEXT: [[Y_SHIFT_NOT:%.*]] = xor i8 [[Y_SHIFT]], -1
; CHECK-NEXT: [[ADD:%.*]] = add i8 [[X_SHIFT]], [[Y_SHIFT_NOT]]
; CHECK-NEXT: ret i8 [[ADD]]
;
%x.shift = ashr i8 %x, %shamt
%y.shift = ashr i8 %y, %shamt
%y.shift.not = xor i8 %y.shift, -1
%add = add i8 %x.shift, %y.shift.not
ret i8 %add
}