6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-02-07 14:33:15 +00:00
Code Issues Projects Releases Wiki Activity

Refactor the getTypeLegalizationCost interface. No functionality change.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@167422 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Nadav Rotem 2012-11-05 23:57:45 +00:00
parent 7ae3bcca45
commit 887c1fe701
3 changed files with 18 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/llvm/Target/TargetTransformImpl.h
View File

@ -55,8 +55,7 @@ protected:
const TargetLowering *TLI; const TargetLowering *TLI;
/// Estimate the cost of type-legalization and the legalized type. /// Estimate the cost of type-legalization and the legalized type.
std::pair<unsigned, MVT> std::pair<unsigned, MVT> getTypeLegalizationCost(Type *Ty) const;
getTypeLegalizationCost(LLVMContext &C, EVT Ty) const;
/// Estimate the overhead of scalarizing an instruction. Insert and Extract /// Estimate the overhead of scalarizing an instruction. Insert and Extract
/// are set if the result needs to be inserted and/or extracted from vectors. /// are set if the result needs to be inserted and/or extracted from vectors.

32
lib/Target/TargetTransformImpl.cpp
View File

@ -131,24 +131,27 @@ int VectorTargetTransformImpl::InstructionOpcodeToISD(unsigned Opcode) const {
} }
std::pair<unsigned, MVT> std::pair<unsigned, MVT>
VectorTargetTransformImpl::getTypeLegalizationCost(LLVMContext &C, VectorTargetTransformImpl::getTypeLegalizationCost(Type *Ty) const {
EVT Ty) const {
LLVMContext &C = Ty->getContext();
EVT MTy = TLI->getValueType(Ty);
unsigned Cost = 1; unsigned Cost = 1;
// We keep legalizing the type until we find a legal kind. We assume that // We keep legalizing the type until we find a legal kind. We assume that
// the only operation that costs anything is the split. After splitting // the only operation that costs anything is the split. After splitting
// we need to handle two types. // we need to handle two types.
while (true) { while (true) {
TargetLowering::LegalizeKind LK = TLI->getTypeConversion(C, Ty); TargetLowering::LegalizeKind LK = TLI->getTypeConversion(C, MTy);
if (LK.first == TargetLowering::TypeLegal) if (LK.first == TargetLowering::TypeLegal)
return std::make_pair(Cost, Ty.getSimpleVT()); return std::make_pair(Cost, MTy.getSimpleVT());
if (LK.first == TargetLowering::TypeSplitVector || if (LK.first == TargetLowering::TypeSplitVector ||
LK.first == TargetLowering::TypeExpandInteger) LK.first == TargetLowering::TypeExpandInteger)
Cost *= 2; Cost *= 2;
// Keep legalizing the type. // Keep legalizing the type.
Ty = LK.second; MTy = LK.second;
} }
} }
@ -175,8 +178,7 @@ unsigned VectorTargetTransformImpl::getArithmeticInstrCost(unsigned Opcode,
int ISD = InstructionOpcodeToISD(Opcode); int ISD = InstructionOpcodeToISD(Opcode);
assert(ISD && "Invalid opcode"); assert(ISD && "Invalid opcode");
std::pair<unsigned, MVT> LT = std::pair<unsigned, MVT> LT = getTypeLegalizationCost(Ty);
getTypeLegalizationCost(Ty->getContext(), TLI->getValueType(Ty));
if (!TLI->isOperationExpand(ISD, LT.second)) { if (!TLI->isOperationExpand(ISD, LT.second)) {
// The operation is legal. Assume it costs 1. Multiply // The operation is legal. Assume it costs 1. Multiply
@ -206,11 +208,8 @@ unsigned VectorTargetTransformImpl::getCastInstrCost(unsigned Opcode, Type *Dst,
int ISD = InstructionOpcodeToISD(Opcode); int ISD = InstructionOpcodeToISD(Opcode);
assert(ISD && "Invalid opcode"); assert(ISD && "Invalid opcode");
std::pair<unsigned, MVT> SrcLT = std::pair<unsigned, MVT> SrcLT = getTypeLegalizationCost(Src);
getTypeLegalizationCost(Src->getContext(), TLI->getValueType(Src)); std::pair<unsigned, MVT> DstLT = getTypeLegalizationCost(Dst);
std::pair<unsigned, MVT> DstLT =
getTypeLegalizationCost(Dst->getContext(), TLI->getValueType(Dst));
// Handle scalar conversions. // Handle scalar conversions.
if (!Src->isVectorTy() && !Dst->isVectorTy()) { if (!Src->isVectorTy() && !Dst->isVectorTy()) {
@ -292,8 +291,7 @@ unsigned VectorTargetTransformImpl::getCmpSelInstrCost(unsigned Opcode,
ISD = ISD::VSELECT; ISD = ISD::VSELECT;
} }
std::pair<unsigned, MVT> LT = std::pair<unsigned, MVT> LT = getTypeLegalizationCost(ValTy);
getTypeLegalizationCost(ValTy->getContext(), TLI->getValueType(ValTy));
if (!TLI->isOperationExpand(ISD, LT.second)) { if (!TLI->isOperationExpand(ISD, LT.second)) {
// The operation is legal. Assume it costs 1. Multiply // The operation is legal. Assume it costs 1. Multiply
@ -334,8 +332,7 @@ unsigned
VectorTargetTransformImpl::getMemoryOpCost(unsigned Opcode, Type *Src, VectorTargetTransformImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
unsigned Alignment, unsigned Alignment,
unsigned AddressSpace) const { unsigned AddressSpace) const {
std::pair<unsigned, MVT> LT = std::pair<unsigned, MVT> LT = getTypeLegalizationCost(Src);
getTypeLegalizationCost(Src->getContext(), TLI->getValueType(Src));
// Assume that all loads of legal types cost 1. // Assume that all loads of legal types cost 1.
return LT.first; return LT.first;
@ -343,7 +340,6 @@ VectorTargetTransformImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
unsigned unsigned
VectorTargetTransformImpl::getNumberOfParts(Type *Tp) const { VectorTargetTransformImpl::getNumberOfParts(Type *Tp) const {
std::pair<unsigned, MVT> LT = std::pair<unsigned, MVT> LT = getTypeLegalizationCost(Tp);
getTypeLegalizationCost(Tp->getContext(), TLI->getValueType(Tp));
return LT.first; return LT.first;
} }

9
lib/Target/X86/X86ISelLowering.cpp
View File

@ -17530,8 +17530,7 @@ unsigned
X86VectorTargetTransformInfo::getArithmeticInstrCost(unsigned Opcode, X86VectorTargetTransformInfo::getArithmeticInstrCost(unsigned Opcode,
Type *Ty) const { Type *Ty) const {
// Legalize the type. // Legalize the type.
std::pair<unsigned, MVT> LT = std::pair<unsigned, MVT> LT = getTypeLegalizationCost(Ty);
getTypeLegalizationCost(Ty->getContext(), TLI->getValueType(Ty));
int ISD = InstructionOpcodeToISD(Opcode); int ISD = InstructionOpcodeToISD(Opcode);
assert(ISD && "Invalid opcode"); assert(ISD && "Invalid opcode");
@ -17569,8 +17568,7 @@ X86VectorTargetTransformInfo::getVectorInstrCost(unsigned Opcode, Type *Val,
if (Index != -1U) { if (Index != -1U) {
// Legalize the type. // Legalize the type.
std::pair<unsigned, MVT> LT = std::pair<unsigned, MVT> LT = getTypeLegalizationCost(Val);
getTypeLegalizationCost(Val->getContext(), TLI->getValueType(Val));
// This type is legalized to a scalar type. // This type is legalized to a scalar type.
if (!LT.second.isVector()) if (!LT.second.isVector())
@ -17592,8 +17590,7 @@ unsigned X86VectorTargetTransformInfo::getCmpSelInstrCost(unsigned Opcode,
Type *ValTy, Type *ValTy,
Type *CondTy) const { Type *CondTy) const {
// Legalize the type. // Legalize the type.
std::pair<unsigned, MVT> LT = std::pair<unsigned, MVT> LT = getTypeLegalizationCost(ValTy);
getTypeLegalizationCost(ValTy->getContext(), TLI->getValueType(ValTy));
MVT MTy = LT.second; MVT MTy = LT.second;