[SampleFDO][NFC] Refactor: make SampleProfileLoaderBaseImpl a template class

[xur]

Summary

This patch makes SampleProfileLoaderBaseImpl a template class so it can be
used in CodeGen transformation.

Noticeable changes:

• use one template parameter and use a typemap to get other used types.
• use a wrapper function getFunction to get IR level function.
• use a wrapper function getEntryBB to get first BB as MachineBasicBlock does not have this API.
• remove the temporary "inline" keywords in previous refactor patch.
• change the template function findEquivalencesFor to a regular function. This function has a single caller with type of PostDominatorTree. It's simpler to use the type directly because MachinePostDominatorTree is not a derived type of template DominatorTreeBase.

[dblaikie]

Really really broad feedback - this work to write common abstractions over LLVM IR and MIR seems to overlap with https://lists.llvm.org/pipermail/llvm-dev/2020-December/147433.html

It's non-trivial as to what exactly these APIs should look like (virtual/type erased v templates, etc). But may be useful to consider some of the options here.

My current rough guess is that templates are probably the right tool, but that more common abstractions should be implemented in the IR types themselves - eg: the TypeMap and getFunction/getEntryBB could be rolled into the IR types themselves as authoritative/core features, rather than grafting them on with traits.

llvm/include/llvm/Transforms/Utils/SampleProfileLoaderBaseImpl.h

50–71

Seems like a layering violation to be declaring these entities that aren't reachable from Transform/Utils?

Could the MIR TypeMap specialization be defined in the MIR library instead?

63

This should probably be a declaration (it should mean more immediate/explicit compilation failures):

template<typename BlockT> struct TypeMap;

(also I tend to suggest using typename rather than class - since they don't have any different meaning for C++ and typename more accurately describes what kind of entity can be used (though, yes, in this particular case the typenames do have to be classes))

llvm/lib/Transforms/IPO/SampleProfile.cpp

221–234

Perhaps these functions could be part of the TypeMap? (Generalizing TypeMap to "IRTraits" or something like that)

Alternatively they could be implemented as overloads, but part of traits is probably the right call.

[xur]

In D96981#2572663, @dblaikie wrote:

Really really broad feedback - this work to write common abstractions over LLVM IR and MIR seems to overlap with https://lists.llvm.org/pipermail/llvm-dev/2020-December/147433.html

It's non-trivial as to what exactly these APIs should look like (virtual/type erased v templates, etc). But may be useful to consider some of the options here.

My current rough guess is that templates are probably the right tool, but that more common abstractions should be implemented in the IR types themselves - eg: the TypeMap and getFunction/getEntryBB could be rolled into the IR types themselves as authoritative/core features, rather than grafting them on with traits.

David. Thanks for the comments!

Yes. If all the building blocks have a common obstructions, we probably can use other method to share the common transformation / analysis code b/w IR and MIR.
This template base method has been used in the code base (such as BlockFreqInfo, Dominator and DominatorFrontier).
For now, I think I will use the template base method as I have some other patches depending on this.

Once the common abstractions are in-place. I don't mind to refactor the code again if that is a better way for sharing the code.

[xur]

llvm/include/llvm/Transforms/Utils/SampleProfileLoaderBaseImpl.h

50–71

why this is a layering violation? I think this is just a forward declaration -- we don't need the definition (complete type) here.

63

TypeMap specialization needs to after the TypeMap definition, but before the uses of the types.
That means I need to put the code in header, and split line 63 to a common header files.
I think that is a littler messy than current way.

using typename is a good idea. I will change.

llvm/lib/Transforms/IPO/SampleProfile.cpp

221–234

I did not put into the TypeMap (or IRTraits) is because in current implementation, we don't have the complete type of the type parameters.
If we put these functions into traits, we need to expose the definition.

[dblaikie]

llvm/include/llvm/Transforms/Utils/SampleProfileLoaderBaseImpl.h

50–71

While it wouldn't break any build system I know about - it would break, for instance, in C++ standard modules (where declarations are owned by the module that declares them) and violates at least conceptual layering, that Transforms have nothing to do with MIR.

(Google's style guide talks about not forward declaring entities not in the same project - though what constitutes a "project" is a bit vague and probably doesn't quite apply here)

63

TypeMap specialization needs to after the TypeMap definition, but before the uses of the types.

I don't think that's the case. At least a small test case ( https://godbolt.org/z/ecjox8 ) appears to work as desired - and I'd expect /something/ like that to work, since it'd be quite common to specialize a template far away from where that template is defined and used, since it might need to be specialized with some type unknown to the template and the usage (as is/should be the case here).

[xur]

llvm/include/llvm/Transforms/Utils/SampleProfileLoaderBaseImpl.h

50–71

Thanks for the explanation. Good to know this!

63

Sorry that I did not make my point clear. I know the small test would work -- as it does have the problem I was talking about.

The "TypeMap definition" is like line 1 in the small test case. It needs to be before the specialization at line 4 and line 12.
In my code, line 4 and line 12 will be in a different header file (or I can keep one in the template header, but the other will go the MIR header).
This MIR header file need to be before the template header file. But line 1 needs to be before the MIR header file.
So line 1 needs to be moved from the template header -- so that it appears before line 4 and line 12.

But this is not a problem. Because the layer violation issue, I need to change it anyway.

[xur]

Integrated the comments from David Blaikie.

[dblaikie]

llvm/include/llvm/Transforms/Utils/SampleProfileLoaderBaseImpl.h

63

Sorry I'm not quite following.

Why would the MIR header file need to go before the template header file? In my example, all the MIR related things (struct b, and traits<b> specialization) came after the generic template/IR things.

I think the declaration of TypeMap/IRTraits could remain in SampleProfileLoaderBaseImpl.h for now.

[xur]

llvm/include/llvm/Transforms/Utils/SampleProfileLoaderBaseImpl.h

63

ah. OK. you are right!
I got the point now.

I will update the patch shortly.

[xur]

Integrated David's review comments.

[dblaikie]

Looks good, thanks!

llvm/include/llvm/Transforms/Utils/SampleProfileLoaderBaseImpl.h

52

This can be reduced to a declaration - might make for better compilation errors if the template is used without a specialization.

[xur]

llvm/include/llvm/Transforms/Utils/SampleProfileLoaderBaseImpl.h

52

Good point. Will change to a declaration.

[hoy]

We have an MCF-based counts inference algorithm to be integrated into the refactored framework later. The algorithm only works on IR so far since it leverages certain IR characteristics like Unreachable and Invoke instructions to distribute counts more reasonably. Looks like some sort of specialized code is needed. So far the refactoring looks good to me. Thanks.

[wmi]

LGTM.

llvm/include/llvm/Transforms/Utils/SampleProfileLoaderBaseImpl.h

 #include "llvm/ProfileData/SampleProf.h"
 #include "llvm/ProfileData/SampleProfReader.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/GenericDomTree.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Utils/SampleProfileLoaderBaseUtil.h"
 
 namespace llvm {
-using namespace llvm;
 using namespace sampleprof;
 using namespace sampleprofutil;
 using ProfileCount = Function::ProfileCount;
 
 #define DEBUG_TYPE "sample-profile-impl"
 
-using BlockWeightMap = DenseMap<const BasicBlock *, uint64_t>;
-using EquivalenceClassMap = DenseMap<const BasicBlock *, const BasicBlock *>;
-using Edge = std::pair<const BasicBlock *, const BasicBlock *>;
-using EdgeWeightMap = DenseMap<Edge, uint64_t>;
-using BlockEdgeMap =
-    DenseMap<const BasicBlock *, SmallVector<const BasicBlock *, 8>>;
+namespace afdo_detail {
+
+template <typename BlockT> struct IRTraits {};
+template <> struct IRTraits<BasicBlock> {
+  using InstructionT = Instruction;
+  using BasicBlockT = BasicBlock;
+  using FunctionT = Function;
+  using BlockFrequencyInfoT = BlockFrequencyInfo;
+  using LoopT = Loop;
+  using LoopInfoT = LoopInfo;
+  using OptRemarkEmitterT = OptimizationRemarkEmitter;
+  using OptRemarkAnalysisT = OptimizationRemarkAnalysis;
+  using DominatorTreeT = DominatorTree;
+  using PostDominatorTreeT = PostDominatorTree;
+  static Function &getFunction(Function &F) { return F; }
+  static const BasicBlock *getEntryBB(const Function *F) {
+    return &F->getEntryBlock();
+  }
+};
+
+} // end namespace afdo_detail
 
 extern cl::opt<unsigned> SampleProfileMaxPropagateIterations;
 extern cl::opt<unsigned> SampleProfileRecordCoverage;
 extern cl::opt<unsigned> SampleProfileSampleCoverage;
 extern cl::opt<bool> NoWarnSampleUnused;
 
-class SampleProfileLoaderBaseImpl {
+template <typename BT> class SampleProfileLoaderBaseImpl {
 public:
   SampleProfileLoaderBaseImpl(std::string Name) : Filename(Name) {}
   void dump() { Reader->dump(); }
 
+  using InstructionT = typename afdo_detail::IRTraits<BT>::InstructionT;
+  using BasicBlockT = typename afdo_detail::IRTraits<BT>::BasicBlockT;
+  using BlockFrequencyInfoT =
+      typename afdo_detail::IRTraits<BT>::BlockFrequencyInfoT;
+  using FunctionT = typename afdo_detail::IRTraits<BT>::FunctionT;
+  using LoopT = typename afdo_detail::IRTraits<BT>::LoopT;
+  using LoopInfoT = typename afdo_detail::IRTraits<BT>::LoopInfoT;
+  using OptRemarkEmitterT =
+      typename afdo_detail::IRTraits<BT>::OptRemarkEmitterT;
+  using OptRemarkAnalysisT =
+      typename afdo_detail::IRTraits<BT>::OptRemarkAnalysisT;
+  using DominatorTreeT = typename afdo_detail::IRTraits<BT>::DominatorTreeT;
+  using PostDominatorTreeT =
+      typename afdo_detail::IRTraits<BT>::PostDominatorTreeT;
+
+  using BlockWeightMap = DenseMap<const BasicBlockT *, uint64_t>;
+  using EquivalenceClassMap =
+      DenseMap<const BasicBlockT *, const BasicBlockT *>;
+  using Edge = std::pair<const BasicBlockT *, const BasicBlockT *>;
+  using EdgeWeightMap = DenseMap<Edge, uint64_t>;
+  using BlockEdgeMap =
+      DenseMap<const BasicBlockT *, SmallVector<const BasicBlockT *, 8>>;
+
 protected:
   ~SampleProfileLoaderBaseImpl() = default;
   friend class SampleCoverageTracker;
 
-  inline unsigned getFunctionLoc(Function &F);
-  inline virtual ErrorOr<uint64_t> getInstWeight(const Instruction &Inst);
-  inline ErrorOr<uint64_t> getInstWeightImpl(const Instruction &Inst);
-  inline ErrorOr<uint64_t> getBlockWeight(const BasicBlock *BB);
+  Function &getFunction(FunctionT &F) {
+    return afdo_detail::IRTraits<BT>::getFunction(F);
+  }
+  const BasicBlockT *getEntryBB(const FunctionT *F) {
+    return afdo_detail::IRTraits<BT>::getEntryBB(F);
+  }
+
+  unsigned getFunctionLoc(FunctionT &Func);
+  virtual ErrorOr<uint64_t> getInstWeight(const InstructionT &Inst);
+  ErrorOr<uint64_t> getInstWeightImpl(const InstructionT &Inst);
+  ErrorOr<uint64_t> getBlockWeight(const BasicBlockT *BB);
   mutable DenseMap<const DILocation *, const FunctionSamples *>
       DILocation2SampleMap;
-  inline virtual const FunctionSamples *
-  findFunctionSamples(const Instruction &I) const;
-  inline void printEdgeWeight(raw_ostream &OS, Edge E);
-  inline void printBlockWeight(raw_ostream &OS, const BasicBlock *BB) const;
-  inline void printBlockEquivalence(raw_ostream &OS, const BasicBlock *BB);
-  inline bool computeBlockWeights(Function &F);
-  inline void findEquivalenceClasses(Function &F);
-  template <bool IsPostDom>
-  inline void
-  findEquivalencesFor(BasicBlock *BB1, ArrayRef<BasicBlock *> Descendants,
-                      DominatorTreeBase<BasicBlock, IsPostDom> *DomTree);
-
-  inline void propagateWeights(Function &F);
-  inline uint64_t visitEdge(Edge E, unsigned *NumUnknownEdges,
-                            Edge *UnknownEdge);
-  inline void buildEdges(Function &F);
-  inline bool propagateThroughEdges(Function &F, bool UpdateBlockCount);
-  inline void clearFunctionData();
-  inline void computeDominanceAndLoopInfo(Function &F);
-  inline bool
-  computeAndPropagateWeights(Function &F,
+  virtual const FunctionSamples *
+  findFunctionSamples(const InstructionT &I) const;
+  void printEdgeWeight(raw_ostream &OS, Edge E);
+  void printBlockWeight(raw_ostream &OS, const BasicBlockT *BB) const;
+  void printBlockEquivalence(raw_ostream &OS, const BasicBlockT *BB);
+  bool computeBlockWeights(FunctionT &F);
+  void findEquivalenceClasses(FunctionT &F);
+  void findEquivalencesFor(BasicBlockT *BB1,
+                           ArrayRef<BasicBlockT *> Descendants,
+                           PostDominatorTreeT *DomTree);
+
+  void propagateWeights(FunctionT &F);
+  uint64_t visitEdge(Edge E, unsigned *NumUnknownEdges, Edge *UnknownEdge);
+  void buildEdges(FunctionT &F);
+  bool propagateThroughEdges(FunctionT &F, bool UpdateBlockCount);
+  void clearFunctionData();
+  void computeDominanceAndLoopInfo(FunctionT &F);
+  bool
+  computeAndPropagateWeights(FunctionT &F,
                              const DenseSet<GlobalValue::GUID> &InlinedGUIDs);
-  inline void emitCoverageRemarks(Function &F);
+  void emitCoverageRemarks(FunctionT &F);
 
   /// Map basic blocks to their computed weights.
   ///
   /// The weight of a basic block is defined to be the maximum
   /// of all the instruction weights in that block.
   BlockWeightMap BlockWeights;
 
   /// Map edges to their computed weights.
   ///
   /// Edge weights are computed by propagating basic block weights in
   /// SampleProfile::propagateWeights.
   EdgeWeightMap EdgeWeights;
 
   /// Set of visited blocks during propagation.
-  SmallPtrSet<const BasicBlock *, 32> VisitedBlocks;
+  SmallPtrSet<const BasicBlockT *, 32> VisitedBlocks;
 
   /// Set of visited edges during propagation.
   SmallSet<Edge, 32> VisitedEdges;
 
   /// Equivalence classes for block weights.
   ///
   /// Two blocks BB1 and BB2 are in the same equivalence class if they
   /// dominate and post-dominate each other, and they are in the same loop
   /// nest. When this happens, the two blocks are guaranteed to execute
   /// the same number of times.
   EquivalenceClassMap EquivalenceClass;
 
   /// Dominance, post-dominance and loop information.
-  std::unique_ptr<DominatorTree> DT;
-  std::unique_ptr<PostDominatorTree> PDT;
-  std::unique_ptr<LoopInfo> LI;
+  std::unique_ptr<DominatorTreeT> DT;
+  std::unique_ptr<PostDominatorTreeT> PDT;
+  std::unique_ptr<LoopInfoT> LI;
 
   /// Predecessors for each basic block in the CFG.
   BlockEdgeMap Predecessors;
 
   /// Successors for each basic block in the CFG.
   BlockEdgeMap Successors;
 
   /// Profile coverage tracker.
   SampleCoverageTracker CoverageTracker;
 
   /// Profile reader object.
   std::unique_ptr<SampleProfileReader> Reader;
 
   /// Samples collected for the body of this function.
   FunctionSamples *Samples = nullptr;
 
   /// Name of the profile file to load.
   std::string Filename;
 
   /// Profile Summary Info computed from sample profile.
   ProfileSummaryInfo *PSI = nullptr;
 
   /// Optimization Remark Emitter used to emit diagnostic remarks.
-  OptimizationRemarkEmitter *ORE = nullptr;
+  OptRemarkEmitterT *ORE = nullptr;
 };
 
 /// Clear all the per-function data used to load samples and propagate weights.
-void SampleProfileLoaderBaseImpl::clearFunctionData() {
+template <typename BT>
+void SampleProfileLoaderBaseImpl<BT>::clearFunctionData() {
   BlockWeights.clear();
   EdgeWeights.clear();
   VisitedBlocks.clear();
   VisitedEdges.clear();
   EquivalenceClass.clear();
   DT = nullptr;
   PDT = nullptr;
   LI = nullptr;
   Predecessors.clear();
   Successors.clear();
   CoverageTracker.clear();
 }
 
 #ifndef NDEBUG
 /// Print the weight of edge \p E on stream \p OS.
 ///
 /// \param OS  Stream to emit the output to.
 /// \param E  Edge to print.
-void SampleProfileLoaderBaseImpl::printEdgeWeight(raw_ostream &OS, Edge E) {
+template <typename BT>
+void SampleProfileLoaderBaseImpl<BT>::printEdgeWeight(raw_ostream &OS, Edge E) {
   OS << "weight[" << E.first->getName() << "->" << E.second->getName()
      << "]: " << EdgeWeights[E] << "\n";
 }
 
 /// Print the equivalence class of block \p BB on stream \p OS.
 ///
 /// \param OS  Stream to emit the output to.
 /// \param BB  Block to print.
-void SampleProfileLoaderBaseImpl::printBlockEquivalence(raw_ostream &OS,
-                                                        const BasicBlock *BB) {
-  const BasicBlock *Equiv = EquivalenceClass[BB];
+template <typename BT>
+void SampleProfileLoaderBaseImpl<BT>::printBlockEquivalence(
+    raw_ostream &OS, const BasicBlockT *BB) {
+  const BasicBlockT *Equiv = EquivalenceClass[BB];
   OS << "equivalence[" << BB->getName()
      << "]: " << ((Equiv) ? EquivalenceClass[BB]->getName() : "NONE") << "\n";
 }
 
 /// Print the weight of block \p BB on stream \p OS.
 ///
 /// \param OS  Stream to emit the output to.
 /// \param BB  Block to print.
-void SampleProfileLoaderBaseImpl::printBlockWeight(raw_ostream &OS,
-                                                   const BasicBlock *BB) const {
+template <typename BT>
+void SampleProfileLoaderBaseImpl<BT>::printBlockWeight(
+    raw_ostream &OS, const BasicBlockT *BB) const {
   const auto &I = BlockWeights.find(BB);
   uint64_t W = (I == BlockWeights.end() ? 0 : I->second);
   OS << "weight[" << BB->getName() << "]: " << W << "\n";
 }
 #endif
 
 /// Get the weight for an instruction.
 ///
 /// The "weight" of an instruction \p Inst is the number of samples
 /// collected on that instruction at runtime. To retrieve it, we
 /// need to compute the line number of \p Inst relative to the start of its
 /// function. We use HeaderLineno to compute the offset. We then
 /// look up the samples collected for \p Inst using BodySamples.
 ///
 /// \param Inst Instruction to query.
 ///
 /// \returns the weight of \p Inst.
+template <typename BT>
 ErrorOr<uint64_t>
-SampleProfileLoaderBaseImpl::getInstWeight(const Instruction &Inst) {
+SampleProfileLoaderBaseImpl<BT>::getInstWeight(const InstructionT &Inst) {
   return getInstWeightImpl(Inst);
 }
 
+template <typename BT>
 ErrorOr<uint64_t>
-SampleProfileLoaderBaseImpl::getInstWeightImpl(const Instruction &Inst) {
+SampleProfileLoaderBaseImpl<BT>::getInstWeightImpl(const InstructionT &Inst) {
   const FunctionSamples *FS = findFunctionSamples(Inst);
   if (!FS)
     return std::error_code();
 
   const DebugLoc &DLoc = Inst.getDebugLoc();
   if (!DLoc)
     return std::error_code();
 
   const DILocation *DIL = DLoc;
   uint32_t LineOffset = FunctionSamples::getOffset(DIL);
   uint32_t Discriminator = DIL->getBaseDiscriminator();
   ErrorOr<uint64_t> R = FS->findSamplesAt(LineOffset, Discriminator);
   if (R) {
     bool FirstMark =
         CoverageTracker.markSamplesUsed(FS, LineOffset, Discriminator, R.get());
     if (FirstMark) {
       ORE->emit([&]() {
-        OptimizationRemarkAnalysis Remark(DEBUG_TYPE, "AppliedSamples", &Inst);
+        OptRemarkAnalysisT Remark(DEBUG_TYPE, "AppliedSamples", &Inst);
         Remark << "Applied " << ore::NV("NumSamples", *R);
         Remark << " samples from profile (offset: ";
         Remark << ore::NV("LineOffset", LineOffset);
         if (Discriminator) {
           Remark << ".";
           Remark << ore::NV("Discriminator", Discriminator);
         }
         Remark << ")";

 /// Compute the weight of a basic block.
 ///
 /// The weight of basic block \p BB is the maximum weight of all the
 /// instructions in BB.
 ///
 /// \param BB The basic block to query.
 ///
 /// \returns the weight for \p BB.
+template <typename BT>
 ErrorOr<uint64_t>
-SampleProfileLoaderBaseImpl::getBlockWeight(const BasicBlock *BB) {
+SampleProfileLoaderBaseImpl<BT>::getBlockWeight(const BasicBlockT *BB) {
   uint64_t Max = 0;
   bool HasWeight = false;
-  for (auto &I : BB->getInstList()) {
+  for (auto &I : *BB) {
     const ErrorOr<uint64_t> &R = getInstWeight(I);
     if (R) {
       Max = std::max(Max, R.get());
       HasWeight = true;
     }
   }
   return HasWeight ? ErrorOr<uint64_t>(Max) : std::error_code();
 }
 
 /// Compute and store the weights of every basic block.
 ///
 /// This populates the BlockWeights map by computing
 /// the weights of every basic block in the CFG.
 ///
 /// \param F The function to query.
-bool SampleProfileLoaderBaseImpl::computeBlockWeights(Function &F) {
+template <typename BT>
+bool SampleProfileLoaderBaseImpl<BT>::computeBlockWeights(FunctionT &F) {
   bool Changed = false;
   LLVM_DEBUG(dbgs() << "Block weights\n");
   for (const auto &BB : F) {
     ErrorOr<uint64_t> Weight = getBlockWeight(&BB);
     if (Weight) {
       BlockWeights[&BB] = Weight.get();
       VisitedBlocks.insert(&BB);
       Changed = true;
     }
     LLVM_DEBUG(printBlockWeight(dbgs(), &BB));
   }
 
   return Changed;
 }
 
 /// Get the FunctionSamples for an instruction.
 ///
 /// The FunctionSamples of an instruction \p Inst is the inlined instance
 /// in which that instruction is coming from. We traverse the inline stack
 /// of that instruction, and match it with the tree nodes in the profile.
 ///
 /// \param Inst Instruction to query.
 ///
 /// \returns the FunctionSamples pointer to the inlined instance.
-const FunctionSamples *SampleProfileLoaderBaseImpl::findFunctionSamples(
-    const Instruction &Inst) const {
+template <typename BT>
+const FunctionSamples *SampleProfileLoaderBaseImpl<BT>::findFunctionSamples(
+    const InstructionT &Inst) const {
   const DILocation *DIL = Inst.getDebugLoc();
   if (!DIL)
     return Samples;
 
   auto it = DILocation2SampleMap.try_emplace(DIL, nullptr);
   if (it.second) {
     it.first->second = Samples->findFunctionSamples(DIL, Reader->getRemapper());
   }

 /// For every block BB2 that meets those two requirements, we set BB2's
 /// equivalence class to \p BB1.
 ///
 /// \param BB1  Block to check.
 /// \param Descendants  Descendants of \p BB1 in either the dom or pdom tree.
 /// \param DomTree  Opposite dominator tree. If \p Descendants is filled
 ///                 with blocks from \p BB1's dominator tree, then
 ///                 this is the post-dominator tree, and vice versa.
-template <bool IsPostDom>
-void SampleProfileLoaderBaseImpl::findEquivalencesFor(
-    BasicBlock *BB1, ArrayRef<BasicBlock *> Descendants,
-    DominatorTreeBase<BasicBlock, IsPostDom> *DomTree) {
-  const BasicBlock *EC = EquivalenceClass[BB1];
+template <typename BT>
+void SampleProfileLoaderBaseImpl<BT>::findEquivalencesFor(
+    BasicBlockT *BB1, ArrayRef<BasicBlockT *> Descendants,
+    PostDominatorTreeT *DomTree) {
+  const BasicBlockT *EC = EquivalenceClass[BB1];
   uint64_t Weight = BlockWeights[EC];
   for (const auto *BB2 : Descendants) {
     bool IsDomParent = DomTree->dominates(BB2, BB1);
     bool IsInSameLoop = LI->getLoopFor(BB1) == LI->getLoopFor(BB2);
     if (BB1 != BB2 && IsDomParent && IsInSameLoop) {
       EquivalenceClass[BB2] = EC;
       // If BB2 is visited, then the entire EC should be marked as visited.
       if (VisitedBlocks.count(BB2)) {
         VisitedBlocks.insert(EC);
       }
 
       // If BB2 is heavier than BB1, make BB2 have the same weight
       // as BB1.
       //
       // Note that we don't worry about the opposite situation here
       // (when BB2 is lighter than BB1). We will deal with this
       // during the propagation phase. Right now, we just want to
       // make sure that BB1 has the largest weight of all the
       // members of its equivalence set.
       Weight = std::max(Weight, BlockWeights[BB2]);
     }
   }
-  if (EC == &EC->getParent()->getEntryBlock()) {
+  const BasicBlockT *EntryBB = getEntryBB(EC->getParent());
+  if (EC == EntryBB) {
     BlockWeights[EC] = Samples->getHeadSamples() + 1;
   } else {
     BlockWeights[EC] = Weight;
   }
 }
 
 /// Find equivalence classes.
 ///
 /// Since samples may be missing from blocks, we can fill in the gaps by setting
 /// the weights of all the blocks in the same equivalence class to the same
 /// weight. To compute the concept of equivalence, we use dominance and loop
 /// information. Two blocks B1 and B2 are in the same equivalence class if B1
 /// dominates B2, B2 post-dominates B1 and both are in the same loop.
 ///
 /// \param F The function to query.
-void SampleProfileLoaderBaseImpl::findEquivalenceClasses(Function &F) {
-  SmallVector<BasicBlock *, 8> DominatedBBs;
+template <typename BT>
+void SampleProfileLoaderBaseImpl<BT>::findEquivalenceClasses(FunctionT &F) {
+  SmallVector<BasicBlockT *, 8> DominatedBBs;
   LLVM_DEBUG(dbgs() << "\nBlock equivalence classes\n");
   // Find equivalence sets based on dominance and post-dominance information.
   for (auto &BB : F) {
-    BasicBlock *BB1 = &BB;
+    BasicBlockT *BB1 = &BB;
 
     // Compute BB1's equivalence class once.
     if (EquivalenceClass.count(BB1)) {
       LLVM_DEBUG(printBlockEquivalence(dbgs(), BB1));
       continue;
     }
 
     // By default, blocks are in their own equivalence class.
void SampleProfileLoaderBaseImpl<BT>::findEquivalenceClasses(FunctionT &F) {
   //
   // All the basic blocks in the same equivalence class will execute
   // the same number of times. Since we know that the head block in
   // each equivalence class has the largest weight, assign that weight
   // to all the blocks in that equivalence class.
   LLVM_DEBUG(
       dbgs() << "\nAssign the same weight to all blocks in the same class\n");
   for (auto &BI : F) {
-    const BasicBlock *BB = &BI;
-    const BasicBlock *EquivBB = EquivalenceClass[BB];
+    const BasicBlockT *BB = &BI;
+    const BasicBlockT *EquivBB = EquivalenceClass[BB];
     if (BB != EquivBB)
       BlockWeights[BB] = BlockWeights[EquivBB];
     LLVM_DEBUG(printBlockWeight(dbgs(), BB));
   }
 }
 
 /// Visit the given edge to decide if it has a valid weight.
 ///
 /// If \p E has not been visited before, we copy to \p UnknownEdge
 /// and increment the count of unknown edges.
 ///
 /// \param E  Edge to visit.
 /// \param NumUnknownEdges  Current number of unknown edges.
 /// \param UnknownEdge  Set if E has not been visited before.
 ///
 /// \returns E's weight, if known. Otherwise, return 0.
-uint64_t SampleProfileLoaderBaseImpl::visitEdge(Edge E,
+template <typename BT>
+uint64_t SampleProfileLoaderBaseImpl<BT>::visitEdge(Edge E,
                                                     unsigned *NumUnknownEdges,
                                                     Edge *UnknownEdge) {
   if (!VisitedEdges.count(E)) {
     (*NumUnknownEdges)++;
     *UnknownEdge = E;
     return 0;
   }
 
   return EdgeWeights[E];
 }
 
 /// Propagate weights through incoming/outgoing edges.
 ///
 /// If the weight of a basic block is known, and there is only one edge
 /// with an unknown weight, we can calculate the weight of that edge.
 ///
 /// Similarly, if all the edges have a known count, we can calculate the
 /// count of the basic block, if needed.
 ///
 /// \param F  Function to process.
 /// \param UpdateBlockCount  Whether we should update basic block counts that
 ///                          has already been annotated.
 ///
 /// \returns  True if new weights were assigned to edges or blocks.
-bool SampleProfileLoaderBaseImpl::propagateThroughEdges(Function &F,
-                                                        bool UpdateBlockCount) {
+template <typename BT>
+bool SampleProfileLoaderBaseImpl<BT>::propagateThroughEdges(
+    FunctionT &F, bool UpdateBlockCount) {
   bool Changed = false;
   LLVM_DEBUG(dbgs() << "\nPropagation through edges\n");
   for (const auto &BI : F) {
-    const BasicBlock *BB = &BI;
-    const BasicBlock *EC = EquivalenceClass[BB];
+    const BasicBlockT *BB = &BI;
+    const BasicBlockT *EC = EquivalenceClass[BB];
 
     // Visit all the predecessor and successor edges to determine
     // which ones have a weight assigned already. Note that it doesn't
     // matter that we only keep track of a single unknown edge. The
     // only case we are interested in handling is when only a single
     // edge is unknown (see setEdgeOrBlockWeight).
     for (unsigned i = 0; i < 2; i++) {
       uint64_t TotalWeight = 0;
for (unsigned i = 0; i < 2; i++) {
           }
         } else if (NumUnknownEdges == 1 && VisitedBlocks.count(EC)) {
           // If there is a single unknown edge and the block has been
           // visited, then we can compute E's weight.
           if (BBWeight >= TotalWeight)
             EdgeWeights[UnknownEdge] = BBWeight - TotalWeight;
           else
             EdgeWeights[UnknownEdge] = 0;
-          const BasicBlock *OtherEC;
+          const BasicBlockT *OtherEC;
           if (i == 0)
             OtherEC = EquivalenceClass[UnknownEdge.first];
           else
             OtherEC = EquivalenceClass[UnknownEdge.second];
           // Edge weights should never exceed the BB weights it connects.
           if (VisitedBlocks.count(OtherEC) &&
               EdgeWeights[UnknownEdge] > BlockWeights[OtherEC])
             EdgeWeights[UnknownEdge] = BlockWeights[OtherEC];
bool SampleProfileLoaderBaseImpl<BT>::propagateThroughEdges(
 
   return Changed;
 }
 
 /// Build in/out edge lists for each basic block in the CFG.
 ///
 /// We are interested in unique edges. If a block B1 has multiple
 /// edges to another block B2, we only add a single B1->B2 edge.
-void SampleProfileLoaderBaseImpl::buildEdges(Function &F) {
+template <typename BT>
+void SampleProfileLoaderBaseImpl<BT>::buildEdges(FunctionT &F) {
   for (auto &BI : F) {
-    BasicBlock *B1 = &BI;
+    BasicBlockT *B1 = &BI;
 
     // Add predecessors for B1.
-    SmallPtrSet<BasicBlock *, 16> Visited;
+    SmallPtrSet<BasicBlockT *, 16> Visited;
     if (!Predecessors[B1].empty())
       llvm_unreachable("Found a stale predecessors list in a basic block.");
-    for (BasicBlock *B2 : predecessors(B1))
+    for (BasicBlockT *B2 : predecessors(B1))
       if (Visited.insert(B2).second)
         Predecessors[B1].push_back(B2);
 
     // Add successors for B1.
     Visited.clear();
     if (!Successors[B1].empty())
       llvm_unreachable("Found a stale successors list in a basic block.");
-    for (BasicBlock *B2 : successors(B1))
+    for (BasicBlockT *B2 : successors(B1))
       if (Visited.insert(B2).second)
         Successors[B1].push_back(B2);
   }
 }
 
 /// Propagate weights into edges
 ///
 /// The following rules are applied to every block BB in the CFG:
 ///
 /// - If BB has a single predecessor/successor, then the weight
 ///   of that edge is the weight of the block.
 ///
 /// - If all incoming or outgoing edges are known except one, and the
 ///   weight of the block is already known, the weight of the unknown
 ///   edge will be the weight of the block minus the sum of all the known
 ///   edges. If the sum of all the known edges is larger than BB's weight,
 ///   we set the unknown edge weight to zero.
 ///
 /// - If there is a self-referential edge, and the weight of the block is
 ///   known, the weight for that edge is set to the weight of the block
 ///   minus the weight of the other incoming edges to that block (if
 ///   known).
-void SampleProfileLoaderBaseImpl::propagateWeights(Function &F) {
+template <typename BT>
+void SampleProfileLoaderBaseImpl<BT>::propagateWeights(FunctionT &F) {
   bool Changed = true;
   unsigned I = 0;
 
   // If BB weight is larger than its corresponding loop's header BB weight,
   // use the BB weight to replace the loop header BB weight.
   for (auto &BI : F) {
-    BasicBlock *BB = &BI;
-    Loop *L = LI->getLoopFor(BB);
+    BasicBlockT *BB = &BI;
+    LoopT *L = LI->getLoopFor(BB);
     if (!L) {
       continue;
     }
-    BasicBlock *Header = L->getHeader();
+    BasicBlockT *Header = L->getHeader();
     if (Header && BlockWeights[BB] > BlockWeights[Header]) {
       BlockWeights[Header] = BlockWeights[BB];
     }
   }
 
   // Before propagation starts, build, for each block, a list of
   // unique predecessors and successors. This is necessary to handle
   // identical edges in multiway branches. Since we visit all blocks and all

 /// FIXME: Try to replace this propagation heuristic with a scheme
 /// that is guaranteed to finalize. A work-list approach similar to
 /// the standard value propagation algorithm used by SSA-CCP might
 /// work here.
 ///
 /// \param F The function to query.
 ///
 /// \returns true if \p F was modified. Returns false, otherwise.
-bool SampleProfileLoaderBaseImpl::computeAndPropagateWeights(
-    Function &F, const DenseSet<GlobalValue::GUID> &InlinedGUIDs) {
+template <typename BT>
+bool SampleProfileLoaderBaseImpl<BT>::computeAndPropagateWeights(
+    FunctionT &F, const DenseSet<GlobalValue::GUID> &InlinedGUIDs) {
   bool Changed = (InlinedGUIDs.size() != 0);
 
   // Compute basic block weights.
   Changed |= computeBlockWeights(F);
 
   if (Changed) {
     // Add an entry count to the function using the samples gathered at the
     // function entry.
     // Sets the GUIDs that are inlined in the profiled binary. This is used
     // for ThinLink to make correct liveness analysis, and also make the IR
     // match the profiled binary before annotation.
-    F.setEntryCount(
+    getFunction(F).setEntryCount(
         ProfileCount(Samples->getHeadSamples() + 1, Function::PCT_Real),
         &InlinedGUIDs);
 
     // Compute dominance and loop info needed for propagation.
     computeDominanceAndLoopInfo(F);
 
     // Find equivalence classes.
     findEquivalenceClasses(F);
 
     // Propagate weights to all edges.
     propagateWeights(F);
   }
 
   return Changed;
 }
 
-void SampleProfileLoaderBaseImpl::emitCoverageRemarks(Function &F) {
+template <typename BT>
+void SampleProfileLoaderBaseImpl<BT>::emitCoverageRemarks(FunctionT &F) {
   // If coverage checking was requested, compute it now.
+  const Function &Func = getFunction(F);
   if (SampleProfileRecordCoverage) {
     unsigned Used = CoverageTracker.countUsedRecords(Samples, PSI);
     unsigned Total = CoverageTracker.countBodyRecords(Samples, PSI);
     unsigned Coverage = CoverageTracker.computeCoverage(Used, Total);
     if (Coverage < SampleProfileRecordCoverage) {
-      F.getContext().diagnose(DiagnosticInfoSampleProfile(
-          F.getSubprogram()->getFilename(), getFunctionLoc(F),
+      Func.getContext().diagnose(DiagnosticInfoSampleProfile(
+          Func.getSubprogram()->getFilename(), getFunctionLoc(F),
           Twine(Used) + " of " + Twine(Total) + " available profile records (" +
               Twine(Coverage) + "%) were applied",
           DS_Warning));
     }
   }
 
   if (SampleProfileSampleCoverage) {
     uint64_t Used = CoverageTracker.getTotalUsedSamples();
     uint64_t Total = CoverageTracker.countBodySamples(Samples, PSI);
     unsigned Coverage = CoverageTracker.computeCoverage(Used, Total);
     if (Coverage < SampleProfileSampleCoverage) {
-      F.getContext().diagnose(DiagnosticInfoSampleProfile(
-          F.getSubprogram()->getFilename(), getFunctionLoc(F),
+      Func.getContext().diagnose(DiagnosticInfoSampleProfile(
+          Func.getSubprogram()->getFilename(), getFunctionLoc(F),
           Twine(Used) + " of " + Twine(Total) + " available profile samples (" +
               Twine(Coverage) + "%) were applied",
           DS_Warning));
     }
   }
 }
 
 /// Get the line number for the function header.
 ///
 /// This looks up function \p F in the current compilation unit and
 /// retrieves the line number where the function is defined. This is
 /// line 0 for all the samples read from the profile file. Every line
 /// number is relative to this line.
 ///
 /// \param F  Function object to query.
 ///
 /// \returns the line number where \p F is defined. If it returns 0,
 ///          it means that there is no debug information available for \p F.
-unsigned SampleProfileLoaderBaseImpl::getFunctionLoc(Function &F) {
+template <typename BT>
+unsigned SampleProfileLoaderBaseImpl<BT>::getFunctionLoc(FunctionT &Func) {
+  const Function &F = getFunction(Func);
   if (DISubprogram *S = F.getSubprogram())
     return S->getLine();
 
   if (NoWarnSampleUnused)
     return 0;
 
   // If the start of \p F is missing, emit a diagnostic to inform the user
   // about the missed opportunity.
   F.getContext().diagnose(DiagnosticInfoSampleProfile(
       "No debug information found in function " + F.getName() +
           ": Function profile not used",
       DS_Warning));
   return 0;
 }
 
-void SampleProfileLoaderBaseImpl::computeDominanceAndLoopInfo(Function &F) {
-  DT.reset(new DominatorTree);
+template <typename BT>
+void SampleProfileLoaderBaseImpl<BT>::computeDominanceAndLoopInfo(
+    FunctionT &F) {
+  DT.reset(new DominatorTreeT);
   DT->recalculate(F);
 
   PDT.reset(new PostDominatorTree(F));
 
-  LI.reset(new LoopInfo);
+  LI.reset(new LoopInfoT);
   LI->analyze(*DT);
 }
 
 #undef DEBUG_TYPE
 
 } // namespace llvm
 #endif // LLVM_TRANSFORMS_UTILS_SAMPLEPROFILELOADERIMPL_H

llvm/lib/Transforms/IPO/SampleProfile.cpp

 
 static cl::opt<std::string> ProfileInlineReplayFile(
     "sample-profile-inline-replay", cl::init(""), cl::value_desc("filename"),
     cl::desc(
         "Optimization remarks file containing inline remarks to be replayed "
         "by inlining from sample profile loader."),
     cl::Hidden);
 
 namespace {
 
 using BlockWeightMap = DenseMap<const BasicBlock *, uint64_t>;
 using EquivalenceClassMap = DenseMap<const BasicBlock *, const BasicBlock *>;
 using Edge = std::pair<const BasicBlock *, const BasicBlock *>;
 using EdgeWeightMap = DenseMap<Edge, uint64_t>;
 using BlockEdgeMap =
     DenseMap<const BasicBlock *, SmallVector<const BasicBlock *, 8>>;
 
 class GUIDToFuncNameMapper {
 public:
   GUIDToFuncNameMapper(Module &M, SampleProfileReader &Reader,
                        DenseMap<uint64_t, StringRef> &GUIDToFuncNameMap)
       : CurrentReader(Reader), CurrentModule(M),
         CurrentGUIDToFuncNameMap(GUIDToFuncNameMap) {
     if (!CurrentReader.useMD5())
       return;
 
     for (const auto &F : CurrentModule) {
       StringRef OrigName = F.getName();
       CurrentGUIDToFuncNameMap.insert(
           {Function::getGUID(OrigName), OrigName});
using CandidateQueue =
     PriorityQueue<InlineCandidate, std::vector<InlineCandidate>,
                   CandidateComparer>;
 
 /// Sample profile pass.
 ///
 /// This pass reads profile data from the file specified by
 /// -sample-profile-file and annotates every affected function with the
 /// profile information found in that file.
-class SampleProfileLoader final : public SampleProfileLoaderBaseImpl {
+class SampleProfileLoader final
+    : public SampleProfileLoaderBaseImpl<BasicBlock> {
 public:
   SampleProfileLoader(
       StringRef Name, StringRef RemapName, ThinOrFullLTOPhase LTOPhase,
       std::function<AssumptionCache &(Function &)> GetAssumptionCache,
       std::function<TargetTransformInfo &(Function &)> GetTargetTransformInfo,
       std::function<const TargetLibraryInfo &(Function &)> GetTLI)
       : SampleProfileLoaderBaseImpl(std::string(Name)),
         GetAC(std::move(GetAssumptionCache)),