34 #define DEBUG_TYPE "arm-disassembler"
53 void advanceITState() {
58 bool instrInITBlock() {
59 return !ITStates.empty();
63 bool instrLastInITBlock() {
64 return ITStates.size() == 1;
71 void setITState(
char Firstcond,
char Mask) {
73 unsigned NumTZ = countTrailingZeros<uint8_t>(
Mask);
74 unsigned char CCBits =
static_cast<unsigned char>(Firstcond & 0xf);
75 assert(NumTZ <= 3 &&
"Invalid IT mask!");
77 for (
unsigned Pos = NumTZ+1; Pos <= 3; ++Pos) {
79 ITStates.push_back(CCBits ^
Else);
81 ITStates.push_back(CCBits);
85 std::vector<unsigned char> ITStates;
91 unsigned getVPTPred() {
93 if (instrInVPTBlock())
94 Pred = VPTStates.back();
98 void advanceVPTState() {
102 bool instrInVPTBlock() {
103 return !VPTStates.empty();
106 bool instrLastInVPTBlock() {
107 return VPTStates.size() == 1;
110 void setVPTState(
char Mask) {
112 unsigned NumTZ = countTrailingZeros<uint8_t>(
Mask);
113 assert(NumTZ <= 3 &&
"Invalid VPT mask!");
115 for (
unsigned Pos = NumTZ+1; Pos <= 3; ++Pos) {
116 bool T = ((
Mask >> Pos) & 1) == 0;
136 ~ARMDisassembler()
override =
default;
151 mutable ITStatus ITBlock;
152 mutable VPTStatus VPTBlock;
554 template <
int shift,
int WriteBack>
616 template <
bool isSigned,
bool isNeg,
bool zeroPermitted,
int size>
651 template <
bool Writeback>
667 template <
unsigned MinLog,
unsigned MaxLog>
671 template <
unsigned start>
687 template <
bool scalar, OperandDecoder predicate_decoder>
702 #include "ARMGenDisassemblerTables.inc"
707 return new ARMDisassembler(STI, Ctx);
715 switch (
MI.getOpcode()) {
734 if (
MI.getOperand(0).getReg() == ARM::SP &&
735 MI.getOperand(1).getReg() != ARM::SP)
738 default:
return Result;
746 if (STI.getFeatureBits()[ARM::ModeThumb])
747 return getThumbInstruction(
MI, Size, Bytes, Address, CS);
748 return getARMInstruction(
MI, Size, Bytes, Address, CS);
757 assert(!STI.getFeatureBits()[ARM::ModeThumb] &&
758 "Asked to disassemble an ARM instruction but Subtarget is in Thumb "
762 if (Bytes.
size() < 4) {
769 (Bytes[3] << 24) | (Bytes[2] << 16) | (Bytes[1] << 8) | (Bytes[0] << 0);
773 decodeInstruction(DecoderTableARM32,
MI,
Insn, Address,
this, STI);
784 const DecodeTable Tables[] = {
785 {DecoderTableVFP32,
false}, {DecoderTableVFPV832,
false},
786 {DecoderTableNEONData32,
true}, {DecoderTableNEONLoadStore32,
true},
787 {DecoderTableNEONDup32,
true}, {DecoderTablev8NEON32,
false},
788 {DecoderTablev8Crypto32,
false},
791 for (
auto Table : Tables) {
792 Result = decodeInstruction(Table.P,
MI,
Insn, Address,
this, STI);
804 decodeInstruction(DecoderTableCoProc32,
MI,
Insn, Address,
this, STI);
865 for (
unsigned i = 0;
i < NumOps; ++
i, ++
I) {
866 if (
I ==
MI.end())
break;
867 if (OpInfo[
i].isOptionalDef() && OpInfo[
i].RegClass == ARM::CCRRegClassID) {
868 if (
i > 0 && OpInfo[
i-1].isPredicate())
continue;
880 for (
unsigned i = 0;
i < NumOps; ++
i) {
892 ARMDisassembler::AddThumbPredicate(
MCInst &
MI)
const {
895 const FeatureBitset &FeatureBits = getSubtargetInfo().getFeatureBits();
899 switch (
MI.getOpcode()) {
916 if (ITBlock.instrInITBlock())
922 if (
MI.getOperand(0).getImm() == 0x10 && (FeatureBits[ARM::FeatureRAS]) != 0)
931 if (ITBlock.instrInITBlock() && !ITBlock.instrLastInITBlock())
948 if (ITBlock.instrInITBlock()) {
949 CC = ITBlock.getITCC();
950 ITBlock.advanceITState();
951 }
else if (VPTBlock.instrInVPTBlock()) {
952 VCC = VPTBlock.getVPTPred();
953 VPTBlock.advanceVPTState();
960 for (
unsigned i = 0;
i < NumOps; ++
i, ++CCI) {
961 if (OpInfo[
i].isPredicate() || CCI ==
MI.end())
break;
977 for (VCCPos = 0; VCCPos < NumOps; ++VCCPos, ++VCCI) {
995 "Inactive register in vpred_r is not tied to an output!");
1011 void ARMDisassembler::UpdateThumbVFPPredicate(
1014 CC = ITBlock.getITCC();
1017 if (ITBlock.instrInITBlock())
1018 ITBlock.advanceITState();
1019 else if (VPTBlock.instrInVPTBlock()) {
1020 CC = VPTBlock.getVPTPred();
1021 VPTBlock.advanceVPTState();
1027 for (
unsigned i = 0;
i < NumOps; ++
i, ++
I) {
1028 if (OpInfo[
i].isPredicate() ) {
1036 I->setReg(ARM::CPSR);
1046 CommentStream = &CS;
1048 assert(STI.getFeatureBits()[ARM::ModeThumb] &&
1049 "Asked to disassemble in Thumb mode but Subtarget is in ARM mode!");
1052 if (Bytes.
size() < 2) {
1057 uint16_t Insn16 = (Bytes[1] << 8) | Bytes[0];
1059 decodeInstruction(DecoderTableThumb16,
MI, Insn16, Address,
this, STI);
1062 Check(Result, AddThumbPredicate(
MI));
1066 Result = decodeInstruction(DecoderTableThumbSBit16,
MI, Insn16, Address,
this,
1070 bool InITBlock = ITBlock.instrInITBlock();
1071 Check(Result, AddThumbPredicate(
MI));
1077 decodeInstruction(DecoderTableThumb216,
MI, Insn16, Address,
this, STI);
1083 if (
MI.getOpcode() == ARM::t2IT && ITBlock.instrInITBlock())
1086 Check(Result, AddThumbPredicate(
MI));
1091 if (
MI.getOpcode() == ARM::t2IT) {
1092 unsigned Firstcond =
MI.getOperand(0).getImm();
1093 unsigned Mask =
MI.getOperand(1).getImm();
1094 ITBlock.setITState(Firstcond,
Mask);
1098 CS <<
"unpredictable IT predicate sequence";
1105 if (Bytes.
size() < 4) {
1111 (Bytes[3] << 8) | (Bytes[2] << 0) | (Bytes[1] << 24) | (Bytes[0] << 16);
1114 decodeInstruction(DecoderTableMVE32,
MI, Insn32, Address,
this, STI);
1120 if (
isVPTOpcode(
MI.getOpcode()) && VPTBlock.instrInVPTBlock())
1123 Check(Result, AddThumbPredicate(
MI));
1126 unsigned Mask =
MI.getOperand(0).getImm();
1127 VPTBlock.setVPTState(
Mask);
1134 decodeInstruction(DecoderTableThumb32,
MI, Insn32, Address,
this, STI);
1137 bool InITBlock = ITBlock.instrInITBlock();
1138 Check(Result, AddThumbPredicate(
MI));
1144 decodeInstruction(DecoderTableThumb232,
MI, Insn32, Address,
this, STI);
1147 Check(Result, AddThumbPredicate(
MI));
1151 if (fieldFromInstruction(Insn32, 28, 4) == 0xE) {
1153 decodeInstruction(DecoderTableVFP32,
MI, Insn32, Address,
this, STI);
1156 UpdateThumbVFPPredicate(Result,
MI);
1162 decodeInstruction(DecoderTableVFPV832,
MI, Insn32, Address,
this, STI);
1168 if (fieldFromInstruction(Insn32, 28, 4) == 0xE) {
1169 Result = decodeInstruction(DecoderTableNEONDup32,
MI, Insn32, Address,
this,
1173 Check(Result, AddThumbPredicate(
MI));
1178 if (fieldFromInstruction(Insn32, 24, 8) == 0xF9) {
1180 NEONLdStInsn &= 0xF0FFFFFF;
1181 NEONLdStInsn |= 0x04000000;
1182 Result = decodeInstruction(DecoderTableNEONLoadStore32,
MI, NEONLdStInsn,
1183 Address,
this, STI);
1186 Check(Result, AddThumbPredicate(
MI));
1191 if (fieldFromInstruction(Insn32, 24, 4) == 0xF) {
1193 NEONDataInsn &= 0xF0FFFFFF;
1194 NEONDataInsn |= (NEONDataInsn & 0x10000000) >> 4;
1195 NEONDataInsn |= 0x12000000;
1196 Result = decodeInstruction(DecoderTableNEONData32,
MI, NEONDataInsn,
1197 Address,
this, STI);
1200 Check(Result, AddThumbPredicate(
MI));
1205 NEONCryptoInsn &= 0xF0FFFFFF;
1206 NEONCryptoInsn |= (NEONCryptoInsn & 0x10000000) >> 4;
1207 NEONCryptoInsn |= 0x12000000;
1208 Result = decodeInstruction(DecoderTablev8Crypto32,
MI, NEONCryptoInsn,
1209 Address,
this, STI);
1216 NEONv8Insn &= 0xF3FFFFFF;
1217 Result = decodeInstruction(DecoderTablev8NEON32,
MI, NEONv8Insn, Address,
1225 uint32_t Coproc = fieldFromInstruction(Insn32, 8, 4);
1227 ? DecoderTableThumb2CDE32
1228 : DecoderTableThumb2CoProc32;
1230 decodeInstruction(DecoderTable,
MI, Insn32, Address,
this, STI);
1233 Check(Result, AddThumbPredicate(
MI));
1253 ARM::R0, ARM::R1,
ARM::R2, ARM::R3,
1255 ARM::R8, ARM::R9, ARM::R10, ARM::R11,
1256 ARM::R12, ARM::SP, ARM::LR, ARM::PC
1260 ARM::R0, ARM::R1,
ARM::R2, ARM::R3,
1262 ARM::R8, ARM::R9, ARM::R10, ARM::R11,
1263 ARM::R12, 0, ARM::LR, ARM::APSR
1369 ARM::R0_R1, ARM::R2_R3, ARM::R4_R5, ARM::R6_R7,
1370 ARM::R8_R9, ARM::R10_R11, ARM::R12_SP
1400 if ((RegNo & 1) || RegNo > 10)
1453 ((
const MCDisassembler*)Decoder)->getSubtargetInfo().getFeatureBits();
1455 if ((RegNo == 13 && !featureBits[ARM::HasV8Ops]) || RegNo == 15)
1463 ARM::S0, ARM::S1, ARM::S2, ARM::S3,
1464 ARM::S4, ARM::S5, ARM::S6, ARM::S7,
1465 ARM::S8, ARM::S9, ARM::S10, ARM::S11,
1466 ARM::S12, ARM::S13, ARM::S14, ARM::S15,
1467 ARM::S16, ARM::S17, ARM::S18, ARM::S19,
1468 ARM::S20, ARM::S21, ARM::S22, ARM::S23,
1469 ARM::S24, ARM::S25, ARM::S26, ARM::S27,
1470 ARM::S28, ARM::S29, ARM::S30, ARM::S31
1491 ARM::D0, ARM::D1, ARM::D2, ARM::D3,
1492 ARM::D4, ARM::D5, ARM::D6, ARM::D7,
1493 ARM::D8, ARM::D9, ARM::D10, ARM::D11,
1494 ARM::D12, ARM::D13, ARM::D14, ARM::D15,
1495 ARM::D16, ARM::D17, ARM::D18, ARM::D19,
1496 ARM::D20, ARM::D21, ARM::D22, ARM::D23,
1497 ARM::D24, ARM::D25, ARM::D26, ARM::D27,
1498 ARM::D28, ARM::D29, ARM::D30, ARM::D31
1505 ((
const MCDisassembler*)Decoder)->getSubtargetInfo().getFeatureBits();
1507 bool hasD32 = featureBits[ARM::FeatureD32];
1509 if (RegNo > 31 || (!hasD32 && RegNo > 15))
1542 ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3,
1543 ARM::Q4, ARM::Q5, ARM::Q6, ARM::Q7,
1544 ARM::Q8, ARM::Q9, ARM::Q10, ARM::Q11,
1545 ARM::Q12, ARM::Q13, ARM::Q14, ARM::Q15
1551 if (RegNo > 31 || (RegNo & 1) != 0)
1561 ARM::Q0, ARM::D1_D2, ARM::Q1, ARM::D3_D4, ARM::Q2, ARM::D5_D6,
1562 ARM::Q3, ARM::D7_D8, ARM::Q4, ARM::D9_D10, ARM::Q5, ARM::D11_D12,
1563 ARM::Q6, ARM::D13_D14, ARM::Q7, ARM::D15_D16, ARM::Q8, ARM::D17_D18,
1564 ARM::Q9, ARM::D19_D20, ARM::Q10, ARM::D21_D22, ARM::Q11, ARM::D23_D24,
1565 ARM::Q12, ARM::D25_D26, ARM::Q13, ARM::D27_D28, ARM::Q14, ARM::D29_D30,
1581 ARM::D0_D2, ARM::D1_D3, ARM::D2_D4, ARM::D3_D5,
1582 ARM::D4_D6, ARM::D5_D7, ARM::D6_D8, ARM::D7_D9,
1583 ARM::D8_D10, ARM::D9_D11, ARM::D10_D12, ARM::D11_D13,
1584 ARM::D12_D14, ARM::D13_D15, ARM::D14_D16, ARM::D15_D17,
1585 ARM::D16_D18, ARM::D17_D19, ARM::D18_D20, ARM::D19_D21,
1586 ARM::D20_D22, ARM::D21_D23, ARM::D22_D24, ARM::D23_D25,
1587 ARM::D24_D26, ARM::D25_D27, ARM::D26_D28, ARM::D27_D29,
1588 ARM::D28_D30, ARM::D29_D31
1608 if (Inst.
getOpcode() == ARM::tBcc && Val == 0xE)
1635 unsigned Rm = fieldFromInstruction(Val, 0, 4);
1636 unsigned type = fieldFromInstruction(Val, 5, 2);
1637 unsigned imm = fieldFromInstruction(Val, 7, 5);
1662 unsigned Op =
Shift | (imm << 3);
1673 unsigned Rm = fieldFromInstruction(Val, 0, 4);
1674 unsigned type = fieldFromInstruction(Val, 5, 2);
1675 unsigned Rs = fieldFromInstruction(Val, 8, 4);
1709 bool NeedDisjointWriteback =
false;
1710 unsigned WritebackReg = 0;
1715 case ARM::LDMIA_UPD:
1716 case ARM::LDMDB_UPD:
1717 case ARM::LDMIB_UPD:
1718 case ARM::LDMDA_UPD:
1719 case ARM::t2LDMIA_UPD:
1720 case ARM::t2LDMDB_UPD:
1721 case ARM::t2STMIA_UPD:
1722 case ARM::t2STMDB_UPD:
1723 NeedDisjointWriteback =
true;
1733 for (
unsigned i = 0;
i < 16; ++
i) {
1734 if (Val & (1 <<
i)) {
1743 if (NeedDisjointWriteback && WritebackReg == Inst.
end()[-1].getReg())
1757 unsigned Vd = fieldFromInstruction(Val, 8, 5);
1758 unsigned regs = fieldFromInstruction(Val, 0, 8);
1761 if (regs == 0 || (Vd + regs) > 32) {
1762 regs = Vd + regs > 32 ? 32 - Vd : regs;
1769 for (
unsigned i = 0;
i < (regs - 1); ++
i) {
1782 unsigned Vd = fieldFromInstruction(Val, 8, 5);
1783 unsigned regs = fieldFromInstruction(Val, 1, 7);
1786 if (regs == 0 || regs > 16 || (Vd + regs) > 32) {
1787 regs = Vd + regs > 32 ? 32 - Vd : regs;
1795 for (
unsigned i = 0;
i < (regs - 1); ++
i) {
1811 unsigned msb = fieldFromInstruction(Val, 5, 5);
1812 unsigned lsb = fieldFromInstruction(Val, 0, 5);
1824 if (msb != 31) msb_mask = (1U << (msb+1)) - 1;
1825 uint32_t lsb_mask = (1U << lsb) - 1;
1836 unsigned pred = fieldFromInstruction(
Insn, 28, 4);
1837 unsigned CRd = fieldFromInstruction(
Insn, 12, 4);
1838 unsigned coproc = fieldFromInstruction(
Insn, 8, 4);
1839 unsigned imm = fieldFromInstruction(
Insn, 0, 8);
1840 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
1841 unsigned U = fieldFromInstruction(
Insn, 23, 1);
1843 ((
const MCDisassembler*)Decoder)->getSubtargetInfo().getFeatureBits();
1846 case ARM::LDC_OFFSET:
1849 case ARM::LDC_OPTION:
1850 case ARM::LDCL_OFFSET:
1852 case ARM::LDCL_POST:
1853 case ARM::LDCL_OPTION:
1854 case ARM::STC_OFFSET:
1857 case ARM::STC_OPTION:
1858 case ARM::STCL_OFFSET:
1860 case ARM::STCL_POST:
1861 case ARM::STCL_OPTION:
1862 case ARM::t2LDC_OFFSET:
1863 case ARM::t2LDC_PRE:
1864 case ARM::t2LDC_POST:
1865 case ARM::t2LDC_OPTION:
1866 case ARM::t2LDCL_OFFSET:
1867 case ARM::t2LDCL_PRE:
1868 case ARM::t2LDCL_POST:
1869 case ARM::t2LDCL_OPTION:
1870 case ARM::t2STC_OFFSET:
1871 case ARM::t2STC_PRE:
1872 case ARM::t2STC_POST:
1873 case ARM::t2STC_OPTION:
1874 case ARM::t2STCL_OFFSET:
1875 case ARM::t2STCL_PRE:
1876 case ARM::t2STCL_POST:
1877 case ARM::t2STCL_OPTION:
1878 case ARM::t2LDC2_OFFSET:
1879 case ARM::t2LDC2L_OFFSET:
1880 case ARM::t2LDC2_PRE:
1881 case ARM::t2LDC2L_PRE:
1882 case ARM::t2STC2_OFFSET:
1883 case ARM::t2STC2L_OFFSET:
1884 case ARM::t2STC2_PRE:
1885 case ARM::t2STC2L_PRE:
1886 case ARM::LDC2_OFFSET:
1887 case ARM::LDC2L_OFFSET:
1889 case ARM::LDC2L_PRE:
1890 case ARM::STC2_OFFSET:
1891 case ARM::STC2L_OFFSET:
1893 case ARM::STC2L_PRE:
1894 case ARM::t2LDC2_OPTION:
1895 case ARM::t2STC2_OPTION:
1896 case ARM::t2LDC2_POST:
1897 case ARM::t2LDC2L_POST:
1898 case ARM::t2STC2_POST:
1899 case ARM::t2STC2L_POST:
1900 case ARM::LDC2_POST:
1901 case ARM::LDC2L_POST:
1902 case ARM::STC2_POST:
1903 case ARM::STC2L_POST:
1904 if (coproc == 0xA || coproc == 0xB ||
1905 (featureBits[ARM::HasV8_1MMainlineOps] &&
1906 (coproc == 0x8 || coproc == 0x9 || coproc == 0xA || coproc == 0xB ||
1907 coproc == 0xE || coproc == 0xF)))
1914 if (featureBits[ARM::HasV8Ops] && (coproc != 14))
1923 case ARM::t2LDC2_OFFSET:
1924 case ARM::t2LDC2L_OFFSET:
1925 case ARM::t2LDC2_PRE:
1926 case ARM::t2LDC2L_PRE:
1927 case ARM::t2STC2_OFFSET:
1928 case ARM::t2STC2L_OFFSET:
1929 case ARM::t2STC2_PRE:
1930 case ARM::t2STC2L_PRE:
1931 case ARM::LDC2_OFFSET:
1932 case ARM::LDC2L_OFFSET:
1934 case ARM::LDC2L_PRE:
1935 case ARM::STC2_OFFSET:
1936 case ARM::STC2L_OFFSET:
1938 case ARM::STC2L_PRE:
1939 case ARM::t2LDC_OFFSET:
1940 case ARM::t2LDCL_OFFSET:
1941 case ARM::t2LDC_PRE:
1942 case ARM::t2LDCL_PRE:
1943 case ARM::t2STC_OFFSET:
1944 case ARM::t2STCL_OFFSET:
1945 case ARM::t2STC_PRE:
1946 case ARM::t2STCL_PRE:
1947 case ARM::LDC_OFFSET:
1948 case ARM::LDCL_OFFSET:
1951 case ARM::STC_OFFSET:
1952 case ARM::STCL_OFFSET:
1958 case ARM::t2LDC2_POST:
1959 case ARM::t2LDC2L_POST:
1960 case ARM::t2STC2_POST:
1961 case ARM::t2STC2L_POST:
1962 case ARM::LDC2_POST:
1963 case ARM::LDC2L_POST:
1964 case ARM::STC2_POST:
1965 case ARM::STC2L_POST:
1966 case ARM::t2LDC_POST:
1967 case ARM::t2LDCL_POST:
1968 case ARM::t2STC_POST:
1969 case ARM::t2STCL_POST:
1971 case ARM::LDCL_POST:
1973 case ARM::STCL_POST:
1984 case ARM::LDC_OFFSET:
1987 case ARM::LDC_OPTION:
1988 case ARM::LDCL_OFFSET:
1990 case ARM::LDCL_POST:
1991 case ARM::LDCL_OPTION:
1992 case ARM::STC_OFFSET:
1995 case ARM::STC_OPTION:
1996 case ARM::STCL_OFFSET:
1998 case ARM::STCL_POST:
1999 case ARM::STCL_OPTION:
2015 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
2016 unsigned Rt = fieldFromInstruction(
Insn, 12, 4);
2017 unsigned Rm = fieldFromInstruction(
Insn, 0, 4);
2018 unsigned imm = fieldFromInstruction(
Insn, 0, 12);
2019 unsigned pred = fieldFromInstruction(
Insn, 28, 4);
2020 unsigned reg = fieldFromInstruction(
Insn, 25, 1);
2021 unsigned P = fieldFromInstruction(
Insn, 24, 1);
2022 unsigned W = fieldFromInstruction(
Insn, 21, 1);
2026 case ARM::STR_POST_IMM:
2027 case ARM::STR_POST_REG:
2028 case ARM::STRB_POST_IMM:
2029 case ARM::STRB_POST_REG:
2030 case ARM::STRT_POST_REG:
2031 case ARM::STRT_POST_IMM:
2032 case ARM::STRBT_POST_REG:
2033 case ARM::STRBT_POST_IMM:
2046 case ARM::LDR_POST_IMM:
2047 case ARM::LDR_POST_REG:
2048 case ARM::LDRB_POST_IMM:
2049 case ARM::LDRB_POST_REG:
2050 case ARM::LDRBT_POST_REG:
2051 case ARM::LDRBT_POST_IMM:
2052 case ARM::LDRT_POST_REG:
2053 case ARM::LDRT_POST_IMM:
2065 if (!fieldFromInstruction(
Insn, 23, 1))
2068 bool writeback = (
P == 0) || (
W == 1);
2069 unsigned idx_mode = 0;
2072 else if (!
P && writeback)
2075 if (writeback && (Rn == 15 || Rn == Rt))
2082 switch( fieldFromInstruction(
Insn, 5, 2)) {
2098 unsigned amt = fieldFromInstruction(
Insn, 7, 5);
2121 unsigned Rn = fieldFromInstruction(Val, 13, 4);
2122 unsigned Rm = fieldFromInstruction(Val, 0, 4);
2123 unsigned type = fieldFromInstruction(Val, 5, 2);
2124 unsigned imm = fieldFromInstruction(Val, 7, 5);
2125 unsigned U = fieldFromInstruction(Val, 12, 1);
2178 unsigned Rt = fieldFromInstruction(
Insn, 12, 4);
2179 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
2180 unsigned Rm = fieldFromInstruction(
Insn, 0, 4);
2181 unsigned type = fieldFromInstruction(
Insn, 22, 1);
2182 unsigned imm = fieldFromInstruction(
Insn, 8, 4);
2183 unsigned U = ((~fieldFromInstruction(
Insn, 23, 1)) & 1) << 8;
2184 unsigned pred = fieldFromInstruction(
Insn, 28, 4);
2185 unsigned W = fieldFromInstruction(
Insn, 21, 1);
2186 unsigned P = fieldFromInstruction(
Insn, 24, 1);
2187 unsigned Rt2 = Rt + 1;
2189 bool writeback = (
W == 1) | (
P == 0);
2195 case ARM::STRD_POST:
2198 case ARM::LDRD_POST:
2207 case ARM::STRD_POST:
2208 if (
P == 0 &&
W == 1)
2211 if (writeback && (Rn == 15 || Rn == Rt || Rn == Rt2))
2213 if (
type && Rm == 15)
2217 if (!
type && fieldFromInstruction(
Insn, 8, 4))
2222 case ARM::STRH_POST:
2225 if (writeback && (Rn == 15 || Rn == Rt))
2227 if (!
type && Rm == 15)
2232 case ARM::LDRD_POST:
2233 if (
type && Rn == 15) {
2238 if (
P == 0 &&
W == 1)
2240 if (!
type && (Rt2 == 15 || Rm == 15 || Rm == Rt || Rm == Rt2))
2242 if (!
type && writeback && Rn == 15)
2244 if (writeback && (Rn == Rt || Rn == Rt2))
2249 case ARM::LDRH_POST:
2250 if (
type && Rn == 15) {
2257 if (!
type && Rm == 15)
2259 if (!
type && writeback && (Rn == 15 || Rn == Rt))
2263 case ARM::LDRSH_PRE:
2264 case ARM::LDRSH_POST:
2266 case ARM::LDRSB_PRE:
2267 case ARM::LDRSB_POST:
2268 if (
type && Rn == 15) {
2273 if (
type && (Rt == 15 || (writeback && Rn == Rt)))
2275 if (!
type && (Rt == 15 || Rm == 15))
2277 if (!
type && writeback && (Rn == 15 || Rn == Rt))
2294 case ARM::STRD_POST:
2297 case ARM::STRH_POST:
2311 case ARM::STRD_POST:
2314 case ARM::LDRD_POST:
2327 case ARM::LDRD_POST:
2330 case ARM::LDRH_POST:
2332 case ARM::LDRSH_PRE:
2333 case ARM::LDRSH_POST:
2335 case ARM::LDRSB_PRE:
2336 case ARM::LDRSB_POST:
2370 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
2371 unsigned mode = fieldFromInstruction(
Insn, 23, 2);
2400 unsigned Rd = fieldFromInstruction(
Insn, 12, 4);
2401 unsigned Rm = fieldFromInstruction(
Insn, 0, 4);
2402 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
2403 unsigned pred = fieldFromInstruction(
Insn, 28, 4);
2425 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
2426 unsigned pred = fieldFromInstruction(
Insn, 28, 4);
2427 unsigned reglist = fieldFromInstruction(
Insn, 0, 16);
2435 case ARM::LDMDA_UPD:
2441 case ARM::LDMDB_UPD:
2447 case ARM::LDMIA_UPD:
2453 case ARM::LDMIB_UPD:
2459 case ARM::STMDA_UPD:
2465 case ARM::STMDB_UPD:
2471 case ARM::STMIA_UPD:
2477 case ARM::STMIB_UPD:
2485 if (fieldFromInstruction(
Insn, 20, 1) == 0) {
2487 if (!(fieldFromInstruction(
Insn, 22, 1) == 1 &&
2488 fieldFromInstruction(
Insn, 20, 1) == 0))
2515 unsigned pred = fieldFromInstruction(
Insn, 28, 4);
2516 unsigned imm8 = fieldFromInstruction(
Insn, 0, 8);
2529 if (imm8 == 0x10 &&
pred != 0xe && ((FeatureBits[ARM::FeatureRAS]) != 0))
2538 unsigned imod = fieldFromInstruction(
Insn, 18, 2);
2539 unsigned M = fieldFromInstruction(
Insn, 17, 1);
2540 unsigned iflags = fieldFromInstruction(
Insn, 6, 3);
2541 unsigned mode = fieldFromInstruction(
Insn, 0, 5);
2547 if (fieldFromInstruction(
Insn, 5, 1) != 0 ||
2548 fieldFromInstruction(
Insn, 16, 1) != 0 ||
2549 fieldFromInstruction(
Insn, 20, 8) != 0x10)
2564 }
else if (imod && !
M) {
2569 }
else if (!imod &&
M) {
2586 unsigned imod = fieldFromInstruction(
Insn, 9, 2);
2587 unsigned M = fieldFromInstruction(
Insn, 8, 1);
2588 unsigned iflags = fieldFromInstruction(
Insn, 5, 3);
2589 unsigned mode = fieldFromInstruction(
Insn, 0, 5);
2605 }
else if (imod && !
M) {
2610 }
else if (!imod &&
M) {
2616 int imm = fieldFromInstruction(
Insn, 0, 8);
2629 unsigned imm = fieldFromInstruction(
Insn, 0, 8);
2631 unsigned Opcode = ARM::t2HINT;
2634 Opcode = ARM::t2PACBTI;
2635 }
else if (imm == 0x1D) {
2636 Opcode = ARM::t2PAC;
2637 }
else if (imm == 0x2D) {
2638 Opcode = ARM::t2AUT;
2639 }
else if (imm == 0x0F) {
2640 Opcode = ARM::t2BTI;
2644 if (Opcode == ARM::t2HINT) {
2656 unsigned Rd = fieldFromInstruction(
Insn, 8, 4);
2659 imm |= (fieldFromInstruction(
Insn, 0, 8) << 0);
2660 imm |= (fieldFromInstruction(
Insn, 12, 3) << 8);
2661 imm |= (fieldFromInstruction(
Insn, 16, 4) << 12);
2662 imm |= (fieldFromInstruction(
Insn, 26, 1) << 11);
2681 unsigned Rd = fieldFromInstruction(
Insn, 12, 4);
2682 unsigned pred = fieldFromInstruction(
Insn, 28, 4);
2685 imm |= (fieldFromInstruction(
Insn, 0, 12) << 0);
2686 imm |= (fieldFromInstruction(
Insn, 16, 4) << 12);
2709 unsigned Rd = fieldFromInstruction(
Insn, 16, 4);
2710 unsigned Rn = fieldFromInstruction(
Insn, 0, 4);
2711 unsigned Rm = fieldFromInstruction(
Insn, 8, 4);
2712 unsigned Ra = fieldFromInstruction(
Insn, 12, 4);
2713 unsigned pred = fieldFromInstruction(
Insn, 28, 4);
2738 unsigned Pred = fieldFromInstruction(
Insn, 28, 4);
2739 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
2740 unsigned Rm = fieldFromInstruction(
Insn, 0, 4);
2760 unsigned Imm = fieldFromInstruction(
Insn, 9, 1);
2765 if (!FeatureBits[ARM::HasV8_1aOps] ||
2766 !FeatureBits[ARM::HasV8Ops])
2771 if (fieldFromInstruction(
Insn, 20,12) != 0xf11 ||
2772 fieldFromInstruction(
Insn, 4,4) != 0)
2774 if (fieldFromInstruction(
Insn, 10,10) != 0 ||
2775 fieldFromInstruction(
Insn, 0,4) != 0)
2789 unsigned add = fieldFromInstruction(Val, 12, 1);
2790 unsigned imm = fieldFromInstruction(Val, 0, 12);
2791 unsigned Rn = fieldFromInstruction(Val, 13, 4);
2796 if (!
add) imm *= -1;
2797 if (imm == 0 && !
add) imm = INT32_MIN;
2810 unsigned Rn = fieldFromInstruction(Val, 9, 4);
2812 unsigned U = fieldFromInstruction(Val, 8, 1);
2813 unsigned imm = fieldFromInstruction(Val, 0, 8);
2831 unsigned Rn = fieldFromInstruction(Val, 9, 4);
2833 unsigned U = fieldFromInstruction(Val, 8, 1);
2834 unsigned imm = fieldFromInstruction(Val, 0, 8);
2864 unsigned S = fieldFromInstruction(
Insn, 26, 1);
2865 unsigned J1 = fieldFromInstruction(
Insn, 13, 1);
2866 unsigned J2 = fieldFromInstruction(
Insn, 11, 1);
2867 unsigned I1 = !(J1 ^
S);
2868 unsigned I2 = !(J2 ^
S);
2869 unsigned imm10 = fieldFromInstruction(
Insn, 16, 10);
2870 unsigned imm11 = fieldFromInstruction(
Insn, 0, 11);
2871 unsigned tmp = (
S << 23) | (
I1 << 22) | (I2 << 21) | (imm10 << 11) | imm11;
2872 int imm32 = SignExtend32<25>(
tmp << 1);
2874 true, 4, Inst, Decoder))
2885 unsigned pred = fieldFromInstruction(
Insn, 28, 4);
2886 unsigned imm = fieldFromInstruction(
Insn, 0, 24) << 2;
2890 imm |= fieldFromInstruction(
Insn, 24, 1) << 1;
2892 true, 4, Inst, Decoder))
2898 true, 4, Inst, Decoder))
2915 unsigned Rm = fieldFromInstruction(Val, 0, 4);
2916 unsigned align = fieldFromInstruction(Val, 4, 2);
2933 unsigned Rd = fieldFromInstruction(
Insn, 12, 4);
2934 Rd |= fieldFromInstruction(
Insn, 22, 1) << 4;
2935 unsigned wb = fieldFromInstruction(
Insn, 16, 4);
2936 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
2937 Rn |= fieldFromInstruction(
Insn, 4, 2) << 4;
2938 unsigned Rm = fieldFromInstruction(
Insn, 0, 4);
2942 case ARM::VLD1q16:
case ARM::VLD1q32:
case ARM::VLD1q64:
case ARM::VLD1q8:
2943 case ARM::VLD1q16wb_fixed:
case ARM::VLD1q16wb_register:
2944 case ARM::VLD1q32wb_fixed:
case ARM::VLD1q32wb_register:
2945 case ARM::VLD1q64wb_fixed:
case ARM::VLD1q64wb_register:
2946 case ARM::VLD1q8wb_fixed:
case ARM::VLD1q8wb_register:
2947 case ARM::VLD2d16:
case ARM::VLD2d32:
case ARM::VLD2d8:
2948 case ARM::VLD2d16wb_fixed:
case ARM::VLD2d16wb_register:
2949 case ARM::VLD2d32wb_fixed:
case ARM::VLD2d32wb_register:
2950 case ARM::VLD2d8wb_fixed:
case ARM::VLD2d8wb_register:
2957 case ARM::VLD2b16wb_fixed:
2958 case ARM::VLD2b16wb_register:
2959 case ARM::VLD2b32wb_fixed:
2960 case ARM::VLD2b32wb_register:
2961 case ARM::VLD2b8wb_fixed:
2962 case ARM::VLD2b8wb_register:
2976 case ARM::VLD3d8_UPD:
2977 case ARM::VLD3d16_UPD:
2978 case ARM::VLD3d32_UPD:
2982 case ARM::VLD4d8_UPD:
2983 case ARM::VLD4d16_UPD:
2984 case ARM::VLD4d32_UPD:
2991 case ARM::VLD3q8_UPD:
2992 case ARM::VLD3q16_UPD:
2993 case ARM::VLD3q32_UPD:
2997 case ARM::VLD4q8_UPD:
2998 case ARM::VLD4q16_UPD:
2999 case ARM::VLD4q32_UPD:
3012 case ARM::VLD3d8_UPD:
3013 case ARM::VLD3d16_UPD:
3014 case ARM::VLD3d32_UPD:
3018 case ARM::VLD4d8_UPD:
3019 case ARM::VLD4d16_UPD:
3020 case ARM::VLD4d32_UPD:
3027 case ARM::VLD3q8_UPD:
3028 case ARM::VLD3q16_UPD:
3029 case ARM::VLD3q32_UPD:
3033 case ARM::VLD4q8_UPD:
3034 case ARM::VLD4q16_UPD:
3035 case ARM::VLD4q32_UPD:
3048 case ARM::VLD4d8_UPD:
3049 case ARM::VLD4d16_UPD:
3050 case ARM::VLD4d32_UPD:
3057 case ARM::VLD4q8_UPD:
3058 case ARM::VLD4q16_UPD:
3059 case ARM::VLD4q32_UPD:
3069 case ARM::VLD1d8wb_fixed:
3070 case ARM::VLD1d16wb_fixed:
3071 case ARM::VLD1d32wb_fixed:
3072 case ARM::VLD1d64wb_fixed:
3073 case ARM::VLD1d8wb_register:
3074 case ARM::VLD1d16wb_register:
3075 case ARM::VLD1d32wb_register:
3076 case ARM::VLD1d64wb_register:
3077 case ARM::VLD1q8wb_fixed:
3078 case ARM::VLD1q16wb_fixed:
3079 case ARM::VLD1q32wb_fixed:
3080 case ARM::VLD1q64wb_fixed:
3081 case ARM::VLD1q8wb_register:
3082 case ARM::VLD1q16wb_register:
3083 case ARM::VLD1q32wb_register:
3084 case ARM::VLD1q64wb_register:
3085 case ARM::VLD1d8Twb_fixed:
3086 case ARM::VLD1d8Twb_register:
3087 case ARM::VLD1d16Twb_fixed:
3088 case ARM::VLD1d16Twb_register:
3089 case ARM::VLD1d32Twb_fixed:
3090 case ARM::VLD1d32Twb_register:
3091 case ARM::VLD1d64Twb_fixed:
3092 case ARM::VLD1d64Twb_register:
3093 case ARM::VLD1d8Qwb_fixed:
3094 case ARM::VLD1d8Qwb_register:
3095 case ARM::VLD1d16Qwb_fixed:
3096 case ARM::VLD1d16Qwb_register:
3097 case ARM::VLD1d32Qwb_fixed:
3098 case ARM::VLD1d32Qwb_register:
3099 case ARM::VLD1d64Qwb_fixed:
3100 case ARM::VLD1d64Qwb_register:
3101 case ARM::VLD2d8wb_fixed:
3102 case ARM::VLD2d16wb_fixed:
3103 case ARM::VLD2d32wb_fixed:
3104 case ARM::VLD2q8wb_fixed:
3105 case ARM::VLD2q16wb_fixed:
3106 case ARM::VLD2q32wb_fixed:
3107 case ARM::VLD2d8wb_register:
3108 case ARM::VLD2d16wb_register:
3109 case ARM::VLD2d32wb_register:
3110 case ARM::VLD2q8wb_register:
3111 case ARM::VLD2q16wb_register:
3112 case ARM::VLD2q32wb_register:
3113 case ARM::VLD2b8wb_fixed:
3114 case ARM::VLD2b16wb_fixed:
3115 case ARM::VLD2b32wb_fixed:
3116 case ARM::VLD2b8wb_register:
3117 case ARM::VLD2b16wb_register:
3118 case ARM::VLD2b32wb_register:
3121 case ARM::VLD3d8_UPD:
3122 case ARM::VLD3d16_UPD:
3123 case ARM::VLD3d32_UPD:
3124 case ARM::VLD3q8_UPD:
3125 case ARM::VLD3q16_UPD:
3126 case ARM::VLD3q32_UPD:
3127 case ARM::VLD4d8_UPD:
3128 case ARM::VLD4d16_UPD:
3129 case ARM::VLD4d32_UPD:
3130 case ARM::VLD4q8_UPD:
3131 case ARM::VLD4q16_UPD:
3132 case ARM::VLD4q32_UPD:
3159 case ARM::VLD1d8wb_fixed:
3160 case ARM::VLD1d16wb_fixed:
3161 case ARM::VLD1d32wb_fixed:
3162 case ARM::VLD1d64wb_fixed:
3163 case ARM::VLD1d8Twb_fixed:
3164 case ARM::VLD1d16Twb_fixed:
3165 case ARM::VLD1d32Twb_fixed:
3166 case ARM::VLD1d64Twb_fixed:
3167 case ARM::VLD1d8Qwb_fixed:
3168 case ARM::VLD1d16Qwb_fixed:
3169 case ARM::VLD1d32Qwb_fixed:
3170 case ARM::VLD1d64Qwb_fixed:
3171 case ARM::VLD1d8wb_register:
3172 case ARM::VLD1d16wb_register:
3173 case ARM::VLD1d32wb_register:
3174 case ARM::VLD1d64wb_register:
3175 case ARM::VLD1q8wb_fixed:
3176 case ARM::VLD1q16wb_fixed:
3177 case ARM::VLD1q32wb_fixed:
3178 case ARM::VLD1q64wb_fixed:
3179 case ARM::VLD1q8wb_register:
3180 case ARM::VLD1q16wb_register:
3181 case ARM::VLD1q32wb_register:
3182 case ARM::VLD1q64wb_register:
3186 if (Rm != 0xD && Rm != 0xF &&
3190 case ARM::VLD2d8wb_fixed:
3191 case ARM::VLD2d16wb_fixed:
3192 case ARM::VLD2d32wb_fixed:
3193 case ARM::VLD2b8wb_fixed:
3194 case ARM::VLD2b16wb_fixed:
3195 case ARM::VLD2b32wb_fixed:
3196 case ARM::VLD2q8wb_fixed:
3197 case ARM::VLD2q16wb_fixed:
3198 case ARM::VLD2q32wb_fixed:
3208 unsigned type = fieldFromInstruction(
Insn, 8, 4);
3209 unsigned align = fieldFromInstruction(
Insn, 4, 2);
3214 unsigned load = fieldFromInstruction(
Insn, 21, 1);
3222 unsigned size = fieldFromInstruction(
Insn, 6, 2);
3225 unsigned type = fieldFromInstruction(
Insn, 8, 4);
3226 unsigned align = fieldFromInstruction(
Insn, 4, 2);
3230 unsigned load = fieldFromInstruction(
Insn, 21, 1);
3238 unsigned size = fieldFromInstruction(
Insn, 6, 2);
3241 unsigned align = fieldFromInstruction(
Insn, 4, 2);
3244 unsigned load = fieldFromInstruction(
Insn, 21, 1);
3252 unsigned size = fieldFromInstruction(
Insn, 6, 2);
3255 unsigned load = fieldFromInstruction(
Insn, 21, 1);
3265 unsigned Rd = fieldFromInstruction(
Insn, 12, 4);
3266 Rd |= fieldFromInstruction(
Insn, 22, 1) << 4;
3267 unsigned wb = fieldFromInstruction(
Insn, 16, 4);
3268 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
3269 Rn |= fieldFromInstruction(
Insn, 4, 2) << 4;
3270 unsigned Rm = fieldFromInstruction(
Insn, 0, 4);
3274 case ARM::VST1d8wb_fixed:
3275 case ARM::VST1d16wb_fixed:
3276 case ARM::VST1d32wb_fixed:
3277 case ARM::VST1d64wb_fixed:
3278 case ARM::VST1d8wb_register:
3279 case ARM::VST1d16wb_register:
3280 case ARM::VST1d32wb_register:
3281 case ARM::VST1d64wb_register:
3282 case ARM::VST1q8wb_fixed:
3283 case ARM::VST1q16wb_fixed:
3284 case ARM::VST1q32wb_fixed:
3285 case ARM::VST1q64wb_fixed:
3286 case ARM::VST1q8wb_register:
3287 case ARM::VST1q16wb_register:
3288 case ARM::VST1q32wb_register:
3289 case ARM::VST1q64wb_register:
3290 case ARM::VST1d8Twb_fixed:
3291 case ARM::VST1d16Twb_fixed:
3292 case ARM::VST1d32Twb_fixed:
3293 case ARM::VST1d64Twb_fixed:
3294 case ARM::VST1d8Twb_register:
3295 case ARM::VST1d16Twb_register:
3296 case ARM::VST1d32Twb_register:
3297 case ARM::VST1d64Twb_register:
3298 case ARM::VST1d8Qwb_fixed:
3299 case ARM::VST1d16Qwb_fixed:
3300 case ARM::VST1d32Qwb_fixed:
3301 case ARM::VST1d64Qwb_fixed:
3302 case ARM::VST1d8Qwb_register:
3303 case ARM::VST1d16Qwb_register:
3304 case ARM::VST1d32Qwb_register:
3305 case ARM::VST1d64Qwb_register:
3306 case ARM::VST2d8wb_fixed:
3307 case ARM::VST2d16wb_fixed:
3308 case ARM::VST2d32wb_fixed:
3309 case ARM::VST2d8wb_register:
3310 case ARM::VST2d16wb_register:
3311 case ARM::VST2d32wb_register:
3312 case ARM::VST2q8wb_fixed:
3313 case ARM::VST2q16wb_fixed:
3314 case ARM::VST2q32wb_fixed:
3315 case ARM::VST2q8wb_register:
3316 case ARM::VST2q16wb_register:
3317 case ARM::VST2q32wb_register:
3318 case ARM::VST2b8wb_fixed:
3319 case ARM::VST2b16wb_fixed:
3320 case ARM::VST2b32wb_fixed:
3321 case ARM::VST2b8wb_register:
3322 case ARM::VST2b16wb_register:
3323 case ARM::VST2b32wb_register:
3328 case ARM::VST3d8_UPD:
3329 case ARM::VST3d16_UPD:
3330 case ARM::VST3d32_UPD:
3331 case ARM::VST3q8_UPD:
3332 case ARM::VST3q16_UPD:
3333 case ARM::VST3q32_UPD:
3334 case ARM::VST4d8_UPD:
3335 case ARM::VST4d16_UPD:
3336 case ARM::VST4d32_UPD:
3337 case ARM::VST4q8_UPD:
3338 case ARM::VST4q16_UPD:
3339 case ARM::VST4q32_UPD:
3356 else if (Rm != 0xF) {
3361 case ARM::VST1d8wb_fixed:
3362 case ARM::VST1d16wb_fixed:
3363 case ARM::VST1d32wb_fixed:
3364 case ARM::VST1d64wb_fixed:
3365 case ARM::VST1q8wb_fixed:
3366 case ARM::VST1q16wb_fixed:
3367 case ARM::VST1q32wb_fixed:
3368 case ARM::VST1q64wb_fixed:
3369 case ARM::VST1d8Twb_fixed:
3370 case ARM::VST1d16Twb_fixed:
3371 case ARM::VST1d32Twb_fixed:
3372 case ARM::VST1d64Twb_fixed:
3373 case ARM::VST1d8Qwb_fixed:
3374 case ARM::VST1d16Qwb_fixed:
3375 case ARM::VST1d32Qwb_fixed:
3376 case ARM::VST1d64Qwb_fixed:
3377 case ARM::VST2d8wb_fixed:
3378 case ARM::VST2d16wb_fixed:
3379 case ARM::VST2d32wb_fixed:
3380 case ARM::VST2q8wb_fixed:
3381 case ARM::VST2q16wb_fixed:
3382 case ARM::VST2q32wb_fixed:
3383 case ARM::VST2b8wb_fixed:
3384 case ARM::VST2b16wb_fixed:
3385 case ARM::VST2b32wb_fixed:
3395 case ARM::VST1q16wb_fixed:
3396 case ARM::VST1q16wb_register:
3397 case ARM::VST1q32wb_fixed:
3398 case ARM::VST1q32wb_register:
3399 case ARM::VST1q64wb_fixed:
3400 case ARM::VST1q64wb_register:
3401 case ARM::VST1q8wb_fixed:
3402 case ARM::VST1q8wb_register:
3406 case ARM::VST2d16wb_fixed:
3407 case ARM::VST2d16wb_register:
3408 case ARM::VST2d32wb_fixed:
3409 case ARM::VST2d32wb_register:
3410 case ARM::VST2d8wb_fixed:
3411 case ARM::VST2d8wb_register:
3418 case ARM::VST2b16wb_fixed:
3419 case ARM::VST2b16wb_register:
3420 case ARM::VST2b32wb_fixed:
3421 case ARM::VST2b32wb_register:
3422 case ARM::VST2b8wb_fixed:
3423 case ARM::VST2b8wb_register:
3437 case ARM::VST3d8_UPD:
3438 case ARM::VST3d16_UPD:
3439 case ARM::VST3d32_UPD:
3443 case ARM::VST4d8_UPD:
3444 case ARM::VST4d16_UPD:
3445 case ARM::VST4d32_UPD:
3452 case ARM::VST3q8_UPD:
3453 case ARM::VST3q16_UPD:
3454 case ARM::VST3q32_UPD:
3458 case ARM::VST4q8_UPD:
3459 case ARM::VST4q16_UPD:
3460 case ARM::VST4q32_UPD:
3473 case ARM::VST3d8_UPD:
3474 case ARM::VST3d16_UPD:
3475 case ARM::VST3d32_UPD:
3479 case ARM::VST4d8_UPD:
3480 case ARM::VST4d16_UPD:
3481 case ARM::VST4d32_UPD:
3488 case ARM::VST3q8_UPD:
3489 case ARM::VST3q16_UPD:
3490 case ARM::VST3q32_UPD:
3494 case ARM::VST4q8_UPD:
3495 case ARM::VST4q16_UPD:
3496 case ARM::VST4q32_UPD:
3509 case ARM::VST4d8_UPD:
3510 case ARM::VST4d16_UPD:
3511 case ARM::VST4d32_UPD:
3518 case ARM::VST4q8_UPD:
3519 case ARM::VST4q16_UPD:
3520 case ARM::VST4q32_UPD:
3536 unsigned Rd = fieldFromInstruction(
Insn, 12, 4);
3537 Rd |= fieldFromInstruction(
Insn, 22, 1) << 4;
3538 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
3539 unsigned Rm = fieldFromInstruction(
Insn, 0, 4);
3540 unsigned align = fieldFromInstruction(
Insn, 4, 1);
3541 unsigned size = fieldFromInstruction(
Insn, 6, 2);
3548 case ARM::VLD1DUPq16:
case ARM::VLD1DUPq32:
case ARM::VLD1DUPq8:
3549 case ARM::VLD1DUPq16wb_fixed:
case ARM::VLD1DUPq16wb_register:
3550 case ARM::VLD1DUPq32wb_fixed:
case ARM::VLD1DUPq32wb_register:
3551 case ARM::VLD1DUPq8wb_fixed:
case ARM::VLD1DUPq8wb_register:
3572 if (Rm != 0xD && Rm != 0xF &&
3584 unsigned Rd = fieldFromInstruction(
Insn, 12, 4);
3585 Rd |= fieldFromInstruction(
Insn, 22, 1) << 4;
3586 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
3587 unsigned Rm = fieldFromInstruction(
Insn, 0, 4);
3588 unsigned align = fieldFromInstruction(
Insn, 4, 1);
3589 unsigned size = 1 << fieldFromInstruction(
Insn, 6, 2);
3593 case ARM::VLD2DUPd16:
case ARM::VLD2DUPd32:
case ARM::VLD2DUPd8:
3594 case ARM::VLD2DUPd16wb_fixed:
case ARM::VLD2DUPd16wb_register:
3595 case ARM::VLD2DUPd32wb_fixed:
case ARM::VLD2DUPd32wb_register:
3596 case ARM::VLD2DUPd8wb_fixed:
case ARM::VLD2DUPd8wb_register:
3600 case ARM::VLD2DUPd16x2:
case ARM::VLD2DUPd32x2:
case ARM::VLD2DUPd8x2:
3601 case ARM::VLD2DUPd16x2wb_fixed:
case ARM::VLD2DUPd16x2wb_register:
3602 case ARM::VLD2DUPd32x2wb_fixed:
case ARM::VLD2DUPd32x2wb_register:
3603 case ARM::VLD2DUPd8x2wb_fixed:
case ARM::VLD2DUPd8x2wb_register:
3620 if (Rm != 0xD && Rm != 0xF) {
3633 unsigned Rd = fieldFromInstruction(
Insn, 12, 4);
3634 Rd |= fieldFromInstruction(
Insn, 22, 1) << 4;
3635 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
3636 unsigned Rm = fieldFromInstruction(
Insn, 0, 4);
3637 unsigned inc = fieldFromInstruction(
Insn, 5, 1) + 1;
3656 else if (Rm != 0xF) {
3669 unsigned Rd = fieldFromInstruction(
Insn, 12, 4);
3670 Rd |= fieldFromInstruction(
Insn, 22, 1) << 4;
3671 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
3672 unsigned Rm = fieldFromInstruction(
Insn, 0, 4);
3673 unsigned size = fieldFromInstruction(
Insn, 6, 2);
3674 unsigned inc = fieldFromInstruction(
Insn, 5, 1) + 1;
3675 unsigned align = fieldFromInstruction(
Insn, 4, 1);
3709 else if (Rm != 0xF) {
3722 unsigned Rd = fieldFromInstruction(
Insn, 12, 4);
3723 Rd |= fieldFromInstruction(
Insn, 22, 1) << 4;
3724 unsigned imm = fieldFromInstruction(
Insn, 0, 4);
3725 imm |= fieldFromInstruction(
Insn, 16, 3) << 4;
3726 imm |= fieldFromInstruction(
Insn, 24, 1) << 7;
3727 imm |= fieldFromInstruction(
Insn, 8, 4) << 8;
3728 imm |= fieldFromInstruction(
Insn, 5, 1) << 12;
3729 unsigned Q = fieldFromInstruction(
Insn, 6, 1);
3742 case ARM::VORRiv4i16:
3743 case ARM::VORRiv2i32:
3744 case ARM::VBICiv4i16:
3745 case ARM::VBICiv2i32:
3749 case ARM::VORRiv8i16:
3750 case ARM::VORRiv4i32:
3751 case ARM::VBICiv8i16:
3752 case ARM::VBICiv4i32:
3768 unsigned Qd = ((fieldFromInstruction(
Insn, 22, 1) << 3) |
3769 fieldFromInstruction(
Insn, 13, 3));
3770 unsigned cmode = fieldFromInstruction(
Insn, 8, 4);
3771 unsigned imm = fieldFromInstruction(
Insn, 0, 4);
3772 imm |= fieldFromInstruction(
Insn, 16, 3) << 4;
3773 imm |= fieldFromInstruction(
Insn, 28, 1) << 7;
3775 imm |= fieldFromInstruction(
Insn, 5, 1) << 12;
3777 if (cmode == 0xF && Inst.
getOpcode() == ARM::MVE_VMVNimmi32)
3797 unsigned Qd = fieldFromInstruction(
Insn, 13, 3);
3798 Qd |= fieldFromInstruction(
Insn, 22, 1) << 3;
3803 unsigned Qn = fieldFromInstruction(
Insn, 17, 3);
3804 Qn |= fieldFromInstruction(
Insn, 7, 1) << 3;
3807 unsigned Qm = fieldFromInstruction(
Insn, 1, 3);
3808 Qm |= fieldFromInstruction(
Insn, 5, 1) << 3;
3811 if (!fieldFromInstruction(
Insn, 12, 1))
3823 unsigned Rd = fieldFromInstruction(
Insn, 12, 4);
3824 Rd |= fieldFromInstruction(
Insn, 22, 1) << 4;
3825 unsigned Rm = fieldFromInstruction(
Insn, 0, 4);
3826 Rm |= fieldFromInstruction(
Insn, 5, 1) << 4;
3827 unsigned size = fieldFromInstruction(
Insn, 18, 2);
3871 unsigned Rd = fieldFromInstruction(
Insn, 12, 4);
3872 Rd |= fieldFromInstruction(
Insn, 22, 1) << 4;
3873 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
3874 Rn |= fieldFromInstruction(
Insn, 7, 1) << 4;
3875 unsigned Rm = fieldFromInstruction(
Insn, 0, 4);
3876 Rm |= fieldFromInstruction(
Insn, 5, 1) << 4;
3877 unsigned op = fieldFromInstruction(
Insn, 6, 1);
3908 unsigned dst = fieldFromInstruction(
Insn, 8, 3);
3909 unsigned imm = fieldFromInstruction(
Insn, 0, 8);
3932 true, 2, Inst, Decoder))
3941 true, 4, Inst, Decoder))
3950 true, 2, Inst, Decoder))
3960 unsigned Rn = fieldFromInstruction(Val, 0, 3);
3961 unsigned Rm = fieldFromInstruction(Val, 3, 3);
3976 unsigned Rn = fieldFromInstruction(Val, 0, 3);
3977 unsigned imm = fieldFromInstruction(Val, 3, 5);
3989 unsigned imm = Val << 2;
4011 unsigned Rn = fieldFromInstruction(Val, 6, 4);
4012 unsigned Rm = fieldFromInstruction(Val, 2, 4);
4013 unsigned imm = fieldFromInstruction(Val, 0, 2);
4041 unsigned Rt = fieldFromInstruction(
Insn, 12, 4);
4042 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
4045 ((
const MCDisassembler*)Decoder)->getSubtargetInfo().getFeatureBits();
4047 bool hasMP = featureBits[ARM::FeatureMP];
4048 bool hasV7Ops = featureBits[ARM::HasV7Ops];
4103 if (!hasV7Ops || !hasMP)
4111 unsigned addrmode = fieldFromInstruction(
Insn, 4, 2);
4112 addrmode |= fieldFromInstruction(
Insn, 0, 4) << 2;
4113 addrmode |= fieldFromInstruction(
Insn, 16, 4) << 6;
4125 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
4126 unsigned Rt = fieldFromInstruction(
Insn, 12, 4);
4127 unsigned U = fieldFromInstruction(
Insn, 9, 1);
4128 unsigned imm = fieldFromInstruction(
Insn, 0, 8);
4131 unsigned add = fieldFromInstruction(
Insn, 9, 1);
4134 ((
const MCDisassembler*)Decoder)->getSubtargetInfo().getFeatureBits();
4136 bool hasMP = featureBits[ARM::FeatureMP];
4137 bool hasV7Ops = featureBits[ARM::HasV7Ops];
4147 case ARM::t2LDRSBi8:
4153 case ARM::t2LDRSHi8:
4170 case ARM::t2LDRSHi8:
4176 case ARM::t2LDRSBi8:
4192 if (!hasV7Ops || !hasMP)
4210 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
4211 unsigned Rt = fieldFromInstruction(
Insn, 12, 4);
4212 unsigned imm = fieldFromInstruction(
Insn, 0, 12);
4216 ((
const MCDisassembler*)Decoder)->getSubtargetInfo().getFeatureBits();
4218 bool hasMP = featureBits[ARM::FeatureMP];
4219 bool hasV7Ops = featureBits[ARM::HasV7Ops];
4226 case ARM::t2LDRHi12:
4229 case ARM::t2LDRSHi12:
4232 case ARM::t2LDRBi12:
4235 case ARM::t2LDRSBi12:
4252 case ARM::t2LDRSHi12:
4254 case ARM::t2LDRHi12:
4257 case ARM::t2LDRSBi12:
4272 case ARM::t2PLDWi12:
4273 if (!hasV7Ops || !hasMP)
4290 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
4291 unsigned Rt = fieldFromInstruction(
Insn, 12, 4);
4292 unsigned imm = fieldFromInstruction(
Insn, 0, 8);
4330 unsigned Rt = fieldFromInstruction(
Insn, 12, 4);
4331 unsigned U = fieldFromInstruction(
Insn, 23, 1);
4332 int imm = fieldFromInstruction(
Insn, 0, 12);
4335 ((
const MCDisassembler*)Decoder)->getSubtargetInfo().getFeatureBits();
4337 bool hasV7Ops = featureBits[ARM::HasV7Ops];
4341 case ARM::t2LDRBpci:
4342 case ARM::t2LDRHpci:
4345 case ARM::t2LDRSBpci:
4348 case ARM::t2LDRSHpci:
4384 int imm = Val & 0xFF;
4386 if (!(Val & 0x100)) imm *= -1;
4398 int imm = Val & 0x7F;
4413 unsigned Rn = fieldFromInstruction(Val, 9, 4);
4414 unsigned imm = fieldFromInstruction(Val, 0, 9);
4429 unsigned Rn = fieldFromInstruction(Val, 8, 4);
4430 unsigned imm = fieldFromInstruction(Val, 0, 8);
4445 unsigned Rn = fieldFromInstruction(Val, 8, 4);
4446 unsigned imm = fieldFromInstruction(Val, 0, 8);
4458 int imm = Val & 0xFF;
4461 else if (!(Val & 0x100))
4468 template <
int shift>
4471 int imm = Val & 0x7F;
4474 else if (!(Val & 0x80))
4476 if (imm != INT32_MIN)
4477 imm *= (1U <<
shift);
4488 unsigned Rn = fieldFromInstruction(Val, 9, 4);
4489 unsigned imm = fieldFromInstruction(Val, 0, 9);
4530 template <
int shift>
4536 unsigned Rn = fieldFromInstruction(Val, 8, 3);
4537 unsigned imm = fieldFromInstruction(Val, 0, 8);
4541 if (!
Check(
S, DecodeT2Imm7<shift>(Inst, imm, Address, Decoder)))
4547 template <
int shift,
int WriteBack>
4553 unsigned Rn = fieldFromInstruction(Val, 8, 4);
4554 unsigned imm = fieldFromInstruction(Val, 0, 8);
4560 if (!
Check(
S, DecodeT2Imm7<shift>(Inst, imm, Address, Decoder)))
4571 unsigned Rt = fieldFromInstruction(
Insn, 12, 4);
4572 unsigned Rn = fieldFromInstruction(
Insn, 16, 4);
4573 unsigned addr = fieldFromInstruction(
Insn, 0, 8);
4574 addr |= fieldFromInstruction(
Insn, 9, 1) << 8;
4576 unsigned load = fieldFromInstruction(
Insn, 20, 1);
4580 case ARM::t2LDR_PRE:
4581 case ARM::t2LDR_POST:
4584 case ARM::t2LDRB_PRE:
4585 case ARM::t2LDRB_POST:
4588 case ARM::t2LDRH_PRE:
4589 case ARM::t2LDRH_POST:
4592 case ARM::t2LDRSB_PRE:
4593 case ARM::t2LDRSB_POST:
4599 case ARM::t2LDRSH_PRE:
4600 case ARM::t2LDRSH_POST:
4633 unsigned Rn = fieldFromInstruction(Val, 13, 4);
4634 unsigned imm = fieldFromInstruction(Val, 0, 12);
4639 case ARM::t2STRBi12:
4640 case ARM::t2STRHi12:
4658 unsigned imm = fieldFromInstruction(
Insn, 0, 7);
4673 unsigned Rdm = fieldFromInstruction(
Insn, 0, 3);
4674 Rdm |= fieldFromInstruction(
Insn, 7, 1) << 3;
4681 }
else if (Inst.
getOpcode() == ARM::tADDspr) {
4682 unsigned Rm = fieldFromInstruction(
Insn, 3, 4);
4696 unsigned imod = fieldFromInstruction(
Insn, 4, 1) | 0x2;
4697 unsigned flags = fieldFromInstruction(
Insn, 0, 3);
4709 unsigned Rm = fieldFromInstruction(
Insn, 0, 4);
4710 unsigned add = fieldFromInstruction(
Insn, 4, 1);
4723 unsigned Rn = fieldFromInstruction(
Insn, 3, 4);
4724 unsigned Qm = fieldFromInstruction(
Insn, 0, 3);
4734 template <
int shift>
4739 unsigned Qm = fieldFromInstruction(
Insn, 8, 3);
4740 int imm = fieldFromInstruction(
Insn, 0, 7);