2012-02-18 20:03:15 +08:00
|
|
|
//===-- ARMInstrThumb2.td - Thumb2 support for ARM ---------*- tablegen -*-===//
|
2009-05-30 07:41:08 +08:00
|
|
|
//
|
|
|
|
// 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-18 02:13:58 +08:00
|
|
|
|
2009-07-10 09:54:42 +08:00
|
|
|
// IT block predicate field
|
2011-08-27 05:43:41 +08:00
|
|
|
def it_pred_asmoperand : AsmOperandClass {
|
|
|
|
let Name = "ITCondCode";
|
|
|
|
let ParserMethod = "parseITCondCode";
|
|
|
|
}
|
2009-07-10 09:54:42 +08:00
|
|
|
def it_pred : Operand<i32> {
|
2010-03-03 01:57:15 +08:00
|
|
|
let PrintMethod = "printMandatoryPredicateOperand";
|
2011-08-27 05:43:41 +08:00
|
|
|
let ParserMatchClass = it_pred_asmoperand;
|
2009-07-10 09:54:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// IT block condition mask
|
2011-08-27 05:43:41 +08:00
|
|
|
def it_mask_asmoperand : AsmOperandClass { let Name = "ITMask"; }
|
2009-07-10 09:54:42 +08:00
|
|
|
def it_mask : Operand<i32> {
|
|
|
|
let PrintMethod = "printThumbITMask";
|
2011-08-27 05:43:41 +08:00
|
|
|
let ParserMatchClass = it_mask_asmoperand;
|
2009-07-10 09:54:42 +08:00
|
|
|
}
|
|
|
|
|
2011-09-27 05:06:22 +08:00
|
|
|
// t2_shift_imm: An integer that encodes a shift amount and the type of shift
|
|
|
|
// (asr or lsl). The 6-bit immediate encodes as:
|
|
|
|
// {5} 0 ==> lsl
|
|
|
|
// 1 asr
|
|
|
|
// {4-0} imm5 shift amount.
|
|
|
|
// asr #32 not allowed
|
|
|
|
def t2_shift_imm : Operand<i32> {
|
|
|
|
let PrintMethod = "printShiftImmOperand";
|
|
|
|
let ParserMatchClass = ShifterImmAsmOperand;
|
|
|
|
let DecoderMethod = "DecodeT2ShifterImmOperand";
|
|
|
|
}
|
|
|
|
|
2009-06-18 02:13:58 +08: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 10:26:13 +08:00
|
|
|
ComplexPattern<i32, 2, "SelectT2ShifterOperandReg",
|
2009-06-18 02:13:58 +08:00
|
|
|
[shl,srl,sra,rotr]> {
|
2010-11-15 13:19:05 +08:00
|
|
|
let EncoderMethod = "getT2SORegOpValue";
|
2009-06-27 10:26:13 +08:00
|
|
|
let PrintMethod = "printT2SOOperand";
|
2011-08-23 07:10:16 +08:00
|
|
|
let DecoderMethod = "DecodeSORegImmOperand";
|
2011-09-01 02:23:08 +08:00
|
|
|
let ParserMatchClass = ShiftedImmAsmOperand;
|
|
|
|
let MIOperandInfo = (ops rGPR, i32imm);
|
2009-06-18 02:13:58 +08:00
|
|
|
}
|
|
|
|
|
2009-06-24 01:48:47 +08: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-12 04:47:22 +08:00
|
|
|
return CurDAG->getTargetConstant(~((uint32_t)N->getZExtValue()), MVT::i32);
|
2009-06-18 02:13:58 +08:00
|
|
|
}]>;
|
|
|
|
|
2009-06-24 01:48:47 +08: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-12 04:47:22 +08:00
|
|
|
return CurDAG->getTargetConstant(-((int)N->getZExtValue()), MVT::i32);
|
2009-06-24 01:48:47 +08:00
|
|
|
}]>;
|
|
|
|
|
2012-06-18 22:51:32 +08:00
|
|
|
// so_imm_notSext_XFORM - Return a so_imm value packed into the format
|
|
|
|
// described for so_imm_notSext def below, with sign extension from 16
|
|
|
|
// bits.
|
|
|
|
def t2_so_imm_notSext16_XFORM : SDNodeXForm<imm, [{
|
|
|
|
APInt apIntN = N->getAPIntValue();
|
|
|
|
unsigned N16bitSignExt = apIntN.trunc(16).sext(32).getZExtValue();
|
|
|
|
return CurDAG->getTargetConstant(~N16bitSignExt, MVT::i32);
|
|
|
|
}]>;
|
|
|
|
|
2009-06-24 01:48:47 +08: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-08 01:43:06 +08:00
|
|
|
// immediate splatted into multiple bytes of the word.
|
2011-11-12 08:58:43 +08:00
|
|
|
def t2_so_imm_asmoperand : ImmAsmOperand { let Name = "T2SOImm"; }
|
2011-04-30 06:48:03 +08:00
|
|
|
def t2_so_imm : Operand<i32>, ImmLeaf<i32, [{
|
|
|
|
return ARM_AM::getT2SOImmVal(Imm) != -1;
|
|
|
|
}]> {
|
2011-06-28 07:54:06 +08:00
|
|
|
let ParserMatchClass = t2_so_imm_asmoperand;
|
2010-11-15 13:19:05 +08:00
|
|
|
let EncoderMethod = "getT2SOImmOpValue";
|
2011-08-10 04:55:18 +08:00
|
|
|
let DecoderMethod = "DecodeT2SOImm";
|
2010-11-13 05:12:40 +08:00
|
|
|
}
|
2009-06-18 02:13:58 +08:00
|
|
|
|
2010-02-17 05:07:46 +08:00
|
|
|
// t2_so_imm_not - Match an immediate that is a complement
|
2009-06-24 01:48:47 +08:00
|
|
|
// of a t2_so_imm.
|
2011-10-29 06:36:30 +08:00
|
|
|
// Note: this pattern doesn't require an encoder method and such, as it's
|
|
|
|
// only used on aliases (Pat<> and InstAlias<>). The actual encoding
|
|
|
|
// is handled by the destination instructions, which use t2_so_imm.
|
|
|
|
def t2_so_imm_not_asmoperand : AsmOperandClass { let Name = "T2SOImmNot"; }
|
2011-12-08 08:31:07 +08:00
|
|
|
def t2_so_imm_not : Operand<i32>, PatLeaf<(imm), [{
|
2009-07-09 05:03:57 +08:00
|
|
|
return ARM_AM::getT2SOImmVal(~((uint32_t)N->getZExtValue())) != -1;
|
2011-10-29 06:36:30 +08:00
|
|
|
}], t2_so_imm_not_XFORM> {
|
|
|
|
let ParserMatchClass = t2_so_imm_not_asmoperand;
|
|
|
|
}
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2012-06-18 22:51:32 +08:00
|
|
|
// t2_so_imm_notSext - match an immediate that is a complement of a t2_so_imm
|
|
|
|
// if the upper 16 bits are zero.
|
|
|
|
def t2_so_imm_notSext : Operand<i32>, PatLeaf<(imm), [{
|
|
|
|
APInt apIntN = N->getAPIntValue();
|
|
|
|
if (!apIntN.isIntN(16)) return false;
|
|
|
|
unsigned N16bitSignExt = apIntN.trunc(16).sext(32).getZExtValue();
|
|
|
|
return ARM_AM::getT2SOImmVal(~N16bitSignExt) != -1;
|
|
|
|
}], t2_so_imm_notSext16_XFORM> {
|
|
|
|
let ParserMatchClass = t2_so_imm_not_asmoperand;
|
|
|
|
}
|
|
|
|
|
2009-06-24 01:48:47 +08:00
|
|
|
// t2_so_imm_neg - Match an immediate that is a negation of a t2_so_imm.
|
2011-12-08 08:31:07 +08:00
|
|
|
def t2_so_imm_neg_asmoperand : AsmOperandClass { let Name = "T2SOImmNeg"; }
|
|
|
|
def t2_so_imm_neg : Operand<i32>, PatLeaf<(imm), [{
|
2012-03-30 05:19:52 +08:00
|
|
|
int64_t Value = -(int)N->getZExtValue();
|
|
|
|
return Value && ARM_AM::getT2SOImmVal(Value) != -1;
|
2011-12-08 08:31:07 +08:00
|
|
|
}], t2_so_imm_neg_XFORM> {
|
|
|
|
let ParserMatchClass = t2_so_imm_neg_asmoperand;
|
|
|
|
}
|
2009-06-18 02:13:58 +08:00
|
|
|
|
2009-06-24 01:48:47 +08:00
|
|
|
/// imm0_4095 predicate - True if the 32-bit immediate is in the range [0.4095].
|
2012-04-06 04:57:13 +08:00
|
|
|
def imm0_4095_asmoperand: ImmAsmOperand { let Name = "Imm0_4095"; }
|
|
|
|
def imm0_4095 : Operand<i32>, ImmLeaf<i32, [{
|
2011-04-28 13:49:04 +08:00
|
|
|
return Imm >= 0 && Imm < 4096;
|
2012-04-06 04:57:13 +08:00
|
|
|
}]> {
|
|
|
|
let ParserMatchClass = imm0_4095_asmoperand;
|
|
|
|
}
|
2009-06-18 02:13:58 +08:00
|
|
|
|
2012-04-06 04:57:13 +08:00
|
|
|
def imm0_4095_neg_asmoperand: AsmOperandClass { let Name = "Imm0_4095Neg"; }
|
|
|
|
def imm0_4095_neg : Operand<i32>, PatLeaf<(i32 imm), [{
|
2010-02-17 05:07:46 +08:00
|
|
|
return (uint32_t)(-N->getZExtValue()) < 4096;
|
2012-04-06 04:57:13 +08:00
|
|
|
}], imm_neg_XFORM> {
|
|
|
|
let ParserMatchClass = imm0_4095_neg_asmoperand;
|
|
|
|
}
|
2009-06-18 02:13:58 +08:00
|
|
|
|
2012-11-15 03:39:15 +08:00
|
|
|
def imm1_255_neg : PatLeaf<(i32 imm), [{
|
|
|
|
uint32_t Val = -N->getZExtValue();
|
|
|
|
return (Val > 0 && Val < 255);
|
2010-02-17 05:07:46 +08:00
|
|
|
}], imm_neg_XFORM>;
|
2009-08-04 09:41:15 +08:00
|
|
|
|
2010-07-15 01:45:16 +08:00
|
|
|
def imm0_255_not : PatLeaf<(i32 imm), [{
|
|
|
|
return (uint32_t)(~N->getZExtValue()) < 255;
|
|
|
|
}], imm_comp_XFORM>;
|
|
|
|
|
2011-04-29 22:18:15 +08: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 15:51:04 +08:00
|
|
|
// Define Thumb2 specific addressing modes.
|
|
|
|
|
|
|
|
// t2addrmode_imm12 := reg + imm12
|
2011-09-08 04:58:57 +08:00
|
|
|
def t2addrmode_imm12_asmoperand : AsmOperandClass {let Name="MemUImm12Offset";}
|
2009-06-29 15:51:04 +08:00
|
|
|
def t2addrmode_imm12 : Operand<i32>,
|
|
|
|
ComplexPattern<i32, 2, "SelectT2AddrModeImm12", []> {
|
2013-04-13 02:47:25 +08:00
|
|
|
let PrintMethod = "printAddrModeImm12Operand<false>";
|
2010-12-11 04:53:44 +08:00
|
|
|
let EncoderMethod = "getAddrModeImm12OpValue";
|
2011-08-10 04:55:18 +08:00
|
|
|
let DecoderMethod = "DecodeT2AddrModeImm12";
|
2011-09-08 04:58:57 +08:00
|
|
|
let ParserMatchClass = t2addrmode_imm12_asmoperand;
|
2009-06-29 15:51:04 +08:00
|
|
|
let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
|
|
|
|
}
|
|
|
|
|
2011-03-19 01:42:55 +08:00
|
|
|
// t2ldrlabel := imm12
|
|
|
|
def t2ldrlabel : Operand<i32> {
|
|
|
|
let EncoderMethod = "getAddrModeImm12OpValue";
|
2012-10-30 09:04:51 +08:00
|
|
|
let PrintMethod = "printThumbLdrLabelOperand";
|
2011-03-19 01:42:55 +08:00
|
|
|
}
|
|
|
|
|
2012-01-19 06:46:46 +08:00
|
|
|
def t2ldr_pcrel_imm12_asmoperand : AsmOperandClass {let Name = "MemPCRelImm12";}
|
|
|
|
def t2ldr_pcrel_imm12 : Operand<i32> {
|
|
|
|
let ParserMatchClass = t2ldr_pcrel_imm12_asmoperand;
|
|
|
|
// used for assembler pseudo instruction and maps to t2ldrlabel, so
|
|
|
|
// doesn't need encoder or print methods of its own.
|
|
|
|
}
|
2011-03-19 01:42:55 +08:00
|
|
|
|
2010-12-14 08:36:49 +08:00
|
|
|
// ADR instruction labels.
|
|
|
|
def t2adrlabel : Operand<i32> {
|
|
|
|
let EncoderMethod = "getT2AdrLabelOpValue";
|
2013-07-03 17:21:44 +08:00
|
|
|
let PrintMethod = "printAdrLabelOperand<0>";
|
2010-12-14 08:36:49 +08:00
|
|
|
}
|
|
|
|
|
2011-09-08 07:39:14 +08:00
|
|
|
// t2addrmode_posimm8 := reg + imm8
|
|
|
|
def MemPosImm8OffsetAsmOperand : AsmOperandClass {let Name="MemPosImm8Offset";}
|
|
|
|
def t2addrmode_posimm8 : Operand<i32> {
|
2013-06-18 16:12:51 +08:00
|
|
|
let PrintMethod = "printT2AddrModeImm8Operand<false>";
|
2011-09-08 07:39:14 +08:00
|
|
|
let EncoderMethod = "getT2AddrModeImm8OpValue";
|
|
|
|
let DecoderMethod = "DecodeT2AddrModeImm8";
|
|
|
|
let ParserMatchClass = MemPosImm8OffsetAsmOperand;
|
|
|
|
let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
|
|
|
|
}
|
|
|
|
|
2011-09-08 04:58:57 +08:00
|
|
|
// t2addrmode_negimm8 := reg - imm8
|
|
|
|
def MemNegImm8OffsetAsmOperand : AsmOperandClass {let Name="MemNegImm8Offset";}
|
|
|
|
def t2addrmode_negimm8 : Operand<i32>,
|
|
|
|
ComplexPattern<i32, 2, "SelectT2AddrModeImm8", []> {
|
2013-06-18 16:12:51 +08:00
|
|
|
let PrintMethod = "printT2AddrModeImm8Operand<false>";
|
2011-09-08 04:58:57 +08:00
|
|
|
let EncoderMethod = "getT2AddrModeImm8OpValue";
|
|
|
|
let DecoderMethod = "DecodeT2AddrModeImm8";
|
|
|
|
let ParserMatchClass = MemNegImm8OffsetAsmOperand;
|
|
|
|
let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
|
|
|
|
}
|
|
|
|
|
2010-03-05 01:40:44 +08:00
|
|
|
// t2addrmode_imm8 := reg +/- imm8
|
2011-08-04 07:50:40 +08:00
|
|
|
def MemImm8OffsetAsmOperand : AsmOperandClass { let Name = "MemImm8Offset"; }
|
2013-06-18 16:12:51 +08:00
|
|
|
class T2AddrMode_Imm8 : Operand<i32>,
|
|
|
|
ComplexPattern<i32, 2, "SelectT2AddrModeImm8", []> {
|
2010-12-11 04:53:44 +08:00
|
|
|
let EncoderMethod = "getT2AddrModeImm8OpValue";
|
2011-08-10 04:55:18 +08:00
|
|
|
let DecoderMethod = "DecodeT2AddrModeImm8";
|
2011-08-04 07:50:40 +08:00
|
|
|
let ParserMatchClass = MemImm8OffsetAsmOperand;
|
2009-06-29 15:51:04 +08:00
|
|
|
let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
|
|
|
|
}
|
|
|
|
|
2013-06-18 16:12:51 +08:00
|
|
|
def t2addrmode_imm8 : T2AddrMode_Imm8 {
|
|
|
|
let PrintMethod = "printT2AddrModeImm8Operand<false>";
|
|
|
|
}
|
|
|
|
|
|
|
|
def t2addrmode_imm8_pre : T2AddrMode_Imm8 {
|
|
|
|
let PrintMethod = "printT2AddrModeImm8Operand<true>";
|
|
|
|
}
|
|
|
|
|
2009-07-03 08:06:39 +08:00
|
|
|
def t2am_imm8_offset : Operand<i32>,
|
2010-09-22 04:31:19 +08:00
|
|
|
ComplexPattern<i32, 1, "SelectT2AddrModeImm8Offset",
|
|
|
|
[], [SDNPWantRoot]> {
|
2009-07-02 15:28:31 +08:00
|
|
|
let PrintMethod = "printT2AddrModeImm8OffsetOperand";
|
2010-12-11 04:53:44 +08:00
|
|
|
let EncoderMethod = "getT2AddrModeImm8OffsetOpValue";
|
2011-08-10 04:55:18 +08:00
|
|
|
let DecoderMethod = "DecodeT2Imm8";
|
2009-07-02 15:28:31 +08:00
|
|
|
}
|
|
|
|
|
2009-07-10 06:21:59 +08:00
|
|
|
// t2addrmode_imm8s4 := reg +/- (imm8 << 2)
|
2011-09-09 06:07:06 +08:00
|
|
|
def MemImm8s4OffsetAsmOperand : AsmOperandClass {let Name = "MemImm8s4Offset";}
|
2013-06-18 16:12:51 +08:00
|
|
|
class T2AddrMode_Imm8s4 : Operand<i32> {
|
2010-12-11 04:53:44 +08:00
|
|
|
let EncoderMethod = "getT2AddrModeImm8s4OpValue";
|
2011-08-10 04:55:18 +08:00
|
|
|
let DecoderMethod = "DecodeT2AddrModeImm8s4";
|
2011-09-09 06:07:06 +08:00
|
|
|
let ParserMatchClass = MemImm8s4OffsetAsmOperand;
|
2009-07-01 06:50:01 +08:00
|
|
|
let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
|
|
|
|
}
|
|
|
|
|
2013-06-18 16:12:51 +08:00
|
|
|
def t2addrmode_imm8s4 : T2AddrMode_Imm8s4 {
|
|
|
|
let PrintMethod = "printT2AddrModeImm8s4Operand<false>";
|
|
|
|
}
|
|
|
|
|
|
|
|
def t2addrmode_imm8s4_pre : T2AddrMode_Imm8s4 {
|
|
|
|
let PrintMethod = "printT2AddrModeImm8s4Operand<true>";
|
|
|
|
}
|
|
|
|
|
2011-09-09 06:07:06 +08:00
|
|
|
def t2am_imm8s4_offset_asmoperand : AsmOperandClass { let Name = "Imm8s4"; }
|
2010-03-11 09:13:36 +08:00
|
|
|
def t2am_imm8s4_offset : Operand<i32> {
|
|
|
|
let PrintMethod = "printT2AddrModeImm8s4OffsetOperand";
|
2011-09-09 06:07:06 +08:00
|
|
|
let EncoderMethod = "getT2Imm8s4OpValue";
|
2011-08-05 07:18:05 +08:00
|
|
|
let DecoderMethod = "DecodeT2Imm8S4";
|
2010-03-11 09:13:36 +08:00
|
|
|
}
|
|
|
|
|
2011-09-10 02:37:27 +08:00
|
|
|
// t2addrmode_imm0_1020s4 := reg + (imm8 << 2)
|
|
|
|
def MemImm0_1020s4OffsetAsmOperand : AsmOperandClass {
|
|
|
|
let Name = "MemImm0_1020s4Offset";
|
|
|
|
}
|
2013-07-16 17:46:55 +08:00
|
|
|
def t2addrmode_imm0_1020s4 : Operand<i32>,
|
|
|
|
ComplexPattern<i32, 2, "SelectT2AddrModeExclusive"> {
|
2011-09-10 02:37:27 +08:00
|
|
|
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-10 04:40:44 +08:00
|
|
|
// t2addrmode_so_reg := reg + (reg << imm2)
|
2011-09-08 07:10:15 +08:00
|
|
|
def t2addrmode_so_reg_asmoperand : AsmOperandClass {let Name="T2MemRegOffset";}
|
2009-06-29 15:51:04 +08:00
|
|
|
def t2addrmode_so_reg : Operand<i32>,
|
|
|
|
ComplexPattern<i32, 3, "SelectT2AddrModeSoReg", []> {
|
|
|
|
let PrintMethod = "printT2AddrModeSoRegOperand";
|
2010-12-11 04:53:44 +08:00
|
|
|
let EncoderMethod = "getT2AddrModeSORegOpValue";
|
2011-08-10 04:55:18 +08:00
|
|
|
let DecoderMethod = "DecodeT2AddrModeSOReg";
|
2011-09-08 07:10:15 +08: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
llvm-svn: 109842
2010-07-30 10:41:01 +08:00
|
|
|
let MIOperandInfo = (ops GPR:$base, rGPR:$offsreg, i32imm:$offsimm);
|
2009-06-29 15:51:04 +08:00
|
|
|
}
|
|
|
|
|
2011-09-20 06:21:13 +08:00
|
|
|
// Addresses for the TBB/TBH instructions.
|
|
|
|
def addrmode_tbb_asmoperand : AsmOperandClass { let Name = "MemTBB"; }
|
|
|
|
def addrmode_tbb : Operand<i32> {
|
|
|
|
let PrintMethod = "printAddrModeTBB";
|
|
|
|
let ParserMatchClass = addrmode_tbb_asmoperand;
|
|
|
|
let MIOperandInfo = (ops GPR:$Rn, rGPR:$Rm);
|
|
|
|
}
|
|
|
|
def addrmode_tbh_asmoperand : AsmOperandClass { let Name = "MemTBH"; }
|
|
|
|
def addrmode_tbh : Operand<i32> {
|
|
|
|
let PrintMethod = "printAddrModeTBH";
|
|
|
|
let ParserMatchClass = addrmode_tbh_asmoperand;
|
|
|
|
let MIOperandInfo = (ops GPR:$Rn, rGPR:$Rm);
|
|
|
|
}
|
|
|
|
|
2009-06-18 02:13:58 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2009-06-27 10:26:13 +08:00
|
|
|
// Multiclass helpers...
|
2009-06-18 02:13:58 +08:00
|
|
|
//
|
|
|
|
|
2010-11-16 02:45:17 +08:00
|
|
|
|
|
|
|
class T2OneRegImm<dag oops, dag iops, InstrItinClass itin,
|
2010-11-14 13:37:38 +08:00
|
|
|
string opc, string asm, list<dag> pattern>
|
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> Rd;
|
2010-11-16 02:45:17 +08:00
|
|
|
bits<12> imm;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-16 02:45:17 +08:00
|
|
|
let Inst{26} = imm{11};
|
|
|
|
let Inst{14-12} = imm{10-8};
|
|
|
|
let Inst{7-0} = imm{7-0};
|
|
|
|
}
|
|
|
|
|
2010-11-16 03:58:36 +08:00
|
|
|
|
2010-11-16 02:45:17 +08: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 13:37:38 +08:00
|
|
|
bits<4> Rn;
|
|
|
|
bits<12> imm;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-14 13:37:38 +08:00
|
|
|
let Inst{26} = imm{11};
|
|
|
|
let Inst{14-12} = imm{10-8};
|
|
|
|
let Inst{7-0} = imm{7-0};
|
|
|
|
}
|
|
|
|
|
2010-11-16 03:58:36 +08: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-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{19-16} = Rn;
|
2010-11-16 03:58:36 +08:00
|
|
|
let Inst{26} = imm{11};
|
|
|
|
let Inst{14-12} = imm{10-8};
|
|
|
|
let Inst{7-0} = imm{7-0};
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-11-16 02:45:17 +08: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-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-16 02:45:17 +08: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-08 04:50:15 +08:00
|
|
|
: T2sI<oops, iops, itin, opc, asm, pattern> {
|
2010-11-16 02:45:17 +08:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<12> ShiftedRm;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-16 02:45:17 +08: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-16 03:58:36 +08: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-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{19-16} = Rn;
|
2010-11-16 03:58:36 +08: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-16 02:45:17 +08:00
|
|
|
class T2TwoReg<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-20 01:11:02 +08:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
2010-11-16 02:45:17 +08:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rm;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{3-0} = Rm;
|
2010-11-16 02:45:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class T2sTwoReg<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-20 01:11:02 +08:00
|
|
|
: T2sI<oops, iops, itin, opc, asm, pattern> {
|
2010-11-16 02:45:17 +08:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rm;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{3-0} = Rm;
|
2010-11-16 02:45:17 +08:00
|
|
|
}
|
|
|
|
|
2010-11-16 03:58:36 +08:00
|
|
|
class T2TwoRegCmp<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-20 01:11:02 +08:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
2010-11-16 03:58:36 +08:00
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{3-0} = Rm;
|
2010-11-16 03:58:36 +08:00
|
|
|
}
|
|
|
|
|
2010-11-16 02:45:17 +08: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-09 07:04:16 +08:00
|
|
|
bits<4> Rn;
|
2010-12-09 07:24:29 +08:00
|
|
|
bits<12> imm;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
2010-12-09 07:24:29 +08: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-16 02:45:17 +08:00
|
|
|
}
|
|
|
|
|
2010-11-14 13:37:38 +08:00
|
|
|
class T2sTwoRegImm<dag oops, dag iops, InstrItinClass itin,
|
2010-11-13 05:12:40 +08: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-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{19-16} = Rn;
|
2010-11-13 05:12:40 +08:00
|
|
|
let Inst{26} = imm{11};
|
|
|
|
let Inst{14-12} = imm{10-8};
|
|
|
|
let Inst{7-0} = imm{7-0};
|
|
|
|
}
|
|
|
|
|
2010-11-16 03:58:36 +08: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-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{3-0} = Rm;
|
2010-11-16 03:58:36 +08: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-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{3-0} = Rm;
|
2010-11-16 03:58:36 +08:00
|
|
|
let Inst{14-12} = imm{4-2};
|
|
|
|
let Inst{7-6} = imm{1-0};
|
|
|
|
}
|
|
|
|
|
2010-11-13 05:12:40 +08:00
|
|
|
class T2ThreeReg<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-20 01:11:02 +08:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
2010-11-14 13:37:38 +08:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{3-0} = Rm;
|
2010-11-14 13:37:38 +08:00
|
|
|
}
|
|
|
|
|
2013-09-18 17:45:55 +08:00
|
|
|
class T2ThreeRegNoP<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string asm, list<dag> pattern>
|
|
|
|
: T2XI<oops, iops, itin, asm, pattern> {
|
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
|
|
|
|
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{3-0} = Rm;
|
|
|
|
}
|
|
|
|
|
2010-11-14 13:37:38 +08:00
|
|
|
class T2sThreeReg<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-20 01:11:02 +08:00
|
|
|
: T2sI<oops, iops, itin, opc, asm, pattern> {
|
2010-11-13 05:12:40 +08:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{3-0} = Rm;
|
2010-11-13 05:12:40 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class T2TwoRegShiftedReg<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-14 13:37:38 +08:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<12> ShiftedRm;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{19-16} = Rn;
|
2010-11-14 13:37:38 +08: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-13 05:12:40 +08:00
|
|
|
: T2sI<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<12> ShiftedRm;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{19-16} = Rn;
|
2010-11-13 05:12:40 +08: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 09:08:42 +08:00
|
|
|
class T2FourReg<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-20 01:11:02 +08:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
2010-11-18 09:08:42 +08:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
|
|
|
bits<4> Ra;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{15-12} = Ra;
|
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{3-0} = Rm;
|
2010-11-18 09:08:42 +08:00
|
|
|
}
|
|
|
|
|
2010-12-09 06:38:41 +08: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-09 06:29:28 +08:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> RdLo;
|
|
|
|
bits<4> RdHi;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
|
|
|
|
2010-12-09 06:38:41 +08:00
|
|
|
let Inst{31-23} = 0b111110111;
|
|
|
|
let Inst{22-20} = opc22_20;
|
2010-12-09 06:29:28 +08:00
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{15-12} = RdLo;
|
|
|
|
let Inst{11-8} = RdHi;
|
2010-12-09 06:38:41 +08:00
|
|
|
let Inst{7-4} = opc7_4;
|
2010-12-09 06:29:28 +08:00
|
|
|
let Inst{3-0} = Rm;
|
|
|
|
}
|
2012-09-04 22:37:49 +08:00
|
|
|
class T2MlaLong<bits<3> opc22_20, bits<4> opc7_4,
|
|
|
|
dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<4> RdLo;
|
|
|
|
bits<4> RdHi;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
|
|
|
|
|
|
|
let Inst{31-23} = 0b111110111;
|
|
|
|
let Inst{22-20} = opc22_20;
|
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{15-12} = RdLo;
|
|
|
|
let Inst{11-8} = RdHi;
|
|
|
|
let Inst{7-4} = opc7_4;
|
|
|
|
let Inst{3-0} = Rm;
|
|
|
|
}
|
2010-12-09 06:29:28 +08:00
|
|
|
|
2010-11-18 09:08:42 +08:00
|
|
|
|
2009-06-24 03:39:13 +08:00
|
|
|
/// T2I_bin_irs - Defines a set of (op reg, {so_imm|r|so_reg}) patterns for a
|
2010-05-25 12:43:08 +08:00
|
|
|
/// binary operation that produces a value. These are predicable and can be
|
2009-06-25 10:08:06 +08:00
|
|
|
/// changed to modify CPSR.
|
2010-09-29 08:27:46 +08:00
|
|
|
multiclass T2I_bin_irs<bits<4> opcod, string opc,
|
|
|
|
InstrItinClass iii, InstrItinClass iir, InstrItinClass iis,
|
2012-08-03 05:50:41 +08:00
|
|
|
PatFrag opnode, bit Commutable = 0,
|
2011-06-28 08:19:13 +08:00
|
|
|
string wide = ""> {
|
2009-06-24 01:48:47 +08:00
|
|
|
// shifted imm
|
2010-11-14 13:37:38 +08:00
|
|
|
def ri : T2sTwoRegImm<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_imm:$imm), iii,
|
|
|
|
opc, "\t$Rd, $Rn, $imm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, (opnode rGPR:$Rn, t2_so_imm:$imm))]>,
|
|
|
|
Sched<[WriteALU, ReadALU]> {
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 0;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
2009-06-24 03:39:13 +08:00
|
|
|
// register
|
2010-11-14 13:37:38 +08:00
|
|
|
def rr : T2sThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), iir,
|
|
|
|
opc, !strconcat(wide, "\t$Rd, $Rn, $Rm"),
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, (opnode rGPR:$Rn, rGPR:$Rm))]>,
|
|
|
|
Sched<[WriteALU, ReadALU, ReadALU]> {
|
2009-06-26 08:19:44 +08:00
|
|
|
let isCommutable = Commutable;
|
2009-12-16 01:24:14 +08: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 08:19:44 +08:00
|
|
|
}
|
2009-06-24 01:48:47 +08:00
|
|
|
// shifted register
|
2010-11-14 13:37:38 +08:00
|
|
|
def rs : T2sTwoRegShiftedReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_reg:$ShiftedRm), iis,
|
|
|
|
opc, !strconcat(wide, "\t$Rd, $Rn, $ShiftedRm"),
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, (opnode rGPR:$Rn, t2_so_reg:$ShiftedRm))]>,
|
|
|
|
Sched<[WriteALUsi, ReadALU]> {
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
2010-08-30 09:47:35 +08:00
|
|
|
}
|
2011-06-28 08:19:13 +08:00
|
|
|
// Assembly aliases for optional destination operand when it's the same
|
|
|
|
// as the source operand.
|
2011-08-23 02:04:24 +08:00
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p} $Rdn, $imm"),
|
2012-08-03 05:50:41 +08:00
|
|
|
(!cast<Instruction>(NAME#"ri") rGPR:$Rdn, rGPR:$Rdn,
|
2011-06-28 08:19:13 +08:00
|
|
|
t2_so_imm:$imm, pred:$p,
|
2011-08-23 02:04:24 +08:00
|
|
|
cc_out:$s)>;
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", wide, " $Rdn, $Rm"),
|
2012-08-03 05:50:41 +08:00
|
|
|
(!cast<Instruction>(NAME#"rr") rGPR:$Rdn, rGPR:$Rdn,
|
2011-06-28 08:19:13 +08:00
|
|
|
rGPR:$Rm, pred:$p,
|
2011-08-23 02:04:24 +08:00
|
|
|
cc_out:$s)>;
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", wide, " $Rdn, $shift"),
|
2012-08-03 05:50:41 +08:00
|
|
|
(!cast<Instruction>(NAME#"rs") rGPR:$Rdn, rGPR:$Rdn,
|
2011-06-28 08:19:13 +08:00
|
|
|
t2_so_reg:$shift, pred:$p,
|
2011-08-23 02:04:24 +08:00
|
|
|
cc_out:$s)>;
|
2010-08-30 09:47:35 +08:00
|
|
|
}
|
|
|
|
|
2009-07-28 07:34:12 +08:00
|
|
|
/// T2I_bin_w_irs - Same as T2I_bin_irs except these operations need
|
2011-06-28 08:19:13 +08:00
|
|
|
// the ".w" suffix to indicate that they are wide.
|
2010-09-29 08:27:46 +08:00
|
|
|
multiclass T2I_bin_w_irs<bits<4> opcod, string opc,
|
|
|
|
InstrItinClass iii, InstrItinClass iir, InstrItinClass iis,
|
2012-08-03 05:50:41 +08:00
|
|
|
PatFrag opnode, bit Commutable = 0> :
|
|
|
|
T2I_bin_irs<opcod, opc, iii, iir, iis, opnode, Commutable, ".w"> {
|
2012-02-25 03:06:05 +08:00
|
|
|
// Assembler aliases w/ the ".w" suffix.
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}.w", " $Rd, $Rn, $imm"),
|
2012-08-03 05:50:41 +08:00
|
|
|
(!cast<Instruction>(NAME#"ri") rGPR:$Rd, rGPR:$Rn, t2_so_imm:$imm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
2011-09-03 02:41:35 +08:00
|
|
|
// Assembler aliases w/o the ".w" suffix.
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", " $Rd, $Rn, $Rm"),
|
2012-08-03 05:50:41 +08:00
|
|
|
(!cast<Instruction>(NAME#"rr") rGPR:$Rd, rGPR:$Rn, rGPR:$Rm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
2011-09-03 02:41:35 +08:00
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", " $Rd, $Rn, $shift"),
|
2012-08-03 05:50:41 +08:00
|
|
|
(!cast<Instruction>(NAME#"rs") rGPR:$Rd, rGPR:$Rn, t2_so_reg:$shift,
|
|
|
|
pred:$p, cc_out:$s)>;
|
2011-09-03 02:41:35 +08:00
|
|
|
|
|
|
|
// and with the optional destination operand, too.
|
2012-03-17 06:18:29 +08:00
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}.w", " $Rdn, $imm"),
|
2012-08-03 05:50:41 +08:00
|
|
|
(!cast<Instruction>(NAME#"ri") rGPR:$Rdn, rGPR:$Rdn, t2_so_imm:$imm,
|
|
|
|
pred:$p, cc_out:$s)>;
|
2011-09-03 02:41:35 +08:00
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", " $Rdn, $Rm"),
|
2012-08-03 05:50:41 +08:00
|
|
|
(!cast<Instruction>(NAME#"rr") rGPR:$Rdn, rGPR:$Rdn, rGPR:$Rm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
2011-09-03 02:41:35 +08:00
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", " $Rdn, $shift"),
|
2012-08-03 05:50:41 +08:00
|
|
|
(!cast<Instruction>(NAME#"rs") rGPR:$Rdn, rGPR:$Rdn, t2_so_reg:$shift,
|
|
|
|
pred:$p, cc_out:$s)>;
|
2011-09-03 02:41:35 +08:00
|
|
|
}
|
2010-08-29 11:55:31 +08:00
|
|
|
|
2009-06-26 04:59:23 +08:00
|
|
|
/// T2I_rbin_is - Same as T2I_bin_irs except the order of operands are
|
2010-08-14 07:24:25 +08: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-18 02:13:58 +08:00
|
|
|
// shifted imm
|
2010-11-14 13:37:38 +08:00
|
|
|
def ri : T2sTwoRegImm<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_imm:$imm), IIC_iALUi,
|
|
|
|
opc, ".w\t$Rd, $Rn, $imm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, (opnode t2_so_imm:$imm, rGPR:$Rn))]>,
|
|
|
|
Sched<[WriteALU, ReadALU]> {
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 0;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
2010-08-14 07:24:25 +08:00
|
|
|
// register
|
2010-11-14 13:37:38 +08:00
|
|
|
def rr : T2sThreeReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iALUr,
|
|
|
|
opc, "\t$Rd, $Rn, $Rm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[/* For disassembly only; pattern left blank */]>,
|
|
|
|
Sched<[WriteALU, ReadALU, ReadALU]> {
|
2010-08-14 07:24:25 +08: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-18 02:13:58 +08:00
|
|
|
// shifted register
|
2010-11-14 13:37:38 +08:00
|
|
|
def rs : T2sTwoRegShiftedReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_reg:$ShiftedRm),
|
|
|
|
IIC_iALUsir, opc, "\t$Rd, $Rn, $ShiftedRm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, (opnode t2_so_reg:$ShiftedRm, rGPR:$Rn))]>,
|
|
|
|
Sched<[WriteALUsi, ReadALU]> {
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
}
|
2009-06-18 02:13:58 +08:00
|
|
|
}
|
|
|
|
|
2009-06-24 03:39:13 +08:00
|
|
|
/// T2I_bin_s_irs - Similar to T2I_bin_irs except it sets the 's' bit so the
|
2009-06-18 02:13:58 +08:00
|
|
|
/// instruction modifies the CPSR register.
|
2011-09-21 10:20:46 +08:00
|
|
|
///
|
|
|
|
/// These opcodes will be converted to the real non-S opcodes by
|
|
|
|
/// AdjustInstrPostInstrSelection after giving then an optional CPSR operand.
|
2011-10-19 03:18:52 +08:00
|
|
|
let hasPostISelHook = 1, Defs = [CPSR] in {
|
|
|
|
multiclass T2I_bin_s_irs<InstrItinClass iii, InstrItinClass iir,
|
|
|
|
InstrItinClass iis, PatFrag opnode,
|
|
|
|
bit Commutable = 0> {
|
2009-06-24 01:48:47 +08:00
|
|
|
// shifted imm
|
2011-10-19 03:18:52 +08:00
|
|
|
def ri : t2PseudoInst<(outs rGPR:$Rd),
|
|
|
|
(ins GPRnopc:$Rn, t2_so_imm:$imm, pred:$p),
|
|
|
|
4, iii,
|
|
|
|
[(set rGPR:$Rd, CPSR, (opnode GPRnopc:$Rn,
|
2013-06-07 00:35:25 +08:00
|
|
|
t2_so_imm:$imm))]>,
|
|
|
|
Sched<[WriteALU, ReadALU]>;
|
2009-06-24 03:39:13 +08:00
|
|
|
// register
|
2011-10-19 03:18:52 +08:00
|
|
|
def rr : t2PseudoInst<(outs rGPR:$Rd), (ins GPRnopc:$Rn, rGPR:$Rm, pred:$p),
|
|
|
|
4, iir,
|
|
|
|
[(set rGPR:$Rd, CPSR, (opnode GPRnopc:$Rn,
|
2013-06-07 00:35:25 +08:00
|
|
|
rGPR:$Rm))]>,
|
|
|
|
Sched<[WriteALU, ReadALU, ReadALU]> {
|
2011-10-19 03:18:52 +08:00
|
|
|
let isCommutable = Commutable;
|
|
|
|
}
|
2009-06-24 01:48:47 +08:00
|
|
|
// shifted register
|
2011-10-19 03:18:52 +08:00
|
|
|
def rs : t2PseudoInst<(outs rGPR:$Rd),
|
|
|
|
(ins GPRnopc:$Rn, t2_so_reg:$ShiftedRm, pred:$p),
|
|
|
|
4, iis,
|
|
|
|
[(set rGPR:$Rd, CPSR, (opnode GPRnopc:$Rn,
|
2013-06-07 00:35:25 +08:00
|
|
|
t2_so_reg:$ShiftedRm))]>,
|
|
|
|
Sched<[WriteALUsi, ReadALUsr]>;
|
2011-10-19 03:18:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// T2I_rbin_s_is - Same as T2I_bin_s_irs, except selection DAG
|
|
|
|
/// operands are reversed.
|
|
|
|
let hasPostISelHook = 1, Defs = [CPSR] in {
|
|
|
|
multiclass T2I_rbin_s_is<PatFrag opnode> {
|
|
|
|
// shifted imm
|
|
|
|
def ri : t2PseudoInst<(outs rGPR:$Rd),
|
2012-05-22 01:57:17 +08:00
|
|
|
(ins rGPR:$Rn, t2_so_imm:$imm, pred:$p),
|
2011-10-19 03:18:52 +08:00
|
|
|
4, IIC_iALUi,
|
|
|
|
[(set rGPR:$Rd, CPSR, (opnode t2_so_imm:$imm,
|
2013-06-07 00:35:25 +08:00
|
|
|
rGPR:$Rn))]>,
|
|
|
|
Sched<[WriteALU, ReadALU]>;
|
2011-10-19 03:18:52 +08:00
|
|
|
// shifted register
|
|
|
|
def rs : t2PseudoInst<(outs rGPR:$Rd),
|
2012-05-22 01:57:17 +08:00
|
|
|
(ins rGPR:$Rn, t2_so_reg:$ShiftedRm, pred:$p),
|
2011-10-19 03:18:52 +08:00
|
|
|
4, IIC_iALUsi,
|
|
|
|
[(set rGPR:$Rd, CPSR, (opnode t2_so_reg:$ShiftedRm,
|
2013-06-07 00:35:25 +08:00
|
|
|
rGPR:$Rn))]>,
|
|
|
|
Sched<[WriteALUsi, ReadALU]>;
|
2009-06-24 01:48:47 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-24 03:39:13 +08: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-16 01:24:14 +08:00
|
|
|
multiclass T2I_bin_ii12rs<bits<3> op23_21, string opc, PatFrag opnode,
|
|
|
|
bit Commutable = 0> {
|
2009-06-18 02:13:58 +08:00
|
|
|
// shifted imm
|
2010-08-31 03:49:58 +08: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 13:37:38 +08:00
|
|
|
def ri : T2sTwoRegImm<
|
2011-10-04 04:51:59 +08:00
|
|
|
(outs GPRnopc:$Rd), (ins GPRnopc:$Rn, t2_so_imm:$imm), IIC_iALUi,
|
|
|
|
opc, ".w\t$Rd, $Rn, $imm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set GPRnopc:$Rd, (opnode GPRnopc:$Rn, t2_so_imm:$imm))]>,
|
|
|
|
Sched<[WriteALU, ReadALU]> {
|
2009-12-16 01:24:14 +08: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-31 03:49:58 +08:00
|
|
|
}
|
2009-06-24 01:48:47 +08:00
|
|
|
// 12-bit imm
|
2010-12-09 07:04:16 +08:00
|
|
|
def ri12 : T2I<
|
2011-10-04 04:51:59 +08:00
|
|
|
(outs GPRnopc:$Rd), (ins GPR:$Rn, imm0_4095:$imm), IIC_iALUi,
|
2010-11-14 13:37:38 +08:00
|
|
|
!strconcat(opc, "w"), "\t$Rd, $Rn, $imm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set GPRnopc:$Rd, (opnode GPR:$Rn, imm0_4095:$imm))]>,
|
|
|
|
Sched<[WriteALU, ReadALU]> {
|
2010-12-09 07:04:16 +08:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<12> imm;
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11110;
|
2010-12-09 07:04:16 +08:00
|
|
|
let Inst{26} = imm{11};
|
|
|
|
let Inst{25-24} = 0b10;
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{23-21} = op23_21;
|
|
|
|
let Inst{20} = 0; // The S bit.
|
2010-12-09 07:04:16 +08:00
|
|
|
let Inst{19-16} = Rn;
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{15} = 0;
|
2010-12-09 07:04:16 +08:00
|
|
|
let Inst{14-12} = imm{10-8};
|
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{7-0} = imm{7-0};
|
2009-12-16 01:24:14 +08:00
|
|
|
}
|
2009-06-24 03:39:13 +08:00
|
|
|
// register
|
2011-10-04 04:51:59 +08:00
|
|
|
def rr : T2sThreeReg<(outs GPRnopc:$Rd), (ins GPRnopc:$Rn, rGPR:$Rm),
|
|
|
|
IIC_iALUr, opc, ".w\t$Rd, $Rn, $Rm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set GPRnopc:$Rd, (opnode GPRnopc:$Rn, rGPR:$Rm))]>,
|
|
|
|
Sched<[WriteALU, ReadALU, ReadALU]> {
|
2009-06-26 08:19:44 +08:00
|
|
|
let isCommutable = Commutable;
|
2009-12-16 01:24:14 +08: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 08:19:44 +08:00
|
|
|
}
|
2009-06-24 01:48:47 +08:00
|
|
|
// shifted register
|
2010-11-14 13:37:38 +08:00
|
|
|
def rs : T2sTwoRegShiftedReg<
|
2011-10-04 04:51:59 +08:00
|
|
|
(outs GPRnopc:$Rd), (ins GPRnopc:$Rn, t2_so_reg:$ShiftedRm),
|
2010-11-14 13:37:38 +08:00
|
|
|
IIC_iALUsi, opc, ".w\t$Rd, $Rn, $ShiftedRm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set GPRnopc:$Rd, (opnode GPRnopc:$Rn, t2_so_reg:$ShiftedRm))]>,
|
|
|
|
Sched<[WriteALUsi, ReadALU]> {
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
2010-01-09 01:41:33 +08:00
|
|
|
let Inst{24} = 1;
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{23-21} = op23_21;
|
|
|
|
}
|
2009-06-24 01:48:47 +08:00
|
|
|
}
|
2009-06-18 02:13:58 +08:00
|
|
|
|
2009-11-24 08:20:27 +08:00
|
|
|
/// T2I_adde_sube_irs - Defines a set of (op reg, {so_imm|r|so_reg}) patterns
|
2010-02-17 04:42:29 +08:00
|
|
|
/// for a binary operation that produces a value and use the carry
|
2009-11-24 08:20:27 +08:00
|
|
|
/// bit. It's not predicable.
|
2011-08-30 09:34:54 +08:00
|
|
|
let Defs = [CPSR], Uses = [CPSR] in {
|
2010-02-17 05:23:02 +08:00
|
|
|
multiclass T2I_adde_sube_irs<bits<4> opcod, string opc, PatFrag opnode,
|
|
|
|
bit Commutable = 0> {
|
2009-06-24 01:48:47 +08:00
|
|
|
// shifted imm
|
2010-11-14 13:37:38 +08:00
|
|
|
def ri : T2sTwoRegImm<(outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_imm:$imm),
|
2010-11-13 05:12:40 +08:00
|
|
|
IIC_iALUi, opc, "\t$Rd, $Rn, $imm",
|
2011-08-30 09:34:54 +08:00
|
|
|
[(set rGPR:$Rd, CPSR, (opnode rGPR:$Rn, t2_so_imm:$imm, CPSR))]>,
|
2013-06-07 00:35:25 +08:00
|
|
|
Requires<[IsThumb2]>, Sched<[WriteALU, ReadALU]> {
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 0;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
2009-06-24 03:39:13 +08:00
|
|
|
// register
|
2010-11-14 13:37:38 +08:00
|
|
|
def rr : T2sThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iALUr,
|
2010-11-13 05:12:40 +08:00
|
|
|
opc, ".w\t$Rd, $Rn, $Rm",
|
2011-08-30 09:34:54 +08:00
|
|
|
[(set rGPR:$Rd, CPSR, (opnode rGPR:$Rn, rGPR:$Rm, CPSR))]>,
|
2013-06-07 00:35:25 +08:00
|
|
|
Requires<[IsThumb2]>, Sched<[WriteALU, ReadALU, ReadALU]> {
|
2009-06-26 08:19:44 +08:00
|
|
|
let isCommutable = Commutable;
|
2009-12-16 01:24:14 +08: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 08:19:44 +08:00
|
|
|
}
|
2009-06-18 02:13:58 +08:00
|
|
|
// shifted register
|
2010-11-14 13:37:38 +08:00
|
|
|
def rs : T2sTwoRegShiftedReg<
|
2010-11-20 01:11:02 +08:00
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_reg:$ShiftedRm),
|
2010-11-13 05:12:40 +08:00
|
|
|
IIC_iALUsi, opc, ".w\t$Rd, $Rn, $ShiftedRm",
|
2011-08-30 09:34:54 +08:00
|
|
|
[(set rGPR:$Rd, CPSR, (opnode rGPR:$Rn, t2_so_reg:$ShiftedRm, CPSR))]>,
|
2013-06-07 00:35:25 +08:00
|
|
|
Requires<[IsThumb2]>, Sched<[WriteALUsi, ReadALU]> {
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
}
|
2010-02-17 04:42:29 +08:00
|
|
|
}
|
2011-04-23 11:55:32 +08:00
|
|
|
}
|
2010-02-17 04:42:29 +08:00
|
|
|
|
2009-06-24 03:39:13 +08:00
|
|
|
/// T2I_sh_ir - Defines a set of (op reg, {so_imm|r}) patterns for a shift /
|
|
|
|
// rotate operation that produces a value.
|
2012-08-03 05:59:52 +08:00
|
|
|
multiclass T2I_sh_ir<bits<2> opcod, string opc, Operand ty, PatFrag opnode> {
|
2009-06-24 03:39:13 +08:00
|
|
|
// 5-bit imm
|
2010-11-16 03:58:36 +08:00
|
|
|
def ri : T2sTwoRegShiftImm<
|
2011-08-09 04:42:17 +08:00
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rm, ty:$imm), IIC_iMOVsi,
|
2010-11-16 03:58:36 +08:00
|
|
|
opc, ".w\t$Rd, $Rm, $imm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, (opnode rGPR:$Rm, (i32 ty:$imm)))]>,
|
|
|
|
Sched<[WriteALU]> {
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-21} = 0b010010;
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{5-4} = opcod;
|
|
|
|
}
|
2009-06-24 03:39:13 +08:00
|
|
|
// register
|
2010-11-16 03:58:36 +08:00
|
|
|
def rr : T2sThreeReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMOVsr,
|
|
|
|
opc, ".w\t$Rd, $Rn, $Rm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, (opnode rGPR:$Rn, rGPR:$Rm))]>,
|
|
|
|
Sched<[WriteALU]> {
|
2009-12-16 01:24:14 +08: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-03 05:28:54 +08:00
|
|
|
|
|
|
|
// Optional destination register
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", ".w $Rdn, $imm"),
|
2012-08-03 05:59:52 +08:00
|
|
|
(!cast<Instruction>(NAME#"ri") rGPR:$Rdn, rGPR:$Rdn, ty:$imm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
2011-09-03 05:28:54 +08:00
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", ".w $Rdn, $Rm"),
|
2012-08-03 05:59:52 +08:00
|
|
|
(!cast<Instruction>(NAME#"rr") rGPR:$Rdn, rGPR:$Rdn, rGPR:$Rm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
2011-09-03 05:28:54 +08:00
|
|
|
|
|
|
|
// Assembler aliases w/o the ".w" suffix.
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", " $Rd, $Rn, $imm"),
|
2012-08-03 05:59:52 +08:00
|
|
|
(!cast<Instruction>(NAME#"ri") rGPR:$Rd, rGPR:$Rn, ty:$imm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
2011-09-03 05:28:54 +08:00
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", " $Rd, $Rn, $Rm"),
|
2012-08-03 05:59:52 +08:00
|
|
|
(!cast<Instruction>(NAME#"rr") rGPR:$Rd, rGPR:$Rn, rGPR:$Rm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
2011-09-03 05:28:54 +08:00
|
|
|
|
|
|
|
// and with the optional destination operand, too.
|
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", " $Rdn, $imm"),
|
2012-08-03 05:59:52 +08:00
|
|
|
(!cast<Instruction>(NAME#"ri") rGPR:$Rdn, rGPR:$Rdn, ty:$imm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
2011-09-03 05:28:54 +08:00
|
|
|
def : t2InstAlias<!strconcat(opc, "${s}${p}", " $Rdn, $Rm"),
|
2012-08-03 05:59:52 +08:00
|
|
|
(!cast<Instruction>(NAME#"rr") rGPR:$Rdn, rGPR:$Rdn, rGPR:$Rm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
2009-06-24 03:39:13 +08:00
|
|
|
}
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2009-12-16 01:24:14 +08:00
|
|
|
/// T2I_cmp_irs - Defines a set of (op r, {so_imm|r|so_reg}) cmp / test
|
2009-06-24 03:39:13 +08:00
|
|
|
/// patterns. Similar to T2I_bin_irs except the instruction does not produce
|
2009-06-24 01:48:47 +08:00
|
|
|
/// a explicit result, only implicitly set CPSR.
|
2010-09-29 08:49:25 +08:00
|
|
|
multiclass T2I_cmp_irs<bits<4> opcod, string opc,
|
|
|
|
InstrItinClass iii, InstrItinClass iir, InstrItinClass iis,
|
2012-08-03 05:59:52 +08:00
|
|
|
PatFrag opnode> {
|
2011-09-07 05:44:58 +08:00
|
|
|
let isCompare = 1, Defs = [CPSR] in {
|
2009-06-24 01:48:47 +08:00
|
|
|
// shifted imm
|
2010-11-16 03:58:36 +08:00
|
|
|
def ri : T2OneRegCmpImm<
|
2011-09-07 05:44:58 +08:00
|
|
|
(outs), (ins GPRnopc:$Rn, t2_so_imm:$imm), iii,
|
2010-11-16 03:58:36 +08:00
|
|
|
opc, ".w\t$Rn, $imm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(opnode GPRnopc:$Rn, t2_so_imm:$imm)]>, Sched<[WriteCMP]> {
|
2009-12-16 01:24:14 +08: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-24 03:39:13 +08:00
|
|
|
// register
|
2010-11-16 03:58:36 +08:00
|
|
|
def rr : T2TwoRegCmp<
|
2011-09-07 05:44:58 +08:00
|
|
|
(outs), (ins GPRnopc:$Rn, rGPR:$Rm), iir,
|
2011-08-24 01:37:32 +08:00
|
|
|
opc, ".w\t$Rn, $Rm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(opnode GPRnopc:$Rn, rGPR:$Rm)]>, Sched<[WriteCMP]> {
|
2009-12-16 01:24:14 +08: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-18 02:13:58 +08:00
|
|
|
// shifted register
|
2010-11-16 03:58:36 +08:00
|
|
|
def rs : T2OneRegCmpShiftedReg<
|
2011-09-07 05:44:58 +08:00
|
|
|
(outs), (ins GPRnopc:$Rn, t2_so_reg:$ShiftedRm), iis,
|
2010-11-16 03:58:36 +08:00
|
|
|
opc, ".w\t$Rn, $ShiftedRm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(opnode GPRnopc:$Rn, t2_so_reg:$ShiftedRm)]>,
|
|
|
|
Sched<[WriteCMPsi]> {
|
2009-12-16 01:24:14 +08: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-18 02:13:58 +08:00
|
|
|
}
|
2011-09-07 05:44:58 +08: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"),
|
2012-08-03 05:59:52 +08:00
|
|
|
(!cast<Instruction>(NAME#"ri") GPRnopc:$Rn, t2_so_imm:$imm, pred:$p)>;
|
2011-09-07 05:44:58 +08:00
|
|
|
def : t2InstAlias<!strconcat(opc, "${p}", " $Rn, $shift"),
|
2012-08-03 05:59:52 +08:00
|
|
|
(!cast<Instruction>(NAME#"rs") GPRnopc:$Rn, t2_so_reg:$shift, pred:$p)>;
|
2009-06-18 02:13:58 +08:00
|
|
|
}
|
|
|
|
|
2009-06-30 10:15:48 +08:00
|
|
|
/// T2I_ld - Defines a set of (op r, {imm12|imm8|so_reg}) load patterns.
|
2010-09-30 09:08:25 +08:00
|
|
|
multiclass T2I_ld<bit signed, bits<2> opcod, string opc,
|
2011-08-12 04:40:40 +08:00
|
|
|
InstrItinClass iii, InstrItinClass iis, RegisterClass target,
|
|
|
|
PatFrag opnode> {
|
|
|
|
def i12 : T2Ii12<(outs target:$Rt), (ins t2addrmode_imm12:$addr), iii,
|
2010-11-30 06:44:32 +08:00
|
|
|
opc, ".w\t$Rt, $addr",
|
2011-08-12 04:40:40 +08:00
|
|
|
[(set target:$Rt, (opnode t2addrmode_imm12:$addr))]> {
|
2011-09-08 04:58:57 +08:00
|
|
|
bits<4> Rt;
|
|
|
|
bits<17> addr;
|
|
|
|
let Inst{31-25} = 0b1111100;
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{24} = signed;
|
|
|
|
let Inst{23} = 1;
|
|
|
|
let Inst{22-21} = opcod;
|
|
|
|
let Inst{20} = 1; // load
|
2010-12-01 06:45:47 +08:00
|
|
|
let Inst{19-16} = addr{16-13}; // Rn
|
2011-09-08 04:58:57 +08:00
|
|
|
let Inst{15-12} = Rt;
|
2010-12-01 06:45:47 +08:00
|
|
|
let Inst{11-0} = addr{11-0}; // imm
|
2013-06-18 16:03:06 +08:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeT2LoadImm12";
|
2009-12-16 01:24:14 +08:00
|
|
|
}
|
2011-09-08 04:58:57 +08:00
|
|
|
def i8 : T2Ii8 <(outs target:$Rt), (ins t2addrmode_negimm8:$addr), iii,
|
2010-11-30 06:44:32 +08:00
|
|
|
opc, "\t$Rt, $addr",
|
2011-09-08 04:58:57 +08:00
|
|
|
[(set target:$Rt, (opnode t2addrmode_negimm8:$addr))]> {
|
|
|
|
bits<4> Rt;
|
|
|
|
bits<13> addr;
|
2009-12-16 01:24:14 +08: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-08 04:58:57 +08:00
|
|
|
let Inst{19-16} = addr{12-9}; // Rn
|
|
|
|
let Inst{15-12} = Rt;
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{11} = 1;
|
|
|
|
// Offset: index==TRUE, wback==FALSE
|
|
|
|
let Inst{10} = 1; // The P bit.
|
2010-11-30 06:44:32 +08:00
|
|
|
let Inst{9} = addr{8}; // U
|
2011-09-08 04:58:57 +08:00
|
|
|
let Inst{8} = 0; // The W bit.
|
2010-11-30 06:44:32 +08:00
|
|
|
let Inst{7-0} = addr{7-0}; // imm
|
2013-06-18 16:03:06 +08:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeT2LoadImm8";
|
2009-12-16 01:24:14 +08:00
|
|
|
}
|
2011-08-12 04:40:40 +08:00
|
|
|
def s : T2Iso <(outs target:$Rt), (ins t2addrmode_so_reg:$addr), iis,
|
2010-11-30 06:44:32 +08:00
|
|
|
opc, ".w\t$Rt, $addr",
|
2011-08-12 04:40:40 +08:00
|
|
|
[(set target:$Rt, (opnode t2addrmode_so_reg:$addr))]> {
|
2009-12-16 01:24:14 +08: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-03 07:05:38 +08:00
|
|
|
|
2010-11-30 06:44:32 +08:00
|
|
|
bits<4> Rt;
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{15-12} = Rt;
|
2010-12-03 07:05:38 +08:00
|
|
|
|
2010-11-30 06:44:32 +08: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-10 04:55:18 +08:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeT2LoadShift";
|
2009-12-16 01:24:14 +08:00
|
|
|
}
|
2010-11-03 13:14:24 +08:00
|
|
|
|
2012-01-19 06:04:42 +08:00
|
|
|
// pci variant is very similar to i12, but supports negative offsets
|
|
|
|
// from the PC.
|
2011-08-12 04:40:40 +08:00
|
|
|
def pci : T2Ipc <(outs target:$Rt), (ins t2ldrlabel:$addr), iii,
|
2011-02-09 06:39:40 +08:00
|
|
|
opc, ".w\t$Rt, $addr",
|
2011-08-12 04:40:40 +08:00
|
|
|
[(set target:$Rt, (opnode (ARMWrapper tconstpool:$addr)))]> {
|
2011-02-09 06:39:40 +08:00
|
|
|
let isReMaterializable = 1;
|
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-25} = 0b00;
|
|
|
|
let Inst{24} = signed;
|
|
|
|
let Inst{22-21} = opcod;
|
|
|
|
let Inst{20} = 1; // load
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
2013-06-24 17:11:38 +08:00
|
|
|
|
|
|
|
bits<4> Rt;
|
2011-02-09 06:39:40 +08:00
|
|
|
let Inst{15-12} = Rt{3-0};
|
2013-06-24 17:11:38 +08:00
|
|
|
|
|
|
|
bits<13> addr;
|
|
|
|
let Inst{23} = addr{12}; // add = (U == '1')
|
2011-02-09 06:39:40 +08:00
|
|
|
let Inst{11-0} = addr{11-0};
|
2013-06-18 16:03:06 +08:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeT2LoadLabel";
|
2011-02-09 06:39:40 +08:00
|
|
|
}
|
2009-06-30 10:15:48 +08:00
|
|
|
}
|
|
|
|
|
2009-07-01 06:11:34 +08:00
|
|
|
/// T2I_st - Defines a set of (op r, {imm12|imm8|so_reg}) store patterns.
|
2010-09-30 09:08:25 +08:00
|
|
|
multiclass T2I_st<bits<2> opcod, string opc,
|
2011-08-12 04:40:40 +08:00
|
|
|
InstrItinClass iii, InstrItinClass iis, RegisterClass target,
|
|
|
|
PatFrag opnode> {
|
|
|
|
def i12 : T2Ii12<(outs), (ins target:$Rt, t2addrmode_imm12:$addr), iii,
|
2010-11-30 06:44:32 +08:00
|
|
|
opc, ".w\t$Rt, $addr",
|
2011-08-12 04:40:40 +08:00
|
|
|
[(opnode target:$Rt, t2addrmode_imm12:$addr)]> {
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0001;
|
|
|
|
let Inst{22-21} = opcod;
|
|
|
|
let Inst{20} = 0; // !load
|
2010-12-03 07:05:38 +08:00
|
|
|
|
2010-11-30 06:44:32 +08:00
|
|
|
bits<4> Rt;
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{15-12} = Rt;
|
2010-12-03 07:05:38 +08:00
|
|
|
|
2010-12-01 06:45:47 +08:00
|
|
|
bits<17> addr;
|
2011-04-13 02:48:00 +08:00
|
|
|
let addr{12} = 1; // add = TRUE
|
2010-12-01 06:45:47 +08: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-16 01:24:14 +08:00
|
|
|
}
|
2011-09-08 04:58:57 +08:00
|
|
|
def i8 : T2Ii8 <(outs), (ins target:$Rt, t2addrmode_negimm8:$addr), iii,
|
2010-11-30 06:44:32 +08:00
|
|
|
opc, "\t$Rt, $addr",
|
2011-09-08 04:58:57 +08:00
|
|
|
[(opnode target:$Rt, t2addrmode_negimm8:$addr)]> {
|
2009-12-16 01:24:14 +08: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-03 07:05:38 +08:00
|
|
|
|
2010-11-30 06:44:32 +08:00
|
|
|
bits<4> Rt;
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{15-12} = Rt;
|
2010-12-03 07:05:38 +08:00
|
|
|
|
2010-11-30 06:44:32 +08: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-16 01:24:14 +08:00
|
|
|
}
|
2011-08-12 04:40:40 +08:00
|
|
|
def s : T2Iso <(outs), (ins target:$Rt, t2addrmode_so_reg:$addr), iis,
|
2010-11-30 06:44:32 +08:00
|
|
|
opc, ".w\t$Rt, $addr",
|
2011-08-12 04:40:40 +08:00
|
|
|
[(opnode target:$Rt, t2addrmode_so_reg:$addr)]> {
|
2009-12-16 01:24:14 +08: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-03 07:05:38 +08:00
|
|
|
|
2010-11-30 06:44:32 +08:00
|
|
|
bits<4> Rt;
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{15-12} = Rt;
|
2010-12-03 07:05:38 +08:00
|
|
|
|
2010-11-30 06:44:32 +08: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-16 01:24:14 +08:00
|
|
|
}
|
2009-07-01 06:11:34 +08:00
|
|
|
}
|
|
|
|
|
2010-09-30 09:08:25 +08:00
|
|
|
/// T2I_ext_rrot - A unary operation with two forms: one whose operand is a
|
2009-07-03 09:43:10 +08:00
|
|
|
/// register and one whose operand is a register rotated by 8/16/24.
|
2011-07-28 00:47:19 +08: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-09 03:49:37 +08:00
|
|
|
[(set rGPR:$Rd, (opnode (rotr rGPR:$Rm, rot_imm:$rot)))]>,
|
|
|
|
Requires<[IsThumb2]> {
|
2011-07-28 00:47:19 +08: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-20 01:11:02 +08:00
|
|
|
|
2011-07-28 00:47:19 +08:00
|
|
|
bits<2> rot;
|
|
|
|
let Inst{5-4} = rot{1-0}; // rotate
|
2009-07-03 09:43:10 +08:00
|
|
|
}
|
|
|
|
|
2010-06-25 02:20:04 +08:00
|
|
|
// UXTB16 - Requres T2ExtractPack, does not need the .w qualifier.
|
2011-07-28 01:48:13 +08:00
|
|
|
class T2I_ext_rrot_uxtb16<bits<3> opcod, string opc, PatFrag opnode>
|
2011-08-24 01:37:32 +08: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-28 01:48:13 +08: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-05 06:24:41 +08:00
|
|
|
}
|
|
|
|
|
2010-06-25 02:20:04 +08:00
|
|
|
// SXTB16 - Requres T2ExtractPack, does not need the .w qualifier, no pattern
|
|
|
|
// supported yet.
|
2011-07-28 01:48:13 +08: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-02 05:12:19 +08:00
|
|
|
Requires<[IsThumb2, HasT2ExtractPack]> {
|
2011-07-28 01:48:13 +08: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.
llvm-svn: 97573
2010-03-03 02:14:57 +08:00
|
|
|
}
|
|
|
|
|
2010-09-30 09:08:25 +08:00
|
|
|
/// T2I_exta_rrot - A binary operation with two forms: one whose operand is a
|
2009-07-03 09:43:10 +08:00
|
|
|
/// register and one whose operand is a register rotated by 8/16/24.
|
2011-07-28 01:48:13 +08: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 09:43:10 +08:00
|
|
|
}
|
|
|
|
|
2011-07-28 01:48:13 +08: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.
llvm-svn: 97573
2010-03-03 02:14:57 +08:00
|
|
|
}
|
|
|
|
|
2009-06-27 10:26:13 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Instructions
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-06-25 07:47:58 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Miscellaneous Instructions.
|
|
|
|
//
|
|
|
|
|
2010-11-16 05:30:39 +08: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-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-16 05:30:39 +08:00
|
|
|
let Inst{26} = label{11};
|
|
|
|
let Inst{14-12} = label{10-8};
|
|
|
|
let Inst{7-0} = label{7-0};
|
|
|
|
}
|
|
|
|
|
2009-06-25 07:47:58 +08:00
|
|
|
// LEApcrel - Load a pc-relative address into a register without offending the
|
|
|
|
// assembler.
|
2010-12-14 08:36:49 +08:00
|
|
|
def t2ADR : T2PCOneRegImm<(outs rGPR:$Rd),
|
|
|
|
(ins t2adrlabel:$addr, pred:$p),
|
2013-06-07 00:35:25 +08:00
|
|
|
IIC_iALUi, "adr{$p}.w\t$Rd, $addr", []>,
|
|
|
|
Sched<[WriteALU, ReadALU]> {
|
2009-12-16 01:24:14 +08: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-15 04:46:39 +08:00
|
|
|
|
2010-12-14 08:36:49 +08: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-10 06:24:36 +08:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeT2Adr";
|
2010-12-14 06:51:08 +08:00
|
|
|
}
|
2010-12-14 08:36:49 +08:00
|
|
|
|
|
|
|
let neverHasSideEffects = 1, isReMaterializable = 1 in
|
2010-12-16 02:48:45 +08:00
|
|
|
def t2LEApcrel : t2PseudoInst<(outs rGPR:$Rd), (ins i32imm:$label, pred:$p),
|
2013-06-07 00:35:25 +08:00
|
|
|
4, IIC_iALUi, []>, Sched<[WriteALU, ReadALU]>;
|
2012-08-25 05:44:11 +08:00
|
|
|
let hasSideEffects = 1 in
|
2013-09-05 19:59:43 +08:00
|
|
|
def t2LEApcrelJT : t2PseudoInst<(outs rGPR:$Rd),
|
2010-12-16 02:48:45 +08:00
|
|
|
(ins i32imm:$label, nohash_imm:$id, pred:$p),
|
2011-07-14 07:22:26 +08:00
|
|
|
4, IIC_iALUi,
|
2013-06-07 00:35:25 +08:00
|
|
|
[]>, Sched<[WriteALU, ReadALU]>;
|
2009-06-25 07:47:58 +08:00
|
|
|
|
2010-12-09 07:30:19 +08:00
|
|
|
|
2009-06-27 10:26:13 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Load / store Instructions.
|
|
|
|
//
|
|
|
|
|
2009-06-29 15:51:04 +08:00
|
|
|
// Load
|
2010-02-28 07:47:46 +08:00
|
|
|
let canFoldAsLoad = 1, isReMaterializable = 1 in
|
2011-08-12 04:40:40 +08:00
|
|
|
defm t2LDR : T2I_ld<0, 0b10, "ldr", IIC_iLoad_i, IIC_iLoad_si, GPR,
|
2010-09-30 09:08:25 +08:00
|
|
|
UnOpFrag<(load node:$Src)>>;
|
2009-06-30 10:15:48 +08:00
|
|
|
|
|
|
|
// Loads with zero extension
|
2010-10-28 14:47:08 +08:00
|
|
|
defm t2LDRH : T2I_ld<0, 0b01, "ldrh", IIC_iLoad_bh_i, IIC_iLoad_bh_si,
|
2013-06-18 16:03:06 +08:00
|
|
|
GPR, UnOpFrag<(zextloadi16 node:$Src)>>;
|
2010-10-28 14:47:08 +08:00
|
|
|
defm t2LDRB : T2I_ld<0, 0b00, "ldrb", IIC_iLoad_bh_i, IIC_iLoad_bh_si,
|
2013-06-18 16:03:06 +08:00
|
|
|
GPR, UnOpFrag<(zextloadi8 node:$Src)>>;
|
2009-06-30 10:15:48 +08:00
|
|
|
|
|
|
|
// Loads with sign extension
|
2010-10-28 14:47:08 +08:00
|
|
|
defm t2LDRSH : T2I_ld<1, 0b01, "ldrsh", IIC_iLoad_bh_i, IIC_iLoad_bh_si,
|
2013-06-18 16:03:06 +08:00
|
|
|
GPR, UnOpFrag<(sextloadi16 node:$Src)>>;
|
2010-10-28 14:47:08 +08:00
|
|
|
defm t2LDRSB : T2I_ld<1, 0b00, "ldrsb", IIC_iLoad_bh_i, IIC_iLoad_bh_si,
|
2013-06-18 16:03:06 +08:00
|
|
|
GPR, UnOpFrag<(sextloadi8 node:$Src)>>;
|
2009-06-30 10:15:48 +08:00
|
|
|
|
2010-12-02 03:18:46 +08:00
|
|
|
let mayLoad = 1, neverHasSideEffects = 1, hasExtraDefRegAllocReq = 1 in {
|
2009-06-30 10:15:48 +08:00
|
|
|
// Load doubleword
|
2010-12-02 03:18:46 +08:00
|
|
|
def t2LDRDi8 : T2Ii8s4<1, 0, 1, (outs rGPR:$Rt, rGPR:$Rt2),
|
2009-09-27 17:46:04 +08:00
|
|
|
(ins t2addrmode_imm8s4:$addr),
|
2011-09-09 06:07:06 +08:00
|
|
|
IIC_iLoad_d_i, "ldrd", "\t$Rt, $Rt2, $addr", "", []>;
|
2010-05-19 14:07:03 +08:00
|
|
|
} // mayLoad = 1, neverHasSideEffects = 1, hasExtraDefRegAllocReq = 1
|
2009-06-30 10:15:48 +08:00
|
|
|
|
|
|
|
// zextload i1 -> zextload i8
|
|
|
|
def : T2Pat<(zextloadi1 t2addrmode_imm12:$addr),
|
|
|
|
(t2LDRBi12 t2addrmode_imm12:$addr)>;
|
2011-09-08 04:58:57 +08:00
|
|
|
def : T2Pat<(zextloadi1 t2addrmode_negimm8:$addr),
|
|
|
|
(t2LDRBi8 t2addrmode_negimm8:$addr)>;
|
2009-06-30 10:15:48 +08: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-08 04:58:57 +08:00
|
|
|
def : T2Pat<(extloadi1 t2addrmode_negimm8:$addr),
|
|
|
|
(t2LDRBi8 t2addrmode_negimm8:$addr)>;
|
2009-06-30 10:15:48 +08: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-08 04:58:57 +08:00
|
|
|
def : T2Pat<(extloadi8 t2addrmode_negimm8:$addr),
|
|
|
|
(t2LDRBi8 t2addrmode_negimm8:$addr)>;
|
2009-06-30 10:15:48 +08: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-08 04:58:57 +08:00
|
|
|
def : T2Pat<(extloadi16 t2addrmode_negimm8:$addr),
|
|
|
|
(t2LDRHi8 t2addrmode_negimm8:$addr)>;
|
2009-06-30 10:15:48 +08: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 15:51:04 +08: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
llvm-svn: 109842
2010-07-30 10:41:01 +08: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 15:28:31 +08:00
|
|
|
// Indexed loads
|
2010-11-30 08:14:31 +08:00
|
|
|
|
2010-05-19 14:07:03 +08:00
|
|
|
let mayLoad = 1, neverHasSideEffects = 1 in {
|
2011-09-08 08:39:19 +08:00
|
|
|
def t2LDR_PRE : T2Ipreldst<0, 0b10, 1, 1, (outs GPR:$Rt, GPR:$Rn_wb),
|
2013-06-18 16:12:51 +08:00
|
|
|
(ins t2addrmode_imm8_pre:$addr),
|
2010-09-30 09:08:25 +08:00
|
|
|
AddrModeT2_i8, IndexModePre, IIC_iLoad_iu,
|
2013-07-22 17:06:12 +08:00
|
|
|
"ldr", "\t$Rt, $addr!", "$addr.base = $Rn_wb", []>;
|
2009-07-02 15:28:31 +08:00
|
|
|
|
2011-09-08 08:39:19 +08:00
|
|
|
def t2LDR_POST : T2Ipostldst<0, 0b10, 1, 0, (outs GPR:$Rt, GPR:$Rn_wb),
|
2011-09-08 09:01:32 +08:00
|
|
|
(ins addr_offset_none:$Rn, t2am_imm8_offset:$offset),
|
|
|
|
AddrModeT2_i8, IndexModePost, IIC_iLoad_iu,
|
2011-09-24 05:26:40 +08:00
|
|
|
"ldr", "\t$Rt, $Rn$offset", "$Rn = $Rn_wb", []>;
|
2009-07-02 15:28:31 +08:00
|
|
|
|
2011-09-08 08:39:19 +08:00
|
|
|
def t2LDRB_PRE : T2Ipreldst<0, 0b00, 1, 1, (outs GPR:$Rt, GPR:$Rn_wb),
|
2013-06-18 16:12:51 +08:00
|
|
|
(ins t2addrmode_imm8_pre:$addr),
|
2010-09-30 09:08:25 +08:00
|
|
|
AddrModeT2_i8, IndexModePre, IIC_iLoad_bh_iu,
|
2013-07-22 17:06:12 +08:00
|
|
|
"ldrb", "\t$Rt, $addr!", "$addr.base = $Rn_wb", []>;
|
|
|
|
|
2011-09-08 08:39:19 +08:00
|
|
|
def t2LDRB_POST : T2Ipostldst<0, 0b00, 1, 0, (outs GPR:$Rt, GPR:$Rn_wb),
|
2011-09-08 09:01:32 +08:00
|
|
|
(ins addr_offset_none:$Rn, t2am_imm8_offset:$offset),
|
|
|
|
AddrModeT2_i8, IndexModePost, IIC_iLoad_bh_iu,
|
2011-09-24 05:26:40 +08:00
|
|
|
"ldrb", "\t$Rt, $Rn$offset", "$Rn = $Rn_wb", []>;
|
2009-07-02 15:28:31 +08:00
|
|
|
|
2011-09-08 08:39:19 +08:00
|
|
|
def t2LDRH_PRE : T2Ipreldst<0, 0b01, 1, 1, (outs GPR:$Rt, GPR:$Rn_wb),
|
2013-06-18 16:12:51 +08:00
|
|
|
(ins t2addrmode_imm8_pre:$addr),
|
2010-09-30 09:08:25 +08:00
|
|
|
AddrModeT2_i8, IndexModePre, IIC_iLoad_bh_iu,
|
2013-07-22 17:06:12 +08:00
|
|
|
"ldrh", "\t$Rt, $addr!", "$addr.base = $Rn_wb", []>;
|
|
|
|
|
2011-09-08 08:39:19 +08:00
|
|
|
def t2LDRH_POST : T2Ipostldst<0, 0b01, 1, 0, (outs GPR:$Rt, GPR:$Rn_wb),
|
2011-09-08 09:01:32 +08:00
|
|
|
(ins addr_offset_none:$Rn, t2am_imm8_offset:$offset),
|
|
|
|
AddrModeT2_i8, IndexModePost, IIC_iLoad_bh_iu,
|
2011-09-24 05:26:40 +08:00
|
|
|
"ldrh", "\t$Rt, $Rn$offset", "$Rn = $Rn_wb", []>;
|
2009-07-02 15:28:31 +08:00
|
|
|
|
2011-09-08 08:39:19 +08:00
|
|
|
def t2LDRSB_PRE : T2Ipreldst<1, 0b00, 1, 1, (outs GPR:$Rt, GPR:$Rn_wb),
|
2013-06-18 16:12:51 +08:00
|
|
|
(ins t2addrmode_imm8_pre:$addr),
|
2010-09-30 09:08:25 +08:00
|
|
|
AddrModeT2_i8, IndexModePre, IIC_iLoad_bh_iu,
|
2011-09-08 08:39:19 +08:00
|
|
|
"ldrsb", "\t$Rt, $addr!", "$addr.base = $Rn_wb",
|
2013-07-22 17:06:12 +08:00
|
|
|
[]>;
|
|
|
|
|
2011-09-08 08:39:19 +08:00
|
|
|
def t2LDRSB_POST : T2Ipostldst<1, 0b00, 1, 0, (outs GPR:$Rt, GPR:$Rn_wb),
|
2011-09-08 09:01:32 +08:00
|
|
|
(ins addr_offset_none:$Rn, t2am_imm8_offset:$offset),
|
|
|
|
AddrModeT2_i8, IndexModePost, IIC_iLoad_bh_iu,
|
2011-09-24 05:26:40 +08:00
|
|
|
"ldrsb", "\t$Rt, $Rn$offset", "$Rn = $Rn_wb", []>;
|
2009-07-03 07:16:11 +08:00
|
|
|
|
2011-09-08 08:39:19 +08:00
|
|
|
def t2LDRSH_PRE : T2Ipreldst<1, 0b01, 1, 1, (outs GPR:$Rt, GPR:$Rn_wb),
|
2013-06-18 16:12:51 +08:00
|
|
|
(ins t2addrmode_imm8_pre:$addr),
|
2010-09-30 09:08:25 +08:00
|
|
|
AddrModeT2_i8, IndexModePre, IIC_iLoad_bh_iu,
|
2011-09-08 08:39:19 +08:00
|
|
|
"ldrsh", "\t$Rt, $addr!", "$addr.base = $Rn_wb",
|
2013-07-22 17:06:12 +08:00
|
|
|
[]>;
|
|
|
|
|
2011-09-08 08:39:19 +08:00
|
|
|
def t2LDRSH_POST : T2Ipostldst<1, 0b01, 1, 0, (outs GPR:$Rt, GPR:$Rn_wb),
|
2011-09-08 09:01:32 +08:00
|
|
|
(ins addr_offset_none:$Rn, t2am_imm8_offset:$offset),
|
|
|
|
AddrModeT2_i8, IndexModePost, IIC_iLoad_bh_iu,
|
2011-09-24 05:26:40 +08:00
|
|
|
"ldrsh", "\t$Rt, $Rn$offset", "$Rn = $Rn_wb", []>;
|
2010-11-20 01:11:02 +08:00
|
|
|
} // mayLoad = 1, neverHasSideEffects = 1
|
2009-07-03 07:16:11 +08:00
|
|
|
|
2011-09-08 07:39:14 +08:00
|
|
|
// LDRT, LDRBT, LDRHT, LDRSBT, LDRSHT all have offset mode (PUW=0b110).
|
2010-03-04 02:45:36 +08:00
|
|
|
// Ref: A8.6.57 LDR (immediate, Thumb) Encoding T4
|
2010-09-30 09:08:25 +08:00
|
|
|
class T2IldT<bit signed, bits<2> type, string opc, InstrItinClass ii>
|
2011-09-08 07:39:14 +08:00
|
|
|
: T2Ii8<(outs rGPR:$Rt), (ins t2addrmode_posimm8:$addr), ii, opc,
|
2010-12-01 02:38:28 +08:00
|
|
|
"\t$Rt, $addr", []> {
|
2011-09-08 07:39:14 +08:00
|
|
|
bits<4> Rt;
|
|
|
|
bits<13> addr;
|
2010-03-04 02:45:36 +08: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-08 07:39:14 +08:00
|
|
|
let Inst{19-16} = addr{12-9};
|
|
|
|
let Inst{15-12} = Rt;
|
2010-03-04 02:45:36 +08:00
|
|
|
let Inst{11} = 1;
|
|
|
|
let Inst{10-8} = 0b110; // PUW.
|
2011-09-08 07:39:14 +08:00
|
|
|
let Inst{7-0} = addr{7-0};
|
2013-06-18 16:03:06 +08:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeT2LoadT";
|
2010-03-04 02:45:36 +08:00
|
|
|
}
|
|
|
|
|
2010-09-30 09:08:25 +08: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-04 02:45:36 +08:00
|
|
|
|
2013-08-29 00:39:20 +08:00
|
|
|
class T2Ildacq<bits<4> bits23_20, bits<2> bit54, dag oops, dag iops,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
|
|
|
: Thumb2I<oops, iops, AddrModeNone, 4, NoItinerary,
|
|
|
|
opc, asm, "", pattern>, Requires<[IsThumb, HasV8]> {
|
2013-08-28 01:38:16 +08:00
|
|
|
bits<4> Rt;
|
|
|
|
bits<4> addr;
|
|
|
|
|
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-24} = 0b000;
|
|
|
|
let Inst{23-20} = bits23_20;
|
|
|
|
let Inst{11-6} = 0b111110;
|
|
|
|
let Inst{5-4} = bit54;
|
|
|
|
let Inst{3-0} = 0b1111;
|
|
|
|
|
|
|
|
// Encode instruction operands
|
|
|
|
let Inst{19-16} = addr;
|
|
|
|
let Inst{15-12} = Rt;
|
|
|
|
}
|
|
|
|
|
2013-08-29 00:39:20 +08:00
|
|
|
def t2LDA : T2Ildacq<0b1101, 0b10, (outs rGPR:$Rt),
|
|
|
|
(ins addr_offset_none:$addr), "lda", "\t$Rt, $addr", []>;
|
|
|
|
def t2LDAB : T2Ildacq<0b1101, 0b00, (outs rGPR:$Rt),
|
|
|
|
(ins addr_offset_none:$addr), "ldab", "\t$Rt, $addr", []>;
|
|
|
|
def t2LDAH : T2Ildacq<0b1101, 0b01, (outs rGPR:$Rt),
|
|
|
|
(ins addr_offset_none:$addr), "ldah", "\t$Rt, $addr", []>;
|
2013-08-28 01:38:16 +08:00
|
|
|
|
2009-07-01 06:11:34 +08:00
|
|
|
// Store
|
2011-08-12 04:40:40 +08:00
|
|
|
defm t2STR :T2I_st<0b10,"str", IIC_iStore_i, IIC_iStore_si, GPR,
|
2010-09-30 09:08:25 +08:00
|
|
|
BinOpFrag<(store node:$LHS, node:$RHS)>>;
|
2010-10-28 14:47:08 +08:00
|
|
|
defm t2STRB:T2I_st<0b00,"strb", IIC_iStore_bh_i, IIC_iStore_bh_si,
|
2011-08-12 04:40:40 +08:00
|
|
|
rGPR, BinOpFrag<(truncstorei8 node:$LHS, node:$RHS)>>;
|
2010-10-28 14:47:08 +08:00
|
|
|
defm t2STRH:T2I_st<0b01,"strh", IIC_iStore_bh_i, IIC_iStore_bh_si,
|
2011-08-12 04:40:40 +08:00
|
|
|
rGPR, BinOpFrag<(truncstorei16 node:$LHS, node:$RHS)>>;
|
2009-07-01 06:11:34 +08:00
|
|
|
|
2009-07-01 06:50:01 +08:00
|
|
|
// Store doubleword
|
2011-10-16 14:38:06 +08:00
|
|
|
let mayStore = 1, neverHasSideEffects = 1, hasExtraSrcRegAllocReq = 1 in
|
2009-12-16 01:24:14 +08:00
|
|
|
def t2STRDi8 : T2Ii8s4<1, 0, 0, (outs),
|
2014-04-04 16:14:13 +08:00
|
|
|
(ins rGPR:$Rt, rGPR:$Rt2, t2addrmode_imm8s4:$addr),
|
2011-09-09 06:07:06 +08:00
|
|
|
IIC_iStore_d_r, "strd", "\t$Rt, $Rt2, $addr", "", []>;
|
2009-07-01 06:50:01 +08:00
|
|
|
|
2009-07-03 08:06:39 +08:00
|
|
|
// Indexed stores
|
2011-10-16 14:38:10 +08:00
|
|
|
|
|
|
|
let mayStore = 1, neverHasSideEffects = 1 in {
|
2011-09-08 08:39:19 +08:00
|
|
|
def t2STR_PRE : T2Ipreldst<0, 0b10, 0, 1, (outs GPRnopc:$Rn_wb),
|
2013-06-18 16:12:51 +08:00
|
|
|
(ins GPRnopc:$Rt, t2addrmode_imm8_pre:$addr),
|
2010-09-30 09:08:25 +08:00
|
|
|
AddrModeT2_i8, IndexModePre, IIC_iStore_iu,
|
2011-09-17 05:55:56 +08:00
|
|
|
"str", "\t$Rt, $addr!",
|
2013-07-22 17:06:12 +08:00
|
|
|
"$addr.base = $Rn_wb,@earlyclobber $Rn_wb", []>;
|
|
|
|
|
2011-09-17 05:55:56 +08:00
|
|
|
def t2STRH_PRE : T2Ipreldst<0, 0b01, 0, 1, (outs GPRnopc:$Rn_wb),
|
2013-06-18 16:12:51 +08:00
|
|
|
(ins rGPR:$Rt, t2addrmode_imm8_pre:$addr),
|
2011-09-17 05:55:56 +08:00
|
|
|
AddrModeT2_i8, IndexModePre, IIC_iStore_iu,
|
|
|
|
"strh", "\t$Rt, $addr!",
|
2013-07-22 17:06:12 +08:00
|
|
|
"$addr.base = $Rn_wb,@earlyclobber $Rn_wb", []>;
|
2011-09-17 05:55:56 +08:00
|
|
|
|
|
|
|
def t2STRB_PRE : T2Ipreldst<0, 0b00, 0, 1, (outs GPRnopc:$Rn_wb),
|
2013-06-18 16:12:51 +08:00
|
|
|
(ins rGPR:$Rt, t2addrmode_imm8_pre:$addr),
|
2011-09-17 05:55:56 +08:00
|
|
|
AddrModeT2_i8, IndexModePre, IIC_iStore_bh_iu,
|
|
|
|
"strb", "\t$Rt, $addr!",
|
2013-07-22 17:06:12 +08:00
|
|
|
"$addr.base = $Rn_wb,@earlyclobber $Rn_wb", []>;
|
2011-10-18 11:17:34 +08:00
|
|
|
} // mayStore = 1, neverHasSideEffects = 1
|
2009-07-03 08:06:39 +08:00
|
|
|
|
2011-09-08 08:39:19 +08:00
|
|
|
def t2STR_POST : T2Ipostldst<0, 0b10, 0, 0, (outs GPRnopc:$Rn_wb),
|
2011-12-14 05:10:25 +08:00
|
|
|
(ins GPRnopc:$Rt, addr_offset_none:$Rn,
|
2011-09-17 05:09:00 +08:00
|
|
|
t2am_imm8_offset:$offset),
|
2010-09-30 09:08:25 +08:00
|
|
|
AddrModeT2_i8, IndexModePost, IIC_iStore_iu,
|
2011-09-24 05:26:40 +08:00
|
|
|
"str", "\t$Rt, $Rn$offset",
|
2011-09-08 08:39:19 +08:00
|
|
|
"$Rn = $Rn_wb,@earlyclobber $Rn_wb",
|
|
|
|
[(set GPRnopc:$Rn_wb,
|
2011-12-14 05:10:25 +08:00
|
|
|
(post_store GPRnopc:$Rt, addr_offset_none:$Rn,
|
2011-09-17 05:09:00 +08:00
|
|
|
t2am_imm8_offset:$offset))]>;
|
2009-07-03 08:06:39 +08:00
|
|
|
|
2011-09-08 08:39:19 +08:00
|
|
|
def t2STRH_POST : T2Ipostldst<0, 0b01, 0, 0, (outs GPRnopc:$Rn_wb),
|
2011-09-17 05:09:00 +08:00
|
|
|
(ins rGPR:$Rt, addr_offset_none:$Rn,
|
|
|
|
t2am_imm8_offset:$offset),
|
2010-09-30 09:08:25 +08:00
|
|
|
AddrModeT2_i8, IndexModePost, IIC_iStore_bh_iu,
|
2011-09-24 05:26:40 +08:00
|
|
|
"strh", "\t$Rt, $Rn$offset",
|
2011-09-08 08:39:19 +08:00
|
|
|
"$Rn = $Rn_wb,@earlyclobber $Rn_wb",
|
|
|
|
[(set GPRnopc:$Rn_wb,
|
2011-09-17 05:09:00 +08:00
|
|
|
(post_truncsti16 rGPR:$Rt, addr_offset_none:$Rn,
|
|
|
|
t2am_imm8_offset:$offset))]>;
|
2009-07-03 08:06:39 +08:00
|
|
|
|
2011-09-08 08:39:19 +08:00
|
|
|
def t2STRB_POST : T2Ipostldst<0, 0b00, 0, 0, (outs GPRnopc:$Rn_wb),
|
2011-09-17 05:09:00 +08:00
|
|
|
(ins rGPR:$Rt, addr_offset_none:$Rn,
|
|
|
|
t2am_imm8_offset:$offset),
|
2010-09-30 09:08:25 +08:00
|
|
|
AddrModeT2_i8, IndexModePost, IIC_iStore_bh_iu,
|
2011-09-24 05:26:40 +08:00
|
|
|
"strb", "\t$Rt, $Rn$offset",
|
2011-09-08 08:39:19 +08:00
|
|
|
"$Rn = $Rn_wb,@earlyclobber $Rn_wb",
|
|
|
|
[(set GPRnopc:$Rn_wb,
|
2011-09-17 05:09:00 +08:00
|
|
|
(post_truncsti8 rGPR:$Rt, addr_offset_none:$Rn,
|
|
|
|
t2am_imm8_offset:$offset))]>;
|
2009-07-03 08:06:39 +08:00
|
|
|
|
2011-09-17 05:55:56 +08: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-04 02:45:36 +08: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 09:08:25 +08:00
|
|
|
class T2IstT<bits<2> type, string opc, InstrItinClass ii>
|
2011-04-14 05:04:32 +08:00
|
|
|
: T2Ii8<(outs rGPR:$Rt), (ins t2addrmode_imm8:$addr), ii, opc,
|
2010-12-01 02:38:28 +08:00
|
|
|
"\t$Rt, $addr", []> {
|
2010-03-04 02:45:36 +08: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-03 07:05:38 +08:00
|
|
|
|
2010-12-01 02:38:28 +08:00
|
|
|
bits<4> Rt;
|
|
|
|
bits<13> addr;
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{15-12} = Rt;
|
2010-12-01 02:38:28 +08:00
|
|
|
let Inst{19-16} = addr{12-9};
|
|
|
|
let Inst{7-0} = addr{7-0};
|
2010-03-04 02:45:36 +08:00
|
|
|
}
|
|
|
|
|
2010-09-30 09:08:25 +08: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 08:01:13 +08:00
|
|
|
|
2010-03-11 09:13:36 +08:00
|
|
|
// ldrd / strd pre / post variants
|
|
|
|
// For disassembly only.
|
|
|
|
|
2011-09-09 06:07:06 +08:00
|
|
|
def t2LDRD_PRE : T2Ii8s4<1, 1, 1, (outs rGPR:$Rt, rGPR:$Rt2, GPR:$wb),
|
2013-06-18 16:12:51 +08:00
|
|
|
(ins t2addrmode_imm8s4_pre:$addr), IIC_iLoad_d_ru,
|
2011-09-09 06:07:06 +08:00
|
|
|
"ldrd", "\t$Rt, $Rt2, $addr!", "$addr.base = $wb", []> {
|
|
|
|
let DecoderMethod = "DecodeT2LDRDPreInstruction";
|
|
|
|
}
|
2010-03-11 09:13:36 +08:00
|
|
|
|
2011-09-09 06:07:06 +08: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-14 04:46:26 +08:00
|
|
|
IIC_iLoad_d_ru, "ldrd", "\t$Rt, $Rt2, $addr$imm",
|
2011-09-09 06:07:06 +08:00
|
|
|
"$addr.base = $wb", []>;
|
2010-03-11 09:13:36 +08:00
|
|
|
|
2011-09-09 06:07:06 +08:00
|
|
|
def t2STRD_PRE : T2Ii8s4<1, 1, 0, (outs GPR:$wb),
|
2013-06-18 16:12:51 +08:00
|
|
|
(ins rGPR:$Rt, rGPR:$Rt2, t2addrmode_imm8s4_pre:$addr),
|
2011-09-09 06:07:06 +08:00
|
|
|
IIC_iStore_d_ru, "strd", "\t$Rt, $Rt2, $addr!",
|
|
|
|
"$addr.base = $wb", []> {
|
|
|
|
let DecoderMethod = "DecodeT2STRDPreInstruction";
|
|
|
|
}
|
2010-03-11 09:13:36 +08:00
|
|
|
|
2011-09-09 06:07:06 +08: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-14 04:46:26 +08:00
|
|
|
IIC_iStore_d_ru, "strd", "\t$Rt, $Rt2, $addr$imm",
|
2011-09-09 06:07:06 +08:00
|
|
|
"$addr.base = $wb", []>;
|
2009-07-03 08:18:36 +08:00
|
|
|
|
2013-08-29 00:39:20 +08:00
|
|
|
class T2Istrrel<bits<2> bit54, dag oops, dag iops,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
|
|
|
: Thumb2I<oops, iops, AddrModeNone, 4, NoItinerary, opc,
|
|
|
|
asm, "", pattern>, Requires<[IsThumb, HasV8]> {
|
2013-08-28 01:38:16 +08:00
|
|
|
bits<4> Rt;
|
|
|
|
bits<4> addr;
|
|
|
|
|
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-20} = 0b0001100;
|
|
|
|
let Inst{11-6} = 0b111110;
|
|
|
|
let Inst{5-4} = bit54;
|
|
|
|
let Inst{3-0} = 0b1111;
|
|
|
|
|
|
|
|
// Encode instruction operands
|
|
|
|
let Inst{19-16} = addr;
|
|
|
|
let Inst{15-12} = Rt;
|
|
|
|
}
|
|
|
|
|
2013-08-29 00:39:20 +08:00
|
|
|
def t2STL : T2Istrrel<0b10, (outs), (ins rGPR:$Rt, addr_offset_none:$addr),
|
2013-08-28 01:38:16 +08:00
|
|
|
"stl", "\t$Rt, $addr", []>;
|
2013-08-29 00:39:20 +08:00
|
|
|
def t2STLB : T2Istrrel<0b00, (outs), (ins rGPR:$Rt, addr_offset_none:$addr),
|
2013-08-28 01:38:16 +08:00
|
|
|
"stlb", "\t$Rt, $addr", []>;
|
2013-08-29 00:39:20 +08:00
|
|
|
def t2STLH : T2Istrrel<0b01, (outs), (ins rGPR:$Rt, addr_offset_none:$addr),
|
2013-08-28 01:38:16 +08:00
|
|
|
"stlh", "\t$Rt, $addr", []>;
|
|
|
|
|
2010-03-05 01:40:44 +08:00
|
|
|
// T2Ipl (Preload Data/Instruction) signals the memory system of possible future
|
2011-10-27 06:22:01 +08:00
|
|
|
// data/instruction access.
|
2010-11-03 14:34:55 +08:00
|
|
|
// instr_write is inverted for Thumb mode: (prefetch 3) -> (preload 0),
|
|
|
|
// (prefetch 1) -> (preload 2), (prefetch 2) -> (preload 1).
|
2010-11-04 13:19:35 +08:00
|
|
|
multiclass T2Ipl<bits<1> write, bits<1> instr, string opc> {
|
2010-03-05 01:40:44 +08:00
|
|
|
|
2010-11-03 14:34:55 +08:00
|
|
|
def i12 : T2Ii12<(outs), (ins t2addrmode_imm12:$addr), IIC_Preload, opc,
|
2010-11-03 13:14:24 +08:00
|
|
|
"\t$addr",
|
2013-06-07 02:06:30 +08:00
|
|
|
[(ARMPreload t2addrmode_imm12:$addr, (i32 write), (i32 instr))]>,
|
|
|
|
Sched<[WritePreLd]> {
|
2010-03-05 01:40:44 +08:00
|
|
|
let Inst{31-25} = 0b1111100;
|
2010-11-04 13:19:35 +08:00
|
|
|
let Inst{24} = instr;
|
2013-06-24 17:11:38 +08:00
|
|
|
let Inst{23} = 1;
|
2010-03-05 01:40:44 +08:00
|
|
|
let Inst{22} = 0;
|
2010-11-04 13:19:35 +08:00
|
|
|
let Inst{21} = write;
|
2010-03-05 01:40:44 +08:00
|
|
|
let Inst{20} = 1;
|
|
|
|
let Inst{15-12} = 0b1111;
|
2010-12-03 07:05:38 +08:00
|
|
|
|
2010-12-01 06:45:47 +08:00
|
|
|
bits<17> addr;
|
|
|
|
let Inst{19-16} = addr{16-13}; // Rn
|
2010-12-01 03:19:31 +08:00
|
|
|
let Inst{11-0} = addr{11-0}; // imm12
|
2013-06-24 17:11:38 +08:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeT2LoadImm12";
|
2010-03-05 01:40:44 +08:00
|
|
|
}
|
|
|
|
|
2011-09-08 04:58:57 +08:00
|
|
|
def i8 : T2Ii8<(outs), (ins t2addrmode_negimm8:$addr), IIC_Preload, opc,
|
2010-11-03 13:14:24 +08:00
|
|
|
"\t$addr",
|
2013-06-07 02:06:30 +08:00
|
|
|
[(ARMPreload t2addrmode_negimm8:$addr, (i32 write), (i32 instr))]>,
|
|
|
|
Sched<[WritePreLd]> {
|
2010-03-05 01:40:44 +08:00
|
|
|
let Inst{31-25} = 0b1111100;
|
2010-11-04 13:19:35 +08:00
|
|
|
let Inst{24} = instr;
|
2010-03-05 01:40:44 +08:00
|
|
|
let Inst{23} = 0; // U = 0
|
|
|
|
let Inst{22} = 0;
|
2010-11-04 13:19:35 +08:00
|
|
|
let Inst{21} = write;
|
2010-03-05 01:40:44 +08:00
|
|
|
let Inst{20} = 1;
|
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
let Inst{11-8} = 0b1100;
|
2010-12-03 07:05:38 +08:00
|
|
|
|
2010-12-01 03:19:31 +08:00
|
|
|
bits<13> addr;
|
|
|
|
let Inst{19-16} = addr{12-9}; // Rn
|
|
|
|
let Inst{7-0} = addr{7-0}; // imm8
|
2013-06-24 17:11:38 +08:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeT2LoadImm8";
|
2010-03-05 01:40:44 +08:00
|
|
|
}
|
|
|
|
|
2010-11-03 14:34:55 +08:00
|
|
|
def s : T2Iso<(outs), (ins t2addrmode_so_reg:$addr), IIC_Preload, opc,
|
2010-11-03 13:14:24 +08:00
|
|
|
"\t$addr",
|
2013-06-07 02:06:30 +08:00
|
|
|
[(ARMPreload t2addrmode_so_reg:$addr, (i32 write), (i32 instr))]>,
|
|
|
|
Sched<[WritePreLd]> {
|
2010-03-05 01:40:44 +08:00
|
|
|
let Inst{31-25} = 0b1111100;
|
2010-11-04 13:19:35 +08:00
|
|
|
let Inst{24} = instr;
|
2010-03-05 01:40:44 +08:00
|
|
|
let Inst{23} = 0; // add = TRUE for T1
|
|
|
|
let Inst{22} = 0;
|
2010-11-04 13:19:35 +08:00
|
|
|
let Inst{21} = write;
|
2010-03-05 01:40:44 +08:00
|
|
|
let Inst{20} = 1;
|
|
|
|
let Inst{15-12} = 0b1111;
|
2013-06-24 17:11:38 +08:00
|
|
|
let Inst{11-6} = 0b000000;
|
2010-12-03 07:05:38 +08:00
|
|
|
|
2010-12-01 03:19:31 +08: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-10 04:55:18 +08:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeT2LoadShift";
|
2010-03-05 01:40:44 +08:00
|
|
|
}
|
2013-08-07 00:07:46 +08:00
|
|
|
}
|
2013-06-24 17:11:38 +08:00
|
|
|
|
2013-08-07 00:07:46 +08: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]>;
|
2013-06-24 17:11:38 +08:00
|
|
|
|
2013-08-07 00:07:46 +08:00
|
|
|
// pci variant is very similar to i12, but supports negative offsets
|
|
|
|
// from the PC. Only PLD and PLI have pci variants (not PLDW)
|
|
|
|
class T2Iplpci<bits<1> inst, string opc> : T2Iso<(outs), (ins t2ldrlabel:$addr),
|
2014-04-04 07:43:18 +08:00
|
|
|
IIC_Preload, opc, "\t$addr",
|
2013-08-07 00:07:46 +08:00
|
|
|
[(ARMPreload (ARMWrapper tconstpool:$addr),
|
|
|
|
(i32 0), (i32 inst))]>, Sched<[WritePreLd]> {
|
|
|
|
let Inst{31-25} = 0b1111100;
|
|
|
|
let Inst{24} = inst;
|
|
|
|
let Inst{22-20} = 0b001;
|
|
|
|
let Inst{19-16} = 0b1111;
|
|
|
|
let Inst{15-12} = 0b1111;
|
2013-06-24 17:11:38 +08:00
|
|
|
|
2013-08-07 00:07:46 +08:00
|
|
|
bits<13> addr;
|
|
|
|
let Inst{23} = addr{12}; // add = (U == '1')
|
|
|
|
let Inst{11-0} = addr{11-0}; // imm12
|
|
|
|
|
|
|
|
let DecoderMethod = "DecodeT2LoadLabel";
|
2010-03-05 01:40:44 +08:00
|
|
|
}
|
|
|
|
|
2013-08-07 00:07:46 +08:00
|
|
|
def t2PLDpci : T2Iplpci<0, "pld">, Requires<[IsThumb2]>;
|
|
|
|
def t2PLIpci : T2Iplpci<1, "pli">, Requires<[IsThumb2,HasV7]>;
|
2010-03-05 01:40:44 +08:00
|
|
|
|
2009-07-03 08:18:36 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Load / store multiple Instructions.
|
|
|
|
//
|
|
|
|
|
2011-09-13 05:28:46 +08:00
|
|
|
multiclass thumb2_ld_mult<string asm, InstrItinClass itin,
|
2010-11-13 17:09:38 +08:00
|
|
|
InstrItinClass itin_upd, bit L_bit> {
|
2010-11-16 09:16:36 +08:00
|
|
|
def IA :
|
2010-11-13 17:09:38 +08:00
|
|
|
T2XI<(outs), (ins GPR:$Rn, pred:$p, reglist:$regs, variable_ops),
|
2011-09-08 00:22:42 +08:00
|
|
|
itin, !strconcat(asm, "${p}.w\t$Rn, $regs"), []> {
|
2010-11-13 17:09:38 +08:00
|
|
|
bits<4> Rn;
|
|
|
|
bits<16> regs;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-11-13 17:09:38 +08: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-10-25 01:16:24 +08:00
|
|
|
let Inst{15-0} = regs;
|
2010-11-13 17:09:38 +08:00
|
|
|
}
|
2010-11-16 09:16:36 +08:00
|
|
|
def IA_UPD :
|
2010-11-13 17:09:38 +08:00
|
|
|
T2XIt<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, reglist:$regs, variable_ops),
|
2011-09-08 00:22:42 +08:00
|
|
|
itin_upd, !strconcat(asm, "${p}.w\t$Rn!, $regs"), "$Rn = $wb", []> {
|
2010-11-13 17:09:38 +08:00
|
|
|
bits<4> Rn;
|
|
|
|
bits<16> regs;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-11-13 17:09:38 +08: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-10-25 01:16:24 +08:00
|
|
|
let Inst{15-0} = regs;
|
2010-11-13 17:09:38 +08:00
|
|
|
}
|
2010-11-16 09:16:36 +08:00
|
|
|
def DB :
|
2010-11-13 17:09:38 +08:00
|
|
|
T2XI<(outs), (ins GPR:$Rn, pred:$p, reglist:$regs, variable_ops),
|
2011-09-08 02:39:47 +08:00
|
|
|
itin, !strconcat(asm, "db${p}\t$Rn, $regs"), []> {
|
2010-11-13 17:09:38 +08: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-10-25 01:16:24 +08:00
|
|
|
let Inst{15-0} = regs;
|
2010-11-13 17:09:38 +08:00
|
|
|
}
|
2010-11-16 09:16:36 +08:00
|
|
|
def DB_UPD :
|
2010-11-13 17:09:38 +08:00
|
|
|
T2XIt<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, reglist:$regs, variable_ops),
|
2011-09-08 02:39:47 +08:00
|
|
|
itin_upd, !strconcat(asm, "db${p}\t$Rn!, $regs"), "$Rn = $wb", []> {
|
2010-11-13 17:09:38 +08: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-10-25 01:16:24 +08:00
|
|
|
let Inst{15-0} = regs;
|
2010-11-13 17:09:38 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-13 19:20:05 +08:00
|
|
|
let neverHasSideEffects = 1 in {
|
2010-11-13 18:57:02 +08:00
|
|
|
|
|
|
|
let mayLoad = 1, hasExtraDefRegAllocReq = 1 in
|
2011-09-13 05:28:46 +08: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 18:57:02 +08:00
|
|
|
|
|
|
|
let mayStore = 1, hasExtraSrcRegAllocReq = 1 in
|
2011-09-13 05:28:46 +08:00
|
|
|
defm t2STM : thumb2_st_mult<"stm", IIC_iStore_m, IIC_iStore_mu, 0>;
|
2010-11-13 18:57:02 +08:00
|
|
|
|
|
|
|
} // neverHasSideEffects
|
|
|
|
|
2009-07-03 08:18:36 +08:00
|
|
|
|
2009-06-18 02:13:58 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Move Instructions.
|
|
|
|
//
|
|
|
|
|
2009-06-24 01:48:47 +08:00
|
|
|
let neverHasSideEffects = 1 in
|
2011-09-10 08:15:36 +08:00
|
|
|
def t2MOVr : T2sTwoReg<(outs GPRnopc:$Rd), (ins GPR:$Rm), IIC_iMOVr,
|
2013-06-07 00:35:25 +08:00
|
|
|
"mov", ".w\t$Rd, $Rm", []>, Sched<[WriteALU]> {
|
2009-12-16 01:24:14 +08: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-10-19 01:09:35 +08:00
|
|
|
def : t2InstAlias<"mov${p}.w $Rd, $Rm", (t2MOVr GPRnopc:$Rd, GPR:$Rm,
|
|
|
|
pred:$p, zero_reg)>;
|
2011-09-10 08:15:36 +08: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-24 01:48:47 +08:00
|
|
|
|
2009-09-28 17:14:39 +08:00
|
|
|
// AddedComplexity to ensure isel tries t2MOVi before t2MOVi16.
|
2010-11-18 04:13:28 +08:00
|
|
|
let isReMaterializable = 1, isAsCheapAsAMove = 1, isMoveImm = 1,
|
|
|
|
AddedComplexity = 1 in
|
2010-11-16 08:29:56 +08:00
|
|
|
def t2MOVi : T2sOneRegImm<(outs rGPR:$Rd), (ins t2_so_imm:$imm), IIC_iMOVi,
|
|
|
|
"mov", ".w\t$Rd, $imm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, t2_so_imm:$imm)]>, Sched<[WriteALU]> {
|
2009-12-16 01:24:14 +08: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-27 00:10:07 +08:00
|
|
|
|
2011-09-10 08:15:36 +08: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-28 07:54:06 +08:00
|
|
|
|
2010-11-18 04:13:28 +08:00
|
|
|
let isReMaterializable = 1, isAsCheapAsAMove = 1, isMoveImm = 1 in
|
2011-07-20 03:13:28 +08:00
|
|
|
def t2MOVi16 : T2I<(outs rGPR:$Rd), (ins imm0_65535_expr:$imm), IIC_iMOVi,
|
2010-11-16 08:29:56 +08:00
|
|
|
"movw", "\t$Rd, $imm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, imm0_65535:$imm)]>, Sched<[WriteALU]> {
|
2009-12-16 01:24:14 +08: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-20 01:11:02 +08:00
|
|
|
|
2010-11-16 08:29:56 +08:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<16> imm;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-16 08:29:56 +08: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};
|
2011-10-05 06:44:48 +08:00
|
|
|
let DecoderMethod = "DecodeT2MOVTWInstruction";
|
2009-12-16 01:24:14 +08:00
|
|
|
}
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2014-04-04 07:43:18 +08:00
|
|
|
def : t2InstAlias<"mov${p} $Rd, $imm",
|
2013-08-21 21:14:58 +08:00
|
|
|
(t2MOVi16 rGPR:$Rd, imm256_65535_expr:$imm, pred:$p)>;
|
|
|
|
|
2011-01-22 02:55:51 +08:00
|
|
|
def t2MOVi16_ga_pcrel : PseudoInst<(outs rGPR:$Rd),
|
2011-01-17 16:03:18 +08:00
|
|
|
(ins i32imm:$addr, pclabel:$id), IIC_iMOVi, []>;
|
|
|
|
|
|
|
|
let Constraints = "$src = $Rd" in {
|
2011-01-13 15:58:56 +08:00
|
|
|
def t2MOVTi16 : T2I<(outs rGPR:$Rd),
|
2011-07-20 03:13:28 +08:00
|
|
|
(ins rGPR:$src, imm0_65535_expr:$imm), IIC_iMOVi,
|
2010-11-16 08:29:56 +08:00
|
|
|
"movt", "\t$Rd, $imm",
|
|
|
|
[(set rGPR:$Rd,
|
2013-06-07 00:35:25 +08:00
|
|
|
(or (and rGPR:$src, 0xffff), lo16AllZero:$imm))]>,
|
|
|
|
Sched<[WriteALU]> {
|
2009-12-16 01:24:14 +08: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-20 01:11:02 +08:00
|
|
|
|
2010-11-16 08:29:56 +08:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<16> imm;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-16 08:29:56 +08: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};
|
2011-10-05 06:44:48 +08:00
|
|
|
let DecoderMethod = "DecodeT2MOVTWInstruction";
|
2009-12-16 01:24:14 +08:00
|
|
|
}
|
2009-06-18 02:13:58 +08:00
|
|
|
|
2011-01-22 02:55:51 +08:00
|
|
|
def t2MOVTi16_ga_pcrel : PseudoInst<(outs rGPR:$Rd),
|
2013-06-07 00:35:25 +08:00
|
|
|
(ins rGPR:$src, i32imm:$addr, pclabel:$id), IIC_iMOVi, []>,
|
|
|
|
Sched<[WriteALU]>;
|
2011-01-17 16:03:18 +08:00
|
|
|
} // 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
llvm-svn: 109842
2010-07-30 10:41:01 +08:00
|
|
|
def : T2Pat<(or rGPR:$src, 0xffff0000), (t2MOVTi16 rGPR:$src, 0xffff)>;
|
2009-10-21 16:15:52 +08:00
|
|
|
|
2009-07-03 09:43:10 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Extend Instructions.
|
|
|
|
//
|
|
|
|
|
|
|
|
// Sign extenders
|
|
|
|
|
2011-07-28 00:47:19 +08:00
|
|
|
def t2SXTB : T2I_ext_rrot<0b100, "sxtb",
|
2009-12-16 01:24:14 +08:00
|
|
|
UnOpFrag<(sext_inreg node:$Src, i8)>>;
|
2011-07-28 00:47:19 +08:00
|
|
|
def t2SXTH : T2I_ext_rrot<0b000, "sxth",
|
2009-12-16 01:24:14 +08:00
|
|
|
UnOpFrag<(sext_inreg node:$Src, i16)>>;
|
2011-07-28 01:48:13 +08:00
|
|
|
def t2SXTB16 : T2I_ext_rrot_sxtb16<0b010, "sxtb16">;
|
2009-07-03 09:43:10 +08:00
|
|
|
|
2011-07-28 01:48:13 +08:00
|
|
|
def t2SXTAB : T2I_exta_rrot<0b100, "sxtab",
|
2009-07-03 09:43:10 +08:00
|
|
|
BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS, i8))>>;
|
2011-07-28 01:48:13 +08:00
|
|
|
def t2SXTAH : T2I_exta_rrot<0b000, "sxtah",
|
2009-07-03 09:43:10 +08:00
|
|
|
BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS,i16))>>;
|
2011-07-28 01:48:13 +08:00
|
|
|
def t2SXTAB16 : T2I_exta_rrot_np<0b010, "sxtab16">;
|
2009-07-03 09:43:10 +08:00
|
|
|
|
|
|
|
// Zero extenders
|
|
|
|
|
|
|
|
let AddedComplexity = 16 in {
|
2011-07-28 00:47:19 +08:00
|
|
|
def t2UXTB : T2I_ext_rrot<0b101, "uxtb",
|
2009-12-16 01:24:14 +08:00
|
|
|
UnOpFrag<(and node:$Src, 0x000000FF)>>;
|
2011-07-28 00:47:19 +08:00
|
|
|
def t2UXTH : T2I_ext_rrot<0b001, "uxth",
|
2009-12-16 01:24:14 +08:00
|
|
|
UnOpFrag<(and node:$Src, 0x0000FFFF)>>;
|
2011-07-28 01:48:13 +08:00
|
|
|
def t2UXTB16 : T2I_ext_rrot_uxtb16<0b011, "uxtb16",
|
2009-12-16 01:24:14 +08:00
|
|
|
UnOpFrag<(and node:$Src, 0x00FF00FF)>>;
|
2009-07-03 09:43:10 +08:00
|
|
|
|
2010-07-29 07:17:45 +08: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
llvm-svn: 109842
2010-07-30 10:41:01 +08:00
|
|
|
//def : T2Pat<(and (shl rGPR:$Src, (i32 8)), 0xFF00FF),
|
2011-07-28 01:48:13 +08:00
|
|
|
// (t2UXTB16 rGPR:$Src, 3)>,
|
2010-11-01 23:59:52 +08: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
llvm-svn: 109842
2010-07-30 10:41:01 +08:00
|
|
|
def : T2Pat<(and (srl rGPR:$Src, (i32 8)), 0xFF00FF),
|
2011-07-28 01:48:13 +08:00
|
|
|
(t2UXTB16 rGPR:$Src, 1)>,
|
2010-11-01 23:59:52 +08:00
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
2009-07-03 09:43:10 +08:00
|
|
|
|
2011-07-28 01:48:13 +08:00
|
|
|
def t2UXTAB : T2I_exta_rrot<0b101, "uxtab",
|
2009-11-24 08:20:27 +08:00
|
|
|
BinOpFrag<(add node:$LHS, (and node:$RHS, 0x00FF))>>;
|
2011-07-28 01:48:13 +08:00
|
|
|
def t2UXTAH : T2I_exta_rrot<0b001, "uxtah",
|
2009-11-24 08:20:27 +08:00
|
|
|
BinOpFrag<(add node:$LHS, (and node:$RHS, 0xFFFF))>>;
|
2011-07-28 01:48:13 +08:00
|
|
|
def t2UXTAB16 : T2I_exta_rrot_np<0b011, "uxtab16">;
|
2009-07-03 09:43:10 +08:00
|
|
|
}
|
|
|
|
|
2009-06-18 02:13:58 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Arithmetic Instructions.
|
|
|
|
//
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2009-12-16 01:24:14 +08: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-24 01:48:47 +08:00
|
|
|
|
|
|
|
// ADD and SUB with 's' bit set. No 12-bit immediate (T4) variants.
|
2011-09-21 10:20:46 +08:00
|
|
|
//
|
|
|
|
// Currently, t2ADDS/t2SUBS are pseudo opcodes that exist only in the
|
|
|
|
// selection DAG. They are "lowered" to real t2ADD/t2SUB opcodes by
|
|
|
|
// AdjustInstrPostInstrSelection where we determine whether or not to
|
|
|
|
// set the "s" bit based on CPSR liveness.
|
|
|
|
//
|
|
|
|
// FIXME: Eliminate t2ADDS/t2SUBS pseudo opcodes after adding tablegen
|
|
|
|
// support for an optional CPSR definition that corresponds to the DAG
|
|
|
|
// node's second value. We can then eliminate the implicit def of CPSR.
|
2011-10-19 03:18:52 +08:00
|
|
|
defm t2ADDS : T2I_bin_s_irs <IIC_iALUi, IIC_iALUr, IIC_iALUsi,
|
2011-08-30 09:34:54 +08:00
|
|
|
BinOpFrag<(ARMaddc node:$LHS, node:$RHS)>, 1>;
|
2011-10-19 03:18:52 +08:00
|
|
|
defm t2SUBS : T2I_bin_s_irs <IIC_iALUi, IIC_iALUr, IIC_iALUsi,
|
2011-08-30 09:34:54 +08:00
|
|
|
BinOpFrag<(ARMsubc node:$LHS, node:$RHS)>>;
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2011-09-21 02:22:31 +08:00
|
|
|
let hasPostISelHook = 1 in {
|
2009-12-16 01:24:14 +08:00
|
|
|
defm t2ADC : T2I_adde_sube_irs<0b1010, "adc",
|
2011-08-30 09:34:54 +08:00
|
|
|
BinOpWithFlagFrag<(ARMadde node:$LHS, node:$RHS, node:$FLAG)>, 1>;
|
2009-12-16 01:24:14 +08:00
|
|
|
defm t2SBC : T2I_adde_sube_irs<0b1011, "sbc",
|
2011-08-30 09:34:54 +08:00
|
|
|
BinOpWithFlagFrag<(ARMsube node:$LHS, node:$RHS, node:$FLAG)>>;
|
2011-09-21 02:22:31 +08:00
|
|
|
}
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2009-07-28 00:39:05 +08:00
|
|
|
// RSB
|
2010-08-14 07:24:25 +08:00
|
|
|
defm t2RSB : T2I_rbin_irs <0b1110, "rsb",
|
2009-12-16 01:24:14 +08:00
|
|
|
BinOpFrag<(sub node:$LHS, node:$RHS)>>;
|
2011-09-07 02:52:20 +08:00
|
|
|
|
|
|
|
// FIXME: Eliminate them if we can write def : Pat patterns which defines
|
|
|
|
// CPSR and the implicit def of CPSR is not needed.
|
2011-10-19 03:18:52 +08:00
|
|
|
defm t2RSBS : T2I_rbin_s_is <BinOpFrag<(ARMsubc node:$LHS, node:$RHS)>>;
|
2009-06-24 01:48:47 +08:00
|
|
|
|
|
|
|
// (sub X, imm) gets canonicalized to (add X, -imm). Match this form.
|
2010-07-15 01:45:16 +08: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
|
2012-11-15 03:39:15 +08:00
|
|
|
def : T2Pat<(add GPR:$src, imm1_255_neg:$imm),
|
|
|
|
(t2SUBri GPR:$src, imm1_255_neg:$imm)>;
|
2010-07-15 01:45:16 +08:00
|
|
|
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)>;
|
2012-06-23 08:29:06 +08:00
|
|
|
def : T2Pat<(add GPR:$src, imm0_65535_neg:$imm),
|
|
|
|
(t2SUBrr GPR:$src, (t2MOVi16 (imm_neg_XFORM imm:$imm)))>;
|
|
|
|
|
2010-07-15 01:45:16 +08:00
|
|
|
let AddedComplexity = 1 in
|
2012-11-15 03:39:15 +08:00
|
|
|
def : T2Pat<(ARMaddc rGPR:$src, imm1_255_neg:$imm),
|
|
|
|
(t2SUBSri rGPR:$src, imm1_255_neg:$imm)>;
|
2011-08-30 09:34:54 +08: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
llvm-svn: 109842
2010-07-30 10:41:01 +08:00
|
|
|
(t2SUBSri rGPR:$src, t2_so_imm_neg:$imm)>;
|
2012-06-23 08:29:06 +08:00
|
|
|
def : T2Pat<(ARMaddc rGPR:$src, imm0_65535_neg:$imm),
|
|
|
|
(t2SUBSrr rGPR:$src, (t2MOVi16 (imm_neg_XFORM imm:$imm)))>;
|
2010-07-15 01:45:16 +08: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 09:41:15 +08:00
|
|
|
let AddedComplexity = 1 in
|
2011-08-30 09:34:54 +08:00
|
|
|
def : T2Pat<(ARMadde rGPR:$src, imm0_255_not:$imm, CPSR),
|
2011-04-23 11:55:32 +08:00
|
|
|
(t2SBCri rGPR:$src, imm0_255_not:$imm)>;
|
2011-08-30 09:34:54 +08:00
|
|
|
def : T2Pat<(ARMadde rGPR:$src, t2_so_imm_not:$imm, CPSR),
|
2011-04-23 11:55:32 +08:00
|
|
|
(t2SBCri rGPR:$src, t2_so_imm_not:$imm)>;
|
2012-06-23 08:29:06 +08:00
|
|
|
def : T2Pat<(ARMadde rGPR:$src, imm0_65535_neg:$imm, CPSR),
|
2012-10-25 03:53:01 +08:00
|
|
|
(t2SBCrr rGPR:$src, (t2MOVi16 (imm_not_XFORM imm:$imm)))>;
|
2009-06-24 01:48:47 +08: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.
llvm-svn: 97573
2010-03-03 02:14:57 +08:00
|
|
|
// Select Bytes -- for disassembly only
|
|
|
|
|
2010-12-01 04:00:01 +08:00
|
|
|
def t2SEL : T2ThreeReg<(outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm),
|
2011-07-02 05:12:19 +08: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.
llvm-svn: 97573
2010-03-03 02:14:57 +08: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]
llvm-svn: 97276
2010-02-27 06:04:29 +08:00
|
|
|
// A6.3.13, A6.3.14, A6.3.15 Parallel addition and subtraction (signed/unsigned)
|
|
|
|
// And Miscellaneous operations -- for disassembly only
|
2010-07-30 01:56:55 +08:00
|
|
|
class T2I_pam<bits<3> op22_20, bits<4> op7_4, string opc,
|
2011-01-21 22:07:40 +08: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-02 05:12:19 +08: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]
llvm-svn: 97276
2010-02-27 06:04:29 +08: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-20 01:11:02 +08:00
|
|
|
|
2010-11-18 03:57:38 +08:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08: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]
llvm-svn: 97276
2010-02-27 06:04:29 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Saturating add/subtract -- for disassembly only
|
|
|
|
|
2010-07-30 01:56:55 +08:00
|
|
|
def t2QADD : T2I_pam<0b000, 0b1000, "qadd",
|
2011-01-21 22:07:40 +08: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]
llvm-svn: 97276
2010-02-27 06:04:29 +08: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 22:07:40 +08: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]
llvm-svn: 97276
2010-02-27 06:04:29 +08:00
|
|
|
def t2QSAX : T2I_pam<0b110, 0b0001, "qsax">;
|
2010-07-30 01:56:55 +08:00
|
|
|
def t2QSUB : T2I_pam<0b000, 0b1010, "qsub",
|
2011-01-21 22:07:40 +08: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]
llvm-svn: 97276
2010-02-27 06:04:29 +08: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-19 04:32:18 +08: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;
|
|
|
|
}
|
|
|
|
|
2011-09-20 08:26:34 +08:00
|
|
|
// Unsigned Sum of Absolute Differences [and Accumulate].
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2USAD8 : T2ThreeReg_mac<0, 0b111, 0b0000, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rn, rGPR:$Rm),
|
2011-07-02 05:12:19 +08: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]
llvm-svn: 97276
2010-02-27 06:04:29 +08:00
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
}
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2USADA8 : T2FourReg_mac<0, 0b111, 0b0000, (outs rGPR:$Rd),
|
2010-11-20 01:11:02 +08:00
|
|
|
(ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), NoItinerary,
|
2011-07-02 05:12:19 +08: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]
llvm-svn: 97276
2010-02-27 06:04:29 +08:00
|
|
|
|
2011-09-20 08:26:34 +08:00
|
|
|
// Signed/Unsigned saturate.
|
2010-11-18 03:57:38 +08:00
|
|
|
class T2SatI<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-20 01:11:02 +08:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
2010-11-18 03:57:38 +08:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rn;
|
|
|
|
bits<5> sat_imm;
|
|
|
|
bits<7> sh;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{19-16} = Rn;
|
2011-07-26 06:20:28 +08:00
|
|
|
let Inst{4-0} = sat_imm;
|
|
|
|
let Inst{21} = sh{5};
|
2010-11-18 03:57:38 +08:00
|
|
|
let Inst{14-12} = sh{4-2};
|
|
|
|
let Inst{7-6} = sh{1-0};
|
|
|
|
}
|
|
|
|
|
2010-12-01 04:00:01 +08:00
|
|
|
def t2SSAT: T2SatI<
|
2011-09-27 05:06:22 +08:00
|
|
|
(outs rGPR:$Rd),
|
|
|
|
(ins imm1_32:$sat_imm, rGPR:$Rn, t2_shift_imm:$sh),
|
2011-09-20 08:26:34 +08:00
|
|
|
NoItinerary, "ssat", "\t$Rd, $sat_imm, $Rn$sh", []> {
|
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]
llvm-svn: 97276
2010-02-27 06:04:29 +08:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25-22} = 0b1100;
|
|
|
|
let Inst{20} = 0;
|
|
|
|
let Inst{15} = 0;
|
2011-09-20 04:00:02 +08: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]
llvm-svn: 97276
2010-02-27 06:04:29 +08:00
|
|
|
}
|
|
|
|
|
2010-12-01 04:00:01 +08:00
|
|
|
def t2SSAT16: T2SatI<
|
2011-07-26 07:09:14 +08:00
|
|
|
(outs rGPR:$Rd), (ins imm1_16:$sat_imm, rGPR:$Rn), NoItinerary,
|
2011-09-20 08:26:34 +08:00
|
|
|
"ssat16", "\t$Rd, $sat_imm, $Rn", []>,
|
2011-07-02 05:12:19 +08:00
|
|
|
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]
llvm-svn: 97276
2010-02-27 06:04:29 +08: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-17 06:17:02 +08: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]
llvm-svn: 97276
2010-02-27 06:04:29 +08:00
|
|
|
}
|
|
|
|
|
2010-12-01 04:00:01 +08:00
|
|
|
def t2USAT: T2SatI<
|
2011-09-27 05:06:22 +08:00
|
|
|
(outs rGPR:$Rd),
|
|
|
|
(ins imm0_31:$sat_imm, rGPR:$Rn, t2_shift_imm:$sh),
|
2011-09-20 08:26:34 +08:00
|
|
|
NoItinerary, "usat", "\t$Rd, $sat_imm, $Rn$sh", []> {
|
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]
llvm-svn: 97276
2010-02-27 06:04:29 +08:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25-22} = 0b1110;
|
|
|
|
let Inst{20} = 0;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
|
|
|
|
2011-09-17 02:32:30 +08:00
|
|
|
def t2USAT16: T2SatI<(outs rGPR:$Rd), (ins imm0_15:$sat_imm, rGPR:$Rn),
|
2011-06-14 06:54:22 +08:00
|
|
|
NoItinerary,
|
2011-09-20 08:26:34 +08:00
|
|
|
"usat16", "\t$Rd, $sat_imm, $Rn", []>,
|
2011-07-02 05:12:19 +08:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2011-09-24 05:57:50 +08:00
|
|
|
let Inst{31-22} = 0b1111001110;
|
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]
llvm-svn: 97276
2010-02-27 06:04:29 +08:00
|
|
|
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-24 05:57:50 +08: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]
llvm-svn: 97276
2010-02-27 06:04:29 +08:00
|
|
|
}
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2010-08-14 05:48:10 +08: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-30 06:48:09 +08:00
|
|
|
|
2009-06-24 03:39:13 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Shift and rotate Instructions.
|
|
|
|
//
|
|
|
|
|
2011-09-03 05:28:54 +08:00
|
|
|
defm t2LSL : T2I_sh_ir<0b00, "lsl", imm0_31,
|
2012-08-03 05:59:52 +08:00
|
|
|
BinOpFrag<(shl node:$LHS, node:$RHS)>>;
|
2011-09-03 02:43:25 +08:00
|
|
|
defm t2LSR : T2I_sh_ir<0b01, "lsr", imm_sr,
|
2012-08-03 05:59:52 +08:00
|
|
|
BinOpFrag<(srl node:$LHS, node:$RHS)>>;
|
2011-09-03 02:43:25 +08:00
|
|
|
defm t2ASR : T2I_sh_ir<0b10, "asr", imm_sr,
|
2012-08-03 05:59:52 +08:00
|
|
|
BinOpFrag<(sra node:$LHS, node:$RHS)>>;
|
2011-09-03 05:28:54 +08:00
|
|
|
defm t2ROR : T2I_sh_ir<0b11, "ror", imm0_31,
|
2012-08-03 05:59:52 +08:00
|
|
|
BinOpFrag<(rotr node:$LHS, node:$RHS)>>;
|
2009-06-24 03:39:13 +08:00
|
|
|
|
2011-04-29 22:18:15 +08:00
|
|
|
// (rotr x, (and y, 0x...1f)) ==> (ROR x, y)
|
2012-07-03 01:22:47 +08:00
|
|
|
def : T2Pat<(rotr rGPR:$lhs, (and rGPR:$rhs, lo5AllOne)),
|
|
|
|
(t2RORrr rGPR:$lhs, rGPR:$rhs)>;
|
2011-04-29 22:18:15 +08:00
|
|
|
|
2009-09-02 02:32:09 +08:00
|
|
|
let Uses = [CPSR] in {
|
2010-11-18 03:57:38 +08:00
|
|
|
def t2RRX : T2sTwoReg<(outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iMOVsi,
|
|
|
|
"rrx", "\t$Rd, $Rm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, (ARMrrx rGPR:$Rm))]>, Sched<[WriteALU]> {
|
2009-12-16 01:24:14 +08: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-02 02:32:09 +08:00
|
|
|
}
|
2009-06-24 03:39:13 +08:00
|
|
|
|
2011-01-10 23:26:39 +08:00
|
|
|
let isCodeGenOnly = 1, Defs = [CPSR] in {
|
2010-11-16 03:58:36 +08:00
|
|
|
def t2MOVsrl_flag : T2TwoRegShiftImm<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iMOVsi,
|
|
|
|
"lsrs", ".w\t$Rd, $Rm, #1",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, (ARMsrl_flag rGPR:$Rm))]>,
|
|
|
|
Sched<[WriteALU]> {
|
2009-12-16 01:24:14 +08: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-16 03:58:36 +08:00
|
|
|
def t2MOVsra_flag : T2TwoRegShiftImm<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iMOVsi,
|
|
|
|
"asrs", ".w\t$Rd, $Rm, #1",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, (ARMsra_flag rGPR:$Rm))]>,
|
|
|
|
Sched<[WriteALU]> {
|
2009-12-16 01:24:14 +08: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-29 01:06:49 +08:00
|
|
|
}
|
|
|
|
|
2009-06-24 01:48:47 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Bitwise Instructions.
|
|
|
|
//
|
|
|
|
|
2009-12-16 01:24:14 +08:00
|
|
|
defm t2AND : T2I_bin_w_irs<0b0000, "and",
|
2010-09-29 08:27:46 +08:00
|
|
|
IIC_iBITi, IIC_iBITr, IIC_iBITsi,
|
2012-08-03 05:50:41 +08:00
|
|
|
BinOpFrag<(and node:$LHS, node:$RHS)>, 1>;
|
2009-12-16 01:24:14 +08:00
|
|
|
defm t2ORR : T2I_bin_w_irs<0b0010, "orr",
|
2010-09-29 08:27:46 +08:00
|
|
|
IIC_iBITi, IIC_iBITr, IIC_iBITsi,
|
2012-08-03 05:50:41 +08:00
|
|
|
BinOpFrag<(or node:$LHS, node:$RHS)>, 1>;
|
2009-12-16 01:24:14 +08:00
|
|
|
defm t2EOR : T2I_bin_w_irs<0b0100, "eor",
|
2010-09-29 08:27:46 +08:00
|
|
|
IIC_iBITi, IIC_iBITr, IIC_iBITsi,
|
2012-08-03 05:50:41 +08:00
|
|
|
BinOpFrag<(xor node:$LHS, node:$RHS)>, 1>;
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2009-12-16 01:24:14 +08:00
|
|
|
defm t2BIC : T2I_bin_w_irs<0b0001, "bic",
|
2010-09-29 08:27:46 +08:00
|
|
|
IIC_iBITi, IIC_iBITr, IIC_iBITsi,
|
2012-08-03 05:50:41 +08:00
|
|
|
BinOpFrag<(and node:$LHS, (not node:$RHS))>>;
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2010-11-18 06:16:31 +08:00
|
|
|
class T2BitFI<dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-20 01:11:02 +08:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
2010-11-18 06:16:31 +08:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<5> msb;
|
|
|
|
bits<5> lsb;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
2010-11-18 06:16:31 +08: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-20 01:11:02 +08:00
|
|
|
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{19-16} = Rn;
|
2010-11-18 06:16:31 +08: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-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11110;
|
2011-04-16 06:52:15 +08:00
|
|
|
let Inst{26} = 0; // should be 0.
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{25} = 1;
|
|
|
|
let Inst{24-20} = 0b10110;
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
let Inst{15} = 0;
|
2011-04-16 06:52:15 +08:00
|
|
|
let Inst{5} = 0; // should be 0.
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-11-18 06:16:31 +08:00
|
|
|
bits<10> imm;
|
|
|
|
let msb{4-0} = imm{9-5};
|
|
|
|
let lsb{4-0} = imm{4-0};
|
2009-12-16 01:24:14 +08:00
|
|
|
}
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2010-11-18 06:16:31 +08:00
|
|
|
def t2SBFX: T2TwoRegBitFI<
|
2011-07-28 05:09:25 +08:00
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, imm0_31:$lsb, imm1_32:$msb),
|
2010-11-18 06:16:31 +08:00
|
|
|
IIC_iUNAsi, "sbfx", "\t$Rd, $Rn, $lsb, $msb", []> {
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 1;
|
|
|
|
let Inst{24-20} = 0b10100;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
2009-10-14 02:59:48 +08:00
|
|
|
|
2010-11-18 06:16:31 +08:00
|
|
|
def t2UBFX: T2TwoRegBitFI<
|
2011-07-28 05:09:25 +08:00
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, imm0_31:$lsb, imm1_32:$msb),
|
2010-11-18 06:16:31 +08:00
|
|
|
IIC_iUNAsi, "ubfx", "\t$Rd, $Rn, $lsb, $msb", []> {
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 1;
|
|
|
|
let Inst{24-20} = 0b11100;
|
|
|
|
let Inst{15} = 0;
|
|
|
|
}
|
2009-10-14 02:59:48 +08:00
|
|
|
|
2010-02-03 03:31:58 +08:00
|
|
|
// A8.6.18 BFI - Bitfield insert (Encoding T1)
|
2011-01-19 04:45:56 +08: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 08:35:08 +08:00
|
|
|
let Inst{26} = 0; // should be 0.
|
2011-01-19 04:45:56 +08:00
|
|
|
let Inst{25} = 1;
|
|
|
|
let Inst{24-20} = 0b10110;
|
|
|
|
let Inst{15} = 0;
|
2011-04-15 08:35:08 +08:00
|
|
|
let Inst{5} = 0; // should be 0.
|
2011-01-19 04:45:56 +08:00
|
|
|
|
|
|
|
bits<10> imm;
|
|
|
|
let msb{4-0} = imm{9-5};
|
|
|
|
let lsb{4-0} = imm{4-0};
|
|
|
|
}
|
2010-02-03 03:31:58 +08:00
|
|
|
}
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2010-09-29 08:27:46 +08:00
|
|
|
defm t2ORN : T2I_bin_irs<0b0011, "orn",
|
|
|
|
IIC_iBITi, IIC_iBITr, IIC_iBITsi,
|
2012-08-03 05:50:41 +08:00
|
|
|
BinOpFrag<(or node:$LHS, (not node:$RHS))>, 0, "">;
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2011-09-15 05:24:41 +08: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,
|
2012-12-11 07:21:26 +08:00
|
|
|
PatFrag opnode,
|
|
|
|
bit Cheap = 0, bit ReMat = 0, bit MoveImm = 0> {
|
2011-09-15 05:24:41 +08:00
|
|
|
// shifted imm
|
|
|
|
def i : T2sOneRegImm<(outs rGPR:$Rd), (ins t2_so_imm:$imm), iii,
|
|
|
|
opc, "\t$Rd, $imm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, (opnode t2_so_imm:$imm))]>, Sched<[WriteALU]> {
|
2011-09-15 05:24:41 +08:00
|
|
|
let isAsCheapAsAMove = Cheap;
|
|
|
|
let isReMaterializable = ReMat;
|
2012-12-11 07:21:26 +08:00
|
|
|
let isMoveImm = MoveImm;
|
2011-09-15 05:24:41 +08:00
|
|
|
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",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, (opnode rGPR:$Rm))]>, Sched<[WriteALU]> {
|
2011-09-15 05:24:41 +08:00
|
|
|
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",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, (opnode t2_so_reg:$ShiftedRm))]>,
|
|
|
|
Sched<[WriteALU]> {
|
2011-09-15 05:24:41 +08:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = opcod;
|
|
|
|
let Inst{19-16} = 0b1111; // Rn
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-27 07:13:13 +08:00
|
|
|
// Prefer over of t2EORri ra, rb, -1 because mvn has 16-bit version
|
|
|
|
let AddedComplexity = 1 in
|
2010-09-29 08:49:25 +08:00
|
|
|
defm t2MVN : T2I_un_irs <0b0011, "mvn",
|
2010-09-30 06:42:35 +08:00
|
|
|
IIC_iMVNi, IIC_iMVNr, IIC_iMVNsi,
|
2012-12-11 07:21:26 +08:00
|
|
|
UnOpFrag<(not node:$Src)>, 1, 1, 1>;
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2010-07-21 00:07:04 +08: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
llvm-svn: 109842
2010-07-30 10:41:01 +08:00
|
|
|
def : T2Pat<(and rGPR:$src, t2_so_imm_not:$imm),
|
|
|
|
(t2BICri rGPR:$src, t2_so_imm_not:$imm)>;
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2012-06-18 22:51:32 +08:00
|
|
|
// top16Zero - answer true if the upper 16 bits of $src are 0, false otherwise
|
|
|
|
def top16Zero: PatLeaf<(i32 rGPR:$src), [{
|
|
|
|
return CurDAG->MaskedValueIsZero(SDValue(N,0), APInt::getHighBitsSet(32, 16));
|
|
|
|
}]>;
|
|
|
|
|
|
|
|
// so_imm_notSext is needed instead of so_imm_not, as the value of imm
|
|
|
|
// will match the extended, not the original bitWidth for $src.
|
|
|
|
def : T2Pat<(and top16Zero:$src, t2_so_imm_notSext:$imm),
|
|
|
|
(t2BICri rGPR:$src, t2_so_imm_notSext:$imm)>;
|
|
|
|
|
|
|
|
|
2009-08-01 14:13:52 +08: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
llvm-svn: 109842
2010-07-30 10:41:01 +08:00
|
|
|
def : T2Pat<(or rGPR:$src, t2_so_imm_not:$imm),
|
|
|
|
(t2ORNri rGPR:$src, t2_so_imm_not:$imm)>,
|
2009-08-12 09:56:42 +08:00
|
|
|
Requires<[IsThumb2]>;
|
2009-07-07 06:23:46 +08:00
|
|
|
|
|
|
|
def : T2Pat<(t2_so_imm_not:$src),
|
|
|
|
(t2MVNi t2_so_imm_not:$src)>;
|
2009-06-24 01:48:47 +08:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Multiply Instructions.
|
|
|
|
//
|
2009-06-26 08:19:44 +08:00
|
|
|
let isCommutable = 1 in
|
2010-11-18 09:08:42 +08: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-16 01:24:14 +08: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-24 01:48:47 +08:00
|
|
|
|
2010-11-18 09:08:42 +08:00
|
|
|
def t2MLA: T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
|
|
|
|
"mla", "\t$Rd, $Rn, $Rm, $Ra",
|
2012-09-30 05:43:49 +08:00
|
|
|
[(set rGPR:$Rd, (add (mul rGPR:$Rn, rGPR:$Rm), rGPR:$Ra))]>,
|
|
|
|
Requires<[IsThumb2, UseMulOps]> {
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-23} = 0b0110;
|
|
|
|
let Inst{22-20} = 0b000;
|
|
|
|
let Inst{7-4} = 0b0000; // Multiply
|
|
|
|
}
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2010-11-18 09:08:42 +08:00
|
|
|
def t2MLS: T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
|
|
|
|
"mls", "\t$Rd, $Rn, $Rm, $Ra",
|
2012-09-30 05:43:49 +08:00
|
|
|
[(set rGPR:$Rd, (sub rGPR:$Ra, (mul rGPR:$Rn, rGPR:$Rm)))]>,
|
|
|
|
Requires<[IsThumb2, UseMulOps]> {
|
2009-12-16 01:24:14 +08: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-24 01:48:47 +08:00
|
|
|
|
2009-07-07 09:17:28 +08:00
|
|
|
// Extra precision multiplies with low / high results
|
|
|
|
let neverHasSideEffects = 1 in {
|
|
|
|
let isCommutable = 1 in {
|
2010-12-09 06:38:41 +08:00
|
|
|
def t2SMULL : T2MulLong<0b000, 0b0000,
|
2011-08-23 07:16:48 +08:00
|
|
|
(outs rGPR:$RdLo, rGPR:$RdHi),
|
2010-11-18 09:08:42 +08:00
|
|
|
(ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL64,
|
2011-08-23 07:16:48 +08:00
|
|
|
"smull", "\t$RdLo, $RdHi, $Rn, $Rm", []>;
|
2009-07-07 09:17:28 +08:00
|
|
|
|
2010-12-09 06:38:41 +08:00
|
|
|
def t2UMULL : T2MulLong<0b010, 0b0000,
|
2010-12-09 06:29:28 +08:00
|
|
|
(outs rGPR:$RdLo, rGPR:$RdHi),
|
2010-11-18 09:08:42 +08:00
|
|
|
(ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL64,
|
2010-12-09 06:38:41 +08:00
|
|
|
"umull", "\t$RdLo, $RdHi, $Rn, $Rm", []>;
|
2009-12-16 01:24:14 +08:00
|
|
|
} // isCommutable
|
2009-07-07 09:17:28 +08:00
|
|
|
|
|
|
|
// Multiply + accumulate
|
2012-09-04 22:37:49 +08:00
|
|
|
def t2SMLAL : T2MlaLong<0b100, 0b0000,
|
2012-08-12 13:11:56 +08:00
|
|
|
(outs rGPR:$RdLo, rGPR:$RdHi),
|
2012-09-04 22:37:49 +08:00
|
|
|
(ins rGPR:$Rn, rGPR:$Rm, rGPR:$RLo, rGPR:$RHi), IIC_iMAC64,
|
|
|
|
"smlal", "\t$RdLo, $RdHi, $Rn, $Rm", []>,
|
|
|
|
RegConstraint<"$RLo = $RdLo, $RHi = $RdHi">;
|
2009-07-07 09:17:28 +08:00
|
|
|
|
2012-09-04 22:37:49 +08:00
|
|
|
def t2UMLAL : T2MlaLong<0b110, 0b0000,
|
2012-08-12 13:11:56 +08:00
|
|
|
(outs rGPR:$RdLo, rGPR:$RdHi),
|
2012-09-04 22:37:49 +08:00
|
|
|
(ins rGPR:$Rn, rGPR:$Rm, rGPR:$RLo, rGPR:$RHi), IIC_iMAC64,
|
|
|
|
"umlal", "\t$RdLo, $RdHi, $Rn, $Rm", []>,
|
|
|
|
RegConstraint<"$RLo = $RdLo, $RHi = $RdHi">;
|
2009-07-07 09:17:28 +08:00
|
|
|
|
2010-12-09 06:38:41 +08:00
|
|
|
def t2UMAAL : T2MulLong<0b110, 0b0110,
|
|
|
|
(outs rGPR:$RdLo, rGPR:$RdHi),
|
2010-11-18 09:08:42 +08:00
|
|
|
(ins rGPR:$Rn, rGPR:$Rm), IIC_iMAC64,
|
2011-07-02 05:12:19 +08:00
|
|
|
"umaal", "\t$RdLo, $RdHi, $Rn, $Rm", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2009-07-07 09:17:28 +08: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.
llvm-svn: 97573
2010-03-03 02:14:57 +08:00
|
|
|
// Rounding variants of the below included for disassembly only
|
|
|
|
|
2009-07-07 09:17:28 +08:00
|
|
|
// Most significant word multiply
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2SMMUL : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL32,
|
|
|
|
"smmul", "\t$Rd, $Rn, $Rm",
|
2011-07-02 05:12:19 +08:00
|
|
|
[(set rGPR:$Rd, (mulhs rGPR:$Rn, rGPR:$Rm))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-16 01:24:14 +08: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 09:17:28 +08:00
|
|
|
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2SMMULR : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL32,
|
2011-07-02 05:12:19 +08: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.
llvm-svn: 97573
2010-03-03 02:14:57 +08: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-19 04:32:18 +08:00
|
|
|
def t2SMMLA : T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
|
|
|
|
"smmla", "\t$Rd, $Rn, $Rm, $Ra",
|
2011-07-02 05:12:19 +08:00
|
|
|
[(set rGPR:$Rd, (add (mulhs rGPR:$Rm, rGPR:$Rn), rGPR:$Ra))]>,
|
2012-09-30 05:43:49 +08:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP, UseMulOps]> {
|
2009-12-16 01:24:14 +08: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 09:17:28 +08:00
|
|
|
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2SMMLAR: T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
|
2011-07-02 05:12:19 +08: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.
llvm-svn: 97573
2010-03-03 02:14:57 +08: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 09:17:28 +08:00
|
|
|
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2SMMLS: T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
|
|
|
|
"smmls", "\t$Rd, $Rn, $Rm, $Ra",
|
2011-07-02 05:12:19 +08:00
|
|
|
[(set rGPR:$Rd, (sub rGPR:$Ra, (mulhs rGPR:$Rn, rGPR:$Rm)))]>,
|
2012-09-30 05:43:49 +08:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP, UseMulOps]> {
|
2009-12-16 01:24:14 +08: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 09:17:28 +08:00
|
|
|
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2SMMLSR:T2FourReg<
|
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
|
2011-07-02 05:12:19 +08: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.
llvm-svn: 97573
2010-03-03 02:14:57 +08: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 09:17:28 +08:00
|
|
|
multiclass T2I_smul<string opc, PatFrag opnode> {
|
2010-11-19 04:32:18 +08: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-02 05:12:19 +08:00
|
|
|
(sext_inreg rGPR:$Rm, i16)))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-16 01:24:14 +08: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 09:17:28 +08:00
|
|
|
|
2010-11-19 04:32:18 +08: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-02 05:12:19 +08:00
|
|
|
(sra rGPR:$Rm, (i32 16))))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-16 01:24:14 +08: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 09:17:28 +08:00
|
|
|
|
2010-11-19 04:32:18 +08: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-02 05:12:19 +08:00
|
|
|
(sext_inreg rGPR:$Rm, i16)))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-16 01:24:14 +08: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 09:17:28 +08:00
|
|
|
|
2010-11-19 04:32:18 +08: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-02 05:12:19 +08:00
|
|
|
(sra rGPR:$Rm, (i32 16))))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-16 01:24:14 +08: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 09:17:28 +08:00
|
|
|
|
2010-11-19 04:32:18 +08: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-02 05:12:19 +08:00
|
|
|
(sext_inreg rGPR:$Rm, i16)), (i32 16)))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-16 01:24:14 +08: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 09:17:28 +08:00
|
|
|
|
2010-11-19 04:32:18 +08: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-02 05:12:19 +08:00
|
|
|
(sra rGPR:$Rm, (i32 16))), (i32 16)))]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]> {
|
2009-12-16 01:24:14 +08: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 09:17:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
multiclass T2I_smla<string opc, PatFrag opnode> {
|
2010-11-19 04:32:18 +08: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-02 05:12:19 +08:00
|
|
|
(sext_inreg rGPR:$Rm, i16))))]>,
|
2012-09-30 05:43:49 +08:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP, UseMulOps]> {
|
2009-12-16 01:24:14 +08: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 09:17:28 +08:00
|
|
|
|
2010-11-19 04:32:18 +08: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-02 05:12:19 +08:00
|
|
|
(sra rGPR:$Rm, (i32 16)))))]>,
|
2012-09-30 05:43:49 +08:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP, UseMulOps]> {
|
2009-12-16 01:24:14 +08: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 09:17:28 +08:00
|
|
|
|
2010-11-19 04:32:18 +08: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-02 05:12:19 +08:00
|
|
|
(sext_inreg rGPR:$Rm, i16))))]>,
|
2012-09-30 05:43:49 +08:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP, UseMulOps]> {
|
2009-12-16 01:24:14 +08: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 09:17:28 +08:00
|
|
|
|
2010-11-19 04:32:18 +08: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-02 05:12:19 +08:00
|
|
|
(sra rGPR:$Rm, (i32 16)))))]>,
|
2012-09-30 05:43:49 +08:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP, UseMulOps]> {
|
2009-12-16 01:24:14 +08: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 09:17:28 +08:00
|
|
|
|
2010-11-19 04:32:18 +08: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-02 05:12:19 +08:00
|
|
|
(sext_inreg rGPR:$Rm, i16)), (i32 16))))]>,
|
2012-09-30 05:43:49 +08:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP, UseMulOps]> {
|
2009-12-16 01:24:14 +08: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 09:17:28 +08:00
|
|
|
|
2010-11-19 04:32:18 +08: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-02 05:12:19 +08:00
|
|
|
(sra rGPR:$Rm, (i32 16))), (i32 16))))]>,
|
2012-09-30 05:43:49 +08:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP, UseMulOps]> {
|
2009-12-16 01:24:14 +08: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 09:17:28 +08: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-16 07:45:50 +08:00
|
|
|
// Halfword multiple accumulate long: SMLAL<x><y>
|
2010-11-19 04:32:18 +08: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-02 05:12:19 +08:00
|
|
|
[/* For disassembly only; pattern left blank */]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-19 04:32:18 +08: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-02 05:12:19 +08:00
|
|
|
[/* For disassembly only; pattern left blank */]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-19 04:32:18 +08: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-02 05:12:19 +08:00
|
|
|
[/* For disassembly only; pattern left blank */]>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-19 04:32:18 +08: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-02 05:12:19 +08: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]
llvm-svn: 97276
2010-02-27 06:04:29 +08:00
|
|
|
|
|
|
|
// Dual halfword multiple: SMUAD, SMUSD, SMLAD, SMLSD, SMLALD, SMLSLD
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2SMUAD: T2ThreeReg_mac<
|
|
|
|
0, 0b010, 0b0000, (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm),
|
2011-07-02 05:12:19 +08: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]
llvm-svn: 97276
2010-02-27 06:04:29 +08:00
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
}
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2SMUADX:T2ThreeReg_mac<
|
|
|
|
0, 0b010, 0b0001, (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm),
|
2011-07-02 05:12:19 +08: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]
llvm-svn: 97276
2010-02-27 06:04:29 +08:00
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
}
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2SMUSD: T2ThreeReg_mac<
|
|
|
|
0, 0b100, 0b0000, (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm),
|
2011-07-02 05:12:19 +08: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]
llvm-svn: 97276
2010-02-27 06:04:29 +08:00
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
}
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2SMUSDX:T2ThreeReg_mac<
|
|
|
|
0, 0b100, 0b0001, (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm),
|
2011-07-02 05:12:19 +08: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]
llvm-svn: 97276
2010-02-27 06:04:29 +08:00
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
}
|
2011-08-23 07:31:45 +08:00
|
|
|
def t2SMLAD : T2FourReg_mac<
|
2010-11-19 04:32:18 +08:00
|
|
|
0, 0b010, 0b0000, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32, "smlad",
|
2011-07-02 05:12:19 +08:00
|
|
|
"\t$Rd, $Rn, $Rm, $Ra", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2SMLADX : T2FourReg_mac<
|
|
|
|
0, 0b010, 0b0001, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32, "smladx",
|
2011-07-02 05:12:19 +08:00
|
|
|
"\t$Rd, $Rn, $Rm, $Ra", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2SMLSD : T2FourReg_mac<0, 0b100, 0b0000, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32, "smlsd",
|
2011-07-02 05:12:19 +08:00
|
|
|
"\t$Rd, $Rn, $Rm, $Ra", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2SMLSDX : T2FourReg_mac<0, 0b100, 0b0001, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32, "smlsdx",
|
2011-07-02 05:12:19 +08:00
|
|
|
"\t$Rd, $Rn, $Rm, $Ra", []>,
|
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2SMLALD : T2FourReg_mac<1, 0b100, 0b1100, (outs rGPR:$Ra,rGPR:$Rd),
|
2011-09-17 00:58:03 +08:00
|
|
|
(ins rGPR:$Rn, rGPR:$Rm), IIC_iMAC64, "smlald",
|
|
|
|
"\t$Ra, $Rd, $Rn, $Rm", []>,
|
2011-07-02 05:12:19 +08:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2SMLALDX : T2FourReg_mac<1, 0b100, 0b1101, (outs rGPR:$Ra,rGPR:$Rd),
|
2011-09-17 00:58:03 +08:00
|
|
|
(ins rGPR:$Rn,rGPR:$Rm), IIC_iMAC64, "smlaldx",
|
|
|
|
"\t$Ra, $Rd, $Rn, $Rm", []>,
|
2011-07-02 05:12:19 +08:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2SMLSLD : T2FourReg_mac<1, 0b101, 0b1100, (outs rGPR:$Ra,rGPR:$Rd),
|
2011-09-17 01:10:44 +08:00
|
|
|
(ins rGPR:$Rn,rGPR:$Rm), IIC_iMAC64, "smlsld",
|
|
|
|
"\t$Ra, $Rd, $Rn, $Rm", []>,
|
2011-07-02 05:12:19 +08:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2010-11-19 04:32:18 +08:00
|
|
|
def t2SMLSLDX : T2FourReg_mac<1, 0b101, 0b1101, (outs rGPR:$Ra,rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rm,rGPR:$Rn), IIC_iMAC64, "smlsldx",
|
2011-09-17 01:10:44 +08:00
|
|
|
"\t$Ra, $Rd, $Rn, $Rm", []>,
|
2011-07-02 05:12:19 +08:00
|
|
|
Requires<[IsThumb2, HasThumb2DSP]>;
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2011-06-22 03:00:54 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Division Instructions.
|
|
|
|
// Signed and unsigned division on v7-M
|
|
|
|
//
|
2012-09-30 05:43:49 +08:00
|
|
|
def t2SDIV : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iDIV,
|
2011-06-22 03:00:54 +08:00
|
|
|
"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;
|
|
|
|
}
|
|
|
|
|
2012-09-30 05:43:49 +08:00
|
|
|
def t2UDIV : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iDIV,
|
2011-06-22 03:00:54 +08:00
|
|
|
"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-24 01:48:47 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Misc. Arithmetic Instructions.
|
|
|
|
//
|
|
|
|
|
2010-02-17 05:23:02 +08: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-19 05:15:19 +08:00
|
|
|
: T2ThreeReg<oops, iops, itin, opc, asm, pattern> {
|
2009-12-16 01:24:14 +08: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-09 06:10:43 +08:00
|
|
|
let Rn{3-0} = Rm;
|
2009-12-16 01:24:14 +08:00
|
|
|
}
|
|
|
|
|
2010-11-19 05:15:19 +08:00
|
|
|
def t2CLZ : T2I_misc<0b11, 0b00, (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iUNAr,
|
2013-06-07 00:35:25 +08:00
|
|
|
"clz", "\t$Rd, $Rm", [(set rGPR:$Rd, (ctlz rGPR:$Rm))]>,
|
|
|
|
Sched<[WriteALU]>;
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2010-11-19 05:15:19 +08:00
|
|
|
def t2RBIT : T2I_misc<0b01, 0b10, (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iUNAr,
|
|
|
|
"rbit", "\t$Rd, $Rm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, (ARMrbit rGPR:$Rm))]>,
|
|
|
|
Sched<[WriteALU]>;
|
2010-01-19 03:58:49 +08:00
|
|
|
|
2010-11-19 05:15:19 +08:00
|
|
|
def t2REV : T2I_misc<0b01, 0b00, (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iUNAr,
|
2013-06-07 00:35:25 +08:00
|
|
|
"rev", ".w\t$Rd, $Rm", [(set rGPR:$Rd, (bswap rGPR:$Rm))]>,
|
|
|
|
Sched<[WriteALU]>;
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2010-11-19 05:15:19 +08:00
|
|
|
def t2REV16 : T2I_misc<0b01, 0b01, (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iUNAr,
|
|
|
|
"rev16", ".w\t$Rd, $Rm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, (rotr (bswap rGPR:$Rm), (i32 16)))]>,
|
|
|
|
Sched<[WriteALU]>;
|
2011-06-18 04:47:21 +08:00
|
|
|
|
2010-11-19 05:15:19 +08:00
|
|
|
def t2REVSH : T2I_misc<0b01, 0b11, (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iUNAr,
|
|
|
|
"revsh", ".w\t$Rd, $Rm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(set rGPR:$Rd, (sra (bswap rGPR:$Rm), (i32 16)))]>,
|
|
|
|
Sched<[WriteALU]>;
|
2011-03-19 05:52:42 +08:00
|
|
|
|
2011-06-16 01:17:48 +08:00
|
|
|
def : T2Pat<(or (sra (shl rGPR:$Rm, (i32 24)), (i32 16)),
|
2011-06-21 14:01:08 +08:00
|
|
|
(and (srl rGPR:$Rm, (i32 8)), 0xFF)),
|
2011-06-16 01:17:48 +08:00
|
|
|
(t2REVSH rGPR:$Rm)>;
|
|
|
|
|
2010-11-19 05:15:19 +08:00
|
|
|
def t2PKHBT : T2ThreeReg<
|
2011-09-15 07:16:41 +08:00
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, pkh_lsl_amt:$sh),
|
|
|
|
IIC_iBITsi, "pkhbt", "\t$Rd, $Rn, $Rm$sh",
|
2010-11-19 05:15:19 +08:00
|
|
|
[(set rGPR:$Rd, (or (and rGPR:$Rn, 0xFFFF),
|
2011-07-21 04:49:03 +08:00
|
|
|
(and (shl rGPR:$Rm, pkh_lsl_amt:$sh),
|
2010-05-06 04:44:35 +08:00
|
|
|
0xFFFF0000)))]>,
|
2013-06-07 00:35:25 +08:00
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>,
|
|
|
|
Sched<[WriteALUsi, ReadALU]> {
|
2009-12-16 01:24:14 +08: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-20 01:11:02 +08:00
|
|
|
|
2011-07-21 04:32:09 +08:00
|
|
|
bits<5> sh;
|
|
|
|
let Inst{14-12} = sh{4-2};
|
|
|
|
let Inst{7-6} = sh{1-0};
|
2009-12-16 01:24:14 +08:00
|
|
|
}
|
2009-07-07 13:35:52 +08: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
llvm-svn: 109842
2010-07-30 10:41:01 +08:00
|
|
|
def : T2Pat<(or (and rGPR:$src1, 0xFFFF), (and rGPR:$src2, 0xFFFF0000)),
|
|
|
|
(t2PKHBT rGPR:$src1, rGPR:$src2, 0)>,
|
2010-11-01 23:59:52 +08:00
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
2010-08-18 01:23:19 +08:00
|
|
|
def : T2Pat<(or (and rGPR:$src1, 0xFFFF), (shl rGPR:$src2, imm16_31:$sh)),
|
2011-07-21 04:32:09 +08:00
|
|
|
(t2PKHBT rGPR:$src1, rGPR:$src2, imm16_31:$sh)>,
|
2010-11-01 23:59:52 +08:00
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
2009-07-07 13:35:52 +08:00
|
|
|
|
2010-08-17 06:26:55 +08:00
|
|
|
// Note: Shifts of 1-15 bits will be transformed to srl instead of sra and
|
|
|
|
// will match the pattern below.
|
2010-11-19 05:15:19 +08:00
|
|
|
def t2PKHTB : T2ThreeReg<
|
2011-09-15 07:16:41 +08:00
|
|
|
(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, pkh_asr_amt:$sh),
|
|
|
|
IIC_iBITsi, "pkhtb", "\t$Rd, $Rn, $Rm$sh",
|
2010-11-19 05:15:19 +08:00
|
|
|
[(set rGPR:$Rd, (or (and rGPR:$Rn, 0xFFFF0000),
|
2011-07-21 04:49:03 +08:00
|
|
|
(and (sra rGPR:$Rm, pkh_asr_amt:$sh),
|
2010-08-18 01:23:19 +08:00
|
|
|
0xFFFF)))]>,
|
2013-06-07 00:35:25 +08:00
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>,
|
|
|
|
Sched<[WriteALUsi, ReadALU]> {
|
2009-12-16 01:24:14 +08: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-20 01:11:02 +08:00
|
|
|
|
2011-07-21 04:32:09 +08:00
|
|
|
bits<5> sh;
|
|
|
|
let Inst{14-12} = sh{4-2};
|
|
|
|
let Inst{7-6} = sh{1-0};
|
2009-12-16 01:24:14 +08:00
|
|
|
}
|
2009-07-07 13:35:52 +08: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.
|
2013-07-10 06:59:22 +08:00
|
|
|
// We also can not replace a srl (17..31) by an arithmetic shift we would use in
|
|
|
|
// pkhtb src1, src2, asr (17..31).
|
|
|
|
def : T2Pat<(or (and rGPR:$src1, 0xFFFF0000), (srl rGPR:$src2, imm16:$sh)),
|
|
|
|
(t2PKHTB rGPR:$src1, rGPR:$src2, imm16:$sh)>,
|
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
|
|
|
def : T2Pat<(or (and rGPR:$src1, 0xFFFF0000), (sra rGPR:$src2, imm16_31:$sh)),
|
2011-07-21 04:32:09 +08:00
|
|
|
(t2PKHTB rGPR:$src1, rGPR:$src2, imm16_31:$sh)>,
|
2010-11-01 23:59:52 +08: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
llvm-svn: 109842
2010-07-30 10:41:01 +08:00
|
|
|
def : T2Pat<(or (and rGPR:$src1, 0xFFFF0000),
|
2010-08-18 01:23:19 +08:00
|
|
|
(and (srl rGPR:$src2, imm1_15:$sh), 0xFFFF)),
|
2011-07-21 04:32:09 +08:00
|
|
|
(t2PKHTB rGPR:$src1, rGPR:$src2, imm1_15:$sh)>,
|
2010-11-01 23:59:52 +08:00
|
|
|
Requires<[HasT2ExtractPack, IsThumb2]>;
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2013-09-18 17:45:55 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// CRC32 Instructions
|
|
|
|
//
|
|
|
|
// Polynomials:
|
|
|
|
// + CRC32{B,H,W} 0x04C11DB7
|
|
|
|
// + CRC32C{B,H,W} 0x1EDC6F41
|
|
|
|
//
|
|
|
|
|
|
|
|
class T2I_crc32<bit C, bits<2> sz, string suffix, SDPatternOperator builtin>
|
|
|
|
: T2ThreeRegNoP<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), NoItinerary,
|
|
|
|
!strconcat("crc32", suffix, "\t$Rd, $Rn, $Rm"),
|
|
|
|
[(set rGPR:$Rd, (builtin rGPR:$Rn, rGPR:$Rm))]>,
|
2013-10-29 17:47:35 +08:00
|
|
|
Requires<[IsThumb2, HasV8, HasCRC]> {
|
2013-09-18 17:45:55 +08:00
|
|
|
let Inst{31-27} = 0b11111;
|
|
|
|
let Inst{26-21} = 0b010110;
|
|
|
|
let Inst{20} = C;
|
|
|
|
let Inst{15-12} = 0b1111;
|
|
|
|
let Inst{7-6} = 0b10;
|
|
|
|
let Inst{5-4} = sz;
|
|
|
|
}
|
|
|
|
|
|
|
|
def t2CRC32B : T2I_crc32<0, 0b00, "b", int_arm_crc32b>;
|
|
|
|
def t2CRC32CB : T2I_crc32<1, 0b00, "cb", int_arm_crc32cb>;
|
|
|
|
def t2CRC32H : T2I_crc32<0, 0b01, "h", int_arm_crc32h>;
|
|
|
|
def t2CRC32CH : T2I_crc32<1, 0b01, "ch", int_arm_crc32ch>;
|
|
|
|
def t2CRC32W : T2I_crc32<0, 0b10, "w", int_arm_crc32w>;
|
|
|
|
def t2CRC32CW : T2I_crc32<1, 0b10, "cw", int_arm_crc32cw>;
|
|
|
|
|
2009-06-24 01:48:47 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Comparison Instructions...
|
|
|
|
//
|
2009-12-16 01:24:14 +08:00
|
|
|
defm t2CMP : T2I_cmp_irs<0b1101, "cmp",
|
2010-09-29 08:49:25 +08:00
|
|
|
IIC_iCMPi, IIC_iCMPr, IIC_iCMPsi,
|
2012-08-03 05:59:52 +08:00
|
|
|
BinOpFrag<(ARMcmp node:$LHS, node:$RHS)>>;
|
2010-12-08 04:41:06 +08:00
|
|
|
|
2011-09-07 05:44:58 +08: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-24 01:48:47 +08:00
|
|
|
|
2012-06-11 16:07:26 +08:00
|
|
|
let isCompare = 1, Defs = [CPSR] in {
|
|
|
|
// shifted imm
|
|
|
|
def t2CMNri : T2OneRegCmpImm<
|
|
|
|
(outs), (ins GPRnopc:$Rn, t2_so_imm:$imm), IIC_iCMPi,
|
|
|
|
"cmn", ".w\t$Rn, $imm",
|
2013-06-07 00:35:25 +08:00
|
|
|
[(ARMcmn GPRnopc:$Rn, (ineg t2_so_imm:$imm))]>,
|
|
|
|
Sched<[WriteCMP, ReadALU]> {
|
2012-06-11 16:07:26 +08:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{25} = 0;
|
|
|
|
let Inst{24-21} = 0b1000;
|
|
|
|
let Inst{20} = 1; // The S bit.
|
|
|
|
let Inst{15} = 0;
|
|
|
|
let Inst{11-8} = 0b1111; // Rd
|
|
|
|
}
|
|
|
|
// register
|
|
|
|
def t2CMNzrr : T2TwoRegCmp<
|
|
|
|
(outs), (ins GPRnopc:$Rn, rGPR:$Rm), IIC_iCMPr,
|
|
|
|
"cmn", ".w\t$Rn, $Rm",
|
|
|
|
[(BinOpFrag<(ARMcmpZ node:$LHS,(ineg node:$RHS))>
|
2013-06-07 00:35:25 +08:00
|
|
|
GPRnopc:$Rn, rGPR:$Rm)]>, Sched<[WriteCMP, ReadALU, ReadALU]> {
|
2012-06-11 16:07:26 +08:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = 0b1000;
|
|
|
|
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
|
|
|
|
}
|
|
|
|
// shifted register
|
|
|
|
def t2CMNzrs : T2OneRegCmpShiftedReg<
|
|
|
|
(outs), (ins GPRnopc:$Rn, t2_so_reg:$ShiftedRm), IIC_iCMPsi,
|
|
|
|
"cmn", ".w\t$Rn, $ShiftedRm",
|
|
|
|
[(BinOpFrag<(ARMcmpZ node:$LHS,(ineg node:$RHS))>
|
2013-06-07 00:35:25 +08:00
|
|
|
GPRnopc:$Rn, t2_so_reg:$ShiftedRm)]>,
|
|
|
|
Sched<[WriteCMPsi, ReadALU, ReadALU]> {
|
2012-06-11 16:07:26 +08:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-25} = 0b01;
|
|
|
|
let Inst{24-21} = 0b1000;
|
|
|
|
let Inst{20} = 1; // The S bit.
|
|
|
|
let Inst{11-8} = 0b1111; // Rd
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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).
|
2012-08-03 05:59:52 +08:00
|
|
|
def : t2InstAlias<"cmn${p} $Rn, $imm",
|
|
|
|
(t2CMNri GPRnopc:$Rn, t2_so_imm:$imm, pred:$p)>;
|
|
|
|
def : t2InstAlias<"cmn${p} $Rn, $shift",
|
|
|
|
(t2CMNzrs GPRnopc:$Rn, t2_so_reg:$shift, pred:$p)>;
|
2010-08-26 23:50:25 +08:00
|
|
|
|
2012-06-11 16:07:26 +08:00
|
|
|
def : T2Pat<(ARMcmp GPR:$src, t2_so_imm_neg:$imm),
|
|
|
|
(t2CMNri GPR:$src, t2_so_imm_neg:$imm)>;
|
2010-08-26 23:50:25 +08:00
|
|
|
|
2012-06-11 16:07:26 +08:00
|
|
|
def : T2Pat<(ARMcmpZ GPRnopc:$src, t2_so_imm_neg:$imm),
|
|
|
|
(t2CMNri GPRnopc:$src, t2_so_imm_neg:$imm)>;
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2009-12-16 01:24:14 +08:00
|
|
|
defm t2TST : T2I_cmp_irs<0b0000, "tst",
|
2010-09-29 08:49:25 +08:00
|
|
|
IIC_iTSTi, IIC_iTSTr, IIC_iTSTsi,
|
2012-08-03 05:59:52 +08:00
|
|
|
BinOpFrag<(ARMcmpZ (and_su node:$LHS, node:$RHS), 0)>>;
|
2009-12-16 01:24:14 +08:00
|
|
|
defm t2TEQ : T2I_cmp_irs<0b0100, "teq",
|
2010-09-29 08:49:25 +08:00
|
|
|
IIC_iTSTi, IIC_iTSTr, IIC_iTSTsi,
|
2012-08-03 05:59:52 +08:00
|
|
|
BinOpFrag<(ARMcmpZ (xor_su node:$LHS, node:$RHS), 0)>>;
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2009-07-08 04:39:03 +08:00
|
|
|
// Conditional moves
|
2010-11-13 10:25:14 +08:00
|
|
|
let neverHasSideEffects = 1 in {
|
2012-04-05 02:23:42 +08:00
|
|
|
|
2012-08-17 07:14:20 +08:00
|
|
|
let isCommutable = 1, isSelect = 1 in
|
2011-07-02 01:14:11 +08:00
|
|
|
def t2MOVCCr : t2PseudoInst<(outs rGPR:$Rd),
|
2013-08-22 17:57:11 +08:00
|
|
|
(ins rGPR:$false, rGPR:$Rm, cmovpred:$p),
|
2011-07-14 07:22:26 +08:00
|
|
|
4, IIC_iCMOVr,
|
2013-08-22 17:57:11 +08:00
|
|
|
[(set rGPR:$Rd, (ARMcmov rGPR:$false, rGPR:$Rm,
|
|
|
|
cmovpred:$p))]>,
|
|
|
|
RegConstraint<"$false = $Rd">, Sched<[WriteALU]>;
|
2009-07-08 04:39:03 +08:00
|
|
|
|
2010-11-18 04:13:28 +08:00
|
|
|
let isMoveImm = 1 in
|
2013-08-22 17:57:11 +08:00
|
|
|
def t2MOVCCi
|
|
|
|
: t2PseudoInst<(outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$false, t2_so_imm:$imm, cmovpred:$p),
|
2011-07-14 07:22:26 +08:00
|
|
|
4, IIC_iCMOVi,
|
2013-08-22 17:57:11 +08:00
|
|
|
[(set rGPR:$Rd, (ARMcmov rGPR:$false,t2_so_imm:$imm,
|
|
|
|
cmovpred:$p))]>,
|
|
|
|
RegConstraint<"$false = $Rd">, Sched<[WriteALU]>;
|
2009-12-16 01:24:14 +08:00
|
|
|
|
2011-07-02 01:14:11 +08:00
|
|
|
let isCodeGenOnly = 1 in {
|
2010-11-18 04:13:28 +08:00
|
|
|
let isMoveImm = 1 in
|
2013-08-22 17:57:11 +08:00
|
|
|
def t2MOVCCi16
|
|
|
|
: t2PseudoInst<(outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$false, imm0_65535_expr:$imm, cmovpred:$p),
|
|
|
|
4, IIC_iCMOVi,
|
|
|
|
[(set rGPR:$Rd, (ARMcmov rGPR:$false, imm0_65535:$imm,
|
|
|
|
cmovpred:$p))]>,
|
|
|
|
RegConstraint<"$false = $Rd">, Sched<[WriteALU]>;
|
2010-10-07 08:53:56 +08:00
|
|
|
|
2010-11-18 04:13:28 +08:00
|
|
|
let isMoveImm = 1 in
|
2013-08-22 17:57:11 +08:00
|
|
|
def t2MVNCCi
|
|
|
|
: t2PseudoInst<(outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$false, t2_so_imm:$imm, cmovpred:$p),
|
|
|
|
4, IIC_iCMOVi,
|
|
|
|
[(set rGPR:$Rd,
|
|
|
|
(ARMcmov rGPR:$false, t2_so_imm_not:$imm,
|
|
|
|
cmovpred:$p))]>,
|
|
|
|
RegConstraint<"$false = $Rd">, Sched<[WriteALU]>;
|
|
|
|
|
|
|
|
class MOVCCShPseudo<SDPatternOperator opnode, Operand ty>
|
|
|
|
: t2PseudoInst<(outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$false, rGPR:$Rm, i32imm:$imm, cmovpred:$p),
|
|
|
|
4, IIC_iCMOVsi,
|
|
|
|
[(set rGPR:$Rd, (ARMcmov rGPR:$false,
|
|
|
|
(opnode rGPR:$Rm, (i32 ty:$imm)),
|
|
|
|
cmovpred:$p))]>,
|
|
|
|
RegConstraint<"$false = $Rd">, Sched<[WriteALU]>;
|
|
|
|
|
|
|
|
def t2MOVCClsl : MOVCCShPseudo<shl, imm0_31>;
|
|
|
|
def t2MOVCClsr : MOVCCShPseudo<srl, imm_sr>;
|
|
|
|
def t2MOVCCasr : MOVCCShPseudo<sra, imm_sr>;
|
|
|
|
def t2MOVCCror : MOVCCShPseudo<rotr, imm0_31>;
|
2010-11-13 10:25:14 +08:00
|
|
|
|
2010-11-18 04:13:28 +08:00
|
|
|
let isMoveImm = 1 in
|
2013-08-22 17:57:11 +08:00
|
|
|
def t2MOVCCi32imm
|
|
|
|
: t2PseudoInst<(outs rGPR:$dst),
|
|
|
|
(ins rGPR:$false, i32imm:$src, cmovpred:$p),
|
|
|
|
8, IIC_iCMOVix2,
|
|
|
|
[(set rGPR:$dst, (ARMcmov rGPR:$false, imm:$src,
|
|
|
|
cmovpred:$p))]>,
|
|
|
|
RegConstraint<"$false = $dst">;
|
2012-03-21 05:28:05 +08:00
|
|
|
} // isCodeGenOnly = 1
|
Optimize a couple of common patterns involving conditional moves where the false
value is zero. Instead of a cmov + op, issue an conditional op instead. e.g.
cmp r9, r4
mov r4, #0
moveq r4, #1
orr lr, lr, r4
should be:
cmp r9, r4
orreq lr, lr, #1
That is, optimize (or x, (cmov 0, y, cond)) to (or.cond x, y). Similarly extend
this to xor as well as (and x, (cmov -1, y, cond)) => (and.cond x, y).
It's possible to extend this to ADD and SUB but I don't think they are common.
rdar://8659097
llvm-svn: 151224
2012-02-23 09:19:06 +08:00
|
|
|
|
2011-07-02 01:14:11 +08:00
|
|
|
} // neverHasSideEffects
|
2009-08-01 09:43:45 +08:00
|
|
|
|
2009-12-15 02:56:47 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Atomic operations intrinsics
|
|
|
|
//
|
|
|
|
|
|
|
|
// memory barriers protect the atomic sequences
|
|
|
|
let hasSideEffects = 1 in {
|
2013-06-27 00:52:32 +08:00
|
|
|
def t2DMB : T2I<(outs), (ins memb_opt:$opt), NoItinerary,
|
2013-09-05 23:35:24 +08:00
|
|
|
"dmb", "\t$opt", [(int_arm_dmb (i32 imm0_15:$opt))]>,
|
2013-06-27 00:52:32 +08:00
|
|
|
Requires<[HasDB]> {
|
2010-10-30 08:54:37 +08:00
|
|
|
bits<4> opt;
|
|
|
|
let Inst{31-4} = 0xf3bf8f5;
|
|
|
|
let Inst{3-0} = opt;
|
2009-12-15 02:56:47 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-27 00:52:32 +08:00
|
|
|
def t2DSB : T2I<(outs), (ins memb_opt:$opt), NoItinerary,
|
2013-09-05 23:35:24 +08:00
|
|
|
"dsb", "\t$opt", [(int_arm_dsb (i32 imm0_15:$opt))]>,
|
|
|
|
Requires<[HasDB]> {
|
2010-10-30 08:54:37 +08:00
|
|
|
bits<4> opt;
|
|
|
|
let Inst{31-4} = 0xf3bf8f4;
|
|
|
|
let Inst{3-0} = opt;
|
2010-03-03 08:16:28 +08:00
|
|
|
}
|
|
|
|
|
2013-06-27 00:52:32 +08:00
|
|
|
def t2ISB : T2I<(outs), (ins instsyncb_opt:$opt), NoItinerary,
|
|
|
|
"isb", "\t$opt", []>, Requires<[HasDB]> {
|
2011-09-07 06:53:27 +08:00
|
|
|
bits<4> opt;
|
2010-10-30 08:54:37 +08:00
|
|
|
let Inst{31-4} = 0xf3bf8f6;
|
2011-09-07 06:53:27 +08:00
|
|
|
let Inst{3-0} = opt;
|
2010-03-03 08:16:28 +08:00
|
|
|
}
|
|
|
|
|
2013-08-28 01:38:16 +08:00
|
|
|
class T2I_ldrex<bits<4> opcod, dag oops, dag iops, AddrMode am, int sz,
|
2009-12-16 01:24:14 +08: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;
|
2013-08-28 01:38:16 +08:00
|
|
|
let Inst{7-4} = opcod;
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{3-0} = 0b1111;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2011-03-25 05:04:58 +08:00
|
|
|
bits<4> addr;
|
2010-11-19 08:28:38 +08:00
|
|
|
bits<4> Rt;
|
2011-03-25 05:04:58 +08:00
|
|
|
let Inst{19-16} = addr;
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{15-12} = Rt;
|
2009-12-16 01:24:14 +08:00
|
|
|
}
|
2013-08-28 01:38:16 +08:00
|
|
|
class T2I_strex<bits<4> opcod, dag oops, dag iops, AddrMode am, int sz,
|
2009-12-16 01:24:14 +08: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;
|
2013-08-28 01:38:16 +08:00
|
|
|
let Inst{7-4} = opcod;
|
2010-11-20 01:11:02 +08:00
|
|
|
|
2010-11-19 08:28:38 +08:00
|
|
|
bits<4> Rd;
|
2011-03-25 05:04:58 +08:00
|
|
|
bits<4> addr;
|
2010-11-19 08:28:38 +08:00
|
|
|
bits<4> Rt;
|
2011-03-25 05:04:58 +08:00
|
|
|
let Inst{3-0} = Rd;
|
|
|
|
let Inst{19-16} = addr;
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{15-12} = Rt;
|
2009-12-16 01:24:14 +08:00
|
|
|
}
|
|
|
|
|
2009-12-15 02:56:47 +08:00
|
|
|
let mayLoad = 1 in {
|
2013-08-28 01:38:16 +08:00
|
|
|
def t2LDREXB : T2I_ldrex<0b0100, (outs rGPR:$Rt), (ins addr_offset_none:$addr),
|
2011-07-14 07:22:26 +08:00
|
|
|
AddrModeNone, 4, NoItinerary,
|
2013-07-16 17:46:55 +08:00
|
|
|
"ldrexb", "\t$Rt, $addr", "",
|
|
|
|
[(set rGPR:$Rt, (ldrex_1 addr_offset_none:$addr))]>;
|
2013-08-28 01:38:16 +08:00
|
|
|
def t2LDREXH : T2I_ldrex<0b0101, (outs rGPR:$Rt), (ins addr_offset_none:$addr),
|
2011-07-14 07:22:26 +08:00
|
|
|
AddrModeNone, 4, NoItinerary,
|
2013-07-16 17:46:55 +08:00
|
|
|
"ldrexh", "\t$Rt, $addr", "",
|
|
|
|
[(set rGPR:$Rt, (ldrex_2 addr_offset_none:$addr))]>;
|
2011-09-10 02:37:27 +08:00
|
|
|
def t2LDREX : Thumb2I<(outs rGPR:$Rt), (ins t2addrmode_imm0_1020s4:$addr),
|
2011-07-14 07:22:26 +08:00
|
|
|
AddrModeNone, 4, NoItinerary,
|
2013-07-16 17:46:55 +08:00
|
|
|
"ldrex", "\t$Rt, $addr", "",
|
|
|
|
[(set rGPR:$Rt, (ldrex_4 t2addrmode_imm0_1020s4:$addr))]> {
|
2011-09-10 02:37:27 +08:00
|
|
|
bits<4> Rt;
|
|
|
|
bits<12> addr;
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-20} = 0b0000101;
|
2011-09-10 02:37:27 +08:00
|
|
|
let Inst{19-16} = addr{11-8};
|
2010-12-11 05:52:38 +08:00
|
|
|
let Inst{15-12} = Rt;
|
2011-09-10 02:37:27 +08:00
|
|
|
let Inst{11-8} = 0b1111;
|
|
|
|
let Inst{7-0} = addr{7-0};
|
2009-12-16 01:24:14 +08:00
|
|
|
}
|
2011-05-28 12:07:29 +08:00
|
|
|
let hasExtraDefRegAllocReq = 1 in
|
2013-08-28 01:38:16 +08:00
|
|
|
def t2LDREXD : T2I_ldrex<0b0111, (outs rGPR:$Rt, rGPR:$Rt2),
|
2011-09-10 02:37:27 +08:00
|
|
|
(ins addr_offset_none:$addr),
|
2011-07-14 07:22:26 +08:00
|
|
|
AddrModeNone, 4, NoItinerary,
|
2011-03-25 05:04:58 +08:00
|
|
|
"ldrexd", "\t$Rt, $Rt2, $addr", "",
|
2010-11-19 08:28:38 +08:00
|
|
|
[], {?, ?, ?, ?}> {
|
|
|
|
bits<4> Rt2;
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rt2;
|
2010-11-19 08:28:38 +08:00
|
|
|
}
|
2013-08-28 01:38:16 +08:00
|
|
|
def t2LDAEXB : T2I_ldrex<0b1100, (outs rGPR:$Rt), (ins addr_offset_none:$addr),
|
|
|
|
AddrModeNone, 4, NoItinerary,
|
|
|
|
"ldaexb", "\t$Rt, $addr", "",
|
2014-03-26 22:39:31 +08:00
|
|
|
[(set rGPR:$Rt, (ldaex_1 addr_offset_none:$addr))]>,
|
|
|
|
Requires<[IsThumb, HasV8]>;
|
2013-08-28 01:38:16 +08:00
|
|
|
def t2LDAEXH : T2I_ldrex<0b1101, (outs rGPR:$Rt), (ins addr_offset_none:$addr),
|
|
|
|
AddrModeNone, 4, NoItinerary,
|
|
|
|
"ldaexh", "\t$Rt, $addr", "",
|
2014-03-26 22:39:31 +08:00
|
|
|
[(set rGPR:$Rt, (ldaex_2 addr_offset_none:$addr))]>,
|
|
|
|
Requires<[IsThumb, HasV8]>;
|
2013-08-28 01:38:16 +08:00
|
|
|
def t2LDAEX : Thumb2I<(outs rGPR:$Rt), (ins addr_offset_none:$addr),
|
|
|
|
AddrModeNone, 4, NoItinerary,
|
|
|
|
"ldaex", "\t$Rt, $addr", "",
|
2014-03-26 22:39:31 +08:00
|
|
|
[(set rGPR:$Rt, (ldaex_4 addr_offset_none:$addr))]>,
|
|
|
|
Requires<[IsThumb, HasV8]> {
|
2013-08-28 01:38:16 +08:00
|
|
|
bits<4> Rt;
|
|
|
|
bits<4> addr;
|
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-20} = 0b0001101;
|
|
|
|
let Inst{19-16} = addr;
|
|
|
|
let Inst{15-12} = Rt;
|
|
|
|
let Inst{11-8} = 0b1111;
|
|
|
|
let Inst{7-0} = 0b11101111;
|
|
|
|
}
|
|
|
|
let hasExtraDefRegAllocReq = 1 in
|
|
|
|
def t2LDAEXD : T2I_ldrex<0b1111, (outs rGPR:$Rt, rGPR:$Rt2),
|
|
|
|
(ins addr_offset_none:$addr),
|
|
|
|
AddrModeNone, 4, NoItinerary,
|
|
|
|
"ldaexd", "\t$Rt, $Rt2, $addr", "",
|
2013-08-28 22:33:35 +08:00
|
|
|
[], {?, ?, ?, ?}>, Requires<[IsThumb, HasV8]> {
|
2013-08-28 01:38:16 +08:00
|
|
|
bits<4> Rt2;
|
|
|
|
let Inst{11-8} = Rt2;
|
|
|
|
|
|
|
|
let Inst{7} = 1;
|
|
|
|
}
|
2009-12-15 02:56:47 +08:00
|
|
|
}
|
|
|
|
|
2010-11-19 08:28:38 +08:00
|
|
|
let mayStore = 1, Constraints = "@earlyclobber $Rd" in {
|
2013-08-28 01:38:16 +08:00
|
|
|
def t2STREXB : T2I_strex<0b0100, (outs rGPR:$Rd),
|
2011-09-10 02:37:27 +08:00
|
|
|
(ins rGPR:$Rt, addr_offset_none:$addr),
|
2011-07-14 07:22:26 +08:00
|
|
|
AddrModeNone, 4, NoItinerary,
|
2013-07-16 17:46:55 +08:00
|
|
|
"strexb", "\t$Rd, $Rt, $addr", "",
|
2014-03-26 22:39:31 +08:00
|
|
|
[(set rGPR:$Rd,
|
|
|
|
(strex_1 rGPR:$Rt, addr_offset_none:$addr))]>;
|
2013-08-28 01:38:16 +08:00
|
|
|
def t2STREXH : T2I_strex<0b0101, (outs rGPR:$Rd),
|
2011-09-10 02:37:27 +08:00
|
|
|
(ins rGPR:$Rt, addr_offset_none:$addr),
|
2011-07-14 07:22:26 +08:00
|
|
|
AddrModeNone, 4, NoItinerary,
|
2013-07-16 17:46:55 +08:00
|
|
|
"strexh", "\t$Rd, $Rt, $addr", "",
|
2014-03-26 22:39:31 +08:00
|
|
|
[(set rGPR:$Rd,
|
|
|
|
(strex_2 rGPR:$Rt, addr_offset_none:$addr))]>;
|
2013-07-16 17:46:55 +08:00
|
|
|
|
2011-09-10 02:37:27 +08:00
|
|
|
def t2STREX : Thumb2I<(outs rGPR:$Rd), (ins rGPR:$Rt,
|
|
|
|
t2addrmode_imm0_1020s4:$addr),
|
2011-07-14 07:22:26 +08:00
|
|
|
AddrModeNone, 4, NoItinerary,
|
2011-03-25 05:04:58 +08:00
|
|
|
"strex", "\t$Rd, $Rt, $addr", "",
|
2014-03-26 22:39:31 +08:00
|
|
|
[(set rGPR:$Rd,
|
|
|
|
(strex_4 rGPR:$Rt, t2addrmode_imm0_1020s4:$addr))]> {
|
2010-12-11 05:52:38 +08:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rt;
|
2011-09-10 02:37:27 +08:00
|
|
|
bits<12> addr;
|
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-20} = 0b0000100;
|
|
|
|
let Inst{19-16} = addr{11-8};
|
2010-12-11 05:52:38 +08:00
|
|
|
let Inst{15-12} = Rt;
|
2011-09-10 02:37:27 +08:00
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{7-0} = addr{7-0};
|
2009-12-16 01:24:14 +08:00
|
|
|
}
|
2012-01-24 06:57:52 +08:00
|
|
|
let hasExtraSrcRegAllocReq = 1 in
|
2013-08-28 01:38:16 +08:00
|
|
|
def t2STREXD : T2I_strex<0b0111, (outs rGPR:$Rd),
|
2011-09-10 02:37:27 +08:00
|
|
|
(ins rGPR:$Rt, rGPR:$Rt2, addr_offset_none:$addr),
|
2011-07-14 07:22:26 +08:00
|
|
|
AddrModeNone, 4, NoItinerary,
|
2011-03-25 05:04:58 +08:00
|
|
|
"strexd", "\t$Rd, $Rt, $Rt2, $addr", "", [],
|
2010-11-19 08:28:38 +08:00
|
|
|
{?, ?, ?, ?}> {
|
|
|
|
bits<4> Rt2;
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rt2;
|
2010-11-19 08:28:38 +08:00
|
|
|
}
|
2013-08-28 01:38:16 +08:00
|
|
|
def t2STLEXB : T2I_strex<0b1100, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rt, addr_offset_none:$addr),
|
|
|
|
AddrModeNone, 4, NoItinerary,
|
|
|
|
"stlexb", "\t$Rd, $Rt, $addr", "",
|
2014-03-26 22:39:31 +08:00
|
|
|
[(set rGPR:$Rd,
|
|
|
|
(stlex_1 rGPR:$Rt, addr_offset_none:$addr))]>,
|
|
|
|
Requires<[IsThumb, HasV8]>;
|
2013-08-28 01:38:16 +08:00
|
|
|
|
|
|
|
def t2STLEXH : T2I_strex<0b1101, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rt, addr_offset_none:$addr),
|
|
|
|
AddrModeNone, 4, NoItinerary,
|
|
|
|
"stlexh", "\t$Rd, $Rt, $addr", "",
|
2014-03-26 22:39:31 +08:00
|
|
|
[(set rGPR:$Rd,
|
|
|
|
(stlex_2 rGPR:$Rt, addr_offset_none:$addr))]>,
|
|
|
|
Requires<[IsThumb, HasV8]>;
|
2013-08-28 01:38:16 +08:00
|
|
|
|
|
|
|
def t2STLEX : Thumb2I<(outs rGPR:$Rd), (ins rGPR:$Rt,
|
|
|
|
addr_offset_none:$addr),
|
|
|
|
AddrModeNone, 4, NoItinerary,
|
|
|
|
"stlex", "\t$Rd, $Rt, $addr", "",
|
2014-03-26 22:39:31 +08:00
|
|
|
[(set rGPR:$Rd,
|
|
|
|
(stlex_4 rGPR:$Rt, addr_offset_none:$addr))]>,
|
|
|
|
Requires<[IsThumb, HasV8]> {
|
2013-08-28 01:38:16 +08:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<4> Rt;
|
|
|
|
bits<4> addr;
|
|
|
|
let Inst{31-27} = 0b11101;
|
|
|
|
let Inst{26-20} = 0b0001100;
|
|
|
|
let Inst{19-16} = addr;
|
|
|
|
let Inst{15-12} = Rt;
|
|
|
|
let Inst{11-4} = 0b11111110;
|
|
|
|
let Inst{3-0} = Rd;
|
|
|
|
}
|
|
|
|
let hasExtraSrcRegAllocReq = 1 in
|
|
|
|
def t2STLEXD : T2I_strex<0b1111, (outs rGPR:$Rd),
|
|
|
|
(ins rGPR:$Rt, rGPR:$Rt2, addr_offset_none:$addr),
|
|
|
|
AddrModeNone, 4, NoItinerary,
|
|
|
|
"stlexd", "\t$Rd, $Rt, $Rt2, $addr", "", [],
|
|
|
|
{?, ?, ?, ?}>, Requires<[IsThumb, HasV8]> {
|
|
|
|
bits<4> Rt2;
|
|
|
|
let Inst{11-8} = Rt2;
|
|
|
|
}
|
2012-01-24 06:57:52 +08:00
|
|
|
}
|
2009-12-15 02:56:47 +08:00
|
|
|
|
2013-07-16 17:46:55 +08:00
|
|
|
def t2CLREX : T2I<(outs), (ins), NoItinerary, "clrex", "", [(int_arm_clrex)]>,
|
2011-01-21 03:18:32 +08:00
|
|
|
Requires<[IsThumb2, HasV7]> {
|
|
|
|
let Inst{31-16} = 0xf3bf;
|
2010-03-03 06:11:06 +08:00
|
|
|
let Inst{15-14} = 0b10;
|
2011-01-21 03:18:32 +08:00
|
|
|
let Inst{13} = 0;
|
2010-03-03 06:11:06 +08:00
|
|
|
let Inst{12} = 0;
|
2011-01-21 03:18:32 +08:00
|
|
|
let Inst{11-8} = 0b1111;
|
2010-03-03 06:11:06 +08:00
|
|
|
let Inst{7-4} = 0b0010;
|
2011-01-21 03:18:32 +08:00
|
|
|
let Inst{3-0} = 0b1111;
|
2010-03-03 06:11:06 +08:00
|
|
|
}
|
|
|
|
|
2013-07-16 17:46:55 +08:00
|
|
|
def : T2Pat<(and (ldrex_1 addr_offset_none:$addr), 0xff),
|
|
|
|
(t2LDREXB addr_offset_none:$addr)>;
|
|
|
|
def : T2Pat<(and (ldrex_2 addr_offset_none:$addr), 0xffff),
|
|
|
|
(t2LDREXH addr_offset_none:$addr)>;
|
|
|
|
def : T2Pat<(strex_1 (and GPR:$Rt, 0xff), addr_offset_none:$addr),
|
|
|
|
(t2STREXB GPR:$Rt, addr_offset_none:$addr)>;
|
|
|
|
def : T2Pat<(strex_2 (and GPR:$Rt, 0xffff), addr_offset_none:$addr),
|
|
|
|
(t2STREXH GPR:$Rt, addr_offset_none:$addr)>;
|
|
|
|
|
2014-03-26 22:39:31 +08:00
|
|
|
def : T2Pat<(and (ldaex_1 addr_offset_none:$addr), 0xff),
|
|
|
|
(t2LDAEXB addr_offset_none:$addr)>;
|
|
|
|
def : T2Pat<(and (ldaex_2 addr_offset_none:$addr), 0xffff),
|
|
|
|
(t2LDAEXH addr_offset_none:$addr)>;
|
|
|
|
def : T2Pat<(stlex_1 (and GPR:$Rt, 0xff), addr_offset_none:$addr),
|
|
|
|
(t2STLEXB GPR:$Rt, addr_offset_none:$addr)>;
|
|
|
|
def : T2Pat<(stlex_2 (and GPR:$Rt, 0xffff), addr_offset_none:$addr),
|
|
|
|
(t2STLEXH GPR:$Rt, addr_offset_none:$addr)>;
|
|
|
|
|
2009-08-12 03:42:21 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SJLJ Exception handling intrinsics
|
2009-08-13 23:11:43 +08:00
|
|
|
// eh_sjlj_setjmp() is an instruction sequence to store the return
|
2009-08-12 03:42:21 +08: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 13:18:47 +08:00
|
|
|
// when we get here from a longjmp(). We force everything out of registers
|
2009-08-12 03:42:21 +08: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-28 07:49:24 +08:00
|
|
|
// $val is a scratch register for our use.
|
2010-02-09 07:22:00 +08:00
|
|
|
let Defs =
|
2011-06-07 08:08:49 +08:00
|
|
|
[ R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, LR, CPSR,
|
2012-01-14 06:55:42 +08:00
|
|
|
Q0, Q1, Q2, Q3, Q8, Q9, Q10, Q11, Q12, Q13, Q14, Q15],
|
2011-10-18 06:26:23 +08:00
|
|
|
hasSideEffects = 1, isBarrier = 1, isCodeGenOnly = 1,
|
|
|
|
usesCustomInserter = 1 in {
|
2010-08-27 01:02:47 +08:00
|
|
|
def t2Int_eh_sjlj_setjmp : Thumb2XI<(outs), (ins tGPR:$src, tGPR:$val),
|
2011-07-14 07:22:26 +08:00
|
|
|
AddrModeNone, 0, NoItinerary, "", "",
|
2010-08-27 01:02:47 +08:00
|
|
|
[(set R0, (ARMeh_sjlj_setjmp tGPR:$src, tGPR:$val))]>,
|
2010-04-10 04:41:18 +08:00
|
|
|
Requires<[IsThumb2, HasVFP2]>;
|
2009-08-12 03:42:21 +08:00
|
|
|
}
|
|
|
|
|
2010-04-10 04:41:18 +08:00
|
|
|
let Defs =
|
2011-06-07 08:08:49 +08:00
|
|
|
[ R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, LR, CPSR ],
|
2011-10-18 06:26:23 +08:00
|
|
|
hasSideEffects = 1, isBarrier = 1, isCodeGenOnly = 1,
|
|
|
|
usesCustomInserter = 1 in {
|
2010-08-27 01:02:47 +08:00
|
|
|
def t2Int_eh_sjlj_setjmp_nofp : Thumb2XI<(outs), (ins tGPR:$src, tGPR:$val),
|
2011-07-14 07:22:26 +08:00
|
|
|
AddrModeNone, 0, NoItinerary, "", "",
|
2010-08-27 01:02:47 +08:00
|
|
|
[(set R0, (ARMeh_sjlj_setjmp tGPR:$src, tGPR:$val))]>,
|
2010-04-10 04:41:18 +08:00
|
|
|
Requires<[IsThumb2, NoVFP]>;
|
|
|
|
}
|
2009-08-12 03:42:21 +08:00
|
|
|
|
|
|
|
|
2009-07-01 02:04:13 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Control-Flow Instructions
|
|
|
|
//
|
|
|
|
|
2009-07-10 06:58:39 +08: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 16:22:27 +08:00
|
|
|
let isReturn = 1, isTerminator = 1, isBarrier = 1, mayLoad = 1,
|
2010-11-01 03:10:56 +08:00
|
|
|
hasExtraDefRegAllocReq = 1, isCodeGenOnly = 1 in
|
2011-07-09 01:40:42 +08:00
|
|
|
def t2LDMIA_RET: t2PseudoExpand<(outs GPR:$wb), (ins GPR:$Rn, pred:$p,
|
2011-07-01 02:25:42 +08:00
|
|
|
reglist:$regs, variable_ops),
|
2011-07-14 07:22:26 +08:00
|
|
|
4, IIC_iLoad_mBr, [],
|
2011-07-09 01:40:42 +08:00
|
|
|
(t2LDMIA_UPD GPR:$wb, GPR:$Rn, pred:$p, reglist:$regs)>,
|
2011-07-01 02:25:42 +08:00
|
|
|
RegConstraint<"$Rn = $wb">;
|
2009-07-10 06:58:39 +08:00
|
|
|
|
2009-07-01 02:04:13 +08:00
|
|
|
let isBranch = 1, isTerminator = 1, isBarrier = 1 in {
|
|
|
|
let isPredicable = 1 in
|
2011-09-10 05:48:23 +08:00
|
|
|
def t2B : T2I<(outs), (ins uncondbrtarget:$target), IIC_Br,
|
|
|
|
"b", ".w\t$target",
|
2013-06-07 02:42:09 +08:00
|
|
|
[(br bb:$target)]>, Sched<[WriteBr]> {
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{15-14} = 0b10;
|
|
|
|
let Inst{12} = 1;
|
2010-11-30 02:54:38 +08:00
|
|
|
|
2012-10-30 07:27:20 +08:00
|
|
|
bits<24> target;
|
2013-08-09 18:38:32 +08:00
|
|
|
let Inst{26} = target{23};
|
|
|
|
let Inst{13} = target{22};
|
|
|
|
let Inst{11} = target{21};
|
2012-10-30 07:27:20 +08:00
|
|
|
let Inst{25-16} = target{20-11};
|
2010-11-30 02:54:38 +08:00
|
|
|
let Inst{10-0} = target{10-0};
|
2012-04-13 07:13:34 +08:00
|
|
|
let DecoderMethod = "DecodeT2BInstruction";
|
2014-04-04 07:43:18 +08:00
|
|
|
let AsmMatchConverter = "cvtThumbBranches";
|
|
|
|
}
|
2009-07-01 02:04:13 +08:00
|
|
|
|
2010-11-30 06:40:58 +08:00
|
|
|
let isNotDuplicable = 1, isIndirectBranch = 1 in {
|
2010-12-16 03:03:16 +08:00
|
|
|
def t2BR_JT : t2PseudoInst<(outs),
|
2010-11-30 06:37:40 +08:00
|
|
|
(ins GPR:$target, GPR:$index, i32imm:$jt, i32imm:$id),
|
2011-07-14 07:22:26 +08:00
|
|
|
0, IIC_Br,
|
2013-06-07 02:42:09 +08:00
|
|
|
[(ARMbr2jt GPR:$target, GPR:$index, tjumptable:$jt, imm:$id)]>,
|
|
|
|
Sched<[WriteBr]>;
|
2009-07-29 10:18:14 +08:00
|
|
|
|
2009-08-01 14:13:52 +08:00
|
|
|
// FIXME: Add a non-pc based case that can be predicated.
|
2010-12-16 03:03:16 +08:00
|
|
|
def t2TBB_JT : t2PseudoInst<(outs),
|
2013-06-07 02:42:09 +08:00
|
|
|
(ins GPR:$index, i32imm:$jt, i32imm:$id), 0, IIC_Br, []>,
|
|
|
|
Sched<[WriteBr]>;
|
2009-07-29 10:18:14 +08:00
|
|
|
|
2010-12-16 03:03:16 +08:00
|
|
|
def t2TBH_JT : t2PseudoInst<(outs),
|
2013-06-07 02:42:09 +08:00
|
|
|
(ins GPR:$index, i32imm:$jt, i32imm:$id), 0, IIC_Br, []>,
|
|
|
|
Sched<[WriteBr]>;
|
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.
llvm-svn: 97573
2010-03-03 02:14:57 +08:00
|
|
|
|
2011-09-20 06:21:13 +08:00
|
|
|
def t2TBB : T2I<(outs), (ins addrmode_tbb:$addr), IIC_Br,
|
2013-06-07 02:42:09 +08:00
|
|
|
"tbb", "\t$addr", []>, Sched<[WriteBrTbl]> {
|
2010-11-30 06:37:40 +08:00
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
2010-12-18 02:42:56 +08:00
|
|
|
let Inst{31-20} = 0b111010001101;
|
2010-11-30 06:37:40 +08:00
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{15-5} = 0b11110000000;
|
|
|
|
let Inst{4} = 0; // B form
|
|
|
|
let Inst{3-0} = Rm;
|
2011-09-20 06:21:13 +08:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeThumbTableBranch";
|
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.
llvm-svn: 97573
2010-03-03 02:14:57 +08:00
|
|
|
}
|
|
|
|
|
2011-09-20 06:21:13 +08:00
|
|
|
def t2TBH : T2I<(outs), (ins addrmode_tbh:$addr), IIC_Br,
|
2013-06-07 02:42:09 +08:00
|
|
|
"tbh", "\t$addr", []>, Sched<[WriteBrTbl]> {
|
2010-11-30 06:37:40 +08:00
|
|
|
bits<4> Rn;
|
|
|
|
bits<4> Rm;
|
2010-12-18 02:42:56 +08:00
|
|
|
let Inst{31-20} = 0b111010001101;
|
2010-11-30 06:37:40 +08:00
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{15-5} = 0b11110000000;
|
|
|
|
let Inst{4} = 1; // H form
|
|
|
|
let Inst{3-0} = Rm;
|
2011-09-20 06:21:13 +08:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeThumbTableBranch";
|
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.
llvm-svn: 97573
2010-03-03 02:14:57 +08:00
|
|
|
}
|
2009-07-29 10:18:14 +08:00
|
|
|
} // isNotDuplicable, isIndirectBranch
|
|
|
|
|
2009-07-01 03:50:22 +08:00
|
|
|
} // isBranch, isTerminator, isBarrier
|
2009-07-01 02:04:13 +08:00
|
|
|
|
|
|
|
// FIXME: should be able to write a pattern for ARMBrcond, but can't use
|
2011-09-10 05:48:23 +08:00
|
|
|
// a two-value operand where a dag node expects ", "two operands. :(
|
2009-07-01 02:04:13 +08:00
|
|
|
let isBranch = 1, isTerminator = 1 in
|
2009-08-07 00:52:47 +08:00
|
|
|
def t2Bcc : T2I<(outs), (ins brtarget:$target), IIC_Br,
|
2009-10-27 08:08:59 +08:00
|
|
|
"b", ".w\t$target",
|
2013-06-07 02:42:09 +08:00
|
|
|
[/*(ARMbrcond bb:$target, imm:$cc)*/]>, Sched<[WriteBr]> {
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{15-14} = 0b10;
|
|
|
|
let Inst{12} = 0;
|
2010-12-15 04:46:39 +08:00
|
|
|
|
2010-12-09 08:27:41 +08: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-10 04:55:18 +08:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeThumb2BCCInstruction";
|
2013-08-09 18:38:32 +08:00
|
|
|
let AsmMatchConverter = "cvtThumbBranches";
|
2009-12-16 01:24:14 +08:00
|
|
|
}
|
2009-06-24 01:48:47 +08:00
|
|
|
|
2014-01-06 22:28:05 +08:00
|
|
|
// Tail calls. The MachO version of thumb tail calls uses a t2 branch, so
|
2011-07-09 04:32:21 +08:00
|
|
|
// it goes here.
|
|
|
|
let isCall = 1, isTerminator = 1, isReturn = 1, isBarrier = 1 in {
|
2011-12-21 02:26:50 +08:00
|
|
|
// IOS version.
|
2012-02-24 09:19:29 +08:00
|
|
|
let Uses = [SP] in
|
2011-09-10 05:48:23 +08:00
|
|
|
def tTAILJMPd: tPseudoExpand<(outs),
|
2012-07-14 04:27:00 +08:00
|
|
|
(ins uncondbrtarget:$dst, pred:$p),
|
2011-07-14 07:22:26 +08:00
|
|
|
4, IIC_Br, [],
|
2011-09-10 05:48:23 +08:00
|
|
|
(t2B uncondbrtarget:$dst, pred:$p)>,
|
2014-01-06 22:28:05 +08:00
|
|
|
Requires<[IsThumb2, IsMachO]>, Sched<[WriteBr]>;
|
2011-07-09 04:32:21 +08:00
|
|
|
}
|
2009-07-10 09:54:42 +08:00
|
|
|
|
|
|
|
// IT block
|
2010-06-19 07:09:54 +08:00
|
|
|
let Defs = [ITSTATE] in
|
2009-07-10 09:54:42 +08:00
|
|
|
def t2IT : Thumb2XI<(outs), (ins it_pred:$cc, it_mask:$mask),
|
2011-07-14 07:22:26 +08:00
|
|
|
AddrModeNone, 2, IIC_iALUx,
|
2013-10-03 17:31:51 +08:00
|
|
|
"it$mask\t$cc", "", []>,
|
|
|
|
ComplexDeprecationPredicate<"IT"> {
|
2009-12-16 01:24:14 +08:00
|
|
|
// 16-bit instruction.
|
2009-12-16 10:32:54 +08:00
|
|
|
let Inst{31-16} = 0x0000;
|
2009-12-16 01:24:14 +08:00
|
|
|
let Inst{15-8} = 0b10111111;
|
2010-11-30 02:54:38 +08:00
|
|
|
|
|
|
|
bits<4> cc;
|
|
|
|
bits<4> mask;
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{7-4} = cc;
|
|
|
|
let Inst{3-0} = mask;
|
2011-08-31 06:58:27 +08:00
|
|
|
|
|
|
|
let DecoderMethod = "DecodeIT";
|
2009-12-16 01:24:14 +08:00
|
|
|
}
|
2009-07-10 09:54:42 +08:00
|
|
|
|
2010-02-26 03:05:29 +08:00
|
|
|
// Branch and Exchange Jazelle -- for disassembly only
|
|
|
|
// Rm = Inst{19-16}
|
2013-06-07 02:42:09 +08:00
|
|
|
def t2BXJ : T2I<(outs), (ins rGPR:$func), NoItinerary, "bxj", "\t$func", []>,
|
|
|
|
Sched<[WriteBr]> {
|
2011-09-03 07:43:09 +08:00
|
|
|
bits<4> func;
|
2010-02-26 03:05:29 +08:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{26} = 0;
|
|
|
|
let Inst{25-20} = 0b111100;
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{19-16} = func;
|
2011-09-03 07:43:09 +08:00
|
|
|
let Inst{15-0} = 0b1000111100000000;
|
2010-02-26 03:05:29 +08:00
|
|
|
}
|
|
|
|
|
2011-08-19 01:51:36 +08: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,?,?,?}>,
|
2013-06-07 02:42:09 +08:00
|
|
|
Requires<[IsThumb2]>, Sched<[WriteBr]> {
|
2011-08-19 01:51:36 +08:00
|
|
|
// 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,?,?,?}>,
|
2013-06-07 02:42:09 +08:00
|
|
|
Requires<[IsThumb2]>, Sched<[WriteBr]> {
|
2011-08-19 01:51:36 +08:00
|
|
|
// 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-09-20 07:38:34 +08:00
|
|
|
// Change Processor State is a system instruction.
|
2011-02-14 21:09:44 +08:00
|
|
|
// 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,
|
2011-09-20 07:38:34 +08:00
|
|
|
!strconcat("cps", asm_op), []> {
|
2011-02-14 21:09:44 +08:00
|
|
|
bits<2> imod;
|
|
|
|
bits<3> iflags;
|
|
|
|
bits<5> mode;
|
|
|
|
bit M;
|
|
|
|
|
2013-04-27 01:54:54 +08:00
|
|
|
let Inst{31-11} = 0b111100111010111110000;
|
2011-02-14 21:09:44 +08:00
|
|
|
let Inst{10-9} = imod;
|
|
|
|
let Inst{8} = M;
|
|
|
|
let Inst{7-5} = iflags;
|
|
|
|
let Inst{4-0} = mode;
|
2011-08-24 01:45:18 +08:00
|
|
|
let DecoderMethod = "DecodeT2CPSInstruction";
|
2011-02-14 21:09:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
let M = 1 in
|
|
|
|
def t2CPS3p : t2CPS<(ins imod_op:$imod, iflags_op:$iflags, i32imm:$mode),
|
2013-08-09 21:52:32 +08:00
|
|
|
"$imod\t$iflags, $mode">;
|
2011-02-14 21:09:44 +08:00
|
|
|
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
|
2011-09-20 07:58:31 +08:00
|
|
|
def t2CPS1p : t2CPS<(ins imm0_31:$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.
llvm-svn: 97573
2010-03-03 02:14:57 +08:00
|
|
|
|
2013-08-09 21:52:32 +08:00
|
|
|
def : t2InstAlias<"cps$imod.w $iflags, $mode",
|
|
|
|
(t2CPS3p imod_op:$imod, iflags_op:$iflags, i32imm:$mode), 0>;
|
|
|
|
def : t2InstAlias<"cps.w $mode", (t2CPS1p imm0_31:$mode), 0>;
|
|
|
|
|
2010-03-03 10:09:43 +08:00
|
|
|
// A6.3.4 Branches and miscellaneous control
|
|
|
|
// Table A6-14 Change Processor State, and hint instructions
|
2013-10-23 18:14:40 +08:00
|
|
|
def t2HINT : T2I<(outs), (ins imm0_239:$imm), NoItinerary, "hint", ".w\t$imm",[]> {
|
|
|
|
bits<8> imm;
|
2013-04-27 01:54:54 +08:00
|
|
|
let Inst{31-3} = 0b11110011101011111000000000000;
|
2013-10-23 18:14:40 +08:00
|
|
|
let Inst{7-0} = imm;
|
2012-06-19 03:45:50 +08:00
|
|
|
}
|
|
|
|
|
2013-10-23 18:14:40 +08:00
|
|
|
def : t2InstAlias<"hint$p $imm", (t2HINT imm0_239:$imm, pred:$p)>;
|
2012-06-19 03:45:50 +08:00
|
|
|
def : t2InstAlias<"nop$p.w", (t2HINT 0, pred:$p)>;
|
|
|
|
def : t2InstAlias<"yield$p.w", (t2HINT 1, pred:$p)>;
|
|
|
|
def : t2InstAlias<"wfe$p.w", (t2HINT 2, pred:$p)>;
|
|
|
|
def : t2InstAlias<"wfi$p.w", (t2HINT 3, pred:$p)>;
|
|
|
|
def : t2InstAlias<"sev$p.w", (t2HINT 4, pred:$p)>;
|
2013-10-01 20:39:11 +08:00
|
|
|
def : t2InstAlias<"sevl$p.w", (t2HINT 5, pred:$p)> {
|
|
|
|
let Predicates = [IsThumb2, HasV8];
|
|
|
|
}
|
2010-03-03 10:09:43 +08:00
|
|
|
|
2011-07-14 06:59:38 +08:00
|
|
|
def t2DBG : T2I<(outs), (ins imm0_15:$opt), NoItinerary, "dbg", "\t$opt", []> {
|
2010-12-01 04:00:01 +08:00
|
|
|
bits<4> opt;
|
2011-09-07 06:06:40 +08:00
|
|
|
let Inst{31-20} = 0b111100111010;
|
|
|
|
let Inst{19-16} = 0b1111;
|
|
|
|
let Inst{15-8} = 0b10000000;
|
|
|
|
let Inst{7-4} = 0b1111;
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{3-0} = opt;
|
2010-03-03 10:09:43 +08:00
|
|
|
}
|
|
|
|
|
2011-09-20 07:38:34 +08:00
|
|
|
// Secure Monitor Call is a system instruction.
|
2010-02-26 04:25:24 +08:00
|
|
|
// Option = Inst{19-16}
|
2014-04-04 07:43:18 +08:00
|
|
|
def t2SMC : T2I<(outs), (ins imm0_15:$opt), NoItinerary, "smc", "\t$opt",
|
2013-04-10 20:08:35 +08:00
|
|
|
[]>, Requires<[IsThumb2, HasTrustZone]> {
|
2010-02-26 04:25:24 +08:00
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{26-20} = 0b1111111;
|
|
|
|
let Inst{15-12} = 0b1000;
|
2010-12-03 07:05:38 +08:00
|
|
|
|
2010-11-30 03:22:08 +08:00
|
|
|
bits<4> opt;
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{19-16} = opt;
|
2010-11-30 03:22:08 +08:00
|
|
|
}
|
|
|
|
|
2013-09-05 22:14:19 +08:00
|
|
|
class T2DCPS<bits<2> opt, string opc>
|
|
|
|
: T2I<(outs), (ins), NoItinerary, opc, "", []>, Requires<[IsThumb2, HasV8]> {
|
|
|
|
let Inst{31-27} = 0b11110;
|
|
|
|
let Inst{26-20} = 0b1111000;
|
|
|
|
let Inst{19-16} = 0b1111;
|
|
|
|
let Inst{15-12} = 0b1000;
|
|
|
|
let Inst{11-2} = 0b0000000000;
|
|
|
|
let Inst{1-0} = opt;
|
|
|
|
}
|
|
|
|
|
|
|
|
def t2DCPS1 : T2DCPS<0b01, "dcps1">;
|
|
|
|
def t2DCPS2 : T2DCPS<0b10, "dcps2">;
|
|
|
|
def t2DCPS3 : T2DCPS<0b11, "dcps3">;
|
|
|
|
|
2011-09-17 02:25:22 +08:00
|
|
|
class T2SRS<bits<2> Op, bit W, dag oops, dag iops, InstrItinClass itin,
|
|
|
|
string opc, string asm, list<dag> pattern>
|
2010-11-30 03:22:08 +08:00
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
|
|
|
bits<5> mode;
|
2011-09-17 02:25:22 +08: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-30 03:22:08 +08:00
|
|
|
let Inst{4-0} = mode{4-0};
|
2010-02-26 04:25:24 +08:00
|
|
|
}
|
|
|
|
|
2011-09-17 02:25:22 +08: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-30 03:22:08 +08:00
|
|
|
|
2013-02-23 08:52:09 +08:00
|
|
|
|
|
|
|
def : t2InstAlias<"srsdb${p} $mode", (t2SRSDB imm0_31:$mode, pred:$p)>;
|
|
|
|
def : t2InstAlias<"srsdb${p} $mode!", (t2SRSDB_UPD imm0_31:$mode, pred:$p)>;
|
|
|
|
|
|
|
|
def : t2InstAlias<"srsia${p} $mode", (t2SRSIA imm0_31:$mode, pred:$p)>;
|
|
|
|
def : t2InstAlias<"srsia${p} $mode!", (t2SRSIA_UPD imm0_31:$mode, pred:$p)>;
|
|
|
|
|
2011-09-17 02:25:22 +08:00
|
|
|
// Return From Exception is a system instruction.
|
2010-11-30 04:38:48 +08:00
|
|
|
class T2RFE<bits<12> op31_20, dag oops, dag iops, InstrItinClass itin,
|
2010-11-30 03:22:08 +08:00
|
|
|
string opc, string asm, list<dag> pattern>
|
|
|
|
: T2I<oops, iops, itin, opc, asm, pattern> {
|
2010-11-30 04:38:48 +08:00
|
|
|
let Inst{31-20} = op31_20{11-0};
|
2010-12-03 07:05:38 +08:00
|
|
|
|
2010-11-30 03:22:08 +08:00
|
|
|
bits<4> Rn;
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{19-16} = Rn;
|
2011-04-13 05:41:51 +08:00
|
|
|
let Inst{15-0} = 0xc000;
|
2010-11-30 03:22:08 +08:00
|
|
|
}
|
|
|
|
|
2010-11-30 04:38:48 +08:00
|
|
|
def t2RFEDBW : T2RFE<0b111010000011,
|
2011-04-13 05:41:51 +08:00
|
|
|
(outs), (ins GPR:$Rn), NoItinerary, "rfedb", "\t$Rn!",
|
2010-11-30 04:38:48 +08:00
|
|
|
[/* For disassembly only; pattern left blank */]>;
|
|
|
|
def t2RFEDB : T2RFE<0b111010000001,
|
2011-04-13 05:41:51 +08:00
|
|
|
(outs), (ins GPR:$Rn), NoItinerary, "rfedb", "\t$Rn",
|
2010-11-30 04:38:48 +08:00
|
|
|
[/* For disassembly only; pattern left blank */]>;
|
|
|
|
def t2RFEIAW : T2RFE<0b111010011011,
|
2011-04-13 05:41:51 +08:00
|
|
|
(outs), (ins GPR:$Rn), NoItinerary, "rfeia", "\t$Rn!",
|
2010-11-30 04:38:48 +08:00
|
|
|
[/* For disassembly only; pattern left blank */]>;
|
|
|
|
def t2RFEIA : T2RFE<0b111010011001,
|
2011-04-13 05:41:51 +08:00
|
|
|
(outs), (ins GPR:$Rn), NoItinerary, "rfeia", "\t$Rn",
|
2010-11-30 04:38:48 +08:00
|
|
|
[/* For disassembly only; pattern left blank */]>;
|
2010-02-26 04:25:24 +08:00
|
|
|
|
2013-08-01 05:05:30 +08:00
|
|
|
// B9.3.19 SUBS PC, LR, #imm (Thumb2) system instruction.
|
2013-10-01 22:33:28 +08:00
|
|
|
// Exception return instruction is "subs pc, lr, #imm".
|
|
|
|
let isReturn = 1, isBarrier = 1, isTerminator = 1, Defs = [PC] in
|
2013-08-01 05:05:30 +08:00
|
|
|
def t2SUBS_PC_LR : T2I <(outs), (ins imm0_255:$imm), NoItinerary,
|
2013-10-01 22:33:28 +08:00
|
|
|
"subs", "\tpc, lr, $imm",
|
|
|
|
[(ARMintretflag imm0_255:$imm)]>,
|
|
|
|
Requires<[IsThumb2]> {
|
2013-08-01 05:05:30 +08:00
|
|
|
let Inst{31-8} = 0b111100111101111010001111;
|
|
|
|
|
|
|
|
bits<8> imm;
|
|
|
|
let Inst{7-0} = imm;
|
|
|
|
}
|
|
|
|
|
2009-06-24 01:48:47 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Non-Instruction Patterns
|
|
|
|
//
|
|
|
|
|
2009-09-28 17:14:39 +08:00
|
|
|
// 32-bit immediate using movw + movt.
|
2010-09-25 06:03:46 +08:00
|
|
|
// This is a single pseudo instruction to make it re-materializable.
|
|
|
|
// FIXME: Remove this when we can do generalized remat.
|
2011-01-19 10:16:49 +08:00
|
|
|
let isReMaterializable = 1, isMoveImm = 1 in
|
2010-10-07 06:01:26 +08:00
|
|
|
def t2MOVi32imm : PseudoInst<(outs rGPR:$dst), (ins i32imm:$src), IIC_iMOVix2,
|
2010-11-18 09:38:26 +08:00
|
|
|
[(set rGPR:$dst, (i32 imm:$src))]>,
|
2014-01-23 21:43:47 +08:00
|
|
|
Requires<[IsThumb, UseMovt]>;
|
2009-11-07 07:52:48 +08:00
|
|
|
|
2011-01-22 02:55:51 +08:00
|
|
|
// Pseudo instruction that combines movw + movt + add pc (if pic).
|
2011-01-20 16:34:58 +08: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-22 02:55:51 +08:00
|
|
|
let isReMaterializable = 1 in {
|
|
|
|
def t2MOV_ga_pcrel : PseudoInst<(outs rGPR:$dst), (ins i32imm:$addr),
|
|
|
|
IIC_iMOVix2addpc,
|
2011-01-20 16:34:58 +08:00
|
|
|
[(set rGPR:$dst, (ARMWrapperPIC tglobaladdr:$addr))]>,
|
|
|
|
Requires<[IsThumb2, UseMovt]>;
|
2011-01-17 16:03:18 +08:00
|
|
|
|
2011-01-22 02:55:51 +08:00
|
|
|
}
|
|
|
|
|
2009-11-24 08:44:37 +08:00
|
|
|
// ConstantPool, GlobalAddress, and JumpTable
|
|
|
|
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-07 07:52:48 +08: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-28 07:47:46 +08:00
|
|
|
let canFoldAsLoad = 1, isReMaterializable = 1 in
|
2011-01-20 16:34:58 +08:00
|
|
|
def t2LDRpci_pic : PseudoInst<(outs rGPR:$dst), (ins i32imm:$addr, pclabel:$cp),
|
2010-11-18 09:38:26 +08:00
|
|
|
IIC_iLoadiALU,
|
2011-01-20 16:34:58 +08:00
|
|
|
[(set rGPR:$dst, (ARMpic_add (load (ARMWrapper tconstpool:$addr)),
|
2009-11-07 07:52:48 +08:00
|
|
|
imm:$cp))]>,
|
|
|
|
Requires<[IsThumb2]>;
|
2011-10-11 06:59:55 +08:00
|
|
|
|
2011-10-19 02:40:53 +08:00
|
|
|
// Pseudo isntruction that combines movs + predicated rsbmi
|
2011-10-11 06:59:55 +08:00
|
|
|
// to implement integer ABS
|
|
|
|
let usesCustomInserter = 1, Defs = [CPSR] in {
|
|
|
|
def t2ABS : PseudoInst<(outs rGPR:$dst), (ins rGPR:$src),
|
|
|
|
NoItinerary, []>, Requires<[IsThumb2]>;
|
|
|
|
}
|
|
|
|
|
2011-09-08 05:10:42 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Coprocessor load/store -- for disassembly only
|
|
|
|
//
|
2011-10-13 04:54:17 +08:00
|
|
|
class T2CI<bits<4> op31_28, dag oops, dag iops, string opc, string asm>
|
2011-09-08 05:10:42 +08:00
|
|
|
: T2I<oops, iops, NoItinerary, opc, asm, []> {
|
2011-10-13 04:54:17 +08:00
|
|
|
let Inst{31-28} = op31_28;
|
2011-09-08 05:10:42 +08:00
|
|
|
let Inst{27-25} = 0b110;
|
|
|
|
}
|
|
|
|
|
2011-10-13 04:54:17 +08:00
|
|
|
multiclass t2LdStCop<bits<4> op31_28, bit load, bit Dbit, string asm> {
|
|
|
|
def _OFFSET : T2CI<op31_28,
|
|
|
|
(outs), (ins p_imm:$cop, c_imm:$CRd, addrmode5:$addr),
|
|
|
|
asm, "\t$cop, $CRd, $addr"> {
|
|
|
|
bits<13> addr;
|
|
|
|
bits<4> cop;
|
|
|
|
bits<4> CRd;
|
2011-09-08 05:10:42 +08:00
|
|
|
let Inst{24} = 1; // P = 1
|
2011-10-13 04:54:17 +08:00
|
|
|
let Inst{23} = addr{8};
|
|
|
|
let Inst{22} = Dbit;
|
2011-09-08 05:10:42 +08:00
|
|
|
let Inst{21} = 0; // W = 0
|
|
|
|
let Inst{20} = load;
|
2011-10-13 04:54:17 +08:00
|
|
|
let Inst{19-16} = addr{12-9};
|
|
|
|
let Inst{15-12} = CRd;
|
|
|
|
let Inst{11-8} = cop;
|
|
|
|
let Inst{7-0} = addr{7-0};
|
2011-09-08 05:10:42 +08:00
|
|
|
let DecoderMethod = "DecodeCopMemInstruction";
|
|
|
|
}
|
2011-10-13 04:54:17 +08:00
|
|
|
def _PRE : T2CI<op31_28,
|
2013-06-14 19:21:35 +08:00
|
|
|
(outs), (ins p_imm:$cop, c_imm:$CRd, addrmode5_pre:$addr),
|
2011-10-13 04:54:17 +08:00
|
|
|
asm, "\t$cop, $CRd, $addr!"> {
|
|
|
|
bits<13> addr;
|
|
|
|
bits<4> cop;
|
|
|
|
bits<4> CRd;
|
2011-09-08 05:10:42 +08:00
|
|
|
let Inst{24} = 1; // P = 1
|
2011-10-13 04:54:17 +08:00
|
|
|
let Inst{23} = addr{8};
|
|
|
|
let Inst{22} = Dbit;
|
2011-09-08 05:10:42 +08:00
|
|
|
let Inst{21} = 1; // W = 1
|
|
|
|
let Inst{20} = load;
|
2011-10-13 04:54:17 +08:00
|
|
|
let Inst{19-16} = addr{12-9};
|
|
|
|
let Inst{15-12} = CRd;
|
|
|
|
let Inst{11-8} = cop;
|
|
|
|
let Inst{7-0} = addr{7-0};
|
2011-09-08 05:10:42 +08:00
|
|
|
let DecoderMethod = "DecodeCopMemInstruction";
|
|
|
|
}
|
2011-10-13 04:54:17 +08:00
|
|
|
def _POST: T2CI<op31_28,
|
|
|
|
(outs), (ins p_imm:$cop, c_imm:$CRd, addr_offset_none:$addr,
|
|
|
|
postidx_imm8s4:$offset),
|
|
|
|
asm, "\t$cop, $CRd, $addr, $offset"> {
|
|
|
|
bits<9> offset;
|
|
|
|
bits<4> addr;
|
|
|
|
bits<4> cop;
|
|
|
|
bits<4> CRd;
|
2011-09-08 05:10:42 +08:00
|
|
|
let Inst{24} = 0; // P = 0
|
2011-10-13 04:54:17 +08:00
|
|
|
let Inst{23} = offset{8};
|
|
|
|
let Inst{22} = Dbit;
|
2011-09-08 05:10:42 +08:00
|
|
|
let Inst{21} = 1; // W = 1
|
|
|
|
let Inst{20} = load;
|
2011-10-13 04:54:17 +08:00
|
|
|
let Inst{19-16} = addr;
|
|
|
|
let Inst{15-12} = CRd;
|
|
|
|
let Inst{11-8} = cop;
|
|
|
|
let Inst{7-0} = offset{7-0};
|
2011-09-08 05:10:42 +08:00
|
|
|
let DecoderMethod = "DecodeCopMemInstruction";
|
|
|
|
}
|
2011-10-13 04:54:17 +08:00
|
|
|
def _OPTION : T2CI<op31_28, (outs),
|
|
|
|
(ins p_imm:$cop, c_imm:$CRd, addr_offset_none:$addr,
|
|
|
|
coproc_option_imm:$option),
|
|
|
|
asm, "\t$cop, $CRd, $addr, $option"> {
|
|
|
|
bits<8> option;
|
|
|
|
bits<4> addr;
|
|
|
|
bits<4> cop;
|
|
|
|
bits<4> CRd;
|
2011-09-08 05:10:42 +08:00
|
|
|
let Inst{24} = 0; // P = 0
|
|
|
|
let Inst{23} = 1; // U = 1
|
2011-10-13 04:54:17 +08:00
|
|
|
let Inst{22} = Dbit;
|
2011-09-08 05:10:42 +08:00
|
|
|
let Inst{21} = 0; // W = 0
|
|
|
|
let Inst{20} = load;
|
2011-10-13 04:54:17 +08:00
|
|
|
let Inst{19-16} = addr;
|
|
|
|
let Inst{15-12} = CRd;
|
|
|
|
let Inst{11-8} = cop;
|
|
|
|
let Inst{7-0} = option;
|
2011-09-08 05:10:42 +08:00
|
|
|
let DecoderMethod = "DecodeCopMemInstruction";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-13 04:54:17 +08:00
|
|
|
defm t2LDC : t2LdStCop<0b1110, 1, 0, "ldc">;
|
|
|
|
defm t2LDCL : t2LdStCop<0b1110, 1, 1, "ldcl">;
|
|
|
|
defm t2STC : t2LdStCop<0b1110, 0, 0, "stc">;
|
|
|
|
defm t2STCL : t2LdStCop<0b1110, 0, 1, "stcl">;
|
2013-11-09 00:25:50 +08:00
|
|
|
defm t2LDC2 : t2LdStCop<0b1111, 1, 0, "ldc2">, Requires<[PreV8]>;
|
|
|
|
defm t2LDC2L : t2LdStCop<0b1111, 1, 1, "ldc2l">, Requires<[PreV8]>;
|
|
|
|
defm t2STC2 : t2LdStCop<0b1111, 0, 0, "stc2">, Requires<[PreV8]>;
|
|
|
|
defm t2STC2L : t2LdStCop<0b1111, 0, 1, "stc2l">, Requires<[PreV8]>;
|
2011-09-08 05:10:42 +08:00
|
|
|
|
2010-02-26 02:46:43 +08:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Move between special register and ARM core register -- for disassembly only
|
|
|
|
//
|
2011-09-15 04:03:46 +08:00
|
|
|
// Move to ARM core register from Special Register
|
2011-09-28 22:21:38 +08:00
|
|
|
|
|
|
|
// A/R class MRS.
|
|
|
|
//
|
|
|
|
// A/R class can only move from CPSR or SPSR.
|
2012-04-24 06:04:10 +08:00
|
|
|
def t2MRS_AR : T2I<(outs GPR:$Rd), (ins), NoItinerary, "mrs", "\t$Rd, apsr",
|
2013-09-23 22:26:15 +08:00
|
|
|
[]>, Requires<[IsThumb2,IsNotMClass]> {
|
2011-09-15 04:03:46 +08:00
|
|
|
bits<4> Rd;
|
|
|
|
let Inst{31-12} = 0b11110011111011111000;
|
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{7-0} = 0b0000;
|
2010-11-30 03:29:15 +08:00
|
|
|
}
|
|
|
|
|
2011-09-28 22:21:38 +08:00
|
|
|
def : t2InstAlias<"mrs${p} $Rd, cpsr", (t2MRS_AR GPR:$Rd, pred:$p)>;
|
2011-09-15 04:03:46 +08:00
|
|
|
|
2012-04-24 06:04:10 +08:00
|
|
|
def t2MRSsys_AR: T2I<(outs GPR:$Rd), (ins), NoItinerary, "mrs", "\t$Rd, spsr",
|
2013-09-23 22:26:15 +08:00
|
|
|
[]>, Requires<[IsThumb2,IsNotMClass]> {
|
2010-11-30 04:38:48 +08:00
|
|
|
bits<4> Rd;
|
2011-09-15 04:03:46 +08:00
|
|
|
let Inst{31-12} = 0b11110011111111111000;
|
2010-12-09 06:10:43 +08:00
|
|
|
let Inst{11-8} = Rd;
|
2011-09-15 04:03:46 +08:00
|
|
|
let Inst{7-0} = 0b0000;
|
2010-02-26 02:46:43 +08:00
|
|
|
}
|
|
|
|
|
2011-09-28 22:21:38 +08:00
|
|
|
// M class MRS.
|
|
|
|
//
|
|
|
|
// This MRS has a mask field in bits 7-0 and can take more values than
|
|
|
|
// the A/R class (a full msr_mask).
|
|
|
|
def t2MRS_M : T2I<(outs rGPR:$Rd), (ins msr_mask:$mask), NoItinerary,
|
|
|
|
"mrs", "\t$Rd, $mask", []>,
|
2012-04-27 09:27:19 +08:00
|
|
|
Requires<[IsThumb,IsMClass]> {
|
2011-09-28 22:21:38 +08:00
|
|
|
bits<4> Rd;
|
|
|
|
bits<8> mask;
|
|
|
|
let Inst{31-12} = 0b11110011111011111000;
|
|
|
|
let Inst{11-8} = Rd;
|
|
|
|
let Inst{19-16} = 0b1111;
|
|
|
|
let Inst{7-0} = mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-19 03:45:59 +08:00
|
|
|
// Move from ARM core register to Special Register
|
|
|
|
//
|
2011-09-28 22:21:38 +08:00
|
|
|
// A/R class MSR.
|
|
|
|
//
|
2011-02-19 03:45:59 +08:00
|
|
|
// 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-28 22:21:38 +08:00
|
|
|
def t2MSR_AR : T2I<(outs), (ins msr_mask:$mask, rGPR:$Rn),
|
|
|
|
NoItinerary, "msr", "\t$mask, $Rn", []>,
|
2013-09-23 22:26:15 +08:00
|
|
|
Requires<[IsThumb2,IsNotMClass]> {
|
2011-02-19 03:45:59 +08:00
|
|
|
bits<5> mask;
|
2010-11-30 03:29:15 +08:00
|
|
|
bits<4> Rn;
|
2011-09-15 04:03:46 +08:00
|
|
|
let Inst{31-21} = 0b11110011100;
|
2011-02-19 03:45:59 +08:00
|
|
|
let Inst{20} = mask{4}; // R Bit
|
2011-09-15 04:03:46 +08:00
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{15-12} = 0b1000;
|
2011-02-19 03:45:59 +08:00
|
|
|
let Inst{11-8} = mask{3-0};
|
2011-09-15 04:03:46 +08:00
|
|
|
let Inst{7-0} = 0;
|
2010-11-30 03:29:15 +08:00
|
|
|
}
|
|
|
|
|
2011-09-28 22:21:38 +08:00
|
|
|
// M class MSR.
|
|
|
|
//
|
|
|
|
// Move from ARM core register to Special Register
|
|
|
|
def t2MSR_M : T2I<(outs), (ins msr_mask:$SYSm, rGPR:$Rn),
|
|
|
|
NoItinerary, "msr", "\t$SYSm, $Rn", []>,
|
2012-04-27 09:27:19 +08:00
|
|
|
Requires<[IsThumb,IsMClass]> {
|
2012-05-18 06:18:01 +08:00
|
|
|
bits<12> SYSm;
|
2011-09-28 22:21:38 +08:00
|
|
|
bits<4> Rn;
|
|
|
|
let Inst{31-21} = 0b11110011100;
|
|
|
|
let Inst{20} = 0b0;
|
|
|
|
let Inst{19-16} = Rn;
|
|
|
|
let Inst{15-12} = 0b1000;
|
2012-05-18 06:18:01 +08:00
|
|
|
let Inst{11-0} = SYSm;
|
2011-09-28 22:21:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-21 00:58:48 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2011-07-14 05:14:23 +08:00
|
|
|
// Move between coprocessor and ARM core register
|
2011-01-21 00:58:48 +08:00
|
|
|
//
|
|
|
|
|
2011-07-14 05:35:10 +08:00
|
|
|
class t2MovRCopro<bits<4> Op, string opc, bit direction, dag oops, dag iops,
|
|
|
|
list<dag> pattern>
|
2013-06-27 00:52:40 +08:00
|
|
|
: T2Cop<Op, oops, iops, opc, "\t$cop, $opc1, $Rt, $CRn, $CRm, $opc2",
|
2011-07-14 05:14:23 +08: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-14 05:35:10 +08:00
|
|
|
class t2MovRRCopro<bits<4> Op, string opc, bit direction,
|
|
|
|
list<dag> pattern = []>
|
|
|
|
: T2Cop<Op, (outs),
|
2011-07-15 05:26:42 +08:00
|
|
|
(ins p_imm:$cop, imm0_15:$opc1, GPR:$Rt, GPR:$Rt2, c_imm:$CRm),
|
2013-06-27 00:52:40 +08:00
|
|
|
opc, "\t$cop, $opc1, $Rt, $Rt2, $CRm", pattern> {
|
2011-07-14 05:14:23 +08:00
|
|
|
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-14 05:35:10 +08:00
|
|
|
/* from ARM core register to coprocessor */
|
|
|
|
def t2MCR : t2MovRCopro<0b1110, "mcr", 0,
|
|
|
|
(outs),
|
2011-07-15 05:19:17 +08:00
|
|
|
(ins p_imm:$cop, imm0_7:$opc1, GPR:$Rt, c_imm:$CRn,
|
|
|
|
c_imm:$CRm, imm0_7:$opc2),
|
2011-07-14 05:35:10 +08:00
|
|
|
[(int_arm_mcr imm:$cop, imm:$opc1, GPR:$Rt, imm:$CRn,
|
2013-09-17 17:54:57 +08:00
|
|
|
imm:$CRm, imm:$opc2)]>,
|
|
|
|
ComplexDeprecationPredicate<"MCR">;
|
2013-06-27 00:52:40 +08:00
|
|
|
def : t2InstAlias<"mcr${p} $cop, $opc1, $Rt, $CRn, $CRm",
|
2012-03-16 08:45:58 +08:00
|
|
|
(t2MCR p_imm:$cop, imm0_7:$opc1, GPR:$Rt, c_imm:$CRn,
|
2013-06-27 00:52:40 +08:00
|
|
|
c_imm:$CRm, 0, pred:$p)>;
|
2011-07-14 05:35:10 +08:00
|
|
|
def t2MCR2 : t2MovRCopro<0b1111, "mcr2", 0,
|
2011-07-15 05:19:17 +08:00
|
|
|
(outs), (ins p_imm:$cop, imm0_7:$opc1, GPR:$Rt, c_imm:$CRn,
|
|
|
|
c_imm:$CRm, imm0_7:$opc2),
|
2011-05-04 01:29:29 +08:00
|
|
|
[(int_arm_mcr2 imm:$cop, imm:$opc1, GPR:$Rt, imm:$CRn,
|
2013-11-09 00:25:50 +08:00
|
|
|
imm:$CRm, imm:$opc2)]> {
|
|
|
|
let Predicates = [IsThumb2, PreV8];
|
|
|
|
}
|
2013-06-27 00:52:40 +08:00
|
|
|
def : t2InstAlias<"mcr2${p} $cop, $opc1, $Rt, $CRn, $CRm",
|
2012-03-16 08:45:58 +08:00
|
|
|
(t2MCR2 p_imm:$cop, imm0_7:$opc1, GPR:$Rt, c_imm:$CRn,
|
2013-06-27 00:52:40 +08:00
|
|
|
c_imm:$CRm, 0, pred:$p)>;
|
2011-07-14 05:35:10 +08:00
|
|
|
|
|
|
|
/* from coprocessor to ARM core register */
|
|
|
|
def t2MRC : t2MovRCopro<0b1110, "mrc", 1,
|
2013-08-06 23:52:36 +08:00
|
|
|
(outs GPRwithAPSR:$Rt), (ins p_imm:$cop, imm0_7:$opc1, c_imm:$CRn,
|
2011-07-20 04:35:35 +08:00
|
|
|
c_imm:$CRm, imm0_7:$opc2), []>;
|
2013-06-27 00:52:40 +08:00
|
|
|
def : t2InstAlias<"mrc${p} $cop, $opc1, $Rt, $CRn, $CRm",
|
2013-08-06 23:52:36 +08:00
|
|
|
(t2MRC GPRwithAPSR:$Rt, p_imm:$cop, imm0_7:$opc1, c_imm:$CRn,
|
2013-06-27 00:52:40 +08:00
|
|
|
c_imm:$CRm, 0, pred:$p)>;
|
2011-07-14 05:35:10 +08:00
|
|
|
|
|
|
|
def t2MRC2 : t2MovRCopro<0b1111, "mrc2", 1,
|
2013-08-06 23:52:36 +08:00
|
|
|
(outs GPRwithAPSR:$Rt), (ins p_imm:$cop, imm0_7:$opc1, c_imm:$CRn,
|
2013-11-09 00:25:50 +08:00
|
|
|
c_imm:$CRm, imm0_7:$opc2), []> {
|
|
|
|
let Predicates = [IsThumb2, PreV8];
|
|
|
|
}
|
2013-06-27 00:52:40 +08:00
|
|
|
def : t2InstAlias<"mrc2${p} $cop, $opc1, $Rt, $CRn, $CRm",
|
2013-08-06 23:52:36 +08:00
|
|
|
(t2MRC2 GPRwithAPSR:$Rt, p_imm:$cop, imm0_7:$opc1, c_imm:$CRn,
|
2013-06-27 00:52:40 +08:00
|
|
|
c_imm:$CRm, 0, pred:$p)>;
|
2011-01-21 00:58:48 +08:00
|
|
|
|
2011-07-14 05:35:10 +08: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-21 00:58:48 +08:00
|
|
|
|
2011-07-14 05:35:10 +08: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-21 00:58:48 +08:00
|
|
|
|
|
|
|
|
2011-07-14 05:35:10 +08: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-04 01:29:29 +08:00
|
|
|
[(int_arm_mcrr2 imm:$cop, imm:$opc1, GPR:$Rt,
|
2013-11-09 00:25:50 +08:00
|
|
|
GPR:$Rt2, imm:$CRm)]> {
|
|
|
|
let Predicates = [IsThumb2, PreV8];
|
|
|
|
}
|
|
|
|
|
2011-07-14 05:35:10 +08:00
|
|
|
/* from coprocessor to ARM core register */
|
|
|
|
def t2MRRC : t2MovRRCopro<0b1110, "mrrc", 1>;
|
|
|
|
|
2013-11-09 00:25:50 +08:00
|
|
|
def t2MRRC2 : t2MovRRCopro<0b1111, "mrrc2", 1> {
|
|
|
|
let Predicates = [IsThumb2, PreV8];
|
|
|
|
}
|
2011-01-21 00:58:48 +08:00
|
|
|
|
2011-01-21 02:32:09 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2011-07-14 05:14:23 +08:00
|
|
|
// Other Coprocessor Instructions.
|
2011-01-21 02:32:09 +08:00
|
|
|
//
|
|
|
|
|
2013-08-08 18:20:41 +08:00
|
|
|
def t2CDP : T2Cop<0b1110, (outs), (ins p_imm:$cop, imm0_15:$opc1,
|
2011-07-14 06:01:08 +08:00
|
|
|
c_imm:$CRd, c_imm:$CRn, c_imm:$CRm, imm0_7:$opc2),
|
2013-06-27 00:52:40 +08:00
|
|
|
"cdp", "\t$cop, $opc1, $CRd, $CRn, $CRm, $opc2",
|
2011-07-14 05:14:23 +08:00
|
|
|
[(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;
|
2013-11-09 00:25:50 +08:00
|
|
|
|
|
|
|
let Predicates = [IsThumb2, PreV8];
|
2011-07-14 05:14:23 +08:00
|
|
|
}
|
|
|
|
|
2011-07-14 06:06:11 +08:00
|
|
|
def t2CDP2 : T2Cop<0b1111, (outs), (ins p_imm:$cop, imm0_15:$opc1,
|
2011-07-14 06:01:08 +08:00
|
|
|
c_imm:$CRd, c_imm:$CRn, c_imm:$CRm, imm0_7:$opc2),
|
2013-06-27 00:52:40 +08:00
|
|
|
"cdp2", "\t$cop, $opc1, $CRd, $CRn, $CRm, $opc2",
|
2011-05-04 01:29:29 +08:00
|
|
|
[(int_arm_cdp2 imm:$cop, imm:$opc1, imm:$CRd, imm:$CRn,
|
|
|
|
imm:$CRm, imm:$opc2)]> {
|
2011-01-21 02:32:09 +08: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;
|
2013-11-09 00:25:50 +08:00
|
|
|
|
|
|
|
let Predicates = [IsThumb2, PreV8];
|
2011-01-21 02:32:09 +08:00
|
|
|
}
|
2011-07-28 00:47:19 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Non-Instruction Patterns
|
|
|
|
//
|
|
|
|
|
|
|
|
// SXT/UXT with no rotate
|
2011-07-28 01:48:13 +08:00
|
|
|
let AddedComplexity = 16 in {
|
|
|
|
def : T2Pat<(and rGPR:$Rm, 0x000000FF), (t2UXTB rGPR:$Rm, 0)>,
|
2011-08-09 03:49:37 +08:00
|
|
|
Requires<[IsThumb2]>;
|
2011-07-28 01:48:13 +08:00
|
|
|
def : T2Pat<(and rGPR:$Rm, 0x0000FFFF), (t2UXTH rGPR:$Rm, 0)>,
|
2011-08-09 03:49:37 +08:00
|
|
|
Requires<[IsThumb2]>;
|
2011-07-28 01:48:13 +08: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-09 03:49:37 +08:00
|
|
|
Requires<[IsThumb2]>;
|
2011-07-28 01:48:13 +08:00
|
|
|
def : T2Pat<(sext_inreg rGPR:$Src, i16), (t2SXTH rGPR:$Src, 0)>,
|
2011-08-09 03:49:37 +08:00
|
|
|
Requires<[IsThumb2]>;
|
2011-07-28 01:48:13 +08: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 10:59:24 +08:00
|
|
|
|
|
|
|
// Atomic load/store patterns
|
2012-08-28 11:11:27 +08:00
|
|
|
def : T2Pat<(atomic_load_8 t2addrmode_imm12:$addr),
|
|
|
|
(t2LDRBi12 t2addrmode_imm12:$addr)>;
|
|
|
|
def : T2Pat<(atomic_load_8 t2addrmode_negimm8:$addr),
|
|
|
|
(t2LDRBi8 t2addrmode_negimm8:$addr)>;
|
2011-08-26 10:59:24 +08:00
|
|
|
def : T2Pat<(atomic_load_8 t2addrmode_so_reg:$addr),
|
2012-08-28 11:11:27 +08:00
|
|
|
(t2LDRBs t2addrmode_so_reg:$addr)>;
|
|
|
|
def : T2Pat<(atomic_load_16 t2addrmode_imm12:$addr),
|
|
|
|
(t2LDRHi12 t2addrmode_imm12:$addr)>;
|
|
|
|
def : T2Pat<(atomic_load_16 t2addrmode_negimm8:$addr),
|
|
|
|
(t2LDRHi8 t2addrmode_negimm8:$addr)>;
|
2011-08-26 10:59:24 +08:00
|
|
|
def : T2Pat<(atomic_load_16 t2addrmode_so_reg:$addr),
|
2012-08-28 11:11:27 +08:00
|
|
|
(t2LDRHs t2addrmode_so_reg:$addr)>;
|
|
|
|
def : T2Pat<(atomic_load_32 t2addrmode_imm12:$addr),
|
|
|
|
(t2LDRi12 t2addrmode_imm12:$addr)>;
|
2011-09-08 04:58:57 +08:00
|
|
|
def : T2Pat<(atomic_load_32 t2addrmode_negimm8:$addr),
|
2012-08-28 11:11:27 +08:00
|
|
|
(t2LDRi8 t2addrmode_negimm8:$addr)>;
|
2011-08-26 10:59:24 +08:00
|
|
|
def : T2Pat<(atomic_load_32 t2addrmode_so_reg:$addr),
|
2012-08-28 11:11:27 +08:00
|
|
|
(t2LDRs t2addrmode_so_reg:$addr)>;
|
2011-08-26 10:59:24 +08:00
|
|
|
def : T2Pat<(atomic_store_8 t2addrmode_imm12:$addr, GPR:$val),
|
|
|
|
(t2STRBi12 GPR:$val, t2addrmode_imm12:$addr)>;
|
2011-09-08 04:58:57 +08:00
|
|
|
def : T2Pat<(atomic_store_8 t2addrmode_negimm8:$addr, GPR:$val),
|
|
|
|
(t2STRBi8 GPR:$val, t2addrmode_negimm8:$addr)>;
|
2011-08-26 10:59:24 +08: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-08 04:58:57 +08:00
|
|
|
def : T2Pat<(atomic_store_16 t2addrmode_negimm8:$addr, GPR:$val),
|
|
|
|
(t2STRHi8 GPR:$val, t2addrmode_negimm8:$addr)>;
|
2011-08-26 10:59:24 +08: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-08 04:58:57 +08:00
|
|
|
def : T2Pat<(atomic_store_32 t2addrmode_negimm8:$addr, GPR:$val),
|
|
|
|
(t2STRi8 GPR:$val, t2addrmode_negimm8:$addr)>;
|
2011-08-26 10:59:24 +08:00
|
|
|
def : T2Pat<(atomic_store_32 t2addrmode_so_reg:$addr, GPR:$val),
|
|
|
|
(t2STRs GPR:$val, t2addrmode_so_reg:$addr)>;
|
2011-09-01 02:23:08 +08:00
|
|
|
|
2013-09-26 20:22:36 +08:00
|
|
|
let AddedComplexity = 8 in {
|
|
|
|
def : T2Pat<(atomic_load_acquire_8 addr_offset_none:$addr), (t2LDAB addr_offset_none:$addr)>;
|
|
|
|
def : T2Pat<(atomic_load_acquire_16 addr_offset_none:$addr), (t2LDAH addr_offset_none:$addr)>;
|
|
|
|
def : T2Pat<(atomic_load_acquire_32 addr_offset_none:$addr), (t2LDA addr_offset_none:$addr)>;
|
|
|
|
def : T2Pat<(atomic_store_release_8 addr_offset_none:$addr, GPR:$val), (t2STLB GPR:$val, addr_offset_none:$addr)>;
|
|
|
|
def : T2Pat<(atomic_store_release_16 addr_offset_none:$addr, GPR:$val), (t2STLH GPR:$val, addr_offset_none:$addr)>;
|
|
|
|
def : T2Pat<(atomic_store_release_32 addr_offset_none:$addr, GPR:$val), (t2STL GPR:$val, addr_offset_none:$addr)>;
|
|
|
|
}
|
|
|
|
|
2011-09-01 02:23:08 +08: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-03 02:14:46 +08:00
|
|
|
// Aliases for ADD without the ".w" optional width specifier.
|
2011-09-01 08:28:52 +08:00
|
|
|
def : t2InstAlias<"add${s}${p} $Rd, $Rn, $imm",
|
2014-04-04 07:43:18 +08:00
|
|
|
(t2ADDri GPRnopc:$Rd, GPRnopc:$Rn, t2_so_imm:$imm, pred:$p,
|
2013-08-19 23:02:25 +08:00
|
|
|
cc_out:$s)>;
|
2011-09-01 08:28:52 +08:00
|
|
|
def : t2InstAlias<"add${p} $Rd, $Rn, $imm",
|
2011-10-04 04:51:59 +08:00
|
|
|
(t2ADDri12 GPRnopc:$Rd, GPR:$Rn, imm0_4095:$imm, pred:$p)>;
|
2011-09-03 02:14:46 +08:00
|
|
|
def : t2InstAlias<"add${s}${p} $Rd, $Rn, $Rm",
|
2011-10-04 04:51:59 +08:00
|
|
|
(t2ADDrr GPRnopc:$Rd, GPRnopc:$Rn, rGPR:$Rm, pred:$p, cc_out:$s)>;
|
2011-09-03 02:14:46 +08:00
|
|
|
def : t2InstAlias<"add${s}${p} $Rd, $Rn, $ShiftedRm",
|
2011-10-04 04:51:59 +08:00
|
|
|
(t2ADDrs GPRnopc:$Rd, GPRnopc:$Rn, t2_so_reg:$ShiftedRm,
|
2011-09-17 06:58:42 +08:00
|
|
|
pred:$p, cc_out:$s)>;
|
2011-10-29 00:57:07 +08:00
|
|
|
// ... and with the destination and source register combined.
|
|
|
|
def : t2InstAlias<"add${s}${p} $Rdn, $imm",
|
|
|
|
(t2ADDri GPRnopc:$Rdn, GPRnopc:$Rdn, t2_so_imm:$imm, pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"add${p} $Rdn, $imm",
|
|
|
|
(t2ADDri12 GPRnopc:$Rdn, GPRnopc:$Rdn, imm0_4095:$imm, pred:$p)>;
|
|
|
|
def : t2InstAlias<"add${s}${p} $Rdn, $Rm",
|
|
|
|
(t2ADDrr GPRnopc:$Rdn, GPRnopc:$Rdn, rGPR:$Rm, pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"add${s}${p} $Rdn, $ShiftedRm",
|
|
|
|
(t2ADDrs GPRnopc:$Rdn, GPRnopc:$Rdn, t2_so_reg:$ShiftedRm,
|
|
|
|
pred:$p, cc_out:$s)>;
|
2011-09-17 06:58:42 +08:00
|
|
|
|
2012-04-06 04:57:13 +08:00
|
|
|
// add w/ negative immediates is just a sub.
|
|
|
|
def : t2InstAlias<"add${s}${p} $Rd, $Rn, $imm",
|
|
|
|
(t2SUBri GPRnopc:$Rd, GPRnopc:$Rn, t2_so_imm_neg:$imm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"add${p} $Rd, $Rn, $imm",
|
|
|
|
(t2SUBri12 GPRnopc:$Rd, GPR:$Rn, imm0_4095_neg:$imm, pred:$p)>;
|
|
|
|
def : t2InstAlias<"add${s}${p} $Rdn, $imm",
|
|
|
|
(t2SUBri GPRnopc:$Rdn, GPRnopc:$Rdn, t2_so_imm_neg:$imm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"add${p} $Rdn, $imm",
|
|
|
|
(t2SUBri12 GPRnopc:$Rdn, GPRnopc:$Rdn, imm0_4095_neg:$imm, pred:$p)>;
|
|
|
|
|
2012-05-02 05:17:34 +08:00
|
|
|
def : t2InstAlias<"add${s}${p}.w $Rd, $Rn, $imm",
|
|
|
|
(t2SUBri GPRnopc:$Rd, GPRnopc:$Rn, t2_so_imm_neg:$imm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"addw${p} $Rd, $Rn, $imm",
|
|
|
|
(t2SUBri12 GPRnopc:$Rd, GPR:$Rn, imm0_4095_neg:$imm, pred:$p)>;
|
|
|
|
def : t2InstAlias<"add${s}${p}.w $Rdn, $imm",
|
|
|
|
(t2SUBri GPRnopc:$Rdn, GPRnopc:$Rdn, t2_so_imm_neg:$imm, pred:$p,
|
|
|
|
cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"addw${p} $Rdn, $imm",
|
|
|
|
(t2SUBri12 GPRnopc:$Rdn, GPRnopc:$Rdn, imm0_4095_neg:$imm, pred:$p)>;
|
|
|
|
|
2012-04-06 04:57:13 +08:00
|
|
|
|
2011-09-17 06:58:42 +08:00
|
|
|
// Aliases for SUB without the ".w" optional width specifier.
|
|
|
|
def : t2InstAlias<"sub${s}${p} $Rd, $Rn, $imm",
|
2011-10-04 04:51:59 +08:00
|
|
|
(t2SUBri GPRnopc:$Rd, GPRnopc:$Rn, t2_so_imm:$imm, pred:$p, cc_out:$s)>;
|
2011-09-17 06:58:42 +08:00
|
|
|
def : t2InstAlias<"sub${p} $Rd, $Rn, $imm",
|
2011-10-04 04:51:59 +08:00
|
|
|
(t2SUBri12 GPRnopc:$Rd, GPR:$Rn, imm0_4095:$imm, pred:$p)>;
|
2011-09-17 06:58:42 +08:00
|
|
|
def : t2InstAlias<"sub${s}${p} $Rd, $Rn, $Rm",
|
2011-10-04 04:51:59 +08:00
|
|
|
(t2SUBrr GPRnopc:$Rd, GPRnopc:$Rn, rGPR:$Rm, pred:$p, cc_out:$s)>;
|
2011-09-17 06:58:42 +08:00
|
|
|
def : t2InstAlias<"sub${s}${p} $Rd, $Rn, $ShiftedRm",
|
2011-10-04 04:51:59 +08:00
|
|
|
(t2SUBrs GPRnopc:$Rd, GPRnopc:$Rn, t2_so_reg:$ShiftedRm,
|
2011-09-03 02:14:46 +08:00
|
|
|
pred:$p, cc_out:$s)>;
|
2011-10-29 00:57:07 +08:00
|
|
|
// ... and with the destination and source register combined.
|
|
|
|
def : t2InstAlias<"sub${s}${p} $Rdn, $imm",
|
|
|
|
(t2SUBri GPRnopc:$Rdn, GPRnopc:$Rdn, t2_so_imm:$imm, pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"sub${p} $Rdn, $imm",
|
|
|
|
(t2SUBri12 GPRnopc:$Rdn, GPRnopc:$Rdn, imm0_4095:$imm, pred:$p)>;
|
2012-04-11 01:31:55 +08:00
|
|
|
def : t2InstAlias<"sub${s}${p}.w $Rdn, $Rm",
|
|
|
|
(t2SUBrr GPRnopc:$Rdn, GPRnopc:$Rdn, rGPR:$Rm, pred:$p, cc_out:$s)>;
|
2011-10-29 00:57:07 +08:00
|
|
|
def : t2InstAlias<"sub${s}${p} $Rdn, $Rm",
|
|
|
|
(t2SUBrr GPRnopc:$Rdn, GPRnopc:$Rdn, rGPR:$Rm, pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"sub${s}${p} $Rdn, $ShiftedRm",
|
|
|
|
(t2SUBrs GPRnopc:$Rdn, GPRnopc:$Rdn, t2_so_reg:$ShiftedRm,
|
|
|
|
pred:$p, cc_out:$s)>;
|
|
|
|
|
2011-09-07 05:44:58 +08: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-07 06:14:58 +08:00
|
|
|
// Memory barriers
|
2013-11-06 05:36:02 +08:00
|
|
|
def : InstAlias<"dmb${p}", (t2DMB 0xf, pred:$p)>, Requires<[HasDB]>;
|
|
|
|
def : InstAlias<"dsb${p}", (t2DSB 0xf, pred:$p)>, Requires<[HasDB]>;
|
|
|
|
def : InstAlias<"isb${p}", (t2ISB 0xf, pred:$p)>, Requires<[HasDB]>;
|
2011-09-08 04:58:57 +08:00
|
|
|
|
2011-09-10 03:42:40 +08:00
|
|
|
// Alias for LDR, LDRB, LDRH, LDRSB, and LDRSH without the ".w" optional
|
|
|
|
// width specifier.
|
2011-09-08 05:41:25 +08: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-10 03:42:40 +08: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-08 07:10:15 +08: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-10 03:42:40 +08: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-15 05:24:41 +08:00
|
|
|
|
2011-10-27 06:22:01 +08:00
|
|
|
def : t2InstAlias<"ldr${p} $Rt, $addr",
|
2014-02-12 04:48:39 +08:00
|
|
|
(t2LDRpci GPRnopc:$Rt, t2ldrlabel:$addr, pred:$p)>;
|
2011-10-27 06:22:01 +08:00
|
|
|
def : t2InstAlias<"ldrb${p} $Rt, $addr",
|
|
|
|
(t2LDRBpci rGPR:$Rt, t2ldrlabel:$addr, pred:$p)>;
|
|
|
|
def : t2InstAlias<"ldrh${p} $Rt, $addr",
|
|
|
|
(t2LDRHpci rGPR:$Rt, t2ldrlabel:$addr, pred:$p)>;
|
|
|
|
def : t2InstAlias<"ldrsb${p} $Rt, $addr",
|
|
|
|
(t2LDRSBpci rGPR:$Rt, t2ldrlabel:$addr, pred:$p)>;
|
|
|
|
def : t2InstAlias<"ldrsh${p} $Rt, $addr",
|
|
|
|
(t2LDRSHpci rGPR:$Rt, t2ldrlabel:$addr, pred:$p)>;
|
|
|
|
|
2011-10-28 01:16:55 +08:00
|
|
|
// Alias for MVN with(out) the ".w" optional width specifier.
|
|
|
|
def : t2InstAlias<"mvn${s}${p}.w $Rd, $imm",
|
|
|
|
(t2MVNi rGPR:$Rd, t2_so_imm:$imm, pred:$p, cc_out:$s)>;
|
2011-09-15 05:24:41 +08:00
|
|
|
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-15 07:16:41 +08: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 23:55:04 +08: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-12-08 02:32:28 +08:00
|
|
|
// STMIA/STMIA_UPD aliases w/o the optional .w suffix
|
|
|
|
def : t2InstAlias<"stm${p} $Rn, $regs",
|
|
|
|
(t2STMIA GPR:$Rn, pred:$p, reglist:$regs)>;
|
|
|
|
def : t2InstAlias<"stm${p} $Rn!, $regs",
|
|
|
|
(t2STMIA_UPD GPR:$Rn, pred:$p, reglist:$regs)>;
|
|
|
|
|
|
|
|
// LDMIA/LDMIA_UPD aliases w/o the optional .w suffix
|
|
|
|
def : t2InstAlias<"ldm${p} $Rn, $regs",
|
|
|
|
(t2LDMIA GPR:$Rn, pred:$p, reglist:$regs)>;
|
|
|
|
def : t2InstAlias<"ldm${p} $Rn!, $regs",
|
|
|
|
(t2LDMIA_UPD GPR:$Rn, pred:$p, reglist:$regs)>;
|
|
|
|
|
2011-11-10 07:44:23 +08:00
|
|
|
// STMDB/STMDB_UPD aliases w/ the optional .w suffix
|
|
|
|
def : t2InstAlias<"stmdb${p}.w $Rn, $regs",
|
|
|
|
(t2STMDB GPR:$Rn, pred:$p, reglist:$regs)>;
|
|
|
|
def : t2InstAlias<"stmdb${p}.w $Rn!, $regs",
|
|
|
|
(t2STMDB_UPD GPR:$Rn, pred:$p, reglist:$regs)>;
|
|
|
|
|
2011-10-28 01:33:59 +08:00
|
|
|
// LDMDB/LDMDB_UPD aliases w/ the optional .w suffix
|
|
|
|
def : t2InstAlias<"ldmdb${p}.w $Rn, $regs",
|
|
|
|
(t2LDMDB GPR:$Rn, pred:$p, reglist:$regs)>;
|
|
|
|
def : t2InstAlias<"ldmdb${p}.w $Rn!, $regs",
|
|
|
|
(t2LDMDB_UPD GPR:$Rn, pred:$p, reglist:$regs)>;
|
|
|
|
|
2011-09-16 03:46:13 +08:00
|
|
|
// Alias for REV/REV16/REVSH without the ".w" optional width specifier.
|
2011-09-16 02:13:30 +08:00
|
|
|
def : t2InstAlias<"rev${p} $Rd, $Rm", (t2REV rGPR:$Rd, rGPR:$Rm, pred:$p)>;
|
2011-09-16 03:46:13 +08: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-16 04:54:14 +08: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-17 02:32:30 +08: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-17 04:50:13 +08:00
|
|
|
// STM w/o the .w suffix.
|
|
|
|
def : t2InstAlias<"stm${p} $Rn, $regs",
|
|
|
|
(t2STMIA GPR:$Rn, pred:$p, reglist:$regs)>;
|
2011-09-17 05:06:12 +08: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-20 01:56:37 +08: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)>;
|
2011-09-28 06:18:54 +08:00
|
|
|
|
2011-09-20 04:29:33 +08:00
|
|
|
def : t2InstAlias<"sxtb${p} $Rd, $Rm",
|
|
|
|
(t2SXTB rGPR:$Rd, rGPR:$Rm, 0, pred:$p)>;
|
|
|
|
def : t2InstAlias<"sxtb16${p} $Rd, $Rm",
|
|
|
|
(t2SXTB16 rGPR:$Rd, rGPR:$Rm, 0, pred:$p)>;
|
|
|
|
def : t2InstAlias<"sxth${p} $Rd, $Rm",
|
|
|
|
(t2SXTH rGPR:$Rd, rGPR:$Rm, 0, pred:$p)>;
|
2011-09-28 06:18:54 +08:00
|
|
|
def : t2InstAlias<"sxtb${p}.w $Rd, $Rm",
|
|
|
|
(t2SXTB rGPR:$Rd, rGPR:$Rm, 0, pred:$p)>;
|
|
|
|
def : t2InstAlias<"sxth${p}.w $Rd, $Rm",
|
|
|
|
(t2SXTH rGPR:$Rd, rGPR:$Rm, 0, pred:$p)>;
|
2011-09-20 04:29:33 +08:00
|
|
|
|
2011-09-20 08:46:54 +08:00
|
|
|
def : t2InstAlias<"uxtab${p} $Rd, $Rn, $Rm",
|
|
|
|
(t2UXTAB rGPR:$Rd, rGPR:$Rn, rGPR:$Rm, 0, pred:$p)>;
|
|
|
|
def : t2InstAlias<"uxtah${p} $Rd, $Rn, $Rm",
|
|
|
|
(t2UXTAH rGPR:$Rd, rGPR:$Rn, rGPR:$Rm, 0, pred:$p)>;
|
|
|
|
def : t2InstAlias<"uxtab16${p} $Rd, $Rn, $Rm",
|
|
|
|
(t2UXTAB16 rGPR:$Rd, rGPR:$Rn, rGPR:$Rm, 0, pred:$p)>;
|
|
|
|
def : t2InstAlias<"uxtb${p} $Rd, $Rm",
|
|
|
|
(t2UXTB rGPR:$Rd, rGPR:$Rm, 0, pred:$p)>;
|
|
|
|
def : t2InstAlias<"uxtb16${p} $Rd, $Rm",
|
|
|
|
(t2UXTB16 rGPR:$Rd, rGPR:$Rm, 0, pred:$p)>;
|
|
|
|
def : t2InstAlias<"uxth${p} $Rd, $Rm",
|
|
|
|
(t2UXTH rGPR:$Rd, rGPR:$Rm, 0, pred:$p)>;
|
|
|
|
|
2011-09-28 06:18:54 +08:00
|
|
|
def : t2InstAlias<"uxtb${p}.w $Rd, $Rm",
|
|
|
|
(t2UXTB rGPR:$Rd, rGPR:$Rm, 0, pred:$p)>;
|
|
|
|
def : t2InstAlias<"uxth${p}.w $Rd, $Rm",
|
|
|
|
(t2UXTH rGPR:$Rd, rGPR:$Rm, 0, pred:$p)>;
|
|
|
|
|
2011-09-20 04:29:33 +08:00
|
|
|
// Extend instruction w/o the ".w" optional width specifier.
|
2011-09-20 08:46:54 +08:00
|
|
|
def : t2InstAlias<"uxtb${p} $Rd, $Rm$rot",
|
|
|
|
(t2UXTB rGPR:$Rd, rGPR:$Rm, rot_imm:$rot, pred:$p)>;
|
|
|
|
def : t2InstAlias<"uxtb16${p} $Rd, $Rm$rot",
|
|
|
|
(t2UXTB16 rGPR:$Rd, rGPR:$Rm, rot_imm:$rot, pred:$p)>;
|
|
|
|
def : t2InstAlias<"uxth${p} $Rd, $Rm$rot",
|
|
|
|
(t2UXTH rGPR:$Rd, rGPR:$Rm, rot_imm:$rot, pred:$p)>;
|
|
|
|
|
2011-09-20 04:29:33 +08:00
|
|
|
def : t2InstAlias<"sxtb${p} $Rd, $Rm$rot",
|
|
|
|
(t2SXTB rGPR:$Rd, rGPR:$Rm, rot_imm:$rot, pred:$p)>;
|
|
|
|
def : t2InstAlias<"sxtb16${p} $Rd, $Rm$rot",
|
|
|
|
(t2SXTB16 rGPR:$Rd, rGPR:$Rm, rot_imm:$rot, pred:$p)>;
|
|
|
|
def : t2InstAlias<"sxth${p} $Rd, $Rm$rot",
|
|
|
|
(t2SXTH rGPR:$Rd, rGPR:$Rm, rot_imm:$rot, pred:$p)>;
|
2011-10-29 06:36:30 +08:00
|
|
|
|
|
|
|
|
|
|
|
// "mov Rd, t2_so_imm_not" can be handled via "mvn" in assembly, just like
|
|
|
|
// for isel.
|
|
|
|
def : t2InstAlias<"mov${p} $Rd, $imm",
|
|
|
|
(t2MVNi rGPR:$Rd, t2_so_imm_not:$imm, pred:$p, zero_reg)>;
|
2011-12-15 01:56:51 +08:00
|
|
|
def : t2InstAlias<"mvn${p} $Rd, $imm",
|
|
|
|
(t2MOVi rGPR:$Rd, t2_so_imm_not:$imm, pred:$p, zero_reg)>;
|
2011-12-10 06:02:17 +08:00
|
|
|
// Same for AND <--> BIC
|
|
|
|
def : t2InstAlias<"bic${s}${p} $Rd, $Rn, $imm",
|
2013-08-16 19:55:44 +08:00
|
|
|
(t2ANDri rGPR:$Rd, rGPR:$Rn, t2_so_imm_not:$imm,
|
2011-12-10 06:02:17 +08:00
|
|
|
pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"bic${s}${p} $Rdn, $imm",
|
2013-08-16 19:55:44 +08:00
|
|
|
(t2ANDri rGPR:$Rdn, rGPR:$Rdn, t2_so_imm_not:$imm,
|
2011-12-10 06:02:17 +08:00
|
|
|
pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"and${s}${p} $Rd, $Rn, $imm",
|
2013-08-16 19:55:44 +08:00
|
|
|
(t2BICri rGPR:$Rd, rGPR:$Rn, t2_so_imm_not:$imm,
|
2011-12-10 06:02:17 +08:00
|
|
|
pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"and${s}${p} $Rdn, $imm",
|
2013-08-16 19:55:44 +08:00
|
|
|
(t2BICri rGPR:$Rdn, rGPR:$Rdn, t2_so_imm_not:$imm,
|
2011-12-10 06:02:17 +08:00
|
|
|
pred:$p, cc_out:$s)>;
|
2011-12-15 01:30:24 +08:00
|
|
|
// Likewise, "add Rd, t2_so_imm_neg" -> sub
|
2011-12-08 08:31:07 +08:00
|
|
|
def : t2InstAlias<"add${s}${p} $Rd, $Rn, $imm",
|
|
|
|
(t2SUBri GPRnopc:$Rd, GPRnopc:$Rn, t2_so_imm_neg:$imm,
|
|
|
|
pred:$p, cc_out:$s)>;
|
|
|
|
def : t2InstAlias<"add${s}${p} $Rd, $imm",
|
|
|
|
(t2SUBri GPRnopc:$Rd, GPRnopc:$Rd, t2_so_imm_neg:$imm,
|
|
|
|
pred:$p, cc_out:$s)>;
|
2011-12-15 01:30:24 +08:00
|
|
|
// Same for CMP <--> CMN via t2_so_imm_neg
|
|
|
|
def : t2InstAlias<"cmp${p} $Rd, $imm",
|
2012-06-11 16:07:26 +08:00
|
|
|
(t2CMNri rGPR:$Rd, t2_so_imm_neg:$imm, pred:$p)>;
|
2011-12-15 01:30:24 +08:00
|
|
|
def : t2InstAlias<"cmn${p} $Rd, $imm",
|
|
|
|
(t2CMPri rGPR:$Rd, t2_so_imm_neg:$imm, pred:$p)>;
|
2011-11-16 03:55:16 +08:00
|
|
|
|
|
|
|
|
|
|
|
// Wide 'mul' encoding can be specified with only two operands.
|
|
|
|
def : t2InstAlias<"mul${p} $Rn, $Rm",
|
2011-12-06 13:03:45 +08:00
|
|
|
(t2MUL rGPR:$Rn, rGPR:$Rm, rGPR:$Rn, pred:$p)>;
|
2011-12-14 04:23:22 +08:00
|
|
|
|
|
|
|
// "neg" is and alias for "rsb rd, rn, #0"
|
|
|
|
def : t2InstAlias<"neg${s}${p} $Rd, $Rm",
|
|
|
|
(t2RSBri rGPR:$Rd, rGPR:$Rm, 0, pred:$p, cc_out:$s)>;
|
2011-12-14 06:45:11 +08:00
|
|
|
|
|
|
|
// MOV so_reg assembler pseudos. InstAlias isn't expressive enough for
|
|
|
|
// these, unfortunately.
|
|
|
|
def t2MOVsi: t2AsmPseudo<"mov${p} $Rd, $shift",
|
|
|
|
(ins rGPR:$Rd, t2_so_reg:$shift, pred:$p)>;
|
|
|
|
def t2MOVSsi: t2AsmPseudo<"movs${p} $Rd, $shift",
|
|
|
|
(ins rGPR:$Rd, t2_so_reg:$shift, pred:$p)>;
|
2011-12-16 07:52:17 +08:00
|
|
|
|
2011-12-22 04:54:00 +08:00
|
|
|
def t2MOVsr: t2AsmPseudo<"mov${p} $Rd, $shift",
|
|
|
|
(ins rGPR:$Rd, so_reg_reg:$shift, pred:$p)>;
|
|
|
|
def t2MOVSsr: t2AsmPseudo<"movs${p} $Rd, $shift",
|
|
|
|
(ins rGPR:$Rd, so_reg_reg:$shift, pred:$p)>;
|
|
|
|
|
2011-12-16 07:52:17 +08:00
|
|
|
// ADR w/o the .w suffix
|
|
|
|
def : t2InstAlias<"adr${p} $Rd, $addr",
|
|
|
|
(t2ADR rGPR:$Rd, t2adrlabel:$addr, pred:$p)>;
|
2012-01-19 06:46:46 +08:00
|
|
|
|
|
|
|
// LDR(literal) w/ alternate [pc, #imm] syntax.
|
|
|
|
def t2LDRpcrel : t2AsmPseudo<"ldr${p} $Rt, $addr",
|
2013-08-15 23:43:06 +08:00
|
|
|
(ins GPR:$Rt, t2ldr_pcrel_imm12:$addr, pred:$p)>;
|
2012-01-19 06:46:46 +08:00
|
|
|
def t2LDRBpcrel : t2AsmPseudo<"ldrb${p} $Rt, $addr",
|
|
|
|
(ins GPRnopc:$Rt, t2ldr_pcrel_imm12:$addr, pred:$p)>;
|
|
|
|
def t2LDRHpcrel : t2AsmPseudo<"ldrh${p} $Rt, $addr",
|
|
|
|
(ins GPRnopc:$Rt, t2ldr_pcrel_imm12:$addr, pred:$p)>;
|
|
|
|
def t2LDRSBpcrel : t2AsmPseudo<"ldrsb${p} $Rt, $addr",
|
|
|
|
(ins GPRnopc:$Rt, t2ldr_pcrel_imm12:$addr, pred:$p)>;
|
|
|
|
def t2LDRSHpcrel : t2AsmPseudo<"ldrsh${p} $Rt, $addr",
|
|
|
|
(ins GPRnopc:$Rt, t2ldr_pcrel_imm12:$addr, pred:$p)>;
|
|
|
|
// Version w/ the .w suffix.
|
|
|
|
def : t2InstAlias<"ldr${p}.w $Rt, $addr",
|
2013-08-15 23:43:06 +08:00
|
|
|
(t2LDRpcrel GPR:$Rt, t2ldr_pcrel_imm12:$addr, pred:$p), 0>;
|
2012-01-19 06:46:46 +08:00
|
|
|
def : t2InstAlias<"ldrb${p}.w $Rt, $addr",
|
|
|
|
(t2LDRBpcrel GPRnopc:$Rt, t2ldr_pcrel_imm12:$addr, pred:$p)>;
|
|
|
|
def : t2InstAlias<"ldrh${p}.w $Rt, $addr",
|
|
|
|
(t2LDRHpcrel GPRnopc:$Rt, t2ldr_pcrel_imm12:$addr, pred:$p)>;
|
|
|
|
def : t2InstAlias<"ldrsb${p}.w $Rt, $addr",
|
|
|
|
(t2LDRSBpcrel GPRnopc:$Rt, t2ldr_pcrel_imm12:$addr, pred:$p)>;
|
|
|
|
def : t2InstAlias<"ldrsh${p}.w $Rt, $addr",
|
|
|
|
(t2LDRSHpcrel GPRnopc:$Rt, t2ldr_pcrel_imm12:$addr, pred:$p)>;
|
2012-01-21 08:07:56 +08:00
|
|
|
|
|
|
|
def : t2InstAlias<"add${p} $Rd, pc, $imm",
|
|
|
|
(t2ADR rGPR:$Rd, imm0_4095:$imm, pred:$p)>;
|
2013-07-17 05:52:34 +08:00
|
|
|
|
2013-07-20 00:18:56 +08:00
|
|
|
// PLD/PLDW/PLI with alternate literal form.
|
|
|
|
def : t2InstAlias<"pld${p} $addr",
|
|
|
|
(t2PLDpci t2ldr_pcrel_imm12:$addr, pred:$p)>;
|
2013-07-19 06:19:59 +08:00
|
|
|
def : InstAlias<"pli${p} $addr",
|
|
|
|
(t2PLIpci t2ldr_pcrel_imm12:$addr, pred:$p)>,
|
|
|
|
Requires<[IsThumb2,HasV7]>;
|