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/SelectionDAG.h"
24 #include "llvm/CodeGen/SelectionDAGNodes.h"
25 #include "llvm/CodeGen/TargetInstrInfo.h"
26 #include "llvm/CodeGen/TargetLowering.h"
27 #include "llvm/CodeGen/TargetRegisterInfo.h"
28 #include "llvm/CodeGen/TargetSubtargetInfo.h"
29 #include "llvm/CodeGen/ValueTypes.h"
30 #include "llvm/Config/llvm-config.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/ModuleSlotTracker.h"
38 #include "llvm/IR/Value.h"
39 #include "llvm/Support/Casting.h"
40 #include "llvm/Support/CommandLine.h"
41 #include "llvm/Support/Compiler.h"
42 #include "llvm/Support/Debug.h"
43 #include "llvm/Support/ErrorHandling.h"
44 #include "llvm/Support/MachineValueType.h"
45 #include "llvm/Support/Printable.h"
46 #include "llvm/Support/raw_ostream.h"
47 #include "llvm/Target/TargetIntrinsicInfo.h"
48 #include "llvm/Target/TargetMachine.h"
49 #include "SDNodeDbgValue.h"
56 VerboseDAGDumping("dag-dump-verbose", cl::Hidden,
57 cl::desc("Display more information when dumping selection "
60 std::string SDNode::getOperationName(const SelectionDAG *G) const {
61 switch (getOpcode()) {
63 if (getOpcode() < ISD::BUILTIN_OP_END)
64 return "<<Unknown DAG Node>>";
65 if (isMachineOpcode()) {
67 if (const TargetInstrInfo *TII = G->getSubtarget().getInstrInfo())
68 if (getMachineOpcode() < TII->getNumOpcodes())
69 return TII->getName(getMachineOpcode());
70 return "<<Unknown Machine Node #" + utostr(getOpcode()) + ">>";
73 const TargetLowering &TLI = G->getTargetLoweringInfo();
74 const char *Name = TLI.getTargetNodeName(getOpcode());
75 if (Name) return Name;
76 return "<<Unknown Target Node #" + utostr(getOpcode()) + ">>";
78 return "<<Unknown Node #" + utostr(getOpcode()) + ">>";
81 case ISD::DELETED_NODE: return "<<Deleted Node!>>";
83 case ISD::PREFETCH: return "Prefetch";
84 case ISD::ATOMIC_FENCE: return "AtomicFence";
85 case ISD::ATOMIC_CMP_SWAP: return "AtomicCmpSwap";
86 case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS: return "AtomicCmpSwapWithSuccess";
87 case ISD::ATOMIC_SWAP: return "AtomicSwap";
88 case ISD::ATOMIC_LOAD_ADD: return "AtomicLoadAdd";
89 case ISD::ATOMIC_LOAD_SUB: return "AtomicLoadSub";
90 case ISD::ATOMIC_LOAD_AND: return "AtomicLoadAnd";
91 case ISD::ATOMIC_LOAD_CLR: return "AtomicLoadClr";
92 case ISD::ATOMIC_LOAD_OR: return "AtomicLoadOr";
93 case ISD::ATOMIC_LOAD_XOR: return "AtomicLoadXor";
94 case ISD::ATOMIC_LOAD_NAND: return "AtomicLoadNand";
95 case ISD::ATOMIC_LOAD_MIN: return "AtomicLoadMin";
96 case ISD::ATOMIC_LOAD_MAX: return "AtomicLoadMax";
97 case ISD::ATOMIC_LOAD_UMIN: return "AtomicLoadUMin";
98 case ISD::ATOMIC_LOAD_UMAX: return "AtomicLoadUMax";
99 case ISD::ATOMIC_LOAD: return "AtomicLoad";
100 case ISD::ATOMIC_STORE: return "AtomicStore";
101 case ISD::PCMARKER: return "PCMarker";
102 case ISD::READCYCLECOUNTER: return "ReadCycleCounter";
103 case ISD::SRCVALUE: return "SrcValue";
104 case ISD::MDNODE_SDNODE: return "MDNode";
105 case ISD::EntryToken: return "EntryToken";
106 case ISD::TokenFactor: return "TokenFactor";
107 case ISD::AssertSext: return "AssertSext";
108 case ISD::AssertZext: return "AssertZext";
110 case ISD::BasicBlock: return "BasicBlock";
111 case ISD::VALUETYPE: return "ValueType";
112 case ISD::Register: return "Register";
113 case ISD::RegisterMask: return "RegisterMask";
115 if (cast<ConstantSDNode>(this)->isOpaque())
116 return "OpaqueConstant";
118 case ISD::ConstantFP: return "ConstantFP";
119 case ISD::GlobalAddress: return "GlobalAddress";
120 case ISD::GlobalTLSAddress: return "GlobalTLSAddress";
121 case ISD::FrameIndex: return "FrameIndex";
122 case ISD::JumpTable: return "JumpTable";
123 case ISD::GLOBAL_OFFSET_TABLE: return "GLOBAL_OFFSET_TABLE";
124 case ISD::RETURNADDR: return "RETURNADDR";
125 case ISD::ADDROFRETURNADDR: return "ADDROFRETURNADDR";
126 case ISD::FRAMEADDR: return "FRAMEADDR";
127 case ISD::SPONENTRY: return "SPONENTRY";
128 case ISD::LOCAL_RECOVER: return "LOCAL_RECOVER";
129 case ISD::READ_REGISTER: return "READ_REGISTER";
130 case ISD::WRITE_REGISTER: return "WRITE_REGISTER";
131 case ISD::FRAME_TO_ARGS_OFFSET: return "FRAME_TO_ARGS_OFFSET";
132 case ISD::EH_DWARF_CFA: return "EH_DWARF_CFA";
133 case ISD::EH_RETURN: return "EH_RETURN";
134 case ISD::EH_SJLJ_SETJMP: return "EH_SJLJ_SETJMP";
135 case ISD::EH_SJLJ_LONGJMP: return "EH_SJLJ_LONGJMP";
136 case ISD::EH_SJLJ_SETUP_DISPATCH: return "EH_SJLJ_SETUP_DISPATCH";
137 case ISD::ConstantPool: return "ConstantPool";
138 case ISD::TargetIndex: return "TargetIndex";
139 case ISD::ExternalSymbol: return "ExternalSymbol";
140 case ISD::BlockAddress: return "BlockAddress";
141 case ISD::INTRINSIC_WO_CHAIN:
142 case ISD::INTRINSIC_VOID:
143 case ISD::INTRINSIC_W_CHAIN: {
144 unsigned OpNo = getOpcode() == ISD::INTRINSIC_WO_CHAIN ? 0 : 1;
145 unsigned IID = cast<ConstantSDNode>(getOperand(OpNo))->getZExtValue();
146 if (IID < Intrinsic::num_intrinsics)
147 return Intrinsic::getName((Intrinsic::ID)IID, None);
148 else if (const TargetIntrinsicInfo *TII = G->getTarget().getIntrinsicInfo())
149 return TII->getName(IID);
150 llvm_unreachable("Invalid intrinsic ID");
153 case ISD::BUILD_VECTOR: return "BUILD_VECTOR";
154 case ISD::TargetConstant:
155 if (cast<ConstantSDNode>(this)->isOpaque())
156 return "OpaqueTargetConstant";
157 return "TargetConstant";
158 case ISD::TargetConstantFP: return "TargetConstantFP";
159 case ISD::TargetGlobalAddress: return "TargetGlobalAddress";
160 case ISD::TargetGlobalTLSAddress: return "TargetGlobalTLSAddress";
161 case ISD::TargetFrameIndex: return "TargetFrameIndex";
162 case ISD::TargetJumpTable: return "TargetJumpTable";
163 case ISD::TargetConstantPool: return "TargetConstantPool";
164 case ISD::TargetExternalSymbol: return "TargetExternalSymbol";
165 case ISD::MCSymbol: return "MCSymbol";
166 case ISD::TargetBlockAddress: return "TargetBlockAddress";
168 case ISD::CopyToReg: return "CopyToReg";
169 case ISD::CopyFromReg: return "CopyFromReg";
170 case ISD::UNDEF: return "undef";
171 case ISD::MERGE_VALUES: return "merge_values";
172 case ISD::INLINEASM: return "inlineasm";
173 case ISD::EH_LABEL: return "eh_label";
174 case ISD::HANDLENODE: return "handlenode";
177 case ISD::FABS: return "fabs";
178 case ISD::FMINNUM: return "fminnum";
179 case ISD::STRICT_FMINNUM: return "strict_fminnum";
180 case ISD::FMAXNUM: return "fmaxnum";
181 case ISD::STRICT_FMAXNUM: return "strict_fmaxnum";
182 case ISD::FMINNUM_IEEE: return "fminnum_ieee";
183 case ISD::FMAXNUM_IEEE: return "fmaxnum_ieee";
184 case ISD::FMINIMUM: return "fminimum";
185 case ISD::FMAXIMUM: return "fmaximum";
186 case ISD::FNEG: return "fneg";
187 case ISD::FSQRT: return "fsqrt";
188 case ISD::STRICT_FSQRT: return "strict_fsqrt";
189 case ISD::FCBRT: return "fcbrt";
190 case ISD::FSIN: return "fsin";
191 case ISD::STRICT_FSIN: return "strict_fsin";
192 case ISD::FCOS: return "fcos";
193 case ISD::STRICT_FCOS: return "strict_fcos";
194 case ISD::FSINCOS: return "fsincos";
195 case ISD::FTRUNC: return "ftrunc";
196 case ISD::STRICT_FTRUNC: return "strict_ftrunc";
197 case ISD::FFLOOR: return "ffloor";
198 case ISD::STRICT_FFLOOR: return "strict_ffloor";
199 case ISD::FCEIL: return "fceil";
200 case ISD::STRICT_FCEIL: return "strict_fceil";
201 case ISD::FRINT: return "frint";
202 case ISD::STRICT_FRINT: return "strict_frint";
203 case ISD::FNEARBYINT: return "fnearbyint";
204 case ISD::STRICT_FNEARBYINT: return "strict_fnearbyint";
205 case ISD::FROUND: return "fround";
206 case ISD::STRICT_FROUND: return "strict_fround";
207 case ISD::FEXP: return "fexp";
208 case ISD::STRICT_FEXP: return "strict_fexp";
209 case ISD::FEXP2: return "fexp2";
210 case ISD::STRICT_FEXP2: return "strict_fexp2";
211 case ISD::FLOG: return "flog";
212 case ISD::STRICT_FLOG: return "strict_flog";
213 case ISD::FLOG2: return "flog2";
214 case ISD::STRICT_FLOG2: return "strict_flog2";
215 case ISD::FLOG10: return "flog10";
216 case ISD::STRICT_FLOG10: return "strict_flog10";
219 case ISD::ADD: return "add";
220 case ISD::SUB: return "sub";
221 case ISD::MUL: return "mul";
222 case ISD::MULHU: return "mulhu";
223 case ISD::MULHS: return "mulhs";
224 case ISD::SDIV: return "sdiv";
225 case ISD::UDIV: return "udiv";
226 case ISD::SREM: return "srem";
227 case ISD::UREM: return "urem";
228 case ISD::SMUL_LOHI: return "smul_lohi";
229 case ISD::UMUL_LOHI: return "umul_lohi";
230 case ISD::SDIVREM: return "sdivrem";
231 case ISD::UDIVREM: return "udivrem";
232 case ISD::AND: return "and";
233 case ISD::OR: return "or";
234 case ISD::XOR: return "xor";
235 case ISD::SHL: return "shl";
236 case ISD::SRA: return "sra";
237 case ISD::SRL: return "srl";
238 case ISD::ROTL: return "rotl";
239 case ISD::ROTR: return "rotr";
240 case ISD::FSHL: return "fshl";
241 case ISD::FSHR: return "fshr";
242 case ISD::FADD: return "fadd";
243 case ISD::STRICT_FADD: return "strict_fadd";
244 case ISD::FSUB: return "fsub";
245 case ISD::STRICT_FSUB: return "strict_fsub";
246 case ISD::FMUL: return "fmul";
247 case ISD::STRICT_FMUL: return "strict_fmul";
248 case ISD::FDIV: return "fdiv";
249 case ISD::STRICT_FDIV: return "strict_fdiv";
250 case ISD::FMA: return "fma";
251 case ISD::STRICT_FMA: return "strict_fma";
252 case ISD::FMAD: return "fmad";
253 case ISD::FREM: return "frem";
254 case ISD::STRICT_FREM: return "strict_frem";
255 case ISD::FCOPYSIGN: return "fcopysign";
256 case ISD::FGETSIGN: return "fgetsign";
257 case ISD::FCANONICALIZE: return "fcanonicalize";
258 case ISD::FPOW: return "fpow";
259 case ISD::STRICT_FPOW: return "strict_fpow";
260 case ISD::SMIN: return "smin";
261 case ISD::SMAX: return "smax";
262 case ISD::UMIN: return "umin";
263 case ISD::UMAX: return "umax";
265 case ISD::FPOWI: return "fpowi";
266 case ISD::STRICT_FPOWI: return "strict_fpowi";
267 case ISD::SETCC: return "setcc";
268 case ISD::SETCCCARRY: return "setcccarry";
269 case ISD::SELECT: return "select";
270 case ISD::VSELECT: return "vselect";
271 case ISD::SELECT_CC: return "select_cc";
272 case ISD::INSERT_VECTOR_ELT: return "insert_vector_elt";
273 case ISD::EXTRACT_VECTOR_ELT: return "extract_vector_elt";
274 case ISD::CONCAT_VECTORS: return "concat_vectors";
275 case ISD::INSERT_SUBVECTOR: return "insert_subvector";
276 case ISD::EXTRACT_SUBVECTOR: return "extract_subvector";
277 case ISD::SCALAR_TO_VECTOR: return "scalar_to_vector";
278 case ISD::VECTOR_SHUFFLE: return "vector_shuffle";
279 case ISD::CARRY_FALSE: return "carry_false";
280 case ISD::ADDC: return "addc";
281 case ISD::ADDE: return "adde";
282 case ISD::ADDCARRY: return "addcarry";
283 case ISD::SADDO: return "saddo";
284 case ISD::UADDO: return "uaddo";
285 case ISD::SSUBO: return "ssubo";
286 case ISD::USUBO: return "usubo";
287 case ISD::SMULO: return "smulo";
288 case ISD::UMULO: return "umulo";
289 case ISD::SUBC: return "subc";
290 case ISD::SUBE: return "sube";
291 case ISD::SUBCARRY: return "subcarry";
292 case ISD::SHL_PARTS: return "shl_parts";
293 case ISD::SRA_PARTS: return "sra_parts";
294 case ISD::SRL_PARTS: return "srl_parts";
296 case ISD::SADDSAT: return "saddsat";
297 case ISD::UADDSAT: return "uaddsat";
298 case ISD::SSUBSAT: return "ssubsat";
299 case ISD::USUBSAT: return "usubsat";
300 case ISD::SMULFIX: return "smulfix";
302 // Conversion operators.
303 case ISD::SIGN_EXTEND: return "sign_extend";
304 case ISD::ZERO_EXTEND: return "zero_extend";
305 case ISD::ANY_EXTEND: return "any_extend";
306 case ISD::SIGN_EXTEND_INREG: return "sign_extend_inreg";
307 case ISD::ANY_EXTEND_VECTOR_INREG: return "any_extend_vector_inreg";
308 case ISD::SIGN_EXTEND_VECTOR_INREG: return "sign_extend_vector_inreg";
309 case ISD::ZERO_EXTEND_VECTOR_INREG: return "zero_extend_vector_inreg";
310 case ISD::TRUNCATE: return "truncate";
311 case ISD::FP_ROUND: return "fp_round";
312 case ISD::FLT_ROUNDS_: return "flt_rounds";
313 case ISD::FP_ROUND_INREG: return "fp_round_inreg";
314 case ISD::FP_EXTEND: return "fp_extend";
316 case ISD::SINT_TO_FP: return "sint_to_fp";
317 case ISD::UINT_TO_FP: return "uint_to_fp";
318 case ISD::FP_TO_SINT: return "fp_to_sint";
319 case ISD::FP_TO_UINT: return "fp_to_uint";
320 case ISD::BITCAST: return "bitcast";
321 case ISD::ADDRSPACECAST: return "addrspacecast";
322 case ISD::FP16_TO_FP: return "fp16_to_fp";
323 case ISD::FP_TO_FP16: return "fp_to_fp16";
325 // Control flow instructions
326 case ISD::BR: return "br";
327 case ISD::BRIND: return "brind";
328 case ISD::BR_JT: return "br_jt";
329 case ISD::BRCOND: return "brcond";
330 case ISD::BR_CC: return "br_cc";
331 case ISD::CALLSEQ_START: return "callseq_start";
332 case ISD::CALLSEQ_END: return "callseq_end";
335 case ISD::CATCHRET: return "catchret";
336 case ISD::CLEANUPRET: return "cleanupret";
339 case ISD::LOAD: return "load";
340 case ISD::STORE: return "store";
341 case ISD::MLOAD: return "masked_load";
342 case ISD::MSTORE: return "masked_store";
343 case ISD::MGATHER: return "masked_gather";
344 case ISD::MSCATTER: return "masked_scatter";
345 case ISD::VAARG: return "vaarg";
346 case ISD::VACOPY: return "vacopy";
347 case ISD::VAEND: return "vaend";
348 case ISD::VASTART: return "vastart";
349 case ISD::DYNAMIC_STACKALLOC: return "dynamic_stackalloc";
350 case ISD::EXTRACT_ELEMENT: return "extract_element";
351 case ISD::BUILD_PAIR: return "build_pair";
352 case ISD::STACKSAVE: return "stacksave";
353 case ISD::STACKRESTORE: return "stackrestore";
354 case ISD::TRAP: return "trap";
355 case ISD::DEBUGTRAP: return "debugtrap";
356 case ISD::LIFETIME_START: return "lifetime.start";
357 case ISD::LIFETIME_END: return "lifetime.end";
358 case ISD::GC_TRANSITION_START: return "gc_transition.start";
359 case ISD::GC_TRANSITION_END: return "gc_transition.end";
360 case ISD::GET_DYNAMIC_AREA_OFFSET: return "get.dynamic.area.offset";
363 case ISD::ABS: return "abs";
364 case ISD::BITREVERSE: return "bitreverse";
365 case ISD::BSWAP: return "bswap";
366 case ISD::CTPOP: return "ctpop";
367 case ISD::CTTZ: return "cttz";
368 case ISD::CTTZ_ZERO_UNDEF: return "cttz_zero_undef";
369 case ISD::CTLZ: return "ctlz";
370 case ISD::CTLZ_ZERO_UNDEF: return "ctlz_zero_undef";
373 case ISD::INIT_TRAMPOLINE: return "init_trampoline";
374 case ISD::ADJUST_TRAMPOLINE: return "adjust_trampoline";
377 switch (cast<CondCodeSDNode>(this)->get()) {
378 default: llvm_unreachable("Unknown setcc condition!");
379 case ISD::SETOEQ: return "setoeq";
380 case ISD::SETOGT: return "setogt";
381 case ISD::SETOGE: return "setoge";
382 case ISD::SETOLT: return "setolt";
383 case ISD::SETOLE: return "setole";
384 case ISD::SETONE: return "setone";
386 case ISD::SETO: return "seto";
387 case ISD::SETUO: return "setuo";
388 case ISD::SETUEQ: return "setueq";
389 case ISD::SETUGT: return "setugt";
390 case ISD::SETUGE: return "setuge";
391 case ISD::SETULT: return "setult";
392 case ISD::SETULE: return "setule";
393 case ISD::SETUNE: return "setune";
395 case ISD::SETEQ: return "seteq";
396 case ISD::SETGT: return "setgt";
397 case ISD::SETGE: return "setge";
398 case ISD::SETLT: return "setlt";
399 case ISD::SETLE: return "setle";
400 case ISD::SETNE: return "setne";
402 case ISD::SETTRUE: return "settrue";
403 case ISD::SETTRUE2: return "settrue2";
404 case ISD::SETFALSE: return "setfalse";
405 case ISD::SETFALSE2: return "setfalse2";
407 case ISD::VECREDUCE_FADD: return "vecreduce_fadd";
408 case ISD::VECREDUCE_STRICT_FADD: return "vecreduce_strict_fadd";
409 case ISD::VECREDUCE_FMUL: return "vecreduce_fmul";
410 case ISD::VECREDUCE_STRICT_FMUL: return "vecreduce_strict_fmul";
411 case ISD::VECREDUCE_ADD: return "vecreduce_add";
412 case ISD::VECREDUCE_MUL: return "vecreduce_mul";
413 case ISD::VECREDUCE_AND: return "vecreduce_and";
414 case ISD::VECREDUCE_OR: return "vecreduce_or";
415 case ISD::VECREDUCE_XOR: return "vecreduce_xor";
416 case ISD::VECREDUCE_SMAX: return "vecreduce_smax";
417 case ISD::VECREDUCE_SMIN: return "vecreduce_smin";
418 case ISD::VECREDUCE_UMAX: return "vecreduce_umax";
419 case ISD::VECREDUCE_UMIN: return "vecreduce_umin";
420 case ISD::VECREDUCE_FMAX: return "vecreduce_fmax";
421 case ISD::VECREDUCE_FMIN: return "vecreduce_fmin";
425 const char *SDNode::getIndexedModeName(ISD::MemIndexedMode AM) {
428 case ISD::PRE_INC: return "<pre-inc>";
429 case ISD::PRE_DEC: return "<pre-dec>";
430 case ISD::POST_INC: return "<post-inc>";
431 case ISD::POST_DEC: return "<post-dec>";
435 static Printable PrintNodeId(const SDNode &Node) {
436 return Printable([&Node](raw_ostream &OS) {
438 OS << 't' << Node.PersistentId;
440 OS << (const void*)&Node;
445 // Print the MMO with more information from the SelectionDAG.
446 static void printMemOperand(raw_ostream &OS, const MachineMemOperand &MMO,
447 const MachineFunction *MF, const Module *M,
448 const MachineFrameInfo *MFI,
449 const TargetInstrInfo *TII, LLVMContext &Ctx) {
450 ModuleSlotTracker MST(M);
452 MST.incorporateFunction(MF->getFunction());
453 SmallVector<StringRef, 0> SSNs;
454 MMO.print(OS, MST, SSNs, Ctx, MFI, TII);
457 static void printMemOperand(raw_ostream &OS, const MachineMemOperand &MMO,
458 const SelectionDAG *G) {
460 const MachineFunction *MF = &G->getMachineFunction();
461 return printMemOperand(OS, MMO, MF, MF->getFunction().getParent(),
462 &MF->getFrameInfo(), G->getSubtarget().getInstrInfo(),
466 return printMemOperand(OS, MMO, /*MF=*/nullptr, /*M=*/nullptr,
467 /*MFI=*/nullptr, /*TII=*/nullptr, Ctx);
471 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
472 LLVM_DUMP_METHOD void SDNode::dump() const { dump(nullptr); }
474 LLVM_DUMP_METHOD void SDNode::dump(const SelectionDAG *G) const {
480 void SDNode::print_types(raw_ostream &OS, const SelectionDAG *G) const {
481 for (unsigned i = 0, e = getNumValues(); i != e; ++i) {
483 if (getValueType(i) == MVT::Other)
486 OS << getValueType(i).getEVTString();
490 void SDNode::print_details(raw_ostream &OS, const SelectionDAG *G) const {
491 if (getFlags().hasNoUnsignedWrap())
494 if (getFlags().hasNoSignedWrap())
497 if (getFlags().hasExact())
500 if (getFlags().hasNoNaNs())
503 if (getFlags().hasNoInfs())
506 if (getFlags().hasNoSignedZeros())
509 if (getFlags().hasAllowReciprocal())
512 if (getFlags().hasAllowContract())
515 if (getFlags().hasApproximateFuncs())
518 if (getFlags().hasAllowReassociation())
521 if (getFlags().hasVectorReduction())
522 OS << " vector-reduction";
524 if (const MachineSDNode *MN = dyn_cast<MachineSDNode>(this)) {
525 if (!MN->memoperands_empty()) {
528 for (MachineSDNode::mmo_iterator i = MN->memoperands_begin(),
529 e = MN->memoperands_end(); i != e; ++i) {
530 printMemOperand(OS, **i, G);
531 if (std::next(i) != e)
536 } else if (const ShuffleVectorSDNode *SVN =
537 dyn_cast<ShuffleVectorSDNode>(this)) {
539 for (unsigned i = 0, e = ValueList[0].getVectorNumElements(); i != e; ++i) {
540 int Idx = SVN->getMaskElt(i);
548 } else if (const ConstantSDNode *CSDN = dyn_cast<ConstantSDNode>(this)) {
549 OS << '<' << CSDN->getAPIntValue() << '>';
550 } else if (const ConstantFPSDNode *CSDN = dyn_cast<ConstantFPSDNode>(this)) {
551 if (&CSDN->getValueAPF().getSemantics() == &APFloat::IEEEsingle())
552 OS << '<' << CSDN->getValueAPF().convertToFloat() << '>';
553 else if (&CSDN->getValueAPF().getSemantics() == &APFloat::IEEEdouble())
554 OS << '<' << CSDN->getValueAPF().convertToDouble() << '>';
557 CSDN->getValueAPF().bitcastToAPInt().print(OS, false);
560 } else if (const GlobalAddressSDNode *GADN =
561 dyn_cast<GlobalAddressSDNode>(this)) {
562 int64_t offset = GADN->getOffset();
564 GADN->getGlobal()->printAsOperand(OS);
567 OS << " + " << offset;
570 if (unsigned int TF = GADN->getTargetFlags())
571 OS << " [TF=" << TF << ']';
572 } else if (const FrameIndexSDNode *FIDN = dyn_cast<FrameIndexSDNode>(this)) {
573 OS << "<" << FIDN->getIndex() << ">";
574 } else if (const JumpTableSDNode *JTDN = dyn_cast<JumpTableSDNode>(this)) {
575 OS << "<" << JTDN->getIndex() << ">";
576 if (unsigned int TF = JTDN->getTargetFlags())
577 OS << " [TF=" << TF << ']';
578 } else if (const ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(this)){
579 int offset = CP->getOffset();
580 if (CP->isMachineConstantPoolEntry())
581 OS << "<" << *CP->getMachineCPVal() << ">";
583 OS << "<" << *CP->getConstVal() << ">";
585 OS << " + " << offset;
588 if (unsigned int TF = CP->getTargetFlags())
589 OS << " [TF=" << TF << ']';
590 } else if (const TargetIndexSDNode *TI = dyn_cast<TargetIndexSDNode>(this)) {
591 OS << "<" << TI->getIndex() << '+' << TI->getOffset() << ">";
592 if (unsigned TF = TI->getTargetFlags())
593 OS << " [TF=" << TF << ']';
594 } else if (const BasicBlockSDNode *BBDN = dyn_cast<BasicBlockSDNode>(this)) {
596 const Value *LBB = (const Value*)BBDN->getBasicBlock()->getBasicBlock();
598 OS << LBB->getName() << " ";
599 OS << (const void*)BBDN->getBasicBlock() << ">";
600 } else if (const RegisterSDNode *R = dyn_cast<RegisterSDNode>(this)) {
601 OS << ' ' << printReg(R->getReg(),
602 G ? G->getSubtarget().getRegisterInfo() : nullptr);
603 } else if (const ExternalSymbolSDNode *ES =
604 dyn_cast<ExternalSymbolSDNode>(this)) {
605 OS << "'" << ES->getSymbol() << "'";
606 if (unsigned int TF = ES->getTargetFlags())
607 OS << " [TF=" << TF << ']';
608 } else if (const SrcValueSDNode *M = dyn_cast<SrcValueSDNode>(this)) {
610 OS << "<" << M->getValue() << ">";
613 } else if (const MDNodeSDNode *MD = dyn_cast<MDNodeSDNode>(this)) {
615 OS << "<" << MD->getMD() << ">";
618 } else if (const VTSDNode *N = dyn_cast<VTSDNode>(this)) {
619 OS << ":" << N->getVT().getEVTString();
621 else if (const LoadSDNode *LD = dyn_cast<LoadSDNode>(this)) {
624 printMemOperand(OS, *LD->getMemOperand(), G);
627 switch (LD->getExtensionType()) {
628 default: doExt = false; break;
629 case ISD::EXTLOAD: OS << ", anyext"; break;
630 case ISD::SEXTLOAD: OS << ", sext"; break;
631 case ISD::ZEXTLOAD: OS << ", zext"; break;
634 OS << " from " << LD->getMemoryVT().getEVTString();
636 const char *AM = getIndexedModeName(LD->getAddressingMode());
641 } else if (const StoreSDNode *ST = dyn_cast<StoreSDNode>(this)) {
643 printMemOperand(OS, *ST->getMemOperand(), G);
645 if (ST->isTruncatingStore())
646 OS << ", trunc to " << ST->getMemoryVT().getEVTString();
648 const char *AM = getIndexedModeName(ST->getAddressingMode());
653 } else if (const MemSDNode* M = dyn_cast<MemSDNode>(this)) {
655 printMemOperand(OS, *M->getMemOperand(), G);
657 } else if (const BlockAddressSDNode *BA =
658 dyn_cast<BlockAddressSDNode>(this)) {
659 int64_t offset = BA->getOffset();
661 BA->getBlockAddress()->getFunction()->printAsOperand(OS, false);
663 BA->getBlockAddress()->getBasicBlock()->printAsOperand(OS, false);
666 OS << " + " << offset;
669 if (unsigned int TF = BA->getTargetFlags())
670 OS << " [TF=" << TF << ']';
671 } else if (const AddrSpaceCastSDNode *ASC =
672 dyn_cast<AddrSpaceCastSDNode>(this)) {
674 << ASC->getSrcAddressSpace()
676 << ASC->getDestAddressSpace()
680 if (VerboseDAGDumping) {
681 if (unsigned Order = getIROrder())
682 OS << " [ORD=" << Order << ']';
684 if (getNodeId() != -1)
685 OS << " [ID=" << getNodeId() << ']';
686 if (!(isa<ConstantSDNode>(this) || (isa<ConstantFPSDNode>(this))))
687 OS << "# D:" << isDivergent();
692 DILocation *L = getDebugLoc();
696 if (auto *Scope = L->getScope())
697 OS << Scope->getFilename();
700 OS << ':' << L->getLine();
701 if (unsigned C = L->getColumn())
704 for (SDDbgValue *Dbg : G->GetDbgValues(this)) {
705 if (Dbg->getKind() != SDDbgValue::SDNODE || Dbg->isInvalidated())
712 LLVM_DUMP_METHOD void SDDbgValue::dump(raw_ostream &OS) const {
715 OS << '(' << u.s.ResNo << ')';
716 OS << ":\"" << Var->getName() << '"';
718 if (Expr->getNumElements())
723 /// Return true if this node is so simple that we should just print it inline
724 /// if it appears as an operand.
725 static bool shouldPrintInline(const SDNode &Node) {
726 if (Node.getOpcode() == ISD::EntryToken)
728 return Node.getNumOperands() == 0;
731 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
732 static void DumpNodes(const SDNode *N, unsigned indent, const SelectionDAG *G) {
733 for (const SDValue &Op : N->op_values()) {
734 if (shouldPrintInline(*Op.getNode()))
736 if (Op.getNode()->hasOneUse())
737 DumpNodes(Op.getNode(), indent+2, G);
740 dbgs().indent(indent);
744 LLVM_DUMP_METHOD void SelectionDAG::dump() const {
745 dbgs() << "SelectionDAG has " << AllNodes.size() << " nodes:\n";
747 for (allnodes_const_iterator I = allnodes_begin(), E = allnodes_end();
749 const SDNode *N = &*I;
750 if (!N->hasOneUse() && N != getRoot().getNode() &&
751 (!shouldPrintInline(*N) || N->use_empty()))
752 DumpNodes(N, 2, this);
755 if (getRoot().getNode()) DumpNodes(getRoot().getNode(), 2, this);
760 void SDNode::printr(raw_ostream &OS, const SelectionDAG *G) const {
761 OS << PrintNodeId(*this) << ": ";
763 OS << " = " << getOperationName(G);
764 print_details(OS, G);
767 static bool printOperand(raw_ostream &OS, const SelectionDAG *G,
768 const SDValue Value) {
769 if (!Value.getNode()) {
772 } else if (shouldPrintInline(*Value.getNode())) {
773 OS << Value->getOperationName(G) << ':';
774 Value->print_types(OS, G);
775 Value->print_details(OS, G);
778 OS << PrintNodeId(*Value.getNode());
779 if (unsigned RN = Value.getResNo())
785 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
786 using VisitedSDNodeSet = SmallPtrSet<const SDNode *, 32>;
788 static void DumpNodesr(raw_ostream &OS, const SDNode *N, unsigned indent,
789 const SelectionDAG *G, VisitedSDNodeSet &once) {
790 if (!once.insert(N).second) // If we've been here before, return now.
793 // Dump the current SDNode, but don't end the line yet.
797 // Having printed this SDNode, walk the children:
798 for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
802 const SDValue Op = N->getOperand(i);
803 bool printedInline = printOperand(OS, G, Op);
805 once.insert(Op.getNode());
810 // Dump children that have grandchildren on their own line(s).
811 for (const SDValue &Op : N->op_values())
812 DumpNodesr(OS, Op.getNode(), indent+2, G, once);
815 LLVM_DUMP_METHOD void SDNode::dumpr() const {
816 VisitedSDNodeSet once;
817 DumpNodesr(dbgs(), this, 0, nullptr, once);
820 LLVM_DUMP_METHOD void SDNode::dumpr(const SelectionDAG *G) const {
821 VisitedSDNodeSet once;
822 DumpNodesr(dbgs(), this, 0, G, once);
826 static void printrWithDepthHelper(raw_ostream &OS, const SDNode *N,
827 const SelectionDAG *G, unsigned depth,
839 for (const SDValue &Op : N->op_values()) {
840 // Don't follow chain operands.
841 if (Op.getValueType() == MVT::Other)
844 printrWithDepthHelper(OS, Op.getNode(), G, depth-1, indent+2);
848 void SDNode::printrWithDepth(raw_ostream &OS, const SelectionDAG *G,
849 unsigned depth) const {
850 printrWithDepthHelper(OS, this, G, depth, 0);
853 void SDNode::printrFull(raw_ostream &OS, const SelectionDAG *G) const {
854 // Don't print impossibly deep things.
855 printrWithDepth(OS, G, 10);
858 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
860 void SDNode::dumprWithDepth(const SelectionDAG *G, unsigned depth) const {
861 printrWithDepth(dbgs(), G, depth);
864 LLVM_DUMP_METHOD void SDNode::dumprFull(const SelectionDAG *G) const {
865 // Don't print impossibly deep things.
866 dumprWithDepth(G, 10);
870 void SDNode::print(raw_ostream &OS, const SelectionDAG *G) const {
872 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
873 if (i) OS << ", "; else OS << " ";
874 printOperand(OS, G, getOperand(i));
876 if (DebugLoc DL = getDebugLoc()) {