blockfreq: Skip irreducible backedges inside functions

[oota-llvm.git] / lib / Analysis / BlockFrequencyInfoImpl.cpp

diff --git a/lib/Analysis/BlockFrequencyInfoImpl.cpp b/lib/Analysis/BlockFrequencyInfoImpl.cpp
index c2337bebe3bde587c9993ee155d27fa0b565d8de..29a4117c1300d028725326bfa8d45e9a37b06ebd 100644 (file)
--- a/lib/Analysis/BlockFrequencyInfoImpl.cpp
+++ b/lib/Analysis/BlockFrequencyInfoImpl.cpp
@@ -598,7 +598,11 @@ void Distribution::normalize() {
 }
 
 void BlockFrequencyInfoImplBase::clear() {
-  *this = BlockFrequencyInfoImplBase();
+  // Swap with a default-constructed std::vector, since std::vector<>::clear()
+  // does not actually clear heap storage.
+  std::vector<FrequencyData>().swap(Freqs);
+  std::vector<WorkingData>().swap(Working);
+  std::vector<std::unique_ptr<LoopData>>().swap(Loops);
 }
 
 /// \brief Clear all memory not needed downstream.
@@ -626,11 +630,11 @@ static void cleanup(BlockFrequencyInfoImplBase &BFI) {
 static BlockNode getPackagedNode(const BlockFrequencyInfoImplBase &BFI,
                                  const BlockNode &Node) {
   assert(Node.isValid());
-  if (!BFI.Working[Node.Index].IsPackaged)
+  if (!BFI.Working[Node.Index].isPackaged())
     return Node;
-  if (!BFI.Working[Node.Index].ContainingLoop.isValid())
+  if (!BFI.Working[Node.Index].isAPackage())
     return Node;
-  return getPackagedNode(BFI, BFI.Working[Node.Index].ContainingLoop);
+  return getPackagedNode(BFI, BFI.Working[Node.Index].getContainingHeader());
 }
 
 /// \brief Get the appropriate mass for a possible pseudo-node loop package.
@@ -641,8 +645,8 @@ static BlockNode getPackagedNode(const BlockFrequencyInfoImplBase &BFI,
 static BlockMass &getPackageMass(BlockFrequencyInfoImplBase &BFI,
                                  const BlockNode &Node) {
   assert(Node.isValid());
-  assert(!BFI.Working[Node.Index].IsPackaged);
-  if (!BFI.Working[Node.Index].IsAPackage)
+  assert(!BFI.Working[Node.Index].isPackaged());
+  if (!BFI.Working[Node.Index].isAPackage())
     return BFI.Working[Node.Index].Mass;
 
   return BFI.getLoopPackage(Node).Mass;
@@ -677,13 +681,13 @@ void BlockFrequencyInfoImplBase::addToDist(Distribution &Dist,
   BlockNode Resolved = getPackagedNode(*this, Succ);
   assert(Resolved != LoopHead);
 
-  if (Working[Resolved.Index].ContainingLoop != LoopHead) {
+  if (Working[Resolved.Index].getContainingHeader() != LoopHead) {
     DEBUG(debugSuccessor("  exit  ", Resolved));
     Dist.addExit(Resolved, Weight);
     return;
   }
 
-  if (!LoopHead.isValid() && Resolved < Pred) {
+  if (Resolved < Pred) {
     // Irreducible backedge.  Skip this edge in the distribution.
     DEBUG(debugSuccessor("skipped ", Resolved));
     return;
@@ -740,11 +744,12 @@ void BlockFrequencyInfoImplBase::computeLoopScale(const BlockNode &LoopHead) {
 /// \brief Package up a loop.
 void BlockFrequencyInfoImplBase::packageLoop(const BlockNode &LoopHead) {
   DEBUG(dbgs() << "packaging-loop: " << getBlockName(LoopHead) << "\n");
-  Working[LoopHead.Index].IsAPackage = true;
-  for (const BlockNode &M : getLoopPackage(LoopHead).Members) {
-    DEBUG(dbgs() << " - node: " << getBlockName(M.Index) << "\n");
-    Working[M.Index].IsPackaged = true;
-  }
+  auto &PackagedLoop = getLoopPackage(LoopHead);
+  PackagedLoop.IsPackaged = true;
+  DEBUG(for (const BlockNode &M
+             : PackagedLoop.Members) {
+               dbgs() << " - node: " << getBlockName(M.Index) << "\n";
+             });
 }
 
 void BlockFrequencyInfoImplBase::distributeMass(const BlockNode &Source,