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

   1 //===-- FLATInstructions.td - FLAT 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 def FlatOffset : ComplexPattern<iPTR, 2, "SelectFlatOffset", [], [SDNPWantRoot], -10>;
  10 def GlobalOffset : ComplexPattern<iPTR, 2, "SelectGlobalOffset", [], [SDNPWantRoot], -10>;
  11 def ScratchOffset : ComplexPattern<iPTR, 2, "SelectScratchOffset", [], [SDNPWantRoot], -10>;
  12
  13 def GlobalSAddr : ComplexPattern<iPTR, 3, "SelectGlobalSAddr", [], [SDNPWantRoot], -10>;
  14 def ScratchSAddr : ComplexPattern<iPTR, 2, "SelectScratchSAddr", [], [SDNPWantRoot], -10>;
  15 def ScratchSVAddr : ComplexPattern<iPTR, 3, "SelectScratchSVAddr", [], [SDNPWantRoot], -10>;
  16
  17 //===----------------------------------------------------------------------===//
  18 // FLAT classes
  19 //===----------------------------------------------------------------------===//
  20
  21 class FLAT_Pseudo<string opName, dag outs, dag ins,
  22                   string asmOps, list<dag> pattern=[]> :
  23   InstSI<outs, ins, "", pattern>,
  24   SIMCInstr<opName, SIEncodingFamily.NONE> {
  25
  26   let isPseudo = 1;
  27   let isCodeGenOnly = 1;
  28
  29   let FLAT = 1;
  30
  31   let UseNamedOperandTable = 1;
  32   let hasSideEffects = 0;
  33   let SchedRW = [WriteVMEM];
  34
  35   string Mnemonic = opName;
  36   string AsmOperands = asmOps;
  37
  38   bits<1> is_flat_global = 0;
  39   bits<1> is_flat_scratch = 0;
  40
  41   bits<1> has_vdst = 1;
  42
  43   // We need to distinguish having saddr and enabling saddr because
  44   // saddr is only valid for scratch and global instructions. Pre-gfx9
  45   // these bits were reserved, so we also don't necessarily want to
  46   // set these bits to the disabled value for the original flat
  47   // segment instructions.
  48   bits<1> has_saddr = 0;
  49   bits<1> enabled_saddr = 0;
  50   bits<7> saddr_value = 0;
  51   bits<1> has_vaddr = 1;
  52
  53   bits<1> has_data = 1;
  54   bits<1> has_glc  = 1;
  55   bits<1> glcValue = 0;
  56   bits<1> has_dlc  = 1;
  57   bits<1> dlcValue = 0;
  58   bits<1> has_sccb  = 1;
  59   bits<1> sccbValue = 0;
  60   bits<1> has_sve  = 0; // Scratch VGPR Enable
  61   bits<1> lds = 0;
  62   bits<1> sve = 0;
  63
  64   let SubtargetPredicate = !if(is_flat_global, HasFlatGlobalInsts,
  65     !if(is_flat_scratch, HasFlatScratchInsts, HasFlatAddressSpace));
  66
  67   // TODO: M0 if it could possibly access LDS (before gfx9? only)?
  68   let Uses = !if(is_flat_global, [EXEC], [EXEC, FLAT_SCR]);
  69
  70   // Internally, FLAT instruction are executed as both an LDS and a
  71   // Buffer instruction; so, they increment both VM_CNT and LGKM_CNT
  72   // and are not considered done until both have been decremented.
  73   let VM_CNT = 1;
  74   let LGKM_CNT = !not(!or(is_flat_global, is_flat_scratch));
  75
  76   let FlatGlobal = is_flat_global;
  77
  78   let FlatScratch = is_flat_scratch;
  79 }
  80
  81 class FLAT_Real <bits<7> op, FLAT_Pseudo ps, string opName = ps.Mnemonic> :
  82   InstSI <ps.OutOperandList, ps.InOperandList, opName # ps.AsmOperands, []>,
  83   Enc64 {
  84
  85   let isPseudo = 0;
  86   let isCodeGenOnly = 0;
  87
  88   let FLAT = 1;
  89
  90   // copy relevant pseudo op flags
  91   let SubtargetPredicate   = ps.SubtargetPredicate;
  92   let AsmMatchConverter    = ps.AsmMatchConverter;
  93   let OtherPredicates      = ps.OtherPredicates;
  94   let TSFlags              = ps.TSFlags;
  95   let UseNamedOperandTable = ps.UseNamedOperandTable;
  96   let SchedRW              = ps.SchedRW;
  97   let mayLoad              = ps.mayLoad;
  98   let mayStore             = ps.mayStore;
  99   let IsAtomicRet          = ps.IsAtomicRet;
 100   let IsAtomicNoRet        = ps.IsAtomicNoRet;
 101   let VM_CNT               = ps.VM_CNT;
 102   let LGKM_CNT             = ps.LGKM_CNT;
 103   let VALU                 = ps.VALU;
 104
 105   // encoding fields
 106   bits<8> vaddr;
 107   bits<10> vdata;
 108   bits<7> saddr;
 109   bits<10> vdst;
 110
 111   bits<5> cpol;
 112
 113   // Only valid on gfx9
 114   bits<1> lds = ps.lds; // LDS DMA for global and scratch
 115
 116   // Segment, 00=flat, 01=scratch, 10=global, 11=reserved
 117   bits<2> seg = !if(ps.is_flat_global, 0b10,
 118                   !if(ps.is_flat_scratch, 0b01, 0));
 119
 120   // Signed offset. Highest bit ignored for flat and treated as 12-bit
 121   // unsigned for flat accesses.
 122   bits<13> offset;
 123   // GFX90A+ only: instruction uses AccVGPR for data
 124   bits<1> acc = !if(ps.has_vdst, vdst{9}, !if(ps.has_data, vdata{9}, 0));
 125
 126   // We don't use tfe right now, and it was removed in gfx9.
 127   bits<1> tfe = 0;
 128
 129   // Only valid on GFX9+
 130   let Inst{12-0} = offset;
 131   let Inst{13} = !if(ps.has_sve, ps.sve, lds);
 132   let Inst{15-14} = seg;
 133
 134   let Inst{16}    = !if(ps.has_glc, cpol{CPolBit.GLC}, ps.glcValue);
 135   let Inst{17}    = cpol{CPolBit.SLC};
 136   let Inst{24-18} = op;
 137   let Inst{31-26} = 0x37; // Encoding.
 138   let Inst{39-32} = !if(ps.has_vaddr, vaddr, ?);
 139   let Inst{47-40} = !if(ps.has_data, vdata{7-0}, ?);
 140   let Inst{54-48} = !if(ps.has_saddr, !if(ps.enabled_saddr, saddr, 0x7f), 0);
 141
 142   // 54-48 is reserved.
 143   let Inst{55}    = acc; // nv on GFX9+, TFE before. AccVGPR for data on GFX90A.
 144   let Inst{63-56} = !if(ps.has_vdst, vdst{7-0}, ?);
 145 }
 146
 147 class GlobalSaddrTable <bit is_saddr, string Name = ""> {
 148   bit IsSaddr = is_saddr;
 149   string SaddrOp = Name;
 150 }
 151
 152 // TODO: Is exec allowed for saddr? The disabled value 0x7f is the
 153 // same encoding value as exec_hi, so it isn't possible to use that if
 154 // saddr is 32-bit (which isn't handled here yet).
 155 class FLAT_Load_Pseudo <string opName, RegisterClass regClass,
 156   bit HasTiedOutput = 0,
 157   bit HasSaddr = 0, bit EnableSaddr = 0,
 158   RegisterOperand vdata_op = getLdStRegisterOperand<regClass>.ret> : FLAT_Pseudo<
 159   opName,
 160   (outs vdata_op:$vdst),
 161   !con(
 162     !con(
 163       !if(EnableSaddr,
 164         (ins SReg_64:$saddr, VGPR_32:$vaddr),
 165         (ins VReg_64:$vaddr)),
 166         (ins flat_offset:$offset)),
 167         // FIXME: Operands with default values do not work with following non-optional operands.
 168         !if(HasTiedOutput, (ins CPol:$cpol, vdata_op:$vdst_in),
 169                            (ins CPol_0:$cpol))),
 170   " $vdst, $vaddr"#!if(HasSaddr, !if(EnableSaddr, ", $saddr", ", off"), "")#"$offset$cpol"> {
 171   let has_data = 0;
 172   let mayLoad = 1;
 173   let has_saddr = HasSaddr;
 174   let enabled_saddr = EnableSaddr;
 175   let PseudoInstr = opName#!if(!and(HasSaddr, EnableSaddr), "_SADDR", "");
 176   let maybeAtomic = 1;
 177
 178   let Constraints = !if(HasTiedOutput, "$vdst = $vdst_in", "");
 179   let DisableEncoding = !if(HasTiedOutput, "$vdst_in", "");
 180 }
 181
 182 class FLAT_Store_Pseudo <string opName, RegisterClass vdataClass,
 183   bit HasSaddr = 0, bit EnableSaddr = 0> : FLAT_Pseudo<
 184   opName,
 185   (outs),
 186   !con(
 187     !if(EnableSaddr,
 188       (ins VGPR_32:$vaddr, getLdStRegisterOperand<vdataClass>.ret:$vdata, SReg_64:$saddr),
 189       (ins VReg_64:$vaddr, getLdStRegisterOperand<vdataClass>.ret:$vdata)),
 190       (ins flat_offset:$offset, CPol_0:$cpol)),
 191   " $vaddr, $vdata"#!if(HasSaddr, !if(EnableSaddr, ", $saddr", ", off"), "")#"$offset$cpol"> {
 192   let mayLoad  = 0;
 193   let mayStore = 1;
 194   let has_vdst = 0;
 195   let has_saddr = HasSaddr;
 196   let enabled_saddr = EnableSaddr;
 197   let PseudoInstr = opName#!if(!and(HasSaddr, EnableSaddr), "_SADDR", "");
 198   let maybeAtomic = 1;
 199 }
 200
 201 multiclass FLAT_Global_Load_Pseudo<string opName, RegisterClass regClass, bit HasTiedInput = 0> {
 202   let is_flat_global = 1, SubtargetPredicate = HasFlatGlobalInsts in {
 203     def "" : FLAT_Load_Pseudo<opName, regClass, HasTiedInput, 1>,
 204       GlobalSaddrTable<0, opName>;
 205     def _SADDR : FLAT_Load_Pseudo<opName, regClass, HasTiedInput, 1, 1>,
 206       GlobalSaddrTable<1, opName>;
 207   }
 208 }
 209
 210 class FLAT_Global_Load_AddTid_Pseudo <string opName, RegisterClass regClass,
 211   bit HasTiedOutput = 0, bit EnableSaddr = 0> : FLAT_Pseudo<
 212   opName,
 213   (outs regClass:$vdst),
 214   !con(!if(EnableSaddr, (ins SReg_64:$saddr), (ins)),
 215     (ins flat_offset:$offset, CPol_0:$cpol),
 216     !if(HasTiedOutput, (ins regClass:$vdst_in), (ins))),
 217   " $vdst, "#!if(EnableSaddr, "$saddr", "off")#"$offset$cpol"> {
 218   let is_flat_global = 1;
 219   let has_data = 0;
 220   let mayLoad = 1;
 221   let has_vaddr = 0;
 222   let has_saddr = 1;
 223   let enabled_saddr = EnableSaddr;
 224   let maybeAtomic = 1;
 225   let PseudoInstr = opName#!if(EnableSaddr, "_SADDR", "");
 226
 227   let Constraints = !if(HasTiedOutput, "$vdst = $vdst_in", "");
 228   let DisableEncoding = !if(HasTiedOutput, "$vdst_in", "");
 229 }
 230
 231 multiclass FLAT_Global_Load_AddTid_Pseudo<string opName, RegisterClass regClass,
 232   bit HasTiedOutput = 0> {
 233   def "" : FLAT_Global_Load_AddTid_Pseudo<opName, regClass, HasTiedOutput>,
 234     GlobalSaddrTable<0, opName>;
 235   def _SADDR : FLAT_Global_Load_AddTid_Pseudo<opName, regClass, HasTiedOutput, 1>,
 236     GlobalSaddrTable<1, opName>;
 237 }
 238
 239 multiclass FLAT_Global_Store_Pseudo<string opName, RegisterClass regClass> {
 240   let is_flat_global = 1, SubtargetPredicate = HasFlatGlobalInsts in {
 241     def "" : FLAT_Store_Pseudo<opName, regClass, 1>,
 242       GlobalSaddrTable<0, opName>;
 243     def _SADDR : FLAT_Store_Pseudo<opName, regClass, 1, 1>,
 244       GlobalSaddrTable<1, opName>;
 245   }
 246 }
 247
 248 class FLAT_Global_Load_LDS_Pseudo <string opName, bit EnableSaddr = 0> : FLAT_Pseudo<
 249   opName,
 250   (outs ),
 251   !con(
 252       !if(EnableSaddr, (ins SReg_64:$saddr, VGPR_32:$vaddr), (ins VReg_64:$vaddr)),
 253       (ins flat_offset:$offset, CPol_0:$cpol)),
 254   " $vaddr"#!if(EnableSaddr, ", $saddr", ", off")#"$offset$cpol"> {
 255   let LGKM_CNT = 1;
 256   let is_flat_global = 1;
 257   let lds = 1;
 258   let has_data = 0;
 259   let has_vdst = 0;
 260   let mayLoad = 1;
 261   let mayStore = 1;
 262   let has_saddr = 1;
 263   let enabled_saddr = EnableSaddr;
 264   let VALU = 1;
 265   let PseudoInstr = opName#!if(EnableSaddr, "_SADDR", "");
 266   let Uses = [M0, EXEC];
 267   let SchedRW = [WriteVMEM, WriteLDS];
 268 }
 269
 270 multiclass FLAT_Global_Load_LDS_Pseudo<string opName> {
 271   def ""     : FLAT_Global_Load_LDS_Pseudo<opName>,
 272     GlobalSaddrTable<0, opName>;
 273   def _SADDR : FLAT_Global_Load_LDS_Pseudo<opName, 1>,
 274     GlobalSaddrTable<1, opName>;
 275 }
 276
 277 class FLAT_Global_Store_AddTid_Pseudo <string opName, RegisterClass vdataClass,
 278   bit EnableSaddr = 0> : FLAT_Pseudo<
 279   opName,
 280   (outs),
 281   !con(!if(EnableSaddr, (ins vdataClass:$vdata, SReg_64:$saddr), (ins vdataClass:$vdata)),
 282     (ins flat_offset:$offset, CPol:$cpol)),
 283   " $vdata, "#!if(EnableSaddr, "$saddr", "off")#"$offset$cpol"> {
 284   let is_flat_global = 1;
 285   let mayLoad  = 0;
 286   let mayStore = 1;
 287   let has_vdst = 0;
 288   let has_vaddr = 0;
 289   let has_saddr = 1;
 290   let enabled_saddr = EnableSaddr;
 291   let maybeAtomic = 1;
 292   let PseudoInstr = opName#!if(EnableSaddr, "_SADDR", "");
 293 }
 294
 295 multiclass FLAT_Global_Store_AddTid_Pseudo<string opName, RegisterClass regClass> {
 296   def "" : FLAT_Global_Store_AddTid_Pseudo<opName, regClass>,
 297     GlobalSaddrTable<0, opName>;
 298   def _SADDR : FLAT_Global_Store_AddTid_Pseudo<opName, regClass, 1>,
 299     GlobalSaddrTable<1, opName>;
 300 }
 301
 302 class FlatScratchInst <string sv_op, string mode> {
 303   string SVOp = sv_op;
 304   string Mode = mode;
 305 }
 306
 307 class FLAT_Scratch_Load_Pseudo <string opName, RegisterClass regClass,
 308   bit HasTiedOutput = 0,
 309   bit EnableSaddr = 0,
 310   bit EnableSVE = 0,
 311   bit EnableVaddr = !or(EnableSVE, !not(EnableSaddr))>
 312   : FLAT_Pseudo<
 313   opName,
 314   (outs getLdStRegisterOperand<regClass>.ret:$vdst),
 315   !con(
 316     !if(EnableSVE,
 317         (ins VGPR_32:$vaddr, SReg_32_XEXEC_HI:$saddr, flat_offset:$offset),
 318         !if(EnableSaddr,
 319           (ins SReg_32_XEXEC_HI:$saddr, flat_offset:$offset),
 320           !if(EnableVaddr,
 321             (ins VGPR_32:$vaddr, flat_offset:$offset),
 322             (ins flat_offset:$offset)))),
 323      !if(HasTiedOutput, (ins CPol:$cpol, getLdStRegisterOperand<regClass>.ret:$vdst_in),
 324                         (ins CPol_0:$cpol))),
 325   " $vdst, "#!if(EnableVaddr, "$vaddr, ", "off, ")#!if(EnableSaddr, "$saddr", "off")#"$offset$cpol"> {
 326   let has_data = 0;
 327   let mayLoad = 1;
 328   let has_saddr = 1;
 329   let enabled_saddr = EnableSaddr;
 330   let has_vaddr = EnableVaddr;
 331   let has_sve = EnableSVE;
 332   let sve = EnableVaddr;
 333   let PseudoInstr = opName#!if(EnableSVE, "_SVS", !if(EnableSaddr, "_SADDR", !if(EnableVaddr, "", "_ST")));
 334   let maybeAtomic = 1;
 335
 336   let Constraints = !if(HasTiedOutput, "$vdst = $vdst_in", "");
 337   let DisableEncoding = !if(HasTiedOutput, "$vdst_in", "");
 338 }
 339
 340 class FLAT_Scratch_Store_Pseudo <string opName, RegisterClass vdataClass, bit EnableSaddr = 0,
 341   bit EnableSVE = 0,
 342   bit EnableVaddr = !or(EnableSVE, !not(EnableSaddr)),
 343   RegisterOperand vdata_op = getLdStRegisterOperand<vdataClass>.ret> : FLAT_Pseudo<
 344   opName,
 345   (outs),
 346   !if(EnableSVE,
 347     (ins vdata_op:$vdata, VGPR_32:$vaddr, SReg_32_XEXEC_HI:$saddr, flat_offset:$offset, CPol_0:$cpol),
 348     !if(EnableSaddr,
 349       (ins vdata_op:$vdata, SReg_32_XEXEC_HI:$saddr, flat_offset:$offset, CPol_0:$cpol),
 350       !if(EnableVaddr,
 351         (ins vdata_op:$vdata, VGPR_32:$vaddr, flat_offset:$offset, CPol_0:$cpol),
 352         (ins vdata_op:$vdata, flat_offset:$offset, CPol_0:$cpol)))),
 353   " "#!if(EnableVaddr, "$vaddr", "off")#", $vdata, "#!if(EnableSaddr, "$saddr", "off")#"$offset$cpol"> {
 354   let mayLoad  = 0;
 355   let mayStore = 1;
 356   let has_vdst = 0;
 357   let has_saddr = 1;
 358   let enabled_saddr = EnableSaddr;
 359   let has_vaddr = EnableVaddr;
 360   let has_sve = EnableSVE;
 361   let sve = EnableVaddr;
 362   let PseudoInstr = opName#!if(EnableSVE, "_SVS", !if(EnableSaddr, "_SADDR", !if(EnableVaddr, "", "_ST")));
 363   let maybeAtomic = 1;
 364 }
 365
 366 multiclass FLAT_Scratch_Load_Pseudo<string opName, RegisterClass regClass, bit HasTiedOutput = 0> {
 367   let is_flat_scratch = 1 in {
 368     def "" : FLAT_Scratch_Load_Pseudo<opName, regClass, HasTiedOutput>,
 369              FlatScratchInst<opName, "SV">;
 370     def _SADDR : FLAT_Scratch_Load_Pseudo<opName, regClass, HasTiedOutput, 1>,
 371                  FlatScratchInst<opName, "SS">;
 372
 373     let SubtargetPredicate = HasFlatScratchSVSMode in
 374     def _SVS : FLAT_Scratch_Load_Pseudo<opName, regClass, HasTiedOutput, 1, 1>,
 375                FlatScratchInst<opName, "SVS">;
 376
 377     let SubtargetPredicate = HasFlatScratchSTMode in
 378     def _ST  : FLAT_Scratch_Load_Pseudo<opName, regClass, HasTiedOutput, 0, 0, 0>,
 379                FlatScratchInst<opName, "ST">;
 380   }
 381 }
 382
 383 multiclass FLAT_Scratch_Store_Pseudo<string opName, RegisterClass regClass> {
 384   let is_flat_scratch = 1 in {
 385     def "" : FLAT_Scratch_Store_Pseudo<opName, regClass>,
 386              FlatScratchInst<opName, "SV">;
 387     def _SADDR : FLAT_Scratch_Store_Pseudo<opName, regClass, 1>,
 388                  FlatScratchInst<opName, "SS">;
 389
 390     let SubtargetPredicate = HasFlatScratchSVSMode in
 391     def _SVS : FLAT_Scratch_Store_Pseudo<opName, regClass, 1, 1>,
 392                FlatScratchInst<opName, "SVS">;
 393
 394     let SubtargetPredicate = HasFlatScratchSTMode in
 395     def _ST  : FLAT_Scratch_Store_Pseudo<opName, regClass, 0, 0, 0>,
 396                FlatScratchInst<opName, "ST">;
 397   }
 398 }
 399
 400 class FLAT_Scratch_Load_LDS_Pseudo <string opName, bit EnableSaddr = 0,
 401   bit EnableSVE = 0,
 402   bit EnableVaddr = !or(EnableSVE, !not(EnableSaddr))> : FLAT_Pseudo<
 403   opName,
 404   (outs ),
 405   !if(EnableSVE,
 406     (ins VGPR_32:$vaddr, SReg_32_XEXEC_HI:$saddr, flat_offset:$offset, CPol:$cpol),
 407     !if(EnableSaddr,
 408       (ins SReg_32_XEXEC_HI:$saddr, flat_offset:$offset, CPol:$cpol),
 409       !if(EnableVaddr,
 410         (ins VGPR_32:$vaddr, flat_offset:$offset, CPol:$cpol),
 411         (ins flat_offset:$offset, CPol:$cpol)))),
 412   " "#!if(EnableVaddr, "$vaddr, ", "off, ")#!if(EnableSaddr, "$saddr", "off")#"$offset$cpol"> {
 413
 414   let LGKM_CNT = 1;
 415   let is_flat_scratch = 1;
 416   let lds = 1;
 417   let has_data = 0;
 418   let has_vdst = 0;
 419   let mayLoad = 1;
 420   let mayStore = 1;
 421   let has_saddr = 1;
 422   let enabled_saddr = EnableSaddr;
 423   let has_vaddr = EnableVaddr;
 424   let has_sve = EnableSVE;
 425   let sve = EnableVaddr;
 426   let VALU = 1;
 427   let PseudoInstr = opName#!if(EnableSVE, "_SVS", !if(EnableSaddr, "_SADDR", !if(EnableVaddr, "", "_ST")));
 428   let Uses = [M0, EXEC];
 429   let SchedRW = [WriteVMEM, WriteLDS];
 430 }
 431
 432 multiclass FLAT_Scratch_Load_LDS_Pseudo<string opName> {
 433   def ""     : FLAT_Scratch_Load_LDS_Pseudo<opName>,
 434                FlatScratchInst<opName, "SV">;
 435   def _SADDR : FLAT_Scratch_Load_LDS_Pseudo<opName, 1>,
 436                FlatScratchInst<opName, "SS">;
 437   def _SVS   : FLAT_Scratch_Load_LDS_Pseudo<opName, 1, 1>,
 438                FlatScratchInst<opName, "SVS">;
 439   def _ST    : FLAT_Scratch_Load_LDS_Pseudo<opName, 0, 0, 0>,
 440                FlatScratchInst<opName, "ST">;
 441 }
 442
 443 class FLAT_AtomicNoRet_Pseudo<string opName, dag outs, dag ins,
 444                                string asm, list<dag> pattern = []> :
 445   FLAT_Pseudo<opName, outs, ins, asm, pattern> {
 446     let mayLoad = 1;
 447     let mayStore = 1;
 448     let has_glc  = 0;
 449     let glcValue = 0;
 450     let has_vdst = 0;
 451     let has_sccb  = 1;
 452     let sccbValue = 0;
 453     let maybeAtomic = 1;
 454     let IsAtomicNoRet = 1;
 455 }
 456
 457 class FLAT_AtomicRet_Pseudo<string opName, dag outs, dag ins,
 458                             string asm, list<dag> pattern = []>
 459   : FLAT_AtomicNoRet_Pseudo<opName, outs, ins, asm, pattern> {
 460   let hasPostISelHook = 1;
 461   let has_vdst = 1;
 462   let glcValue = 1;
 463   let sccbValue = 0;
 464   let IsAtomicNoRet = 0;
 465   let IsAtomicRet = 1;
 466   let PseudoInstr = NAME # "_RTN";
 467 }
 468
 469 multiclass FLAT_Atomic_Pseudo<
 470   string opName,
 471   RegisterClass vdst_rc,
 472   ValueType vt,
 473   ValueType data_vt = vt,
 474   RegisterClass data_rc = vdst_rc,
 475   bit isFP = isFloatType<data_vt>.ret,
 476   RegisterOperand data_op = getLdStRegisterOperand<data_rc>.ret> {
 477   def "" : FLAT_AtomicNoRet_Pseudo <opName,
 478     (outs),
 479     (ins VReg_64:$vaddr, data_op:$vdata, flat_offset:$offset, CPol_0:$cpol),
 480     " $vaddr, $vdata$offset$cpol">,
 481     GlobalSaddrTable<0, opName>,
 482     AtomicNoRet <opName, 0> {
 483     let PseudoInstr = NAME;
 484     let FPAtomic = isFP;
 485     let AddedComplexity = -1; // Prefer global atomics if available
 486   }
 487
 488   def _RTN : FLAT_AtomicRet_Pseudo <opName,
 489     (outs getLdStRegisterOperand<vdst_rc>.ret:$vdst),
 490     (ins VReg_64:$vaddr, data_op:$vdata, flat_offset:$offset, CPol_GLC1:$cpol),
 491     " $vdst, $vaddr, $vdata$offset$cpol">,
 492     GlobalSaddrTable<0, opName#"_rtn">,
 493     AtomicNoRet <opName, 1> {
 494     let FPAtomic = isFP;
 495     let AddedComplexity = -1; // Prefer global atomics if available
 496   }
 497 }
 498
 499 multiclass FLAT_Global_Atomic_Pseudo_NO_RTN<
 500   string opName,
 501   RegisterClass vdst_rc,
 502   ValueType vt,
 503   ValueType data_vt = vt,
 504   RegisterClass data_rc = vdst_rc,
 505   bit isFP = isFloatType<data_vt>.ret,
 506   RegisterOperand data_op = getLdStRegisterOperand<data_rc>.ret> {
 507
 508   def "" : FLAT_AtomicNoRet_Pseudo <opName,
 509     (outs),
 510     (ins VReg_64:$vaddr, data_op:$vdata, flat_offset:$offset, CPol_0:$cpol),
 511     " $vaddr, $vdata, off$offset$cpol">,
 512     GlobalSaddrTable<0, opName>,
 513     AtomicNoRet <opName, 0> {
 514     let has_saddr = 1;
 515     let PseudoInstr = NAME;
 516     let FPAtomic = isFP;
 517   }
 518
 519   def _SADDR : FLAT_AtomicNoRet_Pseudo <opName,
 520     (outs),
 521     (ins VGPR_32:$vaddr, data_op:$vdata, SReg_64:$saddr, flat_offset:$offset, CPol_0:$cpol),
 522     " $vaddr, $vdata, $saddr$offset$cpol">,
 523     GlobalSaddrTable<1, opName>,
 524     AtomicNoRet <opName#"_saddr", 0> {
 525     let has_saddr = 1;
 526     let enabled_saddr = 1;
 527     let PseudoInstr = NAME#"_SADDR";
 528     let FPAtomic = isFP;
 529   }
 530 }
 531
 532 multiclass FLAT_Global_Atomic_Pseudo_RTN<
 533   string opName,
 534   RegisterClass vdst_rc,
 535   ValueType vt,
 536   ValueType data_vt = vt,
 537   RegisterClass data_rc = vdst_rc,
 538   bit isFP = isFloatType<data_vt>.ret,
 539   RegisterOperand data_op = getLdStRegisterOperand<data_rc>.ret,
 540   RegisterOperand vdst_op = getLdStRegisterOperand<vdst_rc>.ret> {
 541
 542   def _RTN : FLAT_AtomicRet_Pseudo <opName,
 543     (outs vdst_op:$vdst),
 544       (ins VReg_64:$vaddr, data_op:$vdata, flat_offset:$offset, CPol_GLC1:$cpol),
 545     " $vdst, $vaddr, $vdata, off$offset$cpol">,
 546     GlobalSaddrTable<0, opName#"_rtn">,
 547     AtomicNoRet <opName, 1> {
 548     let has_saddr = 1;
 549     let FPAtomic = isFP;
 550   }
 551
 552   def _SADDR_RTN : FLAT_AtomicRet_Pseudo <opName,
 553     (outs vdst_op:$vdst),
 554       (ins VGPR_32:$vaddr, data_op:$vdata, SReg_64:$saddr, flat_offset:$offset, CPol_GLC1:$cpol),
 555     " $vdst, $vaddr, $vdata, $saddr$offset$cpol">,
 556     GlobalSaddrTable<1, opName#"_rtn">,
 557     AtomicNoRet <opName#"_saddr", 1> {
 558      let has_saddr = 1;
 559      let enabled_saddr = 1;
 560      let PseudoInstr = NAME#"_SADDR_RTN";
 561      let FPAtomic = isFP;
 562   }
 563 }
 564
 565 multiclass FLAT_Global_Atomic_Pseudo<
 566   string opName,
 567   RegisterClass vdst_rc,
 568   ValueType vt,
 569   ValueType data_vt = vt,
 570   RegisterClass data_rc = vdst_rc> {
 571   let is_flat_global = 1, SubtargetPredicate = HasFlatGlobalInsts in {
 572     defm "" : FLAT_Global_Atomic_Pseudo_NO_RTN<opName, vdst_rc, vt, data_vt, data_rc>;
 573     defm "" : FLAT_Global_Atomic_Pseudo_RTN<opName, vdst_rc, vt, data_vt, data_rc>;
 574   }
 575 }
 576
 577 //===----------------------------------------------------------------------===//
 578 // Flat Instructions
 579 //===----------------------------------------------------------------------===//
 580
 581 def FLAT_LOAD_UBYTE    : FLAT_Load_Pseudo <"flat_load_ubyte", VGPR_32>;
 582 def FLAT_LOAD_SBYTE    : FLAT_Load_Pseudo <"flat_load_sbyte", VGPR_32>;
 583 def FLAT_LOAD_USHORT   : FLAT_Load_Pseudo <"flat_load_ushort", VGPR_32>;
 584 def FLAT_LOAD_SSHORT   : FLAT_Load_Pseudo <"flat_load_sshort", VGPR_32>;
 585 def FLAT_LOAD_DWORD    : FLAT_Load_Pseudo <"flat_load_dword", VGPR_32>;
 586 def FLAT_LOAD_DWORDX2  : FLAT_Load_Pseudo <"flat_load_dwordx2", VReg_64>;
 587 def FLAT_LOAD_DWORDX4  : FLAT_Load_Pseudo <"flat_load_dwordx4", VReg_128>;
 588 def FLAT_LOAD_DWORDX3  : FLAT_Load_Pseudo <"flat_load_dwordx3", VReg_96>;
 589
 590 def FLAT_STORE_BYTE    : FLAT_Store_Pseudo <"flat_store_byte", VGPR_32>;
 591 def FLAT_STORE_SHORT   : FLAT_Store_Pseudo <"flat_store_short", VGPR_32>;
 592 def FLAT_STORE_DWORD   : FLAT_Store_Pseudo <"flat_store_dword", VGPR_32>;
 593 def FLAT_STORE_DWORDX2 : FLAT_Store_Pseudo <"flat_store_dwordx2", VReg_64>;
 594 def FLAT_STORE_DWORDX4 : FLAT_Store_Pseudo <"flat_store_dwordx4", VReg_128>;
 595 def FLAT_STORE_DWORDX3 : FLAT_Store_Pseudo <"flat_store_dwordx3", VReg_96>;
 596
 597 let SubtargetPredicate = HasD16LoadStore in {
 598 def FLAT_LOAD_UBYTE_D16     : FLAT_Load_Pseudo <"flat_load_ubyte_d16", VGPR_32, 1>;
 599 def FLAT_LOAD_UBYTE_D16_HI  : FLAT_Load_Pseudo <"flat_load_ubyte_d16_hi", VGPR_32, 1>;
 600 def FLAT_LOAD_SBYTE_D16     : FLAT_Load_Pseudo <"flat_load_sbyte_d16", VGPR_32, 1>;
 601 def FLAT_LOAD_SBYTE_D16_HI  : FLAT_Load_Pseudo <"flat_load_sbyte_d16_hi", VGPR_32, 1>;
 602 def FLAT_LOAD_SHORT_D16     : FLAT_Load_Pseudo <"flat_load_short_d16", VGPR_32, 1>;
 603 def FLAT_LOAD_SHORT_D16_HI  : FLAT_Load_Pseudo <"flat_load_short_d16_hi", VGPR_32, 1>;
 604
 605 def FLAT_STORE_BYTE_D16_HI  : FLAT_Store_Pseudo <"flat_store_byte_d16_hi", VGPR_32>;
 606 def FLAT_STORE_SHORT_D16_HI : FLAT_Store_Pseudo <"flat_store_short_d16_hi", VGPR_32>;
 607 }
 608
 609 defm FLAT_ATOMIC_CMPSWAP    : FLAT_Atomic_Pseudo <"flat_atomic_cmpswap",
 610                                 VGPR_32, i32, v2i32, VReg_64>;
 611
 612 defm FLAT_ATOMIC_CMPSWAP_X2 : FLAT_Atomic_Pseudo <"flat_atomic_cmpswap_x2",
 613                                 VReg_64, i64, v2i64, VReg_128>;
 614
 615 defm FLAT_ATOMIC_SWAP       : FLAT_Atomic_Pseudo <"flat_atomic_swap",
 616                                 VGPR_32, i32>;
 617
 618 defm FLAT_ATOMIC_SWAP_X2    : FLAT_Atomic_Pseudo <"flat_atomic_swap_x2",
 619                                 VReg_64, i64>;
 620
 621 defm FLAT_ATOMIC_ADD        : FLAT_Atomic_Pseudo <"flat_atomic_add",
 622                                 VGPR_32, i32>;
 623
 624 defm FLAT_ATOMIC_SUB        : FLAT_Atomic_Pseudo <"flat_atomic_sub",
 625                                 VGPR_32, i32>;
 626
 627 defm FLAT_ATOMIC_SMIN       : FLAT_Atomic_Pseudo <"flat_atomic_smin",
 628                                 VGPR_32, i32>;
 629
 630 defm FLAT_ATOMIC_UMIN       : FLAT_Atomic_Pseudo <"flat_atomic_umin",
 631                                 VGPR_32, i32>;
 632
 633 defm FLAT_ATOMIC_SMAX       : FLAT_Atomic_Pseudo <"flat_atomic_smax",
 634                                 VGPR_32, i32>;
 635
 636 defm FLAT_ATOMIC_UMAX       : FLAT_Atomic_Pseudo <"flat_atomic_umax",
 637                                 VGPR_32, i32>;
 638
 639 defm FLAT_ATOMIC_AND        : FLAT_Atomic_Pseudo <"flat_atomic_and",
 640                                 VGPR_32, i32>;
 641
 642 defm FLAT_ATOMIC_OR         : FLAT_Atomic_Pseudo <"flat_atomic_or",
 643                                 VGPR_32, i32>;
 644
 645 defm FLAT_ATOMIC_XOR        : FLAT_Atomic_Pseudo <"flat_atomic_xor",
 646                                 VGPR_32, i32>;
 647
 648 defm FLAT_ATOMIC_INC        : FLAT_Atomic_Pseudo <"flat_atomic_inc",
 649                                 VGPR_32, i32>;
 650
 651 defm FLAT_ATOMIC_DEC        : FLAT_Atomic_Pseudo <"flat_atomic_dec",
 652                                 VGPR_32, i32>;
 653
 654 defm FLAT_ATOMIC_ADD_X2     : FLAT_Atomic_Pseudo <"flat_atomic_add_x2",
 655                                 VReg_64, i64>;
 656
 657 defm FLAT_ATOMIC_SUB_X2     : FLAT_Atomic_Pseudo <"flat_atomic_sub_x2",
 658                                 VReg_64, i64>;
 659
 660 defm FLAT_ATOMIC_SMIN_X2    : FLAT_Atomic_Pseudo <"flat_atomic_smin_x2",
 661                                 VReg_64, i64>;
 662
 663 defm FLAT_ATOMIC_UMIN_X2    : FLAT_Atomic_Pseudo <"flat_atomic_umin_x2",
 664                                 VReg_64, i64>;
 665
 666 defm FLAT_ATOMIC_SMAX_X2    : FLAT_Atomic_Pseudo <"flat_atomic_smax_x2",
 667                                 VReg_64, i64>;
 668
 669 defm FLAT_ATOMIC_UMAX_X2    : FLAT_Atomic_Pseudo <"flat_atomic_umax_x2",
 670                                 VReg_64, i64>;
 671
 672 defm FLAT_ATOMIC_AND_X2     : FLAT_Atomic_Pseudo <"flat_atomic_and_x2",
 673                                 VReg_64, i64>;
 674
 675 defm FLAT_ATOMIC_OR_X2      : FLAT_Atomic_Pseudo <"flat_atomic_or_x2",
 676                                 VReg_64, i64>;
 677
 678 defm FLAT_ATOMIC_XOR_X2     : FLAT_Atomic_Pseudo <"flat_atomic_xor_x2",
 679                                 VReg_64, i64>;
 680
 681 defm FLAT_ATOMIC_INC_X2     : FLAT_Atomic_Pseudo <"flat_atomic_inc_x2",
 682                                 VReg_64, i64>;
 683
 684 defm FLAT_ATOMIC_DEC_X2     : FLAT_Atomic_Pseudo <"flat_atomic_dec_x2",
 685                                 VReg_64, i64>;
 686
 687 // GFX7-, GFX10-only flat instructions.
 688 let SubtargetPredicate = isGFX7GFX10 in {
 689
 690 defm FLAT_ATOMIC_FCMPSWAP_X2 : FLAT_Atomic_Pseudo <"flat_atomic_fcmpswap_x2",
 691                                 VReg_64, f64, v2f64, VReg_128>;
 692
 693 defm FLAT_ATOMIC_FMIN_X2     : FLAT_Atomic_Pseudo <"flat_atomic_fmin_x2",
 694                                 VReg_64, f64>;
 695
 696 defm FLAT_ATOMIC_FMAX_X2     : FLAT_Atomic_Pseudo <"flat_atomic_fmax_x2",
 697                                 VReg_64, f64>;
 698
 699 } // End SubtargetPredicate = isGFX7GFX10
 700
 701 let SubtargetPredicate = isGFX90APlus in {
 702   defm FLAT_ATOMIC_ADD_F64   : FLAT_Atomic_Pseudo<"flat_atomic_add_f64", VReg_64, f64>;
 703   defm FLAT_ATOMIC_MIN_F64   : FLAT_Atomic_Pseudo<"flat_atomic_min_f64", VReg_64, f64>;
 704   defm FLAT_ATOMIC_MAX_F64   : FLAT_Atomic_Pseudo<"flat_atomic_max_f64", VReg_64, f64>;
 705   defm GLOBAL_ATOMIC_ADD_F64 : FLAT_Global_Atomic_Pseudo<"global_atomic_add_f64", VReg_64, f64>;
 706   defm GLOBAL_ATOMIC_MIN_F64 : FLAT_Global_Atomic_Pseudo<"global_atomic_min_f64", VReg_64, f64>;
 707   defm GLOBAL_ATOMIC_MAX_F64 : FLAT_Global_Atomic_Pseudo<"global_atomic_max_f64", VReg_64, f64>;
 708 } // End SubtargetPredicate = isGFX90APlus
 709
 710 let SubtargetPredicate = isGFX940Plus in {
 711   defm FLAT_ATOMIC_PK_ADD_F16    : FLAT_Atomic_Pseudo<"flat_atomic_pk_add_f16",  VGPR_32, v2f16>;
 712   defm FLAT_ATOMIC_PK_ADD_BF16   : FLAT_Atomic_Pseudo<"flat_atomic_pk_add_bf16", VGPR_32, v2f16>;
 713   defm GLOBAL_ATOMIC_PK_ADD_BF16 : FLAT_Global_Atomic_Pseudo<"global_atomic_pk_add_bf16", VGPR_32, v2f16>;
 714 } // End SubtargetPredicate = isGFX940Plus
 715
 716 // GFX7-, GFX10-, GFX11-only flat instructions.
 717 let SubtargetPredicate = isGFX7GFX10GFX11 in {
 718
 719 defm FLAT_ATOMIC_FCMPSWAP    : FLAT_Atomic_Pseudo <"flat_atomic_fcmpswap",
 720                                 VGPR_32, f32, v2f32, VReg_64>;
 721
 722 defm FLAT_ATOMIC_FMIN        : FLAT_Atomic_Pseudo <"flat_atomic_fmin",
 723                                 VGPR_32, f32>;
 724
 725 defm FLAT_ATOMIC_FMAX        : FLAT_Atomic_Pseudo <"flat_atomic_fmax",
 726                                 VGPR_32, f32>;
 727
 728 } // End SubtargetPredicate = isGFX7GFX10GFX11
 729
 730 // GFX940-, GFX11-only flat instructions.
 731 let SubtargetPredicate = isGFX940GFX11Plus in {
 732   defm FLAT_ATOMIC_ADD_F32       : FLAT_Atomic_Pseudo<"flat_atomic_add_f32",     VGPR_32, f32>;
 733 } // End SubtargetPredicate = isGFX940GFX11Plus
 734
 735 defm GLOBAL_LOAD_UBYTE    : FLAT_Global_Load_Pseudo <"global_load_ubyte", VGPR_32>;
 736 defm GLOBAL_LOAD_SBYTE    : FLAT_Global_Load_Pseudo <"global_load_sbyte", VGPR_32>;
 737 defm GLOBAL_LOAD_USHORT   : FLAT_Global_Load_Pseudo <"global_load_ushort", VGPR_32>;
 738 defm GLOBAL_LOAD_SSHORT   : FLAT_Global_Load_Pseudo <"global_load_sshort", VGPR_32>;
 739 defm GLOBAL_LOAD_DWORD    : FLAT_Global_Load_Pseudo <"global_load_dword", VGPR_32>;
 740 defm GLOBAL_LOAD_DWORDX2  : FLAT_Global_Load_Pseudo <"global_load_dwordx2", VReg_64>;
 741 defm GLOBAL_LOAD_DWORDX3  : FLAT_Global_Load_Pseudo <"global_load_dwordx3", VReg_96>;
 742 defm GLOBAL_LOAD_DWORDX4  : FLAT_Global_Load_Pseudo <"global_load_dwordx4", VReg_128>;
 743
 744 defm GLOBAL_LOAD_UBYTE_D16    : FLAT_Global_Load_Pseudo <"global_load_ubyte_d16", VGPR_32, 1>;
 745 defm GLOBAL_LOAD_UBYTE_D16_HI : FLAT_Global_Load_Pseudo <"global_load_ubyte_d16_hi", VGPR_32, 1>;
 746 defm GLOBAL_LOAD_SBYTE_D16    : FLAT_Global_Load_Pseudo <"global_load_sbyte_d16", VGPR_32, 1>;
 747 defm GLOBAL_LOAD_SBYTE_D16_HI : FLAT_Global_Load_Pseudo <"global_load_sbyte_d16_hi", VGPR_32, 1>;
 748 defm GLOBAL_LOAD_SHORT_D16    : FLAT_Global_Load_Pseudo <"global_load_short_d16", VGPR_32, 1>;
 749 defm GLOBAL_LOAD_SHORT_D16_HI : FLAT_Global_Load_Pseudo <"global_load_short_d16_hi", VGPR_32, 1>;
 750 let OtherPredicates = [HasGFX10_BEncoding] in
 751 defm GLOBAL_LOAD_DWORD_ADDTID : FLAT_Global_Load_AddTid_Pseudo <"global_load_dword_addtid", VGPR_32>;
 752
 753 defm GLOBAL_STORE_BYTE    : FLAT_Global_Store_Pseudo <"global_store_byte", VGPR_32>;
 754 defm GLOBAL_STORE_SHORT   : FLAT_Global_Store_Pseudo <"global_store_short", VGPR_32>;
 755 defm GLOBAL_STORE_DWORD   : FLAT_Global_Store_Pseudo <"global_store_dword", VGPR_32>;
 756 defm GLOBAL_STORE_DWORDX2 : FLAT_Global_Store_Pseudo <"global_store_dwordx2", VReg_64>;
 757 defm GLOBAL_STORE_DWORDX3 : FLAT_Global_Store_Pseudo <"global_store_dwordx3", VReg_96>;
 758 defm GLOBAL_STORE_DWORDX4 : FLAT_Global_Store_Pseudo <"global_store_dwordx4", VReg_128>;
 759 let OtherPredicates = [HasGFX10_BEncoding] in
 760 defm GLOBAL_STORE_DWORD_ADDTID : FLAT_Global_Store_AddTid_Pseudo <"global_store_dword_addtid", VGPR_32>;
 761
 762 defm GLOBAL_STORE_BYTE_D16_HI  : FLAT_Global_Store_Pseudo <"global_store_byte_d16_hi", VGPR_32>;
 763 defm GLOBAL_STORE_SHORT_D16_HI : FLAT_Global_Store_Pseudo <"global_store_short_d16_hi", VGPR_32>;
 764
 765 let is_flat_global = 1 in {
 766 defm GLOBAL_ATOMIC_CMPSWAP : FLAT_Global_Atomic_Pseudo <"global_atomic_cmpswap",
 767                                VGPR_32, i32, v2i32, VReg_64>;
 768
 769 defm GLOBAL_ATOMIC_CMPSWAP_X2 : FLAT_Global_Atomic_Pseudo <"global_atomic_cmpswap_x2",
 770                                   VReg_64, i64, v2i64, VReg_128>;
 771
 772 defm GLOBAL_ATOMIC_SWAP : FLAT_Global_Atomic_Pseudo <"global_atomic_swap",
 773                              VGPR_32, i32>;
 774
 775 defm GLOBAL_ATOMIC_SWAP_X2 : FLAT_Global_Atomic_Pseudo <"global_atomic_swap_x2",
 776                                 VReg_64, i64>;
 777
 778 defm GLOBAL_ATOMIC_ADD : FLAT_Global_Atomic_Pseudo <"global_atomic_add",
 779                            VGPR_32, i32>;
 780
 781 defm GLOBAL_ATOMIC_SUB : FLAT_Global_Atomic_Pseudo <"global_atomic_sub",
 782                            VGPR_32, i32>;
 783
 784 defm GLOBAL_ATOMIC_SMIN : FLAT_Global_Atomic_Pseudo <"global_atomic_smin",
 785                             VGPR_32, i32>;
 786
 787 defm GLOBAL_ATOMIC_UMIN : FLAT_Global_Atomic_Pseudo <"global_atomic_umin",
 788                             VGPR_32, i32>;
 789
 790 defm GLOBAL_ATOMIC_SMAX : FLAT_Global_Atomic_Pseudo <"global_atomic_smax",
 791                             VGPR_32, i32>;
 792
 793 defm GLOBAL_ATOMIC_UMAX : FLAT_Global_Atomic_Pseudo <"global_atomic_umax",
 794                             VGPR_32, i32>;
 795
 796 defm GLOBAL_ATOMIC_AND : FLAT_Global_Atomic_Pseudo <"global_atomic_and",
 797                            VGPR_32, i32>;
 798
 799 defm GLOBAL_ATOMIC_OR : FLAT_Global_Atomic_Pseudo <"global_atomic_or",
 800                           VGPR_32, i32>;
 801
 802 defm GLOBAL_ATOMIC_XOR : FLAT_Global_Atomic_Pseudo <"global_atomic_xor",
 803                            VGPR_32, i32>;
 804
 805 defm GLOBAL_ATOMIC_INC : FLAT_Global_Atomic_Pseudo <"global_atomic_inc",
 806                            VGPR_32, i32>;
 807
 808 defm GLOBAL_ATOMIC_DEC : FLAT_Global_Atomic_Pseudo <"global_atomic_dec",
 809                            VGPR_32, i32>;
 810
 811 defm GLOBAL_ATOMIC_ADD_X2 : FLAT_Global_Atomic_Pseudo <"global_atomic_add_x2",
 812                               VReg_64, i64>;
 813
 814 defm GLOBAL_ATOMIC_SUB_X2 : FLAT_Global_Atomic_Pseudo <"global_atomic_sub_x2",
 815                               VReg_64, i64>;
 816
 817 defm GLOBAL_ATOMIC_SMIN_X2 : FLAT_Global_Atomic_Pseudo <"global_atomic_smin_x2",
 818                                VReg_64, i64>;
 819
 820 defm GLOBAL_ATOMIC_UMIN_X2 : FLAT_Global_Atomic_Pseudo <"global_atomic_umin_x2",
 821                                VReg_64, i64>;
 822
 823 defm GLOBAL_ATOMIC_SMAX_X2 : FLAT_Global_Atomic_Pseudo <"global_atomic_smax_x2",
 824                                VReg_64, i64>;
 825
 826 defm GLOBAL_ATOMIC_UMAX_X2 : FLAT_Global_Atomic_Pseudo <"global_atomic_umax_x2",
 827                                VReg_64, i64>;
 828
 829 defm GLOBAL_ATOMIC_AND_X2 : FLAT_Global_Atomic_Pseudo <"global_atomic_and_x2",
 830                               VReg_64, i64>;
 831
 832 defm GLOBAL_ATOMIC_OR_X2 : FLAT_Global_Atomic_Pseudo <"global_atomic_or_x2",
 833                              VReg_64, i64>;
 834
 835 defm GLOBAL_ATOMIC_XOR_X2 : FLAT_Global_Atomic_Pseudo <"global_atomic_xor_x2",
 836                               VReg_64, i64>;
 837
 838 defm GLOBAL_ATOMIC_INC_X2 : FLAT_Global_Atomic_Pseudo <"global_atomic_inc_x2",
 839                               VReg_64, i64>;
 840
 841 defm GLOBAL_ATOMIC_DEC_X2 : FLAT_Global_Atomic_Pseudo <"global_atomic_dec_x2",
 842                               VReg_64, i64>;
 843
 844 let SubtargetPredicate = HasGFX10_BEncoding in
 845 defm GLOBAL_ATOMIC_CSUB : FLAT_Global_Atomic_Pseudo_RTN <"global_atomic_csub",
 846                               VGPR_32, i32>;
 847
 848 defm GLOBAL_LOAD_LDS_UBYTE  : FLAT_Global_Load_LDS_Pseudo <"global_load_lds_ubyte">;
 849 defm GLOBAL_LOAD_LDS_SBYTE  : FLAT_Global_Load_LDS_Pseudo <"global_load_lds_sbyte">;
 850 defm GLOBAL_LOAD_LDS_USHORT : FLAT_Global_Load_LDS_Pseudo <"global_load_lds_ushort">;
 851 defm GLOBAL_LOAD_LDS_SSHORT : FLAT_Global_Load_LDS_Pseudo <"global_load_lds_sshort">;
 852 defm GLOBAL_LOAD_LDS_DWORD  : FLAT_Global_Load_LDS_Pseudo <"global_load_lds_dword">;
 853
 854 } // End is_flat_global = 1
 855
 856
 857
 858 let SubtargetPredicate = HasFlatScratchInsts in {
 859 defm SCRATCH_LOAD_UBYTE    : FLAT_Scratch_Load_Pseudo <"scratch_load_ubyte", VGPR_32>;
 860 defm SCRATCH_LOAD_SBYTE    : FLAT_Scratch_Load_Pseudo <"scratch_load_sbyte", VGPR_32>;
 861 defm SCRATCH_LOAD_USHORT   : FLAT_Scratch_Load_Pseudo <"scratch_load_ushort", VGPR_32>;
 862 defm SCRATCH_LOAD_SSHORT   : FLAT_Scratch_Load_Pseudo <"scratch_load_sshort", VGPR_32>;
 863 defm SCRATCH_LOAD_DWORD    : FLAT_Scratch_Load_Pseudo <"scratch_load_dword", VGPR_32>;
 864 defm SCRATCH_LOAD_DWORDX2  : FLAT_Scratch_Load_Pseudo <"scratch_load_dwordx2", VReg_64>;
 865 defm SCRATCH_LOAD_DWORDX3  : FLAT_Scratch_Load_Pseudo <"scratch_load_dwordx3", VReg_96>;
 866 defm SCRATCH_LOAD_DWORDX4  : FLAT_Scratch_Load_Pseudo <"scratch_load_dwordx4", VReg_128>;
 867
 868 defm SCRATCH_LOAD_UBYTE_D16    : FLAT_Scratch_Load_Pseudo <"scratch_load_ubyte_d16", VGPR_32, 1>;
 869 defm SCRATCH_LOAD_UBYTE_D16_HI : FLAT_Scratch_Load_Pseudo <"scratch_load_ubyte_d16_hi", VGPR_32, 1>;
 870 defm SCRATCH_LOAD_SBYTE_D16    : FLAT_Scratch_Load_Pseudo <"scratch_load_sbyte_d16", VGPR_32, 1>;
 871 defm SCRATCH_LOAD_SBYTE_D16_HI : FLAT_Scratch_Load_Pseudo <"scratch_load_sbyte_d16_hi", VGPR_32, 1>;
 872 defm SCRATCH_LOAD_SHORT_D16    : FLAT_Scratch_Load_Pseudo <"scratch_load_short_d16", VGPR_32, 1>;
 873 defm SCRATCH_LOAD_SHORT_D16_HI : FLAT_Scratch_Load_Pseudo <"scratch_load_short_d16_hi", VGPR_32, 1>;
 874
 875 defm SCRATCH_STORE_BYTE    : FLAT_Scratch_Store_Pseudo <"scratch_store_byte", VGPR_32>;
 876 defm SCRATCH_STORE_SHORT   : FLAT_Scratch_Store_Pseudo <"scratch_store_short", VGPR_32>;
 877 defm SCRATCH_STORE_DWORD   : FLAT_Scratch_Store_Pseudo <"scratch_store_dword", VGPR_32>;
 878 defm SCRATCH_STORE_DWORDX2 : FLAT_Scratch_Store_Pseudo <"scratch_store_dwordx2", VReg_64>;
 879 defm SCRATCH_STORE_DWORDX3 : FLAT_Scratch_Store_Pseudo <"scratch_store_dwordx3", VReg_96>;
 880 defm SCRATCH_STORE_DWORDX4 : FLAT_Scratch_Store_Pseudo <"scratch_store_dwordx4", VReg_128>;
 881
 882 defm SCRATCH_STORE_BYTE_D16_HI : FLAT_Scratch_Store_Pseudo <"scratch_store_byte_d16_hi", VGPR_32>;
 883 defm SCRATCH_STORE_SHORT_D16_HI : FLAT_Scratch_Store_Pseudo <"scratch_store_short_d16_hi", VGPR_32>;
 884
 885 defm SCRATCH_LOAD_LDS_UBYTE  : FLAT_Scratch_Load_LDS_Pseudo <"scratch_load_lds_ubyte">;
 886 defm SCRATCH_LOAD_LDS_SBYTE  : FLAT_Scratch_Load_LDS_Pseudo <"scratch_load_lds_sbyte">;
 887 defm SCRATCH_LOAD_LDS_USHORT : FLAT_Scratch_Load_LDS_Pseudo <"scratch_load_lds_ushort">;
 888 defm SCRATCH_LOAD_LDS_SSHORT : FLAT_Scratch_Load_LDS_Pseudo <"scratch_load_lds_sshort">;
 889 defm SCRATCH_LOAD_LDS_DWORD  : FLAT_Scratch_Load_LDS_Pseudo <"scratch_load_lds_dword">;
 890
 891 } // End SubtargetPredicate = HasFlatScratchInsts
 892
 893 let SubtargetPredicate = isGFX10Plus, is_flat_global = 1 in {
 894   defm GLOBAL_ATOMIC_FCMPSWAP :
 895     FLAT_Global_Atomic_Pseudo<"global_atomic_fcmpswap", VGPR_32, f32, v2f32, VReg_64>;
 896   defm GLOBAL_ATOMIC_FMIN :
 897     FLAT_Global_Atomic_Pseudo<"global_atomic_fmin", VGPR_32, f32>;
 898   defm GLOBAL_ATOMIC_FMAX :
 899     FLAT_Global_Atomic_Pseudo<"global_atomic_fmax", VGPR_32, f32>;
 900   defm GLOBAL_ATOMIC_FCMPSWAP_X2 :
 901     FLAT_Global_Atomic_Pseudo<"global_atomic_fcmpswap_x2", VReg_64, f64, v2f64, VReg_128>;
 902   defm GLOBAL_ATOMIC_FMIN_X2 :
 903     FLAT_Global_Atomic_Pseudo<"global_atomic_fmin_x2", VReg_64, f64>;
 904   defm GLOBAL_ATOMIC_FMAX_X2 :
 905     FLAT_Global_Atomic_Pseudo<"global_atomic_fmax_x2", VReg_64, f64>;
 906 } // End SubtargetPredicate = isGFX10Plus, is_flat_global = 1
 907
 908 let is_flat_global = 1 in {
 909 let OtherPredicates = [HasAtomicFaddNoRtnInsts] in
 910   defm GLOBAL_ATOMIC_ADD_F32 : FLAT_Global_Atomic_Pseudo_NO_RTN <
 911     "global_atomic_add_f32", VGPR_32, f32
 912   >;
 913 let OtherPredicates = [HasAtomicPkFaddNoRtnInsts] in
 914   defm GLOBAL_ATOMIC_PK_ADD_F16 : FLAT_Global_Atomic_Pseudo_NO_RTN <
 915     "global_atomic_pk_add_f16", VGPR_32, v2f16
 916   >;
 917 let OtherPredicates = [HasAtomicFaddRtnInsts] in
 918   defm GLOBAL_ATOMIC_ADD_F32 : FLAT_Global_Atomic_Pseudo_RTN <
 919     "global_atomic_add_f32", VGPR_32, f32
 920   >;
 921 let OtherPredicates = [isGFX90APlus] in
 922   defm GLOBAL_ATOMIC_PK_ADD_F16 : FLAT_Global_Atomic_Pseudo_RTN <
 923     "global_atomic_pk_add_f16", VGPR_32, v2f16
 924   >;
 925 } // End is_flat_global = 1
 926
 927 //===----------------------------------------------------------------------===//
 928 // Flat Patterns
 929 //===----------------------------------------------------------------------===//
 930
 931 // Patterns for global loads with no offset.
 932 class FlatLoadPat <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
 933   (vt (node (FlatOffset i64:$vaddr, i16:$offset))),
 934   (inst $vaddr, $offset)
 935 >;
 936
 937 class FlatLoadPat_D16 <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
 938   (node (FlatOffset (i64 VReg_64:$vaddr), i16:$offset), vt:$in),
 939   (inst $vaddr, $offset, 0, $in)
 940 >;
 941
 942 class FlatSignedLoadPat_D16 <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
 943   (node (GlobalOffset (i64 VReg_64:$vaddr), i16:$offset), vt:$in),
 944   (inst $vaddr, $offset, 0, $in)
 945 >;
 946
 947 class GlobalLoadSaddrPat_D16 <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
 948   (vt (node (GlobalSAddr (i64 SReg_64:$saddr), (i32 VGPR_32:$voffset), i16:$offset), vt:$in)),
 949   (inst $saddr, $voffset, $offset, 0, $in)
 950 >;
 951
 952 class FlatLoadSignedPat <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
 953   (vt (node (GlobalOffset (i64 VReg_64:$vaddr), i16:$offset))),
 954   (inst $vaddr, $offset)
 955 >;
 956
 957 class GlobalLoadSaddrPat <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
 958   (vt (node (GlobalSAddr (i64 SReg_64:$saddr), (i32 VGPR_32:$voffset), i16:$offset))),
 959   (inst $saddr, $voffset, $offset, 0)
 960 >;
 961
 962 class GlobalStoreSaddrPat <FLAT_Pseudo inst, SDPatternOperator node,
 963                            ValueType vt> : GCNPat <
 964   (node vt:$data, (GlobalSAddr (i64 SReg_64:$saddr), (i32 VGPR_32:$voffset), i16:$offset)),
 965   (inst $voffset, getVregSrcForVT<vt>.ret:$data, $saddr, $offset)
 966 >;
 967
 968 class GlobalAtomicStoreSaddrPat <FLAT_Pseudo inst, SDPatternOperator node,
 969                                  ValueType vt> : GCNPat <
 970   (node (GlobalSAddr (i64 SReg_64:$saddr), (i32 VGPR_32:$voffset), i16:$offset), vt:$data),
 971   (inst $voffset, getVregSrcForVT<vt>.ret:$data, $saddr, $offset)
 972 >;
 973
 974 class GlobalAtomicSaddrPat <FLAT_Pseudo inst, SDPatternOperator node,
 975                             ValueType vt, ValueType data_vt = vt> : GCNPat <
 976   (vt (node (GlobalSAddr (i64 SReg_64:$saddr), (i32 VGPR_32:$voffset), i16:$offset), data_vt:$data)),
 977   (inst $voffset, getVregSrcForVT<data_vt>.ret:$data, $saddr, $offset)
 978 >;
 979
 980 class GlobalAtomicNoRtnSaddrPat <FLAT_Pseudo inst, SDPatternOperator node,
 981                                  ValueType vt> : GCNPat <
 982   (node (GlobalSAddr (i64 SReg_64:$saddr), (i32 VGPR_32:$voffset), i16:$offset), vt:$data),
 983   (inst $voffset, getVregSrcForVT<vt>.ret:$data, $saddr, $offset)
 984 >;
 985
 986 class FlatStorePat <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
 987   (node vt:$data, (FlatOffset i64:$vaddr, i16:$offset)),
 988   (inst $vaddr, getVregSrcForVT<vt>.ret:$data, $offset)
 989 >;
 990
 991 class FlatStoreSignedPat <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
 992   (node vt:$data, (GlobalOffset i64:$vaddr, i16:$offset)),
 993   (inst $vaddr, getVregSrcForVT<vt>.ret:$data, $offset)
 994 >;
 995
 996 class FlatStoreAtomicPat <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
 997   // atomic store follows atomic binop convention so the address comes
 998   // first.
 999   (node (FlatOffset i64:$vaddr, i16:$offset), vt:$data),
1000   (inst $vaddr, getVregSrcForVT<vt>.ret:$data, $offset)
1001 >;
1002
1003 class FlatStoreSignedAtomicPat <FLAT_Pseudo inst, SDPatternOperator node,
1004                                 ValueType vt, ValueType data_vt = vt> : GCNPat <
1005   // atomic store follows atomic binop convention so the address comes
1006   // first.
1007   (node (GlobalOffset i64:$vaddr, i16:$offset), data_vt:$data),
1008   (inst $vaddr, getVregSrcForVT<data_vt>.ret:$data, $offset)
1009 >;
1010
1011 class FlatAtomicPatNoRtn <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
1012   (node (FlatOffset i64:$vaddr, i16:$offset), vt:$data),
1013   (inst VReg_64:$vaddr, getVregSrcForVT<vt>.ret:$data, $offset)
1014 >;
1015
1016 multiclass FlatAtomicPat <string inst, string node, ValueType vt,
1017                           ValueType data_vt = vt> {
1018   defvar rtnNode = !cast<PatFrags>(node#"_ret_"#vt.Size);
1019   defvar noRtnNode = !cast<PatFrags>(node#"_noret_"#vt.Size);
1020
1021   def : GCNPat <(vt (rtnNode (FlatOffset i64:$vaddr, i16:$offset), data_vt:$data)),
1022     (!cast<FLAT_Pseudo>(inst#"_RTN") VReg_64:$vaddr, getVregSrcForVT<data_vt>.ret:$data, $offset)>;
1023
1024   def : GCNPat <(vt (noRtnNode (FlatOffset i64:$vaddr, i16:$offset), data_vt:$data)),
1025     (!cast<FLAT_Pseudo>(inst) VReg_64:$vaddr, getVregSrcForVT<data_vt>.ret:$data, $offset)>;
1026 }
1027
1028 multiclass FlatSignedAtomicPat <string inst, string node, ValueType vt,
1029                                 ValueType data_vt = vt, bit isIntr = 0> {
1030   defvar rtnNode = !cast<PatFrags>(node # "_ret" # !if(isIntr, "", "_" # vt.Size));
1031   defvar noRtnNode = !cast<PatFrags>(node # "_noret" # !if(isIntr, "", "_" # vt.Size));
1032
1033   def : GCNPat <(vt (rtnNode (GlobalOffset i64:$vaddr, i16:$offset), data_vt:$data)),
1034     (!cast<FLAT_Pseudo>(inst#"_RTN") VReg_64:$vaddr, getVregSrcForVT<data_vt>.ret:$data, $offset)>;
1035
1036   def : GCNPat <(vt (noRtnNode (GlobalOffset i64:$vaddr, i16:$offset), data_vt:$data)),
1037     (!cast<FLAT_Pseudo>(inst) VReg_64:$vaddr, getVregSrcForVT<data_vt>.ret:$data, $offset)>;
1038 }
1039
1040 multiclass FlatSignedAtomicIntrPat <string inst, string node, ValueType vt,
1041                                     ValueType data_vt = vt> {
1042   defm : FlatSignedAtomicPat<inst, node, vt, data_vt, /* isIntr */ 1>;
1043 }
1044
1045 class FlatSignedAtomicPatNoRtn <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
1046   (node (GlobalOffset i64:$vaddr, i16:$offset), vt:$data),
1047   (inst VReg_64:$vaddr, getVregSrcForVT<vt>.ret:$data, $offset)
1048 >;
1049
1050 class FlatSignedAtomicPatRtn <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt,
1051                               ValueType data_vt = vt> : GCNPat <
1052   (vt (node (GlobalOffset i64:$vaddr, i16:$offset), data_vt:$data)),
1053   (inst VReg_64:$vaddr, getVregSrcForVT<data_vt>.ret:$data, $offset)
1054 >;
1055
1056 class ScratchLoadSignedPat <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
1057   (vt (node (ScratchOffset (i32 VGPR_32:$vaddr), i16:$offset))),
1058   (inst $vaddr, $offset)
1059 >;
1060
1061 class ScratchLoadSignedPat_D16 <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
1062   (node (ScratchOffset (i32 VGPR_32:$vaddr), i16:$offset), vt:$in),
1063   (inst $vaddr, $offset, 0, $in)
1064 >;
1065
1066 class ScratchStoreSignedPat <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
1067   (node vt:$data, (ScratchOffset (i32 VGPR_32:$vaddr), i16:$offset)),
1068   (inst getVregSrcForVT<vt>.ret:$data, $vaddr, $offset)
1069 >;
1070
1071 class ScratchLoadSaddrPat <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
1072   (vt (node (ScratchSAddr (i32 SGPR_32:$saddr), i16:$offset))),
1073   (inst $saddr, $offset)
1074 >;
1075
1076 class ScratchLoadSaddrPat_D16 <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
1077   (vt (node (ScratchSAddr (i32 SGPR_32:$saddr), i16:$offset), vt:$in)),
1078   (inst $saddr, $offset, 0, $in)
1079 >;
1080
1081 class ScratchStoreSaddrPat <FLAT_Pseudo inst, SDPatternOperator node,
1082                             ValueType vt> : GCNPat <
1083   (node vt:$data, (ScratchSAddr (i32 SGPR_32:$saddr), i16:$offset)),
1084   (inst getVregSrcForVT<vt>.ret:$data, $saddr, $offset)
1085 >;
1086
1087 class ScratchLoadSVaddrPat <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
1088   (vt (node (ScratchSVAddr (i32 VGPR_32:$vaddr), (i32 SGPR_32:$saddr), i16:$offset))),
1089   (inst $vaddr, $saddr, $offset, 0)
1090 >;
1091
1092 class ScratchStoreSVaddrPat <FLAT_Pseudo inst, SDPatternOperator node,
1093                              ValueType vt> : GCNPat <
1094   (node vt:$data, (ScratchSVAddr (i32 VGPR_32:$vaddr), (i32 SGPR_32:$saddr), i16:$offset)),
1095   (inst getVregSrcForVT<vt>.ret:$data, $vaddr, $saddr, $offset)
1096 >;
1097
1098 class ScratchLoadSVaddrPat_D16 <FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> : GCNPat <
1099   (vt (node (ScratchSVAddr (i32 VGPR_32:$vaddr), (i32 SGPR_32:$saddr), i16:$offset), vt:$in)),
1100   (inst $vaddr, $saddr, $offset, 0, $in)
1101 >;
1102
1103 let OtherPredicates = [HasFlatAddressSpace] in {
1104
1105 def : FlatLoadPat <FLAT_LOAD_UBYTE, atomic_load_8_flat, i32>;
1106 def : FlatLoadPat <FLAT_LOAD_UBYTE, atomic_load_8_flat, i16>;
1107 def : FlatLoadPat <FLAT_LOAD_USHORT, atomic_load_16_flat, i32>;
1108 def : FlatLoadPat <FLAT_LOAD_USHORT, atomic_load_16_flat, i16>;
1109 def : FlatLoadPat <FLAT_LOAD_UBYTE, extloadi8_flat, i32>;
1110 def : FlatLoadPat <FLAT_LOAD_UBYTE, zextloadi8_flat, i32>;
1111 def : FlatLoadPat <FLAT_LOAD_SBYTE, sextloadi8_flat, i32>;
1112 def : FlatLoadPat <FLAT_LOAD_UBYTE, extloadi8_flat, i16>;
1113 def : FlatLoadPat <FLAT_LOAD_UBYTE, zextloadi8_flat, i16>;
1114 def : FlatLoadPat <FLAT_LOAD_SBYTE, sextloadi8_flat, i16>;
1115 def : FlatLoadPat <FLAT_LOAD_USHORT, extloadi16_flat, i32>;
1116 def : FlatLoadPat <FLAT_LOAD_USHORT, zextloadi16_flat, i32>;
1117 def : FlatLoadPat <FLAT_LOAD_USHORT, load_flat, i16>;
1118 def : FlatLoadPat <FLAT_LOAD_SSHORT, sextloadi16_flat, i32>;
1119 def : FlatLoadPat <FLAT_LOAD_DWORDX3, load_flat, v3i32>;
1120
1121 def : FlatLoadPat <FLAT_LOAD_DWORD, atomic_load_32_flat, i32>;
1122 def : FlatLoadPat <FLAT_LOAD_DWORDX2, atomic_load_64_flat, i64>;
1123
1124 def : FlatStorePat <FLAT_STORE_BYTE, truncstorei8_flat, i32>;
1125 def : FlatStorePat <FLAT_STORE_SHORT, truncstorei16_flat, i32>;
1126
1127 foreach vt = Reg32Types.types in {
1128 def : FlatLoadPat <FLAT_LOAD_DWORD, load_flat, vt>;
1129 def : FlatStorePat <FLAT_STORE_DWORD, store_flat, vt>;
1130 }
1131
1132 foreach vt = VReg_64.RegTypes in {
1133 def : FlatStorePat <FLAT_STORE_DWORDX2, store_flat, vt>;
1134 def : FlatLoadPat <FLAT_LOAD_DWORDX2, load_flat, vt>;
1135 }
1136
1137 def : FlatStorePat <FLAT_STORE_DWORDX3, store_flat, v3i32>;
1138
1139 foreach vt = VReg_128.RegTypes in {
1140 def : FlatLoadPat <FLAT_LOAD_DWORDX4, load_flat, vt>;
1141 def : FlatStorePat <FLAT_STORE_DWORDX4, store_flat, vt>;
1142 }
1143
1144 def : FlatStoreAtomicPat <FLAT_STORE_DWORD, atomic_store_32_flat, i32>;
1145 def : FlatStoreAtomicPat <FLAT_STORE_DWORDX2, atomic_store_64_flat, i64>;
1146 def : FlatStoreAtomicPat <FLAT_STORE_BYTE, atomic_store_8_flat, i32>;
1147 def : FlatStoreAtomicPat <FLAT_STORE_BYTE, atomic_store_8_flat, i16>;
1148 def : FlatStoreAtomicPat <FLAT_STORE_SHORT, atomic_store_16_flat, i32>;
1149 def : FlatStoreAtomicPat <FLAT_STORE_SHORT, atomic_store_16_flat, i16>;
1150
1151 foreach as = [ "flat", "global" ] in {
1152 defm : FlatAtomicPat <"FLAT_ATOMIC_ADD", "atomic_load_add_"#as, i32>;
1153 defm : FlatAtomicPat <"FLAT_ATOMIC_SUB", "atomic_load_sub_"#as, i32>;
1154 defm : FlatAtomicPat <"FLAT_ATOMIC_INC", "atomic_inc_"#as, i32>;
1155 defm : FlatAtomicPat <"FLAT_ATOMIC_DEC", "atomic_dec_"#as, i32>;
1156 defm : FlatAtomicPat <"FLAT_ATOMIC_AND", "atomic_load_and_"#as, i32>;
1157 defm : FlatAtomicPat <"FLAT_ATOMIC_SMAX", "atomic_load_max_"#as, i32>;
1158 defm : FlatAtomicPat <"FLAT_ATOMIC_UMAX", "atomic_load_umax_"#as, i32>;
1159 defm : FlatAtomicPat <"FLAT_ATOMIC_SMIN", "atomic_load_min_"#as, i32>;
1160 defm : FlatAtomicPat <"FLAT_ATOMIC_UMIN", "atomic_load_umin_"#as, i32>;
1161 defm : FlatAtomicPat <"FLAT_ATOMIC_OR", "atomic_load_or_"#as, i32>;
1162 defm : FlatAtomicPat <"FLAT_ATOMIC_SWAP", "atomic_swap_"#as, i32>;
1163 defm : FlatAtomicPat <"FLAT_ATOMIC_CMPSWAP", "AMDGPUatomic_cmp_swap_"#as, i32, v2i32>;
1164 defm : FlatAtomicPat <"FLAT_ATOMIC_XOR", "atomic_load_xor_"#as, i32>;
1165
1166 defm : FlatAtomicPat <"FLAT_ATOMIC_ADD_X2", "atomic_load_add_"#as, i64>;
1167 defm : FlatAtomicPat <"FLAT_ATOMIC_SUB_X2", "atomic_load_sub_"#as, i64>;
1168 defm : FlatAtomicPat <"FLAT_ATOMIC_INC_X2", "atomic_inc_"#as, i64>;
1169 defm : FlatAtomicPat <"FLAT_ATOMIC_DEC_X2", "atomic_dec_"#as, i64>;
1170 defm : FlatAtomicPat <"FLAT_ATOMIC_AND_X2", "atomic_load_and_"#as, i64>;
1171 defm : FlatAtomicPat <"FLAT_ATOMIC_SMAX_X2", "atomic_load_max_"#as, i64>;
1172 defm : FlatAtomicPat <"FLAT_ATOMIC_UMAX_X2", "atomic_load_umax_"#as, i64>;
1173 defm : FlatAtomicPat <"FLAT_ATOMIC_SMIN_X2", "atomic_load_min_"#as, i64>;
1174 defm : FlatAtomicPat <"FLAT_ATOMIC_UMIN_X2", "atomic_load_umin_"#as, i64>;
1175 defm : FlatAtomicPat <"FLAT_ATOMIC_OR_X2", "atomic_load_or_"#as, i64>;
1176 defm : FlatAtomicPat <"FLAT_ATOMIC_SWAP_X2", "atomic_swap_"#as, i64>;
1177 defm : FlatAtomicPat <"FLAT_ATOMIC_CMPSWAP_X2", "AMDGPUatomic_cmp_swap_"#as, i64, v2i64>;
1178 defm : FlatAtomicPat <"FLAT_ATOMIC_XOR_X2", "atomic_load_xor_"#as, i64>;
1179 } // end foreach as
1180
1181 def : FlatStorePat <FLAT_STORE_BYTE, truncstorei8_flat, i16>;
1182 def : FlatStorePat <FLAT_STORE_SHORT, store_flat, i16>;
1183
1184 let OtherPredicates = [HasD16LoadStore] in {
1185 def : FlatStorePat <FLAT_STORE_SHORT_D16_HI, truncstorei16_hi16_flat, i32>;
1186 def : FlatStorePat <FLAT_STORE_BYTE_D16_HI, truncstorei8_hi16_flat, i32>;
1187 }
1188
1189 let OtherPredicates = [D16PreservesUnusedBits] in {
1190 def : FlatLoadPat_D16 <FLAT_LOAD_UBYTE_D16_HI, az_extloadi8_d16_hi_flat, v2i16>;
1191 def : FlatLoadPat_D16 <FLAT_LOAD_UBYTE_D16_HI, az_extloadi8_d16_hi_flat, v2f16>;
1192 def : FlatLoadPat_D16 <FLAT_LOAD_SBYTE_D16_HI, sextloadi8_d16_hi_flat, v2i16>;
1193 def : FlatLoadPat_D16 <FLAT_LOAD_SBYTE_D16_HI, sextloadi8_d16_hi_flat, v2f16>;
1194 def : FlatLoadPat_D16 <FLAT_LOAD_SHORT_D16_HI, load_d16_hi_flat, v2i16>;
1195 def : FlatLoadPat_D16 <FLAT_LOAD_SHORT_D16_HI, load_d16_hi_flat, v2f16>;
1196
1197 def : FlatLoadPat_D16 <FLAT_LOAD_UBYTE_D16, az_extloadi8_d16_lo_flat, v2i16>;
1198 def : FlatLoadPat_D16 <FLAT_LOAD_UBYTE_D16, az_extloadi8_d16_lo_flat, v2f16>;
1199 def : FlatLoadPat_D16 <FLAT_LOAD_SBYTE_D16, sextloadi8_d16_lo_flat, v2i16>;
1200 def : FlatLoadPat_D16 <FLAT_LOAD_SBYTE_D16, sextloadi8_d16_lo_flat, v2f16>;
1201 def : FlatLoadPat_D16 <FLAT_LOAD_SHORT_D16, load_d16_lo_flat, v2i16>;
1202 def : FlatLoadPat_D16 <FLAT_LOAD_SHORT_D16, load_d16_lo_flat, v2f16>;
1203 }
1204
1205 } // End OtherPredicates = [HasFlatAddressSpace]
1206
1207
1208 multiclass GlobalFLATLoadPats<FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> {
1209   def : FlatLoadSignedPat <inst, node, vt> {
1210     let AddedComplexity = 10;
1211   }
1212
1213   def : GlobalLoadSaddrPat<!cast<FLAT_Pseudo>(!cast<string>(inst)#"_SADDR"), node, vt> {
1214     let AddedComplexity = 11;
1215   }
1216 }
1217
1218 multiclass GlobalFLATLoadPats_D16<FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> {
1219   def : FlatSignedLoadPat_D16 <inst, node, vt> {
1220     let AddedComplexity = 10;
1221   }
1222
1223   def : GlobalLoadSaddrPat_D16<!cast<FLAT_Pseudo>(!cast<string>(inst)#"_SADDR"), node, vt> {
1224     let AddedComplexity = 11;
1225   }
1226 }
1227
1228 multiclass GlobalFLATStorePats<FLAT_Pseudo inst, SDPatternOperator node,
1229                                ValueType vt> {
1230   def : FlatStoreSignedPat <inst, node, vt> {
1231     let AddedComplexity = 10;
1232   }
1233
1234   def : GlobalStoreSaddrPat<!cast<FLAT_Pseudo>(!cast<string>(inst)#"_SADDR"), node, vt> {
1235     let AddedComplexity = 11;
1236   }
1237 }
1238
1239 // Deal with swapped operands for atomic_store vs. regular store
1240 multiclass GlobalFLATAtomicStorePats<FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> {
1241   def : FlatStoreSignedAtomicPat <inst, node, vt> {
1242     let AddedComplexity = 10;
1243   }
1244
1245   def : GlobalAtomicStoreSaddrPat<!cast<FLAT_Pseudo>(!cast<string>(inst)#"_SADDR"), node, vt> {
1246     let AddedComplexity = 11;
1247   }
1248 }
1249
1250 multiclass GlobalFLATAtomicPatsRtn<string nortn_inst_name, SDPatternOperator node,
1251                                    ValueType vt, ValueType data_vt = vt> {
1252   def : FlatSignedAtomicPatRtn <!cast<FLAT_Pseudo>(nortn_inst_name#"_RTN"), node, vt, data_vt> {
1253     let AddedComplexity = 10;
1254   }
1255
1256   def : GlobalAtomicSaddrPat<!cast<FLAT_Pseudo>(nortn_inst_name#"_SADDR_RTN"), node, vt, data_vt> {
1257     let AddedComplexity = 11;
1258   }
1259 }
1260
1261 multiclass GlobalFLATAtomicPats<string inst, string node, ValueType vt,
1262                                 ValueType data_vt = vt, bit isIntr = 0> {
1263   defvar rtnNode = !cast<PatFrags>(node # "_ret" # !if(isIntr, "", "_" # vt.Size));
1264   defvar noRtnNode = !cast<PatFrags>(node # "_noret" # !if(isIntr, "", "_" # vt.Size));
1265
1266   let AddedComplexity = 10 in {
1267     defm : FlatSignedAtomicPat <inst, node, vt, data_vt, isIntr>;
1268   }
1269
1270   let AddedComplexity = 11 in {
1271     def : GlobalAtomicSaddrPat<!cast<FLAT_Pseudo>(inst#"_SADDR"), noRtnNode, vt, data_vt>;
1272     def : GlobalAtomicSaddrPat<!cast<FLAT_Pseudo>(inst#"_SADDR_RTN"), rtnNode, vt, data_vt>;
1273   }
1274 }
1275
1276 multiclass GlobalFLATAtomicIntrPats<string inst, string node, ValueType vt,
1277                                     ValueType data_vt = vt> {
1278   defm : GlobalFLATAtomicPats<inst, node, vt, data_vt, /* isIntr */ 1>;
1279 }
1280
1281 multiclass GlobalFLATNoRtnAtomicPats<FLAT_Pseudo inst, SDPatternOperator node,
1282                                      ValueType vt> {
1283   def : FlatSignedAtomicPatNoRtn <inst, node, vt> {
1284     let AddedComplexity = 10;
1285   }
1286
1287   def : GlobalAtomicNoRtnSaddrPat<!cast<FLAT_Pseudo>(!cast<string>(inst)#"_SADDR"), node, vt> {
1288     let AddedComplexity = 11;
1289   }
1290 }
1291
1292 multiclass ScratchFLATLoadPats<FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> {
1293   def : ScratchLoadSignedPat <inst, node, vt> {
1294     let AddedComplexity = 25;
1295   }
1296
1297   def : ScratchLoadSaddrPat<!cast<FLAT_Pseudo>(!cast<string>(inst)#"_SADDR"), node, vt> {
1298     let AddedComplexity = 26;
1299   }
1300
1301   def : ScratchLoadSVaddrPat<!cast<FLAT_Pseudo>(!cast<string>(inst)#"_SVS"), node, vt> {
1302     let SubtargetPredicate = HasFlatScratchSVSMode;
1303     let AddedComplexity = 27;
1304   }
1305 }
1306
1307 multiclass ScratchFLATStorePats<FLAT_Pseudo inst, SDPatternOperator node,
1308                                ValueType vt> {
1309   def : ScratchStoreSignedPat <inst, node, vt> {
1310     let AddedComplexity = 25;
1311   }
1312
1313   def : ScratchStoreSaddrPat<!cast<FLAT_Pseudo>(!cast<string>(inst)#"_SADDR"), node, vt> {
1314     let AddedComplexity = 26;
1315   }
1316
1317   def : ScratchStoreSVaddrPat<!cast<FLAT_Pseudo>(!cast<string>(inst)#"_SVS"), node, vt> {
1318     let SubtargetPredicate = HasFlatScratchSVSMode;
1319     let AddedComplexity = 27;
1320   }
1321 }
1322
1323 multiclass ScratchFLATLoadPats_D16<FLAT_Pseudo inst, SDPatternOperator node, ValueType vt> {
1324   def : ScratchLoadSignedPat_D16 <inst, node, vt> {
1325     let AddedComplexity = 25;
1326   }
1327
1328   def : ScratchLoadSaddrPat_D16<!cast<FLAT_Pseudo>(!cast<string>(inst)#"_SADDR"), node, vt> {
1329     let AddedComplexity = 26;
1330   }
1331
1332   def : ScratchLoadSVaddrPat_D16 <!cast<FLAT_Pseudo>(!cast<string>(inst)#"_SVS"), node, vt> {
1333     let SubtargetPredicate = HasFlatScratchSVSMode;
1334     let AddedComplexity = 27;
1335   }
1336 }
1337
1338 let OtherPredicates = [HasFlatGlobalInsts] in {
1339
1340 defm : GlobalFLATLoadPats <GLOBAL_LOAD_UBYTE, atomic_load_8_global, i32>;
1341 defm : GlobalFLATLoadPats <GLOBAL_LOAD_UBYTE, atomic_load_8_global, i16>;
1342 defm : GlobalFLATLoadPats <GLOBAL_LOAD_USHORT, atomic_load_16_global, i32>;
1343 defm : GlobalFLATLoadPats <GLOBAL_LOAD_USHORT, atomic_load_16_global, i16>;
1344 defm : GlobalFLATLoadPats <GLOBAL_LOAD_UBYTE, extloadi8_global, i32>;
1345 defm : GlobalFLATLoadPats <GLOBAL_LOAD_UBYTE, zextloadi8_global, i32>;
1346 defm : GlobalFLATLoadPats <GLOBAL_LOAD_SBYTE, sextloadi8_global, i32>;
1347 defm : GlobalFLATLoadPats <GLOBAL_LOAD_UBYTE, extloadi8_global, i16>;
1348 defm : GlobalFLATLoadPats <GLOBAL_LOAD_UBYTE, zextloadi8_global, i16>;
1349 defm : GlobalFLATLoadPats <GLOBAL_LOAD_SBYTE, sextloadi8_global, i16>;
1350 defm : GlobalFLATLoadPats <GLOBAL_LOAD_USHORT, extloadi16_global, i32>;
1351 defm : GlobalFLATLoadPats <GLOBAL_LOAD_USHORT, zextloadi16_global, i32>;
1352 defm : GlobalFLATLoadPats <GLOBAL_LOAD_SSHORT, sextloadi16_global, i32>;
1353 defm : GlobalFLATLoadPats <GLOBAL_LOAD_USHORT, load_global, i16>;
1354
1355 foreach vt = Reg32Types.types in {
1356 defm : GlobalFLATLoadPats <GLOBAL_LOAD_DWORD, load_global, vt>;
1357 defm : GlobalFLATStorePats <GLOBAL_STORE_DWORD, store_global, vt>;
1358 }
1359
1360 foreach vt = VReg_64.RegTypes in {
1361 defm : GlobalFLATLoadPats <GLOBAL_LOAD_DWORDX2, load_global, vt>;
1362 defm : GlobalFLATStorePats <GLOBAL_STORE_DWORDX2, store_global, vt>;
1363 }
1364
1365 defm : GlobalFLATLoadPats <GLOBAL_LOAD_DWORDX3, load_global, v3i32>;
1366
1367 foreach vt = VReg_128.RegTypes in {
1368 defm : GlobalFLATLoadPats <GLOBAL_LOAD_DWORDX4, load_global, vt>;
1369 defm : GlobalFLATStorePats <GLOBAL_STORE_DWORDX4, store_global, vt>;
1370 }
1371
1372 // There is no distinction for atomic load lowering during selection;
1373 // the memory legalizer will set the cache bits and insert the
1374 // appropriate waits.
1375 defm : GlobalFLATLoadPats <GLOBAL_LOAD_DWORD, atomic_load_32_global, i32>;
1376 defm : GlobalFLATLoadPats <GLOBAL_LOAD_DWORDX2, atomic_load_64_global, i64>;
1377
1378 defm : GlobalFLATStorePats <GLOBAL_STORE_BYTE, truncstorei8_global, i32>;
1379 defm : GlobalFLATStorePats <GLOBAL_STORE_BYTE, truncstorei8_global, i16>;
1380 defm : GlobalFLATStorePats <GLOBAL_STORE_SHORT, truncstorei16_global, i32>;
1381 defm : GlobalFLATStorePats <GLOBAL_STORE_SHORT, store_global, i16>;
1382 defm : GlobalFLATStorePats <GLOBAL_STORE_DWORDX3, store_global, v3i32>;
1383
1384 let OtherPredicates = [HasD16LoadStore] in {
1385 defm : GlobalFLATStorePats <GLOBAL_STORE_SHORT_D16_HI, truncstorei16_hi16_global, i32>;
1386 defm : GlobalFLATStorePats <GLOBAL_STORE_BYTE_D16_HI, truncstorei8_hi16_global, i32>;
1387 }
1388
1389 let OtherPredicates = [D16PreservesUnusedBits] in {
1390 defm : GlobalFLATLoadPats_D16 <GLOBAL_LOAD_UBYTE_D16_HI, az_extloadi8_d16_hi_global, v2i16>;
1391 defm : GlobalFLATLoadPats_D16 <GLOBAL_LOAD_UBYTE_D16_HI, az_extloadi8_d16_hi_global, v2f16>;
1392 defm : GlobalFLATLoadPats_D16 <GLOBAL_LOAD_SBYTE_D16_HI, sextloadi8_d16_hi_global, v2i16>;
1393 defm : GlobalFLATLoadPats_D16 <GLOBAL_LOAD_SBYTE_D16_HI, sextloadi8_d16_hi_global, v2f16>;
1394 defm : GlobalFLATLoadPats_D16 <GLOBAL_LOAD_SHORT_D16_HI, load_d16_hi_global, v2i16>;
1395 defm : GlobalFLATLoadPats_D16 <GLOBAL_LOAD_SHORT_D16_HI, load_d16_hi_global, v2f16>;
1396
1397 defm : GlobalFLATLoadPats_D16 <GLOBAL_LOAD_UBYTE_D16, az_extloadi8_d16_lo_global, v2i16>;
1398 defm : GlobalFLATLoadPats_D16 <GLOBAL_LOAD_UBYTE_D16, az_extloadi8_d16_lo_global, v2f16>;
1399 defm : GlobalFLATLoadPats_D16 <GLOBAL_LOAD_SBYTE_D16, sextloadi8_d16_lo_global, v2i16>;
1400 defm : GlobalFLATLoadPats_D16 <GLOBAL_LOAD_SBYTE_D16, sextloadi8_d16_lo_global, v2f16>;
1401 defm : GlobalFLATLoadPats_D16 <GLOBAL_LOAD_SHORT_D16, load_d16_lo_global, v2i16>;
1402 defm : GlobalFLATLoadPats_D16 <GLOBAL_LOAD_SHORT_D16, load_d16_lo_global, v2f16>;
1403 }
1404
1405 defm : GlobalFLATAtomicStorePats <GLOBAL_STORE_BYTE, atomic_store_8_global, i32>;
1406 defm : GlobalFLATAtomicStorePats <GLOBAL_STORE_BYTE, atomic_store_8_global, i16>;
1407 defm : GlobalFLATAtomicStorePats <GLOBAL_STORE_SHORT, atomic_store_16_global, i32>;
1408 defm : GlobalFLATAtomicStorePats <GLOBAL_STORE_SHORT, atomic_store_16_global, i16>;
1409 defm : GlobalFLATAtomicStorePats <GLOBAL_STORE_DWORD, atomic_store_32_global, i32>;
1410 defm : GlobalFLATAtomicStorePats <GLOBAL_STORE_DWORDX2, atomic_store_64_global, i64>;
1411
1412 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_ADD", "atomic_load_add_global", i32>;
1413 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_SUB", "atomic_load_sub_global", i32>;
1414 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_INC", "atomic_inc_global", i32>;
1415 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_DEC", "atomic_dec_global", i32>;
1416 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_AND", "atomic_load_and_global", i32>;
1417 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_SMAX", "atomic_load_max_global", i32>;
1418 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_UMAX", "atomic_load_umax_global", i32>;
1419 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_SMIN", "atomic_load_min_global", i32>;
1420 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_UMIN", "atomic_load_umin_global", i32>;
1421 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_OR", "atomic_load_or_global", i32>;
1422 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_SWAP", "atomic_swap_global", i32>;
1423 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_CMPSWAP", "AMDGPUatomic_cmp_swap_global", i32, v2i32>;
1424 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_XOR", "atomic_load_xor_global", i32>;
1425 defm : GlobalFLATAtomicPatsRtn <"GLOBAL_ATOMIC_CSUB", int_amdgcn_global_atomic_csub, i32>;
1426
1427 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_ADD_X2", "atomic_load_add_global", i64>;
1428 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_SUB_X2", "atomic_load_sub_global", i64>;
1429 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_INC_X2", "atomic_inc_global", i64>;
1430 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_DEC_X2", "atomic_dec_global", i64>;
1431 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_AND_X2", "atomic_load_and_global", i64>;
1432 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_SMAX_X2", "atomic_load_max_global", i64>;
1433 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_UMAX_X2", "atomic_load_umax_global", i64>;
1434 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_SMIN_X2", "atomic_load_min_global", i64>;
1435 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_UMIN_X2", "atomic_load_umin_global", i64>;
1436 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_OR_X2", "atomic_load_or_global", i64>;
1437 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_SWAP_X2", "atomic_swap_global", i64>;
1438 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_CMPSWAP_X2", "AMDGPUatomic_cmp_swap_global", i64, v2i64>;
1439 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_XOR_X2", "atomic_load_xor_global", i64>;
1440
1441 let OtherPredicates = [isGFX10Plus] in {
1442 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_FMIN", "atomic_load_fmin_global", f32>;
1443 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_FMAX", "atomic_load_fmax_global", f32>;
1444 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_FMIN_X2", "atomic_load_fmin_global", f64>;
1445 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_FMAX_X2", "atomic_load_fmax_global", f64>;
1446 defm : GlobalFLATAtomicIntrPats <"GLOBAL_ATOMIC_FMIN", "int_amdgcn_global_atomic_fmin", f32>;
1447 defm : GlobalFLATAtomicIntrPats <"GLOBAL_ATOMIC_FMAX", "int_amdgcn_global_atomic_fmax", f32>;
1448 defm : GlobalFLATAtomicIntrPats <"GLOBAL_ATOMIC_FMIN_X2", "int_amdgcn_global_atomic_fmin", f64>;
1449 defm : GlobalFLATAtomicIntrPats <"GLOBAL_ATOMIC_FMAX_X2", "int_amdgcn_global_atomic_fmax", f64>;
1450 }
1451
1452 let OtherPredicates = [HasAtomicFaddNoRtnInsts] in
1453 defm : GlobalFLATNoRtnAtomicPats <GLOBAL_ATOMIC_ADD_F32,    atomic_load_fadd_global_noret_32, f32>;
1454 let OtherPredicates = [HasAtomicPkFaddNoRtnInsts] in
1455 defm : GlobalFLATNoRtnAtomicPats <GLOBAL_ATOMIC_PK_ADD_F16, atomic_load_fadd_v2f16_global_noret_32, v2f16>;
1456
1457 let OtherPredicates = [isGFX90APlus] in {
1458 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_ADD_F32", "atomic_load_fadd_global", f32>;
1459 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_PK_ADD_F16", "atomic_load_fadd_v2f16_global", v2f16>;
1460 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_ADD_F64", "atomic_load_fadd_global", f64>;
1461 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_MIN_F64", "atomic_load_fmin_global", f64>;
1462 defm : GlobalFLATAtomicPats <"GLOBAL_ATOMIC_MAX_F64", "atomic_load_fmax_global", f64>;
1463 defm : GlobalFLATAtomicIntrPats <"GLOBAL_ATOMIC_ADD_F32", "int_amdgcn_global_atomic_fadd", f32>;
1464 defm : GlobalFLATAtomicIntrPats <"GLOBAL_ATOMIC_ADD_F64", "int_amdgcn_global_atomic_fadd", f64>;
1465 defm : GlobalFLATAtomicIntrPats <"GLOBAL_ATOMIC_PK_ADD_F16", "int_amdgcn_global_atomic_fadd", v2f16>;
1466 defm : GlobalFLATAtomicIntrPats <"GLOBAL_ATOMIC_MIN_F64", "int_amdgcn_global_atomic_fmin", f64>;
1467 defm : GlobalFLATAtomicIntrPats <"GLOBAL_ATOMIC_MAX_F64", "int_amdgcn_global_atomic_fmax", f64>;
1468 defm : FlatSignedAtomicPat <"FLAT_ATOMIC_ADD_F64", "atomic_load_fadd_flat", f64>;
1469 defm : FlatSignedAtomicPat <"FLAT_ATOMIC_MIN_F64", "atomic_load_fmin_flat", f64>;
1470 defm : FlatSignedAtomicPat <"FLAT_ATOMIC_MAX_F64", "atomic_load_fmax_flat", f64>;
1471 defm : FlatSignedAtomicIntrPat <"FLAT_ATOMIC_ADD_F64", "int_amdgcn_flat_atomic_fadd", f64>;
1472 defm : FlatSignedAtomicIntrPat <"FLAT_ATOMIC_MIN_F64", "int_amdgcn_flat_atomic_fmin", f64>;
1473 defm : FlatSignedAtomicIntrPat <"FLAT_ATOMIC_MAX_F64", "int_amdgcn_flat_atomic_fmax", f64>;
1474 }
1475
1476 let OtherPredicates = [isGFX940Plus] in {
1477 defm : FlatSignedAtomicPat <"FLAT_ATOMIC_ADD_F32",    "atomic_load_fadd_flat",       f32>;
1478 defm : FlatSignedAtomicPat <"FLAT_ATOMIC_PK_ADD_F16", "atomic_load_fadd_v2f16_flat", v2f16>;
1479 defm : FlatSignedAtomicIntrPat <"FLAT_ATOMIC_ADD_F32",     "int_amdgcn_flat_atomic_fadd",        f32>;
1480 defm : FlatSignedAtomicIntrPat <"FLAT_ATOMIC_PK_ADD_F16",  "int_amdgcn_flat_atomic_fadd",        v2f16>;
1481 defm : FlatSignedAtomicIntrPat <"FLAT_ATOMIC_PK_ADD_BF16", "int_amdgcn_flat_atomic_fadd_v2bf16", v2i16>;
1482 defm : GlobalFLATAtomicIntrPats <"GLOBAL_ATOMIC_PK_ADD_BF16", "int_amdgcn_global_atomic_fadd_v2bf16", v2i16>;
1483 }
1484
1485 } // End OtherPredicates = [HasFlatGlobalInsts], AddedComplexity = 10
1486
1487 let OtherPredicates = [HasFlatScratchInsts, EnableFlatScratch] in {
1488
1489 defm : ScratchFLATLoadPats <SCRATCH_LOAD_UBYTE, extloadi8_private, i32>;
1490 defm : ScratchFLATLoadPats <SCRATCH_LOAD_UBYTE, zextloadi8_private, i32>;
1491 defm : ScratchFLATLoadPats <SCRATCH_LOAD_SBYTE, sextloadi8_private, i32>;
1492 defm : ScratchFLATLoadPats <SCRATCH_LOAD_UBYTE, extloadi8_private, i16>;
1493 defm : ScratchFLATLoadPats <SCRATCH_LOAD_UBYTE, zextloadi8_private, i16>;
1494 defm : ScratchFLATLoadPats <SCRATCH_LOAD_SBYTE, sextloadi8_private, i16>;
1495 defm : ScratchFLATLoadPats <SCRATCH_LOAD_USHORT, extloadi16_private, i32>;
1496 defm : ScratchFLATLoadPats <SCRATCH_LOAD_USHORT, zextloadi16_private, i32>;
1497 defm : ScratchFLATLoadPats <SCRATCH_LOAD_SSHORT, sextloadi16_private, i32>;
1498 defm : ScratchFLATLoadPats <SCRATCH_LOAD_USHORT, load_private, i16>;
1499
1500 foreach vt = Reg32Types.types in {
1501 defm : ScratchFLATLoadPats <SCRATCH_LOAD_DWORD, load_private, vt>;
1502 defm : ScratchFLATStorePats <SCRATCH_STORE_DWORD, store_private, vt>;
1503 }
1504
1505 foreach vt = VReg_64.RegTypes in {
1506 defm : ScratchFLATLoadPats <SCRATCH_LOAD_DWORDX2, load_private, vt>;
1507 defm : ScratchFLATStorePats <SCRATCH_STORE_DWORDX2, store_private, vt>;
1508 }
1509
1510 defm : ScratchFLATLoadPats <SCRATCH_LOAD_DWORDX3, load_private, v3i32>;
1511
1512 foreach vt = VReg_128.RegTypes in {
1513 defm : ScratchFLATLoadPats <SCRATCH_LOAD_DWORDX4, load_private, vt>;
1514 defm : ScratchFLATStorePats <SCRATCH_STORE_DWORDX4, store_private, vt>;
1515 }
1516
1517 defm : ScratchFLATStorePats <SCRATCH_STORE_BYTE, truncstorei8_private, i32>;
1518 defm : ScratchFLATStorePats <SCRATCH_STORE_BYTE, truncstorei8_private, i16>;
1519 defm : ScratchFLATStorePats <SCRATCH_STORE_SHORT, truncstorei16_private, i32>;
1520 defm : ScratchFLATStorePats <SCRATCH_STORE_SHORT, store_private, i16>;
1521 defm : ScratchFLATStorePats <SCRATCH_STORE_DWORDX3, store_private, v3i32>;
1522
1523 let OtherPredicates = [HasD16LoadStore, HasFlatScratchInsts, EnableFlatScratch] in {
1524 defm : ScratchFLATStorePats <SCRATCH_STORE_SHORT_D16_HI, truncstorei16_hi16_private, i32>;
1525 defm : ScratchFLATStorePats <SCRATCH_STORE_BYTE_D16_HI, truncstorei8_hi16_private, i32>;
1526 }
1527
1528 let OtherPredicates = [D16PreservesUnusedBits, HasFlatScratchInsts, EnableFlatScratch] in {
1529 defm : ScratchFLATLoadPats_D16 <SCRATCH_LOAD_UBYTE_D16_HI, az_extloadi8_d16_hi_private, v2i16>;
1530 defm : ScratchFLATLoadPats_D16 <SCRATCH_LOAD_UBYTE_D16_HI, az_extloadi8_d16_hi_private, v2f16>;
1531 defm : ScratchFLATLoadPats_D16 <SCRATCH_LOAD_SBYTE_D16_HI, sextloadi8_d16_hi_private, v2i16>;
1532 defm : ScratchFLATLoadPats_D16 <SCRATCH_LOAD_SBYTE_D16_HI, sextloadi8_d16_hi_private, v2f16>;
1533 defm : ScratchFLATLoadPats_D16 <SCRATCH_LOAD_SHORT_D16_HI, load_d16_hi_private, v2i16>;
1534 defm : ScratchFLATLoadPats_D16 <SCRATCH_LOAD_SHORT_D16_HI, load_d16_hi_private, v2f16>;
1535
1536 defm : ScratchFLATLoadPats_D16 <SCRATCH_LOAD_UBYTE_D16, az_extloadi8_d16_lo_private, v2i16>;
1537 defm : ScratchFLATLoadPats_D16 <SCRATCH_LOAD_UBYTE_D16, az_extloadi8_d16_lo_private, v2f16>;
1538 defm : ScratchFLATLoadPats_D16 <SCRATCH_LOAD_SBYTE_D16, sextloadi8_d16_lo_private, v2i16>;
1539 defm : ScratchFLATLoadPats_D16 <SCRATCH_LOAD_SBYTE_D16, sextloadi8_d16_lo_private, v2f16>;
1540 defm : ScratchFLATLoadPats_D16 <SCRATCH_LOAD_SHORT_D16, load_d16_lo_private, v2i16>;
1541 defm : ScratchFLATLoadPats_D16 <SCRATCH_LOAD_SHORT_D16, load_d16_lo_private, v2f16>;
1542 }
1543
1544 } // End OtherPredicates = [HasFlatScratchInsts,EnableFlatScratch]
1545
1546 //===----------------------------------------------------------------------===//
1547 // Target
1548 //===----------------------------------------------------------------------===//
1549
1550 //===----------------------------------------------------------------------===//
1551 // CI
1552 //===----------------------------------------------------------------------===//
1553
1554 class FLAT_Real_ci <bits<7> op, FLAT_Pseudo ps> :
1555   FLAT_Real <op, ps>,
1556   SIMCInstr <ps.PseudoInstr, SIEncodingFamily.SI> {
1557   let AssemblerPredicate = isGFX7Only;
1558   let DecoderNamespace="GFX7";
1559 }
1560
1561 def FLAT_LOAD_UBYTE_ci         : FLAT_Real_ci <0x8,  FLAT_LOAD_UBYTE>;
1562 def FLAT_LOAD_SBYTE_ci         : FLAT_Real_ci <0x9,  FLAT_LOAD_SBYTE>;
1563 def FLAT_LOAD_USHORT_ci        : FLAT_Real_ci <0xa,  FLAT_LOAD_USHORT>;
1564 def FLAT_LOAD_SSHORT_ci        : FLAT_Real_ci <0xb,  FLAT_LOAD_SSHORT>;
1565 def FLAT_LOAD_DWORD_ci         : FLAT_Real_ci <0xc,  FLAT_LOAD_DWORD>;
1566 def FLAT_LOAD_DWORDX2_ci       : FLAT_Real_ci <0xd,  FLAT_LOAD_DWORDX2>;
1567 def FLAT_LOAD_DWORDX4_ci       : FLAT_Real_ci <0xe,  FLAT_LOAD_DWORDX4>;
1568 def FLAT_LOAD_DWORDX3_ci       : FLAT_Real_ci <0xf,  FLAT_LOAD_DWORDX3>;
1569
1570 def FLAT_STORE_BYTE_ci         : FLAT_Real_ci <0x18, FLAT_STORE_BYTE>;
1571 def FLAT_STORE_SHORT_ci        : FLAT_Real_ci <0x1a, FLAT_STORE_SHORT>;
1572 def FLAT_STORE_DWORD_ci        : FLAT_Real_ci <0x1c, FLAT_STORE_DWORD>;
1573 def FLAT_STORE_DWORDX2_ci      : FLAT_Real_ci <0x1d, FLAT_STORE_DWORDX2>;
1574 def FLAT_STORE_DWORDX4_ci      : FLAT_Real_ci <0x1e, FLAT_STORE_DWORDX4>;
1575 def FLAT_STORE_DWORDX3_ci      : FLAT_Real_ci <0x1f, FLAT_STORE_DWORDX3>;
1576
1577 multiclass FLAT_Real_Atomics_ci <bits<7> op, FLAT_Pseudo ps> {
1578   def _ci     : FLAT_Real_ci<op, !cast<FLAT_Pseudo>(ps.PseudoInstr)>;
1579   def _RTN_ci : FLAT_Real_ci<op, !cast<FLAT_Pseudo>(ps.PseudoInstr # "_RTN")>;
1580 }
1581
1582 defm FLAT_ATOMIC_SWAP          : FLAT_Real_Atomics_ci <0x30, FLAT_ATOMIC_SWAP>;
1583 defm FLAT_ATOMIC_CMPSWAP       : FLAT_Real_Atomics_ci <0x31, FLAT_ATOMIC_CMPSWAP>;
1584 defm FLAT_ATOMIC_ADD           : FLAT_Real_Atomics_ci <0x32, FLAT_ATOMIC_ADD>;
1585 defm FLAT_ATOMIC_SUB           : FLAT_Real_Atomics_ci <0x33, FLAT_ATOMIC_SUB>;
1586 defm FLAT_ATOMIC_SMIN          : FLAT_Real_Atomics_ci <0x35, FLAT_ATOMIC_SMIN>;
1587 defm FLAT_ATOMIC_UMIN          : FLAT_Real_Atomics_ci <0x36, FLAT_ATOMIC_UMIN>;
1588 defm FLAT_ATOMIC_SMAX          : FLAT_Real_Atomics_ci <0x37, FLAT_ATOMIC_SMAX>;
1589 defm FLAT_ATOMIC_UMAX          : FLAT_Real_Atomics_ci <0x38, FLAT_ATOMIC_UMAX>;
1590 defm FLAT_ATOMIC_AND           : FLAT_Real_Atomics_ci <0x39, FLAT_ATOMIC_AND>;
1591 defm FLAT_ATOMIC_OR            : FLAT_Real_Atomics_ci <0x3a, FLAT_ATOMIC_OR>;
1592 defm FLAT_ATOMIC_XOR           : FLAT_Real_Atomics_ci <0x3b, FLAT_ATOMIC_XOR>;
1593 defm FLAT_ATOMIC_INC           : FLAT_Real_Atomics_ci <0x3c, FLAT_ATOMIC_INC>;
1594 defm FLAT_ATOMIC_DEC           : FLAT_Real_Atomics_ci <0x3d, FLAT_ATOMIC_DEC>;
1595 defm FLAT_ATOMIC_SWAP_X2       : FLAT_Real_Atomics_ci <0x50, FLAT_ATOMIC_SWAP_X2>;
1596 defm FLAT_ATOMIC_CMPSWAP_X2    : FLAT_Real_Atomics_ci <0x51, FLAT_ATOMIC_CMPSWAP_X2>;
1597 defm FLAT_ATOMIC_ADD_X2        : FLAT_Real_Atomics_ci <0x52, FLAT_ATOMIC_ADD_X2>;
1598 defm FLAT_ATOMIC_SUB_X2        : FLAT_Real_Atomics_ci <0x53, FLAT_ATOMIC_SUB_X2>;
1599 defm FLAT_ATOMIC_SMIN_X2       : FLAT_Real_Atomics_ci <0x55, FLAT_ATOMIC_SMIN_X2>;
1600 defm FLAT_ATOMIC_UMIN_X2       : FLAT_Real_Atomics_ci <0x56, FLAT_ATOMIC_UMIN_X2>;
1601 defm FLAT_ATOMIC_SMAX_X2       : FLAT_Real_Atomics_ci <0x57, FLAT_ATOMIC_SMAX_X2>;
1602 defm FLAT_ATOMIC_UMAX_X2       : FLAT_Real_Atomics_ci <0x58, FLAT_ATOMIC_UMAX_X2>;
1603 defm FLAT_ATOMIC_AND_X2        : FLAT_Real_Atomics_ci <0x59, FLAT_ATOMIC_AND_X2>;
1604 defm FLAT_ATOMIC_OR_X2         : FLAT_Real_Atomics_ci <0x5a, FLAT_ATOMIC_OR_X2>;
1605 defm FLAT_ATOMIC_XOR_X2        : FLAT_Real_Atomics_ci <0x5b, FLAT_ATOMIC_XOR_X2>;
1606 defm FLAT_ATOMIC_INC_X2        : FLAT_Real_Atomics_ci <0x5c, FLAT_ATOMIC_INC_X2>;
1607 defm FLAT_ATOMIC_DEC_X2        : FLAT_Real_Atomics_ci <0x5d, FLAT_ATOMIC_DEC_X2>;
1608
1609 // CI Only flat instructions
1610 defm FLAT_ATOMIC_FCMPSWAP      : FLAT_Real_Atomics_ci <0x3e, FLAT_ATOMIC_FCMPSWAP>;
1611 defm FLAT_ATOMIC_FMIN          : FLAT_Real_Atomics_ci <0x3f, FLAT_ATOMIC_FMIN>;
1612 defm FLAT_ATOMIC_FMAX          : FLAT_Real_Atomics_ci <0x40, FLAT_ATOMIC_FMAX>;
1613 defm FLAT_ATOMIC_FCMPSWAP_X2   : FLAT_Real_Atomics_ci <0x5e, FLAT_ATOMIC_FCMPSWAP_X2>;
1614 defm FLAT_ATOMIC_FMIN_X2       : FLAT_Real_Atomics_ci <0x5f, FLAT_ATOMIC_FMIN_X2>;
1615 defm FLAT_ATOMIC_FMAX_X2       : FLAT_Real_Atomics_ci <0x60, FLAT_ATOMIC_FMAX_X2>;
1616
1617
1618 //===----------------------------------------------------------------------===//
1619 // VI
1620 //===----------------------------------------------------------------------===//
1621
1622 class FLAT_Real_vi <bits<7> op, FLAT_Pseudo ps, bit has_sccb = ps.has_sccb> :
1623   FLAT_Real <op, ps>,
1624   SIMCInstr <ps.PseudoInstr, SIEncodingFamily.VI> {
1625   let AssemblerPredicate = isGFX8GFX9;
1626   let DecoderNamespace = "GFX8";
1627
1628   let Inst{25} = !if(has_sccb, cpol{CPolBit.SCC}, ps.sccbValue);
1629   let AsmString = ps.Mnemonic #
1630                   !subst("$sccb", !if(has_sccb, "$sccb",""), ps.AsmOperands);
1631 }
1632
1633 multiclass FLAT_Real_AllAddr_vi<bits<7> op,
1634   bit has_sccb = !cast<FLAT_Pseudo>(NAME).has_sccb> {
1635   def _vi : FLAT_Real_vi<op, !cast<FLAT_Pseudo>(NAME), has_sccb>;
1636   def _SADDR_vi : FLAT_Real_vi<op, !cast<FLAT_Pseudo>(NAME#"_SADDR"), has_sccb>;
1637 }
1638
1639 class FLAT_Real_gfx940 <bits<7> op, FLAT_Pseudo ps> :
1640   FLAT_Real <op, ps>,
1641   SIMCInstr <ps.PseudoInstr, SIEncodingFamily.GFX940> {
1642   let AssemblerPredicate = isGFX940Plus;
1643   let DecoderNamespace = "GFX9";
1644   let Inst{13} = ps.sve;
1645   let Inst{25} = !if(ps.has_sccb, cpol{CPolBit.SCC}, ps.sccbValue);
1646 }
1647
1648 multiclass FLAT_Real_AllAddr_SVE_vi<bits<7> op> {
1649   def _vi : FLAT_Real_vi<op, !cast<FLAT_Pseudo>(NAME)> {
1650     let AssemblerPredicate = isGFX8GFX9NotGFX940;
1651     let OtherPredicates = [isGFX8GFX9NotGFX940];
1652   }
1653   def _SADDR_vi : FLAT_Real_vi<op, !cast<FLAT_Pseudo>(NAME#"_SADDR")> {
1654     let DecoderNamespace = "GFX9";
1655   }
1656   let AssemblerPredicate = isGFX940Plus, SubtargetPredicate = isGFX940Plus in {
1657     def _VE_gfx940  : FLAT_Real_gfx940<op, !cast<FLAT_Pseudo>(NAME)>;
1658     def _SVS_gfx940 : FLAT_Real_gfx940<op, !cast<FLAT_Pseudo>(NAME#"_SVS")>;
1659     def _ST_gfx940  : FLAT_Real_gfx940<op, !cast<FLAT_Pseudo>(NAME#"_ST")>;
1660   }
1661 }
1662
1663 multiclass FLAT_Real_AllAddr_LDS<bits<7> op, bits<7> pre_gfx940_op,
1664   string pre_gfx940_name = !subst("_lds", "", !cast<FLAT_Pseudo>(NAME).PseudoInstr),
1665   bit has_sccb = !cast<FLAT_Pseudo>(NAME).has_sccb> {
1666
1667   let OtherPredicates = [isGFX8GFX9NotGFX940] in {
1668     def _vi : FLAT_Real_vi<pre_gfx940_op, !cast<FLAT_Pseudo>(NAME), has_sccb> {
1669       let AsmString = pre_gfx940_name # !cast<FLAT_Pseudo>(NAME).AsmOperands # " lds";
1670     }
1671     def _SADDR_vi : FLAT_Real_vi<pre_gfx940_op, !cast<FLAT_Pseudo>(NAME#"_SADDR"), has_sccb> {
1672       let AsmString = pre_gfx940_name # !cast<FLAT_Pseudo>(NAME#"_SADDR").AsmOperands # " lds";
1673     }
1674   }
1675
1676   let SubtargetPredicate = isGFX940Plus in {
1677     def _gfx940 : FLAT_Real_gfx940<op, !cast<FLAT_Pseudo>(NAME)>;
1678     def _SADDR_gfx940 : FLAT_Real_gfx940<op, !cast<FLAT_Pseudo>(NAME#"_SADDR")>;
1679   }
1680 }
1681
1682 multiclass FLAT_Real_AllAddr_SVE_LDS<bits<7> op, bits<7> pre_gfx940_op> {
1683   defm "" : FLAT_Real_AllAddr_LDS<op, pre_gfx940_op>;
1684   let SubtargetPredicate = isGFX940Plus in {
1685     def _SVS_gfx940 : FLAT_Real_gfx940<op, !cast<FLAT_Pseudo>(NAME#"_SVS")>;
1686     def _ST_gfx940  : FLAT_Real_gfx940<op, !cast<FLAT_Pseudo>(NAME#"_ST")>;
1687   }
1688 }
1689
1690 def FLAT_LOAD_UBYTE_vi         : FLAT_Real_vi <0x10, FLAT_LOAD_UBYTE>;
1691 def FLAT_LOAD_SBYTE_vi         : FLAT_Real_vi <0x11, FLAT_LOAD_SBYTE>;
1692 def FLAT_LOAD_USHORT_vi        : FLAT_Real_vi <0x12, FLAT_LOAD_USHORT>;
1693 def FLAT_LOAD_SSHORT_vi        : FLAT_Real_vi <0x13, FLAT_LOAD_SSHORT>;
1694 def FLAT_LOAD_DWORD_vi         : FLAT_Real_vi <0x14, FLAT_LOAD_DWORD>;
1695 def FLAT_LOAD_DWORDX2_vi       : FLAT_Real_vi <0x15, FLAT_LOAD_DWORDX2>;
1696 def FLAT_LOAD_DWORDX4_vi       : FLAT_Real_vi <0x17, FLAT_LOAD_DWORDX4>;
1697 def FLAT_LOAD_DWORDX3_vi       : FLAT_Real_vi <0x16, FLAT_LOAD_DWORDX3>;
1698
1699 def FLAT_STORE_BYTE_vi         : FLAT_Real_vi <0x18, FLAT_STORE_BYTE>;
1700 def FLAT_STORE_BYTE_D16_HI_vi  : FLAT_Real_vi <0x19, FLAT_STORE_BYTE_D16_HI>;
1701 def FLAT_STORE_SHORT_vi        : FLAT_Real_vi <0x1a, FLAT_STORE_SHORT>;
1702 def FLAT_STORE_SHORT_D16_HI_vi : FLAT_Real_vi <0x1b, FLAT_STORE_SHORT_D16_HI>;
1703 def FLAT_STORE_DWORD_vi        : FLAT_Real_vi <0x1c, FLAT_STORE_DWORD>;
1704 def FLAT_STORE_DWORDX2_vi      : FLAT_Real_vi <0x1d, FLAT_STORE_DWORDX2>;
1705 def FLAT_STORE_DWORDX4_vi      : FLAT_Real_vi <0x1f, FLAT_STORE_DWORDX4>;
1706 def FLAT_STORE_DWORDX3_vi      : FLAT_Real_vi <0x1e, FLAT_STORE_DWORDX3>;
1707
1708 def FLAT_LOAD_UBYTE_D16_vi    : FLAT_Real_vi <0x20, FLAT_LOAD_UBYTE_D16>;
1709 def FLAT_LOAD_UBYTE_D16_HI_vi : FLAT_Real_vi <0x21, FLAT_LOAD_UBYTE_D16_HI>;
1710 def FLAT_LOAD_SBYTE_D16_vi    : FLAT_Real_vi <0x22, FLAT_LOAD_SBYTE_D16>;
1711 def FLAT_LOAD_SBYTE_D16_HI_vi : FLAT_Real_vi <0x23, FLAT_LOAD_SBYTE_D16_HI>;
1712 def FLAT_LOAD_SHORT_D16_vi    : FLAT_Real_vi <0x24, FLAT_LOAD_SHORT_D16>;
1713 def FLAT_LOAD_SHORT_D16_HI_vi : FLAT_Real_vi <0x25, FLAT_LOAD_SHORT_D16_HI>;
1714
1715 multiclass FLAT_Real_Atomics_vi <bits<7> op, FLAT_Pseudo ps,
1716   bit has_sccb = !cast<FLAT_Pseudo>(NAME).has_sccb> {
1717   def _vi     : FLAT_Real_vi<op, !cast<FLAT_Pseudo>(ps.PseudoInstr), has_sccb>;
1718   def _RTN_vi : FLAT_Real_vi<op, !cast<FLAT_Pseudo>(ps.PseudoInstr # "_RTN"), has_sccb>;
1719 }
1720
1721 multiclass FLAT_Global_Real_Atomics_vi<bits<7> op,
1722   bit has_sccb = !cast<FLAT_Pseudo>(NAME).has_sccb> :
1723   FLAT_Real_AllAddr_vi<op, has_sccb> {
1724   def _RTN_vi  : FLAT_Real_vi <op, !cast<FLAT_Pseudo>(NAME#"_RTN"), has_sccb>;
1725   def _SADDR_RTN_vi : FLAT_Real_vi <op, !cast<FLAT_Pseudo>(NAME#"_SADDR_RTN"), has_sccb>;
1726 }
1727
1728
1729 defm FLAT_ATOMIC_SWAP       : FLAT_Real_Atomics_vi <0x40, FLAT_ATOMIC_SWAP>;
1730 defm FLAT_ATOMIC_CMPSWAP    : FLAT_Real_Atomics_vi <0x41, FLAT_ATOMIC_CMPSWAP>;
1731 defm FLAT_ATOMIC_ADD        : FLAT_Real_Atomics_vi <0x42, FLAT_ATOMIC_ADD>;
1732 defm FLAT_ATOMIC_SUB        : FLAT_Real_Atomics_vi <0x43, FLAT_ATOMIC_SUB>;
1733 defm FLAT_ATOMIC_SMIN       : FLAT_Real_Atomics_vi <0x44, FLAT_ATOMIC_SMIN>;
1734 defm FLAT_ATOMIC_UMIN       : FLAT_Real_Atomics_vi <0x45, FLAT_ATOMIC_UMIN>;
1735 defm FLAT_ATOMIC_SMAX       : FLAT_Real_Atomics_vi <0x46, FLAT_ATOMIC_SMAX>;
1736 defm FLAT_ATOMIC_UMAX       : FLAT_Real_Atomics_vi <0x47, FLAT_ATOMIC_UMAX>;
1737 defm FLAT_ATOMIC_AND        : FLAT_Real_Atomics_vi <0x48, FLAT_ATOMIC_AND>;
1738 defm FLAT_ATOMIC_OR         : FLAT_Real_Atomics_vi <0x49, FLAT_ATOMIC_OR>;
1739 defm FLAT_ATOMIC_XOR        : FLAT_Real_Atomics_vi <0x4a, FLAT_ATOMIC_XOR>;
1740 defm FLAT_ATOMIC_INC        : FLAT_Real_Atomics_vi <0x4b, FLAT_ATOMIC_INC>;
1741 defm FLAT_ATOMIC_DEC        : FLAT_Real_Atomics_vi <0x4c, FLAT_ATOMIC_DEC>;
1742 defm FLAT_ATOMIC_SWAP_X2    : FLAT_Real_Atomics_vi <0x60, FLAT_ATOMIC_SWAP_X2>;
1743 defm FLAT_ATOMIC_CMPSWAP_X2 : FLAT_Real_Atomics_vi <0x61, FLAT_ATOMIC_CMPSWAP_X2>;
1744 defm FLAT_ATOMIC_ADD_X2     : FLAT_Real_Atomics_vi <0x62, FLAT_ATOMIC_ADD_X2>;
1745 defm FLAT_ATOMIC_SUB_X2     : FLAT_Real_Atomics_vi <0x63, FLAT_ATOMIC_SUB_X2>;
1746 defm FLAT_ATOMIC_SMIN_X2    : FLAT_Real_Atomics_vi <0x64, FLAT_ATOMIC_SMIN_X2>;
1747 defm FLAT_ATOMIC_UMIN_X2    : FLAT_Real_Atomics_vi <0x65, FLAT_ATOMIC_UMIN_X2>;
1748 defm FLAT_ATOMIC_SMAX_X2    : FLAT_Real_Atomics_vi <0x66, FLAT_ATOMIC_SMAX_X2>;
1749 defm FLAT_ATOMIC_UMAX_X2    : FLAT_Real_Atomics_vi <0x67, FLAT_ATOMIC_UMAX_X2>;
1750 defm FLAT_ATOMIC_AND_X2     : FLAT_Real_Atomics_vi <0x68, FLAT_ATOMIC_AND_X2>;
1751 defm FLAT_ATOMIC_OR_X2      : FLAT_Real_Atomics_vi <0x69, FLAT_ATOMIC_OR_X2>;
1752 defm FLAT_ATOMIC_XOR_X2     : FLAT_Real_Atomics_vi <0x6a, FLAT_ATOMIC_XOR_X2>;
1753 defm FLAT_ATOMIC_INC_X2     : FLAT_Real_Atomics_vi <0x6b, FLAT_ATOMIC_INC_X2>;
1754 defm FLAT_ATOMIC_DEC_X2     : FLAT_Real_Atomics_vi <0x6c, FLAT_ATOMIC_DEC_X2>;
1755
1756 defm GLOBAL_LOAD_UBYTE : FLAT_Real_AllAddr_vi <0x10>;
1757 defm GLOBAL_LOAD_SBYTE : FLAT_Real_AllAddr_vi <0x11>;
1758 defm GLOBAL_LOAD_USHORT : FLAT_Real_AllAddr_vi <0x12>;
1759 defm GLOBAL_LOAD_SSHORT : FLAT_Real_AllAddr_vi <0x13>;
1760 defm GLOBAL_LOAD_DWORD : FLAT_Real_AllAddr_vi <0x14>;
1761 defm GLOBAL_LOAD_DWORDX2 : FLAT_Real_AllAddr_vi <0x15>;
1762 defm GLOBAL_LOAD_DWORDX3 : FLAT_Real_AllAddr_vi <0x16>;
1763 defm GLOBAL_LOAD_DWORDX4 : FLAT_Real_AllAddr_vi <0x17>;
1764
1765 defm GLOBAL_LOAD_UBYTE_D16    : FLAT_Real_AllAddr_vi <0x20>;
1766 defm GLOBAL_LOAD_UBYTE_D16_HI : FLAT_Real_AllAddr_vi <0x21>;
1767 defm GLOBAL_LOAD_SBYTE_D16    : FLAT_Real_AllAddr_vi <0x22>;
1768 defm GLOBAL_LOAD_SBYTE_D16_HI : FLAT_Real_AllAddr_vi <0x23>;
1769 defm GLOBAL_LOAD_SHORT_D16    : FLAT_Real_AllAddr_vi <0x24>;
1770 defm GLOBAL_LOAD_SHORT_D16_HI : FLAT_Real_AllAddr_vi <0x25>;
1771
1772 defm GLOBAL_STORE_BYTE : FLAT_Real_AllAddr_vi <0x18>;
1773 defm GLOBAL_STORE_BYTE_D16_HI : FLAT_Real_AllAddr_vi <0x19>;
1774 defm GLOBAL_STORE_SHORT : FLAT_Real_AllAddr_vi <0x1a>;
1775 defm GLOBAL_STORE_SHORT_D16_HI : FLAT_Real_AllAddr_vi <0x1b>;
1776 defm GLOBAL_STORE_DWORD : FLAT_Real_AllAddr_vi <0x1c>;
1777 defm GLOBAL_STORE_DWORDX2 : FLAT_Real_AllAddr_vi <0x1d>;
1778 defm GLOBAL_STORE_DWORDX3 : FLAT_Real_AllAddr_vi <0x1e>;
1779 defm GLOBAL_STORE_DWORDX4 : FLAT_Real_AllAddr_vi <0x1f>;
1780
1781 defm GLOBAL_LOAD_LDS_UBYTE  : FLAT_Real_AllAddr_LDS <0x026, 0x10>;
1782 defm GLOBAL_LOAD_LDS_SBYTE  : FLAT_Real_AllAddr_LDS <0x027, 0x11>;
1783 defm GLOBAL_LOAD_LDS_USHORT : FLAT_Real_AllAddr_LDS <0x028, 0x12>;
1784 defm GLOBAL_LOAD_LDS_SSHORT : FLAT_Real_AllAddr_LDS <0x029, 0x13>;
1785 defm GLOBAL_LOAD_LDS_DWORD  : FLAT_Real_AllAddr_LDS <0x02a, 0x14>;
1786
1787 defm GLOBAL_ATOMIC_SWAP       : FLAT_Global_Real_Atomics_vi <0x40>;
1788 defm GLOBAL_ATOMIC_CMPSWAP    : FLAT_Global_Real_Atomics_vi <0x41>;
1789 defm GLOBAL_ATOMIC_ADD        : FLAT_Global_Real_Atomics_vi <0x42>;
1790 defm GLOBAL_ATOMIC_SUB        : FLAT_Global_Real_Atomics_vi <0x43>;
1791 defm GLOBAL_ATOMIC_SMIN       : FLAT_Global_Real_Atomics_vi <0x44>;
1792 defm GLOBAL_ATOMIC_UMIN       : FLAT_Global_Real_Atomics_vi <0x45>;
1793 defm GLOBAL_ATOMIC_SMAX       : FLAT_Global_Real_Atomics_vi <0x46>;
1794 defm GLOBAL_ATOMIC_UMAX       : FLAT_Global_Real_Atomics_vi <0x47>;
1795 defm GLOBAL_ATOMIC_AND        : FLAT_Global_Real_Atomics_vi <0x48>;
1796 defm GLOBAL_ATOMIC_OR         : FLAT_Global_Real_Atomics_vi <0x49>;
1797 defm GLOBAL_ATOMIC_XOR        : FLAT_Global_Real_Atomics_vi <0x4a>;
1798 defm GLOBAL_ATOMIC_INC        : FLAT_Global_Real_Atomics_vi <0x4b>;
1799 defm GLOBAL_ATOMIC_DEC        : FLAT_Global_Real_Atomics_vi <0x4c>;
1800 defm GLOBAL_ATOMIC_SWAP_X2    : FLAT_Global_Real_Atomics_vi <0x60>;
1801 defm GLOBAL_ATOMIC_CMPSWAP_X2 : FLAT_Global_Real_Atomics_vi <0x61>;
1802 defm GLOBAL_ATOMIC_ADD_X2     : FLAT_Global_Real_Atomics_vi <0x62>;
1803 defm GLOBAL_ATOMIC_SUB_X2     : FLAT_Global_Real_Atomics_vi <0x63>;
1804 defm GLOBAL_ATOMIC_SMIN_X2    : FLAT_Global_Real_Atomics_vi <0x64>;
1805 defm GLOBAL_ATOMIC_UMIN_X2    : FLAT_Global_Real_Atomics_vi <0x65>;
1806 defm GLOBAL_ATOMIC_SMAX_X2    : FLAT_Global_Real_Atomics_vi <0x66>;
1807 defm GLOBAL_ATOMIC_UMAX_X2    : FLAT_Global_Real_Atomics_vi <0x67>;
1808 defm GLOBAL_ATOMIC_AND_X2     : FLAT_Global_Real_Atomics_vi <0x68>;
1809 defm GLOBAL_ATOMIC_OR_X2      : FLAT_Global_Real_Atomics_vi <0x69>;
1810 defm GLOBAL_ATOMIC_XOR_X2     : FLAT_Global_Real_Atomics_vi <0x6a>;
1811 defm GLOBAL_ATOMIC_INC_X2     : FLAT_Global_Real_Atomics_vi <0x6b>;
1812 defm GLOBAL_ATOMIC_DEC_X2     : FLAT_Global_Real_Atomics_vi <0x6c>;
1813
1814 defm SCRATCH_LOAD_LDS_UBYTE  : FLAT_Real_AllAddr_SVE_LDS <0x026, 0x10>;
1815 defm SCRATCH_LOAD_LDS_SBYTE  : FLAT_Real_AllAddr_SVE_LDS <0x027, 0x11>;
1816 defm SCRATCH_LOAD_LDS_USHORT : FLAT_Real_AllAddr_SVE_LDS <0x028, 0x12>;
1817 defm SCRATCH_LOAD_LDS_SSHORT : FLAT_Real_AllAddr_SVE_LDS <0x029, 0x13>;
1818 defm SCRATCH_LOAD_LDS_DWORD  : FLAT_Real_AllAddr_SVE_LDS <0x02a, 0x14>;
1819
1820 defm SCRATCH_LOAD_UBYTE         : FLAT_Real_AllAddr_SVE_vi <0x10>;
1821 defm SCRATCH_LOAD_SBYTE         : FLAT_Real_AllAddr_SVE_vi <0x11>;
1822 defm SCRATCH_LOAD_USHORT        : FLAT_Real_AllAddr_SVE_vi <0x12>;
1823 defm SCRATCH_LOAD_SSHORT        : FLAT_Real_AllAddr_SVE_vi <0x13>;
1824 defm SCRATCH_LOAD_DWORD         : FLAT_Real_AllAddr_SVE_vi <0x14>;
1825 defm SCRATCH_LOAD_DWORDX2       : FLAT_Real_AllAddr_SVE_vi <0x15>;
1826 defm SCRATCH_LOAD_DWORDX3       : FLAT_Real_AllAddr_SVE_vi <0x16>;
1827 defm SCRATCH_LOAD_DWORDX4       : FLAT_Real_AllAddr_SVE_vi <0x17>;
1828 defm SCRATCH_STORE_BYTE         : FLAT_Real_AllAddr_SVE_vi <0x18>;
1829 defm SCRATCH_STORE_BYTE_D16_HI  : FLAT_Real_AllAddr_SVE_vi <0x19>;
1830 defm SCRATCH_LOAD_UBYTE_D16     : FLAT_Real_AllAddr_SVE_vi <0x20>;
1831 defm SCRATCH_LOAD_UBYTE_D16_HI  : FLAT_Real_AllAddr_SVE_vi <0x21>;
1832 defm SCRATCH_LOAD_SBYTE_D16     : FLAT_Real_AllAddr_SVE_vi <0x22>;
1833 defm SCRATCH_LOAD_SBYTE_D16_HI  : FLAT_Real_AllAddr_SVE_vi <0x23>;
1834 defm SCRATCH_LOAD_SHORT_D16     : FLAT_Real_AllAddr_SVE_vi <0x24>;
1835 defm SCRATCH_LOAD_SHORT_D16_HI  : FLAT_Real_AllAddr_SVE_vi <0x25>;
1836 defm SCRATCH_STORE_SHORT        : FLAT_Real_AllAddr_SVE_vi <0x1a>;
1837 defm SCRATCH_STORE_SHORT_D16_HI : FLAT_Real_AllAddr_SVE_vi <0x1b>;
1838 defm SCRATCH_STORE_DWORD        : FLAT_Real_AllAddr_SVE_vi <0x1c>;
1839 defm SCRATCH_STORE_DWORDX2      : FLAT_Real_AllAddr_SVE_vi <0x1d>;
1840 defm SCRATCH_STORE_DWORDX3      : FLAT_Real_AllAddr_SVE_vi <0x1e>;
1841 defm SCRATCH_STORE_DWORDX4      : FLAT_Real_AllAddr_SVE_vi <0x1f>;
1842
1843 let SubtargetPredicate = isGFX8GFX9NotGFX940 in {
1844   // These instructions are encoded differently on gfx90* and gfx940.
1845   defm GLOBAL_ATOMIC_ADD_F32    : FLAT_Global_Real_Atomics_vi <0x04d, 0>;
1846   defm GLOBAL_ATOMIC_PK_ADD_F16 : FLAT_Global_Real_Atomics_vi <0x04e, 0>;
1847 }
1848
1849 let SubtargetPredicate = isGFX90AOnly in {
1850   defm FLAT_ATOMIC_ADD_F64   : FLAT_Real_Atomics_vi<0x4f, FLAT_ATOMIC_ADD_F64, 0>;
1851   defm FLAT_ATOMIC_MIN_F64   : FLAT_Real_Atomics_vi<0x50, FLAT_ATOMIC_MIN_F64, 0>;
1852   defm FLAT_ATOMIC_MAX_F64   : FLAT_Real_Atomics_vi<0x51, FLAT_ATOMIC_MAX_F64, 0>;
1853   defm GLOBAL_ATOMIC_ADD_F64 : FLAT_Global_Real_Atomics_vi<0x4f, 0>;
1854   defm GLOBAL_ATOMIC_MIN_F64 : FLAT_Global_Real_Atomics_vi<0x50, 0>;
1855   defm GLOBAL_ATOMIC_MAX_F64 : FLAT_Global_Real_Atomics_vi<0x51, 0>;
1856 } // End SubtargetPredicate = isGFX90AOnly
1857
1858 multiclass FLAT_Real_AllAddr_gfx940<bits<7> op> {
1859   def _gfx940       : FLAT_Real_gfx940<op, !cast<FLAT_Pseudo>(NAME)>;
1860   def _SADDR_gfx940 : FLAT_Real_gfx940<op, !cast<FLAT_Pseudo>(NAME#"_SADDR")>;
1861 }
1862
1863 multiclass FLAT_Real_Atomics_gfx940 <bits<7> op, FLAT_Pseudo ps> {
1864   def _gfx940     : FLAT_Real_gfx940<op, !cast<FLAT_Pseudo>(ps.PseudoInstr)>;
1865   def _RTN_gfx940 : FLAT_Real_gfx940<op, !cast<FLAT_Pseudo>(ps.PseudoInstr # "_RTN")>;
1866 }
1867
1868 multiclass FLAT_Global_Real_Atomics_gfx940<bits<7> op> :
1869   FLAT_Real_AllAddr_gfx940<op> {
1870   def _RTN_gfx940       : FLAT_Real_gfx940 <op, !cast<FLAT_Pseudo>(NAME#"_RTN")>;
1871   def _SADDR_RTN_gfx940 : FLAT_Real_gfx940 <op, !cast<FLAT_Pseudo>(NAME#"_SADDR_RTN")>;
1872 }
1873
1874 let SubtargetPredicate = isGFX940Plus in {
1875   // These instructions are encoded differently on gfx90* and gfx940.
1876   defm GLOBAL_ATOMIC_ADD_F32     : FLAT_Global_Real_Atomics_gfx940 <0x04d>;
1877   defm GLOBAL_ATOMIC_PK_ADD_F16  : FLAT_Global_Real_Atomics_gfx940 <0x04e>;
1878
1879   defm FLAT_ATOMIC_ADD_F64       : FLAT_Real_Atomics_gfx940<0x4f, FLAT_ATOMIC_ADD_F64>;
1880   defm FLAT_ATOMIC_MIN_F64       : FLAT_Real_Atomics_gfx940<0x50, FLAT_ATOMIC_MIN_F64>;
1881   defm FLAT_ATOMIC_MAX_F64       : FLAT_Real_Atomics_gfx940<0x51, FLAT_ATOMIC_MAX_F64>;
1882   defm GLOBAL_ATOMIC_ADD_F64     : FLAT_Global_Real_Atomics_gfx940<0x4f>;
1883   defm GLOBAL_ATOMIC_MIN_F64     : FLAT_Global_Real_Atomics_gfx940<0x50>;
1884   defm GLOBAL_ATOMIC_MAX_F64     : FLAT_Global_Real_Atomics_gfx940<0x51>;
1885   defm FLAT_ATOMIC_ADD_F32       : FLAT_Real_Atomics_vi<0x4d, FLAT_ATOMIC_ADD_F32>;
1886   defm FLAT_ATOMIC_PK_ADD_F16    : FLAT_Real_Atomics_vi<0x4e, FLAT_ATOMIC_PK_ADD_F16>;
1887   defm FLAT_ATOMIC_PK_ADD_BF16   : FLAT_Real_Atomics_vi<0x52, FLAT_ATOMIC_PK_ADD_BF16>;
1888   defm GLOBAL_ATOMIC_PK_ADD_BF16 : FLAT_Global_Real_Atomics_vi<0x52>;
1889 } // End SubtargetPredicate = isGFX940Plus
1890
1891 //===----------------------------------------------------------------------===//
1892 // GFX10.
1893 //===----------------------------------------------------------------------===//
1894
1895 class FLAT_Real_gfx10<bits<7> op, FLAT_Pseudo ps> :
1896     FLAT_Real<op, ps>, SIMCInstr<ps.PseudoInstr, SIEncodingFamily.GFX10> {
1897   let AssemblerPredicate = isGFX10Only;
1898   let DecoderNamespace = "GFX10";
1899
1900   let Inst{11-0}  = offset{11-0};
1901   let Inst{12}    = !if(ps.has_dlc, cpol{CPolBit.DLC}, ps.dlcValue);
1902   let Inst{54-48} = !if(ps.has_saddr, !if(ps.enabled_saddr, saddr, 0x7d), 0x7d);
1903   let Inst{55}    = 0;
1904 }
1905
1906
1907 multiclass FLAT_Real_Base_gfx10<bits<7> op> {
1908   def _gfx10 :
1909     FLAT_Real_gfx10<op, !cast<FLAT_Pseudo>(NAME)>;
1910 }
1911
1912 multiclass FLAT_Real_RTN_gfx10<bits<7> op> {
1913   def _RTN_gfx10 :
1914     FLAT_Real_gfx10<op, !cast<FLAT_Pseudo>(NAME#"_RTN")>;
1915 }
1916
1917 multiclass FLAT_Real_SADDR_gfx10<bits<7> op> {
1918   def _SADDR_gfx10 :
1919     FLAT_Real_gfx10<op, !cast<FLAT_Pseudo>(NAME#"_SADDR")>;
1920 }
1921
1922 multiclass FLAT_Real_SADDR_RTN_gfx10<bits<7> op> {
1923   def _SADDR_RTN_gfx10 :
1924     FLAT_Real_gfx10<op, !cast<FLAT_Pseudo>(NAME#"_SADDR_RTN")>;
1925 }
1926
1927 multiclass FLAT_Real_ST_gfx10<bits<7> op> {
1928   def _ST_gfx10 :
1929     FLAT_Real_gfx10<op, !cast<FLAT_Pseudo>(NAME#"_ST")> {
1930       let Inst{54-48} = !cast<int>(EXEC_HI.HWEncoding);
1931       let OtherPredicates = [HasFlatScratchSTMode];
1932     }
1933 }
1934
1935 multiclass FLAT_Real_AllAddr_gfx10<bits<7> op> :
1936   FLAT_Real_Base_gfx10<op>,
1937   FLAT_Real_SADDR_gfx10<op>;
1938
1939 multiclass FLAT_Real_Atomics_gfx10<bits<7> op> :
1940   FLAT_Real_Base_gfx10<op>,
1941   FLAT_Real_RTN_gfx10<op>;
1942
1943 multiclass FLAT_Real_GlblAtomics_gfx10<bits<7> op> :
1944   FLAT_Real_AllAddr_gfx10<op>,
1945   FLAT_Real_RTN_gfx10<op>,
1946   FLAT_Real_SADDR_RTN_gfx10<op>;
1947
1948 multiclass FLAT_Real_GlblAtomics_RTN_gfx10<bits<7> op> :
1949   FLAT_Real_RTN_gfx10<op>,
1950   FLAT_Real_SADDR_RTN_gfx10<op>;
1951
1952 multiclass FLAT_Real_ScratchAllAddr_gfx10<bits<7> op> :
1953   FLAT_Real_Base_gfx10<op>,
1954   FLAT_Real_SADDR_gfx10<op>,
1955   FLAT_Real_ST_gfx10<op>;
1956
1957 multiclass FLAT_Real_AllAddr_LDS_gfx10<bits<7> op,
1958   string opname = !subst("_lds", "", !cast<FLAT_Pseudo>(NAME).PseudoInstr)> {
1959   let AsmString = opname # !cast<FLAT_Pseudo>(NAME).AsmOperands # " lds" in
1960   defm "" : FLAT_Real_Base_gfx10<op>;
1961
1962   let AsmString = opname # !cast<FLAT_Pseudo>(NAME#"_SADDR").AsmOperands # " lds" in
1963   defm "" : FLAT_Real_SADDR_gfx10<op>;
1964 }
1965
1966 multiclass FLAT_Real_ScratchAllAddr_LDS_gfx10<bits<7> op,
1967   string opname = !subst("_lds", "", !cast<FLAT_Pseudo>(NAME).PseudoInstr)> {
1968   defm "" : FLAT_Real_AllAddr_LDS_gfx10<op>;
1969
1970   let AsmString = opname # !cast<FLAT_Pseudo>(NAME#"_ST").AsmOperands # " lds" in
1971   defm "" : FLAT_Real_ST_gfx10<op>;
1972 }
1973
1974 // ENC_FLAT.
1975 defm FLAT_LOAD_UBYTE            : FLAT_Real_Base_gfx10<0x008>;
1976 defm FLAT_LOAD_SBYTE            : FLAT_Real_Base_gfx10<0x009>;
1977 defm FLAT_LOAD_USHORT           : FLAT_Real_Base_gfx10<0x00a>;
1978 defm FLAT_LOAD_SSHORT           : FLAT_Real_Base_gfx10<0x00b>;
1979 defm FLAT_LOAD_DWORD            : FLAT_Real_Base_gfx10<0x00c>;
1980 defm FLAT_LOAD_DWORDX2          : FLAT_Real_Base_gfx10<0x00d>;
1981 defm FLAT_LOAD_DWORDX4          : FLAT_Real_Base_gfx10<0x00e>;
1982 defm FLAT_LOAD_DWORDX3          : FLAT_Real_Base_gfx10<0x00f>;
1983 defm FLAT_STORE_BYTE            : FLAT_Real_Base_gfx10<0x018>;
1984 defm FLAT_STORE_BYTE_D16_HI     : FLAT_Real_Base_gfx10<0x019>;
1985 defm FLAT_STORE_SHORT           : FLAT_Real_Base_gfx10<0x01a>;
1986 defm FLAT_STORE_SHORT_D16_HI    : FLAT_Real_Base_gfx10<0x01b>;
1987 defm FLAT_STORE_DWORD           : FLAT_Real_Base_gfx10<0x01c>;
1988 defm FLAT_STORE_DWORDX2         : FLAT_Real_Base_gfx10<0x01d>;
1989 defm FLAT_STORE_DWORDX4         : FLAT_Real_Base_gfx10<0x01e>;
1990 defm FLAT_STORE_DWORDX3         : FLAT_Real_Base_gfx10<0x01f>;
1991 defm FLAT_LOAD_UBYTE_D16        : FLAT_Real_Base_gfx10<0x020>;
1992 defm FLAT_LOAD_UBYTE_D16_HI     : FLAT_Real_Base_gfx10<0x021>;
1993 defm FLAT_LOAD_SBYTE_D16        : FLAT_Real_Base_gfx10<0x022>;
1994 defm FLAT_LOAD_SBYTE_D16_HI     : FLAT_Real_Base_gfx10<0x023>;
1995 defm FLAT_LOAD_SHORT_D16        : FLAT_Real_Base_gfx10<0x024>;
1996 defm FLAT_LOAD_SHORT_D16_HI     : FLAT_Real_Base_gfx10<0x025>;
1997 defm FLAT_ATOMIC_SWAP           : FLAT_Real_Atomics_gfx10<0x030>;
1998 defm FLAT_ATOMIC_CMPSWAP        : FLAT_Real_Atomics_gfx10<0x031>;
1999 defm FLAT_ATOMIC_ADD            : FLAT_Real_Atomics_gfx10<0x032>;
2000 defm FLAT_ATOMIC_SUB            : FLAT_Real_Atomics_gfx10<0x033>;
2001 defm FLAT_ATOMIC_SMIN           : FLAT_Real_Atomics_gfx10<0x035>;
2002 defm FLAT_ATOMIC_UMIN           : FLAT_Real_Atomics_gfx10<0x036>;
2003 defm FLAT_ATOMIC_SMAX           : FLAT_Real_Atomics_gfx10<0x037>;
2004 defm FLAT_ATOMIC_UMAX           : FLAT_Real_Atomics_gfx10<0x038>;
2005 defm FLAT_ATOMIC_AND            : FLAT_Real_Atomics_gfx10<0x039>;
2006 defm FLAT_ATOMIC_OR             : FLAT_Real_Atomics_gfx10<0x03a>;
2007 defm FLAT_ATOMIC_XOR            : FLAT_Real_Atomics_gfx10<0x03b>;
2008 defm FLAT_ATOMIC_INC            : FLAT_Real_Atomics_gfx10<0x03c>;
2009 defm FLAT_ATOMIC_DEC            : FLAT_Real_Atomics_gfx10<0x03d>;
2010 defm FLAT_ATOMIC_FCMPSWAP       : FLAT_Real_Atomics_gfx10<0x03e>;
2011 defm FLAT_ATOMIC_FMIN           : FLAT_Real_Atomics_gfx10<0x03f>;
2012 defm FLAT_ATOMIC_FMAX           : FLAT_Real_Atomics_gfx10<0x040>;
2013 defm FLAT_ATOMIC_SWAP_X2        : FLAT_Real_Atomics_gfx10<0x050>;
2014 defm FLAT_ATOMIC_CMPSWAP_X2     : FLAT_Real_Atomics_gfx10<0x051>;
2015 defm FLAT_ATOMIC_ADD_X2         : FLAT_Real_Atomics_gfx10<0x052>;
2016 defm FLAT_ATOMIC_SUB_X2         : FLAT_Real_Atomics_gfx10<0x053>;
2017 defm FLAT_ATOMIC_SMIN_X2        : FLAT_Real_Atomics_gfx10<0x055>;
2018 defm FLAT_ATOMIC_UMIN_X2        : FLAT_Real_Atomics_gfx10<0x056>;
2019 defm FLAT_ATOMIC_SMAX_X2        : FLAT_Real_Atomics_gfx10<0x057>;
2020 defm FLAT_ATOMIC_UMAX_X2        : FLAT_Real_Atomics_gfx10<0x058>;
2021 defm FLAT_ATOMIC_AND_X2         : FLAT_Real_Atomics_gfx10<0x059>;
2022 defm FLAT_ATOMIC_OR_X2          : FLAT_Real_Atomics_gfx10<0x05a>;
2023 defm FLAT_ATOMIC_XOR_X2         : FLAT_Real_Atomics_gfx10<0x05b>;
2024 defm FLAT_ATOMIC_INC_X2         : FLAT_Real_Atomics_gfx10<0x05c>;
2025 defm FLAT_ATOMIC_DEC_X2         : FLAT_Real_Atomics_gfx10<0x05d>;
2026 defm FLAT_ATOMIC_FCMPSWAP_X2    : FLAT_Real_Atomics_gfx10<0x05e>;
2027 defm FLAT_ATOMIC_FMIN_X2        : FLAT_Real_Atomics_gfx10<0x05f>;
2028 defm FLAT_ATOMIC_FMAX_X2        : FLAT_Real_Atomics_gfx10<0x060>;
2029
2030
2031 // ENC_FLAT_GLBL.
2032 defm GLOBAL_LOAD_UBYTE          : FLAT_Real_AllAddr_gfx10<0x008>;
2033 defm GLOBAL_LOAD_SBYTE          : FLAT_Real_AllAddr_gfx10<0x009>;
2034 defm GLOBAL_LOAD_USHORT         : FLAT_Real_AllAddr_gfx10<0x00a>;
2035 defm GLOBAL_LOAD_SSHORT         : FLAT_Real_AllAddr_gfx10<0x00b>;
2036 defm GLOBAL_LOAD_DWORD          : FLAT_Real_AllAddr_gfx10<0x00c>;
2037 defm GLOBAL_LOAD_DWORDX2        : FLAT_Real_AllAddr_gfx10<0x00d>;
2038 defm GLOBAL_LOAD_DWORDX4        : FLAT_Real_AllAddr_gfx10<0x00e>;
2039 defm GLOBAL_LOAD_DWORDX3        : FLAT_Real_AllAddr_gfx10<0x00f>;
2040 defm GLOBAL_STORE_BYTE          : FLAT_Real_AllAddr_gfx10<0x018>;
2041 defm GLOBAL_STORE_BYTE_D16_HI   : FLAT_Real_AllAddr_gfx10<0x019>;
2042 defm GLOBAL_STORE_SHORT         : FLAT_Real_AllAddr_gfx10<0x01a>;
2043 defm GLOBAL_STORE_SHORT_D16_HI  : FLAT_Real_AllAddr_gfx10<0x01b>;
2044 defm GLOBAL_STORE_DWORD         : FLAT_Real_AllAddr_gfx10<0x01c>;
2045 defm GLOBAL_STORE_DWORDX2       : FLAT_Real_AllAddr_gfx10<0x01d>;
2046 defm GLOBAL_STORE_DWORDX4       : FLAT_Real_AllAddr_gfx10<0x01e>;
2047 defm GLOBAL_STORE_DWORDX3       : FLAT_Real_AllAddr_gfx10<0x01f>;
2048 defm GLOBAL_LOAD_UBYTE_D16      : FLAT_Real_AllAddr_gfx10<0x020>;
2049 defm GLOBAL_LOAD_UBYTE_D16_HI   : FLAT_Real_AllAddr_gfx10<0x021>;
2050 defm GLOBAL_LOAD_SBYTE_D16      : FLAT_Real_AllAddr_gfx10<0x022>;
2051 defm GLOBAL_LOAD_SBYTE_D16_HI   : FLAT_Real_AllAddr_gfx10<0x023>;
2052 defm GLOBAL_LOAD_SHORT_D16      : FLAT_Real_AllAddr_gfx10<0x024>;
2053 defm GLOBAL_LOAD_SHORT_D16_HI   : FLAT_Real_AllAddr_gfx10<0x025>;
2054 defm GLOBAL_ATOMIC_SWAP         : FLAT_Real_GlblAtomics_gfx10<0x030>;
2055 defm GLOBAL_ATOMIC_CMPSWAP      : FLAT_Real_GlblAtomics_gfx10<0x031>;
2056 defm GLOBAL_ATOMIC_ADD          : FLAT_Real_GlblAtomics_gfx10<0x032>;
2057 defm GLOBAL_ATOMIC_SUB          : FLAT_Real_GlblAtomics_gfx10<0x033>;
2058 defm GLOBAL_ATOMIC_CSUB         : FLAT_Real_GlblAtomics_RTN_gfx10<0x034>;
2059 defm GLOBAL_ATOMIC_SMIN         : FLAT_Real_GlblAtomics_gfx10<0x035>;
2060 defm GLOBAL_ATOMIC_UMIN         : FLAT_Real_GlblAtomics_gfx10<0x036>;
2061 defm GLOBAL_ATOMIC_SMAX         : FLAT_Real_GlblAtomics_gfx10<0x037>;
2062 defm GLOBAL_ATOMIC_UMAX         : FLAT_Real_GlblAtomics_gfx10<0x038>;
2063 defm GLOBAL_ATOMIC_AND          : FLAT_Real_GlblAtomics_gfx10<0x039>;
2064 defm GLOBAL_ATOMIC_OR           : FLAT_Real_GlblAtomics_gfx10<0x03a>;
2065 defm GLOBAL_ATOMIC_XOR          : FLAT_Real_GlblAtomics_gfx10<0x03b>;
2066 defm GLOBAL_ATOMIC_INC          : FLAT_Real_GlblAtomics_gfx10<0x03c>;
2067 defm GLOBAL_ATOMIC_DEC          : FLAT_Real_GlblAtomics_gfx10<0x03d>;
2068 defm GLOBAL_ATOMIC_FCMPSWAP     : FLAT_Real_GlblAtomics_gfx10<0x03e>;
2069 defm GLOBAL_ATOMIC_FMIN         : FLAT_Real_GlblAtomics_gfx10<0x03f>;
2070 defm GLOBAL_ATOMIC_FMAX         : FLAT_Real_GlblAtomics_gfx10<0x040>;
2071 defm GLOBAL_ATOMIC_SWAP_X2      : FLAT_Real_GlblAtomics_gfx10<0x050>;
2072 defm GLOBAL_ATOMIC_CMPSWAP_X2   : FLAT_Real_GlblAtomics_gfx10<0x051>;
2073 defm GLOBAL_ATOMIC_ADD_X2       : FLAT_Real_GlblAtomics_gfx10<0x052>;
2074 defm GLOBAL_ATOMIC_SUB_X2       : FLAT_Real_GlblAtomics_gfx10<0x053>;
2075 defm GLOBAL_ATOMIC_SMIN_X2      : FLAT_Real_GlblAtomics_gfx10<0x055>;
2076 defm GLOBAL_ATOMIC_UMIN_X2      : FLAT_Real_GlblAtomics_gfx10<0x056>;
2077 defm GLOBAL_ATOMIC_SMAX_X2      : FLAT_Real_GlblAtomics_gfx10<0x057>;
2078 defm GLOBAL_ATOMIC_UMAX_X2      : FLAT_Real_GlblAtomics_gfx10<0x058>;
2079 defm GLOBAL_ATOMIC_AND_X2       : FLAT_Real_GlblAtomics_gfx10<0x059>;
2080 defm GLOBAL_ATOMIC_OR_X2        : FLAT_Real_GlblAtomics_gfx10<0x05a>;
2081 defm GLOBAL_ATOMIC_XOR_X2       : FLAT_Real_GlblAtomics_gfx10<0x05b>;
2082 defm GLOBAL_ATOMIC_INC_X2       : FLAT_Real_GlblAtomics_gfx10<0x05c>;
2083 defm GLOBAL_ATOMIC_DEC_X2       : FLAT_Real_GlblAtomics_gfx10<0x05d>;
2084 defm GLOBAL_ATOMIC_FCMPSWAP_X2  : FLAT_Real_GlblAtomics_gfx10<0x05e>;
2085 defm GLOBAL_ATOMIC_FMIN_X2      : FLAT_Real_GlblAtomics_gfx10<0x05f>;
2086 defm GLOBAL_ATOMIC_FMAX_X2      : FLAT_Real_GlblAtomics_gfx10<0x060>;
2087 defm GLOBAL_LOAD_DWORD_ADDTID   : FLAT_Real_AllAddr_gfx10<0x016>;
2088 defm GLOBAL_STORE_DWORD_ADDTID  : FLAT_Real_AllAddr_gfx10<0x017>;
2089
2090 defm GLOBAL_LOAD_LDS_UBYTE      : FLAT_Real_AllAddr_LDS_gfx10 <0x008>;
2091 defm GLOBAL_LOAD_LDS_SBYTE      : FLAT_Real_AllAddr_LDS_gfx10 <0x009>;
2092 defm GLOBAL_LOAD_LDS_USHORT     : FLAT_Real_AllAddr_LDS_gfx10 <0x00a>;
2093 defm GLOBAL_LOAD_LDS_SSHORT     : FLAT_Real_AllAddr_LDS_gfx10 <0x00b>;
2094 defm GLOBAL_LOAD_LDS_DWORD      : FLAT_Real_AllAddr_LDS_gfx10 <0x00c>;
2095
2096 // ENC_FLAT_SCRATCH.
2097 defm SCRATCH_LOAD_UBYTE         : FLAT_Real_ScratchAllAddr_gfx10<0x008>;
2098 defm SCRATCH_LOAD_SBYTE         : FLAT_Real_ScratchAllAddr_gfx10<0x009>;
2099 defm SCRATCH_LOAD_USHORT        : FLAT_Real_ScratchAllAddr_gfx10<0x00a>;
2100 defm SCRATCH_LOAD_SSHORT        : FLAT_Real_ScratchAllAddr_gfx10<0x00b>;
2101 defm SCRATCH_LOAD_DWORD         : FLAT_Real_ScratchAllAddr_gfx10<0x00c>;
2102 defm SCRATCH_LOAD_DWORDX2       : FLAT_Real_ScratchAllAddr_gfx10<0x00d>;
2103 defm SCRATCH_LOAD_DWORDX4       : FLAT_Real_ScratchAllAddr_gfx10<0x00e>;
2104 defm SCRATCH_LOAD_DWORDX3       : FLAT_Real_ScratchAllAddr_gfx10<0x00f>;
2105 defm SCRATCH_STORE_BYTE         : FLAT_Real_ScratchAllAddr_gfx10<0x018>;
2106 defm SCRATCH_STORE_BYTE_D16_HI  : FLAT_Real_ScratchAllAddr_gfx10<0x019>;
2107 defm SCRATCH_STORE_SHORT        : FLAT_Real_ScratchAllAddr_gfx10<0x01a>;
2108 defm SCRATCH_STORE_SHORT_D16_HI : FLAT_Real_ScratchAllAddr_gfx10<0x01b>;
2109 defm SCRATCH_STORE_DWORD        : FLAT_Real_ScratchAllAddr_gfx10<0x01c>;
2110 defm SCRATCH_STORE_DWORDX2      : FLAT_Real_ScratchAllAddr_gfx10<0x01d>;
2111 defm SCRATCH_STORE_DWORDX4      : FLAT_Real_ScratchAllAddr_gfx10<0x01e>;
2112 defm SCRATCH_STORE_DWORDX3      : FLAT_Real_ScratchAllAddr_gfx10<0x01f>;
2113 defm SCRATCH_LOAD_UBYTE_D16     : FLAT_Real_ScratchAllAddr_gfx10<0x020>;
2114 defm SCRATCH_LOAD_UBYTE_D16_HI  : FLAT_Real_ScratchAllAddr_gfx10<0x021>;
2115 defm SCRATCH_LOAD_SBYTE_D16     : FLAT_Real_ScratchAllAddr_gfx10<0x022>;
2116 defm SCRATCH_LOAD_SBYTE_D16_HI  : FLAT_Real_ScratchAllAddr_gfx10<0x023>;
2117 defm SCRATCH_LOAD_SHORT_D16     : FLAT_Real_ScratchAllAddr_gfx10<0x024>;
2118 defm SCRATCH_LOAD_SHORT_D16_HI  : FLAT_Real_ScratchAllAddr_gfx10<0x025>;
2119
2120 defm SCRATCH_LOAD_LDS_UBYTE     : FLAT_Real_ScratchAllAddr_LDS_gfx10 <0x008>;
2121 defm SCRATCH_LOAD_LDS_SBYTE     : FLAT_Real_ScratchAllAddr_LDS_gfx10 <0x009>;
2122 defm SCRATCH_LOAD_LDS_USHORT    : FLAT_Real_ScratchAllAddr_LDS_gfx10 <0x00a>;
2123 defm SCRATCH_LOAD_LDS_SSHORT    : FLAT_Real_ScratchAllAddr_LDS_gfx10 <0x00b>;
2124 defm SCRATCH_LOAD_LDS_DWORD     : FLAT_Real_ScratchAllAddr_LDS_gfx10 <0x00c>;
2125
2126 //===----------------------------------------------------------------------===//
2127 // GFX11
2128 //===----------------------------------------------------------------------===//
2129
2130 class FLAT_Real_gfx11 <bits<7> op, FLAT_Pseudo ps, string opName = ps.Mnemonic> :
2131   FLAT_Real <op, ps, opName>,
2132   SIMCInstr <ps.PseudoInstr, SIEncodingFamily.GFX11> {
2133   let AssemblerPredicate = isGFX11Plus;
2134   let DecoderNamespace = "GFX11";
2135
2136   let Inst{13}    = !if(ps.has_dlc, cpol{CPolBit.DLC}, ps.dlcValue);
2137   let Inst{14}    = !if(ps.has_glc, cpol{CPolBit.GLC}, ps.glcValue);
2138   let Inst{15}    = cpol{CPolBit.SLC};
2139   let Inst{17-16} = seg;
2140   let Inst{55}    = ps.sve;
2141 }
2142
2143 multiclass FLAT_Real_Base_gfx11<bits<7> op, string ps, string opName, int renamed = false> {
2144   def _gfx11 : FLAT_Real_gfx11<op, !cast<FLAT_Pseudo>(ps), opName> {
2145     let Inst{54-48} = !cast<int>(SGPR_NULL_gfx11plus.HWEncoding);
2146   }
2147   if renamed then
2148     def _renamed_gfx11 : MnemonicAlias<!cast<FLAT_Pseudo>(ps).Mnemonic, opName>, Requires<[isGFX11Plus]>;
2149 }
2150
2151 multiclass FLAT_Real_RTN_gfx11<bits<7> op, string ps, string opName> {
2152   def _RTN_gfx11 : FLAT_Real_gfx11<op, !cast<FLAT_Pseudo>(ps#"_RTN"), opName> {
2153     let Inst{54-48} = !cast<int>(SGPR_NULL_gfx11plus.HWEncoding);
2154   }
2155 }
2156
2157 multiclass FLAT_Real_SADDR_gfx11<bits<7> op, string ps, string opName> {
2158   def _SADDR_gfx11 : FLAT_Real_gfx11<op, !cast<FLAT_Pseudo>(ps#"_SADDR"), opName>;
2159 }
2160
2161 multiclass FLAT_Real_SADDR_RTN_gfx11<bits<7> op, string ps, string opName> {
2162   def _SADDR_RTN_gfx11 : FLAT_Real_gfx11<op, !cast<FLAT_Pseudo>(ps#"_SADDR_RTN"), opName>;
2163 }
2164
2165 multiclass FLAT_Real_ST_gfx11<bits<7> op, string ps, string opName> {
2166   def _ST_gfx11 : FLAT_Real_gfx11<op, !cast<FLAT_Pseudo>(ps#"_ST"), opName> {
2167     let Inst{54-48} = !cast<int>(SGPR_NULL_gfx11plus.HWEncoding);
2168     let OtherPredicates = [HasFlatScratchSTMode];
2169   }
2170 }
2171
2172 multiclass FLAT_Real_SVS_gfx11<bits<7> op, string ps, string opName> {
2173   def _SVS_gfx11 : FLAT_Real_gfx11<op, !cast<FLAT_Pseudo>(ps#"_SVS"), opName> {
2174     let OtherPredicates = [HasFlatScratchSVSMode];
2175   }
2176 }
2177
2178 multiclass FLAT_Real_AllAddr_gfx11<bits<7> op, string ps, string opName, int renamed = false> :
2179   FLAT_Real_Base_gfx11<op, ps, opName, renamed>,
2180   FLAT_Real_SADDR_gfx11<op, ps, opName>;
2181
2182 multiclass FLAT_Real_Atomics_gfx11<bits<7> op, string ps, string opName, int renamed = false> :
2183   FLAT_Real_Base_gfx11<op, ps, opName, renamed>,
2184   FLAT_Real_RTN_gfx11<op, ps, opName>;
2185
2186 multiclass FLAT_Real_GlblAtomics_gfx11<bits<7> op, string ps, string opName, int renamed = false> :
2187   FLAT_Real_AllAddr_gfx11<op, ps, opName, renamed>,
2188   FLAT_Real_RTN_gfx11<op, ps, opName>,
2189   FLAT_Real_SADDR_RTN_gfx11<op, ps, opName>;
2190
2191 multiclass FLAT_Real_GlblAtomics_RTN_gfx11<bits<7> op, string ps, string opName> :
2192   FLAT_Real_RTN_gfx11<op, ps, opName>,
2193   FLAT_Real_SADDR_RTN_gfx11<op, ps, opName>;
2194
2195 multiclass FLAT_Real_ScratchAllAddr_gfx11<bits<7> op, string ps, string opName, int renamed = false> :
2196   FLAT_Real_Base_gfx11<op, ps, opName, renamed>,
2197   FLAT_Real_SADDR_gfx11<op, ps, opName>,
2198   FLAT_Real_ST_gfx11<op, ps, opName>,
2199   FLAT_Real_SVS_gfx11<op, ps, opName>;
2200
2201 // ENC_FLAT.
2202 defm FLAT_LOAD_U8               : FLAT_Real_Base_gfx11<0x010, "FLAT_LOAD_UBYTE", "flat_load_u8", true>;
2203 defm FLAT_LOAD_I8               : FLAT_Real_Base_gfx11<0x011, "FLAT_LOAD_SBYTE", "flat_load_i8", true>;
2204 defm FLAT_LOAD_U16              : FLAT_Real_Base_gfx11<0x012, "FLAT_LOAD_USHORT", "flat_load_u16", true>;
2205 defm FLAT_LOAD_I16              : FLAT_Real_Base_gfx11<0x013, "FLAT_LOAD_SSHORT", "flat_load_i16", true>;
2206 defm FLAT_LOAD_B32              : FLAT_Real_Base_gfx11<0x014, "FLAT_LOAD_DWORD", "flat_load_b32", true>;
2207 defm FLAT_LOAD_B64              : FLAT_Real_Base_gfx11<0x015, "FLAT_LOAD_DWORDX2", "flat_load_b64", true>;
2208 defm FLAT_LOAD_B96              : FLAT_Real_Base_gfx11<0x016, "FLAT_LOAD_DWORDX3", "flat_load_b96", true>;
2209 defm FLAT_LOAD_B128             : FLAT_Real_Base_gfx11<0x017, "FLAT_LOAD_DWORDX4", "flat_load_b128", true>;
2210 defm FLAT_STORE_B8              : FLAT_Real_Base_gfx11<0x018, "FLAT_STORE_BYTE", "flat_store_b8", true>;
2211 defm FLAT_STORE_B16             : FLAT_Real_Base_gfx11<0x019, "FLAT_STORE_SHORT", "flat_store_b16", true>;
2212 defm FLAT_STORE_B32             : FLAT_Real_Base_gfx11<0x01a, "FLAT_STORE_DWORD", "flat_store_b32", true>;
2213 defm FLAT_STORE_B64             : FLAT_Real_Base_gfx11<0x01b, "FLAT_STORE_DWORDX2", "flat_store_b64", true>;
2214 defm FLAT_STORE_B96             : FLAT_Real_Base_gfx11<0x01c, "FLAT_STORE_DWORDX3", "flat_store_b96", true>;
2215 defm FLAT_STORE_B128            : FLAT_Real_Base_gfx11<0x01d, "FLAT_STORE_DWORDX4", "flat_store_b128", true>;
2216 defm FLAT_LOAD_D16_U8           : FLAT_Real_Base_gfx11<0x01e, "FLAT_LOAD_UBYTE_D16", "flat_load_d16_u8">;
2217 defm FLAT_LOAD_D16_I8           : FLAT_Real_Base_gfx11<0x01f, "FLAT_LOAD_SBYTE_D16", "flat_load_d16_i8">;
2218 defm FLAT_LOAD_D16_B16          : FLAT_Real_Base_gfx11<0x020, "FLAT_LOAD_SHORT_D16", "flat_load_d16_b16">;
2219 defm FLAT_LOAD_D16_HI_U8        : FLAT_Real_Base_gfx11<0x021, "FLAT_LOAD_UBYTE_D16_HI", "flat_load_d16_hi_u8">;
2220 defm FLAT_LOAD_D16_HI_I8        : FLAT_Real_Base_gfx11<0x022, "FLAT_LOAD_SBYTE_D16_HI", "flat_load_d16_hi_i8">;
2221 defm FLAT_LOAD_D16_HI_B16       : FLAT_Real_Base_gfx11<0x023, "FLAT_LOAD_SHORT_D16_HI", "flat_load_d16_hi_b16">;
2222 defm FLAT_STORE_D16_HI_B8       : FLAT_Real_Base_gfx11<0x024, "FLAT_STORE_BYTE_D16_HI", "flat_store_d16_hi_b8">;
2223 defm FLAT_STORE_D16_HI_B16      : FLAT_Real_Base_gfx11<0x025, "FLAT_STORE_SHORT_D16_HI", "flat_store_d16_hi_b16">;
2224 defm FLAT_ATOMIC_SWAP_B32       : FLAT_Real_Atomics_gfx11<0x033, "FLAT_ATOMIC_SWAP", "flat_atomic_swap_b32", true>;
2225 defm FLAT_ATOMIC_CMPSWAP_B32    : FLAT_Real_Atomics_gfx11<0x034, "FLAT_ATOMIC_CMPSWAP", "flat_atomic_cmpswap_b32", true>;
2226 defm FLAT_ATOMIC_ADD_U32        : FLAT_Real_Atomics_gfx11<0x035, "FLAT_ATOMIC_ADD", "flat_atomic_add_u32", true>;
2227 defm FLAT_ATOMIC_SUB_U32        : FLAT_Real_Atomics_gfx11<0x036, "FLAT_ATOMIC_SUB", "flat_atomic_sub_u32", true>;
2228 defm FLAT_ATOMIC_MIN_I32        : FLAT_Real_Atomics_gfx11<0x038, "FLAT_ATOMIC_SMIN", "flat_atomic_min_i32", true>;
2229 defm FLAT_ATOMIC_MIN_U32        : FLAT_Real_Atomics_gfx11<0x039, "FLAT_ATOMIC_UMIN", "flat_atomic_min_u32", true>;
2230 defm FLAT_ATOMIC_MAX_I32        : FLAT_Real_Atomics_gfx11<0x03a, "FLAT_ATOMIC_SMAX", "flat_atomic_max_i32", true>;
2231 defm FLAT_ATOMIC_MAX_U32        : FLAT_Real_Atomics_gfx11<0x03b, "FLAT_ATOMIC_UMAX", "flat_atomic_max_u32", true>;
2232 defm FLAT_ATOMIC_AND_B32        : FLAT_Real_Atomics_gfx11<0x03c, "FLAT_ATOMIC_AND", "flat_atomic_and_b32", true>;
2233 defm FLAT_ATOMIC_OR_B32         : FLAT_Real_Atomics_gfx11<0x03d, "FLAT_ATOMIC_OR", "flat_atomic_or_b32", true>;
2234 defm FLAT_ATOMIC_XOR_B32        : FLAT_Real_Atomics_gfx11<0x03e, "FLAT_ATOMIC_XOR", "flat_atomic_xor_b32", true>;
2235 defm FLAT_ATOMIC_INC_U32        : FLAT_Real_Atomics_gfx11<0x03f, "FLAT_ATOMIC_INC", "flat_atomic_inc_u32", true>;
2236 defm FLAT_ATOMIC_DEC_U32        : FLAT_Real_Atomics_gfx11<0x040, "FLAT_ATOMIC_DEC", "flat_atomic_dec_u32", true>;
2237 defm FLAT_ATOMIC_SWAP_B64       : FLAT_Real_Atomics_gfx11<0x041, "FLAT_ATOMIC_SWAP_X2", "flat_atomic_swap_b64", true>;
2238 defm FLAT_ATOMIC_CMPSWAP_B64    : FLAT_Real_Atomics_gfx11<0x042, "FLAT_ATOMIC_CMPSWAP_X2", "flat_atomic_cmpswap_b64", true>;
2239 defm FLAT_ATOMIC_ADD_U64        : FLAT_Real_Atomics_gfx11<0x043, "FLAT_ATOMIC_ADD_X2", "flat_atomic_add_u64", true>;
2240 defm FLAT_ATOMIC_SUB_U64        : FLAT_Real_Atomics_gfx11<0x044, "FLAT_ATOMIC_SUB_X2", "flat_atomic_sub_u64", true>;
2241 defm FLAT_ATOMIC_MIN_I64        : FLAT_Real_Atomics_gfx11<0x045, "FLAT_ATOMIC_SMIN_X2", "flat_atomic_min_i64", true>;
2242 defm FLAT_ATOMIC_MIN_U64        : FLAT_Real_Atomics_gfx11<0x046, "FLAT_ATOMIC_UMIN_X2", "flat_atomic_min_u64", true>;
2243 defm FLAT_ATOMIC_MAX_I64        : FLAT_Real_Atomics_gfx11<0x047, "FLAT_ATOMIC_SMAX_X2", "flat_atomic_max_i64", true>;
2244 defm FLAT_ATOMIC_MAX_U64        : FLAT_Real_Atomics_gfx11<0x048, "FLAT_ATOMIC_UMAX_X2", "flat_atomic_max_u64", true>;
2245 defm FLAT_ATOMIC_AND_B64        : FLAT_Real_Atomics_gfx11<0x049, "FLAT_ATOMIC_AND_X2", "flat_atomic_and_b64", true>;
2246 defm FLAT_ATOMIC_OR_B64         : FLAT_Real_Atomics_gfx11<0x04a, "FLAT_ATOMIC_OR_X2", "flat_atomic_or_b64", true>;
2247 defm FLAT_ATOMIC_XOR_B64        : FLAT_Real_Atomics_gfx11<0x04b, "FLAT_ATOMIC_XOR_X2", "flat_atomic_xor_b64", true>;
2248 defm FLAT_ATOMIC_INC_U64        : FLAT_Real_Atomics_gfx11<0x04c, "FLAT_ATOMIC_INC_X2", "flat_atomic_inc_u64", true>;
2249 defm FLAT_ATOMIC_DEC_U64        : FLAT_Real_Atomics_gfx11<0x04d, "FLAT_ATOMIC_DEC_X2", "flat_atomic_dec_u64", true>;
2250 defm FLAT_ATOMIC_CMPSWAP_F32    : FLAT_Real_Atomics_gfx11<0x050, "FLAT_ATOMIC_FCMPSWAP", "flat_atomic_cmpswap_f32">;
2251 defm FLAT_ATOMIC_MIN_F32        : FLAT_Real_Atomics_gfx11<0x051, "FLAT_ATOMIC_FMIN", "flat_atomic_min_f32">;
2252 defm FLAT_ATOMIC_MAX_F32        : FLAT_Real_Atomics_gfx11<0x052, "FLAT_ATOMIC_FMAX", "flat_atomic_max_f32">;
2253 defm FLAT_ATOMIC_ADD_F32        : FLAT_Real_Atomics_gfx11<0x056, "FLAT_ATOMIC_ADD_F32", "flat_atomic_add_f32">;
2254
2255 // ENC_FLAT_GLBL.
2256 defm GLOBAL_LOAD_U8             : FLAT_Real_AllAddr_gfx11<0x010, "GLOBAL_LOAD_UBYTE", "global_load_u8", true>;
2257 defm GLOBAL_LOAD_I8             : FLAT_Real_AllAddr_gfx11<0x011, "GLOBAL_LOAD_SBYTE", "global_load_i8", true>;
2258 defm GLOBAL_LOAD_U16            : FLAT_Real_AllAddr_gfx11<0x012, "GLOBAL_LOAD_USHORT", "global_load_u16", true>;
2259 defm GLOBAL_LOAD_I16            : FLAT_Real_AllAddr_gfx11<0x013, "GLOBAL_LOAD_SSHORT", "global_load_i16", true>;
2260 defm GLOBAL_LOAD_B32            : FLAT_Real_AllAddr_gfx11<0x014, "GLOBAL_LOAD_DWORD", "global_load_b32", true>;
2261 defm GLOBAL_LOAD_B64            : FLAT_Real_AllAddr_gfx11<0x015, "GLOBAL_LOAD_DWORDX2", "global_load_b64", true>;
2262 defm GLOBAL_LOAD_B96            : FLAT_Real_AllAddr_gfx11<0x016, "GLOBAL_LOAD_DWORDX3", "global_load_b96", true>;
2263 defm GLOBAL_LOAD_B128           : FLAT_Real_AllAddr_gfx11<0x017, "GLOBAL_LOAD_DWORDX4", "global_load_b128", true>;
2264 defm GLOBAL_STORE_B8            : FLAT_Real_AllAddr_gfx11<0x018, "GLOBAL_STORE_BYTE", "global_store_b8", true>;
2265 defm GLOBAL_STORE_B16           : FLAT_Real_AllAddr_gfx11<0x019, "GLOBAL_STORE_SHORT", "global_store_b16", true>;
2266 defm GLOBAL_STORE_B32           : FLAT_Real_AllAddr_gfx11<0x01a, "GLOBAL_STORE_DWORD", "global_store_b32", true>;
2267 defm GLOBAL_STORE_B64           : FLAT_Real_AllAddr_gfx11<0x01b, "GLOBAL_STORE_DWORDX2", "global_store_b64", true>;
2268 defm GLOBAL_STORE_B96           : FLAT_Real_AllAddr_gfx11<0x01c, "GLOBAL_STORE_DWORDX3", "global_store_b96", true>;
2269 defm GLOBAL_STORE_B128          : FLAT_Real_AllAddr_gfx11<0x01d, "GLOBAL_STORE_DWORDX4", "global_store_b128", true>;
2270 defm GLOBAL_LOAD_D16_U8         : FLAT_Real_AllAddr_gfx11<0x01e, "GLOBAL_LOAD_UBYTE_D16", "global_load_d16_u8">;
2271 defm GLOBAL_LOAD_D16_I8         : FLAT_Real_AllAddr_gfx11<0x01f, "GLOBAL_LOAD_SBYTE_D16", "global_load_d16_i8">;
2272 defm GLOBAL_LOAD_D16_B16        : FLAT_Real_AllAddr_gfx11<0x020, "GLOBAL_LOAD_SHORT_D16", "global_load_d16_b16">;
2273 defm GLOBAL_LOAD_D16_HI_U8      : FLAT_Real_AllAddr_gfx11<0x021, "GLOBAL_LOAD_UBYTE_D16_HI", "global_load_d16_hi_u8">;
2274 defm GLOBAL_LOAD_D16_HI_I8      : FLAT_Real_AllAddr_gfx11<0x022, "GLOBAL_LOAD_SBYTE_D16_HI", "global_load_d16_hi_i8">;
2275 defm GLOBAL_LOAD_D16_HI_B16     : FLAT_Real_AllAddr_gfx11<0x023, "GLOBAL_LOAD_SHORT_D16_HI", "global_load_d16_hi_b16">;
2276 defm GLOBAL_STORE_D16_HI_B8     : FLAT_Real_AllAddr_gfx11<0x024, "GLOBAL_STORE_BYTE_D16_HI", "global_store_d16_hi_b8">;
2277 defm GLOBAL_STORE_D16_HI_B16    : FLAT_Real_AllAddr_gfx11<0x025, "GLOBAL_STORE_SHORT_D16_HI", "global_store_d16_hi_b16">;
2278 defm GLOBAL_LOAD_ADDTID_B32     : FLAT_Real_AllAddr_gfx11<0x028, "GLOBAL_LOAD_DWORD_ADDTID", "global_load_addtid_b32">;
2279 defm GLOBAL_STORE_ADDTID_B32    : FLAT_Real_AllAddr_gfx11<0x029, "GLOBAL_STORE_DWORD_ADDTID", "global_store_addtid_b32">;
2280 defm GLOBAL_ATOMIC_SWAP_B32     : FLAT_Real_GlblAtomics_gfx11<0x033, "GLOBAL_ATOMIC_SWAP", "global_atomic_swap_b32", true>;
2281 defm GLOBAL_ATOMIC_CMPSWAP_B32  : FLAT_Real_GlblAtomics_gfx11<0x034, "GLOBAL_ATOMIC_CMPSWAP", "global_atomic_cmpswap_b32", true>;
2282 defm GLOBAL_ATOMIC_ADD_U32      : FLAT_Real_GlblAtomics_gfx11<0x035, "GLOBAL_ATOMIC_ADD", "global_atomic_add_u32", true>;
2283 defm GLOBAL_ATOMIC_SUB_U32      : FLAT_Real_GlblAtomics_gfx11<0x036, "GLOBAL_ATOMIC_SUB", "global_atomic_sub_u32", true>;
2284 defm GLOBAL_ATOMIC_CSUB_U32     : FLAT_Real_GlblAtomics_RTN_gfx11<0x037, "GLOBAL_ATOMIC_CSUB", "global_atomic_csub_u32">;
2285 defm GLOBAL_ATOMIC_MIN_I32      : FLAT_Real_GlblAtomics_gfx11<0x038, "GLOBAL_ATOMIC_SMIN", "global_atomic_min_i32", true>;
2286 defm GLOBAL_ATOMIC_MIN_U32      : FLAT_Real_GlblAtomics_gfx11<0x039, "GLOBAL_ATOMIC_UMIN", "global_atomic_min_u32", true>;
2287 defm GLOBAL_ATOMIC_MAX_I32      : FLAT_Real_GlblAtomics_gfx11<0x03a, "GLOBAL_ATOMIC_SMAX", "global_atomic_max_i32", true>;
2288 defm GLOBAL_ATOMIC_MAX_U32      : FLAT_Real_GlblAtomics_gfx11<0x03b, "GLOBAL_ATOMIC_UMAX", "global_atomic_max_u32", true>;
2289 defm GLOBAL_ATOMIC_AND_B32      : FLAT_Real_GlblAtomics_gfx11<0x03c, "GLOBAL_ATOMIC_AND", "global_atomic_and_b32", true>;
2290 defm GLOBAL_ATOMIC_OR_B32       : FLAT_Real_GlblAtomics_gfx11<0x03d, "GLOBAL_ATOMIC_OR", "global_atomic_or_b32", true>;
2291 defm GLOBAL_ATOMIC_XOR_B32      : FLAT_Real_GlblAtomics_gfx11<0x03e, "GLOBAL_ATOMIC_XOR", "global_atomic_xor_b32", true>;
2292 defm GLOBAL_ATOMIC_INC_U32      : FLAT_Real_GlblAtomics_gfx11<0x03f, "GLOBAL_ATOMIC_INC", "global_atomic_inc_u32", true>;
2293 defm GLOBAL_ATOMIC_DEC_U32      : FLAT_Real_GlblAtomics_gfx11<0x040, "GLOBAL_ATOMIC_DEC", "global_atomic_dec_u32", true>;
2294 defm GLOBAL_ATOMIC_SWAP_B64     : FLAT_Real_GlblAtomics_gfx11<0x041, "GLOBAL_ATOMIC_SWAP_X2", "global_atomic_swap_b64", true>;
2295 defm GLOBAL_ATOMIC_CMPSWAP_B64  : FLAT_Real_GlblAtomics_gfx11<0x042, "GLOBAL_ATOMIC_CMPSWAP_X2", "global_atomic_cmpswap_b64", true>;
2296 defm GLOBAL_ATOMIC_ADD_U64      : FLAT_Real_GlblAtomics_gfx11<0x043, "GLOBAL_ATOMIC_ADD_X2", "global_atomic_add_u64", true>;
2297 defm GLOBAL_ATOMIC_SUB_U64      : FLAT_Real_GlblAtomics_gfx11<0x044, "GLOBAL_ATOMIC_SUB_X2", "global_atomic_sub_u64", true>;
2298 defm GLOBAL_ATOMIC_MIN_I64      : FLAT_Real_GlblAtomics_gfx11<0x045, "GLOBAL_ATOMIC_SMIN_X2", "global_atomic_min_i64", true>;
2299 defm GLOBAL_ATOMIC_MIN_U64      : FLAT_Real_GlblAtomics_gfx11<0x046, "GLOBAL_ATOMIC_UMIN_X2", "global_atomic_min_u64", true>;
2300 defm GLOBAL_ATOMIC_MAX_I64      : FLAT_Real_GlblAtomics_gfx11<0x047, "GLOBAL_ATOMIC_SMAX_X2", "global_atomic_max_i64", true>;
2301 defm GLOBAL_ATOMIC_MAX_U64      : FLAT_Real_GlblAtomics_gfx11<0x048, "GLOBAL_ATOMIC_UMAX_X2", "global_atomic_max_u64", true>;
2302 defm GLOBAL_ATOMIC_AND_B64      : FLAT_Real_GlblAtomics_gfx11<0x049, "GLOBAL_ATOMIC_AND_X2", "global_atomic_and_b64", true>;
2303 defm GLOBAL_ATOMIC_OR_B64       : FLAT_Real_GlblAtomics_gfx11<0x04a, "GLOBAL_ATOMIC_OR_X2", "global_atomic_or_b64", true>;
2304 defm GLOBAL_ATOMIC_XOR_B64      : FLAT_Real_GlblAtomics_gfx11<0x04b, "GLOBAL_ATOMIC_XOR_X2", "global_atomic_xor_b64", true>;
2305 defm GLOBAL_ATOMIC_INC_U64      : FLAT_Real_GlblAtomics_gfx11<0x04c, "GLOBAL_ATOMIC_INC_X2", "global_atomic_inc_u64", true>;
2306 defm GLOBAL_ATOMIC_DEC_U64      : FLAT_Real_GlblAtomics_gfx11<0x04d, "GLOBAL_ATOMIC_DEC_X2", "global_atomic_dec_u64", true>;
2307 defm GLOBAL_ATOMIC_CMPSWAP_F32  : FLAT_Real_GlblAtomics_gfx11<0x050, "GLOBAL_ATOMIC_FCMPSWAP", "global_atomic_cmpswap_f32">;
2308 defm GLOBAL_ATOMIC_MIN_F32      : FLAT_Real_GlblAtomics_gfx11<0x051, "GLOBAL_ATOMIC_FMIN", "global_atomic_min_f32">;
2309 defm GLOBAL_ATOMIC_MAX_F32      : FLAT_Real_GlblAtomics_gfx11<0x052, "GLOBAL_ATOMIC_FMAX", "global_atomic_max_f32">;
2310 defm GLOBAL_ATOMIC_ADD_F32      : FLAT_Real_GlblAtomics_gfx11<0x056, "GLOBAL_ATOMIC_ADD_F32", "global_atomic_add_f32">;
2311
2312 // ENC_FLAT_SCRATCH.
2313 defm SCRATCH_LOAD_U8            : FLAT_Real_ScratchAllAddr_gfx11<0x10, "SCRATCH_LOAD_UBYTE", "scratch_load_u8", true>;
2314 defm SCRATCH_LOAD_I8            : FLAT_Real_ScratchAllAddr_gfx11<0x11, "SCRATCH_LOAD_SBYTE", "scratch_load_i8", true>;
2315 defm SCRATCH_LOAD_U16           : FLAT_Real_ScratchAllAddr_gfx11<0x12, "SCRATCH_LOAD_USHORT", "scratch_load_u16", true>;
2316 defm SCRATCH_LOAD_I16           : FLAT_Real_ScratchAllAddr_gfx11<0x13, "SCRATCH_LOAD_SSHORT", "scratch_load_i16", true>;
2317 defm SCRATCH_LOAD_B32           : FLAT_Real_ScratchAllAddr_gfx11<0x14, "SCRATCH_LOAD_DWORD", "scratch_load_b32", true>;
2318 defm SCRATCH_LOAD_B64           : FLAT_Real_ScratchAllAddr_gfx11<0x15, "SCRATCH_LOAD_DWORDX2", "scratch_load_b64", true>;
2319 defm SCRATCH_LOAD_B96           : FLAT_Real_ScratchAllAddr_gfx11<0x16, "SCRATCH_LOAD_DWORDX3", "scratch_load_b96", true>;
2320 defm SCRATCH_LOAD_B128          : FLAT_Real_ScratchAllAddr_gfx11<0x17, "SCRATCH_LOAD_DWORDX4", "scratch_load_b128", true>;
2321 defm SCRATCH_STORE_B8           : FLAT_Real_ScratchAllAddr_gfx11<0x18, "SCRATCH_STORE_BYTE", "scratch_store_b8", true>;
2322 defm SCRATCH_STORE_B16          : FLAT_Real_ScratchAllAddr_gfx11<0x19, "SCRATCH_STORE_SHORT", "scratch_store_b16", true>;
2323 defm SCRATCH_STORE_B32          : FLAT_Real_ScratchAllAddr_gfx11<0x1a, "SCRATCH_STORE_DWORD", "scratch_store_b32", true>;
2324 defm SCRATCH_STORE_B64          : FLAT_Real_ScratchAllAddr_gfx11<0x1b, "SCRATCH_STORE_DWORDX2", "scratch_store_b64", true>;
2325 defm SCRATCH_STORE_B96          : FLAT_Real_ScratchAllAddr_gfx11<0x1c, "SCRATCH_STORE_DWORDX3", "scratch_store_b96", true>;
2326 defm SCRATCH_STORE_B128         : FLAT_Real_ScratchAllAddr_gfx11<0x1d, "SCRATCH_STORE_DWORDX4", "scratch_store_b128", true>;
2327 defm SCRATCH_LOAD_D16_U8        : FLAT_Real_ScratchAllAddr_gfx11<0x1e, "SCRATCH_LOAD_UBYTE_D16", "scratch_load_d16_u8">;
2328 defm SCRATCH_LOAD_D16_I8        : FLAT_Real_ScratchAllAddr_gfx11<0x1f, "SCRATCH_LOAD_SBYTE_D16", "scratch_load_d16_i8">;
2329 defm SCRATCH_LOAD_D16_B16       : FLAT_Real_ScratchAllAddr_gfx11<0x20, "SCRATCH_LOAD_SHORT_D16", "scratch_load_d16_b16">;
2330 defm SCRATCH_LOAD_D16_HI_U8     : FLAT_Real_ScratchAllAddr_gfx11<0x21, "SCRATCH_LOAD_UBYTE_D16_HI", "scratch_load_d16_hi_u8">;
2331 defm SCRATCH_LOAD_D16_HI_I8     : FLAT_Real_ScratchAllAddr_gfx11<0x22, "SCRATCH_LOAD_SBYTE_D16_HI", "scratch_load_d16_hi_i8">;
2332 defm SCRATCH_LOAD_D16_HI_B16    : FLAT_Real_ScratchAllAddr_gfx11<0x23, "SCRATCH_LOAD_SHORT_D16_HI", "scratch_load_d16_hi_b16">;
2333 defm SCRATCH_STORE_D16_HI_B8    : FLAT_Real_ScratchAllAddr_gfx11<0x24, "SCRATCH_STORE_BYTE_D16_HI", "scratch_store_d16_hi_b8">;
2334 defm SCRATCH_STORE_D16_HI_B16   : FLAT_Real_ScratchAllAddr_gfx11<0x25, "SCRATCH_STORE_SHORT_D16_HI", "scratch_store_d16_hi_b16">;