1 //===- ARMInstrThumb2.td - Thumb2 support for ARM -------------------------===//
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 //===----------------------------------------------------------------------===//
10 // This file describes the Thumb2 instruction set.
12 //===----------------------------------------------------------------------===//
14 // IT block predicate field
15 def it_pred : Operand<i32> {
16 let PrintMethod = "printPredicateOperand";
19 // IT block condition mask
20 def it_mask : Operand<i32> {
21 let PrintMethod = "printThumbITMask";
24 // Table branch address
25 def tb_addrmode : Operand<i32> {
26 let PrintMethod = "printTBAddrMode";
29 // Shifted operands. No register controlled shifts for Thumb2.
30 // Note: We do not support rrx shifted operands yet.
31 def t2_so_reg : Operand<i32>, // reg imm
32 ComplexPattern<i32, 2, "SelectT2ShifterOperandReg",
34 let PrintMethod = "printT2SOOperand";
35 let MIOperandInfo = (ops GPR, i32imm);
38 // t2_so_imm_not_XFORM - Return the complement of a t2_so_imm value
39 def t2_so_imm_not_XFORM : SDNodeXForm<imm, [{
40 return CurDAG->getTargetConstant(~((uint32_t)N->getZExtValue()), MVT::i32);
43 // t2_so_imm_neg_XFORM - Return the negation of a t2_so_imm value
44 def t2_so_imm_neg_XFORM : SDNodeXForm<imm, [{
45 return CurDAG->getTargetConstant(-((int)N->getZExtValue()), MVT::i32);
48 // t2_so_imm - Match a 32-bit immediate operand, which is an
49 // 8-bit immediate rotated by an arbitrary number of bits, or an 8-bit
50 // immediate splatted into multiple bytes of the word. t2_so_imm values are
51 // represented in the imm field in the same 12-bit form that they are encoded
52 // into t2_so_imm instructions: the 8-bit immediate is the least significant bits
53 // [bits 0-7], the 4-bit shift/splat amount is the next 4 bits [bits 8-11].
54 def t2_so_imm : Operand<i32>,
56 return ARM_AM::getT2SOImmVal((uint32_t)N->getZExtValue()) != -1;
59 // t2_so_imm_not - Match an immediate that is a complement
61 def t2_so_imm_not : Operand<i32>,
63 return ARM_AM::getT2SOImmVal(~((uint32_t)N->getZExtValue())) != -1;
64 }], t2_so_imm_not_XFORM>;
66 // t2_so_imm_neg - Match an immediate that is a negation of a t2_so_imm.
67 def t2_so_imm_neg : Operand<i32>,
69 return ARM_AM::getT2SOImmVal(-((int)N->getZExtValue())) != -1;
70 }], t2_so_imm_neg_XFORM>;
72 /// imm1_31 predicate - True if the 32-bit immediate is in the range [1,31].
73 def imm1_31 : PatLeaf<(i32 imm), [{
74 return (int32_t)N->getZExtValue() >= 1 && (int32_t)N->getZExtValue() < 32;
77 /// imm0_4095 predicate - True if the 32-bit immediate is in the range [0.4095].
78 def imm0_4095 : Operand<i32>,
80 return (uint32_t)N->getZExtValue() < 4096;
83 def imm0_4095_neg : PatLeaf<(i32 imm), [{
84 return (uint32_t)(-N->getZExtValue()) < 4096;
87 def imm0_255_neg : PatLeaf<(i32 imm), [{
88 return (uint32_t)(-N->getZExtValue()) < 255;
91 /// imm0_65535 predicate - True if the 32-bit immediate is in the range
93 def imm0_65535 : PatLeaf<(i32 imm), [{
94 return (uint32_t)N->getZExtValue() < 65536;
97 /// Split a 32-bit immediate into two 16 bit parts.
98 def t2_lo16 : SDNodeXForm<imm, [{
99 return CurDAG->getTargetConstant((uint32_t)N->getZExtValue() & 0xffff,
103 def t2_hi16 : SDNodeXForm<imm, [{
104 return CurDAG->getTargetConstant((uint32_t)N->getZExtValue() >> 16, MVT::i32);
107 def t2_lo16AllZero : PatLeaf<(i32 imm), [{
108 // Returns true if all low 16-bits are 0.
109 return (((uint32_t)N->getZExtValue()) & 0xFFFFUL) == 0;
113 // Define Thumb2 specific addressing modes.
115 // t2addrmode_imm12 := reg + imm12
116 def t2addrmode_imm12 : Operand<i32>,
117 ComplexPattern<i32, 2, "SelectT2AddrModeImm12", []> {
118 let PrintMethod = "printT2AddrModeImm12Operand";
119 let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
122 // t2addrmode_imm8 := reg - imm8
123 def t2addrmode_imm8 : Operand<i32>,
124 ComplexPattern<i32, 2, "SelectT2AddrModeImm8", []> {
125 let PrintMethod = "printT2AddrModeImm8Operand";
126 let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
129 def t2am_imm8_offset : Operand<i32>,
130 ComplexPattern<i32, 1, "SelectT2AddrModeImm8Offset", []>{
131 let PrintMethod = "printT2AddrModeImm8OffsetOperand";
134 // t2addrmode_imm8s4 := reg +/- (imm8 << 2)
135 def t2addrmode_imm8s4 : Operand<i32>,
136 ComplexPattern<i32, 2, "SelectT2AddrModeImm8s4", []> {
137 let PrintMethod = "printT2AddrModeImm8s4Operand";
138 let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
141 // t2addrmode_so_reg := reg + (reg << imm2)
142 def t2addrmode_so_reg : Operand<i32>,
143 ComplexPattern<i32, 3, "SelectT2AddrModeSoReg", []> {
144 let PrintMethod = "printT2AddrModeSoRegOperand";
145 let MIOperandInfo = (ops GPR:$base, GPR:$offsreg, i32imm:$offsimm);
149 //===----------------------------------------------------------------------===//
150 // Multiclass helpers...
153 /// T2I_un_irs - Defines a set of (op reg, {so_imm|r|so_reg}) patterns for a
154 /// unary operation that produces a value. These are predicable and can be
155 /// changed to modify CPSR.
156 multiclass T2I_un_irs<string opc, PatFrag opnode, bit Cheap = 0, bit ReMat = 0>{
158 def i : T2sI<(outs GPR:$dst), (ins t2_so_imm:$src), IIC_iMOVi,
160 [(set GPR:$dst, (opnode t2_so_imm:$src))]> {
161 let isAsCheapAsAMove = Cheap;
162 let isReMaterializable = ReMat;
165 def r : T2I<(outs GPR:$dst), (ins GPR:$src), IIC_iMOVr,
166 opc, ".w $dst, $src",
167 [(set GPR:$dst, (opnode GPR:$src))]>;
169 def s : T2I<(outs GPR:$dst), (ins t2_so_reg:$src), IIC_iMOVsi,
170 opc, ".w $dst, $src",
171 [(set GPR:$dst, (opnode t2_so_reg:$src))]>;
174 /// T2I_bin_irs - Defines a set of (op reg, {so_imm|r|so_reg}) patterns for a
175 // binary operation that produces a value. These are predicable and can be
176 /// changed to modify CPSR.
177 multiclass T2I_bin_irs<string opc, PatFrag opnode,
178 bit Commutable = 0, string wide =""> {
180 def ri : T2sI<(outs GPR:$dst), (ins GPR:$lhs, t2_so_imm:$rhs), IIC_iALUi,
181 opc, " $dst, $lhs, $rhs",
182 [(set GPR:$dst, (opnode GPR:$lhs, t2_so_imm:$rhs))]>;
184 def rr : T2sI<(outs GPR:$dst), (ins GPR:$lhs, GPR:$rhs), IIC_iALUr,
185 opc, !strconcat(wide, " $dst, $lhs, $rhs"),
186 [(set GPR:$dst, (opnode GPR:$lhs, GPR:$rhs))]> {
187 let isCommutable = Commutable;
190 def rs : T2sI<(outs GPR:$dst), (ins GPR:$lhs, t2_so_reg:$rhs), IIC_iALUsi,
191 opc, !strconcat(wide, " $dst, $lhs, $rhs"),
192 [(set GPR:$dst, (opnode GPR:$lhs, t2_so_reg:$rhs))]>;
195 /// T2I_bin_w_irs - Same as T2I_bin_irs except these operations need
196 // the ".w" prefix to indicate that they are wide.
197 multiclass T2I_bin_w_irs<string opc, PatFrag opnode, bit Commutable = 0> :
198 T2I_bin_irs<opc, opnode, Commutable, ".w">;
200 /// T2I_rbin_is - Same as T2I_bin_irs except the order of operands are
201 /// reversed. It doesn't define the 'rr' form since it's handled by its
202 /// T2I_bin_irs counterpart.
203 multiclass T2I_rbin_is<string opc, PatFrag opnode> {
205 def ri : T2I<(outs GPR:$dst), (ins GPR:$rhs, t2_so_imm:$lhs), IIC_iALUi,
206 opc, ".w $dst, $rhs, $lhs",
207 [(set GPR:$dst, (opnode t2_so_imm:$lhs, GPR:$rhs))]>;
209 def rs : T2I<(outs GPR:$dst), (ins GPR:$rhs, t2_so_reg:$lhs), IIC_iALUsi,
210 opc, " $dst, $rhs, $lhs",
211 [(set GPR:$dst, (opnode t2_so_reg:$lhs, GPR:$rhs))]>;
214 /// T2I_bin_s_irs - Similar to T2I_bin_irs except it sets the 's' bit so the
215 /// instruction modifies the CPSR register.
216 let Defs = [CPSR] in {
217 multiclass T2I_bin_s_irs<string opc, PatFrag opnode, bit Commutable = 0> {
219 def ri : T2I<(outs GPR:$dst), (ins GPR:$lhs, t2_so_imm:$rhs), IIC_iALUi,
220 !strconcat(opc, "s"), ".w $dst, $lhs, $rhs",
221 [(set GPR:$dst, (opnode GPR:$lhs, t2_so_imm:$rhs))]>;
223 def rr : T2I<(outs GPR:$dst), (ins GPR:$lhs, GPR:$rhs), IIC_iALUr,
224 !strconcat(opc, "s"), ".w $dst, $lhs, $rhs",
225 [(set GPR:$dst, (opnode GPR:$lhs, GPR:$rhs))]> {
226 let isCommutable = Commutable;
229 def rs : T2I<(outs GPR:$dst), (ins GPR:$lhs, t2_so_reg:$rhs), IIC_iALUsi,
230 !strconcat(opc, "s"), ".w $dst, $lhs, $rhs",
231 [(set GPR:$dst, (opnode GPR:$lhs, t2_so_reg:$rhs))]>;
235 /// T2I_bin_ii12rs - Defines a set of (op reg, {so_imm|imm0_4095|r|so_reg})
236 /// patterns for a binary operation that produces a value.
237 multiclass T2I_bin_ii12rs<string opc, PatFrag opnode, bit Commutable = 0> {
239 def ri : T2sI<(outs GPR:$dst), (ins GPR:$lhs, t2_so_imm:$rhs), IIC_iALUi,
240 opc, ".w $dst, $lhs, $rhs",
241 [(set GPR:$dst, (opnode GPR:$lhs, t2_so_imm:$rhs))]>;
243 def ri12 : T2sI<(outs GPR:$dst), (ins GPR:$lhs, imm0_4095:$rhs), IIC_iALUi,
244 !strconcat(opc, "w"), " $dst, $lhs, $rhs",
245 [(set GPR:$dst, (opnode GPR:$lhs, imm0_4095:$rhs))]>;
247 def rr : T2sI<(outs GPR:$dst), (ins GPR:$lhs, GPR:$rhs), IIC_iALUr,
248 opc, ".w $dst, $lhs, $rhs",
249 [(set GPR:$dst, (opnode GPR:$lhs, GPR:$rhs))]> {
250 let isCommutable = Commutable;
253 def rs : T2sI<(outs GPR:$dst), (ins GPR:$lhs, t2_so_reg:$rhs), IIC_iALUsi,
254 opc, ".w $dst, $lhs, $rhs",
255 [(set GPR:$dst, (opnode GPR:$lhs, t2_so_reg:$rhs))]>;
258 /// T2I_adde_sube_irs - Defines a set of (op reg, {so_imm|r|so_reg}) patterns for a
259 /// binary operation that produces a value and use and define the carry bit.
260 /// It's not predicable.
261 let Uses = [CPSR] in {
262 multiclass T2I_adde_sube_irs<string opc, PatFrag opnode, bit Commutable = 0> {
264 def ri : T2sI<(outs GPR:$dst), (ins GPR:$lhs, t2_so_imm:$rhs), IIC_iALUi,
265 opc, " $dst, $lhs, $rhs",
266 [(set GPR:$dst, (opnode GPR:$lhs, t2_so_imm:$rhs))]>,
267 Requires<[IsThumb2, CarryDefIsUnused]>;
269 def rr : T2sI<(outs GPR:$dst), (ins GPR:$lhs, GPR:$rhs), IIC_iALUr,
270 opc, ".w $dst, $lhs, $rhs",
271 [(set GPR:$dst, (opnode GPR:$lhs, GPR:$rhs))]>,
272 Requires<[IsThumb2, CarryDefIsUnused]> {
273 let isCommutable = Commutable;
276 def rs : T2sI<(outs GPR:$dst), (ins GPR:$lhs, t2_so_reg:$rhs), IIC_iALUsi,
277 opc, ".w $dst, $lhs, $rhs",
278 [(set GPR:$dst, (opnode GPR:$lhs, t2_so_reg:$rhs))]>,
279 Requires<[IsThumb2, CarryDefIsUnused]>;
280 // Carry setting variants
282 def Sri : T2XI<(outs GPR:$dst), (ins GPR:$lhs, t2_so_imm:$rhs), IIC_iALUi,
283 !strconcat(opc, "s $dst, $lhs, $rhs"),
284 [(set GPR:$dst, (opnode GPR:$lhs, t2_so_imm:$rhs))]>,
285 Requires<[IsThumb2, CarryDefIsUsed]> {
289 def Srr : T2XI<(outs GPR:$dst), (ins GPR:$lhs, GPR:$rhs), IIC_iALUr,
290 !strconcat(opc, "s.w $dst, $lhs, $rhs"),
291 [(set GPR:$dst, (opnode GPR:$lhs, GPR:$rhs))]>,
292 Requires<[IsThumb2, CarryDefIsUsed]> {
294 let isCommutable = Commutable;
297 def Srs : T2XI<(outs GPR:$dst), (ins GPR:$lhs, t2_so_reg:$rhs), IIC_iALUsi,
298 !strconcat(opc, "s.w $dst, $lhs, $rhs"),
299 [(set GPR:$dst, (opnode GPR:$lhs, t2_so_reg:$rhs))]>,
300 Requires<[IsThumb2, CarryDefIsUsed]> {
306 /// T2I_rbin_s_is - Same as T2I_rbin_is except sets 's' bit.
307 let Defs = [CPSR] in {
308 multiclass T2I_rbin_s_is<string opc, PatFrag opnode> {
310 def ri : T2XI<(outs GPR:$dst), (ins GPR:$rhs, t2_so_imm:$lhs, cc_out:$s),
312 !strconcat(opc, "${s}.w $dst, $rhs, $lhs"),
313 [(set GPR:$dst, (opnode t2_so_imm:$lhs, GPR:$rhs))]>;
315 def rs : T2XI<(outs GPR:$dst), (ins GPR:$rhs, t2_so_reg:$lhs, cc_out:$s),
317 !strconcat(opc, "${s} $dst, $rhs, $lhs"),
318 [(set GPR:$dst, (opnode t2_so_reg:$lhs, GPR:$rhs))]>;
322 /// T2I_sh_ir - Defines a set of (op reg, {so_imm|r}) patterns for a shift /
323 // rotate operation that produces a value.
324 multiclass T2I_sh_ir<string opc, PatFrag opnode> {
326 def ri : T2sI<(outs GPR:$dst), (ins GPR:$lhs, i32imm:$rhs), IIC_iMOVsi,
327 opc, ".w $dst, $lhs, $rhs",
328 [(set GPR:$dst, (opnode GPR:$lhs, imm1_31:$rhs))]>;
330 def rr : T2sI<(outs GPR:$dst), (ins GPR:$lhs, GPR:$rhs), IIC_iMOVsr,
331 opc, ".w $dst, $lhs, $rhs",
332 [(set GPR:$dst, (opnode GPR:$lhs, GPR:$rhs))]>;
335 /// T2I_cmp_is - Defines a set of (op r, {so_imm|r|so_reg}) cmp / test
336 /// patterns. Similar to T2I_bin_irs except the instruction does not produce
337 /// a explicit result, only implicitly set CPSR.
338 let Defs = [CPSR] in {
339 multiclass T2I_cmp_is<string opc, PatFrag opnode> {
341 def ri : T2I<(outs), (ins GPR:$lhs, t2_so_imm:$rhs), IIC_iCMPi,
342 opc, ".w $lhs, $rhs",
343 [(opnode GPR:$lhs, t2_so_imm:$rhs)]>;
345 def rr : T2I<(outs), (ins GPR:$lhs, GPR:$rhs), IIC_iCMPr,
346 opc, ".w $lhs, $rhs",
347 [(opnode GPR:$lhs, GPR:$rhs)]>;
349 def rs : T2I<(outs), (ins GPR:$lhs, t2_so_reg:$rhs), IIC_iCMPsi,
350 opc, ".w $lhs, $rhs",
351 [(opnode GPR:$lhs, t2_so_reg:$rhs)]>;
355 /// T2I_ld - Defines a set of (op r, {imm12|imm8|so_reg}) load patterns.
356 multiclass T2I_ld<string opc, PatFrag opnode> {
357 def i12 : T2Ii12<(outs GPR:$dst), (ins t2addrmode_imm12:$addr), IIC_iLoadi,
358 opc, ".w $dst, $addr",
359 [(set GPR:$dst, (opnode t2addrmode_imm12:$addr))]>;
360 def i8 : T2Ii8 <(outs GPR:$dst), (ins t2addrmode_imm8:$addr), IIC_iLoadi,
362 [(set GPR:$dst, (opnode t2addrmode_imm8:$addr))]>;
363 def s : T2Iso <(outs GPR:$dst), (ins t2addrmode_so_reg:$addr), IIC_iLoadr,
364 opc, ".w $dst, $addr",
365 [(set GPR:$dst, (opnode t2addrmode_so_reg:$addr))]>;
366 def pci : T2Ipc <(outs GPR:$dst), (ins i32imm:$addr), IIC_iLoadi,
367 opc, ".w $dst, $addr",
368 [(set GPR:$dst, (opnode (ARMWrapper tconstpool:$addr)))]>;
371 /// T2I_st - Defines a set of (op r, {imm12|imm8|so_reg}) store patterns.
372 multiclass T2I_st<string opc, PatFrag opnode> {
373 def i12 : T2Ii12<(outs), (ins GPR:$src, t2addrmode_imm12:$addr), IIC_iStorei,
374 opc, ".w $src, $addr",
375 [(opnode GPR:$src, t2addrmode_imm12:$addr)]>;
376 def i8 : T2Ii8 <(outs), (ins GPR:$src, t2addrmode_imm8:$addr), IIC_iStorei,
378 [(opnode GPR:$src, t2addrmode_imm8:$addr)]>;
379 def s : T2Iso <(outs), (ins GPR:$src, t2addrmode_so_reg:$addr), IIC_iStorer,
380 opc, ".w $src, $addr",
381 [(opnode GPR:$src, t2addrmode_so_reg:$addr)]>;
384 /// T2I_picld - Defines the PIC load pattern.
385 class T2I_picld<string opc, PatFrag opnode> :
386 T2I<(outs GPR:$dst), (ins addrmodepc:$addr), IIC_iLoadi,
387 !strconcat("\n${addr:label}:\n\t", opc), " $dst, $addr",
388 [(set GPR:$dst, (opnode addrmodepc:$addr))]>;
390 /// T2I_picst - Defines the PIC store pattern.
391 class T2I_picst<string opc, PatFrag opnode> :
392 T2I<(outs), (ins GPR:$src, addrmodepc:$addr), IIC_iStorer,
393 !strconcat("\n${addr:label}:\n\t", opc), " $src, $addr",
394 [(opnode GPR:$src, addrmodepc:$addr)]>;
397 /// T2I_unary_rrot - A unary operation with two forms: one whose operand is a
398 /// register and one whose operand is a register rotated by 8/16/24.
399 multiclass T2I_unary_rrot<string opc, PatFrag opnode> {
400 def r : T2I<(outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
401 opc, ".w $dst, $src",
402 [(set GPR:$dst, (opnode GPR:$src))]>;
403 def r_rot : T2I<(outs GPR:$dst), (ins GPR:$src, i32imm:$rot), IIC_iUNAsi,
404 opc, ".w $dst, $src, ror $rot",
405 [(set GPR:$dst, (opnode (rotr GPR:$src, rot_imm:$rot)))]>;
408 /// T2I_bin_rrot - A binary operation with two forms: one whose operand is a
409 /// register and one whose operand is a register rotated by 8/16/24.
410 multiclass T2I_bin_rrot<string opc, PatFrag opnode> {
411 def rr : T2I<(outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS), IIC_iALUr,
412 opc, " $dst, $LHS, $RHS",
413 [(set GPR:$dst, (opnode GPR:$LHS, GPR:$RHS))]>;
414 def rr_rot : T2I<(outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS, i32imm:$rot),
415 IIC_iALUsr, opc, " $dst, $LHS, $RHS, ror $rot",
416 [(set GPR:$dst, (opnode GPR:$LHS,
417 (rotr GPR:$RHS, rot_imm:$rot)))]>;
420 //===----------------------------------------------------------------------===//
422 //===----------------------------------------------------------------------===//
424 //===----------------------------------------------------------------------===//
425 // Miscellaneous Instructions.
428 // LEApcrel - Load a pc-relative address into a register without offending the
430 def t2LEApcrel : T2XI<(outs GPR:$dst), (ins i32imm:$label, pred:$p), IIC_iALUi,
431 "adr$p.w $dst, #$label", []>;
433 def t2LEApcrelJT : T2XI<(outs GPR:$dst),
434 (ins i32imm:$label, nohash_imm:$id, pred:$p), IIC_iALUi,
435 "adr$p.w $dst, #${label}_${id}", []>;
437 // ADD r, sp, {so_imm|i12}
438 def t2ADDrSPi : T2sI<(outs GPR:$dst), (ins GPR:$sp, t2_so_imm:$imm),
439 IIC_iALUi, "add", ".w $dst, $sp, $imm", []>;
440 def t2ADDrSPi12 : T2I<(outs GPR:$dst), (ins GPR:$sp, imm0_4095:$imm),
441 IIC_iALUi, "addw", " $dst, $sp, $imm", []>;
444 def t2ADDrSPs : T2sI<(outs GPR:$dst), (ins GPR:$sp, t2_so_reg:$rhs),
445 IIC_iALUsi, "add", ".w $dst, $sp, $rhs", []>;
447 // SUB r, sp, {so_imm|i12}
448 def t2SUBrSPi : T2sI<(outs GPR:$dst), (ins GPR:$sp, t2_so_imm:$imm),
449 IIC_iALUi, "sub", ".w $dst, $sp, $imm", []>;
450 def t2SUBrSPi12 : T2I<(outs GPR:$dst), (ins GPR:$sp, imm0_4095:$imm),
451 IIC_iALUi, "subw", " $dst, $sp, $imm", []>;
454 def t2SUBrSPs : T2sI<(outs GPR:$dst), (ins GPR:$sp, t2_so_reg:$rhs),
456 "sub", " $dst, $sp, $rhs", []>;
459 // Pseudo instruction that will expand into a t2SUBrSPi + a copy.
460 let usesCustomDAGSchedInserter = 1 in { // Expanded by the scheduler.
461 def t2SUBrSPi_ : PseudoInst<(outs GPR:$dst), (ins GPR:$sp, t2_so_imm:$imm),
462 NoItinerary, "@ sub.w $dst, $sp, $imm", []>;
463 def t2SUBrSPi12_ : PseudoInst<(outs GPR:$dst), (ins GPR:$sp, imm0_4095:$imm),
464 NoItinerary, "@ subw $dst, $sp, $imm", []>;
465 def t2SUBrSPs_ : PseudoInst<(outs GPR:$dst), (ins GPR:$sp, t2_so_reg:$rhs),
466 NoItinerary, "@ sub $dst, $sp, $rhs", []>;
467 } // usesCustomDAGSchedInserter
470 //===----------------------------------------------------------------------===//
471 // Load / store Instructions.
475 let canFoldAsLoad = 1 in
476 defm t2LDR : T2I_ld<"ldr", UnOpFrag<(load node:$Src)>>;
478 // Loads with zero extension
479 defm t2LDRH : T2I_ld<"ldrh", UnOpFrag<(zextloadi16 node:$Src)>>;
480 defm t2LDRB : T2I_ld<"ldrb", UnOpFrag<(zextloadi8 node:$Src)>>;
482 // Loads with sign extension
483 defm t2LDRSH : T2I_ld<"ldrsh", UnOpFrag<(sextloadi16 node:$Src)>>;
484 defm t2LDRSB : T2I_ld<"ldrsb", UnOpFrag<(sextloadi8 node:$Src)>>;
488 def t2LDRDi8 : T2Ii8s4<(outs GPR:$dst1, GPR:$dst2),
489 (ins t2addrmode_imm8s4:$addr),
490 IIC_iLoadi, "ldrd", " $dst1, $addr", []>;
491 def t2LDRDpci : T2Ii8s4<(outs GPR:$dst1, GPR:$dst2),
492 (ins i32imm:$addr), IIC_iLoadi,
493 "ldrd", " $dst1, $addr", []>;
496 // zextload i1 -> zextload i8
497 def : T2Pat<(zextloadi1 t2addrmode_imm12:$addr),
498 (t2LDRBi12 t2addrmode_imm12:$addr)>;
499 def : T2Pat<(zextloadi1 t2addrmode_imm8:$addr),
500 (t2LDRBi8 t2addrmode_imm8:$addr)>;
501 def : T2Pat<(zextloadi1 t2addrmode_so_reg:$addr),
502 (t2LDRBs t2addrmode_so_reg:$addr)>;
503 def : T2Pat<(zextloadi1 (ARMWrapper tconstpool:$addr)),
504 (t2LDRBpci tconstpool:$addr)>;
506 // extload -> zextload
507 // FIXME: Reduce the number of patterns by legalizing extload to zextload
509 def : T2Pat<(extloadi1 t2addrmode_imm12:$addr),
510 (t2LDRBi12 t2addrmode_imm12:$addr)>;
511 def : T2Pat<(extloadi1 t2addrmode_imm8:$addr),
512 (t2LDRBi8 t2addrmode_imm8:$addr)>;
513 def : T2Pat<(extloadi1 t2addrmode_so_reg:$addr),
514 (t2LDRBs t2addrmode_so_reg:$addr)>;
515 def : T2Pat<(extloadi1 (ARMWrapper tconstpool:$addr)),
516 (t2LDRBpci tconstpool:$addr)>;
518 def : T2Pat<(extloadi8 t2addrmode_imm12:$addr),
519 (t2LDRBi12 t2addrmode_imm12:$addr)>;
520 def : T2Pat<(extloadi8 t2addrmode_imm8:$addr),
521 (t2LDRBi8 t2addrmode_imm8:$addr)>;
522 def : T2Pat<(extloadi8 t2addrmode_so_reg:$addr),
523 (t2LDRBs t2addrmode_so_reg:$addr)>;
524 def : T2Pat<(extloadi8 (ARMWrapper tconstpool:$addr)),
525 (t2LDRBpci tconstpool:$addr)>;
527 def : T2Pat<(extloadi16 t2addrmode_imm12:$addr),
528 (t2LDRHi12 t2addrmode_imm12:$addr)>;
529 def : T2Pat<(extloadi16 t2addrmode_imm8:$addr),
530 (t2LDRHi8 t2addrmode_imm8:$addr)>;
531 def : T2Pat<(extloadi16 t2addrmode_so_reg:$addr),
532 (t2LDRHs t2addrmode_so_reg:$addr)>;
533 def : T2Pat<(extloadi16 (ARMWrapper tconstpool:$addr)),
534 (t2LDRHpci tconstpool:$addr)>;
538 def t2LDR_PRE : T2Iidxldst<(outs GPR:$dst, GPR:$base_wb),
539 (ins t2addrmode_imm8:$addr),
540 AddrModeT2_i8, IndexModePre, IIC_iLoadiu,
541 "ldr", " $dst, $addr!", "$addr.base = $base_wb",
544 def t2LDR_POST : T2Iidxldst<(outs GPR:$dst, GPR:$base_wb),
545 (ins GPR:$base, t2am_imm8_offset:$offset),
546 AddrModeT2_i8, IndexModePost, IIC_iLoadiu,
547 "ldr", " $dst, [$base], $offset", "$base = $base_wb",
550 def t2LDRB_PRE : T2Iidxldst<(outs GPR:$dst, GPR:$base_wb),
551 (ins t2addrmode_imm8:$addr),
552 AddrModeT2_i8, IndexModePre, IIC_iLoadiu,
553 "ldrb", " $dst, $addr!", "$addr.base = $base_wb",
555 def t2LDRB_POST : T2Iidxldst<(outs GPR:$dst, GPR:$base_wb),
556 (ins GPR:$base, t2am_imm8_offset:$offset),
557 AddrModeT2_i8, IndexModePost, IIC_iLoadiu,
558 "ldrb", " $dst, [$base], $offset", "$base = $base_wb",
561 def t2LDRH_PRE : T2Iidxldst<(outs GPR:$dst, GPR:$base_wb),
562 (ins t2addrmode_imm8:$addr),
563 AddrModeT2_i8, IndexModePre, IIC_iLoadiu,
564 "ldrh", " $dst, $addr!", "$addr.base = $base_wb",
566 def t2LDRH_POST : T2Iidxldst<(outs GPR:$dst, GPR:$base_wb),
567 (ins GPR:$base, t2am_imm8_offset:$offset),
568 AddrModeT2_i8, IndexModePost, IIC_iLoadiu,
569 "ldrh", " $dst, [$base], $offset", "$base = $base_wb",
572 def t2LDRSB_PRE : T2Iidxldst<(outs GPR:$dst, GPR:$base_wb),
573 (ins t2addrmode_imm8:$addr),
574 AddrModeT2_i8, IndexModePre, IIC_iLoadiu,
575 "ldrsb", " $dst, $addr!", "$addr.base = $base_wb",
577 def t2LDRSB_POST : T2Iidxldst<(outs GPR:$dst, GPR:$base_wb),
578 (ins GPR:$base, t2am_imm8_offset:$offset),
579 AddrModeT2_i8, IndexModePost, IIC_iLoadiu,
580 "ldrsb", " $dst, [$base], $offset", "$base = $base_wb",
583 def t2LDRSH_PRE : T2Iidxldst<(outs GPR:$dst, GPR:$base_wb),
584 (ins t2addrmode_imm8:$addr),
585 AddrModeT2_i8, IndexModePre, IIC_iLoadiu,
586 "ldrsh", " $dst, $addr!", "$addr.base = $base_wb",
588 def t2LDRSH_POST : T2Iidxldst<(outs GPR:$dst, GPR:$base_wb),
589 (ins GPR:$base, t2am_imm8_offset:$offset),
590 AddrModeT2_i8, IndexModePost, IIC_iLoadiu,
591 "ldrsh", " $dst, [$base], $offset", "$base = $base_wb",
596 defm t2STR : T2I_st<"str", BinOpFrag<(store node:$LHS, node:$RHS)>>;
597 defm t2STRB : T2I_st<"strb", BinOpFrag<(truncstorei8 node:$LHS, node:$RHS)>>;
598 defm t2STRH : T2I_st<"strh", BinOpFrag<(truncstorei16 node:$LHS, node:$RHS)>>;
602 def t2STRDi8 : T2Ii8s4<(outs),
603 (ins GPR:$src1, GPR:$src2, t2addrmode_imm8s4:$addr),
604 IIC_iStorer, "strd", " $src1, $addr", []>;
607 def t2STR_PRE : T2Iidxldst<(outs GPR:$base_wb),
608 (ins GPR:$src, GPR:$base, t2am_imm8_offset:$offset),
609 AddrModeT2_i8, IndexModePre, IIC_iStoreiu,
610 "str", " $src, [$base, $offset]!", "$base = $base_wb",
612 (pre_store GPR:$src, GPR:$base, t2am_imm8_offset:$offset))]>;
614 def t2STR_POST : T2Iidxldst<(outs GPR:$base_wb),
615 (ins GPR:$src, GPR:$base, t2am_imm8_offset:$offset),
616 AddrModeT2_i8, IndexModePost, IIC_iStoreiu,
617 "str", " $src, [$base], $offset", "$base = $base_wb",
619 (post_store GPR:$src, GPR:$base, t2am_imm8_offset:$offset))]>;
621 def t2STRH_PRE : T2Iidxldst<(outs GPR:$base_wb),
622 (ins GPR:$src, GPR:$base, t2am_imm8_offset:$offset),
623 AddrModeT2_i8, IndexModePre, IIC_iStoreiu,
624 "strh", " $src, [$base, $offset]!", "$base = $base_wb",
626 (pre_truncsti16 GPR:$src, GPR:$base, t2am_imm8_offset:$offset))]>;
628 def t2STRH_POST : T2Iidxldst<(outs GPR:$base_wb),
629 (ins GPR:$src, GPR:$base, t2am_imm8_offset:$offset),
630 AddrModeT2_i8, IndexModePost, IIC_iStoreiu,
631 "strh", " $src, [$base], $offset", "$base = $base_wb",
633 (post_truncsti16 GPR:$src, GPR:$base, t2am_imm8_offset:$offset))]>;
635 def t2STRB_PRE : T2Iidxldst<(outs GPR:$base_wb),
636 (ins GPR:$src, GPR:$base, t2am_imm8_offset:$offset),
637 AddrModeT2_i8, IndexModePre, IIC_iStoreiu,
638 "strb", " $src, [$base, $offset]!", "$base = $base_wb",
640 (pre_truncsti8 GPR:$src, GPR:$base, t2am_imm8_offset:$offset))]>;
642 def t2STRB_POST : T2Iidxldst<(outs GPR:$base_wb),
643 (ins GPR:$src, GPR:$base, t2am_imm8_offset:$offset),
644 AddrModeT2_i8, IndexModePost, IIC_iStoreiu,
645 "strb", " $src, [$base], $offset", "$base = $base_wb",
647 (post_truncsti8 GPR:$src, GPR:$base, t2am_imm8_offset:$offset))]>;
650 // FIXME: ldrd / strd pre / post variants
652 //===----------------------------------------------------------------------===//
653 // Load / store multiple Instructions.
657 def t2LDM : T2XI<(outs),
658 (ins addrmode4:$addr, pred:$p, reglist:$dst1, variable_ops),
659 IIC_iLoadm, "ldm${addr:submode}${p}${addr:wide} $addr, $dst1", []>;
662 def t2STM : T2XI<(outs),
663 (ins addrmode4:$addr, pred:$p, reglist:$src1, variable_ops),
664 IIC_iStorem, "stm${addr:submode}${p}${addr:wide} $addr, $src1", []>;
666 //===----------------------------------------------------------------------===//
667 // Move Instructions.
670 let neverHasSideEffects = 1 in
671 def t2MOVr : T2sI<(outs GPR:$dst), (ins GPR:$src), IIC_iMOVr,
672 "mov", ".w $dst, $src", []>;
674 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
675 def t2MOVi : T2sI<(outs GPR:$dst), (ins t2_so_imm:$src), IIC_iMOVi,
676 "mov", ".w $dst, $src",
677 [(set GPR:$dst, t2_so_imm:$src)]>;
679 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
680 def t2MOVi16 : T2I<(outs GPR:$dst), (ins i32imm:$src), IIC_iMOVi,
681 "movw", " $dst, $src",
682 [(set GPR:$dst, imm0_65535:$src)]>;
684 // FIXME: Also available in ARM mode.
685 let Constraints = "$src = $dst" in
686 def t2MOVTi16 : T2sI<(outs GPR:$dst), (ins GPR:$src, i32imm:$imm), IIC_iMOVi,
687 "movt", " $dst, $imm",
689 (or (and GPR:$src, 0xffff), t2_lo16AllZero:$imm))]>;
691 //===----------------------------------------------------------------------===//
692 // Extend Instructions.
697 defm t2SXTB : T2I_unary_rrot<"sxtb", UnOpFrag<(sext_inreg node:$Src, i8)>>;
698 defm t2SXTH : T2I_unary_rrot<"sxth", UnOpFrag<(sext_inreg node:$Src, i16)>>;
700 defm t2SXTAB : T2I_bin_rrot<"sxtab",
701 BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS, i8))>>;
702 defm t2SXTAH : T2I_bin_rrot<"sxtah",
703 BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS,i16))>>;
705 // TODO: SXT(A){B|H}16
709 let AddedComplexity = 16 in {
710 defm t2UXTB : T2I_unary_rrot<"uxtb" , UnOpFrag<(and node:$Src, 0x000000FF)>>;
711 defm t2UXTH : T2I_unary_rrot<"uxth" , UnOpFrag<(and node:$Src, 0x0000FFFF)>>;
712 defm t2UXTB16 : T2I_unary_rrot<"uxtb16", UnOpFrag<(and node:$Src, 0x00FF00FF)>>;
714 def : T2Pat<(and (shl GPR:$Src, (i32 8)), 0xFF00FF),
715 (t2UXTB16r_rot GPR:$Src, 24)>;
716 def : T2Pat<(and (srl GPR:$Src, (i32 8)), 0xFF00FF),
717 (t2UXTB16r_rot GPR:$Src, 8)>;
719 defm t2UXTAB : T2I_bin_rrot<"uxtab",
720 BinOpFrag<(add node:$LHS, (and node:$RHS, 0x00FF))>>;
721 defm t2UXTAH : T2I_bin_rrot<"uxtah",
722 BinOpFrag<(add node:$LHS, (and node:$RHS, 0xFFFF))>>;
725 //===----------------------------------------------------------------------===//
726 // Arithmetic Instructions.
729 defm t2ADD : T2I_bin_ii12rs<"add", BinOpFrag<(add node:$LHS, node:$RHS)>, 1>;
730 defm t2SUB : T2I_bin_ii12rs<"sub", BinOpFrag<(sub node:$LHS, node:$RHS)>>;
732 // ADD and SUB with 's' bit set. No 12-bit immediate (T4) variants.
733 defm t2ADDS : T2I_bin_s_irs <"add", BinOpFrag<(addc node:$LHS, node:$RHS)>, 1>;
734 defm t2SUBS : T2I_bin_s_irs <"sub", BinOpFrag<(subc node:$LHS, node:$RHS)>>;
736 defm t2ADC : T2I_adde_sube_irs<"adc",BinOpFrag<(adde node:$LHS, node:$RHS)>,1>;
737 defm t2SBC : T2I_adde_sube_irs<"sbc",BinOpFrag<(sube node:$LHS, node:$RHS)>>;
740 defm t2RSB : T2I_rbin_is <"rsb", BinOpFrag<(sub node:$LHS, node:$RHS)>>;
741 defm t2RSBS : T2I_rbin_s_is <"rsb", BinOpFrag<(subc node:$LHS, node:$RHS)>>;
743 // (sub X, imm) gets canonicalized to (add X, -imm). Match this form.
744 let AddedComplexity = 1 in
745 def : T2Pat<(add GPR:$src, imm0_255_neg:$imm),
746 (t2SUBri GPR:$src, imm0_255_neg:$imm)>;
747 def : T2Pat<(add GPR:$src, t2_so_imm_neg:$imm),
748 (t2SUBri GPR:$src, t2_so_imm_neg:$imm)>;
749 def : T2Pat<(add GPR:$src, imm0_4095_neg:$imm),
750 (t2SUBri12 GPR:$src, imm0_4095_neg:$imm)>;
753 //===----------------------------------------------------------------------===//
754 // Shift and rotate Instructions.
757 defm t2LSL : T2I_sh_ir<"lsl", BinOpFrag<(shl node:$LHS, node:$RHS)>>;
758 defm t2LSR : T2I_sh_ir<"lsr", BinOpFrag<(srl node:$LHS, node:$RHS)>>;
759 defm t2ASR : T2I_sh_ir<"asr", BinOpFrag<(sra node:$LHS, node:$RHS)>>;
760 defm t2ROR : T2I_sh_ir<"ror", BinOpFrag<(rotr node:$LHS, node:$RHS)>>;
762 let Uses = [CPSR] in {
763 def t2MOVrx : T2sI<(outs GPR:$dst), (ins GPR:$src), IIC_iMOVsi,
764 "rrx", " $dst, $src",
765 [(set GPR:$dst, (ARMrrx GPR:$src))]>;
768 let Defs = [CPSR] in {
769 def t2MOVsrl_flag : T2XI<(outs GPR:$dst), (ins GPR:$src), IIC_iMOVsi,
770 "lsrs.w $dst, $src, #1",
771 [(set GPR:$dst, (ARMsrl_flag GPR:$src))]>;
772 def t2MOVsra_flag : T2XI<(outs GPR:$dst), (ins GPR:$src), IIC_iMOVsi,
773 "asrs.w $dst, $src, #1",
774 [(set GPR:$dst, (ARMsra_flag GPR:$src))]>;
777 //===----------------------------------------------------------------------===//
778 // Bitwise Instructions.
781 defm t2AND : T2I_bin_w_irs<"and", BinOpFrag<(and node:$LHS, node:$RHS)>, 1>;
782 defm t2ORR : T2I_bin_w_irs<"orr", BinOpFrag<(or node:$LHS, node:$RHS)>, 1>;
783 defm t2EOR : T2I_bin_w_irs<"eor", BinOpFrag<(xor node:$LHS, node:$RHS)>, 1>;
785 defm t2BIC : T2I_bin_w_irs<"bic", BinOpFrag<(and node:$LHS, (not node:$RHS))>>;
787 let Constraints = "$src = $dst" in
788 def t2BFC : T2I<(outs GPR:$dst), (ins GPR:$src, bf_inv_mask_imm:$imm),
789 IIC_iALUi, "bfc", " $dst, $imm",
790 [(set GPR:$dst, (and GPR:$src, bf_inv_mask_imm:$imm))]>;
792 // FIXME: A8.6.18 BFI - Bitfield insert (Encoding T1)
794 defm t2ORN : T2I_bin_irs<"orn", BinOpFrag<(or node:$LHS, (not node:$RHS))>>;
796 // Prefer over of t2EORri ra, rb, -1 because mvn has 16-bit version
797 let AddedComplexity = 1 in
798 defm t2MVN : T2I_un_irs <"mvn", UnOpFrag<(not node:$Src)>, 1, 1>;
801 def : T2Pat<(and GPR:$src, t2_so_imm_not:$imm),
802 (t2BICri GPR:$src, t2_so_imm_not:$imm)>;
804 // FIXME: Disable this pattern on Darwin to workaround an assembler bug.
805 def : T2Pat<(or GPR:$src, t2_so_imm_not:$imm),
806 (t2ORNri GPR:$src, t2_so_imm_not:$imm)>,
807 Requires<[IsThumb2]>;
809 def : T2Pat<(t2_so_imm_not:$src),
810 (t2MVNi t2_so_imm_not:$src)>;
812 //===----------------------------------------------------------------------===//
813 // Multiply Instructions.
815 let isCommutable = 1 in
816 def t2MUL: T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b), IIC_iMUL32,
817 "mul", " $dst, $a, $b",
818 [(set GPR:$dst, (mul GPR:$a, GPR:$b))]>;
820 def t2MLA: T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c), IIC_iMAC32,
821 "mla", " $dst, $a, $b, $c",
822 [(set GPR:$dst, (add (mul GPR:$a, GPR:$b), GPR:$c))]>;
824 def t2MLS: T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c), IIC_iMAC32,
825 "mls", " $dst, $a, $b, $c",
826 [(set GPR:$dst, (sub GPR:$c, (mul GPR:$a, GPR:$b)))]>;
828 // Extra precision multiplies with low / high results
829 let neverHasSideEffects = 1 in {
830 let isCommutable = 1 in {
831 def t2SMULL : T2I<(outs GPR:$ldst, GPR:$hdst), (ins GPR:$a, GPR:$b), IIC_iMUL64,
832 "smull", " $ldst, $hdst, $a, $b", []>;
834 def t2UMULL : T2I<(outs GPR:$ldst, GPR:$hdst), (ins GPR:$a, GPR:$b), IIC_iMUL64,
835 "umull", " $ldst, $hdst, $a, $b", []>;
838 // Multiply + accumulate
839 def t2SMLAL : T2I<(outs GPR:$ldst, GPR:$hdst), (ins GPR:$a, GPR:$b), IIC_iMAC64,
840 "smlal", " $ldst, $hdst, $a, $b", []>;
842 def t2UMLAL : T2I<(outs GPR:$ldst, GPR:$hdst), (ins GPR:$a, GPR:$b), IIC_iMAC64,
843 "umlal", " $ldst, $hdst, $a, $b", []>;
845 def t2UMAAL : T2I<(outs GPR:$ldst, GPR:$hdst), (ins GPR:$a, GPR:$b), IIC_iMAC64,
846 "umaal", " $ldst, $hdst, $a, $b", []>;
847 } // neverHasSideEffects
849 // Most significant word multiply
850 def t2SMMUL : T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b), IIC_iMUL32,
851 "smmul", " $dst, $a, $b",
852 [(set GPR:$dst, (mulhs GPR:$a, GPR:$b))]>;
854 def t2SMMLA : T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c), IIC_iMAC32,
855 "smmla", " $dst, $a, $b, $c",
856 [(set GPR:$dst, (add (mulhs GPR:$a, GPR:$b), GPR:$c))]>;
859 def t2SMMLS : T2I <(outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c), IIC_iMAC32,
860 "smmls", " $dst, $a, $b, $c",
861 [(set GPR:$dst, (sub GPR:$c, (mulhs GPR:$a, GPR:$b)))]>;
863 multiclass T2I_smul<string opc, PatFrag opnode> {
864 def BB : T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b), IIC_iMUL32,
865 !strconcat(opc, "bb"), " $dst, $a, $b",
866 [(set GPR:$dst, (opnode (sext_inreg GPR:$a, i16),
867 (sext_inreg GPR:$b, i16)))]>;
869 def BT : T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b), IIC_iMUL32,
870 !strconcat(opc, "bt"), " $dst, $a, $b",
871 [(set GPR:$dst, (opnode (sext_inreg GPR:$a, i16),
872 (sra GPR:$b, (i32 16))))]>;
874 def TB : T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b), IIC_iMUL32,
875 !strconcat(opc, "tb"), " $dst, $a, $b",
876 [(set GPR:$dst, (opnode (sra GPR:$a, (i32 16)),
877 (sext_inreg GPR:$b, i16)))]>;
879 def TT : T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b), IIC_iMUL32,
880 !strconcat(opc, "tt"), " $dst, $a, $b",
881 [(set GPR:$dst, (opnode (sra GPR:$a, (i32 16)),
882 (sra GPR:$b, (i32 16))))]>;
884 def WB : T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b), IIC_iMUL16,
885 !strconcat(opc, "wb"), " $dst, $a, $b",
886 [(set GPR:$dst, (sra (opnode GPR:$a,
887 (sext_inreg GPR:$b, i16)), (i32 16)))]>;
889 def WT : T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b), IIC_iMUL16,
890 !strconcat(opc, "wt"), " $dst, $a, $b",
891 [(set GPR:$dst, (sra (opnode GPR:$a,
892 (sra GPR:$b, (i32 16))), (i32 16)))]>;
896 multiclass T2I_smla<string opc, PatFrag opnode> {
897 def BB : T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc), IIC_iMAC16,
898 !strconcat(opc, "bb"), " $dst, $a, $b, $acc",
899 [(set GPR:$dst, (add GPR:$acc,
900 (opnode (sext_inreg GPR:$a, i16),
901 (sext_inreg GPR:$b, i16))))]>;
903 def BT : T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc), IIC_iMAC16,
904 !strconcat(opc, "bt"), " $dst, $a, $b, $acc",
905 [(set GPR:$dst, (add GPR:$acc, (opnode (sext_inreg GPR:$a, i16),
906 (sra GPR:$b, (i32 16)))))]>;
908 def TB : T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc), IIC_iMAC16,
909 !strconcat(opc, "tb"), " $dst, $a, $b, $acc",
910 [(set GPR:$dst, (add GPR:$acc, (opnode (sra GPR:$a, (i32 16)),
911 (sext_inreg GPR:$b, i16))))]>;
913 def TT : T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc), IIC_iMAC16,
914 !strconcat(opc, "tt"), " $dst, $a, $b, $acc",
915 [(set GPR:$dst, (add GPR:$acc, (opnode (sra GPR:$a, (i32 16)),
916 (sra GPR:$b, (i32 16)))))]>;
918 def WB : T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc), IIC_iMAC16,
919 !strconcat(opc, "wb"), " $dst, $a, $b, $acc",
920 [(set GPR:$dst, (add GPR:$acc, (sra (opnode GPR:$a,
921 (sext_inreg GPR:$b, i16)), (i32 16))))]>;
923 def WT : T2I<(outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc), IIC_iMAC16,
924 !strconcat(opc, "wt"), " $dst, $a, $b, $acc",
925 [(set GPR:$dst, (add GPR:$acc, (sra (opnode GPR:$a,
926 (sra GPR:$b, (i32 16))), (i32 16))))]>;
929 defm t2SMUL : T2I_smul<"smul", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
930 defm t2SMLA : T2I_smla<"smla", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
932 // TODO: Halfword multiple accumulate long: SMLAL<x><y>
933 // TODO: Dual halfword multiple: SMUAD, SMUSD, SMLAD, SMLSD, SMLALD, SMLSLD
936 //===----------------------------------------------------------------------===//
937 // Misc. Arithmetic Instructions.
940 def t2CLZ : T2I<(outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
941 "clz", " $dst, $src",
942 [(set GPR:$dst, (ctlz GPR:$src))]>;
944 def t2REV : T2I<(outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
945 "rev", ".w $dst, $src",
946 [(set GPR:$dst, (bswap GPR:$src))]>;
948 def t2REV16 : T2I<(outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
949 "rev16", ".w $dst, $src",
951 (or (and (srl GPR:$src, (i32 8)), 0xFF),
952 (or (and (shl GPR:$src, (i32 8)), 0xFF00),
953 (or (and (srl GPR:$src, (i32 8)), 0xFF0000),
954 (and (shl GPR:$src, (i32 8)), 0xFF000000)))))]>;
956 def t2REVSH : T2I<(outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
957 "revsh", ".w $dst, $src",
960 (or (srl (and GPR:$src, 0xFF00), (i32 8)),
961 (shl GPR:$src, (i32 8))), i16))]>;
963 def t2PKHBT : T2I<(outs GPR:$dst), (ins GPR:$src1, GPR:$src2, i32imm:$shamt),
964 IIC_iALUsi, "pkhbt", " $dst, $src1, $src2, LSL $shamt",
965 [(set GPR:$dst, (or (and GPR:$src1, 0xFFFF),
966 (and (shl GPR:$src2, (i32 imm:$shamt)),
969 // Alternate cases for PKHBT where identities eliminate some nodes.
970 def : T2Pat<(or (and GPR:$src1, 0xFFFF), (and GPR:$src2, 0xFFFF0000)),
971 (t2PKHBT GPR:$src1, GPR:$src2, 0)>;
972 def : T2Pat<(or (and GPR:$src1, 0xFFFF), (shl GPR:$src2, imm16_31:$shamt)),
973 (t2PKHBT GPR:$src1, GPR:$src2, imm16_31:$shamt)>;
975 def t2PKHTB : T2I<(outs GPR:$dst), (ins GPR:$src1, GPR:$src2, i32imm:$shamt),
976 IIC_iALUsi, "pkhtb", " $dst, $src1, $src2, ASR $shamt",
977 [(set GPR:$dst, (or (and GPR:$src1, 0xFFFF0000),
978 (and (sra GPR:$src2, imm16_31:$shamt),
981 // Alternate cases for PKHTB where identities eliminate some nodes. Note that
982 // a shift amount of 0 is *not legal* here, it is PKHBT instead.
983 def : T2Pat<(or (and GPR:$src1, 0xFFFF0000), (srl GPR:$src2, (i32 16))),
984 (t2PKHTB GPR:$src1, GPR:$src2, 16)>;
985 def : T2Pat<(or (and GPR:$src1, 0xFFFF0000),
986 (and (srl GPR:$src2, imm1_15:$shamt), 0xFFFF)),
987 (t2PKHTB GPR:$src1, GPR:$src2, imm1_15:$shamt)>;
989 //===----------------------------------------------------------------------===//
990 // Comparison Instructions...
993 defm t2CMP : T2I_cmp_is<"cmp",
994 BinOpFrag<(ARMcmp node:$LHS, node:$RHS)>>;
995 defm t2CMPz : T2I_cmp_is<"cmp",
996 BinOpFrag<(ARMcmpZ node:$LHS, node:$RHS)>>;
998 defm t2CMN : T2I_cmp_is<"cmn",
999 BinOpFrag<(ARMcmp node:$LHS,(ineg node:$RHS))>>;
1000 defm t2CMNz : T2I_cmp_is<"cmn",
1001 BinOpFrag<(ARMcmpZ node:$LHS,(ineg node:$RHS))>>;
1003 def : T2Pat<(ARMcmp GPR:$src, t2_so_imm_neg:$imm),
1004 (t2CMNri GPR:$src, t2_so_imm_neg:$imm)>;
1006 def : T2Pat<(ARMcmpZ GPR:$src, t2_so_imm_neg:$imm),
1007 (t2CMNri GPR:$src, t2_so_imm_neg:$imm)>;
1009 defm t2TST : T2I_cmp_is<"tst",
1010 BinOpFrag<(ARMcmpZ (and node:$LHS, node:$RHS), 0)>>;
1011 defm t2TEQ : T2I_cmp_is<"teq",
1012 BinOpFrag<(ARMcmpZ (xor node:$LHS, node:$RHS), 0)>>;
1014 // A8.6.27 CBNZ, CBZ - Compare and branch on (non)zero.
1015 // Short range conditional branch. Looks awesome for loops. Need to figure
1016 // out how to use this one.
1019 // Conditional moves
1020 // FIXME: should be able to write a pattern for ARMcmov, but can't use
1021 // a two-value operand where a dag node expects two operands. :(
1022 def t2MOVCCr : T2I<(outs GPR:$dst), (ins GPR:$false, GPR:$true), IIC_iCMOVr,
1023 "mov", ".w $dst, $true",
1024 [/*(set GPR:$dst, (ARMcmov GPR:$false, GPR:$true, imm:$cc, CCR:$ccr))*/]>,
1025 RegConstraint<"$false = $dst">;
1027 def t2MOVCCi : T2I<(outs GPR:$dst), (ins GPR:$false, t2_so_imm:$true),
1028 IIC_iCMOVi, "mov", ".w $dst, $true",
1029 [/*(set GPR:$dst, (ARMcmov GPR:$false, t2_so_imm:$true, imm:$cc, CCR:$ccr))*/]>,
1030 RegConstraint<"$false = $dst">;
1032 def t2MOVCClsl : T2I<(outs GPR:$dst), (ins GPR:$false, GPR:$true, i32imm:$rhs),
1033 IIC_iCMOVsi, "lsl", ".w $dst, $true, $rhs", []>,
1034 RegConstraint<"$false = $dst">;
1035 def t2MOVCClsr : T2I<(outs GPR:$dst), (ins GPR:$false, GPR:$true, i32imm:$rhs),
1036 IIC_iCMOVsi, "lsr", ".w $dst, $true, $rhs", []>,
1037 RegConstraint<"$false = $dst">;
1038 def t2MOVCCasr : T2I<(outs GPR:$dst), (ins GPR:$false, GPR:$true, i32imm:$rhs),
1039 IIC_iCMOVsi, "asr", ".w $dst, $true, $rhs", []>,
1040 RegConstraint<"$false = $dst">;
1041 def t2MOVCCror : T2I<(outs GPR:$dst), (ins GPR:$false, GPR:$true, i32imm:$rhs),
1042 IIC_iCMOVsi, "ror", ".w $dst, $true, $rhs", []>,
1043 RegConstraint<"$false = $dst">;
1045 //===----------------------------------------------------------------------===//
1049 // __aeabi_read_tp preserves the registers r1-r3.
1051 Defs = [R0, R12, LR, CPSR] in {
1052 def t2TPsoft : T2XI<(outs), (ins), IIC_Br,
1053 "bl __aeabi_read_tp",
1054 [(set R0, ARMthread_pointer)]>;
1057 //===----------------------------------------------------------------------===//
1058 // SJLJ Exception handling intrinsics
1059 // eh_sjlj_setjmp() is an instruction sequence to store the return
1060 // address and save #0 in R0 for the non-longjmp case.
1061 // Since by its nature we may be coming from some other function to get
1062 // here, and we're using the stack frame for the containing function to
1063 // save/restore registers, we can't keep anything live in regs across
1064 // the eh_sjlj_setjmp(), else it will almost certainly have been tromped upon
1065 // when we get here from a longjmp(). We force everthing out of registers
1066 // except for our own input by listing the relevant registers in Defs. By
1067 // doing so, we also cause the prologue/epilogue code to actively preserve
1068 // all of the callee-saved resgisters, which is exactly what we want.
1070 [ R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, LR, D0,
1071 D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15,
1072 D16, D17, D18, D19, D20, D21, D22, D23, D24, D25, D26, D27, D28, D29, D30,
1074 def t2Int_eh_sjlj_setjmp : Thumb2XI<(outs), (ins GPR:$src),
1075 AddrModeNone, SizeSpecial, NoItinerary,
1076 "str.w sp, [$src, #+8] @ eh_setjmp begin\n"
1079 "\tstr.w r12, [$src, #+4]\n"
1082 "0:\tmovs r0, #1 @ eh_setjmp end\n"
1084 [(set R0, (ARMeh_sjlj_setjmp GPR:$src))]>;
1089 //===----------------------------------------------------------------------===//
1090 // Control-Flow Instructions
1093 // FIXME: remove when we have a way to marking a MI with these properties.
1094 // FIXME: $dst1 should be a def. But the extra ops must be in the end of the
1096 // FIXME: Should pc be an implicit operand like PICADD, etc?
1097 let isReturn = 1, isTerminator = 1, mayLoad = 1 in
1098 def t2LDM_RET : T2XI<(outs),
1099 (ins addrmode4:$addr, pred:$p, reglist:$dst1, variable_ops),
1100 IIC_Br, "ldm${addr:submode}${p}${addr:wide} $addr, $dst1",
1103 let isBranch = 1, isTerminator = 1, isBarrier = 1 in {
1104 let isPredicable = 1 in
1105 def t2B : T2XI<(outs), (ins brtarget:$target), IIC_Br,
1109 let isNotDuplicable = 1, isIndirectBranch = 1 in {
1112 (ins GPR:$target, GPR:$index, jt2block_operand:$jt, i32imm:$id),
1113 IIC_Br, "mov pc, $target\n$jt",
1114 [(ARMbr2jt GPR:$target, GPR:$index, tjumptable:$jt, imm:$id)]>;
1116 // FIXME: Add a non-pc based case that can be predicated.
1119 (ins tb_addrmode:$index, jt2block_operand:$jt, i32imm:$id),
1120 IIC_Br, "tbb $index\n$jt", []>;
1124 (ins tb_addrmode:$index, jt2block_operand:$jt, i32imm:$id),
1125 IIC_Br, "tbh $index\n$jt", []>;
1126 } // isNotDuplicable, isIndirectBranch
1128 } // isBranch, isTerminator, isBarrier
1130 // FIXME: should be able to write a pattern for ARMBrcond, but can't use
1131 // a two-value operand where a dag node expects two operands. :(
1132 let isBranch = 1, isTerminator = 1 in
1133 def t2Bcc : T2I<(outs), (ins brtarget:$target), IIC_Br,
1135 [/*(ARMbrcond bb:$target, imm:$cc)*/]>;
1139 def t2IT : Thumb2XI<(outs), (ins it_pred:$cc, it_mask:$mask),
1140 AddrModeNone, Size2Bytes, IIC_iALUx,
1141 "it$mask $cc", "", []>;
1143 //===----------------------------------------------------------------------===//
1144 // Non-Instruction Patterns
1147 // ConstantPool, GlobalAddress, and JumpTable
1148 def : T2Pat<(ARMWrapper tglobaladdr :$dst), (t2LEApcrel tglobaladdr :$dst)>;
1149 def : T2Pat<(ARMWrapper tconstpool :$dst), (t2LEApcrel tconstpool :$dst)>;
1150 def : T2Pat<(ARMWrapperJT tjumptable:$dst, imm:$id),
1151 (t2LEApcrelJT tjumptable:$dst, imm:$id)>;
1153 // Large immediate handling.
1155 def : T2Pat<(i32 imm:$src),
1156 (t2MOVTi16 (t2MOVi16 (t2_lo16 imm:$src)), (t2_hi16 imm:$src))>;