SelectionDAG: Introduce PersistentID to SDNode for assert builds.

[MatzeB]

Summary

This gives us more human readable numbers to identify nodes in debug
dumps.

Before:

0x7fcbd9700160: ch = EntryToken

0x7fcbd985c7c8: i64 = Register %RAX

 ...

    0x7fcbd9700160: <multiple use>
  0x7fcbd985c578: i64,ch = MOV64rm 0x7fcbd985c6a0, 0x7fcbd985cc68, 0x7fcbd985c200, 0x7fcbd985cd90, 0x7fcbd985ceb8, 0x7fcbd9700160<Mem:LD8[@foo]> [ORD=2]

0x7fcbd985c8f0: ch,glue = CopyToReg 0x7fcbd9700160, 0x7fcbd985c7c8, 0x7fcbd985c578 [ORD=3]

  0x7fcbd985c7c8: <multiple use>
  0x7fcbd985c8f0: <multiple use>
  0x7fcbd985c8f0: <multiple use>
0x7fcbd985ca18: ch = RETQ 0x7fcbd985c7c8, 0x7fcbd985c8f0, 0x7fcbd985c8f0:1 [ORD=3]

Now:

t0: ch = EntryToken

t5: i64 = Register %RAX

  ...

    t0: <multiple use>
  t3: i64,ch = MOV64rm t10, t12, t11, t13, t14, t0<Mem:LD8[@foo]> [ORD=2]

t6: ch,glue = CopyToReg t0, t5, t3 [ORD=3]

  t5: <multiple use>
  t6: <multiple use>
  t6: <multiple use>
t7: ch = RETQ t5, t6, t6:1 [ORD=3]

[escha]

as someone who uses selectionDAG dumper a lot, I'd just like to say I *really* appreciate this patch.

[resistor]

LGTM

llvm/trunk/include/llvm/CodeGen/SelectionDAG.h

class SelectionDAG {
   BumpPtrAllocator OperandAllocator;
 
   /// Pool allocation for misc. objects that are created once per SelectionDAG.
   BumpPtrAllocator Allocator;
 
   /// Tracks dbg_value information through SDISel.
   SDDbgInfo *DbgInfo;
 
+#ifndef NDEBUG
+  uint16_t NextPersistentId;
+#endif
+
 public:
   /// Clients of various APIs that cause global effects on
   /// the DAG can optionally implement this interface.  This allows the clients
   /// to handle the various sorts of updates that happen.
   ///
   /// A DAGUpdateListener automatically registers itself with DAG when it is
   /// constructed, and removes itself when destroyed in RAII fashion.
   struct DAGUpdateListener {

llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h

private:
 
   /// Return a pointer to the specified value type.
   static const EVT *getValueTypeList(EVT VT);
 
   friend class SelectionDAG;
   friend struct ilist_traits<SDNode>;
 
 public:
+#ifndef NDEBUG
+  /// Unique and persistent id per SDNode in the DAG.
+  /// Used for debug printing.
+  uint16_t PersistentId;
+#endif
+
   //===--------------------------------------------------------------------===//
   //  Accessors
   //
 
   /// Return the SelectionDAG opcode value for this node. For
   /// pre-isel nodes (those for which isMachineOpcode returns false), these
   /// are the opcode values in the ISD and <target>ISD namespaces. For
   /// post-isel opcodes, see getMachineOpcode.

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

 
 /// \brief Insert a newly allocated node into the DAG.
 ///
 /// Handles insertion into the all nodes list and CSE map, as well as
 /// verification and other common operations when a new node is allocated.
 void SelectionDAG::InsertNode(SDNode *N) {
   AllNodes.push_back(N);
 #ifndef NDEBUG
+  N->PersistentId = NextPersistentId++;
   VerifySDNode(N);
 #endif
 }
 
 /// RemoveNodeFromCSEMaps - Take the specified node out of the CSE map that
 /// correspond to it.  This is useful when we're about to delete or repurpose
 /// the node.  We don't want future request for structurally identical nodes
 /// to return N anymore.
SelectionDAG::~SelectionDAG() {
   delete DbgInfo;
 }
 
 void SelectionDAG::allnodes_clear() {
   assert(&*AllNodes.begin() == &EntryNode);
   AllNodes.remove(AllNodes.begin());
   while (!AllNodes.empty())
     DeallocateNode(AllNodes.begin());
+#ifndef NDEBUG
+  NextPersistentId = 0;
+#endif
 }
 
 BinarySDNode *SelectionDAG::GetBinarySDNode(unsigned Opcode, SDLoc DL,
                                             SDVTList VTs, SDValue N1,
                                             SDValue N2,
                                             const SDNodeFlags *Flags) {
   if (isBinOpWithFlags(Opcode)) {
     // If no flags were passed in, use a default flags object.

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp

const char *SDNode::getIndexedModeName(ISD::MemIndexedMode AM) {
   default:              return "";
   case ISD::PRE_INC:    return "<pre-inc>";
   case ISD::PRE_DEC:    return "<pre-dec>";
   case ISD::POST_INC:   return "<post-inc>";
   case ISD::POST_DEC:   return "<post-dec>";
   }
 }
 
+namespace {
+class PrintNodeId {
+  const SDNode &Node;
+public:
+  explicit PrintNodeId(const SDNode &Node)
+      : Node(Node) {}
+  void print(raw_ostream &OS) const {
+#ifndef NDEBUG
+    OS << 't' << Node.PersistentId;
+#else
+    OS << (const void*)&Node;
+#endif
+  }
+};
+
+static inline raw_ostream &operator<<(raw_ostream &OS, const PrintNodeId &P) {
+  P.print(OS);
+  return OS;
+}
+}
+
 void SDNode::dump() const { dump(nullptr); }
 void SDNode::dump(const SelectionDAG *G) const {
   print(dbgs(), G);
   dbgs() << '\n';
 }
 
 void SDNode::print_types(raw_ostream &OS, const SelectionDAG *G) const {
-  OS << (const void*)this << ": ";
+  OS << PrintNodeId(*this) << ": ";
 
   for (unsigned i = 0, e = getNumValues(); i != e; ++i) {
     if (i) OS << ",";
     if (getValueType(i) == MVT::Other)
       OS << "ch";
     else
       OS << getValueType(i).getEVTString();
   }

 }
 
 static void DumpNodes(const SDNode *N, unsigned indent, const SelectionDAG *G) {
   for (const SDValue &Op : N->op_values())
     if (Op.getNode()->hasOneUse())
       DumpNodes(Op.getNode(), indent+2, G);
     else
       dbgs() << "\n" << std::string(indent+2, ' ')
-             << (void*)Op.getNode() << ": <multiple use>";
+             << PrintNodeId(*Op.getNode()) << ": <multiple use>";
 
   dbgs() << '\n';
   dbgs().indent(indent);
   N->dump(G);
 }
 
 void SelectionDAG::dump() const {
   dbgs() << "SelectionDAG has " << AllNodes.size() << " nodes:";
void SDNode::dumprFull(const SelectionDAG *G) const {
   // Don't print impossibly deep things.
   dumprWithDepth(G, 10);
 }
 
 void SDNode::print(raw_ostream &OS, const SelectionDAG *G) const {
   print_types(OS, G);
   for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
     if (i) OS << ", "; else OS << " ";
-    OS << (void*)getOperand(i).getNode();
-    if (unsigned RN = getOperand(i).getResNo())
+    const SDValue Operand = getOperand(i);
+    OS << PrintNodeId(*Operand.getNode());
+    if (unsigned RN = Operand.getResNo())
       OS << ":" << RN;
   }
   print_details(OS, G);
 }

llvm/trunk/test/CodeGen/PowerPC/ppc64-icbt-pwr7.ll

 ; Test the ICBT instruction is not emitted on POWER7
 ; Based on the ppc64-prefetch.ll test
 ; RUN: not llc -mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr7 < %s 2>&1 | FileCheck %s
  
 declare void @llvm.prefetch(i8*, i32, i32, i32)
 
 define void @test(i8* %a, ...) nounwind {
 entry:
   call void @llvm.prefetch(i8* %a, i32 0, i32 3, i32 0)
   ret void
 
 ; FIXME: Crashing is not really the correct behavior here, we really should just emit nothing
-; CHECK: Cannot select: 0x{{[0-9,a-f]+}}: ch = Prefetch 
-; CHECK: 0x{{[0-9,a-f]+}}: i32 = Constant<0> 
-; CHECK-NEXT: 0x{{[0-9,a-f]+}}: i32 = Constant<3>
-; CHECK-NEXT: 0x{{[0-9,a-f]+}}: i32 = Constant<0>
+; CHECK: Cannot select: {{0x[0-9,a-f]+|t[0-9]+}}: ch = Prefetch
+; CHECK: {{0x[0-9,a-f]+|t[0-9]+}}: i32 = Constant<0>
+; CHECK-NEXT: {{0x[0-9,a-f]+|t[0-9]+}}: i32 = Constant<3>
+; CHECK-NEXT: {{0x[0-9,a-f]+|t[0-9]+}}: i32 = Constant<0>
 
 }
 

llvm/trunk/test/DebugInfo/Generic/constant-sdnodes-have-dbg-location.ll

 ; RUN: llc -debug < %s 2>&1 | FileCheck %s
 ; REQUIRES: asserts
 
-; CHECK: 0x{{[0-9,a-f]+}}: i32 = Constant<-1>test.c:4:5
+; CHECK: t{{[0-9]+}}: i32 = Constant<-1>test.c:4:5
 
 define i32 @main() {
 entry:
   %retval = alloca i32, align 4
   store i32 0, i32* %retval
   ret i32 -1, !dbg !10
 }
 

llvm/trunk/test/DebugInfo/Generic/constantfp-sdnodes-have-dbg-location.ll

 ; RUN: llc -debug < %s 2>&1 | FileCheck %s
 ; REQUIRES: asserts
 
-; CHECK: 0x{{[0-9,a-f]+}}: f64 = ConstantFP<1.500000e+00>test.c:3:5
+; CHECK: t{{[0-9]+}}: f64 = ConstantFP<1.500000e+00>test.c:3:5
 
 define double @f() {
 entry:
   ret double 1.500000e+00, !dbg !10
 }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!8, !9}