use super::insn::{Operand, Operands, Reg, Width};
use super::Insn;
fn narrow(
mnemonic: &'static str,
encoding: &'static str,
addr: u32,
sets_flags: bool,
operands: Operands,
) -> Insn {
Insn {
mnemonic,
encoding,
addr,
width: Width::Narrow,
cond: None,
sets_flags,
explicit_width: false,
operands,
}
}
pub(crate) fn decode(hw1: u16, _hw2: u16, addr: u32) -> Option<Insn> {
if hw1 >> 14 != 0 {
return None;
}
let rd = Reg((hw1 & 7) as u8);
let rlow = Reg(((hw1 >> 3) & 7) as u8);
let rhigh = Reg(((hw1 >> 6) & 7) as u8);
let imm3 = i64::from((hw1 >> 6) & 7);
let imm5 = (hw1 >> 6) & 0x1F;
let rdn = Reg(((hw1 >> 8) & 7) as u8);
let imm8 = i64::from(hw1 & 0xFF);
let shift = |mnemonic: &'static str, amount: u16| {
narrow(
mnemonic,
"T1",
addr,
true,
[
Operand::Reg(rd),
Operand::Reg(rlow),
Operand::Imm(i64::from(amount)),
]
.into_iter()
.collect(),
)
};
let three = |mnemonic: &'static str, third: Operand| {
narrow(
mnemonic,
"T1",
addr,
true,
[Operand::Reg(rd), Operand::Reg(rlow), third]
.into_iter()
.collect(),
)
};
let imm8_form = |mnemonic: &'static str, encoding: &'static str, sets_flags: bool| {
narrow(
mnemonic,
encoding,
addr,
sets_flags,
[Operand::Reg(rdn), Operand::Imm(imm8)]
.into_iter()
.collect(),
)
};
Some(match (hw1 >> 9) & 0x1F {
0b00000..=0b00011 => {
if imm5 == 0 {
narrow(
"mov",
"T2",
addr,
true,
[Operand::Reg(rd), Operand::Reg(rlow)].into_iter().collect(),
)
} else {
shift("lsl", imm5)
}
}
0b00100..=0b00111 => shift("lsr", if imm5 == 0 { 32 } else { imm5 }),
0b01000..=0b01011 => shift("asr", if imm5 == 0 { 32 } else { imm5 }),
0b01100 => three("add", Operand::Reg(rhigh)),
0b01101 => three("sub", Operand::Reg(rhigh)),
0b01110 => three("add", Operand::Imm(imm3)),
0b01111 => three("sub", Operand::Imm(imm3)),
0b10000..=0b10011 => imm8_form("mov", "T1", true),
0b10100..=0b10111 => imm8_form("cmp", "T1", false),
0b11000..=0b11011 => imm8_form("add", "T2", true),
_ => imm8_form("sub", "T2", true),
})
}
fn low(op: Option<Operand>) -> Option<u16> {
match op {
Some(Operand::Reg(r)) if r.is_low() => Some(u16::from(r.num())),
_ => None,
}
}
fn imm(op: Option<Operand>, max: i64) -> Option<u16> {
match op {
Some(Operand::Imm(v)) if (0..=max).contains(&v) => Some(v as u16),
_ => None,
}
}
fn flags_ok(insn: &Insn, expected: bool) -> bool {
insn.sets_flags == expected || (insn.cond.is_some() && !insn.sets_flags)
}
pub(crate) fn encode(insn: &Insn) -> Option<u16> {
if insn.width != Width::Narrow {
return None;
}
let ops = &insn.operands;
let (a, b, c) = (ops.get(0), ops.get(1), ops.get(2));
match (insn.mnemonic, insn.encoding, ops.len()) {
("mov", "T2", 2) if flags_ok(insn, true) => Some((low(b)? << 3) | low(a)?),
("lsl", "T1", 3) | ("lsr", "T1", 3) | ("asr", "T1", 3) if flags_ok(insn, true) => {
let (base, max) = match insn.mnemonic {
"lsl" => (0x0000, 31),
"lsr" => (0x0800, 32),
_ => (0x1000, 32),
};
let n = imm(c, max)?;
if n == 0 {
return None;
}
Some(base | ((n & 0x1F) << 6) | (low(b)? << 3) | low(a)?)
}
("add", "T1", 3) | ("sub", "T1", 3) if flags_ok(insn, true) => {
let base = match (insn.mnemonic, c) {
("add", Some(Operand::Reg(_))) => 0x1800,
("sub", Some(Operand::Reg(_))) => 0x1A00,
("add", _) => 0x1C00,
_ => 0x1E00,
};
let third = match c {
Some(Operand::Reg(_)) => low(c)?,
_ => imm(c, 7)?,
};
Some(base | (third << 6) | (low(b)? << 3) | low(a)?)
}
("mov", "T1", 2) if flags_ok(insn, true) => Some(0x2000 | (low(a)? << 8) | imm(b, 255)?),
("cmp", "T1", 2) if flags_ok(insn, false) => Some(0x2800 | (low(a)? << 8) | imm(b, 255)?),
("add", "T2", 2) if flags_ok(insn, true) => Some(0x3000 | (low(a)? << 8) | imm(b, 255)?),
("sub", "T2", 2) if flags_ok(insn, true) => Some(0x3800 | (low(a)? << 8) | imm(b, 255)?),
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::{decode, encode};
use crate::isa::Target;
use crate::isa::{decode_halfwords, Operand, Width};
#[test]
fn exhaustive_round_trip() {
let holes: Vec<u16> = (0x0000u16..=0x3FFF)
.filter(|hw| decode(*hw, 0, 0).is_none())
.collect();
assert_eq!(
holes,
Vec::new(),
"A5.2.1 allocates every encoding in 00xxxx"
);
for hw in 0x0000u16..=0x3FFF {
let insn = decode(hw, 0, 0).expect("the group is fully allocated");
assert_eq!(insn.width, Width::Narrow, "{hw:#06x} is a 16-bit encoding");
assert_eq!(
encode(&insn),
Some(hw),
"{hw:#06x} decoded as `{insn}` but did not re-encode"
);
}
}
#[test]
fn dispatch_boundary() {
for hw in 0x0000u16..=0x3FFF {
assert_eq!(
decode_halfwords(hw, 0, 0, Target::Union),
decode(hw, 0, 0),
"{hw:#06x} is not reaching t16_shift"
);
}
assert!(decode(0x4000, 0, 0).is_none());
assert!(decode(0xFFFF, 0, 0).is_none());
}
#[test]
fn ual_per_table_row() {
let cases: &[(u16, &str)] = &[
(0x0088, "lsls r0, r1, #2"),
(0x08CB, "lsrs r3, r1, #3"),
(0x1151, "asrs r1, r2, #5"),
(0x1888, "adds r0, r1, r2"),
(0x1AE5, "subs r5, r4, r3"),
(0x1C08, "adds r0, r1, #0"),
(0x1FD1, "subs r1, r2, #7"),
(0x232A, "movs r3, #0x2a"),
(0x2F00, "cmp r7, #0"),
(0x2864, "cmp r0, #0x64"),
(0x3101, "adds r1, #1"),
(0x3CFF, "subs r4, #0xff"),
];
for &(hw, text) in cases {
let bytes = hw.to_le_bytes();
let insn = crate::isa::decode_at(&bytes, 0).expect("defined encoding");
assert_eq!(insn.to_string(), text, "for {hw:#06x}");
}
}
#[test]
fn lsl_zero_is_mov_register_t2() {
let insn = decode(0x0000, 0, 0).unwrap();
assert_eq!(insn.mnemonic, "mov");
assert_eq!(insn.encoding, "T2");
assert!(insn.sets_flags);
assert_eq!(insn.operands.len(), 2);
assert_eq!(insn.to_string(), "movs r0, r0");
let insn = decode(0x0011, 0, 0).unwrap();
assert_eq!(insn.to_string(), "movs r1, r2");
assert_eq!(encode(&insn), Some(0x0011));
for hw in 0x0000u16..=0x07FF {
let insn = decode(hw, 0, 0).unwrap();
let expected = if (hw >> 6) & 0x1F == 0 { "mov" } else { "lsl" };
assert_eq!(insn.mnemonic, expected, "for {hw:#06x}");
}
}
#[test]
fn right_shift_by_zero_field_is_thirty_two() {
let insn = decode(0x0800, 0, 0).unwrap();
assert_eq!(insn.mnemonic, "lsr");
assert_eq!(insn.operands.get(2), Some(Operand::Imm(32)));
assert_eq!(insn.to_string(), "lsrs r0, r0, #0x20");
assert_eq!(encode(&insn), Some(0x0800));
let insn = decode(0x1000, 0, 0).unwrap();
assert_eq!(insn.mnemonic, "asr");
assert_eq!(insn.operands.get(2), Some(Operand::Imm(32)));
assert_eq!(encode(&insn), Some(0x1000));
let insn = decode(0x0840, 0, 0).unwrap();
assert_eq!(insn.operands.get(2), Some(Operand::Imm(1)));
assert_eq!(insn.to_string(), "lsrs r0, r0, #1");
let insn = decode(0x0040, 0, 0).unwrap();
assert_eq!(insn.to_string(), "lsls r0, r0, #1");
}
#[test]
fn cmp_never_prints_an_s_suffix() {
for hw in 0x2800u16..=0x2FFF {
let insn = decode(hw, 0, 0).unwrap();
assert_eq!(insn.mnemonic, "cmp");
assert!(!insn.sets_flags, "{hw:#06x} would print as `cmps`");
let text = insn.to_string();
assert!(text.starts_with("cmp "), "{hw:#06x} printed `{text}`");
}
}
#[test]
fn add_register_keeps_three_operands() {
let insn = decode(0x1880, 0, 0).unwrap();
assert_eq!(insn.operands.len(), 3);
assert_eq!(insn.to_string(), "adds r0, r0, r2");
}
#[test]
fn encode_rejects_foreign_forms() {
use crate::isa::{Insn, Operands, Reg};
let mut ops = Operands::new();
ops.push(Operand::Reg(Reg(0)));
ops.push(Operand::Reg(Reg::SP));
ops.push(Operand::Imm(4));
let sp_form = Insn {
mnemonic: "add",
encoding: "T1",
addr: 0,
width: Width::Narrow,
cond: None,
sets_flags: true,
explicit_width: false,
operands: ops,
};
assert_eq!(encode(&sp_form), None);
let mut wide = decode(0x3101, 0, 0).unwrap();
wide.width = Width::Wide;
assert_eq!(encode(&wide), None);
let mut big = decode(0x3101, 0, 0).unwrap();
big.operands = [Operand::Reg(Reg(1)), Operand::Imm(256)]
.into_iter()
.collect();
assert_eq!(encode(&big), None);
}
#[test]
fn encode_refuses_operands_no_field_can_hold() {
use crate::isa::{Insn, Operands, Reg};
let build = |mnemonic, encoding, ops: &[Operand], sets_flags| Insn {
mnemonic,
encoding,
addr: 0,
width: Width::Narrow,
cond: None,
sets_flags,
explicit_width: false,
operands: ops.iter().copied().collect::<Operands>(),
};
let r0 = Operand::Reg(Reg(0));
let r1 = Operand::Reg(Reg(1));
let r8 = Operand::Reg(Reg(8));
let cases: &[(&'static str, &'static str, &[Operand], bool, &str)] = &[
("mov", "T2", &[r0, r8], true, "Rm is high"),
("mov", "T2", &[r8, r0], true, "Rd is high"),
(
"lsl",
"T1",
&[r0, r1, Operand::Imm(0)],
true,
"LSL #0 is a MOV",
),
(
"lsr",
"T1",
&[r0, r1, Operand::Imm(0)],
true,
"LSR #0 is #32",
),
(
"asr",
"T1",
&[r0, r1, Operand::Imm(0)],
true,
"ASR #0 is #32",
),
(
"lsl",
"T1",
&[r0, r1, Operand::Imm(32)],
true,
"LSL max is 31",
),
(
"lsr",
"T1",
&[r0, r1, Operand::Imm(33)],
true,
"LSR max is 32",
),
(
"lsl",
"T1",
&[r0, r1, r1],
true,
"a shift amount is no register",
),
("lsl", "T1", &[r0, r8, Operand::Imm(2)], true, "Rm is high"),
("lsl", "T1", &[r8, r0, Operand::Imm(2)], true, "Rd is high"),
("add", "T1", &[r0, r1, r8], true, "Rm is high"),
("add", "T1", &[r0, r8, r1], true, "Rn is high"),
("add", "T1", &[r8, r0, r1], true, "Rd is high"),
(
"add",
"T1",
&[r0, r1, Operand::Imm(8)],
true,
"imm3 max is 7",
),
(
"sub",
"T1",
&[r0, r1, Operand::Imm(-1)],
true,
"imm3 is unsigned",
),
("mov", "T1", &[r8, Operand::Imm(1)], true, "Rd is high"),
(
"mov",
"T1",
&[r0, Operand::Imm(256)],
true,
"imm8 max is 255",
),
(
"cmp",
"T1",
&[r0, Operand::Imm(256)],
false,
"imm8 max is 255",
),
("cmp", "T1", &[r8, Operand::Imm(1)], false, "Rn is high"),
(
"add",
"T2",
&[r0, Operand::Imm(256)],
true,
"imm8 max is 255",
),
("add", "T2", &[r8, Operand::Imm(1)], true, "Rdn is high"),
(
"sub",
"T2",
&[r0, Operand::Imm(256)],
true,
"imm8 max is 255",
),
("sub", "T2", &[r8, Operand::Imm(1)], true, "Rdn is high"),
(
"mov",
"T1",
&[r0, Operand::Imm(1)],
false,
"MOV T1 sets flags",
),
(
"cmp",
"T1",
&[r0, Operand::Imm(1)],
true,
"CMP has no S bit",
),
("mov", "T2", &[r0, r1], false, "MOV T2 sets flags"),
(
"lsl",
"T1",
&[r0, r1, Operand::Imm(2)],
false,
"LSL T1 sets flags",
),
("add", "T1", &[r0, r1, r1], false, "ADD reg T1 sets flags"),
(
"add",
"T2",
&[r0, Operand::Imm(1)],
false,
"ADD imm T2 sets flags",
),
(
"sub",
"T2",
&[r0, Operand::Imm(1)],
false,
"SUB imm T2 sets flags",
),
];
for &(mnemonic, encoding, ops, sets_flags, why) in cases {
let insn = build(mnemonic, encoding, ops, sets_flags);
assert_eq!(encode(&insn), None, "`{insn}` encoded anyway: {why}");
}
assert_eq!(encode(&build("mov", "T2", &[r0, r1], true)), Some(0x0008));
assert_eq!(
encode(&build("lsl", "T1", &[r0, r1, Operand::Imm(31)], true)),
Some(0x07C8)
);
assert_eq!(
encode(&build("lsr", "T1", &[r0, r1, Operand::Imm(32)], true)),
Some(0x0808),
"a shift of 32 encodes as a zero field (A7.4.2)"
);
assert_eq!(
encode(&build("add", "T1", &[r0, r1, Operand::Imm(7)], true)),
Some(0x1DC8)
);
assert_eq!(
encode(&build("sub", "T2", &[r0, Operand::Imm(255)], true)),
Some(0x38FF)
);
}
}