Lines Matching defs:LT

663     std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(Src);
664     if (const auto *Entry = CostTableLookup(NEONFltDblTbl, ISD, LT.second))
665       return AdjustCost(LT.first * Entry->Cost);
932     std::pair<InstructionCost, MVT> LT =
934     return LT.first * (ValTy->getScalarType()->isIntegerTy() ? 4 : 1);
1034     std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(ValTy);
1035     return LT.first;
1060     std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(ValTy);
1067     if (LT.second.isVector() && LT.second.getVectorNumElements() > 2) {
1068       if (LT.first > 1)
1069         return LT.first * BaseCost +
1260       std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(Tp);
1262               CostTableLookup(NEONDupTbl, ISD::VECTOR_SHUFFLE, LT.second))
1263         return LT.first * Entry->Cost;
1281       std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(Tp);
1283               CostTableLookup(NEONShuffleTbl, ISD::VECTOR_SHUFFLE, LT.second))
1284         return LT.first * Entry->Cost;
1305       std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(Tp);
1307                                               ISD::VECTOR_SHUFFLE, LT.second))
1308         return LT.first * Entry->Cost;
1321       std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(Tp);
1323                                               LT.second))
1324         return LT.first * Entry->Cost *
1329       std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(Tp);
1330       if (LT.second.isVector() &&
1331           Mask.size() <= LT.second.getVectorNumElements() &&
1332           (isVREVMask(Mask, LT.second, 16) || isVREVMask(Mask, LT.second, 32) ||
1333            isVREVMask(Mask, LT.second, 64)))
1334         return ST->getMVEVectorCostFactor(TTI::TCK_RecipThroughput) * LT.first;
1369   std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(Ty);
1415     if (const auto *Entry = CostTableLookup(CostTbl, ISDOpcode, LT.second))
1416       return LT.first * Entry->Cost;
1428     if (LT.second == MVT::v2i64 && Op2Info.isUniform() && Op2Info.isConstant())
1471   if (TLI->isOperationLegalOrCustomOrPromote(ISDOpcode, LT.second))
1472     return LT.first * BaseCost;
1509     std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(Src);
1510     return LT.first * 4;
1610   std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(DataTy);
1618       NumElems * LT.first * ST->getMVEVectorCostFactor(CostKind);
1624       NumElems * LT.first + (VariableMask ? NumElems * 5 : 0) +
1772   std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(ValTy);
1779   if (const auto *Entry = CostTableLookup(CostTblAdd, ISD, LT.second))
1780     return Entry->Cost * ST->getMVEVectorCostFactor(CostKind) * LT.first;
1796       std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(ValTy);
1806           ((LT.second == MVT::v16i8 && RevVTSize <= 32) ||
1807            (LT.second == MVT::v8i16 && RevVTSize <= 32) ||
1808            (LT.second == MVT::v4i32 && RevVTSize <= 64)))
1809         return ST->getMVEVectorCostFactor(CostKind) * LT.first;
1827     std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(ValTy);
1837         ((LT.second == MVT::v16i8 && RevVTSize <= 32) ||
1838          (LT.second == MVT::v8i16 && RevVTSize <= 64) ||
1839          (LT.second == MVT::v4i32 && RevVTSize <= 64)))
1840       return ST->getMVEVectorCostFactor(CostKind) * LT.first;
1889     std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(Ty);
1899     if (const auto *Entry = CostTableLookup(CostTblAdd, ISD::SMIN, LT.second))
1900       return Entry->Cost * ST->getMVEVectorCostFactor(CostKind) * LT.first;
1950     std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(RetTy);
1951     if (LT.second == MVT::v4i32 || LT.second == MVT::v8i16 ||
1952         LT.second == MVT::v16i8) {
1956           LT.second.getScalarSizeInBits() == RetTy->getScalarSizeInBits() ? 1
1958       return LT.first * ST->getMVEVectorCostFactor(CostKind) * Instrs;
1971     std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(VT);
1972     if (LT.second == MVT::v4i32 || LT.second == MVT::v8i16 ||
1973         LT.second == MVT::v16i8)
1974       return LT.first * ST->getMVEVectorCostFactor(CostKind);
1982     std::pair<InstructionCost, MVT> LT = getTypeLegalizationCost(VT);
1983     if (LT.second == MVT::v4f32 || LT.second == MVT::v8f16)
1984       return LT.first * ST->getMVEVectorCostFactor(CostKind);
1992     auto LT = getTypeLegalizationCost(ICA.getArgTypes()[0]);
1995     if ((ST->hasVFP2Base() && LT.second == MVT::f32 && MTy == MVT::i32) ||
1996         (ST->hasFP64() && LT.second == MVT::f64 && MTy == MVT::i32) ||
1997         (ST->hasFullFP16() && LT.second == MVT::f16 && MTy == MVT::i32))
1998       return LT.first;
2002         (LT.second == MVT::v4f32 || LT.second == MVT::v8f16) &&
2003         LT.second.getScalarSizeInBits() == MTy.getScalarSizeInBits())
2004       return LT.first * ST->getMVEVectorCostFactor(CostKind);
2007     if (((ST->hasVFP2Base() && LT.second == MVT::f32) ||
2008          (ST->hasFP64() && LT.second == MVT::f64) ||
2009          (ST->hasFullFP16() && LT.second == MVT::f16) ||
2011           (LT.second == MVT::v4f32 || LT.second == MVT::v8f16))) &&
2012         LT.second.getScalarSizeInBits() >= MTy.getScalarSizeInBits()) {
2014                                       LT.second.getScalarSizeInBits());
2016           LT.second.isVector() ? ST->getMVEVectorCostFactor(CostKind) : 1;
2025       return LT.first * Cost;