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