third_party/llvm-16.0/llvm/lib/Target/AMDGPU/VOPInstructions.td - SwiftShader - Git at Google


            
            //===-- VOPInstructions.td - Vector Instruction Definitions ---------------===//

            
            //

            
            // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

            
            // See https://llvm.org/LICENSE.txt for license information.

            
            // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

            
            //

            
            //===----------------------------------------------------------------------===//


            // dummies for outer let

            
            class LetDummies {

            
              bit TRANS;

            
              bit ReadsModeReg;

            
              bit mayRaiseFPException;

            
              bit isCommutable;

            
              bit isConvertibleToThreeAddress;

            
              bit isMoveImm;

            
              bit isReMaterializable;

            
              bit isAsCheapAsAMove;

            
              bit VOPAsmPrefer32Bit;

            
              bit FPDPRounding;

            
              Predicate SubtargetPredicate;

            
              string Constraints;

            
              string DisableEncoding;

            
              list<SchedReadWrite> SchedRW;

            
              list<Register> Uses;

            
              list<Register> Defs;

            
              list<Predicate> OtherPredicates;

            
              Predicate AssemblerPredicate;

            
              string DecoderNamespace;

            
            }


            class VOP <string opName> {

            
              string OpName = opName;

            
            }


            // First 13 insts from VOPDY are also VOPDX. DOT2ACC_F32_BF16 is omitted

            
            defvar VOPDX_Max_Index = 12;


            class VOPD_Component<bits<5> OpIn, string vOPDName> {

            
              Instruction BaseVOP = !cast<Instruction>(NAME);

            
              string VOPDName = "v_dual_" # !substr(vOPDName, 2);

            
              bits<5> VOPDOp = OpIn;

            
              bit CanBeVOPDX = !le(VOPDOp, VOPDX_Max_Index);

            
            }


            class VOPAnyCommon <dag outs, dag ins, string asm, list<dag> pattern> :

            
                InstSI <outs, ins, asm, pattern> {


              let mayLoad = 0;

            
              let mayStore = 0;

            
              let hasSideEffects = 0;

            
              let UseNamedOperandTable = 1;

            
              let VALU = 1;

            
              let Uses = !if(ReadsModeReg, [MODE, EXEC], [EXEC]);

            
            }


            class VOP_Pseudo <string opName, string suffix, VOPProfile P, dag outs, dag ins,

            
                              string asm, list<dag> pattern> :

            
              InstSI <outs, ins, asm, pattern>,

            
              VOP <opName>,

            
              SIMCInstr <opName#suffix, SIEncodingFamily.NONE> {

            
              let isPseudo = 1;

            
              let isCodeGenOnly = 1;

            
              let UseNamedOperandTable = 1;


              string Mnemonic = opName;

            
              Instruction Opcode = !cast<Instruction>(NAME);

            
              bit IsTrue16 = P.IsTrue16;

            
              VOPProfile Pfl = P;


              string AsmOperands;

            
            }


            class VOP3Common <dag outs, dag ins, string asm = "",

            
                              list<dag> pattern = [], bit HasMods = 0> :

            
              VOPAnyCommon <outs, ins, asm, pattern> {


              // Using complex patterns gives VOP3 patterns a very high complexity rating,

            
              // but standalone patterns are almost always preferred, so we need to adjust the

            
              // priority lower.  The goal is to use a high number to reduce complexity to

            
              // zero (or less than zero).

            
              let AddedComplexity = -1000;


              let VOP3 = 1;


              let AsmVariantName = AMDGPUAsmVariants.VOP3;

            
              let AsmMatchConverter = !if(HasMods, "cvtVOP3", "");


              let isCodeGenOnly = 0;


              int Size = 8;


              // Because SGPRs may be allowed if there are multiple operands, we

            
              // need a post-isel hook to insert copies in order to avoid

            
              // violating constant bus requirements.

            
              let hasPostISelHook = 1;

            
            }


            class VOP3_Pseudo <string opName, VOPProfile P, list<dag> pattern = [],

            
                               bit isVOP3P = 0, bit isVop3OpSel = 0> :

            
              VOP_Pseudo <opName, "_e64", P, P.Outs64,

            
                          !if(isVop3OpSel,

            
                              P.InsVOP3OpSel,

            
                              !if(!and(isVOP3P, P.IsPacked), P.InsVOP3P, P.Ins64)),

            
                          "", pattern> {


              let VOP3_OPSEL = isVop3OpSel;

            
              let IsPacked = P.IsPacked;

            
              let IsMAI = P.IsMAI;

            
              let IsWMMA = P.IsWMMA;


              let AsmOperands = !if(isVop3OpSel,

            
                                    P.AsmVOP3OpSel,

            
                                    !if(!and(isVOP3P, P.IsPacked), P.AsmVOP3P, P.Asm64));


              let Size = 8;

            
              let mayLoad = 0;

            
              let mayStore = 0;

            
              let hasSideEffects = 0;


              // Because SGPRs may be allowed if there are multiple operands, we

            
              // need a post-isel hook to insert copies in order to avoid

            
              // violating constant bus requirements.

            
              let hasPostISelHook = 1;


              // Using complex patterns gives VOP3 patterns a very high complexity rating,

            
              // but standalone patterns are almost always preferred, so we need to adjust the

            
              // priority lower.  The goal is to use a high number to reduce complexity to

            
              // zero (or less than zero).

            
              let AddedComplexity = -1000;


              let VOP3 = 1;

            
              let VALU = 1;

            
              let FPClamp = P.HasFPClamp;

            
              let IntClamp = P.HasIntClamp;

            
              let ClampLo = P.HasClampLo;

            
              let ClampHi = P.HasClampHi;


              let ReadsModeReg = !or(isFloatType<P.DstVT>.ret, isFloatType<P.Src0VT>.ret);


              let mayRaiseFPException = ReadsModeReg;

            
              let Uses = !if(ReadsModeReg, [MODE, EXEC], [EXEC]);


              let AsmVariantName = AMDGPUAsmVariants.VOP3;

            
              let AsmMatchConverter =

            
                !if(isVOP3P,

            
                    "cvtVOP3P",

            
                    !if(!or(P.HasModifiers, P.HasOMod, P.HasIntClamp),

            
                        "cvtVOP3",

            
                        ""));

            
            }


            class VOP3P_Pseudo <string opName, VOPProfile P, list<dag> pattern = []> :

            
              VOP3_Pseudo<opName, P, pattern, 1> {

            
              let VOP3P = 1;

            
            }


            class VOP_Real<VOP_Pseudo ps> {

            
              Instruction Opcode = !cast<Instruction>(NAME);

            
              bit IsSingle = ps.Pfl.IsSingle;

            
            }


            class VOP3_Real <VOP_Pseudo ps, int EncodingFamily, string asm_name = ps.Mnemonic> :

            
              VOP_Real <ps>,

            
              InstSI <ps.OutOperandList, ps.InOperandList, asm_name # ps.AsmOperands, []>,

            
              SIMCInstr <ps.PseudoInstr, EncodingFamily> {


              let VALU = 1;

            
              let VOP3 = 1;

            
              let isPseudo = 0;

            
              let isCodeGenOnly = 0;

            
              let UseNamedOperandTable = 1;


              // copy relevant pseudo op flags

            
              let SubtargetPredicate = ps.SubtargetPredicate;

            
              let OtherPredicates    = ps.OtherPredicates;

            
              let AsmMatchConverter  = ps.AsmMatchConverter;

            
              let AsmVariantName     = ps.AsmVariantName;

            
              let Constraints        = ps.Constraints;

            
              let DisableEncoding    = ps.DisableEncoding;

            
              let TSFlags            = ps.TSFlags;

            
              let UseNamedOperandTable = ps.UseNamedOperandTable;

            
              let Uses                 = ps.Uses;

            
              let Defs                 = ps.Defs;

            
              let SchedRW              = ps.SchedRW;

            
              let mayLoad              = ps.mayLoad;

            
              let mayStore             = ps.mayStore;

            
              let TRANS                = ps.TRANS;


              VOPProfile Pfl = ps.Pfl;

            
            }


            // XXX - Is there any reason to distinguish this from regular VOP3

            
            // here?

            
            class VOP3P_Real<VOP_Pseudo ps, int EncodingFamily, string asm_name = ps.Mnemonic> :

            
              VOP3_Real<ps, EncodingFamily, asm_name> {


              // The v_wmma pseudos have extra constraints that we do not want to impose on the real instruction.

            
              let Constraints        = !if(!eq(!substr(ps.Mnemonic,0,6), "v_wmma"), "", ps.Constraints);

            
            }


            class VOP3a<VOPProfile P> : Enc64 {

            
              bits<4> src0_modifiers;

            
              bits<9> src0;

            
              bits<3> src1_modifiers;

            
              bits<9> src1;

            
              bits<3> src2_modifiers;

            
              bits<9> src2;

            
              bits<1> clamp;

            
              bits<2> omod;


              let Inst{8}     = !if(P.HasSrc0Mods, src0_modifiers{1}, 0);

            
              let Inst{9}     = !if(P.HasSrc1Mods, src1_modifiers{1}, 0);

            
              let Inst{10}    = !if(P.HasSrc2Mods, src2_modifiers{1}, 0);


              let Inst{31-26} = 0x34; //encoding

            
              let Inst{40-32} = !if(P.HasSrc0, src0, 0);

            
              let Inst{49-41} = !if(P.HasSrc1, src1, 0);

            
              let Inst{58-50} = !if(P.HasSrc2, src2, 0);

            
              let Inst{60-59} = !if(P.HasOMod, omod, 0);

            
              let Inst{61}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0);

            
              let Inst{62}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0);

            
              let Inst{63}    = !if(P.HasSrc2Mods, src2_modifiers{0}, 0);

            
            }


            class VOP3a_gfx6_gfx7<bits<9> op, VOPProfile p> : VOP3a<p> {

            
              let Inst{11}    = !if(p.HasClamp, clamp{0}, 0);

            
              let Inst{25-17} = op;

            
            }


            class VOP3a_gfx10<bits<10> op, VOPProfile p> : VOP3a<p> {

            
              let Inst{15}    = !if(p.HasClamp, clamp{0}, 0);

            
              let Inst{25-16} = op;

            
              let Inst{31-26} = 0x35;

            
            }


            class VOP3a_gfx11<bits<10> op, VOPProfile p> : VOP3a_gfx10<op, p>;


            class VOP3a_vi <bits<10> op, VOPProfile P> : VOP3a<P> {

            
              let Inst{25-16} = op;

            
              let Inst{15}    = !if(P.HasClamp, clamp{0}, 0);

            
            }


            class VOP3e_gfx6_gfx7<bits<9> op, VOPProfile p> : VOP3a_gfx6_gfx7<op, p> {

            
              bits<8> vdst;

            
              let Inst{7-0} = !if(p.EmitDst, vdst{7-0}, 0);

            
            }


            class VOP3e_gfx10<bits<10> op, VOPProfile p> : VOP3a_gfx10<op, p> {

            
              bits<8> vdst;

            
              let Inst{7-0} = !if(p.EmitDst, vdst{7-0}, 0);

            
            }


            class VOP3e_gfx11<bits<10> op, VOPProfile p> : VOP3e_gfx10<op, p>;


            class VOP3e_vi <bits<10> op, VOPProfile P> : VOP3a_vi <op, P> {

            
              bits<8> vdst;

            
              let Inst{7-0} = !if(P.EmitDst, vdst{7-0}, 0);

            
            }


            class VOP3OpSel_gfx9 <bits<10> op, VOPProfile P> : VOP3e_vi <op, P> {

            
              let Inst{11} = !if(P.HasSrc0, src0_modifiers{2}, 0);

            
              let Inst{12} = !if(P.HasSrc1, src1_modifiers{2}, 0);

            
              let Inst{13} = !if(P.HasSrc2, src2_modifiers{2}, 0);

            
              let Inst{14} = !if(P.HasDst,  src0_modifiers{3}, 0);

            
            }


            class VOP3OpSel_gfx10<bits<10> op, VOPProfile p> : VOP3e_gfx10<op, p> {

            
              let Inst{11} = !if(p.HasSrc0, src0_modifiers{2}, 0);

            
              let Inst{12} = !if(p.HasSrc1, src1_modifiers{2}, 0);

            
              let Inst{13} = !if(p.HasSrc2, src2_modifiers{2}, 0);

            
              let Inst{14} = !if(p.HasDst,  src0_modifiers{3}, 0);

            
            }


            class VOP3OpSel_gfx11<bits<10> op, VOPProfile p> : VOP3OpSel_gfx10<op, p>;


            class VOP3DotOpSel_gfx11<bits<10> op, VOPProfile p> : VOP3OpSel_gfx11<op, p>{

            
              let Inst{11} = ?;

            
              let Inst{12} = ?;

            
            }


            // NB: For V_INTERP* opcodes, src0 is encoded as src1 and vice versa

            
            class VOP3Interp_vi <bits<10> op, VOPProfile P> : VOP3e_vi <op, P> {

            
              bits<2> attrchan;

            
              bits<6> attr;

            
              bits<1> high;


              let Inst{8}     = 0; // No modifiers for src0

            
              let Inst{61}    = 0;


              let Inst{9}     = !if(P.HasSrc0Mods, src0_modifiers{1}, 0);

            
              let Inst{62}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0);


              let Inst{37-32} = attr;

            
              let Inst{39-38} = attrchan;

            
              let Inst{40}    = !if(P.HasHigh, high, 0);


              let Inst{49-41} = src0;

            
            }


            class VOP3Interp_gfx10<bits<10> op, VOPProfile p> : VOP3e_gfx10<op, p> {

            
              bits<6> attr;

            
              bits<2> attrchan;

            
              bits<1> high;


              let Inst{8}     = 0;

            
              let Inst{9}     = !if(p.HasSrc0Mods, src0_modifiers{1}, 0);

            
              let Inst{37-32} = attr;

            
              let Inst{39-38} = attrchan;

            
              let Inst{40}    = !if(p.HasHigh, high, 0);

            
              let Inst{49-41} = src0;

            
              let Inst{61}    = 0;

            
              let Inst{62}    = !if(p.HasSrc0Mods, src0_modifiers{0}, 0);

            
            }


            class VOP3Interp_gfx11<bits<10> op, VOPProfile p> : VOP3Interp_gfx10<op, p>;


            class VOP3be <VOPProfile P> : Enc64 {

            
              bits<8> vdst;

            
              bits<2> src0_modifiers;

            
              bits<9> src0;

            
              bits<2> src1_modifiers;

            
              bits<9> src1;

            
              bits<2> src2_modifiers;

            
              bits<9> src2;

            
              bits<7> sdst;

            
              bits<2> omod;


              let Inst{7-0}   = vdst;

            
              let Inst{14-8}  = sdst;

            
              let Inst{31-26} = 0x34; //encoding

            
              let Inst{40-32} = !if(P.HasSrc0, src0, 0);

            
              let Inst{49-41} = !if(P.HasSrc1, src1, 0);

            
              let Inst{58-50} = !if(P.HasSrc2, src2, 0);

            
              let Inst{60-59} = !if(P.HasOMod, omod, 0);

            
              let Inst{61}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0);

            
              let Inst{62}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0);

            
              let Inst{63}    = !if(P.HasSrc2Mods, src2_modifiers{0}, 0);

            
            }


            class VOP3Pe <bits<7> op, VOPProfile P> : Enc64 {

            
              bits<8> vdst;

            
              bits<4> src0_modifiers;

            
              bits<9> src0;

            
              bits<4> src1_modifiers;

            
              bits<9> src1;

            
              bits<4> src2_modifiers;

            
              bits<9> src2;

            
              bits<1> clamp;


              let Inst{7-0} = vdst;

            
              let Inst{8} = !if(P.HasSrc0Mods, src0_modifiers{1}, 0); // neg_hi src0

            
              let Inst{9} = !if(P.HasSrc1Mods, src1_modifiers{1}, 0); // neg_hi src1

            
              let Inst{10} = !if(P.HasSrc2Mods, src2_modifiers{1}, 0); // neg_hi src2


              let Inst{11} = !if(!and(P.HasSrc0, P.HasOpSel), src0_modifiers{2}, 0); // op_sel(0)

            
              let Inst{12} = !if(!and(P.HasSrc1, P.HasOpSel), src1_modifiers{2}, 0); // op_sel(1)

            
              let Inst{13} = !if(!and(P.HasSrc2, P.HasOpSel), src2_modifiers{2}, 0); // op_sel(2)


              let Inst{14} = !if(!and(P.HasSrc2, P.HasOpSel), src2_modifiers{3}, ?); // op_sel_hi(2)


              let Inst{15} = !if(P.HasClamp, clamp{0}, 0);


              let Inst{22-16} = op;

            
              let Inst{31-23} = 0x1a7; //encoding

            
              let Inst{40-32} = !if(P.HasSrc0, src0, 0);

            
              let Inst{49-41} = !if(P.HasSrc1, src1, 0);

            
              let Inst{58-50} = !if(P.HasSrc2, src2, 0);

            
              let Inst{59}    = !if(!and(P.HasSrc0, P.HasOpSel), src0_modifiers{3}, ?); // op_sel_hi(0)

            
              let Inst{60}    = !if(!and(P.HasSrc1, P.HasOpSel), src1_modifiers{3}, ?); // op_sel_hi(1)

            
              let Inst{61}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0); // neg (lo)

            
              let Inst{62}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0); // neg (lo)

            
              let Inst{63}    = !if(P.HasSrc2Mods, src2_modifiers{0}, 0); // neg (lo)

            
            }


            class VOP3Pe_MAI <bits<7> op, VOPProfile P, bit acc_cd = 0> : Enc64 {

            
              bits<8> vdst;

            
              bits<10> src0;

            
              bits<10> src1;

            
              bits<9> src2;

            
              bits<3> blgp;

            
              bits<3> cbsz;

            
              bits<4> abid;


              let Inst{7-0} = vdst;


              let Inst{10-8}  = !if(P.HasSrc1, cbsz, 0);

            
              let Inst{14-11} = !if(P.HasSrc1, abid, 0);


              let Inst{15} = acc_cd;


              let Inst{22-16} = op;

            
              let Inst{31-23} = 0x1a7; //encoding

            
              let Inst{40-32} = !if(P.HasSrc0, src0{8-0}, 0);

            
              let Inst{49-41} = !if(P.HasSrc1, src1{8-0}, 0);

            
              let Inst{58-50} = !if(P.HasSrc2, src2, 0);


              let Inst{59}    = !if(P.HasSrc0, src0{9}, 0); // acc(0)

            
              let Inst{60}    = !if(P.HasSrc1, src1{9}, 0); // acc(1)


              let Inst{63-61} = !if(P.HasSrc1, blgp, 0);

            
            }


            class VOP3Pe_SMFMAC <bits<7> op> : Enc64 {

            
              bits<10> vdst; // VGPR or AGPR, but not SGPR. vdst{8} is not encoded in the instruction.

            
              bits<10> src0;

            
              bits<10> src1;

            
              bits<9> idx;

            
              bits<3> blgp;

            
              bits<3> cbsz;

            
              bits<4> abid;


              let blgp = 0;


              let Inst{7-0} = vdst{7-0};


              let Inst{10-8}  = cbsz;

            
              let Inst{14-11} = abid;


              let Inst{15} = vdst{9}; // acc(vdst)


              let Inst{22-16} = op;

            
              let Inst{31-23} = 0x1a7; // encoding

            
              let Inst{40-32} = src0{8-0};

            
              let Inst{49-41} = src1{8-0};

            
              let Inst{58-50} = idx;


              let Inst{59}    = src0{9}; // acc(0)

            
              let Inst{60}    = src1{9}; // acc(1)


              let Inst{63-61} = blgp;

            
            }


            class VOP3Pe_gfx10 <bits<7> op, VOPProfile P> : VOP3Pe<op, P> {

            
              let Inst{31-23} = 0x198; //encoding

            
            }


            class VOP3Pe_gfx11<bits<7> op, VOPProfile P> : VOP3Pe_gfx10<op, P>;


            class VOP3be_gfx6_gfx7<bits<9> op, VOPProfile p> : VOP3be<p> {

            
              let Inst{25-17} = op;

            
            }


            class VOP3be_gfx10<bits<10> op, VOPProfile p> : VOP3be<p> {

            
              bits<1> clamp;

            
              let Inst{15}    = !if(p.HasClamp, clamp{0}, 0);

            
              let Inst{25-16} = op;

            
              let Inst{31-26} = 0x35;

            
            }


            class VOP3be_gfx11<bits<10> op, VOPProfile p> : VOP3be_gfx10<op, p>;


            class VOP3be_vi <bits<10> op, VOPProfile P> : VOP3be<P> {

            
              bits<1> clamp;

            
              let Inst{25-16} = op;

            
              let Inst{15}    = !if(P.HasClamp, clamp{0}, 0);

            
            }


            def SDWA {

            
              // sdwa_sel

            
              int BYTE_0 = 0;

            
              int BYTE_1 = 1;

            
              int BYTE_2 = 2;

            
              int BYTE_3 = 3;

            
              int WORD_0 = 4;

            
              int WORD_1 = 5;

            
              int DWORD = 6;


              // dst_unused

            
              int UNUSED_PAD = 0;

            
              int UNUSED_SEXT = 1;

            
              int UNUSED_PRESERVE = 2;

            
            }


            class VOP_SDWAe<VOPProfile P> : Enc64 {

            
              bits<8> src0;

            
              bits<3> src0_sel;

            
              bits<2> src0_modifiers; // float: {abs,neg}, int {sext}

            
              bits<3> src1_sel;

            
              bits<2> src1_modifiers;

            
              bits<3> dst_sel;

            
              bits<2> dst_unused;

            
              bits<1> clamp;


              let Inst{39-32} = !if(P.HasSrc0, src0{7-0}, 0);

            
              let Inst{42-40} = !if(P.EmitDstSel, dst_sel{2-0}, ?);

            
              let Inst{44-43} = !if(P.EmitDstSel, dst_unused{1-0}, ?);

            
              let Inst{45}    = !if(P.HasSDWAClamp, clamp{0}, 0);

            
              let Inst{50-48} = !if(P.HasSrc0, src0_sel{2-0}, 0);

            
              let Inst{51}    = !if(P.HasSrc0IntMods, src0_modifiers{0}, 0);

            
              let Inst{53-52} = !if(P.HasSrc0FloatMods, src0_modifiers{1-0}, 0);

            
              let Inst{58-56} = !if(P.HasSrc1, src1_sel{2-0}, 0);

            
              let Inst{59}    = !if(P.HasSrc1IntMods, src1_modifiers{0}, 0);

            
              let Inst{61-60} = !if(P.HasSrc1FloatMods, src1_modifiers{1-0}, 0);

            
            }


            // GFX9 adds two features to SDWA:

            
            // 1.	Add 3 fields to the SDWA microcode word: S0, S1 and OMOD.

            
            //    a. S0 and S1 indicate that source 0 and 1 respectively are SGPRs rather

            
            //       than VGPRs (at most 1 can be an SGPR);

            
            //    b. OMOD is the standard output modifier (result *2, *4, /2)

            
            // 2.	Add a new version of the SDWA microcode word for VOPC: SDWAB. This

            
            //    replaces OMOD and the dest fields with SD and SDST (SGPR destination)

            
            //    field.

            
            //    a. When SD=1, the SDST is used as the destination for the compare result;

            
            //    b. When SD=0, VCC is used.

            
            //

            
            // In GFX9, V_MAC_F16, V_MAC_F32 opcodes cannot be used with SDWA


            // gfx9 SDWA basic encoding

            
            class VOP_SDWA9e<VOPProfile P> : Enc64 {

            
              bits<9> src0; // {src0_sgpr{0}, src0{7-0}}

            
              bits<3> src0_sel;

            
              bits<2> src0_modifiers; // float: {abs,neg}, int {sext}

            
              bits<3> src1_sel;

            
              bits<2> src1_modifiers;

            
              bits<1> src1_sgpr;


              let Inst{39-32} = !if(P.HasSrc0, src0{7-0}, 0);

            
              let Inst{50-48} = !if(P.HasSrc0, src0_sel{2-0}, 0);

            
              let Inst{51}    = !if(P.HasSrc0IntMods, src0_modifiers{0}, 0);

            
              let Inst{53-52} = !if(P.HasSrc0FloatMods, src0_modifiers{1-0}, 0);

            
              let Inst{55}    = !if(P.HasSrc0, src0{8}, 0);

            
              let Inst{58-56} = !if(P.HasSrc1, src1_sel{2-0}, 0);

            
              let Inst{59}    = !if(P.HasSrc1IntMods, src1_modifiers{0}, 0);

            
              let Inst{61-60} = !if(P.HasSrc1FloatMods, src1_modifiers{1-0}, 0);

            
              let Inst{63}    = 0; // src1_sgpr - should be specified in subclass

            
            }


            // gfx9 SDWA-A

            
            class VOP_SDWA9Ae<VOPProfile P> : VOP_SDWA9e<P> {

            
              bits<3> dst_sel;

            
              bits<2> dst_unused;

            
              bits<1> clamp;

            
              bits<2> omod;


              let Inst{42-40} = !if(P.EmitDstSel, dst_sel{2-0}, ?);

            
              let Inst{44-43} = !if(P.EmitDstSel, dst_unused{1-0}, ?);

            
              let Inst{45}    = !if(P.HasSDWAClamp, clamp{0}, 0);

            
              let Inst{47-46} = !if(P.HasSDWAOMod, omod{1-0}, 0);

            
            }


            // gfx9 SDWA-B

            
            class VOP_SDWA9Be<VOPProfile P> : VOP_SDWA9e<P> {

            
              bits<8> sdst; // {vcc_sdst{0}, sdst{6-0}}


              let Inst{46-40} = !if(P.EmitDst, sdst{6-0}, ?);

            
              let Inst{47} = !if(P.EmitDst, sdst{7}, 0);

            
            }


            class VOP_SDWA_Pseudo <string opName, VOPProfile P, list<dag> pattern=[]> :

            
              InstSI <P.OutsSDWA, P.InsSDWA, "", pattern>,

            
              VOP <opName>,

            
              SIMCInstr <opName#"_sdwa", SIEncodingFamily.NONE> {


              let isPseudo = 1;

            
              let isCodeGenOnly = 1;

            
              let UseNamedOperandTable = 1;


              string Mnemonic = opName;

            
              string AsmOperands = P.AsmSDWA;

            
              string AsmOperands9 = P.AsmSDWA9;


              let Size = 8;

            
              let mayLoad = 0;

            
              let mayStore = 0;

            
              let hasSideEffects = 0;


              let VALU = 1;

            
              let SDWA = 1;


              let ReadsModeReg = !or(isFloatType<P.DstVT>.ret, isFloatType<P.Src0VT>.ret);


              let mayRaiseFPException = ReadsModeReg;

            
              let Uses = !if(ReadsModeReg, [MODE, EXEC], [EXEC]);


              let SubtargetPredicate = HasSDWA;

            
              let AssemblerPredicate = HasSDWA;

            
              let AsmVariantName = !if(P.HasExtSDWA, AMDGPUAsmVariants.SDWA,

            
                                                     AMDGPUAsmVariants.Disable);

            
              let DecoderNamespace = "SDWA";


              VOPProfile Pfl = P;

            
            }


            class VOP_SDWA_Real <VOP_SDWA_Pseudo ps> :

            
              InstSI <ps.OutOperandList, ps.InOperandList, ps.Mnemonic # ps.AsmOperands, []>,

            
              SIMCInstr <ps.PseudoInstr, SIEncodingFamily.SDWA> {


              let VALU = 1;

            
              let SDWA = 1;

            
              let isPseudo = 0;

            
              let isCodeGenOnly = 0;


              let Defs = ps.Defs;

            
              let Uses = ps.Uses;

            
              let hasSideEffects = ps.hasSideEffects;


              let Constraints     = ps.Constraints;

            
              let DisableEncoding = ps.DisableEncoding;


              // Copy relevant pseudo op flags

            
              let SubtargetPredicate   = ps.SubtargetPredicate;

            
              let AssemblerPredicate   = ps.AssemblerPredicate;

            
              let AsmMatchConverter    = ps.AsmMatchConverter;

            
              let AsmVariantName       = ps.AsmVariantName;

            
              let UseNamedOperandTable = ps.UseNamedOperandTable;

            
              let DecoderNamespace     = ps.DecoderNamespace;

            
              let Constraints          = ps.Constraints;

            
              let DisableEncoding      = ps.DisableEncoding;

            
              let TSFlags              = ps.TSFlags;

            
              let SchedRW              = ps.SchedRW;

            
              let mayLoad              = ps.mayLoad;

            
              let mayStore             = ps.mayStore;

            
              let TRANS                = ps.TRANS;

            
            }


            class Base_VOP_SDWA9_Real <VOP_SDWA_Pseudo ps> :

            
              InstSI <ps.OutOperandList, ps.InOperandList, ps.Mnemonic # ps.AsmOperands9, []> {


              let VALU = 1;

            
              let SDWA = 1;

            
              let isPseudo = 0;

            
              let isCodeGenOnly = 0;


              let Defs = ps.Defs;

            
              let Uses = ps.Uses;

            
              let hasSideEffects = ps.hasSideEffects;


              let Constraints     = ps.Constraints;

            
              let DisableEncoding = ps.DisableEncoding;


              let SubtargetPredicate = HasSDWA9;

            
              let AssemblerPredicate = HasSDWA9;

            
              let AsmVariantName = !if(ps.Pfl.HasExtSDWA9, AMDGPUAsmVariants.SDWA9,

            
                                                           AMDGPUAsmVariants.Disable);

            
              let DecoderNamespace = "SDWA9";


              // Copy relevant pseudo op flags

            
              let AsmMatchConverter    = ps.AsmMatchConverter;

            
              let UseNamedOperandTable = ps.UseNamedOperandTable;

            
              let Constraints          = ps.Constraints;

            
              let DisableEncoding      = ps.DisableEncoding;

            
              let TSFlags              = ps.TSFlags;

            
              let SchedRW              = ps.SchedRW;

            
              let mayLoad              = ps.mayLoad;

            
              let mayStore             = ps.mayStore;

            
              let TRANS                = ps.TRANS;

            
            }


            class VOP_SDWA9_Real <VOP_SDWA_Pseudo ps> :

            
              Base_VOP_SDWA9_Real <ps >,

            
              SIMCInstr <ps.PseudoInstr, SIEncodingFamily.SDWA9>;


            class Base_VOP_SDWA10_Real<VOP_SDWA_Pseudo ps> : Base_VOP_SDWA9_Real<ps> {

            
              let SubtargetPredicate = HasSDWA10;

            
              let AssemblerPredicate = HasSDWA10;

            
              let DecoderNamespace = "SDWA10";

            
            }


            class VOP_SDWA10_Real<VOP_SDWA_Pseudo ps> :

            
              Base_VOP_SDWA10_Real<ps>, SIMCInstr<ps.PseudoInstr, SIEncodingFamily.SDWA10>;


            class VOP_DPPe<VOPProfile P, bit IsDPP16=0> : Enc64 {

            
              bits<2> src0_modifiers;

            
              bits<8> src0;

            
              bits<2> src1_modifiers;

            
              bits<9> dpp_ctrl;

            
              bits<1> bound_ctrl;

            
              bits<4> bank_mask;

            
              bits<4> row_mask;

            
              bit     fi;


              let Inst{39-32} = !if(P.HasSrc0, src0{7-0}, 0);

            
              let Inst{48-40} = dpp_ctrl;

            
              let Inst{50}    = !if(IsDPP16, fi, ?);

            
              let Inst{51}    = bound_ctrl;

            
              let Inst{52}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0); // src0_neg

            
              let Inst{53}    = !if(P.HasSrc0Mods, src0_modifiers{1}, 0); // src0_abs

            
              let Inst{54}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0); // src1_neg

            
              let Inst{55}    = !if(P.HasSrc1Mods, src1_modifiers{1}, 0); // src1_abs

            
              let Inst{59-56} = bank_mask;

            
              let Inst{63-60} = row_mask;

            
            }


            class VOP3_DPPe_Fields_Base {

            
              bits<9> dpp_ctrl;

            
              bits<1> bound_ctrl;

            
              bits<4> bank_mask;

            
              bits<4> row_mask;

            
              bit     fi;

            
            }

            
            class VOP3_DPPe_Fields : VOP3_DPPe_Fields_Base {

            
              bits<8> src0;

            
            }


            // Common refers to common between DPP and DPP8

            
            class VOP3_DPPe_Common_Base<bits<10> op, VOPProfile P> : Enc96 {

            
              bits<4> src0_modifiers;

            
              bits<3> src1_modifiers;

            
              bits<3> src2_modifiers;

            
              bits<1> clamp;

            
              bits<2> omod;


              let Inst{8}     = !if(P.HasSrc0Mods, src0_modifiers{1}, 0);

            
              let Inst{9}     = !if(P.HasSrc1Mods, src1_modifiers{1}, 0);

            
              let Inst{10}    = !if(P.HasSrc2Mods, src2_modifiers{1}, 0);

            
              // OPSEL must be set such that the low result only uses low inputs, and the high result only uses high inputs.

            
              let Inst{11} = !if(P.HasOpSel,!if(P.HasSrc0Mods, src0_modifiers{2}, 0),?);

            
              let Inst{12} = !if(P.HasOpSel,!if(P.HasSrc1Mods, src1_modifiers{2}, 0),?);

            
              let Inst{13} = !if(P.HasOpSel,!if(P.HasSrc2Mods, src2_modifiers{2}, 0),?);

            
              let Inst{14} = !if(P.HasOpSel,!if(P.HasSrc0Mods, src0_modifiers{3}, 0),?);

            
              let Inst{15}    = !if(P.HasClamp, clamp, 0);

            
              let Inst{25-16} = op;

            
              let Inst{31-26} = 0x35;


              let Inst{60-59} = !if(P.HasOMod, omod, 0);

            
              let Inst{61}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0);

            
              let Inst{62}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0);

            
              let Inst{63}    = !if(P.HasSrc2Mods, src2_modifiers{0}, 0);

            
            }


            class VOP3_DPPe_Common<bits<10> op, VOPProfile P> : VOP3_DPPe_Common_Base<op, P> {

            
              bits<8> vdst;

            
              bits<9> src1;

            
              bits<9> src2;


              let Inst{7-0}   = !if(P.EmitDst, vdst{7-0}, 0);

            
              let Inst{49-41} = !if(P.HasSrc1, src1, 0);

            
              let Inst{58-50} = !if(P.HasSrc2, src2, 0);

            
            }


            class VOP3P_DPPe_Common_Base<bits<7> op, VOPProfile P> : Enc96 {

            
              bits<4> src0_modifiers;

            
              bits<4> src1_modifiers;

            
              bits<4> src2_modifiers;

            
              bits<1> clamp;


              let Inst{8} = !if(P.HasSrc0Mods, src0_modifiers{1}, 0); // neg_hi src0

            
              let Inst{9} = !if(P.HasSrc1Mods, src1_modifiers{1}, 0); // neg_hi src1

            
              let Inst{10} = !if(P.HasSrc2Mods, src2_modifiers{1}, 0); // neg_hi src2

            
              let Inst{11} = !if(!and(P.HasSrc0, P.HasOpSel), src0_modifiers{2}, 0); // op_sel(0)

            
              let Inst{12} = !if(!and(P.HasSrc1, P.HasOpSel), src1_modifiers{2}, 0); // op_sel(1)

            
              let Inst{13} = !if(!and(P.HasSrc2, P.HasOpSel), src2_modifiers{2}, 0); // op_sel(2)

            
              let Inst{14} = !if(!and(P.HasSrc2, P.HasOpSel), src2_modifiers{3}, ?); // op_sel_hi(2)

            
              let Inst{15} = !if(P.HasClamp, clamp{0}, 0);

            
              let Inst{22-16} = op;

            
              let Inst{31-23} = 0x198; // encoding

            
              let Inst{59}    = !if(!and(P.HasSrc0, P.HasOpSel), src0_modifiers{3}, ?); // op_sel_hi(0)

            
              let Inst{60}    = !if(!and(P.HasSrc1, P.HasOpSel), src1_modifiers{3}, ?); // op_sel_hi(1)

            
              let Inst{61}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0); // neg (lo)

            
              let Inst{62}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0); // neg (lo)

            
              let Inst{63}    = !if(P.HasSrc2Mods, src2_modifiers{0}, 0); // neg (lo)

            
            }


            class VOP3P_DPPe_Common<bits<7> op, VOPProfile P> : VOP3P_DPPe_Common_Base<op, P> {

            
              bits<8> vdst;

            
              bits<9> src1;

            
              bits<9> src2;


              let Inst{7-0} = vdst;

            
              let Inst{49-41} = !if(P.HasSrc1, src1, 0);

            
              let Inst{58-50} = !if(P.HasSrc2, src2, 0);

            
            }


            class VOP_DPP_Pseudo <string OpName, VOPProfile P, list<dag> pattern=[],

            
              dag Ins = P.InsDPP, string asmOps = P.AsmDPP> :

            
              InstSI <P.OutsDPP, Ins, OpName#asmOps, pattern>,

            
              VOP <OpName>,

            
              SIMCInstr <OpName#"_dpp", SIEncodingFamily.NONE> {


              let isPseudo = 1;

            
              let isCodeGenOnly = 1;


              let mayLoad = 0;

            
              let mayStore = 0;

            
              let hasSideEffects = 0;

            
              let UseNamedOperandTable = 1;


              let VALU = 1;

            
              let DPP = 1;

            
              let Size = 8;


              let ReadsModeReg = !or(isFloatType<P.DstVT>.ret, isFloatType<P.Src0VT>.ret);


              let mayRaiseFPException = ReadsModeReg;

            
              let Uses = !if(ReadsModeReg, [MODE, EXEC], [EXEC]);

            
              let isConvergent = 1;


              string Mnemonic = OpName;

            
              string AsmOperands = asmOps;


              let AsmMatchConverter = !if(P.HasModifiers, "cvtDPP", "");

            
              let SubtargetPredicate = !if(P.HasExt64BitDPP, Has64BitDPP, HasDPP);

            
              let AssemblerPredicate = !if(P.HasExt64BitDPP, Has64BitDPP, HasDPP);

            
              let AsmVariantName = !if(P.HasExtDPP, AMDGPUAsmVariants.DPP,

            
                                                    AMDGPUAsmVariants.Disable);

            
              let Constraints = !if(P.NumSrcArgs, P.TieRegDPP # " = $vdst", "");

            
              let DisableEncoding = !if(P.NumSrcArgs, P.TieRegDPP, "");

            
              let DecoderNamespace = "DPP";


              VOPProfile Pfl = P;

            
            }


            class VOP3_DPP_Pseudo <string OpName, VOPProfile P> :

            
              VOP_DPP_Pseudo <OpName, P, [], P.InsVOP3DPP, P.AsmVOP3DPP> {

            
              let PseudoInstr = OpName#"_e64"#"_dpp";

            
              let OutOperandList = P.OutsVOP3DPP;

            
              let Size = 12;

            
              let VOP3 = 1;

            
              let AsmMatchConverter = "cvtVOP3DPP";

            
              let AsmVariantName = !if(P.HasExtVOP3DPP, AMDGPUAsmVariants.VOP3_DPP,

            
                                                        AMDGPUAsmVariants.Disable);

            
            }


            class VOP_DPP_Real <VOP_DPP_Pseudo ps, int EncodingFamily> :

            
              InstSI <ps.OutOperandList, ps.InOperandList, ps.Mnemonic # ps.AsmOperands, []>,

            
              SIMCInstr <ps.PseudoInstr, EncodingFamily> {


              let VALU = 1;

            
              let DPP = 1;

            
              let isPseudo = 0;

            
              let isCodeGenOnly = 0;


              let Defs = ps.Defs;

            
              let Uses = ps.Uses;

            
              let hasSideEffects = ps.hasSideEffects;


              let Constraints     = ps.Constraints;

            
              let DisableEncoding = ps.DisableEncoding;


              // Copy relevant pseudo op flags

            
              let isConvergent         = ps.isConvergent;

            
              let SubtargetPredicate   = ps.SubtargetPredicate;

            
              let AssemblerPredicate   = ps.AssemblerPredicate;

            
              let OtherPredicates      = ps.OtherPredicates;

            
              let AsmMatchConverter    = ps.AsmMatchConverter;

            
              let AsmVariantName       = ps.AsmVariantName;

            
              let UseNamedOperandTable = ps.UseNamedOperandTable;

            
              let DecoderNamespace     = ps.DecoderNamespace;

            
              let Constraints          = ps.Constraints;

            
              let DisableEncoding      = ps.DisableEncoding;

            
              let TSFlags              = ps.TSFlags;

            
              let SchedRW              = ps.SchedRW;

            
              let mayLoad              = ps.mayLoad;

            
              let mayStore             = ps.mayStore;

            
              let TRANS                = ps.TRANS;

            
            }


            class VOP_DPP_Base <string OpName, VOPProfile P,

            
                           dag InsDPP,

            
                           string AsmDPP > :

            
              InstSI <P.OutsDPP, InsDPP, OpName#AsmDPP, []> {


              let mayLoad = 0;

            
              let mayStore = 0;

            
              let hasSideEffects = 0;

            
              let UseNamedOperandTable = 1;


              let VALU = 1;

            
              let DPP = 1;

            
              let Size = 8;


              let AsmMatchConverter = !if(P.HasModifiers, "cvtDPP", "");

            
              let SubtargetPredicate = !if(P.HasExt64BitDPP, Has64BitDPP, HasDPP);

            
              let AssemblerPredicate = !if(P.HasExt64BitDPP, Has64BitDPP, HasDPP);

            
              let AsmVariantName = !if(P.HasExtDPP, AMDGPUAsmVariants.DPP,

            
                                                    AMDGPUAsmVariants.Disable);

            
              let Constraints = !if(P.NumSrcArgs, P.TieRegDPP # " = $vdst", "");

            
              let DisableEncoding = !if(P.NumSrcArgs, P.TieRegDPP, "");

            
              let DecoderNamespace = "DPP";

            
            }


            class VOP_DPP <string OpName, VOPProfile P, bit IsDPP16,

            
                           dag InsDPP = !if(IsDPP16, P.InsDPP16, P.InsDPP),

            
                           string AsmDPP = !if(IsDPP16, P.AsmDPP16, P.AsmDPP)> :

            
              VOP_DPP_Base<OpName, P, InsDPP, AsmDPP>, VOP_DPPe<P, IsDPP16>;


            class VOP3_DPP_Base <string OpName, VOPProfile P, bit IsDPP16,

            
                           dag InsDPP = !if(IsDPP16, P.InsVOP3DPP16, P.InsVOP3DPP),

            
                           string AsmDPP = !if(IsDPP16, P.AsmVOP3DPP16, P.AsmVOP3DPP)> :

            
              VOP_DPP_Base<OpName, P, InsDPP, AsmDPP> {

            
              let OutOperandList = P.OutsVOP3DPP;

            
              let AsmMatchConverter = "cvtVOP3DPP";

            
              let VOP3 = 1;

            
              let AsmVariantName = !if(P.HasExtVOP3DPP, AMDGPUAsmVariants.VOP3_DPP,

            
                                                        AMDGPUAsmVariants.Disable);

            
              let Size = 12;

            
            }


            class VOP3_DPP <bits<10> op, string OpName, VOPProfile P, bit IsDPP16,

            
                           dag InsDPP = !if(IsDPP16, P.InsVOP3DPP16, P.InsVOP3DPP),

            
                           string AsmDPP = !if(IsDPP16, P.AsmVOP3DPP16, P.AsmVOP3DPP)> :

            
              VOP3_DPP_Base<OpName, P, IsDPP16, InsDPP, AsmDPP>, VOP3_DPPe_Common<op, P>,

            
              VOP3_DPPe_Fields {


              let Inst{40-32} = 0xfa;

            
              let Inst{71-64} = !if(P.HasSrc0, src0{7-0}, 0);

            
              let Inst{80-72} = dpp_ctrl;

            
              let Inst{82}    = !if(IsDPP16, fi, ?);

            
              let Inst{83}    = bound_ctrl;


              // Inst{87-84} ignored by hw

            
              let Inst{91-88} = bank_mask;

            
              let Inst{95-92} = row_mask;

            
            }


            class VOP3P_DPP <bits<7> op, string OpName, VOPProfile P, bit IsDPP16,

            
                           dag InsDPP = !if(IsDPP16, P.InsVOP3DPP16, P.InsVOP3DPP),

            
                           string AsmDPP = !if(IsDPP16, P.AsmVOP3DPP16, P.AsmVOP3DPP)> :

            
              VOP3_DPP_Base<OpName, P, IsDPP16, InsDPP, AsmDPP>, VOP3P_DPPe_Common<op, P>,

            
              VOP3_DPPe_Fields {


              let VOP3P = 1;


              let Inst{40-32} = 0xfa;

            
              let Inst{71-64} = !if(P.HasSrc0, src0{7-0}, 0);

            
              let Inst{80-72} = dpp_ctrl;

            
              let Inst{82}    = !if(IsDPP16, fi, ?);

            
              let Inst{83}    = bound_ctrl;


              // Inst{87-84} ignored by hw

            
              let Inst{91-88} = bank_mask;

            
              let Inst{95-92} = row_mask;

            
            }


            class VOP_DPP8e<VOPProfile P> : Enc64 {

            
              bits<8> src0;

            
              bits<24> dpp8;

            
              bits<9> fi;


              let Inst{39-32} = !if(P.HasSrc0, src0{7-0}, 0);

            
              let Inst{63-40} = dpp8{23-0};

            
            }


            class VOP3_DPP8e_Fields {

            
              bits<8> src0;

            
              bits<24> dpp8;

            
              bits<9> fi;

            
            }


            class VOP_DPP8_Base<string OpName, VOPProfile P, dag InsDPP8 = P.InsDPP8, string AsmDPP8 = P.AsmDPP8> :

            
              InstSI<P.OutsDPP8, InsDPP8, OpName#AsmDPP8, []> {


              let mayLoad = 0;

            
              let mayStore = 0;

            
              let hasSideEffects = 0;

            
              let UseNamedOperandTable = 1;


              let VALU = 1;

            
              let DPP = 1;

            
              let Size = 8;


              let AsmMatchConverter = "cvtDPP8";

            
              let SubtargetPredicate = HasDPP8;

            
              let AssemblerPredicate = HasDPP8;

            
              let AsmVariantName = AMDGPUAsmVariants.DPP;

            
              let Constraints = !if(P.NumSrcArgs, P.TieRegDPP # " = $vdst", "");

            
              let DisableEncoding = !if(P.NumSrcArgs, P.TieRegDPP, "");

            
            }


            class VOP_DPP8<string OpName, VOPProfile P> :

            
              VOP_DPP8_Base<OpName, P>, VOP_DPP8e<P>;


            class VOP3_DPP8_Base<string OpName, VOPProfile P> :

            
              VOP_DPP8_Base<OpName, P, P.InsVOP3DPP8, P.AsmVOP3DPP8> {

            
              let OutOperandList = P.OutsVOP3DPP8;

            
              let AsmMatchConverter = "cvtVOP3DPP8";

            
              let AsmVariantName = !if(P.HasExtVOP3DPP, AMDGPUAsmVariants.VOP3_DPP,

            
                                                        AMDGPUAsmVariants.Disable);

            
              let VOP3 = 1;

            
              let Size = 12;

            
            }


            class VOP3_DPP8<bits<10> op, string OpName, VOPProfile P> :

            
              VOP3_DPP8_Base<OpName, P>, VOP3_DPPe_Common<op, P>,

            
              VOP3_DPP8e_Fields {


              let Inst{40-32} = fi;

            
              let Inst{71-64} = !if(P.HasSrc0, src0{7-0}, 0);

            
              let Inst{95-72} = dpp8{23-0};

            
            }


            class VOP3P_DPP8<bits<7> op, string OpName, VOPProfile P> :

            
              VOP3_DPP8_Base<OpName, P>, VOP3P_DPPe_Common<op, P>,

            
              VOP3_DPP8e_Fields {


              let VOP3P = 1;

            
              let Inst{40-32} = fi;

            
              let Inst{71-64} = !if(P.HasSrc0, src0{7-0}, 0);

            
              let Inst{95-72} = dpp8{23-0};

            
            }


            def DPP8Mode {

            
              int FI_0 = 0xE9;

            
              int FI_1 = 0xEA;

            
            }


            class getNumNodeArgs<SDPatternOperator Op> {

            
              SDNode N = !cast<SDNode>(Op);

            
              SDTypeProfile TP = N.TypeProfile;

            
              int ret = TP.NumOperands;

            
            }


            class getDivergentFrag<SDPatternOperator Op> {

            
              assert !or(!isa<SDNode>(Op), !isa<PatFrags>(Op)), "Expected SDNode or PatFrags";


              int NumSrcArgs = !if(!isa<SDNode>(Op), getNumNodeArgs<Op>.ret,

            
                !size(!cast<PatFrags>(Op).Operands));

            
              PatFrag ret = PatFrag <

            
                !if(!eq(NumSrcArgs, 1),

            
                         (ops node:$src0),

            
                         !if(!eq(NumSrcArgs, 2),

            
                           (ops node:$src0, node:$src1),

            
                           (ops node:$src0, node:$src1, node:$src2))),

            
                !if(!eq(NumSrcArgs, 1),

            
                         (Op $src0),

            
                         !if(!eq(NumSrcArgs, 2),

            
                           (Op $src0, $src1),

            
                           (Op $src0, $src1, $src2))),

            
                [{ return N->isDivergent(); }]

            
              >;

            
            }


            class VOPPatGen<SDPatternOperator Op, VOPProfile P> {

            
              PatFrag Operator = getDivergentFrag < Op >.ret;


              dag Ins = !foreach(tmp, P.Ins32, !subst(ins, Operator,

            
                                                     !subst(P.Src0RC32, P.Src0VT,

            
                                                           !subst(P.Src1RC32, P.Src1VT, tmp))));


              dag Outs = !foreach(tmp, P.Outs32, !subst(outs, set,

            
                                                       !subst(P.DstRC, P.DstVT, tmp)));


              list<dag> ret =  [!con(Outs, (set Ins))];

            
            }


            class DivergentUnaryFrag<SDPatternOperator Op> : PatFrag <

            
              (ops node:$src0),

            
              (Op $src0),

            
              [{ return N->isDivergent(); }]> {

            
              // This check is unnecessary as it's captured by the result register

            
              // bank constraint.

            
              //

            
              // FIXME: Should add a way for the emitter to recognize this is a

            
              // trivially true predicate to eliminate the check.

            
              let GISelPredicateCode = [{return true;}];

            
            }


            class VOPPatOrNull<SDPatternOperator Op, VOPProfile P> {

            
              list<dag> ret = !if(!ne(P.NeedPatGen,PatGenMode.NoPattern), VOPPatGen<Op, P>.ret, []);

            
            }


            class DivergentFragOrOp<SDPatternOperator Op, VOPProfile P> {

            
              SDPatternOperator ret = !if(!eq(P.NeedPatGen,PatGenMode.Pattern),

            
               !if(!isa<SDNode>(Op), getDivergentFrag<Op>.ret, Op), Op);

            
            }


            class getVSrcOp<ValueType vt> {

            
              RegisterOperand ret = !if(!eq(vt.Size, 32), VSrc_b32, VSrc_b16);

            
            }


            // Class for binary integer operations with the clamp bit set for saturation

            
            // TODO: Add sub with negated inline constant pattern.

            
            class VOPBinOpClampPat<SDPatternOperator node, Instruction inst, ValueType vt> :

            
              GCNPat<(node vt:$src0, vt:$src1),

            
                     (inst getVSrcOp<vt>.ret:$src0, getVSrcOp<vt>.ret:$src1,

            
                           DSTCLAMP.ENABLE)

            
            >;


            //===----------------------------------------------------------------------===//

            
            // VOP3 Classes

            
            //===----------------------------------------------------------------------===//


            class getVOP3ModPat<VOPProfile P, SDPatternOperator node> {

            
              dag src0 = !if(P.HasOMod,

            
                (VOP3Mods0 P.Src0VT:$src0, i32:$src0_modifiers, i1:$clamp, i32:$omod),

            
                (VOP3Mods0 P.Src0VT:$src0, i32:$src0_modifiers, i1:$clamp));


              list<dag> ret3 = [(set P.DstVT:$vdst,

            
                (DivergentFragOrOp<node, P>.ret (P.Src0VT src0),

            
                      (P.Src1VT (VOP3Mods P.Src1VT:$src1, i32:$src1_modifiers)),

            
                      (P.Src2VT (VOP3Mods P.Src2VT:$src2, i32:$src2_modifiers))))];


              list<dag> ret2 = [(set P.DstVT:$vdst,

            
                (DivergentFragOrOp<node, P>.ret (P.Src0VT src0),

            
                      (P.Src1VT (VOP3Mods P.Src1VT:$src1, i32:$src1_modifiers))))];


              list<dag> ret1 = [(set P.DstVT:$vdst,

            
                (DivergentFragOrOp<node, P>.ret (P.Src0VT src0)))];


              list<dag> ret = !if(!eq(P.NumSrcArgs, 3), ret3,

            
                              !if(!eq(P.NumSrcArgs, 2), ret2,

            
                              ret1));

            
            }


            class getVOP3PModPat<VOPProfile P, SDPatternOperator node, bit HasExplicitClamp,

            
                                 bit IsDOT = 0,

            
                                 ComplexPattern SrcPat = !if(IsDOT, VOP3PModsDOT, VOP3PMods)> {

            
              dag src0_dag = (P.Src0VT (SrcPat P.Src0VT:$src0, i32:$src0_modifiers));

            
              dag src1_dag = (P.Src1VT (SrcPat P.Src1VT:$src1, i32:$src1_modifiers));

            
              dag src2_dag = (P.Src2VT (SrcPat P.Src2VT:$src2, i32:$src2_modifiers));

            
              dag clamp_dag = (i1 timm:$clamp);


              list<dag> ret3 = [(set P.DstVT:$vdst,

            
                !if(HasExplicitClamp,

            
                    (DivergentFragOrOp<node, P>.ret src0_dag, src1_dag, src2_dag, clamp_dag),

            
                    (DivergentFragOrOp<node, P>.ret src0_dag, src1_dag, src2_dag)))];


              list<dag> ret2 = [(set P.DstVT:$vdst,

            
                !if(HasExplicitClamp,

            
                    (DivergentFragOrOp<node, P>.ret src0_dag, src1_dag, clamp_dag),

            
                    (DivergentFragOrOp<node, P>.ret src0_dag, src1_dag)))];


              list<dag> ret1 = [(set P.DstVT:$vdst,

            
                !if(HasExplicitClamp,

            
                    (DivergentFragOrOp<node, P>.ret src0_dag, clamp_dag),

            
                    (DivergentFragOrOp<node, P>.ret src0_dag)))];


              list<dag> ret = !if(!eq(P.NumSrcArgs, 3), ret3,

            
                              !if(!eq(P.NumSrcArgs, 2), ret2,

            
                              ret1));

            
            }


            class getVOP3OpSelPat<VOPProfile P, SDPatternOperator node> {

            
              list<dag> ret3 = [(set P.DstVT:$vdst,

            
                    (DivergentFragOrOp<node, P>.ret (P.Src0VT (VOP3OpSel P.Src0VT:$src0, i32:$src0_modifiers)),

            
                      (P.Src1VT (VOP3OpSel P.Src1VT:$src1, i32:$src1_modifiers)),

            
                      (P.Src2VT (VOP3OpSel P.Src2VT:$src2, i32:$src2_modifiers))))];


              list<dag> ret2 = [(set P.DstVT:$vdst,

            
                (DivergentFragOrOp<node, P>.ret (P.Src0VT (VOP3OpSel P.Src0VT:$src0, i32:$src0_modifiers)),

            
                                                (P.Src1VT (VOP3OpSel P.Src1VT:$src1, i32:$src1_modifiers))))];


              list<dag> ret1 = [(set P.DstVT:$vdst,

            
                (DivergentFragOrOp<node, P>.ret (P.Src0VT (VOP3OpSel P.Src0VT:$src0, i32:$src0_modifiers))))];


              list<dag> ret = !if(!eq(P.NumSrcArgs, 3), ret3,

            
                              !if(!eq(P.NumSrcArgs, 2), ret2,

            
                              ret1));

            
            }


            class getVOP3OpSelModPat<VOPProfile P, SDPatternOperator node> {

            
              list<dag> ret3 = [(set P.DstVT:$vdst,

            
                (DivergentFragOrOp<node, P>.ret (P.Src0VT !if(P.HasClamp, (VOP3OpSelMods P.Src0VT:$src0, i32:$src0_modifiers),

            
                                                (VOP3OpSelMods P.Src0VT:$src0, i32:$src0_modifiers))),

            
                      (P.Src1VT (VOP3OpSelMods P.Src1VT:$src1, i32:$src1_modifiers)),

            
                      (P.Src2VT (VOP3OpSelMods P.Src2VT:$src2, i32:$src2_modifiers))))];


              list<dag> ret2 = [(set P.DstVT:$vdst,

            
                (DivergentFragOrOp<node, P>.ret !if(P.HasClamp, (P.Src0VT (VOP3OpSelMods P.Src0VT:$src0, i32:$src0_modifiers)),

            
                                      (P.Src0VT (VOP3OpSelMods P.Src0VT:$src0, i32:$src0_modifiers))),

            
                      (P.Src1VT (VOP3OpSelMods P.Src1VT:$src1, i32:$src1_modifiers))))];


              list<dag> ret1 = [(set P.DstVT:$vdst,

            
                (DivergentFragOrOp<node, P>.ret (P.Src0VT (VOP3OpSelMods P.Src0VT:$src0, i32:$src0_modifiers))))];


              list<dag> ret = !if(!eq(P.NumSrcArgs, 3), ret3,

            
                              !if(!eq(P.NumSrcArgs, 2), ret2,

            
                              ret1));

            
            }


            class getVOP3FromVOP2Pat<VOPProfile P, SDPatternOperator node> {

            
              list<dag> ret = [(set P.DstVT:$vdst, (node P.Src0VT:$src0, P.Src1VT:$src1))];

            
            }

            
            // In VOP1, we can have clamp and omod even if !HasModifiers

            
            class getVOP3Pat<VOPProfile P, SDPatternOperator node> {

            
              dag src0 =

            
                !if(P.HasOMod,

            
                  !if(P.HasClamp,

            
                      (VOP3Mods0 P.Src0VT:$src0, i1:$clamp, i32:$omod),

            
                      (VOP3Mods0 P.Src0VT:$src0, i32:$omod)), // impossible?

            
                  !if(P.HasClamp,

            
                      (VOP3Mods0 P.Src0VT:$src0, i1:$clamp),

            
                      (VOP3Mods0 P.Src0VT:$src0))

            
                );

            
              list<dag> ret3 = [(set P.DstVT:$vdst, (DivergentFragOrOp<node, P>.ret (P.Src0VT src0), P.Src1VT:$src1, P.Src2VT:$src2))];


              list<dag> ret2 = [(set P.DstVT:$vdst, (DivergentFragOrOp<node, P>.ret (P.Src0VT src0), P.Src1VT:$src1))];


              list<dag> ret1 = [(set P.DstVT:$vdst, (DivergentFragOrOp<node, P>.ret (P.Src0VT src0)))];

            
              list<dag> ret = !if(!eq(P.NumSrcArgs, 3), ret3,

            
                              !if(!eq(P.NumSrcArgs, 2), ret2,

            
                              ret1));

            
            }


            class getVOP3ClampPat<VOPProfile P, SDPatternOperator node> {

            
              list<dag> ret3 = [(set P.DstVT:$vdst, (node P.Src0VT:$src0, P.Src1VT:$src1, P.Src2VT:$src2, i1:$clamp))];

            
              list<dag> ret2 = [(set P.DstVT:$vdst, (node P.Src0VT:$src0, P.Src1VT:$src1, i1:$clamp))];

            
              list<dag> ret1 = [(set P.DstVT:$vdst, (node P.Src0VT:$src0, i1:$clamp))];

            
              list<dag> ret = !if(!eq(P.NumSrcArgs, 3), ret3,

            
                              !if(!eq(P.NumSrcArgs, 2), ret2,

            
                              ret1));

            
            }


            class getVOP3MAIPat<VOPProfile P, SDPatternOperator node> {

            
              list<dag> ret = !if(!eq(P.Src0VT, P.Src1VT),

            
                                  // mfma

            
                                  [(set P.DstVT:$vdst, (node P.Src0VT:$src0, P.Src1VT:$src1, P.Src2VT:$src2,

            
                                                        timm:$cbsz, timm:$abid, timm:$blgp))],

            
                                  // smfmac

            
                                  [(set P.DstVT:$vdst, (node P.Src0VT:$src0, P.Src1VT:$src1, P.Src2VT:$src2, i32:$idx,

            
                                                        timm:$cbsz, timm:$abid))]);

            
            }


            class VOP3Features<bit Clamp, bit OpSel, bit Packed, bit MAI> {

            
              bit HasClamp = Clamp;

            
              bit HasOpSel = OpSel;

            
              bit IsPacked = Packed;

            
              bit IsMAI = MAI;

            
            }


            def VOP3_REGULAR : VOP3Features<0, 0, 0, 0>;

            
            def VOP3_CLAMP   : VOP3Features<1, 0, 0, 0>;

            
            def VOP3_OPSEL   : VOP3Features<1, 1, 0, 0>;

            
            def VOP3_PACKED  : VOP3Features<1, 1, 1, 0>;

            
            def VOP3_MAI     : VOP3Features<0, 0, 0, 1>;


            class VOP3_Profile_Base<VOPProfile P, VOP3Features Features = VOP3_REGULAR> : VOPProfile<P.ArgVT> {


              let HasClamp = !if(Features.HasClamp, 1, P.HasClamp);

            
              let HasOpSel = !if(Features.HasOpSel, 1, P.HasOpSel);

            
              let IsMAI    = !if(Features.IsMAI,    1, P.IsMAI);

            
              let IsPacked = !if(Features.IsPacked, 1, P.IsPacked);


              let HasModifiers =

            
                  !if (Features.IsMAI, 0,

            
                       !or(Features.IsPacked, Features.HasOpSel, P.HasModifiers));

            
            }


            class VOP3_Profile<VOPProfile P, VOP3Features Features = VOP3_REGULAR> : VOP3_Profile_Base<P, Features> {

            
              let IsSingle = 1;


            }


            // consistently gives instructions a _e64 suffix

            
            multiclass VOP3Inst_Pseudo_Wrapper<string opName, VOPProfile P, list<dag> pattern = [], bit VOP3Only = 0> {

            
                def _e64 : VOP3_Pseudo<opName, P, pattern, VOP3Only>;

            
            }


            class VOP3InstBase<string OpName, VOPProfile P, SDPatternOperator node = null_frag, bit IsVOP2 = 0> :

            
              VOP3_Pseudo<OpName, P,

            
                !if(P.HasOpSel,

            
                    !if(P.HasModifiers,

            
                        getVOP3OpSelModPat<P, node>.ret,

            
                        getVOP3OpSelPat<P, node>.ret),

            
                    !if(P.HasModifiers,

            
                        getVOP3ModPat<P, node>.ret,

            
                        !if(IsVOP2,

            
                          getVOP3FromVOP2Pat<P, node>.ret,

            
                          !if(P.HasIntClamp,

            
                              getVOP3ClampPat<P, node>.ret,

            
                              !if (P.IsMAI,

            
                                  getVOP3MAIPat<P, node>.ret,

            
                                  getVOP3Pat<P, node>.ret))))),

            
                0, P.HasOpSel> {


              let IntClamp = P.HasIntClamp;

            
              let AsmMatchConverter =

            
                !if(P.HasOpSel,

            
                    "cvtVOP3OpSel",

            
                    !if(!or(P.HasModifiers, P.HasOMod, P.HasIntClamp),

            
                        "cvtVOP3",

            
                        ""));

            
            }


            multiclass VOP3Inst<string OpName, VOPProfile P, SDPatternOperator node = null_frag> {

            
              def _e64 : VOP3InstBase<OpName, P, node>;

            
              let SubtargetPredicate = isGFX11Plus in {

            
                foreach _ = BoolToList<P.HasExtVOP3DPP>.ret in

            
                  def _e64_dpp : VOP3_DPP_Pseudo <OpName, P>;

            
              } // end SubtargetPredicate = isGFX11Plus

            
            }


            //===----------------------------------------------------------------------===//

            
            // VOP3 DPP

            
            //===----------------------------------------------------------------------===//


            class Base_VOP3_DPP16<bits<10> op, VOP_DPP_Pseudo ps, string opName = ps.OpName>

            
                : VOP3_DPP<op, opName, ps.Pfl, 1> {

            
              let VOP3_OPSEL = ps.Pfl.HasOpSel;

            
              let IsDOT = ps.IsDOT;

            
              let hasSideEffects = ps.hasSideEffects;

            
              let Defs = ps.Defs;

            
              let SchedRW = ps.SchedRW;

            
              let Uses = ps.Uses;

            
              let AssemblerPredicate = HasDPP16;

            
              let SubtargetPredicate = HasDPP16;

            
              let OtherPredicates = ps.OtherPredicates;

            
            }


            class VOP3_DPP16<bits<10> op, VOP_DPP_Pseudo ps, int subtarget,

            
                             string opName = ps.OpName>

            
                : Base_VOP3_DPP16<op, ps, opName>, SIMCInstr<ps.PseudoInstr, subtarget>;


            class Base_VOP3_DPP8<bits<10> op, VOP_Pseudo ps, string opName = ps.OpName>

            
                : VOP3_DPP8<op, opName, ps.Pfl> {

            
              let VOP3_OPSEL = ps.Pfl.HasOpSel;

            
              let IsDOT = ps.IsDOT;

            
              let hasSideEffects = ps.hasSideEffects;

            
              let Defs = ps.Defs;

            
              let SchedRW = ps.SchedRW;

            
              let Uses = ps.Uses;


              let OtherPredicates = ps.OtherPredicates;

            
            }


            class Base_VOP3b_DPP16<bits<10> op, VOP_DPP_Pseudo ps,

            
                                   string opName = ps.OpName>

            
                : Base_VOP3_DPP16<op, ps, opName> {

            
              bits<7> sdst;

            
              let Inst{14 - 8} = sdst;

            
            }


            class VOP3b_DPP8_Base<bits<10> op, VOP_Pseudo ps, string opName = ps.OpName>

            
                : Base_VOP3_DPP8<op, ps, opName> {

            
              bits<7> sdst;

            
              let Inst{14 - 8} = sdst;

            
            }


            //===----------------------------------------------------------------------===//

            
            // VOP3 GFX11

            
            //===----------------------------------------------------------------------===//


            let AssemblerPredicate = isGFX11Only,

            
                DecoderNamespace = "GFX11" in {

            
              multiclass VOP3_Real_Base_gfx11<bits<10> op, string opName = NAME,

            
                                              bit isSingle = 0> {

            
                defvar ps = !cast<VOP_Pseudo>(opName#"_e64");

            
                let IsSingle = !or(isSingle, ps.Pfl.IsSingle) in {

            
                foreach _ = BoolToList<ps.Pfl.HasOpSel>.ret in

            
                  def _e64_gfx11 :

            
                    VOP3_Real<ps, SIEncodingFamily.GFX11>,

            
                    VOP3OpSel_gfx11<op, ps.Pfl>;

            
                foreach _ = BoolToList<!not(ps.Pfl.HasOpSel)>.ret in

            
                  def _e64_gfx11 :

            
                    VOP3_Real<ps, SIEncodingFamily.GFX11>,

            
                    VOP3e_gfx11<op, ps.Pfl>;

            
                }

            
              }

            
              multiclass VOP3Dot_Real_Base_gfx11<bits<10> op, string opName = NAME,

            
                                                 bit isSingle = 0> {

            
                defvar ps = !cast<VOP_Pseudo>(opName#"_e64");

            
                let IsSingle = !or(isSingle, ps.Pfl.IsSingle) in {

            
                  def _e64_gfx11 :

            
                    VOP3_Real<ps, SIEncodingFamily.GFX11>,

            
                    VOP3DotOpSel_gfx11<op, ps.Pfl>;

            
                }

            
              }

            
              multiclass VOP3_Real_with_name_gfx11<bits<10> op, string opName,

            
                                                   string asmName, bit isSingle = 0> {

            
                defvar ps = !cast<VOP_Pseudo>(opName#"_e64");

            
                let AsmString = asmName # ps.AsmOperands,

            
                    IsSingle = !or(isSingle, ps.Pfl.IsSingle) in {

            
                foreach _ = BoolToList<ps.Pfl.HasOpSel>.ret in

            
                  def _e64_gfx11 :

            
                    VOP3_Real<ps, SIEncodingFamily.GFX11>,

            
                    VOP3OpSel_gfx11<op, ps.Pfl>;

            
                foreach _ = BoolToList<!not(ps.Pfl.HasOpSel)>.ret in

            
                  def _e64_gfx11 :

            
                    VOP3_Real<ps, SIEncodingFamily.GFX11>,

            
                    VOP3e_gfx11<op, ps.Pfl>;

            
                }

            
                def _gfx11_VOP3_alias : MnemonicAlias<ps.Mnemonic, asmName>, Requires<[isGFX11Plus]>, LetDummies;

            
              }

            
              // for READLANE/WRITELANE

            
              multiclass VOP3_Real_No_Suffix_gfx11<bits<10> op, string opName = NAME> {

            
                defvar ps = !cast<VOP_Pseudo>(opName);

            
                  def _e64_gfx11 :

            
                    VOP3_Real<ps, SIEncodingFamily.GFX11>,

            
                    VOP3e_gfx11<op, ps.Pfl>;

            
              }

            
              multiclass VOP3_Real_dpp_Base_gfx11<bits<10> op, string opName = NAME> {

            
                def _e64_dpp_gfx11 : VOP3_DPP16<op, !cast<VOP_DPP_Pseudo>(opName#"_e64"#"_dpp"), SIEncodingFamily.GFX11> {

            
                  let DecoderNamespace = "DPPGFX11";

            
                  }

            
              }


              multiclass VOP3Dot_Real_dpp_Base_gfx11<bits<10> op, string opName = NAME> {

            
                def _e64_dpp_gfx11 : VOP3_DPP16<op, !cast<VOP_DPP_Pseudo>(opName#"_e64"#"_dpp"), SIEncodingFamily.GFX11> {

            
                  let Inst{11} = ?;

            
                  let Inst{12} = ?;

            
                  let DecoderNamespace = "DPPGFX11";

            
                  }

            
              }


              multiclass VOP3_Real_dpp_with_name_gfx11<bits<10> op, string opName,

            
                                                       string asmName> {

            
                defvar ps = !cast<VOP3_Pseudo>(opName#"_e64");

            
                let AsmString = asmName # ps.Pfl.AsmVOP3DPP16, DecoderNamespace = "DPPGFX11" in {

            
                  defm NAME : VOP3_Real_dpp_Base_gfx11<op, opName>;

            
                }

            
              }

            
              multiclass VOP3_Real_dpp8_Base_gfx11<bits<10> op, string opName = NAME> {

            
                defvar ps = !cast<VOP3_Pseudo>(opName#"_e64");

            
                def _e64_dpp8_gfx11 : Base_VOP3_DPP8<op, ps> {

            
                  let DecoderNamespace = "DPP8GFX11";

            
                }

            
              }


              multiclass VOP3Dot_Real_dpp8_Base_gfx11<bits<10> op, string opName = NAME> {

            
                defvar ps = !cast<VOP3_Pseudo>(opName#"_e64");

            
                def _e64_dpp8_gfx11 : Base_VOP3_DPP8<op, ps> {

            
                  let Inst{11} = ?;

            
                  let Inst{12} = ?;

            
                  let DecoderNamespace = "DPP8GFX11";

            
                }

            
              }


              multiclass VOP3_Real_dpp8_with_name_gfx11<bits<10> op, string opName,

            
                                                       string asmName> {

            
                defvar ps = !cast<VOP3_Pseudo>(opName#"_e64");

            
                let AsmString = asmName # ps.Pfl.AsmVOP3DPP8, DecoderNamespace = "DPP8GFX11"  in {

            
                  defm NAME : VOP3_Real_dpp8_Base_gfx11<op, opName>;

            
                }

            
              }

            
              multiclass VOP3be_Real_gfx11<bits<10> op, string opName, string asmName,

            
                                           bit isSingle = 0> {

            
                defvar ps = !cast<VOP3_Pseudo>(opName#"_e64");

            
                let IsSingle = !or(isSingle, ps.Pfl.IsSingle) in

            
                  def _e64_gfx11 :

            
                    VOP3_Real<ps, SIEncodingFamily.GFX11, asmName>,

            
                    VOP3be_gfx11<op, ps.Pfl> ;

            
              }

            
              multiclass VOP3be_Real_dpp_gfx11<bits<10> op, string opName, string asmName> {

            
                defvar ps = !cast<VOP3_Pseudo>(opName #"_e64");

            
                defvar dpp_ps = !cast<VOP_DPP_Pseudo>(opName #"_e64" #"_dpp");

            
                def _e64_dpp_gfx11 : Base_VOP3b_DPP16<op, dpp_ps, asmName>,

            
                                     SIMCInstr<dpp_ps.PseudoInstr, SIEncodingFamily.GFX11> {

            
                  let DecoderNamespace = "DPPGFX11";

            
                }

            
              }

            
              multiclass VOP3be_Real_dpp8_gfx11<bits<10> op, string opName, string asmName> {

            
                defvar ps = !cast<VOP3_Pseudo>(opName #"_e64");

            
                def _e64_dpp8_gfx11 : VOP3b_DPP8_Base<op, ps, asmName> {

            
                  let DecoderNamespace = "DPP8GFX11";

            
                }

            
              }

            
            } // End AssemblerPredicate = isGFX11Only, DecoderNamespace = "GFX11"


            // VOP1 and VOP2 depend on these triple defs

            
            multiclass VOP3_Realtriple_gfx11<bits<10> op,

            
                                             bit isSingle = 0, string opName = NAME> :

            
              VOP3_Real_Base_gfx11<op, opName, isSingle>,

            
              VOP3_Real_dpp_Base_gfx11<op, opName>,

            
              VOP3_Real_dpp8_Base_gfx11<op, opName>;


            multiclass VOP3Dot_Realtriple_gfx11<bits<10> op,

            
                                             bit isSingle = 0, string opName = NAME> :

            
              VOP3Dot_Real_Base_gfx11<op, opName, isSingle>,

            
              VOP3Dot_Real_dpp_Base_gfx11<op, opName>,

            
              VOP3Dot_Real_dpp8_Base_gfx11<op, opName>;


            multiclass VOP3Only_Realtriple_gfx11<bits<10> op> :

            
              VOP3_Realtriple_gfx11<op, 1>;


            multiclass VOP3_Realtriple_with_name_gfx11<bits<10> op, string opName,

            
                                                       string asmName, bit isSingle = 0> :

            
              VOP3_Real_with_name_gfx11<op, opName, asmName, isSingle>,

            
              VOP3_Real_dpp_with_name_gfx11<op, opName, asmName>,

            
              VOP3_Real_dpp8_with_name_gfx11<op, opName, asmName>;


            multiclass VOP3Only_Realtriple_with_name_gfx11<bits<10> op, string opName,

            
                                                           string asmName> :

            
              VOP3_Realtriple_with_name_gfx11<op, opName, asmName, 1>;


            multiclass VOP3Only_Realtriple_t16_gfx11<bits<10> op, string asmName,

            
                                                 string opName = NAME>

            
                : VOP3Only_Realtriple_with_name_gfx11<op, opName, asmName>;


            multiclass VOP3be_Realtriple_gfx11<

            
                bits<10> op, bit isSingle = 0, string opName = NAME,

            
                string asmName = !cast<VOP_Pseudo>(opName#"_e64").Mnemonic> :

            
              VOP3be_Real_gfx11<op, opName, asmName, isSingle>,

            
              VOP3be_Real_dpp_gfx11<op, opName, asmName>,

            
              VOP3be_Real_dpp8_gfx11<op, opName, asmName>;


            multiclass VOP3beOnly_Realtriple_gfx11<bits<10> op> :

            
              VOP3be_Realtriple_gfx11<op, 1>;


            include "VOPCInstructions.td"

            
            include "VOP1Instructions.td"

            
            include "VOP2Instructions.td"

            
            include "VOP3Instructions.td"

            
            include "VOP3PInstructions.td"

            
            include "VOPDInstructions.td"


            class ClassPat<Instruction inst, ValueType vt> : GCNPat <

            
              (is_fpclass (vt (VOP3Mods vt:$src0, i32:$src0_mods)), (i32 timm:$mask)),

            
              (inst i32:$src0_mods, vt:$src0, (V_MOV_B32_e32 timm:$mask))

            
            >;


            def : ClassPat<V_CMP_CLASS_F16_e64, f16> {

            
              let OtherPredicates = [NotHasTrue16BitInsts, Has16BitInsts];

            
            }


            def : ClassPat<V_CMP_CLASS_F16_t16_e64, f16> {

            
              let OtherPredicates = [HasTrue16BitInsts];

            
            }


            def : ClassPat<V_CMP_CLASS_F32_e64, f32>;

            
            def : ClassPat<V_CMP_CLASS_F64_e64, f64>;


            class VOPInfoTable <string Format> : GenericTable {

            
              let FilterClass = Format # "_Real";

            
              let CppTypeName = "VOPInfo";

            
              let Fields = ["Opcode", "IsSingle"];


              let PrimaryKey = ["Opcode"];

            
              let PrimaryKeyName = "get" # Format # "OpcodeHelper";

            
            }


            def VOP1InfoTable : VOPInfoTable<"VOP1">;

            
            def VOP2InfoTable : VOPInfoTable<"VOP2">;

            
            def VOP3InfoTable : VOPInfoTable<"VOP3">;


            class VOPC64Table <string Format> : GenericTable {

            
              let FilterClass = "VOPC64_" # Format # "_Base";

            
              let CppTypeName = "VOPC64DPPInfo";

            
              let Fields = ["Opcode"];


              let PrimaryKey = ["Opcode"];

            
              let PrimaryKeyName = "isVOPC64" # Format # "OpcodeHelper";

            
            }


            def VOPC64DPPTable : VOPC64Table<"DPP">;

            
            def VOPC64DPP8Table : VOPC64Table<"DPP8">;


            def VOPTrue16Table : GenericTable {

            
              let FilterClass = "VOP_Pseudo";

            
              let CppTypeName = "VOPTrue16Info";

            
              let Fields = ["Opcode", "IsTrue16"];


              let PrimaryKey = ["Opcode"];

            
              let PrimaryKeyName = "getTrue16OpcodeHelper";

            
            }