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 def UseVMLx : Predicate<"Subtarget->useVMLx()">;
145 //===----------------------------------------------------------------------===//
146 // ARM Flag Definitions.
148 class RegConstraint<string C> {
149 string Constraints = C;
152 //===----------------------------------------------------------------------===//
153 // ARM specific transformation functions and pattern fragments.
156 // so_imm_neg_XFORM - Return a so_imm value packed into the format described for
157 // so_imm_neg def below.
158 def so_imm_neg_XFORM : SDNodeXForm<imm, [{
159 return CurDAG->getTargetConstant(-(int)N->getZExtValue(), MVT::i32);
162 // so_imm_not_XFORM - Return a so_imm value packed into the format described for
163 // so_imm_not def below.
164 def so_imm_not_XFORM : SDNodeXForm<imm, [{
165 return CurDAG->getTargetConstant(~(int)N->getZExtValue(), MVT::i32);
168 // rot_imm predicate - True if the 32-bit immediate is equal to 8, 16, or 24.
169 def rot_imm : PatLeaf<(i32 imm), [{
170 int32_t v = (int32_t)N->getZExtValue();
171 return v == 8 || v == 16 || v == 24;
174 /// imm1_15 predicate - True if the 32-bit immediate is in the range [1,15].
175 def imm1_15 : PatLeaf<(i32 imm), [{
176 return (int32_t)N->getZExtValue() >= 1 && (int32_t)N->getZExtValue() < 16;
179 /// imm16_31 predicate - True if the 32-bit immediate is in the range [16,31].
180 def imm16_31 : PatLeaf<(i32 imm), [{
181 return (int32_t)N->getZExtValue() >= 16 && (int32_t)N->getZExtValue() < 32;
186 return ARM_AM::getSOImmVal(-(int)N->getZExtValue()) != -1;
187 }], so_imm_neg_XFORM>;
191 return ARM_AM::getSOImmVal(~(int)N->getZExtValue()) != -1;
192 }], so_imm_not_XFORM>;
194 // sext_16_node predicate - True if the SDNode is sign-extended 16 or more bits.
195 def sext_16_node : PatLeaf<(i32 GPR:$a), [{
196 return CurDAG->ComputeNumSignBits(SDValue(N,0)) >= 17;
199 /// bf_inv_mask_imm predicate - An AND mask to clear an arbitrary width bitfield
201 def bf_inv_mask_imm : Operand<i32>,
203 uint32_t v = (uint32_t)N->getZExtValue();
206 // there can be 1's on either or both "outsides", all the "inside"
208 unsigned int lsb = 0, msb = 31;
209 while (v & (1 << msb)) --msb;
210 while (v & (1 << lsb)) ++lsb;
211 for (unsigned int i = lsb; i <= msb; ++i) {
217 let PrintMethod = "printBitfieldInvMaskImmOperand";
220 /// Split a 32-bit immediate into two 16 bit parts.
221 def lo16 : SDNodeXForm<imm, [{
222 return CurDAG->getTargetConstant((uint32_t)N->getZExtValue() & 0xffff,
226 def hi16 : SDNodeXForm<imm, [{
227 return CurDAG->getTargetConstant((uint32_t)N->getZExtValue() >> 16, MVT::i32);
230 def lo16AllZero : PatLeaf<(i32 imm), [{
231 // Returns true if all low 16-bits are 0.
232 return (((uint32_t)N->getZExtValue()) & 0xFFFFUL) == 0;
235 /// imm0_65535 predicate - True if the 32-bit immediate is in the range
237 def imm0_65535 : PatLeaf<(i32 imm), [{
238 return (uint32_t)N->getZExtValue() < 65536;
241 class BinOpFrag<dag res> : PatFrag<(ops node:$LHS, node:$RHS), res>;
242 class UnOpFrag <dag res> : PatFrag<(ops node:$Src), res>;
244 /// adde and sube predicates - True based on whether the carry flag output
245 /// will be needed or not.
246 def adde_dead_carry :
247 PatFrag<(ops node:$LHS, node:$RHS), (adde node:$LHS, node:$RHS),
248 [{return !N->hasAnyUseOfValue(1);}]>;
249 def sube_dead_carry :
250 PatFrag<(ops node:$LHS, node:$RHS), (sube node:$LHS, node:$RHS),
251 [{return !N->hasAnyUseOfValue(1);}]>;
252 def adde_live_carry :
253 PatFrag<(ops node:$LHS, node:$RHS), (adde node:$LHS, node:$RHS),
254 [{return N->hasAnyUseOfValue(1);}]>;
255 def sube_live_carry :
256 PatFrag<(ops node:$LHS, node:$RHS), (sube node:$LHS, node:$RHS),
257 [{return N->hasAnyUseOfValue(1);}]>;
259 //===----------------------------------------------------------------------===//
260 // Operand Definitions.
264 def brtarget : Operand<OtherVT>;
266 // A list of registers separated by comma. Used by load/store multiple.
267 def reglist : Operand<i32> {
268 let PrintMethod = "printRegisterList";
271 // An operand for the CONSTPOOL_ENTRY pseudo-instruction.
272 def cpinst_operand : Operand<i32> {
273 let PrintMethod = "printCPInstOperand";
276 def jtblock_operand : Operand<i32> {
277 let PrintMethod = "printJTBlockOperand";
279 def jt2block_operand : Operand<i32> {
280 let PrintMethod = "printJT2BlockOperand";
284 def pclabel : Operand<i32> {
285 let PrintMethod = "printPCLabel";
288 // shifter_operand operands: so_reg and so_imm.
289 def so_reg : Operand<i32>, // reg reg imm
290 ComplexPattern<i32, 3, "SelectShifterOperandReg",
291 [shl,srl,sra,rotr]> {
292 let PrintMethod = "printSORegOperand";
293 let MIOperandInfo = (ops GPR, GPR, i32imm);
296 // so_imm - Match a 32-bit shifter_operand immediate operand, which is an
297 // 8-bit immediate rotated by an arbitrary number of bits. so_imm values are
298 // represented in the imm field in the same 12-bit form that they are encoded
299 // into so_imm instructions: the 8-bit immediate is the least significant bits
300 // [bits 0-7], the 4-bit shift amount is the next 4 bits [bits 8-11].
301 def so_imm : Operand<i32>,
303 return ARM_AM::getSOImmVal(N->getZExtValue()) != -1;
305 let PrintMethod = "printSOImmOperand";
308 // Break so_imm's up into two pieces. This handles immediates with up to 16
309 // bits set in them. This uses so_imm2part to match and so_imm2part_[12] to
310 // get the first/second pieces.
311 def so_imm2part : Operand<i32>,
313 return ARM_AM::isSOImmTwoPartVal((unsigned)N->getZExtValue());
315 let PrintMethod = "printSOImm2PartOperand";
318 def so_imm2part_1 : SDNodeXForm<imm, [{
319 unsigned V = ARM_AM::getSOImmTwoPartFirst((unsigned)N->getZExtValue());
320 return CurDAG->getTargetConstant(V, MVT::i32);
323 def so_imm2part_2 : SDNodeXForm<imm, [{
324 unsigned V = ARM_AM::getSOImmTwoPartSecond((unsigned)N->getZExtValue());
325 return CurDAG->getTargetConstant(V, MVT::i32);
328 def so_neg_imm2part : Operand<i32>, PatLeaf<(imm), [{
329 return ARM_AM::isSOImmTwoPartVal(-(int)N->getZExtValue());
331 let PrintMethod = "printSOImm2PartOperand";
334 def so_neg_imm2part_1 : SDNodeXForm<imm, [{
335 unsigned V = ARM_AM::getSOImmTwoPartFirst(-(int)N->getZExtValue());
336 return CurDAG->getTargetConstant(V, MVT::i32);
339 def so_neg_imm2part_2 : SDNodeXForm<imm, [{
340 unsigned V = ARM_AM::getSOImmTwoPartSecond(-(int)N->getZExtValue());
341 return CurDAG->getTargetConstant(V, MVT::i32);
344 /// imm0_31 predicate - True if the 32-bit immediate is in the range [0,31].
345 def imm0_31 : Operand<i32>, PatLeaf<(imm), [{
346 return (int32_t)N->getZExtValue() < 32;
349 // Define ARM specific addressing modes.
351 // addrmode2 := reg +/- reg shop imm
352 // addrmode2 := reg +/- imm12
354 def addrmode2 : Operand<i32>,
355 ComplexPattern<i32, 3, "SelectAddrMode2", []> {
356 let PrintMethod = "printAddrMode2Operand";
357 let MIOperandInfo = (ops GPR:$base, GPR:$offsreg, i32imm:$offsimm);
360 def am2offset : Operand<i32>,
361 ComplexPattern<i32, 2, "SelectAddrMode2Offset", []> {
362 let PrintMethod = "printAddrMode2OffsetOperand";
363 let MIOperandInfo = (ops GPR, i32imm);
366 // addrmode3 := reg +/- reg
367 // addrmode3 := reg +/- imm8
369 def addrmode3 : Operand<i32>,
370 ComplexPattern<i32, 3, "SelectAddrMode3", []> {
371 let PrintMethod = "printAddrMode3Operand";
372 let MIOperandInfo = (ops GPR:$base, GPR:$offsreg, i32imm:$offsimm);
375 def am3offset : Operand<i32>,
376 ComplexPattern<i32, 2, "SelectAddrMode3Offset", []> {
377 let PrintMethod = "printAddrMode3OffsetOperand";
378 let MIOperandInfo = (ops GPR, i32imm);
381 // addrmode4 := reg, <mode|W>
383 def addrmode4 : Operand<i32>,
384 ComplexPattern<i32, 2, "SelectAddrMode4", []> {
385 let PrintMethod = "printAddrMode4Operand";
386 let MIOperandInfo = (ops GPR:$addr, i32imm);
389 // addrmode5 := reg +/- imm8*4
391 def addrmode5 : Operand<i32>,
392 ComplexPattern<i32, 2, "SelectAddrMode5", []> {
393 let PrintMethod = "printAddrMode5Operand";
394 let MIOperandInfo = (ops GPR:$base, i32imm);
397 // addrmode6 := reg with optional writeback
399 def addrmode6 : Operand<i32>,
400 ComplexPattern<i32, 2, "SelectAddrMode6", []> {
401 let PrintMethod = "printAddrMode6Operand";
402 let MIOperandInfo = (ops GPR:$addr, i32imm);
405 def am6offset : Operand<i32> {
406 let PrintMethod = "printAddrMode6OffsetOperand";
407 let MIOperandInfo = (ops GPR);
410 // addrmodepc := pc + reg
412 def addrmodepc : Operand<i32>,
413 ComplexPattern<i32, 2, "SelectAddrModePC", []> {
414 let PrintMethod = "printAddrModePCOperand";
415 let MIOperandInfo = (ops GPR, i32imm);
418 def nohash_imm : Operand<i32> {
419 let PrintMethod = "printNoHashImmediate";
422 //===----------------------------------------------------------------------===//
424 include "ARMInstrFormats.td"
426 //===----------------------------------------------------------------------===//
427 // Multiclass helpers...
430 /// AsI1_bin_irs - Defines a set of (op r, {so_imm|r|so_reg}) patterns for a
431 /// binop that produces a value.
432 multiclass AsI1_bin_irs<bits<4> opcod, string opc, PatFrag opnode,
433 bit Commutable = 0> {
434 def ri : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
435 IIC_iALUi, opc, "\t$dst, $a, $b",
436 [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]> {
439 def rr : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm,
440 IIC_iALUr, opc, "\t$dst, $a, $b",
441 [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]> {
442 let Inst{11-4} = 0b00000000;
444 let isCommutable = Commutable;
446 def rs : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
447 IIC_iALUsr, opc, "\t$dst, $a, $b",
448 [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]> {
453 /// AI1_bin_s_irs - Similar to AsI1_bin_irs except it sets the 's' bit so the
454 /// instruction modifies the CPSR register.
455 let Defs = [CPSR] in {
456 multiclass AI1_bin_s_irs<bits<4> opcod, string opc, PatFrag opnode,
457 bit Commutable = 0> {
458 def ri : AI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
459 IIC_iALUi, opc, "\t$dst, $a, $b",
460 [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]> {
464 def rr : AI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm,
465 IIC_iALUr, opc, "\t$dst, $a, $b",
466 [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]> {
467 let isCommutable = Commutable;
468 let Inst{11-4} = 0b00000000;
472 def rs : AI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
473 IIC_iALUsr, opc, "\t$dst, $a, $b",
474 [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]> {
481 /// AI1_cmp_irs - Defines a set of (op r, {so_imm|r|so_reg}) cmp / test
482 /// patterns. Similar to AsI1_bin_irs except the instruction does not produce
483 /// a explicit result, only implicitly set CPSR.
484 let Defs = [CPSR] in {
485 multiclass AI1_cmp_irs<bits<4> opcod, string opc, PatFrag opnode,
486 bit Commutable = 0> {
487 def ri : AI1<opcod, (outs), (ins GPR:$a, so_imm:$b), DPFrm, IIC_iCMPi,
489 [(opnode GPR:$a, so_imm:$b)]> {
493 def rr : AI1<opcod, (outs), (ins GPR:$a, GPR:$b), DPFrm, IIC_iCMPr,
495 [(opnode GPR:$a, GPR:$b)]> {
496 let Inst{11-4} = 0b00000000;
499 let isCommutable = Commutable;
501 def rs : AI1<opcod, (outs), (ins GPR:$a, so_reg:$b), DPSoRegFrm, IIC_iCMPsr,
503 [(opnode GPR:$a, so_reg:$b)]> {
510 /// AI_unary_rrot - A unary operation with two forms: one whose operand is a
511 /// register and one whose operand is a register rotated by 8/16/24.
512 /// FIXME: Remove the 'r' variant. Its rot_imm is zero.
513 multiclass AI_unary_rrot<bits<8> opcod, string opc, PatFrag opnode> {
514 def r : AExtI<opcod, (outs GPR:$dst), (ins GPR:$src),
515 IIC_iUNAr, opc, "\t$dst, $src",
516 [(set GPR:$dst, (opnode GPR:$src))]>,
517 Requires<[IsARM, HasV6]> {
518 let Inst{11-10} = 0b00;
519 let Inst{19-16} = 0b1111;
521 def r_rot : AExtI<opcod, (outs GPR:$dst), (ins GPR:$src, i32imm:$rot),
522 IIC_iUNAsi, opc, "\t$dst, $src, ror $rot",
523 [(set GPR:$dst, (opnode (rotr GPR:$src, rot_imm:$rot)))]>,
524 Requires<[IsARM, HasV6]> {
525 let Inst{19-16} = 0b1111;
529 multiclass AI_unary_rrot_np<bits<8> opcod, string opc> {
530 def r : AExtI<opcod, (outs GPR:$dst), (ins GPR:$src),
531 IIC_iUNAr, opc, "\t$dst, $src",
532 [/* For disassembly only; pattern left blank */]>,
533 Requires<[IsARM, HasV6]> {
534 let Inst{11-10} = 0b00;
535 let Inst{19-16} = 0b1111;
537 def r_rot : AExtI<opcod, (outs GPR:$dst), (ins GPR:$src, i32imm:$rot),
538 IIC_iUNAsi, opc, "\t$dst, $src, ror $rot",
539 [/* For disassembly only; pattern left blank */]>,
540 Requires<[IsARM, HasV6]> {
541 let Inst{19-16} = 0b1111;
545 /// AI_bin_rrot - A binary operation with two forms: one whose operand is a
546 /// register and one whose operand is a register rotated by 8/16/24.
547 multiclass AI_bin_rrot<bits<8> opcod, string opc, PatFrag opnode> {
548 def rr : AExtI<opcod, (outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS),
549 IIC_iALUr, opc, "\t$dst, $LHS, $RHS",
550 [(set GPR:$dst, (opnode GPR:$LHS, GPR:$RHS))]>,
551 Requires<[IsARM, HasV6]> {
552 let Inst{11-10} = 0b00;
554 def rr_rot : AExtI<opcod, (outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS,
556 IIC_iALUsi, opc, "\t$dst, $LHS, $RHS, ror $rot",
557 [(set GPR:$dst, (opnode GPR:$LHS,
558 (rotr GPR:$RHS, rot_imm:$rot)))]>,
559 Requires<[IsARM, HasV6]>;
562 // For disassembly only.
563 multiclass AI_bin_rrot_np<bits<8> opcod, string opc> {
564 def rr : AExtI<opcod, (outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS),
565 IIC_iALUr, opc, "\t$dst, $LHS, $RHS",
566 [/* For disassembly only; pattern left blank */]>,
567 Requires<[IsARM, HasV6]> {
568 let Inst{11-10} = 0b00;
570 def rr_rot : AExtI<opcod, (outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS,
572 IIC_iALUsi, opc, "\t$dst, $LHS, $RHS, ror $rot",
573 [/* For disassembly only; pattern left blank */]>,
574 Requires<[IsARM, HasV6]>;
577 /// AI1_adde_sube_irs - Define instructions and patterns for adde and sube.
578 let Uses = [CPSR] in {
579 multiclass AI1_adde_sube_irs<bits<4> opcod, string opc, PatFrag opnode,
580 bit Commutable = 0> {
581 def ri : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
582 DPFrm, IIC_iALUi, opc, "\t$dst, $a, $b",
583 [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]>,
587 def rr : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
588 DPFrm, IIC_iALUr, opc, "\t$dst, $a, $b",
589 [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]>,
591 let isCommutable = Commutable;
592 let Inst{11-4} = 0b00000000;
595 def rs : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
596 DPSoRegFrm, IIC_iALUsr, opc, "\t$dst, $a, $b",
597 [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]>,
602 // Carry setting variants
603 let Defs = [CPSR] in {
604 multiclass AI1_adde_sube_s_irs<bits<4> opcod, string opc, PatFrag opnode,
605 bit Commutable = 0> {
606 def Sri : AXI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
607 DPFrm, IIC_iALUi, !strconcat(opc, "\t$dst, $a, $b"),
608 [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]>,
613 def Srr : AXI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
614 DPFrm, IIC_iALUr, !strconcat(opc, "\t$dst, $a, $b"),
615 [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]>,
617 let Inst{11-4} = 0b00000000;
621 def Srs : AXI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
622 DPSoRegFrm, IIC_iALUsr, !strconcat(opc, "\t$dst, $a, $b"),
623 [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]>,
632 //===----------------------------------------------------------------------===//
634 //===----------------------------------------------------------------------===//
636 //===----------------------------------------------------------------------===//
637 // Miscellaneous Instructions.
640 /// CONSTPOOL_ENTRY - This instruction represents a floating constant pool in
641 /// the function. The first operand is the ID# for this instruction, the second
642 /// is the index into the MachineConstantPool that this is, the third is the
643 /// size in bytes of this constant pool entry.
644 let neverHasSideEffects = 1, isNotDuplicable = 1 in
645 def CONSTPOOL_ENTRY :
646 PseudoInst<(outs), (ins cpinst_operand:$instid, cpinst_operand:$cpidx,
647 i32imm:$size), NoItinerary,
648 "${instid:label} ${cpidx:cpentry}", []>;
650 // FIXME: Marking these as hasSideEffects is necessary to prevent machine DCE
651 // from removing one half of the matched pairs. That breaks PEI, which assumes
652 // these will always be in pairs, and asserts if it finds otherwise. Better way?
653 let Defs = [SP], Uses = [SP], hasSideEffects = 1 in {
655 PseudoInst<(outs), (ins i32imm:$amt1, i32imm:$amt2, pred:$p), NoItinerary,
656 "@ ADJCALLSTACKUP $amt1",
657 [(ARMcallseq_end timm:$amt1, timm:$amt2)]>;
659 def ADJCALLSTACKDOWN :
660 PseudoInst<(outs), (ins i32imm:$amt, pred:$p), NoItinerary,
661 "@ ADJCALLSTACKDOWN $amt",
662 [(ARMcallseq_start timm:$amt)]>;
665 def NOP : AI<(outs), (ins), MiscFrm, NoItinerary, "nop", "",
666 [/* For disassembly only; pattern left blank */]>,
667 Requires<[IsARM, HasV6T2]> {
668 let Inst{27-16} = 0b001100100000;
669 let Inst{7-0} = 0b00000000;
672 def YIELD : AI<(outs), (ins), MiscFrm, NoItinerary, "yield", "",
673 [/* For disassembly only; pattern left blank */]>,
674 Requires<[IsARM, HasV6T2]> {
675 let Inst{27-16} = 0b001100100000;
676 let Inst{7-0} = 0b00000001;
679 def WFE : AI<(outs), (ins), MiscFrm, NoItinerary, "wfe", "",
680 [/* For disassembly only; pattern left blank */]>,
681 Requires<[IsARM, HasV6T2]> {
682 let Inst{27-16} = 0b001100100000;
683 let Inst{7-0} = 0b00000010;
686 def WFI : AI<(outs), (ins), MiscFrm, NoItinerary, "wfi", "",
687 [/* For disassembly only; pattern left blank */]>,
688 Requires<[IsARM, HasV6T2]> {
689 let Inst{27-16} = 0b001100100000;
690 let Inst{7-0} = 0b00000011;
693 def SEL : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm, NoItinerary, "sel",
695 [/* For disassembly only; pattern left blank */]>,
696 Requires<[IsARM, HasV6]> {
697 let Inst{27-20} = 0b01101000;
698 let Inst{7-4} = 0b1011;
701 def SEV : AI<(outs), (ins), MiscFrm, NoItinerary, "sev", "",
702 [/* For disassembly only; pattern left blank */]>,
703 Requires<[IsARM, HasV6T2]> {
704 let Inst{27-16} = 0b001100100000;
705 let Inst{7-0} = 0b00000100;
708 // The i32imm operand $val can be used by a debugger to store more information
709 // about the breakpoint.
710 def BKPT : AI<(outs), (ins i32imm:$val), MiscFrm, NoItinerary, "bkpt", "\t$val",
711 [/* For disassembly only; pattern left blank */]>,
713 let Inst{27-20} = 0b00010010;
714 let Inst{7-4} = 0b0111;
717 // Change Processor State is a system instruction -- for disassembly only.
718 // The singleton $opt operand contains the following information:
719 // opt{4-0} = mode from Inst{4-0}
720 // opt{5} = changemode from Inst{17}
721 // opt{8-6} = AIF from Inst{8-6}
722 // opt{10-9} = imod from Inst{19-18} with 0b10 as enable and 0b11 as disable
723 def CPS : AXI<(outs), (ins cps_opt:$opt), MiscFrm, NoItinerary, "cps$opt",
724 [/* For disassembly only; pattern left blank */]>,
726 let Inst{31-28} = 0b1111;
727 let Inst{27-20} = 0b00010000;
732 // Preload signals the memory system of possible future data/instruction access.
733 // These are for disassembly only.
735 // A8.6.117, A8.6.118. Different instructions are generated for #0 and #-0.
736 // The neg_zero operand translates -0 to -1, -1 to -2, ..., etc.
737 multiclass APreLoad<bit data, bit read, string opc> {
739 def i : AXI<(outs), (ins GPR:$base, neg_zero:$imm), MiscFrm, NoItinerary,
740 !strconcat(opc, "\t[$base, $imm]"), []> {
741 let Inst{31-26} = 0b111101;
742 let Inst{25} = 0; // 0 for immediate form
745 let Inst{21-20} = 0b01;
748 def r : AXI<(outs), (ins addrmode2:$addr), MiscFrm, NoItinerary,
749 !strconcat(opc, "\t$addr"), []> {
750 let Inst{31-26} = 0b111101;
751 let Inst{25} = 1; // 1 for register form
754 let Inst{21-20} = 0b01;
759 defm PLD : APreLoad<1, 1, "pld">;
760 defm PLDW : APreLoad<1, 0, "pldw">;
761 defm PLI : APreLoad<0, 1, "pli">;
763 def SETENDBE : AXI<(outs),(ins), MiscFrm, NoItinerary, "setend\tbe",
764 [/* For disassembly only; pattern left blank */]>,
766 let Inst{31-28} = 0b1111;
767 let Inst{27-20} = 0b00010000;
770 let Inst{7-4} = 0b0000;
773 def SETENDLE : AXI<(outs),(ins), MiscFrm, NoItinerary, "setend\tle",
774 [/* For disassembly only; pattern left blank */]>,
776 let Inst{31-28} = 0b1111;
777 let Inst{27-20} = 0b00010000;
780 let Inst{7-4} = 0b0000;
783 def DBG : AI<(outs), (ins i32imm:$opt), MiscFrm, NoItinerary, "dbg", "\t$opt",
784 [/* For disassembly only; pattern left blank */]>,
785 Requires<[IsARM, HasV7]> {
786 let Inst{27-16} = 0b001100100000;
787 let Inst{7-4} = 0b1111;
790 // A5.4 Permanently UNDEFINED instructions.
791 def TRAP : AI<(outs), (ins), MiscFrm, NoItinerary, "trap", "",
792 [/* For disassembly only; pattern left blank */]>,
794 let Inst{27-25} = 0b011;
795 let Inst{24-20} = 0b11111;
796 let Inst{7-5} = 0b111;
800 // Address computation and loads and stores in PIC mode.
801 let isNotDuplicable = 1 in {
802 def PICADD : AXI1<0b0100, (outs GPR:$dst), (ins GPR:$a, pclabel:$cp, pred:$p),
803 Pseudo, IIC_iALUr, "\n$cp:\n\tadd$p\t$dst, pc, $a",
804 [(set GPR:$dst, (ARMpic_add GPR:$a, imm:$cp))]>;
806 let AddedComplexity = 10 in {
807 def PICLDR : AXI2ldw<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
808 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldr$p\t$dst, $addr",
809 [(set GPR:$dst, (load addrmodepc:$addr))]>;
811 def PICLDRH : AXI3ldh<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
812 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldrh${p}\t$dst, $addr",
813 [(set GPR:$dst, (zextloadi16 addrmodepc:$addr))]>;
815 def PICLDRB : AXI2ldb<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
816 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldrb${p}\t$dst, $addr",
817 [(set GPR:$dst, (zextloadi8 addrmodepc:$addr))]>;
819 def PICLDRSH : AXI3ldsh<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
820 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldrsh${p}\t$dst, $addr",
821 [(set GPR:$dst, (sextloadi16 addrmodepc:$addr))]>;
823 def PICLDRSB : AXI3ldsb<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
824 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldrsb${p}\t$dst, $addr",
825 [(set GPR:$dst, (sextloadi8 addrmodepc:$addr))]>;
827 let AddedComplexity = 10 in {
828 def PICSTR : AXI2stw<(outs), (ins GPR:$src, addrmodepc:$addr, pred:$p),
829 Pseudo, IIC_iStorer, "\n${addr:label}:\n\tstr$p\t$src, $addr",
830 [(store GPR:$src, addrmodepc:$addr)]>;
832 def PICSTRH : AXI3sth<(outs), (ins GPR:$src, addrmodepc:$addr, pred:$p),
833 Pseudo, IIC_iStorer, "\n${addr:label}:\n\tstrh${p}\t$src, $addr",
834 [(truncstorei16 GPR:$src, addrmodepc:$addr)]>;
836 def PICSTRB : AXI2stb<(outs), (ins GPR:$src, addrmodepc:$addr, pred:$p),
837 Pseudo, IIC_iStorer, "\n${addr:label}:\n\tstrb${p}\t$src, $addr",
838 [(truncstorei8 GPR:$src, addrmodepc:$addr)]>;
840 } // isNotDuplicable = 1
843 // LEApcrel - Load a pc-relative address into a register without offending the
845 def LEApcrel : AXI1<0x0, (outs GPR:$dst), (ins i32imm:$label, pred:$p),
847 !strconcat(!strconcat(".set ${:private}PCRELV${:uid}, ($label-(",
848 "${:private}PCRELL${:uid}+8))\n"),
849 !strconcat("${:private}PCRELL${:uid}:\n\t",
850 "add$p\t$dst, pc, #${:private}PCRELV${:uid}")),
853 def LEApcrelJT : AXI1<0x0, (outs GPR:$dst),
854 (ins i32imm:$label, nohash_imm:$id, pred:$p),
856 !strconcat(!strconcat(".set ${:private}PCRELV${:uid}, "
858 "${:private}PCRELL${:uid}+8))\n"),
859 !strconcat("${:private}PCRELL${:uid}:\n\t",
860 "add$p\t$dst, pc, #${:private}PCRELV${:uid}")),
865 //===----------------------------------------------------------------------===//
866 // Control Flow Instructions.
869 let isReturn = 1, isTerminator = 1, isBarrier = 1 in {
871 def BX_RET : AI<(outs), (ins), BrMiscFrm, IIC_Br,
872 "bx", "\tlr", [(ARMretflag)]>,
873 Requires<[IsARM, HasV4T]> {
874 let Inst{3-0} = 0b1110;
875 let Inst{7-4} = 0b0001;
876 let Inst{19-8} = 0b111111111111;
877 let Inst{27-20} = 0b00010010;
881 def MOVPCLR : AI<(outs), (ins), BrMiscFrm, IIC_Br,
882 "mov", "\tpc, lr", [(ARMretflag)]>,
883 Requires<[IsARM, NoV4T]> {
884 let Inst{11-0} = 0b000000001110;
885 let Inst{15-12} = 0b1111;
886 let Inst{19-16} = 0b0000;
887 let Inst{27-20} = 0b00011010;
892 let isBranch = 1, isTerminator = 1, isBarrier = 1, isIndirectBranch = 1 in {
894 def BRIND : AXI<(outs), (ins GPR:$dst), BrMiscFrm, IIC_Br, "bx\t$dst",
896 Requires<[IsARM, HasV4T]> {
897 let Inst{7-4} = 0b0001;
898 let Inst{19-8} = 0b111111111111;
899 let Inst{27-20} = 0b00010010;
900 let Inst{31-28} = 0b1110;
904 def MOVPCRX : AXI<(outs), (ins GPR:$dst), BrMiscFrm, IIC_Br, "mov\tpc, $dst",
906 Requires<[IsARM, NoV4T]> {
907 let Inst{11-4} = 0b00000000;
908 let Inst{15-12} = 0b1111;
909 let Inst{19-16} = 0b0000;
910 let Inst{27-20} = 0b00011010;
911 let Inst{31-28} = 0b1110;
915 // FIXME: remove when we have a way to marking a MI with these properties.
916 // FIXME: Should pc be an implicit operand like PICADD, etc?
917 let isReturn = 1, isTerminator = 1, isBarrier = 1, mayLoad = 1,
918 hasExtraDefRegAllocReq = 1 in
919 def LDM_RET : AXI4ld<(outs GPR:$wb), (ins addrmode4:$addr, pred:$p,
920 reglist:$dsts, variable_ops),
921 IndexModeUpd, LdStMulFrm, IIC_Br,
922 "ldm${addr:submode}${p}\t$addr!, $dsts",
923 "$addr.addr = $wb", []>;
925 // On non-Darwin platforms R9 is callee-saved.
927 Defs = [R0, R1, R2, R3, R12, LR,
928 D0, D1, D2, D3, D4, D5, D6, D7,
929 D16, D17, D18, D19, D20, D21, D22, D23,
930 D24, D25, D26, D27, D28, D29, D30, D31, CPSR, FPSCR] in {
931 def BL : ABXI<0b1011, (outs), (ins i32imm:$func, variable_ops),
932 IIC_Br, "bl\t${func:call}",
933 [(ARMcall tglobaladdr:$func)]>,
934 Requires<[IsARM, IsNotDarwin]> {
935 let Inst{31-28} = 0b1110;
938 def BL_pred : ABI<0b1011, (outs), (ins i32imm:$func, variable_ops),
939 IIC_Br, "bl", "\t${func:call}",
940 [(ARMcall_pred tglobaladdr:$func)]>,
941 Requires<[IsARM, IsNotDarwin]>;
944 def BLX : AXI<(outs), (ins GPR:$func, variable_ops), BrMiscFrm,
945 IIC_Br, "blx\t$func",
946 [(ARMcall GPR:$func)]>,
947 Requires<[IsARM, HasV5T, IsNotDarwin]> {
948 let Inst{7-4} = 0b0011;
949 let Inst{19-8} = 0b111111111111;
950 let Inst{27-20} = 0b00010010;
954 // Note: Restrict $func to the tGPR regclass to prevent it being in LR.
955 def BX : ABXIx2<(outs), (ins tGPR:$func, variable_ops),
956 IIC_Br, "mov\tlr, pc\n\tbx\t$func",
957 [(ARMcall_nolink tGPR:$func)]>,
958 Requires<[IsARM, HasV4T, IsNotDarwin]> {
959 let Inst{7-4} = 0b0001;
960 let Inst{19-8} = 0b111111111111;
961 let Inst{27-20} = 0b00010010;
965 def BMOVPCRX : ABXIx2<(outs), (ins tGPR:$func, variable_ops),
966 IIC_Br, "mov\tlr, pc\n\tmov\tpc, $func",
967 [(ARMcall_nolink tGPR:$func)]>,
968 Requires<[IsARM, NoV4T, IsNotDarwin]> {
969 let Inst{11-4} = 0b00000000;
970 let Inst{15-12} = 0b1111;
971 let Inst{19-16} = 0b0000;
972 let Inst{27-20} = 0b00011010;
976 // On Darwin R9 is call-clobbered.
978 Defs = [R0, R1, R2, R3, R9, R12, LR,
979 D0, D1, D2, D3, D4, D5, D6, D7,
980 D16, D17, D18, D19, D20, D21, D22, D23,
981 D24, D25, D26, D27, D28, D29, D30, D31, CPSR, FPSCR] in {
982 def BLr9 : ABXI<0b1011, (outs), (ins i32imm:$func, variable_ops),
983 IIC_Br, "bl\t${func:call}",
984 [(ARMcall tglobaladdr:$func)]>, Requires<[IsARM, IsDarwin]> {
985 let Inst{31-28} = 0b1110;
988 def BLr9_pred : ABI<0b1011, (outs), (ins i32imm:$func, variable_ops),
989 IIC_Br, "bl", "\t${func:call}",
990 [(ARMcall_pred tglobaladdr:$func)]>,
991 Requires<[IsARM, IsDarwin]>;
994 def BLXr9 : AXI<(outs), (ins GPR:$func, variable_ops), BrMiscFrm,
995 IIC_Br, "blx\t$func",
996 [(ARMcall GPR:$func)]>, Requires<[IsARM, HasV5T, IsDarwin]> {
997 let Inst{7-4} = 0b0011;
998 let Inst{19-8} = 0b111111111111;
999 let Inst{27-20} = 0b00010010;
1003 // Note: Restrict $func to the tGPR regclass to prevent it being in LR.
1004 def BXr9 : ABXIx2<(outs), (ins tGPR:$func, variable_ops),
1005 IIC_Br, "mov\tlr, pc\n\tbx\t$func",
1006 [(ARMcall_nolink tGPR:$func)]>,
1007 Requires<[IsARM, HasV4T, IsDarwin]> {
1008 let Inst{7-4} = 0b0001;
1009 let Inst{19-8} = 0b111111111111;
1010 let Inst{27-20} = 0b00010010;
1014 def BMOVPCRXr9 : ABXIx2<(outs), (ins tGPR:$func, variable_ops),
1015 IIC_Br, "mov\tlr, pc\n\tmov\tpc, $func",
1016 [(ARMcall_nolink tGPR:$func)]>,
1017 Requires<[IsARM, NoV4T, IsDarwin]> {
1018 let Inst{11-4} = 0b00000000;
1019 let Inst{15-12} = 0b1111;
1020 let Inst{19-16} = 0b0000;
1021 let Inst{27-20} = 0b00011010;
1025 let isBranch = 1, isTerminator = 1 in {
1026 // B is "predicable" since it can be xformed into a Bcc.
1027 let isBarrier = 1 in {
1028 let isPredicable = 1 in
1029 def B : ABXI<0b1010, (outs), (ins brtarget:$target), IIC_Br,
1030 "b\t$target", [(br bb:$target)]>;
1032 let isNotDuplicable = 1, isIndirectBranch = 1 in {
1033 def BR_JTr : JTI<(outs), (ins GPR:$target, jtblock_operand:$jt, i32imm:$id),
1034 IIC_Br, "mov\tpc, $target \n$jt",
1035 [(ARMbrjt GPR:$target, tjumptable:$jt, imm:$id)]> {
1036 let Inst{11-4} = 0b00000000;
1037 let Inst{15-12} = 0b1111;
1038 let Inst{20} = 0; // S Bit
1039 let Inst{24-21} = 0b1101;
1040 let Inst{27-25} = 0b000;
1042 def BR_JTm : JTI<(outs),
1043 (ins addrmode2:$target, jtblock_operand:$jt, i32imm:$id),
1044 IIC_Br, "ldr\tpc, $target \n$jt",
1045 [(ARMbrjt (i32 (load addrmode2:$target)), tjumptable:$jt,
1047 let Inst{15-12} = 0b1111;
1048 let Inst{20} = 1; // L bit
1049 let Inst{21} = 0; // W bit
1050 let Inst{22} = 0; // B bit
1051 let Inst{24} = 1; // P bit
1052 let Inst{27-25} = 0b011;
1054 def BR_JTadd : JTI<(outs),
1055 (ins GPR:$target, GPR:$idx, jtblock_operand:$jt, i32imm:$id),
1056 IIC_Br, "add\tpc, $target, $idx \n$jt",
1057 [(ARMbrjt (add GPR:$target, GPR:$idx), tjumptable:$jt,
1059 let Inst{15-12} = 0b1111;
1060 let Inst{20} = 0; // S bit
1061 let Inst{24-21} = 0b0100;
1062 let Inst{27-25} = 0b000;
1064 } // isNotDuplicable = 1, isIndirectBranch = 1
1067 // FIXME: should be able to write a pattern for ARMBrcond, but can't use
1068 // a two-value operand where a dag node expects two operands. :(
1069 def Bcc : ABI<0b1010, (outs), (ins brtarget:$target),
1070 IIC_Br, "b", "\t$target",
1071 [/*(ARMbrcond bb:$target, imm:$cc, CCR:$ccr)*/]>;
1074 // Branch and Exchange Jazelle -- for disassembly only
1075 def BXJ : ABI<0b0001, (outs), (ins GPR:$func), NoItinerary, "bxj", "\t$func",
1076 [/* For disassembly only; pattern left blank */]> {
1077 let Inst{23-20} = 0b0010;
1078 //let Inst{19-8} = 0xfff;
1079 let Inst{7-4} = 0b0010;
1082 // Secure Monitor Call is a system instruction -- for disassembly only
1083 def SMC : ABI<0b0001, (outs), (ins i32imm:$opt), NoItinerary, "smc", "\t$opt",
1084 [/* For disassembly only; pattern left blank */]> {
1085 let Inst{23-20} = 0b0110;
1086 let Inst{7-4} = 0b0111;
1089 // Supervisor Call (Software Interrupt) -- for disassembly only
1091 def SVC : ABI<0b1111, (outs), (ins i32imm:$svc), IIC_Br, "svc", "\t$svc",
1092 [/* For disassembly only; pattern left blank */]>;
1095 // Store Return State is a system instruction -- for disassembly only
1096 def SRSW : 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} = 0b110; // W = 1
1103 def SRS : ABXI<{1,0,0,?}, (outs), (ins addrmode4:$addr, i32imm:$mode),
1104 NoItinerary, "srs${addr:submode}\tsp, $mode",
1105 [/* For disassembly only; pattern left blank */]> {
1106 let Inst{31-28} = 0b1111;
1107 let Inst{22-20} = 0b100; // W = 0
1110 // Return From Exception is a system instruction -- for disassembly only
1111 def RFEW : 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} = 0b011; // W = 1
1118 def RFE : ABXI<{1,0,0,?}, (outs), (ins addrmode4:$addr, GPR:$base),
1119 NoItinerary, "rfe${addr:submode}\t$base",
1120 [/* For disassembly only; pattern left blank */]> {
1121 let Inst{31-28} = 0b1111;
1122 let Inst{22-20} = 0b001; // W = 0
1125 //===----------------------------------------------------------------------===//
1126 // Load / store Instructions.
1130 let canFoldAsLoad = 1, isReMaterializable = 1 in
1131 def LDR : AI2ldw<(outs GPR:$dst), (ins addrmode2:$addr), LdFrm, IIC_iLoadr,
1132 "ldr", "\t$dst, $addr",
1133 [(set GPR:$dst, (load addrmode2:$addr))]>;
1135 // Special LDR for loads from non-pc-relative constpools.
1136 let canFoldAsLoad = 1, mayLoad = 1, isReMaterializable = 1 in
1137 def LDRcp : AI2ldw<(outs GPR:$dst), (ins addrmode2:$addr), LdFrm, IIC_iLoadr,
1138 "ldr", "\t$dst, $addr", []>;
1140 // Loads with zero extension
1141 def LDRH : AI3ldh<(outs GPR:$dst), (ins addrmode3:$addr), LdMiscFrm,
1142 IIC_iLoadr, "ldrh", "\t$dst, $addr",
1143 [(set GPR:$dst, (zextloadi16 addrmode3:$addr))]>;
1145 def LDRB : AI2ldb<(outs GPR:$dst), (ins addrmode2:$addr), LdFrm,
1146 IIC_iLoadr, "ldrb", "\t$dst, $addr",
1147 [(set GPR:$dst, (zextloadi8 addrmode2:$addr))]>;
1149 // Loads with sign extension
1150 def LDRSH : AI3ldsh<(outs GPR:$dst), (ins addrmode3:$addr), LdMiscFrm,
1151 IIC_iLoadr, "ldrsh", "\t$dst, $addr",
1152 [(set GPR:$dst, (sextloadi16 addrmode3:$addr))]>;
1154 def LDRSB : AI3ldsb<(outs GPR:$dst), (ins addrmode3:$addr), LdMiscFrm,
1155 IIC_iLoadr, "ldrsb", "\t$dst, $addr",
1156 [(set GPR:$dst, (sextloadi8 addrmode3:$addr))]>;
1158 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in {
1160 def LDRD : AI3ldd<(outs GPR:$dst1, GPR:$dst2), (ins addrmode3:$addr), LdMiscFrm,
1161 IIC_iLoadr, "ldrd", "\t$dst1, $addr",
1162 []>, Requires<[IsARM, HasV5TE]>;
1165 def LDR_PRE : AI2ldwpr<(outs GPR:$dst, GPR:$base_wb),
1166 (ins addrmode2:$addr), LdFrm, IIC_iLoadru,
1167 "ldr", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1169 def LDR_POST : AI2ldwpo<(outs GPR:$dst, GPR:$base_wb),
1170 (ins GPR:$base, am2offset:$offset), LdFrm, IIC_iLoadru,
1171 "ldr", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1173 def LDRH_PRE : AI3ldhpr<(outs GPR:$dst, GPR:$base_wb),
1174 (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadru,
1175 "ldrh", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1177 def LDRH_POST : AI3ldhpo<(outs GPR:$dst, GPR:$base_wb),
1178 (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1179 "ldrh", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1181 def LDRB_PRE : AI2ldbpr<(outs GPR:$dst, GPR:$base_wb),
1182 (ins addrmode2:$addr), LdFrm, IIC_iLoadru,
1183 "ldrb", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1185 def LDRB_POST : AI2ldbpo<(outs GPR:$dst, GPR:$base_wb),
1186 (ins GPR:$base,am2offset:$offset), LdFrm, IIC_iLoadru,
1187 "ldrb", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1189 def LDRSH_PRE : AI3ldshpr<(outs GPR:$dst, GPR:$base_wb),
1190 (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadru,
1191 "ldrsh", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1193 def LDRSH_POST: AI3ldshpo<(outs GPR:$dst, GPR:$base_wb),
1194 (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1195 "ldrsh", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1197 def LDRSB_PRE : AI3ldsbpr<(outs GPR:$dst, GPR:$base_wb),
1198 (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadru,
1199 "ldrsb", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1201 def LDRSB_POST: AI3ldsbpo<(outs GPR:$dst, GPR:$base_wb),
1202 (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1203 "ldrsb", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1205 // For disassembly only
1206 def LDRD_PRE : AI3lddpr<(outs GPR:$dst1, GPR:$dst2, GPR:$base_wb),
1207 (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadr,
1208 "ldrd", "\t$dst1, $dst2, $addr!", "$addr.base = $base_wb", []>,
1209 Requires<[IsARM, HasV5TE]>;
1211 // For disassembly only
1212 def LDRD_POST : AI3lddpo<(outs GPR:$dst1, GPR:$dst2, GPR:$base_wb),
1213 (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadr,
1214 "ldrd", "\t$dst1, $dst2, [$base], $offset", "$base = $base_wb", []>,
1215 Requires<[IsARM, HasV5TE]>;
1219 // LDRT, LDRBT, LDRSBT, LDRHT, LDRSHT are for disassembly only.
1221 def LDRT : AI2ldwpo<(outs GPR:$dst, GPR:$base_wb),
1222 (ins GPR:$base, am2offset:$offset), LdFrm, IIC_iLoadru,
1223 "ldrt", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1224 let Inst{21} = 1; // overwrite
1227 def LDRBT : AI2ldbpo<(outs GPR:$dst, GPR:$base_wb),
1228 (ins GPR:$base,am2offset:$offset), LdFrm, IIC_iLoadru,
1229 "ldrbt", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1230 let Inst{21} = 1; // overwrite
1233 def LDRSBT : AI3ldsbpo<(outs GPR:$dst, GPR:$base_wb),
1234 (ins GPR:$base,am2offset:$offset), LdMiscFrm, IIC_iLoadru,
1235 "ldrsbt", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1236 let Inst{21} = 1; // overwrite
1239 def LDRHT : AI3ldhpo<(outs GPR:$dst, GPR:$base_wb),
1240 (ins GPR:$base, am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1241 "ldrht", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1242 let Inst{21} = 1; // overwrite
1245 def LDRSHT : AI3ldshpo<(outs GPR:$dst, GPR:$base_wb),
1246 (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1247 "ldrsht", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1248 let Inst{21} = 1; // overwrite
1252 def STR : AI2stw<(outs), (ins GPR:$src, addrmode2:$addr), StFrm, IIC_iStorer,
1253 "str", "\t$src, $addr",
1254 [(store GPR:$src, addrmode2:$addr)]>;
1256 // Stores with truncate
1257 def STRH : AI3sth<(outs), (ins GPR:$src, addrmode3:$addr), StMiscFrm,
1258 IIC_iStorer, "strh", "\t$src, $addr",
1259 [(truncstorei16 GPR:$src, addrmode3:$addr)]>;
1261 def STRB : AI2stb<(outs), (ins GPR:$src, addrmode2:$addr), StFrm, IIC_iStorer,
1262 "strb", "\t$src, $addr",
1263 [(truncstorei8 GPR:$src, addrmode2:$addr)]>;
1266 let mayStore = 1, hasExtraSrcRegAllocReq = 1 in
1267 def STRD : AI3std<(outs), (ins GPR:$src1, GPR:$src2, addrmode3:$addr),
1268 StMiscFrm, IIC_iStorer,
1269 "strd", "\t$src1, $addr", []>, Requires<[IsARM, HasV5TE]>;
1272 def STR_PRE : AI2stwpr<(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 (pre_store GPR:$src, GPR:$base, am2offset:$offset))]>;
1279 def STR_POST : AI2stwpo<(outs GPR:$base_wb),
1280 (ins GPR:$src, GPR:$base,am2offset:$offset),
1281 StFrm, IIC_iStoreru,
1282 "str", "\t$src, [$base], $offset", "$base = $base_wb",
1284 (post_store GPR:$src, GPR:$base, am2offset:$offset))]>;
1286 def STRH_PRE : AI3sthpr<(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",
1291 (pre_truncsti16 GPR:$src, GPR:$base,am3offset:$offset))]>;
1293 def STRH_POST: AI3sthpo<(outs GPR:$base_wb),
1294 (ins GPR:$src, GPR:$base,am3offset:$offset),
1295 StMiscFrm, IIC_iStoreru,
1296 "strh", "\t$src, [$base], $offset", "$base = $base_wb",
1297 [(set GPR:$base_wb, (post_truncsti16 GPR:$src,
1298 GPR:$base, am3offset:$offset))]>;
1300 def STRB_PRE : AI2stbpr<(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, (pre_truncsti8 GPR:$src,
1305 GPR:$base, am2offset:$offset))]>;
1307 def STRB_POST: AI2stbpo<(outs GPR:$base_wb),
1308 (ins GPR:$src, GPR:$base,am2offset:$offset),
1309 StFrm, IIC_iStoreru,
1310 "strb", "\t$src, [$base], $offset", "$base = $base_wb",
1311 [(set GPR:$base_wb, (post_truncsti8 GPR:$src,
1312 GPR:$base, am2offset:$offset))]>;
1314 // For disassembly only
1315 def STRD_PRE : AI3stdpr<(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 // For disassembly only
1322 def STRD_POST: AI3stdpo<(outs GPR:$base_wb),
1323 (ins GPR:$src1, GPR:$src2, GPR:$base, am3offset:$offset),
1324 StMiscFrm, IIC_iStoreru,
1325 "strd", "\t$src1, $src2, [$base], $offset",
1326 "$base = $base_wb", []>;
1328 // STRT, STRBT, and STRHT are for disassembly only.
1330 def STRT : AI2stwpo<(outs GPR:$base_wb),
1331 (ins GPR:$src, GPR:$base,am2offset:$offset),
1332 StFrm, IIC_iStoreru,
1333 "strt", "\t$src, [$base], $offset", "$base = $base_wb",
1334 [/* For disassembly only; pattern left blank */]> {
1335 let Inst{21} = 1; // overwrite
1338 def STRBT : AI2stbpo<(outs GPR:$base_wb),
1339 (ins GPR:$src, GPR:$base,am2offset:$offset),
1340 StFrm, IIC_iStoreru,
1341 "strbt", "\t$src, [$base], $offset", "$base = $base_wb",
1342 [/* For disassembly only; pattern left blank */]> {
1343 let Inst{21} = 1; // overwrite
1346 def STRHT: AI3sthpo<(outs GPR:$base_wb),
1347 (ins GPR:$src, GPR:$base,am3offset:$offset),
1348 StMiscFrm, IIC_iStoreru,
1349 "strht", "\t$src, [$base], $offset", "$base = $base_wb",
1350 [/* For disassembly only; pattern left blank */]> {
1351 let Inst{21} = 1; // overwrite
1354 //===----------------------------------------------------------------------===//
1355 // Load / store multiple Instructions.
1358 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in {
1359 def LDM : AXI4ld<(outs), (ins addrmode4:$addr, pred:$p,
1360 reglist:$dsts, variable_ops),
1361 IndexModeNone, LdStMulFrm, IIC_iLoadm,
1362 "ldm${addr:submode}${p}\t$addr, $dsts", "", []>;
1364 def LDM_UPD : AXI4ld<(outs GPR:$wb), (ins addrmode4:$addr, pred:$p,
1365 reglist:$dsts, variable_ops),
1366 IndexModeUpd, LdStMulFrm, IIC_iLoadm,
1367 "ldm${addr:submode}${p}\t$addr!, $dsts",
1368 "$addr.addr = $wb", []>;
1369 } // mayLoad, hasExtraDefRegAllocReq
1371 let mayStore = 1, hasExtraSrcRegAllocReq = 1 in {
1372 def STM : AXI4st<(outs), (ins addrmode4:$addr, pred:$p,
1373 reglist:$srcs, variable_ops),
1374 IndexModeNone, LdStMulFrm, IIC_iStorem,
1375 "stm${addr:submode}${p}\t$addr, $srcs", "", []>;
1377 def STM_UPD : AXI4st<(outs GPR:$wb), (ins addrmode4:$addr, pred:$p,
1378 reglist:$srcs, variable_ops),
1379 IndexModeUpd, LdStMulFrm, IIC_iStorem,
1380 "stm${addr:submode}${p}\t$addr!, $srcs",
1381 "$addr.addr = $wb", []>;
1382 } // mayStore, hasExtraSrcRegAllocReq
1384 //===----------------------------------------------------------------------===//
1385 // Move Instructions.
1388 let neverHasSideEffects = 1 in
1389 def MOVr : AsI1<0b1101, (outs GPR:$dst), (ins GPR:$src), DPFrm, IIC_iMOVr,
1390 "mov", "\t$dst, $src", []>, UnaryDP {
1391 let Inst{11-4} = 0b00000000;
1395 def MOVs : AsI1<0b1101, (outs GPR:$dst), (ins so_reg:$src),
1396 DPSoRegFrm, IIC_iMOVsr,
1397 "mov", "\t$dst, $src", [(set GPR:$dst, so_reg:$src)]>, UnaryDP {
1401 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
1402 def MOVi : AsI1<0b1101, (outs GPR:$dst), (ins so_imm:$src), DPFrm, IIC_iMOVi,
1403 "mov", "\t$dst, $src", [(set GPR:$dst, so_imm:$src)]>, UnaryDP {
1407 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
1408 def MOVi16 : AI1<0b1000, (outs GPR:$dst), (ins i32imm:$src),
1410 "movw", "\t$dst, $src",
1411 [(set GPR:$dst, imm0_65535:$src)]>,
1412 Requires<[IsARM, HasV6T2]>, UnaryDP {
1417 let Constraints = "$src = $dst" in
1418 def MOVTi16 : AI1<0b1010, (outs GPR:$dst), (ins GPR:$src, i32imm:$imm),
1420 "movt", "\t$dst, $imm",
1422 (or (and GPR:$src, 0xffff),
1423 lo16AllZero:$imm))]>, UnaryDP,
1424 Requires<[IsARM, HasV6T2]> {
1429 def : ARMPat<(or GPR:$src, 0xffff0000), (MOVTi16 GPR:$src, 0xffff)>,
1430 Requires<[IsARM, HasV6T2]>;
1432 let Uses = [CPSR] in
1433 def MOVrx : AsI1<0b1101, (outs GPR:$dst), (ins GPR:$src), Pseudo, IIC_iMOVsi,
1434 "mov", "\t$dst, $src, rrx",
1435 [(set GPR:$dst, (ARMrrx GPR:$src))]>, UnaryDP;
1437 // These aren't really mov instructions, but we have to define them this way
1438 // due to flag operands.
1440 let Defs = [CPSR] in {
1441 def MOVsrl_flag : AI1<0b1101, (outs GPR:$dst), (ins GPR:$src), Pseudo,
1442 IIC_iMOVsi, "movs", "\t$dst, $src, lsr #1",
1443 [(set GPR:$dst, (ARMsrl_flag GPR:$src))]>, UnaryDP;
1444 def MOVsra_flag : AI1<0b1101, (outs GPR:$dst), (ins GPR:$src), Pseudo,
1445 IIC_iMOVsi, "movs", "\t$dst, $src, asr #1",
1446 [(set GPR:$dst, (ARMsra_flag GPR:$src))]>, UnaryDP;
1449 //===----------------------------------------------------------------------===//
1450 // Extend Instructions.
1455 defm SXTB : AI_unary_rrot<0b01101010,
1456 "sxtb", UnOpFrag<(sext_inreg node:$Src, i8)>>;
1457 defm SXTH : AI_unary_rrot<0b01101011,
1458 "sxth", UnOpFrag<(sext_inreg node:$Src, i16)>>;
1460 defm SXTAB : AI_bin_rrot<0b01101010,
1461 "sxtab", BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS, i8))>>;
1462 defm SXTAH : AI_bin_rrot<0b01101011,
1463 "sxtah", BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS,i16))>>;
1465 // For disassembly only
1466 defm SXTB16 : AI_unary_rrot_np<0b01101000, "sxtb16">;
1468 // For disassembly only
1469 defm SXTAB16 : AI_bin_rrot_np<0b01101000, "sxtab16">;
1473 let AddedComplexity = 16 in {
1474 defm UXTB : AI_unary_rrot<0b01101110,
1475 "uxtb" , UnOpFrag<(and node:$Src, 0x000000FF)>>;
1476 defm UXTH : AI_unary_rrot<0b01101111,
1477 "uxth" , UnOpFrag<(and node:$Src, 0x0000FFFF)>>;
1478 defm UXTB16 : AI_unary_rrot<0b01101100,
1479 "uxtb16", UnOpFrag<(and node:$Src, 0x00FF00FF)>>;
1481 def : ARMV6Pat<(and (shl GPR:$Src, (i32 8)), 0xFF00FF),
1482 (UXTB16r_rot GPR:$Src, 24)>;
1483 def : ARMV6Pat<(and (srl GPR:$Src, (i32 8)), 0xFF00FF),
1484 (UXTB16r_rot GPR:$Src, 8)>;
1486 defm UXTAB : AI_bin_rrot<0b01101110, "uxtab",
1487 BinOpFrag<(add node:$LHS, (and node:$RHS, 0x00FF))>>;
1488 defm UXTAH : AI_bin_rrot<0b01101111, "uxtah",
1489 BinOpFrag<(add node:$LHS, (and node:$RHS, 0xFFFF))>>;
1492 // This isn't safe in general, the add is two 16-bit units, not a 32-bit add.
1493 // For disassembly only
1494 defm UXTAB16 : AI_bin_rrot_np<0b01101100, "uxtab16">;
1497 def SBFX : I<(outs GPR:$dst),
1498 (ins GPR:$src, imm0_31:$lsb, imm0_31:$width),
1499 AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iALUi,
1500 "sbfx", "\t$dst, $src, $lsb, $width", "", []>,
1501 Requires<[IsARM, HasV6T2]> {
1502 let Inst{27-21} = 0b0111101;
1503 let Inst{6-4} = 0b101;
1506 def UBFX : I<(outs GPR:$dst),
1507 (ins GPR:$src, imm0_31:$lsb, imm0_31:$width),
1508 AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iALUi,
1509 "ubfx", "\t$dst, $src, $lsb, $width", "", []>,
1510 Requires<[IsARM, HasV6T2]> {
1511 let Inst{27-21} = 0b0111111;
1512 let Inst{6-4} = 0b101;
1515 //===----------------------------------------------------------------------===//
1516 // Arithmetic Instructions.
1519 defm ADD : AsI1_bin_irs<0b0100, "add",
1520 BinOpFrag<(add node:$LHS, node:$RHS)>, 1>;
1521 defm SUB : AsI1_bin_irs<0b0010, "sub",
1522 BinOpFrag<(sub node:$LHS, node:$RHS)>>;
1524 // ADD and SUB with 's' bit set.
1525 defm ADDS : AI1_bin_s_irs<0b0100, "adds",
1526 BinOpFrag<(addc node:$LHS, node:$RHS)>, 1>;
1527 defm SUBS : AI1_bin_s_irs<0b0010, "subs",
1528 BinOpFrag<(subc node:$LHS, node:$RHS)>>;
1530 defm ADC : AI1_adde_sube_irs<0b0101, "adc",
1531 BinOpFrag<(adde_dead_carry node:$LHS, node:$RHS)>, 1>;
1532 defm SBC : AI1_adde_sube_irs<0b0110, "sbc",
1533 BinOpFrag<(sube_dead_carry node:$LHS, node:$RHS)>>;
1534 defm ADCS : AI1_adde_sube_s_irs<0b0101, "adcs",
1535 BinOpFrag<(adde_live_carry node:$LHS, node:$RHS)>, 1>;
1536 defm SBCS : AI1_adde_sube_s_irs<0b0110, "sbcs",
1537 BinOpFrag<(sube_live_carry node:$LHS, node:$RHS) >>;
1539 // These don't define reg/reg forms, because they are handled above.
1540 def RSBri : AsI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
1541 IIC_iALUi, "rsb", "\t$dst, $a, $b",
1542 [(set GPR:$dst, (sub so_imm:$b, GPR:$a))]> {
1546 def RSBrs : AsI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
1547 IIC_iALUsr, "rsb", "\t$dst, $a, $b",
1548 [(set GPR:$dst, (sub so_reg:$b, GPR:$a))]> {
1552 // RSB with 's' bit set.
1553 let Defs = [CPSR] in {
1554 def RSBSri : AI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
1555 IIC_iALUi, "rsbs", "\t$dst, $a, $b",
1556 [(set GPR:$dst, (subc so_imm:$b, GPR:$a))]> {
1560 def RSBSrs : AI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
1561 IIC_iALUsr, "rsbs", "\t$dst, $a, $b",
1562 [(set GPR:$dst, (subc so_reg:$b, GPR:$a))]> {
1568 let Uses = [CPSR] in {
1569 def RSCri : AsI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
1570 DPFrm, IIC_iALUi, "rsc", "\t$dst, $a, $b",
1571 [(set GPR:$dst, (sube_dead_carry so_imm:$b, GPR:$a))]>,
1575 def RSCrs : AsI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
1576 DPSoRegFrm, IIC_iALUsr, "rsc", "\t$dst, $a, $b",
1577 [(set GPR:$dst, (sube_dead_carry so_reg:$b, GPR:$a))]>,
1583 // FIXME: Allow these to be predicated.
1584 let Defs = [CPSR], Uses = [CPSR] in {
1585 def RSCSri : AXI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
1586 DPFrm, IIC_iALUi, "rscs\t$dst, $a, $b",
1587 [(set GPR:$dst, (sube_dead_carry so_imm:$b, GPR:$a))]>,
1592 def RSCSrs : AXI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
1593 DPSoRegFrm, IIC_iALUsr, "rscs\t$dst, $a, $b",
1594 [(set GPR:$dst, (sube_dead_carry so_reg:$b, GPR:$a))]>,
1601 // (sub X, imm) gets canonicalized to (add X, -imm). Match this form.
1602 def : ARMPat<(add GPR:$src, so_imm_neg:$imm),
1603 (SUBri GPR:$src, so_imm_neg:$imm)>;
1605 //def : ARMPat<(addc GPR:$src, so_imm_neg:$imm),
1606 // (SUBSri GPR:$src, so_imm_neg:$imm)>;
1607 //def : ARMPat<(adde GPR:$src, so_imm_neg:$imm),
1608 // (SBCri GPR:$src, so_imm_neg:$imm)>;
1610 // Note: These are implemented in C++ code, because they have to generate
1611 // ADD/SUBrs instructions, which use a complex pattern that a xform function
1613 // (mul X, 2^n+1) -> (add (X << n), X)
1614 // (mul X, 2^n-1) -> (rsb X, (X << n))
1616 // ARM Arithmetic Instruction -- for disassembly only
1617 // GPR:$dst = GPR:$a op GPR:$b
1618 class AAI<bits<8> op27_20, bits<4> op7_4, string opc>
1619 : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm, IIC_iALUr,
1620 opc, "\t$dst, $a, $b",
1621 [/* For disassembly only; pattern left blank */]> {
1622 let Inst{27-20} = op27_20;
1623 let Inst{7-4} = op7_4;
1626 // Saturating add/subtract -- for disassembly only
1628 def QADD : AAI<0b00010000, 0b0101, "qadd">;
1629 def QADD16 : AAI<0b01100010, 0b0001, "qadd16">;
1630 def QADD8 : AAI<0b01100010, 0b1001, "qadd8">;
1631 def QASX : AAI<0b01100010, 0b0011, "qasx">;
1632 def QDADD : AAI<0b00010100, 0b0101, "qdadd">;
1633 def QDSUB : AAI<0b00010110, 0b0101, "qdsub">;
1634 def QSAX : AAI<0b01100010, 0b0101, "qsax">;
1635 def QSUB : AAI<0b00010010, 0b0101, "qsub">;
1636 def QSUB16 : AAI<0b01100010, 0b0111, "qsub16">;
1637 def QSUB8 : AAI<0b01100010, 0b1111, "qsub8">;
1638 def UQADD16 : AAI<0b01100110, 0b0001, "uqadd16">;
1639 def UQADD8 : AAI<0b01100110, 0b1001, "uqadd8">;
1640 def UQASX : AAI<0b01100110, 0b0011, "uqasx">;
1641 def UQSAX : AAI<0b01100110, 0b0101, "uqsax">;
1642 def UQSUB16 : AAI<0b01100110, 0b0111, "uqsub16">;
1643 def UQSUB8 : AAI<0b01100110, 0b1111, "uqsub8">;
1645 // Signed/Unsigned add/subtract -- for disassembly only
1647 def SASX : AAI<0b01100001, 0b0011, "sasx">;
1648 def SADD16 : AAI<0b01100001, 0b0001, "sadd16">;
1649 def SADD8 : AAI<0b01100001, 0b1001, "sadd8">;
1650 def SSAX : AAI<0b01100001, 0b0101, "ssax">;
1651 def SSUB16 : AAI<0b01100001, 0b0111, "ssub16">;
1652 def SSUB8 : AAI<0b01100001, 0b1111, "ssub8">;
1653 def UASX : AAI<0b01100101, 0b0011, "uasx">;
1654 def UADD16 : AAI<0b01100101, 0b0001, "uadd16">;
1655 def UADD8 : AAI<0b01100101, 0b1001, "uadd8">;
1656 def USAX : AAI<0b01100101, 0b0101, "usax">;
1657 def USUB16 : AAI<0b01100101, 0b0111, "usub16">;
1658 def USUB8 : AAI<0b01100101, 0b1111, "usub8">;
1660 // Signed/Unsigned halving add/subtract -- for disassembly only
1662 def SHASX : AAI<0b01100011, 0b0011, "shasx">;
1663 def SHADD16 : AAI<0b01100011, 0b0001, "shadd16">;
1664 def SHADD8 : AAI<0b01100011, 0b1001, "shadd8">;
1665 def SHSAX : AAI<0b01100011, 0b0101, "shsax">;
1666 def SHSUB16 : AAI<0b01100011, 0b0111, "shsub16">;
1667 def SHSUB8 : AAI<0b01100011, 0b1111, "shsub8">;
1668 def UHASX : AAI<0b01100111, 0b0011, "uhasx">;
1669 def UHADD16 : AAI<0b01100111, 0b0001, "uhadd16">;
1670 def UHADD8 : AAI<0b01100111, 0b1001, "uhadd8">;
1671 def UHSAX : AAI<0b01100111, 0b0101, "uhsax">;
1672 def UHSUB16 : AAI<0b01100111, 0b0111, "uhsub16">;
1673 def UHSUB8 : AAI<0b01100111, 0b1111, "uhsub8">;
1675 // Unsigned Sum of Absolute Differences [and Accumulate] -- for disassembly only
1677 def USAD8 : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b),
1678 MulFrm /* for convenience */, NoItinerary, "usad8",
1679 "\t$dst, $a, $b", []>,
1680 Requires<[IsARM, HasV6]> {
1681 let Inst{27-20} = 0b01111000;
1682 let Inst{15-12} = 0b1111;
1683 let Inst{7-4} = 0b0001;
1685 def USADA8 : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1686 MulFrm /* for convenience */, NoItinerary, "usada8",
1687 "\t$dst, $a, $b, $acc", []>,
1688 Requires<[IsARM, HasV6]> {
1689 let Inst{27-20} = 0b01111000;
1690 let Inst{7-4} = 0b0001;
1693 // Signed/Unsigned saturate -- for disassembly only
1695 def SSATlsl : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1696 DPFrm, NoItinerary, "ssat", "\t$dst, $bit_pos, $a, lsl $shamt",
1697 [/* For disassembly only; pattern left blank */]> {
1698 let Inst{27-21} = 0b0110101;
1699 let Inst{6-4} = 0b001;
1702 def SSATasr : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1703 DPFrm, NoItinerary, "ssat", "\t$dst, $bit_pos, $a, asr $shamt",
1704 [/* For disassembly only; pattern left blank */]> {
1705 let Inst{27-21} = 0b0110101;
1706 let Inst{6-4} = 0b101;
1709 def SSAT16 : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a), DPFrm,
1710 NoItinerary, "ssat16", "\t$dst, $bit_pos, $a",
1711 [/* For disassembly only; pattern left blank */]> {
1712 let Inst{27-20} = 0b01101010;
1713 let Inst{7-4} = 0b0011;
1716 def USATlsl : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1717 DPFrm, NoItinerary, "usat", "\t$dst, $bit_pos, $a, lsl $shamt",
1718 [/* For disassembly only; pattern left blank */]> {
1719 let Inst{27-21} = 0b0110111;
1720 let Inst{6-4} = 0b001;
1723 def USATasr : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1724 DPFrm, NoItinerary, "usat", "\t$dst, $bit_pos, $a, asr $shamt",
1725 [/* For disassembly only; pattern left blank */]> {
1726 let Inst{27-21} = 0b0110111;
1727 let Inst{6-4} = 0b101;
1730 def USAT16 : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a), DPFrm,
1731 NoItinerary, "usat16", "\t$dst, $bit_pos, $a",
1732 [/* For disassembly only; pattern left blank */]> {
1733 let Inst{27-20} = 0b01101110;
1734 let Inst{7-4} = 0b0011;
1737 //===----------------------------------------------------------------------===//
1738 // Bitwise Instructions.
1741 defm AND : AsI1_bin_irs<0b0000, "and",
1742 BinOpFrag<(and node:$LHS, node:$RHS)>, 1>;
1743 defm ORR : AsI1_bin_irs<0b1100, "orr",
1744 BinOpFrag<(or node:$LHS, node:$RHS)>, 1>;
1745 defm EOR : AsI1_bin_irs<0b0001, "eor",
1746 BinOpFrag<(xor node:$LHS, node:$RHS)>, 1>;
1747 defm BIC : AsI1_bin_irs<0b1110, "bic",
1748 BinOpFrag<(and node:$LHS, (not node:$RHS))>>;
1750 def BFC : I<(outs GPR:$dst), (ins GPR:$src, bf_inv_mask_imm:$imm),
1751 AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iUNAsi,
1752 "bfc", "\t$dst, $imm", "$src = $dst",
1753 [(set GPR:$dst, (and GPR:$src, bf_inv_mask_imm:$imm))]>,
1754 Requires<[IsARM, HasV6T2]> {
1755 let Inst{27-21} = 0b0111110;
1756 let Inst{6-0} = 0b0011111;
1759 // A8.6.18 BFI - Bitfield insert (Encoding A1)
1760 // Added for disassembler with the pattern field purposely left blank.
1761 def BFI : I<(outs GPR:$dst), (ins GPR:$src, bf_inv_mask_imm:$imm),
1762 AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iUNAsi,
1763 "bfi", "\t$dst, $src, $imm", "",
1764 [/* For disassembly only; pattern left blank */]>,
1765 Requires<[IsARM, HasV6T2]> {
1766 let Inst{27-21} = 0b0111110;
1767 let Inst{6-4} = 0b001; // Rn: Inst{3-0} != 15
1770 def MVNr : AsI1<0b1111, (outs GPR:$dst), (ins GPR:$src), DPFrm, IIC_iMOVr,
1771 "mvn", "\t$dst, $src",
1772 [(set GPR:$dst, (not GPR:$src))]>, UnaryDP {
1774 let Inst{11-4} = 0b00000000;
1776 def MVNs : AsI1<0b1111, (outs GPR:$dst), (ins so_reg:$src), DPSoRegFrm,
1777 IIC_iMOVsr, "mvn", "\t$dst, $src",
1778 [(set GPR:$dst, (not so_reg:$src))]>, UnaryDP {
1781 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
1782 def MVNi : AsI1<0b1111, (outs GPR:$dst), (ins so_imm:$imm), DPFrm,
1783 IIC_iMOVi, "mvn", "\t$dst, $imm",
1784 [(set GPR:$dst, so_imm_not:$imm)]>,UnaryDP {
1788 def : ARMPat<(and GPR:$src, so_imm_not:$imm),
1789 (BICri GPR:$src, so_imm_not:$imm)>;
1791 //===----------------------------------------------------------------------===//
1792 // Multiply Instructions.
1795 let isCommutable = 1 in
1796 def MUL : AsMul1I<0b0000000, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1797 IIC_iMUL32, "mul", "\t$dst, $a, $b",
1798 [(set GPR:$dst, (mul GPR:$a, GPR:$b))]>;
1800 def MLA : AsMul1I<0b0000001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1801 IIC_iMAC32, "mla", "\t$dst, $a, $b, $c",
1802 [(set GPR:$dst, (add (mul GPR:$a, GPR:$b), GPR:$c))]>;
1804 def MLS : AMul1I<0b0000011, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1805 IIC_iMAC32, "mls", "\t$dst, $a, $b, $c",
1806 [(set GPR:$dst, (sub GPR:$c, (mul GPR:$a, GPR:$b)))]>,
1807 Requires<[IsARM, HasV6T2]>;
1809 // Extra precision multiplies with low / high results
1810 let neverHasSideEffects = 1 in {
1811 let isCommutable = 1 in {
1812 def SMULL : AsMul1I<0b0000110, (outs GPR:$ldst, GPR:$hdst),
1813 (ins GPR:$a, GPR:$b), IIC_iMUL64,
1814 "smull", "\t$ldst, $hdst, $a, $b", []>;
1816 def UMULL : AsMul1I<0b0000100, (outs GPR:$ldst, GPR:$hdst),
1817 (ins GPR:$a, GPR:$b), IIC_iMUL64,
1818 "umull", "\t$ldst, $hdst, $a, $b", []>;
1821 // Multiply + accumulate
1822 def SMLAL : AsMul1I<0b0000111, (outs GPR:$ldst, GPR:$hdst),
1823 (ins GPR:$a, GPR:$b), IIC_iMAC64,
1824 "smlal", "\t$ldst, $hdst, $a, $b", []>;
1826 def UMLAL : AsMul1I<0b0000101, (outs GPR:$ldst, GPR:$hdst),
1827 (ins GPR:$a, GPR:$b), IIC_iMAC64,
1828 "umlal", "\t$ldst, $hdst, $a, $b", []>;
1830 def UMAAL : AMul1I <0b0000010, (outs GPR:$ldst, GPR:$hdst),
1831 (ins GPR:$a, GPR:$b), IIC_iMAC64,
1832 "umaal", "\t$ldst, $hdst, $a, $b", []>,
1833 Requires<[IsARM, HasV6]>;
1834 } // neverHasSideEffects
1836 // Most significant word multiply
1837 def SMMUL : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1838 IIC_iMUL32, "smmul", "\t$dst, $a, $b",
1839 [(set GPR:$dst, (mulhs GPR:$a, GPR:$b))]>,
1840 Requires<[IsARM, HasV6]> {
1841 let Inst{7-4} = 0b0001;
1842 let Inst{15-12} = 0b1111;
1845 def SMMULR : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1846 IIC_iMUL32, "smmulr", "\t$dst, $a, $b",
1847 [/* For disassembly only; pattern left blank */]>,
1848 Requires<[IsARM, HasV6]> {
1849 let Inst{7-4} = 0b0011; // R = 1
1850 let Inst{15-12} = 0b1111;
1853 def SMMLA : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1854 IIC_iMAC32, "smmla", "\t$dst, $a, $b, $c",
1855 [(set GPR:$dst, (add (mulhs GPR:$a, GPR:$b), GPR:$c))]>,
1856 Requires<[IsARM, HasV6]> {
1857 let Inst{7-4} = 0b0001;
1860 def SMMLAR : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1861 IIC_iMAC32, "smmlar", "\t$dst, $a, $b, $c",
1862 [/* For disassembly only; pattern left blank */]>,
1863 Requires<[IsARM, HasV6]> {
1864 let Inst{7-4} = 0b0011; // R = 1
1867 def SMMLS : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1868 IIC_iMAC32, "smmls", "\t$dst, $a, $b, $c",
1869 [(set GPR:$dst, (sub GPR:$c, (mulhs GPR:$a, GPR:$b)))]>,
1870 Requires<[IsARM, HasV6]> {
1871 let Inst{7-4} = 0b1101;
1874 def SMMLSR : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1875 IIC_iMAC32, "smmlsr", "\t$dst, $a, $b, $c",
1876 [/* For disassembly only; pattern left blank */]>,
1877 Requires<[IsARM, HasV6]> {
1878 let Inst{7-4} = 0b1111; // R = 1
1881 multiclass AI_smul<string opc, PatFrag opnode> {
1882 def BB : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1883 IIC_iMUL32, !strconcat(opc, "bb"), "\t$dst, $a, $b",
1884 [(set GPR:$dst, (opnode (sext_inreg GPR:$a, i16),
1885 (sext_inreg GPR:$b, i16)))]>,
1886 Requires<[IsARM, HasV5TE]> {
1891 def BT : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1892 IIC_iMUL32, !strconcat(opc, "bt"), "\t$dst, $a, $b",
1893 [(set GPR:$dst, (opnode (sext_inreg GPR:$a, i16),
1894 (sra GPR:$b, (i32 16))))]>,
1895 Requires<[IsARM, HasV5TE]> {
1900 def TB : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1901 IIC_iMUL32, !strconcat(opc, "tb"), "\t$dst, $a, $b",
1902 [(set GPR:$dst, (opnode (sra GPR:$a, (i32 16)),
1903 (sext_inreg GPR:$b, i16)))]>,
1904 Requires<[IsARM, HasV5TE]> {
1909 def TT : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1910 IIC_iMUL32, !strconcat(opc, "tt"), "\t$dst, $a, $b",
1911 [(set GPR:$dst, (opnode (sra GPR:$a, (i32 16)),
1912 (sra GPR:$b, (i32 16))))]>,
1913 Requires<[IsARM, HasV5TE]> {
1918 def WB : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1919 IIC_iMUL16, !strconcat(opc, "wb"), "\t$dst, $a, $b",
1920 [(set GPR:$dst, (sra (opnode GPR:$a,
1921 (sext_inreg GPR:$b, i16)), (i32 16)))]>,
1922 Requires<[IsARM, HasV5TE]> {
1927 def WT : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1928 IIC_iMUL16, !strconcat(opc, "wt"), "\t$dst, $a, $b",
1929 [(set GPR:$dst, (sra (opnode GPR:$a,
1930 (sra GPR:$b, (i32 16))), (i32 16)))]>,
1931 Requires<[IsARM, HasV5TE]> {
1938 multiclass AI_smla<string opc, PatFrag opnode> {
1939 def BB : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1940 IIC_iMAC16, !strconcat(opc, "bb"), "\t$dst, $a, $b, $acc",
1941 [(set GPR:$dst, (add GPR:$acc,
1942 (opnode (sext_inreg GPR:$a, i16),
1943 (sext_inreg GPR:$b, i16))))]>,
1944 Requires<[IsARM, HasV5TE]> {
1949 def BT : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1950 IIC_iMAC16, !strconcat(opc, "bt"), "\t$dst, $a, $b, $acc",
1951 [(set GPR:$dst, (add GPR:$acc, (opnode (sext_inreg GPR:$a, i16),
1952 (sra GPR:$b, (i32 16)))))]>,
1953 Requires<[IsARM, HasV5TE]> {
1958 def TB : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1959 IIC_iMAC16, !strconcat(opc, "tb"), "\t$dst, $a, $b, $acc",
1960 [(set GPR:$dst, (add GPR:$acc, (opnode (sra GPR:$a, (i32 16)),
1961 (sext_inreg GPR:$b, i16))))]>,
1962 Requires<[IsARM, HasV5TE]> {
1967 def TT : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1968 IIC_iMAC16, !strconcat(opc, "tt"), "\t$dst, $a, $b, $acc",
1969 [(set GPR:$dst, (add GPR:$acc, (opnode (sra GPR:$a, (i32 16)),
1970 (sra GPR:$b, (i32 16)))))]>,
1971 Requires<[IsARM, HasV5TE]> {
1976 def WB : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1977 IIC_iMAC16, !strconcat(opc, "wb"), "\t$dst, $a, $b, $acc",
1978 [(set GPR:$dst, (add GPR:$acc, (sra (opnode GPR:$a,
1979 (sext_inreg GPR:$b, i16)), (i32 16))))]>,
1980 Requires<[IsARM, HasV5TE]> {
1985 def WT : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1986 IIC_iMAC16, !strconcat(opc, "wt"), "\t$dst, $a, $b, $acc",
1987 [(set GPR:$dst, (add GPR:$acc, (sra (opnode GPR:$a,
1988 (sra GPR:$b, (i32 16))), (i32 16))))]>,
1989 Requires<[IsARM, HasV5TE]> {
1995 defm SMUL : AI_smul<"smul", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
1996 defm SMLA : AI_smla<"smla", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
1998 // Halfword multiply accumulate long: SMLAL<x><y> -- for disassembly only
1999 def SMLALBB : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2000 IIC_iMAC64, "smlalbb", "\t$ldst, $hdst, $a, $b",
2001 [/* For disassembly only; pattern left blank */]>,
2002 Requires<[IsARM, HasV5TE]> {
2007 def SMLALBT : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2008 IIC_iMAC64, "smlalbt", "\t$ldst, $hdst, $a, $b",
2009 [/* For disassembly only; pattern left blank */]>,
2010 Requires<[IsARM, HasV5TE]> {
2015 def SMLALTB : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2016 IIC_iMAC64, "smlaltb", "\t$ldst, $hdst, $a, $b",
2017 [/* For disassembly only; pattern left blank */]>,
2018 Requires<[IsARM, HasV5TE]> {
2023 def SMLALTT : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2024 IIC_iMAC64, "smlaltt", "\t$ldst, $hdst, $a, $b",
2025 [/* For disassembly only; pattern left blank */]>,
2026 Requires<[IsARM, HasV5TE]> {
2031 // Helper class for AI_smld -- for disassembly only
2032 class AMulDualI<bit long, bit sub, bit swap, dag oops, dag iops,
2033 InstrItinClass itin, string opc, string asm>
2034 : AI<oops, iops, MulFrm, itin, opc, asm, []>, Requires<[IsARM, HasV6]> {
2039 let Inst{21-20} = 0b00;
2040 let Inst{22} = long;
2041 let Inst{27-23} = 0b01110;
2044 multiclass AI_smld<bit sub, string opc> {
2046 def D : AMulDualI<0, sub, 0, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2047 NoItinerary, !strconcat(opc, "d"), "\t$dst, $a, $b, $acc">;
2049 def DX : AMulDualI<0, sub, 1, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2050 NoItinerary, !strconcat(opc, "dx"), "\t$dst, $a, $b, $acc">;
2052 def LD : AMulDualI<1, sub, 0, (outs GPR:$ldst,GPR:$hdst), (ins GPR:$a,GPR:$b),
2053 NoItinerary, !strconcat(opc, "ld"), "\t$ldst, $hdst, $a, $b">;
2055 def LDX : AMulDualI<1, sub, 1, (outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2056 NoItinerary, !strconcat(opc, "ldx"),"\t$ldst, $hdst, $a, $b">;
2060 defm SMLA : AI_smld<0, "smla">;
2061 defm SMLS : AI_smld<1, "smls">;
2063 multiclass AI_sdml<bit sub, string opc> {
2065 def D : AMulDualI<0, sub, 0, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2066 NoItinerary, !strconcat(opc, "d"), "\t$dst, $a, $b"> {
2067 let Inst{15-12} = 0b1111;
2070 def DX : AMulDualI<0, sub, 1, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2071 NoItinerary, !strconcat(opc, "dx"), "\t$dst, $a, $b"> {
2072 let Inst{15-12} = 0b1111;
2077 defm SMUA : AI_sdml<0, "smua">;
2078 defm SMUS : AI_sdml<1, "smus">;
2080 //===----------------------------------------------------------------------===//
2081 // Misc. Arithmetic Instructions.
2084 def CLZ : AMiscA1I<0b000010110, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2085 "clz", "\t$dst, $src",
2086 [(set GPR:$dst, (ctlz GPR:$src))]>, Requires<[IsARM, HasV5T]> {
2087 let Inst{7-4} = 0b0001;
2088 let Inst{11-8} = 0b1111;
2089 let Inst{19-16} = 0b1111;
2092 def RBIT : AMiscA1I<0b01101111, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2093 "rbit", "\t$dst, $src",
2094 [(set GPR:$dst, (ARMrbit GPR:$src))]>,
2095 Requires<[IsARM, HasV6T2]> {
2096 let Inst{7-4} = 0b0011;
2097 let Inst{11-8} = 0b1111;
2098 let Inst{19-16} = 0b1111;
2101 def REV : AMiscA1I<0b01101011, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2102 "rev", "\t$dst, $src",
2103 [(set GPR:$dst, (bswap GPR:$src))]>, Requires<[IsARM, HasV6]> {
2104 let Inst{7-4} = 0b0011;
2105 let Inst{11-8} = 0b1111;
2106 let Inst{19-16} = 0b1111;
2109 def REV16 : AMiscA1I<0b01101011, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2110 "rev16", "\t$dst, $src",
2112 (or (and (srl GPR:$src, (i32 8)), 0xFF),
2113 (or (and (shl GPR:$src, (i32 8)), 0xFF00),
2114 (or (and (srl GPR:$src, (i32 8)), 0xFF0000),
2115 (and (shl GPR:$src, (i32 8)), 0xFF000000)))))]>,
2116 Requires<[IsARM, HasV6]> {
2117 let Inst{7-4} = 0b1011;
2118 let Inst{11-8} = 0b1111;
2119 let Inst{19-16} = 0b1111;
2122 def REVSH : AMiscA1I<0b01101111, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2123 "revsh", "\t$dst, $src",
2126 (or (srl (and GPR:$src, 0xFF00), (i32 8)),
2127 (shl GPR:$src, (i32 8))), i16))]>,
2128 Requires<[IsARM, HasV6]> {
2129 let Inst{7-4} = 0b1011;
2130 let Inst{11-8} = 0b1111;
2131 let Inst{19-16} = 0b1111;
2134 def PKHBT : AMiscA1I<0b01101000, (outs GPR:$dst),
2135 (ins GPR:$src1, GPR:$src2, i32imm:$shamt),
2136 IIC_iALUsi, "pkhbt", "\t$dst, $src1, $src2, lsl $shamt",
2137 [(set GPR:$dst, (or (and GPR:$src1, 0xFFFF),
2138 (and (shl GPR:$src2, (i32 imm:$shamt)),
2140 Requires<[IsARM, HasV6]> {
2141 let Inst{6-4} = 0b001;
2144 // Alternate cases for PKHBT where identities eliminate some nodes.
2145 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF), (and GPR:$src2, 0xFFFF0000)),
2146 (PKHBT GPR:$src1, GPR:$src2, 0)>;
2147 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF), (shl GPR:$src2, imm16_31:$shamt)),
2148 (PKHBT GPR:$src1, GPR:$src2, imm16_31:$shamt)>;
2151 def PKHTB : AMiscA1I<0b01101000, (outs GPR:$dst),
2152 (ins GPR:$src1, GPR:$src2, i32imm:$shamt),
2153 IIC_iALUsi, "pkhtb", "\t$dst, $src1, $src2, asr $shamt",
2154 [(set GPR:$dst, (or (and GPR:$src1, 0xFFFF0000),
2155 (and (sra GPR:$src2, imm16_31:$shamt),
2156 0xFFFF)))]>, Requires<[IsARM, HasV6]> {
2157 let Inst{6-4} = 0b101;
2160 // Alternate cases for PKHTB where identities eliminate some nodes. Note that
2161 // a shift amount of 0 is *not legal* here, it is PKHBT instead.
2162 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF0000), (srl GPR:$src2, (i32 16))),
2163 (PKHTB GPR:$src1, GPR:$src2, 16)>;
2164 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF0000),
2165 (and (srl GPR:$src2, imm1_15:$shamt), 0xFFFF)),
2166 (PKHTB GPR:$src1, GPR:$src2, imm1_15:$shamt)>;
2168 //===----------------------------------------------------------------------===//
2169 // Comparison Instructions...
2172 defm CMP : AI1_cmp_irs<0b1010, "cmp",
2173 BinOpFrag<(ARMcmp node:$LHS, node:$RHS)>>;
2174 //FIXME: Disable CMN, as CCodes are backwards from compare expectations
2175 // Compare-to-zero still works out, just not the relationals
2176 //defm CMN : AI1_cmp_irs<0b1011, "cmn",
2177 // BinOpFrag<(ARMcmp node:$LHS,(ineg node:$RHS))>>;
2179 // Note that TST/TEQ don't set all the same flags that CMP does!
2180 defm TST : AI1_cmp_irs<0b1000, "tst",
2181 BinOpFrag<(ARMcmpZ (and node:$LHS, node:$RHS), 0)>, 1>;
2182 defm TEQ : AI1_cmp_irs<0b1001, "teq",
2183 BinOpFrag<(ARMcmpZ (xor node:$LHS, node:$RHS), 0)>, 1>;
2185 defm CMPz : AI1_cmp_irs<0b1010, "cmp",
2186 BinOpFrag<(ARMcmpZ node:$LHS, node:$RHS)>>;
2187 defm CMNz : AI1_cmp_irs<0b1011, "cmn",
2188 BinOpFrag<(ARMcmpZ node:$LHS,(ineg node:$RHS))>>;
2190 //def : ARMPat<(ARMcmp GPR:$src, so_imm_neg:$imm),
2191 // (CMNri GPR:$src, so_imm_neg:$imm)>;
2193 def : ARMPat<(ARMcmpZ GPR:$src, so_imm_neg:$imm),
2194 (CMNzri GPR:$src, so_imm_neg:$imm)>;
2197 // Conditional moves
2198 // FIXME: should be able to write a pattern for ARMcmov, but can't use
2199 // a two-value operand where a dag node expects two operands. :(
2200 def MOVCCr : AI1<0b1101, (outs GPR:$dst), (ins GPR:$false, GPR:$true), DPFrm,
2201 IIC_iCMOVr, "mov", "\t$dst, $true",
2202 [/*(set GPR:$dst, (ARMcmov GPR:$false, GPR:$true, imm:$cc, CCR:$ccr))*/]>,
2203 RegConstraint<"$false = $dst">, UnaryDP {
2204 let Inst{11-4} = 0b00000000;
2208 def MOVCCs : AI1<0b1101, (outs GPR:$dst),
2209 (ins GPR:$false, so_reg:$true), DPSoRegFrm, IIC_iCMOVsr,
2210 "mov", "\t$dst, $true",
2211 [/*(set GPR:$dst, (ARMcmov GPR:$false, so_reg:$true, imm:$cc, CCR:$ccr))*/]>,
2212 RegConstraint<"$false = $dst">, UnaryDP {
2216 def MOVCCi : AI1<0b1101, (outs GPR:$dst),
2217 (ins GPR:$false, so_imm:$true), DPFrm, IIC_iCMOVi,
2218 "mov", "\t$dst, $true",
2219 [/*(set GPR:$dst, (ARMcmov GPR:$false, so_imm:$true, imm:$cc, CCR:$ccr))*/]>,
2220 RegConstraint<"$false = $dst">, UnaryDP {
2224 //===----------------------------------------------------------------------===//
2225 // Atomic operations intrinsics
2228 // memory barriers protect the atomic sequences
2229 let hasSideEffects = 1 in {
2230 def Int_MemBarrierV7 : AInoP<(outs), (ins),
2231 Pseudo, NoItinerary,
2233 [(ARMMemBarrierV7)]>,
2234 Requires<[IsARM, HasV7]> {
2235 let Inst{31-4} = 0xf57ff05;
2236 // FIXME: add support for options other than a full system DMB
2237 // See DMB disassembly-only variants below.
2238 let Inst{3-0} = 0b1111;
2241 def Int_SyncBarrierV7 : AInoP<(outs), (ins),
2242 Pseudo, NoItinerary,
2244 [(ARMSyncBarrierV7)]>,
2245 Requires<[IsARM, HasV7]> {
2246 let Inst{31-4} = 0xf57ff04;
2247 // FIXME: add support for options other than a full system DSB
2248 // See DSB disassembly-only variants below.
2249 let Inst{3-0} = 0b1111;
2252 def Int_MemBarrierV6 : AInoP<(outs), (ins GPR:$zero),
2253 Pseudo, NoItinerary,
2254 "mcr", "\tp15, 0, $zero, c7, c10, 5",
2255 [(ARMMemBarrierV6 GPR:$zero)]>,
2256 Requires<[IsARM, HasV6]> {
2257 // FIXME: add support for options other than a full system DMB
2258 // FIXME: add encoding
2261 def Int_SyncBarrierV6 : AInoP<(outs), (ins GPR:$zero),
2262 Pseudo, NoItinerary,
2263 "mcr", "\tp15, 0, $zero, c7, c10, 4",
2264 [(ARMSyncBarrierV6 GPR:$zero)]>,
2265 Requires<[IsARM, HasV6]> {
2266 // FIXME: add support for options other than a full system DSB
2267 // FIXME: add encoding
2271 // Helper class for multiclass MemB -- for disassembly only
2272 class AMBI<string opc, string asm>
2273 : AInoP<(outs), (ins), MiscFrm, NoItinerary, opc, asm,
2274 [/* For disassembly only; pattern left blank */]>,
2275 Requires<[IsARM, HasV7]> {
2276 let Inst{31-20} = 0xf57;
2279 multiclass MemB<bits<4> op7_4, string opc> {
2281 def st : AMBI<opc, "\tst"> {
2282 let Inst{7-4} = op7_4;
2283 let Inst{3-0} = 0b1110;
2286 def ish : AMBI<opc, "\tish"> {
2287 let Inst{7-4} = op7_4;
2288 let Inst{3-0} = 0b1011;
2291 def ishst : AMBI<opc, "\tishst"> {
2292 let Inst{7-4} = op7_4;
2293 let Inst{3-0} = 0b1010;
2296 def nsh : AMBI<opc, "\tnsh"> {
2297 let Inst{7-4} = op7_4;
2298 let Inst{3-0} = 0b0111;
2301 def nshst : AMBI<opc, "\tnshst"> {
2302 let Inst{7-4} = op7_4;
2303 let Inst{3-0} = 0b0110;
2306 def osh : AMBI<opc, "\tosh"> {
2307 let Inst{7-4} = op7_4;
2308 let Inst{3-0} = 0b0011;
2311 def oshst : AMBI<opc, "\toshst"> {
2312 let Inst{7-4} = op7_4;
2313 let Inst{3-0} = 0b0010;
2317 // These DMB variants are for disassembly only.
2318 defm DMB : MemB<0b0101, "dmb">;
2320 // These DSB variants are for disassembly only.
2321 defm DSB : MemB<0b0100, "dsb">;
2323 // ISB has only full system option -- for disassembly only
2324 def ISBsy : AMBI<"isb", ""> {
2325 let Inst{7-4} = 0b0110;
2326 let Inst{3-0} = 0b1111;
2329 let usesCustomInserter = 1 in {
2330 let Uses = [CPSR] in {
2331 def ATOMIC_LOAD_ADD_I8 : PseudoInst<
2332 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2333 "${:comment} ATOMIC_LOAD_ADD_I8 PSEUDO!",
2334 [(set GPR:$dst, (atomic_load_add_8 GPR:$ptr, GPR:$incr))]>;
2335 def ATOMIC_LOAD_SUB_I8 : PseudoInst<
2336 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2337 "${:comment} ATOMIC_LOAD_SUB_I8 PSEUDO!",
2338 [(set GPR:$dst, (atomic_load_sub_8 GPR:$ptr, GPR:$incr))]>;
2339 def ATOMIC_LOAD_AND_I8 : PseudoInst<
2340 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2341 "${:comment} ATOMIC_LOAD_AND_I8 PSEUDO!",
2342 [(set GPR:$dst, (atomic_load_and_8 GPR:$ptr, GPR:$incr))]>;
2343 def ATOMIC_LOAD_OR_I8 : PseudoInst<
2344 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2345 "${:comment} ATOMIC_LOAD_OR_I8 PSEUDO!",
2346 [(set GPR:$dst, (atomic_load_or_8 GPR:$ptr, GPR:$incr))]>;
2347 def ATOMIC_LOAD_XOR_I8 : PseudoInst<
2348 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2349 "${:comment} ATOMIC_LOAD_XOR_I8 PSEUDO!",
2350 [(set GPR:$dst, (atomic_load_xor_8 GPR:$ptr, GPR:$incr))]>;
2351 def ATOMIC_LOAD_NAND_I8 : PseudoInst<
2352 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2353 "${:comment} ATOMIC_LOAD_NAND_I8 PSEUDO!",
2354 [(set GPR:$dst, (atomic_load_nand_8 GPR:$ptr, GPR:$incr))]>;
2355 def ATOMIC_LOAD_ADD_I16 : PseudoInst<
2356 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2357 "${:comment} ATOMIC_LOAD_ADD_I16 PSEUDO!",
2358 [(set GPR:$dst, (atomic_load_add_16 GPR:$ptr, GPR:$incr))]>;
2359 def ATOMIC_LOAD_SUB_I16 : PseudoInst<
2360 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2361 "${:comment} ATOMIC_LOAD_SUB_I16 PSEUDO!",
2362 [(set GPR:$dst, (atomic_load_sub_16 GPR:$ptr, GPR:$incr))]>;
2363 def ATOMIC_LOAD_AND_I16 : PseudoInst<
2364 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2365 "${:comment} ATOMIC_LOAD_AND_I16 PSEUDO!",
2366 [(set GPR:$dst, (atomic_load_and_16 GPR:$ptr, GPR:$incr))]>;
2367 def ATOMIC_LOAD_OR_I16 : PseudoInst<
2368 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2369 "${:comment} ATOMIC_LOAD_OR_I16 PSEUDO!",
2370 [(set GPR:$dst, (atomic_load_or_16 GPR:$ptr, GPR:$incr))]>;
2371 def ATOMIC_LOAD_XOR_I16 : PseudoInst<
2372 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2373 "${:comment} ATOMIC_LOAD_XOR_I16 PSEUDO!",
2374 [(set GPR:$dst, (atomic_load_xor_16 GPR:$ptr, GPR:$incr))]>;
2375 def ATOMIC_LOAD_NAND_I16 : PseudoInst<
2376 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2377 "${:comment} ATOMIC_LOAD_NAND_I16 PSEUDO!",
2378 [(set GPR:$dst, (atomic_load_nand_16 GPR:$ptr, GPR:$incr))]>;
2379 def ATOMIC_LOAD_ADD_I32 : PseudoInst<
2380 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2381 "${:comment} ATOMIC_LOAD_ADD_I32 PSEUDO!",
2382 [(set GPR:$dst, (atomic_load_add_32 GPR:$ptr, GPR:$incr))]>;
2383 def ATOMIC_LOAD_SUB_I32 : PseudoInst<
2384 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2385 "${:comment} ATOMIC_LOAD_SUB_I32 PSEUDO!",
2386 [(set GPR:$dst, (atomic_load_sub_32 GPR:$ptr, GPR:$incr))]>;
2387 def ATOMIC_LOAD_AND_I32 : PseudoInst<
2388 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2389 "${:comment} ATOMIC_LOAD_AND_I32 PSEUDO!",
2390 [(set GPR:$dst, (atomic_load_and_32 GPR:$ptr, GPR:$incr))]>;
2391 def ATOMIC_LOAD_OR_I32 : PseudoInst<
2392 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2393 "${:comment} ATOMIC_LOAD_OR_I32 PSEUDO!",
2394 [(set GPR:$dst, (atomic_load_or_32 GPR:$ptr, GPR:$incr))]>;
2395 def ATOMIC_LOAD_XOR_I32 : PseudoInst<
2396 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2397 "${:comment} ATOMIC_LOAD_XOR_I32 PSEUDO!",
2398 [(set GPR:$dst, (atomic_load_xor_32 GPR:$ptr, GPR:$incr))]>;
2399 def ATOMIC_LOAD_NAND_I32 : PseudoInst<
2400 (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2401 "${:comment} ATOMIC_LOAD_NAND_I32 PSEUDO!",
2402 [(set GPR:$dst, (atomic_load_nand_32 GPR:$ptr, GPR:$incr))]>;
2404 def ATOMIC_SWAP_I8 : PseudoInst<
2405 (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary,
2406 "${:comment} ATOMIC_SWAP_I8 PSEUDO!",
2407 [(set GPR:$dst, (atomic_swap_8 GPR:$ptr, GPR:$new))]>;
2408 def ATOMIC_SWAP_I16 : PseudoInst<
2409 (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary,
2410 "${:comment} ATOMIC_SWAP_I16 PSEUDO!",
2411 [(set GPR:$dst, (atomic_swap_16 GPR:$ptr, GPR:$new))]>;
2412 def ATOMIC_SWAP_I32 : PseudoInst<
2413 (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary,
2414 "${:comment} ATOMIC_SWAP_I32 PSEUDO!",
2415 [(set GPR:$dst, (atomic_swap_32 GPR:$ptr, GPR:$new))]>;
2417 def ATOMIC_CMP_SWAP_I8 : PseudoInst<
2418 (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary,
2419 "${:comment} ATOMIC_CMP_SWAP_I8 PSEUDO!",
2420 [(set GPR:$dst, (atomic_cmp_swap_8 GPR:$ptr, GPR:$old, GPR:$new))]>;
2421 def ATOMIC_CMP_SWAP_I16 : PseudoInst<
2422 (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary,
2423 "${:comment} ATOMIC_CMP_SWAP_I16 PSEUDO!",
2424 [(set GPR:$dst, (atomic_cmp_swap_16 GPR:$ptr, GPR:$old, GPR:$new))]>;
2425 def ATOMIC_CMP_SWAP_I32 : PseudoInst<
2426 (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary,
2427 "${:comment} ATOMIC_CMP_SWAP_I32 PSEUDO!",
2428 [(set GPR:$dst, (atomic_cmp_swap_32 GPR:$ptr, GPR:$old, GPR:$new))]>;
2432 let mayLoad = 1 in {
2433 def LDREXB : AIldrex<0b10, (outs GPR:$dest), (ins GPR:$ptr), NoItinerary,
2434 "ldrexb", "\t$dest, [$ptr]",
2436 def LDREXH : AIldrex<0b11, (outs GPR:$dest), (ins GPR:$ptr), NoItinerary,
2437 "ldrexh", "\t$dest, [$ptr]",
2439 def LDREX : AIldrex<0b00, (outs GPR:$dest), (ins GPR:$ptr), NoItinerary,
2440 "ldrex", "\t$dest, [$ptr]",
2442 def LDREXD : AIldrex<0b01, (outs GPR:$dest, GPR:$dest2), (ins GPR:$ptr),
2444 "ldrexd", "\t$dest, $dest2, [$ptr]",
2448 let mayStore = 1, Constraints = "@earlyclobber $success" in {
2449 def STREXB : AIstrex<0b10, (outs GPR:$success), (ins GPR:$src, GPR:$ptr),
2451 "strexb", "\t$success, $src, [$ptr]",
2453 def STREXH : AIstrex<0b11, (outs GPR:$success), (ins GPR:$src, GPR:$ptr),
2455 "strexh", "\t$success, $src, [$ptr]",
2457 def STREX : AIstrex<0b00, (outs GPR:$success), (ins GPR:$src, GPR:$ptr),
2459 "strex", "\t$success, $src, [$ptr]",
2461 def STREXD : AIstrex<0b01, (outs GPR:$success),
2462 (ins GPR:$src, GPR:$src2, GPR:$ptr),
2464 "strexd", "\t$success, $src, $src2, [$ptr]",
2468 // Clear-Exclusive is for disassembly only.
2469 def CLREX : AXI<(outs), (ins), MiscFrm, NoItinerary, "clrex",
2470 [/* For disassembly only; pattern left blank */]>,
2471 Requires<[IsARM, HasV7]> {
2472 let Inst{31-20} = 0xf57;
2473 let Inst{7-4} = 0b0001;
2476 // SWP/SWPB are deprecated in V6/V7 and for disassembly only.
2477 let mayLoad = 1 in {
2478 def SWP : AI<(outs GPR:$dst), (ins GPR:$src, GPR:$ptr), LdStExFrm, NoItinerary,
2479 "swp", "\t$dst, $src, [$ptr]",
2480 [/* For disassembly only; pattern left blank */]> {
2481 let Inst{27-23} = 0b00010;
2482 let Inst{22} = 0; // B = 0
2483 let Inst{21-20} = 0b00;
2484 let Inst{7-4} = 0b1001;
2487 def SWPB : AI<(outs GPR:$dst), (ins GPR:$src, GPR:$ptr), LdStExFrm, NoItinerary,
2488 "swpb", "\t$dst, $src, [$ptr]",
2489 [/* For disassembly only; pattern left blank */]> {
2490 let Inst{27-23} = 0b00010;
2491 let Inst{22} = 1; // B = 1
2492 let Inst{21-20} = 0b00;
2493 let Inst{7-4} = 0b1001;
2497 //===----------------------------------------------------------------------===//
2501 // __aeabi_read_tp preserves the registers r1-r3.
2503 Defs = [R0, R12, LR, CPSR] in {
2504 def TPsoft : ABXI<0b1011, (outs), (ins), IIC_Br,
2505 "bl\t__aeabi_read_tp",
2506 [(set R0, ARMthread_pointer)]>;
2509 //===----------------------------------------------------------------------===//
2510 // SJLJ Exception handling intrinsics
2511 // eh_sjlj_setjmp() is an instruction sequence to store the return
2512 // address and save #0 in R0 for the non-longjmp case.
2513 // Since by its nature we may be coming from some other function to get
2514 // here, and we're using the stack frame for the containing function to
2515 // save/restore registers, we can't keep anything live in regs across
2516 // the eh_sjlj_setjmp(), else it will almost certainly have been tromped upon
2517 // when we get here from a longjmp(). We force everthing out of registers
2518 // except for our own input by listing the relevant registers in Defs. By
2519 // doing so, we also cause the prologue/epilogue code to actively preserve
2520 // all of the callee-saved resgisters, which is exactly what we want.
2521 // A constant value is passed in $val, and we use the location as a scratch.
2523 [ R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, LR, D0,
2524 D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15,
2525 D16, D17, D18, D19, D20, D21, D22, D23, D24, D25, D26, D27, D28, D29, D30,
2527 def Int_eh_sjlj_setjmp : XI<(outs), (ins GPR:$src, GPR:$val),
2528 AddrModeNone, SizeSpecial, IndexModeNone,
2529 Pseudo, NoItinerary,
2530 "str\tsp, [$src, #+8] @ eh_setjmp begin\n\t"
2531 "add\t$val, pc, #8\n\t"
2532 "str\t$val, [$src, #+4]\n\t"
2534 "add\tpc, pc, #0\n\t"
2535 "mov\tr0, #1 @ eh_setjmp end", "",
2536 [(set R0, (ARMeh_sjlj_setjmp GPR:$src, GPR:$val))]>;
2539 //===----------------------------------------------------------------------===//
2540 // Non-Instruction Patterns
2543 // Large immediate handling.
2545 // Two piece so_imms.
2546 let isReMaterializable = 1 in
2547 def MOVi2pieces : AI1x2<(outs GPR:$dst), (ins so_imm2part:$src),
2549 "mov", "\t$dst, $src",
2550 [(set GPR:$dst, so_imm2part:$src)]>,
2551 Requires<[IsARM, NoV6T2]>;
2553 def : ARMPat<(or GPR:$LHS, so_imm2part:$RHS),
2554 (ORRri (ORRri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
2555 (so_imm2part_2 imm:$RHS))>;
2556 def : ARMPat<(xor GPR:$LHS, so_imm2part:$RHS),
2557 (EORri (EORri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
2558 (so_imm2part_2 imm:$RHS))>;
2559 def : ARMPat<(add GPR:$LHS, so_imm2part:$RHS),
2560 (ADDri (ADDri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
2561 (so_imm2part_2 imm:$RHS))>;
2562 def : ARMPat<(add GPR:$LHS, so_neg_imm2part:$RHS),
2563 (SUBri (SUBri GPR:$LHS, (so_neg_imm2part_1 imm:$RHS)),
2564 (so_neg_imm2part_2 imm:$RHS))>;
2566 // 32-bit immediate using movw + movt.
2567 // This is a single pseudo instruction, the benefit is that it can be remat'd
2568 // as a single unit instead of having to handle reg inputs.
2569 // FIXME: Remove this when we can do generalized remat.
2570 let isReMaterializable = 1 in
2571 def MOVi32imm : AI1x2<(outs GPR:$dst), (ins i32imm:$src), Pseudo, IIC_iMOVi,
2572 "movw", "\t$dst, ${src:lo16}\n\tmovt${p}\t$dst, ${src:hi16}",
2573 [(set GPR:$dst, (i32 imm:$src))]>,
2574 Requires<[IsARM, HasV6T2]>;
2576 // ConstantPool, GlobalAddress, and JumpTable
2577 def : ARMPat<(ARMWrapper tglobaladdr :$dst), (LEApcrel tglobaladdr :$dst)>,
2578 Requires<[IsARM, DontUseMovt]>;
2579 def : ARMPat<(ARMWrapper tconstpool :$dst), (LEApcrel tconstpool :$dst)>;
2580 def : ARMPat<(ARMWrapper tglobaladdr :$dst), (MOVi32imm tglobaladdr :$dst)>,
2581 Requires<[IsARM, UseMovt]>;
2582 def : ARMPat<(ARMWrapperJT tjumptable:$dst, imm:$id),
2583 (LEApcrelJT tjumptable:$dst, imm:$id)>;
2585 // TODO: add,sub,and, 3-instr forms?
2589 def : ARMPat<(ARMcall texternalsym:$func), (BL texternalsym:$func)>,
2590 Requires<[IsARM, IsNotDarwin]>;
2591 def : ARMPat<(ARMcall texternalsym:$func), (BLr9 texternalsym:$func)>,
2592 Requires<[IsARM, IsDarwin]>;
2594 // zextload i1 -> zextload i8
2595 def : ARMPat<(zextloadi1 addrmode2:$addr), (LDRB addrmode2:$addr)>;
2597 // extload -> zextload
2598 def : ARMPat<(extloadi1 addrmode2:$addr), (LDRB addrmode2:$addr)>;
2599 def : ARMPat<(extloadi8 addrmode2:$addr), (LDRB addrmode2:$addr)>;
2600 def : ARMPat<(extloadi16 addrmode3:$addr), (LDRH addrmode3:$addr)>;
2602 def : ARMPat<(extloadi8 addrmodepc:$addr), (PICLDRB addrmodepc:$addr)>;
2603 def : ARMPat<(extloadi16 addrmodepc:$addr), (PICLDRH addrmodepc:$addr)>;
2606 def : ARMV5TEPat<(mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2607 (sra (shl GPR:$b, (i32 16)), (i32 16))),
2608 (SMULBB GPR:$a, GPR:$b)>;
2609 def : ARMV5TEPat<(mul sext_16_node:$a, sext_16_node:$b),
2610 (SMULBB GPR:$a, GPR:$b)>;
2611 def : ARMV5TEPat<(mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2612 (sra GPR:$b, (i32 16))),
2613 (SMULBT GPR:$a, GPR:$b)>;
2614 def : ARMV5TEPat<(mul sext_16_node:$a, (sra GPR:$b, (i32 16))),
2615 (SMULBT GPR:$a, GPR:$b)>;
2616 def : ARMV5TEPat<(mul (sra GPR:$a, (i32 16)),
2617 (sra (shl GPR:$b, (i32 16)), (i32 16))),
2618 (SMULTB GPR:$a, GPR:$b)>;
2619 def : ARMV5TEPat<(mul (sra GPR:$a, (i32 16)), sext_16_node:$b),
2620 (SMULTB GPR:$a, GPR:$b)>;
2621 def : ARMV5TEPat<(sra (mul GPR:$a, (sra (shl GPR:$b, (i32 16)), (i32 16))),
2623 (SMULWB GPR:$a, GPR:$b)>;
2624 def : ARMV5TEPat<(sra (mul GPR:$a, sext_16_node:$b), (i32 16)),
2625 (SMULWB GPR:$a, GPR:$b)>;
2627 def : ARMV5TEPat<(add GPR:$acc,
2628 (mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2629 (sra (shl GPR:$b, (i32 16)), (i32 16)))),
2630 (SMLABB GPR:$a, GPR:$b, GPR:$acc)>;
2631 def : ARMV5TEPat<(add GPR:$acc,
2632 (mul sext_16_node:$a, sext_16_node:$b)),
2633 (SMLABB GPR:$a, GPR:$b, GPR:$acc)>;
2634 def : ARMV5TEPat<(add GPR:$acc,
2635 (mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2636 (sra GPR:$b, (i32 16)))),
2637 (SMLABT GPR:$a, GPR:$b, GPR:$acc)>;
2638 def : ARMV5TEPat<(add GPR:$acc,
2639 (mul sext_16_node:$a, (sra GPR:$b, (i32 16)))),
2640 (SMLABT GPR:$a, GPR:$b, GPR:$acc)>;
2641 def : ARMV5TEPat<(add GPR:$acc,
2642 (mul (sra GPR:$a, (i32 16)),
2643 (sra (shl GPR:$b, (i32 16)), (i32 16)))),
2644 (SMLATB GPR:$a, GPR:$b, GPR:$acc)>;
2645 def : ARMV5TEPat<(add GPR:$acc,
2646 (mul (sra GPR:$a, (i32 16)), sext_16_node:$b)),
2647 (SMLATB GPR:$a, GPR:$b, GPR:$acc)>;
2648 def : ARMV5TEPat<(add GPR:$acc,
2649 (sra (mul GPR:$a, (sra (shl GPR:$b, (i32 16)), (i32 16))),
2651 (SMLAWB GPR:$a, GPR:$b, GPR:$acc)>;
2652 def : ARMV5TEPat<(add GPR:$acc,
2653 (sra (mul GPR:$a, sext_16_node:$b), (i32 16))),
2654 (SMLAWB GPR:$a, GPR:$b, GPR:$acc)>;
2656 //===----------------------------------------------------------------------===//
2660 include "ARMInstrThumb.td"
2662 //===----------------------------------------------------------------------===//
2666 include "ARMInstrThumb2.td"
2668 //===----------------------------------------------------------------------===//
2669 // Floating Point Support
2672 include "ARMInstrVFP.td"
2674 //===----------------------------------------------------------------------===//
2675 // Advanced SIMD (NEON) Support
2678 include "ARMInstrNEON.td"
2680 //===----------------------------------------------------------------------===//
2681 // Coprocessor Instructions. For disassembly only.
2684 def CDP : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2685 nohash_imm:$CRd, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2686 NoItinerary, "cdp", "\tp$cop, $opc1, cr$CRd, cr$CRn, cr$CRm, $opc2",
2687 [/* For disassembly only; pattern left blank */]> {
2691 def CDP2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2692 nohash_imm:$CRd, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2693 NoItinerary, "cdp2\tp$cop, $opc1, cr$CRd, cr$CRn, cr$CRm, $opc2",
2694 [/* For disassembly only; pattern left blank */]> {
2695 let Inst{31-28} = 0b1111;
2699 class ACI<dag oops, dag iops, string opc, string asm>
2700 : I<oops, iops, AddrModeNone, Size4Bytes, IndexModeNone, BrFrm, NoItinerary,
2701 opc, asm, "", [/* For disassembly only; pattern left blank */]> {
2702 let Inst{27-25} = 0b110;
2705 multiclass LdStCop<bits<4> op31_28, bit load, string opc> {
2707 def _OFFSET : ACI<(outs),
2708 (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2709 opc, "\tp$cop, cr$CRd, $addr"> {
2710 let Inst{31-28} = op31_28;
2711 let Inst{24} = 1; // P = 1
2712 let Inst{21} = 0; // W = 0
2713 let Inst{22} = 0; // D = 0
2714 let Inst{20} = load;
2717 def _PRE : ACI<(outs),
2718 (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2719 opc, "\tp$cop, cr$CRd, $addr!"> {
2720 let Inst{31-28} = op31_28;
2721 let Inst{24} = 1; // P = 1
2722 let Inst{21} = 1; // W = 1
2723 let Inst{22} = 0; // D = 0
2724 let Inst{20} = load;
2727 def _POST : ACI<(outs),
2728 (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, am2offset:$offset),
2729 opc, "\tp$cop, cr$CRd, [$base], $offset"> {
2730 let Inst{31-28} = op31_28;
2731 let Inst{24} = 0; // P = 0
2732 let Inst{21} = 1; // W = 1
2733 let Inst{22} = 0; // D = 0
2734 let Inst{20} = load;
2737 def _OPTION : ACI<(outs),
2738 (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, i32imm:$option),
2739 opc, "\tp$cop, cr$CRd, [$base], $option"> {
2740 let Inst{31-28} = op31_28;
2741 let Inst{24} = 0; // P = 0
2742 let Inst{23} = 1; // U = 1
2743 let Inst{21} = 0; // W = 0
2744 let Inst{22} = 0; // D = 0
2745 let Inst{20} = load;
2748 def L_OFFSET : ACI<(outs),
2749 (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2750 opc, "l\tp$cop, cr$CRd, $addr"> {
2751 let Inst{31-28} = op31_28;
2752 let Inst{24} = 1; // P = 1
2753 let Inst{21} = 0; // W = 0
2754 let Inst{22} = 1; // D = 1
2755 let Inst{20} = load;
2758 def L_PRE : ACI<(outs),
2759 (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2760 opc, "l\tp$cop, cr$CRd, $addr!"> {
2761 let Inst{31-28} = op31_28;
2762 let Inst{24} = 1; // P = 1
2763 let Inst{21} = 1; // W = 1
2764 let Inst{22} = 1; // D = 1
2765 let Inst{20} = load;
2768 def L_POST : ACI<(outs),
2769 (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, am2offset:$offset),
2770 opc, "l\tp$cop, cr$CRd, [$base], $offset"> {
2771 let Inst{31-28} = op31_28;
2772 let Inst{24} = 0; // P = 0
2773 let Inst{21} = 1; // W = 1
2774 let Inst{22} = 1; // D = 1
2775 let Inst{20} = load;
2778 def L_OPTION : ACI<(outs),
2779 (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, nohash_imm:$option),
2780 opc, "l\tp$cop, cr$CRd, [$base], $option"> {
2781 let Inst{31-28} = op31_28;
2782 let Inst{24} = 0; // P = 0
2783 let Inst{23} = 1; // U = 1
2784 let Inst{21} = 0; // W = 0
2785 let Inst{22} = 1; // D = 1
2786 let Inst{20} = load;
2790 defm LDC : LdStCop<{?,?,?,?}, 1, "ldc">;
2791 defm LDC2 : LdStCop<0b1111, 1, "ldc2">;
2792 defm STC : LdStCop<{?,?,?,?}, 0, "stc">;
2793 defm STC2 : LdStCop<0b1111, 0, "stc2">;
2795 def MCR : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2796 GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2797 NoItinerary, "mcr", "\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2798 [/* For disassembly only; pattern left blank */]> {
2803 def MCR2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2804 GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2805 NoItinerary, "mcr2\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2806 [/* For disassembly only; pattern left blank */]> {
2807 let Inst{31-28} = 0b1111;
2812 def MRC : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2813 GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2814 NoItinerary, "mrc", "\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2815 [/* For disassembly only; pattern left blank */]> {
2820 def MRC2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2821 GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2822 NoItinerary, "mrc2\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2823 [/* For disassembly only; pattern left blank */]> {
2824 let Inst{31-28} = 0b1111;
2829 def MCRR : ABI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
2830 GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
2831 NoItinerary, "mcrr", "\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
2832 [/* For disassembly only; pattern left blank */]> {
2833 let Inst{23-20} = 0b0100;
2836 def MCRR2 : ABXI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
2837 GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
2838 NoItinerary, "mcrr2\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
2839 [/* For disassembly only; pattern left blank */]> {
2840 let Inst{31-28} = 0b1111;
2841 let Inst{23-20} = 0b0100;
2844 def MRRC : ABI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
2845 GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
2846 NoItinerary, "mrrc", "\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
2847 [/* For disassembly only; pattern left blank */]> {
2848 let Inst{23-20} = 0b0101;
2851 def MRRC2 : ABXI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
2852 GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
2853 NoItinerary, "mrrc2\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
2854 [/* For disassembly only; pattern left blank */]> {
2855 let Inst{31-28} = 0b1111;
2856 let Inst{23-20} = 0b0101;
2859 //===----------------------------------------------------------------------===//
2860 // Move between special register and ARM core register -- for disassembly only
2863 def MRS : ABI<0b0001,(outs GPR:$dst),(ins), NoItinerary, "mrs", "\t$dst, cpsr",
2864 [/* For disassembly only; pattern left blank */]> {
2865 let Inst{23-20} = 0b0000;
2866 let Inst{7-4} = 0b0000;
2869 def MRSsys : ABI<0b0001,(outs GPR:$dst),(ins), NoItinerary,"mrs","\t$dst, spsr",
2870 [/* For disassembly only; pattern left blank */]> {
2871 let Inst{23-20} = 0b0100;
2872 let Inst{7-4} = 0b0000;
2875 def MSR : ABI<0b0001, (outs), (ins GPR:$src, msr_mask:$mask), NoItinerary,
2876 "msr", "\tcpsr$mask, $src",
2877 [/* For disassembly only; pattern left blank */]> {
2878 let Inst{23-20} = 0b0010;
2879 let Inst{7-4} = 0b0000;
2882 def MSRi : ABI<0b0011, (outs), (ins so_imm:$a, msr_mask:$mask), NoItinerary,
2883 "msr", "\tcpsr$mask, $a",
2884 [/* For disassembly only; pattern left blank */]> {
2885 let Inst{23-20} = 0b0010;
2886 let Inst{7-4} = 0b0000;
2889 def MSRsys : ABI<0b0001, (outs), (ins GPR:$src, msr_mask:$mask), NoItinerary,
2890 "msr", "\tspsr$mask, $src",
2891 [/* For disassembly only; pattern left blank */]> {
2892 let Inst{23-20} = 0b0110;
2893 let Inst{7-4} = 0b0000;
2896 def MSRsysi : ABI<0b0011, (outs), (ins so_imm:$a, msr_mask:$mask), NoItinerary,
2897 "msr", "\tspsr$mask, $a",
2898 [/* For disassembly only; pattern left blank */]> {
2899 let Inst{23-20} = 0b0110;
2900 let Inst{7-4} = 0b0000;