lib/Target/Alpha/AlphaInstrInfo.td

   1 //===- AlphaInstrInfo.td - The Alpha Instruction Set -------*- tablegen -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 include "AlphaInstrFormats.td"
  14
  15 //********************
  16 //Paterns for matching
  17 //********************
  18 def immUExt8  : PatLeaf<(imm), [{
  19   // immUExt8 predicate - True if the immediate fits in a 8-bit zero extended
  20   // field.  Used by instructions like 'addi'.
  21   return (unsigned long)N->getValue() == (unsigned char)N->getValue();
  22 }]>;
  23 def intop : PatFrag<(ops node:$op), (sext_inreg node:$op, i32)>;
  24
  25
  26   // //#define FP    $15
  27   // //#define RA    $26
  28   // //#define PV    $27
  29   // //#define GP    $29
  30   // //#define SP    $30
  31
  32 def PHI : PseudoInstAlpha<(ops variable_ops), "#phi">;
  33 def IDEF : PseudoInstAlpha<(ops GPRC:$RA), "#idef $RA">;
  34 def WTF : PseudoInstAlpha<(ops variable_ops), "#wtf">;
  35 def ADJUSTSTACKUP : PseudoInstAlpha<(ops variable_ops), "ADJUP">;
  36 def ADJUSTSTACKDOWN : PseudoInstAlpha<(ops variable_ops), "ADJDOWN">;
  37 def ALTENT : PseudoInstAlpha<(ops s64imm:$TARGET), "$TARGET:\n">;
  38 def PCLABEL : PseudoInstAlpha<(ops s64imm:$num), "PCMARKER_$num:\n">;
  39 def MEMLABEL : PseudoInstAlpha<(ops s64imm:$i, s64imm:$j, s64imm:$k, s64imm:$m),
  40          "LSMARKER$$$i$$$j$$$k$$$m:\n">;
  41
  42 //*****************
  43 //These are shortcuts, the assembler expands them
  44 //*****************
  45 //AT = R28
  46 //T0-T7 = R1 - R8
  47 //T8-T11 = R22-R25
  48
  49 //An even better improvement on the Int = SetCC(FP):  SelectCC!
  50 //These are evil because they hide control flow in a MBB
  51 //really the ISel should emit multiple MBB
  52 let isTwoAddress = 1 in {
  53 //Conditional move of an int based on a FP CC
  54   def CMOVEQ_FP : PseudoInstAlpha<(ops GPRC:$RDEST, GPRC:$RSRC_F, GPRC:$RSRC_T, FPRC:$RCOND),
  55                                   "fbne $RCOND, 42f\n\tbis $RSRC_T,$RSRC_T,$RDEST\n42:\n">;
  56   def CMOVEQi_FP : PseudoInstAlpha<(ops GPRC:$RDEST, GPRC:$RSRC_F, u8imm:$L, FPRC:$RCOND),
  57                                   "fbne $RCOND, 42f\n\taddq $$31,$L,$RDEST\n42:\n">;
  58
  59   def CMOVNE_FP : PseudoInstAlpha<(ops GPRC:$RDEST, GPRC:$RSRC_F, GPRC:$RSRC_T, FPRC:$RCOND),
  60                                   "fbeq $RCOND, 42f\n\tbis $RSRC_T,$RSRC_T,$RDEST\n42:\n">;
  61   def CMOVNEi_FP : PseudoInstAlpha<(ops GPRC:$RDEST, GPRC:$RSRC_F, u8imm:$L, FPRC:$RCOND),
  62                                   "fbeq $RCOND, 42f\n\taddq $$31,$L,$RDEST\n42:\n">;
  63 //Conditional move of an FP based on a Int CC
  64   def FCMOVEQ_INT : PseudoInstAlpha<(ops GPRC:$RDEST, GPRC:$RSRC_F, GPRC:$RSRC_T, FPRC:$RCOND),
  65                                   "bne $RCOND, 42f\n\tcpys $RSRC_T,$RSRC_T,$RDEST\n42:\n">;
  66   def FCMOVNE_INT : PseudoInstAlpha<(ops GPRC:$RDEST, GPRC:$RSRC_F, GPRC:$RSRC_T, FPRC:$RCOND),
  67                                   "beq $RCOND, 42f\n\tcpys $RSRC_T,$RSRC_T,$RDEST\n42:\n">;
  68 }
  69
  70 //***********************
  71 //Real instructions
  72 //***********************
  73
  74 //Operation Form:
  75
  76 //conditional moves, int
  77 def CMOVEQ   : OForm4<  0x11, 0x24, "cmoveq $RCOND,$RSRC,$RDEST">; //CMOVE if RCOND =  zero
  78 def CMOVEQi  : OForm4L< 0x11, 0x24, "cmoveq $RCOND,$L,$RDEST">; //CMOVE if RCOND =  zero
  79 def CMOVGE   : OForm4<  0x11, 0x46, "cmovge $RCOND,$RSRC,$RDEST">; //CMOVE if RCOND >= zero
  80 def CMOVGEi  : OForm4L< 0x11, 0x46, "cmovge $RCOND,$L,$RDEST">; //CMOVE if RCOND >= zero
  81 def CMOVGT   : OForm4<  0x11, 0x66, "cmovgt $RCOND,$RSRC,$RDEST">; //CMOVE if RCOND > zero
  82 def CMOVGTi  : OForm4L< 0x11, 0x66, "cmovgt $RCOND,$L,$RDEST">; //CMOVE if RCOND > zero
  83 def CMOVLBC  : OForm4<  0x11, 0x16, "cmovlbc $RCOND,$RSRC,$RDEST">; //CMOVE if RCOND low bit clear
  84 def CMOVLBCi : OForm4L< 0x11, 0x16, "cmovlbc $RCOND,$L,$RDEST">; //CMOVE if RCOND low bit clear
  85 def CMOVLBS  : OForm4<  0x11, 0x14, "cmovlbs $RCOND,$RSRC,$RDEST">; //CMOVE if RCOND low bit set
  86 def CMOVLBSi : OForm4L< 0x11, 0x14, "cmovlbs $RCOND,$L,$RDEST">; //CMOVE if RCOND low bit set
  87 def CMOVLE   : OForm4<  0x11, 0x64, "cmovle $RCOND,$RSRC,$RDEST">; //CMOVE if RCOND <= zero
  88 def CMOVLEi  : OForm4L< 0x11, 0x64, "cmovle $RCOND,$L,$RDEST">; //CMOVE if RCOND <= zero
  89 def CMOVLT   : OForm4<  0x11, 0x44, "cmovlt $RCOND,$RSRC,$RDEST">; //CMOVE if RCOND < zero
  90 def CMOVLTi  : OForm4L< 0x11, 0x44, "cmovlt $RCOND,$L,$RDEST">; //CMOVE if RCOND < zero
  91 def CMOVNE   : OForm4<  0x11, 0x26, "cmovne $RCOND,$RSRC,$RDEST">; //CMOVE if RCOND != zero
  92 def CMOVNEi  : OForm4L< 0x11, 0x26, "cmovne $RCOND,$L,$RDEST">; //CMOVE if RCOND != zero
  93
  94 let isTwoAddress = 1 in {
  95 //conditional moves, fp
  96  def FCMOVEQ : FPFormCM<0x17, 0x02A, (ops FPRC:$RDEST, FPRC:$RSRC2, FPRC:$RSRC, FPRC:$RCOND),
  97         "fcmoveq $RCOND,$RSRC,$RDEST">; //FCMOVE if = zero
  98  def FCMOVGE : FPFormCM<0x17, 0x02D, (ops FPRC:$RDEST, FPRC:$RSRC2, FPRC:$RSRC, FPRC:$RCOND),
  99         "fcmovge $RCOND,$RSRC,$RDEST">; //FCMOVE if >= zero
 100  def FCMOVGT : FPFormCM<0x17, 0x02F, (ops FPRC:$RDEST, FPRC:$RSRC2, FPRC:$RSRC, FPRC:$RCOND),
 101         "fcmovgt $RCOND,$RSRC,$RDEST">; //FCMOVE if > zero
 102  def FCMOVLE : FPFormCM<0x17, 0x02E, (ops FPRC:$RDEST, FPRC:$RSRC2, FPRC:$RSRC, FPRC:$RCOND),
 103         "fcmovle $RCOND,$RSRC,$RDEST">; //FCMOVE if <= zero
 104  def FCMOVLT : FPFormCM<0x17, 0x02, (ops FPRC:$RDEST, FPRC:$RSRC2, FPRC:$RSRC, FPRC:$RCOND),
 105         "fcmovlt $RCOND,$RSRC,$RDEST">; // FCMOVE if < zero
 106  def FCMOVNE : FPFormCM<0x17, 0x02B, (ops FPRC:$RDEST, FPRC:$RSRC2, FPRC:$RSRC, FPRC:$RCOND),
 107         "fcmovne $RCOND,$RSRC,$RDEST">; //FCMOVE if != zero
 108 }
 109
 110 def ADDL     : OForm< 0x10, 0x00, "addl $RA,$RB,$RC",
 111                       [(set GPRC:$RC, (intop (add GPRC:$RA, GPRC:$RB)))]>;
 112 def ADDLi    : OFormL<0x10, 0x00, "addl $RA,$L,$RC",
 113                       [(set GPRC:$RC, (intop (add GPRC:$RA, immUExt8:$L)))]>;
 114 def ADDQ     : OForm< 0x10, 0x20, "addq $RA,$RB,$RC",
 115                       [(set GPRC:$RC, (add GPRC:$RA, GPRC:$RB))]>;
 116 def ADDQi    : OFormL<0x10, 0x20, "addq $RA,$L,$RC",
 117                       [(set GPRC:$RC, (add GPRC:$RA, immUExt8:$L))]>;
 118 //def AMASK    : OForm< 0x11, 0x61, "AMASK $RA,$RB,$RC", []>; //Architecture mask
 119 //def AMASKi   : OFormL<0x11, 0x61, "AMASK $RA,$L,$RC", []>; //Architecture mask
 120 def AND      : OForm< 0x11, 0x00, "and $RA,$RB,$RC",
 121                       [(set GPRC:$RC, (and GPRC:$RA, GPRC:$RB))]>;
 122 def ANDi     : OFormL<0x11, 0x00, "and $RA,$L,$RC",
 123                       [(set GPRC:$RC, (and GPRC:$RA, immUExt8:$L))]>;
 124 def BIC      : OForm< 0x11, 0x08, "bic $RA,$RB,$RC",
 125                       [(set GPRC:$RC, (and GPRC:$RA, (not GPRC:$RB)))]>;
 126 def BICi     : OFormL<0x11, 0x08, "bic $RA,$L,$RC", []>;
 127 //                      [(set GPRC:$RC, (and GPRC:$RA, (not immUExt8:$L)))]>; //FIXME?
 128 def BIS      : OForm< 0x11, 0x20, "bis $RA,$RB,$RC",
 129                       [(set GPRC:$RC, (or GPRC:$RA, GPRC:$RB))]>;
 130 def BISi     : OFormL<0x11, 0x20, "bis $RA,$L,$RC",
 131                       [(set GPRC:$RC, (or GPRC:$RA, immUExt8:$L))]>;
 132 def CTLZ     : OForm2<0x1C, 0x32, "CTLZ $RB,$RC",
 133                       [(set GPRC:$RC, (ctlz GPRC:$RB))]>;
 134 def CTPOP    : OForm2<0x1C, 0x30, "CTPOP $RB,$RC",
 135                       [(set GPRC:$RC, (ctpop GPRC:$RB))]>;
 136 def CTTZ     : OForm2<0x1C, 0x33, "CTTZ $RB,$RC",
 137                       [(set GPRC:$RC, (cttz GPRC:$RB))]>;
 138 def EQV      : OForm< 0x11, 0x48, "eqv $RA,$RB,$RC",
 139                       [(set GPRC:$RC, (xor GPRC:$RA, (not GPRC:$RB)))]>;
 140 def EQVi     : OFormL<0x11, 0x48, "eqv $RA,$L,$RC", []>;
 141 //                      [(set GPRC:$RC, (xor GPRC:$RA, (not immUExt8:$L)))]>;
 142 //def EXTBL    : OForm< 0x12, 0x06, "EXTBL $RA,$RB,$RC", []>; //Extract byte low
 143 //def EXTBLi   : OFormL<0x12, 0x06, "EXTBL $RA,$L,$RC", []>; //Extract byte low
 144 //def EXTLH    : OForm< 0x12, 0x6A, "EXTLH $RA,$RB,$RC", []>; //Extract longword high
 145 //def EXTLHi   : OFormL<0x12, 0x6A, "EXTLH $RA,$L,$RC", []>; //Extract longword high
 146 //def EXTLL    : OForm< 0x12, 0x26, "EXTLL $RA,$RB,$RC", []>; //Extract longword low
 147 //def EXTLLi   : OFormL<0x12, 0x26, "EXTLL $RA,$L,$RC", []>; //Extract longword low
 148 //def EXTQH    : OForm< 0x12, 0x7A, "EXTQH $RA,$RB,$RC", []>; //Extract quadword high
 149 //def EXTQHi   : OFormL<0x12, 0x7A, "EXTQH $RA,$L,$RC", []>; //Extract quadword high
 150 //def EXTQ     : OForm< 0x12, 0x36, "EXTQ $RA,$RB,$RC", []>; //Extract quadword low
 151 //def EXTQi    : OFormL<0x12, 0x36, "EXTQ $RA,$L,$RC", []>; //Extract quadword low
 152 //def EXTWH    : OForm< 0x12, 0x5A, "EXTWH $RA,$RB,$RC", []>; //Extract word high
 153 //def EXTWHi   : OFormL<0x12, 0x5A, "EXTWH $RA,$L,$RC", []>; //Extract word high
 154 //def EXTWL    : OForm< 0x12, 0x16, "EXTWL $RA,$RB,$RC", []>; //Extract word low
 155 //def EXTWLi   : OFormL<0x12, 0x16, "EXTWL $RA,$L,$RC", []>; //Extract word low
 156 //def IMPLVER  : OForm< 0x11, 0x6C, "IMPLVER $RA,$RB,$RC", []>; //Implementation version
 157 //def IMPLVERi : OFormL<0x11, 0x6C, "IMPLVER $RA,$L,$RC", []>; //Implementation version
 158 //def INSBL    : OForm< 0x12, 0x0B, "INSBL $RA,$RB,$RC", []>; //Insert byte low
 159 //def INSBLi   : OFormL<0x12, 0x0B, "INSBL $RA,$L,$RC", []>; //Insert byte low
 160 //def INSLH    : OForm< 0x12, 0x67, "INSLH $RA,$RB,$RC", []>; //Insert longword high
 161 //def INSLHi   : OFormL<0x12, 0x67, "INSLH $RA,$L,$RC", []>; //Insert longword high
 162 //def INSLL    : OForm< 0x12, 0x2B, "INSLL $RA,$RB,$RC", []>; //Insert longword low
 163 //def INSLLi   : OFormL<0x12, 0x2B, "INSLL $RA,$L,$RC", []>; //Insert longword low
 164 //def INSQH    : OForm< 0x12, 0x77, "INSQH $RA,$RB,$RC", []>; //Insert quadword high
 165 //def INSQHi   : OFormL<0x12, 0x77, "INSQH $RA,$L,$RC", []>; //Insert quadword high
 166 //def INSQL    : OForm< 0x12, 0x3B, "INSQL $RA,$RB,$RC", []>; //Insert quadword low
 167 //def INSQLi   : OFormL<0x12, 0x3B, "INSQL $RA,$L,$RC", []>; //Insert quadword low
 168 //def INSWH    : OForm< 0x12, 0x57, "INSWH $RA,$RB,$RC", []>; //Insert word high
 169 //def INSWHi   : OFormL<0x12, 0x57, "INSWH $RA,$L,$RC", []>; //Insert word high
 170 //def INSWL    : OForm< 0x12, 0x1B, "INSWL $RA,$RB,$RC", []>; //Insert word low
 171 //def INSWLi   : OFormL<0x12, 0x1B, "INSWL $RA,$L,$RC", []>; //Insert word low
 172 //def MSKBL    : OForm< 0x12, 0x02, "MSKBL $RA,$RB,$RC", []>; //Mask byte low
 173 //def MSKBLi   : OFormL<0x12, 0x02, "MSKBL $RA,$L,$RC", []>; //Mask byte low
 174 //def MSKLH    : OForm< 0x12, 0x62, "MSKLH $RA,$RB,$RC", []>; //Mask longword high
 175 //def MSKLHi   : OFormL<0x12, 0x62, "MSKLH $RA,$L,$RC", []>; //Mask longword high
 176 //def MSKLL    : OForm< 0x12, 0x22, "MSKLL $RA,$RB,$RC", []>; //Mask longword low
 177 //def MSKLLi   : OFormL<0x12, 0x22, "MSKLL $RA,$L,$RC", []>; //Mask longword low
 178 //def MSKQH    : OForm< 0x12, 0x72, "MSKQH $RA,$RB,$RC", []>; //Mask quadword high
 179 //def MSKQHi   : OFormL<0x12, 0x72, "MSKQH $RA,$L,$RC", []>; //Mask quadword high
 180 //def MSKQL    : OForm< 0x12, 0x32, "MSKQL $RA,$RB,$RC", []>; //Mask quadword low
 181 //def MSKQLi   : OFormL<0x12, 0x32, "MSKQL $RA,$L,$RC", []>; //Mask quadword low
 182 //def MSKWH    : OForm< 0x12, 0x52, "MSKWH $RA,$RB,$RC", []>; //Mask word high
 183 //def MSKWHi   : OFormL<0x12, 0x52, "MSKWH $RA,$L,$RC", []>; //Mask word high
 184 //def MSKWL    : OForm< 0x12, 0x12, "MSKWL $RA,$RB,$RC", []>; //Mask word low
 185 //def MSKWLi   : OFormL<0x12, 0x12, "MSKWL $RA,$L,$RC", []>; //Mask word low
 186
 187 // Some Alpha pattern fragments to make things more terse and easier to read.
 188 def add4  : PatFrag<(ops node:$op1, node:$op2),
 189                     (add (shl node:$op1, 2), node:$op2)>;
 190 def sub4  : PatFrag<(ops node:$op1, node:$op2),
 191                     (sub (shl node:$op1, 2), node:$op2)>;
 192 def add8  : PatFrag<(ops node:$op1, node:$op2),
 193                     (add (shl node:$op1, 3), node:$op2)>;
 194 def sub8  : PatFrag<(ops node:$op1, node:$op2),
 195                     (sub (shl node:$op1, 3), node:$op2)>;
 196
 197 def MULL     : OForm< 0x13, 0x00, "mull $RA,$RB,$RC",
 198                       [(set GPRC:$RC, (intop (mul GPRC:$RA, GPRC:$RB)))]>;
 199 def MULLi    : OFormL<0x13, 0x00, "mull $RA,$L,$RC",
 200                       [(set GPRC:$RC, (intop (mul GPRC:$RA, immUExt8:$L)))]>;
 201 def MULQ     : OForm< 0x13, 0x20, "mulq $RA,$RB,$RC",
 202                       [(set GPRC:$RC, (mul GPRC:$RA, GPRC:$RB))]>;
 203 def MULQi    : OFormL<0x13, 0x20, "mulq $RA,$L,$RC",
 204                       [(set GPRC:$RC, (mul GPRC:$RA, immUExt8:$L))]>;
 205 def ORNOT    : OForm< 0x11, 0x28, "ornot $RA,$RB,$RC",
 206                       [(set GPRC:$RC, (or GPRC:$RA, (not GPRC:$RB)))]>;
 207 def ORNOTi   : OFormL<0x11, 0x28, "ornot $RA,$L,$RC", []>;
 208 //                      [(set GPRC:$RC, (or GPRC:$RA, (not immUExt8:$L)))]>;
 209 def S4ADDL   : OForm< 0x10, 0x02, "s4addl $RA,$RB,$RC",
 210                       [(set GPRC:$RC, (intop (add4 GPRC:$RA, GPRC:$RB)))]>;
 211 def S4ADDLi  : OFormL<0x10, 0x02, "s4addl $RA,$L,$RC",
 212                       [(set GPRC:$RC, (intop (add4 GPRC:$RA, immUExt8:$L)))]>;
 213 def S4ADDQ   : OForm< 0x10, 0x22, "s4addq $RA,$RB,$RC",
 214                       [(set GPRC:$RC, (add4 GPRC:$RA, GPRC:$RB))]>;
 215 def S4ADDQi  : OFormL<0x10, 0x22, "s4addq $RA,$L,$RC",
 216                       [(set GPRC:$RC, (add4 GPRC:$RA, immUExt8:$L))]>;
 217 def S4SUBL   : OForm< 0x10, 0x0B, "s4subl $RA,$RB,$RC",
 218                       [(set GPRC:$RC, (intop (sub4 GPRC:$RA, GPRC:$RB)))]>;
 219 def S4SUBLi  : OFormL<0x10, 0x0B, "s4subl $RA,$L,$RC",
 220                       [(set GPRC:$RC, (intop (sub4 GPRC:$RA, immUExt8:$L)))]>;
 221 def S4SUBQ   : OForm< 0x10, 0x2B, "s4subq $RA,$RB,$RC",
 222                       [(set GPRC:$RC, (sub4 GPRC:$RA, GPRC:$RB))]>;
 223 def S4SUBQi  : OFormL<0x10, 0x2B, "s4subq $RA,$L,$RC",
 224                       [(set GPRC:$RC, (sub4 GPRC:$RA, immUExt8:$L))]>;
 225 def S8ADDL   : OForm< 0x10, 0x12, "s8addl $RA,$RB,$RC",
 226                       [(set GPRC:$RC, (intop (add8 GPRC:$RA, GPRC:$RB)))]>;
 227 def S8ADDLi  : OFormL<0x10, 0x12, "s8addl $RA,$L,$RC",
 228                       [(set GPRC:$RC, (intop (add8 GPRC:$RA, immUExt8:$L)))]>;
 229 def S8ADDQ   : OForm< 0x10, 0x32, "s8addq $RA,$RB,$RC",
 230                       [(set GPRC:$RC, (add8 GPRC:$RA, GPRC:$RB))]>;
 231 def S8ADDQi  : OFormL<0x10, 0x32, "s8addq $RA,$L,$RC",
 232                       [(set GPRC:$RC, (add8 GPRC:$RA, immUExt8:$L))]>;
 233 def S8SUBL   : OForm< 0x10, 0x1B, "s8subl $RA,$RB,$RC",
 234                       [(set GPRC:$RC, (intop (sub8 GPRC:$RA, GPRC:$RB)))]>;
 235 def S8SUBLi  : OFormL<0x10, 0x1B, "s8subl $RA,$L,$RC",
 236                       [(set GPRC:$RC, (intop (sub8 GPRC:$RA, immUExt8:$L)))]>;
 237 def S8SUBQ   : OForm< 0x10, 0x3B, "s8subq $RA,$RB,$RC",
 238                       [(set GPRC:$RC, (sub8 GPRC:$RA, GPRC:$RB))]>;
 239 def S8SUBQi  : OFormL<0x10, 0x3B, "s8subq $RA,$L,$RC",
 240                       [(set GPRC:$RC, (sub8 GPRC:$RA, immUExt8:$L))]>;
 241 def SEXTB    : OForm2<0x1C, 0x00, "sextb $RB,$RC",
 242                       [(set GPRC:$RC, (sext_inreg GPRC:$RB, i8))]>;
 243 def SEXTW    : OForm2<0x1C, 0x01, "sextw $RB,$RC",
 244                       [(set GPRC:$RC, (sext_inreg GPRC:$RB, i16))]>;
 245 def SL       : OForm< 0x12, 0x39, "sll $RA,$RB,$RC",
 246                       [(set GPRC:$RC, (shl GPRC:$RA, GPRC:$RB))]>;
 247 def SLi      : OFormL<0x12, 0x39, "sll $RA,$L,$RC",
 248                       [(set GPRC:$RC, (shl GPRC:$RA, immUExt8:$L))]>;
 249 def SRA      : OForm< 0x12, 0x3C, "sra $RA,$RB,$RC",
 250                       [(set GPRC:$RC, (sra GPRC:$RA, GPRC:$RB))]>;
 251 def SRAi     : OFormL<0x12, 0x3C, "sra $RA,$L,$RC",
 252                       [(set GPRC:$RC, (sra GPRC:$RA, immUExt8:$L))]>;
 253 def SRL      : OForm< 0x12, 0x34, "srl $RA,$RB,$RC",
 254                       [(set GPRC:$RC, (srl GPRC:$RA, GPRC:$RB))]>;
 255 def SRLi     : OFormL<0x12, 0x34, "srl $RA,$L,$RC",
 256                       [(set GPRC:$RC, (srl GPRC:$RA, immUExt8:$L))]>;
 257 def SUBL     : OForm< 0x10, 0x09, "subl $RA,$RB,$RC",
 258                       [(set GPRC:$RC, (intop (sub GPRC:$RA, GPRC:$RB)))]>;
 259 def SUBLi    : OFormL<0x10, 0x09, "subl $RA,$L,$RC",
 260                       [(set GPRC:$RC, (intop (sub GPRC:$RA, immUExt8:$L)))]>;
 261 def SUBQ     : OForm< 0x10, 0x29, "subq $RA,$RB,$RC",
 262                       [(set GPRC:$RC, (sub GPRC:$RA, GPRC:$RB))]>;
 263 def SUBQi    : OFormL<0x10, 0x29, "subq $RA,$L,$RC",
 264                       [(set GPRC:$RC, (sub GPRC:$RA, immUExt8:$L))]>;
 265 def UMULH    : OForm< 0x13, 0x30, "umulh $RA,$RB,$RC",
 266                       [(set GPRC:$RC, (mulhu GPRC:$RA, GPRC:$RB))]>;
 267 def UMULHi   : OFormL<0x13, 0x30, "umulh $RA,$L,$RC",
 268                       [(set GPRC:$RC, (mulhu GPRC:$RA, immUExt8:$L))]>;
 269 def XOR      : OForm< 0x11, 0x40, "xor $RA,$RB,$RC",
 270                       [(set GPRC:$RC, (xor GPRC:$RA, GPRC:$RB))]>;
 271 def XORi     : OFormL<0x11, 0x40, "xor $RA,$L,$RC",
 272                       [(set GPRC:$RC, (xor GPRC:$RA, immUExt8:$L))]>;
 273 def ZAP      : OForm< 0x12, 0x30, "zap $RA,$RB,$RC", []>; //Zero bytes
 274 def ZAPi     : OFormL<0x12, 0x30, "zap $RA,$L,$RC", []>; //Zero bytes
 275 def ZAPNOT   : OForm< 0x12, 0x31, "zapnot $RA,$RB,$RC", []>; //Zero bytes not
 276 def ZAPNOTi  : OFormL<0x12, 0x31, "zapnot $RA,$L,$RC", []>; //Zero bytes not
 277
 278 //Comparison, int
 279 def CMPBGE   : OForm< 0x10, 0x0F, "cmpbge $RA,$RB,$RC", []>; //Compare byte
 280 def CMPBGEi  : OFormL<0x10, 0x0F, "cmpbge $RA,$L,$RC", []>; //Compare byte
 281 def CMPEQ    : OForm< 0x10, 0x2D, "cmpeq $RA,$RB,$RC", []>; //Compare signed quadword equal
 282 def CMPEQi   : OFormL<0x10, 0x2D, "cmpeq $RA,$L,$RC", []>; //Compare signed quadword equal
 283 def CMPLE    : OForm< 0x10, 0x6D, "cmple $RA,$RB,$RC", []>; //Compare signed quadword less than or equal
 284 def CMPLEi   : OFormL<0x10, 0x6D, "cmple $RA,$L,$RC", []>; //Compare signed quadword less than or equal
 285 def CMPLT    : OForm< 0x10, 0x4D, "cmplt $RA,$RB,$RC", []>; //Compare signed quadword less than
 286 def CMPLTi   : OFormL<0x10, 0x4D, "cmplt $RA,$L,$RC", []>; //Compare signed quadword less than
 287 def CMPULE   : OForm< 0x10, 0x3D, "cmpule $RA,$RB,$RC", []>; //Compare unsigned quadword less than or equal
 288 def CMPULEi  : OFormL<0x10, 0x3D, "cmpule $RA,$L,$RC", []>; //Compare unsigned quadword less than or equal
 289 def CMPULT   : OForm< 0x10, 0x1D, "cmpult $RA,$RB,$RC", []>; //Compare unsigned quadword less than
 290 def CMPULTi  : OFormL<0x10, 0x1D, "cmpult $RA,$L,$RC", []>; //Compare unsigned quadword less than
 291
 292 //Comparison, FP
 293 def CMPTEQ : FPForm<0x16, 0x0A5, "cmpteq/su $RA,$RB,$RC">;  //Compare T_floating equal
 294 def CMPTLE : FPForm<0x16, 0x0A7, "cmptle/su $RA,$RB,$RC">;  //Compare T_floating less than or equal
 295 def CMPTLT : FPForm<0x16, 0x0A6, "cmptlt/su $RA,$RB,$RC">;  //Compare T_floating less than
 296 def CMPTUN : FPForm<0x16, 0x0A4, "cmptun/su $RA,$RB,$RC">;  //Compare T_floating unordered
 297
 298 //There are in the Multimedia extentions, so let's not use them yet
 299 //def MAXSB8  : OForm<0x1C, 0x3E, "MAXSB8 $RA,$RB,$RC">; //Vector signed byte maximum
 300 //def MAXSW4 : OForm< 0x1C, 0x3F, "MAXSW4 $RA,$RB,$RC">; //Vector signed word maximum
 301 //def MAXUB8  : OForm<0x1C, 0x3C, "MAXUB8 $RA,$RB,$RC">; //Vector unsigned byte maximum
 302 //def MAXUW4 : OForm< 0x1C, 0x3D, "MAXUW4 $RA,$RB,$RC">; //Vector unsigned word maximum
 303 //def MINSB8 : OForm< 0x1C, 0x38, "MINSB8 $RA,$RB,$RC">; //Vector signed byte minimum
 304 //def MINSW4 : OForm< 0x1C, 0x39, "MINSW4 $RA,$RB,$RC">; //Vector signed word minimum
 305 //def MINUB8 : OForm< 0x1C, 0x3A, "MINUB8 $RA,$RB,$RC">; //Vector unsigned byte minimum
 306 //def MINUW4 : OForm< 0x1C, 0x3B, "MINUW4 $RA,$RB,$RC">; //Vector unsigned word minimum
 307 //def PERR : OForm< 0x1C, 0x31, "PERR $RA,$RB,$RC">; //Pixel error
 308 //def PKLB : OForm< 0x1C, 0x37, "PKLB $RA,$RB,$RC">; //Pack longwords to bytes
 309 //def PKWB  : OForm<0x1C, 0x36, "PKWB $RA,$RB,$RC">; //Pack words to bytes
 310 //def UNPKBL : OForm< 0x1C, 0x35, "UNPKBL $RA,$RB,$RC">; //Unpack bytes to longwords
 311 //def UNPKBW : OForm< 0x1C, 0x34, "UNPKBW $RA,$RB,$RC">; //Unpack bytes to words
 312
 313 //End operate
 314
 315 let isReturn = 1, isTerminator = 1 in
 316   def RET : MbrForm< 0x1A, 0x02, (ops GPRC:$RD, GPRC:$RS, s64imm:$DISP), "ret $RD,($RS),$DISP">; //Return from subroutine
 317 //DAG Version:
 318 let isReturn = 1, isTerminator = 1, Ra = 31, Rb = 26, disp = 1, Uses = [R26] in
 319   def RETDAG : MbrForm< 0x1A, 0x02, (ops), "ret $$31,($$26),1">; //Return from subroutine
 320
 321 def JMP : MbrForm< 0x1A, 0x00, (ops GPRC:$RD, GPRC:$RS, GPRC:$DISP), "jmp $RD,($RS),$DISP">; //Jump
 322 let isCall = 1,
 323     Defs = [R0, R1, R2, R3, R4, R5, R6, R7, R8, R16, R17, R18, R19,
 324             R20, R21, R22, R23, R24, R25, R27, R28, R29,
 325             F0, F1,
 326             F10, F11, F12, F13, F14, F15, F16, F17, F18, F19,
 327             F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30], Uses = [R29] in {
 328     def JSR : MbrForm< 0x1A, 0x01, (ops GPRC:$RD, GPRC:$RS, s14imm:$DISP), "jsr $RD,($RS),$DISP">; //Jump to subroutine
 329     def BSR : BForm<0x34, "bsr $RA,$DISP">; //Branch to subroutine
 330 }
 331 let isCall = 1, Defs = [R24, R25, R27, R28], Uses = [R24, R25] in
 332   def JSRs : MbrForm< 0x1A, 0x01, (ops GPRC:$RD, GPRC:$RS, s14imm:$DISP), "jsr $RD,($RS),$DISP">; //Jump to div or rem
 333
 334 def JSR_COROUTINE : MbrForm< 0x1A, 0x03, (ops GPRC:$RD, GPRC:$RS, s14imm:$DISP), "jsr_coroutine $RD,($RS),$DISP">; //Jump to subroutine return
 335 def BR : BForm<0x30, "br $RA,$DISP">; //Branch
 336
 337 //Stores, int
 338 def STB : MForm<0x0E, "stb $RA,$DISP($RB)">; // Store byte
 339 def STW : MForm<0x0D, "stw $RA,$DISP($RB)">; // Store word
 340 def STL : MForm<0x2C, "stl $RA,$DISP($RB)">; // Store longword
 341 def STQ : MForm<0x2D, "stq $RA,$DISP($RB)">; //Store quadword
 342
 343 //Loads, int
 344 def LDL : MForm<0x28,  "ldl $RA,$DISP($RB)">; // Load sign-extended longword
 345 def LDQ : MForm<0x29,  "ldq $RA,$DISP($RB)">; //Load quadword
 346 def LDBU : MForm<0x0A, "ldbu $RA,$DISP($RB)">; //Load zero-extended byte
 347 def LDWU : MForm<0x0C, "ldwu $RA,$DISP($RB)">; //Load zero-extended word
 348
 349 //Stores, float
 350 def STS : MForm<0x26, "sts $RA,$DISP($RB)">; //Store S_floating
 351 def STT : MForm<0x27, "stt $RA,$DISP($RB)">; //Store T_floating
 352
 353 //Loads, float
 354 def LDS : MForm<0x22, "lds $RA,$DISP($RB)">; //Load S_floating
 355 def LDT : MForm<0x23, "ldt $RA,$DISP($RB)">; //Load T_floating
 356
 357 //Load address
 358 def LDA : MForm<0x08,  "lda $RA,$DISP($RB)">;  //Load address
 359 def LDAH : MForm<0x09, "ldah $RA,$DISP($RB)">;  //Load address high
 360
 361
 362 //Loads, int, Rellocated Low form
 363 def LDLr : MForm<0x28,  "ldl $RA,$DISP($RB)\t\t!gprellow">; // Load sign-extended longword
 364 def LDQr : MForm<0x29,  "ldq $RA,$DISP($RB)\t\t!gprellow">; //Load quadword
 365 def LDBUr : MForm<0x0A, "ldbu $RA,$DISP($RB)\t\t!gprellow">; //Load zero-extended byte
 366 def LDWUr : MForm<0x0C, "ldwu $RA,$DISP($RB)\t\t!gprellow">; //Load zero-extended word
 367
 368 //Loads, float, Rellocated Low form
 369 def LDSr : MForm<0x22, "lds $RA,$DISP($RB)\t\t!gprellow">; //Load S_floating
 370 def LDTr : MForm<0x23, "ldt $RA,$DISP($RB)\t\t!gprellow">; //Load T_floating
 371
 372 //Load address, rellocated low and high form
 373 def LDAr : MForm<0x08,  "lda $RA,$DISP($RB)\t\t!gprellow">;  //Load address
 374 def LDAHr : MForm<0x09, "ldah $RA,$DISP($RB)\t\t!gprelhigh">;  //Load address high
 375
 376 //load address, rellocated gpdist form
 377 def LDAg : MgForm<0x08,  "lda $RA,0($RB)\t\t!gpdisp!$NUM">;  //Load address
 378 def LDAHg : MgForm<0x09, "ldah $RA,0($RB)\t\t!gpdisp!$NUM">;  //Load address
 379
 380
 381 //Load quad, rellocated literal form
 382 def LDQl : MForm<0x29, "ldq $RA,$DISP($RB)\t\t!literal">; //Load quadword
 383
 384 //Stores, int
 385 def STBr : MForm<0x0E, "stb $RA,$DISP($RB)\t\t!gprellow">; // Store byte
 386 def STWr : MForm<0x0D, "stw $RA,$DISP($RB)\t\t!gprellow">; // Store word
 387 def STLr : MForm<0x2C, "stl $RA,$DISP($RB)\t\t!gprellow">; // Store longword
 388 def STQr : MForm<0x2D, "stq $RA,$DISP($RB)\t\t!gprellow">; //Store quadword
 389
 390 //Stores, float
 391 def STSr : MForm<0x26, "sts $RA,$DISP($RB)\t\t!gprellow">; //Store S_floating
 392 def STTr : MForm<0x27, "stt $RA,$DISP($RB)\t\t!gprellow">; //Store T_floating
 393
 394
 395 //Branches, int
 396 def BEQ : BForm<0x39,  "beq $RA,$DISP">; //Branch if = zero
 397 def BGE : BForm<0x3E,  "bge $RA,$DISP">; //Branch if >= zero
 398 def BGT : BForm<0x3F,  "bgt $RA,$DISP">; //Branch if > zero
 399 def BLBC : BForm<0x38, "blbc $RA,$DISP">; //Branch if low bit clear
 400 def BLBS : BForm<0x3C, "blbs $RA,$DISP">; //Branch if low bit set
 401 def BLE : BForm<0x3B,  "ble $RA,$DISP">; //Branch if <= zero
 402 def BLT : BForm<0x3A,  "blt $RA,$DISP">; //Branch if < zero
 403 def BNE : BForm<0x3D,  "bne $RA,$DISP">; //Branch if != zero
 404
 405 //Branches, float
 406 def FBEQ : FBForm<0x31, "fbeq $RA,$DISP">; //Floating branch if =  zero
 407 def FBGE : FBForm<0x36, "fbge $RA,$DISP">; //Floating branch if >= zero
 408 def FBGT : FBForm<0x37, "fbgt $RA,$DISP">; //Floating branch if > zero
 409 def FBLE : FBForm<0x33, "fble $RA,$DISP">; //Floating branch if <= zero
 410 def FBLT : FBForm<0x32, "fblt $RA,$DISP">; //Floating branch if < zero
 411 def FBNE : FBForm<0x35, "fbne $RA,$DISP">; //Floating branch if != zero
 412
 413 //Funky Floating point ops
 414 def CPYS  : FPForm<0x17, 0x020, "cpys $RA,$RB,$RC">;  //Copy sign
 415 def CPYSE : FPForm<0x17, 0x022, "cpyse $RA,$RB,$RC">; //Copy sign and exponent
 416 def CPYSN : FPForm<0x17, 0x021, "cpysn $RA,$RB,$RC">; //Copy sign negate
 417
 418 //Basic Floating point ops
 419 def ADDS  : FPForm<0x16, 0x580, "adds/su $RA,$RB,$RC">;  //Add S_floating
 420 def ADDT  : FPForm<0x16, 0x5A0, "addt/su $RA,$RB,$RC">;  //Add T_floating
 421 def SUBS  : FPForm<0x16, 0x581, "subs/su $RA,$RB,$RC">;  //Subtract S_floating
 422 def SUBT  : FPForm<0x16, 0x5A1, "subt/su $RA,$RB,$RC">;  //Subtract T_floating
 423 def DIVS  : FPForm<0x16, 0x583, "divs/su $RA,$RB,$RC">;  //Divide S_floating
 424 def DIVT  : FPForm<0x16, 0x5A3, "divt/su $RA,$RB,$RC">;  //Divide T_floating
 425 def MULS  : FPForm<0x16, 0x582, "muls/su $RA,$RB,$RC">;  //Multiply S_floating
 426 def MULT  : FPForm<0x16, 0x5A2, "mult/su $RA,$RB,$RC">;  //Multiply T_floating
 427 def SQRTS : FPForm<0x14, 0x58B, "sqrts/su $RA,$RB,$RC">;  //Square root S_floating
 428 def SQRTT : FPForm<0x14, 0x5AB, "sqrtt/su $RA,$RB,$RC">;  //Square root T_floating
 429
 430 //INT reg to FP reg and back again
 431 //not supported on 21164
 432 def FTOIS : FPForm<0x1C, 0x078, "ftois $RA,$RC">; //Floating to integer move, S_floating
 433 def FTOIT : FPForm<0x1C, 0x070, "ftoit $RA,$RC">; //Floating to integer move, T_floating
 434 def ITOFS : FPForm<0x14, 0x004, "itofs $RA,$RC">; //Integer to floating move, S_floating
 435 def ITOFT : FPForm<0x14, 0x024, "itoft $RA,$RC">; //Integer to floating move, T_floating
 436
 437 //CVTLQ F-P 17.010 Convert longword to quadword
 438 //CVTQL F-P 17.030 Convert quadword to longword
 439 //These use SW completion, may not have function code for that set right (matters for JIT)
 440 def CVTQS : FPForm<0x16, 0x0BC, "cvtqs $RB,$RC">; //Convert quadword to S_floating
 441 def CVTQT : FPForm<0x16, 0x0BE, "cvtqt $RB,$RC">; //Convert quadword to T_floating
 442 def CVTST : FPForm<0x16, 0x2AC, "cvtsts $RB,$RC">; //Convert S_floating to T_floating
 443 def CVTTQ : FPForm<0x16, 0x52F, "cvttq/svc $RB,$RC">; //Convert T_floating to quadword
 444 def CVTTS : FPForm<0x16, 0x5AC, "cvtts/su $RB,$RC">; //Convert T_floating to S_floating
 445
 446 //S_floating : IEEE Single
 447 //T_floating : IEEE Double
 448
 449 //Mnemonic Format Opcode Description
 450
 451 //CALL_PAL Pcd 00 Trap to PALcode
 452 //ECB Mfc 18.E800 Evict cache block
 453 //EXCB Mfc 18.0400 Exception barrier
 454 //FETCH Mfc 18.8000 Prefetch data
 455 //FETCH_M Mfc 18.A000 Prefetch data, modify intent
 456
 457 //LDL_L Mem 2A Load sign-extended longword locked
 458 //LDQ_L Mem 2B Load quadword locked
 459 //LDQ_U Mem 0B Load unaligned quadword
 460 //MB Mfc 18.4000 Memory barrier
 461 //RPCC Mfc 18.C000 Read process cycle counter
 462
 463 //STL_C Mem 2E Store longword conditional
 464 //STQ_C Mem 2F Store quadword conditional
 465 //STQ_U Mem 0F Store unaligned quadword
 466
 467 //TRAPB Mfc 18.0000 Trap barrier
 468 //WH64 Mfc 18.F800 Write hint \14 64 bytes
 469 //WMB Mfc 18.4400 Write memory barrier
 470
 471
 472 //MF_FPCR F-P 17.025 Move from FPCR
 473 //MT_FPCR F-P 17.024 Move to FPCR