Utility to print all the basic blocks of a loop.

[hiraditya]

Summary

Useful in debugging.

[sanjoy]

llvm/include/llvm/Analysis/LoopInfoImpl.h

346

Not sure if this needs to be a completely separate method -- why not just pass in a verbose flag to print?

356

Hm, just noticed that this is misleading both here and in the print method above -- if the loop has multiple latches, we won't tag any blocks as <latch>. This should be fixed (we need a isLoopLatch helper like we have isLoopExiting). @hiraditya - do you mind fixing this in a later change? If you won't be able to get to it, please let me know and I'll do it.

[hiraditya]

llvm/include/llvm/Analysis/LoopInfoImpl.h

346

Okay, I'll push the patch with just another parameter to print.

356

I can do that in a separate patch. Thanks for the pointer.

[hiraditya]

Addresssed comments of Sanjoy.

[sanjoy]

LGTM with comments inline.

However: if it isn't too much extra work, can I ask you to please land
the Verbose flag in a separate change from the isLoopLatch change?
If that's too much extra work, don't bother, since these are low risk
changes.

llvm/include/llvm/Analysis/LoopInfo.h

171

Don't repeat function names in new doxygen comments.

176

I'd do this slightly differently. I'd have the precondition be that
BB belongs to the loop (and start with an assert(contains(BB))),
and have the body just be a:

auto PredBegin = ...;
auto PredEnd = ...;
return std::find(BB, PredBegin, PredEnd) != PredEnd;

llvm/lib/Analysis/LoopInfo.cpp

392

Add a /*Verbose=*/ before true and /*Depth=*/ before 0.

[sebpop]

In D22817#496596, @sanjoy wrote:

LGTM with comments inline.

However: if it isn't too much extra work, can I ask you to please land
the Verbose flag in a separate change from the isLoopLatch change?
If that's too much extra work, don't bother, since these are low risk
changes.

Split in two patches and addressed all last comments:
https://reviews.llvm.org/rL276837
https://reviews.llvm.org/rL276838

Thanks Sanjoy for your review.

llvm/include/llvm/Analysis/LoopInfo.h

for (typename BlockTraits::ChildIteratorType SI =
          BlockTraits::child_begin(BB),
          SE = BlockTraits::child_end(BB); SI != SE; ++SI) {
       if (!contains(*SI))
         return true;
     }
     return false;
   }
 
+  /// isLoopLatch - Returns true if \p BB is a loop-latch.
+  /// A latch block is a block that contains a branch back to the header.
+  /// This function is useful when there are multiple latches in a loop
+  /// because \fn getLoopLatch will return nullptr in that case.
+  bool isLoopLatch(const BlockT *BB) const {
+    BlockT *Header = getHeader();
+    typedef GraphTraits<Inverse<BlockT*> > InvBlockTraits;
+    typename InvBlockTraits::ChildIteratorType PI =
+      InvBlockTraits::child_begin(Header);
+    typename InvBlockTraits::ChildIteratorType PE =
+      InvBlockTraits::child_end(Header);
+    for (; PI != PE; ++PI) {
+      typename InvBlockTraits::NodeType *N = *PI;
+      if ((BB == N) && contains(N))
+        return true;
+    }
+    return false;
+  }
+
   /// Calculate the number of back edges to the loop header.
   unsigned getNumBackEdges() const {
     unsigned NumBackEdges = 0;
     BlockT *H = getHeader();
 
     typedef GraphTraits<Inverse<BlockT*> > InvBlockTraits;
     for (typename InvBlockTraits::ChildIteratorType I =
          InvBlockTraits::child_begin(H),
public:
   }
 
   /// Verify loop structure
   void verifyLoop() const;
 
   /// Verify loop structure of this loop and all nested loops.
   void verifyLoopNest(DenseSet<const LoopT*> *Loops) const;
 
-  void print(raw_ostream &OS, unsigned Depth = 0) const;
+  void print(raw_ostream &OS, unsigned Depth = 0, bool Verbose = false) const;
+
+  /// Print loop with all the BBs inside it.
+  void printVerbose(raw_ostream &OS, unsigned Depth = 0) const;
 
 protected:
   friend class LoopInfoBase<BlockT, LoopT>;
   explicit LoopBase(BlockT *BB) : ParentLoop(nullptr) {
     Blocks.push_back(BB);
     DenseBlockSet.insert(BB);
   }
 };
public:
   /// This assumes that loop exits are in canonical form.
   void getUniqueExitBlocks(SmallVectorImpl<BasicBlock *> &ExitBlocks) const;
 
   /// If getUniqueExitBlocks would return exactly one block, return that block.
   /// Otherwise return null.
   BasicBlock *getUniqueExitBlock() const;
 
   void dump() const;
+  void dumpVerbose() const;
 
   /// Return the debug location of the start of this loop.
   /// This looks for a BB terminating instruction with a known debug
   /// location by looking at the preheader and header blocks. If it
   /// cannot find a terminating instruction with location information,
   /// it returns an unknown location.
   DebugLoc getStartLoc() const;
 

llvm/include/llvm/Analysis/LoopInfoImpl.h

void LoopBase<BlockT, LoopT>::verifyLoopNest(
   // Verify this loop.
   verifyLoop();
   // Verify the subloops.
   for (iterator I = begin(), E = end(); I != E; ++I)
     (*I)->verifyLoopNest(Loops);
 }
 
 template<class BlockT, class LoopT>
-void LoopBase<BlockT, LoopT>::print(raw_ostream &OS, unsigned Depth) const {
+void LoopBase<BlockT, LoopT>::print(raw_ostream &OS, unsigned Depth,
+                                    bool Verbose) const {
   OS.indent(Depth*2) << "Loop at depth " << getLoopDepth()
        << " containing: ";
 
+  BlockT *H = getHeader();
   for (unsigned i = 0; i < getBlocks().size(); ++i) {
-    if (i) OS << ",";
     BlockT *BB = getBlocks()[i];
+    if (!Verbose) {
+      if (i) OS << ",";
       BB->printAsOperand(OS, false);
-    if (BB == getHeader())    OS << "<header>";
-    if (BB == getLoopLatch()) OS << "<latch>";
-    if (isLoopExiting(BB))    OS << "<exiting>";
+    } else OS << "\n";
+
+    if (BB == H) OS << "<header>";
+    if (isLoopLatch(BB)) OS << "<latch>";
+    if (isLoopExiting(BB)) OS << "<exiting>";
+    if (Verbose)
+      BB->print(OS);
   }
   OS << "\n";
 
   for (iterator I = begin(), E = end(); I != E; ++I)
     (*I)->print(OS, Depth+2);
 }
 
 //===----------------------------------------------------------------------===//
 /// Stable LoopInfo Analysis - Build a loop tree using stable iterators so the
 /// result does / not depend on use list (block predecessor) order.
 ///
 
 /// Discover a subloop with the specified backedges such that: All blocks within
 /// this loop are mapped to this loop or a subloop. And all subloops within this
 /// loop have their parent loop set to this loop or a subloop.
 template<class BlockT, class LoopT>
 static void discoverAndMapSubloop(LoopT *L, ArrayRef<BlockT*> Backedges,
                                   LoopInfoBase<BlockT, LoopT> *LI,
                                   const DominatorTreeBase<BlockT> &DomTree) {
   typedef GraphTraits<Inverse<BlockT*> > InvBlockTraits;
 
   unsigned NumBlocks = 0;
   unsigned NumSubloops = 0;
 
   // Perform a backward CFG traversal using a worklist.
   std::vector<BlockT *> ReverseCFGWorklist(Backedges.begin(), Backedges.end());
   while (!ReverseCFGWorklist.empty()) {

llvm/lib/Analysis/LoopInfo.cpp

if (UniqueExitBlocks.size() == 1)
     return UniqueExitBlocks[0];
   return nullptr;
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void Loop::dump() const {
   print(dbgs());
 }
+
+LLVM_DUMP_METHOD void Loop::dumpVerbose() const {
+  print(dbgs(), 0, true);
+}
 #endif
 
 //===----------------------------------------------------------------------===//
 // UnloopUpdater implementation
 //
 
 namespace {
 /// Find the new parent loop for all blocks within the "unloop" whose last