Skip to content

Commit 408c440

Browse files
fhahnfhahn
committed
Revert "[TTI] Add VecPred argument to getCmpSelInstrCost."
This reverts commit 73f01e3. This appears to break http://lab.llvm.org:8011/#/builders/85/builds/383.
1 parent 3d049bc commit 408c440

21 files changed

+78
-148
lines changed

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

Lines changed: 5 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,6 @@
2121
#ifndef LLVM_ANALYSIS_TARGETTRANSFORMINFO_H
2222
#define LLVM_ANALYSIS_TARGETTRANSFORMINFO_H
2323

24-
#include "llvm/IR/InstrTypes.h"
2524
#include "llvm/IR/Operator.h"
2625
#include "llvm/IR/PassManager.h"
2726
#include "llvm/Pass.h"
@@ -1093,14 +1092,10 @@ class TargetTransformInfo {
10931092

10941093
/// \returns The expected cost of compare and select instructions. If there
10951094
/// is an existing instruction that holds Opcode, it may be passed in the
1096-
/// 'I' parameter. The \p VecPred parameter can be used to indicate the select
1097-
/// is using a compare with the specified predicate as condition. When vector
1098-
/// types are passed, \p VecPred must be used for all lanes.
1099-
int getCmpSelInstrCost(
1100-
unsigned Opcode, Type *ValTy, Type *CondTy = nullptr,
1101-
CmpInst::Predicate VecPred = CmpInst::BAD_ICMP_PREDICATE,
1102-
TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput,
1103-
const Instruction *I = nullptr) const;
1095+
/// 'I' parameter.
1096+
int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy = nullptr,
1097+
TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput,
1098+
const Instruction *I = nullptr) const;
11041099

11051100
/// \return The expected cost of vector Insert and Extract.
11061101
/// Use -1 to indicate that there is no information on the index value.
@@ -1539,7 +1534,6 @@ class TargetTransformInfo::Concept {
15391534
virtual int getCFInstrCost(unsigned Opcode,
15401535
TTI::TargetCostKind CostKind) = 0;
15411536
virtual int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
1542-
CmpInst::Predicate VecPred,
15431537
TTI::TargetCostKind CostKind,
15441538
const Instruction *I) = 0;
15451539
virtual int getVectorInstrCost(unsigned Opcode, Type *Val,
@@ -1981,10 +1975,9 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept {
19811975
return Impl.getCFInstrCost(Opcode, CostKind);
19821976
}
19831977
int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
1984-
CmpInst::Predicate VecPred,
19851978
TTI::TargetCostKind CostKind,
19861979
const Instruction *I) override {
1987-
return Impl.getCmpSelInstrCost(Opcode, ValTy, CondTy, VecPred, CostKind, I);
1980+
return Impl.getCmpSelInstrCost(Opcode, ValTy, CondTy, CostKind, I);
19881981
}
19891982
int getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index) override {
19901983
return Impl.getVectorInstrCost(Opcode, Val, Index);

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

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -478,7 +478,6 @@ class TargetTransformInfoImplBase {
478478
}
479479

480480
unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
481-
CmpInst::Predicate VecPred,
482481
TTI::TargetCostKind CostKind,
483482
const Instruction *I) const {
484483
return 1;
@@ -948,14 +947,12 @@ class TargetTransformInfoImplCRTPBase : public TargetTransformInfoImplBase {
948947
case Instruction::Select: {
949948
Type *CondTy = U->getOperand(0)->getType();
950949
return TargetTTI->getCmpSelInstrCost(Opcode, U->getType(), CondTy,
951-
CmpInst::BAD_ICMP_PREDICATE,
952950
CostKind, I);
953951
}
954952
case Instruction::ICmp:
955953
case Instruction::FCmp: {
956954
Type *ValTy = U->getOperand(0)->getType();
957955
return TargetTTI->getCmpSelInstrCost(Opcode, ValTy, U->getType(),
958-
cast<CmpInst>(U)->getPredicate(),
959956
CostKind, I);
960957
}
961958
case Instruction::InsertElement: {

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

Lines changed: 28 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -881,7 +881,6 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
881881
}
882882

883883
unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
884-
CmpInst::Predicate VecPred,
885884
TTI::TargetCostKind CostKind,
886885
const Instruction *I = nullptr) {
887886
const TargetLoweringBase *TLI = getTLI();
@@ -890,8 +889,7 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
890889

891890
// TODO: Handle other cost kinds.
892891
if (CostKind != TTI::TCK_RecipThroughput)
893-
return BaseT::getCmpSelInstrCost(Opcode, ValTy, CondTy, VecPred, CostKind,
894-
I);
892+
return BaseT::getCmpSelInstrCost(Opcode, ValTy, CondTy, CostKind, I);
895893

896894
// Selects on vectors are actually vector selects.
897895
if (ISD == ISD::SELECT) {
@@ -916,7 +914,7 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
916914
if (CondTy)
917915
CondTy = CondTy->getScalarType();
918916
unsigned Cost = thisT()->getCmpSelInstrCost(
919-
Opcode, ValVTy->getScalarType(), CondTy, VecPred, CostKind, I);
917+
Opcode, ValVTy->getScalarType(), CondTy, CostKind, I);
920918

921919
// Return the cost of multiple scalar invocation plus the cost of
922920
// inserting and extracting the values.
@@ -1243,12 +1241,10 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
12431241
// For non-rotates (X != Y) we must add shift-by-zero handling costs.
12441242
if (X != Y) {
12451243
Type *CondTy = RetTy->getWithNewBitWidth(1);
1246-
Cost +=
1247-
thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, RetTy, CondTy,
1248-
CmpInst::BAD_ICMP_PREDICATE, CostKind);
1249-
Cost +=
1250-
thisT()->getCmpSelInstrCost(BinaryOperator::Select, RetTy, CondTy,
1251-
CmpInst::BAD_ICMP_PREDICATE, CostKind);
1244+
Cost += thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, RetTy, CondTy,
1245+
CostKind);
1246+
Cost += thisT()->getCmpSelInstrCost(BinaryOperator::Select, RetTy,
1247+
CondTy, CostKind);
12521248
}
12531249
return Cost;
12541250
}
@@ -1487,12 +1483,10 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
14871483
Type *CondTy = RetTy->getWithNewBitWidth(1);
14881484
unsigned Cost = 0;
14891485
// TODO: Ideally getCmpSelInstrCost would accept an icmp condition code.
1490-
Cost +=
1491-
thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, RetTy, CondTy,
1492-
CmpInst::BAD_ICMP_PREDICATE, CostKind);
1493-
Cost +=
1494-
thisT()->getCmpSelInstrCost(BinaryOperator::Select, RetTy, CondTy,
1495-
CmpInst::BAD_ICMP_PREDICATE, CostKind);
1486+
Cost += thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, RetTy, CondTy,
1487+
CostKind);
1488+
Cost += thisT()->getCmpSelInstrCost(BinaryOperator::Select, RetTy, CondTy,
1489+
CostKind);
14961490
// TODO: Should we add an OperandValueProperties::OP_Zero property?
14971491
if (IID == Intrinsic::abs)
14981492
Cost += thisT()->getArithmeticInstrCost(
@@ -1514,12 +1508,10 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
15141508
IntrinsicCostAttributes Attrs(OverflowOp, OpTy, {RetTy, RetTy}, FMF,
15151509
ScalarizationCostPassed);
15161510
Cost += thisT()->getIntrinsicInstrCost(Attrs, CostKind);
1517-
Cost +=
1518-
thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, RetTy, CondTy,
1519-
CmpInst::BAD_ICMP_PREDICATE, CostKind);
1520-
Cost += 2 * thisT()->getCmpSelInstrCost(
1521-
BinaryOperator::Select, RetTy, CondTy,
1522-
CmpInst::BAD_ICMP_PREDICATE, CostKind);
1511+
Cost += thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, RetTy, CondTy,
1512+
CostKind);
1513+
Cost += 2 * thisT()->getCmpSelInstrCost(BinaryOperator::Select, RetTy,
1514+
CondTy, CostKind);
15231515
return Cost;
15241516
}
15251517
case Intrinsic::uadd_sat:
@@ -1535,9 +1527,8 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
15351527
IntrinsicCostAttributes Attrs(OverflowOp, OpTy, {RetTy, RetTy}, FMF,
15361528
ScalarizationCostPassed);
15371529
Cost += thisT()->getIntrinsicInstrCost(Attrs, CostKind);
1538-
Cost +=
1539-
thisT()->getCmpSelInstrCost(BinaryOperator::Select, RetTy, CondTy,
1540-
CmpInst::BAD_ICMP_PREDICATE, CostKind);
1530+
Cost += thisT()->getCmpSelInstrCost(BinaryOperator::Select, RetTy, CondTy,
1531+
CostKind);
15411532
return Cost;
15421533
}
15431534
case Intrinsic::smul_fix:
@@ -1582,12 +1573,10 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
15821573
// Overflow -> (LHSSign != RHSSign) && (LHSSign != SumSign)
15831574
unsigned Cost = 0;
15841575
Cost += thisT()->getArithmeticInstrCost(Opcode, SumTy, CostKind);
1585-
Cost += 3 * thisT()->getCmpSelInstrCost(
1586-
BinaryOperator::ICmp, SumTy, OverflowTy,
1587-
CmpInst::BAD_ICMP_PREDICATE, CostKind);
1588-
Cost += 2 * thisT()->getCmpSelInstrCost(
1589-
BinaryOperator::ICmp, OverflowTy, OverflowTy,
1590-
CmpInst::BAD_ICMP_PREDICATE, CostKind);
1576+
Cost += 3 * thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, SumTy,
1577+
OverflowTy, CostKind);
1578+
Cost += 2 * thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, OverflowTy,
1579+
OverflowTy, CostKind);
15911580
Cost += thisT()->getArithmeticInstrCost(BinaryOperator::And, OverflowTy,
15921581
CostKind);
15931582
return Cost;
@@ -1602,9 +1591,8 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
16021591

16031592
unsigned Cost = 0;
16041593
Cost += thisT()->getArithmeticInstrCost(Opcode, SumTy, CostKind);
1605-
Cost +=
1606-
thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, SumTy, OverflowTy,
1607-
CmpInst::BAD_ICMP_PREDICATE, CostKind);
1594+
Cost += thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, SumTy,
1595+
OverflowTy, CostKind);
16081596
return Cost;
16091597
}
16101598
case Intrinsic::smul_with_overflow:
@@ -1633,9 +1621,8 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
16331621
CostKind, TTI::OK_AnyValue,
16341622
TTI::OK_UniformConstantValue);
16351623

1636-
Cost +=
1637-
thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, MulTy, OverflowTy,
1638-
CmpInst::BAD_ICMP_PREDICATE, CostKind);
1624+
Cost += thisT()->getCmpSelInstrCost(BinaryOperator::ICmp, MulTy,
1625+
OverflowTy, CostKind);
16391626
return Cost;
16401627
}
16411628
case Intrinsic::ctpop:
@@ -1877,10 +1864,9 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
18771864
(IsPairwise + 1) * thisT()->getShuffleCost(TTI::SK_ExtractSubvector,
18781865
Ty, NumVecElts, SubTy);
18791866
MinMaxCost +=
1880-
thisT()->getCmpSelInstrCost(CmpOpcode, SubTy, CondTy,
1881-
CmpInst::BAD_ICMP_PREDICATE, CostKind) +
1867+
thisT()->getCmpSelInstrCost(CmpOpcode, SubTy, CondTy, CostKind) +
18821868
thisT()->getCmpSelInstrCost(Instruction::Select, SubTy, CondTy,
1883-
CmpInst::BAD_ICMP_PREDICATE, CostKind);
1869+
CostKind);
18841870
Ty = SubTy;
18851871
++LongVectorCount;
18861872
}
@@ -1902,10 +1888,9 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
19021888
thisT()->getShuffleCost(TTI::SK_PermuteSingleSrc, Ty, 0, Ty);
19031889
MinMaxCost +=
19041890
NumReduxLevels *
1905-
(thisT()->getCmpSelInstrCost(CmpOpcode, Ty, CondTy,
1906-
CmpInst::BAD_ICMP_PREDICATE, CostKind) +
1891+
(thisT()->getCmpSelInstrCost(CmpOpcode, Ty, CondTy, CostKind) +
19071892
thisT()->getCmpSelInstrCost(Instruction::Select, Ty, CondTy,
1908-
CmpInst::BAD_ICMP_PREDICATE, CostKind));
1893+
CostKind));
19091894
// The last min/max should be in vector registers and we counted it above.
19101895
// So just need a single extractelement.
19111896
return ShuffleCost + MinMaxCost +

‎llvm/lib/Analysis/TargetTransformInfo.cpp

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -807,13 +807,11 @@ int TargetTransformInfo::getCFInstrCost(unsigned Opcode,
807807

808808
int TargetTransformInfo::getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
809809
Type *CondTy,
810-
CmpInst::Predicate VecPred,
811810
TTI::TargetCostKind CostKind,
812811
const Instruction *I) const {
813812
assert((I == nullptr || I->getOpcode() == Opcode) &&
814813
"Opcode should reflect passed instruction.");
815-
int Cost =
816-
TTIImpl->getCmpSelInstrCost(Opcode, ValTy, CondTy, VecPred, CostKind, I);
814+
int Cost = TTIImpl->getCmpSelInstrCost(Opcode, ValTy, CondTy, CostKind, I);
817815
assert(Cost >= 0 && "TTI should not produce negative costs!");
818816
return Cost;
819817
}

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

Lines changed: 4 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -6,8 +6,8 @@
66
//
77
//===----------------------------------------------------------------------===//
88

9-
#include "AArch64TargetTransformInfo.h"
109
#include "AArch64ExpandImm.h"
10+
#include "AArch64TargetTransformInfo.h"
1111
#include "MCTargetDesc/AArch64AddressingModes.h"
1212
#include "llvm/Analysis/LoopInfo.h"
1313
#include "llvm/Analysis/TargetTransformInfo.h"
@@ -16,11 +16,9 @@
1616
#include "llvm/CodeGen/TargetLowering.h"
1717
#include "llvm/IR/IntrinsicInst.h"
1818
#include "llvm/IR/IntrinsicsAArch64.h"
19-
#include "llvm/IR/PatternMatch.h"
2019
#include "llvm/Support/Debug.h"
2120
#include <algorithm>
2221
using namespace llvm;
23-
using namespace llvm::PatternMatch;
2422

2523
#define DEBUG_TYPE "aarch64tti"
2624

@@ -677,40 +675,19 @@ int AArch64TTIImpl::getAddressComputationCost(Type *Ty, ScalarEvolution *SE,
677675
}
678676

679677
int AArch64TTIImpl::getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
680-
Type *CondTy, CmpInst::Predicate VecPred,
678+
Type *CondTy,
681679
TTI::TargetCostKind CostKind,
682680
const Instruction *I) {
683681
// TODO: Handle other cost kinds.
684682
if (CostKind != TTI::TCK_RecipThroughput)
685-
return BaseT::getCmpSelInstrCost(Opcode, ValTy, CondTy, VecPred, CostKind,
686-
I);
683+
return BaseT::getCmpSelInstrCost(Opcode, ValTy, CondTy, CostKind, I);
687684

688685
int ISD = TLI->InstructionOpcodeToISD(Opcode);
689686
// We don't lower some vector selects well that are wider than the register
690687
// width.
691688
if (ValTy->isVectorTy() && ISD == ISD::SELECT) {
692689
// We would need this many instructions to hide the scalarization happening.
693690
const int AmortizationCost = 20;
694-
695-
// If VecPred is not set, check if we can get a predicate from the context
696-
// instruction, if its type matches the requested ValTy.
697-
if (VecPred == CmpInst::BAD_ICMP_PREDICATE && I && I->getType() == ValTy) {
698-
CmpInst::Predicate CurrentPred;
699-
if (match(I, m_Select(m_Cmp(CurrentPred, m_Value(), m_Value()), m_Value(),
700-
m_Value())))
701-
VecPred = CurrentPred;
702-
}
703-
// Check if we have a compare/select chain that can be lowered using CMxx &
704-
// BFI pair.
705-
if (CmpInst::isIntPredicate(VecPred)) {
706-
static const auto ValidMinMaxTys = {MVT::v8i8, MVT::v16i8, MVT::v4i16,
707-
MVT::v8i16, MVT::v2i32, MVT::v4i32,
708-
MVT::v2i64};
709-
auto LT = TLI->getTypeLegalizationCost(DL, ValTy);
710-
if (any_of(ValidMinMaxTys, [&LT](MVT M) { return M == LT.second; }))
711-
return LT.first;
712-
}
713-
714691
static const TypeConversionCostTblEntry
715692
VectorSelectTbl[] = {
716693
{ ISD::SELECT, MVT::v16i1, MVT::v16i16, 16 },
@@ -730,7 +707,7 @@ int AArch64TTIImpl::getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
730707
return Entry->Cost;
731708
}
732709
}
733-
return BaseT::getCmpSelInstrCost(Opcode, ValTy, CondTy, VecPred, CostKind, I);
710+
return BaseT::getCmpSelInstrCost(Opcode, ValTy, CondTy, CostKind, I);
734711
}
735712

736713
AArch64TTIImpl::TTI::MemCmpExpansionOptions

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

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -141,7 +141,6 @@ class AArch64TTIImpl : public BasicTTIImplBase<AArch64TTIImpl> {
141141
int getAddressComputationCost(Type *Ty, ScalarEvolution *SE, const SCEV *Ptr);
142142

143143
int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
144-
CmpInst::Predicate VecPred,
145144
TTI::TargetCostKind CostKind,
146145
const Instruction *I = nullptr);
147146

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

Lines changed: 3 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -810,7 +810,6 @@ int ARMTTIImpl::getVectorInstrCost(unsigned Opcode, Type *ValTy,
810810
}
811811

812812
int ARMTTIImpl::getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
813-
CmpInst::Predicate VecPred,
814813
TTI::TargetCostKind CostKind,
815814
const Instruction *I) {
816815
int ISD = TLI->InstructionOpcodeToISD(Opcode);
@@ -840,8 +839,7 @@ int ARMTTIImpl::getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
840839
}
841840

842841
if (CostKind != TTI::TCK_RecipThroughput)
843-
return BaseT::getCmpSelInstrCost(Opcode, ValTy, CondTy, VecPred, CostKind,
844-
I);
842+
return BaseT::getCmpSelInstrCost(Opcode, ValTy, CondTy, CostKind, I);
845843

846844
// On NEON a vector select gets lowered to vbsl.
847845
if (ST->hasNEON() && ValTy->isVectorTy() && ISD == ISD::SELECT) {
@@ -868,8 +866,8 @@ int ARMTTIImpl::getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
868866
int BaseCost = ST->hasMVEIntegerOps() && ValTy->isVectorTy()
869867
? ST->getMVEVectorCostFactor()
870868
: 1;
871-
return BaseCost *
872-
BaseT::getCmpSelInstrCost(Opcode, ValTy, CondTy, VecPred, CostKind, I);
869+
return BaseCost * BaseT::getCmpSelInstrCost(Opcode, ValTy, CondTy, CostKind,
870+
I);
873871
}
874872

875873
int ARMTTIImpl::getAddressComputationCost(Type *Ty, ScalarEvolution *SE,

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

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -212,7 +212,6 @@ class ARMTTIImpl : public BasicTTIImplBase<ARMTTIImpl> {
212212
const Instruction *I = nullptr);
213213

214214
int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
215-
CmpInst::Predicate VecPred,
216215
TTI::TargetCostKind CostKind,
217216
const Instruction *I = nullptr);
218217

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

Lines changed: 2 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -242,16 +242,13 @@ unsigned HexagonTTIImpl::getInterleavedMemoryOpCost(
242242
}
243243

244244
unsigned HexagonTTIImpl::getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
245-
Type *CondTy,
246-
CmpInst::Predicate VecPred,
247-
TTI::TargetCostKind CostKind,
248-
const Instruction *I) {
245+
Type *CondTy, TTI::TargetCostKind CostKind, const Instruction *I) {
249246
if (ValTy->isVectorTy() && CostKind == TTI::TCK_RecipThroughput) {
250247
std::pair<int, MVT> LT = TLI.getTypeLegalizationCost(DL, ValTy);
251248
if (Opcode == Instruction::FCmp)
252249
return LT.first + FloatFactor * getTypeNumElements(ValTy);
253250
}
254-
return BaseT::getCmpSelInstrCost(Opcode, ValTy, CondTy, VecPred, CostKind, I);
251+
return BaseT::getCmpSelInstrCost(Opcode, ValTy, CondTy, CostKind, I);
255252
}
256253

257254
unsigned HexagonTTIImpl::getArithmeticInstrCost(

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

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -134,8 +134,6 @@ class HexagonTTIImpl : public BasicTTIImplBase<HexagonTTIImpl> {
134134
TTI::TargetCostKind CostKind = TTI::TCK_SizeAndLatency,
135135
bool UseMaskForCond = false, bool UseMaskForGaps = false);
136136
unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
137-
138-
CmpInst::Predicate VecPred,
139137
TTI::TargetCostKind CostKind,
140138
const Instruction *I = nullptr);
141139
unsigned getArithmeticInstrCost(

0 commit comments

Comments
 (0)