use super::{AddrMode, Insn, Mem, Operand, Operands, Reg, Width};
const REG_OFFSET: [&str; 8] = [
"str", "strh", "strb", "ldrsb", "ldr", "ldrh", "ldrb", "ldrsh", ];
const IMM_OFFSET: [(&str, &str, u32); 3] = [
("str", "ldr", 4), ("strb", "ldrb", 1), ("strh", "ldrh", 2), ];
fn literal_base(addr: u32) -> u32 {
addr.wrapping_add(4) & !3
}
fn narrow(mnemonic: &'static str, encoding: &'static str, addr: u32, operands: Operands) -> Insn {
Insn {
mnemonic,
encoding,
addr,
width: Width::Narrow,
cond: None,
sets_flags: false,
explicit_width: false,
operands,
}
}
fn transfer(rt: Reg, mem: Mem) -> Operands {
let mut operands = Operands::new();
operands.push(Operand::Reg(rt));
operands.push(Operand::Mem(mem));
operands
}
pub(crate) fn decode(hw1: u16, _hw2: u16, addr: u32) -> Option<Insn> {
match hw1 >> 11 {
0b01001 => Some(decode_literal(hw1, addr)),
0b01010 | 0b01011 => Some(decode_register(hw1, addr)),
0b01100..=0b10001 => Some(decode_immediate(hw1, addr)),
0b10010 | 0b10011 => Some(decode_sp_relative(hw1, addr)),
0b10100 => Some(decode_adr(hw1, addr)),
0b10101 => Some(decode_add_sp(hw1, addr)),
_ => None,
}
}
fn decode_literal(hw1: u16, addr: u32) -> Insn {
let rt = Reg(((hw1 >> 8) & 0b111) as u8);
let offset = (hw1 & 0xFF) as u32 * 4;
let mut operands = transfer(
rt,
Mem {
base: Reg::PC,
index: None,
offset,
add: true,
align: 0,
mode: AddrMode::Offset,
},
);
operands.push(Operand::Target(literal_base(addr).wrapping_add(offset)));
narrow("ldr", "T1", addr, operands)
}
fn decode_register(hw1: u16, addr: u32) -> Insn {
let opb = ((hw1 >> 9) & 0b111) as usize;
let rm = Reg(((hw1 >> 6) & 0b111) as u8);
let rn = Reg(((hw1 >> 3) & 0b111) as u8);
let rt = Reg((hw1 & 0b111) as u8);
let operands = transfer(
rt,
Mem {
base: rn,
index: Some((rm, None)),
offset: 0,
add: true,
align: 0,
mode: AddrMode::Offset,
},
);
narrow(REG_OFFSET[opb], "T1", addr, operands)
}
fn decode_immediate(hw1: u16, addr: u32) -> Insn {
let (store, load, scale) = IMM_OFFSET[(hw1 >> 12) as usize - 0b0110];
let mnemonic = if hw1 & 0x0800 != 0 { load } else { store };
let offset = ((hw1 >> 6) & 0x1F) as u32 * scale;
let rn = Reg(((hw1 >> 3) & 0b111) as u8);
let rt = Reg((hw1 & 0b111) as u8);
let operands = transfer(
rt,
Mem {
base: rn,
index: None,
offset,
add: true,
align: 0,
mode: AddrMode::Offset,
},
);
narrow(mnemonic, "T1", addr, operands)
}
fn decode_sp_relative(hw1: u16, addr: u32) -> Insn {
let mnemonic = if hw1 & 0x0800 != 0 { "ldr" } else { "str" };
let rt = Reg(((hw1 >> 8) & 0b111) as u8);
let operands = transfer(
rt,
Mem {
base: Reg::SP,
index: None,
offset: u32::from(hw1 & 0xFF) * 4,
add: true,
align: 0,
mode: AddrMode::Offset,
},
);
narrow(mnemonic, "T2", addr, operands)
}
fn decode_adr(hw1: u16, addr: u32) -> Insn {
let rd = Reg(((hw1 >> 8) & 0b111) as u8);
let target = literal_base(addr).wrapping_add((hw1 & 0xFF) as u32 * 4);
let mut operands = Operands::new();
operands.push(Operand::Reg(rd));
operands.push(Operand::Target(target));
narrow("adr", "T1", addr, operands)
}
fn decode_add_sp(hw1: u16, addr: u32) -> Insn {
let rd = Reg(((hw1 >> 8) & 0b111) as u8);
let mut operands = Operands::new();
operands.push(Operand::Reg(rd));
operands.push(Operand::Reg(Reg::SP));
operands.push(Operand::Imm((hw1 & 0xFF) as i64 * 4));
narrow("add", "T1", addr, operands)
}
fn low_reg(op: Option<Operand>) -> Option<u16> {
match op {
Some(Operand::Reg(r)) if r.is_low() => Some(r.num() as u16),
_ => None,
}
}
fn scaled_imm8(bytes: u32) -> Option<u16> {
if bytes % 4 != 0 || bytes / 4 > 0xFF {
return None;
}
Some((bytes / 4) as u16)
}
pub(crate) fn encode(insn: &Insn) -> Option<u16> {
if insn.width != Width::Narrow || insn.sets_flags || insn.explicit_width {
return None;
}
match insn.mnemonic {
"adr" => encode_adr(insn),
"add" => encode_add_sp(insn),
_ => encode_transfer(insn),
}
}
fn encode_adr(insn: &Insn) -> Option<u16> {
if insn.encoding != "T1" || insn.operands.len() != 2 {
return None;
}
let rd = low_reg(insn.operands.get(0))?;
let target = match insn.operands.get(1) {
Some(Operand::Target(t)) => t,
_ => return None,
};
let imm8 = scaled_imm8(target.checked_sub(literal_base(insn.addr))?)?;
Some(0xA000 | (rd << 8) | imm8)
}
fn encode_add_sp(insn: &Insn) -> Option<u16> {
if insn.encoding != "T1" || insn.operands.len() != 3 {
return None;
}
let rd = low_reg(insn.operands.get(0))?;
if insn.operands.get(1) != Some(Operand::Reg(Reg::SP)) {
return None;
}
let imm = match insn.operands.get(2) {
Some(Operand::Imm(v)) => u32::try_from(v).ok()?,
_ => return None,
};
Some(0xA800 | (rd << 8) | scaled_imm8(imm)?)
}
fn encode_transfer(insn: &Insn) -> Option<u16> {
let rt = low_reg(insn.operands.get(0))?;
let mem = match insn.operands.get(1) {
Some(Operand::Mem(m)) => m,
_ => return None,
};
if mem.mode != AddrMode::Offset {
return None;
}
if let Some((rm, shift)) = mem.index {
if shift.is_some() || mem.offset != 0 || !mem.add || insn.operands.len() != 2 {
return None;
}
if insn.encoding != "T1" || !mem.base.is_low() || !rm.is_low() {
return None;
}
let opb = REG_OFFSET.iter().position(|m| *m == insn.mnemonic)? as u16;
return Some(
0x5000 | (opb << 9) | ((rm.num() as u16) << 6) | ((mem.base.num() as u16) << 3) | rt,
);
}
if !mem.add {
return None;
}
let offset = mem.offset;
if mem.base == Reg::PC {
if insn.mnemonic != "ldr" || insn.encoding != "T1" || insn.operands.len() != 3 {
return None;
}
let target = match insn.operands.get(2) {
Some(Operand::Target(t)) => t,
_ => return None,
};
if target != literal_base(insn.addr).wrapping_add(offset) {
return None;
}
return Some(0x4800 | (rt << 8) | scaled_imm8(offset)?);
}
if mem.base == Reg::SP {
if insn.encoding != "T2" || insn.operands.len() != 2 {
return None;
}
let load = match insn.mnemonic {
"ldr" => 1u16,
"str" => 0u16,
_ => return None,
};
return Some(0x9000 | (load << 11) | (rt << 8) | scaled_imm8(offset)?);
}
if insn.encoding != "T1" || insn.operands.len() != 2 || !mem.base.is_low() {
return None;
}
let (row, load) = IMM_OFFSET
.iter()
.enumerate()
.find_map(|(i, (store, load, _))| {
if *store == insn.mnemonic {
Some((i, 0u16))
} else if *load == insn.mnemonic {
Some((i, 1u16))
} else {
None
}
})?;
let scale = IMM_OFFSET[row].2;
if offset % scale != 0 {
return None;
}
let imm5 = offset / scale;
if imm5 > 0x1F {
return None;
}
let opa = 0b0110 + row as u16;
Some((opa << 12) | (load << 11) | ((imm5 as u16) << 6) | ((mem.base.num() as u16) << 3) | rt)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::isa::{Shift, ShiftAmount, ShiftKind};
const FIRST: u16 = 0x4800;
const LAST: u16 = 0xAFFF;
const ALIGNED: u32 = 0x1000;
const UNALIGNED: u32 = 0x1002;
fn ual(hw1: u16, addr: u32) -> String {
decode(hw1, 0, addr)
.expect("every halfword in A5.2.4 decodes")
.to_string()
}
fn mem_of(hw1: u16, addr: u32) -> String {
let mem = decode(hw1, 0, addr)
.expect("every halfword in A5.2.4 decodes")
.operands
.as_slice()
.find_map(|o| match o {
Operand::Mem(m) => Some(m.to_string()),
_ => None,
});
mem.unwrap_or_else(String::new)
}
#[test]
fn group_is_fully_allocated_and_round_trips_at_both_alignments() {
let holes: Vec<u16> = (FIRST..=LAST)
.filter(|hw1| decode(*hw1, 0, ALIGNED).is_none())
.collect();
assert_eq!(holes, Vec::new(), "Table A5-5 leaves no hole");
let mut decoded = 0usize;
for hw1 in FIRST..=LAST {
for addr in [ALIGNED, UNALIGNED] {
let insn = decode(hw1, 0, addr).expect("the group is fully allocated");
decoded += 1;
assert_eq!(insn.width, Width::Narrow, "{hw1:#06x}");
assert_eq!(insn.len(), 2, "{hw1:#06x}");
assert_eq!(insn.addr, addr, "{hw1:#06x}");
assert!(insn.cond.is_none(), "{hw1:#06x} carries no condition");
assert!(!insn.sets_flags, "{hw1:#06x} must not print an S suffix");
assert!(!insn.explicit_width, "{hw1:#06x}");
for op in insn.operands.as_slice() {
if let Operand::Mem(m) = op {
assert_eq!(m.mode, AddrMode::Offset, "{hw1:#06x}");
assert!(m.add, "{hw1:#06x}");
assert_eq!(m.align, 0, "{hw1:#06x}");
if matches!(insn.mnemonic, "ldrsb" | "ldrsh") {
assert!(m.index.is_some(), "{hw1:#06x} signed 16-bit immediate load");
}
}
}
assert_eq!(
encode(&insn),
Some(hw1),
"round-trip of {hw1:#06x} at {addr:#x}"
);
}
assert_eq!(
decode(hw1, 0, ALIGNED).unwrap().branch_target(),
decode(hw1, 0, UNALIGNED).unwrap().branch_target(),
"Align(PC,4) of {hw1:#06x}"
);
}
assert_eq!(decoded, 2 * 0x6800);
}
#[test]
fn outside_the_group_is_not_ours() {
assert!(decode(0x47FF, 0, 0).is_none());
assert!(decode(0xB000, 0, 0).is_none());
}
#[test]
fn register_offset_row_prints_as_rt_rn_rm() {
let hw = |opb: u16| 0x5000 | (opb << 9) | (2 << 6) | (1 << 3);
assert_eq!(ual(hw(0b000), 0), "str r0, [r1, r2]");
assert_eq!(ual(hw(0b001), 0), "strh r0, [r1, r2]");
assert_eq!(ual(hw(0b010), 0), "strb r0, [r1, r2]");
assert_eq!(ual(hw(0b011), 0), "ldrsb r0, [r1, r2]");
assert_eq!(ual(hw(0b100), 0), "ldr r0, [r1, r2]");
assert_eq!(ual(hw(0b101), 0), "ldrh r0, [r1, r2]");
assert_eq!(ual(hw(0b110), 0), "ldrb r0, [r1, r2]");
assert_eq!(ual(hw(0b111), 0), "ldrsh r0, [r1, r2]");
}
#[test]
fn immediate_rows_scale_by_access_size() {
let hw = |opa: u16, load: u16| (opa << 12) | (load << 11) | (1 << 6) | (1 << 3);
assert_eq!(ual(hw(0b0110, 0), 0), "str r0, [r1, #4]");
assert_eq!(ual(hw(0b0110, 1), 0), "ldr r0, [r1, #4]");
assert_eq!(ual(hw(0b0111, 0), 0), "strb r0, [r1, #1]");
assert_eq!(ual(hw(0b0111, 1), 0), "ldrb r0, [r1, #1]");
assert_eq!(ual(hw(0b1000, 0), 0), "strh r0, [r1, #2]");
assert_eq!(ual(hw(0b1000, 1), 0), "ldrh r0, [r1, #2]");
assert_eq!(ual(0x9001, 0), "str r0, [sp, #4]");
assert_eq!(ual(0x9801, 0), "ldr r0, [sp, #4]");
assert_eq!(ual(0x6008, 0), "str r0, [r1]");
assert_eq!(ual(0x9000, 0), "str r0, [sp]");
}
#[test]
fn immediate_rows_reach_the_top_of_their_range() {
let hw = |opa: u16, load: u16| (opa << 12) | (load << 11) | (0x1F << 6) | (1 << 3);
assert_eq!(ual(hw(0b0110, 0), 0), "str r0, [r1, #124]");
assert_eq!(ual(hw(0b0110, 1), 0), "ldr r0, [r1, #124]");
assert_eq!(ual(hw(0b0111, 0), 0), "strb r0, [r1, #31]");
assert_eq!(ual(hw(0b0111, 1), 0), "ldrb r0, [r1, #31]");
assert_eq!(ual(hw(0b1000, 0), 0), "strh r0, [r1, #62]");
assert_eq!(ual(hw(0b1000, 1), 0), "ldrh r0, [r1, #62]");
assert_eq!(ual(0x98FF, 0), "ldr r0, [sp, #1020]");
assert_eq!(ual(0x90FF, 0), "str r0, [sp, #1020]");
}
#[test]
fn literal_load_resolves_against_aligned_pc() {
let hw = 0x4B04;
assert_eq!(mem_of(hw, 0x102), "[pc, #16]");
assert_eq!(decode(hw, 0, 0x102).unwrap().branch_target(), Some(0x114));
assert_eq!(decode(hw, 0, 0x104).unwrap().branch_target(), Some(0x118));
assert_eq!(decode(hw, 0, 0x100).unwrap().branch_target(), Some(0x114));
let insn = decode(hw, 0, 0x102).unwrap();
assert_eq!(insn.mnemonic, "ldr");
assert_eq!(insn.encoding, "T1");
assert_eq!(insn.operands.len(), 3);
assert_eq!(insn.operands.get(0), Some(Operand::Reg(Reg(3))));
assert_eq!(insn.operands.get(2), Some(Operand::Target(0x114)));
assert_eq!(insn.to_string(), "ldr r3, [pc, #16], 0x114");
assert_eq!(mem_of(0x4B00, 0x102), "[pc]");
assert_eq!(
decode(0x4B00, 0, 0x102).unwrap().to_string(),
"ldr r3, [pc, #0], 0x104"
);
assert_eq!(
decode(0x4B00, 0, 0x102).unwrap().branch_target(),
Some(0x104)
);
assert_eq!(mem_of(0x4BFF, 0), "[pc, #1020]");
}
#[test]
fn adr_and_add_sp_print_their_ual_forms() {
assert_eq!(ual(0xA002, 0x1000), "adr r0, 0x100c");
assert_eq!(ual(0xA002, 0x1002), "adr r0, 0x100c");
assert_eq!(ual(0xA002, 0x1004), "adr r0, 0x1010");
assert_eq!(ual(0xA7FF, 0), "adr r7, 0x400");
assert_eq!(ual(0xA801, 0x1002), "add r0, sp, #4");
assert_eq!(ual(0xAFFF, 0), "add r7, sp, #0x3fc");
assert_eq!(ual(0xA800, 0), "add r0, sp, #0");
assert!(!decode(0xA801, 0, 0).unwrap().sets_flags);
}
#[test]
fn encode_rejects_what_this_group_cannot_hold() {
let base = decode(0x6048, 0, 0).unwrap(); assert_eq!(encode(&base), Some(0x6048));
let mut foreign = base;
foreign.mnemonic = "stm";
assert_eq!(encode(&foreign), None);
let mut wide = base;
wide.width = Width::Wide;
assert_eq!(encode(&wide), None);
let mut flags = base;
flags.sets_flags = true;
assert_eq!(encode(&flags), None);
let mut pre = base;
pre.operands = transfer(
Reg(0),
Mem {
base: Reg(1),
index: None,
offset: 4,
add: true,
align: 0,
mode: AddrMode::PreIndex,
},
);
assert_eq!(encode(&pre), None);
for (bad, add) in [(2u32, true), (128, true), (4, false), (0, false)] {
let mut off = base;
off.operands = transfer(
Reg(0),
Mem {
base: Reg(1),
index: None,
offset: bad,
add,
align: 0,
mode: AddrMode::Offset,
},
);
assert_eq!(encode(&off), None, "offset {bad} add {add}");
}
let mut high = base;
high.operands = transfer(
Reg(8),
Mem {
base: Reg(9),
index: None,
offset: 4,
add: true,
align: 0,
mode: AddrMode::Offset,
},
);
assert_eq!(encode(&high), None);
let mut shifted = decode(0x5888, 0, 0).unwrap(); assert_eq!(encode(&shifted), Some(0x5888));
shifted.operands = transfer(
Reg(0),
Mem {
base: Reg(1),
index: Some((
Reg(2),
Some(super::super::Shift {
kind: super::super::ShiftKind::Lsl,
amount: super::super::ShiftAmount::Imm(2),
}),
)),
offset: 0,
add: true,
align: 0,
mode: AddrMode::Offset,
},
);
assert_eq!(encode(&shifted), None);
let mut literal = decode(0x4B04, 0, 0x102).unwrap();
assert_eq!(encode(&literal), Some(0x4B04));
literal.operands = {
let mut ops = transfer(
Reg(3),
Mem {
base: Reg::PC,
index: None,
offset: 16,
add: true,
align: 0,
mode: AddrMode::Offset,
},
);
ops.push(Operand::Target(0x116)); ops
};
assert_eq!(encode(&literal), None);
let mut adr = decode(0xA002, 0, 0x1000).unwrap();
assert_eq!(encode(&adr), Some(0xA002));
adr.operands = {
let mut ops = Operands::new();
ops.push(Operand::Reg(Reg(0)));
ops.push(Operand::Target(0x0FFC));
ops
};
assert_eq!(encode(&adr), None);
for bad in [1024i64, 6, -4] {
let mut add = decode(0xA801, 0, 0).unwrap();
let mut ops = Operands::new();
ops.push(Operand::Reg(Reg(0)));
ops.push(Operand::Reg(Reg::SP));
ops.push(Operand::Imm(bad));
add.operands = ops;
assert_eq!(encode(&add), None, "add sp immediate {bad}");
}
let mut sp = decode(0x9801, 0, 0).unwrap();
assert_eq!(encode(&sp), Some(0x9801));
sp.encoding = "T1";
assert_eq!(encode(&sp), None);
}
#[test]
fn encode_declines_every_shape_that_is_not_this_groups() {
let mem = |base: Reg, offset, add, mode| Mem {
base,
index: None,
offset,
add,
align: 0,
mode,
};
let r0 = Operand::Reg(Reg(0));
let sp = Operand::Reg(Reg::SP);
let ops = |items: &[Operand]| items.iter().copied().collect::<Operands>();
let adr = decode(0xA002, 0, 0x1000).unwrap();
for (encoding, operands, why) in [
("T2", ops(&[r0, Operand::Target(0x1008)]), "T2 is 32-bit"),
("T1", ops(&[r0]), "a label is required"),
(
"T1",
ops(&[r0, Operand::Target(0x1008), Operand::Imm(0)]),
"two operands only",
),
("T1", ops(&[r0, Operand::Imm(8)]), "the label is resolved"),
(
"T1",
ops(&[Operand::Reg(Reg(8)), Operand::Target(0x1008)]),
"Rd is three bits",
),
(
"T1",
ops(&[r0, Operand::Target(0x1006)]),
"labels are word-aligned multiples of four",
),
] {
let bad = Insn {
encoding,
operands,
..adr
};
assert_eq!(encode(&bad), None, "`{bad}`: {why}");
}
let add_sp = decode(0xA801, 0, 0).unwrap();
for (operands, why) in [
(
ops(&[r0, Operand::Reg(Reg(1)), Operand::Imm(4)]),
"the second operand must be the SP",
),
(ops(&[r0, sp]), "three operands"),
(
ops(&[r0, sp, Operand::Reg(Reg(1))]),
"the third operand is an immediate",
),
(
ops(&[Operand::Reg(Reg(9)), sp, Operand::Imm(4)]),
"Rd is three bits",
),
] {
let bad = Insn { operands, ..add_sp };
assert_eq!(encode(&bad), None, "`{bad}`: {why}");
}
let mut renamed = add_sp;
renamed.encoding = "T3";
assert_eq!(encode(&renamed), None, "T3 is `add.w`, four bytes");
let mut trailing = add_sp;
trailing.operands = ops(&[r0, sp, Operand::Imm(4), Operand::Imm(0)]);
assert_eq!(encode(&trailing), None, "a fourth operand is not ours");
let reg_off = decode(0x5088, 0, 0).unwrap(); assert_eq!(encode(®_off), Some(0x5088));
let indexed = |base: Reg, index| {
ops(&[
r0,
Operand::Mem(Mem {
index: Some(index),
..mem(base, 0, true, AddrMode::Offset)
}),
])
};
for (mnemonic, encoding, operands, why) in [
(
"strex",
"T1",
indexed(Reg(1), (Reg(2), None)),
"not a row of Table A5-5",
),
(
"str",
"T2",
indexed(Reg(1), (Reg(2), None)),
"T2 is the wide row",
),
(
"str",
"T1",
indexed(Reg(9), (Reg(2), None)),
"Rn is three bits",
),
(
"str",
"T1",
indexed(Reg(1), (Reg(9), None)),
"Rm is three bits",
),
(
"str",
"T1",
indexed(
Reg(1),
(
Reg(2),
Some(Shift {
kind: ShiftKind::Lsl,
amount: ShiftAmount::Imm(2),
}),
),
),
"only the wide forms scale an index",
),
] {
let bad = Insn {
mnemonic,
encoding,
operands,
..reg_off
};
assert_eq!(encode(&bad), None, "`{bad}`: {why}");
}
let indexed_mem = |offset, add| {
ops(&[
r0,
Operand::Mem(Mem {
index: Some((Reg(2), None)),
..mem(Reg(1), offset, add, AddrMode::Offset)
}),
])
};
for (operands, why) in [
(
indexed_mem(4, true),
"no field holds a displacement beside Rm",
),
(
indexed_mem(0, false),
"no U bit: a register index is always added",
),
] {
let bad = Insn {
operands,
..reg_off
};
assert_eq!(encode(&bad), None, "`{bad}`: {why}");
}
let literal = decode(0x4B01, 0, 0x1000).unwrap();
assert_eq!(encode(&literal), Some(0x4B01));
let pc_mem = |offset| Operand::Mem(mem(Reg::PC, offset, true, AddrMode::Offset));
for (mnemonic, encoding, operands, why) in [
(
"str",
"T1",
ops(&[r0, pc_mem(4), Operand::Target(0x1008)]),
"there is no pc-relative store",
),
(
"ldr",
"T2",
ops(&[r0, pc_mem(4), Operand::Target(0x1008)]),
"T2 is the SP-relative row",
),
(
"ldr",
"T1",
ops(&[r0, pc_mem(4)]),
"the resolved address is part of the form",
),
(
"ldr",
"T1",
ops(&[r0, pc_mem(4), Operand::Imm(0x1008)]),
"the third operand is a resolved target",
),
(
"ldr",
"T1",
ops(&[r0, pc_mem(6), Operand::Target(0x100A)]),
"imm8:'00' is a multiple of four",
),
(
"ldr",
"T1",
ops(&[r0, pc_mem(1024), Operand::Target(0x1404)]),
"imm8:'00' reaches 1020",
),
] {
let bad = Insn {
mnemonic,
encoding,
operands,
..literal
};
assert_eq!(encode(&bad), None, "`{bad}`: {why}");
}
let sp_rel = decode(0x9801, 0, 0).unwrap();
for (mnemonic, offset, why) in [
("ldrb", 4u32, "no SP-relative byte load"),
("strh", 4, "no SP-relative halfword store"),
("ldr", 2, "imm8:'00' is a multiple of four"),
("ldr", 1024, "imm8:'00' reaches 1020"),
] {
let bad = Insn {
mnemonic,
operands: ops(&[
r0,
Operand::Mem(mem(Reg::SP, offset, true, AddrMode::Offset)),
]),
..sp_rel
};
assert_eq!(encode(&bad), None, "`{bad}`: {why}");
}
let imm_off = decode(0x6048, 0, 0).unwrap(); for (encoding, operands, why) in [
(
"T1",
ops(&[r0, Operand::Mem(mem(Reg(9), 4, true, AddrMode::Offset))]),
"Rn is three bits",
),
(
"T2",
ops(&[r0, Operand::Mem(mem(Reg(1), 4, true, AddrMode::Offset))]),
"T2 is the SP-relative row",
),
(
"T1",
ops(&[
r0,
Operand::Mem(mem(Reg(1), 4, true, AddrMode::Offset)),
Operand::Imm(0),
]),
"two operands only",
),
] {
let bad = Insn {
encoding,
operands,
..imm_off
};
assert_eq!(encode(&bad), None, "`{bad}`: {why}");
}
}
#[test]
fn a_condition_from_an_it_block_does_not_change_the_halfword() {
let mut insn = decode(0x6848, 0, 0).unwrap(); insn.cond = Some(crate::Cond::Eq);
assert_eq!(insn.to_string(), "ldreq r0, [r1, #4]");
assert_eq!(encode(&insn), Some(0x6848));
}
}