2009-05-29 23:41:08 +00:00
|
|
|
//===- ARMInstrThumb2.td - Thumb2 support for ARM -------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file describes the Thumb2 instruction set.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
2009-06-17 18:13:58 +00:00
|
|
|
|
2009-07-10 01:54:42 +00:00
|
|
|
// IT block predicate field
|
2011-08-26 21:43:41 +00:00
|
|
|
def it_pred_asmoperand : AsmOperandClass {
|
|
|
|
let Name = "ITCondCode";
|
|
|
|
let ParserMethod = "parseITCondCode";
|
|
|
|
}
|
2009-07-10 01:54:42 +00:00
|
|
|
def it_pred : Operand<i32> {
|
2010-03-02 17:57:15 +00:00
|
|
|
let PrintMethod = "printMandatoryPredicateOperand";
|
2011-08-26 21:43:41 +00:00
|
|
|
let ParserMatchClass = it_pred_asmoperand;
|
2009-07-10 01:54:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// IT block condition mask
|
2011-08-26 21:43:41 +00:00
|
|
|
def it_mask_asmoperand : AsmOperandClass { let Name = "ITMask"; }
|
2009-07-10 01:54:42 +00:00
|
|
|
def it_mask : Operand<i32> {
|
|
|
|
let PrintMethod = "printThumbITMask";
|
2011-08-26 21:43:41 +00:00
|
|
|
let ParserMatchClass = it_mask_asmoperand;
|
2009-07-10 01:54:42 +00:00
|
|
|
}
|
|
|
|
|
2009-06-17 18:13:58 +00:00
|
|
|
// Shifted operands. No register controlled shifts for Thumb2.
|
|
|
|
// Note: We do not support rrx shifted operands yet.
|
|
|
|
def t2_so_reg : Operand<i32>, // reg imm
|
2009-06-27 02:26:13 +00:00
|
|
|
ComplexPattern<i32, 2, "SelectT2ShifterOperandReg",
|
2009-06-17 18:13:58 +00:00
|
|
|
[shl,srl,sra,rotr]> {
|
2010-11-15 05:19:05 +00:00
|
|
|
let EncoderMethod = "getT2SORegOpValue";
|
2009-06-27 02:26:13 +00:00
|
|
|
let PrintMethod = "printT2SOOperand";
|
2011-08-22 23:10:16 +00:00
|
|
|
let DecoderMethod = "DecodeSORegImmOperand";
|
2011-08-31 18:23:08 +00:00
|
|
|
let ParserMatchClass = ShiftedImmAsmOperand;
|
|
|
|
let MIOperandInfo = (ops rGPR, i32imm);
|
2009-06-17 18:13:58 +00:00
|
|
|
}
|
|
|
|
|
2009-06-23 17:48:47 +00:00
|
|
|
// t2_so_imm_not_XFORM - Return the complement of a t2_so_imm value
|
|
|
|
def t2_so_imm_not_XFORM : SDNodeXForm<imm, [{
|
2009-08-11 20:47:22 +00:00
|
|
|
return CurDAG->getTargetConstant(~((uint32_t)N->getZExtValue()), MVT::i32);
|
2009-06-17 18:13:58 +00:00
|
|
|
}]>;
|
|
|
|
|
2009-06-23 17:48:47 +00:00
|
|
|
// t2_so_imm_neg_XFORM - Return the negation of a t2_so_imm value
|
|
|
|
def t2_so_imm_neg_XFORM : SDNodeXForm<imm, [{
|
2009-08-11 20:47:22 +00:00
|
|
|
return CurDAG->getTargetConstant(-((int)N->getZExtValue()), MVT::i32);
|
2009-06-23 17:48:47 +00:00
|
|
|
}]>;
|
|
|
|
|
|
|
|
// t2_so_imm - Match a 32-bit immediate operand, which is an
|
|
|
|
// 8-bit immediate rotated by an arbitrary number of bits, or an 8-bit
|
2011-02-07 17:43:06 +00:00
|
|
|
// immediate splatted into multiple bytes of the word.
|
2011-06-27 23:54:06 +00:00
|
|
|
def t2_so_imm_asmoperand : AsmOperandClass { let Name = "T2SOImm"; }
|
2011-04-29 22:48:03 +00:00
|
|
|
def t2_so_imm : Operand<i32>, ImmLeaf<i32, [{
|
|
|
|
return ARM_AM::getT2SOImmVal(Imm) != -1;
|
|
|
|
}]> {
|
2011-06-27 23:54:06 +00:00
|
|
|
let ParserMatchClass = t2_so_imm_asmoperand;
|
2010-11-15 05:19:05 +00:00
|
|
|
let EncoderMethod = "getT2SOImmOpValue";
|
2011-08-09 20:55:18 +00:00
|
|
|
let DecoderMethod = "DecodeT2SOImm";
|
2010-11-12 21:12:40 +00:00
|
|
|
}
|
2009-06-17 18:13:58 +00:00
|
|
|
|
2010-02-16 21:07:46 +00:00
|
|
|
// t2_so_imm_not - Match an immediate that is a complement
|
2009-06-23 17:48:47 +00:00
|
|
|
// of a t2_so_imm.
|
|
|
|
def t2_so_imm_not : Operand<i32>,
|
|
|
|
PatLeaf<(imm), [{
|
2009-07-08 21:03:57 +00:00
|
|
|
return ARM_AM::getT2SOImmVal(~((uint32_t)N->getZExtValue())) != -1;
|
|
|
|
}], t2_so_imm_not_XFORM>;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
|
|
|
// t2_so_imm_neg - Match an immediate that is a negation of a t2_so_imm.
|
|
|
|
def t2_so_imm_neg : Operand<i32>,
|
|
|
|
PatLeaf<(imm), [{
|
2010-11-12 22:42:47 +00:00
|
|
|
return ARM_AM::getT2SOImmVal(-((uint32_t)N->getZExtValue())) != -1;
|
2009-07-08 21:03:57 +00:00
|
|
|
}], t2_so_imm_neg_XFORM>;
|
2009-06-17 18:13:58 +00:00
|
|
|
|
2009-06-23 17:48:47 +00:00
|
|
|
/// imm0_4095 predicate - True if the 32-bit immediate is in the range [0.4095].
|
2009-08-07 00:34:42 +00:00
|
|
|
def imm0_4095 : Operand<i32>,
|
2011-04-28 05:49:04 +00:00
|
|
|
ImmLeaf<i32, [{
|
|
|
|
return Imm >= 0 && Imm < 4096;
|
2009-06-23 17:48:47 +00:00
|
|
|
}]>;
|
2009-06-17 18:13:58 +00:00
|
|
|
|
2010-02-16 21:07:46 +00:00
|
|
|
def imm0_4095_neg : PatLeaf<(i32 imm), [{
|
|
|
|
return (uint32_t)(-N->getZExtValue()) < 4096;
|
|
|
|
}], imm_neg_XFORM>;
|
2009-06-17 18:13:58 +00:00
|
|
|
|
2009-08-04 01:41:15 +00:00
|
|
|
def imm0_255_neg : PatLeaf<(i32 imm), [{
|
|
|
|
return (uint32_t)(-N->getZExtValue()) < 255;
|
2010-02-16 21:07:46 +00:00
|
|
|
}], imm_neg_XFORM>;
|
2009-08-04 01:41:15 +00:00
|
|
|
|
2010-07-14 17:45:16 +00:00
|
|
|
def imm0_255_not : PatLeaf<(i32 imm), [{
|
|
|
|
return (uint32_t)(~N->getZExtValue()) < 255;
|
|
|
|
}], imm_comp_XFORM>;
|
|
|
|
|
2011-04-29 14:18:15 +00:00
|
|
|
def lo5AllOne : PatLeaf<(i32 imm), [{
|
|
|
|
// Returns true if all low 5-bits are 1.
|
|
|
|
return (((uint32_t)N->getZExtValue()) & 0x1FUL) == 0x1FUL;
|
|
|
|
}]>;
|
|
|
|
|
2009-06-29 07:51:04 +00:00
|
|
|
// Define Thumb2 specific addressing modes.
|
|
|
|
|
|
|
|
// t2addrmode_imm12 := reg + imm12
|
2011-09-07 20:58:57 +00:00
|
|
|
def t2addrmode_imm12_asmoperand : AsmOperandClass {let Name="MemUImm12Offset";}
|
2009-06-29 07:51:04 +00:00
|
|
|
def t2addrmode_imm12 : Operand<i32>,
|
|
|
|
ComplexPattern<i32, 2, "SelectT2AddrModeImm12", []> {
|
2010-10-25 20:00:01 +00:00
|
|
|
let PrintMethod = "printAddrModeImm12Operand";
|
2010-12-10 20:53:44 +00:00
|
|
|
let EncoderMethod = "getAddrModeImm12OpValue";
|
2011-08-09 20:55:18 +00:00
|
|
|
let DecoderMethod = "DecodeT2AddrModeImm12";
|
2011-09-07 20:58:57 +00:00
|
|
|
let ParserMatchClass = t2addrmode_imm12_asmoperand;
|
2009-06-29 07:51:04 +00:00
|
|
|
let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
|
|
|
|
}
|
|
|
|
|
2011-03-18 17:42:55 +00:00
|
|
|
// t2ldrlabel := imm12
|
|
|
|
def t2ldrlabel : Operand<i32> {
|
|
|
|
let EncoderMethod = "getAddrModeImm12OpValue";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-12-14 00:36:49 +00:00
|
|
|
// ADR instruction labels.
|
|
|
|
def t2adrlabel : Operand<i32> {
|
|
|
|
let EncoderMethod = "getT2AdrLabelOpValue";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-09-07 23:39:14 +00:00
|
|
|
// t2addrmode_posimm8 := reg + imm8
|
|
|
|
def MemPosImm8OffsetAsmOperand : AsmOperandClass {let Name="MemPosImm8Offset";}
|
|
|
|
def t2addrmode_posimm8 : Operand<i32> {
|
|
|
|
let PrintMethod = "printT2AddrModeImm8Operand";
|
|
|
|
let EncoderMethod = "getT2AddrModeImm8OpValue";
|
|
|
|
let DecoderMethod = "DecodeT2AddrModeImm8";
|
|
|
|
let ParserMatchClass = MemPosImm8OffsetAsmOperand;
|
|
|
|
let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
|
|
|
|
}
|
|
|
|
|
2011-09-07 20:58:57 +00:00
|
|
|
// t2addrmode_negimm8 := reg - imm8
|
|
|
|
def MemNegImm8OffsetAsmOperand : AsmOperandClass {let Name="MemNegImm8Offset";}
|
|
|
|
def t2addrmode_negimm8 : Operand<i32>,
|
|
|
|
ComplexPattern<i32, 2, "SelectT2AddrModeImm8", []> {
|
|
|
|
let PrintMethod = "printT2AddrModeImm8Operand";
|
|
|
|
let EncoderMethod = "getT2AddrModeImm8OpValue";
|
|
|
|
let DecoderMethod = "DecodeT2AddrModeImm8";
|
|
|
|
let ParserMatchClass = MemNegImm8OffsetAsmOperand;
|
|
|
|
let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
|
|
|
|
}
|
|
|
|
|
2010-03-04 17:40:44 +00:00
|
|
|
// t2addrmode_imm8 := reg +/- imm8
|
2011-08-03 23:50:40 +00:00
|
|
|
def MemImm8OffsetAsmOperand : AsmOperandClass { let Name = "MemImm8Offset"; }
|
2009-06-29 07:51:04 +00:00
|
|
|
def t2addrmode_imm8 : Operand<i32>,
|
|
|
|
ComplexPattern<i32, 2, "SelectT2AddrModeImm8", []> {
|
|
|
|
let PrintMethod = "printT2AddrModeImm8Operand";
|
2010-12-10 20:53:44 +00:00
|
|
|
let EncoderMethod = "getT2AddrModeImm8OpValue";
|
2011-08-09 20:55:18 +00:00
|
|
|
let DecoderMethod = "DecodeT2AddrModeImm8";
|
2011-08-03 23:50:40 +00:00
|
|
|
let ParserMatchClass = MemImm8OffsetAsmOperand;
|
2009-06-29 07:51:04 +00:00
|
|
|
let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
|
|
|
|
}
|
|
|
|
|
2009-07-03 00:06:39 +00:00
|
|
|
def t2am_imm8_offset : Operand<i32>,
|
2010-09-21 20:31:19 +00:00
|
|
|
ComplexPattern<i32, 1, "SelectT2AddrModeImm8Offset",
|
|
|
|
[], [SDNPWantRoot]> {
|
2009-07-02 07:28:31 +00:00
|
|
|
let PrintMethod = "printT2AddrModeImm8OffsetOperand";
|
2010-12-10 20:53:44 +00:00
|
|
|
let EncoderMethod = "getT2AddrModeImm8OffsetOpValue";
|
2011-08-09 20:55:18 +00:00
|
|
|
let DecoderMethod = "DecodeT2Imm8";
|
2009-07-02 07:28:31 +00:00
|
|
|
}
|
|
|
|
|
2009-07-09 22:21:59 +00:00
|
|
|
// t2addrmode_imm8s4 := reg +/- (imm8 << 2)
|
2011-09-08 22:07:06 +00:00
|
|
|
def MemImm8s4OffsetAsmOperand : AsmOperandClass {let Name = "MemImm8s4Offset";}
|
2010-09-05 22:51:11 +00:00
|
|
|
def t2addrmode_imm8s4 : Operand<i32> {
|
2009-07-09 22:21:59 +00:00
|
|
|
let PrintMethod = "printT2AddrModeImm8s4Operand";
|
2010-12-10 20:53:44 +00:00
|
|
|
let EncoderMethod = "getT2AddrModeImm8s4OpValue";
|
2011-08-09 20:55:18 +00:00
|
|
|
let DecoderMethod = "DecodeT2AddrModeImm8s4";
|
2011-09-08 22:07:06 +00:00
|
|
|
let ParserMatchClass = MemImm8s4OffsetAsmOperand;
|
2009-06-30 22:50:01 +00:00
|
|
|
let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
|
|
|
|
}
|
|
|
|
|
2011-09-08 22:07:06 +00:00
|
|
|
def t2am_imm8s4_offset_asmoperand : AsmOperandClass { let Name = "Imm8s4"; }
|
2010-03-11 01:13:36 +00:00
|
|
|
def t2am_imm8s4_offset : Operand<i32> {
|
|
|
|
let PrintMethod = "printT2AddrModeImm8s4OffsetOperand";
|
2011-09-08 22:07:06 +00:00
|
|
|
let EncoderMethod = "getT2Imm8s4OpValue";
|
2011-08-04 23:18:05 +00:00
|
|
|
let DecoderMethod = "DecodeT2Imm8S4";
|
2010-03-11 01:13:36 +00:00
|
|
|
}
|
|
|
|
|
2011-09-09 18:37:27 +00:00
|
|
|
// t2addrmode_imm0_1020s4 := reg + (imm8 << 2)
|
|
|
|
def MemImm0_1020s4OffsetAsmOperand : AsmOperandClass {
|
|
|
|
let Name = "MemImm0_1020s4Offset";
|
|
|
|
}
|
|
|
|
def t2addrmode_imm0_1020s4 : Operand<i32> {
|
|
|
|
let PrintMethod = "printT2AddrModeImm0_1020s4Operand";
|
|
|
|
let EncoderMethod = "getT2AddrModeImm0_1020s4OpValue";
|
|
|
|
let DecoderMethod = "DecodeT2AddrModeImm0_1020s4";
|
|
|
|
let ParserMatchClass = MemImm0_1020s4OffsetAsmOperand;
|
|
|
|
let MIOperandInfo = (ops GPRnopc:$base, i32imm:$offsimm);
|
|
|
|
}
|
|
|
|
|
2009-07-09 20:40:44 +00:00
|
|
|
// t2addrmode_so_reg := reg + (reg << imm2)
|
2011-09-07 23:10:15 +00:00
|
|
|
def t2addrmode_so_reg_asmoperand : AsmOperandClass {let Name="T2MemRegOffset";}
|
2009-06-29 07:51:04 +00:00
|
|
|
def t2addrmode_so_reg : Operand<i32>,
|
|
|
|
ComplexPattern<i32, 3, "SelectT2AddrModeSoReg", []> {
|
|
|
|
let PrintMethod = "printT2AddrModeSoRegOperand";
|
2010-12-10 20:53:44 +00:00
|
|
|
let EncoderMethod = "getT2AddrModeSORegOpValue";
|
2011-08-09 20:55:18 +00:00
|
|
|
let DecoderMethod = "DecodeT2AddrModeSOReg";
|
2011-09-07 23:10:15 +00:00
|
|
|
let ParserMatchClass = t2addrmode_so_reg_asmoperand;
|
Many Thumb2 instructions can reference the full ARM register set (i.e.,
have 4 bits per register in the operand encoding), but have undefined
behavior when the operand value is 13 or 15 (SP and PC, respectively).
The trivial coalescer in linear scan sometimes will merge a copy from
SP into a subsequent instruction which uses the copy, and if that
instruction cannot legally reference SP, we get bad code such as:
mls r0,r9,r0,sp
instead of:
mov r2, sp
mls r0, r9, r0, r2
This patch adds a new register class for use by Thumb2 that excludes
the problematic registers (SP and PC) and is used instead of GPR
for those operands which cannot legally reference PC or SP. The
trivial coalescer explicitly requires that the register class
of the destination for the COPY instruction contain the source
register for the COPY to be considered for coalescing. This prevents
errant instructions like that above.
PR7499
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@109842 91177308-0d34-0410-b5e6-96231b3b80d8
2010-07-30 02:41:01 +00:00
|
|
|
let MIOperandInfo = (ops GPR:$base, rGPR:$offsreg, i32imm:$offsimm);
|
2009-06-29 07:51:04 +00:00
|
|
|
}
|
|
|
|
|
2009-06-17 18:13:58 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2009-06-27 02:26:13 +00:00
|
|
|
// Multiclass helpers...
|
2009-06-17 18:13:58 +00:00
|
|
|
//
|
|
|
|
|
2010-11-15 18:45:17 +00:00
|
|
|
|
|
|
|
class T2OneRegImm<dag oops, dag iops, InstrItinClass itin,
|
2010-11-14 05:37:38 +00:00
|
|
|
string opc, string asm, list<dag> pattern>
|
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> Rd;
|
2010-11-15 18:45:17 +00:00
|
|
|
bits<12> imm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-15 18:45:17 +00:00
|
|
|
let Inst{26} = imm{11};
|
|
|
|
let Inst{14-12} = imm{10-8};
|
|
|
|
let Inst{7-0} = imm{7-0};
|
|
|
|
}
|
|
|
|
|
2010-11-15 19:58:36 +00:00
|
|
|
|
2010-11-15 18:45:17 +00:00
|
|
|
class T2sOneRegImm<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
|
|
|
: T2sI<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> Rd;
|
2010-11-14 05:37:38 +00:00
|
|
|
bits<4> Rn;
|
|
|
|
bits<12> imm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-14 05:37:38 +00:00
|
|
|
let Inst{26} = imm{11};
|
|
|
|
let Inst{14-12} = imm{10-8};
|
|
|
|
let Inst{7-0} = imm{7-0};
|
|
|
|
}
|
|
|
|
|
2010-11-15 19:58:36 +00:00
|
|
|
class T2OneRegCmpImm<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<12> imm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{19-16} = Rn;
|
2010-11-15 19:58:36 +00:00
|
|
|
let Inst{26} = imm{11};
|
|
|
|
let Inst{14-12} = imm{10-8};
|
|
|
|
let Inst{7-0} = imm{7-0};
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-11-15 18:45:17 +00:00
|
|
|
class T2OneRegShiftedReg<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> Rd;
|
|
|
|
bits<12> ShiftedRm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-15 18:45:17 +00:00
|
|
|
let Inst{3-0} = ShiftedRm{3-0};
|
|
|
|
let Inst{5-4} = ShiftedRm{6-5};
|
|
|
|
let Inst{14-12} = ShiftedRm{11-9};
|
|
|
|
let Inst{7-6} = ShiftedRm{8-7};
|
|
|
|
}
|
|
|
|
|
|
|
|
class T2sOneRegShiftedReg<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-12-07 20:50:15 +00:00
|
|
|
: T2sI<oops, iops, itin, opc, asm, pattern> {
|
2010-11-15 18:45:17 +00:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<12> ShiftedRm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-15 18:45:17 +00:00
|
|
|
let Inst{3-0} = ShiftedRm{3-0};
|
|
|
|
let Inst{5-4} = ShiftedRm{6-5};
|
|
|
|
let Inst{14-12} = ShiftedRm{11-9};
|
|
|
|
let Inst{7-6} = ShiftedRm{8-7};
|
|
|
|
}
|
|
|
|
|
2010-11-15 19:58:36 +00:00
|
|
|
class T2OneRegCmpShiftedReg<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<12> ShiftedRm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{19-16} = Rn;
|
2010-11-15 19:58:36 +00:00
|
|
|
let Inst{3-0} = ShiftedRm{3-0};
|
|
|
|
let Inst{5-4} = ShiftedRm{6-5};
|
|
|
|
let Inst{14-12} = ShiftedRm{11-9};
|
|
|
|
let Inst{7-6} = ShiftedRm{8-7};
|
|
|
|
}
|
|
|
|
|
2010-11-15 18:45:17 +00:00
|
|
|
class T2TwoReg<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-19 17:11:02 +00:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
2010-11-15 18:45:17 +00:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{3-0} = Rm;
|
2010-11-15 18:45:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
class T2sTwoReg<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-19 17:11:02 +00:00
|
|
|
: T2sI<oops, iops, itin, opc, asm, pattern> {
|
2010-11-15 18:45:17 +00:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{3-0} = Rm;
|
2010-11-15 18:45:17 +00:00
|
|
|
}
|
|
|
|
|
2010-11-15 19:58:36 +00:00
|
|
|
class T2TwoRegCmp<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-19 17:11:02 +00:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
2010-11-15 19:58:36 +00:00
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{3-0} = Rm;
|
2010-11-15 19:58:36 +00:00
|
|
|
}
|
|
|
|
|
2010-11-15 18:45:17 +00:00
|
|
|
|
|
|
|
class T2TwoRegImm<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> Rd;
|
2010-12-08 23:04:16 +00:00
|
|
|
bits<4> Rn;
|
2010-12-08 23:24:29 +00:00
|
|
|
bits<12> imm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
2010-12-08 23:24:29 +00:00
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{26} = imm{11};
|
|
|
|
let Inst{14-12} = imm{10-8};
|
|
|
|
let Inst{7-0} = imm{7-0};
|
2010-11-15 18:45:17 +00:00
|
|
|
}
|
|
|
|
|
2010-11-14 05:37:38 +00:00
|
|
|
class T2sTwoRegImm<dag oops, dag iops, InstrItinClass itin,
|
2010-11-12 21:12:40 +00:00
|
|
|
string opc, string asm, list<dag> pattern>
|
|
|
|
: T2sI<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<12> imm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{19-16} = Rn;
|
2010-11-12 21:12:40 +00:00
|
|
|
let Inst{26} = imm{11};
|
|
|
|
let Inst{14-12} = imm{10-8};
|
|
|
|
let Inst{7-0} = imm{7-0};
|
|
|
|
}
|
|
|
|
|
2010-11-15 19:58:36 +00:00
|
|
|
class T2TwoRegShiftImm<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rm;
|
|
|
|
bits<5> imm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{3-0} = Rm;
|
2010-11-15 19:58:36 +00:00
|
|
|
let Inst{14-12} = imm{4-2};
|
|
|
|
let Inst{7-6} = imm{1-0};
|
|
|
|
}
|
|
|
|
|
|
|
|
class T2sTwoRegShiftImm<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
|
|
|
: T2sI<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rm;
|
|
|
|
bits<5> imm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{3-0} = Rm;
|
2010-11-15 19:58:36 +00:00
|
|
|
let Inst{14-12} = imm{4-2};
|
|
|
|
let Inst{7-6} = imm{1-0};
|
|
|
|
}
|
|
|
|
|
2010-11-12 21:12:40 +00:00
|
|
|
class T2ThreeReg<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-19 17:11:02 +00:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
2010-11-14 05:37:38 +00:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{3-0} = Rm;
|
2010-11-14 05:37:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
class T2sThreeReg<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-19 17:11:02 +00:00
|
|
|
: T2sI<oops, iops, itin, opc, asm, pattern> {
|
2010-11-12 21:12:40 +00:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{3-0} = Rm;
|
2010-11-12 21:12:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
class T2TwoRegShiftedReg<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-14 05:37:38 +00:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<12> ShiftedRm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{19-16} = Rn;
|
2010-11-14 05:37:38 +00:00
|
|
|
let Inst{3-0} = ShiftedRm{3-0};
|
|
|
|
let Inst{5-4} = ShiftedRm{6-5};
|
|
|
|
let Inst{14-12} = ShiftedRm{11-9};
|
|
|
|
let Inst{7-6} = ShiftedRm{8-7};
|
|
|
|
}
|
|
|
|
|
|
|
|
class T2sTwoRegShiftedReg<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-12 21:12:40 +00:00
|
|
|
: T2sI<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<12> ShiftedRm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{19-16} = Rn;
|
2010-11-12 21:12:40 +00:00
|
|
|
let Inst{3-0} = ShiftedRm{3-0};
|
|
|
|
let Inst{5-4} = ShiftedRm{6-5};
|
|
|
|
let Inst{14-12} = ShiftedRm{11-9};
|
|
|
|
let Inst{7-6} = ShiftedRm{8-7};
|
|
|
|
}
|
|
|
|
|
2010-11-18 01:08:42 +00:00
|
|
|
class T2FourReg<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-19 17:11:02 +00:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
2010-11-18 01:08:42 +00:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
|
|
|
bits<4> Ra;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{15-12} = Ra;
|
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{3-0} = Rm;
|
2010-11-18 01:08:42 +00:00
|
|
|
}
|
|
|
|
|
2010-12-08 22:38:41 +00:00
|
|
|
class T2MulLong<bits<3> opc22_20, bits<4> opc7_4,
|
|
|
|
dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-12-08 22:29:28 +00:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> RdLo;
|
|
|
|
bits<4> RdHi;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
|
|
|
|
2010-12-08 22:38:41 +00:00
|
|
|
let Inst{31-23} = 0b111110111;
|
|
|
|
let Inst{22-20} = opc22_20;
|
2010-12-08 22:29:28 +00:00
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{15-12} = RdLo;
|
|
|
|
let Inst{11-8} = RdHi;
|
2010-12-08 22:38:41 +00:00
|
|
|
let Inst{7-4} = opc7_4;
|
2010-12-08 22:29:28 +00:00
|
|
|
let Inst{3-0} = Rm;
|
|
|
|
}
|
|
|
|
|
2010-11-18 01:08:42 +00:00
|
|
|
|
2009-06-23 19:39:13 +00:00
|
|
|
/// T2I_bin_irs - Defines a set of (op reg, {so_imm|r|so_reg}) patterns for a
|
2010-05-25 04:43:08 +00:00
|
|
|
/// binary operation that produces a value. These are predicable and can be
|
2009-06-25 02:08:06 +00:00
|
|
|
/// changed to modify CPSR.
|
2010-09-29 00:27:46 +00:00
|
|
|
multiclass T2I_bin_irs<bits<4> opcod, string opc,
|
|
|
|
InstrItinClass iii, InstrItinClass iir, InstrItinClass iis,
|
2011-06-28 00:19:13 +00:00
|
|
|
PatFrag opnode, string baseOpc, bit Commutable = 0,
|
|
|
|
string wide = ""> {
|
2009-06-23 17:48:47 +00:00
|
|
|
// shifted imm
|
2010-11-14 05:37:38 +00:00
|
|
|
def ri : T2sTwoRegImm<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_imm:$imm), iii,
|
|
|
|
opc, "\t$Rd, $Rn, $imm",
|
|
|
|
[(set rGPR:$Rd, (opnode rGPR:$Rn, t2_so_imm:$imm))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 0;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
2009-06-23 19:39:13 +00:00
|
|
|
// register
|
2010-11-14 05:37:38 +00:00
|
|
|
def rr : T2sThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), iir,
|
|
|
|
opc, !strconcat(wide, "\t$Rd, $Rn, $Rm"),
|
|
|
|
[(set rGPR:$Rd, (opnode rGPR:$Rn, rGPR:$Rm))]> {
|
2009-06-26 00:19:44 +00:00
|
|
|
let isCommutable = Commutable;
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{14-12} = 0b000; // imm3
|
|
|
|
let Inst{7-6} = 0b00; // imm2
|
|
|
|
let Inst{5-4} = 0b00; // type
|
2009-06-26 00:19:44 +00:00
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
// shifted register
|
2010-11-14 05:37:38 +00:00
|
|
|
def rs : T2sTwoRegShiftedReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_reg:$ShiftedRm), iis,
|
|
|
|
opc, !strconcat(wide, "\t$Rd, $Rn, $ShiftedRm"),
|
|
|
|
[(set rGPR:$Rd, (opnode rGPR:$Rn, t2_so_reg:$ShiftedRm))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
2010-08-30 01:47:35 +00:00
|
|
|
}
|
2011-06-28 00:19:13 +00:00
|
|
|
// Assembly aliases for optional destination operand when it's the same
|
|
|
|
// as the source operand.
|
2011-08-22 18:04:24 +00:00
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p} $Rdn, $imm"),
|
2011-06-28 00:19:13 +00:00
|
|
|
(!cast<Instruction>(!strconcat(baseOpc, "ri")) rGPR:$Rdn, rGPR:$Rdn,
|
|
|
|
t2_so_imm:$imm, pred:$p,
|
2011-08-22 18:04:24 +00:00
|
|
|
cc_out:$s)>;
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", wide, " $Rdn, $Rm"),
|
2011-06-28 00:19:13 +00:00
|
|
|
(!cast<Instruction>(!strconcat(baseOpc, "rr")) rGPR:$Rdn, rGPR:$Rdn,
|
|
|
|
rGPR:$Rm, pred:$p,
|
2011-08-22 18:04:24 +00:00
|
|
|
cc_out:$s)>;
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", wide, " $Rdn, $shift"),
|
2011-06-28 00:19:13 +00:00
|
|
|
(!cast<Instruction>(!strconcat(baseOpc, "rs")) rGPR:$Rdn, rGPR:$Rdn,
|
|
|
|
t2_so_reg:$shift, pred:$p,
|
2011-08-22 18:04:24 +00:00
|
|
|
cc_out:$s)>;
|
2010-08-30 01:47:35 +00:00
|
|
|
}
|
|
|
|
|
2009-07-27 23:34:12 +00:00
|
|
|
/// T2I_bin_w_irs - Same as T2I_bin_irs except these operations need
|
2011-06-28 00:19:13 +00:00
|
|
|
// the ".w" suffix to indicate that they are wide.
|
2010-09-29 00:27:46 +00:00
|
|
|
multiclass T2I_bin_w_irs<bits<4> opcod, string opc,
|
|
|
|
InstrItinClass iii, InstrItinClass iir, InstrItinClass iis,
|
2011-06-28 00:19:13 +00:00
|
|
|
PatFrag opnode, string baseOpc, bit Commutable = 0> :
|
2011-09-02 18:41:35 +00:00
|
|
|
T2I_bin_irs<opcod, opc, iii, iir, iis, opnode, baseOpc, Commutable, ".w"> {
|
|
|
|
// Assembler aliases w/o the ".w" suffix.
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", " $Rd, $Rn, $Rm"),
|
|
|
|
(!cast<Instruction>(!strconcat(baseOpc, "rr")) rGPR:$Rd, rGPR:$Rn,
|
|
|
|
rGPR:$Rm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", " $Rd, $Rn, $shift"),
|
|
|
|
(!cast<Instruction>(!strconcat(baseOpc, "rs")) rGPR:$Rd, rGPR:$Rn,
|
|
|
|
t2_so_reg:$shift, pred:$p,
|
|
|
|
cc_out:$s)>;
|
|
|
|
|
|
|
|
// and with the optional destination operand, too.
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", " $Rdn, $Rm"),
|
|
|
|
(!cast<Instruction>(!strconcat(baseOpc, "rr")) rGPR:$Rdn, rGPR:$Rdn,
|
|
|
|
rGPR:$Rm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", " $Rdn, $shift"),
|
|
|
|
(!cast<Instruction>(!strconcat(baseOpc, "rs")) rGPR:$Rdn, rGPR:$Rdn,
|
|
|
|
t2_so_reg:$shift, pred:$p,
|
|
|
|
cc_out:$s)>;
|
|
|
|
}
|
2010-08-29 03:55:31 +00:00
|
|
|
|
2009-06-25 20:59:23 +00:00
|
|
|
/// T2I_rbin_is - Same as T2I_bin_irs except the order of operands are
|
2010-08-13 23:24:25 +00:00
|
|
|
/// reversed. The 'rr' form is only defined for the disassembler; for codegen
|
|
|
|
/// it is equivalent to the T2I_bin_irs counterpart.
|
|
|
|
multiclass T2I_rbin_irs<bits<4> opcod, string opc, PatFrag opnode> {
|
2009-06-17 18:13:58 +00:00
|
|
|
// shifted imm
|
2010-11-14 05:37:38 +00:00
|
|
|
def ri : T2sTwoRegImm<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_imm:$imm), IIC_iALUi,
|
|
|
|
opc, ".w\t$Rd, $Rn, $imm",
|
|
|
|
[(set rGPR:$Rd, (opnode t2_so_imm:$imm, rGPR:$Rn))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 0;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
2010-08-13 23:24:25 +00:00
|
|
|
// register
|
2010-11-14 05:37:38 +00:00
|
|
|
def rr : T2sThreeReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iALUr,
|
|
|
|
opc, "\t$Rd, $Rn, $Rm",
|
2010-08-14 03:18:29 +00:00
|
|
|
[/* For disassembly only; pattern left blank */]> {
|
2010-08-13 23:24:25 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{14-12} = 0b000; // imm3
|
|
|
|
let Inst{7-6} = 0b00; // imm2
|
|
|
|
let Inst{5-4} = 0b00; // type
|
|
|
|
}
|
2009-06-17 18:13:58 +00:00
|
|
|
// shifted register
|
2010-11-14 05:37:38 +00:00
|
|
|
def rs : T2sTwoRegShiftedReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_reg:$ShiftedRm),
|
|
|
|
IIC_iALUsir, opc, "\t$Rd, $Rn, $ShiftedRm",
|
|
|
|
[(set rGPR:$Rd, (opnode t2_so_reg:$ShiftedRm, rGPR:$Rn))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
}
|
2009-06-17 18:13:58 +00:00
|
|
|
}
|
|
|
|
|
2009-06-23 19:39:13 +00:00
|
|
|
/// T2I_bin_s_irs - Similar to T2I_bin_irs except it sets the 's' bit so the
|
2009-06-17 18:13:58 +00:00
|
|
|
/// instruction modifies the CPSR register.
|
2011-09-06 18:52:20 +00:00
|
|
|
let hasPostISelHook = 1, isCodeGenOnly = 1, Defs = [CPSR] in {
|
2010-09-29 00:27:46 +00:00
|
|
|
multiclass T2I_bin_s_irs<bits<4> opcod, string opc,
|
|
|
|
InstrItinClass iii, InstrItinClass iir, InstrItinClass iis,
|
|
|
|
PatFrag opnode, bit Commutable = 0> {
|
2009-06-23 17:48:47 +00:00
|
|
|
// shifted imm
|
2011-09-06 18:52:20 +00:00
|
|
|
def ri : T2sTwoRegImm<
|
2010-11-14 05:37:38 +00:00
|
|
|
(outs rGPR:$Rd), (ins GPR:$Rn, t2_so_imm:$imm), iii,
|
2011-09-06 18:52:20 +00:00
|
|
|
opc, ".w\t$Rd, $Rn, $imm",
|
2011-08-30 01:34:54 +00:00
|
|
|
[(set rGPR:$Rd, CPSR, (opnode GPR:$Rn, t2_so_imm:$imm))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 0;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
2009-06-23 19:39:13 +00:00
|
|
|
// register
|
2011-09-06 18:52:20 +00:00
|
|
|
def rr : T2sThreeReg<
|
2010-11-14 05:37:38 +00:00
|
|
|
(outs rGPR:$Rd), (ins GPR:$Rn, rGPR:$Rm), iir,
|
2011-09-06 18:52:20 +00:00
|
|
|
opc, ".w\t$Rd, $Rn, $Rm",
|
2011-08-30 01:34:54 +00:00
|
|
|
[(set rGPR:$Rd, CPSR, (opnode GPR:$Rn, rGPR:$Rm))]> {
|
2009-06-26 00:19:44 +00:00
|
|
|
let isCommutable = Commutable;
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{14-12} = 0b000; // imm3
|
|
|
|
let Inst{7-6} = 0b00; // imm2
|
|
|
|
let Inst{5-4} = 0b00; // type
|
2009-06-26 00:19:44 +00:00
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
// shifted register
|
2011-09-06 18:52:20 +00:00
|
|
|
def rs : T2sTwoRegShiftedReg<
|
2010-11-14 05:37:38 +00:00
|
|
|
(outs rGPR:$Rd), (ins GPR:$Rn, t2_so_reg:$ShiftedRm), iis,
|
2011-09-06 18:52:20 +00:00
|
|
|
opc, ".w\t$Rd, $Rn, $ShiftedRm",
|
2011-08-30 01:34:54 +00:00
|
|
|
[(set rGPR:$Rd, CPSR, (opnode GPR:$Rn, t2_so_reg:$ShiftedRm))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-23 19:39:13 +00:00
|
|
|
/// T2I_bin_ii12rs - Defines a set of (op reg, {so_imm|imm0_4095|r|so_reg})
|
|
|
|
/// patterns for a binary operation that produces a value.
|
2009-12-15 17:24:14 +00:00
|
|
|
multiclass T2I_bin_ii12rs<bits<3> op23_21, string opc, PatFrag opnode,
|
|
|
|
bit Commutable = 0> {
|
2009-06-17 18:13:58 +00:00
|
|
|
// shifted imm
|
2010-08-30 19:49:58 +00:00
|
|
|
// The register-immediate version is re-materializable. This is useful
|
|
|
|
// in particular for taking the address of a local.
|
|
|
|
let isReMaterializable = 1 in {
|
2010-11-14 05:37:38 +00:00
|
|
|
def ri : T2sTwoRegImm<
|
2011-09-02 18:14:46 +00:00
|
|
|
(outs rGPR:$Rd), (ins GPRnopc:$Rn, t2_so_imm:$imm), IIC_iALUi,
|
2010-11-14 05:37:38 +00:00
|
|
|
opc, ".w\t$Rd, $Rn, $imm",
|
2011-09-02 18:14:46 +00:00
|
|
|
[(set rGPR:$Rd, (opnode GPRnopc:$Rn, t2_so_imm:$imm))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 0;
|
|
|
|
let Inst{24} = 1;
|
|
|
|
let Inst{23-21} = op23_21;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
2010-08-30 19:49:58 +00:00
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
// 12-bit imm
|
2010-12-08 23:04:16 +00:00
|
|
|
def ri12 : T2I<
|
2010-11-14 05:37:38 +00:00
|
|
|
(outs rGPR:$Rd), (ins GPR:$Rn, imm0_4095:$imm), IIC_iALUi,
|
|
|
|
!strconcat(opc, "w"), "\t$Rd, $Rn, $imm",
|
|
|
|
[(set rGPR:$Rd, (opnode GPR:$Rn, imm0_4095:$imm))]> {
|
2010-12-08 23:04:16 +00:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<12> imm;
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
2010-12-08 23:04:16 +00:00
|
|
|
let Inst{26} = imm{11};
|
|
|
|
let Inst{25-24} = 0b10;
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{23-21} = op23_21;
|
|
|
|
let Inst{20} = 0; // The S bit.
|
2010-12-08 23:04:16 +00:00
|
|
|
let Inst{19-16} = Rn;
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{15} = 0;
|
2010-12-08 23:04:16 +00:00
|
|
|
let Inst{14-12} = imm{10-8};
|
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{7-0} = imm{7-0};
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2009-06-23 19:39:13 +00:00
|
|
|
// register
|
2011-09-02 18:14:46 +00:00
|
|
|
def rr : T2sThreeReg<(outs rGPR:$Rd), (ins GPRnopc:$Rn, rGPR:$Rm), IIC_iALUr,
|
2010-11-14 05:37:38 +00:00
|
|
|
opc, ".w\t$Rd, $Rn, $Rm",
|
2011-09-02 18:14:46 +00:00
|
|
|
[(set rGPR:$Rd, (opnode GPRnopc:$Rn, rGPR:$Rm))]> {
|
2009-06-26 00:19:44 +00:00
|
|
|
let isCommutable = Commutable;
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24} = 1;
|
|
|
|
let Inst{23-21} = op23_21;
|
|
|
|
let Inst{14-12} = 0b000; // imm3
|
|
|
|
let Inst{7-6} = 0b00; // imm2
|
|
|
|
let Inst{5-4} = 0b00; // type
|
2009-06-26 00:19:44 +00:00
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
// shifted register
|
2010-11-14 05:37:38 +00:00
|
|
|
def rs : T2sTwoRegShiftedReg<
|
2011-09-02 18:14:46 +00:00
|
|
|
(outs rGPR:$Rd), (ins GPRnopc:$Rn, t2_so_reg:$ShiftedRm),
|
2010-11-14 05:37:38 +00:00
|
|
|
IIC_iALUsi, opc, ".w\t$Rd, $Rn, $ShiftedRm",
|
2011-09-02 18:14:46 +00:00
|
|
|
[(set rGPR:$Rd, (opnode GPRnopc:$Rn, t2_so_reg:$ShiftedRm))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
2010-01-08 17:41:33 +00:00
|
|
|
let Inst{24} = 1;
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{23-21} = op23_21;
|
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
}
|
2009-06-17 18:13:58 +00:00
|
|
|
|
2009-11-24 00:20:27 +00:00
|
|
|
/// T2I_adde_sube_irs - Defines a set of (op reg, {so_imm|r|so_reg}) patterns
|
2010-02-16 20:42:29 +00:00
|
|
|
/// for a binary operation that produces a value and use the carry
|
2009-11-24 00:20:27 +00:00
|
|
|
/// bit. It's not predicable.
|
2011-08-30 01:34:54 +00:00
|
|
|
let Defs = [CPSR], Uses = [CPSR] in {
|
2010-02-16 21:23:02 +00:00
|
|
|
multiclass T2I_adde_sube_irs<bits<4> opcod, string opc, PatFrag opnode,
|
|
|
|
bit Commutable = 0> {
|
2009-06-23 17:48:47 +00:00
|
|
|
// shifted imm
|
2010-11-14 05:37:38 +00:00
|
|
|
def ri : T2sTwoRegImm<(outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_imm:$imm),
|
2010-11-12 21:12:40 +00:00
|
|
|
IIC_iALUi, opc, "\t$Rd, $Rn, $imm",
|
2011-08-30 01:34:54 +00:00
|
|
|
[(set rGPR:$Rd, CPSR, (opnode rGPR:$Rn, t2_so_imm:$imm, CPSR))]>,
|
2010-02-16 20:42:29 +00:00
|
|
|
Requires<[IsThumb2]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 0;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
2009-06-23 19:39:13 +00:00
|
|
|
// register
|
2010-11-14 05:37:38 +00:00
|
|
|
def rr : T2sThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iALUr,
|
2010-11-12 21:12:40 +00:00
|
|
|
opc, ".w\t$Rd, $Rn, $Rm",
|
2011-08-30 01:34:54 +00:00
|
|
|
[(set rGPR:$Rd, CPSR, (opnode rGPR:$Rn, rGPR:$Rm, CPSR))]>,
|
2010-02-16 20:42:29 +00:00
|
|
|
Requires<[IsThumb2]> {
|
2009-06-26 00:19:44 +00:00
|
|
|
let isCommutable = Commutable;
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{14-12} = 0b000; // imm3
|
|
|
|
let Inst{7-6} = 0b00; // imm2
|
|
|
|
let Inst{5-4} = 0b00; // type
|
2009-06-26 00:19:44 +00:00
|
|
|
}
|
2009-06-17 18:13:58 +00:00
|
|
|
// shifted register
|
2010-11-14 05:37:38 +00:00
|
|
|
def rs : T2sTwoRegShiftedReg<
|
2010-11-19 17:11:02 +00:00
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_reg:$ShiftedRm),
|
2010-11-12 21:12:40 +00:00
|
|
|
IIC_iALUsi, opc, ".w\t$Rd, $Rn, $ShiftedRm",
|
2011-08-30 01:34:54 +00:00
|
|
|
[(set rGPR:$Rd, CPSR, (opnode rGPR:$Rn, t2_so_reg:$ShiftedRm, CPSR))]>,
|
2010-02-16 20:42:29 +00:00
|
|
|
Requires<[IsThumb2]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
}
|
2010-02-16 20:42:29 +00:00
|
|
|
}
|
2011-04-23 03:55:32 +00:00
|
|
|
}
|
2010-02-16 20:42:29 +00:00
|
|
|
|
2010-08-13 23:24:25 +00:00
|
|
|
/// T2I_rbin_s_is - Same as T2I_rbin_irs except sets 's' bit and the register
|
|
|
|
/// version is not needed since this is only for codegen.
|
2011-09-06 18:52:20 +00:00
|
|
|
let hasPostISelHook = 1, isCodeGenOnly = 1, Defs = [CPSR] in {
|
2009-12-15 17:24:14 +00:00
|
|
|
multiclass T2I_rbin_s_is<bits<4> opcod, string opc, PatFrag opnode> {
|
2009-06-25 20:59:23 +00:00
|
|
|
// shifted imm
|
2011-09-06 18:52:20 +00:00
|
|
|
def ri : T2sTwoRegImm<
|
2010-11-14 05:37:38 +00:00
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_imm:$imm), IIC_iALUi,
|
2011-09-06 18:52:20 +00:00
|
|
|
opc, ".w\t$Rd, $Rn, $imm",
|
2011-08-30 01:34:54 +00:00
|
|
|
[(set rGPR:$Rd, CPSR, (opnode t2_so_imm:$imm, rGPR:$Rn))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 0;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
2009-06-25 20:59:23 +00:00
|
|
|
// shifted register
|
2011-09-06 18:52:20 +00:00
|
|
|
def rs : T2sTwoRegShiftedReg<
|
2010-11-14 05:37:38 +00:00
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_reg:$ShiftedRm),
|
2011-09-06 18:52:20 +00:00
|
|
|
IIC_iALUsi, opc, "\t$Rd, $Rn, $ShiftedRm",
|
2011-08-30 01:34:54 +00:00
|
|
|
[(set rGPR:$Rd, CPSR, (opnode t2_so_reg:$ShiftedRm, rGPR:$Rn))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-23 19:39:13 +00:00
|
|
|
/// T2I_sh_ir - Defines a set of (op reg, {so_imm|r}) patterns for a shift /
|
|
|
|
// rotate operation that produces a value.
|
2011-09-02 21:28:54 +00:00
|
|
|
multiclass T2I_sh_ir<bits<2> opcod, string opc, Operand ty, PatFrag opnode,
|
|
|
|
string baseOpc> {
|
2009-06-23 19:39:13 +00:00
|
|
|
// 5-bit imm
|
2010-11-15 19:58:36 +00:00
|
|
|
def ri : T2sTwoRegShiftImm<
|
2011-08-08 20:42:17 +00:00
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rm, ty:$imm), IIC_iMOVsi,
|
2010-11-15 19:58:36 +00:00
|
|
|
opc, ".w\t$Rd, $Rm, $imm",
|
2011-08-17 21:51:27 +00:00
|
|
|
[(set rGPR:$Rd, (opnode rGPR:$Rm, (i32 ty:$imm)))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-21} = 0b010010;
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{5-4} = opcod;
|
|
|
|
}
|
2009-06-23 19:39:13 +00:00
|
|
|
// register
|
2010-11-15 19:58:36 +00:00
|
|
|
def rr : T2sThreeReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMOVsr,
|
|
|
|
opc, ".w\t$Rd, $Rn, $Rm",
|
|
|
|
[(set rGPR:$Rd, (opnode rGPR:$Rn, rGPR:$Rm))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0100;
|
|
|
|
let Inst{22-21} = opcod;
|
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
let Inst{7-4} = 0b0000;
|
|
|
|
}
|
2011-09-02 21:28:54 +00:00
|
|
|
|
|
|
|
// Optional destination register
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", ".w $Rdn, $imm"),
|
|
|
|
(!cast<Instruction>(!strconcat(baseOpc, "ri")) rGPR:$Rdn, rGPR:$Rdn,
|
|
|
|
ty:$imm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", ".w $Rdn, $Rm"),
|
|
|
|
(!cast<Instruction>(!strconcat(baseOpc, "rr")) rGPR:$Rdn, rGPR:$Rdn,
|
|
|
|
rGPR:$Rm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
|
|
|
|
|
|
|
// Assembler aliases w/o the ".w" suffix.
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", " $Rd, $Rn, $imm"),
|
|
|
|
(!cast<Instruction>(!strconcat(baseOpc, "ri")) rGPR:$Rd, rGPR:$Rn,
|
|
|
|
ty:$imm, pred:$p,
|
2011-09-06 21:44:58 +00:00
|
|
|
cc_out:$s)>;
|
2011-09-02 21:28:54 +00:00
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", " $Rd, $Rn, $Rm"),
|
|
|
|
(!cast<Instruction>(!strconcat(baseOpc, "rr")) rGPR:$Rd, rGPR:$Rn,
|
|
|
|
rGPR:$Rm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
|
|
|
|
|
|
|
// and with the optional destination operand, too.
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", " $Rdn, $imm"),
|
|
|
|
(!cast<Instruction>(!strconcat(baseOpc, "ri")) rGPR:$Rdn, rGPR:$Rdn,
|
|
|
|
ty:$imm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", " $Rdn, $Rm"),
|
|
|
|
(!cast<Instruction>(!strconcat(baseOpc, "rr")) rGPR:$Rdn, rGPR:$Rdn,
|
|
|
|
rGPR:$Rm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
2009-06-23 19:39:13 +00:00
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2009-12-15 17:24:14 +00:00
|
|
|
/// T2I_cmp_irs - Defines a set of (op r, {so_imm|r|so_reg}) cmp / test
|
2009-06-23 19:39:13 +00:00
|
|
|
/// patterns. Similar to T2I_bin_irs except the instruction does not produce
|
2009-06-23 17:48:47 +00:00
|
|
|
/// a explicit result, only implicitly set CPSR.
|
2010-09-29 00:49:25 +00:00
|
|
|
multiclass T2I_cmp_irs<bits<4> opcod, string opc,
|
|
|
|
InstrItinClass iii, InstrItinClass iir, InstrItinClass iis,
|
2011-09-06 21:44:58 +00:00
|
|
|
PatFrag opnode, string baseOpc> {
|
|
|
|
let isCompare = 1, Defs = [CPSR] in {
|
2009-06-23 17:48:47 +00:00
|
|
|
// shifted imm
|
2010-11-15 19:58:36 +00:00
|
|
|
def ri : T2OneRegCmpImm<
|
2011-09-06 21:44:58 +00:00
|
|
|
(outs), (ins GPRnopc:$Rn, t2_so_imm:$imm), iii,
|
2010-11-15 19:58:36 +00:00
|
|
|
opc, ".w\t$Rn, $imm",
|
2011-09-06 21:44:58 +00:00
|
|
|
[(opnode GPRnopc:$Rn, t2_so_imm:$imm)]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 0;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{20} = 1; // The S bit.
|
|
|
|
let Inst{15} = 0;
|
|
|
|
let Inst{11-8} = 0b1111; // Rd
|
|
|
|
}
|
2009-06-23 19:39:13 +00:00
|
|
|
// register
|
2010-11-15 19:58:36 +00:00
|
|
|
def rr : T2TwoRegCmp<
|
2011-09-06 21:44:58 +00:00
|
|
|
(outs), (ins GPRnopc:$Rn, rGPR:$Rm), iir,
|
2011-08-23 17:37:32 +00:00
|
|
|
opc, ".w\t$Rn, $Rm",
|
2011-09-06 21:44:58 +00:00
|
|
|
[(opnode GPRnopc:$Rn, rGPR:$Rm)]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{20} = 1; // The S bit.
|
|
|
|
let Inst{14-12} = 0b000; // imm3
|
|
|
|
let Inst{11-8} = 0b1111; // Rd
|
|
|
|
let Inst{7-6} = 0b00; // imm2
|
|
|
|
let Inst{5-4} = 0b00; // type
|
|
|
|
}
|
2009-06-17 18:13:58 +00:00
|
|
|
// shifted register
|
2010-11-15 19:58:36 +00:00
|
|
|
def rs : T2OneRegCmpShiftedReg<
|
2011-09-06 21:44:58 +00:00
|
|
|
(outs), (ins GPRnopc:$Rn, t2_so_reg:$ShiftedRm), iis,
|
2010-11-15 19:58:36 +00:00
|
|
|
opc, ".w\t$Rn, $ShiftedRm",
|
2011-09-06 21:44:58 +00:00
|
|
|
[(opnode GPRnopc:$Rn, t2_so_reg:$ShiftedRm)]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{20} = 1; // The S bit.
|
|
|
|
let Inst{11-8} = 0b1111; // Rd
|
|
|
|
}
|
2009-06-17 18:13:58 +00:00
|
|
|
}
|
2011-09-06 21:44:58 +00:00
|
|
|
|
|
|
|
// Assembler aliases w/o the ".w" suffix.
|
|
|
|
// No alias here for 'rr' version as not all instantiations of this
|
|
|
|
// multiclass want one (CMP in particular, does not).
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${p}", " $Rn, $imm"),
|
|
|
|
(!cast<Instruction>(!strconcat(baseOpc, "ri")) GPRnopc:$Rn,
|
|
|
|
t2_so_imm:$imm, pred:$p)>;
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${p}", " $Rn, $shift"),
|
|
|
|
(!cast<Instruction>(!strconcat(baseOpc, "rs")) GPRnopc:$Rn,
|
|
|
|
t2_so_reg:$shift,
|
|
|
|
pred:$p)>;
|
2009-06-17 18:13:58 +00:00
|
|
|
}
|
|
|
|
|
2009-06-30 02:15:48 +00:00
|
|
|
/// T2I_ld - Defines a set of (op r, {imm12|imm8|so_reg}) load patterns.
|
2010-09-30 01:08:25 +00:00
|
|
|
multiclass T2I_ld<bit signed, bits<2> opcod, string opc,
|
2011-08-11 20:40:40 +00:00
|
|
|
InstrItinClass iii, InstrItinClass iis, RegisterClass target,
|
|
|
|
PatFrag opnode> {
|
|
|
|
def i12 : T2Ii12<(outs target:$Rt), (ins t2addrmode_imm12:$addr), iii,
|
2010-11-29 22:44:32 +00:00
|
|
|
opc, ".w\t$Rt, $addr",
|
2011-08-11 20:40:40 +00:00
|
|
|
[(set target:$Rt, (opnode t2addrmode_imm12:$addr))]> {
|
2011-09-07 20:58:57 +00:00
|
|
|
bits<4> Rt;
|
|
|
|
bits<17> addr;
|
|
|
|
let Inst{31-25} = 0b1111100;
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{24} = signed;
|
|
|
|
let Inst{23} = 1;
|
|
|
|
let Inst{22-21} = opcod;
|
|
|
|
let Inst{20} = 1; // load
|
2010-11-30 22:45:47 +00:00
|
|
|
let Inst{19-16} = addr{16-13}; // Rn
|
2011-09-07 20:58:57 +00:00
|
|
|
let Inst{15-12} = Rt;
|
2010-11-30 22:45:47 +00:00
|
|
|
let Inst{11-0} = addr{11-0}; // imm
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2011-09-07 20:58:57 +00:00
|
|
|
def i8 : T2Ii8 <(outs target:$Rt), (ins t2addrmode_negimm8:$addr), iii,
|
2010-11-29 22:44:32 +00:00
|
|
|
opc, "\t$Rt, $addr",
|
2011-09-07 20:58:57 +00:00
|
|
|
[(set target:$Rt, (opnode t2addrmode_negimm8:$addr))]> {
|
|
|
|
bits<4> Rt;
|
|
|
|
bits<13> addr;
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-25} = 0b00;
|
|
|
|
let Inst{24} = signed;
|
|
|
|
let Inst{23} = 0;
|
|
|
|
let Inst{22-21} = opcod;
|
|
|
|
let Inst{20} = 1; // load
|
2011-09-07 20:58:57 +00:00
|
|
|
let Inst{19-16} = addr{12-9}; // Rn
|
|
|
|
let Inst{15-12} = Rt;
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{11} = 1;
|
|
|
|
// Offset: index==TRUE, wback==FALSE
|
|
|
|
let Inst{10} = 1; // The P bit.
|
2010-11-29 22:44:32 +00:00
|
|
|
let Inst{9} = addr{8}; // U
|
2011-09-07 20:58:57 +00:00
|
|
|
let Inst{8} = 0; // The W bit.
|
2010-11-29 22:44:32 +00:00
|
|
|
let Inst{7-0} = addr{7-0}; // imm
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2011-08-11 20:40:40 +00:00
|
|
|
def s : T2Iso <(outs target:$Rt), (ins t2addrmode_so_reg:$addr), iis,
|
2010-11-29 22:44:32 +00:00
|
|
|
opc, ".w\t$Rt, $addr",
|
2011-08-11 20:40:40 +00:00
|
|
|
[(set target:$Rt, (opnode t2addrmode_so_reg:$addr))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-25} = 0b00;
|
|
|
|
let Inst{24} = signed;
|
|
|
|
let Inst{23} = 0;
|
|
|
|
let Inst{22-21} = opcod;
|
|
|
|
let Inst{20} = 1; // load
|
|
|
|
let Inst{11-6} = 0b000000;
|
2010-12-02 23:05:38 +00:00
|
|
|
|
2010-11-29 22:44:32 +00:00
|
|
|
bits<4> Rt;
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{15-12} = Rt;
|
2010-12-02 23:05:38 +00:00
|
|
|
|
2010-11-29 22:44:32 +00:00
|
|
|
bits<10> addr;
|
|
|
|
let Inst{19-16} = addr{9-6}; // Rn
|
|
|
|
let Inst{3-0} = addr{5-2}; // Rm
|
|
|
|
let Inst{5-4} = addr{1-0}; // imm
|
2011-08-09 20:55:18 +00:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeT2LoadShift";
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2010-11-03 05:14:24 +00:00
|
|
|
|
2011-02-08 22:39:40 +00:00
|
|
|
// FIXME: Is the pci variant actually needed?
|
2011-08-11 20:40:40 +00:00
|
|
|
def pci : T2Ipc <(outs target:$Rt), (ins t2ldrlabel:$addr), iii,
|
2011-02-08 22:39:40 +00:00
|
|
|
opc, ".w\t$Rt, $addr",
|
2011-08-11 20:40:40 +00:00
|
|
|
[(set target:$Rt, (opnode (ARMWrapper tconstpool:$addr)))]> {
|
2011-02-08 22:39:40 +00:00
|
|
|
let isReMaterializable = 1;
|
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-25} = 0b00;
|
|
|
|
let Inst{24} = signed;
|
|
|
|
let Inst{23} = ?; // add = (U == '1')
|
|
|
|
let Inst{22-21} = opcod;
|
|
|
|
let Inst{20} = 1; // load
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
bits<4> Rt;
|
|
|
|
bits<12> addr;
|
|
|
|
let Inst{15-12} = Rt{3-0};
|
|
|
|
let Inst{11-0} = addr{11-0};
|
|
|
|
}
|
2009-06-30 02:15:48 +00:00
|
|
|
}
|
|
|
|
|
2009-06-30 22:11:34 +00:00
|
|
|
/// T2I_st - Defines a set of (op r, {imm12|imm8|so_reg}) store patterns.
|
2010-09-30 01:08:25 +00:00
|
|
|
multiclass T2I_st<bits<2> opcod, string opc,
|
2011-08-11 20:40:40 +00:00
|
|
|
InstrItinClass iii, InstrItinClass iis, RegisterClass target,
|
|
|
|
PatFrag opnode> {
|
|
|
|
def i12 : T2Ii12<(outs), (ins target:$Rt, t2addrmode_imm12:$addr), iii,
|
2010-11-29 22:44:32 +00:00
|
|
|
opc, ".w\t$Rt, $addr",
|
2011-08-11 20:40:40 +00:00
|
|
|
[(opnode target:$Rt, t2addrmode_imm12:$addr)]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0001;
|
|
|
|
let Inst{22-21} = opcod;
|
|
|
|
let Inst{20} = 0; // !load
|
2010-12-02 23:05:38 +00:00
|
|
|
|
2010-11-29 22:44:32 +00:00
|
|
|
bits<4> Rt;
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{15-12} = Rt;
|
2010-12-02 23:05:38 +00:00
|
|
|
|
2010-11-30 22:45:47 +00:00
|
|
|
bits<17> addr;
|
2011-04-12 18:48:00 +00:00
|
|
|
let addr{12} = 1; // add = TRUE
|
2010-11-30 22:45:47 +00:00
|
|
|
let Inst{19-16} = addr{16-13}; // Rn
|
|
|
|
let Inst{23} = addr{12}; // U
|
|
|
|
let Inst{11-0} = addr{11-0}; // imm
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2011-09-07 20:58:57 +00:00
|
|
|
def i8 : T2Ii8 <(outs), (ins target:$Rt, t2addrmode_negimm8:$addr), iii,
|
2010-11-29 22:44:32 +00:00
|
|
|
opc, "\t$Rt, $addr",
|
2011-09-07 20:58:57 +00:00
|
|
|
[(opnode target:$Rt, t2addrmode_negimm8:$addr)]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0000;
|
|
|
|
let Inst{22-21} = opcod;
|
|
|
|
let Inst{20} = 0; // !load
|
|
|
|
let Inst{11} = 1;
|
|
|
|
// Offset: index==TRUE, wback==FALSE
|
|
|
|
let Inst{10} = 1; // The P bit.
|
|
|
|
let Inst{8} = 0; // The W bit.
|
2010-12-02 23:05:38 +00:00
|
|
|
|
2010-11-29 22:44:32 +00:00
|
|
|
bits<4> Rt;
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{15-12} = Rt;
|
2010-12-02 23:05:38 +00:00
|
|
|
|
2010-11-29 22:44:32 +00:00
|
|
|
bits<13> addr;
|
|
|
|
let Inst{19-16} = addr{12-9}; // Rn
|
|
|
|
let Inst{9} = addr{8}; // U
|
|
|
|
let Inst{7-0} = addr{7-0}; // imm
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2011-08-11 20:40:40 +00:00
|
|
|
def s : T2Iso <(outs), (ins target:$Rt, t2addrmode_so_reg:$addr), iis,
|
2010-11-29 22:44:32 +00:00
|
|
|
opc, ".w\t$Rt, $addr",
|
2011-08-11 20:40:40 +00:00
|
|
|
[(opnode target:$Rt, t2addrmode_so_reg:$addr)]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0000;
|
|
|
|
let Inst{22-21} = opcod;
|
|
|
|
let Inst{20} = 0; // !load
|
|
|
|
let Inst{11-6} = 0b000000;
|
2010-12-02 23:05:38 +00:00
|
|
|
|
2010-11-29 22:44:32 +00:00
|
|
|
bits<4> Rt;
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{15-12} = Rt;
|
2010-12-02 23:05:38 +00:00
|
|
|
|
2010-11-29 22:44:32 +00:00
|
|
|
bits<10> addr;
|
|
|
|
let Inst{19-16} = addr{9-6}; // Rn
|
|
|
|
let Inst{3-0} = addr{5-2}; // Rm
|
|
|
|
let Inst{5-4} = addr{1-0}; // imm
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2009-06-30 22:11:34 +00:00
|
|
|
}
|
|
|
|
|
2010-09-30 01:08:25 +00:00
|
|
|
/// T2I_ext_rrot - A unary operation with two forms: one whose operand is a
|
2009-07-03 01:43:10 +00:00
|
|
|
/// register and one whose operand is a register rotated by 8/16/24.
|
2011-07-27 16:47:19 +00:00
|
|
|
class T2I_ext_rrot<bits<3> opcod, string opc, PatFrag opnode>
|
|
|
|
: T2TwoReg<(outs rGPR:$Rd), (ins rGPR:$Rm, rot_imm:$rot), IIC_iEXTr,
|
|
|
|
opc, ".w\t$Rd, $Rm$rot",
|
2011-08-08 19:49:37 +00:00
|
|
|
[(set rGPR:$Rd, (opnode (rotr rGPR:$Rm, rot_imm:$rot)))]>,
|
|
|
|
Requires<[IsThumb2]> {
|
2011-07-27 16:47:19 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0100;
|
|
|
|
let Inst{22-20} = opcod;
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
let Inst{7} = 1;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2011-07-27 16:47:19 +00:00
|
|
|
bits<2> rot;
|
|
|
|
let Inst{5-4} = rot{1-0}; // rotate
|
2009-07-03 01:43:10 +00:00
|
|
|
}
|
|
|
|
|
2010-06-24 18:20:04 +00:00
|
|
|
// UXTB16 - Requres T2ExtractPack, does not need the .w qualifier.
|
2011-07-27 17:48:13 +00:00
|
|
|
class T2I_ext_rrot_uxtb16<bits<3> opcod, string opc, PatFrag opnode>
|
2011-08-23 17:37:32 +00:00
|
|
|
: T2TwoReg<(outs rGPR:$Rd), (ins rGPR:$Rm, rot_imm:$rot),
|
|
|
|
IIC_iEXTr, opc, "\t$Rd, $Rm$rot",
|
|
|
|
[(set rGPR:$Rd, (opnode (rotr rGPR:$Rm, rot_imm:$rot)))]>,
|
2011-07-27 17:48:13 +00:00
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]> {
|
|
|
|
bits<2> rot;
|
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0100;
|
|
|
|
let Inst{22-20} = opcod;
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
let Inst{7} = 1;
|
|
|
|
let Inst{5-4} = rot;
|
2010-03-04 22:24:41 +00:00
|
|
|
}
|
|
|
|
|
2010-06-24 18:20:04 +00:00
|
|
|
// SXTB16 - Requres T2ExtractPack, does not need the .w qualifier, no pattern
|
|
|
|
// supported yet.
|
2011-07-27 17:48:13 +00:00
|
|
|
class T2I_ext_rrot_sxtb16<bits<3> opcod, string opc>
|
|
|
|
: T2TwoReg<(outs rGPR:$Rd), (ins rGPR:$Rm, rot_imm:$rot), IIC_iEXTr,
|
|
|
|
opc, "\t$Rd, $Rm$rot", []>,
|
2011-07-01 21:12:19 +00:00
|
|
|
Requires<[IsThumb2, HasT2ExtractPack]> {
|
2011-07-27 17:48:13 +00:00
|
|
|
bits<2> rot;
|
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0100;
|
|
|
|
let Inst{22-20} = opcod;
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
let Inst{7} = 1;
|
|
|
|
let Inst{5-4} = rot;
|
Added 32-bit Thumb instructions: CPS, SDIV, UDIV, SXTB16, SXTAB16, UXTAB16, SEL,
SMMULR, SMMLAR, SMMLSR, TBB, TBH, and 16-bit Thumb instruction CPS for
disassembly only.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97573 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-02 18:14:57 +00:00
|
|
|
}
|
|
|
|
|
2010-09-30 01:08:25 +00:00
|
|
|
/// T2I_exta_rrot - A binary operation with two forms: one whose operand is a
|
2009-07-03 01:43:10 +00:00
|
|
|
/// register and one whose operand is a register rotated by 8/16/24.
|
2011-07-27 17:48:13 +00:00
|
|
|
class T2I_exta_rrot<bits<3> opcod, string opc, PatFrag opnode>
|
|
|
|
: T2ThreeReg<(outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rn, rGPR:$Rm, rot_imm:$rot),
|
|
|
|
IIC_iEXTAsr, opc, "\t$Rd, $Rn, $Rm$rot",
|
|
|
|
[(set rGPR:$Rd, (opnode rGPR:$Rn, (rotr rGPR:$Rm,rot_imm:$rot)))]>,
|
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]> {
|
|
|
|
bits<2> rot;
|
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0100;
|
|
|
|
let Inst{22-20} = opcod;
|
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
let Inst{7} = 1;
|
|
|
|
let Inst{5-4} = rot;
|
2009-07-03 01:43:10 +00:00
|
|
|
}
|
|
|
|
|
2011-07-27 17:48:13 +00:00
|
|
|
class T2I_exta_rrot_np<bits<3> opcod, string opc>
|
|
|
|
: T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm,rot_imm:$rot),
|
|
|
|
IIC_iEXTAsr, opc, "\t$Rd, $Rn, $Rm$rot", []> {
|
|
|
|
bits<2> rot;
|
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0100;
|
|
|
|
let Inst{22-20} = opcod;
|
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
let Inst{7} = 1;
|
|
|
|
let Inst{5-4} = rot;
|
Added 32-bit Thumb instructions: CPS, SDIV, UDIV, SXTB16, SXTAB16, UXTAB16, SEL,
SMMULR, SMMLAR, SMMLSR, TBB, TBH, and 16-bit Thumb instruction CPS for
disassembly only.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97573 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-02 18:14:57 +00:00
|
|
|
}
|
|
|
|
|
2009-06-27 02:26:13 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Instructions
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-06-24 23:47:58 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Miscellaneous Instructions.
|
|
|
|
//
|
|
|
|
|
2010-11-15 21:30:39 +00:00
|
|
|
class T2PCOneRegImm<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string asm, list<dag> pattern>
|
|
|
|
: T2XI<oops, iops, itin, asm, pattern> {
|
|
|
|
bits<4> Rd;
|
|
|
|
bits<12> label;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-15 21:30:39 +00:00
|
|
|
let Inst{26} = label{11};
|
|
|
|
let Inst{14-12} = label{10-8};
|
|
|
|
let Inst{7-0} = label{7-0};
|
|
|
|
}
|
|
|
|
|
2009-06-24 23:47:58 +00:00
|
|
|
// LEApcrel - Load a pc-relative address into a register without offending the
|
|
|
|
// assembler.
|
2010-12-14 00:36:49 +00:00
|
|
|
def t2ADR : T2PCOneRegImm<(outs rGPR:$Rd),
|
|
|
|
(ins t2adrlabel:$addr, pred:$p),
|
2011-09-09 22:24:36 +00:00
|
|
|
IIC_iALUi, "adr{$p}.w\t$Rd, $addr", []> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25-24} = 0b10;
|
|
|
|
// Inst{23:21} = '11' (add = FALSE) or '00' (add = TRUE)
|
|
|
|
let Inst{22} = 0;
|
|
|
|
let Inst{20} = 0;
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{15} = 0;
|
2010-12-14 20:46:39 +00:00
|
|
|
|
2010-12-14 00:36:49 +00:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<13> addr;
|
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{23} = addr{12};
|
|
|
|
let Inst{21} = addr{12};
|
|
|
|
let Inst{26} = addr{11};
|
|
|
|
let Inst{14-12} = addr{10-8};
|
|
|
|
let Inst{7-0} = addr{7-0};
|
2011-09-09 22:24:36 +00:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeT2Adr";
|
2010-12-13 22:51:08 +00:00
|
|
|
}
|
2010-12-14 00:36:49 +00:00
|
|
|
|
|
|
|
let neverHasSideEffects = 1, isReMaterializable = 1 in
|
2010-12-15 18:48:45 +00:00
|
|
|
def t2LEApcrel : t2PseudoInst<(outs rGPR:$Rd), (ins i32imm:$label, pred:$p),
|
2011-07-13 23:22:26 +00:00
|
|
|
4, IIC_iALUi, []>;
|
2010-12-15 18:48:45 +00:00
|
|
|
def t2LEApcrelJT : t2PseudoInst<(outs rGPR:$Rd),
|
|
|
|
(ins i32imm:$label, nohash_imm:$id, pred:$p),
|
2011-07-13 23:22:26 +00:00
|
|
|
4, IIC_iALUi,
|
2010-12-15 18:48:45 +00:00
|
|
|
[]>;
|
2009-06-24 23:47:58 +00:00
|
|
|
|
2010-12-08 23:30:19 +00:00
|
|
|
|
2009-06-27 02:26:13 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Load / store Instructions.
|
|
|
|
//
|
|
|
|
|
2009-06-29 07:51:04 +00:00
|
|
|
// Load
|
2010-02-27 23:47:46 +00:00
|
|
|
let canFoldAsLoad = 1, isReMaterializable = 1 in
|
2011-08-11 20:40:40 +00:00
|
|
|
defm t2LDR : T2I_ld<0, 0b10, "ldr", IIC_iLoad_i, IIC_iLoad_si, GPR,
|
2010-09-30 01:08:25 +00:00
|
|
|
UnOpFrag<(load node:$Src)>>;
|
2009-06-30 02:15:48 +00:00
|
|
|
|
|
|
|
// Loads with zero extension
|
2010-10-28 06:47:08 +00:00
|
|
|
defm t2LDRH : T2I_ld<0, 0b01, "ldrh", IIC_iLoad_bh_i, IIC_iLoad_bh_si,
|
2011-08-11 20:40:40 +00:00
|
|
|
rGPR, UnOpFrag<(zextloadi16 node:$Src)>>;
|
2010-10-28 06:47:08 +00:00
|
|
|
defm t2LDRB : T2I_ld<0, 0b00, "ldrb", IIC_iLoad_bh_i, IIC_iLoad_bh_si,
|
2011-08-11 20:40:40 +00:00
|
|
|
rGPR, UnOpFrag<(zextloadi8 node:$Src)>>;
|
2009-06-30 02:15:48 +00:00
|
|
|
|
|
|
|
// Loads with sign extension
|
2010-10-28 06:47:08 +00:00
|
|
|
defm t2LDRSH : T2I_ld<1, 0b01, "ldrsh", IIC_iLoad_bh_i, IIC_iLoad_bh_si,
|
2011-08-11 20:40:40 +00:00
|
|
|
rGPR, UnOpFrag<(sextloadi16 node:$Src)>>;
|
2010-10-28 06:47:08 +00:00
|
|
|
defm t2LDRSB : T2I_ld<1, 0b00, "ldrsb", IIC_iLoad_bh_i, IIC_iLoad_bh_si,
|
2011-08-11 20:40:40 +00:00
|
|
|
rGPR, UnOpFrag<(sextloadi8 node:$Src)>>;
|
2009-06-30 02:15:48 +00:00
|
|
|
|
2010-12-01 19:18:46 +00:00
|
|
|
let mayLoad = 1, neverHasSideEffects = 1, hasExtraDefRegAllocReq = 1 in {
|
2009-06-30 02:15:48 +00:00
|
|
|
// Load doubleword
|
2010-12-01 19:18:46 +00:00
|
|
|
def t2LDRDi8 : T2Ii8s4<1, 0, 1, (outs rGPR:$Rt, rGPR:$Rt2),
|
2009-09-27 09:46:04 +00:00
|
|
|
(ins t2addrmode_imm8s4:$addr),
|
2011-09-08 22:07:06 +00:00
|
|
|
IIC_iLoad_d_i, "ldrd", "\t$Rt, $Rt2, $addr", "", []>;
|
2010-05-19 06:07:03 +00:00
|
|
|
} // mayLoad = 1, neverHasSideEffects = 1, hasExtraDefRegAllocReq = 1
|
2009-06-30 02:15:48 +00:00
|
|
|
|
|
|
|
// zextload i1 -> zextload i8
|
|
|
|
def : T2Pat<(zextloadi1 t2addrmode_imm12:$addr),
|
|
|
|
(t2LDRBi12 t2addrmode_imm12:$addr)>;
|
2011-09-07 20:58:57 +00:00
|
|
|
def : T2Pat<(zextloadi1 t2addrmode_negimm8:$addr),
|
|
|
|
(t2LDRBi8 t2addrmode_negimm8:$addr)>;
|
2009-06-30 02:15:48 +00:00
|
|
|
def : T2Pat<(zextloadi1 t2addrmode_so_reg:$addr),
|
|
|
|
(t2LDRBs t2addrmode_so_reg:$addr)>;
|
|
|
|
def : T2Pat<(zextloadi1 (ARMWrapper tconstpool:$addr)),
|
|
|
|
(t2LDRBpci tconstpool:$addr)>;
|
|
|
|
|
|
|
|
// extload -> zextload
|
|
|
|
// FIXME: Reduce the number of patterns by legalizing extload to zextload
|
|
|
|
// earlier?
|
|
|
|
def : T2Pat<(extloadi1 t2addrmode_imm12:$addr),
|
|
|
|
(t2LDRBi12 t2addrmode_imm12:$addr)>;
|
2011-09-07 20:58:57 +00:00
|
|
|
def : T2Pat<(extloadi1 t2addrmode_negimm8:$addr),
|
|
|
|
(t2LDRBi8 t2addrmode_negimm8:$addr)>;
|
2009-06-30 02:15:48 +00:00
|
|
|
def : T2Pat<(extloadi1 t2addrmode_so_reg:$addr),
|
|
|
|
(t2LDRBs t2addrmode_so_reg:$addr)>;
|
|
|
|
def : T2Pat<(extloadi1 (ARMWrapper tconstpool:$addr)),
|
|
|
|
(t2LDRBpci tconstpool:$addr)>;
|
|
|
|
|
|
|
|
def : T2Pat<(extloadi8 t2addrmode_imm12:$addr),
|
|
|
|
(t2LDRBi12 t2addrmode_imm12:$addr)>;
|
2011-09-07 20:58:57 +00:00
|
|
|
def : T2Pat<(extloadi8 t2addrmode_negimm8:$addr),
|
|
|
|
(t2LDRBi8 t2addrmode_negimm8:$addr)>;
|
2009-06-30 02:15:48 +00:00
|
|
|
def : T2Pat<(extloadi8 t2addrmode_so_reg:$addr),
|
|
|
|
(t2LDRBs t2addrmode_so_reg:$addr)>;
|
|
|
|
def : T2Pat<(extloadi8 (ARMWrapper tconstpool:$addr)),
|
|
|
|
(t2LDRBpci tconstpool:$addr)>;
|
|
|
|
|
|
|
|
def : T2Pat<(extloadi16 t2addrmode_imm12:$addr),
|
|
|
|
(t2LDRHi12 t2addrmode_imm12:$addr)>;
|
2011-09-07 20:58:57 +00:00
|
|
|
def : T2Pat<(extloadi16 t2addrmode_negimm8:$addr),
|
|
|
|
(t2LDRHi8 t2addrmode_negimm8:$addr)>;
|
2009-06-30 02:15:48 +00:00
|
|
|
def : T2Pat<(extloadi16 t2addrmode_so_reg:$addr),
|
|
|
|
(t2LDRHs t2addrmode_so_reg:$addr)>;
|
|
|
|
def : T2Pat<(extloadi16 (ARMWrapper tconstpool:$addr)),
|
|
|
|
(t2LDRHpci tconstpool:$addr)>;
|
2009-06-29 07:51:04 +00:00
|
|
|
|
Many Thumb2 instructions can reference the full ARM register set (i.e.,
have 4 bits per register in the operand encoding), but have undefined
behavior when the operand value is 13 or 15 (SP and PC, respectively).
The trivial coalescer in linear scan sometimes will merge a copy from
SP into a subsequent instruction which uses the copy, and if that
instruction cannot legally reference SP, we get bad code such as:
mls r0,r9,r0,sp
instead of:
mov r2, sp
mls r0, r9, r0, r2
This patch adds a new register class for use by Thumb2 that excludes
the problematic registers (SP and PC) and is used instead of GPR
for those operands which cannot legally reference PC or SP. The
trivial coalescer explicitly requires that the register class
of the destination for the COPY instruction contain the source
register for the COPY to be considered for coalescing. This prevents
errant instructions like that above.
PR7499
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@109842 91177308-0d34-0410-b5e6-96231b3b80d8
2010-07-30 02:41:01 +00:00
|
|
|
// FIXME: The destination register of the loads and stores can't be PC, but
|
|
|
|
// can be SP. We need another regclass (similar to rGPR) to represent
|
|
|
|
// that. Not a pressing issue since these are selected manually,
|
|
|
|
// not via pattern.
|
|
|
|
|
2009-07-02 07:28:31 +00:00
|
|
|
// Indexed loads
|
2010-11-30 00:14:31 +00:00
|
|
|
|
2010-05-19 06:07:03 +00:00
|
|
|
let mayLoad = 1, neverHasSideEffects = 1 in {
|
2011-09-08 00:39:19 +00:00
|
|
|
def t2LDR_PRE : T2Ipreldst<0, 0b10, 1, 1, (outs GPR:$Rt, GPR:$Rn_wb),
|
2009-07-02 07:28:31 +00:00
|
|
|
(ins t2addrmode_imm8:$addr),
|
2010-09-30 01:08:25 +00:00
|
|
|
AddrModeT2_i8, IndexModePre, IIC_iLoad_iu,
|
2011-09-08 00:39:19 +00:00
|
|
|
"ldr", "\t$Rt, $addr!", "$addr.base = $Rn_wb",
|
|
|
|
[]> {
|
|
|
|
let AsmMatchConverter = "cvtLdWriteBackRegT2AddrModeImm8";
|
|
|
|
}
|
2009-07-02 07:28:31 +00:00
|
|
|
|
2011-09-08 00:39:19 +00:00
|
|
|
def t2LDR_POST : T2Ipostldst<0, 0b10, 1, 0, (outs GPR:$Rt, GPR:$Rn_wb),
|
2011-09-08 01:01:32 +00:00
|
|
|
(ins addr_offset_none:$Rn, t2am_imm8_offset:$offset),
|
|
|
|
AddrModeT2_i8, IndexModePost, IIC_iLoad_iu,
|
|
|
|
"ldr", "\t$Rt, $Rn, $offset", "$Rn = $Rn_wb", []>;
|
2009-07-02 07:28:31 +00:00
|
|
|
|
2011-09-08 00:39:19 +00:00
|
|
|
def t2LDRB_PRE : T2Ipreldst<0, 0b00, 1, 1, (outs GPR:$Rt, GPR:$Rn_wb),
|
2009-07-02 07:28:31 +00:00
|
|
|
(ins t2addrmode_imm8:$addr),
|
2010-09-30 01:08:25 +00:00
|
|
|
AddrModeT2_i8, IndexModePre, IIC_iLoad_bh_iu,
|
2011-09-08 00:39:19 +00:00
|
|
|
"ldrb", "\t$Rt, $addr!", "$addr.base = $Rn_wb",
|
|
|
|
[]> {
|
|
|
|
let AsmMatchConverter = "cvtLdWriteBackRegT2AddrModeImm8";
|
|
|
|
}
|
|
|
|
def t2LDRB_POST : T2Ipostldst<0, 0b00, 1, 0, (outs GPR:$Rt, GPR:$Rn_wb),
|
2011-09-08 01:01:32 +00:00
|
|
|
(ins addr_offset_none:$Rn, t2am_imm8_offset:$offset),
|
|
|
|
AddrModeT2_i8, IndexModePost, IIC_iLoad_bh_iu,
|
|
|
|
"ldrb", "\t$Rt, $Rn, $offset", "$Rn = $Rn_wb", []>;
|
2009-07-02 07:28:31 +00:00
|
|
|
|
2011-09-08 00:39:19 +00:00
|
|
|
def t2LDRH_PRE : T2Ipreldst<0, 0b01, 1, 1, (outs GPR:$Rt, GPR:$Rn_wb),
|
2009-07-02 07:28:31 +00:00
|
|
|
(ins t2addrmode_imm8:$addr),
|
2010-09-30 01:08:25 +00:00
|
|
|
AddrModeT2_i8, IndexModePre, IIC_iLoad_bh_iu,
|
2011-09-08 00:39:19 +00:00
|
|
|
"ldrh", "\t$Rt, $addr!", "$addr.base = $Rn_wb",
|
|
|
|
[]> {
|
|
|
|
let AsmMatchConverter = "cvtLdWriteBackRegT2AddrModeImm8";
|
|
|
|
}
|
|
|
|
def t2LDRH_POST : T2Ipostldst<0, 0b01, 1, 0, (outs GPR:$Rt, GPR:$Rn_wb),
|
2011-09-08 01:01:32 +00:00
|
|
|
(ins addr_offset_none:$Rn, t2am_imm8_offset:$offset),
|
|
|
|
AddrModeT2_i8, IndexModePost, IIC_iLoad_bh_iu,
|
|
|
|
"ldrh", "\t$Rt, $Rn, $offset", "$Rn = $Rn_wb", []>;
|
2009-07-02 07:28:31 +00:00
|
|
|
|
2011-09-08 00:39:19 +00:00
|
|
|
def t2LDRSB_PRE : T2Ipreldst<1, 0b00, 1, 1, (outs GPR:$Rt, GPR:$Rn_wb),
|
2009-07-02 23:16:11 +00:00
|
|
|
(ins t2addrmode_imm8:$addr),
|
2010-09-30 01:08:25 +00:00
|
|
|
AddrModeT2_i8, IndexModePre, IIC_iLoad_bh_iu,
|
2011-09-08 00:39:19 +00:00
|
|
|
"ldrsb", "\t$Rt, $addr!", "$addr.base = $Rn_wb",
|
|
|
|
[]> {
|
|
|
|
let AsmMatchConverter = "cvtLdWriteBackRegT2AddrModeImm8";
|
|
|
|
}
|
|
|
|
def t2LDRSB_POST : T2Ipostldst<1, 0b00, 1, 0, (outs GPR:$Rt, GPR:$Rn_wb),
|
2011-09-08 01:01:32 +00:00
|
|
|
(ins addr_offset_none:$Rn, t2am_imm8_offset:$offset),
|
|
|
|
AddrModeT2_i8, IndexModePost, IIC_iLoad_bh_iu,
|
|
|
|
"ldrsb", "\t$Rt, $Rn, $offset", "$Rn = $Rn_wb", []>;
|
2009-07-02 23:16:11 +00:00
|
|
|
|
2011-09-08 00:39:19 +00:00
|
|
|
def t2LDRSH_PRE : T2Ipreldst<1, 0b01, 1, 1, (outs GPR:$Rt, GPR:$Rn_wb),
|
2009-07-02 23:16:11 +00:00
|
|
|
(ins t2addrmode_imm8:$addr),
|
2010-09-30 01:08:25 +00:00
|
|
|
AddrModeT2_i8, IndexModePre, IIC_iLoad_bh_iu,
|
2011-09-08 00:39:19 +00:00
|
|
|
"ldrsh", "\t$Rt, $addr!", "$addr.base = $Rn_wb",
|
|
|
|
[]> {
|
|
|
|
let AsmMatchConverter = "cvtLdWriteBackRegT2AddrModeImm8";
|
|
|
|
}
|
|
|
|
def t2LDRSH_POST : T2Ipostldst<1, 0b01, 1, 0, (outs GPR:$Rt, GPR:$Rn_wb),
|
2011-09-08 01:01:32 +00:00
|
|
|
(ins addr_offset_none:$Rn, t2am_imm8_offset:$offset),
|
|
|
|
AddrModeT2_i8, IndexModePost, IIC_iLoad_bh_iu,
|
|
|
|
"ldrsh", "\t$Rt, $Rn, $offset", "$Rn = $Rn_wb", []>;
|
2010-11-19 17:11:02 +00:00
|
|
|
} // mayLoad = 1, neverHasSideEffects = 1
|
2009-07-02 23:16:11 +00:00
|
|
|
|
2011-09-07 23:39:14 +00:00
|
|
|
// LDRT, LDRBT, LDRHT, LDRSBT, LDRSHT all have offset mode (PUW=0b110).
|
2010-03-03 18:45:36 +00:00
|
|
|
// Ref: A8.6.57 LDR (immediate, Thumb) Encoding T4
|
2010-09-30 01:08:25 +00:00
|
|
|
class T2IldT<bit signed, bits<2> type, string opc, InstrItinClass ii>
|
2011-09-07 23:39:14 +00:00
|
|
|
: T2Ii8<(outs rGPR:$Rt), (ins t2addrmode_posimm8:$addr), ii, opc,
|
2010-11-30 18:38:28 +00:00
|
|
|
"\t$Rt, $addr", []> {
|
2011-09-07 23:39:14 +00:00
|
|
|
bits<4> Rt;
|
|
|
|
bits<13> addr;
|
2010-03-03 18:45:36 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-25} = 0b00;
|
|
|
|
let Inst{24} = signed;
|
|
|
|
let Inst{23} = 0;
|
|
|
|
let Inst{22-21} = type;
|
|
|
|
let Inst{20} = 1; // load
|
2011-09-07 23:39:14 +00:00
|
|
|
let Inst{19-16} = addr{12-9};
|
|
|
|
let Inst{15-12} = Rt;
|
2010-03-03 18:45:36 +00:00
|
|
|
let Inst{11} = 1;
|
|
|
|
let Inst{10-8} = 0b110; // PUW.
|
2011-09-07 23:39:14 +00:00
|
|
|
let Inst{7-0} = addr{7-0};
|
2010-03-03 18:45:36 +00:00
|
|
|
}
|
|
|
|
|
2010-09-30 01:08:25 +00:00
|
|
|
def t2LDRT : T2IldT<0, 0b10, "ldrt", IIC_iLoad_i>;
|
|
|
|
def t2LDRBT : T2IldT<0, 0b00, "ldrbt", IIC_iLoad_bh_i>;
|
|
|
|
def t2LDRHT : T2IldT<0, 0b01, "ldrht", IIC_iLoad_bh_i>;
|
|
|
|
def t2LDRSBT : T2IldT<1, 0b00, "ldrsbt", IIC_iLoad_bh_i>;
|
|
|
|
def t2LDRSHT : T2IldT<1, 0b01, "ldrsht", IIC_iLoad_bh_i>;
|
2010-03-03 18:45:36 +00:00
|
|
|
|
2009-06-30 22:11:34 +00:00
|
|
|
// Store
|
2011-08-11 20:40:40 +00:00
|
|
|
defm t2STR :T2I_st<0b10,"str", IIC_iStore_i, IIC_iStore_si, GPR,
|
2010-09-30 01:08:25 +00:00
|
|
|
BinOpFrag<(store node:$LHS, node:$RHS)>>;
|
2010-10-28 06:47:08 +00:00
|
|
|
defm t2STRB:T2I_st<0b00,"strb", IIC_iStore_bh_i, IIC_iStore_bh_si,
|
2011-08-11 20:40:40 +00:00
|
|
|
rGPR, BinOpFrag<(truncstorei8 node:$LHS, node:$RHS)>>;
|
2010-10-28 06:47:08 +00:00
|
|
|
defm t2STRH:T2I_st<0b01,"strh", IIC_iStore_bh_i, IIC_iStore_bh_si,
|
2011-08-11 20:40:40 +00:00
|
|
|
rGPR, BinOpFrag<(truncstorei16 node:$LHS, node:$RHS)>>;
|
2009-06-30 22:11:34 +00:00
|
|
|
|
2009-06-30 22:50:01 +00:00
|
|
|
// Store doubleword
|
2010-12-01 19:18:46 +00:00
|
|
|
let mayLoad = 1, neverHasSideEffects = 1, hasExtraSrcRegAllocReq = 1 in
|
2009-12-15 17:24:14 +00:00
|
|
|
def t2STRDi8 : T2Ii8s4<1, 0, 0, (outs),
|
2010-12-01 19:18:46 +00:00
|
|
|
(ins GPR:$Rt, GPR:$Rt2, t2addrmode_imm8s4:$addr),
|
2011-09-08 22:07:06 +00:00
|
|
|
IIC_iStore_d_r, "strd", "\t$Rt, $Rt2, $addr", "", []>;
|
2009-06-30 22:50:01 +00:00
|
|
|
|
2009-07-03 00:06:39 +00:00
|
|
|
// Indexed stores
|
2011-09-08 00:39:19 +00:00
|
|
|
def t2STR_PRE : T2Ipreldst<0, 0b10, 0, 1, (outs GPRnopc:$Rn_wb),
|
2011-09-16 21:55:56 +00:00
|
|
|
(ins rGPR:$Rt, t2addrmode_imm8:$addr),
|
2010-09-30 01:08:25 +00:00
|
|
|
AddrModeT2_i8, IndexModePre, IIC_iStore_iu,
|
2011-09-16 21:55:56 +00:00
|
|
|
"str", "\t$Rt, $addr!",
|
|
|
|
"$addr.base = $Rn_wb,@earlyclobber $Rn_wb", []> {
|
|
|
|
let AsmMatchConverter = "cvtStWriteBackRegT2AddrModeImm8";
|
|
|
|
}
|
|
|
|
def t2STRH_PRE : T2Ipreldst<0, 0b01, 0, 1, (outs GPRnopc:$Rn_wb),
|
|
|
|
(ins rGPR:$Rt, t2addrmode_imm8:$addr),
|
|
|
|
AddrModeT2_i8, IndexModePre, IIC_iStore_iu,
|
|
|
|
"strh", "\t$Rt, $addr!",
|
|
|
|
"$addr.base = $Rn_wb,@earlyclobber $Rn_wb", []> {
|
|
|
|
let AsmMatchConverter = "cvtStWriteBackRegT2AddrModeImm8";
|
|
|
|
}
|
|
|
|
|
|
|
|
def t2STRB_PRE : T2Ipreldst<0, 0b00, 0, 1, (outs GPRnopc:$Rn_wb),
|
|
|
|
(ins rGPR:$Rt, t2addrmode_imm8:$addr),
|
|
|
|
AddrModeT2_i8, IndexModePre, IIC_iStore_bh_iu,
|
|
|
|
"strb", "\t$Rt, $addr!",
|
|
|
|
"$addr.base = $Rn_wb,@earlyclobber $Rn_wb", []> {
|
|
|
|
let AsmMatchConverter = "cvtStWriteBackRegT2AddrModeImm8";
|
|
|
|
}
|
2009-07-03 00:06:39 +00:00
|
|
|
|
2011-09-08 00:39:19 +00:00
|
|
|
def t2STR_POST : T2Ipostldst<0, 0b10, 0, 0, (outs GPRnopc:$Rn_wb),
|
2011-09-16 21:09:00 +00:00
|
|
|
(ins rGPR:$Rt, addr_offset_none:$Rn,
|
|
|
|
t2am_imm8_offset:$offset),
|
2010-09-30 01:08:25 +00:00
|
|
|
AddrModeT2_i8, IndexModePost, IIC_iStore_iu,
|
2011-09-08 01:01:32 +00:00
|
|
|
"str", "\t$Rt, $Rn, $offset",
|
2011-09-08 00:39:19 +00:00
|
|
|
"$Rn = $Rn_wb,@earlyclobber $Rn_wb",
|
|
|
|
[(set GPRnopc:$Rn_wb,
|
2011-09-16 21:09:00 +00:00
|
|
|
(post_store rGPR:$Rt, addr_offset_none:$Rn,
|
|
|
|
t2am_imm8_offset:$offset))]>;
|
2009-07-03 00:06:39 +00:00
|
|
|
|
2011-09-08 00:39:19 +00:00
|
|
|
def t2STRH_POST : T2Ipostldst<0, 0b01, 0, 0, (outs GPRnopc:$Rn_wb),
|
2011-09-16 21:09:00 +00:00
|
|
|
(ins rGPR:$Rt, addr_offset_none:$Rn,
|
|
|
|
t2am_imm8_offset:$offset),
|
2010-09-30 01:08:25 +00:00
|
|
|
AddrModeT2_i8, IndexModePost, IIC_iStore_bh_iu,
|
2011-09-08 01:01:32 +00:00
|
|
|
"strh", "\t$Rt, $Rn, $offset",
|
2011-09-08 00:39:19 +00:00
|
|
|
"$Rn = $Rn_wb,@earlyclobber $Rn_wb",
|
|
|
|
[(set GPRnopc:$Rn_wb,
|
2011-09-16 21:09:00 +00:00
|
|
|
(post_truncsti16 rGPR:$Rt, addr_offset_none:$Rn,
|
|
|
|
t2am_imm8_offset:$offset))]>;
|
2009-07-03 00:06:39 +00:00
|
|
|
|
2011-09-08 00:39:19 +00:00
|
|
|
def t2STRB_POST : T2Ipostldst<0, 0b00, 0, 0, (outs GPRnopc:$Rn_wb),
|
2011-09-16 21:09:00 +00:00
|
|
|
(ins rGPR:$Rt, addr_offset_none:$Rn,
|
|
|
|
t2am_imm8_offset:$offset),
|
2010-09-30 01:08:25 +00:00
|
|
|
AddrModeT2_i8, IndexModePost, IIC_iStore_bh_iu,
|
2011-09-08 01:01:32 +00:00
|
|
|
"strb", "\t$Rt, $Rn, $offset",
|
2011-09-08 00:39:19 +00:00
|
|
|
"$Rn = $Rn_wb,@earlyclobber $Rn_wb",
|
|
|
|
[(set GPRnopc:$Rn_wb,
|
2011-09-16 21:09:00 +00:00
|
|
|
(post_truncsti8 rGPR:$Rt, addr_offset_none:$Rn,
|
|
|
|
t2am_imm8_offset:$offset))]>;
|
2009-07-03 00:06:39 +00:00
|
|
|
|
2011-09-16 21:55:56 +00:00
|
|
|
// Pseudo-instructions for pattern matching the pre-indexed stores. We can't
|
|
|
|
// put the patterns on the instruction definitions directly as ISel wants
|
|
|
|
// the address base and offset to be separate operands, not a single
|
|
|
|
// complex operand like we represent the instructions themselves. The
|
|
|
|
// pseudos map between the two.
|
|
|
|
let usesCustomInserter = 1,
|
|
|
|
Constraints = "$Rn = $Rn_wb,@earlyclobber $Rn_wb" in {
|
|
|
|
def t2STR_preidx: t2PseudoInst<(outs GPRnopc:$Rn_wb),
|
|
|
|
(ins rGPR:$Rt, GPRnopc:$Rn, t2am_imm8_offset:$offset, pred:$p),
|
|
|
|
4, IIC_iStore_ru,
|
|
|
|
[(set GPRnopc:$Rn_wb,
|
|
|
|
(pre_store rGPR:$Rt, GPRnopc:$Rn, t2am_imm8_offset:$offset))]>;
|
|
|
|
def t2STRB_preidx: t2PseudoInst<(outs GPRnopc:$Rn_wb),
|
|
|
|
(ins rGPR:$Rt, GPRnopc:$Rn, t2am_imm8_offset:$offset, pred:$p),
|
|
|
|
4, IIC_iStore_ru,
|
|
|
|
[(set GPRnopc:$Rn_wb,
|
|
|
|
(pre_truncsti8 rGPR:$Rt, GPRnopc:$Rn, t2am_imm8_offset:$offset))]>;
|
|
|
|
def t2STRH_preidx: t2PseudoInst<(outs GPRnopc:$Rn_wb),
|
|
|
|
(ins rGPR:$Rt, GPRnopc:$Rn, t2am_imm8_offset:$offset, pred:$p),
|
|
|
|
4, IIC_iStore_ru,
|
|
|
|
[(set GPRnopc:$Rn_wb,
|
|
|
|
(pre_truncsti16 rGPR:$Rt, GPRnopc:$Rn, t2am_imm8_offset:$offset))]>;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-03-03 18:45:36 +00:00
|
|
|
// STRT, STRBT, STRHT all have offset mode (PUW=0b110) and are for disassembly
|
|
|
|
// only.
|
|
|
|
// Ref: A8.6.193 STR (immediate, Thumb) Encoding T4
|
2010-09-30 01:08:25 +00:00
|
|
|
class T2IstT<bits<2> type, string opc, InstrItinClass ii>
|
2011-04-13 21:04:32 +00:00
|
|
|
: T2Ii8<(outs rGPR:$Rt), (ins t2addrmode_imm8:$addr), ii, opc,
|
2010-11-30 18:38:28 +00:00
|
|
|
"\t$Rt, $addr", []> {
|
2010-03-03 18:45:36 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-25} = 0b00;
|
|
|
|
let Inst{24} = 0; // not signed
|
|
|
|
let Inst{23} = 0;
|
|
|
|
let Inst{22-21} = type;
|
|
|
|
let Inst{20} = 0; // store
|
|
|
|
let Inst{11} = 1;
|
|
|
|
let Inst{10-8} = 0b110; // PUW
|
2010-12-02 23:05:38 +00:00
|
|
|
|
2010-11-30 18:38:28 +00:00
|
|
|
bits<4> Rt;
|
|
|
|
bits<13> addr;
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{15-12} = Rt;
|
2010-11-30 18:38:28 +00:00
|
|
|
let Inst{19-16} = addr{12-9};
|
|
|
|
let Inst{7-0} = addr{7-0};
|
2010-03-03 18:45:36 +00:00
|
|
|
}
|
|
|
|
|
2010-09-30 01:08:25 +00:00
|
|
|
def t2STRT : T2IstT<0b10, "strt", IIC_iStore_i>;
|
|
|
|
def t2STRBT : T2IstT<0b00, "strbt", IIC_iStore_bh_i>;
|
|
|
|
def t2STRHT : T2IstT<0b01, "strht", IIC_iStore_bh_i>;
|
2009-07-01 00:01:13 +00:00
|
|
|
|
2010-03-11 01:13:36 +00:00
|
|
|
// ldrd / strd pre / post variants
|
|
|
|
// For disassembly only.
|
|
|
|
|
2011-09-08 22:07:06 +00:00
|
|
|
def t2LDRD_PRE : T2Ii8s4<1, 1, 1, (outs rGPR:$Rt, rGPR:$Rt2, GPR:$wb),
|
|
|
|
(ins t2addrmode_imm8s4:$addr), IIC_iLoad_d_ru,
|
|
|
|
"ldrd", "\t$Rt, $Rt2, $addr!", "$addr.base = $wb", []> {
|
|
|
|
let AsmMatchConverter = "cvtT2LdrdPre";
|
|
|
|
let DecoderMethod = "DecodeT2LDRDPreInstruction";
|
|
|
|
}
|
2010-03-11 01:13:36 +00:00
|
|
|
|
2011-09-08 22:07:06 +00:00
|
|
|
def t2LDRD_POST : T2Ii8s4post<0, 1, 1, (outs rGPR:$Rt, rGPR:$Rt2, GPR:$wb),
|
|
|
|
(ins addr_offset_none:$addr, t2am_imm8s4_offset:$imm),
|
2011-09-13 20:46:26 +00:00
|
|
|
IIC_iLoad_d_ru, "ldrd", "\t$Rt, $Rt2, $addr$imm",
|
2011-09-08 22:07:06 +00:00
|
|
|
"$addr.base = $wb", []>;
|
2010-03-11 01:13:36 +00:00
|
|
|
|
2011-09-08 22:07:06 +00:00
|
|
|
def t2STRD_PRE : T2Ii8s4<1, 1, 0, (outs GPR:$wb),
|
|
|
|
(ins rGPR:$Rt, rGPR:$Rt2, t2addrmode_imm8s4:$addr),
|
|
|
|
IIC_iStore_d_ru, "strd", "\t$Rt, $Rt2, $addr!",
|
|
|
|
"$addr.base = $wb", []> {
|
|
|
|
let AsmMatchConverter = "cvtT2StrdPre";
|
|
|
|
let DecoderMethod = "DecodeT2STRDPreInstruction";
|
|
|
|
}
|
2010-03-11 01:13:36 +00:00
|
|
|
|
2011-09-08 22:07:06 +00:00
|
|
|
def t2STRD_POST : T2Ii8s4post<0, 1, 0, (outs GPR:$wb),
|
|
|
|
(ins rGPR:$Rt, rGPR:$Rt2, addr_offset_none:$addr,
|
|
|
|
t2am_imm8s4_offset:$imm),
|
2011-09-13 20:46:26 +00:00
|
|
|
IIC_iStore_d_ru, "strd", "\t$Rt, $Rt2, $addr$imm",
|
2011-09-08 22:07:06 +00:00
|
|
|
"$addr.base = $wb", []>;
|
2009-07-03 00:18:36 +00:00
|
|
|
|
2010-03-04 17:40:44 +00:00
|
|
|
// T2Ipl (Preload Data/Instruction) signals the memory system of possible future
|
|
|
|
// data/instruction access. These are for disassembly only.
|
2010-11-03 06:34:55 +00:00
|
|
|
// instr_write is inverted for Thumb mode: (prefetch 3) -> (preload 0),
|
|
|
|
// (prefetch 1) -> (preload 2), (prefetch 2) -> (preload 1).
|
2010-11-04 05:19:35 +00:00
|
|
|
multiclass T2Ipl<bits<1> write, bits<1> instr, string opc> {
|
2010-03-04 17:40:44 +00:00
|
|
|
|
2010-11-03 06:34:55 +00:00
|
|
|
def i12 : T2Ii12<(outs), (ins t2addrmode_imm12:$addr), IIC_Preload, opc,
|
2010-11-03 05:14:24 +00:00
|
|
|
"\t$addr",
|
2010-11-04 05:19:35 +00:00
|
|
|
[(ARMPreload t2addrmode_imm12:$addr, (i32 write), (i32 instr))]> {
|
2010-03-04 17:40:44 +00:00
|
|
|
let Inst{31-25} = 0b1111100;
|
2010-11-04 05:19:35 +00:00
|
|
|
let Inst{24} = instr;
|
2010-03-04 17:40:44 +00:00
|
|
|
let Inst{22} = 0;
|
2010-11-04 05:19:35 +00:00
|
|
|
let Inst{21} = write;
|
2010-03-04 17:40:44 +00:00
|
|
|
let Inst{20} = 1;
|
|
|
|
let Inst{15-12} = 0b1111;
|
2010-12-02 23:05:38 +00:00
|
|
|
|
2010-11-30 22:45:47 +00:00
|
|
|
bits<17> addr;
|
2011-04-12 18:48:00 +00:00
|
|
|
let addr{12} = 1; // add = TRUE
|
2010-11-30 22:45:47 +00:00
|
|
|
let Inst{19-16} = addr{16-13}; // Rn
|
|
|
|
let Inst{23} = addr{12}; // U
|
2010-11-30 19:19:31 +00:00
|
|
|
let Inst{11-0} = addr{11-0}; // imm12
|
2010-03-04 17:40:44 +00:00
|
|
|
}
|
|
|
|
|
2011-09-07 20:58:57 +00:00
|
|
|
def i8 : T2Ii8<(outs), (ins t2addrmode_negimm8:$addr), IIC_Preload, opc,
|
2010-11-03 05:14:24 +00:00
|
|
|
"\t$addr",
|
2011-09-07 20:58:57 +00:00
|
|
|
[(ARMPreload t2addrmode_negimm8:$addr, (i32 write), (i32 instr))]> {
|
2010-03-04 17:40:44 +00:00
|
|
|
let Inst{31-25} = 0b1111100;
|
2010-11-04 05:19:35 +00:00
|
|
|
let Inst{24} = instr;
|
2010-03-04 17:40:44 +00:00
|
|
|
let Inst{23} = 0; // U = 0
|
|
|
|
let Inst{22} = 0;
|
2010-11-04 05:19:35 +00:00
|
|
|
let Inst{21} = write;
|
2010-03-04 17:40:44 +00:00
|
|
|
let Inst{20} = 1;
|
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
let Inst{11-8} = 0b1100;
|
2010-12-02 23:05:38 +00:00
|
|
|
|
2010-11-30 19:19:31 +00:00
|
|
|
bits<13> addr;
|
|
|
|
let Inst{19-16} = addr{12-9}; // Rn
|
|
|
|
let Inst{7-0} = addr{7-0}; // imm8
|
2010-03-04 17:40:44 +00:00
|
|
|
}
|
|
|
|
|
2010-11-03 06:34:55 +00:00
|
|
|
def s : T2Iso<(outs), (ins t2addrmode_so_reg:$addr), IIC_Preload, opc,
|
2010-11-03 05:14:24 +00:00
|
|
|
"\t$addr",
|
2010-11-04 05:19:35 +00:00
|
|
|
[(ARMPreload t2addrmode_so_reg:$addr, (i32 write), (i32 instr))]> {
|
2010-03-04 17:40:44 +00:00
|
|
|
let Inst{31-25} = 0b1111100;
|
2010-11-04 05:19:35 +00:00
|
|
|
let Inst{24} = instr;
|
2010-03-04 17:40:44 +00:00
|
|
|
let Inst{23} = 0; // add = TRUE for T1
|
|
|
|
let Inst{22} = 0;
|
2010-11-04 05:19:35 +00:00
|
|
|
let Inst{21} = write;
|
2010-03-04 17:40:44 +00:00
|
|
|
let Inst{20} = 1;
|
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
let Inst{11-6} = 0000000;
|
2010-12-02 23:05:38 +00:00
|
|
|
|
2010-11-30 19:19:31 +00:00
|
|
|
bits<10> addr;
|
|
|
|
let Inst{19-16} = addr{9-6}; // Rn
|
|
|
|
let Inst{3-0} = addr{5-2}; // Rm
|
|
|
|
let Inst{5-4} = addr{1-0}; // imm2
|
2011-08-09 20:55:18 +00:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeT2LoadShift";
|
2010-03-04 17:40:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-04 05:19:35 +00:00
|
|
|
defm t2PLD : T2Ipl<0, 0, "pld">, Requires<[IsThumb2]>;
|
|
|
|
defm t2PLDW : T2Ipl<1, 0, "pldw">, Requires<[IsThumb2,HasV7,HasMP]>;
|
|
|
|
defm t2PLI : T2Ipl<0, 1, "pli">, Requires<[IsThumb2,HasV7]>;
|
2010-03-04 17:40:44 +00:00
|
|
|
|
2009-07-03 00:18:36 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Load / store multiple Instructions.
|
|
|
|
//
|
|
|
|
|
2011-09-12 21:28:46 +00:00
|
|
|
multiclass thumb2_ld_mult<string asm, InstrItinClass itin,
|
2010-11-13 09:09:38 +00:00
|
|
|
InstrItinClass itin_upd, bit L_bit> {
|
2010-11-16 01:16:36 +00:00
|
|
|
def IA :
|
2010-11-13 09:09:38 +00:00
|
|
|
T2XI<(outs), (ins GPR:$Rn, pred:$p, reglist:$regs, variable_ops),
|
2011-09-07 16:22:42 +00:00
|
|
|
itin, !strconcat(asm, "${p}.w\t$Rn, $regs"), []> {
|
2010-11-13 09:09:38 +00:00
|
|
|
bits<4> Rn;
|
|
|
|
bits<16> regs;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-11-13 09:09:38 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b00;
|
|
|
|
let Inst{24-23} = 0b01; // Increment After
|
|
|
|
let Inst{22} = 0;
|
|
|
|
let Inst{21} = 0; // No writeback
|
|
|
|
let Inst{20} = L_bit;
|
|
|
|
let Inst{19-16} = Rn;
|
2011-09-12 21:28:46 +00:00
|
|
|
let Inst{15} = 0;
|
|
|
|
let Inst{14-0} = regs{14-0};
|
2010-11-13 09:09:38 +00:00
|
|
|
}
|
2010-11-16 01:16:36 +00:00
|
|
|
def IA_UPD :
|
2010-11-13 09:09:38 +00:00
|
|
|
T2XIt<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, reglist:$regs, variable_ops),
|
2011-09-07 16:22:42 +00:00
|
|
|
itin_upd, !strconcat(asm, "${p}.w\t$Rn!, $regs"), "$Rn = $wb", []> {
|
2010-11-13 09:09:38 +00:00
|
|
|
bits<4> Rn;
|
|
|
|
bits<16> regs;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-11-13 09:09:38 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b00;
|
|
|
|
let Inst{24-23} = 0b01; // Increment After
|
|
|
|
let Inst{22} = 0;
|
|
|
|
let Inst{21} = 1; // Writeback
|
|
|
|
let Inst{20} = L_bit;
|
|
|
|
let Inst{19-16} = Rn;
|
2011-09-12 21:28:46 +00:00
|
|
|
let Inst{15} = 0;
|
|
|
|
let Inst{14-0} = regs{14-0};
|
2010-11-13 09:09:38 +00:00
|
|
|
}
|
2010-11-16 01:16:36 +00:00
|
|
|
def DB :
|
2010-11-13 09:09:38 +00:00
|
|
|
T2XI<(outs), (ins GPR:$Rn, pred:$p, reglist:$regs, variable_ops),
|
2011-09-07 18:39:47 +00:00
|
|
|
itin, !strconcat(asm, "db${p}\t$Rn, $regs"), []> {
|
2010-11-13 09:09:38 +00:00
|
|
|
bits<4> Rn;
|
|
|
|
bits<16> regs;
|
|
|
|
|
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b00;
|
|
|
|
let Inst{24-23} = 0b10; // Decrement Before
|
|
|
|
let Inst{22} = 0;
|
|
|
|
let Inst{21} = 0; // No writeback
|
|
|
|
let Inst{20} = L_bit;
|
|
|
|
let Inst{19-16} = Rn;
|
2011-09-12 21:28:46 +00:00
|
|
|
let Inst{15} = 0;
|
|
|
|
let Inst{14-0} = regs{14-0};
|
2010-11-13 09:09:38 +00:00
|
|
|
}
|
2010-11-16 01:16:36 +00:00
|
|
|
def DB_UPD :
|
2010-11-13 09:09:38 +00:00
|
|
|
T2XIt<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, reglist:$regs, variable_ops),
|
2011-09-07 18:39:47 +00:00
|
|
|
itin_upd, !strconcat(asm, "db${p}\t$Rn!, $regs"), "$Rn = $wb", []> {
|
2010-11-13 09:09:38 +00:00
|
|
|
bits<4> Rn;
|
|
|
|
bits<16> regs;
|
|
|
|
|
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b00;
|
|
|
|
let Inst{24-23} = 0b10; // Decrement Before
|
|
|
|
let Inst{22} = 0;
|
|
|
|
let Inst{21} = 1; // Writeback
|
|
|
|
let Inst{20} = L_bit;
|
|
|
|
let Inst{19-16} = Rn;
|
2011-09-12 21:28:46 +00:00
|
|
|
let Inst{15} = 0;
|
|
|
|
let Inst{14-0} = regs{14-0};
|
2010-11-13 09:09:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-13 11:20:05 +00:00
|
|
|
let neverHasSideEffects = 1 in {
|
2010-11-13 10:57:02 +00:00
|
|
|
|
|
|
|
let mayLoad = 1, hasExtraDefRegAllocReq = 1 in
|
2011-09-12 21:28:46 +00:00
|
|
|
defm t2LDM : thumb2_ld_mult<"ldm", IIC_iLoad_m, IIC_iLoad_mu, 1>;
|
|
|
|
|
|
|
|
multiclass thumb2_st_mult<string asm, InstrItinClass itin,
|
|
|
|
InstrItinClass itin_upd, bit L_bit> {
|
|
|
|
def IA :
|
|
|
|
T2XI<(outs), (ins GPR:$Rn, pred:$p, reglist:$regs, variable_ops),
|
|
|
|
itin, !strconcat(asm, "${p}.w\t$Rn, $regs"), []> {
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<16> regs;
|
|
|
|
|
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b00;
|
|
|
|
let Inst{24-23} = 0b01; // Increment After
|
|
|
|
let Inst{22} = 0;
|
|
|
|
let Inst{21} = 0; // No writeback
|
|
|
|
let Inst{20} = L_bit;
|
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
let Inst{14} = regs{14};
|
|
|
|
let Inst{13} = 0;
|
|
|
|
let Inst{12-0} = regs{12-0};
|
|
|
|
}
|
|
|
|
def IA_UPD :
|
|
|
|
T2XIt<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, reglist:$regs, variable_ops),
|
|
|
|
itin_upd, !strconcat(asm, "${p}.w\t$Rn!, $regs"), "$Rn = $wb", []> {
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<16> regs;
|
|
|
|
|
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b00;
|
|
|
|
let Inst{24-23} = 0b01; // Increment After
|
|
|
|
let Inst{22} = 0;
|
|
|
|
let Inst{21} = 1; // Writeback
|
|
|
|
let Inst{20} = L_bit;
|
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
let Inst{14} = regs{14};
|
|
|
|
let Inst{13} = 0;
|
|
|
|
let Inst{12-0} = regs{12-0};
|
|
|
|
}
|
|
|
|
def DB :
|
|
|
|
T2XI<(outs), (ins GPR:$Rn, pred:$p, reglist:$regs, variable_ops),
|
|
|
|
itin, !strconcat(asm, "db${p}\t$Rn, $regs"), []> {
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<16> regs;
|
|
|
|
|
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b00;
|
|
|
|
let Inst{24-23} = 0b10; // Decrement Before
|
|
|
|
let Inst{22} = 0;
|
|
|
|
let Inst{21} = 0; // No writeback
|
|
|
|
let Inst{20} = L_bit;
|
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
let Inst{14} = regs{14};
|
|
|
|
let Inst{13} = 0;
|
|
|
|
let Inst{12-0} = regs{12-0};
|
|
|
|
}
|
|
|
|
def DB_UPD :
|
|
|
|
T2XIt<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, reglist:$regs, variable_ops),
|
|
|
|
itin_upd, !strconcat(asm, "db${p}\t$Rn!, $regs"), "$Rn = $wb", []> {
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<16> regs;
|
|
|
|
|
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b00;
|
|
|
|
let Inst{24-23} = 0b10; // Decrement Before
|
|
|
|
let Inst{22} = 0;
|
|
|
|
let Inst{21} = 1; // Writeback
|
|
|
|
let Inst{20} = L_bit;
|
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
let Inst{14} = regs{14};
|
|
|
|
let Inst{13} = 0;
|
|
|
|
let Inst{12-0} = regs{12-0};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-13 10:57:02 +00:00
|
|
|
|
|
|
|
let mayStore = 1, hasExtraSrcRegAllocReq = 1 in
|
2011-09-12 21:28:46 +00:00
|
|
|
defm t2STM : thumb2_st_mult<"stm", IIC_iStore_m, IIC_iStore_mu, 0>;
|
2010-11-13 10:57:02 +00:00
|
|
|
|
|
|
|
} // neverHasSideEffects
|
|
|
|
|
2009-07-03 00:18:36 +00:00
|
|
|
|
2009-06-17 18:13:58 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Move Instructions.
|
|
|
|
//
|
|
|
|
|
2009-06-23 17:48:47 +00:00
|
|
|
let neverHasSideEffects = 1 in
|
2011-09-10 00:15:36 +00:00
|
|
|
def t2MOVr : T2sTwoReg<(outs GPRnopc:$Rd), (ins GPR:$Rm), IIC_iMOVr,
|
2010-11-16 00:29:56 +00:00
|
|
|
"mov", ".w\t$Rd, $Rm", []> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = 0b0010;
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{14-12} = 0b000;
|
|
|
|
let Inst{7-4} = 0b0000;
|
|
|
|
}
|
2011-09-10 00:15:36 +00:00
|
|
|
def : t2InstAlias<"movs${p}.w $Rd, $Rm", (t2MOVr GPRnopc:$Rd, GPR:$Rm,
|
|
|
|
pred:$p, CPSR)>;
|
|
|
|
def : t2InstAlias<"movs${p} $Rd, $Rm", (t2MOVr GPRnopc:$Rd, GPR:$Rm,
|
|
|
|
pred:$p, CPSR)>;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2009-09-28 09:14:39 +00:00
|
|
|
// AddedComplexity to ensure isel tries t2MOVi before t2MOVi16.
|
2010-11-17 20:13:28 +00:00
|
|
|
let isReMaterializable = 1, isAsCheapAsAMove = 1, isMoveImm = 1,
|
|
|
|
AddedComplexity = 1 in
|
2010-11-16 00:29:56 +00:00
|
|
|
def t2MOVi : T2sOneRegImm<(outs rGPR:$Rd), (ins t2_so_imm:$imm), IIC_iMOVi,
|
|
|
|
"mov", ".w\t$Rd, $imm",
|
|
|
|
[(set rGPR:$Rd, t2_so_imm:$imm)]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 0;
|
|
|
|
let Inst{24-21} = 0b0010;
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
2009-06-26 16:10:07 +00:00
|
|
|
|
2011-09-10 00:15:36 +00:00
|
|
|
// cc_out is handled as part of the explicit mnemonic in the parser for 'mov'.
|
|
|
|
// Use aliases to get that to play nice here.
|
|
|
|
def : t2InstAlias<"movs${p}.w $Rd, $imm", (t2MOVi rGPR:$Rd, t2_so_imm:$imm,
|
|
|
|
pred:$p, CPSR)>;
|
|
|
|
def : t2InstAlias<"movs${p} $Rd, $imm", (t2MOVi rGPR:$Rd, t2_so_imm:$imm,
|
|
|
|
pred:$p, CPSR)>;
|
|
|
|
|
|
|
|
def : t2InstAlias<"mov${p}.w $Rd, $imm", (t2MOVi rGPR:$Rd, t2_so_imm:$imm,
|
|
|
|
pred:$p, zero_reg)>;
|
|
|
|
def : t2InstAlias<"mov${p} $Rd, $imm", (t2MOVi rGPR:$Rd, t2_so_imm:$imm,
|
|
|
|
pred:$p, zero_reg)>;
|
2011-06-27 23:54:06 +00:00
|
|
|
|
2010-11-17 20:13:28 +00:00
|
|
|
let isReMaterializable = 1, isAsCheapAsAMove = 1, isMoveImm = 1 in
|
2011-07-19 19:13:28 +00:00
|
|
|
def t2MOVi16 : T2I<(outs rGPR:$Rd), (ins imm0_65535_expr:$imm), IIC_iMOVi,
|
2010-11-16 00:29:56 +00:00
|
|
|
"movw", "\t$Rd, $imm",
|
|
|
|
[(set rGPR:$Rd, imm0_65535:$imm)]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 1;
|
|
|
|
let Inst{24-21} = 0b0010;
|
|
|
|
let Inst{20} = 0; // The S bit.
|
|
|
|
let Inst{15} = 0;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-11-16 00:29:56 +00:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<16> imm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-16 00:29:56 +00:00
|
|
|
let Inst{19-16} = imm{15-12};
|
|
|
|
let Inst{26} = imm{11};
|
|
|
|
let Inst{14-12} = imm{10-8};
|
|
|
|
let Inst{7-0} = imm{7-0};
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2011-01-21 18:55:51 +00:00
|
|
|
def t2MOVi16_ga_pcrel : PseudoInst<(outs rGPR:$Rd),
|
2011-01-17 08:03:18 +00:00
|
|
|
(ins i32imm:$addr, pclabel:$id), IIC_iMOVi, []>;
|
|
|
|
|
|
|
|
let Constraints = "$src = $Rd" in {
|
2011-01-13 07:58:56 +00:00
|
|
|
def t2MOVTi16 : T2I<(outs rGPR:$Rd),
|
2011-07-19 19:13:28 +00:00
|
|
|
(ins rGPR:$src, imm0_65535_expr:$imm), IIC_iMOVi,
|
2010-11-16 00:29:56 +00:00
|
|
|
"movt", "\t$Rd, $imm",
|
|
|
|
[(set rGPR:$Rd,
|
Many Thumb2 instructions can reference the full ARM register set (i.e.,
have 4 bits per register in the operand encoding), but have undefined
behavior when the operand value is 13 or 15 (SP and PC, respectively).
The trivial coalescer in linear scan sometimes will merge a copy from
SP into a subsequent instruction which uses the copy, and if that
instruction cannot legally reference SP, we get bad code such as:
mls r0,r9,r0,sp
instead of:
mov r2, sp
mls r0, r9, r0, r2
This patch adds a new register class for use by Thumb2 that excludes
the problematic registers (SP and PC) and is used instead of GPR
for those operands which cannot legally reference PC or SP. The
trivial coalescer explicitly requires that the register class
of the destination for the COPY instruction contain the source
register for the COPY to be considered for coalescing. This prevents
errant instructions like that above.
PR7499
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@109842 91177308-0d34-0410-b5e6-96231b3b80d8
2010-07-30 02:41:01 +00:00
|
|
|
(or (and rGPR:$src, 0xffff), lo16AllZero:$imm))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 1;
|
|
|
|
let Inst{24-21} = 0b0110;
|
|
|
|
let Inst{20} = 0; // The S bit.
|
|
|
|
let Inst{15} = 0;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-11-16 00:29:56 +00:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<16> imm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-16 00:29:56 +00:00
|
|
|
let Inst{19-16} = imm{15-12};
|
|
|
|
let Inst{26} = imm{11};
|
|
|
|
let Inst{14-12} = imm{10-8};
|
|
|
|
let Inst{7-0} = imm{7-0};
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2009-06-17 18:13:58 +00:00
|
|
|
|
2011-01-21 18:55:51 +00:00
|
|
|
def t2MOVTi16_ga_pcrel : PseudoInst<(outs rGPR:$Rd),
|
2011-01-17 08:03:18 +00:00
|
|
|
(ins rGPR:$src, i32imm:$addr, pclabel:$id), IIC_iMOVi, []>;
|
|
|
|
} // Constraints
|
|
|
|
|
Many Thumb2 instructions can reference the full ARM register set (i.e.,
have 4 bits per register in the operand encoding), but have undefined
behavior when the operand value is 13 or 15 (SP and PC, respectively).
The trivial coalescer in linear scan sometimes will merge a copy from
SP into a subsequent instruction which uses the copy, and if that
instruction cannot legally reference SP, we get bad code such as:
mls r0,r9,r0,sp
instead of:
mov r2, sp
mls r0, r9, r0, r2
This patch adds a new register class for use by Thumb2 that excludes
the problematic registers (SP and PC) and is used instead of GPR
for those operands which cannot legally reference PC or SP. The
trivial coalescer explicitly requires that the register class
of the destination for the COPY instruction contain the source
register for the COPY to be considered for coalescing. This prevents
errant instructions like that above.
PR7499
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@109842 91177308-0d34-0410-b5e6-96231b3b80d8
2010-07-30 02:41:01 +00:00
|
|
|
def : T2Pat<(or rGPR:$src, 0xffff0000), (t2MOVTi16 rGPR:$src, 0xffff)>;
|
2009-10-21 08:15:52 +00:00
|
|
|
|
2009-07-03 01:43:10 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Extend Instructions.
|
|
|
|
//
|
|
|
|
|
|
|
|
// Sign extenders
|
|
|
|
|
2011-07-27 16:47:19 +00:00
|
|
|
def t2SXTB : T2I_ext_rrot<0b100, "sxtb",
|
2009-12-15 17:24:14 +00:00
|
|
|
UnOpFrag<(sext_inreg node:$Src, i8)>>;
|
2011-07-27 16:47:19 +00:00
|
|
|
def t2SXTH : T2I_ext_rrot<0b000, "sxth",
|
2009-12-15 17:24:14 +00:00
|
|
|
UnOpFrag<(sext_inreg node:$Src, i16)>>;
|
2011-07-27 17:48:13 +00:00
|
|
|
def t2SXTB16 : T2I_ext_rrot_sxtb16<0b010, "sxtb16">;
|
2009-07-03 01:43:10 +00:00
|
|
|
|
2011-07-27 17:48:13 +00:00
|
|
|
def t2SXTAB : T2I_exta_rrot<0b100, "sxtab",
|
2009-07-03 01:43:10 +00:00
|
|
|
BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS, i8))>>;
|
2011-07-27 17:48:13 +00:00
|
|
|
def t2SXTAH : T2I_exta_rrot<0b000, "sxtah",
|
2009-07-03 01:43:10 +00:00
|
|
|
BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS,i16))>>;
|
2011-07-27 17:48:13 +00:00
|
|
|
def t2SXTAB16 : T2I_exta_rrot_np<0b010, "sxtab16">;
|
2009-07-03 01:43:10 +00:00
|
|
|
|
2011-07-27 17:48:13 +00:00
|
|
|
// TODO: SXT(A){B|H}16
|
2009-07-03 01:43:10 +00:00
|
|
|
|
|
|
|
// Zero extenders
|
|
|
|
|
|
|
|
let AddedComplexity = 16 in {
|
2011-07-27 16:47:19 +00:00
|
|
|
def t2UXTB : T2I_ext_rrot<0b101, "uxtb",
|
2009-12-15 17:24:14 +00:00
|
|
|
UnOpFrag<(and node:$Src, 0x000000FF)>>;
|
2011-07-27 16:47:19 +00:00
|
|
|
def t2UXTH : T2I_ext_rrot<0b001, "uxth",
|
2009-12-15 17:24:14 +00:00
|
|
|
UnOpFrag<(and node:$Src, 0x0000FFFF)>>;
|
2011-07-27 17:48:13 +00:00
|
|
|
def t2UXTB16 : T2I_ext_rrot_uxtb16<0b011, "uxtb16",
|
2009-12-15 17:24:14 +00:00
|
|
|
UnOpFrag<(and node:$Src, 0x00FF00FF)>>;
|
2009-07-03 01:43:10 +00:00
|
|
|
|
2010-07-28 23:17:45 +00:00
|
|
|
// FIXME: This pattern incorrectly assumes the shl operator is a rotate.
|
|
|
|
// The transformation should probably be done as a combiner action
|
|
|
|
// instead so we can include a check for masking back in the upper
|
|
|
|
// eight bits of the source into the lower eight bits of the result.
|
Many Thumb2 instructions can reference the full ARM register set (i.e.,
have 4 bits per register in the operand encoding), but have undefined
behavior when the operand value is 13 or 15 (SP and PC, respectively).
The trivial coalescer in linear scan sometimes will merge a copy from
SP into a subsequent instruction which uses the copy, and if that
instruction cannot legally reference SP, we get bad code such as:
mls r0,r9,r0,sp
instead of:
mov r2, sp
mls r0, r9, r0, r2
This patch adds a new register class for use by Thumb2 that excludes
the problematic registers (SP and PC) and is used instead of GPR
for those operands which cannot legally reference PC or SP. The
trivial coalescer explicitly requires that the register class
of the destination for the COPY instruction contain the source
register for the COPY to be considered for coalescing. This prevents
errant instructions like that above.
PR7499
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@109842 91177308-0d34-0410-b5e6-96231b3b80d8
2010-07-30 02:41:01 +00:00
|
|
|
//def : T2Pat<(and (shl rGPR:$Src, (i32 8)), 0xFF00FF),
|
2011-07-27 17:48:13 +00:00
|
|
|
// (t2UXTB16 rGPR:$Src, 3)>,
|
2010-11-01 15:59:52 +00:00
|
|
|
// Requires<[HasT2ExtractPack, IsThumb2]>;
|
Many Thumb2 instructions can reference the full ARM register set (i.e.,
have 4 bits per register in the operand encoding), but have undefined
behavior when the operand value is 13 or 15 (SP and PC, respectively).
The trivial coalescer in linear scan sometimes will merge a copy from
SP into a subsequent instruction which uses the copy, and if that
instruction cannot legally reference SP, we get bad code such as:
mls r0,r9,r0,sp
instead of:
mov r2, sp
mls r0, r9, r0, r2
This patch adds a new register class for use by Thumb2 that excludes
the problematic registers (SP and PC) and is used instead of GPR
for those operands which cannot legally reference PC or SP. The
trivial coalescer explicitly requires that the register class
of the destination for the COPY instruction contain the source
register for the COPY to be considered for coalescing. This prevents
errant instructions like that above.
PR7499
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@109842 91177308-0d34-0410-b5e6-96231b3b80d8
2010-07-30 02:41:01 +00:00
|
|
|
def : T2Pat<(and (srl rGPR:$Src, (i32 8)), 0xFF00FF),
|
2011-07-27 17:48:13 +00:00
|
|
|
(t2UXTB16 rGPR:$Src, 1)>,
|
2010-11-01 15:59:52 +00:00
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
2009-07-03 01:43:10 +00:00
|
|
|
|
2011-07-27 17:48:13 +00:00
|
|
|
def t2UXTAB : T2I_exta_rrot<0b101, "uxtab",
|
2009-11-24 00:20:27 +00:00
|
|
|
BinOpFrag<(add node:$LHS, (and node:$RHS, 0x00FF))>>;
|
2011-07-27 17:48:13 +00:00
|
|
|
def t2UXTAH : T2I_exta_rrot<0b001, "uxtah",
|
2009-11-24 00:20:27 +00:00
|
|
|
BinOpFrag<(add node:$LHS, (and node:$RHS, 0xFFFF))>>;
|
2011-07-27 17:48:13 +00:00
|
|
|
def t2UXTAB16 : T2I_exta_rrot_np<0b011, "uxtab16">;
|
2009-07-03 01:43:10 +00:00
|
|
|
}
|
|
|
|
|
2009-06-17 18:13:58 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Arithmetic Instructions.
|
|
|
|
//
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2009-12-15 17:24:14 +00:00
|
|
|
defm t2ADD : T2I_bin_ii12rs<0b000, "add",
|
|
|
|
BinOpFrag<(add node:$LHS, node:$RHS)>, 1>;
|
|
|
|
defm t2SUB : T2I_bin_ii12rs<0b101, "sub",
|
|
|
|
BinOpFrag<(sub node:$LHS, node:$RHS)>>;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
|
|
|
// ADD and SUB with 's' bit set. No 12-bit immediate (T4) variants.
|
2011-09-06 18:52:20 +00:00
|
|
|
// FIXME: Eliminate them if we can write def : Pat patterns which defines
|
|
|
|
// CPSR and the implicit def of CPSR is not needed.
|
2009-12-15 17:24:14 +00:00
|
|
|
defm t2ADDS : T2I_bin_s_irs <0b1000, "add",
|
2010-09-29 00:27:46 +00:00
|
|
|
IIC_iALUi, IIC_iALUr, IIC_iALUsi,
|
2011-08-30 01:34:54 +00:00
|
|
|
BinOpFrag<(ARMaddc node:$LHS, node:$RHS)>, 1>;
|
2009-12-15 17:24:14 +00:00
|
|
|
defm t2SUBS : T2I_bin_s_irs <0b1101, "sub",
|
2010-09-29 00:27:46 +00:00
|
|
|
IIC_iALUi, IIC_iALUr, IIC_iALUsi,
|
2011-08-30 01:34:54 +00:00
|
|
|
BinOpFrag<(ARMsubc node:$LHS, node:$RHS)>>;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2011-08-30 19:09:48 +00:00
|
|
|
let hasPostISelHook = 1 in {
|
2009-12-15 17:24:14 +00:00
|
|
|
defm t2ADC : T2I_adde_sube_irs<0b1010, "adc",
|
2011-08-30 01:34:54 +00:00
|
|
|
BinOpWithFlagFrag<(ARMadde node:$LHS, node:$RHS, node:$FLAG)>, 1>;
|
2009-12-15 17:24:14 +00:00
|
|
|
defm t2SBC : T2I_adde_sube_irs<0b1011, "sbc",
|
2011-08-30 01:34:54 +00:00
|
|
|
BinOpWithFlagFrag<(ARMsube node:$LHS, node:$RHS, node:$FLAG)>>;
|
2011-08-30 19:09:48 +00:00
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2009-07-27 16:39:05 +00:00
|
|
|
// RSB
|
2010-08-13 23:24:25 +00:00
|
|
|
defm t2RSB : T2I_rbin_irs <0b1110, "rsb",
|
2009-12-15 17:24:14 +00:00
|
|
|
BinOpFrag<(sub node:$LHS, node:$RHS)>>;
|
2011-09-06 18:52:20 +00:00
|
|
|
|
|
|
|
// FIXME: Eliminate them if we can write def : Pat patterns which defines
|
|
|
|
// CPSR and the implicit def of CPSR is not needed.
|
2009-12-15 17:24:14 +00:00
|
|
|
defm t2RSBS : T2I_rbin_s_is <0b1110, "rsb",
|
2011-08-30 01:34:54 +00:00
|
|
|
BinOpFrag<(ARMsubc node:$LHS, node:$RHS)>>;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
|
|
|
// (sub X, imm) gets canonicalized to (add X, -imm). Match this form.
|
2010-07-14 17:45:16 +00:00
|
|
|
// The assume-no-carry-in form uses the negation of the input since add/sub
|
|
|
|
// assume opposite meanings of the carry flag (i.e., carry == !borrow).
|
|
|
|
// See the definition of AddWithCarry() in the ARM ARM A2.2.1 for the gory
|
|
|
|
// details.
|
|
|
|
// The AddedComplexity preferences the first variant over the others since
|
|
|
|
// it can be shrunk to a 16-bit wide encoding, while the others cannot.
|
|
|
|
let AddedComplexity = 1 in
|
|
|
|
def : T2Pat<(add GPR:$src, imm0_255_neg:$imm),
|
|
|
|
(t2SUBri GPR:$src, imm0_255_neg:$imm)>;
|
|
|
|
def : T2Pat<(add GPR:$src, t2_so_imm_neg:$imm),
|
|
|
|
(t2SUBri GPR:$src, t2_so_imm_neg:$imm)>;
|
|
|
|
def : T2Pat<(add GPR:$src, imm0_4095_neg:$imm),
|
|
|
|
(t2SUBri12 GPR:$src, imm0_4095_neg:$imm)>;
|
|
|
|
let AddedComplexity = 1 in
|
2011-08-30 01:34:54 +00:00
|
|
|
def : T2Pat<(ARMaddc rGPR:$src, imm0_255_neg:$imm),
|
Many Thumb2 instructions can reference the full ARM register set (i.e.,
have 4 bits per register in the operand encoding), but have undefined
behavior when the operand value is 13 or 15 (SP and PC, respectively).
The trivial coalescer in linear scan sometimes will merge a copy from
SP into a subsequent instruction which uses the copy, and if that
instruction cannot legally reference SP, we get bad code such as:
mls r0,r9,r0,sp
instead of:
mov r2, sp
mls r0, r9, r0, r2
This patch adds a new register class for use by Thumb2 that excludes
the problematic registers (SP and PC) and is used instead of GPR
for those operands which cannot legally reference PC or SP. The
trivial coalescer explicitly requires that the register class
of the destination for the COPY instruction contain the source
register for the COPY to be considered for coalescing. This prevents
errant instructions like that above.
PR7499
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@109842 91177308-0d34-0410-b5e6-96231b3b80d8
2010-07-30 02:41:01 +00:00
|
|
|
(t2SUBSri rGPR:$src, imm0_255_neg:$imm)>;
|
2011-08-30 01:34:54 +00:00
|
|
|
def : T2Pat<(ARMaddc rGPR:$src, t2_so_imm_neg:$imm),
|
Many Thumb2 instructions can reference the full ARM register set (i.e.,
have 4 bits per register in the operand encoding), but have undefined
behavior when the operand value is 13 or 15 (SP and PC, respectively).
The trivial coalescer in linear scan sometimes will merge a copy from
SP into a subsequent instruction which uses the copy, and if that
instruction cannot legally reference SP, we get bad code such as:
mls r0,r9,r0,sp
instead of:
mov r2, sp
mls r0, r9, r0, r2
This patch adds a new register class for use by Thumb2 that excludes
the problematic registers (SP and PC) and is used instead of GPR
for those operands which cannot legally reference PC or SP. The
trivial coalescer explicitly requires that the register class
of the destination for the COPY instruction contain the source
register for the COPY to be considered for coalescing. This prevents
errant instructions like that above.
PR7499
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@109842 91177308-0d34-0410-b5e6-96231b3b80d8
2010-07-30 02:41:01 +00:00
|
|
|
(t2SUBSri rGPR:$src, t2_so_imm_neg:$imm)>;
|
2010-07-14 17:45:16 +00:00
|
|
|
// The with-carry-in form matches bitwise not instead of the negation.
|
|
|
|
// Effectively, the inverse interpretation of the carry flag already accounts
|
|
|
|
// for part of the negation.
|
2009-08-04 01:41:15 +00:00
|
|
|
let AddedComplexity = 1 in
|
2011-08-30 01:34:54 +00:00
|
|
|
def : T2Pat<(ARMadde rGPR:$src, imm0_255_not:$imm, CPSR),
|
2011-04-23 03:55:32 +00:00
|
|
|
(t2SBCri rGPR:$src, imm0_255_not:$imm)>;
|
2011-08-30 01:34:54 +00:00
|
|
|
def : T2Pat<(ARMadde rGPR:$src, t2_so_imm_not:$imm, CPSR),
|
2011-04-23 03:55:32 +00:00
|
|
|
(t2SBCri rGPR:$src, t2_so_imm_not:$imm)>;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
Added 32-bit Thumb instructions: CPS, SDIV, UDIV, SXTB16, SXTAB16, UXTAB16, SEL,
SMMULR, SMMLAR, SMMLSR, TBB, TBH, and 16-bit Thumb instruction CPS for
disassembly only.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97573 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-02 18:14:57 +00:00
|
|
|
// Select Bytes -- for disassembly only
|
|
|
|
|
2010-11-30 20:00:01 +00:00
|
|
|
def t2SEL : T2ThreeReg<(outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm),
|
2011-07-01 21:12:19 +00:00
|
|
|
NoItinerary, "sel", "\t$Rd, $Rn, $Rm", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
Added 32-bit Thumb instructions: CPS, SDIV, UDIV, SXTB16, SXTAB16, UXTAB16, SEL,
SMMULR, SMMLAR, SMMLSR, TBB, TBH, and 16-bit Thumb instruction CPS for
disassembly only.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97573 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-02 18:14:57 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-24} = 0b010;
|
|
|
|
let Inst{23} = 0b1;
|
|
|
|
let Inst{22-20} = 0b010;
|
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
let Inst{7} = 0b1;
|
|
|
|
let Inst{6-4} = 0b000;
|
|
|
|
}
|
|
|
|
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
// A6.3.13, A6.3.14, A6.3.15 Parallel addition and subtraction (signed/unsigned)
|
|
|
|
// And Miscellaneous operations -- for disassembly only
|
2010-07-29 17:56:55 +00:00
|
|
|
class T2I_pam<bits<3> op22_20, bits<4> op7_4, string opc,
|
2011-01-21 14:07:40 +00:00
|
|
|
list<dag> pat = [/* For disassembly only; pattern left blank */],
|
|
|
|
dag iops = (ins rGPR:$Rn, rGPR:$Rm),
|
|
|
|
string asm = "\t$Rd, $Rn, $Rm">
|
2011-07-01 21:12:19 +00:00
|
|
|
: T2I<(outs rGPR:$Rd), iops, NoItinerary, opc, asm, pat>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0101;
|
|
|
|
let Inst{22-20} = op22_20;
|
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
let Inst{7-4} = op7_4;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-11-17 19:57:38 +00:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{3-0} = Rm;
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Saturating add/subtract -- for disassembly only
|
|
|
|
|
2010-07-29 17:56:55 +00:00
|
|
|
def t2QADD : T2I_pam<0b000, 0b1000, "qadd",
|
2011-01-21 14:07:40 +00:00
|
|
|
[(set rGPR:$Rd, (int_arm_qadd rGPR:$Rn, rGPR:$Rm))],
|
|
|
|
(ins rGPR:$Rm, rGPR:$Rn), "\t$Rd, $Rm, $Rn">;
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
def t2QADD16 : T2I_pam<0b001, 0b0001, "qadd16">;
|
|
|
|
def t2QADD8 : T2I_pam<0b000, 0b0001, "qadd8">;
|
|
|
|
def t2QASX : T2I_pam<0b010, 0b0001, "qasx">;
|
2011-01-21 14:07:40 +00:00
|
|
|
def t2QDADD : T2I_pam<0b000, 0b1001, "qdadd", [],
|
|
|
|
(ins rGPR:$Rm, rGPR:$Rn), "\t$Rd, $Rm, $Rn">;
|
|
|
|
def t2QDSUB : T2I_pam<0b000, 0b1011, "qdsub", [],
|
|
|
|
(ins rGPR:$Rm, rGPR:$Rn), "\t$Rd, $Rm, $Rn">;
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
def t2QSAX : T2I_pam<0b110, 0b0001, "qsax">;
|
2010-07-29 17:56:55 +00:00
|
|
|
def t2QSUB : T2I_pam<0b000, 0b1010, "qsub",
|
2011-01-21 14:07:40 +00:00
|
|
|
[(set rGPR:$Rd, (int_arm_qsub rGPR:$Rn, rGPR:$Rm))],
|
|
|
|
(ins rGPR:$Rm, rGPR:$Rn), "\t$Rd, $Rm, $Rn">;
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
def t2QSUB16 : T2I_pam<0b101, 0b0001, "qsub16">;
|
|
|
|
def t2QSUB8 : T2I_pam<0b100, 0b0001, "qsub8">;
|
|
|
|
def t2UQADD16 : T2I_pam<0b001, 0b0101, "uqadd16">;
|
|
|
|
def t2UQADD8 : T2I_pam<0b000, 0b0101, "uqadd8">;
|
|
|
|
def t2UQASX : T2I_pam<0b010, 0b0101, "uqasx">;
|
|
|
|
def t2UQSAX : T2I_pam<0b110, 0b0101, "uqsax">;
|
|
|
|
def t2UQSUB16 : T2I_pam<0b101, 0b0101, "uqsub16">;
|
|
|
|
def t2UQSUB8 : T2I_pam<0b100, 0b0101, "uqsub8">;
|
|
|
|
|
|
|
|
// Signed/Unsigned add/subtract -- for disassembly only
|
|
|
|
|
|
|
|
def t2SASX : T2I_pam<0b010, 0b0000, "sasx">;
|
|
|
|
def t2SADD16 : T2I_pam<0b001, 0b0000, "sadd16">;
|
|
|
|
def t2SADD8 : T2I_pam<0b000, 0b0000, "sadd8">;
|
|
|
|
def t2SSAX : T2I_pam<0b110, 0b0000, "ssax">;
|
|
|
|
def t2SSUB16 : T2I_pam<0b101, 0b0000, "ssub16">;
|
|
|
|
def t2SSUB8 : T2I_pam<0b100, 0b0000, "ssub8">;
|
|
|
|
def t2UASX : T2I_pam<0b010, 0b0100, "uasx">;
|
|
|
|
def t2UADD16 : T2I_pam<0b001, 0b0100, "uadd16">;
|
|
|
|
def t2UADD8 : T2I_pam<0b000, 0b0100, "uadd8">;
|
|
|
|
def t2USAX : T2I_pam<0b110, 0b0100, "usax">;
|
|
|
|
def t2USUB16 : T2I_pam<0b101, 0b0100, "usub16">;
|
|
|
|
def t2USUB8 : T2I_pam<0b100, 0b0100, "usub8">;
|
|
|
|
|
|
|
|
// Signed/Unsigned halving add/subtract -- for disassembly only
|
|
|
|
|
|
|
|
def t2SHASX : T2I_pam<0b010, 0b0010, "shasx">;
|
|
|
|
def t2SHADD16 : T2I_pam<0b001, 0b0010, "shadd16">;
|
|
|
|
def t2SHADD8 : T2I_pam<0b000, 0b0010, "shadd8">;
|
|
|
|
def t2SHSAX : T2I_pam<0b110, 0b0010, "shsax">;
|
|
|
|
def t2SHSUB16 : T2I_pam<0b101, 0b0010, "shsub16">;
|
|
|
|
def t2SHSUB8 : T2I_pam<0b100, 0b0010, "shsub8">;
|
|
|
|
def t2UHASX : T2I_pam<0b010, 0b0110, "uhasx">;
|
|
|
|
def t2UHADD16 : T2I_pam<0b001, 0b0110, "uhadd16">;
|
|
|
|
def t2UHADD8 : T2I_pam<0b000, 0b0110, "uhadd8">;
|
|
|
|
def t2UHSAX : T2I_pam<0b110, 0b0110, "uhsax">;
|
|
|
|
def t2UHSUB16 : T2I_pam<0b101, 0b0110, "uhsub16">;
|
|
|
|
def t2UHSUB8 : T2I_pam<0b100, 0b0110, "uhsub8">;
|
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
// Helper class for disassembly only
|
|
|
|
// A6.3.16 & A6.3.17
|
|
|
|
// T2Imac - Thumb2 multiply [accumulate, and absolute difference] instructions.
|
|
|
|
class T2ThreeReg_mac<bit long, bits<3> op22_20, bits<4> op7_4, dag oops,
|
|
|
|
dag iops, InstrItinClass itin, string opc, string asm, list<dag> pattern>
|
|
|
|
: T2ThreeReg<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-24} = 0b011;
|
|
|
|
let Inst{23} = long;
|
|
|
|
let Inst{22-20} = op22_20;
|
|
|
|
let Inst{7-4} = op7_4;
|
|
|
|
}
|
|
|
|
|
|
|
|
class T2FourReg_mac<bit long, bits<3> op22_20, bits<4> op7_4, dag oops,
|
|
|
|
dag iops, InstrItinClass itin, string opc, string asm, list<dag> pattern>
|
|
|
|
: T2FourReg<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-24} = 0b011;
|
|
|
|
let Inst{23} = long;
|
|
|
|
let Inst{22-20} = op22_20;
|
|
|
|
let Inst{7-4} = op7_4;
|
|
|
|
}
|
|
|
|
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
// Unsigned Sum of Absolute Differences [and Accumulate] -- for disassembly only
|
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2USAD8 : T2ThreeReg_mac<0, 0b111, 0b0000, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rn, rGPR:$Rm),
|
2011-07-01 21:12:19 +00:00
|
|
|
NoItinerary, "usad8", "\t$Rd, $Rn, $Rm", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
}
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2USADA8 : T2FourReg_mac<0, 0b111, 0b0000, (outs rGPR:$Rd),
|
2010-11-19 17:11:02 +00:00
|
|
|
(ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), NoItinerary,
|
2011-07-01 21:12:19 +00:00
|
|
|
"usada8", "\t$Rd, $Rn, $Rm, $Ra", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
|
|
|
|
// Signed/Unsigned saturate -- for disassembly only
|
|
|
|
|
2010-11-17 19:57:38 +00:00
|
|
|
class T2SatI<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-19 17:11:02 +00:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
2010-11-17 19:57:38 +00:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<5> sat_imm;
|
|
|
|
bits<7> sh;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{19-16} = Rn;
|
2011-07-25 22:20:28 +00:00
|
|
|
let Inst{4-0} = sat_imm;
|
|
|
|
let Inst{21} = sh{5};
|
2010-11-17 19:57:38 +00:00
|
|
|
let Inst{14-12} = sh{4-2};
|
|
|
|
let Inst{7-6} = sh{1-0};
|
|
|
|
}
|
|
|
|
|
2010-11-30 20:00:01 +00:00
|
|
|
def t2SSAT: T2SatI<
|
2011-07-22 23:16:18 +00:00
|
|
|
(outs rGPR:$Rd), (ins imm1_32:$sat_imm, rGPR:$Rn, shift_imm:$sh),
|
2011-05-31 03:33:27 +00:00
|
|
|
NoItinerary, "ssat", "\t$Rd, $sat_imm, $Rn$sh",
|
|
|
|
[/* For disassembly only; pattern left blank */]> {
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25-22} = 0b1100;
|
|
|
|
let Inst{20} = 0;
|
|
|
|
let Inst{15} = 0;
|
2011-09-19 20:00:02 +00:00
|
|
|
let Inst{5} = 0;
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
}
|
|
|
|
|
2010-11-30 20:00:01 +00:00
|
|
|
def t2SSAT16: T2SatI<
|
2011-07-25 23:09:14 +00:00
|
|
|
(outs rGPR:$Rd), (ins imm1_16:$sat_imm, rGPR:$Rn), NoItinerary,
|
2011-05-31 03:33:27 +00:00
|
|
|
"ssat16", "\t$Rd, $sat_imm, $Rn",
|
2011-07-01 21:12:19 +00:00
|
|
|
[/* For disassembly only; pattern left blank */]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25-22} = 0b1100;
|
|
|
|
let Inst{20} = 0;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
let Inst{21} = 1; // sh = '1'
|
|
|
|
let Inst{14-12} = 0b000; // imm3 = '000'
|
|
|
|
let Inst{7-6} = 0b00; // imm2 = '00'
|
2011-09-16 22:17:02 +00:00
|
|
|
let Inst{5-4} = 0b00;
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
}
|
|
|
|
|
2010-11-30 20:00:01 +00:00
|
|
|
def t2USAT: T2SatI<
|
2011-09-16 18:32:30 +00:00
|
|
|
(outs rGPR:$Rd), (ins imm0_31:$sat_imm, rGPR:$Rn, shift_imm:$sh),
|
2010-11-30 20:00:01 +00:00
|
|
|
NoItinerary, "usat", "\t$Rd, $sat_imm, $Rn$sh",
|
2010-08-13 21:48:10 +00:00
|
|
|
[/* For disassembly only; pattern left blank */]> {
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25-22} = 0b1110;
|
|
|
|
let Inst{20} = 0;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
|
|
|
|
2011-09-16 18:32:30 +00:00
|
|
|
def t2USAT16: T2SatI<(outs rGPR:$Rd), (ins imm0_15:$sat_imm, rGPR:$Rn),
|
2011-06-13 22:54:22 +00:00
|
|
|
NoItinerary,
|
2011-08-22 23:27:47 +00:00
|
|
|
"usat16", "\t$Rd, $sat_imm, $Rn",
|
2011-07-01 21:12:19 +00:00
|
|
|
[/* For disassembly only; pattern left blank */]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25-22} = 0b1110;
|
|
|
|
let Inst{20} = 0;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
let Inst{21} = 1; // sh = '1'
|
|
|
|
let Inst{14-12} = 0b000; // imm3 = '000'
|
|
|
|
let Inst{7-6} = 0b00; // imm2 = '00'
|
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2010-08-13 21:48:10 +00:00
|
|
|
def : T2Pat<(int_arm_ssat GPR:$a, imm:$pos), (t2SSAT imm:$pos, GPR:$a, 0)>;
|
|
|
|
def : T2Pat<(int_arm_usat GPR:$a, imm:$pos), (t2USAT imm:$pos, GPR:$a, 0)>;
|
2010-07-29 22:48:09 +00:00
|
|
|
|
2009-06-23 19:39:13 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Shift and rotate Instructions.
|
|
|
|
//
|
|
|
|
|
2011-09-02 21:28:54 +00:00
|
|
|
defm t2LSL : T2I_sh_ir<0b00, "lsl", imm0_31,
|
|
|
|
BinOpFrag<(shl node:$LHS, node:$RHS)>, "t2LSL">;
|
2011-09-02 18:43:25 +00:00
|
|
|
defm t2LSR : T2I_sh_ir<0b01, "lsr", imm_sr,
|
2011-09-02 21:28:54 +00:00
|
|
|
BinOpFrag<(srl node:$LHS, node:$RHS)>, "t2LSR">;
|
2011-09-02 18:43:25 +00:00
|
|
|
defm t2ASR : T2I_sh_ir<0b10, "asr", imm_sr,
|
2011-09-02 21:28:54 +00:00
|
|
|
BinOpFrag<(sra node:$LHS, node:$RHS)>, "t2ASR">;
|
|
|
|
defm t2ROR : T2I_sh_ir<0b11, "ror", imm0_31,
|
|
|
|
BinOpFrag<(rotr node:$LHS, node:$RHS)>, "t2ROR">;
|
2009-06-23 19:39:13 +00:00
|
|
|
|
2011-04-29 14:18:15 +00:00
|
|
|
// (rotr x, (and y, 0x...1f)) ==> (ROR x, y)
|
|
|
|
def : Pat<(rotr rGPR:$lhs, (and rGPR:$rhs, lo5AllOne)),
|
|
|
|
(t2RORrr rGPR:$lhs, rGPR:$rhs)>;
|
|
|
|
|
2009-09-01 18:32:09 +00:00
|
|
|
let Uses = [CPSR] in {
|
2010-11-17 19:57:38 +00:00
|
|
|
def t2RRX : T2sTwoReg<(outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iMOVsi,
|
|
|
|
"rrx", "\t$Rd, $Rm",
|
|
|
|
[(set rGPR:$Rd, (ARMrrx rGPR:$Rm))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = 0b0010;
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{14-12} = 0b000;
|
|
|
|
let Inst{7-4} = 0b0011;
|
|
|
|
}
|
2009-09-01 18:32:09 +00:00
|
|
|
}
|
2009-06-23 19:39:13 +00:00
|
|
|
|
2011-01-10 15:26:39 +00:00
|
|
|
let isCodeGenOnly = 1, Defs = [CPSR] in {
|
2010-11-15 19:58:36 +00:00
|
|
|
def t2MOVsrl_flag : T2TwoRegShiftImm<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iMOVsi,
|
|
|
|
"lsrs", ".w\t$Rd, $Rm, #1",
|
|
|
|
[(set rGPR:$Rd, (ARMsrl_flag rGPR:$Rm))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = 0b0010;
|
|
|
|
let Inst{20} = 1; // The S bit.
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{5-4} = 0b01; // Shift type.
|
|
|
|
// Shift amount = Inst{14-12:7-6} = 1.
|
|
|
|
let Inst{14-12} = 0b000;
|
|
|
|
let Inst{7-6} = 0b01;
|
|
|
|
}
|
2010-11-15 19:58:36 +00:00
|
|
|
def t2MOVsra_flag : T2TwoRegShiftImm<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iMOVsi,
|
|
|
|
"asrs", ".w\t$Rd, $Rm, #1",
|
|
|
|
[(set rGPR:$Rd, (ARMsra_flag rGPR:$Rm))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = 0b0010;
|
|
|
|
let Inst{20} = 1; // The S bit.
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{5-4} = 0b10; // Shift type.
|
|
|
|
// Shift amount = Inst{14-12:7-6} = 1.
|
|
|
|
let Inst{14-12} = 0b000;
|
|
|
|
let Inst{7-6} = 0b01;
|
|
|
|
}
|
2009-07-28 17:06:49 +00:00
|
|
|
}
|
|
|
|
|
2009-06-23 17:48:47 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Bitwise Instructions.
|
|
|
|
//
|
|
|
|
|
2009-12-15 17:24:14 +00:00
|
|
|
defm t2AND : T2I_bin_w_irs<0b0000, "and",
|
2010-09-29 00:27:46 +00:00
|
|
|
IIC_iBITi, IIC_iBITr, IIC_iBITsi,
|
2011-06-28 00:19:13 +00:00
|
|
|
BinOpFrag<(and node:$LHS, node:$RHS)>, "t2AND", 1>;
|
2009-12-15 17:24:14 +00:00
|
|
|
defm t2ORR : T2I_bin_w_irs<0b0010, "orr",
|
2010-09-29 00:27:46 +00:00
|
|
|
IIC_iBITi, IIC_iBITr, IIC_iBITsi,
|
2011-06-28 00:19:13 +00:00
|
|
|
BinOpFrag<(or node:$LHS, node:$RHS)>, "t2ORR", 1>;
|
2009-12-15 17:24:14 +00:00
|
|
|
defm t2EOR : T2I_bin_w_irs<0b0100, "eor",
|
2010-09-29 00:27:46 +00:00
|
|
|
IIC_iBITi, IIC_iBITr, IIC_iBITsi,
|
2011-06-28 00:19:13 +00:00
|
|
|
BinOpFrag<(xor node:$LHS, node:$RHS)>, "t2EOR", 1>;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2009-12-15 17:24:14 +00:00
|
|
|
defm t2BIC : T2I_bin_w_irs<0b0001, "bic",
|
2010-09-29 00:27:46 +00:00
|
|
|
IIC_iBITi, IIC_iBITr, IIC_iBITsi,
|
2011-06-28 00:19:13 +00:00
|
|
|
BinOpFrag<(and node:$LHS, (not node:$RHS))>,
|
|
|
|
"t2BIC">;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2010-11-17 22:16:31 +00:00
|
|
|
class T2BitFI<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-19 17:11:02 +00:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
2010-11-17 22:16:31 +00:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<5> msb;
|
|
|
|
bits<5> lsb;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-17 22:16:31 +00:00
|
|
|
let Inst{4-0} = msb{4-0};
|
|
|
|
let Inst{14-12} = lsb{4-2};
|
|
|
|
let Inst{7-6} = lsb{1-0};
|
|
|
|
}
|
|
|
|
|
|
|
|
class T2TwoRegBitFI<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
|
|
|
: T2BitFI<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> Rn;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{19-16} = Rn;
|
2010-11-17 22:16:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
let Constraints = "$src = $Rd" in
|
|
|
|
def t2BFC : T2BitFI<(outs rGPR:$Rd), (ins rGPR:$src, bf_inv_mask_imm:$imm),
|
|
|
|
IIC_iUNAsi, "bfc", "\t$Rd, $imm",
|
|
|
|
[(set rGPR:$Rd, (and rGPR:$src, bf_inv_mask_imm:$imm))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
2011-04-15 22:52:15 +00:00
|
|
|
let Inst{26} = 0; // should be 0.
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{25} = 1;
|
|
|
|
let Inst{24-20} = 0b10110;
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{15} = 0;
|
2011-04-15 22:52:15 +00:00
|
|
|
let Inst{5} = 0; // should be 0.
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-11-17 22:16:31 +00:00
|
|
|
bits<10> imm;
|
|
|
|
let msb{4-0} = imm{9-5};
|
|
|
|
let lsb{4-0} = imm{4-0};
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2010-11-17 22:16:31 +00:00
|
|
|
def t2SBFX: T2TwoRegBitFI<
|
2011-07-27 21:09:25 +00:00
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, imm0_31:$lsb, imm1_32:$msb),
|
2010-11-17 22:16:31 +00:00
|
|
|
IIC_iUNAsi, "sbfx", "\t$Rd, $Rn, $lsb, $msb", []> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 1;
|
|
|
|
let Inst{24-20} = 0b10100;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
2009-10-13 18:59:48 +00:00
|
|
|
|
2010-11-17 22:16:31 +00:00
|
|
|
def t2UBFX: T2TwoRegBitFI<
|
2011-07-27 21:09:25 +00:00
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, imm0_31:$lsb, imm1_32:$msb),
|
2010-11-17 22:16:31 +00:00
|
|
|
IIC_iUNAsi, "ubfx", "\t$Rd, $Rn, $lsb, $msb", []> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 1;
|
|
|
|
let Inst{24-20} = 0b11100;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
2009-10-13 18:59:48 +00:00
|
|
|
|
2010-02-02 19:31:58 +00:00
|
|
|
// A8.6.18 BFI - Bitfield insert (Encoding T1)
|
2011-01-18 20:45:56 +00:00
|
|
|
let Constraints = "$src = $Rd" in {
|
|
|
|
def t2BFI : T2TwoRegBitFI<(outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$src, rGPR:$Rn, bf_inv_mask_imm:$imm),
|
|
|
|
IIC_iBITi, "bfi", "\t$Rd, $Rn, $imm",
|
|
|
|
[(set rGPR:$Rd, (ARMbfi rGPR:$src, rGPR:$Rn,
|
|
|
|
bf_inv_mask_imm:$imm))]> {
|
|
|
|
let Inst{31-27} = 0b11110;
|
2011-04-15 00:35:08 +00:00
|
|
|
let Inst{26} = 0; // should be 0.
|
2011-01-18 20:45:56 +00:00
|
|
|
let Inst{25} = 1;
|
|
|
|
let Inst{24-20} = 0b10110;
|
|
|
|
let Inst{15} = 0;
|
2011-04-15 00:35:08 +00:00
|
|
|
let Inst{5} = 0; // should be 0.
|
2011-01-18 20:45:56 +00:00
|
|
|
|
|
|
|
bits<10> imm;
|
|
|
|
let msb{4-0} = imm{9-5};
|
|
|
|
let lsb{4-0} = imm{4-0};
|
|
|
|
}
|
2010-02-02 19:31:58 +00:00
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2010-09-29 00:27:46 +00:00
|
|
|
defm t2ORN : T2I_bin_irs<0b0011, "orn",
|
|
|
|
IIC_iBITi, IIC_iBITr, IIC_iBITsi,
|
2011-06-28 00:19:13 +00:00
|
|
|
BinOpFrag<(or node:$LHS, (not node:$RHS))>,
|
|
|
|
"t2ORN", 0, "">;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2011-09-14 21:24:41 +00:00
|
|
|
/// T2I_un_irs - Defines a set of (op reg, {so_imm|r|so_reg}) patterns for a
|
|
|
|
/// unary operation that produces a value. These are predicable and can be
|
|
|
|
/// changed to modify CPSR.
|
|
|
|
multiclass T2I_un_irs<bits<4> opcod, string opc,
|
|
|
|
InstrItinClass iii, InstrItinClass iir, InstrItinClass iis,
|
|
|
|
PatFrag opnode, bit Cheap = 0, bit ReMat = 0> {
|
|
|
|
// shifted imm
|
|
|
|
def i : T2sOneRegImm<(outs rGPR:$Rd), (ins t2_so_imm:$imm), iii,
|
|
|
|
opc, "\t$Rd, $imm",
|
|
|
|
[(set rGPR:$Rd, (opnode t2_so_imm:$imm))]> {
|
|
|
|
let isAsCheapAsAMove = Cheap;
|
|
|
|
let isReMaterializable = ReMat;
|
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 0;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
|
|
|
// register
|
|
|
|
def r : T2sTwoReg<(outs rGPR:$Rd), (ins rGPR:$Rm), iir,
|
|
|
|
opc, ".w\t$Rd, $Rm",
|
|
|
|
[(set rGPR:$Rd, (opnode rGPR:$Rm))]> {
|
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{14-12} = 0b000; // imm3
|
|
|
|
let Inst{7-6} = 0b00; // imm2
|
|
|
|
let Inst{5-4} = 0b00; // type
|
|
|
|
}
|
|
|
|
// shifted register
|
|
|
|
def s : T2sOneRegShiftedReg<(outs rGPR:$Rd), (ins t2_so_reg:$ShiftedRm), iis,
|
|
|
|
opc, ".w\t$Rd, $ShiftedRm",
|
|
|
|
[(set rGPR:$Rd, (opnode t2_so_reg:$ShiftedRm))]> {
|
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-26 23:13:13 +00:00
|
|
|
// Prefer over of t2EORri ra, rb, -1 because mvn has 16-bit version
|
|
|
|
let AddedComplexity = 1 in
|
2010-09-29 00:49:25 +00:00
|
|
|
defm t2MVN : T2I_un_irs <0b0011, "mvn",
|
2010-09-29 22:42:35 +00:00
|
|
|
IIC_iMVNi, IIC_iMVNr, IIC_iMVNsi,
|
2010-09-29 00:49:25 +00:00
|
|
|
UnOpFrag<(not node:$Src)>, 1, 1>;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2010-07-20 16:07:04 +00:00
|
|
|
let AddedComplexity = 1 in
|
Many Thumb2 instructions can reference the full ARM register set (i.e.,
have 4 bits per register in the operand encoding), but have undefined
behavior when the operand value is 13 or 15 (SP and PC, respectively).
The trivial coalescer in linear scan sometimes will merge a copy from
SP into a subsequent instruction which uses the copy, and if that
instruction cannot legally reference SP, we get bad code such as:
mls r0,r9,r0,sp
instead of:
mov r2, sp
mls r0, r9, r0, r2
This patch adds a new register class for use by Thumb2 that excludes
the problematic registers (SP and PC) and is used instead of GPR
for those operands which cannot legally reference PC or SP. The
trivial coalescer explicitly requires that the register class
of the destination for the COPY instruction contain the source
register for the COPY to be considered for coalescing. This prevents
errant instructions like that above.
PR7499
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@109842 91177308-0d34-0410-b5e6-96231b3b80d8
2010-07-30 02:41:01 +00:00
|
|
|
def : T2Pat<(and rGPR:$src, t2_so_imm_not:$imm),
|
|
|
|
(t2BICri rGPR:$src, t2_so_imm_not:$imm)>;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2009-08-01 06:13:52 +00:00
|
|
|
// FIXME: Disable this pattern on Darwin to workaround an assembler bug.
|
Many Thumb2 instructions can reference the full ARM register set (i.e.,
have 4 bits per register in the operand encoding), but have undefined
behavior when the operand value is 13 or 15 (SP and PC, respectively).
The trivial coalescer in linear scan sometimes will merge a copy from
SP into a subsequent instruction which uses the copy, and if that
instruction cannot legally reference SP, we get bad code such as:
mls r0,r9,r0,sp
instead of:
mov r2, sp
mls r0, r9, r0, r2
This patch adds a new register class for use by Thumb2 that excludes
the problematic registers (SP and PC) and is used instead of GPR
for those operands which cannot legally reference PC or SP. The
trivial coalescer explicitly requires that the register class
of the destination for the COPY instruction contain the source
register for the COPY to be considered for coalescing. This prevents
errant instructions like that above.
PR7499
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@109842 91177308-0d34-0410-b5e6-96231b3b80d8
2010-07-30 02:41:01 +00:00
|
|
|
def : T2Pat<(or rGPR:$src, t2_so_imm_not:$imm),
|
|
|
|
(t2ORNri rGPR:$src, t2_so_imm_not:$imm)>,
|
2009-08-12 01:56:42 +00:00
|
|
|
Requires<[IsThumb2]>;
|
2009-07-06 22:23:46 +00:00
|
|
|
|
|
|
|
def : T2Pat<(t2_so_imm_not:$src),
|
|
|
|
(t2MVNi t2_so_imm_not:$src)>;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Multiply Instructions.
|
|
|
|
//
|
2009-06-26 00:19:44 +00:00
|
|
|
let isCommutable = 1 in
|
2010-11-18 01:08:42 +00:00
|
|
|
def t2MUL: T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL32,
|
|
|
|
"mul", "\t$Rd, $Rn, $Rm",
|
|
|
|
[(set rGPR:$Rd, (mul rGPR:$Rn, rGPR:$Rm))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b000;
|
|
|
|
let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
|
|
|
|
let Inst{7-4} = 0b0000; // Multiply
|
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2010-11-18 01:08:42 +00:00
|
|
|
def t2MLA: T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
|
|
|
|
"mla", "\t$Rd, $Rn, $Rm, $Ra",
|
|
|
|
[(set rGPR:$Rd, (add (mul rGPR:$Rn, rGPR:$Rm), rGPR:$Ra))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b000;
|
|
|
|
let Inst{7-4} = 0b0000; // Multiply
|
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2010-11-18 01:08:42 +00:00
|
|
|
def t2MLS: T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
|
|
|
|
"mls", "\t$Rd, $Rn, $Rm, $Ra",
|
|
|
|
[(set rGPR:$Rd, (sub rGPR:$Ra, (mul rGPR:$Rn, rGPR:$Rm)))]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b000;
|
|
|
|
let Inst{7-4} = 0b0001; // Multiply and Subtract
|
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2009-07-07 01:17:28 +00:00
|
|
|
// Extra precision multiplies with low / high results
|
|
|
|
let neverHasSideEffects = 1 in {
|
|
|
|
let isCommutable = 1 in {
|
2010-12-08 22:38:41 +00:00
|
|
|
def t2SMULL : T2MulLong<0b000, 0b0000,
|
2011-08-22 23:16:48 +00:00
|
|
|
(outs rGPR:$RdLo, rGPR:$RdHi),
|
2010-11-18 01:08:42 +00:00
|
|
|
(ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL64,
|
2011-08-22 23:16:48 +00:00
|
|
|
"smull", "\t$RdLo, $RdHi, $Rn, $Rm", []>;
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-12-08 22:38:41 +00:00
|
|
|
def t2UMULL : T2MulLong<0b010, 0b0000,
|
2010-12-08 22:29:28 +00:00
|
|
|
(outs rGPR:$RdLo, rGPR:$RdHi),
|
2010-11-18 01:08:42 +00:00
|
|
|
(ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL64,
|
2010-12-08 22:38:41 +00:00
|
|
|
"umull", "\t$RdLo, $RdHi, $Rn, $Rm", []>;
|
2009-12-15 17:24:14 +00:00
|
|
|
} // isCommutable
|
2009-07-07 01:17:28 +00:00
|
|
|
|
|
|
|
// Multiply + accumulate
|
2010-12-08 22:38:41 +00:00
|
|
|
def t2SMLAL : T2MulLong<0b100, 0b0000,
|
|
|
|
(outs rGPR:$RdLo, rGPR:$RdHi),
|
2010-11-18 01:08:42 +00:00
|
|
|
(ins rGPR:$Rn, rGPR:$Rm), IIC_iMAC64,
|
2010-12-08 22:38:41 +00:00
|
|
|
"smlal", "\t$RdLo, $RdHi, $Rn, $Rm", []>;
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-12-08 22:38:41 +00:00
|
|
|
def t2UMLAL : T2MulLong<0b110, 0b0000,
|
|
|
|
(outs rGPR:$RdLo, rGPR:$RdHi),
|
2010-11-18 01:08:42 +00:00
|
|
|
(ins rGPR:$Rn, rGPR:$Rm), IIC_iMAC64,
|
2010-12-08 22:38:41 +00:00
|
|
|
"umlal", "\t$RdLo, $RdHi, $Rn, $Rm", []>;
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-12-08 22:38:41 +00:00
|
|
|
def t2UMAAL : T2MulLong<0b110, 0b0110,
|
|
|
|
(outs rGPR:$RdLo, rGPR:$RdHi),
|
2010-11-18 01:08:42 +00:00
|
|
|
(ins rGPR:$Rn, rGPR:$Rm), IIC_iMAC64,
|
2011-07-01 21:12:19 +00:00
|
|
|
"umaal", "\t$RdLo, $RdHi, $Rn, $Rm", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2009-07-07 01:17:28 +00:00
|
|
|
} // neverHasSideEffects
|
|
|
|
|
Added 32-bit Thumb instructions: CPS, SDIV, UDIV, SXTB16, SXTAB16, UXTAB16, SEL,
SMMULR, SMMLAR, SMMLSR, TBB, TBH, and 16-bit Thumb instruction CPS for
disassembly only.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97573 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-02 18:14:57 +00:00
|
|
|
// Rounding variants of the below included for disassembly only
|
|
|
|
|
2009-07-07 01:17:28 +00:00
|
|
|
// Most significant word multiply
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMMUL : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL32,
|
|
|
|
"smmul", "\t$Rd, $Rn, $Rm",
|
2011-07-01 21:12:19 +00:00
|
|
|
[(set rGPR:$Rd, (mulhs rGPR:$Rn, rGPR:$Rm))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b101;
|
|
|
|
let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
|
|
|
|
let Inst{7-4} = 0b0000; // No Rounding (Inst{4} = 0)
|
|
|
|
}
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMMULR : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL32,
|
2011-07-01 21:12:19 +00:00
|
|
|
"smmulr", "\t$Rd, $Rn, $Rm", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
Added 32-bit Thumb instructions: CPS, SDIV, UDIV, SXTB16, SXTAB16, UXTAB16, SEL,
SMMULR, SMMLAR, SMMLSR, TBB, TBH, and 16-bit Thumb instruction CPS for
disassembly only.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97573 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-02 18:14:57 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b101;
|
|
|
|
let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
|
|
|
|
let Inst{7-4} = 0b0001; // Rounding (Inst{4} = 1)
|
|
|
|
}
|
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMMLA : T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
|
|
|
|
"smmla", "\t$Rd, $Rn, $Rm, $Ra",
|
2011-07-01 21:12:19 +00:00
|
|
|
[(set rGPR:$Rd, (add (mulhs rGPR:$Rm, rGPR:$Rn), rGPR:$Ra))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b101;
|
|
|
|
let Inst{7-4} = 0b0000; // No Rounding (Inst{4} = 0)
|
|
|
|
}
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMMLAR: T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
|
2011-07-01 21:12:19 +00:00
|
|
|
"smmlar", "\t$Rd, $Rn, $Rm, $Ra", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
Added 32-bit Thumb instructions: CPS, SDIV, UDIV, SXTB16, SXTAB16, UXTAB16, SEL,
SMMULR, SMMLAR, SMMLSR, TBB, TBH, and 16-bit Thumb instruction CPS for
disassembly only.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97573 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-02 18:14:57 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b101;
|
|
|
|
let Inst{7-4} = 0b0001; // Rounding (Inst{4} = 1)
|
|
|
|
}
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMMLS: T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
|
|
|
|
"smmls", "\t$Rd, $Rn, $Rm, $Ra",
|
2011-07-01 21:12:19 +00:00
|
|
|
[(set rGPR:$Rd, (sub rGPR:$Ra, (mulhs rGPR:$Rn, rGPR:$Rm)))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b110;
|
|
|
|
let Inst{7-4} = 0b0000; // No Rounding (Inst{4} = 0)
|
|
|
|
}
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMMLSR:T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
|
2011-07-01 21:12:19 +00:00
|
|
|
"smmlsr", "\t$Rd, $Rn, $Rm, $Ra", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
Added 32-bit Thumb instructions: CPS, SDIV, UDIV, SXTB16, SXTAB16, UXTAB16, SEL,
SMMULR, SMMLAR, SMMLSR, TBB, TBH, and 16-bit Thumb instruction CPS for
disassembly only.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97573 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-02 18:14:57 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b110;
|
|
|
|
let Inst{7-4} = 0b0001; // Rounding (Inst{4} = 1)
|
|
|
|
}
|
|
|
|
|
2009-07-07 01:17:28 +00:00
|
|
|
multiclass T2I_smul<string opc, PatFrag opnode> {
|
2010-11-18 20:32:18 +00:00
|
|
|
def BB : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL16,
|
|
|
|
!strconcat(opc, "bb"), "\t$Rd, $Rn, $Rm",
|
|
|
|
[(set rGPR:$Rd, (opnode (sext_inreg rGPR:$Rn, i16),
|
2011-07-01 21:12:19 +00:00
|
|
|
(sext_inreg rGPR:$Rm, i16)))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b001;
|
|
|
|
let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
|
|
|
|
let Inst{7-6} = 0b00;
|
|
|
|
let Inst{5-4} = 0b00;
|
|
|
|
}
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
def BT : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL16,
|
|
|
|
!strconcat(opc, "bt"), "\t$Rd, $Rn, $Rm",
|
|
|
|
[(set rGPR:$Rd, (opnode (sext_inreg rGPR:$Rn, i16),
|
2011-07-01 21:12:19 +00:00
|
|
|
(sra rGPR:$Rm, (i32 16))))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b001;
|
|
|
|
let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
|
|
|
|
let Inst{7-6} = 0b00;
|
|
|
|
let Inst{5-4} = 0b01;
|
|
|
|
}
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
def TB : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL16,
|
|
|
|
!strconcat(opc, "tb"), "\t$Rd, $Rn, $Rm",
|
|
|
|
[(set rGPR:$Rd, (opnode (sra rGPR:$Rn, (i32 16)),
|
2011-07-01 21:12:19 +00:00
|
|
|
(sext_inreg rGPR:$Rm, i16)))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b001;
|
|
|
|
let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
|
|
|
|
let Inst{7-6} = 0b00;
|
|
|
|
let Inst{5-4} = 0b10;
|
|
|
|
}
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
def TT : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL16,
|
|
|
|
!strconcat(opc, "tt"), "\t$Rd, $Rn, $Rm",
|
|
|
|
[(set rGPR:$Rd, (opnode (sra rGPR:$Rn, (i32 16)),
|
2011-07-01 21:12:19 +00:00
|
|
|
(sra rGPR:$Rm, (i32 16))))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b001;
|
|
|
|
let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
|
|
|
|
let Inst{7-6} = 0b00;
|
|
|
|
let Inst{5-4} = 0b11;
|
|
|
|
}
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
def WB : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL16,
|
|
|
|
!strconcat(opc, "wb"), "\t$Rd, $Rn, $Rm",
|
|
|
|
[(set rGPR:$Rd, (sra (opnode rGPR:$Rn,
|
2011-07-01 21:12:19 +00:00
|
|
|
(sext_inreg rGPR:$Rm, i16)), (i32 16)))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b011;
|
|
|
|
let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
|
|
|
|
let Inst{7-6} = 0b00;
|
|
|
|
let Inst{5-4} = 0b00;
|
|
|
|
}
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
def WT : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL16,
|
|
|
|
!strconcat(opc, "wt"), "\t$Rd, $Rn, $Rm",
|
|
|
|
[(set rGPR:$Rd, (sra (opnode rGPR:$Rn,
|
2011-07-01 21:12:19 +00:00
|
|
|
(sra rGPR:$Rm, (i32 16))), (i32 16)))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b011;
|
|
|
|
let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
|
|
|
|
let Inst{7-6} = 0b00;
|
|
|
|
let Inst{5-4} = 0b01;
|
|
|
|
}
|
2009-07-07 01:17:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
multiclass T2I_smla<string opc, PatFrag opnode> {
|
2010-11-18 20:32:18 +00:00
|
|
|
def BB : T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC16,
|
|
|
|
!strconcat(opc, "bb"), "\t$Rd, $Rn, $Rm, $Ra",
|
|
|
|
[(set rGPR:$Rd, (add rGPR:$Ra,
|
|
|
|
(opnode (sext_inreg rGPR:$Rn, i16),
|
2011-07-01 21:12:19 +00:00
|
|
|
(sext_inreg rGPR:$Rm, i16))))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b001;
|
|
|
|
let Inst{7-6} = 0b00;
|
|
|
|
let Inst{5-4} = 0b00;
|
|
|
|
}
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
def BT : T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC16,
|
|
|
|
!strconcat(opc, "bt"), "\t$Rd, $Rn, $Rm, $Ra",
|
|
|
|
[(set rGPR:$Rd, (add rGPR:$Ra, (opnode (sext_inreg rGPR:$Rn, i16),
|
2011-07-01 21:12:19 +00:00
|
|
|
(sra rGPR:$Rm, (i32 16)))))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b001;
|
|
|
|
let Inst{7-6} = 0b00;
|
|
|
|
let Inst{5-4} = 0b01;
|
|
|
|
}
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
def TB : T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC16,
|
|
|
|
!strconcat(opc, "tb"), "\t$Rd, $Rn, $Rm, $Ra",
|
|
|
|
[(set rGPR:$Rd, (add rGPR:$Ra, (opnode (sra rGPR:$Rn, (i32 16)),
|
2011-07-01 21:12:19 +00:00
|
|
|
(sext_inreg rGPR:$Rm, i16))))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b001;
|
|
|
|
let Inst{7-6} = 0b00;
|
|
|
|
let Inst{5-4} = 0b10;
|
|
|
|
}
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
def TT : T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC16,
|
|
|
|
!strconcat(opc, "tt"), "\t$Rd, $Rn, $Rm, $Ra",
|
|
|
|
[(set rGPR:$Rd, (add rGPR:$Ra, (opnode (sra rGPR:$Rn, (i32 16)),
|
2011-07-01 21:12:19 +00:00
|
|
|
(sra rGPR:$Rm, (i32 16)))))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b001;
|
|
|
|
let Inst{7-6} = 0b00;
|
|
|
|
let Inst{5-4} = 0b11;
|
|
|
|
}
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
def WB : T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC16,
|
|
|
|
!strconcat(opc, "wb"), "\t$Rd, $Rn, $Rm, $Ra",
|
|
|
|
[(set rGPR:$Rd, (add rGPR:$Ra, (sra (opnode rGPR:$Rn,
|
2011-07-01 21:12:19 +00:00
|
|
|
(sext_inreg rGPR:$Rm, i16)), (i32 16))))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b011;
|
|
|
|
let Inst{7-6} = 0b00;
|
|
|
|
let Inst{5-4} = 0b00;
|
|
|
|
}
|
2009-07-07 01:17:28 +00:00
|
|
|
|
2010-11-18 20:32:18 +00:00
|
|
|
def WT : T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC16,
|
|
|
|
!strconcat(opc, "wt"), "\t$Rd, $Rn, $Rm, $Ra",
|
|
|
|
[(set rGPR:$Rd, (add rGPR:$Ra, (sra (opnode rGPR:$Rn,
|
2011-07-01 21:12:19 +00:00
|
|
|
(sra rGPR:$Rm, (i32 16))), (i32 16))))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b011;
|
|
|
|
let Inst{7-6} = 0b00;
|
|
|
|
let Inst{5-4} = 0b01;
|
|
|
|
}
|
2009-07-07 01:17:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
defm t2SMUL : T2I_smul<"smul", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
|
|
|
|
defm t2SMLA : T2I_smla<"smla", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
|
|
|
|
|
2011-09-15 23:45:50 +00:00
|
|
|
// Halfword multiple accumulate long: SMLAL<x><y>
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMLALBB : T2FourReg_mac<1, 0b100, 0b1000, (outs rGPR:$Ra,rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rn,rGPR:$Rm), IIC_iMAC64, "smlalbb", "\t$Ra, $Rd, $Rn, $Rm",
|
2011-07-01 21:12:19 +00:00
|
|
|
[/* For disassembly only; pattern left blank */]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMLALBT : T2FourReg_mac<1, 0b100, 0b1001, (outs rGPR:$Ra,rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rn,rGPR:$Rm), IIC_iMAC64, "smlalbt", "\t$Ra, $Rd, $Rn, $Rm",
|
2011-07-01 21:12:19 +00:00
|
|
|
[/* For disassembly only; pattern left blank */]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMLALTB : T2FourReg_mac<1, 0b100, 0b1010, (outs rGPR:$Ra,rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rn,rGPR:$Rm), IIC_iMAC64, "smlaltb", "\t$Ra, $Rd, $Rn, $Rm",
|
2011-07-01 21:12:19 +00:00
|
|
|
[/* For disassembly only; pattern left blank */]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMLALTT : T2FourReg_mac<1, 0b100, 0b1011, (outs rGPR:$Ra,rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rn,rGPR:$Rm), IIC_iMAC64, "smlaltt", "\t$Ra, $Rd, $Rn, $Rm",
|
2011-07-01 21:12:19 +00:00
|
|
|
[/* For disassembly only; pattern left blank */]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
|
|
|
|
// Dual halfword multiple: SMUAD, SMUSD, SMLAD, SMLSD, SMLALD, SMLSLD
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMUAD: T2ThreeReg_mac<
|
|
|
|
0, 0b010, 0b0000, (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm),
|
2011-07-01 21:12:19 +00:00
|
|
|
IIC_iMAC32, "smuad", "\t$Rd, $Rn, $Rm", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
}
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMUADX:T2ThreeReg_mac<
|
|
|
|
0, 0b010, 0b0001, (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm),
|
2011-07-01 21:12:19 +00:00
|
|
|
IIC_iMAC32, "smuadx", "\t$Rd, $Rn, $Rm", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
}
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMUSD: T2ThreeReg_mac<
|
|
|
|
0, 0b100, 0b0000, (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm),
|
2011-07-01 21:12:19 +00:00
|
|
|
IIC_iMAC32, "smusd", "\t$Rd, $Rn, $Rm", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
}
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMUSDX:T2ThreeReg_mac<
|
|
|
|
0, 0b100, 0b0001, (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm),
|
2011-07-01 21:12:19 +00:00
|
|
|
IIC_iMAC32, "smusdx", "\t$Rd, $Rn, $Rm", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
Added the follwoing 32-bit Thumb instructions for disassembly only:
o Parallel addition and subtraction, signed/unsigned
o Miscellaneous operations: QADD, QDADD, QSUB, QDSUB
o Unsigned sum of absolute differences [and accumulate]: USAD8, USADA8
o Signed/Unsigned saturate: SSAT, SSAT16, USAT, USAT16
o Signed multiply accumulate long (halfwords): SMLAL<x><y>
o Signed multiply accumulate/subtract [long] (dual): SMLAD[x], SMLALD[X], SMLSD[X], SMLSLD[X]
o Signed dual multiply add/subtract [long]: SMUAD[X], SMUSD[X]
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97276 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-26 22:04:29 +00:00
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
}
|
2011-08-22 23:31:45 +00:00
|
|
|
def t2SMLAD : T2FourReg_mac<
|
2010-11-18 20:32:18 +00:00
|
|
|
0, 0b010, 0b0000, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32, "smlad",
|
2011-07-01 21:12:19 +00:00
|
|
|
"\t$Rd, $Rn, $Rm, $Ra", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMLADX : T2FourReg_mac<
|
|
|
|
0, 0b010, 0b0001, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32, "smladx",
|
2011-07-01 21:12:19 +00:00
|
|
|
"\t$Rd, $Rn, $Rm, $Ra", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMLSD : T2FourReg_mac<0, 0b100, 0b0000, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32, "smlsd",
|
2011-07-01 21:12:19 +00:00
|
|
|
"\t$Rd, $Rn, $Rm, $Ra", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMLSDX : T2FourReg_mac<0, 0b100, 0b0001, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32, "smlsdx",
|
2011-07-01 21:12:19 +00:00
|
|
|
"\t$Rd, $Rn, $Rm, $Ra", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMLALD : T2FourReg_mac<1, 0b100, 0b1100, (outs rGPR:$Ra,rGPR:$Rd),
|
2011-09-16 16:58:03 +00:00
|
|
|
(ins rGPR:$Rn, rGPR:$Rm), IIC_iMAC64, "smlald",
|
|
|
|
"\t$Ra, $Rd, $Rn, $Rm", []>,
|
2011-07-01 21:12:19 +00:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMLALDX : T2FourReg_mac<1, 0b100, 0b1101, (outs rGPR:$Ra,rGPR:$Rd),
|
2011-09-16 16:58:03 +00:00
|
|
|
(ins rGPR:$Rn,rGPR:$Rm), IIC_iMAC64, "smlaldx",
|
|
|
|
"\t$Ra, $Rd, $Rn, $Rm", []>,
|
2011-07-01 21:12:19 +00:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMLSLD : T2FourReg_mac<1, 0b101, 0b1100, (outs rGPR:$Ra,rGPR:$Rd),
|
2011-09-16 17:10:44 +00:00
|
|
|
(ins rGPR:$Rn,rGPR:$Rm), IIC_iMAC64, "smlsld",
|
|
|
|
"\t$Ra, $Rd, $Rn, $Rm", []>,
|
2011-07-01 21:12:19 +00:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-18 20:32:18 +00:00
|
|
|
def t2SMLSLDX : T2FourReg_mac<1, 0b101, 0b1101, (outs rGPR:$Ra,rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rm,rGPR:$Rn), IIC_iMAC64, "smlsldx",
|
2011-09-16 17:10:44 +00:00
|
|
|
"\t$Ra, $Rd, $Rn, $Rm", []>,
|
2011-07-01 21:12:19 +00:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2011-06-21 19:00:54 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Division Instructions.
|
|
|
|
// Signed and unsigned division on v7-M
|
|
|
|
//
|
|
|
|
def t2SDIV : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iALUi,
|
|
|
|
"sdiv", "\t$Rd, $Rn, $Rm",
|
|
|
|
[(set rGPR:$Rd, (sdiv rGPR:$Rn, rGPR:$Rm))]>,
|
|
|
|
Requires<[HasDivide, IsThumb2]> {
|
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-21} = 0b011100;
|
|
|
|
let Inst{20} = 0b1;
|
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
let Inst{7-4} = 0b1111;
|
|
|
|
}
|
|
|
|
|
|
|
|
def t2UDIV : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iALUi,
|
|
|
|
"udiv", "\t$Rd, $Rn, $Rm",
|
|
|
|
[(set rGPR:$Rd, (udiv rGPR:$Rn, rGPR:$Rm))]>,
|
|
|
|
Requires<[HasDivide, IsThumb2]> {
|
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-21} = 0b011101;
|
|
|
|
let Inst{20} = 0b1;
|
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
let Inst{7-4} = 0b1111;
|
|
|
|
}
|
|
|
|
|
2009-06-23 17:48:47 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Misc. Arithmetic Instructions.
|
|
|
|
//
|
|
|
|
|
2010-02-16 21:23:02 +00:00
|
|
|
class T2I_misc<bits<2> op1, bits<2> op2, dag oops, dag iops,
|
|
|
|
InstrItinClass itin, string opc, string asm, list<dag> pattern>
|
2010-11-18 21:15:19 +00:00
|
|
|
: T2ThreeReg<oops, iops, itin, opc, asm, pattern> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-22} = 0b01010;
|
|
|
|
let Inst{21-20} = op1;
|
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
let Inst{7-6} = 0b10;
|
|
|
|
let Inst{5-4} = op2;
|
2010-12-08 22:10:43 +00:00
|
|
|
let Rn{3-0} = Rm;
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
|
|
|
|
2010-11-18 21:15:19 +00:00
|
|
|
def t2CLZ : T2I_misc<0b11, 0b00, (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iUNAr,
|
|
|
|
"clz", "\t$Rd, $Rm", [(set rGPR:$Rd, (ctlz rGPR:$Rm))]>;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2010-11-18 21:15:19 +00:00
|
|
|
def t2RBIT : T2I_misc<0b01, 0b10, (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iUNAr,
|
|
|
|
"rbit", "\t$Rd, $Rm",
|
|
|
|
[(set rGPR:$Rd, (ARMrbit rGPR:$Rm))]>;
|
2010-01-18 19:58:49 +00:00
|
|
|
|
2010-11-18 21:15:19 +00:00
|
|
|
def t2REV : T2I_misc<0b01, 0b00, (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iUNAr,
|
|
|
|
"rev", ".w\t$Rd, $Rm", [(set rGPR:$Rd, (bswap rGPR:$Rm))]>;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2010-11-18 21:15:19 +00:00
|
|
|
def t2REV16 : T2I_misc<0b01, 0b01, (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iUNAr,
|
|
|
|
"rev16", ".w\t$Rd, $Rm",
|
2011-06-21 06:01:08 +00:00
|
|
|
[(set rGPR:$Rd, (rotr (bswap rGPR:$Rm), (i32 16)))]>;
|
2011-06-17 20:47:21 +00:00
|
|
|
|
2010-11-18 21:15:19 +00:00
|
|
|
def t2REVSH : T2I_misc<0b01, 0b11, (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iUNAr,
|
|
|
|
"revsh", ".w\t$Rd, $Rm",
|
2011-06-21 06:01:08 +00:00
|
|
|
[(set rGPR:$Rd, (sra (bswap rGPR:$Rm), (i32 16)))]>;
|
2011-03-18 21:52:42 +00:00
|
|
|
|
2011-06-15 17:17:48 +00:00
|
|
|
def : T2Pat<(or (sra (shl rGPR:$Rm, (i32 24)), (i32 16)),
|
2011-06-21 06:01:08 +00:00
|
|
|
(and (srl rGPR:$Rm, (i32 8)), 0xFF)),
|
2011-06-15 17:17:48 +00:00
|
|
|
(t2REVSH rGPR:$Rm)>;
|
|
|
|
|
2010-11-18 21:15:19 +00:00
|
|
|
def t2PKHBT : T2ThreeReg<
|
2011-09-14 23:16:41 +00:00
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, pkh_lsl_amt:$sh),
|
|
|
|
IIC_iBITsi, "pkhbt", "\t$Rd, $Rn, $Rm$sh",
|
2010-11-18 21:15:19 +00:00
|
|
|
[(set rGPR:$Rd, (or (and rGPR:$Rn, 0xFFFF),
|
2011-07-20 20:49:03 +00:00
|
|
|
(and (shl rGPR:$Rm, pkh_lsl_amt:$sh),
|
2010-05-05 20:44:35 +00:00
|
|
|
0xFFFF0000)))]>,
|
2010-11-01 15:59:52 +00:00
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-20} = 0b01100;
|
|
|
|
let Inst{5} = 0; // BT form
|
|
|
|
let Inst{4} = 0;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2011-07-20 20:32:09 +00:00
|
|
|
bits<5> sh;
|
|
|
|
let Inst{14-12} = sh{4-2};
|
|
|
|
let Inst{7-6} = sh{1-0};
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2009-07-07 05:35:52 +00:00
|
|
|
|
|
|
|
// Alternate cases for PKHBT where identities eliminate some nodes.
|
Many Thumb2 instructions can reference the full ARM register set (i.e.,
have 4 bits per register in the operand encoding), but have undefined
behavior when the operand value is 13 or 15 (SP and PC, respectively).
The trivial coalescer in linear scan sometimes will merge a copy from
SP into a subsequent instruction which uses the copy, and if that
instruction cannot legally reference SP, we get bad code such as:
mls r0,r9,r0,sp
instead of:
mov r2, sp
mls r0, r9, r0, r2
This patch adds a new register class for use by Thumb2 that excludes
the problematic registers (SP and PC) and is used instead of GPR
for those operands which cannot legally reference PC or SP. The
trivial coalescer explicitly requires that the register class
of the destination for the COPY instruction contain the source
register for the COPY to be considered for coalescing. This prevents
errant instructions like that above.
PR7499
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@109842 91177308-0d34-0410-b5e6-96231b3b80d8
2010-07-30 02:41:01 +00:00
|
|
|
def : T2Pat<(or (and rGPR:$src1, 0xFFFF), (and rGPR:$src2, 0xFFFF0000)),
|
|
|
|
(t2PKHBT rGPR:$src1, rGPR:$src2, 0)>,
|
2010-11-01 15:59:52 +00:00
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
2010-08-17 17:23:19 +00:00
|
|
|
def : T2Pat<(or (and rGPR:$src1, 0xFFFF), (shl rGPR:$src2, imm16_31:$sh)),
|
2011-07-20 20:32:09 +00:00
|
|
|
(t2PKHBT rGPR:$src1, rGPR:$src2, imm16_31:$sh)>,
|
2010-11-01 15:59:52 +00:00
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
2009-07-07 05:35:52 +00:00
|
|
|
|
2010-08-16 22:26:55 +00:00
|
|
|
// Note: Shifts of 1-15 bits will be transformed to srl instead of sra and
|
|
|
|
// will match the pattern below.
|
2010-11-18 21:15:19 +00:00
|
|
|
def t2PKHTB : T2ThreeReg<
|
2011-09-14 23:16:41 +00:00
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, pkh_asr_amt:$sh),
|
|
|
|
IIC_iBITsi, "pkhtb", "\t$Rd, $Rn, $Rm$sh",
|
2010-11-18 21:15:19 +00:00
|
|
|
[(set rGPR:$Rd, (or (and rGPR:$Rn, 0xFFFF0000),
|
2011-07-20 20:49:03 +00:00
|
|
|
(and (sra rGPR:$Rm, pkh_asr_amt:$sh),
|
2010-08-17 17:23:19 +00:00
|
|
|
0xFFFF)))]>,
|
2010-11-01 15:59:52 +00:00
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-20} = 0b01100;
|
|
|
|
let Inst{5} = 1; // TB form
|
|
|
|
let Inst{4} = 0;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2011-07-20 20:32:09 +00:00
|
|
|
bits<5> sh;
|
|
|
|
let Inst{14-12} = sh{4-2};
|
|
|
|
let Inst{7-6} = sh{1-0};
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2009-07-07 05:35:52 +00:00
|
|
|
|
|
|
|
// Alternate cases for PKHTB where identities eliminate some nodes. Note that
|
|
|
|
// a shift amount of 0 is *not legal* here, it is PKHBT instead.
|
2010-08-16 22:26:55 +00:00
|
|
|
def : T2Pat<(or (and rGPR:$src1, 0xFFFF0000), (srl rGPR:$src2, imm16_31:$sh)),
|
2011-07-20 20:32:09 +00:00
|
|
|
(t2PKHTB rGPR:$src1, rGPR:$src2, imm16_31:$sh)>,
|
2010-11-01 15:59:52 +00:00
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
Many Thumb2 instructions can reference the full ARM register set (i.e.,
have 4 bits per register in the operand encoding), but have undefined
behavior when the operand value is 13 or 15 (SP and PC, respectively).
The trivial coalescer in linear scan sometimes will merge a copy from
SP into a subsequent instruction which uses the copy, and if that
instruction cannot legally reference SP, we get bad code such as:
mls r0,r9,r0,sp
instead of:
mov r2, sp
mls r0, r9, r0, r2
This patch adds a new register class for use by Thumb2 that excludes
the problematic registers (SP and PC) and is used instead of GPR
for those operands which cannot legally reference PC or SP. The
trivial coalescer explicitly requires that the register class
of the destination for the COPY instruction contain the source
register for the COPY to be considered for coalescing. This prevents
errant instructions like that above.
PR7499
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@109842 91177308-0d34-0410-b5e6-96231b3b80d8
2010-07-30 02:41:01 +00:00
|
|
|
def : T2Pat<(or (and rGPR:$src1, 0xFFFF0000),
|
2010-08-17 17:23:19 +00:00
|
|
|
(and (srl rGPR:$src2, imm1_15:$sh), 0xFFFF)),
|
2011-07-20 20:32:09 +00:00
|
|
|
(t2PKHTB rGPR:$src1, rGPR:$src2, imm1_15:$sh)>,
|
2010-11-01 15:59:52 +00:00
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Comparison Instructions...
|
|
|
|
//
|
2009-12-15 17:24:14 +00:00
|
|
|
defm t2CMP : T2I_cmp_irs<0b1101, "cmp",
|
2010-09-29 00:49:25 +00:00
|
|
|
IIC_iCMPi, IIC_iCMPr, IIC_iCMPsi,
|
2011-09-06 21:44:58 +00:00
|
|
|
BinOpFrag<(ARMcmp node:$LHS, node:$RHS)>, "t2CMP">;
|
2010-12-07 20:41:06 +00:00
|
|
|
|
2011-09-06 21:44:58 +00:00
|
|
|
def : T2Pat<(ARMcmpZ GPRnopc:$lhs, t2_so_imm:$imm),
|
|
|
|
(t2CMPri GPRnopc:$lhs, t2_so_imm:$imm)>;
|
|
|
|
def : T2Pat<(ARMcmpZ GPRnopc:$lhs, rGPR:$rhs),
|
|
|
|
(t2CMPrr GPRnopc:$lhs, rGPR:$rhs)>;
|
|
|
|
def : T2Pat<(ARMcmpZ GPRnopc:$lhs, t2_so_reg:$rhs),
|
|
|
|
(t2CMPrs GPRnopc:$lhs, t2_so_reg:$rhs)>;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2010-08-26 15:50:25 +00:00
|
|
|
//FIXME: Disable CMN, as CCodes are backwards from compare expectations
|
|
|
|
// Compare-to-zero still works out, just not the relationals
|
2010-01-22 00:08:13 +00:00
|
|
|
//defm t2CMN : T2I_cmp_irs<0b1000, "cmn",
|
|
|
|
// BinOpFrag<(ARMcmp node:$LHS,(ineg node:$RHS))>>;
|
2010-08-26 15:50:25 +00:00
|
|
|
defm t2CMNz : T2I_cmp_irs<0b1000, "cmn",
|
2010-09-29 00:49:25 +00:00
|
|
|
IIC_iCMPi, IIC_iCMPr, IIC_iCMPsi,
|
2011-09-06 21:44:58 +00:00
|
|
|
BinOpFrag<(ARMcmpZ node:$LHS,(ineg node:$RHS))>,
|
|
|
|
"t2CMNz">;
|
2010-08-26 15:50:25 +00:00
|
|
|
|
2010-01-22 00:08:13 +00:00
|
|
|
//def : T2Pat<(ARMcmp GPR:$src, t2_so_imm_neg:$imm),
|
|
|
|
// (t2CMNri GPR:$src, t2_so_imm_neg:$imm)>;
|
2010-08-26 15:50:25 +00:00
|
|
|
|
2011-09-06 21:44:58 +00:00
|
|
|
def : T2Pat<(ARMcmpZ GPRnopc:$src, t2_so_imm_neg:$imm),
|
|
|
|
(t2CMNzri GPRnopc:$src, t2_so_imm_neg:$imm)>;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2009-12-15 17:24:14 +00:00
|
|
|
defm t2TST : T2I_cmp_irs<0b0000, "tst",
|
2010-09-29 00:49:25 +00:00
|
|
|
IIC_iTSTi, IIC_iTSTr, IIC_iTSTsi,
|
2011-09-06 21:44:58 +00:00
|
|
|
BinOpFrag<(ARMcmpZ (and_su node:$LHS, node:$RHS), 0)>,
|
|
|
|
"t2TST">;
|
2009-12-15 17:24:14 +00:00
|
|
|
defm t2TEQ : T2I_cmp_irs<0b0100, "teq",
|
2010-09-29 00:49:25 +00:00
|
|
|
IIC_iTSTi, IIC_iTSTr, IIC_iTSTsi,
|
2011-09-06 21:44:58 +00:00
|
|
|
BinOpFrag<(ARMcmpZ (xor_su node:$LHS, node:$RHS), 0)>,
|
|
|
|
"t2TEQ">;
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2009-07-07 20:39:03 +00:00
|
|
|
// Conditional moves
|
|
|
|
// FIXME: should be able to write a pattern for ARMcmov, but can't use
|
2010-02-16 21:07:46 +00:00
|
|
|
// a two-value operand where a dag node expects two operands. :(
|
2010-11-13 02:25:14 +00:00
|
|
|
let neverHasSideEffects = 1 in {
|
2011-07-01 17:14:11 +00:00
|
|
|
def t2MOVCCr : t2PseudoInst<(outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$false, rGPR:$Rm, pred:$p),
|
2011-07-13 23:22:26 +00:00
|
|
|
4, IIC_iCMOVr,
|
2010-11-18 21:46:31 +00:00
|
|
|
[/*(set rGPR:$Rd, (ARMcmov rGPR:$false, rGPR:$Rm, imm:$cc, CCR:$ccr))*/]>,
|
2011-07-01 17:14:11 +00:00
|
|
|
RegConstraint<"$false = $Rd">;
|
2009-07-07 20:39:03 +00:00
|
|
|
|
2010-11-17 20:13:28 +00:00
|
|
|
let isMoveImm = 1 in
|
2011-07-01 17:14:11 +00:00
|
|
|
def t2MOVCCi : t2PseudoInst<(outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$false, t2_so_imm:$imm, pred:$p),
|
2011-07-13 23:22:26 +00:00
|
|
|
4, IIC_iCMOVi,
|
2010-11-18 21:46:31 +00:00
|
|
|
[/*(set rGPR:$Rd,(ARMcmov rGPR:$false,t2_so_imm:$imm, imm:$cc, CCR:$ccr))*/]>,
|
2011-07-01 17:14:11 +00:00
|
|
|
RegConstraint<"$false = $Rd">;
|
2009-12-15 17:24:14 +00:00
|
|
|
|
2011-07-01 17:14:11 +00:00
|
|
|
// FIXME: Pseudo-ize these. For now, just mark codegen only.
|
|
|
|
let isCodeGenOnly = 1 in {
|
2010-11-17 20:13:28 +00:00
|
|
|
let isMoveImm = 1 in
|
2011-07-19 19:13:28 +00:00
|
|
|
def t2MOVCCi16 : T2I<(outs rGPR:$Rd), (ins rGPR:$false, imm0_65535_expr:$imm),
|
2010-11-12 22:42:47 +00:00
|
|
|
IIC_iCMOVi,
|
2010-11-16 00:29:56 +00:00
|
|
|
"movw", "\t$Rd, $imm", []>,
|
|
|
|
RegConstraint<"$false = $Rd"> {
|
2010-10-07 00:53:56 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 1;
|
|
|
|
let Inst{24-21} = 0b0010;
|
|
|
|
let Inst{20} = 0; // The S bit.
|
|
|
|
let Inst{15} = 0;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-11-16 00:29:56 +00:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<16> imm;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-16 00:29:56 +00:00
|
|
|
let Inst{19-16} = imm{15-12};
|
|
|
|
let Inst{26} = imm{11};
|
|
|
|
let Inst{14-12} = imm{10-8};
|
|
|
|
let Inst{7-0} = imm{7-0};
|
2010-10-07 00:53:56 +00:00
|
|
|
}
|
|
|
|
|
2010-11-17 20:13:28 +00:00
|
|
|
let isMoveImm = 1 in
|
2010-11-13 02:25:14 +00:00
|
|
|
def t2MOVCCi32imm : PseudoInst<(outs rGPR:$dst),
|
|
|
|
(ins rGPR:$false, i32imm:$src, pred:$p),
|
2010-11-18 01:38:26 +00:00
|
|
|
IIC_iCMOVix2, []>, RegConstraint<"$false = $dst">;
|
2010-11-13 02:25:14 +00:00
|
|
|
|
2010-11-17 20:13:28 +00:00
|
|
|
let isMoveImm = 1 in
|
2010-11-18 21:46:31 +00:00
|
|
|
def t2MVNCCi : T2OneRegImm<(outs rGPR:$Rd), (ins rGPR:$false, t2_so_imm:$imm),
|
|
|
|
IIC_iCMOVi, "mvn", ".w\t$Rd, $imm",
|
|
|
|
[/*(set rGPR:$Rd,(ARMcmov rGPR:$false,t2_so_imm_not:$imm,
|
2010-11-12 22:42:47 +00:00
|
|
|
imm:$cc, CCR:$ccr))*/]>,
|
2010-11-18 21:46:31 +00:00
|
|
|
RegConstraint<"$false = $Rd"> {
|
2010-11-12 22:42:47 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 0;
|
|
|
|
let Inst{24-21} = 0b0011;
|
|
|
|
let Inst{20} = 0; // The S bit.
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
|
|
|
|
2009-12-15 17:24:14 +00:00
|
|
|
class T2I_movcc_sh<bits<2> opcod, dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-15 19:58:36 +00:00
|
|
|
: T2TwoRegShiftImm<oops, iops, itin, opc, asm, pattern> {
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = 0b0010;
|
|
|
|
let Inst{20} = 0; // The S bit.
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{5-4} = opcod; // Shift type.
|
|
|
|
}
|
2010-11-15 19:58:36 +00:00
|
|
|
def t2MOVCClsl : T2I_movcc_sh<0b00, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$false, rGPR:$Rm, i32imm:$imm),
|
|
|
|
IIC_iCMOVsi, "lsl", ".w\t$Rd, $Rm, $imm", []>,
|
|
|
|
RegConstraint<"$false = $Rd">;
|
|
|
|
def t2MOVCClsr : T2I_movcc_sh<0b01, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$false, rGPR:$Rm, i32imm:$imm),
|
|
|
|
IIC_iCMOVsi, "lsr", ".w\t$Rd, $Rm, $imm", []>,
|
|
|
|
RegConstraint<"$false = $Rd">;
|
|
|
|
def t2MOVCCasr : T2I_movcc_sh<0b10, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$false, rGPR:$Rm, i32imm:$imm),
|
|
|
|
IIC_iCMOVsi, "asr", ".w\t$Rd, $Rm, $imm", []>,
|
|
|
|
RegConstraint<"$false = $Rd">;
|
|
|
|
def t2MOVCCror : T2I_movcc_sh<0b11, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$false, rGPR:$Rm, i32imm:$imm),
|
|
|
|
IIC_iCMOVsi, "ror", ".w\t$Rd, $Rm, $imm", []>,
|
|
|
|
RegConstraint<"$false = $Rd">;
|
2011-06-27 23:54:06 +00:00
|
|
|
} // isCodeGenOnly = 1
|
2011-07-01 17:14:11 +00:00
|
|
|
} // neverHasSideEffects
|
2009-08-01 01:43:45 +00:00
|
|
|
|
2009-12-14 18:56:47 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Atomic operations intrinsics
|
|
|
|
//
|
|
|
|
|
|
|
|
// memory barriers protect the atomic sequences
|
|
|
|
let hasSideEffects = 1 in {
|
2010-10-30 00:54:37 +00:00
|
|
|
def t2DMB : AInoP<(outs), (ins memb_opt:$opt), ThumbFrm, NoItinerary,
|
|
|
|
"dmb", "\t$opt", [(ARMMemBarrier (i32 imm:$opt))]>,
|
|
|
|
Requires<[IsThumb, HasDB]> {
|
|
|
|
bits<4> opt;
|
|
|
|
let Inst{31-4} = 0xf3bf8f5;
|
|
|
|
let Inst{3-0} = opt;
|
2009-12-14 18:56:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-30 00:54:37 +00:00
|
|
|
def t2DSB : AInoP<(outs), (ins memb_opt:$opt), ThumbFrm, NoItinerary,
|
2011-09-06 22:53:27 +00:00
|
|
|
"dsb", "\t$opt", []>,
|
2010-10-30 00:54:37 +00:00
|
|
|
Requires<[IsThumb, HasDB]> {
|
|
|
|
bits<4> opt;
|
|
|
|
let Inst{31-4} = 0xf3bf8f4;
|
|
|
|
let Inst{3-0} = opt;
|
2010-03-03 00:16:28 +00:00
|
|
|
}
|
|
|
|
|
2011-09-06 22:53:27 +00:00
|
|
|
def t2ISB : AInoP<(outs), (ins memb_opt:$opt), ThumbFrm, NoItinerary,
|
|
|
|
"isb", "\t$opt",
|
2011-09-06 23:09:19 +00:00
|
|
|
[]>, Requires<[IsThumb2, HasDB]> {
|
2011-09-06 22:53:27 +00:00
|
|
|
bits<4> opt;
|
2010-10-30 00:54:37 +00:00
|
|
|
let Inst{31-4} = 0xf3bf8f6;
|
2011-09-06 22:53:27 +00:00
|
|
|
let Inst{3-0} = opt;
|
2010-03-03 00:16:28 +00:00
|
|
|
}
|
|
|
|
|
2011-07-13 23:22:26 +00:00
|
|
|
class T2I_ldrex<bits<2> opcod, dag oops, dag iops, AddrMode am, int sz,
|
2009-12-15 17:24:14 +00:00
|
|
|
InstrItinClass itin, string opc, string asm, string cstr,
|
|
|
|
list<dag> pattern, bits<4> rt2 = 0b1111>
|
|
|
|
: Thumb2I<oops, iops, am, sz, itin, opc, asm, cstr, pattern> {
|
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-20} = 0b0001101;
|
|
|
|
let Inst{11-8} = rt2;
|
|
|
|
let Inst{7-6} = 0b01;
|
|
|
|
let Inst{5-4} = opcod;
|
|
|
|
let Inst{3-0} = 0b1111;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2011-03-24 21:04:58 +00:00
|
|
|
bits<4> addr;
|
2010-11-19 00:28:38 +00:00
|
|
|
bits<4> Rt;
|
2011-03-24 21:04:58 +00:00
|
|
|
let Inst{19-16} = addr;
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{15-12} = Rt;
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2011-07-13 23:22:26 +00:00
|
|
|
class T2I_strex<bits<2> opcod, dag oops, dag iops, AddrMode am, int sz,
|
2009-12-15 17:24:14 +00:00
|
|
|
InstrItinClass itin, string opc, string asm, string cstr,
|
|
|
|
list<dag> pattern, bits<4> rt2 = 0b1111>
|
|
|
|
: Thumb2I<oops, iops, am, sz, itin, opc, asm, cstr, pattern> {
|
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-20} = 0b0001100;
|
|
|
|
let Inst{11-8} = rt2;
|
|
|
|
let Inst{7-6} = 0b01;
|
|
|
|
let Inst{5-4} = opcod;
|
2010-11-19 17:11:02 +00:00
|
|
|
|
2010-11-19 00:28:38 +00:00
|
|
|
bits<4> Rd;
|
2011-03-24 21:04:58 +00:00
|
|
|
bits<4> addr;
|
2010-11-19 00:28:38 +00:00
|
|
|
bits<4> Rt;
|
2011-03-24 21:04:58 +00:00
|
|
|
let Inst{3-0} = Rd;
|
|
|
|
let Inst{19-16} = addr;
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{15-12} = Rt;
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
|
|
|
|
2009-12-14 18:56:47 +00:00
|
|
|
let mayLoad = 1 in {
|
2011-09-09 18:37:27 +00:00
|
|
|
def t2LDREXB : T2I_ldrex<0b00, (outs rGPR:$Rt), (ins addr_offset_none:$addr),
|
2011-07-13 23:22:26 +00:00
|
|
|
AddrModeNone, 4, NoItinerary,
|
2011-06-13 22:54:22 +00:00
|
|
|
"ldrexb", "\t$Rt, $addr", "", []>;
|
2011-09-09 18:37:27 +00:00
|
|
|
def t2LDREXH : T2I_ldrex<0b01, (outs rGPR:$Rt), (ins addr_offset_none:$addr),
|
2011-07-13 23:22:26 +00:00
|
|
|
AddrModeNone, 4, NoItinerary,
|
2011-06-13 22:54:22 +00:00
|
|
|
"ldrexh", "\t$Rt, $addr", "", []>;
|
2011-09-09 18:37:27 +00:00
|
|
|
def t2LDREX : Thumb2I<(outs rGPR:$Rt), (ins t2addrmode_imm0_1020s4:$addr),
|
2011-07-13 23:22:26 +00:00
|
|
|
AddrModeNone, 4, NoItinerary,
|
2011-06-13 22:54:22 +00:00
|
|
|
"ldrex", "\t$Rt, $addr", "", []> {
|
2011-09-09 18:37:27 +00:00
|
|
|
bits<4> Rt;
|
|
|
|
bits<12> addr;
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-20} = 0b0000101;
|
2011-09-09 18:37:27 +00:00
|
|
|
let Inst{19-16} = addr{11-8};
|
2010-12-10 21:52:38 +00:00
|
|
|
let Inst{15-12} = Rt;
|
2011-09-09 18:37:27 +00:00
|
|
|
let Inst{11-8} = 0b1111;
|
|
|
|
let Inst{7-0} = addr{7-0};
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2011-05-28 04:07:29 +00:00
|
|
|
let hasExtraDefRegAllocReq = 1 in
|
|
|
|
def t2LDREXD : T2I_ldrex<0b11, (outs rGPR:$Rt, rGPR:$Rt2),
|
2011-09-09 18:37:27 +00:00
|
|
|
(ins addr_offset_none:$addr),
|
2011-07-13 23:22:26 +00:00
|
|
|
AddrModeNone, 4, NoItinerary,
|
2011-03-24 21:04:58 +00:00
|
|
|
"ldrexd", "\t$Rt, $Rt2, $addr", "",
|
2010-11-19 00:28:38 +00:00
|
|
|
[], {?, ?, ?, ?}> {
|
|
|
|
bits<4> Rt2;
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rt2;
|
2010-11-19 00:28:38 +00:00
|
|
|
}
|
2009-12-14 18:56:47 +00:00
|
|
|
}
|
|
|
|
|
2010-11-19 00:28:38 +00:00
|
|
|
let mayStore = 1, Constraints = "@earlyclobber $Rd" in {
|
2011-06-13 22:54:22 +00:00
|
|
|
def t2STREXB : T2I_strex<0b00, (outs rGPR:$Rd),
|
2011-09-09 18:37:27 +00:00
|
|
|
(ins rGPR:$Rt, addr_offset_none:$addr),
|
2011-07-13 23:22:26 +00:00
|
|
|
AddrModeNone, 4, NoItinerary,
|
2011-06-13 22:54:22 +00:00
|
|
|
"strexb", "\t$Rd, $Rt, $addr", "", []>;
|
|
|
|
def t2STREXH : T2I_strex<0b01, (outs rGPR:$Rd),
|
2011-09-09 18:37:27 +00:00
|
|
|
(ins rGPR:$Rt, addr_offset_none:$addr),
|
2011-07-13 23:22:26 +00:00
|
|
|
AddrModeNone, 4, NoItinerary,
|
2011-06-13 22:54:22 +00:00
|
|
|
"strexh", "\t$Rd, $Rt, $addr", "", []>;
|
2011-09-09 18:37:27 +00:00
|
|
|
def t2STREX : Thumb2I<(outs rGPR:$Rd), (ins rGPR:$Rt,
|
|
|
|
t2addrmode_imm0_1020s4:$addr),
|
2011-07-13 23:22:26 +00:00
|
|
|
AddrModeNone, 4, NoItinerary,
|
2011-03-24 21:04:58 +00:00
|
|
|
"strex", "\t$Rd, $Rt, $addr", "",
|
|
|
|
[]> {
|
2010-12-10 21:52:38 +00:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rt;
|
2011-09-09 18:37:27 +00:00
|
|
|
bits<12> addr;
|
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-20} = 0b0000100;
|
|
|
|
let Inst{19-16} = addr{11-8};
|
2010-12-10 21:52:38 +00:00
|
|
|
let Inst{15-12} = Rt;
|
2011-09-09 18:37:27 +00:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{7-0} = addr{7-0};
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2011-05-28 04:07:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
let hasExtraSrcRegAllocReq = 1, Constraints = "@earlyclobber $Rd" in
|
2010-11-19 00:28:38 +00:00
|
|
|
def t2STREXD : T2I_strex<0b11, (outs rGPR:$Rd),
|
2011-09-09 18:37:27 +00:00
|
|
|
(ins rGPR:$Rt, rGPR:$Rt2, addr_offset_none:$addr),
|
2011-07-13 23:22:26 +00:00
|
|
|
AddrModeNone, 4, NoItinerary,
|
2011-03-24 21:04:58 +00:00
|
|
|
"strexd", "\t$Rd, $Rt, $Rt2, $addr", "", [],
|
2010-11-19 00:28:38 +00:00
|
|
|
{?, ?, ?, ?}> {
|
|
|
|
bits<4> Rt2;
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rt2;
|
2010-11-19 00:28:38 +00:00
|
|
|
}
|
2009-12-14 18:56:47 +00:00
|
|
|
|
2011-09-06 20:27:04 +00:00
|
|
|
def t2CLREX : T2I<(outs), (ins), NoItinerary, "clrex", "", []>,
|
2011-01-20 19:18:32 +00:00
|
|
|
Requires<[IsThumb2, HasV7]> {
|
|
|
|
let Inst{31-16} = 0xf3bf;
|
2010-03-02 22:11:06 +00:00
|
|
|
let Inst{15-14} = 0b10;
|
2011-01-20 19:18:32 +00:00
|
|
|
let Inst{13} = 0;
|
2010-03-02 22:11:06 +00:00
|
|
|
let Inst{12} = 0;
|
2011-01-20 19:18:32 +00:00
|
|
|
let Inst{11-8} = 0b1111;
|
2010-03-02 22:11:06 +00:00
|
|
|
let Inst{7-4} = 0b0010;
|
2011-01-20 19:18:32 +00:00
|
|
|
let Inst{3-0} = 0b1111;
|
2010-03-02 22:11:06 +00:00
|
|
|
}
|
|
|
|
|
2009-08-11 19:42:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SJLJ Exception handling intrinsics
|
2009-08-13 15:11:43 +00:00
|
|
|
// eh_sjlj_setjmp() is an instruction sequence to store the return
|
2009-08-11 19:42:21 +00:00
|
|
|
// address and save #0 in R0 for the non-longjmp case.
|
|
|
|
// Since by its nature we may be coming from some other function to get
|
|
|
|
// here, and we're using the stack frame for the containing function to
|
|
|
|
// save/restore registers, we can't keep anything live in regs across
|
|
|
|
// the eh_sjlj_setjmp(), else it will almost certainly have been tromped upon
|
2011-04-15 05:18:47 +00:00
|
|
|
// when we get here from a longjmp(). We force everything out of registers
|
2009-08-11 19:42:21 +00:00
|
|
|
// except for our own input by listing the relevant registers in Defs. By
|
|
|
|
// doing so, we also cause the prologue/epilogue code to actively preserve
|
|
|
|
// all of the callee-saved resgisters, which is exactly what we want.
|
2010-05-27 23:49:24 +00:00
|
|
|
// $val is a scratch register for our use.
|
2010-02-08 23:22:00 +00:00
|
|
|
let Defs =
|
2011-06-07 00:08:49 +00:00
|
|
|
[ R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, LR, CPSR,
|
2011-05-03 22:31:24 +00:00
|
|
|
QQQQ0, QQQQ1, QQQQ2, QQQQ3 ],
|
|
|
|
hasSideEffects = 1, isBarrier = 1, isCodeGenOnly = 1 in {
|
2010-08-26 17:02:47 +00:00
|
|
|
def t2Int_eh_sjlj_setjmp : Thumb2XI<(outs), (ins tGPR:$src, tGPR:$val),
|
2011-07-13 23:22:26 +00:00
|
|
|
AddrModeNone, 0, NoItinerary, "", "",
|
2010-08-26 17:02:47 +00:00
|
|
|
[(set R0, (ARMeh_sjlj_setjmp tGPR:$src, tGPR:$val))]>,
|
2010-04-09 20:41:18 +00:00
|
|
|
Requires<[IsThumb2, HasVFP2]>;
|
2009-08-11 19:42:21 +00:00
|
|
|
}
|
|
|
|
|
2010-04-09 20:41:18 +00:00
|
|
|
let Defs =
|
2011-06-07 00:08:49 +00:00
|
|
|
[ R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, LR, CPSR ],
|
2010-10-31 19:15:18 +00:00
|
|
|
hasSideEffects = 1, isBarrier = 1, isCodeGenOnly = 1 in {
|
2010-08-26 17:02:47 +00:00
|
|
|
def t2Int_eh_sjlj_setjmp_nofp : Thumb2XI<(outs), (ins tGPR:$src, tGPR:$val),
|
2011-07-13 23:22:26 +00:00
|
|
|
AddrModeNone, 0, NoItinerary, "", "",
|
2010-08-26 17:02:47 +00:00
|
|
|
[(set R0, (ARMeh_sjlj_setjmp tGPR:$src, tGPR:$val))]>,
|
2010-04-09 20:41:18 +00:00
|
|
|
Requires<[IsThumb2, NoVFP]>;
|
|
|
|
}
|
2009-08-11 19:42:21 +00:00
|
|
|
|
|
|
|
|
2009-06-30 18:04:13 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Control-Flow Instructions
|
|
|
|
//
|
|
|
|
|
2009-07-09 22:58:39 +00:00
|
|
|
// FIXME: remove when we have a way to marking a MI with these properties.
|
|
|
|
// FIXME: Should pc be an implicit operand like PICADD, etc?
|
2009-10-01 08:22:27 +00:00
|
|
|
let isReturn = 1, isTerminator = 1, isBarrier = 1, mayLoad = 1,
|
2010-10-31 19:10:56 +00:00
|
|
|
hasExtraDefRegAllocReq = 1, isCodeGenOnly = 1 in
|
2011-07-08 17:40:42 +00:00
|
|
|
def t2LDMIA_RET: t2PseudoExpand<(outs GPR:$wb), (ins GPR:$Rn, pred:$p,
|
2011-06-30 18:25:42 +00:00
|
|
|
reglist:$regs, variable_ops),
|
2011-07-13 23:22:26 +00:00
|
|
|
4, IIC_iLoad_mBr, [],
|
2011-07-08 17:40:42 +00:00
|
|
|
(t2LDMIA_UPD GPR:$wb, GPR:$Rn, pred:$p, reglist:$regs)>,
|
2011-06-30 18:25:42 +00:00
|
|
|
RegConstraint<"$Rn = $wb">;
|
2009-07-09 22:58:39 +00:00
|
|
|
|
2009-06-30 18:04:13 +00:00
|
|
|
let isBranch = 1, isTerminator = 1, isBarrier = 1 in {
|
|
|
|
let isPredicable = 1 in
|
2011-09-09 21:48:23 +00:00
|
|
|
def t2B : T2I<(outs), (ins uncondbrtarget:$target), IIC_Br,
|
|
|
|
"b", ".w\t$target",
|
2009-12-15 17:24:14 +00:00
|
|
|
[(br bb:$target)]> {
|
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{15-14} = 0b10;
|
|
|
|
let Inst{12} = 1;
|
2010-11-29 18:54:38 +00:00
|
|
|
|
|
|
|
bits<20> target;
|
|
|
|
let Inst{26} = target{19};
|
|
|
|
let Inst{11} = target{18};
|
|
|
|
let Inst{13} = target{17};
|
|
|
|
let Inst{21-16} = target{16-11};
|
|
|
|
let Inst{10-0} = target{10-0};
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2009-06-30 18:04:13 +00:00
|
|
|
|
2010-11-29 22:40:58 +00:00
|
|
|
let isNotDuplicable = 1, isIndirectBranch = 1 in {
|
2010-12-15 19:03:16 +00:00
|
|
|
def t2BR_JT : t2PseudoInst<(outs),
|
2010-11-29 22:37:40 +00:00
|
|
|
(ins GPR:$target, GPR:$index, i32imm:$jt, i32imm:$id),
|
2011-07-13 23:22:26 +00:00
|
|
|
0, IIC_Br,
|
2010-11-29 22:37:40 +00:00
|
|
|
[(ARMbr2jt GPR:$target, GPR:$index, tjumptable:$jt, imm:$id)]>;
|
2009-07-29 02:18:14 +00:00
|
|
|
|
2009-08-01 06:13:52 +00:00
|
|
|
// FIXME: Add a non-pc based case that can be predicated.
|
2010-12-15 19:03:16 +00:00
|
|
|
def t2TBB_JT : t2PseudoInst<(outs),
|
2010-11-29 22:37:40 +00:00
|
|
|
(ins GPR:$index, i32imm:$jt, i32imm:$id),
|
2011-07-13 23:22:26 +00:00
|
|
|
0, IIC_Br, []>;
|
2009-07-29 02:18:14 +00:00
|
|
|
|
2010-12-15 19:03:16 +00:00
|
|
|
def t2TBH_JT : t2PseudoInst<(outs),
|
2010-11-29 22:37:40 +00:00
|
|
|
(ins GPR:$index, i32imm:$jt, i32imm:$id),
|
2011-07-13 23:22:26 +00:00
|
|
|
0, IIC_Br, []>;
|
Added 32-bit Thumb instructions: CPS, SDIV, UDIV, SXTB16, SXTAB16, UXTAB16, SEL,
SMMULR, SMMLAR, SMMLSR, TBB, TBH, and 16-bit Thumb instruction CPS for
disassembly only.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97573 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-02 18:14:57 +00:00
|
|
|
|
2010-11-29 22:37:40 +00:00
|
|
|
def t2TBB : T2I<(outs), (ins GPR:$Rn, GPR:$Rm), IIC_Br,
|
|
|
|
"tbb", "\t[$Rn, $Rm]", []> {
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
2010-12-17 18:42:56 +00:00
|
|
|
let Inst{31-20} = 0b111010001101;
|
2010-11-29 22:37:40 +00:00
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{15-5} = 0b11110000000;
|
|
|
|
let Inst{4} = 0; // B form
|
|
|
|
let Inst{3-0} = Rm;
|
Added 32-bit Thumb instructions: CPS, SDIV, UDIV, SXTB16, SXTAB16, UXTAB16, SEL,
SMMULR, SMMLAR, SMMLSR, TBB, TBH, and 16-bit Thumb instruction CPS for
disassembly only.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97573 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-02 18:14:57 +00:00
|
|
|
}
|
|
|
|
|
2010-11-29 22:37:40 +00:00
|
|
|
def t2TBH : T2I<(outs), (ins GPR:$Rn, GPR:$Rm), IIC_Br,
|
|
|
|
"tbh", "\t[$Rn, $Rm, lsl #1]", []> {
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
2010-12-17 18:42:56 +00:00
|
|
|
let Inst{31-20} = 0b111010001101;
|
2010-11-29 22:37:40 +00:00
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{15-5} = 0b11110000000;
|
|
|
|
let Inst{4} = 1; // H form
|
|
|
|
let Inst{3-0} = Rm;
|
Added 32-bit Thumb instructions: CPS, SDIV, UDIV, SXTB16, SXTAB16, UXTAB16, SEL,
SMMULR, SMMLAR, SMMLSR, TBB, TBH, and 16-bit Thumb instruction CPS for
disassembly only.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97573 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-02 18:14:57 +00:00
|
|
|
}
|
2009-07-29 02:18:14 +00:00
|
|
|
} // isNotDuplicable, isIndirectBranch
|
|
|
|
|
2009-06-30 19:50:22 +00:00
|
|
|
} // isBranch, isTerminator, isBarrier
|
2009-06-30 18:04:13 +00:00
|
|
|
|
|
|
|
// FIXME: should be able to write a pattern for ARMBrcond, but can't use
|
2011-09-09 21:48:23 +00:00
|
|
|
// a two-value operand where a dag node expects ", "two operands. :(
|
2009-06-30 18:04:13 +00:00
|
|
|
let isBranch = 1, isTerminator = 1 in
|
2009-08-06 16:52:47 +00:00
|
|
|
def t2Bcc : T2I<(outs), (ins brtarget:$target), IIC_Br,
|
2009-10-27 00:08:59 +00:00
|
|
|
"b", ".w\t$target",
|
2009-12-15 17:24:14 +00:00
|
|
|
[/*(ARMbrcond bb:$target, imm:$cc)*/]> {
|
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{15-14} = 0b10;
|
|
|
|
let Inst{12} = 0;
|
2010-12-14 20:46:39 +00:00
|
|
|
|
2010-12-09 00:27:41 +00:00
|
|
|
bits<4> p;
|
|
|
|
let Inst{25-22} = p;
|
|
|
|
|
|
|
|
bits<21> target;
|
|
|
|
let Inst{26} = target{20};
|
|
|
|
let Inst{11} = target{19};
|
|
|
|
let Inst{13} = target{18};
|
|
|
|
let Inst{21-16} = target{17-12};
|
|
|
|
let Inst{10-0} = target{11-1};
|
2011-08-09 20:55:18 +00:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeThumb2BCCInstruction";
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2009-06-23 17:48:47 +00:00
|
|
|
|
2011-07-08 20:32:21 +00:00
|
|
|
// Tail calls. The Darwin version of thumb tail calls uses a t2 branch, so
|
|
|
|
// it goes here.
|
|
|
|
let isCall = 1, isTerminator = 1, isReturn = 1, isBarrier = 1 in {
|
|
|
|
// Darwin version.
|
|
|
|
let Defs = [R0, R1, R2, R3, R9, R12, QQQQ0, QQQQ2, QQQQ3, PC],
|
|
|
|
Uses = [SP] in
|
2011-09-09 21:48:23 +00:00
|
|
|
def tTAILJMPd: tPseudoExpand<(outs),
|
|
|
|
(ins uncondbrtarget:$dst, pred:$p, variable_ops),
|
2011-07-13 23:22:26 +00:00
|
|
|
4, IIC_Br, [],
|
2011-09-09 21:48:23 +00:00
|
|
|
(t2B uncondbrtarget:$dst, pred:$p)>,
|
2011-07-08 20:32:21 +00:00
|
|
|
Requires<[IsThumb2, IsDarwin]>;
|
|
|
|
}
|
2009-07-10 01:54:42 +00:00
|
|
|
|
|
|
|
// IT block
|
2010-06-18 23:09:54 +00:00
|
|
|
let Defs = [ITSTATE] in
|
2009-07-10 01:54:42 +00:00
|
|
|
def t2IT : Thumb2XI<(outs), (ins it_pred:$cc, it_mask:$mask),
|
2011-07-13 23:22:26 +00:00
|
|
|
AddrModeNone, 2, IIC_iALUx,
|
2009-12-15 17:24:14 +00:00
|
|
|
"it$mask\t$cc", "", []> {
|
|
|
|
// 16-bit instruction.
|
2009-12-16 02:32:54 +00:00
|
|
|
let Inst{31-16} = 0x0000;
|
2009-12-15 17:24:14 +00:00
|
|
|
let Inst{15-8} = 0b10111111;
|
2010-11-29 18:54:38 +00:00
|
|
|
|
|
|
|
bits<4> cc;
|
|
|
|
bits<4> mask;
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{7-4} = cc;
|
|
|
|
let Inst{3-0} = mask;
|
2011-08-30 22:58:27 +00:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeIT";
|
2009-12-15 17:24:14 +00:00
|
|
|
}
|
2009-07-10 01:54:42 +00:00
|
|
|
|
2010-02-25 19:05:29 +00:00
|
|
|
// Branch and Exchange Jazelle -- for disassembly only
|
|
|
|
// Rm = Inst{19-16}
|
2011-09-02 23:43:09 +00:00
|
|
|
def t2BXJ : T2I<(outs), (ins rGPR:$func), NoItinerary, "bxj", "\t$func", []> {
|
|
|
|
bits<4> func;
|
2010-02-25 19:05:29 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{26} = 0;
|
|
|
|
let Inst{25-20} = 0b111100;
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{19-16} = func;
|
2011-09-02 23:43:09 +00:00
|
|
|
let Inst{15-0} = 0b1000111100000000;
|
2010-02-25 19:05:29 +00:00
|
|
|
}
|
|
|
|
|
2011-08-18 17:51:36 +00:00
|
|
|
// Compare and branch on zero / non-zero
|
|
|
|
let isBranch = 1, isTerminator = 1 in {
|
|
|
|
def tCBZ : T1I<(outs), (ins tGPR:$Rn, t_cbtarget:$target), IIC_Br,
|
|
|
|
"cbz\t$Rn, $target", []>,
|
|
|
|
T1Misc<{0,0,?,1,?,?,?}>,
|
|
|
|
Requires<[IsThumb2]> {
|
|
|
|
// A8.6.27
|
|
|
|
bits<6> target;
|
|
|
|
bits<3> Rn;
|
|
|
|
let Inst{9} = target{5};
|
|
|
|
let Inst{7-3} = target{4-0};
|
|
|
|
let Inst{2-0} = Rn;
|
|
|
|
}
|
|
|
|
|
|
|
|
def tCBNZ : T1I<(outs), (ins tGPR:$Rn, t_cbtarget:$target), IIC_Br,
|
|
|
|
"cbnz\t$Rn, $target", []>,
|
|
|
|
T1Misc<{1,0,?,1,?,?,?}>,
|
|
|
|
Requires<[IsThumb2]> {
|
|
|
|
// A8.6.27
|
|
|
|
bits<6> target;
|
|
|
|
bits<3> Rn;
|
|
|
|
let Inst{9} = target{5};
|
|
|
|
let Inst{7-3} = target{4-0};
|
|
|
|
let Inst{2-0} = Rn;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-14 13:09:44 +00:00
|
|
|
// Change Processor State is a system instruction -- for disassembly and
|
|
|
|
// parsing only.
|
|
|
|
// FIXME: Since the asm parser has currently no clean way to handle optional
|
|
|
|
// operands, create 3 versions of the same instruction. Once there's a clean
|
|
|
|
// framework to represent optional operands, change this behavior.
|
|
|
|
class t2CPS<dag iops, string asm_op> : T2XI<(outs), iops, NoItinerary,
|
|
|
|
!strconcat("cps", asm_op),
|
|
|
|
[/* For disassembly only; pattern left blank */]> {
|
|
|
|
bits<2> imod;
|
|
|
|
bits<3> iflags;
|
|
|
|
bits<5> mode;
|
|
|
|
bit M;
|
|
|
|
|
Added 32-bit Thumb instructions: CPS, SDIV, UDIV, SXTB16, SXTAB16, UXTAB16, SEL,
SMMULR, SMMLAR, SMMLSR, TBB, TBH, and 16-bit Thumb instruction CPS for
disassembly only.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97573 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-02 18:14:57 +00:00
|
|
|
let Inst{31-27} = 0b11110;
|
2011-02-14 13:09:44 +00:00
|
|
|
let Inst{26} = 0;
|
Added 32-bit Thumb instructions: CPS, SDIV, UDIV, SXTB16, SXTAB16, UXTAB16, SEL,
SMMULR, SMMLAR, SMMLSR, TBB, TBH, and 16-bit Thumb instruction CPS for
disassembly only.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97573 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-02 18:14:57 +00:00
|
|
|
let Inst{25-20} = 0b111010;
|
2011-02-14 13:09:44 +00:00
|
|
|
let Inst{19-16} = 0b1111;
|
Added 32-bit Thumb instructions: CPS, SDIV, UDIV, SXTB16, SXTAB16, UXTAB16, SEL,
SMMULR, SMMLAR, SMMLSR, TBB, TBH, and 16-bit Thumb instruction CPS for
disassembly only.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97573 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-02 18:14:57 +00:00
|
|
|
let Inst{15-14} = 0b10;
|
2011-02-14 13:09:44 +00:00
|
|
|
let Inst{12} = 0;
|
|
|
|
let Inst{10-9} = imod;
|
|
|
|
let Inst{8} = M;
|
|
|
|
let Inst{7-5} = iflags;
|
|
|
|
let Inst{4-0} = mode;
|
2011-08-23 17:45:18 +00:00
|
|
|
let DecoderMethod = "DecodeT2CPSInstruction";
|
2011-02-14 13:09:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
let M = 1 in
|
|
|
|
def t2CPS3p : t2CPS<(ins imod_op:$imod, iflags_op:$iflags, i32imm:$mode),
|
|
|
|
"$imod.w\t$iflags, $mode">;
|
|
|
|
let mode = 0, M = 0 in
|
|
|
|
def t2CPS2p : t2CPS<(ins imod_op:$imod, iflags_op:$iflags),
|
|
|
|
"$imod.w\t$iflags">;
|
|
|
|
let imod = 0, iflags = 0, M = 1 in
|
|
|
|
def t2CPS1p : t2CPS<(ins i32imm:$mode), "\t$mode">;
|
Added 32-bit Thumb instructions: CPS, SDIV, UDIV, SXTB16, SXTAB16, UXTAB16, SEL,
SMMULR, SMMLAR, SMMLSR, TBB, TBH, and 16-bit Thumb instruction CPS for
disassembly only.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@97573 91177308-0d34-0410-b5e6-96231b3b80d8
2010-03-02 18:14:57 +00:00
|
|
|
|
2010-03-03 02:09:43 +00:00
|
|
|
// A6.3.4 Branches and miscellaneous control
|
|
|
|
// Table A6-14 Change Processor State, and hint instructions
|
|
|
|
// Helper class for disassembly only.
|
|
|
|
class T2I_hint<bits<8> op7_0, string opc, string asm>
|
|
|
|
: T2I<(outs), (ins), NoItinerary, opc, asm,
|
|
|
|
[/* For disassembly only; pattern left blank */]> {
|
|
|
|
let Inst{31-20} = 0xf3a;
|
2011-01-26 13:28:14 +00:00
|
|
|
let Inst{19-16} = 0b1111;
|
2010-03-03 02:09:43 +00:00
|
|
|
let Inst{15-14} = 0b10;
|
|
|
|
let Inst{12} = 0;
|
|
|
|
let Inst{10-8} = 0b000;
|
|
|
|
let Inst{7-0} = op7_0;
|
|
|
|
}
|
|
|
|
|
|
|
|
def t2NOP : T2I_hint<0b00000000, "nop", ".w">;
|
|
|
|
def t2YIELD : T2I_hint<0b00000001, "yield", ".w">;
|
|
|
|
def t2WFE : T2I_hint<0b00000010, "wfe", ".w">;
|
|
|
|
def t2WFI : T2I_hint<0b00000011, "wfi", ".w">;
|
|
|
|
def t2SEV : T2I_hint<0b00000100, "sev", ".w">;
|
|
|
|
|
2011-07-13 22:59:38 +00:00
|
|
|
def t2DBG : T2I<(outs), (ins imm0_15:$opt), NoItinerary, "dbg", "\t$opt", []> {
|
2010-11-30 20:00:01 +00:00
|
|
|
bits<4> opt;
|
2011-09-06 22:06:40 +00:00
|
|
|
let Inst{31-20} = 0b111100111010;
|
|
|
|
let Inst{19-16} = 0b1111;
|
|
|
|
let Inst{15-8} = 0b10000000;
|
|
|
|
let Inst{7-4} = 0b1111;
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{3-0} = opt;
|
2010-03-03 02:09:43 +00:00
|
|
|
}
|
|
|
|
|
2010-02-25 20:25:24 +00:00
|
|
|
// Secure Monitor Call is a system instruction -- for disassembly only
|
|
|
|
// Option = Inst{19-16}
|
2011-07-22 18:13:31 +00:00
|
|
|
def t2SMC : T2I<(outs), (ins imm0_15:$opt), NoItinerary, "smc", "\t$opt",
|
2010-02-25 20:25:24 +00:00
|
|
|
[/* For disassembly only; pattern left blank */]> {
|
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{26-20} = 0b1111111;
|
|
|
|
let Inst{15-12} = 0b1000;
|
2010-12-02 23:05:38 +00:00
|
|
|
|
2010-11-29 19:22:08 +00:00
|
|
|
bits<4> opt;
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{19-16} = opt;
|
2010-11-29 19:22:08 +00:00
|
|
|
}
|
|
|
|
|
2011-09-16 18:25:22 +00:00
|
|
|
class T2SRS<bits<2> Op, bit W, dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-29 19:22:08 +00:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<5> mode;
|
2011-09-16 18:25:22 +00:00
|
|
|
let Inst{31-25} = 0b1110100;
|
|
|
|
let Inst{24-23} = Op;
|
|
|
|
let Inst{22} = 0;
|
|
|
|
let Inst{21} = W;
|
|
|
|
let Inst{20-16} = 0b01101;
|
|
|
|
let Inst{15-5} = 0b11000000000;
|
2010-11-29 19:22:08 +00:00
|
|
|
let Inst{4-0} = mode{4-0};
|
2010-02-25 20:25:24 +00:00
|
|
|
}
|
|
|
|
|
2011-09-16 18:25:22 +00:00
|
|
|
// Store Return State is a system instruction.
|
|
|
|
def t2SRSDB_UPD : T2SRS<0b00, 1, (outs), (ins imm0_31:$mode), NoItinerary,
|
|
|
|
"srsdb", "\tsp!, $mode", []>;
|
|
|
|
def t2SRSDB : T2SRS<0b00, 0, (outs), (ins imm0_31:$mode), NoItinerary,
|
|
|
|
"srsdb","\tsp, $mode", []>;
|
|
|
|
def t2SRSIA_UPD : T2SRS<0b11, 1, (outs), (ins imm0_31:$mode), NoItinerary,
|
|
|
|
"srsia","\tsp!, $mode", []>;
|
|
|
|
def t2SRSIA : T2SRS<0b11, 0, (outs), (ins imm0_31:$mode), NoItinerary,
|
|
|
|
"srsia","\tsp, $mode", []>;
|
2010-11-29 19:22:08 +00:00
|
|
|
|
2011-09-16 18:25:22 +00:00
|
|
|
// Return From Exception is a system instruction.
|
2010-11-29 20:38:48 +00:00
|
|
|
class T2RFE<bits<12> op31_20, dag oops, dag iops, InstrItinClass itin,
|
2010-11-29 19:22:08 +00:00
|
|
|
string opc, string asm, list<dag> pattern>
|
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
2010-11-29 20:38:48 +00:00
|
|
|
let Inst{31-20} = op31_20{11-0};
|
2010-12-02 23:05:38 +00:00
|
|
|
|
2010-11-29 19:22:08 +00:00
|
|
|
bits<4> Rn;
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{19-16} = Rn;
|
2011-04-12 21:41:51 +00:00
|
|
|
let Inst{15-0} = 0xc000;
|
2010-11-29 19:22:08 +00:00
|
|
|
}
|
|
|
|
|
2010-11-29 20:38:48 +00:00
|
|
|
def t2RFEDBW : T2RFE<0b111010000011,
|
2011-04-12 21:41:51 +00:00
|
|
|
(outs), (ins GPR:$Rn), NoItinerary, "rfedb", "\t$Rn!",
|
2010-11-29 20:38:48 +00:00
|
|
|
[/* For disassembly only; pattern left blank */]>;
|
|
|
|
def t2RFEDB : T2RFE<0b111010000001,
|
2011-04-12 21:41:51 +00:00
|
|
|
(outs), (ins GPR:$Rn), NoItinerary, "rfedb", "\t$Rn",
|
2010-11-29 20:38:48 +00:00
|
|
|
[/* For disassembly only; pattern left blank */]>;
|
|
|
|
def t2RFEIAW : T2RFE<0b111010011011,
|
2011-04-12 21:41:51 +00:00
|
|
|
(outs), (ins GPR:$Rn), NoItinerary, "rfeia", "\t$Rn!",
|
2010-11-29 20:38:48 +00:00
|
|
|
[/* For disassembly only; pattern left blank */]>;
|
|
|
|
def t2RFEIA : T2RFE<0b111010011001,
|
2011-04-12 21:41:51 +00:00
|
|
|
(outs), (ins GPR:$Rn), NoItinerary, "rfeia", "\t$Rn",
|
2010-11-29 20:38:48 +00:00
|
|
|
[/* For disassembly only; pattern left blank */]>;
|
2010-02-25 20:25:24 +00:00
|
|
|
|
2009-06-23 17:48:47 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Non-Instruction Patterns
|
|
|
|
//
|
|
|
|
|
2009-09-28 09:14:39 +00:00
|
|
|
// 32-bit immediate using movw + movt.
|
2010-09-24 22:03:46 +00:00
|
|
|
// This is a single pseudo instruction to make it re-materializable.
|
|
|
|
// FIXME: Remove this when we can do generalized remat.
|
2011-01-19 02:16:49 +00:00
|
|
|
let isReMaterializable = 1, isMoveImm = 1 in
|
2010-10-06 22:01:26 +00:00
|
|
|
def t2MOVi32imm : PseudoInst<(outs rGPR:$dst), (ins i32imm:$src), IIC_iMOVix2,
|
2010-11-18 01:38:26 +00:00
|
|
|
[(set rGPR:$dst, (i32 imm:$src))]>,
|
2010-10-06 22:01:26 +00:00
|
|
|
Requires<[IsThumb, HasV6T2]>;
|
2009-11-06 23:52:48 +00:00
|
|
|
|
2011-01-21 18:55:51 +00:00
|
|
|
// Pseudo instruction that combines movw + movt + add pc (if pic).
|
2011-01-20 08:34:58 +00:00
|
|
|
// It also makes it possible to rematerialize the instructions.
|
|
|
|
// FIXME: Remove this when we can do generalized remat and when machine licm
|
|
|
|
// can properly the instructions.
|
2011-01-21 18:55:51 +00:00
|
|
|
let isReMaterializable = 1 in {
|
|
|
|
def t2MOV_ga_pcrel : PseudoInst<(outs rGPR:$dst), (ins i32imm:$addr),
|
|
|
|
IIC_iMOVix2addpc,
|
2011-01-20 08:34:58 +00:00
|
|
|
[(set rGPR:$dst, (ARMWrapperPIC tglobaladdr:$addr))]>,
|
|
|
|
Requires<[IsThumb2, UseMovt]>;
|
2011-01-17 08:03:18 +00:00
|
|
|
|
2011-01-21 18:55:51 +00:00
|
|
|
def t2MOV_ga_dyn : PseudoInst<(outs rGPR:$dst), (ins i32imm:$addr),
|
|
|
|
IIC_iMOVix2,
|
|
|
|
[(set rGPR:$dst, (ARMWrapperDYN tglobaladdr:$addr))]>,
|
|
|
|
Requires<[IsThumb2, UseMovt]>;
|
|
|
|
}
|
|
|
|
|
2009-11-24 00:44:37 +00:00
|
|
|
// ConstantPool, GlobalAddress, and JumpTable
|
|
|
|
def : T2Pat<(ARMWrapper tglobaladdr :$dst), (t2LEApcrel tglobaladdr :$dst)>,
|
|
|
|
Requires<[IsThumb2, DontUseMovt]>;
|
|
|
|
def : T2Pat<(ARMWrapper tconstpool :$dst), (t2LEApcrel tconstpool :$dst)>;
|
|
|
|
def : T2Pat<(ARMWrapper tglobaladdr :$dst), (t2MOVi32imm tglobaladdr :$dst)>,
|
|
|
|
Requires<[IsThumb2, UseMovt]>;
|
|
|
|
|
|
|
|
def : T2Pat<(ARMWrapperJT tjumptable:$dst, imm:$id),
|
|
|
|
(t2LEApcrelJT tjumptable:$dst, imm:$id)>;
|
|
|
|
|
2009-11-06 23:52:48 +00:00
|
|
|
// Pseudo instruction that combines ldr from constpool and add pc. This should
|
|
|
|
// be expanded into two instructions late to allow if-conversion and
|
|
|
|
// scheduling.
|
2010-02-27 23:47:46 +00:00
|
|
|
let canFoldAsLoad = 1, isReMaterializable = 1 in
|
2011-01-20 08:34:58 +00:00
|
|
|
def t2LDRpci_pic : PseudoInst<(outs rGPR:$dst), (ins i32imm:$addr, pclabel:$cp),
|
2010-11-18 01:38:26 +00:00
|
|
|
IIC_iLoadiALU,
|
2011-01-20 08:34:58 +00:00
|
|
|
[(set rGPR:$dst, (ARMpic_add (load (ARMWrapper tconstpool:$addr)),
|
2009-11-06 23:52:48 +00:00
|
|
|
imm:$cp))]>,
|
|
|
|
Requires<[IsThumb2]>;
|
2011-09-07 21:10:42 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Coprocessor load/store -- for disassembly only
|
|
|
|
//
|
|
|
|
class T2CI<dag oops, dag iops, string opc, string asm>
|
|
|
|
: T2I<oops, iops, NoItinerary, opc, asm, []> {
|
|
|
|
let Inst{27-25} = 0b110;
|
|
|
|
}
|
|
|
|
|
|
|
|
multiclass T2LdStCop<bits<4> op31_28, bit load, string opc> {
|
|
|
|
def _OFFSET : T2CI<(outs),
|
|
|
|
(ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
|
|
|
|
opc, "\tp$cop, cr$CRd, $addr"> {
|
|
|
|
let Inst{31-28} = op31_28;
|
|
|
|
let Inst{24} = 1; // P = 1
|
|
|
|
let Inst{21} = 0; // W = 0
|
|
|
|
let Inst{22} = 0; // D = 0
|
|
|
|
let Inst{20} = load;
|
|
|
|
let DecoderMethod = "DecodeCopMemInstruction";
|
|
|
|
}
|
|
|
|
|
|
|
|
def _PRE : T2CI<(outs),
|
|
|
|
(ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
|
|
|
|
opc, "\tp$cop, cr$CRd, $addr!"> {
|
|
|
|
let Inst{31-28} = op31_28;
|
|
|
|
let Inst{24} = 1; // P = 1
|
|
|
|
let Inst{21} = 1; // W = 1
|
|
|
|
let Inst{22} = 0; // D = 0
|
|
|
|
let Inst{20} = load;
|
|
|
|
let DecoderMethod = "DecodeCopMemInstruction";
|
|
|
|
}
|
|
|
|
|
|
|
|
def _POST : T2CI<(outs),
|
|
|
|
(ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
|
|
|
|
opc, "\tp$cop, cr$CRd, $addr"> {
|
|
|
|
let Inst{31-28} = op31_28;
|
|
|
|
let Inst{24} = 0; // P = 0
|
|
|
|
let Inst{21} = 1; // W = 1
|
|
|
|
let Inst{22} = 0; // D = 0
|
|
|
|
let Inst{20} = load;
|
|
|
|
let DecoderMethod = "DecodeCopMemInstruction";
|
|
|
|
}
|
|
|
|
|
|
|
|
def _OPTION : T2CI<(outs),
|
|
|
|
(ins nohash_imm:$cop,nohash_imm:$CRd,GPR:$base, nohash_imm:$option),
|
|
|
|
opc, "\tp$cop, cr$CRd, [$base], \\{$option\\}"> {
|
|
|
|
let Inst{31-28} = op31_28;
|
|
|
|
let Inst{24} = 0; // P = 0
|
|
|
|
let Inst{23} = 1; // U = 1
|
|
|
|
let Inst{21} = 0; // W = 0
|
|
|
|
let Inst{22} = 0; // D = 0
|
|
|
|
let Inst{20} = load;
|
|
|
|
let DecoderMethod = "DecodeCopMemInstruction";
|
|
|
|
}
|
|
|
|
|
|
|
|
def L_OFFSET : T2CI<(outs),
|
|
|
|
(ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
|
|
|
|
!strconcat(opc, "l"), "\tp$cop, cr$CRd, $addr"> {
|
|
|
|
let Inst{31-28} = op31_28;
|
|
|
|
let Inst{24} = 1; // P = 1
|
|
|
|
let Inst{21} = 0; // W = 0
|
|
|
|
let Inst{22} = 1; // D = 1
|
|
|
|
let Inst{20} = load;
|
|
|
|
let DecoderMethod = "DecodeCopMemInstruction";
|
|
|
|
}
|
|
|
|
|
|
|
|
def L_PRE : T2CI<(outs),
|
|
|
|
(ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
|
|
|
|
!strconcat(opc, "l"), "\tp$cop, cr$CRd, $addr!"> {
|
|
|
|
let Inst{31-28} = op31_28;
|
|
|
|
let Inst{24} = 1; // P = 1
|
|
|
|
let Inst{21} = 1; // W = 1
|
|
|
|
let Inst{22} = 1; // D = 1
|
|
|
|
let Inst{20} = load;
|
|
|
|
let DecoderMethod = "DecodeCopMemInstruction";
|
|
|
|
}
|
|
|
|
|
|
|
|
def L_POST : T2CI<(outs),
|
|
|
|
(ins nohash_imm:$cop, nohash_imm:$CRd, addr_offset_none:$addr,
|
|
|
|
postidx_imm8s4:$offset),
|
|
|
|
!strconcat(opc, "l"), "\tp$cop, cr$CRd, $addr, $offset"> {
|
|
|
|
let Inst{31-28} = op31_28;
|
|
|
|
let Inst{24} = 0; // P = 0
|
|
|
|
let Inst{21} = 1; // W = 1
|
|
|
|
let Inst{22} = 1; // D = 1
|
|
|
|
let Inst{20} = load;
|
|
|
|
let DecoderMethod = "DecodeCopMemInstruction";
|
|
|
|
}
|
|
|
|
|
|
|
|
def L_OPTION : T2CI<(outs),
|
|
|
|
(ins nohash_imm:$cop, nohash_imm:$CRd,GPR:$base,nohash_imm:$option),
|
|
|
|
!strconcat(opc, "l"), "\tp$cop, cr$CRd, [$base], \\{$option\\}"> {
|
|
|
|
let Inst{31-28} = op31_28;
|
|
|
|
let Inst{24} = 0; // P = 0
|
|
|
|
let Inst{23} = 1; // U = 1
|
|
|
|
let Inst{21} = 0; // W = 0
|
|
|
|
let Inst{22} = 1; // D = 1
|
|
|
|
let Inst{20} = load;
|
|
|
|
let DecoderMethod = "DecodeCopMemInstruction";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
defm t2LDC : T2LdStCop<0b1111, 1, "ldc">;
|
|
|
|
defm t2STC : T2LdStCop<0b1111, 0, "stc">;
|
|
|
|
|
2010-02-25 18:46:43 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Move between special register and ARM core register -- for disassembly only
|
|
|
|
//
|
2011-09-14 20:03:46 +00:00
|
|
|
// Move to ARM core register from Special Register
|
|
|
|
def t2MRS : T2I<(outs GPR:$Rd), (ins), NoItinerary, "mrs", "\t$Rd, apsr", []> {
|
|
|
|
bits<4> Rd;
|
|
|
|
let Inst{31-12} = 0b11110011111011111000;
|
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{7-0} = 0b0000;
|
2010-11-29 19:29:15 +00:00
|
|
|
}
|
|
|
|
|
2011-09-14 20:03:46 +00:00
|
|
|
def : t2InstAlias<"mrs${p} $Rd, cpsr", (t2MRS GPR:$Rd, pred:$p)>;
|
|
|
|
|
|
|
|
def t2MRSsys:T2I<(outs GPR:$Rd), (ins), NoItinerary, "mrs", "\t$Rd, spsr", []> {
|
2010-11-29 20:38:48 +00:00
|
|
|
bits<4> Rd;
|
2011-09-14 20:03:46 +00:00
|
|
|
let Inst{31-12} = 0b11110011111111111000;
|
2010-12-08 22:10:43 +00:00
|
|
|
let Inst{11-8} = Rd;
|
2011-09-14 20:03:46 +00:00
|
|
|
let Inst{7-0} = 0b0000;
|
2010-02-25 18:46:43 +00:00
|
|
|
}
|
|
|
|
|
2011-02-18 19:45:59 +00:00
|
|
|
// Move from ARM core register to Special Register
|
|
|
|
//
|
|
|
|
// No need to have both system and application versions, the encodings are the
|
|
|
|
// same and the assembly parser has no way to distinguish between them. The mask
|
|
|
|
// operand contains the special register (R Bit) in bit 4 and bits 3-0 contains
|
|
|
|
// the mask with the fields to be accessed in the special register.
|
2011-09-14 20:03:46 +00:00
|
|
|
def t2MSR : T2I<(outs), (ins msr_mask:$mask, rGPR:$Rn),
|
|
|
|
NoItinerary, "msr", "\t$mask, $Rn", []> {
|
2011-02-18 19:45:59 +00:00
|
|
|
bits<5> mask;
|
2010-11-29 19:29:15 +00:00
|
|
|
bits<4> Rn;
|
2011-09-14 20:03:46 +00:00
|
|
|
let Inst{31-21} = 0b11110011100;
|
2011-02-18 19:45:59 +00:00
|
|
|
let Inst{20} = mask{4}; // R Bit
|
2011-09-14 20:03:46 +00:00
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{15-12} = 0b1000;
|
2011-02-18 19:45:59 +00:00
|
|
|
let Inst{11-8} = mask{3-0};
|
2011-09-14 20:03:46 +00:00
|
|
|
let Inst{7-0} = 0;
|
2010-11-29 19:29:15 +00:00
|
|
|
}
|
|
|
|
|
2011-01-20 16:58:48 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2011-07-13 21:14:23 +00:00
|
|
|
// Move between coprocessor and ARM core register
|
2011-01-20 16:58:48 +00:00
|
|
|
//
|
|
|
|
|
2011-07-13 21:35:10 +00:00
|
|
|
class t2MovRCopro<bits<4> Op, string opc, bit direction, dag oops, dag iops,
|
|
|
|
list<dag> pattern>
|
|
|
|
: T2Cop<Op, oops, iops,
|
2011-07-13 21:17:59 +00:00
|
|
|
!strconcat(opc, "\t$cop, $opc1, $Rt, $CRn, $CRm, $opc2"),
|
2011-07-13 21:14:23 +00:00
|
|
|
pattern> {
|
|
|
|
let Inst{27-24} = 0b1110;
|
|
|
|
let Inst{20} = direction;
|
|
|
|
let Inst{4} = 1;
|
|
|
|
|
|
|
|
bits<4> Rt;
|
|
|
|
bits<4> cop;
|
|
|
|
bits<3> opc1;
|
|
|
|
bits<3> opc2;
|
|
|
|
bits<4> CRm;
|
|
|
|
bits<4> CRn;
|
|
|
|
|
|
|
|
let Inst{15-12} = Rt;
|
|
|
|
let Inst{11-8} = cop;
|
|
|
|
let Inst{23-21} = opc1;
|
|
|
|
let Inst{7-5} = opc2;
|
|
|
|
let Inst{3-0} = CRm;
|
|
|
|
let Inst{19-16} = CRn;
|
|
|
|
}
|
|
|
|
|
2011-07-13 21:35:10 +00:00
|
|
|
class t2MovRRCopro<bits<4> Op, string opc, bit direction,
|
|
|
|
list<dag> pattern = []>
|
|
|
|
: T2Cop<Op, (outs),
|
2011-07-14 21:26:42 +00:00
|
|
|
(ins p_imm:$cop, imm0_15:$opc1, GPR:$Rt, GPR:$Rt2, c_imm:$CRm),
|
2011-07-13 21:14:23 +00:00
|
|
|
!strconcat(opc, "\t$cop, $opc1, $Rt, $Rt2, $CRm"), pattern> {
|
|
|
|
let Inst{27-24} = 0b1100;
|
|
|
|
let Inst{23-21} = 0b010;
|
|
|
|
let Inst{20} = direction;
|
|
|
|
|
|
|
|
bits<4> Rt;
|
|
|
|
bits<4> Rt2;
|
|
|
|
bits<4> cop;
|
|
|
|
bits<4> opc1;
|
|
|
|
bits<4> CRm;
|
|
|
|
|
|
|
|
let Inst{15-12} = Rt;
|
|
|
|
let Inst{19-16} = Rt2;
|
|
|
|
let Inst{11-8} = cop;
|
|
|
|
let Inst{7-4} = opc1;
|
|
|
|
let Inst{3-0} = CRm;
|
|
|
|
}
|
|
|
|
|
2011-07-13 21:35:10 +00:00
|
|
|
/* from ARM core register to coprocessor */
|
|
|
|
def t2MCR : t2MovRCopro<0b1110, "mcr", 0,
|
|
|
|
(outs),
|
2011-07-14 21:19:17 +00:00
|
|
|
(ins p_imm:$cop, imm0_7:$opc1, GPR:$Rt, c_imm:$CRn,
|
|
|
|
c_imm:$CRm, imm0_7:$opc2),
|
2011-07-13 21:35:10 +00:00
|
|
|
[(int_arm_mcr imm:$cop, imm:$opc1, GPR:$Rt, imm:$CRn,
|
|
|
|
imm:$CRm, imm:$opc2)]>;
|
|
|
|
def t2MCR2 : t2MovRCopro<0b1111, "mcr2", 0,
|
2011-07-14 21:19:17 +00:00
|
|
|
(outs), (ins p_imm:$cop, imm0_7:$opc1, GPR:$Rt, c_imm:$CRn,
|
|
|
|
c_imm:$CRm, imm0_7:$opc2),
|
2011-05-03 17:29:29 +00:00
|
|
|
[(int_arm_mcr2 imm:$cop, imm:$opc1, GPR:$Rt, imm:$CRn,
|
|
|
|
imm:$CRm, imm:$opc2)]>;
|
2011-07-13 21:35:10 +00:00
|
|
|
|
|
|
|
/* from coprocessor to ARM core register */
|
|
|
|
def t2MRC : t2MovRCopro<0b1110, "mrc", 1,
|
2011-07-19 20:35:35 +00:00
|
|
|
(outs GPR:$Rt), (ins p_imm:$cop, imm0_7:$opc1, c_imm:$CRn,
|
|
|
|
c_imm:$CRm, imm0_7:$opc2), []>;
|
2011-07-13 21:35:10 +00:00
|
|
|
|
|
|
|
def t2MRC2 : t2MovRCopro<0b1111, "mrc2", 1,
|
2011-07-19 20:35:35 +00:00
|
|
|
(outs GPR:$Rt), (ins p_imm:$cop, imm0_7:$opc1, c_imm:$CRn,
|
|
|
|
c_imm:$CRm, imm0_7:$opc2), []>;
|
2011-01-20 16:58:48 +00:00
|
|
|
|
2011-07-13 21:35:10 +00:00
|
|
|
def : T2v6Pat<(int_arm_mrc imm:$cop, imm:$opc1, imm:$CRn, imm:$CRm, imm:$opc2),
|
|
|
|
(t2MRC imm:$cop, imm:$opc1, imm:$CRn, imm:$CRm, imm:$opc2)>;
|
2011-01-20 16:58:48 +00:00
|
|
|
|
2011-07-13 21:35:10 +00:00
|
|
|
def : T2v6Pat<(int_arm_mrc2 imm:$cop, imm:$opc1, imm:$CRn, imm:$CRm, imm:$opc2),
|
|
|
|
(t2MRC2 imm:$cop, imm:$opc1, imm:$CRn, imm:$CRm, imm:$opc2)>;
|
2011-01-20 16:58:48 +00:00
|
|
|
|
|
|
|
|
2011-07-13 21:35:10 +00:00
|
|
|
/* from ARM core register to coprocessor */
|
|
|
|
def t2MCRR : t2MovRRCopro<0b1110, "mcrr", 0,
|
|
|
|
[(int_arm_mcrr imm:$cop, imm:$opc1, GPR:$Rt, GPR:$Rt2,
|
|
|
|
imm:$CRm)]>;
|
|
|
|
def t2MCRR2 : t2MovRRCopro<0b1111, "mcrr2", 0,
|
2011-05-03 17:29:29 +00:00
|
|
|
[(int_arm_mcrr2 imm:$cop, imm:$opc1, GPR:$Rt,
|
|
|
|
GPR:$Rt2, imm:$CRm)]>;
|
2011-07-13 21:35:10 +00:00
|
|
|
/* from coprocessor to ARM core register */
|
|
|
|
def t2MRRC : t2MovRRCopro<0b1110, "mrrc", 1>;
|
|
|
|
|
|
|
|
def t2MRRC2 : t2MovRRCopro<0b1111, "mrrc2", 1>;
|
2011-01-20 16:58:48 +00:00
|
|
|
|
2011-01-20 18:32:09 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2011-07-13 21:14:23 +00:00
|
|
|
// Other Coprocessor Instructions.
|
2011-01-20 18:32:09 +00:00
|
|
|
//
|
|
|
|
|
2011-07-13 22:06:11 +00:00
|
|
|
def tCDP : T2Cop<0b1110, (outs), (ins p_imm:$cop, imm0_15:$opc1,
|
2011-07-13 22:01:08 +00:00
|
|
|
c_imm:$CRd, c_imm:$CRn, c_imm:$CRm, imm0_7:$opc2),
|
2011-07-13 21:14:23 +00:00
|
|
|
"cdp\t$cop, $opc1, $CRd, $CRn, $CRm, $opc2",
|
|
|
|
[(int_arm_cdp imm:$cop, imm:$opc1, imm:$CRd, imm:$CRn,
|
|
|
|
imm:$CRm, imm:$opc2)]> {
|
|
|
|
let Inst{27-24} = 0b1110;
|
|
|
|
|
|
|
|
bits<4> opc1;
|
|
|
|
bits<4> CRn;
|
|
|
|
bits<4> CRd;
|
|
|
|
bits<4> cop;
|
|
|
|
bits<3> opc2;
|
|
|
|
bits<4> CRm;
|
|
|
|
|
|
|
|
let Inst{3-0} = CRm;
|
|
|
|
let Inst{4} = 0;
|
|
|
|
let Inst{7-5} = opc2;
|
|
|
|
let Inst{11-8} = cop;
|
|
|
|
let Inst{15-12} = CRd;
|
|
|
|
let Inst{19-16} = CRn;
|
|
|
|
let Inst{23-20} = opc1;
|
|
|
|
}
|
|
|
|
|
2011-07-13 22:06:11 +00:00
|
|
|
def t2CDP2 : T2Cop<0b1111, (outs), (ins p_imm:$cop, imm0_15:$opc1,
|
2011-07-13 22:01:08 +00:00
|
|
|
c_imm:$CRd, c_imm:$CRn, c_imm:$CRm, imm0_7:$opc2),
|
2011-01-20 18:32:09 +00:00
|
|
|
"cdp2\t$cop, $opc1, $CRd, $CRn, $CRm, $opc2",
|
2011-05-03 17:29:29 +00:00
|
|
|
[(int_arm_cdp2 imm:$cop, imm:$opc1, imm:$CRd, imm:$CRn,
|
|
|
|
imm:$CRm, imm:$opc2)]> {
|
2011-01-20 18:32:09 +00:00
|
|
|
let Inst{27-24} = 0b1110;
|
|
|
|
|
|
|
|
bits<4> opc1;
|
|
|
|
bits<4> CRn;
|
|
|
|
bits<4> CRd;
|
|
|
|
bits<4> cop;
|
|
|
|
bits<3> opc2;
|
|
|
|
bits<4> CRm;
|
|
|
|
|
|
|
|
let Inst{3-0} = CRm;
|
|
|
|
let Inst{4} = 0;
|
|
|
|
let Inst{7-5} = opc2;
|
|
|
|
let Inst{11-8} = cop;
|
|
|
|
let Inst{15-12} = CRd;
|
|
|
|
let Inst{19-16} = CRn;
|
|
|
|
let Inst{23-20} = opc1;
|
|
|
|
}
|
2011-07-27 16:47:19 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Non-Instruction Patterns
|
|
|
|
//
|
|
|
|
|
|
|
|
// SXT/UXT with no rotate
|
2011-07-27 17:48:13 +00:00
|
|
|
let AddedComplexity = 16 in {
|
|
|
|
def : T2Pat<(and rGPR:$Rm, 0x000000FF), (t2UXTB rGPR:$Rm, 0)>,
|
2011-08-08 19:49:37 +00:00
|
|
|
Requires<[IsThumb2]>;
|
2011-07-27 17:48:13 +00:00
|
|
|
def : T2Pat<(and rGPR:$Rm, 0x0000FFFF), (t2UXTH rGPR:$Rm, 0)>,
|
2011-08-08 19:49:37 +00:00
|
|
|
Requires<[IsThumb2]>;
|
2011-07-27 17:48:13 +00:00
|
|
|
def : T2Pat<(and rGPR:$Rm, 0x00FF00FF), (t2UXTB16 rGPR:$Rm, 0)>,
|
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
|
|
|
def : T2Pat<(add rGPR:$Rn, (and rGPR:$Rm, 0x00FF)),
|
|
|
|
(t2UXTAB rGPR:$Rn, rGPR:$Rm, 0)>,
|
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
|
|
|
def : T2Pat<(add rGPR:$Rn, (and rGPR:$Rm, 0xFFFF)),
|
|
|
|
(t2UXTAH rGPR:$Rn, rGPR:$Rm, 0)>,
|
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
|
|
|
}
|
|
|
|
|
|
|
|
def : T2Pat<(sext_inreg rGPR:$Src, i8), (t2SXTB rGPR:$Src, 0)>,
|
2011-08-08 19:49:37 +00:00
|
|
|
Requires<[IsThumb2]>;
|
2011-07-27 17:48:13 +00:00
|
|
|
def : T2Pat<(sext_inreg rGPR:$Src, i16), (t2SXTH rGPR:$Src, 0)>,
|
2011-08-08 19:49:37 +00:00
|
|
|
Requires<[IsThumb2]>;
|
2011-07-27 17:48:13 +00:00
|
|
|
def : T2Pat<(add rGPR:$Rn, (sext_inreg rGPR:$Rm, i8)),
|
|
|
|
(t2SXTAB rGPR:$Rn, rGPR:$Rm, 0)>,
|
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
|
|
|
def : T2Pat<(add rGPR:$Rn, (sext_inreg rGPR:$Rm, i16)),
|
|
|
|
(t2SXTAH rGPR:$Rn, rGPR:$Rm, 0)>,
|
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
2011-08-26 02:59:24 +00:00
|
|
|
|
|
|
|
// Atomic load/store patterns
|
|
|
|
def : T2Pat<(atomic_load_8 t2addrmode_imm12:$addr),
|
|
|
|
(t2LDRBi12 t2addrmode_imm12:$addr)>;
|
2011-09-07 20:58:57 +00:00
|
|
|
def : T2Pat<(atomic_load_8 t2addrmode_negimm8:$addr),
|
|
|
|
(t2LDRBi8 t2addrmode_negimm8:$addr)>;
|
2011-08-26 02:59:24 +00:00
|
|
|
def : T2Pat<(atomic_load_8 t2addrmode_so_reg:$addr),
|
|
|
|
(t2LDRBs t2addrmode_so_reg:$addr)>;
|
|
|
|
def : T2Pat<(atomic_load_16 t2addrmode_imm12:$addr),
|
|
|
|
(t2LDRHi12 t2addrmode_imm12:$addr)>;
|
2011-09-07 20:58:57 +00:00
|
|
|
def : T2Pat<(atomic_load_16 t2addrmode_negimm8:$addr),
|
|
|
|
(t2LDRHi8 t2addrmode_negimm8:$addr)>;
|
2011-08-26 02:59:24 +00:00
|
|
|
def : T2Pat<(atomic_load_16 t2addrmode_so_reg:$addr),
|
|
|
|
(t2LDRHs t2addrmode_so_reg:$addr)>;
|
|
|
|
def : T2Pat<(atomic_load_32 t2addrmode_imm12:$addr),
|
|
|
|
(t2LDRi12 t2addrmode_imm12:$addr)>;
|
2011-09-07 20:58:57 +00:00
|
|
|
def : T2Pat<(atomic_load_32 t2addrmode_negimm8:$addr),
|
|
|
|
(t2LDRi8 t2addrmode_negimm8:$addr)>;
|
2011-08-26 02:59:24 +00:00
|
|
|
def : T2Pat<(atomic_load_32 t2addrmode_so_reg:$addr),
|
|
|
|
(t2LDRs t2addrmode_so_reg:$addr)>;
|
|
|
|
def : T2Pat<(atomic_store_8 t2addrmode_imm12:$addr, GPR:$val),
|
|
|
|
(t2STRBi12 GPR:$val, t2addrmode_imm12:$addr)>;
|
2011-09-07 20:58:57 +00:00
|
|
|
def : T2Pat<(atomic_store_8 t2addrmode_negimm8:$addr, GPR:$val),
|
|
|
|
(t2STRBi8 GPR:$val, t2addrmode_negimm8:$addr)>;
|
2011-08-26 02:59:24 +00:00
|
|
|
def : T2Pat<(atomic_store_8 t2addrmode_so_reg:$addr, GPR:$val),
|
|
|
|
(t2STRBs GPR:$val, t2addrmode_so_reg:$addr)>;
|
|
|
|
def : T2Pat<(atomic_store_16 t2addrmode_imm12:$addr, GPR:$val),
|
|
|
|
(t2STRHi12 GPR:$val, t2addrmode_imm12:$addr)>;
|
2011-09-07 20:58:57 +00:00
|
|
|
def : T2Pat<(atomic_store_16 t2addrmode_negimm8:$addr, GPR:$val),
|
|
|
|
(t2STRHi8 GPR:$val, t2addrmode_negimm8:$addr)>;
|
2011-08-26 02:59:24 +00:00
|
|
|
def : T2Pat<(atomic_store_16 t2addrmode_so_reg:$addr, GPR:$val),
|
|
|
|
(t2STRHs GPR:$val, t2addrmode_so_reg:$addr)>;
|
|
|
|
def : T2Pat<(atomic_store_32 t2addrmode_imm12:$addr, GPR:$val),
|
|
|
|
(t2STRi12 GPR:$val, t2addrmode_imm12:$addr)>;
|
2011-09-07 20:58:57 +00:00
|
|
|
def : T2Pat<(atomic_store_32 t2addrmode_negimm8:$addr, GPR:$val),
|
|
|
|
(t2STRi8 GPR:$val, t2addrmode_negimm8:$addr)>;
|
2011-08-26 02:59:24 +00:00
|
|
|
def : T2Pat<(atomic_store_32 t2addrmode_so_reg:$addr, GPR:$val),
|
|
|
|
(t2STRs GPR:$val, t2addrmode_so_reg:$addr)>;
|
2011-08-31 18:23:08 +00:00
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Assembler aliases
|
|
|
|
//
|
|
|
|
|
|
|
|
// Aliases for ADC without the ".w" optional width specifier.
|
|
|
|
def : t2InstAlias<"adc${s}${p} $Rd, $Rn, $Rm",
|
|
|
|
(t2ADCrr rGPR:$Rd, rGPR:$Rn, rGPR:$Rm, pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"adc${s}${p} $Rd, $Rn, $ShiftedRm",
|
|
|
|
(t2ADCrs rGPR:$Rd, rGPR:$Rn, t2_so_reg:$ShiftedRm,
|
|
|
|
pred:$p, cc_out:$s)>;
|
|
|
|
|
|
|
|
// Aliases for SBC without the ".w" optional width specifier.
|
|
|
|
def : t2InstAlias<"sbc${s}${p} $Rd, $Rn, $Rm",
|
|
|
|
(t2SBCrr rGPR:$Rd, rGPR:$Rn, rGPR:$Rm, pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"sbc${s}${p} $Rd, $Rn, $ShiftedRm",
|
|
|
|
(t2SBCrs rGPR:$Rd, rGPR:$Rn, t2_so_reg:$ShiftedRm,
|
|
|
|
pred:$p, cc_out:$s)>;
|
|
|
|
|
2011-09-02 18:14:46 +00:00
|
|
|
// Aliases for ADD without the ".w" optional width specifier.
|
2011-09-01 00:28:52 +00:00
|
|
|
def : t2InstAlias<"add${s}${p} $Rd, $Rn, $imm",
|
2011-09-02 18:14:46 +00:00
|
|
|
(t2ADDri rGPR:$Rd, GPRnopc:$Rn, t2_so_imm:$imm, pred:$p, cc_out:$s)>;
|
2011-09-01 00:28:52 +00:00
|
|
|
def : t2InstAlias<"add${p} $Rd, $Rn, $imm",
|
2011-09-02 18:14:46 +00:00
|
|
|
(t2ADDri12 rGPR:$Rd, GPR:$Rn, imm0_4095:$imm, pred:$p)>;
|
|
|
|
def : t2InstAlias<"add${s}${p} $Rd, $Rn, $Rm",
|
|
|
|
(t2ADDrr rGPR:$Rd, GPRnopc:$Rn, rGPR:$Rm, pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"add${s}${p} $Rd, $Rn, $ShiftedRm",
|
|
|
|
(t2ADDrs rGPR:$Rd, GPRnopc:$Rn, t2_so_reg:$ShiftedRm,
|
2011-09-16 22:58:42 +00:00
|
|
|
pred:$p, cc_out:$s)>;
|
|
|
|
|
|
|
|
// Aliases for SUB without the ".w" optional width specifier.
|
|
|
|
def : t2InstAlias<"sub${s}${p} $Rd, $Rn, $imm",
|
|
|
|
(t2SUBri rGPR:$Rd, GPRnopc:$Rn, t2_so_imm:$imm, pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"sub${p} $Rd, $Rn, $imm",
|
|
|
|
(t2SUBri12 rGPR:$Rd, GPR:$Rn, imm0_4095:$imm, pred:$p)>;
|
|
|
|
def : t2InstAlias<"sub${s}${p} $Rd, $Rn, $Rm",
|
|
|
|
(t2SUBrr rGPR:$Rd, GPRnopc:$Rn, rGPR:$Rm, pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"sub${s}${p} $Rd, $Rn, $ShiftedRm",
|
|
|
|
(t2SUBrs rGPR:$Rd, GPRnopc:$Rn, t2_so_reg:$ShiftedRm,
|
2011-09-02 18:14:46 +00:00
|
|
|
pred:$p, cc_out:$s)>;
|
2011-09-06 21:44:58 +00:00
|
|
|
|
|
|
|
// Alias for compares without the ".w" optional width specifier.
|
|
|
|
def : t2InstAlias<"cmn${p} $Rn, $Rm",
|
|
|
|
(t2CMNzrr GPRnopc:$Rn, rGPR:$Rm, pred:$p)>;
|
|
|
|
def : t2InstAlias<"teq${p} $Rn, $Rm",
|
|
|
|
(t2TEQrr GPRnopc:$Rn, rGPR:$Rm, pred:$p)>;
|
|
|
|
def : t2InstAlias<"tst${p} $Rn, $Rm",
|
|
|
|
(t2TSTrr GPRnopc:$Rn, rGPR:$Rm, pred:$p)>;
|
|
|
|
|
2011-09-06 22:14:58 +00:00
|
|
|
// Memory barriers
|
|
|
|
def : InstAlias<"dmb", (t2DMB 0xf)>, Requires<[IsThumb2, HasDB]>;
|
|
|
|
def : InstAlias<"dsb", (t2DSB 0xf)>, Requires<[IsThumb2, HasDB]>;
|
2011-09-06 22:53:27 +00:00
|
|
|
def : InstAlias<"isb", (t2ISB 0xf)>, Requires<[IsThumb2, HasDB]>;
|
2011-09-07 20:58:57 +00:00
|
|
|
|
2011-09-09 19:42:40 +00:00
|
|
|
// Alias for LDR, LDRB, LDRH, LDRSB, and LDRSH without the ".w" optional
|
|
|
|
// width specifier.
|
2011-09-07 21:41:25 +00:00
|
|
|
def : t2InstAlias<"ldr${p} $Rt, $addr",
|
|
|
|
(t2LDRi12 GPR:$Rt, t2addrmode_imm12:$addr, pred:$p)>;
|
|
|
|
def : t2InstAlias<"ldrb${p} $Rt, $addr",
|
|
|
|
(t2LDRBi12 rGPR:$Rt, t2addrmode_imm12:$addr, pred:$p)>;
|
|
|
|
def : t2InstAlias<"ldrh${p} $Rt, $addr",
|
|
|
|
(t2LDRHi12 rGPR:$Rt, t2addrmode_imm12:$addr, pred:$p)>;
|
2011-09-09 19:42:40 +00:00
|
|
|
def : t2InstAlias<"ldrsb${p} $Rt, $addr",
|
|
|
|
(t2LDRSBi12 rGPR:$Rt, t2addrmode_imm12:$addr, pred:$p)>;
|
|
|
|
def : t2InstAlias<"ldrsh${p} $Rt, $addr",
|
|
|
|
(t2LDRSHi12 rGPR:$Rt, t2addrmode_imm12:$addr, pred:$p)>;
|
|
|
|
|
2011-09-07 23:10:15 +00:00
|
|
|
def : t2InstAlias<"ldr${p} $Rt, $addr",
|
|
|
|
(t2LDRs GPR:$Rt, t2addrmode_so_reg:$addr, pred:$p)>;
|
|
|
|
def : t2InstAlias<"ldrb${p} $Rt, $addr",
|
|
|
|
(t2LDRBs rGPR:$Rt, t2addrmode_so_reg:$addr, pred:$p)>;
|
|
|
|
def : t2InstAlias<"ldrh${p} $Rt, $addr",
|
|
|
|
(t2LDRHs rGPR:$Rt, t2addrmode_so_reg:$addr, pred:$p)>;
|
2011-09-09 19:42:40 +00:00
|
|
|
def : t2InstAlias<"ldrsb${p} $Rt, $addr",
|
|
|
|
(t2LDRSBs rGPR:$Rt, t2addrmode_so_reg:$addr, pred:$p)>;
|
|
|
|
def : t2InstAlias<"ldrsh${p} $Rt, $addr",
|
|
|
|
(t2LDRSHs rGPR:$Rt, t2addrmode_so_reg:$addr, pred:$p)>;
|
2011-09-14 21:24:41 +00:00
|
|
|
|
|
|
|
// Alias for MVN without the ".w" optional width specifier.
|
|
|
|
def : t2InstAlias<"mvn${s}${p} $Rd, $Rm",
|
|
|
|
(t2MVNr rGPR:$Rd, rGPR:$Rm, pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"mvn${s}${p} $Rd, $ShiftedRm",
|
|
|
|
(t2MVNs rGPR:$Rd, t2_so_reg:$ShiftedRm, pred:$p, cc_out:$s)>;
|
2011-09-14 23:16:41 +00:00
|
|
|
|
|
|
|
// PKHBT/PKHTB with default shift amount. PKHTB is equivalent to PKHBT when the
|
|
|
|
// shift amount is zero (i.e., unspecified).
|
|
|
|
def : InstAlias<"pkhbt${p} $Rd, $Rn, $Rm",
|
|
|
|
(t2PKHBT rGPR:$Rd, rGPR:$Rn, rGPR:$Rm, 0, pred:$p)>,
|
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
|
|
|
def : InstAlias<"pkhtb${p} $Rd, $Rn, $Rm",
|
|
|
|
(t2PKHBT rGPR:$Rd, rGPR:$Rn, rGPR:$Rm, 0, pred:$p)>,
|
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
|
|
|
|
2011-09-15 15:55:04 +00:00
|
|
|
// PUSH/POP aliases for STM/LDM
|
|
|
|
def : t2InstAlias<"push${p}.w $regs", (t2STMDB_UPD SP, pred:$p, reglist:$regs)>;
|
|
|
|
def : t2InstAlias<"push${p} $regs", (t2STMDB_UPD SP, pred:$p, reglist:$regs)>;
|
|
|
|
def : t2InstAlias<"pop${p}.w $regs", (t2LDMIA_UPD SP, pred:$p, reglist:$regs)>;
|
|
|
|
def : t2InstAlias<"pop${p} $regs", (t2LDMIA_UPD SP, pred:$p, reglist:$regs)>;
|
|
|
|
|
2011-09-15 19:46:13 +00:00
|
|
|
// Alias for REV/REV16/REVSH without the ".w" optional width specifier.
|
2011-09-15 18:13:30 +00:00
|
|
|
def : t2InstAlias<"rev${p} $Rd, $Rm", (t2REV rGPR:$Rd, rGPR:$Rm, pred:$p)>;
|
2011-09-15 19:46:13 +00:00
|
|
|
def : t2InstAlias<"rev16${p} $Rd, $Rm", (t2REV16 rGPR:$Rd, rGPR:$Rm, pred:$p)>;
|
|
|
|
def : t2InstAlias<"revsh${p} $Rd, $Rm", (t2REVSH rGPR:$Rd, rGPR:$Rm, pred:$p)>;
|
2011-09-15 20:54:14 +00:00
|
|
|
|
|
|
|
|
|
|
|
// Alias for RSB without the ".w" optional width specifier, and with optional
|
|
|
|
// implied destination register.
|
|
|
|
def : t2InstAlias<"rsb${s}${p} $Rd, $Rn, $imm",
|
|
|
|
(t2RSBri rGPR:$Rd, rGPR:$Rn, t2_so_imm:$imm, pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"rsb${s}${p} $Rdn, $imm",
|
|
|
|
(t2RSBri rGPR:$Rdn, rGPR:$Rdn, t2_so_imm:$imm, pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"rsb${s}${p} $Rdn, $Rm",
|
|
|
|
(t2RSBrr rGPR:$Rdn, rGPR:$Rdn, rGPR:$Rm, pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"rsb${s}${p} $Rdn, $ShiftedRm",
|
|
|
|
(t2RSBrs rGPR:$Rdn, rGPR:$Rdn, t2_so_reg:$ShiftedRm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
2011-09-16 18:32:30 +00:00
|
|
|
|
|
|
|
// SSAT/USAT optional shift operand.
|
|
|
|
def : t2InstAlias<"ssat${p} $Rd, $sat_imm, $Rn",
|
|
|
|
(t2SSAT rGPR:$Rd, imm1_32:$sat_imm, rGPR:$Rn, 0, pred:$p)>;
|
|
|
|
def : t2InstAlias<"usat${p} $Rd, $sat_imm, $Rn",
|
|
|
|
(t2USAT rGPR:$Rd, imm0_31:$sat_imm, rGPR:$Rn, 0, pred:$p)>;
|
|
|
|
|
2011-09-16 20:50:13 +00:00
|
|
|
// STM w/o the .w suffix.
|
|
|
|
def : t2InstAlias<"stm${p} $Rn, $regs",
|
|
|
|
(t2STMIA GPR:$Rn, pred:$p, reglist:$regs)>;
|
2011-09-16 21:06:12 +00:00
|
|
|
|
|
|
|
// Alias for STR, STRB, and STRH without the ".w" optional
|
|
|
|
// width specifier.
|
|
|
|
def : t2InstAlias<"str${p} $Rt, $addr",
|
|
|
|
(t2STRi12 GPR:$Rt, t2addrmode_imm12:$addr, pred:$p)>;
|
|
|
|
def : t2InstAlias<"strb${p} $Rt, $addr",
|
|
|
|
(t2STRBi12 rGPR:$Rt, t2addrmode_imm12:$addr, pred:$p)>;
|
|
|
|
def : t2InstAlias<"strh${p} $Rt, $addr",
|
|
|
|
(t2STRHi12 rGPR:$Rt, t2addrmode_imm12:$addr, pred:$p)>;
|
|
|
|
|
|
|
|
def : t2InstAlias<"str${p} $Rt, $addr",
|
|
|
|
(t2STRs GPR:$Rt, t2addrmode_so_reg:$addr, pred:$p)>;
|
|
|
|
def : t2InstAlias<"strb${p} $Rt, $addr",
|
|
|
|
(t2STRBs rGPR:$Rt, t2addrmode_so_reg:$addr, pred:$p)>;
|
|
|
|
def : t2InstAlias<"strh${p} $Rt, $addr",
|
|
|
|
(t2STRHs rGPR:$Rt, t2addrmode_so_reg:$addr, pred:$p)>;
|
2011-09-19 17:56:37 +00:00
|
|
|
|
|
|
|
// Extend instruction optional rotate operand.
|
|
|
|
def : t2InstAlias<"sxtab${p} $Rd, $Rn, $Rm",
|
|
|
|
(t2SXTAB rGPR:$Rd, rGPR:$Rn, rGPR:$Rm, 0, pred:$p)>;
|
|
|
|
def : t2InstAlias<"sxtah${p} $Rd, $Rn, $Rm",
|
|
|
|
(t2SXTAH rGPR:$Rd, rGPR:$Rn, rGPR:$Rm, 0, pred:$p)>;
|
|
|
|
def : t2InstAlias<"sxtab16${p} $Rd, $Rn, $Rm",
|
|
|
|
(t2SXTAB16 rGPR:$Rd, rGPR:$Rn, rGPR:$Rm, 0, pred:$p)>;
|