1 //===- ARMInstrInfo.td - Target Description for ARM Target -*- 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 //===----------------------------------------------------------------------===//
10 // This file describes the ARM instructions in TableGen format.
12 //===----------------------------------------------------------------------===//
14 //===----------------------------------------------------------------------===//
15 // ARM specific DAG Nodes.
19 def SDT_ARMCallSeqStart : SDCallSeqStart<[ SDTCisVT<0, i32> ]>;
20 def SDT_ARMCallSeqEnd : SDCallSeqEnd<[ SDTCisVT<0, i32>, SDTCisVT<1, i32> ]>;
22 def SDT_ARMSaveCallPC : SDTypeProfile<0, 1, []>;
24 def SDT_ARMcall : SDTypeProfile<0, -1, [SDTCisInt<0>]>;
26 def SDT_ARMCMov : SDTypeProfile<1, 3,
27 [SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>,
30 def SDT_ARMBrcond : SDTypeProfile<0, 2,
31 [SDTCisVT<0, OtherVT>, SDTCisVT<1, i32>]>;
33 def SDT_ARMBrJT : SDTypeProfile<0, 3,
34 [SDTCisPtrTy<0>, SDTCisVT<1, i32>,
37 def SDT_ARMBr2JT : SDTypeProfile<0, 4,
38 [SDTCisPtrTy<0>, SDTCisVT<1, i32>,
39 SDTCisVT<2, i32>, SDTCisVT<3, i32>]>;
41 def SDT_ARMCmp : SDTypeProfile<0, 2, [SDTCisSameAs<0, 1>]>;
43 def SDT_ARMPICAdd : SDTypeProfile<1, 2, [SDTCisSameAs<0, 1>,
44 SDTCisPtrTy<1>, SDTCisVT<2, i32>]>;
46 def SDT_ARMThreadPointer : SDTypeProfile<1, 0, [SDTCisPtrTy<0>]>;
47 def SDT_ARMEH_SJLJ_Setjmp : SDTypeProfile<1, 1, [SDTCisInt<0>, SDTCisPtrTy<1>]>;
50 def ARMWrapper : SDNode<"ARMISD::Wrapper", SDTIntUnaryOp>;
51 def ARMWrapperJT : SDNode<"ARMISD::WrapperJT", SDTIntBinOp>;
53 def ARMcallseq_start : SDNode<"ISD::CALLSEQ_START", SDT_ARMCallSeqStart,
54 [SDNPHasChain, SDNPOutFlag]>;
55 def ARMcallseq_end : SDNode<"ISD::CALLSEQ_END", SDT_ARMCallSeqEnd,
56 [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
58 def ARMcall : SDNode<"ARMISD::CALL", SDT_ARMcall,
59 [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
60 def ARMcall_pred : SDNode<"ARMISD::CALL_PRED", SDT_ARMcall,
61 [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
62 def ARMcall_nolink : SDNode<"ARMISD::CALL_NOLINK", SDT_ARMcall,
63 [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
65 def ARMretflag : SDNode<"ARMISD::RET_FLAG", SDTNone,
66 [SDNPHasChain, SDNPOptInFlag]>;
68 def ARMcmov : SDNode<"ARMISD::CMOV", SDT_ARMCMov,
70 def ARMcneg : SDNode<"ARMISD::CNEG", SDT_ARMCMov,
73 def ARMbrcond : SDNode<"ARMISD::BRCOND", SDT_ARMBrcond,
74 [SDNPHasChain, SDNPInFlag, SDNPOutFlag]>;
76 def ARMbrjt : SDNode<"ARMISD::BR_JT", SDT_ARMBrJT,
78 def ARMbr2jt : SDNode<"ARMISD::BR2_JT", SDT_ARMBr2JT,
81 def ARMcmp : SDNode<"ARMISD::CMP", SDT_ARMCmp,
84 def ARMcmpZ : SDNode<"ARMISD::CMPZ", SDT_ARMCmp,
85 [SDNPOutFlag,SDNPCommutative]>;
87 def ARMpic_add : SDNode<"ARMISD::PIC_ADD", SDT_ARMPICAdd>;
89 def ARMsrl_flag : SDNode<"ARMISD::SRL_FLAG", SDTIntUnaryOp, [SDNPOutFlag]>;
90 def ARMsra_flag : SDNode<"ARMISD::SRA_FLAG", SDTIntUnaryOp, [SDNPOutFlag]>;
91 def ARMrrx : SDNode<"ARMISD::RRX" , SDTIntUnaryOp, [SDNPInFlag ]>;
93 def ARMthread_pointer: SDNode<"ARMISD::THREAD_POINTER", SDT_ARMThreadPointer>;
94 def ARMeh_sjlj_setjmp: SDNode<"ARMISD::EH_SJLJ_SETJMP", SDT_ARMEH_SJLJ_Setjmp>;
96 //===----------------------------------------------------------------------===//
97 // ARM Instruction Predicate Definitions.
99 def HasV5T : Predicate<"Subtarget->hasV5TOps()">;
100 def HasV5TE : Predicate<"Subtarget->hasV5TEOps()">;
101 def HasV6 : Predicate<"Subtarget->hasV6Ops()">;
102 def HasV6T2 : Predicate<"Subtarget->hasV6T2Ops()">;
103 def NoV6T2 : Predicate<"!Subtarget->hasV6T2Ops()">;
104 def HasV7 : Predicate<"Subtarget->hasV7Ops()">;
105 def HasVFP2 : Predicate<"Subtarget->hasVFP2()">;
106 def HasVFP3 : Predicate<"Subtarget->hasVFP3()">;
107 def HasNEON : Predicate<"Subtarget->hasNEON()">;
108 def UseNEONForFP : Predicate<"Subtarget->useNEONForSinglePrecisionFP()">;
109 def DontUseNEONForFP : Predicate<"!Subtarget->useNEONForSinglePrecisionFP()">;
110 def IsThumb : Predicate<"Subtarget->isThumb()">;
111 def IsThumb1Only : Predicate<"Subtarget->isThumb1Only()">;
112 def IsThumb2 : Predicate<"Subtarget->isThumb2()">;
113 def IsARM : Predicate<"!Subtarget->isThumb()">;
114 def IsDarwin : Predicate<"Subtarget->isTargetDarwin()">;
115 def IsNotDarwin : Predicate<"!Subtarget->isTargetDarwin()">;
116 def CarryDefIsUnused : Predicate<"!N.getNode()->hasAnyUseOfValue(1)">;
117 def CarryDefIsUsed : Predicate<"N.getNode()->hasAnyUseOfValue(1)">;
119 //===----------------------------------------------------------------------===//
120 // ARM Flag Definitions.
122 class RegConstraint<string C> {
123 string Constraints = C;
126 //===----------------------------------------------------------------------===//
127 // ARM specific transformation functions and pattern fragments.
130 // so_imm_neg_XFORM - Return a so_imm value packed into the format described for
131 // so_imm_neg def below.
132 def so_imm_neg_XFORM : SDNodeXForm<imm, [{
133 return CurDAG->getTargetConstant(-(int)N->getZExtValue(), MVT::i32);
136 // so_imm_not_XFORM - Return a so_imm value packed into the format described for
137 // so_imm_not def below.
138 def so_imm_not_XFORM : SDNodeXForm<imm, [{
139 return CurDAG->getTargetConstant(~(int)N->getZExtValue(), MVT::i32);
142 // rot_imm predicate - True if the 32-bit immediate is equal to 8, 16, or 24.
143 def rot_imm : PatLeaf<(i32 imm), [{
144 int32_t v = (int32_t)N->getZExtValue();
145 return v == 8 || v == 16 || v == 24;
148 /// imm1_15 predicate - True if the 32-bit immediate is in the range [1,15].
149 def imm1_15 : PatLeaf<(i32 imm), [{
150 return (int32_t)N->getZExtValue() >= 1 && (int32_t)N->getZExtValue() < 16;
153 /// imm16_31 predicate - True if the 32-bit immediate is in the range [16,31].
154 def imm16_31 : PatLeaf<(i32 imm), [{
155 return (int32_t)N->getZExtValue() >= 16 && (int32_t)N->getZExtValue() < 32;
160 return ARM_AM::getSOImmVal(-(int)N->getZExtValue()) != -1;
161 }], so_imm_neg_XFORM>;
165 return ARM_AM::getSOImmVal(~(int)N->getZExtValue()) != -1;
166 }], so_imm_not_XFORM>;
168 // sext_16_node predicate - True if the SDNode is sign-extended 16 or more bits.
169 def sext_16_node : PatLeaf<(i32 GPR:$a), [{
170 return CurDAG->ComputeNumSignBits(SDValue(N,0)) >= 17;
173 /// bf_inv_mask_imm predicate - An AND mask to clear an arbitrary width bitfield
175 def bf_inv_mask_imm : Operand<i32>,
177 uint32_t v = (uint32_t)N->getZExtValue();
180 // there can be 1's on either or both "outsides", all the "inside"
182 unsigned int lsb = 0, msb = 31;
183 while (v & (1 << msb)) --msb;
184 while (v & (1 << lsb)) ++lsb;
185 for (unsigned int i = lsb; i <= msb; ++i) {
191 let PrintMethod = "printBitfieldInvMaskImmOperand";
194 /// Split a 32-bit immediate into two 16 bit parts.
195 def lo16 : SDNodeXForm<imm, [{
196 return CurDAG->getTargetConstant((uint32_t)N->getZExtValue() & 0xffff,
200 def hi16 : SDNodeXForm<imm, [{
201 return CurDAG->getTargetConstant((uint32_t)N->getZExtValue() >> 16, MVT::i32);
204 def lo16AllZero : PatLeaf<(i32 imm), [{
205 // Returns true if all low 16-bits are 0.
206 return (((uint32_t)N->getZExtValue()) & 0xFFFFUL) == 0;
209 /// imm0_65535 predicate - True if the 32-bit immediate is in the range
211 def imm0_65535 : PatLeaf<(i32 imm), [{
212 return (uint32_t)N->getZExtValue() < 65536;
215 class BinOpFrag<dag res> : PatFrag<(ops node:$LHS, node:$RHS), res>;
216 class UnOpFrag <dag res> : PatFrag<(ops node:$Src), res>;
218 //===----------------------------------------------------------------------===//
219 // Operand Definitions.
223 def brtarget : Operand<OtherVT>;
225 // A list of registers separated by comma. Used by load/store multiple.
226 def reglist : Operand<i32> {
227 let PrintMethod = "printRegisterList";
230 // An operand for the CONSTPOOL_ENTRY pseudo-instruction.
231 def cpinst_operand : Operand<i32> {
232 let PrintMethod = "printCPInstOperand";
235 def jtblock_operand : Operand<i32> {
236 let PrintMethod = "printJTBlockOperand";
238 def jt2block_operand : Operand<i32> {
239 let PrintMethod = "printJT2BlockOperand";
243 def pclabel : Operand<i32> {
244 let PrintMethod = "printPCLabel";
247 // shifter_operand operands: so_reg and so_imm.
248 def so_reg : Operand<i32>, // reg reg imm
249 ComplexPattern<i32, 3, "SelectShifterOperandReg",
250 [shl,srl,sra,rotr]> {
251 let PrintMethod = "printSORegOperand";
252 let MIOperandInfo = (ops GPR, GPR, i32imm);
255 // so_imm - Match a 32-bit shifter_operand immediate operand, which is an
256 // 8-bit immediate rotated by an arbitrary number of bits. so_imm values are
257 // represented in the imm field in the same 12-bit form that they are encoded
258 // into so_imm instructions: the 8-bit immediate is the least significant bits
259 // [bits 0-7], the 4-bit shift amount is the next 4 bits [bits 8-11].
260 def so_imm : Operand<i32>,
262 return ARM_AM::getSOImmVal(N->getZExtValue()) != -1;
264 let PrintMethod = "printSOImmOperand";
267 // Break so_imm's up into two pieces. This handles immediates with up to 16
268 // bits set in them. This uses so_imm2part to match and so_imm2part_[12] to
269 // get the first/second pieces.
270 def so_imm2part : Operand<i32>,
272 return ARM_AM::isSOImmTwoPartVal((unsigned)N->getZExtValue());
274 let PrintMethod = "printSOImm2PartOperand";
277 def so_imm2part_1 : SDNodeXForm<imm, [{
278 unsigned V = ARM_AM::getSOImmTwoPartFirst((unsigned)N->getZExtValue());
279 return CurDAG->getTargetConstant(V, MVT::i32);
282 def so_imm2part_2 : SDNodeXForm<imm, [{
283 unsigned V = ARM_AM::getSOImmTwoPartSecond((unsigned)N->getZExtValue());
284 return CurDAG->getTargetConstant(V, MVT::i32);
287 /// imm0_31 predicate - True if the 32-bit immediate is in the range [0,31].
288 def imm0_31 : Operand<i32>, PatLeaf<(imm), [{
289 return (int32_t)N->getZExtValue() < 32;
292 // Define ARM specific addressing modes.
294 // addrmode2 := reg +/- reg shop imm
295 // addrmode2 := reg +/- imm12
297 def addrmode2 : Operand<i32>,
298 ComplexPattern<i32, 3, "SelectAddrMode2", []> {
299 let PrintMethod = "printAddrMode2Operand";
300 let MIOperandInfo = (ops GPR:$base, GPR:$offsreg, i32imm:$offsimm);
303 def am2offset : Operand<i32>,
304 ComplexPattern<i32, 2, "SelectAddrMode2Offset", []> {
305 let PrintMethod = "printAddrMode2OffsetOperand";
306 let MIOperandInfo = (ops GPR, i32imm);
309 // addrmode3 := reg +/- reg
310 // addrmode3 := reg +/- imm8
312 def addrmode3 : Operand<i32>,
313 ComplexPattern<i32, 3, "SelectAddrMode3", []> {
314 let PrintMethod = "printAddrMode3Operand";
315 let MIOperandInfo = (ops GPR:$base, GPR:$offsreg, i32imm:$offsimm);
318 def am3offset : Operand<i32>,
319 ComplexPattern<i32, 2, "SelectAddrMode3Offset", []> {
320 let PrintMethod = "printAddrMode3OffsetOperand";
321 let MIOperandInfo = (ops GPR, i32imm);
324 // addrmode4 := reg, <mode|W>
326 def addrmode4 : Operand<i32>,
327 ComplexPattern<i32, 2, "SelectAddrMode4", []> {
328 let PrintMethod = "printAddrMode4Operand";
329 let MIOperandInfo = (ops GPR, i32imm);
332 // addrmode5 := reg +/- imm8*4
334 def addrmode5 : Operand<i32>,
335 ComplexPattern<i32, 2, "SelectAddrMode5", []> {
336 let PrintMethod = "printAddrMode5Operand";
337 let MIOperandInfo = (ops GPR, i32imm);
340 // addrmode6 := reg with optional writeback
342 def addrmode6 : Operand<i32>,
343 ComplexPattern<i32, 3, "SelectAddrMode6", []> {
344 let PrintMethod = "printAddrMode6Operand";
345 let MIOperandInfo = (ops GPR:$addr, GPR:$upd, i32imm);
348 // addrmodepc := pc + reg
350 def addrmodepc : Operand<i32>,
351 ComplexPattern<i32, 2, "SelectAddrModePC", []> {
352 let PrintMethod = "printAddrModePCOperand";
353 let MIOperandInfo = (ops GPR, i32imm);
356 def nohash_imm : Operand<i32> {
357 let PrintMethod = "printNoHashImmediate";
360 //===----------------------------------------------------------------------===//
362 include "ARMInstrFormats.td"
364 //===----------------------------------------------------------------------===//
365 // Multiclass helpers...
368 /// AsI1_bin_irs - Defines a set of (op r, {so_imm|r|so_reg}) patterns for a
369 /// binop that produces a value.
370 multiclass AsI1_bin_irs<bits<4> opcod, string opc, PatFrag opnode,
371 bit Commutable = 0> {
372 def ri : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
373 IIC_iALUi, opc, "\t$dst, $a, $b",
374 [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]> {
377 def rr : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm,
378 IIC_iALUr, opc, "\t$dst, $a, $b",
379 [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]> {
380 let Inst{11-4} = 0b00000000;
382 let isCommutable = Commutable;
384 def rs : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
385 IIC_iALUsr, opc, "\t$dst, $a, $b",
386 [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]> {
391 /// AI1_bin_s_irs - Similar to AsI1_bin_irs except it sets the 's' bit so the
392 /// instruction modifies the CPSR register.
393 let Defs = [CPSR] in {
394 multiclass AI1_bin_s_irs<bits<4> opcod, string opc, PatFrag opnode,
395 bit Commutable = 0> {
396 def ri : AI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
397 IIC_iALUi, opc, "s\t$dst, $a, $b",
398 [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]> {
402 def rr : AI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm,
403 IIC_iALUr, opc, "s\t$dst, $a, $b",
404 [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]> {
405 let isCommutable = Commutable;
406 let Inst{11-4} = 0b00000000;
410 def rs : AI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
411 IIC_iALUsr, opc, "s\t$dst, $a, $b",
412 [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]> {
419 /// AI1_cmp_irs - Defines a set of (op r, {so_imm|r|so_reg}) cmp / test
420 /// patterns. Similar to AsI1_bin_irs except the instruction does not produce
421 /// a explicit result, only implicitly set CPSR.
422 let Defs = [CPSR] in {
423 multiclass AI1_cmp_irs<bits<4> opcod, string opc, PatFrag opnode,
424 bit Commutable = 0> {
425 def ri : AI1<opcod, (outs), (ins GPR:$a, so_imm:$b), DPFrm, IIC_iCMPi,
427 [(opnode GPR:$a, so_imm:$b)]> {
431 def rr : AI1<opcod, (outs), (ins GPR:$a, GPR:$b), DPFrm, IIC_iCMPr,
433 [(opnode GPR:$a, GPR:$b)]> {
434 let Inst{11-4} = 0b00000000;
437 let isCommutable = Commutable;
439 def rs : AI1<opcod, (outs), (ins GPR:$a, so_reg:$b), DPSoRegFrm, IIC_iCMPsr,
441 [(opnode GPR:$a, so_reg:$b)]> {
448 /// AI_unary_rrot - A unary operation with two forms: one whose operand is a
449 /// register and one whose operand is a register rotated by 8/16/24.
450 /// FIXME: Remove the 'r' variant. Its rot_imm is zero.
451 multiclass AI_unary_rrot<bits<8> opcod, string opc, PatFrag opnode> {
452 def r : AExtI<opcod, (outs GPR:$dst), (ins GPR:$src),
453 IIC_iUNAr, opc, "\t$dst, $src",
454 [(set GPR:$dst, (opnode GPR:$src))]>,
455 Requires<[IsARM, HasV6]> {
456 let Inst{11-10} = 0b00;
457 let Inst{19-16} = 0b1111;
459 def r_rot : AExtI<opcod, (outs GPR:$dst), (ins GPR:$src, i32imm:$rot),
460 IIC_iUNAsi, opc, "\t$dst, $src, ror $rot",
461 [(set GPR:$dst, (opnode (rotr GPR:$src, rot_imm:$rot)))]>,
462 Requires<[IsARM, HasV6]> {
463 let Inst{19-16} = 0b1111;
467 /// AI_bin_rrot - A binary operation with two forms: one whose operand is a
468 /// register and one whose operand is a register rotated by 8/16/24.
469 multiclass AI_bin_rrot<bits<8> opcod, string opc, PatFrag opnode> {
470 def rr : AExtI<opcod, (outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS),
471 IIC_iALUr, opc, "\t$dst, $LHS, $RHS",
472 [(set GPR:$dst, (opnode GPR:$LHS, GPR:$RHS))]>,
473 Requires<[IsARM, HasV6]> {
474 let Inst{11-10} = 0b00;
476 def rr_rot : AExtI<opcod, (outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS, i32imm:$rot),
477 IIC_iALUsi, opc, "\t$dst, $LHS, $RHS, ror $rot",
478 [(set GPR:$dst, (opnode GPR:$LHS,
479 (rotr GPR:$RHS, rot_imm:$rot)))]>,
480 Requires<[IsARM, HasV6]>;
483 /// AI1_adde_sube_irs - Define instructions and patterns for adde and sube.
484 let Uses = [CPSR] in {
485 multiclass AI1_adde_sube_irs<bits<4> opcod, string opc, PatFrag opnode,
486 bit Commutable = 0> {
487 def ri : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
488 DPFrm, IIC_iALUi, opc, "\t$dst, $a, $b",
489 [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]>,
490 Requires<[IsARM, CarryDefIsUnused]> {
493 def rr : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
494 DPFrm, IIC_iALUr, opc, "\t$dst, $a, $b",
495 [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]>,
496 Requires<[IsARM, CarryDefIsUnused]> {
497 let isCommutable = Commutable;
498 let Inst{11-4} = 0b00000000;
501 def rs : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
502 DPSoRegFrm, IIC_iALUsr, opc, "\t$dst, $a, $b",
503 [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]>,
504 Requires<[IsARM, CarryDefIsUnused]> {
507 // Carry setting variants
508 def Sri : AXI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
509 DPFrm, IIC_iALUi, !strconcat(opc, "s\t$dst, $a, $b"),
510 [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]>,
511 Requires<[IsARM, CarryDefIsUsed]> {
516 def Srr : AXI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
517 DPFrm, IIC_iALUr, !strconcat(opc, "s\t$dst, $a, $b"),
518 [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]>,
519 Requires<[IsARM, CarryDefIsUsed]> {
521 let Inst{11-4} = 0b00000000;
525 def Srs : AXI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
526 DPSoRegFrm, IIC_iALUsr, !strconcat(opc, "s\t$dst, $a, $b"),
527 [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]>,
528 Requires<[IsARM, CarryDefIsUsed]> {
536 //===----------------------------------------------------------------------===//
538 //===----------------------------------------------------------------------===//
540 //===----------------------------------------------------------------------===//
541 // Miscellaneous Instructions.
544 /// CONSTPOOL_ENTRY - This instruction represents a floating constant pool in
545 /// the function. The first operand is the ID# for this instruction, the second
546 /// is the index into the MachineConstantPool that this is, the third is the
547 /// size in bytes of this constant pool entry.
548 let neverHasSideEffects = 1, isNotDuplicable = 1 in
549 def CONSTPOOL_ENTRY :
550 PseudoInst<(outs), (ins cpinst_operand:$instid, cpinst_operand:$cpidx,
551 i32imm:$size), NoItinerary,
552 "${instid:label} ${cpidx:cpentry}", []>;
554 let Defs = [SP], Uses = [SP] in {
556 PseudoInst<(outs), (ins i32imm:$amt1, i32imm:$amt2, pred:$p), NoItinerary,
557 "@ ADJCALLSTACKUP $amt1",
558 [(ARMcallseq_end timm:$amt1, timm:$amt2)]>;
560 def ADJCALLSTACKDOWN :
561 PseudoInst<(outs), (ins i32imm:$amt, pred:$p), NoItinerary,
562 "@ ADJCALLSTACKDOWN $amt",
563 [(ARMcallseq_start timm:$amt)]>;
567 PseudoInst<(outs), (ins i32imm:$line, i32imm:$col, i32imm:$file), NoItinerary,
568 ".loc $file, $line, $col",
569 [(dwarf_loc (i32 imm:$line), (i32 imm:$col), (i32 imm:$file))]>;
572 // Address computation and loads and stores in PIC mode.
573 let isNotDuplicable = 1 in {
574 def PICADD : AXI1<0b0100, (outs GPR:$dst), (ins GPR:$a, pclabel:$cp, pred:$p),
575 Pseudo, IIC_iALUr, "\n$cp:\n\tadd$p\t$dst, pc, $a",
576 [(set GPR:$dst, (ARMpic_add GPR:$a, imm:$cp))]>;
578 let AddedComplexity = 10 in {
579 let canFoldAsLoad = 1 in
580 def PICLDR : AXI2ldw<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
581 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldr$p\t$dst, $addr",
582 [(set GPR:$dst, (load addrmodepc:$addr))]>;
584 def PICLDRH : AXI3ldh<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
585 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldr${p}h\t$dst, $addr",
586 [(set GPR:$dst, (zextloadi16 addrmodepc:$addr))]>;
588 def PICLDRB : AXI2ldb<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
589 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldr${p}b\t$dst, $addr",
590 [(set GPR:$dst, (zextloadi8 addrmodepc:$addr))]>;
592 def PICLDRSH : AXI3ldsh<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
593 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldr${p}sh\t$dst, $addr",
594 [(set GPR:$dst, (sextloadi16 addrmodepc:$addr))]>;
596 def PICLDRSB : AXI3ldsb<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
597 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldr${p}sb\t$dst, $addr",
598 [(set GPR:$dst, (sextloadi8 addrmodepc:$addr))]>;
600 let AddedComplexity = 10 in {
601 def PICSTR : AXI2stw<(outs), (ins GPR:$src, addrmodepc:$addr, pred:$p),
602 Pseudo, IIC_iStorer, "\n${addr:label}:\n\tstr$p\t$src, $addr",
603 [(store GPR:$src, addrmodepc:$addr)]>;
605 def PICSTRH : AXI3sth<(outs), (ins GPR:$src, addrmodepc:$addr, pred:$p),
606 Pseudo, IIC_iStorer, "\n${addr:label}:\n\tstr${p}h\t$src, $addr",
607 [(truncstorei16 GPR:$src, addrmodepc:$addr)]>;
609 def PICSTRB : AXI2stb<(outs), (ins GPR:$src, addrmodepc:$addr, pred:$p),
610 Pseudo, IIC_iStorer, "\n${addr:label}:\n\tstr${p}b\t$src, $addr",
611 [(truncstorei8 GPR:$src, addrmodepc:$addr)]>;
613 } // isNotDuplicable = 1
616 // LEApcrel - Load a pc-relative address into a register without offending the
618 def LEApcrel : AXI1<0x0, (outs GPR:$dst), (ins i32imm:$label, pred:$p),
620 !strconcat(!strconcat(".set ${:private}PCRELV${:uid}, ($label-(",
621 "${:private}PCRELL${:uid}+8))\n"),
622 !strconcat("${:private}PCRELL${:uid}:\n\t",
623 "add$p\t$dst, pc, #${:private}PCRELV${:uid}")),
626 def LEApcrelJT : AXI1<0x0, (outs GPR:$dst),
627 (ins i32imm:$label, nohash_imm:$id, pred:$p),
629 !strconcat(!strconcat(".set ${:private}PCRELV${:uid}, "
631 "${:private}PCRELL${:uid}+8))\n"),
632 !strconcat("${:private}PCRELL${:uid}:\n\t",
633 "add$p\t$dst, pc, #${:private}PCRELV${:uid}")),
638 //===----------------------------------------------------------------------===//
639 // Control Flow Instructions.
642 let isReturn = 1, isTerminator = 1, isBarrier = 1 in
643 def BX_RET : AI<(outs), (ins), BrMiscFrm, IIC_Br,
644 "bx", "\tlr", [(ARMretflag)]> {
645 let Inst{7-4} = 0b0001;
646 let Inst{19-8} = 0b111111111111;
647 let Inst{27-20} = 0b00010010;
651 let isBranch = 1, isTerminator = 1, isBarrier = 1, isIndirectBranch = 1 in {
652 def BRIND : AXI<(outs), (ins GPR:$dst), BrMiscFrm, IIC_Br, "bx\t$dst",
653 [(brind GPR:$dst)]> {
654 let Inst{7-4} = 0b0001;
655 let Inst{19-8} = 0b111111111111;
656 let Inst{27-20} = 0b00010010;
660 // FIXME: remove when we have a way to marking a MI with these properties.
661 // FIXME: Should pc be an implicit operand like PICADD, etc?
662 let isReturn = 1, isTerminator = 1, isBarrier = 1, mayLoad = 1,
663 hasExtraDefRegAllocReq = 1 in
664 def LDM_RET : AXI4ld<(outs),
665 (ins addrmode4:$addr, pred:$p, reglist:$wb, variable_ops),
666 LdStMulFrm, IIC_Br, "ldm${p}${addr:submode}\t$addr, $wb",
669 // On non-Darwin platforms R9 is callee-saved.
671 Defs = [R0, R1, R2, R3, R12, LR,
672 D0, D1, D2, D3, D4, D5, D6, D7,
673 D16, D17, D18, D19, D20, D21, D22, D23,
674 D24, D25, D26, D27, D28, D29, D30, D31, CPSR, FPSCR] in {
675 def BL : ABXI<0b1011, (outs), (ins i32imm:$func, variable_ops),
676 IIC_Br, "bl\t${func:call}",
677 [(ARMcall tglobaladdr:$func)]>,
678 Requires<[IsARM, IsNotDarwin]> {
679 let Inst{31-28} = 0b1110;
682 def BL_pred : ABI<0b1011, (outs), (ins i32imm:$func, variable_ops),
683 IIC_Br, "bl", "\t${func:call}",
684 [(ARMcall_pred tglobaladdr:$func)]>,
685 Requires<[IsARM, IsNotDarwin]>;
688 def BLX : AXI<(outs), (ins GPR:$func, variable_ops), BrMiscFrm,
689 IIC_Br, "blx\t$func",
690 [(ARMcall GPR:$func)]>,
691 Requires<[IsARM, HasV5T, IsNotDarwin]> {
692 let Inst{7-4} = 0b0011;
693 let Inst{19-8} = 0b111111111111;
694 let Inst{27-20} = 0b00010010;
698 def BX : ABXIx2<(outs), (ins GPR:$func, variable_ops),
699 IIC_Br, "mov\tlr, pc\n\tbx\t$func",
700 [(ARMcall_nolink GPR:$func)]>,
701 Requires<[IsARM, IsNotDarwin]> {
702 let Inst{7-4} = 0b0001;
703 let Inst{19-8} = 0b111111111111;
704 let Inst{27-20} = 0b00010010;
708 // On Darwin R9 is call-clobbered.
710 Defs = [R0, R1, R2, R3, R9, R12, LR,
711 D0, D1, D2, D3, D4, D5, D6, D7,
712 D16, D17, D18, D19, D20, D21, D22, D23,
713 D24, D25, D26, D27, D28, D29, D30, D31, CPSR, FPSCR] in {
714 def BLr9 : ABXI<0b1011, (outs), (ins i32imm:$func, variable_ops),
715 IIC_Br, "bl\t${func:call}",
716 [(ARMcall tglobaladdr:$func)]>, Requires<[IsARM, IsDarwin]> {
717 let Inst{31-28} = 0b1110;
720 def BLr9_pred : ABI<0b1011, (outs), (ins i32imm:$func, variable_ops),
721 IIC_Br, "bl", "\t${func:call}",
722 [(ARMcall_pred tglobaladdr:$func)]>,
723 Requires<[IsARM, IsDarwin]>;
726 def BLXr9 : AXI<(outs), (ins GPR:$func, variable_ops), BrMiscFrm,
727 IIC_Br, "blx\t$func",
728 [(ARMcall GPR:$func)]>, Requires<[IsARM, HasV5T, IsDarwin]> {
729 let Inst{7-4} = 0b0011;
730 let Inst{19-8} = 0b111111111111;
731 let Inst{27-20} = 0b00010010;
735 def BXr9 : ABXIx2<(outs), (ins GPR:$func, variable_ops),
736 IIC_Br, "mov\tlr, pc\n\tbx\t$func",
737 [(ARMcall_nolink GPR:$func)]>, Requires<[IsARM, IsDarwin]> {
738 let Inst{7-4} = 0b0001;
739 let Inst{19-8} = 0b111111111111;
740 let Inst{27-20} = 0b00010010;
744 let isBranch = 1, isTerminator = 1 in {
745 // B is "predicable" since it can be xformed into a Bcc.
746 let isBarrier = 1 in {
747 let isPredicable = 1 in
748 def B : ABXI<0b1010, (outs), (ins brtarget:$target), IIC_Br,
749 "b\t$target", [(br bb:$target)]>;
751 let isNotDuplicable = 1, isIndirectBranch = 1 in {
752 def BR_JTr : JTI<(outs), (ins GPR:$target, jtblock_operand:$jt, i32imm:$id),
753 IIC_Br, "mov\tpc, $target \n$jt",
754 [(ARMbrjt GPR:$target, tjumptable:$jt, imm:$id)]> {
755 let Inst{20} = 0; // S Bit
756 let Inst{24-21} = 0b1101;
757 let Inst{27-25} = 0b000;
759 def BR_JTm : JTI<(outs),
760 (ins addrmode2:$target, jtblock_operand:$jt, i32imm:$id),
761 IIC_Br, "ldr\tpc, $target \n$jt",
762 [(ARMbrjt (i32 (load addrmode2:$target)), tjumptable:$jt,
764 let Inst{20} = 1; // L bit
765 let Inst{21} = 0; // W bit
766 let Inst{22} = 0; // B bit
767 let Inst{24} = 1; // P bit
768 let Inst{27-25} = 0b011;
770 def BR_JTadd : JTI<(outs),
771 (ins GPR:$target, GPR:$idx, jtblock_operand:$jt, i32imm:$id),
772 IIC_Br, "add\tpc, $target, $idx \n$jt",
773 [(ARMbrjt (add GPR:$target, GPR:$idx), tjumptable:$jt,
775 let Inst{20} = 0; // S bit
776 let Inst{24-21} = 0b0100;
777 let Inst{27-25} = 0b000;
779 } // isNotDuplicable = 1, isIndirectBranch = 1
782 // FIXME: should be able to write a pattern for ARMBrcond, but can't use
783 // a two-value operand where a dag node expects two operands. :(
784 def Bcc : ABI<0b1010, (outs), (ins brtarget:$target),
785 IIC_Br, "b", "\t$target",
786 [/*(ARMbrcond bb:$target, imm:$cc, CCR:$ccr)*/]>;
789 //===----------------------------------------------------------------------===//
790 // Load / store Instructions.
794 let canFoldAsLoad = 1, isReMaterializable = 1 in
795 def LDR : AI2ldw<(outs GPR:$dst), (ins addrmode2:$addr), LdFrm, IIC_iLoadr,
796 "ldr", "\t$dst, $addr",
797 [(set GPR:$dst, (load addrmode2:$addr))]>;
799 // Special LDR for loads from non-pc-relative constpools.
800 let canFoldAsLoad = 1, mayLoad = 1, isReMaterializable = 1 in
801 def LDRcp : AI2ldw<(outs GPR:$dst), (ins addrmode2:$addr), LdFrm, IIC_iLoadr,
802 "ldr", "\t$dst, $addr", []>;
804 // Loads with zero extension
805 def LDRH : AI3ldh<(outs GPR:$dst), (ins addrmode3:$addr), LdMiscFrm,
806 IIC_iLoadr, "ldr", "h\t$dst, $addr",
807 [(set GPR:$dst, (zextloadi16 addrmode3:$addr))]>;
809 def LDRB : AI2ldb<(outs GPR:$dst), (ins addrmode2:$addr), LdFrm,
810 IIC_iLoadr, "ldr", "b\t$dst, $addr",
811 [(set GPR:$dst, (zextloadi8 addrmode2:$addr))]>;
813 // Loads with sign extension
814 def LDRSH : AI3ldsh<(outs GPR:$dst), (ins addrmode3:$addr), LdMiscFrm,
815 IIC_iLoadr, "ldr", "sh\t$dst, $addr",
816 [(set GPR:$dst, (sextloadi16 addrmode3:$addr))]>;
818 def LDRSB : AI3ldsb<(outs GPR:$dst), (ins addrmode3:$addr), LdMiscFrm,
819 IIC_iLoadr, "ldr", "sb\t$dst, $addr",
820 [(set GPR:$dst, (sextloadi8 addrmode3:$addr))]>;
822 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in {
824 def LDRD : AI3ldd<(outs GPR:$dst1, GPR:$dst2), (ins addrmode3:$addr), LdMiscFrm,
825 IIC_iLoadr, "ldr", "d\t$dst1, $addr",
826 []>, Requires<[IsARM, HasV5TE]>;
829 def LDR_PRE : AI2ldwpr<(outs GPR:$dst, GPR:$base_wb),
830 (ins addrmode2:$addr), LdFrm, IIC_iLoadru,
831 "ldr", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
833 def LDR_POST : AI2ldwpo<(outs GPR:$dst, GPR:$base_wb),
834 (ins GPR:$base, am2offset:$offset), LdFrm, IIC_iLoadru,
835 "ldr", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
837 def LDRH_PRE : AI3ldhpr<(outs GPR:$dst, GPR:$base_wb),
838 (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadru,
839 "ldr", "h\t$dst, $addr!", "$addr.base = $base_wb", []>;
841 def LDRH_POST : AI3ldhpo<(outs GPR:$dst, GPR:$base_wb),
842 (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
843 "ldr", "h\t$dst, [$base], $offset", "$base = $base_wb", []>;
845 def LDRB_PRE : AI2ldbpr<(outs GPR:$dst, GPR:$base_wb),
846 (ins addrmode2:$addr), LdFrm, IIC_iLoadru,
847 "ldr", "b\t$dst, $addr!", "$addr.base = $base_wb", []>;
849 def LDRB_POST : AI2ldbpo<(outs GPR:$dst, GPR:$base_wb),
850 (ins GPR:$base,am2offset:$offset), LdFrm, IIC_iLoadru,
851 "ldr", "b\t$dst, [$base], $offset", "$base = $base_wb", []>;
853 def LDRSH_PRE : AI3ldshpr<(outs GPR:$dst, GPR:$base_wb),
854 (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadru,
855 "ldr", "sh\t$dst, $addr!", "$addr.base = $base_wb", []>;
857 def LDRSH_POST: AI3ldshpo<(outs GPR:$dst, GPR:$base_wb),
858 (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
859 "ldr", "sh\t$dst, [$base], $offset", "$base = $base_wb", []>;
861 def LDRSB_PRE : AI3ldsbpr<(outs GPR:$dst, GPR:$base_wb),
862 (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadru,
863 "ldr", "sb\t$dst, $addr!", "$addr.base = $base_wb", []>;
865 def LDRSB_POST: AI3ldsbpo<(outs GPR:$dst, GPR:$base_wb),
866 (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
867 "ldr", "sb\t$dst, [$base], $offset", "$base = $base_wb", []>;
871 def STR : AI2stw<(outs), (ins GPR:$src, addrmode2:$addr), StFrm, IIC_iStorer,
872 "str", "\t$src, $addr",
873 [(store GPR:$src, addrmode2:$addr)]>;
875 // Stores with truncate
876 def STRH : AI3sth<(outs), (ins GPR:$src, addrmode3:$addr), StMiscFrm, IIC_iStorer,
877 "str", "h\t$src, $addr",
878 [(truncstorei16 GPR:$src, addrmode3:$addr)]>;
880 def STRB : AI2stb<(outs), (ins GPR:$src, addrmode2:$addr), StFrm, IIC_iStorer,
881 "str", "b\t$src, $addr",
882 [(truncstorei8 GPR:$src, addrmode2:$addr)]>;
885 let mayStore = 1, hasExtraSrcRegAllocReq = 1 in
886 def STRD : AI3std<(outs), (ins GPR:$src1, GPR:$src2, addrmode3:$addr),
887 StMiscFrm, IIC_iStorer,
888 "str", "d\t$src1, $addr", []>, Requires<[IsARM, HasV5TE]>;
891 def STR_PRE : AI2stwpr<(outs GPR:$base_wb),
892 (ins GPR:$src, GPR:$base, am2offset:$offset),
894 "str", "\t$src, [$base, $offset]!", "$base = $base_wb",
896 (pre_store GPR:$src, GPR:$base, am2offset:$offset))]>;
898 def STR_POST : AI2stwpo<(outs GPR:$base_wb),
899 (ins GPR:$src, GPR:$base,am2offset:$offset),
901 "str", "\t$src, [$base], $offset", "$base = $base_wb",
903 (post_store GPR:$src, GPR:$base, am2offset:$offset))]>;
905 def STRH_PRE : AI3sthpr<(outs GPR:$base_wb),
906 (ins GPR:$src, GPR:$base,am3offset:$offset),
907 StMiscFrm, IIC_iStoreru,
908 "str", "h\t$src, [$base, $offset]!", "$base = $base_wb",
910 (pre_truncsti16 GPR:$src, GPR:$base,am3offset:$offset))]>;
912 def STRH_POST: AI3sthpo<(outs GPR:$base_wb),
913 (ins GPR:$src, GPR:$base,am3offset:$offset),
914 StMiscFrm, IIC_iStoreru,
915 "str", "h\t$src, [$base], $offset", "$base = $base_wb",
916 [(set GPR:$base_wb, (post_truncsti16 GPR:$src,
917 GPR:$base, am3offset:$offset))]>;
919 def STRB_PRE : AI2stbpr<(outs GPR:$base_wb),
920 (ins GPR:$src, GPR:$base,am2offset:$offset),
922 "str", "b\t$src, [$base, $offset]!", "$base = $base_wb",
923 [(set GPR:$base_wb, (pre_truncsti8 GPR:$src,
924 GPR:$base, am2offset:$offset))]>;
926 def STRB_POST: AI2stbpo<(outs GPR:$base_wb),
927 (ins GPR:$src, GPR:$base,am2offset:$offset),
929 "str", "b\t$src, [$base], $offset", "$base = $base_wb",
930 [(set GPR:$base_wb, (post_truncsti8 GPR:$src,
931 GPR:$base, am2offset:$offset))]>;
933 //===----------------------------------------------------------------------===//
934 // Load / store multiple Instructions.
937 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in
938 def LDM : AXI4ld<(outs),
939 (ins addrmode4:$addr, pred:$p, reglist:$wb, variable_ops),
940 LdStMulFrm, IIC_iLoadm, "ldm${p}${addr:submode}\t$addr, $wb",
943 let mayStore = 1, hasExtraSrcRegAllocReq = 1 in
944 def STM : AXI4st<(outs),
945 (ins addrmode4:$addr, pred:$p, reglist:$wb, variable_ops),
946 LdStMulFrm, IIC_iStorem, "stm${p}${addr:submode}\t$addr, $wb",
949 //===----------------------------------------------------------------------===//
950 // Move Instructions.
953 let neverHasSideEffects = 1 in
954 def MOVr : AsI1<0b1101, (outs GPR:$dst), (ins GPR:$src), DPFrm, IIC_iMOVr,
955 "mov", "\t$dst, $src", []>, UnaryDP {
956 let Inst{11-4} = 0b00000000;
960 def MOVs : AsI1<0b1101, (outs GPR:$dst), (ins so_reg:$src),
961 DPSoRegFrm, IIC_iMOVsr,
962 "mov", "\t$dst, $src", [(set GPR:$dst, so_reg:$src)]>, UnaryDP {
966 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
967 def MOVi : AsI1<0b1101, (outs GPR:$dst), (ins so_imm:$src), DPFrm, IIC_iMOVi,
968 "mov", "\t$dst, $src", [(set GPR:$dst, so_imm:$src)]>, UnaryDP {
972 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
973 def MOVi16 : AI1<0b1000, (outs GPR:$dst), (ins i32imm:$src),
975 "movw", "\t$dst, $src",
976 [(set GPR:$dst, imm0_65535:$src)]>,
977 Requires<[IsARM, HasV6T2]> {
982 let Constraints = "$src = $dst" in
983 def MOVTi16 : AI1<0b1010, (outs GPR:$dst), (ins GPR:$src, i32imm:$imm),
985 "movt", "\t$dst, $imm",
987 (or (and GPR:$src, 0xffff),
988 lo16AllZero:$imm))]>, UnaryDP,
989 Requires<[IsARM, HasV6T2]> {
994 def : ARMPat<(or GPR:$src, 0xffff0000), (MOVTi16 GPR:$src, 0xffff)>,
995 Requires<[IsARM, HasV6T2]>;
998 def MOVrx : AsI1<0b1101, (outs GPR:$dst), (ins GPR:$src), Pseudo, IIC_iMOVsi,
999 "mov", "\t$dst, $src, rrx",
1000 [(set GPR:$dst, (ARMrrx GPR:$src))]>, UnaryDP;
1002 // These aren't really mov instructions, but we have to define them this way
1003 // due to flag operands.
1005 let Defs = [CPSR] in {
1006 def MOVsrl_flag : AI1<0b1101, (outs GPR:$dst), (ins GPR:$src), Pseudo,
1007 IIC_iMOVsi, "mov", "s\t$dst, $src, lsr #1",
1008 [(set GPR:$dst, (ARMsrl_flag GPR:$src))]>, UnaryDP;
1009 def MOVsra_flag : AI1<0b1101, (outs GPR:$dst), (ins GPR:$src), Pseudo,
1010 IIC_iMOVsi, "mov", "s\t$dst, $src, asr #1",
1011 [(set GPR:$dst, (ARMsra_flag GPR:$src))]>, UnaryDP;
1014 //===----------------------------------------------------------------------===//
1015 // Extend Instructions.
1020 defm SXTB : AI_unary_rrot<0b01101010,
1021 "sxtb", UnOpFrag<(sext_inreg node:$Src, i8)>>;
1022 defm SXTH : AI_unary_rrot<0b01101011,
1023 "sxth", UnOpFrag<(sext_inreg node:$Src, i16)>>;
1025 defm SXTAB : AI_bin_rrot<0b01101010,
1026 "sxtab", BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS, i8))>>;
1027 defm SXTAH : AI_bin_rrot<0b01101011,
1028 "sxtah", BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS,i16))>>;
1030 // TODO: SXT(A){B|H}16
1034 let AddedComplexity = 16 in {
1035 defm UXTB : AI_unary_rrot<0b01101110,
1036 "uxtb" , UnOpFrag<(and node:$Src, 0x000000FF)>>;
1037 defm UXTH : AI_unary_rrot<0b01101111,
1038 "uxth" , UnOpFrag<(and node:$Src, 0x0000FFFF)>>;
1039 defm UXTB16 : AI_unary_rrot<0b01101100,
1040 "uxtb16", UnOpFrag<(and node:$Src, 0x00FF00FF)>>;
1042 def : ARMV6Pat<(and (shl GPR:$Src, (i32 8)), 0xFF00FF),
1043 (UXTB16r_rot GPR:$Src, 24)>;
1044 def : ARMV6Pat<(and (srl GPR:$Src, (i32 8)), 0xFF00FF),
1045 (UXTB16r_rot GPR:$Src, 8)>;
1047 defm UXTAB : AI_bin_rrot<0b01101110, "uxtab",
1048 BinOpFrag<(add node:$LHS, (and node:$RHS, 0x00FF))>>;
1049 defm UXTAH : AI_bin_rrot<0b01101111, "uxtah",
1050 BinOpFrag<(add node:$LHS, (and node:$RHS, 0xFFFF))>>;
1053 // This isn't safe in general, the add is two 16-bit units, not a 32-bit add.
1054 //defm UXTAB16 : xxx<"uxtab16", 0xff00ff>;
1056 // TODO: UXT(A){B|H}16
1058 def SBFX : I<(outs GPR:$dst),
1059 (ins GPR:$src, imm0_31:$lsb, imm0_31:$width),
1060 AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iALUi,
1061 "sbfx", "\t$dst, $src, $lsb, $width", "", []>,
1062 Requires<[IsARM, HasV6T2]> {
1063 let Inst{27-21} = 0b0111101;
1064 let Inst{6-4} = 0b101;
1067 def UBFX : I<(outs GPR:$dst),
1068 (ins GPR:$src, imm0_31:$lsb, imm0_31:$width),
1069 AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iALUi,
1070 "ubfx", "\t$dst, $src, $lsb, $width", "", []>,
1071 Requires<[IsARM, HasV6T2]> {
1072 let Inst{27-21} = 0b0111111;
1073 let Inst{6-4} = 0b101;
1076 //===----------------------------------------------------------------------===//
1077 // Arithmetic Instructions.
1080 defm ADD : AsI1_bin_irs<0b0100, "add",
1081 BinOpFrag<(add node:$LHS, node:$RHS)>, 1>;
1082 defm SUB : AsI1_bin_irs<0b0010, "sub",
1083 BinOpFrag<(sub node:$LHS, node:$RHS)>>;
1085 // ADD and SUB with 's' bit set.
1086 defm ADDS : AI1_bin_s_irs<0b0100, "add",
1087 BinOpFrag<(addc node:$LHS, node:$RHS)>>;
1088 defm SUBS : AI1_bin_s_irs<0b0010, "sub",
1089 BinOpFrag<(subc node:$LHS, node:$RHS)>>;
1091 defm ADC : AI1_adde_sube_irs<0b0101, "adc",
1092 BinOpFrag<(adde node:$LHS, node:$RHS)>, 1>;
1093 defm SBC : AI1_adde_sube_irs<0b0110, "sbc",
1094 BinOpFrag<(sube node:$LHS, node:$RHS)>>;
1096 // These don't define reg/reg forms, because they are handled above.
1097 def RSBri : AsI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
1098 IIC_iALUi, "rsb", "\t$dst, $a, $b",
1099 [(set GPR:$dst, (sub so_imm:$b, GPR:$a))]> {
1103 def RSBrs : AsI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
1104 IIC_iALUsr, "rsb", "\t$dst, $a, $b",
1105 [(set GPR:$dst, (sub so_reg:$b, GPR:$a))]> {
1109 // RSB with 's' bit set.
1110 let Defs = [CPSR] in {
1111 def RSBSri : AI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
1112 IIC_iALUi, "rsb", "s\t$dst, $a, $b",
1113 [(set GPR:$dst, (subc so_imm:$b, GPR:$a))]> {
1117 def RSBSrs : AI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
1118 IIC_iALUsr, "rsb", "s\t$dst, $a, $b",
1119 [(set GPR:$dst, (subc so_reg:$b, GPR:$a))]> {
1125 let Uses = [CPSR] in {
1126 def RSCri : AsI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
1127 DPFrm, IIC_iALUi, "rsc", "\t$dst, $a, $b",
1128 [(set GPR:$dst, (sube so_imm:$b, GPR:$a))]>,
1129 Requires<[IsARM, CarryDefIsUnused]> {
1132 def RSCrs : AsI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
1133 DPSoRegFrm, IIC_iALUsr, "rsc", "\t$dst, $a, $b",
1134 [(set GPR:$dst, (sube so_reg:$b, GPR:$a))]>,
1135 Requires<[IsARM, CarryDefIsUnused]> {
1140 // FIXME: Allow these to be predicated.
1141 let Defs = [CPSR], Uses = [CPSR] in {
1142 def RSCSri : AXI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
1143 DPFrm, IIC_iALUi, "rscs\t$dst, $a, $b",
1144 [(set GPR:$dst, (sube so_imm:$b, GPR:$a))]>,
1145 Requires<[IsARM, CarryDefIsUnused]> {
1149 def RSCSrs : AXI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
1150 DPSoRegFrm, IIC_iALUsr, "rscs\t$dst, $a, $b",
1151 [(set GPR:$dst, (sube so_reg:$b, GPR:$a))]>,
1152 Requires<[IsARM, CarryDefIsUnused]> {
1158 // (sub X, imm) gets canonicalized to (add X, -imm). Match this form.
1159 def : ARMPat<(add GPR:$src, so_imm_neg:$imm),
1160 (SUBri GPR:$src, so_imm_neg:$imm)>;
1162 //def : ARMPat<(addc GPR:$src, so_imm_neg:$imm),
1163 // (SUBSri GPR:$src, so_imm_neg:$imm)>;
1164 //def : ARMPat<(adde GPR:$src, so_imm_neg:$imm),
1165 // (SBCri GPR:$src, so_imm_neg:$imm)>;
1167 // Note: These are implemented in C++ code, because they have to generate
1168 // ADD/SUBrs instructions, which use a complex pattern that a xform function
1170 // (mul X, 2^n+1) -> (add (X << n), X)
1171 // (mul X, 2^n-1) -> (rsb X, (X << n))
1174 //===----------------------------------------------------------------------===//
1175 // Bitwise Instructions.
1178 defm AND : AsI1_bin_irs<0b0000, "and",
1179 BinOpFrag<(and node:$LHS, node:$RHS)>, 1>;
1180 defm ORR : AsI1_bin_irs<0b1100, "orr",
1181 BinOpFrag<(or node:$LHS, node:$RHS)>, 1>;
1182 defm EOR : AsI1_bin_irs<0b0001, "eor",
1183 BinOpFrag<(xor node:$LHS, node:$RHS)>, 1>;
1184 defm BIC : AsI1_bin_irs<0b1110, "bic",
1185 BinOpFrag<(and node:$LHS, (not node:$RHS))>>;
1187 def BFC : I<(outs GPR:$dst), (ins GPR:$src, bf_inv_mask_imm:$imm),
1188 AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iUNAsi,
1189 "bfc", "\t$dst, $imm", "$src = $dst",
1190 [(set GPR:$dst, (and GPR:$src, bf_inv_mask_imm:$imm))]>,
1191 Requires<[IsARM, HasV6T2]> {
1192 let Inst{27-21} = 0b0111110;
1193 let Inst{6-0} = 0b0011111;
1196 def MVNr : AsI1<0b1111, (outs GPR:$dst), (ins GPR:$src), DPFrm, IIC_iMOVr,
1197 "mvn", "\t$dst, $src",
1198 [(set GPR:$dst, (not GPR:$src))]>, UnaryDP {
1199 let Inst{11-4} = 0b00000000;
1201 def MVNs : AsI1<0b1111, (outs GPR:$dst), (ins so_reg:$src), DPSoRegFrm,
1202 IIC_iMOVsr, "mvn", "\t$dst, $src",
1203 [(set GPR:$dst, (not so_reg:$src))]>, UnaryDP;
1204 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
1205 def MVNi : AsI1<0b1111, (outs GPR:$dst), (ins so_imm:$imm), DPFrm,
1206 IIC_iMOVi, "mvn", "\t$dst, $imm",
1207 [(set GPR:$dst, so_imm_not:$imm)]>,UnaryDP {
1211 def : ARMPat<(and GPR:$src, so_imm_not:$imm),
1212 (BICri GPR:$src, so_imm_not:$imm)>;
1214 //===----------------------------------------------------------------------===//
1215 // Multiply Instructions.
1218 let isCommutable = 1 in
1219 def MUL : AsMul1I<0b0000000, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1220 IIC_iMUL32, "mul", "\t$dst, $a, $b",
1221 [(set GPR:$dst, (mul GPR:$a, GPR:$b))]>;
1223 def MLA : AsMul1I<0b0000001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1224 IIC_iMAC32, "mla", "\t$dst, $a, $b, $c",
1225 [(set GPR:$dst, (add (mul GPR:$a, GPR:$b), GPR:$c))]>;
1227 def MLS : AMul1I<0b0000011, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1228 IIC_iMAC32, "mls", "\t$dst, $a, $b, $c",
1229 [(set GPR:$dst, (sub GPR:$c, (mul GPR:$a, GPR:$b)))]>,
1230 Requires<[IsARM, HasV6T2]>;
1232 // Extra precision multiplies with low / high results
1233 let neverHasSideEffects = 1 in {
1234 let isCommutable = 1 in {
1235 def SMULL : AsMul1I<0b0000110, (outs GPR:$ldst, GPR:$hdst),
1236 (ins GPR:$a, GPR:$b), IIC_iMUL64,
1237 "smull", "\t$ldst, $hdst, $a, $b", []>;
1239 def UMULL : AsMul1I<0b0000100, (outs GPR:$ldst, GPR:$hdst),
1240 (ins GPR:$a, GPR:$b), IIC_iMUL64,
1241 "umull", "\t$ldst, $hdst, $a, $b", []>;
1244 // Multiply + accumulate
1245 def SMLAL : AsMul1I<0b0000111, (outs GPR:$ldst, GPR:$hdst),
1246 (ins GPR:$a, GPR:$b), IIC_iMAC64,
1247 "smlal", "\t$ldst, $hdst, $a, $b", []>;
1249 def UMLAL : AsMul1I<0b0000101, (outs GPR:$ldst, GPR:$hdst),
1250 (ins GPR:$a, GPR:$b), IIC_iMAC64,
1251 "umlal", "\t$ldst, $hdst, $a, $b", []>;
1253 def UMAAL : AMul1I <0b0000010, (outs GPR:$ldst, GPR:$hdst),
1254 (ins GPR:$a, GPR:$b), IIC_iMAC64,
1255 "umaal", "\t$ldst, $hdst, $a, $b", []>,
1256 Requires<[IsARM, HasV6]>;
1257 } // neverHasSideEffects
1259 // Most significant word multiply
1260 def SMMUL : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1261 IIC_iMUL32, "smmul", "\t$dst, $a, $b",
1262 [(set GPR:$dst, (mulhs GPR:$a, GPR:$b))]>,
1263 Requires<[IsARM, HasV6]> {
1264 let Inst{7-4} = 0b0001;
1265 let Inst{15-12} = 0b1111;
1268 def SMMLA : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1269 IIC_iMAC32, "smmla", "\t$dst, $a, $b, $c",
1270 [(set GPR:$dst, (add (mulhs GPR:$a, GPR:$b), GPR:$c))]>,
1271 Requires<[IsARM, HasV6]> {
1272 let Inst{7-4} = 0b0001;
1276 def SMMLS : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1277 IIC_iMAC32, "smmls", "\t$dst, $a, $b, $c",
1278 [(set GPR:$dst, (sub GPR:$c, (mulhs GPR:$a, GPR:$b)))]>,
1279 Requires<[IsARM, HasV6]> {
1280 let Inst{7-4} = 0b1101;
1283 multiclass AI_smul<string opc, PatFrag opnode> {
1284 def BB : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1285 IIC_iMUL32, !strconcat(opc, "bb"), "\t$dst, $a, $b",
1286 [(set GPR:$dst, (opnode (sext_inreg GPR:$a, i16),
1287 (sext_inreg GPR:$b, i16)))]>,
1288 Requires<[IsARM, HasV5TE]> {
1293 def BT : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1294 IIC_iMUL32, !strconcat(opc, "bt"), "\t$dst, $a, $b",
1295 [(set GPR:$dst, (opnode (sext_inreg GPR:$a, i16),
1296 (sra GPR:$b, (i32 16))))]>,
1297 Requires<[IsARM, HasV5TE]> {
1302 def TB : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1303 IIC_iMUL32, !strconcat(opc, "tb"), "\t$dst, $a, $b",
1304 [(set GPR:$dst, (opnode (sra GPR:$a, (i32 16)),
1305 (sext_inreg GPR:$b, i16)))]>,
1306 Requires<[IsARM, HasV5TE]> {
1311 def TT : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1312 IIC_iMUL32, !strconcat(opc, "tt"), "\t$dst, $a, $b",
1313 [(set GPR:$dst, (opnode (sra GPR:$a, (i32 16)),
1314 (sra GPR:$b, (i32 16))))]>,
1315 Requires<[IsARM, HasV5TE]> {
1320 def WB : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1321 IIC_iMUL16, !strconcat(opc, "wb"), "\t$dst, $a, $b",
1322 [(set GPR:$dst, (sra (opnode GPR:$a,
1323 (sext_inreg GPR:$b, i16)), (i32 16)))]>,
1324 Requires<[IsARM, HasV5TE]> {
1329 def WT : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1330 IIC_iMUL16, !strconcat(opc, "wt"), "\t$dst, $a, $b",
1331 [(set GPR:$dst, (sra (opnode GPR:$a,
1332 (sra GPR:$b, (i32 16))), (i32 16)))]>,
1333 Requires<[IsARM, HasV5TE]> {
1340 multiclass AI_smla<string opc, PatFrag opnode> {
1341 def BB : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1342 IIC_iMAC16, !strconcat(opc, "bb"), "\t$dst, $a, $b, $acc",
1343 [(set GPR:$dst, (add GPR:$acc,
1344 (opnode (sext_inreg GPR:$a, i16),
1345 (sext_inreg GPR:$b, i16))))]>,
1346 Requires<[IsARM, HasV5TE]> {
1351 def BT : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1352 IIC_iMAC16, !strconcat(opc, "bt"), "\t$dst, $a, $b, $acc",
1353 [(set GPR:$dst, (add GPR:$acc, (opnode (sext_inreg GPR:$a, i16),
1354 (sra GPR:$b, (i32 16)))))]>,
1355 Requires<[IsARM, HasV5TE]> {
1360 def TB : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1361 IIC_iMAC16, !strconcat(opc, "tb"), "\t$dst, $a, $b, $acc",
1362 [(set GPR:$dst, (add GPR:$acc, (opnode (sra GPR:$a, (i32 16)),
1363 (sext_inreg GPR:$b, i16))))]>,
1364 Requires<[IsARM, HasV5TE]> {
1369 def TT : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1370 IIC_iMAC16, !strconcat(opc, "tt"), "\t$dst, $a, $b, $acc",
1371 [(set GPR:$dst, (add GPR:$acc, (opnode (sra GPR:$a, (i32 16)),
1372 (sra GPR:$b, (i32 16)))))]>,
1373 Requires<[IsARM, HasV5TE]> {
1378 def WB : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1379 IIC_iMAC16, !strconcat(opc, "wb"), "\t$dst, $a, $b, $acc",
1380 [(set GPR:$dst, (add GPR:$acc, (sra (opnode GPR:$a,
1381 (sext_inreg GPR:$b, i16)), (i32 16))))]>,
1382 Requires<[IsARM, HasV5TE]> {
1387 def WT : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1388 IIC_iMAC16, !strconcat(opc, "wt"), "\t$dst, $a, $b, $acc",
1389 [(set GPR:$dst, (add GPR:$acc, (sra (opnode GPR:$a,
1390 (sra GPR:$b, (i32 16))), (i32 16))))]>,
1391 Requires<[IsARM, HasV5TE]> {
1397 defm SMUL : AI_smul<"smul", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
1398 defm SMLA : AI_smla<"smla", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
1400 // TODO: Halfword multiple accumulate long: SMLAL<x><y>
1401 // TODO: Dual halfword multiple: SMUAD, SMUSD, SMLAD, SMLSD, SMLALD, SMLSLD
1403 //===----------------------------------------------------------------------===//
1404 // Misc. Arithmetic Instructions.
1407 def CLZ : AMiscA1I<0b000010110, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
1408 "clz", "\t$dst, $src",
1409 [(set GPR:$dst, (ctlz GPR:$src))]>, Requires<[IsARM, HasV5T]> {
1410 let Inst{7-4} = 0b0001;
1411 let Inst{11-8} = 0b1111;
1412 let Inst{19-16} = 0b1111;
1415 def REV : AMiscA1I<0b01101011, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
1416 "rev", "\t$dst, $src",
1417 [(set GPR:$dst, (bswap GPR:$src))]>, Requires<[IsARM, HasV6]> {
1418 let Inst{7-4} = 0b0011;
1419 let Inst{11-8} = 0b1111;
1420 let Inst{19-16} = 0b1111;
1423 def REV16 : AMiscA1I<0b01101011, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
1424 "rev16", "\t$dst, $src",
1426 (or (and (srl GPR:$src, (i32 8)), 0xFF),
1427 (or (and (shl GPR:$src, (i32 8)), 0xFF00),
1428 (or (and (srl GPR:$src, (i32 8)), 0xFF0000),
1429 (and (shl GPR:$src, (i32 8)), 0xFF000000)))))]>,
1430 Requires<[IsARM, HasV6]> {
1431 let Inst{7-4} = 0b1011;
1432 let Inst{11-8} = 0b1111;
1433 let Inst{19-16} = 0b1111;
1436 def REVSH : AMiscA1I<0b01101111, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
1437 "revsh", "\t$dst, $src",
1440 (or (srl (and GPR:$src, 0xFF00), (i32 8)),
1441 (shl GPR:$src, (i32 8))), i16))]>,
1442 Requires<[IsARM, HasV6]> {
1443 let Inst{7-4} = 0b1011;
1444 let Inst{11-8} = 0b1111;
1445 let Inst{19-16} = 0b1111;
1448 def PKHBT : AMiscA1I<0b01101000, (outs GPR:$dst),
1449 (ins GPR:$src1, GPR:$src2, i32imm:$shamt),
1450 IIC_iALUsi, "pkhbt", "\t$dst, $src1, $src2, LSL $shamt",
1451 [(set GPR:$dst, (or (and GPR:$src1, 0xFFFF),
1452 (and (shl GPR:$src2, (i32 imm:$shamt)),
1454 Requires<[IsARM, HasV6]> {
1455 let Inst{6-4} = 0b001;
1458 // Alternate cases for PKHBT where identities eliminate some nodes.
1459 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF), (and GPR:$src2, 0xFFFF0000)),
1460 (PKHBT GPR:$src1, GPR:$src2, 0)>;
1461 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF), (shl GPR:$src2, imm16_31:$shamt)),
1462 (PKHBT GPR:$src1, GPR:$src2, imm16_31:$shamt)>;
1465 def PKHTB : AMiscA1I<0b01101000, (outs GPR:$dst),
1466 (ins GPR:$src1, GPR:$src2, i32imm:$shamt),
1467 IIC_iALUsi, "pkhtb", "\t$dst, $src1, $src2, ASR $shamt",
1468 [(set GPR:$dst, (or (and GPR:$src1, 0xFFFF0000),
1469 (and (sra GPR:$src2, imm16_31:$shamt),
1470 0xFFFF)))]>, Requires<[IsARM, HasV6]> {
1471 let Inst{6-4} = 0b101;
1474 // Alternate cases for PKHTB where identities eliminate some nodes. Note that
1475 // a shift amount of 0 is *not legal* here, it is PKHBT instead.
1476 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF0000), (srl GPR:$src2, (i32 16))),
1477 (PKHTB GPR:$src1, GPR:$src2, 16)>;
1478 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF0000),
1479 (and (srl GPR:$src2, imm1_15:$shamt), 0xFFFF)),
1480 (PKHTB GPR:$src1, GPR:$src2, imm1_15:$shamt)>;
1482 //===----------------------------------------------------------------------===//
1483 // Comparison Instructions...
1486 defm CMP : AI1_cmp_irs<0b1010, "cmp",
1487 BinOpFrag<(ARMcmp node:$LHS, node:$RHS)>>;
1488 defm CMN : AI1_cmp_irs<0b1011, "cmn",
1489 BinOpFrag<(ARMcmp node:$LHS,(ineg node:$RHS))>>;
1491 // Note that TST/TEQ don't set all the same flags that CMP does!
1492 defm TST : AI1_cmp_irs<0b1000, "tst",
1493 BinOpFrag<(ARMcmpZ (and node:$LHS, node:$RHS), 0)>, 1>;
1494 defm TEQ : AI1_cmp_irs<0b1001, "teq",
1495 BinOpFrag<(ARMcmpZ (xor node:$LHS, node:$RHS), 0)>, 1>;
1497 defm CMPz : AI1_cmp_irs<0b1010, "cmp",
1498 BinOpFrag<(ARMcmpZ node:$LHS, node:$RHS)>>;
1499 defm CMNz : AI1_cmp_irs<0b1011, "cmn",
1500 BinOpFrag<(ARMcmpZ node:$LHS,(ineg node:$RHS))>>;
1502 def : ARMPat<(ARMcmp GPR:$src, so_imm_neg:$imm),
1503 (CMNri GPR:$src, so_imm_neg:$imm)>;
1505 def : ARMPat<(ARMcmpZ GPR:$src, so_imm_neg:$imm),
1506 (CMNri GPR:$src, so_imm_neg:$imm)>;
1509 // Conditional moves
1510 // FIXME: should be able to write a pattern for ARMcmov, but can't use
1511 // a two-value operand where a dag node expects two operands. :(
1512 def MOVCCr : AI1<0b1101, (outs GPR:$dst), (ins GPR:$false, GPR:$true), DPFrm,
1513 IIC_iCMOVr, "mov", "\t$dst, $true",
1514 [/*(set GPR:$dst, (ARMcmov GPR:$false, GPR:$true, imm:$cc, CCR:$ccr))*/]>,
1515 RegConstraint<"$false = $dst">, UnaryDP {
1516 let Inst{11-4} = 0b00000000;
1520 def MOVCCs : AI1<0b1101, (outs GPR:$dst),
1521 (ins GPR:$false, so_reg:$true), DPSoRegFrm, IIC_iCMOVsr,
1522 "mov", "\t$dst, $true",
1523 [/*(set GPR:$dst, (ARMcmov GPR:$false, so_reg:$true, imm:$cc, CCR:$ccr))*/]>,
1524 RegConstraint<"$false = $dst">, UnaryDP {
1528 def MOVCCi : AI1<0b1101, (outs GPR:$dst),
1529 (ins GPR:$false, so_imm:$true), DPFrm, IIC_iCMOVi,
1530 "mov", "\t$dst, $true",
1531 [/*(set GPR:$dst, (ARMcmov GPR:$false, so_imm:$true, imm:$cc, CCR:$ccr))*/]>,
1532 RegConstraint<"$false = $dst">, UnaryDP {
1537 //===----------------------------------------------------------------------===//
1541 // __aeabi_read_tp preserves the registers r1-r3.
1543 Defs = [R0, R12, LR, CPSR] in {
1544 def TPsoft : ABXI<0b1011, (outs), (ins), IIC_Br,
1545 "bl\t__aeabi_read_tp",
1546 [(set R0, ARMthread_pointer)]>;
1549 //===----------------------------------------------------------------------===//
1550 // SJLJ Exception handling intrinsics
1551 // eh_sjlj_setjmp() is an instruction sequence to store the return
1552 // address and save #0 in R0 for the non-longjmp case.
1553 // Since by its nature we may be coming from some other function to get
1554 // here, and we're using the stack frame for the containing function to
1555 // save/restore registers, we can't keep anything live in regs across
1556 // the eh_sjlj_setjmp(), else it will almost certainly have been tromped upon
1557 // when we get here from a longjmp(). We force everthing out of registers
1558 // except for our own input by listing the relevant registers in Defs. By
1559 // doing so, we also cause the prologue/epilogue code to actively preserve
1560 // all of the callee-saved resgisters, which is exactly what we want.
1562 [ R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, LR, D0,
1563 D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15,
1564 D16, D17, D18, D19, D20, D21, D22, D23, D24, D25, D26, D27, D28, D29, D30,
1566 def Int_eh_sjlj_setjmp : XI<(outs), (ins GPR:$src),
1567 AddrModeNone, SizeSpecial, IndexModeNone,
1568 Pseudo, NoItinerary,
1569 "str\tsp, [$src, #+8] @ eh_setjmp begin\n\t"
1570 "add\tr12, pc, #8\n\t"
1571 "str\tr12, [$src, #+4]\n\t"
1573 "add\tpc, pc, #0\n\t"
1574 "mov\tr0, #1 @ eh_setjmp end", "",
1575 [(set R0, (ARMeh_sjlj_setjmp GPR:$src))]>;
1578 //===----------------------------------------------------------------------===//
1579 // Non-Instruction Patterns
1582 // ConstantPool, GlobalAddress, and JumpTable
1583 def : ARMPat<(ARMWrapper tglobaladdr :$dst), (LEApcrel tglobaladdr :$dst)>;
1584 def : ARMPat<(ARMWrapper tconstpool :$dst), (LEApcrel tconstpool :$dst)>;
1585 def : ARMPat<(ARMWrapperJT tjumptable:$dst, imm:$id),
1586 (LEApcrelJT tjumptable:$dst, imm:$id)>;
1588 // Large immediate handling.
1590 // Two piece so_imms.
1591 let isReMaterializable = 1 in
1592 def MOVi2pieces : AI1x2<(outs GPR:$dst), (ins so_imm2part:$src),
1594 "mov", "\t$dst, $src",
1595 [(set GPR:$dst, so_imm2part:$src)]>,
1596 Requires<[IsARM, NoV6T2]>;
1598 def : ARMPat<(or GPR:$LHS, so_imm2part:$RHS),
1599 (ORRri (ORRri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
1600 (so_imm2part_2 imm:$RHS))>;
1601 def : ARMPat<(xor GPR:$LHS, so_imm2part:$RHS),
1602 (EORri (EORri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
1603 (so_imm2part_2 imm:$RHS))>;
1604 def : ARMPat<(add GPR:$LHS, so_imm2part:$RHS),
1605 (ADDri (ADDri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
1606 (so_imm2part_2 imm:$RHS))>;
1607 def : ARMPat<(sub GPR:$LHS, so_imm2part:$RHS),
1608 (SUBri (SUBri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
1609 (so_imm2part_2 imm:$RHS))>;
1611 // 32-bit immediate using movw + movt.
1612 // This is a single pseudo instruction, the benefit is that it can be remat'd
1613 // as a single unit instead of having to handle reg inputs.
1614 // FIXME: Remove this when we can do generalized remat.
1615 let isReMaterializable = 1 in
1616 def MOVi32imm : AI1x2<(outs GPR:$dst), (ins i32imm:$src), Pseudo, IIC_iMOVi,
1617 "movw", "\t$dst, ${src:lo16}\n\tmovt${p} $dst, ${src:hi16}",
1618 [(set GPR:$dst, (i32 imm:$src))]>,
1619 Requires<[IsARM, HasV6T2]>;
1621 // TODO: add,sub,and, 3-instr forms?
1625 def : ARMPat<(ARMcall texternalsym:$func), (BL texternalsym:$func)>,
1626 Requires<[IsARM, IsNotDarwin]>;
1627 def : ARMPat<(ARMcall texternalsym:$func), (BLr9 texternalsym:$func)>,
1628 Requires<[IsARM, IsDarwin]>;
1630 // zextload i1 -> zextload i8
1631 def : ARMPat<(zextloadi1 addrmode2:$addr), (LDRB addrmode2:$addr)>;
1633 // extload -> zextload
1634 def : ARMPat<(extloadi1 addrmode2:$addr), (LDRB addrmode2:$addr)>;
1635 def : ARMPat<(extloadi8 addrmode2:$addr), (LDRB addrmode2:$addr)>;
1636 def : ARMPat<(extloadi16 addrmode3:$addr), (LDRH addrmode3:$addr)>;
1638 def : ARMPat<(extloadi8 addrmodepc:$addr), (PICLDRB addrmodepc:$addr)>;
1639 def : ARMPat<(extloadi16 addrmodepc:$addr), (PICLDRH addrmodepc:$addr)>;
1642 def : ARMV5TEPat<(mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
1643 (sra (shl GPR:$b, (i32 16)), (i32 16))),
1644 (SMULBB GPR:$a, GPR:$b)>;
1645 def : ARMV5TEPat<(mul sext_16_node:$a, sext_16_node:$b),
1646 (SMULBB GPR:$a, GPR:$b)>;
1647 def : ARMV5TEPat<(mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
1648 (sra GPR:$b, (i32 16))),
1649 (SMULBT GPR:$a, GPR:$b)>;
1650 def : ARMV5TEPat<(mul sext_16_node:$a, (sra GPR:$b, (i32 16))),
1651 (SMULBT GPR:$a, GPR:$b)>;
1652 def : ARMV5TEPat<(mul (sra GPR:$a, (i32 16)),
1653 (sra (shl GPR:$b, (i32 16)), (i32 16))),
1654 (SMULTB GPR:$a, GPR:$b)>;
1655 def : ARMV5TEPat<(mul (sra GPR:$a, (i32 16)), sext_16_node:$b),
1656 (SMULTB GPR:$a, GPR:$b)>;
1657 def : ARMV5TEPat<(sra (mul GPR:$a, (sra (shl GPR:$b, (i32 16)), (i32 16))),
1659 (SMULWB GPR:$a, GPR:$b)>;
1660 def : ARMV5TEPat<(sra (mul GPR:$a, sext_16_node:$b), (i32 16)),
1661 (SMULWB GPR:$a, GPR:$b)>;
1663 def : ARMV5TEPat<(add GPR:$acc,
1664 (mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
1665 (sra (shl GPR:$b, (i32 16)), (i32 16)))),
1666 (SMLABB GPR:$a, GPR:$b, GPR:$acc)>;
1667 def : ARMV5TEPat<(add GPR:$acc,
1668 (mul sext_16_node:$a, sext_16_node:$b)),
1669 (SMLABB GPR:$a, GPR:$b, GPR:$acc)>;
1670 def : ARMV5TEPat<(add GPR:$acc,
1671 (mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
1672 (sra GPR:$b, (i32 16)))),
1673 (SMLABT GPR:$a, GPR:$b, GPR:$acc)>;
1674 def : ARMV5TEPat<(add GPR:$acc,
1675 (mul sext_16_node:$a, (sra GPR:$b, (i32 16)))),
1676 (SMLABT GPR:$a, GPR:$b, GPR:$acc)>;
1677 def : ARMV5TEPat<(add GPR:$acc,
1678 (mul (sra GPR:$a, (i32 16)),
1679 (sra (shl GPR:$b, (i32 16)), (i32 16)))),
1680 (SMLATB GPR:$a, GPR:$b, GPR:$acc)>;
1681 def : ARMV5TEPat<(add GPR:$acc,
1682 (mul (sra GPR:$a, (i32 16)), sext_16_node:$b)),
1683 (SMLATB GPR:$a, GPR:$b, GPR:$acc)>;
1684 def : ARMV5TEPat<(add GPR:$acc,
1685 (sra (mul GPR:$a, (sra (shl GPR:$b, (i32 16)), (i32 16))),
1687 (SMLAWB GPR:$a, GPR:$b, GPR:$acc)>;
1688 def : ARMV5TEPat<(add GPR:$acc,
1689 (sra (mul GPR:$a, sext_16_node:$b), (i32 16))),
1690 (SMLAWB GPR:$a, GPR:$b, GPR:$acc)>;
1692 //===----------------------------------------------------------------------===//
1696 include "ARMInstrThumb.td"
1698 //===----------------------------------------------------------------------===//
1702 include "ARMInstrThumb2.td"
1704 //===----------------------------------------------------------------------===//
1705 // Floating Point Support
1708 include "ARMInstrVFP.td"
1710 //===----------------------------------------------------------------------===//
1711 // Advanced SIMD (NEON) Support
1714 include "ARMInstrNEON.td"