use super::insn::{Operand, Operands, Reg, Shift, ShiftAmount, ShiftKind, Width};
use super::Insn;
fn align_pc(addr: u32) -> u32 {
addr.wrapping_add(4) & !3
}
fn wide(
mnemonic: &'static str,
encoding: &'static str,
addr: u32,
explicit_width: bool,
operands: Operands,
) -> Insn {
Insn {
mnemonic,
encoding,
addr,
width: Width::Wide,
cond: None,
sets_flags: false,
explicit_width,
operands,
}
}
fn adr(addr: u32, rd: Reg, add: bool, imm32: u32) -> Insn {
let base = align_pc(addr);
let target = if add {
base.wrapping_add(imm32)
} else {
base.wrapping_sub(imm32)
};
wide(
"adr",
if add { "T3" } else { "T2" },
addr,
true,
[Operand::Reg(rd), Operand::Target(target)]
.into_iter()
.collect(),
)
}
pub(crate) fn decode(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw1 >> 11 != 0b11110 || (hw1 >> 9) & 1 != 1 || hw2 & 0x8000 != 0 {
return None;
}
let i = (hw1 >> 10) & 1;
let op = (hw1 >> 4) & 0x1F;
let rn = Reg((hw1 & 0xF) as u8);
let imm3 = (hw2 >> 12) & 7;
let rd = Reg(((hw2 >> 8) & 0xF) as u8);
let imm2 = (hw2 >> 6) & 3;
let imm8 = hw2 & 0xFF;
let tail = hw2 & 0x1F;
let imm12 = i64::from((i << 11) | (imm3 << 8) | imm8);
let imm16 = imm12 | (i64::from(hw1 & 0xF) << 12);
let five = (imm3 << 2) | imm2;
let three = |a: Reg, b: Reg, v: i64| -> Operands {
[Operand::Reg(a), Operand::Reg(b), Operand::Imm(v)]
.into_iter()
.collect()
};
Some(match op {
0b00000 if rn == Reg::PC => adr(addr, rd, true, imm12 as u32),
0b00000 => wide("addw", "T4", addr, false, three(rd, rn, imm12)),
0b00100 => wide(
"movw",
"T3",
addr,
false,
[Operand::Reg(rd), Operand::Imm(imm16)]
.into_iter()
.collect(),
),
0b01010 if rn == Reg::PC => adr(addr, rd, false, imm12 as u32),
0b01010 => wide(
"subw",
if rn == Reg::SP { "T3" } else { "T4" },
addr,
false,
three(rd, rn, imm12),
),
0b01100 => wide(
"movt",
"T1",
addr,
false,
[Operand::Reg(rd), Operand::Imm(imm16)]
.into_iter()
.collect(),
),
0b10000 | 0b10010 | 0b11000 | 0b11010 => {
let signed = op & 0b01000 == 0;
let asr = op & 0b00010 != 0;
if asr && five == 0 {
let sat = i64::from(hw2 & 0xF) + i64::from(signed);
wide(
if signed { "ssat16" } else { "usat16" },
"T1",
addr,
false,
[Operand::Reg(rd), Operand::Imm(sat), Operand::Reg(rn)]
.into_iter()
.collect(),
)
} else {
let sat = i64::from(tail) + i64::from(signed);
let source = if asr || five != 0 {
Operand::RegShifted(
rn,
Shift {
kind: if asr { ShiftKind::Asr } else { ShiftKind::Lsl },
amount: ShiftAmount::Imm(five as u8),
},
)
} else {
Operand::Reg(rn)
};
wide(
if signed { "ssat" } else { "usat" },
"T1",
addr,
false,
[Operand::Reg(rd), Operand::Imm(sat), source]
.into_iter()
.collect(),
)
}
}
0b10100 | 0b11100 => wide(
if op == 0b10100 { "sbfx" } else { "ubfx" },
"T1",
addr,
false,
[
Operand::Reg(rd),
Operand::Reg(rn),
Operand::Imm(i64::from(five)),
Operand::Imm(i64::from(tail) + 1),
]
.into_iter()
.collect(),
),
0b10110 => {
if tail < five {
return None;
}
let width = i64::from(tail) - i64::from(five) + 1;
if rn == Reg::PC {
wide(
"bfc",
"T1",
addr,
false,
[
Operand::Reg(rd),
Operand::Imm(i64::from(five)),
Operand::Imm(width),
]
.into_iter()
.collect(),
)
} else {
wide(
"bfi",
"T1",
addr,
false,
[
Operand::Reg(rd),
Operand::Reg(rn),
Operand::Imm(i64::from(five)),
Operand::Imm(width),
]
.into_iter()
.collect(),
)
}
}
_ => return None,
})
}
fn reg(op: Option<Operand>) -> Option<u16> {
match op {
Some(Operand::Reg(r)) => Some(u16::from(r.num())),
_ => None,
}
}
fn imm_val(op: Option<Operand>) -> Option<i64> {
match op {
Some(Operand::Imm(v)) => Some(v),
_ => None,
}
}
fn uimm(op: Option<Operand>, max: i64) -> Option<u16> {
let v = imm_val(op)?;
if (0..=max).contains(&v) {
Some(v as u16)
} else {
None
}
}
fn sat_field(op: Option<Operand>, signed: bool, max: i64) -> Option<u16> {
let v = imm_val(op)?;
let min = i64::from(signed);
if !(min..=max).contains(&v) {
return None;
}
Some((v - min) as u16)
}
fn sat_source(op: Option<Operand>) -> Option<(u16, u16, u16)> {
match op {
Some(Operand::Reg(r)) => Some((u16::from(r.num()), 0, 0)),
Some(Operand::RegShifted(r, s)) => {
let amount = match s.amount {
ShiftAmount::Imm(n) => u16::from(n),
ShiftAmount::Reg(_) => return None,
};
let sh = match s.kind {
ShiftKind::Lsl => 0,
ShiftKind::Asr => 1,
_ => return None,
};
if amount == 0 || amount > 31 {
return None;
}
Some((u16::from(r.num()), sh, amount))
}
_ => None,
}
}
fn plain12(op: u16, rn: u16, rd: u16, imm12: u16) -> (u16, u16) {
(
0xF200 | ((imm12 >> 11) << 10) | (op << 4) | rn,
(((imm12 >> 8) & 7) << 12) | (rd << 8) | (imm12 & 0xFF),
)
}
fn field_form(op: u16, rn: u16, rd: u16, five: u16, tail: u16) -> (u16, u16) {
(
0xF200 | (op << 4) | rn,
((five >> 2) << 12) | (rd << 8) | ((five & 3) << 6) | tail,
)
}
pub(crate) fn encode(insn: &Insn) -> Option<(u16, u16)> {
if insn.width != Width::Wide || insn.sets_flags {
return None;
}
let ops = &insn.operands;
let (a, b, c, d) = (ops.get(0), ops.get(1), ops.get(2), ops.get(3));
match (insn.mnemonic, insn.encoding, ops.len()) {
("addw", "T4", 3) => {
let rn = reg(b)?;
if rn == 15 {
return None;
}
Some(plain12(0b00000, rn, reg(a)?, uimm(c, 4095)?))
}
("subw", "T4", 3) | ("subw", "T3", 3) => {
let rn = reg(b)?;
if rn == 15 || (rn == 13) != (insn.encoding == "T3") {
return None;
}
Some(plain12(0b01010, rn, reg(a)?, uimm(c, 4095)?))
}
("adr", "T3", 2) | ("adr", "T2", 2) => {
let add = insn.encoding == "T3";
let target = match b {
Some(Operand::Target(t)) => t,
_ => return None,
};
let base = align_pc(insn.addr);
let off = if add {
target.wrapping_sub(base)
} else {
base.wrapping_sub(target)
};
if off > 4095 {
return None;
}
Some(plain12(
if add { 0b00000 } else { 0b01010 },
15,
reg(a)?,
off as u16,
))
}
("movw", "T3", 2) | ("movt", "T1", 2) => {
let imm = uimm(b, 0xFFFF)?;
let op = if insn.mnemonic == "movw" {
0b00100
} else {
0b01100
};
Some(plain12(op, imm >> 12, reg(a)?, imm & 0xFFF))
}
("ssat", "T1", 3) | ("usat", "T1", 3) => {
let signed = insn.mnemonic == "ssat";
let sat = sat_field(b, signed, if signed { 32 } else { 31 })?;
let (rn, sh, amount) = sat_source(c)?;
let op = 0b10000 | (if signed { 0 } else { 0b01000 }) | (sh << 1);
Some(field_form(op, rn, reg(a)?, amount, sat))
}
("ssat16", "T1", 3) | ("usat16", "T1", 3) => {
let signed = insn.mnemonic == "ssat16";
let sat = sat_field(b, signed, if signed { 16 } else { 15 })?;
let op = 0b10010 | (if signed { 0 } else { 0b01000 });
Some(field_form(op, reg(c)?, reg(a)?, 0, sat))
}
("sbfx", "T1", 4) | ("ubfx", "T1", 4) => {
let lsb = uimm(c, 31)?;
let width = imm_val(d)?;
if !(1..=32).contains(&width) {
return None;
}
let op = if insn.mnemonic == "sbfx" {
0b10100
} else {
0b11100
};
Some(field_form(op, reg(b)?, reg(a)?, lsb, (width - 1) as u16))
}
("bfi", "T1", 4) => {
let rn = reg(b)?;
let lsb = uimm(c, 31)?;
let msb = i64::from(lsb) + imm_val(d)? - 1;
if rn == 15 || !(i64::from(lsb)..=31).contains(&msb) {
return None;
}
Some(field_form(0b10110, rn, reg(a)?, lsb, msb as u16))
}
("bfc", "T1", 3) => {
let lsb = uimm(b, 31)?;
let msb = i64::from(lsb) + imm_val(c)? - 1;
if !(i64::from(lsb)..=31).contains(&msb) {
return None;
}
Some(field_form(0b10110, 15, reg(a)?, lsb, msb as u16))
}
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::{align_pc, decode, encode};
use crate::isa::Target;
use crate::isa::{decode_halfwords, Insn, Operand, Operands, Reg, Width};
const ALLOCATED: [u16; 11] = [
0b00000, 0b00100, 0b01010, 0b01100, 0b10000, 0b10010, 0b10100, 0b10110, 0b11000, 0b11010,
0b11100,
];
fn canonical(hw1: u16, hw2: u16) -> (u16, u16) {
let op = (hw1 >> 4) & 0x1F;
let mut h1 = hw1;
let mut h2 = hw2;
if op >= 0b10000 {
h1 &= !0x0400;
h2 &= !0x0020;
}
if (op == 0b10010 || op == 0b11010) && hw2 & 0x70C0 == 0 {
h2 &= !0x0010;
}
(h1, h2)
}
#[test]
fn systematic_round_trip() {
const IMM3: [u16; 4] = [0, 1, 6, 7];
const RD: [u16; 6] = [0, 1, 7, 8, 14, 15];
const LOW8: [u16; 16] = [
0x00, 0x01, 0x1E, 0x1F, 0x20, 0x3F, 0x40, 0x41, 0x5E, 0x7F, 0x80, 0x9F, 0xC0, 0xDE,
0xFE, 0xFF,
];
let mut seen = [0u32; 32];
for i in 0..2u16 {
for op in 0..32u16 {
for rn in 0..16u16 {
let hw1 = 0xF200 | (i << 10) | (op << 4) | rn;
for imm3 in IMM3 {
for rd in RD {
for low in LOW8 {
let hw2 = (imm3 << 12) | (rd << 8) | low;
let insn = match decode(hw1, hw2, 0x1000) {
Some(x) => x,
None => continue,
};
seen[op as usize] += 1;
assert_eq!(insn.width, Width::Wide, "{hw1:#06x} {hw2:#06x}");
assert!(
!insn.sets_flags,
"{hw1:#06x} {hw2:#06x} would print as `{}s`",
insn.mnemonic
);
assert_eq!(insn.addr, 0x1000);
assert_eq!(
encode(&insn),
Some(canonical(hw1, hw2)),
"{hw1:#06x} {hw2:#06x} decoded as `{insn}` but did not \
re-encode"
);
}
}
}
}
}
}
for (op, &count) in seen.iter().enumerate() {
let allocated = ALLOCATED.contains(&(op as u16));
let negation = if allocated { "" } else { "not " };
assert_eq!(
count > 0,
allocated,
"op {op:#07b} is {negation}allocated in Table A5-12"
);
}
}
#[test]
fn dispatch_boundary() {
for op in ALLOCATED {
let hw1 = 0xF200 | (op << 4) | 1;
let hw2 = 0x0102;
assert_eq!(
decode_halfwords(hw1, hw2, 0x1000, Target::Union),
decode(hw1, hw2, 0x1000),
"{hw1:#06x} is not reaching t32_dp_plainimm"
);
assert!(decode(hw1 & !0x0200, hw2, 0).is_none());
assert!(decode(hw1, hw2 | 0x8000, 0).is_none());
}
assert!(decode(0x4770, 0, 0).is_none());
assert!(decode(0xE800, 0x0102, 0).is_none());
assert!(decode(0xFA00, 0x0102, 0).is_none());
}
#[test]
fn movw_movt_immediate_field_order() {
let insn = decode(0xF64B, 0x63EF, 0).unwrap();
assert_eq!(insn.mnemonic, "movw");
assert_eq!(insn.encoding, "T3");
assert_eq!(insn.operands.get(1), Some(Operand::Imm(0xBEEF)));
assert_eq!(insn.to_string(), "movw r3, #0xbeef");
assert_eq!(encode(&insn), Some((0xF64B, 0x63EF)));
let insn = decode(0xF2C1, 0x2334, 0).unwrap();
assert_eq!(insn.mnemonic, "movt");
assert_eq!(insn.encoding, "T1");
assert_eq!(insn.operands.get(1), Some(Operand::Imm(0x1234)));
assert_eq!(insn.to_string(), "movt r3, #0x1234");
assert_eq!(encode(&insn), Some((0xF2C1, 0x2334)));
let movw = decode(0xF64B, 0x63EF, 0).unwrap();
assert_eq!(movw.operands.get(1), Some(Operand::Imm(0xBEEF)));
let no_i = decode(0xF64B & !0x0400, 0x63EF, 0).unwrap();
assert_eq!(no_i.operands.get(1), Some(Operand::Imm(0xBEEF - 0x800)));
let no_imm4 = decode(0xF640, 0x63EF, 0).unwrap();
assert_eq!(no_imm4.operands.get(1), Some(Operand::Imm(0xBEEF - 0xB000)));
let no_imm3 = decode(0xF64B, 0x03EF, 0).unwrap();
assert_eq!(no_imm3.operands.get(1), Some(Operand::Imm(0xBEEF - 0x600)));
for bit in 0..16u32 {
let v = 1u32 << bit;
let (imm4, i, imm3, imm8) = (v >> 12, (v >> 11) & 1, (v >> 8) & 7, v & 0xFF);
let hw1 = 0xF240 | ((i as u16) << 10) | (imm4 as u16);
let hw2 = ((imm3 as u16) << 12) | (imm8 as u16);
let insn = decode(hw1, hw2, 0).unwrap();
assert_eq!(insn.mnemonic, "movw");
assert_eq!(
insn.operands.get(1),
Some(Operand::Imm(i64::from(v))),
"bit {bit} of a MOVW immediate"
);
assert_eq!(encode(&insn), Some((hw1, hw2)));
}
}
#[test]
fn adr_resolves_against_aligned_pc() {
assert_eq!(align_pc(0x1000), 0x1004);
assert_eq!(align_pc(0x1002), 0x1004);
assert_eq!(align_pc(0x1004), 0x1008);
assert_eq!(align_pc(0x1006), 0x1008);
for &addr in &[0x1000u32, 0x1002] {
let insn = decode(0xF20F, 0x0010, addr).unwrap();
assert_eq!(insn.mnemonic, "adr");
assert_eq!(insn.encoding, "T3");
assert!(insn.explicit_width);
assert_eq!(insn.branch_target(), Some(0x1014), "at {addr:#x}");
assert_eq!(insn.to_string(), "adr.w r0, 0x1014");
assert_eq!(encode(&insn), Some((0xF20F, 0x0010)), "at {addr:#x}");
}
for &addr in &[0x1000u32, 0x1002] {
let insn = decode(0xF2AF, 0x0120, addr).unwrap();
assert_eq!(insn.mnemonic, "adr");
assert_eq!(insn.encoding, "T2");
assert_eq!(insn.branch_target(), Some(0x0FE4), "at {addr:#x}");
assert_eq!(insn.to_string(), "adr.w r1, 0xfe4");
assert_eq!(encode(&insn), Some((0xF2AF, 0x0120)), "at {addr:#x}");
}
assert_eq!(
decode(0xF20F, 0x0010, 0x1004).unwrap().branch_target(),
Some(0x1018)
);
let add0 = decode(0xF20F, 0x0000, 0x1000).unwrap();
let sub0 = decode(0xF2AF, 0x0000, 0x1000).unwrap();
assert_eq!(add0.branch_target(), sub0.branch_target());
assert_eq!(add0.branch_target(), Some(0x1004));
assert_eq!(encode(&add0), Some((0xF20F, 0x0000)));
assert_eq!(encode(&sub0), Some((0xF2AF, 0x0000)));
let far = decode(0xF60F, 0x70FF, 0x1000).unwrap();
assert_eq!(far.branch_target(), Some(0x1004 + 4095));
let back = decode(0xF6AF, 0x70FF, 0x1000).unwrap();
assert_eq!(back.branch_target(), Some(0x1004 - 4095));
}
#[test]
fn fields_ual_prints_differently_from_the_encoding() {
let insn = decode(0xF301, 0x0000, 0).unwrap();
assert_eq!(insn.to_string(), "ssat r0, #1, r1");
assert_eq!(insn.operands.get(1), Some(Operand::Imm(1)));
assert_eq!(encode(&insn), Some((0xF301, 0x0000)));
let insn = decode(0xF301, 0x001F, 0).unwrap();
assert_eq!(insn.to_string(), "ssat r0, #0x20, r1");
let insn = decode(0xF381, 0x0000, 0).unwrap();
assert_eq!(insn.to_string(), "usat r0, #0, r1");
assert_eq!(insn.operands.get(1), Some(Operand::Imm(0)));
let insn = decode(0xF381, 0x001F, 0).unwrap();
assert_eq!(insn.to_string(), "usat r0, #0x1f, r1");
assert_eq!(
decode(0xF321, 0x0000, 0).unwrap().to_string(),
"ssat16 r0, #1, r1"
);
assert_eq!(
decode(0xF3A1, 0x0000, 0).unwrap().to_string(),
"usat16 r0, #0, r1"
);
let insn = decode(0xF341, 0x1047, 0).unwrap();
assert_eq!(insn.to_string(), "sbfx r0, r1, #5, #8");
assert_eq!(insn.operands.get(2), Some(Operand::Imm(5)));
assert_eq!(insn.operands.get(3), Some(Operand::Imm(8)));
assert_eq!(encode(&insn), Some((0xF341, 0x1047)));
let insn = decode(0xF3C1, 0x001F, 0).unwrap();
assert_eq!(insn.to_string(), "ubfx r0, r1, #0, #0x20");
assert_eq!(insn.operands.get(3), Some(Operand::Imm(32)));
let insn = decode(0xF361, 0x100F, 0).unwrap();
assert_eq!(insn.to_string(), "bfi r0, r1, #4, #0xc");
assert_eq!(insn.operands.get(2), Some(Operand::Imm(4)));
assert_eq!(insn.operands.get(3), Some(Operand::Imm(12)));
assert_eq!(encode(&insn), Some((0xF361, 0x100F)));
}
#[test]
fn ual_per_table_row() {
let cases: &[(u16, u16, &str)] = &[
(0xF201, 0x1023, "addw r0, r1, #0x123"),
(0xF20D, 0x1D00, "addw sp, sp, #0x100"),
(0xF20F, 0x0010, "adr.w r0, 0x1014"),
(0xF64B, 0x63EF, "movw r3, #0xbeef"),
(0xF6A3, 0x72FF, "subw r2, r3, #0xfff"),
(0xF6AD, 0x7DFF, "subw sp, sp, #0xfff"),
(0xF2AF, 0x0120, "adr.w r1, 0xfe4"),
(0xF2C1, 0x2334, "movt r3, #0x1234"),
(0xF301, 0x10D7, "ssat r0, #0x18, r1, lsl #7"),
(0xF301, 0x0000, "ssat r0, #1, r1"),
(0xF321, 0x101F, "ssat r0, #0x20, r1, asr #4"),
(0xF321, 0x000F, "ssat16 r0, #0x10, r1"),
(0xF341, 0x1047, "sbfx r0, r1, #5, #8"),
(0xF361, 0x100F, "bfi r0, r1, #4, #0xc"),
(0xF36F, 0x200B, "bfc r0, #8, #4"),
(0xF381, 0x001F, "usat r0, #0x1f, r1"),
(0xF3A1, 0x10D7, "usat r0, #0x17, r1, asr #7"),
(0xF3A1, 0x000F, "usat16 r0, #0xf, r1"),
(0xF3C1, 0x001F, "ubfx r0, r1, #0, #0x20"),
];
for &(hw1, hw2, text) in cases {
let insn = decode_halfwords(hw1, hw2, 0x1000, Target::Union).expect("defined encoding");
assert_eq!(insn.to_string(), text, "for {hw1:#06x} {hw2:#06x}");
assert_eq!(encode(&insn), Some((hw1, hw2)), "for `{text}`");
}
}
#[test]
fn bitfield_with_msb_below_lsb_is_refused() {
assert!(decode(0xF361, 0x2003, 0).is_none());
assert!(decode(0xF36F, 0x2003, 0).is_none());
let insn = decode(0xF361, 0x2008, 0).unwrap();
assert_eq!(insn.to_string(), "bfi r0, r1, #8, #1");
assert_eq!(encode(&insn), Some((0xF361, 0x2008)));
assert!(decode(0xF361, 0x2007, 0).is_none());
for lsb in 0..32u16 {
for msb in 0..32u16 {
let hw2 = ((lsb >> 2) << 12) | ((lsb & 3) << 6) | msb;
assert_eq!(
decode(0xF361, hw2, 0).is_some(),
msb >= lsb,
"bfi lsb {lsb} msb {msb}"
);
assert_eq!(
decode(0xF36F, hw2, 0).is_some(),
msb >= lsb,
"bfc lsb {lsb} msb {msb}"
);
}
}
let mut zero_width = decode(0xF361, 0x2008, 0).unwrap();
zero_width.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Imm(8),
Operand::Imm(0),
]
.into_iter()
.collect();
assert_eq!(encode(&zero_width), None);
zero_width.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Imm(24),
Operand::Imm(9),
]
.into_iter()
.collect();
assert_eq!(encode(&zero_width), None);
}
#[test]
fn should_be_zero_bits_are_ignored() {
let canon = decode(0xF341, 0x1047, 0).unwrap();
let stray = decode(0xF741, 0x1047, 0).unwrap();
assert_eq!(canon, stray);
assert_eq!(encode(&stray), Some((0xF341, 0x1047)));
let stray = decode(0xF341, 0x1067, 0).unwrap();
assert_eq!(canon, stray);
assert_eq!(encode(&stray), Some((0xF341, 0x1047)));
let canon = decode(0xF321, 0x000F, 0).unwrap();
let stray = decode(0xF321, 0x001F, 0).unwrap();
assert_eq!(canon, stray);
assert_eq!(encode(&stray), Some((0xF321, 0x000F)));
assert_eq!(
decode(0xF301, 0x001F, 0).unwrap().operands.get(1),
Some(Operand::Imm(32))
);
}
#[test]
fn wide_add_and_subtract_never_set_flags() {
for op in [0b00000u16, 0b01010] {
for rn in 0..15u16 {
let insn = decode(0xF200 | (op << 4) | rn, 0x1023, 0).unwrap();
assert!(!insn.sets_flags);
let text = insn.to_string();
assert!(
text.starts_with("addw ") || text.starts_with("subw "),
"printed `{text}`"
);
}
}
}
#[test]
fn sp_forms_carry_their_own_encoding_names() {
assert_eq!(decode(0xF20D, 0x1D00, 0).unwrap().encoding, "T4");
assert_eq!(decode(0xF6AD, 0x7DFF, 0).unwrap().encoding, "T3");
assert_eq!(decode(0xF6A3, 0x72FF, 0).unwrap().encoding, "T4");
let mut wrong = decode(0xF6AD, 0x7DFF, 0).unwrap();
wrong.encoding = "T4";
assert_eq!(encode(&wrong), None);
}
#[test]
fn encode_rejects_foreign_forms() {
let base = decode(0xF201, 0x1023, 0).unwrap();
let mut narrow = base;
narrow.width = Width::Narrow;
assert_eq!(encode(&narrow), None);
let mut flags = base;
flags.sets_flags = true;
assert_eq!(encode(&flags), None);
let mut modimm = base;
modimm.mnemonic = "add";
modimm.encoding = "T3";
assert_eq!(encode(&modimm), None);
let mut pc_form = base;
pc_form.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg::PC),
Operand::Imm(0x123),
]
.into_iter()
.collect();
assert_eq!(encode(&pc_form), None);
let mut bfi_pc = decode(0xF361, 0x100F, 0).unwrap();
bfi_pc.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg::PC),
Operand::Imm(4),
Operand::Imm(12),
]
.into_iter()
.collect();
assert_eq!(encode(&bfi_pc), None);
let mut big = base;
big.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Imm(4096),
]
.into_iter()
.collect();
assert_eq!(encode(&big), None);
let ssat = decode(0xF301, 0x0000, 0).unwrap();
let usat = decode(0xF381, 0x0000, 0).unwrap();
let sat_with = |insn: &Insn, v: i64| {
let mut i = *insn;
let mut ops = Operands::new();
ops.push(Operand::Reg(Reg(0)));
ops.push(Operand::Imm(v));
ops.push(Operand::Reg(Reg(1)));
i.operands = ops;
encode(&i)
};
assert_eq!(sat_with(&ssat, 0), None);
assert!(sat_with(&ssat, 32).is_some());
assert!(sat_with(&usat, 0).is_some());
assert_eq!(sat_with(&usat, 32), None);
let mut far = decode(0xF20F, 0x0010, 0x1000).unwrap();
far.operands = [Operand::Reg(Reg(0)), Operand::Target(0x2003)]
.into_iter()
.collect();
assert!(encode(&far).is_some());
far.operands = [Operand::Reg(Reg(0)), Operand::Target(0x2004)]
.into_iter()
.collect();
assert_eq!(encode(&far), None);
far.operands = [Operand::Reg(Reg(0)), Operand::Target(0x0FF0)]
.into_iter()
.collect();
assert_eq!(encode(&far), None);
}
#[test]
fn saturate_shift_operand() {
use crate::isa::{Shift, ShiftAmount, ShiftKind};
let plain = decode(0xF301, 0x0000, 0).unwrap();
assert_eq!(plain.operands.get(2), Some(Operand::Reg(Reg(1))));
let shifted = decode(0xF301, 0x10D7, 0).unwrap();
assert_eq!(
shifted.operands.get(2),
Some(Operand::RegShifted(
Reg(1),
Shift {
kind: ShiftKind::Lsl,
amount: ShiftAmount::Imm(7),
}
))
);
let asr = decode(0xF321, 0x101F, 0).unwrap();
assert_eq!(
asr.operands.get(2),
Some(Operand::RegShifted(
Reg(1),
Shift {
kind: ShiftKind::Asr,
amount: ShiftAmount::Imm(4),
}
))
);
let mut explicit_zero = plain;
explicit_zero.operands = [
Operand::Reg(Reg(0)),
Operand::Imm(1),
Operand::RegShifted(
Reg(1),
Shift {
kind: ShiftKind::Lsl,
amount: ShiftAmount::Imm(0),
},
),
]
.into_iter()
.collect();
assert_eq!(encode(&explicit_zero), None);
explicit_zero.operands = [
Operand::Reg(Reg(0)),
Operand::Imm(1),
Operand::RegShifted(
Reg(1),
Shift {
kind: ShiftKind::Ror,
amount: ShiftAmount::Imm(4),
},
),
]
.into_iter()
.collect();
assert_eq!(encode(&explicit_zero), None);
}
#[test]
fn encode_rejects_every_mangled_operand_slot() {
for (hw1, hw2) in [
(0xF201u16, 0x1023u16), (0xF6A3, 0x72FF), (0xF6AD, 0x7DFF), (0xF20F, 0x0010), (0xF2AF, 0x0120), (0xF64B, 0x63EF), (0xF2C1, 0x2334), (0xF301, 0x10D7), (0xF301, 0x0000), (0xF321, 0x000F), (0xF381, 0x001F), (0xF3A1, 0x000F), (0xF341, 0x1047), (0xF3C1, 0x001F), (0xF361, 0x100F), (0xF36F, 0x200B), ] {
let insn = decode(hw1, hw2, 0x1000).unwrap();
assert_eq!(
encode(&insn),
Some((hw1, hw2)),
"`{insn}` should round-trip before anything is mangled"
);
let arity = insn.operands.len();
for slot in 0..arity {
let mut mangled = insn;
mangled.operands = (0..arity)
.map(|i| {
let op = insn.operands.get(i).unwrap();
if i != slot {
op
} else {
match op {
Operand::Imm(_) | Operand::Target(_) => Operand::Reg(Reg(0)),
_ => Operand::Imm(0),
}
}
})
.collect();
assert_eq!(encode(&mangled), None, "`{insn}`, operand {slot} mangled");
}
}
}
#[test]
fn bitfield_widths_outside_the_field_are_refused() {
let extract = |mnemonic: &'static str, hw1, hw2, lsb: i64, width: i64| {
let mut insn: Insn = decode(hw1, hw2, 0).unwrap();
assert_eq!(insn.mnemonic, mnemonic);
insn.operands = [
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
Operand::Imm(lsb),
Operand::Imm(width),
]
.into_iter()
.collect();
encode(&insn)
};
for (mnemonic, hw1, hw2) in [("sbfx", 0xF341u16, 0x1047u16), ("ubfx", 0xF3C1, 0x001F)] {
assert_eq!(
extract(mnemonic, hw1, hw2, 0, 0),
None,
"{mnemonic} #0 wide"
);
assert_eq!(extract(mnemonic, hw1, hw2, 0, 33), None, "{mnemonic} #33");
assert_eq!(extract(mnemonic, hw1, hw2, 0, -1), None, "{mnemonic} #-1");
assert!(extract(mnemonic, hw1, hw2, 0, 1).is_some(), "{mnemonic} #1");
assert!(
extract(mnemonic, hw1, hw2, 0, 32).is_some(),
"{mnemonic} #32"
);
}
let clear = |lsb: i64, width: i64| {
let mut insn: Insn = decode(0xF36F, 0x200B, 0).unwrap();
assert_eq!(insn.mnemonic, "bfc");
insn.operands = [Operand::Reg(Reg(0)), Operand::Imm(lsb), Operand::Imm(width)]
.into_iter()
.collect();
encode(&insn)
};
assert!(
clear(8, 24).is_some(),
"bits 8..=31 is the whole of the top"
);
assert_eq!(clear(8, 25), None, "that would need bit 32");
assert_eq!(clear(8, 0), None, "a field of no bits clears nothing");
assert!(clear(0, 32).is_some(), "the whole register");
assert_eq!(clear(0, 33), None);
}
#[test]
fn a_saturating_shift_cannot_be_by_a_register() {
use crate::isa::{Shift, ShiftAmount, ShiftKind};
let mut insn = decode(0xF301, 0x10D7, 0).unwrap();
assert_eq!(insn.mnemonic, "ssat");
insn.operands = [
Operand::Reg(Reg(0)),
Operand::Imm(1),
Operand::RegShifted(
Reg(1),
Shift {
kind: ShiftKind::Lsl,
amount: ShiftAmount::Reg(Reg(2)),
},
),
]
.into_iter()
.collect();
assert_eq!(encode(&insn), None);
}
#[test]
fn movw_movt_pair_builds_a_word() {
let lo = decode(0xF64B, 0x63EF, 0).unwrap();
let hi = decode(0xF6CD, 0x63AD, 4).unwrap();
const WORD: u32 = 0xDEAD_BEEF;
assert_eq!(
lo.operands.get(1),
Some(Operand::Imm(i64::from(WORD & 0xFFFF)))
);
assert_eq!(
hi.operands.get(1),
Some(Operand::Imm(i64::from(WORD >> 16)))
);
assert_eq!(lo.to_string(), "movw r3, #0xbeef");
assert_eq!(hi.to_string(), "movt r3, #0xdead");
}
}