use super::{AddrMode, FpReg, Insn, Mem, Operand, Operands, Reg, Width};
fn bit(x: u16, n: u32) -> u16 {
(x >> n) & 1
}
fn bits(x: u16, hi: u32, lo: u32) -> u16 {
(x >> lo) & ((1u16 << (hi - lo + 1)) - 1)
}
fn literal_base(addr: u32) -> u32 {
addr.wrapping_add(4) & !3
}
fn sreg(v: u16, x: u16) -> FpReg {
FpReg::S((((v << 1) | x) & 0x1F) as u8)
}
fn dreg(v: u16, x: u16) -> FpReg {
FpReg::D((((x << 4) | v) & 0x1F) as u8)
}
fn freg(v: u16, x: u16, dbl: bool) -> FpReg {
if dbl {
dreg(v, x)
} else {
sreg(v, x)
}
}
fn split(r: FpReg, dbl: bool) -> Option<(u16, u16)> {
match (r, dbl) {
(FpReg::S(n), false) if n < 32 => Some(((n >> 1) as u16, (n & 1) as u16)),
(FpReg::D(n), true) if n < 32 => Some(((n & 0xF) as u16, (n >> 4) as u16)),
_ => None,
}
}
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,
}
}
fn ops(list: &[Operand]) -> Operands {
let mut o = Operands::new();
for item in list {
o.push(*item);
}
o
}
macro_rules! fp_range_row {
($letter:literal, $first:literal, [$($last:literal),* $(,)?]) => {
[$(concat!("{", $letter, $first, "-", $letter, $last, "}")),*]
};
}
macro_rules! fp_range_table {
($letter:literal, [$($first:literal),* $(,)?], $lasts:tt) => {
[$(fp_range_row!($letter, $first, $lasts)),*]
};
}
const S_RANGES: [[&str; 32]; 32] = fp_range_table!(
"s",
[
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31
],
[
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31
]
);
const D_RANGES: [[&str; 32]; 32] = fp_range_table!(
"d",
[
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31
],
[
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31
]
);
macro_rules! fp_single_table {
($letter:literal, [$($n:literal),* $(,)?]) => {
[$(concat!("{", $letter, $n, "}")),*]
};
}
const S_SINGLE: [&str; 32] = fp_single_table!(
"s",
[
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31
]
);
const D_SINGLE: [&str; 32] = fp_single_table!(
"d",
[
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31
]
);
const WRITEBACK: [&str; 16] = [
"r0!", "r1!", "r2!", "r3!", "r4!", "r5!", "r6!", "r7!", "r8!", "r9!", "r10!", "r11!", "r12!",
"sp!", "lr!", "pc!",
];
macro_rules! braced {
($($n:literal),* $(,)?) => { [$(concat!("{", $n, "}")),*] };
}
const OPTIONS: [&str; 256] = braced![
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173,
174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192,
193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211,
212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230,
231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249,
250, 251, 252, 253, 254, 255
];
const LDC_STC: [&str; 8] = [
"stc", "stc2", "stcl", "stc2l", "ldc", "ldc2", "ldcl", "ldc2l",
];
const CDP: [&str; 2] = ["cdp", "cdp2"];
const MCR_MRC: [&str; 4] = ["mcr", "mcr2", "mrc", "mrc2"];
const MCRR_MRRC: [&str; 4] = ["mcrr", "mcrr2", "mrrc", "mrrc2"];
const FPSCR_REG: u16 = 0b0001;
fn writable_sysreg(reg: u16) -> bool {
matches!(reg, 0b0000 | FPSCR_REG | 0b1000)
}
const FP_SYSREGS: [Option<&str>; 16] = [
Some("fpsid"), Some("fpscr"), None, None, None, Some("mvfr2"), Some("mvfr1"), Some("mvfr0"), Some("fpexc"), None, None, None, None, None, None, None, ];
struct Dp3 {
names: (&'static str, &'static str),
t: u16,
hi: u16,
lo: u16,
op: u16,
enc: &'static str,
}
const DP3: [Dp3; 15] = [
Dp3 {
names: ("vmla.f32", "vmla.f64"),
t: 0,
hi: 0,
lo: 0b00,
op: 0,
enc: "T1",
},
Dp3 {
names: ("vmls.f32", "vmls.f64"),
t: 0,
hi: 0,
lo: 0b00,
op: 1,
enc: "T1",
},
Dp3 {
names: ("vnmls.f32", "vnmls.f64"),
t: 0,
hi: 0,
lo: 0b01,
op: 0,
enc: "T1",
},
Dp3 {
names: ("vnmla.f32", "vnmla.f64"),
t: 0,
hi: 0,
lo: 0b01,
op: 1,
enc: "T1",
},
Dp3 {
names: ("vmul.f32", "vmul.f64"),
t: 0,
hi: 0,
lo: 0b10,
op: 0,
enc: "T1",
},
Dp3 {
names: ("vnmul.f32", "vnmul.f64"),
t: 0,
hi: 0,
lo: 0b10,
op: 1,
enc: "T2",
},
Dp3 {
names: ("vadd.f32", "vadd.f64"),
t: 0,
hi: 0,
lo: 0b11,
op: 0,
enc: "T1",
},
Dp3 {
names: ("vsub.f32", "vsub.f64"),
t: 0,
hi: 0,
lo: 0b11,
op: 1,
enc: "T1",
},
Dp3 {
names: ("vdiv.f32", "vdiv.f64"),
t: 0,
hi: 1,
lo: 0b00,
op: 0,
enc: "T1",
},
Dp3 {
names: ("vfnms.f32", "vfnms.f64"),
t: 0,
hi: 1,
lo: 0b01,
op: 0,
enc: "T1",
},
Dp3 {
names: ("vfnma.f32", "vfnma.f64"),
t: 0,
hi: 1,
lo: 0b01,
op: 1,
enc: "T1",
},
Dp3 {
names: ("vfma.f32", "vfma.f64"),
t: 0,
hi: 1,
lo: 0b10,
op: 0,
enc: "T1",
},
Dp3 {
names: ("vfms.f32", "vfms.f64"),
t: 0,
hi: 1,
lo: 0b10,
op: 1,
enc: "T1",
},
Dp3 {
names: ("vmaxnm.f32", "vmaxnm.f64"),
t: 1,
hi: 1,
lo: 0b00,
op: 0,
enc: "T1",
},
Dp3 {
names: ("vminnm.f32", "vminnm.f64"),
t: 1,
hi: 1,
lo: 0b00,
op: 1,
enc: "T1",
},
];
const VSEL: [(&str, &str); 4] = [
("vseleq.f32", "vseleq.f64"),
("vselvs.f32", "vselvs.f64"),
("vselge.f32", "vselge.f64"),
("vselgt.f32", "vselgt.f64"),
];
struct Dp2 {
names: (&'static str, &'static str),
t: u16,
opc2: u16,
opc3: u16,
}
const DP2: [Dp2; 11] = [
Dp2 {
names: ("vmov.f32", "vmov.f64"),
t: 0,
opc2: 0b0000,
opc3: 0b01,
}, Dp2 {
names: ("vabs.f32", "vabs.f64"),
t: 0,
opc2: 0b0000,
opc3: 0b11,
}, Dp2 {
names: ("vneg.f32", "vneg.f64"),
t: 0,
opc2: 0b0001,
opc3: 0b01,
}, Dp2 {
names: ("vsqrt.f32", "vsqrt.f64"),
t: 0,
opc2: 0b0001,
opc3: 0b11,
}, Dp2 {
names: ("vrintr.f32", "vrintr.f64"),
t: 0,
opc2: 0b0110,
opc3: 0b01,
}, Dp2 {
names: ("vrintz.f32", "vrintz.f64"),
t: 0,
opc2: 0b0110,
opc3: 0b11,
}, Dp2 {
names: ("vrintx.f32", "vrintx.f64"),
t: 0,
opc2: 0b0111,
opc3: 0b01,
}, Dp2 {
names: ("vrinta.f32", "vrinta.f64"),
t: 1,
opc2: 0b1000,
opc3: 0b01,
},
Dp2 {
names: ("vrintn.f32", "vrintn.f64"),
t: 1,
opc2: 0b1001,
opc3: 0b01,
},
Dp2 {
names: ("vrintp.f32", "vrintp.f64"),
t: 1,
opc2: 0b1010,
opc3: 0b01,
},
Dp2 {
names: ("vrintm.f32", "vrintm.f64"),
t: 1,
opc2: 0b1011,
opc3: 0b01,
},
];
const VCMP: [(&str, &str); 2] = [("vcmp.f32", "vcmp.f64"), ("vcmpe.f32", "vcmpe.f64")];
const CVT_HALF: [[[&str; 2]; 2]; 2] = [
[
["vcvtb.f32.f16", "vcvtb.f16.f32"],
["vcvtb.f64.f16", "vcvtb.f16.f64"],
],
[
["vcvtt.f32.f16", "vcvtt.f16.f32"],
["vcvtt.f64.f16", "vcvtt.f16.f64"],
],
];
const CVT_FROM_INT: [[&str; 2]; 2] = [
["vcvt.f32.u32", "vcvt.f32.s32"],
["vcvt.f64.u32", "vcvt.f64.s32"],
];
const CVT_TO_INT: [[[&str; 2]; 2]; 2] = [
[
["vcvtr.u32.f32", "vcvtr.u32.f64"],
["vcvtr.s32.f32", "vcvtr.s32.f64"],
],
[
["vcvt.u32.f32", "vcvt.u32.f64"],
["vcvt.s32.f32", "vcvt.s32.f64"],
],
];
const CVT_DP_SP: [&str; 2] = ["vcvt.f64.f32", "vcvt.f32.f64"];
const CVT_FIXED: [[[[&str; 2]; 2]; 2]; 2] = [
[
[
["vcvt.f32.s16", "vcvt.f32.u16"],
["vcvt.f32.s32", "vcvt.f32.u32"],
],
[
["vcvt.f64.s16", "vcvt.f64.u16"],
["vcvt.f64.s32", "vcvt.f64.u32"],
],
],
[
[
["vcvt.s16.f32", "vcvt.u16.f32"],
["vcvt.s32.f32", "vcvt.u32.f32"],
],
[
["vcvt.s16.f64", "vcvt.u16.f64"],
["vcvt.s32.f64", "vcvt.u32.f64"],
],
],
];
const CVT_RM: [[[&str; 2]; 2]; 4] = [
[
["vcvta.u32.f32", "vcvta.u32.f64"],
["vcvta.s32.f32", "vcvta.s32.f64"],
],
[
["vcvtn.u32.f32", "vcvtn.u32.f64"],
["vcvtn.s32.f32", "vcvtn.s32.f64"],
],
[
["vcvtp.u32.f32", "vcvtp.u32.f64"],
["vcvtp.s32.f32", "vcvtp.s32.f64"],
],
[
["vcvtm.u32.f32", "vcvtm.u32.f64"],
["vcvtm.s32.f32", "vcvtm.s32.f64"],
],
];
const VLDM_VSTM: [[&str; 2]; 2] = [["vstmia", "vstmdb"], ["vldmia", "vldmdb"]];
fn vfp_expand_imm(imm8: u16, dbl: bool) -> f64 {
let imm8 = imm8 & 0xFF;
let sign = (imm8 >> 7) & 1;
let b6 = (imm8 >> 6) & 1;
let low = (imm8 >> 4) & 0b11;
let frac = imm8 & 0xF;
if dbl {
let exp =
(u64::from(b6 ^ 1) << 10) | (if b6 == 1 { 0xFF << 2 } else { 0 }) | u64::from(low);
f64::from_bits((u64::from(sign) << 63) | (exp << 52) | (u64::from(frac) << 48))
} else {
let exp = (u32::from(b6 ^ 1) << 7) | (if b6 == 1 { 0x1F << 2 } else { 0 }) | u32::from(low);
f64::from(f32::from_bits(
(u32::from(sign) << 31) | (exp << 23) | (u32::from(frac) << 19),
))
}
}
fn vfp_compress_imm(value: f64, dbl: bool) -> Option<u16> {
(0..256u16).find(|&imm8| vfp_expand_imm(imm8, dbl).to_bits() == value.to_bits())
}
pub(crate) fn decode(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw1 & 0xEC00 != 0xEC00 {
return None;
}
let op1 = bits(hw1, 9, 4);
let coproc = bits(hw2, 11, 8);
let fp = coproc & 0b1110 == 0b1010;
let op = bit(hw2, 4);
if op1 & 0b11_0000 == 0b11_0000 || op1 & 0b11_1110 == 0 {
return None;
}
match op1 {
0b00_0100 | 0b00_0101 => {
if fp {
fp_two_core(hw1, hw2, addr)
} else {
mcrr(hw1, hw2, addr)
}
}
o if o & 0b10_0000 == 0 => {
if fp {
fp_load_store(hw1, hw2, addr)
} else {
ldc_stc(hw1, hw2, addr)
}
}
_ if op == 0 => {
if fp {
fp_data_processing(hw1, hw2, addr)
} else {
cdp(hw1, hw2, addr)
}
}
_ => {
if fp {
fp_transfer(hw1, hw2, addr)
} else {
mcr(hw1, hw2, addr)
}
}
}
}
fn enc_of(hw1: u16) -> &'static str {
if bit(hw1, 12) == 1 {
"T2"
} else {
"T1"
}
}
fn ldc_stc(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let (p, u, d, w, l) = (
bit(hw1, 8),
bit(hw1, 7),
bit(hw1, 6),
bit(hw1, 5),
bit(hw1, 4),
);
let rn = Reg(bits(hw1, 3, 0) as u8);
let imm8 = u32::from(hw2 & 0xFF);
let head = [
Operand::Coproc(bits(hw2, 11, 8) as u8),
Operand::CoprocReg(bits(hw2, 15, 12) as u8),
];
let mnemonic = LDC_STC[((l << 2) | (d << 1) | bit(hw1, 12)) as usize];
let mode = match (p, w) {
(1, 0) => AddrMode::Offset,
(1, 1) => AddrMode::PreIndex,
(0, 1) => AddrMode::PostIndex,
_ => {
let mem = Mem {
base: rn,
index: None,
offset: 0,
add: true,
align: 0,
mode: AddrMode::Offset,
};
let option = Operand::Option(OPTIONS[imm8 as usize]);
let operands = ops(&[head[0], head[1], Operand::Mem(mem), option]);
return Some(wide(mnemonic, enc_of(hw1), addr, operands));
}
};
let mem = Mem {
base: rn,
index: None,
offset: imm8 * 4,
add: u == 1,
align: 0,
mode,
};
let mut operands = ops(&[head[0], head[1], Operand::Mem(mem)]);
if l == 1 && rn.num() == 15 && mode == AddrMode::Offset {
operands.push(Operand::Target(
literal_base(addr).wrapping_add(mem.displacement() as u32),
));
}
Some(wide(mnemonic, enc_of(hw1), addr, operands))
}
fn cdp(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let operands = ops(&[
Operand::Coproc(bits(hw2, 11, 8) as u8),
Operand::Imm(i64::from(bits(hw1, 7, 4))),
Operand::CoprocReg(bits(hw2, 15, 12) as u8),
Operand::CoprocReg(bits(hw1, 3, 0) as u8),
Operand::CoprocReg(bits(hw2, 3, 0) as u8),
Operand::Imm(i64::from(bits(hw2, 7, 5))),
]);
Some(wide(
CDP[bit(hw1, 12) as usize],
enc_of(hw1),
addr,
operands,
))
}
fn mcr(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let l = bit(hw1, 4);
let rt = bits(hw2, 15, 12) as u8;
let dest = if l == 1 && rt == 15 {
Operand::SpecialReg("apsr_nzcv")
} else {
Operand::Reg(Reg(rt))
};
let operands = ops(&[
Operand::Coproc(bits(hw2, 11, 8) as u8),
Operand::Imm(i64::from(bits(hw1, 7, 5))),
dest,
Operand::CoprocReg(bits(hw1, 3, 0) as u8),
Operand::CoprocReg(bits(hw2, 3, 0) as u8),
Operand::Imm(i64::from(bits(hw2, 7, 5))),
]);
let mnemonic = MCR_MRC[((l << 1) | bit(hw1, 12)) as usize];
Some(wide(mnemonic, enc_of(hw1), addr, operands))
}
fn mcrr(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let operands = ops(&[
Operand::Coproc(bits(hw2, 11, 8) as u8),
Operand::Imm(i64::from(bits(hw2, 7, 4))),
Operand::Reg(Reg(bits(hw2, 15, 12) as u8)),
Operand::Reg(Reg(bits(hw1, 3, 0) as u8)),
Operand::CoprocReg(bits(hw2, 3, 0) as u8),
]);
let mnemonic = MCRR_MRRC[((bit(hw1, 4) << 1) | bit(hw1, 12)) as usize];
Some(wide(mnemonic, enc_of(hw1), addr, operands))
}
fn fp_list(first: u16, regs: u16, dbl: bool) -> Option<Operand> {
if regs == 0 || first + regs > 32 || (dbl && regs > 16) {
return None;
}
if regs == 1 {
let single = if dbl { D_SINGLE } else { S_SINGLE };
return Some(Operand::Text(single[first as usize]));
}
let table = if dbl { &D_RANGES } else { &S_RANGES };
Some(Operand::Text(
table[first as usize][(first + regs - 1) as usize],
))
}
fn fp_load_store(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if bit(hw1, 12) == 1 {
return None;
}
let (p, u, d, w, l) = (
bit(hw1, 8),
bit(hw1, 7),
bit(hw1, 6),
bit(hw1, 5),
bit(hw1, 4),
);
let rn = Reg(bits(hw1, 3, 0) as u8);
let vd = bits(hw2, 15, 12);
let dbl = bit(hw2, 8) == 1;
let imm8 = hw2 & 0xFF;
let enc = if dbl { "T1" } else { "T2" };
if p == 1 && w == 0 {
let mem = Mem {
base: rn,
index: None,
offset: u32::from(imm8) * 4,
add: u == 1,
align: 0,
mode: AddrMode::Offset,
};
let mut operands = ops(&[Operand::FpReg(freg(vd, d, dbl)), Operand::Mem(mem)]);
if l == 1 && rn.num() == 15 {
operands.push(Operand::Target(
literal_base(addr).wrapping_add(mem.displacement() as u32),
));
}
let mnemonic = if l == 1 { "vldr" } else { "vstr" };
return Some(wide(mnemonic, enc, addr, operands));
}
if dbl && imm8 % 2 != 0 {
return None;
}
let regs = if dbl { imm8 / 2 } else { imm8 };
let first = if dbl { (d << 4) | vd } else { (vd << 1) | d };
let list = fp_list(first, regs, dbl)?;
let base = |wb: bool| {
if wb {
Operand::Text(WRITEBACK[rn.num() as usize])
} else {
Operand::Reg(rn)
}
};
match (p, u, w) {
(0, 1, _) => {
if w == 1 && l == 1 && rn.num() == 13 {
return Some(wide("vpop", enc, addr, ops(&[list])));
}
let mnemonic = VLDM_VSTM[l as usize][0];
Some(wide(mnemonic, enc, addr, ops(&[base(w == 1), list])))
}
(1, 0, 1) => {
if l == 0 && rn.num() == 13 {
return Some(wide("vpush", enc, addr, ops(&[list])));
}
let mnemonic = VLDM_VSTM[l as usize][1];
Some(wide(mnemonic, enc, addr, ops(&[base(true), list])))
}
_ => None,
}
}
#[derive(Clone, Copy)]
struct Fp {
t: u16,
hi: u16,
d: u16,
lo: u16,
vn: u16,
vd: u16,
dbl: bool,
opc3: u16,
n: u16,
m: u16,
vm: u16,
}
impl Fp {
fn new(hw1: u16, hw2: u16) -> Fp {
Fp {
t: bit(hw1, 12),
hi: bit(hw1, 7),
d: bit(hw1, 6),
lo: bits(hw1, 5, 4),
vn: bits(hw1, 3, 0),
vd: bits(hw2, 15, 12),
dbl: bit(hw2, 8) == 1,
opc3: bits(hw2, 7, 6),
n: bit(hw2, 7),
m: bit(hw2, 5),
vm: bits(hw2, 3, 0),
}
}
fn opc2(self) -> u16 {
self.vn
}
fn rd(self, dbl: bool) -> Operand {
Operand::FpReg(freg(self.vd, self.d, dbl))
}
fn rn(self, dbl: bool) -> Operand {
Operand::FpReg(freg(self.vn, self.n, dbl))
}
fn rm(self, dbl: bool) -> Operand {
Operand::FpReg(freg(self.vm, self.m, dbl))
}
}
fn pick(names: (&'static str, &'static str), dbl: bool) -> &'static str {
if dbl {
names.1
} else {
names.0
}
}
fn fp_data_processing(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let f = Fp::new(hw1, hw2);
let dbl = f.dbl;
if f.t == 1 && f.hi == 0 {
if f.opc3 & 1 != 0 {
return None;
}
let operands = ops(&[f.rd(dbl), f.rn(dbl), f.rm(dbl)]);
return Some(wide(pick(VSEL[f.lo as usize], dbl), "T1", addr, operands));
}
if !(f.hi == 1 && f.lo == 0b11) {
for row in DP3.iter() {
if row.t == f.t && row.hi == f.hi && row.lo == f.lo && row.op == f.opc3 & 1 {
let operands = ops(&[f.rd(dbl), f.rn(dbl), f.rm(dbl)]);
return Some(wide(pick(row.names, dbl), row.enc, addr, operands));
}
}
return None;
}
if f.t == 1 {
return fpv5_round_or_convert(f, addr);
}
if f.opc3 & 1 == 0 {
if f.opc3 != 0 || f.m != 0 {
return None;
}
let value = vfp_expand_imm((f.opc2() << 4) | f.vm, dbl);
let operands = ops(&[f.rd(dbl), Operand::FpImm(value)]);
return Some(wide(
pick(("vmov.f32", "vmov.f64"), dbl),
"T1",
addr,
operands,
));
}
for row in DP2.iter() {
if row.t == 0 && row.opc2 == f.opc2() && row.opc3 == f.opc3 {
let operands = ops(&[f.rd(dbl), f.rm(dbl)]);
return Some(wide(pick(row.names, dbl), "T1", addr, operands));
}
}
fp_convert(f, addr)
}
fn fpv5_round_or_convert(f: Fp, addr: u32) -> Option<Insn> {
let rm = (f.opc2() & 0b11) as usize;
match f.opc2() >> 2 {
0b10 => {
for row in DP2.iter() {
if row.t == 1 && row.opc2 == f.opc2() && row.opc3 == f.opc3 {
let operands = ops(&[f.rd(f.dbl), f.rm(f.dbl)]);
return Some(wide(pick(row.names, f.dbl), "T1", addr, operands));
}
}
None
}
0b11 if f.opc3 & 1 == 1 => {
let name = CVT_RM[rm][f.n as usize][f.dbl as usize];
let operands = ops(&[f.rd(false), f.rm(f.dbl)]);
Some(wide(name, "T1", addr, operands))
}
_ => None,
}
}
fn fp_convert(f: Fp, addr: u32) -> Option<Insn> {
let dbl = f.dbl;
match f.opc2() {
0b0010 | 0b0011 => {
let op = f.opc2() & 1;
let name = CVT_HALF[f.n as usize][dbl as usize][op as usize];
let operands = ops(&[f.rd(dbl && op == 0), f.rm(dbl && op == 1)]);
Some(wide(name, "T1", addr, operands))
}
0b0100 | 0b0101 => {
let name = pick(VCMP[f.n as usize], dbl);
if f.opc2() & 1 == 1 {
if f.vm != 0 || f.m != 0 {
return None;
}
let operands = ops(&[f.rd(dbl), Operand::Text("#0.0")]);
Some(wide(name, "T2", addr, operands))
} else {
let operands = ops(&[f.rd(dbl), f.rm(dbl)]);
Some(wide(name, "T1", addr, operands))
}
}
0b0111 => {
let operands = ops(&[f.rd(!dbl), f.rm(dbl)]);
Some(wide(CVT_DP_SP[dbl as usize], "T1", addr, operands))
}
0b1000 => {
let name = CVT_FROM_INT[dbl as usize][f.n as usize];
let operands = ops(&[f.rd(dbl), f.rm(false)]);
Some(wide(name, "T1", addr, operands))
}
0b1100 | 0b1101 => {
let name = CVT_TO_INT[f.n as usize][(f.opc2() & 1) as usize][dbl as usize];
let operands = ops(&[f.rd(false), f.rm(dbl)]);
Some(wide(name, "T1", addr, operands))
}
0b1010 | 0b1011 | 0b1110 | 0b1111 => {
let to_fixed = (f.opc2() >> 2) & 1;
let u = f.opc2() & 1;
let sx = f.n;
let size = if sx == 1 { 32 } else { 16 };
let frac = size - i64::from((f.vm << 1) | f.m);
if frac < 0 {
return None;
}
let name = CVT_FIXED[to_fixed as usize][dbl as usize][sx as usize][u as usize];
let operands = ops(&[f.rd(dbl), f.rd(dbl), Operand::Imm(frac)]);
Some(wide(name, "T1", addr, operands))
}
_ => None,
}
}
fn fp_transfer(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if bit(hw1, 12) == 1 || bits(hw2, 3, 0) != 0 {
return None;
}
let a = bits(hw1, 7, 5);
let l = bit(hw1, 4);
let vn = bits(hw1, 3, 0);
let rt = Reg(bits(hw2, 15, 12) as u8);
let c = bit(hw2, 8);
let b = bits(hw2, 6, 5);
let n = bit(hw2, 7);
match (c, a) {
(0, 0b000) if b == 0 => {
let s = Operand::FpReg(sreg(vn, n));
let r = Operand::Reg(rt);
let operands = if l == 1 { ops(&[r, s]) } else { ops(&[s, r]) };
Some(wide("vmov", "T1", addr, operands))
}
(0, 0b111) if n == 0 && b == 0 => {
let spec = Operand::SpecialReg(FP_SYSREGS[vn as usize]?);
if l == 1 {
if rt.num() == 15 && vn != FPSCR_REG {
return None;
}
let dest = if rt.num() == 15 {
Operand::SpecialReg("apsr_nzcv")
} else {
Operand::Reg(rt)
};
Some(wide("vmrs", "T1", addr, ops(&[dest, spec])))
} else {
if !writable_sysreg(vn) {
return None;
}
Some(wide("vmsr", "T1", addr, ops(&[spec, Operand::Reg(rt)])))
}
}
(1, _) if a & 0b110 == 0 && b == 0 => {
let scalar = Operand::FpScalar(dreg(vn, n), a as u8 & 1);
let r = Operand::Reg(rt);
let operands = if l == 1 {
ops(&[r, scalar])
} else {
ops(&[scalar, r])
};
Some(wide("vmov.32", "T1", addr, operands))
}
_ => None,
}
}
fn fp_two_core(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if bit(hw1, 12) == 1 || bits(hw2, 7, 6) != 0 || bit(hw2, 4) != 1 {
return None;
}
let l = bit(hw1, 4);
let rt2 = Operand::Reg(Reg(bits(hw1, 3, 0) as u8));
let rt = Operand::Reg(Reg(bits(hw2, 15, 12) as u8));
let vm = bits(hw2, 3, 0);
let m = bit(hw2, 5);
if bit(hw2, 8) == 1 {
let d = Operand::FpReg(dreg(vm, m));
let operands = if l == 1 {
ops(&[rt, rt2, d])
} else {
ops(&[d, rt, rt2])
};
Some(wide("vmov", "T1", addr, operands))
} else {
let first = (vm << 1) | m;
if first == 31 {
return None;
}
let s0 = Operand::FpReg(sreg(vm, m));
let s1 = Operand::FpReg(FpReg::S(first as u8 + 1));
let operands = if l == 1 {
ops(&[rt, rt2, s0, s1])
} else {
ops(&[s0, s1, rt, rt2])
};
Some(wide("vmov", "T1", addr, operands))
}
}
fn op_reg(insn: &Insn, i: usize) -> Option<Reg> {
match insn.operands.get(i) {
Some(Operand::Reg(r)) if r.num() < 16 => Some(r),
_ => None,
}
}
fn op_fp(insn: &Insn, i: usize) -> Option<FpReg> {
match insn.operands.get(i) {
Some(Operand::FpReg(r)) => Some(r),
_ => None,
}
}
fn op_imm(insn: &Insn, i: usize, max: i64) -> Option<u16> {
match insn.operands.get(i) {
Some(Operand::Imm(v)) if v >= 0 && v <= max => Some(v as u16),
_ => None,
}
}
fn op_coproc(insn: &Insn, i: usize) -> Option<u16> {
match insn.operands.get(i) {
Some(Operand::Coproc(n)) if n < 16 => Some(u16::from(n)),
_ => None,
}
}
fn op_creg(insn: &Insn, i: usize) -> Option<u16> {
match insn.operands.get(i) {
Some(Operand::CoprocReg(n)) if n < 16 => Some(u16::from(n)),
_ => None,
}
}
fn op_mem(insn: &Insn, i: usize) -> Option<Mem> {
match insn.operands.get(i) {
Some(Operand::Mem(m)) if m.index.is_none() && m.base.num() < 16 => Some(m),
_ => None,
}
}
fn split_any(r: FpReg) -> Option<(u16, u16, bool)> {
match r {
FpReg::S(n) if n < 32 => Some((u16::from(n >> 1), u16::from(n & 1), false)),
FpReg::D(n) if n < 32 => Some((u16::from(n & 0xF), u16::from(n >> 4), true)),
_ => None,
}
}
fn matches_pair(names: (&'static str, &'static str), mnemonic: &str) -> Option<bool> {
if mnemonic == names.0 {
Some(false)
} else if mnemonic == names.1 {
Some(true)
} else {
None
}
}
fn scaled_imm8(mem: &Mem) -> Option<(u16, u16)> {
if mem.offset % 4 != 0 || mem.offset / 4 > 0xFF {
return None;
}
Some((u16::from(mem.add), (mem.offset / 4) as u16))
}
#[derive(Default)]
struct Words {
t: u16,
hi: u16,
d: u16,
lo: u16,
vn: u16,
vd: u16,
sz: u16,
opc3: u16,
m: u16,
vm: u16,
}
impl Words {
fn pack(self) -> (u16, u16) {
let hw1 =
0xEE00 | (self.t << 12) | (self.hi << 7) | (self.d << 6) | (self.lo << 4) | self.vn;
let hw2 = (self.vd << 12)
| ((0b1010 | self.sz) << 8)
| (self.opc3 << 6)
| (self.m << 5)
| self.vm;
(hw1, hw2)
}
}
pub(crate) fn encode(insn: &Insn) -> Option<(u16, u16)> {
if insn.width != Width::Wide || insn.sets_flags || insn.explicit_width {
return None;
}
if let Some(idx) = MCR_MRC.iter().position(|m| *m == insn.mnemonic) {
return encode_mcr(insn, idx as u16);
}
if let Some(idx) = MCRR_MRRC.iter().position(|m| *m == insn.mnemonic) {
return encode_mcrr(insn, idx as u16);
}
if let Some(idx) = LDC_STC.iter().position(|m| *m == insn.mnemonic) {
return encode_ldc_stc(insn, idx as u16);
}
match insn.mnemonic {
"cdp" | "cdp2" => encode_cdp(insn),
"vldr" | "vstr" => encode_vldr_vstr(insn),
"vstmia" => encode_vldm_vstm(insn, VSTMIA),
"vldmia" => encode_vldm_vstm(insn, VLDMIA),
"vstmdb" => encode_vldm_vstm(insn, VSTMDB),
"vldmdb" => encode_vldm_vstm(insn, VLDMDB),
"vpush" => encode_vldm_vstm(insn, VPUSH),
"vpop" => encode_vldm_vstm(insn, VPOP),
"vmrs" | "vmsr" => encode_vmrs_vmsr(insn),
"vmov" => encode_vmov_core(insn),
"vmov.32" => encode_vmov_scalar(insn),
_ => encode_fp_data_processing(insn),
}
}
fn encode_cdp(insn: &Insn) -> Option<(u16, u16)> {
let t = u16::from(insn.mnemonic == "cdp2");
if insn.encoding != enc_name(t) || insn.operands.len() != 6 {
return None;
}
let coproc = op_coproc(insn, 0)?;
let opc1 = op_imm(insn, 1, 15)?;
let crd = op_creg(insn, 2)?;
let crn = op_creg(insn, 3)?;
let crm = op_creg(insn, 4)?;
let opc2 = op_imm(insn, 5, 7)?;
let hw1 = 0xEE00 | (t << 12) | (opc1 << 4) | crn;
let hw2 = (crd << 12) | (coproc << 8) | (opc2 << 5) | crm;
Some((hw1, hw2))
}
fn encode_mcr(insn: &Insn, idx: u16) -> Option<(u16, u16)> {
let (l, t) = (idx >> 1, idx & 1);
if insn.encoding != enc_name(t) || insn.operands.len() != 6 {
return None;
}
let coproc = op_coproc(insn, 0)?;
let opc1 = op_imm(insn, 1, 7)?;
let rt = match insn.operands.get(2) {
Some(Operand::Reg(r)) if r.num() < 16 => u16::from(r.num()),
Some(Operand::SpecialReg("apsr_nzcv")) if l == 1 => 15,
_ => return None,
};
let crn = op_creg(insn, 3)?;
let crm = op_creg(insn, 4)?;
let opc2 = op_imm(insn, 5, 7)?;
let hw1 = 0xEE00 | (t << 12) | (opc1 << 5) | (l << 4) | crn;
let hw2 = (rt << 12) | (coproc << 8) | (opc2 << 5) | (1 << 4) | crm;
Some((hw1, hw2))
}
fn encode_mcrr(insn: &Insn, idx: u16) -> Option<(u16, u16)> {
let (l, t) = (idx >> 1, idx & 1);
if insn.encoding != enc_name(t) || insn.operands.len() != 5 {
return None;
}
let coproc = op_coproc(insn, 0)?;
let opc1 = op_imm(insn, 1, 15)?;
let rt = u16::from(op_reg(insn, 2)?.num());
let rt2 = u16::from(op_reg(insn, 3)?.num());
let crm = op_creg(insn, 4)?;
let hw1 = 0xEC00 | (t << 12) | (1 << 6) | (l << 4) | rt2;
let hw2 = (rt << 12) | (coproc << 8) | (opc1 << 4) | crm;
Some((hw1, hw2))
}
fn enc_name(t: u16) -> &'static str {
if t == 1 {
"T2"
} else {
"T1"
}
}
fn encode_ldc_stc(insn: &Insn, idx: u16) -> Option<(u16, u16)> {
let (l, d, t) = ((idx >> 2) & 1, (idx >> 1) & 1, idx & 1);
if insn.encoding != enc_name(t) {
return None;
}
let coproc = op_coproc(insn, 0)?;
let crd = op_creg(insn, 1)?;
let mem = op_mem(insn, 2)?;
let rn = u16::from(mem.base.num());
let (p, u, w, imm8) = if let Some(Operand::Option(s)) = insn.operands.get(3) {
let option = OPTIONS.iter().position(|o| *o == s)? as u16;
if insn.operands.len() != 4 || mem.mode != AddrMode::Offset || mem.offset != 0 || !mem.add {
return None;
}
(0, 1, 0, option)
} else {
if !matches!(insn.operands.len(), 3 | 4) {
return None;
}
let (u, imm8) = scaled_imm8(&mem)?;
let (p, w) = match mem.mode {
AddrMode::Offset => (1, 0),
AddrMode::PreIndex => (1, 1),
AddrMode::PostIndex => (0, 1),
AddrMode::PostIncrement => return None,
};
let literal = l == 1 && rn == 15 && mem.mode == AddrMode::Offset;
match (literal, insn.operands.get(3)) {
(false, None) => {}
(true, Some(Operand::Target(target)))
if target == literal_base(insn.addr).wrapping_add(mem.displacement() as u32) => {}
_ => return None,
}
(p, u, w, imm8)
};
let hw1 = 0xEC00 | (t << 12) | (p << 8) | (u << 7) | (d << 6) | (w << 5) | (l << 4) | rn;
let hw2 = (crd << 12) | (coproc << 8) | imm8;
Some((hw1, hw2))
}
fn encode_vldr_vstr(insn: &Insn) -> Option<(u16, u16)> {
let l = u16::from(insn.mnemonic == "vldr");
let (vd, d, dbl) = split_any(op_fp(insn, 0)?)?;
if insn.encoding != if dbl { "T1" } else { "T2" } {
return None;
}
let mem = op_mem(insn, 1)?;
if mem.mode != AddrMode::Offset {
return None;
}
let (u, imm8) = scaled_imm8(&mem)?;
let rn = u16::from(mem.base.num());
let literal = l == 1 && rn == 15;
if insn.operands.len() != if literal { 3 } else { 2 } {
return None;
}
match (literal, insn.operands.get(2)) {
(false, None) => {}
(true, Some(Operand::Target(target)))
if target == literal_base(insn.addr).wrapping_add(mem.displacement() as u32) => {}
_ => return None,
}
let hw1 = 0xEC00 | (1 << 8) | (u << 7) | (d << 6) | (l << 4) | rn;
let hw2 = (vd << 12) | ((0b1010 | u16::from(dbl)) << 8) | imm8;
Some((hw1, hw2))
}
fn parse_base(op: Option<Operand>) -> Option<(u16, u16)> {
match op {
Some(Operand::Reg(r)) if r.num() < 16 => Some((u16::from(r.num()), 0)),
Some(Operand::Text(s)) => WRITEBACK
.iter()
.position(|w| *w == s)
.map(|i| (i as u16, 1)),
_ => None,
}
}
fn parse_list(op: Option<Operand>) -> Option<(u16, u16, bool)> {
match op {
Some(Operand::Text(s)) => {
for first in 0..32usize {
if S_SINGLE[first] == s {
return Some((first as u16, 1, false));
}
if D_SINGLE[first] == s {
return Some((first as u16, 1, true));
}
for last in first..32 {
let regs = (last - first + 1) as u16;
if S_RANGES[first][last] == s {
return Some((first as u16, regs, false));
}
if D_RANGES[first][last] == s {
return Some((first as u16, regs, true));
}
}
}
None
}
_ => None,
}
}
#[derive(Clone, Copy)]
struct Transfer {
p: u16,
u: u16,
l: u16,
stack: bool,
}
const VSTMIA: Transfer = Transfer {
p: 0,
u: 1,
l: 0,
stack: false,
};
const VLDMIA: Transfer = Transfer {
p: 0,
u: 1,
l: 1,
stack: false,
};
const VSTMDB: Transfer = Transfer {
p: 1,
u: 0,
l: 0,
stack: false,
};
const VLDMDB: Transfer = Transfer {
p: 1,
u: 0,
l: 1,
stack: false,
};
const VPUSH: Transfer = Transfer {
p: 1,
u: 0,
l: 0,
stack: true,
};
const VPOP: Transfer = Transfer {
p: 0,
u: 1,
l: 1,
stack: true,
};
fn encode_vldm_vstm(insn: &Insn, form: Transfer) -> Option<(u16, u16)> {
let Transfer { p, u, l, stack } = form;
let (rn, w, list) = if stack {
if insn.operands.len() != 1 {
return None;
}
(13, 1, insn.operands.get(0))
} else {
if insn.operands.len() != 2 {
return None;
}
let (rn, w) = parse_base(insn.operands.get(0))?;
if (p == 1 && w == 0) || (rn == 13 && w == 1 && p != l) {
return None;
}
(rn, w, insn.operands.get(1))
};
let (first, regs, dbl) = parse_list(list)?;
if insn.encoding != if dbl { "T1" } else { "T2" } {
return None;
}
if regs == 0 || first + regs > 32 || (dbl && regs > 16) {
return None;
}
let imm8 = if dbl { regs * 2 } else { regs };
let (vd, d) = if dbl {
(first & 0xF, first >> 4)
} else {
(first >> 1, first & 1)
};
let hw1 = 0xEC00 | (p << 8) | (u << 7) | (d << 6) | (w << 5) | (l << 4) | rn;
let hw2 = (vd << 12) | ((0b1010 | u16::from(dbl)) << 8) | imm8;
Some((hw1, hw2))
}
fn encode_vmrs_vmsr(insn: &Insn) -> Option<(u16, u16)> {
if insn.encoding != "T1" || insn.operands.len() != 2 {
return None;
}
let l = u16::from(insn.mnemonic == "vmrs");
let (spec, core) = if l == 1 {
(insn.operands.get(1), insn.operands.get(0))
} else {
(insn.operands.get(0), insn.operands.get(1))
};
let reg = match spec {
Some(Operand::SpecialReg(name)) => FP_SYSREGS
.iter()
.position(|r| *r == Some(name))
.map(|i| i as u16)?,
_ => return None,
};
let rt = match core {
Some(Operand::Reg(r)) if r.num() < 16 => u16::from(r.num()),
Some(Operand::SpecialReg("apsr_nzcv")) if l == 1 && reg == FPSCR_REG => 15,
_ => return None,
};
if l == 0 && !writable_sysreg(reg) {
return None;
}
let hw1 = 0xEE00 | (0b111 << 5) | (l << 4) | reg;
let hw2 = (rt << 12) | (0b1010 << 8) | (1 << 4);
Some((hw1, hw2))
}
fn encode_vmov_core(insn: &Insn) -> Option<(u16, u16)> {
if insn.encoding != "T1" {
return None;
}
match insn.operands.len() {
2 => {
let (op, s, rt) = match (insn.operands.get(0), insn.operands.get(1)) {
(Some(Operand::FpReg(s)), Some(Operand::Reg(r))) => (0, s, r),
(Some(Operand::Reg(r)), Some(Operand::FpReg(s))) => (1, s, r),
_ => return None,
};
let (vn, n) = split(s, false)?;
let hw1 = 0xEE00 | (op << 4) | vn;
let hw2 = (u16::from(rt.num()) << 12) | (0b1010 << 8) | (n << 7) | (1 << 4);
Some((hw1, hw2))
}
3 => {
let (op, dm, rt, rt2) = match (
insn.operands.get(0),
insn.operands.get(1),
insn.operands.get(2),
) {
(Some(Operand::FpReg(d)), Some(Operand::Reg(a)), Some(Operand::Reg(b))) => {
(0, d, a, b)
}
(Some(Operand::Reg(a)), Some(Operand::Reg(b)), Some(Operand::FpReg(d))) => {
(1, d, a, b)
}
_ => return None,
};
let (vm, m) = split(dm, true)?;
let hw1 = 0xEC00 | (1 << 6) | (op << 4) | u16::from(rt2.num());
let hw2 = (u16::from(rt.num()) << 12) | (0b1011 << 8) | (m << 5) | (1 << 4) | vm;
Some((hw1, hw2))
}
4 => {
let (op, sm, sm1, rt, rt2) = match (
insn.operands.get(0),
insn.operands.get(1),
insn.operands.get(2),
insn.operands.get(3),
) {
(
Some(Operand::FpReg(a)),
Some(Operand::FpReg(b)),
Some(Operand::Reg(t)),
Some(Operand::Reg(t2)),
) => (0, a, b, t, t2),
(
Some(Operand::Reg(t)),
Some(Operand::Reg(t2)),
Some(Operand::FpReg(a)),
Some(Operand::FpReg(b)),
) => (1, a, b, t, t2),
_ => return None,
};
let (vm, m) = split(sm, false)?;
let first = (vm << 1) | m;
if first == 31 || sm1 != FpReg::S(first as u8 + 1) {
return None;
}
let hw1 = 0xEC00 | (1 << 6) | (op << 4) | u16::from(rt2.num());
let hw2 = (u16::from(rt.num()) << 12) | (0b1010 << 8) | (m << 5) | (1 << 4) | vm;
Some((hw1, hw2))
}
_ => None,
}
}
fn encode_vmov_scalar(insn: &Insn) -> Option<(u16, u16)> {
if insn.encoding != "T1" || insn.operands.len() != 2 {
return None;
}
let (l, scalar, index, rt) = match (insn.operands.get(0), insn.operands.get(1)) {
(Some(Operand::FpScalar(d, i)), Some(Operand::Reg(r))) => (0, d, i, r),
(Some(Operand::Reg(r)), Some(Operand::FpScalar(d, i))) => (1, d, i, r),
_ => return None,
};
if index > 1 {
return None;
}
let (vd, d) = split(scalar, true)?;
let hw1 = 0xEE00 | (u16::from(index) << 5) | (l << 4) | vd;
let hw2 = (u16::from(rt.num()) << 12) | (0b1011 << 8) | (d << 7) | (1 << 4);
Some((hw1, hw2))
}
fn encode_three(insn: &Insn, dbl: bool, row: &Dp3) -> Option<(u16, u16)> {
if insn.operands.len() != 3 || insn.encoding != row.enc {
return None;
}
let (vd, d) = split(op_fp(insn, 0)?, dbl)?;
let (vn, n) = split(op_fp(insn, 1)?, dbl)?;
let (vm, m) = split(op_fp(insn, 2)?, dbl)?;
Some(
Words {
t: row.t,
hi: row.hi,
d,
lo: row.lo,
vn,
vd,
sz: u16::from(dbl),
opc3: (n << 1) | row.op,
m,
vm,
}
.pack(),
)
}
fn encode_two(insn: &Insn, dbl: bool, row: &Dp2) -> Option<(u16, u16)> {
if insn.operands.len() != 2 || insn.encoding != "T1" {
return None;
}
let (vd, d) = split(op_fp(insn, 0)?, dbl)?;
let (vm, m) = split(op_fp(insn, 1)?, dbl)?;
Some(
Words {
t: row.t,
hi: 1,
d,
lo: 0b11,
vn: row.opc2,
vd,
sz: u16::from(dbl),
opc3: row.opc3,
m,
vm,
}
.pack(),
)
}
fn convert_regs(insn: &Insn, dst_dbl: bool, src_dbl: bool) -> Option<(u16, u16, u16, u16)> {
let (vd, d) = split(op_fp(insn, 0)?, dst_dbl)?;
let (vm, m) = split(op_fp(insn, 1)?, src_dbl)?;
Some((vd, d, vm, m))
}
fn encode_fp_data_processing(insn: &Insn) -> Option<(u16, u16)> {
if let Some(dbl) = matches_pair(("vmov.f32", "vmov.f64"), insn.mnemonic) {
if let Some(Operand::FpImm(value)) = insn.operands.get(1) {
if insn.encoding != "T1" || insn.operands.len() != 2 {
return None;
}
let (vd, d) = split(op_fp(insn, 0)?, dbl)?;
let imm8 = vfp_compress_imm(value, dbl)?;
return Some(
Words {
t: 0,
hi: 1,
d,
lo: 0b11,
vn: imm8 >> 4,
vd,
sz: u16::from(dbl),
vm: imm8 & 0xF,
..Default::default()
}
.pack(),
);
}
}
for row in DP3.iter() {
if let Some(dbl) = matches_pair(row.names, insn.mnemonic) {
return encode_three(insn, dbl, row);
}
}
for (cc, names) in VSEL.iter().enumerate() {
if let Some(dbl) = matches_pair(*names, insn.mnemonic) {
if insn.operands.len() != 3 || insn.encoding != "T1" {
return None;
}
let (vd, d) = split(op_fp(insn, 0)?, dbl)?;
let (vn, n) = split(op_fp(insn, 1)?, dbl)?;
let (vm, m) = split(op_fp(insn, 2)?, dbl)?;
return Some(
Words {
t: 1,
hi: 0,
d,
lo: cc as u16,
vn,
vd,
sz: u16::from(dbl),
opc3: n << 1,
m,
vm,
}
.pack(),
);
}
}
for row in DP2.iter() {
if let Some(dbl) = matches_pair(row.names, insn.mnemonic) {
return encode_two(insn, dbl, row);
}
}
for (e, names) in VCMP.iter().enumerate() {
if let Some(dbl) = matches_pair(*names, insn.mnemonic) {
if insn.operands.len() != 2 {
return None;
}
let (vd, d) = split(op_fp(insn, 0)?, dbl)?;
let (opc2, vm, m) = match (insn.encoding, insn.operands.get(1)) {
("T1", Some(Operand::FpReg(other))) => {
let (vm, m) = split(other, dbl)?;
(0b0100, vm, m)
}
("T2", Some(Operand::Text("#0.0"))) => (0b0101, 0, 0),
_ => return None,
};
return Some(
Words {
t: 0,
hi: 1,
d,
lo: 0b11,
vn: opc2,
vd,
sz: u16::from(dbl),
opc3: ((e as u16) << 1) | 1,
m,
vm,
}
.pack(),
);
}
}
encode_convert(insn)
}
fn encode_convert(insn: &Insn) -> Option<(u16, u16)> {
if insn.encoding != "T1" {
return None;
}
match insn.operands.len() {
3 => encode_convert_fixed(insn),
2 => encode_convert_pair(insn),
_ => None,
}
}
fn encode_convert_fixed(insn: &Insn) -> Option<(u16, u16)> {
for (to_fixed, by_sf) in CVT_FIXED.iter().enumerate() {
for (sf, by_sx) in by_sf.iter().enumerate() {
for (sx, by_u) in by_sx.iter().enumerate() {
for (u, name) in by_u.iter().enumerate() {
if *name != insn.mnemonic {
continue;
}
let dbl = sf == 1;
let dest = op_fp(insn, 0)?;
let (vd, d) = split(dest, dbl)?;
if op_fp(insn, 1) != Some(dest) {
return None;
}
let size = if sx == 1 { 32 } else { 16 };
let field = match insn.operands.get(2) {
Some(Operand::Imm(frac)) if (0..=32).contains(&frac) => size - frac,
Some(Operand::Imm(_)) => return None,
_ => return None,
};
if !(0..32).contains(&field) {
return None;
}
return Some(
Words {
t: 0,
hi: 1,
d,
lo: 0b11,
vn: 0b1010 | ((to_fixed as u16) << 2) | u as u16,
vd,
sz: sf as u16,
opc3: ((sx as u16) << 1) | 1,
m: (field & 1) as u16,
vm: (field >> 1) as u16,
}
.pack(),
);
}
}
}
}
None
}
fn encode_convert_pair(insn: &Insn) -> Option<(u16, u16)> {
for (t, by_sz) in CVT_HALF.iter().enumerate() {
for (sz, by_op) in by_sz.iter().enumerate() {
for (op, name) in by_op.iter().enumerate() {
if *name != insn.mnemonic {
continue;
}
let dbl = sz == 1;
let (vd, d, vm, m) = convert_regs(insn, dbl && op == 0, dbl && op == 1)?;
return Some(
Words {
t: 0,
hi: 1,
d,
lo: 0b11,
vn: 0b0010 | op as u16,
vd,
sz: sz as u16,
opc3: ((t as u16) << 1) | 1,
m,
vm,
}
.pack(),
);
}
}
}
for (sz, by_signed) in CVT_FROM_INT.iter().enumerate() {
for (signed, name) in by_signed.iter().enumerate() {
if *name != insn.mnemonic {
continue;
}
let (vd, d, vm, m) = convert_regs(insn, sz == 1, false)?;
return Some(
Words {
t: 0,
hi: 1,
d,
lo: 0b11,
vn: 0b1000,
vd,
sz: sz as u16,
opc3: ((signed as u16) << 1) | 1,
m,
vm,
}
.pack(),
);
}
}
for (round, by_signed) in CVT_TO_INT.iter().enumerate() {
for (signed, by_sz) in by_signed.iter().enumerate() {
for (sz, name) in by_sz.iter().enumerate() {
if *name != insn.mnemonic {
continue;
}
let (vd, d, vm, m) = convert_regs(insn, false, sz == 1)?;
return Some(
Words {
t: 0,
hi: 1,
d,
lo: 0b11,
vn: 0b1100 | signed as u16,
vd,
sz: sz as u16,
opc3: ((round as u16) << 1) | 1,
m,
vm,
}
.pack(),
);
}
}
}
for (sz, name) in CVT_DP_SP.iter().enumerate() {
if *name == insn.mnemonic {
let (vd, d, vm, m) = convert_regs(insn, sz == 0, sz == 1)?;
return Some(
Words {
t: 0,
hi: 1,
d,
lo: 0b11,
vn: 0b0111,
vd,
sz: sz as u16,
opc3: 0b11,
m,
vm,
}
.pack(),
);
}
}
for (rm, by_signed) in CVT_RM.iter().enumerate() {
for (signed, by_sz) in by_signed.iter().enumerate() {
for (sz, name) in by_sz.iter().enumerate() {
if *name != insn.mnemonic {
continue;
}
let (vd, d, vm, m) = convert_regs(insn, false, sz == 1)?;
return Some(
Words {
t: 1,
hi: 1,
d,
lo: 0b11,
vn: 0b1100 | rm as u16,
vd,
sz: sz as u16,
opc3: ((signed as u16) << 1) | 1,
m,
vm,
}
.pack(),
);
}
}
}
None
}
#[cfg(test)]
mod tests {
use super::*;
use crate::isa::MAX_OPERANDS;
const ADDR: u32 = 0x1000;
fn insn(mnemonic: &'static str, encoding: &'static str, operands: &[Operand]) -> Insn {
wide(mnemonic, encoding, ADDR, ops(operands))
}
fn check(hw1: u16, hw2: u16, text: &str) {
let decoded = decode(hw1, hw2, ADDR);
assert!(
decoded.is_some(),
"{hw1:#06x} {hw2:#06x} ({text}) must decode"
);
let insn = decoded.unwrap();
assert_eq!(
insn.to_string(),
text,
"printed form of {hw1:#06x} {hw2:#06x}"
);
assert_eq!(
encode(&insn),
Some((hw1, hw2)),
"round trip of {hw1:#06x} {hw2:#06x} ({text})"
);
}
fn round_trip(hw1: u16, hw2: u16) -> Option<Insn> {
let insn = decode(hw1, hw2, ADDR)?;
assert_eq!(insn.width, Width::Wide, "{hw1:#06x} {hw2:#06x}");
assert_eq!(insn.len(), 4, "{hw1:#06x} {hw2:#06x}");
assert_eq!(insn.addr, ADDR, "{hw1:#06x} {hw2:#06x}");
assert!(insn.cond.is_none(), "{hw1:#06x} {hw2:#06x}");
assert!(!insn.sets_flags, "{hw1:#06x} {hw2:#06x}");
assert!(!insn.explicit_width, "{hw1:#06x} {hw2:#06x}");
assert_eq!(
encode(&insn),
Some((hw1, hw2)),
"round trip of {hw1:#06x} {hw2:#06x} ({insn})"
);
Some(insn)
}
fn dec(hw1: u16, hw2: u16) -> Insn {
let decoded = decode(hw1, hw2, ADDR);
assert!(decoded.is_some(), "{hw1:#06x} {hw2:#06x} must decode");
decoded.unwrap()
}
fn replacing(insn: &Insn, i: usize, op: Operand) -> Insn {
let mut out = *insn;
out.operands = insn
.operands
.as_slice()
.enumerate()
.map(|(n, existing)| if n == i { op } else { existing })
.collect();
out
}
const ENCODERS: [(u16, u16); 49] = [
(0xEE13, 0x27A4), (0xFE01, 0x0E02), (0xEE23, 0x27B4), (0xEE33, 0x27B4), (0xEE11, 0xFE72), (0xEC43, 0x2714), (0xEC53, 0x2714), (0xED92, 0x1702), (0xEDB2, 0x1702), (0xECB2, 0x1702), (0xEC92, 0x170C), (0xED9F, 0x1704), (0xED82, 0x1702), (0xFDC0, 0x0E00), (0xEDD2, 0x0A02), (0xED12, 0x3B02), (0xEDDF, 0x0A04), (0xED8D, 0x8AFF), (0xECD2, 0x0A04), (0xECB2, 0x1B06), (0xED72, 0x2A02), (0xEC82, 0x0B04), (0xED22, 0x4B08), (0xED2D, 0x0A04), (0xECBD, 0x2B08), (0xEE03, 0x4A90), (0xEE13, 0x4A90), (0xEE23, 0x4B10), (0xEE13, 0x4B10), (0xEC41, 0x0A32), (0xEC51, 0x0A32), (0xEC41, 0x0B19), (0xEC51, 0x0B19), (0xEEE1, 0x5A10), (0xEEF1, 0x5A10), (0xEEF1, 0xFA10), (0xEE71, 0x0A21), (0xEE32, 0x1B03), (0xEE12, 0x1B43), (0xFE41, 0x0A21), (0xFE22, 0x1B03), (0xEEF0, 0x0AC1), (0xEEB1, 0x1B42), (0xFEF8, 0x0A41), (0xEEF0, 0x0A00), (0xEEF4, 0x0A41), (0xEEF5, 0x1B40), (0xEEFD, 0x0AC1), (0xEEFE, 0x0A66), ];
const CONVERSIONS: [(u16, u16); 6] = [
(0xEEF8, 0x0AC1), (0xEEFC, 0x0B42), (0xEEB7, 0x1AC1), (0xEEF7, 0x0BC2), (0xEEF2, 0x0A41), (0xFEFC, 0x2AC3), ];
fn group_halfwords() -> impl Iterator<Item = u16> {
(0xEC00u16..=0xEFFF).chain(0xFC00u16..=0xFFFF)
}
#[test]
fn systematic_sweep_round_trips_and_accounts_for_every_hole() {
let coprocs = [0x0u16, 0x7, 0xA, 0xB, 0xE, 0xF];
let bodies = [
0x00u16, 0x01, 0x02, 0x04, 0x08, 0x10, 0x11, 0x20, 0x41, 0x66, 0x90, 0xC1, 0xCF, 0xFF,
];
let vds = [0x0u16, 0x1, 0xF];
let (mut decoded, mut simd, mut undefined, mut unallocated) = (0usize, 0, 0, 0);
let mut total = 0usize;
for hw1 in group_halfwords() {
let op1 = bits(hw1, 9, 4);
for &coproc in coprocs.iter() {
for &body in bodies.iter() {
for &vd in vds.iter() {
let hw2 = (vd << 12) | (coproc << 8) | body;
total += 1;
let insn = round_trip(hw1, hw2);
if op1 & 0b11_0000 == 0b11_0000 {
assert!(insn.is_none(), "{hw1:#06x} {hw2:#06x} is SIMD");
simd += 1;
} else if op1 & 0b11_1110 == 0 {
assert!(insn.is_none(), "{hw1:#06x} {hw2:#06x} is UNDEFINED");
undefined += 1;
} else if insn.is_some() {
decoded += 1;
} else {
unallocated += 1;
}
}
}
}
}
assert_eq!(total, 2048 * 6 * 14 * 3);
assert_eq!(simd + undefined + decoded + unallocated, total);
assert_eq!(simd, total / 4);
assert_eq!(undefined, total / 32);
assert_eq!(decoded, 285_238);
assert_eq!(unallocated, 85_706);
}
#[test]
fn single_and_double_read_the_same_bits_in_opposite_orders() {
check(0xEE30, 0xFB81, "vadd.f64 d15, d16, d1");
check(0xEE30, 0xFA81, "vadd.f32 s30, s1, s2");
check(0xEEB0, 0xFBE1, "vabs.f64 d15, d17");
check(0xEEB0, 0xFAE1, "vabs.f32 s30, s3");
}
#[test]
fn register_halves_round_trip_for_every_high_bit_combination() {
const NUMBERS: [u8; 5] = [0, 1, 15, 16, 31];
let mut checked = 0usize;
for &a in NUMBERS.iter() {
for &b in NUMBERS.iter() {
for &c in NUMBERS.iter() {
for &dbl in [false, true].iter() {
let reg =
|n: u8| Operand::FpReg(if dbl { FpReg::D(n) } else { FpReg::S(n) });
let name = if dbl { "vadd.f64" } else { "vadd.f32" };
let original = insn(name, "T1", &[reg(a), reg(b), reg(c)]);
let (hw1, hw2) = encode(&original).expect("encodable");
assert_eq!(
decode(hw1, hw2, ADDR).as_ref(),
Some(&original),
"{original} through {hw1:#06x} {hw2:#06x}"
);
checked += 1;
}
}
}
}
assert_eq!(checked, 5 * 5 * 5 * 2);
}
#[test]
fn vfp_expand_imm_matches_the_manuals_table() {
for &dbl in [false, true].iter() {
assert_eq!(vfp_expand_imm(0x00, dbl), 2.0);
assert_eq!(vfp_expand_imm(0x80, dbl), -2.0);
assert_eq!(vfp_expand_imm(0x70, dbl), 1.0);
assert_eq!(vfp_expand_imm(0x40, dbl), 0.125);
assert_eq!(vfp_expand_imm(0x3F, dbl), 31.0);
assert_eq!(vfp_expand_imm(0xE8, dbl), -0.75);
for imm8 in 0..256u16 {
assert_eq!(vfp_expand_imm(imm8, false), vfp_expand_imm(imm8, true));
assert_eq!(vfp_compress_imm(vfp_expand_imm(imm8, dbl), dbl), Some(imm8));
}
}
for value in [0.0, -0.0, 0.3, 1.1, 0.0625, 32.0, f64::INFINITY, f64::NAN] {
assert_eq!(vfp_compress_imm(value, false), None, "{value}");
assert_eq!(vfp_compress_imm(value, true), None, "{value}");
}
check(0xEEF0, 0x0A00, "vmov.f32 s1, #2.0");
check(0xEEBE, 0x1B08, "vmov.f64 d1, #-0.75");
let bad = insn(
"vmov.f32",
"T1",
&[Operand::FpReg(FpReg::S(0)), Operand::FpImm(0.3)],
);
assert_eq!(encode(&bad), None);
}
#[test]
fn generic_coprocessor_prints_the_manuals_syntax() {
check(0xEE13, 0x27A4, "cdp p7, #1, c2, c3, c4, #5");
check(0xFE01, 0x0E02, "cdp2 p14, #0, c0, c1, c2, #0");
check(0xEE23, 0x27B4, "mcr p7, #1, r2, c3, c4, #5");
check(0xFEE1, 0x0E12, "mcr2 p14, #7, r0, c1, c2, #0");
check(0xEE33, 0x27B4, "mrc p7, #1, r2, c3, c4, #5");
check(0xFE11, 0x0E12, "mrc2 p14, #0, r0, c1, c2, #0");
check(0xEE11, 0xFE72, "mrc p14, #0, apsr_nzcv, c1, c2, #3");
check(0xEC43, 0x2714, "mcrr p7, #1, r2, r3, c4");
check(0xFC41, 0x0E02, "mcrr2 p14, #0, r0, r1, c2");
check(0xEC53, 0x2714, "mrrc p7, #1, r2, r3, c4");
check(0xFC51, 0x0E02, "mrrc2 p14, #0, r0, r1, c2");
}
#[test]
fn coprocessor_load_store_prints_every_addressing_form() {
check(0xED92, 0x1702, "ldc p7, c1, [r2, #8]");
check(0xED52, 0x1702, "ldcl p7, c1, [r2, #-8]");
check(0xFD90, 0x0E00, "ldc2 p14, c0, [r0]");
check(0xFDD0, 0x0E01, "ldc2l p14, c0, [r0, #4]");
check(0xEDB2, 0x1702, "ldc p7, c1, [r2, #8]!");
check(0xECB2, 0x1702, "ldc p7, c1, [r2], #8");
check(0xEC32, 0x1702, "ldc p7, c1, [r2], #-8");
check(0xEC92, 0x170C, "ldc p7, c1, [r2], {12}");
check(0xEC82, 0x17FF, "stc p7, c1, [r2], {255}");
check(0xED9F, 0x1704, "ldc p7, c1, [pc, #16], 0x1014");
check(0xECA0, 0x0000, "stc p0, c0, [r0], #0");
check(0xED80, 0x0000, "stc p0, c0, [r0]");
let post = decode(0xECA0, 0x0000, ADDR).unwrap();
let offset = decode(0xED80, 0x0000, ADDR).unwrap();
assert_ne!(post, offset);
assert_eq!(
post.operands.get(2),
Some(Operand::Mem(Mem {
base: Reg(0),
index: None,
offset: 0,
add: true,
align: 0,
mode: AddrMode::PostIndex,
}))
);
check(0xED10, 0x0000, "ldc p0, c0, [r0, #-0]");
check(0xED30, 0x0000, "ldc p0, c0, [r0, #-0]!");
check(0xEC30, 0x0000, "ldc p0, c0, [r0], #-0");
check(0xED82, 0x1702, "stc p7, c1, [r2, #8]");
check(0xED42, 0x1E02, "stcl p14, c1, [r2, #-8]");
check(0xFD80, 0x0E00, "stc2 p14, c0, [r0]");
check(0xFDC0, 0x0E00, "stc2l p14, c0, [r0]");
}
#[test]
fn extension_register_load_store_prints_the_manuals_syntax() {
check(0xEDD2, 0x0A02, "vldr s1, [r2, #8]");
check(0xED12, 0x3B02, "vldr d3, [r2, #-8]");
check(0xED90, 0x0A00, "vldr s0, [r0]");
check(0xED8D, 0x8AFF, "vstr s16, [sp, #1020]");
check(0xEDC0, 0x1B01, "vstr d17, [r0, #4]");
check(0xEDDF, 0x0A04, "vldr s1, [pc, #16], 0x1014");
check(0xECD2, 0x0A04, "vldmia r2, {s1-s4}");
check(0xECB2, 0x1B06, "vldmia r2!, {d1-d3}");
check(0xED72, 0x2A02, "vldmdb r2!, {s5-s6}");
check(0xEC82, 0x0B04, "vstmia r2, {d0-d1}");
check(0xED22, 0x4B08, "vstmdb r2!, {d4-d7}");
check(0xECA2, 0x0A01, "vstmia r2!, {s0}");
}
#[test]
fn register_ranges_print_and_round_trip() {
check(0xED2D, 0x0A04, "vpush {s0-s3}");
check(0xECBD, 0x2B08, "vpop {d2-d5}");
check(0xED2D, 0x0B20, "vpush {d0-d15}");
check(0xECFD, 0xFA01, "vpop {s31}");
let mut ranges = 0usize;
for first in 0..32u16 {
for regs in 1..=(32 - first) {
let hw1 = 0xED2D | ((first & 1) << 6);
let hw2 = ((first >> 1) << 12) | 0x0A00 | regs;
let insn = round_trip(hw1, hw2).expect("a legal single-precision list");
assert_eq!(insn.mnemonic, "vpush");
ranges += 1;
}
}
for first in 0..32u16 {
for regs in 1..=16.min(32 - first) {
let hw1 = 0xECBD | ((first >> 4) << 6);
let hw2 = ((first & 0xF) << 12) | 0x0B00 | (regs * 2);
let insn = round_trip(hw1, hw2).expect("a legal double-precision list");
assert_eq!(insn.mnemonic, "vpop");
ranges += 1;
}
}
assert_eq!(ranges, 528 + 392);
assert!(decode(0xECFD, 0xFA02, ADDR).is_none());
assert!(decode(0xECBD, 0x0B22, ADDR).is_none());
assert!(decode(0xECB2, 0x1B03, ADDR).is_none());
}
#[test]
fn three_register_data_processing_prints_the_manuals_syntax() {
check(0xEE71, 0x0A21, "vadd.f32 s1, s2, s3"); check(0xEE32, 0x1B03, "vadd.f64 d1, d2, d3");
check(0xEE71, 0x0A61, "vsub.f32 s1, s2, s3"); check(0xEE61, 0x0BA2, "vmul.f64 d16, d17, d18"); check(0xEE61, 0x0A61, "vnmul.f32 s1, s2, s3"); check(0xEE82, 0x1B03, "vdiv.f64 d1, d2, d3"); check(0xEE41, 0x0A21, "vmla.f32 s1, s2, s3"); check(0xEE41, 0x0A61, "vmls.f32 s1, s2, s3");
check(0xEE12, 0x1B43, "vnmla.f64 d1, d2, d3"); check(0xEE51, 0x0A21, "vnmls.f32 s1, s2, s3");
check(0xEEE1, 0x0A21, "vfma.f32 s1, s2, s3"); check(0xEEA2, 0x1B43, "vfms.f64 d1, d2, d3");
check(0xEED1, 0x0A61, "vfnma.f32 s1, s2, s3"); check(0xEE92, 0x1B03, "vfnms.f64 d1, d2, d3");
check(0xFEC1, 0x0A21, "vmaxnm.f32 s1, s2, s3"); check(0xFE82, 0x1B43, "vminnm.f64 d1, d2, d3");
check(0xFE41, 0x0A21, "vseleq.f32 s1, s2, s3");
check(0xFE51, 0x0A21, "vselvs.f32 s1, s2, s3");
check(0xFE22, 0x1B03, "vselge.f64 d1, d2, d3");
check(0xFE71, 0x0A21, "vselgt.f32 s1, s2, s3");
}
#[test]
fn two_register_data_processing_prints_the_manuals_syntax() {
check(0xEEF0, 0x0AC1, "vabs.f32 s1, s2"); check(0xEEB1, 0x1B42, "vneg.f64 d1, d2"); check(0xEEF1, 0xFACF, "vsqrt.f32 s31, s30"); check(0xEEF0, 0x0A41, "vmov.f32 s1, s2"); check(0xEEF0, 0x1B42, "vmov.f64 d17, d2");
check(0xEEF4, 0x0A41, "vcmp.f32 s1, s2");
check(0xEEB4, 0x1BC2, "vcmpe.f64 d1, d2");
check(0xEEF5, 0x1B40, "vcmp.f64 d17, #0.0");
check(0xEEF5, 0x0AC0, "vcmpe.f32 s1, #0.0");
check(0xFEF8, 0x0A41, "vrinta.f32 s1, s2");
check(0xFEB9, 0x1B42, "vrintn.f64 d1, d2");
check(0xFEFA, 0x0A41, "vrintp.f32 s1, s2");
check(0xFEBB, 0x1B42, "vrintm.f64 d1, d2");
check(0xEEF7, 0x0A41, "vrintx.f32 s1, s2");
check(0xEEB6, 0x1BC2, "vrintz.f64 d1, d2");
check(0xEEF6, 0x0A41, "vrintr.f32 s1, s2");
}
#[test]
fn conversions_print_both_of_their_types() {
check(0xEEFD, 0x0AC1, "vcvt.s32.f32 s1, s2");
check(0xEEFC, 0x0B42, "vcvtr.u32.f64 s1, d2");
check(0xEEF8, 0x0AC1, "vcvt.f32.s32 s1, s2");
check(0xEEB8, 0x1B41, "vcvt.f64.u32 d1, s2");
check(0xEEB7, 0x1AC1, "vcvt.f64.f32 d1, s2");
check(0xEEF7, 0x0BC2, "vcvt.f32.f64 s1, d2");
check(0xEEFE, 0x0A66, "vcvt.s16.f32 s1, s1, #3");
check(0xEEBB, 0x1B64, "vcvt.f64.u16 d1, d1, #7");
check(0xEEBF, 0x0AC0, "vcvt.u32.f32 s0, s0, #0x20");
check(0xEEF2, 0x0A41, "vcvtb.f32.f16 s1, s2");
check(0xEEF3, 0x0AC1, "vcvtt.f16.f32 s1, s2");
check(0xEEB2, 0x1B41, "vcvtb.f64.f16 d1, s2");
check(0xEEF3, 0x0BC2, "vcvtt.f16.f64 s1, d2");
check(0xFEFC, 0x2AC3, "vcvta.s32.f32 s5, s6");
check(0xFEFD, 0x2B46, "vcvtn.u32.f64 s5, d6");
check(0xFEFE, 0x2BC6, "vcvtp.s32.f64 s5, d6");
check(0xFEFF, 0x2A43, "vcvtm.u32.f32 s5, s6");
}
#[test]
fn core_register_transfers_print_the_manuals_syntax() {
check(0xEE03, 0x4A90, "vmov s7, r4");
check(0xEE13, 0x4A90, "vmov r4, s7");
check(0xEE23, 0x4B10, "vmov.32 d3[1], r4");
check(0xEE13, 0x4B10, "vmov.32 r4, d3[0]");
check(0xEC41, 0x0A32, "vmov s5, s6, r0, r1");
check(0xEC51, 0x0A32, "vmov r0, r1, s5, s6");
check(0xEC41, 0x0B19, "vmov d9, r0, r1");
check(0xEC51, 0x0B19, "vmov r0, r1, d9");
check(0xEEE1, 0x5A10, "vmsr fpscr, r5");
}
#[test]
fn vmrs_apsr_nzcv_is_the_idiom_that_follows_vcmp() {
check(0xEEF1, 0xFA10, "vmrs apsr_nzcv, fpscr");
check(0xEEF1, 0x5A10, "vmrs r5, fpscr");
check(0xEEF8, 0x0A10, "vmrs r0, fpexc");
check(0xEEF0, 0x0A10, "vmrs r0, fpsid");
assert!(decode(0xEEF2, 0x0A10, ADDR).is_none());
check(0xEEE8, 0x0A10, "vmsr fpexc, r0");
assert!(decode(0xEEE7, 0x0A10, ADDR).is_none());
assert!(decode(0xEEF8, 0xFA10, ADDR).is_none());
assert!(decode(0xEEF1, 0x5A30, ADDR).is_none());
}
#[test]
fn outside_the_group_is_not_ours() {
assert!(decode(0xEBFF, 0x0000, ADDR).is_none());
assert!(decode(0xE800, 0x0000, ADDR).is_none());
assert!(decode(0xF800, 0x0000, ADDR).is_none());
assert!(decode(0xEF00, 0x0B10, ADDR).is_none());
assert!(decode(0xFF00, 0x0B10, ADDR).is_none());
assert!(decode(0xEC00, 0x0700, ADDR).is_none());
assert!(decode(0xEC10, 0x0700, ADDR).is_none());
assert!(decode(0xFC92, 0x0B04, ADDR).is_none());
assert!(decode(0xFE03, 0x4A90, ADDR).is_none());
assert!(decode(0xEE83, 0x4B10, ADDR).is_none());
assert!(decode(0xEE43, 0x4B10, ADDR).is_none());
assert!(decode(0xEE23, 0x4B30, ADDR).is_none());
assert!(decode(0xEE82, 0x1B43, ADDR).is_none());
let alien = insn("add", "T3", &[Operand::Reg(Reg(0)), Operand::Reg(Reg(1))]);
assert_eq!(encode(&alien), None);
let good = decode(0xEE71, 0x0A21, ADDR).unwrap();
let mut wrong = good;
wrong.encoding = "T2";
assert_eq!(encode(&wrong), None);
let mut flagged = good;
flagged.sets_flags = true;
assert_eq!(encode(&flagged), None);
let mut narrow = good;
narrow.width = Width::Narrow;
assert_eq!(encode(&narrow), None);
}
#[test]
fn encode_rejects_operands_the_encoding_cannot_hold() {
let mixed = insn(
"vadd.f32",
"T1",
&[
Operand::FpReg(FpReg::D(0)),
Operand::FpReg(FpReg::D(1)),
Operand::FpReg(FpReg::D(2)),
],
);
assert_eq!(encode(&mixed), None);
let quad = insn(
"vabs.f64",
"T1",
&[Operand::FpReg(FpReg::Q(0)), Operand::FpReg(FpReg::Q(1))],
);
assert_eq!(encode(&quad), None);
let indexed = insn(
"ldc",
"T1",
&[
Operand::Coproc(7),
Operand::CoprocReg(1),
Operand::Mem(Mem {
base: Reg(2),
index: Some((Reg(3), None)),
offset: 0,
add: true,
align: 0,
mode: AddrMode::Offset,
}),
],
);
assert_eq!(encode(&indexed), None);
for offset in [6u32, 1024] {
for add in [true, false] {
let mem = Operand::Mem(Mem {
base: Reg(2),
index: None,
offset,
add,
align: 0,
mode: AddrMode::Offset,
});
let bad = insn("vldr", "T2", &[Operand::FpReg(FpReg::S(0)), mem]);
assert_eq!(encode(&bad), None, "offset {offset} add {add}");
}
}
for frac in [0i64, 33] {
let fbits = insn(
"vcvt.s32.f32",
"T1",
&[
Operand::FpReg(FpReg::S(0)),
Operand::FpReg(FpReg::S(0)),
Operand::Imm(frac),
],
);
assert_eq!(encode(&fbits), None, "fbits #{frac}");
}
let long = insn("vpush", "T1", &[Operand::Text(D_RANGES[0][16])]);
assert_eq!(encode(&long), None);
let bogus = insn("vpop", "T1", &[Operand::Text("{q0-q1}")]);
assert_eq!(encode(&bogus), None);
let mcr = insn(
"mcr",
"T1",
&[
Operand::Coproc(14),
Operand::Imm(0),
Operand::SpecialReg("apsr_nzcv"),
Operand::CoprocReg(1),
Operand::CoprocReg(2),
Operand::Imm(3),
],
);
assert_eq!(encode(&mcr), None);
}
#[test]
fn writeback_and_stack_forms_do_not_overlap() {
let list = Operand::Text(S_RANGES[0][3]);
let pop = insn("vldmia", "T2", &[Operand::Text(WRITEBACK[13]), list]);
assert_eq!(encode(&pop), None);
let push = insn("vstmdb", "T2", &[Operand::Text(WRITEBACK[13]), list]);
assert_eq!(encode(&push), None);
let db = insn("vldmdb", "T2", &[Operand::Reg(Reg(2)), list]);
assert_eq!(encode(&db), None);
let ia = insn("vldmia", "T2", &[Operand::Text(WRITEBACK[2]), list]);
assert_eq!(encode(&ia), Some((0xECB2, 0x0A04)));
}
#[test]
fn encode_checks_every_operand_position_and_the_operand_count() {
let alien = Operand::RegList(0b11);
for (hw1, hw2) in ENCODERS.iter().chain(CONVERSIONS.iter()) {
let (hw1, hw2) = (*hw1, *hw2);
let insn = dec(hw1, hw2);
for i in 0..insn.operands.len() {
let mangled = replacing(&insn, i, alien);
assert_eq!(
encode(&mangled),
None,
"operand {i} of {hw1:#06x} {hw2:#06x} ({insn}) is not checked"
);
}
if insn.operands.len() < MAX_OPERANDS {
let mut longer = insn;
longer.operands.push(alien);
assert_eq!(
encode(&longer),
None,
"a trailing operand on {hw1:#06x} {hw2:#06x} ({insn}) is ignored"
);
if insn.operands.len() + 1 < MAX_OPERANDS {
longer.operands.push(alien);
assert_eq!(encode(&longer), None, "{hw1:#06x} {hw2:#06x}");
}
}
let mut shorter = insn;
shorter.operands = insn
.operands
.as_slice()
.take(insn.operands.len() - 1)
.collect();
assert_ne!(
encode(&shorter),
Some((hw1, hw2)),
"{hw1:#06x} {hw2:#06x} ({insn}) re-encodes with an operand missing"
);
}
}
#[test]
fn encode_requires_the_architectural_encoding_name_to_match() {
for (hw1, hw2) in ENCODERS.iter().chain(CONVERSIONS.iter()) {
let (hw1, hw2) = (*hw1, *hw2);
let insn = dec(hw1, hw2);
let mut renamed = insn;
renamed.encoding = if insn.encoding == "T1" { "T2" } else { "T1" };
assert_eq!(
encode(&renamed),
None,
"{hw1:#06x} {hw2:#06x} ({insn}) encodes under the wrong encoding name"
);
}
}
#[test]
fn encode_requires_every_register_to_match_the_precision_its_field_implies() {
for (hw1, hw2) in ENCODERS.iter().chain(CONVERSIONS.iter()) {
let (hw1, hw2) = (*hw1, *hw2);
let insn = dec(hw1, hw2);
for i in 0..insn.operands.len() {
let swapped = match insn.operands.get(i) {
Some(Operand::FpReg(FpReg::S(n))) => Operand::FpReg(FpReg::D(n)),
Some(Operand::FpReg(FpReg::D(n))) => Operand::FpReg(FpReg::S(n)),
_ => continue,
};
let mangled = replacing(&insn, i, swapped);
assert_eq!(
encode(&mangled),
None,
"operand {i} of {hw1:#06x} {hw2:#06x} ({insn}) took the wrong precision"
);
}
}
}
#[test]
fn encode_refuses_the_first_number_past_the_end_of_each_field() {
for (hw1, hw2) in ENCODERS.iter().chain(CONVERSIONS.iter()) {
let (hw1, hw2) = (*hw1, *hw2);
let insn = dec(hw1, hw2);
for i in 0..insn.operands.len() {
let past_the_end = match insn.operands.get(i) {
Some(Operand::FpReg(FpReg::S(_))) => Operand::FpReg(FpReg::S(32)),
Some(Operand::FpReg(FpReg::D(_))) => Operand::FpReg(FpReg::D(32)),
Some(Operand::FpScalar(_, lane)) => Operand::FpScalar(FpReg::D(32), lane),
Some(Operand::Coproc(_)) => Operand::Coproc(16),
Some(Operand::CoprocReg(_)) => Operand::CoprocReg(16),
_ => continue,
};
let mangled = replacing(&insn, i, past_the_end);
assert_eq!(
encode(&mangled),
None,
"operand {i} of {hw1:#06x} {hw2:#06x} ({insn}) overflowed its field"
);
}
}
}
#[test]
fn coprocessor_load_store_encode_refuses_addressing_it_cannot_hold() {
let head = [Operand::Coproc(7), Operand::CoprocReg(1)];
let mem = |mode, offset, add| {
Operand::Mem(Mem {
base: Reg(2),
index: None,
offset,
add,
align: 0,
mode,
})
};
let post_inc = insn(
"ldc",
"T1",
&[head[0], head[1], mem(AddrMode::PostIncrement, 0, true)],
);
assert_eq!(encode(&post_inc), None);
for offset in [6u32, 1024] {
let bad = insn(
"ldc",
"T1",
&[head[0], head[1], mem(AddrMode::Offset, offset, true)],
);
assert_eq!(encode(&bad), None, "offset {offset}");
}
let named = insn(
"ldc",
"T1",
&[
head[0],
head[1],
mem(AddrMode::Offset, 0, true),
Operand::Option("sy"),
],
);
assert_eq!(encode(&named), None);
for bad_mem in [
mem(AddrMode::Offset, 8, true),
mem(AddrMode::Offset, 0, false),
mem(AddrMode::PreIndex, 0, true),
] {
let unindexed = insn(
"ldc",
"T1",
&[head[0], head[1], bad_mem, Operand::Option(OPTIONS[12])],
);
assert_eq!(encode(&unindexed), None);
}
let quad = insn(
"vldr",
"T2",
&[Operand::FpReg(FpReg::Q(0)), mem(AddrMode::Offset, 8, true)],
);
assert_eq!(encode(&quad), None);
for mode in [
AddrMode::PreIndex,
AddrMode::PostIndex,
AddrMode::PostIncrement,
] {
let bad = insn(
"vldr",
"T2",
&[Operand::FpReg(FpReg::S(0)), mem(mode, 8, true)],
);
assert_eq!(encode(&bad), None);
}
let literal = dec(0xEDDF, 0x0A04);
assert_eq!(literal.operands.get(2), Some(Operand::Target(0x1014)));
assert_eq!(
encode(&replacing(&literal, 2, Operand::Target(0x1018))),
None
);
let ldc_literal = dec(0xED9F, 0x1704);
assert_eq!(ldc_literal.operands.get(3), Some(Operand::Target(0x1014)));
assert_eq!(
encode(&replacing(&ldc_literal, 3, Operand::Target(0x1018))),
None
);
}
#[test]
fn special_register_transfers_encode_only_the_named_registers() {
let unknown = insn(
"vmrs",
"T1",
&[Operand::Reg(Reg(5)), Operand::SpecialReg("fpinst")],
);
assert_eq!(encode(&unknown), None);
assert_eq!(dec(0xEEF7, 0x0A10).to_string(), "vmrs r0, mvfr0");
let readonly = insn(
"vmsr",
"T1",
&[Operand::SpecialReg("mvfr0"), Operand::Reg(Reg(0))],
);
assert_eq!(encode(&readonly), None);
let wide_index = insn(
"vmov.32",
"T1",
&[Operand::FpScalar(FpReg::D(3), 2), Operand::Reg(Reg(4))],
);
assert_eq!(encode(&wide_index), None);
let single = insn(
"vmov.32",
"T1",
&[Operand::FpScalar(FpReg::S(3), 0), Operand::Reg(Reg(4))],
);
assert_eq!(encode(&single), None);
let gapped = insn(
"vmov",
"T1",
&[
Operand::FpReg(FpReg::S(5)),
Operand::FpReg(FpReg::S(7)),
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
],
);
assert_eq!(encode(&gapped), None);
let off_end = insn(
"vmov",
"T1",
&[
Operand::FpReg(FpReg::S(31)),
Operand::FpReg(FpReg::S(0)),
Operand::Reg(Reg(0)),
Operand::Reg(Reg(1)),
],
);
assert_eq!(encode(&off_end), None);
}
#[test]
fn multiple_register_transfer_encode_refuses_a_base_that_is_not_one() {
let bogus_base = insn(
"vldmia",
"T2",
&[Operand::Text("sp!!"), Operand::Text(S_RANGES[0][3])],
);
assert_eq!(encode(&bogus_base), None);
let wrong_enc = insn(
"vldmia",
"T1",
&[Operand::Reg(Reg(2)), Operand::Text(S_RANGES[0][3])],
);
assert_eq!(encode(&wrong_enc), None);
}
#[test]
fn core_to_single_transfer_refuses_the_two_bits_its_neighbours_use_as_opc2() {
for b in [0x20u16, 0x40, 0x60] {
assert!(
decode(0xEE03, 0x4A90 | b, ADDR).is_none(),
"vmov s7, r4 with B set by {b:#04x} must not decode"
);
assert!(
decode(0xEE13, 0x4A90 | b, ADDR).is_none(),
"vmov r4, s7 with B set by {b:#04x} must not decode"
);
}
check(0xEE03, 0x4A90, "vmov s7, r4");
check(0xEE13, 0x4A90, "vmov r4, s7");
}
#[test]
fn generic_coprocessor_encode_bounds_every_immediate_field() {
for (hw1, hw2) in [
(0xEE13u16, 0x27A4u16), (0xFE01, 0x0E02), (0xEE23, 0x27B4), (0xEE33, 0x27B4), (0xEC43, 0x2714), (0xEC53, 0x2714), ] {
let insn = dec(hw1, hw2);
for i in 0..insn.operands.len() {
if !matches!(insn.operands.get(i), Some(Operand::Imm(_))) {
continue;
}
for value in [-1i64, 16] {
let mangled = replacing(&insn, i, Operand::Imm(value));
assert_eq!(
encode(&mangled),
None,
"operand {i} of {hw1:#06x} {hw2:#06x} ({insn}) accepted #{value}"
);
}
}
}
}
#[test]
fn decode_refuses_the_two_unpredictable_register_numbers_the_fields_can_hold() {
assert!(decode(0xEC41, 0x2A3F, ADDR).is_none());
assert_eq!(dec(0xEC41, 0x2A1F).to_string(), "vmov s30, s31, r2, r1");
assert!(decode(0xEEBA, 0x0A6F, ADDR).is_none());
assert_eq!(dec(0xEEBA, 0x0A48).to_string(), "vcvt.f32.s16 s0, s0, #0");
}
}