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

SLPVectorizer: Strength reduce SmallVectors to ArrayRefs.

Browse Source 
Avoids a couple of copies and allows more flexibility in the clients.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@179935 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Benjamin Kramer
2013-04-20 09:49:10 +00:00
parent cd949714eb
commit 6fe5cc49d8
3 changed files with 28 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
lib/Transforms/Vectorize/SLPVectorizer.cpp
View File

@@ -128,7 +128,7 @@ private:
bool tryToVectorizePair(Value *A, Value *B, BoUpSLP &R); bool tryToVectorizePair(Value *A, Value *B, BoUpSLP &R);
/// \brief Try to vectorize a list of operands. /// \brief Try to vectorize a list of operands.
bool tryToVectorizeList(BoUpSLP::ValueList &VL, BoUpSLP &R); bool tryToVectorizeList(ArrayRef<Value *> VL, BoUpSLP &R);
/// \brief Try to vectorize a chain that may start at the operands of \V; /// \brief Try to vectorize a chain that may start at the operands of \V;
bool tryToVectorize(BinaryOperator *V, BoUpSLP &R); bool tryToVectorize(BinaryOperator *V, BoUpSLP &R);
@@ -174,13 +174,11 @@ unsigned SLPVectorizer::collectStores(BasicBlock *BB, BoUpSLP &R) {
bool SLPVectorizer::tryToVectorizePair(Value *A, Value *B, BoUpSLP &R) { bool SLPVectorizer::tryToVectorizePair(Value *A, Value *B, BoUpSLP &R) {
if (!A || !B) return false; if (!A || !B) return false;
BoUpSLP::ValueList VL; Value *VL[] = { A, B };
VL.push_back(A);
VL.push_back(B);
return tryToVectorizeList(VL, R); return tryToVectorizeList(VL, R);
} }
bool SLPVectorizer::tryToVectorizeList(BoUpSLP::ValueList &VL, BoUpSLP &R) { bool SLPVectorizer::tryToVectorizeList(ArrayRef<Value *> VL, BoUpSLP &R) {
DEBUG(dbgs()<<"SLP: Vectorizing a list of length = " << VL.size() << ".\n"); DEBUG(dbgs()<<"SLP: Vectorizing a list of length = " << VL.size() << ".\n");
int Cost = R.getTreeCost(VL); int Cost = R.getTreeCost(VL);
int ExtrCost = R.getScalarizationCost(VL); int ExtrCost = R.getScalarizationCost(VL);

24
lib/Transforms/Vectorize/VecUtils.cpp
View File

@@ -103,7 +103,7 @@ bool BoUpSLP::isConsecutiveAccess(Value *A, Value *B) {
return ((-Offset) == Sz); return ((-Offset) == Sz);
} }
bool BoUpSLP::vectorizeStoreChain(ValueList &Chain, int CostThreshold) { bool BoUpSLP::vectorizeStoreChain(ArrayRef<Value *> Chain, int CostThreshold) {
Type *StoreTy = cast<StoreInst>(Chain[0])->getValueOperand()->getType(); Type *StoreTy = cast<StoreInst>(Chain[0])->getValueOperand()->getType();
unsigned Sz = DL->getTypeSizeInBits(StoreTy); unsigned Sz = DL->getTypeSizeInBits(StoreTy);
unsigned VF = MinVecRegSize / Sz; unsigned VF = MinVecRegSize / Sz;
@@ -115,7 +115,7 @@ bool BoUpSLP::vectorizeStoreChain(ValueList &Chain, int CostThreshold) {
for (unsigned i = 0, e = Chain.size(); i < e; ++i) { for (unsigned i = 0, e = Chain.size(); i < e; ++i) {
if (i + VF > e) return Changed; if (i + VF > e) return Changed;
DEBUG(dbgs()<<"SLP: Analyzing " << VF << " stores at offset "<< i << "\n"); DEBUG(dbgs()<<"SLP: Analyzing " << VF << " stores at offset "<< i << "\n");
ValueList Operands(&Chain[i], &Chain[i] + VF); ArrayRef<Value *> Operands = Chain.slice(i, VF);
int Cost = getTreeCost(Operands); int Cost = getTreeCost(Operands);
DEBUG(dbgs() << "SLP: Found cost=" << Cost << " for VF=" << VF << "\n"); DEBUG(dbgs() << "SLP: Found cost=" << Cost << " for VF=" << VF << "\n");
@@ -130,7 +130,7 @@ bool BoUpSLP::vectorizeStoreChain(ValueList &Chain, int CostThreshold) {
return Changed; return Changed;
} }
bool BoUpSLP::vectorizeStores(StoreList &Stores, int costThreshold) { bool BoUpSLP::vectorizeStores(ArrayRef<StoreInst *> Stores, int costThreshold) {
ValueSet Heads, Tails; ValueSet Heads, Tails;
SmallDenseMap<Value*, Value*> ConsecutiveChain; SmallDenseMap<Value*, Value*> ConsecutiveChain;
@@ -178,7 +178,7 @@ bool BoUpSLP::vectorizeStores(StoreList &Stores, int costThreshold) {
return Changed; return Changed;
} }
int BoUpSLP::getScalarizationCost(ValueList &VL) { int BoUpSLP::getScalarizationCost(ArrayRef<Value *> VL) {
// Find the type of the operands in VL. // Find the type of the operands in VL.
Type *ScalarTy = VL[0]->getType(); Type *ScalarTy = VL[0]->getType();
if (StoreInst *SI = dyn_cast<StoreInst>(VL[0])) if (StoreInst *SI = dyn_cast<StoreInst>(VL[0]))
@@ -223,7 +223,7 @@ Value *BoUpSLP::isUnsafeToSink(Instruction *Src, Instruction *Dst) {
return 0; return 0;
} }
void BoUpSLP::vectorizeArith(ValueList &Operands) { void BoUpSLP::vectorizeArith(ArrayRef<Value *> Operands) {
Value *Vec = vectorizeTree(Operands, Operands.size()); Value *Vec = vectorizeTree(Operands, Operands.size());
BasicBlock::iterator Loc = cast<Instruction>(Vec); BasicBlock::iterator Loc = cast<Instruction>(Vec);
IRBuilder<> Builder(++Loc); IRBuilder<> Builder(++Loc);
@@ -236,7 +236,7 @@ void BoUpSLP::vectorizeArith(ValueList &Operands) {
} }
} }
int BoUpSLP::getTreeCost(ValueList &VL) { int BoUpSLP::getTreeCost(ArrayRef<Value *> VL) {
// Get rid of the list of stores that were removed, and from the // Get rid of the list of stores that were removed, and from the
// lists of instructions with multiple users. // lists of instructions with multiple users.
MemBarrierIgnoreList.clear(); MemBarrierIgnoreList.clear();
@@ -278,7 +278,7 @@ int BoUpSLP::getTreeCost(ValueList &VL) {
return getTreeCost_rec(VL, 0); return getTreeCost_rec(VL, 0);
} }
void BoUpSLP::getTreeUses_rec(ValueList &VL, unsigned Depth) { void BoUpSLP::getTreeUses_rec(ArrayRef<Value *> VL, unsigned Depth) {
if (Depth == RecursionMaxDepth) return; if (Depth == RecursionMaxDepth) return;
// Don't handle vectors. // Don't handle vectors.
@@ -367,7 +367,7 @@ void BoUpSLP::getTreeUses_rec(ValueList &VL, unsigned Depth) {
} }
} }
int BoUpSLP::getTreeCost_rec(ValueList &VL, unsigned Depth) { int BoUpSLP::getTreeCost_rec(ArrayRef<Value *> VL, unsigned Depth) {
Type *ScalarTy = VL[0]->getType(); Type *ScalarTy = VL[0]->getType();
if (StoreInst *SI = dyn_cast<StoreInst>(VL[0])) if (StoreInst *SI = dyn_cast<StoreInst>(VL[0]))
@@ -516,14 +516,14 @@ int BoUpSLP::getTreeCost_rec(ValueList &VL, unsigned Depth) {
} }
} }
Instruction *BoUpSLP::GetLastInstr(ValueList &VL, unsigned VF) { Instruction *BoUpSLP::GetLastInstr(ArrayRef<Value *> VL, unsigned VF) {
int MaxIdx = InstrIdx[BB->getFirstNonPHI()]; int MaxIdx = InstrIdx[BB->getFirstNonPHI()];
for (unsigned i = 0; i < VF; ++i ) for (unsigned i = 0; i < VF; ++i )
MaxIdx = std::max(MaxIdx, InstrIdx[VL[i]]); MaxIdx = std::max(MaxIdx, InstrIdx[VL[i]]);
return InstrVec[MaxIdx + 1]; return InstrVec[MaxIdx + 1];
} }
Value *BoUpSLP::Scalarize(ValueList &VL, VectorType *Ty) { Value *BoUpSLP::Scalarize(ArrayRef<Value *> VL, VectorType *Ty) {
IRBuilder<> Builder(GetLastInstr(VL, Ty->getNumElements())); IRBuilder<> Builder(GetLastInstr(VL, Ty->getNumElements()));
Value *Vec = UndefValue::get(Ty); Value *Vec = UndefValue::get(Ty);
for (unsigned i=0; i < Ty->getNumElements(); ++i) { for (unsigned i=0; i < Ty->getNumElements(); ++i) {
@@ -538,7 +538,7 @@ Value *BoUpSLP::Scalarize(ValueList &VL, VectorType *Ty) {
return Vec; return Vec;
} }
Value *BoUpSLP::vectorizeTree(ValueList &VL, int VF) { Value *BoUpSLP::vectorizeTree(ArrayRef<Value *> VL, int VF) {
Value *V = vectorizeTree_rec(VL, VF); Value *V = vectorizeTree_rec(VL, VF);
// We moved some instructions around. We have to number them again // We moved some instructions around. We have to number them again
// before we can do any analysis. // before we can do any analysis.
@@ -547,7 +547,7 @@ Value *BoUpSLP::vectorizeTree(ValueList &VL, int VF) {
return V; return V;
} }
Value *BoUpSLP::vectorizeTree_rec(ValueList &VL, int VF) { Value *BoUpSLP::vectorizeTree_rec(ArrayRef<Value *> VL, int VF) {
Type *ScalarTy = VL[0]->getType(); Type *ScalarTy = VL[0]->getType();
if (StoreInst *SI = dyn_cast<StoreInst>(VL[0])) if (StoreInst *SI = dyn_cast<StoreInst>(VL[0]))
ScalarTy = SI->getValueOperand()->getType(); ScalarTy = SI->getValueOperand()->getType();

26
lib/Transforms/Vectorize/VecUtils.h
View File

@@ -53,24 +53,24 @@ struct BoUpSLP {
/// \brief Vectorize the tree that starts with the elements in \p VL. /// \brief Vectorize the tree that starts with the elements in \p VL.
/// \returns the vectorized value. /// \returns the vectorized value.
Value *vectorizeTree(ValueList &VL, int VF); Value *vectorizeTree(ArrayRef<Value *> VL, int VF);
/// \returns the vectorization cost of the subtree that starts at \p VL. /// \returns the vectorization cost of the subtree that starts at \p VL.
/// A negative number means that this is profitable. /// A negative number means that this is profitable.
int getTreeCost(ValueList &VL); int getTreeCost(ArrayRef<Value *> VL);
/// \returns the scalarization cost for this ValueList. Assuming that this /// \returns the scalarization cost for this list of values. Assuming that
/// subtree gets vectorized, we may need to extract the values from the /// this subtree gets vectorized, we may need to extract the values from the
/// roots. This method calculates the cost of extracting the values. /// roots. This method calculates the cost of extracting the values.
int getScalarizationCost(ValueList &VL); int getScalarizationCost(ArrayRef<Value *> VL);
/// \brief Attempts to order and vectorize a sequence of stores. This /// \brief Attempts to order and vectorize a sequence of stores. This
/// function does a quadratic scan of the given stores. /// function does a quadratic scan of the given stores.
/// \returns true if the basic block was modified. /// \returns true if the basic block was modified.
bool vectorizeStores(StoreList &Stores, int costThreshold); bool vectorizeStores(ArrayRef<StoreInst *> Stores, int costThreshold);
/// \brief Vectorize a group of scalars into a vector tree. /// \brief Vectorize a group of scalars into a vector tree.
void vectorizeArith(ValueList &Operands); void vectorizeArith(ArrayRef<Value *> Operands);
/// \returns the list of new instructions that were added in order to collect /// \returns the list of new instructions that were added in order to collect
/// scalars into vectors. This list can be used to further optimize the gather /// scalars into vectors. This list can be used to further optimize the gather
@@ -79,21 +79,21 @@ struct BoUpSLP {
private: private:
/// \brief This method contains the recursive part of getTreeCost. /// \brief This method contains the recursive part of getTreeCost.
int getTreeCost_rec(ValueList &VL, unsigned Depth); int getTreeCost_rec(ArrayRef<Value *> VL, unsigned Depth);
/// \brief This recursive method looks for vectorization hazards such as /// \brief This recursive method looks for vectorization hazards such as
/// values that are used by multiple users and checks that values are used /// values that are used by multiple users and checks that values are used
/// by only one vector lane. It updates the variables LaneMap, MultiUserVals. /// by only one vector lane. It updates the variables LaneMap, MultiUserVals.
void getTreeUses_rec(ValueList &VL, unsigned Depth); void getTreeUses_rec(ArrayRef<Value *> VL, unsigned Depth);
/// \brief This method contains the recursive part of vectorizeTree. /// \brief This method contains the recursive part of vectorizeTree.
Value *vectorizeTree_rec(ValueList &VL, int VF); Value *vectorizeTree_rec(ArrayRef<Value *> VL, int VF);
/// \brief Number all of the instructions in the block. /// \brief Number all of the instructions in the block.
void numberInstructions(); void numberInstructions();
/// \brief Vectorize a sorted sequence of stores. /// \brief Vectorize a sorted sequence of stores.
bool vectorizeStoreChain(ValueList &Chain, int CostThreshold); bool vectorizeStoreChain(ArrayRef<Value *> Chain, int CostThreshold);
/// \returns the scalarization cost for this type. Scalarization in this /// \returns the scalarization cost for this type. Scalarization in this
/// context means the creation of vectors from a group of scalars. /// context means the creation of vectors from a group of scalars.
@@ -109,10 +109,10 @@ private:
/// \returns the instruction that appears last in the BB from \p VL. /// \returns the instruction that appears last in the BB from \p VL.
/// Only consider the first \p VF elements. /// Only consider the first \p VF elements.
Instruction *GetLastInstr(ValueList &VL, unsigned VF); Instruction *GetLastInstr(ArrayRef<Value *> VL, unsigned VF);
/// \returns a vector from a collection of scalars in \p VL. /// \returns a vector from a collection of scalars in \p VL.
Value *Scalarize(ValueList &VL, VectorType *Ty); Value *Scalarize(ArrayRef<Value *> VL, VectorType *Ty);
private: private:
/// Maps instructions to numbers and back. /// Maps instructions to numbers and back.