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