use super::{Insn, Operand, Operands, Reg, Width};
use crate::Cond;
fn narrow(mnemonic: &'static str, encoding: &'static str, addr: u32, operands: Operands) -> Insn {
Insn {
mnemonic,
encoding,
addr,
width: Width::Narrow,
cond: None,
sets_flags: false,
explicit_width: false,
operands,
}
}
fn ops<const N: usize>(items: [Operand; N]) -> Operands {
items.into_iter().collect()
}
const CPS_IFLAGS: [&str; 8] = ["", "f", "i", "if", "a", "af", "ai", "aif"];
pub(crate) fn decode(hw1: u16, _hw2: u16, addr: u32) -> Option<Insn> {
if hw1 & 0xF000 != 0xB000 {
return None;
}
match (hw1 >> 5) & 0x7F {
0b000_0000..=0b000_0011 => Some(decode_adjust_sp(hw1, addr, "add", "T2")),
0b000_0100..=0b000_0111 => Some(decode_adjust_sp(hw1, addr, "sub", "T1")),
0b000_1000..=0b000_1111 => Some(decode_cb(hw1, addr)),
0b001_0000..=0b001_0111 => Some(decode_extend(hw1, addr)),
0b001_1000..=0b001_1111 => Some(decode_cb(hw1, addr)),
0b010_0000..=0b010_1111 => decode_push_pop(hw1, addr, "push", 14),
0b011_0010 => decode_setend(hw1, addr),
0b011_0011 => decode_cps(hw1, addr),
0b100_1000..=0b100_1111 => Some(decode_cb(hw1, addr)),
0b101_0000..=0b101_0111 => decode_reverse(hw1, addr),
0b101_1000..=0b101_1111 => Some(decode_cb(hw1, addr)),
0b110_0000..=0b110_1111 => decode_push_pop(hw1, addr, "pop", 15),
0b111_0000..=0b111_0111 => Some(decode_bkpt(hw1, addr)),
0b111_1000..=0b111_1111 => decode_it_or_hint(hw1, addr),
_ => None,
}
}
fn decode_adjust_sp(hw1: u16, addr: u32, mnemonic: &'static str, encoding: &'static str) -> Insn {
let imm = i64::from(hw1 & 0x7F) * 4;
narrow(
mnemonic,
encoding,
addr,
ops([Operand::Reg(Reg::SP), Operand::Imm(imm)]),
)
}
fn decode_cb(hw1: u16, addr: u32) -> Insn {
let nonzero = hw1 & (1 << 11) != 0;
let i = (hw1 >> 9) & 1;
let imm5 = (hw1 >> 3) & 0x1F;
let offset = u32::from((i << 6) | (imm5 << 1));
let target = addr.wrapping_add(4).wrapping_add(offset);
narrow(
if nonzero { "cbnz" } else { "cbz" },
"T1",
addr,
ops([
Operand::Reg(Reg((hw1 & 0x7) as u8)),
Operand::Target(target),
]),
)
}
fn decode_extend(hw1: u16, addr: u32) -> Insn {
let mnemonic = match (hw1 >> 6) & 0b11 {
0b00 => "sxth",
0b01 => "sxtb",
0b10 => "uxth",
_ => "uxtb",
};
narrow(mnemonic, "T1", addr, decode_rd_rm(hw1))
}
fn decode_reverse(hw1: u16, addr: u32) -> Option<Insn> {
let mnemonic = match (hw1 >> 6) & 0b11 {
0b00 => "rev",
0b01 => "rev16",
0b10 => return None,
_ => "revsh",
};
Some(narrow(mnemonic, "T1", addr, decode_rd_rm(hw1)))
}
fn decode_rd_rm(hw1: u16) -> Operands {
ops([
Operand::Reg(Reg((hw1 & 0x7) as u8)),
Operand::Reg(Reg(((hw1 >> 3) & 0x7) as u8)),
])
}
fn decode_push_pop(hw1: u16, addr: u32, mnemonic: &'static str, extra_bit: u8) -> Option<Insn> {
let list = (hw1 & 0xFF) | (((hw1 >> 8) & 1) << extra_bit);
if list == 0 {
return None;
}
Some(narrow(mnemonic, "T1", addr, ops([Operand::RegList(list)])))
}
fn decode_setend(hw1: u16, addr: u32) -> Option<Insn> {
if hw1 & 0x17 != 0x10 {
return None;
}
let endian = if hw1 & (1 << 3) != 0 { "be" } else { "le" };
Some(narrow("setend", "T1", addr, ops([Operand::Text(endian)])))
}
fn decode_cps(hw1: u16, addr: u32) -> Option<Insn> {
if hw1 & (1 << 3) != 0 {
return None; }
let iflags = CPS_IFLAGS[(hw1 & 0b111) as usize];
if iflags.is_empty() {
return None; }
let mnemonic = if hw1 & (1 << 4) != 0 {
"cpsid"
} else {
"cpsie"
};
Some(narrow(mnemonic, "T1", addr, ops([Operand::Text(iflags)])))
}
fn decode_bkpt(hw1: u16, addr: u32) -> Insn {
let mut insn = narrow(
"bkpt",
"T1",
addr,
ops([Operand::Imm(i64::from(hw1 & 0xFF))]),
);
insn.cond = Some(Cond::Al);
insn
}
fn decode_it_or_hint(hw1: u16, addr: u32) -> Option<Insn> {
let firstcond = ((hw1 >> 4) & 0xF) as u8;
let mask = (hw1 & 0xF) as u8;
if mask == 0 {
let mnemonic = match firstcond {
0b0000 => "nop",
0b0001 => "yield",
0b0010 => "wfe",
0b0011 => "wfi",
0b0100 => "sev",
_ => return None,
};
return Some(narrow(mnemonic, "T1", addr, Operands::new()));
}
let cond = Cond::from_bits(firstcond)?;
if cond == Cond::Al && mask.count_ones() != 1 {
return None;
}
let (len, letters) = it_letters_from_mask(firstcond, mask);
let mnemonic = it_spelling(len, letters);
let operand = if cond == Cond::Al {
Operand::Text("al")
} else {
Operand::Cond(cond)
};
Some(narrow(mnemonic, "T1", addr, ops([operand])))
}
fn it_letters_from_mask(firstcond: u8, mask: u8) -> (u8, [bool; 3]) {
let fc0 = firstcond & 1;
let len = 3 - (mask.trailing_zeros().min(3) as u8);
let mut letters = [true; 3];
for (i, letter) in letters.iter_mut().enumerate().take(len as usize) {
*letter = (mask >> (3 - i)) & 1 == fc0;
}
(len, letters)
}
const IT_SPELLINGS: [&str; 15] = [
"it", "ite", "itt", "itee", "itet", "itte", "ittt", "iteee", "iteet", "itete", "itett", "ittee", "ittet", "ittte", "itttt", ];
fn it_spelling(len: u8, letters: [bool; 3]) -> &'static str {
let len = usize::from(len);
let mut index = (1usize << len) - 1;
for (i, letter) in letters.iter().enumerate().take(len) {
index += usize::from(*letter) << (len - 1 - i);
}
IT_SPELLINGS[index]
}
fn it_letters_from_name(name: &str) -> Option<(u8, [bool; 3])> {
let (len, letters) = match name {
"it" => (0, [true, true, true]),
"itt" => (1, [true, true, true]),
"ite" => (1, [false, true, true]),
"ittt" => (2, [true, true, true]),
"itte" => (2, [true, false, true]),
"itet" => (2, [false, true, true]),
"itee" => (2, [false, false, true]),
"itttt" => (3, [true, true, true]),
"ittte" => (3, [true, true, false]),
"ittet" => (3, [true, false, true]),
"ittee" => (3, [true, false, false]),
"itett" => (3, [false, true, true]),
"itete" => (3, [false, true, false]),
"iteet" => (3, [false, false, true]),
"iteee" => (3, [false, false, false]),
_ => return None,
};
Some((len, letters))
}
pub(crate) fn encode(insn: &Insn) -> Option<u16> {
match insn.mnemonic {
"add" if insn.encoding == "T2" => encode_adjust_sp(insn, 0xB000),
"sub" if insn.encoding == "T1" => encode_adjust_sp(insn, 0xB080),
"cbz" => encode_cb(insn, 0xB100),
"cbnz" => encode_cb(insn, 0xB900),
"sxth" => encode_rd_rm(insn, 0xB200),
"sxtb" => encode_rd_rm(insn, 0xB240),
"uxth" => encode_rd_rm(insn, 0xB280),
"uxtb" => encode_rd_rm(insn, 0xB2C0),
"push" => encode_push_pop(insn, 0xB400, 14),
"setend" => match insn.operands.get(0) {
Some(Operand::Text("le")) => Some(0xB650),
Some(Operand::Text("be")) => Some(0xB658),
_ => None,
},
"cpsie" => encode_cps(insn, 0xB660),
"cpsid" => encode_cps(insn, 0xB670),
"rev" => encode_rd_rm(insn, 0xBA00),
"rev16" => encode_rd_rm(insn, 0xBA40),
"revsh" => encode_rd_rm(insn, 0xBAC0),
"pop" => encode_push_pop(insn, 0xBC00, 15),
"bkpt" => match insn.operands.get(0) {
Some(Operand::Imm(v)) if (0..=255).contains(&v) => Some(0xBE00 | (v as u16)),
_ => None,
},
"nop" => Some(0xBF00),
"yield" => Some(0xBF10),
"wfe" => Some(0xBF20),
"wfi" => Some(0xBF30),
"sev" => Some(0xBF40),
_ => encode_it(insn),
}
}
fn encode_adjust_sp(insn: &Insn, base: u16) -> Option<u16> {
if insn.operands.len() != 2 || insn.operands.get(0) != Some(Operand::Reg(Reg::SP)) {
return None;
}
match insn.operands.get(1) {
Some(Operand::Imm(v)) if (0..=508).contains(&v) && v % 4 == 0 => {
Some(base | (v as u16 / 4))
}
_ => None,
}
}
fn encode_cb(insn: &Insn, base: u16) -> Option<u16> {
let rn = match insn.operands.get(0) {
Some(Operand::Reg(r)) if r.is_low() => u16::from(r.num()),
_ => return None,
};
let target = match insn.operands.get(1) {
Some(Operand::Target(t)) => t,
_ => return None,
};
let offset = target.wrapping_sub(insn.addr.wrapping_add(4));
if offset > 126 || offset % 2 != 0 {
return None;
}
let offset = offset as u16;
Some(base | ((offset & 0x40) << 3) | ((offset & 0x3E) << 2) | rn)
}
fn encode_rd_rm(insn: &Insn, base: u16) -> Option<u16> {
match (insn.operands.get(0), insn.operands.get(1)) {
(Some(Operand::Reg(rd)), Some(Operand::Reg(rm))) if rd.is_low() && rm.is_low() => {
Some(base | (u16::from(rm.num()) << 3) | u16::from(rd.num()))
}
_ => None,
}
}
fn encode_push_pop(insn: &Insn, base: u16, extra_bit: u8) -> Option<u16> {
let list = match insn.operands.get(0) {
Some(Operand::RegList(bits)) => bits,
_ => return None,
};
let allowed = 0x00FF | (1u16 << extra_bit);
if list == 0 || list & !allowed != 0 {
return None;
}
Some(base | (list & 0xFF) | (((list >> extra_bit) & 1) << 8))
}
fn encode_cps(insn: &Insn, base: u16) -> Option<u16> {
let flags = match insn.operands.get(0) {
Some(Operand::Text(s)) => s,
_ => return None,
};
let aif = CPS_IFLAGS
.iter()
.position(|f| *f == flags)
.filter(|i| *i != 0)?;
Some(base | aif as u16)
}
fn encode_it(insn: &Insn) -> Option<u16> {
let (len, letters) = it_letters_from_name(insn.mnemonic)?;
let firstcond = match insn.operands.get(0) {
Some(Operand::Cond(c)) => c.bits(),
Some(Operand::Text("al")) => Cond::Al.bits(),
_ => return None,
};
let fc0 = firstcond & 1;
let mut mask = 1u8 << (3 - len);
for (i, letter) in letters.iter().enumerate().take(len as usize) {
let bit = if *letter { fc0 } else { fc0 ^ 1 };
mask |= bit << (3 - i);
}
if firstcond == Cond::Al.bits() && mask.count_ones() != 1 {
return None;
}
Some(0xBF00 | (u16::from(firstcond) << 4) | u16::from(mask))
}
#[cfg(test)]
mod tests {
use super::super::{it_state_from, ItState};
use super::*;
const ADDR: u32 = 0x1000;
fn dis(hw1: u16) -> String {
decode(hw1, 0, ADDR).expect("should decode").to_string()
}
#[test]
fn exhaustive_round_trip() {
let mut decoded = 0usize;
for hw in 0xB000u32..=0xBFFFu32 {
let hw = hw as u16;
if let Some(insn) = decode(hw, 0, ADDR) {
decoded += 1;
assert_eq!(
encode(&insn),
Some(hw),
"{hw:#06x} decoded as `{insn}` did not re-encode"
);
assert!(!insn.sets_flags, "{hw:#06x} `{insn}` must not set flags");
assert!(!insn.explicit_width, "{hw:#06x} `{insn}` is never .n/.w");
assert_eq!(insn.width, Width::Narrow);
assert_eq!(insn.addr, ADDR);
}
}
assert_eq!(decoded, 3241);
}
#[test]
fn undefined_holes_are_accounted_for() {
let mut undecoded: Vec<u16> = (0xB000u32..=0xBFFF)
.map(|hw| hw as u16)
.filter(|hw| decode(*hw, 0, ADDR).is_none())
.collect();
assert_eq!(undecoded.len(), 855);
undecoded.sort_unstable();
let mut expected: Vec<u16> = Vec::new();
let unallocated_opcodes: Vec<u16> = (0b011_0000..=0b011_0001)
.chain(0b011_0100..=0b011_0111) .chain(0b011_1000..=0b011_1111) .chain(0b100_0000..=0b100_0111) .chain(0b101_0100..=0b101_0101) .collect();
assert_eq!(unallocated_opcodes.len(), 24);
for op in unallocated_opcodes {
expected.extend((0..32).map(|low| 0xB000 | (op << 5) | low));
}
expected.extend((0xB640..=0xB65F).filter(|hw| *hw != 0xB650 && *hw != 0xB658));
expected.extend((0xB660..=0xB67F).filter(|hw| *hw & 8 != 0 || *hw & 7 == 0));
expected.push(0xB400);
expected.push(0xBC00);
expected.extend((0b0101..=0b1111).map(|opa: u16| 0xBF00 | (opa << 4)));
expected.extend(0xBFF1..=0xBFFF);
expected.extend(
(1u16..=15)
.filter(|m| m.count_ones() != 1)
.map(|m| 0xBFE0 | m),
);
expected.sort_unstable();
assert_eq!(expected.len(), 768 + 30 + 18 + 2 + 37);
assert_eq!(undecoded, expected);
}
#[test]
fn per_row_decode_counts() {
let mut counts = std::collections::BTreeMap::new();
for hw in 0xB000u32..=0xBFFF {
if let Some(insn) = decode(hw as u16, 0, ADDR) {
*counts.entry(insn.mnemonic).or_insert(0usize) += 1;
}
}
for (mnemonic, want) in [
("add", 128),
("sub", 128),
("cbz", 512),
("cbnz", 512),
("sxth", 64),
("sxtb", 64),
("uxth", 64),
("uxtb", 64),
("push", 511),
("setend", 2),
("cpsie", 7),
("cpsid", 7),
("rev", 64),
("rev16", 64),
("revsh", 64),
("pop", 511),
("bkpt", 256),
("nop", 1),
("yield", 1),
("wfe", 1),
("wfi", 1),
("sev", 1),
] {
assert_eq!(counts.get(mnemonic), Some(&want), "count for {mnemonic}");
}
let its: usize = counts
.iter()
.filter(|(m, _)| m.starts_with("it"))
.map(|(_, n)| *n)
.sum();
assert_eq!(its, 16 * 15 - 15 - 11);
}
#[test]
fn printed_ual_covers_every_row() {
assert_eq!(dis(0xB000), "add sp, #0");
assert_eq!(dis(0xB005), "add sp, #0x14");
assert_eq!(dis(0xB07F), "add sp, #0x1fc"); assert_eq!(dis(0xB080), "sub sp, #0");
assert_eq!(dis(0xB085), "sub sp, #0x14");
assert_eq!(dis(0xB0FF), "sub sp, #0x1fc");
assert_eq!(dis(0xB108), "cbz r0, 0x1006");
assert_eq!(dis(0xB908), "cbnz r0, 0x1006");
assert_eq!(dis(0xB211), "sxth r1, r2");
assert_eq!(dis(0xB251), "sxtb r1, r2");
assert_eq!(dis(0xB291), "uxth r1, r2");
assert_eq!(dis(0xB2D1), "uxtb r1, r2");
assert_eq!(dis(0xBA11), "rev r1, r2");
assert_eq!(dis(0xBA51), "rev16 r1, r2");
assert_eq!(dis(0xBAD1), "revsh r1, r2");
assert!(decode(0xBA91, 0, ADDR).is_none(), "101010x is UNDEFINED");
assert_eq!(dis(0xB410), "push {r4}");
assert_eq!(dis(0xB5F0), "push {r4-r7, lr}");
assert_eq!(dis(0xBC10), "pop {r4}");
assert_eq!(dis(0xBDF0), "pop {r4-r7, pc}");
assert_eq!(dis(0xB650), "setend le");
assert_eq!(dis(0xB658), "setend be");
assert_eq!(dis(0xB661), "cpsie f");
assert_eq!(dis(0xB662), "cpsie i");
assert_eq!(dis(0xB663), "cpsie if");
assert_eq!(dis(0xB667), "cpsie aif");
assert_eq!(dis(0xB672), "cpsid i");
assert_eq!(dis(0xB674), "cpsid a");
assert_eq!(dis(0xBE00), "bkpt #0");
assert_eq!(dis(0xBEAB), "bkpt #0xab");
assert_eq!(dis(0xBF08), "it eq");
assert_eq!(dis(0xBF00), "nop");
assert_eq!(dis(0xBF10), "yield");
assert_eq!(dis(0xBF20), "wfe");
assert_eq!(dis(0xBF30), "wfi");
assert_eq!(dis(0xBF40), "sev");
assert!(decode(0xBF50, 0, ADDR).is_none(), "unallocated hint");
}
#[test]
fn prologue_and_epilogue() {
let push = decode(0xB500, 0, ADDR).unwrap();
assert_eq!(push.to_string(), "push {lr}");
assert_eq!(push.operands.get(0), Some(Operand::RegList(1 << 14)));
assert!(!push.writes_pc());
let pop = decode(0xBD00, 0, ADDR).unwrap();
assert_eq!(pop.to_string(), "pop {pc}");
assert_eq!(pop.operands.get(0), Some(Operand::RegList(1 << 15)));
assert!(pop.writes_pc(), "pop {{pc}} must be seen to write pc");
assert!(pop.is_branch());
assert_eq!(dis(0xB5FF), "push {r0-r7, lr}");
assert_eq!(dis(0xBDFF), "pop {r0-r7, pc}");
assert_eq!(
decode(0xB400, 0, ADDR),
None,
"`push {{}}` is not an instruction"
);
assert_eq!(
decode(0xBC00, 0, ADDR),
None,
"`pop {{}}` is not an instruction"
);
assert_eq!(dis(0xB401), "push {r0}");
assert_eq!(dis(0xB500), "push {lr}");
assert_eq!(dis(0xBC01), "pop {r0}");
assert_eq!(dis(0xBD00), "pop {pc}");
let empty = Insn {
operands: ops([Operand::RegList(0)]),
..decode(0xB500, 0, ADDR).unwrap()
};
assert_eq!(encode(&empty), None);
}
#[test]
fn cbz_is_forward_only() {
let insn = decode(0xB108, 0, ADDR).unwrap();
assert_eq!(insn.branch_target(), Some(ADDR + 4 + 2));
let insn = decode(0xB300, 0, ADDR).unwrap();
assert_eq!(insn.branch_target(), Some(ADDR + 4 + 64));
assert_eq!(insn.to_string(), "cbz r0, 0x1044");
let insn = decode(0xB3F8, 0, ADDR).unwrap();
assert_eq!(insn.branch_target(), Some(ADDR + 4 + 126));
assert!(insn.is_branch());
for hw in 0xB000u32..=0xBFFF {
if let Some(i) = decode(hw as u16, 0, ADDR) {
if let Some(t) = i.branch_target() {
assert!((ADDR + 4..=ADDR + 4 + 126).contains(&t), "{hw:#06x}");
}
}
}
let insn = decode(0xB3F8, 0, ADDR).unwrap();
let moved = Insn {
addr: ADDR + 128,
..insn
};
assert_eq!(encode(&moved), None, "target is behind the instruction");
let moved = Insn {
addr: ADDR - 2,
..insn
};
assert_eq!(encode(&moved), None, "+128 exceeds the 126-byte reach");
let moved = Insn {
addr: ADDR + 2,
..insn
};
assert_eq!(encode(&moved), Some(0xB3F0), "one imm5 step closer");
}
#[test]
fn it_spellings() {
assert_eq!(dis(0xBF08), "it eq"); assert_eq!(dis(0xBF04), "itt eq"); assert_eq!(dis(0xBF0C), "ite eq"); assert_eq!(dis(0xBF02), "ittt eq"); assert_eq!(dis(0xBF06), "itte eq"); assert_eq!(dis(0xBF0A), "itet eq"); assert_eq!(dis(0xBF0E), "itee eq"); assert_eq!(dis(0xBF01), "itttt eq"); assert_eq!(dis(0xBF0F), "iteee eq");
assert_eq!(dis(0xBF18), "it ne");
assert_eq!(dis(0xBF14), "ite ne");
assert_eq!(dis(0xBF1C), "itt ne");
assert_eq!(dis(0xBF12), "itee ne");
assert_eq!(dis(0xBFE8), "it al");
assert_eq!(dis(0xBFE4), "itt al");
assert_eq!(dis(0xBFE2), "ittt al");
assert_eq!(dis(0xBFE1), "itttt al");
assert!(
decode(0xBFEC, 0, ADDR).is_none(),
"`ite al` is UNPREDICTABLE"
);
assert!(decode(0xBFF8, 0, ADDR).is_none(), "firstcond 0b1111");
}
#[test]
fn it_agrees_with_it_state() {
for (hw, cond, mask, governed) in [
(0xBF08u16, 0b0000u8, 0b1000u8, 1usize), (0xBF04, 0b0000, 0b0100, 2), (0xBF0C, 0b0000, 0b1100, 2), (0xBF02, 0b0000, 0b0010, 3), (0xBF01, 0b0000, 0b0001, 4), (0xBF1C, 0b0001, 0b1100, 2), (0xBFE8, 0b1110, 0b1000, 1), ] {
let insn = decode(hw, 0, ADDR).unwrap();
assert!(insn.mnemonic.starts_with("it"), "{hw:#06x} {insn}");
let state = it_state_from(hw);
assert_eq!(state, ItState { cond, mask }, "{hw:#06x} `{insn}`");
assert_eq!(state.current(), Cond::from_bits(cond));
let mut state = state;
let mut n = 0;
while state.active() {
n += 1;
state = state.advance();
assert!(n <= 4, "{hw:#06x} `{insn}` never ends");
}
assert_eq!(n, governed, "{hw:#06x} `{insn}` block length");
}
assert_eq!(it_state_from(0xBF00), ItState::INACTIVE);
}
#[test]
fn bkpt_is_unconditional() {
let insn = decode(0xBE00, 0, ADDR).unwrap();
assert_eq!(insn.cond, Some(Cond::Al));
assert_eq!(insn.to_string(), "bkpt #0");
for hw in 0xB000u32..=0xBFFF {
if let Some(i) = decode(hw as u16, 0, ADDR) {
if i.mnemonic != "bkpt" {
assert_eq!(i.cond, None, "{hw:#06x} `{i}`");
}
}
}
}
#[test]
fn encode_rejects_inexpressible() {
let base = decode(0xB000, 0, ADDR).unwrap();
for imm in [-4i64, 2, 510, 512] {
let bad = Insn {
operands: ops([Operand::Reg(Reg::SP), Operand::Imm(imm)]),
..base
};
assert_eq!(encode(&bad), None, "add sp, #{imm}");
}
let push = decode(0xB500, 0, ADDR).unwrap();
for bits in [1u16 << 15, 1 << 8, 1 << 13] {
let bad = Insn {
operands: ops([Operand::RegList(bits)]),
..push
};
assert_eq!(encode(&bad), None, "push {bits:#x}");
}
let pop = decode(0xBD00, 0, ADDR).unwrap();
let bad = Insn {
operands: ops([Operand::RegList(1 << 14)]),
..pop
};
assert_eq!(encode(&bad), None, "pop cannot name lr");
let alien = Insn {
mnemonic: "bl",
..base
};
assert_eq!(encode(&alien), None);
for (hw, mine, theirs) in [(0xB002u16, "T2", "T3"), (0xB082, "T1", "T2")] {
let right = decode(hw, 0, ADDR).unwrap();
assert_eq!(right.encoding, mine, "`{right}` is {mine}");
assert_eq!(encode(&right), Some(hw));
let renamed = Insn {
encoding: theirs,
..right
};
assert_eq!(encode(&renamed), None, "`{renamed}` as {theirs} is wide");
}
}
#[test]
fn it_spellings_match_table_a7_3() {
for fc0 in [0u8, 1] {
for mask in 1u8..=15 {
let len = 3 - mask.trailing_zeros().min(3);
let mut expected = String::from("it");
for i in 0..len {
let bit = (mask >> (3 - i)) & 1;
expected.push(if bit == fc0 { 't' } else { 'e' });
}
let (n, letters) = it_letters_from_mask(fc0, mask);
assert_eq!(u32::from(n), len, "mask {mask:#06b} letter count");
assert_eq!(
it_spelling(n, letters),
expected,
"fc0 {fc0} mask {mask:#06b}"
);
assert_eq!(
it_letters_from_name(&expected),
Some((n, letters_of(n, letters))),
"{expected} does not read back"
);
}
}
}
fn letters_of(len: u8, letters: [bool; 3]) -> [bool; 3] {
let mut out = [true; 3];
out[..usize::from(len)].copy_from_slice(&letters[..usize::from(len)]);
out
}
#[test]
fn encode_reads_no_operand_it_has_not_checked() {
let r0 = Operand::Reg(Reg(0));
let sp = Operand::Reg(Reg::SP);
let imm = Operand::Imm(4);
let cases: &[(u16, &[Operand], &str)] = &[
(0xB001, &[r0, imm], "the first operand is the SP"),
(0xB001, &[sp], "two operands"),
(0xB001, &[sp, imm, imm], "two operands"),
(0xB001, &[sp, r0], "the second operand is an immediate"),
(0xB081, &[r0, imm], "SUB's first operand is the SP too"),
(
0xB108,
&[Operand::Reg(Reg(8)), Operand::Target(0x1006)],
"Rn is three bits",
),
(0xB108, &[imm, Operand::Target(0x1006)], "Rn is a register"),
(0xB108, &[r0, imm], "the target is resolved, not an offset"),
(0xB108, &[r0], "two operands"),
(0xB211, &[Operand::Reg(Reg(8)), r0], "Rd is three bits"),
(0xB211, &[r0, Operand::Reg(Reg(8))], "Rm is three bits"),
(0xB211, &[r0, imm], "Rm is a register"),
(0xB211, &[r0], "two operands"),
(0xBA11, &[r0, imm], "REV takes two registers"),
(0xB500, &[r0], "the operand is a register list"),
(0xBD00, &[imm], "the operand is a register list"),
(0xB650, &[imm], "the operand is an endianness"),
(0xB650, &[Operand::Text("mid")], "only `le` and `be` exist"),
(0xB661, &[imm], "the operand is an iflags string"),
(
0xB661,
&[Operand::Text("")],
"`A:I:F == 000` has no spelling",
),
(0xB661, &[Operand::Text("fi")], "the order is a, i, f"),
(0xBE00, &[r0], "the operand is an immediate"),
(0xBE00, &[Operand::Imm(256)], "imm8 holds 0..=255"),
(0xBE00, &[Operand::Imm(-1)], "imm8 is unsigned"),
(0xBF08, &[imm], "the operand is a condition"),
(0xBF08, &[Operand::Text("eq")], "only AL is spelled as text"),
];
for &(hw, operands, why) in cases {
let base = decode(hw, 0, ADDR).expect("the base halfword decodes");
let bad = Insn {
operands: operands.iter().copied().collect(),
..base
};
assert_eq!(encode(&bad), None, "`{bad}` from {hw:#06x}: {why}");
}
for mnemonic in ["ite", "itee", "iteee", "itte"] {
let bad = Insn {
mnemonic,
operands: ops([Operand::Text("al")]),
..decode(0xBF08, 0, ADDR).unwrap()
};
assert_eq!(encode(&bad), None, "`{mnemonic} al` is UNPREDICTABLE");
}
for (mnemonic, hw) in [("it", 0xBFE8u16), ("itt", 0xBFE4), ("ittt", 0xBFE2)] {
let good = Insn {
mnemonic,
operands: ops([Operand::Text("al")]),
..decode(0xBF08, 0, ADDR).unwrap()
};
assert_eq!(encode(&good), Some(hw), "`{mnemonic} al`");
}
}
#[test]
fn rejects_other_groups() {
for hw in [0x0000u16, 0x4770, 0xAFFF, 0xC000, 0xD000, 0xFFFF] {
assert!(decode(hw, 0, ADDR).is_none(), "{hw:#06x}");
}
}
}