[llvm] [InstCombine] Fold `(select C, (x bin_op a), x) bin_op b` into `x bin_op select C, (a bin_op b), b` (PR #173511)
via llvm-commits
llvm-commits at lists.llvm.org
Wed Dec 24 14:06:56 PST 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-pgo
Author: Gábor Spaits (spaits)
<details>
<summary>Changes</summary>
Fixes #<!-- -->154246 .
Another approach than PR #<!-- -->172662 .
@<!-- -->nikic has mentioned in the comments that the approach I took in #<!-- -->172662 may be fragile. There may be cases where the folding may cause infinite loops (like we saw it with `div` and `rem` (for these ops I have fixed that PR too)).
This is another more stable approach. Although it comes with a bit more changes (I would rather say additions). I decided to add a new function for this optimization.
In my previous PR I was thinking about solving the issue in `SimplifyAssociativeOrCommutative`, but after some experimenting I came to the conclusion that it couldn't be done that elegantly as I have planed it.
---
Patch is 36.56 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/173511.diff
7 Files Affected:
- (modified) llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp (+3)
- (modified) llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp (+6)
- (modified) llvm/lib/Transforms/InstCombine/InstCombineInternal.h (+2)
- (modified) llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp (+3)
- (modified) llvm/lib/Transforms/InstCombine/InstructionCombining.cpp (+39)
- (modified) llvm/test/Transforms/InstCombine/binop-select.ll (+759)
- (modified) llvm/test/Transforms/PGOProfile/chr.ll (+12-12)
``````````diff
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp b/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
index 9bee523c7b7e5..95e7cbed60a27 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
@@ -863,6 +863,9 @@ Instruction *InstCombinerImpl::foldAddWithConstant(BinaryOperator &Add) {
if (Instruction *NV = foldBinOpIntoSelectOrPhi(Add))
return NV;
+ if (Instruction *FoldedLogic = foldSelectIntoBinOp(Add))
+ return FoldedLogic;
+
Value *X;
Constant *Op00C;
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp b/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
index 9cf382f8020fa..5978e39ebb2b6 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
@@ -4077,6 +4077,9 @@ Instruction *InstCombinerImpl::visitOr(BinaryOperator &I) {
if (Instruction *FoldedLogic = foldBinOpIntoSelectOrPhi(I))
return FoldedLogic;
+ if (Instruction *FoldedLogic = foldSelectIntoBinOp(I))
+ return FoldedLogic;
+
if (Instruction *BitOp = matchBSwapOrBitReverse(I, /*MatchBSwaps*/ true,
/*MatchBitReversals*/ true))
return BitOp;
@@ -5383,6 +5386,9 @@ Instruction *InstCombinerImpl::visitXor(BinaryOperator &I) {
if (Instruction *FoldedLogic = foldBinOpIntoSelectOrPhi(I))
return FoldedLogic;
+ if (Instruction *FoldedLogic = foldSelectIntoBinOp(I))
+ return FoldedLogic;
+
// Y ^ (X | Y) --> X & ~Y
// Y ^ (Y | X) --> X & ~Y
if (match(Op1, m_OneUse(m_c_Or(m_Value(X), m_Specific(Op0)))))
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineInternal.h b/llvm/lib/Transforms/InstCombine/InstCombineInternal.h
index 9bdd8cb71f7f3..2bfb632c37a63 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineInternal.h
+++ b/llvm/lib/Transforms/InstCombine/InstCombineInternal.h
@@ -667,6 +667,8 @@ class LLVM_LIBRARY_VISIBILITY InstCombinerImpl final
bool FoldWithMultiUse = false,
bool SimplifyBothArms = false);
+ Instruction *foldSelectIntoBinOp(BinaryOperator &Op);
+
/// This is a convenience wrapper function for the above two functions.
Instruction *foldBinOpIntoSelectOrPhi(BinaryOperator &I);
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp b/llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
index a9aacc707cc20..303557520ee23 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
@@ -317,6 +317,9 @@ Instruction *InstCombinerImpl::visitMul(BinaryOperator &I) {
if (Instruction *FoldedMul = foldBinOpIntoSelectOrPhi(I))
return FoldedMul;
+ if (Instruction *FoldedLogic = foldSelectIntoBinOp(I))
+ return FoldedLogic;
+
if (Value *FoldedMul = foldMulSelectToNegate(I, Builder))
return replaceInstUsesWith(I, FoldedMul);
diff --git a/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp b/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
index 14244236d75d5..df32ef7fd8450 100644
--- a/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
@@ -1876,6 +1876,45 @@ static Value *simplifyInstructionWithPHI(Instruction &I, PHINode *PN,
return nullptr;
}
+// In some cases it is beneficial to fold a select into a binary operator.
+// For example:
+// %1 = or %in, 4
+// %2 = select %cond, %1, %in
+// %3 = or %2, 1
+// =>
+// %1 = select i1 %cond, 5, 1
+// %2 = or %1, %in
+Instruction *InstCombinerImpl::foldSelectIntoBinOp(BinaryOperator &Op) {
+ SelectInst *SI = dyn_cast<SelectInst>(Op.getOperand(0));
+ ConstantInt *Const = dyn_cast<ConstantInt>(Op.getOperand(1));
+ if (!SI || !Const || !Op.hasOneUse() || !SI->hasOneUse())
+ return nullptr;
+
+ // TODO: Maybe hasOneUse the other bin op too?
+
+ Value *Input, *NewTV, *NewFV, *Cond;
+ ConstantInt *Const2;
+ if (match(SI, m_Select(m_Value(Cond),
+ m_c_BinOp(Op.getOpcode(), m_Value(Input),
+ m_ConstantInt(Const2)),
+ m_Deferred(Input)))) {
+ NewTV = simplifyBinOp(Op.getOpcode(), Const, Const2,
+ SQ.getWithInstruction(&Op));
+ NewFV = Const;
+ } else if (match(SI, m_Select(m_Value(Cond), m_Value(Input),
+ m_c_BinOp(Op.getOpcode(), m_Deferred(Input),
+ m_ConstantInt(Const2))))) {
+ NewTV = Const;
+ NewFV = simplifyBinOp(Op.getOpcode(), Const, Const2,
+ SQ.getWithInstruction(&Op));
+ } else
+ return nullptr;
+
+ SelectInst *NewSI = SelectInst::Create(Cond, NewTV, NewFV);
+ InsertNewInstBefore(NewSI, Op.getIterator());
+ return BinaryOperator::Create(Op.getOpcode(), NewSI, Input);
+}
+
Instruction *InstCombinerImpl::foldOpIntoPhi(Instruction &I, PHINode *PN,
bool AllowMultipleUses) {
unsigned NumPHIValues = PN->getNumIncomingValues();
diff --git a/llvm/test/Transforms/InstCombine/binop-select.ll b/llvm/test/Transforms/InstCombine/binop-select.ll
index 9e336ad104599..c5da60c316c50 100644
--- a/llvm/test/Transforms/InstCombine/binop-select.ll
+++ b/llvm/test/Transforms/InstCombine/binop-select.ll
@@ -571,3 +571,762 @@ define i32 @OrSelectIcmpNonZero(i32 %a, i32 %b) {
%or = or i32 %sel, %a
ret i32 %or
}
+
+define i8 @BinOpSelectBinOpMultiUseRegsWithSelect1(i8 %arg0, i8 %arg1, i1 %whatToReturn) {
+; CHECK-LABEL: @BinOpSelectBinOpMultiUseRegsWithSelect1(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[V1:%.*]] = or i8 [[ARG0:%.*]], 4
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 5, i8 1
+; CHECK-NEXT: [[V3:%.*]] = or i8 [[TMP1]], [[ARG0]]
+; CHECK-NEXT: [[USE:%.*]] = add i8 [[V1]], 42
+; CHECK-NEXT: [[RETVAL:%.*]] = select i1 [[WHATTORETURN:%.*]], i8 [[USE]], i8 [[V3]]
+; CHECK-NEXT: ret i8 [[RETVAL]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = or i8 4, %arg0
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = or i8 1, %v2
+ %use = add i8 %v1, 42
+ %retVal = select i1 %whatToReturn, i8 %use, i8 %v3
+ ret i8 %retVal
+}
+
+
+define i8 @BinOpSelectBinOpMultiUseRegsWithSelect2(i8 %arg0, i8 %arg1, i1 %whatToReturn) {
+; CHECK-LABEL: @BinOpSelectBinOpMultiUseRegsWithSelect2(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[V1:%.*]] = or i8 [[ARG0:%.*]], 4
+; CHECK-NEXT: [[V2:%.*]] = select i1 [[V0]], i8 [[V1]], i8 [[ARG0]]
+; CHECK-NEXT: [[V3:%.*]] = or i8 [[V2]], 1
+; CHECK-NEXT: [[USE:%.*]] = add i8 [[V2]], 42
+; CHECK-NEXT: [[RETVAL:%.*]] = select i1 [[WHATTORETURN:%.*]], i8 [[USE]], i8 [[V3]]
+; CHECK-NEXT: ret i8 [[RETVAL]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = or i8 4, %arg0
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = or i8 1, %v2
+ %use = add i8 %v2, 42
+ %retVal = select i1 %whatToReturn, i8 %use, i8 %v3
+ ret i8 %retVal
+}
+
+define i8 @BinOpSelectBinOpMultiUseRegsWithSelect3(i8 %arg0, i8 %arg1, i1 %whatToReturn) {
+; CHECK-LABEL: @BinOpSelectBinOpMultiUseRegsWithSelect3(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 5, i8 1
+; CHECK-NEXT: [[RETVAL_V:%.*]] = select i1 [[WHATTORETURN:%.*]], i8 4, i8 [[TMP1]]
+; CHECK-NEXT: [[RETVAL:%.*]] = or i8 [[ARG0:%.*]], [[RETVAL_V]]
+; CHECK-NEXT: ret i8 [[RETVAL]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = or i8 4, %arg0
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = or i8 1, %v2
+ %retVal = select i1 %whatToReturn, i8 %v1, i8 %v3
+ ret i8 %retVal
+}
+
+define i8 @BinOpSelectBinOpMultiUseRegsWithSelect4(i8 %arg0, i8 %arg1, i1 %whatToReturn) {
+; CHECK-LABEL: @BinOpSelectBinOpMultiUseRegsWithSelect4(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[V1:%.*]] = or i8 [[ARG0:%.*]], 4
+; CHECK-NEXT: [[V2:%.*]] = select i1 [[V0]], i8 [[V1]], i8 [[ARG0]]
+; CHECK-NEXT: [[NOT_WHATTORETURN:%.*]] = xor i1 [[WHATTORETURN:%.*]], true
+; CHECK-NEXT: [[V3:%.*]] = zext i1 [[NOT_WHATTORETURN]] to i8
+; CHECK-NEXT: [[RETVAL:%.*]] = or i8 [[V2]], [[V3]]
+; CHECK-NEXT: ret i8 [[RETVAL]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = or i8 4, %arg0
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = or i8 1, %v2
+ %retVal = select i1 %whatToReturn, i8 %v2, i8 %v3
+ ret i8 %retVal
+}
+
+; or tests
+define i8 @orSelectOrNoCommonBits1(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @orSelectOrNoCommonBits1(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 5, i8 1
+; CHECK-NEXT: [[V3:%.*]] = or i8 [[TMP1]], [[ARG0:%.*]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = or i8 %arg0, 4
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = or i8 %v2, 1
+ ret i8 %v3
+}
+
+define i8 @orSelectOrNoCommonBits2(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @orSelectOrNoCommonBits2(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[V1:%.*]] = zext i1 [[V0]] to i8
+; CHECK-NEXT: [[V2:%.*]] = or i8 [[ARG0:%.*]], [[V1]]
+; CHECK-NEXT: [[V3:%.*]] = or i8 [[V2]], 4
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = or i8 %arg0, 1
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = or i8 %v2, 4
+ ret i8 %v3
+}
+
+define i8 @orSelectOrReserved(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @orSelectOrReserved(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 13, i8 15
+; CHECK-NEXT: [[V3:%.*]] = or i8 [[TMP1]], [[ARG0:%.*]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = or i8 %arg0, 11
+ %v2 = select i1 %v0, i8 %arg0, i8 %v1
+ %v3 = or i8 %v2, 13
+ ret i8 %v3
+}
+
+define i8 @orSelectOrSubset1(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @orSelectOrSubset1(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 15, i8 13
+; CHECK-NEXT: [[V3:%.*]] = or i8 [[TMP1]], [[ARG0:%.*]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = or i8 %arg0, 11
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = or i8 %v2, 13
+ ret i8 %v3
+}
+
+define i8 @orSelectOrSubset2(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @orSelectOrSubset2(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 15, i8 11
+; CHECK-NEXT: [[V3:%.*]] = or i8 [[TMP1]], [[ARG0:%.*]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = or i8 %arg0, 13
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = or i8 %v2, 11
+ ret i8 %v3
+}
+
+define i8 @orSelectOrSomeCommon1(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @orSelectOrSomeCommon1(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 15, i8 5
+; CHECK-NEXT: [[V3:%.*]] = or i8 [[TMP1]], [[ARG0:%.*]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = or i8 %arg0, 11
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = or i8 %v2, 5
+ ret i8 %v3
+}
+
+define i8 @orSelectOrSomeCommon2(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @orSelectOrSomeCommon2(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 15, i8 11
+; CHECK-NEXT: [[V3:%.*]] = or i8 [[TMP1]], [[ARG0:%.*]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = or i8 %arg0, 5
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = or i8 %v2, 11
+ ret i8 %v3
+}
+
+define i8 @orSelectOrSame(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @orSelectOrSame(
+; CHECK-NEXT: [[V1:%.*]] = or i8 [[ARG0:%.*]], 42
+; CHECK-NEXT: ret i8 [[V1]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = or i8 %arg0, 42
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = or i8 %v2, 42
+ ret i8 %v3
+}
+
+; and tests
+define i8 @andSelectandNoCommonBits1(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @andSelectandNoCommonBits1(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = and i8 [[ARG0:%.*]], 1
+; CHECK-NEXT: [[V3:%.*]] = select i1 [[V0]], i8 0, i8 [[TMP1]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = and i8 %arg0, 4
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = and i8 %v2, 1
+ ret i8 %v3
+}
+
+define i8 @andSelectandNoCommonBits2(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @andSelectandNoCommonBits2(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[V3:%.*]] = and i8 [[V2:%.*]], 4
+; CHECK-NEXT: [[V4:%.*]] = select i1 [[V0]], i8 0, i8 [[V3]]
+; CHECK-NEXT: ret i8 [[V4]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = and i8 %arg0, 1
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = and i8 %v2, 4
+ ret i8 %v3
+}
+
+define i8 @andSelectandSubset1(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @andSelectandSubset1(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[V3_V:%.*]] = select i1 [[V0]], i8 9, i8 13
+; CHECK-NEXT: [[V3:%.*]] = and i8 [[ARG0:%.*]], [[V3_V]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = and i8 %arg0, 11
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = and i8 %v2, 13
+ ret i8 %v3
+}
+
+define i8 @andSelectandSubset2(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @andSelectandSubset2(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[V3_V:%.*]] = select i1 [[V0]], i8 9, i8 11
+; CHECK-NEXT: [[V3:%.*]] = and i8 [[ARG0:%.*]], [[V3_V]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = and i8 %arg0, 13
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = and i8 %v2, 11
+ ret i8 %v3
+}
+
+define i8 @andSelectandSomeCommon1(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @andSelectandSomeCommon1(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[V3_V:%.*]] = select i1 [[V0]], i8 1, i8 5
+; CHECK-NEXT: [[V3:%.*]] = and i8 [[ARG0:%.*]], [[V3_V]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = and i8 %arg0, 11
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = and i8 %v2, 5
+ ret i8 %v3
+}
+
+define i8 @andSelectandSomeCommon2(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @andSelectandSomeCommon2(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[V3_V:%.*]] = select i1 [[V0]], i8 1, i8 11
+; CHECK-NEXT: [[V3:%.*]] = and i8 [[ARG0:%.*]], [[V3_V]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = and i8 %arg0, 5
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = and i8 %v2, 11
+ ret i8 %v3
+}
+
+define i8 @andSelectandSame(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @andSelectandSame(
+; CHECK-NEXT: [[V1:%.*]] = and i8 [[ARG0:%.*]], 42
+; CHECK-NEXT: ret i8 [[V1]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = and i8 %arg0, 42
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = and i8 %v2, 42
+ ret i8 %v3
+}
+
+; xor tests
+define i8 @xorSelectxorNoCommonBits1(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @xorSelectxorNoCommonBits1(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 5, i8 1
+; CHECK-NEXT: [[V3:%.*]] = xor i8 [[TMP1]], [[ARG0:%.*]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = xor i8 %arg0, 4
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = xor i8 %v2, 1
+ ret i8 %v3
+}
+
+define i8 @xorSelectxorNoCommonBits2(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @xorSelectxorNoCommonBits2(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[V1:%.*]] = zext i1 [[V0]] to i8
+; CHECK-NEXT: [[V2:%.*]] = xor i8 [[ARG0:%.*]], [[V1]]
+; CHECK-NEXT: [[V3:%.*]] = xor i8 [[V2]], 4
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = xor i8 %arg0, 1
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = xor i8 %v2, 4
+ ret i8 %v3
+}
+
+define i8 @xorSelectxorSubset1(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @xorSelectxorSubset1(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 6, i8 13
+; CHECK-NEXT: [[V3:%.*]] = xor i8 [[TMP1]], [[ARG0:%.*]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = xor i8 %arg0, 11
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = xor i8 %v2, 13
+ ret i8 %v3
+}
+
+define i8 @xorSelectxorSubset2(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @xorSelectxorSubset2(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 6, i8 11
+; CHECK-NEXT: [[V3:%.*]] = xor i8 [[TMP1]], [[ARG0:%.*]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = xor i8 %arg0, 13
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = xor i8 %v2, 11
+ ret i8 %v3
+}
+
+define i8 @xorSelectxorSomeCommon1(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @xorSelectxorSomeCommon1(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 14, i8 5
+; CHECK-NEXT: [[V3:%.*]] = xor i8 [[TMP1]], [[ARG0:%.*]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = xor i8 %arg0, 11
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = xor i8 %v2, 5
+ ret i8 %v3
+}
+
+define i8 @xorSelectxorSomeCommon2(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @xorSelectxorSomeCommon2(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 14, i8 11
+; CHECK-NEXT: [[V3:%.*]] = xor i8 [[TMP1]], [[ARG0:%.*]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = xor i8 %arg0, 5
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = xor i8 %v2, 11
+ ret i8 %v3
+}
+
+define i8 @xorSelectxorSame(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @xorSelectxorSame(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[V1:%.*]] = xor i8 [[ARG0:%.*]], 42
+; CHECK-NEXT: [[V3:%.*]] = select i1 [[V0]], i8 [[ARG0]], i8 [[V1]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = xor i8 %arg0, 42
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = xor i8 %v2, 42
+ ret i8 %v3
+}
+
+; add tests
+define i8 @addSelectaddNoCommonBits1(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @addSelectaddNoCommonBits1(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 5, i8 1
+; CHECK-NEXT: [[V3:%.*]] = add i8 [[TMP1]], [[ARG0:%.*]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = add i8 %arg0, 4
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = add i8 %v2, 1
+ ret i8 %v3
+}
+
+define i8 @addSelectaddNoCommonBits2(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @addSelectaddNoCommonBits2(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[V1:%.*]] = zext i1 [[V0]] to i8
+; CHECK-NEXT: [[V2:%.*]] = add i8 [[ARG0:%.*]], [[V1]]
+; CHECK-NEXT: [[V3:%.*]] = add i8 [[V2]], 4
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = add i8 %arg0, 1
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = add i8 %v2, 4
+ ret i8 %v3
+}
+
+define i8 @addSelectaddSubset1(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @addSelectaddSubset1(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 24, i8 13
+; CHECK-NEXT: [[V3:%.*]] = add i8 [[TMP1]], [[ARG0:%.*]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = add i8 %arg0, 11
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = add i8 %v2, 13
+ ret i8 %v3
+}
+
+define i8 @addSelectaddSubset2(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @addSelectaddSubset2(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 24, i8 11
+; CHECK-NEXT: [[V3:%.*]] = add i8 [[TMP1]], [[ARG0:%.*]]
+; CHECK-NEXT: ret i8 [[V3]]
+;
+ %v0 = icmp eq i8 %arg1, -1
+ %v1 = add i8 %arg0, 13
+ %v2 = select i1 %v0, i8 %v1, i8 %arg0
+ %v3 = add i8 %v2, 11
+ ret i8 %v3
+}
+
+define i8 @addSelectaddSomeCommon1(i8 %arg0, i8 %arg1) {
+; CHECK-LABEL: @addSelectaddSomeCommon1(
+; CHECK-NEXT: [[V0:%.*]] = icmp eq i8 [[ARG1:%.*]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = select i1 [[V0]], i8 16, i8 5
+; CHECK-NEXT: [[V3:%.*]] = add i8 [[TMP1]], [[ARG0:%.*]]
+;...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/173511
More information about the llvm-commits
mailing list