LLVM 24.0.0git
ISDOpcodes.h
Go to the documentation of this file.
1//===-- llvm/CodeGen/ISDOpcodes.h - CodeGen opcodes -------------*- C++ -*-===//
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 file declares codegen opcodes and related utilities.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CODEGEN_ISDOPCODES_H
14#define LLVM_CODEGEN_ISDOPCODES_H
15
18
19namespace llvm {
20
21class StringRef;
22
23/// ISD namespace - This namespace contains an enum which represents all of the
24/// SelectionDAG node types and value types.
25///
26namespace ISD {
27
28//===--------------------------------------------------------------------===//
29/// ISD::NodeType enum - This enum defines the target-independent operators
30/// for a SelectionDAG.
31///
32/// Targets may also define target-dependent operator codes for SDNodes. For
33/// example, on x86, these are the enum values in the X86ISD namespace.
34/// Targets should aim to use target-independent operators to model their
35/// instruction sets as much as possible, and only use target-dependent
36/// operators when they have special requirements.
37///
38/// Finally, during and after selection proper, SNodes may use special
39/// operator codes that correspond directly with MachineInstr opcodes. These
40/// are used to represent selected instructions. See the isMachineOpcode()
41/// and getMachineOpcode() member functions of SDNode.
42///
44
45 /// DELETED_NODE - This is an illegal value that is used to catch
46 /// errors. This opcode is not a legal opcode for any node.
48
49 /// EntryToken - This is the marker used to indicate the start of a region.
51
52 /// TokenFactor - This node takes multiple tokens as input and produces a
53 /// single token result. This is used to represent the fact that the operand
54 /// operators are independent of each other.
56
57 /// AssertSext, AssertZext - These nodes record if a register contains a
58 /// value that has already been zero or sign extended from a narrower type.
59 /// These nodes take two operands. The first is the node that has already
60 /// been extended, and the second is a value type node indicating the width
61 /// of the extension.
62 /// NOTE: In case of the source value (or any vector element value) is
63 /// poisoned the assertion will not be true for that value.
66
67 /// AssertAlign - These nodes record if a register contains a value that
68 /// has a known alignment and the trailing bits are known to be zero.
69 /// NOTE: In case of the source value (or any vector element value) is
70 /// poisoned the assertion will not be true for that value.
72
73 /// AssertNoFPClass - These nodes record if a register contains a float
74 /// value that is known to be not some type.
75 /// This node takes two operands. The first is the node that is known
76 /// never to be some float types; the second is a constant value with
77 /// the value of FPClassTest (casted to uint32_t).
78 /// NOTE: In case of the source value (or any vector element value) is
79 /// poisoned the assertion will not be true for that value.
81
82 /// Various leaf nodes.
97
98 /// A ptrauth constant.
99 /// ptr, key, addr-disc, disc
100 /// Note that the addr-disc can be a non-constant value, to allow representing
101 /// a constant global address signed using address-diversification, in code.
103
104 /// The address of the GOT
106
107 /// FRAMEADDR, RETURNADDR - These nodes represent llvm.frameaddress and
108 /// llvm.returnaddress on the DAG. These nodes take one operand, the index
109 /// of the frame or return address to return. An index of zero corresponds
110 /// to the current function's frame or return address, an index of one to
111 /// the parent's frame or return address, and so on.
114
115 /// ADDROFRETURNADDR - Represents the llvm.addressofreturnaddress intrinsic.
116 /// This node takes no operand, returns a target-specific pointer to the
117 /// place in the stack frame where the return address of the current
118 /// function is stored.
120
121 /// SPONENTRY - Represents the llvm.sponentry intrinsic. Takes no argument
122 /// and returns the stack pointer value at the entry of the current
123 /// function calling this intrinsic.
125
126 /// STACKADDRESS - Represents the llvm.stackaddress intrinsic. Takes no
127 /// argument and returns the starting address of the stack region that may be
128 /// used by called functions.
130
131 /// LOCAL_RECOVER - Represents the llvm.localrecover intrinsic.
132 /// Materializes the offset from the local object pointer of another
133 /// function to a particular local object passed to llvm.localescape. The
134 /// operand is the MCSymbol label used to represent this offset, since
135 /// typically the offset is not known until after code generation of the
136 /// parent.
138
139 /// READ_REGISTER, WRITE_REGISTER - This node represents llvm.register on
140 /// the DAG, which implements the named register global variables extension.
143
144 /// FRAME_TO_ARGS_OFFSET - This node represents offset from frame pointer to
145 /// first (possible) on-stack argument. This is needed for correct stack
146 /// adjustment during unwind.
148
149 /// EH_DWARF_CFA - This node represents the pointer to the DWARF Canonical
150 /// Frame Address (CFA), generally the value of the stack pointer at the
151 /// call site in the previous frame.
153
154 /// OUTCHAIN = EH_RETURN(INCHAIN, OFFSET, HANDLER) - This node represents
155 /// 'eh_return' gcc dwarf builtin, which is used to return from
156 /// exception. The general meaning is: adjust stack by OFFSET and pass
157 /// execution to HANDLER. Many platform-related details also :)
159
160 /// RESULT, OUTCHAIN = EH_SJLJ_SETJMP(INCHAIN, buffer)
161 /// This corresponds to the eh.sjlj.setjmp intrinsic.
162 /// It takes an input chain and a pointer to the jump buffer as inputs
163 /// and returns an outchain.
165
166 /// OUTCHAIN = EH_SJLJ_LONGJMP(INCHAIN, buffer)
167 /// This corresponds to the eh.sjlj.longjmp intrinsic.
168 /// It takes an input chain and a pointer to the jump buffer as inputs
169 /// and returns an outchain.
171
172 /// OUTCHAIN = EH_SJLJ_SETUP_DISPATCH(INCHAIN)
173 /// The target initializes the dispatch table here.
175
176 /// TargetConstant* - Like Constant*, but the DAG does not do any folding,
177 /// simplification, or lowering of the constant. They are used for constants
178 /// which are known to fit in the immediate fields of their users, or for
179 /// carrying magic numbers which are not values which need to be
180 /// materialized in registers.
183
184 /// TargetGlobalAddress - Like GlobalAddress, but the DAG does no folding or
185 /// anything else with this node, and this is valid in the target-specific
186 /// dag, turning into a GlobalAddress operand.
194
196
197 /// TargetIndex - Like a constant pool entry, but with completely
198 /// target-dependent semantics. Holds target flags, a 32-bit index, and a
199 /// 64-bit index. Targets can use this however they like.
201
202 /// RESULT = INTRINSIC_WO_CHAIN(INTRINSICID, arg1, arg2, ...)
203 /// This node represents a target intrinsic function with no side effects.
204 /// The first operand is the ID number of the intrinsic from the
205 /// llvm::Intrinsic namespace. The operands to the intrinsic follow. The
206 /// node returns the result of the intrinsic.
208
209 /// RESULT,OUTCHAIN = INTRINSIC_W_CHAIN(INCHAIN, INTRINSICID, arg1, ...)
210 /// This node represents a target intrinsic function with side effects that
211 /// returns a result. The first operand is a chain pointer. The second is
212 /// the ID number of the intrinsic from the llvm::Intrinsic namespace. The
213 /// operands to the intrinsic follow. The node has two results, the result
214 /// of the intrinsic and an output chain.
216
217 /// OUTCHAIN = INTRINSIC_VOID(INCHAIN, INTRINSICID, arg1, arg2, ...)
218 /// This node represents a target intrinsic function with side effects that
219 /// does not return a result. The first operand is a chain pointer. The
220 /// second is the ID number of the intrinsic from the llvm::Intrinsic
221 /// namespace. The operands to the intrinsic follow.
223
224 /// CopyToReg - This node has three operands: a chain, a register number to
225 /// set to this value, and a value.
227
228 /// CopyFromReg - This node indicates that the input value is a virtual or
229 /// physical register that is defined outside of the scope of this
230 /// SelectionDAG. The register is available from the RegisterSDNode object.
231 /// Note that CopyFromReg is considered as also freezing the value.
233
234 /// UNDEF - An undefined node.
236
237 /// POISON - A poison node.
239
240 /// FREEZE - FREEZE(VAL) returns an arbitrary value if VAL is UNDEF (or
241 /// is evaluated to UNDEF), or returns VAL otherwise. Note that each
242 /// read of UNDEF can yield different value, but FREEZE(UNDEF) cannot.
244
245 /// EXTRACT_ELEMENT - This is used to get the lower or upper (determined by
246 /// a Constant, which is required to be operand #1) half of the integer or
247 /// float value specified as operand #0. This is only for use before
248 /// legalization, for values that will be broken into multiple registers.
250
251 /// BUILD_PAIR - This is the opposite of EXTRACT_ELEMENT in some ways.
252 /// Given two values of the same integer value type, this produces a value
253 /// twice as big. Like EXTRACT_ELEMENT, this can only be used before
254 /// legalization. The lower part of the composite value should be in
255 /// element 0 and the upper part should be in element 1.
257
258 /// MERGE_VALUES - This node takes multiple discrete operands and returns
259 /// them all as its individual results. This nodes has exactly the same
260 /// number of inputs and outputs. This node is useful for some pieces of the
261 /// code generator that want to think about a single node with multiple
262 /// results, not multiple nodes.
264
265 /// Simple integer binary arithmetic operators.
273
274 /// SMUL_LOHI/UMUL_LOHI - Multiply two integers of type iN, producing
275 /// a signed/unsigned value of type i[2*N], and return the full value as
276 /// two results, each of type iN.
279
280 /// SDIVREM/UDIVREM - Divide two integers and produce both a quotient and
281 /// remainder result.
284
285 /// CARRY_FALSE - This node is used when folding other nodes,
286 /// like ADDC/SUBC, which indicate the carry result is always false.
288
289 /// Carry-setting nodes for multiple precision addition and subtraction.
290 /// These nodes take two operands of the same value type, and produce two
291 /// results. The first result is the normal add or sub result, the second
292 /// result is the carry flag result as a glue.
293 /// FIXME: These nodes are deprecated in favor of UADDO_CARRY and USUBO_CARRY.
294 /// They are kept around for now to provide a smooth transition path
295 /// toward the use of UADDO_CARRY/USUBO_CARRY and will eventually be removed.
298
299 /// Carry-using nodes for multiple precision addition and subtraction. These
300 /// nodes take three operands: The first two are the normal lhs and rhs to
301 /// the add or sub, and the third is the input carry flag as a glue. These
302 /// nodes produce two results; the normal result of the add or sub, and the
303 /// output carry flag as a glue. These nodes both read and write a carry flag
304 /// to allow them to them to be chained together for add and sub of
305 /// arbitrarily large values.
308
309 /// Carry-using nodes for multiple precision addition and subtraction.
310 /// These nodes take three operands: The first two are the normal lhs and
311 /// rhs to the add or sub, and the third is a boolean value that is true if
312 /// and only if there is an incoming carry/borrow. These nodes produce two
313 /// results: the normal result of the add or sub, and a boolean value that is
314 /// true if and only if there is an outgoing carry/borrow. If the type of the
315 /// boolean is not i1 then the high bits conform to getBooleanContents.
316 ///
317 /// Care must be taken if these opcodes are lowered to hardware instructions
318 /// that use the inverse logic -- false if and only if there is an
319 /// incoming/outgoing carry/borrow. In such cases, you must preserve the
320 /// semantics of these opcodes by inverting the incoming carry/borrow, feeding
321 /// it to the add/sub hardware instruction, and then inverting the outgoing
322 /// carry/borrow.
323 ///
324 /// The use of these opcodes is preferable to ADDE/SUBE if the target supports
325 /// it, as the carry is a regular value rather than a glue, which allows
326 /// further optimisation.
327 ///
328 /// These opcodes are different from [US]{ADD,SUB}O in that
329 /// U{ADD,SUB}O_CARRY consume and produce a carry/borrow, whereas
330 /// [US]{ADD,SUB}O produce an overflow.
333
334 /// Carry-using overflow-aware nodes for multiple precision addition and
335 /// subtraction. These nodes take three operands: The first two are normal lhs
336 /// and rhs to the add or sub, and the third is a boolean indicating if there
337 /// is an incoming carry. They produce two results: the normal result of the
338 /// add or sub, and a boolean that indicates if an overflow occurred (*not*
339 /// flag, because it may be a store to memory, etc.). If the type of the
340 /// boolean is not i1 then the high bits conform to getBooleanContents.
343
344 /// RESULT, BOOL = [SU]ADDO(LHS, RHS) - Overflow-aware nodes for addition.
345 /// These nodes take two operands: the normal LHS and RHS to the add. They
346 /// produce two results: the normal result of the add, and a boolean that
347 /// indicates if an overflow occurred (*not* a flag, because it may be store
348 /// to memory, etc.). If the type of the boolean is not i1 then the high
349 /// bits conform to getBooleanContents.
350 /// These nodes are generated from llvm.[su]add.with.overflow intrinsics.
353
354 /// Same for subtraction.
357
358 /// Same for multiplication.
361
362 /// RESULT = [US]ADDSAT(LHS, RHS) - Perform saturation addition on 2
363 /// integers with the same bit width (W). If the true value of LHS + RHS
364 /// exceeds the largest value that can be represented by W bits, the
365 /// resulting value is this maximum value. Otherwise, if this value is less
366 /// than the smallest value that can be represented by W bits, the
367 /// resulting value is this minimum value.
370
371 /// RESULT = [US]SUBSAT(LHS, RHS) - Perform saturation subtraction on 2
372 /// integers with the same bit width (W). If the true value of LHS - RHS
373 /// exceeds the largest value that can be represented by W bits, the
374 /// resulting value is this maximum value. Otherwise, if this value is less
375 /// than the smallest value that can be represented by W bits, the
376 /// resulting value is this minimum value.
379
380 /// RESULT = [US]SHLSAT(LHS, RHS) - Perform saturation left shift. The first
381 /// operand is the value to be shifted, and the second argument is the amount
382 /// to shift by. Both must be integers. After legalization the type of the
383 /// shift amount is known to be TLI.getShiftAmountTy(). Before legalization
384 /// the shift amount can be any type, but care must be taken to ensure it is
385 /// large enough. If the true value of LHS << RHS exceeds the largest value
386 /// that can be represented by W bits, the resulting value is this maximum
387 /// value, Otherwise, if this value is less than the smallest value that can
388 /// be represented by W bits, the resulting value is this minimum value.
391
392 /// RESULT = [US]MULFIX(LHS, RHS, SCALE) - Perform fixed point multiplication
393 /// on 2 integers with the same width and scale. SCALE represents the scale
394 /// of both operands as fixed point numbers. This SCALE parameter must be a
395 /// constant integer. A scale of zero is effectively performing
396 /// multiplication on 2 integers.
399
400 /// Same as the corresponding unsaturated fixed point instructions, but the
401 /// result is clamped between the min and max values representable by the
402 /// bits of the first 2 operands.
405
406 /// RESULT = [US]DIVFIX(LHS, RHS, SCALE) - Perform fixed point division on
407 /// 2 integers with the same width and scale. SCALE represents the scale
408 /// of both operands as fixed point numbers. This SCALE parameter must be a
409 /// constant integer.
412
413 /// Same as the corresponding unsaturated fixed point instructions, but the
414 /// result is clamped between the min and max values representable by the
415 /// bits of the first 2 operands.
418
419 /// Simple binary floating point operators.
425
426 /// Constrained versions of the binary floating point operators.
427 /// These will be lowered to the simple operators before final selection.
428 /// They are used to limit optimizations while the DAG is being
429 /// optimized.
436
437 /// Constrained versions of libm-equivalent floating point intrinsics.
438 /// These will be lowered to the equivalent non-constrained pseudo-op
439 /// (or expanded to the equivalent library call) before final selection.
440 /// They are used to limit optimizations while the DAG is being optimized.
477
478 /// STRICT_FP_TO_[US]INT - Convert a floating point value to a signed or
479 /// unsigned integer. These have the same semantics as fptosi and fptoui
480 /// in IR.
481 /// They are used to limit optimizations while the DAG is being optimized.
484
485 /// STRICT_[US]INT_TO_FP - Convert a signed or unsigned integer to
486 /// a floating point value. These have the same semantics as sitofp and
487 /// uitofp in IR.
488 /// They are used to limit optimizations while the DAG is being optimized.
491
492 /// X = STRICT_FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating
493 /// point type down to the precision of the destination VT. TRUNC is a
494 /// flag, which is always an integer that is zero or one. If TRUNC is 0,
495 /// this is a normal rounding, if it is 1, this FP_ROUND is known to not
496 /// change the value of Y.
497 ///
498 /// The TRUNC = 1 case is used in cases where we know that the value will
499 /// not be modified by the node, because Y is not using any of the extra
500 /// precision of source type. This allows certain transformations like
501 /// STRICT_FP_EXTEND(STRICT_FP_ROUND(X,1)) -> X which are not safe for
502 /// STRICT_FP_EXTEND(STRICT_FP_ROUND(X,0)) because the extra bits aren't
503 /// removed.
504 /// It is used to limit optimizations while the DAG is being optimized.
506
507 /// X = STRICT_FP_EXTEND(Y) - Extend a smaller FP type into a larger FP
508 /// type.
509 /// It is used to limit optimizations while the DAG is being optimized.
511
512 /// STRICT_FSETCC/STRICT_FSETCCS - Constrained versions of SETCC, used
513 /// for floating-point operands only. STRICT_FSETCC performs a quiet
514 /// comparison operation, while STRICT_FSETCCS performs a signaling
515 /// comparison operation.
518
519 /// FPTRUNC_ROUND - This corresponds to the fptrunc_round intrinsic.
521
522 /// FMA - Perform a * b + c with no intermediate rounding step.
524
525 /// FMAD - Perform a * b + c, while getting the same result as the
526 /// separately rounded operations.
528
529 /// FMULADD - Performs a * b + c, with, or without, intermediate rounding.
530 /// It is expected that this will be illegal for most targets, as it usually
531 /// makes sense to split this or use an FMA. But some targets, such as
532 /// WebAssembly, can directly support these semantics.
534
535 /// FCOPYSIGN(X, Y) - Return the value of X with the sign of Y. NOTE: This
536 /// DAG node does not require that X and Y have the same type, just that
537 /// they are both floating point. X and the result must have the same type.
538 /// FCOPYSIGN(f32, f64) is allowed.
540
541 /// INT = FGETSIGN(FP) - Return the sign bit of the specified floating point
542 /// value as an integer 0/1 value.
544
545 /// Returns platform specific canonical encoding of a floating point number.
547
548 /// Performs a check of floating point class property, defined by IEEE-754.
549 /// The first operand is the floating point value to check. The second operand
550 /// specifies the checked property and is a TargetConstant which specifies
551 /// test in the same way as intrinsic 'is_fpclass'.
552 /// Returns boolean value.
554
555 /// BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a fixed-width vector
556 /// with the specified, possibly variable, elements. The types of the
557 /// operands must match the vector element type, except that integer types
558 /// are allowed to be larger than the element type, in which case the
559 /// operands are implicitly truncated. The types of the operands must all
560 /// be the same.
562
563 /// INSERT_VECTOR_ELT(VECTOR, VAL, IDX) - Returns VECTOR with the element
564 /// at IDX replaced with VAL. If the type of VAL is larger than the vector
565 /// element type then VAL is truncated before replacement.
566 ///
567 /// If VECTOR is a scalable vector, then IDX may be larger than the minimum
568 /// vector width. IDX is not first scaled by the runtime scaling factor of
569 /// VECTOR.
571
572 /// EXTRACT_VECTOR_ELT(VECTOR, IDX) - Returns a single element from VECTOR
573 /// identified by the (potentially variable) element number IDX. If the return
574 /// type is an integer type larger than the element type of the vector, the
575 /// result is extended to the width of the return type. In that case, the high
576 /// bits are undefined.
577 ///
578 /// If VECTOR is a scalable vector, then IDX may be larger than the minimum
579 /// vector width. IDX is not first scaled by the runtime scaling factor of
580 /// VECTOR.
582
583 /// CONCAT_VECTORS(VECTOR0, VECTOR1, ...) - Given a number of values of
584 /// vector type with the same length and element type, this produces a
585 /// concatenated vector result value, with length equal to the sum of the
586 /// lengths of the input vectors. If VECTOR0 is a fixed-width vector, then
587 /// VECTOR1..VECTORN must all be fixed-width vectors. Similarly, if VECTOR0
588 /// is a scalable vector, then VECTOR1..VECTORN must all be scalable vectors.
590
591 /// INSERT_SUBVECTOR(VECTOR1, VECTOR2, IDX) - Returns a vector with VECTOR2
592 /// inserted into VECTOR1. IDX represents the starting element number at which
593 /// VECTOR2 will be inserted. IDX must be a constant multiple of T's known
594 /// minimum vector length. Let the type of VECTOR2 be T, then if T is a
595 /// scalable vector, IDX is first scaled by the runtime scaling factor of T.
596 /// The elements of VECTOR1 starting at IDX are overwritten with VECTOR2.
597 /// Elements IDX through (IDX + num_elements(T) - 1) must be valid VECTOR1
598 /// indices. If this condition cannot be determined statically but is false at
599 /// runtime, then the result vector is undefined. The IDX parameter must be a
600 /// vector index constant type, which for most targets will be an integer
601 /// pointer type.
602 ///
603 /// This operation supports inserting a fixed-width vector into a scalable
604 /// vector, but not the other way around.
606
607 /// EXTRACT_SUBVECTOR(VECTOR, IDX) - Returns a subvector from VECTOR.
608 /// Let the result type be T, then IDX represents the starting element number
609 /// from which a subvector of type T is extracted. IDX must be a constant
610 /// multiple of T's known minimum vector length. If T is a scalable vector,
611 /// IDX is first scaled by the runtime scaling factor of T. Elements IDX
612 /// through (IDX + num_elements(T) - 1) must be valid VECTOR indices. If this
613 /// condition cannot be determined statically but is false at runtime, then
614 /// the result vector is undefined. The IDX parameter must be a vector index
615 /// constant type, which for most targets will be an integer pointer type.
616 ///
617 /// This operation supports extracting a fixed-width vector from a scalable
618 /// vector, but not the other way around.
620
621 /// VECTOR_DEINTERLEAVE(VEC1, VEC2, ...) - Returns N vectors from N input
622 /// vectors, where N is the factor to deinterleave. All input and output
623 /// vectors must have the same type.
624 ///
625 /// Each output contains the deinterleaved indices for a specific field from
626 /// CONCAT_VECTORS(VEC1, VEC2, ...):
627 ///
628 /// Result[I][J] = CONCAT_VECTORS(...)[I + N * J]
630
631 /// VECTOR_INTERLEAVE(VEC1, VEC2, ...) - Returns N vectors from N input
632 /// vectors, where N is the factor to interleave. All input and
633 /// output vectors must have the same type.
634 ///
635 /// All input vectors are interleaved into one wide vector, which is then
636 /// chunked into equal sized parts:
637 ///
638 /// Interleaved[I] = VEC(I % N)[I / N]
639 /// Result[J] = EXTRACT_SUBVECTOR(Interleaved, J * getVectorMinNumElements())
641
642 /// VECTOR_REPEAT(FIXED_LENGTH_VECTOR)
643 /// Repeatedly copies the elements of the source fixed-length vector to fill a
644 /// scalable vector with the same minimum element count.
646
647 /// VECTOR_REVERSE(VECTOR) - Returns a vector, of the same type as VECTOR,
648 /// whose elements are shuffled using the following algorithm:
649 /// RESULT[i] = VECTOR[VECTOR.ElementCount - 1 - i]
651
652 /// VECTOR_SHUFFLE(VEC1, VEC2) - Returns a vector, of the same type as
653 /// VEC1/VEC2. A VECTOR_SHUFFLE node also contains an array of constant int
654 /// values that indicate which value (or undef) each result element will
655 /// get. These constant ints are accessible through the
656 /// ShuffleVectorSDNode class. This is quite similar to the Altivec
657 /// 'vperm' instruction, except that the indices must be constants and are
658 /// in terms of the element size of VEC1/VEC2, not in terms of bytes.
660
661 /// VECTOR_SHUFFLE_VAR(VEC, MASK) - Returns VEC permuted by MASK, an integer
662 /// vector with the same number of elements as VEC. Result element i is
663 /// VEC[MASK[i]], with MASK[i] treated as unsigned, or poison if MASK[i] is
664 /// out of range.
666
667 /// VECTOR_SPLICE_LEFT(VEC1, VEC2, OFFSET) - Shifts CONCAT_VECTORS(VEC1, VEC2)
668 /// left by OFFSET elements and returns the lower half.
670 /// VECTOR_SPLICE_RIGHT(VEC1, VEC2, OFFSET) - Shifts CONCAT_VECTORS(VEC1,
671 /// VEC2)
672 /// right by OFFSET elements and returns the upper half.
674
675 /// SCALAR_TO_VECTOR(VAL) - This represents the operation of loading a
676 /// scalar value into element 0 of the resultant vector type. The top
677 /// elements 1 to N-1 of the N-element vector are poison. The type of
678 /// the operand must match the vector element type, except when they
679 /// are integer types. In this case the operand is allowed to be wider
680 /// than the vector element type, and is implicitly truncated to it.
682
683 /// SPLAT_VECTOR(VAL) - Returns a vector with the scalar value VAL
684 /// duplicated in all lanes. The type of the operand must match the vector
685 /// element type, except when they are integer types. In this case the
686 /// operand is allowed to be wider than the vector element type, and is
687 /// implicitly truncated to it.
689
690 /// SPLAT_VECTOR_PARTS(SCALAR1, SCALAR2, ...) - Returns a vector with the
691 /// scalar values joined together and then duplicated in all lanes. This
692 /// represents a SPLAT_VECTOR that has had its scalar operand expanded. This
693 /// allows representing a 64-bit splat on a target with 32-bit integers. The
694 /// total width of the scalars must cover the element width. SCALAR1 contains
695 /// the least significant bits of the value regardless of endianness and all
696 /// scalars should have the same type.
698
699 /// STEP_VECTOR(IMM) - Returns a scalable vector whose lanes are comprised
700 /// of a linear sequence of unsigned values starting from 0 with a step of
701 /// IMM, where IMM must be a TargetConstant with type equal to the vector
702 /// element type. The arithmetic is performed modulo the bitwidth of the
703 /// element.
704 ///
705 /// The operation does not support returning fixed-width vectors or
706 /// non-constant operands.
708
709 /// VECTOR_COMPRESS(Vec, Mask, Passthru)
710 /// consecutively place vector elements based on mask
711 /// e.g., vec = {A, B, C, D} and mask = {1, 0, 1, 0}
712 /// --> {A, C, ?, ?} where ? is undefined
713 /// If passthru is defined, ?s are replaced with elements from passthru.
714 /// If passthru is undef, ?s remain undefined.
716
717 /// MULHU/MULHS - Multiply high - Multiply two integers of type iN,
718 /// producing an unsigned/signed value of type i[2*N], then return the top
719 /// part.
722
723 /// AVGFLOORS/AVGFLOORU - Averaging add - Add two integers using an integer of
724 /// type i[N+1], halving the result by shifting it one bit right.
725 /// shr(add(ext(X), ext(Y)), 1)
728 /// AVGCEILS/AVGCEILU - Rounding averaging add - Add two integers using an
729 /// integer of type i[N+2], add 1 and halve the result by shifting it one bit
730 /// right. shr(add(ext(X), ext(Y), 1), 1)
733
734 /// AVGSUBFLOORS/AVGSUBFLOORU - Averaging subtract - Subtract two integers
735 /// using an integer of type i[N+1], halving the result by shifting it one bit
736 /// right, i.e. rounding towards negative infinity. This is a signed
737 /// difference, not an absolute difference like ABDS/ABDU.
738 /// shr(sub(ext(X), ext(Y)), 1)
741
742 /// ABDS/ABDU - Absolute difference - Return the absolute difference between
743 /// two numbers interpreted as signed/unsigned.
744 /// i.e trunc(abs(sext(Op0) - sext(Op1))) becomes abds(Op0, Op1)
745 /// or trunc(abs(zext(Op0) - zext(Op1))) becomes abdu(Op0, Op1)
748
749 /// [US]{MIN/MAX} - Binary minimum or maximum of signed or unsigned
750 /// integers.
755
756 /// [US]CMP - 3-way comparison of signed or unsigned integers. Returns -1, 0,
757 /// or 1 depending on whether Op0 <, ==, or > Op1. The operands can have type
758 /// different to the result.
761
762 /// Bitwise operators - logical and, logical or, logical xor.
766
767 /// ABS - Determine the unsigned absolute value of a signed integer value of
768 /// the same bitwidth.
769 /// Note: A value of INT_MIN will return INT_MIN, no saturation or overflow
770 /// is performed.
772
773 /// ABS with a poison result for INT_MIN. This corresponds to
774 /// llvm.abs(x, true) where the "int min is poison" flag is set.
776
777 /// Shift and rotation operations. After legalization, the type of the
778 /// shift amount is known to be TLI.getShiftAmountTy(). Before legalization
779 /// the shift amount can be any type, but care must be taken to ensure it is
780 /// large enough. TLI.getShiftAmountTy() is i8 on some targets, but before
781 /// legalization, types like i1024 can occur and i8 doesn't have enough bits
782 /// to represent the shift amount.
783 /// When the 1st operand is a vector, the shift amount must be in the same
784 /// type. (TLI.getShiftAmountTy() will return the same type when the input
785 /// type is a vector.)
786 /// For rotates and funnel shifts, the shift amount is treated as an unsigned
787 /// amount modulo the element size of the first operand.
788 ///
789 /// Funnel 'double' shifts take 3 operands, 2 inputs and the shift amount.
790 ///
791 /// fshl(X,Y,Z): (X << (Z % BW)) | (Y >> (BW - (Z % BW)))
792 /// fshr(X,Y,Z): (X << (BW - (Z % BW))) | (Y >> (Z % BW))
800
801 /// Carry-less multiplication operations.
805
806 /// Parallel bit extract (compress) and parallel bit deposit (expand).
809
810 /// Byte Swap and Counting operators.
817
818 /// Bit counting operators with a poisoned result for zero inputs.
821
822 /// Count leading redundant sign bits. Equivalent to
823 /// (sub (ctlz (x < 0 ? ~x : x)), 1).
825
826 /// Select(COND, TRUEVAL, FALSEVAL). If the type of the boolean COND is not
827 /// i1 then the high bits must conform to getBooleanContents.
829
830 /// Select with a vector condition (op #0) and two vector operands (ops #1
831 /// and #2), returning a vector result. All vectors have the same length.
832 /// Much like the scalar select and setcc, each bit in the condition selects
833 /// whether the corresponding result element is taken from op #1 or op #2.
834 /// At first, the VSELECT condition is of vXi1 type. Later, targets may
835 /// change the condition type in order to match the VSELECT node using a
836 /// pattern. The condition follows the BooleanContent format of the target.
838
839 /// Select with condition operator - This selects between a true value and
840 /// a false value (ops #2 and #3) based on the boolean result of comparing
841 /// the lhs and rhs (ops #0 and #1) of a conditional expression with the
842 /// condition code in op #4, a CondCodeSDNode.
844
845 /// SetCC operator - This evaluates to a true value iff the condition is
846 /// true. If the result value type is not i1 then the high bits conform
847 /// to getBooleanContents. The operands to this are the left and right
848 /// operands to compare (ops #0, and #1) and the condition code to compare
849 /// them with (op #2) as a CondCodeSDNode. If the operands are vector types
850 /// then the result type must also be a vector type.
852
853 /// Like SetCC, ops #0 and #1 are the LHS and RHS operands to compare, but
854 /// op #2 is a boolean indicating if there is an incoming carry. This
855 /// operator checks the result of "LHS - RHS - Carry", and can be used to
856 /// compare two wide integers:
857 /// (setcccarry lhshi rhshi (usubo_carry lhslo rhslo) cc).
858 /// Only valid for integers.
860
861 /// SHL_PARTS/SRA_PARTS/SRL_PARTS - These operators are used for expanded
862 /// integer shift operations. The operation ordering is:
863 ///
864 /// [Lo,Hi] = op [LoLHS,HiLHS], Amt
868
869 /// Conversion operators. These are all single input single output
870 /// operations. For all of these, the result type must be strictly
871 /// wider or narrower (depending on the operation) than the source
872 /// type.
873
874 /// SIGN_EXTEND - Used for integer types, replicating the sign bit
875 /// into new bits.
877
878 /// ZERO_EXTEND - Used for integer types, zeroing the new bits. Can carry
879 /// the NonNeg SDNodeFlag to indicate that the input is known to be
880 /// non-negative. If the flag is present and the input is negative, the result
881 /// is poison.
883
884 /// ANY_EXTEND - Used for integer types. The high bits are undefined.
886
887 /// TRUNCATE - Completely drop the high bits.
889 /// TRUNCATE_[SU]SAT_[SU] - Truncate for saturated operand
890 /// [SU] located in middle, prefix for `SAT` means indicates whether
891 /// existing truncate target was a signed operation. For examples,
892 /// If `truncate(smin(smax(x, C), C))` was saturated then become `S`.
893 /// If `truncate(umin(x, C))` was saturated then become `U`.
894 /// [SU] located in last indicates whether range of truncated values is
895 /// sign-saturated. For example, if `truncate(smin(smax(x, C), C))` is a
896 /// truncation to `i8`, then if value of C ranges from `-128 to 127`, it will
897 /// be saturated against signed values, resulting in `S`, which will combine
898 /// to `TRUNCATE_SSAT_S`. If the value of C ranges from `0 to 255`, it will
899 /// be saturated against unsigned values, resulting in `U`, which will
900 /// combine to `TRUNCATE_SSAT_U`. Similarly, in `truncate(umin(x, C))`, if
901 /// value of C ranges from `0 to 255`, it becomes `U` because it is saturated
902 /// for unsigned values. As a result, it combines to `TRUNCATE_USAT_U`.
903 TRUNCATE_SSAT_S, // saturate signed input to signed result -
904 // truncate(smin(smax(x, C), C))
905 TRUNCATE_SSAT_U, // saturate signed input to unsigned result -
906 // truncate(smin(smax(x, 0), C))
907 TRUNCATE_USAT_U, // saturate unsigned input to unsigned result -
908 // truncate(umin(x, C))
909
910 /// [SU]INT_TO_FP - These operators convert integers (whose interpreted sign
911 /// depends on the first letter) to floating point.
914
915 /// SIGN_EXTEND_INREG - This operator atomically performs a SHL/SRA pair to
916 /// sign extend a small value in a large integer register (e.g. sign
917 /// extending the low 8 bits of a 32-bit register to fill the top 24 bits
918 /// with the 7th bit). The size of the smaller type is indicated by the 1th
919 /// operand, a ValueType node.
921
922 /// ANY_EXTEND_VECTOR_INREG(Vector) - This operator represents an
923 /// in-register any-extension of the low lanes of an integer vector. The
924 /// result type must have fewer elements than the operand type, and those
925 /// elements must be larger integer types such that the total size of the
926 /// operand type is less than or equal to the size of the result type. Each
927 /// of the low operand elements is any-extended into the corresponding,
928 /// wider result elements with the high bits becoming undef.
929 /// NOTE: The type legalizer prefers to make the operand and result size
930 /// the same to allow expansion to shuffle vector during op legalization.
932
933 /// SIGN_EXTEND_VECTOR_INREG(Vector) - This operator represents an
934 /// in-register sign-extension of the low lanes of an integer vector. The
935 /// result type must have fewer elements than the operand type, and those
936 /// elements must be larger integer types such that the total size of the
937 /// operand type is less than or equal to the size of the result type. Each
938 /// of the low operand elements is sign-extended into the corresponding,
939 /// wider result elements.
940 /// NOTE: The type legalizer prefers to make the operand and result size
941 /// the same to allow expansion to shuffle vector during op legalization.
943
944 /// ZERO_EXTEND_VECTOR_INREG(Vector) - This operator represents an
945 /// in-register zero-extension of the low lanes of an integer vector. The
946 /// result type must have fewer elements than the operand type, and those
947 /// elements must be larger integer types such that the total size of the
948 /// operand type is less than or equal to the size of the result type. Each
949 /// of the low operand elements is zero-extended into the corresponding,
950 /// wider result elements.
951 /// NOTE: The type legalizer prefers to make the operand and result size
952 /// the same to allow expansion to shuffle vector during op legalization.
954
955 /// FP_TO_[US]INT - Convert a floating point value to a signed or unsigned
956 /// integer. These have the same semantics as fptosi and fptoui in IR. If
957 /// the FP value cannot fit in the integer type, the results are undefined.
960
961 /// FP_TO_[US]INT_SAT - Convert floating point value in operand 0 to a
962 /// signed or unsigned scalar integer type given in operand 1 with the
963 /// following semantics:
964 ///
965 /// * If the value is NaN, zero is returned.
966 /// * If the value is larger/smaller than the largest/smallest integer,
967 /// the largest/smallest integer is returned (saturation).
968 /// * Otherwise the result of rounding the value towards zero is returned.
969 ///
970 /// The scalar width of the type given in operand 1 must be equal to, or
971 /// smaller than, the scalar result type width. It may end up being smaller
972 /// than the result width as a result of integer type legalization.
973 ///
974 /// After converting to the scalar integer type in operand 1, the value is
975 /// extended to the result VT. FP_TO_SINT_SAT sign extends and FP_TO_UINT_SAT
976 /// zero extends.
979
980 /// X = FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating point type
981 /// down to the precision of the destination VT. TRUNC is a flag, which is
982 /// always an integer that is zero or one. If TRUNC is 0, this is a
983 /// normal rounding, if it is 1, this FP_ROUND is known to not change the
984 /// value of Y.
985 ///
986 /// The TRUNC = 1 case is used in cases where we know that the value will
987 /// not be modified by the node, because Y is not using any of the extra
988 /// precision of source type. This allows certain transformations like
989 /// FP_EXTEND(FP_ROUND(X,1)) -> X which are not safe for
990 /// FP_EXTEND(FP_ROUND(X,0)) because the extra bits aren't removed.
992
993 /// Returns current rounding mode:
994 /// -1 Undefined
995 /// 0 Round to 0
996 /// 1 Round to nearest, ties to even
997 /// 2 Round to +inf
998 /// 3 Round to -inf
999 /// 4 Round to nearest, ties to zero
1000 /// Other values are target dependent.
1001 /// Result is rounding mode and chain. Input is a chain.
1003
1004 /// Set rounding mode.
1005 /// The first operand is a chain pointer. The second specifies the required
1006 /// rounding mode, encoded in the same way as used in GET_ROUNDING.
1008
1009 /// X = FP_EXTEND(Y) - Extend a smaller FP type into a larger FP type.
1011
1012 /// BITCAST - This operator converts between integer, vector and FP
1013 /// values, as if the value was stored to memory with one type and loaded
1014 /// from the same address with the other type (or equivalently for vector
1015 /// format conversions, etc). The source and result are required to have
1016 /// the same bit size (e.g. f32 <-> i32). This can also be used for
1017 /// int-to-int or fp-to-fp conversions, but that is a noop, deleted by
1018 /// getNode().
1019 ///
1020 /// This operator is subtly different from the bitcast instruction from
1021 /// LLVM-IR since this node may change the bits in the register. For
1022 /// example, this occurs on big-endian NEON and big-endian MSA where the
1023 /// layout of the bits in the register depends on the vector type and this
1024 /// operator acts as a shuffle operation for some vector type combinations.
1026
1027 /// ADDRSPACECAST - This operator converts between pointers of different
1028 /// address spaces.
1030
1031 /// FP16_TO_FP, FP_TO_FP16 - These operators are used to perform promotions
1032 /// and truncation for half-precision (16 bit) floating numbers. These nodes
1033 /// form a semi-softened interface for dealing with f16 (as an i16), which
1034 /// is often a storage-only type but has native conversions.
1039
1040 /// BF16_TO_FP, FP_TO_BF16 - These operators are used to perform promotions
1041 /// and truncation for bfloat16. These nodes form a semi-softened interface
1042 /// for dealing with bf16 (as an i16), which is often a storage-only type but
1043 /// has native conversions.
1048
1049 /// CONVERT_FROM_ARBITRARY_FP - This operator converts from an arbitrary
1050 /// floating-point represented as an integer to a native FP type.
1051 /// The first operand is the integer containing the source FP bits.
1052 /// The second operand is a constant indicating the source FP semantics.
1054
1055 /// CONVERT_TO_ARBITRARY_FP - Converts a native FP value to an arbitrary
1056 /// floating-point format, returning the result as an integer.
1057 /// The first operand is the source value.
1058 /// The second operand is a constant indicating the destination FP semantics.
1059 /// The third operand is a constant indication the rounding mode.
1060 /// The last operand is a boolean constant indicating whether the result has
1061 /// to be saturated.
1063
1064 /// Perform various unary floating-point operations inspired by libm. For
1065 /// FPOWI, the result is undefined if the integer operand doesn't fit into
1066 /// sizeof(int).
1082 /// FLDEXP - ldexp, inspired by libm (op0 * 2**op1).
1084 /// FATAN2 - atan2, inspired by libm.
1086
1087 /// FFREXP - frexp, extract fractional and exponent component of a
1088 /// floating-point value. Returns the two components as separate return
1089 /// values.
1091
1109
1110 /// FMINNUM/FMAXNUM - Same semantics as the llvm.minnum/maxnum intrinsics.
1113
1114 /// FMINNUM_IEEE/FMAXNUM_IEEE - Same as FMINNUM/FMAXNUM, except that a
1115 /// signaling NaN operand deterministically returns a quiet NaN, like IEEE-754
1116 /// 2008's minNum/maxNum. -0 is ordered less than +0, relaxed by the nsz flag.
1117 ///
1118 /// Deprecated, and will be removed soon: this is a legal implementation of
1119 /// FMINNUM/FMAXNUM, so targets should select those instead.
1122
1123 /// FMINIMUM/FMAXIMUM - Same semantics as the llvm.minimum/maximum intrinsics.
1126
1127 /// FMINIMUMNUM/FMAXIMUMNUM - Same semantics as the llvm.minimumnum/maximumnum
1128 /// intrinsics.
1131
1132 /// PSEUDO_FMIN is strictly equivalent to op0 olt op1 ? op0 : op1.
1133 /// PSEUDO_FMAX is strictly equivalent to op0 ogt op1 ? op0 : op1.
1134 /// In particular, this implies that if both operands are zeros, the second
1135 /// operand is returned (regardless of sign), and that if one operand is NaN,
1136 /// the second operand is returned (exactly as-is, without any NaN changes).
1137 /// The StrictFP variant assumes signaling fcmp (FSETCCS).
1140
1141 /// FSINCOS - Compute both fsin and fcos as a single operation.
1143
1144 /// FSINCOSPI - Compute both the sine and cosine times pi more accurately
1145 /// than FSINCOS(pi*x), especially for large x.
1147
1148 /// FMODF - Decomposes the operand into integral and fractional parts, each
1149 /// having the same type and sign as the operand.
1151
1152 /// Gets the current floating-point environment. The first operand is a token
1153 /// chain. The results are FP environment, represented by an integer value,
1154 /// and a token chain.
1156
1157 /// Sets the current floating-point environment. The first operand is a token
1158 /// chain, the second is FP environment, represented by an integer value. The
1159 /// result is a token chain.
1161
1162 /// Set floating-point environment to default state. The first operand and the
1163 /// result are token chains.
1165
1166 /// Gets the current floating-point environment. The first operand is a token
1167 /// chain, the second is a pointer to memory, where FP environment is stored
1168 /// to. The result is a token chain.
1170
1171 /// Sets the current floating point environment. The first operand is a token
1172 /// chain, the second is a pointer to memory, where FP environment is loaded
1173 /// from. The result is a token chain.
1175
1176 /// Reads the current dynamic floating-point control modes. The operand is
1177 /// a token chain.
1179
1180 /// Sets the current dynamic floating-point control modes. The first operand
1181 /// is a token chain, the second is control modes set represented as integer
1182 /// value.
1184
1185 /// Sets default dynamic floating-point control modes. The operand is a
1186 /// token chain.
1188
1189 /// LOAD and STORE have token chains as their first operand, then the same
1190 /// operands as an LLVM load/store instruction, then an offset node that
1191 /// is added / subtracted from the base pointer to form the address (for
1192 /// indexed memory ops).
1195
1196 /// DYNAMIC_STACKALLOC - Allocate some number of bytes on the stack aligned
1197 /// to a specified boundary. This node always has two return values: a new
1198 /// stack pointer value and a chain. The first operand is the token chain,
1199 /// the second is the number of bytes to allocate, and the third is the
1200 /// alignment boundary. The size is guaranteed to be a multiple of the
1201 /// stack alignment, and the alignment is guaranteed to be bigger than the
1202 /// stack alignment (if required) or 0 to get standard stack alignment.
1204
1205 /// Control flow instructions. These all have token chains.
1206
1207 /// BR - Unconditional branch. The first operand is the chain
1208 /// operand, the second is the MBB to branch to.
1210
1211 /// BRIND - Indirect branch. The first operand is the chain, the second
1212 /// is the value to branch to, which must be of the same type as the
1213 /// target's pointer type.
1215
1216 /// BR_JT - Jumptable branch. The first operand is the chain, the second
1217 /// is the jumptable index, the last one is the jumptable entry index.
1219
1220 /// JUMP_TABLE_DEBUG_INFO - Jumptable debug info. The first operand is the
1221 /// chain, the second is the jumptable index.
1223
1224 /// BRCOND - Conditional branch. The first operand is the chain, the
1225 /// second is the condition, the third is the block to branch to if the
1226 /// condition is true. If the type of the condition is not i1, then the
1227 /// high bits must conform to getBooleanContents. If the condition is undef,
1228 /// it nondeterministically jumps to the block.
1229 /// TODO: Its semantics w.r.t undef requires further discussion; we need to
1230 /// make it sure that it is consistent with optimizations in MIR & the
1231 /// meaning of IMPLICIT_DEF. See https://reviews.llvm.org/D92015
1233
1234 /// BR_CC - Conditional branch. The behavior is like that of SELECT_CC, in
1235 /// that the condition is represented as condition code, and two nodes to
1236 /// compare, rather than as a combined SetCC node. The operands in order
1237 /// are chain, cc, lhs, rhs, block to branch to if condition is true. If
1238 /// condition is undef, it nondeterministically jumps to the block.
1240
1241 /// INLINEASM - Represents an inline asm block. This node always has two
1242 /// return values: a chain and a flag result. The inputs are as follows:
1243 /// Operand #0 : Input chain.
1244 /// Operand #1 : a ExternalSymbolSDNode with a pointer to the asm string.
1245 /// Operand #2 : a MDNodeSDNode with the !srcloc metadata.
1246 /// Operand #3 : HasSideEffect, IsAlignStack bits.
1247 /// After this, it is followed by a list of operands with this format:
1248 /// ConstantSDNode: Flags that encode whether it is a mem or not, the
1249 /// of operands that follow, etc. See InlineAsm.h.
1250 /// ... however many operands ...
1251 /// Operand #last: Optional, an incoming flag.
1252 ///
1253 /// The variable width operands are required to represent target addressing
1254 /// modes as a single "operand", even though they may have multiple
1255 /// SDOperands.
1257
1258 /// INLINEASM_BR - Branching version of inline asm. Used by asm-goto.
1260
1261 /// EH_LABEL - Represents a label in mid basic block used to track
1262 /// locations needed for debug and exception handling tables. These nodes
1263 /// take a chain as input and return a chain.
1265
1266 /// ANNOTATION_LABEL - Represents a mid basic block label used by
1267 /// annotations. This should remain within the basic block and be ordered
1268 /// with respect to other call instructions, but loads and stores may float
1269 /// past it.
1271
1272 /// CATCHRET - Represents a return from a catch block funclet. Used for
1273 /// MSVC compatible exception handling. Takes a chain operand and a
1274 /// destination basic block operand.
1276
1277 /// CLEANUPRET - Represents a return from a cleanup block funclet. Used for
1278 /// MSVC compatible exception handling. Takes only a chain operand.
1280
1281 /// STACKSAVE - STACKSAVE has one operand, an input chain. It produces a
1282 /// value, the same type as the pointer type for the system, and an output
1283 /// chain.
1285
1286 /// STACKRESTORE has two operands, an input chain and a pointer to restore
1287 /// to it returns an output chain.
1289
1290 /// CALLSEQ_START/CALLSEQ_END - These operators mark the beginning and end
1291 /// of a call sequence, and carry arbitrary information that target might
1292 /// want to know. The first operand is a chain, the rest are specified by
1293 /// the target and not touched by the DAG optimizers.
1294 /// Targets that may use stack to pass call arguments define additional
1295 /// operands:
1296 /// - size of the call frame part that must be set up within the
1297 /// CALLSEQ_START..CALLSEQ_END pair,
1298 /// - part of the call frame prepared prior to CALLSEQ_START.
1299 /// Both these parameters must be constants, their sum is the total call
1300 /// frame size.
1301 /// CALLSEQ_START..CALLSEQ_END pairs may not be nested.
1302 CALLSEQ_START, // Beginning of a call sequence
1303 CALLSEQ_END, // End of a call sequence
1304
1305 /// VAARG - VAARG has four operands: an input chain, a pointer, a SRCVALUE,
1306 /// and the alignment. It returns a pair of values: the vaarg value and a
1307 /// new chain.
1309
1310 /// VACOPY - VACOPY has 5 operands: an input chain, a destination pointer,
1311 /// a source pointer, a SRCVALUE for the destination, and a SRCVALUE for the
1312 /// source.
1314
1315 /// VAEND, VASTART - VAEND and VASTART have three operands: an input chain,
1316 /// pointer, and a SRCVALUE.
1319
1320 /// PREALLOCATED_SETUP - This has 2 operands: an input chain and a SRCVALUE
1321 /// with the preallocated call Value.
1323 /// PREALLOCATED_ARG - This has 3 operands: an input chain, a SRCVALUE
1324 /// with the preallocated call Value, and a constant int.
1326
1327 /// SRCVALUE - This is a node type that holds a Value* that is used to
1328 /// make reference to a value in the LLVM IR.
1330
1331 /// MDNODE_SDNODE - This is a node that holdes an MDNode*, which is used to
1332 /// reference metadata in the IR.
1334
1335 /// PCMARKER - This corresponds to the pcmarker intrinsic.
1337
1338 /// READCYCLECOUNTER - This corresponds to the readcyclecounter intrinsic.
1339 /// It produces a chain and one i64 value. The only operand is a chain.
1340 /// If i64 is not legal, the result will be expanded into smaller values.
1341 /// Still, it returns an i64, so targets should set legality for i64.
1342 /// The result is the content of the architecture-specific cycle
1343 /// counter-like register (or other high accuracy low latency clock source).
1345
1346 /// READSTEADYCOUNTER - This corresponds to the readfixedcounter intrinsic.
1347 /// It has the same semantics as the READCYCLECOUNTER implementation except
1348 /// that the result is the content of the architecture-specific fixed
1349 /// frequency counter suitable for measuring elapsed time.
1351
1352 /// HANDLENODE node - Used as a handle for various purposes.
1354
1355 /// INIT_TRAMPOLINE - This corresponds to the init_trampoline intrinsic. It
1356 /// takes as input a token chain, the pointer to the trampoline, the pointer
1357 /// to the nested function, the pointer to pass for the 'nest' parameter, a
1358 /// SRCVALUE for the trampoline and another for the nested function
1359 /// (allowing targets to access the original Function*).
1360 /// It produces a token chain as output.
1362
1363 /// ADJUST_TRAMPOLINE - This corresponds to the adjust_trampoline intrinsic.
1364 /// It takes a pointer to the trampoline and produces a (possibly) new
1365 /// pointer to the same trampoline with platform-specific adjustments
1366 /// applied. The pointer it returns points to an executable block of code.
1368
1369 /// TRAP - Trapping instruction
1371
1372 /// DEBUGTRAP - Trap intended to get the attention of a debugger.
1374
1375 /// UBSANTRAP - Trap with an immediate describing the kind of sanitizer
1376 /// failure.
1378
1379 /// PREFETCH - This corresponds to a prefetch intrinsic. The first operand
1380 /// is the chain. The other operands are the address to prefetch,
1381 /// read / write specifier, locality specifier and instruction / data cache
1382 /// specifier.
1384
1385 /// ARITH_FENCE - This corresponds to a arithmetic fence intrinsic. Both its
1386 /// operand and output are the same floating type.
1388
1389 /// MEMBARRIER - Compiler barrier only; generate a no-op.
1391
1392 /// OUTCHAIN = ATOMIC_FENCE(INCHAIN, ordering, scope)
1393 /// This corresponds to the fence instruction. It takes an input chain, and
1394 /// two integer constants: an AtomicOrdering and a SynchronizationScope.
1396
1397 /// Val, OUTCHAIN = ATOMIC_LOAD(INCHAIN, ptr)
1398 /// This corresponds to "load atomic" instruction.
1400
1401 /// OUTCHAIN = ATOMIC_STORE(INCHAIN, val, ptr)
1402 /// This corresponds to "store atomic" instruction.
1404
1405 /// Val, OUTCHAIN = ATOMIC_CMP_SWAP(INCHAIN, ptr, cmp, swap)
1406 /// For double-word atomic operations:
1407 /// ValLo, ValHi, OUTCHAIN = ATOMIC_CMP_SWAP(INCHAIN, ptr, cmpLo, cmpHi,
1408 /// swapLo, swapHi)
1409 /// This corresponds to the cmpxchg instruction.
1411
1412 /// Val, Success, OUTCHAIN
1413 /// = ATOMIC_CMP_SWAP_WITH_SUCCESS(INCHAIN, ptr, cmp, swap)
1414 /// N.b. this is still a strong cmpxchg operation, so
1415 /// Success == "Val == cmp".
1417
1418 /// Val, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amt)
1419 /// Val, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN, ptr, amt)
1420 /// For double-word atomic operations:
1421 /// ValLo, ValHi, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amtLo, amtHi)
1422 /// ValLo, ValHi, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN, ptr, amtLo, amtHi)
1423 /// These correspond to the atomicrmw instruction.
1448
1449 /// Masked load and store - consecutive vector load and store operations
1450 /// with additional mask operand that prevents memory accesses to the
1451 /// masked-off lanes.
1452 ///
1453 /// Val, OutChain = MLOAD(BasePtr, Mask, PassThru)
1454 /// OutChain = MSTORE(Value, BasePtr, Mask)
1457
1458 /// Masked gather and scatter - load and store operations for a vector of
1459 /// random addresses with additional mask operand that prevents memory
1460 /// accesses to the masked-off lanes.
1461 ///
1462 /// Val, OutChain = GATHER(InChain, PassThru, Mask, BasePtr, Index, Scale)
1463 /// OutChain = SCATTER(InChain, Value, Mask, BasePtr, Index, Scale)
1464 ///
1465 /// The Index operand can have more vector elements than the other operands
1466 /// due to type legalization. The extra elements are ignored.
1469
1470 /// This corresponds to the llvm.lifetime.* intrinsics. The first operand
1471 /// is the chain and the second operand is the alloca pointer.
1474
1475 /// FAKE_USE represents a use of the operand but does not do anything.
1476 /// Its purpose is the extension of the operand's lifetime mainly for
1477 /// debugging purposes.
1479
1480 /// COND_LOOP is a conditional branch to self, used for implementing efficient
1481 /// conditional traps.
1483
1484 /// GC_TRANSITION_START/GC_TRANSITION_END - These operators mark the
1485 /// beginning and end of GC transition sequence, and carry arbitrary
1486 /// information that target might need for lowering. The first operand is
1487 /// a chain, the rest are specified by the target and not touched by the DAG
1488 /// optimizers. GC_TRANSITION_START..GC_TRANSITION_END pairs may not be
1489 /// nested.
1492
1493 /// GET_DYNAMIC_AREA_OFFSET - get offset from native SP to the address of
1494 /// the most recent dynamic alloca. For most targets that would be 0, but
1495 /// for some others (e.g. PowerPC, PowerPC64) that would be compile-time
1496 /// known nonzero constant. The only operand here is the chain.
1498
1499 /// Pseudo probe for AutoFDO, as a place holder in a basic block to improve
1500 /// the sample counts quality.
1502
1503 /// VSCALE(IMM) - Returns the runtime scaling factor used to calculate the
1504 /// number of elements within a scalable vector. IMM is a constant integer
1505 /// multiplier that is applied to the runtime value.
1507
1508 /// Generic reduction nodes. These nodes represent horizontal vector
1509 /// reduction operations, producing a scalar result.
1510 /// The SEQ variants perform reductions in sequential order. The first
1511 /// operand is an initial scalar accumulator value, and the second operand
1512 /// is the vector to reduce.
1513 /// E.g. RES = VECREDUCE_SEQ_FADD f32 ACC, <4 x f32> SRC_VEC
1514 /// ... is equivalent to
1515 /// RES = (((ACC + SRC_VEC[0]) + SRC_VEC[1]) + SRC_VEC[2]) + SRC_VEC[3]
1518
1519 /// These reductions have relaxed evaluation order semantics, and have a
1520 /// single vector operand. The order of evaluation is unspecified. For
1521 /// pow-of-2 vectors, one valid legalizer expansion is to use a tree
1522 /// reduction, i.e.:
1523 /// For RES = VECREDUCE_FADD <8 x f16> SRC_VEC
1524 ///
1525 /// PART_RDX = FADD SRC_VEC[0:3], SRC_VEC[4:7]
1526 /// PART_RDX2 = FADD PART_RDX[0:1], PART_RDX[2:3]
1527 /// RES = FADD PART_RDX2[0], PART_RDX2[1]
1528 ///
1529 /// For non-pow-2 vectors, this can be computed by extracting each element
1530 /// and performing the operation as if it were scalarized.
1533 /// FMIN/FMAX nodes can have flags, for NaN/NoNaN variants.
1536 /// FMINIMUM/FMAXIMUM nodes propatate NaNs and signed zeroes using the
1537 /// llvm.minimum and llvm.maximum semantics.
1540 /// FMINIMUMNUM/FMAXIMUMNUM nodes do not propagate NaNs and order signed
1541 /// zeroes using the llvm.minimumnum and llvm.maximumnum semantics.
1544 /// Integer reductions may have a result type larger than the vector element
1545 /// type. However, the reduction is performed using the vector element type
1546 /// and the value in the top bits is unspecified.
1556
1557 /// PARTIAL_REDUCE_[U|S]MLA(Accumulator, Input1, Input2)
1558 /// The partial reduction nodes sign or zero extend Input1 and Input2
1559 /// (with the extension kind noted below) to the element type of
1560 /// Accumulator before multiplying their results.
1561 /// This result is concatenated to the Accumulator, and this is then reduced,
1562 /// using addition, to the result type.
1563 /// The output is only expected to either be given to another partial
1564 /// reduction operation or an equivalent vector reduce operation, so the order
1565 /// in which the elements are reduced is deliberately not specified.
1566 /// Input1 and Input2 must be the same type. Accumulator and the output must
1567 /// be the same type.
1568 /// The number of elements in Input1 and Input2 must be a positive integer
1569 /// multiple of the number of elements in the Accumulator / output type.
1570 /// Input1 and Input2 must have an element type which is the same as or
1571 /// smaller than the element type of the Accumulator and output.
1572 PARTIAL_REDUCE_SMLA, // sext, sext
1573 PARTIAL_REDUCE_UMLA, // zext, zext
1575 PARTIAL_REDUCE_FMLA, // fpext, fpext
1576
1577 /// The `llvm.experimental.stackmap` intrinsic.
1578 /// Operands: input chain, glue, <id>, <numShadowBytes>, [live0[, live1...]]
1579 /// Outputs: output chain, glue
1581
1582 /// The `llvm.experimental.patchpoint.*` intrinsic.
1583 /// Operands: input chain, [glue], reg-mask, <id>, <numShadowBytes>, callee,
1584 /// <numArgs>, cc, ...
1585 /// Outputs: [rv], output chain, glue
1587
1588 /// PTRADD represents pointer arithmetic semantics, for targets that opt in
1589 /// using shouldPreservePtrArith().
1590 /// ptr = PTRADD ptr, offset
1592
1593// Vector Predication
1594#define BEGIN_REGISTER_VP_SDNODE(VPSDID, ...) VPSDID,
1595#include "llvm/IR/VPIntrinsics.def"
1596
1597 /// Issue a no-op relocation against a given symbol at the current location.
1599
1600 /// The `llvm.experimental.convergence.*` intrinsics.
1604 /// This does not correspond to any convergence control intrinsic. It is used
1605 /// to glue a convergence control token to a convergent operation in the DAG,
1606 /// which is later translated to an implicit use in the MIR.
1608
1609 /// Experimental vector histogram intrinsic
1610 /// Operands: Input Chain, Inc, Mask, Base, Index, Scale, ID
1611 /// Output: Output Chain
1613
1614 /// Returns the number of number of trailing (least significant) zero elements
1615 /// in a vector. Has a single mask vector operand. The result is poison if the
1616 /// return type isn't wide enough to hold the maximum number of elements in
1617 /// the input vector.
1620
1621 /// Finds the index of the last active mask element
1622 /// Operands: Mask
1624
1625 /// GET_ACTIVE_LANE_MASK - this corrosponds to the llvm.get.active.lane.mask
1626 /// intrinsic. It creates a mask representing active and inactive vector
1627 /// lanes, active while Base + index < Trip Count. As with the intrinsic,
1628 /// the operands Base and Trip Count have the same scalar integer type and
1629 /// the internal addition of Base + index cannot overflow. However, the ISD
1630 /// node supports result types which are wider than i1, where the high
1631 /// bits conform to getBooleanContents similar to the SETCC operator.
1633
1634 /// Has one mask vector operand. Returns a mask with all ones up to but not
1635 /// including the first active element in the input, followed by zeroes.
1637
1638 /// VECTOR_MATCH - this corresponds to the llvm.experimental.vector.match
1639 /// intrinsic.
1640 /// Operands: Source, Needle, Mask
1641 /// Source has the same number of elements as the result and Needle may have
1642 /// a different number of elements. The result type matches Mask. The ISD
1643 /// node supports result and mask types wider than i1, in these cases the
1644 /// high bits conform to getBooleanContents similar to the SETCC operator.
1646
1647 /// The `llvm.loop.dependence.{war, raw}.mask` intrinsics
1648 /// Operands: Load pointer, Store pointer, Element size, Lane offset
1649 /// Output: Mask
1650 ///
1651 /// Note: The semantics of these opcodes differ slightly from the intrinsics.
1652 /// Wherever "lane" (meaning lane index) occurs in the intrinsic definition,
1653 /// it is replaced with (lane + lane_offset) for the ISD opcode.
1654 ///
1655 /// E.g., for LOOP_DEPENDENCE_WAR_MASK:
1656 /// `elementSize * lane < (ptrB - ptrA)`
1657 /// Becomes:
1658 /// `elementSize * (lane + lane_offset) < (ptrB - ptrA)`
1659 ///
1660 /// This is done to allow for trivial splitting of the operation. Note: The
1661 /// lane offset is always a constant, for scalable masks, it is implicitly
1662 /// multiplied by vscale.
1665
1666 /// Masked vector arithmetic that returns poison on disabled lanes. Disabled
1667 /// lanes do not have undefined behaviour on division by zero or overflow. The
1668 /// first two operands are input vectors, the third operand is the mask.
1673
1674 /// llvm.clear_cache intrinsic
1675 /// Operands: Input Chain, Start Addres, End Address
1676 /// Outputs: Output Chain
1678
1679 /// Untyped node storing deactivation symbol reference
1680 /// (DeactivationSymbolSDNode).
1682
1683 /// BUILTIN_OP_END - This must be the last enum value in this list.
1684 /// The target-specific pre-isel opcode values start here.
1686};
1687
1688/// Whether this is bitwise logic opcode.
1689inline bool isBitwiseLogicOp(unsigned Opcode) {
1690 return Opcode == ISD::AND || Opcode == ISD::OR || Opcode == ISD::XOR;
1691}
1692
1693/// Whether this is an integer absolute-value opcode (ISD::ABS or
1694/// ISD::ABS_MIN_POISON).
1695inline bool isAbsOpcode(unsigned Opcode) {
1696 return Opcode == ISD::ABS || Opcode == ISD::ABS_MIN_POISON;
1697}
1698
1699/// Whether this is an integer min/max opcode (ISD::(U|S)MIN or ISD::(U|S)MAX).
1700inline bool isMinMaxOpcode(unsigned Opcode) {
1701 return Opcode == ISD::SMIN || Opcode == ISD::SMAX || Opcode == ISD::UMIN ||
1702 Opcode == ISD::UMAX;
1703}
1704
1705/// Given a \p MinMaxOpc of ISD::(U|S)MIN or ISD::(U|S)MAX, returns
1706/// ISD::(U|S)MAX and ISD::(U|S)MIN, respectively.
1707LLVM_ABI NodeType getInverseMinMaxOpcode(unsigned MinMaxOpc);
1708
1709/// Given a \p MinMaxOpc of ISD::(U|S)MIN or ISD::(U|S)MAX, returns the
1710/// corresponding opcode with the opposite signedness:
1711/// ISD::SMIN <-> ISD::UMIN, ISD::SMAX <-> ISD::UMAX.
1713
1714/// Get underlying scalar opcode for VECREDUCE opcode.
1715/// For example ISD::AND for ISD::VECREDUCE_AND.
1716LLVM_ABI NodeType getVecReduceBaseOpcode(unsigned VecReduceOpcode);
1717
1718/// Given a \p MaskedOpc of ISD::MASKED_(U|S)(DIV|REM), returns the unmasked
1719/// ISD::(U|S)(DIV|REM).
1720LLVM_ABI NodeType getUnmaskedBinOpOpcode(unsigned MaskedOpc);
1721
1722/// Whether this is a vector-predicated Opcode.
1723LLVM_ABI bool isVPOpcode(unsigned Opcode);
1724
1725/// Whether this is a vector-predicated binary operation opcode.
1726LLVM_ABI bool isVPBinaryOp(unsigned Opcode);
1727
1728/// Whether this is a vector-predicated reduction opcode.
1729LLVM_ABI bool isVPReduction(unsigned Opcode);
1730
1731/// The operand position of the vector mask.
1732LLVM_ABI std::optional<unsigned> getVPMaskIdx(unsigned Opcode);
1733
1734/// The operand position of the explicit vector length parameter.
1735LLVM_ABI std::optional<unsigned> getVPExplicitVectorLengthIdx(unsigned Opcode);
1736
1737/// Translate this VP Opcode to its corresponding non-VP Opcode.
1738LLVM_ABI std::optional<unsigned> getBaseOpcodeForVP(unsigned Opcode,
1739 bool hasFPExcept);
1740
1741/// Translate this non-VP Opcode to its corresponding VP Opcode.
1742LLVM_ABI std::optional<unsigned> getVPForBaseOpcode(unsigned Opcode);
1743
1744//===--------------------------------------------------------------------===//
1745/// MemIndexedMode enum - This enum defines the load / store indexed
1746/// addressing modes.
1747///
1748/// UNINDEXED "Normal" load / store. The effective address is already
1749/// computed and is available in the base pointer. The offset
1750/// operand is always undefined. In addition to producing a
1751/// chain, an unindexed load produces one value (result of the
1752/// load); an unindexed store does not produce a value.
1753///
1754/// PRE_INC Similar to the unindexed mode where the effective address is
1755/// PRE_DEC the value of the base pointer add / subtract the offset.
1756/// It considers the computation as being folded into the load /
1757/// store operation (i.e. the load / store does the address
1758/// computation as well as performing the memory transaction).
1759/// The base operand is always undefined. In addition to
1760/// producing a chain, pre-indexed load produces two values
1761/// (result of the load and the result of the address
1762/// computation); a pre-indexed store produces one value (result
1763/// of the address computation).
1764///
1765/// POST_INC The effective address is the value of the base pointer. The
1766/// POST_DEC value of the offset operand is then added to / subtracted
1767/// from the base after memory transaction. In addition to
1768/// producing a chain, post-indexed load produces two values
1769/// (the result of the load and the result of the base +/- offset
1770/// computation); a post-indexed store produces one value (the
1771/// the result of the base +/- offset computation).
1773
1774static const int LAST_INDEXED_MODE = POST_DEC + 1;
1775
1776//===--------------------------------------------------------------------===//
1777/// MemIndexType enum - This enum defines how to interpret MGATHER/SCATTER's
1778/// index parameter when calculating addresses.
1779///
1780/// SIGNED_SCALED Addr = Base + ((signed)Index * Scale)
1781/// UNSIGNED_SCALED Addr = Base + ((unsigned)Index * Scale)
1782///
1783/// NOTE: The value of Scale is typically only known to the node owning the
1784/// IndexType, with a value of 1 the equivalent of being unscaled.
1786
1788
1789inline bool isIndexTypeSigned(MemIndexType IndexType) {
1790 return IndexType == SIGNED_SCALED;
1791}
1792
1793//===--------------------------------------------------------------------===//
1794/// LoadExtType enum - This enum defines the three variants of LOADEXT
1795/// (load with extension).
1796///
1797/// SEXTLOAD loads the integer operand and sign extends it to a larger
1798/// integer result type.
1799/// ZEXTLOAD loads the integer operand and zero extends it to a larger
1800/// integer result type.
1801/// EXTLOAD is used for two things: floating point extending loads and
1802/// integer extending loads [the top bits are undefined].
1804
1805static const int LAST_LOADEXT_TYPE = ZEXTLOAD + 1;
1806
1808
1809//===--------------------------------------------------------------------===//
1810/// ISD::CondCode enum - These are ordered carefully to make the bitfields
1811/// below work out, when considering SETFALSE (something that never exists
1812/// dynamically) as 0. "U" -> Unsigned (for integer operands) or Unordered
1813/// (for floating point), "L" -> Less than, "G" -> Greater than, "E" -> Equal
1814/// to. If the "N" column is 1, the result of the comparison is undefined if
1815/// the input is a NAN.
1816///
1817/// All of these (except for the 'always folded ops') should be handled for
1818/// floating point. For integer, only the SETEQ,SETNE,SETLT,SETLE,SETGT,
1819/// SETGE,SETULT,SETULE,SETUGT, and SETUGE opcodes are used.
1820///
1821/// Note that these are laid out in a specific order to allow bit-twiddling
1822/// to transform conditions.
1824 // Opcode N U L G E Intuitive operation
1825 SETFALSE, // 0 0 0 0 Always false (always folded)
1826 SETOEQ, // 0 0 0 1 True if ordered and equal
1827 SETOGT, // 0 0 1 0 True if ordered and greater than
1828 SETOGE, // 0 0 1 1 True if ordered and greater than or equal
1829 SETOLT, // 0 1 0 0 True if ordered and less than
1830 SETOLE, // 0 1 0 1 True if ordered and less than or equal
1831 SETONE, // 0 1 1 0 True if ordered and operands are unequal
1832 SETO, // 0 1 1 1 True if ordered (no nans)
1833 SETUO, // 1 0 0 0 True if unordered: isnan(X) | isnan(Y)
1834 SETUEQ, // 1 0 0 1 True if unordered or equal
1835 SETUGT, // 1 0 1 0 True if unordered or greater than
1836 SETUGE, // 1 0 1 1 True if unordered, greater than, or equal
1837 SETULT, // 1 1 0 0 True if unordered or less than
1838 SETULE, // 1 1 0 1 True if unordered, less than, or equal
1839 SETUNE, // 1 1 1 0 True if unordered or not equal
1840 SETTRUE, // 1 1 1 1 Always true (always folded)
1841 // Don't care operations: undefined if the input is a nan.
1842 SETFALSE2, // 1 X 0 0 0 Always false (always folded)
1843 SETEQ, // 1 X 0 0 1 True if equal
1844 SETGT, // 1 X 0 1 0 True if greater than
1845 SETGE, // 1 X 0 1 1 True if greater than or equal
1846 SETLT, // 1 X 1 0 0 True if less than
1847 SETLE, // 1 X 1 0 1 True if less than or equal
1848 SETNE, // 1 X 1 1 0 True if not equal
1849 SETTRUE2, // 1 X 1 1 1 Always true (always folded)
1850
1851 SETCC_INVALID // Marker value.
1852};
1853
1854/// Return true if this is a setcc instruction that performs a signed
1855/// comparison when used with integer operands.
1856inline bool isSignedIntSetCC(CondCode Code) {
1857 return Code == SETGT || Code == SETGE || Code == SETLT || Code == SETLE;
1858}
1859
1860/// Return true if this is a setcc instruction that performs an unsigned
1861/// comparison when used with integer operands.
1862inline bool isUnsignedIntSetCC(CondCode Code) {
1863 return Code == SETUGT || Code == SETUGE || Code == SETULT || Code == SETULE;
1864}
1865
1866/// Return true if this is a setcc instruction that performs an equality
1867/// comparison when used with integer operands.
1868inline bool isIntEqualitySetCC(CondCode Code) {
1869 return Code == SETEQ || Code == SETNE;
1870}
1871
1872/// Convert a signed integer condition code to unsigned.
1873/// For equality and unsigned conditions, returns the condition unchanged.
1874/// For signed conditions, returns the corresponding unsigned condition.
1876 switch (Code) {
1877 default:
1878 llvm_unreachable("Non-integer setcc condition!");
1879 case SETEQ:
1880 case SETNE:
1881 case SETUGT:
1882 case SETULT:
1883 case SETUGE:
1884 case SETULE:
1885 case SETTRUE:
1886 case SETFALSE:
1887 return Code;
1888 case SETGT:
1889 return SETUGT;
1890 case SETLT:
1891 return SETULT;
1892 case SETGE:
1893 return SETUGE;
1894 case SETLE:
1895 return SETULE;
1896 }
1897}
1898
1899/// Return true if this is a setcc instruction that performs an equality
1900/// comparison when used with floating point operands.
1901inline bool isFPEqualitySetCC(CondCode Code) {
1902 return Code == SETOEQ || Code == SETONE || Code == SETUEQ || Code == SETUNE;
1903}
1904
1905/// Return true if the specified condition returns true if the two operands to
1906/// the condition are equal. Note that if one of the two operands is a NaN,
1907/// this value is meaningless.
1908inline bool isTrueWhenEqual(CondCode Cond) { return ((int)Cond & 1) != 0; }
1909
1910/// This function returns 0 if the condition is always false if an operand is
1911/// a NaN, 1 if the condition is always true if the operand is a NaN, and 2 if
1912/// the condition is undefined if the operand is a NaN.
1914 return ((int)Cond >> 3) & 3;
1915}
1916
1917/// Return the operation corresponding to !(X op Y), where 'op' is a valid
1918/// SetCC operation.
1919LLVM_ABI CondCode getSetCCInverse(CondCode Operation, EVT Type);
1920
1921/// Return the name of the given condition code, e.g. "setoeq".
1923
1924inline bool isExtOpcode(unsigned Opcode) {
1925 return Opcode == ISD::ANY_EXTEND || Opcode == ISD::ZERO_EXTEND ||
1926 Opcode == ISD::SIGN_EXTEND;
1927}
1928
1929inline bool isExtVecInRegOpcode(unsigned Opcode) {
1930 return Opcode == ISD::ANY_EXTEND_VECTOR_INREG ||
1933}
1934
1935namespace GlobalISel {
1936/// Return the operation corresponding to !(X op Y), where 'op' is a valid
1937/// SetCC operation. The U bit of the condition code has different meanings
1938/// between floating point and integer comparisons and LLT's don't provide
1939/// this distinction. As such we need to be told whether the comparison is
1940/// floating point or integer-like. Pointers should use integer-like
1941/// comparisons.
1943} // end namespace GlobalISel
1944
1945/// Return the operation corresponding to (Y op X) when given the operation
1946/// for (X op Y).
1948
1949/// Return the result of a logical OR between different comparisons of
1950/// identical values: ((X op1 Y) | (X op2 Y)). This function returns
1951/// SETCC_INVALID if it is not possible to represent the resultant comparison.
1953
1954/// Return the result of a logical AND between different comparisons of
1955/// identical values: ((X op1 Y) & (X op2 Y)). This function returns
1956/// SETCC_INVALID if it is not possible to represent the resultant comparison.
1958
1959} // namespace ISD
1960
1961} // namespace llvm
1962
1963#endif
#define LLVM_ABI
Definition Compiler.h:211
PowerPC Reduce CR logical Operation
SmallVector< MachineOperand, 4 > Cond
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:46
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
LLVM_ABI CondCode getSetCCInverse(CondCode Operation, bool isIntegerLike)
Return the operation corresponding to !(X op Y), where 'op' is a valid SetCC operation.
ISD namespace - This namespace contains an enum which represents all of the SelectionDAG node types a...
Definition ISDOpcodes.h:26
LLVM_ABI CondCode getSetCCAndOperation(CondCode Op1, CondCode Op2, EVT Type)
Return the result of a logical AND between different comparisons of identical values: ((X op1 Y) & (X...
NodeType
ISD::NodeType enum - This enum defines the target-independent operators for a SelectionDAG.
Definition ISDOpcodes.h:43
@ SETCC
SetCC operator - This evaluates to a true value iff the condition is true.
Definition ISDOpcodes.h:851
@ MERGE_VALUES
MERGE_VALUES - This node takes multiple discrete operands and returns them all as its individual resu...
Definition ISDOpcodes.h:263
@ STACKRESTORE
STACKRESTORE has two operands, an input chain and a pointer to restore to it returns an output chain.
@ STACKSAVE
STACKSAVE - STACKSAVE has one operand, an input chain.
@ TargetConstantPool
Definition ISDOpcodes.h:191
@ CONVERGENCECTRL_ANCHOR
The llvm.experimental.convergence.* intrinsics.
@ MDNODE_SDNODE
MDNODE_SDNODE - This is a node that holdes an MDNode*, which is used to reference metadata in the IR.
@ STRICT_FSETCC
STRICT_FSETCC/STRICT_FSETCCS - Constrained versions of SETCC, used for floating-point operands only.
Definition ISDOpcodes.h:516
@ PTRADD
PTRADD represents pointer arithmetic semantics, for targets that opt in using shouldPreservePtrArith(...
@ DELETED_NODE
DELETED_NODE - This is an illegal value that is used to catch errors.
Definition ISDOpcodes.h:47
@ POISON
POISON - A poison node.
Definition ISDOpcodes.h:238
@ SET_FPENV
Sets the current floating-point environment.
@ PARTIAL_REDUCE_SMLA
PARTIAL_REDUCE_[U|S]MLA(Accumulator, Input1, Input2) The partial reduction nodes sign or zero extend ...
@ ATOMIC_LOAD_FMINIMUMNUM
@ LOOP_DEPENDENCE_RAW_MASK
@ MASK_BEFOREFIRST
Has one mask vector operand.
@ VECREDUCE_SEQ_FADD
Generic reduction nodes.
@ COND_LOOP
COND_LOOP is a conditional branch to self, used for implementing efficient conditional traps.
@ MLOAD
Masked load and store - consecutive vector load and store operations with additional mask operand tha...
@ EH_SJLJ_LONGJMP
OUTCHAIN = EH_SJLJ_LONGJMP(INCHAIN, buffer) This corresponds to the eh.sjlj.longjmp intrinsic.
Definition ISDOpcodes.h:170
@ VECREDUCE_FMINIMUMNUM
@ FGETSIGN
INT = FGETSIGN(FP) - Return the sign bit of the specified floating point value as an integer 0/1 valu...
Definition ISDOpcodes.h:543
@ SMUL_LOHI
SMUL_LOHI/UMUL_LOHI - Multiply two integers of type iN, producing a signed/unsigned value of type i[2...
Definition ISDOpcodes.h:277
@ AVGSUBFLOORS
AVGSUBFLOORS/AVGSUBFLOORU - Averaging subtract - Subtract two integers using an integer of type i[N+1...
Definition ISDOpcodes.h:739
@ INSERT_SUBVECTOR
INSERT_SUBVECTOR(VECTOR1, VECTOR2, IDX) - Returns a vector with VECTOR2 inserted into VECTOR1.
Definition ISDOpcodes.h:605
@ STACKADDRESS
STACKADDRESS - Represents the llvm.stackaddress intrinsic.
Definition ISDOpcodes.h:129
@ JUMP_TABLE_DEBUG_INFO
JUMP_TABLE_DEBUG_INFO - Jumptable debug info.
@ BSWAP
Byte Swap and Counting operators.
Definition ISDOpcodes.h:811
@ SMULFIX
RESULT = [US]MULFIX(LHS, RHS, SCALE) - Perform fixed point multiplication on 2 integers with the same...
Definition ISDOpcodes.h:397
@ VAEND
VAEND, VASTART - VAEND and VASTART have three operands: an input chain, pointer, and a SRCVALUE.
@ TargetBlockAddress
Definition ISDOpcodes.h:193
@ DEACTIVATION_SYMBOL
Untyped node storing deactivation symbol reference (DeactivationSymbolSDNode).
@ ATOMIC_STORE
OUTCHAIN = ATOMIC_STORE(INCHAIN, val, ptr) This corresponds to "store atomic" instruction.
@ ADDC
Carry-setting nodes for multiple precision addition and subtraction.
Definition ISDOpcodes.h:296
@ FRAME_TO_ARGS_OFFSET
FRAME_TO_ARGS_OFFSET - This node represents offset from frame pointer to first (possible) on-stack ar...
Definition ISDOpcodes.h:147
@ RESET_FPENV
Set floating-point environment to default state.
@ FMAD
FMAD - Perform a * b + c, while getting the same result as the separately rounded operations.
Definition ISDOpcodes.h:527
@ ADD
Simple integer binary arithmetic operators.
Definition ISDOpcodes.h:266
@ LOAD
LOAD and STORE have token chains as their first operand, then the same operands as an LLVM load/store...
@ SMULFIXSAT
Same as the corresponding unsaturated fixed point instructions, but the result is clamped between the...
Definition ISDOpcodes.h:403
@ SET_FPMODE
Sets the current dynamic floating-point control modes.
@ ANY_EXTEND
ANY_EXTEND - Used for integer types. The high bits are undefined.
Definition ISDOpcodes.h:885
@ CTTZ_ELTS
Returns the number of number of trailing (least significant) zero elements in a vector.
@ ATOMIC_LOAD_USUB_COND
@ FMA
FMA - Perform a * b + c with no intermediate rounding step.
Definition ISDOpcodes.h:523
@ VECTOR_FIND_LAST_ACTIVE
Finds the index of the last active mask element Operands: Mask.
@ FMODF
FMODF - Decomposes the operand into integral and fractional parts, each having the same type and sign...
@ PSEUDO_FMIN
PSEUDO_FMIN is strictly equivalent to op0 olt op1 ?
@ FATAN2
FATAN2 - atan2, inspired by libm.
@ FSINCOSPI
FSINCOSPI - Compute both the sine and cosine times pi more accurately than FSINCOS(pi*x),...
@ INTRINSIC_VOID
OUTCHAIN = INTRINSIC_VOID(INCHAIN, INTRINSICID, arg1, arg2, ...) This node represents a target intrin...
Definition ISDOpcodes.h:222
@ EH_SJLJ_SETUP_DISPATCH
OUTCHAIN = EH_SJLJ_SETUP_DISPATCH(INCHAIN) The target initializes the dispatch table here.
Definition ISDOpcodes.h:174
@ GlobalAddress
Definition ISDOpcodes.h:90
@ ATOMIC_CMP_SWAP_WITH_SUCCESS
Val, Success, OUTCHAIN = ATOMIC_CMP_SWAP_WITH_SUCCESS(INCHAIN, ptr, cmp, swap) N.b.
@ STRICT_FMINIMUM
Definition ISDOpcodes.h:476
@ SINT_TO_FP
[SU]INT_TO_FP - These operators convert integers (whose interpreted sign depends on the first letter)...
Definition ISDOpcodes.h:912
@ CONCAT_VECTORS
CONCAT_VECTORS(VECTOR0, VECTOR1, ...) - Given a number of values of vector type with the same length ...
Definition ISDOpcodes.h:589
@ VECREDUCE_FMAX
FMIN/FMAX nodes can have flags, for NaN/NoNaN variants.
@ FADD
Simple binary floating point operators.
Definition ISDOpcodes.h:420
@ VECREDUCE_FMAXIMUM
FMINIMUM/FMAXIMUM nodes propatate NaNs and signed zeroes using the llvm.minimum and llvm....
@ VECTOR_SHUFFLE_VAR
VECTOR_SHUFFLE_VAR(VEC, MASK) - Returns VEC permuted by MASK, an integer vector with the same number ...
Definition ISDOpcodes.h:665
@ ABS
ABS - Determine the unsigned absolute value of a signed integer value of the same bitwidth.
Definition ISDOpcodes.h:771
@ MEMBARRIER
MEMBARRIER - Compiler barrier only; generate a no-op.
@ ATOMIC_FENCE
OUTCHAIN = ATOMIC_FENCE(INCHAIN, ordering, scope) This corresponds to the fence instruction.
@ RESET_FPMODE
Sets default dynamic floating-point control modes.
@ SIGN_EXTEND_VECTOR_INREG
SIGN_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register sign-extension of the low ...
Definition ISDOpcodes.h:942
@ SDIVREM
SDIVREM/UDIVREM - Divide two integers and produce both a quotient and remainder result.
Definition ISDOpcodes.h:282
@ FP16_TO_FP
FP16_TO_FP, FP_TO_FP16 - These operators are used to perform promotions and truncation for half-preci...
@ FMULADD
FMULADD - Performs a * b + c, with, or without, intermediate rounding.
Definition ISDOpcodes.h:533
@ FPTRUNC_ROUND
FPTRUNC_ROUND - This corresponds to the fptrunc_round intrinsic.
Definition ISDOpcodes.h:520
@ FAKE_USE
FAKE_USE represents a use of the operand but does not do anything.
@ BITCAST
BITCAST - This operator converts between integer, vector and FP values, as if the value was stored to...
@ STRICT_PSEUDO_FMAX
Definition ISDOpcodes.h:465
@ BUILD_PAIR
BUILD_PAIR - This is the opposite of EXTRACT_ELEMENT in some ways.
Definition ISDOpcodes.h:256
@ CLMUL
Carry-less multiplication operations.
Definition ISDOpcodes.h:802
@ INIT_TRAMPOLINE
INIT_TRAMPOLINE - This corresponds to the init_trampoline intrinsic.
@ FLDEXP
FLDEXP - ldexp, inspired by libm (op0 * 2**op1).
@ SDIVFIX
RESULT = [US]DIVFIX(LHS, RHS, SCALE) - Perform fixed point division on 2 integers with the same width...
Definition ISDOpcodes.h:410
@ STRICT_FSQRT
Constrained versions of libm-equivalent floating point intrinsics.
Definition ISDOpcodes.h:441
@ BUILTIN_OP_END
BUILTIN_OP_END - This must be the last enum value in this list.
@ GlobalTLSAddress
Definition ISDOpcodes.h:91
@ SRCVALUE
SRCVALUE - This is a node type that holds a Value* that is used to make reference to a value in the L...
@ CONVERT_FROM_ARBITRARY_FP
CONVERT_FROM_ARBITRARY_FP - This operator converts from an arbitrary floating-point represented as an...
@ EH_LABEL
EH_LABEL - Represents a label in mid basic block used to track locations needed for debug and excepti...
@ ATOMIC_LOAD_USUB_SAT
@ CTLZ_ZERO_POISON
Definition ISDOpcodes.h:820
@ EH_RETURN
OUTCHAIN = EH_RETURN(INCHAIN, OFFSET, HANDLER) - This node represents 'eh_return' gcc dwarf builtin,...
Definition ISDOpcodes.h:158
@ ANNOTATION_LABEL
ANNOTATION_LABEL - Represents a mid basic block label used by annotations.
@ SET_ROUNDING
Set rounding mode.
@ CONVERGENCECTRL_GLUE
This does not correspond to any convergence control intrinsic.
@ PARTIAL_REDUCE_UMLA
@ SIGN_EXTEND
Conversion operators.
Definition ISDOpcodes.h:876
@ AVGCEILS
AVGCEILS/AVGCEILU - Rounding averaging add - Add two integers using an integer of type i[N+2],...
Definition ISDOpcodes.h:731
@ STRICT_UINT_TO_FP
Definition ISDOpcodes.h:490
@ SCALAR_TO_VECTOR
SCALAR_TO_VECTOR(VAL) - This represents the operation of loading a scalar value into element 0 of the...
Definition ISDOpcodes.h:681
@ PREALLOCATED_SETUP
PREALLOCATED_SETUP - This has 2 operands: an input chain and a SRCVALUE with the preallocated call Va...
@ READSTEADYCOUNTER
READSTEADYCOUNTER - This corresponds to the readfixedcounter intrinsic.
@ ADDROFRETURNADDR
ADDROFRETURNADDR - Represents the llvm.addressofreturnaddress intrinsic.
Definition ISDOpcodes.h:119
@ TargetExternalSymbol
Definition ISDOpcodes.h:192
@ CONVERGENCECTRL_ENTRY
@ BR
Control flow instructions. These all have token chains.
@ VECREDUCE_FADD
These reductions have relaxed evaluation order semantics, and have a single vector operand.
@ TargetJumpTable
Definition ISDOpcodes.h:190
@ TargetIndex
TargetIndex - Like a constant pool entry, but with completely target-dependent semantics.
Definition ISDOpcodes.h:200
@ PARTIAL_REDUCE_FMLA
@ PREFETCH
PREFETCH - This corresponds to a prefetch intrinsic.
@ STRICT_PSEUDO_FMIN
Definition ISDOpcodes.h:464
@ TRUNCATE_SSAT_U
Definition ISDOpcodes.h:905
@ VECREDUCE_FMAXIMUMNUM
FMINIMUMNUM/FMAXIMUMNUM nodes do not propagate NaNs and order signed zeroes using the llvm....
@ FSINCOS
FSINCOS - Compute both fsin and fcos as a single operation.
@ 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:859
@ FNEG
Perform various unary floating-point operations inspired by libm.
@ BR_CC
BR_CC - Conditional branch.
@ SSUBO
Same for subtraction.
Definition ISDOpcodes.h:355
@ PREALLOCATED_ARG
PREALLOCATED_ARG - This has 3 operands: an input chain, a SRCVALUE with the preallocated call Value,...
@ BRIND
BRIND - Indirect branch.
@ BR_JT
BR_JT - Jumptable branch.
@ GC_TRANSITION_START
GC_TRANSITION_START/GC_TRANSITION_END - These operators mark the beginning and end of GC transition s...
@ VECTOR_INTERLEAVE
VECTOR_INTERLEAVE(VEC1, VEC2, ...) - Returns N vectors from N input vectors, where N is the factor to...
Definition ISDOpcodes.h:640
@ STEP_VECTOR
STEP_VECTOR(IMM) - Returns a scalable vector whose lanes are comprised of a linear sequence of unsign...
Definition ISDOpcodes.h:707
@ FCANONICALIZE
Returns platform specific canonical encoding of a floating point number.
Definition ISDOpcodes.h:546
@ IS_FPCLASS
Performs a check of floating point class property, defined by IEEE-754.
Definition ISDOpcodes.h:553
@ SSUBSAT
RESULT = [US]SUBSAT(LHS, RHS) - Perform saturation subtraction on 2 integers with the same bit width ...
Definition ISDOpcodes.h:377
@ SELECT
Select(COND, TRUEVAL, FALSEVAL).
Definition ISDOpcodes.h:828
@ ATOMIC_LOAD
Val, OUTCHAIN = ATOMIC_LOAD(INCHAIN, ptr) This corresponds to "load atomic" instruction.
@ UNDEF
UNDEF - An undefined node.
Definition ISDOpcodes.h:235
@ EXTRACT_ELEMENT
EXTRACT_ELEMENT - This is used to get the lower or upper (determined by a Constant,...
Definition ISDOpcodes.h:249
@ SPLAT_VECTOR
SPLAT_VECTOR(VAL) - Returns a vector with the scalar value VAL duplicated in all lanes.
Definition ISDOpcodes.h:688
@ AssertAlign
AssertAlign - These nodes record if a register contains a value that has a known alignment and the tr...
Definition ISDOpcodes.h:71
@ VACOPY
VACOPY - VACOPY has 5 operands: an input chain, a destination pointer, a source pointer,...
@ GET_ACTIVE_LANE_MASK
GET_ACTIVE_LANE_MASK - this corrosponds to the llvm.get.active.lane.mask intrinsic.
@ BasicBlock
Various leaf nodes.
Definition ISDOpcodes.h:83
@ CopyFromReg
CopyFromReg - This node indicates that the input value is a virtual or physical register that is defi...
Definition ISDOpcodes.h:232
@ SADDO
RESULT, BOOL = [SU]ADDO(LHS, RHS) - Overflow-aware nodes for addition.
Definition ISDOpcodes.h:351
@ TargetGlobalAddress
TargetGlobalAddress - Like GlobalAddress, but the DAG does no folding or anything else with this node...
Definition ISDOpcodes.h:187
@ ARITH_FENCE
ARITH_FENCE - This corresponds to a arithmetic fence intrinsic.
@ CTLS
Count leading redundant sign bits.
Definition ISDOpcodes.h:824
@ VECREDUCE_ADD
Integer reductions may have a result type larger than the vector element type.
@ GET_ROUNDING
Returns current rounding mode: -1 Undefined 0 Round to 0 1 Round to nearest, ties to even 2 Round to ...
@ STRICT_FP_TO_FP16
@ MULHU
MULHU/MULHS - Multiply high - Multiply two integers of type iN, producing an unsigned/signed value of...
Definition ISDOpcodes.h:720
@ CLEANUPRET
CLEANUPRET - Represents a return from a cleanup block funclet.
@ ATOMIC_LOAD_FMAXIMUM
@ GET_FPMODE
Reads the current dynamic floating-point control modes.
@ STRICT_FP16_TO_FP
@ GET_FPENV
Gets the current floating-point environment.
@ SHL
Shift and rotation operations.
Definition ISDOpcodes.h:793
@ AssertNoFPClass
AssertNoFPClass - These nodes record if a register contains a float value that is known to be not som...
Definition ISDOpcodes.h:80
@ VECTOR_SHUFFLE
VECTOR_SHUFFLE(VEC1, VEC2) - Returns a vector, of the same type as VEC1/VEC2.
Definition ISDOpcodes.h:659
@ PtrAuthGlobalAddress
A ptrauth constant.
Definition ISDOpcodes.h:102
@ EXTRACT_SUBVECTOR
EXTRACT_SUBVECTOR(VECTOR, IDX) - Returns a subvector from VECTOR.
Definition ISDOpcodes.h:619
@ FMINNUM_IEEE
FMINNUM_IEEE/FMAXNUM_IEEE - Same as FMINNUM/FMAXNUM, except that a signaling NaN operand deterministi...
@ STRICT_FMAXIMUM
Definition ISDOpcodes.h:475
@ EntryToken
EntryToken - This is the marker used to indicate the start of a region.
Definition ISDOpcodes.h:50
@ READ_REGISTER
READ_REGISTER, WRITE_REGISTER - This node represents llvm.register on the DAG, which implements the n...
Definition ISDOpcodes.h:141
@ EXTRACT_VECTOR_ELT
EXTRACT_VECTOR_ELT(VECTOR, IDX) - Returns a single element from VECTOR identified by the (potentially...
Definition ISDOpcodes.h:581
@ CopyToReg
CopyToReg - This node has three operands: a chain, a register number to set to this value,...
Definition ISDOpcodes.h:226
@ ZERO_EXTEND
ZERO_EXTEND - Used for integer types, zeroing the new bits.
Definition ISDOpcodes.h:882
@ TargetConstantFP
Definition ISDOpcodes.h:182
@ DEBUGTRAP
DEBUGTRAP - Trap intended to get the attention of a debugger.
@ SELECT_CC
Select with condition operator - This selects between a true value and a false value (ops #2 and #3) ...
Definition ISDOpcodes.h:843
@ VSCALE
VSCALE(IMM) - Returns the runtime scaling factor used to calculate the number of elements within a sc...
@ ATOMIC_CMP_SWAP
Val, OUTCHAIN = ATOMIC_CMP_SWAP(INCHAIN, ptr, cmp, swap) For double-word atomic operations: ValLo,...
@ LOCAL_RECOVER
LOCAL_RECOVER - Represents the llvm.localrecover intrinsic.
Definition ISDOpcodes.h:137
@ FMINNUM
FMINNUM/FMAXNUM - Same semantics as the llvm.minnum/maxnum intrinsics.
@ UBSANTRAP
UBSANTRAP - Trap with an immediate describing the kind of sanitizer failure.
@ SSHLSAT
RESULT = [US]SHLSAT(LHS, RHS) - Perform saturation left shift.
Definition ISDOpcodes.h:389
@ PATCHPOINT
The llvm.experimental.patchpoint.
@ SMULO
Same for multiplication.
Definition ISDOpcodes.h:359
@ ATOMIC_LOAD_FMINIMUM
@ DYNAMIC_STACKALLOC
DYNAMIC_STACKALLOC - Allocate some number of bytes on the stack aligned to a specified boundary.
@ TargetFrameIndex
Definition ISDOpcodes.h:189
@ VECTOR_SPLICE_LEFT
VECTOR_SPLICE_LEFT(VEC1, VEC2, OFFSET) - Shifts CONCAT_VECTORS(VEC1, VEC2) left by OFFSET elements an...
Definition ISDOpcodes.h:669
@ ANY_EXTEND_VECTOR_INREG
ANY_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register any-extension of the low la...
Definition ISDOpcodes.h:931
@ SIGN_EXTEND_INREG
SIGN_EXTEND_INREG - This operator atomically performs a SHL/SRA pair to sign extend a small value in ...
Definition ISDOpcodes.h:920
@ SMIN
[US]{MIN/MAX} - Binary minimum or maximum of signed or unsigned integers.
Definition ISDOpcodes.h:751
@ MASKED_UDIV
Masked vector arithmetic that returns poison on disabled lanes.
@ VECTOR_REVERSE
VECTOR_REVERSE(VECTOR) - Returns a vector, of the same type as VECTOR, whose elements are shuffled us...
Definition ISDOpcodes.h:650
@ LIFETIME_START
This corresponds to the llvm.lifetime.
@ SDIVFIXSAT
Same as the corresponding unsaturated fixed point instructions, but the result is clamped between the...
Definition ISDOpcodes.h:416
@ FP_EXTEND
X = FP_EXTEND(Y) - Extend a smaller FP type into a larger FP type.
@ GLOBAL_OFFSET_TABLE
The address of the GOT.
Definition ISDOpcodes.h:105
@ VSELECT
Select with a vector condition (op #0) and two vector operands (ops #1 and #2), returning a vector re...
Definition ISDOpcodes.h:837
@ UADDO_CARRY
Carry-using nodes for multiple precision addition and subtraction.
Definition ISDOpcodes.h:331
@ STRICT_SINT_TO_FP
STRICT_[US]INT_TO_FP - Convert a signed or unsigned integer to a floating point value.
Definition ISDOpcodes.h:489
@ MGATHER
Masked gather and scatter - load and store operations for a vector of random addresses with additiona...
@ HANDLENODE
HANDLENODE node - Used as a handle for various purposes.
@ STRICT_BF16_TO_FP
@ PCMARKER
PCMARKER - This corresponds to the pcmarker intrinsic.
@ STRICT_FROUNDEVEN
Definition ISDOpcodes.h:469
@ INLINEASM_BR
INLINEASM_BR - Branching version of inline asm. Used by asm-goto.
@ ATOMIC_LOAD_FMAXIMUMNUM
@ EH_DWARF_CFA
EH_DWARF_CFA - This node represents the pointer to the DWARF Canonical Frame Address (CFA),...
Definition ISDOpcodes.h:152
@ BF16_TO_FP
BF16_TO_FP, FP_TO_BF16 - These operators are used to perform promotions and truncation for bfloat16.
@ FRAMEADDR
FRAMEADDR, RETURNADDR - These nodes represent llvm.frameaddress and llvm.returnaddress on the DAG.
Definition ISDOpcodes.h:112
@ ATOMIC_LOAD_UDEC_WRAP
@ STRICT_FP_TO_UINT
Definition ISDOpcodes.h:483
@ PEXT
Parallel bit extract (compress) and parallel bit deposit (expand).
Definition ISDOpcodes.h:807
@ STRICT_FP_ROUND
X = STRICT_FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating point type down to the precision ...
Definition ISDOpcodes.h:505
@ STRICT_FP_TO_SINT
STRICT_FP_TO_[US]INT - Convert a floating point value to a signed or unsigned integer.
Definition ISDOpcodes.h:482
@ FMINIMUM
FMINIMUM/FMAXIMUM - Same semantics as the llvm.minimum/maximum intrinsics.
@ FP_TO_SINT
FP_TO_[US]INT - Convert a floating point value to a signed or unsigned integer.
Definition ISDOpcodes.h:958
@ READCYCLECOUNTER
READCYCLECOUNTER - This corresponds to the readcyclecounter intrinsic.
@ TargetConstant
TargetConstant* - Like Constant*, but the DAG does not do any folding, simplification,...
Definition ISDOpcodes.h:181
@ STRICT_FP_EXTEND
X = STRICT_FP_EXTEND(Y) - Extend a smaller FP type into a larger FP type.
Definition ISDOpcodes.h:510
@ RELOC_NONE
Issue a no-op relocation against a given symbol at the current location.
@ AND
Bitwise operators - logical and, logical or, logical xor.
Definition ISDOpcodes.h:763
@ TRAP
TRAP - Trapping instruction.
@ INTRINSIC_WO_CHAIN
RESULT = INTRINSIC_WO_CHAIN(INTRINSICID, arg1, arg2, ...) This node represents a target intrinsic fun...
Definition ISDOpcodes.h:207
@ GET_FPENV_MEM
Gets the current floating-point environment.
@ PSEUDO_PROBE
Pseudo probe for AutoFDO, as a place holder in a basic block to improve the sample counts quality.
@ STRICT_FP_TO_BF16
@ SCMP
[US]CMP - 3-way comparison of signed or unsigned integers.
Definition ISDOpcodes.h:759
@ CARRY_FALSE
CARRY_FALSE - This node is used when folding other nodes, like ADDC/SUBC, which indicate the carry re...
Definition ISDOpcodes.h:287
@ AVGFLOORS
AVGFLOORS/AVGFLOORU - Averaging add - Add two integers using an integer of type i[N+1],...
Definition ISDOpcodes.h:726
@ VECTOR_MATCH
VECTOR_MATCH - this corresponds to the llvm.experimental.vector.match intrinsic.
@ VECTOR_SPLICE_RIGHT
VECTOR_SPLICE_RIGHT(VEC1, VEC2, OFFSET) - Shifts CONCAT_VECTORS(VEC1,VEC2) right by OFFSET elements a...
Definition ISDOpcodes.h:673
@ ADDE
Carry-using nodes for multiple precision addition and subtraction.
Definition ISDOpcodes.h:306
@ STRICT_FADD
Constrained versions of the binary floating point operators.
Definition ISDOpcodes.h:430
@ STACKMAP
The llvm.experimental.stackmap intrinsic.
@ SPLAT_VECTOR_PARTS
SPLAT_VECTOR_PARTS(SCALAR1, SCALAR2, ...) - Returns a vector with the scalar values joined together a...
Definition ISDOpcodes.h:697
@ FREEZE
FREEZE - FREEZE(VAL) returns an arbitrary value if VAL is UNDEF (or is evaluated to UNDEF),...
Definition ISDOpcodes.h:243
@ INSERT_VECTOR_ELT
INSERT_VECTOR_ELT(VECTOR, VAL, IDX) - Returns VECTOR with the element at IDX replaced with VAL.
Definition ISDOpcodes.h:570
@ TokenFactor
TokenFactor - This node takes multiple tokens as input and produces a single token result.
Definition ISDOpcodes.h:55
@ ATOMIC_SWAP
Val, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amt) Val, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN,...
@ CTTZ_ZERO_POISON
Bit counting operators with a poisoned result for zero inputs.
Definition ISDOpcodes.h:819
@ ExternalSymbol
Definition ISDOpcodes.h:95
@ FFREXP
FFREXP - frexp, extract fractional and exponent component of a floating-point value.
@ FP_ROUND
X = FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating point type down to the precision of the ...
Definition ISDOpcodes.h:991
@ VECTOR_COMPRESS
VECTOR_COMPRESS(Vec, Mask, Passthru) consecutively place vector elements based on mask e....
Definition ISDOpcodes.h:715
@ SPONENTRY
SPONENTRY - Represents the llvm.sponentry intrinsic.
Definition ISDOpcodes.h:124
@ CLEAR_CACHE
llvm.clear_cache intrinsic Operands: Input Chain, Start Addres, End Address Outputs: Output Chain
@ CONVERGENCECTRL_LOOP
@ ZERO_EXTEND_VECTOR_INREG
ZERO_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register zero-extension of the low ...
Definition ISDOpcodes.h:953
@ ADDRSPACECAST
ADDRSPACECAST - This operator converts between pointers of different address spaces.
@ EXPERIMENTAL_VECTOR_HISTOGRAM
Experimental vector histogram intrinsic Operands: Input Chain, Inc, Mask, Base, Index,...
@ INLINEASM
INLINEASM - Represents an inline asm block.
@ STRICT_FNEARBYINT
Definition ISDOpcodes.h:461
@ 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:977
@ VECREDUCE_FMINIMUM
@ EH_SJLJ_SETJMP
RESULT, OUTCHAIN = EH_SJLJ_SETJMP(INCHAIN, buffer) This corresponds to the eh.sjlj....
Definition ISDOpcodes.h:164
@ TRUNCATE
TRUNCATE - Completely drop the high bits.
Definition ISDOpcodes.h:888
@ VAARG
VAARG - VAARG has four operands: an input chain, a pointer, a SRCVALUE, and the alignment.
@ BRCOND
BRCOND - Conditional branch.
@ VECREDUCE_SEQ_FMUL
@ CONVERT_TO_ARBITRARY_FP
CONVERT_TO_ARBITRARY_FP - Converts a native FP value to an arbitrary floating-point format,...
@ SHL_PARTS
SHL_PARTS/SRA_PARTS/SRL_PARTS - These operators are used for expanded integer shift operations.
Definition ISDOpcodes.h:865
@ CATCHRET
CATCHRET - Represents a return from a catch block funclet.
@ GC_TRANSITION_END
@ AssertSext
AssertSext, AssertZext - These nodes record if a register contains a value that has already been zero...
Definition ISDOpcodes.h:64
@ ATOMIC_LOAD_UINC_WRAP
@ FCOPYSIGN
FCOPYSIGN(X, Y) - Return the value of X with the sign of Y.
Definition ISDOpcodes.h:539
@ PARTIAL_REDUCE_SUMLA
@ SADDSAT
RESULT = [US]ADDSAT(LHS, RHS) - Perform saturation addition on 2 integers with the same bit width (W)...
Definition ISDOpcodes.h:368
@ CALLSEQ_START
CALLSEQ_START/CALLSEQ_END - These operators mark the beginning and end of a call sequence,...
@ VECTOR_REPEAT
VECTOR_REPEAT(FIXED_LENGTH_VECTOR) Repeatedly copies the elements of the source fixed-length vector t...
Definition ISDOpcodes.h:645
@ VECTOR_DEINTERLEAVE
VECTOR_DEINTERLEAVE(VEC1, VEC2, ...) - Returns N vectors from N input vectors, where N is the factor ...
Definition ISDOpcodes.h:629
@ GET_DYNAMIC_AREA_OFFSET
GET_DYNAMIC_AREA_OFFSET - get offset from native SP to the address of the most recent dynamic alloca.
@ CTTZ_ELTS_ZERO_POISON
@ SET_FPENV_MEM
Sets the current floating point environment.
@ FMINIMUMNUM
FMINIMUMNUM/FMAXIMUMNUM - Same semantics as the llvm.minimumnum/maximumnum intrinsics.
@ TRUNCATE_SSAT_S
TRUNCATE_[SU]SAT_[SU] - Truncate for saturated operand [SU] located in middle, prefix for SAT means i...
Definition ISDOpcodes.h:903
@ ABDS
ABDS/ABDU - Absolute difference - Return the absolute difference between two numbers interpreted as s...
Definition ISDOpcodes.h:746
@ ADJUST_TRAMPOLINE
ADJUST_TRAMPOLINE - This corresponds to the adjust_trampoline intrinsic.
@ TRUNCATE_USAT_U
Definition ISDOpcodes.h:907
@ SADDO_CARRY
Carry-using overflow-aware nodes for multiple precision addition and subtraction.
Definition ISDOpcodes.h:341
@ INTRINSIC_W_CHAIN
RESULT,OUTCHAIN = INTRINSIC_W_CHAIN(INCHAIN, INTRINSICID, arg1, ...) This node represents a target in...
Definition ISDOpcodes.h:215
@ TargetGlobalTLSAddress
Definition ISDOpcodes.h:188
@ ABS_MIN_POISON
ABS with a poison result for INT_MIN.
Definition ISDOpcodes.h:775
@ BUILD_VECTOR
BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a fixed-width vector with the specified,...
Definition ISDOpcodes.h:561
@ LOOP_DEPENDENCE_WAR_MASK
The llvm.loop.dependence.
bool isIndexTypeSigned(MemIndexType IndexType)
bool isExtVecInRegOpcode(unsigned Opcode)
LLVM_ABI NodeType getOppositeSignednessMinMaxOpcode(unsigned MinMaxOpc)
Given a MinMaxOpc of ISD::(U|S)MIN or ISD::(U|S)MAX, returns the corresponding opcode with the opposi...
LLVM_ABI NodeType getExtForLoadExtType(bool IsFP, LoadExtType)
bool isMinMaxOpcode(unsigned Opcode)
Whether this is an integer min/max opcode (ISD::(U|S)MIN or ISD::(U|S)MAX).
bool isFPEqualitySetCC(CondCode Code)
Return true if this is a setcc instruction that performs an equality comparison when used with floati...
bool isExtOpcode(unsigned Opcode)
static const int LAST_LOADEXT_TYPE
LLVM_ABI NodeType getUnmaskedBinOpOpcode(unsigned MaskedOpc)
Given a MaskedOpc of ISD::MASKED_(U|S)(DIV|REM), returns the unmasked ISD::(U|S)(DIV|REM).
LLVM_ABI bool isVPBinaryOp(unsigned Opcode)
Whether this is a vector-predicated binary operation opcode.
LLVM_ABI CondCode getSetCCInverse(CondCode Operation, EVT Type)
Return the operation corresponding to !(X op Y), where 'op' is a valid SetCC operation.
LLVM_ABI std::optional< unsigned > getBaseOpcodeForVP(unsigned Opcode, bool hasFPExcept)
Translate this VP Opcode to its corresponding non-VP Opcode.
CondCode getUnsignedSetCC(CondCode Code)
Convert a signed integer condition code to unsigned.
bool isBitwiseLogicOp(unsigned Opcode)
Whether this is bitwise logic opcode.
bool isTrueWhenEqual(CondCode Cond)
Return true if the specified condition returns true if the two operands to the condition are equal.
LLVM_ABI std::optional< unsigned > getVPMaskIdx(unsigned Opcode)
The operand position of the vector mask.
static const int LAST_MEM_INDEX_TYPE
unsigned getUnorderedFlavor(CondCode Cond)
This function returns 0 if the condition is always false if an operand is a NaN, 1 if the condition i...
LLVM_ABI std::optional< unsigned > getVPExplicitVectorLengthIdx(unsigned Opcode)
The operand position of the explicit vector length parameter.
LLVM_ABI CondCode getSetCCSwappedOperands(CondCode Operation)
Return the operation corresponding to (Y op X) when given the operation for (X op Y).
LLVM_ABI std::optional< unsigned > getVPForBaseOpcode(unsigned Opcode)
Translate this non-VP Opcode to its corresponding VP Opcode.
MemIndexType
MemIndexType enum - This enum defines how to interpret MGATHER/SCATTER's index parameter when calcula...
LLVM_ABI StringRef getCondCodeName(CondCode Operation)
Return the name of the given condition code, e.g. "setoeq".
bool isSignedIntSetCC(CondCode Code)
Return true if this is a setcc instruction that performs a signed comparison when used with integer o...
LLVM_ABI NodeType getInverseMinMaxOpcode(unsigned MinMaxOpc)
Given a MinMaxOpc of ISD::(U|S)MIN or ISD::(U|S)MAX, returns ISD::(U|S)MAX and ISD::(U|S)MIN,...
LLVM_ABI bool isVPReduction(unsigned Opcode)
Whether this is a vector-predicated reduction opcode.
MemIndexedMode
MemIndexedMode enum - This enum defines the load / store indexed addressing modes.
CondCode
ISD::CondCode enum - These are ordered carefully to make the bitfields below work out,...
LLVM_ABI NodeType getVecReduceBaseOpcode(unsigned VecReduceOpcode)
Get underlying scalar opcode for VECREDUCE opcode.
LoadExtType
LoadExtType enum - This enum defines the three variants of LOADEXT (load with extension).
bool isAbsOpcode(unsigned Opcode)
Whether this is an integer absolute-value opcode (ISD::ABS or ISD::ABS_MIN_POISON).
bool isUnsignedIntSetCC(CondCode Code)
Return true if this is a setcc instruction that performs an unsigned comparison when used with intege...
static const int LAST_INDEXED_MODE
LLVM_ABI bool isVPOpcode(unsigned Opcode)
Whether this is a vector-predicated Opcode.
LLVM_ABI CondCode getSetCCOrOperation(CondCode Op1, CondCode Op2, EVT Type)
Return the result of a logical OR between different comparisons of identical values: ((X op1 Y) | (X ...
bool isIntEqualitySetCC(CondCode Code)
Return true if this is a setcc instruction that performs an equality comparison when used with intege...
This is an optimization pass for GlobalISel generic memory operations.
Extended Value Type.
Definition ValueTypes.h:35