6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-25 16:24:23 +00:00
Code Issues Projects Releases Wiki Activity

Remove trailing whitespace.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@117727 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bob Wilson
2010-10-29 22:20:43 +00:00
parent a7c78220c4
commit 09fd64644d
1 changed files with 69 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

139
lib/Transforms/InstCombine/InstCombineVectorOps.cpp
View File

@ -18,7 +18,7 @@ using namespace llvm;
/// CheapToScalarize - Return true if the value is cheaper to scalarize than it /// CheapToScalarize - Return true if the value is cheaper to scalarize than it
/// is to leave as a vector operation. /// is to leave as a vector operation.
static bool CheapToScalarize(Value *V, bool isConstant) { static bool CheapToScalarize(Value *V, bool isConstant) {
if (isa<ConstantAggregateZero>(V)) if (isa<ConstantAggregateZero>(V))
return true; return true;
if (ConstantVector *C = dyn_cast<ConstantVector>(V)) { if (ConstantVector *C = dyn_cast<ConstantVector>(V)) {
if (isConstant) return true; if (isConstant) return true;
@ -31,7 +31,7 @@ static bool CheapToScalarize(Value *V, bool isConstant) {
} }
Instruction *I = dyn_cast<Instruction>(V); Instruction *I = dyn_cast<Instruction>(V);
if (!I) return false; if (!I) return false;
// Insert element gets simplified to the inserted element or is deleted if // Insert element gets simplified to the inserted element or is deleted if
// this is constant idx extract element and its a constant idx insertelt. // this is constant idx extract element and its a constant idx insertelt.
if (I->getOpcode() == Instruction::InsertElement && isConstant && if (I->getOpcode() == Instruction::InsertElement && isConstant &&
@ -49,7 +49,7 @@ static bool CheapToScalarize(Value *V, bool isConstant) {
(CheapToScalarize(CI->getOperand(0), isConstant) || (CheapToScalarize(CI->getOperand(0), isConstant) ||
CheapToScalarize(CI->getOperand(1), isConstant))) CheapToScalarize(CI->getOperand(1), isConstant)))
return true; return true;
return false; return false;
} }
@ -61,7 +61,7 @@ static std::vector<int> getShuffleMask(const ShuffleVectorInst *SVI) {
return std::vector<int>(NElts, 0); return std::vector<int>(NElts, 0);
if (isa<UndefValue>(SVI->getOperand(2))) if (isa<UndefValue>(SVI->getOperand(2)))
return std::vector<int>(NElts, -1); return std::vector<int>(NElts, -1);
std::vector<int> Result; std::vector<int> Result;
const ConstantVector *CP = cast<ConstantVector>(SVI->getOperand(2)); const ConstantVector *CP = cast<ConstantVector>(SVI->getOperand(2));
for (User::const_op_iterator i = CP->op_begin(), e = CP->op_end(); i!=e; ++i) for (User::const_op_iterator i = CP->op_begin(), e = CP->op_end(); i!=e; ++i)
@ -81,41 +81,41 @@ static Value *FindScalarElement(Value *V, unsigned EltNo) {
unsigned Width = PTy->getNumElements(); unsigned Width = PTy->getNumElements();
if (EltNo >= Width) // Out of range access. if (EltNo >= Width) // Out of range access.
return UndefValue::get(PTy->getElementType()); return UndefValue::get(PTy->getElementType());
if (isa<UndefValue>(V)) if (isa<UndefValue>(V))
return UndefValue::get(PTy->getElementType()); return UndefValue::get(PTy->getElementType());
if (isa<ConstantAggregateZero>(V)) if (isa<ConstantAggregateZero>(V))
return Constant::getNullValue(PTy->getElementType()); return Constant::getNullValue(PTy->getElementType());
if (ConstantVector *CP = dyn_cast<ConstantVector>(V)) if (ConstantVector *CP = dyn_cast<ConstantVector>(V))
return CP->getOperand(EltNo); return CP->getOperand(EltNo);
if (InsertElementInst *III = dyn_cast<InsertElementInst>(V)) { if (InsertElementInst *III = dyn_cast<InsertElementInst>(V)) {
// If this is an insert to a variable element, we don't know what it is. // If this is an insert to a variable element, we don't know what it is.
if (!isa<ConstantInt>(III->getOperand(2))) if (!isa<ConstantInt>(III->getOperand(2)))
return 0; return 0;
unsigned IIElt = cast<ConstantInt>(III->getOperand(2))->getZExtValue(); unsigned IIElt = cast<ConstantInt>(III->getOperand(2))->getZExtValue();
// If this is an insert to the element we are looking for, return the // If this is an insert to the element we are looking for, return the
// inserted value. // inserted value.
if (EltNo == IIElt) if (EltNo == IIElt)
return III->getOperand(1); return III->getOperand(1);
// Otherwise, the insertelement doesn't modify the value, recurse on its // Otherwise, the insertelement doesn't modify the value, recurse on its
// vector input. // vector input.
return FindScalarElement(III->getOperand(0), EltNo); return FindScalarElement(III->getOperand(0), EltNo);
} }
if (ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(V)) { if (ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(V)) {
unsigned LHSWidth = unsigned LHSWidth =
cast<VectorType>(SVI->getOperand(0)->getType())->getNumElements(); cast<VectorType>(SVI->getOperand(0)->getType())->getNumElements();
int InEl = getShuffleMask(SVI)[EltNo]; int InEl = getShuffleMask(SVI)[EltNo];
if (InEl < 0) if (InEl < 0)
return UndefValue::get(PTy->getElementType()); return UndefValue::get(PTy->getElementType());
if (InEl < (int)LHSWidth) if (InEl < (int)LHSWidth)
return FindScalarElement(SVI->getOperand(0), InEl); return FindScalarElement(SVI->getOperand(0), InEl);
return FindScalarElement(SVI->getOperand(1), InEl - LHSWidth); return FindScalarElement(SVI->getOperand(1), InEl - LHSWidth);
} }
// Otherwise, we don't know. // Otherwise, we don't know.
return 0; return 0;
} }
@ -124,11 +124,11 @@ Instruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) {
// If vector val is undef, replace extract with scalar undef. // If vector val is undef, replace extract with scalar undef.
if (isa<UndefValue>(EI.getOperand(0))) if (isa<UndefValue>(EI.getOperand(0)))
return ReplaceInstUsesWith(EI, UndefValue::get(EI.getType())); return ReplaceInstUsesWith(EI, UndefValue::get(EI.getType()));
// If vector val is constant 0, replace extract with scalar 0. // If vector val is constant 0, replace extract with scalar 0.
if (isa<ConstantAggregateZero>(EI.getOperand(0))) if (isa<ConstantAggregateZero>(EI.getOperand(0)))
return ReplaceInstUsesWith(EI, Constant::getNullValue(EI.getType())); return ReplaceInstUsesWith(EI, Constant::getNullValue(EI.getType()));
if (ConstantVector *C = dyn_cast<ConstantVector>(EI.getOperand(0))) { if (ConstantVector *C = dyn_cast<ConstantVector>(EI.getOperand(0))) {
// If vector val is constant with all elements the same, replace EI with // If vector val is constant with all elements the same, replace EI with
// that element. When the elements are not identical, we cannot replace yet // that element. When the elements are not identical, we cannot replace yet
@ -136,24 +136,24 @@ Instruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) {
Constant *op0 = C->getOperand(0); Constant *op0 = C->getOperand(0);
for (unsigned i = 1; i != C->getNumOperands(); ++i) for (unsigned i = 1; i != C->getNumOperands(); ++i)
if (C->getOperand(i) != op0) { if (C->getOperand(i) != op0) {
op0 = 0; op0 = 0;
break; break;
} }
if (op0) if (op0)
return ReplaceInstUsesWith(EI, op0); return ReplaceInstUsesWith(EI, op0);
} }
// If extracting a specified index from the vector, see if we can recursively // If extracting a specified index from the vector, see if we can recursively
// find a previously computed scalar that was inserted into the vector. // find a previously computed scalar that was inserted into the vector.
if (ConstantInt *IdxC = dyn_cast<ConstantInt>(EI.getOperand(1))) { if (ConstantInt *IdxC = dyn_cast<ConstantInt>(EI.getOperand(1))) {
unsigned IndexVal = IdxC->getZExtValue(); unsigned IndexVal = IdxC->getZExtValue();
unsigned VectorWidth = EI.getVectorOperandType()->getNumElements(); unsigned VectorWidth = EI.getVectorOperandType()->getNumElements();
// If this is extracting an invalid index, turn this into undef, to avoid // If this is extracting an invalid index, turn this into undef, to avoid
// crashing the code below. // crashing the code below.
if (IndexVal >= VectorWidth) if (IndexVal >= VectorWidth)
return ReplaceInstUsesWith(EI, UndefValue::get(EI.getType())); return ReplaceInstUsesWith(EI, UndefValue::get(EI.getType()));
// This instruction only demands the single element from the input vector. // 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 // If the input vector has a single use, simplify it based on this use
// property. // property.
@ -167,22 +167,22 @@ Instruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) {
return &EI; return &EI;
} }
} }
if (Value *Elt = FindScalarElement(EI.getOperand(0), IndexVal)) if (Value *Elt = FindScalarElement(EI.getOperand(0), IndexVal))
return ReplaceInstUsesWith(EI, Elt); return ReplaceInstUsesWith(EI, Elt);
// If the this extractelement is directly using a bitcast from a vector of // 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 // 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. // it. In this case, we will end up needing to bitcast the scalars.
if (BitCastInst *BCI = dyn_cast<BitCastInst>(EI.getOperand(0))) { if (BitCastInst *BCI = dyn_cast<BitCastInst>(EI.getOperand(0))) {
if (const VectorType *VT = if (const VectorType *VT =
dyn_cast<VectorType>(BCI->getOperand(0)->getType())) dyn_cast<VectorType>(BCI->getOperand(0)->getType()))
if (VT->getNumElements() == VectorWidth) if (VT->getNumElements() == VectorWidth)
if (Value *Elt = FindScalarElement(BCI->getOperand(0), IndexVal)) if (Value *Elt = FindScalarElement(BCI->getOperand(0), IndexVal))
return new BitCastInst(Elt, EI.getType()); return new BitCastInst(Elt, EI.getType());
} }
} }
if (Instruction *I = dyn_cast<Instruction>(EI.getOperand(0))) { if (Instruction *I = dyn_cast<Instruction>(EI.getOperand(0))) {
// Push extractelement into predecessor operation if legal and // Push extractelement into predecessor operation if legal and
// profitable to do so // profitable to do so
@ -216,7 +216,7 @@ Instruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) {
Value *Src; Value *Src;
unsigned LHSWidth = unsigned LHSWidth =
cast<VectorType>(SVI->getOperand(0)->getType())->getNumElements(); cast<VectorType>(SVI->getOperand(0)->getType())->getNumElements();
if (SrcIdx < 0) if (SrcIdx < 0)
return ReplaceInstUsesWith(EI, UndefValue::get(EI.getType())); return ReplaceInstUsesWith(EI, UndefValue::get(EI.getType()));
if (SrcIdx < (int)LHSWidth) if (SrcIdx < (int)LHSWidth)
@ -237,42 +237,42 @@ Instruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) {
} }
/// CollectSingleShuffleElements - If V is a shuffle of values that ONLY returns /// CollectSingleShuffleElements - If V is a shuffle of values that ONLY returns
/// elements from either LHS or RHS, return the shuffle mask and true. /// elements from either LHS or RHS, return the shuffle mask and true.
/// Otherwise, return false. /// Otherwise, return false.
static bool CollectSingleShuffleElements(Value *V, Value *LHS, Value *RHS, static bool CollectSingleShuffleElements(Value *V, Value *LHS, Value *RHS,
std::vector<Constant*> &Mask) { std::vector<Constant*> &Mask) {
assert(V->getType() == LHS->getType() && V->getType() == RHS->getType() && assert(V->getType() == LHS->getType() && V->getType() == RHS->getType() &&
"Invalid CollectSingleShuffleElements"); "Invalid CollectSingleShuffleElements");
unsigned NumElts = cast<VectorType>(V->getType())->getNumElements(); unsigned NumElts = cast<VectorType>(V->getType())->getNumElements();
if (isa<UndefValue>(V)) { if (isa<UndefValue>(V)) {
Mask.assign(NumElts, UndefValue::get(Type::getInt32Ty(V->getContext()))); Mask.assign(NumElts, UndefValue::get(Type::getInt32Ty(V->getContext())));
return true; return true;
} }
if (V == LHS) { if (V == LHS) {
for (unsigned i = 0; i != NumElts; ++i) for (unsigned i = 0; i != NumElts; ++i)
Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()), i)); Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()), i));
return true; return true;
} }
if (V == RHS) { if (V == RHS) {
for (unsigned i = 0; i != NumElts; ++i) for (unsigned i = 0; i != NumElts; ++i)
Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()), Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()),
i+NumElts)); i+NumElts));
return true; return true;
} }
if (InsertElementInst *IEI = dyn_cast<InsertElementInst>(V)) { if (InsertElementInst *IEI = dyn_cast<InsertElementInst>(V)) {
// If this is an insert of an extract from some other vector, include it. // If this is an insert of an extract from some other vector, include it.
Value *VecOp = IEI->getOperand(0); Value *VecOp = IEI->getOperand(0);
Value *ScalarOp = IEI->getOperand(1); Value *ScalarOp = IEI->getOperand(1);
Value *IdxOp = IEI->getOperand(2); Value *IdxOp = IEI->getOperand(2);
if (!isa<ConstantInt>(IdxOp)) if (!isa<ConstantInt>(IdxOp))
return false; return false;
unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue(); unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue();
if (isa<UndefValue>(ScalarOp)) { // inserting undef into vector. if (isa<UndefValue>(ScalarOp)) { // inserting undef into vector.
// Okay, we can handle this if the vector we are insertinting into is // Okay, we can handle this if the vector we are insertinting into is
// transitively ok. // transitively ok.
@ -280,13 +280,13 @@ static bool CollectSingleShuffleElements(Value *V, Value *LHS, Value *RHS,
// If so, update the mask to reflect the inserted undef. // If so, update the mask to reflect the inserted undef.
Mask[InsertedIdx] = UndefValue::get(Type::getInt32Ty(V->getContext())); Mask[InsertedIdx] = UndefValue::get(Type::getInt32Ty(V->getContext()));
return true; return true;
} }
} else if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)){ } else if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)){
if (isa<ConstantInt>(EI->getOperand(1)) && if (isa<ConstantInt>(EI->getOperand(1)) &&
EI->getOperand(0)->getType() == V->getType()) { EI->getOperand(0)->getType() == V->getType()) {
unsigned ExtractedIdx = unsigned ExtractedIdx =
cast<ConstantInt>(EI->getOperand(1))->getZExtValue(); cast<ConstantInt>(EI->getOperand(1))->getZExtValue();
// This must be extracting from either LHS or RHS. // This must be extracting from either LHS or RHS.
if (EI->getOperand(0) == LHS || EI->getOperand(0) == RHS) { if (EI->getOperand(0) == LHS || EI->getOperand(0) == RHS) {
// Okay, we can handle this if the vector we are insertinting into is // Okay, we can handle this if the vector we are insertinting into is
@ -294,15 +294,14 @@ static bool CollectSingleShuffleElements(Value *V, Value *LHS, Value *RHS,
if (CollectSingleShuffleElements(VecOp, LHS, RHS, Mask)) { if (CollectSingleShuffleElements(VecOp, LHS, RHS, Mask)) {
// If so, update the mask to reflect the inserted value. // If so, update the mask to reflect the inserted value.
if (EI->getOperand(0) == LHS) { if (EI->getOperand(0) == LHS) {
Mask[InsertedIdx % NumElts] = Mask[InsertedIdx % NumElts] =
ConstantInt::get(Type::getInt32Ty(V->getContext()), ConstantInt::get(Type::getInt32Ty(V->getContext()),
ExtractedIdx); ExtractedIdx);
} else { } else {
assert(EI->getOperand(0) == RHS); assert(EI->getOperand(0) == RHS);
Mask[InsertedIdx % NumElts] = Mask[InsertedIdx % NumElts] =
ConstantInt::get(Type::getInt32Ty(V->getContext()), ConstantInt::get(Type::getInt32Ty(V->getContext()),
ExtractedIdx+NumElts); ExtractedIdx+NumElts);
} }
return true; return true;
} }
@ -311,7 +310,7 @@ static bool CollectSingleShuffleElements(Value *V, Value *LHS, Value *RHS,
} }
} }
// TODO: Handle shufflevector here! // TODO: Handle shufflevector here!
return false; return false;
} }
@ -320,11 +319,11 @@ static bool CollectSingleShuffleElements(Value *V, Value *LHS, Value *RHS,
/// that computes V and the LHS value of the shuffle. /// that computes V and the LHS value of the shuffle.
static Value *CollectShuffleElements(Value *V, std::vector<Constant*> &Mask, static Value *CollectShuffleElements(Value *V, std::vector<Constant*> &Mask,
Value *&RHS) { Value *&RHS) {
assert(V->getType()->isVectorTy() && assert(V->getType()->isVectorTy() &&
(RHS == 0 || V->getType() == RHS->getType()) && (RHS == 0 || V->getType() == RHS->getType()) &&
"Invalid shuffle!"); "Invalid shuffle!");
unsigned NumElts = cast<VectorType>(V->getType())->getNumElements(); unsigned NumElts = cast<VectorType>(V->getType())->getNumElements();
if (isa<UndefValue>(V)) { if (isa<UndefValue>(V)) {
Mask.assign(NumElts, UndefValue::get(Type::getInt32Ty(V->getContext()))); Mask.assign(NumElts, UndefValue::get(Type::getInt32Ty(V->getContext())));
return V; return V;
@ -336,25 +335,25 @@ static Value *CollectShuffleElements(Value *V, std::vector<Constant*> &Mask,
Value *VecOp = IEI->getOperand(0); Value *VecOp = IEI->getOperand(0);
Value *ScalarOp = IEI->getOperand(1); Value *ScalarOp = IEI->getOperand(1);
Value *IdxOp = IEI->getOperand(2); Value *IdxOp = IEI->getOperand(2);
if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)) { if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)) {
if (isa<ConstantInt>(EI->getOperand(1)) && isa<ConstantInt>(IdxOp) && if (isa<ConstantInt>(EI->getOperand(1)) && isa<ConstantInt>(IdxOp) &&
EI->getOperand(0)->getType() == V->getType()) { EI->getOperand(0)->getType() == V->getType()) {
unsigned ExtractedIdx = unsigned ExtractedIdx =
cast<ConstantInt>(EI->getOperand(1))->getZExtValue(); cast<ConstantInt>(EI->getOperand(1))->getZExtValue();
unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue(); unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue();
// Either the extracted from or inserted into vector must be RHSVec, // Either the extracted from or inserted into vector must be RHSVec,
// otherwise we'd end up with a shuffle of three inputs. // otherwise we'd end up with a shuffle of three inputs.
if (EI->getOperand(0) == RHS || RHS == 0) { if (EI->getOperand(0) == RHS || RHS == 0) {
RHS = EI->getOperand(0); RHS = EI->getOperand(0);
Value *V = CollectShuffleElements(VecOp, Mask, RHS); Value *V = CollectShuffleElements(VecOp, Mask, RHS);
Mask[InsertedIdx % NumElts] = Mask[InsertedIdx % NumElts] =
ConstantInt::get(Type::getInt32Ty(V->getContext()), ConstantInt::get(Type::getInt32Ty(V->getContext()),
NumElts+ExtractedIdx); NumElts+ExtractedIdx);
return V; return V;
} }
if (VecOp == RHS) { if (VecOp == RHS) {
Value *V = CollectShuffleElements(EI->getOperand(0), Mask, RHS); Value *V = CollectShuffleElements(EI->getOperand(0), Mask, RHS);
// Everything but the extracted element is replaced with the RHS. // Everything but the extracted element is replaced with the RHS.
@ -365,7 +364,7 @@ static Value *CollectShuffleElements(Value *V, std::vector<Constant*> &Mask,
} }
return V; return V;
} }
// If this insertelement is a chain that comes from exactly these two // If this insertelement is a chain that comes from exactly these two
// vectors, return the vector and the effective shuffle. // vectors, return the vector and the effective shuffle.
if (CollectSingleShuffleElements(IEI, EI->getOperand(0), RHS, Mask)) if (CollectSingleShuffleElements(IEI, EI->getOperand(0), RHS, Mask))
@ -374,7 +373,7 @@ static Value *CollectShuffleElements(Value *V, std::vector<Constant*> &Mask,
} }
} }
// TODO: Handle shufflevector here! // TODO: Handle shufflevector here!
// Otherwise, can't do anything fancy. Return an identity vector. // Otherwise, can't do anything fancy. Return an identity vector.
for (unsigned i = 0; i != NumElts; ++i) for (unsigned i = 0; i != NumElts; ++i)
Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()), i)); Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()), i));
@ -385,12 +384,12 @@ Instruction *InstCombiner::visitInsertElementInst(InsertElementInst &IE) {
Value *VecOp = IE.getOperand(0); Value *VecOp = IE.getOperand(0);
Value *ScalarOp = IE.getOperand(1); Value *ScalarOp = IE.getOperand(1);
Value *IdxOp = IE.getOperand(2); Value *IdxOp = IE.getOperand(2);
// Inserting an undef or into an undefined place, remove this. // Inserting an undef or into an undefined place, remove this.
if (isa<UndefValue>(ScalarOp) || isa<UndefValue>(IdxOp)) if (isa<UndefValue>(ScalarOp) || isa<UndefValue>(IdxOp))
ReplaceInstUsesWith(IE, VecOp); ReplaceInstUsesWith(IE, VecOp);
// If the inserted element was extracted from some other vector, and if the // If the inserted element was extracted from some other vector, and if the
// indexes are constant, try to turn this into a shufflevector operation. // indexes are constant, try to turn this into a shufflevector operation.
if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)) { if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)) {
if (isa<ConstantInt>(EI->getOperand(1)) && isa<ConstantInt>(IdxOp) && if (isa<ConstantInt>(EI->getOperand(1)) && isa<ConstantInt>(IdxOp) &&
@ -399,18 +398,18 @@ Instruction *InstCombiner::visitInsertElementInst(InsertElementInst &IE) {
unsigned ExtractedIdx = unsigned ExtractedIdx =
cast<ConstantInt>(EI->getOperand(1))->getZExtValue(); cast<ConstantInt>(EI->getOperand(1))->getZExtValue();
unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue(); unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue();
if (ExtractedIdx >= NumVectorElts) // Out of range extract. if (ExtractedIdx >= NumVectorElts) // Out of range extract.
return ReplaceInstUsesWith(IE, VecOp); return ReplaceInstUsesWith(IE, VecOp);
if (InsertedIdx >= NumVectorElts) // Out of range insert. if (InsertedIdx >= NumVectorElts) // Out of range insert.
return ReplaceInstUsesWith(IE, UndefValue::get(IE.getType())); return ReplaceInstUsesWith(IE, UndefValue::get(IE.getType()));
// If we are extracting a value from a vector, then inserting it right // If we are extracting a value from a vector, then inserting it right
// back into the same place, just use the input vector. // back into the same place, just use the input vector.
if (EI->getOperand(0) == VecOp && ExtractedIdx == InsertedIdx) if (EI->getOperand(0) == VecOp && ExtractedIdx == InsertedIdx)
return ReplaceInstUsesWith(IE, VecOp); return ReplaceInstUsesWith(IE, VecOp);
// If this insertelement isn't used by some other insertelement, turn it // If this insertelement isn't used by some other insertelement, turn it
// (and any insertelements it points to), into one big shuffle. // (and any insertelements it points to), into one big shuffle.
if (!IE.hasOneUse() || !isa<InsertElementInst>(IE.use_back())) { if (!IE.hasOneUse() || !isa<InsertElementInst>(IE.use_back())) {
@ -424,13 +423,13 @@ Instruction *InstCombiner::visitInsertElementInst(InsertElementInst &IE) {
} }
} }
} }
unsigned VWidth = cast<VectorType>(VecOp->getType())->getNumElements(); unsigned VWidth = cast<VectorType>(VecOp->getType())->getNumElements();
APInt UndefElts(VWidth, 0); APInt UndefElts(VWidth, 0);
APInt AllOnesEltMask(APInt::getAllOnesValue(VWidth)); APInt AllOnesEltMask(APInt::getAllOnesValue(VWidth));
if (SimplifyDemandedVectorElts(&IE, AllOnesEltMask, UndefElts)) if (SimplifyDemandedVectorElts(&IE, AllOnesEltMask, UndefElts))
return &IE; return &IE;
return 0; return 0;
} }
@ -439,18 +438,18 @@ Instruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
Value *LHS = SVI.getOperand(0); Value *LHS = SVI.getOperand(0);
Value *RHS = SVI.getOperand(1); Value *RHS = SVI.getOperand(1);
std::vector<int> Mask = getShuffleMask(&SVI); std::vector<int> Mask = getShuffleMask(&SVI);
bool MadeChange = false; bool MadeChange = false;
// Undefined shuffle mask -> undefined value. // Undefined shuffle mask -> undefined value.
if (isa<UndefValue>(SVI.getOperand(2))) if (isa<UndefValue>(SVI.getOperand(2)))
return ReplaceInstUsesWith(SVI, UndefValue::get(SVI.getType())); return ReplaceInstUsesWith(SVI, UndefValue::get(SVI.getType()));
unsigned VWidth = cast<VectorType>(SVI.getType())->getNumElements(); unsigned VWidth = cast<VectorType>(SVI.getType())->getNumElements();
if (VWidth != cast<VectorType>(LHS->getType())->getNumElements()) if (VWidth != cast<VectorType>(LHS->getType())->getNumElements())
return 0; return 0;
APInt UndefElts(VWidth, 0); APInt UndefElts(VWidth, 0);
APInt AllOnesEltMask(APInt::getAllOnesValue(VWidth)); APInt AllOnesEltMask(APInt::getAllOnesValue(VWidth));
if (SimplifyDemandedVectorElts(&SVI, AllOnesEltMask, UndefElts)) { if (SimplifyDemandedVectorElts(&SVI, AllOnesEltMask, UndefElts)) {
@ -458,7 +457,7 @@ Instruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
RHS = SVI.getOperand(1); RHS = SVI.getOperand(1);
MadeChange = true; MadeChange = true;
} }
// Canonicalize shuffle(x ,x,mask) -> shuffle(x, undef,mask') // Canonicalize shuffle(x ,x,mask) -> shuffle(x, undef,mask')
// Canonicalize shuffle(undef,x,mask) -> shuffle(x, undef,mask'). // Canonicalize shuffle(undef,x,mask) -> shuffle(x, undef,mask').
if (LHS == RHS || isa<UndefValue>(LHS)) { if (LHS == RHS || isa<UndefValue>(LHS)) {
@ -466,7 +465,7 @@ Instruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
// shuffle(undef,undef,mask) -> undef. // shuffle(undef,undef,mask) -> undef.
return ReplaceInstUsesWith(SVI, LHS); return ReplaceInstUsesWith(SVI, LHS);
} }
// Remap any references to RHS to use LHS. // Remap any references to RHS to use LHS.
std::vector<Constant*> Elts; std::vector<Constant*> Elts;
for (unsigned i = 0, e = Mask.size(); i != e; ++i) { for (unsigned i = 0, e = Mask.size(); i != e; ++i) {
@ -491,23 +490,23 @@ Instruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
RHS = SVI.getOperand(1); RHS = SVI.getOperand(1);
MadeChange = true; MadeChange = true;
} }
// Analyze the shuffle, are the LHS or RHS and identity shuffles? // Analyze the shuffle, are the LHS or RHS and identity shuffles?
bool isLHSID = true, isRHSID = true; bool isLHSID = true, isRHSID = true;
for (unsigned i = 0, e = Mask.size(); i != e; ++i) { for (unsigned i = 0, e = Mask.size(); i != e; ++i) {
if (Mask[i] < 0) continue; // Ignore undef values. if (Mask[i] < 0) continue; // Ignore undef values.
// Is this an identity shuffle of the LHS value? // Is this an identity shuffle of the LHS value?
isLHSID &= (Mask[i] == (int)i); isLHSID &= (Mask[i] == (int)i);
// Is this an identity shuffle of the RHS value? // Is this an identity shuffle of the RHS value?
isRHSID &= (Mask[i]-e == i); isRHSID &= (Mask[i]-e == i);
} }
// Eliminate identity shuffles. // Eliminate identity shuffles.
if (isLHSID) return ReplaceInstUsesWith(SVI, LHS); if (isLHSID) return ReplaceInstUsesWith(SVI, LHS);
if (isRHSID) return ReplaceInstUsesWith(SVI, RHS); if (isRHSID) return ReplaceInstUsesWith(SVI, RHS);
// If the LHS is a shufflevector itself, see if we can combine it with this // If the LHS is a shufflevector itself, see if we can combine it with this
// one without producing an unusual shuffle. Here we are really conservative: // one without producing an unusual shuffle. Here we are really conservative:
// we are absolutely afraid of producing a shuffle mask not in the input // we are absolutely afraid of producing a shuffle mask not in the input
@ -520,7 +519,7 @@ Instruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
if (ShuffleVectorInst *LHSSVI = dyn_cast<ShuffleVectorInst>(LHS)) { if (ShuffleVectorInst *LHSSVI = dyn_cast<ShuffleVectorInst>(LHS)) {
if (isa<UndefValue>(RHS)) { if (isa<UndefValue>(RHS)) {
std::vector<int> LHSMask = getShuffleMask(LHSSVI); std::vector<int> LHSMask = getShuffleMask(LHSSVI);
if (LHSMask.size() == Mask.size()) { if (LHSMask.size() == Mask.size()) {
std::vector<int> NewMask; std::vector<int> NewMask;
bool isSplat = true; bool isSplat = true;
@ -539,7 +538,7 @@ Instruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
} }
NewMask.push_back(MaskElt); NewMask.push_back(MaskElt);
} }
// If the result mask is equal to the src shuffle or this // If the result mask is equal to the src shuffle or this
// shuffle mask, do the replacement. // shuffle mask, do the replacement.
if (isSplat || NewMask == LHSMask || NewMask == Mask) { if (isSplat || NewMask == LHSMask || NewMask == Mask) {
@ -559,7 +558,7 @@ Instruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
} }
} }
} }
return MadeChange ? &SVI : 0; return MadeChange ? &SVI : 0;
} }