2010-01-05 05:36:20 +00:00
|
|
|
//===- InstCombineVectorOps.cpp -------------------------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements instcombine for ExtractElement, InsertElement and
|
|
|
|
// ShuffleVector.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "InstCombine.h"
|
2013-01-15 23:43:14 +00:00
|
|
|
#include "llvm/Support/PatternMatch.h"
|
2010-01-05 05:36:20 +00:00
|
|
|
using namespace llvm;
|
2013-01-15 23:43:14 +00:00
|
|
|
using namespace PatternMatch;
|
2010-01-05 05:36:20 +00:00
|
|
|
|
|
|
|
/// CheapToScalarize - Return true if the value is cheaper to scalarize than it
|
2012-01-24 14:31:22 +00:00
|
|
|
/// is to leave as a vector operation. isConstant indicates whether we're
|
|
|
|
/// extracting one known element. If false we're extracting a variable index.
|
2010-01-05 05:36:20 +00:00
|
|
|
static bool CheapToScalarize(Value *V, bool isConstant) {
|
2012-01-26 00:42:34 +00:00
|
|
|
if (Constant *C = dyn_cast<Constant>(V)) {
|
2010-01-05 05:36:20 +00:00
|
|
|
if (isConstant) return true;
|
2012-01-26 00:42:34 +00:00
|
|
|
|
|
|
|
// If all elts are the same, we can extract it and use any of the values.
|
|
|
|
Constant *Op0 = C->getAggregateElement(0U);
|
|
|
|
for (unsigned i = 1, e = V->getType()->getVectorNumElements(); i != e; ++i)
|
|
|
|
if (C->getAggregateElement(i) != Op0)
|
2010-01-05 05:36:20 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
Instruction *I = dyn_cast<Instruction>(V);
|
|
|
|
if (!I) return false;
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// Insert element gets simplified to the inserted element or is deleted if
|
|
|
|
// this is constant idx extract element and its a constant idx insertelt.
|
|
|
|
if (I->getOpcode() == Instruction::InsertElement && isConstant &&
|
|
|
|
isa<ConstantInt>(I->getOperand(2)))
|
|
|
|
return true;
|
|
|
|
if (I->getOpcode() == Instruction::Load && I->hasOneUse())
|
|
|
|
return true;
|
|
|
|
if (BinaryOperator *BO = dyn_cast<BinaryOperator>(I))
|
|
|
|
if (BO->hasOneUse() &&
|
|
|
|
(CheapToScalarize(BO->getOperand(0), isConstant) ||
|
|
|
|
CheapToScalarize(BO->getOperand(1), isConstant)))
|
|
|
|
return true;
|
|
|
|
if (CmpInst *CI = dyn_cast<CmpInst>(I))
|
|
|
|
if (CI->hasOneUse() &&
|
|
|
|
(CheapToScalarize(CI->getOperand(0), isConstant) ||
|
|
|
|
CheapToScalarize(CI->getOperand(1), isConstant)))
|
|
|
|
return true;
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// FindScalarElement - Given a vector and an element number, see if the scalar
|
|
|
|
/// value is already around as a register, for example if it were inserted then
|
|
|
|
/// extracted from the vector.
|
|
|
|
static Value *FindScalarElement(Value *V, unsigned EltNo) {
|
2010-02-16 11:11:14 +00:00
|
|
|
assert(V->getType()->isVectorTy() && "Not looking at a vector?");
|
2012-01-26 00:42:34 +00:00
|
|
|
VectorType *VTy = cast<VectorType>(V->getType());
|
|
|
|
unsigned Width = VTy->getNumElements();
|
2010-01-05 05:36:20 +00:00
|
|
|
if (EltNo >= Width) // Out of range access.
|
2012-01-26 00:42:34 +00:00
|
|
|
return UndefValue::get(VTy->getElementType());
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2012-01-26 00:42:34 +00:00
|
|
|
if (Constant *C = dyn_cast<Constant>(V))
|
|
|
|
return C->getAggregateElement(EltNo);
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:42:08 +00:00
|
|
|
if (InsertElementInst *III = dyn_cast<InsertElementInst>(V)) {
|
2010-01-05 05:36:20 +00:00
|
|
|
// If this is an insert to a variable element, we don't know what it is.
|
2010-10-29 22:20:43 +00:00
|
|
|
if (!isa<ConstantInt>(III->getOperand(2)))
|
2010-01-05 05:36:20 +00:00
|
|
|
return 0;
|
|
|
|
unsigned IIElt = cast<ConstantInt>(III->getOperand(2))->getZExtValue();
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// If this is an insert to the element we are looking for, return the
|
|
|
|
// inserted value.
|
2010-10-29 22:20:43 +00:00
|
|
|
if (EltNo == IIElt)
|
2010-01-05 05:36:20 +00:00
|
|
|
return III->getOperand(1);
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// Otherwise, the insertelement doesn't modify the value, recurse on its
|
|
|
|
// vector input.
|
|
|
|
return FindScalarElement(III->getOperand(0), EltNo);
|
2010-01-05 05:42:08 +00:00
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:42:08 +00:00
|
|
|
if (ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(V)) {
|
2012-01-26 00:42:34 +00:00
|
|
|
unsigned LHSWidth = SVI->getOperand(0)->getType()->getVectorNumElements();
|
2011-10-21 19:11:34 +00:00
|
|
|
int InEl = SVI->getMaskValue(EltNo);
|
2010-10-29 22:20:43 +00:00
|
|
|
if (InEl < 0)
|
2012-01-26 00:42:34 +00:00
|
|
|
return UndefValue::get(VTy->getElementType());
|
2010-10-29 22:03:05 +00:00
|
|
|
if (InEl < (int)LHSWidth)
|
|
|
|
return FindScalarElement(SVI->getOperand(0), InEl);
|
|
|
|
return FindScalarElement(SVI->getOperand(1), InEl - LHSWidth);
|
2010-01-05 05:36:20 +00:00
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2013-01-15 23:43:14 +00:00
|
|
|
// Extract a value from a vector add operation with a constant zero.
|
|
|
|
Value *Val = 0; Constant *Con = 0;
|
|
|
|
if (match(V, m_Add(m_Value(Val), m_Constant(Con)))) {
|
|
|
|
if (Con->getAggregateElement(EltNo)->isNullValue())
|
|
|
|
return FindScalarElement(Val, EltNo);
|
|
|
|
}
|
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// Otherwise, we don't know.
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-04-18 19:35:39 +00:00
|
|
|
// If we have a PHI node with a vector type that has only 2 uses: feed
|
|
|
|
// itself and be an operand of extractelemnt at a constant location,
|
|
|
|
// try to replace the PHI of the vector type with a PHI of a scalar type
|
|
|
|
Instruction *InstCombiner::scalarizePHI(ExtractElementInst &EI, PHINode *PN) {
|
|
|
|
// Verify that the PHI node has exactly 2 uses. Otherwise return NULL.
|
|
|
|
if (!PN->hasNUses(2))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
// If so, it's known at this point that one operand is PHI and the other is
|
|
|
|
// an extractelement node. Find the PHI user that is not the extractelement
|
|
|
|
// node.
|
|
|
|
Value::use_iterator iu = PN->use_begin();
|
|
|
|
Instruction *PHIUser = dyn_cast<Instruction>(*iu);
|
|
|
|
if (PHIUser == cast<Instruction>(&EI))
|
|
|
|
PHIUser = cast<Instruction>(*(++iu));
|
|
|
|
|
|
|
|
// Verify that this PHI user has one use, which is the PHI itself,
|
|
|
|
// and that it is a binary operation which is cheap to scalarize.
|
|
|
|
// otherwise return NULL.
|
|
|
|
if (!PHIUser->hasOneUse() || !(PHIUser->use_back() == PN) ||
|
2013-05-24 12:33:28 +00:00
|
|
|
!(isa<BinaryOperator>(PHIUser)) || !CheapToScalarize(PHIUser, true))
|
2013-04-18 19:35:39 +00:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
// Create a scalar PHI node that will replace the vector PHI node
|
|
|
|
// just before the current PHI node.
|
2013-05-24 12:33:28 +00:00
|
|
|
PHINode *scalarPHI = cast<PHINode>(InsertNewInstWith(
|
|
|
|
PHINode::Create(EI.getType(), PN->getNumIncomingValues(), ""), *PN));
|
2013-04-18 19:35:39 +00:00
|
|
|
// Scalarize each PHI operand.
|
2013-05-24 12:33:28 +00:00
|
|
|
for (unsigned i = 0; i < PN->getNumIncomingValues(); i++) {
|
2013-04-18 19:35:39 +00:00
|
|
|
Value *PHIInVal = PN->getIncomingValue(i);
|
|
|
|
BasicBlock *inBB = PN->getIncomingBlock(i);
|
|
|
|
Value *Elt = EI.getIndexOperand();
|
|
|
|
// If the operand is the PHI induction variable:
|
|
|
|
if (PHIInVal == PHIUser) {
|
|
|
|
// Scalarize the binary operation. Its first operand is the
|
|
|
|
// scalar PHI and the second operand is extracted from the other
|
|
|
|
// vector operand.
|
|
|
|
BinaryOperator *B0 = cast<BinaryOperator>(PHIUser);
|
2013-05-24 12:33:28 +00:00
|
|
|
unsigned opId = (B0->getOperand(0) == PN) ? 1 : 0;
|
2013-05-24 12:29:54 +00:00
|
|
|
Value *Op = InsertNewInstWith(
|
|
|
|
ExtractElementInst::Create(B0->getOperand(opId), Elt,
|
|
|
|
B0->getOperand(opId)->getName() + ".Elt"),
|
|
|
|
*B0);
|
2013-04-18 19:35:39 +00:00
|
|
|
Value *newPHIUser = InsertNewInstWith(
|
2013-05-24 12:33:28 +00:00
|
|
|
BinaryOperator::Create(B0->getOpcode(), scalarPHI, Op), *B0);
|
2013-04-18 19:35:39 +00:00
|
|
|
scalarPHI->addIncoming(newPHIUser, inBB);
|
|
|
|
} else {
|
|
|
|
// Scalarize PHI input:
|
2013-05-24 12:33:28 +00:00
|
|
|
Instruction *newEI = ExtractElementInst::Create(PHIInVal, Elt, "");
|
2013-04-18 19:35:39 +00:00
|
|
|
// Insert the new instruction into the predecessor basic block.
|
|
|
|
Instruction *pos = dyn_cast<Instruction>(PHIInVal);
|
|
|
|
BasicBlock::iterator InsertPos;
|
|
|
|
if (pos && !isa<PHINode>(pos)) {
|
|
|
|
InsertPos = pos;
|
|
|
|
++InsertPos;
|
|
|
|
} else {
|
|
|
|
InsertPos = inBB->getFirstInsertionPt();
|
|
|
|
}
|
|
|
|
|
|
|
|
InsertNewInstWith(newEI, *InsertPos);
|
|
|
|
|
|
|
|
scalarPHI->addIncoming(newEI, inBB);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ReplaceInstUsesWith(EI, scalarPHI);
|
|
|
|
}
|
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
Instruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) {
|
2012-01-26 00:42:34 +00:00
|
|
|
// If vector val is constant with all elements the same, replace EI with
|
|
|
|
// that element. We handle a known element # below.
|
|
|
|
if (Constant *C = dyn_cast<Constant>(EI.getOperand(0)))
|
|
|
|
if (CheapToScalarize(C, false))
|
|
|
|
return ReplaceInstUsesWith(EI, C->getAggregateElement(0U));
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// If extracting a specified index from the vector, see if we can recursively
|
|
|
|
// find a previously computed scalar that was inserted into the vector.
|
|
|
|
if (ConstantInt *IdxC = dyn_cast<ConstantInt>(EI.getOperand(1))) {
|
|
|
|
unsigned IndexVal = IdxC->getZExtValue();
|
|
|
|
unsigned VectorWidth = EI.getVectorOperandType()->getNumElements();
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// If this is extracting an invalid index, turn this into undef, to avoid
|
|
|
|
// crashing the code below.
|
|
|
|
if (IndexVal >= VectorWidth)
|
|
|
|
return ReplaceInstUsesWith(EI, UndefValue::get(EI.getType()));
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// This instruction only demands the single element from the input vector.
|
|
|
|
// If the input vector has a single use, simplify it based on this use
|
|
|
|
// property.
|
|
|
|
if (EI.getOperand(0)->hasOneUse() && VectorWidth != 1) {
|
|
|
|
APInt UndefElts(VectorWidth, 0);
|
2010-02-08 23:56:03 +00:00
|
|
|
APInt DemandedMask(VectorWidth, 0);
|
2010-12-01 08:53:58 +00:00
|
|
|
DemandedMask.setBit(IndexVal);
|
2010-01-05 05:36:20 +00:00
|
|
|
if (Value *V = SimplifyDemandedVectorElts(EI.getOperand(0),
|
|
|
|
DemandedMask, UndefElts)) {
|
|
|
|
EI.setOperand(0, V);
|
|
|
|
return &EI;
|
|
|
|
}
|
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
if (Value *Elt = FindScalarElement(EI.getOperand(0), IndexVal))
|
|
|
|
return ReplaceInstUsesWith(EI, Elt);
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// If the this extractelement is directly using a bitcast from a vector of
|
|
|
|
// the same number of elements, see if we can find the source element from
|
|
|
|
// it. In this case, we will end up needing to bitcast the scalars.
|
|
|
|
if (BitCastInst *BCI = dyn_cast<BitCastInst>(EI.getOperand(0))) {
|
2012-01-26 00:42:34 +00:00
|
|
|
if (VectorType *VT = dyn_cast<VectorType>(BCI->getOperand(0)->getType()))
|
2010-01-05 05:36:20 +00:00
|
|
|
if (VT->getNumElements() == VectorWidth)
|
|
|
|
if (Value *Elt = FindScalarElement(BCI->getOperand(0), IndexVal))
|
|
|
|
return new BitCastInst(Elt, EI.getType());
|
|
|
|
}
|
2013-04-18 19:35:39 +00:00
|
|
|
|
|
|
|
// If there's a vector PHI feeding a scalar use through this extractelement
|
|
|
|
// instruction, try to scalarize the PHI.
|
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(EI.getOperand(0))) {
|
2013-05-04 01:08:15 +00:00
|
|
|
Instruction *scalarPHI = scalarizePHI(EI, PN);
|
|
|
|
if (scalarPHI)
|
2013-05-24 12:33:28 +00:00
|
|
|
return scalarPHI;
|
2013-04-18 19:35:39 +00:00
|
|
|
}
|
2010-01-05 05:36:20 +00:00
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
if (Instruction *I = dyn_cast<Instruction>(EI.getOperand(0))) {
|
|
|
|
// Push extractelement into predecessor operation if legal and
|
|
|
|
// profitable to do so
|
|
|
|
if (BinaryOperator *BO = dyn_cast<BinaryOperator>(I)) {
|
|
|
|
if (I->hasOneUse() &&
|
|
|
|
CheapToScalarize(BO, isa<ConstantInt>(EI.getOperand(1)))) {
|
|
|
|
Value *newEI0 =
|
2010-10-29 22:20:45 +00:00
|
|
|
Builder->CreateExtractElement(BO->getOperand(0), EI.getOperand(1),
|
|
|
|
EI.getName()+".lhs");
|
2010-01-05 05:36:20 +00:00
|
|
|
Value *newEI1 =
|
2010-10-29 22:20:45 +00:00
|
|
|
Builder->CreateExtractElement(BO->getOperand(1), EI.getOperand(1),
|
|
|
|
EI.getName()+".rhs");
|
2010-01-05 05:36:20 +00:00
|
|
|
return BinaryOperator::Create(BO->getOpcode(), newEI0, newEI1);
|
|
|
|
}
|
|
|
|
} else if (InsertElementInst *IE = dyn_cast<InsertElementInst>(I)) {
|
|
|
|
// Extracting the inserted element?
|
|
|
|
if (IE->getOperand(2) == EI.getOperand(1))
|
|
|
|
return ReplaceInstUsesWith(EI, IE->getOperand(1));
|
|
|
|
// If the inserted and extracted elements are constants, they must not
|
|
|
|
// be the same value, extract from the pre-inserted value instead.
|
|
|
|
if (isa<Constant>(IE->getOperand(2)) && isa<Constant>(EI.getOperand(1))) {
|
|
|
|
Worklist.AddValue(EI.getOperand(0));
|
|
|
|
EI.setOperand(0, IE->getOperand(0));
|
|
|
|
return &EI;
|
|
|
|
}
|
|
|
|
} else if (ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(I)) {
|
|
|
|
// If this is extracting an element from a shufflevector, figure out where
|
|
|
|
// it came from and extract from the appropriate input element instead.
|
|
|
|
if (ConstantInt *Elt = dyn_cast<ConstantInt>(EI.getOperand(1))) {
|
2011-10-21 19:11:34 +00:00
|
|
|
int SrcIdx = SVI->getMaskValue(Elt->getZExtValue());
|
2010-01-05 05:36:20 +00:00
|
|
|
Value *Src;
|
|
|
|
unsigned LHSWidth =
|
2012-01-26 00:42:34 +00:00
|
|
|
SVI->getOperand(0)->getType()->getVectorNumElements();
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-10-29 22:03:05 +00:00
|
|
|
if (SrcIdx < 0)
|
|
|
|
return ReplaceInstUsesWith(EI, UndefValue::get(EI.getType()));
|
|
|
|
if (SrcIdx < (int)LHSWidth)
|
2010-01-05 05:36:20 +00:00
|
|
|
Src = SVI->getOperand(0);
|
2010-10-29 22:03:05 +00:00
|
|
|
else {
|
2010-01-05 05:36:20 +00:00
|
|
|
SrcIdx -= LHSWidth;
|
|
|
|
Src = SVI->getOperand(1);
|
|
|
|
}
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Int32Ty = Type::getInt32Ty(EI.getContext());
|
2010-01-05 05:36:20 +00:00
|
|
|
return ExtractElementInst::Create(Src,
|
2010-10-29 22:03:07 +00:00
|
|
|
ConstantInt::get(Int32Ty,
|
2010-01-05 05:36:20 +00:00
|
|
|
SrcIdx, false));
|
|
|
|
}
|
2011-03-31 22:57:29 +00:00
|
|
|
} else if (CastInst *CI = dyn_cast<CastInst>(I)) {
|
|
|
|
// Canonicalize extractelement(cast) -> cast(extractelement)
|
|
|
|
// bitcasts can change the number of vector elements and they cost nothing
|
2013-04-18 19:56:44 +00:00
|
|
|
if (CI->hasOneUse() && (CI->getOpcode() != Instruction::BitCast)) {
|
2013-04-22 20:51:10 +00:00
|
|
|
Value *EE = Builder->CreateExtractElement(CI->getOperand(0),
|
|
|
|
EI.getIndexOperand());
|
|
|
|
Worklist.AddValue(EE);
|
2011-03-31 22:57:29 +00:00
|
|
|
return CastInst::Create(CI->getOpcode(), EE, EI.getType());
|
|
|
|
}
|
2010-01-05 05:36:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// CollectSingleShuffleElements - If V is a shuffle of values that ONLY returns
|
2010-10-29 22:20:43 +00:00
|
|
|
/// elements from either LHS or RHS, return the shuffle mask and true.
|
2010-01-05 05:36:20 +00:00
|
|
|
/// Otherwise, return false.
|
|
|
|
static bool CollectSingleShuffleElements(Value *V, Value *LHS, Value *RHS,
|
2012-01-27 03:08:05 +00:00
|
|
|
SmallVectorImpl<Constant*> &Mask) {
|
2010-01-05 05:36:20 +00:00
|
|
|
assert(V->getType() == LHS->getType() && V->getType() == RHS->getType() &&
|
|
|
|
"Invalid CollectSingleShuffleElements");
|
|
|
|
unsigned NumElts = cast<VectorType>(V->getType())->getNumElements();
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
if (isa<UndefValue>(V)) {
|
|
|
|
Mask.assign(NumElts, UndefValue::get(Type::getInt32Ty(V->getContext())));
|
|
|
|
return true;
|
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
if (V == LHS) {
|
|
|
|
for (unsigned i = 0; i != NumElts; ++i)
|
|
|
|
Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()), i));
|
|
|
|
return true;
|
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
if (V == RHS) {
|
|
|
|
for (unsigned i = 0; i != NumElts; ++i)
|
|
|
|
Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()),
|
|
|
|
i+NumElts));
|
|
|
|
return true;
|
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
if (InsertElementInst *IEI = dyn_cast<InsertElementInst>(V)) {
|
|
|
|
// If this is an insert of an extract from some other vector, include it.
|
|
|
|
Value *VecOp = IEI->getOperand(0);
|
|
|
|
Value *ScalarOp = IEI->getOperand(1);
|
|
|
|
Value *IdxOp = IEI->getOperand(2);
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
if (!isa<ConstantInt>(IdxOp))
|
|
|
|
return false;
|
|
|
|
unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue();
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
if (isa<UndefValue>(ScalarOp)) { // inserting undef into vector.
|
|
|
|
// Okay, we can handle this if the vector we are insertinting into is
|
|
|
|
// transitively ok.
|
|
|
|
if (CollectSingleShuffleElements(VecOp, LHS, RHS, Mask)) {
|
|
|
|
// If so, update the mask to reflect the inserted undef.
|
|
|
|
Mask[InsertedIdx] = UndefValue::get(Type::getInt32Ty(V->getContext()));
|
|
|
|
return true;
|
2010-10-29 22:20:43 +00:00
|
|
|
}
|
2010-01-05 05:36:20 +00:00
|
|
|
} else if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)){
|
|
|
|
if (isa<ConstantInt>(EI->getOperand(1)) &&
|
|
|
|
EI->getOperand(0)->getType() == V->getType()) {
|
|
|
|
unsigned ExtractedIdx =
|
|
|
|
cast<ConstantInt>(EI->getOperand(1))->getZExtValue();
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// This must be extracting from either LHS or RHS.
|
|
|
|
if (EI->getOperand(0) == LHS || EI->getOperand(0) == RHS) {
|
|
|
|
// Okay, we can handle this if the vector we are insertinting into is
|
|
|
|
// transitively ok.
|
|
|
|
if (CollectSingleShuffleElements(VecOp, LHS, RHS, Mask)) {
|
|
|
|
// If so, update the mask to reflect the inserted value.
|
|
|
|
if (EI->getOperand(0) == LHS) {
|
2010-10-29 22:20:43 +00:00
|
|
|
Mask[InsertedIdx % NumElts] =
|
2010-01-05 05:36:20 +00:00
|
|
|
ConstantInt::get(Type::getInt32Ty(V->getContext()),
|
|
|
|
ExtractedIdx);
|
|
|
|
} else {
|
|
|
|
assert(EI->getOperand(0) == RHS);
|
2010-10-29 22:20:43 +00:00
|
|
|
Mask[InsertedIdx % NumElts] =
|
2010-01-05 05:36:20 +00:00
|
|
|
ConstantInt::get(Type::getInt32Ty(V->getContext()),
|
|
|
|
ExtractedIdx+NumElts);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// TODO: Handle shufflevector here!
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// CollectShuffleElements - We are building a shuffle of V, using RHS as the
|
|
|
|
/// RHS of the shuffle instruction, if it is not null. Return a shuffle mask
|
|
|
|
/// that computes V and the LHS value of the shuffle.
|
2012-01-27 03:08:05 +00:00
|
|
|
static Value *CollectShuffleElements(Value *V, SmallVectorImpl<Constant*> &Mask,
|
2010-01-05 05:36:20 +00:00
|
|
|
Value *&RHS) {
|
2010-10-29 22:20:43 +00:00
|
|
|
assert(V->getType()->isVectorTy() &&
|
2010-01-05 05:36:20 +00:00
|
|
|
(RHS == 0 || V->getType() == RHS->getType()) &&
|
|
|
|
"Invalid shuffle!");
|
|
|
|
unsigned NumElts = cast<VectorType>(V->getType())->getNumElements();
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
if (isa<UndefValue>(V)) {
|
|
|
|
Mask.assign(NumElts, UndefValue::get(Type::getInt32Ty(V->getContext())));
|
|
|
|
return V;
|
2012-01-24 14:31:22 +00:00
|
|
|
}
|
2013-01-18 05:09:16 +00:00
|
|
|
|
2012-01-24 14:31:22 +00:00
|
|
|
if (isa<ConstantAggregateZero>(V)) {
|
2010-01-05 05:36:20 +00:00
|
|
|
Mask.assign(NumElts, ConstantInt::get(Type::getInt32Ty(V->getContext()),0));
|
|
|
|
return V;
|
2012-01-24 14:31:22 +00:00
|
|
|
}
|
2013-01-18 05:09:16 +00:00
|
|
|
|
2012-01-24 14:31:22 +00:00
|
|
|
if (InsertElementInst *IEI = dyn_cast<InsertElementInst>(V)) {
|
2010-01-05 05:36:20 +00:00
|
|
|
// If this is an insert of an extract from some other vector, include it.
|
|
|
|
Value *VecOp = IEI->getOperand(0);
|
|
|
|
Value *ScalarOp = IEI->getOperand(1);
|
|
|
|
Value *IdxOp = IEI->getOperand(2);
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)) {
|
|
|
|
if (isa<ConstantInt>(EI->getOperand(1)) && isa<ConstantInt>(IdxOp) &&
|
|
|
|
EI->getOperand(0)->getType() == V->getType()) {
|
|
|
|
unsigned ExtractedIdx =
|
2010-10-29 22:20:45 +00:00
|
|
|
cast<ConstantInt>(EI->getOperand(1))->getZExtValue();
|
2010-01-05 05:36:20 +00:00
|
|
|
unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue();
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// Either the extracted from or inserted into vector must be RHSVec,
|
|
|
|
// otherwise we'd end up with a shuffle of three inputs.
|
|
|
|
if (EI->getOperand(0) == RHS || RHS == 0) {
|
|
|
|
RHS = EI->getOperand(0);
|
|
|
|
Value *V = CollectShuffleElements(VecOp, Mask, RHS);
|
2010-10-29 22:20:43 +00:00
|
|
|
Mask[InsertedIdx % NumElts] =
|
2010-10-29 22:20:45 +00:00
|
|
|
ConstantInt::get(Type::getInt32Ty(V->getContext()),
|
|
|
|
NumElts+ExtractedIdx);
|
2010-01-05 05:36:20 +00:00
|
|
|
return V;
|
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
if (VecOp == RHS) {
|
|
|
|
Value *V = CollectShuffleElements(EI->getOperand(0), Mask, RHS);
|
Fix for wrong instcombine on vector insert/extract
When trying to collapse sequences of insertelement/extractelement
instructions into single shuffle instructions, there is one specific
case where the Instruction Combiner wrongly updates the resulting
Mask of shuffle indexes.
The problem is in function CollectShuffleElments.
If we have a sequence of insert/extract element instructions
like the one below:
%tmp1 = extractelement <4 x float> %LHS, i32 0
%tmp2 = insertelement <4 x float> %RHS, float %tmp1, i32 1
%tmp3 = extractelement <4 x float> %RHS, i32 2
%tmp4 = insertelement <4 x float> %tmp2, float %tmp3, i32 3
Where:
. %RHS will have a mask of [4,5,6,7]
. %LHS will have a mask of [0,1,2,3]
The Mask of shuffle indexes is wrongly computed to [4,1,6,7]
instead of [4,0,6,7].
When analyzing %tmp2 in order to compute the Mask for the
resulting shuffle instruction, the algorithm forgets to update
the mask index at position 1 with the index associated to the
element extracted from %LHS by instruction %tmp1.
Patch by Andrea DiBiagio!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@179291 91177308-0d34-0410-b5e6-96231b3b80d8
2013-04-11 15:10:09 +00:00
|
|
|
// Update Mask to reflect that `ScalarOp' has been inserted at
|
|
|
|
// position `InsertedIdx' within the vector returned by IEI.
|
|
|
|
Mask[InsertedIdx % NumElts] = Mask[ExtractedIdx];
|
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// Everything but the extracted element is replaced with the RHS.
|
|
|
|
for (unsigned i = 0; i != NumElts; ++i) {
|
|
|
|
if (i != InsertedIdx)
|
|
|
|
Mask[i] = ConstantInt::get(Type::getInt32Ty(V->getContext()),
|
|
|
|
NumElts+i);
|
|
|
|
}
|
|
|
|
return V;
|
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// If this insertelement is a chain that comes from exactly these two
|
|
|
|
// vectors, return the vector and the effective shuffle.
|
|
|
|
if (CollectSingleShuffleElements(IEI, EI->getOperand(0), RHS, Mask))
|
|
|
|
return EI->getOperand(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// TODO: Handle shufflevector here!
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// Otherwise, can't do anything fancy. Return an identity vector.
|
|
|
|
for (unsigned i = 0; i != NumElts; ++i)
|
|
|
|
Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()), i));
|
|
|
|
return V;
|
|
|
|
}
|
|
|
|
|
|
|
|
Instruction *InstCombiner::visitInsertElementInst(InsertElementInst &IE) {
|
|
|
|
Value *VecOp = IE.getOperand(0);
|
|
|
|
Value *ScalarOp = IE.getOperand(1);
|
|
|
|
Value *IdxOp = IE.getOperand(2);
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// Inserting an undef or into an undefined place, remove this.
|
|
|
|
if (isa<UndefValue>(ScalarOp) || isa<UndefValue>(IdxOp))
|
|
|
|
ReplaceInstUsesWith(IE, VecOp);
|
2010-10-29 22:20:43 +00:00
|
|
|
|
|
|
|
// If the inserted element was extracted from some other vector, and if the
|
2010-01-05 05:36:20 +00:00
|
|
|
// indexes are constant, try to turn this into a shufflevector operation.
|
|
|
|
if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)) {
|
|
|
|
if (isa<ConstantInt>(EI->getOperand(1)) && isa<ConstantInt>(IdxOp) &&
|
|
|
|
EI->getOperand(0)->getType() == IE.getType()) {
|
|
|
|
unsigned NumVectorElts = IE.getType()->getNumElements();
|
|
|
|
unsigned ExtractedIdx =
|
2010-10-29 22:20:45 +00:00
|
|
|
cast<ConstantInt>(EI->getOperand(1))->getZExtValue();
|
2010-01-05 05:36:20 +00:00
|
|
|
unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue();
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
if (ExtractedIdx >= NumVectorElts) // Out of range extract.
|
|
|
|
return ReplaceInstUsesWith(IE, VecOp);
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
if (InsertedIdx >= NumVectorElts) // Out of range insert.
|
|
|
|
return ReplaceInstUsesWith(IE, UndefValue::get(IE.getType()));
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// If we are extracting a value from a vector, then inserting it right
|
|
|
|
// back into the same place, just use the input vector.
|
|
|
|
if (EI->getOperand(0) == VecOp && ExtractedIdx == InsertedIdx)
|
2010-10-29 22:20:43 +00:00
|
|
|
return ReplaceInstUsesWith(IE, VecOp);
|
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// If this insertelement isn't used by some other insertelement, turn it
|
|
|
|
// (and any insertelements it points to), into one big shuffle.
|
|
|
|
if (!IE.hasOneUse() || !isa<InsertElementInst>(IE.use_back())) {
|
2012-01-27 03:08:05 +00:00
|
|
|
SmallVector<Constant*, 16> Mask;
|
2010-01-05 05:36:20 +00:00
|
|
|
Value *RHS = 0;
|
|
|
|
Value *LHS = CollectShuffleElements(&IE, Mask, RHS);
|
|
|
|
if (RHS == 0) RHS = UndefValue::get(LHS->getType());
|
|
|
|
// We now have a shuffle of LHS, RHS, Mask.
|
2010-10-29 22:20:45 +00:00
|
|
|
return new ShuffleVectorInst(LHS, RHS, ConstantVector::get(Mask));
|
2010-01-05 05:36:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
unsigned VWidth = cast<VectorType>(VecOp->getType())->getNumElements();
|
|
|
|
APInt UndefElts(VWidth, 0);
|
|
|
|
APInt AllOnesEltMask(APInt::getAllOnesValue(VWidth));
|
2011-02-19 22:42:40 +00:00
|
|
|
if (Value *V = SimplifyDemandedVectorElts(&IE, AllOnesEltMask, UndefElts)) {
|
|
|
|
if (V != &IE)
|
|
|
|
return ReplaceInstUsesWith(IE, V);
|
2010-01-05 05:36:20 +00:00
|
|
|
return &IE;
|
2011-02-19 22:42:40 +00:00
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-05-31 00:59:42 +00:00
|
|
|
/// Return true if we can evaluate the specified expression tree if the vector
|
|
|
|
/// elements were shuffled in a different order.
|
|
|
|
static bool CanEvaluateShuffled(Value *V, ArrayRef<int> Mask,
|
2013-06-01 20:51:31 +00:00
|
|
|
unsigned Depth = 5) {
|
2013-05-31 00:59:42 +00:00
|
|
|
// We can always reorder the elements of a constant.
|
|
|
|
if (isa<Constant>(V))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// We won't reorder vector arguments. No IPO here.
|
|
|
|
Instruction *I = dyn_cast<Instruction>(V);
|
|
|
|
if (!I) return false;
|
|
|
|
|
|
|
|
// Two users may expect different orders of the elements. Don't try it.
|
|
|
|
if (!I->hasOneUse())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (Depth == 0) return false;
|
|
|
|
|
|
|
|
switch (I->getOpcode()) {
|
|
|
|
case Instruction::Add:
|
|
|
|
case Instruction::FAdd:
|
|
|
|
case Instruction::Sub:
|
|
|
|
case Instruction::FSub:
|
|
|
|
case Instruction::Mul:
|
|
|
|
case Instruction::FMul:
|
|
|
|
case Instruction::UDiv:
|
|
|
|
case Instruction::SDiv:
|
|
|
|
case Instruction::FDiv:
|
|
|
|
case Instruction::URem:
|
|
|
|
case Instruction::SRem:
|
|
|
|
case Instruction::FRem:
|
|
|
|
case Instruction::Shl:
|
|
|
|
case Instruction::LShr:
|
|
|
|
case Instruction::AShr:
|
|
|
|
case Instruction::And:
|
|
|
|
case Instruction::Or:
|
|
|
|
case Instruction::Xor:
|
|
|
|
case Instruction::ICmp:
|
|
|
|
case Instruction::FCmp:
|
|
|
|
case Instruction::Trunc:
|
|
|
|
case Instruction::ZExt:
|
|
|
|
case Instruction::SExt:
|
|
|
|
case Instruction::FPToUI:
|
|
|
|
case Instruction::FPToSI:
|
|
|
|
case Instruction::UIToFP:
|
|
|
|
case Instruction::SIToFP:
|
|
|
|
case Instruction::FPTrunc:
|
|
|
|
case Instruction::FPExt:
|
|
|
|
case Instruction::GetElementPtr: {
|
|
|
|
for (int i = 0, e = I->getNumOperands(); i != e; ++i) {
|
|
|
|
if (!CanEvaluateShuffled(I->getOperand(i), Mask, Depth-1))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
case Instruction::InsertElement: {
|
|
|
|
ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(2));
|
|
|
|
if (!CI) return false;
|
|
|
|
int ElementNumber = CI->getLimitedValue();
|
|
|
|
|
|
|
|
// Verify that 'CI' does not occur twice in Mask. A single 'insertelement'
|
|
|
|
// can't put an element into multiple indices.
|
|
|
|
bool SeenOnce = false;
|
|
|
|
for (int i = 0, e = Mask.size(); i != e; ++i) {
|
|
|
|
if (Mask[i] == ElementNumber) {
|
|
|
|
if (SeenOnce)
|
|
|
|
return false;
|
|
|
|
SeenOnce = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return CanEvaluateShuffled(I->getOperand(0), Mask, Depth-1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Rebuild a new instruction just like 'I' but with the new operands given.
|
|
|
|
/// In the event of type mismatch, the type of the operands is correct.
|
|
|
|
static Value *BuildNew(Instruction *I, ArrayRef<Value*> NewOps) {
|
|
|
|
// We don't want to use the IRBuilder here because we want the replacement
|
|
|
|
// instructions to appear next to 'I', not the builder's insertion point.
|
|
|
|
switch (I->getOpcode()) {
|
|
|
|
case Instruction::Add:
|
|
|
|
case Instruction::FAdd:
|
|
|
|
case Instruction::Sub:
|
|
|
|
case Instruction::FSub:
|
|
|
|
case Instruction::Mul:
|
|
|
|
case Instruction::FMul:
|
|
|
|
case Instruction::UDiv:
|
|
|
|
case Instruction::SDiv:
|
|
|
|
case Instruction::FDiv:
|
|
|
|
case Instruction::URem:
|
|
|
|
case Instruction::SRem:
|
|
|
|
case Instruction::FRem:
|
|
|
|
case Instruction::Shl:
|
|
|
|
case Instruction::LShr:
|
|
|
|
case Instruction::AShr:
|
|
|
|
case Instruction::And:
|
|
|
|
case Instruction::Or:
|
|
|
|
case Instruction::Xor: {
|
|
|
|
BinaryOperator *BO = cast<BinaryOperator>(I);
|
|
|
|
assert(NewOps.size() == 2 && "binary operator with #ops != 2");
|
|
|
|
BinaryOperator *New =
|
|
|
|
BinaryOperator::Create(cast<BinaryOperator>(I)->getOpcode(),
|
|
|
|
NewOps[0], NewOps[1], "", BO);
|
|
|
|
if (isa<OverflowingBinaryOperator>(BO)) {
|
|
|
|
New->setHasNoUnsignedWrap(BO->hasNoUnsignedWrap());
|
|
|
|
New->setHasNoSignedWrap(BO->hasNoSignedWrap());
|
|
|
|
}
|
|
|
|
if (isa<PossiblyExactOperator>(BO)) {
|
|
|
|
New->setIsExact(BO->isExact());
|
|
|
|
}
|
|
|
|
return New;
|
|
|
|
}
|
|
|
|
case Instruction::ICmp:
|
|
|
|
assert(NewOps.size() == 2 && "icmp with #ops != 2");
|
|
|
|
return new ICmpInst(I, cast<ICmpInst>(I)->getPredicate(),
|
|
|
|
NewOps[0], NewOps[1]);
|
|
|
|
case Instruction::FCmp:
|
|
|
|
assert(NewOps.size() == 2 && "fcmp with #ops != 2");
|
|
|
|
return new FCmpInst(I, cast<FCmpInst>(I)->getPredicate(),
|
|
|
|
NewOps[0], NewOps[1]);
|
|
|
|
case Instruction::Trunc:
|
|
|
|
case Instruction::ZExt:
|
|
|
|
case Instruction::SExt:
|
|
|
|
case Instruction::FPToUI:
|
|
|
|
case Instruction::FPToSI:
|
|
|
|
case Instruction::UIToFP:
|
|
|
|
case Instruction::SIToFP:
|
|
|
|
case Instruction::FPTrunc:
|
|
|
|
case Instruction::FPExt: {
|
|
|
|
// It's possible that the mask has a different number of elements from
|
|
|
|
// the original cast. We recompute the destination type to match the mask.
|
|
|
|
Type *DestTy =
|
|
|
|
VectorType::get(I->getType()->getScalarType(),
|
|
|
|
NewOps[0]->getType()->getVectorNumElements());
|
|
|
|
assert(NewOps.size() == 1 && "cast with #ops != 1");
|
|
|
|
return CastInst::Create(cast<CastInst>(I)->getOpcode(), NewOps[0], DestTy,
|
|
|
|
"", I);
|
|
|
|
}
|
|
|
|
case Instruction::GetElementPtr: {
|
|
|
|
Value *Ptr = NewOps[0];
|
|
|
|
ArrayRef<Value*> Idx = NewOps.slice(1);
|
|
|
|
GetElementPtrInst *GEP = GetElementPtrInst::Create(Ptr, Idx, "", I);
|
|
|
|
GEP->setIsInBounds(cast<GetElementPtrInst>(I)->isInBounds());
|
|
|
|
return GEP;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
llvm_unreachable("failed to rebuild vector instructions");
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *
|
|
|
|
InstCombiner::EvaluateInDifferentElementOrder(Value *V, ArrayRef<int> Mask) {
|
|
|
|
// Mask.size() does not need to be equal to the number of vector elements.
|
|
|
|
|
|
|
|
assert(V->getType()->isVectorTy() && "can't reorder non-vector elements");
|
|
|
|
if (isa<UndefValue>(V)) {
|
|
|
|
return UndefValue::get(VectorType::get(V->getType()->getScalarType(),
|
|
|
|
Mask.size()));
|
|
|
|
}
|
|
|
|
if (isa<ConstantAggregateZero>(V)) {
|
|
|
|
return ConstantAggregateZero::get(
|
|
|
|
VectorType::get(V->getType()->getScalarType(),
|
|
|
|
Mask.size()));
|
|
|
|
}
|
|
|
|
if (Constant *C = dyn_cast<Constant>(V)) {
|
|
|
|
SmallVector<Constant *, 16> MaskValues;
|
|
|
|
for (int i = 0, e = Mask.size(); i != e; ++i) {
|
|
|
|
if (Mask[i] == -1)
|
|
|
|
MaskValues.push_back(UndefValue::get(Builder->getInt32Ty()));
|
|
|
|
else
|
|
|
|
MaskValues.push_back(Builder->getInt32(Mask[i]));
|
|
|
|
}
|
|
|
|
return ConstantExpr::getShuffleVector(C, UndefValue::get(C->getType()),
|
|
|
|
ConstantVector::get(MaskValues));
|
|
|
|
}
|
|
|
|
|
|
|
|
Instruction *I = cast<Instruction>(V);
|
|
|
|
switch (I->getOpcode()) {
|
|
|
|
case Instruction::Add:
|
|
|
|
case Instruction::FAdd:
|
|
|
|
case Instruction::Sub:
|
|
|
|
case Instruction::FSub:
|
|
|
|
case Instruction::Mul:
|
|
|
|
case Instruction::FMul:
|
|
|
|
case Instruction::UDiv:
|
|
|
|
case Instruction::SDiv:
|
|
|
|
case Instruction::FDiv:
|
|
|
|
case Instruction::URem:
|
|
|
|
case Instruction::SRem:
|
|
|
|
case Instruction::FRem:
|
|
|
|
case Instruction::Shl:
|
|
|
|
case Instruction::LShr:
|
|
|
|
case Instruction::AShr:
|
|
|
|
case Instruction::And:
|
|
|
|
case Instruction::Or:
|
|
|
|
case Instruction::Xor:
|
|
|
|
case Instruction::ICmp:
|
|
|
|
case Instruction::FCmp:
|
|
|
|
case Instruction::Trunc:
|
|
|
|
case Instruction::ZExt:
|
|
|
|
case Instruction::SExt:
|
|
|
|
case Instruction::FPToUI:
|
|
|
|
case Instruction::FPToSI:
|
|
|
|
case Instruction::UIToFP:
|
|
|
|
case Instruction::SIToFP:
|
|
|
|
case Instruction::FPTrunc:
|
|
|
|
case Instruction::FPExt:
|
|
|
|
case Instruction::Select:
|
|
|
|
case Instruction::GetElementPtr: {
|
|
|
|
SmallVector<Value*, 8> NewOps;
|
|
|
|
bool NeedsRebuild = (Mask.size() != I->getType()->getVectorNumElements());
|
|
|
|
for (int i = 0, e = I->getNumOperands(); i != e; ++i) {
|
|
|
|
Value *V = EvaluateInDifferentElementOrder(I->getOperand(i), Mask);
|
|
|
|
NewOps.push_back(V);
|
|
|
|
NeedsRebuild |= (V != I->getOperand(i));
|
|
|
|
}
|
|
|
|
if (NeedsRebuild) {
|
|
|
|
return BuildNew(I, NewOps);
|
|
|
|
}
|
|
|
|
return I;
|
|
|
|
}
|
|
|
|
case Instruction::InsertElement: {
|
|
|
|
int Element = cast<ConstantInt>(I->getOperand(2))->getLimitedValue();
|
|
|
|
|
|
|
|
// The insertelement was inserting at Element. Figure out which element
|
|
|
|
// that becomes after shuffling. The answer is guaranteed to be unique
|
|
|
|
// by CanEvaluateShuffled.
|
2013-06-01 20:51:31 +00:00
|
|
|
bool Found = false;
|
2013-05-31 00:59:42 +00:00
|
|
|
int Index = 0;
|
2013-06-01 20:51:31 +00:00
|
|
|
for (int e = Mask.size(); Index != e; ++Index) {
|
|
|
|
if (Mask[Index] == Element) {
|
|
|
|
Found = true;
|
2013-05-31 00:59:42 +00:00
|
|
|
break;
|
2013-06-01 20:51:31 +00:00
|
|
|
}
|
|
|
|
}
|
2013-05-31 00:59:42 +00:00
|
|
|
|
2013-06-01 20:51:31 +00:00
|
|
|
if (!Found)
|
2013-07-12 23:08:06 +00:00
|
|
|
return UndefValue::get(
|
|
|
|
VectorType::get(V->getType()->getScalarType(), Mask.size()));
|
|
|
|
|
2013-05-31 00:59:42 +00:00
|
|
|
Value *V = EvaluateInDifferentElementOrder(I->getOperand(0), Mask);
|
|
|
|
return InsertElementInst::Create(V, I->getOperand(1),
|
|
|
|
Builder->getInt32(Index), "", I);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
llvm_unreachable("failed to reorder elements of vector instruction!");
|
|
|
|
}
|
2010-01-05 05:36:20 +00:00
|
|
|
|
|
|
|
Instruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
|
|
|
|
Value *LHS = SVI.getOperand(0);
|
|
|
|
Value *RHS = SVI.getOperand(1);
|
2012-01-26 00:42:34 +00:00
|
|
|
SmallVector<int, 16> Mask = SVI.getShuffleMask();
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
bool MadeChange = false;
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// Undefined shuffle mask -> undefined value.
|
|
|
|
if (isa<UndefValue>(SVI.getOperand(2)))
|
|
|
|
return ReplaceInstUsesWith(SVI, UndefValue::get(SVI.getType()));
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-08-17 22:55:27 +00:00
|
|
|
unsigned VWidth = cast<VectorType>(SVI.getType())->getNumElements();
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
APInt UndefElts(VWidth, 0);
|
|
|
|
APInt AllOnesEltMask(APInt::getAllOnesValue(VWidth));
|
2011-02-19 22:42:40 +00:00
|
|
|
if (Value *V = SimplifyDemandedVectorElts(&SVI, AllOnesEltMask, UndefElts)) {
|
|
|
|
if (V != &SVI)
|
|
|
|
return ReplaceInstUsesWith(SVI, V);
|
2010-01-05 05:36:20 +00:00
|
|
|
LHS = SVI.getOperand(0);
|
|
|
|
RHS = SVI.getOperand(1);
|
|
|
|
MadeChange = true;
|
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2011-10-21 19:06:29 +00:00
|
|
|
unsigned LHSWidth = cast<VectorType>(LHS->getType())->getNumElements();
|
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// Canonicalize shuffle(x ,x,mask) -> shuffle(x, undef,mask')
|
|
|
|
// Canonicalize shuffle(undef,x,mask) -> shuffle(x, undef,mask').
|
|
|
|
if (LHS == RHS || isa<UndefValue>(LHS)) {
|
2010-08-17 22:55:27 +00:00
|
|
|
if (isa<UndefValue>(LHS) && LHS == RHS) {
|
|
|
|
// shuffle(undef,undef,mask) -> undef.
|
2013-05-31 00:59:42 +00:00
|
|
|
Value *Result = (VWidth == LHSWidth)
|
2011-10-21 19:06:29 +00:00
|
|
|
? LHS : UndefValue::get(SVI.getType());
|
2013-05-31 00:59:42 +00:00
|
|
|
return ReplaceInstUsesWith(SVI, Result);
|
2010-08-17 22:55:27 +00:00
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
// Remap any references to RHS to use LHS.
|
2012-01-27 03:08:05 +00:00
|
|
|
SmallVector<Constant*, 16> Elts;
|
2011-10-21 19:06:29 +00:00
|
|
|
for (unsigned i = 0, e = LHSWidth; i != VWidth; ++i) {
|
2012-01-27 03:08:05 +00:00
|
|
|
if (Mask[i] < 0) {
|
2010-01-05 05:36:20 +00:00
|
|
|
Elts.push_back(UndefValue::get(Type::getInt32Ty(SVI.getContext())));
|
2012-01-27 03:08:05 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((Mask[i] >= (int)e && isa<UndefValue>(RHS)) ||
|
|
|
|
(Mask[i] < (int)e && isa<UndefValue>(LHS))) {
|
|
|
|
Mask[i] = -1; // Turn into undef.
|
|
|
|
Elts.push_back(UndefValue::get(Type::getInt32Ty(SVI.getContext())));
|
|
|
|
} else {
|
|
|
|
Mask[i] = Mask[i] % e; // Force to LHS.
|
|
|
|
Elts.push_back(ConstantInt::get(Type::getInt32Ty(SVI.getContext()),
|
|
|
|
Mask[i]));
|
2010-01-05 05:36:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
SVI.setOperand(0, SVI.getOperand(1));
|
|
|
|
SVI.setOperand(1, UndefValue::get(RHS->getType()));
|
|
|
|
SVI.setOperand(2, ConstantVector::get(Elts));
|
|
|
|
LHS = SVI.getOperand(0);
|
|
|
|
RHS = SVI.getOperand(1);
|
|
|
|
MadeChange = true;
|
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2011-10-21 19:06:29 +00:00
|
|
|
if (VWidth == LHSWidth) {
|
|
|
|
// Analyze the shuffle, are the LHS or RHS and identity shuffles?
|
|
|
|
bool isLHSID = true, isRHSID = true;
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = Mask.size(); i != e; ++i) {
|
|
|
|
if (Mask[i] < 0) continue; // Ignore undef values.
|
|
|
|
// Is this an identity shuffle of the LHS value?
|
|
|
|
isLHSID &= (Mask[i] == (int)i);
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2011-10-21 19:06:29 +00:00
|
|
|
// Is this an identity shuffle of the RHS value?
|
|
|
|
isRHSID &= (Mask[i]-e == i);
|
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2011-10-21 19:06:29 +00:00
|
|
|
// Eliminate identity shuffles.
|
|
|
|
if (isLHSID) return ReplaceInstUsesWith(SVI, LHS);
|
|
|
|
if (isRHSID) return ReplaceInstUsesWith(SVI, RHS);
|
2010-08-10 21:38:12 +00:00
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2013-06-03 23:15:20 +00:00
|
|
|
if (isa<UndefValue>(RHS) && CanEvaluateShuffled(LHS, Mask)) {
|
2013-05-31 00:59:42 +00:00
|
|
|
Value *V = EvaluateInDifferentElementOrder(LHS, Mask);
|
|
|
|
return ReplaceInstUsesWith(SVI, V);
|
|
|
|
}
|
|
|
|
|
2010-08-17 22:55:27 +00:00
|
|
|
// If the LHS is a shufflevector itself, see if we can combine it with this
|
2011-10-21 19:06:29 +00:00
|
|
|
// one without producing an unusual shuffle.
|
|
|
|
// Cases that might be simplified:
|
|
|
|
// 1.
|
|
|
|
// x1=shuffle(v1,v2,mask1)
|
|
|
|
// x=shuffle(x1,undef,mask)
|
|
|
|
// ==>
|
|
|
|
// x=shuffle(v1,undef,newMask)
|
|
|
|
// newMask[i] = (mask[i] < x1.size()) ? mask1[mask[i]] : -1
|
|
|
|
// 2.
|
|
|
|
// x1=shuffle(v1,undef,mask1)
|
|
|
|
// x=shuffle(x1,x2,mask)
|
|
|
|
// where v1.size() == mask1.size()
|
|
|
|
// ==>
|
|
|
|
// x=shuffle(v1,x2,newMask)
|
|
|
|
// newMask[i] = (mask[i] < x1.size()) ? mask1[mask[i]] : mask[i]
|
|
|
|
// 3.
|
|
|
|
// x2=shuffle(v2,undef,mask2)
|
|
|
|
// x=shuffle(x1,x2,mask)
|
|
|
|
// where v2.size() == mask2.size()
|
|
|
|
// ==>
|
|
|
|
// x=shuffle(x1,v2,newMask)
|
|
|
|
// newMask[i] = (mask[i] < x1.size())
|
|
|
|
// ? mask[i] : mask2[mask[i]-x1.size()]+x1.size()
|
|
|
|
// 4.
|
|
|
|
// x1=shuffle(v1,undef,mask1)
|
|
|
|
// x2=shuffle(v2,undef,mask2)
|
|
|
|
// x=shuffle(x1,x2,mask)
|
|
|
|
// where v1.size() == v2.size()
|
|
|
|
// ==>
|
|
|
|
// x=shuffle(v1,v2,newMask)
|
|
|
|
// newMask[i] = (mask[i] < x1.size())
|
|
|
|
// ? mask1[mask[i]] : mask2[mask[i]-x1.size()]+v1.size()
|
|
|
|
//
|
|
|
|
// Here we are really conservative:
|
2010-08-17 22:55:27 +00:00
|
|
|
// we are absolutely afraid of producing a shuffle mask not in the input
|
|
|
|
// program, because the code gen may not be smart enough to turn a merged
|
|
|
|
// shuffle into two specific shuffles: it may produce worse code. As such,
|
2013-05-01 00:25:27 +00:00
|
|
|
// we only merge two shuffles if the result is either a splat or one of the
|
|
|
|
// input shuffle masks. In this case, merging the shuffles just removes
|
|
|
|
// one instruction, which we know is safe. This is good for things like
|
2011-10-21 19:06:29 +00:00
|
|
|
// turning: (splat(splat)) -> splat, or
|
|
|
|
// merge(V[0..n], V[n+1..2n]) -> V[0..2n]
|
|
|
|
ShuffleVectorInst* LHSShuffle = dyn_cast<ShuffleVectorInst>(LHS);
|
|
|
|
ShuffleVectorInst* RHSShuffle = dyn_cast<ShuffleVectorInst>(RHS);
|
|
|
|
if (LHSShuffle)
|
|
|
|
if (!isa<UndefValue>(LHSShuffle->getOperand(1)) && !isa<UndefValue>(RHS))
|
|
|
|
LHSShuffle = NULL;
|
|
|
|
if (RHSShuffle)
|
|
|
|
if (!isa<UndefValue>(RHSShuffle->getOperand(1)))
|
|
|
|
RHSShuffle = NULL;
|
|
|
|
if (!LHSShuffle && !RHSShuffle)
|
|
|
|
return MadeChange ? &SVI : 0;
|
|
|
|
|
|
|
|
Value* LHSOp0 = NULL;
|
|
|
|
Value* LHSOp1 = NULL;
|
|
|
|
Value* RHSOp0 = NULL;
|
|
|
|
unsigned LHSOp0Width = 0;
|
|
|
|
unsigned RHSOp0Width = 0;
|
|
|
|
if (LHSShuffle) {
|
|
|
|
LHSOp0 = LHSShuffle->getOperand(0);
|
|
|
|
LHSOp1 = LHSShuffle->getOperand(1);
|
|
|
|
LHSOp0Width = cast<VectorType>(LHSOp0->getType())->getNumElements();
|
|
|
|
}
|
|
|
|
if (RHSShuffle) {
|
|
|
|
RHSOp0 = RHSShuffle->getOperand(0);
|
|
|
|
RHSOp0Width = cast<VectorType>(RHSOp0->getType())->getNumElements();
|
|
|
|
}
|
|
|
|
Value* newLHS = LHS;
|
|
|
|
Value* newRHS = RHS;
|
|
|
|
if (LHSShuffle) {
|
|
|
|
// case 1
|
2010-08-17 22:55:27 +00:00
|
|
|
if (isa<UndefValue>(RHS)) {
|
2011-10-21 19:06:29 +00:00
|
|
|
newLHS = LHSOp0;
|
|
|
|
newRHS = LHSOp1;
|
|
|
|
}
|
|
|
|
// case 2 or 4
|
|
|
|
else if (LHSOp0Width == LHSWidth) {
|
|
|
|
newLHS = LHSOp0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// case 3 or 4
|
|
|
|
if (RHSShuffle && RHSOp0Width == LHSWidth) {
|
|
|
|
newRHS = RHSOp0;
|
|
|
|
}
|
|
|
|
// case 4
|
|
|
|
if (LHSOp0 == RHSOp0) {
|
|
|
|
newLHS = LHSOp0;
|
|
|
|
newRHS = NULL;
|
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2011-10-21 19:06:29 +00:00
|
|
|
if (newLHS == LHS && newRHS == RHS)
|
|
|
|
return MadeChange ? &SVI : 0;
|
|
|
|
|
|
|
|
SmallVector<int, 16> LHSMask;
|
|
|
|
SmallVector<int, 16> RHSMask;
|
2012-01-26 00:42:34 +00:00
|
|
|
if (newLHS != LHS)
|
|
|
|
LHSMask = LHSShuffle->getShuffleMask();
|
|
|
|
if (RHSShuffle && newRHS != RHS)
|
|
|
|
RHSMask = RHSShuffle->getShuffleMask();
|
|
|
|
|
2011-10-21 19:06:29 +00:00
|
|
|
unsigned newLHSWidth = (newLHS != LHS) ? LHSOp0Width : LHSWidth;
|
|
|
|
SmallVector<int, 16> newMask;
|
|
|
|
bool isSplat = true;
|
|
|
|
int SplatElt = -1;
|
|
|
|
// Create a new mask for the new ShuffleVectorInst so that the new
|
|
|
|
// ShuffleVectorInst is equivalent to the original one.
|
|
|
|
for (unsigned i = 0; i < VWidth; ++i) {
|
|
|
|
int eltMask;
|
2013-01-18 05:30:07 +00:00
|
|
|
if (Mask[i] < 0) {
|
2011-10-21 19:06:29 +00:00
|
|
|
// This element is an undef value.
|
|
|
|
eltMask = -1;
|
|
|
|
} else if (Mask[i] < (int)LHSWidth) {
|
|
|
|
// This element is from left hand side vector operand.
|
2013-01-18 05:09:16 +00:00
|
|
|
//
|
2011-10-21 19:06:29 +00:00
|
|
|
// If LHS is going to be replaced (case 1, 2, or 4), calculate the
|
|
|
|
// new mask value for the element.
|
|
|
|
if (newLHS != LHS) {
|
|
|
|
eltMask = LHSMask[Mask[i]];
|
|
|
|
// If the value selected is an undef value, explicitly specify it
|
|
|
|
// with a -1 mask value.
|
|
|
|
if (eltMask >= (int)LHSOp0Width && isa<UndefValue>(LHSOp1))
|
|
|
|
eltMask = -1;
|
2013-01-18 05:09:16 +00:00
|
|
|
} else
|
2011-10-21 19:06:29 +00:00
|
|
|
eltMask = Mask[i];
|
|
|
|
} else {
|
|
|
|
// This element is from right hand side vector operand
|
|
|
|
//
|
|
|
|
// If the value selected is an undef value, explicitly specify it
|
|
|
|
// with a -1 mask value. (case 1)
|
|
|
|
if (isa<UndefValue>(RHS))
|
|
|
|
eltMask = -1;
|
|
|
|
// If RHS is going to be replaced (case 3 or 4), calculate the
|
|
|
|
// new mask value for the element.
|
|
|
|
else if (newRHS != RHS) {
|
|
|
|
eltMask = RHSMask[Mask[i]-LHSWidth];
|
|
|
|
// If the value selected is an undef value, explicitly specify it
|
|
|
|
// with a -1 mask value.
|
|
|
|
if (eltMask >= (int)RHSOp0Width) {
|
|
|
|
assert(isa<UndefValue>(RHSShuffle->getOperand(1))
|
|
|
|
&& "should have been check above");
|
|
|
|
eltMask = -1;
|
2010-08-13 00:17:53 +00:00
|
|
|
}
|
2013-01-18 05:09:16 +00:00
|
|
|
} else
|
2011-10-21 19:06:29 +00:00
|
|
|
eltMask = Mask[i]-LHSWidth;
|
|
|
|
|
|
|
|
// If LHS's width is changed, shift the mask value accordingly.
|
|
|
|
// If newRHS == NULL, i.e. LHSOp0 == RHSOp0, we want to remap any
|
[InstCombine] Teach InstCombine how to handle an obfuscated splat.
An obfuscated splat is where the frontend poorly generates code for a splat
using several different shuffles to create the splat, i.e.,
%A = load <4 x float>* %in_ptr, align 16
%B = shufflevector <4 x float> %A, <4 x float> undef, <4 x i32> <i32 0, i32 0, i32 undef, i32 undef>
%C = shufflevector <4 x float> %B, <4 x float> %A, <4 x i32> <i32 0, i32 1, i32 4, i32 undef>
%D = shufflevector <4 x float> %C, <4 x float> %A, <4 x i32> <i32 0, i32 1, i32 2, i32 4>
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@166061 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-16 21:29:38 +00:00
|
|
|
// references from RHSOp0 to LHSOp0, so we don't need to shift the mask.
|
|
|
|
// If newRHS == newLHS, we want to remap any references from newRHS to
|
|
|
|
// newLHS so that we can properly identify splats that may occur due to
|
|
|
|
// obfuscation accross the two vectors.
|
|
|
|
if (eltMask >= 0 && newRHS != NULL && newLHS != newRHS)
|
2011-10-21 19:06:29 +00:00
|
|
|
eltMask += newLHSWidth;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if this could still be a splat.
|
|
|
|
if (eltMask >= 0) {
|
|
|
|
if (SplatElt >= 0 && SplatElt != eltMask)
|
|
|
|
isSplat = false;
|
|
|
|
SplatElt = eltMask;
|
|
|
|
}
|
|
|
|
|
|
|
|
newMask.push_back(eltMask);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the result mask is equal to one of the original shuffle masks,
|
2013-05-01 00:25:27 +00:00
|
|
|
// or is a splat, do the replacement.
|
|
|
|
if (isSplat || newMask == LHSMask || newMask == RHSMask || newMask == Mask) {
|
2011-10-21 19:06:29 +00:00
|
|
|
SmallVector<Constant*, 16> Elts;
|
|
|
|
Type *Int32Ty = Type::getInt32Ty(SVI.getContext());
|
|
|
|
for (unsigned i = 0, e = newMask.size(); i != e; ++i) {
|
|
|
|
if (newMask[i] < 0) {
|
|
|
|
Elts.push_back(UndefValue::get(Int32Ty));
|
|
|
|
} else {
|
|
|
|
Elts.push_back(ConstantInt::get(Int32Ty, newMask[i]));
|
|
|
|
}
|
2010-08-13 00:17:53 +00:00
|
|
|
}
|
2011-10-21 19:06:29 +00:00
|
|
|
if (newRHS == NULL)
|
|
|
|
newRHS = UndefValue::get(newLHS->getType());
|
|
|
|
return new ShuffleVectorInst(newLHS, newRHS, ConstantVector::get(Elts));
|
2010-08-13 00:17:53 +00:00
|
|
|
}
|
2010-10-29 22:20:43 +00:00
|
|
|
|
2010-01-05 05:36:20 +00:00
|
|
|
return MadeChange ? &SVI : 0;
|
|
|
|
}
|