diff options
| -rw-r--r-- | src/armv7.rs | 272 | ||||
| -rw-r--r-- | src/armv7/thumb.rs | 3103 | ||||
| -rw-r--r-- | test/armv7.rs | 10 | ||||
| -rw-r--r-- | test/armv7/thumb.rs | 3396 |
4 files changed, 6777 insertions, 4 deletions
diff --git a/src/armv7.rs b/src/armv7.rs index 007ded9..ac84ad9 100644 --- a/src/armv7.rs +++ b/src/armv7.rs @@ -9,6 +9,8 @@ use std::fmt::{self, Display, Formatter}; use yaxpeax_arch::{Arch, AddressDiff, Colorize, Decoder, LengthedInstruction, NoColors, ShowContextual, YaxColors}; +mod thumb; + pub struct ConditionedOpcode(pub Opcode, pub bool, pub ConditionCode); impl Display for ConditionedOpcode { @@ -45,6 +47,71 @@ fn reg_name_colorize<C: fmt::Display, Y: YaxColors<C>>(reg: Reg, colors: &Y) -> impl <T: fmt::Write, Color: fmt::Display, Y: YaxColors<Color>> ShowContextual<u32, NoContext, Color, T, Y> for Instruction { fn contextualize(&self, colors: &Y, _address: u32, _context: Option<&NoContext>, out: &mut T) -> fmt::Result { match self.opcode { + Opcode::IT => { + if let (Operand::Imm32(cond), Operand::Imm32(mask)) = (&self.operands[0], &self.operands[1]) { + let inv = cond & 1 == 1; + let condition = ConditionCode::build(*cond as u8); + if mask & 0b0001 != 0 { + // three flags + write!( + out, + "it{}{}{} {}", + if inv ^ ((mask & 0b1000) != 0) { "e" } else { "t" }, + if inv ^ ((mask & 0b0100) != 0) { "e" } else { "t" }, + if inv ^ ((mask & 0b0010) != 0) { "e" } else { "t" }, + condition, + )?; + } else if mask & 0b0010 != 0 { + // two flags + write!( + out, + "it{}{} {}", + if inv ^ ((mask & 0b1000) != 0) { "e" } else { "t" }, + if inv ^ ((mask & 0b0100) != 0) { "e" } else { "t" }, + condition, + )?; + } else if mask & 0b0100 != 0 { + // one flag + write!( + out, + "it{} {}", + if inv ^ ((mask & 0b1000) != 0) { "e" } else { "t" }, + condition, + )?; + } else { + // no flags + write!(out, "it {}", condition)?; + } + // if the condition is AL, it won't get displayed. append it here. + if *cond == 14 { + write!(out, "al")?; + } + return Ok(()); + } else { + panic!("impossible it operand"); + } + } + Opcode::CPS(_) => { + if let Operand::Imm12(aif) = &self.operands[0] { + return write!( + out, + "{} {}{}{}", + &self.opcode, + if aif & 0b100 != 0 { "a" } else { "" }, + if aif & 0b010 != 0 { "i" } else { "" }, + if aif & 0b001 != 0 { "f" } else { "" }, + ); + } else { + panic!("impossible cps operand"); + } + } + Opcode::SETEND => { + if let Operand::Imm12(i) = &self.operands[0] { + return write!(out, "setend {}", if *i == 0 { "le" } else { "be" }); + } else { + panic!("impossible setend operand"); + } + } Opcode::LDR => { match self.operands { // TODO: should this be PostindexOffset? @@ -264,7 +331,13 @@ impl <T: fmt::Write, Color: fmt::Display, Y: YaxColors<Color>> Colorize<T, Color fn colorize(&self, colors: &Y, out: &mut T) -> fmt::Result { match self.0 { Opcode::Incomplete(_) | + Opcode::UDF | Opcode::Invalid => { write!(out, "{}", colors.invalid_op(self)) }, + Opcode::TBB | + Opcode::TBH | + Opcode::CBZ | + Opcode::CBNZ | + Opcode::IT | Opcode::B | Opcode::BL | Opcode::BLX | @@ -274,6 +347,7 @@ impl <T: fmt::Write, Color: fmt::Display, Y: YaxColors<Color>> Colorize<T, Color Opcode::AND | Opcode::EOR | Opcode::ORR | + Opcode::ORN | Opcode::LSL | Opcode::LSR | Opcode::ROR | @@ -356,16 +430,58 @@ impl <T: fmt::Write, Color: fmt::Display, Y: YaxColors<Color>> Colorize<T, Color Opcode::SWPB | Opcode::MSR | Opcode::MRS | + Opcode::CLREX | + Opcode::SXTAB | + Opcode::SXTAB16 | + Opcode::SXTAH | + Opcode::SXTB | + Opcode::SXTB16 | + Opcode::SXTH | + Opcode::UXTAB | + Opcode::UXTAB16 | + Opcode::UXTAH | + Opcode::UXTB | + Opcode::UXTB16 | + Opcode::UXTH | + Opcode::PKHTB | + Opcode::PKHBT | + Opcode::REV | + Opcode::REV16 | + Opcode::REVSH | + Opcode::SSAT | + Opcode::SSAT16 | + Opcode::SBFX | + Opcode::USAT | + Opcode::USAT16 | + Opcode::UBFX | + Opcode::BFI | + Opcode::BFC | Opcode::MOV | Opcode::MOVT | Opcode::MVN => { write!(out, "{}", colors.data_op(self)) }, + Opcode::HINT | + Opcode::NOP | + Opcode::ISB | + Opcode::DMB | + Opcode::DSB | + Opcode::CSDB | Opcode::SRS(_, _) | Opcode::BKPT => { write!(out, "{}", colors.misc_op(self)) }, + Opcode::DBG | + Opcode::CPS(_) | + Opcode::SETEND | + Opcode::ENTERX | + Opcode::LEAVEX | + Opcode::YIELD | + Opcode::WFE | + Opcode::WFI | + Opcode::SEV | Opcode::ERET | Opcode::RFE(_, _) | Opcode::HVC | + Opcode::SVC | Opcode::SMC | Opcode::LDC2(_) | Opcode::LDC2L(_) | @@ -453,10 +569,12 @@ impl Display for Opcode { Opcode::STREX => { write!(f, "strex") }, Opcode::LDM(false, false, _, _) => { write!(f, "ldmda") }, Opcode::LDM(false, true, _, _) => { write!(f, "ldmdb") }, + // TODO: seems like these are backwards Opcode::LDM(true, false, _, _) => { write!(f, "ldm") }, Opcode::LDM(true, true, _, _) => { write!(f, "ldmia") }, Opcode::STM(false, false, _, _) => { write!(f, "stmda") }, Opcode::STM(false, true, _, _) => { write!(f, "stmdb") }, + // TODO: seems like these are backwards Opcode::STM(true, false, _, _) => { write!(f, "stm") }, Opcode::STM(true, true, _, _) => { write!(f, "stmia") }, Opcode::LDR => { write!(f, "ldr") }, @@ -496,6 +614,55 @@ impl Display for Opcode { Opcode::SMLAW(second) => { write!(f, "smlaw{}", if *second { "t" } else { "b" }) }, + Opcode::TBB => { write!(f, "tbb") }, + Opcode::TBH => { write!(f, "tbh") }, + Opcode::UDF => { write!(f, "udf") }, + Opcode::SVC => { write!(f, "svc") }, + Opcode::WFE => { write!(f, "wfe") }, + Opcode::WFI => { write!(f, "wfi") }, + Opcode::SEV => { write!(f, "sev") }, + Opcode::CSDB => { write!(f, "csdb") }, + Opcode::YIELD => { write!(f, "yield") }, + Opcode::HINT => { write!(f, "hint") }, + Opcode::NOP => { write!(f, "nop") }, + Opcode::LEAVEX => { write!(f, "leavex") }, + Opcode::ENTERX => { write!(f, "enterx") }, + Opcode::CLREX => { write!(f, "clrex") }, + Opcode::DSB => { write!(f, "dsb") }, + Opcode::DMB => { write!(f, "dmb") }, + Opcode::ISB => { write!(f, "isb") }, + Opcode::SXTH => { write!(f, "sxth") }, + Opcode::UXTH => { write!(f, "uxth") }, + Opcode::SXTB16 => { write!(f, "sxtb16") }, + Opcode::UXTB16 => { write!(f, "uxtb16") }, + Opcode::SXTB => { write!(f, "sxtb") }, + Opcode::UXTB => { write!(f, "uxtb") }, + Opcode::SXTAH => { write!(f, "sxtah") }, + Opcode::UXTAH => { write!(f, "uxtah") }, + Opcode::SXTAB16 => { write!(f, "sxtab16") }, + Opcode::UXTAB16 => { write!(f, "uxtab16") }, + Opcode::SXTAB => { write!(f, "sxtab") }, + Opcode::UXTAB => { write!(f, "uxtab") }, + Opcode::CBZ => { write!(f, "cbz") }, + Opcode::CBNZ => { write!(f, "cbnz") }, + Opcode::SETEND => { write!(f, "setend") }, + Opcode::CPS(disable) => { write!(f, "cps{}", if *disable { "id" } else { "ie" }) }, + Opcode::REV => { write!(f, "rev") }, + Opcode::REV16 => { write!(f, "rev16") }, + Opcode::REVSH => { write!(f, "revsh") }, + Opcode::IT => { write!(f, "it") }, + Opcode::PKHTB => { write!(f, "pkhtb") }, + Opcode::PKHBT => { write!(f, "pkhbt") }, + Opcode::ORN => { write!(f, "orn") }, + Opcode::SSAT => { write!(f, "ssat") }, + Opcode::SSAT16 => { write!(f, "ssat16") }, + Opcode::SBFX => { write!(f, "sbfx") }, + Opcode::USAT => { write!(f, "usat") }, + Opcode::USAT16 => { write!(f, "usat16") }, + Opcode::UBFX => { write!(f, "ubfx") }, + Opcode::BFI => { write!(f, "bfi") }, + Opcode::BFC => { write!(f, "bfc") }, + Opcode::DBG => { write!(f, "dbg") }, } } } @@ -606,6 +773,57 @@ pub enum Opcode { QDADD, QSUB, QADD, + + TBB, + TBH, + UDF, + SVC, + WFE, + WFI, + SEV, + CSDB, + YIELD, + HINT, + NOP, + LEAVEX, + ENTERX, + CLREX, + DSB, + DMB, + ISB, + SXTH, + UXTH, + SXTB16, + UXTB16, + SXTB, + UXTB, + SXTAH, + UXTAH, + SXTAB16, + UXTAB16, + SXTAB, + UXTAB, + CBZ, + CBNZ, + SETEND, + CPS(bool), + REV, + REV16, + REVSH, + IT, + + PKHTB, + PKHBT, + ORN, + SSAT, + SSAT16, + SBFX, + USAT, + USAT16, + UBFX, + BFI, + BFC, + DBG, } static DATA_PROCESSING_OPCODES: [Opcode; 16] = [ @@ -635,6 +853,7 @@ pub struct RegShift { impl RegShift { fn into_shift(&self) -> RegShiftStyle { + // TODO: is this mask really off by one. should it be 0b10000?? if self.data & 0b1000 == 0 { RegShiftStyle::RegImm(RegImmShift { data: self.data }) } else { @@ -1416,6 +1635,7 @@ pub struct InstDecoder { mode: DecodeMode, version: ARMVersion, should_is_must: bool, + thumb: bool, } impl Default for InstDecoder { @@ -1424,16 +1644,31 @@ impl Default for InstDecoder { mode: DecodeMode::Any, version: ARMVersion::Any, should_is_must: true, + thumb: false, } } } impl InstDecoder { + pub fn set_thumb_mode(&mut self, thumb: bool) { + self.thumb = thumb; + } + + pub fn with_thumb_mode(mut self, thumb: bool) -> Self { + self.set_thumb_mode(thumb); + self + } + + pub fn default_thumb() -> Self { + Self::default().with_thumb_mode(true) + } + pub fn armv4() -> Self { Self { mode: DecodeMode::Any, version: ARMVersion::v4, should_is_must: true, + thumb: false, } } @@ -1442,6 +1677,7 @@ impl InstDecoder { mode: DecodeMode::Any, version: ARMVersion::v5, should_is_must: true, + thumb: false, } } @@ -1450,6 +1686,7 @@ impl InstDecoder { mode: DecodeMode::Any, version: ARMVersion::v6, should_is_must: true, + thumb: false, } } @@ -1458,6 +1695,16 @@ impl InstDecoder { mode: DecodeMode::Any, version: ARMVersion::v6t2, should_is_must: true, + thumb: false, + } + } + + pub fn armv6t2_thumb() -> Self { + Self { + mode: DecodeMode::Any, + version: ARMVersion::v6t2, + should_is_must: true, + thumb: true, } } @@ -1466,6 +1713,16 @@ impl InstDecoder { mode: DecodeMode::Any, version: ARMVersion::v7, should_is_must: true, + thumb: false, + } + } + + pub fn armv7_thumb() -> Self { + Self { + mode: DecodeMode::Any, + version: ARMVersion::v7, + should_is_must: true, + thumb: true, } } @@ -1474,6 +1731,16 @@ impl InstDecoder { mode: DecodeMode::Any, version: ARMVersion::v7ve, should_is_must: true, + thumb: false, + } + } + + pub fn armv7ve_thumb() -> Self { + Self { + mode: DecodeMode::Any, + version: ARMVersion::v7ve, + should_is_must: true, + thumb: true, } } @@ -1482,6 +1749,7 @@ impl InstDecoder { mode: DecodeMode::Any, version: ARMVersion::v7vese, should_is_must: true, + thumb: false, } } } @@ -1491,6 +1759,10 @@ impl Decoder<Instruction> for InstDecoder { type Error = DecodeError; fn decode_into<T: IntoIterator<Item=u8>>(&self, inst: &mut Instruction, bytes: T) -> Result<(), Self::Error> { + if self.thumb { + return thumb::decode_into(&self, inst, bytes); + } + fn read_word<T: IntoIterator<Item=u8>>(bytes: T) -> Result<u32, DecodeError> { let mut iter = bytes.into_iter(); let instr: u32 = diff --git a/src/armv7/thumb.rs b/src/armv7/thumb.rs new file mode 100644 index 0000000..d786305 --- /dev/null +++ b/src/armv7/thumb.rs @@ -0,0 +1,3103 @@ +use std::fmt; + +// use yaxpeax_arch::{Arch, AddressDiff, Decoder, LengthedInstruction}; + +use armv7::ConditionCode; +use armv7::DecodeError; +use armv7::Reg; +use armv7::RegShift; +use armv7::Operand; +use armv7::Opcode; +use armv7::Instruction; +use armv7::InstDecoder; +use armv7::StatusRegMask; + +#[allow(non_snake_case)] +fn ROR_C(x: u32, shift: u16) -> (u32, bool) { +// let m = shift % 32; // `shift` is known to be 31 or lower + let m = shift; + let result = (x >> m) | (x << (32 - m)); + let carry_out = (result >> 31) & 1 != 0; + (result, carry_out) +} + +#[allow(non_snake_case)] +fn ThumbExpandImm_C(imm: u16) -> u32 { + if imm & 0b1100_0000_0000 == 0 { + let ty = (imm >> 8) & 0b11; + let imm_low = (imm & 0b11111111) as u32; + match ty { + 0b00 => { + imm_low + } + 0b01 => { + if imm_low == 0 { + panic!("unpredictable"); + } + (imm_low << 16) | imm_low + } + 0b10 => { + if imm_low == 0 { + panic!("unpredictable"); + } + (imm_low << 24) | (imm_low << 8) + } + 0b11 => { + if imm_low == 0 { + panic!("unpredictable"); + } + (imm_low << 24) | (imm_low << 16) | (imm_low << 8) | imm_low + } + _ => { + unreachable!("impossible bit pattern"); + } + } + } else { + let unrotated_value = ((1 << 7) | (imm & 0b1111111)) as u32; + let rot = (imm >> 7) & 0b11111; + // TODO: figure out what to do with carry_out + let (imm32, _carry_out) = ROR_C(unrotated_value, rot); + imm32 + } +} + +#[allow(non_snake_case)] +fn DecodeImmShift(reg: u8, ty: u8, imm5: u8) -> RegShift { + let imm = match ty { + 0b00 => { imm5 }, + 0b01 => { + if imm5 == 0 { + 32 + } else { + imm5 + } + }, + 0b10 => { + if imm5 == 0 { + 32 + } else { + imm5 + } + }, + 0b11 => { + // ignores the `if ty == 11 && imm5 = 00000 then shift_t = RRX && shift_n = 1` + imm5 + } + _ => { + unreachable!("impossible bit pattern"); + } + }; + RegShift::from_raw( + 0b1000 | // `RegImm` + reg as u16 | + ((ty as u16) << 5)| + ((imm as u16) << 7) + ) +} + +#[allow(non_snake_case)] +pub fn decode_into<T: IntoIterator<Item=u8>>(_decoder: &InstDecoder, inst: &mut Instruction, bytes: T) -> Result<(), DecodeError> { + let mut iter = bytes.into_iter(); + let instr: u16 = + ((iter.next().ok_or(DecodeError::ExhaustedInput)? as u16) ) | + ((iter.next().ok_or(DecodeError::ExhaustedInput)? as u16) << 8 ); + + let opword = instr >> 11; + + // `A6.1 Thumb instruction set encoding` + if opword >= 0b11101 { + let lower: u16 = + ((iter.next().ok_or(DecodeError::ExhaustedInput)? as u16) ) | + ((iter.next().ok_or(DecodeError::ExhaustedInput)? as u16) << 8 ); + + let op2 = (instr >> 5) & 0b1111111; + + // 32b instruction - `A6-228, 32-bit Thumb instruction encoding` + // opword low bits 01, 10, and 11 correspond to `op1` in table `A6-9` + if opword < 0b11110 { + // op1 == 0b01 + if op2 < 0b1000000 { + // `op2` is `0b00.. ` or `0b01..` + if op2 < 0b0100000 { + // `Load/store`, either `multiple` or `dual` + let rn = (instr & 0b1111) as u8; + // TODO: double check + if op2 & 0b0000100 != 0 { + // `Load/store dual, load/store exclusive, table branch` (`A6-236`) + let op1op2 = ((instr >> 7) & 0b11) | ((instr >> 4) & 0b11); + let rn = (instr & 0b1111) as u8; + let imm8 = lower & 0b11111111; + let rd = ((lower >> 8) & 0b1111) as u8; + let rt = ((lower >> 12) & 0b1111) as u8; + + match op1op2 { + 0b0000 => { + // `STREX` (`A8-691`) + // v6T2 + if rd == 13 || rd == 15 || rt == 13 || rt == 15 || rn == 15 { + todo!("UNPREDICTABLE"); + } + if rd == rn || rd == rt { + todo!("UNPREDICTABLE"); + } + inst.opcode = Opcode::STREX; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rt)), + // preindex for `[<Rn>, #<imm>]`, no writeback. imm is zero + // extended, so not signed; always add. + Operand::RegDerefPreindexOffset( + Reg::from_u8(rn), + imm8 << 2, + true, + false, + ), + Operand::Nothing, + ]; + } + 0b0001 => { + // `LDREX` (`A8-433`) + // v6T2 + if rt == 13 || rt == 15 || rn == 15 { + todo!("UNPREDICTABLE"); + } + // TODO: should_is_must() + // rd == 0b1111 + inst.opcode = Opcode::LDREX; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + // preindex for `[<Rn>, #<imm>]`, no writeback. imm is zero + // extended, so not signed; always add. + Operand::RegDerefPreindexOffset( + Reg::from_u8(rn), + imm8 << 2, + true, + false, + ), + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b0010 | + 0b0110 => { + // `STRD (immediate)` (`A8-687`) + // v6T2 + // bit 5 (w) == 0 + let w = false; + let u = (instr >> 7) & 1 != 0; + let p = (instr >> 8) & 1 != 0; + // `if P == '0' && W == '0' then SEE "Related encodings"` -> this + // would imply tbb/tbh, should be unreachable + if rn == 15 || rt == 13 || rt == 15 || rd == 13 || rd == 15 { + todo!("UNPREDICTABLE"); + } + inst.opcode = Opcode::STRD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::Reg(Reg::from_u8(rd)), + if p { + Operand::RegDerefPreindexOffset(Reg::from_u8(rn), imm8 << 2, u, w) + } else { + // p == 0 and w == 0 is impossible, would be tbb/tbh + Operand::RegDerefPostindexOffset(Reg::from_u8(rn), imm8 << 2, u, false) + }, + Operand::Nothing, + ]; + } + 0b0011 | + 0b0111 => { + // `LDRD (immediate)`/`(literal)` (`A8-687`) + // bit 5 (w) == 0 + let w = false; + let u = (instr >> 7) & 1 != 0; + let p = (instr >> 8) & 1 != 0; + // `if P == '0' && W == '0' then SEE "Related encodings"` -> this + // would imply tbb/tbh, should be unreachable + if rt == 13 || rt == 15 || rd == 13 || rd == 15 || rd == rt { + todo!("UNPREDICTABLE"); + } + if w && (rn == rt || rn == rd) { + todo!("UNPREDICTABLE"); + } + if rn != 0b1111 { + // `LDRD (immediate)` (`A8-427`) + // v6T2 + inst.opcode = Opcode::LDRD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::Reg(Reg::from_u8(rd)), + if p { + Operand::RegDerefPreindexOffset(Reg::from_u8(rn), imm8 << 2, u, w) + } else { + // p == 0 and w == 0 is impossible, would be tbb/tbh + Operand::RegDerefPostindexOffset(Reg::from_u8(rn), imm8 << 2, u, false) + }, + Operand::Nothing, + ]; + } else { + // `LDRD (literal)` (`A8-429`) + // v6T2 + if w { + todo!("UNPREDICTABLE"); + } + // which because !(p == 0 && w == 0), we know p is true + inst.opcode = Opcode::LDRD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::Reg(Reg::from_u8(rd)), + Operand::RegDerefPreindexOffset(Reg::from_u8(rn), imm8 << 2, u, false), + Operand::Nothing, + ]; + } + } + 0b0100 => { + // `STREX_` + // v7 + let op3 = (lower >> 4) & 0b1111; + let rt2 = rd; + let rd = (imm8 & 0b1111) as u8; + match op3 { + 0b0100 => { + // `STREXB` (`A8-693`) + if rd == 13 || rd == 15 || rt == 13 || rt == 15 || rn == 15 { + todo!("UNPREDICTABLE"); + } + if rd == rn || rd == rt { + todo!("UNPREDICTABLE"); + } + // TODO: should_is_must() + // rt2 == 0b1111 + inst.opcode = Opcode::STREXB; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rt)), + Operand::RegDeref(Reg::from_u8(rn)), + Operand::Nothing, + ]; + } + 0b0101 => { + // `STREXH` (`A8-693`) + if rd == 13 || rd == 15 || rt == 13 || rt == 15 || rn == 15 { + todo!("UNPREDICTABLE"); + } + if rd == rn || rd == rt { + todo!("UNPREDICTABLE"); + } + // TODO: should_is_must() + // rt2 == 0b1111 + inst.opcode = Opcode::STREXH; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rt)), + Operand::RegDeref(Reg::from_u8(rn)), + Operand::Nothing, + ]; + } + 0b0111 => { + // `STREXD` (`A8-693`) + if rd == 13 || rd == 15 || rt == 13 || rt == 15 || rt2 == 13 || rt2 == 15 || rn == 15 { + todo!("UNPREDICTABLE"); + } + if rd == rn || rd == rt || rd == rt2 { + todo!("UNPREDICTABLE"); + } + inst.opcode = Opcode::STREXD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rt)), + Operand::Reg(Reg::from_u8(rt2)), + Operand::RegDeref(Reg::from_u8(rn)), + ]; + } + _ => { + return Err(DecodeError::Undefined); + } + } + } + 0b0101 => { + // `TBB`/`TBH`/`LDREX_` + let op3 = (lower >> 4) & 0b1111; + let rt2 = rd; + let rd = (imm8 & 0b1111) as u8; + match op3 { + 0b0000 => { + // `TBB` + // TODO: should_is_must() + // rt == 0b1111 + // rd == 0b0000 + inst.opcode = Opcode::TBB; + inst.operands = [ + Operand::RegDerefPreindexReg( + Reg::from_u8(rn), + Reg::from_u8(rd), + true, // add + false, // no wback + ), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b0001 => { + // `TBH` + // TODO: should_is_must() + // rt == 0b1111 + // rd == 0b0000 + inst.opcode = Opcode::TBB; + inst.operands = [ + Operand::RegDerefPreindexRegShift( + Reg::from_u8(rn), + // want `<Rm>, LSL #1`, construct a raw shift + // ourselves + RegShift::from_raw( + 0b1000 | // `RegImm` + rd as u16 | // reg == rd + (0b00 << 5) | // LSL + (1 << 7) // shift == #1 + ), + true, // add + false, // no wback + ), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b0100 => { + // `LDREXB` + if rt == 13 || rt == 15 || rn == 15 { + todo!("UNPREDICTABLE"); + } + // TODO: should_is_must() + // rt2 == 0b1111 + // rd == 0b1111 + inst.opcode = Opcode::LDREXB; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::RegDeref(Reg::from_u8(rn)), + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b0101 => { + // `LDREXH` + if rt == 13 || rt == 15 || rn == 15 { + todo!("UNPREDICTABLE"); + } + // TODO: should_is_must() + // rt2 == 0b1111 + // rd == 0b1111 + inst.opcode = Opcode::LDREXH; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::RegDeref(Reg::from_u8(rn)), + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b0110 => { + // `LDREXD` + if rt == 13 || rt == 15 || rt2 == 13 || rt2 == 15 || rn == 15 { + todo!("UNPREDICTABLE"); + } + // TODO: should_is_must() + // rd == 0b1111 + inst.opcode = Opcode::LDREXD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::Reg(Reg::from_u8(rt2)), + Operand::RegDeref(Reg::from_u8(rn)), + Operand::Nothing, + ]; + } + _ => { + return Err(DecodeError::Undefined); + } + } + } + 0b1000 | + 0b1010 | + 0b1100 | + 0b1110 => { + // `STRD (immediate)` (`A8-687`) + // v6T2 + // bit 5 (w) == 1 + let w = true; + let u = (instr >> 7) & 1 != 0; + let p = (instr >> 8) & 1 != 0; + // `if P == '0' && W == '0' then SEE "Related encodings"` -> this + // would imply tbb/tbh, should be unreachable + if rn == 15 || rt == 13 || rt == 15 || rd == 13 || rd == 15 { + todo!("UNPREDICTABLE"); + } + inst.opcode = Opcode::STRD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::Reg(Reg::from_u8(rd)), + if p { + Operand::RegDerefPreindexOffset(Reg::from_u8(rn), imm8 << 2, u, w) + } else { + // p == 0 and w == 0 is impossible, would be tbb/tbh + Operand::RegDerefPostindexOffset(Reg::from_u8(rn), imm8 << 2, u, false) + }, + Operand::Nothing, + ]; + } + 0b1001 | + 0b1011 | + 0b1101 | + 0b1111 => { + // `LDRD (immediate)` (`A8-687`) + // v6T2 + // bit 5 (w) == 1 + let w = true; + let u = (instr >> 7) & 1 != 0; + let p = (instr >> 8) & 1 != 0; + // `if P == '0' && W == '0' then SEE "Related encodings"` -> this + // would imply tbb/tbh, should be unreachable + if rt == 13 || rt == 15 || rd == 13 || rd == 15 || rd == rt { + todo!("UNPREDICTABLE"); + } + if w && (rn == rt || rn == rd) { + todo!("UNPREDICTABLE"); + } + if rn != 0b1111 { + // `LDRD (immediate)` (`A8-427`) + // v6T2 + inst.opcode = Opcode::LDRD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::Reg(Reg::from_u8(rd)), + if p { + Operand::RegDerefPreindexOffset(Reg::from_u8(rn), imm8 << 2, u, w) + } else { + // p == 0 and w == 0 is impossible, would be tbb/tbh + Operand::RegDerefPostindexOffset(Reg::from_u8(rn), imm8 << 2, u, false) + }, + Operand::Nothing, + ]; + } else { + // `LDRD (literal)` (`A8-429`) + // v6T2 + if w { + todo!("UNPREDICTABLE"); + } + // which because !(p == 0 && w == 0), we know p is true + inst.opcode = Opcode::LDRD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::Reg(Reg::from_u8(rd)), + Operand::RegDerefPreindexOffset(Reg::from_u8(rn), imm8 << 2, u, false), + Operand::Nothing, + ]; + } + } + _ => { + unreachable!("impossible bit pattern"); + } + } + } else { + let w = instr & 0b100000 != 0; + // `Load/store multiple` (`A6-235`) + if instr & 0b10000 == 0 { + // `L == 0` + match (instr >> 7) & 0b11 { + 0b00 => { + // `SRS (Thumb)` (`B9-1990`) + // v6T2 + inst.opcode = Opcode::SRS(false, true); // `srsdb` + inst.operands = [ + Operand::RegWBack(Reg::from_u8(13), w), + Operand::Imm12(lower & 0b1111), // #<mode> ? what's the syntax here? #<the literal>? + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b01 => { + // `STM (STMIA, STMEA)` (`A8-665`) + // v6T2 + if rn == 15 || lower.count_ones() < 2 { + todo!("UNPREDICTABLE"); + } + if w && (lower & (1 << rn)) != 0 { + todo!("UNPREDICTABLE"); + } + inst.opcode = Opcode::STM( + true, // add + true, // preincrement + w, // wback + true, // usermode + ); + inst.operands = [ + Operand::RegWBack(Reg::from_u8(rn), w), + Operand::RegList(lower), + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b10 => { + // `STMDB`/`STMFD` (`A8-669`) + // or `PUSH` (`A8-539`) + if w && rn == 0b1101 { + // `PUSH` + // v6T2 + if lower.count_ones() < 2 { + todo!("UNPREDICTABLE"); + } + inst.opcode = Opcode::PUSH; + inst.operands = [ + Operand::RegList(lower), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `STMDB` + // v6T2 + if rn == 15 || lower.count_ones() < 2 { + todo!("UNPREDICTABLE"); + } + if w && (lower & (1 << rn)) != 0 { + todo!("UNPREDICTABLE"); + } + inst.opcode = Opcode::STM( + false, // decrement + true, // preincrement + w, // wback + true, // usermode? + ); + inst.operands = [ + Operand::RegWBack(Reg::from_u8(rn), w), + Operand::RegList(lower), + Operand::Nothing, + Operand::Nothing, + ]; + } + } + 0b11 => { + // `SRS (Thumb)` (`B9-1990`) + // v6T2 + inst.opcode = Opcode::SRS(false, true); // `srsia` + inst.operands = [ + Operand::RegWBack(Reg::from_u8(13), w), + Operand::Imm12(lower & 0b1111), // #<mode> ? what's the syntax here? #<the literal>? + Operand::Nothing, + Operand::Nothing, + ]; + } + _ => { + unreachable!(); + } + } + } else { + // `L == 1` + match (instr >> 7) & 0b11 { + 0b00 => { + // `RFE` (`B9-1986`) + // v6T2 + if rn == 15 { + todo!("UNPREDICTABLE"); + } + inst.opcode = Opcode::RFE(false, true); + inst.operands = [ + Operand::RegWBack(Reg::from_u8(rn), w), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b01 => { + // `LDM/LDMIA/LDMFD (Thumb)` (`A8-397`) + if w && rn == 0b1101 { + // `POP` (`A8-535`) + if lower.count_ones() < 2 || (lower & 0xc000) == 0xc000 { + todo!("UNPREDICTABLE"); + } + inst.opcode = Opcode::POP; + inst.operands = [ + Operand::RegList(lower), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `LDM/LDMIA/LDMFD` + if rn == 15 || lower.count_ones() < 2 { + todo!("UNPREDICTABLE"); + } + if w && (lower & (1 << rn)) != 0 { + todo!("UNPREDICTABLE"); + } + inst.opcode = Opcode::LDM(true, true, w, true); + inst.operands = [ + Operand::RegWBack(Reg::from_u8(rn), w), + Operand::RegList(lower), + Operand::Nothing, + Operand::Nothing, + ]; + } + } + 0b10 => { + // `LDMDB/LDMEA` (`A8-403`) + if rn == 15 || lower.count_ones() < 2 { + todo!("UNPREDICTABLE"); + } + if w && (lower & (1 << rn)) != 0 { + todo!("UNPREDICTABLE"); + } + inst.opcode = Opcode::LDM(false, true, w, true); + inst.operands = [ + Operand::RegWBack(Reg::from_u8(rn), w), + Operand::RegList(lower), + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b11 => { + // `RFE` (`B9-1986`) + // v6T2 + if rn == 15 { + todo!("UNPREDICTABLE"); + } + inst.opcode = Opcode::RFE(true, false); + inst.operands = [ + Operand::RegWBack(Reg::from_u8(rn), w), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + _ => { + unreachable!(); + } + } + } + } + } else { + // `Data-processing (shfited register)` (`A6-241`) + // v6T2 + let op = op2 & 0b1111; + let s = instr & 0b10000 != 0; + let rn = (instr & 0b1111) as u8; + let rd = ((lower >> 8) & 0b1111) as u8; + + let imm3 = (lower >> 12) & 0b111; + let imm2 = (lower >> 6) & 0b11; + let tp = (lower >> 4) & 0b11; + let rm = (lower & 0b1111) as u8; + + let shift = RegShift::from_raw( + 0b1000 | // reg-imm shift. TODO: probably need to change the const + rm as u16 | + (imm2 << 7) | (imm3 << 9) | + tp << 5 + ); + let shift = Operand::RegShift(shift); + + match op { + 0b0000 => { + if rd == 0b1111 && s { + // `TST` (`A8-747`) + // v6T2 + inst.opcode = Opcode::TST; + inst.operands = [ + Operand::Reg(Reg::from_u8(rn)), + shift, + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `AND` (`A8-324`) + // v6T2 + // TODO: S + inst.opcode = Opcode::AND; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + shift, + Operand::Nothing, + ]; + } + } + 0b0001 => { + // `BIC` (`A8-340`) + // v6T2 + // TODO: S + inst.opcode = Opcode::BIC; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + shift, + Operand::Nothing, + ]; + } + 0b0010 => { + if rn == 0b1111 { + // `Move register and immediate shifts`, also `A6-241` + let tp = (lower >> 4) & 0b11; + let imm2 = (lower >> 6) & 0b11; + let imm3 = (lower >> 12) & 0b111; + match tp { + 0b00 => { + if imm2 | imm3 == 0 { + // `MOV (register, Thumb)` (`A8-487`) + return Err(DecodeError::Incomplete); + } else { + // `LSL (immediate)` (`A8-469`) + return Err(DecodeError::Incomplete); + } + }, + 0b01 => { + // `LSR (immediate)` (`A8-473`) + return Err(DecodeError::Incomplete); + } + 0b10 => { + // `ASR (immediate)` (`A8-328`) + return Err(DecodeError::Incomplete); + } + 0b11 => { + if imm2 | imm3 == 0 { + // `RRX` (`A8-573`) + return Err(DecodeError::Incomplete); + } else { + // `ROR (immediate)` (`A8-569`) + return Err(DecodeError::Incomplete); + } + } + _ => { + unreachable!("impossible bit pattern for `tp`"); + } + } + } else { + // `ORR` (`A8-519`) + // v6T2 + // TODO: S + inst.opcode = Opcode::ORR; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + shift, + Operand::Nothing, + ]; + } + } + 0b0011 => { + if rn == 0b1111 { + // `MVN` (`A8-507`) + // v6T2 + // TODO: S + inst.opcode = Opcode::MVN; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + shift, + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `ORN` (`A8-515`) + // v6T2 + // TODO: S + inst.opcode = Opcode::ORN; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + shift, + Operand::Nothing, + ]; + } + } + 0b0100 => { + if rd == 0b1111 && s { + // `TEQ` (`A8-741`) + // v6T2 + inst.opcode = Opcode::TEQ; + inst.operands = [ + Operand::Reg(Reg::from_u8(rn)), + shift, + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `EOR` (`A8-385`) + // v6T2 + // TODO: S + inst.opcode = Opcode::EOR; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + shift, + Operand::Nothing, + ]; + } + } + 0b0110 => { + // `PKH` (`A8-523`) + // v6T2 + // TODO: fix shift + // TODO: check opcode + // TODO: S + inst.opcode = if lower & 0b10000 != 0 { + Opcode::PKHTB + } else { + Opcode::PKHBT + }; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + shift, + Operand::Nothing, + ]; + } + 0b1000 => { + if rd == 0b1111 && s { + // `CMN` (`A8-364`) + // v6T2 + inst.opcode = Opcode::CMN; + inst.operands = [ + Operand::Reg(Reg::from_u8(rn)), + shift, + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `ADD` (`A8-308`) + // TODO: S + inst.opcode = Opcode::ADD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + shift, + Operand::Nothing, + ]; + } + } + 0b1010 => { + // `ADC` (`A8-300`) + // v6T2 + // TODO: S + inst.opcode = Opcode::ADC; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + shift, + Operand::Nothing, + ]; + } + 0b1011 => { + // `SBC` (`A8-595`) + // v6T2 + // TODO: S + inst.opcode = Opcode::SBC; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + shift, + Operand::Nothing, + ]; + } + 0b1101 => { + if rd == 0b1111 && s { + // `CMP` (`A8-370`) + // v6T2 + inst.opcode = Opcode::CMP; + inst.operands = [ + Operand::Reg(Reg::from_u8(rn)), + shift, + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `SUB` (`A8-713`) + // v6T2 + // TODO: S + inst.opcode = Opcode::SUB; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + shift, + Operand::Nothing, + ]; + } + } + 0b1110 => { + // `RSB` (`A8-577`) + inst.opcode = Opcode::RSB; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + shift, + Operand::Nothing, + ]; + } + _ => { + // undefined encoding + return Err(DecodeError::Undefined); + } + } + } + } else { + // `Coprocessor, Advanced SIMD, and Floating-point instructions` (`A6-249`) + // v6T2 + eprintln!("TODO: coproc/simd/fp"); + return Err(DecodeError::Incomplete); + } + } else if opword < 0b11111 { + // op1 == 0b10 + if lower & 0x80 == 0 { + // op == 0 + if op2 & 0b0100000 == 0 { + // `A6.3.1` `Data-processing (modified immediate)` (`A6-229`) + // see `A6.3.2` for `Modified immediate constants in Thumb instructions` on how + // to decode immediates + // v6T2 + let op = op2 & 0b1111; + let i = instr >> 10 & 1; + let s = instr & 0b10000 != 0; + let rn = (instr & 0b1111) as u8; + let imm3 = (lower >> 12) & 0b111; + let rd = ((lower >> 8) & 0b1111) as u8; + let imm8 = lower & 0b11111111; + let imm = (i << 11) | (imm3 << 8) | imm8; + + let imm = ThumbExpandImm_C(imm); + + match op { + 0b0000 => { + if rd == 0b1111 && s { + // `TST` (`A8-745`) + // v6T2 + inst.opcode = Opcode::TST; + inst.operands = [ + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(imm as u32), + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `AND` (`A8-322`) + // v6T2 + // TODO: S + inst.opcode = Opcode::AND; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(imm as u32), + Operand::Nothing, + ]; + } + } + 0b0001 => { + // `BIC` (`A8-338`) + // v6T2 + // TODO: S + inst.opcode = Opcode::BIC; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(imm as u32), + Operand::Nothing, + ]; + } + 0b0010 => { + if rn == 0b1111 { + // `MOV` (`A8-485`) + // v6T2 + // TODO: S + inst.opcode = Opcode::MOV; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Imm32(imm as u32), + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `ORR` (`A8-517`) + // v6T2 + // TODO: S + inst.opcode = Opcode::ORR; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(imm as u32), + Operand::Nothing, + ]; + } + } + 0b0011 => { + if rn == 0b1111 { + // `MVN` (`A8-505`) + // v6T2 + // TODO: S + inst.opcode = Opcode::MOV; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Imm32(imm as u32), + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `ORN` (`A8-513`) + // v6T2 + // TODO: S + inst.opcode = Opcode::ORN; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(imm as u32), + Operand::Nothing, + ]; + } + } + 0b0100 => { + if rd == 0b1111 && s { + // `TEQ` (`A8-739`) + // v6T2 + // TODO: S + inst.opcode = Opcode::TEQ; + inst.operands = [ + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(imm as u32), + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `EOR` (`A8-383`) + // v6T2 + // TODO: S + inst.opcode = Opcode::EOR; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(imm as u32), + Operand::Nothing, + ]; + } + } + 0b1000 => { + if rd == 0b1111 && s { + // `CMN` (`A8-362`) + // v6T2 + // TODO: S + inst.opcode = Opcode::CMN; + inst.operands = [ + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(imm as u32), + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `ADD` (`A8-304`) + // v6T2 + // TODO: S + inst.opcode = Opcode::ADD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(imm as u32), + Operand::Nothing, + ]; + } + } + 0b1010 => { + // `ADC` (`A8-298`) + // v6T2 + // TODO: S + inst.opcode = Opcode::ADC; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(imm as u32), + Operand::Nothing, + ]; + } + 0b1011 => { + // `SBC` (`A8-593`) + // v6T2 + // TODO: S + inst.opcode = Opcode::SBC; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(imm as u32), + Operand::Nothing, + ]; + } + 0b1101 => { + if rd == 0b1111 && s { + // `CMP` (`A8-368`) + // v6T2 + // TODO: S + inst.opcode = Opcode::CMP; + inst.operands = [ + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(imm as u32), + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `SUB` (`A8-709`) + // v6T2 + // TODO: S + inst.opcode = Opcode::SUB; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(imm as u32), + Operand::Nothing, + ]; + } + } + 0b1110 => { + // `RSB` (`A8-575`) + // v6T2 + // TODO: S + inst.opcode = Opcode::RSB; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(imm as u32), + Operand::Nothing, + ]; + } + _ => { + // undefined encoding + return Err(DecodeError::Undefined); + } + } + } else { + // `Data-processing (plain binary immediate)` (`A6-232`) + // v6T2 + let op = (instr >> 4) & 0b11111; + let i = instr >> 10 & 1; + let s = instr & 0b10000 != 0; + inst.s = s; + let rn = (instr & 0b1111) as u8; + let imm3 = (lower >> 12) & 0b111; + let rd = ((lower >> 8) & 0b1111) as u8; + let imm8 = lower & 0b11111111; + let imm = (i << 11) | (imm3 << 8) | imm8; + + match op { + 0b00000 => { + if rn != 0b1111 { + // `ADD` (`A8-304`) + // v6T2 + inst.opcode = Opcode::ADD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(imm as u32), + Operand::Nothing, + ]; + } else { + // `ADR` (`A8-320`) + // v6T2 + // TODO: add = TRUE; + inst.opcode = Opcode::ADR; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Imm32(imm as u32), + Operand::Nothing, + Operand::Nothing, + ]; + } + } + 0b00100 => { + // `MOV` (`A8-485`) + inst.opcode = Opcode::MOV; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Imm32(imm as u32 | ((rn as u32) << 16)), + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b01010 => { + if rn != 0b1111 { + // `SUB` (`A8-709`) + // v6T2 + inst.opcode = Opcode::SUB; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(imm as u32), + Operand::Nothing, + ]; + } else { + // `ADR` (`A8-320`) + // v6T2 + // TODO: add = FALSE; + inst.opcode = Opcode::ADR; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Imm32(imm as u32), + Operand::Nothing, + Operand::Nothing, + ]; + } + } + 0b01100 => { + // `MOVT` (`A8-492`) + // v6T2 + inst.opcode = Opcode::MOVT; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Imm32(imm as u32 | ((rn as u32) << 16)), + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b10000 => { + // `SSAT` (`A8-653`) + // v6T2 + let imm3_2 = ((lower >> 10) & 0b11100) | ((lower >> 6) & 0b11); + let sh = 0; // from the opcode + let shift = DecodeImmShift(rn, sh << 1, imm3_2 as u8); + inst.opcode = Opcode::SSAT; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Imm32((lower & 0b11111) as u32), + Operand::RegShift(shift), + Operand::Nothing, + ]; + } + 0b10010 => { + let imm3_2 = ((lower >> 10) & 0b11100) | ((lower >> 6) & 0b11); + if imm3_2 != 0 { + let shift = DecodeImmShift(rn, ((instr >> 4) & 0b10) as u8, imm3_2 as u8); + // `SSAT` + // v6T2 + inst.opcode = Opcode::SSAT; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Imm32((lower & 0b11111) as u32), + Operand::RegShift(shift), + Operand::Nothing, + ]; + } else { + // `SSAT16` + // v6T2 + inst.opcode = Opcode::SSAT16; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Imm32((lower & 0b11111) as u32), + Operand::Reg(Reg::from_u8(rn)), + Operand::Nothing, + ]; + } + } + 0b10100 => { + // `SBFX` (`A8-599`) + // v6T2 + inst.opcode = Opcode::SBFX; + let imm3_2 = ((lower >> 10) & 0b11100) | ((lower >> 6) & 0b11); + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm12(imm3_2), + Operand::Imm12((lower & 0b11111) + 1), + ]; + } + 0b10110 => { + if rn != 0b1111 { + // `BFI` (`A8-336`) + // v6T2 + inst.opcode = Opcode::BFI; + let imm3_2 = ((lower >> 10) & 0b11100) | ((lower >> 6) & 0b11); + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm12(imm3_2), + // TODO: this is `msb` but the operand here should be `width` + Operand::Imm12(lower & 0b11111), + ]; + } else { + // `BFC` (`A8-334`) + // v6T2 + inst.opcode = Opcode::BFC; + let imm3_2 = ((lower >> 10) & 0b11100) | ((lower >> 6) & 0b11); + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm12(imm3_2), + // TODO: this is `msb` but the operand here should be `width` + Operand::Imm32((lower & 0b1111) as u32), + ]; + } + } + 0b11000 => { + // `USAT` (`A8-797`) + // v6T2 + let imm3_2 = ((lower >> 10) & 0b11100) | ((lower >> 6) & 0b11); + let sh = 0; // from the opcode + let shift = DecodeImmShift(rn, sh << 1, imm3_2 as u8); + inst.opcode = Opcode::USAT; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Imm32((lower & 0b1111) as u32), + Operand::RegShift(shift), + Operand::Nothing, + ]; + } + 0b11010 => { + let imm3_2 = ((lower >> 10) & 0b11100) | ((lower >> 6) & 0b11); + if imm3_2 != 0 { + let sh = 1; // from the opcode + let shift = DecodeImmShift(rn, sh << 1, imm3_2 as u8); + // `USAT` + // v6T2 + inst.opcode = Opcode::USAT; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Imm32((lower & 0b1111) as u32), + Operand::RegShift(shift), + Operand::Nothing, + ]; + } else { + // `USAT16` + // v6T2 + inst.opcode = Opcode::USAT16; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Imm32((lower & 0b1111) as u32), + Operand::Reg(Reg::from_u8(rn)), + Operand::Nothing, + ]; + } + } + 0b11100 => { + // `UBFX` (`A8-757`) + // v6T2 + inst.opcode = Opcode::UBFX; + let imm3_2 = ((lower >> 10) & 0b11100) | ((lower >> 6) & 0b11); + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm12(imm3_2), + Operand::Imm12((lower & 0b11111) + 1), + ]; + } + _ => { + return Err(DecodeError::Undefined); + } + } + } + } else { + // op == 1 + // `Branches and miscellaneous control` (`A6-233`) + let imm8 = lower & 0b11111111; + let op2 = (lower >> 8) & 0b0111; + let op1 = (lower >> 12) & 0b111; + let op = (instr >> 4) & 0b1111111; + if op1 & 0b101 == 0b000 { + // the high bit of op is a sign bit, if a conditional branch. otherwise, it is + // 0 for valid instructiosn other than `udf`, `hvc`, and `smc`. `Branch` is + // ruled out as `op1` is `0x1`, so see if this is any of the misc + // instructions: + if op & 0b0111000 != 0b0111000 { + // `Conditional branch` (`A8-332`) + // v6T2 + inst.condition = ConditionCode::build(((instr >> 8) & 0b1111) as u8); + inst.opcode = Opcode::B; + inst.operands = [ + Operand::BranchThumbOffset(((instr & 0b11111111) + 1) as i8 as i32), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // some misc instruction, rule out `udf`, `hvc`, `smc`: + if op < 0b1000000 { + // misc instruction + if op < 0b0111010 { + // `MSR` in some form, slightly more work to figure this out + let rn = (instr & 0b1111) as u8; + if imm8 & 0b00100000 != 0 { + // `MSR` (`B9-1980`) + // v7VE + let sysm = (((lower >> 4) & 1) << 4) | ((lower >> 8) & 0b1111); + let r = (instr >> 4) & 1; + inst.opcode = Opcode::MSR; + inst.operands = [ + // TODO: is this the appropriate banked reg? + Reg::from_sysm(r != 0, sysm as u8).expect("from_sysm works"), + Operand::Reg(Reg::from_u8(rn)), + Operand::Nothing, + Operand::Nothing, + ]; + } else { + if op == 0b0111000 { + if op2 & 0b0011 == 0b00 { + // `Move to Special register, Application level` (`A8-501`) + let mask = (lower >> 10) & 0b11; + let spec_reg = match mask { + 0b00 => { + todo!("UNPREDICTABLE"); + } + 0b01 => { + StatusRegMask::APSR_G + } + 0b10 => { + StatusRegMask::APSR_NZCVQ + } + 0b11 => { + StatusRegMask::APSR_NZCVQG + } + _ => { + unreachable!("impossible mask bits"); + } + }; + inst.opcode = Opcode::MSR; + inst.operands = [ + Operand::StatusRegMask(spec_reg), + Operand::Reg(Reg::from_u8(rn)), + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `Move to Special register, System level` (`B9-1984`) + let mask = ((lower >> 8) & 0b1111) as u8; + let r = (instr >> 4) & 1; + inst.opcode = Opcode::MSR; + inst.operands = [ + // TODO: is this the appropriate? + Reg::from_sysm(r != 0, mask).expect("from_sysm works"), + Operand::Reg(Reg::from_u8(rn)), + Operand::Nothing, + Operand::Nothing, + ]; + } + } else { + // `Move to Special register, System level` (`B9-1984`) + let mask = ((lower >> 8) & 0b1111) as u8; + let r = (instr >> 4) & 1; + inst.opcode = Opcode::MSR; + inst.operands = [ + // TODO: is this the appropriate? + Reg::from_sysm(r != 0, mask).expect("from_sysm works"), + Operand::Reg(Reg::from_u8(rn)), + Operand::Nothing, + Operand::Nothing, + ]; + } + } + } else if op < 0b0111011 { + // `Change Processor State, and hints` (`A6-234`) + let op1 = (lower >> 8) & 0b111; + let op2 = lower & 0b11111111; + if op1 != 0b000 { + // `CPS (Thumb)` (`B9-1964`) + // v6T2 + let _mode = lower & 0b11111; + let _aif = (lower >> 5) & 0b111; + let _m = (lower >> 8) & 1; + let _imod = (lower >> 9) & 0b11; + // TODO: no CPS instruction? yet? + eprintln!("cps support is not complete"); + return Err(DecodeError::Incomplete); + // inst.opcode = Opcode::CPS; + } else { + if op2 >= 0b11110000 { + // `DBG` (`A8-378`) + let option = lower & 0b1111; + inst.opcode = Opcode::DBG; + inst.operands = [ + Operand::Imm12(option), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else { + match op2 { + 0b00000000 => { + // `NOP` (`A8-511`) + // v6T2 + // TODO: should_is_must + inst.opcode = Opcode::NOP; + inst.operands = [ + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b00000001 => { + // `YIELD` (`A8-1109`) + // v7 + inst.opcode = Opcode::YIELD; + inst.operands = [ + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b00000010 => { + // `WFE` (`A8-1105`) + // v7 + inst.opcode = Opcode::WFE; + inst.operands = [ + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b00000011 => { + // `WFI` (`A8-1107`) + // v7 + inst.opcode = Opcode::WFI; + inst.operands = [ + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b00000100 => { + // `SEV` (`A8-607`) + // v7 + inst.opcode = Opcode::SEV; + inst.operands = [ + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b00010100 => { + // `CSDB` (`A8-376`) + // v6T2 + inst.opcode = Opcode::CSDB; + inst.operands = [ + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + _ => { + return Err(DecodeError::Undefined); + } + } + } + } + } else if op < 0b0111100 { + // `Miscellaneous control instructions` (`A6-235`) + let op = (lower >> 4) & 0b1111; + match op { + 0b0000 => { + // `ENTERX` (`A9-1116`) + // ThumbEE + inst.opcode = Opcode::LEAVEX; + inst.operands = [ + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + }, + 0b0001 => { + // `ENTERX` (`A9-1116`) + // ThumbEE + inst.opcode = Opcode::ENTERX; + inst.operands = [ + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + }, + 0b0010 => { + // `CLREX` (`A8-358`) + // v7 + inst.opcode = Opcode::CLREX; + inst.operands = [ + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + }, + 0b0100 => { + // `DSB` (`A8-381`) + // v7 + let option = lower & 0b1111; + inst.opcode = Opcode::DSB; + inst.operands = [ + Operand::Imm12(option), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + }, + 0b0101 => { + // `DMB` (`A8-379`) + // v7 + let option = lower & 0b1111; + inst.opcode = Opcode::DMB; + inst.operands = [ + Operand::Imm12(option), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + }, + 0b0110 => { + // `ISB` (`A8-390`) + // v7 + let option = lower & 0b1111; + inst.opcode = Opcode::ISB; + inst.operands = [ + Operand::Imm12(option), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + }, + _ => { + return Err(DecodeError::Undefined); + } + } + } else if op < 0b0111101 { + // `BXJ` (`A8-352`) + // v6T2 + let rm = (instr & 0b1111) as u8; + inst.opcode = Opcode::BXJ; + inst.operands = [ + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else if op < 0b0111110 { + // `ERET` or `SUBS PC, LR` + // v6T2 + // `v7VE` defines `ERET` here, identical to `subs pc, lr` with + // `imm8 == 0`. `v7VE` does not change the behavior of this + // instruction at `PL1`. + let imm8 = lower & 0b11111111; + if imm8 == 0 { + // `ERET` (`B9-1968`) + // v6T2 + // if <v7VE, `subs pc, lr, #0` + inst.opcode = Opcode::ERET; + inst.operands = [ + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `SUBS PC, LR (Thumb)` (`B9-1996`) + // v6T2 + inst.opcode = Opcode::SUB; + inst.s = true; + inst.operands = [ + Operand::Reg(Reg::from_u8(15)), // pc + Operand::Reg(Reg::from_u8(14)), // lr + Operand::Imm12(lower & 0b11111111), + Operand::Nothing, + ]; + } + } else { + // `op` is `0b0111110` or `0b0111111`, both are `MRS` but there's + // some discerning to do still. + let imm8 = lower & 0b11111111; + if imm8 & 0b00100000 != 0 { + // `MRS (Banked register)` (`B9-1978`) + // v7VE + let r = instr & 0b10000; + let sysm = (lower & 0b10000) | (instr & 0b1111); + let rd = ((lower >> 8) & 0b1111) as u8; + inst.opcode = Opcode::MRS; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Reg::from_sysm(r != 0, sysm as u8).expect("from_sysm works"), + Operand::Nothing, + Operand::Nothing, + ]; + } else { + if op == 0b0111110 { + // `MRS` (`A8-497`) + // v6T2 + inst.opcode = Opcode::MRS; + let rd = ((lower >> 8) & 0b1111) as u8; + inst.opcode = Opcode::MRS; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + // TODO: "<spec_reg>"? + Reg::from_sysm(false, 0).expect("from_sysm works"), + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `MRS` (`B9-1976`) + // v6T2 + inst.opcode = Opcode::MRS; + let rd = ((lower >> 8) & 0b1111) as u8; + let r = (instr >> 4) & 1; + inst.opcode = Opcode::MRS; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + // TODO: "<spec_reg>"? + Reg::from_sysm(r != 0, 0).expect("from_sysm works"), + Operand::Nothing, + Operand::Nothing, + ]; + } + } + } + } else { + if op == 0b1111111 { + if op1 == 0b000 { + // `SMC` (aka `SMI`) (`B9-1988`) + // "Security Extensions" + let imm = instr & 0b1111; + inst.opcode = Opcode::SMC; + inst.operands = [ + Operand::Imm12(imm), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `UDF` (`A8-759`) + // All (first defined in issue `C.a`) + // TODO: should this decode to an intentional `UDF` + // instruction? + return Err(DecodeError::Undefined); + } + } else if op == 0b1111110 { + if op1 == 0b000 { + // `HVC` (`B8-1970`) + // v7VE + let imm = lower & 0b1111_1111_1111; + inst.opcode = Opcode::HVC; + inst.operands = [ + Operand::Imm12(imm), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // undefined, but by not being mentioned in the manual + return Err(DecodeError::Undefined); + } + } else { + // undefined, but by not being mentioned in the manual + return Err(DecodeError::Undefined); + } + } + } + } else if op1 & 0b101 == 0b001 { + // `Branch` (`A8-332`) + // v6T2 + // + let imm11 = lower & 0b111_1111_1111; + let imm6 = instr & 0b11_1111; + let j1 = (lower >> 13) & 1; + let j2 = (lower >> 11) & 1; + let s = (instr >> 10) & 1; + let imm = + (imm11 as u32) | + ((imm6 as u32) << 11) | + ((j1 as u32) << 17) | + ((j2 as u32) << 18) | + ((s as u32) << 19); + let imm = (imm << 12) >> 12; + inst.opcode = Opcode::B; + inst.operands = [ + Operand::Imm32(imm as u32), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else if op1 & 0b101 == 0b100 { + // `Branch with Link and Exchange` (`A8-346`) + // `UNDEFINED` in v4T + // v5T + let imm11 = lower & 0b111_1111_1111; + let imm10 = instr & 0b11_1111_1111; + let j1 = (lower >> 13) & 1; + let j2 = (lower >> 11) & 1; + let s = (instr >> 10) & 1; + let imm = + (imm11 as u32) | + ((imm10 as u32) << 11) | + ((j1 as u32) << 21) | + ((j2 as u32) << 22) | + ((s as u32) << 23); + let imm = (imm << 8) >> 8; + inst.opcode = Opcode::BLX; + inst.operands = [ + Operand::Imm32(imm as u32), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `Brach with Link` (`A8-346`) + // v4T + let imm11 = lower & 0b111_1111_1111; + let imm10 = instr & 0b11_1111_1111; + let j1 = (lower >> 13) & 1; + let j2 = (lower >> 11) & 1; + let s = (instr >> 10) & 1; + let imm = + (imm11 as u32) | + ((imm10 as u32) << 11) | + ((j1 as u32) << 21) | + ((j2 as u32) << 22) | + ((s as u32) << 23); + let imm = (imm << 8) >> 8; + inst.opcode = Opcode::BL; + inst.operands = [ + Operand::Imm32(imm as u32), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + } + } else { + // op1 == 0b11 + if op2 & 0b1000000 == 0 { + if op2 & 0b0100000 == 0 { + // loads, stores + if op2 & 0b0000001 == 0 { + // store single item, or advanced simd load/store + if op2 & 0b00100000 == 0 { + // `Store single data item` (`A6-240`) + let rn = (instr & 0b1111) as u8; + let op1 = (instr >> 5) & 0b111; + let size_bits = op1 & 0b011; + let op2 = (lower >> 6) & 0b111111; + match size_bits { + 0b00 => { + // `STRB_` + if op2 == 0 { + // `STRB (register)` (`A8-683`) + // encoding T2 + // v6T2 + let rm = (lower & 0b1111) as u8; + let imm2 = (lower >> 4) & 0b11; + let rt = ((lower >> 12) & 0b1111) as u8; + inst.opcode = Opcode::STRB; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::RegDerefPreindexRegShift( + Reg::from_u8(rn), + RegShift::from_raw( + // do things + 0b0000 | // imm shift + (imm2 << 7) | // imm + rm as u16 | // shiftee + (0b00 << 5) // shift style (lsl) + ), + true, // add + false, // wback + ), + Operand::Nothing, + Operand::Nothing, + ]; + } else if (op2 & 0b111100) == 0b111000 { + // `STRBT` (`A8-685`) + // v6T2 + let imm8 = lower & 0b1111_1111; + let rt = ((lower >> 12) & 0b1111) as u8; + inst.opcode = Opcode::STRBT; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::RegDerefPreindexOffset( + Reg::from_u8(rn), + imm8, + true, // add + false, // wback + ), + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `STRB (immediate, Thumb)` (`A8-679`) + // encoding T3 + // v6T2 + let imm8 = lower & 0b1111_1111; + let puw = (lower >> 8) & 0b111; + let p = puw & 0b100 != 0; + let u = puw & 0b010 != 0; + let w = puw & 0b001 != 0; + // assert!(puw != 0b110) // would be `strbt` + let rt = ((lower >> 12) & 0b1111) as u8; + inst.opcode = Opcode::STRB; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + // do the puw + if p { + Operand::RegDerefPreindexOffset( + Reg::from_u8(rn), + imm8, + u, // add + w, // wback + ) + } else { + Operand::RegDerefPostindexOffset( + Reg::from_u8(rn), + imm8, + u, // add + w, // wback + ) + }, + Operand::Nothing, + Operand::Nothing, + ]; + } + } + 0b01 => { + // `STRH_` + // v6T2 + if op2 == 0 { + // `STRH (register)` (`A8-703`) + let rm = (lower & 0b1111) as u8; + let imm2 = (lower >> 4) & 0b11; + let rt = ((lower >> 12) & 0b1111) as u8; + inst.opcode = Opcode::STRH; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::RegDerefPreindexRegShift( + Reg::from_u8(rn), + RegShift::from_raw( + // do things + 0b0000 | // imm shift + (imm2 << 7) | // imm + rm as u16 | // shiftee + (0b00 << 5) // shift style (lsl) + ), + true, // add + false, // wback + ), + Operand::Nothing, + Operand::Nothing, + ]; + } else if (op2 & 0b111100) == 0b111000 { + // `STRHT` (`A8-705`) + let imm8 = lower & 0b1111_1111; + let rt = ((lower >> 12) & 0b1111) as u8; + inst.opcode = Opcode::STRHT; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::RegDerefPreindexOffset( + Reg::from_u8(rn), + imm8, + true, // add + false, // wback + ), + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `STRH (immediate, Thumb)` (`A8-699`) + // encoding T3 + // v6T2 + let imm8 = lower & 0b1111_1111; + let puw = (lower >> 8) & 0b111; + let p = puw & 0b100 != 0; + let u = puw & 0b010 != 0; + let w = puw & 0b001 != 0; + // assert!(puw != 0b110) // would be `strbt` + let rt = ((lower >> 12) & 0b1111) as u8; + inst.opcode = Opcode::STRH; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + // do the puw + if p { + Operand::RegDerefPreindexOffset( + Reg::from_u8(rn), + imm8, + u, // add + w, // wback + ) + } else { + Operand::RegDerefPostindexOffset( + Reg::from_u8(rn), + imm8, + u, // add + w, // wback + ) + }, + Operand::Nothing, + Operand::Nothing, + ]; + } + } + 0b10 => { + // `STR_` + if op2 == 0 { + // `STR (register)` (`A8-677`) + // v6T2 + let rm = (lower & 0b1111) as u8; + let imm2 = (lower >> 4) & 0b11; + let rt = ((lower >> 12) & 0b1111) as u8; + inst.opcode = Opcode::STR; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::RegDerefPreindexRegShift( + Reg::from_u8(rn), + RegShift::from_raw( + // do things + 0b0000 | // imm shift + (imm2 << 7) | // imm + rm as u16 | // shiftee + (0b00 << 5) // shift style (lsl) + ), + true, // add + false, // wback + ), + Operand::Nothing, + Operand::Nothing, + ]; + } else if (op2 & 0b111100) == 0b111000 { + // `STRT` (`A8-707`) + let imm8 = lower & 0b1111_1111; + let rt = ((lower >> 12) & 0b1111) as u8; + inst.opcode = Opcode::STRT; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::RegDerefPreindexOffset( + Reg::from_u8(rn), + imm8, + true, // add + false, // wback + ), + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `STR (immediate, Thumb)` (`A8-673`) + // encoding T4 + // v6T2 + let imm8 = lower & 0b1111_1111; + let puw = (lower >> 8) & 0b111; + let p = puw & 0b100 != 0; + let u = puw & 0b010 != 0; + let w = puw & 0b001 != 0; + // assert!(puw != 0b110) // would be `strbt` + let rt = ((lower >> 12) & 0b1111) as u8; + inst.opcode = Opcode::STR; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + // do the puw + if p { + Operand::RegDerefPreindexOffset( + Reg::from_u8(rn), + imm8, + u, // add + w, // wback + ) + } else { + Operand::RegDerefPostindexOffset( + Reg::from_u8(rn), + imm8, + u, // add + w, // wback + ) + }, + Operand::Nothing, + Operand::Nothing, + ]; + } + } + 0b11 => { + return Err(DecodeError::Undefined); + } + _ => { + unreachable!("impossible bit pattern"); + } + } + } else { + // `Advanced SIMD element or structure load/store instructions` + // (`A7-273`) + } + } else { + // load {byte, halfword, word} + let size_bits = (op2 >> 1) & 0b11; + if size_bits == 0b00 { + // `Load byte, memory hints` (`A6-239`) + } else if size_bits == 0b01 { + // `Load halfword, memory hints` (`A6-238`) + } else if size_bits == 0b10 { + // `Load word` (`A6-237`) + } else { + // `UNDEFINED` + return Err(DecodeError::Undefined); + } + } + } else { + if op2 & 0b0010000 == 0 { + // `Data-processing (register)` (`A6-243`) + let op1 = (instr >> 4) & 0b1111; + let op2 = (lower >> 4) & 0b1111; + let rn = (instr & 0b1111) as u8; + if op1 < 0b1000 { + // `LSL`, `LSR`, `ASR`, `ROR`, `SXTAH`, .... out of table `A6-24` + if op2 < 0b1000 { + // `LSL`, `LSR`, `ASR`, `ROR` + // v6T2 + let op = [ + Opcode::LSL, + Opcode::LSR, + Opcode::ASR, + Opcode::ROR, + ][((op2 >> 1) & 0b11) as usize]; + let rd = ((lower >> 8) & 0b1111) as u8; + let rm = (lower & 0b1111) as u8; + inst.opcode = op; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + ]; + } else { + // `SXTAH` and friends + if op1 > 0b101 { + return Err(DecodeError::Undefined); + } + + if rn == 0b1111 { + let op = [ + Opcode::SXTH, + Opcode::UXTH, + Opcode::SXTB16, + Opcode::UXTB16, + Opcode::SXTB, + Opcode::UXTB, + ][(op1 & 0b111) as usize]; + + let rm = (lower & 0b1111) as u8; + let rotate = (lower >> 1) & 0b11000; + let rd = ((lower >> 8) & 0b1111) as u8; + + inst.opcode = op; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Imm32(rotate as u32), + Operand::Nothing, + ]; + } else { + let op = [ + Opcode::SXTAH, + Opcode::UXTAH, + Opcode::SXTAB16, + Opcode::UXTAB16, + Opcode::SXTAH, + Opcode::UXTAB, + ][(op1 & 0b111) as usize]; + + let rm = (lower & 0b1111) as u8; + let rotate = (lower >> 1) & 0b11000; + let rd = ((lower >> 8) & 0b1111) as u8; + + inst.opcode = op; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Imm32(rotate as u32), + ]; + }; + } + } else { + if op2 < 0b0100 { + // `Parallel addition and subtraction, signed` + } else if op2 < 0b1000 { + // `Parallel addition and subtraction, unsigned` (`A6-244`) + } else if op2 < 0b1100 { + // `Miscellaneous operations` (`A6-246`) + } else { + return Err(DecodeError::Undefined); + } + } + } else { + if op2 & 0b0001000 == 0 { + // `Multiply, multiply accumulate, and absolute difference` (`A6-247`) + } else { + // `Long multiply, long multiply accumulate, and divide` (`A6-248`) + } + } + } + } else { + // `Coprocessor, Advanced SIMD, and Floating-point instructions` (`A6-249`) + } + } + } else { + // 16b instruction - `A6-221, 16-bit Thumb instruction encoding` + // `Table A6-1` + if opword < 0b01000 { + // `Shift (immediate), add, subtract, move, and compare` page `A6-222` + // v4T + let opcode = opword & 0b111; + // TODO: `S` iff outside `IT` block + inst.s = true; + + match opcode { + 0b000 => { + // LSL (immediate) + // footnote: when opcode is 0, bits 8:6 are 0, encoding is `MOV`. see `A8-487`. + let rd = (instr & 0b111) as u8; + let rm = ((instr >> 3) & 0b111) as u8; + let imm5 = (instr >> 6) & 0b11111; + inst.opcode = Opcode::LSL; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Imm12(imm5), + Operand::Nothing, + ]; + } + 0b001 => { + /* LSR on page A8-473 */ + let rd = (instr & 0b111) as u8; + let rm = ((instr >> 3) & 0b111) as u8; + let imm5 = (instr >> 6) & 0b11111; + let imm = if imm5 == 0 { + 0x20 + } else { + imm5 + }; + inst.opcode = Opcode::LSR; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Imm12(imm), + Operand::Nothing, + ]; + } + 0b010 => { + /* ASR on page A8-328 */ + let rd = (instr & 0b111) as u8; + let rm = ((instr >> 3) & 0b111) as u8; + let imm5 = (instr >> 6) & 0b11111; + let imm = if imm5 == 0 { + 0x20 + } else { + imm5 + }; + inst.opcode = Opcode::ASR; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Imm12(imm), + Operand::Nothing, + ]; + } + 0b011 => { + /* ADD, SUB (register/immediate) */ + let oplower = (instr >> 9) & 0b11; + let rd = (instr & 0b111) as u8; + let rn = ((instr >> 3) & 0b111) as u8; + let rm = ((instr >> 6) & 0b111) as u8; + + match oplower { + 0b00 => { + inst.opcode = Opcode::ADD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + ]; + } + 0b01 => { + inst.opcode = Opcode::SUB; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + ]; + } + 0b10 => { + inst.opcode = Opcode::ADD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(rm as u32), + Operand::Nothing, + ]; + } + 0b11 => { + inst.opcode = Opcode::SUB; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rn)), + Operand::Imm32(rm as u32), + Operand::Nothing, + ]; + } + _ => { + unreachable!("impossible bit pattern"); + } + } + } + 0b100 => { + /* MOV on page A8-485 */ + + let imm8 = instr & 0b1111_1111; + let rd = ((instr >> 8) & 0b111) as u8; + inst.opcode = Opcode::MOV; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Imm32(imm8 as u32), + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b101 => { + /* CMP on page A8-368 */ + inst.s = false; + let imm8 = instr & 0b1111_1111; + let rd = ((instr >> 8) & 0b111) as u8; + inst.opcode = Opcode::CMP; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Imm32(imm8 as u32), + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b110 => { + /* ADD (immediate, Thumb) on page A8-304 */ + let imm8 = instr & 0b1111_1111; + let rdn = ((instr >> 8) & 0b111) as u8; + inst.opcode = Opcode::ADD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rdn)), + Operand::Imm32(imm8 as u32), + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b111 => { + /* SUB (immediate, Thumb) on page A8-709 */ + let imm8 = instr & 0b1111_1111; + let rdn = ((instr >> 8) & 0b111) as u8; + inst.opcode = Opcode::SUB; + inst.operands = [ + Operand::Reg(Reg::from_u8(rdn)), + Operand::Imm32(imm8 as u32), + Operand::Nothing, + Operand::Nothing, + ]; + } + _ => { + unreachable!("impossible bit pattern"); + } + } + } else if opword < 0b01001 { + let opcode_bits = (instr >> 6) & 0b1111; + // `Data-processing` on page `A6-223` or `Special data instructions and branch and + // exchange` on page `A6-224` + if (instr >> 10) < 0b010001 { + // `Data-processing` on page `A6-223` + // v4T + // TODO: condition inside IT block, no S + inst.s = true; + let rdn = (instr & 0b111) as u8; + let rm = ((instr >> 3) & 0b111) as u8; + if opcode_bits == 0b1101 { + inst.opcode = Opcode::MUL; + inst.operands = [ + Operand::Reg(Reg::from_u8(rdn)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Reg(Reg::from_u8(rdn)), + Operand::Nothing, + ]; + } else if opcode_bits == 0b1001 { + inst.opcode = Opcode::RSB; + inst.operands = [ + Operand::Reg(Reg::from_u8(rdn)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Imm12(0), + Operand::Nothing, + ]; + } else { + let opcode = [ + Opcode::AND, + Opcode::EOR, + Opcode::LSL, + Opcode::LSR, + Opcode::ASR, + Opcode::ADC, + Opcode::SBC, + Opcode::ROR, + Opcode::TST, + Opcode::RSB, + Opcode::CMP, + Opcode::CMN, + Opcode::ORR, + Opcode::MUL, + Opcode::BIC, + Opcode::MVN, + ][opcode_bits as usize]; + inst.opcode = opcode; + if opcode_bits == 8 || opcode_bits == 10 || opcode_bits == 11 { + inst.s = false; + } + inst.operands = [ + Operand::Reg(Reg::from_u8(rdn)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + Operand::Nothing, + ]; + } + } else { + // `Special data instructions and branch and exchange` on page `A6-224` + match opcode_bits { + 0b0000 => { + // `Add Low Registers` (`A8-308`) + // v6T2, `UNPREDICTABLE` in earlier versions + let rdn = ((instr & 0b111) | ((instr >> 4) & 0b1000)) as u8; + let rm = ((instr >> 3) & 0b1111) as u8; + inst.opcode = Opcode::ADD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rdn)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + Operand::Nothing, + ]; + }, + 0b0001 | + 0b0010 | + 0b0011 => { + // `Add High Registers` (`A8-308`) + // v4T + let rdn = ((instr & 0b111) | ((instr >> 4) & 0b1000)) as u8; + let rm = ((instr >> 3) & 0b1111) as u8; + inst.opcode = Opcode::ADD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rdn)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + Operand::Nothing, + ]; + }, + 0b0100 | + 0b0101 | + 0b0110 | + 0b0111 => { + // `Compare High Registers` (`A8-307`) + // v4T + let rn = ((instr & 0b111) | ((instr >> 4) & 0b1000)) as u8; + let rm = ((instr >> 3) & 0b1111) as u8; + inst.opcode = Opcode::CMP; + inst.operands = [ + Operand::Reg(Reg::from_u8(rn)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b1000 => { + // `Move Low Registers` (`A8-487`) + // v6, `UNPREDICTABLE` in earlier versions + // (encoding T1) + let rd = ((instr & 0b111) | ((instr >> 4) & 0b1000)) as u8; + let rm = ((instr >> 3) & 0b1111) as u8; + inst.opcode = Opcode::MOV; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b1001 | + 0b1010 | + 0b1011 => { + // `Move High Registers` (`A8-487`) + // v4T + let rd = ((instr & 0b111) | ((instr >> 4) & 0b1000)) as u8; + let rm = ((instr >> 3) & 0b1111) as u8; + inst.opcode = Opcode::MOV; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + Operand::Nothing, + ]; + }, + 0b1100 | + 0b1101 => { + // `Branch and Exchange` (`A8-350`) + // v4T + let rm = ((instr >> 3) & 0b1111) as u8; + inst.opcode = Opcode::BX; + inst.operands = [ + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b1110 | + 0b1111 => { + // `Branch and Link with Exchange` (`A8-348`) + // v5T, `UNPREDICTABLE` in earlier versions + let rm = ((instr >> 3) & 0b1111) as u8; + inst.opcode = Opcode::BLX; + inst.operands = [ + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + _ => { + unreachable!("bad bit pattern"); + } + } + } + } else if opword < 0b01010 { + // `LDR (literal)` on page `A8-411` -- v4T + let imm8 = instr & 0b1111_1111; + let rt = ((instr >> 8) & 0b111) as u8; + inst.opcode = Opcode::LDR; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::RegDerefPreindexOffset( + Reg::from_u8(0b1111), + imm8 << 2, + true, // add + false, // no wback + ), + Operand::Nothing, + Operand::Nothing, + ]; + } else if opword < 0b10100 { + let op_b = (instr >> 9) & 0b111; + let op_a = instr >> 12; + // `Load/store single data item` on page `A6-225` + // v4T + let rt = (instr & 0b111) as u8; + let rn = ((instr >> 3) & 0b111) as u8; + let rm = ((instr >> 6) & 0b111) as u8; + let imm5 = (instr >> 6) & 0b11111; + if op_a == 0b0101 { + let op = [ + Opcode::STR, + Opcode::STRH, + Opcode::STRB, + Opcode::LDRSB, + Opcode::LDR, + Opcode::LDRH, + Opcode::LDRB, + Opcode::LDRSH, + ][op_b as usize]; + inst.opcode = op; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::RegDerefPreindexReg( + Reg::from_u8(rn), + Reg::from_u8(rm), + true, // add + false, // wback + ), + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // opword is 0b0110, 0b0111, 0b1000, or 0b1001. opb bit 2 can be used to form a + // three-bit index and select an opcode. operands are shared. except the last two. + // those are sp-relative. + let upper = op_a - 0b0110; + let idx = (upper << 1) | (op_b >> 2); + let op = [ + Opcode::STR, + Opcode::LDR, + Opcode::STRB, + Opcode::LDRB, + Opcode::STRH, + Opcode::LDRH, + Opcode::STR, + Opcode::LDR, + ][idx as usize]; + inst.opcode = op; + if idx < 6 { + let shift = match idx >> 1 { + 0b00 => 2, + 0b01 => 0, + 0b10 => 1, + _ => { unreachable!("impossible bit pattern"); } + }; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::RegDerefPreindexOffset( + Reg::from_u8(rn), + imm5 << shift, + true, // add + false, // wback + ), + Operand::Nothing, + Operand::Nothing, + ]; + } else { + let rt = ((instr >> 8) & 0b111) as u8; + let imm8 = instr & 0b1111_1111; + inst.operands = [ + Operand::Reg(Reg::from_u8(rt)), + Operand::RegDerefPreindexOffset( + Reg::from_u8(13), // sp + imm8 << 2, + true, // add + false, // wback + ), + Operand::Nothing, + Operand::Nothing, + ]; + } + } + } else if opword < 0b10101 { + // `ADR` on page `A8-320` -- v4T + let rd = ((instr >> 8) & 0b111) as u8; + let imm8 = instr & 0b1111_1111; + inst.opcode = Opcode::ADR; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Imm32(imm8 as u32 * 4), + Operand::Nothing, + Operand::Nothing, + ]; + } else if opword < 0b10110 { + // `ADD (SP plus immediate)` on `A8-314` -- v4T + let rd = ((instr >> 8) & 0b111) as u8; + let imm8 = instr & 0b1111_1111; + inst.opcode = Opcode::ADD; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(13)), // sp + Operand::Imm32(imm8 as u32 * 4), + Operand::Nothing, + ]; + } else if opword < 0b11000 { + // `Miscellaneous 16-bit instructions` on page `A6-226` + let opcode_bits = (instr >> 5) & 0b1111111; + if opcode_bits < 0b0000100 { + // `Add Immediate to SP` (`A8-314`) + // v4T + // encoding T2 + let imm7 = instr & 0b111_1111; + inst.s = false; + inst.opcode = Opcode::ADD; + inst.operands = [ + Operand::Reg(Reg::from_u8(13)), + Operand::Reg(Reg::from_u8(13)), + Operand::Imm32((imm7 << 2) as u32), + Operand::Nothing, + ]; + } else if opcode_bits < 0b0001000 { + // `Subtract Immediate to SP` (`A8-717`) + // v4T + let imm7 = instr & 0b111_1111; + inst.s = false; + inst.opcode = Opcode::SUB; + inst.operands = [ + Operand::Reg(Reg::from_u8(13)), + Operand::Reg(Reg::from_u8(13)), + Operand::Imm32((imm7 << 2) as u32), + Operand::Nothing, + ]; + } else if opcode_bits < 0b0010000 { + // `Compare and Branch on Zero` (`A8-354`) + // v6T2 + let op = (instr >> 11) & 1 != 0; + let rn = (instr & 0b111) as u8; + let imm5 = (instr >> 3) & 0b11111; + let imm = (((instr >> 9) & 1) << 5) | imm5; + inst.opcode = if op { + Opcode::CBNZ + } else { + Opcode::CBZ + }; + inst.operands = [ + Operand::Reg(Reg::from_u8(rn)), + Operand::BranchThumbOffset(imm as i32 + 1), + Operand::Nothing, + Operand::Nothing, + ]; + } else if opcode_bits < 0b0010010 { + // `Signed Extend Halfword` (`A8-735`) + // v6 + let rd = (instr & 0b111) as u8; + let rm = ((instr >> 3) & 0b111) as u8; + inst.opcode = Opcode::SXTH; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + Operand::Nothing, + ]; + } else if opcode_bits < 0b0010100 { + // `Signed Extend Byte` (`A8-731`) + // v6 + let rd = (instr & 0b111) as u8; + let rm = ((instr >> 3) & 0b111) as u8; + inst.opcode = Opcode::SXTB; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + Operand::Nothing, + ]; + } else if opcode_bits < 0b0010110 { + // `Unsigned Extend Halfword` (`A8-817`) + // v6 + let rd = (instr & 0b111) as u8; + let rm = ((instr >> 3) & 0b111) as u8; + inst.opcode = Opcode::UXTH; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + Operand::Nothing, + ]; + } else if opcode_bits < 0b0011000 { + // `Unsigned Extend Byte` (`A8-813`) + // v6 + let rd = (instr & 0b111) as u8; + let rm = ((instr >> 3) & 0b111) as u8; + inst.opcode = Opcode::UXTB; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + Operand::Nothing, + ]; + } else if opcode_bits < 0b0100000 { + // `Compare and Branch on Zero` (`A8-354`) + // v6T2 + let op = (instr >> 11) & 1 != 0; + let rn = (instr & 0b111) as u8; + let imm5 = (instr >> 3) & 0b11111; + let imm = (((instr >> 9) & 1) << 5) | imm5; + inst.opcode = if op { + Opcode::CBNZ + } else { + Opcode::CBZ + }; + inst.operands = [ + Operand::Reg(Reg::from_u8(rn)), + Operand::BranchThumbOffset(imm as i32 + 1), + Operand::Nothing, + Operand::Nothing, + ]; + } else if opcode_bits < 0b0110000 { + // `Push multiple registers` (`A8-539`) + // v4T + let m = (instr >> 8) & 1; + let reglist = (instr & 0b1111_1111) | (m << (6 + 8)); + inst.opcode = Opcode::PUSH; + inst.operands = [ + Operand::RegList(reglist), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else if opcode_bits < 0b0110010 { + // undefined encoding between `PUSH` and `SETEND` + return Err(DecodeError::Undefined); + } else if opcode_bits < 0b0110011 { + // opword == 0b0110010 + // `Set Endianness` (`A8-605`) + // v6 + let e = (instr >> 3) & 1; + inst.opcode = Opcode::SETEND; + inst.operands = [ + Operand::Imm12(e), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else if opcode_bits < 0b0110100 { + // opword == 0b0110011 + // `Change Processor State` (`B9-1964`) + // v6 + let aif = instr & 0b111; + let im = (instr >> 4) & 1; + inst.opcode = Opcode::CPS(im != 0); + inst.operands = [ + Operand::Imm12(aif), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else if opcode_bits < 0b1001000 { + // undefined encoding between `CPS` and `CBNZ/CBZ` + return Err(DecodeError::Undefined); + } else if opcode_bits < 0b1010000 { + // `Compare and Branch on Nonzero` (`A8-354`) + // v6T2 + let op = (instr >> 11) & 1 != 0; + let rn = (instr & 0b111) as u8; + let imm5 = (instr >> 3) & 0b11111; + let imm = (((instr >> 9) & 1) << 5) | imm5; + inst.opcode = if op { + Opcode::CBNZ + } else { + Opcode::CBZ + }; + inst.operands = [ + Operand::Reg(Reg::from_u8(rn)), + Operand::BranchThumbOffset(imm as i32 + 1), + Operand::Nothing, + Operand::Nothing, + ]; + } else if opcode_bits < 0b1010010 { + // `Byte-Reverse Word` (`A8-563`) + // v6 + let rd = (instr & 0b111) as u8; + let rm = ((instr >> 3) & 0b111) as u8; + inst.opcode = Opcode::REV; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + Operand::Nothing, + ]; + } else if opcode_bits < 0b1010100 { + // `Byte-Reverse Packed Halfword` (`A8-565`) + // v6 + let rd = (instr & 0b111) as u8; + let rm = ((instr >> 3) & 0b111) as u8; + inst.opcode = Opcode::REV16; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + Operand::Nothing, + ]; + } else if opcode_bits < 0b1010110 { + // undefined encoding where `Byte-Reverse Signed Word` might go + return Err(DecodeError::Undefined); + } else if opcode_bits < 0b1011000 { + // `Byte-Reverse Signed Halfword` (`A8-567`) + // v6 + let rd = (instr & 0b111) as u8; + let rm = ((instr >> 3) & 0b111) as u8; + inst.opcode = Opcode::REVSH; + inst.operands = [ + Operand::Reg(Reg::from_u8(rd)), + Operand::Reg(Reg::from_u8(rm)), + Operand::Nothing, + Operand::Nothing, + ]; + } else if opcode_bits < 0b1100000 { + // `Compare and Branch on Nonzero` (`A8-354`) + // v6T2 + let op = (instr >> 11) & 1 != 0; + let rn = (instr & 0b111) as u8; + let imm5 = (instr >> 3) & 0b11111; + let imm = (((instr >> 9) & 1) << 5) | imm5; + inst.opcode = if op { + Opcode::CBNZ + } else { + Opcode::CBZ + }; + inst.operands = [ + Operand::Reg(Reg::from_u8(rn)), + Operand::BranchThumbOffset(imm as i32 + 1), + Operand::Nothing, + Operand::Nothing, + ]; + } else if opcode_bits < 0b1110000 { + // `Pop Multiple Registers` (`A8-535`) + // v4T + let p = (instr >> 8) & 1; + let reglist = (instr & 0b1111_1111) | (p << (7 + 8)); + inst.opcode = Opcode::POP; + inst.operands = [ + Operand::RegList(reglist), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else if opcode_bits < 0b1111000 { + // `Breakpoint` (`A8-344`) + // v5 + let imm8 = instr & 0b1111_1111; + inst.opcode = Opcode::BKPT; + inst.operands = [ + Operand::Imm32(imm8 as u32), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `If-Then, and hints` (`A6-227`) + let opb = instr & 0b1111; + let opa = (instr >> 4) & 0b1111; + + if opb != 0 { + // `IT` (`A8-391`) + // v6T2 + let firstcond = opa; + let mask = opb; + inst.opcode = Opcode::IT; + if firstcond == 0b1111 { + return Err(DecodeError::InvalidOperand); + } + inst.operands = [ + Operand::Imm32(firstcond as u32), + Operand::Imm32(mask as u32), + Operand::Nothing, + Operand::Nothing, + ]; + } else { + match opa { + 0b0000 => { + // `NOP` (`A8-511`) + // v6T2 + inst.opcode = Opcode::NOP; + inst.operands = [ + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b0001 => { + // `YIELD` (`A8-1109`) + // v7 + inst.opcode = Opcode::YIELD; + inst.operands = [ + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b0010 => { + // `WFE` (`A8-1105`) + // v7 + inst.opcode = Opcode::WFE; + inst.operands = [ + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b0011 => { + // `WFI` (`A8-1107`) + // v7 + inst.opcode = Opcode::WFI; + inst.operands = [ + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + 0b0100 => { + // `SEV` (`A8-607`) + // v7 + inst.opcode = Opcode::SEV; + inst.operands = [ + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + hint => { + // `Other encodings in this space are unallocated hints. They execute + // as NOPs, but software must not use them.` + inst.opcode = Opcode::HINT; + inst.operands = [ + Operand::Imm12(hint), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + } + } + } + } else if opword < 0b11001 { + // `STM (STMIA, STMEA)` on page `A8-665` -- v4T + let rn = ((instr >> 8) & 0b111) as u8; + let reglist = instr & 0b1111_1111; + inst.opcode = Opcode::STM(true, true, false, true); // stmia, no wback, yes usermode + inst.operands = [ + Operand::RegWBack(Reg::from_u8(rn), true), // always wback + Operand::RegList(reglist as u16), + Operand::Nothing, + Operand::Nothing, + ]; + } else if opword < 0b11010 { + // `LDM/LDMIA/LDMFD (Thumb)` on page `A8-397` -- v4T + let rn = ((instr >> 8) & 0b111) as u8; + let reglist = instr & 0b1111_1111; + let w = (reglist & (1 << rn)) == 0; + inst.opcode = Opcode::LDM(true, true, false, true); // ldmia, no wback, yes usermode + inst.operands = [ + Operand::RegWBack(Reg::from_u8(rn), w), + Operand::RegList(reglist as u16), + Operand::Nothing, + Operand::Nothing, + ]; + } else if opword < 0b11100 { + // `Conditional branch, and Supervisor Call` on page `A6-227` + let opcode = (instr >> 8) & 0b1111; + if opcode < 0b1110 { + // `B` (`A8-332`) + // v4T + inst.opcode = Opcode::B; + let imm = instr & 0b1111_1111; + let imm = imm as i8 as i32; + let cond = (instr >> 8) & 0b1111; + inst.condition = ConditionCode::build(cond as u8); + inst.operands = [ + Operand::BranchThumbOffset(imm + 1), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else if opcode < 0b1111 { + // `UDF` (`A8-759`) + // v4T + // first described in revision `C.a` + inst.opcode = Opcode::UDF; + inst.operands = [ + Operand::Imm32((instr & 0xff) as u32), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } else { + // `SVC` (`A8-721`) + // v4T + inst.opcode = Opcode::SVC; + inst.operands = [ + Operand::Imm32((instr & 0xff) as u32), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + } else { + // `B` on page `A8-332` -- v4T + inst.opcode = Opcode::B; + let imm = instr & 0b111_1111_1111; + let imm = ((imm as i32) << 21) >> 20; + inst.operands = [ + Operand::Imm32(imm as u32), + Operand::Nothing, + Operand::Nothing, + Operand::Nothing, + ]; + } + } + Ok(()) +} diff --git a/test/armv7.rs b/test/armv7.rs index 865aeb5..09a57e2 100644 --- a/test/armv7.rs +++ b/test/armv7.rs @@ -1,6 +1,8 @@ use yaxpeax_arch::{Arch, Decoder, LengthedInstruction}; use yaxpeax_arm::armv7::{ARMv7, Instruction, ConditionCode, DecodeError, Operand, Opcode, Reg, RegShift}; +mod thumb; + type InstDecoder = <ARMv7 as Arch>::Decoder; fn test_invalid_under(decoder: &InstDecoder, data: [u8; 4]) { @@ -351,9 +353,9 @@ fn test_decode_pop() { [0xf0, 0x40, 0x2d, 0xe9], Instruction { condition: ConditionCode::AL, - opcode: Opcode::STM(false, true, true, false), + opcode: Opcode::STM(false, true, false, false), operands: [ - Operand::Reg(Reg::from_u8(13)), + Operand::RegWBack(Reg::from_u8(13), true), Operand::RegList(16624), Operand::Nothing, Operand::Nothing, @@ -369,9 +371,9 @@ fn test_decode_pop() { [0xf0, 0x80, 0xbd, 0x18], Instruction { condition: ConditionCode::NE, - opcode: Opcode::LDM(true, false, true, false), + opcode: Opcode::LDM(true, false, false, false), operands: [ - Operand::Reg(Reg::from_u8(13)), + Operand::RegWBack(Reg::from_u8(13), true), Operand::RegList(33008), Operand::Nothing, Operand::Nothing, diff --git a/test/armv7/thumb.rs b/test/armv7/thumb.rs new file mode 100644 index 0000000..f61e94d --- /dev/null +++ b/test/armv7/thumb.rs @@ -0,0 +1,3396 @@ +use yaxpeax_arch::{Arch, Decoder, LengthedInstruction}; +use yaxpeax_arm::armv7::{ARMv7, Instruction, ConditionCode, DecodeError, Operand, Opcode, Reg, RegShift}; + +type InstDecoder = <ARMv7 as Arch>::Decoder; + +fn test_invalid_under(decoder: &InstDecoder, data: &[u8]) { + match decoder.decode(data.to_vec()) { + Err(_) => { }, + Ok(inst) => { + panic!( + "unexpected successful decode for {:#x?}\ngot: {}", + data, + inst + ); + } + } +} + +fn test_display_under(decoder: &InstDecoder, data: [u8; 4], expected: &'static str) { + let instr = decoder.decode(data.to_vec()).unwrap_or_else(|_| panic!("failed to decode {:#x?}", data)); + let displayed = format!("{}", instr); + assert!( + displayed == expected, + "decode error for {:#x?}:\n decoded: {:?}\n expected: {:?}\n", + data, + displayed, expected + ); +} + +fn test_decode(data: &[u8], expected: Instruction) { + let instr = InstDecoder::default_thumb().decode(data.to_vec()).unwrap(); + assert!( + instr == expected, + "decode error for {:#x?}:\n decoded: {:?}\n expected: {:?}\n", + data, + instr, expected + ); +} + +fn test_invalid(data: &[u8]) { + test_invalid_under(&InstDecoder::default(), data); +} + +fn test_display(data: &[u8], expected: &'static str) { + let instr = InstDecoder::default_thumb().decode(data.to_vec()).unwrap(); + let text = format!("{}", instr); + assert!( + text == expected, + "display error for {:#x?}\n decoded: {:?}\n displayed: {}\n expected: {}\n", + data, + instr, + text, expected + ); +} + +#[test] +fn test_decode_add_cases() { + test_display( + &[0x01, 0x44], + "add r1, r0" + ); + test_display( + &[0x01, 0xa8], + "add r0, sp, 0x4" + ); + test_display( + &[0x01, 0xa9], + "add r1, sp, 0x4" + ); + test_display( + &[0x01, 0xaa], + "add r2, sp, 0x4" + ); + test_display( + &[0x01, 0xab], + "add r3, sp, 0x4" + ); + test_display( + &[0x01, 0xad], + "add r5, sp, 0x4" + ); + test_display( + &[0x01, 0xae], + "add r6, sp, 0x4" + ); + test_display( + &[0x01, 0xaf], + "add r7, sp, 0x4" + ); + test_display( + &[0x05, 0xac], + "add r4, sp, 0x14" + ); + test_display( + &[0x61, 0xb0], + "add sp, sp, 0x184" + ); + test_display( + &[0x01, 0xb0], + "add sp, sp, 0x4" + ); + test_display( + &[0x02, 0x44], + "add r2, r0" + ); + test_display( + &[0x02, 0xb0], + "add sp, sp, 0x8" + ); + test_display( + &[0x03, 0x44], + "add r3, r0" + ); + test_display( + &[0x17, 0x44], + "add r7, r2" + ); + test_display( + &[0x1b, 0x44], + "add r3, r3" + ); + test_display( + &[0x54, 0x44], + "add r4, r10" + ); + test_display( + &[0x57, 0x44], + "add r7, r10" + ); + test_display( + &[0x5a, 0x44], + "add r2, fp" + ); + test_display( + &[0x61, 0x44], + "add r1, ip" + ); + test_display( + &[0x68, 0x44], + "add r0, sp" + ); + test_display( + &[0x69, 0x44], + "add r1, sp" + ); + test_display( + &[0x6a, 0x44], + "add r2, sp" + ); + test_display( + &[0x6b, 0x44], + "add r3, sp" + ); + test_display( + &[0x6d, 0x44], + "add r5, sp" + ); + test_display( + &[0x6e, 0x44], + "add r6, sp" + ); + test_display( + &[0x6f, 0x44], + "add r7, sp" + ); + test_display( + &[0x75, 0x44], + "add r5, lr" + ); + test_display( + &[0x79, 0x44], + "add r1, pc" + ); + test_display( + &[0xc0, 0x44], + "add r8, r8" + ); + test_display( + &[0xc1, 0x44], + "add sb, r8" + ); + test_display( + &[0xc2, 0x44], + "add r10, r8" + ); + test_display( + &[0xc3, 0x44], + "add fp, r8" + ); + test_display( + &[0xc4, 0x44], + "add ip, r8" + ); + test_display( + &[0xc5, 0x44], + "add sp, r8" + ); + test_display( + &[0xc6, 0x44], + "add lr, r8" + ); + test_display( + &[0xc7, 0x44], + "add pc, r8" + ); + test_display( + &[0xc8, 0x44], + "add r8, sb" + ); + test_display( + &[0xc9, 0x44], + "add sb, sb" + ); + test_display( + &[0xca, 0x44], + "add r10, sb" + ); + test_display( + &[0xcb, 0x44], + "add fp, sb" + ); + test_display( + &[0xcc, 0x44], + "add ip, sb" + ); + test_display( + &[0xcd, 0x44], + "add sp, sb" + ); + test_display( + &[0xce, 0x44], + "add lr, sb" + ); + test_display( + &[0xcf, 0x44], + "add pc, sb" + ); + test_display( + &[0xd0, 0x44], + "add r8, r10" + ); + test_display( + &[0xd1, 0x44], + "add sb, r10" + ); + test_display( + &[0xd2, 0x44], + "add r10, r10" + ); + test_display( + &[0xd3, 0x44], + "add fp, r10" + ); + test_display( + &[0xd4, 0x44], + "add ip, r10" + ); + test_display( + &[0xd5, 0x44], + "add sp, r10" + ); + test_display( + &[0xd6, 0x44], + "add lr, r10" + ); + test_display( + &[0xd7, 0x44], + "add pc, r10" + ); + test_display( + &[0xd8, 0x44], + "add r8, fp" + ); + test_display( + &[0xd9, 0x44], + "add sb, fp" + ); + test_display( + &[0xda, 0x44], + "add r10, fp" + ); + test_display( + &[0xdb, 0x44], + "add fp, fp" + ); + test_display( + &[0xdc, 0x44], + "add ip, fp" + ); + test_display( + &[0xdd, 0x44], + "add sp, fp" + ); + test_display( + &[0xde, 0x44], + "add lr, fp" + ); + test_display( + &[0xdf, 0x44], + "add pc, fp" + ); + test_display( + &[0xe0, 0x44], + "add r8, ip" + ); + test_display( + &[0xe1, 0x44], + "add sb, ip" + ); + test_display( + &[0xe2, 0x44], + "add r10, ip" + ); + test_display( + &[0xe3, 0x44], + "add fp, ip" + ); + test_display( + &[0xe4, 0x44], + "add ip, ip" + ); + test_display( + &[0xe5, 0x44], + "add sp, ip" + ); + test_display( + &[0xe6, 0x44], + "add lr, ip" + ); + test_display( + &[0xe7, 0x44], + "add pc, ip" + ); + test_display( + &[0xe8, 0x44], + "add r8, sp" + ); + test_display( + &[0xe9, 0x44], + "add sb, sp" + ); + test_display( + &[0xea, 0x44], + "add r10, sp" + ); + test_display( + &[0xeb, 0x44], + "add fp, sp" + ); + test_display( + &[0xec, 0x44], + "add ip, sp" + ); + test_display( + &[0xed, 0x44], + "add sp, sp" + ); + test_display( + &[0xee, 0x44], + "add lr, sp" + ); + test_display( + &[0xef, 0x44], + "add pc, sp" + ); + test_display( + &[0xf0, 0x44], + "add r8, lr" + ); + test_display( + &[0xf1, 0x44], + "add sb, lr" + ); + test_display( + &[0xf2, 0x44], + "add r10, lr" + ); + test_display( + &[0xf3, 0x44], + "add fp, lr" + ); + test_display( + &[0xf4, 0x44], + "add ip, lr" + ); + test_display( + &[0xf5, 0x44], + "add sp, lr" + ); + test_display( + &[0xf6, 0x44], + "add lr, lr" + ); + test_display( + &[0xf7, 0x44], + "add pc, lr" + ); + test_display( + &[0xf8, 0x44], + "add r8, pc" + ); + test_display( + &[0xf9, 0x44], + "add sb, pc" + ); + test_display( + &[0xfa, 0x44], + "add r10, pc" + ); + test_display( + &[0xfb, 0x44], + "add fp, pc" + ); + test_display( + &[0xfc, 0x44], + "add ip, pc" + ); + test_display( + &[0xfd, 0x44], + "add sp, pc" + ); + test_display( + &[0xfe, 0x44], + "add lr, pc" + ); + test_display( + &[0xff, 0x44], + "add pc, pc" + ); +} +#[test] +fn test_decode_adr_cases() { + test_display( + &[0x00, 0xa3], + "adr r3, 0x0" + ); + test_display( + &[0x28, 0xa7], + "adr r7, 0xa0" + ); + test_display( + &[0x29, 0xa0], + "adr r0, 0xa4" + ); + test_display( + &[0xff, 0xa6], + "adr r6, 0x3fc" + ); + test_display( + &[0xff, 0xa7], + "adr r7, 0x3fc" + ); +} +#[test] +fn test_decode_bcc_cases() { + test_display( + &[0x80, 0x47], + "blx r0" + ); + test_display( + &[0x88, 0x47], + "blx r1" + ); + test_display( + &[0x90, 0x47], + "blx r2" + ); + test_display( + &[0x98, 0x47], + "blx r3" + ); + test_display( + &[0xa0, 0x47], + "blx r4" + ); + test_display( + &[0xa8, 0x47], + "blx r5" + ); + test_display( + &[0xb0, 0x47], + "blx r6" + ); + test_display( + &[0xb8, 0x47], + "blx r7" + ); + test_display( + &[0xc0, 0x47], + "blx r8" + ); + test_display( + &[0xc8, 0x47], + "blx sb" + ); + test_display( + &[0xd0, 0x47], + "blx r10" + ); + test_display( + &[0xd8, 0x47], + "blx fp" + ); + test_display( + &[0xe0, 0x47], + "blx ip" + ); + test_display( + &[0xe8, 0x47], + "blx sp" + ); + test_display( + &[0xf0, 0x47], + "blx lr" + ); + test_display( + &[0xf8, 0x47], + "blx pc" + ); + test_display( + &[0xfe, 0xd0], + "beq $-0x2" + ); + test_display( + &[0xfe, 0xd1], + "bne $-0x2" + ); + test_display( + &[0xfe, 0xd2], + "bhs $-0x2" + ); + test_display( + &[0xfe, 0xd3], + "blo $-0x2" + ); + test_display( + &[0xfe, 0xd4], + "bmi $-0x2" + ); + test_display( + &[0xfe, 0xd5], + "bpl $-0x2" + ); + test_display( + &[0xfe, 0xd6], + "bvs $-0x2" + ); + test_display( + &[0xfe, 0xd7], + "bvc $-0x2" + ); + test_display( + &[0xfe, 0xd8], + "bhi $-0x2" + ); + test_display( + &[0xfe, 0xd9], + "bls $-0x2" + ); + test_display( + &[0xfe, 0xda], + "bge $-0x2" + ); + test_display( + &[0xfe, 0xdb], + "blt $-0x2" + ); + test_display( + &[0xfe, 0xdc], + "bgt $-0x2" + ); + test_display( + &[0xfe, 0xdd], + "ble $-0x2" + ); + test_display( + &[0xd3, 0xd0], + "beq $-0x58" + ); + test_display( + &[0xd3, 0xd1], + "bne $-0x58" + ); + test_display( + &[0xd3, 0xd2], + "bhs $-0x58" + ); + test_display( + &[0xd3, 0xd3], + "blo $-0x58" + ); + test_display( + &[0xd3, 0xd4], + "bmi $-0x58" + ); + test_display( + &[0xd3, 0xd5], + "bpl $-0x58" + ); + test_display( + &[0xd3, 0xd6], + "bvs $-0x58" + ); + test_display( + &[0xd3, 0xd7], + "bvc $-0x58" + ); + test_display( + &[0xd3, 0xd8], + "bhi $-0x58" + ); + test_display( + &[0xd3, 0xd9], + "bls $-0x58" + ); + test_display( + &[0xd3, 0xda], + "bge $-0x58" + ); + test_display( + &[0xd3, 0xdb], + "blt $-0x58" + ); + test_display( + &[0xd3, 0xdc], + "bgt $-0x58" + ); + test_display( + &[0xd3, 0xdd], + "ble $-0x58" + ); + test_display( + &[0xfd, 0xd0], + "beq $-0x4" + ); + test_display( + &[0xfd, 0xd1], + "bne $-0x4" + ); + test_display( + &[0xfd, 0xd2], + "bhs $-0x4" + ); + test_display( + &[0xfd, 0xd3], + "blo $-0x4" + ); + test_display( + &[0xfd, 0xd4], + "bmi $-0x4" + ); + test_display( + &[0xfd, 0xd5], + "bpl $-0x4" + ); + test_display( + &[0xfd, 0xd6], + "bvs $-0x4" + ); + test_display( + &[0xfd, 0xd7], + "bvc $-0x4" + ); + test_display( + &[0xfd, 0xd8], + "bhi $-0x4" + ); + test_display( + &[0xfd, 0xd9], + "bls $-0x4" + ); + test_display( + &[0xfd, 0xda], + "bge $-0x4" + ); + test_display( + &[0xfd, 0xdb], + "blt $-0x4" + ); + test_display( + &[0xfd, 0xdc], + "bgt $-0x4" + ); + test_display( + &[0xfd, 0xdd], + "ble $-0x4" + ); +} +#[test] +fn test_decode_bkpt_cases() { + test_display( + &[0x00, 0xbe], + "bkpt 0x0" + ); + test_display( + &[0x75, 0xbe], + "bkpt 0x75" + ); + test_display( + &[0xff, 0xbe], + "bkpt 0xff" + ); +} +#[test] +fn test_decode_bx_cases() { + test_display( + &[0x00, 0x47], + "bx r0" + ); + test_display( + &[0x01, 0x47], + "bx r0" + ); + test_display( + &[0x02, 0x47], + "bx r0" + ); + test_display( + &[0x03, 0x47], + "bx r0" + ); + test_display( + &[0x04, 0x47], + "bx r0" + ); + test_display( + &[0x05, 0x47], + "bx r0" + ); + test_display( + &[0x06, 0x47], + "bx r0" + ); + test_display( + &[0x07, 0x47], + "bx r0" + ); + test_display( + &[0x08, 0x47], + "bx r1" + ); + test_display( + &[0x09, 0x47], + "bx r1" + ); + test_display( + &[0x0a, 0x47], + "bx r1" + ); + test_display( + &[0x0b, 0x47], + "bx r1" + ); + test_display( + &[0x0c, 0x47], + "bx r1" + ); + test_display( + &[0x0d, 0x47], + "bx r1" + ); + test_display( + &[0x0e, 0x47], + "bx r1" + ); + test_display( + &[0x0f, 0x47], + "bx r1" + ); + test_display( + &[0x10, 0x47], + "bx r2" + ); + test_display( + &[0x11, 0x47], + "bx r2" + ); + test_display( + &[0x12, 0x47], + "bx r2" + ); + test_display( + &[0x13, 0x47], + "bx r2" + ); + test_display( + &[0x14, 0x47], + "bx r2" + ); + test_display( + &[0x15, 0x47], + "bx r2" + ); + test_display( + &[0x16, 0x47], + "bx r2" + ); + test_display( + &[0x17, 0x47], + "bx r2" + ); + test_display( + &[0x18, 0x47], + "bx r3" + ); + test_display( + &[0x19, 0x47], + "bx r3" + ); + test_display( + &[0x1a, 0x47], + "bx r3" + ); + test_display( + &[0x1b, 0x47], + "bx r3" + ); + test_display( + &[0x1c, 0x47], + "bx r3" + ); + test_display( + &[0x1d, 0x47], + "bx r3" + ); + test_display( + &[0x1e, 0x47], + "bx r3" + ); + test_display( + &[0x1f, 0x47], + "bx r3" + ); + test_display( + &[0x20, 0x47], + "bx r4" + ); + test_display( + &[0x21, 0x47], + "bx r4" + ); + test_display( + &[0x22, 0x47], + "bx r4" + ); + test_display( + &[0x23, 0x47], + "bx r4" + ); + test_display( + &[0x24, 0x47], + "bx r4" + ); + test_display( + &[0x25, 0x47], + "bx r4" + ); + test_display( + &[0x26, 0x47], + "bx r4" + ); + test_display( + &[0x27, 0x47], + "bx r4" + ); + test_display( + &[0x28, 0x47], + "bx r5" + ); + test_display( + &[0x29, 0x47], + "bx r5" + ); + test_display( + &[0x2a, 0x47], + "bx r5" + ); + test_display( + &[0x2b, 0x47], + "bx r5" + ); + test_display( + &[0x2c, 0x47], + "bx r5" + ); + test_display( + &[0x2d, 0x47], + "bx r5" + ); + test_display( + &[0x2e, 0x47], + "bx r5" + ); + test_display( + &[0x2f, 0x47], + "bx r5" + ); + test_display( + &[0x30, 0x47], + "bx r6" + ); + test_display( + &[0x31, 0x47], + "bx r6" + ); + test_display( + &[0x32, 0x47], + "bx r6" + ); + test_display( + &[0x33, 0x47], + "bx r6" + ); + test_display( + &[0x34, 0x47], + "bx r6" + ); + test_display( + &[0x35, 0x47], + "bx r6" + ); + test_display( + &[0x36, 0x47], + "bx r6" + ); + test_display( + &[0x37, 0x47], + "bx r6" + ); + test_display( + &[0x38, 0x47], + "bx r7" + ); + test_display( + &[0x39, 0x47], + "bx r7" + ); + test_display( + &[0x3a, 0x47], + "bx r7" + ); + test_display( + &[0x3b, 0x47], + "bx r7" + ); + test_display( + &[0x3c, 0x47], + "bx r7" + ); + test_display( + &[0x3d, 0x47], + "bx r7" + ); + test_display( + &[0x3e, 0x47], + "bx r7" + ); + test_display( + &[0x3f, 0x47], + "bx r7" + ); + test_display( + &[0x40, 0x47], + "bx r8" + ); + test_display( + &[0x41, 0x47], + "bx r8" + ); + test_display( + &[0x42, 0x47], + "bx r8" + ); + test_display( + &[0x43, 0x47], + "bx r8" + ); + test_display( + &[0x44, 0x47], + "bx r8" + ); + test_display( + &[0x45, 0x47], + "bx r8" + ); + test_display( + &[0x46, 0x47], + "bx r8" + ); + test_display( + &[0x47, 0x47], + "bx r8" + ); + test_display( + &[0x48, 0x47], + "bx sb" + ); + test_display( + &[0x49, 0x47], + "bx sb" + ); + test_display( + &[0x4a, 0x47], + "bx sb" + ); + test_display( + &[0x4b, 0x47], + "bx sb" + ); + test_display( + &[0x4c, 0x47], + "bx sb" + ); + test_display( + &[0x4d, 0x47], + "bx sb" + ); + test_display( + &[0x4e, 0x47], + "bx sb" + ); + test_display( + &[0x4f, 0x47], + "bx sb" + ); + test_display( + &[0x50, 0x47], + "bx r10" + ); + test_display( + &[0x51, 0x47], + "bx r10" + ); + test_display( + &[0x52, 0x47], + "bx r10" + ); + test_display( + &[0x53, 0x47], + "bx r10" + ); + test_display( + &[0x54, 0x47], + "bx r10" + ); + test_display( + &[0x55, 0x47], + "bx r10" + ); + test_display( + &[0x56, 0x47], + "bx r10" + ); + test_display( + &[0x57, 0x47], + "bx r10" + ); + test_display( + &[0x58, 0x47], + "bx fp" + ); + test_display( + &[0x59, 0x47], + "bx fp" + ); + test_display( + &[0x5a, 0x47], + "bx fp" + ); + test_display( + &[0x5b, 0x47], + "bx fp" + ); + test_display( + &[0x5c, 0x47], + "bx fp" + ); + test_display( + &[0x5d, 0x47], + "bx fp" + ); + test_display( + &[0x5e, 0x47], + "bx fp" + ); + test_display( + &[0x5f, 0x47], + "bx fp" + ); + test_display( + &[0x60, 0x47], + "bx ip" + ); + test_display( + &[0x61, 0x47], + "bx ip" + ); + test_display( + &[0x62, 0x47], + "bx ip" + ); + test_display( + &[0x63, 0x47], + "bx ip" + ); + test_display( + &[0x64, 0x47], + "bx ip" + ); + test_display( + &[0x65, 0x47], + "bx ip" + ); + test_display( + &[0x66, 0x47], + "bx ip" + ); + test_display( + &[0x67, 0x47], + "bx ip" + ); + test_display( + &[0x68, 0x47], + "bx sp" + ); + test_display( + &[0x69, 0x47], + "bx sp" + ); + test_display( + &[0x6a, 0x47], + "bx sp" + ); + test_display( + &[0x6b, 0x47], + "bx sp" + ); + test_display( + &[0x6c, 0x47], + "bx sp" + ); + test_display( + &[0x6d, 0x47], + "bx sp" + ); + test_display( + &[0x6e, 0x47], + "bx sp" + ); + test_display( + &[0x6f, 0x47], + "bx sp" + ); + test_display( + &[0x70, 0x47], + "bx lr" + ); + test_display( + &[0x71, 0x47], + "bx lr" + ); + test_display( + &[0x72, 0x47], + "bx lr" + ); + test_display( + &[0x73, 0x47], + "bx lr" + ); + test_display( + &[0x74, 0x47], + "bx lr" + ); + test_display( + &[0x75, 0x47], + "bx lr" + ); + test_display( + &[0x76, 0x47], + "bx lr" + ); + test_display( + &[0x77, 0x47], + "bx lr" + ); + test_display( + &[0x78, 0x47], + "bx pc" + ); + test_display( + &[0x79, 0x47], + "bx pc" + ); + test_display( + &[0x7a, 0x47], + "bx pc" + ); + test_display( + &[0x7b, 0x47], + "bx pc" + ); + test_display( + &[0x7c, 0x47], + "bx pc" + ); + test_display( + &[0x7d, 0x47], + "bx pc" + ); + test_display( + &[0x7e, 0x47], + "bx pc" + ); + test_display( + &[0x7f, 0x47], + "bx pc" + ); +} +#[test] +fn test_decode_cbz_cbnz_cases() { + test_display( + &[0x01, 0xb1], + "cbz r1, $+0x2" // original test: 0x4. assume address is 0, so $ is 2, +2 makes 4? + ); + test_display( + &[0x01, 0xb3], + "cbz r1, $+0x42" // original test: 0x4. assume address is 0, so $ is 2, +2 makes 4? + ); + test_display( + &[0x01, 0xb9], + "cbnz r1, $+0x2" // original test: 0x4. assume address is 0, so $ is 2, +2 makes 4? + ); + test_display( + &[0x01, 0xbb], + "cbnz r1, $+0x42" // original test: 0x4. assume address is 0, so $ is 2, +2 makes 4? + ); + test_display( + &[0x07, 0xb1], + "cbz r7, $+0x2" // original test: 0x4. assume address is 0, so $ is 2, +2 makes 4? + ); + test_display( + &[0x07, 0xb3], + "cbz r7, $+0x42" + ); + test_display( + &[0x07, 0xb9], + "cbnz r7, $+0x2" + ); + test_display( + &[0x07, 0xbb], + "cbnz r7, $+0x42" + ); + test_display( + &[0xff, 0xb1], + "cbz r7, $+0x40" + ); + test_display( + &[0xff, 0xb3], + "cbz r7, $+0x80" + ); + test_display( + &[0xff, 0xb9], + "cbnz r7, $+0x40" + ); + test_display( + &[0xff, 0xbb], + "cbnz r7, $+0x80" + ); +} +#[test] +fn test_decode_cmn_test_cases() { + test_display( + &[0x33, 0x42], + "tst r3, r6" + ); + test_display( + &[0xf3, 0x42], + "cmn r3, r6" + ); +} +#[test] +fn test_decode_cmp_cases() { + test_display( + &[0x00, 0x45], + "cmp r0, r0" + ); + test_display( + &[0x01, 0x45], + "cmp r1, r0" + ); + test_display( + &[0x02, 0x28], + "cmp r0, 0x2" + ); + test_display( + &[0x02, 0x29], + "cmp r1, 0x2" + ); + test_display( + &[0x02, 0x2a], + "cmp r2, 0x2" + ); + test_display( + &[0x02, 0x2b], + "cmp r3, 0x2" + ); + test_display( + &[0x02, 0x2c], + "cmp r4, 0x2" + ); + test_display( + &[0x02, 0x2d], + "cmp r5, 0x2" + ); + test_display( + &[0x02, 0x2e], + "cmp r6, 0x2" + ); + test_display( + &[0x02, 0x2f], + "cmp r7, 0x2" + ); + test_display( + &[0xff, 0x28], + "cmp r0, 0xff" + ); + test_display( + &[0xff, 0x29], + "cmp r1, 0xff" + ); + test_display( + &[0xff, 0x2a], + "cmp r2, 0xff" + ); + test_display( + &[0xff, 0x2b], + "cmp r3, 0xff" + ); + test_display( + &[0xff, 0x2c], + "cmp r4, 0xff" + ); + test_display( + &[0xff, 0x2d], + "cmp r5, 0xff" + ); + test_display( + &[0xff, 0x2e], + "cmp r6, 0xff" + ); + test_display( + &[0xff, 0x2f], + "cmp r7, 0xff" + ); + test_display( + &[0x53, 0x45], + "cmp r3, r10" + ); + test_display( + &[0x6c, 0x45], + "cmp r4, sp" + ); + test_display( + &[0x7e, 0x45], + "cmp r6, pc" + ); + test_display( + &[0xfe, 0x45], + "cmp lr, pc" + ); + test_display( + &[0xff, 0x45], + "cmp pc, pc" + ); +} +#[test] +fn test_decode_it_cases() { + test_display( + &[0x01, 0xbf], + "itttt eq" + ); + test_display( + &[0x03, 0xbf], + "ittte eq" + ); + test_display( + &[0x05, 0xbf], + "ittet eq" + ); + test_display( + &[0x07, 0xbf], + "ittee eq" + ); + test_display( + &[0x09, 0xbf], + "itett eq" + ); + test_display( + &[0x0b, 0xbf], + "itete eq" + ); + test_display( + &[0x0d, 0xbf], + "iteet eq" + ); + test_display( + &[0x0f, 0xbf], + "iteee eq" + ); + test_display( + &[0x11, 0xbf], + "iteee ne" + ); + test_display( + &[0x13, 0xbf], + "iteet ne" + ); + test_display( + &[0x15, 0xbf], + "itete ne" + ); + test_display( + &[0x17, 0xbf], + "itett ne" + ); + test_display( + &[0x19, 0xbf], + "ittee ne" + ); + test_display( + &[0x1b, 0xbf], + "ittet ne" + ); + test_display( + &[0x1d, 0xbf], + "ittte ne" + ); + test_display( + &[0x1f, 0xbf], + "itttt ne" + ); + test_display( + &[0x21, 0xbf], + "itttt hs" + ); + test_display( + &[0x23, 0xbf], + "ittte hs" + ); + test_display( + &[0x25, 0xbf], + "ittet hs" + ); + test_display( + &[0x27, 0xbf], + "ittee hs" + ); + test_display( + &[0x29, 0xbf], + "itett hs" + ); + test_display( + &[0x2b, 0xbf], + "itete hs" + ); + test_display( + &[0x2d, 0xbf], + "iteet hs" + ); + test_display( + &[0x2f, 0xbf], + "iteee hs" + ); + test_display( + &[0x31, 0xbf], + "iteee lo" + ); + test_display( + &[0x33, 0xbf], + "iteet lo" + ); + test_display( + &[0x35, 0xbf], + "itete lo" + ); + test_display( + &[0x37, 0xbf], + "itett lo" + ); + test_display( + &[0x39, 0xbf], + "ittee lo" + ); + test_display( + &[0x3b, 0xbf], + "ittet lo" + ); + test_display( + &[0x3d, 0xbf], + "ittte lo" + ); + test_display( + &[0x3f, 0xbf], + "itttt lo" + ); + test_display( + &[0x41, 0xbf], + "itttt mi" + ); + test_display( + &[0x43, 0xbf], + "ittte mi" + ); + test_display( + &[0x45, 0xbf], + "ittet mi" + ); + test_display( + &[0x47, 0xbf], + "ittee mi" + ); + test_display( + &[0x49, 0xbf], + "itett mi" + ); + test_display( + &[0x4b, 0xbf], + "itete mi" + ); + test_display( + &[0x4d, 0xbf], + "iteet mi" + ); + test_display( + &[0x4f, 0xbf], + "iteee mi" + ); + test_display( + &[0x51, 0xbf], + "iteee pl" + ); + test_display( + &[0x53, 0xbf], + "iteet pl" + ); + test_display( + &[0x55, 0xbf], + "itete pl" + ); + test_display( + &[0x57, 0xbf], + "itett pl" + ); + test_display( + &[0x59, 0xbf], + "ittee pl" + ); + test_display( + &[0x5b, 0xbf], + "ittet pl" + ); + test_display( + &[0x5d, 0xbf], + "ittte pl" + ); + test_display( + &[0x5f, 0xbf], + "itttt pl" + ); + test_display( + &[0x61, 0xbf], + "itttt vs" + ); + test_display( + &[0x63, 0xbf], + "ittte vs" + ); + test_display( + &[0x65, 0xbf], + "ittet vs" + ); + test_display( + &[0x67, 0xbf], + "ittee vs" + ); + test_display( + &[0x69, 0xbf], + "itett vs" + ); + test_display( + &[0x6b, 0xbf], + "itete vs" + ); + test_display( + &[0x6d, 0xbf], + "iteet vs" + ); + test_display( + &[0x6f, 0xbf], + "iteee vs" + ); + test_display( + &[0x71, 0xbf], + "iteee vc" + ); + test_display( + &[0x73, 0xbf], + "iteet vc" + ); + test_display( + &[0x75, 0xbf], + "itete vc" + ); + test_display( + &[0x77, 0xbf], + "itett vc" + ); + test_display( + &[0x79, 0xbf], + "ittee vc" + ); + test_display( + &[0x7b, 0xbf], + "ittet vc" + ); + test_display( + &[0x7d, 0xbf], + "ittte vc" + ); + test_display( + &[0x7f, 0xbf], + "itttt vc" + ); + test_display( + &[0x81, 0xbf], + "itttt hi" + ); + test_display( + &[0x83, 0xbf], + "ittte hi" + ); + test_display( + &[0x85, 0xbf], + "ittet hi" + ); + test_display( + &[0x87, 0xbf], + "ittee hi" + ); + test_display( + &[0x89, 0xbf], + "itett hi" + ); + test_display( + &[0x8b, 0xbf], + "itete hi" + ); + test_display( + &[0x8d, 0xbf], + "iteet hi" + ); + test_display( + &[0x8f, 0xbf], + "iteee hi" + ); + test_display( + &[0x91, 0xbf], + "iteee ls" + ); + test_display( + &[0x93, 0xbf], + "iteet ls" + ); + test_display( + &[0x95, 0xbf], + "itete ls" + ); + test_display( + &[0x97, 0xbf], + "itett ls" + ); + test_display( + &[0x99, 0xbf], + "ittee ls" + ); + test_display( + &[0x9b, 0xbf], + "ittet ls" + ); + test_display( + &[0x9d, 0xbf], + "ittte ls" + ); + test_display( + &[0x9f, 0xbf], + "itttt ls" + ); + test_display( + &[0xa1, 0xbf], + "itttt ge" + ); + test_display( + &[0xa3, 0xbf], + "ittte ge" + ); + test_display( + &[0xa5, 0xbf], + "ittet ge" + ); + test_display( + &[0xa7, 0xbf], + "ittee ge" + ); + test_display( + &[0xa9, 0xbf], + "itett ge" + ); + test_display( + &[0xab, 0xbf], + "itete ge" + ); + test_display( + &[0xad, 0xbf], + "iteet ge" + ); + test_display( + &[0xaf, 0xbf], + "iteee ge" + ); + test_display( + &[0xb1, 0xbf], + "iteee lt" + ); + test_display( + &[0xb3, 0xbf], + "iteet lt" + ); + test_display( + &[0xb5, 0xbf], + "itete lt" + ); + test_display( + &[0xb7, 0xbf], + "itett lt" + ); + test_display( + &[0xb9, 0xbf], + "ittee lt" + ); + test_display( + &[0xbb, 0xbf], + "ittet lt" + ); + test_display( + &[0xbd, 0xbf], + "ittte lt" + ); + test_display( + &[0xbf, 0xbf], + "itttt lt" + ); + test_display( + &[0xc1, 0xbf], + "itttt gt" + ); + test_display( + &[0xc3, 0xbf], + "ittte gt" + ); + test_display( + &[0xc5, 0xbf], + "ittet gt" + ); + test_display( + &[0xc7, 0xbf], + "ittee gt" + ); + test_display( + &[0xc9, 0xbf], + "itett gt" + ); + test_display( + &[0xcb, 0xbf], + "itete gt" + ); + test_display( + &[0xcd, 0xbf], + "iteet gt" + ); + test_display( + &[0xcf, 0xbf], + "iteee gt" + ); + test_display( + &[0xd1, 0xbf], + "iteee le" + ); + test_display( + &[0xd3, 0xbf], + "iteet le" + ); + test_display( + &[0xd5, 0xbf], + "itete le" + ); + test_display( + &[0xd7, 0xbf], + "itett le" + ); + test_display( + &[0xd9, 0xbf], + "ittee le" + ); + test_display( + &[0xdb, 0xbf], + "ittet le" + ); + test_display( + &[0xdd, 0xbf], + "ittte le" + ); + test_display( + &[0xdf, 0xbf], + "itttt le" + ); + test_display( + &[0xe1, 0xbf], + "itttt al" + ); + test_display( + &[0xe3, 0xbf], + "ittte al" + ); + test_display( + &[0xe5, 0xbf], + "ittet al" + ); + test_display( + &[0xe7, 0xbf], + "ittee al" + ); + test_display( + &[0xe9, 0xbf], + "itett al" + ); + test_display( + &[0xeb, 0xbf], + "itete al" + ); + test_display( + &[0xed, 0xbf], + "iteet al" + ); + test_display( + &[0xef, 0xbf], + "iteee al" + ); +} +#[test] +fn test_decode_ldm_16b_cases() { + test_display( + &[0x80, 0xc8], + "ldm r0!, {r7}" + ); + test_display( + &[0x80, 0xc9], + "ldm r1!, {r7}" + ); + test_display( + &[0x80, 0xca], + "ldm r2!, {r7}" + ); + test_display( + &[0x80, 0xcb], + "ldm r3!, {r7}" + ); + test_display( + &[0x80, 0xcc], + "ldm r4!, {r7}" + ); + test_display( + &[0x80, 0xcd], + "ldm r5!, {r7}" + ); + test_display( + &[0x80, 0xce], + "ldm r6!, {r7}" + ); + test_display( + &[0x80, 0xcf], + "ldm r7, {r7}" + ); + test_display( + &[0xb0, 0xce], + "ldm r6!, {r4, r5, r7}" + ); + test_display( + &[0xb0, 0xcf], + "ldm r7, {r4, r5, r7}" + ); + test_display( + &[0xc0, 0xcb], + "ldm r3!, {r6, r7}" + ); + test_display( + &[0xfe, 0xc8], + "ldm r0!, {r1, r2, r3, r4, r5, r6, r7}" + ); + test_display( + &[0xed, 0xcc], + "ldm r4!, {r0, r2, r3, r5, r6, r7}" + ); + test_display( + &[0xef, 0xcc], + "ldm r4!, {r0, r1, r2, r3, r5, r6, r7}" + ); + test_display( + &[0xfe, 0xce], + "ldm r6, {r1, r2, r3, r4, r5, r6, r7}" + ); + test_display( + &[0xff, 0xcd], + "ldm r5, {r0, r1, r2, r3, r4, r5, r6, r7}" + ); +} +#[test] +fn test_decode_ldr_16b_cases() { + test_display( + &[0x00, 0x48], + "ldr r0, [pc]" + ); + test_display( + &[0x00, 0x49], + "ldr r1, [pc]" + ); + test_display( + &[0x00, 0x4a], + "ldr r2, [pc]" + ); + test_display( + &[0x00, 0x4b], + "ldr r3, [pc]" + ); + test_display( + &[0x00, 0x4c], + "ldr r4, [pc]" + ); + test_display( + &[0x00, 0x4d], + "ldr r5, [pc]" + ); + test_display( + &[0x00, 0x4e], + "ldr r6, [pc]" + ); + test_display( + &[0x00, 0x4f], + "ldr r7, [pc]" + ); + test_display( + &[0x00, 0x56], + "ldrsb r0, [r0, r0]" + ); + test_display( + &[0x00, 0x57], + "ldrsb r0, [r0, r4]" + ); + test_display( + &[0x00, 0x58], + "ldr r0, [r0, r0]" + ); + test_display( + &[0x00, 0x59], + "ldr r0, [r0, r4]" + ); + test_display( + &[0x00, 0x5a], + "ldrh r0, [r0, r0]" + ); + test_display( + &[0x00, 0x5b], + "ldrh r0, [r0, r4]" + ); + test_display( + &[0x00, 0x5c], + "ldrb r0, [r0, r0]" + ); + test_display( + &[0x00, 0x5d], + "ldrb r0, [r0, r4]" + ); + test_display( + &[0x00, 0x5e], + "ldrsh r0, [r0, r0]" + ); + test_display( + &[0x00, 0x5f], + "ldrsh r0, [r0, r4]" + ); + test_display( + &[0x00, 0x68], + "ldr r0, [r0]" + ); + test_display( + &[0x00, 0x69], + "ldr r0, [r0, 0x10]" + ); + test_display( + &[0x00, 0x6a], + "ldr r0, [r0, 0x20]" + ); + test_display( + &[0x00, 0x6b], + "ldr r0, [r0, 0x30]" + ); + test_display( + &[0x00, 0x6c], + "ldr r0, [r0, 0x40]" + ); + test_display( + &[0x00, 0x6d], + "ldr r0, [r0, 0x50]" + ); + test_display( + &[0x00, 0x6e], + "ldr r0, [r0, 0x60]" + ); + test_display( + &[0x00, 0x6f], + "ldr r0, [r0, 0x70]" + ); + test_display( + &[0x00, 0x78], + "ldrb r0, [r0]" + ); + test_display( + &[0x00, 0x79], + "ldrb r0, [r0, 0x4]" + ); + test_display( + &[0x00, 0x7a], + "ldrb r0, [r0, 0x8]" + ); + test_display( + &[0x00, 0x7b], + "ldrb r0, [r0, 0xc]" + ); + test_display( + &[0x00, 0x7c], + "ldrb r0, [r0, 0x10]" + ); + test_display( + &[0x00, 0x7d], + "ldrb r0, [r0, 0x14]" + ); + test_display( + &[0x00, 0x7e], + "ldrb r0, [r0, 0x18]" + ); + test_display( + &[0x00, 0x7f], + "ldrb r0, [r0, 0x1c]" + ); + test_display( + &[0x00, 0x88], + "ldrh r0, [r0]" + ); + test_display( + &[0x00, 0x89], + "ldrh r0, [r0, 0x8]" + ); + test_display( + &[0x00, 0x8a], + "ldrh r0, [r0, 0x10]" + ); + test_display( + &[0x00, 0x8b], + "ldrh r0, [r0, 0x18]" + ); + test_display( + &[0x00, 0x8c], + "ldrh r0, [r0, 0x20]" + ); + test_display( + &[0x00, 0x8d], + "ldrh r0, [r0, 0x28]" + ); + test_display( + &[0x00, 0x8e], + "ldrh r0, [r0, 0x30]" + ); + test_display( + &[0x00, 0x8f], + "ldrh r0, [r0, 0x38]" + ); + test_display( + &[0x00, 0x98], + "ldr r0, [sp]" + ); + test_display( + &[0x00, 0x99], + "ldr r1, [sp]" + ); + test_display( + &[0x00, 0x9a], + "ldr r2, [sp]" + ); + test_display( + &[0x00, 0x9b], + "ldr r3, [sp]" + ); + test_display( + &[0x00, 0x9c], + "ldr r4, [sp]" + ); + test_display( + &[0x00, 0x9d], + "ldr r5, [sp]" + ); + test_display( + &[0x00, 0x9e], + "ldr r6, [sp]" + ); + test_display( + &[0x00, 0x9f], + "ldr r7, [sp]" + ); + test_display( + &[0x01, 0x48], + "ldr r0, [pc, 0x4]" + ); + test_display( + &[0x01, 0x49], + "ldr r1, [pc, 0x4]" + ); + test_display( + &[0x01, 0x4a], + "ldr r2, [pc, 0x4]" + ); + test_display( + &[0x01, 0x4b], + "ldr r3, [pc, 0x4]" + ); + test_display( + &[0x01, 0x4c], + "ldr r4, [pc, 0x4]" + ); + test_display( + &[0x01, 0x4d], + "ldr r5, [pc, 0x4]" + ); + test_display( + &[0x01, 0x4e], + "ldr r6, [pc, 0x4]" + ); + test_display( + &[0x01, 0x4f], + "ldr r7, [pc, 0x4]" + ); + test_display( + &[0xff, 0x48], + "ldr r0, [pc, 0x3fc]" + ); + test_display( + &[0xff, 0x49], + "ldr r1, [pc, 0x3fc]" + ); + test_display( + &[0xff, 0x4a], + "ldr r2, [pc, 0x3fc]" + ); + test_display( + &[0xff, 0x4b], + "ldr r3, [pc, 0x3fc]" + ); + test_display( + &[0xff, 0x4c], + "ldr r4, [pc, 0x3fc]" + ); + test_display( + &[0xff, 0x4d], + "ldr r5, [pc, 0x3fc]" + ); + test_display( + &[0xff, 0x4e], + "ldr r6, [pc, 0x3fc]" + ); + test_display( + &[0xff, 0x4f], + "ldr r7, [pc, 0x3fc]" + ); + test_display( + &[0xff, 0x56], + "ldrsb r7, [r7, r3]" + ); + test_display( + &[0xff, 0x58], + "ldr r7, [r7, r3]" + ); + test_display( + &[0xff, 0x5a], + "ldrh r7, [r7, r3]" + ); + test_display( + &[0xff, 0x5c], + "ldrb r7, [r7, r3]" + ); + test_display( + &[0xff, 0x5e], + "ldrsh r7, [r7, r3]" + ); + test_display( + &[0xff, 0x68], + "ldr r7, [r7, 0xc]" + ); + test_display( + &[0xff, 0x69], + "ldr r7, [r7, 0x1c]" + ); + test_display( + &[0xff, 0x6a], + "ldr r7, [r7, 0x2c]" + ); + test_display( + &[0xff, 0x6b], + "ldr r7, [r7, 0x3c]" + ); + test_display( + &[0xff, 0x6c], + "ldr r7, [r7, 0x4c]" + ); + test_display( + &[0xff, 0x6d], + "ldr r7, [r7, 0x5c]" + ); + test_display( + &[0xff, 0x6e], + "ldr r7, [r7, 0x6c]" + ); + test_display( + &[0xff, 0x6f], + "ldr r7, [r7, 0x7c]" + ); + test_display( + &[0xff, 0x78], + "ldrb r7, [r7, 0x3]" + ); + test_display( + &[0xff, 0x79], + "ldrb r7, [r7, 0x7]" + ); + test_display( + &[0xff, 0x7a], + "ldrb r7, [r7, 0xb]" + ); + test_display( + &[0xff, 0x7b], + "ldrb r7, [r7, 0xf]" + ); + test_display( + &[0xff, 0x7c], + "ldrb r7, [r7, 0x13]" + ); + test_display( + &[0xff, 0x7d], + "ldrb r7, [r7, 0x17]" + ); + test_display( + &[0xff, 0x7e], + "ldrb r7, [r7, 0x1b]" + ); + test_display( + &[0xff, 0x7f], + "ldrb r7, [r7, 0x1f]" + ); + test_display( + &[0xff, 0x88], + "ldrh r7, [r7, 0x6]" + ); + test_display( + &[0xff, 0x89], + "ldrh r7, [r7, 0xe]" + ); + test_display( + &[0xff, 0x8a], + "ldrh r7, [r7, 0x16]" + ); + test_display( + &[0xff, 0x8b], + "ldrh r7, [r7, 0x1e]" + ); + test_display( + &[0xff, 0x8c], + "ldrh r7, [r7, 0x26]" + ); + test_display( + &[0xff, 0x8d], + "ldrh r7, [r7, 0x2e]" + ); + test_display( + &[0xff, 0x8e], + "ldrh r7, [r7, 0x36]" + ); + test_display( + &[0xff, 0x8f], + "ldrh r7, [r7, 0x3e]" + ); + test_display( + &[0xff, 0x98], + "ldr r0, [sp, 0x3fc]" + ); + test_display( + &[0xff, 0x99], + "ldr r1, [sp, 0x3fc]" + ); + test_display( + &[0xff, 0x9a], + "ldr r2, [sp, 0x3fc]" + ); + test_display( + &[0xff, 0x9b], + "ldr r3, [sp, 0x3fc]" + ); + test_display( + &[0xff, 0x9c], + "ldr r4, [sp, 0x3fc]" + ); + test_display( + &[0xff, 0x9d], + "ldr r5, [sp, 0x3fc]" + ); + test_display( + &[0xff, 0x9e], + "ldr r6, [sp, 0x3fc]" + ); + test_display( + &[0xff, 0x9f], + "ldr r7, [sp, 0x3fc]" + ); +} +#[test] +fn test_decode_misc_cases() { + test_display( + &[0x00, 0xbf], + "nop" + ); + test_display( + &[0x10, 0xbf], + "yield" + ); + test_display( + &[0x20, 0xbf], + "wfe" + ); + test_display( + &[0x30, 0xbf], + "wfi" + ); + test_display( + &[0x40, 0xbf], + "sev" + ); + test_display( + &[0x50, 0xb6], + "setend le" + ); + test_display( + &[0x50, 0xbf], + "hint 0x5" + ); + test_display( + &[0x58, 0xb6], + "setend be" + ); + test_display( + &[0x60, 0xbf], + "hint 0x6" + ); + test_display( + &[0x61, 0xb6], + "cpsie f" + ); + test_display( + &[0x62, 0xb6], + "cpsie i" + ); + test_display( + &[0x63, 0xb6], + "cpsie if" + ); + test_display( + &[0x64, 0xb6], + "cpsie a" + ); + test_display( + &[0x65, 0xb6], + "cpsie af" + ); + test_display( + &[0x66, 0xb6], + "cpsie ai" + ); + test_display( + &[0x67, 0xb6], + "cpsie aif" + ); + test_display( + &[0x70, 0xbf], + "hint 0x7" + ); + test_display( + &[0x71, 0xb6], + "cpsid f" + ); + test_display( + &[0x72, 0xb6], + "cpsid i" + ); + test_display( + &[0x73, 0xb6], + "cpsid if" + ); + test_display( + &[0x74, 0xb6], + "cpsid a" + ); + test_display( + &[0x75, 0xb6], + "cpsid af" + ); + test_display( + &[0x76, 0xb6], + "cpsid ai" + ); + test_display( + &[0x77, 0xb6], + "cpsid aif" + ); + test_display( + &[0x80, 0xbf], + "hint 0x8" + ); + test_display( + &[0x90, 0xbf], + "hint 0x9" + ); + test_display( + &[0xa0, 0xbf], + "hint 0xa" + ); + test_display( + &[0xb0, 0xbf], + "hint 0xb" + ); + test_display( + &[0xc0, 0xbf], + "hint 0xc" + ); + test_display( + &[0xd0, 0xbf], + "hint 0xd" + ); + test_display( + &[0xe0, 0xbf], + "hint 0xe" + ); + test_display( + &[0xf0, 0xbf], + "hint 0xf" + ); + test_display( + &[0xfe, 0xde], + "udf 0xfe" + ); +} +#[test] +fn test_decode_mov_cases() { + test_display( + &[0x21, 0x46], + "mov r1, r4" + ); + test_display( + &[0x90, 0x46], + "mov r8, r2" + ); + test_display( + &[0x91, 0x46], + "mov sb, r2" + ); + test_display( + &[0x92, 0x46], + "mov r10, r2" + ); + test_display( + &[0x93, 0x46], + "mov fp, r2" + ); + test_display( + &[0x94, 0x46], + "mov ip, r2" + ); + test_display( + &[0x95, 0x46], + "mov sp, r2" + ); + test_display( + &[0x96, 0x46], + "mov lr, r2" + ); + test_display( + &[0x97, 0x46], + "mov pc, r2" + ); + test_display( + &[0xc0, 0x46], + "mov r8, r8" + ); + test_display( + &[0xc1, 0x46], + "mov sb, r8" + ); + test_display( + &[0xc2, 0x46], + "mov r10, r8" + ); + test_display( + &[0xc3, 0x46], + "mov fp, r8" + ); + test_display( + &[0xc4, 0x46], + "mov ip, r8" + ); + test_display( + &[0xc5, 0x46], + "mov sp, r8" + ); + test_display( + &[0xc6, 0x46], + "mov lr, r8" + ); + test_display( + &[0xc7, 0x46], + "mov pc, r8" + ); + test_display( + &[0xc8, 0x46], + "mov r8, sb" + ); + test_display( + &[0xc9, 0x46], + "mov sb, sb" + ); + test_display( + &[0xca, 0x46], + "mov r10, sb" + ); + test_display( + &[0xcb, 0x46], + "mov fp, sb" + ); + test_display( + &[0xcc, 0x46], + "mov ip, sb" + ); + test_display( + &[0xcd, 0x46], + "mov sp, sb" + ); + test_display( + &[0xce, 0x46], + "mov lr, sb" + ); + test_display( + &[0xcf, 0x46], + "mov pc, sb" + ); + test_display( + &[0xfc, 0x46], + "mov ip, pc" + ); + test_display( + &[0xfd, 0x46], + "mov sp, pc" + ); + test_display( + &[0xfe, 0x46], + "mov lr, pc" + ); + test_display( + &[0xff, 0x46], + "mov pc, pc" + ); +} +#[test] +fn test_decode_op_s_cases() { + test_display( + &[0x00, 0x18], + "adds r0, r0, r0" + ); + test_display( + &[0x00, 0x19], + "adds r0, r0, r4" + ); + test_display( + &[0x00, 0x1c], + "adds r0, r0, 0x0" + ); + test_display( + &[0x00, 0x1d], + "adds r0, r0, 0x4" + ); + test_display( + &[0x00, 0x30], + "adds r0, 0x0" + ); + test_display( + &[0x00, 0x31], + "adds r1, 0x0" + ); + test_display( + &[0x00, 0x32], + "adds r2, 0x0" + ); + test_display( + &[0x00, 0x33], + "adds r3, 0x0" + ); + test_display( + &[0x00, 0x34], + "adds r4, 0x0" + ); + test_display( + &[0x00, 0x35], + "adds r5, 0x0" + ); + test_display( + &[0x00, 0x36], + "adds r6, 0x0" + ); + test_display( + &[0x00, 0x37], + "adds r7, 0x0" + ); + test_display( + &[0x00, 0x40], + "ands r0, r0" + ); + test_display( + &[0x00, 0x43], + "orrs r0, r0" + ); + test_display( + &[0x01, 0x08], + "lsrs r1, r0, 0x20" + ); + test_display( + &[0x01, 0x09], + "lsrs r1, r0, 0x4" + ); + test_display( + &[0x01, 0x0a], + "lsrs r1, r0, 0x8" + ); + test_display( + &[0x01, 0x0b], + "lsrs r1, r0, 0xc" + ); + test_display( + &[0x01, 0x0c], + "lsrs r1, r0, 0x10" + ); + test_display( + &[0x01, 0x0d], + "lsrs r1, r0, 0x14" + ); + test_display( + &[0x01, 0x0e], + "lsrs r1, r0, 0x18" + ); + test_display( + &[0x01, 0x0f], + "lsrs r1, r0, 0x1c" + ); + test_display( + &[0x01, 0x10], + "asrs r1, r0, 0x20" + ); + test_display( + &[0x01, 0x11], + "asrs r1, r0, 0x4" + ); + test_display( + &[0x01, 0x12], + "asrs r1, r0, 0x8" + ); + test_display( + &[0x01, 0x13], + "asrs r1, r0, 0xc" + ); + test_display( + &[0x01, 0x14], + "asrs r1, r0, 0x10" + ); + test_display( + &[0x01, 0x15], + "asrs r1, r0, 0x14" + ); + test_display( + &[0x01, 0x16], + "asrs r1, r0, 0x18" + ); + test_display( + &[0x01, 0x17], + "asrs r1, r0, 0x1c" + ); + test_display( + &[0x01, 0x18], + "adds r1, r0, r0" + ); + test_display( + &[0x01, 0x19], + "adds r1, r0, r4" + ); + test_display( + &[0x01, 0x1c], + "adds r1, r0, 0x0" + ); + test_display( + &[0x01, 0x1d], + "adds r1, r0, 0x4" + ); + test_display( + &[0x01, 0x30], + "adds r0, 0x1" + ); + test_display( + &[0x01, 0x31], + "adds r1, 0x1" + ); + test_display( + &[0x01, 0x32], + "adds r2, 0x1" + ); + test_display( + &[0x01, 0x33], + "adds r3, 0x1" + ); + test_display( + &[0x01, 0x34], + "adds r4, 0x1" + ); + test_display( + &[0x01, 0x35], + "adds r5, 0x1" + ); + test_display( + &[0x01, 0x36], + "adds r6, 0x1" + ); + test_display( + &[0x01, 0x37], + "adds r7, 0x1" + ); + test_display( + &[0x0a, 0x01], + "lsls r2, r1, 0x4" + ); + test_display( + &[0x0a, 0x02], + "lsls r2, r1, 0x8" + ); + test_display( + &[0x0a, 0x03], + "lsls r2, r1, 0xc" + ); + test_display( + &[0x0a, 0x04], + "lsls r2, r1, 0x10" + ); + test_display( + &[0x0a, 0x05], + "lsls r2, r1, 0x14" + ); + test_display( + &[0x0a, 0x06], + "lsls r2, r1, 0x18" + ); + test_display( + &[0x0a, 0x07], + "lsls r2, r1, 0x1c" + ); + test_display( + &[0x13, 0x1a], + "subs r3, r2, r0" + ); + test_display( + &[0x13, 0x1b], + "subs r3, r2, r4" + ); + test_display( + &[0x13, 0x1e], + "subs r3, r2, 0x0" + ); + test_display( + &[0x13, 0x1f], + "subs r3, r2, 0x4" + ); + test_display( + &[0x3d, 0x40], + "ands r5, r7" + ); + test_display( + &[0x3d, 0x43], + "orrs r5, r7" + ); + test_display( + &[0x7d, 0x40], + "eors r5, r7" + ); + test_display( + &[0x7d, 0x41], + "adcs r5, r7" + ); + test_display( + &[0x7d, 0x42], + "rsbs r5, r7, 0x0" + ); + test_display( + &[0x7d, 0x43], + "muls r5, r7, r5" + ); + test_display( + &[0xbd, 0x41], + "sbcs r5, r7" + ); + test_display( + &[0xbd, 0x43], + "bics r5, r7" + ); + test_display( + &[0xd6, 0x41], + "rors r6, r2" + ); + test_display( + &[0xd6, 0x43], + "mvns r6, r2" + ); + test_display( + &[0xfd, 0x20], + "movs r0, 0xfd" + ); + test_display( + &[0xfd, 0x20], + "movs r0, 0xfd" + ); + test_display( + &[0xfd, 0x21], + "movs r1, 0xfd" + ); + test_display( + &[0xfd, 0x21], + "movs r1, 0xfd" + ); + test_display( + &[0xfd, 0x22], + "movs r2, 0xfd" + ); + test_display( + &[0xfd, 0x22], + "movs r2, 0xfd" + ); + test_display( + &[0xfd, 0x23], + "movs r3, 0xfd" + ); + test_display( + &[0xfd, 0x23], + "movs r3, 0xfd" + ); + test_display( + &[0xfd, 0x24], + "movs r4, 0xfd" + ); + test_display( + &[0xfd, 0x24], + "movs r4, 0xfd" + ); + test_display( + &[0xfd, 0x25], + "movs r5, 0xfd" + ); + test_display( + &[0xfd, 0x25], + "movs r5, 0xfd" + ); + test_display( + &[0xfd, 0x26], + "movs r6, 0xfd" + ); + test_display( + &[0xfd, 0x26], + "movs r6, 0xfd" + ); + test_display( + &[0xfd, 0x27], + "movs r7, 0xfd" + ); + test_display( + &[0xfd, 0x27], + "movs r7, 0xfd" + ); + test_display( + &[0xfe, 0x00], + "lsls r6, r7, 0x3" + ); + test_display( + &[0xfe, 0x01], + "lsls r6, r7, 0x7" + ); + test_display( + &[0xfe, 0x02], + "lsls r6, r7, 0xb" + ); + test_display( + &[0xfe, 0x03], + "lsls r6, r7, 0xf" + ); + test_display( + &[0xfe, 0x04], + "lsls r6, r7, 0x13" + ); + test_display( + &[0xfe, 0x05], + "lsls r6, r7, 0x17" + ); + test_display( + &[0xfe, 0x06], + "lsls r6, r7, 0x1b" + ); + test_display( + &[0xfe, 0x07], + "lsls r6, r7, 0x1f" + ); + test_display( + &[0xfe, 0x08], + "lsrs r6, r7, 0x3" + ); + test_display( + &[0xfe, 0x09], + "lsrs r6, r7, 0x7" + ); + test_display( + &[0xfe, 0x0a], + "lsrs r6, r7, 0xb" + ); + test_display( + &[0xfe, 0x0b], + "lsrs r6, r7, 0xf" + ); + test_display( + &[0xfe, 0x0c], + "lsrs r6, r7, 0x13" + ); + test_display( + &[0xfe, 0x0d], + "lsrs r6, r7, 0x17" + ); + test_display( + &[0xfe, 0x0e], + "lsrs r6, r7, 0x1b" + ); + test_display( + &[0xfe, 0x0f], + "lsrs r6, r7, 0x1f" + ); + test_display( + &[0xfe, 0x10], + "asrs r6, r7, 0x3" + ); + test_display( + &[0xfe, 0x11], + "asrs r6, r7, 0x7" + ); + test_display( + &[0xfe, 0x12], + "asrs r6, r7, 0xb" + ); + test_display( + &[0xfe, 0x13], + "asrs r6, r7, 0xf" + ); + test_display( + &[0xfe, 0x14], + "asrs r6, r7, 0x13" + ); + test_display( + &[0xfe, 0x15], + "asrs r6, r7, 0x17" + ); + test_display( + &[0xfe, 0x16], + "asrs r6, r7, 0x1b" + ); + test_display( + &[0xfe, 0x17], + "asrs r6, r7, 0x1f" + ); + test_display( + &[0xfe, 0x40], + "lsrs r6, r7" + ); + test_display( + &[0xfe, 0x41], + "rors r6, r7" + ); + test_display( + &[0xfe, 0x43], + "mvns r6, r7" + ); + test_display( + &[0xff, 0x18], + "adds r7, r7, r3" + ); + test_display( + &[0xff, 0x19], + "adds r7, r7, r7" + ); + test_display( + &[0xff, 0x1c], + "adds r7, r7, 0x3" + ); + test_display( + &[0xff, 0x1d], + "adds r7, r7, 0x7" + ); + test_display( + &[0xff, 0x30], + "adds r0, 0xff" + ); + test_display( + &[0xff, 0x31], + "adds r1, 0xff" + ); + test_display( + &[0xff, 0x32], + "adds r2, 0xff" + ); + test_display( + &[0xff, 0x33], + "adds r3, 0xff" + ); + test_display( + &[0xff, 0x34], + "adds r4, 0xff" + ); + test_display( + &[0xff, 0x35], + "adds r5, 0xff" + ); + test_display( + &[0xff, 0x36], + "adds r6, 0xff" + ); + test_display( + &[0xff, 0x37], + "adds r7, 0xff" + ); +} +#[test] +fn test_decode_pop_cases() { + test_display( + &[0x00, 0xbd], + "pop {pc}" + ); + test_display( + &[0x01, 0xbc], + "pop {r0}" + ); + test_display( + &[0x7f, 0xbd], + "pop {r0, r1, r2, r3, r4, r5, r6, pc}" + ); + test_display( + &[0xff, 0xbd], + "pop {r0, r1, r2, r3, r4, r5, r6, r7, pc}" + ); +} +#[test] +fn test_decode_push_cases() { + test_display( + &[0x00, 0xb5], + "push {lr}" + ); + test_display( + &[0x01, 0xb4], + "push {r0}" + ); + test_display( + &[0xff, 0xb5], + "push {r0, r1, r2, r3, r4, r5, r6, r7, lr}" + ); +} +#[test] +fn test_decode_rev_cases() { + test_display( + &[0x0a, 0xba], + "rev r2, r1" + ); + test_display( + &[0x4a, 0xba], + "rev16 r2, r1" + ); + test_display( + &[0xca, 0xba], + "revsh r2, r1" + ); +} +#[test] +fn test_decode_stm_16b_cases() { + test_display( + &[0x01, 0xc0], + "stmia r0!, {r0}" + ); + test_display( + &[0x01, 0xc1], + "stmia r1!, {r0}" + ); + test_display( + &[0x01, 0xc2], + "stmia r2!, {r0}" + ); + test_display( + &[0x01, 0xc3], + "stmia r3!, {r0}" + ); + test_display( + &[0x01, 0xc4], + "stmia r4!, {r0}" + ); + test_display( + &[0x01, 0xc5], + "stmia r5!, {r0}" + ); + test_display( + &[0x01, 0xc6], + "stmia r6!, {r0}" + ); + test_display( + &[0x01, 0xc7], + "stmia r7!, {r0}" + ); + test_display( + &[0xff, 0xc3], + "stmia r3!, {r0, r1, r2, r3, r4, r5, r6, r7}" + ); +} +#[test] +fn test_decode_str_16b_cases() { + test_display( + &[0x00, 0x50], + "str r0, [r0, r0]" + ); + test_display( + &[0x00, 0x51], + "str r0, [r0, r4]" + ); + test_display( + &[0x00, 0x52], + "strh r0, [r0, r0]" + ); + test_display( + &[0x00, 0x53], + "strh r0, [r0, r4]" + ); + test_display( + &[0x00, 0x54], + "strb r0, [r0, r0]" + ); + test_display( + &[0x00, 0x55], + "strb r0, [r0, r4]" + ); + test_display( + &[0xfe, 0x60], + "str r6, [r7, 0xc]" + ); + test_display( + &[0xfe, 0x61], + "str r6, [r7, 0x1c]" + ); + test_display( + &[0xfe, 0x62], + "str r6, [r7, 0x2c]" + ); + test_display( + &[0xfe, 0x63], + "str r6, [r7, 0x3c]" + ); + test_display( + &[0xfe, 0x64], + "str r6, [r7, 0x4c]" + ); + test_display( + &[0xfe, 0x65], + "str r6, [r7, 0x5c]" + ); + test_display( + &[0xfe, 0x66], + "str r6, [r7, 0x6c]" + ); + test_display( + &[0xfe, 0x67], + "str r6, [r7, 0x7c]" + ); + test_display( + &[0xfe, 0x70], + "strb r6, [r7, 0x3]" + ); + test_display( + &[0xfe, 0x71], + "strb r6, [r7, 0x7]" + ); + test_display( + &[0xfe, 0x72], + "strb r6, [r7, 0xb]" + ); + test_display( + &[0xfe, 0x73], + "strb r6, [r7, 0xf]" + ); + test_display( + &[0xfe, 0x74], + "strb r6, [r7, 0x13]" + ); + test_display( + &[0xfe, 0x75], + "strb r6, [r7, 0x17]" + ); + test_display( + &[0xfe, 0x76], + "strb r6, [r7, 0x1b]" + ); + test_display( + &[0xfe, 0x77], + "strb r6, [r7, 0x1f]" + ); + test_display( + &[0xfe, 0x80], + "strh r6, [r7, 0x6]" + ); + test_display( + &[0xfe, 0x81], + "strh r6, [r7, 0xe]" + ); + test_display( + &[0xfe, 0x82], + "strh r6, [r7, 0x16]" + ); + test_display( + &[0xfe, 0x83], + "strh r6, [r7, 0x1e]" + ); + test_display( + &[0xfe, 0x84], + "strh r6, [r7, 0x26]" + ); + test_display( + &[0xfe, 0x85], + "strh r6, [r7, 0x2e]" + ); + test_display( + &[0xfe, 0x86], + "strh r6, [r7, 0x36]" + ); + test_display( + &[0xfe, 0x87], + "strh r6, [r7, 0x3e]" + ); + test_display( + &[0xfe, 0x90], + "str r0, [sp, 0x3f8]" + ); + test_display( + &[0xfe, 0x91], + "str r1, [sp, 0x3f8]" + ); + test_display( + &[0xfe, 0x92], + "str r2, [sp, 0x3f8]" + ); + test_display( + &[0xfe, 0x93], + "str r3, [sp, 0x3f8]" + ); + test_display( + &[0xfe, 0x94], + "str r4, [sp, 0x3f8]" + ); + test_display( + &[0xfe, 0x95], + "str r5, [sp, 0x3f8]" + ); + test_display( + &[0xfe, 0x96], + "str r6, [sp, 0x3f8]" + ); + test_display( + &[0xfe, 0x97], + "str r7, [sp, 0x3f8]" + ); + test_display( + &[0xff, 0x50], + "str r7, [r7, r3]" + ); + test_display( + &[0xff, 0x90], + "str r0, [sp, 0x3fc]" + ); + test_display( + &[0xff, 0x91], + "str r1, [sp, 0x3fc]" + ); + test_display( + &[0xff, 0x92], + "str r2, [sp, 0x3fc]" + ); + test_display( + &[0xff, 0x93], + "str r3, [sp, 0x3fc]" + ); + test_display( + &[0xff, 0x94], + "str r4, [sp, 0x3fc]" + ); + test_display( + &[0xff, 0x95], + "str r5, [sp, 0x3fc]" + ); + test_display( + &[0xff, 0x96], + "str r6, [sp, 0x3fc]" + ); + test_display( + &[0xff, 0x97], + "str r7, [sp, 0x3fc]" + ); +} +#[test] +fn test_decode_sub_cases() { + test_display( + &[0xd8, 0xb0], + "sub sp, sp, 0x160" + ); +} +#[test] +fn test_decode_svc_cases() { + test_display( + &[0x27, 0xdf], + "svc 0x27" + ); + test_display( + &[0xad, 0xdf], + "svc 0xad" + ); +} +#[test] +fn test_decode_udf_cases() { + test_display( + &[0x27, 0xde], + "udf 0x27" + ); + test_display( + &[0xad, 0xde], + "udf 0xad" + ); +} +#[test] +fn test_decode_ux_sx_cases() { + test_display( + &[0x0a, 0xb2], + "sxth r2, r1" + ); + test_display( + &[0x4a, 0xb2], + "sxtb r2, r1" + ); + test_display( + &[0x8a, 0xb2], + "uxth r2, r1" + ); + test_display( + &[0xca, 0xb2], + "uxtb r2, r1" + ); +} |