[JumpThreading] Invalidate LVI after combineMetadataForCSE.

llvm/include/llvm/Analysis/LazyValueInfo.h

@@ -26,114 +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);
-
-  /// 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: