[llvm] 7af408e - [JumpThreading][NFC] Improved access to LazyValueInfoImpl.
via llvm-commits
llvm-commits at lists.llvm.org
Sun Sep 3 20:52:02 PDT 2023
Author: DianQK
Date: 2023-09-04T11:50:14+08:00
New Revision: 7af408e89bd0915ff830fea8824e05d8f7e71d4d
URL: https://github.com/llvm/llvm-project/commit/7af408e89bd0915ff830fea8824e05d8f7e71d4d
DIFF: https://github.com/llvm/llvm-project/commit/7af408e89bd0915ff830fea8824e05d8f7e71d4d.diff
LOG: [JumpThreading][NFC] Improved access to LazyValueInfoImpl.
Added:
Modified:
llvm/include/llvm/Analysis/LazyValueInfo.h
llvm/lib/Analysis/LazyValueInfo.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Analysis/LazyValueInfo.h b/llvm/include/llvm/Analysis/LazyValueInfo.h
index 7b2bfdac75a8fa..f013a4a75d3d6a 100644
--- a/llvm/include/llvm/Analysis/LazyValueInfo.h
+++ b/llvm/include/llvm/Analysis/LazyValueInfo.h
@@ -26,117 +26,120 @@ namespace llvm {
class Instruction;
class TargetLibraryInfo;
class Value;
-
-/// This pass computes, caches, and vends lazy value constraint information.
-class LazyValueInfo {
- friend class LazyValueInfoWrapperPass;
- AssumptionCache *AC = nullptr;
- const DataLayout *DL = nullptr;
- class TargetLibraryInfo *TLI = nullptr;
- void *PImpl = nullptr;
- LazyValueInfo(const LazyValueInfo&) = delete;
- void operator=(const LazyValueInfo&) = delete;
-public:
- ~LazyValueInfo();
- LazyValueInfo() = default;
- LazyValueInfo(AssumptionCache *AC_, const DataLayout *DL_,
- TargetLibraryInfo *TLI_)
- : AC(AC_), DL(DL_), TLI(TLI_) {}
- LazyValueInfo(LazyValueInfo &&Arg)
- : AC(Arg.AC), DL(Arg.DL), TLI(Arg.TLI), PImpl(Arg.PImpl) {
- Arg.PImpl = nullptr;
- }
- LazyValueInfo &operator=(LazyValueInfo &&Arg) {
- releaseMemory();
- AC = Arg.AC;
- DL = Arg.DL;
- TLI = Arg.TLI;
- PImpl = Arg.PImpl;
- Arg.PImpl = nullptr;
- return *this;
- }
-
- /// This is used to return true/false/dunno results.
- enum Tristate {
- Unknown = -1, False = 0, True = 1
+ class LazyValueInfoImpl;
+ /// This pass computes, caches, and vends lazy value constraint information.
+ class LazyValueInfo {
+ friend class LazyValueInfoWrapperPass;
+ AssumptionCache *AC = nullptr;
+ const DataLayout *DL = nullptr;
+ class TargetLibraryInfo *TLI = nullptr;
+ LazyValueInfoImpl *PImpl = nullptr;
+ LazyValueInfo(const LazyValueInfo &) = delete;
+ void operator=(const LazyValueInfo &) = delete;
+
+ LazyValueInfoImpl *getImpl();
+ LazyValueInfoImpl &getOrCreateImpl(const Module *M);
+
+ public:
+ ~LazyValueInfo();
+ LazyValueInfo() = default;
+ LazyValueInfo(AssumptionCache *AC_, const DataLayout *DL_,
+ TargetLibraryInfo *TLI_)
+ : AC(AC_), DL(DL_), TLI(TLI_) {}
+ LazyValueInfo(LazyValueInfo &&Arg)
+ : AC(Arg.AC), DL(Arg.DL), TLI(Arg.TLI), PImpl(Arg.PImpl) {
+ Arg.PImpl = nullptr;
+ }
+ LazyValueInfo &operator=(LazyValueInfo &&Arg) {
+ releaseMemory();
+ AC = Arg.AC;
+ DL = Arg.DL;
+ TLI = Arg.TLI;
+ PImpl = Arg.PImpl;
+ Arg.PImpl = nullptr;
+ return *this;
+ }
+
+ /// This is used to return true/false/dunno results.
+ enum Tristate { Unknown = -1, False = 0, True = 1 };
+
+ // Public query interface.
+
+ /// Determine whether the specified value comparison with a constant is
+ /// known to be true or false on the specified CFG edge. Pred is a CmpInst
+ /// predicate.
+ Tristate getPredicateOnEdge(unsigned Pred, Value *V, Constant *C,
+ BasicBlock *FromBB, BasicBlock *ToBB,
+ Instruction *CxtI = nullptr);
+
+ /// Determine whether the specified value comparison with a constant is
+ /// known to be true or false at the specified instruction. \p Pred is a
+ /// CmpInst predicate. If \p UseBlockValue is true, the block value is also
+ /// taken into account.
+ Tristate getPredicateAt(unsigned Pred, Value *V, Constant *C,
+ Instruction *CxtI, bool UseBlockValue);
+
+ /// Determine whether the specified value comparison is known to be true
+ /// or false at the specified instruction. While this takes two Value's,
+ /// it still requires that one of them is a constant.
+ /// \p Pred is a CmpInst predicate.
+ /// If \p UseBlockValue is true, the block value is also taken into account.
+ Tristate getPredicateAt(unsigned Pred, Value *LHS, Value *RHS,
+ Instruction *CxtI, bool UseBlockValue);
+
+ /// Determine whether the specified value is known to be a constant at the
+ /// specified instruction. Return null if not.
+ Constant *getConstant(Value *V, Instruction *CxtI);
+
+ /// Return the ConstantRange constraint that is known to hold for the
+ /// specified value at the specified instruction. This may only be called
+ /// on integer-typed Values.
+ ConstantRange getConstantRange(Value *V, Instruction *CxtI,
+ bool UndefAllowed = true);
+
+ /// Return the ConstantRange constraint that is known to hold for the value
+ /// at a specific use-site.
+ ConstantRange getConstantRangeAtUse(const Use &U, bool UndefAllowed = true);
+
+ /// Determine whether the specified value is known to be a
+ /// constant on the specified edge. Return null if not.
+ Constant *getConstantOnEdge(Value *V, BasicBlock *FromBB, BasicBlock *ToBB,
+ Instruction *CxtI = nullptr);
+
+ /// Return the ConstantRage constraint that is known to hold for the
+ /// specified value on the specified edge. This may be only be called
+ /// on integer-typed Values.
+ ConstantRange getConstantRangeOnEdge(Value *V, BasicBlock *FromBB,
+ BasicBlock *ToBB,
+ Instruction *CxtI = nullptr);
+
+ /// Inform the analysis cache that we have threaded an edge from
+ /// PredBB to OldSucc to be from PredBB to NewSucc instead.
+ void threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc,
+ BasicBlock *NewSucc);
+
+ /// Remove information related to this value from the cache.
+ void forgetValue(Value *V);
+
+ /// Inform the analysis cache that we have erased a block.
+ void eraseBlock(BasicBlock *BB);
+
+ /// Complete flush all previously computed values
+ void clear();
+
+ /// Print the \LazyValueInfo Analysis.
+ /// We pass in the DTree that is required for identifying which basic blocks
+ /// we can solve/print for, in the LVIPrinter.
+ void printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS);
+
+ // For old PM pass. Delete once LazyValueInfoWrapperPass is gone.
+ void releaseMemory();
+
+ /// Handle invalidation events in the new pass manager.
+ bool invalidate(Function &F, const PreservedAnalyses &PA,
+ FunctionAnalysisManager::Invalidator &Inv);
};
- // Public query interface.
-
- /// Determine whether the specified value comparison with a constant is known
- /// to be true or false on the specified CFG edge.
- /// Pred is a CmpInst predicate.
- Tristate getPredicateOnEdge(unsigned Pred, Value *V, Constant *C,
- BasicBlock *FromBB, BasicBlock *ToBB,
- Instruction *CxtI = nullptr);
-
- /// Determine whether the specified value comparison with a constant is known
- /// to be true or false at the specified instruction.
- /// \p Pred is a CmpInst predicate. If \p UseBlockValue is true, the block
- /// value is also taken into account.
- Tristate getPredicateAt(unsigned Pred, Value *V, Constant *C,
- Instruction *CxtI, bool UseBlockValue);
-
- /// Determine whether the specified value comparison is known to be true
- /// or false at the specified instruction. While this takes two Value's,
- /// it still requires that one of them is a constant.
- /// \p Pred is a CmpInst predicate.
- /// If \p UseBlockValue is true, the block value is also taken into account.
- Tristate getPredicateAt(unsigned Pred, Value *LHS, Value *RHS,
- Instruction *CxtI, bool UseBlockValue);
-
- /// Determine whether the specified value is known to be a constant at the
- /// specified instruction. Return null if not.
- Constant *getConstant(Value *V, Instruction *CxtI);
-
- /// Return the ConstantRange constraint that is known to hold for the
- /// specified value at the specified instruction. This may only be called
- /// on integer-typed Values.
- ConstantRange getConstantRange(Value *V, Instruction *CxtI,
- bool UndefAllowed = true);
-
- /// Return the ConstantRange constraint that is known to hold for the value
- /// at a specific use-site.
- ConstantRange getConstantRangeAtUse(const Use &U, bool UndefAllowed = true);
-
- /// Determine whether the specified value is known to be a
- /// constant on the specified edge. Return null if not.
- Constant *getConstantOnEdge(Value *V, BasicBlock *FromBB, BasicBlock *ToBB,
- Instruction *CxtI = nullptr);
-
- /// Return the ConstantRage constraint that is known to hold for the
- /// specified value on the specified edge. This may be only be called
- /// on integer-typed Values.
- ConstantRange getConstantRangeOnEdge(Value *V, BasicBlock *FromBB,
- BasicBlock *ToBB,
- Instruction *CxtI = nullptr);
-
- /// Inform the analysis cache that we have threaded an edge from
- /// PredBB to OldSucc to be from PredBB to NewSucc instead.
- void threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc, BasicBlock *NewSucc);
-
- /// Remove information related to this value from the cache.
- void forgetValue(Value *V);
-
- /// Inform the analysis cache that we have erased a block.
- void eraseBlock(BasicBlock *BB);
-
- /// Complete flush all previously computed values
- void clear(const Module *M);
-
- /// Print the \LazyValueInfo Analysis.
- /// We pass in the DTree that is required for identifying which basic blocks
- /// we can solve/print for, in the LVIPrinter.
- void printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS);
-
- // For old PM pass. Delete once LazyValueInfoWrapperPass is gone.
- void releaseMemory();
-
- /// Handle invalidation events in the new pass manager.
- bool invalidate(Function &F, const PreservedAnalyses &PA,
- FunctionAnalysisManager::Invalidator &Inv);
-};
-
/// Analysis to compute lazy value information.
class LazyValueAnalysis : public AnalysisInfoMixin<LazyValueAnalysis> {
public:
diff --git a/llvm/lib/Analysis/LazyValueInfo.cpp b/llvm/lib/Analysis/LazyValueInfo.cpp
index 2ba6036056d991..80136a090a8010 100644
--- a/llvm/lib/Analysis/LazyValueInfo.cpp
+++ b/llvm/lib/Analysis/LazyValueInfo.cpp
@@ -336,11 +336,10 @@ void LazyValueInfoCache::threadEdgeImpl(BasicBlock *OldSucc,
}
}
-
+namespace llvm {
namespace {
/// An assembly annotator class to print LazyValueCache information in
/// comments.
-class LazyValueInfoImpl;
class LazyValueInfoAnnotatedWriter : public AssemblyAnnotationWriter {
LazyValueInfoImpl *LVIImpl;
// While analyzing which blocks we can solve values for, we need the dominator
@@ -357,8 +356,7 @@ class LazyValueInfoAnnotatedWriter : public AssemblyAnnotationWriter {
void emitInstructionAnnot(const Instruction *I,
formatted_raw_ostream &OS) override;
};
-}
-namespace {
+} // namespace
// The actual implementation of the lazy analysis and update. Note that the
// inheritance from LazyValueInfoCache is intended to be temporary while
// splitting the code and then transitioning to a has-a relationship.
@@ -483,8 +481,7 @@ class LazyValueInfoImpl {
Function *GuardDecl)
: AC(AC), DL(DL), GuardDecl(GuardDecl) {}
};
-} // end anonymous namespace
-
+} // namespace llvm
void LazyValueInfoImpl::solve() {
SmallVector<std::pair<BasicBlock *, Value *>, 8> StartingStack(
@@ -1546,25 +1543,12 @@ void LazyValueInfoImpl::threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc,
// LazyValueInfo Impl
//===----------------------------------------------------------------------===//
-/// This lazily constructs the LazyValueInfoImpl.
-static LazyValueInfoImpl &getImpl(void *&PImpl, AssumptionCache *AC,
- const Module *M) {
- if (!PImpl) {
- assert(M && "getCache() called with a null Module");
- const DataLayout &DL = M->getDataLayout();
- Function *GuardDecl = M->getFunction(
- Intrinsic::getName(Intrinsic::experimental_guard));
- PImpl = new LazyValueInfoImpl(AC, DL, GuardDecl);
- }
- return *static_cast<LazyValueInfoImpl*>(PImpl);
-}
-
bool LazyValueInfoWrapperPass::runOnFunction(Function &F) {
Info.AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
Info.TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
- if (Info.PImpl)
- getImpl(Info.PImpl, Info.AC, F.getParent()).clear();
+ if (auto *Impl = Info.getImpl())
+ Impl->clear();
// Fully lazy.
return false;
@@ -1578,12 +1562,30 @@ void LazyValueInfoWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
LazyValueInfo &LazyValueInfoWrapperPass::getLVI() { return Info; }
+/// This lazily constructs the LazyValueInfoImpl.
+LazyValueInfoImpl &LazyValueInfo::getOrCreateImpl(const Module *M) {
+ if (!PImpl) {
+ assert(M && "getCache() called with a null Module");
+ const DataLayout &DL = M->getDataLayout();
+ Function *GuardDecl =
+ M->getFunction(Intrinsic::getName(Intrinsic::experimental_guard));
+ PImpl = new LazyValueInfoImpl(AC, DL, GuardDecl);
+ }
+ return *static_cast<LazyValueInfoImpl *>(PImpl);
+}
+
+LazyValueInfoImpl *LazyValueInfo::getImpl() {
+ if (!PImpl)
+ return nullptr;
+ return static_cast<LazyValueInfoImpl *>(PImpl);
+}
+
LazyValueInfo::~LazyValueInfo() { releaseMemory(); }
void LazyValueInfo::releaseMemory() {
// If the cache was allocated, free it.
- if (PImpl) {
- delete &getImpl(PImpl, AC, nullptr);
+ if (auto *Impl = getImpl()) {
+ delete &*Impl;
PImpl = nullptr;
}
}
@@ -1630,7 +1632,7 @@ Constant *LazyValueInfo::getConstant(Value *V, Instruction *CxtI) {
BasicBlock *BB = CxtI->getParent();
ValueLatticeElement Result =
- getImpl(PImpl, AC, BB->getModule()).getValueInBlock(V, BB, CxtI);
+ getOrCreateImpl(BB->getModule()).getValueInBlock(V, BB, CxtI);
if (Result.isConstant())
return Result.getConstant();
@@ -1648,7 +1650,7 @@ ConstantRange LazyValueInfo::getConstantRange(Value *V, Instruction *CxtI,
unsigned Width = V->getType()->getIntegerBitWidth();
BasicBlock *BB = CxtI->getParent();
ValueLatticeElement Result =
- getImpl(PImpl, AC, BB->getModule()).getValueInBlock(V, BB, CxtI);
+ getOrCreateImpl(BB->getModule()).getValueInBlock(V, BB, CxtI);
if (Result.isUnknown())
return ConstantRange::getEmpty(Width);
if (Result.isConstantRange(UndefAllowed))
@@ -1714,7 +1716,7 @@ Constant *LazyValueInfo::getConstantOnEdge(Value *V, BasicBlock *FromBB,
Instruction *CxtI) {
Module *M = FromBB->getModule();
ValueLatticeElement Result =
- getImpl(PImpl, AC, M).getValueOnEdge(V, FromBB, ToBB, CxtI);
+ getOrCreateImpl(M).getValueOnEdge(V, FromBB, ToBB, CxtI);
if (Result.isConstant())
return Result.getConstant();
@@ -1733,7 +1735,7 @@ ConstantRange LazyValueInfo::getConstantRangeOnEdge(Value *V,
unsigned Width = V->getType()->getIntegerBitWidth();
Module *M = FromBB->getModule();
ValueLatticeElement Result =
- getImpl(PImpl, AC, M).getValueOnEdge(V, FromBB, ToBB, CxtI);
+ getOrCreateImpl(M).getValueOnEdge(V, FromBB, ToBB, CxtI);
if (Result.isUnknown())
return ConstantRange::getEmpty(Width);
@@ -1819,7 +1821,7 @@ LazyValueInfo::getPredicateOnEdge(unsigned Pred, Value *V, Constant *C,
Instruction *CxtI) {
Module *M = FromBB->getModule();
ValueLatticeElement Result =
- getImpl(PImpl, AC, M).getValueOnEdge(V, FromBB, ToBB, CxtI);
+ getOrCreateImpl(M).getValueOnEdge(V, FromBB, ToBB, CxtI);
return getPredicateResult(Pred, C, Result, M->getDataLayout(), TLI);
}
@@ -1841,9 +1843,10 @@ LazyValueInfo::getPredicateAt(unsigned Pred, Value *V, Constant *C,
return LazyValueInfo::True;
}
- ValueLatticeElement Result = UseBlockValue
- ? getImpl(PImpl, AC, M).getValueInBlock(V, CxtI->getParent(), CxtI)
- : getImpl(PImpl, AC, M).getValueAt(V, CxtI);
+ auto &Impl = getOrCreateImpl(M);
+ ValueLatticeElement Result =
+ UseBlockValue ? Impl.getValueInBlock(V, CxtI->getParent(), CxtI)
+ : Impl.getValueAt(V, CxtI);
Tristate Ret = getPredicateResult(Pred, C, Result, DL, TLI);
if (Ret != Unknown)
return Ret;
@@ -1947,12 +1950,12 @@ LazyValueInfo::Tristate LazyValueInfo::getPredicateAt(unsigned P, Value *LHS,
if (UseBlockValue) {
Module *M = CxtI->getModule();
ValueLatticeElement L =
- getImpl(PImpl, AC, M).getValueInBlock(LHS, CxtI->getParent(), CxtI);
+ getOrCreateImpl(M).getValueInBlock(LHS, CxtI->getParent(), CxtI);
if (L.isOverdefined())
return LazyValueInfo::Unknown;
ValueLatticeElement R =
- getImpl(PImpl, AC, M).getValueInBlock(RHS, CxtI->getParent(), CxtI);
+ getOrCreateImpl(M).getValueInBlock(RHS, CxtI->getParent(), CxtI);
Type *Ty = CmpInst::makeCmpResultType(LHS->getType());
if (Constant *Res = L.getCompare((CmpInst::Predicate)P, Ty, R,
M->getDataLayout())) {
@@ -1967,33 +1970,28 @@ LazyValueInfo::Tristate LazyValueInfo::getPredicateAt(unsigned P, Value *LHS,
void LazyValueInfo::threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc,
BasicBlock *NewSucc) {
- if (PImpl) {
- getImpl(PImpl, AC, PredBB->getModule())
- .threadEdge(PredBB, OldSucc, NewSucc);
- }
+ if (auto *Impl = getImpl())
+ Impl->threadEdge(PredBB, OldSucc, NewSucc);
}
void LazyValueInfo::forgetValue(Value *V) {
- if (PImpl)
- getImpl(PImpl, AC, nullptr).forgetValue(V);
+ if (auto *Impl = getImpl())
+ getImpl()->forgetValue(V);
}
void LazyValueInfo::eraseBlock(BasicBlock *BB) {
- if (PImpl) {
- getImpl(PImpl, AC, BB->getModule()).eraseBlock(BB);
- }
+ if (auto *Impl = getImpl())
+ getImpl()->eraseBlock(BB);
}
-void LazyValueInfo::clear(const Module *M) {
- if (PImpl) {
- getImpl(PImpl, AC, M).clear();
- }
+void LazyValueInfo::clear() {
+ if (auto *Impl = getImpl())
+ getImpl()->clear();
}
void LazyValueInfo::printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS) {
- if (PImpl) {
- getImpl(PImpl, AC, F.getParent()).printLVI(F, DTree, OS);
- }
+ if (auto *Impl = getImpl())
+ getImpl()->printLVI(F, DTree, OS);
}
// Print the LVI for the function arguments at the start of each basic block.
More information about the llvm-commits
mailing list