[llvm] [InstCombine] [X86] pblendvb intrinsics must be replaced by select when possible (PR #137322)
via llvm-commits
llvm-commits at lists.llvm.org
Fri Apr 25 05:46:40 PDT 2025
github-actions[bot] wrote:
<!--LLVM CODE FORMAT COMMENT: {clang-format}-->
:warning: C/C++ code formatter, clang-format found issues in your code. :warning:
<details>
<summary>
You can test this locally with the following command:
</summary>
``````````bash
git-clang-format --diff HEAD~1 HEAD --extensions cpp -- llvm/lib/Target/X86/X86InstCombineIntrinsic.cpp
``````````
</details>
<details>
<summary>
View the diff from clang-format here.
</summary>
``````````diff
diff --git a/llvm/lib/Target/X86/X86InstCombineIntrinsic.cpp b/llvm/lib/Target/X86/X86InstCombineIntrinsic.cpp
index 0eb7c43f8..7b67786c7 100644
--- a/llvm/lib/Target/X86/X86InstCombineIntrinsic.cpp
+++ b/llvm/lib/Target/X86/X86InstCombineIntrinsic.cpp
@@ -56,22 +56,22 @@ static Value *getBoolVecFromMask(Value *Mask, const DataLayout &DL) {
static Value *tryDecomposeVectorLogicMask(Value *Mask, IRBuilderBase &Builder) {
// Look through bitcasts
Mask = InstCombiner::peekThroughBitcast(Mask);
-
+
// Direct sign-extension case (should be caught by the main code path)
Value *InnerVal;
if (match(Mask, m_SExt(m_Value(InnerVal))) &&
InnerVal->getType()->isVectorTy() &&
InnerVal->getType()->getScalarType()->isIntegerTy(1))
return InnerVal;
-
+
// Handle AND of sign-extended vectors: (sext A) & (sext B) -> sext(A & B)
Value *LHS, *RHS;
Value *LHSInner, *RHSInner;
if (match(Mask, m_And(m_Value(LHS), m_Value(RHS)))) {
LHS = InstCombiner::peekThroughBitcast(LHS);
RHS = InstCombiner::peekThroughBitcast(RHS);
-
- if (match(LHS, m_SExt(m_Value(LHSInner))) &&
+
+ if (match(LHS, m_SExt(m_Value(LHSInner))) &&
LHSInner->getType()->isVectorTy() &&
LHSInner->getType()->getScalarType()->isIntegerTy(1) &&
match(RHS, m_SExt(m_Value(RHSInner))) &&
@@ -80,21 +80,21 @@ static Value *tryDecomposeVectorLogicMask(Value *Mask, IRBuilderBase &Builder) {
LHSInner->getType() == RHSInner->getType()) {
return Builder.CreateAnd(LHSInner, RHSInner);
}
-
+
// Try recursively on each operand
Value *DecomposedLHS = tryDecomposeVectorLogicMask(LHS, Builder);
Value *DecomposedRHS = tryDecomposeVectorLogicMask(RHS, Builder);
- if (DecomposedLHS && DecomposedRHS &&
+ if (DecomposedLHS && DecomposedRHS &&
DecomposedLHS->getType() == DecomposedRHS->getType())
return Builder.CreateAnd(DecomposedLHS, DecomposedRHS);
}
-
+
// Handle XOR of sign-extended vectors: (sext A) ^ (sext B) -> sext(A ^ B)
if (match(Mask, m_Xor(m_Value(LHS), m_Value(RHS)))) {
LHS = InstCombiner::peekThroughBitcast(LHS);
RHS = InstCombiner::peekThroughBitcast(RHS);
-
- if (match(LHS, m_SExt(m_Value(LHSInner))) &&
+
+ if (match(LHS, m_SExt(m_Value(LHSInner))) &&
LHSInner->getType()->isVectorTy() &&
LHSInner->getType()->getScalarType()->isIntegerTy(1) &&
match(RHS, m_SExt(m_Value(RHSInner))) &&
@@ -103,21 +103,21 @@ static Value *tryDecomposeVectorLogicMask(Value *Mask, IRBuilderBase &Builder) {
LHSInner->getType() == RHSInner->getType()) {
return Builder.CreateXor(LHSInner, RHSInner);
}
-
+
// Try recursively on each operand
Value *DecomposedLHS = tryDecomposeVectorLogicMask(LHS, Builder);
Value *DecomposedRHS = tryDecomposeVectorLogicMask(RHS, Builder);
- if (DecomposedLHS && DecomposedRHS &&
+ if (DecomposedLHS && DecomposedRHS &&
DecomposedLHS->getType() == DecomposedRHS->getType())
return Builder.CreateXor(DecomposedLHS, DecomposedRHS);
}
-
+
// Handle OR of sign-extended vectors: (sext A) | (sext B) -> sext(A | B)
if (match(Mask, m_Or(m_Value(LHS), m_Value(RHS)))) {
LHS = InstCombiner::peekThroughBitcast(LHS);
RHS = InstCombiner::peekThroughBitcast(RHS);
-
- if (match(LHS, m_SExt(m_Value(LHSInner))) &&
+
+ if (match(LHS, m_SExt(m_Value(LHSInner))) &&
LHSInner->getType()->isVectorTy() &&
LHSInner->getType()->getScalarType()->isIntegerTy(1) &&
match(RHS, m_SExt(m_Value(RHSInner))) &&
@@ -126,23 +126,22 @@ static Value *tryDecomposeVectorLogicMask(Value *Mask, IRBuilderBase &Builder) {
LHSInner->getType() == RHSInner->getType()) {
return Builder.CreateOr(LHSInner, RHSInner);
}
-
+
// Try recursively on each operand
Value *DecomposedLHS = tryDecomposeVectorLogicMask(LHS, Builder);
Value *DecomposedRHS = tryDecomposeVectorLogicMask(RHS, Builder);
- if (DecomposedLHS && DecomposedRHS &&
+ if (DecomposedLHS && DecomposedRHS &&
DecomposedLHS->getType() == DecomposedRHS->getType())
return Builder.CreateOr(DecomposedLHS, DecomposedRHS);
}
-
+
// Handle AndNot: (sext A) & ~(sext B) -> sext(A & ~B)
Value *NotOp;
- if (match(Mask, m_And(m_Value(LHS),
- m_Not(m_Value(NotOp))))) {
+ if (match(Mask, m_And(m_Value(LHS), m_Not(m_Value(NotOp))))) {
LHS = InstCombiner::peekThroughBitcast(LHS);
NotOp = InstCombiner::peekThroughBitcast(NotOp);
-
- if (match(LHS, m_SExt(m_Value(LHSInner))) &&
+
+ if (match(LHS, m_SExt(m_Value(LHSInner))) &&
LHSInner->getType()->isVectorTy() &&
LHSInner->getType()->getScalarType()->isIntegerTy(1) &&
match(NotOp, m_SExt(m_Value(RHSInner))) &&
@@ -152,24 +151,21 @@ static Value *tryDecomposeVectorLogicMask(Value *Mask, IRBuilderBase &Builder) {
Value *NotRHSInner = Builder.CreateNot(RHSInner);
return Builder.CreateAnd(LHSInner, NotRHSInner);
}
-
+
// Try recursively on each operand
Value *DecomposedLHS = tryDecomposeVectorLogicMask(LHS, Builder);
Value *DecomposedNotOp = tryDecomposeVectorLogicMask(NotOp, Builder);
- if (DecomposedLHS && DecomposedNotOp &&
+ if (DecomposedLHS && DecomposedNotOp &&
DecomposedLHS->getType() == DecomposedNotOp->getType()) {
Value *NotRHS = Builder.CreateNot(DecomposedNotOp);
return Builder.CreateAnd(DecomposedLHS, NotRHS);
}
}
-
+
// No matching pattern found
return nullptr;
}
-
-
-
// TODO: If the x86 backend knew how to convert a bool vector mask back to an
// XMM register mask efficiently, we could transform all x86 masked intrinsics
// to LLVM masked intrinsics and remove the x86 masked intrinsic defs.
@@ -2268,16 +2264,15 @@ static bool simplifyX86VPERMMask(Instruction *II, bool IsBinary,
return IC.SimplifyDemandedBits(II, /*OpNo=*/1, DemandedMask, KnownMask);
}
-
static Instruction *createMaskSelect(InstCombiner &IC, CallInst &II,
- Value *BoolVec, Value *Op0, Value *Op1,
- Value *MaskSrc = nullptr,
- ArrayRef<int> ShuffleMask = std::nullopt) {
+ Value *BoolVec, Value *Op0, Value *Op1,
+ Value *MaskSrc = nullptr,
+ ArrayRef<int> ShuffleMask = std::nullopt) {
auto *MaskTy = cast<FixedVectorType>(II.getArgOperand(2)->getType());
auto *OpTy = cast<FixedVectorType>(II.getType());
unsigned NumMaskElts = MaskTy->getNumElements();
unsigned NumOperandElts = OpTy->getNumElements();
-
+
// If we peeked through a shuffle, reapply the shuffle to the bool vector.
if (MaskSrc) {
unsigned NumMaskSrcElts =
@@ -2292,15 +2287,14 @@ static Instruction *createMaskSelect(InstCombiner &IC, CallInst &II,
BoolVec = IC.Builder.CreateShuffleVector(BoolVec, ScaledMask);
MaskTy = FixedVectorType::get(MaskTy->getElementType(), NumMaskElts);
}
-
- assert(MaskTy->getPrimitiveSizeInBits() ==
- OpTy->getPrimitiveSizeInBits() &&
+
+ assert(MaskTy->getPrimitiveSizeInBits() == OpTy->getPrimitiveSizeInBits() &&
"Not expecting mask and operands with different sizes");
-
+
if (NumMaskElts == NumOperandElts) {
return SelectInst::Create(BoolVec, Op1, Op0);
}
-
+
// If the mask has less elements than the operands, each mask bit maps to
// multiple elements of the operands. Bitcast back and forth.
if (NumMaskElts < NumOperandElts) {
@@ -2309,11 +2303,10 @@ static Instruction *createMaskSelect(InstCombiner &IC, CallInst &II,
Value *Sel = IC.Builder.CreateSelect(BoolVec, CastOp1, CastOp0);
return new BitCastInst(Sel, II.getType());
}
-
+
return nullptr;
}
-
std::optional<Instruction *>
X86TTIImpl::instCombineIntrinsic(InstCombiner &IC, IntrinsicInst &II) const {
auto SimplifyDemandedVectorEltsLow = [&IC](Value *Op, unsigned Width,
@@ -3078,16 +3071,19 @@ X86TTIImpl::instCombineIntrinsic(InstCombiner &IC, IntrinsicInst &II) const {
if (match(Mask, m_SExt(m_Value(BoolVec))) &&
BoolVec->getType()->isVectorTy() &&
BoolVec->getType()->getScalarSizeInBits() == 1) {
- Instruction *Select = createMaskSelect(IC, II, BoolVec, Op0, Op1, MaskSrc, ShuffleMask);
- if (Select) return Select;
- } else {
- BoolVec = tryDecomposeVectorLogicMask(Mask,IC.Builder);
- if (BoolVec) {
- Instruction *Select = createMaskSelect(IC, II, BoolVec, Op0, Op1, MaskSrc, ShuffleMask);
- if (Select)
- return Select;
- }
- }
+ Instruction *Select =
+ createMaskSelect(IC, II, BoolVec, Op0, Op1, MaskSrc, ShuffleMask);
+ if (Select)
+ return Select;
+ } else {
+ BoolVec = tryDecomposeVectorLogicMask(Mask, IC.Builder);
+ if (BoolVec) {
+ Instruction *Select =
+ createMaskSelect(IC, II, BoolVec, Op0, Op1, MaskSrc, ShuffleMask);
+ if (Select)
+ return Select;
+ }
+ }
break;
}
``````````
</details>
https://github.com/llvm/llvm-project/pull/137322
More information about the llvm-commits
mailing list