lib/Target/AMDGPU/CIInstructions.td

   1 //===-- CIInstructions.td - CI Instruction Defintions ---------------------===//
   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 // Instruction definitions for CI and newer.
  10 //===----------------------------------------------------------------------===//
  11 // Remaining instructions:
  12 // S_CBRANCH_CDBGUSER
  13 // S_CBRANCH_CDBGSYS
  14 // S_CBRANCH_CDBGSYS_OR_USER
  15 // S_CBRANCH_CDBGSYS_AND_USER
  16 // DS_NOP
  17 // DS_GWS_SEMA_RELEASE_ALL
  18 // DS_WRAP_RTN_B32
  19 // DS_CNDXCHG32_RTN_B64
  20 // DS_WRITE_B96
  21 // DS_WRITE_B128
  22 // DS_CONDXCHG32_RTN_B128
  23 // DS_READ_B96
  24 // DS_READ_B128
  25 // BUFFER_LOAD_DWORDX3
  26 // BUFFER_STORE_DWORDX3
  27
  28
  29 def isCIVI : Predicate <
  30   "Subtarget->getGeneration() == AMDGPUSubtarget::SEA_ISLANDS || "
  31   "Subtarget->getGeneration() == AMDGPUSubtarget::VOLCANIC_ISLANDS"
  32 >, AssemblerPredicate<"FeatureCIInsts">;
  33
  34 def HasFlatAddressSpace : Predicate<"Subtarget->hasFlatAddressSpace()">;
  35
  36 //===----------------------------------------------------------------------===//
  37 // VOP1 Instructions
  38 //===----------------------------------------------------------------------===//
  39
  40 let SubtargetPredicate = isCIVI in {
  41
  42 let SchedRW = [WriteDoubleAdd] in {
  43 defm V_TRUNC_F64 : VOP1Inst <vop1<0x17>, "v_trunc_f64",
  44   VOP_F64_F64, ftrunc
  45 >;
  46 defm V_CEIL_F64 : VOP1Inst <vop1<0x18>, "v_ceil_f64",
  47   VOP_F64_F64, fceil
  48 >;
  49 defm V_FLOOR_F64 : VOP1Inst <vop1<0x1A>, "v_floor_f64",
  50   VOP_F64_F64, ffloor
  51 >;
  52 defm V_RNDNE_F64 : VOP1Inst <vop1<0x19>, "v_rndne_f64",
  53   VOP_F64_F64, frint
  54 >;
  55 } // End SchedRW = [WriteDoubleAdd]
  56
  57 let SchedRW = [WriteQuarterRate32] in {
  58 defm V_LOG_LEGACY_F32 : VOP1Inst <vop1<0x45, 0x4c>, "v_log_legacy_f32",
  59   VOP_F32_F32
  60 >;
  61 defm V_EXP_LEGACY_F32 : VOP1Inst <vop1<0x46, 0x4b>, "v_exp_legacy_f32",
  62   VOP_F32_F32
  63 >;
  64 } // End SchedRW = [WriteQuarterRate32]
  65
  66 //===----------------------------------------------------------------------===//
  67 // VOP3 Instructions
  68 //===----------------------------------------------------------------------===//
  69
  70 defm V_QSAD_PK_U16_U8 : VOP3Inst <vop3<0x173>, "v_qsad_pk_u16_u8",
  71   VOP_I32_I32_I32
  72 >;
  73 defm V_MQSAD_U16_U8 : VOP3Inst <vop3<0x172>, "v_mqsad_u16_u8",
  74   VOP_I32_I32_I32
  75 >;
  76 defm V_MQSAD_U32_U8 : VOP3Inst <vop3<0x175>, "v_mqsad_u32_u8",
  77   VOP_I32_I32_I32
  78 >;
  79
  80 let isCommutable = 1 in {
  81 defm V_MAD_U64_U32 : VOP3Inst <vop3<0x176>, "v_mad_u64_u32",
  82   VOP_I64_I32_I32_I64
  83 >;
  84
  85 // XXX - Does this set VCC?
  86 defm V_MAD_I64_I32 : VOP3Inst <vop3<0x177>, "v_mad_i64_i32",
  87   VOP_I64_I32_I32_I64
  88 >;
  89 } // End isCommutable = 1
  90
  91
  92 //===----------------------------------------------------------------------===//
  93 // DS Instructions
  94 //===----------------------------------------------------------------------===//
  95 defm DS_WRAP_RTN_F32 : DS_1A1D_RET <0x34, "ds_wrap_rtn_f32", VGPR_32, "ds_wrap_f32">;
  96
  97 // DS_CONDXCHG32_RTN_B64
  98 // DS_CONDXCHG32_RTN_B128
  99
 100 //===----------------------------------------------------------------------===//
 101 // SMRD Instructions
 102 //===----------------------------------------------------------------------===//
 103
 104 defm S_DCACHE_INV_VOL : SMRD_Inval <smrd<0x1d, 0x22>,
 105   "s_dcache_inv_vol", int_amdgcn_s_dcache_inv_vol>;
 106
 107 //===----------------------------------------------------------------------===//
 108 // MUBUF Instructions
 109 //===----------------------------------------------------------------------===//
 110
 111 defm BUFFER_WBINVL1_VOL : MUBUF_Invalidate <mubuf<0x70, 0x3f>,
 112   "buffer_wbinvl1_vol", int_amdgcn_buffer_wbinvl1_vol
 113 >;
 114
 115 //===----------------------------------------------------------------------===//
 116 // Flat Instructions
 117 //===----------------------------------------------------------------------===//
 118
 119 defm FLAT_LOAD_UBYTE : FLAT_Load_Helper <
 120   flat<0x8, 0x10>, "flat_load_ubyte", VGPR_32
 121 >;
 122 defm FLAT_LOAD_SBYTE : FLAT_Load_Helper <
 123   flat<0x9, 0x11>, "flat_load_sbyte", VGPR_32
 124 >;
 125 defm FLAT_LOAD_USHORT : FLAT_Load_Helper <
 126   flat<0xa, 0x12>, "flat_load_ushort", VGPR_32
 127 >;
 128 defm FLAT_LOAD_SSHORT : FLAT_Load_Helper <
 129   flat<0xb, 0x13>, "flat_load_sshort", VGPR_32>
 130 ;
 131 defm FLAT_LOAD_DWORD : FLAT_Load_Helper <
 132   flat<0xc, 0x14>, "flat_load_dword", VGPR_32
 133 >;
 134 defm FLAT_LOAD_DWORDX2 : FLAT_Load_Helper <
 135   flat<0xd, 0x15>, "flat_load_dwordx2", VReg_64
 136 >;
 137 defm FLAT_LOAD_DWORDX4 : FLAT_Load_Helper <
 138   flat<0xe, 0x17>, "flat_load_dwordx4", VReg_128
 139 >;
 140 defm FLAT_LOAD_DWORDX3 : FLAT_Load_Helper <
 141   flat<0xf, 0x16>, "flat_load_dwordx3", VReg_96
 142 >;
 143 defm FLAT_STORE_BYTE : FLAT_Store_Helper <
 144   flat<0x18>, "flat_store_byte", VGPR_32
 145 >;
 146 defm FLAT_STORE_SHORT : FLAT_Store_Helper <
 147   flat <0x1a>, "flat_store_short", VGPR_32
 148 >;
 149 defm FLAT_STORE_DWORD : FLAT_Store_Helper <
 150   flat<0x1c>, "flat_store_dword", VGPR_32
 151 >;
 152 defm FLAT_STORE_DWORDX2 : FLAT_Store_Helper <
 153   flat<0x1d>, "flat_store_dwordx2", VReg_64
 154 >;
 155 defm FLAT_STORE_DWORDX4 : FLAT_Store_Helper <
 156   flat<0x1e, 0x1f>, "flat_store_dwordx4", VReg_128
 157 >;
 158 defm FLAT_STORE_DWORDX3 : FLAT_Store_Helper <
 159   flat<0x1f, 0x1e>, "flat_store_dwordx3", VReg_96
 160 >;
 161 defm FLAT_ATOMIC_SWAP : FLAT_ATOMIC <
 162   flat<0x30, 0x40>, "flat_atomic_swap", VGPR_32
 163 >;
 164 defm FLAT_ATOMIC_CMPSWAP : FLAT_ATOMIC <
 165   flat<0x31, 0x41>, "flat_atomic_cmpswap", VGPR_32, VReg_64
 166 >;
 167 defm FLAT_ATOMIC_ADD : FLAT_ATOMIC <
 168   flat<0x32, 0x42>, "flat_atomic_add", VGPR_32
 169 >;
 170 defm FLAT_ATOMIC_SUB : FLAT_ATOMIC <
 171   flat<0x33, 0x43>, "flat_atomic_sub", VGPR_32
 172 >;
 173 defm FLAT_ATOMIC_SMIN : FLAT_ATOMIC <
 174   flat<0x35, 0x44>, "flat_atomic_smin", VGPR_32
 175 >;
 176 defm FLAT_ATOMIC_UMIN : FLAT_ATOMIC <
 177   flat<0x36, 0x45>, "flat_atomic_umin", VGPR_32
 178 >;
 179 defm FLAT_ATOMIC_SMAX : FLAT_ATOMIC <
 180   flat<0x37, 0x46>, "flat_atomic_smax", VGPR_32
 181 >;
 182 defm FLAT_ATOMIC_UMAX : FLAT_ATOMIC <
 183   flat<0x38, 0x47>, "flat_atomic_umax", VGPR_32
 184 >;
 185 defm FLAT_ATOMIC_AND : FLAT_ATOMIC <
 186   flat<0x39, 0x48>, "flat_atomic_and", VGPR_32
 187 >;
 188 defm FLAT_ATOMIC_OR : FLAT_ATOMIC <
 189   flat<0x3a, 0x49>, "flat_atomic_or", VGPR_32
 190 >;
 191 defm FLAT_ATOMIC_XOR : FLAT_ATOMIC <
 192   flat<0x3b, 0x4a>, "flat_atomic_xor", VGPR_32
 193 >;
 194 defm FLAT_ATOMIC_INC : FLAT_ATOMIC <
 195   flat<0x3c, 0x4b>, "flat_atomic_inc", VGPR_32
 196 >;
 197 defm FLAT_ATOMIC_DEC : FLAT_ATOMIC <
 198   flat<0x3d, 0x4c>, "flat_atomic_dec", VGPR_32
 199 >;
 200 defm FLAT_ATOMIC_SWAP_X2 : FLAT_ATOMIC <
 201   flat<0x50, 0x60>, "flat_atomic_swap_x2", VReg_64
 202 >;
 203 defm FLAT_ATOMIC_CMPSWAP_X2 : FLAT_ATOMIC <
 204   flat<0x51, 0x61>, "flat_atomic_cmpswap_x2", VReg_64, VReg_128
 205 >;
 206 defm FLAT_ATOMIC_ADD_X2 : FLAT_ATOMIC <
 207   flat<0x52, 0x62>, "flat_atomic_add_x2", VReg_64
 208 >;
 209 defm FLAT_ATOMIC_SUB_X2 : FLAT_ATOMIC <
 210   flat<0x53, 0x63>, "flat_atomic_sub_x2", VReg_64
 211 >;
 212 defm FLAT_ATOMIC_SMIN_X2 : FLAT_ATOMIC <
 213   flat<0x55, 0x64>, "flat_atomic_smin_x2", VReg_64
 214 >;
 215 defm FLAT_ATOMIC_UMIN_X2 : FLAT_ATOMIC <
 216   flat<0x56, 0x65>, "flat_atomic_umin_x2", VReg_64
 217 >;
 218 defm FLAT_ATOMIC_SMAX_X2 : FLAT_ATOMIC <
 219   flat<0x57, 0x66>, "flat_atomic_smax_x2", VReg_64
 220 >;
 221 defm FLAT_ATOMIC_UMAX_X2 : FLAT_ATOMIC <
 222   flat<0x58, 0x67>, "flat_atomic_umax_x2", VReg_64
 223 >;
 224 defm FLAT_ATOMIC_AND_X2 : FLAT_ATOMIC <
 225   flat<0x59, 0x68>, "flat_atomic_and_x2", VReg_64
 226 >;
 227 defm FLAT_ATOMIC_OR_X2 : FLAT_ATOMIC <
 228   flat<0x5a, 0x69>, "flat_atomic_or_x2", VReg_64
 229 >;
 230 defm FLAT_ATOMIC_XOR_X2 : FLAT_ATOMIC <
 231   flat<0x5b, 0x6a>, "flat_atomic_xor_x2", VReg_64
 232 >;
 233 defm FLAT_ATOMIC_INC_X2 : FLAT_ATOMIC <
 234   flat<0x5c, 0x6b>, "flat_atomic_inc_x2", VReg_64
 235 >;
 236 defm FLAT_ATOMIC_DEC_X2 : FLAT_ATOMIC <
 237   flat<0x5d, 0x6c>, "flat_atomic_dec_x2", VReg_64
 238 >;
 239
 240 } // End SubtargetPredicate = isCIVI
 241
 242 // CI Only flat instructions
 243
 244 let SubtargetPredicate = isCI, VIAssemblerPredicate = DisableInst in {
 245
 246 defm FLAT_ATOMIC_FCMPSWAP : FLAT_ATOMIC <
 247   flat<0x3e>, "flat_atomic_fcmpswap", VGPR_32, VReg_64
 248 >;
 249 defm FLAT_ATOMIC_FMIN : FLAT_ATOMIC <
 250   flat<0x3f>, "flat_atomic_fmin", VGPR_32
 251 >;
 252 defm FLAT_ATOMIC_FMAX : FLAT_ATOMIC <
 253   flat<0x40>, "flat_atomic_fmax", VGPR_32
 254 >;
 255 defm FLAT_ATOMIC_FCMPSWAP_X2 : FLAT_ATOMIC <
 256   flat<0x5e>, "flat_atomic_fcmpswap_x2", VReg_64, VReg_128
 257 >;
 258 defm FLAT_ATOMIC_FMIN_X2 : FLAT_ATOMIC <
 259   flat<0x5f>, "flat_atomic_fmin_x2", VReg_64
 260 >;
 261 defm FLAT_ATOMIC_FMAX_X2 : FLAT_ATOMIC <
 262   flat<0x60>, "flat_atomic_fmax_x2", VReg_64
 263 >;
 264
 265 } // End let SubtargetPredicate = isCI, VIAssemblerPredicate = DisableInst
 266
 267 //===----------------------------------------------------------------------===//
 268 // Flat Patterns
 269 //===----------------------------------------------------------------------===//
 270
 271 let Predicates = [HasFlatAddressSpace] in {
 272
 273 class FLATLoad_Pattern <FLAT Instr_ADDR64, ValueType vt,
 274                              PatFrag flat_ld> :
 275   Pat <(vt (flat_ld i64:$ptr)),
 276        (Instr_ADDR64 $ptr, 0, 0, 0)
 277 >;
 278
 279 def : FLATLoad_Pattern <FLAT_LOAD_SBYTE, i32, sextloadi8_flat>;
 280 def : FLATLoad_Pattern <FLAT_LOAD_UBYTE, i32, az_extloadi8_flat>;
 281 def : FLATLoad_Pattern <FLAT_LOAD_SSHORT, i32, sextloadi16_flat>;
 282 def : FLATLoad_Pattern <FLAT_LOAD_USHORT, i32, az_extloadi16_flat>;
 283 def : FLATLoad_Pattern <FLAT_LOAD_DWORD, i32, flat_load>;
 284 def : FLATLoad_Pattern <FLAT_LOAD_DWORDX2, i64, flat_load>;
 285 def : FLATLoad_Pattern <FLAT_LOAD_DWORDX2, i64, az_extloadi32_flat>;
 286 def : FLATLoad_Pattern <FLAT_LOAD_DWORDX2, v2i32, flat_load>;
 287 def : FLATLoad_Pattern <FLAT_LOAD_DWORDX4, v4i32, flat_load>;
 288
 289 class FLATStore_Pattern <FLAT Instr, ValueType vt, PatFrag st> :
 290   Pat <(st vt:$value, i64:$ptr),
 291         (Instr $value, $ptr, 0, 0, 0)
 292   >;
 293
 294 def : FLATStore_Pattern <FLAT_STORE_BYTE, i32, truncstorei8_flat>;
 295 def : FLATStore_Pattern <FLAT_STORE_SHORT, i32, truncstorei16_flat>;
 296 def : FLATStore_Pattern <FLAT_STORE_DWORD, i32, flat_store>;
 297 def : FLATStore_Pattern <FLAT_STORE_DWORDX2, i64, flat_store>;
 298 def : FLATStore_Pattern <FLAT_STORE_DWORDX2, v2i32, flat_store>;
 299 def : FLATStore_Pattern <FLAT_STORE_DWORDX4, v4i32, flat_store>;
 300
 301 } // End HasFlatAddressSpace predicate
 302
 303 let Predicates = [isCI] in {
 304
 305 // Convert (x - floor(x)) to fract(x)
 306 def : Pat <
 307   (f32 (fsub (f32 (VOP3Mods f32:$x, i32:$mods)),
 308              (f32 (ffloor (f32 (VOP3Mods f32:$x, i32:$mods)))))),
 309   (V_FRACT_F32_e64 $mods, $x, DSTCLAMP.NONE, DSTOMOD.NONE)
 310 >;
 311
 312 // Convert (x + (-floor(x))) to fract(x)
 313 def : Pat <
 314   (f64 (fadd (f64 (VOP3Mods f64:$x, i32:$mods)),
 315              (f64 (fneg (f64 (ffloor (f64 (VOP3Mods f64:$x, i32:$mods)))))))),
 316   (V_FRACT_F64_e64 $mods, $x, DSTCLAMP.NONE, DSTOMOD.NONE)
 317 >;
 318
 319 } // End Predicates = [isCI]
 320
 321
 322 //===----------------------------------------------------------------------===//
 323 // Patterns to generate flat for global
 324 //===----------------------------------------------------------------------===//
 325
 326 def useFlatForGlobal : Predicate <
 327   "Subtarget->useFlatForGlobal() || "
 328   "Subtarget->getGeneration() >= AMDGPUSubtarget::VOLCANIC_ISLANDS">;
 329
 330 let Predicates = [useFlatForGlobal] in {
 331
 332 // 1. Offset as 20bit DWORD immediate
 333 def : Pat <
 334   (SIload_constant v4i32:$sbase, IMM20bit:$offset),
 335   (S_BUFFER_LOAD_DWORD_IMM $sbase, (as_i32imm $offset))
 336 >;
 337
 338 // Patterns for global loads with no offset
 339 class FlatLoadPat <FLAT inst, SDPatternOperator node, ValueType vt> : Pat <
 340   (vt (node i64:$addr)),
 341   (inst $addr, 0, 0, 0)
 342 >;
 343
 344 def : FlatLoadPat <FLAT_LOAD_UBYTE, az_extloadi8_global, i32>;
 345 def : FlatLoadPat <FLAT_LOAD_SBYTE, sextloadi8_global, i32>;
 346 def : FlatLoadPat <FLAT_LOAD_USHORT, az_extloadi16_global, i32>;
 347 def : FlatLoadPat <FLAT_LOAD_SSHORT, sextloadi16_global, i32>;
 348 def : FlatLoadPat <FLAT_LOAD_DWORD, global_load, i32>;
 349 def : FlatLoadPat <FLAT_LOAD_DWORDX2, global_load, v2i32>;
 350 def : FlatLoadPat <FLAT_LOAD_DWORDX4, global_load, v4i32>;
 351
 352 class FlatStorePat <FLAT inst, SDPatternOperator node, ValueType vt> : Pat <
 353   (node vt:$data, i64:$addr),
 354   (inst $data, $addr, 0, 0, 0)
 355 >;
 356
 357 def : FlatStorePat <FLAT_STORE_BYTE, truncstorei8_global, i32>;
 358 def : FlatStorePat <FLAT_STORE_SHORT, truncstorei16_global, i32>;
 359 def : FlatStorePat <FLAT_STORE_DWORD, global_store, i32>;
 360 def : FlatStorePat <FLAT_STORE_DWORDX2, global_store, v2i32>;
 361 def : FlatStorePat <FLAT_STORE_DWORDX4, global_store, v4i32>;
 362
 363 class FlatAtomicPat <FLAT inst, SDPatternOperator node, ValueType vt> : Pat <
 364   (vt (node i64:$addr, vt:$data)),
 365   (inst $addr, $data, 0, 0)
 366 >;
 367
 368 def : FlatAtomicPat <FLAT_ATOMIC_ADD_RTN, atomic_add_global, i32>;
 369 def : FlatAtomicPat <FLAT_ATOMIC_AND_RTN, atomic_and_global, i32>;
 370 def : FlatAtomicPat <FLAT_ATOMIC_SUB_RTN, atomic_sub_global, i32>;
 371 def : FlatAtomicPat <FLAT_ATOMIC_SMAX_RTN, atomic_max_global, i32>;
 372 def : FlatAtomicPat <FLAT_ATOMIC_UMAX_RTN, atomic_umax_global, i32>;
 373 def : FlatAtomicPat <FLAT_ATOMIC_SMIN_RTN, atomic_min_global, i32>;
 374 def : FlatAtomicPat <FLAT_ATOMIC_UMIN_RTN, atomic_umin_global, i32>;
 375 def : FlatAtomicPat <FLAT_ATOMIC_OR_RTN, atomic_or_global, i32>;
 376 def : FlatAtomicPat <FLAT_ATOMIC_SWAP_RTN, atomic_swap_global, i32>;
 377 def : FlatAtomicPat <FLAT_ATOMIC_XOR_RTN, atomic_xor_global, i32>;
 378
 379 } // End Predicates = [useFlatForGlobal]