1 //===- SelectionDAGDumper.cpp - Implement SelectionDAG::dump() ------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This implements the SelectionDAG::dump method and friends.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/ADT/APFloat.h"
15 #include "llvm/ADT/APInt.h"
16 #include "llvm/ADT/None.h"
17 #include "llvm/ADT/SmallPtrSet.h"
18 #include "llvm/ADT/StringExtras.h"
19 #include "llvm/CodeGen/ISDOpcodes.h"
20 #include "llvm/CodeGen/MachineBasicBlock.h"
21 #include "llvm/CodeGen/MachineConstantPool.h"
22 #include "llvm/CodeGen/MachineMemOperand.h"
23 #include "llvm/CodeGen/MachineValueType.h"
24 #include "llvm/CodeGen/SelectionDAG.h"
25 #include "llvm/CodeGen/SelectionDAGNodes.h"
26 #include "llvm/CodeGen/TargetInstrInfo.h"
27 #include "llvm/CodeGen/TargetLowering.h"
28 #include "llvm/CodeGen/TargetRegisterInfo.h"
29 #include "llvm/CodeGen/TargetSubtargetInfo.h"
30 #include "llvm/CodeGen/ValueTypes.h"
31 #include "llvm/IR/BasicBlock.h"
32 #include "llvm/IR/Constants.h"
33 #include "llvm/IR/DebugInfoMetadata.h"
34 #include "llvm/IR/DebugLoc.h"
35 #include "llvm/IR/Function.h"
36 #include "llvm/IR/Intrinsics.h"
37 #include "llvm/IR/Value.h"
38 #include "llvm/Support/Casting.h"
39 #include "llvm/Support/CommandLine.h"
40 #include "llvm/Support/Compiler.h"
41 #include "llvm/Support/Debug.h"
42 #include "llvm/Support/ErrorHandling.h"
43 #include "llvm/Support/Printable.h"
44 #include "llvm/Support/raw_ostream.h"
45 #include "llvm/Target/TargetIntrinsicInfo.h"
46 #include "llvm/Target/TargetMachine.h"
53 VerboseDAGDumping("dag-dump-verbose", cl::Hidden,
54 cl::desc("Display more information when dumping selection "
57 std::string SDNode::getOperationName(const SelectionDAG *G) const {
58 switch (getOpcode()) {
60 if (getOpcode() < ISD::BUILTIN_OP_END)
61 return "<<Unknown DAG Node>>";
62 if (isMachineOpcode()) {
64 if (const TargetInstrInfo *TII = G->getSubtarget().getInstrInfo())
65 if (getMachineOpcode() < TII->getNumOpcodes())
66 return TII->getName(getMachineOpcode());
67 return "<<Unknown Machine Node #" + utostr(getOpcode()) + ">>";
70 const TargetLowering &TLI = G->getTargetLoweringInfo();
71 const char *Name = TLI.getTargetNodeName(getOpcode());
72 if (Name) return Name;
73 return "<<Unknown Target Node #" + utostr(getOpcode()) + ">>";
75 return "<<Unknown Node #" + utostr(getOpcode()) + ">>";
78 case ISD::DELETED_NODE: return "<<Deleted Node!>>";
80 case ISD::PREFETCH: return "Prefetch";
81 case ISD::ATOMIC_FENCE: return "AtomicFence";
82 case ISD::ATOMIC_CMP_SWAP: return "AtomicCmpSwap";
83 case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS: return "AtomicCmpSwapWithSuccess";
84 case ISD::ATOMIC_SWAP: return "AtomicSwap";
85 case ISD::ATOMIC_LOAD_ADD: return "AtomicLoadAdd";
86 case ISD::ATOMIC_LOAD_SUB: return "AtomicLoadSub";
87 case ISD::ATOMIC_LOAD_AND: return "AtomicLoadAnd";
88 case ISD::ATOMIC_LOAD_OR: return "AtomicLoadOr";
89 case ISD::ATOMIC_LOAD_XOR: return "AtomicLoadXor";
90 case ISD::ATOMIC_LOAD_NAND: return "AtomicLoadNand";
91 case ISD::ATOMIC_LOAD_MIN: return "AtomicLoadMin";
92 case ISD::ATOMIC_LOAD_MAX: return "AtomicLoadMax";
93 case ISD::ATOMIC_LOAD_UMIN: return "AtomicLoadUMin";
94 case ISD::ATOMIC_LOAD_UMAX: return "AtomicLoadUMax";
95 case ISD::ATOMIC_LOAD: return "AtomicLoad";
96 case ISD::ATOMIC_STORE: return "AtomicStore";
97 case ISD::PCMARKER: return "PCMarker";
98 case ISD::READCYCLECOUNTER: return "ReadCycleCounter";
99 case ISD::SRCVALUE: return "SrcValue";
100 case ISD::MDNODE_SDNODE: return "MDNode";
101 case ISD::EntryToken: return "EntryToken";
102 case ISD::TokenFactor: return "TokenFactor";
103 case ISD::AssertSext: return "AssertSext";
104 case ISD::AssertZext: return "AssertZext";
106 case ISD::BasicBlock: return "BasicBlock";
107 case ISD::VALUETYPE: return "ValueType";
108 case ISD::Register: return "Register";
109 case ISD::RegisterMask: return "RegisterMask";
111 if (cast<ConstantSDNode>(this)->isOpaque())
112 return "OpaqueConstant";
114 case ISD::ConstantFP: return "ConstantFP";
115 case ISD::GlobalAddress: return "GlobalAddress";
116 case ISD::GlobalTLSAddress: return "GlobalTLSAddress";
117 case ISD::FrameIndex: return "FrameIndex";
118 case ISD::JumpTable: return "JumpTable";
119 case ISD::GLOBAL_OFFSET_TABLE: return "GLOBAL_OFFSET_TABLE";
120 case ISD::RETURNADDR: return "RETURNADDR";
121 case ISD::ADDROFRETURNADDR: return "ADDROFRETURNADDR";
122 case ISD::FRAMEADDR: return "FRAMEADDR";
123 case ISD::LOCAL_RECOVER: return "LOCAL_RECOVER";
124 case ISD::READ_REGISTER: return "READ_REGISTER";
125 case ISD::WRITE_REGISTER: return "WRITE_REGISTER";
126 case ISD::FRAME_TO_ARGS_OFFSET: return "FRAME_TO_ARGS_OFFSET";
127 case ISD::EH_DWARF_CFA: return "EH_DWARF_CFA";
128 case ISD::EH_RETURN: return "EH_RETURN";
129 case ISD::EH_SJLJ_SETJMP: return "EH_SJLJ_SETJMP";
130 case ISD::EH_SJLJ_LONGJMP: return "EH_SJLJ_LONGJMP";
131 case ISD::EH_SJLJ_SETUP_DISPATCH: return "EH_SJLJ_SETUP_DISPATCH";
132 case ISD::ConstantPool: return "ConstantPool";
133 case ISD::TargetIndex: return "TargetIndex";
134 case ISD::ExternalSymbol: return "ExternalSymbol";
135 case ISD::BlockAddress: return "BlockAddress";
136 case ISD::INTRINSIC_WO_CHAIN:
137 case ISD::INTRINSIC_VOID:
138 case ISD::INTRINSIC_W_CHAIN: {
139 unsigned OpNo = getOpcode() == ISD::INTRINSIC_WO_CHAIN ? 0 : 1;
140 unsigned IID = cast<ConstantSDNode>(getOperand(OpNo))->getZExtValue();
141 if (IID < Intrinsic::num_intrinsics)
142 return Intrinsic::getName((Intrinsic::ID)IID, None);
143 else if (const TargetIntrinsicInfo *TII = G->getTarget().getIntrinsicInfo())
144 return TII->getName(IID);
145 llvm_unreachable("Invalid intrinsic ID");
148 case ISD::BUILD_VECTOR: return "BUILD_VECTOR";
149 case ISD::TargetConstant:
150 if (cast<ConstantSDNode>(this)->isOpaque())
151 return "OpaqueTargetConstant";
152 return "TargetConstant";
153 case ISD::TargetConstantFP: return "TargetConstantFP";
154 case ISD::TargetGlobalAddress: return "TargetGlobalAddress";
155 case ISD::TargetGlobalTLSAddress: return "TargetGlobalTLSAddress";
156 case ISD::TargetFrameIndex: return "TargetFrameIndex";
157 case ISD::TargetJumpTable: return "TargetJumpTable";
158 case ISD::TargetConstantPool: return "TargetConstantPool";
159 case ISD::TargetExternalSymbol: return "TargetExternalSymbol";
160 case ISD::MCSymbol: return "MCSymbol";
161 case ISD::TargetBlockAddress: return "TargetBlockAddress";
163 case ISD::CopyToReg: return "CopyToReg";
164 case ISD::CopyFromReg: return "CopyFromReg";
165 case ISD::UNDEF: return "undef";
166 case ISD::MERGE_VALUES: return "merge_values";
167 case ISD::INLINEASM: return "inlineasm";
168 case ISD::EH_LABEL: return "eh_label";
169 case ISD::HANDLENODE: return "handlenode";
172 case ISD::FABS: return "fabs";
173 case ISD::FMINNUM: return "fminnum";
174 case ISD::FMAXNUM: return "fmaxnum";
175 case ISD::FMINNAN: return "fminnan";
176 case ISD::FMAXNAN: return "fmaxnan";
177 case ISD::FNEG: return "fneg";
178 case ISD::FSQRT: return "fsqrt";
179 case ISD::FSIN: return "fsin";
180 case ISD::FCOS: return "fcos";
181 case ISD::FSINCOS: return "fsincos";
182 case ISD::FTRUNC: return "ftrunc";
183 case ISD::FFLOOR: return "ffloor";
184 case ISD::FCEIL: return "fceil";
185 case ISD::FRINT: return "frint";
186 case ISD::FNEARBYINT: return "fnearbyint";
187 case ISD::FROUND: return "fround";
188 case ISD::FEXP: return "fexp";
189 case ISD::FEXP2: return "fexp2";
190 case ISD::FLOG: return "flog";
191 case ISD::FLOG2: return "flog2";
192 case ISD::FLOG10: return "flog10";
195 case ISD::ADD: return "add";
196 case ISD::SUB: return "sub";
197 case ISD::MUL: return "mul";
198 case ISD::MULHU: return "mulhu";
199 case ISD::MULHS: return "mulhs";
200 case ISD::SDIV: return "sdiv";
201 case ISD::UDIV: return "udiv";
202 case ISD::SREM: return "srem";
203 case ISD::UREM: return "urem";
204 case ISD::SMUL_LOHI: return "smul_lohi";
205 case ISD::UMUL_LOHI: return "umul_lohi";
206 case ISD::SDIVREM: return "sdivrem";
207 case ISD::UDIVREM: return "udivrem";
208 case ISD::AND: return "and";
209 case ISD::OR: return "or";
210 case ISD::XOR: return "xor";
211 case ISD::SHL: return "shl";
212 case ISD::SRA: return "sra";
213 case ISD::SRL: return "srl";
214 case ISD::ROTL: return "rotl";
215 case ISD::ROTR: return "rotr";
216 case ISD::FADD: return "fadd";
217 case ISD::FSUB: return "fsub";
218 case ISD::FMUL: return "fmul";
219 case ISD::FDIV: return "fdiv";
220 case ISD::FMA: return "fma";
221 case ISD::FMAD: return "fmad";
222 case ISD::FREM: return "frem";
223 case ISD::FCOPYSIGN: return "fcopysign";
224 case ISD::FGETSIGN: return "fgetsign";
225 case ISD::FCANONICALIZE: return "fcanonicalize";
226 case ISD::FPOW: return "fpow";
227 case ISD::SMIN: return "smin";
228 case ISD::SMAX: return "smax";
229 case ISD::UMIN: return "umin";
230 case ISD::UMAX: return "umax";
232 case ISD::FPOWI: return "fpowi";
233 case ISD::SETCC: return "setcc";
234 case ISD::SETCCE: return "setcce";
235 case ISD::SETCCCARRY: return "setcccarry";
236 case ISD::SELECT: return "select";
237 case ISD::VSELECT: return "vselect";
238 case ISD::SELECT_CC: return "select_cc";
239 case ISD::INSERT_VECTOR_ELT: return "insert_vector_elt";
240 case ISD::EXTRACT_VECTOR_ELT: return "extract_vector_elt";
241 case ISD::CONCAT_VECTORS: return "concat_vectors";
242 case ISD::INSERT_SUBVECTOR: return "insert_subvector";
243 case ISD::EXTRACT_SUBVECTOR: return "extract_subvector";
244 case ISD::SCALAR_TO_VECTOR: return "scalar_to_vector";
245 case ISD::VECTOR_SHUFFLE: return "vector_shuffle";
246 case ISD::CARRY_FALSE: return "carry_false";
247 case ISD::ADDC: return "addc";
248 case ISD::ADDE: return "adde";
249 case ISD::ADDCARRY: return "addcarry";
250 case ISD::SADDO: return "saddo";
251 case ISD::UADDO: return "uaddo";
252 case ISD::SSUBO: return "ssubo";
253 case ISD::USUBO: return "usubo";
254 case ISD::SMULO: return "smulo";
255 case ISD::UMULO: return "umulo";
256 case ISD::SUBC: return "subc";
257 case ISD::SUBE: return "sube";
258 case ISD::SUBCARRY: return "subcarry";
259 case ISD::SHL_PARTS: return "shl_parts";
260 case ISD::SRA_PARTS: return "sra_parts";
261 case ISD::SRL_PARTS: return "srl_parts";
263 // Conversion operators.
264 case ISD::SIGN_EXTEND: return "sign_extend";
265 case ISD::ZERO_EXTEND: return "zero_extend";
266 case ISD::ANY_EXTEND: return "any_extend";
267 case ISD::SIGN_EXTEND_INREG: return "sign_extend_inreg";
268 case ISD::ANY_EXTEND_VECTOR_INREG: return "any_extend_vector_inreg";
269 case ISD::SIGN_EXTEND_VECTOR_INREG: return "sign_extend_vector_inreg";
270 case ISD::ZERO_EXTEND_VECTOR_INREG: return "zero_extend_vector_inreg";
271 case ISD::TRUNCATE: return "truncate";
272 case ISD::FP_ROUND: return "fp_round";
273 case ISD::FLT_ROUNDS_: return "flt_rounds";
274 case ISD::FP_ROUND_INREG: return "fp_round_inreg";
275 case ISD::FP_EXTEND: return "fp_extend";
277 case ISD::SINT_TO_FP: return "sint_to_fp";
278 case ISD::UINT_TO_FP: return "uint_to_fp";
279 case ISD::FP_TO_SINT: return "fp_to_sint";
280 case ISD::FP_TO_UINT: return "fp_to_uint";
281 case ISD::BITCAST: return "bitcast";
282 case ISD::ADDRSPACECAST: return "addrspacecast";
283 case ISD::FP16_TO_FP: return "fp16_to_fp";
284 case ISD::FP_TO_FP16: return "fp_to_fp16";
286 // Control flow instructions
287 case ISD::BR: return "br";
288 case ISD::BRIND: return "brind";
289 case ISD::BR_JT: return "br_jt";
290 case ISD::BRCOND: return "brcond";
291 case ISD::BR_CC: return "br_cc";
292 case ISD::CALLSEQ_START: return "callseq_start";
293 case ISD::CALLSEQ_END: return "callseq_end";
296 case ISD::CATCHRET: return "catchret";
297 case ISD::CLEANUPRET: return "cleanupret";
300 case ISD::LOAD: return "load";
301 case ISD::STORE: return "store";
302 case ISD::MLOAD: return "masked_load";
303 case ISD::MSTORE: return "masked_store";
304 case ISD::MGATHER: return "masked_gather";
305 case ISD::MSCATTER: return "masked_scatter";
306 case ISD::VAARG: return "vaarg";
307 case ISD::VACOPY: return "vacopy";
308 case ISD::VAEND: return "vaend";
309 case ISD::VASTART: return "vastart";
310 case ISD::DYNAMIC_STACKALLOC: return "dynamic_stackalloc";
311 case ISD::EXTRACT_ELEMENT: return "extract_element";
312 case ISD::BUILD_PAIR: return "build_pair";
313 case ISD::STACKSAVE: return "stacksave";
314 case ISD::STACKRESTORE: return "stackrestore";
315 case ISD::TRAP: return "trap";
316 case ISD::DEBUGTRAP: return "debugtrap";
317 case ISD::LIFETIME_START: return "lifetime.start";
318 case ISD::LIFETIME_END: return "lifetime.end";
319 case ISD::GC_TRANSITION_START: return "gc_transition.start";
320 case ISD::GC_TRANSITION_END: return "gc_transition.end";
321 case ISD::GET_DYNAMIC_AREA_OFFSET: return "get.dynamic.area.offset";
324 case ISD::ABS: return "abs";
325 case ISD::BITREVERSE: return "bitreverse";
326 case ISD::BSWAP: return "bswap";
327 case ISD::CTPOP: return "ctpop";
328 case ISD::CTTZ: return "cttz";
329 case ISD::CTTZ_ZERO_UNDEF: return "cttz_zero_undef";
330 case ISD::CTLZ: return "ctlz";
331 case ISD::CTLZ_ZERO_UNDEF: return "ctlz_zero_undef";
334 case ISD::INIT_TRAMPOLINE: return "init_trampoline";
335 case ISD::ADJUST_TRAMPOLINE: return "adjust_trampoline";
338 switch (cast<CondCodeSDNode>(this)->get()) {
339 default: llvm_unreachable("Unknown setcc condition!");
340 case ISD::SETOEQ: return "setoeq";
341 case ISD::SETOGT: return "setogt";
342 case ISD::SETOGE: return "setoge";
343 case ISD::SETOLT: return "setolt";
344 case ISD::SETOLE: return "setole";
345 case ISD::SETONE: return "setone";
347 case ISD::SETO: return "seto";
348 case ISD::SETUO: return "setuo";
349 case ISD::SETUEQ: return "setueq";
350 case ISD::SETUGT: return "setugt";
351 case ISD::SETUGE: return "setuge";
352 case ISD::SETULT: return "setult";
353 case ISD::SETULE: return "setule";
354 case ISD::SETUNE: return "setune";
356 case ISD::SETEQ: return "seteq";
357 case ISD::SETGT: return "setgt";
358 case ISD::SETGE: return "setge";
359 case ISD::SETLT: return "setlt";
360 case ISD::SETLE: return "setle";
361 case ISD::SETNE: return "setne";
363 case ISD::SETTRUE: return "settrue";
364 case ISD::SETTRUE2: return "settrue2";
365 case ISD::SETFALSE: return "setfalse";
366 case ISD::SETFALSE2: return "setfalse2";
368 case ISD::VECREDUCE_FADD: return "vecreduce_fadd";
369 case ISD::VECREDUCE_FMUL: return "vecreduce_fmul";
370 case ISD::VECREDUCE_ADD: return "vecreduce_add";
371 case ISD::VECREDUCE_MUL: return "vecreduce_mul";
372 case ISD::VECREDUCE_AND: return "vecreduce_and";
373 case ISD::VECREDUCE_OR: return "vecreduce_or";
374 case ISD::VECREDUCE_XOR: return "vecreduce_xor";
375 case ISD::VECREDUCE_SMAX: return "vecreduce_smax";
376 case ISD::VECREDUCE_SMIN: return "vecreduce_smin";
377 case ISD::VECREDUCE_UMAX: return "vecreduce_umax";
378 case ISD::VECREDUCE_UMIN: return "vecreduce_umin";
379 case ISD::VECREDUCE_FMAX: return "vecreduce_fmax";
380 case ISD::VECREDUCE_FMIN: return "vecreduce_fmin";
384 const char *SDNode::getIndexedModeName(ISD::MemIndexedMode AM) {
387 case ISD::PRE_INC: return "<pre-inc>";
388 case ISD::PRE_DEC: return "<pre-dec>";
389 case ISD::POST_INC: return "<post-inc>";
390 case ISD::POST_DEC: return "<post-dec>";
394 static Printable PrintNodeId(const SDNode &Node) {
395 return Printable([&Node](raw_ostream &OS) {
397 OS << 't' << Node.PersistentId;
399 OS << (const void*)&Node;
404 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
405 LLVM_DUMP_METHOD void SDNode::dump() const { dump(nullptr); }
407 LLVM_DUMP_METHOD void SDNode::dump(const SelectionDAG *G) const {
413 void SDNode::print_types(raw_ostream &OS, const SelectionDAG *G) const {
414 for (unsigned i = 0, e = getNumValues(); i != e; ++i) {
416 if (getValueType(i) == MVT::Other)
419 OS << getValueType(i).getEVTString();
423 void SDNode::print_details(raw_ostream &OS, const SelectionDAG *G) const {
424 if (getFlags().hasNoUnsignedWrap())
427 if (getFlags().hasNoSignedWrap())
430 if (getFlags().hasExact())
433 if (getFlags().hasUnsafeAlgebra())
436 if (getFlags().hasNoNaNs())
439 if (getFlags().hasNoInfs())
442 if (getFlags().hasNoSignedZeros())
445 if (getFlags().hasAllowReciprocal())
448 if (getFlags().hasAllowContract())
451 if (getFlags().hasVectorReduction())
452 OS << " vector-reduction";
454 if (const MachineSDNode *MN = dyn_cast<MachineSDNode>(this)) {
455 if (!MN->memoperands_empty()) {
458 for (MachineSDNode::mmo_iterator i = MN->memoperands_begin(),
459 e = MN->memoperands_end(); i != e; ++i) {
461 if (std::next(i) != e)
466 } else if (const ShuffleVectorSDNode *SVN =
467 dyn_cast<ShuffleVectorSDNode>(this)) {
469 for (unsigned i = 0, e = ValueList[0].getVectorNumElements(); i != e; ++i) {
470 int Idx = SVN->getMaskElt(i);
478 } else if (const ConstantSDNode *CSDN = dyn_cast<ConstantSDNode>(this)) {
479 OS << '<' << CSDN->getAPIntValue() << '>';
480 } else if (const ConstantFPSDNode *CSDN = dyn_cast<ConstantFPSDNode>(this)) {
481 if (&CSDN->getValueAPF().getSemantics() == &APFloat::IEEEsingle())
482 OS << '<' << CSDN->getValueAPF().convertToFloat() << '>';
483 else if (&CSDN->getValueAPF().getSemantics() == &APFloat::IEEEdouble())
484 OS << '<' << CSDN->getValueAPF().convertToDouble() << '>';
487 CSDN->getValueAPF().bitcastToAPInt().print(OS, false);
490 } else if (const GlobalAddressSDNode *GADN =
491 dyn_cast<GlobalAddressSDNode>(this)) {
492 int64_t offset = GADN->getOffset();
494 GADN->getGlobal()->printAsOperand(OS);
497 OS << " + " << offset;
500 if (unsigned int TF = GADN->getTargetFlags())
501 OS << " [TF=" << TF << ']';
502 } else if (const FrameIndexSDNode *FIDN = dyn_cast<FrameIndexSDNode>(this)) {
503 OS << "<" << FIDN->getIndex() << ">";
504 } else if (const JumpTableSDNode *JTDN = dyn_cast<JumpTableSDNode>(this)) {
505 OS << "<" << JTDN->getIndex() << ">";
506 if (unsigned int TF = JTDN->getTargetFlags())
507 OS << " [TF=" << TF << ']';
508 } else if (const ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(this)){
509 int offset = CP->getOffset();
510 if (CP->isMachineConstantPoolEntry())
511 OS << "<" << *CP->getMachineCPVal() << ">";
513 OS << "<" << *CP->getConstVal() << ">";
515 OS << " + " << offset;
518 if (unsigned int TF = CP->getTargetFlags())
519 OS << " [TF=" << TF << ']';
520 } else if (const TargetIndexSDNode *TI = dyn_cast<TargetIndexSDNode>(this)) {
521 OS << "<" << TI->getIndex() << '+' << TI->getOffset() << ">";
522 if (unsigned TF = TI->getTargetFlags())
523 OS << " [TF=" << TF << ']';
524 } else if (const BasicBlockSDNode *BBDN = dyn_cast<BasicBlockSDNode>(this)) {
526 const Value *LBB = (const Value*)BBDN->getBasicBlock()->getBasicBlock();
528 OS << LBB->getName() << " ";
529 OS << (const void*)BBDN->getBasicBlock() << ">";
530 } else if (const RegisterSDNode *R = dyn_cast<RegisterSDNode>(this)) {
531 OS << ' ' << printReg(R->getReg(),
532 G ? G->getSubtarget().getRegisterInfo() : nullptr);
533 } else if (const ExternalSymbolSDNode *ES =
534 dyn_cast<ExternalSymbolSDNode>(this)) {
535 OS << "'" << ES->getSymbol() << "'";
536 if (unsigned int TF = ES->getTargetFlags())
537 OS << " [TF=" << TF << ']';
538 } else if (const SrcValueSDNode *M = dyn_cast<SrcValueSDNode>(this)) {
540 OS << "<" << M->getValue() << ">";
543 } else if (const MDNodeSDNode *MD = dyn_cast<MDNodeSDNode>(this)) {
545 OS << "<" << MD->getMD() << ">";
548 } else if (const VTSDNode *N = dyn_cast<VTSDNode>(this)) {
549 OS << ":" << N->getVT().getEVTString();
551 else if (const LoadSDNode *LD = dyn_cast<LoadSDNode>(this)) {
552 OS << "<" << *LD->getMemOperand();
555 switch (LD->getExtensionType()) {
556 default: doExt = false; break;
557 case ISD::EXTLOAD: OS << ", anyext"; break;
558 case ISD::SEXTLOAD: OS << ", sext"; break;
559 case ISD::ZEXTLOAD: OS << ", zext"; break;
562 OS << " from " << LD->getMemoryVT().getEVTString();
564 const char *AM = getIndexedModeName(LD->getAddressingMode());
569 } else if (const StoreSDNode *ST = dyn_cast<StoreSDNode>(this)) {
570 OS << "<" << *ST->getMemOperand();
572 if (ST->isTruncatingStore())
573 OS << ", trunc to " << ST->getMemoryVT().getEVTString();
575 const char *AM = getIndexedModeName(ST->getAddressingMode());
580 } else if (const MemSDNode* M = dyn_cast<MemSDNode>(this)) {
581 OS << "<" << *M->getMemOperand() << ">";
582 } else if (const BlockAddressSDNode *BA =
583 dyn_cast<BlockAddressSDNode>(this)) {
584 int64_t offset = BA->getOffset();
586 BA->getBlockAddress()->getFunction()->printAsOperand(OS, false);
588 BA->getBlockAddress()->getBasicBlock()->printAsOperand(OS, false);
591 OS << " + " << offset;
594 if (unsigned int TF = BA->getTargetFlags())
595 OS << " [TF=" << TF << ']';
596 } else if (const AddrSpaceCastSDNode *ASC =
597 dyn_cast<AddrSpaceCastSDNode>(this)) {
599 << ASC->getSrcAddressSpace()
601 << ASC->getDestAddressSpace()
605 if (VerboseDAGDumping) {
606 if (unsigned Order = getIROrder())
607 OS << " [ORD=" << Order << ']';
609 if (getNodeId() != -1)
610 OS << " [ID=" << getNodeId() << ']';
615 DILocation *L = getDebugLoc();
619 if (auto *Scope = L->getScope())
620 OS << Scope->getFilename();
623 OS << ':' << L->getLine();
624 if (unsigned C = L->getColumn())
629 /// Return true if this node is so simple that we should just print it inline
630 /// if it appears as an operand.
631 static bool shouldPrintInline(const SDNode &Node) {
632 if (Node.getOpcode() == ISD::EntryToken)
634 return Node.getNumOperands() == 0;
637 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
638 static void DumpNodes(const SDNode *N, unsigned indent, const SelectionDAG *G) {
639 for (const SDValue &Op : N->op_values()) {
640 if (shouldPrintInline(*Op.getNode()))
642 if (Op.getNode()->hasOneUse())
643 DumpNodes(Op.getNode(), indent+2, G);
646 dbgs().indent(indent);
650 LLVM_DUMP_METHOD void SelectionDAG::dump() const {
651 dbgs() << "SelectionDAG has " << AllNodes.size() << " nodes:\n";
653 for (allnodes_const_iterator I = allnodes_begin(), E = allnodes_end();
655 const SDNode *N = &*I;
656 if (!N->hasOneUse() && N != getRoot().getNode() &&
657 (!shouldPrintInline(*N) || N->use_empty()))
658 DumpNodes(N, 2, this);
661 if (getRoot().getNode()) DumpNodes(getRoot().getNode(), 2, this);
666 void SDNode::printr(raw_ostream &OS, const SelectionDAG *G) const {
667 OS << PrintNodeId(*this) << ": ";
669 OS << " = " << getOperationName(G);
670 print_details(OS, G);
673 static bool printOperand(raw_ostream &OS, const SelectionDAG *G,
674 const SDValue Value) {
675 if (!Value.getNode()) {
678 } else if (shouldPrintInline(*Value.getNode())) {
679 OS << Value->getOperationName(G) << ':';
680 Value->print_types(OS, G);
681 Value->print_details(OS, G);
684 OS << PrintNodeId(*Value.getNode());
685 if (unsigned RN = Value.getResNo())
691 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
692 using VisitedSDNodeSet = SmallPtrSet<const SDNode *, 32>;
694 static void DumpNodesr(raw_ostream &OS, const SDNode *N, unsigned indent,
695 const SelectionDAG *G, VisitedSDNodeSet &once) {
696 if (!once.insert(N).second) // If we've been here before, return now.
699 // Dump the current SDNode, but don't end the line yet.
703 // Having printed this SDNode, walk the children:
704 for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
708 const SDValue Op = N->getOperand(i);
709 bool printedInline = printOperand(OS, G, Op);
711 once.insert(Op.getNode());
716 // Dump children that have grandchildren on their own line(s).
717 for (const SDValue &Op : N->op_values())
718 DumpNodesr(OS, Op.getNode(), indent+2, G, once);
721 LLVM_DUMP_METHOD void SDNode::dumpr() const {
722 VisitedSDNodeSet once;
723 DumpNodesr(dbgs(), this, 0, nullptr, once);
726 LLVM_DUMP_METHOD void SDNode::dumpr(const SelectionDAG *G) const {
727 VisitedSDNodeSet once;
728 DumpNodesr(dbgs(), this, 0, G, once);
732 static void printrWithDepthHelper(raw_ostream &OS, const SDNode *N,
733 const SelectionDAG *G, unsigned depth,
745 for (const SDValue &Op : N->op_values()) {
746 // Don't follow chain operands.
747 if (Op.getValueType() == MVT::Other)
750 printrWithDepthHelper(OS, Op.getNode(), G, depth-1, indent+2);
754 void SDNode::printrWithDepth(raw_ostream &OS, const SelectionDAG *G,
755 unsigned depth) const {
756 printrWithDepthHelper(OS, this, G, depth, 0);
759 void SDNode::printrFull(raw_ostream &OS, const SelectionDAG *G) const {
760 // Don't print impossibly deep things.
761 printrWithDepth(OS, G, 10);
764 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
766 void SDNode::dumprWithDepth(const SelectionDAG *G, unsigned depth) const {
767 printrWithDepth(dbgs(), G, depth);
770 LLVM_DUMP_METHOD void SDNode::dumprFull(const SelectionDAG *G) const {
771 // Don't print impossibly deep things.
772 dumprWithDepth(G, 10);
776 void SDNode::print(raw_ostream &OS, const SelectionDAG *G) const {
778 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
779 if (i) OS << ", "; else OS << " ";
780 printOperand(OS, G, getOperand(i));