[LazyBFI] Split out and templatize LazyBlockFrequencyInfo, NFC

[anemet]

Summary

This will be used by the LazyMachineBFI pass.

(I am posting this for completeness but I am planning to commit this with post-commit review as part of the patchset.)

include/llvm/Analysis/LazyBlockFrequencyInfo.h

 #include "llvm/Pass.h"
 
 namespace llvm {
 class AnalysisUsage;
 class BranchProbabilityInfo;
 class Function;
 class LoopInfo;
 
-/// \brief This is an alternative analysis pass to
-/// BlockFrequencyInfoWrapperPass.  The difference is that with this pass the
-/// block frequencies are not computed when the analysis pass is executed but
-/// rather when the BFI results is explicitly requested by the analysis client.
-///
-/// There are some additional requirements for any client pass that wants to use
-/// the analysis:
-///
-/// 1. The pass needs to initialize dependent passes with:
-///
-///   INITIALIZE_PASS_DEPENDENCY(LazyBFIPass)
-///
-/// 2. Similarly, getAnalysisUsage should call:
-///
-///   LazyBlockFrequencyInfoPass::getLazyBFIAnalysisUsage(AU)
-///
-/// 3. The computed BFI should be requested with
-///    getAnalysis<LazyBlockFrequencyInfoPass>().getBFI() before either LoopInfo
-///    or BPI could be invalidated for example by changing the CFG.
-///
-/// Note that it is expected that we wouldn't need this functionality for the
-/// new PM since with the new PM, analyses are executed on demand.
-class LazyBlockFrequencyInfoPass : public FunctionPass {
-
-  /// Wraps a BFI to allow lazy computation of the block frequencies.
-  ///
-  /// A pass that only conditionally uses BFI can uncondtionally require the
-  /// analysis without paying for the overhead if BFI doesn't end up being used.
-  class LazyBlockFrequencyInfo {
-  public:
-    LazyBlockFrequencyInfo()
-        : Calculated(false), F(nullptr), BPIPass(nullptr), LI(nullptr) {}
+template <typename FunctionT, typename LazyBranchProbabilityInfoPassT,
+          typename LoopInfoT, typename BlockFrequencyInfoT>
 
-    /// Set up the per-function input.
-    void setAnalysis(const Function *F, LazyBranchProbabilityInfoPass *BPIPass,
-                     const LoopInfo *LI) {
-      this->F = F;
-      this->BPIPass = BPIPass;
-      this->LI = LI;
-    }
+  void setAnalysis(const FunctionT *F, LazyBranchProbabilityInfoPassT *BPIPass,
+                   const LoopInfoT *LI) {
 
-    /// Retrieve the BFI with the block frequencies computed.
-    BlockFrequencyInfo &getCalculated() {
-      if (!Calculated) {
-        assert(F && BPIPass && LI && "call setAnalysis");
-        BFI.calculate(*F, BPIPass->getBPI(), *LI);
-        Calculated = true;
-      }
-      return BFI;
-    }
+  BlockFrequencyInfoT &getCalculated() {
 
-    const BlockFrequencyInfo &getCalculated() const {
-      return const_cast<LazyBlockFrequencyInfo *>(this)->getCalculated();
-    }
+  const BlockFrequencyInfoT &getCalculated() const {
 
-    void releaseMemory() {
-      BFI.releaseMemory();
-      Calculated = false;
-      setAnalysis(nullptr, nullptr, nullptr);
-    }
 
-  private:
-    BlockFrequencyInfo BFI;
-    bool Calculated;
-    const Function *F;
-    LazyBranchProbabilityInfoPass *BPIPass;
-    const LoopInfo *LI;
-  };
+  BlockFrequencyInfoT BFI;
+  const FunctionT *F;
+  LazyBranchProbabilityInfoPassT *BPIPass;
+  const LoopInfoT *LI;
 
-  LazyBlockFrequencyInfo LBFI;
+/// \brief This is an alternative analysis pass to
+/// BlockFrequencyInfoWrapperPass.  The difference is that with this pass the
+/// block frequencies are not computed when the analysis pass is executed but
+/// rather when the BFI results is explicitly requested by the analysis client.
+///
+/// There are some additional requirements for any client pass that wants to use
+/// the analysis:
+///
+/// 1. The pass needs to initialize dependent passes with:
+///
+///   INITIALIZE_PASS_DEPENDENCY(LazyBFIPass)
+///
+/// 2. Similarly, getAnalysisUsage should call:
+///
+///   LazyBlockFrequencyInfoPass::getLazyBFIAnalysisUsage(AU)
+///
+/// 3. The computed BFI should be requested with
+///    getAnalysis<LazyBlockFrequencyInfoPass>().getBFI() before either LoopInfo
+///    or BPI could be invalidated for example by changing the CFG.
+///
+/// Note that it is expected that we wouldn't need this functionality for the
+/// new PM since with the new PM, analyses are executed on demand.
+
+class LazyBlockFrequencyInfoPass : public FunctionPass {
+private:
+  LazyBlockFrequencyInfo<Function, LazyBranchProbabilityInfoPass, LoopInfo,
+                         BlockFrequencyInfo>
+      LBFI;
 
 public:
   static char ID;
 
   LazyBlockFrequencyInfoPass();
 
   /// \brief Compute and return the block frequencies.
   BlockFrequencyInfo &getBFI() { return LBFI.getCalculated(); }