include/llvm/CodeGen/ISDOpcodes.h

   1 //===-- llvm/CodeGen/ISDOpcodes.h - CodeGen opcodes -------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file declares codegen opcodes and related utilities.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CODEGEN_ISDOPCODES_H
  15 #define LLVM_CODEGEN_ISDOPCODES_H
  16
  17 namespace llvm {
  18
  19 /// ISD namespace - This namespace contains an enum which represents all of the
  20 /// SelectionDAG node types and value types.
  21 ///
  22 namespace ISD {
  23
  24   //===--------------------------------------------------------------------===//
  25   /// ISD::NodeType enum - This enum defines the target-independent operators
  26   /// for a SelectionDAG.
  27   ///
  28   /// Targets may also define target-dependent operator codes for SDNodes. For
  29   /// example, on x86, these are the enum values in the X86ISD namespace.
  30   /// Targets should aim to use target-independent operators to model their
  31   /// instruction sets as much as possible, and only use target-dependent
  32   /// operators when they have special requirements.
  33   ///
  34   /// Finally, during and after selection proper, SNodes may use special
  35   /// operator codes that correspond directly with MachineInstr opcodes. These
  36   /// are used to represent selected instructions. See the isMachineOpcode()
  37   /// and getMachineOpcode() member functions of SDNode.
  38   ///
  39   enum NodeType {
  40     /// DELETED_NODE - This is an illegal value that is used to catch
  41     /// errors.  This opcode is not a legal opcode for any node.
  42     DELETED_NODE,
  43
  44     /// EntryToken - This is the marker used to indicate the start of a region.
  45     EntryToken,
  46
  47     /// TokenFactor - This node takes multiple tokens as input and produces a
  48     /// single token result. This is used to represent the fact that the operand
  49     /// operators are independent of each other.
  50     TokenFactor,
  51
  52     /// AssertSext, AssertZext - These nodes record if a register contains a
  53     /// value that has already been zero or sign extended from a narrower type.
  54     /// These nodes take two operands.  The first is the node that has already
  55     /// been extended, and the second is a value type node indicating the width
  56     /// of the extension
  57     AssertSext, AssertZext,
  58
  59     /// Various leaf nodes.
  60     BasicBlock, VALUETYPE, CONDCODE, Register, RegisterMask,
  61     Constant, ConstantFP,
  62     GlobalAddress, GlobalTLSAddress, FrameIndex,
  63     JumpTable, ConstantPool, ExternalSymbol, BlockAddress,
  64
  65     /// The address of the GOT
  66     GLOBAL_OFFSET_TABLE,
  67
  68     /// FRAMEADDR, RETURNADDR - These nodes represent llvm.frameaddress and
  69     /// llvm.returnaddress on the DAG.  These nodes take one operand, the index
  70     /// of the frame or return address to return.  An index of zero corresponds
  71     /// to the current function's frame or return address, an index of one to
  72     /// the parent's frame or return address, and so on.
  73     FRAMEADDR, RETURNADDR,
  74
  75     /// LOCAL_RECOVER - Represents the llvm.localrecover intrinsic.
  76     /// Materializes the offset from the local object pointer of another
  77     /// function to a particular local object passed to llvm.localescape. The
  78     /// operand is the MCSymbol label used to represent this offset, since
  79     /// typically the offset is not known until after code generation of the
  80     /// parent.
  81     LOCAL_RECOVER,
  82
  83     /// READ_REGISTER, WRITE_REGISTER - This node represents llvm.register on
  84     /// the DAG, which implements the named register global variables extension.
  85     READ_REGISTER,
  86     WRITE_REGISTER,
  87
  88     /// FRAME_TO_ARGS_OFFSET - This node represents offset from frame pointer to
  89     /// first (possible) on-stack argument. This is needed for correct stack
  90     /// adjustment during unwind.
  91     FRAME_TO_ARGS_OFFSET,
  92
  93     /// OUTCHAIN = EH_RETURN(INCHAIN, OFFSET, HANDLER) - This node represents
  94     /// 'eh_return' gcc dwarf builtin, which is used to return from
  95     /// exception. The general meaning is: adjust stack by OFFSET and pass
  96     /// execution to HANDLER. Many platform-related details also :)
  97     EH_RETURN,
  98
  99     /// RESULT, OUTCHAIN = EH_SJLJ_SETJMP(INCHAIN, buffer)
 100     /// This corresponds to the eh.sjlj.setjmp intrinsic.
 101     /// It takes an input chain and a pointer to the jump buffer as inputs
 102     /// and returns an outchain.
 103     EH_SJLJ_SETJMP,
 104
 105     /// OUTCHAIN = EH_SJLJ_LONGJMP(INCHAIN, buffer)
 106     /// This corresponds to the eh.sjlj.longjmp intrinsic.
 107     /// It takes an input chain and a pointer to the jump buffer as inputs
 108     /// and returns an outchain.
 109     EH_SJLJ_LONGJMP,
 110
 111     /// OUTCHAIN = EH_SJLJ_SETUP_DISPATCH(INCHAIN)
 112     /// The target initializes the dispatch table here.
 113     EH_SJLJ_SETUP_DISPATCH,
 114
 115     /// TargetConstant* - Like Constant*, but the DAG does not do any folding,
 116     /// simplification, or lowering of the constant. They are used for constants
 117     /// which are known to fit in the immediate fields of their users, or for
 118     /// carrying magic numbers which are not values which need to be
 119     /// materialized in registers.
 120     TargetConstant,
 121     TargetConstantFP,
 122
 123     /// TargetGlobalAddress - Like GlobalAddress, but the DAG does no folding or
 124     /// anything else with this node, and this is valid in the target-specific
 125     /// dag, turning into a GlobalAddress operand.
 126     TargetGlobalAddress,
 127     TargetGlobalTLSAddress,
 128     TargetFrameIndex,
 129     TargetJumpTable,
 130     TargetConstantPool,
 131     TargetExternalSymbol,
 132     TargetBlockAddress,
 133
 134     MCSymbol,
 135
 136     /// TargetIndex - Like a constant pool entry, but with completely
 137     /// target-dependent semantics. Holds target flags, a 32-bit index, and a
 138     /// 64-bit index. Targets can use this however they like.
 139     TargetIndex,
 140
 141     /// RESULT = INTRINSIC_WO_CHAIN(INTRINSICID, arg1, arg2, ...)
 142     /// This node represents a target intrinsic function with no side effects.
 143     /// The first operand is the ID number of the intrinsic from the
 144     /// llvm::Intrinsic namespace.  The operands to the intrinsic follow.  The
 145     /// node returns the result of the intrinsic.
 146     INTRINSIC_WO_CHAIN,
 147
 148     /// RESULT,OUTCHAIN = INTRINSIC_W_CHAIN(INCHAIN, INTRINSICID, arg1, ...)
 149     /// This node represents a target intrinsic function with side effects that
 150     /// returns a result.  The first operand is a chain pointer.  The second is
 151     /// the ID number of the intrinsic from the llvm::Intrinsic namespace.  The
 152     /// operands to the intrinsic follow.  The node has two results, the result
 153     /// of the intrinsic and an output chain.
 154     INTRINSIC_W_CHAIN,
 155
 156     /// OUTCHAIN = INTRINSIC_VOID(INCHAIN, INTRINSICID, arg1, arg2, ...)
 157     /// This node represents a target intrinsic function with side effects that
 158     /// does not return a result.  The first operand is a chain pointer.  The
 159     /// second is the ID number of the intrinsic from the llvm::Intrinsic
 160     /// namespace.  The operands to the intrinsic follow.
 161     INTRINSIC_VOID,
 162
 163     /// CopyToReg - This node has three operands: a chain, a register number to
 164     /// set to this value, and a value.
 165     CopyToReg,
 166
 167     /// CopyFromReg - This node indicates that the input value is a virtual or
 168     /// physical register that is defined outside of the scope of this
 169     /// SelectionDAG.  The register is available from the RegisterSDNode object.
 170     CopyFromReg,
 171
 172     /// UNDEF - An undefined node.
 173     UNDEF,
 174
 175     /// EXTRACT_ELEMENT - This is used to get the lower or upper (determined by
 176     /// a Constant, which is required to be operand #1) half of the integer or
 177     /// float value specified as operand #0.  This is only for use before
 178     /// legalization, for values that will be broken into multiple registers.
 179     EXTRACT_ELEMENT,
 180
 181     /// BUILD_PAIR - This is the opposite of EXTRACT_ELEMENT in some ways.
 182     /// Given two values of the same integer value type, this produces a value
 183     /// twice as big.  Like EXTRACT_ELEMENT, this can only be used before
 184     /// legalization.
 185     BUILD_PAIR,
 186
 187     /// MERGE_VALUES - This node takes multiple discrete operands and returns
 188     /// them all as its individual results.  This nodes has exactly the same
 189     /// number of inputs and outputs. This node is useful for some pieces of the
 190     /// code generator that want to think about a single node with multiple
 191     /// results, not multiple nodes.
 192     MERGE_VALUES,
 193
 194     /// Simple integer binary arithmetic operators.
 195     ADD, SUB, MUL, SDIV, UDIV, SREM, UREM,
 196
 197     /// SMUL_LOHI/UMUL_LOHI - Multiply two integers of type iN, producing
 198     /// a signed/unsigned value of type i[2*N], and return the full value as
 199     /// two results, each of type iN.
 200     SMUL_LOHI, UMUL_LOHI,
 201
 202     /// SDIVREM/UDIVREM - Divide two integers and produce both a quotient and
 203     /// remainder result.
 204     SDIVREM, UDIVREM,
 205
 206     /// CARRY_FALSE - This node is used when folding other nodes,
 207     /// like ADDC/SUBC, which indicate the carry result is always false.
 208     CARRY_FALSE,
 209
 210     /// Carry-setting nodes for multiple precision addition and subtraction.
 211     /// These nodes take two operands of the same value type, and produce two
 212     /// results.  The first result is the normal add or sub result, the second
 213     /// result is the carry flag result.
 214     ADDC, SUBC,
 215
 216     /// Carry-using nodes for multiple precision addition and subtraction. These
 217     /// nodes take three operands: The first two are the normal lhs and rhs to
 218     /// the add or sub, and the third is the input carry flag.  These nodes
 219     /// produce two results; the normal result of the add or sub, and the output
 220     /// carry flag.  These nodes both read and write a carry flag to allow them
 221     /// to them to be chained together for add and sub of arbitrarily large
 222     /// values.
 223     ADDE, SUBE,
 224
 225     /// RESULT, BOOL = [SU]ADDO(LHS, RHS) - Overflow-aware nodes for addition.
 226     /// These nodes take two operands: the normal LHS and RHS to the add. They
 227     /// produce two results: the normal result of the add, and a boolean that
 228     /// indicates if an overflow occurred (*not* a flag, because it may be store
 229     /// to memory, etc.).  If the type of the boolean is not i1 then the high
 230     /// bits conform to getBooleanContents.
 231     /// These nodes are generated from llvm.[su]add.with.overflow intrinsics.
 232     SADDO, UADDO,
 233
 234     /// Same for subtraction.
 235     SSUBO, USUBO,
 236
 237     /// Same for multiplication.
 238     SMULO, UMULO,
 239
 240     /// Simple binary floating point operators.
 241     FADD, FSUB, FMUL, FDIV, FREM,
 242
 243     /// FMA - Perform a * b + c with no intermediate rounding step.
 244     FMA,
 245
 246     /// FMAD - Perform a * b + c, while getting the same result as the
 247     /// separately rounded operations.
 248     FMAD,
 249
 250     /// FCOPYSIGN(X, Y) - Return the value of X with the sign of Y.  NOTE: This
 251     /// DAG node does not require that X and Y have the same type, just that
 252     /// they are both floating point.  X and the result must have the same type.
 253     /// FCOPYSIGN(f32, f64) is allowed.
 254     FCOPYSIGN,
 255
 256     /// INT = FGETSIGN(FP) - Return the sign bit of the specified floating point
 257     /// value as an integer 0/1 value.
 258     FGETSIGN,
 259
 260     /// BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a vector with the
 261     /// specified, possibly variable, elements.  The number of elements is
 262     /// required to be a power of two.  The types of the operands must all be
 263     /// the same and must match the vector element type, except that integer
 264     /// types are allowed to be larger than the element type, in which case
 265     /// the operands are implicitly truncated.
 266     BUILD_VECTOR,
 267
 268     /// INSERT_VECTOR_ELT(VECTOR, VAL, IDX) - Returns VECTOR with the element
 269     /// at IDX replaced with VAL.  If the type of VAL is larger than the vector
 270     /// element type then VAL is truncated before replacement.
 271     INSERT_VECTOR_ELT,
 272
 273     /// EXTRACT_VECTOR_ELT(VECTOR, IDX) - Returns a single element from VECTOR
 274     /// identified by the (potentially variable) element number IDX.  If the
 275     /// return type is an integer type larger than the element type of the
 276     /// vector, the result is extended to the width of the return type.
 277     EXTRACT_VECTOR_ELT,
 278
 279     /// CONCAT_VECTORS(VECTOR0, VECTOR1, ...) - Given a number of values of
 280     /// vector type with the same length and element type, this produces a
 281     /// concatenated vector result value, with length equal to the sum of the
 282     /// lengths of the input vectors.
 283     CONCAT_VECTORS,
 284
 285     /// INSERT_SUBVECTOR(VECTOR1, VECTOR2, IDX) - Returns a vector
 286     /// with VECTOR2 inserted into VECTOR1 at the (potentially
 287     /// variable) element number IDX, which must be a multiple of the
 288     /// VECTOR2 vector length.  The elements of VECTOR1 starting at
 289     /// IDX are overwritten with VECTOR2.  Elements IDX through
 290     /// vector_length(VECTOR2) must be valid VECTOR1 indices.
 291     INSERT_SUBVECTOR,
 292
 293     /// EXTRACT_SUBVECTOR(VECTOR, IDX) - Returns a subvector from VECTOR (an
 294     /// vector value) starting with the element number IDX, which must be a
 295     /// constant multiple of the result vector length.
 296     EXTRACT_SUBVECTOR,
 297
 298     /// VECTOR_SHUFFLE(VEC1, VEC2) - Returns a vector, of the same type as
 299     /// VEC1/VEC2.  A VECTOR_SHUFFLE node also contains an array of constant int
 300     /// values that indicate which value (or undef) each result element will
 301     /// get.  These constant ints are accessible through the
 302     /// ShuffleVectorSDNode class.  This is quite similar to the Altivec
 303     /// 'vperm' instruction, except that the indices must be constants and are
 304     /// in terms of the element size of VEC1/VEC2, not in terms of bytes.
 305     VECTOR_SHUFFLE,
 306
 307     /// SCALAR_TO_VECTOR(VAL) - This represents the operation of loading a
 308     /// scalar value into element 0 of the resultant vector type.  The top
 309     /// elements 1 to N-1 of the N-element vector are undefined.  The type
 310     /// of the operand must match the vector element type, except when they
 311     /// are integer types.  In this case the operand is allowed to be wider
 312     /// than the vector element type, and is implicitly truncated to it.
 313     SCALAR_TO_VECTOR,
 314
 315     /// MULHU/MULHS - Multiply high - Multiply two integers of type iN,
 316     /// producing an unsigned/signed value of type i[2*N], then return the top
 317     /// part.
 318     MULHU, MULHS,
 319
 320     /// [US]{MIN/MAX} - Binary minimum or maximum or signed or unsigned
 321     /// integers.
 322     SMIN, SMAX, UMIN, UMAX,
 323
 324     /// Bitwise operators - logical and, logical or, logical xor.
 325     AND, OR, XOR,
 326
 327     /// Shift and rotation operations.  After legalization, the type of the
 328     /// shift amount is known to be TLI.getShiftAmountTy().  Before legalization
 329     /// the shift amount can be any type, but care must be taken to ensure it is
 330     /// large enough.  TLI.getShiftAmountTy() is i8 on some targets, but before
 331     /// legalization, types like i1024 can occur and i8 doesn't have enough bits
 332     /// to represent the shift amount.
 333     /// When the 1st operand is a vector, the shift amount must be in the same
 334     /// type. (TLI.getShiftAmountTy() will return the same type when the input
 335     /// type is a vector.)
 336     SHL, SRA, SRL, ROTL, ROTR,
 337
 338     /// Byte Swap and Counting operators.
 339     BSWAP, CTTZ, CTLZ, CTPOP,
 340
 341     /// [SU]ABSDIFF - Signed/Unsigned absolute difference of two input integer
 342     /// vector. These nodes are generated from llvm.*absdiff* intrinsics.
 343     SABSDIFF, UABSDIFF,
 344
 345     /// Bit counting operators with an undefined result for zero inputs.
 346     CTTZ_ZERO_UNDEF, CTLZ_ZERO_UNDEF,
 347
 348     /// Select(COND, TRUEVAL, FALSEVAL).  If the type of the boolean COND is not
 349     /// i1 then the high bits must conform to getBooleanContents.
 350     SELECT,
 351
 352     /// Select with a vector condition (op #0) and two vector operands (ops #1
 353     /// and #2), returning a vector result.  All vectors have the same length.
 354     /// Much like the scalar select and setcc, each bit in the condition selects
 355     /// whether the corresponding result element is taken from op #1 or op #2.
 356     /// At first, the VSELECT condition is of vXi1 type. Later, targets may
 357     /// change the condition type in order to match the VSELECT node using a
 358     /// pattern. The condition follows the BooleanContent format of the target.
 359     VSELECT,
 360
 361     /// Select with condition operator - This selects between a true value and
 362     /// a false value (ops #2 and #3) based on the boolean result of comparing
 363     /// the lhs and rhs (ops #0 and #1) of a conditional expression with the
 364     /// condition code in op #4, a CondCodeSDNode.
 365     SELECT_CC,
 366
 367     /// SetCC operator - This evaluates to a true value iff the condition is
 368     /// true.  If the result value type is not i1 then the high bits conform
 369     /// to getBooleanContents.  The operands to this are the left and right
 370     /// operands to compare (ops #0, and #1) and the condition code to compare
 371     /// them with (op #2) as a CondCodeSDNode. If the operands are vector types
 372     /// then the result type must also be a vector type.
 373     SETCC,
 374
 375     /// SHL_PARTS/SRA_PARTS/SRL_PARTS - These operators are used for expanded
 376     /// integer shift operations, just like ADD/SUB_PARTS.  The operation
 377     /// ordering is:
 378     ///       [Lo,Hi] = op [LoLHS,HiLHS], Amt
 379     SHL_PARTS, SRA_PARTS, SRL_PARTS,
 380
 381     /// Conversion operators.  These are all single input single output
 382     /// operations.  For all of these, the result type must be strictly
 383     /// wider or narrower (depending on the operation) than the source
 384     /// type.
 385
 386     /// SIGN_EXTEND - Used for integer types, replicating the sign bit
 387     /// into new bits.
 388     SIGN_EXTEND,
 389
 390     /// ZERO_EXTEND - Used for integer types, zeroing the new bits.
 391     ZERO_EXTEND,
 392
 393     /// ANY_EXTEND - Used for integer types.  The high bits are undefined.
 394     ANY_EXTEND,
 395
 396     /// TRUNCATE - Completely drop the high bits.
 397     TRUNCATE,
 398
 399     /// [SU]INT_TO_FP - These operators convert integers (whose interpreted sign
 400     /// depends on the first letter) to floating point.
 401     SINT_TO_FP,
 402     UINT_TO_FP,
 403
 404     /// SIGN_EXTEND_INREG - This operator atomically performs a SHL/SRA pair to
 405     /// sign extend a small value in a large integer register (e.g. sign
 406     /// extending the low 8 bits of a 32-bit register to fill the top 24 bits
 407     /// with the 7th bit).  The size of the smaller type is indicated by the 1th
 408     /// operand, a ValueType node.
 409     SIGN_EXTEND_INREG,
 410
 411     /// ANY_EXTEND_VECTOR_INREG(Vector) - This operator represents an
 412     /// in-register any-extension of the low lanes of an integer vector. The
 413     /// result type must have fewer elements than the operand type, and those
 414     /// elements must be larger integer types such that the total size of the
 415     /// operand type and the result type match. Each of the low operand
 416     /// elements is any-extended into the corresponding, wider result
 417     /// elements with the high bits becoming undef.
 418     ANY_EXTEND_VECTOR_INREG,
 419
 420     /// SIGN_EXTEND_VECTOR_INREG(Vector) - This operator represents an
 421     /// in-register sign-extension of the low lanes of an integer vector. The
 422     /// result type must have fewer elements than the operand type, and those
 423     /// elements must be larger integer types such that the total size of the
 424     /// operand type and the result type match. Each of the low operand
 425     /// elements is sign-extended into the corresponding, wider result
 426     /// elements.
 427     // FIXME: The SIGN_EXTEND_INREG node isn't specifically limited to
 428     // scalars, but it also doesn't handle vectors well. Either it should be
 429     // restricted to scalars or this node (and its handling) should be merged
 430     // into it.
 431     SIGN_EXTEND_VECTOR_INREG,
 432
 433     /// ZERO_EXTEND_VECTOR_INREG(Vector) - This operator represents an
 434     /// in-register zero-extension of the low lanes of an integer vector. The
 435     /// result type must have fewer elements than the operand type, and those
 436     /// elements must be larger integer types such that the total size of the
 437     /// operand type and the result type match. Each of the low operand
 438     /// elements is zero-extended into the corresponding, wider result
 439     /// elements.
 440     ZERO_EXTEND_VECTOR_INREG,
 441
 442     /// FP_TO_[US]INT - Convert a floating point value to a signed or unsigned
 443     /// integer.
 444     FP_TO_SINT,
 445     FP_TO_UINT,
 446
 447     /// X = FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating point type
 448     /// down to the precision of the destination VT.  TRUNC is a flag, which is
 449     /// always an integer that is zero or one.  If TRUNC is 0, this is a
 450     /// normal rounding, if it is 1, this FP_ROUND is known to not change the
 451     /// value of Y.
 452     ///
 453     /// The TRUNC = 1 case is used in cases where we know that the value will
 454     /// not be modified by the node, because Y is not using any of the extra
 455     /// precision of source type.  This allows certain transformations like
 456     /// FP_EXTEND(FP_ROUND(X,1)) -> X which are not safe for
 457     /// FP_EXTEND(FP_ROUND(X,0)) because the extra bits aren't removed.
 458     FP_ROUND,
 459
 460     /// FLT_ROUNDS_ - Returns current rounding mode:
 461     /// -1 Undefined
 462     ///  0 Round to 0
 463     ///  1 Round to nearest
 464     ///  2 Round to +inf
 465     ///  3 Round to -inf
 466     FLT_ROUNDS_,
 467
 468     /// X = FP_ROUND_INREG(Y, VT) - This operator takes an FP register, and
 469     /// rounds it to a floating point value.  It then promotes it and returns it
 470     /// in a register of the same size.  This operation effectively just
 471     /// discards excess precision.  The type to round down to is specified by
 472     /// the VT operand, a VTSDNode.
 473     FP_ROUND_INREG,
 474
 475     /// X = FP_EXTEND(Y) - Extend a smaller FP type into a larger FP type.
 476     FP_EXTEND,
 477
 478     /// BITCAST - This operator converts between integer, vector and FP
 479     /// values, as if the value was stored to memory with one type and loaded
 480     /// from the same address with the other type (or equivalently for vector
 481     /// format conversions, etc).  The source and result are required to have
 482     /// the same bit size (e.g.  f32 <-> i32).  This can also be used for
 483     /// int-to-int or fp-to-fp conversions, but that is a noop, deleted by
 484     /// getNode().
 485     BITCAST,
 486
 487     /// ADDRSPACECAST - This operator converts between pointers of different
 488     /// address spaces.
 489     ADDRSPACECAST,
 490
 491     /// CONVERT_RNDSAT - This operator is used to support various conversions
 492     /// between various types (float, signed, unsigned and vectors of those
 493     /// types) with rounding and saturation. NOTE: Avoid using this operator as
 494     /// most target don't support it and the operator might be removed in the
 495     /// future. It takes the following arguments:
 496     ///   0) value
 497     ///   1) dest type (type to convert to)
 498     ///   2) src type (type to convert from)
 499     ///   3) rounding imm
 500     ///   4) saturation imm
 501     ///   5) ISD::CvtCode indicating the type of conversion to do
 502     CONVERT_RNDSAT,
 503
 504     /// FP16_TO_FP, FP_TO_FP16 - These operators are used to perform promotions
 505     /// and truncation for half-precision (16 bit) floating numbers. These nodes
 506     /// form a semi-softened interface for dealing with f16 (as an i16), which
 507     /// is often a storage-only type but has native conversions.
 508     FP16_TO_FP, FP_TO_FP16,
 509
 510     /// FNEG, FABS, FSQRT, FSIN, FCOS, FPOWI, FPOW,
 511     /// FLOG, FLOG2, FLOG10, FEXP, FEXP2,
 512     /// FCEIL, FTRUNC, FRINT, FNEARBYINT, FROUND, FFLOOR - Perform various unary
 513     /// floating point operations. These are inspired by libm.
 514     FNEG, FABS, FSQRT, FSIN, FCOS, FPOWI, FPOW,
 515     FLOG, FLOG2, FLOG10, FEXP, FEXP2,
 516     FCEIL, FTRUNC, FRINT, FNEARBYINT, FROUND, FFLOOR,
 517     FMINNUM, FMAXNUM,
 518
 519     /// FSINCOS - Compute both fsin and fcos as a single operation.
 520     FSINCOS,
 521
 522     /// LOAD and STORE have token chains as their first operand, then the same
 523     /// operands as an LLVM load/store instruction, then an offset node that
 524     /// is added / subtracted from the base pointer to form the address (for
 525     /// indexed memory ops).
 526     LOAD, STORE,
 527
 528     /// DYNAMIC_STACKALLOC - Allocate some number of bytes on the stack aligned
 529     /// to a specified boundary.  This node always has two return values: a new
 530     /// stack pointer value and a chain. The first operand is the token chain,
 531     /// the second is the number of bytes to allocate, and the third is the
 532     /// alignment boundary.  The size is guaranteed to be a multiple of the
 533     /// stack alignment, and the alignment is guaranteed to be bigger than the
 534     /// stack alignment (if required) or 0 to get standard stack alignment.
 535     DYNAMIC_STACKALLOC,
 536
 537     /// Control flow instructions.  These all have token chains.
 538
 539     /// BR - Unconditional branch.  The first operand is the chain
 540     /// operand, the second is the MBB to branch to.
 541     BR,
 542
 543     /// BRIND - Indirect branch.  The first operand is the chain, the second
 544     /// is the value to branch to, which must be of the same type as the
 545     /// target's pointer type.
 546     BRIND,
 547
 548     /// BR_JT - Jumptable branch. The first operand is the chain, the second
 549     /// is the jumptable index, the last one is the jumptable entry index.
 550     BR_JT,
 551
 552     /// BRCOND - Conditional branch.  The first operand is the chain, the
 553     /// second is the condition, the third is the block to branch to if the
 554     /// condition is true.  If the type of the condition is not i1, then the
 555     /// high bits must conform to getBooleanContents.
 556     BRCOND,
 557
 558     /// BR_CC - Conditional branch.  The behavior is like that of SELECT_CC, in
 559     /// that the condition is represented as condition code, and two nodes to
 560     /// compare, rather than as a combined SetCC node.  The operands in order
 561     /// are chain, cc, lhs, rhs, block to branch to if condition is true.
 562     BR_CC,
 563
 564     /// INLINEASM - Represents an inline asm block.  This node always has two
 565     /// return values: a chain and a flag result.  The inputs are as follows:
 566     ///   Operand #0  : Input chain.
 567     ///   Operand #1  : a ExternalSymbolSDNode with a pointer to the asm string.
 568     ///   Operand #2  : a MDNodeSDNode with the !srcloc metadata.
 569     ///   Operand #3  : HasSideEffect, IsAlignStack bits.
 570     ///   After this, it is followed by a list of operands with this format:
 571     ///     ConstantSDNode: Flags that encode whether it is a mem or not, the
 572     ///                     of operands that follow, etc.  See InlineAsm.h.
 573     ///     ... however many operands ...
 574     ///   Operand #last: Optional, an incoming flag.
 575     ///
 576     /// The variable width operands are required to represent target addressing
 577     /// modes as a single "operand", even though they may have multiple
 578     /// SDOperands.
 579     INLINEASM,
 580
 581     /// EH_LABEL - Represents a label in mid basic block used to track
 582     /// locations needed for debug and exception handling tables.  These nodes
 583     /// take a chain as input and return a chain.
 584     EH_LABEL,
 585
 586     /// STACKSAVE - STACKSAVE has one operand, an input chain.  It produces a
 587     /// value, the same type as the pointer type for the system, and an output
 588     /// chain.
 589     STACKSAVE,
 590
 591     /// STACKRESTORE has two operands, an input chain and a pointer to restore
 592     /// to it returns an output chain.
 593     STACKRESTORE,
 594
 595     /// CALLSEQ_START/CALLSEQ_END - These operators mark the beginning and end
 596     /// of a call sequence, and carry arbitrary information that target might
 597     /// want to know.  The first operand is a chain, the rest are specified by
 598     /// the target and not touched by the DAG optimizers.
 599     /// CALLSEQ_START..CALLSEQ_END pairs may not be nested.
 600     CALLSEQ_START,  // Beginning of a call sequence
 601     CALLSEQ_END,    // End of a call sequence
 602
 603     /// VAARG - VAARG has four operands: an input chain, a pointer, a SRCVALUE,
 604     /// and the alignment. It returns a pair of values: the vaarg value and a
 605     /// new chain.
 606     VAARG,
 607
 608     /// VACOPY - VACOPY has 5 operands: an input chain, a destination pointer,
 609     /// a source pointer, a SRCVALUE for the destination, and a SRCVALUE for the
 610     /// source.
 611     VACOPY,
 612
 613     /// VAEND, VASTART - VAEND and VASTART have three operands: an input chain,
 614     /// pointer, and a SRCVALUE.
 615     VAEND, VASTART,
 616
 617     /// SRCVALUE - This is a node type that holds a Value* that is used to
 618     /// make reference to a value in the LLVM IR.
 619     SRCVALUE,
 620
 621     /// MDNODE_SDNODE - This is a node that holdes an MDNode*, which is used to
 622     /// reference metadata in the IR.
 623     MDNODE_SDNODE,
 624
 625     /// PCMARKER - This corresponds to the pcmarker intrinsic.
 626     PCMARKER,
 627
 628     /// READCYCLECOUNTER - This corresponds to the readcyclecounter intrinsic.
 629     /// The only operand is a chain and a value and a chain are produced.  The
 630     /// value is the contents of the architecture specific cycle counter like
 631     /// register (or other high accuracy low latency clock source)
 632     READCYCLECOUNTER,
 633
 634     /// HANDLENODE node - Used as a handle for various purposes.
 635     HANDLENODE,
 636
 637     /// INIT_TRAMPOLINE - This corresponds to the init_trampoline intrinsic.  It
 638     /// takes as input a token chain, the pointer to the trampoline, the pointer
 639     /// to the nested function, the pointer to pass for the 'nest' parameter, a
 640     /// SRCVALUE for the trampoline and another for the nested function
 641     /// (allowing targets to access the original Function*).
 642     /// It produces a token chain as output.
 643     INIT_TRAMPOLINE,
 644
 645     /// ADJUST_TRAMPOLINE - This corresponds to the adjust_trampoline intrinsic.
 646     /// It takes a pointer to the trampoline and produces a (possibly) new
 647     /// pointer to the same trampoline with platform-specific adjustments
 648     /// applied.  The pointer it returns points to an executable block of code.
 649     ADJUST_TRAMPOLINE,
 650
 651     /// TRAP - Trapping instruction
 652     TRAP,
 653
 654     /// DEBUGTRAP - Trap intended to get the attention of a debugger.
 655     DEBUGTRAP,
 656
 657     /// PREFETCH - This corresponds to a prefetch intrinsic. The first operand
 658     /// is the chain.  The other operands are the address to prefetch,
 659     /// read / write specifier, locality specifier and instruction / data cache
 660     /// specifier.
 661     PREFETCH,
 662
 663     /// OUTCHAIN = ATOMIC_FENCE(INCHAIN, ordering, scope)
 664     /// This corresponds to the fence instruction. It takes an input chain, and
 665     /// two integer constants: an AtomicOrdering and a SynchronizationScope.
 666     ATOMIC_FENCE,
 667
 668     /// Val, OUTCHAIN = ATOMIC_LOAD(INCHAIN, ptr)
 669     /// This corresponds to "load atomic" instruction.
 670     ATOMIC_LOAD,
 671
 672     /// OUTCHAIN = ATOMIC_STORE(INCHAIN, ptr, val)
 673     /// This corresponds to "store atomic" instruction.
 674     ATOMIC_STORE,
 675
 676     /// Val, OUTCHAIN = ATOMIC_CMP_SWAP(INCHAIN, ptr, cmp, swap)
 677     /// For double-word atomic operations:
 678     /// ValLo, ValHi, OUTCHAIN = ATOMIC_CMP_SWAP(INCHAIN, ptr, cmpLo, cmpHi,
 679     ///                                          swapLo, swapHi)
 680     /// This corresponds to the cmpxchg instruction.
 681     ATOMIC_CMP_SWAP,
 682
 683     /// Val, Success, OUTCHAIN
 684     ///     = ATOMIC_CMP_SWAP_WITH_SUCCESS(INCHAIN, ptr, cmp, swap)
 685     /// N.b. this is still a strong cmpxchg operation, so
 686     /// Success == "Val == cmp".
 687     ATOMIC_CMP_SWAP_WITH_SUCCESS,
 688
 689     /// Val, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amt)
 690     /// Val, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN, ptr, amt)
 691     /// For double-word atomic operations:
 692     /// ValLo, ValHi, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amtLo, amtHi)
 693     /// ValLo, ValHi, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN, ptr, amtLo, amtHi)
 694     /// These correspond to the atomicrmw instruction.
 695     ATOMIC_SWAP,
 696     ATOMIC_LOAD_ADD,
 697     ATOMIC_LOAD_SUB,
 698     ATOMIC_LOAD_AND,
 699     ATOMIC_LOAD_OR,
 700     ATOMIC_LOAD_XOR,
 701     ATOMIC_LOAD_NAND,
 702     ATOMIC_LOAD_MIN,
 703     ATOMIC_LOAD_MAX,
 704     ATOMIC_LOAD_UMIN,
 705     ATOMIC_LOAD_UMAX,
 706
 707     // Masked load and store - consecutive vector load and store operations
 708     // with additional mask operand that prevents memory accesses to the
 709     // masked-off lanes.
 710     MLOAD, MSTORE,
 711
 712     // Masked gather and scatter - load and store operations for a vector of
 713     // random addresses with additional mask operand that prevents memory
 714     // accesses to the masked-off lanes.
 715     MGATHER, MSCATTER,
 716
 717     /// This corresponds to the llvm.lifetime.* intrinsics. The first operand
 718     /// is the chain and the second operand is the alloca pointer.
 719     LIFETIME_START, LIFETIME_END,
 720
 721     /// GC_TRANSITION_START/GC_TRANSITION_END - These operators mark the
 722     /// beginning and end of GC transition  sequence, and carry arbitrary
 723     /// information that target might need for lowering.  The first operand is
 724     /// a chain, the rest are specified by the target and not touched by the DAG
 725     /// optimizers. GC_TRANSITION_START..GC_TRANSITION_END pairs may not be
 726     /// nested.
 727     GC_TRANSITION_START,
 728     GC_TRANSITION_END,
 729
 730     /// BUILTIN_OP_END - This must be the last enum value in this list.
 731     /// The target-specific pre-isel opcode values start here.
 732     BUILTIN_OP_END
 733   };
 734
 735   /// FIRST_TARGET_MEMORY_OPCODE - Target-specific pre-isel operations
 736   /// which do not reference a specific memory location should be less than
 737   /// this value. Those that do must not be less than this value, and can
 738   /// be used with SelectionDAG::getMemIntrinsicNode.
 739   static const int FIRST_TARGET_MEMORY_OPCODE = BUILTIN_OP_END+300;
 740
 741   //===--------------------------------------------------------------------===//
 742   /// MemIndexedMode enum - This enum defines the load / store indexed
 743   /// addressing modes.
 744   ///
 745   /// UNINDEXED    "Normal" load / store. The effective address is already
 746   ///              computed and is available in the base pointer. The offset
 747   ///              operand is always undefined. In addition to producing a
 748   ///              chain, an unindexed load produces one value (result of the
 749   ///              load); an unindexed store does not produce a value.
 750   ///
 751   /// PRE_INC      Similar to the unindexed mode where the effective address is
 752   /// PRE_DEC      the value of the base pointer add / subtract the offset.
 753   ///              It considers the computation as being folded into the load /
 754   ///              store operation (i.e. the load / store does the address
 755   ///              computation as well as performing the memory transaction).
 756   ///              The base operand is always undefined. In addition to
 757   ///              producing a chain, pre-indexed load produces two values
 758   ///              (result of the load and the result of the address
 759   ///              computation); a pre-indexed store produces one value (result
 760   ///              of the address computation).
 761   ///
 762   /// POST_INC     The effective address is the value of the base pointer. The
 763   /// POST_DEC     value of the offset operand is then added to / subtracted
 764   ///              from the base after memory transaction. In addition to
 765   ///              producing a chain, post-indexed load produces two values
 766   ///              (the result of the load and the result of the base +/- offset
 767   ///              computation); a post-indexed store produces one value (the
 768   ///              the result of the base +/- offset computation).
 769   enum MemIndexedMode {
 770     UNINDEXED = 0,
 771     PRE_INC,
 772     PRE_DEC,
 773     POST_INC,
 774     POST_DEC,
 775     LAST_INDEXED_MODE
 776   };
 777
 778   //===--------------------------------------------------------------------===//
 779   /// LoadExtType enum - This enum defines the three variants of LOADEXT
 780   /// (load with extension).
 781   ///
 782   /// SEXTLOAD loads the integer operand and sign extends it to a larger
 783   ///          integer result type.
 784   /// ZEXTLOAD loads the integer operand and zero extends it to a larger
 785   ///          integer result type.
 786   /// EXTLOAD  is used for two things: floating point extending loads and
 787   ///          integer extending loads [the top bits are undefined].
 788   enum LoadExtType {
 789     NON_EXTLOAD = 0,
 790     EXTLOAD,
 791     SEXTLOAD,
 792     ZEXTLOAD,
 793     LAST_LOADEXT_TYPE
 794   };
 795
 796   NodeType getExtForLoadExtType(bool IsFP, LoadExtType);
 797
 798   //===--------------------------------------------------------------------===//
 799   /// ISD::CondCode enum - These are ordered carefully to make the bitfields
 800   /// below work out, when considering SETFALSE (something that never exists
 801   /// dynamically) as 0.  "U" -> Unsigned (for integer operands) or Unordered
 802   /// (for floating point), "L" -> Less than, "G" -> Greater than, "E" -> Equal
 803   /// to.  If the "N" column is 1, the result of the comparison is undefined if
 804   /// the input is a NAN.
 805   ///
 806   /// All of these (except for the 'always folded ops') should be handled for
 807   /// floating point.  For integer, only the SETEQ,SETNE,SETLT,SETLE,SETGT,
 808   /// SETGE,SETULT,SETULE,SETUGT, and SETUGE opcodes are used.
 809   ///
 810   /// Note that these are laid out in a specific order to allow bit-twiddling
 811   /// to transform conditions.
 812   enum CondCode {
 813     // Opcode          N U L G E       Intuitive operation
 814     SETFALSE,      //    0 0 0 0       Always false (always folded)
 815     SETOEQ,        //    0 0 0 1       True if ordered and equal
 816     SETOGT,        //    0 0 1 0       True if ordered and greater than
 817     SETOGE,        //    0 0 1 1       True if ordered and greater than or equal
 818     SETOLT,        //    0 1 0 0       True if ordered and less than
 819     SETOLE,        //    0 1 0 1       True if ordered and less than or equal
 820     SETONE,        //    0 1 1 0       True if ordered and operands are unequal
 821     SETO,          //    0 1 1 1       True if ordered (no nans)
 822     SETUO,         //    1 0 0 0       True if unordered: isnan(X) | isnan(Y)
 823     SETUEQ,        //    1 0 0 1       True if unordered or equal
 824     SETUGT,        //    1 0 1 0       True if unordered or greater than
 825     SETUGE,        //    1 0 1 1       True if unordered, greater than, or equal
 826     SETULT,        //    1 1 0 0       True if unordered or less than
 827     SETULE,        //    1 1 0 1       True if unordered, less than, or equal
 828     SETUNE,        //    1 1 1 0       True if unordered or not equal
 829     SETTRUE,       //    1 1 1 1       Always true (always folded)
 830     // Don't care operations: undefined if the input is a nan.
 831     SETFALSE2,     //  1 X 0 0 0       Always false (always folded)
 832     SETEQ,         //  1 X 0 0 1       True if equal
 833     SETGT,         //  1 X 0 1 0       True if greater than
 834     SETGE,         //  1 X 0 1 1       True if greater than or equal
 835     SETLT,         //  1 X 1 0 0       True if less than
 836     SETLE,         //  1 X 1 0 1       True if less than or equal
 837     SETNE,         //  1 X 1 1 0       True if not equal
 838     SETTRUE2,      //  1 X 1 1 1       Always true (always folded)
 839
 840     SETCC_INVALID       // Marker value.
 841   };
 842
 843   /// isSignedIntSetCC - Return true if this is a setcc instruction that
 844   /// performs a signed comparison when used with integer operands.
 845   inline bool isSignedIntSetCC(CondCode Code) {
 846     return Code == SETGT || Code == SETGE || Code == SETLT || Code == SETLE;
 847   }
 848
 849   /// isUnsignedIntSetCC - Return true if this is a setcc instruction that
 850   /// performs an unsigned comparison when used with integer operands.
 851   inline bool isUnsignedIntSetCC(CondCode Code) {
 852     return Code == SETUGT || Code == SETUGE || Code == SETULT || Code == SETULE;
 853   }
 854
 855   /// isTrueWhenEqual - Return true if the specified condition returns true if
 856   /// the two operands to the condition are equal.  Note that if one of the two
 857   /// operands is a NaN, this value is meaningless.
 858   inline bool isTrueWhenEqual(CondCode Cond) {
 859     return ((int)Cond & 1) != 0;
 860   }
 861
 862   /// getUnorderedFlavor - This function returns 0 if the condition is always
 863   /// false if an operand is a NaN, 1 if the condition is always true if the
 864   /// operand is a NaN, and 2 if the condition is undefined if the operand is a
 865   /// NaN.
 866   inline unsigned getUnorderedFlavor(CondCode Cond) {
 867     return ((int)Cond >> 3) & 3;
 868   }
 869
 870   /// getSetCCInverse - Return the operation corresponding to !(X op Y), where
 871   /// 'op' is a valid SetCC operation.
 872   CondCode getSetCCInverse(CondCode Operation, bool isInteger);
 873
 874   /// getSetCCSwappedOperands - Return the operation corresponding to (Y op X)
 875   /// when given the operation for (X op Y).
 876   CondCode getSetCCSwappedOperands(CondCode Operation);
 877
 878   /// getSetCCOrOperation - Return the result of a logical OR between different
 879   /// comparisons of identical values: ((X op1 Y) | (X op2 Y)).  This
 880   /// function returns SETCC_INVALID if it is not possible to represent the
 881   /// resultant comparison.
 882   CondCode getSetCCOrOperation(CondCode Op1, CondCode Op2, bool isInteger);
 883
 884   /// getSetCCAndOperation - Return the result of a logical AND between
 885   /// different comparisons of identical values: ((X op1 Y) & (X op2 Y)).  This
 886   /// function returns SETCC_INVALID if it is not possible to represent the
 887   /// resultant comparison.
 888   CondCode getSetCCAndOperation(CondCode Op1, CondCode Op2, bool isInteger);
 889
 890   //===--------------------------------------------------------------------===//
 891   /// CvtCode enum - This enum defines the various converts CONVERT_RNDSAT
 892   /// supports.
 893   enum CvtCode {
 894     CVT_FF,     /// Float from Float
 895     CVT_FS,     /// Float from Signed
 896     CVT_FU,     /// Float from Unsigned
 897     CVT_SF,     /// Signed from Float
 898     CVT_UF,     /// Unsigned from Float
 899     CVT_SS,     /// Signed from Signed
 900     CVT_SU,     /// Signed from Unsigned
 901     CVT_US,     /// Unsigned from Signed
 902     CVT_UU,     /// Unsigned from Unsigned
 903     CVT_INVALID /// Marker - Invalid opcode
 904   };
 905
 906 } // end llvm::ISD namespace
 907
 908 } // end llvm namespace
 909
 910 #endif