[llvm] bf29495 - NFC: Migrate SimplifyCFG to work on InstructionCost
Sander de Smalen via llvm-commits
llvm-commits at lists.llvm.org
Mon Feb 1 08:14:43 PST 2021
Author: Sander de Smalen
Date: 2021-02-01T16:14:05Z
New Revision: bf294953e77089c314e431a7eb238cb353aa44d5
URL: https://github.com/llvm/llvm-project/commit/bf294953e77089c314e431a7eb238cb353aa44d5
DIFF: https://github.com/llvm/llvm-project/commit/bf294953e77089c314e431a7eb238cb353aa44d5.diff
LOG: NFC: Migrate SimplifyCFG to work on InstructionCost
This patch migrates cost values and arithmetic to work on InstructionCost.
When the interfaces to TargetTransformInfo are changed, any InstructionCost
state will propagate naturally.
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
Reviewed By: spatel
Differential Revision: https://reviews.llvm.org/D95351
Added:
Modified:
llvm/lib/Transforms/Utils/SimplifyCFG.cpp
Removed:
################################################################################
diff --git a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
index 7be430ac4dd9..b7184f25c183 100644
--- a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
+++ b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
@@ -335,8 +335,8 @@ static void AddPredecessorToBlock(BasicBlock *Succ, BasicBlock *NewPred,
/// which is assumed to be safe to speculate. TCC_Free means cheap,
/// TCC_Basic means less cheap, and TCC_Expensive means prohibitively
/// expensive.
-static unsigned computeSpeculationCost(const User *I,
- const TargetTransformInfo &TTI) {
+static InstructionCost computeSpeculationCost(const User *I,
+ const TargetTransformInfo &TTI) {
assert(isSafeToSpeculativelyExecute(I) &&
"Instruction is not safe to speculatively execute!");
return TTI.getUserCost(I, TargetTransformInfo::TCK_SizeAndLatency);
@@ -349,19 +349,20 @@ static unsigned computeSpeculationCost(const User *I,
///
/// If AggressiveInsts is non-null, and if V does not dominate BB, we check to
/// see if V (which must be an instruction) and its recursive operands
-/// that do not dominate BB have a combined cost lower than CostRemaining and
+/// that do not dominate BB have a combined cost lower than Budget and
/// are non-trapping. If both are true, the instruction is inserted into the
/// set and true is returned.
///
/// The cost for most non-trapping instructions is defined as 1 except for
/// Select whose cost is 2.
///
-/// After this function returns, CostRemaining is decreased by the cost of
+/// After this function returns, Cost is increased by the cost of
/// V plus its non-dominating operands. If that cost is greater than
-/// CostRemaining, false is returned and CostRemaining is undefined.
+/// Budget, false is returned and Cost is undefined.
static bool dominatesMergePoint(Value *V, BasicBlock *BB,
SmallPtrSetImpl<Instruction *> &AggressiveInsts,
- int &BudgetRemaining,
+ InstructionCost &Cost,
+ InstructionCost Budget,
const TargetTransformInfo &TTI,
unsigned Depth = 0) {
// It is possible to hit a zero-cost cycle (phi/gep instructions for example),
@@ -404,7 +405,7 @@ static bool dominatesMergePoint(Value *V, BasicBlock *BB,
if (!isSafeToSpeculativelyExecute(I))
return false;
- BudgetRemaining -= computeSpeculationCost(I, TTI);
+ Cost += computeSpeculationCost(I, TTI);
// Allow exactly one instruction to be speculated regardless of its cost
// (as long as it is safe to do so).
@@ -412,14 +413,15 @@ static bool dominatesMergePoint(Value *V, BasicBlock *BB,
// or other expensive operation. The speculation of an expensive instruction
// is expected to be undone in CodeGenPrepare if the speculation has not
// enabled further IR optimizations.
- if (BudgetRemaining < 0 &&
- (!SpeculateOneExpensiveInst || !AggressiveInsts.empty() || Depth > 0))
+ if (Cost > Budget &&
+ (!SpeculateOneExpensiveInst || !AggressiveInsts.empty() || Depth > 0 ||
+ !Cost.isValid()))
return false;
// Okay, we can only really hoist these out if their operands do
// not take us over the cost threshold.
for (User::op_iterator i = I->op_begin(), e = I->op_end(); i != e; ++i)
- if (!dominatesMergePoint(*i, BB, AggressiveInsts, BudgetRemaining, TTI,
+ if (!dominatesMergePoint(*i, BB, AggressiveInsts, Cost, Budget, TTI,
Depth + 1))
return false;
// Okay, it's safe to do this! Remember this instruction.
@@ -2113,7 +2115,7 @@ static Value *isSafeToSpeculateStore(Instruction *I, BasicBlock *BrBB,
static bool validateAndCostRequiredSelects(BasicBlock *BB, BasicBlock *ThenBB,
BasicBlock *EndBB,
unsigned &SpeculatedInstructions,
- int &BudgetRemaining,
+ InstructionCost &Cost,
const TargetTransformInfo &TTI) {
TargetTransformInfo::TargetCostKind CostKind =
BB->getParent()->hasMinSize()
@@ -2130,9 +2132,8 @@ static bool validateAndCostRequiredSelects(BasicBlock *BB, BasicBlock *ThenBB,
if (ThenV == OrigV)
continue;
- BudgetRemaining -=
- TTI.getCmpSelInstrCost(Instruction::Select, PN.getType(), nullptr,
- CmpInst::BAD_ICMP_PREDICATE, CostKind);
+ Cost += TTI.getCmpSelInstrCost(Instruction::Select, PN.getType(), nullptr,
+ CmpInst::BAD_ICMP_PREDICATE, CostKind);
// Don't convert to selects if we could remove undefined behavior instead.
if (passingValueIsAlwaysUndefined(OrigV, &PN) ||
@@ -2148,9 +2149,9 @@ static bool validateAndCostRequiredSelects(BasicBlock *BB, BasicBlock *ThenBB,
if ((ThenCE && !isSafeToSpeculativelyExecute(ThenCE)) ||
(OrigCE && !isSafeToSpeculativelyExecute(OrigCE)))
return false;
- unsigned OrigCost = OrigCE ? computeSpeculationCost(OrigCE, TTI) : 0;
- unsigned ThenCost = ThenCE ? computeSpeculationCost(ThenCE, TTI) : 0;
- unsigned MaxCost =
+ InstructionCost OrigCost = OrigCE ? computeSpeculationCost(OrigCE, TTI) : 0;
+ InstructionCost ThenCost = ThenCE ? computeSpeculationCost(ThenCE, TTI) : 0;
+ InstructionCost MaxCost =
2 * PHINodeFoldingThreshold * TargetTransformInfo::TCC_Basic;
if (OrigCost + ThenCost > MaxCost)
return false;
@@ -2213,8 +2214,8 @@ bool SimplifyCFGOpt::SpeculativelyExecuteBB(BranchInst *BI, BasicBlock *ThenBB,
BasicBlock *BB = BI->getParent();
BasicBlock *EndBB = ThenBB->getTerminator()->getSuccessor(0);
- int BudgetRemaining =
- PHINodeFoldingThreshold * TargetTransformInfo::TCC_Basic;
+ InstructionCost Budget =
+ PHINodeFoldingThreshold * TargetTransformInfo::TCC_Basic;
// If ThenBB is actually on the false edge of the conditional branch, remember
// to swap the select operands later.
@@ -2303,10 +2304,11 @@ bool SimplifyCFGOpt::SpeculativelyExecuteBB(BranchInst *BI, BasicBlock *ThenBB,
// Check that we can insert the selects and that it's not too expensive to do
// so.
bool Convert = SpeculatedStore != nullptr;
+ InstructionCost Cost = 0;
Convert |= validateAndCostRequiredSelects(BB, ThenBB, EndBB,
SpeculatedInstructions,
- BudgetRemaining, TTI);
- if (!Convert || BudgetRemaining < 0)
+ Cost, TTI);
+ if (!Convert || Cost > Budget)
return false;
// If we get here, we can hoist the instruction and if-convert.
@@ -2560,7 +2562,8 @@ static bool FoldTwoEntryPHINode(PHINode *PN, const TargetTransformInfo &TTI,
// instructions. While we are at it, keep track of the instructions
// that need to be moved to the dominating block.
SmallPtrSet<Instruction *, 4> AggressiveInsts;
- int BudgetRemaining =
+ InstructionCost Cost = 0;
+ InstructionCost Budget =
TwoEntryPHINodeFoldingThreshold * TargetTransformInfo::TCC_Basic;
bool Changed = false;
@@ -2574,9 +2577,9 @@ static bool FoldTwoEntryPHINode(PHINode *PN, const TargetTransformInfo &TTI,
}
if (!dominatesMergePoint(PN->getIncomingValue(0), BB, AggressiveInsts,
- BudgetRemaining, TTI) ||
+ Cost, Budget, TTI) ||
!dominatesMergePoint(PN->getIncomingValue(1), BB, AggressiveInsts,
- BudgetRemaining, TTI))
+ Cost, Budget, TTI))
return Changed;
}
@@ -3051,7 +3054,7 @@ bool llvm::FoldBranchToCommonDest(BranchInst *BI, DomTreeUpdater *DTU,
// transformation.
if (TTI) {
Type *Ty = BI->getCondition()->getType();
- unsigned Cost = TTI->getArithmeticInstrCost(Opc, Ty, CostKind);
+ InstructionCost Cost = TTI->getArithmeticInstrCost(Opc, Ty, CostKind);
if (InvertPredCond && (!PBI->getCondition()->hasOneUse() ||
!isa<CmpInst>(PBI->getCondition())))
Cost += TTI->getArithmeticInstrCost(Instruction::Xor, Ty, CostKind);
@@ -3185,7 +3188,8 @@ static bool mergeConditionalStoreToAddress(
// Heuristic: if the block can be if-converted/phi-folded and the
// instructions inside are all cheap (arithmetic/GEPs), it's worthwhile to
// thread this store.
- int BudgetRemaining =
+ InstructionCost Cost = 0;
+ InstructionCost Budget =
PHINodeFoldingThreshold * TargetTransformInfo::TCC_Basic;
for (auto &I : BB->instructionsWithoutDebug()) {
// Consider terminator instruction to be free.
@@ -3201,11 +3205,11 @@ static bool mergeConditionalStoreToAddress(
return false; // Not in white-list - not worthwhile folding.
// And finally, if this is a non-free instruction that we are okay
// speculating, ensure that we consider the speculation budget.
- BudgetRemaining -= TTI.getUserCost(&I, TargetTransformInfo::TCK_SizeAndLatency);
- if (BudgetRemaining < 0)
+ Cost += TTI.getUserCost(&I, TargetTransformInfo::TCK_SizeAndLatency);
+ if (Cost > Budget)
return false; // Eagerly refuse to fold as soon as we're out of budget.
}
- assert(BudgetRemaining >= 0 &&
+ assert(Cost <= Budget &&
"When we run out of budget we will eagerly return from within the "
"per-instruction loop.");
return true;
More information about the llvm-commits
mailing list