From 56243b89e7d5072d2d5498f806679d19ea483dac Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Thu, 26 Jan 2012 02:51:13 +0000 Subject: [PATCH] eliminate the Constant::getVectorElements method. There are better (and more robust) ways to do what it was doing now. Also, add static methods for decoding a ShuffleVector mask. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@149028 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Constant.h | 6 ---- include/llvm/Instructions.h | 12 ++++++-- .../SelectionDAG/SelectionDAGBuilder.cpp | 17 +++-------- lib/VMCore/ConstantFold.cpp | 20 ++++++------- lib/VMCore/Constants.cpp | 30 ------------------- lib/VMCore/Instructions.cpp | 16 +++++----- 6 files changed, 32 insertions(+), 69 deletions(-) diff --git a/include/llvm/Constant.h b/include/llvm/Constant.h index f7d4dd2d32a..11a02e080f9 100644 --- a/include/llvm/Constant.h +++ b/include/llvm/Constant.h @@ -91,12 +91,6 @@ public: /// FIXME: This really should not be in VMCore. PossibleRelocationsTy getRelocationInfo() const; - /// getVectorElements - This method, which is only valid on constant of vector - /// type, returns the elements of the vector in the specified smallvector. - /// This handles breaking down a vector undef into undef elements, etc. For - /// constant exprs and other cases we can't handle, we return an empty vector. - void getVectorElements(SmallVectorImpl &Elts) const; - /// getAggregateElement - For aggregates (struct/array/vector) return the /// constant that corresponds to the specified element if possible, or null if /// not. This can return null if the element index is a ConstantExpr, or if diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h index 35cb025e949..c27c6fa097f 100644 --- a/include/llvm/Instructions.h +++ b/include/llvm/Instructions.h @@ -1677,11 +1677,19 @@ public: /// getMaskValue - Return the index from the shuffle mask for the specified /// output result. This is either -1 if the element is undef or a number less /// than 2*numelements. - int getMaskValue(unsigned i) const; + static int getMaskValue(Constant *Mask, unsigned i); + + int getMaskValue(unsigned i) const { + return getMaskValue(getMask(), i); + } /// getShuffleMask - Return the full mask for this instruction, where each /// element is the element number and undef's are returned as -1. - void getShuffleMask(SmallVectorImpl &Mask) const; + static void getShuffleMask(Constant *Mask, SmallVectorImpl &Result); + + void getShuffleMask(SmallVectorImpl &Result) const { + return getShuffleMask(getMask(), Result); + } SmallVector getShuffleMask() const { SmallVector Mask; diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp index 7731f7c6b28..bc807dedc61 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp @@ -2806,22 +2806,13 @@ static bool isSequentialInRange(const SmallVectorImpl &Mask, } void SelectionDAGBuilder::visitShuffleVector(const User &I) { - SmallVector Mask; SDValue Src1 = getValue(I.getOperand(0)); SDValue Src2 = getValue(I.getOperand(1)); - // Convert the ConstantVector mask operand into an array of ints, with -1 - // representing undef values. - SmallVector MaskElts; - cast(I.getOperand(2))->getVectorElements(MaskElts); - unsigned MaskNumElts = MaskElts.size(); - for (unsigned i = 0; i != MaskNumElts; ++i) { - if (isa(MaskElts[i])) - Mask.push_back(-1); - else - Mask.push_back(cast(MaskElts[i])->getSExtValue()); - } - + SmallVector Mask; + ShuffleVectorInst::getShuffleMask(cast(I.getOperand(2)), Mask); + unsigned MaskNumElts = Mask.size(); + EVT VT = TLI.getValueType(I.getType()); EVT SrcVT = Src1.getValueType(); unsigned SrcNumElts = SrcVT.getVectorNumElements(); diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp index 9a3a99164e7..abc019ff4e0 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -1697,20 +1697,20 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, R==APFloat::cmpEqual); } } else if (C1->getType()->isVectorTy()) { - SmallVector C1Elts, C2Elts; - C1->getVectorElements(C1Elts); - C2->getVectorElements(C2Elts); - if (C1Elts.empty() || C2Elts.empty()) - return 0; - // If we can constant fold the comparison of each element, constant fold // the whole vector comparison. SmallVector ResElts; // Compare the elements, producing an i1 result or constant expr. - for (unsigned i = 0, e = C1Elts.size(); i != e; ++i) - ResElts.push_back(ConstantExpr::getCompare(pred, C1Elts[i], C2Elts[i])); - - return ConstantVector::get(ResElts); + for (unsigned i = 0, e = C1->getType()->getVectorNumElements(); i != e;++i){ + Constant *C1E = C1->getAggregateElement(i); + Constant *C2E = C2->getAggregateElement(i); + if (C1E == 0 || C2E == 0) break; + + ResElts.push_back(ConstantExpr::getCompare(pred, C1E, C2E)); + } + + if (ResElts.size() == C1->getType()->getVectorNumElements()) + return ConstantVector::get(ResElts); } if (C1->getType()->isFloatingPointTy()) { diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index f5239e15697..2530b63d8a1 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -312,36 +312,6 @@ Constant::PossibleRelocationsTy Constant::getRelocationInfo() const { return Result; } - -/// getVectorElements - This method, which is only valid on constant of vector -/// type, returns the elements of the vector in the specified smallvector. -/// This handles breaking down a vector undef into undef elements, etc. For -/// constant exprs and other cases we can't handle, we return an empty vector. -void Constant::getVectorElements(SmallVectorImpl &Elts) const { - assert(getType()->isVectorTy() && "Not a vector constant!"); - - if (const ConstantVector *CV = dyn_cast(this)) { - for (unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) - Elts.push_back(CV->getOperand(i)); - return; - } - - VectorType *VT = cast(getType()); - if (isa(this)) { - Elts.assign(VT->getNumElements(), - Constant::getNullValue(VT->getElementType())); - return; - } - - if (isa(this)) { - Elts.assign(VT->getNumElements(), UndefValue::get(VT->getElementType())); - return; - } - - // Unknown type, must be constant expr etc. -} - - /// removeDeadUsersOfConstant - If the specified constantexpr is dead, remove /// it. This involves recursively eliminating any dead users of the /// constantexpr. diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp index 1de7c01c0d5..a0fb91aada1 100644 --- a/lib/VMCore/Instructions.cpp +++ b/lib/VMCore/Instructions.cpp @@ -1625,11 +1625,11 @@ bool ShuffleVectorInst::isValidOperands(const Value *V1, const Value *V2, /// getMaskValue - Return the index from the shuffle mask for the specified /// output result. This is either -1 if the element is undef or a number less /// than 2*numelements. -int ShuffleVectorInst::getMaskValue(unsigned i) const { - assert(i < getType()->getNumElements() && "Index out of range"); - if (ConstantDataSequential *CDS =dyn_cast(getMask())) +int ShuffleVectorInst::getMaskValue(Constant *Mask, unsigned i) { + assert(i < Mask->getType()->getVectorNumElements() && "Index out of range"); + if (ConstantDataSequential *CDS =dyn_cast(Mask)) return CDS->getElementAsInteger(i); - Constant *C = getMask()->getAggregateElement(i); + Constant *C = Mask->getAggregateElement(i); if (isa(C)) return -1; return cast(C)->getZExtValue(); @@ -1637,15 +1637,15 @@ int ShuffleVectorInst::getMaskValue(unsigned i) const { /// getShuffleMask - Return the full mask for this instruction, where each /// element is the element number and undef's are returned as -1. -void ShuffleVectorInst::getShuffleMask(SmallVectorImpl &Result) const { - unsigned NumElts = getType()->getNumElements(); +void ShuffleVectorInst::getShuffleMask(Constant *Mask, + SmallVectorImpl &Result) { + unsigned NumElts = Mask->getType()->getVectorNumElements(); - if (ConstantDataSequential *CDS=dyn_cast(getMask())) { + if (ConstantDataSequential *CDS=dyn_cast(Mask)) { for (unsigned i = 0; i != NumElts; ++i) Result.push_back(CDS->getElementAsInteger(i)); return; } - Constant *Mask = getMask(); for (unsigned i = 0; i != NumElts; ++i) { Constant *C = Mask->getAggregateElement(i); Result.push_back(isa(C) ? -1 : -- 2.34.1