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