lib/Target/Alpha/AlphaInstrInfo.td

   1 //===- AlphaInstrInfo.td - The Alpha Instruction Set -------*- tablegen -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 include "AlphaInstrFormats.td"
  14
  15 //********************
  16 //Custom DAG Nodes
  17 //********************
  18
  19 def SDTFPUnaryOpUnC  : SDTypeProfile<1, 1, [
  20   SDTCisFP<1>, SDTCisFP<0>
  21 ]>;
  22 def Alpha_cvtqt   : SDNode<"AlphaISD::CVTQT_",    SDTFPUnaryOpUnC, []>;
  23 def Alpha_cvtqs   : SDNode<"AlphaISD::CVTQS_",    SDTFPUnaryOpUnC, []>;
  24 def Alpha_cvttq   : SDNode<"AlphaISD::CVTTQ_"  ,  SDTFPUnaryOp, []>;
  25 def Alpha_gprello : SDNode<"AlphaISD::GPRelLo",   SDTIntBinOp, []>;
  26 def Alpha_gprelhi : SDNode<"AlphaISD::GPRelHi",   SDTIntBinOp, []>;
  27 def Alpha_rellit  : SDNode<"AlphaISD::RelLit",    SDTIntBinOp, []>;
  28
  29 def retflag       : SDNode<"AlphaISD::RET_FLAG", SDTRet,
  30                            [SDNPHasChain, SDNPOptInFlag]>;
  31
  32 // These are target-independent nodes, but have target-specific formats.
  33 def SDT_AlphaCallSeqStart : SDCallSeqStart<[ SDTCisVT<0, i64> ]>;
  34 def SDT_AlphaCallSeqEnd   : SDCallSeqEnd<[ SDTCisVT<0, i64>,
  35                                            SDTCisVT<1, i64> ]>;
  36
  37 def callseq_start : SDNode<"ISD::CALLSEQ_START", SDT_AlphaCallSeqStart,
  38                            [SDNPHasChain, SDNPOutFlag]>;
  39 def callseq_end   : SDNode<"ISD::CALLSEQ_END",   SDT_AlphaCallSeqEnd,
  40                            [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
  41
  42 //********************
  43 //Paterns for matching
  44 //********************
  45 def invX : SDNodeXForm<imm, [{ //invert
  46   return getI64Imm(~N->getValue());
  47 }]>;
  48 def negX : SDNodeXForm<imm, [{ //negate
  49   return getI64Imm(~N->getValue() + 1);
  50 }]>;
  51 def SExt32 : SDNodeXForm<imm, [{ //signed extend int to long
  52   return getI64Imm(((int64_t)N->getValue() << 32) >> 32);
  53 }]>;
  54 def SExt16 : SDNodeXForm<imm, [{ //signed extend int to long
  55   return getI64Imm(((int64_t)N->getValue() << 48) >> 48);
  56 }]>;
  57 def LL16 : SDNodeXForm<imm, [{ //lda part of constant
  58   return getI64Imm(get_lda16(N->getValue()));
  59 }]>;
  60 def LH16 : SDNodeXForm<imm, [{ //ldah part of constant (or more if too big)
  61   return getI64Imm(get_ldah16(N->getValue()));
  62 }]>;
  63 def iZAPX : SDNodeXForm<and, [{ // get imm to ZAPi
  64   ConstantSDNode *RHS = cast<ConstantSDNode>(N->getOperand(1));
  65   return getI64Imm(get_zapImm(SDOperand(), RHS->getValue()));
  66 }]>;
  67 def nearP2X : SDNodeXForm<imm, [{
  68   return getI64Imm(Log2_64(getNearPower2((uint64_t)N->getValue())));
  69 }]>;
  70 def nearP2RemX : SDNodeXForm<imm, [{
  71   uint64_t x = abs(N->getValue() - getNearPower2((uint64_t)N->getValue()));
  72   return getI64Imm(Log2_64(x));
  73 }]>;
  74
  75 def immUExt8  : PatLeaf<(imm), [{ //imm fits in 8 bit zero extended field
  76   return (uint64_t)N->getValue() == (uint8_t)N->getValue();
  77 }]>;
  78 def immUExt8inv  : PatLeaf<(imm), [{ //inverted imm fits in 8 bit zero extended field
  79   return (uint64_t)~N->getValue() == (uint8_t)~N->getValue();
  80 }], invX>;
  81 def immUExt8neg  : PatLeaf<(imm), [{ //negated imm fits in 8 bit zero extended field
  82   return ((uint64_t)~N->getValue() + 1) == (uint8_t)((uint64_t)~N->getValue() + 1);
  83 }], negX>;
  84 def immSExt16  : PatLeaf<(imm), [{ //imm fits in 16 bit sign extended field
  85   return ((int64_t)N->getValue() << 48) >> 48 == (int64_t)N->getValue();
  86 }]>;
  87 def immSExt16int  : PatLeaf<(imm), [{ //(int)imm fits in a 16 bit sign extended field
  88   return ((int64_t)N->getValue() << 48) >> 48 == ((int64_t)N->getValue() << 32) >> 32;
  89 }], SExt16>;
  90
  91 def zappat : PatFrag<(ops node:$LHS), (and node:$LHS, imm:$L), [{
  92   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N->getOperand(1))) {
  93     uint64_t build = get_zapImm(N->getOperand(0), (uint64_t)RHS->getValue());
  94     return build != 0;
  95   }
  96   return false;
  97 }]>;
  98
  99 def immFPZ  : PatLeaf<(fpimm), [{ //the only fpconstant nodes are +/- 0.0
 100   (void)N; // silence warning.
 101   return true;
 102 }]>;
 103
 104 def immRem1  : PatLeaf<(imm), [{return chkRemNearPower2(N->getValue(),1, 0);}]>;
 105 def immRem2  : PatLeaf<(imm), [{return chkRemNearPower2(N->getValue(),2, 0);}]>;
 106 def immRem3  : PatLeaf<(imm), [{return chkRemNearPower2(N->getValue(),3, 0);}]>;
 107 def immRem4  : PatLeaf<(imm), [{return chkRemNearPower2(N->getValue(),4, 0);}]>;
 108 def immRem5  : PatLeaf<(imm), [{return chkRemNearPower2(N->getValue(),5, 0);}]>;
 109 def immRem1n : PatLeaf<(imm), [{return chkRemNearPower2(N->getValue(),1, 1);}]>;
 110 def immRem2n : PatLeaf<(imm), [{return chkRemNearPower2(N->getValue(),2, 1);}]>;
 111 def immRem3n : PatLeaf<(imm), [{return chkRemNearPower2(N->getValue(),3, 1);}]>;
 112 def immRem4n : PatLeaf<(imm), [{return chkRemNearPower2(N->getValue(),4, 1);}]>;
 113 def immRem5n : PatLeaf<(imm), [{return chkRemNearPower2(N->getValue(),5, 1);}]>;
 114
 115 def immRemP2n : PatLeaf<(imm), [{
 116   return isPowerOf2_64(getNearPower2((uint64_t)N->getValue()) - N->getValue());
 117 }]>;
 118 def immRemP2 : PatLeaf<(imm), [{
 119   return isPowerOf2_64(N->getValue() - getNearPower2((uint64_t)N->getValue()));
 120 }]>;
 121 def immUExt8ME : PatLeaf<(imm), [{ //use this imm for mulqi
 122   int64_t d =  abs((int64_t)N->getValue() - (int64_t)getNearPower2((uint64_t)N->getValue()));
 123   if (isPowerOf2_64(d)) return false;
 124   switch (d) {
 125     case 1: case 3: case 5: return false;
 126     default: return (uint64_t)N->getValue() == (uint8_t)N->getValue();
 127   };
 128 }]>;
 129
 130 def intop : PatFrag<(ops node:$op), (sext_inreg node:$op, i32)>;
 131 def add4  : PatFrag<(ops node:$op1, node:$op2),
 132                     (add (shl node:$op1, 2), node:$op2)>;
 133 def sub4  : PatFrag<(ops node:$op1, node:$op2),
 134                     (sub (shl node:$op1, 2), node:$op2)>;
 135 def add8  : PatFrag<(ops node:$op1, node:$op2),
 136                     (add (shl node:$op1, 3), node:$op2)>;
 137 def sub8  : PatFrag<(ops node:$op1, node:$op2),
 138                     (sub (shl node:$op1, 3), node:$op2)>;
 139 class BinOpFrag<dag res> : PatFrag<(ops node:$LHS, node:$RHS), res>;
 140 class CmpOpFrag<dag res> : PatFrag<(ops node:$R), res>;
 141
 142 //Pseudo ops for selection
 143
 144 let isImplicitDef = 1 in {
 145 def IDEF_I : PseudoInstAlpha<(outs GPRC:$RA), (ins), ";#idef $RA",
 146              [(set GPRC:$RA, (undef))], s_pseudo>;
 147 def IDEF_F32 : PseudoInstAlpha<(outs F4RC:$RA), (ins), ";#idef $RA",
 148              [(set F4RC:$RA, (undef))], s_pseudo>;
 149 def IDEF_F64 : PseudoInstAlpha<(outs F8RC:$RA), (ins), ";#idef $RA",
 150              [(set F8RC:$RA, (undef))], s_pseudo>;
 151 }
 152
 153 def WTF : PseudoInstAlpha<(outs), (ins variable_ops), "#wtf", [], s_pseudo>;
 154
 155 let isLoad = 1, hasCtrlDep = 1, Defs = [R30], Uses = [R30] in {
 156 def ADJUSTSTACKUP : PseudoInstAlpha<(outs), (ins s64imm:$amt),
 157                 "; ADJUP $amt",
 158                 [(callseq_start imm:$amt)], s_pseudo>;
 159 def ADJUSTSTACKDOWN : PseudoInstAlpha<(outs), (ins s64imm:$amt1, s64imm:$amt2),
 160                 "; ADJDOWN $amt1",
 161                 [(callseq_end imm:$amt1, imm:$amt2)], s_pseudo>;
 162 }
 163
 164 def ALTENT : PseudoInstAlpha<(outs), (ins s64imm:$TARGET), "$$$TARGET..ng:\n", [], s_pseudo>;
 165 def PCLABEL : PseudoInstAlpha<(outs), (ins s64imm:$num), "PCMARKER_$num:\n",[], s_pseudo>;
 166 def MEMLABEL : PseudoInstAlpha<(outs), (ins s64imm:$i, s64imm:$j, s64imm:$k, s64imm:$m),
 167          "LSMARKER$$$i$$$j$$$k$$$m:", [], s_pseudo>;
 168
 169
 170 //***********************
 171 //Real instructions
 172 //***********************
 173
 174 //Operation Form:
 175
 176 //conditional moves, int
 177
 178 multiclass cmov_inst<bits<7> fun, string asmstr, PatFrag OpNode> {
 179 def r : OForm4<0x11, fun, !strconcat(asmstr, " $RCOND,$RTRUE,$RDEST"),
 180              [(set GPRC:$RDEST, (select (OpNode GPRC:$RCOND), GPRC:$RTRUE, GPRC:$RFALSE))], s_cmov>;
 181 def i : OForm4L<0x11, fun, !strconcat(asmstr, " $RCOND,$RTRUE,$RDEST"),
 182              [(set GPRC:$RDEST, (select (OpNode GPRC:$RCOND), immUExt8:$RTRUE, GPRC:$RFALSE))], s_cmov>;
 183 }
 184
 185 defm CMOVEQ  : cmov_inst<0x24, "cmoveq",  CmpOpFrag<(seteq node:$R, 0)>>;
 186 defm CMOVNE  : cmov_inst<0x26, "cmovne",  CmpOpFrag<(setne node:$R, 0)>>;
 187 defm CMOVLT  : cmov_inst<0x44, "cmovlt",  CmpOpFrag<(setlt node:$R, 0)>>;
 188 defm CMOVLE  : cmov_inst<0x64, "cmovle",  CmpOpFrag<(setle node:$R, 0)>>;
 189 defm CMOVGT  : cmov_inst<0x66, "cmovgt",  CmpOpFrag<(setgt node:$R, 0)>>;
 190 defm CMOVGE  : cmov_inst<0x46, "cmovge",  CmpOpFrag<(setge node:$R, 0)>>;
 191 defm CMOVLBC : cmov_inst<0x16, "cmovlbc", CmpOpFrag<(xor   node:$R, 1)>>;
 192 defm CMOVLBS : cmov_inst<0x14, "cmovlbs", CmpOpFrag<(and   node:$R, 1)>>;
 193
 194 //General pattern for cmov
 195 def : Pat<(select GPRC:$which, GPRC:$src1, GPRC:$src2),
 196       (CMOVNEr GPRC:$src2, GPRC:$src1, GPRC:$which)>;
 197 def : Pat<(select GPRC:$which, GPRC:$src1, immUExt8:$src2),
 198       (CMOVEQi GPRC:$src1, immUExt8:$src2, GPRC:$which)>;
 199
 200 //Invert sense when we can for constants:
 201 def : Pat<(select (setne GPRC:$RCOND, 0), GPRC:$RTRUE, immUExt8:$RFALSE),
 202           (CMOVEQi GPRC:$RCOND, immUExt8:$RFALSE, GPRC:$RTRUE)>;
 203 def : Pat<(select (setgt GPRC:$RCOND, 0), GPRC:$RTRUE, immUExt8:$RFALSE),
 204           (CMOVLEi GPRC:$RCOND, immUExt8:$RFALSE, GPRC:$RTRUE)>;
 205 def : Pat<(select (setge GPRC:$RCOND, 0), GPRC:$RTRUE, immUExt8:$RFALSE),
 206           (CMOVLTi GPRC:$RCOND, immUExt8:$RFALSE, GPRC:$RTRUE)>;
 207 def : Pat<(select (setlt GPRC:$RCOND, 0), GPRC:$RTRUE, immUExt8:$RFALSE),
 208           (CMOVGEi GPRC:$RCOND, immUExt8:$RFALSE, GPRC:$RTRUE)>;
 209 def : Pat<(select (setle GPRC:$RCOND, 0), GPRC:$RTRUE, immUExt8:$RFALSE),
 210           (CMOVGTi GPRC:$RCOND, immUExt8:$RFALSE, GPRC:$RTRUE)>;
 211
 212 multiclass all_inst<bits<6> opc, bits<7> funl, bits<7> funq,
 213                     string asmstr, PatFrag OpNode, InstrItinClass itin> {
 214   def Lr : OForm< opc, funl, !strconcat(asmstr, "l $RA,$RB,$RC"),
 215                [(set GPRC:$RC, (intop (OpNode GPRC:$RA, GPRC:$RB)))], itin>;
 216   def Li : OFormL<opc, funl, !strconcat(asmstr, "l $RA,$L,$RC"),
 217                [(set GPRC:$RC, (intop (OpNode GPRC:$RA, immUExt8:$L)))], itin>;
 218   def Qr : OForm< opc, funq, !strconcat(asmstr, "q $RA,$RB,$RC"),
 219                [(set GPRC:$RC, (OpNode GPRC:$RA, GPRC:$RB))], itin>;
 220   def Qi : OFormL<opc, funq, !strconcat(asmstr, "q $RA,$L,$RC"),
 221                [(set GPRC:$RC, (OpNode GPRC:$RA, immUExt8:$L))], itin>;
 222 }
 223
 224 defm MUL   : all_inst<0x13, 0x00, 0x20, "mul",   BinOpFrag<(mul node:$LHS, node:$RHS)>, s_imul>;
 225 defm ADD   : all_inst<0x10, 0x00, 0x20, "add",   BinOpFrag<(add node:$LHS, node:$RHS)>, s_iadd>;
 226 defm S4ADD : all_inst<0x10, 0x02, 0x22, "s4add", add4, s_iadd>;
 227 defm S8ADD : all_inst<0x10, 0x12, 0x32, "s8add", add8, s_iadd>;
 228 defm S4SUB : all_inst<0x10, 0x0B, 0x2B, "s4sub", sub4, s_iadd>;
 229 defm S8SUB : all_inst<0x10, 0x1B, 0x3B, "s8sub", sub8, s_iadd>;
 230 defm SUB   : all_inst<0x10, 0x09, 0x29, "sub",   BinOpFrag<(sub node:$LHS, node:$RHS)>, s_iadd>;
 231 //Const cases since legalize does sub x, int -> add x, inv(int) + 1
 232 def : Pat<(intop (add GPRC:$RA, immUExt8neg:$L)), (SUBLi GPRC:$RA, immUExt8neg:$L)>;
 233 def : Pat<(add GPRC:$RA, immUExt8neg:$L), (SUBQi GPRC:$RA, immUExt8neg:$L)>;
 234 def : Pat<(intop (add4 GPRC:$RA, immUExt8neg:$L)), (S4SUBLi GPRC:$RA, immUExt8neg:$L)>;
 235 def : Pat<(add4 GPRC:$RA, immUExt8neg:$L), (S4SUBQi GPRC:$RA, immUExt8neg:$L)>;
 236 def : Pat<(intop (add8 GPRC:$RA, immUExt8neg:$L)), (S8SUBLi GPRC:$RA, immUExt8neg:$L)>;
 237 def : Pat<(add8 GPRC:$RA, immUExt8neg:$L), (S8SUBQi GPRC:$RA, immUExt8neg:$L)>;
 238
 239 multiclass log_inst<bits<6> opc, bits<7> fun, string asmstr, SDNode OpNode, InstrItinClass itin> {
 240 def r : OForm<opc, fun, !strconcat(asmstr, " $RA,$RB,$RC"),
 241               [(set GPRC:$RC, (OpNode GPRC:$RA, GPRC:$RB))], itin>;
 242 def i : OFormL<opc, fun, !strconcat(asmstr, " $RA,$L,$RC"),
 243               [(set GPRC:$RC, (OpNode GPRC:$RA, immUExt8:$L))], itin>;
 244 }
 245 multiclass inv_inst<bits<6> opc, bits<7> fun, string asmstr, SDNode OpNode, InstrItinClass itin> {
 246 def r : OForm<opc, fun, !strconcat(asmstr, " $RA,$RB,$RC"),
 247               [(set GPRC:$RC, (OpNode GPRC:$RA, (not GPRC:$RB)))], itin>;
 248 def i : OFormL<opc, fun, !strconcat(asmstr, " $RA,$L,$RC"),
 249               [(set GPRC:$RC, (OpNode GPRC:$RA, immUExt8inv:$L))], itin>;
 250 }
 251
 252 defm AND   : log_inst<0x11, 0x00, "and",   and,   s_ilog>;
 253 defm BIC   : inv_inst<0x11, 0x08, "bic",   and,   s_ilog>;
 254 defm BIS   : log_inst<0x11, 0x20, "bis",   or,    s_ilog>;
 255 defm ORNOT : inv_inst<0x11, 0x28, "ornot", or,    s_ilog>;
 256 defm XOR   : log_inst<0x11, 0x40, "xor",   xor,   s_ilog>;
 257 defm EQV   : inv_inst<0x11, 0x48, "eqv",   xor,   s_ilog>;
 258
 259 defm SL    : log_inst<0x12, 0x39, "sll",   shl,   s_ishf>;
 260 defm SRA   : log_inst<0x12, 0x3c, "sra",   sra,   s_ishf>;
 261 defm SRL   : log_inst<0x12, 0x34, "srl",   srl,   s_ishf>;
 262 defm UMULH : log_inst<0x13, 0x30, "umulh", mulhu, s_imul>;
 263
 264 def CTLZ     : OForm2<0x1C, 0x32, "CTLZ $RB,$RC",
 265                       [(set GPRC:$RC, (ctlz GPRC:$RB))], s_imisc>;
 266 def CTPOP    : OForm2<0x1C, 0x30, "CTPOP $RB,$RC",
 267                       [(set GPRC:$RC, (ctpop GPRC:$RB))], s_imisc>;
 268 def CTTZ     : OForm2<0x1C, 0x33, "CTTZ $RB,$RC",
 269                       [(set GPRC:$RC, (cttz GPRC:$RB))], s_imisc>;
 270 def EXTBL    : OForm< 0x12, 0x06, "EXTBL $RA,$RB,$RC",
 271                       [(set GPRC:$RC, (and (srl GPRC:$RA, (shl GPRC:$RB, 3)), 255))], s_ishf>;
 272 def EXTWL    : OForm< 0x12, 0x16, "EXTWL $RA,$RB,$RC",
 273                       [(set GPRC:$RC, (and (srl GPRC:$RA, (shl GPRC:$RB, 3)), 65535))], s_ishf>;
 274 def EXTLL    : OForm< 0x12, 0x26, "EXTLL $RA,$RB,$RC",
 275                       [(set GPRC:$RC, (and (srl GPRC:$RA, (shl GPRC:$RB, 3)), 4294967295))], s_ishf>;
 276 def SEXTB    : OForm2<0x1C, 0x00, "sextb $RB,$RC",
 277                       [(set GPRC:$RC, (sext_inreg GPRC:$RB, i8))], s_ishf>;
 278 def SEXTW    : OForm2<0x1C, 0x01, "sextw $RB,$RC",
 279                       [(set GPRC:$RC, (sext_inreg GPRC:$RB, i16))], s_ishf>;
 280
 281 //def EXTBLi   : OFormL<0x12, 0x06, "EXTBL $RA,$L,$RC", []>; //Extract byte low
 282 //def EXTLH    : OForm< 0x12, 0x6A, "EXTLH $RA,$RB,$RC", []>; //Extract longword high
 283 //def EXTLHi   : OFormL<0x12, 0x6A, "EXTLH $RA,$L,$RC", []>; //Extract longword high
 284 //def EXTLLi   : OFormL<0x12, 0x26, "EXTLL $RA,$L,$RC", []>; //Extract longword low
 285 //def EXTQH    : OForm< 0x12, 0x7A, "EXTQH $RA,$RB,$RC", []>; //Extract quadword high
 286 //def EXTQHi   : OFormL<0x12, 0x7A, "EXTQH $RA,$L,$RC", []>; //Extract quadword high
 287 //def EXTQ     : OForm< 0x12, 0x36, "EXTQ $RA,$RB,$RC", []>; //Extract quadword low
 288 //def EXTQi    : OFormL<0x12, 0x36, "EXTQ $RA,$L,$RC", []>; //Extract quadword low
 289 //def EXTWH    : OForm< 0x12, 0x5A, "EXTWH $RA,$RB,$RC", []>; //Extract word high
 290 //def EXTWHi   : OFormL<0x12, 0x5A, "EXTWH $RA,$L,$RC", []>; //Extract word high
 291 //def EXTWLi   : OFormL<0x12, 0x16, "EXTWL $RA,$L,$RC", []>; //Extract word low
 292
 293 //def INSBL    : OForm< 0x12, 0x0B, "INSBL $RA,$RB,$RC", []>; //Insert byte low
 294 //def INSBLi   : OFormL<0x12, 0x0B, "INSBL $RA,$L,$RC", []>; //Insert byte low
 295 //def INSLH    : OForm< 0x12, 0x67, "INSLH $RA,$RB,$RC", []>; //Insert longword high
 296 //def INSLHi   : OFormL<0x12, 0x67, "INSLH $RA,$L,$RC", []>; //Insert longword high
 297 //def INSLL    : OForm< 0x12, 0x2B, "INSLL $RA,$RB,$RC", []>; //Insert longword low
 298 //def INSLLi   : OFormL<0x12, 0x2B, "INSLL $RA,$L,$RC", []>; //Insert longword low
 299 //def INSQH    : OForm< 0x12, 0x77, "INSQH $RA,$RB,$RC", []>; //Insert quadword high
 300 //def INSQHi   : OFormL<0x12, 0x77, "INSQH $RA,$L,$RC", []>; //Insert quadword high
 301 //def INSQL    : OForm< 0x12, 0x3B, "INSQL $RA,$RB,$RC", []>; //Insert quadword low
 302 //def INSQLi   : OFormL<0x12, 0x3B, "INSQL $RA,$L,$RC", []>; //Insert quadword low
 303 //def INSWH    : OForm< 0x12, 0x57, "INSWH $RA,$RB,$RC", []>; //Insert word high
 304 //def INSWHi   : OFormL<0x12, 0x57, "INSWH $RA,$L,$RC", []>; //Insert word high
 305 //def INSWL    : OForm< 0x12, 0x1B, "INSWL $RA,$RB,$RC", []>; //Insert word low
 306 //def INSWLi   : OFormL<0x12, 0x1B, "INSWL $RA,$L,$RC", []>; //Insert word low
 307
 308 //def MSKBL    : OForm< 0x12, 0x02, "MSKBL $RA,$RB,$RC", []>; //Mask byte low
 309 //def MSKBLi   : OFormL<0x12, 0x02, "MSKBL $RA,$L,$RC", []>; //Mask byte low
 310 //def MSKLH    : OForm< 0x12, 0x62, "MSKLH $RA,$RB,$RC", []>; //Mask longword high
 311 //def MSKLHi   : OFormL<0x12, 0x62, "MSKLH $RA,$L,$RC", []>; //Mask longword high
 312 //def MSKLL    : OForm< 0x12, 0x22, "MSKLL $RA,$RB,$RC", []>; //Mask longword low
 313 //def MSKLLi   : OFormL<0x12, 0x22, "MSKLL $RA,$L,$RC", []>; //Mask longword low
 314 //def MSKQH    : OForm< 0x12, 0x72, "MSKQH $RA,$RB,$RC", []>; //Mask quadword high
 315 //def MSKQHi   : OFormL<0x12, 0x72, "MSKQH $RA,$L,$RC", []>; //Mask quadword high
 316 //def MSKQL    : OForm< 0x12, 0x32, "MSKQL $RA,$RB,$RC", []>; //Mask quadword low
 317 //def MSKQLi   : OFormL<0x12, 0x32, "MSKQL $RA,$L,$RC", []>; //Mask quadword low
 318 //def MSKWH    : OForm< 0x12, 0x52, "MSKWH $RA,$RB,$RC", []>; //Mask word high
 319 //def MSKWHi   : OFormL<0x12, 0x52, "MSKWH $RA,$L,$RC", []>; //Mask word high
 320 //def MSKWL    : OForm< 0x12, 0x12, "MSKWL $RA,$RB,$RC", []>; //Mask word low
 321 //def MSKWLi   : OFormL<0x12, 0x12, "MSKWL $RA,$L,$RC", []>; //Mask word low
 322
 323 def ZAPNOTi  : OFormL<0x12, 0x31, "zapnot $RA,$L,$RC", [], s_ishf>;
 324
 325 // Define the pattern that produces ZAPNOTi.
 326 def : Pat<(i64 (zappat GPRC:$RA):$imm),
 327           (ZAPNOTi GPRC:$RA, (iZAPX GPRC:$imm))>;
 328
 329
 330 //Comparison, int
 331 //So this is a waste of what this instruction can do, but it still saves something
 332 def CMPBGE  : OForm< 0x10, 0x0F, "cmpbge $RA,$RB,$RC",
 333                      [(set GPRC:$RC, (setuge (and GPRC:$RA, 255), (and GPRC:$RB, 255)))], s_ilog>;
 334 def CMPBGEi : OFormL<0x10, 0x0F, "cmpbge $RA,$L,$RC",
 335                      [(set GPRC:$RC, (setuge (and GPRC:$RA, 255), immUExt8:$L))], s_ilog>;
 336 def CMPEQ   : OForm< 0x10, 0x2D, "cmpeq $RA,$RB,$RC",
 337                      [(set GPRC:$RC, (seteq GPRC:$RA, GPRC:$RB))], s_iadd>;
 338 def CMPEQi  : OFormL<0x10, 0x2D, "cmpeq $RA,$L,$RC",
 339                      [(set GPRC:$RC, (seteq GPRC:$RA, immUExt8:$L))], s_iadd>;
 340 def CMPLE   : OForm< 0x10, 0x6D, "cmple $RA,$RB,$RC",
 341                      [(set GPRC:$RC, (setle GPRC:$RA, GPRC:$RB))], s_iadd>;
 342 def CMPLEi  : OFormL<0x10, 0x6D, "cmple $RA,$L,$RC",
 343                      [(set GPRC:$RC, (setle GPRC:$RA, immUExt8:$L))], s_iadd>;
 344 def CMPLT   : OForm< 0x10, 0x4D, "cmplt $RA,$RB,$RC",
 345                      [(set GPRC:$RC, (setlt GPRC:$RA, GPRC:$RB))], s_iadd>;
 346 def CMPLTi  : OFormL<0x10, 0x4D, "cmplt $RA,$L,$RC",
 347                      [(set GPRC:$RC, (setlt GPRC:$RA, immUExt8:$L))], s_iadd>;
 348 def CMPULE  : OForm< 0x10, 0x3D, "cmpule $RA,$RB,$RC",
 349                      [(set GPRC:$RC, (setule GPRC:$RA, GPRC:$RB))], s_iadd>;
 350 def CMPULEi : OFormL<0x10, 0x3D, "cmpule $RA,$L,$RC",
 351                      [(set GPRC:$RC, (setule GPRC:$RA, immUExt8:$L))], s_iadd>;
 352 def CMPULT  : OForm< 0x10, 0x1D, "cmpult $RA,$RB,$RC",
 353                      [(set GPRC:$RC, (setult GPRC:$RA, GPRC:$RB))], s_iadd>;
 354 def CMPULTi : OFormL<0x10, 0x1D, "cmpult $RA,$L,$RC",
 355                       [(set GPRC:$RC, (setult GPRC:$RA, immUExt8:$L))], s_iadd>;
 356
 357 //Patterns for unsupported int comparisons
 358 def : Pat<(setueq GPRC:$X, GPRC:$Y), (CMPEQ GPRC:$X, GPRC:$Y)>;
 359 def : Pat<(setueq GPRC:$X, immUExt8:$Y), (CMPEQi GPRC:$X, immUExt8:$Y)>;
 360
 361 def : Pat<(setugt GPRC:$X, GPRC:$Y), (CMPULT GPRC:$Y, GPRC:$X)>;
 362 def : Pat<(setugt immUExt8:$X, GPRC:$Y), (CMPULTi GPRC:$Y, immUExt8:$X)>;
 363
 364 def : Pat<(setuge GPRC:$X, GPRC:$Y), (CMPULE GPRC:$Y, GPRC:$X)>;
 365 def : Pat<(setuge immUExt8:$X, GPRC:$Y), (CMPULEi GPRC:$Y, immUExt8:$X)>;
 366
 367 def : Pat<(setgt GPRC:$X, GPRC:$Y), (CMPLT GPRC:$Y, GPRC:$X)>;
 368 def : Pat<(setgt immUExt8:$X, GPRC:$Y), (CMPLTi GPRC:$Y, immUExt8:$X)>;
 369
 370 def : Pat<(setge GPRC:$X, GPRC:$Y), (CMPLE GPRC:$Y, GPRC:$X)>;
 371 def : Pat<(setge immUExt8:$X, GPRC:$Y), (CMPLEi GPRC:$Y, immUExt8:$X)>;
 372
 373 def : Pat<(setne GPRC:$X, GPRC:$Y), (CMPEQi (CMPEQ GPRC:$X, GPRC:$Y), 0)>;
 374 def : Pat<(setne GPRC:$X, immUExt8:$Y), (CMPEQi (CMPEQi GPRC:$X, immUExt8:$Y), 0)>;
 375
 376 def : Pat<(setune GPRC:$X, GPRC:$Y), (CMPEQi (CMPEQ GPRC:$X, GPRC:$Y), 0)>;
 377 def : Pat<(setune GPRC:$X, immUExt8:$Y), (CMPEQi (CMPEQ GPRC:$X, immUExt8:$Y), 0)>;
 378
 379
 380 let isReturn = 1, isTerminator = 1, Ra = 31, Rb = 26, disp = 1, Uses = [R26] in {
 381   def RETDAG : MbrForm< 0x1A, 0x02, (ops), "ret $$31,($$26),1", s_jsr>; //Return from subroutine
 382   def RETDAGp : MbrpForm< 0x1A, 0x02, (ops), "ret $$31,($$26),1", [(retflag)], s_jsr>; //Return from subroutine
 383 }
 384
 385 let isBranch = 1, isTerminator = 1, isBarrier = 1, isIndirectBranch = 1, Ra = 31, disp = 0 in
 386 def JMP : MbrpForm< 0x1A, 0x00, (ops GPRC:$RS), "jmp $$31,($RS),0",
 387           [(brind GPRC:$RS)], s_jsr>; //Jump
 388
 389 let isCall = 1, Ra = 26,
 390     Defs = [R0, R1, R2, R3, R4, R5, R6, R7, R8, R16, R17, R18, R19,
 391             R20, R21, R22, R23, R24, R25, R26, R27, R28, R29,
 392             F0, F1,
 393             F10, F11, F12, F13, F14, F15, F16, F17, F18, F19,
 394             F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30], Uses = [R29] in {
 395     def BSR : BFormD<0x34, "bsr $$26,$$$DISP..ng", [], s_jsr>; //Branch to subroutine
 396 }
 397 let isCall = 1, Ra = 26, Rb = 27, disp = 0,
 398     Defs = [R0, R1, R2, R3, R4, R5, R6, R7, R8, R16, R17, R18, R19,
 399             R20, R21, R22, R23, R24, R25, R26, R27, R28, R29,
 400             F0, F1,
 401             F10, F11, F12, F13, F14, F15, F16, F17, F18, F19,
 402             F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30], Uses = [R27, R29] in {
 403     def JSR : MbrForm< 0x1A, 0x01, (ops ), "jsr $$26,($$27),0", s_jsr>; //Jump to subroutine
 404 }
 405
 406 let isCall = 1, Ra = 23, Rb = 27, disp = 0,
 407     Defs = [R23, R24, R25, R27, R28], Uses = [R24, R25, R27] in
 408   def JSRs : MbrForm< 0x1A, 0x01, (ops ), "jsr $$23,($$27),0", s_jsr>; //Jump to div or rem
 409
 410
 411 def JSR_COROUTINE : MbrForm< 0x1A, 0x03, (ops GPRC:$RD, GPRC:$RS, s14imm:$DISP), "jsr_coroutine $RD,($RS),$DISP", s_jsr>; //Jump to subroutine return
 412
 413
 414 let OutOperandList = (ops GPRC:$RA), InOperandList = (ops s64imm:$DISP, GPRC:$RB) in {
 415 def LDQ   : MForm<0x29, 1, "ldq $RA,$DISP($RB)",
 416                  [(set GPRC:$RA, (load (add GPRC:$RB, immSExt16:$DISP)))], s_ild>;
 417 def LDQr  : MForm<0x29, 1, "ldq $RA,$DISP($RB)\t\t!gprellow",
 418                  [(set GPRC:$RA, (load (Alpha_gprello tglobaladdr:$DISP, GPRC:$RB)))], s_ild>;
 419 def LDL   : MForm<0x28, 1, "ldl $RA,$DISP($RB)",
 420                  [(set GPRC:$RA, (sextloadi32 (add GPRC:$RB, immSExt16:$DISP)))], s_ild>;
 421 def LDLr  : MForm<0x28, 1, "ldl $RA,$DISP($RB)\t\t!gprellow",
 422                  [(set GPRC:$RA, (sextloadi32 (Alpha_gprello tglobaladdr:$DISP, GPRC:$RB)))], s_ild>;
 423 def LDBU  : MForm<0x0A, 1, "ldbu $RA,$DISP($RB)",
 424                  [(set GPRC:$RA, (zextloadi8 (add GPRC:$RB, immSExt16:$DISP)))], s_ild>;
 425 def LDBUr : MForm<0x0A, 1, "ldbu $RA,$DISP($RB)\t\t!gprellow",
 426                  [(set GPRC:$RA, (zextloadi8 (Alpha_gprello tglobaladdr:$DISP, GPRC:$RB)))], s_ild>;
 427 def LDWU  : MForm<0x0C, 1, "ldwu $RA,$DISP($RB)",
 428                  [(set GPRC:$RA, (zextloadi16 (add GPRC:$RB, immSExt16:$DISP)))], s_ild>;
 429 def LDWUr : MForm<0x0C, 1, "ldwu $RA,$DISP($RB)\t\t!gprellow",
 430                  [(set GPRC:$RA, (zextloadi16 (Alpha_gprello tglobaladdr:$DISP, GPRC:$RB)))], s_ild>;
 431 }
 432
 433
 434 let OutOperandList = (ops), InOperandList = (ops GPRC:$RA, s64imm:$DISP, GPRC:$RB) in {
 435 def STB   : MForm<0x0E, 0, "stb $RA,$DISP($RB)",
 436                  [(truncstorei8 GPRC:$RA, (add GPRC:$RB, immSExt16:$DISP))], s_ist>;
 437 def STBr  : MForm<0x0E, 0, "stb $RA,$DISP($RB)\t\t!gprellow",
 438                  [(truncstorei8 GPRC:$RA, (Alpha_gprello tglobaladdr:$DISP, GPRC:$RB))], s_ist>;
 439 def STW   : MForm<0x0D, 0, "stw $RA,$DISP($RB)",
 440                  [(truncstorei16 GPRC:$RA, (add GPRC:$RB, immSExt16:$DISP))], s_ist>;
 441 def STWr  : MForm<0x0D, 0, "stw $RA,$DISP($RB)\t\t!gprellow",
 442                  [(truncstorei16 GPRC:$RA, (Alpha_gprello tglobaladdr:$DISP, GPRC:$RB))], s_ist>;
 443 def STL   : MForm<0x2C, 0, "stl $RA,$DISP($RB)",
 444                  [(truncstorei32 GPRC:$RA, (add GPRC:$RB, immSExt16:$DISP))], s_ist>;
 445 def STLr  : MForm<0x2C, 0, "stl $RA,$DISP($RB)\t\t!gprellow",
 446                  [(truncstorei32 GPRC:$RA, (Alpha_gprello tglobaladdr:$DISP, GPRC:$RB))], s_ist>;
 447 def STQ   : MForm<0x2D, 0, "stq $RA,$DISP($RB)",
 448                  [(store GPRC:$RA, (add GPRC:$RB, immSExt16:$DISP))], s_ist>;
 449 def STQr  : MForm<0x2D, 0, "stq $RA,$DISP($RB)\t\t!gprellow",
 450                  [(store GPRC:$RA, (Alpha_gprello tglobaladdr:$DISP, GPRC:$RB))], s_ist>;
 451 }
 452
 453 //Load address
 454 let OutOperandList = (ops GPRC:$RA), InOperandList = (ops s64imm:$DISP, GPRC:$RB) in {
 455 def LDA   : MForm<0x08, 0, "lda $RA,$DISP($RB)",
 456                  [(set GPRC:$RA, (add GPRC:$RB, immSExt16:$DISP))], s_lda>;
 457 def LDAr  : MForm<0x08, 0, "lda $RA,$DISP($RB)\t\t!gprellow",
 458                  [(set GPRC:$RA, (Alpha_gprello tglobaladdr:$DISP, GPRC:$RB))], s_lda>;  //Load address
 459 def LDAH  : MForm<0x09, 0, "ldah $RA,$DISP($RB)",
 460                  [], s_lda>;  //Load address high
 461 def LDAHr : MForm<0x09, 0, "ldah $RA,$DISP($RB)\t\t!gprelhigh",
 462                  [(set GPRC:$RA, (Alpha_gprelhi tglobaladdr:$DISP, GPRC:$RB))], s_lda>;  //Load address high
 463 }
 464
 465 let OutOperandList = (ops), InOperandList = (ops F4RC:$RA, s64imm:$DISP, GPRC:$RB) in {
 466 def STS  : MForm<0x26, 0, "sts $RA,$DISP($RB)",
 467                 [(store F4RC:$RA, (add GPRC:$RB, immSExt16:$DISP))], s_fst>;
 468 def STSr : MForm<0x26, 0, "sts $RA,$DISP($RB)\t\t!gprellow",
 469                 [(store F4RC:$RA, (Alpha_gprello tglobaladdr:$DISP, GPRC:$RB))], s_fst>;
 470 }
 471 let OutOperandList = (ops F4RC:$RA), InOperandList = (ops s64imm:$DISP, GPRC:$RB) in {
 472 def LDS  : MForm<0x22, 1, "lds $RA,$DISP($RB)",
 473                 [(set F4RC:$RA, (load (add GPRC:$RB, immSExt16:$DISP)))], s_fld>;
 474 def LDSr : MForm<0x22, 1, "lds $RA,$DISP($RB)\t\t!gprellow",
 475                 [(set F4RC:$RA, (load (Alpha_gprello tglobaladdr:$DISP, GPRC:$RB)))], s_fld>;
 476 }
 477 let OutOperandList = (ops), InOperandList = (ops F8RC:$RA, s64imm:$DISP, GPRC:$RB) in {
 478 def STT  : MForm<0x27, 0, "stt $RA,$DISP($RB)",
 479                 [(store F8RC:$RA, (add GPRC:$RB, immSExt16:$DISP))], s_fst>;
 480 def STTr : MForm<0x27, 0, "stt $RA,$DISP($RB)\t\t!gprellow",
 481                 [(store F8RC:$RA, (Alpha_gprello tglobaladdr:$DISP, GPRC:$RB))], s_fst>;
 482 }
 483 let OutOperandList = (ops F8RC:$RA), InOperandList = (ops s64imm:$DISP, GPRC:$RB) in {
 484 def LDT  : MForm<0x23, 1, "ldt $RA,$DISP($RB)",
 485                 [(set F8RC:$RA, (load (add GPRC:$RB, immSExt16:$DISP)))], s_fld>;
 486 def LDTr : MForm<0x23, 1, "ldt $RA,$DISP($RB)\t\t!gprellow",
 487                 [(set F8RC:$RA, (load (Alpha_gprello tglobaladdr:$DISP, GPRC:$RB)))], s_fld>;
 488 }
 489
 490
 491 //constpool rels
 492 def : Pat<(i64 (load (Alpha_gprello tconstpool:$DISP, GPRC:$RB))),
 493           (LDQr tconstpool:$DISP, GPRC:$RB)>;
 494 def : Pat<(i64 (sextloadi32 (Alpha_gprello tconstpool:$DISP, GPRC:$RB))),
 495           (LDLr tconstpool:$DISP, GPRC:$RB)>;
 496 def : Pat<(i64 (zextloadi8 (Alpha_gprello tconstpool:$DISP, GPRC:$RB))),
 497           (LDBUr tconstpool:$DISP, GPRC:$RB)>;
 498 def : Pat<(i64 (zextloadi16 (Alpha_gprello tconstpool:$DISP, GPRC:$RB))),
 499           (LDWUr tconstpool:$DISP, GPRC:$RB)>;
 500 def : Pat<(i64 (Alpha_gprello tconstpool:$DISP, GPRC:$RB)),
 501           (LDAr tconstpool:$DISP, GPRC:$RB)>;
 502 def : Pat<(i64 (Alpha_gprelhi tconstpool:$DISP, GPRC:$RB)),
 503           (LDAHr tconstpool:$DISP, GPRC:$RB)>;
 504 def : Pat<(f32 (load (Alpha_gprello tconstpool:$DISP, GPRC:$RB))),
 505           (LDSr tconstpool:$DISP, GPRC:$RB)>;
 506 def : Pat<(f64 (load (Alpha_gprello tconstpool:$DISP, GPRC:$RB))),
 507           (LDTr tconstpool:$DISP, GPRC:$RB)>;
 508
 509 //jumptable rels
 510 def : Pat<(i64 (Alpha_gprelhi tjumptable:$DISP, GPRC:$RB)),
 511           (LDAHr tjumptable:$DISP, GPRC:$RB)>;
 512 def : Pat<(i64 (Alpha_gprello tjumptable:$DISP, GPRC:$RB)),
 513           (LDAr tjumptable:$DISP, GPRC:$RB)>;
 514
 515
 516 //misc ext patterns
 517 def : Pat<(i64 (extloadi8 (add GPRC:$RB, immSExt16:$DISP))),
 518           (LDBU   immSExt16:$DISP, GPRC:$RB)>;
 519 def : Pat<(i64 (extloadi16 (add GPRC:$RB, immSExt16:$DISP))),
 520           (LDWU  immSExt16:$DISP, GPRC:$RB)>;
 521 def : Pat<(i64 (extloadi32 (add GPRC:$RB, immSExt16:$DISP))),
 522           (LDL   immSExt16:$DISP, GPRC:$RB)>;
 523
 524 //0 disp patterns
 525 def : Pat<(i64 (load GPRC:$addr)),
 526           (LDQ  0, GPRC:$addr)>;
 527 def : Pat<(f64 (load GPRC:$addr)),
 528           (LDT  0, GPRC:$addr)>;
 529 def : Pat<(f32 (load GPRC:$addr)),
 530           (LDS  0, GPRC:$addr)>;
 531 def : Pat<(i64 (sextloadi32 GPRC:$addr)),
 532           (LDL  0, GPRC:$addr)>;
 533 def : Pat<(i64 (zextloadi16 GPRC:$addr)),
 534           (LDWU 0, GPRC:$addr)>;
 535 def : Pat<(i64 (zextloadi8 GPRC:$addr)),
 536           (LDBU 0, GPRC:$addr)>;
 537 def : Pat<(i64 (extloadi8 GPRC:$addr)),
 538           (LDBU 0, GPRC:$addr)>;
 539 def : Pat<(i64 (extloadi16 GPRC:$addr)),
 540           (LDWU 0, GPRC:$addr)>;
 541 def : Pat<(i64 (extloadi32 GPRC:$addr)),
 542           (LDL  0, GPRC:$addr)>;
 543
 544 def : Pat<(store GPRC:$DATA, GPRC:$addr),
 545           (STQ  GPRC:$DATA, 0, GPRC:$addr)>;
 546 def : Pat<(store F8RC:$DATA, GPRC:$addr),
 547           (STT  F8RC:$DATA, 0, GPRC:$addr)>;
 548 def : Pat<(store F4RC:$DATA, GPRC:$addr),
 549           (STS  F4RC:$DATA, 0, GPRC:$addr)>;
 550 def : Pat<(truncstorei32 GPRC:$DATA, GPRC:$addr),
 551           (STL  GPRC:$DATA, 0, GPRC:$addr)>;
 552 def : Pat<(truncstorei16 GPRC:$DATA, GPRC:$addr),
 553           (STW GPRC:$DATA, 0, GPRC:$addr)>;
 554 def : Pat<(truncstorei8 GPRC:$DATA, GPRC:$addr),
 555           (STB GPRC:$DATA, 0, GPRC:$addr)>;
 556
 557
 558 //load address, rellocated gpdist form
 559 let OutOperandList = (ops GPRC:$RA), InOperandList = (ops s16imm:$DISP, GPRC:$RB, s16imm:$NUM) in {
 560 def LDAg  : MForm<0x08, 1, "lda $RA,0($RB)\t\t!gpdisp!$NUM", [], s_lda>;  //Load address
 561 def LDAHg : MForm<0x09, 1, "ldah $RA,0($RB)\t\t!gpdisp!$NUM", [], s_lda>;  //Load address
 562 }
 563
 564 //Load quad, rellocated literal form
 565 let OutOperandList = (ops GPRC:$RA), InOperandList = (ops s64imm:$DISP, GPRC:$RB) in
 566 def LDQl : MForm<0x29, 1, "ldq $RA,$DISP($RB)\t\t!literal",
 567                  [(set GPRC:$RA, (Alpha_rellit tglobaladdr:$DISP, GPRC:$RB))], s_ild>;
 568 def : Pat<(Alpha_rellit texternalsym:$ext, GPRC:$RB),
 569           (LDQl texternalsym:$ext, GPRC:$RB)>;
 570
 571
 572 def RPCC : MfcForm<0x18, 0xC000, "rpcc $RA", s_rpcc>; //Read process cycle counter
 573
 574 //Basic Floating point ops
 575
 576 //Floats
 577
 578 let OutOperandList = (ops F4RC:$RC), InOperandList = (ops F4RC:$RB), Fa = 31 in
 579 def SQRTS : FPForm<0x14, 0x58B, "sqrts/su $RB,$RC",
 580                    [(set F4RC:$RC, (fsqrt F4RC:$RB))], s_fsqrts>;
 581
 582 let OutOperandList = (ops F4RC:$RC), InOperandList = (ops F4RC:$RA, F4RC:$RB) in {
 583 def ADDS  : FPForm<0x16, 0x580, "adds/su $RA,$RB,$RC",
 584                    [(set F4RC:$RC, (fadd F4RC:$RA, F4RC:$RB))], s_fadd>;
 585 def SUBS  : FPForm<0x16, 0x581, "subs/su $RA,$RB,$RC",
 586                    [(set F4RC:$RC, (fsub F4RC:$RA, F4RC:$RB))], s_fadd>;
 587 def DIVS  : FPForm<0x16, 0x583, "divs/su $RA,$RB,$RC",
 588                    [(set F4RC:$RC, (fdiv F4RC:$RA, F4RC:$RB))], s_fdivs>;
 589 def MULS  : FPForm<0x16, 0x582, "muls/su $RA,$RB,$RC",
 590                    [(set F4RC:$RC, (fmul F4RC:$RA, F4RC:$RB))], s_fmul>;
 591
 592 def CPYSS  : FPForm<0x17, 0x020, "cpys $RA,$RB,$RC",
 593                    [(set F4RC:$RC, (fcopysign F4RC:$RB, F4RC:$RA))], s_fadd>;
 594 def CPYSES : FPForm<0x17, 0x022, "cpyse $RA,$RB,$RC",[], s_fadd>; //Copy sign and exponent
 595 def CPYSNS : FPForm<0x17, 0x021, "cpysn $RA,$RB,$RC",
 596                    [(set F4RC:$RC, (fneg (fcopysign F4RC:$RB, F4RC:$RA)))], s_fadd>;
 597 }
 598
 599 //Doubles
 600
 601 let OutOperandList = (ops F8RC:$RC), InOperandList = (ops F8RC:$RB), Fa = 31 in
 602 def SQRTT : FPForm<0x14, 0x5AB, "sqrtt/su $RB,$RC",
 603                    [(set F8RC:$RC, (fsqrt F8RC:$RB))], s_fsqrtt>;
 604
 605 let OutOperandList = (ops F8RC:$RC), InOperandList = (ops F8RC:$RA, F8RC:$RB) in {
 606 def ADDT  : FPForm<0x16, 0x5A0, "addt/su $RA,$RB,$RC",
 607                    [(set F8RC:$RC, (fadd F8RC:$RA, F8RC:$RB))], s_fadd>;
 608 def SUBT  : FPForm<0x16, 0x5A1, "subt/su $RA,$RB,$RC",
 609                    [(set F8RC:$RC, (fsub F8RC:$RA, F8RC:$RB))], s_fadd>;
 610 def DIVT  : FPForm<0x16, 0x5A3, "divt/su $RA,$RB,$RC",
 611                    [(set F8RC:$RC, (fdiv F8RC:$RA, F8RC:$RB))], s_fdivt>;
 612 def MULT  : FPForm<0x16, 0x5A2, "mult/su $RA,$RB,$RC",
 613                    [(set F8RC:$RC, (fmul F8RC:$RA, F8RC:$RB))], s_fmul>;
 614
 615 def CPYST  : FPForm<0x17, 0x020, "cpys $RA,$RB,$RC",
 616                    [(set F8RC:$RC, (fcopysign F8RC:$RB, F8RC:$RA))], s_fadd>;
 617 def CPYSET : FPForm<0x17, 0x022, "cpyse $RA,$RB,$RC",[], s_fadd>; //Copy sign and exponent
 618 def CPYSNT : FPForm<0x17, 0x021, "cpysn $RA,$RB,$RC",
 619                    [(set F8RC:$RC, (fneg (fcopysign F8RC:$RB, F8RC:$RA)))], s_fadd>;
 620
 621 def CMPTEQ : FPForm<0x16, 0x5A5, "cmpteq/su $RA,$RB,$RC", [], s_fadd>;
 622 //                    [(set F8RC:$RC, (seteq F8RC:$RA, F8RC:$RB))]>;
 623 def CMPTLE : FPForm<0x16, 0x5A7, "cmptle/su $RA,$RB,$RC", [], s_fadd>;
 624 //                    [(set F8RC:$RC, (setle F8RC:$RA, F8RC:$RB))]>;
 625 def CMPTLT : FPForm<0x16, 0x5A6, "cmptlt/su $RA,$RB,$RC", [], s_fadd>;
 626 //                    [(set F8RC:$RC, (setlt F8RC:$RA, F8RC:$RB))]>;
 627 def CMPTUN : FPForm<0x16, 0x5A4, "cmptun/su $RA,$RB,$RC", [], s_fadd>;
 628 //                    [(set F8RC:$RC, (setuo F8RC:$RA, F8RC:$RB))]>;
 629 }
 630
 631 //More CPYS forms:
 632 let OutOperandList = (ops F8RC:$RC), InOperandList = (ops F4RC:$RA, F8RC:$RB) in {
 633 def CPYSTs  : FPForm<0x17, 0x020, "cpys $RA,$RB,$RC",
 634                    [(set F8RC:$RC, (fcopysign F8RC:$RB, F4RC:$RA))], s_fadd>;
 635 def CPYSNTs : FPForm<0x17, 0x021, "cpysn $RA,$RB,$RC",
 636                    [(set F8RC:$RC, (fneg (fcopysign F8RC:$RB, F4RC:$RA)))], s_fadd>;
 637 }
 638 let OutOperandList = (ops F4RC:$RC), InOperandList = (ops F8RC:$RA, F4RC:$RB) in {
 639 def CPYSSt  : FPForm<0x17, 0x020, "cpys $RA,$RB,$RC",
 640                    [(set F4RC:$RC, (fcopysign F4RC:$RB, F8RC:$RA))], s_fadd>;
 641 def CPYSESt : FPForm<0x17, 0x022, "cpyse $RA,$RB,$RC",[], s_fadd>; //Copy sign and exponent
 642 def CPYSNSt : FPForm<0x17, 0x021, "cpysn $RA,$RB,$RC",
 643                    [(set F4RC:$RC, (fneg (fcopysign F4RC:$RB, F8RC:$RA)))], s_fadd>;
 644 }
 645
 646 //conditional moves, floats
 647 let OutOperandList = (ops F4RC:$RDEST), InOperandList = (ops F4RC:$RFALSE, F4RC:$RTRUE, F8RC:$RCOND),
 648     isTwoAddress = 1 in {
 649 def FCMOVEQS : FPForm<0x17, 0x02A, "fcmoveq $RCOND,$RTRUE,$RDEST",[], s_fcmov>; //FCMOVE if = zero
 650 def FCMOVGES : FPForm<0x17, 0x02D, "fcmovge $RCOND,$RTRUE,$RDEST",[], s_fcmov>; //FCMOVE if >= zero
 651 def FCMOVGTS : FPForm<0x17, 0x02F, "fcmovgt $RCOND,$RTRUE,$RDEST",[], s_fcmov>; //FCMOVE if > zero
 652 def FCMOVLES : FPForm<0x17, 0x02E, "fcmovle $RCOND,$RTRUE,$RDEST",[], s_fcmov>; //FCMOVE if <= zero
 653 def FCMOVLTS : FPForm<0x17, 0x02C, "fcmovlt $RCOND,$RTRUE,$RDEST",[], s_fcmov>; // FCMOVE if < zero
 654 def FCMOVNES : FPForm<0x17, 0x02B, "fcmovne $RCOND,$RTRUE,$RDEST",[], s_fcmov>; //FCMOVE if != zero
 655 }
 656 //conditional moves, doubles
 657 let OutOperandList = (ops F8RC:$RDEST), InOperandList = (ops F8RC:$RFALSE, F8RC:$RTRUE, F8RC:$RCOND),
 658     isTwoAddress = 1 in {
 659 def FCMOVEQT : FPForm<0x17, 0x02A, "fcmoveq $RCOND,$RTRUE,$RDEST", [], s_fcmov>;
 660 def FCMOVGET : FPForm<0x17, 0x02D, "fcmovge $RCOND,$RTRUE,$RDEST", [], s_fcmov>;
 661 def FCMOVGTT : FPForm<0x17, 0x02F, "fcmovgt $RCOND,$RTRUE,$RDEST", [], s_fcmov>;
 662 def FCMOVLET : FPForm<0x17, 0x02E, "fcmovle $RCOND,$RTRUE,$RDEST", [], s_fcmov>;
 663 def FCMOVLTT : FPForm<0x17, 0x02C, "fcmovlt $RCOND,$RTRUE,$RDEST", [], s_fcmov>;
 664 def FCMOVNET : FPForm<0x17, 0x02B, "fcmovne $RCOND,$RTRUE,$RDEST", [], s_fcmov>;
 665 }
 666
 667 //misc FP selects
 668 //Select double
 669
 670 def : Pat<(select (seteq F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 671       (FCMOVNET F8RC:$sf, F8RC:$st, (CMPTEQ F8RC:$RA, F8RC:$RB))>;
 672 def : Pat<(select (setoeq F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 673       (FCMOVNET F8RC:$sf, F8RC:$st, (CMPTEQ F8RC:$RA, F8RC:$RB))>;
 674 def : Pat<(select (setueq F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 675       (FCMOVNET F8RC:$sf, F8RC:$st, (CMPTEQ F8RC:$RA, F8RC:$RB))>;
 676
 677 def : Pat<(select (setne F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 678       (FCMOVEQT F8RC:$sf, F8RC:$st, (CMPTEQ F8RC:$RA, F8RC:$RB))>;
 679 def : Pat<(select (setone F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 680       (FCMOVEQT F8RC:$sf, F8RC:$st, (CMPTEQ F8RC:$RA, F8RC:$RB))>;
 681 def : Pat<(select (setune F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 682       (FCMOVEQT F8RC:$sf, F8RC:$st, (CMPTEQ F8RC:$RA, F8RC:$RB))>;
 683
 684 def : Pat<(select (setgt F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 685       (FCMOVNET F8RC:$sf, F8RC:$st, (CMPTLT F8RC:$RB, F8RC:$RA))>;
 686 def : Pat<(select (setogt F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 687       (FCMOVNET F8RC:$sf, F8RC:$st, (CMPTLT F8RC:$RB, F8RC:$RA))>;
 688 def : Pat<(select (setugt F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 689       (FCMOVNET F8RC:$sf, F8RC:$st, (CMPTLT F8RC:$RB, F8RC:$RA))>;
 690
 691 def : Pat<(select (setge F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 692       (FCMOVNET F8RC:$sf, F8RC:$st, (CMPTLE F8RC:$RB, F8RC:$RA))>;
 693 def : Pat<(select (setoge F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 694       (FCMOVNET F8RC:$sf, F8RC:$st, (CMPTLE F8RC:$RB, F8RC:$RA))>;
 695 def : Pat<(select (setuge F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 696       (FCMOVNET F8RC:$sf, F8RC:$st, (CMPTLE F8RC:$RB, F8RC:$RA))>;
 697
 698 def : Pat<(select (setlt F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 699       (FCMOVNET F8RC:$sf, F8RC:$st, (CMPTLT F8RC:$RA, F8RC:$RB))>;
 700 def : Pat<(select (setolt F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 701       (FCMOVNET F8RC:$sf, F8RC:$st, (CMPTLT F8RC:$RA, F8RC:$RB))>;
 702 def : Pat<(select (setult F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 703       (FCMOVNET F8RC:$sf, F8RC:$st, (CMPTLT F8RC:$RA, F8RC:$RB))>;
 704
 705 def : Pat<(select (setle F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 706       (FCMOVNET F8RC:$sf, F8RC:$st, (CMPTLE F8RC:$RA, F8RC:$RB))>;
 707 def : Pat<(select (setole F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 708       (FCMOVNET F8RC:$sf, F8RC:$st, (CMPTLE F8RC:$RA, F8RC:$RB))>;
 709 def : Pat<(select (setule F8RC:$RA, F8RC:$RB), F8RC:$st, F8RC:$sf),
 710       (FCMOVNET F8RC:$sf, F8RC:$st, (CMPTLE F8RC:$RA, F8RC:$RB))>;
 711
 712 //Select single
 713 def : Pat<(select (seteq F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 714       (FCMOVNES F4RC:$sf, F4RC:$st, (CMPTEQ F8RC:$RA, F8RC:$RB))>;
 715 def : Pat<(select (setoeq F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 716       (FCMOVNES F4RC:$sf, F4RC:$st, (CMPTEQ F8RC:$RA, F8RC:$RB))>;
 717 def : Pat<(select (setueq F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 718       (FCMOVNES F4RC:$sf, F4RC:$st, (CMPTEQ F8RC:$RA, F8RC:$RB))>;
 719
 720 def : Pat<(select (setne F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 721       (FCMOVEQS F4RC:$sf, F4RC:$st, (CMPTEQ F8RC:$RA, F8RC:$RB))>;
 722 def : Pat<(select (setone F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 723       (FCMOVEQS F4RC:$sf, F4RC:$st, (CMPTEQ F8RC:$RA, F8RC:$RB))>;
 724 def : Pat<(select (setune F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 725       (FCMOVEQS F4RC:$sf, F4RC:$st, (CMPTEQ F8RC:$RA, F8RC:$RB))>;
 726
 727 def : Pat<(select (setgt F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 728       (FCMOVNES F4RC:$sf, F4RC:$st, (CMPTLT F8RC:$RB, F8RC:$RA))>;
 729 def : Pat<(select (setogt F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 730       (FCMOVNES F4RC:$sf, F4RC:$st, (CMPTLT F8RC:$RB, F8RC:$RA))>;
 731 def : Pat<(select (setugt F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 732       (FCMOVNES F4RC:$sf, F4RC:$st, (CMPTLT F8RC:$RB, F8RC:$RA))>;
 733
 734 def : Pat<(select (setge F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 735       (FCMOVNES F4RC:$sf, F4RC:$st, (CMPTLE F8RC:$RB, F8RC:$RA))>;
 736 def : Pat<(select (setoge F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 737       (FCMOVNES F4RC:$sf, F4RC:$st, (CMPTLE F8RC:$RB, F8RC:$RA))>;
 738 def : Pat<(select (setuge F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 739       (FCMOVNES F4RC:$sf, F4RC:$st, (CMPTLE F8RC:$RB, F8RC:$RA))>;
 740
 741 def : Pat<(select (setlt F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 742       (FCMOVNES F4RC:$sf, F4RC:$st, (CMPTLT F8RC:$RA, F8RC:$RB))>;
 743 def : Pat<(select (setolt F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 744       (FCMOVNES F4RC:$sf, F4RC:$st, (CMPTLT F8RC:$RA, F8RC:$RB))>;
 745 def : Pat<(select (setult F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 746       (FCMOVNES F4RC:$sf, F4RC:$st, (CMPTLT F8RC:$RA, F8RC:$RB))>;
 747
 748 def : Pat<(select (setle F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 749       (FCMOVNES F4RC:$sf, F4RC:$st, (CMPTLE F8RC:$RA, F8RC:$RB))>;
 750 def : Pat<(select (setole F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 751       (FCMOVNES F4RC:$sf, F4RC:$st, (CMPTLE F8RC:$RA, F8RC:$RB))>;
 752 def : Pat<(select (setule F8RC:$RA, F8RC:$RB), F4RC:$st, F4RC:$sf),
 753       (FCMOVNES F4RC:$sf, F4RC:$st, (CMPTLE F8RC:$RA, F8RC:$RB))>;
 754
 755
 756
 757 let OutOperandList = (ops GPRC:$RC), InOperandList = (ops F4RC:$RA), Fb = 31 in
 758 def FTOIS : FPForm<0x1C, 0x078, "ftois $RA,$RC",[], s_ftoi>; //Floating to integer move, S_floating
 759 let OutOperandList = (ops GPRC:$RC), InOperandList = (ops F8RC:$RA), Fb = 31 in
 760 def FTOIT : FPForm<0x1C, 0x070, "ftoit $RA,$RC",
 761         [(set GPRC:$RC, (bitconvert F8RC:$RA))], s_ftoi>; //Floating to integer move
 762 let OutOperandList = (ops F4RC:$RC), InOperandList = (ops GPRC:$RA), Fb = 31 in
 763 def ITOFS : FPForm<0x14, 0x004, "itofs $RA,$RC",[], s_itof>; //Integer to floating move, S_floating
 764 let OutOperandList = (ops F8RC:$RC), InOperandList = (ops GPRC:$RA), Fb = 31 in
 765 def ITOFT : FPForm<0x14, 0x024, "itoft $RA,$RC",
 766         [(set F8RC:$RC, (bitconvert GPRC:$RA))], s_itof>; //Integer to floating move
 767
 768
 769 let OutOperandList = (ops F4RC:$RC), InOperandList = (ops F8RC:$RB), Fa = 31 in
 770 def CVTQS : FPForm<0x16, 0x7BC, "cvtqs/sui $RB,$RC",
 771         [(set F4RC:$RC, (Alpha_cvtqs F8RC:$RB))], s_fadd>;
 772 let OutOperandList = (ops F8RC:$RC), InOperandList = (ops F8RC:$RB), Fa = 31 in
 773 def CVTQT : FPForm<0x16, 0x7BE, "cvtqt/sui $RB,$RC",
 774         [(set F8RC:$RC, (Alpha_cvtqt F8RC:$RB))], s_fadd>;
 775 let OutOperandList = (ops F8RC:$RC), InOperandList = (ops F8RC:$RB), Fa = 31 in
 776 def CVTTQ : FPForm<0x16, 0x52F, "cvttq/svc $RB,$RC",
 777         [(set F8RC:$RC, (Alpha_cvttq F8RC:$RB))], s_fadd>;
 778 let OutOperandList = (ops F8RC:$RC), InOperandList = (ops F4RC:$RB), Fa = 31 in
 779 def CVTST : FPForm<0x16, 0x6AC, "cvtst/s $RB,$RC",
 780                    [(set F8RC:$RC, (fextend F4RC:$RB))], s_fadd>;
 781 let OutOperandList = (ops F4RC:$RC), InOperandList = (ops F8RC:$RB), Fa = 31 in
 782 def CVTTS : FPForm<0x16, 0x7AC, "cvtts/sui $RB,$RC",
 783                    [(set F4RC:$RC, (fround F8RC:$RB))], s_fadd>;
 784
 785
 786 /////////////////////////////////////////////////////////
 787 //Branching
 788 /////////////////////////////////////////////////////////
 789 class br_icc<bits<6> opc, string asmstr>
 790   : BFormN<opc, (ops u64imm:$opc, GPRC:$R, target:$dst),
 791     !strconcat(asmstr, " $R,$dst"),  s_icbr>;
 792 class br_fcc<bits<6> opc, string asmstr>
 793   : BFormN<opc, (ops u64imm:$opc, F8RC:$R, target:$dst),
 794     !strconcat(asmstr, " $R,$dst"),  s_fbr>;
 795
 796 let isBranch = 1, isTerminator = 1, hasCtrlDep = 1 in {
 797 let Ra = 31 in
 798 def BR : BFormD<0x30, "br $$31,$DISP", [(br bb:$DISP)], s_ubr>;
 799
 800 def COND_BRANCH_I : BFormN<0, (ops u64imm:$opc, GPRC:$R, target:$dst),
 801                     "{:comment} COND_BRANCH imm:$opc, GPRC:$R, bb:$dst",
 802                     s_icbr>;
 803 def COND_BRANCH_F : BFormN<0, (ops u64imm:$opc, F8RC:$R, target:$dst),
 804                     "{:comment} COND_BRANCH imm:$opc, F8RC:$R, bb:$dst",
 805                     s_fbr>;
 806 //Branches, int
 807 def BEQ  : br_icc<0x39, "beq">;
 808 def BGE  : br_icc<0x3E, "bge">;
 809 def BGT  : br_icc<0x3F, "bgt">;
 810 def BLBC : br_icc<0x38, "blbc">;
 811 def BLBS : br_icc<0x3C, "blbs">;
 812 def BLE  : br_icc<0x3B, "ble">;
 813 def BLT  : br_icc<0x3A, "blt">;
 814 def BNE  : br_icc<0x3D, "bne">;
 815
 816 //Branches, float
 817 def FBEQ : br_fcc<0x31, "fbeq">;
 818 def FBGE : br_fcc<0x36, "fbge">;
 819 def FBGT : br_fcc<0x37, "fbgt">;
 820 def FBLE : br_fcc<0x33, "fble">;
 821 def FBLT : br_fcc<0x32, "fblt">;
 822 def FBNE : br_fcc<0x36, "fbne">;
 823 }
 824
 825 //An ugly trick to get the opcode as an imm I can use
 826 def immBRCond : SDNodeXForm<imm, [{
 827   switch((uint64_t)N->getValue()) {
 828     case 0:  return getI64Imm(Alpha::BEQ);
 829     case 1:  return getI64Imm(Alpha::BNE);
 830     case 2:  return getI64Imm(Alpha::BGE);
 831     case 3:  return getI64Imm(Alpha::BGT);
 832     case 4:  return getI64Imm(Alpha::BLE);
 833     case 5:  return getI64Imm(Alpha::BLT);
 834     case 6:  return getI64Imm(Alpha::BLBS);
 835     case 7:  return getI64Imm(Alpha::BLBC);
 836     case 20: return getI64Imm(Alpha::FBEQ);
 837     case 21: return getI64Imm(Alpha::FBNE);
 838     case 22: return getI64Imm(Alpha::FBGE);
 839     case 23: return getI64Imm(Alpha::FBGT);
 840     case 24: return getI64Imm(Alpha::FBLE);
 841     case 25: return getI64Imm(Alpha::FBLT);
 842     default: assert(0 && "Unknown branch type");
 843   }
 844 }]>;
 845
 846 //Int cond patterns
 847 def : Pat<(brcond (seteq GPRC:$RA, 0), bb:$DISP),
 848       (COND_BRANCH_I (immBRCond 0),  GPRC:$RA, bb:$DISP)>;
 849 def : Pat<(brcond (setge GPRC:$RA, 0), bb:$DISP),
 850       (COND_BRANCH_I (immBRCond 2),  GPRC:$RA, bb:$DISP)>;
 851 def : Pat<(brcond (setgt GPRC:$RA, 0), bb:$DISP),
 852       (COND_BRANCH_I (immBRCond 3),  GPRC:$RA, bb:$DISP)>;
 853 def : Pat<(brcond (and   GPRC:$RA, 1), bb:$DISP),
 854       (COND_BRANCH_I (immBRCond 6),  GPRC:$RA, bb:$DISP)>;
 855 def : Pat<(brcond (setle GPRC:$RA, 0), bb:$DISP),
 856       (COND_BRANCH_I (immBRCond 4),  GPRC:$RA, bb:$DISP)>;
 857 def : Pat<(brcond (setlt GPRC:$RA, 0), bb:$DISP),
 858       (COND_BRANCH_I (immBRCond 5),  GPRC:$RA, bb:$DISP)>;
 859 def : Pat<(brcond (setne GPRC:$RA, 0), bb:$DISP),
 860       (COND_BRANCH_I (immBRCond 1),  GPRC:$RA, bb:$DISP)>;
 861
 862 def : Pat<(brcond GPRC:$RA, bb:$DISP),
 863       (COND_BRANCH_I (immBRCond 1), GPRC:$RA, bb:$DISP)>;
 864 def : Pat<(brcond (setne GPRC:$RA, GPRC:$RB), bb:$DISP),
 865       (COND_BRANCH_I (immBRCond 0), (CMPEQ GPRC:$RA, GPRC:$RB), bb:$DISP)>;
 866 def : Pat<(brcond (setne GPRC:$RA, immUExt8:$L), bb:$DISP),
 867       (COND_BRANCH_I (immBRCond 0), (CMPEQi GPRC:$RA, immUExt8:$L), bb:$DISP)>;
 868
 869 //FP cond patterns
 870 def : Pat<(brcond (seteq F8RC:$RA, immFPZ), bb:$DISP),
 871       (COND_BRANCH_F (immBRCond 20),  F8RC:$RA, bb:$DISP)>;
 872 def : Pat<(brcond (setne F8RC:$RA, immFPZ), bb:$DISP),
 873       (COND_BRANCH_F (immBRCond 21),  F8RC:$RA, bb:$DISP)>;
 874 def : Pat<(brcond (setge F8RC:$RA, immFPZ), bb:$DISP),
 875       (COND_BRANCH_F (immBRCond 22),  F8RC:$RA, bb:$DISP)>;
 876 def : Pat<(brcond (setgt F8RC:$RA, immFPZ), bb:$DISP),
 877       (COND_BRANCH_F (immBRCond 23),  F8RC:$RA, bb:$DISP)>;
 878 def : Pat<(brcond (setle F8RC:$RA, immFPZ), bb:$DISP),
 879       (COND_BRANCH_F (immBRCond 24),  F8RC:$RA, bb:$DISP)>;
 880 def : Pat<(brcond (setlt F8RC:$RA, immFPZ), bb:$DISP),
 881       (COND_BRANCH_F (immBRCond 25),  F8RC:$RA, bb:$DISP)>;
 882
 883
 884 def : Pat<(brcond (seteq F8RC:$RA, F8RC:$RB), bb:$DISP),
 885       (COND_BRANCH_F (immBRCond 21), (CMPTEQ F8RC:$RA, F8RC:$RB), bb:$DISP)>;
 886 def : Pat<(brcond (setoeq F8RC:$RA, F8RC:$RB), bb:$DISP),
 887       (COND_BRANCH_F (immBRCond 21), (CMPTEQ F8RC:$RA, F8RC:$RB), bb:$DISP)>;
 888 def : Pat<(brcond (setueq F8RC:$RA, F8RC:$RB), bb:$DISP),
 889       (COND_BRANCH_F (immBRCond 21), (CMPTEQ F8RC:$RA, F8RC:$RB), bb:$DISP)>;
 890
 891 def : Pat<(brcond (setlt F8RC:$RA, F8RC:$RB), bb:$DISP),
 892       (COND_BRANCH_F (immBRCond 21), (CMPTLT F8RC:$RA, F8RC:$RB), bb:$DISP)>;
 893 def : Pat<(brcond (setolt F8RC:$RA, F8RC:$RB), bb:$DISP),
 894       (COND_BRANCH_F (immBRCond 21), (CMPTLT F8RC:$RA, F8RC:$RB), bb:$DISP)>;
 895 def : Pat<(brcond (setult F8RC:$RA, F8RC:$RB), bb:$DISP),
 896       (COND_BRANCH_F (immBRCond 21), (CMPTLT F8RC:$RA, F8RC:$RB), bb:$DISP)>;
 897
 898 def : Pat<(brcond (setle F8RC:$RA, F8RC:$RB), bb:$DISP),
 899       (COND_BRANCH_F (immBRCond 21), (CMPTLE F8RC:$RA, F8RC:$RB), bb:$DISP)>;
 900 def : Pat<(brcond (setole F8RC:$RA, F8RC:$RB), bb:$DISP),
 901       (COND_BRANCH_F (immBRCond 21), (CMPTLE F8RC:$RA, F8RC:$RB), bb:$DISP)>;
 902 def : Pat<(brcond (setule F8RC:$RA, F8RC:$RB), bb:$DISP),
 903       (COND_BRANCH_F (immBRCond 21), (CMPTLE F8RC:$RA, F8RC:$RB), bb:$DISP)>;
 904
 905 def : Pat<(brcond (setgt F8RC:$RA, F8RC:$RB), bb:$DISP),
 906       (COND_BRANCH_F (immBRCond 21), (CMPTLT F8RC:$RB, F8RC:$RA), bb:$DISP)>;
 907 def : Pat<(brcond (setogt F8RC:$RA, F8RC:$RB), bb:$DISP),
 908       (COND_BRANCH_F (immBRCond 21), (CMPTLT F8RC:$RB, F8RC:$RA), bb:$DISP)>;
 909 def : Pat<(brcond (setugt F8RC:$RA, F8RC:$RB), bb:$DISP),
 910       (COND_BRANCH_F (immBRCond 21), (CMPTLT F8RC:$RB, F8RC:$RA), bb:$DISP)>;
 911
 912 def : Pat<(brcond (setge F8RC:$RA, F8RC:$RB), bb:$DISP),
 913       (COND_BRANCH_F (immBRCond 21), (CMPTLE F8RC:$RB, F8RC:$RA), bb:$DISP)>;
 914 def : Pat<(brcond (setoge F8RC:$RA, F8RC:$RB), bb:$DISP),
 915       (COND_BRANCH_F (immBRCond 21), (CMPTLE F8RC:$RB, F8RC:$RA), bb:$DISP)>;
 916 def : Pat<(brcond (setuge F8RC:$RA, F8RC:$RB), bb:$DISP),
 917       (COND_BRANCH_F (immBRCond 21), (CMPTLE F8RC:$RB, F8RC:$RA), bb:$DISP)>;
 918
 919 def : Pat<(brcond (setne F8RC:$RA, F8RC:$RB), bb:$DISP),
 920       (COND_BRANCH_F (immBRCond 20), (CMPTEQ F8RC:$RA, F8RC:$RB), bb:$DISP)>;
 921 def : Pat<(brcond (setone F8RC:$RA, F8RC:$RB), bb:$DISP),
 922       (COND_BRANCH_F (immBRCond 20), (CMPTEQ F8RC:$RA, F8RC:$RB), bb:$DISP)>;
 923 def : Pat<(brcond (setune F8RC:$RA, F8RC:$RB), bb:$DISP),
 924       (COND_BRANCH_F (immBRCond 20), (CMPTEQ F8RC:$RA, F8RC:$RB), bb:$DISP)>;
 925
 926
 927 def : Pat<(brcond (setoeq F8RC:$RA, immFPZ), bb:$DISP),
 928       (COND_BRANCH_F (immBRCond 20), F8RC:$RA,bb:$DISP)>;
 929 def : Pat<(brcond (setueq F8RC:$RA, immFPZ), bb:$DISP),
 930       (COND_BRANCH_F (immBRCond 20), F8RC:$RA,bb:$DISP)>;
 931
 932 def : Pat<(brcond (setoge F8RC:$RA, immFPZ), bb:$DISP),
 933       (COND_BRANCH_F (immBRCond 22), F8RC:$RA,bb:$DISP)>;
 934 def : Pat<(brcond (setuge F8RC:$RA, immFPZ), bb:$DISP),
 935       (COND_BRANCH_F (immBRCond 22), F8RC:$RA,bb:$DISP)>;
 936
 937 def : Pat<(brcond (setogt F8RC:$RA, immFPZ), bb:$DISP),
 938       (COND_BRANCH_F (immBRCond 23), F8RC:$RA,bb:$DISP)>;
 939 def : Pat<(brcond (setugt F8RC:$RA, immFPZ), bb:$DISP),
 940       (COND_BRANCH_F (immBRCond 23), F8RC:$RA,bb:$DISP)>;
 941
 942 def : Pat<(brcond (setole F8RC:$RA, immFPZ), bb:$DISP),
 943       (COND_BRANCH_F (immBRCond 24), F8RC:$RA,bb:$DISP)>;
 944 def : Pat<(brcond (setule F8RC:$RA, immFPZ), bb:$DISP),
 945       (COND_BRANCH_F (immBRCond 24), F8RC:$RA,bb:$DISP)>;
 946
 947 def : Pat<(brcond (setolt F8RC:$RA, immFPZ), bb:$DISP),
 948       (COND_BRANCH_F (immBRCond 25), F8RC:$RA,bb:$DISP)>;
 949 def : Pat<(brcond (setult F8RC:$RA, immFPZ), bb:$DISP),
 950       (COND_BRANCH_F (immBRCond 25), F8RC:$RA,bb:$DISP)>;
 951
 952 def : Pat<(brcond (setone F8RC:$RA, immFPZ), bb:$DISP),
 953       (COND_BRANCH_F (immBRCond 21), F8RC:$RA,bb:$DISP)>;
 954 def : Pat<(brcond (setune F8RC:$RA, immFPZ), bb:$DISP),
 955       (COND_BRANCH_F (immBRCond 21), F8RC:$RA,bb:$DISP)>;
 956
 957 //End Branches
 958
 959 //S_floating : IEEE Single
 960 //T_floating : IEEE Double
 961
 962 //Unused instructions
 963 //Mnemonic Format Opcode Description
 964 //CALL_PAL Pcd 00 Trap to PALcode
 965 //ECB Mfc 18.E800 Evict cache block
 966 //EXCB Mfc 18.0400 Exception barrier
 967 //FETCH Mfc 18.8000 Prefetch data
 968 //FETCH_M Mfc 18.A000 Prefetch data, modify intent
 969 //LDL_L Mem 2A Load sign-extended longword locked
 970 //LDQ_L Mem 2B Load quadword locked
 971 //LDQ_U Mem 0B Load unaligned quadword
 972 //MB Mfc 18.4000 Memory barrier
 973 //STL_C Mem 2E Store longword conditional
 974 //STQ_C Mem 2F Store quadword conditional
 975 //STQ_U Mem 0F Store unaligned quadword
 976 //TRAPB Mfc 18.0000 Trap barrier
 977 //WH64 Mfc 18.F800 Write hint \14 64 bytes
 978 //WMB Mfc 18.4400 Write memory barrier
 979 //MF_FPCR F-P 17.025 Move from FPCR
 980 //MT_FPCR F-P 17.024 Move to FPCR
 981 //There are in the Multimedia extentions, so let's not use them yet
 982 //def MAXSB8  : OForm<0x1C, 0x3E, "MAXSB8 $RA,$RB,$RC">; //Vector signed byte maximum
 983 //def MAXSW4 : OForm< 0x1C, 0x3F, "MAXSW4 $RA,$RB,$RC">; //Vector signed word maximum
 984 //def MAXUB8  : OForm<0x1C, 0x3C, "MAXUB8 $RA,$RB,$RC">; //Vector unsigned byte maximum
 985 //def MAXUW4 : OForm< 0x1C, 0x3D, "MAXUW4 $RA,$RB,$RC">; //Vector unsigned word maximum
 986 //def MINSB8 : OForm< 0x1C, 0x38, "MINSB8 $RA,$RB,$RC">; //Vector signed byte minimum
 987 //def MINSW4 : OForm< 0x1C, 0x39, "MINSW4 $RA,$RB,$RC">; //Vector signed word minimum
 988 //def MINUB8 : OForm< 0x1C, 0x3A, "MINUB8 $RA,$RB,$RC">; //Vector unsigned byte minimum
 989 //def MINUW4 : OForm< 0x1C, 0x3B, "MINUW4 $RA,$RB,$RC">; //Vector unsigned word minimum
 990 //def PERR : OForm< 0x1C, 0x31, "PERR $RA,$RB,$RC">; //Pixel error
 991 //def PKLB : OForm< 0x1C, 0x37, "PKLB $RA,$RB,$RC">; //Pack longwords to bytes
 992 //def PKWB  : OForm<0x1C, 0x36, "PKWB $RA,$RB,$RC">; //Pack words to bytes
 993 //def UNPKBL : OForm< 0x1C, 0x35, "UNPKBL $RA,$RB,$RC">; //Unpack bytes to longwords
 994 //def UNPKBW : OForm< 0x1C, 0x34, "UNPKBW $RA,$RB,$RC">; //Unpack bytes to words
 995 //CVTLQ F-P 17.010 Convert longword to quadword
 996 //CVTQL F-P 17.030 Convert quadword to longword
 997
 998
 999 //Constant handling
1000
1001 def immConst2Part  : PatLeaf<(imm), [{
1002   //true if imm fits in a LDAH LDA pair
1003   int64_t val = (int64_t)N->getValue();
1004   return (val <= IMM_FULLHIGH  && val >= IMM_FULLLOW);
1005 }]>;
1006 def immConst2PartInt  : PatLeaf<(imm), [{
1007   //true if imm fits in a LDAH LDA pair with zeroext
1008   uint64_t uval = N->getValue();
1009   int32_t val32 = (int32_t)uval;
1010   return ((uval >> 32) == 0 && //empty upper bits
1011           val32 <= IMM_FULLHIGH);
1012 //          val32 >= IMM_FULLLOW  + IMM_LOW  * IMM_MULT); //Always True
1013 }], SExt32>;
1014
1015 def : Pat<(i64 immConst2Part:$imm),
1016           (LDA (LL16 immConst2Part:$imm), (LDAH (LH16 immConst2Part:$imm), R31))>;
1017
1018 def : Pat<(i64 immSExt16:$imm),
1019           (LDA immSExt16:$imm, R31)>;
1020
1021 def : Pat<(i64 immSExt16int:$imm),
1022           (ZAPNOTi (LDA (SExt16 immSExt16int:$imm), R31), 15)>;
1023 def : Pat<(i64 immConst2PartInt:$imm),
1024           (ZAPNOTi (LDA (LL16 (SExt32 immConst2PartInt:$imm)),
1025                         (LDAH (LH16 (SExt32 immConst2PartInt:$imm)), R31)), 15)>;
1026
1027
1028 //TODO: I want to just define these like this!
1029 //def : Pat<(i64 0),
1030 //          (R31)>;
1031 //def : Pat<(f64 0.0),
1032 //          (F31)>;
1033 //def : Pat<(f64 -0.0),
1034 //          (CPYSNT F31, F31)>;
1035 //def : Pat<(f32 0.0),
1036 //          (F31)>;
1037 //def : Pat<(f32 -0.0),
1038 //          (CPYSNS F31, F31)>;
1039
1040 //Misc Patterns:
1041
1042 def : Pat<(sext_inreg GPRC:$RB, i32),
1043           (ADDLi GPRC:$RB, 0)>;
1044
1045 def : Pat<(fabs F8RC:$RB),
1046           (CPYST F31, F8RC:$RB)>;
1047 def : Pat<(fabs F4RC:$RB),
1048           (CPYSS F31, F4RC:$RB)>;
1049 def : Pat<(fneg F8RC:$RB),
1050           (CPYSNT F8RC:$RB, F8RC:$RB)>;
1051 def : Pat<(fneg F4RC:$RB),
1052           (CPYSNS F4RC:$RB, F4RC:$RB)>;
1053
1054 def : Pat<(fcopysign F4RC:$A, (fneg F4RC:$B)),
1055           (CPYSNS F4RC:$B, F4RC:$A)>;
1056 def : Pat<(fcopysign F8RC:$A, (fneg F8RC:$B)),
1057           (CPYSNT F8RC:$B, F8RC:$A)>;
1058 def : Pat<(fcopysign F4RC:$A, (fneg F8RC:$B)),
1059           (CPYSNSt F8RC:$B, F4RC:$A)>;
1060 def : Pat<(fcopysign F8RC:$A, (fneg F4RC:$B)),
1061           (CPYSNTs F4RC:$B, F8RC:$A)>;
1062
1063 //Yes, signed multiply high is ugly
1064 def : Pat<(mulhs GPRC:$RA, GPRC:$RB),
1065           (SUBQr (UMULHr GPRC:$RA, GPRC:$RB), (ADDQr (CMOVGEr GPRC:$RB, R31, GPRC:$RA),
1066                                                      (CMOVGEr GPRC:$RA, R31, GPRC:$RB)))>;
1067
1068 //Stupid crazy arithmetic stuff:
1069 let AddedComplexity = 1 in {
1070 def : Pat<(mul GPRC:$RA, 5), (S4ADDQr GPRC:$RA, GPRC:$RA)>;
1071 def : Pat<(mul GPRC:$RA, 9), (S8ADDQr GPRC:$RA, GPRC:$RA)>;
1072 def : Pat<(mul GPRC:$RA, 3), (S4SUBQr GPRC:$RA, GPRC:$RA)>;
1073 def : Pat<(mul GPRC:$RA, 7), (S8SUBQr GPRC:$RA, GPRC:$RA)>;
1074
1075 //slight tree expansion if we are multiplying near to a power of 2
1076 //n is above a power of 2
1077 def : Pat<(mul GPRC:$RA, immRem1:$imm),
1078           (ADDQr (SLr GPRC:$RA, (nearP2X immRem1:$imm)), GPRC:$RA)>;
1079 def : Pat<(mul GPRC:$RA, immRem2:$imm),
1080           (ADDQr (SLr GPRC:$RA, (nearP2X immRem2:$imm)), (ADDQr GPRC:$RA, GPRC:$RA))>;
1081 def : Pat<(mul GPRC:$RA, immRem3:$imm),
1082           (ADDQr (SLr GPRC:$RA, (nearP2X immRem3:$imm)), (S4SUBQr GPRC:$RA, GPRC:$RA))>;
1083 def : Pat<(mul GPRC:$RA, immRem4:$imm),
1084           (S4ADDQr GPRC:$RA, (SLr GPRC:$RA, (nearP2X immRem4:$imm)))>;
1085 def : Pat<(mul GPRC:$RA, immRem5:$imm),
1086           (ADDQr (SLr GPRC:$RA, (nearP2X immRem5:$imm)), (S4ADDQr GPRC:$RA, GPRC:$RA))>;
1087 def : Pat<(mul GPRC:$RA, immRemP2:$imm),
1088           (ADDQr (SLr GPRC:$RA, (nearP2X immRemP2:$imm)), (SLi GPRC:$RA, (nearP2RemX immRemP2:$imm)))>;
1089
1090 //n is below a power of 2
1091 //FIXME: figure out why something is truncating the imm to 32bits
1092 // this will fix 2007-11-27-mulneg3
1093 //def : Pat<(mul GPRC:$RA, immRem1n:$imm),
1094 //          (SUBQr (SLr GPRC:$RA, (nearP2X immRem1n:$imm)), GPRC:$RA)>;
1095 //def : Pat<(mul GPRC:$RA, immRem2n:$imm),
1096 //          (SUBQr (SLr GPRC:$RA, (nearP2X immRem2n:$imm)), (ADDQr GPRC:$RA, GPRC:$RA))>;
1097 //def : Pat<(mul GPRC:$RA, immRem3n:$imm),
1098 //          (SUBQr (SLr GPRC:$RA, (nearP2X immRem3n:$imm)), (S4SUBQr GPRC:$RA, GPRC:$RA))>;
1099 //def : Pat<(mul GPRC:$RA, immRem4n:$imm),
1100 //          (SUBQr (SLr GPRC:$RA, (nearP2X immRem4n:$imm)), (SLi GPRC:$RA, 2))>;
1101 //def : Pat<(mul GPRC:$RA, immRem5n:$imm),
1102 //          (SUBQr (SLr GPRC:$RA, (nearP2X immRem5n:$imm)), (S4ADDQr GPRC:$RA, GPRC:$RA))>;
1103 //def : Pat<(mul GPRC:$RA, immRemP2n:$imm),
1104 //          (SUBQr (SLr GPRC:$RA, (nearP2X immRemP2n:$imm)), (SLi GPRC:$RA, (nearP2RemX immRemP2n:$imm)))>;
1105 } //Added complexity