use crate::Cond;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Reg(pub u8);
impl Reg {
pub const SP: Reg = Reg(13);
pub const LR: Reg = Reg(14);
pub const PC: Reg = Reg(15);
pub fn num(self) -> u8 {
self.0 & 0xF
}
pub fn is_low(self) -> bool {
self.num() < 8
}
}
impl core::fmt::Display for Reg {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self.num() {
13 => f.write_str("sp"),
14 => f.write_str("lr"),
15 => f.write_str("pc"),
n => write!(f, "r{n}"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum FpReg {
S(u8),
D(u8),
Q(u8),
}
impl core::fmt::Display for FpReg {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
FpReg::S(n) => write!(f, "s{n}"),
FpReg::D(n) => write!(f, "d{n}"),
FpReg::Q(n) => write!(f, "q{n}"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ShiftKind {
Lsl,
Lsr,
Asr,
Ror,
Rrx,
}
impl core::fmt::Display for ShiftKind {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str(match self {
ShiftKind::Lsl => "lsl",
ShiftKind::Lsr => "lsr",
ShiftKind::Asr => "asr",
ShiftKind::Ror => "ror",
ShiftKind::Rrx => "rrx",
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ShiftAmount {
Imm(u8),
Reg(Reg),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Shift {
pub kind: ShiftKind,
pub amount: ShiftAmount,
}
impl core::fmt::Display for Shift {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match (self.kind, self.amount) {
(ShiftKind::Rrx, _) => f.write_str("rrx"),
(kind, ShiftAmount::Imm(n)) => write!(f, "{kind} #{n}"),
(kind, ShiftAmount::Reg(r)) => write!(f, "{kind} {r}"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum AddrMode {
Offset,
PreIndex,
PostIndex,
PostIncrement,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Mem {
pub base: Reg,
pub index: Option<(Reg, Option<Shift>)>,
pub offset: u32,
pub add: bool,
pub align: u16,
pub mode: AddrMode,
}
impl Mem {
#[must_use]
pub const fn displacement(&self) -> i64 {
if self.add {
self.offset as i64
} else {
-(self.offset as i64)
}
}
}
impl Mem {
fn write(&self, f: &mut core::fmt::Formatter<'_>, force_offset: bool) -> core::fmt::Result {
let disp = |f: &mut core::fmt::Formatter<'_>, always: bool| -> core::fmt::Result {
if let Some((idx, shift)) = self.index {
write!(f, ", {idx}")?;
if let Some(s) = shift {
write!(f, ", {s}")?;
}
} else if always || self.offset != 0 || !self.add {
if self.add {
write!(f, ", #{}", self.offset)?;
} else {
write!(f, ", #-{}", self.offset)?;
}
}
Ok(())
};
let close = |f: &mut core::fmt::Formatter<'_>| -> core::fmt::Result {
if self.align != 0 {
write!(f, ":{}", self.align)?;
}
f.write_str("]")
};
match self.mode {
AddrMode::Offset => {
write!(f, "[{}", self.base)?;
disp(f, force_offset)?;
close(f)
}
AddrMode::PreIndex => {
write!(f, "[{}", self.base)?;
disp(f, true)?;
close(f)?;
f.write_str("!")
}
AddrMode::PostIndex => {
write!(f, "[{}", self.base)?;
close(f)?;
disp(f, true)
}
AddrMode::PostIncrement => {
write!(f, "[{}", self.base)?;
close(f)?;
f.write_str("!")
}
}
}
}
impl core::fmt::Display for Mem {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
self.write(f, false)
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
#[non_exhaustive]
pub enum Operand {
Reg(Reg),
RegShifted(Reg, Shift),
Imm(i64),
RegList(u16),
Target(u32),
Mem(Mem),
FpReg(FpReg),
FpScalar(FpReg, u8),
FpImm(f64),
SpecialReg(&'static str),
Option(&'static str),
Coproc(u8),
CoprocReg(u8),
Cond(Cond),
Text(&'static str),
}
impl core::fmt::Display for Operand {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Operand::Reg(r) => write!(f, "{r}"),
Operand::RegShifted(r, s) => write!(f, "{r}, {s}"),
Operand::Imm(v) => {
if *v < 0 {
write!(f, "#-{:#x}", -(*v))
} else if *v < 10 {
write!(f, "#{v}")
} else {
write!(f, "#{v:#x}")
}
}
Operand::RegList(bits) => write_reglist(f, *bits),
Operand::Target(addr) => write!(f, "{addr:#x}"),
Operand::Mem(m) => write!(f, "{m}"),
Operand::FpReg(r) => write!(f, "{r}"),
Operand::FpScalar(r, i) => write!(f, "{r}[{i}]"),
Operand::FpImm(v) if v.fract() == 0.0 && v.is_finite() => write!(f, "#{v:.1}"),
Operand::FpImm(v) => write!(f, "#{v}"),
Operand::SpecialReg(s) => f.write_str(s),
Operand::Option(s) => f.write_str(s),
Operand::Coproc(n) => write!(f, "p{n}"),
Operand::CoprocReg(n) => write!(f, "c{n}"),
Operand::Cond(c) => write!(f, "{c}"),
Operand::Text(s) => f.write_str(s),
}
}
}
fn write_reglist(f: &mut core::fmt::Formatter<'_>, bits: u16) -> core::fmt::Result {
f.write_str("{")?;
let mut first = true;
let mut i = 0u8;
while i < 16 {
if bits & (1 << i) == 0 {
i += 1;
continue;
}
let start = i;
while i < 15 && bits & (1 << (i + 1)) != 0 {
i += 1;
}
if !first {
f.write_str(", ")?;
}
first = false;
match i - start {
0 => write!(f, "{}", Reg(start))?,
1 => write!(f, "{}, {}", Reg(start), Reg(i))?,
_ => write!(f, "{}-{}", Reg(start), Reg(i))?,
}
i += 1;
}
f.write_str("}")
}
pub const MAX_OPERANDS: usize = 6;
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Operands {
items: [Option<Operand>; MAX_OPERANDS],
len: u8,
}
impl Default for Operands {
fn default() -> Self {
Operands {
items: [None; MAX_OPERANDS],
len: 0,
}
}
}
impl Operands {
pub fn new() -> Self {
Self::default()
}
pub fn push(&mut self, op: Operand) {
assert!(
(self.len as usize) < MAX_OPERANDS,
"more than {MAX_OPERANDS} operands"
);
self.items[self.len as usize] = Some(op);
self.len += 1;
}
pub fn as_slice(&self) -> impl Iterator<Item = Operand> + '_ {
self.items[..self.len as usize].iter().filter_map(|o| *o)
}
pub fn len(&self) -> usize {
self.len as usize
}
pub fn is_empty(&self) -> bool {
self.len == 0
}
pub fn get(&self, i: usize) -> Option<Operand> {
self.items.get(i).copied().flatten()
}
}
impl core::iter::FromIterator<Operand> for Operands {
fn from_iter<T: IntoIterator<Item = Operand>>(iter: T) -> Self {
let mut ops = Operands::new();
for op in iter {
ops.push(op);
}
ops
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Width {
Narrow,
Wide,
}
impl Width {
pub fn bytes(self) -> usize {
match self {
Width::Narrow => 2,
Width::Wide => 4,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Insn {
pub mnemonic: &'static str,
pub encoding: &'static str,
pub addr: u32,
pub width: Width,
pub cond: Option<Cond>,
pub sets_flags: bool,
pub explicit_width: bool,
pub operands: Operands,
}
impl Insn {
pub fn len(&self) -> usize {
self.width.bytes()
}
pub fn is_empty(&self) -> bool {
false
}
pub fn is_branch(&self) -> bool {
matches!(
self.mnemonic,
"b" | "bl"
| "blx"
| "bx"
| "bxj"
| "cbz"
| "cbnz"
| "tbb"
| "tbh"
| "hb"
| "hbl"
| "hbp"
| "hblp"
| "chka"
) || self.writes_pc()
}
pub fn is_call(&self) -> bool {
matches!(self.mnemonic, "bl" | "blx" | "hbl" | "hblp")
}
pub fn writes_pc(&self) -> bool {
match self.mnemonic {
"pop" | "ldm" | "ldmia" | "ldmdb" => self
.operands
.as_slice()
.any(|o| matches!(o, Operand::RegList(bits) if bits & (1 << 15) != 0)),
"bx" | "bxj" => true,
"blx" => matches!(self.operands.get(0), Some(Operand::Reg(_))),
"rfeia" | "rfedb" => true,
m if m.starts_with("str")
|| m.starts_with("vstr")
|| m.starts_with("vstm")
|| m.starts_with("vldm")
|| m.starts_with("stm")
|| m == "push"
|| m == "vpush"
|| matches!(
m,
"cmp" | "cmn" | "tst" | "teq" | "chka" | "srsia" | "srsdb"
) =>
{
false
}
_ => matches!(self.operands.get(0), Some(Operand::Reg(Reg::PC))),
}
}
pub fn branch_target(&self) -> Option<u32> {
self.operands.as_slice().find_map(|o| match o {
Operand::Target(t) => Some(t),
_ => None,
})
}
}
impl core::fmt::Display for Insn {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str(self.mnemonic)?;
if self.sets_flags {
f.write_str("s")?;
}
if let Some(c) = self.cond {
f.write_str(c.suffix())?;
}
if self.explicit_width {
f.write_str(match self.width {
Width::Narrow => ".n",
Width::Wide => ".w",
})?;
}
let literal = self.width == Width::Narrow
&& self
.operands
.as_slice()
.any(|o| matches!(o, Operand::Target(_)));
let mut first = true;
for op in self.operands.as_slice() {
f.write_str(if first { " " } else { ", " })?;
first = false;
match op {
Operand::Mem(m) if literal && m.base.num() == Reg::PC.0 => m.write(f, true)?,
_ => write!(f, "{op}")?,
}
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
fn insn(mnemonic: &'static str, ops: &[Operand]) -> Insn {
Insn {
mnemonic,
encoding: "T1",
addr: 0,
width: Width::Narrow,
cond: None,
sets_flags: false,
explicit_width: false,
operands: ops.iter().copied().collect(),
}
}
#[test]
fn writes_pc_distinguishes_destinations_from_sources() {
assert!(insn("mov", &[Operand::Reg(Reg::PC), Operand::Reg(Reg(1))]).writes_pc());
assert!(insn("add", &[Operand::Reg(Reg::PC), Operand::Reg(Reg::LR)]).writes_pc());
assert!(insn("ldr", &[Operand::Reg(Reg::PC), Operand::Reg(Reg(0))]).writes_pc());
assert!(!insn("str", &[Operand::Reg(Reg::PC), Operand::Reg(Reg(0))]).writes_pc());
assert!(!insn("strb", &[Operand::Reg(Reg::PC), Operand::Reg(Reg(0))]).writes_pc());
assert!(!insn("stm", &[Operand::Reg(Reg::PC), Operand::RegList(0x0003)]).writes_pc());
assert!(!insn("cmp", &[Operand::Reg(Reg::PC), Operand::Reg(Reg(0))]).writes_pc());
assert!(!insn("tst", &[Operand::Reg(Reg::PC), Operand::Reg(Reg(0))]).writes_pc());
assert!(insn("pop", &[Operand::RegList(1 << 15)]).writes_pc());
assert!(!insn("pop", &[Operand::RegList(1 << 14)]).writes_pc());
assert!(!insn("push", &[Operand::RegList(1 << 15)]).writes_pc());
}
#[test]
fn thumbee_handler_branches_are_branches_and_two_are_calls() {
let hb = insn("hb", &[Operand::Imm(7)]);
let hbl = insn("hbl", &[Operand::Imm(7)]);
let hbp = insn("hbp", &[Operand::Imm(3), Operand::Imm(7)]);
let hblp = insn("hblp", &[Operand::Imm(3), Operand::Imm(7)]);
for i in [hb, hbl, hbp, hblp] {
assert!(i.is_branch(), "{i}");
assert!(!i.writes_pc(), "{i}");
assert_eq!(i.branch_target(), None, "{i}");
}
assert!(!hb.is_call());
assert!(
hbl.is_call(),
"A9.5.2: HBL saves a return address to the LR"
);
assert!(!hbp.is_call());
assert!(
hblp.is_call(),
"A9.5.3: HBLP saves a return address to the LR"
);
}
#[test]
fn chka_is_a_branch_but_not_a_call_and_writes_no_pc() {
let chka = insn("chka", &[Operand::Reg(Reg(0)), Operand::Reg(Reg(1))]);
assert!(chka.is_branch());
assert!(!chka.is_call());
assert!(!chka.writes_pc());
assert_eq!(chka.branch_target(), None);
let chka_pc = insn("chka", &[Operand::Reg(Reg::PC), Operand::Reg(Reg(1))]);
assert!(!chka_pc.writes_pc(), "Rn is the array size, a source");
assert!(chka_pc.is_branch(), "still a branch, by mnemonic");
}
#[test]
fn rfe_is_a_branch_whatever_its_operand_looks_like() {
for base in [Operand::Reg(Reg(0)), Operand::Text("r0!")] {
for m in ["rfeia", "rfedb"] {
let i = insn(m, &[base]);
assert!(i.writes_pc(), "{i} loads pc from memory");
assert!(i.is_branch(), "{i}");
assert!(!i.is_call(), "{i} does not write lr");
assert_eq!(i.branch_target(), None, "{i}");
}
}
assert!(insn("rfedb", &[Operand::Reg(Reg::PC)]).writes_pc());
}
#[test]
fn srs_stores_and_does_not_branch() {
for m in ["srsia", "srsdb"] {
let i = insn(m, &[Operand::Text("sp!"), Operand::Imm(0x11)]);
assert!(!i.writes_pc(), "{i}");
assert!(!i.is_branch(), "{i}");
let odd = insn(m, &[Operand::Reg(Reg::PC), Operand::Imm(0x11)]);
assert!(!odd.writes_pc(), "{odd}: the base is an address");
}
}
#[test]
fn blx_writes_pc_only_in_its_register_form() {
let reg = insn("blx", &[Operand::Reg(Reg(3))]);
let imm = insn("blx", &[Operand::Target(0x1234)]);
assert!(
reg.writes_pc(),
"blx r3 writes pc from r3, exactly as bx does"
);
assert!(!imm.writes_pc(), "blx <label> is classified with b and bl");
for i in [reg, imm] {
assert!(i.is_branch(), "{i}");
assert!(i.is_call(), "{i}");
}
assert!(insn("blx", &[Operand::Reg(Reg::PC)]).writes_pc());
assert!(insn("bx", &[Operand::Reg(Reg(3))]).writes_pc());
assert!(insn("bxj", &[Operand::Reg(Reg(3))]).writes_pc());
assert!(!insn("bx", &[Operand::Reg(Reg(3))]).is_call());
}
#[test]
fn vector_load_multiple_base_is_not_a_destination() {
for m in ["vldmia", "vldmdb"] {
let i = insn(m, &[Operand::Reg(Reg::PC), Operand::Text("{s0-s3}")]);
assert!(!i.writes_pc(), "{i}: the first operand is the base");
assert!(!i.is_branch(), "{i}");
}
}
#[test]
fn exception_generating_instructions_are_not_branches() {
for m in ["svc", "bkpt", "udf", "smc"] {
let i = insn(m, &[Operand::Imm(0)]);
assert!(!i.is_branch(), "{i}");
assert!(!i.is_call(), "{i}");
assert!(!i.writes_pc(), "{i}");
}
for m in ["enterx", "leavex"] {
assert!(!insn(m, &[]).is_branch());
}
}
#[test]
fn branch_target_of_a_literal_load_is_the_pool_word() {
let pool = Mem {
base: Reg::PC,
index: None,
offset: 8,
add: true,
align: 0,
mode: AddrMode::Offset,
};
let plain = insn(
"ldr",
&[
Operand::Reg(Reg(0)),
Operand::Mem(pool),
Operand::Target(0x1010),
],
);
assert!(!plain.is_branch());
assert_eq!(plain.branch_target(), Some(0x1010));
let into_pc = insn(
"ldr",
&[
Operand::Reg(Reg::PC),
Operand::Mem(pool),
Operand::Target(0x1010),
],
);
assert!(into_pc.is_branch() && into_pc.writes_pc());
assert_eq!(into_pc.branch_target(), Some(0x1010));
assert!(
into_pc
.operands
.as_slice()
.any(|o| matches!(o, Operand::Mem(_))),
"the `Mem` operand is what marks the target as a pool address"
);
}
#[test]
fn pc_destination_fallback_still_holds() {
assert!(insn("ldrd", &[Operand::Reg(Reg::PC), Operand::Reg(Reg(1))]).writes_pc());
assert!(insn("mrs", &[Operand::Reg(Reg::PC), Operand::SpecialReg("APSR")]).writes_pc());
assert!(insn("sub", &[Operand::Reg(Reg::PC), Operand::Reg(Reg::LR)]).writes_pc());
for m in ["ldm", "ldmia", "ldmdb", "pop"] {
assert!(insn(m, &[Operand::Text("r0!"), Operand::RegList(1 << 15)]).writes_pc());
assert!(!insn(m, &[Operand::Text("r0!"), Operand::RegList(1 << 14)]).writes_pc());
assert!(!insn(m, &[Operand::Reg(Reg::PC), Operand::RegList(1)]).writes_pc());
}
for m in ["tbb", "tbh"] {
let i = insn(
m,
&[Operand::Mem(Mem {
base: Reg(0),
index: Some((Reg(1), None)),
offset: 0,
add: true,
align: 0,
mode: AddrMode::Offset,
})],
);
assert!(i.is_branch() && !i.writes_pc() && !i.is_call(), "{i}");
}
}
#[test]
fn mem_display_follows_the_manuals_syntax_lines() {
let mem = |mode, add, offset| Mem {
base: Reg(0),
index: None,
offset,
add,
align: 0,
mode,
};
assert_eq!(mem(AddrMode::Offset, true, 0).to_string(), "[r0]");
assert_eq!(mem(AddrMode::Offset, false, 0).to_string(), "[r0, #-0]");
assert_eq!(mem(AddrMode::Offset, true, 4).to_string(), "[r0, #4]");
assert_eq!(mem(AddrMode::Offset, false, 4).to_string(), "[r0, #-4]");
assert_eq!(mem(AddrMode::PreIndex, true, 0).to_string(), "[r0, #0]!");
assert_eq!(mem(AddrMode::PreIndex, false, 0).to_string(), "[r0, #-0]!");
assert_eq!(mem(AddrMode::PostIndex, true, 0).to_string(), "[r0], #0");
assert_eq!(mem(AddrMode::PostIndex, false, 0).to_string(), "[r0], #-0");
assert_eq!(mem(AddrMode::PostIndex, true, 4).to_string(), "[r0], #4");
for mode in [AddrMode::Offset, AddrMode::PreIndex, AddrMode::PostIndex] {
let plus = mem(mode, true, 0);
let minus = mem(mode, false, 0);
assert_ne!(plus, minus);
assert_ne!(plus.to_string(), minus.to_string());
assert_eq!(plus.displacement(), minus.displacement());
}
assert_eq!(mem(AddrMode::Offset, false, 4).displacement(), -4);
assert_eq!(mem(AddrMode::PostIncrement, true, 0).to_string(), "[r0]!");
let indexed = Mem {
index: Some((
Reg(3),
Some(Shift {
kind: ShiftKind::Lsl,
amount: ShiftAmount::Imm(1),
}),
)),
..mem(AddrMode::Offset, true, 0)
};
assert_eq!(indexed.to_string(), "[r0, r3, lsl #1]");
assert_eq!(
Mem {
align: 64,
..mem(AddrMode::Offset, true, 0)
}
.to_string(),
"[r0:64]"
);
assert_eq!(
Mem {
align: 128,
..mem(AddrMode::PostIncrement, true, 0)
}
.to_string(),
"[r0:128]!"
);
assert_eq!(
Mem {
align: 64,
index: Some((Reg(3), None)),
..mem(AddrMode::PostIndex, true, 0)
}
.to_string(),
"[r0:64], r3"
);
}
#[test]
fn reglist_display_collapses_runs() {
let show = |bits| insn("push", &[Operand::RegList(bits)]).to_string();
assert_eq!(show(0b0000_0000_0000_1111), "push {r0-r3}");
assert_eq!(show(0b0100_0000_0000_0001), "push {r0, lr}");
assert_eq!(show(0b1000_0000_0000_0011), "push {r0, r1, pc}");
assert_eq!(show(0b0000_0000_1000_0001), "push {r0, r7}");
}
#[test]
fn a_narrow_literal_load_prints_its_zero_displacement() {
let pool = |add, offset| Mem {
base: Reg::PC,
index: None,
offset,
add,
align: 0,
mode: AddrMode::Offset,
};
assert_eq!(pool(true, 0).to_string(), "[pc]");
assert_eq!(pool(true, 8).to_string(), "[pc, #8]");
assert_eq!(pool(false, 0).to_string(), "[pc, #-0]");
let literal = |width, ops: &[Operand]| Insn {
width,
..insn("ldr", ops)
};
let t1 = literal(
Width::Narrow,
&[
Operand::Reg(Reg(0)),
Operand::Mem(pool(true, 0)),
Operand::Target(0x1004),
],
);
assert_eq!(t1.to_string(), "ldr r0, [pc, #0], 0x1004");
let mut t2 = literal(
Width::Wide,
&[
Operand::Reg(Reg(0)),
Operand::Mem(pool(true, 0)),
Operand::Target(0x1004),
],
);
t2.explicit_width = true;
assert_eq!(t2.to_string(), "ldr.w r0, [pc], 0x1004");
let strex = insn(
"strex",
&[
Operand::Reg(Reg::PC),
Operand::Reg(Reg(0)),
Operand::Mem(pool(true, 0)),
],
);
assert_eq!(strex.to_string(), "strex pc, r0, [pc]");
let sp = insn(
"ldr",
&[
Operand::Reg(Reg(0)),
Operand::Mem(Mem {
base: Reg::SP,
..pool(true, 0)
}),
Operand::Target(0x1004),
],
);
assert_eq!(sp.to_string(), "ldr r0, [sp], 0x1004");
let minus = insn(
"ldr",
&[
Operand::Reg(Reg(0)),
Operand::Mem(pool(false, 0)),
Operand::Target(0x1004),
],
);
assert_eq!(minus.to_string(), "ldr r0, [pc, #-0], 0x1004");
let indexed = insn(
"ldr",
&[
Operand::Reg(Reg(0)),
Operand::Mem(Mem {
index: Some((Reg(3), None)),
..pool(true, 0)
}),
Operand::Target(0x1004),
],
);
assert_eq!(indexed.to_string(), "ldr r0, [pc, r3], 0x1004");
}
#[test]
fn fp_immediates_always_carry_a_decimal_point() {
let show = |v: f64| Operand::FpImm(v).to_string();
assert_eq!(show(5.0), "#5.0");
assert_eq!(show(2.0), "#2.0");
assert_eq!(show(-19.0), "#-19.0");
assert_eq!(show(0.0), "#0.0");
assert_eq!(show(-0.0), "#-0.0");
assert_eq!(show(0.125), "#0.125");
assert_eq!(show(-0.375), "#-0.375");
assert_eq!(show(31.0), "#31.0");
assert_eq!(show(0.0625), "#0.0625");
}
#[test]
fn operand_display_covers_every_variant() {
assert_eq!(Operand::Reg(Reg(3)).to_string(), "r3");
assert_eq!(
Operand::RegShifted(
Reg(3),
Shift {
kind: ShiftKind::Asr,
amount: ShiftAmount::Imm(4),
},
)
.to_string(),
"r3, asr #4"
);
assert_eq!(Operand::Imm(9).to_string(), "#9");
assert_eq!(Operand::Imm(10).to_string(), "#0xa");
assert_eq!(Operand::Imm(-0x18).to_string(), "#-0x18");
assert_eq!(Operand::Imm(-1).to_string(), "#-0x1");
assert_eq!(Operand::RegList(0b1001).to_string(), "{r0, r3}");
assert_eq!(Operand::Target(0x8004).to_string(), "0x8004");
assert_eq!(Operand::FpReg(FpReg::S(5)).to_string(), "s5");
assert_eq!(Operand::FpReg(FpReg::D(15)).to_string(), "d15");
assert_eq!(Operand::FpReg(FpReg::Q(3)).to_string(), "q3");
assert_eq!(Operand::FpScalar(FpReg::D(3), 1).to_string(), "d3[1]");
assert_eq!(Operand::SpecialReg("PRIMASK").to_string(), "PRIMASK");
assert_eq!(Operand::Option("nshst").to_string(), "nshst");
assert_eq!(Operand::Coproc(14).to_string(), "p14");
assert_eq!(Operand::CoprocReg(5).to_string(), "c5");
assert_eq!(Operand::Cond(Cond::Ge).to_string(), "ge");
assert_eq!(Operand::Text("be").to_string(), "be");
assert_eq!(ShiftKind::Lsl.to_string(), "lsl");
assert_eq!(ShiftKind::Lsr.to_string(), "lsr");
assert_eq!(ShiftKind::Asr.to_string(), "asr");
assert_eq!(ShiftKind::Ror.to_string(), "ror");
assert_eq!(ShiftKind::Rrx.to_string(), "rrx");
let rrx = Shift {
kind: ShiftKind::Rrx,
amount: ShiftAmount::Imm(1),
};
assert_eq!(rrx.to_string(), "rrx", "the amount is never printed");
assert_eq!(
Shift {
kind: ShiftKind::Ror,
amount: ShiftAmount::Reg(Reg(2)),
}
.to_string(),
"ror r2"
);
}
#[test]
fn an_explicit_width_prints_as_a_qualifier() {
let mut i = insn("mov", &[Operand::Reg(Reg(0)), Operand::Reg(Reg(1))]);
assert_eq!(i.to_string(), "mov r0, r1", "no qualifier by default");
i.explicit_width = true;
assert_eq!(i.to_string(), "mov.n r0, r1");
i.width = Width::Wide;
assert_eq!(i.to_string(), "mov.w r0, r1");
i.sets_flags = true;
i.cond = Some(Cond::Eq);
assert_eq!(i.to_string(), "movseq.w r0, r1");
}
#[test]
fn len_follows_the_width_and_is_empty_is_never_true() {
let mut i = insn("bx", &[Operand::Reg(Reg::LR)]);
assert_eq!(i.len(), 2);
assert_eq!(i.len(), Width::Narrow.bytes());
assert!(!i.is_empty());
i.width = Width::Wide;
assert_eq!(i.len(), 4);
assert_eq!(i.len(), Width::Wide.bytes());
assert!(!i.is_empty());
}
struct FailAfter {
budget: usize,
writes: usize,
}
impl core::fmt::Write for FailAfter {
fn write_str(&mut self, _: &str) -> core::fmt::Result {
if self.writes == self.budget {
return Err(core::fmt::Error);
}
self.writes += 1;
Ok(())
}
}
#[test]
fn display_propagates_writer_errors() {
use core::fmt::Write;
let mem = |mode, index, align| Mem {
base: Reg(1),
index,
offset: 4,
add: true,
align,
mode,
};
let lsl3 = Shift {
kind: ShiftKind::Lsl,
amount: ShiftAmount::Imm(3),
};
let shift = Some(lsl3);
let mut rich = insn(
"ldr",
&[
Operand::Reg(Reg(0)),
Operand::Mem(mem(AddrMode::Offset, None, 0)),
Operand::Target(0x1234),
],
);
rich.sets_flags = true;
rich.cond = Some(Cond::Ne);
rich.explicit_width = true;
let literal = insn(
"ldr",
&[
Operand::Reg(Reg(0)),
Operand::Mem(Mem {
base: Reg::PC,
offset: 0,
..mem(AddrMode::Offset, None, 0)
}),
Operand::Target(0x1004),
],
);
assert_eq!(literal.to_string(), "ldr r0, [pc, #0], 0x1004");
let cases: &[&dyn core::fmt::Display] = &[
&Reg::PC,
&FpReg::D(3),
&ShiftKind::Ror,
&lsl3,
&mem(AddrMode::Offset, Some((Reg(2), shift)), 0),
&mem(AddrMode::Offset, None, 64),
&Mem {
add: false,
..mem(AddrMode::Offset, None, 0)
},
&Mem {
base: Reg::PC,
offset: 0,
..mem(AddrMode::Offset, None, 0)
},
&mem(AddrMode::PreIndex, None, 0),
&mem(AddrMode::PostIndex, None, 32),
&mem(AddrMode::PostIncrement, None, 16),
&Operand::RegList(0b1000_0111_0000_1101),
&Operand::Imm(-4),
&Operand::FpImm(2.0),
&rich,
&literal,
];
for case in cases {
let mut sink = FailAfter {
budget: usize::MAX,
writes: 0,
};
write!(sink, "{case}").expect("an unlimited sink never fails");
let n = sink.writes;
assert!(n > 0, "`{case}` wrote nothing at all");
for budget in 0..n {
let mut sink = FailAfter { budget, writes: 0 };
assert!(
write!(sink, "{case}").is_err(),
"`{case}` swallowed a failure at write {budget} of {n}"
);
assert_eq!(sink.writes, budget, "`{case}` wrote on past the failure");
}
let mut sink = FailAfter {
budget: n,
writes: 0,
};
assert!(write!(sink, "{case}").is_ok(), "`{case}` at full budget");
}
}
#[test]
fn registers_print_their_architectural_names() {
assert_eq!(Reg(0).to_string(), "r0");
assert_eq!(Reg(12).to_string(), "r12");
assert_eq!(Reg::SP.to_string(), "sp");
assert_eq!(Reg::LR.to_string(), "lr");
assert_eq!(Reg::PC.to_string(), "pc");
assert!(Reg(7).is_low() && !Reg(8).is_low());
}
#[test]
fn no_clause_of_the_source_first_guard_can_be_dropped() {
for m in [
"str", "strb", "strh", "strd", "strex", "strexb", "vstr", "vstm", "vldm", "stm",
"stmdb", "push", "vpush", "cmp", "cmn", "tst", "teq", "chka", "srsia", "srsdb",
] {
let i = insn(m, &[Operand::Reg(Reg::PC), Operand::Reg(Reg(0))]);
assert!(
!i.writes_pc(),
"{m} names a source first, so `{m} pc, r0` reads pc"
);
}
for m in ["mov", "add", "sub", "and", "orr", "eor", "lsl", "adr"] {
let i = insn(m, &[Operand::Reg(Reg::PC), Operand::Reg(Reg(0))]);
assert!(i.writes_pc(), "`{m} pc, r0` writes pc");
}
for m in ["ldr", "vldr", "sub"] {
let i = insn(m, &[Operand::Reg(Reg::PC), Operand::Reg(Reg(0))]);
assert!(i.writes_pc(), "`{m} pc, r0` writes pc");
}
}
}