forked from OSchip/llvm-project
Add a overload to CostTable which allows it to infer the size of the table.
Use it to avoid repeating ourselves too often. Also store MVT::SimpleValueType in the TTI tables so they can be statically initialized, MVT's constructors create bloated initialization code otherwise. llvm-svn: 188095
This commit is contained in:
Benjamin Kramer
parent
9111258ad7
commit
21585fd9c1
|
|
@ -25,18 +25,25 @@ struct CostTblEntry {
|
|||
unsigned Cost;
|
||||
};
|
||||
|
||||
/// Find in cost table, TypeTy must be comparable by ==
|
||||
template <class TypeTy>
|
||||
int CostTableLookup(const CostTblEntry<TypeTy> *Tbl,
|
||||
unsigned len, int ISD, TypeTy Ty) {
|
||||
/// Find in cost table, TypeTy must be comparable to CompareTy by ==
|
||||
template <class TypeTy, class CompareTy>
|
||||
int CostTableLookup(const CostTblEntry<TypeTy> *Tbl, unsigned len, int ISD,
|
||||
CompareTy Ty) {
|
||||
for (unsigned int i = 0; i < len; ++i)
|
||||
if (Tbl[i].ISD == ISD && Tbl[i].Type == Ty)
|
||||
if (ISD == Tbl[i].ISD && Ty == Tbl[i].Type)
|
||||
return i;
|
||||
|
||||
// Could not find an entry.
|
||||
return -1;
|
||||
}
|
||||
|
||||
/// Find in cost table, TypeTy must be comparable to CompareTy by ==
|
||||
template <class TypeTy, class CompareTy, unsigned N>
|
||||
int CostTableLookup(const CostTblEntry<TypeTy>(&Tbl)[N], int ISD,
|
||||
CompareTy Ty) {
|
||||
return CostTableLookup(Tbl, N, ISD, Ty);
|
||||
}
|
||||
|
||||
/// Type Conversion Cost Table
|
||||
template <class TypeTy>
|
||||
struct TypeConversionCostTblEntry {
|
||||
|
|
@ -46,18 +53,28 @@ struct TypeConversionCostTblEntry {
|
|||
unsigned Cost;
|
||||
};
|
||||
|
||||
/// Find in type conversion cost table, TypeTy must be comparable by ==
|
||||
template <class TypeTy>
|
||||
/// Find in type conversion cost table, TypeTy must be comparable to CompareTy
|
||||
/// by ==
|
||||
template <class TypeTy, class CompareTy>
|
||||
int ConvertCostTableLookup(const TypeConversionCostTblEntry<TypeTy> *Tbl,
|
||||
unsigned len, int ISD, TypeTy Dst, TypeTy Src) {
|
||||
unsigned len, int ISD, CompareTy Dst,
|
||||
CompareTy Src) {
|
||||
for (unsigned int i = 0; i < len; ++i)
|
||||
if (Tbl[i].ISD == ISD && Tbl[i].Src == Src && Tbl[i].Dst == Dst)
|
||||
if (ISD == Tbl[i].ISD && Src == Tbl[i].Src && Dst == Tbl[i].Dst)
|
||||
return i;
|
||||
|
||||
// Could not find an entry.
|
||||
return -1;
|
||||
}
|
||||
|
||||
/// Find in type conversion cost table, TypeTy must be comparable to CompareTy
|
||||
/// by ==
|
||||
template <class TypeTy, class CompareTy, unsigned N>
|
||||
int ConvertCostTableLookup(const TypeConversionCostTblEntry<TypeTy>(&Tbl)[N],
|
||||
int ISD, CompareTy Dst, CompareTy Src) {
|
||||
return ConvertCostTableLookup(Tbl, N, ISD, Dst, Src);
|
||||
}
|
||||
|
||||
} // namespace llvm
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -182,7 +182,7 @@ unsigned ARMTTI::getCastInstrCost(unsigned Opcode, Type *Dst,
|
|||
assert(ISD && "Invalid opcode");
|
||||
|
||||
// Single to/from double precision conversions.
|
||||
static const CostTblEntry<MVT> NEONFltDblTbl[] = {
|
||||
static const CostTblEntry<MVT::SimpleValueType> NEONFltDblTbl[] = {
|
||||
// Vector fptrunc/fpext conversions.
|
||||
{ ISD::FP_ROUND, MVT::v2f64, 2 },
|
||||
{ ISD::FP_EXTEND, MVT::v2f32, 2 },
|
||||
|
|
@ -192,8 +192,7 @@ unsigned ARMTTI::getCastInstrCost(unsigned Opcode, Type *Dst,
|
|||
if (Src->isVectorTy() && ST->hasNEON() && (ISD == ISD::FP_ROUND ||
|
||||
ISD == ISD::FP_EXTEND)) {
|
||||
std::pair<unsigned, MVT> LT = TLI->getTypeLegalizationCost(Src);
|
||||
int Idx = CostTableLookup<MVT>(NEONFltDblTbl, array_lengthof(NEONFltDblTbl),
|
||||
ISD, LT.second);
|
||||
int Idx = CostTableLookup(NEONFltDblTbl, ISD, LT.second);
|
||||
if (Idx != -1)
|
||||
return LT.first * NEONFltDblTbl[Idx].Cost;
|
||||
}
|
||||
|
|
@ -207,7 +206,8 @@ unsigned ARMTTI::getCastInstrCost(unsigned Opcode, Type *Dst,
|
|||
// Some arithmetic, load and store operations have specific instructions
|
||||
// to cast up/down their types automatically at no extra cost.
|
||||
// TODO: Get these tables to know at least what the related operations are.
|
||||
static const TypeConversionCostTblEntry<MVT> NEONVectorConversionTbl[] = {
|
||||
static const TypeConversionCostTblEntry<MVT::SimpleValueType>
|
||||
NEONVectorConversionTbl[] = {
|
||||
{ ISD::SIGN_EXTEND, MVT::v4i32, MVT::v4i16, 0 },
|
||||
{ ISD::ZERO_EXTEND, MVT::v4i32, MVT::v4i16, 0 },
|
||||
{ ISD::SIGN_EXTEND, MVT::v2i64, MVT::v2i32, 1 },
|
||||
|
|
@ -283,15 +283,15 @@ unsigned ARMTTI::getCastInstrCost(unsigned Opcode, Type *Dst,
|
|||
};
|
||||
|
||||
if (SrcTy.isVector() && ST->hasNEON()) {
|
||||
int Idx = ConvertCostTableLookup<MVT>(NEONVectorConversionTbl,
|
||||
array_lengthof(NEONVectorConversionTbl),
|
||||
ISD, DstTy.getSimpleVT(), SrcTy.getSimpleVT());
|
||||
int Idx = ConvertCostTableLookup(NEONVectorConversionTbl, ISD,
|
||||
DstTy.getSimpleVT(), SrcTy.getSimpleVT());
|
||||
if (Idx != -1)
|
||||
return NEONVectorConversionTbl[Idx].Cost;
|
||||
}
|
||||
|
||||
// Scalar float to integer conversions.
|
||||
static const TypeConversionCostTblEntry<MVT> NEONFloatConversionTbl[] = {
|
||||
static const TypeConversionCostTblEntry<MVT::SimpleValueType>
|
||||
NEONFloatConversionTbl[] = {
|
||||
{ ISD::FP_TO_SINT, MVT::i1, MVT::f32, 2 },
|
||||
{ ISD::FP_TO_UINT, MVT::i1, MVT::f32, 2 },
|
||||
{ ISD::FP_TO_SINT, MVT::i1, MVT::f64, 2 },
|
||||
|
|
@ -314,16 +314,15 @@ unsigned ARMTTI::getCastInstrCost(unsigned Opcode, Type *Dst,
|
|||
{ ISD::FP_TO_UINT, MVT::i64, MVT::f64, 10 }
|
||||
};
|
||||
if (SrcTy.isFloatingPoint() && ST->hasNEON()) {
|
||||
int Idx = ConvertCostTableLookup<MVT>(NEONFloatConversionTbl,
|
||||
array_lengthof(NEONFloatConversionTbl),
|
||||
ISD, DstTy.getSimpleVT(),
|
||||
SrcTy.getSimpleVT());
|
||||
int Idx = ConvertCostTableLookup(NEONFloatConversionTbl, ISD,
|
||||
DstTy.getSimpleVT(), SrcTy.getSimpleVT());
|
||||
if (Idx != -1)
|
||||
return NEONFloatConversionTbl[Idx].Cost;
|
||||
}
|
||||
|
||||
// Scalar integer to float conversions.
|
||||
static const TypeConversionCostTblEntry<MVT> NEONIntegerConversionTbl[] = {
|
||||
static const TypeConversionCostTblEntry<MVT::SimpleValueType>
|
||||
NEONIntegerConversionTbl[] = {
|
||||
{ ISD::SINT_TO_FP, MVT::f32, MVT::i1, 2 },
|
||||
{ ISD::UINT_TO_FP, MVT::f32, MVT::i1, 2 },
|
||||
{ ISD::SINT_TO_FP, MVT::f64, MVT::i1, 2 },
|
||||
|
|
@ -347,16 +346,15 @@ unsigned ARMTTI::getCastInstrCost(unsigned Opcode, Type *Dst,
|
|||
};
|
||||
|
||||
if (SrcTy.isInteger() && ST->hasNEON()) {
|
||||
int Idx = ConvertCostTableLookup<MVT>(NEONIntegerConversionTbl,
|
||||
array_lengthof(NEONIntegerConversionTbl),
|
||||
ISD, DstTy.getSimpleVT(),
|
||||
SrcTy.getSimpleVT());
|
||||
int Idx = ConvertCostTableLookup(NEONIntegerConversionTbl, ISD,
|
||||
DstTy.getSimpleVT(), SrcTy.getSimpleVT());
|
||||
if (Idx != -1)
|
||||
return NEONIntegerConversionTbl[Idx].Cost;
|
||||
}
|
||||
|
||||
// Scalar integer conversion costs.
|
||||
static const TypeConversionCostTblEntry<MVT> ARMIntegerConversionTbl[] = {
|
||||
static const TypeConversionCostTblEntry<MVT::SimpleValueType>
|
||||
ARMIntegerConversionTbl[] = {
|
||||
// i16 -> i64 requires two dependent operations.
|
||||
{ ISD::SIGN_EXTEND, MVT::i64, MVT::i16, 2 },
|
||||
|
||||
|
|
@ -368,11 +366,8 @@ unsigned ARMTTI::getCastInstrCost(unsigned Opcode, Type *Dst,
|
|||
};
|
||||
|
||||
if (SrcTy.isInteger()) {
|
||||
int Idx =
|
||||
ConvertCostTableLookup<MVT>(ARMIntegerConversionTbl,
|
||||
array_lengthof(ARMIntegerConversionTbl),
|
||||
ISD, DstTy.getSimpleVT(),
|
||||
SrcTy.getSimpleVT());
|
||||
int Idx = ConvertCostTableLookup(ARMIntegerConversionTbl, ISD,
|
||||
DstTy.getSimpleVT(), SrcTy.getSimpleVT());
|
||||
if (Idx != -1)
|
||||
return ARMIntegerConversionTbl[Idx].Cost;
|
||||
}
|
||||
|
|
@ -400,7 +395,8 @@ unsigned ARMTTI::getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
|
|||
// On NEON a a vector select gets lowered to vbsl.
|
||||
if (ST->hasNEON() && ValTy->isVectorTy() && ISD == ISD::SELECT) {
|
||||
// Lowering of some vector selects is currently far from perfect.
|
||||
static const TypeConversionCostTblEntry<MVT> NEONVectorSelectTbl[] = {
|
||||
static const TypeConversionCostTblEntry<MVT::SimpleValueType>
|
||||
NEONVectorSelectTbl[] = {
|
||||
{ ISD::SELECT, MVT::v16i1, MVT::v16i16, 2*16 + 1 + 3*1 + 4*1 },
|
||||
{ ISD::SELECT, MVT::v8i1, MVT::v8i32, 4*8 + 1*3 + 1*4 + 1*2 },
|
||||
{ ISD::SELECT, MVT::v16i1, MVT::v16i32, 4*16 + 1*6 + 1*8 + 1*4 },
|
||||
|
|
@ -412,9 +408,8 @@ unsigned ARMTTI::getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
|
|||
EVT SelCondTy = TLI->getValueType(CondTy);
|
||||
EVT SelValTy = TLI->getValueType(ValTy);
|
||||
if (SelCondTy.isSimple() && SelValTy.isSimple()) {
|
||||
int Idx = ConvertCostTableLookup<MVT>(NEONVectorSelectTbl,
|
||||
array_lengthof(NEONVectorSelectTbl),
|
||||
ISD, SelCondTy.getSimpleVT(),
|
||||
int Idx = ConvertCostTableLookup(NEONVectorSelectTbl, ISD,
|
||||
SelCondTy.getSimpleVT(),
|
||||
SelValTy.getSimpleVT());
|
||||
if (Idx != -1)
|
||||
return NEONVectorSelectTbl[Idx].Cost;
|
||||
|
|
@ -448,7 +443,7 @@ unsigned ARMTTI::getShuffleCost(ShuffleKind Kind, Type *Tp, int Index,
|
|||
if (Kind != SK_Reverse)
|
||||
return TargetTransformInfo::getShuffleCost(Kind, Tp, Index, SubTp);
|
||||
|
||||
static const CostTblEntry<MVT> NEONShuffleTbl[] = {
|
||||
static const CostTblEntry<MVT::SimpleValueType> NEONShuffleTbl[] = {
|
||||
// Reverse shuffle cost one instruction if we are shuffling within a double
|
||||
// word (vrev) or two if we shuffle a quad word (vrev, vext).
|
||||
{ ISD::VECTOR_SHUFFLE, MVT::v2i32, 1 },
|
||||
|
|
@ -464,8 +459,7 @@ unsigned ARMTTI::getShuffleCost(ShuffleKind Kind, Type *Tp, int Index,
|
|||
|
||||
std::pair<unsigned, MVT> LT = TLI->getTypeLegalizationCost(Tp);
|
||||
|
||||
int Idx = CostTableLookup<MVT>(NEONShuffleTbl, array_lengthof(NEONShuffleTbl),
|
||||
ISD::VECTOR_SHUFFLE, LT.second);
|
||||
int Idx = CostTableLookup(NEONShuffleTbl, ISD::VECTOR_SHUFFLE, LT.second);
|
||||
if (Idx == -1)
|
||||
return TargetTransformInfo::getShuffleCost(Kind, Tp, Index, SubTp);
|
||||
|
||||
|
|
@ -480,7 +474,7 @@ unsigned ARMTTI::getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueK
|
|||
|
||||
const unsigned FunctionCallDivCost = 20;
|
||||
const unsigned ReciprocalDivCost = 10;
|
||||
static const CostTblEntry<MVT> CostTbl[] = {
|
||||
static const CostTblEntry<MVT::SimpleValueType> CostTbl[] = {
|
||||
// Division.
|
||||
// These costs are somewhat random. Choose a cost of 20 to indicate that
|
||||
// vectorizing devision (added function call) is going to be very expensive.
|
||||
|
|
@ -524,8 +518,7 @@ unsigned ARMTTI::getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueK
|
|||
int Idx = -1;
|
||||
|
||||
if (ST->hasNEON())
|
||||
Idx = CostTableLookup<MVT>(CostTbl, array_lengthof(CostTbl), ISDOpcode,
|
||||
LT.second);
|
||||
Idx = CostTableLookup(CostTbl, ISDOpcode, LT.second);
|
||||
|
||||
if (Idx != -1)
|
||||
return LT.first * CostTbl[Idx].Cost;
|
||||
|
|
|
|||
|
|
@ -174,7 +174,7 @@ unsigned X86TTI::getArithmeticInstrCost(unsigned Opcode, Type *Ty,
|
|||
int ISD = TLI->InstructionOpcodeToISD(Opcode);
|
||||
assert(ISD && "Invalid opcode");
|
||||
|
||||
static const CostTblEntry<MVT> AVX2CostTable[] = {
|
||||
static const CostTblEntry<MVT::SimpleValueType> AVX2CostTable[] = {
|
||||
// Shifts on v4i64/v8i32 on AVX2 is legal even though we declare to
|
||||
// customize them to detect the cases where shift amount is a scalar one.
|
||||
{ ISD::SHL, MVT::v4i32, 1 },
|
||||
|
|
@ -211,13 +211,13 @@ unsigned X86TTI::getArithmeticInstrCost(unsigned Opcode, Type *Ty,
|
|||
|
||||
// Look for AVX2 lowering tricks.
|
||||
if (ST->hasAVX2()) {
|
||||
int Idx = CostTableLookup<MVT>(AVX2CostTable, array_lengthof(AVX2CostTable),
|
||||
ISD, LT.second);
|
||||
int Idx = CostTableLookup(AVX2CostTable, ISD, LT.second);
|
||||
if (Idx != -1)
|
||||
return LT.first * AVX2CostTable[Idx].Cost;
|
||||
}
|
||||
|
||||
static const CostTblEntry<MVT> SSE2UniformConstCostTable[] = {
|
||||
static const CostTblEntry<MVT::SimpleValueType>
|
||||
SSE2UniformConstCostTable[] = {
|
||||
// We don't correctly identify costs of casts because they are marked as
|
||||
// custom.
|
||||
// Constant splats are cheaper for the following instructions.
|
||||
|
|
@ -238,15 +238,13 @@ unsigned X86TTI::getArithmeticInstrCost(unsigned Opcode, Type *Ty,
|
|||
|
||||
if (Op2Info == TargetTransformInfo::OK_UniformConstantValue &&
|
||||
ST->hasSSE2()) {
|
||||
int Idx = CostTableLookup<MVT>(SSE2UniformConstCostTable,
|
||||
array_lengthof(SSE2UniformConstCostTable),
|
||||
ISD, LT.second);
|
||||
int Idx = CostTableLookup(SSE2UniformConstCostTable, ISD, LT.second);
|
||||
if (Idx != -1)
|
||||
return LT.first * SSE2UniformConstCostTable[Idx].Cost;
|
||||
}
|
||||
|
||||
|
||||
static const CostTblEntry<MVT> SSE2CostTable[] = {
|
||||
static const CostTblEntry<MVT::SimpleValueType> SSE2CostTable[] = {
|
||||
// We don't correctly identify costs of casts because they are marked as
|
||||
// custom.
|
||||
// For some cases, where the shift amount is a scalar we would be able
|
||||
|
|
@ -287,13 +285,12 @@ unsigned X86TTI::getArithmeticInstrCost(unsigned Opcode, Type *Ty,
|
|||
};
|
||||
|
||||
if (ST->hasSSE2()) {
|
||||
int Idx = CostTableLookup<MVT>(SSE2CostTable, array_lengthof(SSE2CostTable),
|
||||
ISD, LT.second);
|
||||
int Idx = CostTableLookup(SSE2CostTable, ISD, LT.second);
|
||||
if (Idx != -1)
|
||||
return LT.first * SSE2CostTable[Idx].Cost;
|
||||
}
|
||||
|
||||
static const CostTblEntry<MVT> AVX1CostTable[] = {
|
||||
static const CostTblEntry<MVT::SimpleValueType> AVX1CostTable[] = {
|
||||
// We don't have to scalarize unsupported ops. We can issue two half-sized
|
||||
// operations and we only need to extract the upper YMM half.
|
||||
// Two ops + 1 extract + 1 insert = 4.
|
||||
|
|
@ -312,21 +309,19 @@ unsigned X86TTI::getArithmeticInstrCost(unsigned Opcode, Type *Ty,
|
|||
|
||||
// Look for AVX1 lowering tricks.
|
||||
if (ST->hasAVX() && !ST->hasAVX2()) {
|
||||
int Idx = CostTableLookup<MVT>(AVX1CostTable, array_lengthof(AVX1CostTable),
|
||||
ISD, LT.second);
|
||||
int Idx = CostTableLookup(AVX1CostTable, ISD, LT.second);
|
||||
if (Idx != -1)
|
||||
return LT.first * AVX1CostTable[Idx].Cost;
|
||||
}
|
||||
|
||||
// Custom lowering of vectors.
|
||||
static const CostTblEntry<MVT> CustomLowered[] = {
|
||||
static const CostTblEntry<MVT::SimpleValueType> CustomLowered[] = {
|
||||
// A v2i64/v4i64 and multiply is custom lowered as a series of long
|
||||
// multiplies(3), shifts(4) and adds(2).
|
||||
{ ISD::MUL, MVT::v2i64, 9 },
|
||||
{ ISD::MUL, MVT::v4i64, 9 },
|
||||
};
|
||||
int Idx = CostTableLookup<MVT>(CustomLowered, array_lengthof(CustomLowered),
|
||||
ISD, LT.second);
|
||||
int Idx = CostTableLookup(CustomLowered, ISD, LT.second);
|
||||
if (Idx != -1)
|
||||
return LT.first * CustomLowered[Idx].Cost;
|
||||
|
||||
|
|
@ -363,7 +358,8 @@ unsigned X86TTI::getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src) const {
|
|||
std::pair<unsigned, MVT> LTSrc = TLI->getTypeLegalizationCost(Src);
|
||||
std::pair<unsigned, MVT> LTDest = TLI->getTypeLegalizationCost(Dst);
|
||||
|
||||
static const TypeConversionCostTblEntry<MVT> SSE2ConvTbl[] = {
|
||||
static const TypeConversionCostTblEntry<MVT::SimpleValueType>
|
||||
SSE2ConvTbl[] = {
|
||||
// These are somewhat magic numbers justified by looking at the output of
|
||||
// Intel's IACA, running some kernels and making sure when we take
|
||||
// legalization into account the throughput will be overestimated.
|
||||
|
|
@ -387,9 +383,8 @@ unsigned X86TTI::getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src) const {
|
|||
};
|
||||
|
||||
if (ST->hasSSE2() && !ST->hasAVX()) {
|
||||
int Idx = ConvertCostTableLookup<MVT>(SSE2ConvTbl,
|
||||
array_lengthof(SSE2ConvTbl),
|
||||
ISD, LTDest.second, LTSrc.second);
|
||||
int Idx =
|
||||
ConvertCostTableLookup(SSE2ConvTbl, ISD, LTDest.second, LTSrc.second);
|
||||
if (Idx != -1)
|
||||
return LTSrc.first * SSE2ConvTbl[Idx].Cost;
|
||||
}
|
||||
|
|
@ -401,7 +396,8 @@ unsigned X86TTI::getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src) const {
|
|||
if (!SrcTy.isSimple() || !DstTy.isSimple())
|
||||
return TargetTransformInfo::getCastInstrCost(Opcode, Dst, Src);
|
||||
|
||||
static const TypeConversionCostTblEntry<MVT> AVXConversionTbl[] = {
|
||||
static const TypeConversionCostTblEntry<MVT::SimpleValueType>
|
||||
AVXConversionTbl[] = {
|
||||
{ ISD::SIGN_EXTEND, MVT::v8i32, MVT::v8i16, 1 },
|
||||
{ ISD::ZERO_EXTEND, MVT::v8i32, MVT::v8i16, 1 },
|
||||
{ ISD::SIGN_EXTEND, MVT::v4i64, MVT::v4i32, 1 },
|
||||
|
|
@ -446,9 +442,8 @@ unsigned X86TTI::getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src) const {
|
|||
};
|
||||
|
||||
if (ST->hasAVX()) {
|
||||
int Idx = ConvertCostTableLookup<MVT>(AVXConversionTbl,
|
||||
array_lengthof(AVXConversionTbl),
|
||||
ISD, DstTy.getSimpleVT(), SrcTy.getSimpleVT());
|
||||
int Idx = ConvertCostTableLookup(AVXConversionTbl, ISD, DstTy.getSimpleVT(),
|
||||
SrcTy.getSimpleVT());
|
||||
if (Idx != -1)
|
||||
return AVXConversionTbl[Idx].Cost;
|
||||
}
|
||||
|
|
@ -466,7 +461,7 @@ unsigned X86TTI::getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
|
|||
int ISD = TLI->InstructionOpcodeToISD(Opcode);
|
||||
assert(ISD && "Invalid opcode");
|
||||
|
||||
static const CostTblEntry<MVT> SSE42CostTbl[] = {
|
||||
static const CostTblEntry<MVT::SimpleValueType> SSE42CostTbl[] = {
|
||||
{ ISD::SETCC, MVT::v2f64, 1 },
|
||||
{ ISD::SETCC, MVT::v4f32, 1 },
|
||||
{ ISD::SETCC, MVT::v2i64, 1 },
|
||||
|
|
@ -475,7 +470,7 @@ unsigned X86TTI::getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
|
|||
{ ISD::SETCC, MVT::v16i8, 1 },
|
||||
};
|
||||
|
||||
static const CostTblEntry<MVT> AVX1CostTbl[] = {
|
||||
static const CostTblEntry<MVT::SimpleValueType> AVX1CostTbl[] = {
|
||||
{ ISD::SETCC, MVT::v4f64, 1 },
|
||||
{ ISD::SETCC, MVT::v8f32, 1 },
|
||||
// AVX1 does not support 8-wide integer compare.
|
||||
|
|
@ -485,7 +480,7 @@ unsigned X86TTI::getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
|
|||
{ ISD::SETCC, MVT::v32i8, 4 },
|
||||
};
|
||||
|
||||
static const CostTblEntry<MVT> AVX2CostTbl[] = {
|
||||
static const CostTblEntry<MVT::SimpleValueType> AVX2CostTbl[] = {
|
||||
{ ISD::SETCC, MVT::v4i64, 1 },
|
||||
{ ISD::SETCC, MVT::v8i32, 1 },
|
||||
{ ISD::SETCC, MVT::v16i16, 1 },
|
||||
|
|
@ -493,22 +488,19 @@ unsigned X86TTI::getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
|
|||
};
|
||||
|
||||
if (ST->hasAVX2()) {
|
||||
int Idx = CostTableLookup<MVT>(AVX2CostTbl, array_lengthof(AVX2CostTbl),
|
||||
ISD, MTy);
|
||||
int Idx = CostTableLookup(AVX2CostTbl, ISD, MTy);
|
||||
if (Idx != -1)
|
||||
return LT.first * AVX2CostTbl[Idx].Cost;
|
||||
}
|
||||
|
||||
if (ST->hasAVX()) {
|
||||
int Idx = CostTableLookup<MVT>(AVX1CostTbl, array_lengthof(AVX1CostTbl),
|
||||
ISD, MTy);
|
||||
int Idx = CostTableLookup(AVX1CostTbl, ISD, MTy);
|
||||
if (Idx != -1)
|
||||
return LT.first * AVX1CostTbl[Idx].Cost;
|
||||
}
|
||||
|
||||
if (ST->hasSSE42()) {
|
||||
int Idx = CostTableLookup<MVT>(SSE42CostTbl, array_lengthof(SSE42CostTbl),
|
||||
ISD, MTy);
|
||||
int Idx = CostTableLookup(SSE42CostTbl, ISD, MTy);
|
||||
if (Idx != -1)
|
||||
return LT.first * SSE42CostTbl[Idx].Cost;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue