[Dominators] Simplify block and node printing

[kuhar]

Summary

This patch adds BlockPrinter-- a small wrapper for printing CFG nodes and DomTree nodes to raw_ostream. It is meant to be only used internally, for debugging and printing errors.

[• dberlin]

include/llvm/Support/GenericDomTreeConstruction.h

103

This doesn't print blocks, it print block names.
I'd go with BlockNamePrinter.

298

typo: discovereed->discovered

[kuhar]

Address the comments.

[davide]

This is not your fault but it would be awesome if we introduced a common error handling for the dom, so that we can just call that routine which also calls flush.
(that way we don't have to repeat flush all over the place). Maybe in a separate patch.

[kuhar]

In D35286#807383, @davide wrote:

This is not your fault but it would be awesome if we introduced a common error handling for the dom, so that we can just call that routine which also calls flush.

Is there something similar in LLVM that I could use as an example?

[davide]

In D35286#807394, @kuhar wrote:

In D35286#807383, @davide wrote:

This is not your fault but it would be awesome if we introduced a common error handling for the dom, so that we can just call that routine which also calls flush.

Is there something similar in LLVM that I could use as an example?

it just needs to be a static helper, nothing fancy, just to reduce the amount of os.flush() typing :)
see, e.g. r299551 (except that you need to call os.flush() and this routine actually returns.

[kuhar]

Makes sense. I'll add this error printing helper in a separate patch.

[grosser]

This looks good from my perspective. Thanks for cleaning up the code!

[davide]

LGTM, thanks.

include/llvm/Support/GenericDomTreeConstruction.h

TreeNodePtr getNodeForBlock(NodePtr BB, DomTreeT &DT) {
     // IDomNode
     return (DT.DomTreeNodes[BB] = IDomNode->addChild(
                 llvm::make_unique<DomTreeNodeBase<NodeT>>(BB, IDomNode)))
         .get();
   }
 
   static bool AlwaysDescend(NodePtr, NodePtr) { return true; }
 
+  struct BlockPrinter {
+    NodePtr N;
+
+    BlockPrinter(NodePtr Block) : N(Block) {}
+    BlockPrinter(TreeNodePtr TN) : N(TN ? TN->getBlock() : nullptr) {}
+
+    friend raw_ostream &operator<<(raw_ostream &O, const BlockPrinter &BP) {
+      if (!BP.N)
+        O << "nullptr";
+      else
+        BP.N->printAsOperand(O, false);
+
+      return O;
+    }
+  };
+
   // Custom DFS implementation which can skip nodes based on a provided
   // predicate. It also collects ReverseChildren so that we don't have to spend
   // time getting predecessors in SemiNCA.
   template <bool Inverse, typename DescendCondition>
   unsigned runDFS(NodePtr V, unsigned LastNum, DescendCondition Condition,
                   unsigned AttachToNum) {
     assert(V);
     SmallVector<NodePtr, 64> WorkList = {V};
struct SemiNCAInfo {
   }
 
   void attachNewSubtree(DomTreeT& DT, const TreeNodePtr AttachTo) {
     // Attach the first unreachable block to AttachTo.
     NodeToInfo[NumToNode[1]].IDom = AttachTo->getBlock();
     // Loop over all of the discovered blocks in the function...
     for (size_t i = 1, e = NumToNode.size(); i != e; ++i) {
       NodePtr W = NumToNode[i];
-      DTB_DEBUG(dbgs() << "\tdiscovereed a new reachable node ");
-      DTB_DEBUG(PrintBlockOrNullptr(dbgs(), W));
-      DTB_DEBUG(dbgs() << "\n");
+      DTB_DEBUG(dbgs() << "\tdiscovereed a new reachable node "
+                       << BlockPrinter(W) << "\n");
 
       // Don't replace this with 'count', the insertion side effect is important
       if (DT.DomTreeNodes[W]) continue;  // Haven't calculated this node yet?
 
       NodePtr ImmDom = getIDom(W);
 
       // Get or calculate the node for the immediate dominator
       TreeNodePtr IDomNode = getNodeForBlock(ImmDom, DT);
 
       // Add a new tree node for this BasicBlock, and link it as a child of
       // IDomNode
       DT.DomTreeNodes[W] = IDomNode->addChild(
           llvm::make_unique<DomTreeNodeBase<NodeT>>(W, IDomNode));
     }
   }
 
-  static void PrintBlockOrNullptr(raw_ostream &O, NodePtr Obj) {
-    if (!Obj)
-      O << "nullptr";
-    else
-      Obj->printAsOperand(O, false);
-  }
-
   // Checks if the tree contains all reachable nodes in the input graph.
   bool verifyReachability(const DomTreeT &DT) {
     clear();
     doFullDFSWalk(DT, AlwaysDescend);
 
     for (auto &NodeToTN : DT.DomTreeNodes) {
       const TreeNodePtr TN = NodeToTN.second.get();
       const NodePtr BB = TN->getBlock();
 
       // Virtual root doesn't have a corresponding CFG node.
       if (DT.isVirtualRoot(TN)) continue;
 
       if (!BB || NodeToInfo.count(BB) == 0) {
-        errs() << "DomTree node ";
-        PrintBlockOrNullptr(errs(), BB);
-        errs() << " not found by DFS walk!\n";
+        errs() << "DomTree node " << BlockPrinter(BB)
+               << " not found by DFS walk!\n";
         errs().flush();
 
         return false;
       }
     }
 
     for (const NodePtr N : NumToNode) {
       if (N && !DT.getNode(N)) {
-        errs() << "CFG node ";
-        PrintBlockOrNullptr(errs(), N);
-        errs() << " not found in the DomTree!\n";
+        errs() << "CFG node " << BlockPrinter(N)
+               << " not found in the DomTree!\n";
         errs().flush();
 
         return false;
       }
     }
 
     return true;
   }
 
   // Check if for every parent with a level L in the tree all of its children
   // have level L + 1.
   static bool VerifyLevels(const DomTreeT &DT) {
     for (auto &NodeToTN : DT.DomTreeNodes) {
       const TreeNodePtr TN = NodeToTN.second.get();
       const NodePtr BB = TN->getBlock();
       if (!BB) continue;
 
       const TreeNodePtr IDom = TN->getIDom();
       if (!IDom && TN->getLevel() != 0) {
-        errs() << "Node without an IDom ";
-        PrintBlockOrNullptr(errs(), BB);
-        errs() << " has a nonzero level " << TN->getLevel() << "!\n";
+        errs() << "Node without an IDom " << BlockPrinter(BB)
+               << " has a nonzero level " << TN->getLevel() << "!\n";
         errs().flush();
 
         return false;
       }
 
       if (IDom && TN->getLevel() != IDom->getLevel() + 1) {
-        errs() << "Node ";
-        PrintBlockOrNullptr(errs(), BB);
-        errs() << " has level " << TN->getLevel() << " while it's IDom ";
-        PrintBlockOrNullptr(errs(), IDom->getBlock());
-        errs() << " has level " << IDom->getLevel() << "!\n";
+        errs() << "Node " << BlockPrinter(BB) << " has level " << TN->getLevel()
+               << " while its IDom " << BlockPrinter(IDom->getBlock())
+               << " has level " << IDom->getLevel() << "!\n";
         errs().flush();
 
         return false;
       }
     }
 
     return true;
   }
for (auto &BlockToInfo : NodeToInfo) {
       const NodePtr To = BlockToInfo.first;
       const TreeNodePtr ToTN = DT.getNode(To);
       assert(ToTN);
 
       const NodePtr NCD = DT.findNearestCommonDominator(From, To);
       const TreeNodePtr NCDTN = DT.getNode(NCD);
       const TreeNodePtr ToIDom = ToTN->getIDom();
       if (NCDTN != ToTN && NCDTN != ToIDom) {
-        errs() << "NearestCommonDominator verification failed:\n\tNCD(From:";
-        PrintBlockOrNullptr(errs(), From);
-        errs() << ", To:";
-        PrintBlockOrNullptr(errs(), To);
-        errs() << ") = ";
-        PrintBlockOrNullptr(errs(), NCD);
-        errs() << ",\t (should be To or IDom[To]: ";
-        PrintBlockOrNullptr(errs(), ToIDom ? ToIDom->getBlock() : nullptr);
-        errs() << ")\n";
+        errs() << "NearestCommonDominator verification failed:\n\tNCD(From:"
+               << BlockPrinter(From) << ", To:" << BlockPrinter(To)
+               << ") = " << BlockPrinter(NCD)
+               << ",\t (should be To or IDom[To]: " << BlockPrinter(ToIDom)
+               << ")\n";
         errs().flush();
 
         return false;
       }
     }
 
     return true;
   }
for (auto &NodeToTN : DT.DomTreeNodes) {
 
       clear();
       doFullDFSWalk(DT, [BB](NodePtr From, NodePtr To) {
         return From != BB && To != BB;
       });
 
       for (TreeNodePtr Child : TN->getChildren())
         if (NodeToInfo.count(Child->getBlock()) != 0) {
-          errs() << "Child ";
-          PrintBlockOrNullptr(errs(), Child->getBlock());
-          errs() << " reachable after its parent ";
-          PrintBlockOrNullptr(errs(), BB);
-          errs() << " is removed!\n";
+          errs() << "Child " << BlockPrinter(Child)
+                 << " reachable after its parent " << BlockPrinter(BB)
+                 << " is removed!\n";
           errs().flush();
 
           return false;
         }
     }
 
     return true;
   }
for (auto &NodeToTN : DT.DomTreeNodes) {
         doFullDFSWalk(DT, [BBN](NodePtr From, NodePtr To) {
           return From != BBN && To != BBN;
         });
 
         for (const TreeNodePtr S : Siblings) {
           if (S == N) continue;
 
           if (NodeToInfo.count(S->getBlock()) == 0) {
-            errs() << "Node ";
-            PrintBlockOrNullptr(errs(), S->getBlock());
-            errs() << " not reachable when its sibling ";
-            PrintBlockOrNullptr(errs(), N->getBlock());
-            errs() << " is removed!\n";
+            errs() << "Node " << BlockPrinter(S)
+                   << " not reachable when its sibling " << BlockPrinter(N)
+                   << " is removed!\n";
             errs().flush();
 
             return false;
           }
         }
       }
     }