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

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