[llvm] change contents of ScalarEvolution from private to protected (PR #83052)
Joshua Ferguson via llvm-commits
llvm-commits at lists.llvm.org
Thu Feb 29 08:34:16 PST 2024
https://github.com/skewballfox updated https://github.com/llvm/llvm-project/pull/83052
>From eea887cf6be39856fa441ed48f72c1c9177a76a6 Mon Sep 17 00:00:00 2001
From: Joshua Ferguson <joshua.ferguson.273 at gmail.com>
Date: Sun, 25 Feb 2024 14:06:02 -0600
Subject: [PATCH 1/4] mainly pushing to switch machines
---
llvm/include/llvm/Analysis/ScalarEvolution.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h
index 0880f9c65aa45d..1b03437de30c28 100644
--- a/llvm/include/llvm/Analysis/ScalarEvolution.h
+++ b/llvm/include/llvm/Analysis/ScalarEvolution.h
@@ -1345,7 +1345,7 @@ class ScalarEvolution {
}
};
-private:
+protected:
/// A CallbackVH to arrange for ScalarEvolution to be notified whenever a
/// Value is deleted.
class SCEVCallbackVH final : public CallbackVH {
>From e47436b767d635c14c10fc8c0bfc4fe30b8967d6 Mon Sep 17 00:00:00 2001
From: skewballfox <joshua.ferguson.273 at gmail.com>
Date: Thu, 29 Feb 2024 08:35:45 -0600
Subject: [PATCH 2/4] added AssumeLoopExits bool to SE, lifting MustExit code
into SE
---
llvm/include/llvm/Analysis/ScalarEvolution.h | 9 ++-
.../llvm/Analysis/Utils/EnzymeFunctionUtils.h | 71 +++++++++++++++++++
llvm/lib/Analysis/ScalarEvolution.cpp | 8 ++-
3 files changed, 84 insertions(+), 4 deletions(-)
create mode 100644 llvm/include/llvm/Analysis/Utils/EnzymeFunctionUtils.h
diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h
index 1b03437de30c28..3075358e95791f 100644
--- a/llvm/include/llvm/Analysis/ScalarEvolution.h
+++ b/llvm/include/llvm/Analysis/ScalarEvolution.h
@@ -460,6 +460,9 @@ class ScalarEvolution {
LoopComputable ///< The SCEV varies predictably with the loop.
};
+ bool AssumeLoopExists = false;
+ void setAssumeLoopExists();
+
/// An enum describing the relationship between a SCEV and a basic block.
enum BlockDisposition {
DoesNotDominateBlock, ///< The SCEV does not dominate the block.
@@ -1345,7 +1348,7 @@ class ScalarEvolution {
}
};
-protected:
+ private:
/// A CallbackVH to arrange for ScalarEvolution to be notified whenever a
/// Value is deleted.
class SCEVCallbackVH final : public CallbackVH {
@@ -1364,7 +1367,7 @@ class ScalarEvolution {
/// The function we are analyzing.
Function &F;
-
+
/// Does the module have any calls to the llvm.experimental.guard intrinsic
/// at all? If this is false, we avoid doing work that will only help if
/// thare are guards present in the IR.
@@ -1765,7 +1768,7 @@ class ScalarEvolution {
/// an arbitrary expression as opposed to only constants.
const SCEV *computeSymbolicMaxBackedgeTakenCount(const Loop *L);
- // Helper functions for computeExitLimitFromCond to avoid exponential time
+// Helper functions for computeExitLimitFromCond to avoid exponential time
// complexity.
class ExitLimitCache {
diff --git a/llvm/include/llvm/Analysis/Utils/EnzymeFunctionUtils.h b/llvm/include/llvm/Analysis/Utils/EnzymeFunctionUtils.h
new file mode 100644
index 00000000000000..a211bdca6a47d6
--- /dev/null
+++ b/llvm/include/llvm/Analysis/Utils/EnzymeFunctionUtils.h
@@ -0,0 +1,71 @@
+
+#include "llvm/Analysis/AliasAnalysis.h"
+#include "llvm/Analysis/LoopAnalysisManager.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
+
+#include "llvm/IR/Function.h"
+
+#include "llvm/IR/Instructions.h"
+#include "llvm/Transforms/Utils/ValueMapper.h"
+#include <deque>
+
+
+// TODO note this doesn't go through [loop, unreachable], and we could get more
+// performance by doing this can consider doing some domtree magic potentially
+static inline llvm::SmallPtrSet<llvm::BasicBlock *, 4>
+getGuaranteedUnreachable(llvm::Function *F) {
+ llvm::SmallPtrSet<llvm::BasicBlock *, 4> knownUnreachables;
+ if (F->empty())
+ return knownUnreachables;
+ std::deque<llvm::BasicBlock *> todo;
+ for (auto &BB : *F) {
+ todo.push_back(&BB);
+ }
+
+ while (!todo.empty()) {
+ llvm::BasicBlock *next = todo.front();
+ todo.pop_front();
+
+ if (knownUnreachables.find(next) != knownUnreachables.end())
+ continue;
+
+ if (llvm::isa<llvm::ReturnInst>(next->getTerminator()))
+ continue;
+
+ if (llvm::isa<llvm::UnreachableInst>(next->getTerminator())) {
+ knownUnreachables.insert(next);
+ for (llvm::BasicBlock *Pred : predecessors(next)) {
+ todo.push_back(Pred);
+ }
+ continue;
+ }
+
+ // Assume resumes don't happen
+ // TODO consider EH
+ if (llvm::isa<llvm::ResumeInst>(next->getTerminator())) {
+ knownUnreachables.insert(next);
+ for (llvm::BasicBlock *Pred : predecessors(next)) {
+ todo.push_back(Pred);
+ }
+ continue;
+ }
+
+ bool unreachable = true;
+ for (llvm::BasicBlock *Succ : llvm::successors(next)) {
+ if (knownUnreachables.find(Succ) == knownUnreachables.end()) {
+ unreachable = false;
+ break;
+ }
+ }
+
+ if (!unreachable)
+ continue;
+ knownUnreachables.insert(next);
+ for (llvm::BasicBlock *Pred : llvm::predecessors(next)) {
+ todo.push_back(Pred);
+ }
+ continue;
+ }
+
+ return knownUnreachables;
+}
\ No newline at end of file
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index 4b2db80bc1ec30..6dc59108f5e188 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -82,6 +82,7 @@
#include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/Config/llvm-config.h"
+#include "llvm/Analysis/Utils/EnzymeFunctionUtils.h"
#include "llvm/IR/Argument.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/CFG.h"
@@ -509,6 +510,10 @@ const SCEV *ScalarEvolution::getVScale(Type *Ty) {
return S;
}
+void ScalarEvolution::setAssumeLoopExists() {
+ this->AssumeLoopExists=true;
+}
+
SCEVCastExpr::SCEVCastExpr(const FoldingSetNodeIDRef ID, SCEVTypes SCEVTy,
const SCEV *op, Type *ty)
: SCEV(ID, SCEVTy, computeExpressionSize(op)), Op(op), Ty(ty) {}
@@ -7413,7 +7418,7 @@ bool ScalarEvolution::loopIsFiniteByAssumption(const Loop *L) {
// A mustprogress loop without side effects must be finite.
// TODO: The check used here is very conservative. It's only *specific*
// side effects which are well defined in infinite loops.
- return isFinite(L) || (isMustProgress(L) && loopHasNoSideEffects(L));
+ return this->AssumeLoopExists || isFinite(L) || (isMustProgress(L) && loopHasNoSideEffects(L));
}
const SCEV *ScalarEvolution::createSCEVIter(Value *V) {
@@ -13354,6 +13359,7 @@ const SCEV *ScalarEvolution::getElementSize(Instruction *Inst) {
return getSizeOfExpr(ETy, Ty);
}
+
//===----------------------------------------------------------------------===//
// SCEVCallbackVH Class Implementation
//===----------------------------------------------------------------------===//
>From f55e361a3ba1d4a5ca30f4b9719d23d57d273cc5 Mon Sep 17 00:00:00 2001
From: skewballfox <joshua.ferguson.273 at gmail.com>
Date: Thu, 29 Feb 2024 09:51:55 -0600
Subject: [PATCH 3/4] added MustExitcode for computeExitLimit
---
llvm/include/llvm/Analysis/ScalarEvolution.h | 7 ++--
.../llvm/Analysis/Utils/EnzymeFunctionUtils.h | 1 -
llvm/lib/Analysis/ScalarEvolution.cpp | 32 +++++++++++++++----
3 files changed, 30 insertions(+), 10 deletions(-)
diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h
index 3075358e95791f..4cc1954c1233f6 100644
--- a/llvm/include/llvm/Analysis/ScalarEvolution.h
+++ b/llvm/include/llvm/Analysis/ScalarEvolution.h
@@ -462,6 +462,7 @@ class ScalarEvolution {
bool AssumeLoopExists = false;
void setAssumeLoopExists();
+ llvm::SmallPtrSet<llvm::BasicBlock *, 4> GuaranteedUnreachable;
/// An enum describing the relationship between a SCEV and a basic block.
enum BlockDisposition {
@@ -1348,7 +1349,7 @@ class ScalarEvolution {
}
};
- private:
+private:
/// A CallbackVH to arrange for ScalarEvolution to be notified whenever a
/// Value is deleted.
class SCEVCallbackVH final : public CallbackVH {
@@ -1367,7 +1368,7 @@ class ScalarEvolution {
/// The function we are analyzing.
Function &F;
-
+
/// Does the module have any calls to the llvm.experimental.guard intrinsic
/// at all? If this is false, we avoid doing work that will only help if
/// thare are guards present in the IR.
@@ -1768,7 +1769,7 @@ class ScalarEvolution {
/// an arbitrary expression as opposed to only constants.
const SCEV *computeSymbolicMaxBackedgeTakenCount(const Loop *L);
-// Helper functions for computeExitLimitFromCond to avoid exponential time
+ // Helper functions for computeExitLimitFromCond to avoid exponential time
// complexity.
class ExitLimitCache {
diff --git a/llvm/include/llvm/Analysis/Utils/EnzymeFunctionUtils.h b/llvm/include/llvm/Analysis/Utils/EnzymeFunctionUtils.h
index a211bdca6a47d6..59032cbe6dddd4 100644
--- a/llvm/include/llvm/Analysis/Utils/EnzymeFunctionUtils.h
+++ b/llvm/include/llvm/Analysis/Utils/EnzymeFunctionUtils.h
@@ -9,7 +9,6 @@
#include "llvm/Transforms/Utils/ValueMapper.h"
#include <deque>
-
// TODO note this doesn't go through [loop, unreachable], and we could get more
// performance by doing this can consider doing some domtree magic potentially
static inline llvm::SmallPtrSet<llvm::BasicBlock *, 4>
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index 6dc59108f5e188..c1071f07b7f280 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -80,9 +80,9 @@
#include "llvm/Analysis/MemoryBuiltins.h"
#include "llvm/Analysis/ScalarEvolutionExpressions.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
+#include "llvm/Analysis/Utils/EnzymeFunctionUtils.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/Config/llvm-config.h"
-#include "llvm/Analysis/Utils/EnzymeFunctionUtils.h"
#include "llvm/IR/Argument.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/CFG.h"
@@ -510,9 +510,7 @@ const SCEV *ScalarEvolution::getVScale(Type *Ty) {
return S;
}
-void ScalarEvolution::setAssumeLoopExists() {
- this->AssumeLoopExists=true;
-}
+void ScalarEvolution::setAssumeLoopExists() { this->AssumeLoopExists = true; }
SCEVCastExpr::SCEVCastExpr(const FoldingSetNodeIDRef ID, SCEVTypes SCEVTy,
const SCEV *op, Type *ty)
@@ -7418,7 +7416,8 @@ bool ScalarEvolution::loopIsFiniteByAssumption(const Loop *L) {
// A mustprogress loop without side effects must be finite.
// TODO: The check used here is very conservative. It's only *specific*
// side effects which are well defined in infinite loops.
- return this->AssumeLoopExists || isFinite(L) || (isMustProgress(L) && loopHasNoSideEffects(L));
+ return this->AssumeLoopExists || isFinite(L) ||
+ (isMustProgress(L) && loopHasNoSideEffects(L));
}
const SCEV *ScalarEvolution::createSCEVIter(Value *V) {
@@ -8833,6 +8832,26 @@ ScalarEvolution::computeBackedgeTakenCount(const Loop *L,
ScalarEvolution::ExitLimit
ScalarEvolution::computeExitLimit(const Loop *L, BasicBlock *ExitingBlock,
bool AllowPredicates) {
+ if (AssumeLoopExists) {
+ SmallVector<BasicBlock *, 8> ExitingBlocks;
+ L->getExitingBlocks(ExitingBlocks);
+ for (auto &ExitingBlock : ExitingBlocks) {
+ BasicBlock *Exit = nullptr;
+ for (auto *SBB : successors(ExitingBlock)) {
+ if (!L->contains(SBB)) {
+ if (GuaranteedUnreachable.count(SBB))
+ continue;
+ Exit = SBB;
+ break;
+ }
+ }
+ if (!Exit)
+ ExitingBlock = nullptr;
+ }
+ ExitingBlocks.erase(
+ std::remove(ExitingBlocks.begin(), ExitingBlocks.end(), nullptr),
+ ExitingBlocks.end());
+ }
assert(L->contains(ExitingBlock) && "Exit count for non-loop block?");
// If our exiting block does not dominate the latch, then its connection with
// loop's exit limit may be far from trivial.
@@ -8858,6 +8877,8 @@ ScalarEvolution::computeExitLimit(const Loop *L, BasicBlock *ExitingBlock,
BasicBlock *Exit = nullptr;
for (auto *SBB : successors(ExitingBlock))
if (!L->contains(SBB)) {
+ if (AssumeLoopExists and GuaranteedUnreachable.count(SBB))
+ continue;
if (Exit) // Multiple exit successors.
return getCouldNotCompute();
Exit = SBB;
@@ -13359,7 +13380,6 @@ const SCEV *ScalarEvolution::getElementSize(Instruction *Inst) {
return getSizeOfExpr(ETy, Ty);
}
-
//===----------------------------------------------------------------------===//
// SCEVCallbackVH Class Implementation
//===----------------------------------------------------------------------===//
>From 8e85c0653be244e036e68eb31a4022ff05b23257 Mon Sep 17 00:00:00 2001
From: skewballfox <joshua.ferguson.273 at gmail.com>
Date: Thu, 29 Feb 2024 10:33:22 -0600
Subject: [PATCH 4/4] added enzyme mustExit code to
computeExitLimitFromSingleExitSwitch
---
llvm/lib/Analysis/ScalarEvolution.cpp | 10 ++++++++--
1 file changed, 8 insertions(+), 2 deletions(-)
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index c1071f07b7f280..d28436e02466be 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -9264,8 +9264,14 @@ ScalarEvolution::computeExitLimitFromSingleExitSwitch(const Loop *L,
if (Switch->getDefaultDest() == ExitingBlock)
return getCouldNotCompute();
- assert(L->contains(Switch->getDefaultDest()) &&
- "Default case must not exit the loop!");
+ // if not using enzyme executes by default
+ // if using enzyme and the code is guaranteed unreachable,
+ // the default destination doesn't matter
+ if (!AssumeLoopExists ||
+ !GuaranteedUnreachable.count(Switch->getDefaultDest())) {
+ assert(L->contains(Switch->getDefaultDest()) &&
+ "Default case must not exit the loop!");
+ }
const SCEV *LHS = getSCEVAtScope(Switch->getCondition(), L);
const SCEV *RHS = getConstant(Switch->findCaseDest(ExitingBlock));
More information about the llvm-commits
mailing list