use super::{Insn, Operand, Operands, Reg, Width};
#[derive(Clone, Copy)]
struct Cell {
acc: &'static str,
plain: Option<&'static str>,
}
macro_rules! both {
($acc:expr, $plain:expr) => {
Some(Cell {
acc: $acc,
plain: Some($plain),
})
};
}
macro_rules! only {
($acc:expr) => {
Some(Cell {
acc: $acc,
plain: None,
})
};
}
const TABLE_A5_28: [[Option<Cell>; 4]; 8] = [
[both!("mla", "mul"), only!("mls"), None, None],
[
both!("smlabb", "smulbb"),
both!("smlabt", "smulbt"),
both!("smlatb", "smultb"),
both!("smlatt", "smultt"),
],
[
both!("smlad", "smuad"),
both!("smladx", "smuadx"),
None,
None,
],
[
both!("smlawb", "smulwb"),
both!("smlawt", "smulwt"),
None,
None,
],
[
both!("smlsd", "smusd"),
both!("smlsdx", "smusdx"),
None,
None,
],
[
both!("smmla", "smmul"),
both!("smmlar", "smmulr"),
None,
None,
],
[only!("smmls"), only!("smmlsr"), None, None],
[both!("usada8", "usad8"), None, None, None], ];
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum Shape {
Long,
Div,
}
#[derive(Clone, Copy)]
struct Row29 {
op1: u16,
op2: u16,
mnemonic: &'static str,
shape: Shape,
}
macro_rules! long {
($op1:expr, $op2:expr, $mnemonic:expr) => {
Row29 {
op1: $op1,
op2: $op2,
mnemonic: $mnemonic,
shape: Shape::Long,
}
};
}
macro_rules! div {
($op1:expr, $op2:expr, $mnemonic:expr) => {
Row29 {
op1: $op1,
op2: $op2,
mnemonic: $mnemonic,
shape: Shape::Div,
}
};
}
const TABLE_A5_29: [Row29; 15] = [
long!(0b000, 0b0000, "smull"), div!(0b001, 0b1111, "sdiv"), long!(0b010, 0b0000, "umull"), div!(0b011, 0b1111, "udiv"), long!(0b100, 0b0000, "smlal"), long!(0b100, 0b1000, "smlalbb"), long!(0b100, 0b1001, "smlalbt"), long!(0b100, 0b1010, "smlaltb"), long!(0b100, 0b1011, "smlaltt"), long!(0b100, 0b1100, "smlald"), long!(0b100, 0b1101, "smlaldx"), long!(0b101, 0b1100, "smlsld"), long!(0b101, 0b1101, "smlsldx"), long!(0b110, 0b0000, "umlal"), long!(0b110, 0b0110, "umaal"), ];
const ALIAS: u8 = 0b1111;
pub(crate) fn decode(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw1 >> 8 != 0xFB {
return None;
}
if hw1 & 0x80 == 0 {
decode_a5_3_16(hw1, hw2, addr)
} else {
decode_a5_3_17(hw1, hw2, addr)
}
}
fn decode_a5_3_16(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw2 & 0b1100_0000 != 0 {
return None;
}
let op1 = ((hw1 >> 4) & 0b111) as usize;
let op2 = ((hw2 >> 4) & 0b11) as usize;
let cell = TABLE_A5_28[op1][op2]?;
let rn = Reg((hw1 & 0xF) as u8);
let ra = Reg(((hw2 >> 12) & 0xF) as u8);
let rd = Reg(((hw2 >> 8) & 0xF) as u8);
let rm = Reg((hw2 & 0xF) as u8);
let mut operands = Operands::new();
operands.push(Operand::Reg(rd));
operands.push(Operand::Reg(rn));
operands.push(Operand::Reg(rm));
let mnemonic = match cell.plain {
Some(plain) if ra.num() == ALIAS => plain,
_ => {
operands.push(Operand::Reg(ra));
cell.acc
}
};
Some(Insn {
mnemonic,
encoding: if mnemonic == "mul" { "T2" } else { "T1" },
addr,
width: Width::Wide,
cond: None,
sets_flags: false,
explicit_width: false,
operands,
})
}
fn decode_a5_3_17(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let op1 = (hw1 >> 4) & 0b111;
let op2 = (hw2 >> 4) & 0xF;
let row = TABLE_A5_29.iter().find(|r| r.op1 == op1 && r.op2 == op2)?;
let rn = Reg((hw1 & 0xF) as u8);
let rdlo = Reg(((hw2 >> 12) & 0xF) as u8);
let rdhi = Reg(((hw2 >> 8) & 0xF) as u8);
let rm = Reg((hw2 & 0xF) as u8);
let mut operands = Operands::new();
match row.shape {
Shape::Long => {
operands.push(Operand::Reg(rdlo));
operands.push(Operand::Reg(rdhi));
operands.push(Operand::Reg(rn));
operands.push(Operand::Reg(rm));
}
Shape::Div => {
if rdlo.num() != ALIAS {
return None;
}
operands.push(Operand::Reg(rdhi));
operands.push(Operand::Reg(rn));
operands.push(Operand::Reg(rm));
}
}
Some(Insn {
mnemonic: row.mnemonic,
encoding: "T1",
addr,
width: Width::Wide,
cond: None,
sets_flags: false,
explicit_width: false,
operands,
})
}
pub(crate) fn encode(insn: &Insn) -> Option<(u16, u16)> {
if insn.width != Width::Wide || insn.sets_flags {
return None;
}
encode_a5_3_16(insn).or_else(|| encode_a5_3_17(insn))
}
fn reg_at(insn: &Insn, i: usize) -> Option<u16> {
match insn.operands.get(i) {
Some(Operand::Reg(r)) => Some(r.num() as u16),
_ => None,
}
}
fn encode_a5_3_16(insn: &Insn) -> Option<(u16, u16)> {
let (op1, op2, cell, plain) = find_a5_28(insn.mnemonic)?;
let wide_mul = insn.mnemonic == "mul";
if insn.encoding != if wide_mul { "T2" } else { "T1" } || insn.explicit_width {
return None;
}
let rd = reg_at(insn, 0)?;
let rn = reg_at(insn, 1)?;
let rm = reg_at(insn, 2)?;
let ra = if plain {
if insn.operands.len() != 3 {
return None;
}
u16::from(ALIAS)
} else {
if insn.operands.len() != 4 {
return None;
}
let ra = reg_at(insn, 3)?;
if cell.plain.is_some() && ra == u16::from(ALIAS) {
return None;
}
ra
};
Some((0xFB00 | op1 << 4 | rn, ra << 12 | rd << 8 | op2 << 4 | rm))
}
fn encode_a5_3_17(insn: &Insn) -> Option<(u16, u16)> {
let row = TABLE_A5_29.iter().find(|r| r.mnemonic == insn.mnemonic)?;
if insn.encoding != "T1" || insn.explicit_width {
return None;
}
let (rn, hw2) = match row.shape {
Shape::Long => {
if insn.operands.len() != 4 {
return None;
}
let (rdlo, rdhi) = (reg_at(insn, 0)?, reg_at(insn, 1)?);
let (rn, rm) = (reg_at(insn, 2)?, reg_at(insn, 3)?);
(rn, rdlo << 12 | rdhi << 8 | row.op2 << 4 | rm)
}
Shape::Div => {
if insn.operands.len() != 3 {
return None;
}
let rd = reg_at(insn, 0)?;
let (rn, rm) = (reg_at(insn, 1)?, reg_at(insn, 2)?);
(rn, 0xF000 | rd << 8 | row.op2 << 4 | rm)
}
};
Some((0xFB80 | row.op1 << 4 | rn, hw2))
}
fn find_a5_28(mnemonic: &str) -> Option<(u16, u16, Cell, bool)> {
for (op1, row) in TABLE_A5_28.iter().enumerate() {
for (op2, cell) in row.iter().enumerate() {
if let Some(cell) = cell {
if cell.acc == mnemonic {
return Some((op1 as u16, op2 as u16, *cell, false));
}
if cell.plain == Some(mnemonic) {
return Some((op1 as u16, op2 as u16, *cell, true));
}
}
}
}
None
}
#[cfg(test)]
mod tests {
use super::*;
use crate::isa::decode_halfwords;
use crate::isa::Target;
fn hw1_28(op1: u16, rn: u16) -> u16 {
0xFB00 | op1 << 4 | rn
}
fn hw1_29(op1: u16, rn: u16) -> u16 {
0xFB80 | op1 << 4 | rn
}
fn hw2_28(ra: u16, rd: u16, op2: u16, rm: u16) -> u16 {
ra << 12 | rd << 8 | op2 << 4 | rm
}
fn hw2_29(rdlo: u16, rdhi: u16, op2: u16, rm: u16) -> u16 {
rdlo << 12 | rdhi << 8 | op2 << 4 | rm
}
fn ual28(op1: u16, op2: u16, ra: u16) -> String {
decode(hw1_28(op1, 1), hw2_28(ra, 0, op2, 2), 0)
.expect("allocated in Table A5-28")
.to_string()
}
fn ual29(op1: u16, op2: u16, rdlo: u16) -> String {
decode(hw1_29(op1, 2), hw2_29(rdlo, 1, op2, 3), 0)
.expect("allocated in Table A5-29")
.to_string()
}
const RA: [u16; 2] = [0, 15];
const REGS: [u16; 3] = [0, 1, 15];
#[test]
fn a5_3_16_round_trips_exhaustively() {
let mut decoded = 0usize;
let mut undefined = 0usize;
for op1 in 0..8u16 {
for op2 in 0..4u16 {
for ra in RA {
for rn in REGS {
for rd in REGS {
for rm in REGS {
let hw1 = hw1_28(op1, rn);
let hw2 = hw2_28(ra, rd, op2, rm);
match decode(hw1, hw2, 0) {
Some(insn) => {
decoded += 1;
assert_eq!(
insn.width,
Width::Wide,
"{hw1:#06x} {hw2:#06x}"
);
assert_eq!(insn.len(), 4, "{hw1:#06x} {hw2:#06x}");
assert!(
!insn.sets_flags,
"nothing in A5.3.16 sets flags: {hw1:#06x} {hw2:#06x}"
);
assert!(insn.cond.is_none(), "{hw1:#06x} {hw2:#06x}");
assert_eq!(
encode(&insn),
Some((hw1, hw2)),
"round-trip of {hw1:#06x} {hw2:#06x} ({insn})"
);
}
None => {
undefined += 1;
assert!(
TABLE_A5_28[op1 as usize][op2 as usize].is_none(),
"{hw1:#06x} {hw2:#06x} is allocated but did not decode"
);
}
}
}
}
}
}
}
}
assert_eq!(decoded + undefined, 1728);
assert_eq!(decoded, 17 * 54, "allocated cells");
assert_eq!(decoded, 918);
assert_eq!(undefined, 15 * 54, "UNDEFINED cells");
assert_eq!(undefined, 810);
}
#[test]
fn a5_3_17_round_trips_exhaustively() {
let mut decoded = 0usize;
let mut undefined = 0usize;
for op1 in 0..8u16 {
for op2 in 0..16u16 {
for rdlo in RA {
for rn in REGS {
for rdhi in REGS {
for rm in REGS {
let hw1 = hw1_29(op1, rn);
let hw2 = hw2_29(rdlo, rdhi, op2, rm);
match decode(hw1, hw2, 0) {
Some(insn) => {
decoded += 1;
assert_eq!(
insn.width,
Width::Wide,
"{hw1:#06x} {hw2:#06x}"
);
assert_eq!(insn.encoding, "T1", "{hw1:#06x} {hw2:#06x}");
assert!(
!insn.sets_flags,
"nothing in A5.3.17 sets flags: {hw1:#06x} {hw2:#06x}"
);
assert!(!insn.explicit_width, "{hw1:#06x} {hw2:#06x}");
assert_eq!(
encode(&insn),
Some((hw1, hw2)),
"round-trip of {hw1:#06x} {hw2:#06x} ({insn})"
);
}
None => {
undefined += 1;
let row = TABLE_A5_29
.iter()
.find(|r| r.op1 == op1 && r.op2 == op2);
match row {
None => {}
Some(r) => assert!(
r.shape == Shape::Div && rdlo != 15,
"{hw1:#06x} {hw2:#06x} is allocated but did not decode"
),
}
}
}
}
}
}
}
}
}
assert_eq!(decoded + undefined, 6912);
assert_eq!(decoded, 13 * 54 + 2 * 27, "allocated rows");
assert_eq!(decoded, 756);
assert_eq!(undefined, 113 * 54 + 2 * 27, "UNDEFINED plus SBO rejects");
assert_eq!(undefined, 6156);
}
#[test]
fn second_halfword_bits_7_6_must_be_zero() {
for op1 in 0..8u16 {
for op2 in 0..4u16 {
for high in 1..4u16 {
let hw2 = hw2_28(3, 0, op2, 2) | high << 6;
assert!(
decode(hw1_28(op1, 1), hw2, 0).is_none(),
"op1={op1:03b} op2={op2:02b} hw2[7:6]={high:02b}"
);
}
}
}
}
#[test]
fn outside_the_group_is_not_ours() {
assert!(decode(0xFAF1, 0xF082, 0).is_none());
assert!(decode(0xFC01, 0xF002, 0).is_none());
assert!(decode(0x4351, 0, 0).is_none());
}
#[test]
fn table_a5_28_prints_ual() {
assert_eq!(ual28(0b000, 0b00, 3), "mla r0, r1, r2, r3");
assert_eq!(ual28(0b000, 0b00, 15), "mul r0, r1, r2");
assert_eq!(ual28(0b000, 0b01, 3), "mls r0, r1, r2, r3");
assert_eq!(ual28(0b001, 0b00, 3), "smlabb r0, r1, r2, r3");
assert_eq!(ual28(0b001, 0b01, 3), "smlabt r0, r1, r2, r3");
assert_eq!(ual28(0b001, 0b10, 3), "smlatb r0, r1, r2, r3");
assert_eq!(ual28(0b001, 0b11, 3), "smlatt r0, r1, r2, r3");
assert_eq!(ual28(0b001, 0b00, 15), "smulbb r0, r1, r2");
assert_eq!(ual28(0b001, 0b01, 15), "smulbt r0, r1, r2");
assert_eq!(ual28(0b001, 0b10, 15), "smultb r0, r1, r2");
assert_eq!(ual28(0b001, 0b11, 15), "smultt r0, r1, r2");
assert_eq!(ual28(0b010, 0b00, 3), "smlad r0, r1, r2, r3");
assert_eq!(ual28(0b010, 0b01, 3), "smladx r0, r1, r2, r3");
assert_eq!(ual28(0b010, 0b00, 15), "smuad r0, r1, r2");
assert_eq!(ual28(0b010, 0b01, 15), "smuadx r0, r1, r2");
assert_eq!(ual28(0b011, 0b00, 3), "smlawb r0, r1, r2, r3");
assert_eq!(ual28(0b011, 0b01, 3), "smlawt r0, r1, r2, r3");
assert_eq!(ual28(0b011, 0b00, 15), "smulwb r0, r1, r2");
assert_eq!(ual28(0b011, 0b01, 15), "smulwt r0, r1, r2");
assert_eq!(ual28(0b100, 0b00, 3), "smlsd r0, r1, r2, r3");
assert_eq!(ual28(0b100, 0b01, 3), "smlsdx r0, r1, r2, r3");
assert_eq!(ual28(0b100, 0b00, 15), "smusd r0, r1, r2");
assert_eq!(ual28(0b100, 0b01, 15), "smusdx r0, r1, r2");
assert_eq!(ual28(0b101, 0b00, 3), "smmla r0, r1, r2, r3");
assert_eq!(ual28(0b101, 0b01, 3), "smmlar r0, r1, r2, r3");
assert_eq!(ual28(0b101, 0b00, 15), "smmul r0, r1, r2");
assert_eq!(ual28(0b101, 0b01, 15), "smmulr r0, r1, r2");
assert_eq!(ual28(0b110, 0b00, 3), "smmls r0, r1, r2, r3");
assert_eq!(ual28(0b110, 0b01, 3), "smmlsr r0, r1, r2, r3");
assert_eq!(ual28(0b111, 0b00, 3), "usada8 r0, r1, r2, r3");
assert_eq!(ual28(0b111, 0b00, 15), "usad8 r0, r1, r2");
}
#[test]
fn table_a5_29_prints_ual() {
assert_eq!(ual29(0b000, 0b0000, 0), "smull r0, r1, r2, r3");
assert_eq!(ual29(0b001, 0b1111, 15), "sdiv r1, r2, r3");
assert_eq!(ual29(0b010, 0b0000, 0), "umull r0, r1, r2, r3");
assert_eq!(ual29(0b011, 0b1111, 15), "udiv r1, r2, r3");
assert_eq!(ual29(0b100, 0b0000, 0), "smlal r0, r1, r2, r3");
assert_eq!(ual29(0b100, 0b1000, 0), "smlalbb r0, r1, r2, r3");
assert_eq!(ual29(0b100, 0b1001, 0), "smlalbt r0, r1, r2, r3");
assert_eq!(ual29(0b100, 0b1010, 0), "smlaltb r0, r1, r2, r3");
assert_eq!(ual29(0b100, 0b1011, 0), "smlaltt r0, r1, r2, r3");
assert_eq!(ual29(0b100, 0b1100, 0), "smlald r0, r1, r2, r3");
assert_eq!(ual29(0b100, 0b1101, 0), "smlaldx r0, r1, r2, r3");
assert_eq!(ual29(0b101, 0b1100, 0), "smlsld r0, r1, r2, r3");
assert_eq!(ual29(0b101, 0b1101, 0), "smlsldx r0, r1, r2, r3");
assert_eq!(ual29(0b110, 0b0000, 0), "umlal r0, r1, r2, r3");
assert_eq!(ual29(0b110, 0b0110, 0), "umaal r0, r1, r2, r3");
}
#[test]
fn ra_1111_is_the_plain_multiply_not_r15() {
let rows: [(u16, u16, &str, &str); 12] = [
(0b000, 0b00, "mla", "mul"),
(0b001, 0b00, "smlabb", "smulbb"),
(0b001, 0b11, "smlatt", "smultt"),
(0b010, 0b00, "smlad", "smuad"),
(0b010, 0b01, "smladx", "smuadx"),
(0b011, 0b00, "smlawb", "smulwb"),
(0b011, 0b01, "smlawt", "smulwt"),
(0b100, 0b00, "smlsd", "smusd"),
(0b100, 0b01, "smlsdx", "smusdx"),
(0b101, 0b00, "smmla", "smmul"),
(0b101, 0b01, "smmlar", "smmulr"),
(0b111, 0b00, "usada8", "usad8"),
];
for (op1, op2, acc, plain) in rows {
let with_ra = decode(hw1_28(op1, 1), hw2_28(3, 0, op2, 2), 0).unwrap();
assert_eq!(with_ra.mnemonic, acc, "op1={op1:03b} op2={op2:02b}");
assert_eq!(with_ra.operands.len(), 4, "{acc} accumulates");
assert_eq!(with_ra.operands.get(3), Some(Operand::Reg(Reg(3))));
let aliased = decode(hw1_28(op1, 1), hw2_28(15, 0, op2, 2), 0).unwrap();
assert_eq!(aliased.mnemonic, plain, "op1={op1:03b} op2={op2:02b}");
assert_eq!(aliased.operands.len(), 3, "{plain} has nothing to add");
assert_ne!(with_ra.mnemonic, aliased.mnemonic);
assert!(!aliased.to_string().contains("pc"));
}
}
#[test]
fn the_two_rows_without_an_alias_read_ra_as_r15() {
for (op1, op2, mnemonic) in [
(0b000u16, 0b01u16, "mls"),
(0b110, 0b00, "smmls"),
(0b110, 0b01, "smmlsr"),
] {
let insn = decode(hw1_28(op1, 1), hw2_28(15, 0, op2, 2), 0).unwrap();
assert_eq!(insn.mnemonic, mnemonic);
assert_eq!(insn.operands.len(), 4);
assert_eq!(insn.operands.get(3), Some(Operand::Reg(Reg::PC)));
assert!(insn.to_string().ends_with(", pc"));
assert_eq!(
encode(&insn),
Some((hw1_28(op1, 1), hw2_28(15, 0, op2, 2))),
"{mnemonic} with r15 still round-trips"
);
}
}
#[test]
fn halfword_suffix_matrix_is_n_then_m() {
let expected = ["bb", "bt", "tb", "tt"];
for (op2, half) in expected.iter().enumerate() {
let op2 = op2 as u16;
assert_eq!(
decode(hw1_28(0b001, 1), hw2_28(3, 0, op2, 2), 0)
.unwrap()
.mnemonic,
format!("smla{half}"),
"op2 = {op2:02b}"
);
assert_eq!(
decode(hw1_28(0b001, 1), hw2_28(15, 0, op2, 2), 0)
.unwrap()
.mnemonic,
format!("smul{half}"),
"op2 = {op2:02b}"
);
assert_eq!(
decode(hw1_29(0b100, 2), hw2_29(0, 1, 0b1000 | op2, 3), 0)
.unwrap()
.mnemonic,
format!("smlal{half}"),
"op2 = 10{op2:02b}"
);
}
assert_eq!(ual28(0b011, 0b00, 3), "smlawb r0, r1, r2, r3");
assert_eq!(ual28(0b011, 0b01, 3), "smlawt r0, r1, r2, r3");
}
#[test]
fn x_suffix_is_op2_bit_0() {
for (op1, base, x) in [(0b010u16, "smlad", "smladx"), (0b100, "smlsd", "smlsdx")] {
assert_eq!(
decode(hw1_28(op1, 1), hw2_28(3, 0, 0, 2), 0)
.unwrap()
.mnemonic,
base
);
assert_eq!(
decode(hw1_28(op1, 1), hw2_28(3, 0, 1, 2), 0)
.unwrap()
.mnemonic,
x
);
}
for (op1, base, x) in [(0b010u16, "smuad", "smuadx"), (0b100, "smusd", "smusdx")] {
assert_eq!(
decode(hw1_28(op1, 1), hw2_28(15, 0, 0, 2), 0)
.unwrap()
.mnemonic,
base
);
assert_eq!(
decode(hw1_28(op1, 1), hw2_28(15, 0, 1, 2), 0)
.unwrap()
.mnemonic,
x
);
}
for (op1, base, x) in [
(0b100u16, "smlald", "smlaldx"),
(0b101, "smlsld", "smlsldx"),
] {
assert_eq!(
decode(hw1_29(op1, 2), hw2_29(0, 1, 0b1100, 3), 0)
.unwrap()
.mnemonic,
base
);
assert_eq!(
decode(hw1_29(op1, 2), hw2_29(0, 1, 0b1101, 3), 0)
.unwrap()
.mnemonic,
x
);
}
}
#[test]
fn r_suffix_is_op2_bit_0() {
for (op1, ra, base, rounded) in [
(0b101u16, 3u16, "smmla", "smmlar"),
(0b101, 15, "smmul", "smmulr"),
(0b110, 3, "smmls", "smmlsr"),
] {
assert_eq!(
decode(hw1_28(op1, 1), hw2_28(ra, 0, 0, 2), 0)
.unwrap()
.mnemonic,
base
);
assert_eq!(
decode(hw1_28(op1, 1), hw2_28(ra, 0, 1, 2), 0)
.unwrap()
.mnemonic,
rounded
);
}
}
#[test]
fn smlal_names_both_destinations_in_the_manuals_order() {
let insn = decode(hw1_29(0b100, 2), hw2_29(4, 5, 0b0000, 3), 0).unwrap();
assert_eq!(insn.mnemonic, "smlal");
assert_eq!(insn.operands.len(), 4);
assert!(insn.operands.len() <= crate::isa::MAX_OPERANDS);
assert_eq!(insn.operands.get(0), Some(Operand::Reg(Reg(4)))); assert_eq!(insn.operands.get(1), Some(Operand::Reg(Reg(5)))); assert_eq!(insn.operands.get(2), Some(Operand::Reg(Reg(2)))); assert_eq!(insn.operands.get(3), Some(Operand::Reg(Reg(3)))); assert_eq!(insn.to_string(), "smlal r4, r5, r2, r3");
let same = decode(hw1_29(0b100, 2), hw2_29(4, 4, 0b0000, 3), 0).unwrap();
assert_eq!(same.to_string(), "smlal r4, r4, r2, r3");
assert_eq!(
encode(&same),
Some((hw1_29(0b100, 2), hw2_29(4, 4, 0b0000, 3)))
);
}
#[test]
fn divides_are_three_operands_with_an_sbo_field() {
let sdiv = decode(0xFB91, 0xF0F2, 0).unwrap();
assert_eq!(sdiv.to_string(), "sdiv r0, r1, r2");
assert_eq!(sdiv.operands.len(), 3);
assert_eq!(encode(&sdiv), Some((0xFB91, 0xF0F2)));
let udiv = decode(0xFBB1, 0xF0F2, 0).unwrap();
assert_eq!(udiv.to_string(), "udiv r0, r1, r2");
assert_eq!(encode(&udiv), Some((0xFBB1, 0xF0F2)));
assert!(decode(0xFB91, 0x00F2, 0).is_none());
assert!(decode(0xFB91, 0xF002, 0).is_none());
}
#[test]
fn known_good_encodings() {
for (hw1, hw2, text) in [
(0xFB01u16, 0xF002u16, "mul r0, r1, r2"),
(0xFB01, 0x3002, "mla r0, r1, r2, r3"),
(0xFB01, 0x3012, "mls r0, r1, r2, r3"),
(0xFB11, 0x3002, "smlabb r0, r1, r2, r3"),
(0xFB71, 0xF002, "usad8 r0, r1, r2"),
(0xFB71, 0x3002, "usada8 r0, r1, r2, r3"),
(0xFB82, 0x0103, "smull r0, r1, r2, r3"),
(0xFBA2, 0x0103, "umull r0, r1, r2, r3"),
(0xFBC2, 0x0103, "smlal r0, r1, r2, r3"),
(0xFBE2, 0x0103, "umlal r0, r1, r2, r3"),
(0xFBE2, 0x0163, "umaal r0, r1, r2, r3"),
] {
let insn = decode(hw1, hw2, 0).expect(text);
assert_eq!(insn.to_string(), text);
assert_eq!(encode(&insn), Some((hw1, hw2)), "{text}");
}
}
#[test]
fn wide_mul_does_not_collide_with_the_narrow_one() {
let wide = decode(0xFB01, 0xF002, 0).unwrap();
assert_eq!(wide.mnemonic, "mul");
assert_eq!(wide.encoding, "T2");
assert_eq!(wide.width, Width::Wide);
assert!(!wide.explicit_width);
assert!(!wide.sets_flags, "`muls` is the 16-bit T1, not this");
assert_eq!(wide.to_string(), "mul r0, r1, r2");
assert_eq!(encode(&wide), Some((0xFB01, 0xF002)));
assert_eq!(
decode_halfwords(0xFB01, 0xF002, 0, Target::Union),
Some(wide)
);
assert_eq!(crate::isa::encode(&wide), Some((0xFB01, 0xF002)));
let narrow = decode_halfwords(0x4351, 0, 0, Target::Union).unwrap();
assert_eq!(narrow.mnemonic, "mul");
assert_eq!(narrow.width, Width::Narrow);
assert_eq!(encode(&narrow), None);
assert_eq!(crate::isa::encode(&narrow), Some((0x4351, 0)));
}
#[test]
fn the_dispatcher_routes_both_sub_tables_here() {
for (hw1, hw2) in [(0xFB11u16, 0x3002u16), (0xFBC2, 0x0103)] {
assert_eq!(
decode_halfwords(hw1, hw2, 0, Target::Union),
decode(hw1, hw2, 0)
);
assert!(decode(hw1, hw2, 0).is_some());
}
}
#[test]
fn addr_is_carried_through() {
let insn = decode(0xFB01, 0xF002, 0x8010).unwrap();
assert_eq!(insn.addr, 0x8010);
assert!(insn.branch_target().is_none());
}
#[test]
fn encode_rejects_what_this_group_cannot_hold() {
let mla = decode(0xFB01, 0x3002, 0).unwrap();
let smlal = decode(0xFBC2, 0x0103, 0).unwrap();
let mut foreign = mla;
foreign.mnemonic = "add";
assert_eq!(encode(&foreign), None);
let mut narrow = mla;
narrow.width = Width::Narrow;
assert_eq!(encode(&narrow), None);
let mut t2 = mla;
t2.encoding = "T2";
assert_eq!(encode(&t2), None);
let mut suffixed = mla;
suffixed.explicit_width = true;
assert_eq!(encode(&suffixed), None);
let mut mul = decode(0xFB01, 0xF002, 0).unwrap();
mul.encoding = "T1";
assert_eq!(encode(&mul), None);
let mut suffixed_mul = decode(0xFB01, 0xF002, 0).unwrap();
suffixed_mul.explicit_width = true;
assert_eq!(encode(&suffixed_mul), None);
let mut flagged = mla;
flagged.sets_flags = true;
assert_eq!(encode(&flagged), None);
let mut mla_pc = mla;
mla_pc.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Reg(Reg(2)),
Operand::Reg(Reg::PC),
]
.into_iter()
.collect();
assert_eq!(encode(&mla_pc), None);
let mut short_mla = mla;
short_mla.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Reg(Reg(2)),
]
.into_iter()
.collect();
assert_eq!(encode(&short_mla), None);
let mut long_mul = decode(0xFB01, 0xF002, 0).unwrap();
long_mul.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Reg(Reg(2)),
Operand::Reg(Reg(3)),
]
.into_iter()
.collect();
assert_eq!(encode(&long_mul), None);
let mut short_smlal = smlal;
short_smlal.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Reg(Reg(2)),
]
.into_iter()
.collect();
assert_eq!(encode(&short_smlal), None);
let mut long_sdiv = decode(0xFB91, 0xF0F2, 0).unwrap();
long_sdiv.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Reg(Reg(2)),
Operand::Reg(Reg(3)),
]
.into_iter()
.collect();
assert_eq!(encode(&long_sdiv), None);
let mut smlal_t2 = smlal;
smlal_t2.encoding = "T2";
assert_eq!(encode(&smlal_t2), None, "no T2 in Table A5-29");
let mut smlal_wide = smlal;
smlal_wide.explicit_width = true;
assert_eq!(encode(&smlal_wide), None, "`smlal.w` is not a spelling");
let shapes: [(Insn, usize); 4] = [
(mla, 4), (decode(0xFB01, 0xF002, 0).unwrap(), 3), (smlal, 4), (decode(0xFB91, 0xF0F2, 0).unwrap(), 3), ];
for (template, arity) in shapes {
assert_eq!(
template.operands.len(),
arity,
"`{}` should take {arity} operands",
template.mnemonic
);
for slot in 0..arity {
let mut mangled = template;
mangled.operands = (0..arity)
.map(|i| {
if i == slot {
Operand::Imm(0)
} else {
Operand::Reg(Reg(i as u8))
}
})
.collect();
assert_eq!(
encode(&mangled),
None,
"`{}` with a non-register in operand {slot}",
template.mnemonic
);
}
}
}
}