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