LoopData(LoopData *Parent, const BlockNode &Header)
: Parent(Parent), Header(Header), IsPackaged(false) {}
LoopData(LoopData *Parent, const BlockNode &Header)
: Parent(Parent), Header(Header), IsPackaged(false) {}
+ bool isHeader(const BlockNode &Node) const { return Node == Header; }
+ BlockNode getHeader() const { return Header; }
};
/// \brief Index of loop information.
};
/// \brief Index of loop information.
WorkingData(const BlockNode &Node) : Node(Node), Loop(nullptr) {}
WorkingData(const BlockNode &Node) : Node(Node), Loop(nullptr) {}
- bool isLoopHeader() const { return Loop && Loop->Header == Node; }
+ bool isLoopHeader() const { return Loop && Loop->isHeader(Node); }
bool hasLoopHeader() const { return isLoopHeader() ? Loop->Parent : Loop; }
LoopData *getContainingLoop() const {
bool hasLoopHeader() const { return isLoopHeader() ? Loop->Parent : Loop; }
LoopData *getContainingLoop() const {
BlockNode getContainingHeader() const {
auto *ContainingLoop = getContainingLoop();
if (ContainingLoop)
BlockNode getContainingHeader() const {
auto *ContainingLoop = getContainingLoop();
if (ContainingLoop)
- return ContainingLoop->Header;
+ return ContainingLoop->getHeader();
template <class BT>
void BlockFrequencyInfoImpl<BT>::computeMassInLoop(LoopData &Loop) {
// Compute mass in loop.
template <class BT>
void BlockFrequencyInfoImpl<BT>::computeMassInLoop(LoopData &Loop) {
// Compute mass in loop.
- DEBUG(dbgs() << "compute-mass-in-loop: " << getBlockName(Loop.Header)
+ DEBUG(dbgs() << "compute-mass-in-loop: " << getBlockName(Loop.getHeader())
- Working[Loop.Header.Index].Mass = BlockMass::getFull();
- propagateMassToSuccessors(&Loop, Loop.Header);
+ Working[Loop.getHeader().Index].Mass = BlockMass::getFull();
+ propagateMassToSuccessors(&Loop, Loop.getHeader());
for (const BlockNode &M : Loop.Members)
propagateMassToSuccessors(&Loop, M);
for (const BlockNode &M : Loop.Members)
propagateMassToSuccessors(&Loop, M);
DEBUG(dbgs() << " - node: " << getBlockName(Node) << "\n");
// Calculate probability for successors.
Distribution Dist;
DEBUG(dbgs() << " - node: " << getBlockName(Node) << "\n");
// Calculate probability for successors.
Distribution Dist;
- BlockNode LoopHead;
- if (OuterLoop)
- LoopHead = OuterLoop->Header;
- if (Node != LoopHead && Working[Node.Index].isLoopHeader())
+ if (Working[Node.Index].isLoopHeader() &&
+ Working[Node.Index].Loop != OuterLoop)
addLoopSuccessorsToDist(OuterLoop, *Working[Node.Index].Loop, Dist);
else {
const BlockT *BB = getBlock(Node);
addLoopSuccessorsToDist(OuterLoop, *Working[Node.Index].Loop, Dist);
else {
const BlockT *BB = getBlock(Node);
- BlockNode LoopHead;
- if (OuterLoop)
- LoopHead = OuterLoop->Header;
+ auto isLoopHeader = [&OuterLoop](const BlockNode &Node) {
+ return OuterLoop && OuterLoop->isHeader(Node);
+ };
#ifndef NDEBUG
auto debugSuccessor = [&](const char *Type, const BlockNode &Resolved) {
dbgs() << " =>"
<< " [" << Type << "] weight = " << Weight;
#ifndef NDEBUG
auto debugSuccessor = [&](const char *Type, const BlockNode &Resolved) {
dbgs() << " =>"
<< " [" << Type << "] weight = " << Weight;
+ if (!isLoopHeader(Succ))
dbgs() << ", succ = " << getBlockName(Succ);
if (Resolved != Succ)
dbgs() << ", resolved = " << getBlockName(Resolved);
dbgs() << ", succ = " << getBlockName(Succ);
if (Resolved != Succ)
dbgs() << ", resolved = " << getBlockName(Resolved);
(void)debugSuccessor;
#endif
(void)debugSuccessor;
#endif
- if (Succ == LoopHead) {
+ if (isLoopHeader(Succ)) {
DEBUG(debugSuccessor("backedge", Succ));
DEBUG(debugSuccessor("backedge", Succ));
- Dist.addBackedge(LoopHead, Weight);
+ Dist.addBackedge(OuterLoop->getHeader(), Weight);
return;
}
BlockNode Resolved = getPackagedNode(*this, Succ);
return;
}
BlockNode Resolved = getPackagedNode(*this, Succ);
- assert(Resolved != LoopHead);
+ assert(!isLoopHeader(Resolved));
- if (Working[Resolved.Index].getContainingHeader() != LoopHead) {
+ if (Working[Resolved.Index].getContainingLoop() != OuterLoop) {
DEBUG(debugSuccessor(" exit ", Resolved));
Dist.addExit(Resolved, Weight);
return;
DEBUG(debugSuccessor(" exit ", Resolved));
Dist.addExit(Resolved, Weight);
return;
const LoopData *OuterLoop, LoopData &Loop, Distribution &Dist) {
// Copy the exit map into Dist.
for (const auto &I : Loop.Exits)
const LoopData *OuterLoop, LoopData &Loop, Distribution &Dist) {
// Copy the exit map into Dist.
for (const auto &I : Loop.Exits)
- addToDist(Dist, OuterLoop, Loop.Header, I.first, I.second.getMass());
+ addToDist(Dist, OuterLoop, Loop.getHeader(), I.first, I.second.getMass());
// We don't need this map any more. Clear it to prevent quadratic memory
// usage in deeply nested loops with irreducible control flow.
// We don't need this map any more. Clear it to prevent quadratic memory
// usage in deeply nested loops with irreducible control flow.
/// \brief Compute the loop scale for a loop.
void BlockFrequencyInfoImplBase::computeLoopScale(LoopData &Loop) {
// Compute loop scale.
/// \brief Compute the loop scale for a loop.
void BlockFrequencyInfoImplBase::computeLoopScale(LoopData &Loop) {
// Compute loop scale.
- DEBUG(dbgs() << "compute-loop-scale: " << getBlockName(Loop.Header) << "\n");
+ DEBUG(dbgs() << "compute-loop-scale: " << getBlockName(Loop.getHeader())
+ << "\n");
// LoopScale == 1 / ExitMass
// ExitMass == HeadMass - BackedgeMass
// LoopScale == 1 / ExitMass
// ExitMass == HeadMass - BackedgeMass
/// \brief Package up a loop.
void BlockFrequencyInfoImplBase::packageLoop(LoopData &Loop) {
/// \brief Package up a loop.
void BlockFrequencyInfoImplBase::packageLoop(LoopData &Loop) {
- DEBUG(dbgs() << "packaging-loop: " << getBlockName(Loop.Header) << "\n");
+ DEBUG(dbgs() << "packaging-loop: " << getBlockName(Loop.getHeader()) << "\n");
Loop.IsPackaged = true;
DEBUG(for (const BlockNode &M
: Loop.Members) {
Loop.IsPackaged = true;
DEBUG(for (const BlockNode &M
: Loop.Members) {
(void)debugAssign;
#endif
(void)debugAssign;
#endif
- BlockNode LoopHead;
- if (OuterLoop)
- LoopHead = OuterLoop->Header;
for (const Weight &W : Dist.Weights) {
// Check for a local edge (forward and non-exit).
if (W.Type == Weight::Local) {
for (const Weight &W : Dist.Weights) {
// Check for a local edge (forward and non-exit).
if (W.Type == Weight::Local) {