6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-18 13:34:04 +00:00
Code Issues Projects Releases Wiki Activity

blockfreq: Expose getPackagedNode()

Browse Source 
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
This commit is contained in:
Duncan P. N. Exon Smith 2014-04-25 04:38:12 +00:00
parent 3df8534be1
commit 7ed8c05157
2 changed files with 23 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
include/llvm/Analysis/BlockFrequencyInfoImpl.h
View File

@ -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(),

25
lib/Analysis/BlockFrequencyInfoImpl.cpp
View File

@ -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) {