[AMDGPU][MC][NFC] MUBUF/MTBUF code cleanup

[piotr]

Summary

Refactor code to reduce code duplication and improve maintainability.

• Extract BUF_Pseudo common base class
• Refactor getMUBUFInsDA
• Refactor getMUBUFAtomicInsDA
• Refactor getMTBUFInsDA
• Refactor getMUBUFAsmOps
• Refactor getMTBUFAsmOps

llvm/lib/Target/AMDGPU/BUFInstructions.td

class MUBUFAddr64Table <bit is_addr64, string Name> {
   string OpName = Name;
 }
 
 class MTBUFAddr64Table <bit is_addr64, string Name> {
   bit IsAddr64 = is_addr64;
   string OpName = Name;
 }
 
+
 //===----------------------------------------------------------------------===//
-// MTBUF classes
+// BUF class (base class for MTBUF and MUBUF pseudos)
 //===----------------------------------------------------------------------===//
 
-class MTBUFGetBaseOpcode<string Op> {
-  string ret = !subst("FORMAT_XY", "FORMAT_X",
-    !subst("FORMAT_XYZ", "FORMAT_X",
-    !subst("FORMAT_XYZW", "FORMAT_X", Op)));
-}
-
-
-class MTBUF_Pseudo <string opName, dag outs, dag ins,
+class BUF_Pseudo <string opName, dag outs, dag ins,
                     string asmOps, list<dag> pattern=[]> :
   InstSI<outs, ins, "", pattern>,
   SIMCInstr<opName, SIEncodingFamily.NONE> {
 
   let isPseudo = 1;
   let isCodeGenOnly = 1;
   let Size = 8;
   let UseNamedOperandTable = 1;
 
   string Mnemonic = opName;
   string AsmOperands = asmOps;
 
   Instruction Opcode = !cast<Instruction>(NAME);
-  Instruction BaseOpcode = !cast<Instruction>(MTBUFGetBaseOpcode<NAME>.ret);
+
 
   let VM_CNT = 1;
   let EXP_CNT = 1;
-  let MTBUF = 1;
+
   let Uses = [EXEC];
   let hasSideEffects = 0;
   let SchedRW = [WriteVMEM];
 
-  let AsmMatchConverter = "cvtMtbuf";
+
 
   bits<1> offen       = 0;
   bits<1> idxen       = 0;
   bits<1> addr64      = 0;
-  bits<1> has_vdata   = 1;
+  bits<1> lds         = 0;
+  bits<1> has_vdata   = !not(lds);
   bits<1> has_vaddr   = 1;
   bits<1> has_glc     = 1;
   bits<1> has_dlc     = 1;
   bits<1> glc_value   = 0; // the value for glc if no such operand
   bits<1> dlc_value   = 0; // the value for dlc if no such operand
   bits<1> has_srsrc   = 1;
   bits<1> has_soffset = 1;
   bits<1> has_offset  = 1;
   bits<1> has_slc     = 1;
   bits<1> tfe         = ?;
   bits<4> elements    = 0;
   bits<1> has_sccb    = 1;
   bits<1> sccb_value  = 0;
+  bits<1> IsBufferInv = 0;
+}
+
+
+
+//===----------------------------------------------------------------------===//
+// MTBUF classes
+//===----------------------------------------------------------------------===//
+
+class MTBUFGetBaseOpcode<string Op> {
+  string ret = !subst("FORMAT_XY", "FORMAT_X",
+    !subst("FORMAT_XYZ", "FORMAT_X",
+    !subst("FORMAT_XYZW", "FORMAT_X", Op)));
+}
+
+
+class MTBUF_Pseudo <string opName, dag outs, dag ins,
+                    string asmOps, list<dag> pattern=[]> :
+  BUF_Pseudo <opName, outs, ins, asmOps, pattern> {
+
+  Instruction BaseOpcode = !cast<Instruction>(MTBUFGetBaseOpcode<NAME>.ret);
+  let MTBUF = 1;
+  let AsmMatchConverter = "cvtMtbuf";
 }
 
 class MTBUF_Real <MTBUF_Pseudo ps, string real_name = ps.Mnemonic> :
   InstSI <ps.OutOperandList, ps.InOperandList, real_name # ps.AsmOperands, []> {
 
   let isPseudo = 0;
   let isCodeGenOnly = 0;
 
class MTBUF_Real <MTBUF_Pseudo ps, string real_name = ps.Mnemonic> :
   bits<1> acc = !if(ps.has_vdata, vdata{9}, 0);
 }
 
 class getMTBUFInsDA<list<RegisterClass> vdataList,
                     list<RegisterClass> vaddrList=[]> {
   RegisterClass vdataClass = !if(!empty(vdataList), ?, !head(vdataList));
   RegisterClass vaddrClass = !if(!empty(vaddrList), ?, !head(vaddrList));
   RegisterOperand vdata_op = getLdStRegisterOperand<vdataClass>.ret;
-  dag InsNoData = !if(!empty(vaddrList),
-    (ins                    SReg_128:$srsrc, SCSrc_b32:$soffset,
-         offset:$offset, FORMAT:$format, CPol:$cpol, SWZ:$swz),
-    (ins vaddrClass:$vaddr, SReg_128:$srsrc, SCSrc_b32:$soffset,
-         offset:$offset, FORMAT:$format, CPol:$cpol, SWZ:$swz)
-  );
-  dag InsData = !if(!empty(vaddrList),
-    (ins vdata_op:$vdata,                    SReg_128:$srsrc,
-         SCSrc_b32:$soffset, offset:$offset, FORMAT:$format, CPol:$cpol,
-         SWZ:$swz),
-    (ins vdata_op:$vdata, vaddrClass:$vaddr, SReg_128:$srsrc,
-         SCSrc_b32:$soffset, offset:$offset, FORMAT:$format, CPol:$cpol,
-         SWZ:$swz)
-  );
-  dag ret = !if(!empty(vdataList), InsNoData, InsData);
+
+  dag NonVaddrInputs = (ins SReg_128:$srsrc, SCSrc_b32:$soffset, offset:$offset, FORMAT:$format, CPol:$cpol, SWZ:$swz);
+  dag Inputs = !if(!empty(vaddrList), NonVaddrInputs, !con((ins vaddrClass:$vaddr), NonVaddrInputs));
+  dag ret = !if(!empty(vdataList), Inputs, !con((ins vdata_op:$vdata), Inputs));
 }
 
+
 class getMTBUFIns<int addrKind, list<RegisterClass> vdataList=[]> {
   dag ret =
     !if(!eq(addrKind, BUFAddrKind.Offset), getMTBUFInsDA<vdataList>.ret,
     !if(!eq(addrKind, BUFAddrKind.OffEn),  getMTBUFInsDA<vdataList, [VGPR_32]>.ret,
     !if(!eq(addrKind, BUFAddrKind.IdxEn),  getMTBUFInsDA<vdataList, [VGPR_32]>.ret,
     !if(!eq(addrKind, BUFAddrKind.BothEn), getMTBUFInsDA<vdataList, [VReg_64]>.ret,
     !if(!eq(addrKind, BUFAddrKind.Addr64), getMTBUFInsDA<vdataList, [VReg_64]>.ret,
     (ins))))));
 }
 
 class getMTBUFAsmOps<int addrKind> {
   string Pfx =
     !if(!eq(addrKind, BUFAddrKind.Offset), "off, $srsrc,$format $soffset",
     !if(!eq(addrKind, BUFAddrKind.OffEn),
             "$vaddr, $srsrc,$format $soffset offen",
     !if(!eq(addrKind, BUFAddrKind.IdxEn),
             "$vaddr, $srsrc,$format $soffset idxen",
     !if(!eq(addrKind, BUFAddrKind.BothEn),
             "$vaddr, $srsrc,$format $soffset idxen offen",
     !if(!eq(addrKind, BUFAddrKind.Addr64),
             "$vaddr, $srsrc,$format $soffset addr64",
     "")))));
-  string ret = Pfx # "$offset";
+  string ret = " $vdata, " # Pfx # "$offset$cpol$swz";
 }
 
 class MTBUF_SetupAddr<int addrKind> {
   bits<1> offen  = !or(!eq(addrKind, BUFAddrKind.OffEn),
                        !eq(addrKind, BUFAddrKind.BothEn));
 
   bits<1> idxen  = !or(!eq(addrKind, BUFAddrKind.IdxEn),
                        !eq(addrKind, BUFAddrKind.BothEn));
 
   bits<1> addr64 = !eq(addrKind, BUFAddrKind.Addr64);
 
   bits<1> has_vaddr = !ne(addrKind, BUFAddrKind.Offset);
 }
 
 class MTBUF_Load_Pseudo <string opName,
                          int addrKind,
                          RegisterClass vdataClass,
                          int elems,
                          list<dag> pattern=[],
                          // Workaround bug bz30254
                          int addrKindCopy = addrKind>
   : MTBUF_Pseudo<opName,
                  (outs getLdStRegisterOperand<vdataClass>.ret:$vdata),
                  getMTBUFIns<addrKindCopy>.ret,
-                 " $vdata, " # getMTBUFAsmOps<addrKindCopy>.ret # "$cpol$swz",
+                 getMTBUFAsmOps<addrKindCopy>.ret,
                  pattern>,
     MTBUF_SetupAddr<addrKindCopy> {
   let PseudoInstr = opName # "_" # getAddrName<addrKindCopy>.ret;
   let mayLoad = 1;
   let mayStore = 0;
   let elements = elems;
 }
 
class MTBUF_Store_Pseudo <string opName,
                           int elems,
                           list<dag> pattern=[],
                           // Workaround bug bz30254
                           int addrKindCopy = addrKind,
                           RegisterClass vdataClassCopy = vdataClass>
   : MTBUF_Pseudo<opName,
                  (outs),
                  getMTBUFIns<addrKindCopy, [vdataClassCopy]>.ret,
-                 " $vdata, " # getMTBUFAsmOps<addrKindCopy>.ret # "$cpol$swz",
+                 getMTBUFAsmOps<addrKindCopy>.ret,
                  pattern>,
     MTBUF_SetupAddr<addrKindCopy> {
   let PseudoInstr = opName # "_" # getAddrName<addrKindCopy>.ret;
   let mayLoad = 0;
   let mayStore = 1;
   let elements = elems;
 }
 

 class MUBUFGetBaseOpcode<string Op> {
   string ret = !subst("DWORDX2", "DWORD",
     !subst("DWORDX3", "DWORD",
     !subst("DWORDX4", "DWORD", Op)));
 }
 
 class MUBUF_Pseudo <string opName, dag outs, dag ins,
                     string asmOps, list<dag> pattern=[]> :
-  InstSI<outs, ins, "", pattern>,
-  SIMCInstr<opName, SIEncodingFamily.NONE> {
-
-  let isPseudo = 1;
-  let isCodeGenOnly = 1;
-  let Size = 8;
-  let UseNamedOperandTable = 1;
+  BUF_Pseudo <opName, outs, ins, asmOps, pattern> {
 
-  string Mnemonic = opName;
-  string AsmOperands = asmOps;
-
-  Instruction Opcode = !cast<Instruction>(NAME);
   Instruction BaseOpcode = !cast<Instruction>(MUBUFGetBaseOpcode<NAME>.ret);
-
-  let VM_CNT = 1;
-  let EXP_CNT = 1;
   let MUBUF = 1;
-  let Uses = [EXEC];
-  let hasSideEffects = 0;
-  let SchedRW = [WriteVMEM];
-
   let AsmMatchConverter = "cvtMubuf";
-
-  bits<1> offen       = 0;
-  bits<1> idxen       = 0;
-  bits<1> addr64      = 0;
-  bits<1> lds         = 0;
-  bits<1> has_vdata   = !not(lds);
-  bits<1> has_vaddr   = 1;
-  bits<1> has_glc     = 1;
-  bits<1> has_dlc     = 1;
-  bits<1> glc_value   = 0; // the value for glc if no such operand
-  bits<1> dlc_value   = 0; // the value for dlc if no such operand
-  bits<1> has_srsrc   = 1;
-  bits<1> has_soffset = 1;
-  bits<1> has_offset  = 1;
-  bits<1> has_slc     = 1;
-  bits<1> tfe         = ?;
-  bits<4> elements    = 0;
-  bits<1> has_sccb    = 1;
-  bits<1> sccb_value  = 0;
-  bits<1> IsBufferInv = 0;
 }
 
 class MUBUF_Real <MUBUF_Pseudo ps, string real_name = ps.Mnemonic> :
   InstSI <ps.OutOperandList, ps.InOperandList, real_name # ps.AsmOperands, []> {
 
   let isPseudo = 0;
   let isCodeGenOnly = 0;
 
class MUBUF_Real <MUBUF_Pseudo ps, string real_name = ps.Mnemonic> :
   bits<7>  srsrc;
   bits<8>  soffset;
 
   // GFX90A+ only: instruction uses AccVGPR for data
   // Bit supersedes tfe.
   bits<1> acc = !if(ps.has_vdata, vdata{9}, !if(ps.lds, ?, 0));
 }
 
-
 // For cache invalidation instructions.
 class MUBUF_Invalidate <string opName, SDPatternOperator node = null_frag> :
   MUBUF_Pseudo<opName, (outs), (ins), "", [(node)]> {
 
   let AsmMatchConverter = "";
 
   let hasSideEffects = 1;
   let mayLoad = 0;
class getLdStVDataRegisterOperand<RegisterClass RC, bit isTFE> {
   RegisterOperand ret = !if(isTFE, tfeVDataOp, getLdStRegisterOperand<RC>.ret);
 }
 
 class getMUBUFInsDA<list<RegisterClass> vdataList,
                     list<RegisterClass> vaddrList, bit isTFE> {
   RegisterClass vdataClass = !if(!empty(vdataList), ?, !head(vdataList));
   RegisterClass vaddrClass = !if(!empty(vaddrList), ?, !head(vaddrList));
   RegisterOperand vdata_op = getLdStVDataRegisterOperand<vdataClass, isTFE>.ret;
-  dag InsNoData = !if(!empty(vaddrList),
-    (ins                    SReg_128:$srsrc, SCSrc_b32:$soffset,
-         offset:$offset, CPol_0:$cpol),
-    (ins vaddrClass:$vaddr, SReg_128:$srsrc, SCSrc_b32:$soffset,
-         offset:$offset, CPol_0:$cpol)
-  );
-  dag InsData = !if(!empty(vaddrList),
-    (ins vdata_op:$vdata,                    SReg_128:$srsrc,
-         SCSrc_b32:$soffset, offset:$offset, CPol_0:$cpol),
-    (ins vdata_op:$vdata, vaddrClass:$vaddr, SReg_128:$srsrc,
-         SCSrc_b32:$soffset, offset:$offset, CPol_0:$cpol)
-  );
-  dag ret = !con(!if(!empty(vdataList), InsNoData, InsData), (ins SWZ_0:$swz));
+
+  dag NonVaddrInputs = (ins SReg_128:$srsrc, SCSrc_b32:$soffset, offset:$offset, CPol_0:$cpol, SWZ_0:$swz);
+  dag Inputs = !if(!empty(vaddrList), NonVaddrInputs, !con((ins vaddrClass:$vaddr), NonVaddrInputs));
+  dag ret = !if(!empty(vdataList), Inputs, !con((ins vdata_op:$vdata), Inputs));
 }
 
 class getMUBUFElements<ValueType vt> {
   int ret =
     !if(!eq(vt, f16), 1,
       !if(!eq(vt, v2f16), 2,
         !if(!eq(vt, v3f16), 3,
           !if(!eq(vt, v4f16), 4,
dag ret =
     !if(!eq(addrKind, BUFAddrKind.Offset), getMUBUFInsDA<vdataList, [], isTFE>.ret,
     !if(!eq(addrKind, BUFAddrKind.OffEn),  getMUBUFInsDA<vdataList, [VGPR_32], isTFE>.ret,
     !if(!eq(addrKind, BUFAddrKind.IdxEn),  getMUBUFInsDA<vdataList, [VGPR_32], isTFE>.ret,
     !if(!eq(addrKind, BUFAddrKind.BothEn), getMUBUFInsDA<vdataList, [VReg_64], isTFE>.ret,
     !if(!eq(addrKind, BUFAddrKind.Addr64), getMUBUFInsDA<vdataList, [VReg_64], isTFE>.ret,
     (ins))))));
 }
 
-class getMUBUFAsmOps<int addrKind> {
-  string Pfx =
+class getMUBUFAsmOps<int addrKind, bit noVdata = 0, bit isLds = 0, bit isTFE = 0, bit isSwz = 0> {
+  string Vdata = !if(noVdata, " ", " $vdata, ");
+  string Lds = !if(isLds, " lds", "");
+  string TFE = !if(isTFE, " tfe", "");
+  string MainArgs =
     !if(!eq(addrKind, BUFAddrKind.Offset), "off, $srsrc, $soffset",
     !if(!eq(addrKind, BUFAddrKind.OffEn),  "$vaddr, $srsrc, $soffset offen",
     !if(!eq(addrKind, BUFAddrKind.IdxEn),  "$vaddr, $srsrc, $soffset idxen",
     !if(!eq(addrKind, BUFAddrKind.BothEn), "$vaddr, $srsrc, $soffset idxen offen",
     !if(!eq(addrKind, BUFAddrKind.Addr64), "$vaddr, $srsrc, $soffset addr64",
     "")))));
-  string ret = Pfx # "$offset";
+  string Offset = "$offset";
+  string OtherArgs = "$cpol";
+  string Swz = !if(isSwz, "$swz", "");
+
+  string ret = Vdata # MainArgs # Offset # OtherArgs # Lds # TFE # Swz;
 }
 
 class MUBUF_SetupAddr<int addrKind> {
   bits<1> offen  = !or(!eq(addrKind, BUFAddrKind.OffEn),
                        !eq(addrKind, BUFAddrKind.BothEn));
 
   bits<1> idxen  = !or(!eq(addrKind, BUFAddrKind.IdxEn),
                        !eq(addrKind, BUFAddrKind.BothEn));
class MUBUF_Load_Pseudo <string opName,
                          // Workaround bug bz30254
                          int addrKindCopy = addrKind,
                          RegisterClass vdata_rc = getVregSrcForVT<vdata_vt>.ret,
                          RegisterOperand vdata_op = getLdStVDataRegisterOperand<vdata_rc, isTFE>.ret>
   : MUBUF_Pseudo<opName,
                  !if(!or(isLds, isLdsOpc), (outs), (outs vdata_op:$vdata)),
                  !con(getMUBUFIns<addrKindCopy, [], isTFE>.ret,
                       !if(HasTiedDest, (ins vdata_op:$vdata_in), (ins))),
-                 !if(!or(isLds, isLdsOpc), " ", " $vdata, ") # getMUBUFAsmOps<addrKindCopy>.ret # "$cpol" #
-                   !if(isLds, " lds", "") # !if(isTFE, " tfe", "") # "$swz",
+                 getMUBUFAsmOps<addrKindCopy, !or(isLds, isLdsOpc), isLds, isTFE, 1>.ret,
                  pattern>,
     MUBUF_SetupAddr<addrKindCopy> {
   let PseudoInstr = opName # !if(isLds, "_lds", "") # !if(isTFE, "_tfe", "") #
                     "_" # getAddrName<addrKindCopy>.ret;
   let AsmMatchConverter = "cvtMubuf";
 
   let Constraints = !if(HasTiedDest, "$vdata = $vdata_in", "");
   let LGKM_CNT = isLds;
class MUBUF_Store_Pseudo <string opName,
                           ValueType store_vt,
                           bit isTFE = 0,
                           list<dag> pattern=[],
                           // Workaround bug bz30254
                           int addrKindCopy = addrKind>
   : MUBUF_Pseudo<opName,
                  (outs),
                  getMUBUFIns<addrKindCopy, [getVregSrcForVT<store_vt>.ret], isTFE>.ret,
-                 " $vdata, " # getMUBUFAsmOps<addrKindCopy>.ret # "$cpol" #
-                   !if(isTFE, " tfe", "") # "$swz",
+                 getMUBUFAsmOps<addrKindCopy, 0, 0, isTFE, 1>.ret,
                  pattern>,
     MUBUF_SetupAddr<addrKindCopy> {
   let PseudoInstr = opName # "_" # !if(isTFE, "_tfe", "") #
                     getAddrName<addrKindCopy>.ret;
   let mayLoad = 0;
   let mayStore = 1;
   let maybeAtomic = 1;
   let elements = getMUBUFElements<store_vt>.ret;
class MUBUF_Pseudo_Store_Lds<string opName>
   let Uses = [EXEC, M0];
   let AsmMatchConverter = "cvtMubuf";
 }
 
 class getMUBUFAtomicInsDA<RegisterClass vdataClass, bit vdata_in,
                           list<RegisterClass> vaddrList=[]> {
   RegisterClass vaddrClass = !if(!empty(vaddrList), ?, !head(vaddrList));
   RegisterOperand vdata_op = getLdStRegisterOperand<vdataClass>.ret;
-  dag ret = !if(vdata_in,
-    !if(!empty(vaddrList),
-      (ins vdata_op:$vdata_in,
-           SReg_128:$srsrc, SCSrc_b32:$soffset, offset:$offset, CPol_GLC1:$cpol),
-      (ins vdata_op:$vdata_in, vaddrClass:$vaddr,
-           SReg_128:$srsrc, SCSrc_b32:$soffset, offset:$offset, CPol_GLC1:$cpol)
-    ),
-    !if(!empty(vaddrList),
-      (ins vdata_op:$vdata,
-           SReg_128:$srsrc, SCSrc_b32:$soffset, offset:$offset, CPol_0:$cpol),
-      (ins vdata_op:$vdata, vaddrClass:$vaddr,
-           SReg_128:$srsrc, SCSrc_b32:$soffset, offset:$offset, CPol_0:$cpol)
-  ));
+
+  dag VData = !if(vdata_in, (ins vdata_op:$vdata_in), (ins vdata_op:$vdata));
+  dag Data = !if(!empty(vaddrList), VData, !con(VData, (ins vaddrClass:$vaddr)));
+  dag MainInputs = (ins SReg_128:$srsrc, SCSrc_b32:$soffset, offset:$offset);
+  dag CPol = !if(vdata_in, (ins CPol_GLC1:$cpol), (ins CPol_0:$cpol));
+
+  dag ret = !con(Data, !con(MainInputs, CPol));
 }
 
 class getMUBUFAtomicIns<int addrKind,
                         RegisterClass vdataClass,
                         bit vdata_in,
                         // Workaround bug bz30254
                         RegisterClass vdataClassCopy=vdataClass> {
   dag ret =
class MUBUF_AtomicNoRet_Pseudo<string opName, int addrKind,
                                RegisterClass vdataClass,
                                list<dag> pattern=[],
                                // Workaround bug bz30254
                                int addrKindCopy = addrKind,
                                RegisterClass vdataClassCopy = vdataClass>
   : MUBUF_Atomic_Pseudo<opName, addrKindCopy,
                         (outs),
                         getMUBUFAtomicIns<addrKindCopy, vdataClassCopy, 0>.ret,
-                        " $vdata, " # getMUBUFAsmOps<addrKindCopy>.ret # "$cpol",
+                        getMUBUFAsmOps<addrKindCopy>.ret,
                         pattern>,
     AtomicNoRet<opName # "_" # getAddrName<addrKindCopy>.ret, 0> {
   let PseudoInstr = opName # "_" # getAddrName<addrKindCopy>.ret;
   let glc_value = 0;
   let dlc_value = 0;
   let sccb_value = 0;
   let IsAtomicNoRet = 1;
 }
 
 class MUBUF_AtomicRet_Pseudo<string opName, int addrKind,
                              RegisterClass vdataClass,
                              list<dag> pattern=[],
                              // Workaround bug bz30254
                              int addrKindCopy = addrKind,
                              RegisterClass vdataClassCopy = vdataClass,
                              RegisterOperand vdata_op = getLdStRegisterOperand<vdataClass>.ret>
   : MUBUF_Atomic_Pseudo<opName, addrKindCopy,
                         (outs vdata_op:$vdata),
                         getMUBUFAtomicIns<addrKindCopy, vdataClassCopy, 1>.ret,
-                        " $vdata, " # getMUBUFAsmOps<addrKindCopy>.ret # "$cpol",
+                        getMUBUFAsmOps<addrKindCopy>.ret,
                         pattern>,
     AtomicNoRet<opName # "_" # getAddrName<addrKindCopy>.ret, 1> {
   let PseudoInstr = opName # "_rtn_" # getAddrName<addrKindCopy>.ret;
   let glc_value = 1;
   let dlc_value = 0;
   let sccb_value = 0;
   let IsAtomicRet = 1;
   let Constraints = "$vdata = $vdata_in";