LLVM  16.0.0git
SelectionDAGDumper.cpp
Go to the documentation of this file.
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-exception
6 //
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/TargetInstrInfo.h"
25 #include "llvm/CodeGen/TargetLowering.h"
26 #include "llvm/CodeGen/TargetRegisterInfo.h"
27 #include "llvm/CodeGen/TargetSubtargetInfo.h"
28 #include "llvm/CodeGen/ValueTypes.h"
29 #include "llvm/Config/llvm-config.h"
30 #include "llvm/IR/BasicBlock.h"
31 #include "llvm/IR/Constants.h"
32 #include "llvm/IR/DebugInfoMetadata.h"
33 #include "llvm/IR/DebugLoc.h"
34 #include "llvm/IR/Function.h"
35 #include "llvm/IR/Intrinsics.h"
36 #include "llvm/IR/ModuleSlotTracker.h"
37 #include "llvm/IR/Value.h"
38 #include "llvm/Support/Casting.h"
39 #include "llvm/Support/CommandLine.h"
40 #include "llvm/Support/Compiler.h"
41 #include "llvm/Support/Debug.h"
42 #include "llvm/Support/ErrorHandling.h"
43 #include "llvm/Support/MachineValueType.h"
44 #include "llvm/Support/Printable.h"
45 #include "llvm/Support/raw_ostream.h"
46 #include "llvm/Target/TargetIntrinsicInfo.h"
47 #include "llvm/Target/TargetMachine.h"
48 #include <cstdint>
49 #include <iterator>
50 
51 using namespace llvm;
52 
53 static cl::opt<bool>
54 VerboseDAGDumping("dag-dump-verbose", cl::Hidden,
55  cl::desc("Display more information when dumping selection "
56  "DAG nodes."));
57 
58 std::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 TargetLowering &TLI = G->getTargetLoweringInfo();
72  const char *Name = TLI.getTargetNodeName(getOpcode());
73  if (Name) return Name;
74  return "<<Unknown Target Node #" + utostr(getOpcode()) + ">>";
75  }
76  return "<<Unknown Node #" + utostr(getOpcode()) + ">>";
77 
78 #ifndef NDEBUG
79  case ISD::DELETED_NODE: return "<<Deleted Node!>>";
80 #endif
81  case ISD::PREFETCH: return "Prefetch";
82  case ISD::ATOMIC_FENCE: return "AtomicFence";
83  case ISD::ATOMIC_CMP_SWAP: return "AtomicCmpSwap";
84  case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS: return "AtomicCmpSwapWithSuccess";
85  case ISD::ATOMIC_SWAP: return "AtomicSwap";
86  case ISD::ATOMIC_LOAD_ADD: return "AtomicLoadAdd";
87  case ISD::ATOMIC_LOAD_SUB: return "AtomicLoadSub";
88  case ISD::ATOMIC_LOAD_AND: return "AtomicLoadAnd";
89  case ISD::ATOMIC_LOAD_CLR: return "AtomicLoadClr";
90  case ISD::ATOMIC_LOAD_OR: return "AtomicLoadOr";
91  case ISD::ATOMIC_LOAD_XOR: return "AtomicLoadXor";
92  case ISD::ATOMIC_LOAD_NAND: return "AtomicLoadNand";
93  case ISD::ATOMIC_LOAD_MIN: return "AtomicLoadMin";
94  case ISD::ATOMIC_LOAD_MAX: return "AtomicLoadMax";
95  case ISD::ATOMIC_LOAD_UMIN: return "AtomicLoadUMin";
96  case ISD::ATOMIC_LOAD_UMAX: return "AtomicLoadUMax";
97  case ISD::ATOMIC_LOAD_FADD: return "AtomicLoadFAdd";
98  case ISD::ATOMIC_LOAD: return "AtomicLoad";
99  case ISD::ATOMIC_STORE: return "AtomicStore";
100  case ISD::PCMARKER: return "PCMarker";
101  case ISD::READCYCLECOUNTER: return "ReadCycleCounter";
102  case ISD::SRCVALUE: return "SrcValue";
103  case ISD::MDNODE_SDNODE: return "MDNode";
104  case ISD::EntryToken: return "EntryToken";
105  case ISD::TokenFactor: return "TokenFactor";
106  case ISD::AssertSext: return "AssertSext";
107  case ISD::AssertZext: return "AssertZext";
108  case ISD::AssertAlign: return "AssertAlign";
109 
110  case ISD::BasicBlock: return "BasicBlock";
111  case ISD::VALUETYPE: return "ValueType";
112  case ISD::Register: return "Register";
113  case ISD::RegisterMask: return "RegisterMask";
114  case ISD::Constant:
115  if (cast<ConstantSDNode>(this)->isOpaque())
116  return "OpaqueConstant";
117  return "Constant";
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::getBaseName((Intrinsic::ID)IID).str();
148  if (!G)
149  return "Unknown intrinsic";
150  if (const TargetIntrinsicInfo *TII = G->getTarget().getIntrinsicInfo())
151  return TII->getName(IID);
152  llvm_unreachable("Invalid intrinsic ID");
153  }
154 
155  case ISD::BUILD_VECTOR: return "BUILD_VECTOR";
156  case ISD::TargetConstant:
157  if (cast<ConstantSDNode>(this)->isOpaque())
158  return "OpaqueTargetConstant";
159  return "TargetConstant";
160  case ISD::TargetConstantFP: return "TargetConstantFP";
161  case ISD::TargetGlobalAddress: return "TargetGlobalAddress";
162  case ISD::TargetGlobalTLSAddress: return "TargetGlobalTLSAddress";
163  case ISD::TargetFrameIndex: return "TargetFrameIndex";
164  case ISD::TargetJumpTable: return "TargetJumpTable";
165  case ISD::TargetConstantPool: return "TargetConstantPool";
166  case ISD::TargetExternalSymbol: return "TargetExternalSymbol";
167  case ISD::MCSymbol: return "MCSymbol";
168  case ISD::TargetBlockAddress: return "TargetBlockAddress";
169 
170  case ISD::CopyToReg: return "CopyToReg";
171  case ISD::CopyFromReg: return "CopyFromReg";
172  case ISD::UNDEF: return "undef";
173  case ISD::VSCALE: return "vscale";
174  case ISD::MERGE_VALUES: return "merge_values";
175  case ISD::INLINEASM: return "inlineasm";
176  case ISD::INLINEASM_BR: return "inlineasm_br";
177  case ISD::EH_LABEL: return "eh_label";
178  case ISD::ANNOTATION_LABEL: return "annotation_label";
179  case ISD::HANDLENODE: return "handlenode";
180 
181  // Unary operators
182  case ISD::FABS: return "fabs";
183  case ISD::FMINNUM: return "fminnum";
184  case ISD::STRICT_FMINNUM: return "strict_fminnum";
185  case ISD::FMAXNUM: return "fmaxnum";
186  case ISD::STRICT_FMAXNUM: return "strict_fmaxnum";
187  case ISD::FMINNUM_IEEE: return "fminnum_ieee";
188  case ISD::FMAXNUM_IEEE: return "fmaxnum_ieee";
189  case ISD::FMINIMUM: return "fminimum";
190  case ISD::STRICT_FMINIMUM: return "strict_fminimum";
191  case ISD::FMAXIMUM: return "fmaximum";
192  case ISD::STRICT_FMAXIMUM: return "strict_fmaximum";
193  case ISD::FNEG: return "fneg";
194  case ISD::FSQRT: return "fsqrt";
195  case ISD::STRICT_FSQRT: return "strict_fsqrt";
196  case ISD::FCBRT: return "fcbrt";
197  case ISD::FSIN: return "fsin";
198  case ISD::STRICT_FSIN: return "strict_fsin";
199  case ISD::FCOS: return "fcos";
200  case ISD::STRICT_FCOS: return "strict_fcos";
201  case ISD::FSINCOS: return "fsincos";
202  case ISD::FTRUNC: return "ftrunc";
203  case ISD::STRICT_FTRUNC: return "strict_ftrunc";
204  case ISD::FFLOOR: return "ffloor";
205  case ISD::STRICT_FFLOOR: return "strict_ffloor";
206  case ISD::FCEIL: return "fceil";
207  case ISD::STRICT_FCEIL: return "strict_fceil";
208  case ISD::FRINT: return "frint";
209  case ISD::STRICT_FRINT: return "strict_frint";
210  case ISD::FNEARBYINT: return "fnearbyint";
211  case ISD::STRICT_FNEARBYINT: return "strict_fnearbyint";
212  case ISD::FROUND: return "fround";
213  case ISD::STRICT_FROUND: return "strict_fround";
214  case ISD::FROUNDEVEN: return "froundeven";
215  case ISD::STRICT_FROUNDEVEN: return "strict_froundeven";
216  case ISD::FEXP: return "fexp";
217  case ISD::STRICT_FEXP: return "strict_fexp";
218  case ISD::FEXP2: return "fexp2";
219  case ISD::STRICT_FEXP2: return "strict_fexp2";
220  case ISD::FLOG: return "flog";
221  case ISD::STRICT_FLOG: return "strict_flog";
222  case ISD::FLOG2: return "flog2";
223  case ISD::STRICT_FLOG2: return "strict_flog2";
224  case ISD::FLOG10: return "flog10";
225  case ISD::STRICT_FLOG10: return "strict_flog10";
226 
227  // Binary operators
228  case ISD::ADD: return "add";
229  case ISD::SUB: return "sub";
230  case ISD::MUL: return "mul";
231  case ISD::MULHU: return "mulhu";
232  case ISD::MULHS: return "mulhs";
233  case ISD::AVGFLOORU: return "avgflooru";
234  case ISD::AVGFLOORS: return "avgfloors";
235  case ISD::AVGCEILU: return "avgceilu";
236  case ISD::AVGCEILS: return "avgceils";
237  case ISD::ABDS: return "abds";
238  case ISD::ABDU: return "abdu";
239  case ISD::SDIV: return "sdiv";
240  case ISD::UDIV: return "udiv";
241  case ISD::SREM: return "srem";
242  case ISD::UREM: return "urem";
243  case ISD::SMUL_LOHI: return "smul_lohi";
244  case ISD::UMUL_LOHI: return "umul_lohi";
245  case ISD::SDIVREM: return "sdivrem";
246  case ISD::UDIVREM: return "udivrem";
247  case ISD::AND: return "and";
248  case ISD::OR: return "or";
249  case ISD::XOR: return "xor";
250  case ISD::SHL: return "shl";
251  case ISD::SRA: return "sra";
252  case ISD::SRL: return "srl";
253  case ISD::ROTL: return "rotl";
254  case ISD::ROTR: return "rotr";
255  case ISD::FSHL: return "fshl";
256  case ISD::FSHR: return "fshr";
257  case ISD::FADD: return "fadd";
258  case ISD::STRICT_FADD: return "strict_fadd";
259  case ISD::FSUB: return "fsub";
260  case ISD::STRICT_FSUB: return "strict_fsub";
261  case ISD::FMUL: return "fmul";
262  case ISD::STRICT_FMUL: return "strict_fmul";
263  case ISD::FDIV: return "fdiv";
264  case ISD::STRICT_FDIV: return "strict_fdiv";
265  case ISD::FMA: return "fma";
266  case ISD::STRICT_FMA: return "strict_fma";
267  case ISD::FMAD: return "fmad";
268  case ISD::FREM: return "frem";
269  case ISD::STRICT_FREM: return "strict_frem";
270  case ISD::FCOPYSIGN: return "fcopysign";
271  case ISD::FGETSIGN: return "fgetsign";
272  case ISD::FCANONICALIZE: return "fcanonicalize";
273  case ISD::IS_FPCLASS: return "is_fpclass";
274  case ISD::FPOW: return "fpow";
275  case ISD::STRICT_FPOW: return "strict_fpow";
276  case ISD::SMIN: return "smin";
277  case ISD::SMAX: return "smax";
278  case ISD::UMIN: return "umin";
279  case ISD::UMAX: return "umax";
280 
281  case ISD::FPOWI: return "fpowi";
282  case ISD::STRICT_FPOWI: return "strict_fpowi";
283  case ISD::SETCC: return "setcc";
284  case ISD::SETCCCARRY: return "setcccarry";
285  case ISD::STRICT_FSETCC: return "strict_fsetcc";
286  case ISD::STRICT_FSETCCS: return "strict_fsetccs";
287  case ISD::SELECT: return "select";
288  case ISD::VSELECT: return "vselect";
289  case ISD::SELECT_CC: return "select_cc";
290  case ISD::INSERT_VECTOR_ELT: return "insert_vector_elt";
291  case ISD::EXTRACT_VECTOR_ELT: return "extract_vector_elt";
292  case ISD::CONCAT_VECTORS: return "concat_vectors";
293  case ISD::INSERT_SUBVECTOR: return "insert_subvector";
294  case ISD::EXTRACT_SUBVECTOR: return "extract_subvector";
295  case ISD::SCALAR_TO_VECTOR: return "scalar_to_vector";
296  case ISD::VECTOR_SHUFFLE: return "vector_shuffle";
297  case ISD::VECTOR_SPLICE: return "vector_splice";
298  case ISD::SPLAT_VECTOR: return "splat_vector";
299  case ISD::SPLAT_VECTOR_PARTS: return "splat_vector_parts";
300  case ISD::VECTOR_REVERSE: return "vector_reverse";
301  case ISD::STEP_VECTOR: return "step_vector";
302  case ISD::CARRY_FALSE: return "carry_false";
303  case ISD::ADDC: return "addc";
304  case ISD::ADDE: return "adde";
305  case ISD::ADDCARRY: return "addcarry";
306  case ISD::SADDO_CARRY: return "saddo_carry";
307  case ISD::SADDO: return "saddo";
308  case ISD::UADDO: return "uaddo";
309  case ISD::SSUBO: return "ssubo";
310  case ISD::USUBO: return "usubo";
311  case ISD::SMULO: return "smulo";
312  case ISD::UMULO: return "umulo";
313  case ISD::SUBC: return "subc";
314  case ISD::SUBE: return "sube";
315  case ISD::SUBCARRY: return "subcarry";
316  case ISD::SSUBO_CARRY: return "ssubo_carry";
317  case ISD::SHL_PARTS: return "shl_parts";
318  case ISD::SRA_PARTS: return "sra_parts";
319  case ISD::SRL_PARTS: return "srl_parts";
320 
321  case ISD::SADDSAT: return "saddsat";
322  case ISD::UADDSAT: return "uaddsat";
323  case ISD::SSUBSAT: return "ssubsat";
324  case ISD::USUBSAT: return "usubsat";
325  case ISD::SSHLSAT: return "sshlsat";
326  case ISD::USHLSAT: return "ushlsat";
327 
328  case ISD::SMULFIX: return "smulfix";
329  case ISD::SMULFIXSAT: return "smulfixsat";
330  case ISD::UMULFIX: return "umulfix";
331  case ISD::UMULFIXSAT: return "umulfixsat";
332 
333  case ISD::SDIVFIX: return "sdivfix";
334  case ISD::SDIVFIXSAT: return "sdivfixsat";
335  case ISD::UDIVFIX: return "udivfix";
336  case ISD::UDIVFIXSAT: return "udivfixsat";
337 
338  // Conversion operators.
339  case ISD::SIGN_EXTEND: return "sign_extend";
340  case ISD::ZERO_EXTEND: return "zero_extend";
341  case ISD::ANY_EXTEND: return "any_extend";
342  case ISD::SIGN_EXTEND_INREG: return "sign_extend_inreg";
343  case ISD::ANY_EXTEND_VECTOR_INREG: return "any_extend_vector_inreg";
344  case ISD::SIGN_EXTEND_VECTOR_INREG: return "sign_extend_vector_inreg";
345  case ISD::ZERO_EXTEND_VECTOR_INREG: return "zero_extend_vector_inreg";
346  case ISD::TRUNCATE: return "truncate";
347  case ISD::FP_ROUND: return "fp_round";
348  case ISD::STRICT_FP_ROUND: return "strict_fp_round";
349  case ISD::FP_EXTEND: return "fp_extend";
350  case ISD::STRICT_FP_EXTEND: return "strict_fp_extend";
351 
352  case ISD::SINT_TO_FP: return "sint_to_fp";
353  case ISD::STRICT_SINT_TO_FP: return "strict_sint_to_fp";
354  case ISD::UINT_TO_FP: return "uint_to_fp";
355  case ISD::STRICT_UINT_TO_FP: return "strict_uint_to_fp";
356  case ISD::FP_TO_SINT: return "fp_to_sint";
357  case ISD::STRICT_FP_TO_SINT: return "strict_fp_to_sint";
358  case ISD::FP_TO_UINT: return "fp_to_uint";
359  case ISD::STRICT_FP_TO_UINT: return "strict_fp_to_uint";
360  case ISD::FP_TO_SINT_SAT: return "fp_to_sint_sat";
361  case ISD::FP_TO_UINT_SAT: return "fp_to_uint_sat";
362  case ISD::BITCAST: return "bitcast";
363  case ISD::ADDRSPACECAST: return "addrspacecast";
364  case ISD::FP16_TO_FP: return "fp16_to_fp";
365  case ISD::STRICT_FP16_TO_FP: return "strict_fp16_to_fp";
366  case ISD::FP_TO_FP16: return "fp_to_fp16";
367  case ISD::STRICT_FP_TO_FP16: return "strict_fp_to_fp16";
368  case ISD::BF16_TO_FP: return "bf16_to_fp";
369  case ISD::FP_TO_BF16: return "fp_to_bf16";
370  case ISD::LROUND: return "lround";
371  case ISD::STRICT_LROUND: return "strict_lround";
372  case ISD::LLROUND: return "llround";
373  case ISD::STRICT_LLROUND: return "strict_llround";
374  case ISD::LRINT: return "lrint";
375  case ISD::STRICT_LRINT: return "strict_lrint";
376  case ISD::LLRINT: return "llrint";
377  case ISD::STRICT_LLRINT: return "strict_llrint";
378 
379  // Control flow instructions
380  case ISD::BR: return "br";
381  case ISD::BRIND: return "brind";
382  case ISD::BR_JT: return "br_jt";
383  case ISD::BRCOND: return "brcond";
384  case ISD::BR_CC: return "br_cc";
385  case ISD::CALLSEQ_START: return "callseq_start";
386  case ISD::CALLSEQ_END: return "callseq_end";
387 
388  // EH instructions
389  case ISD::CATCHRET: return "catchret";
390  case ISD::CLEANUPRET: return "cleanupret";
391 
392  // Other operators
393  case ISD::LOAD: return "load";
394  case ISD::STORE: return "store";
395  case ISD::MLOAD: return "masked_load";
396  case ISD::MSTORE: return "masked_store";
397  case ISD::MGATHER: return "masked_gather";
398  case ISD::MSCATTER: return "masked_scatter";
399  case ISD::VAARG: return "vaarg";
400  case ISD::VACOPY: return "vacopy";
401  case ISD::VAEND: return "vaend";
402  case ISD::VASTART: return "vastart";
403  case ISD::DYNAMIC_STACKALLOC: return "dynamic_stackalloc";
404  case ISD::EXTRACT_ELEMENT: return "extract_element";
405  case ISD::BUILD_PAIR: return "build_pair";
406  case ISD::STACKSAVE: return "stacksave";
407  case ISD::STACKRESTORE: return "stackrestore";
408  case ISD::TRAP: return "trap";
409  case ISD::DEBUGTRAP: return "debugtrap";
410  case ISD::UBSANTRAP: return "ubsantrap";
411  case ISD::LIFETIME_START: return "lifetime.start";
412  case ISD::LIFETIME_END: return "lifetime.end";
413  case ISD::PSEUDO_PROBE:
414  return "pseudoprobe";
415  case ISD::GC_TRANSITION_START: return "gc_transition.start";
416  case ISD::GC_TRANSITION_END: return "gc_transition.end";
417  case ISD::GET_DYNAMIC_AREA_OFFSET: return "get.dynamic.area.offset";
418  case ISD::FREEZE: return "freeze";
419  case ISD::PREALLOCATED_SETUP:
420  return "call_setup";
421  case ISD::PREALLOCATED_ARG:
422  return "call_alloc";
423 
424  // Floating point environment manipulation
425  case ISD::FLT_ROUNDS_: return "flt_rounds";
426  case ISD::SET_ROUNDING: return "set_rounding";
427 
428  // Bit manipulation
429  case ISD::ABS: return "abs";
430  case ISD::BITREVERSE: return "bitreverse";
431  case ISD::BSWAP: return "bswap";
432  case ISD::CTPOP: return "ctpop";
433  case ISD::CTTZ: return "cttz";
434  case ISD::CTTZ_ZERO_UNDEF: return "cttz_zero_undef";
435  case ISD::CTLZ: return "ctlz";
436  case ISD::CTLZ_ZERO_UNDEF: return "ctlz_zero_undef";
437  case ISD::PARITY: return "parity";
438 
439  // Trampolines
440  case ISD::INIT_TRAMPOLINE: return "init_trampoline";
441  case ISD::ADJUST_TRAMPOLINE: return "adjust_trampoline";
442 
443  case ISD::CONDCODE:
444  switch (cast<CondCodeSDNode>(this)->get()) {
445  default: llvm_unreachable("Unknown setcc condition!");
446  case ISD::SETOEQ: return "setoeq";
447  case ISD::SETOGT: return "setogt";
448  case ISD::SETOGE: return "setoge";
449  case ISD::SETOLT: return "setolt";
450  case ISD::SETOLE: return "setole";
451  case ISD::SETONE: return "setone";
452 
453  case ISD::SETO: return "seto";
454  case ISD::SETUO: return "setuo";
455  case ISD::SETUEQ: return "setueq";
456  case ISD::SETUGT: return "setugt";
457  case ISD::SETUGE: return "setuge";
458  case ISD::SETULT: return "setult";
459  case ISD::SETULE: return "setule";
460  case ISD::SETUNE: return "setune";
461 
462  case ISD::SETEQ: return "seteq";
463  case ISD::SETGT: return "setgt";
464  case ISD::SETGE: return "setge";
465  case ISD::SETLT: return "setlt";
466  case ISD::SETLE: return "setle";
467  case ISD::SETNE: return "setne";
468 
469  case ISD::SETTRUE: return "settrue";
470  case ISD::SETTRUE2: return "settrue2";
471  case ISD::SETFALSE: return "setfalse";
472  case ISD::SETFALSE2: return "setfalse2";
473  }
474  case ISD::VECREDUCE_FADD: return "vecreduce_fadd";
475  case ISD::VECREDUCE_SEQ_FADD: return "vecreduce_seq_fadd";
476  case ISD::VECREDUCE_FMUL: return "vecreduce_fmul";
477  case ISD::VECREDUCE_SEQ_FMUL: return "vecreduce_seq_fmul";
478  case ISD::VECREDUCE_ADD: return "vecreduce_add";
479  case ISD::VECREDUCE_MUL: return "vecreduce_mul";
480  case ISD::VECREDUCE_AND: return "vecreduce_and";
481  case ISD::VECREDUCE_OR: return "vecreduce_or";
482  case ISD::VECREDUCE_XOR: return "vecreduce_xor";
483  case ISD::VECREDUCE_SMAX: return "vecreduce_smax";
484  case ISD::VECREDUCE_SMIN: return "vecreduce_smin";
485  case ISD::VECREDUCE_UMAX: return "vecreduce_umax";
486  case ISD::VECREDUCE_UMIN: return "vecreduce_umin";
487  case ISD::VECREDUCE_FMAX: return "vecreduce_fmax";
488  case ISD::VECREDUCE_FMIN: return "vecreduce_fmin";
489  case ISD::STACKMAP:
490  return "stackmap";
491  case ISD::PATCHPOINT:
492  return "patchpoint";
493 
494  // Vector Predication
495 #define BEGIN_REGISTER_VP_SDNODE(SDID, LEGALARG, NAME, ...) \
496  case ISD::SDID: \
497  return #NAME;
498 #include "llvm/IR/VPIntrinsics.def"
499  }
500 }
501 
502 const char *SDNode::getIndexedModeName(ISD::MemIndexedMode AM) {
503  switch (AM) {
504  default: return "";
505  case ISD::PRE_INC: return "<pre-inc>";
506  case ISD::PRE_DEC: return "<pre-dec>";
507  case ISD::POST_INC: return "<post-inc>";
508  case ISD::POST_DEC: return "<post-dec>";
509  }
510 }
511 
512 static Printable PrintNodeId(const SDNode &Node) {
513  return Printable([&Node](raw_ostream &OS) {
514 #ifndef NDEBUG
515  OS << 't' << Node.PersistentId;
516 #else
517  OS << (const void*)&Node;
518 #endif
519  });
520 }
521 
522 // Print the MMO with more information from the SelectionDAG.
523 static void printMemOperand(raw_ostream &OS, const MachineMemOperand &MMO,
524  const MachineFunction *MF, const Module *M,
525  const MachineFrameInfo *MFI,
526  const TargetInstrInfo *TII, LLVMContext &Ctx) {
527  ModuleSlotTracker MST(M);
528  if (MF)
529  MST.incorporateFunction(MF->getFunction());
530  SmallVector<StringRef, 0> SSNs;
531  MMO.print(OS, MST, SSNs, Ctx, MFI, TII);
532 }
533 
534 static void printMemOperand(raw_ostream &OS, const MachineMemOperand &MMO,
535  const SelectionDAG *G) {
536  if (G) {
537  const MachineFunction *MF = &G->getMachineFunction();
538  return printMemOperand(OS, MMO, MF, MF->getFunction().getParent(),
539  &MF->getFrameInfo(),
540  G->getSubtarget().getInstrInfo(), *G->getContext());
541  }
542 
543  LLVMContext Ctx;
544  return printMemOperand(OS, MMO, /*MF=*/nullptr, /*M=*/nullptr,
545  /*MFI=*/nullptr, /*TII=*/nullptr, Ctx);
546 }
547 
548 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
549 LLVM_DUMP_METHOD void SDNode::dump() const { dump(nullptr); }
550 
551 LLVM_DUMP_METHOD void SDNode::dump(const SelectionDAG *G) const {
552  print(dbgs(), G);
553  dbgs() << '\n';
554 }
555 #endif
556 
557 void SDNode::print_types(raw_ostream &OS, const SelectionDAG *G) const {
558  for (unsigned i = 0, e = getNumValues(); i != e; ++i) {
559  if (i) OS << ",";
560  if (getValueType(i) == MVT::Other)
561  OS << "ch";
562  else
563  OS << getValueType(i).getEVTString();
564  }
565 }
566 
567 void SDNode::print_details(raw_ostream &OS, const SelectionDAG *G) const {
568  if (getFlags().hasNoUnsignedWrap())
569  OS << " nuw";
570 
571  if (getFlags().hasNoSignedWrap())
572  OS << " nsw";
573 
574  if (getFlags().hasExact())
575  OS << " exact";
576 
577  if (getFlags().hasNoNaNs())
578  OS << " nnan";
579 
580  if (getFlags().hasNoInfs())
581  OS << " ninf";
582 
583  if (getFlags().hasNoSignedZeros())
584  OS << " nsz";
585 
586  if (getFlags().hasAllowReciprocal())
587  OS << " arcp";
588 
589  if (getFlags().hasAllowContract())
590  OS << " contract";
591 
592  if (getFlags().hasApproximateFuncs())
593  OS << " afn";
594 
595  if (getFlags().hasAllowReassociation())
596  OS << " reassoc";
597 
598  if (getFlags().hasNoFPExcept())
599  OS << " nofpexcept";
600 
601  if (const MachineSDNode *MN = dyn_cast<MachineSDNode>(this)) {
602  if (!MN->memoperands_empty()) {
603  OS << "<";
604  OS << "Mem:";
605  for (MachineSDNode::mmo_iterator i = MN->memoperands_begin(),
606  e = MN->memoperands_end(); i != e; ++i) {
607  printMemOperand(OS, **i, G);
608  if (std::next(i) != e)
609  OS << " ";
610  }
611  OS << ">";
612  }
613  } else if (const ShuffleVectorSDNode *SVN =
614  dyn_cast<ShuffleVectorSDNode>(this)) {
615  OS << "<";
616  for (unsigned i = 0, e = ValueList[0].getVectorNumElements(); i != e; ++i) {
617  int Idx = SVN->getMaskElt(i);
618  if (i) OS << ",";
619  if (Idx < 0)
620  OS << "u";
621  else
622  OS << Idx;
623  }
624  OS << ">";
625  } else if (const ConstantSDNode *CSDN = dyn_cast<ConstantSDNode>(this)) {
626  OS << '<' << CSDN->getAPIntValue() << '>';
627  } else if (const ConstantFPSDNode *CSDN = dyn_cast<ConstantFPSDNode>(this)) {
628  if (&CSDN->getValueAPF().getSemantics() == &APFloat::IEEEsingle())
629  OS << '<' << CSDN->getValueAPF().convertToFloat() << '>';
630  else if (&CSDN->getValueAPF().getSemantics() == &APFloat::IEEEdouble())
631  OS << '<' << CSDN->getValueAPF().convertToDouble() << '>';
632  else {
633  OS << "<APFloat(";
634  CSDN->getValueAPF().bitcastToAPInt().print(OS, false);
635  OS << ")>";
636  }
637  } else if (const GlobalAddressSDNode *GADN =
638  dyn_cast<GlobalAddressSDNode>(this)) {
639  int64_t offset = GADN->getOffset();
640  OS << '<';
641  GADN->getGlobal()->printAsOperand(OS);
642  OS << '>';
643  if (offset > 0)
644  OS << " + " << offset;
645  else
646  OS << " " << offset;
647  if (unsigned int TF = GADN->getTargetFlags())
648  OS << " [TF=" << TF << ']';
649  } else if (const FrameIndexSDNode *FIDN = dyn_cast<FrameIndexSDNode>(this)) {
650  OS << "<" << FIDN->getIndex() << ">";
651  } else if (const JumpTableSDNode *JTDN = dyn_cast<JumpTableSDNode>(this)) {
652  OS << "<" << JTDN->getIndex() << ">";
653  if (unsigned int TF = JTDN->getTargetFlags())
654  OS << " [TF=" << TF << ']';
655  } else if (const ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(this)){
656  int offset = CP->getOffset();
657  if (CP->isMachineConstantPoolEntry())
658  OS << "<" << *CP->getMachineCPVal() << ">";
659  else
660  OS << "<" << *CP->getConstVal() << ">";
661  if (offset > 0)
662  OS << " + " << offset;
663  else
664  OS << " " << offset;
665  if (unsigned int TF = CP->getTargetFlags())
666  OS << " [TF=" << TF << ']';
667  } else if (const TargetIndexSDNode *TI = dyn_cast<TargetIndexSDNode>(this)) {
668  OS << "<" << TI->getIndex() << '+' << TI->getOffset() << ">";
669  if (unsigned TF = TI->getTargetFlags())
670  OS << " [TF=" << TF << ']';
671  } else if (const BasicBlockSDNode *BBDN = dyn_cast<BasicBlockSDNode>(this)) {
672  OS << "<";
673  const Value *LBB = (const Value*)BBDN->getBasicBlock()->getBasicBlock();
674  if (LBB)
675  OS << LBB->getName() << " ";
676  OS << (const void*)BBDN->getBasicBlock() << ">";
677  } else if (const RegisterSDNode *R = dyn_cast<RegisterSDNode>(this)) {
678  OS << ' ' << printReg(R->getReg(),
679  G ? G->getSubtarget().getRegisterInfo() : nullptr);
680  } else if (const ExternalSymbolSDNode *ES =
681  dyn_cast<ExternalSymbolSDNode>(this)) {
682  OS << "'" << ES->getSymbol() << "'";
683  if (unsigned int TF = ES->getTargetFlags())
684  OS << " [TF=" << TF << ']';
685  } else if (const SrcValueSDNode *M = dyn_cast<SrcValueSDNode>(this)) {
686  if (M->getValue())
687  OS << "<" << M->getValue() << ">";
688  else
689  OS << "<null>";
690  } else if (const MDNodeSDNode *MD = dyn_cast<MDNodeSDNode>(this)) {
691  if (MD->getMD())
692  OS << "<" << MD->getMD() << ">";
693  else
694  OS << "<null>";
695  } else if (const VTSDNode *N = dyn_cast<VTSDNode>(this)) {
696  OS << ":" << N->getVT().getEVTString();
697  }
698  else if (const LoadSDNode *LD = dyn_cast<LoadSDNode>(this)) {
699  OS << "<";
700 
701  printMemOperand(OS, *LD->getMemOperand(), G);
702 
703  bool doExt = true;
704  switch (LD->getExtensionType()) {
705  default: doExt = false; break;
706  case ISD::EXTLOAD: OS << ", anyext"; break;
707  case ISD::SEXTLOAD: OS << ", sext"; break;
708  case ISD::ZEXTLOAD: OS << ", zext"; break;
709  }
710  if (doExt)
711  OS << " from " << LD->getMemoryVT().getEVTString();
712 
713  const char *AM = getIndexedModeName(LD->getAddressingMode());
714  if (*AM)
715  OS << ", " << AM;
716 
717  OS << ">";
718  } else if (const StoreSDNode *ST = dyn_cast<StoreSDNode>(this)) {
719  OS << "<";
720  printMemOperand(OS, *ST->getMemOperand(), G);
721 
722  if (ST->isTruncatingStore())
723  OS << ", trunc to " << ST->getMemoryVT().getEVTString();
724 
725  const char *AM = getIndexedModeName(ST->getAddressingMode());
726  if (*AM)
727  OS << ", " << AM;
728 
729  OS << ">";
730  } else if (const MaskedLoadSDNode *MLd = dyn_cast<MaskedLoadSDNode>(this)) {
731  OS << "<";
732 
733  printMemOperand(OS, *MLd->getMemOperand(), G);
734 
735  bool doExt = true;
736  switch (MLd->getExtensionType()) {
737  default: doExt = false; break;
738  case ISD::EXTLOAD: OS << ", anyext"; break;
739  case ISD::SEXTLOAD: OS << ", sext"; break;
740  case ISD::ZEXTLOAD: OS << ", zext"; break;
741  }
742  if (doExt)
743  OS << " from " << MLd->getMemoryVT().getEVTString();
744 
745  const char *AM = getIndexedModeName(MLd->getAddressingMode());
746  if (*AM)
747  OS << ", " << AM;
748 
749  if (MLd->isExpandingLoad())
750  OS << ", expanding";
751 
752  OS << ">";
753  } else if (const MaskedStoreSDNode *MSt = dyn_cast<MaskedStoreSDNode>(this)) {
754  OS << "<";
755  printMemOperand(OS, *MSt->getMemOperand(), G);
756 
757  if (MSt->isTruncatingStore())
758  OS << ", trunc to " << MSt->getMemoryVT().getEVTString();
759 
760  const char *AM = getIndexedModeName(MSt->getAddressingMode());
761  if (*AM)
762  OS << ", " << AM;
763 
764  if (MSt->isCompressingStore())
765  OS << ", compressing";
766 
767  OS << ">";
768  } else if (const auto *MGather = dyn_cast<MaskedGatherSDNode>(this)) {
769  OS << "<";
770  printMemOperand(OS, *MGather->getMemOperand(), G);
771 
772  bool doExt = true;
773  switch (MGather->getExtensionType()) {
774  default: doExt = false; break;
775  case ISD::EXTLOAD: OS << ", anyext"; break;
776  case ISD::SEXTLOAD: OS << ", sext"; break;
777  case ISD::ZEXTLOAD: OS << ", zext"; break;
778  }
779  if (doExt)
780  OS << " from " << MGather->getMemoryVT().getEVTString();
781 
782  auto Signed = MGather->isIndexSigned() ? "signed" : "unsigned";
783  auto Scaled = MGather->isIndexScaled() ? "scaled" : "unscaled";
784  OS << ", " << Signed << " " << Scaled << " offset";
785 
786  OS << ">";
787  } else if (const auto *MScatter = dyn_cast<MaskedScatterSDNode>(this)) {
788  OS << "<";
789  printMemOperand(OS, *MScatter->getMemOperand(), G);
790 
791  if (MScatter->isTruncatingStore())
792  OS << ", trunc to " << MScatter->getMemoryVT().getEVTString();
793 
794  auto Signed = MScatter->isIndexSigned() ? "signed" : "unsigned";
795  auto Scaled = MScatter->isIndexScaled() ? "scaled" : "unscaled";
796  OS << ", " << Signed << " " << Scaled << " offset";
797 
798  OS << ">";
799  } else if (const MemSDNode *M = dyn_cast<MemSDNode>(this)) {
800  OS << "<";
801  printMemOperand(OS, *M->getMemOperand(), G);
802  OS << ">";
803  } else if (const BlockAddressSDNode *BA =
804  dyn_cast<BlockAddressSDNode>(this)) {
805  int64_t offset = BA->getOffset();
806  OS << "<";
807  BA->getBlockAddress()->getFunction()->printAsOperand(OS, false);
808  OS << ", ";
809  BA->getBlockAddress()->getBasicBlock()->printAsOperand(OS, false);
810  OS << ">";
811  if (offset > 0)
812  OS << " + " << offset;
813  else
814  OS << " " << offset;
815  if (unsigned int TF = BA->getTargetFlags())
816  OS << " [TF=" << TF << ']';
817  } else if (const AddrSpaceCastSDNode *ASC =
818  dyn_cast<AddrSpaceCastSDNode>(this)) {
819  OS << '['
820  << ASC->getSrcAddressSpace()
821  << " -> "
822  << ASC->getDestAddressSpace()
823  << ']';
824  } else if (const LifetimeSDNode *LN = dyn_cast<LifetimeSDNode>(this)) {
825  if (LN->hasOffset())
826  OS << "<" << LN->getOffset() << " to " << LN->getOffset() + LN->getSize() << ">";
827  } else if (const auto *AA = dyn_cast<AssertAlignSDNode>(this)) {
828  OS << '<' << AA->getAlign().value() << '>';
829  }
830 
831  if (VerboseDAGDumping) {
832  if (unsigned Order = getIROrder())
833  OS << " [ORD=" << Order << ']';
834 
835  if (getNodeId() != -1)
836  OS << " [ID=" << getNodeId() << ']';
837  if (!(isa<ConstantSDNode>(this) || (isa<ConstantFPSDNode>(this))))
838  OS << " # D:" << isDivergent();
839 
840  if (G && !G->GetDbgValues(this).empty()) {
841  OS << " [NoOfDbgValues=" << G->GetDbgValues(this).size() << ']';
842  for (SDDbgValue *Dbg : G->GetDbgValues(this))
843  if (!Dbg->isInvalidated())
844  Dbg->print(OS);
845  } else if (getHasDebugValue())
846  OS << " [NoOfDbgValues>0]";
847  }
848 }
849 
850 LLVM_DUMP_METHOD void SDDbgValue::print(raw_ostream &OS) const {
851  OS << " DbgVal(Order=" << getOrder() << ')';
852  if (isInvalidated())
853  OS << "(Invalidated)";
854  if (isEmitted())
855  OS << "(Emitted)";
856  OS << "(";
857  bool Comma = false;
858  for (const SDDbgOperand &Op : getLocationOps()) {
859  if (Comma)
860  OS << ", ";
861  switch (Op.getKind()) {
862  case SDDbgOperand::SDNODE:
863  if (Op.getSDNode())
864  OS << "SDNODE=" << PrintNodeId(*Op.getSDNode()) << ':' << Op.getResNo();
865  else
866  OS << "SDNODE";
867  break;
868  case SDDbgOperand::CONST:
869  OS << "CONST";
870  break;
871  case SDDbgOperand::FRAMEIX:
872  OS << "FRAMEIX=" << Op.getFrameIx();
873  break;
874  case SDDbgOperand::VREG:
875  OS << "VREG=" << Op.getVReg();
876  break;
877  }
878  Comma = true;
879  }
880  OS << ")";
881  if (isIndirect()) OS << "(Indirect)";
882  if (isVariadic())
883  OS << "(Variadic)";
884  OS << ":\"" << Var->getName() << '"';
885 #ifndef NDEBUG
886  if (Expr->getNumElements())
887  Expr->dump();
888 #endif
889 }
890 
891 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
892 LLVM_DUMP_METHOD void SDDbgValue::dump() const {
893  if (isInvalidated())
894  return;
895  print(dbgs());
896  dbgs() << "\n";
897 }
898 #endif
899 
900 /// Return true if this node is so simple that we should just print it inline
901 /// if it appears as an operand.
902 static bool shouldPrintInline(const SDNode &Node, const SelectionDAG *G) {
903  // Avoid lots of cluttering when inline printing nodes with associated
904  // DbgValues in verbose mode.
905  if (VerboseDAGDumping && G && !G->GetDbgValues(&Node).empty())
906  return false;
907  if (Node.getOpcode() == ISD::EntryToken)
908  return false;
909  return Node.getNumOperands() == 0;
910 }
911 
912 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
913 static void DumpNodes(const SDNode *N, unsigned indent, const SelectionDAG *G) {
914  for (const SDValue &Op : N->op_values()) {
915  if (shouldPrintInline(*Op.getNode(), G))
916  continue;
917  if (Op.getNode()->hasOneUse())
918  DumpNodes(Op.getNode(), indent+2, G);
919  }
920 
921  dbgs().indent(indent);
922  N->dump(G);
923 }
924 
925 LLVM_DUMP_METHOD void SelectionDAG::dump() const {
926  dbgs() << "SelectionDAG has " << AllNodes.size() << " nodes:\n";
927 
928  for (const SDNode &N : allnodes()) {
929  if (!N.hasOneUse() && &N != getRoot().getNode() &&
930  (!shouldPrintInline(N, this) || N.use_empty()))
931  DumpNodes(&N, 2, this);
932  }
933 
934  if (getRoot().getNode()) DumpNodes(getRoot().getNode(), 2, this);
935  dbgs() << "\n";
936 
937  if (VerboseDAGDumping) {
938  if (DbgBegin() != DbgEnd())
939  dbgs() << "SDDbgValues:\n";
940  for (auto *Dbg : make_range(DbgBegin(), DbgEnd()))
941  Dbg->dump();
942  if (ByvalParmDbgBegin() != ByvalParmDbgEnd())
943  dbgs() << "Byval SDDbgValues:\n";
944  for (auto *Dbg : make_range(ByvalParmDbgBegin(), ByvalParmDbgEnd()))
945  Dbg->dump();
946  }
947  dbgs() << "\n";
948 }
949 #endif
950 
951 void SDNode::printr(raw_ostream &OS, const SelectionDAG *G) const {
952  OS << PrintNodeId(*this) << ": ";
953  print_types(OS, G);
954  OS << " = " << getOperationName(G);
955  print_details(OS, G);
956 }
957 
958 static bool printOperand(raw_ostream &OS, const SelectionDAG *G,
959  const SDValue Value) {
960  if (!Value.getNode()) {
961  OS << "<null>";
962  return false;
963  }
964 
965  if (shouldPrintInline(*Value.getNode(), G)) {
966  OS << Value->getOperationName(G) << ':';
967  Value->print_types(OS, G);
968  Value->print_details(OS, G);
969  return true;
970  }
971 
972  OS << PrintNodeId(*Value.getNode());
973  if (unsigned RN = Value.getResNo())
974  OS << ':' << RN;
975  return false;
976 }
977 
978 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
979 using VisitedSDNodeSet = SmallPtrSet<const SDNode *, 32>;
980 
981 static void DumpNodesr(raw_ostream &OS, const SDNode *N, unsigned indent,
982  const SelectionDAG *G, VisitedSDNodeSet &once) {
983  if (!once.insert(N).second) // If we've been here before, return now.
984  return;
985 
986  // Dump the current SDNode, but don't end the line yet.
987  OS.indent(indent);
988  N->printr(OS, G);
989 
990  // Having printed this SDNode, walk the children:
991  for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
992  if (i) OS << ",";
993  OS << " ";
994 
995  const SDValue Op = N->getOperand(i);
996  bool printedInline = printOperand(OS, G, Op);
997  if (printedInline)
998  once.insert(Op.getNode());
999  }
1000 
1001  OS << "\n";
1002 
1003  // Dump children that have grandchildren on their own line(s).
1004  for (const SDValue &Op : N->op_values())
1005  DumpNodesr(OS, Op.getNode(), indent+2, G, once);
1006 }
1007 
1008 LLVM_DUMP_METHOD void SDNode::dumpr() const {
1009  VisitedSDNodeSet once;
1010  DumpNodesr(dbgs(), this, 0, nullptr, once);
1011 }
1012 
1013 LLVM_DUMP_METHOD void SDNode::dumpr(const SelectionDAG *G) const {
1014  VisitedSDNodeSet once;
1015  DumpNodesr(dbgs(), this, 0, G, once);
1016 }
1017 #endif
1018 
1019 static void printrWithDepthHelper(raw_ostream &OS, const SDNode *N,
1020  const SelectionDAG *G, unsigned depth,
1021  unsigned indent) {
1022  if (depth == 0)
1023  return;
1024 
1025  OS.indent(indent);
1026 
1027  N->print(OS, G);
1028 
1029  for (const SDValue &Op : N->op_values()) {
1030  // Don't follow chain operands.
1031  if (Op.getValueType() == MVT::Other)
1032  continue;
1033  OS << '\n';
1034  printrWithDepthHelper(OS, Op.getNode(), G, depth - 1, indent + 2);
1035  }
1036 }
1037 
1038 void SDNode::printrWithDepth(raw_ostream &OS, const SelectionDAG *G,
1039  unsigned depth) const {
1040  printrWithDepthHelper(OS, this, G, depth, 0);
1041 }
1042 
1043 void SDNode::printrFull(raw_ostream &OS, const SelectionDAG *G) const {
1044  // Don't print impossibly deep things.
1045  printrWithDepth(OS, G, 10);
1046 }
1047 
1048 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1049 LLVM_DUMP_METHOD
1050 void SDNode::dumprWithDepth(const SelectionDAG *G, unsigned depth) const {
1051  printrWithDepth(dbgs(), G, depth);
1052 }
1053 
1054 LLVM_DUMP_METHOD void SDNode::dumprFull(const SelectionDAG *G) const {
1055  // Don't print impossibly deep things.
1056  dumprWithDepth(G, 10);
1057 }
1058 #endif
1059 
1060 void SDNode::print(raw_ostream &OS, const SelectionDAG *G) const {
1061  printr(OS, G);
1062  // Under VerboseDAGDumping divergence will be printed always.
1063  if (isDivergent() && !VerboseDAGDumping)
1064  OS << " # D:1";
1065  for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
1066  if (i) OS << ", "; else OS << " ";
1067  printOperand(OS, G, getOperand(i));
1068  }
1069  if (DebugLoc DL = getDebugLoc()) {
1070  OS << ", ";
1071  DL.print(OS);
1072  }
1073 }
llvm::ISD::SUB
@ SUB
Definition: ISDOpcodes.h:240
llvm::Intrinsic::getBaseName
StringRef getBaseName(ID id)
Return the LLVM name for an intrinsic, without encoded types for overloading, such as "llvm....
Definition: Function.cpp:877
llvm::ISD::FPOWI
@ FPOWI
Definition: ISDOpcodes.h:917
llvm::ISD::FROUNDEVEN
@ FROUNDEVEN
Definition: ISDOpcodes.h:929
i
i
Definition: README.txt:29
llvm::ISD::ExternalSymbol
@ ExternalSymbol
Definition: ISDOpcodes.h:83
llvm::ISD::STRICT_FP_ROUND
@ STRICT_FP_ROUND
X = STRICT_FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating point type down to the precision ...
Definition: ISDOpcodes.h:464
llvm::ISD::SETUGE
@ SETUGE
Definition: ISDOpcodes.h:1437
ValueTypes.h
llvm::ConstantSDNode
Definition: SelectionDAGNodes.h:1581
llvm::ISD::SETCCCARRY
@ SETCCCARRY
Like SetCC, ops #0 and #1 are the LHS and RHS operands to compare, but op #2 is a boolean indicating ...
Definition: ISDOpcodes.h:744
llvm::ISD::SETTRUE
@ SETTRUE
Definition: ISDOpcodes.h:1441
llvm::ISD::STRICT_FSETCC
@ STRICT_FSETCC
STRICT_FSETCC/STRICT_FSETCCS - Constrained versions of SETCC, used for floating-point operands only.
Definition: ISDOpcodes.h:475
llvm::ISD::VECTOR_SHUFFLE
@ VECTOR_SHUFFLE
VECTOR_SHUFFLE(VEC1, VEC2) - Returns a vector, of the same type as VEC1/VEC2.
Definition: ISDOpcodes.h:586
llvm::ISD::SETLE
@ SETLE
Definition: ISDOpcodes.h:1448
llvm::ISD::INTRINSIC_VOID
@ INTRINSIC_VOID
OUTCHAIN = INTRINSIC_VOID(INCHAIN, INTRINSICID, arg1, arg2, ...) This node represents a target intrin...
Definition: ISDOpcodes.h:199
llvm::ISD::SETO
@ SETO
Definition: ISDOpcodes.h:1433
llvm::ISD::MemIndexedMode
MemIndexedMode
MemIndexedMode enum - This enum defines the load / store indexed addressing modes.
Definition: ISDOpcodes.h:1373
LLVM_DUMP_METHOD
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Definition: Compiler.h:492
llvm::ISD::UMULO
@ UMULO
Definition: ISDOpcodes.h:332
llvm::ISD::STRICT_FSQRT
@ STRICT_FSQRT
Constrained versions of libm-equivalent floating point intrinsics.
Definition: ISDOpcodes.h:411
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::ISD::JumpTable
@ JumpTable
Definition: ISDOpcodes.h:81
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::ISD::PATCHPOINT
@ PATCHPOINT
Definition: ISDOpcodes.h:1299
llvm::SDNode::getValueType
EVT getValueType(unsigned ResNo) const
Return the type of a specified result.
Definition: SelectionDAGNodes.h:983
llvm::ISD::VECTOR_REVERSE
@ VECTOR_REVERSE
VECTOR_REVERSE(VECTOR) - Returns a vector, of the same type as VECTOR, whose elements are shuffled us...
Definition: ISDOpcodes.h:577
llvm::ISD::STRICT_FSIN
@ STRICT_FSIN
Definition: ISDOpcodes.h:414
llvm::ISD::OR
@ OR
Definition: ISDOpcodes.h:667
llvm::ISD::FLT_ROUNDS_
@ FLT_ROUNDS_
Returns current rounding mode: -1 Undefined 0 Round to 0 1 Round to nearest, ties to even 2 Round to ...
Definition: ISDOpcodes.h:863
llvm::ISD::SETGT
@ SETGT
Definition: ISDOpcodes.h:1445
llvm::ISD::BITCAST
@ BITCAST
BITCAST - This operator converts between integer, vector and FP values, as if the value was stored to...
Definition: ISDOpcodes.h:886
llvm::ISD::LIFETIME_END
@ LIFETIME_END
Definition: ISDOpcodes.h:1225
llvm::ISD::SETNE
@ SETNE
Definition: ISDOpcodes.h:1449
llvm::ISD::BR_JT
@ BR_JT
BR_JT - Jumptable branch.
Definition: ISDOpcodes.h:991
llvm::APFloatBase::IEEEsingle
static const fltSemantics & IEEEsingle() LLVM_READNONE
Definition: APFloat.cpp:170
DebugInfoMetadata.h
llvm::ISD::FMINNUM
@ FMINNUM
FMINNUM/FMAXNUM - Perform floating-point minimum or maximum on two values.
Definition: ISDOpcodes.h:943
llvm::ISD::AssertSext
@ AssertSext
AssertSext, AssertZext - These nodes record if a register contains a value that has already been zero...
Definition: ISDOpcodes.h:61
llvm::ISD::UDIVFIXSAT
@ UDIVFIXSAT
Definition: ISDOpcodes.h:387
llvm::ISD::STRICT_FMAXNUM
@ STRICT_FMAXNUM
Definition: ISDOpcodes.h:423
llvm::ISD::ATOMIC_LOAD_UMAX
@ ATOMIC_LOAD_UMAX
Definition: ISDOpcodes.h:1195
Printable.h
llvm::ISD::ConstantFP
@ ConstantFP
Definition: ISDOpcodes.h:77
llvm::ISD::CONCAT_VECTORS
@ CONCAT_VECTORS
CONCAT_VECTORS(VECTOR0, VECTOR1, ...) - Given a number of values of vector type with the same length ...
Definition: ISDOpcodes.h:542
llvm::ISD::LIFETIME_START
@ LIFETIME_START
This corresponds to the llvm.lifetime.
Definition: ISDOpcodes.h:1224
llvm::ISD::PRE_DEC
@ PRE_DEC
Definition: ISDOpcodes.h:1373
llvm::MachineMemOperand::print
void print(raw_ostream &OS, ModuleSlotTracker &MST, SmallVectorImpl< StringRef > &SSNs, const LLVMContext &Context, const MachineFrameInfo *MFI, const TargetInstrInfo *TII) const
Support for operator<<.
Definition: MachineOperand.cpp:1103
llvm::ISD::BSWAP
@ BSWAP
Byte Swap and Counting operators.
Definition: ISDOpcodes.h:700
llvm::ISD::UDIV
@ UDIV
Definition: ISDOpcodes.h:243
llvm::ISD::STRICT_UINT_TO_FP
@ STRICT_UINT_TO_FP
Definition: ISDOpcodes.h:449
llvm::ISD::UADDO
@ UADDO
Definition: ISDOpcodes.h:324
llvm::ISD::STRICT_FMINNUM
@ STRICT_FMINNUM
Definition: ISDOpcodes.h:424
llvm::ISD::DYNAMIC_STACKALLOC
@ DYNAMIC_STACKALLOC
DYNAMIC_STACKALLOC - Allocate some number of bytes on the stack aligned to a specified boundary.
Definition: ISDOpcodes.h:976
llvm::ISD::ATOMIC_LOAD_CLR
@ ATOMIC_LOAD_CLR
Definition: ISDOpcodes.h:1188
llvm::ISD::CTTZ_ZERO_UNDEF
@ CTTZ_ZERO_UNDEF
Bit counting operators with an undefined result for zero inputs.
Definition: ISDOpcodes.h:708
llvm::ISD::ADDC
@ ADDC
Carry-setting nodes for multiple precision addition and subtraction.
Definition: ISDOpcodes.h:269
llvm::ISD::INIT_TRAMPOLINE
@ INIT_TRAMPOLINE
INIT_TRAMPOLINE - This corresponds to the init_trampoline intrinsic.
Definition: ISDOpcodes.h:1124
llvm::ISD::MLOAD
@ MLOAD
Definition: ISDOpcodes.h:1207
llvm::ISD::FSHL
@ FSHL
Definition: ISDOpcodes.h:696
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1181
llvm::ISD::FP_TO_UINT_SAT
@ FP_TO_UINT_SAT
Definition: ISDOpcodes.h:839
llvm::ISD::SETEQ
@ SETEQ
Definition: ISDOpcodes.h:1444
llvm::ISD::STACKRESTORE
@ STACKRESTORE
STACKRESTORE has two operands, an input chain and a pointer to restore to it returns an output chain.
Definition: ISDOpcodes.h:1057
llvm::ISD::CONDCODE
@ CONDCODE
Definition: ISDOpcodes.h:73
llvm::ISD::TargetIndex
@ TargetIndex
TargetIndex - Like a constant pool entry, but with completely target-dependent semantics.
Definition: ISDOpcodes.h:177
llvm::MachineSDNode
An SDNode that represents everything that will be needed to construct a MachineInstr.
Definition: SelectionDAGNodes.h:2889
ErrorHandling.h
llvm::ISD::SDIVFIX
@ SDIVFIX
RESULT = [US]DIVFIX(LHS, RHS, SCALE) - Perform fixed point division on 2 integers with the same width...
Definition: ISDOpcodes.h:380
llvm::ISD::MGATHER
@ MGATHER
Definition: ISDOpcodes.h:1219
llvm::ISD::STEP_VECTOR
@ STEP_VECTOR
STEP_VECTOR(IMM) - Returns a scalable vector whose lanes are comprised of a linear sequence of unsign...
Definition: ISDOpcodes.h:632
llvm::ISD::EH_LABEL
@ EH_LABEL
EH_LABEL - Represents a label in mid basic block used to track locations needed for debug and excepti...
Definition: ISDOpcodes.h:1033
llvm::ISD::FLOG2
@ FLOG2
Definition: ISDOpcodes.h:920
llvm::ISD::ANY_EXTEND
@ ANY_EXTEND
ANY_EXTEND - Used for integer types. The high bits are undefined.
Definition: ISDOpcodes.h:766
llvm::ISD::USUBSAT
@ USUBSAT
Definition: ISDOpcodes.h:350
llvm::SDNode
Represents one node in the SelectionDAG.
Definition: SelectionDAGNodes.h:462
MachineBasicBlock.h
llvm::ISD::FMA
@ FMA
FMA - Perform a * b + c with no intermediate rounding step.
Definition: ISDOpcodes.h:482
llvm::ISD::FP_TO_SINT
@ FP_TO_SINT
FP_TO_[US]INT - Convert a floating point value to a signed or unsigned integer.
Definition: ISDOpcodes.h:819
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:139
APInt.h
llvm::ISD::STRICT_FMAXIMUM
@ STRICT_FMAXIMUM
Definition: ISDOpcodes.h:434
llvm::ISD::USHLSAT
@ USHLSAT
Definition: ISDOpcodes.h:360
llvm::ISD::SETULE
@ SETULE
Definition: ISDOpcodes.h:1439
llvm::ISD::PREALLOCATED_SETUP
@ PREALLOCATED_SETUP
Definition: ISDOpcodes.h:1091
llvm::ISD::SHL_PARTS
@ SHL_PARTS
SHL_PARTS/SRA_PARTS/SRL_PARTS - These operators are used for expanded integer shift operations.
Definition: ISDOpcodes.h:749
TargetInstrInfo.h
llvm::MachineMemOperand
A description of a memory reference used in the backend.
Definition: MachineMemOperand.h:127
llvm::ISD::SETCC
@ SETCC
SetCC operator - This evaluates to a true value iff the condition is true.
Definition: ISDOpcodes.h:736
llvm::ISD::STRICT_FPOW
@ STRICT_FPOW
Definition: ISDOpcodes.h:412
llvm::ISD::CALLSEQ_START
@ CALLSEQ_START
CALLSEQ_START/CALLSEQ_END - These operators mark the beginning and end of a call sequence,...
Definition: ISDOpcodes.h:1071
llvm::ISD::SPLAT_VECTOR_PARTS
@ SPLAT_VECTOR_PARTS
SPLAT_VECTOR_PARTS(SCALAR1, SCALAR2, ...) - Returns a vector with the scalar values joined together a...
Definition: ISDOpcodes.h:622
llvm::ISD::VECREDUCE_FMAX
@ VECREDUCE_FMAX
FMIN/FMAX nodes can have flags, for NaN/NoNaN variants.
Definition: ISDOpcodes.h:1275
llvm::ISD::FMAXNUM_IEEE
@ FMAXNUM_IEEE
Definition: ISDOpcodes.h:951
llvm::ISD::MERGE_VALUES
@ MERGE_VALUES
MERGE_VALUES - This node takes multiple discrete operands and returns them all as its individual resu...
Definition: ISDOpcodes.h:236
llvm::ModuleSlotTracker::incorporateFunction
void incorporateFunction(const Function &F)
Incorporate the given function.
Definition: AsmWriter.cpp:860
llvm::ISD::SIGN_EXTEND_VECTOR_INREG
@ SIGN_EXTEND_VECTOR_INREG
SIGN_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register sign-extension of the low ...
Definition: ISDOpcodes.h:803
llvm::ISD::VAEND
@ VAEND
VAEND, VASTART - VAEND and VASTART have three operands: an input chain, pointer, and a SRCVALUE.
Definition: ISDOpcodes.h:1086
llvm::ISD::VECREDUCE_SEQ_FADD
@ VECREDUCE_SEQ_FADD
Generic reduction nodes.
Definition: ISDOpcodes.h:1259
SDNodeDbgValue.h
llvm::ISD::FP_TO_BF16
@ FP_TO_BF16
Definition: ISDOpcodes.h:906
llvm::ISD::SETOEQ
@ SETOEQ
Definition: ISDOpcodes.h:1427
SelectionDAG.h
llvm::ISD::FREEZE
@ FREEZE
Definition: ISDOpcodes.h:216
llvm::ModuleSlotTracker
Manage lifetime of a slot tracker for printing IR.
Definition: ModuleSlotTracker.h:44
llvm::ISD::GC_TRANSITION_END
@ GC_TRANSITION_END
Definition: ISDOpcodes.h:1234
llvm::ISD::STRICT_FLOG
@ STRICT_FLOG
Definition: ISDOpcodes.h:418
llvm::ISD::CALLSEQ_END
@ CALLSEQ_END
Definition: ISDOpcodes.h:1072
llvm::ISD::STRICT_FP_TO_UINT
@ STRICT_FP_TO_UINT
Definition: ISDOpcodes.h:442
llvm::ISD::SETUEQ
@ SETUEQ
Definition: ISDOpcodes.h:1435
llvm::ISD::SMAX
@ SMAX
Definition: ISDOpcodes.h:661
llvm::ISD::ATOMIC_LOAD_OR
@ ATOMIC_LOAD_OR
Definition: ISDOpcodes.h:1189
llvm::ISD::FABS
@ FABS
Definition: ISDOpcodes.h:912
llvm::ISD::ADDCARRY
@ ADDCARRY
Carry-using nodes for multiple precision addition and subtraction.
Definition: ISDOpcodes.h:303
llvm::ISD::BRCOND
@ BRCOND
BRCOND - Conditional branch.
Definition: ISDOpcodes.h:1001
llvm::ISD::EH_SJLJ_SETJMP
@ EH_SJLJ_SETJMP
RESULT, OUTCHAIN = EH_SJLJ_SETJMP(INCHAIN, buffer) This corresponds to the eh.sjlj....
Definition: ISDOpcodes.h:141
llvm::ShuffleVectorSDNode
This SDNode is used to implement the code generator support for the llvm IR shufflevector instruction...
Definition: SelectionDAGNodes.h:1523
llvm::ISD::INLINEASM
@ INLINEASM
INLINEASM - Represents an inline asm block.
Definition: ISDOpcodes.h:1025
llvm::ISD::PSEUDO_PROBE
@ PSEUDO_PROBE
Pseudo probe for AutoFDO, as a place holder in a basic block to improve the sample counts quality.
Definition: ISDOpcodes.h:1244
llvm::TargetIntrinsicInfo
TargetIntrinsicInfo - Interface to description of machine instruction set.
Definition: TargetIntrinsicInfo.h:29
llvm::ISD::STRICT_FLOG2
@ STRICT_FLOG2
Definition: ISDOpcodes.h:420
llvm::ISD::STRICT_FROUND
@ STRICT_FROUND
Definition: ISDOpcodes.h:427
MachineValueType.h
llvm::ISD::BRIND
@ BRIND
BRIND - Indirect branch.
Definition: ISDOpcodes.h:987
llvm::ISD::ROTL
@ ROTL
Definition: ISDOpcodes.h:694
llvm::ISD::AVGFLOORU
@ AVGFLOORU
Definition: ISDOpcodes.h:644
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::ISD::EH_SJLJ_LONGJMP
@ EH_SJLJ_LONGJMP
OUTCHAIN = EH_SJLJ_LONGJMP(INCHAIN, buffer) This corresponds to the eh.sjlj.longjmp intrinsic.
Definition: ISDOpcodes.h:147
llvm::ISD::VECREDUCE_UMAX
@ VECREDUCE_UMAX
Definition: ISDOpcodes.h:1287
llvm::ISD::GC_TRANSITION_START
@ GC_TRANSITION_START
GC_TRANSITION_START/GC_TRANSITION_END - These operators mark the beginning and end of GC transition s...
Definition: ISDOpcodes.h:1233
llvm::ISD::FFLOOR
@ FFLOOR
Definition: ISDOpcodes.h:930
CommandLine.h
llvm::ISD::STRICT_FDIV
@ STRICT_FDIV
Definition: ISDOpcodes.h:403
llvm::ISD::BR_CC
@ BR_CC
BR_CC - Conditional branch.
Definition: ISDOpcodes.h:1008
TargetLowering.h
llvm::ISD::FSHR
@ FSHR
Definition: ISDOpcodes.h:697
llvm::SDNode::getOpcode
unsigned getOpcode() const
Return the SelectionDAG opcode value for this node.
Definition: SelectionDAGNodes.h:642
llvm::ISD::EH_SJLJ_SETUP_DISPATCH
@ EH_SJLJ_SETUP_DISPATCH
OUTCHAIN = EH_SJLJ_SETUP_DISPATCH(INCHAIN) The target initializes the dispatch table here.
Definition: ISDOpcodes.h:151
llvm::ISD::STRICT_FP_TO_SINT
@ STRICT_FP_TO_SINT
STRICT_FP_TO_[US]INT - Convert a floating point value to a signed or unsigned integer.
Definition: ISDOpcodes.h:441
llvm::ISD::GlobalAddress
@ GlobalAddress
Definition: ISDOpcodes.h:78
llvm::ISD::SELECT_CC
@ SELECT_CC
Select with condition operator - This selects between a true value and a false value (ops #2 and #3) ...
Definition: ISDOpcodes.h:728
llvm::TargetInstrInfo
TargetInstrInfo - Interface to description of machine instruction set.
Definition: TargetInstrInfo.h:98
hasNoUnsignedWrap
static bool hasNoUnsignedWrap(BinaryOperator &I)
Definition: InstructionCombining.cpp:298
TargetMachine.h
llvm::ISD::CTLZ
@ CTLZ
Definition: ISDOpcodes.h:702
llvm::SelectionDAG
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Definition: SelectionDAG.h:220
SelectionDAGNodes.h
llvm::ISD::SELECT
@ SELECT
Select(COND, TRUEVAL, FALSEVAL).
Definition: ISDOpcodes.h:713
llvm::ISD::SMULFIXSAT
@ SMULFIXSAT
Same as the corresponding unsaturated fixed point instructions, but the result is clamped between the...
Definition: ISDOpcodes.h:373
Constants.h
llvm::ISD::STRICT_FRINT
@ STRICT_FRINT
Definition: ISDOpcodes.h:421
llvm::ISD::Constant
@ Constant
Definition: ISDOpcodes.h:76
llvm::ISD::ZERO_EXTEND
@ ZERO_EXTEND
ZERO_EXTEND - Used for integer types, zeroing the new bits.
Definition: ISDOpcodes.h:763
llvm::ISD::ABS
@ ABS
ABS - Determine the unsigned absolute value of a signed integer value of the same bitwidth.
Definition: ISDOpcodes.h:674
llvm::ISD::SETGE
@ SETGE
Definition: ISDOpcodes.h:1446
llvm::ISD::SMULFIX
@ SMULFIX
RESULT = [US]MULFIX(LHS, RHS, SCALE) - Perform fixed point multiplication on 2 integers with the same...
Definition: ISDOpcodes.h:367
llvm::ISD::CATCHRET
@ CATCHRET
CATCHRET - Represents a return from a catch block funclet.
Definition: ISDOpcodes.h:1044
llvm::ISD::SIGN_EXTEND_INREG
@ SIGN_EXTEND_INREG
SIGN_EXTEND_INREG - This operator atomically performs a SHL/SRA pair to sign extend a small value in ...
Definition: ISDOpcodes.h:781
llvm::ISD::CopyToReg
@ CopyToReg
CopyToReg - This node has three operands: a chain, a register number to set to this value,...
Definition: ISDOpcodes.h:203
llvm::ISD::STRICT_FNEARBYINT
@ STRICT_FNEARBYINT
Definition: ISDOpcodes.h:422
llvm::ISD::ANY_EXTEND_VECTOR_INREG
@ ANY_EXTEND_VECTOR_INREG
ANY_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register any-extension of the low la...
Definition: ISDOpcodes.h:792
Intrinsics.h
llvm::TargetLowering
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
Definition: TargetLowering.h:3446
llvm::ISD::STRICT_FP16_TO_FP
@ STRICT_FP16_TO_FP
Definition: ISDOpcodes.h:898
llvm::ISD::FROUND
@ FROUND
Definition: ISDOpcodes.h:928
llvm::ISD::TRUNCATE
@ TRUNCATE
TRUNCATE - Completely drop the high bits.
Definition: ISDOpcodes.h:769
llvm::ISD::SRA
@ SRA
Definition: ISDOpcodes.h:692
llvm::ISD::STRICT_FLOG10
@ STRICT_FLOG10
Definition: ISDOpcodes.h:419
llvm::ISD::LLROUND
@ LLROUND
Definition: ISDOpcodes.h:932
llvm::ISD::FMINNUM_IEEE
@ FMINNUM_IEEE
FMINNUM_IEEE/FMAXNUM_IEEE - Perform floating-point minimum or maximum on two values,...
Definition: ISDOpcodes.h:950
llvm::ISD::GLOBAL_OFFSET_TABLE
@ GLOBAL_OFFSET_TABLE
The address of the GOT.
Definition: ISDOpcodes.h:87
llvm::ISD::UDIVREM
@ UDIVREM
Definition: ISDOpcodes.h:256
TII
const HexagonInstrInfo * TII
Definition: HexagonCopyToCombine.cpp:125
llvm::ISD::DELETED_NODE
@ DELETED_NODE
DELETED_NODE - This is an illegal value that is used to catch errors.
Definition: ISDOpcodes.h:44
llvm::ISD::ADDRSPACECAST
@ ADDRSPACECAST
ADDRSPACECAST - This operator converts between pointers of different address spaces.
Definition: ISDOpcodes.h:890
llvm::ISD::ATOMIC_LOAD_AND
@ ATOMIC_LOAD_AND
Definition: ISDOpcodes.h:1187
llvm::ISD::MDNODE_SDNODE
@ MDNODE_SDNODE
MDNODE_SDNODE - This is a node that holdes an MDNode*, which is used to reference metadata in the IR.
Definition: ISDOpcodes.h:1102
llvm::ISD::ATOMIC_LOAD_UMIN
@ ATOMIC_LOAD_UMIN
Definition: ISDOpcodes.h:1194
llvm::ISD::SINT_TO_FP
@ SINT_TO_FP
[SU]INT_TO_FP - These operators convert integers (whose interpreted sign depends on the first letter)...
Definition: ISDOpcodes.h:773
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
APFloat.h
llvm::ISD::FNEARBYINT
@ FNEARBYINT
Definition: ISDOpcodes.h:927
llvm::ISD::FP16_TO_FP
@ FP16_TO_FP
FP16_TO_FP, FP_TO_FP16 - These operators are used to perform promotions and truncation for half-preci...
Definition: ISDOpcodes.h:896
llvm::ISD::FRINT
@ FRINT
Definition: ISDOpcodes.h:926
llvm::ISD::ATOMIC_STORE
@ ATOMIC_STORE
OUTCHAIN = ATOMIC_STORE(INCHAIN, ptr, val) This corresponds to "store atomic" instruction.
Definition: ISDOpcodes.h:1163
llvm::ISD::AssertAlign
@ AssertAlign
AssertAlign - These nodes record if a register contains a value that has a known alignment and the tr...
Definition: ISDOpcodes.h:68
DebugLoc.h
SmallPtrSet.h
llvm::ISD::AND
@ AND
Bitwise operators - logical and, logical or, logical xor.
Definition: ISDOpcodes.h:666
llvm::ISD::SMULO
@ SMULO
Same for multiplication.
Definition: ISDOpcodes.h:331
llvm::ISD::SETOLT
@ SETOLT
Definition: ISDOpcodes.h:1430
llvm::ISD::ABDS
@ ABDS
Definition: ISDOpcodes.h:655
llvm::ISD::TargetGlobalAddress
@ TargetGlobalAddress
TargetGlobalAddress - Like GlobalAddress, but the DAG does no folding or anything else with this node...
Definition: ISDOpcodes.h:164
llvm::ISD::SPLAT_VECTOR
@ SPLAT_VECTOR
SPLAT_VECTOR(VAL) - Returns a vector with the scalar value VAL duplicated in all lanes.
Definition: ISDOpcodes.h:613
llvm::ISD::EntryToken
@ EntryToken
EntryToken - This is the marker used to indicate the start of a region.
Definition: ISDOpcodes.h:47
llvm::ISD::FSINCOS
@ FSINCOS
FSINCOS - Compute both fsin and fcos as a single operation.
Definition: ISDOpcodes.h:960
llvm::ISD::CopyFromReg
@ CopyFromReg
CopyFromReg - This node indicates that the input value is a virtual or physical register that is defi...
Definition: ISDOpcodes.h:208
llvm::ISD::USUBO
@ USUBO
Definition: ISDOpcodes.h:328
llvm::ISD::FCBRT
@ FCBRT
Definition: ISDOpcodes.h:914
llvm::ISD::SETOLE
@ SETOLE
Definition: ISDOpcodes.h:1431
llvm::ISD::SETUGT
@ SETUGT
Definition: ISDOpcodes.h:1436
llvm::ISD::VALUETYPE
@ VALUETYPE
Definition: ISDOpcodes.h:72
llvm::ISD::VECREDUCE_FMUL
@ VECREDUCE_FMUL
Definition: ISDOpcodes.h:1273
llvm::ISD::ATOMIC_LOAD_FADD
@ ATOMIC_LOAD_FADD
Definition: ISDOpcodes.h:1196
llvm::ISD::POST_INC
@ POST_INC
Definition: ISDOpcodes.h:1373
llvm::ISD::TargetConstantFP
@ TargetConstantFP
Definition: ISDOpcodes.h:159
llvm::ISD::FPOW
@ FPOW
Definition: ISDOpcodes.h:918
llvm::ISD::FADD
@ FADD
Simple binary floating point operators.
Definition: ISDOpcodes.h:390
llvm::ISD::BlockAddress
@ BlockAddress
Definition: ISDOpcodes.h:84
llvm::ISD::AVGCEILU
@ AVGCEILU
Definition: ISDOpcodes.h:649
llvm::ISD::SETUNE
@ SETUNE
Definition: ISDOpcodes.h:1440
G
const DataFlowGraph & G
Definition: RDFGraph.cpp:200
llvm::ISD::STRICT_FSETCCS
@ STRICT_FSETCCS
Definition: ISDOpcodes.h:476
llvm::ISD::STRICT_FMINIMUM
@ STRICT_FMINIMUM
Definition: ISDOpcodes.h:435
llvm::ISD::SMIN
@ SMIN
[US]{MIN/MAX} - Binary minimum or maximum of signed or unsigned integers.
Definition: ISDOpcodes.h:660
llvm::ISD::WRITE_REGISTER
@ WRITE_REGISTER
Definition: ISDOpcodes.h:119
llvm::ISD::FMINIMUM
@ FMINIMUM
FMINIMUM/FMAXIMUM - NaN-propagating minimum/maximum that also treat -0.0 as less than 0....
Definition: ISDOpcodes.h:956
BasicBlock.h
llvm::cl::opt< bool >
llvm::ISD::AVGCEILS
@ AVGCEILS
AVGCEILS/AVGCEILU - Rounding averaging add - Add two integers using an integer of type i[N+2],...
Definition: ISDOpcodes.h:648
llvm::ISD::Register
@ Register
Definition: ISDOpcodes.h:74
llvm::ISD::GET_DYNAMIC_AREA_OFFSET
@ GET_DYNAMIC_AREA_OFFSET
GET_DYNAMIC_AREA_OFFSET - get offset from native SP to the address of the most recent dynamic alloca.
Definition: ISDOpcodes.h:1240
llvm::ISD::SADDO
@ SADDO
RESULT, BOOL = [SU]ADDO(LHS, RHS) - Overflow-aware nodes for addition.
Definition: ISDOpcodes.h:323
llvm::ISD::FLOG10
@ FLOG10
Definition: ISDOpcodes.h:921
llvm::ISD::VECREDUCE_FMIN
@ VECREDUCE_FMIN
Definition: ISDOpcodes.h:1276
llvm::ISD::FMAD
@ FMAD
FMAD - Perform a * b + c, while getting the same result as the separately rounded operations.
Definition: ISDOpcodes.h:486
llvm::ISD::LOCAL_RECOVER
@ LOCAL_RECOVER
LOCAL_RECOVER - Represents the llvm.localrecover intrinsic.
Definition: ISDOpcodes.h:114
llvm::ISD::ATOMIC_FENCE
@ ATOMIC_FENCE
OUTCHAIN = ATOMIC_FENCE(INCHAIN, ordering, scope) This corresponds to the fence instruction.
Definition: ISDOpcodes.h:1155
llvm::ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS
@ ATOMIC_CMP_SWAP_WITH_SUCCESS
Val, Success, OUTCHAIN = ATOMIC_CMP_SWAP_WITH_SUCCESS(INCHAIN, ptr, cmp, swap) N.b.
Definition: ISDOpcodes.h:1176
llvm::ISD::ATOMIC_LOAD_MIN
@ ATOMIC_LOAD_MIN
Definition: ISDOpcodes.h:1192
llvm::ISD::FP_TO_UINT
@ FP_TO_UINT
Definition: ISDOpcodes.h:820
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::ConstantFPSDNode
Definition: SelectionDAGNodes.h:1630
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:644
llvm::ISD::VECREDUCE_ADD
@ VECREDUCE_ADD
Integer reductions may have a result type larger than the vector element type.
Definition: ISDOpcodes.h:1280
llvm::ISD::LOAD
@ LOAD
LOAD and STORE have token chains as their first operand, then the same operands as an LLVM load/store...
Definition: ISDOpcodes.h:966
llvm::ISD::VECREDUCE_SMAX
@ VECREDUCE_SMAX
Definition: ISDOpcodes.h:1285
llvm::ISD::AssertZext
@ AssertZext
Definition: ISDOpcodes.h:62
llvm::SDNode::print_details
void print_details(raw_ostream &OS, const SelectionDAG *G) const
Definition: SelectionDAGDumper.cpp:567
llvm::ISD::SRCVALUE
@ SRCVALUE
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:1098
llvm::ISD::STRICT_LRINT
@ STRICT_LRINT
Definition: ISDOpcodes.h:432
llvm::ISD::TRAP
@ TRAP
TRAP - Trapping instruction.
Definition: ISDOpcodes.h:1133
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:54
llvm::ISD::SPONENTRY
@ SPONENTRY
SPONENTRY - Represents the llvm.sponentry intrinsic.
Definition: ISDOpcodes.h:106
llvm::ISD::SSUBO_CARRY
@ SSUBO_CARRY
Definition: ISDOpcodes.h:314
llvm::nodes
iterator_range< typename GraphTraits< GraphType >::nodes_iterator > nodes(const GraphType &G)
Definition: GraphTraits.h:110
llvm::ISD::EXTRACT_VECTOR_ELT
@ EXTRACT_VECTOR_ELT
EXTRACT_VECTOR_ELT(VECTOR, IDX) - Returns a single element from VECTOR identified by the (potentially...
Definition: ISDOpcodes.h:534
llvm::ISD::VECREDUCE_FADD
@ VECREDUCE_FADD
These reductions have relaxed evaluation order semantics, and have a single vector operand.
Definition: ISDOpcodes.h:1272
llvm::ISD::CLEANUPRET
@ CLEANUPRET
CLEANUPRET - Represents a return from a cleanup block funclet.
Definition: ISDOpcodes.h:1048
llvm::ISD::CTLZ_ZERO_UNDEF
@ CTLZ_ZERO_UNDEF
Definition: ISDOpcodes.h:709
llvm::ISD::ATOMIC_LOAD_NAND
@ ATOMIC_LOAD_NAND
Definition: ISDOpcodes.h:1191
llvm::SDNode::getOperand
const SDValue & getOperand(unsigned Num) const
Definition: SelectionDAGNodes.h:918
PrintNodeId
static Printable PrintNodeId(const SDNode &Node)
Definition: SelectionDAGDumper.cpp:512
llvm::ISD::VECREDUCE_SEQ_FMUL
@ VECREDUCE_SEQ_FMUL
Definition: ISDOpcodes.h:1260
llvm::ISD::LRINT
@ LRINT
Definition: ISDOpcodes.h:933
StringExtras.h
llvm::ISD::FP_TO_FP16
@ FP_TO_FP16
Definition: ISDOpcodes.h:897
llvm::ISD::ATOMIC_CMP_SWAP
@ ATOMIC_CMP_SWAP
Val, OUTCHAIN = ATOMIC_CMP_SWAP(INCHAIN, ptr, cmp, swap) For double-word atomic operations: ValLo,...
Definition: ISDOpcodes.h:1170
llvm::ISD::UADDSAT
@ UADDSAT
Definition: ISDOpcodes.h:341
llvm::ISD::ATOMIC_LOAD_ADD
@ ATOMIC_LOAD_ADD
Definition: ISDOpcodes.h:1185
MachineConstantPool.h
llvm::ISD::SSUBSAT
@ SSUBSAT
RESULT = [US]SUBSAT(LHS, RHS) - Perform saturation subtraction on 2 integers with the same bit width ...
Definition: ISDOpcodes.h:349
llvm::ISD::FCOPYSIGN
@ FCOPYSIGN
FCOPYSIGN(X, Y) - Return the value of X with the sign of Y.
Definition: ISDOpcodes.h:492
llvm::SDNode::dump
void dump() const
Dump this node, for debugging.
Definition: SelectionDAGDumper.cpp:549
llvm::MachineSDNode::mmo_iterator
ArrayRef< MachineMemOperand * >::const_iterator mmo_iterator
Definition: SelectionDAGNodes.h:2919
printMemOperand
static void printMemOperand(raw_ostream &OS, const MachineMemOperand &MMO, const MachineFunction *MF, const Module *M, const MachineFrameInfo *MFI, const TargetInstrInfo *TII, LLVMContext &Ctx)
Definition: SelectionDAGDumper.cpp:523
llvm::ISD::MSTORE
@ MSTORE
Definition: ISDOpcodes.h:1208
llvm::ISD::STRICT_LROUND
@ STRICT_LROUND
Definition: ISDOpcodes.h:430
llvm::ISD::SETOGT
@ SETOGT
Definition: ISDOpcodes.h:1428
llvm::ISD::ADJUST_TRAMPOLINE
@ ADJUST_TRAMPOLINE
ADJUST_TRAMPOLINE - This corresponds to the adjust_trampoline intrinsic.
Definition: ISDOpcodes.h:1130
llvm::ISD::MULHS
@ MULHS
Definition: ISDOpcodes.h:638
llvm::MVT::Other
@ Other
Definition: MachineValueType.h:42
llvm::MachineFunction::getFrameInfo
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
Definition: MachineFunction.h:672
llvm::ISD::SETULT
@ SETULT
Definition: ISDOpcodes.h:1438
llvm::ISD::DEBUGTRAP
@ DEBUGTRAP
DEBUGTRAP - Trap intended to get the attention of a debugger.
Definition: ISDOpcodes.h:1136
llvm::SDNode::print
void print(raw_ostream &OS, const SelectionDAG *G=nullptr) const
Definition: SelectionDAGDumper.cpp:1060
llvm::ISD::STACKMAP
@ STACKMAP
Definition: ISDOpcodes.h:1293
llvm::ISD::EH_DWARF_CFA
@ EH_DWARF_CFA
EH_DWARF_CFA - This node represents the pointer to the DWARF Canonical Frame Address (CFA),...
Definition: ISDOpcodes.h:129
llvm::ISD::BasicBlock
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
llvm::ISD::SDIVFIXSAT
@ SDIVFIXSAT
Same as the corresponding unsaturated fixed point instructions, but the result is clamped between the...
Definition: ISDOpcodes.h:386
llvm::ISD::VECREDUCE_AND
@ VECREDUCE_AND
Definition: ISDOpcodes.h:1282
llvm::ISD::TargetGlobalTLSAddress
@ TargetGlobalTLSAddress
Definition: ISDOpcodes.h:165
llvm::ISD::RETURNADDR
@ RETURNADDR
Definition: ISDOpcodes.h:95
llvm::ISD::SUBCARRY
@ SUBCARRY
Definition: ISDOpcodes.h:304
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::TargetLowering::getTargetNodeName
virtual const char * getTargetNodeName(unsigned Opcode) const
This method returns the name of a target specific DAG node.
Definition: TargetLowering.cpp:41
llvm::ISD::POST_DEC
@ POST_DEC
Definition: ISDOpcodes.h:1373
llvm::ISD::STRICT_LLRINT
@ STRICT_LLRINT
Definition: ISDOpcodes.h:433
llvm::ISD::SRA_PARTS
@ SRA_PARTS
Definition: ISDOpcodes.h:750
llvm::ISD::VASTART
@ VASTART
Definition: ISDOpcodes.h:1087
llvm::SDNode::isMachineOpcode
bool isMachineOpcode() const
Test if this node has a post-isel opcode, directly corresponding to a MachineInstr opcode.
Definition: SelectionDAGNodes.h:697
llvm::ISD::TargetBlockAddress
@ TargetBlockAddress
Definition: ISDOpcodes.h:170
llvm::MachineFunction
Definition: MachineFunction.h:257
llvm::ISD::ANNOTATION_LABEL
@ ANNOTATION_LABEL
ANNOTATION_LABEL - Represents a mid basic block label used by annotations.
Definition: ISDOpcodes.h:1039
llvm::ISD::VSCALE
@ VSCALE
VSCALE(IMM) - Returns the runtime scaling factor used to calculate the number of elements within a sc...
Definition: ISDOpcodes.h:1249
llvm::ISD::STRICT_FROUNDEVEN
@ STRICT_FROUNDEVEN
Definition: ISDOpcodes.h:428
llvm::ISD::HANDLENODE
@ HANDLENODE
HANDLENODE node - Used as a handle for various purposes.
Definition: ISDOpcodes.h:1116
llvm::ISD::STRICT_FEXP
@ STRICT_FEXP
Definition: ISDOpcodes.h:416
llvm::ISD::ConstantPool
@ ConstantPool
Definition: ISDOpcodes.h:82
llvm::ISD::FMAXIMUM
@ FMAXIMUM
Definition: ISDOpcodes.h:957
llvm::ISD::GlobalTLSAddress
@ GlobalTLSAddress
Definition: ISDOpcodes.h:79
llvm::ISD::UBSANTRAP
@ UBSANTRAP
UBSANTRAP - Trap with an immediate describing the kind of sanitizer failure.
Definition: ISDOpcodes.h:1140
llvm::ISD::TargetConstantPool
@ TargetConstantPool
Definition: ISDOpcodes.h:168
llvm::SDNode::print_types
void print_types(raw_ostream &OS, const SelectionDAG *G) const
Definition: SelectionDAGDumper.cpp:557
llvm::ISD::STRICT_FCOS
@ STRICT_FCOS
Definition: ISDOpcodes.h:415
llvm::ISD::UMAX
@ UMAX
Definition: ISDOpcodes.h:663
llvm::ISD::PRE_INC
@ PRE_INC
Definition: ISDOpcodes.h:1373
llvm::ISD::SETTRUE2
@ SETTRUE2
Definition: ISDOpcodes.h:1450
llvm::ISD::STRICT_FTRUNC
@ STRICT_FTRUNC
Definition: ISDOpcodes.h:429
llvm::APFloatBase::IEEEdouble
static const fltSemantics & IEEEdouble() LLVM_READNONE
Definition: APFloat.cpp:173
llvm::ISD::ABDU
@ ABDU
Definition: ISDOpcodes.h:656
llvm::ISD::STRICT_SINT_TO_FP
@ STRICT_SINT_TO_FP
STRICT_[US]INT_TO_FP - Convert a signed or unsigned integer to a floating point value.
Definition: ISDOpcodes.h:448
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::ISD::SREM
@ SREM
Definition: ISDOpcodes.h:244
llvm::ISD::LLRINT
@ LLRINT
Definition: ISDOpcodes.h:934
llvm::ISD::UMUL_LOHI
@ UMUL_LOHI
Definition: ISDOpcodes.h:251
llvm::ISD::ATOMIC_LOAD_SUB
@ ATOMIC_LOAD_SUB
Definition: ISDOpcodes.h:1186
llvm::ISD::STRICT_FSUB
@ STRICT_FSUB
Definition: ISDOpcodes.h:401
Compiler.h
TargetSubtargetInfo.h
llvm::SDNode::getIndexedModeName
static const char * getIndexedModeName(ISD::MemIndexedMode AM)
Definition: SelectionDAGDumper.cpp:502
llvm::ISD::FEXP
@ FEXP
Definition: ISDOpcodes.h:922
llvm::ISD::UNDEF
@ UNDEF
UNDEF - An undefined node.
Definition: ISDOpcodes.h:211
llvm::ISD::SMUL_LOHI
@ SMUL_LOHI
SMUL_LOHI/UMUL_LOHI - Multiply two integers of type iN, producing a signed/unsigned value of type i[2...
Definition: ISDOpcodes.h:250
llvm::ISD::BUILTIN_OP_END
@ BUILTIN_OP_END
BUILTIN_OP_END - This must be the last enum value in this list.
Definition: ISDOpcodes.h:1307
llvm::ISD::UMULFIX
@ UMULFIX
Definition: ISDOpcodes.h:368
llvm::ISD::SETFALSE
@ SETFALSE
Definition: ISDOpcodes.h:1426
llvm::ISD::FEXP2
@ FEXP2
Definition: ISDOpcodes.h:923
llvm::ISD::STRICT_FP_EXTEND
@ STRICT_FP_EXTEND
X = STRICT_FP_EXTEND(Y) - Extend a smaller FP type into a larger FP type.
Definition: ISDOpcodes.h:469
llvm::ISD::VECREDUCE_XOR
@ VECREDUCE_XOR
Definition: ISDOpcodes.h:1284
llvm::ISD::FMUL
@ FMUL
Definition: ISDOpcodes.h:392
llvm::ISD::ATOMIC_SWAP
@ ATOMIC_SWAP
Val, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amt) Val, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN,...
Definition: ISDOpcodes.h:1184
llvm::ISD::VECTOR_SPLICE
@ VECTOR_SPLICE
VECTOR_SPLICE(VEC1, VEC2, IMM) - Returns a subvector of the same type as VEC1/VEC2 from CONCAT_VECTOR...
Definition: ISDOpcodes.h:598
llvm::ISD::CARRY_FALSE
@ CARRY_FALSE
CARRY_FALSE - This node is used when folding other nodes, like ADDC/SUBC, which indicate the carry re...
Definition: ISDOpcodes.h:260
llvm::ISD::SSHLSAT
@ SSHLSAT
RESULT = [US]SHLSAT(LHS, RHS) - Perform saturation left shift.
Definition: ISDOpcodes.h:359
llvm::ISD::PCMARKER
@ PCMARKER
PCMARKER - This corresponds to the pcmarker intrinsic.
Definition: ISDOpcodes.h:1105
llvm::ISD::INTRINSIC_WO_CHAIN
@ INTRINSIC_WO_CHAIN
RESULT = INTRINSIC_WO_CHAIN(INTRINSICID, arg1, arg2, ...) This node represents a target intrinsic fun...
Definition: ISDOpcodes.h:184
llvm::ISD::XOR
@ XOR
Definition: ISDOpcodes.h:668
llvm::SDNode::getOperationName
std::string getOperationName(const SelectionDAG *G=nullptr) const
Return the opcode of this operation for printing.
Definition: SelectionDAGDumper.cpp:58
llvm::ISD::FRAMEADDR
@ FRAMEADDR
FRAMEADDR, RETURNADDR - These nodes represent llvm.frameaddress and llvm.returnaddress on the DAG.
Definition: ISDOpcodes.h:94
llvm::ISD::FrameIndex
@ FrameIndex
Definition: ISDOpcodes.h:80
llvm::ISD::FSQRT
@ FSQRT
Definition: ISDOpcodes.h:913
llvm::EVT::getEVTString
std::string getEVTString() const
This function returns value type as a string, e.g. "i32".
Definition: ValueTypes.cpp:152
llvm::ISD::INSERT_SUBVECTOR
@ INSERT_SUBVECTOR
INSERT_SUBVECTOR(VECTOR1, VECTOR2, IDX) - Returns a vector with VECTOR2 inserted into VECTOR1.
Definition: ISDOpcodes.h:558
llvm::ISD::READ_REGISTER
@ READ_REGISTER
READ_REGISTER, WRITE_REGISTER - This node represents llvm.register on the DAG, which implements the n...
Definition: ISDOpcodes.h:118
llvm::ISD::SETLT
@ SETLT
Definition: ISDOpcodes.h:1447
llvm::ISD::STRICT_FMUL
@ STRICT_FMUL
Definition: ISDOpcodes.h:402
llvm::ISD::STRICT_FMA
@ STRICT_FMA
Definition: ISDOpcodes.h:405
llvm::ISD::FMAXNUM
@ FMAXNUM
Definition: ISDOpcodes.h:944
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
llvm::GlobalAddressSDNode
Definition: SelectionDAGNodes.h:1751
llvm::MachineFunction::getFunction
Function & getFunction()
Return the LLVM function that this machine code represents.
Definition: MachineFunction.h:622
llvm::ISD::EXTRACT_SUBVECTOR
@ EXTRACT_SUBVECTOR
EXTRACT_SUBVECTOR(VECTOR, IDX) - Returns a subvector from VECTOR.
Definition: ISDOpcodes.h:572
llvm::ISD::FP_TO_SINT_SAT
@ FP_TO_SINT_SAT
FP_TO_[US]INT_SAT - Convert floating point value in operand 0 to a signed or unsigned scalar integer ...
Definition: ISDOpcodes.h:838
llvm::ISD::SADDO_CARRY
@ SADDO_CARRY
Carry-using overflow-aware nodes for multiple precision addition and subtraction.
Definition: ISDOpcodes.h:313
get
Should compile to something r4 addze r3 instead we get
Definition: README.txt:24
llvm::ISD::VECREDUCE_MUL
@ VECREDUCE_MUL
Definition: ISDOpcodes.h:1281
llvm::ISD::UMULFIXSAT
@ UMULFIXSAT
Definition: ISDOpcodes.h:374
llvm::ISD::STRICT_FP_TO_FP16
@ STRICT_FP_TO_FP16
Definition: ISDOpcodes.h:899
llvm::ISD::BR
@ BR
Control flow instructions. These all have token chains.
Definition: ISDOpcodes.h:982
llvm::ISD::TargetExternalSymbol
@ TargetExternalSymbol
Definition: ISDOpcodes.h:169
llvm::ISD::FCOS
@ FCOS
Definition: ISDOpcodes.h:916
llvm::ISD::FCEIL
@ FCEIL
Definition: ISDOpcodes.h:924
llvm::ISD::FSIN
@ FSIN
Definition: ISDOpcodes.h:915
ISDOpcodes.h
llvm::ISD::INLINEASM_BR
@ INLINEASM_BR
INLINEASM_BR - Branching version of inline asm. Used by asm-goto.
Definition: ISDOpcodes.h:1028
llvm::ISD::BUILD_VECTOR
@ BUILD_VECTOR
BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a fixed-width vector with the specified,...
Definition: ISDOpcodes.h:514
Casting.h
llvm::ISD::STRICT_FCEIL
@ STRICT_FCEIL
Definition: ISDOpcodes.h:425
llvm::ISD::FRAME_TO_ARGS_OFFSET
@ FRAME_TO_ARGS_OFFSET
FRAME_TO_ARGS_OFFSET - This node represents offset from frame pointer to first (possible) on-stack ar...
Definition: ISDOpcodes.h:124
Function.h
llvm::ISD::SUBC
@ SUBC
Definition: ISDOpcodes.h:270
llvm::ISD::VECREDUCE_OR
@ VECREDUCE_OR
Definition: ISDOpcodes.h:1283
llvm::ISD::SETUO
@ SETUO
Definition: ISDOpcodes.h:1434
llvm::ISD::SDIV
@ SDIV
Definition: ISDOpcodes.h:242
llvm::ISD::TargetConstant
@ TargetConstant
TargetConstant* - Like Constant*, but the DAG does not do any folding, simplification,...
Definition: ISDOpcodes.h:158
llvm::ISD::PREALLOCATED_ARG
@ PREALLOCATED_ARG
Definition: ISDOpcodes.h:1094
llvm::SDNode::getNumValues
unsigned getNumValues() const
Return the number of values defined/returned by this operator.
Definition: SelectionDAGNodes.h:980
llvm::ISD::EH_RETURN
@ EH_RETURN
OUTCHAIN = EH_RETURN(INCHAIN, OFFSET, HANDLER) - This node represents 'eh_return' gcc dwarf builtin,...
Definition: ISDOpcodes.h:135
hasNoSignedWrap
static bool hasNoSignedWrap(BinaryOperator &I)
Definition: InstructionCombining.cpp:303
llvm::ISD::STORE
@ STORE
Definition: ISDOpcodes.h:967
llvm::ISD::VACOPY
@ VACOPY
VACOPY - VACOPY has 5 operands: an input chain, a destination pointer, a source pointer,...
Definition: ISDOpcodes.h:1082
llvm::ISD::SRL_PARTS
@ SRL_PARTS
Definition: ISDOpcodes.h:751
llvm::ISD::UINT_TO_FP
@ UINT_TO_FP
Definition: ISDOpcodes.h:774
llvm::ISD::ADD
@ ADD
Simple integer binary arithmetic operators.
Definition: ISDOpcodes.h:239
llvm::ISD::SSUBO
@ SSUBO
Same for subtraction.
Definition: ISDOpcodes.h:327
llvm::SDNode::getMachineOpcode
unsigned getMachineOpcode() const
This may only be called if isMachineOpcode returns true.
Definition: SelectionDAGNodes.h:702
llvm::ISD::STRICT_FFLOOR
@ STRICT_FFLOOR
Definition: ISDOpcodes.h:426
llvm::ISD::IS_FPCLASS
@ IS_FPCLASS
Performs a check of floating point class property, defined by IEEE-754.
Definition: ISDOpcodes.h:506
llvm::ISD::SETOGE
@ SETOGE
Definition: ISDOpcodes.h:1429
llvm::ISD::FP_EXTEND
@ FP_EXTEND
X = FP_EXTEND(Y) - Extend a smaller FP type into a larger FP type.
Definition: ISDOpcodes.h:871
llvm::MachineFrameInfo
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
Definition: MachineFrameInfo.h:105
llvm::ISD::FGETSIGN
@ FGETSIGN
INT = FGETSIGN(FP) - Return the sign bit of the specified floating point value as an integer 0/1 valu...
Definition: ISDOpcodes.h:496
llvm::ISD::RegisterMask
@ RegisterMask
Definition: ISDOpcodes.h:75
llvm::ISD::FSUB
@ FSUB
Definition: ISDOpcodes.h:391
llvm::ISD::PREFETCH
@ PREFETCH
PREFETCH - This corresponds to a prefetch intrinsic.
Definition: ISDOpcodes.h:1146
llvm::ISD::BF16_TO_FP
@ BF16_TO_FP
BF16_TO_FP, FP_TO_BF16 - These operators are used to perform promotions and truncation for bfloat16.
Definition: ISDOpcodes.h:905
llvm::ISD::SHL
@ SHL
Shift and rotation operations.
Definition: ISDOpcodes.h:691
llvm::ISD::READCYCLECOUNTER
@ READCYCLECOUNTER
READCYCLECOUNTER - This corresponds to the readcyclecounter intrinsic.
Definition: ISDOpcodes.h:1113
llvm::ISD::FREM
@ FREM
Definition: ISDOpcodes.h:394
llvm::Printable
Simple wrapper around std::function<void(raw_ostream&)>.
Definition: Printable.h:38
llvm::ISD::MUL
@ MUL
Definition: ISDOpcodes.h:241
llvm::ISD::UREM
@ UREM
Definition: ISDOpcodes.h:245
TargetIntrinsicInfo.h
llvm::ISD::ZERO_EXTEND_VECTOR_INREG
@ ZERO_EXTEND_VECTOR_INREG
ZERO_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register zero-extension of the low ...
Definition: ISDOpcodes.h:814
llvm::ISD::BITREVERSE
@ BITREVERSE
Definition: ISDOpcodes.h:704
llvm::ISD::SUBE
@ SUBE
Definition: ISDOpcodes.h:280
llvm::ISD::SRL
@ SRL
Definition: ISDOpcodes.h:693
llvm::ISD::ADDROFRETURNADDR
@ ADDROFRETURNADDR
ADDROFRETURNADDR - Represents the llvm.addressofreturnaddress intrinsic.
Definition: ISDOpcodes.h:101
llvm::ISD::CTTZ
@ CTTZ
Definition: ISDOpcodes.h:701
llvm::ISD::TargetJumpTable
@ TargetJumpTable
Definition: ISDOpcodes.h:167
llvm::ISD::STRICT_FADD
@ STRICT_FADD
Constrained versions of the binary floating point operators.
Definition: ISDOpcodes.h:400
llvm::ISD::PARITY
@ PARITY
Definition: ISDOpcodes.h:705
llvm::ISD::STRICT_LLROUND
@ STRICT_LLROUND
Definition: ISDOpcodes.h:431
llvm::ISD::UMIN
@ UMIN
Definition: ISDOpcodes.h:662
ModuleSlotTracker.h
MachineMemOperand.h
llvm::ISD::SETFALSE2
@ SETFALSE2
Definition: ISDOpcodes.h:1443
llvm::ISD::MULHU
@ MULHU
MULHU/MULHS - Multiply high - Multiply two integers of type iN, producing an unsigned/signed value of...
Definition: ISDOpcodes.h:637
llvm::ISD::LROUND
@ LROUND
Definition: ISDOpcodes.h:931
llvm::ISD::STRICT_FREM
@ STRICT_FREM
Definition: ISDOpcodes.h:404
llvm::StringRef::str
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:221
llvm::ISD::SETONE
@ SETONE
Definition: ISDOpcodes.h:1432
llvm::ISD::INTRINSIC_W_CHAIN
@ INTRINSIC_W_CHAIN
RESULT,OUTCHAIN = INTRINSIC_W_CHAIN(INCHAIN, INTRINSICID, arg1, ...) This node represents a target in...
Definition: ISDOpcodes.h:192
llvm::ISD::FNEG
@ FNEG
Perform various unary floating-point operations inspired by libm.
Definition: ISDOpcodes.h:911
llvm::ISD::STRICT_FEXP2
@ STRICT_FEXP2
Definition: ISDOpcodes.h:417
llvm::ISD::BUILD_PAIR
@ BUILD_PAIR
BUILD_PAIR - This is the opposite of EXTRACT_ELEMENT in some ways.
Definition: ISDOpcodes.h:229
llvm::ISD::VAARG
@ VAARG
VAARG - VAARG has four operands: an input chain, a pointer, a SRCVALUE, and the alignment.
Definition: ISDOpcodes.h:1077
llvm::ISD::UDIVFIX
@ UDIVFIX
Definition: ISDOpcodes.h:381
llvm::ISD::SDIVREM
@ SDIVREM
SDIVREM/UDIVREM - Divide two integers and produce both a quotient and remainder result.
Definition: ISDOpcodes.h:255
llvm::ISD::STRICT_FPOWI
@ STRICT_FPOWI
Definition: ISDOpcodes.h:413
llvm::cl::desc
Definition: CommandLine.h:412
llvm::ISD::ATOMIC_LOAD_XOR
@ ATOMIC_LOAD_XOR
Definition: ISDOpcodes.h:1190
hasNoInfs
static bool hasNoInfs(const TargetOptions &Options, SDValue N)
Definition: DAGCombiner.cpp:14212
llvm::ISD::TargetFrameIndex
@ TargetFrameIndex
Definition: ISDOpcodes.h:166
llvm::ISD::VECREDUCE_SMIN
@ VECREDUCE_SMIN
Definition: ISDOpcodes.h:1286
llvm::ISD::SIGN_EXTEND
@ SIGN_EXTEND
Conversion operators.
Definition: ISDOpcodes.h:760
raw_ostream.h
llvm::ISD::VECREDUCE_UMIN
@ VECREDUCE_UMIN
Definition: ISDOpcodes.h:1288
n
The same transformation can work with an even modulo with the addition of a and shrink the compare RHS by the same amount Unless the target supports that transformation probably isn t worthwhile The transformation can also easily be made to work with non zero equality for n
Definition: README.txt:685
llvm::ISD::FTRUNC
@ FTRUNC
Definition: ISDOpcodes.h:925
llvm::SDNode::getFlags
SDNodeFlags getFlags() const
Definition: SelectionDAGNodes.h:969
Value.h
llvm::ISD::INSERT_VECTOR_ELT
@ INSERT_VECTOR_ELT
INSERT_VECTOR_ELT(VECTOR, VAL, IDX) - Returns VECTOR with the element at IDX replaced with VAL.
Definition: ISDOpcodes.h:523
llvm::ISD::FCANONICALIZE
@ FCANONICALIZE
Returns platform specific canonical encoding of a floating point number.
Definition: ISDOpcodes.h:499
llvm::ISD::STACKSAVE
@ STACKSAVE
STACKSAVE - STACKSAVE has one operand, an input chain.
Definition: ISDOpcodes.h:1053
llvm::ISD::FLOG
@ FLOG
Definition: ISDOpcodes.h:919
llvm::ISD::ADDE
@ ADDE
Carry-using nodes for multiple precision addition and subtraction.
Definition: ISDOpcodes.h:279
llvm::ISD::FP_ROUND
@ FP_ROUND
X = FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating point type down to the precision of the ...
Definition: ISDOpcodes.h:852
llvm::ISD::ROTR
@ ROTR
Definition: ISDOpcodes.h:695
TargetRegisterInfo.h
llvm::ISD::AVGFLOORS
@ AVGFLOORS
AVGFLOORS/AVGFLOORU - Averaging add - Add two integers using an integer of type i[N+1],...
Definition: ISDOpcodes.h:643
Debug.h
llvm::ISD::SET_ROUNDING
@ SET_ROUNDING
Set rounding mode.
Definition: ISDOpcodes.h:868
llvm::ISD::ATOMIC_LOAD
@ ATOMIC_LOAD
Val, OUTCHAIN = ATOMIC_LOAD(INCHAIN, ptr) This corresponds to "load atomic" instruction.
Definition: ISDOpcodes.h:1159
llvm::ISD::SCALAR_TO_VECTOR
@ SCALAR_TO_VECTOR
SCALAR_TO_VECTOR(VAL) - This represents the operation of loading a scalar value into element 0 of the...
Definition: ISDOpcodes.h:606
llvm::ISD::CTPOP
@ CTPOP
Definition: ISDOpcodes.h:703
llvm::ISD::MCSymbol
@ MCSymbol
Definition: ISDOpcodes.h:172
llvm::ISD::SADDSAT
@ SADDSAT
RESULT = [US]ADDSAT(LHS, RHS) - Perform saturation addition on 2 integers with the same bit width (W)...
Definition: ISDOpcodes.h:340
llvm::ISD::ATOMIC_LOAD_MAX
@ ATOMIC_LOAD_MAX
Definition: ISDOpcodes.h:1193
llvm::ISD::TokenFactor
@ TokenFactor
TokenFactor - This node takes multiple tokens as input and produces a single token result.
Definition: ISDOpcodes.h:52
llvm::ISD::EXTRACT_ELEMENT
@ EXTRACT_ELEMENT
EXTRACT_ELEMENT - This is used to get the lower or upper (determined by a Constant,...
Definition: ISDOpcodes.h:222
llvm::ISD::MSCATTER
@ MSCATTER
Definition: ISDOpcodes.h:1220
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38
llvm::ISD::VSELECT
@ VSELECT
Select with a vector condition (op #0) and two vector operands (ops #1 and #2), returning a vector re...
Definition: ISDOpcodes.h:722
VerboseDAGDumping
static cl::opt< bool > VerboseDAGDumping("dag-dump-verbose", cl::Hidden, cl::desc("Display more information when dumping selection " "DAG nodes."))
llvm::ISD::FDIV
@ FDIV
Definition: ISDOpcodes.h:393
Generated on Wed Sep 28 2022 13:49:51 for LLVM by   doxygen 1.8.17