[Codegen] Alter the default promotion for saturating adds and subs
[llvm-complete.git] / lib / Target / AMDGPU / AMDGPUInstrInfo.td
blob2a73738c141eb65c91bf2a8a9eee3a6d9873bb29
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.
11 //===----------------------------------------------------------------------===//
13 //===----------------------------------------------------------------------===//
14 // AMDGPU DAG Profiles
15 //===----------------------------------------------------------------------===//
17 def AMDGPUDTIntTernaryOp : SDTypeProfile<1, 3, [
18   SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisInt<0>, SDTCisInt<3>
19 ]>;
21 def AMDGPUTrigPreOp : SDTypeProfile<1, 2,
22   [SDTCisSameAs<0, 1>, SDTCisFP<0>, SDTCisInt<2>]
25 def AMDGPULdExpOp : SDTypeProfile<1, 2,
26   [SDTCisSameAs<0, 1>, SDTCisFP<0>, SDTCisInt<2>]
29 def AMDGPUFPClassOp : SDTypeProfile<1, 2,
30   [SDTCisInt<0>, SDTCisFP<1>, SDTCisInt<2>]
33 def AMDGPUFPPackOp : SDTypeProfile<1, 2,
34   [SDTCisFP<1>, SDTCisSameAs<1, 2>]
37 def AMDGPUIntPackOp : SDTypeProfile<1, 2,
38   [SDTCisInt<1>, SDTCisSameAs<1, 2>]
41 def AMDGPUDivScaleOp : SDTypeProfile<2, 3,
42   [SDTCisFP<0>, SDTCisInt<1>, SDTCisSameAs<0, 2>, SDTCisSameAs<0, 3>, SDTCisSameAs<0, 4>]
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>]
50 def AMDGPUKillSDT : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
52 def AMDGPUIfOp : SDTypeProfile<1, 2,
53   [SDTCisVT<0, i1>, SDTCisVT<1, i1>, SDTCisVT<2, OtherVT>]
56 def AMDGPUElseOp : SDTypeProfile<1, 2,
57   [SDTCisVT<0, i1>, SDTCisVT<1, i1>, SDTCisVT<2, OtherVT>]
60 def AMDGPULoopOp : SDTypeProfile<0, 2,
61   [SDTCisVT<0, i1>, SDTCisVT<1, OtherVT>]
64 def AMDGPUIfBreakOp : SDTypeProfile<1, 2,
65   [SDTCisVT<0, i1>, SDTCisVT<1, i1>, SDTCisVT<2, i1>]
68 //===----------------------------------------------------------------------===//
69 // AMDGPU DAG Nodes
72 def AMDGPUif : SDNode<"AMDGPUISD::IF", AMDGPUIfOp, [SDNPHasChain]>;
73 def AMDGPUelse : SDNode<"AMDGPUISD::ELSE", AMDGPUElseOp, [SDNPHasChain]>;
74 def AMDGPUloop : SDNode<"AMDGPUISD::LOOP", AMDGPULoopOp, [SDNPHasChain]>;
76 def callseq_start : SDNode<"ISD::CALLSEQ_START",
77   SDCallSeqStart<[ SDTCisVT<0, i32>, SDTCisVT<1, i32> ]>,
78   [SDNPHasChain, SDNPOutGlue]
81 def callseq_end : SDNode<"ISD::CALLSEQ_END",
82  SDCallSeqEnd<[ SDTCisVT<0, i32>, SDTCisVT<1, i32> ]>,
83   [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]
86 def AMDGPUcall : SDNode<"AMDGPUISD::CALL",
87   SDTypeProfile<0, -1, [SDTCisPtrTy<0>]>,
88   [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue,
89   SDNPVariadic]
92 def AMDGPUtc_return: SDNode<"AMDGPUISD::TC_RETURN",
93   SDTypeProfile<0, 3, [SDTCisPtrTy<0>]>,
94   [SDNPHasChain, SDNPOptInGlue, SDNPVariadic]
97 def AMDGPUtrap : SDNode<"AMDGPUISD::TRAP",
98   SDTypeProfile<0, -1, [SDTCisVT<0, i16>]>,
99     [SDNPHasChain, SDNPVariadic, SDNPSideEffect, SDNPInGlue]
102 def AMDGPUconstdata_ptr : SDNode<
103   "AMDGPUISD::CONST_DATA_PTR", SDTypeProfile <1, 1, [SDTCisVT<0, iPTR>,
104                                                      SDTCisVT<0, iPTR>]>
107 // This argument to this node is a dword address.
108 def AMDGPUdwordaddr : SDNode<"AMDGPUISD::DWORDADDR", SDTIntUnaryOp>;
110 // Force dependencies for vector trunc stores
111 def R600dummy_chain : SDNode<"AMDGPUISD::DUMMY_CHAIN", SDTNone, [SDNPHasChain]>;
113 def AMDGPUcos_impl : SDNode<"AMDGPUISD::COS_HW", SDTFPUnaryOp>;
114 def AMDGPUsin_impl : SDNode<"AMDGPUISD::SIN_HW", SDTFPUnaryOp>;
115 // out = a - floor(a)
116 def AMDGPUfract_impl : SDNode<"AMDGPUISD::FRACT", SDTFPUnaryOp>;
118 // out = 1.0 / a
119 def AMDGPUrcp_impl : SDNode<"AMDGPUISD::RCP", SDTFPUnaryOp>;
121 // out = 1.0 / sqrt(a)
122 def AMDGPUrsq_impl : SDNode<"AMDGPUISD::RSQ", SDTFPUnaryOp>;
124 // out = 1.0 / sqrt(a)
125 def AMDGPUrsq_legacy_impl : SDNode<"AMDGPUISD::RSQ_LEGACY", SDTFPUnaryOp>;
126 def AMDGPUrcp_legacy_impl : SDNode<"AMDGPUISD::RCP_LEGACY", SDTFPUnaryOp>;
128 def AMDGPUrcp_iflag : SDNode<"AMDGPUISD::RCP_IFLAG", SDTFPUnaryOp>;
130 // out = 1.0 / sqrt(a) result clamped to +/- max_float.
131 def AMDGPUrsq_clamp_impl : SDNode<"AMDGPUISD::RSQ_CLAMP", SDTFPUnaryOp>;
133 def AMDGPUldexp_impl : SDNode<"AMDGPUISD::LDEXP", AMDGPULdExpOp>;
135 def AMDGPUpkrtz_f16_f32_impl : SDNode<"AMDGPUISD::CVT_PKRTZ_F16_F32", AMDGPUFPPackOp>;
136 def AMDGPUpknorm_i16_f32_impl : SDNode<"AMDGPUISD::CVT_PKNORM_I16_F32", AMDGPUFPPackOp>;
137 def AMDGPUpknorm_u16_f32_impl : SDNode<"AMDGPUISD::CVT_PKNORM_U16_F32", AMDGPUFPPackOp>;
138 def AMDGPUpk_i16_i32_impl : SDNode<"AMDGPUISD::CVT_PK_I16_I32", AMDGPUIntPackOp>;
139 def AMDGPUpk_u16_u32_impl : SDNode<"AMDGPUISD::CVT_PK_U16_U32", AMDGPUIntPackOp>;
140 def AMDGPUfp_to_f16 : SDNode<"AMDGPUISD::FP_TO_FP16" , SDTFPToIntOp>;
141 def AMDGPUfp16_zext : SDNode<"AMDGPUISD::FP16_ZEXT" , SDTFPToIntOp>;
144 def AMDGPUfp_class_impl : SDNode<"AMDGPUISD::FP_CLASS", AMDGPUFPClassOp>;
146 // out = max(a, b) a and b are floats, where a nan comparison fails.
147 // This is not commutative because this gives the second operand:
148 //   x < nan ? x : nan -> nan
149 //   nan < x ? nan : x -> x
150 def AMDGPUfmax_legacy : SDNode<"AMDGPUISD::FMAX_LEGACY", SDTFPBinOp,
151   []
154 def AMDGPUfmul_legacy : SDNode<"AMDGPUISD::FMUL_LEGACY", SDTFPBinOp,
155   [SDNPCommutative, SDNPAssociative]
158 // out = min(a, b) a and b are floats, where a nan comparison fails.
159 def AMDGPUfmin_legacy : SDNode<"AMDGPUISD::FMIN_LEGACY", SDTFPBinOp,
160   []
163 // FIXME: TableGen doesn't like commutative instructions with more
164 // than 2 operands.
165 // out = max(a, b, c) a, b and c are floats
166 def AMDGPUfmax3 : SDNode<"AMDGPUISD::FMAX3", SDTFPTernaryOp,
167   [/*SDNPCommutative, SDNPAssociative*/]
170 // out = max(a, b, c) a, b, and c are signed ints
171 def AMDGPUsmax3 : SDNode<"AMDGPUISD::SMAX3", AMDGPUDTIntTernaryOp,
172   [/*SDNPCommutative, SDNPAssociative*/]
175 // out = max(a, b, c) a, b and c are unsigned ints
176 def AMDGPUumax3 : SDNode<"AMDGPUISD::UMAX3", AMDGPUDTIntTernaryOp,
177   [/*SDNPCommutative, SDNPAssociative*/]
180 // out = min(a, b, c) a, b and c are floats
181 def AMDGPUfmin3 : SDNode<"AMDGPUISD::FMIN3", SDTFPTernaryOp,
182   [/*SDNPCommutative, SDNPAssociative*/]
185 // out = min(a, b, c) a, b and c are signed ints
186 def AMDGPUsmin3 : SDNode<"AMDGPUISD::SMIN3", AMDGPUDTIntTernaryOp,
187   [/*SDNPCommutative, SDNPAssociative*/]
190 // out = min(a, b) a and b are unsigned ints
191 def AMDGPUumin3 : SDNode<"AMDGPUISD::UMIN3", AMDGPUDTIntTernaryOp,
192   [/*SDNPCommutative, SDNPAssociative*/]
195 // out = (src0 + src1 > 0xFFFFFFFF) ? 1 : 0
196 def AMDGPUcarry : SDNode<"AMDGPUISD::CARRY", SDTIntBinOp, []>;
198 // out = (src1 > src0) ? 1 : 0
199 def AMDGPUborrow : SDNode<"AMDGPUISD::BORROW", SDTIntBinOp, []>;
201 def AMDGPUSetCCOp : SDTypeProfile<1, 3, [        // setcc
202   SDTCisInt<0>, SDTCisSameAs<1, 2>, SDTCisVT<3, OtherVT>
205 def AMDGPUsetcc : SDNode<"AMDGPUISD::SETCC", AMDGPUSetCCOp>;
207 def AMDGPUSetRegOp :  SDTypeProfile<0, 2, [
208   SDTCisInt<0>, SDTCisInt<1>
211 def AMDGPUsetreg : SDNode<"AMDGPUISD::SETREG", AMDGPUSetRegOp, [
212   SDNPHasChain, SDNPSideEffect, SDNPOptInGlue, SDNPOutGlue]>;
214 def AMDGPUfma : SDNode<"AMDGPUISD::FMA_W_CHAIN", SDTFPTernaryOp, [
215    SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
217 def AMDGPUmul : SDNode<"AMDGPUISD::FMUL_W_CHAIN", SDTFPBinOp, [
218   SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
220 def AMDGPUcvt_f32_ubyte0 : SDNode<"AMDGPUISD::CVT_F32_UBYTE0",
221   SDTIntToFPOp, []>;
222 def AMDGPUcvt_f32_ubyte1 : SDNode<"AMDGPUISD::CVT_F32_UBYTE1",
223   SDTIntToFPOp, []>;
224 def AMDGPUcvt_f32_ubyte2 : SDNode<"AMDGPUISD::CVT_F32_UBYTE2",
225   SDTIntToFPOp, []>;
226 def AMDGPUcvt_f32_ubyte3 : SDNode<"AMDGPUISD::CVT_F32_UBYTE3",
227   SDTIntToFPOp, []>;
230 // urecip - This operation is a helper for integer division, it returns the
231 // result of 1 / a as a fractional unsigned integer.
232 // out = (2^32 / a) + e
233 // e is rounding error
234 def AMDGPUurecip : SDNode<"AMDGPUISD::URECIP", SDTIntUnaryOp>;
236 // Special case divide preop and flags.
237 def AMDGPUdiv_scale : SDNode<"AMDGPUISD::DIV_SCALE", AMDGPUDivScaleOp>;
239 //  Special case divide FMA with scale and flags (src0 = Quotient,
240 //  src1 = Denominator, src2 = Numerator).
241 def AMDGPUdiv_fmas : SDNode<"AMDGPUISD::DIV_FMAS", AMDGPUFmasOp,
242                             [SDNPOptInGlue]>;
244 // Single or double precision division fixup.
245 // Special case divide fixup and flags(src0 = Quotient, src1 =
246 // Denominator, src2 = Numerator).
247 def AMDGPUdiv_fixup : SDNode<"AMDGPUISD::DIV_FIXUP", SDTFPTernaryOp>;
249 def AMDGPUfmad_ftz : SDNode<"AMDGPUISD::FMAD_FTZ", SDTFPTernaryOp>;
251 // Look Up 2.0 / pi src0 with segment select src1[4:0]
252 def AMDGPUtrig_preop : SDNode<"AMDGPUISD::TRIG_PREOP", AMDGPUTrigPreOp>;
254 def AMDGPUregister_load : SDNode<"AMDGPUISD::REGISTER_LOAD",
255                           SDTypeProfile<1, 2, [SDTCisPtrTy<1>, SDTCisInt<2>]>,
256                           [SDNPHasChain, SDNPMayLoad]>;
258 def AMDGPUregister_store : SDNode<"AMDGPUISD::REGISTER_STORE",
259                            SDTypeProfile<0, 3, [SDTCisPtrTy<1>, SDTCisInt<2>]>,
260                            [SDNPHasChain, SDNPMayStore]>;
262 // MSKOR instructions are atomic memory instructions used mainly for storing
263 // 8-bit and 16-bit values.  The definition is:
265 // MSKOR(dst, mask, src) MEM[dst] = ((MEM[dst] & ~mask) | src)
267 // src0: vec4(src, 0, 0, mask)
268 // src1: dst - rat offset (aka pointer) in dwords
269 def AMDGPUstore_mskor : SDNode<"AMDGPUISD::STORE_MSKOR",
270                         SDTypeProfile<0, 2, []>,
271                         [SDNPHasChain, SDNPMayStore, SDNPMemOperand]>;
273 def AMDGPUatomic_cmp_swap : SDNode<"AMDGPUISD::ATOMIC_CMP_SWAP",
274                             SDTypeProfile<1, 2, [SDTCisPtrTy<1>, SDTCisVec<2>]>,
275                             [SDNPHasChain, SDNPMayStore, SDNPMayLoad,
276                              SDNPMemOperand]>;
278 def AMDGPUround : SDNode<"ISD::FROUND",
279                          SDTypeProfile<1, 1, [SDTCisFP<0>, SDTCisSameAs<0,1>]>>;
281 def AMDGPUbfe_u32 : SDNode<"AMDGPUISD::BFE_U32", AMDGPUDTIntTernaryOp>;
282 def AMDGPUbfe_i32 : SDNode<"AMDGPUISD::BFE_I32", AMDGPUDTIntTernaryOp>;
283 def AMDGPUbfi : SDNode<"AMDGPUISD::BFI", AMDGPUDTIntTernaryOp>;
284 def AMDGPUbfm : SDNode<"AMDGPUISD::BFM", SDTIntBinOp>;
286 def AMDGPUffbh_u32 : SDNode<"AMDGPUISD::FFBH_U32", SDTIntUnaryOp>;
287 def AMDGPUffbh_i32_impl : SDNode<"AMDGPUISD::FFBH_I32", SDTIntUnaryOp>;
289 def AMDGPUffbl_b32 : SDNode<"AMDGPUISD::FFBL_B32", SDTIntUnaryOp>;
291 // Signed and unsigned 24-bit multiply. The highest 8-bits are ignore
292 // when performing the mulitply. The result is a 32-bit value.
293 def AMDGPUmul_u24 : SDNode<"AMDGPUISD::MUL_U24", SDTIntBinOp,
294   [SDNPCommutative, SDNPAssociative]
296 def AMDGPUmul_i24 : SDNode<"AMDGPUISD::MUL_I24", SDTIntBinOp,
297   [SDNPCommutative, SDNPAssociative]
300 def AMDGPUmulhi_u24 : SDNode<"AMDGPUISD::MULHI_U24", SDTIntBinOp,
301   [SDNPCommutative, SDNPAssociative]
303 def AMDGPUmulhi_i24 : SDNode<"AMDGPUISD::MULHI_I24", SDTIntBinOp,
304   [SDNPCommutative, SDNPAssociative]
307 def AMDGPUmad_u24 : SDNode<"AMDGPUISD::MAD_U24", AMDGPUDTIntTernaryOp,
308   []
310 def AMDGPUmad_i24 : SDNode<"AMDGPUISD::MAD_I24", AMDGPUDTIntTernaryOp,
311   []
314 def AMDGPUsmed3 : SDNode<"AMDGPUISD::SMED3", AMDGPUDTIntTernaryOp,
315   []
318 def AMDGPUumed3 : SDNode<"AMDGPUISD::UMED3", AMDGPUDTIntTernaryOp,
319   []
322 def AMDGPUfmed3_impl : SDNode<"AMDGPUISD::FMED3", SDTFPTernaryOp, []>;
324 def AMDGPUfdot2 : SDNode<"AMDGPUISD::FDOT2",
325                   SDTypeProfile<1, 4, [SDTCisSameAs<0, 3>, SDTCisSameAs<1, 2>,
326                                        SDTCisFP<0>, SDTCisVec<1>,
327                                        SDTCisInt<4>]>,
328                   []>;
330 def AMDGPUperm : SDNode<"AMDGPUISD::PERM", AMDGPUDTIntTernaryOp, []>;
332 def AMDGPUinterp_mov : SDNode<"AMDGPUISD::INTERP_MOV",
333                         SDTypeProfile<1, 3, [SDTCisFP<0>]>,
334                         [SDNPInGlue]>;
336 def AMDGPUinterp_p1 : SDNode<"AMDGPUISD::INTERP_P1",
337                       SDTypeProfile<1, 3, [SDTCisFP<0>]>,
338                       [SDNPInGlue, SDNPOutGlue]>;
340 def AMDGPUinterp_p2 : SDNode<"AMDGPUISD::INTERP_P2",
341                       SDTypeProfile<1, 4, [SDTCisFP<0>]>,
342                       [SDNPInGlue]>;
344 def AMDGPUinterp_p1ll_f16 : SDNode<"AMDGPUISD::INTERP_P1LL_F16",
345                             SDTypeProfile<1, 7, [SDTCisFP<0>]>,
346                             [SDNPInGlue, SDNPOutGlue]>;
348 def AMDGPUinterp_p1lv_f16 : SDNode<"AMDGPUISD::INTERP_P1LV_F16",
349                             SDTypeProfile<1, 9, [SDTCisFP<0>]>,
350                             [SDNPInGlue, SDNPOutGlue]>;
352 def AMDGPUinterp_p2_f16 : SDNode<"AMDGPUISD::INTERP_P2_F16",
353                           SDTypeProfile<1, 8, [SDTCisFP<0>]>,
354                           [SDNPInGlue]>;
356 def AMDGPUkill : SDNode<"AMDGPUISD::KILL", AMDGPUKillSDT,
357   [SDNPHasChain, SDNPSideEffect]>;
359 // SI+ export
360 def AMDGPUExportOp : SDTypeProfile<0, 8, [
361   SDTCisInt<0>,       // i8 tgt
362   SDTCisInt<1>,       // i8 en
363                       // i32 or f32 src0
364   SDTCisSameAs<3, 2>, // f32 src1
365   SDTCisSameAs<4, 2>, // f32 src2
366   SDTCisSameAs<5, 2>, // f32 src3
367   SDTCisInt<6>,       // i1 compr
368   // skip done
369   SDTCisInt<1>        // i1 vm
373 def AMDGPUexport: SDNode<"AMDGPUISD::EXPORT", AMDGPUExportOp,
374   [SDNPHasChain, SDNPMayStore]>;
376 def AMDGPUexport_done: SDNode<"AMDGPUISD::EXPORT_DONE", AMDGPUExportOp,
377   [SDNPHasChain, SDNPMayLoad, SDNPMayStore]>;
380 def R600ExportOp : SDTypeProfile<0, 7, [SDTCisFP<0>, SDTCisInt<1>]>;
382 def R600_EXPORT: SDNode<"AMDGPUISD::R600_EXPORT", R600ExportOp,
383   [SDNPHasChain, SDNPSideEffect]>;
385 //===----------------------------------------------------------------------===//
386 // Flow Control Profile Types
387 //===----------------------------------------------------------------------===//
388 // Branch instruction where second and third are basic blocks
389 def SDTIL_BRCond : SDTypeProfile<0, 2, [
390     SDTCisVT<0, OtherVT>
391     ]>;
393 //===----------------------------------------------------------------------===//
394 // Flow Control DAG Nodes
395 //===----------------------------------------------------------------------===//
396 def IL_brcond      : SDNode<"AMDGPUISD::BRANCH_COND", SDTIL_BRCond, [SDNPHasChain]>;
398 //===----------------------------------------------------------------------===//
399 // Call/Return DAG Nodes
400 //===----------------------------------------------------------------------===//
401 def AMDGPUendpgm : SDNode<"AMDGPUISD::ENDPGM", SDTNone,
402     [SDNPHasChain, SDNPOptInGlue]>;
404 def AMDGPUreturn_to_epilog : SDNode<"AMDGPUISD::RETURN_TO_EPILOG", SDTNone,
405     [SDNPHasChain, SDNPOptInGlue, SDNPVariadic]>;
407 def AMDGPUret_flag : SDNode<"AMDGPUISD::RET_FLAG", SDTypeProfile<0, 1, [SDTCisPtrTy<0>]>,
408   [SDNPHasChain, SDNPOptInGlue, SDNPVariadic]
412 //===----------------------------------------------------------------------===//
413 // Intrinsic/Custom node compatability PatFrags
414 //===----------------------------------------------------------------------===//
416 def AMDGPUrcp : PatFrags<(ops node:$src), [(int_amdgcn_rcp node:$src),
417                                            (AMDGPUrcp_impl node:$src)]>;
418 def AMDGPUrcp_legacy : PatFrags<(ops node:$src), [(int_amdgcn_rcp_legacy node:$src),
419                                                   (AMDGPUrcp_legacy_impl node:$src)]>;
421 def AMDGPUrsq_legacy : PatFrags<(ops node:$src), [(int_amdgcn_rsq_legacy node:$src),
422                                                   (AMDGPUrsq_legacy_impl node:$src)]>;
424 def AMDGPUrsq : PatFrags<(ops node:$src), [(int_amdgcn_rsq node:$src),
425                                            (AMDGPUrsq_impl node:$src)]>;
427 def AMDGPUrsq_clamp : PatFrags<(ops node:$src), [(int_amdgcn_rsq_clamp node:$src),
428                                                  (AMDGPUrsq_clamp_impl node:$src)]>;
430 def AMDGPUsin : PatFrags<(ops node:$src), [(int_amdgcn_sin node:$src),
431                                            (AMDGPUsin_impl node:$src)]>;
432 def AMDGPUcos : PatFrags<(ops node:$src), [(int_amdgcn_cos node:$src),
433                                            (AMDGPUcos_impl node:$src)]>;
434 def AMDGPUfract : PatFrags<(ops node:$src), [(int_amdgcn_fract node:$src),
435                                              (AMDGPUfract_impl node:$src)]>;
437 def AMDGPUldexp : PatFrags<(ops node:$src0, node:$src1),
438   [(int_amdgcn_ldexp node:$src0, node:$src1),
439    (AMDGPUldexp_impl node:$src0, node:$src1)]>;
441 def AMDGPUfp_class : PatFrags<(ops node:$src0, node:$src1),
442   [(int_amdgcn_class node:$src0, node:$src1),
443   (AMDGPUfp_class_impl node:$src0, node:$src1)]>;
445 def AMDGPUfmed3 : PatFrags<(ops node:$src0, node:$src1, node:$src2),
446   [(int_amdgcn_fmed3 node:$src0, node:$src1, node:$src2),
447    (AMDGPUfmed3_impl node:$src0, node:$src1, node:$src2)]>;
449 def AMDGPUffbh_i32 : PatFrags<(ops node:$src),
450   [(int_amdgcn_sffbh node:$src),
451    (AMDGPUffbh_i32_impl node:$src)]>;
453 def AMDGPUpkrtz_f16_f32 : PatFrags<(ops node:$src0, node:$src1),
454   [(int_amdgcn_cvt_pkrtz node:$src0, node:$src1),
455   (AMDGPUpkrtz_f16_f32_impl node:$src0, node:$src1)]>;
457 def AMDGPUpknorm_i16_f32 : PatFrags<(ops node:$src0, node:$src1),
458   [(int_amdgcn_cvt_pknorm_i16 node:$src0, node:$src1),
459   (AMDGPUpknorm_i16_f32_impl node:$src0, node:$src1)]>;
461 def AMDGPUpknorm_u16_f32 : PatFrags<(ops node:$src0, node:$src1),
462   [(int_amdgcn_cvt_pknorm_u16 node:$src0, node:$src1),
463   (AMDGPUpknorm_u16_f32_impl node:$src0, node:$src1)]>;
465 def AMDGPUpk_i16_i32 : PatFrags<(ops node:$src0, node:$src1),
466   [(int_amdgcn_cvt_pk_i16 node:$src0, node:$src1),
467   (AMDGPUpk_i16_i32_impl node:$src0, node:$src1)]>;
469 def AMDGPUpk_u16_u32 : PatFrags<(ops node:$src0, node:$src1),
470   [(int_amdgcn_cvt_pk_u16 node:$src0, node:$src1),
471   (AMDGPUpk_u16_u32_impl node:$src0, node:$src1)]>;