shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity

[TTI] Change new getVectorInstrCost overload to use const reference after D131114

Browse Source 
A const reference is preferred over a non-null const pointer.
`Type *` is kept as is to match the other overload.

Reviewed By: davidxl

Differential Revision: https://reviews.llvm.org/D131197
This commit is contained in:
Fangrui Song 2022-08-04 15:16:51 -07:00
parent a1a71b7dc9
commit 7d6017fd31
7 changed files with 22 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
llvm/include/llvm/Analysis/TargetTransformInfo.h
View File

@ -1178,7 +1178,7 @@ public:
///
/// A typical suitable use case is cost estimation when vector instruction
/// exists (e.g., from basic blocks during transformation).
InstructionCost getVectorInstrCost(const Instruction *I, Type *Val,
InstructionCost getVectorInstrCost(const Instruction &I, Type *Val,
unsigned Index = -1) const;
/// \return The cost of replication shuffle of \p VF elements typed \p EltTy
@ -1759,7 +1759,7 @@ public:
const Instruction *I) = 0;
virtual InstructionCost getVectorInstrCost(unsigned Opcode, Type *Val,
unsigned Index) = 0;
virtual InstructionCost getVectorInstrCost(const Instruction *I, Type *Val,
virtual InstructionCost getVectorInstrCost(const Instruction &I, Type *Val,
unsigned Index) = 0;
virtual InstructionCost
@ -2319,7 +2319,7 @@ public:
unsigned Index) override {
return Impl.getVectorInstrCost(Opcode, Val, Index);
}
InstructionCost getVectorInstrCost(const Instruction *I, Type *Val,
InstructionCost getVectorInstrCost(const Instruction &I, Type *Val,
unsigned Index) override {
return Impl.getVectorInstrCost(I, Val, Index);
}

6
llvm/include/llvm/Analysis/TargetTransformInfoImpl.h
View File

@ -575,7 +575,7 @@ public:
return 1;
}
InstructionCost getVectorInstrCost(const Instruction *I, Type *Val,
InstructionCost getVectorInstrCost(const Instruction &I, Type *Val,
unsigned Index) const {
return 1;
}
@ -1153,7 +1153,7 @@ public:
if (auto *CI = dyn_cast<ConstantInt>(IE->getOperand(2)))
if (CI->getValue().getActiveBits() <= 32)
Idx = CI->getZExtValue();
return TargetTTI->getVectorInstrCost(IE, Ty, Idx);
return TargetTTI->getVectorInstrCost(*IE, Ty, Idx);
}
case Instruction::ShuffleVector: {
auto *Shuffle = dyn_cast<ShuffleVectorInst>(U);
@ -1243,7 +1243,7 @@ public:
if (CI->getValue().getActiveBits() <= 32)
Idx = CI->getZExtValue();
Type *DstTy = U->getOperand(0)->getType();
return TargetTTI->getVectorInstrCost(EEI, DstTy, Idx);
return TargetTTI->getVectorInstrCost(*EEI, DstTy, Idx);
}
}
// By default, just classify everything as 'basic'.

4
llvm/include/llvm/CodeGen/BasicTTIImpl.h
View File

@ -1159,9 +1159,9 @@ public:
return LT.first;
}
InstructionCost getVectorInstrCost(const Instruction *I, Type *Val,
InstructionCost getVectorInstrCost(const Instruction &I, Type *Val,
unsigned Index) {
return thisT()->getVectorInstrCost(I->getOpcode(), Val, Index);
return thisT()->getVectorInstrCost(I.getOpcode(), Val, Index);
}
InstructionCost getReplicationShuffleCost(Type *EltTy, int ReplicationFactor,

3
llvm/lib/Analysis/TargetTransformInfo.cpp
View File

@ -877,10 +877,9 @@ InstructionCost TargetTransformInfo::getVectorInstrCost(unsigned Opcode,
return Cost;
}
InstructionCost TargetTransformInfo::getVectorInstrCost(const Instruction *I,
InstructionCost TargetTransformInfo::getVectorInstrCost(const Instruction &I,
Type *Val,
unsigned Index) const {
assert((I != nullptr) && "Expect not-null instruction pointer");
// FIXME: Assert that Opcode is either InsertElement or ExtractElement.
// This is mentioned in the interface description and respected by all
// callers, but never asserted upon.

2
llvm/lib/CodeGen/CodeGenPrepare.cpp
View File

@ -7261,7 +7261,7 @@ class VectorPromoteHelper {
// scalar to vector.
// The vector chain has to account for the combining cost.
InstructionCost ScalarCost =
TTI.getVectorInstrCost(Transition, PromotedType, Index);
TTI.getVectorInstrCost(*Transition, PromotedType, Index);
InstructionCost VectorCost = StoreExtractCombineCost;
enum TargetTransformInfo::TargetCostKind CostKind =
TargetTransformInfo::TCK_RecipThroughput;

6
llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
View File

@ -5882,7 +5882,7 @@ InstructionCost BoUpSLP::getEntryCost(const TreeEntry *E,
continue;
}
}
Cost -= TTIRef.getVectorInstrCost(EE, EE->getVectorOperandType(), Idx);
Cost -= TTIRef.getVectorInstrCost(*EE, EE->getVectorOperandType(), Idx);
}
// Add a cost for subvector extracts/inserts if required.
for (const auto &Data : ExtractVectorsTys) {
@ -6116,7 +6116,7 @@ InstructionCost BoUpSLP::getEntryCost(const TreeEntry *E,
if (ShuffleOrOp == Instruction::ExtractElement) {
auto *EE = cast<ExtractElementInst>(VL[I]);
CommonCost -= TTI->getVectorInstrCost(
EE, EE->getVectorOperandType(), *getExtractIndex(EE));
*EE, EE->getVectorOperandType(), *getExtractIndex(EE));
} else {
CommonCost -= TTI->getVectorInstrCost(Instruction::ExtractElement,
VecTy, Idx);
@ -6128,7 +6128,7 @@ InstructionCost BoUpSLP::getEntryCost(const TreeEntry *E,
if (ShuffleOrOp == Instruction::ExtractElement) {
auto *EE = cast<ExtractElementInst>(V);
CommonCost += TTI->getVectorInstrCost(
EE, EE->getVectorOperandType(), *getExtractIndex(EE));
*EE, EE->getVectorOperandType(), *getExtractIndex(EE));
} else {
--Idx;
CommonCost += TTI->getVectorInstrCost(Instruction::ExtractElement,

16
llvm/lib/Transforms/Vectorize/VectorCombine.cpp
View File

@ -270,8 +270,8 @@ ExtractElementInst *VectorCombine::getShuffleExtract(
Type *VecTy = Ext0->getVectorOperand()->getType();
assert(VecTy == Ext1->getVectorOperand()->getType() && "Need matching types");
InstructionCost Cost0 = TTI.getVectorInstrCost(Ext0, VecTy, Index0);
InstructionCost Cost1 = TTI.getVectorInstrCost(Ext1, VecTy, Index1);
InstructionCost Cost0 = TTI.getVectorInstrCost(*Ext0, VecTy, Index0);
InstructionCost Cost1 = TTI.getVectorInstrCost(*Ext1, VecTy, Index1);
// If both costs are invalid no shuffle is needed
if (!Cost0.isValid() && !Cost1.isValid())
@ -335,8 +335,10 @@ bool VectorCombine::isExtractExtractCheap(ExtractElementInst *Ext0,
unsigned Ext0Index = Ext0IndexC->getZExtValue();
unsigned Ext1Index = Ext1IndexC->getZExtValue();
InstructionCost Extract0Cost = TTI.getVectorInstrCost(Ext0, VecTy, Ext0Index);
InstructionCost Extract1Cost = TTI.getVectorInstrCost(Ext1, VecTy, Ext1Index);
InstructionCost Extract0Cost =
TTI.getVectorInstrCost(*Ext0, VecTy, Ext0Index);
InstructionCost Extract1Cost =
TTI.getVectorInstrCost(*Ext1, VecTy, Ext1Index);
// A more expensive extract will always be replaced by a splat shuffle.
// For example, if Ext0 is more expensive:
@ -750,8 +752,8 @@ bool VectorCombine::foldExtractedCmps(Instruction &I) {
if (!VecTy)
return false;
InstructionCost OldCost = TTI.getVectorInstrCost(Ext0, VecTy, Index0);
OldCost += TTI.getVectorInstrCost(Ext1, VecTy, Index1);
InstructionCost OldCost = TTI.getVectorInstrCost(*Ext0, VecTy, Index0);
OldCost += TTI.getVectorInstrCost(*Ext1, VecTy, Index1);
OldCost +=
TTI.getCmpSelInstrCost(CmpOpcode, I0->getType(),
CmpInst::makeCmpResultType(I0->getType()), Pred) *
@ -771,7 +773,7 @@ bool VectorCombine::foldExtractedCmps(Instruction &I) {
NewCost += TTI.getShuffleCost(TargetTransformInfo::SK_PermuteSingleSrc, CmpTy,
ShufMask);
NewCost += TTI.getArithmeticInstrCost(I.getOpcode(), CmpTy);
NewCost += TTI.getVectorInstrCost(Ext0, CmpTy, CheapIndex);
NewCost += TTI.getVectorInstrCost(*Ext0, CmpTy, CheapIndex);
// Aggressively form vector ops if the cost is equal because the transform
// may enable further optimization.