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