From 3ccbd4f3c7d164f7cb655ea15ab048176f7ba5b8 Mon Sep 17 00:00:00 2001 From: Sander de Smalen Date: Wed, 20 Jan 2021 17:17:23 +0000 Subject: [PATCH] NFC: Change getUserCost to return InstructionCost This patch migrates the TTI cost interfaces to return an InstructionCost. See this patch for the introduction of the type: https://reviews.llvm.org/D91174 See this thread for context: http://lists.llvm.org/pipermail/llvm-dev/2020-November/146408.html Depends on D97382 Reviewed By: ctetreau, paulwalker-arm Differential Revision: https://reviews.llvm.org/D97466 --- llvm/include/llvm/Analysis/TargetTransformInfo.h | 23 +++++++++++----------- .../llvm/Analysis/TargetTransformInfoImpl.h | 6 +++--- llvm/include/llvm/CodeGen/BasicTTIImpl.h | 2 +- llvm/lib/Analysis/InlineCost.cpp | 22 ++++++++++----------- llvm/lib/Analysis/TargetTransformInfo.cpp | 15 ++++++++------ llvm/lib/Target/ARM/ARMTargetTransformInfo.cpp | 2 +- .../Target/Hexagon/HexagonTargetTransformInfo.cpp | 7 +++---- .../Target/Hexagon/HexagonTargetTransformInfo.h | 4 ++-- llvm/lib/Target/PowerPC/PPCTargetTransformInfo.cpp | 6 +++--- llvm/lib/Target/PowerPC/PPCTargetTransformInfo.h | 4 ++-- 10 files changed, 47 insertions(+), 44 deletions(-) diff --git a/llvm/include/llvm/Analysis/TargetTransformInfo.h b/llvm/include/llvm/Analysis/TargetTransformInfo.h index d635625..dadf8fd 100644 --- a/llvm/include/llvm/Analysis/TargetTransformInfo.h +++ b/llvm/include/llvm/Analysis/TargetTransformInfo.h @@ -317,12 +317,12 @@ public: /// /// The returned cost is defined in terms of \c TargetCostConstants, see its /// comments for a detailed explanation of the cost values. - int getUserCost(const User *U, ArrayRef Operands, - TargetCostKind CostKind) const; + InstructionCost getUserCost(const User *U, ArrayRef Operands, + TargetCostKind CostKind) const; /// This is a helper function which calls the two-argument getUserCost /// with \p Operands which are the current operands U has. - int getUserCost(const User *U, TargetCostKind CostKind) const { + InstructionCost getUserCost(const User *U, TargetCostKind CostKind) const { SmallVector Operands(U->operand_values()); return getUserCost(U, Operands, CostKind); } @@ -1371,11 +1371,11 @@ public: private: /// Estimate the latency of specified instruction. /// Returns 1 as the default value. - int getInstructionLatency(const Instruction *I) const; + InstructionCost getInstructionLatency(const Instruction *I) const; /// Returns the expected throughput cost of the instruction. /// Returns -1 if the cost is unknown. - int getInstructionThroughput(const Instruction *I) const; + InstructionCost getInstructionThroughput(const Instruction *I) const; /// The abstract base class used to type erase specific TTI /// implementations. @@ -1403,8 +1403,9 @@ public: getEstimatedNumberOfCaseClusters(const SwitchInst &SI, unsigned &JTSize, ProfileSummaryInfo *PSI, BlockFrequencyInfo *BFI) = 0; - virtual int getUserCost(const User *U, ArrayRef Operands, - TargetCostKind CostKind) = 0; + virtual InstructionCost getUserCost(const User *U, + ArrayRef Operands, + TargetCostKind CostKind) = 0; virtual BranchProbability getPredictableBranchThreshold() = 0; virtual bool hasBranchDivergence() = 0; virtual bool useGPUDivergenceAnalysis() = 0; @@ -1661,7 +1662,7 @@ public: virtual unsigned getGISelRematGlobalCost() const = 0; virtual bool supportsScalableVectors() const = 0; virtual bool hasActiveVectorLength() const = 0; - virtual int getInstructionLatency(const Instruction *I) = 0; + virtual InstructionCost getInstructionLatency(const Instruction *I) = 0; }; template @@ -1693,8 +1694,8 @@ public: int getMemcpyCost(const Instruction *I) override { return Impl.getMemcpyCost(I); } - int getUserCost(const User *U, ArrayRef Operands, - TargetCostKind CostKind) override { + InstructionCost getUserCost(const User *U, ArrayRef Operands, + TargetCostKind CostKind) override { return Impl.getUserCost(U, Operands, CostKind); } BranchProbability getPredictableBranchThreshold() override { @@ -2214,7 +2215,7 @@ public: return Impl.hasActiveVectorLength(); } - int getInstructionLatency(const Instruction *I) override { + InstructionCost getInstructionLatency(const Instruction *I) override { return Impl.getInstructionLatency(I); } }; diff --git a/llvm/include/llvm/Analysis/TargetTransformInfoImpl.h b/llvm/include/llvm/Analysis/TargetTransformInfoImpl.h index b812277..04cc76c 100644 --- a/llvm/include/llvm/Analysis/TargetTransformInfoImpl.h +++ b/llvm/include/llvm/Analysis/TargetTransformInfoImpl.h @@ -899,8 +899,8 @@ public: return TTI::TCC_Basic; } - int getUserCost(const User *U, ArrayRef Operands, - TTI::TargetCostKind CostKind) { + InstructionCost getUserCost(const User *U, ArrayRef Operands, + TTI::TargetCostKind CostKind) { auto *TargetTTI = static_cast(this); // Handle non-intrinsic calls, invokes, and callbr. // FIXME: Unlikely to be true for anything but CodeSize. @@ -1119,7 +1119,7 @@ public: return TTI::TCC_Basic; } - int getInstructionLatency(const Instruction *I) { + InstructionCost getInstructionLatency(const Instruction *I) { SmallVector Operands(I->operand_values()); if (getUserCost(I, Operands, TTI::TCK_Latency) == TTI::TCC_Free) return 0; diff --git a/llvm/include/llvm/CodeGen/BasicTTIImpl.h b/llvm/include/llvm/CodeGen/BasicTTIImpl.h index 939037e..8aabb59 100644 --- a/llvm/include/llvm/CodeGen/BasicTTIImpl.h +++ b/llvm/include/llvm/CodeGen/BasicTTIImpl.h @@ -517,7 +517,7 @@ public: SimplifyAndSetOp); } - int getInstructionLatency(const Instruction *I) { + InstructionCost getInstructionLatency(const Instruction *I) { if (isa(I)) return getST()->getSchedModel().DefaultLoadLatency; diff --git a/llvm/lib/Analysis/InlineCost.cpp b/llvm/lib/Analysis/InlineCost.cpp index f4e22d4..06e4d9b 100644 --- a/llvm/lib/Analysis/InlineCost.cpp +++ b/llvm/lib/Analysis/InlineCost.cpp @@ -1037,9 +1037,9 @@ bool CallAnalyzer::isGEPFree(GetElementPtrInst &GEP) { Operands.push_back(SimpleOp); else Operands.push_back(Op); - return TargetTransformInfo::TCC_Free == - TTI.getUserCost(&GEP, Operands, - TargetTransformInfo::TCK_SizeAndLatency); + return TTI.getUserCost(&GEP, Operands, + TargetTransformInfo::TCK_SizeAndLatency) == + TargetTransformInfo::TCC_Free; } bool CallAnalyzer::visitAlloca(AllocaInst &I) { @@ -1309,8 +1309,8 @@ bool CallAnalyzer::visitPtrToInt(PtrToIntInst &I) { if (auto *SROAArg = getSROAArgForValueOrNull(I.getOperand(0))) SROAArgValues[&I] = SROAArg; - return TargetTransformInfo::TCC_Free == - TTI.getUserCost(&I, TargetTransformInfo::TCK_SizeAndLatency); + return TTI.getUserCost(&I, TargetTransformInfo::TCK_SizeAndLatency) == + TargetTransformInfo::TCC_Free; } bool CallAnalyzer::visitIntToPtr(IntToPtrInst &I) { @@ -1334,8 +1334,8 @@ bool CallAnalyzer::visitIntToPtr(IntToPtrInst &I) { if (auto *SROAArg = getSROAArgForValueOrNull(Op)) SROAArgValues[&I] = SROAArg; - return TargetTransformInfo::TCC_Free == - TTI.getUserCost(&I, TargetTransformInfo::TCK_SizeAndLatency); + return TTI.getUserCost(&I, TargetTransformInfo::TCK_SizeAndLatency) == + TargetTransformInfo::TCC_Free; } bool CallAnalyzer::visitCastInst(CastInst &I) { @@ -1366,8 +1366,8 @@ bool CallAnalyzer::visitCastInst(CastInst &I) { break; } - return TargetTransformInfo::TCC_Free == - TTI.getUserCost(&I, TargetTransformInfo::TCK_SizeAndLatency); + return TTI.getUserCost(&I, TargetTransformInfo::TCK_SizeAndLatency) == + TargetTransformInfo::TCC_Free; } bool CallAnalyzer::visitUnaryInstruction(UnaryInstruction &I) { @@ -2071,8 +2071,8 @@ bool CallAnalyzer::visitUnreachableInst(UnreachableInst &I) { bool CallAnalyzer::visitInstruction(Instruction &I) { // Some instructions are free. All of the free intrinsics can also be // handled by SROA, etc. - if (TargetTransformInfo::TCC_Free == - TTI.getUserCost(&I, TargetTransformInfo::TCK_SizeAndLatency)) + if (TTI.getUserCost(&I, TargetTransformInfo::TCK_SizeAndLatency) == + TargetTransformInfo::TCC_Free) return true; // We found something we don't understand or can't handle. Mark any SROA-able diff --git a/llvm/lib/Analysis/TargetTransformInfo.cpp b/llvm/lib/Analysis/TargetTransformInfo.cpp index 7fa6ae1..7038994 100644 --- a/llvm/lib/Analysis/TargetTransformInfo.cpp +++ b/llvm/lib/Analysis/TargetTransformInfo.cpp @@ -219,10 +219,11 @@ unsigned TargetTransformInfo::getEstimatedNumberOfCaseClusters( return TTIImpl->getEstimatedNumberOfCaseClusters(SI, JTSize, PSI, BFI); } -int TargetTransformInfo::getUserCost(const User *U, - ArrayRef Operands, - enum TargetCostKind CostKind) const { - int Cost = TTIImpl->getUserCost(U, Operands, CostKind); +InstructionCost +TargetTransformInfo::getUserCost(const User *U, + ArrayRef Operands, + enum TargetCostKind CostKind) const { + InstructionCost Cost = TTIImpl->getUserCost(U, Operands, CostKind); assert((CostKind == TTI::TCK_RecipThroughput || Cost >= 0) && "TTI should not produce negative costs!"); return Cost; @@ -1032,7 +1033,8 @@ bool TargetTransformInfo::supportsScalableVectors() const { return TTIImpl->supportsScalableVectors(); } -int TargetTransformInfo::getInstructionLatency(const Instruction *I) const { +InstructionCost +TargetTransformInfo::getInstructionLatency(const Instruction *I) const { return TTIImpl->getInstructionLatency(I); } @@ -1321,7 +1323,8 @@ TTI::matchVectorReduction(const ExtractElementInst *Root, unsigned &Opcode, return matchPairwiseReduction(Root, Opcode, Ty); } -int TargetTransformInfo::getInstructionThroughput(const Instruction *I) const { +InstructionCost +TargetTransformInfo::getInstructionThroughput(const Instruction *I) const { TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput; switch (I->getOpcode()) { diff --git a/llvm/lib/Target/ARM/ARMTargetTransformInfo.cpp b/llvm/lib/Target/ARM/ARMTargetTransformInfo.cpp index 07c63d5..e2556e5 100644 --- a/llvm/lib/Target/ARM/ARMTargetTransformInfo.cpp +++ b/llvm/lib/Target/ARM/ARMTargetTransformInfo.cpp @@ -2165,7 +2165,7 @@ void ARMTTIImpl::getUnrollingPreferences(Loop *L, ScalarEvolution &SE, // Scan the loop: don't unroll loops with calls as this could prevent // inlining. - unsigned Cost = 0; + InstructionCost Cost = 0; for (auto *BB : L->getBlocks()) { for (auto &I : *BB) { // Don't unroll vectorised loop. MVE does not benefit from it as much as diff --git a/llvm/lib/Target/Hexagon/HexagonTargetTransformInfo.cpp b/llvm/lib/Target/Hexagon/HexagonTargetTransformInfo.cpp index bfbba49..45244fe 100644 --- a/llvm/lib/Target/Hexagon/HexagonTargetTransformInfo.cpp +++ b/llvm/lib/Target/Hexagon/HexagonTargetTransformInfo.cpp @@ -334,10 +334,9 @@ unsigned HexagonTTIImpl::getCacheLineSize() const { return ST.getL1CacheLineSize(); } -int -HexagonTTIImpl::getUserCost(const User *U, - ArrayRef Operands, - TTI::TargetCostKind CostKind) { +InstructionCost HexagonTTIImpl::getUserCost(const User *U, + ArrayRef Operands, + TTI::TargetCostKind CostKind) { auto isCastFoldedIntoLoad = [this](const CastInst *CI) -> bool { if (!CI->isIntegerCast()) return false; diff --git a/llvm/lib/Target/Hexagon/HexagonTargetTransformInfo.h b/llvm/lib/Target/Hexagon/HexagonTargetTransformInfo.h index fd04d1d..d2096ad 100644 --- a/llvm/lib/Target/Hexagon/HexagonTargetTransformInfo.h +++ b/llvm/lib/Target/Hexagon/HexagonTargetTransformInfo.h @@ -162,8 +162,8 @@ public: /// @} - int getUserCost(const User *U, ArrayRef Operands, - TTI::TargetCostKind CostKind); + InstructionCost getUserCost(const User *U, ArrayRef Operands, + TTI::TargetCostKind CostKind); // Hexagon specific decision to generate a lookup table. bool shouldBuildLookupTables() const; diff --git a/llvm/lib/Target/PowerPC/PPCTargetTransformInfo.cpp b/llvm/lib/Target/PowerPC/PPCTargetTransformInfo.cpp index f8145fe..74cb172 100644 --- a/llvm/lib/Target/PowerPC/PPCTargetTransformInfo.cpp +++ b/llvm/lib/Target/PowerPC/PPCTargetTransformInfo.cpp @@ -318,9 +318,9 @@ int PPCTTIImpl::getIntImmCostInst(unsigned Opcode, unsigned Idx, return PPCTTIImpl::getIntImmCost(Imm, Ty, CostKind); } -unsigned -PPCTTIImpl::getUserCost(const User *U, ArrayRef Operands, - TTI::TargetCostKind CostKind) { +InstructionCost PPCTTIImpl::getUserCost(const User *U, + ArrayRef Operands, + TTI::TargetCostKind CostKind) { // We already implement getCastInstrCost and getMemoryOpCost where we perform // the vector adjustment there. if (isa(U) || isa(U) || isa(U)) diff --git a/llvm/lib/Target/PowerPC/PPCTargetTransformInfo.h b/llvm/lib/Target/PowerPC/PPCTargetTransformInfo.h index 87ff0e3..9c86576 100644 --- a/llvm/lib/Target/PowerPC/PPCTargetTransformInfo.h +++ b/llvm/lib/Target/PowerPC/PPCTargetTransformInfo.h @@ -57,8 +57,8 @@ public: int getIntImmCostIntrin(Intrinsic::ID IID, unsigned Idx, const APInt &Imm, Type *Ty, TTI::TargetCostKind CostKind); - unsigned getUserCost(const User *U, ArrayRef Operands, - TTI::TargetCostKind CostKind); + InstructionCost getUserCost(const User *U, ArrayRef Operands, + TTI::TargetCostKind CostKind); TTI::PopcntSupportKind getPopcntSupport(unsigned TyWidth); bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE, -- 2.7.4