SelectionDAGDumper: Print simple operands inline.

[MatzeB]

Summary

Print simple operands inline instead of their pointer/value number.
Simple operands are things like Constant(FP)?, Register and undef,

Before:

  0x7fb6cb8ab800: v4f32 = Register %vreg0
0x7fb6cb8ab928: v4f32,ch = CopyFromReg 0x7fb6cb413770, 0x7fb6cb8ab800
0x7fb6cb8abb78: i64 = Constant<0>

0x7fb6cb8abca0: f32 = extract_vector_elt 0x7fb6cb8ab928, 0x7fb6cb8abb78

After:

0x7fb6cb8ab928 = CopyFromReg:v4f32,ch 0x7fb6cb413770, Register:v4f32  %vreg0
0x7fb6cb8abca0 = extract_vector_elt:f32 0x7fb6cb8ab928, Constant:i64 <0>

[arsenm]

lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp

591

VALUETYPE would another good one to handle

725

single quotes

[MatzeB]

Implement suggestions.

[MatzeB]

Actually added VALUETYPE this time.

[MatzeB]

New version: Use printOperand() in DumpNodesr() as well; simplify the definition of a simple operand as one that has no predecessors (with the exception of EntryToken which looks nicer separate).

[MatzeB]

ping

[resistor]

LGTM.

[MatzeB]

New version which does not depend on http://reviews.llvm.org/D12565 anymore.

For inlined operations this will still print the type behind the operation ("Constant:i32<42>") for toplevel operations the type is still printed on the lhs as before ("tXX: type = operation").

Note that this commit now moves the node details behind the node (like dumpr() already did). The previous behaviour of printing the details behind the operands would be confusing in combination with inlined operations (confusing example: "load t0, t2, undef:i64<LD1[%tmp81]>" as the <LD1...> is part of the load not the undef). We now print: "load<LD1[%tmp81]> t0, t2, undef:i64".

Longer example, before:

t0: ch = EntryToken
  t1: i64 = Register %vreg0
t2: i64,ch = CopyFromReg t0, t1
  t3: i64 = Constant<1>
t4: i64 = add t2, t3
  t5: i64 = Constant<2>
t6: i64 = add t2, t5
t10: i64 = undef
t11: i8,ch = load t0, t2, t10<LD1[%tmp81]>
t12: i8,ch = load t0, t4, t10<LD1[%tmp10]>
t13: i8,ch = load t0, t6, t10<LD1[%tmp12]>

Now:

t0: ch = EntryToken
t2: i64,ch = CopyFromReg t0, Register:i64 %vreg0
t4: i64 = add t2, Constant:i64<1>
t6: i64 = add t2, Constant:i64<2>
t11: i8,ch = load<LD1[%tmp81]> t0, t2, undef:i64
t12: i8,ch = load<LD1[%tmp10]> t0, t4, undef:i64
t13: i8,ch = load<LD1[%tmp12]> t0, t6, undef:i64

[MatzeB]

Is this still good to go even in the reworked form from monday?

[resistor]

Fine with me.

include/llvm/CodeGen/SelectionDAGNodes.h

#endif
 
   typedef const EVT* value_iterator;
   value_iterator value_begin() const { return ValueList; }
   value_iterator value_end() const { return ValueList+NumValues; }
 
   /// Return the opcode of this operation for printing.
   std::string getOperationName(const SelectionDAG *G = nullptr) const;
   static const char* getIndexedModeName(ISD::MemIndexedMode AM);
-  void print_types(raw_ostream &OS, const SelectionDAG *G) const;
+  void print_operation(raw_ostream &OS, const SelectionDAG *G) const;
   void print_details(raw_ostream &OS, const SelectionDAG *G) const;
   void print(raw_ostream &OS, const SelectionDAG *G = nullptr) const;
   void printr(raw_ostream &OS, const SelectionDAG *G = nullptr) const;
 
   /// Print a SelectionDAG node and all children down to
   /// the leaves.  The given SelectionDAG allows target-specific nodes
   /// to be printed in human-readable form.  Unlike printr, this will
   /// print the whole DAG, including children that appear multiple

lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp

 }
 
 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 << PrintNodeId(*this) << " = ";
-
+void SDNode::print_operation(raw_ostream &OS, const SelectionDAG *G) const {
   OS << getOperationName(G) << ':';
   for (unsigned i = 0, e = getNumValues(); i != e; ++i) {
     if (i) OS << ",";
     if (getValueType(i) == MVT::Other)
       OS << "ch";
     else
       OS << getValueType(i).getEVTString();
   }
 }
 
 void SDNode::print_details(raw_ostream &OS, const SelectionDAG *G) const {
   if (const MachineSDNode *MN = dyn_cast<MachineSDNode>(this)) {
     if (!MN->memoperands_empty()) {
-      OS << "<";
+      OS << " <";
       OS << "Mem:";
       for (MachineSDNode::mmo_iterator i = MN->memoperands_begin(),
            e = MN->memoperands_end(); i != e; ++i) {
         OS << **i;
         if (std::next(i) != e)
           OS << " ";
       }
       OS << ">";
     }
   } else if (const ShuffleVectorSDNode *SVN =
                dyn_cast<ShuffleVectorSDNode>(this)) {
-    OS << "<";
+    OS << " <";
     for (unsigned i = 0, e = ValueList[0].getVectorNumElements(); i != e; ++i) {
       int Idx = SVN->getMaskElt(i);
       if (i) OS << ",";
       if (Idx < 0)
         OS << "u";
       else
         OS << Idx;
     }
     OS << ">";
   } else if (const ConstantSDNode *CSDN = dyn_cast<ConstantSDNode>(this)) {
-    OS << '<' << CSDN->getAPIntValue() << '>';
+    OS << " <" << CSDN->getAPIntValue() << '>';
   } else if (const ConstantFPSDNode *CSDN = dyn_cast<ConstantFPSDNode>(this)) {
     if (&CSDN->getValueAPF().getSemantics()==&APFloat::IEEEsingle)
-      OS << '<' << CSDN->getValueAPF().convertToFloat() << '>';
+      OS << " <" << CSDN->getValueAPF().convertToFloat() << '>';
     else if (&CSDN->getValueAPF().getSemantics()==&APFloat::IEEEdouble)
-      OS << '<' << CSDN->getValueAPF().convertToDouble() << '>';
+      OS << " <" << CSDN->getValueAPF().convertToDouble() << '>';
     else {
-      OS << "<APFloat(";
+      OS << " <APFloat(";
       CSDN->getValueAPF().bitcastToAPInt().dump();
       OS << ")>";
     }
   } else if (const GlobalAddressSDNode *GADN =
              dyn_cast<GlobalAddressSDNode>(this)) {
     int64_t offset = GADN->getOffset();
-    OS << '<';
+    OS << " <";
     GADN->getGlobal()->printAsOperand(OS);
     OS << '>';
     if (offset > 0)
       OS << " + " << offset;
     else
       OS << " " << offset;
     if (unsigned int TF = GADN->getTargetFlags())
       OS << " [TF=" << TF << ']';
   } else if (const FrameIndexSDNode *FIDN = dyn_cast<FrameIndexSDNode>(this)) {
-    OS << "<" << FIDN->getIndex() << ">";
+    OS << " <" << FIDN->getIndex() << ">";
   } else if (const JumpTableSDNode *JTDN = dyn_cast<JumpTableSDNode>(this)) {
-    OS << "<" << JTDN->getIndex() << ">";
+    OS << " <" << JTDN->getIndex() << ">";
     if (unsigned int TF = JTDN->getTargetFlags())
       OS << " [TF=" << TF << ']';
   } else if (const ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(this)){
     int offset = CP->getOffset();
     if (CP->isMachineConstantPoolEntry())
-      OS << "<" << *CP->getMachineCPVal() << ">";
+      OS << " <" << *CP->getMachineCPVal() << ">";
     else
-      OS << "<" << *CP->getConstVal() << ">";
+      OS << " <" << *CP->getConstVal() << ">";
     if (offset > 0)
       OS << " + " << offset;
     else
       OS << " " << offset;
     if (unsigned int TF = CP->getTargetFlags())
       OS << " [TF=" << TF << ']';
   } else if (const TargetIndexSDNode *TI = dyn_cast<TargetIndexSDNode>(this)) {
-    OS << "<" << TI->getIndex() << '+' << TI->getOffset() << ">";
+    OS << " <" << TI->getIndex() << '+' << TI->getOffset() << ">";
     if (unsigned TF = TI->getTargetFlags())
       OS << " [TF=" << TF << ']';
   } else if (const BasicBlockSDNode *BBDN = dyn_cast<BasicBlockSDNode>(this)) {
-    OS << "<";
+    OS << " <";
     const Value *LBB = (const Value*)BBDN->getBasicBlock()->getBasicBlock();
     if (LBB)
       OS << LBB->getName() << " ";
     OS << (const void*)BBDN->getBasicBlock() << ">";
   } else if (const RegisterSDNode *R = dyn_cast<RegisterSDNode>(this)) {
     OS << ' ' << PrintReg(R->getReg(),
                           G ? G->getSubtarget().getRegisterInfo() : nullptr);
   } else if (const ExternalSymbolSDNode *ES =
              dyn_cast<ExternalSymbolSDNode>(this)) {
-    OS << "'" << ES->getSymbol() << "'";
+    OS << " '" << ES->getSymbol() << "'";
     if (unsigned int TF = ES->getTargetFlags())
       OS << " [TF=" << TF << ']';
   } else if (const SrcValueSDNode *M = dyn_cast<SrcValueSDNode>(this)) {
     if (M->getValue())
-      OS << "<" << M->getValue() << ">";
+      OS << " <" << M->getValue() << ">";
     else
-      OS << "<null>";
+      OS << " <null>";
   } else if (const MDNodeSDNode *MD = dyn_cast<MDNodeSDNode>(this)) {
     if (MD->getMD())
-      OS << "<" << MD->getMD() << ">";
+      OS << " <" << MD->getMD() << ">";
     else
-      OS << "<null>";
+      OS << " <null>";
   } else if (const VTSDNode *N = dyn_cast<VTSDNode>(this)) {
     OS << ":" << N->getVT().getEVTString();
   }
   else if (const LoadSDNode *LD = dyn_cast<LoadSDNode>(this)) {
-    OS << "<" << *LD->getMemOperand();
+    OS << " <" << *LD->getMemOperand();
 
     bool doExt = true;
     switch (LD->getExtensionType()) {
     default: doExt = false; break;
     case ISD::EXTLOAD:  OS << ", anyext"; break;
     case ISD::SEXTLOAD: OS << ", sext"; break;
     case ISD::ZEXTLOAD: OS << ", zext"; break;
     }
     if (doExt)
       OS << " from " << LD->getMemoryVT().getEVTString();
 
     const char *AM = getIndexedModeName(LD->getAddressingMode());
     if (*AM)
       OS << ", " << AM;
 
     OS << ">";
   } else if (const StoreSDNode *ST = dyn_cast<StoreSDNode>(this)) {
-    OS << "<" << *ST->getMemOperand();
+    OS << " <" << *ST->getMemOperand();
 
     if (ST->isTruncatingStore())
       OS << ", trunc to " << ST->getMemoryVT().getEVTString();
 
     const char *AM = getIndexedModeName(ST->getAddressingMode());
     if (*AM)
       OS << ", " << AM;
 
     OS << ">";
   } else if (const MemSDNode* M = dyn_cast<MemSDNode>(this)) {
-    OS << "<" << *M->getMemOperand() << ">";
+    OS << " <" << *M->getMemOperand() << ">";
   } else if (const BlockAddressSDNode *BA =
                dyn_cast<BlockAddressSDNode>(this)) {
     int64_t offset = BA->getOffset();
-    OS << "<";
+    OS << " <";
     BA->getBlockAddress()->getFunction()->printAsOperand(OS, false);
     OS << ", ";
     BA->getBlockAddress()->getBasicBlock()->printAsOperand(OS, false);
     OS << ">";
     if (offset > 0)
       OS << " + " << offset;
     else
       OS << " " << offset;
     if (unsigned int TF = BA->getTargetFlags())
       OS << " [TF=" << TF << ']';
   } else if (const AddrSpaceCastSDNode *ASC =
                dyn_cast<AddrSpaceCastSDNode>(this)) {
-    OS << '['
+    OS << " ["
        << ASC->getSrcAddressSpace()
        << " -> "
        << ASC->getDestAddressSpace()
        << ']';
   }
 
   if (VerboseDAGDumping) {
     if (unsigned Order = getIROrder())
if (VerboseDAGDumping) {
     else
       OS << "<unknown>";
     OS << ':' << L->getLine();
     if (unsigned C = L->getColumn())
       OS << ':' << C;
   }
 }
 
+/// Return true if this node is so simple that we should just print it inline
+/// if it appears as an operand.
+static bool shouldPrintInline(const SDNode &Node) {
+  unsigned Opcode = Node.getOpcode();
+  return Opcode == ISD::Constant || Opcode == ISD::ConstantFP
+    || Opcode == ISD::Register || Opcode == ISD::RegisterMask
+    || Opcode == ISD::UNDEF || Opcode == ISD::MDNODE_SDNODE
+    || Opcode == ISD::TargetConstant || Opcode == ISD::TargetConstantFP
+    || Opcode == ISD::CONDCODE;
+}
+
 static void DumpNodes(const SDNode *N, unsigned indent, const SelectionDAG *G) {
-  for (const SDValue &Op : N->op_values())
+  for (const SDValue &Op : N->op_values()) {
+    if (shouldPrintInline(*Op.getNode()))
+      continue;
     if (Op.getNode()->hasOneUse())
       DumpNodes(Op.getNode(), indent+2, G);
     else
       dbgs() << "\n" << std::string(indent+2, ' ')
              << PrintNodeId(*Op.getNode()) << ": <multiple use>";
+  }
 
   dbgs() << '\n';
   dbgs().indent(indent);
   N->dump(G);
 }
 
 void SelectionDAG::dump() const {
   dbgs() << "SelectionDAG has " << AllNodes.size() << " nodes:";
 
   for (allnodes_const_iterator I = allnodes_begin(), E = allnodes_end();
        I != E; ++I) {
     const SDNode *N = I;
-    if (!N->hasOneUse() && N != getRoot().getNode())
+    if (!N->hasOneUse() && N != getRoot().getNode() &&
+        (!shouldPrintInline(*N) || N->use_empty()))
       DumpNodes(N, 2, this);
   }
 
   if (getRoot().getNode()) DumpNodes(getRoot().getNode(), 2, this);
   dbgs() << "\n\n";
 }
 
 void SDNode::printr(raw_ostream &OS, const SelectionDAG *G) const {
-  print_types(OS, G);
-  OS << ' ';
+  OS << PrintNodeId(*this) << " = ";
+  print_operation(OS, G);
   print_details(OS, G);
 }
 
 typedef SmallPtrSet<const SDNode *, 128> VisitedSDNodeSet;
 static void DumpNodesr(raw_ostream &OS, const SDNode *N, unsigned indent,
                        const SelectionDAG *G, VisitedSDNodeSet &once) {
   if (!once.insert(N).second) // If we've been here before, return now.
     return;
void SDNode::dumprWithDepth(const SelectionDAG *G, unsigned depth) const {
   printrWithDepth(dbgs(), G, depth);
 }
 
 void SDNode::dumprFull(const SelectionDAG *G) const {
   // Don't print impossibly deep things.
   dumprWithDepth(G, 10);
 }
 
+static void printOperand(raw_ostream &OS, const SelectionDAG *G,
+                         const SDValue Value) {
+  if (shouldPrintInline(*Value.getNode())) {
+    Value->print_operation(OS, G);
+    Value->print_details(OS, G);
+  } else {
+    OS << PrintNodeId(*Value.getNode());
+    if (unsigned RN = Value.getResNo())
+      OS << ":" << RN;
+  }
+}
+
 void SDNode::print(raw_ostream &OS, const SelectionDAG *G) const {
-  print_types(OS, G);
+  OS << PrintNodeId(*this) << " = ";
+  print_operation(OS, G);
   for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
     if (i) OS << ", "; else OS << " ";
-    const SDValue Operand = getOperand(i);
-    OS << PrintNodeId(*Operand.getNode());
-    if (unsigned RN = Operand.getResNo())
-      OS << ":" << RN;
+    printOperand(OS, G, getOperand(i));
   }
   print_details(OS, G);
 }