blockfreq: Expose getPackagedNode()

Make `getPackagedNode()` a member function of
`BlockFrequencyInfoImplBase` so that it's available for templated code.

<rdar://problem/14292693>

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207183 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Analysis/BlockFrequencyInfoImpl.h b/include/llvm/Analysis/BlockFrequencyInfoImpl.h
index f9978cc1c47eaff5c9a754140fcab13594dd77d5..c0e4ddfeb5705ab52d335af83b59e9503ecf907f 100644 (file)
--- a/include/llvm/Analysis/BlockFrequencyInfoImpl.h
+++ b/include/llvm/Analysis/BlockFrequencyInfoImpl.h
@@ -1093,6 +1093,28 @@ public:
     return *Working[Head.Index].Loop;
   }
 
+  /// \brief Get a possibly packaged node.
+  ///
+  /// Get the node currently representing Node, which could be a containing
+  /// loop.
+  ///
+  /// This function should only be called when distributing mass.  As long as
+  /// there are no irreducilbe edges to Node, then it will have complexity O(1)
+  /// in this context.
+  ///
+  /// In general, the complexity is O(L), where L is the number of loop headers
+  /// Node has been packaged into.  Since this method is called in the context
+  /// of distributing mass, L will be the number of loop headers an early exit
+  /// edge jumps out of.
+  BlockNode getPackagedNode(const BlockNode &Node) {
+    assert(Node.isValid());
+    if (!Working[Node.Index].isPackaged())
+      return Node;
+    if (!Working[Node.Index].isAPackage())
+      return Node;
+    return getPackagedNode(Working[Node.Index].getContainingHeader());
+  }
+
   /// \brief Distribute mass according to a distribution.
   ///
   /// Distributes the mass in Source according to Dist.  If LoopHead.isValid(),

diff --git a/lib/Analysis/BlockFrequencyInfoImpl.cpp b/lib/Analysis/BlockFrequencyInfoImpl.cpp
index 761bda5aa9b2bc038ef330c3ce635b06fb2a14f4..d58a7435a352bff2bb8336d80006e0a5dbd54d6a 100644 (file)
--- a/lib/Analysis/BlockFrequencyInfoImpl.cpp
+++ b/lib/Analysis/BlockFrequencyInfoImpl.cpp
@@ -614,29 +614,6 @@ static void cleanup(BlockFrequencyInfoImplBase &BFI) {
   BFI.Freqs = std::move(SavedFreqs);
 }
 
-/// \brief Get a possibly packaged node.
-///
-/// Get the node currently representing Node, which could be a containing
-/// loop.
-///
-/// This function should only be called when distributing mass.  As long as
-/// there are no irreducilbe edges to Node, then it will have complexity O(1)
-/// in this context.
-///
-/// In general, the complexity is O(L), where L is the number of loop headers
-/// Node has been packaged into.  Since this method is called in the context
-/// of distributing mass, L will be the number of loop headers an early exit
-/// edge jumps out of.
-static BlockNode getPackagedNode(const BlockFrequencyInfoImplBase &BFI,
-                                 const BlockNode &Node) {
-  assert(Node.isValid());
-  if (!BFI.Working[Node.Index].isPackaged())
-    return Node;
-  if (!BFI.Working[Node.Index].isAPackage())
-    return Node;
-  return getPackagedNode(BFI, BFI.Working[Node.Index].getContainingHeader());
-}
-
 /// \brief Get the appropriate mass for a possible pseudo-node loop package.
 ///
 /// Get appropriate mass for Node.  If Node is a loop-header (whose loop has
@@ -682,7 +659,7 @@ void BlockFrequencyInfoImplBase::addToDist(Distribution &Dist,
     Dist.addBackedge(OuterLoop->getHeader(), Weight);
     return;
   }
-  BlockNode Resolved = getPackagedNode(*this, Succ);
+  BlockNode Resolved = getPackagedNode(Succ);
   assert(!isLoopHeader(Resolved));
 
   if (Working[Resolved.Index].getContainingLoop() != OuterLoop) {