RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-12-14 15:39:00 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

InstructionSimplify: Refactor foldIdentityShuffles. NFC.

Browse Source 
Summary:
Minor refactoring of foldIdentityShuffles() which allows the removal of a
ConstantDataVector::get() in SimplifyShuffleVectorInstruction.

Reviewers: spatel

Reviewed By: spatel

Subscribers: llvm-commits

Differential Revision: https://reviews.llvm.org/D32955

Conflicts:
	lib/Analysis/InstructionSimplify.cpp

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@302433 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Zvi Rackover 2017-05-08 15:46:58 +00:00
parent 6922382ead
commit 592063190f
1 changed files with 7 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
lib/Analysis/InstructionSimplify.cpp
View File

@ -4034,24 +4034,21 @@ Value *llvm::SimplifyCastInst(unsigned CastOpc, Value *Op, Type *Ty,
/// match a root vector source operand that contains that element in the same /// match a root vector source operand that contains that element in the same
/// vector lane (ie, the same mask index), so we can eliminate the shuffle(s). /// vector lane (ie, the same mask index), so we can eliminate the shuffle(s).
static Value *foldIdentityShuffles(int DestElt, Value *Op0, Value *Op1, static Value *foldIdentityShuffles(int DestElt, Value *Op0, Value *Op1,
Constant *Mask, Value *RootVec, int RootElt, int MaskVal, Value *RootVec,
unsigned MaxRecurse) { unsigned MaxRecurse) {
if (!MaxRecurse--) if (!MaxRecurse--)
return nullptr; return nullptr;
// Bail out if any mask value is undefined. That kind of shuffle may be // Bail out if any mask value is undefined. That kind of shuffle may be
// simplified further based on demanded bits or other folds. // simplified further based on demanded bits or other folds.
int MaskVal = ShuffleVectorInst::getMaskValue(Mask, RootElt);
if (MaskVal == -1) if (MaskVal == -1)
return nullptr; return nullptr;
// The mask value chooses which source operand we need to look at next. // The mask value chooses which source operand we need to look at next.
Value *SourceOp;
int InVecNumElts = Op0->getType()->getVectorNumElements(); int InVecNumElts = Op0->getType()->getVectorNumElements();
if (MaskVal < InVecNumElts) { int RootElt = MaskVal;
RootElt = MaskVal; Value *SourceOp = Op0;
SourceOp = Op0; if (MaskVal >= InVecNumElts) {
} else {
RootElt = MaskVal - InVecNumElts; RootElt = MaskVal - InVecNumElts;
SourceOp = Op1; SourceOp = Op1;
} }
@ -4061,7 +4058,7 @@ static Value *foldIdentityShuffles(int DestElt, Value *Op0, Value *Op1,
if (auto *SourceShuf = dyn_cast<ShuffleVectorInst>(SourceOp)) { if (auto *SourceShuf = dyn_cast<ShuffleVectorInst>(SourceOp)) {
return foldIdentityShuffles( return foldIdentityShuffles(
DestElt, SourceShuf->getOperand(0), SourceShuf->getOperand(1), DestElt, SourceShuf->getOperand(0), SourceShuf->getOperand(1),
SourceShuf->getMask(), RootVec, RootElt, MaxRecurse); SourceShuf->getMaskValue(RootElt), RootVec, MaxRecurse);
} }
// TODO: Look through bitcasts? What if the bitcast changes the vector element // TODO: Look through bitcasts? What if the bitcast changes the vector element
@ -4127,10 +4124,6 @@ static Value *SimplifyShuffleVectorInst(Value *Op0, Value *Op1, Constant *Mask,
if (Op0Const && !Op1Const) { if (Op0Const && !Op1Const) {
std::swap(Op0, Op1); std::swap(Op0, Op1);
ShuffleVectorInst::commuteShuffleMask(Indices, InVecNumElts); ShuffleVectorInst::commuteShuffleMask(Indices, InVecNumElts);
Mask = ConstantDataVector::get(
Mask->getContext(),
makeArrayRef(reinterpret_cast<uint32_t *>(Indices.data()),
MaskNumElts));
} }
// A shuffle of a splat is always the splat itself. Legal if the shuffle's // A shuffle of a splat is always the splat itself. Legal if the shuffle's
@ -4154,7 +4147,8 @@ static Value *SimplifyShuffleVectorInst(Value *Op0, Value *Op1, Constant *Mask,
for (unsigned i = 0; i != MaskNumElts; ++i) { for (unsigned i = 0; i != MaskNumElts; ++i) {
// Note that recursion is limited for each vector element, so if any element // Note that recursion is limited for each vector element, so if any element
// exceeds the limit, this will fail to simplify. // exceeds the limit, this will fail to simplify.
RootVec = foldIdentityShuffles(i, Op0, Op1, Mask, RootVec, i, MaxRecurse); RootVec =
foldIdentityShuffles(i, Op0, Op1, Indices[i], RootVec, MaxRecurse);
// We can't replace a widening/narrowing shuffle with one of its operands. // We can't replace a widening/narrowing shuffle with one of its operands.
if (!RootVec || RootVec->getType() != RetTy) if (!RootVec || RootVec->getType() != RetTy)