use super::insn::{Operand, Operands, Reg, Shift, ShiftAmount, ShiftKind, Width};
use super::Insn;
const GROUP: u16 = 0b111_0101 << 9;
#[derive(Clone, Copy, PartialEq, Eq)]
enum Form {
Three,
Test,
Mvn,
Pack {
tb: u16,
},
Move {
ty: u16,
},
ShiftImm {
ty: u16,
},
}
impl Form {
fn takes_rn_1111(self) -> bool {
matches!(self, Form::Mvn | Form::Move { .. } | Form::ShiftImm { .. })
}
}
struct Row {
op: u16,
mnemonic: &'static str,
encoding: &'static str,
form: Form,
wide_suffix: bool,
}
const TABLE: [Row; 23] = [
Row {
op: 0b0000,
mnemonic: "and",
encoding: "T2",
form: Form::Three,
wide_suffix: true,
}, Row {
op: 0b0000,
mnemonic: "tst",
encoding: "T2",
form: Form::Test,
wide_suffix: true,
}, Row {
op: 0b0001,
mnemonic: "bic",
encoding: "T2",
form: Form::Three,
wide_suffix: true,
}, Row {
op: 0b0010,
mnemonic: "orr",
encoding: "T2",
form: Form::Three,
wide_suffix: true,
}, Row {
op: 0b0011,
mnemonic: "orn",
encoding: "T1",
form: Form::Three,
wide_suffix: false,
}, Row {
op: 0b0011,
mnemonic: "mvn",
encoding: "T2",
form: Form::Mvn,
wide_suffix: true,
}, Row {
op: 0b0100,
mnemonic: "eor",
encoding: "T2",
form: Form::Three,
wide_suffix: true,
}, Row {
op: 0b0100,
mnemonic: "teq",
encoding: "T1",
form: Form::Test,
wide_suffix: false,
}, Row {
op: 0b0110,
mnemonic: "pkhbt",
encoding: "T1",
form: Form::Pack { tb: 0 },
wide_suffix: false,
}, Row {
op: 0b0110,
mnemonic: "pkhtb",
encoding: "T1",
form: Form::Pack { tb: 1 },
wide_suffix: false,
}, Row {
op: 0b1000,
mnemonic: "add",
encoding: "T3",
form: Form::Three,
wide_suffix: true,
}, Row {
op: 0b1000,
mnemonic: "cmn",
encoding: "T2",
form: Form::Test,
wide_suffix: true,
}, Row {
op: 0b1010,
mnemonic: "adc",
encoding: "T2",
form: Form::Three,
wide_suffix: true,
}, Row {
op: 0b1011,
mnemonic: "sbc",
encoding: "T2",
form: Form::Three,
wide_suffix: true,
}, Row {
op: 0b1101,
mnemonic: "sub",
encoding: "T2",
form: Form::Three,
wide_suffix: true,
}, Row {
op: 0b1101,
mnemonic: "cmp",
encoding: "T3",
form: Form::Test,
wide_suffix: true,
}, Row {
op: 0b1110,
mnemonic: "rsb",
encoding: "T1",
form: Form::Three,
wide_suffix: false,
}, Row {
op: 0b0010,
mnemonic: "mov",
encoding: "T3",
form: Form::Move { ty: 0b00 },
wide_suffix: true,
}, Row {
op: 0b0010,
mnemonic: "lsl",
encoding: "T2",
form: Form::ShiftImm { ty: 0b00 },
wide_suffix: true,
}, Row {
op: 0b0010,
mnemonic: "lsr",
encoding: "T2",
form: Form::ShiftImm { ty: 0b01 },
wide_suffix: true,
}, Row {
op: 0b0010,
mnemonic: "asr",
encoding: "T2",
form: Form::ShiftImm { ty: 0b10 },
wide_suffix: true,
}, Row {
op: 0b0010,
mnemonic: "rrx",
encoding: "T1",
form: Form::Move { ty: 0b11 },
wide_suffix: false,
}, Row {
op: 0b0010,
mnemonic: "ror",
encoding: "T1",
form: Form::ShiftImm { ty: 0b11 },
wide_suffix: false,
}, ];
impl Form {
fn arity(self) -> usize {
match self {
Form::Three | Form::Pack { .. } | Form::ShiftImm { .. } => 3,
Form::Test | Form::Mvn | Form::Move { .. } => 2,
}
}
}
fn has_test_alias(op: u16) -> bool {
TABLE.iter().any(|r| r.op == op && r.form == Form::Test)
}
fn has_rn_alias(op: u16) -> bool {
TABLE.iter().any(|r| r.op == op && r.form.takes_rn_1111())
}
fn imm_shift(ty: u16, imm5: u16) -> (ShiftKind, u16) {
match ty {
0b00 => (ShiftKind::Lsl, imm5),
0b01 => (ShiftKind::Lsr, if imm5 == 0 { 32 } else { imm5 }),
0b10 => (ShiftKind::Asr, if imm5 == 0 { 32 } else { imm5 }),
_ if imm5 == 0 => (ShiftKind::Rrx, 1),
_ => (ShiftKind::Ror, imm5),
}
}
fn shifted(rm: Reg, ty: u16, imm5: u16) -> Operand {
match imm_shift(ty, imm5) {
(ShiftKind::Lsl, 0) => Operand::Reg(rm),
(kind, amount) => Operand::RegShifted(
rm,
Shift {
kind,
amount: ShiftAmount::Imm(amount as u8),
},
),
}
}
fn shift_amount_bits(ty: u16, amount: i64) -> Option<u16> {
match ty {
0b01 | 0b10 if (1..=32).contains(&amount) => Some(amount as u16 & 0x1F),
0b00 | 0b11 if (1..=31).contains(&amount) => Some(amount as u16),
_ => None,
}
}
fn unshift(op: Operand) -> Option<(u16, u16, u16)> {
let (rm, kind, amount) = match op {
Operand::Reg(r) => return Some((u16::from(r.num()), 0b00, 0)),
Operand::RegShifted(
r,
Shift {
kind,
amount: ShiftAmount::Imm(n),
},
) => (r, kind, i64::from(n)),
_ => return None,
};
let (ty, imm5) = match kind {
ShiftKind::Lsl => (0b00, shift_amount_bits(0b00, amount)?),
ShiftKind::Lsr => (0b01, shift_amount_bits(0b01, amount)?),
ShiftKind::Asr => (0b10, shift_amount_bits(0b10, amount)?),
ShiftKind::Ror => (0b11, shift_amount_bits(0b11, amount)?),
ShiftKind::Rrx if amount == 1 => (0b11, 0),
ShiftKind::Rrx => return None,
};
Some((u16::from(rm.num()), ty, imm5))
}
pub(crate) fn decode(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw1 & 0xFE00 != GROUP {
return None;
}
if hw2 & 0x8000 != 0 {
return None;
}
let op = (hw1 >> 5) & 0xF;
let s = hw1 & 0x10 != 0;
let rn = Reg((hw1 & 0xF) as u8);
let rd = Reg(((hw2 >> 8) & 0xF) as u8);
let rm = Reg((hw2 & 0xF) as u8);
let ty = (hw2 >> 4) & 0b11;
let imm5 = ((hw2 >> 12) & 0b111) << 2 | (hw2 >> 6) & 0b11;
let want = match op {
0b0010 if rn.num() == 15 => {
if imm5 == 0 && (ty == 0b00 || ty == 0b11) {
Form::Move { ty }
} else {
Form::ShiftImm { ty }
}
}
0b0011 if rn.num() == 15 => Form::Mvn,
0b0110 => {
if s || ty & 1 == 1 {
return None;
}
Form::Pack { tb: ty >> 1 }
}
_ if rd.num() == 15 && has_test_alias(op) => {
if !s {
return None;
}
Form::Test
}
_ => Form::Three,
};
let row = TABLE.iter().find(|r| r.op == op && r.form == want)?;
let mut operands = Operands::new();
match row.form {
Form::Three | Form::Pack { .. } => {
operands.push(Operand::Reg(rd));
operands.push(Operand::Reg(rn));
operands.push(shifted(rm, ty, imm5));
}
Form::Test => {
operands.push(Operand::Reg(rn));
operands.push(shifted(rm, ty, imm5));
}
Form::Mvn => {
operands.push(Operand::Reg(rd));
operands.push(shifted(rm, ty, imm5));
}
Form::Move { .. } => {
operands.push(Operand::Reg(rd));
operands.push(Operand::Reg(rm));
}
Form::ShiftImm { ty } => {
operands.push(Operand::Reg(rd));
operands.push(Operand::Reg(rm));
operands.push(Operand::Imm(i64::from(imm_shift(ty, imm5).1)));
}
}
Some(Insn {
mnemonic: row.mnemonic,
encoding: row.encoding,
addr,
width: Width::Wide,
cond: None,
sets_flags: match row.form {
Form::Test | Form::Pack { .. } => false,
_ => s,
},
explicit_width: row.wide_suffix,
operands,
})
}
pub(crate) fn encode(insn: &Insn) -> Option<(u16, u16)> {
if insn.width != Width::Wide {
return None;
}
let row = TABLE
.iter()
.find(|r| r.mnemonic == insn.mnemonic && r.encoding == insn.encoding)?;
if insn.explicit_width != row.wide_suffix {
return None;
}
let reg = |i: usize| match insn.operands.get(i) {
Some(Operand::Reg(r)) => Some(u16::from(r.num())),
_ => None,
};
let s = match row.form {
Form::Test => {
if insn.sets_flags {
return None;
}
1
}
Form::Pack { .. } => {
if insn.sets_flags {
return None;
}
0
}
_ => u16::from(insn.sets_flags),
};
if insn.operands.len() > row.form.arity() {
return None;
}
let (rn, rd, rm, ty, imm5) = match row.form {
Form::Three => {
let rd = reg(0)?;
let rn = reg(1)?;
if (has_test_alias(row.op) && rd == 15) || (has_rn_alias(row.op) && rn == 15) {
return None;
}
let (rm, ty, imm5) = unshift(insn.operands.get(2)?)?;
(rn, rd, rm, ty, imm5)
}
Form::Test => {
let (rm, ty, imm5) = unshift(insn.operands.get(1)?)?;
(reg(0)?, 15, rm, ty, imm5)
}
Form::Mvn => {
let (rm, ty, imm5) = unshift(insn.operands.get(1)?)?;
(15, reg(0)?, rm, ty, imm5)
}
Form::Pack { tb } => {
let rd = reg(0)?;
let rn = reg(1)?;
let (rm, ty, imm5) = unshift(insn.operands.get(2)?)?;
if ty != tb << 1 {
return None;
}
(rn, rd, rm, ty, imm5)
}
Form::Move { ty } => (15, reg(0)?, reg(1)?, ty, 0),
Form::ShiftImm { ty } => {
let amount = match insn.operands.get(2)? {
Operand::Imm(v) => v,
_ => return None,
};
(15, reg(0)?, reg(1)?, ty, shift_amount_bits(ty, amount)?)
}
};
Some((
GROUP | row.op << 5 | s << 4 | rn,
(imm5 >> 2) << 12 | rd << 8 | (imm5 & 0b11) << 6 | ty << 4 | rm,
))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::isa::decode_halfwords;
use crate::isa::Target;
fn hw(op: u16, s: u16, rn: u16, rd: u16, ty: u16, imm5: u16, rm: u16) -> (u16, u16) {
(
GROUP | op << 5 | s << 4 | rn,
(imm5 >> 2) << 12 | rd << 8 | (imm5 & 0b11) << 6 | ty << 4 | rm,
)
}
fn dec(op: u16, s: u16, rn: u16, rd: u16, ty: u16, imm5: u16, rm: u16) -> Insn {
let (a, b) = hw(op, s, rn, rd, ty, imm5, rm);
let decoded = decode(a, b, 0);
assert!(decoded.is_some(), "{a:#06x} {b:#06x} should decode");
decoded.unwrap()
}
fn ual(op: u16, s: u16, rn: u16, rd: u16, ty: u16, imm5: u16, rm: u16) -> String {
dec(op, s, rn, rd, ty, imm5, rm).to_string()
}
#[test]
fn encode_rejects_every_mangled_operand_slot() {
for (hw1, hw2) in [
hw(0b0000, 0, 1, 0, 0b00, 0, 2), hw(0b0000, 1, 1, 15, 0b00, 0, 2), hw(0b0011, 0, 15, 0, 0b00, 0, 2), hw(0b0110, 0, 1, 0, 0b00, 0, 2), hw(0b0110, 0, 1, 0, 0b10, 4, 2), hw(0b0010, 0, 15, 0, 0b00, 0, 2), hw(0b0010, 0, 15, 0, 0b11, 0, 2), hw(0b0010, 0, 15, 0, 0b00, 3, 2), hw(0b0010, 0, 15, 0, 0b01, 3, 2), hw(0b0010, 0, 15, 0, 0b10, 3, 2), hw(0b0010, 0, 15, 0, 0b11, 3, 2), ] {
let insn = decode(hw1, hw2, 0).unwrap();
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| {
let op = insn.operands.get(i).unwrap();
if i != slot {
op
} else {
match op {
Operand::Imm(_) => Operand::Reg(Reg(0)),
_ => Operand::Imm(0),
}
}
})
.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::Imm(0)))
.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 encode_rejects_shifts_no_encoding_can_hold() {
let and = dec(0b0000, 0, 1, 0, 0b00, 0, 2);
let shifted_and = |kind, n| {
let mut insn = and;
insn.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::RegShifted(
Reg(2),
Shift {
kind,
amount: ShiftAmount::Imm(n),
},
),
]
.iter()
.copied()
.collect();
encode(&insn)
};
for kind in [ShiftKind::Lsr, ShiftKind::Asr] {
assert_eq!(shifted_and(kind, 0), None, "{kind} #0");
assert_eq!(shifted_and(kind, 33), None, "{kind} #33");
assert!(shifted_and(kind, 32).is_some(), "{kind} #32");
}
for kind in [ShiftKind::Lsl, ShiftKind::Ror] {
assert_eq!(shifted_and(kind, 0), None, "{kind} #0");
assert_eq!(shifted_and(kind, 32), None, "{kind} #32");
assert!(shifted_and(kind, 31).is_some(), "{kind} #31");
}
assert!(shifted_and(ShiftKind::Rrx, 1).is_some(), "rrx");
for n in [0u8, 2, 32] {
assert_eq!(shifted_and(ShiftKind::Rrx, n), None, "rrx with amount {n}");
}
let mut by_register = and;
by_register.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::RegShifted(
Reg(2),
Shift {
kind: ShiftKind::Lsl,
amount: ShiftAmount::Reg(Reg(3)),
},
),
]
.iter()
.copied()
.collect();
assert_eq!(encode(&by_register), None);
}
#[test]
fn systematic_round_trip() {
let mut per_op = [0u32; 16];
let mut total = 0u32;
for op in 0..16u16 {
for s in 0..2u16 {
for rn in 0..16u16 {
for rd in 0..16u16 {
for ty in 0..4u16 {
for imm5 in 0..32u16 {
total += 1;
let (a, b) = hw(op, s, rn, rd, ty, imm5, 2);
let insn = match decode(a, b, 0) {
Some(i) => i,
None => continue,
};
per_op[op as usize] += 1;
assert_eq!(insn.width, Width::Wide, "{a:#06x} {b:#06x}");
assert_eq!(insn.len(), 4, "{a:#06x} {b:#06x}");
assert!(insn.cond.is_none(), "{a:#06x} {b:#06x}");
assert_eq!(
encode(&insn),
Some((a, b)),
"{a:#06x} {b:#06x} decoded as `{insn}` but did not re-encode"
);
}
}
}
}
}
}
assert_eq!(total, 1_048_576);
assert_eq!(
per_op,
[
63488, 65536, 65536, 65536, 63488, 0, 16384, 0, 63488, 0, 65536, 65536, 0, 63488,
65536, 0
]
);
let decoded: u32 = per_op.iter().sum();
assert_eq!(decoded, 663_552);
assert_eq!(total - decoded, 5 * 65536 + 4 * 2048 + 3 * 16384);
assert_eq!(total - decoded, 385_024);
}
#[test]
fn dispatch_boundary() {
for op in 0..16u16 {
for s in 0..2u16 {
let (a, b) = hw(op, s, 1, 0, 0b01, 3, 2);
assert_eq!(
decode_halfwords(a, b, 0, Target::Union),
decode(a, b, 0),
"{a:#06x} {b:#06x} is not reaching t32_dp_shiftreg"
);
}
}
assert!(decode(0xE800, 0, 0).is_none());
assert!(decode(0xEC00, 0, 0).is_none());
assert!(decode(0xF000, 0, 0).is_none());
}
#[test]
fn round_trips_through_the_group_dispatcher() {
let mut checked = 0u32;
for op in 0..16u16 {
for s in 0..2u16 {
for rn in [0u16, 1, 13, 15] {
for rd in [0u16, 3, 13, 15] {
for ty in 0..4u16 {
for imm5 in [0u16, 1, 2, 30, 31] {
let (a, b) = hw(op, s, rn, rd, ty, imm5, 2);
let insn = match decode_halfwords(a, b, 0, Target::Union) {
Some(i) => i,
None => continue,
};
checked += 1;
assert_eq!(
crate::isa::encode(&insn),
Some((a, b)),
"{a:#06x} {b:#06x} decoded as `{insn}` but the dispatcher \
re-encoded it elsewhere"
);
}
}
}
}
}
}
assert_eq!(checked, 6240);
}
#[test]
fn table_a5_23_exhaustively() {
let mut cases = 0u32;
for ty in 0..4u16 {
for imm5 in 0..32u16 {
let expected = match (ty, imm5) {
(0b00, 0) => "mov",
(0b00, _) => "lsl",
(0b01, _) => "lsr",
(0b10, _) => "asr",
(0b11, 0) => "rrx",
_ => "ror",
};
let (a, b) = hw(0b0010, 0, 15, 0, ty, imm5, 2);
let insn = decode(a, b, 0).expect("Table A5-23 leaves no hole");
assert_eq!(
insn.mnemonic, expected,
"type {ty:02b}, imm3:imm2 {imm5:05b}"
);
assert_eq!(
insn.operands.len(),
if matches!(expected, "mov" | "rrx") {
2
} else {
3
},
"type {ty:02b}, imm3:imm2 {imm5:05b}"
);
assert_eq!(encode(&insn), Some((a, b)), "round-trip of `{insn}`");
cases += 1;
}
}
assert_eq!(cases, 128);
let name = |ty, imm5| dec(0b0010, 0, 15, 0, ty, imm5, 2).encoding;
assert_eq!(name(0b00, 0), "T3"); assert_eq!(name(0b00, 1), "T2"); assert_eq!(name(0b01, 1), "T2"); assert_eq!(name(0b10, 1), "T2"); assert_eq!(name(0b11, 0), "T1"); assert_eq!(name(0b11, 1), "T1"); }
#[test]
fn decode_imm_shift_reads_zero_as_thirty_two() {
assert_eq!(ual(0b0010, 0, 15, 0, 0b01, 0, 2), "lsr.w r0, r2, #0x20");
assert_eq!(ual(0b0010, 0, 15, 0, 0b10, 0, 2), "asr.w r0, r2, #0x20");
let lsr = dec(0b0010, 0, 15, 0, 0b01, 0, 2);
assert_eq!(lsr.operands.get(2), Some(Operand::Imm(32)));
assert_eq!(ual(0b0010, 0, 15, 0, 0b00, 0, 2), "mov.w r0, r2");
assert_eq!(ual(0b0010, 0, 15, 0, 0b00, 1, 2), "lsl.w r0, r2, #1");
assert_eq!(
ual(0b0000, 0, 1, 0, 0b01, 0, 2),
"and.w r0, r1, r2, lsr #32"
);
assert_eq!(
ual(0b0000, 0, 1, 0, 0b10, 0, 2),
"and.w r0, r1, r2, asr #32"
);
assert_eq!(ual(0b0000, 0, 1, 0, 0b11, 0, 2), "and.w r0, r1, r2, rrx");
assert_eq!(ual(0b0010, 0, 15, 0, 0b11, 0, 2), "rrx r0, r2");
}
#[test]
fn a_zero_shift_is_omitted_and_round_trips() {
let (a, b) = hw(0b0000, 0, 1, 0, 0b00, 0, 2);
let insn = decode(a, b, 0).unwrap();
assert_eq!(insn.to_string(), "and.w r0, r1, r2");
assert_eq!(
insn.operands.get(2),
Some(Operand::Reg(Reg(2))),
"a zero shift is a plain register operand, not a `lsl #0`"
);
assert_eq!(encode(&insn), Some((a, b)));
let (a, b) = hw(0b0000, 0, 1, 0, 0b00, 3, 2);
let insn = decode(a, b, 0).unwrap();
assert_eq!(insn.to_string(), "and.w r0, r1, r2, lsl #3");
assert_eq!(
insn.operands.get(2),
Some(Operand::RegShifted(
Reg(2),
Shift {
kind: ShiftKind::Lsl,
amount: ShiftAmount::Imm(3),
}
))
);
assert_eq!(encode(&insn), Some((a, b)));
let mut explicit_zero = insn;
explicit_zero.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::RegShifted(
Reg(2),
Shift {
kind: ShiftKind::Lsl,
amount: ShiftAmount::Imm(0),
},
),
]
.into_iter()
.collect();
assert_eq!(encode(&explicit_zero), None);
let mut ror_zero = insn;
ror_zero.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::RegShifted(
Reg(2),
Shift {
kind: ShiftKind::Ror,
amount: ShiftAmount::Imm(0),
},
),
]
.into_iter()
.collect();
assert_eq!(encode(&ror_zero), None);
}
#[test]
fn table_a5_22_prints_ual() {
assert_eq!(ual(0b0000, 0, 1, 0, 0, 0, 2), "and.w r0, r1, r2");
assert_eq!(ual(0b0000, 1, 1, 0, 0, 0, 2), "ands.w r0, r1, r2");
assert_eq!(ual(0b0000, 1, 1, 15, 0, 0, 2), "tst.w r1, r2");
assert_eq!(ual(0b0001, 1, 1, 0, 0, 0, 2), "bics.w r0, r1, r2");
assert_eq!(ual(0b0010, 0, 1, 0, 0, 0, 2), "orr.w r0, r1, r2");
assert_eq!(ual(0b0010, 0, 15, 0, 0, 0, 2), "mov.w r0, r2");
assert_eq!(ual(0b0011, 0, 1, 0, 0, 0, 2), "orn r0, r1, r2");
assert_eq!(ual(0b0011, 0, 15, 0, 0, 0, 2), "mvn.w r0, r2");
assert_eq!(ual(0b0100, 0, 1, 0, 0, 0, 2), "eor.w r0, r1, r2");
assert_eq!(ual(0b0100, 1, 1, 15, 0, 0, 2), "teq r1, r2");
assert_eq!(ual(0b0110, 0, 1, 0, 0b00, 0, 2), "pkhbt r0, r1, r2");
assert_eq!(ual(0b0110, 0, 1, 0, 0b00, 4, 2), "pkhbt r0, r1, r2, lsl #4");
assert_eq!(ual(0b0110, 0, 1, 0, 0b10, 3, 2), "pkhtb r0, r1, r2, asr #3");
assert_eq!(ual(0b1000, 0, 1, 0, 0, 0, 2), "add.w r0, r1, r2");
assert_eq!(ual(0b1000, 1, 1, 15, 0, 0, 2), "cmn.w r1, r2");
assert_eq!(ual(0b1010, 0, 1, 0, 0, 0, 2), "adc.w r0, r1, r2");
assert_eq!(ual(0b1011, 0, 1, 0, 0, 0, 2), "sbc.w r0, r1, r2");
assert_eq!(ual(0b1101, 0, 1, 0, 0, 0, 2), "sub.w r0, r1, r2");
assert_eq!(ual(0b1101, 1, 1, 15, 0, 0, 2), "cmp.w r1, r2");
assert_eq!(ual(0b1110, 0, 1, 0, 0, 0, 2), "rsb r0, r1, r2");
assert_eq!(ual(0b1110, 1, 1, 0, 0, 0, 2), "rsbs r0, r1, r2");
assert_eq!(ual(0b0010, 1, 15, 0, 0b00, 5, 2), "lsls.w r0, r2, #5");
assert_eq!(ual(0b0010, 0, 15, 0, 0b01, 5, 2), "lsr.w r0, r2, #5");
assert_eq!(ual(0b0010, 0, 15, 0, 0b10, 5, 2), "asr.w r0, r2, #5");
assert_eq!(ual(0b0010, 0, 15, 0, 0b11, 5, 2), "ror r0, r2, #5");
assert_eq!(ual(0b0010, 1, 15, 0, 0b11, 0, 2), "rrxs r0, r2");
}
#[test]
fn test_forms_print_no_s_suffix() {
for (op, mnemonic) in [
(0b0000u16, "tst"),
(0b0100, "teq"),
(0b1000, "cmn"),
(0b1101, "cmp"),
] {
let (a, b) = hw(op, 1, 1, 15, 0, 0, 2);
let insn = decode(a, b, 0).unwrap();
assert_eq!(insn.mnemonic, mnemonic);
assert!(
!insn.sets_flags,
"{mnemonic} writes flags but prints no `s`"
);
let printed = insn.to_string();
assert!(
printed.starts_with(mnemonic) && !printed.starts_with(&format!("{mnemonic}s")),
"`{printed}` should not carry an `s` suffix"
);
assert_eq!(encode(&insn), Some((a, b)));
}
for ty in [0b00u16, 0b10] {
assert!(!dec(0b0110, 0, 1, 0, ty, 3, 2).sets_flags);
}
}
#[test]
fn rd_1111_without_s_is_unpredictable() {
for op in [0b0000u16, 0b0100, 0b1000, 0b1101] {
for ty in 0..4u16 {
for imm5 in 0..32u16 {
let (a, b) = hw(op, 0, 1, 15, ty, imm5, 2);
assert!(
decode(a, b, 0).is_none(),
"{a:#06x} {b:#06x} is UNPREDICTABLE, not an instruction"
);
}
}
}
let mut and_pc = dec(0b0000, 0, 1, 0, 0, 0, 2);
and_pc.operands = [
Operand::Reg(Reg::PC),
Operand::Reg(Reg(1)),
Operand::Reg(Reg(2)),
]
.into_iter()
.collect();
assert_eq!(encode(&and_pc), None);
for op in [0b0001u16, 0b0011, 0b1010, 0b1011, 0b1110] {
let (a, b) = hw(op, 0, 1, 15, 0, 0, 2);
let insn = decode(a, b, 0).expect("no test alias here");
assert_eq!(encode(&insn), Some((a, b)));
}
}
#[test]
fn the_should_be_zero_bit_is_enforced() {
let (a, b) = hw(0b0000, 0, 1, 0, 0, 0, 2);
assert!(decode(a, b, 0).is_some());
assert!(decode(a, b | 0x8000, 0).is_none());
}
#[test]
fn pkh_reads_type_as_tb_and_t() {
for s in 0..2u16 {
for ty in 0..4u16 {
let (a, b) = hw(0b0110, s, 1, 0, ty, 3, 2);
let defined = s == 0 && ty & 1 == 0;
assert_eq!(decode(a, b, 0).is_some(), defined, "S={s} type={ty:02b}");
}
}
assert_eq!(ual(0b0110, 0, 1, 0, 0b00, 1, 2), "pkhbt r0, r1, r2, lsl #1");
assert_eq!(ual(0b0110, 0, 1, 0, 0b10, 1, 2), "pkhtb r0, r1, r2, asr #1");
assert_eq!(ual(0b0110, 0, 1, 0, 0b00, 0, 2), "pkhbt r0, r1, r2");
assert_eq!(
ual(0b0110, 0, 1, 0, 0b10, 0, 2),
"pkhtb r0, r1, r2, asr #32"
);
let mut bare_tb = dec(0b0110, 0, 1, 0, 0b10, 1, 2);
bare_tb.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Reg(Reg(2)),
]
.into_iter()
.collect();
assert_eq!(encode(&bare_tb), None);
}
#[test]
fn rn_1111_belongs_to_the_aliases() {
for (op, mnemonic) in [(0b0010u16, "orr"), (0b0011, "orn")] {
let (a, b) = hw(op, 0, 1, 0, 0, 0, 2);
let mut insn = decode(a, b, 0).unwrap();
assert_eq!(insn.mnemonic, mnemonic);
insn.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg::PC),
Operand::Reg(Reg(2)),
]
.into_iter()
.collect();
assert_eq!(encode(&insn), None, "{mnemonic} rn == pc is an alias");
}
}
#[test]
fn encode_rejects_what_this_group_cannot_hold() {
let base = dec(0b0000, 0, 1, 0, 0, 0, 2);
let mut foreign = base;
foreign.mnemonic = "ldr";
assert_eq!(encode(&foreign), None);
let mut narrow = base;
narrow.width = Width::Narrow;
assert_eq!(encode(&narrow), None);
let mut t1 = base;
t1.encoding = "T1";
assert_eq!(encode(&t1), None);
let mut unsuffixed = base;
unsuffixed.explicit_width = false;
assert_eq!(encode(&unsuffixed), None);
let mut rsb = dec(0b1110, 0, 1, 0, 0, 0, 2);
rsb.explicit_width = true;
assert_eq!(encode(&rsb), None);
let mut too_few = base;
too_few.operands = [Operand::Reg(Reg(0)), Operand::Reg(Reg(1))]
.into_iter()
.collect();
assert_eq!(encode(&too_few), None);
let mut immediate = dec(0b1000, 0, 1, 0, 0, 0, 2);
assert_eq!(immediate.mnemonic, "add");
assert_eq!(immediate.encoding, "T3");
immediate.operands = [Operand::Reg(Reg(0)), Operand::Reg(Reg(1)), Operand::Imm(4)]
.into_iter()
.collect();
assert_eq!(encode(&immediate), None);
let mut movw = dec(0b0010, 0, 15, 0, 0, 0, 2);
movw.operands = [Operand::Reg(Reg(0)), Operand::Imm(4)]
.into_iter()
.collect();
assert_eq!(encode(&movw), None);
let mut lsl_reg = dec(0b0010, 0, 15, 0, 0b00, 3, 2);
assert_eq!((lsl_reg.mnemonic, lsl_reg.encoding), ("lsl", "T2"));
lsl_reg.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Reg(Reg(2)),
]
.into_iter()
.collect();
assert_eq!(encode(&lsl_reg), None);
let mut lsl32 = dec(0b0010, 0, 15, 0, 0b00, 3, 2);
lsl32.operands = [Operand::Reg(Reg(0)), Operand::Reg(Reg(2)), Operand::Imm(32)]
.into_iter()
.collect();
assert_eq!(encode(&lsl32), None);
let mut lsr33 = dec(0b0010, 0, 15, 0, 0b01, 3, 2);
lsr33.operands = [Operand::Reg(Reg(0)), Operand::Reg(Reg(2)), Operand::Imm(33)]
.into_iter()
.collect();
assert_eq!(encode(&lsr33), None);
let mut by_register = base;
by_register.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::RegShifted(
Reg(2),
Shift {
kind: ShiftKind::Lsl,
amount: ShiftAmount::Reg(Reg(3)),
},
),
]
.into_iter()
.collect();
assert_eq!(encode(&by_register), None);
let mut flagged_tst = dec(0b0000, 1, 1, 15, 0, 0, 2);
flagged_tst.sets_flags = true;
assert_eq!(encode(&flagged_tst), None);
let mut flagged_pkh = dec(0b0110, 0, 1, 0, 0b00, 3, 2);
flagged_pkh.sets_flags = true;
assert_eq!(encode(&flagged_pkh), None);
}
}