use super::{Insn, Operand, Operands, Reg, Width};
use crate::Cond;
fn sign_extend(value: u32, top: u32) -> u32 {
if value & (1 << top) != 0 {
value | (!0u32 << top)
} else {
value
}
}
fn one(op: Operand) -> Operands {
[op].into_iter().collect()
}
fn wide(mnemonic: &'static str, encoding: &'static str, addr: u32, operands: Operands) -> Insn {
Insn {
mnemonic,
encoding,
addr,
width: Width::Wide,
cond: None,
sets_flags: false,
explicit_width: false,
operands,
}
}
pub(crate) fn decode(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw1 >> 11 != 0b11110 || hw2 >> 15 != 1 {
return None;
}
let op = (hw1 >> 4) & 0b1111111;
match (hw2 >> 12) & 0b111 {
0b001 | 0b011 => b_t4(hw1, hw2, addr),
0b100 | 0b110 => blx_t2(hw1, hw2, addr),
0b101 | 0b111 => bl_t1(hw1, hw2, addr),
op1 => {
if op == 0b1111111 {
if op1 == 0b000 {
smc(hw1, hw2, addr)
} else {
udf_w(hw1, hw2, addr)
}
} else if let Some(cond) = t3_cond(hw1) {
Some(b_t3(hw1, hw2, addr, cond))
} else if op1 == 0b000 {
control(hw1, hw2, addr, op)
} else {
None
}
}
}
}
fn wide_imm(hw1: u16, hw2: u16) -> u32 {
let s = ((hw1 >> 10) & 1) as u32;
let imm10 = (hw1 & 0x3FF) as u32;
let j1 = ((hw2 >> 13) & 1) as u32;
let j2 = ((hw2 >> 11) & 1) as u32;
let imm11 = (hw2 & 0x7FF) as u32;
let i1 = !(j1 ^ s) & 1;
let i2 = !(j2 ^ s) & 1;
sign_extend(
(s << 24) | (i1 << 23) | (i2 << 22) | (imm10 << 12) | (imm11 << 1),
24,
)
}
fn t3_cond(hw1: u16) -> Option<Cond> {
let cond = Cond::from_bits(((hw1 >> 6) & 0xF) as u8)?;
if cond == Cond::Al {
None
} else {
Some(cond)
}
}
fn b_t3(hw1: u16, hw2: u16, addr: u32, cond: Cond) -> Insn {
let s = ((hw1 >> 10) & 1) as u32;
let imm6 = (hw1 & 0x3F) as u32;
let j1 = ((hw2 >> 13) & 1) as u32;
let j2 = ((hw2 >> 11) & 1) as u32;
let imm11 = (hw2 & 0x7FF) as u32;
let imm = sign_extend(
(s << 20) | (j2 << 19) | (j1 << 18) | (imm6 << 12) | (imm11 << 1),
20,
);
Insn {
cond: Some(cond),
explicit_width: true,
..wide(
"b",
"T3",
addr,
one(Operand::Target(addr.wrapping_add(4).wrapping_add(imm))),
)
}
}
fn b_t4(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let target = addr.wrapping_add(4).wrapping_add(wide_imm(hw1, hw2));
Some(Insn {
explicit_width: true,
..wide("b", "T4", addr, one(Operand::Target(target)))
})
}
fn bl_t1(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let target = addr.wrapping_add(4).wrapping_add(wide_imm(hw1, hw2));
Some(wide("bl", "T1", addr, one(Operand::Target(target))))
}
fn blx_t2(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw2 & 1 != 0 {
return None;
}
let pc = addr.wrapping_add(4) & !3;
let target = pc.wrapping_add(wide_imm(hw1, hw2));
Some(wide("blx", "T2", addr, one(Operand::Target(target))))
}
fn control(hw1: u16, hw2: u16, addr: u32, op: u16) -> Option<Insn> {
match op {
0b0111000 | 0b0111001 => msr(hw1, hw2, addr),
0b0111010 => hint_or_cps(hw1, hw2, addr),
0b0111011 => misc_control(hw1, hw2, addr),
0b0111100 => bxj(hw1, hw2, addr),
0b0111101 => subs_pc_lr(hw1, hw2, addr),
0b0111110 | 0b0111111 => mrs(hw1, hw2, addr),
_ => None,
}
}
fn msr(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let name = msr_dest(
(hw1 >> 4) & 1 == 1,
((hw2 >> 8) & 0xF) as u8,
(hw2 & 0xFF) as u8,
)?;
let mut operands = Operands::new();
operands.push(Operand::SpecialReg(name));
operands.push(Operand::Reg(Reg((hw1 & 0xF) as u8)));
Some(wide("msr", "T1", addr, operands))
}
fn mrs(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw1 & 0xF != 0xF {
return None;
}
let name = mrs_src((hw1 >> 4) & 1 == 1, (hw2 & 0xFF) as u8)?;
let mut operands = Operands::new();
operands.push(Operand::Reg(Reg(((hw2 >> 8) & 0xF) as u8)));
operands.push(Operand::SpecialReg(name));
Some(wide("mrs", "T1", addr, operands))
}
fn bxj(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw2 != 0x8F00 {
return None;
}
Some(wide(
"bxj",
"T1",
addr,
one(Operand::Reg(Reg((hw1 & 0xF) as u8))),
))
}
fn subs_pc_lr(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw1 & 0xF != 0b1110 || hw2 >> 8 != 0x8F {
return None;
}
let mut operands = Operands::new();
operands.push(Operand::Reg(Reg::PC));
operands.push(Operand::Reg(Reg::LR));
operands.push(Operand::Imm((hw2 & 0xFF) as i64));
Some(Insn {
sets_flags: true,
..wide("sub", "T1", addr, operands)
})
}
fn smc(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw2 != 0x8000 {
return None;
}
Some(wide(
"smc",
"T1",
addr,
one(Operand::Imm((hw1 & 0xF) as i64)),
))
}
fn udf_w(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let imm16 = ((hw1 & 0xF) as i64) << 12 | (hw2 & 0xFFF) as i64;
Some(Insn {
explicit_width: true,
..wide("udf", "T2", addr, one(Operand::Imm(imm16)))
})
}
fn hint_or_cps(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw1 != 0xF3AF || hw2 & 0x0800 != 0 {
return None;
}
let op1 = (hw2 >> 8) & 0b111;
let op2 = (hw2 & 0xFF) as u8;
if op1 != 0 {
return cps(op1, op2, addr);
}
if op2 & 0xF0 == 0xF0 {
return Some(wide(
"dbg",
"T1",
addr,
one(Operand::Imm((op2 & 0xF) as i64)),
));
}
let mnemonic = hint_name(op2)?;
Some(Insn {
explicit_width: true,
..wide(mnemonic, hint_encoding(mnemonic), addr, Operands::new())
})
}
fn hint_encoding(mnemonic: &str) -> &'static str {
if mnemonic == "csdb" {
"T1"
} else {
"T2"
}
}
fn hint_name(op2: u8) -> Option<&'static str> {
Some(match op2 {
0x00 => "nop",
0x01 => "yield",
0x02 => "wfe",
0x03 => "wfi",
0x04 => "sev",
0x14 => "csdb",
_ => return None,
})
}
fn cps(op1: u16, op2: u8, addr: u32) -> Option<Insn> {
let imod = (op1 >> 1) & 0b11;
let m = op1 & 1 == 1;
let a = op2 & 0x80 != 0;
let i = op2 & 0x40 != 0;
let f = op2 & 0x20 != 0;
let mode = (op2 & 0x1F) as i64;
if imod == 0b01 {
return None;
}
if imod == 0b00 {
if a || i || f {
return None;
}
return Some(wide("cps", "T2", addr, one(Operand::Imm(mode))));
}
if !m && mode != 0 {
return None;
}
let mut operands = Operands::new();
operands.push(Operand::Text(iflags(a, i, f)?));
if m {
operands.push(Operand::Imm(mode));
}
Some(Insn {
explicit_width: true,
..wide(
if imod == 0b10 { "cpsie" } else { "cpsid" },
"T2",
addr,
operands,
)
})
}
fn iflags(a: bool, i: bool, f: bool) -> Option<&'static str> {
Some(match (a, i, f) {
(false, false, false) => return None,
(true, false, false) => "a",
(false, true, false) => "i",
(false, false, true) => "f",
(true, true, false) => "ai",
(true, false, true) => "af",
(false, true, true) => "if",
(true, true, true) => "aif",
})
}
fn misc_control(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw1 != 0xF3BF || hw2 >> 8 != 0x8F {
return None;
}
let opc = (hw2 >> 4) & 0xF;
let option = (hw2 & 0xF) as u8;
let bare = |mnemonic| Some(wide(mnemonic, "T1", addr, Operands::new()));
match opc {
0b0000 | 0b0001 if option == 0xF => bare(if opc == 0 { "leavex" } else { "enterx" }),
0b0010 if option == 0xF => bare("clrex"),
0b0100 => match option {
0b0000 => bare("ssbb"),
0b0100 => bare("pssbb"),
_ => Some(wide("dsb", "T1", addr, one(barrier_operand(option, true)))),
},
0b0101 => Some(wide("dmb", "T1", addr, one(barrier_operand(option, true)))),
0b0110 => Some(wide("isb", "T1", addr, one(barrier_operand(option, false)))),
_ => None,
}
}
fn barrier_option(bits: u8) -> Option<&'static str> {
Some(match bits {
0b0010 => "oshst",
0b0011 => "osh",
0b0110 => "nshst",
0b0111 => "nsh",
0b1010 => "ishst",
0b1011 => "ish",
0b1110 => "st",
0b1111 => "sy",
_ => return None,
})
}
fn barrier_operand(bits: u8, shareability: bool) -> Operand {
let name = if shareability {
barrier_option(bits)
} else if bits == 0b1111 {
Some("sy")
} else {
None
};
match name {
Some(n) => Operand::Option(n),
None => Operand::Imm(bits as i64),
}
}
fn msr_dest(spsr: bool, mask: u8, sysm: u8) -> Option<&'static str> {
if spsr {
return if sysm == 0 {
psr_fields(true, mask)
} else {
None
};
}
if mask & 0b0011 == 0 {
m_profile_write(mask >> 2, sysm)
} else if sysm == 0 {
psr_fields(false, mask)
} else {
None
}
}
fn mrs_src(spsr: bool, sysm: u8) -> Option<&'static str> {
if spsr {
return if sysm == 0 { Some("SPSR") } else { None };
}
m_profile_read(sysm)
}
fn m_profile_write(mask: u8, sysm: u8) -> Option<&'static str> {
Some(match (sysm, mask) {
(0, 0b01) => "APSR_g",
(0, 0b10) => "APSR_nzcvq",
(0, 0b11) => "APSR_nzcvqg",
(1, 0b01) => "IAPSR_g",
(1, 0b10) => "IAPSR_nzcvq",
(1, 0b11) => "IAPSR_nzcvqg",
(2, 0b01) => "EAPSR_g",
(2, 0b10) => "EAPSR_nzcvq",
(2, 0b11) => "EAPSR_nzcvqg",
(3, 0b01) => "XPSR_g",
(3, 0b10) => "XPSR_nzcvq",
(3, 0b11) => "XPSR_nzcvqg",
(5, 0b10) => "IPSR",
(6, 0b10) => "EPSR",
(7, 0b10) => "IEPSR",
(8, 0b10) => "MSP",
(9, 0b10) => "PSP",
(16, 0b10) => "PRIMASK",
(17, 0b10) => "BASEPRI",
(18, 0b10) => "BASEPRI_MAX",
(19, 0b10) => "FAULTMASK",
(20, 0b10) => "CONTROL",
_ => return None,
})
}
fn m_profile_read(sysm: u8) -> Option<&'static str> {
Some(match sysm {
0 => "APSR",
1 => "IAPSR",
2 => "EAPSR",
3 => "XPSR",
5 => "IPSR",
6 => "EPSR",
7 => "IEPSR",
8 => "MSP",
9 => "PSP",
16 => "PRIMASK",
17 => "BASEPRI",
18 => "BASEPRI_MAX",
19 => "FAULTMASK",
20 => "CONTROL",
_ => return None,
})
}
const SPSR_FIELDS: [&str; 16] = [
"",
"SPSR_c",
"SPSR_x",
"SPSR_xc",
"SPSR_s",
"SPSR_sc",
"SPSR_sx",
"SPSR_sxc",
"SPSR_f",
"SPSR_fc",
"SPSR_fx",
"SPSR_fxc",
"SPSR_fs",
"SPSR_fsc",
"SPSR_fsx",
"SPSR_fsxc",
];
const CPSR_FIELDS: [&str; 16] = [
"",
"CPSR_c",
"CPSR_x",
"CPSR_xc",
"",
"CPSR_sc",
"CPSR_sx",
"CPSR_sxc",
"",
"CPSR_fc",
"CPSR_fx",
"CPSR_fxc",
"",
"CPSR_fsc",
"CPSR_fsx",
"CPSR_fsxc",
];
fn psr_fields(spsr: bool, mask: u8) -> Option<&'static str> {
let table = if spsr { &SPSR_FIELDS } else { &CPSR_FIELDS };
match table[(mask & 0xF) as usize] {
"" => None,
name => Some(name),
}
}
pub(crate) fn encode(insn: &Insn) -> Option<(u16, u16)> {
if insn.width != Width::Wide {
return None;
}
let imm = |i: usize, max: i64| match insn.operands.get(i) {
Some(Operand::Imm(v)) if (0..=max).contains(&v) => Some(v as u16),
_ => None,
};
if let Some(op2) = hint_bits(insn.mnemonic, insn.encoding) {
if !insn.explicit_width || insn.sets_flags || !insn.operands.is_empty() {
return None;
}
return Some((0xF3AF, 0x8000 | op2));
}
match (insn.mnemonic, insn.encoding) {
("b", "T3") => encode_b_t3(insn),
("b", "T4") => encode_branch(insn, 0x9000, 2, true),
("bl", "T1") => encode_branch(insn, 0xD000, 2, false),
("blx", "T2") => encode_branch(insn, 0xC000, 4, false),
("udf", "T2") => {
if !insn.explicit_width || insn.sets_flags || insn.operands.len() != 1 {
return None;
}
let v = imm(0, 0xFFFF)?;
Some((0xF7F0 | (v >> 12), 0xA000 | (v & 0xFFF)))
}
("smc", "T1") => {
if insn.explicit_width || insn.sets_flags || insn.operands.len() != 1 {
return None;
}
Some((0xF7F0 | imm(0, 0xF)?, 0x8000))
}
("msr", "T1") => {
if insn.explicit_width || insn.sets_flags || insn.operands.len() != 2 {
return None;
}
let name = match insn.operands.get(0) {
Some(Operand::SpecialReg(n)) => n,
_ => return None,
};
let rn = match insn.operands.get(1) {
Some(Operand::Reg(r)) => r.num() as u16,
_ => return None,
};
let (r, mask, sysm) = msr_dest_bits(name)?;
Some((0xF380 | (r << 4) | rn, 0x8000 | (mask << 8) | sysm))
}
("mrs", "T1") => {
if insn.explicit_width || insn.sets_flags || insn.operands.len() != 2 {
return None;
}
let rd = match insn.operands.get(0) {
Some(Operand::Reg(r)) => r.num() as u16,
_ => return None,
};
let name = match insn.operands.get(1) {
Some(Operand::SpecialReg(n)) => n,
_ => return None,
};
let (r, sysm) = mrs_src_bits(name)?;
Some((0xF3EF | (r << 4), 0x8000 | (rd << 8) | sysm))
}
("bxj", "T1") => {
if insn.explicit_width || insn.sets_flags || insn.operands.len() != 1 {
return None;
}
match insn.operands.get(0) {
Some(Operand::Reg(rm)) => Some((0xF3C0 | rm.num() as u16, 0x8F00)),
_ => None,
}
}
("sub", "T1") => {
if insn.explicit_width || !insn.sets_flags || insn.operands.len() != 3 {
return None;
}
if insn.operands.get(0) != Some(Operand::Reg(Reg::PC))
|| insn.operands.get(1) != Some(Operand::Reg(Reg::LR))
{
return None;
}
Some((0xF3DE, 0x8F00 | imm(2, 0xFF)?))
}
("dbg", "T1") => {
if insn.explicit_width || insn.sets_flags || insn.operands.len() != 1 {
return None;
}
Some((0xF3AF, 0x80F0 | imm(0, 0xF)?))
}
("cps" | "cpsie" | "cpsid", "T2") => encode_cps(insn),
("clrex" | "enterx" | "leavex", "T1") => {
if insn.explicit_width || insn.sets_flags || !insn.operands.is_empty() {
return None;
}
let opc = match insn.mnemonic {
"leavex" => 0x0,
"enterx" => 0x1,
_ => 0x2,
};
Some((0xF3BF, 0x8F0F | (opc << 4)))
}
("ssbb" | "pssbb", "T1") => {
if insn.explicit_width || insn.sets_flags || !insn.operands.is_empty() {
return None;
}
Some((0xF3BF, 0x8F40 | if insn.mnemonic == "ssbb" { 0 } else { 4 }))
}
("dsb" | "dmb" | "isb", "T1") => {
if insn.explicit_width || insn.sets_flags || insn.operands.len() != 1 {
return None;
}
let (opc, shareability) = match insn.mnemonic {
"dsb" => (0x4, true),
"dmb" => (0x5, true),
_ => (0x6, false),
};
let option = barrier_bits(insn.operands.get(0), shareability)?;
if opc == 0x4 && (option == 0 || option == 4) {
return None;
}
Some((0xF3BF, 0x8F00 | (opc << 4) | option))
}
_ => None,
}
}
fn encode_branch(insn: &Insn, base: u16, align: u32, explicit_width: bool) -> Option<(u16, u16)> {
if insn.explicit_width != explicit_width || insn.sets_flags || insn.operands.len() != 1 {
return None;
}
let target = match insn.operands.get(0) {
Some(Operand::Target(t)) => t,
_ => return None,
};
let mut pc = insn.addr.wrapping_add(4);
if align == 4 {
pc &= !3;
}
let off = target.wrapping_sub(pc) as i32;
if !(-(1 << 24)..(1 << 24)).contains(&off) || off & (align as i32 - 1) != 0 {
return None;
}
let imm = (off >> 1) as u32 & 0x00ff_ffff;
let s = (imm >> 23) & 1;
let i1 = (imm >> 22) & 1;
let i2 = (imm >> 21) & 1;
let j1 = !(i1 ^ s) & 1;
let j2 = !(i2 ^ s) & 1;
let hw1 = 0xF000 | ((s as u16) << 10) | ((imm >> 11) & 0x3FF) as u16;
let hw2 = base | ((j1 as u16) << 13) | ((j2 as u16) << 11) | (imm & 0x7FF) as u16;
Some((hw1, hw2))
}
fn encode_b_t3(insn: &Insn) -> Option<(u16, u16)> {
if !insn.explicit_width || insn.sets_flags || insn.operands.len() != 1 {
return None;
}
let cond = insn.cond?;
if cond == Cond::Al {
return None;
}
let target = match insn.operands.get(0) {
Some(Operand::Target(t)) => t,
_ => return None,
};
let off = target.wrapping_sub(insn.addr.wrapping_add(4)) as i32;
if !(-(1 << 20)..(1 << 20)).contains(&off) || off & 1 != 0 {
return None;
}
let imm = (off >> 1) as u32 & 0x000f_ffff;
let s = ((imm >> 19) & 1) as u16;
let j2 = ((imm >> 18) & 1) as u16;
let j1 = ((imm >> 17) & 1) as u16;
let hw1 = 0xF000 | (s << 10) | ((cond.bits() as u16) << 6) | ((imm >> 11) & 0x3F) as u16;
let hw2 = 0x8000 | (j1 << 13) | (j2 << 11) | (imm & 0x7FF) as u16;
Some((hw1, hw2))
}
fn encode_cps(insn: &Insn) -> Option<(u16, u16)> {
let (imod, wide_suffix) = match insn.mnemonic {
"cps" => (0b00u16, false),
"cpsie" => (0b10, true),
_ => (0b11, true),
};
if insn.explicit_width != wide_suffix || insn.sets_flags {
return None;
}
let mode_at = |i: usize| match insn.operands.get(i) {
Some(Operand::Imm(v)) if (0..=0x1F).contains(&v) => Some(v as u16),
_ => None,
};
let (m, mode, flags) = if imod == 0b00 {
if insn.operands.len() != 1 {
return None;
}
(1u16, mode_at(0)?, 0u16)
} else {
let name = match insn.operands.get(0) {
Some(Operand::Text(t)) => t,
_ => return None,
};
let bits =
(0u16..8).find(|b| iflags(b & 4 != 0, b & 2 != 0, b & 1 != 0) == Some(name))? << 5;
match insn.operands.len() {
1 => (0, 0, bits),
2 => (1, mode_at(1)?, bits),
_ => return None,
}
};
Some((0xF3AF, 0x8000 | (imod << 9) | (m << 8) | flags | mode))
}
fn msr_dest_bits(name: &str) -> Option<(u16, u16, u16)> {
for spsr in [false, true] {
for mask in 1u8..16 {
for sysm in [0u8, 1, 2, 3, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20] {
if msr_dest(spsr, mask, sysm) == Some(name) {
return Some((spsr as u16, mask as u16, sysm as u16));
}
}
}
}
None
}
fn mrs_src_bits(name: &str) -> Option<(u16, u16)> {
for spsr in [false, true] {
for sysm in 0u8..=20 {
if mrs_src(spsr, sysm) == Some(name) {
return Some((spsr as u16, sysm as u16));
}
}
}
None
}
fn barrier_bits(op: Option<Operand>, shareability: bool) -> Option<u16> {
(0u8..16)
.find(|&bits| Some(barrier_operand(bits, shareability)) == op)
.map(u16::from)
}
fn hint_bits(mnemonic: &str, encoding: &str) -> Option<u16> {
if encoding != hint_encoding(mnemonic) {
return None;
}
(0u8..=0xFF)
.find(|&op2| hint_name(op2) == Some(mnemonic))
.map(u16::from)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{decode_b_wide, decode_bl, encode_b_wide, encode_bl};
fn ual(hw1: u16, hw2: u16) -> String {
dec(hw1, hw2, 0).to_string()
}
fn dec(hw1: u16, hw2: u16, addr: u32) -> Insn {
let decoded = decode(hw1, hw2, addr);
assert!(decoded.is_some(), "{hw1:#06x} {hw2:#06x} did not decode");
decoded.unwrap()
}
fn round_trip(hw1: u16, hw2: u16, addr: u32) -> Insn {
let insn = dec(hw1, hw2, addr);
assert_eq!(
encode(&insn),
Some((hw1, hw2)),
"round-trip of {hw1:#06x} {hw2:#06x} ({insn})"
);
insn
}
fn with_operands(hw1: u16, hw2: u16, operands: &[Operand]) -> Insn {
let mut insn = dec(hw1, hw2, 0);
insn.operands = operands.iter().copied().collect();
insn
}
fn halfwords(bytes: [u8; 4]) -> (u16, u16) {
(
u16::from_le_bytes([bytes[0], bytes[1]]),
u16::from_le_bytes([bytes[2], bytes[3]]),
)
}
const WIDE_CASES: [(u32, u32); 9] = [
(0x0000_1000, 0x0000_2000), (0x0000_2000, 0x0000_1000), (0x0000_1000, 0x0000_1004), (0x0000_1000, 0x0000_1006), (0x0000_1000, 0x0000_1002), (0x0000_0000, 0x0100_0002), (0x0100_0000, 0x0000_0004), (0x0800_0000, 0x0800_0004 + 0x00FF_FFFE), (0x0800_0000, 0x0800_0004 - 0x0100_0000), ];
#[test]
fn bl_agrees_with_the_existing_oracle() {
for (site, target) in WIDE_CASES {
let encoded = encode_bl(site as usize, target);
assert!(
encoded.is_some(),
"oracle rejected {site:#x} -> {target:#x}"
);
let bytes = encoded.unwrap();
let (hw1, hw2) = halfwords(bytes);
let insn = round_trip(hw1, hw2, site);
assert_eq!(insn.mnemonic, "bl");
assert_eq!(insn.encoding, "T1");
assert_eq!(
insn.branch_target(),
decode_bl(&bytes, 0).map(|t| t.wrapping_add(site)),
"target disagreement at {site:#x} -> {target:#x}"
);
assert_eq!(insn.branch_target(), Some(target));
let mut relocated = insn;
relocated.addr = site;
assert_eq!(encode(&relocated), Some((hw1, hw2)));
}
}
#[test]
fn b_wide_agrees_with_the_existing_oracle() {
for (site, target) in WIDE_CASES {
let bytes = encode_b_wide(site as usize, target).unwrap();
let (hw1, hw2) = halfwords(bytes);
let insn = round_trip(hw1, hw2, site);
assert_eq!(insn.mnemonic, "b");
assert_eq!(insn.encoding, "T4");
assert_eq!(
insn.branch_target(),
decode_b_wide(&bytes, 0).map(|t| t.wrapping_add(site)),
"target disagreement at {site:#x} -> {target:#x}"
);
assert_eq!(insn.branch_target(), Some(target));
}
}
#[test]
fn assembler_verified_encodings() {
#[rustfmt::skip]
let cases: [(u16, u16, u32, &str); 24] = [
(0xF383, 0x8810, 0, "msr PRIMASK, r3"),
(0xF380, 0x8800, 0, "msr APSR_nzcvq, r0"),
(0xF3EF, 0x8010, 0, "mrs r0, PRIMASK"),
(0xF3EF, 0x8100, 0, "mrs r1, APSR"),
(0xF3AF, 0x8000, 0, "nop.w"),
(0xF3AF, 0x8014, 0, "csdb.w"),
(0xF3AF, 0x80FF, 0, "dbg #0xf"),
(0xF3BF, 0x8F4F, 0, "dsb sy"),
(0xF3BF, 0x8F4B, 0, "dsb ish"),
(0xF3BF, 0x8F52, 0, "dmb oshst"),
(0xF3BF, 0x8F6F, 0, "isb sy"),
(0xF3BF, 0x8F2F, 0, "clrex"),
(0xF7F1, 0xA234, 0, "udf.w #0x1234"),
(0xF000, 0xB800, 0x34, "b.w 0x38"),
(0xF000, 0xF800, 0x38, "bl 0x3c"),
(0xF43F, 0xAFFE, 0x3C, "beq.w 0x3c"),
(0xF3C5, 0x8F00, 0, "bxj r5"),
(0xF3DE, 0x8F04, 0, "subs pc, lr, #4"),
(0xF380, 0x8900, 0, "msr CPSR_fc, r0"),
(0xF394, 0x8100, 0, "msr SPSR_c, r4"),
(0xF3FF, 0x8200, 0, "mrs r2, SPSR"),
(0xF3AF, 0x8793, 0, "cpsid.w a, #0x13"),
(0xF7F5, 0x8000, 0, "smc #5"),
(0xF7FF, 0xEFFE, 0x08, "blx 0x8"),
];
for (hw1, hw2, addr, text) in cases {
assert_eq!(round_trip(hw1, hw2, addr).to_string(), text);
}
}
#[test]
fn oracle_decoders_are_offset_relative_and_still_agree_bit_for_bit() {
let mut image = [0u8; 4];
for s in 0..2u16 {
for j1 in 0..2u16 {
for j2 in 0..2u16 {
for (imm10, imm11) in [(0u16, 0u16), (0x3FF, 0x7FF), (1, 1), (0x200, 0x400)] {
let hw1 = 0xF000 | (s << 10) | imm10;
for (base, oracle) in [
(0xD000u16, decode_bl as fn(&[u8], usize) -> Option<u32>),
(0x9000, decode_b_wide),
] {
let hw2 = base | (j1 << 13) | (j2 << 11) | imm11;
image[0..2].copy_from_slice(&hw1.to_le_bytes());
image[2..4].copy_from_slice(&hw2.to_le_bytes());
let insn = round_trip(hw1, hw2, 0x40);
assert_eq!(
insn.branch_target(),
oracle(&image, 0).map(|t| t.wrapping_add(0x40)),
"{hw1:#06x} {hw2:#06x}"
);
}
}
}
}
}
}
#[test]
fn b_cond_wide_agrees_with_decode_b_cond() {
let mut image = [0u8; 4];
for s in 0..2u16 {
for j1 in 0..2u16 {
for j2 in 0..2u16 {
for cond in 0..14u16 {
for (imm6, imm11) in [(0u16, 0u16), (0x3F, 0x7FF), (1, 1), (0x20, 0x400)] {
let hw1 = 0xF000 | (s << 10) | (cond << 6) | imm6;
let hw2 = 0x8000 | (j1 << 13) | (j2 << 11) | imm11;
image[0..2].copy_from_slice(&hw1.to_le_bytes());
image[2..4].copy_from_slice(&hw2.to_le_bytes());
let insn = round_trip(hw1, hw2, 0x40);
let oracle = crate::decode_b_cond(&image, 0).unwrap();
assert_eq!(oracle.len, 4);
assert_eq!(insn.cond, Some(oracle.cond), "{hw1:#06x} {hw2:#06x}");
assert_eq!(
insn.branch_target(),
Some(oracle.target.wrapping_add(0x40)),
"{hw1:#06x} {hw2:#06x}"
);
}
}
}
}
}
}
#[test]
fn t3_and_t4_pack_their_immediates_differently() {
let t3 = round_trip(0xF001, 0x8000, 0x1000);
let t4 = round_trip(0xF001, 0x9000, 0x1000);
assert_eq!(t3.cond, Some(Cond::Eq));
assert_eq!(t3.encoding, "T3");
assert_eq!(t3.branch_target(), Some(0x1004 + 0x1000));
assert_eq!(t3.to_string(), "beq.w 0x2004");
assert_eq!(t4.cond, None);
assert_eq!(t4.encoding, "T4");
assert_eq!(t4.branch_target(), Some(0x1004 + 0xC0_1000));
assert_eq!(t4.to_string(), "b.w 0xc02004");
assert_ne!(t3.branch_target(), t4.branch_target());
assert_ne!(t3.branch_target(), Some(0x1004 + 0xC0_1000));
}
#[test]
fn hand_computed_range_vectors() {
let site = 0x0200_0000u32;
let pc = site + 4;
let fwd = round_trip(0xF03F, 0xAFFF, site);
assert_eq!(fwd.branch_target(), Some(pc + 1_048_574));
let back = round_trip(0xF400, 0x8000, site);
assert_eq!(back.branch_target(), Some(pc - 1_048_576));
let mut over = fwd;
over.operands = one(Operand::Target(pc + 1_048_576));
assert_eq!(encode(&over), None);
let mut under = back;
under.operands = one(Operand::Target(pc - 1_048_578));
assert_eq!(encode(&under), None);
let mut odd = fwd;
odd.operands = one(Operand::Target(pc + 3));
assert_eq!(encode(&odd), None);
for (base, mnemonic) in [(0x9000u16, "b"), (0xD000, "bl")] {
let fwd = round_trip(0xF3FF, base | 0x7FF, site);
assert_eq!(fwd.mnemonic, mnemonic);
assert_eq!(fwd.branch_target(), Some(pc + 16_777_214));
let back = round_trip(0xF400, base, site);
assert_eq!(back.branch_target(), Some(pc - 16_777_216));
let mut over = fwd;
over.operands = one(Operand::Target(pc + 16_777_216));
assert_eq!(encode(&over), None);
let mut under = back;
under.operands = one(Operand::Target(pc - 16_777_218));
assert_eq!(encode(&under), None);
}
let fwd = round_trip(0xF3FF, 0xC7FE, site);
assert_eq!(fwd.branch_target(), Some((pc & !3) + 16_777_212));
let back = round_trip(0xF400, 0xC000, site);
assert_eq!(back.branch_target(), Some((pc & !3) - 16_777_216));
let mut over = fwd;
over.operands = one(Operand::Target((pc & !3) + 16_777_216));
assert_eq!(encode(&over), None);
let mut misaligned = fwd;
misaligned.operands = one(Operand::Target((pc & !3) + 2));
assert_eq!(encode(&misaligned), None);
}
#[test]
fn blx_branches_from_the_word_aligned_pc() {
let insn = round_trip(0xF000, 0xE800, 0x1002);
assert_eq!(insn.branch_target(), Some(0x1004));
assert_eq!(
decode(0xF000, 0xF800, 0x1002).unwrap().branch_target(),
Some(0x1006)
);
assert!(decode(0xF000, 0xC001, 0).is_none());
assert!(decode(0xF3FF, 0xC7FF, 0).is_none());
}
#[test]
fn systematic_sweep_round_trips() {
let hw2_low: [u16; 26] = [
0x000, 0x001, 0x002, 0x003, 0x004, 0x014, 0x0F0, 0x0FF, 0x110, 0x400, 0x460, 0x500,
0x793, 0x7FE, 0x7FF, 0x800, 0x810, 0x8FF, 0xA34, 0xF00, 0xF0F, 0xF1F, 0xF2F, 0xF40,
0xF4B, 0xFFF,
];
let mut decoded = 0usize;
for addr in [0u32, 0x0800_1234, 0xFFFF_FFF0] {
for op in 0..128u16 {
for rn in [0u16, 1, 0xE, 0xF] {
let hw1 = 0xF000 | (op << 4) | rn;
for op1 in 0..8u16 {
for low in hw2_low {
let hw2 = 0x8000 | (op1 << 12) | low;
if let Some(insn) = decode(hw1, hw2, addr) {
decoded += 1;
assert_eq!(insn.width, Width::Wide);
assert_eq!(insn.len(), 4);
assert_eq!(
encode(&insn),
Some((hw1, hw2)),
"round-trip of {hw1:#06x} {hw2:#06x} at {addr:#x} ({insn})"
);
}
}
}
}
}
}
assert!(decoded > 30_000, "sweep decoded only {decoded} encodings");
}
#[test]
fn branch_j_bit_sweep_round_trips() {
for addr in [0x1000u32, 0x1002] {
for s in 0..2u16 {
for j1 in 0..2u16 {
for j2 in 0..2u16 {
for hi in [0u16, 1, 0x20, 0x3E, 0x3F] {
for lo in [0u16, 1, 2, 0x7FE, 0x7FF] {
for base in [0x8000u16, 0x9000, 0xC000, 0xD000] {
let hw1 = 0xF000 | (s << 10) | hi;
let hw2 = base | (j1 << 13) | (j2 << 11) | lo;
if decode(hw1, hw2, addr).is_some() {
round_trip(hw1, hw2, addr);
}
}
}
}
}
}
}
}
}
#[test]
fn branch_predicates_are_right_for_each_form() {
let b_cond = decode(0xF100, 0x8000, 0x1000).unwrap(); let b_wide = decode(0xF000, 0x9000, 0x1000).unwrap();
let bl = decode(0xF000, 0xD000, 0x1000).unwrap();
let blx = decode(0xF000, 0xC000, 0x1000).unwrap();
for insn in [b_cond, b_wide, bl, blx] {
assert!(insn.is_branch(), "{insn}");
assert!(insn.branch_target().is_some(), "{insn}");
}
assert!(!b_cond.is_call());
assert!(!b_wide.is_call());
assert!(bl.is_call());
assert!(blx.is_call());
assert_eq!(b_cond.branch_target(), Some(0x1004));
assert_eq!(b_wide.branch_target(), Some(0x1004 + 0xC0_0000));
assert_eq!(bl.branch_target(), Some(0x1004 + 0xC0_0000));
assert_eq!(blx.branch_target(), Some(0x1004 + 0xC0_0000));
let bxj = decode(0xF3C5, 0x8F00, 0).unwrap();
assert!(bxj.is_branch() && !bxj.is_call() && bxj.branch_target().is_none());
let eret = decode(0xF3DE, 0x8F00, 0).unwrap();
assert!(eret.is_branch() && !eret.is_call() && eret.branch_target().is_none());
for (hw1, hw2) in [
(0xF3AFu16, 0x8000u16), (0xF3BF, 0x8F4F), (0xF380, 0x8810), (0xF3EF, 0x8010), (0xF7F0, 0xA000), (0xF7F0, 0x8000), ] {
let insn = decode(hw1, hw2, 0).unwrap();
assert!(!insn.is_branch(), "{insn}");
assert!(!insn.is_call(), "{insn}");
}
}
#[test]
fn conditional_branch_carries_its_condition_in_the_field() {
for bits in 0..14u16 {
let insn = round_trip(0xF000 | (bits << 6), 0x8000, 0);
assert_eq!(insn.cond, Cond::from_bits(bits as u8));
assert_eq!(insn.mnemonic, "b", "the condition is not in the mnemonic");
}
assert_eq!(ual(0xF000, 0x8000), "beq.w 0x4");
assert_eq!(ual(0xF2C0, 0x8000), "blt.w 0x4");
assert_ne!(decode(0xF380, 0x8000, 0).map(|i| i.mnemonic), Some("b"));
assert_ne!(decode(0xF3C0, 0x8000, 0).map(|i| i.mnemonic), Some("b"));
}
#[test]
fn msr_and_mrs_name_both_profiles_registers() {
assert_eq!(ual(0xF383, 0x8810), "msr PRIMASK, r3");
assert_eq!(ual(0xF381, 0x8811), "msr BASEPRI, r1");
assert_eq!(ual(0xF380, 0x8814), "msr CONTROL, r0");
assert_eq!(ual(0xF385, 0x8808), "msr MSP, r5");
assert_eq!(ual(0xF380, 0x8800), "msr APSR_nzcvq, r0");
assert_eq!(ual(0xF380, 0x8400), "msr APSR_g, r0");
assert_eq!(ual(0xF380, 0x8C00), "msr APSR_nzcvqg, r0");
assert_eq!(ual(0xF382, 0x8C03), "msr XPSR_nzcvqg, r2");
assert_eq!(ual(0xF3EF, 0x8010), "mrs r0, PRIMASK");
assert_eq!(ual(0xF3EF, 0x8100), "mrs r1, APSR");
assert_eq!(ual(0xF3EF, 0x8512), "mrs r5, BASEPRI_MAX");
#[rustfmt::skip]
let m_profile: [(u16, u16, &str); 36] = [
(0xF380, 0x8400, "msr APSR_g, r0"),
(0xF380, 0x8800, "msr APSR_nzcvq, r0"),
(0xF380, 0x8C00, "msr APSR_nzcvqg, r0"),
(0xF380, 0x8401, "msr IAPSR_g, r0"),
(0xF380, 0x8801, "msr IAPSR_nzcvq, r0"),
(0xF380, 0x8C01, "msr IAPSR_nzcvqg, r0"),
(0xF380, 0x8402, "msr EAPSR_g, r0"),
(0xF380, 0x8802, "msr EAPSR_nzcvq, r0"),
(0xF380, 0x8C02, "msr EAPSR_nzcvqg, r0"),
(0xF380, 0x8403, "msr XPSR_g, r0"),
(0xF380, 0x8803, "msr XPSR_nzcvq, r0"),
(0xF380, 0x8C03, "msr XPSR_nzcvqg, r0"),
(0xF380, 0x8805, "msr IPSR, r0"),
(0xF380, 0x8806, "msr EPSR, r0"),
(0xF380, 0x8807, "msr IEPSR, r0"),
(0xF380, 0x8808, "msr MSP, r0"),
(0xF380, 0x8809, "msr PSP, r0"),
(0xF380, 0x8810, "msr PRIMASK, r0"),
(0xF380, 0x8811, "msr BASEPRI, r0"),
(0xF380, 0x8812, "msr BASEPRI_MAX, r0"),
(0xF380, 0x8813, "msr FAULTMASK, r0"),
(0xF380, 0x8814, "msr CONTROL, r0"),
(0xF3EF, 0x8000, "mrs r0, APSR"),
(0xF3EF, 0x8001, "mrs r0, IAPSR"),
(0xF3EF, 0x8002, "mrs r0, EAPSR"),
(0xF3EF, 0x8003, "mrs r0, XPSR"),
(0xF3EF, 0x8005, "mrs r0, IPSR"),
(0xF3EF, 0x8006, "mrs r0, EPSR"),
(0xF3EF, 0x8007, "mrs r0, IEPSR"),
(0xF3EF, 0x8008, "mrs r0, MSP"),
(0xF3EF, 0x8009, "mrs r0, PSP"),
(0xF3EF, 0x8010, "mrs r0, PRIMASK"),
(0xF3EF, 0x8011, "mrs r0, BASEPRI"),
(0xF3EF, 0x8012, "mrs r0, BASEPRI_MAX"),
(0xF3EF, 0x8013, "mrs r0, FAULTMASK"),
(0xF3EF, 0x8014, "mrs r0, CONTROL"),
];
for (hw1, hw2, text) in m_profile {
assert_eq!(round_trip(hw1, hw2, 0).to_string(), text);
}
assert_eq!(ual(0xF380, 0x8900), "msr CPSR_fc, r0", "mask 1001");
assert_eq!(ual(0xF384, 0x8F00), "msr CPSR_fsxc, r4");
assert_eq!(ual(0xF390, 0x8F00), "msr SPSR_fsxc, r0");
assert_eq!(ual(0xF394, 0x8100), "msr SPSR_c, r4");
assert_eq!(ual(0xF3FF, 0x8200), "mrs r2, SPSR");
assert!(decode(0xF380, 0x8B10, 0).is_none());
assert!(decode(0xF380, 0x8000, 0).is_none());
assert!(decode(0xF380, 0x8804, 0).is_none());
assert!(decode(0xF3EF, 0x8015, 0).is_none());
assert!(decode(0xF380, 0x8410, 0).is_none());
}
#[test]
fn hints_print_with_their_width_suffix() {
assert_eq!(ual(0xF3AF, 0x8000), "nop.w");
assert_eq!(ual(0xF3AF, 0x8001), "yield.w");
assert_eq!(ual(0xF3AF, 0x8002), "wfe.w");
assert_eq!(ual(0xF3AF, 0x8003), "wfi.w");
assert_eq!(ual(0xF3AF, 0x8004), "sev.w");
assert_eq!(ual(0xF3AF, 0x8014), "csdb.w");
assert_eq!(ual(0xF3AF, 0x80F0), "dbg #0");
assert_eq!(ual(0xF3AF, 0x80FF), "dbg #0xf");
assert_eq!(dec(0xF3AF, 0x8000, 0).encoding, "T2", "nop.w");
assert_eq!(dec(0xF3AF, 0x8004, 0).encoding, "T2", "sev.w");
assert_eq!(dec(0xF3AF, 0x8014, 0).encoding, "T1", "csdb.w");
assert_eq!(dec(0xF3AF, 0x80F0, 0).encoding, "T1", "dbg #0");
for (hw1, hw2) in [
(0xF3AFu16, 0x8000u16),
(0xF3AF, 0x8004),
(0xF3AF, 0x8014),
(0xF3AF, 0x80F5),
] {
round_trip(hw1, hw2, 0);
}
assert!(decode(0xF3AF, 0x8005, 0).is_none());
assert!(decode(0xF3AF, 0x8013, 0).is_none());
assert!(decode(0xF3AE, 0x8000, 0).is_none());
}
#[test]
fn misc_control_prints_named_barrier_options() {
assert_eq!(ual(0xF3BF, 0x8F2F), "clrex");
assert_eq!(ual(0xF3BF, 0x8F4F), "dsb sy");
assert_eq!(ual(0xF3BF, 0x8F4E), "dsb st");
assert_eq!(ual(0xF3BF, 0x8F4B), "dsb ish");
assert_eq!(ual(0xF3BF, 0x8F4A), "dsb ishst");
assert_eq!(ual(0xF3BF, 0x8F47), "dsb nsh");
assert_eq!(ual(0xF3BF, 0x8F46), "dsb nshst");
assert_eq!(ual(0xF3BF, 0x8F43), "dsb osh");
assert_eq!(ual(0xF3BF, 0x8F42), "dsb oshst");
assert_eq!(ual(0xF3BF, 0x8F49), "dsb #9", "reserved option, no name");
assert_eq!(ual(0xF3BF, 0x8F5F), "dmb sy");
assert_eq!(ual(0xF3BF, 0x8F52), "dmb oshst");
assert_eq!(ual(0xF3BF, 0x8F6F), "isb sy");
assert_eq!(ual(0xF3BF, 0x8F60), "isb #0");
assert_eq!(ual(0xF3BF, 0x8F40), "ssbb");
assert_eq!(ual(0xF3BF, 0x8F44), "pssbb");
assert_eq!(ual(0xF3BF, 0x8F0F), "leavex");
assert_eq!(ual(0xF3BF, 0x8F1F), "enterx");
for option in 0..16u16 {
for opc in [0x0u16, 0x1, 0x2, 0x4, 0x5, 0x6] {
let hw2 = 0x8F00 | (opc << 4) | option;
if decode(0xF3BF, hw2, 0).is_some() {
round_trip(0xF3BF, hw2, 0);
}
}
}
assert!(decode(0xF3BF, 0x8F30, 0).is_none());
assert!(decode(0xF3BF, 0x8F2E, 0).is_none());
}
#[test]
fn a_profile_only_control_encodings() {
assert_eq!(ual(0xF3C5, 0x8F00), "bxj r5");
assert_eq!(ual(0xF3DE, 0x8F00), "subs pc, lr, #0");
assert_eq!(ual(0xF3DE, 0x8F04), "subs pc, lr, #4");
assert_eq!(ual(0xF3DE, 0x8F10), "subs pc, lr, #0x10");
assert_eq!(ual(0xF7F5, 0x8000), "smc #5");
assert_eq!(ual(0xF7FF, 0x8000), "smc #0xf");
assert_eq!(ual(0xF3AF, 0x8460), "cpsie.w if");
assert_eq!(ual(0xF3AF, 0x8680), "cpsid.w a");
assert_eq!(ual(0xF3AF, 0x8793), "cpsid.w a, #0x13");
assert_eq!(ual(0xF3AF, 0x8110), "cps #0x10");
for hw2 in [0x8460u16, 0x8680, 0x8793, 0x8110, 0x85E0, 0x87E3] {
round_trip(0xF3AF, hw2, 0);
}
assert!(decode(0xF3AF, 0x8260, 0).is_none());
assert!(decode(0xF3AF, 0x8400, 0).is_none());
assert!(decode(0xF3AF, 0x8160, 0).is_none());
assert!(decode(0xF3AF, 0x8190, 0).is_none(), "A set");
assert!(decode(0xF3AF, 0x8150, 0).is_none(), "I set");
assert!(decode(0xF3AF, 0x8130, 0).is_none(), "F set");
assert!(decode(0xF3C5, 0x8F01, 0).is_none());
assert!(decode(0xF3DD, 0x8F00, 0).is_none());
assert!(decode(0xF7F5, 0x8001, 0).is_none());
}
#[test]
fn udf_wide_decodes_and_keeps_its_immediate() {
assert_eq!(ual(0xF7F1, 0xA234), "udf.w #0x1234");
assert_eq!(ual(0xF7F0, 0xA000), "udf.w #0");
assert_eq!(ual(0xF7FF, 0xAFFF), "udf.w #0xffff");
round_trip(0xF7F1, 0xA234, 0);
round_trip(0xF7FF, 0xAFFF, 0);
assert_eq!(decode(0xF7F1, 0x8000, 0).unwrap().mnemonic, "smc");
assert_eq!(decode(0xF7F1, 0xA000, 0).unwrap().mnemonic, "udf");
}
#[test]
fn outside_the_group_is_not_ours() {
assert!(decode(0xE800, 0x8000, 0).is_none());
assert!(decode(0xF800, 0x8000, 0).is_none());
assert!(decode(0xF000, 0x0000, 0).is_none());
assert!(decode(0xF3AF, 0xA000, 0).is_none());
assert!(decode(0xF3BF, 0xAF4F, 0).is_none());
}
#[test]
fn encode_rejects_what_this_group_cannot_hold() {
let bl = decode(0xF000, 0xD000, 0x1000).unwrap();
let mut foreign = bl;
foreign.mnemonic = "add";
assert_eq!(encode(&foreign), None);
let mut renamed = bl;
renamed.encoding = "T2";
assert_eq!(encode(&renamed), None);
let mut nop_as_t1 = decode(0xF3AF, 0x8000, 0).unwrap();
nop_as_t1.encoding = "T1";
assert_eq!(encode(&nop_as_t1), None);
let mut csdb_as_t2 = decode(0xF3AF, 0x8014, 0).unwrap();
csdb_as_t2.encoding = "T2";
assert_eq!(encode(&csdb_as_t2), None);
let mut narrow = bl;
narrow.width = Width::Narrow;
assert_eq!(encode(&narrow), None);
let mut narrow_nop = decode(0xF3AF, 0x8000, 0).unwrap();
narrow_nop.width = Width::Narrow;
assert_eq!(encode(&narrow_nop), None);
let mut suffixed = bl;
suffixed.explicit_width = true;
assert_eq!(encode(&suffixed), None);
let mut unsuffixed = decode(0xF000, 0x9000, 0).unwrap();
unsuffixed.explicit_width = false;
assert_eq!(encode(&unsuffixed), None);
let mut flagged = bl;
flagged.sets_flags = true;
assert_eq!(encode(&flagged), None);
let mut unflagged = decode(0xF3DE, 0x8F00, 0).unwrap();
unflagged.sets_flags = false;
assert_eq!(encode(&unflagged), None);
let mut uncond = decode(0xF000, 0x8000, 0).unwrap();
uncond.cond = None;
assert_eq!(encode(&uncond), None);
let mut always = decode(0xF000, 0x8000, 0).unwrap();
always.cond = Some(Cond::Al);
assert_eq!(encode(&always), None);
let mut wrong_kind = bl;
wrong_kind.operands = one(Operand::Imm(4));
assert_eq!(encode(&wrong_kind), None);
let mut too_many = bl;
too_many.operands = [Operand::Target(0x2000), Operand::Imm(0)]
.into_iter()
.collect();
assert_eq!(encode(&too_many), None);
let mut unknown_reg = decode(0xF380, 0x8810, 0).unwrap();
unknown_reg.operands = [Operand::SpecialReg("MECR"), Operand::Reg(Reg(0))]
.into_iter()
.collect();
assert_eq!(encode(&unknown_reg), None);
let mut bad_option = decode(0xF3BF, 0x8F4F, 0).unwrap();
bad_option.operands = one(Operand::Option("full"));
assert_eq!(encode(&bad_option), None);
let mut big_udf = decode(0xF7F0, 0xA000, 0).unwrap();
big_udf.operands = one(Operand::Imm(0x1_0000));
assert_eq!(encode(&big_udf), None);
let mut big_smc = decode(0xF7F0, 0x8000, 0).unwrap();
big_smc.operands = one(Operand::Imm(16));
assert_eq!(encode(&big_smc), None);
let mut big_eret = decode(0xF3DE, 0x8F00, 0).unwrap();
big_eret.operands = [
Operand::Reg(Reg::PC),
Operand::Reg(Reg::LR),
Operand::Imm(256),
]
.into_iter()
.collect();
assert_eq!(encode(&big_eret), None);
let mut ssbb_as_dsb = decode(0xF3BF, 0x8F4F, 0).unwrap();
ssbb_as_dsb.operands = one(Operand::Imm(0));
assert_eq!(encode(&ssbb_as_dsb), None);
let mut pssbb_as_dsb = decode(0xF3BF, 0x8F4F, 0).unwrap();
pssbb_as_dsb.operands = one(Operand::Imm(4));
assert_eq!(encode(&pssbb_as_dsb), None);
}
#[test]
fn encode_refuses_every_operand_shape_decode_cannot_produce() {
let reg = Operand::Reg(Reg(0));
let imm = Operand::Imm(0);
let neg = Operand::Imm(-1);
let pc = Operand::Reg(Reg::PC);
let lr = Operand::Reg(Reg::LR);
let primask = Operand::SpecialReg("PRIMASK");
let cases: [(u16, u16, &[Operand], &str); 25] = [
(0xF7F0, 0xA000, &[imm, imm], "udf.w takes one immediate"),
(0xF7F0, 0xA000, &[neg], "udf.w's #<imm16> is unsigned"),
(0xF7F0, 0x8000, &[], "smc takes one immediate"),
(0xF7F0, 0x8000, &[imm, imm], "smc takes one, not two"),
(0xF7F0, 0x8000, &[neg], "smc's #<imm4> is unsigned"),
(0xF383, 0x8810, &[primask], "msr takes two operands"),
(0xF383, 0x8810, &[reg, reg], "msr writes a special register"),
(0xF383, 0x8810, &[primask, imm], "msr reads a core register"),
(
0xF383,
0x8810,
&[primask, reg, imm],
"msr takes two operands",
),
(
0xF383,
0x8810,
&[Operand::SpecialReg("MECR"), reg],
"no SYSm/mask spells MECR",
),
(
0xF3EF,
0x8010,
&[reg, primask, imm],
"mrs takes two operands",
),
(
0xF3EF,
0x8010,
&[primask, primask],
"mrs writes a core register",
),
(0xF3EF, 0x8010, &[reg, reg], "mrs reads a special register"),
(
0xF3EF,
0x8010,
&[reg, Operand::SpecialReg("MECR")],
"no SYSm spells MECR",
),
(0xF3C5, 0x8F00, &[], "bxj takes one register"),
(0xF3C5, 0x8F00, &[reg, reg], "bxj takes one, not two"),
(0xF3C5, 0x8F00, &[imm], "bxj branches to a register"),
(0xF3DE, 0x8F04, &[reg, lr, imm], "the destination is pc"),
(0xF3DE, 0x8F04, &[pc, reg, imm], "the source is lr"),
(
0xF3DE,
0x8F04,
&[pc, lr, imm, imm],
"subs pc, lr takes three, not four",
),
(0xF3DE, 0x8F04, &[pc, lr, neg], "the #<const> is unsigned"),
(0xF3AF, 0x80F0, &[], "dbg takes one immediate"),
(0xF3AF, 0x80F0, &[imm, imm], "dbg takes one, not two"),
(
0xF3AF,
0x80F0,
&[Operand::Imm(16)],
"dbg's option is four bits",
),
(0xF3AF, 0x80F0, &[neg], "dbg's option is unsigned"),
];
for (hw1, hw2, operands, why) in cases {
let insn = with_operands(hw1, hw2, operands);
assert_eq!(encode(&insn), None, "{why} ({hw1:#06x} {hw2:#06x})");
}
let beq = with_operands(0xF000, 0x8000, &[imm]);
assert_eq!(encode(&beq), None, "b<cond>.w branches to a target");
let beq_plus = with_operands(0xF000, 0x8000, &[Operand::Target(4), imm]);
assert_eq!(encode(&beq_plus), None, "b<cond>.w takes one target");
for (hw1, hw2, suffixed) in [
(0xF7F0u16, 0x8000u16, false), (0xF3C5, 0x8F00, false), (0xF3BF, 0x8F2F, false), (0xF3BF, 0x8F40, false), (0xF3BF, 0x8F4F, false), (0xF3AF, 0x8110, false), (0xF7F0, 0xA000, true), (0xF3AF, 0x8000, true), (0xF3AF, 0x8014, true), (0xF000, 0x8000, true), (0xF3AF, 0x8680, true), ] {
let mut flipped = dec(hw1, hw2, 0);
assert_eq!(
flipped.explicit_width, suffixed,
"{hw1:#06x} {hw2:#06x} decoded with the wrong width suffix"
);
flipped.explicit_width = !suffixed;
assert_eq!(encode(&flipped), None, "{hw1:#06x} {hw2:#06x}");
}
for (hw1, hw2) in [
(0xF7F0u16, 0x8000u16), (0xF383, 0x8810), (0xF3EF, 0x8010), (0xF3C5, 0x8F00), (0xF3AF, 0x80F0), (0xF3AF, 0x8000), (0xF3BF, 0x8F2F), (0xF3BF, 0x8F40), (0xF3BF, 0x8F4F), (0xF7F0, 0xA000), (0xF3AF, 0x8110), (0xF000, 0x8000), ] {
let mut flagged = dec(hw1, hw2, 0);
assert!(!flagged.sets_flags, "{hw1:#06x} {hw2:#06x}");
flagged.sets_flags = true;
assert_eq!(encode(&flagged), None, "{hw1:#06x} {hw2:#06x}");
}
for (hw1, hw2) in [
(0xF3AFu16, 0x8000u16), (0xF3BF, 0x8F2F), (0xF3BF, 0x8F40), ] {
let extra = with_operands(hw1, hw2, &[imm]);
assert_eq!(
encode(&extra),
None,
"{hw1:#06x} {hw2:#06x} has no operands"
);
}
let bare_dsb = with_operands(0xF3BF, 0x8F4F, &[]);
assert_eq!(encode(&bare_dsb), None, "dsb takes one <option>");
let sy = Operand::Option("sy");
let wordy_dsb = with_operands(0xF3BF, 0x8F4F, &[sy, sy]);
assert_eq!(encode(&wordy_dsb), None, "dsb takes one <option>, not two");
}
#[test]
fn cps_holds_only_the_three_syntactic_forms_b6_1_1_defines() {
assert!(decode(0xF3AF, 0x8461, 0).is_none());
assert_eq!(ual(0xF3AF, 0x8460), "cpsie.w if");
assert_eq!(ual(0xF3AF, 0x8561), "cpsie.w if, #1");
let a = Operand::Text("a");
let cases: [(u16, &[Operand], &str); 9] = [
(0x8110, &[], "cps takes one mode"),
(
0x8110,
&[Operand::Imm(0x10), Operand::Imm(0)],
"cps takes one mode",
),
(0x8110, &[a], "cps' mode is an immediate"),
(0x8110, &[Operand::Imm(0x20)], "mode is five bits"),
(0x8110, &[Operand::Imm(-1)], "mode is unsigned"),
(0x8680, &[Operand::Imm(0)], "the first operand is <iflags>"),
(
0x8680,
&[Operand::Text("z")],
"z is not an <iflags> spelling",
),
(0x8680, &[a, a], "the mode is an immediate"),
(
0x8680,
&[a, Operand::Imm(0), Operand::Imm(0)],
"at most two operands",
),
];
for (hw2, operands, why) in cases {
let insn = with_operands(0xF3AF, hw2, operands);
assert_eq!(encode(&insn), None, "{why} ({hw2:#06x})");
}
}
#[test]
fn re_encoding_at_a_new_address_moves_the_displacement() {
let at_1000 = decode(0xF000, 0xD000, 0x1000).unwrap();
let target = at_1000.branch_target().unwrap();
let mut at_2000 = at_1000;
at_2000.addr = 0x2000;
let (hw1, hw2) = encode(&at_2000).unwrap();
assert_ne!((hw1, hw2), (0xF000, 0xD000));
assert_eq!(
decode(hw1, hw2, 0x2000).unwrap().branch_target(),
Some(target)
);
assert_eq!(
Some((hw1, hw2)),
encode_bl(0x2000, target).map(halfwords),
"disagreement with encode_bl after relocation"
);
}
}