Skip to content

Commit d53e245

Browse files
alexey-bataevalexey-bataev
committed
[COST][NFC]Introduce OperandValueKind in getMemoryOpCost, NFC.
Added OperandValueKind OpdInfo parameter to getMemoryOpCost functions to better estimate cost with immediate values. Part of D126885.
1 parent d38985a commit d53e245

20 files changed

+117
-63
lines changed

‎llvm/include/llvm/Analysis/TargetTransformInfo.h

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1173,6 +1173,7 @@ class TargetTransformInfo {
11731173
getMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment,
11741174
unsigned AddressSpace,
11751175
TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput,
1176+
OperandValueKind OpdInfo = OK_AnyValue,
11761177
const Instruction *I = nullptr) const;
11771178

11781179
/// \return The cost of VP Load and Store instructions.
@@ -1740,11 +1741,10 @@ class TargetTransformInfo::Concept {
17401741
const APInt &DemandedDstElts,
17411742
TTI::TargetCostKind CostKind) = 0;
17421743

1743-
virtual InstructionCost getMemoryOpCost(unsigned Opcode, Type *Src,
1744-
Align Alignment,
1745-
unsigned AddressSpace,
1746-
TTI::TargetCostKind CostKind,
1747-
const Instruction *I) = 0;
1744+
virtual InstructionCost
1745+
getMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment,
1746+
unsigned AddressSpace, TTI::TargetCostKind CostKind,
1747+
OperandValueKind OpdInfo, const Instruction *I) = 0;
17481748
virtual InstructionCost getVPMemoryOpCost(unsigned Opcode, Type *Src,
17491749
Align Alignment,
17501750
unsigned AddressSpace,
@@ -2307,9 +2307,10 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept {
23072307
InstructionCost getMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment,
23082308
unsigned AddressSpace,
23092309
TTI::TargetCostKind CostKind,
2310+
OperandValueKind OpdInfo,
23102311
const Instruction *I) override {
2311-
return Impl.getMemoryOpCost(Opcode, Src, Alignment, AddressSpace,
2312-
CostKind, I);
2312+
return Impl.getMemoryOpCost(Opcode, Src, Alignment, AddressSpace, CostKind,
2313+
OpdInfo, I);
23132314
}
23142315
InstructionCost getVPMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment,
23152316
unsigned AddressSpace,

‎llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -595,6 +595,7 @@ class TargetTransformInfoImplBase {
595595
InstructionCost getMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment,
596596
unsigned AddressSpace,
597597
TTI::TargetCostKind CostKind,
598+
TTI::OperandValueKind OpdInfo,
598599
const Instruction *I) const {
599600
return 1;
600601
}
@@ -1099,9 +1100,11 @@ class TargetTransformInfoImplCRTPBase : public TargetTransformInfoImplBase {
10991100
case Instruction::Store: {
11001101
auto *SI = cast<StoreInst>(U);
11011102
Type *ValTy = U->getOperand(0)->getType();
1103+
TTI::OperandValueProperties OpVP = TTI::OP_None;
1104+
TTI::OperandValueKind OpVK = TTI::getOperandInfo(U->getOperand(0), OpVP);
11021105
return TargetTTI->getMemoryOpCost(Opcode, ValTy, SI->getAlign(),
1103-
SI->getPointerAddressSpace(),
1104-
CostKind, I);
1106+
SI->getPointerAddressSpace(), CostKind,
1107+
OpVK, I);
11051108
}
11061109
case Instruction::Load: {
11071110
// FIXME: Arbitary cost which could come from the backend.
@@ -1122,8 +1125,8 @@ class TargetTransformInfoImplCRTPBase : public TargetTransformInfoImplBase {
11221125
LoadType = TI->getDestTy();
11231126
}
11241127
return TargetTTI->getMemoryOpCost(Opcode, LoadType, LI->getAlign(),
1125-
LI->getPointerAddressSpace(),
1126-
CostKind, I);
1128+
LI->getPointerAddressSpace(), CostKind,
1129+
TTI::OK_AnyValue, I);
11271130
}
11281131
case Instruction::Select: {
11291132
const Value *Op0, *Op1;

‎llvm/include/llvm/CodeGen/BasicTTIImpl.h

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1221,10 +1221,11 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
12211221
return Cost;
12221222
}
12231223

1224-
InstructionCost getMemoryOpCost(unsigned Opcode, Type *Src,
1225-
MaybeAlign Alignment, unsigned AddressSpace,
1226-
TTI::TargetCostKind CostKind,
1227-
const Instruction *I = nullptr) {
1224+
InstructionCost
1225+
getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
1226+
unsigned AddressSpace, TTI::TargetCostKind CostKind,
1227+
TTI::OperandValueKind OpdInfo = TTI::OK_AnyValue,
1228+
const Instruction *I = nullptr) {
12281229
assert(!Src->isVoidTy() && "Invalid type");
12291230
// Assume types, such as structs, are expensive.
12301231
if (getTLI()->getValueType(DL, Src, true) == MVT::Other)

‎llvm/lib/Analysis/TargetTransformInfo.cpp

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -899,11 +899,12 @@ InstructionCost TargetTransformInfo::getReplicationShuffleCost(
899899

900900
InstructionCost TargetTransformInfo::getMemoryOpCost(
901901
unsigned Opcode, Type *Src, Align Alignment, unsigned AddressSpace,
902-
TTI::TargetCostKind CostKind, const Instruction *I) const {
902+
TTI::TargetCostKind CostKind, TTI::OperandValueKind OpdInfo,
903+
const Instruction *I) const {
903904
assert((I == nullptr || I->getOpcode() == Opcode) &&
904905
"Opcode should reflect passed instruction.");
905-
InstructionCost Cost = TTIImpl->getMemoryOpCost(Opcode, Src, Alignment,
906-
AddressSpace, CostKind, I);
906+
InstructionCost Cost = TTIImpl->getMemoryOpCost(
907+
Opcode, Src, Alignment, AddressSpace, CostKind, OpdInfo, I);
907908
assert(Cost >= 0 && "TTI should not produce negative costs!");
908909
return Cost;
909910
}

‎llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2249,7 +2249,8 @@ InstructionCost AArch64TTIImpl::getGatherScatterOpCost(
22492249

22502250
ElementCount LegalVF = LT.second.getVectorElementCount();
22512251
InstructionCost MemOpCost =
2252-
getMemoryOpCost(Opcode, VT->getElementType(), Alignment, 0, CostKind, I);
2252+
getMemoryOpCost(Opcode, VT->getElementType(), Alignment, 0, CostKind,
2253+
TTI::OK_AnyValue, I);
22532254
// Add on an overhead cost for using gathers/scatters.
22542255
// TODO: At the moment this is applied unilaterally for all CPUs, but at some
22552256
// point we may want a per-CPU overhead.
@@ -2265,6 +2266,7 @@ InstructionCost AArch64TTIImpl::getMemoryOpCost(unsigned Opcode, Type *Ty,
22652266
MaybeAlign Alignment,
22662267
unsigned AddressSpace,
22672268
TTI::TargetCostKind CostKind,
2269+
TTI::OperandValueKind OpdInfo,
22682270
const Instruction *I) {
22692271
EVT VT = TLI->getValueType(DL, Ty, true);
22702272
// Type legalization can't handle structs

‎llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -208,10 +208,11 @@ class AArch64TTIImpl : public BasicTTIImplBase<AArch64TTIImpl> {
208208
bool IsZeroCmp) const;
209209
bool useNeonVector(const Type *Ty) const;
210210

211-
InstructionCost getMemoryOpCost(unsigned Opcode, Type *Src,
212-
MaybeAlign Alignment, unsigned AddressSpace,
213-
TTI::TargetCostKind CostKind,
214-
const Instruction *I = nullptr);
211+
InstructionCost
212+
getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
213+
unsigned AddressSpace, TTI::TargetCostKind CostKind,
214+
TTI::OperandValueKind OpdInfo = TTI::OK_AnyValue,
215+
const Instruction *I = nullptr);
215216

216217
InstructionCost getCostOfKeepingLiveOverCall(ArrayRef<Type *> Tys);
217218

‎llvm/lib/Target/ARM/ARMTargetTransformInfo.cpp

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1450,6 +1450,7 @@ InstructionCost ARMTTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
14501450
MaybeAlign Alignment,
14511451
unsigned AddressSpace,
14521452
TTI::TargetCostKind CostKind,
1453+
TTI::OperandValueKind OpdInfo,
14531454
const Instruction *I) {
14541455
// TODO: Handle other cost kinds.
14551456
if (CostKind != TTI::TCK_RecipThroughput)
@@ -1489,7 +1490,7 @@ InstructionCost ARMTTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
14891490
? ST->getMVEVectorCostFactor(CostKind)
14901491
: 1;
14911492
return BaseCost * BaseT::getMemoryOpCost(Opcode, Src, Alignment, AddressSpace,
1492-
CostKind, I);
1493+
CostKind, OpdInfo, I);
14931494
}
14941495

14951496
InstructionCost

‎llvm/lib/Target/ARM/ARMTargetTransformInfo.h

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -253,10 +253,11 @@ class ARMTTIImpl : public BasicTTIImplBase<ARMTTIImpl> {
253253
ArrayRef<const Value *> Args = ArrayRef<const Value *>(),
254254
const Instruction *CxtI = nullptr);
255255

256-
InstructionCost getMemoryOpCost(unsigned Opcode, Type *Src,
257-
MaybeAlign Alignment, unsigned AddressSpace,
258-
TTI::TargetCostKind CostKind,
259-
const Instruction *I = nullptr);
256+
InstructionCost
257+
getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
258+
unsigned AddressSpace, TTI::TargetCostKind CostKind,
259+
TTI::OperandValueKind OpdInfo = TTI::OK_AnyValue,
260+
const Instruction *I = nullptr);
260261

261262
InstructionCost getMaskedMemoryOpCost(unsigned Opcode, Type *Src,
262263
Align Alignment, unsigned AddressSpace,

‎llvm/lib/Target/Hexagon/HexagonTargetTransformInfo.cpp

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -161,6 +161,7 @@ InstructionCost HexagonTTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
161161
MaybeAlign Alignment,
162162
unsigned AddressSpace,
163163
TTI::TargetCostKind CostKind,
164+
TTI::OperandValueKind OpdInfo,
164165
const Instruction *I) {
165166
assert(Opcode == Instruction::Load || Opcode == Instruction::Store);
166167
// TODO: Handle other cost kinds.
@@ -169,7 +170,7 @@ InstructionCost HexagonTTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
169170

170171
if (Opcode == Instruction::Store)
171172
return BaseT::getMemoryOpCost(Opcode, Src, Alignment, AddressSpace,
172-
CostKind, I);
173+
CostKind, OpdInfo, I);
173174

174175
if (Src->isVectorTy()) {
175176
VectorType *VecTy = cast<VectorType>(Src);
@@ -209,8 +210,8 @@ InstructionCost HexagonTTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
209210
return (3 - LogA) * Cost * NumLoads;
210211
}
211212

212-
return BaseT::getMemoryOpCost(Opcode, Src, Alignment, AddressSpace,
213-
CostKind, I);
213+
return BaseT::getMemoryOpCost(Opcode, Src, Alignment, AddressSpace, CostKind,
214+
OpdInfo, I);
214215
}
215216

216217
InstructionCost

‎llvm/lib/Target/Hexagon/HexagonTargetTransformInfo.h

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -116,10 +116,11 @@ class HexagonTTIImpl : public BasicTTIImplBase<HexagonTTIImpl> {
116116
TTI::TargetCostKind CostKind);
117117
InstructionCost getAddressComputationCost(Type *Tp, ScalarEvolution *SE,
118118
const SCEV *S);
119-
InstructionCost getMemoryOpCost(unsigned Opcode, Type *Src,
120-
MaybeAlign Alignment, unsigned AddressSpace,
121-
TTI::TargetCostKind CostKind,
122-
const Instruction *I = nullptr);
119+
InstructionCost
120+
getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
121+
unsigned AddressSpace, TTI::TargetCostKind CostKind,
122+
TTI::OperandValueKind OpdInfo = TTI::OK_AnyValue,
123+
const Instruction *I = nullptr);
123124
InstructionCost getMaskedMemoryOpCost(unsigned Opcode, Type *Src,
124125
Align Alignment, unsigned AddressSpace,
125126
TTI::TargetCostKind CostKind);

‎llvm/lib/Target/PowerPC/PPCTargetTransformInfo.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1145,6 +1145,7 @@ InstructionCost PPCTTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
11451145
MaybeAlign Alignment,
11461146
unsigned AddressSpace,
11471147
TTI::TargetCostKind CostKind,
1148+
TTI::OperandValueKind OpdInfo,
11481149
const Instruction *I) {
11491150

11501151
InstructionCost CostFactor = vectorCostAdjustmentFactor(Opcode, Src, nullptr);

‎llvm/lib/Target/PowerPC/PPCTargetTransformInfo.h

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -127,10 +127,11 @@ class PPCTTIImpl : public BasicTTIImplBase<PPCTTIImpl> {
127127
using BaseT::getVectorInstrCost;
128128
InstructionCost getVectorInstrCost(unsigned Opcode, Type *Val,
129129
unsigned Index);
130-
InstructionCost getMemoryOpCost(unsigned Opcode, Type *Src,
131-
MaybeAlign Alignment, unsigned AddressSpace,
132-
TTI::TargetCostKind CostKind,
133-
const Instruction *I = nullptr);
130+
InstructionCost
131+
getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
132+
unsigned AddressSpace, TTI::TargetCostKind CostKind,
133+
TTI::OperandValueKind OpdInfo = TTI::OK_AnyValue,
134+
const Instruction *I = nullptr);
134135
InstructionCost getInterleavedMemoryOpCost(
135136
unsigned Opcode, Type *VecTy, unsigned Factor, ArrayRef<unsigned> Indices,
136137
Align Alignment, unsigned AddressSpace, TTI::TargetCostKind CostKind,

‎llvm/lib/Target/RISCV/RISCVTargetTransformInfo.cpp

Lines changed: 13 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -243,8 +243,9 @@ InstructionCost RISCVTTIImpl::getGatherScatterOpCost(
243243
// scalable vectors, we use an estimate on that number since we don't
244244
// know exactly what VL will be.
245245
auto &VTy = *cast<VectorType>(DataTy);
246-
InstructionCost MemOpCost = getMemoryOpCost(Opcode, VTy.getElementType(),
247-
Alignment, 0, CostKind, I);
246+
InstructionCost MemOpCost =
247+
getMemoryOpCost(Opcode, VTy.getElementType(), Alignment, 0, CostKind,
248+
TTI::OK_AnyValue, I);
248249
unsigned NumLoads = getEstimatedVLFor(&VTy);
249250
return NumLoads * MemOpCost;
250251
}
@@ -433,6 +434,16 @@ InstructionCost RISCVTTIImpl::getExtendedReductionCost(
433434
getArithmeticReductionCost(Opcode, ValTy, FMF, CostKind);
434435
}
435436

437+
InstructionCost RISCVTTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
438+
MaybeAlign Alignment,
439+
unsigned AddressSpace,
440+
TTI::TargetCostKind CostKind,
441+
TTI::OperandValueKind OpdInfo,
442+
const Instruction *I) {
443+
return BaseT::getMemoryOpCost(Opcode, Src, Alignment, AddressSpace, CostKind,
444+
OpdInfo, I);
445+
}
446+
436447
void RISCVTTIImpl::getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
437448
TTI::UnrollingPreferences &UP,
438449
OptimizationRemarkEmitter *ORE) {

‎llvm/lib/Target/RISCV/RISCVTargetTransformInfo.h

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -125,6 +125,12 @@ class RISCVTTIImpl : public BasicTTIImplBase<RISCVTTIImpl> {
125125
Optional<FastMathFlags> FMF,
126126
TTI::TargetCostKind CostKind);
127127

128+
InstructionCost
129+
getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
130+
unsigned AddressSpace, TTI::TargetCostKind CostKind,
131+
TTI::OperandValueKind OpdInfo = TTI::OK_AnyValue,
132+
const Instruction *I = nullptr);
133+
128134
bool isElementTypeLegalForScalableVector(Type *Ty) const {
129135
return TLI->isLegalElementTypeForRVV(Ty);
130136
}

‎llvm/lib/Target/SystemZ/SystemZTargetTransformInfo.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1109,6 +1109,7 @@ InstructionCost SystemZTTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
11091109
MaybeAlign Alignment,
11101110
unsigned AddressSpace,
11111111
TTI::TargetCostKind CostKind,
1112+
TTI::OperandValueKind OpdInfo,
11121113
const Instruction *I) {
11131114
assert(!Src->isVoidTy() && "Invalid type");
11141115

‎llvm/lib/Target/SystemZ/SystemZTargetTransformInfo.h

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -111,10 +111,11 @@ class SystemZTTIImpl : public BasicTTIImplBase<SystemZTTIImpl> {
111111
InstructionCost getVectorInstrCost(unsigned Opcode, Type *Val,
112112
unsigned Index);
113113
bool isFoldableLoad(const LoadInst *Ld, const Instruction *&FoldedValue);
114-
InstructionCost getMemoryOpCost(unsigned Opcode, Type *Src,
115-
MaybeAlign Alignment, unsigned AddressSpace,
116-
TTI::TargetCostKind CostKind,
117-
const Instruction *I = nullptr);
114+
InstructionCost
115+
getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
116+
unsigned AddressSpace, TTI::TargetCostKind CostKind,
117+
TTI::OperandValueKind OpdInfo = TTI::OK_AnyValue,
118+
const Instruction *I = nullptr);
118119

119120
InstructionCost getInterleavedMemoryOpCost(
120121
unsigned Opcode, Type *VecTy, unsigned Factor, ArrayRef<unsigned> Indices,

‎llvm/lib/Target/X86/X86TargetTransformInfo.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4050,6 +4050,7 @@ InstructionCost X86TTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
40504050
MaybeAlign Alignment,
40514051
unsigned AddressSpace,
40524052
TTI::TargetCostKind CostKind,
4053+
TTI::OperandValueKind OpdInfo,
40534054
const Instruction *I) {
40544055
// TODO: Handle other cost kinds.
40554056
if (CostKind != TTI::TCK_RecipThroughput) {

‎llvm/lib/Target/X86/X86TargetTransformInfo.h

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -156,10 +156,11 @@ class X86TTIImpl : public BasicTTIImplBase<X86TTIImpl> {
156156
int VF,
157157
const APInt &DemandedDstElts,
158158
TTI::TargetCostKind CostKind);
159-
InstructionCost getMemoryOpCost(unsigned Opcode, Type *Src,
160-
MaybeAlign Alignment, unsigned AddressSpace,
161-
TTI::TargetCostKind CostKind,
162-
const Instruction *I = nullptr);
159+
InstructionCost
160+
getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
161+
unsigned AddressSpace, TTI::TargetCostKind CostKind,
162+
TTI::OperandValueKind OpdInfo = TTI::OK_AnyValue,
163+
const Instruction *I = nullptr);
163164
InstructionCost getMaskedMemoryOpCost(unsigned Opcode, Type *Src,
164165
Align Alignment, unsigned AddressSpace,
165166
TTI::TargetCostKind CostKind);

‎llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

Lines changed: 9 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -6394,12 +6394,15 @@ LoopVectorizationCostModel::getConsecutiveMemOpCost(Instruction *I,
63946394
"Stride should be 1 or -1 for consecutive memory access");
63956395
const Align Alignment = getLoadStoreAlignment(I);
63966396
InstructionCost Cost = 0;
6397-
if (Legal->isMaskRequired(I))
6397+
if (Legal->isMaskRequired(I)) {
63986398
Cost += TTI.getMaskedMemoryOpCost(I->getOpcode(), VectorTy, Alignment, AS,
63996399
CostKind);
6400-
else
6400+
} else {
6401+
TTI::OperandValueProperties OpVP = TTI::OP_None;
6402+
TTI::OperandValueKind OpVK = TTI::getOperandInfo(I->getOperand(0), OpVP);
64016403
Cost += TTI.getMemoryOpCost(I->getOpcode(), VectorTy, Alignment, AS,
6402-
CostKind, I);
6404+
CostKind, OpVK, I);
6405+
}
64036406

64046407
bool Reverse = ConsecutiveStride < 0;
64056408
if (Reverse)
@@ -6676,9 +6679,11 @@ LoopVectorizationCostModel::getMemoryInstructionCost(Instruction *I,
66766679
const Align Alignment = getLoadStoreAlignment(I);
66776680
unsigned AS = getLoadStoreAddressSpace(I);
66786681

6682+
TTI::OperandValueProperties OpVP = TTI::OP_None;
6683+
TTI::OperandValueKind OpVK = TTI::getOperandInfo(I->getOperand(0), OpVP);
66796684
return TTI.getAddressComputationCost(ValTy) +
66806685
TTI.getMemoryOpCost(I->getOpcode(), ValTy, Alignment, AS,
6681-
TTI::TCK_RecipThroughput, I);
6686+
TTI::TCK_RecipThroughput, OpVK, I);
66826687
}
66836688
return getWideningCost(I, VF);
66846689
}

0 commit comments

Comments
 (0)