use super::{Insn, Operand, Operands, Reg, Shift, ShiftAmount, ShiftKind, Width};
const GROUP: u16 = 0b1111_1010;
const RN_NONE: u8 = 0b1111;
const SHIFTS: [&str; 4] = [
"lsl", "lsr", "asr", "ror", ];
const EXTENDS: [(&str, &str); 6] = [
("sxtah", "sxth"), ("uxtah", "uxth"), ("sxtab16", "sxtb16"), ("uxtab16", "uxtb16"), ("sxtab", "sxtb"), ("uxtab", "uxtb"), ];
const PARALLEL: [[[&str; 8]; 3]; 2] = [
[
["sadd8", "sadd16", "sasx", "", "ssub8", "ssub16", "ssax", ""],
["qadd8", "qadd16", "qasx", "", "qsub8", "qsub16", "qsax", ""],
[
"shadd8", "shadd16", "shasx", "", "shsub8", "shsub16", "shsax", "",
],
],
[
["uadd8", "uadd16", "uasx", "", "usub8", "usub16", "usax", ""],
[
"uqadd8", "uqadd16", "uqasx", "", "uqsub8", "uqsub16", "uqsax", "",
],
[
"uhadd8", "uhadd16", "uhasx", "", "uhsub8", "uhsub16", "uhsax", "",
],
],
];
const MISC: [[&str; 4]; 4] = [
["qadd", "qdadd", "qsub", "qdsub"], ["rev", "rev16", "rbit", "revsh"], ["sel", "", "", ""], ["clz", "", "", ""], ];
fn has_narrow_counterpart(mnemonic: &str) -> bool {
matches!(
mnemonic,
"lsl"
| "lsr"
| "asr"
| "ror"
| "sxtb"
| "sxth"
| "uxtb"
| "uxth"
| "rev"
| "rev16"
| "revsh"
)
}
fn encoding_name(mnemonic: &str) -> &'static str {
if has_narrow_counterpart(mnemonic) {
"T2"
} else {
"T1"
}
}
fn extended_operand(rm: Reg, rotate: u8) -> Operand {
if rotate == 0 {
Operand::Reg(rm)
} else {
Operand::RegShifted(
rm,
Shift {
kind: ShiftKind::Ror,
amount: ShiftAmount::Imm(rotate * 8),
},
)
}
}
pub(crate) fn decode(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw1 >> 8 != GROUP {
return None;
}
if hw2 >> 12 != 0b1111 {
return None;
}
let op1 = ((hw1 >> 4) & 0xF) as u8;
let rn = Reg((hw1 & 0xF) as u8);
let rd = Reg(((hw2 >> 8) & 0xF) as u8);
let op2 = ((hw2 >> 4) & 0xF) as u8;
let rm = Reg((hw2 & 0xF) as u8);
let mut operands = Operands::new();
operands.push(Operand::Reg(rd));
let mut sets_flags = false;
let mnemonic = if op1 & 0b1000 == 0 {
if op2 == 0b0000 {
sets_flags = op1 & 1 == 1;
operands.push(Operand::Reg(rn));
operands.push(Operand::Reg(rm));
SHIFTS[(op1 >> 1) as usize]
} else if op2 & 0b1000 != 0 {
let (and_add, plain) = *EXTENDS.get(op1 as usize)?;
if op2 & 0b0100 != 0 {
return None;
}
let rotated = extended_operand(rm, op2 & 0b11);
if rn.num() == RN_NONE {
operands.push(rotated);
plain
} else {
operands.push(Operand::Reg(rn));
operands.push(rotated);
and_add
}
} else {
return None;
}
} else if op2 & 0b1000 == 0 {
let variant = op2 & 0b11;
if variant == 0b11 {
return None;
}
let mnemonic =
PARALLEL[((op2 >> 2) & 1) as usize][variant as usize][(op1 & 0b111) as usize];
if mnemonic.is_empty() {
return None;
}
operands.push(Operand::Reg(rn));
operands.push(Operand::Reg(rm));
mnemonic
} else if op1 & 0b0100 == 0 && op2 & 0b0100 == 0 {
let row = (op1 & 0b11) as usize;
let mnemonic = MISC[row][(op2 & 0b11) as usize];
if mnemonic.is_empty() {
return None;
}
match row {
0 => {
operands.push(Operand::Reg(rm));
operands.push(Operand::Reg(rn));
}
2 => {
operands.push(Operand::Reg(rn));
operands.push(Operand::Reg(rm));
}
_ => {
if rn != rm {
return None;
}
operands.push(Operand::Reg(rm));
}
}
mnemonic
} else {
return None;
};
Some(Insn {
mnemonic,
encoding: encoding_name(mnemonic),
addr,
width: Width::Wide,
cond: None,
sets_flags,
explicit_width: has_narrow_counterpart(mnemonic),
operands,
})
}
fn reg(insn: &Insn, i: usize) -> Option<Reg> {
match insn.operands.get(i)? {
Operand::Reg(r) if r.0 < 16 => Some(r),
_ => None,
}
}
fn rotated_operand(insn: &Insn, i: usize) -> Option<(Reg, u16)> {
match insn.operands.get(i)? {
Operand::Reg(r) if r.0 < 16 => Some((r, 0)),
Operand::RegShifted(
r,
Shift {
kind: ShiftKind::Ror,
amount: ShiftAmount::Imm(n),
},
) if r.0 < 16 && matches!(n, 8 | 16 | 24) => Some((r, (n / 8) as u16)),
_ => None,
}
}
fn assemble(insn: &Insn, op1: u16, rn: Reg, rd: Reg, op2: u16, rm: Reg) -> Option<(u16, u16)> {
if insn.encoding != encoding_name(insn.mnemonic)
|| insn.explicit_width != has_narrow_counterpart(insn.mnemonic)
{
return None;
}
Some((
GROUP << 8 | op1 << 4 | u16::from(rn.num()),
0xF000 | u16::from(rd.num()) << 8 | op2 << 4 | u16::from(rm.num()),
))
}
pub(crate) fn encode(insn: &Insn) -> Option<(u16, u16)> {
if insn.width != Width::Wide || insn.mnemonic.is_empty() {
return None;
}
if let Some(i) = SHIFTS.iter().position(|m| *m == insn.mnemonic) {
if insn.operands.len() > 3 {
return None;
}
let (rd, rn, rm) = (reg(insn, 0)?, reg(insn, 1)?, reg(insn, 2)?);
let op1 = (i as u16) << 1 | u16::from(insn.sets_flags);
return assemble(insn, op1, rn, rd, 0b0000, rm);
}
if insn.sets_flags {
return None;
}
for (op1, (and_add, plain)) in EXTENDS.iter().enumerate() {
if insn.mnemonic == *and_add {
if insn.operands.len() > 3 {
return None;
}
let rd = reg(insn, 0)?;
let rn = reg(insn, 1)?;
if rn.num() == RN_NONE {
return None;
}
let (rm, rotate) = rotated_operand(insn, 2)?;
return assemble(insn, op1 as u16, rn, rd, 0b1000 | rotate, rm);
}
if insn.mnemonic == *plain {
if insn.operands.len() > 2 {
return None;
}
let rd = reg(insn, 0)?;
let (rm, rotate) = rotated_operand(insn, 1)?;
return assemble(insn, op1 as u16, Reg(RN_NONE), rd, 0b1000 | rotate, rm);
}
}
for (signedness, table) in PARALLEL.iter().enumerate() {
for (variant, row) in table.iter().enumerate() {
let found = row.iter().position(|m| *m == insn.mnemonic);
if let Some(op) = found {
if insn.operands.len() > 3 {
return None;
}
let (rd, rn, rm) = (reg(insn, 0)?, reg(insn, 1)?, reg(insn, 2)?);
let op2 = (signedness as u16) << 2 | variant as u16;
return assemble(insn, 0b1000 | op as u16, rn, rd, op2, rm);
}
}
}
for (row, names) in MISC.iter().enumerate() {
let found = names.iter().position(|m| *m == insn.mnemonic);
if let Some(col) = found {
let rd = reg(insn, 0)?;
let (rn, rm) = match row {
0 => {
if insn.operands.len() > 3 {
return None;
}
(reg(insn, 2)?, reg(insn, 1)?)
}
2 => {
if insn.operands.len() > 3 {
return None;
}
(reg(insn, 1)?, reg(insn, 2)?)
}
_ => {
if insn.operands.len() > 2 {
return None;
}
let r = reg(insn, 1)?;
(r, r)
}
};
return assemble(insn, 0b1000 | row as u16, rn, rd, 0b1000 | col as u16, rm);
}
}
None
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn every_register_field_survives_a_round_trip() {
let mut checked = 0usize;
for rd in 0..16u16 {
for r in 0..16u16 {
let (hw1, hw2) = hw(0b1011, r, rd, 0b1000, r);
let decoded = decode(hw1, hw2, 0);
assert!(
decoded.is_some(),
"{hw1:#06x} {hw2:#06x} is `clz r{rd}, r{r}` and must decode"
);
let insn = decoded.unwrap();
assert_eq!(
encode(&insn),
Some((hw1, hw2)),
"round-trip of {hw1:#06x} {hw2:#06x} ({insn})"
);
assert_eq!(
insn.operands.get(0),
Some(Operand::Reg(Reg(rd as u8))),
"Rd must decode from hw2[11:8], not hw2[15:12]"
);
checked += 1;
}
}
assert_eq!(checked, 256, "every (Rd, Rn==Rm) pair should decode");
}
fn hw(op1: u16, rn: u16, rd: u16, op2: u16, rm: u16) -> (u16, u16) {
(GROUP << 8 | op1 << 4 | rn, 0xF000 | rd << 8 | op2 << 4 | rm)
}
fn ual(op1: u16, rn: u16, rd: u16, op2: u16, rm: u16) -> String {
let (hw1, hw2) = hw(op1, rn, rd, op2, rm);
let decoded = decode(hw1, hw2, 0);
assert!(
decoded.is_some(),
"{hw1:#06x} {hw2:#06x} should be a defined encoding"
);
decoded.unwrap().to_string()
}
fn classify(op1: u16, op2: u16, rn: u16, rm: u16) -> Result<&'static str, &'static str> {
match (op1, op2) {
(0..=7, 0) => Ok("shift"),
(0..=7, 1..=7) => Err("A5-24: op1 0xxx allocates op2 0000 and 1xxx only"),
(0..=5, 8..=11) => Ok("extend"),
(0..=5, 12..=15) => Err("hw2[6] is (0) in the extends: UNPREDICTABLE, not encodable"),
(6..=7, 8..=15) => Err("A5-24: rows 011x have no extend"),
(8..=15, 0..=7) => {
if op2 & 0b11 == 0b11 {
Err("A5-25/26: no op2 11 variant")
} else if op1 & 0b111 == 0b011 || op1 & 0b111 == 0b111 {
Err("A5-25/26: no op1 011 or 111 row")
} else {
Ok("parallel")
}
}
(8..=11, 8..=11) => {
if MISC[(op1 & 0b11) as usize][(op2 & 0b11) as usize].is_empty() {
Err("A5-27: unallocated op1/op2")
} else if matches!(op1 & 0b11, 0b01 | 0b11) && rn != rm {
Err("Consistent(Rm): the source register is encoded twice")
} else {
Ok("misc")
}
}
(12..=15, 8..=11) => Err("A5-24: the miscellaneous table needs op1 10xx"),
_ => Err("A5-24: op2 11xx is unallocated"),
}
}
#[test]
fn encode_rejects_every_mangled_operand_slot() {
for (op1, rn, rd, op2, rm) in [
(0b0000u16, 1u16, 3u16, 0b0000u16, 2u16), (0b0111, 1, 7, 0b0000, 2), (0b0000, 1, 3, 0b1000, 2), (0b0000, 1, 9, 0b1011, 2), (0b0000, 15, 3, 0b1000, 2), (0b0101, 15, 12, 0b1010, 2), (0b1000, 1, 3, 0b0000, 2), (0b1000, 1, 3, 0b1000, 2), (0b1001, 1, 3, 0b1000, 1), (0b1010, 1, 3, 0b1000, 2), (0b1011, 1, 3, 0b1000, 1), ] {
let (hw1, hw2) = hw(op1, rn, rd, op2, rm);
let insn = decode(hw1, hw2, 0).unwrap();
assert_eq!(
insn.operands.get(0),
Some(Operand::Reg(Reg(rd as u8))),
"{hw1:#06x} {hw2:#06x}: Rd comes from hw2[11:8]"
);
assert_eq!(
encode(&insn),
Some((hw1, hw2)),
"`{insn}` should round-trip before anything is mangled"
);
let arity = insn.operands.len();
for slot in 0..arity {
let mut mangled = insn;
mangled.operands = (0..arity)
.map(|i| {
if i == slot {
Operand::Imm(0)
} else {
insn.operands.get(i).unwrap()
}
})
.collect();
assert_eq!(encode(&mangled), None, "`{insn}`, operand {slot} mangled");
}
let (fewer, more) = (arity - 1, arity + 1);
let mut short = insn;
short.operands = (0..fewer).map(|i| insn.operands.get(i).unwrap()).collect();
assert_eq!(encode(&short), None, "`{insn}` with {fewer} operands");
let mut long = insn;
long.operands = (0..more)
.map(|i| insn.operands.get(i).unwrap_or(Operand::Reg(Reg(3))))
.collect();
assert_eq!(encode(&long), None, "`{insn}` with {more} operands");
let mut empty = insn;
empty.operands = Operands::new();
assert_eq!(encode(&empty), None, "`{insn}` with no operands");
}
}
#[test]
fn exhaustive_round_trip_and_allocation_census() {
let rns = [0u16, 1, 15];
let rds = [0u16, 15];
let rms = [0u16, 15];
let mut total = 0usize;
let mut decoded = 0usize;
let mut shift = 0usize;
let mut extend = 0usize;
let mut extend_plain = 0usize;
let mut parallel = 0usize;
let mut misc = 0usize;
let mut reasons: Vec<(&str, usize)> = Vec::new();
for op1 in 0..16u16 {
for op2 in 0..16u16 {
for rn in rns {
for rd in rds {
for rm in rms {
total += 1;
let (hw1, hw2) = hw(op1, rn, rd, op2, rm);
let got = decode(hw1, hw2, 0);
match classify(op1, op2, rn, rm) {
Ok(table) => {
assert!(
got.is_some(),
"{hw1:#06x} {hw2:#06x} is a {table}, yet did not decode"
);
let insn = got.unwrap();
decoded += 1;
match table {
"shift" => shift += 1,
"extend" => {
extend += 1;
if insn.operands.len() == 2 {
extend_plain += 1;
}
}
"parallel" => parallel += 1,
_ => misc += 1,
}
assert_eq!(insn.width, Width::Wide, "{hw1:#06x} {hw2:#06x}");
assert_eq!(insn.len(), 4, "{hw1:#06x} {hw2:#06x}");
assert_eq!(insn.addr, 0, "{hw1:#06x} {hw2:#06x}");
assert!(insn.cond.is_none(), "{hw1:#06x} {hw2:#06x}");
assert_eq!(
insn.sets_flags,
table == "shift" && op1 & 1 == 1,
"{hw1:#06x} {hw2:#06x} flag suffix"
);
assert_eq!(
encode(&insn),
Some((hw1, hw2)),
"round-trip of {hw1:#06x} {hw2:#06x} ({insn})"
);
}
Err(why) => {
assert!(
got.is_none(),
"{hw1:#06x} {hw2:#06x} decoded, but the manual says: {why}"
);
match reasons.iter_mut().find(|r| r.0 == why) {
Some(r) => r.1 += 1,
None => reasons.push((why, 1)),
}
}
}
for top in 0..16u16 {
if top == 0b1111 {
continue;
}
let spoiled = (hw2 & 0x0FFF) | (top << 12);
assert!(
decode(hw1, spoiled, 0).is_none(),
"{hw1:#06x} {spoiled:#06x} must be UNDEFINED"
);
}
}
}
}
}
}
assert_eq!(total, 3072);
assert_eq!(shift, 96);
assert_eq!(extend, 288);
assert_eq!(extend_plain, 96);
assert_eq!(extend - extend_plain, 192);
assert_eq!(parallel, 432);
assert_eq!(misc, 80);
assert_eq!(decoded, shift + extend + parallel + misc);
assert_eq!(decoded, 896);
reasons.sort_unstable();
assert_eq!(
reasons,
vec![
("A5-24: op1 0xxx allocates op2 0000 and 1xxx only", 672),
("A5-24: op2 11xx is unallocated", 384),
("A5-24: rows 011x have no extend", 192),
("A5-24: the miscellaneous table needs op1 10xx", 192),
("A5-25/26: no op1 011 or 111 row", 144),
("A5-25/26: no op2 11 variant", 192),
("A5-27: unallocated op1/op2", 72),
("Consistent(Rm): the source register is encoded twice", 40),
(
"hw2[6] is (0) in the extends: UNPREDICTABLE, not encodable",
288
),
]
);
assert_eq!(
reasons.iter().map(|r| r.1).sum::<usize>(),
total - decoded,
"every non-decoding combination is attributed exactly once"
);
assert_eq!(total - decoded, 2176);
}
#[test]
fn second_halfword_must_name_all_ones() {
let (hw1, hw2) = hw(0b0000, 1, 0, 0b0000, 2); assert!(decode(hw1, hw2, 0).is_some());
for top in 0..16u16 {
let spoiled = (hw2 & 0x0FFF) | (top << 12);
assert_eq!(
decode(hw1, spoiled, 0).is_some(),
top == 0b1111,
"hw2 top nibble {top:#x}"
);
}
assert!(decode(0xF901, hw2, 0).is_none());
assert!(decode(0xFB01, hw2, 0).is_none());
}
#[test]
fn table_a5_24_shifts_print_ual() {
assert_eq!(ual(0b0000, 1, 0, 0b0000, 2), "lsl.w r0, r1, r2");
assert_eq!(ual(0b0001, 1, 0, 0b0000, 2), "lsls.w r0, r1, r2");
assert_eq!(ual(0b0010, 1, 0, 0b0000, 2), "lsr.w r0, r1, r2");
assert_eq!(ual(0b0011, 1, 0, 0b0000, 2), "lsrs.w r0, r1, r2");
assert_eq!(ual(0b0100, 1, 0, 0b0000, 2), "asr.w r0, r1, r2");
assert_eq!(ual(0b0101, 1, 0, 0b0000, 2), "asrs.w r0, r1, r2");
assert_eq!(ual(0b0110, 1, 0, 0b0000, 2), "ror.w r0, r1, r2");
assert_eq!(ual(0b0111, 1, 0, 0b0000, 2), "rors.w r0, r1, r2");
}
#[test]
fn table_a5_24_extends_print_ual() {
assert_eq!(ual(0b0000, 1, 0, 0b1000, 2), "sxtah r0, r1, r2");
assert_eq!(ual(0b0000, 15, 0, 0b1000, 2), "sxth.w r0, r2");
assert_eq!(ual(0b0001, 1, 0, 0b1000, 2), "uxtah r0, r1, r2");
assert_eq!(ual(0b0001, 15, 0, 0b1000, 2), "uxth.w r0, r2");
assert_eq!(ual(0b0010, 1, 0, 0b1000, 2), "sxtab16 r0, r1, r2");
assert_eq!(ual(0b0010, 15, 0, 0b1000, 2), "sxtb16 r0, r2");
assert_eq!(ual(0b0011, 1, 0, 0b1000, 2), "uxtab16 r0, r1, r2");
assert_eq!(ual(0b0011, 15, 0, 0b1000, 2), "uxtb16 r0, r2");
assert_eq!(ual(0b0100, 1, 0, 0b1000, 2), "sxtab r0, r1, r2");
assert_eq!(ual(0b0100, 15, 0, 0b1000, 2), "sxtb.w r0, r2");
assert_eq!(ual(0b0101, 1, 0, 0b1000, 2), "uxtab r0, r1, r2");
assert_eq!(ual(0b0101, 15, 0, 0b1000, 2), "uxtb.w r0, r2");
}
#[test]
fn table_a5_25_signed_parallel_prints_ual() {
assert_eq!(ual(0b1000, 1, 0, 0b0000, 2), "sadd8 r0, r1, r2");
assert_eq!(ual(0b1001, 1, 0, 0b0000, 2), "sadd16 r0, r1, r2");
assert_eq!(ual(0b1010, 1, 0, 0b0000, 2), "sasx r0, r1, r2");
assert_eq!(ual(0b1100, 1, 0, 0b0000, 2), "ssub8 r0, r1, r2");
assert_eq!(ual(0b1101, 1, 0, 0b0000, 2), "ssub16 r0, r1, r2");
assert_eq!(ual(0b1110, 1, 0, 0b0000, 2), "ssax r0, r1, r2");
assert_eq!(ual(0b1000, 1, 0, 0b0001, 2), "qadd8 r0, r1, r2");
assert_eq!(ual(0b1001, 1, 0, 0b0001, 2), "qadd16 r0, r1, r2");
assert_eq!(ual(0b1010, 1, 0, 0b0001, 2), "qasx r0, r1, r2");
assert_eq!(ual(0b1100, 1, 0, 0b0001, 2), "qsub8 r0, r1, r2");
assert_eq!(ual(0b1101, 1, 0, 0b0001, 2), "qsub16 r0, r1, r2");
assert_eq!(ual(0b1110, 1, 0, 0b0001, 2), "qsax r0, r1, r2");
assert_eq!(ual(0b1000, 1, 0, 0b0010, 2), "shadd8 r0, r1, r2");
assert_eq!(ual(0b1001, 1, 0, 0b0010, 2), "shadd16 r0, r1, r2");
assert_eq!(ual(0b1010, 1, 0, 0b0010, 2), "shasx r0, r1, r2");
assert_eq!(ual(0b1100, 1, 0, 0b0010, 2), "shsub8 r0, r1, r2");
assert_eq!(ual(0b1101, 1, 0, 0b0010, 2), "shsub16 r0, r1, r2");
assert_eq!(ual(0b1110, 1, 0, 0b0010, 2), "shsax r0, r1, r2");
}
#[test]
fn table_a5_26_unsigned_parallel_prints_ual() {
assert_eq!(ual(0b1000, 1, 0, 0b0100, 2), "uadd8 r0, r1, r2");
assert_eq!(ual(0b1001, 1, 0, 0b0100, 2), "uadd16 r0, r1, r2");
assert_eq!(ual(0b1010, 1, 0, 0b0100, 2), "uasx r0, r1, r2");
assert_eq!(ual(0b1100, 1, 0, 0b0100, 2), "usub8 r0, r1, r2");
assert_eq!(ual(0b1101, 1, 0, 0b0100, 2), "usub16 r0, r1, r2");
assert_eq!(ual(0b1110, 1, 0, 0b0100, 2), "usax r0, r1, r2");
assert_eq!(ual(0b1000, 1, 0, 0b0101, 2), "uqadd8 r0, r1, r2");
assert_eq!(ual(0b1001, 1, 0, 0b0101, 2), "uqadd16 r0, r1, r2");
assert_eq!(ual(0b1010, 1, 0, 0b0101, 2), "uqasx r0, r1, r2");
assert_eq!(ual(0b1100, 1, 0, 0b0101, 2), "uqsub8 r0, r1, r2");
assert_eq!(ual(0b1101, 1, 0, 0b0101, 2), "uqsub16 r0, r1, r2");
assert_eq!(ual(0b1110, 1, 0, 0b0101, 2), "uqsax r0, r1, r2");
assert_eq!(ual(0b1000, 1, 0, 0b0110, 2), "uhadd8 r0, r1, r2");
assert_eq!(ual(0b1001, 1, 0, 0b0110, 2), "uhadd16 r0, r1, r2");
assert_eq!(ual(0b1010, 1, 0, 0b0110, 2), "uhasx r0, r1, r2");
assert_eq!(ual(0b1100, 1, 0, 0b0110, 2), "uhsub8 r0, r1, r2");
assert_eq!(ual(0b1101, 1, 0, 0b0110, 2), "uhsub16 r0, r1, r2");
assert_eq!(ual(0b1110, 1, 0, 0b0110, 2), "uhsax r0, r1, r2");
}
#[test]
fn table_a5_27_misc_prints_ual() {
assert_eq!(ual(0b1000, 1, 0, 0b1000, 2), "qadd r0, r2, r1");
assert_eq!(ual(0b1000, 1, 0, 0b1001, 2), "qdadd r0, r2, r1");
assert_eq!(ual(0b1000, 1, 0, 0b1010, 2), "qsub r0, r2, r1");
assert_eq!(ual(0b1000, 1, 0, 0b1011, 2), "qdsub r0, r2, r1");
assert_eq!(ual(0b1001, 2, 0, 0b1000, 2), "rev.w r0, r2");
assert_eq!(ual(0b1001, 2, 0, 0b1001, 2), "rev16.w r0, r2");
assert_eq!(ual(0b1001, 2, 0, 0b1010, 2), "rbit r0, r2");
assert_eq!(ual(0b1001, 2, 0, 0b1011, 2), "revsh.w r0, r2");
assert_eq!(ual(0b1010, 1, 0, 0b1000, 2), "sel r0, r1, r2");
assert_eq!(ual(0b1011, 2, 0, 0b1000, 2), "clz r0, r2");
}
#[test]
fn rn_1111_switches_each_extend_to_its_plain_form() {
let pairs = [
(0b0000u16, "sxtah", "sxth"),
(0b0001, "uxtah", "uxth"),
(0b0010, "sxtab16", "sxtb16"),
(0b0011, "uxtab16", "uxtb16"),
(0b0100, "sxtab", "sxtb"),
(0b0101, "uxtab", "uxtb"),
];
for (op1, and_add, plain) in pairs {
let (hw1, hw2) = hw(op1, 14, 0, 0b1000, 2);
let with_add = decode(hw1, hw2, 0).unwrap();
let (hw1_p, hw2_p) = hw(op1, 15, 0, 0b1000, 2);
let without = decode(hw1_p, hw2_p, 0).unwrap();
assert_eq!(with_add.mnemonic, and_add, "op1 {op1:04b}");
assert_eq!(without.mnemonic, plain, "op1 {op1:04b}");
assert_ne!(with_add.mnemonic, without.mnemonic);
assert_eq!(with_add.operands.len(), 3, "{and_add}");
assert_eq!(with_add.operands.get(1), Some(Operand::Reg(Reg::LR)));
assert_eq!(without.operands.len(), 2, "{plain}");
assert_eq!(encode(&with_add), Some((hw1, hw2)));
assert_eq!(encode(&without), Some((hw1_p, hw2_p)));
let mut impostor = with_add;
impostor.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg::PC),
Operand::Reg(Reg(2)),
]
.into_iter()
.collect();
assert_eq!(encode(&impostor), None, "{and_add} with Rn = pc");
}
}
#[test]
fn extend_rotation_is_omitted_when_zero() {
assert_eq!(ual(0b0000, 15, 0, 0b1000, 2), "sxth.w r0, r2");
assert_eq!(ual(0b0000, 15, 0, 0b1001, 2), "sxth.w r0, r2, ror #8");
assert_eq!(ual(0b0000, 15, 0, 0b1010, 2), "sxth.w r0, r2, ror #16");
assert_eq!(ual(0b0000, 15, 0, 0b1011, 2), "sxth.w r0, r2, ror #24");
assert_eq!(ual(0b0100, 1, 0, 0b1000, 2), "sxtab r0, r1, r2");
assert_eq!(ual(0b0100, 1, 0, 0b1011, 2), "sxtab r0, r1, r2, ror #24");
for op2 in [0b1000u16, 0b1001, 0b1010, 0b1011] {
let (hw1, hw2) = hw(0b0000, 15, 0, op2, 2);
let insn = decode(hw1, hw2, 0).unwrap();
let expected = if op2 == 0b1000 {
Operand::Reg(Reg(2))
} else {
Operand::RegShifted(
Reg(2),
Shift {
kind: ShiftKind::Ror,
amount: ShiftAmount::Imm(((op2 & 0b11) * 8) as u8),
},
)
};
assert_eq!(insn.operands.get(1), Some(expected), "op2 {op2:04b}");
assert_eq!(encode(&insn), Some((hw1, hw2)), "round-trip of rotate");
}
let mut zero_ror = decode(GROUP << 8 | 0x0F, 0xF082, 0).unwrap();
zero_ror.operands = [
Operand::Reg(Reg(0)),
Operand::RegShifted(
Reg(2),
Shift {
kind: ShiftKind::Ror,
amount: ShiftAmount::Imm(0),
},
),
]
.into_iter()
.collect();
assert_eq!(encode(&zero_ror), None);
}
#[test]
fn the_parallel_grid_is_three_variants_by_six_operations() {
let op1s = [0b1000u16, 0b1001, 0b1010, 0b1100, 0b1101, 0b1110];
let signed: [[&str; 6]; 3] = [
["sadd8", "sadd16", "sasx", "ssub8", "ssub16", "ssax"],
["qadd8", "qadd16", "qasx", "qsub8", "qsub16", "qsax"],
["shadd8", "shadd16", "shasx", "shsub8", "shsub16", "shsax"],
];
let unsigned: [[&str; 6]; 3] = [
["uadd8", "uadd16", "uasx", "usub8", "usub16", "usax"],
["uqadd8", "uqadd16", "uqasx", "uqsub8", "uqsub16", "uqsax"],
["uhadd8", "uhadd16", "uhasx", "uhsub8", "uhsub16", "uhsax"],
];
let mut seen = 0usize;
for (table, base) in [(signed, 0b0000u16), (unsigned, 0b0100)] {
for (variant, row) in table.iter().enumerate() {
for (i, expected) in row.iter().enumerate() {
let op2 = base | variant as u16;
let op1 = op1s[i];
let (hw1, hw2) = hw(op1, 1, 0, op2, 2);
let insn = decode(hw1, hw2, 0).expect("allocated cell");
assert_eq!(insn.mnemonic, *expected, "op1 {op1:04b} op2 {op2:04b}");
assert_eq!(insn.operands.len(), 3);
assert_eq!(insn.operands.get(0), Some(Operand::Reg(Reg(0))));
assert_eq!(insn.operands.get(1), Some(Operand::Reg(Reg(1))));
assert_eq!(insn.operands.get(2), Some(Operand::Reg(Reg(2))));
assert!(!insn.sets_flags, "{expected} writes GE or Q, not NZCV");
assert_eq!(insn.encoding, "T1");
assert!(!insn.explicit_width, "{expected} has no narrow form");
assert_eq!(encode(&insn), Some((hw1, hw2)));
seen += 1;
}
}
for i in [0b1011u16, 0b1111] {
assert!(decode(hw(i, 1, 0, base, 2).0, hw(i, 1, 0, base, 2).1, 0).is_none());
}
assert!(decode(
hw(0b1001, 1, 0, base | 0b11, 2).0,
hw(0b1001, 1, 0, base | 0b11, 2).1,
0
)
.is_none());
}
assert_eq!(seen, 36, "two tables x three variants x six operations");
}
#[test]
fn reverse_and_clz_need_their_source_register_twice() {
for op2 in [0b1000u16, 0b1001, 0b1010, 0b1011] {
assert!(decode(hw(0b1001, 2, 0, op2, 2).0, hw(0b1001, 2, 0, op2, 2).1, 0).is_some());
let (hw1, hw2) = hw(0b1001, 3, 0, op2, 2);
assert!(decode(hw1, hw2, 0).is_none(), "{hw1:#06x} {hw2:#06x}");
}
let (hw1, hw2) = hw(0b1011, 3, 0, 0b1000, 2); assert!(decode(hw1, hw2, 0).is_none());
assert!(decode(
hw(0b1010, 3, 0, 0b1000, 2).0,
hw(0b1010, 3, 0, 0b1000, 2).1,
0
)
.is_some());
assert!(decode(
hw(0b1000, 3, 0, 0b1000, 2).0,
hw(0b1000, 3, 0, 0b1000, 2).1,
0
)
.is_some());
}
#[test]
fn only_the_shifts_carry_a_flag_bit() {
for op1 in [0b0000u16, 0b0010, 0b0100, 0b0110] {
assert!(
!decode(hw(op1, 1, 0, 0, 2).0, hw(op1, 1, 0, 0, 2).1, 0)
.unwrap()
.sets_flags
);
assert!(
decode(hw(op1 | 1, 1, 0, 0, 2).0, hw(op1 | 1, 1, 0, 0, 2).1, 0)
.unwrap()
.sets_flags
);
}
let (hw1, hw2) = hw(0b1001, 1, 0, 0b0001, 2); let insn = decode(hw1, hw2, 0).unwrap();
assert_eq!(insn.to_string(), "qadd16 r0, r1, r2");
let mut flagged = insn;
flagged.sets_flags = true;
assert_eq!(flagged.to_string(), "qadd16s r0, r1, r2");
assert_eq!(encode(&flagged), None);
}
#[test]
fn encode_rejects_what_this_group_does_not_own() {
let base = decode(hw(0b0000, 1, 0, 0, 2).0, hw(0b0000, 1, 0, 0, 2).1, 0).unwrap();
let mut foreign = base;
foreign.mnemonic = "add";
assert_eq!(encode(&foreign), None);
let mut blank = base;
blank.mnemonic = "";
assert_eq!(encode(&blank), None);
let mut narrow = base;
narrow.width = Width::Narrow;
assert_eq!(encode(&narrow), None);
let mut unsuffixed = base;
unsuffixed.explicit_width = false;
assert_eq!(encode(&unsuffixed), None);
let mut wrong_encoding = base;
wrong_encoding.encoding = "T3";
assert_eq!(encode(&wrong_encoding), None);
let mut immediate = base;
immediate.operands = [Operand::Reg(Reg(0)), Operand::Reg(Reg(1)), Operand::Imm(3)]
.into_iter()
.collect();
assert_eq!(encode(&immediate), None);
let mut short_shift = base;
short_shift.operands = [Operand::Reg(Reg(0)), Operand::Reg(Reg(1))]
.into_iter()
.collect();
assert_eq!(encode(&short_shift), None);
let mut wide_reg = base;
wide_reg.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Reg(Reg(16)),
]
.into_iter()
.collect();
assert_eq!(encode(&wide_reg), None, "Rm of a shift is four bits");
let (h1, h2) = hw(0b0000, RN_NONE.into(), 0, 0b1000, 1); let sxth = decode(h1, h2, 0).unwrap();
assert_eq!(sxth.to_string(), "sxth.w r0, r1");
assert_eq!(encode(&sxth), Some((h1, h2)));
let ror8 = Shift {
kind: ShiftKind::Ror,
amount: ShiftAmount::Imm(8),
};
for (operands, why) in [
(
[Operand::Reg(Reg(0)), Operand::Reg(Reg(16))],
"a bare Rm is four bits",
),
(
[Operand::Reg(Reg(0)), Operand::RegShifted(Reg(16), ror8)],
"a rotated Rm is four bits",
),
] {
let mut bad = sxth;
bad.operands = operands.into_iter().collect();
assert_eq!(encode(&bad), None, "{why}");
}
let mut rotated = sxth;
rotated.operands = [Operand::Reg(Reg(0)), Operand::RegShifted(Reg(1), ror8)]
.into_iter()
.collect();
assert_eq!(rotated.to_string(), "sxth.w r0, r1, ror #8");
assert_eq!(encode(&rotated), Some((h1, h2 | 0x0010)));
let (h1, h2) = hw(0b1011, 2, 0, 0b1000, 2); let mut clz = decode(h1, h2, 0).unwrap();
clz.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Reg(Reg(2)),
]
.into_iter()
.collect();
assert_eq!(encode(&clz), None);
let (h1, h2) = hw(0b1010, 1, 0, 0b1000, 2); let mut sel = decode(h1, h2, 0).unwrap();
sel.operands = [Operand::Reg(Reg(0)), Operand::Reg(Reg(1))]
.into_iter()
.collect();
assert_eq!(encode(&sel), None);
let (h1, h2) = hw(0b0000, 15, 0, 0b1000, 2); let mut sxth = decode(h1, h2, 0).unwrap();
sxth.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Reg(Reg(2)),
]
.into_iter()
.collect();
assert_eq!(encode(&sxth), None);
let mut bad_rot = decode(h1, h2, 0).unwrap();
bad_rot.operands = [
Operand::Reg(Reg(0)),
Operand::RegShifted(
Reg(2),
Shift {
kind: ShiftKind::Ror,
amount: ShiftAmount::Imm(4),
},
),
]
.into_iter()
.collect();
assert_eq!(encode(&bad_rot), None);
let mut lsl_rot = decode(h1, h2, 0).unwrap();
lsl_rot.operands = [
Operand::Reg(Reg(0)),
Operand::RegShifted(
Reg(2),
Shift {
kind: ShiftKind::Lsl,
amount: ShiftAmount::Imm(8),
},
),
]
.into_iter()
.collect();
assert_eq!(encode(&lsl_rot), None);
let mut reg_rot = decode(h1, h2, 0).unwrap();
reg_rot.operands = [
Operand::Reg(Reg(0)),
Operand::RegShifted(
Reg(2),
Shift {
kind: ShiftKind::Ror,
amount: ShiftAmount::Reg(Reg(3)),
},
),
]
.into_iter()
.collect();
assert_eq!(encode(®_rot), None);
let mut huge = base;
huge.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Reg(Reg(0x1F)),
]
.into_iter()
.collect();
assert_eq!(encode(&huge), None);
}
#[test]
fn a_condition_does_not_change_the_halfwords() {
let (hw1, hw2) = hw(0b1001, 1, 0, 0b0110, 2); let mut insn = decode(hw1, hw2, 0).unwrap();
insn.cond = Some(crate::Cond::Ne);
assert_eq!(insn.to_string(), "uhadd16ne r0, r1, r2");
assert_eq!(encode(&insn), Some((hw1, hw2)));
}
}