use super::{AddrMode, Insn, Mem, Operand, Reg, Shift, ShiftAmount, ShiftKind, Width};
pub(crate) fn decode(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw1 >> 11 != 0b11111 || (hw1 >> 8) & 0b111 != 0 || (hw1 >> 4) & 1 != 0 {
return None;
}
let op1 = (hw1 >> 5) & 0b111;
let size = op1 & 0b11;
let rn = Reg((hw1 & 0xF) as u8);
let rt = Reg(((hw2 >> 12) & 0xF) as u8);
if size == 0b11 || rn.num() == 15 || rt.num() == 15 {
return None;
}
let mnemonic = SIZED[size as usize];
if op1 & 0b100 != 0 {
let mem = Mem {
base: rn,
index: None,
offset: u32::from(hw2 & 0x0FFF),
add: true,
align: 0,
mode: AddrMode::Offset,
};
let encoding = if size == WORD { "T3" } else { "T2" };
return Some(wide(
mnemonic,
encoding,
addr,
true,
&[Operand::Reg(rt), Operand::Mem(mem)],
));
}
let op2 = (hw2 >> 6) & 0b11_1111;
if op2 & 0b10_0000 == 0 {
if op2 != 0 {
return None;
}
let imm2 = ((hw2 >> 4) & 0b11) as u8;
let mem = Mem {
base: rn,
index: Some((
Reg((hw2 & 0xF) as u8),
if imm2 == 0 {
None
} else {
Some(Shift {
kind: ShiftKind::Lsl,
amount: ShiftAmount::Imm(imm2),
})
},
)),
offset: 0,
add: true,
align: 0,
mode: AddrMode::Offset,
};
return Some(wide(
mnemonic,
"T2",
addr,
true,
&[Operand::Reg(rt), Operand::Mem(mem)],
));
}
let p = (hw2 >> 10) & 1 == 1;
let u = (hw2 >> 9) & 1 == 1;
let w = (hw2 >> 8) & 1 == 1;
let imm8 = u32::from(hw2 & 0xFF);
if p && u && !w {
let mem = Mem {
base: rn,
index: None,
offset: imm8,
add: true,
align: 0,
mode: AddrMode::Offset,
};
return Some(wide(
UNPRIV[size as usize],
"T1",
addr,
false,
&[Operand::Reg(rt), Operand::Mem(mem)],
));
}
if !p && !w {
return None;
}
if size == WORD && rn.num() == 13 && p && !u && w && imm8 == 4 {
return Some(wide(
"push",
"T3",
addr,
true,
&[Operand::RegList(1 << rt.num())],
));
}
let mem = Mem {
base: rn,
index: None,
offset: imm8,
add: u,
align: 0,
mode: if !p {
AddrMode::PostIndex
} else if w {
AddrMode::PreIndex
} else {
AddrMode::Offset
},
};
let encoding = if size == WORD { "T4" } else { "T3" };
Some(wide(
mnemonic,
encoding,
addr,
false,
&[Operand::Reg(rt), Operand::Mem(mem)],
))
}
pub(crate) fn encode(insn: &Insn) -> Option<(u16, u16)> {
if insn.width != Width::Wide || insn.sets_flags {
return None;
}
if insn.mnemonic == "push" {
if insn.encoding != "T3" || insn.operands.len() != 1 {
return None;
}
return match insn.operands.get(0) {
Some(Operand::RegList(bits)) if bits.count_ones() == 1 && bits & 0x8000 == 0 => {
Some((0xF84D, (bits.trailing_zeros() as u16) << 12 | 0x0D04))
}
_ => None,
};
}
let size = match insn.mnemonic {
"strb" | "strbt" => 0u16,
"strh" | "strht" => 1,
"str" | "strt" => 2,
_ => return None,
};
let (rt, mem) = match (insn.operands.get(0), insn.operands.get(1)) {
(Some(Operand::Reg(t)), Some(Operand::Mem(m))) => (t, m),
_ => return None,
};
if insn.operands.len() != 2 || rt.num() == 15 || mem.base.num() == 15 {
return None;
}
let hw1 = 0xF800 | (size << 5) | u16::from(mem.base.num());
let rt_field = u16::from(rt.num()) << 12;
if matches!(insn.mnemonic, "strt" | "strbt" | "strht") {
if insn.encoding != "T1" || mem.index.is_some() || mem.mode != AddrMode::Offset {
return None;
}
if !mem.add {
return None;
}
let imm = u16::try_from(mem.offset).ok()?;
if imm > 0xFF {
return None;
}
return Some((hw1, rt_field | 0x0E00 | imm));
}
if let Some((rm, shift)) = mem.index {
if insn.encoding != "T2" || mem.mode != AddrMode::Offset || mem.offset != 0 || !mem.add {
return None;
}
let imm2 = match shift {
None => 0u16,
Some(Shift {
kind: ShiftKind::Lsl,
amount: ShiftAmount::Imm(n),
}) if (1..=3).contains(&n) => u16::from(n),
_ => return None,
};
return Some((hw1, rt_field | (imm2 << 4) | u16::from(rm.num())));
}
let (imm12_name, imm8_name) = if size == WORD {
("T3", "T4")
} else {
("T2", "T3")
};
if insn.encoding == imm12_name {
if mem.mode != AddrMode::Offset || !mem.add {
return None;
}
let imm = u16::try_from(mem.offset).ok()?;
if imm > 0x0FFF {
return None;
}
return Some((hw1 | 0x0080, rt_field | imm));
}
if insn.encoding != imm8_name {
return None;
}
let magnitude = u16::try_from(mem.offset).ok()?;
if magnitude > 0xFF {
return None;
}
let (p, w) = match mem.mode {
AddrMode::Offset => (1u16, 0u16),
AddrMode::PreIndex => (1, 1),
AddrMode::PostIndex => (0, 1),
AddrMode::PostIncrement => return None,
};
if mem.mode == AddrMode::Offset && mem.add {
return None;
}
let u = u16::from(mem.add);
Some((
hw1,
rt_field | 0x0800 | (p << 10) | (u << 9) | (w << 8) | magnitude,
))
}
const WORD: u16 = 0b10;
const SIZED: [&str; 3] = ["strb", "strh", "str"];
const UNPRIV: [&str; 3] = ["strbt", "strht", "strt"];
fn wide(
mnemonic: &'static str,
encoding: &'static str,
addr: u32,
explicit_width: bool,
ops: &[Operand],
) -> Insn {
Insn {
mnemonic,
encoding,
addr,
width: Width::Wide,
cond: None,
sets_flags: false,
explicit_width,
operands: ops.iter().copied().collect(),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::isa::Target;
fn dec(hw1: u16, hw2: u16) -> Insn {
let decoded = decode(hw1, hw2, 0x1000);
assert!(decoded.is_some(), "{hw1:#06x} {hw2:#06x} failed to decode");
decoded.unwrap()
}
fn check(hw1: u16, hw2: u16, text: &str) -> Insn {
let insn = dec(hw1, hw2);
assert_eq!(insn.to_string(), text, "{hw1:#06x} {hw2:#06x}");
assert_eq!(
encode(&insn),
Some((hw1, hw2)),
"`{insn}` did not re-encode to {hw1:#06x} {hw2:#06x}"
);
assert!(!insn.sets_flags, "no store sets flags");
insn
}
fn hw2_sweep() -> Vec<u16> {
let mut out = Vec::new();
for rt in [0u16, 1, 7, 12, 13, 15] {
let rt = rt << 12;
for imm in [0u16, 1, 2, 4, 0x7FF, 0x800, 0xFFE, 0xFFF] {
out.push(rt | imm);
}
for puw in 0u16..8 {
for imm8 in [0u16, 1, 4, 0x7F, 0x80, 0xFF] {
out.push(rt | 0x0800 | (puw << 8) | imm8);
}
}
for imm2 in 0u16..4 {
for rm in [0u16, 1, 2, 13, 15] {
out.push(rt | (imm2 << 4) | rm);
}
}
for op2 in [1u16, 2, 0x1F, 0x20] {
out.push(rt | (op2 << 6));
}
}
out
}
#[test]
fn systematic_round_trip() {
let mut exact = 0;
let mut minus_zero = 0;
let mut undefined = 0;
let sweep = hw2_sweep();
for op1 in 0u16..8 {
for rn in 0u16..16 {
let hw1 = 0xF800 | (op1 << 5) | rn;
for &hw2 in &sweep {
if let Some(insn) = decode(hw1, hw2, 0x2000) {
assert_eq!(
encode(&insn),
Some((hw1, hw2)),
"{hw1:#06x} {hw2:#06x} re-encoded wrongly as `{insn}`"
);
exact += 1;
if op1 & 0b100 == 0 && hw2 & 0x0BFF == 0x0900 {
minus_zero += 1;
assert!(
insn.to_string().contains("#-0"),
"{hw1:#06x} {hw2:#06x} is `#-0` and must print so"
);
}
} else {
undefined += 1;
}
}
}
}
assert_eq!(sweep.len(), 480);
assert_eq!(exact + undefined, 8 * 16 * sweep.len());
assert_eq!(exact, 31_950, "unexpected number of defined encodings");
assert_eq!(
minus_zero, 450,
"the #-0 writeback and post-indexed forms, and only those"
);
assert_eq!(undefined, 29_490);
}
#[test]
fn minus_zero_is_its_own_encoding() {
let minus = dec(0xF841, 0x0D00);
let plus = dec(0xF841, 0x0F00);
assert_ne!(minus, plus, "#-0 and #+0 are different instructions");
assert_eq!(minus.to_string(), "str r0, [r1, #-0]!");
assert_eq!(plus.to_string(), "str r0, [r1, #0]!");
assert_eq!(encode(&minus), Some((0xF841, 0x0D00)));
assert_eq!(encode(&plus), Some((0xF841, 0x0F00)));
let post_minus = dec(0xF841, 0x0900);
let post_plus = dec(0xF841, 0x0B00);
assert_eq!(post_minus.to_string(), "str r0, [r1], #-0");
assert_eq!(post_plus.to_string(), "str r0, [r1], #0");
assert_eq!(encode(&post_minus), Some((0xF841, 0x0900)));
assert_eq!(encode(&post_plus), Some((0xF841, 0x0B00)));
let off = dec(0xF841, 0x0C00);
assert_eq!(off.to_string(), "str r0, [r1, #-0]");
assert_eq!(encode(&off), Some((0xF841, 0x0C00)));
assert_eq!(dec(0xF8C1, 0x0000).to_string(), "str.w r0, [r1]");
}
#[test]
fn table_a5_21_rows() {
let i = check(0xF881, 0x0020, "strb.w r0, [r1, #32]");
assert_eq!((i.mnemonic, i.encoding), ("strb", "T2"));
let i = check(0xF803, 0x2C05, "strb r2, [r3, #-5]");
assert_eq!((i.mnemonic, i.encoding), ("strb", "T3"));
let i = check(0xF801, 0x0002, "strb.w r0, [r1, r2]");
assert_eq!((i.mnemonic, i.encoding), ("strb", "T2"));
let i = check(0xF8A1, 0x0020, "strh.w r0, [r1, #32]");
assert_eq!((i.mnemonic, i.encoding), ("strh", "T2"));
let i = check(0xF823, 0x2C05, "strh r2, [r3, #-5]");
assert_eq!((i.mnemonic, i.encoding), ("strh", "T3"));
let i = check(0xF821, 0x0002, "strh.w r0, [r1, r2]");
assert_eq!((i.mnemonic, i.encoding), ("strh", "T2"));
let i = check(0xF8C0, 0x3004, "str.w r3, [r0, #4]");
assert_eq!((i.mnemonic, i.encoding), ("str", "T3"));
let i = check(0xF843, 0x2C05, "str r2, [r3, #-5]");
assert_eq!((i.mnemonic, i.encoding), ("str", "T4"));
let i = check(0xF841, 0x0002, "str.w r0, [r1, r2]");
assert_eq!((i.mnemonic, i.encoding), ("str", "T2"));
}
#[test]
fn unprivileged_forms() {
let i = check(0xF803, 0x2E05, "strbt r2, [r3, #5]");
assert_eq!((i.mnemonic, i.encoding), ("strbt", "T1"));
let i = check(0xF823, 0x2E05, "strht r2, [r3, #5]");
assert_eq!((i.mnemonic, i.encoding), ("strht", "T1"));
let i = check(0xF843, 0x2E05, "strt r2, [r3, #5]");
assert_eq!((i.mnemonic, i.encoding), ("strt", "T1"));
check(0xF843, 0x2E00, "strt r2, [r3]");
assert!(!i.explicit_width);
}
#[test]
fn addressing_modes() {
let i = check(0xF841, 0x0C08, "str r0, [r1, #-8]");
assert_eq!(
i.operands.get(1),
Some(Operand::Mem(Mem {
base: Reg(1),
index: None,
offset: 8,
add: false,
align: 0,
mode: AddrMode::Offset,
}))
);
check(0xF841, 0x0F08, "str r0, [r1, #8]!");
check(0xF841, 0x0D08, "str r0, [r1, #-8]!");
check(0xF841, 0x0B08, "str r0, [r1], #8");
check(0xF841, 0x0908, "str r0, [r1], #-8");
check(0xF8C1, 0x0000, "str.w r0, [r1]");
check(0xF8C1, 0x0FFF, "str.w r0, [r1, #4095]");
check(0xF841, 0x0002, "str.w r0, [r1, r2]");
check(0xF841, 0x0032, "str.w r0, [r1, r2, lsl #3]");
}
#[test]
fn offsets_are_unscaled() {
let i = dec(0xF8C1, 0x0004);
assert_eq!(i.to_string(), "str.w r0, [r1, #4]");
assert_eq!(dec(0xF8A1, 0x0004).to_string(), "strh.w r0, [r1, #4]");
assert_eq!(dec(0xF881, 0x0004).to_string(), "strb.w r0, [r1, #4]");
for (hw1, text) in [
(0xF8C1u16, "str.w r0, [r1, #4095]"),
(0xF8A1, "strh.w r0, [r1, #4095]"),
(0xF881, "strb.w r0, [r1, #4095]"),
] {
assert_eq!(dec(hw1, 0x0FFF).to_string(), text);
}
assert_eq!(dec(0xF8C1, 0x0001).to_string(), "str.w r0, [r1, #1]");
assert_eq!(dec(0xF841, 0x0FFF).to_string(), "str r0, [r1, #255]!");
}
#[test]
fn undefined_holes() {
assert!(decode(0xF861, 0x0000, 0).is_none(), "op1 = 011");
assert!(decode(0xF8E1, 0x0000, 0).is_none(), "op1 = 111");
for op1 in 0u16..8 {
let hw1 = 0xF80F | (op1 << 5);
assert!(decode(hw1, 0x0004, 0).is_none(), "{hw1:#06x}: Rn = pc");
assert!(decode(hw1, 0x0C04, 0).is_none(), "{hw1:#06x}: Rn = pc");
}
for u in [0u16, 1] {
let hw2 = 0x0800 | (u << 9) | 4;
assert!(decode(0xF841, hw2, 0).is_none(), "P = 0, W = 0");
}
for op2 in 1u16..0x20 {
let hw2 = op2 << 6;
assert!(decode(0xF841, hw2, 0).is_none(), "op2 = {op2:#08b}");
}
assert!(decode(0xF8C1, 0xF004, 0).is_none(), "str pc, [r1, #4]");
assert!(decode(0xF841, 0xF002, 0).is_none(), "str pc, [r1, r2]");
assert!(decode(0xF801, 0xF004, 0).is_none(), "strb pc, [r1, r2]");
}
#[test]
fn single_register_push() {
let i = check(0xF84D, 0x4D04, "push.w {r4}");
assert_eq!((i.mnemonic, i.encoding), ("push", "T3"));
assert_eq!(i.operands.get(0), Some(Operand::RegList(1 << 4)));
assert_eq!(i.operands.len(), 1);
assert!(!i.writes_pc(), "a push never writes pc");
assert_eq!(dec(0xF84D, 0x4D08).to_string(), "str r4, [sp, #-8]!");
assert_eq!(dec(0xF84C, 0x4D04).to_string(), "str r4, [r12, #-4]!");
assert_eq!(dec(0xF84D, 0x4F04).to_string(), "str r4, [sp, #4]!");
assert_eq!(dec(0xF84D, 0x4904).to_string(), "str r4, [sp], #-4");
assert_eq!(dec(0xF80D, 0x4D04).to_string(), "strb r4, [sp, #-4]!");
}
#[test]
fn unpredictable_but_decoded() {
assert_eq!(dec(0xF881, 0xD004).to_string(), "strb.w sp, [r1, #4]");
assert_eq!(dec(0xF841, 0x000D).to_string(), "str.w r0, [r1, sp]");
assert_eq!(dec(0xF841, 0x000F).to_string(), "str.w r0, [r1, pc]");
assert_eq!(dec(0xF840, 0x0F04).to_string(), "str r0, [r0, #4]!");
}
#[test]
fn encode_rejects_foreign_forms() {
let mut i = dec(0xF8C1, 0x0004);
let mut narrow = i;
narrow.width = Width::Narrow;
assert_eq!(encode(&narrow), None);
let mut flags = i;
flags.sets_flags = true;
assert_eq!(encode(&flags), None);
i.operands = [
Operand::Reg(Reg(0)),
Operand::Mem(Mem {
base: Reg(1),
index: None,
offset: 0x1000,
add: true,
align: 0,
mode: AddrMode::Offset,
}),
]
.iter()
.copied()
.collect();
assert_eq!(encode(&i), None);
let mut t4 = dec(0xF841, 0x0C08);
assert_eq!(encode(&t4), Some((0xF841, 0x0C08)));
t4.operands = [
Operand::Reg(Reg(0)),
Operand::Mem(Mem {
base: Reg(1),
index: None,
offset: 8,
add: true,
align: 0,
mode: AddrMode::Offset,
}),
]
.iter()
.copied()
.collect();
assert_eq!(encode(&t4), None);
let mut zero_shift = dec(0xF841, 0x0002);
zero_shift.operands = [
Operand::Reg(Reg(0)),
Operand::Mem(Mem {
base: Reg(1),
index: Some((
Reg(2),
Some(Shift {
kind: ShiftKind::Lsl,
amount: ShiftAmount::Imm(0),
}),
)),
offset: 0,
add: true,
align: 0,
mode: AddrMode::Offset,
}),
]
.iter()
.copied()
.collect();
assert_eq!(encode(&zero_shift), None);
let mut foreign = dec(0xF8C1, 0x0004);
foreign.mnemonic = "ldr";
assert_eq!(encode(&foreign), None);
let mut wrong_enc = dec(0xF8C1, 0x0004);
wrong_enc.encoding = "T1";
assert_eq!(encode(&wrong_enc), None);
}
#[test]
fn encode_rejects_shapes_the_decoder_cannot_produce() {
fn at(base: u8, offset: u32, add: bool, mode: AddrMode) -> Operand {
Operand::Mem(Mem {
base: Reg(base),
index: None,
offset,
add,
align: 0,
mode,
})
}
fn indexed(base: u8, offset: u32, add: bool, mode: AddrMode) -> Operand {
Operand::Mem(Mem {
base: Reg(base),
index: Some((Reg(2), None)),
offset,
add,
align: 0,
mode,
})
}
let rt = Operand::Reg(Reg(0));
let plain = at(1, 4, true, AddrMode::Offset);
let push = dec(0xF84D, 0x4D04);
let mut t4_push = push;
t4_push.encoding = "T4";
assert_eq!(encode(&t4_push), None, "the single-register push is T3");
assert_eq!(encode(&wide("push", "T3", 0, true, &[])), None, "no list");
assert_eq!(
encode(&wide(
"push",
"T3",
0,
true,
&[Operand::RegList(0x0010), rt]
)),
None,
"push with a spare operand"
);
assert_eq!(encode(&wide("push", "T3", 0, true, &[rt])), None);
assert_eq!(
encode(&wide("push", "T3", 0, true, &[Operand::RegList(0x0030)])),
None,
"two registers is `PUSH` T2, not T3"
);
assert_eq!(
encode(&wide("push", "T3", 0, true, &[Operand::RegList(0x8000)])),
None,
"`pc` cannot be pushed"
);
assert_eq!(
encode(&wide("str", "T3", 0, true, &[plain, rt])),
None,
"the transfer register comes first, then the address"
);
assert_eq!(
encode(&wide("str", "T3", 0, true, &[rt, Operand::Imm(4)])),
None,
"the second operand is an address, not an immediate"
);
assert_eq!(
encode(&wide("str", "T3", 0, true, &[rt, plain, Operand::Imm(0)])),
None,
"a store takes two operands"
);
assert_eq!(
encode(&wide("str", "T3", 0, true, &[Operand::Reg(Reg::PC), plain])),
None,
"`str pc, …` is UNPREDICTABLE"
);
assert_eq!(
encode(&wide(
"str",
"T3",
0,
true,
&[rt, at(15, 4, true, AddrMode::Offset)]
)),
None,
"`Rn == 1111` is UNDEFINED, not a literal store"
);
for (mnemonic, ops, why) in [
(
"strt",
[rt, indexed(1, 0, true, AddrMode::Offset)],
"no unprivileged store takes a register index",
),
(
"strt",
[rt, at(1, 4, true, AddrMode::PreIndex)],
"`U`, `P` and `W` are fixed, so there is no writeback form",
),
(
"strbt",
[rt, at(1, 4, false, AddrMode::Offset)],
"`U == 1` is part of the row; `#-4` and `#-0` are not spellings of it",
),
(
"strht",
[rt, at(1, 0x1_0000, true, AddrMode::Offset)],
"an offset past the end of a u16 must not wrap into the field",
),
(
"strt",
[rt, at(1, 0x100, true, AddrMode::Offset)],
"the field is eight bits",
),
] {
assert_eq!(encode(&wide(mnemonic, "T1", 0, false, &ops)), None, "{why}");
}
let mut t2_strt = dec(0xF803, 0x2E05);
t2_strt.encoding = "T2";
assert_eq!(encode(&t2_strt), None, "the unprivileged forms are T1 only");
for (encoding, mem, why) in [
(
"T3",
indexed(1, 0, true, AddrMode::Offset),
"T2 is its name",
),
(
"T2",
indexed(1, 0, true, AddrMode::PreIndex),
"a register index has no writeback encoding here",
),
(
"T2",
indexed(1, 4, true, AddrMode::Offset),
"there is nowhere to put an immediate beside the index",
),
(
"T2",
indexed(1, 0, false, AddrMode::Offset),
"every register index is added; there is no `U` bit",
),
] {
assert_eq!(
encode(&wide("str", encoding, 0, true, &[rt, mem])),
None,
"{why}"
);
}
for (mem, why) in [
(
at(1, 4, true, AddrMode::PreIndex),
"the 12-bit row has no `P`/`W`; writeback is the 8-bit row",
),
(
at(1, 4, false, AddrMode::Offset),
"the 12-bit field has no `U` beside it and cannot subtract",
),
(
at(1, 0x1_0000, true, AddrMode::Offset),
"an offset past the end of a u16 must not wrap into the field",
),
] {
assert_eq!(
encode(&wide("str", "T3", 0, true, &[rt, mem])),
None,
"{why}"
);
}
for (mem, why) in [
(
at(1, 0x1_0000, false, AddrMode::Offset),
"an offset past the end of a u16 must not wrap into the field",
),
(
at(1, 0x100, false, AddrMode::PreIndex),
"the field is eight bits",
),
(
at(1, 4, false, AddrMode::PostIncrement),
"`[rn]!` with an implicit increment is Advanced SIMD's mode, not a store's",
),
] {
assert_eq!(
encode(&wide("str", "T4", 0, false, &[rt, mem])),
None,
"{why}"
);
}
}
#[test]
fn decode_refuses_halfwords_outside_the_group() {
for hw1 in [0x0000u16, 0x4770, 0xE800, 0xF000] {
assert!(decode(hw1, 0x0004, 0).is_none(), "{hw1:#06x}");
}
assert!(decode(0xF900, 0x0004, 0).is_none());
assert!(decode(0xFB00, 0x0004, 0).is_none());
assert!(decode(0xF8D1, 0x0004, 0).is_none(), "that is an `ldr`");
assert!(decode(0xF811, 0x0004, 0).is_none(), "that is an `ldrb`");
}
#[test]
fn reachable_through_the_dispatcher() {
for (hw1, hw2, text) in [
(0xF8C0u16, 0x3004u16, "str.w r3, [r0, #4]"),
(0xF84D, 0x4D04, "push.w {r4}"),
(0xF803, 0x2E05, "strbt r2, [r3, #5]"),
(0xF821, 0x0032, "strh.w r0, [r1, r2, lsl #3]"),
] {
let routed = super::super::decode_halfwords(hw1, hw2, 0x1000, Target::Union);
assert!(
routed.is_some(),
"{hw1:#06x} {hw2:#06x} did not reach this module"
);
let insn = routed.unwrap();
assert_eq!(insn.to_string(), text);
assert_eq!(insn.width, Width::Wide);
}
}
#[test]
fn classification() {
for (hw1, hw2) in [
(0xF8C1u16, 0x0004u16),
(0xF841, 0x0C08),
(0xF843, 0x2E05),
(0xF84D, 0x4D04),
] {
let i = dec(hw1, hw2);
assert!(!i.is_branch(), "`{i}` is not a branch");
assert!(!i.writes_pc(), "`{i}` does not write pc");
assert!(!i.is_call(), "`{i}` is not a call");
assert!(!i.sets_flags, "`{i}` does not set flags");
assert_eq!(i.len(), 4);
}
}
}