1235 lines · cpp
1//===- SelectionDAGDumper.cpp - Implement SelectionDAG::dump() ------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8//9// This implements the SelectionDAG::dump method and friends.10//11//===----------------------------------------------------------------------===//12 13#include "SDNodeDbgValue.h"14#include "llvm/ADT/APFloat.h"15#include "llvm/ADT/APInt.h"16#include "llvm/ADT/SmallPtrSet.h"17#include "llvm/ADT/StringExtras.h"18#include "llvm/CodeGen/ISDOpcodes.h"19#include "llvm/CodeGen/MachineBasicBlock.h"20#include "llvm/CodeGen/MachineConstantPool.h"21#include "llvm/CodeGen/MachineMemOperand.h"22#include "llvm/CodeGen/SelectionDAG.h"23#include "llvm/CodeGen/SelectionDAGNodes.h"24#include "llvm/CodeGen/SelectionDAGTargetInfo.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/CodeGenTypes/MachineValueType.h"31#include "llvm/Config/llvm-config.h"32#include "llvm/IR/BasicBlock.h"33#include "llvm/IR/Constants.h"34#include "llvm/IR/DebugInfoMetadata.h"35#include "llvm/IR/DebugLoc.h"36#include "llvm/IR/Function.h"37#include "llvm/IR/Intrinsics.h"38#include "llvm/IR/ModuleSlotTracker.h"39#include "llvm/IR/Value.h"40#include "llvm/Support/Casting.h"41#include "llvm/Support/CommandLine.h"42#include "llvm/Support/Compiler.h"43#include "llvm/Support/Debug.h"44#include "llvm/Support/ErrorHandling.h"45#include "llvm/Support/Printable.h"46#include "llvm/Support/raw_ostream.h"47#include "llvm/Target/TargetMachine.h"48#include <cstdint>49#include <iterator>50 51using namespace llvm;52 53static cl::opt<bool>54VerboseDAGDumping("dag-dump-verbose", cl::Hidden,55 cl::desc("Display more information when dumping selection "56 "DAG nodes."));57 58std::string SDNode::getOperationName(const SelectionDAG *G) const {59 switch (getOpcode()) {60 default:61 if (getOpcode() < ISD::BUILTIN_OP_END)62 return "<<Unknown DAG Node>>";63 if (isMachineOpcode()) {64 if (G)65 if (const TargetInstrInfo *TII = G->getSubtarget().getInstrInfo())66 if (getMachineOpcode() < TII->getNumOpcodes())67 return std::string(TII->getName(getMachineOpcode()));68 return "<<Unknown Machine Node #" + utostr(getOpcode()) + ">>";69 }70 if (G) {71 const SelectionDAGTargetInfo &TSI = G->getSelectionDAGInfo();72 if (const char *Name = TSI.getTargetNodeName(getOpcode()))73 return Name;74 const TargetLowering &TLI = G->getTargetLoweringInfo();75 const char *Name = TLI.getTargetNodeName(getOpcode());76 if (Name) return Name;77 return "<<Unknown Target Node #" + utostr(getOpcode()) + ">>";78 }79 return "<<Unknown Node #" + utostr(getOpcode()) + ">>";80 81 // clang-format off82#ifndef NDEBUG83 case ISD::DELETED_NODE: return "<<Deleted Node!>>";84#endif85 case ISD::PREFETCH: return "Prefetch";86 case ISD::MEMBARRIER: return "MemBarrier";87 case ISD::ATOMIC_FENCE: return "AtomicFence";88 case ISD::ATOMIC_CMP_SWAP: return "AtomicCmpSwap";89 case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS: return "AtomicCmpSwapWithSuccess";90 case ISD::ATOMIC_SWAP: return "AtomicSwap";91 case ISD::ATOMIC_LOAD_ADD: return "AtomicLoadAdd";92 case ISD::ATOMIC_LOAD_SUB: return "AtomicLoadSub";93 case ISD::ATOMIC_LOAD_AND: return "AtomicLoadAnd";94 case ISD::ATOMIC_LOAD_CLR: return "AtomicLoadClr";95 case ISD::ATOMIC_LOAD_OR: return "AtomicLoadOr";96 case ISD::ATOMIC_LOAD_XOR: return "AtomicLoadXor";97 case ISD::ATOMIC_LOAD_NAND: return "AtomicLoadNand";98 case ISD::ATOMIC_LOAD_MIN: return "AtomicLoadMin";99 case ISD::ATOMIC_LOAD_MAX: return "AtomicLoadMax";100 case ISD::ATOMIC_LOAD_UMIN: return "AtomicLoadUMin";101 case ISD::ATOMIC_LOAD_UMAX: return "AtomicLoadUMax";102 case ISD::ATOMIC_LOAD_FADD: return "AtomicLoadFAdd";103 case ISD::ATOMIC_LOAD_FSUB: return "AtomicLoadFSub";104 case ISD::ATOMIC_LOAD_FMIN: return "AtomicLoadFMin";105 case ISD::ATOMIC_LOAD_FMAX: return "AtomicLoadFMax";106 case ISD::ATOMIC_LOAD_FMINIMUM: return "AtomicLoadFMinimum";107 case ISD::ATOMIC_LOAD_FMAXIMUM: return "AtomicLoadFMaximum";108 case ISD::ATOMIC_LOAD_UINC_WRAP:109 return "AtomicLoadUIncWrap";110 case ISD::ATOMIC_LOAD_UDEC_WRAP:111 return "AtomicLoadUDecWrap";112 case ISD::ATOMIC_LOAD_USUB_COND:113 return "AtomicLoadUSubCond";114 case ISD::ATOMIC_LOAD_USUB_SAT:115 return "AtomicLoadUSubSat";116 case ISD::ATOMIC_LOAD: return "AtomicLoad";117 case ISD::ATOMIC_STORE: return "AtomicStore";118 case ISD::PCMARKER: return "PCMarker";119 case ISD::READCYCLECOUNTER: return "ReadCycleCounter";120 case ISD::READSTEADYCOUNTER: return "ReadSteadyCounter";121 case ISD::SRCVALUE: return "SrcValue";122 case ISD::MDNODE_SDNODE: return "MDNode";123 case ISD::EntryToken: return "EntryToken";124 case ISD::TokenFactor: return "TokenFactor";125 case ISD::AssertSext: return "AssertSext";126 case ISD::AssertZext: return "AssertZext";127 case ISD::AssertNoFPClass: return "AssertNoFPClass";128 case ISD::AssertAlign: return "AssertAlign";129 130 case ISD::BasicBlock: return "BasicBlock";131 case ISD::VALUETYPE: return "ValueType";132 case ISD::Register: return "Register";133 case ISD::RegisterMask: return "RegisterMask";134 case ISD::Constant:135 if (cast<ConstantSDNode>(this)->isOpaque())136 return "OpaqueConstant";137 return "Constant";138 case ISD::ConstantFP: return "ConstantFP";139 case ISD::GlobalAddress: return "GlobalAddress";140 case ISD::GlobalTLSAddress: return "GlobalTLSAddress";141 case ISD::PtrAuthGlobalAddress: return "PtrAuthGlobalAddress";142 case ISD::FrameIndex: return "FrameIndex";143 case ISD::JumpTable: return "JumpTable";144 case ISD::JUMP_TABLE_DEBUG_INFO:145 return "JUMP_TABLE_DEBUG_INFO";146 case ISD::GLOBAL_OFFSET_TABLE: return "GLOBAL_OFFSET_TABLE";147 case ISD::RETURNADDR: return "RETURNADDR";148 case ISD::ADDROFRETURNADDR: return "ADDROFRETURNADDR";149 case ISD::FRAMEADDR: return "FRAMEADDR";150 case ISD::SPONENTRY: return "SPONENTRY";151 case ISD::LOCAL_RECOVER: return "LOCAL_RECOVER";152 case ISD::READ_REGISTER: return "READ_REGISTER";153 case ISD::WRITE_REGISTER: return "WRITE_REGISTER";154 case ISD::FRAME_TO_ARGS_OFFSET: return "FRAME_TO_ARGS_OFFSET";155 case ISD::EH_DWARF_CFA: return "EH_DWARF_CFA";156 case ISD::EH_RETURN: return "EH_RETURN";157 case ISD::EH_SJLJ_SETJMP: return "EH_SJLJ_SETJMP";158 case ISD::EH_SJLJ_LONGJMP: return "EH_SJLJ_LONGJMP";159 case ISD::EH_SJLJ_SETUP_DISPATCH: return "EH_SJLJ_SETUP_DISPATCH";160 case ISD::ConstantPool: return "ConstantPool";161 case ISD::TargetIndex: return "TargetIndex";162 case ISD::ExternalSymbol: return "ExternalSymbol";163 case ISD::BlockAddress: return "BlockAddress";164 case ISD::INTRINSIC_WO_CHAIN:165 case ISD::INTRINSIC_VOID:166 case ISD::INTRINSIC_W_CHAIN: {167 unsigned OpNo = getOpcode() == ISD::INTRINSIC_WO_CHAIN ? 0 : 1;168 unsigned IID = getOperand(OpNo)->getAsZExtVal();169 if (IID < Intrinsic::num_intrinsics)170 return Intrinsic::getBaseName((Intrinsic::ID)IID).str();171 if (!G)172 return "Unknown intrinsic";173 llvm_unreachable("Invalid intrinsic ID");174 }175 176 case ISD::BUILD_VECTOR: return "BUILD_VECTOR";177 case ISD::TargetConstant:178 if (cast<ConstantSDNode>(this)->isOpaque())179 return "OpaqueTargetConstant";180 return "TargetConstant";181 182 case ISD::TargetConstantFP: return "TargetConstantFP";183 case ISD::TargetGlobalAddress: return "TargetGlobalAddress";184 case ISD::TargetGlobalTLSAddress: return "TargetGlobalTLSAddress";185 case ISD::TargetFrameIndex: return "TargetFrameIndex";186 case ISD::TargetJumpTable: return "TargetJumpTable";187 case ISD::TargetConstantPool: return "TargetConstantPool";188 case ISD::TargetExternalSymbol: return "TargetExternalSymbol";189 case ISD::MCSymbol: return "MCSymbol";190 case ISD::TargetBlockAddress: return "TargetBlockAddress";191 192 case ISD::CopyToReg: return "CopyToReg";193 case ISD::CopyFromReg: return "CopyFromReg";194 case ISD::UNDEF: return "undef";195 case ISD::POISON: return "poison";196 case ISD::VSCALE: return "vscale";197 case ISD::MERGE_VALUES: return "merge_values";198 case ISD::INLINEASM: return "inlineasm";199 case ISD::INLINEASM_BR: return "inlineasm_br";200 case ISD::EH_LABEL: return "eh_label";201 case ISD::ANNOTATION_LABEL: return "annotation_label";202 case ISD::HANDLENODE: return "handlenode";203 204 // Unary operators205 case ISD::FABS: return "fabs";206 case ISD::FMINNUM: return "fminnum";207 case ISD::STRICT_FMINNUM: return "strict_fminnum";208 case ISD::FMAXNUM: return "fmaxnum";209 case ISD::STRICT_FMAXNUM: return "strict_fmaxnum";210 case ISD::FMINNUM_IEEE: return "fminnum_ieee";211 case ISD::FMAXNUM_IEEE: return "fmaxnum_ieee";212 case ISD::FMINIMUM: return "fminimum";213 case ISD::STRICT_FMINIMUM: return "strict_fminimum";214 case ISD::FMAXIMUM: return "fmaximum";215 case ISD::STRICT_FMAXIMUM: return "strict_fmaximum";216 case ISD::FMINIMUMNUM: return "fminimumnum";217 case ISD::FMAXIMUMNUM: return "fmaximumnum";218 case ISD::FNEG: return "fneg";219 case ISD::FSQRT: return "fsqrt";220 case ISD::STRICT_FSQRT: return "strict_fsqrt";221 case ISD::FCBRT: return "fcbrt";222 case ISD::FSIN: return "fsin";223 case ISD::STRICT_FSIN: return "strict_fsin";224 case ISD::FCOS: return "fcos";225 case ISD::STRICT_FCOS: return "strict_fcos";226 case ISD::FSINCOS: return "fsincos";227 case ISD::FSINCOSPI: return "fsincospi";228 case ISD::FMODF: return "fmodf";229 case ISD::FTAN: return "ftan";230 case ISD::STRICT_FTAN: return "strict_ftan";231 case ISD::FASIN: return "fasin";232 case ISD::STRICT_FASIN: return "strict_fasin";233 case ISD::FACOS: return "facos";234 case ISD::STRICT_FACOS: return "strict_facos";235 case ISD::FATAN: return "fatan";236 case ISD::STRICT_FATAN: return "strict_fatan";237 case ISD::FATAN2: return "fatan2";238 case ISD::STRICT_FATAN2: return "strict_fatan2";239 case ISD::FSINH: return "fsinh";240 case ISD::STRICT_FSINH: return "strict_fsinh";241 case ISD::FCOSH: return "fcosh";242 case ISD::STRICT_FCOSH: return "strict_fcosh";243 case ISD::FTANH: return "ftanh";244 case ISD::STRICT_FTANH: return "strict_ftanh";245 case ISD::FTRUNC: return "ftrunc";246 case ISD::STRICT_FTRUNC: return "strict_ftrunc";247 case ISD::FFLOOR: return "ffloor";248 case ISD::STRICT_FFLOOR: return "strict_ffloor";249 case ISD::FCEIL: return "fceil";250 case ISD::STRICT_FCEIL: return "strict_fceil";251 case ISD::FRINT: return "frint";252 case ISD::STRICT_FRINT: return "strict_frint";253 case ISD::FNEARBYINT: return "fnearbyint";254 case ISD::STRICT_FNEARBYINT: return "strict_fnearbyint";255 case ISD::FROUND: return "fround";256 case ISD::STRICT_FROUND: return "strict_fround";257 case ISD::FROUNDEVEN: return "froundeven";258 case ISD::STRICT_FROUNDEVEN: return "strict_froundeven";259 case ISD::FEXP: return "fexp";260 case ISD::STRICT_FEXP: return "strict_fexp";261 case ISD::FEXP2: return "fexp2";262 case ISD::STRICT_FEXP2: return "strict_fexp2";263 case ISD::FEXP10: return "fexp10";264 case ISD::FLOG: return "flog";265 case ISD::STRICT_FLOG: return "strict_flog";266 case ISD::FLOG2: return "flog2";267 case ISD::STRICT_FLOG2: return "strict_flog2";268 case ISD::FLOG10: return "flog10";269 case ISD::STRICT_FLOG10: return "strict_flog10";270 271 // Binary operators272 case ISD::ADD: return "add";273 case ISD::PTRADD: return "ptradd";274 case ISD::SUB: return "sub";275 case ISD::MUL: return "mul";276 case ISD::MULHU: return "mulhu";277 case ISD::MULHS: return "mulhs";278 case ISD::AVGFLOORU: return "avgflooru";279 case ISD::AVGFLOORS: return "avgfloors";280 case ISD::AVGCEILU: return "avgceilu";281 case ISD::AVGCEILS: return "avgceils";282 case ISD::ABDS: return "abds";283 case ISD::ABDU: return "abdu";284 case ISD::SDIV: return "sdiv";285 case ISD::UDIV: return "udiv";286 case ISD::SREM: return "srem";287 case ISD::UREM: return "urem";288 case ISD::SMUL_LOHI: return "smul_lohi";289 case ISD::UMUL_LOHI: return "umul_lohi";290 case ISD::SDIVREM: return "sdivrem";291 case ISD::UDIVREM: return "udivrem";292 case ISD::AND: return "and";293 case ISD::OR: return "or";294 case ISD::XOR: return "xor";295 case ISD::SHL: return "shl";296 case ISD::SRA: return "sra";297 case ISD::SRL: return "srl";298 case ISD::ROTL: return "rotl";299 case ISD::ROTR: return "rotr";300 case ISD::FSHL: return "fshl";301 case ISD::FSHR: return "fshr";302 case ISD::FADD: return "fadd";303 case ISD::STRICT_FADD: return "strict_fadd";304 case ISD::FSUB: return "fsub";305 case ISD::STRICT_FSUB: return "strict_fsub";306 case ISD::FMUL: return "fmul";307 case ISD::STRICT_FMUL: return "strict_fmul";308 case ISD::FDIV: return "fdiv";309 case ISD::STRICT_FDIV: return "strict_fdiv";310 case ISD::FMA: return "fma";311 case ISD::STRICT_FMA: return "strict_fma";312 case ISD::FMAD: return "fmad";313 case ISD::FMULADD: return "fmuladd";314 case ISD::FREM: return "frem";315 case ISD::STRICT_FREM: return "strict_frem";316 case ISD::FCOPYSIGN: return "fcopysign";317 case ISD::FGETSIGN: return "fgetsign";318 case ISD::FCANONICALIZE: return "fcanonicalize";319 case ISD::IS_FPCLASS: return "is_fpclass";320 case ISD::FPOW: return "fpow";321 case ISD::STRICT_FPOW: return "strict_fpow";322 case ISD::SMIN: return "smin";323 case ISD::SMAX: return "smax";324 case ISD::UMIN: return "umin";325 case ISD::UMAX: return "umax";326 case ISD::SCMP: return "scmp";327 case ISD::UCMP: return "ucmp";328 329 case ISD::FLDEXP: return "fldexp";330 case ISD::STRICT_FLDEXP: return "strict_fldexp";331 case ISD::FFREXP: return "ffrexp";332 case ISD::FPOWI: return "fpowi";333 case ISD::STRICT_FPOWI: return "strict_fpowi";334 case ISD::SETCC: return "setcc";335 case ISD::SETCCCARRY: return "setcccarry";336 case ISD::STRICT_FSETCC: return "strict_fsetcc";337 case ISD::STRICT_FSETCCS: return "strict_fsetccs";338 case ISD::FPTRUNC_ROUND: return "fptrunc_round";339 case ISD::SELECT: return "select";340 case ISD::VSELECT: return "vselect";341 case ISD::SELECT_CC: return "select_cc";342 case ISD::INSERT_VECTOR_ELT: return "insert_vector_elt";343 case ISD::EXTRACT_VECTOR_ELT: return "extract_vector_elt";344 case ISD::CONCAT_VECTORS: return "concat_vectors";345 case ISD::INSERT_SUBVECTOR: return "insert_subvector";346 case ISD::EXTRACT_SUBVECTOR: return "extract_subvector";347 case ISD::VECTOR_DEINTERLEAVE: return "vector_deinterleave";348 case ISD::VECTOR_INTERLEAVE: return "vector_interleave";349 case ISD::SCALAR_TO_VECTOR: return "scalar_to_vector";350 case ISD::VECTOR_SHUFFLE: return "vector_shuffle";351 case ISD::VECTOR_SPLICE: return "vector_splice";352 case ISD::SPLAT_VECTOR: return "splat_vector";353 case ISD::SPLAT_VECTOR_PARTS: return "splat_vector_parts";354 case ISD::VECTOR_REVERSE: return "vector_reverse";355 case ISD::STEP_VECTOR: return "step_vector";356 case ISD::CARRY_FALSE: return "carry_false";357 case ISD::ADDC: return "addc";358 case ISD::ADDE: return "adde";359 case ISD::UADDO_CARRY: return "uaddo_carry";360 case ISD::SADDO_CARRY: return "saddo_carry";361 case ISD::SADDO: return "saddo";362 case ISD::UADDO: return "uaddo";363 case ISD::SSUBO: return "ssubo";364 case ISD::USUBO: return "usubo";365 case ISD::SMULO: return "smulo";366 case ISD::UMULO: return "umulo";367 case ISD::SUBC: return "subc";368 case ISD::SUBE: return "sube";369 case ISD::USUBO_CARRY: return "usubo_carry";370 case ISD::SSUBO_CARRY: return "ssubo_carry";371 case ISD::SHL_PARTS: return "shl_parts";372 case ISD::SRA_PARTS: return "sra_parts";373 case ISD::SRL_PARTS: return "srl_parts";374 375 case ISD::SADDSAT: return "saddsat";376 case ISD::UADDSAT: return "uaddsat";377 case ISD::SSUBSAT: return "ssubsat";378 case ISD::USUBSAT: return "usubsat";379 case ISD::SSHLSAT: return "sshlsat";380 case ISD::USHLSAT: return "ushlsat";381 382 case ISD::SMULFIX: return "smulfix";383 case ISD::SMULFIXSAT: return "smulfixsat";384 case ISD::UMULFIX: return "umulfix";385 case ISD::UMULFIXSAT: return "umulfixsat";386 387 case ISD::SDIVFIX: return "sdivfix";388 case ISD::SDIVFIXSAT: return "sdivfixsat";389 case ISD::UDIVFIX: return "udivfix";390 case ISD::UDIVFIXSAT: return "udivfixsat";391 392 // Conversion operators.393 case ISD::SIGN_EXTEND: return "sign_extend";394 case ISD::ZERO_EXTEND: return "zero_extend";395 case ISD::ANY_EXTEND: return "any_extend";396 case ISD::SIGN_EXTEND_INREG: return "sign_extend_inreg";397 case ISD::ANY_EXTEND_VECTOR_INREG: return "any_extend_vector_inreg";398 case ISD::SIGN_EXTEND_VECTOR_INREG: return "sign_extend_vector_inreg";399 case ISD::ZERO_EXTEND_VECTOR_INREG: return "zero_extend_vector_inreg";400 case ISD::TRUNCATE: return "truncate";401 case ISD::TRUNCATE_SSAT_S: return "truncate_ssat_s";402 case ISD::TRUNCATE_SSAT_U: return "truncate_ssat_u";403 case ISD::TRUNCATE_USAT_U: return "truncate_usat_u";404 case ISD::FP_ROUND: return "fp_round";405 case ISD::STRICT_FP_ROUND: return "strict_fp_round";406 case ISD::FP_EXTEND: return "fp_extend";407 case ISD::STRICT_FP_EXTEND: return "strict_fp_extend";408 409 case ISD::SINT_TO_FP: return "sint_to_fp";410 case ISD::STRICT_SINT_TO_FP: return "strict_sint_to_fp";411 case ISD::UINT_TO_FP: return "uint_to_fp";412 case ISD::STRICT_UINT_TO_FP: return "strict_uint_to_fp";413 case ISD::FP_TO_SINT: return "fp_to_sint";414 case ISD::STRICT_FP_TO_SINT: return "strict_fp_to_sint";415 case ISD::FP_TO_UINT: return "fp_to_uint";416 case ISD::STRICT_FP_TO_UINT: return "strict_fp_to_uint";417 case ISD::FP_TO_SINT_SAT: return "fp_to_sint_sat";418 case ISD::FP_TO_UINT_SAT: return "fp_to_uint_sat";419 case ISD::BITCAST: return "bitcast";420 case ISD::ADDRSPACECAST: return "addrspacecast";421 case ISD::FP16_TO_FP: return "fp16_to_fp";422 case ISD::STRICT_FP16_TO_FP: return "strict_fp16_to_fp";423 case ISD::FP_TO_FP16: return "fp_to_fp16";424 case ISD::STRICT_FP_TO_FP16: return "strict_fp_to_fp16";425 case ISD::BF16_TO_FP: return "bf16_to_fp";426 case ISD::STRICT_BF16_TO_FP: return "strict_bf16_to_fp";427 case ISD::FP_TO_BF16: return "fp_to_bf16";428 case ISD::STRICT_FP_TO_BF16: return "strict_fp_to_bf16";429 case ISD::LROUND: return "lround";430 case ISD::STRICT_LROUND: return "strict_lround";431 case ISD::LLROUND: return "llround";432 case ISD::STRICT_LLROUND: return "strict_llround";433 case ISD::LRINT: return "lrint";434 case ISD::STRICT_LRINT: return "strict_lrint";435 case ISD::LLRINT: return "llrint";436 case ISD::STRICT_LLRINT: return "strict_llrint";437 438 // Control flow instructions439 case ISD::BR: return "br";440 case ISD::BRIND: return "brind";441 case ISD::BR_JT: return "br_jt";442 case ISD::BRCOND: return "brcond";443 case ISD::BR_CC: return "br_cc";444 case ISD::CALLSEQ_START: return "callseq_start";445 case ISD::CALLSEQ_END: return "callseq_end";446 447 // EH instructions448 case ISD::CATCHRET: return "catchret";449 case ISD::CLEANUPRET: return "cleanupret";450 451 // Other operators452 case ISD::LOAD: return "load";453 case ISD::STORE: return "store";454 case ISD::MLOAD: return "masked_load";455 case ISD::MSTORE: return "masked_store";456 case ISD::MGATHER: return "masked_gather";457 case ISD::MSCATTER: return "masked_scatter";458 case ISD::VECTOR_COMPRESS: return "vector_compress";459 case ISD::VAARG: return "vaarg";460 case ISD::VACOPY: return "vacopy";461 case ISD::VAEND: return "vaend";462 case ISD::VASTART: return "vastart";463 case ISD::DYNAMIC_STACKALLOC: return "dynamic_stackalloc";464 case ISD::EXTRACT_ELEMENT: return "extract_element";465 case ISD::BUILD_PAIR: return "build_pair";466 case ISD::STACKSAVE: return "stacksave";467 case ISD::STACKRESTORE: return "stackrestore";468 case ISD::TRAP: return "trap";469 case ISD::DEBUGTRAP: return "debugtrap";470 case ISD::UBSANTRAP: return "ubsantrap";471 case ISD::LIFETIME_START: return "lifetime.start";472 case ISD::LIFETIME_END: return "lifetime.end";473 case ISD::FAKE_USE:474 return "fake_use";475 case ISD::RELOC_NONE:476 return "reloc_none";477 case ISD::PSEUDO_PROBE:478 return "pseudoprobe";479 case ISD::GC_TRANSITION_START: return "gc_transition.start";480 case ISD::GC_TRANSITION_END: return "gc_transition.end";481 case ISD::GET_DYNAMIC_AREA_OFFSET: return "get.dynamic.area.offset";482 case ISD::FREEZE: return "freeze";483 case ISD::PREALLOCATED_SETUP:484 return "call_setup";485 case ISD::PREALLOCATED_ARG:486 return "call_alloc";487 488 // Floating point environment manipulation489 case ISD::GET_ROUNDING: return "get_rounding";490 case ISD::SET_ROUNDING: return "set_rounding";491 case ISD::GET_FPENV: return "get_fpenv";492 case ISD::SET_FPENV: return "set_fpenv";493 case ISD::RESET_FPENV: return "reset_fpenv";494 case ISD::GET_FPENV_MEM: return "get_fpenv_mem";495 case ISD::SET_FPENV_MEM: return "set_fpenv_mem";496 case ISD::GET_FPMODE: return "get_fpmode";497 case ISD::SET_FPMODE: return "set_fpmode";498 case ISD::RESET_FPMODE: return "reset_fpmode";499 500 // Convergence control instructions501 case ISD::CONVERGENCECTRL_ANCHOR: return "convergencectrl_anchor";502 case ISD::CONVERGENCECTRL_ENTRY: return "convergencectrl_entry";503 case ISD::CONVERGENCECTRL_LOOP: return "convergencectrl_loop";504 case ISD::CONVERGENCECTRL_GLUE: return "convergencectrl_glue";505 506 // Bit manipulation507 case ISD::ABS: return "abs";508 case ISD::BITREVERSE: return "bitreverse";509 case ISD::BSWAP: return "bswap";510 case ISD::CTPOP: return "ctpop";511 case ISD::CTTZ: return "cttz";512 case ISD::CTTZ_ZERO_UNDEF: return "cttz_zero_undef";513 case ISD::CTLZ: return "ctlz";514 case ISD::CTLZ_ZERO_UNDEF: return "ctlz_zero_undef";515 case ISD::PARITY: return "parity";516 517 // Trampolines518 case ISD::INIT_TRAMPOLINE: return "init_trampoline";519 case ISD::ADJUST_TRAMPOLINE: return "adjust_trampoline";520 521 // clang-format on522 523 case ISD::CONDCODE:524 switch (cast<CondCodeSDNode>(this)->get()) {525 default: llvm_unreachable("Unknown setcc condition!");526 case ISD::SETOEQ: return "setoeq";527 case ISD::SETOGT: return "setogt";528 case ISD::SETOGE: return "setoge";529 case ISD::SETOLT: return "setolt";530 case ISD::SETOLE: return "setole";531 case ISD::SETONE: return "setone";532 533 case ISD::SETO: return "seto";534 case ISD::SETUO: return "setuo";535 case ISD::SETUEQ: return "setueq";536 case ISD::SETUGT: return "setugt";537 case ISD::SETUGE: return "setuge";538 case ISD::SETULT: return "setult";539 case ISD::SETULE: return "setule";540 case ISD::SETUNE: return "setune";541 542 case ISD::SETEQ: return "seteq";543 case ISD::SETGT: return "setgt";544 case ISD::SETGE: return "setge";545 case ISD::SETLT: return "setlt";546 case ISD::SETLE: return "setle";547 case ISD::SETNE: return "setne";548 549 case ISD::SETTRUE: return "settrue";550 case ISD::SETTRUE2: return "settrue2";551 case ISD::SETFALSE: return "setfalse";552 case ISD::SETFALSE2: return "setfalse2";553 }554 case ISD::VECREDUCE_FADD: return "vecreduce_fadd";555 case ISD::VECREDUCE_SEQ_FADD: return "vecreduce_seq_fadd";556 case ISD::VECREDUCE_FMUL: return "vecreduce_fmul";557 case ISD::VECREDUCE_SEQ_FMUL: return "vecreduce_seq_fmul";558 case ISD::VECREDUCE_ADD: return "vecreduce_add";559 case ISD::VECREDUCE_MUL: return "vecreduce_mul";560 case ISD::VECREDUCE_AND: return "vecreduce_and";561 case ISD::VECREDUCE_OR: return "vecreduce_or";562 case ISD::VECREDUCE_XOR: return "vecreduce_xor";563 case ISD::VECREDUCE_SMAX: return "vecreduce_smax";564 case ISD::VECREDUCE_SMIN: return "vecreduce_smin";565 case ISD::VECREDUCE_UMAX: return "vecreduce_umax";566 case ISD::VECREDUCE_UMIN: return "vecreduce_umin";567 case ISD::VECREDUCE_FMAX: return "vecreduce_fmax";568 case ISD::VECREDUCE_FMIN: return "vecreduce_fmin";569 case ISD::VECREDUCE_FMAXIMUM: return "vecreduce_fmaximum";570 case ISD::VECREDUCE_FMINIMUM: return "vecreduce_fminimum";571 case ISD::STACKMAP:572 return "stackmap";573 case ISD::PATCHPOINT:574 return "patchpoint";575 case ISD::CLEAR_CACHE:576 return "clear_cache";577 578 case ISD::EXPERIMENTAL_VECTOR_HISTOGRAM:579 return "histogram";580 581 case ISD::VECTOR_FIND_LAST_ACTIVE:582 return "find_last_active";583 584 case ISD::GET_ACTIVE_LANE_MASK:585 return "get_active_lane_mask";586 587 case ISD::PARTIAL_REDUCE_UMLA:588 return "partial_reduce_umla";589 case ISD::PARTIAL_REDUCE_SMLA:590 return "partial_reduce_smla";591 case ISD::PARTIAL_REDUCE_SUMLA:592 return "partial_reduce_sumla";593 case ISD::PARTIAL_REDUCE_FMLA:594 return "partial_reduce_fmla";595 case ISD::LOOP_DEPENDENCE_WAR_MASK:596 return "loop_dep_war";597 case ISD::LOOP_DEPENDENCE_RAW_MASK:598 return "loop_dep_raw";599 600 // Vector Predication601#define BEGIN_REGISTER_VP_SDNODE(SDID, LEGALARG, NAME, ...) \602 case ISD::SDID: \603 return #NAME;604#include "llvm/IR/VPIntrinsics.def"605 }606}607 608const char *SDNode::getIndexedModeName(ISD::MemIndexedMode AM) {609 switch (AM) {610 default: return "";611 case ISD::PRE_INC: return "<pre-inc>";612 case ISD::PRE_DEC: return "<pre-dec>";613 case ISD::POST_INC: return "<post-inc>";614 case ISD::POST_DEC: return "<post-dec>";615 }616}617 618static Printable PrintNodeId(const SDNode &Node) {619 return Printable([&Node](raw_ostream &OS) {620#ifndef NDEBUG621 static const raw_ostream::Colors Color[] = {622 raw_ostream::BLACK, raw_ostream::RED, raw_ostream::GREEN,623 raw_ostream::YELLOW, raw_ostream::BLUE, raw_ostream::MAGENTA,624 raw_ostream::CYAN,625 };626 OS.changeColor(Color[Node.PersistentId % std::size(Color)]);627 OS << 't' << Node.PersistentId;628 OS.resetColor();629#else630 OS << (const void*)&Node;631#endif632 });633}634 635// Print the MMO with more information from the SelectionDAG.636static void printMemOperand(raw_ostream &OS, const MachineMemOperand &MMO,637 const MachineFunction *MF, const Module *M,638 const MachineFrameInfo *MFI,639 const TargetInstrInfo *TII, LLVMContext &Ctx) {640 ModuleSlotTracker MST(M);641 if (MF)642 MST.incorporateFunction(MF->getFunction());643 SmallVector<StringRef, 0> SSNs;644 MMO.print(OS, MST, SSNs, Ctx, MFI, TII);645}646 647static void printMemOperand(raw_ostream &OS, const MachineMemOperand &MMO,648 const SelectionDAG *G) {649 if (G) {650 const MachineFunction *MF = &G->getMachineFunction();651 return printMemOperand(OS, MMO, MF, MF->getFunction().getParent(),652 &MF->getFrameInfo(),653 G->getSubtarget().getInstrInfo(), *G->getContext());654 }655 656 LLVMContext Ctx;657 return printMemOperand(OS, MMO, /*MF=*/nullptr, /*M=*/nullptr,658 /*MFI=*/nullptr, /*TII=*/nullptr, Ctx);659}660 661#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)662LLVM_DUMP_METHOD void SDNode::dump() const { dump(nullptr); }663 664LLVM_DUMP_METHOD void SDNode::dump(const SelectionDAG *G) const {665 print(dbgs(), G);666 dbgs() << '\n';667}668#endif669 670void SDNode::print_types(raw_ostream &OS, const SelectionDAG *G) const {671 for (unsigned i = 0, e = getNumValues(); i != e; ++i) {672 if (i) OS << ",";673 if (getValueType(i) == MVT::Other)674 OS << "ch";675 else676 OS << getValueType(i).getEVTString();677 }678}679 680void SDNode::print_details(raw_ostream &OS, const SelectionDAG *G) const {681 if (getFlags().hasNoUnsignedWrap())682 OS << " nuw";683 684 if (getFlags().hasNoSignedWrap())685 OS << " nsw";686 687 if (getFlags().hasExact())688 OS << " exact";689 690 if (getFlags().hasDisjoint())691 OS << " disjoint";692 693 if (getFlags().hasSameSign())694 OS << " samesign";695 696 if (getFlags().hasInBounds())697 OS << " inbounds";698 699 if (getFlags().hasNonNeg())700 OS << " nneg";701 702 if (getFlags().hasNoNaNs())703 OS << " nnan";704 705 if (getFlags().hasNoInfs())706 OS << " ninf";707 708 if (getFlags().hasNoSignedZeros())709 OS << " nsz";710 711 if (getFlags().hasAllowReciprocal())712 OS << " arcp";713 714 if (getFlags().hasAllowContract())715 OS << " contract";716 717 if (getFlags().hasApproximateFuncs())718 OS << " afn";719 720 if (getFlags().hasAllowReassociation())721 OS << " reassoc";722 723 if (getFlags().hasNoFPExcept())724 OS << " nofpexcept";725 726 if (const MachineSDNode *MN = dyn_cast<MachineSDNode>(this)) {727 if (!MN->memoperands_empty()) {728 OS << "<";729 OS << "Mem:";730 for (MachineSDNode::mmo_iterator i = MN->memoperands_begin(),731 e = MN->memoperands_end(); i != e; ++i) {732 printMemOperand(OS, **i, G);733 if (std::next(i) != e)734 OS << " ";735 }736 OS << ">";737 }738 } else if (const ShuffleVectorSDNode *SVN =739 dyn_cast<ShuffleVectorSDNode>(this)) {740 OS << "<";741 for (unsigned i = 0, e = ValueList[0].getVectorNumElements(); i != e; ++i) {742 int Idx = SVN->getMaskElt(i);743 if (i) OS << ",";744 if (Idx < 0)745 OS << "u";746 else747 OS << Idx;748 }749 OS << ">";750 } else if (const ConstantSDNode *CSDN = dyn_cast<ConstantSDNode>(this)) {751 OS << '<' << CSDN->getAPIntValue() << '>';752 } else if (const ConstantFPSDNode *CSDN = dyn_cast<ConstantFPSDNode>(this)) {753 if (&CSDN->getValueAPF().getSemantics() == &APFloat::IEEEsingle())754 OS << '<' << CSDN->getValueAPF().convertToFloat() << '>';755 else if (&CSDN->getValueAPF().getSemantics() == &APFloat::IEEEdouble())756 OS << '<' << CSDN->getValueAPF().convertToDouble() << '>';757 else {758 OS << "<APFloat(";759 CSDN->getValueAPF().bitcastToAPInt().print(OS, false);760 OS << ")>";761 }762 } else if (const GlobalAddressSDNode *GADN =763 dyn_cast<GlobalAddressSDNode>(this)) {764 int64_t offset = GADN->getOffset();765 OS << '<';766 GADN->getGlobal()->printAsOperand(OS);767 OS << '>';768 if (offset > 0)769 OS << " + " << offset;770 else771 OS << " " << offset;772 if (unsigned int TF = GADN->getTargetFlags())773 OS << " [TF=" << TF << ']';774 } else if (const FrameIndexSDNode *FIDN = dyn_cast<FrameIndexSDNode>(this)) {775 OS << "<" << FIDN->getIndex() << ">";776 } else if (const JumpTableSDNode *JTDN = dyn_cast<JumpTableSDNode>(this)) {777 OS << "<" << JTDN->getIndex() << ">";778 if (unsigned int TF = JTDN->getTargetFlags())779 OS << " [TF=" << TF << ']';780 } else if (const ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(this)){781 int offset = CP->getOffset();782 if (CP->isMachineConstantPoolEntry())783 OS << "<" << *CP->getMachineCPVal() << ">";784 else785 OS << "<" << *CP->getConstVal() << ">";786 if (offset > 0)787 OS << " + " << offset;788 else789 OS << " " << offset;790 if (unsigned int TF = CP->getTargetFlags())791 OS << " [TF=" << TF << ']';792 } else if (const TargetIndexSDNode *TI = dyn_cast<TargetIndexSDNode>(this)) {793 OS << "<" << TI->getIndex() << '+' << TI->getOffset() << ">";794 if (unsigned TF = TI->getTargetFlags())795 OS << " [TF=" << TF << ']';796 } else if (const BasicBlockSDNode *BBDN = dyn_cast<BasicBlockSDNode>(this)) {797 OS << "<";798 const Value *LBB = (const Value*)BBDN->getBasicBlock()->getBasicBlock();799 if (LBB)800 OS << LBB->getName() << " ";801 OS << (const void*)BBDN->getBasicBlock() << ">";802 } else if (const RegisterSDNode *R = dyn_cast<RegisterSDNode>(this)) {803 OS << ' ' << printReg(R->getReg(),804 G ? G->getSubtarget().getRegisterInfo() : nullptr);805 } else if (const ExternalSymbolSDNode *ES =806 dyn_cast<ExternalSymbolSDNode>(this)) {807 OS << "'" << ES->getSymbol() << "'";808 if (unsigned int TF = ES->getTargetFlags())809 OS << " [TF=" << TF << ']';810 } else if (const SrcValueSDNode *M = dyn_cast<SrcValueSDNode>(this)) {811 if (M->getValue())812 OS << "<" << M->getValue() << ">";813 else814 OS << "<null>";815 } else if (const MDNodeSDNode *MD = dyn_cast<MDNodeSDNode>(this)) {816 if (MD->getMD())817 OS << "<" << MD->getMD() << ">";818 else819 OS << "<null>";820 } else if (const VTSDNode *N = dyn_cast<VTSDNode>(this)) {821 OS << ":" << N->getVT();822 }823 else if (const LoadSDNode *LD = dyn_cast<LoadSDNode>(this)) {824 OS << "<";825 826 printMemOperand(OS, *LD->getMemOperand(), G);827 828 bool doExt = true;829 switch (LD->getExtensionType()) {830 default: doExt = false; break;831 case ISD::EXTLOAD: OS << ", anyext"; break;832 case ISD::SEXTLOAD: OS << ", sext"; break;833 case ISD::ZEXTLOAD: OS << ", zext"; break;834 }835 if (doExt)836 OS << " from " << LD->getMemoryVT();837 838 const char *AM = getIndexedModeName(LD->getAddressingMode());839 if (*AM)840 OS << ", " << AM;841 842 OS << ">";843 } else if (const StoreSDNode *ST = dyn_cast<StoreSDNode>(this)) {844 OS << "<";845 printMemOperand(OS, *ST->getMemOperand(), G);846 847 if (ST->isTruncatingStore())848 OS << ", trunc to " << ST->getMemoryVT();849 850 const char *AM = getIndexedModeName(ST->getAddressingMode());851 if (*AM)852 OS << ", " << AM;853 854 OS << ">";855 } else if (const MaskedLoadSDNode *MLd = dyn_cast<MaskedLoadSDNode>(this)) {856 OS << "<";857 858 printMemOperand(OS, *MLd->getMemOperand(), G);859 860 bool doExt = true;861 switch (MLd->getExtensionType()) {862 default: doExt = false; break;863 case ISD::EXTLOAD: OS << ", anyext"; break;864 case ISD::SEXTLOAD: OS << ", sext"; break;865 case ISD::ZEXTLOAD: OS << ", zext"; break;866 }867 if (doExt)868 OS << " from " << MLd->getMemoryVT();869 870 const char *AM = getIndexedModeName(MLd->getAddressingMode());871 if (*AM)872 OS << ", " << AM;873 874 if (MLd->isExpandingLoad())875 OS << ", expanding";876 877 OS << ">";878 } else if (const MaskedStoreSDNode *MSt = dyn_cast<MaskedStoreSDNode>(this)) {879 OS << "<";880 printMemOperand(OS, *MSt->getMemOperand(), G);881 882 if (MSt->isTruncatingStore())883 OS << ", trunc to " << MSt->getMemoryVT();884 885 const char *AM = getIndexedModeName(MSt->getAddressingMode());886 if (*AM)887 OS << ", " << AM;888 889 if (MSt->isCompressingStore())890 OS << ", compressing";891 892 OS << ">";893 } else if (const auto *MGather = dyn_cast<MaskedGatherSDNode>(this)) {894 OS << "<";895 printMemOperand(OS, *MGather->getMemOperand(), G);896 897 bool doExt = true;898 switch (MGather->getExtensionType()) {899 default: doExt = false; break;900 case ISD::EXTLOAD: OS << ", anyext"; break;901 case ISD::SEXTLOAD: OS << ", sext"; break;902 case ISD::ZEXTLOAD: OS << ", zext"; break;903 }904 if (doExt)905 OS << " from " << MGather->getMemoryVT();906 907 auto Signed = MGather->isIndexSigned() ? "signed" : "unsigned";908 auto Scaled = MGather->isIndexScaled() ? "scaled" : "unscaled";909 OS << ", " << Signed << " " << Scaled << " offset";910 911 OS << ">";912 } else if (const auto *MScatter = dyn_cast<MaskedScatterSDNode>(this)) {913 OS << "<";914 printMemOperand(OS, *MScatter->getMemOperand(), G);915 916 if (MScatter->isTruncatingStore())917 OS << ", trunc to " << MScatter->getMemoryVT();918 919 auto Signed = MScatter->isIndexSigned() ? "signed" : "unsigned";920 auto Scaled = MScatter->isIndexScaled() ? "scaled" : "unscaled";921 OS << ", " << Signed << " " << Scaled << " offset";922 923 OS << ">";924 } else if (const MemSDNode *M = dyn_cast<MemSDNode>(this)) {925 OS << "<";926 printMemOperand(OS, *M->getMemOperand(), G);927 if (auto *A = dyn_cast<AtomicSDNode>(M))928 if (A->getOpcode() == ISD::ATOMIC_LOAD) {929 bool doExt = true;930 switch (A->getExtensionType()) {931 default: doExt = false; break;932 case ISD::EXTLOAD: OS << ", anyext"; break;933 case ISD::SEXTLOAD: OS << ", sext"; break;934 case ISD::ZEXTLOAD: OS << ", zext"; break;935 }936 if (doExt)937 OS << " from " << A->getMemoryVT();938 }939 OS << ">";940 } else if (const BlockAddressSDNode *BA =941 dyn_cast<BlockAddressSDNode>(this)) {942 int64_t offset = BA->getOffset();943 OS << "<";944 BA->getBlockAddress()->getFunction()->printAsOperand(OS, false);945 OS << ", ";946 BA->getBlockAddress()->getBasicBlock()->printAsOperand(OS, false);947 OS << ">";948 if (offset > 0)949 OS << " + " << offset;950 else951 OS << " " << offset;952 if (unsigned int TF = BA->getTargetFlags())953 OS << " [TF=" << TF << ']';954 } else if (const AddrSpaceCastSDNode *ASC =955 dyn_cast<AddrSpaceCastSDNode>(this)) {956 OS << '['957 << ASC->getSrcAddressSpace()958 << " -> "959 << ASC->getDestAddressSpace()960 << ']';961 } else if (const auto *AA = dyn_cast<AssertAlignSDNode>(this)) {962 OS << '<' << AA->getAlign().value() << '>';963 }964 965 if (VerboseDAGDumping) {966 if (unsigned Order = getIROrder())967 OS << " [ORD=" << Order << ']';968 969 if (getNodeId() != -1)970 OS << " [ID=" << getNodeId() << ']';971 if (!(isa<ConstantSDNode>(this) || (isa<ConstantFPSDNode>(this))))972 OS << " # D:" << isDivergent();973 974 if (G && !G->GetDbgValues(this).empty()) {975 OS << " [NoOfDbgValues=" << G->GetDbgValues(this).size() << ']';976 for (SDDbgValue *Dbg : G->GetDbgValues(this))977 if (!Dbg->isInvalidated())978 Dbg->print(OS);979 } else if (getHasDebugValue())980 OS << " [NoOfDbgValues>0]";981 982 if (const auto *MD = G ? G->getPCSections(this) : nullptr) {983 OS << " [pcsections ";984 MD->printAsOperand(OS, G->getMachineFunction().getFunction().getParent());985 OS << ']';986 }987 988 if (MDNode *MMRA = G ? G->getMMRAMetadata(this) : nullptr) {989 OS << " [mmra ";990 MMRA->printAsOperand(OS,991 G->getMachineFunction().getFunction().getParent());992 OS << ']';993 }994 }995}996 997LLVM_DUMP_METHOD void SDDbgValue::print(raw_ostream &OS) const {998 OS << " DbgVal(Order=" << getOrder() << ')';999 if (isInvalidated())1000 OS << "(Invalidated)";1001 if (isEmitted())1002 OS << "(Emitted)";1003 OS << "(";1004 bool Comma = false;1005 for (const SDDbgOperand &Op : getLocationOps()) {1006 if (Comma)1007 OS << ", ";1008 switch (Op.getKind()) {1009 case SDDbgOperand::SDNODE:1010 if (Op.getSDNode())1011 OS << "SDNODE=" << PrintNodeId(*Op.getSDNode()) << ':' << Op.getResNo();1012 else1013 OS << "SDNODE";1014 break;1015 case SDDbgOperand::CONST:1016 OS << "CONST";1017 break;1018 case SDDbgOperand::FRAMEIX:1019 OS << "FRAMEIX=" << Op.getFrameIx();1020 break;1021 case SDDbgOperand::VREG:1022 OS << "VREG=" << printReg(Op.getVReg());1023 break;1024 }1025 Comma = true;1026 }1027 OS << ")";1028 if (isIndirect()) OS << "(Indirect)";1029 if (isVariadic())1030 OS << "(Variadic)";1031 OS << ":\"" << Var->getName() << '"';1032#ifndef NDEBUG1033 if (Expr->getNumElements())1034 Expr->dump();1035#endif1036}1037 1038#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)1039LLVM_DUMP_METHOD void SDDbgValue::dump() const {1040 if (isInvalidated())1041 return;1042 print(dbgs());1043 dbgs() << "\n";1044}1045#endif1046 1047/// Return true if this node is so simple that we should just print it inline1048/// if it appears as an operand.1049static bool shouldPrintInline(const SDNode &Node, const SelectionDAG *G) {1050 // Avoid lots of cluttering when inline printing nodes with associated1051 // DbgValues in verbose mode.1052 if (VerboseDAGDumping && G && !G->GetDbgValues(&Node).empty())1053 return false;1054 if (Node.getOpcode() == ISD::EntryToken)1055 return false;1056 return Node.getNumOperands() == 0;1057}1058 1059#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)1060static void DumpNodes(const SDNode *N, unsigned indent, const SelectionDAG *G) {1061 for (const SDValue &Op : N->op_values()) {1062 if (shouldPrintInline(*Op.getNode(), G))1063 continue;1064 if (Op.getNode()->hasOneUse())1065 DumpNodes(Op.getNode(), indent+2, G);1066 }1067 1068 dbgs().indent(indent);1069 N->dump(G);1070}1071 1072LLVM_DUMP_METHOD void SelectionDAG::dump(bool Sorted) const {1073 dbgs() << "SelectionDAG has " << AllNodes.size() << " nodes:\n";1074 1075 auto dumpEachNode = [this](const SDNode &N) {1076 if (!N.hasOneUse() && &N != getRoot().getNode() &&1077 (!shouldPrintInline(N, this) || N.use_empty()))1078 DumpNodes(&N, 2, this);1079 };1080 1081 if (Sorted) {1082 SmallVector<const SDNode *> SortedNodes;1083 SortedNodes.reserve(AllNodes.size());1084 getTopologicallyOrderedNodes(SortedNodes);1085 for (const SDNode *N : SortedNodes)1086 dumpEachNode(*N);1087 } else {1088 for (const SDNode &N : allnodes())1089 dumpEachNode(N);1090 }1091 1092 if (getRoot().getNode()) DumpNodes(getRoot().getNode(), 2, this);1093 dbgs() << "\n";1094 1095 if (VerboseDAGDumping) {1096 if (DbgBegin() != DbgEnd())1097 dbgs() << "SDDbgValues:\n";1098 for (auto *Dbg : make_range(DbgBegin(), DbgEnd()))1099 Dbg->dump();1100 if (ByvalParmDbgBegin() != ByvalParmDbgEnd())1101 dbgs() << "Byval SDDbgValues:\n";1102 for (auto *Dbg : make_range(ByvalParmDbgBegin(), ByvalParmDbgEnd()))1103 Dbg->dump();1104 }1105 dbgs() << "\n";1106}1107#endif1108 1109void SDNode::printr(raw_ostream &OS, const SelectionDAG *G) const {1110 OS << PrintNodeId(*this) << ": ";1111 print_types(OS, G);1112 OS << " = " << getOperationName(G);1113 print_details(OS, G);1114}1115 1116static bool printOperand(raw_ostream &OS, const SelectionDAG *G,1117 const SDValue Value) {1118 if (!Value.getNode()) {1119 OS << "<null>";1120 return false;1121 }1122 1123 if (shouldPrintInline(*Value.getNode(), G)) {1124 OS << Value->getOperationName(G) << ':';1125 Value->print_types(OS, G);1126 Value->print_details(OS, G);1127 return true;1128 }1129 1130 OS << PrintNodeId(*Value.getNode());1131 if (unsigned RN = Value.getResNo())1132 OS << ':' << RN;1133 return false;1134}1135 1136#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)1137using VisitedSDNodeSet = SmallPtrSet<const SDNode *, 32>;1138 1139static void DumpNodesr(raw_ostream &OS, const SDNode *N, unsigned indent,1140 const SelectionDAG *G, VisitedSDNodeSet &once) {1141 if (!once.insert(N).second) // If we've been here before, return now.1142 return;1143 1144 // Dump the current SDNode, but don't end the line yet.1145 OS.indent(indent);1146 N->printr(OS, G);1147 1148 // Having printed this SDNode, walk the children:1149 for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {1150 if (i) OS << ",";1151 OS << " ";1152 1153 const SDValue Op = N->getOperand(i);1154 bool printedInline = printOperand(OS, G, Op);1155 if (printedInline)1156 once.insert(Op.getNode());1157 }1158 1159 OS << "\n";1160 1161 // Dump children that have grandchildren on their own line(s).1162 for (const SDValue &Op : N->op_values())1163 DumpNodesr(OS, Op.getNode(), indent+2, G, once);1164}1165 1166LLVM_DUMP_METHOD void SDNode::dumpr() const {1167 VisitedSDNodeSet once;1168 DumpNodesr(dbgs(), this, 0, nullptr, once);1169}1170 1171LLVM_DUMP_METHOD void SDNode::dumpr(const SelectionDAG *G) const {1172 VisitedSDNodeSet once;1173 DumpNodesr(dbgs(), this, 0, G, once);1174}1175#endif1176 1177static void printrWithDepthHelper(raw_ostream &OS, const SDNode *N,1178 const SelectionDAG *G, unsigned depth,1179 unsigned indent) {1180 if (depth == 0)1181 return;1182 1183 OS.indent(indent);1184 1185 N->print(OS, G);1186 1187 for (const SDValue &Op : N->op_values()) {1188 // Don't follow chain operands.1189 if (Op.getValueType() == MVT::Other)1190 continue;1191 // Don't print children that were fully rendered inline.1192 if (shouldPrintInline(*Op.getNode(), G))1193 continue;1194 OS << '\n';1195 printrWithDepthHelper(OS, Op.getNode(), G, depth - 1, indent + 2);1196 }1197}1198 1199void SDNode::printrWithDepth(raw_ostream &OS, const SelectionDAG *G,1200 unsigned depth) const {1201 printrWithDepthHelper(OS, this, G, depth, 0);1202}1203 1204void SDNode::printrFull(raw_ostream &OS, const SelectionDAG *G) const {1205 // Don't print impossibly deep things.1206 printrWithDepth(OS, G, 10);1207}1208 1209#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)1210LLVM_DUMP_METHOD1211void SDNode::dumprWithDepth(const SelectionDAG *G, unsigned depth) const {1212 printrWithDepth(dbgs(), G, depth);1213}1214 1215LLVM_DUMP_METHOD void SDNode::dumprFull(const SelectionDAG *G) const {1216 // Don't print impossibly deep things.1217 dumprWithDepth(G, 10);1218}1219#endif1220 1221void SDNode::print(raw_ostream &OS, const SelectionDAG *G) const {1222 printr(OS, G);1223 // Under VerboseDAGDumping divergence will be printed always.1224 if (isDivergent() && !VerboseDAGDumping)1225 OS << " # D:1";1226 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {1227 if (i) OS << ", "; else OS << " ";1228 printOperand(OS, G, getOperand(i));1229 }1230 if (DebugLoc DL = getDebugLoc()) {1231 OS << ", ";1232 DL.print(OS);1233 }1234}1235