Ignore:
Timestamp:
Jul 13, 2015, 2:11:13 PM (4 years ago)
Author:
cameron
Message:

Upgrade LLVM to 3.6.1

Location:
icGREP/icgrep-devel/llvm-3.6.1.src
Files:
1 edited
1 moved

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/llvm-3.6.1.src/lib/Target/R600/SIInstrInfo.td

    r4574 r4664  
    384384}
    385385
    386 class SOP1_Real_si <sop1 op, string opName, dag outs, dag ins, string asm,
    387                     list<dag> pattern> :
    388   SOP1 <outs, ins, asm, pattern>,
     386class SOP1_Real_si <sop1 op, string opName, dag outs, dag ins, string asm> :
     387  SOP1 <outs, ins, asm, []>,
    389388  SOP1e <op.SI>,
    390389  SIMCInstr<opName, SISubtarget.SI>;
    391390
    392 class SOP1_Real_vi <sop1 op, string opName, dag outs, dag ins, string asm,
    393                     list<dag> pattern> :
    394   SOP1 <outs, ins, asm, pattern>,
     391class SOP1_Real_vi <sop1 op, string opName, dag outs, dag ins, string asm> :
     392  SOP1 <outs, ins, asm, []>,
    395393  SOP1e <op.VI>,
    396394  SIMCInstr<opName, SISubtarget.VI>;
     
    401399
    402400  def _si : SOP1_Real_si <op, opName, (outs SReg_32:$dst), (ins SSrc_32:$src0),
    403     opName#" $dst, $src0", pattern>;
     401    opName#" $dst, $src0">;
    404402
    405403  def _vi : SOP1_Real_vi <op, opName, (outs SReg_32:$dst), (ins SSrc_32:$src0),
    406     opName#" $dst, $src0", pattern>;
     404    opName#" $dst, $src0">;
    407405}
    408406
     
    412410
    413411  def _si : SOP1_Real_si <op, opName, (outs SReg_64:$dst), (ins SSrc_64:$src0),
    414     opName#" $dst, $src0", pattern>;
     412    opName#" $dst, $src0">;
    415413
    416414  def _vi : SOP1_Real_vi <op, opName, (outs SReg_64:$dst), (ins SSrc_64:$src0),
    417     opName#" $dst, $src0", pattern>;
     415    opName#" $dst, $src0">;
    418416}
    419417
     
    423421
    424422  def _si : SOP1_Real_si <op, opName, (outs SReg_64:$dst), (ins),
    425     opName#" $dst", pattern> {
     423    opName#" $dst"> {
    426424    let SSRC0 = 0;
    427425  }
    428426
    429427  def _vi : SOP1_Real_vi <op, opName, (outs SReg_64:$dst), (ins),
    430     opName#" $dst", pattern> {
     428    opName#" $dst"> {
    431429    let SSRC0 = 0;
    432430  }
     
    439437
    440438  def _si : SOP1_Real_si <op, opName, (outs SReg_32:$dst), (ins SSrc_64:$src0),
    441     opName#" $dst, $src0", pattern>;
     439    opName#" $dst, $src0">;
    442440
    443441  def _vi : SOP1_Real_vi <op, opName, (outs SReg_32:$dst), (ins SSrc_64:$src0),
    444     opName#" $dst, $src0", pattern>;
     442    opName#" $dst, $src0">;
    445443}
    446444
     
    452450}
    453451
    454 class SOP2_Real_si<sop2 op, string opName, dag outs, dag ins, string asm,
    455                    list<dag> pattern> :
    456   SOP2<outs, ins, asm, pattern>,
     452class SOP2_Real_si<sop2 op, string opName, dag outs, dag ins, string asm> :
     453  SOP2<outs, ins, asm, []>,
    457454  SOP2e<op.SI>,
    458455  SIMCInstr<opName, SISubtarget.SI>;
    459456
    460 class SOP2_Real_vi<sop2 op, string opName, dag outs, dag ins, string asm,
    461                    list<dag> pattern> :
    462   SOP2<outs, ins, asm, pattern>,
     457class SOP2_Real_vi<sop2 op, string opName, dag outs, dag ins, string asm> :
     458  SOP2<outs, ins, asm, []>,
    463459  SOP2e<op.VI>,
    464460  SIMCInstr<opName, SISubtarget.VI>;
     
    470466  def _si : SOP2_Real_si <op, opName, (outs SReg_32:$dst),
    471467    (ins SSrc_32:$src0, SSrc_32:$src1, SCCReg:$scc),
    472     opName#" $dst, $src0, $src1 [$scc]", pattern>;
     468    opName#" $dst, $src0, $src1 [$scc]">;
    473469
    474470  def _vi : SOP2_Real_vi <op, opName, (outs SReg_32:$dst),
    475471    (ins SSrc_32:$src0, SSrc_32:$src1, SCCReg:$scc),
    476     opName#" $dst, $src0, $src1 [$scc]", pattern>;
     472    opName#" $dst, $src0, $src1 [$scc]">;
    477473}
    478474
     
    482478
    483479  def _si : SOP2_Real_si <op, opName, (outs SReg_32:$dst),
    484     (ins SSrc_32:$src0, SSrc_32:$src1), opName#" $dst, $src0, $src1", pattern>;
     480    (ins SSrc_32:$src0, SSrc_32:$src1), opName#" $dst, $src0, $src1">;
    485481
    486482  def _vi : SOP2_Real_vi <op, opName, (outs SReg_32:$dst),
    487     (ins SSrc_32:$src0, SSrc_32:$src1), opName#" $dst, $src0, $src1", pattern>;
     483    (ins SSrc_32:$src0, SSrc_32:$src1), opName#" $dst, $src0, $src1">;
    488484}
    489485
     
    493489
    494490  def _si : SOP2_Real_si <op, opName, (outs SReg_64:$dst),
    495     (ins SSrc_64:$src0, SSrc_64:$src1), opName#" $dst, $src0, $src1", pattern>;
     491    (ins SSrc_64:$src0, SSrc_64:$src1), opName#" $dst, $src0, $src1">;
    496492
    497493  def _vi : SOP2_Real_vi <op, opName, (outs SReg_64:$dst),
    498     (ins SSrc_64:$src0, SSrc_64:$src1), opName#" $dst, $src0, $src1", pattern>;
     494    (ins SSrc_64:$src0, SSrc_64:$src1), opName#" $dst, $src0, $src1">;
    499495}
    500496
     
    504500
    505501  def _si : SOP2_Real_si <op, opName, (outs SReg_64:$dst),
    506     (ins SSrc_64:$src0, SSrc_32:$src1), opName#" $dst, $src0, $src1", pattern>;
     502    (ins SSrc_64:$src0, SSrc_32:$src1), opName#" $dst, $src0, $src1">;
    507503
    508504  def _vi : SOP2_Real_vi <op, opName, (outs SReg_64:$dst),
    509     (ins SSrc_64:$src0, SSrc_32:$src1), opName#" $dst, $src0, $src1", pattern>;
     505    (ins SSrc_64:$src0, SSrc_32:$src1), opName#" $dst, $src0, $src1">;
    510506}
    511507
     
    528524}
    529525
    530 class SOPK_Real_si <sopk op, string opName, dag outs, dag ins, string asm,
    531                     list<dag> pattern> :
    532   SOPK <outs, ins, asm, pattern>,
     526class SOPK_Real_si <sopk op, string opName, dag outs, dag ins, string asm> :
     527  SOPK <outs, ins, asm, []>,
    533528  SOPKe <op.SI>,
    534529  SIMCInstr<opName, SISubtarget.SI>;
    535530
    536 class SOPK_Real_vi <sopk op, string opName, dag outs, dag ins, string asm,
    537                     list<dag> pattern> :
    538   SOPK <outs, ins, asm, pattern>,
     531class SOPK_Real_vi <sopk op, string opName, dag outs, dag ins, string asm> :
     532  SOPK <outs, ins, asm, []>,
    539533  SOPKe <op.VI>,
    540534  SIMCInstr<opName, SISubtarget.VI>;
     
    545539
    546540  def _si : SOPK_Real_si <op, opName, (outs SReg_32:$dst), (ins u16imm:$src0),
    547     opName#" $dst, $src0", pattern>;
     541    opName#" $dst, $src0">;
    548542
    549543  def _vi : SOPK_Real_vi <op, opName, (outs SReg_32:$dst), (ins u16imm:$src0),
    550     opName#" $dst, $src0", pattern>;
     544    opName#" $dst, $src0">;
    551545}
    552546
     
    556550
    557551  def _si : SOPK_Real_si <op, opName, (outs SCCReg:$dst),
    558     (ins SReg_32:$src0, u16imm:$src1), opName#" $dst, $src0", pattern>;
     552    (ins SReg_32:$src0, u16imm:$src1), opName#" $dst, $src0">;
    559553
    560554  def _vi : SOPK_Real_vi <op, opName, (outs SCCReg:$dst),
    561     (ins SReg_32:$src0, u16imm:$src1), opName#" $dst, $src0", pattern>;
     555    (ins SReg_32:$src0, u16imm:$src1), opName#" $dst, $src0">;
    562556}
    563557
     
    793787def VOP_F64_F64_I32 : VOPProfile <[f64, f64, i32, untyped]>;
    794788def VOP_I32_F32_F32 : VOPProfile <[i32, f32, f32, untyped]>;
     789def VOP_I32_F32_I32 : VOPProfile <[i32, f32, i32, untyped]>;
    795790def VOP_I32_I32_I32 : VOPProfile <[i32, i32, i32, untyped]>;
    796791def VOP_I32_I32_I32_VCC : VOPProfile <[i32, i32, i32, untyped]> {
     
    809804
    810805def VOP_I64_I64_I32 : VOPProfile <[i64, i64, i32, untyped]>;
     806def VOP_I64_I32_I64 : VOPProfile <[i64, i32, i64, untyped]>;
    811807def VOP_I64_I64_I64 : VOPProfile <[i64, i64, i64, untyped]>;
    812808
    813809def VOP_F32_F32_F32_F32 : VOPProfile <[f32, f32, f32, f32]>;
     810def VOP_MADK : VOPProfile <[f32, f32, f32, f32]> {
     811  field dag Ins = (ins VCSrc_32:$src0, VGPR_32:$vsrc1, u32imm:$src2);
     812  field string Asm = " $dst, $src0, $vsrc1, $src2";
     813}
    814814def VOP_F64_F64_F64_F64 : VOPProfile <[f64, f64, f64, f64]>;
    815815def VOP_I32_I32_I32_I32 : VOPProfile <[i32, i32, i32, i32]>;
     
    848848}
    849849
     850multiclass VOP1SI_m <vop1 op, dag outs, dag ins, string asm, list<dag> pattern,
     851                   string opName> {
     852  def "" : VOP1_Pseudo <outs, ins, pattern, opName>;
     853
     854  def _si : VOP1<op.SI, outs, ins, asm, []>,
     855            SIMCInstr <opName#"_e32", SISubtarget.SI>;
     856  // No VI instruction. This class is for SI only.
     857}
     858
    850859class VOP2_Pseudo <dag outs, dag ins, list<dag> pattern, string opName> :
    851860  VOP2Common <outs, ins, "", pattern>,
     
    856865
    857866multiclass VOP2SI_m <vop2 op, dag outs, dag ins, string asm, list<dag> pattern,
    858                      string opName, string revOpSI> {
     867                     string opName, string revOp> {
    859868  def "" : VOP2_Pseudo <outs, ins, pattern, opName>,
    860            VOP2_REV<revOpSI#"_e32", !eq(revOpSI, opName)>;
     869           VOP2_REV<revOp#"_e32", !eq(revOp, opName)>;
    861870
    862871  def _si : VOP2 <op.SI, outs, ins, opName#asm, []>,
    863             VOP2_REV<revOpSI#"_e32_si", !eq(revOpSI, opName)>,
    864872            SIMCInstr <opName#"_e32", SISubtarget.SI>;
    865873}
    866874
    867875multiclass VOP2_m <vop2 op, dag outs, dag ins, string asm, list<dag> pattern,
    868                    string opName, string revOpSI, string revOpVI> {
     876                   string opName, string revOp> {
    869877  def "" : VOP2_Pseudo <outs, ins, pattern, opName>,
    870            VOP2_REV<revOpSI#"_e32", !eq(revOpSI, opName)>;
     878           VOP2_REV<revOp#"_e32", !eq(revOp, opName)>;
    871879
    872880  def _si : VOP2 <op.SI, outs, ins, opName#asm, []>,
    873             VOP2_REV<revOpSI#"_e32_si", !eq(revOpSI, opName)>,
    874881            SIMCInstr <opName#"_e32", SISubtarget.SI>;
    875882  def _vi : VOP2 <op.VI, outs, ins, opName#asm, []>,
    876             VOP2_REV<revOpVI#"_e32_vi", !eq(revOpVI, opName)>,
    877883            SIMCInstr <opName#"_e32", SISubtarget.VI>;
    878884}
     
    904910  VOP3Common <outs, ins, asm, []>,
    905911  VOP3e_vi <op>,
     912  SIMCInstr <opName#"_e64", SISubtarget.VI>;
     913
     914class VOP3b_Real_si <bits<9> op, dag outs, dag ins, string asm, string opName> :
     915  VOP3Common <outs, ins, asm, []>,
     916  VOP3be <op>,
     917  SIMCInstr<opName#"_e64", SISubtarget.SI>;
     918
     919class VOP3b_Real_vi <bits<10> op, dag outs, dag ins, string asm, string opName> :
     920  VOP3Common <outs, ins, asm, []>,
     921  VOP3be_vi <op>,
    906922  SIMCInstr <opName#"_e64", SISubtarget.VI>;
    907923
     
    947963}
    948964
     965multiclass VOP3SI_1_m <vop op, dag outs, dag ins, string asm,
     966                     list<dag> pattern, string opName, bit HasMods = 1> {
     967
     968  def "" : VOP3_Pseudo <outs, ins, pattern, opName>;
     969
     970  def _si : VOP3_Real_si <op.SI3, outs, ins, asm, opName>,
     971            VOP3DisableFields<0, 0, HasMods>;
     972  // No VI instruction. This class is for SI only.
     973}
     974
    949975multiclass VOP3_2_m <vop op, dag outs, dag ins, string asm,
    950                      list<dag> pattern, string opName, string revOpSI, string revOpVI,
     976                     list<dag> pattern, string opName, string revOp,
    951977                     bit HasMods = 1, bit UseFullOp = 0> {
    952978
    953979  def "" : VOP3_Pseudo <outs, ins, pattern, opName>,
    954            VOP2_REV<revOpSI#"_e64", !eq(revOpSI, opName)>;
    955 
    956   def _si : VOP3_Real_si <op.SI3,
    957               outs, ins, asm, opName>,
    958             VOP2_REV<revOpSI#"_e64_si", !eq(revOpSI, opName)>,
     980           VOP2_REV<revOp#"_e64", !eq(revOp, opName)>;
     981
     982  def _si : VOP3_Real_si <op.SI3, outs, ins, asm, opName>,
    959983            VOP3DisableFields<1, 0, HasMods>;
    960984
    961   def _vi : VOP3_Real_vi <op.VI3,
    962               outs, ins, asm, opName>,
    963             VOP2_REV<revOpVI#"_e64_vi", !eq(revOpVI, opName)>,
     985  def _vi : VOP3_Real_vi <op.VI3, outs, ins, asm, opName>,
    964986            VOP3DisableFields<1, 0, HasMods>;
    965987}
    966988
     989multiclass VOP3SI_2_m <vop op, dag outs, dag ins, string asm,
     990                     list<dag> pattern, string opName, string revOp,
     991                     bit HasMods = 1, bit UseFullOp = 0> {
     992
     993  def "" : VOP3_Pseudo <outs, ins, pattern, opName>,
     994           VOP2_REV<revOp#"_e64", !eq(revOp, opName)>;
     995
     996  def _si : VOP3_Real_si <op.SI3, outs, ins, asm, opName>,
     997            VOP3DisableFields<1, 0, HasMods>;
     998
     999  // No VI instruction. This class is for SI only.
     1000}
     1001
     1002// XXX - Is v_div_scale_{f32|f64} only available in vop3b without
     1003// option of implicit vcc use?
    9671004multiclass VOP3b_2_m <vop op, dag outs, dag ins, string asm,
    9681005                      list<dag> pattern, string opName, string revOp,
     
    9751012  // so for now hardcode it to VCC as well.
    9761013  let sdst = SIOperand.VCC, Defs = [VCC] in {
    977     def _si : VOP3b <op.SI3, outs, ins, asm, pattern>,
    978               VOP3DisableFields<1, 0, HasMods>,
    979               SIMCInstr<opName#"_e64", SISubtarget.SI>,
    980               VOP2_REV<revOp#"_e64_si", !eq(revOp, opName)>;
    981 
    982     // TODO: Do we need this VI variant here?
    983     /*def _vi : VOP3b_vi <op.VI3, outs, ins, asm, pattern>,
    984               VOP3DisableFields<1, 0, HasMods>,
    985               SIMCInstr<opName#"_e64", SISubtarget.VI>,
    986               VOP2_REV<revOp#"_e64_vi", !eq(revOp, opName)>;*/
     1014    def _si : VOP3b_Real_si <op.SI3, outs, ins, asm, opName>,
     1015              VOP3DisableFields<1, 0, HasMods>;
     1016
     1017    def _vi : VOP3b_Real_vi <op.VI3, outs, ins, asm, opName>,
     1018              VOP3DisableFields<1, 0, HasMods>;
    9871019  } // End sdst = SIOperand.VCC, Defs = [VCC]
     1020}
     1021
     1022multiclass VOP3b_3_m <vop op, dag outs, dag ins, string asm,
     1023                      list<dag> pattern, string opName, string revOp,
     1024                      bit HasMods = 1, bit UseFullOp = 0> {
     1025  def "" : VOP3_Pseudo <outs, ins, pattern, opName>;
     1026
     1027
     1028  def _si : VOP3b_Real_si <op.SI3, outs, ins, asm, opName>,
     1029            VOP3DisableFields<1, 1, HasMods>;
     1030
     1031  def _vi : VOP3b_Real_vi <op.VI3, outs, ins, asm, opName>,
     1032            VOP3DisableFields<1, 1, HasMods>;
    9881033}
    9891034
     
    10471092                       SDPatternOperator node = null_frag> {
    10481093
    1049   def _e32 : VOP1 <op.SI, P.Outs, P.Ins32, opName#P.Asm32, []>,
    1050              VOP <opName>;
    1051 
    1052   def _e64 : VOP3Common <P.Outs, P.Ins64, opName#P.Asm64,
     1094  defm _e32 : VOP1SI_m <op, P.Outs, P.Ins32, opName#P.Asm32, [], opName>;
     1095
     1096  defm _e64 : VOP3SI_1_m <op, P.Outs, P.Ins64, opName#P.Asm64,
    10531097    !if(P.HasModifiers,
    10541098      [(set P.DstVT:$dst, (node (P.Src0VT (VOP3Mods0 P.Src0VT:$src0,
    10551099                                i32:$src0_modifiers, i1:$clamp, i32:$omod))))],
    1056       [(set P.DstVT:$dst, (node P.Src0VT:$src0))])>,
    1057             VOP <opName>,
    1058             VOP3e <op.SI3>,
    1059             VOP3DisableFields<0, 0, P.HasModifiers>;
     1100      [(set P.DstVT:$dst, (node P.Src0VT:$src0))]),
     1101    opName, P.HasModifiers>;
    10601102}
    10611103
     
    10631105                        dag ins32, string asm32, list<dag> pat32,
    10641106                        dag ins64, string asm64, list<dag> pat64,
    1065                         string revOpSI, string revOpVI, bit HasMods> {
    1066   defm _e32 : VOP2_m <op, outs, ins32, asm32, pat32, opName, revOpSI, revOpVI>;
     1107                        string revOp, bit HasMods> {
     1108  defm _e32 : VOP2_m <op, outs, ins32, asm32, pat32, opName, revOp>;
    10671109
    10681110  defm _e64 : VOP3_2_m <op,
    1069     outs, ins64, opName#"_e64"#asm64, pat64, opName, revOpSI, revOpVI, HasMods
     1111    outs, ins64, opName#"_e64"#asm64, pat64, opName, revOp, HasMods
    10701112  >;
    10711113}
     
    10731115multiclass VOP2Inst <vop2 op, string opName, VOPProfile P,
    10741116                     SDPatternOperator node = null_frag,
    1075                      string revOpSI = opName, string revOpVI = revOpSI> : VOP2_Helper <
     1117                     string revOp = opName> : VOP2_Helper <
    10761118  op, opName, P.Outs,
    10771119  P.Ins32, P.Asm32, [],
     
    10831125                 (P.Src1VT (VOP3Mods P.Src1VT:$src1, i32:$src1_modifiers))))],
    10841126      [(set P.DstVT:$dst, (node P.Src0VT:$src0, P.Src1VT:$src1))]),
    1085   revOpSI, revOpVI, P.HasModifiers
    1086 >;
     1127  revOp, P.HasModifiers
     1128>;
     1129
     1130multiclass VOP2InstSI <vop2 op, string opName, VOPProfile P,
     1131                       SDPatternOperator node = null_frag,
     1132                       string revOp = opName> {
     1133  defm _e32 : VOP2SI_m <op, P.Outs, P.Ins32, P.Asm32, [], opName, revOp>;
     1134
     1135  defm _e64 : VOP3SI_2_m <op, P.Outs, P.Ins64, opName#"_e64"#P.Asm64,
     1136    !if(P.HasModifiers,
     1137        [(set P.DstVT:$dst,
     1138             (node (P.Src0VT (VOP3Mods0 P.Src0VT:$src0, i32:$src0_modifiers,
     1139                                        i1:$clamp, i32:$omod)),
     1140                   (P.Src1VT (VOP3Mods P.Src1VT:$src1, i32:$src1_modifiers))))],
     1141        [(set P.DstVT:$dst, (node P.Src0VT:$src0, P.Src1VT:$src1))]),
     1142    opName, revOp, P.HasModifiers>;
     1143}
    10871144
    10881145multiclass VOP2b_Helper <vop2 op, string opName, dag outs,
     
    10911148                         string revOp, bit HasMods> {
    10921149
    1093   defm _e32 : VOP2_m <op, outs, ins32, asm32, pat32, opName, revOp, revOp>;
     1150  defm _e32 : VOP2_m <op, outs, ins32, asm32, pat32, opName, revOp>;
    10941151
    10951152  defm _e64 : VOP3b_2_m <op,
     
    11171174                            dag ins32, string asm32, list<dag> pat32,
    11181175                            dag ins64, string asm64, list<dag> pat64,
    1119                             string revOpSI, string revOpVI, bit HasMods> {
    1120   defm _e32 : VOP2SI_m <op, outs, ins32, asm32, pat32, opName, revOpSI>;
     1176                            string revOp, bit HasMods> {
     1177  defm _e32 : VOP2SI_m <op, outs, ins32, asm32, pat32, opName, revOp>;
    11211178
    11221179  defm _e64 : VOP3_2_m <op, outs, ins64, opName#"_e64"#asm64, pat64, opName,
    1123                         revOpSI, revOpVI, HasMods>;
     1180                        revOp, HasMods>;
    11241181}
    11251182
    11261183multiclass VOP2_VI3_Inst <vop23 op, string opName, VOPProfile P,
    11271184                          SDPatternOperator node = null_frag,
    1128                           string revOpSI = opName, string revOpVI = revOpSI>
     1185                          string revOp = opName>
    11291186                          : VOP2_VI3_Helper <
    11301187  op, opName, P.Outs,
     
    11371194                 (P.Src1VT (VOP3Mods P.Src1VT:$src1, i32:$src1_modifiers))))],
    11381195      [(set P.DstVT:$dst, (node P.Src0VT:$src0, P.Src1VT:$src1))]),
    1139   revOpSI, revOpVI, P.HasModifiers
    1140 >;
     1196  revOp, P.HasModifiers
     1197>;
     1198
     1199multiclass VOP2MADK <vop2 op, string opName, list<dag> pattern = []> {
     1200
     1201  def "" : VOP2_Pseudo <VOP_MADK.Outs, VOP_MADK.Ins, pattern, opName>;
     1202
     1203let isCodeGenOnly = 0 in {
     1204  def _si : VOP2Common <VOP_MADK.Outs, VOP_MADK.Ins,
     1205                        !strconcat(opName, VOP_MADK.Asm), []>,
     1206            SIMCInstr <opName#"_e32", SISubtarget.SI>,
     1207            VOP2_MADKe <op.SI>;
     1208
     1209  def _vi : VOP2Common <VOP_MADK.Outs, VOP_MADK.Ins,
     1210                        !strconcat(opName, VOP_MADK.Asm), []>,
     1211            SIMCInstr <opName#"_e32", SISubtarget.VI>,
     1212            VOP2_MADKe <op.VI>;
     1213} // End isCodeGenOnly = 0
     1214}
    11411215
    11421216class VOPC_Pseudo <dag outs, dag ins, list<dag> pattern, string opName> :
     
    12751349>;
    12761350
     1351// Special case for v_div_fmas_{f32|f64}, since it seems to be the
     1352// only VOP instruction that implicitly reads VCC.
     1353multiclass VOP3_VCC_Inst <vop3 op, string opName,
     1354                          VOPProfile P,
     1355                          SDPatternOperator node = null_frag> : VOP3_Helper <
     1356  op, opName,
     1357  P.Outs,
     1358  (ins InputModsNoDefault:$src0_modifiers, P.Src0RC64:$src0,
     1359       InputModsNoDefault:$src1_modifiers, P.Src1RC64:$src1,
     1360       InputModsNoDefault:$src2_modifiers, P.Src2RC64:$src2,
     1361       ClampMod:$clamp,
     1362       omod:$omod),
     1363  " $dst, $src0_modifiers, $src1_modifiers, $src2_modifiers"#"$clamp"#"$omod",
     1364  [(set P.DstVT:$dst,
     1365            (node (P.Src0VT (VOP3Mods0 P.Src0VT:$src0, i32:$src0_modifiers,
     1366                                       i1:$clamp, i32:$omod)),
     1367                  (P.Src1VT (VOP3Mods P.Src1VT:$src1, i32:$src1_modifiers)),
     1368                  (P.Src2VT (VOP3Mods P.Src2VT:$src2, i32:$src2_modifiers)),
     1369                  (i1 VCC)))],
     1370  3, 1
     1371>;
     1372
    12771373multiclass VOP3b_Helper <vop op, RegisterClass vrc, RegisterOperand arc,
    12781374                    string opName, list<dag> pattern> :
    1279   VOP3b_2_m <
     1375  VOP3b_3_m <
    12801376  op, (outs vrc:$vdst, SReg_64:$sdst),
    12811377      (ins InputModsNoDefault:$src0_modifiers, arc:$src0,
     
    13081404//===----------------------------------------------------------------------===//
    13091405
    1310 class VINTRP_Pseudo <string opName, dag outs, dag ins, string asm,
    1311                      list<dag> pattern> :
    1312   VINTRPCommon <outs, ins, asm, pattern>,
     1406class VINTRP_Pseudo <string opName, dag outs, dag ins, list<dag> pattern> :
     1407  VINTRPCommon <outs, ins, "", pattern>,
    13131408  SIMCInstr<opName, SISubtarget.NONE> {
    13141409  let isPseudo = 1;
     
    13161411
    13171412class VINTRP_Real_si <bits <2> op, string opName, dag outs, dag ins,
    1318                       string asm, list<dag> pattern> :
    1319   VINTRPCommon <outs, ins, asm, pattern>,
     1413                      string asm> :
     1414  VINTRPCommon <outs, ins, asm, []>,
    13201415  VINTRPe <op>,
    13211416  SIMCInstr<opName, SISubtarget.SI>;
    13221417
    13231418class VINTRP_Real_vi <bits <2> op, string opName, dag outs, dag ins,
    1324                       string asm, list<dag> pattern> :
    1325   VINTRPCommon <outs, ins, asm, pattern>,
     1419                      string asm> :
     1420  VINTRPCommon <outs, ins, asm, []>,
    13261421  VINTRPe_vi <op>,
    13271422  SIMCInstr<opName, SISubtarget.VI>;
     
    13321427  let DisableEncoding = disableEncoding,
    13331428      Constraints = constraints in {
    1334     def "" : VINTRP_Pseudo <opName, outs, ins, asm, pattern>;
    1335 
    1336     def _si : VINTRP_Real_si <op, opName, outs, ins, asm, pattern>;
    1337 
    1338     def _vi : VINTRP_Real_vi <op, opName, outs, ins, asm, pattern>;
     1429    def "" : VINTRP_Pseudo <opName, outs, ins, pattern>;
     1430
     1431    def _si : VINTRP_Real_si <op, opName, outs, ins, asm>;
     1432
     1433    def _vi : VINTRP_Real_vi <op, opName, outs, ins, asm>;
    13391434  }
    13401435}
     
    14681563  []>;
    14691564
    1470 class DS_1A_si <bits<8> op, dag outs, dag ins, string asm, list<dag> pat> :
    1471     DS_si <op, outs, ins, asm, pat> {
    1472   bits<16> offset;
    1473 
    1474   // Single load interpret the 2 i8imm operands as a single i16 offset.
    1475   let offset0 = offset{7-0};
    1476   let offset1 = offset{15-8};
    1477 
    1478   let hasSideEffects = 0;
    1479 }
    1480 
    14811565// 1 address, 1 data.
    1482 class DS_1A1D_RET <bits<8> op, string asm, RegisterClass rc, string noRetOp = ""> : DS_1A_si <
    1483   op,
     1566multiclass DS_1A1D_RET_m <bits<8> op, string opName, dag outs, dag ins,
     1567                          string asm, list<dag> pat, string noRetOp> {
     1568  let mayLoad = 1, mayStore = 1,
     1569      hasPostISelHook = 1 // Adjusted to no return version.
     1570      in {
     1571    def "" : DS_Pseudo <opName, outs, ins, pat>,
     1572             AtomicNoRet<noRetOp, 1>;
     1573
     1574    let data1 = 0 in {
     1575      def _si : DS_1A_Real_si <op, opName, outs, ins, asm>;
     1576      def _vi : DS_1A_Real_vi <op, opName, outs, ins, asm>;
     1577    }
     1578  }
     1579}
     1580
     1581multiclass DS_1A1D_RET <bits<8> op, string asm, RegisterClass rc,
     1582                        string noRetOp = ""> : DS_1A1D_RET_m <
     1583  op, asm,
    14841584  (outs rc:$vdst),
    14851585  (ins i1imm:$gds, VGPR_32:$addr, rc:$data0, ds_offset:$offset, M0Reg:$m0),
    1486   asm#" $vdst, $addr, $data0"#"$offset"#" [M0]", []>,
    1487   AtomicNoRet<noRetOp, 1> {
    1488 
    1489   let data1 = 0;
    1490   let mayStore = 1;
    1491   let mayLoad = 1;
    1492 
    1493   let hasPostISelHook = 1; // Adjusted to no return version.
    1494 }
     1586  asm#" $vdst, $addr, $data0"#"$offset"#" [M0]", [], noRetOp>;
    14951587
    14961588// 1 address, 2 data.
    1497 class DS_1A2D_RET <bits<8> op, string asm, RegisterClass rc, string noRetOp = ""> : DS_1A_si <
    1498   op,
     1589multiclass DS_1A2D_RET_m <bits<8> op, string opName, dag outs, dag ins,
     1590                          string asm, list<dag> pat, string noRetOp> {
     1591  let mayLoad = 1, mayStore = 1,
     1592      hasPostISelHook = 1 // Adjusted to no return version.
     1593      in {
     1594    def "" : DS_Pseudo <opName, outs, ins, pat>,
     1595             AtomicNoRet<noRetOp, 1>;
     1596
     1597    def _si : DS_1A_Real_si <op, opName, outs, ins, asm>;
     1598    def _vi : DS_1A_Real_vi <op, opName, outs, ins, asm>;
     1599  }
     1600}
     1601
     1602multiclass DS_1A2D_RET <bits<8> op, string asm, RegisterClass rc,
     1603                   string noRetOp = ""> : DS_1A2D_RET_m <
     1604  op, asm,
    14991605  (outs rc:$vdst),
    15001606  (ins i1imm:$gds, VGPR_32:$addr, rc:$data0, rc:$data1, ds_offset:$offset, M0Reg:$m0),
    15011607  asm#" $vdst, $addr, $data0, $data1"#"$offset"#" [M0]",
    1502   []>,
    1503   AtomicNoRet<noRetOp, 1> {
    1504   let mayStore = 1;
    1505   let mayLoad = 1;
    1506   let hasPostISelHook = 1; // Adjusted to no return version.
    1507 }
     1608  [], noRetOp>;
    15081609
    15091610// 1 address, 2 data.
    1510 class DS_1A2D_NORET <bits<8> op, string asm, RegisterClass rc, string noRetOp = asm> : DS_1A_si <
    1511   op,
     1611multiclass DS_1A2D_NORET_m <bits<8> op, string opName, dag outs, dag ins,
     1612                            string asm, list<dag> pat, string noRetOp> {
     1613  let mayLoad = 1, mayStore = 1 in {
     1614    def "" : DS_Pseudo <opName, outs, ins, pat>,
     1615             AtomicNoRet<noRetOp, 0>;
     1616
     1617    def _si : DS_1A_Real_si <op, opName, outs, ins, asm>;
     1618    def _vi : DS_1A_Real_vi <op, opName, outs, ins, asm>;
     1619  }
     1620}
     1621
     1622multiclass DS_1A2D_NORET <bits<8> op, string asm, RegisterClass rc,
     1623                     string noRetOp = asm> : DS_1A2D_NORET_m <
     1624  op, asm,
    15121625  (outs),
    15131626  (ins i1imm:$gds, VGPR_32:$addr, rc:$data0, rc:$data1, ds_offset:$offset, M0Reg:$m0),
    15141627  asm#" $addr, $data0, $data1"#"$offset"#" [M0]",
    1515   []>,
    1516   AtomicNoRet<noRetOp, 0> {
    1517   let mayStore = 1;
    1518   let mayLoad = 1;
    1519 }
     1628  [], noRetOp>;
    15201629
    15211630// 1 address, 1 data.
    1522 class DS_1A1D_NORET <bits<8> op, string asm, RegisterClass rc, string noRetOp = asm> : DS_1A_si <
    1523   op,
     1631multiclass DS_1A1D_NORET_m <bits<8> op, string opName, dag outs, dag ins,
     1632                            string asm, list<dag> pat, string noRetOp> {
     1633  let mayLoad = 1, mayStore = 1 in {
     1634    def "" : DS_Pseudo <opName, outs, ins, pat>,
     1635             AtomicNoRet<noRetOp, 0>;
     1636
     1637    let data1 = 0 in {
     1638      def _si : DS_1A_Real_si <op, opName, outs, ins, asm>;
     1639      def _vi : DS_1A_Real_vi <op, opName, outs, ins, asm>;
     1640    }
     1641  }
     1642}
     1643
     1644multiclass DS_1A1D_NORET <bits<8> op, string asm, RegisterClass rc,
     1645                          string noRetOp = asm> : DS_1A1D_NORET_m <
     1646  op, asm,
    15241647  (outs),
    15251648  (ins i1imm:$gds, VGPR_32:$addr, rc:$data0, ds_offset:$offset, M0Reg:$m0),
    15261649  asm#" $addr, $data0"#"$offset"#" [M0]",
    1527   []>,
    1528   AtomicNoRet<noRetOp, 0> {
    1529 
    1530   let data1 = 0;
    1531   let mayStore = 1;
    1532   let mayLoad = 1;
    1533 }
     1650  [], noRetOp>;
    15341651
    15351652//===----------------------------------------------------------------------===//
     
    15971714//===----------------------------------------------------------------------===//
    15981715
     1716class mubuf <bits<7> si, bits<7> vi = si> {
     1717  field bits<7> SI = si;
     1718  field bits<7> VI = vi;
     1719}
     1720
     1721class MUBUFAddr64Table <bit is_addr64, string suffix = ""> {
     1722  bit IsAddr64 = is_addr64;
     1723  string OpName = NAME # suffix;
     1724}
     1725
     1726class MUBUF_Pseudo <string opName, dag outs, dag ins, list<dag> pattern> :
     1727  MUBUF <outs, ins, "", pattern>,
     1728  SIMCInstr<opName, SISubtarget.NONE> {
     1729  let isPseudo = 1;
     1730
     1731  // dummy fields, so that we can use let statements around multiclasses
     1732  bits<1> offen;
     1733  bits<1> idxen;
     1734  bits<8> vaddr;
     1735  bits<1> glc;
     1736  bits<1> slc;
     1737  bits<1> tfe;
     1738  bits<8> soffset;
     1739}
     1740
     1741class MUBUF_Real_si <mubuf op, string opName, dag outs, dag ins,
     1742                     string asm> :
     1743  MUBUF <outs, ins, asm, []>,
     1744  MUBUFe <op.SI>,
     1745  SIMCInstr<opName, SISubtarget.SI> {
     1746  let lds = 0;
     1747}
     1748
     1749class MUBUF_Real_vi <mubuf op, string opName, dag outs, dag ins,
     1750                     string asm> :
     1751  MUBUF <outs, ins, asm, []>,
     1752  MUBUFe_vi <op.VI>,
     1753  SIMCInstr<opName, SISubtarget.VI> {
     1754  let lds = 0;
     1755}
     1756
     1757multiclass MUBUF_m <mubuf op, string opName, dag outs, dag ins, string asm,
     1758                    list<dag> pattern> {
     1759
     1760  def "" : MUBUF_Pseudo <opName, outs, ins, pattern>,
     1761           MUBUFAddr64Table <0>;
     1762
     1763  let addr64 = 0 in {
     1764    def _si : MUBUF_Real_si <op, opName, outs, ins, asm>;
     1765  }
     1766
     1767  def _vi : MUBUF_Real_vi <op, opName, outs, ins, asm>;
     1768}
     1769
     1770multiclass MUBUFAddr64_m <mubuf op, string opName, dag outs,
     1771                          dag ins, string asm, list<dag> pattern> {
     1772
     1773  def "" : MUBUF_Pseudo <opName, outs, ins, pattern>,
     1774           MUBUFAddr64Table <1>;
     1775
     1776  let addr64 = 1 in {
     1777    def _si : MUBUF_Real_si <op, opName, outs, ins, asm>;
     1778  }
     1779
     1780  // There is no VI version. If the pseudo is selected, it should be lowered
     1781  // for VI appropriately.
     1782}
     1783
    15991784class MUBUF_si <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
    16001785  MUBUF <outs, ins, asm, pattern>, MUBUFe <op> {
    1601   let lds  = 0;
    1602 }
    1603 
    1604 class MUBUF_vi <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
    1605   MUBUF <outs, ins, asm, pattern>, MUBUFe_vi <op> {
    16061786  let lds = 0;
    16071787}
    16081788
    1609 class MUBUFAddr64Table <bit is_addr64, string suffix = ""> {
    1610 
    1611   bit IsAddr64 = is_addr64;
    1612   string OpName = NAME # suffix;
    1613 }
    1614 
    1615 class MUBUFAtomicAddr64 <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern>
    1616     : MUBUF_si <op, outs, ins, asm, pattern> {
    1617 
    1618   let offen = 0;
    1619   let idxen = 0;
    1620   let addr64 = 1;
    1621   let tfe = 0;
    1622   let lds = 0;
    1623   let soffset = 128;
    1624 }
    1625 
    1626 class MUBUFAtomicOffset <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern>
    1627     : MUBUF_si <op, outs, ins, asm, pattern> {
    1628 
    1629   let offen = 0;
    1630   let idxen = 0;
    1631   let addr64 = 0;
    1632   let tfe = 0;
    1633   let lds = 0;
    1634   let vaddr = 0;
    1635 }
    1636 
    1637 multiclass MUBUF_Atomic <bits<7> op, string name, RegisterClass rc,
     1789multiclass MUBUFAtomicOffset_m <mubuf op, string opName, dag outs, dag ins,
     1790                                string asm, list<dag> pattern, bit is_return> {
     1791
     1792  def "" : MUBUF_Pseudo <opName, outs, ins, pattern>,
     1793           MUBUFAddr64Table <0, !if(is_return, "_RTN", "")>,
     1794           AtomicNoRet<NAME#"_OFFSET", is_return>;
     1795
     1796  let offen = 0, idxen = 0, tfe = 0, vaddr = 0 in {
     1797    let addr64 = 0 in {
     1798      def _si : MUBUF_Real_si <op, opName, outs, ins, asm>;
     1799    }
     1800
     1801    def _vi : MUBUF_Real_vi <op, opName, outs, ins, asm>;
     1802  }
     1803}
     1804
     1805multiclass MUBUFAtomicAddr64_m <mubuf op, string opName, dag outs, dag ins,
     1806                                string asm, list<dag> pattern, bit is_return> {
     1807
     1808  def "" : MUBUF_Pseudo <opName, outs, ins, pattern>,
     1809           MUBUFAddr64Table <1, !if(is_return, "_RTN", "")>,
     1810           AtomicNoRet<NAME#"_ADDR64", is_return>;
     1811
     1812  let offen = 0, idxen = 0, addr64 = 1, tfe = 0, soffset = 128 in {
     1813    def _si : MUBUF_Real_si <op, opName, outs, ins, asm>;
     1814  }
     1815
     1816  // There is no VI version. If the pseudo is selected, it should be lowered
     1817  // for VI appropriately.
     1818}
     1819
     1820multiclass MUBUF_Atomic <mubuf op, string name, RegisterClass rc,
    16381821                         ValueType vt, SDPatternOperator atomic> {
    16391822
     
    16431826    let glc = 0 in {
    16441827
    1645       def _ADDR64 : MUBUFAtomicAddr64 <
    1646         op, (outs),
     1828      defm _ADDR64 : MUBUFAtomicAddr64_m <
     1829        op, name#"_addr64", (outs),
    16471830        (ins rc:$vdata, SReg_128:$srsrc, VReg_64:$vaddr,
    16481831             mbuf_offset:$offset, slc:$slc),
    1649         name#" $vdata, $vaddr, $srsrc, 0 addr64"#"$offset"#"$slc", []
    1650       >, MUBUFAddr64Table<1>, AtomicNoRet<NAME#"_ADDR64", 0>;
    1651 
    1652       def _OFFSET : MUBUFAtomicOffset <
    1653         op, (outs),
     1832        name#" $vdata, $vaddr, $srsrc, 0 addr64"#"$offset"#"$slc", [], 0
     1833      >;
     1834
     1835      defm _OFFSET : MUBUFAtomicOffset_m <
     1836        op, name#"_offset", (outs),
    16541837        (ins rc:$vdata, SReg_128:$srsrc, mbuf_offset:$offset,
    16551838             SCSrc_32:$soffset, slc:$slc),
    1656         name#" $vdata, $srsrc, $soffset"#"$offset"#"$slc", []
    1657       >, MUBUFAddr64Table<0>, AtomicNoRet<NAME#"_OFFSET", 0>;
     1839        name#" $vdata, $srsrc, $soffset"#"$offset"#"$slc", [], 0
     1840      >;
    16581841    } // glc = 0
    16591842
     
    16621845        DisableEncoding = "$vdata_in"  in {
    16631846
    1664       def _RTN_ADDR64 : MUBUFAtomicAddr64 <
    1665         op, (outs rc:$vdata),
     1847      defm _RTN_ADDR64 : MUBUFAtomicAddr64_m <
     1848        op, name#"_rtn_addr64", (outs rc:$vdata),
    16661849        (ins rc:$vdata_in, SReg_128:$srsrc, VReg_64:$vaddr,
    16671850             mbuf_offset:$offset, slc:$slc),
     
    16691852        [(set vt:$vdata,
    16701853         (atomic (MUBUFAddr64Atomic v4i32:$srsrc, i64:$vaddr, i16:$offset,
    1671                                     i1:$slc), vt:$vdata_in))]
    1672       >, MUBUFAddr64Table<1, "_RTN">, AtomicNoRet<NAME#"_ADDR64", 1>;
    1673 
    1674       def _RTN_OFFSET : MUBUFAtomicOffset <
    1675         op, (outs rc:$vdata),
     1854                                    i1:$slc), vt:$vdata_in))], 1
     1855      >;
     1856
     1857      defm _RTN_OFFSET : MUBUFAtomicOffset_m <
     1858        op, name#"_rtn_offset", (outs rc:$vdata),
    16761859        (ins rc:$vdata_in, SReg_128:$srsrc, mbuf_offset:$offset,
    16771860             SCSrc_32:$soffset, slc:$slc),
     
    16791862        [(set vt:$vdata,
    16801863         (atomic (MUBUFOffsetAtomic v4i32:$srsrc, i32:$soffset, i16:$offset,
    1681                                     i1:$slc), vt:$vdata_in))]
    1682       >, MUBUFAddr64Table<0, "_RTN">, AtomicNoRet<NAME#"_OFFSET", 1>;
     1864                                    i1:$slc), vt:$vdata_in))], 1
     1865      >;
    16831866
    16841867    } // glc = 1
     
    16871870}
    16881871
    1689 multiclass MUBUF_Load_Helper <bits<7> op, string asm, RegisterClass regClass,
     1872multiclass MUBUF_Load_Helper <mubuf op, string name, RegisterClass regClass,
    16901873                              ValueType load_vt = i32,
    16911874                              SDPatternOperator ld = null_frag> {
    16921875
    16931876  let mayLoad = 1, mayStore = 0 in {
    1694 
    1695     let addr64 = 0 in {
    1696 
    1697       let offen = 0, idxen = 0, vaddr = 0 in {
    1698         def _OFFSET : MUBUF_si <op, (outs regClass:$vdata),
    1699                              (ins SReg_128:$srsrc,
    1700                              mbuf_offset:$offset, SCSrc_32:$soffset, glc:$glc,
    1701                              slc:$slc, tfe:$tfe),
    1702                              asm#" $vdata, $srsrc, $soffset"#"$offset"#"$glc"#"$slc"#"$tfe",
    1703                              [(set load_vt:$vdata, (ld (MUBUFOffset v4i32:$srsrc,
    1704                                                        i32:$soffset, i16:$offset,
    1705                                                        i1:$glc, i1:$slc, i1:$tfe)))]>,
    1706                      MUBUFAddr64Table<0>;
    1707       }
    1708 
    1709       let offen = 1, idxen = 0  in {
    1710         def _OFFEN  : MUBUF_si <op, (outs regClass:$vdata),
    1711                              (ins SReg_128:$srsrc, VGPR_32:$vaddr,
    1712                              SCSrc_32:$soffset, mbuf_offset:$offset, glc:$glc, slc:$slc,
    1713                              tfe:$tfe),
    1714                              asm#" $vdata, $vaddr, $srsrc, $soffset offen"#"$offset"#"$glc"#"$slc"#"$tfe", []>;
    1715       }
    1716 
    1717       let offen = 0, idxen = 1 in {
    1718         def _IDXEN  : MUBUF_si <op, (outs regClass:$vdata),
    1719                              (ins SReg_128:$srsrc, VGPR_32:$vaddr,
    1720                              mbuf_offset:$offset, SCSrc_32:$soffset, glc:$glc,
    1721                              slc:$slc, tfe:$tfe),
    1722                              asm#" $vdata, $vaddr, $srsrc, $soffset idxen"#"$offset"#"$glc"#"$slc"#"$tfe", []>;
    1723       }
    1724 
    1725       let offen = 1, idxen = 1 in {
    1726         def _BOTHEN : MUBUF_si <op, (outs regClass:$vdata),
    1727                              (ins SReg_128:$srsrc, VReg_64:$vaddr,
    1728                              SCSrc_32:$soffset, glc:$glc, slc:$slc, tfe:$tfe),
    1729                              asm#" $vdata, $vaddr, $srsrc, $soffset, idxen offen"#"$glc"#"$slc"#"$tfe", []>;
    1730       }
    1731     }
    1732 
    1733     let offen = 0, idxen = 0, addr64 = 1, glc = 0, slc = 0, tfe = 0, soffset = 128 /* ZERO */ in {
    1734       def _ADDR64 : MUBUF_si <op, (outs regClass:$vdata),
    1735                            (ins SReg_128:$srsrc, VReg_64:$vaddr, mbuf_offset:$offset),
    1736                            asm#" $vdata, $vaddr, $srsrc, 0 addr64"#"$offset",
    1737                            [(set load_vt:$vdata, (ld (MUBUFAddr64 v4i32:$srsrc,
    1738                                                   i64:$vaddr, i16:$offset)))]>, MUBUFAddr64Table<1>;
    1739     }
    1740   }
    1741 }
    1742 
    1743 multiclass MUBUF_Load_Helper_vi <bits<7> op, string asm, RegisterClass regClass,
    1744                               ValueType load_vt = i32,
    1745                               SDPatternOperator ld = null_frag> {
    1746 
    1747   let lds = 0, mayLoad = 1 in {
    17481877    let offen = 0, idxen = 0, vaddr = 0 in {
    1749       def _OFFSET : MUBUF_vi <op, (outs regClass:$vdata),
     1878      defm _OFFSET : MUBUF_m <op, name#"_offset", (outs regClass:$vdata),
    17501879                           (ins SReg_128:$srsrc,
    17511880                           mbuf_offset:$offset, SCSrc_32:$soffset, glc:$glc,
    17521881                           slc:$slc, tfe:$tfe),
    1753                            asm#" $vdata, $srsrc, $soffset"#"$offset"#"$glc"#"$slc"#"$tfe",
     1882                           name#" $vdata, $srsrc, $soffset"#"$offset"#"$glc"#"$slc"#"$tfe",
    17541883                           [(set load_vt:$vdata, (ld (MUBUFOffset v4i32:$srsrc,
    17551884                                                     i32:$soffset, i16:$offset,
    1756                                                      i1:$glc, i1:$slc, i1:$tfe)))]>,
    1757                            MUBUFAddr64Table<0>;
     1885                                                     i1:$glc, i1:$slc, i1:$tfe)))]>;
    17581886    }
    17591887
    17601888    let offen = 1, idxen = 0  in {
    1761       def _OFFEN  : MUBUF_vi <op, (outs regClass:$vdata),
     1889      defm _OFFEN  : MUBUF_m <op, name#"_offen", (outs regClass:$vdata),
    17621890                           (ins SReg_128:$srsrc, VGPR_32:$vaddr,
    17631891                           SCSrc_32:$soffset, mbuf_offset:$offset, glc:$glc, slc:$slc,
    17641892                           tfe:$tfe),
    1765                            asm#" $vdata, $vaddr, $srsrc, $soffset offen"#"$offset"#"$glc"#"$slc"#"$tfe", []>;
     1893                           name#" $vdata, $vaddr, $srsrc, $soffset offen"#"$offset"#"$glc"#"$slc"#"$tfe", []>;
    17661894    }
    17671895
    17681896    let offen = 0, idxen = 1 in {
    1769       def _IDXEN  : MUBUF_vi <op, (outs regClass:$vdata),
     1897      defm _IDXEN  : MUBUF_m <op, name#"_idxen", (outs regClass:$vdata),
    17701898                           (ins SReg_128:$srsrc, VGPR_32:$vaddr,
    17711899                           mbuf_offset:$offset, SCSrc_32:$soffset, glc:$glc,
    17721900                           slc:$slc, tfe:$tfe),
    1773                            asm#" $vdata, $vaddr, $srsrc, $soffset idxen"#"$offset"#"$glc"#"$slc"#"$tfe", []>;
     1901                           name#" $vdata, $vaddr, $srsrc, $soffset idxen"#"$offset"#"$glc"#"$slc"#"$tfe", []>;
    17741902    }
    17751903
    17761904    let offen = 1, idxen = 1 in {
    1777       def _BOTHEN : MUBUF_vi <op, (outs regClass:$vdata),
     1905      defm _BOTHEN : MUBUF_m <op, name#"_bothen", (outs regClass:$vdata),
    17781906                           (ins SReg_128:$srsrc, VReg_64:$vaddr,
    17791907                           SCSrc_32:$soffset, glc:$glc, slc:$slc, tfe:$tfe),
    1780                            asm#" $vdata, $vaddr, $srsrc, $soffset, idxen offen"#"$glc"#"$slc"#"$tfe", []>;
     1908                           name#" $vdata, $vaddr, $srsrc, $soffset, idxen offen"#"$glc"#"$slc"#"$tfe", []>;
    17811909    }
    1782   }
    1783 }
    1784 
    1785 multiclass MUBUF_Store_Helper <bits<7> op, string name, RegisterClass vdataClass,
     1910
     1911    let offen = 0, idxen = 0, glc = 0, slc = 0, tfe = 0, soffset = 128 /* ZERO */ in {
     1912      defm _ADDR64 : MUBUFAddr64_m <op, name#"_addr64", (outs regClass:$vdata),
     1913                           (ins SReg_128:$srsrc, VReg_64:$vaddr, mbuf_offset:$offset),
     1914                           name#" $vdata, $vaddr, $srsrc, 0 addr64"#"$offset",
     1915                           [(set load_vt:$vdata, (ld (MUBUFAddr64 v4i32:$srsrc,
     1916                                                  i64:$vaddr, i16:$offset)))]>;
     1917    }
     1918  }
     1919}
     1920
     1921multiclass MUBUF_Store_Helper <mubuf op, string name, RegisterClass vdataClass,
    17861922                          ValueType store_vt, SDPatternOperator st> {
    1787 
    17881923  let mayLoad = 0, mayStore = 1 in {
    1789   let addr64 = 0 in {
    1790 
    1791     def "" : MUBUF_si <
    1792       op, (outs),
    1793       (ins vdataClass:$vdata, SReg_128:$srsrc, VGPR_32:$vaddr, SCSrc_32:$soffset,
    1794            mbuf_offset:$offset, offen:$offen, idxen:$idxen, glc:$glc, slc:$slc,
    1795            tfe:$tfe),
    1796       name#" $vdata, $vaddr, $srsrc, $soffset"#"$offen"#"$idxen"#"$offset"#
    1797            "$glc"#"$slc"#"$tfe",
    1798       []
    1799     >;
     1924    defm : MUBUF_m <op, name, (outs),
     1925                    (ins vdataClass:$vdata, SReg_128:$srsrc, VGPR_32:$vaddr, SCSrc_32:$soffset,
     1926                    mbuf_offset:$offset, offen:$offen, idxen:$idxen, glc:$glc, slc:$slc,
     1927                    tfe:$tfe),
     1928                    name#" $vdata, $vaddr, $srsrc, $soffset"#"$offen"#"$idxen"#"$offset"#
     1929                    "$glc"#"$slc"#"$tfe", []>;
    18001930
    18011931    let offen = 0, idxen = 0, vaddr = 0 in {
    1802       def _OFFSET : MUBUF_si <
    1803         op, (outs),
    1804         (ins vdataClass:$vdata, SReg_128:$srsrc, mbuf_offset:$offset,
    1805               SCSrc_32:$soffset, glc:$glc, slc:$slc, tfe:$tfe),
    1806         name#" $vdata, $srsrc, $soffset"#"$offset"#"$glc"#"$slc"#"$tfe",
    1807         [(st store_vt:$vdata, (MUBUFOffset v4i32:$srsrc, i32:$soffset,
    1808                                            i16:$offset, i1:$glc, i1:$slc,
    1809                                            i1:$tfe))]
    1810       >, MUBUFAddr64Table<0>;
     1932      defm _OFFSET : MUBUF_m <op, name#"_offset",(outs),
     1933                              (ins vdataClass:$vdata, SReg_128:$srsrc, mbuf_offset:$offset,
     1934                              SCSrc_32:$soffset, glc:$glc, slc:$slc, tfe:$tfe),
     1935                              name#" $vdata, $srsrc, $soffset"#"$offset"#"$glc"#"$slc"#"$tfe",
     1936                              [(st store_vt:$vdata, (MUBUFOffset v4i32:$srsrc, i32:$soffset,
     1937                                   i16:$offset, i1:$glc, i1:$slc, i1:$tfe))]>;
    18111938    } // offen = 0, idxen = 0, vaddr = 0
    18121939
    18131940    let offen = 1, idxen = 0  in {
    1814       def _OFFEN  : MUBUF_si <
    1815         op, (outs),
    1816         (ins vdataClass:$vdata, SReg_128:$srsrc, VGPR_32:$vaddr, SCSrc_32:$soffset,
    1817              mbuf_offset:$offset, glc:$glc, slc:$slc, tfe:$tfe),
    1818         name#" $vdata, $vaddr, $srsrc, $soffset offen"#"$offset"#
    1819             "$glc"#"$slc"#"$tfe",
    1820         []
    1821       >;
     1941      defm _OFFEN : MUBUF_m <op, name#"_offen", (outs),
     1942                             (ins vdataClass:$vdata, SReg_128:$srsrc, VGPR_32:$vaddr, SCSrc_32:$soffset,
     1943                             mbuf_offset:$offset, glc:$glc, slc:$slc, tfe:$tfe),
     1944                             name#" $vdata, $vaddr, $srsrc, $soffset offen"#"$offset"#
     1945                             "$glc"#"$slc"#"$tfe", []>;
    18221946    } // end offen = 1, idxen = 0
    18231947
    1824   } // End addr64 = 0
    1825 
    1826   def _ADDR64 : MUBUF_si <
    1827     op, (outs),
    1828     (ins vdataClass:$vdata, SReg_128:$srsrc, VReg_64:$vaddr, mbuf_offset:$offset),
    1829     name#" $vdata, $vaddr, $srsrc, 0 addr64"#"$offset",
    1830     [(st store_vt:$vdata,
    1831      (MUBUFAddr64 v4i32:$srsrc, i64:$vaddr, i16:$offset))]>, MUBUFAddr64Table<1>
    1832      {
    1833 
    1834       let mayLoad = 0;
    1835       let mayStore = 1;
    1836 
    1837       // Encoding
    1838       let offen = 0;
    1839       let idxen = 0;
    1840       let glc = 0;
    1841       let addr64 = 1;
    1842       let slc = 0;
    1843       let tfe = 0;
    1844       let soffset = 128; // ZERO
    1845    }
    1846    } // End mayLoad = 0, mayStore = 1
     1948    let offen = 0, idxen = 0, glc = 0, slc = 0, tfe = 0,
     1949        soffset = 128 /* ZERO */ in {
     1950      defm _ADDR64 : MUBUFAddr64_m <op, name#"_addr64", (outs),
     1951                                    (ins vdataClass:$vdata, SReg_128:$srsrc, VReg_64:$vaddr, mbuf_offset:$offset),
     1952                                    name#" $vdata, $vaddr, $srsrc, 0 addr64"#"$offset",
     1953                                    [(st store_vt:$vdata,
     1954                                      (MUBUFAddr64 v4i32:$srsrc, i64:$vaddr, i16:$offset))]>;
     1955    }
     1956  } // End mayLoad = 0, mayStore = 1
    18471957}
    18481958
     
    19132023class MIMG_Sampler_Helper <bits<7> op, string asm,
    19142024                           RegisterClass dst_rc,
    1915                            RegisterClass src_rc> : MIMG <
     2025                           RegisterClass src_rc, int wqm> : MIMG <
    19162026  op,
    19172027  (outs dst_rc:$vdata),
     
    19252035  let mayStore = 0;
    19262036  let hasPostISelHook = 1;
     2037  let WQM = wqm;
    19272038}
    19282039
    19292040multiclass MIMG_Sampler_Src_Helper <bits<7> op, string asm,
    19302041                                    RegisterClass dst_rc,
    1931                                     int channels> {
    1932   def _V1 : MIMG_Sampler_Helper <op, asm, dst_rc, VGPR_32>,
     2042                                    int channels, int wqm> {
     2043  def _V1 : MIMG_Sampler_Helper <op, asm, dst_rc, VGPR_32, wqm>,
    19332044            MIMG_Mask<asm#"_V1", channels>;
    1934   def _V2 : MIMG_Sampler_Helper <op, asm, dst_rc, VReg_64>,
     2045  def _V2 : MIMG_Sampler_Helper <op, asm, dst_rc, VReg_64, wqm>,
    19352046            MIMG_Mask<asm#"_V2", channels>;
    1936   def _V4 : MIMG_Sampler_Helper <op, asm, dst_rc, VReg_128>,
     2047  def _V4 : MIMG_Sampler_Helper <op, asm, dst_rc, VReg_128, wqm>,
    19372048            MIMG_Mask<asm#"_V4", channels>;
    1938   def _V8 : MIMG_Sampler_Helper <op, asm, dst_rc, VReg_256>,
     2049  def _V8 : MIMG_Sampler_Helper <op, asm, dst_rc, VReg_256, wqm>,
    19392050            MIMG_Mask<asm#"_V8", channels>;
    1940   def _V16 : MIMG_Sampler_Helper <op, asm, dst_rc, VReg_512>,
     2051  def _V16 : MIMG_Sampler_Helper <op, asm, dst_rc, VReg_512, wqm>,
    19412052            MIMG_Mask<asm#"_V16", channels>;
    19422053}
    19432054
    19442055multiclass MIMG_Sampler <bits<7> op, string asm> {
    1945   defm _V1 : MIMG_Sampler_Src_Helper<op, asm, VGPR_32, 1>;
    1946   defm _V2 : MIMG_Sampler_Src_Helper<op, asm, VReg_64, 2>;
    1947   defm _V3 : MIMG_Sampler_Src_Helper<op, asm, VReg_96, 3>;
    1948   defm _V4 : MIMG_Sampler_Src_Helper<op, asm, VReg_128, 4>;
     2056  defm _V1 : MIMG_Sampler_Src_Helper<op, asm, VGPR_32, 1, 0>;
     2057  defm _V2 : MIMG_Sampler_Src_Helper<op, asm, VReg_64, 2, 0>;
     2058  defm _V3 : MIMG_Sampler_Src_Helper<op, asm, VReg_96, 3, 0>;
     2059  defm _V4 : MIMG_Sampler_Src_Helper<op, asm, VReg_128, 4, 0>;
     2060}
     2061
     2062multiclass MIMG_Sampler_WQM <bits<7> op, string asm> {
     2063  defm _V1 : MIMG_Sampler_Src_Helper<op, asm, VGPR_32, 1, 1>;
     2064  defm _V2 : MIMG_Sampler_Src_Helper<op, asm, VReg_64, 2, 1>;
     2065  defm _V3 : MIMG_Sampler_Src_Helper<op, asm, VReg_96, 3, 1>;
     2066  defm _V4 : MIMG_Sampler_Src_Helper<op, asm, VReg_128, 4, 1>;
    19492067}
    19502068
    19512069class MIMG_Gather_Helper <bits<7> op, string asm,
    19522070                          RegisterClass dst_rc,
    1953                           RegisterClass src_rc> : MIMG <
     2071                          RegisterClass src_rc, int wqm> : MIMG <
    19542072  op,
    19552073  (outs dst_rc:$vdata),
     
    19722090  let MIMG = 0;
    19732091  let hasPostISelHook = 0;
     2092  let WQM = wqm;
    19742093}
    19752094
    19762095multiclass MIMG_Gather_Src_Helper <bits<7> op, string asm,
    19772096                                    RegisterClass dst_rc,
    1978                                     int channels> {
    1979   def _V1 : MIMG_Gather_Helper <op, asm, dst_rc, VGPR_32>,
     2097                                    int channels, int wqm> {
     2098  def _V1 : MIMG_Gather_Helper <op, asm, dst_rc, VGPR_32, wqm>,
    19802099            MIMG_Mask<asm#"_V1", channels>;
    1981   def _V2 : MIMG_Gather_Helper <op, asm, dst_rc, VReg_64>,
     2100  def _V2 : MIMG_Gather_Helper <op, asm, dst_rc, VReg_64, wqm>,
    19822101            MIMG_Mask<asm#"_V2", channels>;
    1983   def _V4 : MIMG_Gather_Helper <op, asm, dst_rc, VReg_128>,
     2102  def _V4 : MIMG_Gather_Helper <op, asm, dst_rc, VReg_128, wqm>,
    19842103            MIMG_Mask<asm#"_V4", channels>;
    1985   def _V8 : MIMG_Gather_Helper <op, asm, dst_rc, VReg_256>,
     2104  def _V8 : MIMG_Gather_Helper <op, asm, dst_rc, VReg_256, wqm>,
    19862105            MIMG_Mask<asm#"_V8", channels>;
    1987   def _V16 : MIMG_Gather_Helper <op, asm, dst_rc, VReg_512>,
     2106  def _V16 : MIMG_Gather_Helper <op, asm, dst_rc, VReg_512, wqm>,
    19882107            MIMG_Mask<asm#"_V16", channels>;
    19892108}
    19902109
    19912110multiclass MIMG_Gather <bits<7> op, string asm> {
    1992   defm _V1 : MIMG_Gather_Src_Helper<op, asm, VGPR_32, 1>;
    1993   defm _V2 : MIMG_Gather_Src_Helper<op, asm, VReg_64, 2>;
    1994   defm _V3 : MIMG_Gather_Src_Helper<op, asm, VReg_96, 3>;
    1995   defm _V4 : MIMG_Gather_Src_Helper<op, asm, VReg_128, 4>;
     2111  defm _V1 : MIMG_Gather_Src_Helper<op, asm, VGPR_32, 1, 0>;
     2112  defm _V2 : MIMG_Gather_Src_Helper<op, asm, VReg_64, 2, 0>;
     2113  defm _V3 : MIMG_Gather_Src_Helper<op, asm, VReg_96, 3, 0>;
     2114  defm _V4 : MIMG_Gather_Src_Helper<op, asm, VReg_128, 4, 0>;
     2115}
     2116
     2117multiclass MIMG_Gather_WQM <bits<7> op, string asm> {
     2118  defm _V1 : MIMG_Gather_Src_Helper<op, asm, VGPR_32, 1, 1>;
     2119  defm _V2 : MIMG_Gather_Src_Helper<op, asm, VReg_64, 2, 1>;
     2120  defm _V3 : MIMG_Gather_Src_Helper<op, asm, VReg_96, 3, 1>;
     2121  defm _V4 : MIMG_Gather_Src_Helper<op, asm, VReg_128, 4, 1>;
    19962122}
    19972123
Note: See TracChangeset for help on using the changeset viewer.