contrib/llvm-project/llvm/lib/Target/AMDGPU/DSInstructions.td

   1 //===-- DSInstructions.td - DS Instruction Defintions ---------------------===//
   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 class DS_Pseudo <string opName, dag outs, dag ins, string asmOps, list<dag> pattern=[]> :
  10   InstSI <outs, ins, "", pattern>,
  11   SIMCInstr <opName, SIEncodingFamily.NONE> {
  12
  13   let LGKM_CNT = 1;
  14   let DS = 1;
  15   let Size = 8;
  16   let UseNamedOperandTable = 1;
  17
  18   // Most instruction load and store data, so set this as the default.
  19   let mayLoad = 1;
  20   let mayStore = 1;
  21   let maybeAtomic = 1;
  22
  23   let hasSideEffects = 0;
  24   let SchedRW = [WriteLDS];
  25
  26   let isPseudo = 1;
  27   let isCodeGenOnly = 1;
  28
  29   let AsmMatchConverter = "cvtDS";
  30
  31   string Mnemonic = opName;
  32   string AsmOperands = asmOps;
  33
  34   // Well these bits a kind of hack because it would be more natural
  35   // to test "outs" and "ins" dags for the presence of particular operands
  36   bits<1> has_vdst = 1;
  37   bits<1> has_addr = 1;
  38   bits<1> has_data0 = 1;
  39   bits<1> has_data1 = 1;
  40
  41   bits<1> has_gws_data0 = 0; // data0 is encoded as addr
  42
  43   bits<1> has_offset  = 1; // has "offset" that should be split to offset0,1
  44   bits<1> has_offset0 = 1;
  45   bits<1> has_offset1 = 1;
  46
  47   bits<1> has_gds = 1;
  48   bits<1> gdsValue = 0; // if has_gds == 0 set gds to this value
  49
  50   bits<1> has_m0_read = 1;
  51
  52   let Uses = !if(has_m0_read, [M0, EXEC], [EXEC]);
  53 }
  54
  55 class DS_Real <DS_Pseudo ds> :
  56   InstSI <ds.OutOperandList, ds.InOperandList, ds.Mnemonic # " " # ds.AsmOperands, []>,
  57   Enc64 {
  58
  59   let isPseudo = 0;
  60   let isCodeGenOnly = 0;
  61   let DS = 1;
  62   let UseNamedOperandTable = 1;
  63
  64   // copy relevant pseudo op flags
  65   let SubtargetPredicate = ds.SubtargetPredicate;
  66   let OtherPredicates = ds.OtherPredicates;
  67   let AsmMatchConverter  = ds.AsmMatchConverter;
  68
  69   // encoding fields
  70   bits<8> vdst;
  71   bits<1> gds;
  72   bits<8> addr;
  73   bits<8> data0;
  74   bits<8> data1;
  75   bits<8> offset0;
  76   bits<8> offset1;
  77
  78   bits<16> offset;
  79   let offset0 = !if(ds.has_offset, offset{7-0}, ?);
  80   let offset1 = !if(ds.has_offset, offset{15-8}, ?);
  81 }
  82
  83
  84 // DS Pseudo instructions
  85
  86 class DS_0A1D_NORET<string opName, RegisterClass rc = VGPR_32>
  87 : DS_Pseudo<opName,
  88   (outs),
  89   (ins rc:$data0, offset:$offset, gds:$gds),
  90   "$data0$offset$gds"> {
  91
  92   let has_addr = 0;
  93   let has_data1 = 0;
  94   let has_vdst = 0;
  95 }
  96
  97 class DS_1A1D_NORET<string opName, RegisterClass rc = VGPR_32>
  98 : DS_Pseudo<opName,
  99   (outs),
 100   (ins VGPR_32:$addr, rc:$data0, offset:$offset, gds:$gds),
 101   "$addr, $data0$offset$gds"> {
 102
 103   let has_data1 = 0;
 104   let has_vdst = 0;
 105 }
 106
 107 multiclass DS_1A1D_NORET_mc<string opName, RegisterClass rc = VGPR_32> {
 108   def "" : DS_1A1D_NORET<opName, rc>,
 109            AtomicNoRet<opName, 0>;
 110
 111   let has_m0_read = 0 in {
 112     def _gfx9 : DS_1A1D_NORET<opName, rc>,
 113                 AtomicNoRet<opName#"_gfx9", 0>;
 114   }
 115 }
 116
 117 class DS_1A2D_NORET<string opName, RegisterClass rc = VGPR_32>
 118 : DS_Pseudo<opName,
 119   (outs),
 120   (ins VGPR_32:$addr, rc:$data0, rc:$data1, offset:$offset, gds:$gds),
 121   "$addr, $data0, $data1"#"$offset"#"$gds"> {
 122
 123   let has_vdst = 0;
 124 }
 125
 126 multiclass DS_1A2D_NORET_mc<string opName, RegisterClass rc = VGPR_32> {
 127   def "" : DS_1A2D_NORET<opName, rc>,
 128            AtomicNoRet<opName, 0>;
 129
 130   let has_m0_read = 0 in {
 131     def _gfx9 : DS_1A2D_NORET<opName, rc>,
 132                 AtomicNoRet<opName#"_gfx9", 0>;
 133   }
 134 }
 135
 136 class DS_1A2D_Off8_NORET <string opName, RegisterClass rc = VGPR_32>
 137 : DS_Pseudo<opName,
 138   (outs),
 139   (ins VGPR_32:$addr, rc:$data0, rc:$data1,
 140        offset0:$offset0, offset1:$offset1, gds:$gds),
 141   "$addr, $data0, $data1$offset0$offset1$gds"> {
 142
 143   let has_vdst = 0;
 144   let has_offset = 0;
 145   let AsmMatchConverter = "cvtDSOffset01";
 146 }
 147
 148 multiclass DS_1A2D_Off8_NORET_mc <string opName, RegisterClass rc = VGPR_32> {
 149   def "" : DS_1A2D_Off8_NORET<opName, rc>;
 150
 151   let has_m0_read = 0 in {
 152     def _gfx9 : DS_1A2D_Off8_NORET<opName, rc>;
 153   }
 154 }
 155
 156 class DS_1A1D_RET <string opName, RegisterClass rc = VGPR_32>
 157 : DS_Pseudo<opName,
 158   (outs rc:$vdst),
 159   (ins VGPR_32:$addr, rc:$data0, offset:$offset, gds:$gds),
 160   "$vdst, $addr, $data0$offset$gds"> {
 161
 162   let hasPostISelHook = 1;
 163   let has_data1 = 0;
 164 }
 165
 166 multiclass DS_1A1D_RET_mc <string opName, RegisterClass rc = VGPR_32,
 167                            string NoRetOp = ""> {
 168   def "" : DS_1A1D_RET<opName, rc>,
 169     AtomicNoRet<NoRetOp, !if(!eq(NoRetOp, ""), 0, 1)>;
 170
 171   let has_m0_read = 0 in {
 172     def _gfx9 : DS_1A1D_RET<opName, rc>,
 173       AtomicNoRet<!if(!eq(NoRetOp, ""), "", NoRetOp#"_gfx9"),
 174                   !if(!eq(NoRetOp, ""), 0, 1)>;
 175   }
 176 }
 177
 178 class DS_1A2D_RET<string opName,
 179                   RegisterClass rc = VGPR_32,
 180                   RegisterClass src = rc>
 181 : DS_Pseudo<opName,
 182   (outs rc:$vdst),
 183   (ins VGPR_32:$addr, src:$data0, src:$data1, offset:$offset, gds:$gds),
 184   "$vdst, $addr, $data0, $data1$offset$gds"> {
 185
 186   let hasPostISelHook = 1;
 187 }
 188
 189 multiclass DS_1A2D_RET_mc<string opName,
 190                           RegisterClass rc = VGPR_32,
 191                           string NoRetOp = "",
 192                           RegisterClass src = rc> {
 193   def "" : DS_1A2D_RET<opName, rc, src>,
 194     AtomicNoRet<NoRetOp, !if(!eq(NoRetOp, ""), 0, 1)>;
 195
 196   let has_m0_read = 0 in {
 197     def _gfx9 : DS_1A2D_RET<opName, rc, src>,
 198       AtomicNoRet<NoRetOp#"_gfx9", !if(!eq(NoRetOp, ""), 0, 1)>;
 199   }
 200 }
 201
 202 class DS_1A2D_Off8_RET<string opName,
 203                        RegisterClass rc = VGPR_32,
 204                        RegisterClass src = rc>
 205 : DS_Pseudo<opName,
 206   (outs rc:$vdst),
 207   (ins VGPR_32:$addr, src:$data0, src:$data1, offset0:$offset0, offset1:$offset1, gds:$gds),
 208   "$vdst, $addr, $data0, $data1$offset0$offset1$gds"> {
 209
 210   let has_offset = 0;
 211   let AsmMatchConverter = "cvtDSOffset01";
 212
 213   let hasPostISelHook = 1;
 214 }
 215
 216 multiclass DS_1A2D_Off8_RET_mc<string opName,
 217                                RegisterClass rc = VGPR_32,
 218                                RegisterClass src = rc> {
 219   def "" : DS_1A2D_Off8_RET<opName, rc, src>;
 220
 221   let has_m0_read = 0 in {
 222     def _gfx9 : DS_1A2D_Off8_RET<opName, rc, src>;
 223   }
 224 }
 225
 226
 227 class DS_1A_RET<string opName, RegisterClass rc = VGPR_32, bit HasTiedOutput = 0, Operand ofs = offset>
 228 : DS_Pseudo<opName,
 229   (outs rc:$vdst),
 230   !if(HasTiedOutput,
 231     (ins VGPR_32:$addr, ofs:$offset, gds:$gds, rc:$vdst_in),
 232     (ins VGPR_32:$addr, ofs:$offset, gds:$gds)),
 233   "$vdst, $addr$offset$gds"> {
 234   let Constraints = !if(HasTiedOutput, "$vdst = $vdst_in", "");
 235   let DisableEncoding = !if(HasTiedOutput, "$vdst_in", "");
 236   let has_data0 = 0;
 237   let has_data1 = 0;
 238 }
 239
 240 multiclass DS_1A_RET_mc<string opName, RegisterClass rc = VGPR_32, bit HasTiedOutput = 0, Operand ofs = offset> {
 241   def "" : DS_1A_RET<opName, rc, HasTiedOutput, ofs>;
 242
 243   let has_m0_read = 0 in {
 244     def _gfx9 : DS_1A_RET<opName, rc, HasTiedOutput, ofs>;
 245   }
 246 }
 247
 248 class DS_1A_RET_Tied<string opName, RegisterClass rc = VGPR_32> :
 249   DS_1A_RET<opName, rc, 1>;
 250
 251 class DS_1A_Off8_RET <string opName, RegisterClass rc = VGPR_32>
 252 : DS_Pseudo<opName,
 253   (outs rc:$vdst),
 254   (ins VGPR_32:$addr, offset0:$offset0, offset1:$offset1, gds:$gds),
 255   "$vdst, $addr$offset0$offset1$gds"> {
 256
 257   let has_offset = 0;
 258   let has_data0 = 0;
 259   let has_data1 = 0;
 260   let AsmMatchConverter = "cvtDSOffset01";
 261 }
 262
 263 multiclass DS_1A_Off8_RET_mc <string opName, RegisterClass rc = VGPR_32> {
 264   def "" : DS_1A_Off8_RET<opName, rc>;
 265
 266   let has_m0_read = 0 in {
 267     def _gfx9 : DS_1A_Off8_RET<opName, rc>;
 268   }
 269 }
 270
 271 class DS_1A_RET_GDS <string opName> : DS_Pseudo<opName,
 272   (outs VGPR_32:$vdst),
 273   (ins VGPR_32:$addr, offset:$offset),
 274   "$vdst, $addr$offset gds"> {
 275
 276   let has_data0 = 0;
 277   let has_data1 = 0;
 278   let has_gds = 0;
 279   let gdsValue = 1;
 280   let AsmMatchConverter = "cvtDSGds";
 281 }
 282
 283 class DS_0A_RET <string opName> : DS_Pseudo<opName,
 284   (outs VGPR_32:$vdst),
 285   (ins offset:$offset, gds:$gds),
 286   "$vdst$offset$gds"> {
 287
 288   let mayLoad = 1;
 289   let mayStore = 1;
 290
 291   let has_addr = 0;
 292   let has_data0 = 0;
 293   let has_data1 = 0;
 294 }
 295
 296 class DS_1A <string opName> : DS_Pseudo<opName,
 297   (outs),
 298   (ins VGPR_32:$addr, offset:$offset, gds:$gds),
 299   "$addr$offset$gds"> {
 300
 301   let mayLoad = 1;
 302   let mayStore = 1;
 303
 304   let has_vdst = 0;
 305   let has_data0 = 0;
 306   let has_data1 = 0;
 307 }
 308
 309 multiclass DS_1A_mc <string opName> {
 310   def "" : DS_1A<opName>;
 311
 312   let has_m0_read = 0 in {
 313     def _gfx9 : DS_1A<opName>;
 314   }
 315 }
 316
 317
 318 class DS_GWS <string opName, dag ins, string asmOps>
 319 : DS_Pseudo<opName, (outs), ins, asmOps> {
 320
 321   let has_vdst  = 0;
 322   let has_addr  = 0;
 323   let has_data0 = 0;
 324   let has_data1 = 0;
 325
 326   let has_gds   = 0;
 327   let gdsValue  = 1;
 328   let AsmMatchConverter = "cvtDSGds";
 329 }
 330
 331 class DS_GWS_0D <string opName>
 332 : DS_GWS<opName,
 333   (ins offset:$offset, gds:$gds), "$offset gds"> {
 334   let hasSideEffects = 1;
 335 }
 336
 337 class DS_GWS_1D <string opName>
 338 : DS_GWS<opName,
 339   (ins VGPR_32:$data0, offset:$offset, gds:$gds), "$data0$offset gds"> {
 340
 341   let has_gws_data0 = 1;
 342   let hasSideEffects = 1;
 343 }
 344
 345 class DS_VOID <string opName> : DS_Pseudo<opName,
 346   (outs), (ins), ""> {
 347   let mayLoad = 0;
 348   let mayStore = 0;
 349   let hasSideEffects = 1;
 350   let UseNamedOperandTable = 0;
 351   let AsmMatchConverter = "";
 352
 353   let has_vdst = 0;
 354   let has_addr = 0;
 355   let has_data0 = 0;
 356   let has_data1 = 0;
 357   let has_offset = 0;
 358   let has_offset0 = 0;
 359   let has_offset1 = 0;
 360   let has_gds = 0;
 361 }
 362
 363 class DS_1A1D_PERMUTE <string opName, SDPatternOperator node = null_frag>
 364 : DS_Pseudo<opName,
 365   (outs VGPR_32:$vdst),
 366   (ins VGPR_32:$addr, VGPR_32:$data0, offset:$offset),
 367   "$vdst, $addr, $data0$offset",
 368   [(set i32:$vdst,
 369    (node (DS1Addr1Offset i32:$addr, i16:$offset), i32:$data0))] > {
 370
 371   let mayLoad = 0;
 372   let mayStore = 0;
 373   let isConvergent = 1;
 374
 375   let has_data1 = 0;
 376   let has_gds = 0;
 377 }
 378
 379 defm DS_ADD_U32       : DS_1A1D_NORET_mc<"ds_add_u32">;
 380 defm DS_SUB_U32       : DS_1A1D_NORET_mc<"ds_sub_u32">;
 381 defm DS_RSUB_U32      : DS_1A1D_NORET_mc<"ds_rsub_u32">;
 382 defm DS_INC_U32       : DS_1A1D_NORET_mc<"ds_inc_u32">;
 383 defm DS_DEC_U32       : DS_1A1D_NORET_mc<"ds_dec_u32">;
 384 defm DS_MIN_I32       : DS_1A1D_NORET_mc<"ds_min_i32">;
 385 defm DS_MAX_I32       : DS_1A1D_NORET_mc<"ds_max_i32">;
 386 defm DS_MIN_U32       : DS_1A1D_NORET_mc<"ds_min_u32">;
 387 defm DS_MAX_U32       : DS_1A1D_NORET_mc<"ds_max_u32">;
 388 defm DS_AND_B32       : DS_1A1D_NORET_mc<"ds_and_b32">;
 389 defm DS_OR_B32        : DS_1A1D_NORET_mc<"ds_or_b32">;
 390 defm DS_XOR_B32       : DS_1A1D_NORET_mc<"ds_xor_b32">;
 391 defm DS_ADD_F32       : DS_1A1D_NORET_mc<"ds_add_f32">;
 392 defm DS_MIN_F32       : DS_1A1D_NORET_mc<"ds_min_f32">;
 393 defm DS_MAX_F32       : DS_1A1D_NORET_mc<"ds_max_f32">;
 394
 395 let mayLoad = 0 in {
 396 defm DS_WRITE_B8      : DS_1A1D_NORET_mc<"ds_write_b8">;
 397 defm DS_WRITE_B16     : DS_1A1D_NORET_mc<"ds_write_b16">;
 398 defm DS_WRITE_B32     : DS_1A1D_NORET_mc<"ds_write_b32">;
 399 defm DS_WRITE2_B32    : DS_1A2D_Off8_NORET_mc<"ds_write2_b32">;
 400 defm DS_WRITE2ST64_B32: DS_1A2D_Off8_NORET_mc<"ds_write2st64_b32">;
 401
 402
 403 let has_m0_read = 0 in {
 404
 405 let SubtargetPredicate = HasD16LoadStore in {
 406 def DS_WRITE_B8_D16_HI  : DS_1A1D_NORET<"ds_write_b8_d16_hi">;
 407 def DS_WRITE_B16_D16_HI : DS_1A1D_NORET<"ds_write_b16_d16_hi">;
 408 }
 409
 410 } // End has_m0_read = 0
 411
 412 let SubtargetPredicate = HasDSAddTid in {
 413 def DS_WRITE_ADDTID_B32 : DS_0A1D_NORET<"ds_write_addtid_b32">;
 414 }
 415
 416 } // End mayLoad = 0
 417
 418 defm DS_MSKOR_B32     : DS_1A2D_NORET_mc<"ds_mskor_b32">;
 419 defm DS_CMPST_B32     : DS_1A2D_NORET_mc<"ds_cmpst_b32">;
 420 defm DS_CMPST_F32     : DS_1A2D_NORET_mc<"ds_cmpst_f32">;
 421
 422 defm DS_ADD_U64       : DS_1A1D_NORET_mc<"ds_add_u64", VReg_64>;
 423 defm DS_SUB_U64       : DS_1A1D_NORET_mc<"ds_sub_u64", VReg_64>;
 424 defm DS_RSUB_U64      : DS_1A1D_NORET_mc<"ds_rsub_u64", VReg_64>;
 425 defm DS_INC_U64       : DS_1A1D_NORET_mc<"ds_inc_u64", VReg_64>;
 426 defm DS_DEC_U64       : DS_1A1D_NORET_mc<"ds_dec_u64", VReg_64>;
 427 defm DS_MIN_I64       : DS_1A1D_NORET_mc<"ds_min_i64", VReg_64>;
 428 defm DS_MAX_I64       : DS_1A1D_NORET_mc<"ds_max_i64", VReg_64>;
 429 defm DS_MIN_U64       : DS_1A1D_NORET_mc<"ds_min_u64", VReg_64>;
 430 defm DS_MAX_U64       : DS_1A1D_NORET_mc<"ds_max_u64", VReg_64>;
 431 defm DS_AND_B64       : DS_1A1D_NORET_mc<"ds_and_b64", VReg_64>;
 432 defm DS_OR_B64        : DS_1A1D_NORET_mc<"ds_or_b64", VReg_64>;
 433 defm DS_XOR_B64       : DS_1A1D_NORET_mc<"ds_xor_b64", VReg_64>;
 434 defm DS_MSKOR_B64     : DS_1A2D_NORET_mc<"ds_mskor_b64", VReg_64>;
 435 let mayLoad = 0 in {
 436 defm DS_WRITE_B64     : DS_1A1D_NORET_mc<"ds_write_b64", VReg_64>;
 437 defm DS_WRITE2_B64    : DS_1A2D_Off8_NORET_mc<"ds_write2_b64", VReg_64>;
 438 defm DS_WRITE2ST64_B64: DS_1A2D_Off8_NORET_mc<"ds_write2st64_b64", VReg_64>;
 439 }
 440 defm DS_CMPST_B64     : DS_1A2D_NORET_mc<"ds_cmpst_b64", VReg_64>;
 441 defm DS_CMPST_F64     : DS_1A2D_NORET_mc<"ds_cmpst_f64", VReg_64>;
 442 defm DS_MIN_F64       : DS_1A1D_NORET_mc<"ds_min_f64", VReg_64>;
 443 defm DS_MAX_F64       : DS_1A1D_NORET_mc<"ds_max_f64", VReg_64>;
 444
 445 defm DS_ADD_RTN_U32   : DS_1A1D_RET_mc<"ds_add_rtn_u32", VGPR_32, "ds_add_u32">;
 446 defm DS_ADD_RTN_F32   : DS_1A1D_RET_mc<"ds_add_rtn_f32", VGPR_32, "ds_add_f32">;
 447 defm DS_SUB_RTN_U32   : DS_1A1D_RET_mc<"ds_sub_rtn_u32", VGPR_32, "ds_sub_u32">;
 448 defm DS_RSUB_RTN_U32  : DS_1A1D_RET_mc<"ds_rsub_rtn_u32", VGPR_32, "ds_rsub_u32">;
 449 defm DS_INC_RTN_U32   : DS_1A1D_RET_mc<"ds_inc_rtn_u32", VGPR_32, "ds_inc_u32">;
 450 defm DS_DEC_RTN_U32   : DS_1A1D_RET_mc<"ds_dec_rtn_u32", VGPR_32, "ds_dec_u32">;
 451 defm DS_MIN_RTN_I32   : DS_1A1D_RET_mc<"ds_min_rtn_i32", VGPR_32, "ds_min_i32">;
 452 defm DS_MAX_RTN_I32   : DS_1A1D_RET_mc<"ds_max_rtn_i32", VGPR_32, "ds_max_i32">;
 453 defm DS_MIN_RTN_U32   : DS_1A1D_RET_mc<"ds_min_rtn_u32", VGPR_32, "ds_min_u32">;
 454 defm DS_MAX_RTN_U32   : DS_1A1D_RET_mc<"ds_max_rtn_u32", VGPR_32, "ds_max_u32">;
 455 defm DS_AND_RTN_B32   : DS_1A1D_RET_mc<"ds_and_rtn_b32", VGPR_32, "ds_and_b32">;
 456 defm DS_OR_RTN_B32    : DS_1A1D_RET_mc<"ds_or_rtn_b32", VGPR_32, "ds_or_b32">;
 457 defm DS_XOR_RTN_B32   : DS_1A1D_RET_mc<"ds_xor_rtn_b32", VGPR_32, "ds_xor_b32">;
 458 defm DS_MSKOR_RTN_B32 : DS_1A2D_RET_mc<"ds_mskor_rtn_b32", VGPR_32, "ds_mskor_b32">;
 459 defm DS_CMPST_RTN_B32 : DS_1A2D_RET_mc<"ds_cmpst_rtn_b32", VGPR_32, "ds_cmpst_b32">;
 460 defm DS_CMPST_RTN_F32 : DS_1A2D_RET_mc<"ds_cmpst_rtn_f32", VGPR_32, "ds_cmpst_f32">;
 461 defm DS_MIN_RTN_F32   : DS_1A1D_RET_mc<"ds_min_rtn_f32", VGPR_32, "ds_min_f32">;
 462 defm DS_MAX_RTN_F32   : DS_1A1D_RET_mc<"ds_max_rtn_f32", VGPR_32, "ds_max_f32">;
 463
 464 defm DS_WRXCHG_RTN_B32 : DS_1A1D_RET_mc<"ds_wrxchg_rtn_b32">;
 465 defm DS_WRXCHG2_RTN_B32 : DS_1A2D_Off8_RET_mc<"ds_wrxchg2_rtn_b32", VReg_64, VGPR_32>;
 466 defm DS_WRXCHG2ST64_RTN_B32 : DS_1A2D_Off8_RET_mc<"ds_wrxchg2st64_rtn_b32", VReg_64, VGPR_32>;
 467
 468 defm DS_ADD_RTN_U64  : DS_1A1D_RET_mc<"ds_add_rtn_u64", VReg_64, "ds_add_u64">;
 469 defm DS_SUB_RTN_U64  : DS_1A1D_RET_mc<"ds_sub_rtn_u64", VReg_64, "ds_sub_u64">;
 470 defm DS_RSUB_RTN_U64  : DS_1A1D_RET_mc<"ds_rsub_rtn_u64", VReg_64, "ds_rsub_u64">;
 471 defm DS_INC_RTN_U64   : DS_1A1D_RET_mc<"ds_inc_rtn_u64", VReg_64, "ds_inc_u64">;
 472 defm DS_DEC_RTN_U64   : DS_1A1D_RET_mc<"ds_dec_rtn_u64", VReg_64, "ds_dec_u64">;
 473 defm DS_MIN_RTN_I64    : DS_1A1D_RET_mc<"ds_min_rtn_i64", VReg_64, "ds_min_i64">;
 474 defm DS_MAX_RTN_I64    : DS_1A1D_RET_mc<"ds_max_rtn_i64", VReg_64, "ds_max_i64">;
 475 defm DS_MIN_RTN_U64   : DS_1A1D_RET_mc<"ds_min_rtn_u64", VReg_64, "ds_min_u64">;
 476 defm DS_MAX_RTN_U64   : DS_1A1D_RET_mc<"ds_max_rtn_u64", VReg_64, "ds_max_u64">;
 477 defm DS_AND_RTN_B64    : DS_1A1D_RET_mc<"ds_and_rtn_b64", VReg_64, "ds_and_b64">;
 478 defm DS_OR_RTN_B64     : DS_1A1D_RET_mc<"ds_or_rtn_b64", VReg_64, "ds_or_b64">;
 479 defm DS_XOR_RTN_B64    : DS_1A1D_RET_mc<"ds_xor_rtn_b64", VReg_64, "ds_xor_b64">;
 480 defm DS_MSKOR_RTN_B64  : DS_1A2D_RET_mc<"ds_mskor_rtn_b64", VReg_64, "ds_mskor_b64">;
 481 defm DS_CMPST_RTN_B64  : DS_1A2D_RET_mc<"ds_cmpst_rtn_b64", VReg_64, "ds_cmpst_b64">;
 482 defm DS_CMPST_RTN_F64  : DS_1A2D_RET_mc<"ds_cmpst_rtn_f64", VReg_64, "ds_cmpst_f64">;
 483 defm DS_MIN_RTN_F64    : DS_1A1D_RET_mc<"ds_min_rtn_f64", VReg_64, "ds_min_f64">;
 484 defm DS_MAX_RTN_F64    : DS_1A1D_RET_mc<"ds_max_rtn_f64", VReg_64, "ds_max_f64">;
 485
 486 defm DS_WRXCHG_RTN_B64 : DS_1A1D_RET_mc<"ds_wrxchg_rtn_b64", VReg_64>;
 487 defm DS_WRXCHG2_RTN_B64 : DS_1A2D_Off8_RET_mc<"ds_wrxchg2_rtn_b64", VReg_128, VReg_64>;
 488 defm DS_WRXCHG2ST64_RTN_B64 : DS_1A2D_Off8_RET_mc<"ds_wrxchg2st64_rtn_b64", VReg_128, VReg_64>;
 489
 490 let isConvergent = 1, usesCustomInserter = 1 in {
 491 def DS_GWS_INIT       : DS_GWS_1D<"ds_gws_init"> {
 492   let mayLoad = 0;
 493 }
 494 def DS_GWS_SEMA_V     : DS_GWS_0D<"ds_gws_sema_v">;
 495 def DS_GWS_SEMA_BR    : DS_GWS_1D<"ds_gws_sema_br">;
 496 def DS_GWS_SEMA_P     : DS_GWS_0D<"ds_gws_sema_p">;
 497 def DS_GWS_BARRIER    : DS_GWS_1D<"ds_gws_barrier">;
 498 }
 499
 500 def DS_ADD_SRC2_U32   : DS_1A<"ds_add_src2_u32">;
 501 def DS_SUB_SRC2_U32   : DS_1A<"ds_sub_src2_u32">;
 502 def DS_RSUB_SRC2_U32  : DS_1A<"ds_rsub_src2_u32">;
 503 def DS_INC_SRC2_U32   : DS_1A<"ds_inc_src2_u32">;
 504 def DS_DEC_SRC2_U32   : DS_1A<"ds_dec_src2_u32">;
 505 def DS_MIN_SRC2_I32   : DS_1A<"ds_min_src2_i32">;
 506 def DS_MAX_SRC2_I32   : DS_1A<"ds_max_src2_i32">;
 507 def DS_MIN_SRC2_U32   : DS_1A<"ds_min_src2_u32">;
 508 def DS_MAX_SRC2_U32   : DS_1A<"ds_max_src2_u32">;
 509 def DS_AND_SRC2_B32   : DS_1A<"ds_and_src2_b32">;
 510 def DS_OR_SRC2_B32    : DS_1A<"ds_or_src2_b32">;
 511 def DS_XOR_SRC2_B32   : DS_1A<"ds_xor_src2_b32">;
 512 def DS_MIN_SRC2_F32   : DS_1A<"ds_min_src2_f32">;
 513 def DS_MAX_SRC2_F32   : DS_1A<"ds_max_src2_f32">;
 514
 515 def DS_ADD_SRC2_U64   : DS_1A<"ds_add_src2_u64">;
 516 def DS_SUB_SRC2_U64   : DS_1A<"ds_sub_src2_u64">;
 517 def DS_RSUB_SRC2_U64  : DS_1A<"ds_rsub_src2_u64">;
 518 def DS_INC_SRC2_U64   : DS_1A<"ds_inc_src2_u64">;
 519 def DS_DEC_SRC2_U64   : DS_1A<"ds_dec_src2_u64">;
 520 def DS_MIN_SRC2_I64   : DS_1A<"ds_min_src2_i64">;
 521 def DS_MAX_SRC2_I64   : DS_1A<"ds_max_src2_i64">;
 522 def DS_MIN_SRC2_U64   : DS_1A<"ds_min_src2_u64">;
 523 def DS_MAX_SRC2_U64   : DS_1A<"ds_max_src2_u64">;
 524 def DS_AND_SRC2_B64   : DS_1A<"ds_and_src2_b64">;
 525 def DS_OR_SRC2_B64    : DS_1A<"ds_or_src2_b64">;
 526 def DS_XOR_SRC2_B64   : DS_1A<"ds_xor_src2_b64">;
 527 def DS_MIN_SRC2_F64   : DS_1A<"ds_min_src2_f64">;
 528 def DS_MAX_SRC2_F64   : DS_1A<"ds_max_src2_f64">;
 529
 530 def DS_WRITE_SRC2_B32 : DS_1A<"ds_write_src2_b32">;
 531 def DS_WRITE_SRC2_B64 : DS_1A<"ds_write_src2_b64">;
 532
 533 let Uses = [EXEC], mayLoad = 0, mayStore = 0, isConvergent = 1 in {
 534 def DS_SWIZZLE_B32 : DS_1A_RET <"ds_swizzle_b32", VGPR_32, 0, SwizzleImm>;
 535 }
 536
 537 let mayStore = 0 in {
 538 defm DS_READ_I8      : DS_1A_RET_mc<"ds_read_i8">;
 539 defm DS_READ_U8      : DS_1A_RET_mc<"ds_read_u8">;
 540 defm DS_READ_I16     : DS_1A_RET_mc<"ds_read_i16">;
 541 defm DS_READ_U16     : DS_1A_RET_mc<"ds_read_u16">;
 542 defm DS_READ_B32     : DS_1A_RET_mc<"ds_read_b32">;
 543 defm DS_READ_B64     : DS_1A_RET_mc<"ds_read_b64", VReg_64>;
 544
 545 defm DS_READ2_B32    : DS_1A_Off8_RET_mc<"ds_read2_b32", VReg_64>;
 546 defm DS_READ2ST64_B32: DS_1A_Off8_RET_mc<"ds_read2st64_b32", VReg_64>;
 547
 548 defm DS_READ2_B64    : DS_1A_Off8_RET_mc<"ds_read2_b64", VReg_128>;
 549 defm DS_READ2ST64_B64: DS_1A_Off8_RET_mc<"ds_read2st64_b64", VReg_128>;
 550
 551 let has_m0_read = 0 in {
 552 let SubtargetPredicate = HasD16LoadStore in {
 553 def DS_READ_U8_D16     : DS_1A_RET_Tied<"ds_read_u8_d16">;
 554 def DS_READ_U8_D16_HI  : DS_1A_RET_Tied<"ds_read_u8_d16_hi">;
 555 def DS_READ_I8_D16     : DS_1A_RET_Tied<"ds_read_i8_d16">;
 556 def DS_READ_I8_D16_HI  : DS_1A_RET_Tied<"ds_read_i8_d16_hi">;
 557 def DS_READ_U16_D16    : DS_1A_RET_Tied<"ds_read_u16_d16">;
 558 def DS_READ_U16_D16_HI : DS_1A_RET_Tied<"ds_read_u16_d16_hi">;
 559 }
 560 } // End has_m0_read = 0
 561
 562 let SubtargetPredicate = HasDSAddTid in {
 563 def DS_READ_ADDTID_B32 : DS_0A_RET<"ds_read_addtid_b32">;
 564 }
 565
 566 } // End mayStore = 0
 567
 568 def DS_CONSUME       : DS_0A_RET<"ds_consume">;
 569 def DS_APPEND        : DS_0A_RET<"ds_append">;
 570 def DS_ORDERED_COUNT : DS_1A_RET_GDS<"ds_ordered_count">;
 571
 572 //===----------------------------------------------------------------------===//
 573 // Instruction definitions for CI and newer.
 574 //===----------------------------------------------------------------------===//
 575
 576 let SubtargetPredicate = isGFX7Plus in {
 577
 578 defm DS_WRAP_RTN_B32 : DS_1A2D_RET_mc<"ds_wrap_rtn_b32", VGPR_32>;
 579 defm DS_CONDXCHG32_RTN_B64 : DS_1A1D_RET_mc<"ds_condxchg32_rtn_b64", VReg_64>;
 580
 581 let isConvergent = 1, usesCustomInserter = 1 in {
 582 def DS_GWS_SEMA_RELEASE_ALL : DS_GWS_0D<"ds_gws_sema_release_all">;
 583 }
 584
 585 let mayStore = 0 in {
 586 defm DS_READ_B96 : DS_1A_RET_mc<"ds_read_b96", VReg_96>;
 587 defm DS_READ_B128: DS_1A_RET_mc<"ds_read_b128", VReg_128>;
 588 } // End mayStore = 0
 589
 590 let mayLoad = 0 in {
 591 defm DS_WRITE_B96 : DS_1A1D_NORET_mc<"ds_write_b96", VReg_96>;
 592 defm DS_WRITE_B128 : DS_1A1D_NORET_mc<"ds_write_b128", VReg_128>;
 593 } // End mayLoad = 0
 594
 595 def DS_NOP : DS_VOID<"ds_nop">;
 596
 597 } // let SubtargetPredicate = isGFX7Plus
 598
 599 //===----------------------------------------------------------------------===//
 600 // Instruction definitions for VI and newer.
 601 //===----------------------------------------------------------------------===//
 602
 603 let SubtargetPredicate = isGFX8Plus in {
 604
 605 let Uses = [EXEC] in {
 606 def DS_PERMUTE_B32  : DS_1A1D_PERMUTE <"ds_permute_b32",
 607                                        int_amdgcn_ds_permute>;
 608 def DS_BPERMUTE_B32 : DS_1A1D_PERMUTE <"ds_bpermute_b32",
 609                                        int_amdgcn_ds_bpermute>;
 610 }
 611
 612 def DS_ADD_SRC2_F32 : DS_1A<"ds_add_src2_f32">;
 613
 614 } // let SubtargetPredicate = isGFX8Plus
 615
 616 //===----------------------------------------------------------------------===//
 617 // DS Patterns
 618 //===----------------------------------------------------------------------===//
 619
 620 def : GCNPat <
 621   (int_amdgcn_ds_swizzle i32:$src, timm:$offset16),
 622   (DS_SWIZZLE_B32 VGPR_32:$src, (as_i16timm $offset16), (i1 0))
 623 >;
 624
 625 class DSReadPat <DS_Pseudo inst, ValueType vt, PatFrag frag, int gds=0> : GCNPat <
 626   (vt (frag (DS1Addr1Offset i32:$ptr, i16:$offset))),
 627   (inst $ptr, offset:$offset, (i1 gds))
 628 >;
 629
 630 multiclass DSReadPat_mc<DS_Pseudo inst, ValueType vt, string frag> {
 631
 632   let OtherPredicates = [LDSRequiresM0Init] in {
 633     def : DSReadPat<inst, vt, !cast<PatFrag>(frag#"_m0")>;
 634   }
 635
 636   let OtherPredicates = [NotLDSRequiresM0Init] in {
 637     def : DSReadPat<!cast<DS_Pseudo>(!cast<string>(inst)#"_gfx9"), vt, !cast<PatFrag>(frag)>;
 638   }
 639 }
 640
 641 class DSReadPat_D16 <DS_Pseudo inst, PatFrag frag, ValueType vt> : GCNPat <
 642   (frag (DS1Addr1Offset i32:$ptr, i16:$offset), vt:$in),
 643   (inst $ptr, offset:$offset, (i1 0), $in)
 644 >;
 645
 646 defm : DSReadPat_mc <DS_READ_I8, i32, "sextloadi8_local">;
 647 defm : DSReadPat_mc <DS_READ_I8,  i16, "sextloadi8_local">;
 648 defm : DSReadPat_mc <DS_READ_U8,  i32, "extloadi8_local">;
 649 defm : DSReadPat_mc <DS_READ_U8,  i32, "zextloadi8_local">;
 650 defm : DSReadPat_mc <DS_READ_U8,  i16, "extloadi8_local">;
 651 defm : DSReadPat_mc <DS_READ_U8,  i16, "zextloadi8_local">;
 652 defm : DSReadPat_mc <DS_READ_I16, i32, "sextloadi16_local">;
 653 defm : DSReadPat_mc <DS_READ_I16, i32, "sextloadi16_local">;
 654 defm : DSReadPat_mc <DS_READ_U16, i32, "extloadi16_local">;
 655 defm : DSReadPat_mc <DS_READ_U16, i32, "zextloadi16_local">;
 656 defm : DSReadPat_mc <DS_READ_U16, i16, "load_local">;
 657
 658 foreach vt = Reg32Types.types in {
 659 defm : DSReadPat_mc <DS_READ_B32, vt, "load_local">;
 660 }
 661
 662 defm : DSReadPat_mc <DS_READ_B32, i32, "atomic_load_32_local">;
 663 defm : DSReadPat_mc <DS_READ_B64, i64, "atomic_load_64_local">;
 664
 665 let AddedComplexity = 100 in {
 666
 667 foreach vt = VReg_64.RegTypes in {
 668 defm : DSReadPat_mc <DS_READ_B64, vt, "load_align8_local">;
 669 }
 670
 671 defm : DSReadPat_mc <DS_READ_B128, v4i32, "load_align16_local">;
 672
 673 } // End AddedComplexity = 100
 674
 675 let OtherPredicates = [D16PreservesUnusedBits] in {
 676 def : DSReadPat_D16<DS_READ_U16_D16_HI, load_d16_hi_local, v2i16>;
 677 def : DSReadPat_D16<DS_READ_U16_D16_HI, load_d16_hi_local, v2f16>;
 678 def : DSReadPat_D16<DS_READ_U8_D16_HI, az_extloadi8_d16_hi_local, v2i16>;
 679 def : DSReadPat_D16<DS_READ_U8_D16_HI, az_extloadi8_d16_hi_local, v2f16>;
 680 def : DSReadPat_D16<DS_READ_I8_D16_HI, sextloadi8_d16_hi_local, v2i16>;
 681 def : DSReadPat_D16<DS_READ_I8_D16_HI, sextloadi8_d16_hi_local, v2f16>;
 682
 683 def : DSReadPat_D16<DS_READ_U16_D16, load_d16_lo_local, v2i16>;
 684 def : DSReadPat_D16<DS_READ_U16_D16, load_d16_lo_local, v2f16>;
 685 def : DSReadPat_D16<DS_READ_U8_D16, az_extloadi8_d16_lo_local, v2i16>;
 686 def : DSReadPat_D16<DS_READ_U8_D16, az_extloadi8_d16_lo_local, v2f16>;
 687 def : DSReadPat_D16<DS_READ_I8_D16, sextloadi8_d16_lo_local, v2i16>;
 688 def : DSReadPat_D16<DS_READ_I8_D16, sextloadi8_d16_lo_local, v2f16>;
 689 }
 690
 691 class DSWritePat <DS_Pseudo inst, ValueType vt, PatFrag frag, int gds=0> : GCNPat <
 692   (frag vt:$value, (DS1Addr1Offset i32:$ptr, i16:$offset)),
 693   (inst $ptr, getVregSrcForVT<vt>.ret:$value, offset:$offset, (i1 gds))
 694 >;
 695
 696 multiclass DSWritePat_mc <DS_Pseudo inst, ValueType vt, string frag> {
 697   let OtherPredicates = [LDSRequiresM0Init] in {
 698     def : DSWritePat<inst, vt, !cast<PatFrag>(frag#"_m0")>;
 699   }
 700
 701   let OtherPredicates = [NotLDSRequiresM0Init] in {
 702     def : DSWritePat<!cast<DS_Pseudo>(!cast<string>(inst)#"_gfx9"), vt, !cast<PatFrag>(frag)>;
 703   }
 704 }
 705
 706 // Irritatingly, atomic_store reverses the order of operands from a
 707 // normal store.
 708 class DSAtomicWritePat <DS_Pseudo inst, ValueType vt, PatFrag frag> : GCNPat <
 709   (frag (DS1Addr1Offset i32:$ptr, i16:$offset), vt:$value),
 710   (inst $ptr, $value, offset:$offset, (i1 0))
 711 >;
 712
 713 multiclass DSAtomicWritePat_mc <DS_Pseudo inst, ValueType vt, string frag> {
 714   let OtherPredicates = [LDSRequiresM0Init] in {
 715     def : DSAtomicWritePat<inst, vt, !cast<PatFrag>(frag#"_m0")>;
 716   }
 717
 718   let OtherPredicates = [NotLDSRequiresM0Init] in {
 719     def : DSAtomicWritePat<!cast<DS_Pseudo>(!cast<string>(inst)#"_gfx9"), vt, !cast<PatFrag>(frag)>;
 720   }
 721 }
 722
 723 defm : DSWritePat_mc <DS_WRITE_B8, i32, "truncstorei8_local">;
 724 defm : DSWritePat_mc <DS_WRITE_B16, i32, "truncstorei16_local">;
 725 defm : DSWritePat_mc <DS_WRITE_B8, i16, "truncstorei8_local">;
 726 defm : DSWritePat_mc <DS_WRITE_B16, i16, "store_local">;
 727
 728 foreach vt = VGPR_32.RegTypes in {
 729 defm : DSWritePat_mc <DS_WRITE_B32, vt, "store_local">;
 730 }
 731
 732 defm : DSAtomicWritePat_mc <DS_WRITE_B32, i32, "atomic_store_local_32">;
 733 defm : DSAtomicWritePat_mc <DS_WRITE_B64, i64, "atomic_store_local_64">;
 734
 735 let OtherPredicates = [D16PreservesUnusedBits] in {
 736 def : DSWritePat <DS_WRITE_B16_D16_HI, i32, store_hi16_local>;
 737 def : DSWritePat <DS_WRITE_B8_D16_HI, i32, truncstorei8_hi16_local>;
 738 }
 739
 740
 741 class DS64Bit4ByteAlignedReadPat<DS_Pseudo inst, PatFrag frag> : GCNPat <
 742   (v2i32 (frag (DS64Bit4ByteAligned i32:$ptr, i8:$offset0, i8:$offset1))),
 743   (inst $ptr, $offset0, $offset1, (i1 0))
 744 >;
 745
 746 class DS64Bit4ByteAlignedWritePat<DS_Pseudo inst, PatFrag frag> : GCNPat<
 747   (frag v2i32:$value, (DS64Bit4ByteAligned i32:$ptr, i8:$offset0, i8:$offset1)),
 748   (inst $ptr, (i32 (EXTRACT_SUBREG $value, sub0)),
 749               (i32 (EXTRACT_SUBREG $value, sub1)), $offset0, $offset1,
 750               (i1 0))
 751 >;
 752
 753 // v2i32 loads are split into i32 loads on SI during lowering, due to a bug
 754 // related to bounds checking.
 755 let OtherPredicates = [LDSRequiresM0Init, isGFX7Plus] in {
 756 def : DS64Bit4ByteAlignedReadPat<DS_READ2_B32, load_local_m0>;
 757 def : DS64Bit4ByteAlignedWritePat<DS_WRITE2_B32, store_local_m0>;
 758 }
 759
 760 let OtherPredicates = [NotLDSRequiresM0Init] in {
 761 def : DS64Bit4ByteAlignedReadPat<DS_READ2_B32_gfx9, load_local>;
 762 def : DS64Bit4ByteAlignedWritePat<DS_WRITE2_B32_gfx9, store_local>;
 763 }
 764
 765
 766 let AddedComplexity = 100 in {
 767
 768 foreach vt = VReg_64.RegTypes in {
 769 defm : DSWritePat_mc <DS_WRITE_B64, vt, "store_align8_local">;
 770 }
 771
 772 defm : DSWritePat_mc <DS_WRITE_B128, v4i32, "store_align16_local">;
 773
 774 } // End AddedComplexity = 100
 775 class DSAtomicRetPat<DS_Pseudo inst, ValueType vt, PatFrag frag, bit gds=0> : GCNPat <
 776   (frag (DS1Addr1Offset i32:$ptr, i16:$offset), vt:$value),
 777   (inst $ptr, getVregSrcForVT<vt>.ret:$value, offset:$offset, (i1 gds))
 778 >;
 779
 780 multiclass DSAtomicRetPat_mc<DS_Pseudo inst, ValueType vt, string frag> {
 781   let OtherPredicates = [LDSRequiresM0Init] in {
 782     def : DSAtomicRetPat<inst, vt, !cast<PatFrag>(frag#"_local_m0_"#vt.Size)>;
 783   }
 784
 785   let OtherPredicates = [NotLDSRequiresM0Init] in {
 786     def : DSAtomicRetPat<!cast<DS_Pseudo>(!cast<string>(inst)#"_gfx9"), vt,
 787                          !cast<PatFrag>(frag#"_local_"#vt.Size)>;
 788   }
 789
 790   def : DSAtomicRetPat<inst, vt, !cast<PatFrag>(frag#"_region_m0_"#vt.Size), 1>;
 791 }
 792
 793
 794
 795 class DSAtomicCmpXChg<DS_Pseudo inst, ValueType vt, PatFrag frag, bit gds=0> : GCNPat <
 796   (frag (DS1Addr1Offset i32:$ptr, i16:$offset), vt:$cmp, vt:$swap),
 797   (inst $ptr, getVregSrcForVT<vt>.ret:$cmp, getVregSrcForVT<vt>.ret:$swap, offset:$offset, (i1 gds))
 798 >;
 799
 800 multiclass DSAtomicCmpXChg_mc<DS_Pseudo inst, ValueType vt, string frag> {
 801   let OtherPredicates = [LDSRequiresM0Init] in {
 802     def : DSAtomicCmpXChg<inst, vt, !cast<PatFrag>(frag#"_local_m0_"#vt.Size)>;
 803   }
 804
 805   let OtherPredicates = [NotLDSRequiresM0Init] in {
 806     def : DSAtomicCmpXChg<!cast<DS_Pseudo>(!cast<string>(inst)#"_gfx9"), vt,
 807                           !cast<PatFrag>(frag#"_local_"#vt.Size)>;
 808   }
 809
 810   def : DSAtomicCmpXChg<inst, vt, !cast<PatFrag>(frag#"_region_m0_"#vt.Size), 1>;
 811 }
 812
 813
 814
 815 // 32-bit atomics.
 816 defm : DSAtomicRetPat_mc<DS_WRXCHG_RTN_B32, i32, "atomic_swap">;
 817 defm : DSAtomicRetPat_mc<DS_ADD_RTN_U32, i32, "atomic_load_add">;
 818 defm : DSAtomicRetPat_mc<DS_SUB_RTN_U32, i32, "atomic_load_sub">;
 819 defm : DSAtomicRetPat_mc<DS_INC_RTN_U32, i32, "atomic_inc">;
 820 defm : DSAtomicRetPat_mc<DS_DEC_RTN_U32, i32, "atomic_dec">;
 821 defm : DSAtomicRetPat_mc<DS_AND_RTN_B32, i32, "atomic_load_and">;
 822 defm : DSAtomicRetPat_mc<DS_OR_RTN_B32, i32, "atomic_load_or">;
 823 defm : DSAtomicRetPat_mc<DS_XOR_RTN_B32, i32, "atomic_load_xor">;
 824 defm : DSAtomicRetPat_mc<DS_MIN_RTN_I32, i32, "atomic_load_min">;
 825 defm : DSAtomicRetPat_mc<DS_MAX_RTN_I32, i32, "atomic_load_max">;
 826 defm : DSAtomicRetPat_mc<DS_MIN_RTN_U32, i32, "atomic_load_umin">;
 827 defm : DSAtomicRetPat_mc<DS_MAX_RTN_U32, i32, "atomic_load_umax">;
 828 defm : DSAtomicCmpXChg_mc<DS_CMPST_RTN_B32, i32, "atomic_cmp_swap">;
 829 defm : DSAtomicRetPat_mc<DS_MIN_RTN_F32, f32, "atomic_load_fmin">;
 830 defm : DSAtomicRetPat_mc<DS_MAX_RTN_F32, f32, "atomic_load_fmax">;
 831 defm : DSAtomicRetPat_mc<DS_ADD_RTN_F32, f32, "atomic_load_fadd">;
 832
 833 // 64-bit atomics.
 834 defm : DSAtomicRetPat_mc<DS_WRXCHG_RTN_B64, i64, "atomic_swap">;
 835 defm : DSAtomicRetPat_mc<DS_ADD_RTN_U64, i64, "atomic_load_add">;
 836 defm : DSAtomicRetPat_mc<DS_SUB_RTN_U64, i64, "atomic_load_sub">;
 837 defm : DSAtomicRetPat_mc<DS_INC_RTN_U64, i64, "atomic_inc">;
 838 defm : DSAtomicRetPat_mc<DS_DEC_RTN_U64, i64, "atomic_dec">;
 839 defm : DSAtomicRetPat_mc<DS_AND_RTN_B64, i64, "atomic_load_and">;
 840 defm : DSAtomicRetPat_mc<DS_OR_RTN_B64, i64, "atomic_load_or">;
 841 defm : DSAtomicRetPat_mc<DS_XOR_RTN_B64, i64, "atomic_load_xor">;
 842 defm : DSAtomicRetPat_mc<DS_MIN_RTN_I64, i64, "atomic_load_min">;
 843 defm : DSAtomicRetPat_mc<DS_MAX_RTN_I64, i64, "atomic_load_max">;
 844 defm : DSAtomicRetPat_mc<DS_MIN_RTN_U64, i64, "atomic_load_umin">;
 845 defm : DSAtomicRetPat_mc<DS_MAX_RTN_U64, i64, "atomic_load_umax">;
 846
 847 defm : DSAtomicCmpXChg_mc<DS_CMPST_RTN_B64, i64, "atomic_cmp_swap">;
 848
 849 def : Pat <
 850   (SIds_ordered_count i32:$value, i16:$offset),
 851   (DS_ORDERED_COUNT $value, (as_i16imm $offset))
 852 >;
 853
 854 //===----------------------------------------------------------------------===//
 855 // Target-specific instruction encodings.
 856 //===----------------------------------------------------------------------===//
 857
 858 //===----------------------------------------------------------------------===//
 859 // Base ENC_DS for GFX6, GFX7, GFX10.
 860 //===----------------------------------------------------------------------===//
 861
 862 class Base_DS_Real_gfx6_gfx7_gfx10<bits<8> op, DS_Pseudo ps, int ef> :
 863     DS_Real<ps>, SIMCInstr <ps.Mnemonic, ef> {
 864
 865   let Inst{7-0}   = !if(ps.has_offset0, offset0, 0);
 866   let Inst{15-8}  = !if(ps.has_offset1, offset1, 0);
 867   let Inst{17}    = !if(ps.has_gds, gds, ps.gdsValue);
 868   let Inst{25-18} = op;
 869   let Inst{31-26} = 0x36;
 870   let Inst{39-32} = !if(ps.has_addr, addr, !if(ps.has_gws_data0, data0, 0));
 871   let Inst{47-40} = !if(ps.has_data0, data0, 0);
 872   let Inst{55-48} = !if(ps.has_data1, data1, 0);
 873   let Inst{63-56} = !if(ps.has_vdst, vdst, 0);
 874 }
 875
 876 //===----------------------------------------------------------------------===//
 877 // GFX10.
 878 //===----------------------------------------------------------------------===//
 879
 880 let AssemblerPredicate = isGFX10Plus, DecoderNamespace = "GFX10" in {
 881   multiclass DS_Real_gfx10<bits<8> op>  {
 882     def _gfx10 : Base_DS_Real_gfx6_gfx7_gfx10<op, !cast<DS_Pseudo>(NAME),
 883                                               SIEncodingFamily.GFX10>;
 884   }
 885 } // End AssemblerPredicate = isGFX10Plus, DecoderNamespace = "GFX10"
 886
 887 defm DS_ADD_F32          : DS_Real_gfx10<0x015>;
 888 defm DS_ADD_RTN_F32      : DS_Real_gfx10<0x055>;
 889 defm DS_ADD_SRC2_F32     : DS_Real_gfx10<0x095>;
 890 defm DS_WRITE_B8_D16_HI  : DS_Real_gfx10<0x0a0>;
 891 defm DS_WRITE_B16_D16_HI : DS_Real_gfx10<0x0a1>;
 892 defm DS_READ_U8_D16      : DS_Real_gfx10<0x0a2>;
 893 defm DS_READ_U8_D16_HI   : DS_Real_gfx10<0x0a3>;
 894 defm DS_READ_I8_D16      : DS_Real_gfx10<0x0a4>;
 895 defm DS_READ_I8_D16_HI   : DS_Real_gfx10<0x0a5>;
 896 defm DS_READ_U16_D16     : DS_Real_gfx10<0x0a6>;
 897 defm DS_READ_U16_D16_HI  : DS_Real_gfx10<0x0a7>;
 898 defm DS_WRITE_ADDTID_B32 : DS_Real_gfx10<0x0b0>;
 899 defm DS_READ_ADDTID_B32  : DS_Real_gfx10<0x0b1>;
 900 defm DS_PERMUTE_B32      : DS_Real_gfx10<0x0b2>;
 901 defm DS_BPERMUTE_B32     : DS_Real_gfx10<0x0b3>;
 902
 903 //===----------------------------------------------------------------------===//
 904 // GFX7, GFX10.
 905 //===----------------------------------------------------------------------===//
 906
 907 let AssemblerPredicate = isGFX7Only, DecoderNamespace = "GFX7" in {
 908   multiclass DS_Real_gfx7<bits<8> op> {
 909     def _gfx7 : Base_DS_Real_gfx6_gfx7_gfx10<op, !cast<DS_Pseudo>(NAME),
 910                                              SIEncodingFamily.SI>;
 911   }
 912 } // End AssemblerPredicate = isGFX7Only, DecoderNamespace = "GFX7"
 913
 914 multiclass DS_Real_gfx7_gfx10<bits<8> op> :
 915   DS_Real_gfx7<op>, DS_Real_gfx10<op>;
 916
 917 // FIXME-GFX7: Add tests when upstreaming this part.
 918 defm DS_GWS_SEMA_RELEASE_ALL : DS_Real_gfx7_gfx10<0x018>;
 919 defm DS_WRAP_RTN_B32         : DS_Real_gfx7_gfx10<0x034>;
 920 defm DS_CONDXCHG32_RTN_B64   : DS_Real_gfx7_gfx10<0x07e>;
 921 defm DS_WRITE_B96            : DS_Real_gfx7_gfx10<0x0de>;
 922 defm DS_WRITE_B128           : DS_Real_gfx7_gfx10<0x0df>;
 923 defm DS_READ_B96             : DS_Real_gfx7_gfx10<0x0fe>;
 924 defm DS_READ_B128            : DS_Real_gfx7_gfx10<0x0ff>;
 925
 926 //===----------------------------------------------------------------------===//
 927 // GFX6, GFX7, GFX10.
 928 //===----------------------------------------------------------------------===//
 929
 930 let AssemblerPredicate = isGFX6GFX7, DecoderNamespace = "GFX6GFX7" in {
 931   multiclass DS_Real_gfx6_gfx7<bits<8> op> {
 932     def _gfx6_gfx7 : Base_DS_Real_gfx6_gfx7_gfx10<op, !cast<DS_Pseudo>(NAME),
 933                                                   SIEncodingFamily.SI>;
 934   }
 935 } // End AssemblerPredicate = isGFX6GFX7, DecoderNamespace = "GFX6GFX7"
 936
 937 multiclass DS_Real_gfx6_gfx7_gfx10<bits<8> op> :
 938   DS_Real_gfx6_gfx7<op>, DS_Real_gfx10<op>;
 939
 940 defm DS_ADD_U32             : DS_Real_gfx6_gfx7_gfx10<0x000>;
 941 defm DS_SUB_U32             : DS_Real_gfx6_gfx7_gfx10<0x001>;
 942 defm DS_RSUB_U32            : DS_Real_gfx6_gfx7_gfx10<0x002>;
 943 defm DS_INC_U32             : DS_Real_gfx6_gfx7_gfx10<0x003>;
 944 defm DS_DEC_U32             : DS_Real_gfx6_gfx7_gfx10<0x004>;
 945 defm DS_MIN_I32             : DS_Real_gfx6_gfx7_gfx10<0x005>;
 946 defm DS_MAX_I32             : DS_Real_gfx6_gfx7_gfx10<0x006>;
 947 defm DS_MIN_U32             : DS_Real_gfx6_gfx7_gfx10<0x007>;
 948 defm DS_MAX_U32             : DS_Real_gfx6_gfx7_gfx10<0x008>;
 949 defm DS_AND_B32             : DS_Real_gfx6_gfx7_gfx10<0x009>;
 950 defm DS_OR_B32              : DS_Real_gfx6_gfx7_gfx10<0x00a>;
 951 defm DS_XOR_B32             : DS_Real_gfx6_gfx7_gfx10<0x00b>;
 952 defm DS_MSKOR_B32           : DS_Real_gfx6_gfx7_gfx10<0x00c>;
 953 defm DS_WRITE_B32           : DS_Real_gfx6_gfx7_gfx10<0x00d>;
 954 defm DS_WRITE2_B32          : DS_Real_gfx6_gfx7_gfx10<0x00e>;
 955 defm DS_WRITE2ST64_B32      : DS_Real_gfx6_gfx7_gfx10<0x00f>;
 956 defm DS_CMPST_B32           : DS_Real_gfx6_gfx7_gfx10<0x010>;
 957 defm DS_CMPST_F32           : DS_Real_gfx6_gfx7_gfx10<0x011>;
 958 defm DS_MIN_F32             : DS_Real_gfx6_gfx7_gfx10<0x012>;
 959 defm DS_MAX_F32             : DS_Real_gfx6_gfx7_gfx10<0x013>;
 960 defm DS_NOP                 : DS_Real_gfx6_gfx7_gfx10<0x014>;
 961 defm DS_GWS_INIT            : DS_Real_gfx6_gfx7_gfx10<0x019>;
 962 defm DS_GWS_SEMA_V          : DS_Real_gfx6_gfx7_gfx10<0x01a>;
 963 defm DS_GWS_SEMA_BR         : DS_Real_gfx6_gfx7_gfx10<0x01b>;
 964 defm DS_GWS_SEMA_P          : DS_Real_gfx6_gfx7_gfx10<0x01c>;
 965 defm DS_GWS_BARRIER         : DS_Real_gfx6_gfx7_gfx10<0x01d>;
 966 defm DS_WRITE_B8            : DS_Real_gfx6_gfx7_gfx10<0x01e>;
 967 defm DS_WRITE_B16           : DS_Real_gfx6_gfx7_gfx10<0x01f>;
 968 defm DS_ADD_RTN_U32         : DS_Real_gfx6_gfx7_gfx10<0x020>;
 969 defm DS_SUB_RTN_U32         : DS_Real_gfx6_gfx7_gfx10<0x021>;
 970 defm DS_RSUB_RTN_U32        : DS_Real_gfx6_gfx7_gfx10<0x022>;
 971 defm DS_INC_RTN_U32         : DS_Real_gfx6_gfx7_gfx10<0x023>;
 972 defm DS_DEC_RTN_U32         : DS_Real_gfx6_gfx7_gfx10<0x024>;
 973 defm DS_MIN_RTN_I32         : DS_Real_gfx6_gfx7_gfx10<0x025>;
 974 defm DS_MAX_RTN_I32         : DS_Real_gfx6_gfx7_gfx10<0x026>;
 975 defm DS_MIN_RTN_U32         : DS_Real_gfx6_gfx7_gfx10<0x027>;
 976 defm DS_MAX_RTN_U32         : DS_Real_gfx6_gfx7_gfx10<0x028>;
 977 defm DS_AND_RTN_B32         : DS_Real_gfx6_gfx7_gfx10<0x029>;
 978 defm DS_OR_RTN_B32          : DS_Real_gfx6_gfx7_gfx10<0x02a>;
 979 defm DS_XOR_RTN_B32         : DS_Real_gfx6_gfx7_gfx10<0x02b>;
 980 defm DS_MSKOR_RTN_B32       : DS_Real_gfx6_gfx7_gfx10<0x02c>;
 981 defm DS_WRXCHG_RTN_B32      : DS_Real_gfx6_gfx7_gfx10<0x02d>;
 982 defm DS_WRXCHG2_RTN_B32     : DS_Real_gfx6_gfx7_gfx10<0x02e>;
 983 defm DS_WRXCHG2ST64_RTN_B32 : DS_Real_gfx6_gfx7_gfx10<0x02f>;
 984 defm DS_CMPST_RTN_B32       : DS_Real_gfx6_gfx7_gfx10<0x030>;
 985 defm DS_CMPST_RTN_F32       : DS_Real_gfx6_gfx7_gfx10<0x031>;
 986 defm DS_MIN_RTN_F32         : DS_Real_gfx6_gfx7_gfx10<0x032>;
 987 defm DS_MAX_RTN_F32         : DS_Real_gfx6_gfx7_gfx10<0x033>;
 988 defm DS_SWIZZLE_B32         : DS_Real_gfx6_gfx7_gfx10<0x035>;
 989 defm DS_READ_B32            : DS_Real_gfx6_gfx7_gfx10<0x036>;
 990 defm DS_READ2_B32           : DS_Real_gfx6_gfx7_gfx10<0x037>;
 991 defm DS_READ2ST64_B32       : DS_Real_gfx6_gfx7_gfx10<0x038>;
 992 defm DS_READ_I8             : DS_Real_gfx6_gfx7_gfx10<0x039>;
 993 defm DS_READ_U8             : DS_Real_gfx6_gfx7_gfx10<0x03a>;
 994 defm DS_READ_I16            : DS_Real_gfx6_gfx7_gfx10<0x03b>;
 995 defm DS_READ_U16            : DS_Real_gfx6_gfx7_gfx10<0x03c>;
 996 defm DS_CONSUME             : DS_Real_gfx6_gfx7_gfx10<0x03d>;
 997 defm DS_APPEND              : DS_Real_gfx6_gfx7_gfx10<0x03e>;
 998 defm DS_ORDERED_COUNT       : DS_Real_gfx6_gfx7_gfx10<0x03f>;
 999 defm DS_ADD_U64             : DS_Real_gfx6_gfx7_gfx10<0x040>;
1000 defm DS_SUB_U64             : DS_Real_gfx6_gfx7_gfx10<0x041>;
1001 defm DS_RSUB_U64            : DS_Real_gfx6_gfx7_gfx10<0x042>;
1002 defm DS_INC_U64             : DS_Real_gfx6_gfx7_gfx10<0x043>;
1003 defm DS_DEC_U64             : DS_Real_gfx6_gfx7_gfx10<0x044>;
1004 defm DS_MIN_I64             : DS_Real_gfx6_gfx7_gfx10<0x045>;
1005 defm DS_MAX_I64             : DS_Real_gfx6_gfx7_gfx10<0x046>;
1006 defm DS_MIN_U64             : DS_Real_gfx6_gfx7_gfx10<0x047>;
1007 defm DS_MAX_U64             : DS_Real_gfx6_gfx7_gfx10<0x048>;
1008 defm DS_AND_B64             : DS_Real_gfx6_gfx7_gfx10<0x049>;
1009 defm DS_OR_B64              : DS_Real_gfx6_gfx7_gfx10<0x04a>;
1010 defm DS_XOR_B64             : DS_Real_gfx6_gfx7_gfx10<0x04b>;
1011 defm DS_MSKOR_B64           : DS_Real_gfx6_gfx7_gfx10<0x04c>;
1012 defm DS_WRITE_B64           : DS_Real_gfx6_gfx7_gfx10<0x04d>;
1013 defm DS_WRITE2_B64          : DS_Real_gfx6_gfx7_gfx10<0x04e>;
1014 defm DS_WRITE2ST64_B64      : DS_Real_gfx6_gfx7_gfx10<0x04f>;
1015 defm DS_CMPST_B64           : DS_Real_gfx6_gfx7_gfx10<0x050>;
1016 defm DS_CMPST_F64           : DS_Real_gfx6_gfx7_gfx10<0x051>;
1017 defm DS_MIN_F64             : DS_Real_gfx6_gfx7_gfx10<0x052>;
1018 defm DS_MAX_F64             : DS_Real_gfx6_gfx7_gfx10<0x053>;
1019 defm DS_ADD_RTN_U64         : DS_Real_gfx6_gfx7_gfx10<0x060>;
1020 defm DS_SUB_RTN_U64         : DS_Real_gfx6_gfx7_gfx10<0x061>;
1021 defm DS_RSUB_RTN_U64        : DS_Real_gfx6_gfx7_gfx10<0x062>;
1022 defm DS_INC_RTN_U64         : DS_Real_gfx6_gfx7_gfx10<0x063>;
1023 defm DS_DEC_RTN_U64         : DS_Real_gfx6_gfx7_gfx10<0x064>;
1024 defm DS_MIN_RTN_I64         : DS_Real_gfx6_gfx7_gfx10<0x065>;
1025 defm DS_MAX_RTN_I64         : DS_Real_gfx6_gfx7_gfx10<0x066>;
1026 defm DS_MIN_RTN_U64         : DS_Real_gfx6_gfx7_gfx10<0x067>;
1027 defm DS_MAX_RTN_U64         : DS_Real_gfx6_gfx7_gfx10<0x068>;
1028 defm DS_AND_RTN_B64         : DS_Real_gfx6_gfx7_gfx10<0x069>;
1029 defm DS_OR_RTN_B64          : DS_Real_gfx6_gfx7_gfx10<0x06a>;
1030 defm DS_XOR_RTN_B64         : DS_Real_gfx6_gfx7_gfx10<0x06b>;
1031 defm DS_MSKOR_RTN_B64       : DS_Real_gfx6_gfx7_gfx10<0x06c>;
1032 defm DS_WRXCHG_RTN_B64      : DS_Real_gfx6_gfx7_gfx10<0x06d>;
1033 defm DS_WRXCHG2_RTN_B64     : DS_Real_gfx6_gfx7_gfx10<0x06e>;
1034 defm DS_WRXCHG2ST64_RTN_B64 : DS_Real_gfx6_gfx7_gfx10<0x06f>;
1035 defm DS_CMPST_RTN_B64       : DS_Real_gfx6_gfx7_gfx10<0x070>;
1036 defm DS_CMPST_RTN_F64       : DS_Real_gfx6_gfx7_gfx10<0x071>;
1037 defm DS_MIN_RTN_F64         : DS_Real_gfx6_gfx7_gfx10<0x072>;
1038 defm DS_MAX_RTN_F64         : DS_Real_gfx6_gfx7_gfx10<0x073>;
1039 defm DS_READ_B64            : DS_Real_gfx6_gfx7_gfx10<0x076>;
1040 defm DS_READ2_B64           : DS_Real_gfx6_gfx7_gfx10<0x077>;
1041 defm DS_READ2ST64_B64       : DS_Real_gfx6_gfx7_gfx10<0x078>;
1042 defm DS_ADD_SRC2_U32        : DS_Real_gfx6_gfx7_gfx10<0x080>;
1043 defm DS_SUB_SRC2_U32        : DS_Real_gfx6_gfx7_gfx10<0x081>;
1044 defm DS_RSUB_SRC2_U32       : DS_Real_gfx6_gfx7_gfx10<0x082>;
1045 defm DS_INC_SRC2_U32        : DS_Real_gfx6_gfx7_gfx10<0x083>;
1046 defm DS_DEC_SRC2_U32        : DS_Real_gfx6_gfx7_gfx10<0x084>;
1047 defm DS_MIN_SRC2_I32        : DS_Real_gfx6_gfx7_gfx10<0x085>;
1048 defm DS_MAX_SRC2_I32        : DS_Real_gfx6_gfx7_gfx10<0x086>;
1049 defm DS_MIN_SRC2_U32        : DS_Real_gfx6_gfx7_gfx10<0x087>;
1050 defm DS_MAX_SRC2_U32        : DS_Real_gfx6_gfx7_gfx10<0x088>;
1051 defm DS_AND_SRC2_B32        : DS_Real_gfx6_gfx7_gfx10<0x089>;
1052 defm DS_OR_SRC2_B32         : DS_Real_gfx6_gfx7_gfx10<0x08a>;
1053 defm DS_XOR_SRC2_B32        : DS_Real_gfx6_gfx7_gfx10<0x08b>;
1054 defm DS_WRITE_SRC2_B32      : DS_Real_gfx6_gfx7_gfx10<0x08d>;
1055 defm DS_MIN_SRC2_F32        : DS_Real_gfx6_gfx7_gfx10<0x092>;
1056 defm DS_MAX_SRC2_F32        : DS_Real_gfx6_gfx7_gfx10<0x093>;
1057 defm DS_ADD_SRC2_U64        : DS_Real_gfx6_gfx7_gfx10<0x0c0>;
1058 defm DS_SUB_SRC2_U64        : DS_Real_gfx6_gfx7_gfx10<0x0c1>;
1059 defm DS_RSUB_SRC2_U64       : DS_Real_gfx6_gfx7_gfx10<0x0c2>;
1060 defm DS_INC_SRC2_U64        : DS_Real_gfx6_gfx7_gfx10<0x0c3>;
1061 defm DS_DEC_SRC2_U64        : DS_Real_gfx6_gfx7_gfx10<0x0c4>;
1062 defm DS_MIN_SRC2_I64        : DS_Real_gfx6_gfx7_gfx10<0x0c5>;
1063 defm DS_MAX_SRC2_I64        : DS_Real_gfx6_gfx7_gfx10<0x0c6>;
1064 defm DS_MIN_SRC2_U64        : DS_Real_gfx6_gfx7_gfx10<0x0c7>;
1065 defm DS_MAX_SRC2_U64        : DS_Real_gfx6_gfx7_gfx10<0x0c8>;
1066 defm DS_AND_SRC2_B64        : DS_Real_gfx6_gfx7_gfx10<0x0c9>;
1067 defm DS_OR_SRC2_B64         : DS_Real_gfx6_gfx7_gfx10<0x0ca>;
1068 defm DS_XOR_SRC2_B64        : DS_Real_gfx6_gfx7_gfx10<0x0cb>;
1069 defm DS_WRITE_SRC2_B64      : DS_Real_gfx6_gfx7_gfx10<0x0cd>;
1070 defm DS_MIN_SRC2_F64        : DS_Real_gfx6_gfx7_gfx10<0x0d2>;
1071 defm DS_MAX_SRC2_F64        : DS_Real_gfx6_gfx7_gfx10<0x0d3>;
1072
1073 //===----------------------------------------------------------------------===//
1074 // GFX8, GFX9 (VI).
1075 //===----------------------------------------------------------------------===//
1076
1077 class DS_Real_vi <bits<8> op, DS_Pseudo ds> :
1078   DS_Real <ds>,
1079   SIMCInstr <ds.Mnemonic, SIEncodingFamily.VI> {
1080   let AssemblerPredicate = isGFX8GFX9;
1081   let DecoderNamespace = "GFX8";
1082
1083   // encoding
1084   let Inst{7-0}   = !if(ds.has_offset0, offset0, 0);
1085   let Inst{15-8}  = !if(ds.has_offset1, offset1, 0);
1086   let Inst{16}    = !if(ds.has_gds, gds, ds.gdsValue);
1087   let Inst{24-17} = op;
1088   let Inst{31-26} = 0x36; // ds prefix
1089   let Inst{39-32} = !if(ds.has_addr, addr, !if(ds.has_gws_data0, data0, 0));
1090   let Inst{47-40} = !if(ds.has_data0, data0, 0);
1091   let Inst{55-48} = !if(ds.has_data1, data1, 0);
1092   let Inst{63-56} = !if(ds.has_vdst, vdst, 0);
1093 }
1094
1095 def DS_ADD_U32_vi         : DS_Real_vi<0x0,  DS_ADD_U32>;
1096 def DS_SUB_U32_vi         : DS_Real_vi<0x1,  DS_SUB_U32>;
1097 def DS_RSUB_U32_vi        : DS_Real_vi<0x2,  DS_RSUB_U32>;
1098 def DS_INC_U32_vi         : DS_Real_vi<0x3,  DS_INC_U32>;
1099 def DS_DEC_U32_vi         : DS_Real_vi<0x4,  DS_DEC_U32>;
1100 def DS_MIN_I32_vi         : DS_Real_vi<0x5,  DS_MIN_I32>;
1101 def DS_MAX_I32_vi         : DS_Real_vi<0x6,  DS_MAX_I32>;
1102 def DS_MIN_U32_vi         : DS_Real_vi<0x7,  DS_MIN_U32>;
1103 def DS_MAX_U32_vi         : DS_Real_vi<0x8,  DS_MAX_U32>;
1104 def DS_AND_B32_vi         : DS_Real_vi<0x9,  DS_AND_B32>;
1105 def DS_OR_B32_vi          : DS_Real_vi<0xa,  DS_OR_B32>;
1106 def DS_XOR_B32_vi         : DS_Real_vi<0xb,  DS_XOR_B32>;
1107 def DS_MSKOR_B32_vi       : DS_Real_vi<0xc,  DS_MSKOR_B32>;
1108 def DS_WRITE_B32_vi       : DS_Real_vi<0xd,  DS_WRITE_B32>;
1109 def DS_WRITE2_B32_vi      : DS_Real_vi<0xe,  DS_WRITE2_B32>;
1110 def DS_WRITE2ST64_B32_vi  : DS_Real_vi<0xf,  DS_WRITE2ST64_B32>;
1111 def DS_CMPST_B32_vi       : DS_Real_vi<0x10, DS_CMPST_B32>;
1112 def DS_CMPST_F32_vi       : DS_Real_vi<0x11, DS_CMPST_F32>;
1113 def DS_MIN_F32_vi         : DS_Real_vi<0x12, DS_MIN_F32>;
1114 def DS_MAX_F32_vi         : DS_Real_vi<0x13, DS_MAX_F32>;
1115 def DS_NOP_vi             : DS_Real_vi<0x14, DS_NOP>;
1116 def DS_ADD_F32_vi         : DS_Real_vi<0x15, DS_ADD_F32>;
1117 def DS_GWS_INIT_vi        : DS_Real_vi<0x99, DS_GWS_INIT>;
1118 def DS_GWS_SEMA_V_vi      : DS_Real_vi<0x9a, DS_GWS_SEMA_V>;
1119 def DS_GWS_SEMA_BR_vi     : DS_Real_vi<0x9b, DS_GWS_SEMA_BR>;
1120 def DS_GWS_SEMA_P_vi      : DS_Real_vi<0x9c, DS_GWS_SEMA_P>;
1121 def DS_GWS_BARRIER_vi     : DS_Real_vi<0x9d, DS_GWS_BARRIER>;
1122 def DS_WRITE_ADDTID_B32_vi : DS_Real_vi<0x1d, DS_WRITE_ADDTID_B32>;
1123 def DS_WRITE_B8_vi        : DS_Real_vi<0x1e, DS_WRITE_B8>;
1124 def DS_WRITE_B16_vi       : DS_Real_vi<0x1f, DS_WRITE_B16>;
1125 def DS_ADD_RTN_U32_vi     : DS_Real_vi<0x20, DS_ADD_RTN_U32>;
1126 def DS_SUB_RTN_U32_vi     : DS_Real_vi<0x21, DS_SUB_RTN_U32>;
1127 def DS_RSUB_RTN_U32_vi    : DS_Real_vi<0x22, DS_RSUB_RTN_U32>;
1128 def DS_INC_RTN_U32_vi     : DS_Real_vi<0x23, DS_INC_RTN_U32>;
1129 def DS_DEC_RTN_U32_vi     : DS_Real_vi<0x24, DS_DEC_RTN_U32>;
1130 def DS_MIN_RTN_I32_vi     : DS_Real_vi<0x25, DS_MIN_RTN_I32>;
1131 def DS_MAX_RTN_I32_vi     : DS_Real_vi<0x26, DS_MAX_RTN_I32>;
1132 def DS_MIN_RTN_U32_vi     : DS_Real_vi<0x27, DS_MIN_RTN_U32>;
1133 def DS_MAX_RTN_U32_vi     : DS_Real_vi<0x28, DS_MAX_RTN_U32>;
1134 def DS_AND_RTN_B32_vi     : DS_Real_vi<0x29, DS_AND_RTN_B32>;
1135 def DS_OR_RTN_B32_vi      : DS_Real_vi<0x2a, DS_OR_RTN_B32>;
1136 def DS_XOR_RTN_B32_vi     : DS_Real_vi<0x2b, DS_XOR_RTN_B32>;
1137 def DS_MSKOR_RTN_B32_vi   : DS_Real_vi<0x2c, DS_MSKOR_RTN_B32>;
1138 def DS_WRXCHG_RTN_B32_vi  : DS_Real_vi<0x2d, DS_WRXCHG_RTN_B32>;
1139 def DS_WRXCHG2_RTN_B32_vi : DS_Real_vi<0x2e, DS_WRXCHG2_RTN_B32>;
1140 def DS_WRXCHG2ST64_RTN_B32_vi : DS_Real_vi<0x2f, DS_WRXCHG2ST64_RTN_B32>;
1141 def DS_CMPST_RTN_B32_vi   : DS_Real_vi<0x30, DS_CMPST_RTN_B32>;
1142 def DS_CMPST_RTN_F32_vi   : DS_Real_vi<0x31, DS_CMPST_RTN_F32>;
1143 def DS_MIN_RTN_F32_vi     : DS_Real_vi<0x32, DS_MIN_RTN_F32>;
1144 def DS_MAX_RTN_F32_vi     : DS_Real_vi<0x33, DS_MAX_RTN_F32>;
1145 def DS_WRAP_RTN_B32_vi    : DS_Real_vi<0x34, DS_WRAP_RTN_B32>;
1146 def DS_ADD_RTN_F32_vi     : DS_Real_vi<0x35, DS_ADD_RTN_F32>;
1147 def DS_READ_B32_vi        : DS_Real_vi<0x36, DS_READ_B32>;
1148 def DS_READ2_B32_vi       : DS_Real_vi<0x37, DS_READ2_B32>;
1149 def DS_READ2ST64_B32_vi   : DS_Real_vi<0x38, DS_READ2ST64_B32>;
1150 def DS_READ_I8_vi         : DS_Real_vi<0x39, DS_READ_I8>;
1151 def DS_READ_U8_vi         : DS_Real_vi<0x3a, DS_READ_U8>;
1152 def DS_READ_I16_vi        : DS_Real_vi<0x3b, DS_READ_I16>;
1153 def DS_READ_U16_vi        : DS_Real_vi<0x3c, DS_READ_U16>;
1154 def DS_READ_ADDTID_B32_vi : DS_Real_vi<0xb6, DS_READ_ADDTID_B32>;
1155 def DS_CONSUME_vi         : DS_Real_vi<0xbd, DS_CONSUME>;
1156 def DS_APPEND_vi          : DS_Real_vi<0xbe, DS_APPEND>;
1157 def DS_ORDERED_COUNT_vi   : DS_Real_vi<0xbf, DS_ORDERED_COUNT>;
1158 def DS_SWIZZLE_B32_vi     : DS_Real_vi<0x3d, DS_SWIZZLE_B32>;
1159 def DS_PERMUTE_B32_vi     : DS_Real_vi<0x3e, DS_PERMUTE_B32>;
1160 def DS_BPERMUTE_B32_vi    : DS_Real_vi<0x3f, DS_BPERMUTE_B32>;
1161
1162 def DS_ADD_U64_vi         : DS_Real_vi<0x40, DS_ADD_U64>;
1163 def DS_SUB_U64_vi         : DS_Real_vi<0x41, DS_SUB_U64>;
1164 def DS_RSUB_U64_vi        : DS_Real_vi<0x42, DS_RSUB_U64>;
1165 def DS_INC_U64_vi         : DS_Real_vi<0x43, DS_INC_U64>;
1166 def DS_DEC_U64_vi         : DS_Real_vi<0x44, DS_DEC_U64>;
1167 def DS_MIN_I64_vi         : DS_Real_vi<0x45, DS_MIN_I64>;
1168 def DS_MAX_I64_vi         : DS_Real_vi<0x46, DS_MAX_I64>;
1169 def DS_MIN_U64_vi         : DS_Real_vi<0x47, DS_MIN_U64>;
1170 def DS_MAX_U64_vi         : DS_Real_vi<0x48, DS_MAX_U64>;
1171 def DS_AND_B64_vi         : DS_Real_vi<0x49, DS_AND_B64>;
1172 def DS_OR_B64_vi          : DS_Real_vi<0x4a, DS_OR_B64>;
1173 def DS_XOR_B64_vi         : DS_Real_vi<0x4b, DS_XOR_B64>;
1174 def DS_MSKOR_B64_vi       : DS_Real_vi<0x4c, DS_MSKOR_B64>;
1175 def DS_WRITE_B64_vi       : DS_Real_vi<0x4d, DS_WRITE_B64>;
1176 def DS_WRITE2_B64_vi      : DS_Real_vi<0x4E, DS_WRITE2_B64>;
1177 def DS_WRITE2ST64_B64_vi  : DS_Real_vi<0x4f, DS_WRITE2ST64_B64>;
1178 def DS_CMPST_B64_vi       : DS_Real_vi<0x50, DS_CMPST_B64>;
1179 def DS_CMPST_F64_vi       : DS_Real_vi<0x51, DS_CMPST_F64>;
1180 def DS_MIN_F64_vi         : DS_Real_vi<0x52, DS_MIN_F64>;
1181 def DS_MAX_F64_vi         : DS_Real_vi<0x53, DS_MAX_F64>;
1182
1183 def DS_WRITE_B8_D16_HI_vi  : DS_Real_vi<0x54, DS_WRITE_B8_D16_HI>;
1184 def DS_WRITE_B16_D16_HI_vi : DS_Real_vi<0x55, DS_WRITE_B16_D16_HI>;
1185
1186 def DS_READ_U8_D16_vi     : DS_Real_vi<0x56, DS_READ_U8_D16>;
1187 def DS_READ_U8_D16_HI_vi  : DS_Real_vi<0x57, DS_READ_U8_D16_HI>;
1188 def DS_READ_I8_D16_vi     : DS_Real_vi<0x58, DS_READ_I8_D16>;
1189 def DS_READ_I8_D16_HI_vi  : DS_Real_vi<0x59, DS_READ_I8_D16_HI>;
1190 def DS_READ_U16_D16_vi    : DS_Real_vi<0x5a, DS_READ_U16_D16>;
1191 def DS_READ_U16_D16_HI_vi : DS_Real_vi<0x5b, DS_READ_U16_D16_HI>;
1192
1193 def DS_ADD_RTN_U64_vi     : DS_Real_vi<0x60, DS_ADD_RTN_U64>;
1194 def DS_SUB_RTN_U64_vi     : DS_Real_vi<0x61, DS_SUB_RTN_U64>;
1195 def DS_RSUB_RTN_U64_vi    : DS_Real_vi<0x62, DS_RSUB_RTN_U64>;
1196 def DS_INC_RTN_U64_vi     : DS_Real_vi<0x63, DS_INC_RTN_U64>;
1197 def DS_DEC_RTN_U64_vi     : DS_Real_vi<0x64, DS_DEC_RTN_U64>;
1198 def DS_MIN_RTN_I64_vi     : DS_Real_vi<0x65, DS_MIN_RTN_I64>;
1199 def DS_MAX_RTN_I64_vi     : DS_Real_vi<0x66, DS_MAX_RTN_I64>;
1200 def DS_MIN_RTN_U64_vi     : DS_Real_vi<0x67, DS_MIN_RTN_U64>;
1201 def DS_MAX_RTN_U64_vi     : DS_Real_vi<0x68, DS_MAX_RTN_U64>;
1202 def DS_AND_RTN_B64_vi     : DS_Real_vi<0x69, DS_AND_RTN_B64>;
1203 def DS_OR_RTN_B64_vi      : DS_Real_vi<0x6a, DS_OR_RTN_B64>;
1204 def DS_XOR_RTN_B64_vi     : DS_Real_vi<0x6b, DS_XOR_RTN_B64>;
1205 def DS_MSKOR_RTN_B64_vi   : DS_Real_vi<0x6c, DS_MSKOR_RTN_B64>;
1206 def DS_WRXCHG_RTN_B64_vi  : DS_Real_vi<0x6d, DS_WRXCHG_RTN_B64>;
1207 def DS_WRXCHG2_RTN_B64_vi : DS_Real_vi<0x6e, DS_WRXCHG2_RTN_B64>;
1208 def DS_WRXCHG2ST64_RTN_B64_vi : DS_Real_vi<0x6f, DS_WRXCHG2ST64_RTN_B64>;
1209 def DS_CONDXCHG32_RTN_B64_vi   : DS_Real_vi<0x7e, DS_CONDXCHG32_RTN_B64>;
1210 def DS_GWS_SEMA_RELEASE_ALL_vi : DS_Real_vi<0x98, DS_GWS_SEMA_RELEASE_ALL>;
1211 def DS_CMPST_RTN_B64_vi   : DS_Real_vi<0x70, DS_CMPST_RTN_B64>;
1212 def DS_CMPST_RTN_F64_vi   : DS_Real_vi<0x71, DS_CMPST_RTN_F64>;
1213 def DS_MIN_RTN_F64_vi     : DS_Real_vi<0x72, DS_MIN_RTN_F64>;
1214 def DS_MAX_RTN_F64_vi     : DS_Real_vi<0x73, DS_MAX_RTN_F64>;
1215
1216 def DS_READ_B64_vi        : DS_Real_vi<0x76, DS_READ_B64>;
1217 def DS_READ2_B64_vi       : DS_Real_vi<0x77, DS_READ2_B64>;
1218 def DS_READ2ST64_B64_vi   : DS_Real_vi<0x78, DS_READ2ST64_B64>;
1219
1220 def DS_ADD_SRC2_U32_vi    : DS_Real_vi<0x80, DS_ADD_SRC2_U32>;
1221 def DS_SUB_SRC2_U32_vi    : DS_Real_vi<0x81, DS_SUB_SRC2_U32>;
1222 def DS_RSUB_SRC2_U32_vi   : DS_Real_vi<0x82, DS_RSUB_SRC2_U32>;
1223 def DS_INC_SRC2_U32_vi    : DS_Real_vi<0x83, DS_INC_SRC2_U32>;
1224 def DS_DEC_SRC2_U32_vi    : DS_Real_vi<0x84, DS_DEC_SRC2_U32>;
1225 def DS_MIN_SRC2_I32_vi    : DS_Real_vi<0x85, DS_MIN_SRC2_I32>;
1226 def DS_MAX_SRC2_I32_vi    : DS_Real_vi<0x86, DS_MAX_SRC2_I32>;
1227 def DS_MIN_SRC2_U32_vi    : DS_Real_vi<0x87, DS_MIN_SRC2_U32>;
1228 def DS_MAX_SRC2_U32_vi    : DS_Real_vi<0x88, DS_MAX_SRC2_U32>;
1229 def DS_AND_SRC2_B32_vi    : DS_Real_vi<0x89, DS_AND_SRC2_B32>;
1230 def DS_OR_SRC2_B32_vi     : DS_Real_vi<0x8a, DS_OR_SRC2_B32>;
1231 def DS_XOR_SRC2_B32_vi    : DS_Real_vi<0x8b, DS_XOR_SRC2_B32>;
1232 def DS_WRITE_SRC2_B32_vi  : DS_Real_vi<0x8d, DS_WRITE_SRC2_B32>;
1233 def DS_MIN_SRC2_F32_vi    : DS_Real_vi<0x92, DS_MIN_SRC2_F32>;
1234 def DS_MAX_SRC2_F32_vi    : DS_Real_vi<0x93, DS_MAX_SRC2_F32>;
1235 def DS_ADD_SRC2_F32_vi    : DS_Real_vi<0x95, DS_ADD_SRC2_F32>;
1236 def DS_ADD_SRC2_U64_vi    : DS_Real_vi<0xc0, DS_ADD_SRC2_U64>;
1237 def DS_SUB_SRC2_U64_vi    : DS_Real_vi<0xc1, DS_SUB_SRC2_U64>;
1238 def DS_RSUB_SRC2_U64_vi   : DS_Real_vi<0xc2, DS_RSUB_SRC2_U64>;
1239 def DS_INC_SRC2_U64_vi    : DS_Real_vi<0xc3, DS_INC_SRC2_U64>;
1240 def DS_DEC_SRC2_U64_vi    : DS_Real_vi<0xc4, DS_DEC_SRC2_U64>;
1241 def DS_MIN_SRC2_I64_vi    : DS_Real_vi<0xc5, DS_MIN_SRC2_I64>;
1242 def DS_MAX_SRC2_I64_vi    : DS_Real_vi<0xc6, DS_MAX_SRC2_I64>;
1243 def DS_MIN_SRC2_U64_vi    : DS_Real_vi<0xc7, DS_MIN_SRC2_U64>;
1244 def DS_MAX_SRC2_U64_vi    : DS_Real_vi<0xc8, DS_MAX_SRC2_U64>;
1245 def DS_AND_SRC2_B64_vi    : DS_Real_vi<0xc9, DS_AND_SRC2_B64>;
1246 def DS_OR_SRC2_B64_vi     : DS_Real_vi<0xca, DS_OR_SRC2_B64>;
1247 def DS_XOR_SRC2_B64_vi    : DS_Real_vi<0xcb, DS_XOR_SRC2_B64>;
1248 def DS_WRITE_SRC2_B64_vi  : DS_Real_vi<0xcd, DS_WRITE_SRC2_B64>;
1249 def DS_MIN_SRC2_F64_vi    : DS_Real_vi<0xd2, DS_MIN_SRC2_F64>;
1250 def DS_MAX_SRC2_F64_vi    : DS_Real_vi<0xd3, DS_MAX_SRC2_F64>;
1251 def DS_WRITE_B96_vi       : DS_Real_vi<0xde, DS_WRITE_B96>;
1252 def DS_WRITE_B128_vi      : DS_Real_vi<0xdf, DS_WRITE_B128>;
1253 def DS_READ_B96_vi        : DS_Real_vi<0xfe, DS_READ_B96>;
1254 def DS_READ_B128_vi       : DS_Real_vi<0xff, DS_READ_B128>;