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
///
/// 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
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
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);
}
return 1;
}
- InstructionCost getVectorInstrCost(const Instruction *I, Type *Val,
+ InstructionCost getVectorInstrCost(const Instruction &I, Type *Val,
unsigned Index) const {
return 1;
}
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);
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'.
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,
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.
// 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;
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) {
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);
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,
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())
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:
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) *
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.