LLVM  3.7.0
SelectionDAGDumper.cpp
Go to the documentation of this file.
1 //===-- SelectionDAGDumper.cpp - Implement SelectionDAG::dump() -----------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This implements the SelectionDAG::dump method and friends.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "ScheduleDAGSDNodes.h"
16 #include "llvm/ADT/StringExtras.h"
20 #include "llvm/IR/DebugInfo.h"
21 #include "llvm/IR/Function.h"
22 #include "llvm/IR/Intrinsics.h"
23 #include "llvm/Support/Debug.h"
31 using namespace llvm;
32 
33 std::string SDNode::getOperationName(const SelectionDAG *G) const {
34  switch (getOpcode()) {
35  default:
37  return "<<Unknown DAG Node>>";
38  if (isMachineOpcode()) {
39  if (G)
40  if (const TargetInstrInfo *TII = G->getSubtarget().getInstrInfo())
41  if (getMachineOpcode() < TII->getNumOpcodes())
42  return TII->getName(getMachineOpcode());
43  return "<<Unknown Machine Node #" + utostr(getOpcode()) + ">>";
44  }
45  if (G) {
46  const TargetLowering &TLI = G->getTargetLoweringInfo();
47  const char *Name = TLI.getTargetNodeName(getOpcode());
48  if (Name) return Name;
49  return "<<Unknown Target Node #" + utostr(getOpcode()) + ">>";
50  }
51  return "<<Unknown Node #" + utostr(getOpcode()) + ">>";
52 
53 #ifndef NDEBUG
54  case ISD::DELETED_NODE: return "<<Deleted Node!>>";
55 #endif
56  case ISD::PREFETCH: return "Prefetch";
57  case ISD::ATOMIC_FENCE: return "AtomicFence";
58  case ISD::ATOMIC_CMP_SWAP: return "AtomicCmpSwap";
59  case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS: return "AtomicCmpSwapWithSuccess";
60  case ISD::ATOMIC_SWAP: return "AtomicSwap";
61  case ISD::ATOMIC_LOAD_ADD: return "AtomicLoadAdd";
62  case ISD::ATOMIC_LOAD_SUB: return "AtomicLoadSub";
63  case ISD::ATOMIC_LOAD_AND: return "AtomicLoadAnd";
64  case ISD::ATOMIC_LOAD_OR: return "AtomicLoadOr";
65  case ISD::ATOMIC_LOAD_XOR: return "AtomicLoadXor";
66  case ISD::ATOMIC_LOAD_NAND: return "AtomicLoadNand";
67  case ISD::ATOMIC_LOAD_MIN: return "AtomicLoadMin";
68  case ISD::ATOMIC_LOAD_MAX: return "AtomicLoadMax";
69  case ISD::ATOMIC_LOAD_UMIN: return "AtomicLoadUMin";
70  case ISD::ATOMIC_LOAD_UMAX: return "AtomicLoadUMax";
71  case ISD::ATOMIC_LOAD: return "AtomicLoad";
72  case ISD::ATOMIC_STORE: return "AtomicStore";
73  case ISD::PCMARKER: return "PCMarker";
74  case ISD::READCYCLECOUNTER: return "ReadCycleCounter";
75  case ISD::SRCVALUE: return "SrcValue";
76  case ISD::MDNODE_SDNODE: return "MDNode";
77  case ISD::EntryToken: return "EntryToken";
78  case ISD::TokenFactor: return "TokenFactor";
79  case ISD::AssertSext: return "AssertSext";
80  case ISD::AssertZext: return "AssertZext";
81 
82  case ISD::BasicBlock: return "BasicBlock";
83  case ISD::VALUETYPE: return "ValueType";
84  case ISD::Register: return "Register";
85  case ISD::RegisterMask: return "RegisterMask";
86  case ISD::Constant:
87  if (cast<ConstantSDNode>(this)->isOpaque())
88  return "OpaqueConstant";
89  return "Constant";
90  case ISD::ConstantFP: return "ConstantFP";
91  case ISD::GlobalAddress: return "GlobalAddress";
92  case ISD::GlobalTLSAddress: return "GlobalTLSAddress";
93  case ISD::FrameIndex: return "FrameIndex";
94  case ISD::JumpTable: return "JumpTable";
95  case ISD::GLOBAL_OFFSET_TABLE: return "GLOBAL_OFFSET_TABLE";
96  case ISD::RETURNADDR: return "RETURNADDR";
97  case ISD::FRAMEADDR: return "FRAMEADDR";
98  case ISD::LOCAL_RECOVER: return "LOCAL_RECOVER";
99  case ISD::READ_REGISTER: return "READ_REGISTER";
100  case ISD::WRITE_REGISTER: return "WRITE_REGISTER";
101  case ISD::FRAME_TO_ARGS_OFFSET: return "FRAME_TO_ARGS_OFFSET";
102  case ISD::EH_RETURN: return "EH_RETURN";
103  case ISD::EH_SJLJ_SETJMP: return "EH_SJLJ_SETJMP";
104  case ISD::EH_SJLJ_LONGJMP: return "EH_SJLJ_LONGJMP";
105  case ISD::ConstantPool: return "ConstantPool";
106  case ISD::TargetIndex: return "TargetIndex";
107  case ISD::ExternalSymbol: return "ExternalSymbol";
108  case ISD::BlockAddress: return "BlockAddress";
110  case ISD::INTRINSIC_VOID:
111  case ISD::INTRINSIC_W_CHAIN: {
112  unsigned OpNo = getOpcode() == ISD::INTRINSIC_WO_CHAIN ? 0 : 1;
113  unsigned IID = cast<ConstantSDNode>(getOperand(OpNo))->getZExtValue();
114  if (IID < Intrinsic::num_intrinsics)
115  return Intrinsic::getName((Intrinsic::ID)IID);
116  else if (const TargetIntrinsicInfo *TII = G->getTarget().getIntrinsicInfo())
117  return TII->getName(IID);
118  llvm_unreachable("Invalid intrinsic ID");
119  }
120 
121  case ISD::BUILD_VECTOR: return "BUILD_VECTOR";
122  case ISD::TargetConstant:
123  if (cast<ConstantSDNode>(this)->isOpaque())
124  return "OpaqueTargetConstant";
125  return "TargetConstant";
126  case ISD::TargetConstantFP: return "TargetConstantFP";
127  case ISD::TargetGlobalAddress: return "TargetGlobalAddress";
128  case ISD::TargetGlobalTLSAddress: return "TargetGlobalTLSAddress";
129  case ISD::TargetFrameIndex: return "TargetFrameIndex";
130  case ISD::TargetJumpTable: return "TargetJumpTable";
131  case ISD::TargetConstantPool: return "TargetConstantPool";
132  case ISD::TargetExternalSymbol: return "TargetExternalSymbol";
133  case ISD::MCSymbol: return "MCSymbol";
134  case ISD::TargetBlockAddress: return "TargetBlockAddress";
135 
136  case ISD::CopyToReg: return "CopyToReg";
137  case ISD::CopyFromReg: return "CopyFromReg";
138  case ISD::UNDEF: return "undef";
139  case ISD::MERGE_VALUES: return "merge_values";
140  case ISD::INLINEASM: return "inlineasm";
141  case ISD::EH_LABEL: return "eh_label";
142  case ISD::HANDLENODE: return "handlenode";
143 
144  // Unary operators
145  case ISD::FABS: return "fabs";
146  case ISD::FMINNUM: return "fminnum";
147  case ISD::FMAXNUM: return "fmaxnum";
148  case ISD::FNEG: return "fneg";
149  case ISD::FSQRT: return "fsqrt";
150  case ISD::FSIN: return "fsin";
151  case ISD::FCOS: return "fcos";
152  case ISD::FSINCOS: return "fsincos";
153  case ISD::FTRUNC: return "ftrunc";
154  case ISD::FFLOOR: return "ffloor";
155  case ISD::FCEIL: return "fceil";
156  case ISD::FRINT: return "frint";
157  case ISD::FNEARBYINT: return "fnearbyint";
158  case ISD::FROUND: return "fround";
159  case ISD::FEXP: return "fexp";
160  case ISD::FEXP2: return "fexp2";
161  case ISD::FLOG: return "flog";
162  case ISD::FLOG2: return "flog2";
163  case ISD::FLOG10: return "flog10";
164 
165  // Binary operators
166  case ISD::ADD: return "add";
167  case ISD::SUB: return "sub";
168  case ISD::MUL: return "mul";
169  case ISD::MULHU: return "mulhu";
170  case ISD::MULHS: return "mulhs";
171  case ISD::SDIV: return "sdiv";
172  case ISD::UDIV: return "udiv";
173  case ISD::SREM: return "srem";
174  case ISD::UREM: return "urem";
175  case ISD::SMUL_LOHI: return "smul_lohi";
176  case ISD::UMUL_LOHI: return "umul_lohi";
177  case ISD::SDIVREM: return "sdivrem";
178  case ISD::UDIVREM: return "udivrem";
179  case ISD::AND: return "and";
180  case ISD::OR: return "or";
181  case ISD::XOR: return "xor";
182  case ISD::SHL: return "shl";
183  case ISD::SRA: return "sra";
184  case ISD::SRL: return "srl";
185  case ISD::ROTL: return "rotl";
186  case ISD::ROTR: return "rotr";
187  case ISD::FADD: return "fadd";
188  case ISD::FSUB: return "fsub";
189  case ISD::FMUL: return "fmul";
190  case ISD::FDIV: return "fdiv";
191  case ISD::FMA: return "fma";
192  case ISD::FMAD: return "fmad";
193  case ISD::FREM: return "frem";
194  case ISD::FCOPYSIGN: return "fcopysign";
195  case ISD::FGETSIGN: return "fgetsign";
196  case ISD::FPOW: return "fpow";
197  case ISD::SMIN: return "smin";
198  case ISD::SMAX: return "smax";
199  case ISD::UMIN: return "umin";
200  case ISD::UMAX: return "umax";
201 
202  case ISD::FPOWI: return "fpowi";
203  case ISD::SETCC: return "setcc";
204  case ISD::SELECT: return "select";
205  case ISD::VSELECT: return "vselect";
206  case ISD::SELECT_CC: return "select_cc";
207  case ISD::INSERT_VECTOR_ELT: return "insert_vector_elt";
208  case ISD::EXTRACT_VECTOR_ELT: return "extract_vector_elt";
209  case ISD::CONCAT_VECTORS: return "concat_vectors";
210  case ISD::INSERT_SUBVECTOR: return "insert_subvector";
211  case ISD::EXTRACT_SUBVECTOR: return "extract_subvector";
212  case ISD::SCALAR_TO_VECTOR: return "scalar_to_vector";
213  case ISD::VECTOR_SHUFFLE: return "vector_shuffle";
214  case ISD::CARRY_FALSE: return "carry_false";
215  case ISD::ADDC: return "addc";
216  case ISD::ADDE: return "adde";
217  case ISD::SADDO: return "saddo";
218  case ISD::UADDO: return "uaddo";
219  case ISD::SSUBO: return "ssubo";
220  case ISD::USUBO: return "usubo";
221  case ISD::SMULO: return "smulo";
222  case ISD::UMULO: return "umulo";
223  case ISD::SUBC: return "subc";
224  case ISD::SUBE: return "sube";
225  case ISD::SHL_PARTS: return "shl_parts";
226  case ISD::SRA_PARTS: return "sra_parts";
227  case ISD::SRL_PARTS: return "srl_parts";
228 
229  // Conversion operators.
230  case ISD::SIGN_EXTEND: return "sign_extend";
231  case ISD::ZERO_EXTEND: return "zero_extend";
232  case ISD::ANY_EXTEND: return "any_extend";
233  case ISD::SIGN_EXTEND_INREG: return "sign_extend_inreg";
234  case ISD::ANY_EXTEND_VECTOR_INREG: return "any_extend_vector_inreg";
235  case ISD::SIGN_EXTEND_VECTOR_INREG: return "sign_extend_vector_inreg";
236  case ISD::ZERO_EXTEND_VECTOR_INREG: return "zero_extend_vector_inreg";
237  case ISD::TRUNCATE: return "truncate";
238  case ISD::FP_ROUND: return "fp_round";
239  case ISD::FLT_ROUNDS_: return "flt_rounds";
240  case ISD::FP_ROUND_INREG: return "fp_round_inreg";
241  case ISD::FP_EXTEND: return "fp_extend";
242 
243  case ISD::SINT_TO_FP: return "sint_to_fp";
244  case ISD::UINT_TO_FP: return "uint_to_fp";
245  case ISD::FP_TO_SINT: return "fp_to_sint";
246  case ISD::FP_TO_UINT: return "fp_to_uint";
247  case ISD::BITCAST: return "bitcast";
248  case ISD::ADDRSPACECAST: return "addrspacecast";
249  case ISD::FP16_TO_FP: return "fp16_to_fp";
250  case ISD::FP_TO_FP16: return "fp_to_fp16";
251 
252  case ISD::CONVERT_RNDSAT: {
253  switch (cast<CvtRndSatSDNode>(this)->getCvtCode()) {
254  default: llvm_unreachable("Unknown cvt code!");
255  case ISD::CVT_FF: return "cvt_ff";
256  case ISD::CVT_FS: return "cvt_fs";
257  case ISD::CVT_FU: return "cvt_fu";
258  case ISD::CVT_SF: return "cvt_sf";
259  case ISD::CVT_UF: return "cvt_uf";
260  case ISD::CVT_SS: return "cvt_ss";
261  case ISD::CVT_SU: return "cvt_su";
262  case ISD::CVT_US: return "cvt_us";
263  case ISD::CVT_UU: return "cvt_uu";
264  }
265  }
266 
267  // Control flow instructions
268  case ISD::BR: return "br";
269  case ISD::BRIND: return "brind";
270  case ISD::BR_JT: return "br_jt";
271  case ISD::BRCOND: return "brcond";
272  case ISD::BR_CC: return "br_cc";
273  case ISD::CALLSEQ_START: return "callseq_start";
274  case ISD::CALLSEQ_END: return "callseq_end";
275 
276  // Other operators
277  case ISD::LOAD: return "load";
278  case ISD::STORE: return "store";
279  case ISD::MLOAD: return "masked_load";
280  case ISD::MSTORE: return "masked_store";
281  case ISD::MGATHER: return "masked_gather";
282  case ISD::MSCATTER: return "masked_scatter";
283  case ISD::VAARG: return "vaarg";
284  case ISD::VACOPY: return "vacopy";
285  case ISD::VAEND: return "vaend";
286  case ISD::VASTART: return "vastart";
287  case ISD::DYNAMIC_STACKALLOC: return "dynamic_stackalloc";
288  case ISD::EXTRACT_ELEMENT: return "extract_element";
289  case ISD::BUILD_PAIR: return "build_pair";
290  case ISD::STACKSAVE: return "stacksave";
291  case ISD::STACKRESTORE: return "stackrestore";
292  case ISD::TRAP: return "trap";
293  case ISD::DEBUGTRAP: return "debugtrap";
294  case ISD::LIFETIME_START: return "lifetime.start";
295  case ISD::LIFETIME_END: return "lifetime.end";
296  case ISD::GC_TRANSITION_START: return "gc_transition.start";
297  case ISD::GC_TRANSITION_END: return "gc_transition.end";
298 
299  // Bit manipulation
300  case ISD::BSWAP: return "bswap";
301  case ISD::CTPOP: return "ctpop";
302  case ISD::CTTZ: return "cttz";
303  case ISD::CTTZ_ZERO_UNDEF: return "cttz_zero_undef";
304  case ISD::CTLZ: return "ctlz";
305  case ISD::CTLZ_ZERO_UNDEF: return "ctlz_zero_undef";
306 
307  // Trampolines
308  case ISD::INIT_TRAMPOLINE: return "init_trampoline";
309  case ISD::ADJUST_TRAMPOLINE: return "adjust_trampoline";
310 
311  case ISD::CONDCODE:
312  switch (cast<CondCodeSDNode>(this)->get()) {
313  default: llvm_unreachable("Unknown setcc condition!");
314  case ISD::SETOEQ: return "setoeq";
315  case ISD::SETOGT: return "setogt";
316  case ISD::SETOGE: return "setoge";
317  case ISD::SETOLT: return "setolt";
318  case ISD::SETOLE: return "setole";
319  case ISD::SETONE: return "setone";
320 
321  case ISD::SETO: return "seto";
322  case ISD::SETUO: return "setuo";
323  case ISD::SETUEQ: return "setue";
324  case ISD::SETUGT: return "setugt";
325  case ISD::SETUGE: return "setuge";
326  case ISD::SETULT: return "setult";
327  case ISD::SETULE: return "setule";
328  case ISD::SETUNE: return "setune";
329 
330  case ISD::SETEQ: return "seteq";
331  case ISD::SETGT: return "setgt";
332  case ISD::SETGE: return "setge";
333  case ISD::SETLT: return "setlt";
334  case ISD::SETLE: return "setle";
335  case ISD::SETNE: return "setne";
336 
337  case ISD::SETTRUE: return "settrue";
338  case ISD::SETTRUE2: return "settrue2";
339  case ISD::SETFALSE: return "setfalse";
340  case ISD::SETFALSE2: return "setfalse2";
341  }
342  }
343 }
344 
346  switch (AM) {
347  default: return "";
348  case ISD::PRE_INC: return "<pre-inc>";
349  case ISD::PRE_DEC: return "<pre-dec>";
350  case ISD::POST_INC: return "<post-inc>";
351  case ISD::POST_DEC: return "<post-dec>";
352  }
353 }
354 
355 void SDNode::dump() const { dump(nullptr); }
356 void SDNode::dump(const SelectionDAG *G) const {
357  print(dbgs(), G);
358  dbgs() << '\n';
359 }
360 
362  OS << (const void*)this << ": ";
363 
364  for (unsigned i = 0, e = getNumValues(); i != e; ++i) {
365  if (i) OS << ",";
366  if (getValueType(i) == MVT::Other)
367  OS << "ch";
368  else
369  OS << getValueType(i).getEVTString();
370  }
371  OS << " = " << getOperationName(G);
372 }
373 
375  if (const MachineSDNode *MN = dyn_cast<MachineSDNode>(this)) {
376  if (!MN->memoperands_empty()) {
377  OS << "<";
378  OS << "Mem:";
379  for (MachineSDNode::mmo_iterator i = MN->memoperands_begin(),
380  e = MN->memoperands_end(); i != e; ++i) {
381  OS << **i;
382  if (std::next(i) != e)
383  OS << " ";
384  }
385  OS << ">";
386  }
387  } else if (const ShuffleVectorSDNode *SVN =
388  dyn_cast<ShuffleVectorSDNode>(this)) {
389  OS << "<";
390  for (unsigned i = 0, e = ValueList[0].getVectorNumElements(); i != e; ++i) {
391  int Idx = SVN->getMaskElt(i);
392  if (i) OS << ",";
393  if (Idx < 0)
394  OS << "u";
395  else
396  OS << Idx;
397  }
398  OS << ">";
399  } else if (const ConstantSDNode *CSDN = dyn_cast<ConstantSDNode>(this)) {
400  OS << '<' << CSDN->getAPIntValue() << '>';
401  } else if (const ConstantFPSDNode *CSDN = dyn_cast<ConstantFPSDNode>(this)) {
402  if (&CSDN->getValueAPF().getSemantics()==&APFloat::IEEEsingle)
403  OS << '<' << CSDN->getValueAPF().convertToFloat() << '>';
404  else if (&CSDN->getValueAPF().getSemantics()==&APFloat::IEEEdouble)
405  OS << '<' << CSDN->getValueAPF().convertToDouble() << '>';
406  else {
407  OS << "<APFloat(";
408  CSDN->getValueAPF().bitcastToAPInt().dump();
409  OS << ")>";
410  }
411  } else if (const GlobalAddressSDNode *GADN =
412  dyn_cast<GlobalAddressSDNode>(this)) {
413  int64_t offset = GADN->getOffset();
414  OS << '<';
415  GADN->getGlobal()->printAsOperand(OS);
416  OS << '>';
417  if (offset > 0)
418  OS << " + " << offset;
419  else
420  OS << " " << offset;
421  if (unsigned int TF = GADN->getTargetFlags())
422  OS << " [TF=" << TF << ']';
423  } else if (const FrameIndexSDNode *FIDN = dyn_cast<FrameIndexSDNode>(this)) {
424  OS << "<" << FIDN->getIndex() << ">";
425  } else if (const JumpTableSDNode *JTDN = dyn_cast<JumpTableSDNode>(this)) {
426  OS << "<" << JTDN->getIndex() << ">";
427  if (unsigned int TF = JTDN->getTargetFlags())
428  OS << " [TF=" << TF << ']';
429  } else if (const ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(this)){
430  int offset = CP->getOffset();
431  if (CP->isMachineConstantPoolEntry())
432  OS << "<" << *CP->getMachineCPVal() << ">";
433  else
434  OS << "<" << *CP->getConstVal() << ">";
435  if (offset > 0)
436  OS << " + " << offset;
437  else
438  OS << " " << offset;
439  if (unsigned int TF = CP->getTargetFlags())
440  OS << " [TF=" << TF << ']';
441  } else if (const TargetIndexSDNode *TI = dyn_cast<TargetIndexSDNode>(this)) {
442  OS << "<" << TI->getIndex() << '+' << TI->getOffset() << ">";
443  if (unsigned TF = TI->getTargetFlags())
444  OS << " [TF=" << TF << ']';
445  } else if (const BasicBlockSDNode *BBDN = dyn_cast<BasicBlockSDNode>(this)) {
446  OS << "<";
447  const Value *LBB = (const Value*)BBDN->getBasicBlock()->getBasicBlock();
448  if (LBB)
449  OS << LBB->getName() << " ";
450  OS << (const void*)BBDN->getBasicBlock() << ">";
451  } else if (const RegisterSDNode *R = dyn_cast<RegisterSDNode>(this)) {
452  OS << ' ' << PrintReg(R->getReg(),
453  G ? G->getSubtarget().getRegisterInfo() : nullptr);
454  } else if (const ExternalSymbolSDNode *ES =
455  dyn_cast<ExternalSymbolSDNode>(this)) {
456  OS << "'" << ES->getSymbol() << "'";
457  if (unsigned int TF = ES->getTargetFlags())
458  OS << " [TF=" << TF << ']';
459  } else if (const SrcValueSDNode *M = dyn_cast<SrcValueSDNode>(this)) {
460  if (M->getValue())
461  OS << "<" << M->getValue() << ">";
462  else
463  OS << "<null>";
464  } else if (const MDNodeSDNode *MD = dyn_cast<MDNodeSDNode>(this)) {
465  if (MD->getMD())
466  OS << "<" << MD->getMD() << ">";
467  else
468  OS << "<null>";
469  } else if (const VTSDNode *N = dyn_cast<VTSDNode>(this)) {
470  OS << ":" << N->getVT().getEVTString();
471  }
472  else if (const LoadSDNode *LD = dyn_cast<LoadSDNode>(this)) {
473  OS << "<" << *LD->getMemOperand();
474 
475  bool doExt = true;
476  switch (LD->getExtensionType()) {
477  default: doExt = false; break;
478  case ISD::EXTLOAD: OS << ", anyext"; break;
479  case ISD::SEXTLOAD: OS << ", sext"; break;
480  case ISD::ZEXTLOAD: OS << ", zext"; break;
481  }
482  if (doExt)
483  OS << " from " << LD->getMemoryVT().getEVTString();
484 
485  const char *AM = getIndexedModeName(LD->getAddressingMode());
486  if (*AM)
487  OS << ", " << AM;
488 
489  OS << ">";
490  } else if (const StoreSDNode *ST = dyn_cast<StoreSDNode>(this)) {
491  OS << "<" << *ST->getMemOperand();
492 
493  if (ST->isTruncatingStore())
494  OS << ", trunc to " << ST->getMemoryVT().getEVTString();
495 
496  const char *AM = getIndexedModeName(ST->getAddressingMode());
497  if (*AM)
498  OS << ", " << AM;
499 
500  OS << ">";
501  } else if (const MemSDNode* M = dyn_cast<MemSDNode>(this)) {
502  OS << "<" << *M->getMemOperand() << ">";
503  } else if (const BlockAddressSDNode *BA =
504  dyn_cast<BlockAddressSDNode>(this)) {
505  int64_t offset = BA->getOffset();
506  OS << "<";
507  BA->getBlockAddress()->getFunction()->printAsOperand(OS, false);
508  OS << ", ";
509  BA->getBlockAddress()->getBasicBlock()->printAsOperand(OS, false);
510  OS << ">";
511  if (offset > 0)
512  OS << " + " << offset;
513  else
514  OS << " " << offset;
515  if (unsigned int TF = BA->getTargetFlags())
516  OS << " [TF=" << TF << ']';
517  } else if (const AddrSpaceCastSDNode *ASC =
518  dyn_cast<AddrSpaceCastSDNode>(this)) {
519  OS << '['
520  << ASC->getSrcAddressSpace()
521  << " -> "
522  << ASC->getDestAddressSpace()
523  << ']';
524  }
525 
526  if (unsigned Order = getIROrder())
527  OS << " [ORD=" << Order << ']';
528 
529  if (getNodeId() != -1)
530  OS << " [ID=" << getNodeId() << ']';
531 
532  if (!G)
533  return;
534 
535  DILocation *L = getDebugLoc();
536  if (!L)
537  return;
538 
539  if (auto *Scope = L->getScope())
540  OS << Scope->getFilename();
541  else
542  OS << "<unknown>";
543  OS << ':' << L->getLine();
544  if (unsigned C = L->getColumn())
545  OS << ':' << C;
546 }
547 
548 static void DumpNodes(const SDNode *N, unsigned indent, const SelectionDAG *G) {
549  for (const SDValue &Op : N->op_values())
550  if (Op.getNode()->hasOneUse())
551  DumpNodes(Op.getNode(), indent+2, G);
552  else
553  dbgs() << "\n" << std::string(indent+2, ' ')
554  << (void*)Op.getNode() << ": <multiple use>";
555 
556  dbgs() << '\n';
557  dbgs().indent(indent);
558  N->dump(G);
559 }
560 
561 void SelectionDAG::dump() const {
562  dbgs() << "SelectionDAG has " << AllNodes.size() << " nodes:";
563 
564  for (allnodes_const_iterator I = allnodes_begin(), E = allnodes_end();
565  I != E; ++I) {
566  const SDNode *N = I;
567  if (!N->hasOneUse() && N != getRoot().getNode())
568  DumpNodes(N, 2, this);
569  }
570 
571  if (getRoot().getNode()) DumpNodes(getRoot().getNode(), 2, this);
572  dbgs() << "\n\n";
573 }
574 
575 void SDNode::printr(raw_ostream &OS, const SelectionDAG *G) const {
576  print_types(OS, G);
577  print_details(OS, G);
578 }
579 
580 typedef SmallPtrSet<const SDNode *, 128> VisitedSDNodeSet;
581 static void DumpNodesr(raw_ostream &OS, const SDNode *N, unsigned indent,
582  const SelectionDAG *G, VisitedSDNodeSet &once) {
583  if (!once.insert(N).second) // If we've been here before, return now.
584  return;
585 
586  // Dump the current SDNode, but don't end the line yet.
587  OS.indent(indent);
588  N->printr(OS, G);
589 
590  // Having printed this SDNode, walk the children:
591  for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
592  const SDNode *child = N->getOperand(i).getNode();
593 
594  if (i) OS << ",";
595  OS << " ";
596 
597  if (child->getNumOperands() == 0) {
598  // This child has no grandchildren; print it inline right here.
599  child->printr(OS, G);
600  once.insert(child);
601  } else { // Just the address. FIXME: also print the child's opcode.
602  OS << (const void*)child;
603  if (unsigned RN = N->getOperand(i).getResNo())
604  OS << ":" << RN;
605  }
606  }
607 
608  OS << "\n";
609 
610  // Dump children that have grandchildren on their own line(s).
611  for (const SDValue &Op : N->op_values())
612  DumpNodesr(OS, Op.getNode(), indent+2, G, once);
613 }
614 
615 void SDNode::dumpr() const {
616  VisitedSDNodeSet once;
617  DumpNodesr(dbgs(), this, 0, nullptr, once);
618 }
619 
620 void SDNode::dumpr(const SelectionDAG *G) const {
621  VisitedSDNodeSet once;
622  DumpNodesr(dbgs(), this, 0, G, once);
623 }
624 
625 static void printrWithDepthHelper(raw_ostream &OS, const SDNode *N,
626  const SelectionDAG *G, unsigned depth,
627  unsigned indent) {
628  if (depth == 0)
629  return;
630 
631  OS.indent(indent);
632 
633  N->print(OS, G);
634 
635  if (depth < 1)
636  return;
637 
638  for (const SDValue &Op : N->op_values()) {
639  // Don't follow chain operands.
640  if (Op.getValueType() == MVT::Other)
641  continue;
642  OS << '\n';
643  printrWithDepthHelper(OS, Op.getNode(), G, depth-1, indent+2);
644  }
645 }
646 
648  unsigned depth) const {
649  printrWithDepthHelper(OS, this, G, depth, 0);
650 }
651 
652 void SDNode::printrFull(raw_ostream &OS, const SelectionDAG *G) const {
653  // Don't print impossibly deep things.
654  printrWithDepth(OS, G, 10);
655 }
656 
657 void SDNode::dumprWithDepth(const SelectionDAG *G, unsigned depth) const {
658  printrWithDepth(dbgs(), G, depth);
659 }
660 
661 void SDNode::dumprFull(const SelectionDAG *G) const {
662  // Don't print impossibly deep things.
663  dumprWithDepth(G, 10);
664 }
665 
666 void SDNode::print(raw_ostream &OS, const SelectionDAG *G) const {
667  print_types(OS, G);
668  for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
669  if (i) OS << ", "; else OS << " ";
670  OS << (void*)getOperand(i).getNode();
671  if (unsigned RN = getOperand(i).getResNo())
672  OS << ":" << RN;
673  }
674  print_details(OS, G);
675 }
ADJUST_TRAMPOLINE - This corresponds to the adjust_trampoline intrinsic.
Definition: ISDOpcodes.h:641
BITCAST - This operator converts between integer, vector and FP values, as if the value was stored to...
Definition: ISDOpcodes.h:477
X = FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating point type down to the precision of the ...
Definition: ISDOpcodes.h:450
BUILTIN_OP_END - This must be the last enum value in this list.
Definition: ISDOpcodes.h:724
EXTRACT_ELEMENT - This is used to get the lower or upper (determined by a Constant, which is required to be operand #1) half of the integer or float value specified as operand #0.
Definition: ISDOpcodes.h:175
void dumprFull(const SelectionDAG *G=nullptr) const
printrFull to dbgs().
void dump() const
Dump this node, for debugging.
DELETED_NODE - This is an illegal value that is used to catch errors.
Definition: ISDOpcodes.h:42
MDNODE_SDNODE - This is a node that holdes an MDNode*, which is used to reference metadata in the IR...
Definition: ISDOpcodes.h:615
EXTRACT_SUBVECTOR(VECTOR, IDX) - Returns a subvector from VECTOR (an vector value) starting with the ...
Definition: ISDOpcodes.h:292
BR_CC - Conditional branch.
Definition: ISDOpcodes.h:554
Various leaf nodes.
Definition: ISDOpcodes.h:60
static const fltSemantics IEEEdouble
Definition: APFloat.h:133
VECTOR_SHUFFLE(VEC1, VEC2) - Returns a vector, of the same type as VEC1/VEC2.
Definition: ISDOpcodes.h:301
ZERO_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register zero-extension of the low ...
Definition: ISDOpcodes.h:432
Carry-setting nodes for multiple precision addition and subtraction.
Definition: ISDOpcodes.h:210
const TargetMachine & getTarget() const
Definition: SelectionDAG.h:285
const TargetSubtargetInfo & getSubtarget() const
Definition: SelectionDAG.h:286
STACKRESTORE has two operands, an input chain and a pointer to restore to it returns an output chain...
Definition: ISDOpcodes.h:585
raw_ostream & indent(unsigned NumSpaces)
indent - Insert 'NumSpaces' spaces.
RESULT, BOOL = [SU]ADDO(LHS, RHS) - Overflow-aware nodes for addition.
Definition: ISDOpcodes.h:228
unsigned getOpcode() const
Return the SelectionDAG opcode value for this node.
TargetGlobalAddress - Like GlobalAddress, but the DAG does no folding or anything else with this node...
Definition: ISDOpcodes.h:122
Val, Success, OUTCHAIN = ATOMIC_CMP_SWAP_WITH_SUCCESS(INCHAIN, ptr, cmp, swap) N.b.
Definition: ISDOpcodes.h:679
unsigned getNumOperands() const
Return the number of values used by this operation.
const SDValue & getOperand(unsigned Num) const
SIGN_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register sign-extension of the low ...
Definition: ISDOpcodes.h:423
[US]{MIN/MAX} - Binary minimum or maximum or signed or unsigned integers.
Definition: ISDOpcodes.h:318
Same for subtraction.
Definition: ISDOpcodes.h:231
INSERT_SUBVECTOR(VECTOR1, VECTOR2, IDX) - Returns a vector with VECTOR2 inserted into VECTOR1 at the ...
Definition: ISDOpcodes.h:287
The address of the GOT.
Definition: ISDOpcodes.h:66
EntryToken - This is the marker used to indicate the start of a region.
Definition: ISDOpcodes.h:45
OUTCHAIN = ATOMIC_FENCE(INCHAIN, ordering, scope) This corresponds to the fence instruction.
Definition: ISDOpcodes.h:658
Select with condition operator - This selects between a true value and a false value (ops #2 and #3) ...
Definition: ISDOpcodes.h:357
INT = FGETSIGN(FP) - Return the sign bit of the specified floating point value as an integer 0/1 valu...
Definition: ISDOpcodes.h:254
This SDNode is used to implement the code generator support for the llvm IR shufflevector instruction...
RESULT,OUTCHAIN = INTRINSIC_W_CHAIN(INCHAIN, INTRINSICID, arg1, ...) This node represents a target in...
Definition: ISDOpcodes.h:150
void dumpr() const
Dump (recursively) this node and its use-def subgraph.
OUTCHAIN = EH_SJLJ_LONGJMP(INCHAIN, buffer) This corresponds to the eh.sjlj.longjmp intrinsic...
Definition: ISDOpcodes.h:109
SDIVREM/UDIVREM - Divide two integers and produce both a quotient and remainder result.
Definition: ISDOpcodes.h:200
SHL_PARTS/SRA_PARTS/SRL_PARTS - These operators are used for expanded integer shift operations...
Definition: ISDOpcodes.h:371
void print_types(raw_ostream &OS, const SelectionDAG *G) const
void dumprWithDepth(const SelectionDAG *G=nullptr, unsigned depth=100) const
printrWithDepth to dbgs().
MachineMemOperand - A description of a memory reference used in the backend.
virtual const char * getTargetNodeName(unsigned Opcode) const
This method returns the name of a target specific DAG node.
std::string getEVTString() const
getEVTString - This function returns value type as a string, e.g.
Definition: ValueTypes.cpp:106
PCMARKER - This corresponds to the pcmarker intrinsic.
Definition: ISDOpcodes.h:618
This file declares the MachineConstantPool class which is an abstract constant pool to keep track of ...
const HexagonInstrInfo * TII
Shift and rotation operations.
Definition: ISDOpcodes.h:332
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
EVT getValueType(unsigned ResNo) const
Return the type of a specified result.
BUILD_PAIR - This is the opposite of EXTRACT_ELEMENT in some ways.
Definition: ISDOpcodes.h:181
CopyToReg - This node has three operands: a chain, a register number to set to this value...
Definition: ISDOpcodes.h:161
FLT_ROUNDS_ - Returns current rounding mode: -1 Undefined 0 Round to 0 1 Round to nearest 2 Round to ...
Definition: ISDOpcodes.h:458
CALLSEQ_START/CALLSEQ_END - These operators mark the beginning and end of a call sequence, and carry arbitrary information that target might want to know.
Definition: ISDOpcodes.h:592
Val, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amt) Val, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN, ptr, amt) For double-word atomic operations: ValLo, ValHi, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amtLo, amtHi) ValLo, ValHi, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN, ptr, amtLo, amtHi) These correspond to the atomicrmw instruction.
Definition: ISDOpcodes.h:687
FRAMEADDR, RETURNADDR - These nodes represent llvm.frameaddress and llvm.returnaddress on the DAG...
Definition: ISDOpcodes.h:73
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
#define G(x, y, z)
Definition: MD5.cpp:52
static void printrWithDepthHelper(raw_ostream &OS, const SDNode *N, const SelectionDAG *G, unsigned depth, unsigned indent)
INLINEASM - Represents an inline asm block.
Definition: ISDOpcodes.h:571
STACKSAVE - STACKSAVE has one operand, an input chain.
Definition: ISDOpcodes.h:581
FRAME_TO_ARGS_OFFSET - This node represents offset from frame pointer to first (possible) on-stack ar...
Definition: ISDOpcodes.h:91
[SU]INT_TO_FP - These operators convert integers (whose interpreted sign depends on the first letter)...
Definition: ISDOpcodes.h:393
unsigned getNumValues() const
Return the number of values defined/returned by this operator.
Select with a vector condition (op #0) and two vector operands (ops #1 and #2), returning a vector re...
Definition: ISDOpcodes.h:351
Simple integer binary arithmetic operators.
Definition: ISDOpcodes.h:191
static std::string utostr(uint64_t X, bool isNeg=false)
Definition: StringExtras.h:93
static void DumpNodesr(raw_ostream &OS, const SDNode *N, unsigned indent, const SelectionDAG *G, VisitedSDNodeSet &once)
TargetConstant* - Like Constant*, but the DAG does not do any folding, simplification, or lowering of the constant.
Definition: ISDOpcodes.h:116
static const char * getIndexedModeName(ISD::MemIndexedMode AM)
READCYCLECOUNTER - This corresponds to the readcyclecounter intrinsic.
Definition: ISDOpcodes.h:624
ANY_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register any-extension of the low la...
Definition: ISDOpcodes.h:410
RESULT = INTRINSIC_WO_CHAIN(INTRINSICID, arg1, arg2, ...) This node represents a target intrinsic fun...
Definition: ISDOpcodes.h:142
UNDEF - An undefined node.
Definition: ISDOpcodes.h:169
FP_TO_[US]INT - Convert a floating point value to a signed or unsigned integer.
Definition: ISDOpcodes.h:436
std::string getOperationName(const SelectionDAG *G=nullptr) const
Return the opcode of this operation for printing.
BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a vector with the specified, possibly variable...
Definition: ISDOpcodes.h:262
TargetInstrInfo - Interface to description of machine instruction set.
This corresponds to the llvm.lifetime.
Definition: ISDOpcodes.h:711
SDNode * getNode() const
get the SDNode which holds the desired result
OUTCHAIN = INTRINSIC_VOID(INCHAIN, INTRINSICID, arg1, arg2, ...) This node represents a target intrin...
Definition: ISDOpcodes.h:157
Float from Float.
Definition: ISDOpcodes.h:887
Control flow instructions. These all have token chains.
Definition: ISDOpcodes.h:533
READ_REGISTER, WRITE_REGISTER - This node represents llvm.register on the DAG, which implements the n...
Definition: ISDOpcodes.h:85
GC_TRANSITION_START/GC_TRANSITION_END - These operators mark the beginning and end of GC transition s...
Definition: ISDOpcodes.h:719
LOCAL_RECOVER - Represents the llvm.localrecover intrinsic.
Definition: ISDOpcodes.h:81
Simple binary floating point operators.
Definition: ISDOpcodes.h:237
VAEND, VASTART - VAEND and VASTART have three operands: an input chain, pointer, and a SRCVALUE...
Definition: ISDOpcodes.h:607
INSERT_VECTOR_ELT(VECTOR, VAL, IDX) - Returns VECTOR with the element at IDX replaced with VAL...
Definition: ISDOpcodes.h:267
Carry-using nodes for multiple precision addition and subtraction.
Definition: ISDOpcodes.h:219
INIT_TRAMPOLINE - This corresponds to the init_trampoline intrinsic.
Definition: ISDOpcodes.h:635
void printrFull(raw_ostream &O, const SelectionDAG *G=nullptr) const
Print a SelectionDAG node and all children down to the leaves.
TRAP - Trapping instruction.
Definition: ISDOpcodes.h:644
TargetIndex - Like a constant pool entry, but with completely target-dependent semantics.
Definition: ISDOpcodes.h:135
AssertSext, AssertZext - These nodes record if a register contains a value that has already been zero...
Definition: ISDOpcodes.h:57
DEBUGTRAP - Trap intended to get the attention of a debugger.
Definition: ISDOpcodes.h:647
Signed from Signed.
Definition: ISDOpcodes.h:892
VAARG - VAARG has four operands: an input chain, a pointer, a SRCVALUE, and the alignment.
Definition: ISDOpcodes.h:598
Bit counting operators with an undefined result for zero inputs.
Definition: ISDOpcodes.h:338
Val, OUTCHAIN = ATOMIC_CMP_SWAP(INCHAIN, ptr, cmp, swap) For double-word atomic operations: ValLo...
Definition: ISDOpcodes.h:673
X = FP_EXTEND(Y) - Extend a smaller FP type into a larger FP type.
Definition: ISDOpcodes.h:468
HANDLENODE node - Used as a handle for various purposes.
Definition: ISDOpcodes.h:627
EH_LABEL - Represents a label in mid basic block used to track locations needed for debug and excepti...
Definition: ISDOpcodes.h:576
void print(raw_ostream &OS, const SelectionDAG *G=nullptr) const
TargetIntrinsicInfo - Interface to description of machine instruction set.
TokenFactor - This node takes multiple tokens as input and produces a single token result...
Definition: ISDOpcodes.h:50
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:299
EXTRACT_VECTOR_ELT(VECTOR, IDX) - Returns a single element from VECTOR identified by the (potentially...
Definition: ISDOpcodes.h:273
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Definition: SelectionDAG.h:179
X = FP_ROUND_INREG(Y, VT) - This operator takes an FP register, and rounds it to a floating point val...
Definition: ISDOpcodes.h:465
ADDRSPACECAST - This operator converts between pointers of different address spaces.
Definition: ISDOpcodes.h:481
BRCOND - Conditional branch.
Definition: ISDOpcodes.h:548
Signed from Float.
Definition: ISDOpcodes.h:890
An SDNode that represents everything that will be needed to construct a MachineInstr.
Byte Swap and Counting operators.
Definition: ISDOpcodes.h:335
FP16_TO_FP, FP_TO_FP16 - These operators are used to perform promotions and truncation for half-preci...
Definition: ISDOpcodes.h:500
Unsigned from Signed.
Definition: ISDOpcodes.h:894
Represents one node in the SelectionDAG.
void print_details(raw_ostream &OS, const SelectionDAG *G) const
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:123
void printr(raw_ostream &OS, const SelectionDAG *G=nullptr) const
Select(COND, TRUEVAL, FALSEVAL).
Definition: ISDOpcodes.h:342
ZERO_EXTEND - Used for integer types, zeroing the new bits.
Definition: ISDOpcodes.h:383
ANY_EXTEND - Used for integer types. The high bits are undefined.
Definition: ISDOpcodes.h:386
FCOPYSIGN(X, Y) - Return the value of X with the sign of Y.
Definition: ISDOpcodes.h:250
iterator_range< value_op_iterator > op_values() const
BR_JT - Jumptable branch.
Definition: ISDOpcodes.h:542
VACOPY - VACOPY has 5 operands: an input chain, a destination pointer, a source pointer, a SRCVALUE for the destination, and a SRCVALUE for the source.
Definition: ISDOpcodes.h:603
static const fltSemantics IEEEsingle
Definition: APFloat.h:132
Bitwise operators - logical and, logical or, logical xor.
Definition: ISDOpcodes.h:321
std::string getName(ID id, ArrayRef< Type * > Tys=None)
Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
Definition: Function.cpp:500
SMUL_LOHI/UMUL_LOHI - Multiply two integers of type iN, producing a signed/unsigned value of type i[2...
Definition: ISDOpcodes.h:196
virtual const TargetIntrinsicInfo * getIntrinsicInfo() const
If intrinsic information is available, return it. If not, return null.
SIGN_EXTEND_INREG - This operator atomically performs a SHL/SRA pair to sign extend a small value in ...
Definition: ISDOpcodes.h:401
LOAD and STORE have token chains as their first operand, then the same operands as an LLVM load/store...
Definition: ISDOpcodes.h:518
#define N
Same for multiplication.
Definition: ISDOpcodes.h:234
FSINCOS - Compute both fsin and fcos as a single operation.
Definition: ISDOpcodes.h:512
RESULT, OUTCHAIN = EH_SJLJ_SETJMP(INCHAIN, buffer) This corresponds to the eh.sjlj.setjmp intrinsic.
Definition: ISDOpcodes.h:103
CopyFromReg - This node indicates that the input value is a virtual or physical register that is defi...
Definition: ISDOpcodes.h:166
OUTCHAIN = EH_RETURN(INCHAIN, OFFSET, HANDLER) - This node represents 'eh_return' gcc dwarf builtin...
Definition: ISDOpcodes.h:97
CONVERT_RNDSAT - This operator is used to support various conversions between various types (float...
Definition: ISDOpcodes.h:494
CONCAT_VECTORS(VECTOR0, VECTOR1, ...) - Given a number of values of vector type with the same length ...
Definition: ISDOpcodes.h:279
virtual const TargetInstrInfo * getInstrInfo() const
FMA - Perform a * b + c with no intermediate rounding step.
Definition: ISDOpcodes.h:240
PREFETCH - This corresponds to a prefetch intrinsic.
Definition: ISDOpcodes.h:653
void printrWithDepth(raw_ostream &O, const SelectionDAG *G=nullptr, unsigned depth=100) const
Print a SelectionDAG node and children up to depth "depth." The given SelectionDAG allows target-spec...
const TargetLowering & getTargetLoweringInfo() const
Definition: SelectionDAG.h:287
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:38
Signed from Unsigned.
Definition: ISDOpcodes.h:893
FMAD - Perform a * b + c, while getting the same result as the separately rounded operations...
Definition: ISDOpcodes.h:244
Float from Signed.
Definition: ISDOpcodes.h:888
SetCC operator - This evaluates to a true value iff the condition is true.
Definition: ISDOpcodes.h:365
MERGE_VALUES - This node takes multiple discrete operands and returns them all as its individual resu...
Definition: ISDOpcodes.h:188
Conversion operators.
Definition: ISDOpcodes.h:380
Unsigned from Float.
Definition: ISDOpcodes.h:891
OUTCHAIN = ATOMIC_STORE(INCHAIN, ptr, val) This corresponds to "store atomic" instruction.
Definition: ISDOpcodes.h:666
TRUNCATE - Completely drop the high bits.
Definition: ISDOpcodes.h:389
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation...
FNEG, FABS, FSQRT, FSIN, FCOS, FPOWI, FPOW, FLOG, FLOG2, FLOG10, FEXP, FEXP2, FCEIL, FTRUNC, FRINT, FNEARBYINT, FROUND, FFLOOR - Perform various unary floating point operations.
Definition: ISDOpcodes.h:506
Val, OUTCHAIN = ATOMIC_LOAD(INCHAIN, ptr) This corresponds to "load atomic" instruction.
Definition: ISDOpcodes.h:662
SCALAR_TO_VECTOR(VAL) - This represents the operation of loading a scalar value into element 0 of the...
Definition: ISDOpcodes.h:309
Float from Unsigned.
Definition: ISDOpcodes.h:889
static sys::TimeValue now(bool Deterministic)
CARRY_FALSE - This node is used when folding other nodes, like ADDC/SUBC, which indicate the carry re...
Definition: ISDOpcodes.h:204
bool isMachineOpcode() const
Test if this node has a post-isel opcode, directly corresponding to a MachineInstr opcode...
unsigned getMachineOpcode() const
This may only be called if isMachineOpcode returns true.
MemIndexedMode
MemIndexedMode enum - This enum defines the load / store indexed addressing modes.
Definition: ISDOpcodes.h:761
BRIND - Indirect branch.
Definition: ISDOpcodes.h:538
MULHU/MULHS - Multiply high - Multiply two integers of type iN, producing an unsigned/signed value of...
Definition: ISDOpcodes.h:314
SRCVALUE - This is a node type that holds a Value* that is used to make reference to a value in the L...
Definition: ISDOpcodes.h:611
DYNAMIC_STACKALLOC - Allocate some number of bytes on the stack aligned to a specified boundary...
Definition: ISDOpcodes.h:527