use super::{Insn, Operand, Operands, Reg, Width};
#[derive(Clone, Copy, PartialEq, Eq)]
enum Form {
Dest,
Test,
Rsb,
Mul,
}
const TABLE: [(&str, Form); 16] = [
("and", Form::Dest), ("eor", Form::Dest), ("lsl", Form::Dest), ("lsr", Form::Dest), ("asr", Form::Dest), ("adc", Form::Dest), ("sbc", Form::Dest), ("ror", Form::Dest), ("tst", Form::Test), ("rsb", Form::Rsb), ("cmp", Form::Test), ("cmn", Form::Test), ("orr", Form::Dest), ("mul", Form::Mul), ("bic", Form::Dest), ("mvn", Form::Dest), ];
impl Form {
fn sets_flags(self) -> bool {
self != Form::Test
}
}
pub(crate) fn decode(hw1: u16, _hw2: u16, addr: u32) -> Option<Insn> {
if hw1 >> 10 != 0b010000 {
return None;
}
let (mnemonic, form) = TABLE[((hw1 >> 6) & 0xF) as usize];
let hi = Reg(((hw1 >> 3) & 0b111) as u8);
let lo = Reg((hw1 & 0b111) as u8);
let mut operands = Operands::new();
operands.push(Operand::Reg(lo));
operands.push(Operand::Reg(hi));
match form {
Form::Dest | Form::Test => {}
Form::Rsb => operands.push(Operand::Imm(0)),
Form::Mul => operands.push(Operand::Reg(lo)),
}
Some(Insn {
mnemonic,
encoding: "T1",
addr,
width: Width::Narrow,
cond: None,
sets_flags: form.sets_flags(),
explicit_width: false,
operands,
})
}
pub(crate) fn encode(insn: &Insn) -> Option<u16> {
if insn.width != Width::Narrow || insn.encoding != "T1" || insn.explicit_width {
return None;
}
let (opcode, form) = TABLE
.iter()
.position(|(m, _)| *m == insn.mnemonic)
.map(|i| (i as u16, TABLE[i].1))?;
if insn.sets_flags != form.sets_flags() {
return None;
}
let reg = |i: usize| match insn.operands.get(i) {
Some(Operand::Reg(r)) if r.is_low() => Some(r.num() as u16),
_ => None,
};
let (hi, lo) = match form {
Form::Dest | Form::Test => {
if insn.operands.len() != 2 {
return None;
}
(reg(1)?, reg(0)?)
}
Form::Rsb => {
if insn.operands.len() != 3 || insn.operands.get(2) != Some(Operand::Imm(0)) {
return None;
}
(reg(1)?, reg(0)?)
}
Form::Mul => {
let rdm = reg(0)?;
if insn.operands.len() != 3 || reg(2)? != rdm {
return None;
}
(reg(1)?, rdm)
}
};
Some(0x4000 | opcode << 6 | hi << 3 | lo)
}
#[cfg(test)]
mod tests {
use super::*;
fn ual(hw1: u16) -> String {
decode(hw1, 0, 0)
.expect("fully allocated group")
.to_string()
}
fn hw(opcode: u16) -> u16 {
0x4000 | opcode << 6 | 2 << 3 | 1
}
#[test]
fn group_is_fully_allocated_and_round_trips() {
let holes: Vec<u16> = (0x4000..=0x43FFu16)
.filter(|hw1| decode(*hw1, 0, 0).is_none())
.collect();
assert_eq!(
holes,
Vec::new(),
"A5.2.2 leaves no hole in 0x4000..=0x43ff"
);
for hw1 in 0x4000..=0x43FFu16 {
let insn = decode(hw1, 0, 0).expect("the group is fully allocated");
assert_eq!(insn.width, Width::Narrow, "{hw1:#06x} is a 16-bit encoding");
assert_eq!(insn.encoding, "T1", "{hw1:#06x}");
assert_eq!(insn.len(), 2, "{hw1:#06x}");
assert!(insn.cond.is_none(), "{hw1:#06x} carries no condition");
assert!(
insn.operands.as_slice().all(|o| match o {
Operand::Reg(r) => r.is_low(),
_ => true,
}),
"{hw1:#06x} names only r0-r7"
);
assert_eq!(encode(&insn), Some(hw1), "round-trip of {hw1:#06x}");
}
assert_eq!(
(0x4000..=0x43FFu16).count(),
1024,
"the whole 0x4000..=0x43ff space"
);
}
#[test]
fn outside_the_group_is_not_ours() {
assert!(decode(0x3FFF, 0, 0).is_none());
assert!(decode(0x4400, 0, 0).is_none());
}
#[test]
fn table_a5_3_prints_ual() {
assert_eq!(ual(hw(0b0000)), "ands r1, r2");
assert_eq!(ual(hw(0b0001)), "eors r1, r2");
assert_eq!(ual(hw(0b0010)), "lsls r1, r2");
assert_eq!(ual(hw(0b0011)), "lsrs r1, r2");
assert_eq!(ual(hw(0b0100)), "asrs r1, r2");
assert_eq!(ual(hw(0b0101)), "adcs r1, r2");
assert_eq!(ual(hw(0b0110)), "sbcs r1, r2");
assert_eq!(ual(hw(0b0111)), "rors r1, r2");
assert_eq!(ual(hw(0b1000)), "tst r1, r2");
assert_eq!(ual(hw(0b1001)), "rsbs r1, r2, #0");
assert_eq!(ual(hw(0b1010)), "cmp r1, r2");
assert_eq!(ual(hw(0b1011)), "cmn r1, r2");
assert_eq!(ual(hw(0b1100)), "orrs r1, r2");
assert_eq!(ual(hw(0b1101)), "muls r1, r2, r1");
assert_eq!(ual(hw(0b1110)), "bics r1, r2");
assert_eq!(ual(hw(0b1111)), "mvns r1, r2");
}
#[test]
fn register_fields_are_read_in_the_right_order() {
assert_eq!(ual(0x4007), "ands r7, r0");
assert_eq!(ual(0x4000), "ands r0, r0");
assert_eq!(ual(0x43C0), "mvns r0, r0");
}
#[test]
fn flag_setters_print_no_s_suffix() {
for hw1 in [hw(0b1000), hw(0b1010), hw(0b1011)] {
let insn = decode(hw1, 0, 0).unwrap();
assert!(!insn.sets_flags, "{hw1:#06x}");
assert!(!insn.to_string().starts_with("tsts"));
assert!(!insn.to_string().starts_with("cmps"));
assert!(!insn.to_string().starts_with("cmns"));
}
for opcode in [0u16, 1, 2, 3, 4, 5, 6, 7, 9, 12, 13, 14, 15] {
assert!(decode(hw(opcode), 0, 0).unwrap().sets_flags, "{opcode:04b}");
}
}
#[test]
fn rsb_t1_emits_its_implicit_zero() {
let insn = decode(0x4252, 0, 0).unwrap(); assert_eq!(insn.mnemonic, "rsb");
assert_eq!(insn.operands.len(), 3);
assert_eq!(insn.operands.get(2), Some(Operand::Imm(0)));
assert_eq!(insn.to_string(), "rsbs r2, r2, #0");
assert_eq!(ual(0x424B), "rsbs r3, r1, #0");
}
#[test]
fn mul_t1_names_its_destination_twice() {
let insn = decode(0x4351, 0, 0).unwrap(); assert_eq!(insn.mnemonic, "mul");
assert_eq!(insn.operands.get(0), Some(Operand::Reg(Reg(1))));
assert_eq!(insn.operands.get(1), Some(Operand::Reg(Reg(2))));
assert_eq!(insn.operands.get(2), Some(Operand::Reg(Reg(1))));
assert_eq!(insn.to_string(), "muls r1, r2, r1");
}
#[test]
fn shift_by_register_is_two_plain_registers() {
for opcode in [0b0010u16, 0b0011, 0b0100, 0b0111] {
let insn = decode(hw(opcode), 0, 0).unwrap();
assert_eq!(insn.operands.len(), 2, "{opcode:04b}");
assert!(
insn.operands
.as_slice()
.all(|o| matches!(o, Operand::Reg(_))),
"{opcode:04b}"
);
}
}
#[test]
fn encode_rejects_what_this_group_cannot_hold() {
let base = decode(0x4000, 0, 0).unwrap();
let mut foreign = base;
foreign.mnemonic = "add";
assert_eq!(encode(&foreign), None);
let mut wide = base;
wide.width = Width::Wide;
assert_eq!(encode(&wide), None);
let mut t2 = base;
t2.encoding = "T2";
assert_eq!(encode(&t2), None);
let mut suffixed = base;
suffixed.explicit_width = true;
assert_eq!(encode(&suffixed), None);
let mut flagless = base;
flagless.sets_flags = false;
assert_eq!(encode(&flagless), None);
let mut flagged_tst = decode(0x4200, 0, 0).unwrap();
flagged_tst.sets_flags = true;
assert_eq!(encode(&flagged_tst), None);
let mut high = base;
high.operands = [Operand::Reg(Reg::SP), Operand::Reg(Reg(0))]
.into_iter()
.collect();
assert_eq!(encode(&high), None);
let mut high_hi = base;
high_hi.operands = [Operand::Reg(Reg(0)), Operand::Reg(Reg::LR)]
.into_iter()
.collect();
assert_eq!(encode(&high_hi), None);
let mut three = base;
three.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Reg(Reg(2)),
]
.into_iter()
.collect();
assert_eq!(encode(&three), None);
let mut immediate = base;
immediate.operands = [Operand::Reg(Reg(0)), Operand::Imm(1)]
.into_iter()
.collect();
assert_eq!(encode(&immediate), None);
let mut rsb = decode(0x4240, 0, 0).unwrap();
rsb.operands = [Operand::Reg(Reg(0)), Operand::Reg(Reg(0)), Operand::Imm(1)]
.into_iter()
.collect();
assert_eq!(encode(&rsb), None);
let mut rsb_short = decode(0x4240, 0, 0).unwrap();
rsb_short.operands = [Operand::Reg(Reg(0)), Operand::Reg(Reg(0))]
.into_iter()
.collect();
assert_eq!(encode(&rsb_short), None);
let mut rsb_high = decode(0x4240, 0, 0).unwrap();
rsb_high.operands = [Operand::Reg(Reg(0)), Operand::Reg(Reg::PC), Operand::Imm(0)]
.into_iter()
.collect();
assert_eq!(encode(&rsb_high), None);
let mut mul = decode(0x4340, 0, 0).unwrap();
mul.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Reg(Reg(2)),
]
.into_iter()
.collect();
assert_eq!(encode(&mul), None);
let mut mul_short = decode(0x4340, 0, 0).unwrap();
mul_short.operands = [Operand::Reg(Reg(0)), Operand::Reg(Reg(1))]
.into_iter()
.collect();
assert_eq!(encode(&mul_short), None);
let mut mul_high = decode(0x4340, 0, 0).unwrap();
mul_high.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Reg(Reg::PC),
]
.into_iter()
.collect();
assert_eq!(encode(&mul_high), None);
let high = Operand::Reg(Reg(8));
let r0 = Operand::Reg(Reg(0));
let r1 = Operand::Reg(Reg(1));
for (base, ops, field) in [
(0x4240u16, [high, r0, Operand::Imm(0)], "rsb Rd"),
(0x4240, [r0, high, Operand::Imm(0)], "rsb Rn"),
(0x4240, [r0, r1, r1], "rsb #0 is literal"),
(0x4340, [high, r1, high], "mul Rdm"),
(0x4340, [r0, high, r0], "mul Rn"),
(0x4340, [r0, r1, high], "mul Rdm repeated"),
(0x4340, [r0, r1, Operand::Imm(0)], "mul third is a register"),
(0x4340, [Operand::Imm(0), r1, r0], "mul first is a register"),
] {
let bad = Insn {
operands: ops.into_iter().collect(),
..decode(base, 0, 0).unwrap()
};
assert_eq!(encode(&bad), None, "`{bad}` encoded anyway: {field}");
}
}
}