lib/Target/AMDGPU/AMDGPUInstrInfo.td

   1 //===-- AMDGPUInstrInfo.td - AMDGPU DAG nodes --------------*- tablegen -*-===//
   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 contains DAG node defintions for the AMDGPU target.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 //===----------------------------------------------------------------------===//
  14 // AMDGPU DAG Profiles
  15 //===----------------------------------------------------------------------===//
  16
  17 def AMDGPUDTIntTernaryOp : SDTypeProfile<1, 3, [
  18   SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisInt<0>, SDTCisInt<3>
  19 ]>;
  20
  21 def AMDGPUTrigPreOp : SDTypeProfile<1, 2,
  22   [SDTCisSameAs<0, 1>, SDTCisFP<0>, SDTCisInt<2>]
  23 >;
  24
  25 def AMDGPULdExpOp : SDTypeProfile<1, 2,
  26   [SDTCisSameAs<0, 1>, SDTCisFP<0>, SDTCisInt<2>]
  27 >;
  28
  29 def AMDGPUFPClassOp : SDTypeProfile<1, 2,
  30   [SDTCisInt<0>, SDTCisFP<1>, SDTCisInt<2>]
  31 >;
  32
  33 def AMDGPUFPPackOp : SDTypeProfile<1, 2,
  34   [SDTCisFP<1>, SDTCisSameAs<1, 2>]
  35 >;
  36
  37 def AMDGPUIntPackOp : SDTypeProfile<1, 2,
  38   [SDTCisInt<1>, SDTCisSameAs<1, 2>]
  39 >;
  40
  41 def AMDGPUDivScaleOp : SDTypeProfile<2, 3,
  42   [SDTCisFP<0>, SDTCisInt<1>, SDTCisSameAs<0, 2>, SDTCisSameAs<0, 3>, SDTCisSameAs<0, 4>]
  43 >;
  44
  45 // float, float, float, vcc
  46 def AMDGPUFmasOp : SDTypeProfile<1, 4,
  47   [SDTCisFP<0>, SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisSameAs<0, 3>, SDTCisInt<4>]
  48 >;
  49
  50 def AMDGPUKillSDT : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
  51
  52 def AMDGPUIfOp : SDTypeProfile<1, 2,
  53   [SDTCisVT<0, i64>, SDTCisVT<1, i1>, SDTCisVT<2, OtherVT>]
  54 >;
  55
  56 def AMDGPUElseOp : SDTypeProfile<1, 2,
  57   [SDTCisVT<0, i64>, SDTCisVT<1, i64>, SDTCisVT<2, OtherVT>]
  58 >;
  59
  60 def AMDGPULoopOp : SDTypeProfile<0, 2,
  61   [SDTCisVT<0, i64>, SDTCisVT<1, OtherVT>]
  62 >;
  63
  64 def AMDGPUIfBreakOp : SDTypeProfile<1, 2,
  65   [SDTCisVT<0, i64>, SDTCisVT<1, i1>, SDTCisVT<2, i64>]
  66 >;
  67
  68 def AMDGPUAddeSubeOp : SDTypeProfile<2, 3,
  69   [SDTCisSameAs<0, 2>, SDTCisSameAs<0, 3>, SDTCisVT<0, i32>, SDTCisVT<1, i1>, SDTCisVT<4, i1>]
  70 >;
  71
  72 //===----------------------------------------------------------------------===//
  73 // AMDGPU DAG Nodes
  74 //
  75
  76 def AMDGPUif : SDNode<"AMDGPUISD::IF", AMDGPUIfOp, [SDNPHasChain]>;
  77 def AMDGPUelse : SDNode<"AMDGPUISD::ELSE", AMDGPUElseOp, [SDNPHasChain]>;
  78 def AMDGPUloop : SDNode<"AMDGPUISD::LOOP", AMDGPULoopOp, [SDNPHasChain]>;
  79
  80 def callseq_start : SDNode<"ISD::CALLSEQ_START",
  81   SDCallSeqStart<[ SDTCisVT<0, i32>, SDTCisVT<1, i32> ]>,
  82   [SDNPHasChain, SDNPOutGlue]
  83 >;
  84
  85 def callseq_end : SDNode<"ISD::CALLSEQ_END",
  86  SDCallSeqEnd<[ SDTCisVT<0, i32>, SDTCisVT<1, i32> ]>,
  87   [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]
  88 >;
  89
  90 def AMDGPUcall : SDNode<"AMDGPUISD::CALL",
  91   SDTypeProfile<0, -1, [SDTCisPtrTy<0>]>,
  92   [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue,
  93   SDNPVariadic]
  94 >;
  95
  96 def AMDGPUtc_return: SDNode<"AMDGPUISD::TC_RETURN",
  97   SDTypeProfile<0, 3, [SDTCisPtrTy<0>]>,
  98   [SDNPHasChain, SDNPOptInGlue, SDNPVariadic]
  99 >;
 100
 101 def AMDGPUtrap : SDNode<"AMDGPUISD::TRAP",
 102   SDTypeProfile<0, -1, [SDTCisVT<0, i16>]>,
 103     [SDNPHasChain, SDNPVariadic, SDNPSideEffect, SDNPInGlue]
 104 >;
 105
 106 def AMDGPUconstdata_ptr : SDNode<
 107   "AMDGPUISD::CONST_DATA_PTR", SDTypeProfile <1, 1, [SDTCisVT<0, iPTR>,
 108                                                      SDTCisVT<0, iPTR>]>
 109 >;
 110
 111 // This argument to this node is a dword address.
 112 def AMDGPUdwordaddr : SDNode<"AMDGPUISD::DWORDADDR", SDTIntUnaryOp>;
 113
 114 // Force dependencies for vector trunc stores
 115 def R600dummy_chain : SDNode<"AMDGPUISD::DUMMY_CHAIN", SDTNone, [SDNPHasChain]>;
 116
 117 def AMDGPUcos : SDNode<"AMDGPUISD::COS_HW", SDTFPUnaryOp>;
 118 def AMDGPUsin : SDNode<"AMDGPUISD::SIN_HW", SDTFPUnaryOp>;
 119
 120 // out = a - floor(a)
 121 def AMDGPUfract : SDNode<"AMDGPUISD::FRACT", SDTFPUnaryOp>;
 122
 123 // out = 1.0 / a
 124 def AMDGPUrcp : SDNode<"AMDGPUISD::RCP", SDTFPUnaryOp>;
 125
 126 // out = 1.0 / sqrt(a)
 127 def AMDGPUrsq : SDNode<"AMDGPUISD::RSQ", SDTFPUnaryOp>;
 128
 129 // out = 1.0 / sqrt(a)
 130 def AMDGPUrcp_legacy : SDNode<"AMDGPUISD::RCP_LEGACY", SDTFPUnaryOp>;
 131 def AMDGPUrsq_legacy : SDNode<"AMDGPUISD::RSQ_LEGACY", SDTFPUnaryOp>;
 132
 133 def AMDGPUrcp_iflag : SDNode<"AMDGPUISD::RCP_IFLAG", SDTFPUnaryOp>;
 134
 135 // out = 1.0 / sqrt(a) result clamped to +/- max_float.
 136 def AMDGPUrsq_clamp : SDNode<"AMDGPUISD::RSQ_CLAMP", SDTFPUnaryOp>;
 137
 138 def AMDGPUldexp : SDNode<"AMDGPUISD::LDEXP", AMDGPULdExpOp>;
 139
 140 def AMDGPUpkrtz_f16_f32 : SDNode<"AMDGPUISD::CVT_PKRTZ_F16_F32", AMDGPUFPPackOp>;
 141 def AMDGPUpknorm_i16_f32 : SDNode<"AMDGPUISD::CVT_PKNORM_I16_F32", AMDGPUFPPackOp>;
 142 def AMDGPUpknorm_u16_f32 : SDNode<"AMDGPUISD::CVT_PKNORM_U16_F32", AMDGPUFPPackOp>;
 143 def AMDGPUpk_i16_i32 : SDNode<"AMDGPUISD::CVT_PK_I16_I32", AMDGPUIntPackOp>;
 144 def AMDGPUpk_u16_u32 : SDNode<"AMDGPUISD::CVT_PK_U16_U32", AMDGPUIntPackOp>;
 145 def AMDGPUfp_to_f16 : SDNode<"AMDGPUISD::FP_TO_FP16" , SDTFPToIntOp>;
 146 def AMDGPUfp16_zext : SDNode<"AMDGPUISD::FP16_ZEXT" , SDTFPToIntOp>;
 147
 148
 149 def AMDGPUfp_class : SDNode<"AMDGPUISD::FP_CLASS", AMDGPUFPClassOp>;
 150
 151 // out = max(a, b) a and b are floats, where a nan comparison fails.
 152 // This is not commutative because this gives the second operand:
 153 //   x < nan ? x : nan -> nan
 154 //   nan < x ? nan : x -> x
 155 def AMDGPUfmax_legacy : SDNode<"AMDGPUISD::FMAX_LEGACY", SDTFPBinOp,
 156   []
 157 >;
 158
 159 def AMDGPUfmul_legacy : SDNode<"AMDGPUISD::FMUL_LEGACY", SDTFPBinOp,
 160   [SDNPCommutative, SDNPAssociative]
 161 >;
 162
 163 // out = min(a, b) a and b are floats, where a nan comparison fails.
 164 def AMDGPUfmin_legacy : SDNode<"AMDGPUISD::FMIN_LEGACY", SDTFPBinOp,
 165   []
 166 >;
 167
 168 // FIXME: TableGen doesn't like commutative instructions with more
 169 // than 2 operands.
 170 // out = max(a, b, c) a, b and c are floats
 171 def AMDGPUfmax3 : SDNode<"AMDGPUISD::FMAX3", SDTFPTernaryOp,
 172   [/*SDNPCommutative, SDNPAssociative*/]
 173 >;
 174
 175 // out = max(a, b, c) a, b, and c are signed ints
 176 def AMDGPUsmax3 : SDNode<"AMDGPUISD::SMAX3", AMDGPUDTIntTernaryOp,
 177   [/*SDNPCommutative, SDNPAssociative*/]
 178 >;
 179
 180 // out = max(a, b, c) a, b and c are unsigned ints
 181 def AMDGPUumax3 : SDNode<"AMDGPUISD::UMAX3", AMDGPUDTIntTernaryOp,
 182   [/*SDNPCommutative, SDNPAssociative*/]
 183 >;
 184
 185 // out = min(a, b, c) a, b and c are floats
 186 def AMDGPUfmin3 : SDNode<"AMDGPUISD::FMIN3", SDTFPTernaryOp,
 187   [/*SDNPCommutative, SDNPAssociative*/]
 188 >;
 189
 190 // out = min(a, b, c) a, b and c are signed ints
 191 def AMDGPUsmin3 : SDNode<"AMDGPUISD::SMIN3", AMDGPUDTIntTernaryOp,
 192   [/*SDNPCommutative, SDNPAssociative*/]
 193 >;
 194
 195 // out = min(a, b) a and b are unsigned ints
 196 def AMDGPUumin3 : SDNode<"AMDGPUISD::UMIN3", AMDGPUDTIntTernaryOp,
 197   [/*SDNPCommutative, SDNPAssociative*/]
 198 >;
 199
 200 // out = (src0 + src1 > 0xFFFFFFFF) ? 1 : 0
 201 def AMDGPUcarry : SDNode<"AMDGPUISD::CARRY", SDTIntBinOp, []>;
 202
 203 // out = (src1 > src0) ? 1 : 0
 204 def AMDGPUborrow : SDNode<"AMDGPUISD::BORROW", SDTIntBinOp, []>;
 205
 206 // TODO: remove AMDGPUadde/AMDGPUsube when ADDCARRY/SUBCARRY get their own
 207 // nodes in TargetSelectionDAG.td.
 208 def AMDGPUadde : SDNode<"ISD::ADDCARRY", AMDGPUAddeSubeOp, []>;
 209
 210 def AMDGPUsube : SDNode<"ISD::SUBCARRY", AMDGPUAddeSubeOp, []>;
 211
 212 def AMDGPUSetCCOp : SDTypeProfile<1, 3, [        // setcc
 213   SDTCisVT<0, i64>, SDTCisSameAs<1, 2>, SDTCisVT<3, OtherVT>
 214 ]>;
 215
 216 def AMDGPUsetcc : SDNode<"AMDGPUISD::SETCC", AMDGPUSetCCOp>;
 217
 218 def AMDGPUSetRegOp :  SDTypeProfile<0, 2, [
 219   SDTCisInt<0>, SDTCisInt<1>
 220 ]>;
 221
 222 def AMDGPUsetreg : SDNode<"AMDGPUISD::SETREG", AMDGPUSetRegOp, [
 223   SDNPHasChain, SDNPSideEffect, SDNPOptInGlue, SDNPOutGlue]>;
 224
 225 def AMDGPUfma : SDNode<"AMDGPUISD::FMA_W_CHAIN", SDTFPTernaryOp, [
 226    SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
 227
 228 def AMDGPUmul : SDNode<"AMDGPUISD::FMUL_W_CHAIN", SDTFPBinOp, [
 229   SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
 230
 231 def AMDGPUcvt_f32_ubyte0 : SDNode<"AMDGPUISD::CVT_F32_UBYTE0",
 232   SDTIntToFPOp, []>;
 233 def AMDGPUcvt_f32_ubyte1 : SDNode<"AMDGPUISD::CVT_F32_UBYTE1",
 234   SDTIntToFPOp, []>;
 235 def AMDGPUcvt_f32_ubyte2 : SDNode<"AMDGPUISD::CVT_F32_UBYTE2",
 236   SDTIntToFPOp, []>;
 237 def AMDGPUcvt_f32_ubyte3 : SDNode<"AMDGPUISD::CVT_F32_UBYTE3",
 238   SDTIntToFPOp, []>;
 239
 240
 241 // urecip - This operation is a helper for integer division, it returns the
 242 // result of 1 / a as a fractional unsigned integer.
 243 // out = (2^32 / a) + e
 244 // e is rounding error
 245 def AMDGPUurecip : SDNode<"AMDGPUISD::URECIP", SDTIntUnaryOp>;
 246
 247 // Special case divide preop and flags.
 248 def AMDGPUdiv_scale : SDNode<"AMDGPUISD::DIV_SCALE", AMDGPUDivScaleOp>;
 249
 250 //  Special case divide FMA with scale and flags (src0 = Quotient,
 251 //  src1 = Denominator, src2 = Numerator).
 252 def AMDGPUdiv_fmas : SDNode<"AMDGPUISD::DIV_FMAS", AMDGPUFmasOp>;
 253
 254 // Single or double precision division fixup.
 255 // Special case divide fixup and flags(src0 = Quotient, src1 =
 256 // Denominator, src2 = Numerator).
 257 def AMDGPUdiv_fixup : SDNode<"AMDGPUISD::DIV_FIXUP", SDTFPTernaryOp>;
 258
 259 def AMDGPUfmad_ftz : SDNode<"AMDGPUISD::FMAD_FTZ", SDTFPTernaryOp>;
 260
 261 // Look Up 2.0 / pi src0 with segment select src1[4:0]
 262 def AMDGPUtrig_preop : SDNode<"AMDGPUISD::TRIG_PREOP", AMDGPUTrigPreOp>;
 263
 264 def AMDGPUregister_load : SDNode<"AMDGPUISD::REGISTER_LOAD",
 265                           SDTypeProfile<1, 2, [SDTCisPtrTy<1>, SDTCisInt<2>]>,
 266                           [SDNPHasChain, SDNPMayLoad]>;
 267
 268 def AMDGPUregister_store : SDNode<"AMDGPUISD::REGISTER_STORE",
 269                            SDTypeProfile<0, 3, [SDTCisPtrTy<1>, SDTCisInt<2>]>,
 270                            [SDNPHasChain, SDNPMayStore]>;
 271
 272 // MSKOR instructions are atomic memory instructions used mainly for storing
 273 // 8-bit and 16-bit values.  The definition is:
 274 //
 275 // MSKOR(dst, mask, src) MEM[dst] = ((MEM[dst] & ~mask) | src)
 276 //
 277 // src0: vec4(src, 0, 0, mask)
 278 // src1: dst - rat offset (aka pointer) in dwords
 279 def AMDGPUstore_mskor : SDNode<"AMDGPUISD::STORE_MSKOR",
 280                         SDTypeProfile<0, 2, []>,
 281                         [SDNPHasChain, SDNPMayStore, SDNPMemOperand]>;
 282
 283 def AMDGPUatomic_cmp_swap : SDNode<"AMDGPUISD::ATOMIC_CMP_SWAP",
 284                             SDTypeProfile<1, 2, [SDTCisPtrTy<1>, SDTCisVec<2>]>,
 285                             [SDNPHasChain, SDNPMayStore, SDNPMayLoad,
 286                              SDNPMemOperand]>;
 287
 288 def AMDGPUround : SDNode<"ISD::FROUND",
 289                          SDTypeProfile<1, 1, [SDTCisFP<0>, SDTCisSameAs<0,1>]>>;
 290
 291 def AMDGPUbfe_u32 : SDNode<"AMDGPUISD::BFE_U32", AMDGPUDTIntTernaryOp>;
 292 def AMDGPUbfe_i32 : SDNode<"AMDGPUISD::BFE_I32", AMDGPUDTIntTernaryOp>;
 293 def AMDGPUbfi : SDNode<"AMDGPUISD::BFI", AMDGPUDTIntTernaryOp>;
 294 def AMDGPUbfm : SDNode<"AMDGPUISD::BFM", SDTIntBinOp>;
 295
 296 def AMDGPUffbh_u32 : SDNode<"AMDGPUISD::FFBH_U32", SDTIntUnaryOp>;
 297 def AMDGPUffbh_i32 : SDNode<"AMDGPUISD::FFBH_I32", SDTIntUnaryOp>;
 298
 299 def AMDGPUffbl_b32 : SDNode<"AMDGPUISD::FFBL_B32", SDTIntUnaryOp>;
 300
 301 // Signed and unsigned 24-bit multiply. The highest 8-bits are ignore
 302 // when performing the mulitply. The result is a 32-bit value.
 303 def AMDGPUmul_u24 : SDNode<"AMDGPUISD::MUL_U24", SDTIntBinOp,
 304   [SDNPCommutative, SDNPAssociative]
 305 >;
 306 def AMDGPUmul_i24 : SDNode<"AMDGPUISD::MUL_I24", SDTIntBinOp,
 307   [SDNPCommutative, SDNPAssociative]
 308 >;
 309
 310 def AMDGPUmulhi_u24 : SDNode<"AMDGPUISD::MULHI_U24", SDTIntBinOp,
 311   [SDNPCommutative, SDNPAssociative]
 312 >;
 313 def AMDGPUmulhi_i24 : SDNode<"AMDGPUISD::MULHI_I24", SDTIntBinOp,
 314   [SDNPCommutative, SDNPAssociative]
 315 >;
 316
 317 def AMDGPUmad_u24 : SDNode<"AMDGPUISD::MAD_U24", AMDGPUDTIntTernaryOp,
 318   []
 319 >;
 320 def AMDGPUmad_i24 : SDNode<"AMDGPUISD::MAD_I24", AMDGPUDTIntTernaryOp,
 321   []
 322 >;
 323
 324 def AMDGPUsmed3 : SDNode<"AMDGPUISD::SMED3", AMDGPUDTIntTernaryOp,
 325   []
 326 >;
 327
 328 def AMDGPUumed3 : SDNode<"AMDGPUISD::UMED3", AMDGPUDTIntTernaryOp,
 329   []
 330 >;
 331
 332 def AMDGPUfmed3 : SDNode<"AMDGPUISD::FMED3", SDTFPTernaryOp, []>;
 333
 334 def AMDGPUfdot2 : SDNode<"AMDGPUISD::FDOT2",
 335                   SDTypeProfile<1, 4, [SDTCisSameAs<0, 3>, SDTCisSameAs<1, 2>,
 336                                        SDTCisFP<0>, SDTCisVec<1>,
 337                                        SDTCisInt<4>]>,
 338                   []>;
 339
 340 def AMDGPUperm : SDNode<"AMDGPUISD::PERM", AMDGPUDTIntTernaryOp, []>;
 341
 342 def AMDGPUinit_exec : SDNode<"AMDGPUISD::INIT_EXEC",
 343                       SDTypeProfile<0, 1, [SDTCisInt<0>]>,
 344                       [SDNPHasChain, SDNPInGlue]>;
 345
 346 def AMDGPUinit_exec_from_input : SDNode<"AMDGPUISD::INIT_EXEC_FROM_INPUT",
 347                                  SDTypeProfile<0, 2,
 348                                  [SDTCisInt<0>, SDTCisInt<1>]>,
 349                                  [SDNPHasChain, SDNPInGlue]>;
 350
 351 def AMDGPUsendmsg : SDNode<"AMDGPUISD::SENDMSG",
 352                     SDTypeProfile<0, 1, [SDTCisInt<0>]>,
 353                     [SDNPHasChain, SDNPInGlue]>;
 354
 355 def AMDGPUsendmsghalt : SDNode<"AMDGPUISD::SENDMSGHALT",
 356                     SDTypeProfile<0, 1, [SDTCisInt<0>]>,
 357                     [SDNPHasChain, SDNPInGlue]>;
 358
 359 def AMDGPUinterp_mov : SDNode<"AMDGPUISD::INTERP_MOV",
 360                         SDTypeProfile<1, 3, [SDTCisFP<0>]>,
 361                         [SDNPInGlue]>;
 362
 363 def AMDGPUinterp_p1 : SDNode<"AMDGPUISD::INTERP_P1",
 364                       SDTypeProfile<1, 3, [SDTCisFP<0>]>,
 365                       [SDNPInGlue, SDNPOutGlue]>;
 366
 367 def AMDGPUinterp_p2 : SDNode<"AMDGPUISD::INTERP_P2",
 368                       SDTypeProfile<1, 4, [SDTCisFP<0>]>,
 369                       [SDNPInGlue]>;
 370
 371 def AMDGPUinterp_p1ll_f16 : SDNode<"AMDGPUISD::INTERP_P1LL_F16",
 372                             SDTypeProfile<1, 7, [SDTCisFP<0>]>,
 373                             [SDNPInGlue, SDNPOutGlue]>;
 374
 375 def AMDGPUinterp_p1lv_f16 : SDNode<"AMDGPUISD::INTERP_P1LV_F16",
 376                             SDTypeProfile<1, 9, [SDTCisFP<0>]>,
 377                             [SDNPInGlue, SDNPOutGlue]>;
 378
 379 def AMDGPUinterp_p2_f16 : SDNode<"AMDGPUISD::INTERP_P2_F16",
 380                           SDTypeProfile<1, 8, [SDTCisFP<0>]>,
 381                           [SDNPInGlue]>;
 382
 383 def AMDGPUkill : SDNode<"AMDGPUISD::KILL", AMDGPUKillSDT,
 384   [SDNPHasChain, SDNPSideEffect]>;
 385
 386 // SI+ export
 387 def AMDGPUExportOp : SDTypeProfile<0, 8, [
 388   SDTCisInt<0>,       // i8 tgt
 389   SDTCisInt<1>,       // i8 en
 390                       // i32 or f32 src0
 391   SDTCisSameAs<3, 2>, // f32 src1
 392   SDTCisSameAs<4, 2>, // f32 src2
 393   SDTCisSameAs<5, 2>, // f32 src3
 394   SDTCisInt<6>,       // i1 compr
 395   // skip done
 396   SDTCisInt<1>        // i1 vm
 397
 398 ]>;
 399
 400 def AMDGPUexport: SDNode<"AMDGPUISD::EXPORT", AMDGPUExportOp,
 401   [SDNPHasChain, SDNPMayStore]>;
 402
 403 def AMDGPUexport_done: SDNode<"AMDGPUISD::EXPORT_DONE", AMDGPUExportOp,
 404   [SDNPHasChain, SDNPMayLoad, SDNPMayStore]>;
 405
 406
 407 def R600ExportOp : SDTypeProfile<0, 7, [SDTCisFP<0>, SDTCisInt<1>]>;
 408
 409 def R600_EXPORT: SDNode<"AMDGPUISD::R600_EXPORT", R600ExportOp,
 410   [SDNPHasChain, SDNPSideEffect]>;
 411
 412 //===----------------------------------------------------------------------===//
 413 // Flow Control Profile Types
 414 //===----------------------------------------------------------------------===//
 415 // Branch instruction where second and third are basic blocks
 416 def SDTIL_BRCond : SDTypeProfile<0, 2, [
 417     SDTCisVT<0, OtherVT>
 418     ]>;
 419
 420 //===----------------------------------------------------------------------===//
 421 // Flow Control DAG Nodes
 422 //===----------------------------------------------------------------------===//
 423 def IL_brcond      : SDNode<"AMDGPUISD::BRANCH_COND", SDTIL_BRCond, [SDNPHasChain]>;
 424
 425 //===----------------------------------------------------------------------===//
 426 // Call/Return DAG Nodes
 427 //===----------------------------------------------------------------------===//
 428 def AMDGPUendpgm : SDNode<"AMDGPUISD::ENDPGM", SDTNone,
 429     [SDNPHasChain, SDNPOptInGlue]>;
 430
 431 def AMDGPUreturn_to_epilog : SDNode<"AMDGPUISD::RETURN_TO_EPILOG", SDTNone,
 432     [SDNPHasChain, SDNPOptInGlue, SDNPVariadic]>;
 433
 434 def AMDGPUret_flag : SDNode<"AMDGPUISD::RET_FLAG", SDTypeProfile<0, 1, [SDTCisPtrTy<0>]>,
 435   [SDNPHasChain, SDNPOptInGlue, SDNPVariadic]
 436 >;