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, [SDTCisPtrTy<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, 2, [SDTCisInt<0>, SDTCisPtrTy<1>,
50 def SDT_ARMMEMBARRIERV7 : SDTypeProfile<0, 0, []>;
51 def SDT_ARMSYNCBARRIERV7 : SDTypeProfile<0, 0, []>;
52 def SDT_ARMMEMBARRIERV6 : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
53 def SDT_ARMSYNCBARRIERV6 : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
56 def ARMWrapper : SDNode<"ARMISD::Wrapper", SDTIntUnaryOp>;
57 def ARMWrapperJT : SDNode<"ARMISD::WrapperJT", SDTIntBinOp>;
59 def ARMcallseq_start : SDNode<"ISD::CALLSEQ_START", SDT_ARMCallSeqStart,
60 [SDNPHasChain, SDNPOutFlag]>;
61 def ARMcallseq_end : SDNode<"ISD::CALLSEQ_END", SDT_ARMCallSeqEnd,
62 [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
64 def ARMcall : SDNode<"ARMISD::CALL", SDT_ARMcall,
65 [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag,
67 def ARMcall_pred : SDNode<"ARMISD::CALL_PRED", SDT_ARMcall,
68 [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag,
70 def ARMcall_nolink : SDNode<"ARMISD::CALL_NOLINK", SDT_ARMcall,
71 [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag,
74 def ARMretflag : SDNode<"ARMISD::RET_FLAG", SDTNone,
75 [SDNPHasChain, SDNPOptInFlag]>;
77 def ARMcmov : SDNode<"ARMISD::CMOV", SDT_ARMCMov,
79 def ARMcneg : SDNode<"ARMISD::CNEG", SDT_ARMCMov,
82 def ARMbrcond : SDNode<"ARMISD::BRCOND", SDT_ARMBrcond,
83 [SDNPHasChain, SDNPInFlag, SDNPOutFlag]>;
85 def ARMbrjt : SDNode<"ARMISD::BR_JT", SDT_ARMBrJT,
87 def ARMbr2jt : SDNode<"ARMISD::BR2_JT", SDT_ARMBr2JT,
90 def ARMcmp : SDNode<"ARMISD::CMP", SDT_ARMCmp,
93 def ARMcmpZ : SDNode<"ARMISD::CMPZ", SDT_ARMCmp,
94 [SDNPOutFlag,SDNPCommutative]>;
96 def ARMpic_add : SDNode<"ARMISD::PIC_ADD", SDT_ARMPICAdd>;
98 def ARMsrl_flag : SDNode<"ARMISD::SRL_FLAG", SDTIntUnaryOp, [SDNPOutFlag]>;
99 def ARMsra_flag : SDNode<"ARMISD::SRA_FLAG", SDTIntUnaryOp, [SDNPOutFlag]>;
100 def ARMrrx : SDNode<"ARMISD::RRX" , SDTIntUnaryOp, [SDNPInFlag ]>;
102 def ARMthread_pointer: SDNode<"ARMISD::THREAD_POINTER", SDT_ARMThreadPointer>;
103 def ARMeh_sjlj_setjmp: SDNode<"ARMISD::EH_SJLJ_SETJMP", SDT_ARMEH_SJLJ_Setjmp>;
105 def ARMMemBarrierV7 : SDNode<"ARMISD::MEMBARRIER", SDT_ARMMEMBARRIERV7,
107 def ARMSyncBarrierV7 : SDNode<"ARMISD::SYNCBARRIER", SDT_ARMMEMBARRIERV7,
109 def ARMMemBarrierV6 : SDNode<"ARMISD::MEMBARRIER", SDT_ARMMEMBARRIERV6,
111 def ARMSyncBarrierV6 : SDNode<"ARMISD::SYNCBARRIER", SDT_ARMMEMBARRIERV6,
114 def ARMrbit : SDNode<"ARMISD::RBIT", SDTIntUnaryOp>;
116 //===----------------------------------------------------------------------===//
117 // ARM Instruction Predicate Definitions.
119 def HasV4T : Predicate<"Subtarget->hasV4TOps()">;
120 def NoV4T : Predicate<"!Subtarget->hasV4TOps()">;
121 def HasV5T : Predicate<"Subtarget->hasV5TOps()">;
122 def HasV5TE : Predicate<"Subtarget->hasV5TEOps()">;
123 def HasV6 : Predicate<"Subtarget->hasV6Ops()">;
124 def HasV6T2 : Predicate<"Subtarget->hasV6T2Ops()">;
125 def NoV6T2 : Predicate<"!Subtarget->hasV6T2Ops()">;
126 def HasV7 : Predicate<"Subtarget->hasV7Ops()">;
127 def HasVFP2 : Predicate<"Subtarget->hasVFP2()">;
128 def HasVFP3 : Predicate<"Subtarget->hasVFP3()">;
129 def HasNEON : Predicate<"Subtarget->hasNEON()">;
130 def UseNEONForFP : Predicate<"Subtarget->useNEONForSinglePrecisionFP()">;
131 def DontUseNEONForFP : Predicate<"!Subtarget->useNEONForSinglePrecisionFP()">;
132 def IsThumb : Predicate<"Subtarget->isThumb()">;
133 def IsThumb1Only : Predicate<"Subtarget->isThumb1Only()">;
134 def IsThumb2 : Predicate<"Subtarget->isThumb2()">;
135 def IsARM : Predicate<"!Subtarget->isThumb()">;
136 def IsDarwin : Predicate<"Subtarget->isTargetDarwin()">;
137 def IsNotDarwin : Predicate<"!Subtarget->isTargetDarwin()">;
139 // FIXME: Eventually this will be just "hasV6T2Ops".
140 def UseMovt : Predicate<"Subtarget->useMovt()">;
141 def DontUseMovt : Predicate<"!Subtarget->useMovt()">;
143 //===----------------------------------------------------------------------===//
144 // ARM Flag Definitions.
146 class RegConstraint<string C> {
147 string Constraints = C;
150 //===----------------------------------------------------------------------===//
151 // ARM specific transformation functions and pattern fragments.
154 // so_imm_neg_XFORM - Return a so_imm value packed into the format described for
155 // so_imm_neg def below.
156 def so_imm_neg_XFORM : SDNodeXForm<imm, [{
157 return CurDAG->getTargetConstant(-(int)N->getZExtValue(), MVT::i32);
160 // so_imm_not_XFORM - Return a so_imm value packed into the format described for
161 // so_imm_not def below.
162 def so_imm_not_XFORM : SDNodeXForm<imm, [{
163 return CurDAG->getTargetConstant(~(int)N->getZExtValue(), MVT::i32);
166 // rot_imm predicate - True if the 32-bit immediate is equal to 8, 16, or 24.
167 def rot_imm : PatLeaf<(i32 imm), [{
168 int32_t v = (int32_t)N->getZExtValue();
169 return v == 8 || v == 16 || v == 24;
172 /// imm1_15 predicate - True if the 32-bit immediate is in the range [1,15].
173 def imm1_15 : PatLeaf<(i32 imm), [{
174 return (int32_t)N->getZExtValue() >= 1 && (int32_t)N->getZExtValue() < 16;
177 /// imm16_31 predicate - True if the 32-bit immediate is in the range [16,31].
178 def imm16_31 : PatLeaf<(i32 imm), [{
179 return (int32_t)N->getZExtValue() >= 16 && (int32_t)N->getZExtValue() < 32;
184 return ARM_AM::getSOImmVal(-(int)N->getZExtValue()) != -1;
185 }], so_imm_neg_XFORM>;
189 return ARM_AM::getSOImmVal(~(int)N->getZExtValue()) != -1;
190 }], so_imm_not_XFORM>;
192 // sext_16_node predicate - True if the SDNode is sign-extended 16 or more bits.
193 def sext_16_node : PatLeaf<(i32 GPR:$a), [{
194 return CurDAG->ComputeNumSignBits(SDValue(N,0)) >= 17;
197 /// bf_inv_mask_imm predicate - An AND mask to clear an arbitrary width bitfield
199 def bf_inv_mask_imm : Operand<i32>,
201 uint32_t v = (uint32_t)N->getZExtValue();
204 // there can be 1's on either or both "outsides", all the "inside"
206 unsigned int lsb = 0, msb = 31;
207 while (v & (1 << msb)) --msb;
208 while (v & (1 << lsb)) ++lsb;
209 for (unsigned int i = lsb; i <= msb; ++i) {
215 let PrintMethod = "printBitfieldInvMaskImmOperand";
218 /// Split a 32-bit immediate into two 16 bit parts.
219 def lo16 : SDNodeXForm<imm, [{
220 return CurDAG->getTargetConstant((uint32_t)N->getZExtValue() & 0xffff,
224 def hi16 : SDNodeXForm<imm, [{
225 return CurDAG->getTargetConstant((uint32_t)N->getZExtValue() >> 16, MVT::i32);
228 def lo16AllZero : PatLeaf<(i32 imm), [{
229 // Returns true if all low 16-bits are 0.
230 return (((uint32_t)N->getZExtValue()) & 0xFFFFUL) == 0;
233 /// imm0_65535 predicate - True if the 32-bit immediate is in the range
235 def imm0_65535 : PatLeaf<(i32 imm), [{
236 return (uint32_t)N->getZExtValue() < 65536;
239 class BinOpFrag<dag res> : PatFrag<(ops node:$LHS, node:$RHS), res>;
240 class UnOpFrag <dag res> : PatFrag<(ops node:$Src), res>;
242 /// adde and sube predicates - True based on whether the carry flag output
243 /// will be needed or not.
244 def adde_dead_carry :
245 PatFrag<(ops node:$LHS, node:$RHS), (adde node:$LHS, node:$RHS),
246 [{return !N->hasAnyUseOfValue(1);}]>;
247 def sube_dead_carry :
248 PatFrag<(ops node:$LHS, node:$RHS), (sube node:$LHS, node:$RHS),
249 [{return !N->hasAnyUseOfValue(1);}]>;
250 def adde_live_carry :
251 PatFrag<(ops node:$LHS, node:$RHS), (adde node:$LHS, node:$RHS),
252 [{return N->hasAnyUseOfValue(1);}]>;
253 def sube_live_carry :
254 PatFrag<(ops node:$LHS, node:$RHS), (sube node:$LHS, node:$RHS),
255 [{return N->hasAnyUseOfValue(1);}]>;
257 //===----------------------------------------------------------------------===//
258 // Operand Definitions.
262 def brtarget : Operand<OtherVT>;
264 // A list of registers separated by comma. Used by load/store multiple.
265 def reglist : Operand<i32> {
266 let PrintMethod = "printRegisterList";
269 // An operand for the CONSTPOOL_ENTRY pseudo-instruction.
270 def cpinst_operand : Operand<i32> {
271 let PrintMethod = "printCPInstOperand";
274 def jtblock_operand : Operand<i32> {
275 let PrintMethod = "printJTBlockOperand";
277 def jt2block_operand : Operand<i32> {
278 let PrintMethod = "printJT2BlockOperand";
282 def pclabel : Operand<i32> {
283 let PrintMethod = "printPCLabel";
286 // shifter_operand operands: so_reg and so_imm.
287 def so_reg : Operand<i32>, // reg reg imm
288 ComplexPattern<i32, 3, "SelectShifterOperandReg",
289 [shl,srl,sra,rotr]> {
290 let PrintMethod = "printSORegOperand";
291 let MIOperandInfo = (ops GPR, GPR, i32imm);
294 // so_imm - Match a 32-bit shifter_operand immediate operand, which is an
295 // 8-bit immediate rotated by an arbitrary number of bits. so_imm values are
296 // represented in the imm field in the same 12-bit form that they are encoded
297 // into so_imm instructions: the 8-bit immediate is the least significant bits
298 // [bits 0-7], the 4-bit shift amount is the next 4 bits [bits 8-11].
299 def so_imm : Operand<i32>,
301 return ARM_AM::getSOImmVal(N->getZExtValue()) != -1;
303 let PrintMethod = "printSOImmOperand";
306 // Break so_imm's up into two pieces. This handles immediates with up to 16
307 // bits set in them. This uses so_imm2part to match and so_imm2part_[12] to
308 // get the first/second pieces.
309 def so_imm2part : Operand<i32>,
311 return ARM_AM::isSOImmTwoPartVal((unsigned)N->getZExtValue());
313 let PrintMethod = "printSOImm2PartOperand";
316 def so_imm2part_1 : SDNodeXForm<imm, [{
317 unsigned V = ARM_AM::getSOImmTwoPartFirst((unsigned)N->getZExtValue());
318 return CurDAG->getTargetConstant(V, MVT::i32);
321 def so_imm2part_2 : SDNodeXForm<imm, [{
322 unsigned V = ARM_AM::getSOImmTwoPartSecond((unsigned)N->getZExtValue());
323 return CurDAG->getTargetConstant(V, MVT::i32);
326 def so_neg_imm2part : Operand<i32>, PatLeaf<(imm), [{
327 return ARM_AM::isSOImmTwoPartVal(-(int)N->getZExtValue());
329 let PrintMethod = "printSOImm2PartOperand";
332 def so_neg_imm2part_1 : SDNodeXForm<imm, [{
333 unsigned V = ARM_AM::getSOImmTwoPartFirst(-(int)N->getZExtValue());
334 return CurDAG->getTargetConstant(V, MVT::i32);
337 def so_neg_imm2part_2 : SDNodeXForm<imm, [{
338 unsigned V = ARM_AM::getSOImmTwoPartSecond(-(int)N->getZExtValue());
339 return CurDAG->getTargetConstant(V, MVT::i32);
342 /// imm0_31 predicate - True if the 32-bit immediate is in the range [0,31].
343 def imm0_31 : Operand<i32>, PatLeaf<(imm), [{
344 return (int32_t)N->getZExtValue() < 32;
347 // Define ARM specific addressing modes.
349 // addrmode2 := reg +/- reg shop imm
350 // addrmode2 := reg +/- imm12
352 def addrmode2 : Operand<i32>,
353 ComplexPattern<i32, 3, "SelectAddrMode2", []> {
354 let PrintMethod = "printAddrMode2Operand";
355 let MIOperandInfo = (ops GPR:$base, GPR:$offsreg, i32imm:$offsimm);
358 def am2offset : Operand<i32>,
359 ComplexPattern<i32, 2, "SelectAddrMode2Offset", []> {
360 let PrintMethod = "printAddrMode2OffsetOperand";
361 let MIOperandInfo = (ops GPR, i32imm);
364 // addrmode3 := reg +/- reg
365 // addrmode3 := reg +/- imm8
367 def addrmode3 : Operand<i32>,
368 ComplexPattern<i32, 3, "SelectAddrMode3", []> {
369 let PrintMethod = "printAddrMode3Operand";
370 let MIOperandInfo = (ops GPR:$base, GPR:$offsreg, i32imm:$offsimm);
373 def am3offset : Operand<i32>,
374 ComplexPattern<i32, 2, "SelectAddrMode3Offset", []> {
375 let PrintMethod = "printAddrMode3OffsetOperand";
376 let MIOperandInfo = (ops GPR, i32imm);
379 // addrmode4 := reg, <mode|W>
381 def addrmode4 : Operand<i32>,
382 ComplexPattern<i32, 2, "SelectAddrMode4", []> {
383 let PrintMethod = "printAddrMode4Operand";
384 let MIOperandInfo = (ops GPR:$addr, i32imm);
387 // addrmode5 := reg +/- imm8*4
389 def addrmode5 : Operand<i32>,
390 ComplexPattern<i32, 2, "SelectAddrMode5", []> {
391 let PrintMethod = "printAddrMode5Operand";
392 let MIOperandInfo = (ops GPR:$base, i32imm);
395 // addrmode6 := reg with optional writeback
397 def addrmode6 : Operand<i32>,
398 ComplexPattern<i32, 4, "SelectAddrMode6", []> {
399 let PrintMethod = "printAddrMode6Operand";
400 let MIOperandInfo = (ops GPR:$addr, GPR:$upd, i32imm, i32imm);
403 // addrmodepc := pc + reg
405 def addrmodepc : Operand<i32>,
406 ComplexPattern<i32, 2, "SelectAddrModePC", []> {
407 let PrintMethod = "printAddrModePCOperand";
408 let MIOperandInfo = (ops GPR, i32imm);
411 def nohash_imm : Operand<i32> {
412 let PrintMethod = "printNoHashImmediate";
415 //===----------------------------------------------------------------------===//
417 include "ARMInstrFormats.td"
419 //===----------------------------------------------------------------------===//
420 // Multiclass helpers...
423 /// AsI1_bin_irs - Defines a set of (op r, {so_imm|r|so_reg}) patterns for a
424 /// binop that produces a value.
425 multiclass AsI1_bin_irs<bits<4> opcod, string opc, PatFrag opnode,
426 bit Commutable = 0> {
427 def ri : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
428 IIC_iALUi, opc, "\t$dst, $a, $b",
429 [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]> {
432 def rr : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm,
433 IIC_iALUr, opc, "\t$dst, $a, $b",
434 [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]> {
435 let Inst{11-4} = 0b00000000;
437 let isCommutable = Commutable;
439 def rs : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
440 IIC_iALUsr, opc, "\t$dst, $a, $b",
441 [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]> {
446 /// AI1_bin_s_irs - Similar to AsI1_bin_irs except it sets the 's' bit so the
447 /// instruction modifies the CPSR register.
448 let Defs = [CPSR] in {
449 multiclass AI1_bin_s_irs<bits<4> opcod, string opc, PatFrag opnode,
450 bit Commutable = 0> {
451 def ri : AI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
452 IIC_iALUi, opc, "\t$dst, $a, $b",
453 [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]> {
457 def rr : AI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm,
458 IIC_iALUr, opc, "\t$dst, $a, $b",
459 [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]> {
460 let isCommutable = Commutable;
461 let Inst{11-4} = 0b00000000;
465 def rs : AI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
466 IIC_iALUsr, opc, "\t$dst, $a, $b",
467 [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]> {
474 /// AI1_cmp_irs - Defines a set of (op r, {so_imm|r|so_reg}) cmp / test
475 /// patterns. Similar to AsI1_bin_irs except the instruction does not produce
476 /// a explicit result, only implicitly set CPSR.
477 let Defs = [CPSR] in {
478 multiclass AI1_cmp_irs<bits<4> opcod, string opc, PatFrag opnode,
479 bit Commutable = 0> {
480 def ri : AI1<opcod, (outs), (ins GPR:$a, so_imm:$b), DPFrm, IIC_iCMPi,
482 [(opnode GPR:$a, so_imm:$b)]> {
486 def rr : AI1<opcod, (outs), (ins GPR:$a, GPR:$b), DPFrm, IIC_iCMPr,
488 [(opnode GPR:$a, GPR:$b)]> {
489 let Inst{11-4} = 0b00000000;
492 let isCommutable = Commutable;
494 def rs : AI1<opcod, (outs), (ins GPR:$a, so_reg:$b), DPSoRegFrm, IIC_iCMPsr,
496 [(opnode GPR:$a, so_reg:$b)]> {
503 /// AI_unary_rrot - A unary operation with two forms: one whose operand is a
504 /// register and one whose operand is a register rotated by 8/16/24.
505 /// FIXME: Remove the 'r' variant. Its rot_imm is zero.
506 multiclass AI_unary_rrot<bits<8> opcod, string opc, PatFrag opnode> {
507 def r : AExtI<opcod, (outs GPR:$dst), (ins GPR:$src),
508 IIC_iUNAr, opc, "\t$dst, $src",
509 [(set GPR:$dst, (opnode GPR:$src))]>,
510 Requires<[IsARM, HasV6]> {
511 let Inst{11-10} = 0b00;
512 let Inst{19-16} = 0b1111;
514 def r_rot : AExtI<opcod, (outs GPR:$dst), (ins GPR:$src, i32imm:$rot),
515 IIC_iUNAsi, opc, "\t$dst, $src, ror $rot",
516 [(set GPR:$dst, (opnode (rotr GPR:$src, rot_imm:$rot)))]>,
517 Requires<[IsARM, HasV6]> {
518 let Inst{19-16} = 0b1111;
522 multiclass AI_unary_rrot_np<bits<8> opcod, string opc> {
523 def r : AExtI<opcod, (outs GPR:$dst), (ins GPR:$src),
524 IIC_iUNAr, opc, "\t$dst, $src",
525 [/* For disassembly only; pattern left blank */]>,
526 Requires<[IsARM, HasV6]> {
527 let Inst{11-10} = 0b00;
528 let Inst{19-16} = 0b1111;
530 def r_rot : AExtI<opcod, (outs GPR:$dst), (ins GPR:$src, i32imm:$rot),
531 IIC_iUNAsi, opc, "\t$dst, $src, ror $rot",
532 [/* For disassembly only; pattern left blank */]>,
533 Requires<[IsARM, HasV6]> {
534 let Inst{19-16} = 0b1111;
538 /// AI_bin_rrot - A binary operation with two forms: one whose operand is a
539 /// register and one whose operand is a register rotated by 8/16/24.
540 multiclass AI_bin_rrot<bits<8> opcod, string opc, PatFrag opnode> {
541 def rr : AExtI<opcod, (outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS),
542 IIC_iALUr, opc, "\t$dst, $LHS, $RHS",
543 [(set GPR:$dst, (opnode GPR:$LHS, GPR:$RHS))]>,
544 Requires<[IsARM, HasV6]> {
545 let Inst{11-10} = 0b00;
547 def rr_rot : AExtI<opcod, (outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS,
549 IIC_iALUsi, opc, "\t$dst, $LHS, $RHS, ror $rot",
550 [(set GPR:$dst, (opnode GPR:$LHS,
551 (rotr GPR:$RHS, rot_imm:$rot)))]>,
552 Requires<[IsARM, HasV6]>;
555 // For disassembly only.
556 multiclass AI_bin_rrot_np<bits<8> opcod, string opc> {
557 def rr : AExtI<opcod, (outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS),
558 IIC_iALUr, opc, "\t$dst, $LHS, $RHS",
559 [/* For disassembly only; pattern left blank */]>,
560 Requires<[IsARM, HasV6]> {
561 let Inst{11-10} = 0b00;
563 def rr_rot : AExtI<opcod, (outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS,
565 IIC_iALUsi, opc, "\t$dst, $LHS, $RHS, ror $rot",
566 [/* For disassembly only; pattern left blank */]>,
567 Requires<[IsARM, HasV6]>;
570 /// AI1_adde_sube_irs - Define instructions and patterns for adde and sube.
571 let Uses = [CPSR] in {
572 multiclass AI1_adde_sube_irs<bits<4> opcod, string opc, PatFrag opnode,
573 bit Commutable = 0> {
574 def ri : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
575 DPFrm, IIC_iALUi, opc, "\t$dst, $a, $b",
576 [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]>,
580 def rr : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
581 DPFrm, IIC_iALUr, opc, "\t$dst, $a, $b",
582 [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]>,
584 let isCommutable = Commutable;
585 let Inst{11-4} = 0b00000000;
588 def rs : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
589 DPSoRegFrm, IIC_iALUsr, opc, "\t$dst, $a, $b",
590 [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]>,
595 // Carry setting variants
596 let Defs = [CPSR] in {
597 multiclass AI1_adde_sube_s_irs<bits<4> opcod, string opc, PatFrag opnode,
598 bit Commutable = 0> {
599 def Sri : AXI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
600 DPFrm, IIC_iALUi, !strconcat(opc, "\t$dst, $a, $b"),
601 [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]>,
606 def Srr : AXI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
607 DPFrm, IIC_iALUr, !strconcat(opc, "\t$dst, $a, $b"),
608 [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]>,
610 let Inst{11-4} = 0b00000000;
614 def Srs : AXI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
615 DPSoRegFrm, IIC_iALUsr, !strconcat(opc, "\t$dst, $a, $b"),
616 [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]>,
625 //===----------------------------------------------------------------------===//
627 //===----------------------------------------------------------------------===//
629 //===----------------------------------------------------------------------===//
630 // Miscellaneous Instructions.
633 /// CONSTPOOL_ENTRY - This instruction represents a floating constant pool in
634 /// the function. The first operand is the ID# for this instruction, the second
635 /// is the index into the MachineConstantPool that this is, the third is the
636 /// size in bytes of this constant pool entry.
637 let neverHasSideEffects = 1, isNotDuplicable = 1 in
638 def CONSTPOOL_ENTRY :
639 PseudoInst<(outs), (ins cpinst_operand:$instid, cpinst_operand:$cpidx,
640 i32imm:$size), NoItinerary,
641 "${instid:label} ${cpidx:cpentry}", []>;
643 // FIXME: Marking these as hasSideEffects is necessary to prevent machine DCE
644 // from removing one half of the matched pairs. That breaks PEI, which assumes
645 // these will always be in pairs, and asserts if it finds otherwise. Better way?
646 let Defs = [SP], Uses = [SP], hasSideEffects = 1 in {
648 PseudoInst<(outs), (ins i32imm:$amt1, i32imm:$amt2, pred:$p), NoItinerary,
649 "@ ADJCALLSTACKUP $amt1",
650 [(ARMcallseq_end timm:$amt1, timm:$amt2)]>;
652 def ADJCALLSTACKDOWN :
653 PseudoInst<(outs), (ins i32imm:$amt, pred:$p), NoItinerary,
654 "@ ADJCALLSTACKDOWN $amt",
655 [(ARMcallseq_start timm:$amt)]>;
658 def NOP : AI<(outs), (ins), MiscFrm, NoItinerary, "nop", "",
659 [/* For disassembly only; pattern left blank */]>,
660 Requires<[IsARM, HasV6T2]> {
661 let Inst{27-16} = 0b001100100000;
662 let Inst{7-0} = 0b00000000;
665 def YIELD : AI<(outs), (ins), MiscFrm, NoItinerary, "yield", "",
666 [/* For disassembly only; pattern left blank */]>,
667 Requires<[IsARM, HasV6T2]> {
668 let Inst{27-16} = 0b001100100000;
669 let Inst{7-0} = 0b00000001;
672 def WFE : AI<(outs), (ins), MiscFrm, NoItinerary, "wfe", "",
673 [/* For disassembly only; pattern left blank */]>,
674 Requires<[IsARM, HasV6T2]> {
675 let Inst{27-16} = 0b001100100000;
676 let Inst{7-0} = 0b00000010;
679 def WFI : AI<(outs), (ins), MiscFrm, NoItinerary, "wfi", "",
680 [/* For disassembly only; pattern left blank */]>,
681 Requires<[IsARM, HasV6T2]> {
682 let Inst{27-16} = 0b001100100000;
683 let Inst{7-0} = 0b00000011;
686 def SEL : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm, NoItinerary, "sel",
688 [/* For disassembly only; pattern left blank */]>,
689 Requires<[IsARM, HasV6]> {
690 let Inst{27-20} = 0b01101000;
691 let Inst{7-4} = 0b1011;
694 def SEV : AI<(outs), (ins), MiscFrm, NoItinerary, "sev", "",
695 [/* For disassembly only; pattern left blank */]>,
696 Requires<[IsARM, HasV6T2]> {
697 let Inst{27-16} = 0b001100100000;
698 let Inst{7-0} = 0b00000100;
701 // The i32imm operand $val can be used by a debugger to store more information
702 // about the breakpoint.
703 def BKPT : AI<(outs), (ins i32imm:$val), MiscFrm, NoItinerary, "bkpt", "\t$val",
704 [/* For disassembly only; pattern left blank */]>,
706 let Inst{27-20} = 0b00010010;
707 let Inst{7-4} = 0b0111;
710 // Change Processor State is a system instruction -- for disassembly only.
711 // The singleton $opt operand contains the following information:
712 // opt{4-0} = mode from Inst{4-0}
713 // opt{5} = changemode from Inst{17}
714 // opt{8-6} = AIF from Inst{8-6}
715 // opt{10-9} = imod from Inst{19-18} with 0b10 as enable and 0b11 as disable
716 def CPS : AXI<(outs), (ins cps_opt:$opt), MiscFrm, NoItinerary, "cps$opt",
717 [/* For disassembly only; pattern left blank */]>,
719 let Inst{31-28} = 0b1111;
720 let Inst{27-20} = 0b00010000;
725 // Preload signals the memory system of possible future data/instruction access.
726 // These are for disassembly only.
728 // A8.6.117, A8.6.118. Different instructions are generated for #0 and #-0.
729 // The neg_zero operand translates -0 to -1, -1 to -2, ..., etc.
730 multiclass APreLoad<bit data, bit read, string opc> {
732 def i : AXI<(outs), (ins GPR:$base, neg_zero:$imm), MiscFrm, NoItinerary,
733 !strconcat(opc, "\t[$base, $imm]"), []> {
734 let Inst{31-26} = 0b111101;
735 let Inst{25} = 0; // 0 for immediate form
738 let Inst{21-20} = 0b01;
741 def r : AXI<(outs), (ins addrmode2:$addr), MiscFrm, NoItinerary,
742 !strconcat(opc, "\t$addr"), []> {
743 let Inst{31-26} = 0b111101;
744 let Inst{25} = 1; // 1 for register form
747 let Inst{21-20} = 0b01;
752 defm PLD : APreLoad<1, 1, "pld">;
753 defm PLDW : APreLoad<1, 0, "pldw">;
754 defm PLI : APreLoad<0, 1, "pli">;
756 def SETENDBE : AXI<(outs),(ins), MiscFrm, NoItinerary, "setend\tbe",
757 [/* For disassembly only; pattern left blank */]>,
759 let Inst{31-28} = 0b1111;
760 let Inst{27-20} = 0b00010000;
763 let Inst{7-4} = 0b0000;
766 def SETENDLE : AXI<(outs),(ins), MiscFrm, NoItinerary, "setend\tle",
767 [/* For disassembly only; pattern left blank */]>,
769 let Inst{31-28} = 0b1111;
770 let Inst{27-20} = 0b00010000;
773 let Inst{7-4} = 0b0000;
776 def DBG : AI<(outs), (ins i32imm:$opt), MiscFrm, NoItinerary, "dbg", "\t$opt",
777 [/* For disassembly only; pattern left blank */]>,
778 Requires<[IsARM, HasV7]> {
779 let Inst{27-16} = 0b001100100000;
780 let Inst{7-4} = 0b1111;
783 // A5.4 Permanently UNDEFINED instructions.
784 def TRAP : AI<(outs), (ins), MiscFrm, NoItinerary, "trap", "",
785 [/* For disassembly only; pattern left blank */]>,
787 let Inst{27-25} = 0b011;
788 let Inst{24-20} = 0b11111;
789 let Inst{7-5} = 0b111;
793 // Address computation and loads and stores in PIC mode.
794 let isNotDuplicable = 1 in {
795 def PICADD : AXI1<0b0100, (outs GPR:$dst), (ins GPR:$a, pclabel:$cp, pred:$p),
796 Pseudo, IIC_iALUr, "\n$cp:\n\tadd$p\t$dst, pc, $a",
797 [(set GPR:$dst, (ARMpic_add GPR:$a, imm:$cp))]>;
799 let AddedComplexity = 10 in {
800 def PICLDR : AXI2ldw<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
801 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldr$p\t$dst, $addr",
802 [(set GPR:$dst, (load addrmodepc:$addr))]>;
804 def PICLDRH : AXI3ldh<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
805 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldrh${p}\t$dst, $addr",
806 [(set GPR:$dst, (zextloadi16 addrmodepc:$addr))]>;
808 def PICLDRB : AXI2ldb<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
809 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldrb${p}\t$dst, $addr",
810 [(set GPR:$dst, (zextloadi8 addrmodepc:$addr))]>;
812 def PICLDRSH : AXI3ldsh<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
813 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldrsh${p}\t$dst, $addr",
814 [(set GPR:$dst, (sextloadi16 addrmodepc:$addr))]>;
816 def PICLDRSB : AXI3ldsb<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
817 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldrsb${p}\t$dst, $addr",
818 [(set GPR:$dst, (sextloadi8 addrmodepc:$addr))]>;
820 let AddedComplexity = 10 in {
821 def PICSTR : AXI2stw<(outs), (ins GPR:$src, addrmodepc:$addr, pred:$p),
822 Pseudo, IIC_iStorer, "\n${addr:label}:\n\tstr$p\t$src, $addr",
823 [(store GPR:$src, addrmodepc:$addr)]>;
825 def PICSTRH : AXI3sth<(outs), (ins GPR:$src, addrmodepc:$addr, pred:$p),
826 Pseudo, IIC_iStorer, "\n${addr:label}:\n\tstrh${p}\t$src, $addr",
827 [(truncstorei16 GPR:$src, addrmodepc:$addr)]>;
829 def PICSTRB : AXI2stb<(outs), (ins GPR:$src, addrmodepc:$addr, pred:$p),
830 Pseudo, IIC_iStorer, "\n${addr:label}:\n\tstrb${p}\t$src, $addr",
831 [(truncstorei8 GPR:$src, addrmodepc:$addr)]>;
833 } // isNotDuplicable = 1
836 // LEApcrel - Load a pc-relative address into a register without offending the
838 def LEApcrel : AXI1<0x0, (outs GPR:$dst), (ins i32imm:$label, pred:$p),
840 !strconcat(!strconcat(".set ${:private}PCRELV${:uid}, ($label-(",
841 "${:private}PCRELL${:uid}+8))\n"),
842 !strconcat("${:private}PCRELL${:uid}:\n\t",
843 "add$p\t$dst, pc, #${:private}PCRELV${:uid}")),
846 def LEApcrelJT : AXI1<0x0, (outs GPR:$dst),
847 (ins i32imm:$label, nohash_imm:$id, pred:$p),
849 !strconcat(!strconcat(".set ${:private}PCRELV${:uid}, "
851 "${:private}PCRELL${:uid}+8))\n"),
852 !strconcat("${:private}PCRELL${:uid}:\n\t",
853 "add$p\t$dst, pc, #${:private}PCRELV${:uid}")),
858 //===----------------------------------------------------------------------===//
859 // Control Flow Instructions.
862 let isReturn = 1, isTerminator = 1, isBarrier = 1 in {
864 def BX_RET : AI<(outs), (ins), BrMiscFrm, IIC_Br,
865 "bx", "\tlr", [(ARMretflag)]>,
866 Requires<[IsARM, HasV4T]> {
867 let Inst{3-0} = 0b1110;
868 let Inst{7-4} = 0b0001;
869 let Inst{19-8} = 0b111111111111;
870 let Inst{27-20} = 0b00010010;
874 def MOVPCLR : AI<(outs), (ins), BrMiscFrm, IIC_Br,
875 "mov", "\tpc, lr", [(ARMretflag)]>,
876 Requires<[IsARM, NoV4T]> {
877 let Inst{11-0} = 0b000000001110;
878 let Inst{15-12} = 0b1111;
879 let Inst{19-16} = 0b0000;
880 let Inst{27-20} = 0b00011010;
885 let isBranch = 1, isTerminator = 1, isBarrier = 1, isIndirectBranch = 1 in {
887 def BRIND : AXI<(outs), (ins GPR:$dst), BrMiscFrm, IIC_Br, "bx\t$dst",
889 Requires<[IsARM, HasV4T]> {
890 let Inst{7-4} = 0b0001;
891 let Inst{19-8} = 0b111111111111;
892 let Inst{27-20} = 0b00010010;
893 let Inst{31-28} = 0b1110;
897 def MOVPCRX : AXI<(outs), (ins GPR:$dst), BrMiscFrm, IIC_Br, "mov\tpc, $dst",
899 Requires<[IsARM, NoV4T]> {
900 let Inst{11-4} = 0b00000000;
901 let Inst{15-12} = 0b1111;
902 let Inst{19-16} = 0b0000;
903 let Inst{27-20} = 0b00011010;
904 let Inst{31-28} = 0b1110;
908 // FIXME: remove when we have a way to marking a MI with these properties.
909 // FIXME: Should pc be an implicit operand like PICADD, etc?
910 let isReturn = 1, isTerminator = 1, isBarrier = 1, mayLoad = 1,
911 hasExtraDefRegAllocReq = 1 in
912 def LDM_RET : AXI4ld<(outs GPR:$wb), (ins addrmode4:$addr, pred:$p,
913 reglist:$dsts, variable_ops),
914 IndexModeUpd, LdStMulFrm, IIC_Br,
915 "ldm${addr:submode}${p}\t$addr!, $dsts",
916 "$addr.addr = $wb", []>;
918 // On non-Darwin platforms R9 is callee-saved.
920 Defs = [R0, R1, R2, R3, R12, LR,
921 D0, D1, D2, D3, D4, D5, D6, D7,
922 D16, D17, D18, D19, D20, D21, D22, D23,
923 D24, D25, D26, D27, D28, D29, D30, D31, CPSR, FPSCR] in {
924 def BL : ABXI<0b1011, (outs), (ins i32imm:$func, variable_ops),
925 IIC_Br, "bl\t${func:call}",
926 [(ARMcall tglobaladdr:$func)]>,
927 Requires<[IsARM, IsNotDarwin]> {
928 let Inst{31-28} = 0b1110;
931 def BL_pred : ABI<0b1011, (outs), (ins i32imm:$func, variable_ops),
932 IIC_Br, "bl", "\t${func:call}",
933 [(ARMcall_pred tglobaladdr:$func)]>,
934 Requires<[IsARM, IsNotDarwin]>;
937 def BLX : AXI<(outs), (ins GPR:$func, variable_ops), BrMiscFrm,
938 IIC_Br, "blx\t$func",
939 [(ARMcall GPR:$func)]>,
940 Requires<[IsARM, HasV5T, IsNotDarwin]> {
941 let Inst{7-4} = 0b0011;
942 let Inst{19-8} = 0b111111111111;
943 let Inst{27-20} = 0b00010010;
947 // Note: Restrict $func to the tGPR regclass to prevent it being in LR.
948 def BX : ABXIx2<(outs), (ins tGPR:$func, variable_ops),
949 IIC_Br, "mov\tlr, pc\n\tbx\t$func",
950 [(ARMcall_nolink tGPR:$func)]>,
951 Requires<[IsARM, HasV4T, IsNotDarwin]> {
952 let Inst{7-4} = 0b0001;
953 let Inst{19-8} = 0b111111111111;
954 let Inst{27-20} = 0b00010010;
958 def BMOVPCRX : ABXIx2<(outs), (ins tGPR:$func, variable_ops),
959 IIC_Br, "mov\tlr, pc\n\tmov\tpc, $func",
960 [(ARMcall_nolink tGPR:$func)]>,
961 Requires<[IsARM, NoV4T, IsNotDarwin]> {
962 let Inst{11-4} = 0b00000000;
963 let Inst{15-12} = 0b1111;
964 let Inst{19-16} = 0b0000;
965 let Inst{27-20} = 0b00011010;
969 // On Darwin R9 is call-clobbered.
971 Defs = [R0, R1, R2, R3, R9, R12, LR,
972 D0, D1, D2, D3, D4, D5, D6, D7,
973 D16, D17, D18, D19, D20, D21, D22, D23,
974 D24, D25, D26, D27, D28, D29, D30, D31, CPSR, FPSCR] in {
975 def BLr9 : ABXI<0b1011, (outs), (ins i32imm:$func, variable_ops),
976 IIC_Br, "bl\t${func:call}",
977 [(ARMcall tglobaladdr:$func)]>, Requires<[IsARM, IsDarwin]> {
978 let Inst{31-28} = 0b1110;
981 def BLr9_pred : ABI<0b1011, (outs), (ins i32imm:$func, variable_ops),
982 IIC_Br, "bl", "\t${func:call}",
983 [(ARMcall_pred tglobaladdr:$func)]>,
984 Requires<[IsARM, IsDarwin]>;
987 def BLXr9 : AXI<(outs), (ins GPR:$func, variable_ops), BrMiscFrm,
988 IIC_Br, "blx\t$func",
989 [(ARMcall GPR:$func)]>, Requires<[IsARM, HasV5T, IsDarwin]> {
990 let Inst{7-4} = 0b0011;
991 let Inst{19-8} = 0b111111111111;
992 let Inst{27-20} = 0b00010010;
996 // Note: Restrict $func to the tGPR regclass to prevent it being in LR.
997 def BXr9 : ABXIx2<(outs), (ins tGPR:$func, variable_ops),
998 IIC_Br, "mov\tlr, pc\n\tbx\t$func",
999 [(ARMcall_nolink tGPR:$func)]>,
1000 Requires<[IsARM, HasV4T, IsDarwin]> {
1001 let Inst{7-4} = 0b0001;
1002 let Inst{19-8} = 0b111111111111;
1003 let Inst{27-20} = 0b00010010;
1007 def BMOVPCRXr9 : ABXIx2<(outs), (ins tGPR:$func, variable_ops),
1008 IIC_Br, "mov\tlr, pc\n\tmov\tpc, $func",
1009 [(ARMcall_nolink tGPR:$func)]>,
1010 Requires<[IsARM, NoV4T, IsDarwin]> {
1011 let Inst{11-4} = 0b00000000;
1012 let Inst{15-12} = 0b1111;
1013 let Inst{19-16} = 0b0000;
1014 let Inst{27-20} = 0b00011010;
1018 let isBranch = 1, isTerminator = 1 in {
1019 // B is "predicable" since it can be xformed into a Bcc.
1020 let isBarrier = 1 in {
1021 let isPredicable = 1 in
1022 def B : ABXI<0b1010, (outs), (ins brtarget:$target), IIC_Br,
1023 "b\t$target", [(br bb:$target)]>;
1025 let isNotDuplicable = 1, isIndirectBranch = 1 in {
1026 def BR_JTr : JTI<(outs), (ins GPR:$target, jtblock_operand:$jt, i32imm:$id),
1027 IIC_Br, "mov\tpc, $target \n$jt",
1028 [(ARMbrjt GPR:$target, tjumptable:$jt, imm:$id)]> {
1029 let Inst{11-4} = 0b00000000;
1030 let Inst{15-12} = 0b1111;
1031 let Inst{20} = 0; // S Bit
1032 let Inst{24-21} = 0b1101;
1033 let Inst{27-25} = 0b000;
1035 def BR_JTm : JTI<(outs),
1036 (ins addrmode2:$target, jtblock_operand:$jt, i32imm:$id),
1037 IIC_Br, "ldr\tpc, $target \n$jt",
1038 [(ARMbrjt (i32 (load addrmode2:$target)), tjumptable:$jt,
1040 let Inst{15-12} = 0b1111;
1041 let Inst{20} = 1; // L bit
1042 let Inst{21} = 0; // W bit
1043 let Inst{22} = 0; // B bit
1044 let Inst{24} = 1; // P bit
1045 let Inst{27-25} = 0b011;
1047 def BR_JTadd : JTI<(outs),
1048 (ins GPR:$target, GPR:$idx, jtblock_operand:$jt, i32imm:$id),
1049 IIC_Br, "add\tpc, $target, $idx \n$jt",
1050 [(ARMbrjt (add GPR:$target, GPR:$idx), tjumptable:$jt,
1052 let Inst{15-12} = 0b1111;
1053 let Inst{20} = 0; // S bit
1054 let Inst{24-21} = 0b0100;
1055 let Inst{27-25} = 0b000;
1057 } // isNotDuplicable = 1, isIndirectBranch = 1
1060 // FIXME: should be able to write a pattern for ARMBrcond, but can't use
1061 // a two-value operand where a dag node expects two operands. :(
1062 def Bcc : ABI<0b1010, (outs), (ins brtarget:$target),
1063 IIC_Br, "b", "\t$target",
1064 [/*(ARMbrcond bb:$target, imm:$cc, CCR:$ccr)*/]>;
1067 // Branch and Exchange Jazelle -- for disassembly only
1068 def BXJ : ABI<0b0001, (outs), (ins GPR:$func), NoItinerary, "bxj", "\t$func",
1069 [/* For disassembly only; pattern left blank */]> {
1070 let Inst{23-20} = 0b0010;
1071 //let Inst{19-8} = 0xfff;
1072 let Inst{7-4} = 0b0010;
1075 // Secure Monitor Call is a system instruction -- for disassembly only
1076 def SMC : ABI<0b0001, (outs), (ins i32imm:$opt), NoItinerary, "smc", "\t$opt",
1077 [/* For disassembly only; pattern left blank */]> {
1078 let Inst{23-20} = 0b0110;
1079 let Inst{7-4} = 0b0111;
1082 // Supervisor Call (Software Interrupt) -- for disassembly only
1084 def SVC : ABI<0b1111, (outs), (ins i32imm:$svc), IIC_Br, "svc", "\t$svc",
1085 [/* For disassembly only; pattern left blank */]>;
1088 // Store Return State is a system instruction -- for disassembly only
1089 def SRSW : ABXI<{1,0,0,?}, (outs), (ins addrmode4:$addr, i32imm:$mode),
1090 NoItinerary, "srs${addr:submode}\tsp!, $mode",
1091 [/* For disassembly only; pattern left blank */]> {
1092 let Inst{31-28} = 0b1111;
1093 let Inst{22-20} = 0b110; // W = 1
1096 def SRS : ABXI<{1,0,0,?}, (outs), (ins addrmode4:$addr, i32imm:$mode),
1097 NoItinerary, "srs${addr:submode}\tsp, $mode",
1098 [/* For disassembly only; pattern left blank */]> {
1099 let Inst{31-28} = 0b1111;
1100 let Inst{22-20} = 0b100; // W = 0
1103 // Return From Exception is a system instruction -- for disassembly only
1104 def RFEW : ABXI<{1,0,0,?}, (outs), (ins addrmode4:$addr, GPR:$base),
1105 NoItinerary, "rfe${addr:submode}\t$base!",
1106 [/* For disassembly only; pattern left blank */]> {
1107 let Inst{31-28} = 0b1111;
1108 let Inst{22-20} = 0b011; // W = 1
1111 def RFE : ABXI<{1,0,0,?}, (outs), (ins addrmode4:$addr, GPR:$base),
1112 NoItinerary, "rfe${addr:submode}\t$base",
1113 [/* For disassembly only; pattern left blank */]> {
1114 let Inst{31-28} = 0b1111;
1115 let Inst{22-20} = 0b001; // W = 0
1118 //===----------------------------------------------------------------------===//
1119 // Load / store Instructions.
1123 let canFoldAsLoad = 1, isReMaterializable = 1 in
1124 def LDR : AI2ldw<(outs GPR:$dst), (ins addrmode2:$addr), LdFrm, IIC_iLoadr,
1125 "ldr", "\t$dst, $addr",
1126 [(set GPR:$dst, (load addrmode2:$addr))]>;
1128 // Special LDR for loads from non-pc-relative constpools.
1129 let canFoldAsLoad = 1, mayLoad = 1, isReMaterializable = 1 in
1130 def LDRcp : AI2ldw<(outs GPR:$dst), (ins addrmode2:$addr), LdFrm, IIC_iLoadr,
1131 "ldr", "\t$dst, $addr", []>;
1133 // Loads with zero extension
1134 def LDRH : AI3ldh<(outs GPR:$dst), (ins addrmode3:$addr), LdMiscFrm,
1135 IIC_iLoadr, "ldrh", "\t$dst, $addr",
1136 [(set GPR:$dst, (zextloadi16 addrmode3:$addr))]>;
1138 def LDRB : AI2ldb<(outs GPR:$dst), (ins addrmode2:$addr), LdFrm,
1139 IIC_iLoadr, "ldrb", "\t$dst, $addr",
1140 [(set GPR:$dst, (zextloadi8 addrmode2:$addr))]>;
1142 // Loads with sign extension
1143 def LDRSH : AI3ldsh<(outs GPR:$dst), (ins addrmode3:$addr), LdMiscFrm,
1144 IIC_iLoadr, "ldrsh", "\t$dst, $addr",
1145 [(set GPR:$dst, (sextloadi16 addrmode3:$addr))]>;
1147 def LDRSB : AI3ldsb<(outs GPR:$dst), (ins addrmode3:$addr), LdMiscFrm,
1148 IIC_iLoadr, "ldrsb", "\t$dst, $addr",
1149 [(set GPR:$dst, (sextloadi8 addrmode3:$addr))]>;
1151 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in {
1153 def LDRD : AI3ldd<(outs GPR:$dst1, GPR:$dst2), (ins addrmode3:$addr), LdMiscFrm,
1154 IIC_iLoadr, "ldrd", "\t$dst1, $addr",
1155 []>, Requires<[IsARM, HasV5TE]>;
1158 def LDR_PRE : AI2ldwpr<(outs GPR:$dst, GPR:$base_wb),
1159 (ins addrmode2:$addr), LdFrm, IIC_iLoadru,
1160 "ldr", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1162 def LDR_POST : AI2ldwpo<(outs GPR:$dst, GPR:$base_wb),
1163 (ins GPR:$base, am2offset:$offset), LdFrm, IIC_iLoadru,
1164 "ldr", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1166 def LDRH_PRE : AI3ldhpr<(outs GPR:$dst, GPR:$base_wb),
1167 (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadru,
1168 "ldrh", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1170 def LDRH_POST : AI3ldhpo<(outs GPR:$dst, GPR:$base_wb),
1171 (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1172 "ldrh", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1174 def LDRB_PRE : AI2ldbpr<(outs GPR:$dst, GPR:$base_wb),
1175 (ins addrmode2:$addr), LdFrm, IIC_iLoadru,
1176 "ldrb", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1178 def LDRB_POST : AI2ldbpo<(outs GPR:$dst, GPR:$base_wb),
1179 (ins GPR:$base,am2offset:$offset), LdFrm, IIC_iLoadru,
1180 "ldrb", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1182 def LDRSH_PRE : AI3ldshpr<(outs GPR:$dst, GPR:$base_wb),
1183 (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadru,
1184 "ldrsh", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1186 def LDRSH_POST: AI3ldshpo<(outs GPR:$dst, GPR:$base_wb),
1187 (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1188 "ldrsh", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1190 def LDRSB_PRE : AI3ldsbpr<(outs GPR:$dst, GPR:$base_wb),
1191 (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadru,
1192 "ldrsb", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1194 def LDRSB_POST: AI3ldsbpo<(outs GPR:$dst, GPR:$base_wb),
1195 (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1196 "ldrsb", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1198 // For disassembly only
1199 def LDRD_PRE : AI3lddpr<(outs GPR:$dst1, GPR:$dst2, GPR:$base_wb),
1200 (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadr,
1201 "ldrd", "\t$dst1, $dst2, $addr!", "$addr.base = $base_wb", []>,
1202 Requires<[IsARM, HasV5TE]>;
1204 // For disassembly only
1205 def LDRD_POST : AI3lddpo<(outs GPR:$dst1, GPR:$dst2, GPR:$base_wb),
1206 (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadr,
1207 "ldrd", "\t$dst1, $dst2, [$base], $offset", "$base = $base_wb", []>,
1208 Requires<[IsARM, HasV5TE]>;
1212 // LDRT, LDRBT, LDRSBT, LDRHT, LDRSHT are for disassembly only.
1214 def LDRT : AI2ldwpo<(outs GPR:$dst, GPR:$base_wb),
1215 (ins GPR:$base, am2offset:$offset), LdFrm, IIC_iLoadru,
1216 "ldrt", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1217 let Inst{21} = 1; // overwrite
1220 def LDRBT : AI2ldbpo<(outs GPR:$dst, GPR:$base_wb),
1221 (ins GPR:$base,am2offset:$offset), LdFrm, IIC_iLoadru,
1222 "ldrbt", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1223 let Inst{21} = 1; // overwrite
1226 def LDRSBT : AI3ldsbpo<(outs GPR:$dst, GPR:$base_wb),
1227 (ins GPR:$base,am2offset:$offset), LdMiscFrm, IIC_iLoadru,
1228 "ldrsbt", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1229 let Inst{21} = 1; // overwrite
1232 def LDRHT : AI3ldhpo<(outs GPR:$dst, GPR:$base_wb),
1233 (ins GPR:$base, am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1234 "ldrht", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1235 let Inst{21} = 1; // overwrite
1238 def LDRSHT : AI3ldshpo<(outs GPR:$dst, GPR:$base_wb),
1239 (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1240 "ldrsht", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1241 let Inst{21} = 1; // overwrite
1245 def STR : AI2stw<(outs), (ins GPR:$src, addrmode2:$addr), StFrm, IIC_iStorer,
1246 "str", "\t$src, $addr",
1247 [(store GPR:$src, addrmode2:$addr)]>;
1249 // Stores with truncate
1250 def STRH : AI3sth<(outs), (ins GPR:$src, addrmode3:$addr), StMiscFrm,
1251 IIC_iStorer, "strh", "\t$src, $addr",
1252 [(truncstorei16 GPR:$src, addrmode3:$addr)]>;
1254 def STRB : AI2stb<(outs), (ins GPR:$src, addrmode2:$addr), StFrm, IIC_iStorer,
1255 "strb", "\t$src, $addr",
1256 [(truncstorei8 GPR:$src, addrmode2:$addr)]>;
1259 let mayStore = 1, hasExtraSrcRegAllocReq = 1 in
1260 def STRD : AI3std<(outs), (ins GPR:$src1, GPR:$src2, addrmode3:$addr),
1261 StMiscFrm, IIC_iStorer,
1262 "strd", "\t$src1, $addr", []>, Requires<[IsARM, HasV5TE]>;
1265 def STR_PRE : AI2stwpr<(outs GPR:$base_wb),
1266 (ins GPR:$src, GPR:$base, am2offset:$offset),
1267 StFrm, IIC_iStoreru,
1268 "str", "\t$src, [$base, $offset]!", "$base = $base_wb",
1270 (pre_store GPR:$src, GPR:$base, am2offset:$offset))]>;
1272 def STR_POST : AI2stwpo<(outs GPR:$base_wb),
1273 (ins GPR:$src, GPR:$base,am2offset:$offset),
1274 StFrm, IIC_iStoreru,
1275 "str", "\t$src, [$base], $offset", "$base = $base_wb",
1277 (post_store GPR:$src, GPR:$base, am2offset:$offset))]>;
1279 def STRH_PRE : AI3sthpr<(outs GPR:$base_wb),
1280 (ins GPR:$src, GPR:$base,am3offset:$offset),
1281 StMiscFrm, IIC_iStoreru,
1282 "strh", "\t$src, [$base, $offset]!", "$base = $base_wb",
1284 (pre_truncsti16 GPR:$src, GPR:$base,am3offset:$offset))]>;
1286 def STRH_POST: AI3sthpo<(outs GPR:$base_wb),
1287 (ins GPR:$src, GPR:$base,am3offset:$offset),
1288 StMiscFrm, IIC_iStoreru,
1289 "strh", "\t$src, [$base], $offset", "$base = $base_wb",
1290 [(set GPR:$base_wb, (post_truncsti16 GPR:$src,
1291 GPR:$base, am3offset:$offset))]>;
1293 def STRB_PRE : AI2stbpr<(outs GPR:$base_wb),
1294 (ins GPR:$src, GPR:$base,am2offset:$offset),
1295 StFrm, IIC_iStoreru,
1296 "strb", "\t$src, [$base, $offset]!", "$base = $base_wb",
1297 [(set GPR:$base_wb, (pre_truncsti8 GPR:$src,
1298 GPR:$base, am2offset:$offset))]>;
1300 def STRB_POST: AI2stbpo<(outs GPR:$base_wb),
1301 (ins GPR:$src, GPR:$base,am2offset:$offset),
1302 StFrm, IIC_iStoreru,
1303 "strb", "\t$src, [$base], $offset", "$base = $base_wb",
1304 [(set GPR:$base_wb, (post_truncsti8 GPR:$src,
1305 GPR:$base, am2offset:$offset))]>;
1307 // For disassembly only
1308 def STRD_PRE : AI3stdpr<(outs GPR:$base_wb),
1309 (ins GPR:$src1, GPR:$src2, GPR:$base, am3offset:$offset),
1310 StMiscFrm, IIC_iStoreru,
1311 "strd", "\t$src1, $src2, [$base, $offset]!",
1312 "$base = $base_wb", []>;
1314 // For disassembly only
1315 def STRD_POST: AI3stdpo<(outs GPR:$base_wb),
1316 (ins GPR:$src1, GPR:$src2, GPR:$base, am3offset:$offset),
1317 StMiscFrm, IIC_iStoreru,
1318 "strd", "\t$src1, $src2, [$base], $offset",
1319 "$base = $base_wb", []>;
1321 // STRT, STRBT, and STRHT are for disassembly only.
1323 def STRT : AI2stwpo<(outs GPR:$base_wb),
1324 (ins GPR:$src, GPR:$base,am2offset:$offset),
1325 StFrm, IIC_iStoreru,
1326 "strt", "\t$src, [$base], $offset", "$base = $base_wb",
1327 [/* For disassembly only; pattern left blank */]> {
1328 let Inst{21} = 1; // overwrite
1331 def STRBT : AI2stbpo<(outs GPR:$base_wb),
1332 (ins GPR:$src, GPR:$base,am2offset:$offset),
1333 StFrm, IIC_iStoreru,
1334 "strbt", "\t$src, [$base], $offset", "$base = $base_wb",
1335 [/* For disassembly only; pattern left blank */]> {
1336 let Inst{21} = 1; // overwrite
1339 def STRHT: AI3sthpo<(outs GPR:$base_wb),
1340 (ins GPR:$src, GPR:$base,am3offset:$offset),
1341 StMiscFrm, IIC_iStoreru,
1342 "strht", "\t$src, [$base], $offset", "$base = $base_wb",
1343 [/* For disassembly only; pattern left blank */]> {
1344 let Inst{21} = 1; // overwrite
1347 //===----------------------------------------------------------------------===//
1348 // Load / store multiple Instructions.
1351 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in {
1352 def LDM : AXI4ld<(outs), (ins addrmode4:$addr, pred:$p,
1353 reglist:$dsts, variable_ops),
1354 IndexModeNone, LdStMulFrm, IIC_iLoadm,
1355 "ldm${addr:submode}${p}\t$addr, $dsts", "", []>;
1357 def LDM_UPD : AXI4ld<(outs GPR:$wb), (ins addrmode4:$addr, pred:$p,
1358 reglist:$dsts, variable_ops),
1359 IndexModeUpd, LdStMulFrm, IIC_iLoadm,
1360 "ldm${addr:submode}${p}\t$addr!, $dsts",
1361 "$addr.addr = $wb", []>;
1362 } // mayLoad, hasExtraDefRegAllocReq
1364 let mayStore = 1, hasExtraSrcRegAllocReq = 1 in {
1365 def STM : AXI4st<(outs), (ins addrmode4:$addr, pred:$p,
1366 reglist:$srcs, variable_ops),
1367 IndexModeNone, LdStMulFrm, IIC_iStorem,
1368 "stm${addr:submode}${p}\t$addr, $srcs", "", []>;
1370 def STM_UPD : AXI4st<(outs GPR:$wb), (ins addrmode4:$addr, pred:$p,
1371 reglist:$srcs, variable_ops),
1372 IndexModeUpd, LdStMulFrm, IIC_iStorem,
1373 "stm${addr:submode}${p}\t$addr!, $srcs",
1374 "$addr.addr = $wb", []>;
1375 } // mayStore, hasExtraSrcRegAllocReq
1377 //===----------------------------------------------------------------------===//
1378 // Move Instructions.
1381 let neverHasSideEffects = 1 in
1382 def MOVr : AsI1<0b1101, (outs GPR:$dst), (ins GPR:$src), DPFrm, IIC_iMOVr,
1383 "mov", "\t$dst, $src", []>, UnaryDP {
1384 let Inst{11-4} = 0b00000000;
1388 def MOVs : AsI1<0b1101, (outs GPR:$dst), (ins so_reg:$src),
1389 DPSoRegFrm, IIC_iMOVsr,
1390 "mov", "\t$dst, $src", [(set GPR:$dst, so_reg:$src)]>, UnaryDP {
1394 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
1395 def MOVi : AsI1<0b1101, (outs GPR:$dst), (ins so_imm:$src), DPFrm, IIC_iMOVi,
1396 "mov", "\t$dst, $src", [(set GPR:$dst, so_imm:$src)]>, UnaryDP {
1400 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
1401 def MOVi16 : AI1<0b1000, (outs GPR:$dst), (ins i32imm:$src),
1403 "movw", "\t$dst, $src",
1404 [(set GPR:$dst, imm0_65535:$src)]>,
1405 Requires<[IsARM, HasV6T2]>, UnaryDP {
1410 let Constraints = "$src = $dst" in
1411 def MOVTi16 : AI1<0b1010, (outs GPR:$dst), (ins GPR:$src, i32imm:$imm),
1413 "movt", "\t$dst, $imm",
1415 (or (and GPR:$src, 0xffff),
1416 lo16AllZero:$imm))]>, UnaryDP,
1417 Requires<[IsARM, HasV6T2]> {
1422 def : ARMPat<(or GPR:$src, 0xffff0000), (MOVTi16 GPR:$src, 0xffff)>,
1423 Requires<[IsARM, HasV6T2]>;
1425 let Uses = [CPSR] in
1426 def MOVrx : AsI1<0b1101, (outs GPR:$dst), (ins GPR:$src), Pseudo, IIC_iMOVsi,
1427 "mov", "\t$dst, $src, rrx",
1428 [(set GPR:$dst, (ARMrrx GPR:$src))]>, UnaryDP;
1430 // These aren't really mov instructions, but we have to define them this way
1431 // due to flag operands.
1433 let Defs = [CPSR] in {
1434 def MOVsrl_flag : AI1<0b1101, (outs GPR:$dst), (ins GPR:$src), Pseudo,
1435 IIC_iMOVsi, "movs", "\t$dst, $src, lsr #1",
1436 [(set GPR:$dst, (ARMsrl_flag GPR:$src))]>, UnaryDP;
1437 def MOVsra_flag : AI1<0b1101, (outs GPR:$dst), (ins GPR:$src), Pseudo,
1438 IIC_iMOVsi, "movs", "\t$dst, $src, asr #1",
1439 [(set GPR:$dst, (ARMsra_flag GPR:$src))]>, UnaryDP;
1442 //===----------------------------------------------------------------------===//
1443 // Extend Instructions.
1448 defm SXTB : AI_unary_rrot<0b01101010,
1449 "sxtb", UnOpFrag<(sext_inreg node:$Src, i8)>>;
1450 defm SXTH : AI_unary_rrot<0b01101011,
1451 "sxth", UnOpFrag<(sext_inreg node:$Src, i16)>>;
1453 defm SXTAB : AI_bin_rrot<0b01101010,
1454 "sxtab", BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS, i8))>>;
1455 defm SXTAH : AI_bin_rrot<0b01101011,
1456 "sxtah", BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS,i16))>>;
1458 // For disassembly only
1459 defm SXTB16 : AI_unary_rrot_np<0b01101000, "sxtb16">;
1461 // For disassembly only
1462 defm SXTAB16 : AI_bin_rrot_np<0b01101000, "sxtab16">;
1466 let AddedComplexity = 16 in {
1467 defm UXTB : AI_unary_rrot<0b01101110,
1468 "uxtb" , UnOpFrag<(and node:$Src, 0x000000FF)>>;
1469 defm UXTH : AI_unary_rrot<0b01101111,
1470 "uxth" , UnOpFrag<(and node:$Src, 0x0000FFFF)>>;
1471 defm UXTB16 : AI_unary_rrot<0b01101100,
1472 "uxtb16", UnOpFrag<(and node:$Src, 0x00FF00FF)>>;
1474 def : ARMV6Pat<(and (shl GPR:$Src, (i32 8)), 0xFF00FF),
1475 (UXTB16r_rot GPR:$Src, 24)>;
1476 def : ARMV6Pat<(and (srl GPR:$Src, (i32 8)), 0xFF00FF),
1477 (UXTB16r_rot GPR:$Src, 8)>;
1479 defm UXTAB : AI_bin_rrot<0b01101110, "uxtab",
1480 BinOpFrag<(add node:$LHS, (and node:$RHS, 0x00FF))>>;
1481 defm UXTAH : AI_bin_rrot<0b01101111, "uxtah",
1482 BinOpFrag<(add node:$LHS, (and node:$RHS, 0xFFFF))>>;
1485 // This isn't safe in general, the add is two 16-bit units, not a 32-bit add.
1486 // For disassembly only
1487 defm UXTAB16 : AI_bin_rrot_np<0b01101100, "uxtab16">;
1490 def SBFX : I<(outs GPR:$dst),
1491 (ins GPR:$src, imm0_31:$lsb, imm0_31:$width),
1492 AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iALUi,
1493 "sbfx", "\t$dst, $src, $lsb, $width", "", []>,
1494 Requires<[IsARM, HasV6T2]> {
1495 let Inst{27-21} = 0b0111101;
1496 let Inst{6-4} = 0b101;
1499 def UBFX : I<(outs GPR:$dst),
1500 (ins GPR:$src, imm0_31:$lsb, imm0_31:$width),
1501 AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iALUi,
1502 "ubfx", "\t$dst, $src, $lsb, $width", "", []>,
1503 Requires<[IsARM, HasV6T2]> {
1504 let Inst{27-21} = 0b0111111;
1505 let Inst{6-4} = 0b101;
1508 //===----------------------------------------------------------------------===//
1509 // Arithmetic Instructions.
1512 defm ADD : AsI1_bin_irs<0b0100, "add",
1513 BinOpFrag<(add node:$LHS, node:$RHS)>, 1>;
1514 defm SUB : AsI1_bin_irs<0b0010, "sub",
1515 BinOpFrag<(sub node:$LHS, node:$RHS)>>;
1517 // ADD and SUB with 's' bit set.
1518 defm ADDS : AI1_bin_s_irs<0b0100, "adds",
1519 BinOpFrag<(addc node:$LHS, node:$RHS)>, 1>;
1520 defm SUBS : AI1_bin_s_irs<0b0010, "subs",
1521 BinOpFrag<(subc node:$LHS, node:$RHS)>>;
1523 defm ADC : AI1_adde_sube_irs<0b0101, "adc",
1524 BinOpFrag<(adde_dead_carry node:$LHS, node:$RHS)>, 1>;
1525 defm SBC : AI1_adde_sube_irs<0b0110, "sbc",
1526 BinOpFrag<(sube_dead_carry node:$LHS, node:$RHS)>>;
1527 defm ADCS : AI1_adde_sube_s_irs<0b0101, "adcs",
1528 BinOpFrag<(adde_live_carry node:$LHS, node:$RHS)>, 1>;
1529 defm SBCS : AI1_adde_sube_s_irs<0b0110, "sbcs",
1530 BinOpFrag<(sube_live_carry node:$LHS, node:$RHS) >>;
1532 // These don't define reg/reg forms, because they are handled above.
1533 def RSBri : AsI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
1534 IIC_iALUi, "rsb", "\t$dst, $a, $b",
1535 [(set GPR:$dst, (sub so_imm:$b, GPR:$a))]> {
1539 def RSBrs : AsI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
1540 IIC_iALUsr, "rsb", "\t$dst, $a, $b",
1541 [(set GPR:$dst, (sub so_reg:$b, GPR:$a))]> {
1545 // RSB with 's' bit set.
1546 let Defs = [CPSR] in {
1547 def RSBSri : AI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
1548 IIC_iALUi, "rsbs", "\t$dst, $a, $b",
1549 [(set GPR:$dst, (subc so_imm:$b, GPR:$a))]> {
1553 def RSBSrs : AI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
1554 IIC_iALUsr, "rsbs", "\t$dst, $a, $b",
1555 [(set GPR:$dst, (subc so_reg:$b, GPR:$a))]> {
1561 let Uses = [CPSR] in {
1562 def RSCri : AsI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
1563 DPFrm, IIC_iALUi, "rsc", "\t$dst, $a, $b",
1564 [(set GPR:$dst, (sube_dead_carry so_imm:$b, GPR:$a))]>,
1568 def RSCrs : AsI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
1569 DPSoRegFrm, IIC_iALUsr, "rsc", "\t$dst, $a, $b",
1570 [(set GPR:$dst, (sube_dead_carry so_reg:$b, GPR:$a))]>,
1576 // FIXME: Allow these to be predicated.
1577 let Defs = [CPSR], Uses = [CPSR] in {
1578 def RSCSri : AXI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
1579 DPFrm, IIC_iALUi, "rscs\t$dst, $a, $b",
1580 [(set GPR:$dst, (sube_dead_carry so_imm:$b, GPR:$a))]>,
1585 def RSCSrs : AXI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
1586 DPSoRegFrm, IIC_iALUsr, "rscs\t$dst, $a, $b",
1587 [(set GPR:$dst, (sube_dead_carry so_reg:$b, GPR:$a))]>,
1594 // (sub X, imm) gets canonicalized to (add X, -imm). Match this form.
1595 def : ARMPat<(add GPR:$src, so_imm_neg:$imm),
1596 (SUBri GPR:$src, so_imm_neg:$imm)>;
1598 //def : ARMPat<(addc GPR:$src, so_imm_neg:$imm),
1599 // (SUBSri GPR:$src, so_imm_neg:$imm)>;
1600 //def : ARMPat<(adde GPR:$src, so_imm_neg:$imm),
1601 // (SBCri GPR:$src, so_imm_neg:$imm)>;
1603 // Note: These are implemented in C++ code, because they have to generate
1604 // ADD/SUBrs instructions, which use a complex pattern that a xform function
1606 // (mul X, 2^n+1) -> (add (X << n), X)
1607 // (mul X, 2^n-1) -> (rsb X, (X << n))
1609 // ARM Arithmetic Instruction -- for disassembly only
1610 // GPR:$dst = GPR:$a op GPR:$b
1611 class AAI<bits<8> op27_20, bits<4> op7_4, string opc>
1612 : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm, IIC_iALUr,
1613 opc, "\t$dst, $a, $b",
1614 [/* For disassembly only; pattern left blank */]> {
1615 let Inst{27-20} = op27_20;
1616 let Inst{7-4} = op7_4;
1619 // Saturating add/subtract -- for disassembly only
1621 def QADD : AAI<0b00010000, 0b0101, "qadd">;
1622 def QADD16 : AAI<0b01100010, 0b0001, "qadd16">;
1623 def QADD8 : AAI<0b01100010, 0b1001, "qadd8">;
1624 def QASX : AAI<0b01100010, 0b0011, "qasx">;
1625 def QDADD : AAI<0b00010100, 0b0101, "qdadd">;
1626 def QDSUB : AAI<0b00010110, 0b0101, "qdsub">;
1627 def QSAX : AAI<0b01100010, 0b0101, "qsax">;
1628 def QSUB : AAI<0b00010010, 0b0101, "qsub">;
1629 def QSUB16 : AAI<0b01100010, 0b0111, "qsub16">;
1630 def QSUB8 : AAI<0b01100010, 0b1111, "qsub8">;
1631 def UQADD16 : AAI<0b01100110, 0b0001, "uqadd16">;
1632 def UQADD8 : AAI<0b01100110, 0b1001, "uqadd8">;
1633 def UQASX : AAI<0b01100110, 0b0011, "uqasx">;
1634 def UQSAX : AAI<0b01100110, 0b0101, "uqsax">;
1635 def UQSUB16 : AAI<0b01100110, 0b0111, "uqsub16">;
1636 def UQSUB8 : AAI<0b01100110, 0b1111, "uqsub8">;
1638 // Signed/Unsigned add/subtract -- for disassembly only
1640 def SASX : AAI<0b01100001, 0b0011, "sasx">;
1641 def SADD16 : AAI<0b01100001, 0b0001, "sadd16">;
1642 def SADD8 : AAI<0b01100001, 0b1001, "sadd8">;
1643 def SSAX : AAI<0b01100001, 0b0101, "ssax">;
1644 def SSUB16 : AAI<0b01100001, 0b0111, "ssub16">;
1645 def SSUB8 : AAI<0b01100001, 0b1111, "ssub8">;
1646 def UASX : AAI<0b01100101, 0b0011, "uasx">;
1647 def UADD16 : AAI<0b01100101, 0b0001, "uadd16">;
1648 def UADD8 : AAI<0b01100101, 0b1001, "uadd8">;
1649 def USAX : AAI<0b01100101, 0b0101, "usax">;
1650 def USUB16 : AAI<0b01100101, 0b0111, "usub16">;
1651 def USUB8 : AAI<0b01100101, 0b1111, "usub8">;
1653 // Signed/Unsigned halving add/subtract -- for disassembly only
1655 def SHASX : AAI<0b01100011, 0b0011, "shasx">;
1656 def SHADD16 : AAI<0b01100011, 0b0001, "shadd16">;
1657 def SHADD8 : AAI<0b01100011, 0b1001, "shadd8">;
1658 def SHSAX : AAI<0b01100011, 0b0101, "shsax">;
1659 def SHSUB16 : AAI<0b01100011, 0b0111, "shsub16">;
1660 def SHSUB8 : AAI<0b01100011, 0b1111, "shsub8">;
1661 def UHASX : AAI<0b01100111, 0b0011, "uhasx">;
1662 def UHADD16 : AAI<0b01100111, 0b0001, "uhadd16">;
1663 def UHADD8 : AAI<0b01100111, 0b1001, "uhadd8">;
1664 def UHSAX : AAI<0b01100111, 0b0101, "uhsax">;
1665 def UHSUB16 : AAI<0b01100111, 0b0111, "uhsub16">;
1666 def UHSUB8 : AAI<0b01100111, 0b1111, "uhsub8">;
1668 // Unsigned Sum of Absolute Differences [and Accumulate] -- for disassembly only
1670 def USAD8 : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b),
1671 MulFrm /* for convenience */, NoItinerary, "usad8",
1672 "\t$dst, $a, $b", []>,
1673 Requires<[IsARM, HasV6]> {
1674 let Inst{27-20} = 0b01111000;
1675 let Inst{15-12} = 0b1111;
1676 let Inst{7-4} = 0b0001;
1678 def USADA8 : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1679 MulFrm /* for convenience */, NoItinerary, "usada8",
1680 "\t$dst, $a, $b, $acc", []>,
1681 Requires<[IsARM, HasV6]> {
1682 let Inst{27-20} = 0b01111000;
1683 let Inst{7-4} = 0b0001;
1686 // Signed/Unsigned saturate -- for disassembly only
1688 def SSATlsl : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1689 DPFrm, NoItinerary, "ssat", "\t$dst, $bit_pos, $a, lsl $shamt",
1690 [/* For disassembly only; pattern left blank */]> {
1691 let Inst{27-21} = 0b0110101;
1692 let Inst{6-4} = 0b001;
1695 def SSATasr : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1696 DPFrm, NoItinerary, "ssat", "\t$dst, $bit_pos, $a, asr $shamt",
1697 [/* For disassembly only; pattern left blank */]> {
1698 let Inst{27-21} = 0b0110101;
1699 let Inst{6-4} = 0b101;
1702 def SSAT16 : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a), DPFrm,
1703 NoItinerary, "ssat16", "\t$dst, $bit_pos, $a",
1704 [/* For disassembly only; pattern left blank */]> {
1705 let Inst{27-20} = 0b01101010;
1706 let Inst{7-4} = 0b0011;
1709 def USATlsl : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1710 DPFrm, NoItinerary, "usat", "\t$dst, $bit_pos, $a, lsl $shamt",
1711 [/* For disassembly only; pattern left blank */]> {
1712 let Inst{27-21} = 0b0110111;
1713 let Inst{6-4} = 0b001;
1716 def USATasr : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1717 DPFrm, NoItinerary, "usat", "\t$dst, $bit_pos, $a, asr $shamt",
1718 [/* For disassembly only; pattern left blank */]> {
1719 let Inst{27-21} = 0b0110111;
1720 let Inst{6-4} = 0b101;
1723 def USAT16 : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a), DPFrm,
1724 NoItinerary, "usat16", "\t$dst, $bit_pos, $a",
1725 [/* For disassembly only; pattern left blank */]> {
1726 let Inst{27-20} = 0b01101110;
1727 let Inst{7-4} = 0b0011;
1730 //===----------------------------------------------------------------------===//
1731 // Bitwise Instructions.
1734 defm AND : AsI1_bin_irs<0b0000, "and",
1735 BinOpFrag<(and node:$LHS, node:$RHS)>, 1>;
1736 defm ORR : AsI1_bin_irs<0b1100, "orr",
1737 BinOpFrag<(or node:$LHS, node:$RHS)>, 1>;
1738 defm EOR : AsI1_bin_irs<0b0001, "eor",
1739 BinOpFrag<(xor node:$LHS, node:$RHS)>, 1>;
1740 defm BIC : AsI1_bin_irs<0b1110, "bic",
1741 BinOpFrag<(and node:$LHS, (not node:$RHS))>>;
1743 def BFC : I<(outs GPR:$dst), (ins GPR:$src, bf_inv_mask_imm:$imm),
1744 AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iUNAsi,
1745 "bfc", "\t$dst, $imm", "$src = $dst",
1746 [(set GPR:$dst, (and GPR:$src, bf_inv_mask_imm:$imm))]>,
1747 Requires<[IsARM, HasV6T2]> {
1748 let Inst{27-21} = 0b0111110;
1749 let Inst{6-0} = 0b0011111;
1752 // A8.6.18 BFI - Bitfield insert (Encoding A1)
1753 // Added for disassembler with the pattern field purposely left blank.
1754 def BFI : I<(outs GPR:$dst), (ins GPR:$src, bf_inv_mask_imm:$imm),
1755 AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iUNAsi,
1756 "bfi", "\t$dst, $src, $imm", "",
1757 [/* For disassembly only; pattern left blank */]>,
1758 Requires<[IsARM, HasV6T2]> {
1759 let Inst{27-21} = 0b0111110;
1760 let Inst{6-4} = 0b001; // Rn: Inst{3-0} != 15
1763 def MVNr : AsI1<0b1111, (outs GPR:$dst), (ins GPR:$src), DPFrm, IIC_iMOVr,
1764 "mvn", "\t$dst, $src",
1765 [(set GPR:$dst, (not GPR:$src))]>, UnaryDP {
1767 let Inst{11-4} = 0b00000000;
1769 def MVNs : AsI1<0b1111, (outs GPR:$dst), (ins so_reg:$src), DPSoRegFrm,
1770 IIC_iMOVsr, "mvn", "\t$dst, $src",
1771 [(set GPR:$dst, (not so_reg:$src))]>, UnaryDP {
1774 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
1775 def MVNi : AsI1<0b1111, (outs GPR:$dst), (ins so_imm:$imm), DPFrm,
1776 IIC_iMOVi, "mvn", "\t$dst, $imm",
1777 [(set GPR:$dst, so_imm_not:$imm)]>,UnaryDP {
1781 def : ARMPat<(and GPR:$src, so_imm_not:$imm),
1782 (BICri GPR:$src, so_imm_not:$imm)>;
1784 //===----------------------------------------------------------------------===//
1785 // Multiply Instructions.
1788 let isCommutable = 1 in
1789 def MUL : AsMul1I<0b0000000, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1790 IIC_iMUL32, "mul", "\t$dst, $a, $b",
1791 [(set GPR:$dst, (mul GPR:$a, GPR:$b))]>;
1793 def MLA : AsMul1I<0b0000001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1794 IIC_iMAC32, "mla", "\t$dst, $a, $b, $c",
1795 [(set GPR:$dst, (add (mul GPR:$a, GPR:$b), GPR:$c))]>;
1797 def MLS : AMul1I<0b0000011, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1798 IIC_iMAC32, "mls", "\t$dst, $a, $b, $c",
1799 [(set GPR:$dst, (sub GPR:$c, (mul GPR:$a, GPR:$b)))]>,
1800 Requires<[IsARM, HasV6T2]>;
1802 // Extra precision multiplies with low / high results
1803 let neverHasSideEffects = 1 in {
1804 let isCommutable = 1 in {
1805 def SMULL : AsMul1I<0b0000110, (outs GPR:$ldst, GPR:$hdst),
1806 (ins GPR:$a, GPR:$b), IIC_iMUL64,
1807 "smull", "\t$ldst, $hdst, $a, $b", []>;
1809 def UMULL : AsMul1I<0b0000100, (outs GPR:$ldst, GPR:$hdst),
1810 (ins GPR:$a, GPR:$b), IIC_iMUL64,
1811 "umull", "\t$ldst, $hdst, $a, $b", []>;
1814 // Multiply + accumulate
1815 def SMLAL : AsMul1I<0b0000111, (outs GPR:$ldst, GPR:$hdst),
1816 (ins GPR:$a, GPR:$b), IIC_iMAC64,
1817 "smlal", "\t$ldst, $hdst, $a, $b", []>;
1819 def UMLAL : AsMul1I<0b0000101, (outs GPR:$ldst, GPR:$hdst),
1820 (ins GPR:$a, GPR:$b), IIC_iMAC64,
1821 "umlal", "\t$ldst, $hdst, $a, $b", []>;
1823 def UMAAL : AMul1I <0b0000010, (outs GPR:$ldst, GPR:$hdst),
1824 (ins GPR:$a, GPR:$b), IIC_iMAC64,
1825 "umaal", "\t$ldst, $hdst, $a, $b", []>,
1826 Requires<[IsARM, HasV6]>;
1827 } // neverHasSideEffects
1829 // Most significant word multiply
1830 def SMMUL : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1831 IIC_iMUL32, "smmul", "\t$dst, $a, $b",
1832 [(set GPR:$dst, (mulhs GPR:$a, GPR:$b))]>,
1833 Requires<[IsARM, HasV6]> {
1834 let Inst{7-4} = 0b0001;
1835 let Inst{15-12} = 0b1111;
1838 def SMMULR : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1839 IIC_iMUL32, "smmulr", "\t$dst, $a, $b",
1840 [/* For disassembly only; pattern left blank */]>,
1841 Requires<[IsARM, HasV6]> {
1842 let Inst{7-4} = 0b0011; // R = 1
1843 let Inst{15-12} = 0b1111;
1846 def SMMLA : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1847 IIC_iMAC32, "smmla", "\t$dst, $a, $b, $c",
1848 [(set GPR:$dst, (add (mulhs GPR:$a, GPR:$b), GPR:$c))]>,
1849 Requires<[IsARM, HasV6]> {
1850 let Inst{7-4} = 0b0001;
1853 def SMMLAR : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1854 IIC_iMAC32, "smmlar", "\t$dst, $a, $b, $c",
1855 [/* For disassembly only; pattern left blank */]>,
1856 Requires<[IsARM, HasV6]> {
1857 let Inst{7-4} = 0b0011; // R = 1
1860 def SMMLS : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1861 IIC_iMAC32, "smmls", "\t$dst, $a, $b, $c",
1862 [(set GPR:$dst, (sub GPR:$c, (mulhs GPR:$a, GPR:$b)))]>,
1863 Requires<[IsARM, HasV6]> {
1864 let Inst{7-4} = 0b1101;
1867 def SMMLSR : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1868 IIC_iMAC32, "smmlsr", "\t$dst, $a, $b, $c",
1869 [/* For disassembly only; pattern left blank */]>,
1870 Requires<[IsARM, HasV6]> {
1871 let Inst{7-4} = 0b1111; // R = 1
1874 multiclass AI_smul<string opc, PatFrag opnode> {
1875 def BB : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1876 IIC_iMUL32, !strconcat(opc, "bb"), "\t$dst, $a, $b",
1877 [(set GPR:$dst, (opnode (sext_inreg GPR:$a, i16),
1878 (sext_inreg GPR:$b, i16)))]>,
1879 Requires<[IsARM, HasV5TE]> {
1884 def BT : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1885 IIC_iMUL32, !strconcat(opc, "bt"), "\t$dst, $a, $b",
1886 [(set GPR:$dst, (opnode (sext_inreg GPR:$a, i16),
1887 (sra GPR:$b, (i32 16))))]>,
1888 Requires<[IsARM, HasV5TE]> {
1893 def TB : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1894 IIC_iMUL32, !strconcat(opc, "tb"), "\t$dst, $a, $b",
1895 [(set GPR:$dst, (opnode (sra GPR:$a, (i32 16)),
1896 (sext_inreg GPR:$b, i16)))]>,
1897 Requires<[IsARM, HasV5TE]> {
1902 def TT : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1903 IIC_iMUL32, !strconcat(opc, "tt"), "\t$dst, $a, $b",
1904 [(set GPR:$dst, (opnode (sra GPR:$a, (i32 16)),
1905 (sra GPR:$b, (i32 16))))]>,
1906 Requires<[IsARM, HasV5TE]> {
1911 def WB : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1912 IIC_iMUL16, !strconcat(opc, "wb"), "\t$dst, $a, $b",
1913 [(set GPR:$dst, (sra (opnode GPR:$a,
1914 (sext_inreg GPR:$b, i16)), (i32 16)))]>,
1915 Requires<[IsARM, HasV5TE]> {
1920 def WT : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1921 IIC_iMUL16, !strconcat(opc, "wt"), "\t$dst, $a, $b",
1922 [(set GPR:$dst, (sra (opnode GPR:$a,
1923 (sra GPR:$b, (i32 16))), (i32 16)))]>,
1924 Requires<[IsARM, HasV5TE]> {
1931 multiclass AI_smla<string opc, PatFrag opnode> {
1932 def BB : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1933 IIC_iMAC16, !strconcat(opc, "bb"), "\t$dst, $a, $b, $acc",
1934 [(set GPR:$dst, (add GPR:$acc,
1935 (opnode (sext_inreg GPR:$a, i16),
1936 (sext_inreg GPR:$b, i16))))]>,
1937 Requires<[IsARM, HasV5TE]> {
1942 def BT : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1943 IIC_iMAC16, !strconcat(opc, "bt"), "\t$dst, $a, $b, $acc",
1944 [(set GPR:$dst, (add GPR:$acc, (opnode (sext_inreg GPR:$a, i16),
1945 (sra GPR:$b, (i32 16)))))]>,
1946 Requires<[IsARM, HasV5TE]> {
1951 def TB : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1952 IIC_iMAC16, !strconcat(opc, "tb"), "\t$dst, $a, $b, $acc",
1953 [(set GPR:$dst, (add GPR:$acc, (opnode (sra GPR:$a, (i32 16)),
1954 (sext_inreg GPR:$b, i16))))]>,
1955 Requires<[IsARM, HasV5TE]> {
1960 def TT : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1961 IIC_iMAC16, !strconcat(opc, "tt"), "\t$dst, $a, $b, $acc",
1962 [(set GPR:$dst, (add GPR:$acc, (opnode (sra GPR:$a, (i32 16)),
1963 (sra GPR:$b, (i32 16)))))]>,
1964 Requires<[IsARM, HasV5TE]> {
1969 def WB : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1970 IIC_iMAC16, !strconcat(opc, "wb"), "\t$dst, $a, $b, $acc",
1971 [(set GPR:$dst, (add GPR:$acc, (sra (opnode GPR:$a,
1972 (sext_inreg GPR:$b, i16)), (i32 16))))]>,
1973 Requires<[IsARM, HasV5TE]> {
1978 def WT : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1979 IIC_iMAC16, !strconcat(opc, "wt"), "\t$dst, $a, $b, $acc",
1980 [(set GPR:$dst, (add GPR:$acc, (sra (opnode GPR:$a,
1981 (sra GPR:$b, (i32 16))), (i32 16))))]>,
1982 Requires<[IsARM, HasV5TE]> {
1988 defm SMUL : AI_smul<"smul", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
1989 defm SMLA : AI_smla<"smla", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
1991 // Halfword multiply accumulate long: SMLAL<x><y> -- for disassembly only
1992 def SMLALBB : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
1993 IIC_iMAC64, "smlalbb", "\t$ldst, $hdst, $a, $b",
1994 [/* For disassembly only; pattern left blank */]>,
1995 Requires<[IsARM, HasV5TE]> {
2000 def SMLALBT : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2001 IIC_iMAC64, "smlalbt", "\t$ldst, $hdst, $a, $b",
2002 [/* For disassembly only; pattern left blank */]>,
2003 Requires<[IsARM, HasV5TE]> {
2008 def SMLALTB : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2009 IIC_iMAC64, "smlaltb", "\t$ldst, $hdst, $a, $b",
2010 [/* For disassembly only; pattern left blank */]>,
2011 Requires<[IsARM, HasV5TE]> {
2016 def SMLALTT : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2017 IIC_iMAC64, "smlaltt", "\t$ldst, $hdst, $a, $b",
2018 [/* For disassembly only; pattern left blank */]>,
2019 Requires<[IsARM, HasV5TE]> {
2024 // Helper class for AI_smld -- for disassembly only
2025 class AMulDualI<bit long, bit sub, bit swap, dag oops, dag iops,
2026 InstrItinClass itin, string opc, string asm>
2027 : AI<oops, iops, MulFrm, itin, opc, asm, []>, Requires<[IsARM, HasV6]> {
2032 let Inst{21-20} = 0b00;
2033 let Inst{22} = long;
2034 let Inst{27-23} = 0b01110;
2037 multiclass AI_smld<bit sub, string opc> {
2039 def D : AMulDualI<0, sub, 0, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2040 NoItinerary, !strconcat(opc, "d"), "\t$dst, $a, $b, $acc">;
2042 def DX : AMulDualI<0, sub, 1, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2043 NoItinerary, !strconcat(opc, "dx"), "\t$dst, $a, $b, $acc">;
2045 def LD : AMulDualI<1, sub, 0, (outs GPR:$ldst,GPR:$hdst), (ins GPR:$a,GPR:$b),
2046 NoItinerary, !strconcat(opc, "ld"), "\t$ldst, $hdst, $a, $b">;
2048 def LDX : AMulDualI<1, sub, 1, (outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2049 NoItinerary, !strconcat(opc, "ldx"),"\t$ldst, $hdst, $a, $b">;
2053 defm SMLA : AI_smld<0, "smla">;
2054 defm SMLS : AI_smld<1, "smls">;
2056 multiclass AI_sdml<bit sub, string opc> {
2058 def D : AMulDualI<0, sub, 0, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2059 NoItinerary, !strconcat(opc, "d"), "\t$dst, $a, $b"> {
2060 let Inst{15-12} = 0b1111;
2063 def DX : AMulDualI<0, sub, 1, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2064 NoItinerary, !strconcat(opc, "dx"), "\t$dst, $a, $b"> {
2065 let Inst{15-12} = 0b1111;
2070 defm SMUA : AI_sdml<0, "smua">;
2071 defm SMUS : AI_sdml<1, "smus">;
2073 //===----------------------------------------------------------------------===//
2074 // Misc. Arithmetic Instructions.
2077 def CLZ : AMiscA1I<0b000010110, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2078 "clz", "\t$dst, $src",
2079 [(set GPR:$dst, (ctlz GPR:$src))]>, Requires<[IsARM, HasV5T]> {
2080 let Inst{7-4} = 0b0001;
2081 let Inst{11-8} = 0b1111;
2082 let Inst{19-16} = 0b1111;
2085 def RBIT : AMiscA1I<0b01101111, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2086 "rbit", "\t$dst, $src",
2087 [(set GPR:$dst, (ARMrbit GPR:$src))]>,
2088 Requires<[IsARM, HasV6T2]> {
2089 let Inst{7-4} = 0b0011;
2090 let Inst{11-8} = 0b1111;
2091 let Inst{19-16} = 0b1111;
2094 def REV : AMiscA1I<0b01101011, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2095 "rev", "\t$dst, $src",
2096 [(set GPR:$dst, (bswap GPR:$src))]>, Requires<[IsARM, HasV6]> {
2097 let Inst{7-4} = 0b0011;
2098 let Inst{11-8} = 0b1111;
2099 let Inst{19-16} = 0b1111;
2102 def REV16 : AMiscA1I<0b01101011, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2103 "rev16", "\t$dst, $src",
2105 (or (and (srl GPR:$src, (i32 8)), 0xFF),
2106 (or (and (shl GPR:$src, (i32 8)), 0xFF00),
2107 (or (and (srl GPR:$src, (i32 8)), 0xFF0000),
2108 (and (shl GPR:$src, (i32 8)), 0xFF000000)))))]>,
2109 Requires<[IsARM, HasV6]> {
2110 let Inst{7-4} = 0b1011;
2111 let Inst{11-8} = 0b1111;
2112 let Inst{19-16} = 0b1111;
2115 def REVSH : AMiscA1I<0b01101111, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2116 "revsh", "\t$dst, $src",
2119 (or (srl (and GPR:$src, 0xFF00), (i32 8)),
2120 (shl GPR:$src, (i32 8))), i16))]>,
2121 Requires<[IsARM, HasV6]> {
2122 let Inst{7-4} = 0b1011;
2123 let Inst{11-8} = 0b1111;
2124 let Inst{19-16} = 0b1111;
2127 def PKHBT : AMiscA1I<0b01101000, (outs GPR:$dst),
2128 (ins GPR:$src1, GPR:$src2, i32imm:$shamt),
2129 IIC_iALUsi, "pkhbt", "\t$dst, $src1, $src2, lsl $shamt",
2130 [(set GPR:$dst, (or (and GPR:$src1, 0xFFFF),
2131 (and (shl GPR:$src2, (i32 imm:$shamt)),
2133 Requires<[IsARM, HasV6]> {
2134 let Inst{6-4} = 0b001;
2137 // Alternate cases for PKHBT where identities eliminate some nodes.
2138 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF), (and GPR:$src2, 0xFFFF0000)),
2139 (PKHBT GPR:$src1, GPR:$src2, 0)>;
2140 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF), (shl GPR:$src2, imm16_31:$shamt)),
2141 (PKHBT GPR:$src1, GPR:$src2, imm16_31:$shamt)>;
2144 def PKHTB : AMiscA1I<0b01101000, (outs GPR:$dst),
2145 (ins GPR:$src1, GPR:$src2, i32imm:$shamt),
2146 IIC_iALUsi, "pkhtb", "\t$dst, $src1, $src2, asr $shamt",
2147 [(set GPR:$dst, (or (and GPR:$src1, 0xFFFF0000),
2148 (and (sra GPR:$src2, imm16_31:$shamt),
2149 0xFFFF)))]>, Requires<[IsARM, HasV6]> {
2150 let Inst{6-4} = 0b101;
2153 // Alternate cases for PKHTB where identities eliminate some nodes. Note that
2154 // a shift amount of 0 is *not legal* here, it is PKHBT instead.
2155 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF0000), (srl GPR:$src2, (i32 16))),
2156 (PKHTB GPR:$src1, GPR:$src2, 16)>;
2157 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF0000),
2158 (and (srl GPR:$src2, imm1_15:$shamt), 0xFFFF)),
2159 (PKHTB GPR:$src1, GPR:$src2, imm1_15:$shamt)>;
2161 //===----------------------------------------------------------------------===//
2162 // Comparison Instructions...
2165 defm CMP : AI1_cmp_irs<0b1010, "cmp",
2166 BinOpFrag<(ARMcmp node:$LHS, node:$RHS)>>;
2167 //FIXME: Disable CMN, as CCodes are backwards from compare expectations
2168 // Compare-to-zero still works out, just not the relationals
2169 //defm CMN : AI1_cmp_irs<0b1011, "cmn",
2170 // BinOpFrag<(ARMcmp node:$LHS,(ineg node:$RHS))>>;
2172 // Note that TST/TEQ don't set all the same flags that CMP does!
2173 defm TST : AI1_cmp_irs<0b1000, "tst",
2174 BinOpFrag<(ARMcmpZ (and node:$LHS, node:$RHS), 0)>, 1>;
2175 defm TEQ : AI1_cmp_irs<0b1001, "teq",
2176 BinOpFrag<(ARMcmpZ (xor node:$LHS, node:$RHS), 0)>, 1>;
2178 defm CMPz : AI1_cmp_irs<0b1010, "cmp",
2179 BinOpFrag<(ARMcmpZ node:$LHS, node:$RHS)>>;
2180 defm CMNz : AI1_cmp_irs<0b1011, "cmn",
2181 BinOpFrag<(ARMcmpZ node:$LHS,(ineg node:$RHS))>>;
2183 //def : ARMPat<(ARMcmp GPR:$src, so_imm_neg:$imm),
2184 // (CMNri GPR:$src, so_imm_neg:$imm)>;
2186 def : ARMPat<(ARMcmpZ GPR:$src, so_imm_neg:$imm),
2187 (CMNzri GPR:$src, so_imm_neg:$imm)>;
2190 // Conditional moves
2191 // FIXME: should be able to write a pattern for ARMcmov, but can't use
2192 // a two-value operand where a dag node expects two operands. :(
2193 def MOVCCr : AI1<0b1101, (outs GPR:$dst), (ins GPR:$false, GPR:$true), DPFrm,
2194 IIC_iCMOVr, "mov", "\t$dst, $true",
2195 [/*(set GPR:$dst, (ARMcmov GPR:$false, GPR:$true, imm:$cc, CCR:$ccr))*/]>,
2196 RegConstraint<"$false = $dst">, UnaryDP {
2197 let Inst{11-4} = 0b00000000;
2201 def MOVCCs : AI1<0b1101, (outs GPR:$dst),
2202 (ins GPR:$false, so_reg:$true), DPSoRegFrm, IIC_iCMOVsr,
2203 "mov", "\t$dst, $true",
2204 [/*(set GPR:$dst, (ARMcmov GPR:$false, so_reg:$true, imm:$cc, CCR:$ccr))*/]>,
2205 RegConstraint<"$false = $dst">, UnaryDP {
2209 def MOVCCi : AI1<0b1101, (outs GPR:$dst),
2210 (ins GPR:$false, so_imm:$true), DPFrm, IIC_iCMOVi,
2211 "mov", "\t$dst, $true",
2212 [/*(set GPR:$dst, (ARMcmov GPR:$false, so_imm:$true, imm:$cc, CCR:$ccr))*/]>,
2213 RegConstraint<"$false = $dst">, UnaryDP {
2217 //===----------------------------------------------------------------------===//
2218 // Atomic operations intrinsics
2221 // memory barriers protect the atomic sequences
2222 let hasSideEffects = 1 in {
2223 def Int_MemBarrierV7 : AInoP<(outs), (ins),
2224 Pseudo, NoItinerary,
2226 [(ARMMemBarrierV7)]>,
2227 Requires<[IsARM, HasV7]> {
2228 let Inst{31-4} = 0xf57ff05;
2229 // FIXME: add support for options other than a full system DMB
2230 // See DMB disassembly-only variants below.
2231 let Inst{3-0} = 0b1111;
2234 def Int_SyncBarrierV7 : AInoP<(outs), (ins),
2235 Pseudo, NoItinerary,
2237 [(ARMSyncBarrierV7)]>,
2238 Requires<[IsARM, HasV7]> {
2239 let Inst{31-4} = 0xf57ff04;
2240 // FIXME: add support for options other than a full system DSB
2241 // See DSB disassembly-only variants below.
2242 let Inst{3-0} = 0b1111;
2245 def Int_MemBarrierV6 : AInoP<(outs), (ins GPR:$zero),
2246 Pseudo, NoItinerary,
2247 "mcr", "\tp15, 0, $zero, c7, c10, 5",
2248 [(ARMMemBarrierV6 GPR:$zero)]>,
2249 Requires<[IsARM, HasV6]> {
2250 // FIXME: add support for options other than a full system DMB
2251 // FIXME: add encoding
2254 def Int_SyncBarrierV6 : AInoP<(outs), (ins GPR:$zero),
2255 Pseudo, NoItinerary,
2256 "mcr", "\tp15, 0, $zero, c7, c10, 4",
2257 [(ARMSyncBarrierV6 GPR:$zero)]>,
2258 Requires<[IsARM, HasV6]> {
2259 // FIXME: add support for options other than a full system DSB
2260 // FIXME: add encoding
2264 // Helper class for multiclass MemB -- for disassembly only
2265 class AMBI<string opc, string asm>
2266 : AInoP<(outs), (ins), MiscFrm, NoItinerary, opc, asm,
2267 [/* For disassembly only; pattern left blank */]>,
2268 Requires<[IsARM, HasV7]> {
2269 let Inst{31-20} = 0xf57;
2272 multiclass MemB<bits<4> op7_4, string opc> {
2274 def st : AMBI<opc, "\tst"> {
2275 let Inst{7-4} = op7_4;
2276 let Inst{3-0} = 0b1110;
2279 def ish : AMBI<opc, "\tish"> {
2280 let Inst{7-4} = op7_4;
2281 let Inst{3-0} = 0b1011;
2284 def ishst : AMBI<opc, "\tishst"> {
2285 let Inst{7-4} = op7_4;
2286 let Inst{3-0} = 0b1010;
2289 def nsh : AMBI<opc, "\tnsh"> {
2290 let Inst{7-4} = op7_4;
2291 let Inst{3-0} = 0b0111;
2294 def nshst : AMBI<opc, "\tnshst"> {
2295 let Inst{7-4} = op7_4;
2296 let Inst{3-0} = 0b0110;
2299 def osh : AMBI<opc, "\tosh"> {
2300 let Inst{7-4} = op7_4;
2301 let Inst{3-0} = 0b0011;
2304 def oshst : AMBI<opc, "\toshst"> {
2305 let Inst{7-4} = op7_4;
2306 let Inst{3-0} = 0b0010;
2310 // These DMB variants are for disassembly only.
2311 defm DMB : MemB<0b0101, "dmb">;
2313 // These DSB variants are for disassembly only.
2314 defm DSB : MemB<0b0100, "dsb">;
2316 // ISB has only full system option -- for disassembly only
2317 def ISBsy : AMBI<"isb", ""> {
2318 let Inst{7-4} = 0b0110;
2319 let Inst{3-0} = 0b1111;
2322 let usesCustomInserter = 1 in {
2323 let Uses = [CPSR] in {
2324 def ATOMIC_LOAD_ADD_I8 : PseudoInst<
2325 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2326 "${:comment} ATOMIC_LOAD_ADD_I8 PSEUDO!",
2327 [(set GPR:$dst, (atomic_load_add_8 GPR:$ptr, GPR:$incr))]>;
2328 def ATOMIC_LOAD_SUB_I8 : PseudoInst<
2329 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2330 "${:comment} ATOMIC_LOAD_SUB_I8 PSEUDO!",
2331 [(set GPR:$dst, (atomic_load_sub_8 GPR:$ptr, GPR:$incr))]>;
2332 def ATOMIC_LOAD_AND_I8 : PseudoInst<
2333 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2334 "${:comment} ATOMIC_LOAD_AND_I8 PSEUDO!",
2335 [(set GPR:$dst, (atomic_load_and_8 GPR:$ptr, GPR:$incr))]>;
2336 def ATOMIC_LOAD_OR_I8 : PseudoInst<
2337 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2338 "${:comment} ATOMIC_LOAD_OR_I8 PSEUDO!",
2339 [(set GPR:$dst, (atomic_load_or_8 GPR:$ptr, GPR:$incr))]>;
2340 def ATOMIC_LOAD_XOR_I8 : PseudoInst<
2341 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2342 "${:comment} ATOMIC_LOAD_XOR_I8 PSEUDO!",
2343 [(set GPR:$dst, (atomic_load_xor_8 GPR:$ptr, GPR:$incr))]>;
2344 def ATOMIC_LOAD_NAND_I8 : PseudoInst<
2345 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2346 "${:comment} ATOMIC_LOAD_NAND_I8 PSEUDO!",
2347 [(set GPR:$dst, (atomic_load_nand_8 GPR:$ptr, GPR:$incr))]>;
2348 def ATOMIC_LOAD_ADD_I16 : PseudoInst<
2349 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2350 "${:comment} ATOMIC_LOAD_ADD_I16 PSEUDO!",
2351 [(set GPR:$dst, (atomic_load_add_16 GPR:$ptr, GPR:$incr))]>;
2352 def ATOMIC_LOAD_SUB_I16 : PseudoInst<
2353 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2354 "${:comment} ATOMIC_LOAD_SUB_I16 PSEUDO!",
2355 [(set GPR:$dst, (atomic_load_sub_16 GPR:$ptr, GPR:$incr))]>;
2356 def ATOMIC_LOAD_AND_I16 : PseudoInst<
2357 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2358 "${:comment} ATOMIC_LOAD_AND_I16 PSEUDO!",
2359 [(set GPR:$dst, (atomic_load_and_16 GPR:$ptr, GPR:$incr))]>;
2360 def ATOMIC_LOAD_OR_I16 : PseudoInst<
2361 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2362 "${:comment} ATOMIC_LOAD_OR_I16 PSEUDO!",
2363 [(set GPR:$dst, (atomic_load_or_16 GPR:$ptr, GPR:$incr))]>;
2364 def ATOMIC_LOAD_XOR_I16 : PseudoInst<
2365 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2366 "${:comment} ATOMIC_LOAD_XOR_I16 PSEUDO!",
2367 [(set GPR:$dst, (atomic_load_xor_16 GPR:$ptr, GPR:$incr))]>;
2368 def ATOMIC_LOAD_NAND_I16 : PseudoInst<
2369 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2370 "${:comment} ATOMIC_LOAD_NAND_I16 PSEUDO!",
2371 [(set GPR:$dst, (atomic_load_nand_16 GPR:$ptr, GPR:$incr))]>;
2372 def ATOMIC_LOAD_ADD_I32 : PseudoInst<
2373 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2374 "${:comment} ATOMIC_LOAD_ADD_I32 PSEUDO!",
2375 [(set GPR:$dst, (atomic_load_add_32 GPR:$ptr, GPR:$incr))]>;
2376 def ATOMIC_LOAD_SUB_I32 : PseudoInst<
2377 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2378 "${:comment} ATOMIC_LOAD_SUB_I32 PSEUDO!",
2379 [(set GPR:$dst, (atomic_load_sub_32 GPR:$ptr, GPR:$incr))]>;
2380 def ATOMIC_LOAD_AND_I32 : PseudoInst<
2381 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2382 "${:comment} ATOMIC_LOAD_AND_I32 PSEUDO!",
2383 [(set GPR:$dst, (atomic_load_and_32 GPR:$ptr, GPR:$incr))]>;
2384 def ATOMIC_LOAD_OR_I32 : PseudoInst<
2385 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2386 "${:comment} ATOMIC_LOAD_OR_I32 PSEUDO!",
2387 [(set GPR:$dst, (atomic_load_or_32 GPR:$ptr, GPR:$incr))]>;
2388 def ATOMIC_LOAD_XOR_I32 : PseudoInst<
2389 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2390 "${:comment} ATOMIC_LOAD_XOR_I32 PSEUDO!",
2391 [(set GPR:$dst, (atomic_load_xor_32 GPR:$ptr, GPR:$incr))]>;
2392 def ATOMIC_LOAD_NAND_I32 : PseudoInst<
2393 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2394 "${:comment} ATOMIC_LOAD_NAND_I32 PSEUDO!",
2395 [(set GPR:$dst, (atomic_load_nand_32 GPR:$ptr, GPR:$incr))]>;
2397 def ATOMIC_SWAP_I8 : PseudoInst<
2398 (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary,
2399 "${:comment} ATOMIC_SWAP_I8 PSEUDO!",
2400 [(set GPR:$dst, (atomic_swap_8 GPR:$ptr, GPR:$new))]>;
2401 def ATOMIC_SWAP_I16 : PseudoInst<
2402 (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary,
2403 "${:comment} ATOMIC_SWAP_I16 PSEUDO!",
2404 [(set GPR:$dst, (atomic_swap_16 GPR:$ptr, GPR:$new))]>;
2405 def ATOMIC_SWAP_I32 : PseudoInst<
2406 (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary,
2407 "${:comment} ATOMIC_SWAP_I32 PSEUDO!",
2408 [(set GPR:$dst, (atomic_swap_32 GPR:$ptr, GPR:$new))]>;
2410 def ATOMIC_CMP_SWAP_I8 : PseudoInst<
2411 (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary,
2412 "${:comment} ATOMIC_CMP_SWAP_I8 PSEUDO!",
2413 [(set GPR:$dst, (atomic_cmp_swap_8 GPR:$ptr, GPR:$old, GPR:$new))]>;
2414 def ATOMIC_CMP_SWAP_I16 : PseudoInst<
2415 (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary,
2416 "${:comment} ATOMIC_CMP_SWAP_I16 PSEUDO!",
2417 [(set GPR:$dst, (atomic_cmp_swap_16 GPR:$ptr, GPR:$old, GPR:$new))]>;
2418 def ATOMIC_CMP_SWAP_I32 : PseudoInst<
2419 (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary,
2420 "${:comment} ATOMIC_CMP_SWAP_I32 PSEUDO!",
2421 [(set GPR:$dst, (atomic_cmp_swap_32 GPR:$ptr, GPR:$old, GPR:$new))]>;
2425 let mayLoad = 1 in {
2426 def LDREXB : AIldrex<0b10, (outs GPR:$dest), (ins GPR:$ptr), NoItinerary,
2427 "ldrexb", "\t$dest, [$ptr]",
2429 def LDREXH : AIldrex<0b11, (outs GPR:$dest), (ins GPR:$ptr), NoItinerary,
2430 "ldrexh", "\t$dest, [$ptr]",
2432 def LDREX : AIldrex<0b00, (outs GPR:$dest), (ins GPR:$ptr), NoItinerary,
2433 "ldrex", "\t$dest, [$ptr]",
2435 def LDREXD : AIldrex<0b01, (outs GPR:$dest, GPR:$dest2), (ins GPR:$ptr),
2437 "ldrexd", "\t$dest, $dest2, [$ptr]",
2441 let mayStore = 1, Constraints = "@earlyclobber $success" in {
2442 def STREXB : AIstrex<0b10, (outs GPR:$success), (ins GPR:$src, GPR:$ptr),
2444 "strexb", "\t$success, $src, [$ptr]",
2446 def STREXH : AIstrex<0b11, (outs GPR:$success), (ins GPR:$src, GPR:$ptr),
2448 "strexh", "\t$success, $src, [$ptr]",
2450 def STREX : AIstrex<0b00, (outs GPR:$success), (ins GPR:$src, GPR:$ptr),
2452 "strex", "\t$success, $src, [$ptr]",
2454 def STREXD : AIstrex<0b01, (outs GPR:$success),
2455 (ins GPR:$src, GPR:$src2, GPR:$ptr),
2457 "strexd", "\t$success, $src, $src2, [$ptr]",
2461 // Clear-Exclusive is for disassembly only.
2462 def CLREX : AXI<(outs), (ins), MiscFrm, NoItinerary, "clrex",
2463 [/* For disassembly only; pattern left blank */]>,
2464 Requires<[IsARM, HasV7]> {
2465 let Inst{31-20} = 0xf57;
2466 let Inst{7-4} = 0b0001;
2469 // SWP/SWPB are deprecated in V6/V7 and for disassembly only.
2470 let mayLoad = 1 in {
2471 def SWP : AI<(outs GPR:$dst), (ins GPR:$src, GPR:$ptr), LdStExFrm, NoItinerary,
2472 "swp", "\t$dst, $src, [$ptr]",
2473 [/* For disassembly only; pattern left blank */]> {
2474 let Inst{27-23} = 0b00010;
2475 let Inst{22} = 0; // B = 0
2476 let Inst{21-20} = 0b00;
2477 let Inst{7-4} = 0b1001;
2480 def SWPB : AI<(outs GPR:$dst), (ins GPR:$src, GPR:$ptr), LdStExFrm, NoItinerary,
2481 "swpb", "\t$dst, $src, [$ptr]",
2482 [/* For disassembly only; pattern left blank */]> {
2483 let Inst{27-23} = 0b00010;
2484 let Inst{22} = 1; // B = 1
2485 let Inst{21-20} = 0b00;
2486 let Inst{7-4} = 0b1001;
2490 //===----------------------------------------------------------------------===//
2494 // __aeabi_read_tp preserves the registers r1-r3.
2496 Defs = [R0, R12, LR, CPSR] in {
2497 def TPsoft : ABXI<0b1011, (outs), (ins), IIC_Br,
2498 "bl\t__aeabi_read_tp",
2499 [(set R0, ARMthread_pointer)]>;
2502 //===----------------------------------------------------------------------===//
2503 // SJLJ Exception handling intrinsics
2504 // eh_sjlj_setjmp() is an instruction sequence to store the return
2505 // address and save #0 in R0 for the non-longjmp case.
2506 // Since by its nature we may be coming from some other function to get
2507 // here, and we're using the stack frame for the containing function to
2508 // save/restore registers, we can't keep anything live in regs across
2509 // the eh_sjlj_setjmp(), else it will almost certainly have been tromped upon
2510 // when we get here from a longjmp(). We force everthing out of registers
2511 // except for our own input by listing the relevant registers in Defs. By
2512 // doing so, we also cause the prologue/epilogue code to actively preserve
2513 // all of the callee-saved resgisters, which is exactly what we want.
2514 // A constant value is passed in $val, and we use the location as a scratch.
2516 [ R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, LR, D0,
2517 D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15,
2518 D16, D17, D18, D19, D20, D21, D22, D23, D24, D25, D26, D27, D28, D29, D30,
2520 def Int_eh_sjlj_setjmp : XI<(outs), (ins GPR:$src, GPR:$val),
2521 AddrModeNone, SizeSpecial, IndexModeNone,
2522 Pseudo, NoItinerary,
2523 "str\tsp, [$src, #+8] @ eh_setjmp begin\n\t"
2524 "add\t$val, pc, #8\n\t"
2525 "str\t$val, [$src, #+4]\n\t"
2527 "add\tpc, pc, #0\n\t"
2528 "mov\tr0, #1 @ eh_setjmp end", "",
2529 [(set R0, (ARMeh_sjlj_setjmp GPR:$src, GPR:$val))]>;
2532 //===----------------------------------------------------------------------===//
2533 // Non-Instruction Patterns
2536 // Large immediate handling.
2538 // Two piece so_imms.
2539 let isReMaterializable = 1 in
2540 def MOVi2pieces : AI1x2<(outs GPR:$dst), (ins so_imm2part:$src),
2542 "mov", "\t$dst, $src",
2543 [(set GPR:$dst, so_imm2part:$src)]>,
2544 Requires<[IsARM, NoV6T2]>;
2546 def : ARMPat<(or GPR:$LHS, so_imm2part:$RHS),
2547 (ORRri (ORRri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
2548 (so_imm2part_2 imm:$RHS))>;
2549 def : ARMPat<(xor GPR:$LHS, so_imm2part:$RHS),
2550 (EORri (EORri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
2551 (so_imm2part_2 imm:$RHS))>;
2552 def : ARMPat<(add GPR:$LHS, so_imm2part:$RHS),
2553 (ADDri (ADDri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
2554 (so_imm2part_2 imm:$RHS))>;
2555 def : ARMPat<(add GPR:$LHS, so_neg_imm2part:$RHS),
2556 (SUBri (SUBri GPR:$LHS, (so_neg_imm2part_1 imm:$RHS)),
2557 (so_neg_imm2part_2 imm:$RHS))>;
2559 // 32-bit immediate using movw + movt.
2560 // This is a single pseudo instruction, the benefit is that it can be remat'd
2561 // as a single unit instead of having to handle reg inputs.
2562 // FIXME: Remove this when we can do generalized remat.
2563 let isReMaterializable = 1 in
2564 def MOVi32imm : AI1x2<(outs GPR:$dst), (ins i32imm:$src), Pseudo, IIC_iMOVi,
2565 "movw", "\t$dst, ${src:lo16}\n\tmovt${p}\t$dst, ${src:hi16}",
2566 [(set GPR:$dst, (i32 imm:$src))]>,
2567 Requires<[IsARM, HasV6T2]>;
2569 // ConstantPool, GlobalAddress, and JumpTable
2570 def : ARMPat<(ARMWrapper tglobaladdr :$dst), (LEApcrel tglobaladdr :$dst)>,
2571 Requires<[IsARM, DontUseMovt]>;
2572 def : ARMPat<(ARMWrapper tconstpool :$dst), (LEApcrel tconstpool :$dst)>;
2573 def : ARMPat<(ARMWrapper tglobaladdr :$dst), (MOVi32imm tglobaladdr :$dst)>,
2574 Requires<[IsARM, UseMovt]>;
2575 def : ARMPat<(ARMWrapperJT tjumptable:$dst, imm:$id),
2576 (LEApcrelJT tjumptable:$dst, imm:$id)>;
2578 // TODO: add,sub,and, 3-instr forms?
2582 def : ARMPat<(ARMcall texternalsym:$func), (BL texternalsym:$func)>,
2583 Requires<[IsARM, IsNotDarwin]>;
2584 def : ARMPat<(ARMcall texternalsym:$func), (BLr9 texternalsym:$func)>,
2585 Requires<[IsARM, IsDarwin]>;
2587 // zextload i1 -> zextload i8
2588 def : ARMPat<(zextloadi1 addrmode2:$addr), (LDRB addrmode2:$addr)>;
2590 // extload -> zextload
2591 def : ARMPat<(extloadi1 addrmode2:$addr), (LDRB addrmode2:$addr)>;
2592 def : ARMPat<(extloadi8 addrmode2:$addr), (LDRB addrmode2:$addr)>;
2593 def : ARMPat<(extloadi16 addrmode3:$addr), (LDRH addrmode3:$addr)>;
2595 def : ARMPat<(extloadi8 addrmodepc:$addr), (PICLDRB addrmodepc:$addr)>;
2596 def : ARMPat<(extloadi16 addrmodepc:$addr), (PICLDRH addrmodepc:$addr)>;
2599 def : ARMV5TEPat<(mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2600 (sra (shl GPR:$b, (i32 16)), (i32 16))),
2601 (SMULBB GPR:$a, GPR:$b)>;
2602 def : ARMV5TEPat<(mul sext_16_node:$a, sext_16_node:$b),
2603 (SMULBB GPR:$a, GPR:$b)>;
2604 def : ARMV5TEPat<(mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2605 (sra GPR:$b, (i32 16))),
2606 (SMULBT GPR:$a, GPR:$b)>;
2607 def : ARMV5TEPat<(mul sext_16_node:$a, (sra GPR:$b, (i32 16))),
2608 (SMULBT GPR:$a, GPR:$b)>;
2609 def : ARMV5TEPat<(mul (sra GPR:$a, (i32 16)),
2610 (sra (shl GPR:$b, (i32 16)), (i32 16))),
2611 (SMULTB GPR:$a, GPR:$b)>;
2612 def : ARMV5TEPat<(mul (sra GPR:$a, (i32 16)), sext_16_node:$b),
2613 (SMULTB GPR:$a, GPR:$b)>;
2614 def : ARMV5TEPat<(sra (mul GPR:$a, (sra (shl GPR:$b, (i32 16)), (i32 16))),
2616 (SMULWB GPR:$a, GPR:$b)>;
2617 def : ARMV5TEPat<(sra (mul GPR:$a, sext_16_node:$b), (i32 16)),
2618 (SMULWB GPR:$a, GPR:$b)>;
2620 def : ARMV5TEPat<(add GPR:$acc,
2621 (mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2622 (sra (shl GPR:$b, (i32 16)), (i32 16)))),
2623 (SMLABB GPR:$a, GPR:$b, GPR:$acc)>;
2624 def : ARMV5TEPat<(add GPR:$acc,
2625 (mul sext_16_node:$a, sext_16_node:$b)),
2626 (SMLABB GPR:$a, GPR:$b, GPR:$acc)>;
2627 def : ARMV5TEPat<(add GPR:$acc,
2628 (mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2629 (sra GPR:$b, (i32 16)))),
2630 (SMLABT GPR:$a, GPR:$b, GPR:$acc)>;
2631 def : ARMV5TEPat<(add GPR:$acc,
2632 (mul sext_16_node:$a, (sra GPR:$b, (i32 16)))),
2633 (SMLABT GPR:$a, GPR:$b, GPR:$acc)>;
2634 def : ARMV5TEPat<(add GPR:$acc,
2635 (mul (sra GPR:$a, (i32 16)),
2636 (sra (shl GPR:$b, (i32 16)), (i32 16)))),
2637 (SMLATB GPR:$a, GPR:$b, GPR:$acc)>;
2638 def : ARMV5TEPat<(add GPR:$acc,
2639 (mul (sra GPR:$a, (i32 16)), sext_16_node:$b)),
2640 (SMLATB GPR:$a, GPR:$b, GPR:$acc)>;
2641 def : ARMV5TEPat<(add GPR:$acc,
2642 (sra (mul GPR:$a, (sra (shl GPR:$b, (i32 16)), (i32 16))),
2644 (SMLAWB GPR:$a, GPR:$b, GPR:$acc)>;
2645 def : ARMV5TEPat<(add GPR:$acc,
2646 (sra (mul GPR:$a, sext_16_node:$b), (i32 16))),
2647 (SMLAWB GPR:$a, GPR:$b, GPR:$acc)>;
2649 //===----------------------------------------------------------------------===//
2653 include "ARMInstrThumb.td"
2655 //===----------------------------------------------------------------------===//
2659 include "ARMInstrThumb2.td"
2661 //===----------------------------------------------------------------------===//
2662 // Floating Point Support
2665 include "ARMInstrVFP.td"
2667 //===----------------------------------------------------------------------===//
2668 // Advanced SIMD (NEON) Support
2671 include "ARMInstrNEON.td"
2673 //===----------------------------------------------------------------------===//
2674 // Coprocessor Instructions. For disassembly only.
2677 def CDP : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2678 nohash_imm:$CRd, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2679 NoItinerary, "cdp", "\tp$cop, $opc1, cr$CRd, cr$CRn, cr$CRm, $opc2",
2680 [/* For disassembly only; pattern left blank */]> {
2684 def CDP2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2685 nohash_imm:$CRd, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2686 NoItinerary, "cdp2\tp$cop, $opc1, cr$CRd, cr$CRn, cr$CRm, $opc2",
2687 [/* For disassembly only; pattern left blank */]> {
2688 let Inst{31-28} = 0b1111;
2692 class ACI<dag oops, dag iops, string opc, string asm>
2693 : I<oops, iops, AddrModeNone, Size4Bytes, IndexModeNone, BrFrm, NoItinerary,
2694 opc, asm, "", [/* For disassembly only; pattern left blank */]> {
2695 let Inst{27-25} = 0b110;
2698 multiclass LdStCop<bits<4> op31_28, bit load, string opc> {
2700 def _OFFSET : ACI<(outs),
2701 (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2702 opc, "\tp$cop, cr$CRd, $addr"> {
2703 let Inst{31-28} = op31_28;
2704 let Inst{24} = 1; // P = 1
2705 let Inst{21} = 0; // W = 0
2706 let Inst{22} = 0; // D = 0
2707 let Inst{20} = load;
2710 def _PRE : ACI<(outs),
2711 (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2712 opc, "\tp$cop, cr$CRd, $addr!"> {
2713 let Inst{31-28} = op31_28;
2714 let Inst{24} = 1; // P = 1
2715 let Inst{21} = 1; // W = 1
2716 let Inst{22} = 0; // D = 0
2717 let Inst{20} = load;
2720 def _POST : ACI<(outs),
2721 (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, am2offset:$offset),
2722 opc, "\tp$cop, cr$CRd, [$base], $offset"> {
2723 let Inst{31-28} = op31_28;
2724 let Inst{24} = 0; // P = 0
2725 let Inst{21} = 1; // W = 1
2726 let Inst{22} = 0; // D = 0
2727 let Inst{20} = load;
2730 def _OPTION : ACI<(outs),
2731 (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, i32imm:$option),
2732 opc, "\tp$cop, cr$CRd, [$base], $option"> {
2733 let Inst{31-28} = op31_28;
2734 let Inst{24} = 0; // P = 0
2735 let Inst{23} = 1; // U = 1
2736 let Inst{21} = 0; // W = 0
2737 let Inst{22} = 0; // D = 0
2738 let Inst{20} = load;
2741 def L_OFFSET : ACI<(outs),
2742 (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2743 opc, "l\tp$cop, cr$CRd, $addr"> {
2744 let Inst{31-28} = op31_28;
2745 let Inst{24} = 1; // P = 1
2746 let Inst{21} = 0; // W = 0
2747 let Inst{22} = 1; // D = 1
2748 let Inst{20} = load;
2751 def L_PRE : ACI<(outs),
2752 (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2753 opc, "l\tp$cop, cr$CRd, $addr!"> {
2754 let Inst{31-28} = op31_28;
2755 let Inst{24} = 1; // P = 1
2756 let Inst{21} = 1; // W = 1
2757 let Inst{22} = 1; // D = 1
2758 let Inst{20} = load;
2761 def L_POST : ACI<(outs),
2762 (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, am2offset:$offset),
2763 opc, "l\tp$cop, cr$CRd, [$base], $offset"> {
2764 let Inst{31-28} = op31_28;
2765 let Inst{24} = 0; // P = 0
2766 let Inst{21} = 1; // W = 1
2767 let Inst{22} = 1; // D = 1
2768 let Inst{20} = load;
2771 def L_OPTION : ACI<(outs),
2772 (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, nohash_imm:$option),
2773 opc, "l\tp$cop, cr$CRd, [$base], $option"> {
2774 let Inst{31-28} = op31_28;
2775 let Inst{24} = 0; // P = 0
2776 let Inst{23} = 1; // U = 1
2777 let Inst{21} = 0; // W = 0
2778 let Inst{22} = 1; // D = 1
2779 let Inst{20} = load;
2783 defm LDC : LdStCop<{?,?,?,?}, 1, "ldc">;
2784 defm LDC2 : LdStCop<0b1111, 1, "ldc2">;
2785 defm STC : LdStCop<{?,?,?,?}, 0, "stc">;
2786 defm STC2 : LdStCop<0b1111, 0, "stc2">;
2788 def MCR : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2789 GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2790 NoItinerary, "mcr", "\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2791 [/* For disassembly only; pattern left blank */]> {
2796 def MCR2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2797 GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2798 NoItinerary, "mcr2\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2799 [/* For disassembly only; pattern left blank */]> {
2800 let Inst{31-28} = 0b1111;
2805 def MRC : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2806 GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2807 NoItinerary, "mrc", "\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2808 [/* For disassembly only; pattern left blank */]> {
2813 def MRC2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2814 GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2815 NoItinerary, "mrc2\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2816 [/* For disassembly only; pattern left blank */]> {
2817 let Inst{31-28} = 0b1111;
2822 def MCRR : ABI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
2823 GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
2824 NoItinerary, "mcrr", "\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
2825 [/* For disassembly only; pattern left blank */]> {
2826 let Inst{23-20} = 0b0100;
2829 def MCRR2 : ABXI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
2830 GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
2831 NoItinerary, "mcrr2\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
2832 [/* For disassembly only; pattern left blank */]> {
2833 let Inst{31-28} = 0b1111;
2834 let Inst{23-20} = 0b0100;
2837 def MRRC : ABI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
2838 GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
2839 NoItinerary, "mrrc", "\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
2840 [/* For disassembly only; pattern left blank */]> {
2841 let Inst{23-20} = 0b0101;
2844 def MRRC2 : ABXI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
2845 GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
2846 NoItinerary, "mrrc2\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
2847 [/* For disassembly only; pattern left blank */]> {
2848 let Inst{31-28} = 0b1111;
2849 let Inst{23-20} = 0b0101;
2852 //===----------------------------------------------------------------------===//
2853 // Move between special register and ARM core register -- for disassembly only
2856 def MRS : ABI<0b0001,(outs GPR:$dst),(ins), NoItinerary, "mrs", "\t$dst, cpsr",
2857 [/* For disassembly only; pattern left blank */]> {
2858 let Inst{23-20} = 0b0000;
2859 let Inst{7-4} = 0b0000;
2862 def MRSsys : ABI<0b0001,(outs GPR:$dst),(ins), NoItinerary,"mrs","\t$dst, spsr",
2863 [/* For disassembly only; pattern left blank */]> {
2864 let Inst{23-20} = 0b0100;
2865 let Inst{7-4} = 0b0000;
2868 def MSR : ABI<0b0001, (outs), (ins GPR:$src, msr_mask:$mask), NoItinerary,
2869 "msr", "\tcpsr$mask, $src",
2870 [/* For disassembly only; pattern left blank */]> {
2871 let Inst{23-20} = 0b0010;
2872 let Inst{7-4} = 0b0000;
2875 def MSRi : ABI<0b0011, (outs), (ins so_imm:$a, msr_mask:$mask), NoItinerary,
2876 "msr", "\tcpsr$mask, $a",
2877 [/* For disassembly only; pattern left blank */]> {
2878 let Inst{23-20} = 0b0010;
2879 let Inst{7-4} = 0b0000;
2882 def MSRsys : ABI<0b0001, (outs), (ins GPR:$src, msr_mask:$mask), NoItinerary,
2883 "msr", "\tspsr$mask, $src",
2884 [/* For disassembly only; pattern left blank */]> {
2885 let Inst{23-20} = 0b0110;
2886 let Inst{7-4} = 0b0000;
2889 def MSRsysi : ABI<0b0011, (outs), (ins so_imm:$a, msr_mask:$mask), NoItinerary,
2890 "msr", "\tspsr$mask, $a",
2891 [/* For disassembly only; pattern left blank */]> {
2892 let Inst{23-20} = 0b0110;
2893 let Inst{7-4} = 0b0000;