use super::{AddrMode, FpReg, Insn, Mem, Operand, Operands, Reg, Width};
fn simd(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 dnum(hi: u16, lo: u16) -> u8 {
(((hi & 1) << 4) | (lo & 0xF)) as u8
}
fn vec(q: bool, d: u8) -> Option<FpReg> {
if q {
if d & 1 != 0 {
None
} else {
Some(FpReg::Q(d >> 1))
}
} else {
Some(FpReg::D(d))
}
}
fn vec_bits(reg: FpReg) -> Option<(bool, u8)> {
match reg {
FpReg::D(n) if n < 32 => Some((false, n)),
FpReg::Q(n) if n < 16 => Some((true, n << 1)),
_ => None,
}
}
fn fp_at(insn: &Insn, i: usize) -> Option<FpReg> {
match insn.operands.get(i)? {
Operand::FpReg(r) => Some(r),
_ => None,
}
}
fn imm_at(insn: &Insn, i: usize) -> Option<i64> {
match insn.operands.get(i)? {
Operand::Imm(v) => Some(v),
_ => None,
}
}
fn text_at(insn: &Insn, i: usize) -> Option<&'static str> {
match insn.operands.get(i)? {
Operand::Text(s) => Some(s),
_ => None,
}
}
const TEXT_W: usize = 34;
type Text = [u8; TEXT_W];
const fn put_num(mut buf: Text, mut at: usize, v: u8) -> (Text, usize) {
if v >= 10 {
buf[at] = b'0' + v / 10;
at += 1;
}
buf[at] = b'0' + v % 10;
(buf, at + 1)
}
fn text_of(row: &'static Text) -> Option<&'static str> {
let mut len = 0;
while len < TEXT_W && row[len] != 0 {
len += 1;
}
if len == 0 {
return None;
}
core::str::from_utf8(&row[..len]).ok()
}
const LIST_SHAPES: [(u8, u8); 7] = [(1, 1), (2, 1), (3, 1), (4, 1), (2, 2), (3, 2), (4, 2)];
const LIST_SUFFIXES: usize = 10;
const LIST_ROWS: usize = LIST_SHAPES.len() * LIST_SUFFIXES * 32;
const fn list_index(shape: usize, suffix: usize, base: u8) -> usize {
(shape * LIST_SUFFIXES + suffix) * 32 + base as usize
}
const fn list_row(count: u8, inc: u8, base: u8, suffix: usize) -> Text {
let mut buf = [0u8; TEXT_W];
let mut at = 0;
buf[at] = b'{';
at += 1;
if suffix == 0 && inc == 1 && count >= 3 {
buf[at] = b'd';
at += 1;
let (b, a) = put_num(buf, at, base);
buf = b;
at = a;
buf[at] = b'-';
at += 1;
buf[at] = b'd';
at += 1;
let (b, a) = put_num(buf, at, base + count - 1);
buf = b;
at = a;
} else {
let mut i = 0;
while i < count {
if i > 0 {
buf[at] = b',';
at += 1;
buf[at] = b' ';
at += 1;
}
buf[at] = b'd';
at += 1;
let (b, a) = put_num(buf, at, base + i * inc);
buf = b;
at = a;
if suffix >= 1 {
buf[at] = b'[';
at += 1;
if suffix >= 2 {
buf[at] = b'0' + (suffix as u8 - 2);
at += 1;
}
buf[at] = b']';
at += 1;
}
i += 1;
}
}
buf[at] = b'}';
buf
}
static LIST_TEXT: [Text; LIST_ROWS] = {
let mut out = [[0u8; TEXT_W]; LIST_ROWS];
let mut shape = 0;
while shape < LIST_SHAPES.len() {
let (count, inc) = LIST_SHAPES[shape];
let mut suffix = 0;
while suffix < LIST_SUFFIXES {
let mut base = 0u8;
while base < 32 {
if (base as u16) + (inc as u16) * (count as u16 - 1) < 32 {
out[list_index(shape, suffix, base)] = list_row(count, inc, base, suffix);
}
base += 1;
}
suffix += 1;
}
shape += 1;
}
out
};
fn list_text(count: u8, inc: u8, base: u8, suffix: u8) -> Option<&'static str> {
let shape = LIST_SHAPES
.iter()
.position(|&(c, i)| c == count && i == inc)?;
if suffix as usize >= LIST_SUFFIXES || base >= 32 {
return None;
}
text_of(&LIST_TEXT[list_index(shape, suffix as usize, base)])
}
fn list_fields(text: &str) -> Option<(u8, u8, u8, u8)> {
let want = text.as_bytes();
if want.is_empty() {
return None;
}
if want.len() > TEXT_W {
return None;
}
let mut shape = 0;
while shape < LIST_SHAPES.len() {
let (count, inc) = LIST_SHAPES[shape];
for suffix in 0..LIST_SUFFIXES {
for base in 0..32u8 {
let row = &LIST_TEXT[list_index(shape, suffix, base)];
let terminated = want.len() == TEXT_W || row[want.len()] == 0;
if terminated && &row[..want.len()] == want {
return Some((count, inc, base, suffix as u8));
}
}
}
shape += 1;
}
None
}
fn elem_mem(rn: u16, align: u16, rm: u16) -> Mem {
Mem {
base: Reg(rn as u8),
index: if rm == 13 || rm == 15 {
None
} else {
Some((Reg(rm as u8), None))
},
offset: 0,
add: true,
align,
mode: match rm {
15 => AddrMode::Offset,
13 => AddrMode::PostIncrement,
_ => AddrMode::PostIndex,
},
}
}
fn elem_fields(mem: &Mem) -> Option<(u16, u16, u16)> {
if mem.offset != 0 || !mem.add {
return None;
}
let rm = match (mem.mode, mem.index) {
(AddrMode::Offset, None) => 15,
(AddrMode::PostIncrement, None) => 13,
(AddrMode::PostIndex, Some((rm, None))) if rm.num() != 13 && rm.num() != 15 => {
u16::from(rm.num())
}
_ => return None,
};
Some((u16::from(mem.base.num()), mem.align, rm))
}
const ELEM_NAMES: [[[&str; 4]; 4]; 2] = [
[
["vst1.8", "vst1.16", "vst1.32", "vst1.64"],
["vst2.8", "vst2.16", "vst2.32", ""],
["vst3.8", "vst3.16", "vst3.32", ""],
["vst4.8", "vst4.16", "vst4.32", ""],
],
[
["vld1.8", "vld1.16", "vld1.32", "vld1.64"],
["vld2.8", "vld2.16", "vld2.32", ""],
["vld3.8", "vld3.16", "vld3.32", ""],
["vld4.8", "vld4.16", "vld4.32", ""],
],
];
struct MultRow {
n: u8,
count: u8,
inc: u8,
align_ok: u8,
size64: bool,
}
const MULT_ROWS: [MultRow; 16] = [
MultRow {
n: 4,
count: 4,
inc: 1,
align_ok: 0b1111,
size64: false,
}, MultRow {
n: 4,
count: 4,
inc: 2,
align_ok: 0b1111,
size64: false,
}, MultRow {
n: 1,
count: 4,
inc: 1,
align_ok: 0b1111,
size64: true,
}, MultRow {
n: 2,
count: 4,
inc: 1,
align_ok: 0b1111,
size64: false,
}, MultRow {
n: 3,
count: 3,
inc: 1,
align_ok: 0b0011,
size64: false,
}, MultRow {
n: 3,
count: 3,
inc: 2,
align_ok: 0b0011,
size64: false,
}, MultRow {
n: 1,
count: 3,
inc: 1,
align_ok: 0b0011,
size64: true,
}, MultRow {
n: 1,
count: 1,
inc: 1,
align_ok: 0b0011,
size64: true,
}, MultRow {
n: 2,
count: 2,
inc: 1,
align_ok: 0b0111,
size64: false,
}, MultRow {
n: 2,
count: 2,
inc: 2,
align_ok: 0b0111,
size64: false,
}, MultRow {
n: 1,
count: 2,
inc: 1,
align_ok: 0b0111,
size64: true,
}, MultRow {
n: 0,
count: 0,
inc: 0,
align_ok: 0,
size64: false,
}, MultRow {
n: 0,
count: 0,
inc: 0,
align_ok: 0,
size64: false,
}, MultRow {
n: 0,
count: 0,
inc: 0,
align_ok: 0,
size64: false,
}, MultRow {
n: 0,
count: 0,
inc: 0,
align_ok: 0,
size64: false,
}, MultRow {
n: 0,
count: 0,
inc: 0,
align_ok: 0,
size64: false,
}, ];
fn mult_align(align: u16) -> u16 {
match align {
1 => 64,
2 => 128,
3 => 256,
_ => 0,
}
}
fn lane_fields(n: u8, size: u16, ia: u16) -> Option<(u8, u8, u16)> {
let (index, inc, align) = match (n, size) {
(1, 0) => {
if ia & 1 != 0 {
return None;
}
(ia >> 1, 1, 0)
}
(1, 1) => {
if ia & 2 != 0 {
return None;
}
(ia >> 2, 1, if ia & 1 == 0 { 0 } else { 16 })
}
(1, 2) => {
if ia & 4 != 0 || (ia & 3 != 0 && ia & 3 != 3) {
return None;
}
(ia >> 3, 1, if ia & 3 == 0 { 0 } else { 32 })
}
(2, 0) => (ia >> 1, 1, if ia & 1 == 0 { 0 } else { 16 }),
(2, 1) => (
ia >> 2,
if ia & 2 == 0 { 1 } else { 2 },
if ia & 1 == 0 { 0 } else { 32 },
),
(2, 2) => {
if ia & 2 != 0 {
return None;
}
(
ia >> 3,
if ia & 4 == 0 { 1 } else { 2 },
if ia & 1 == 0 { 0 } else { 64 },
)
}
(3, 0) => {
if ia & 1 != 0 {
return None;
}
(ia >> 1, 1, 0)
}
(3, 1) => {
if ia & 1 != 0 {
return None;
}
(ia >> 2, if ia & 2 == 0 { 1 } else { 2 }, 0)
}
(3, 2) => {
if ia & 3 != 0 {
return None;
}
(ia >> 3, if ia & 4 == 0 { 1 } else { 2 }, 0)
}
(4, 0) => (ia >> 1, 1, if ia & 1 == 0 { 0 } else { 32 }),
(4, 1) => (
ia >> 2,
if ia & 2 == 0 { 1 } else { 2 },
if ia & 1 == 0 { 0 } else { 64 },
),
_ => {
if ia & 3 == 3 {
return None;
}
(
ia >> 3,
if ia & 4 == 0 { 1 } else { 2 },
match ia & 3 {
1 => 64,
2 => 128,
_ => 0,
},
)
}
};
Some((index as u8, inc, align))
}
fn all_lanes_fields(n: u8, size: u16, a: bool) -> Option<(u16, u16)> {
match n {
1 => {
if size == 3 || (size == 0 && a) {
return None;
}
Some((size, if a { 8 << size } else { 0 }))
}
2 => {
if size == 3 {
return None;
}
Some((size, if a { 16 << size } else { 0 }))
}
3 => {
if size == 3 || a {
return None;
}
Some((size, 0))
}
_ => {
if size == 3 {
if !a {
return None;
}
Some((2, 128))
} else if size == 2 {
Some((2, if a { 64 } else { 0 }))
} else {
Some((size, if a { 32 << size } else { 0 }))
}
}
}
}
fn elem_operands(list: &'static str, rn: u16, align: u16, rm: u16) -> Operands {
let mut ops = Operands::new();
ops.push(Operand::Text(list));
ops.push(Operand::Mem(elem_mem(rn, align, rm)));
ops
}
fn decode_elem(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw1 & 0x0010 != 0 {
return None; }
let a = (hw1 >> 7) & 1;
let l = ((hw1 >> 5) & 1) as usize;
let rn = hw1 & 0xF;
let d = dnum((hw1 >> 6) & 1, hw2 >> 12);
let rm = hw2 & 0xF;
if a == 0 {
let row = &MULT_ROWS[((hw2 >> 8) & 0xF) as usize];
if row.n == 0 {
return None;
}
let size = (hw2 >> 6) & 3;
if size == 3 && !row.size64 {
return None;
}
let align = (hw2 >> 4) & 3;
if row.align_ok & (1 << align) == 0 {
return None;
}
let name = ELEM_NAMES[l][row.n as usize - 1][size as usize];
let list = list_text(row.count, row.inc, d, 0)?;
let ops = elem_operands(list, rn, mult_align(align), rm);
return Some(simd(name, "T1", addr, ops));
}
let b = (hw2 >> 8) & 0xF;
let n = ((b & 3) + 1) as u8;
if b & 0b1100 == 0b1100 {
if l == 0 {
return None;
}
let (size, align) = all_lanes_fields(n, (hw2 >> 6) & 3, hw2 & 0x10 != 0)?;
let t = (hw2 & 0x20 != 0) as u8;
let (count, inc) = if n == 1 { (1 + t, 1) } else { (n, 1 + t) };
let name = ELEM_NAMES[l][n as usize - 1][size as usize];
let list = list_text(count, inc, d, 1)?;
let ops = elem_operands(list, rn, align, rm);
return Some(simd(name, "T1", addr, ops));
}
let size = b >> 2;
let (index, inc, align) = lane_fields(n, size, (hw2 >> 4) & 0xF)?;
let name = ELEM_NAMES[l][n as usize - 1][size as usize];
let list = list_text(n, inc, d, 2 + index)?;
let ops = elem_operands(list, rn, align, rm);
Some(simd(name, "T1", addr, ops))
}
fn encode_elem(insn: &Insn) -> Option<(u16, u16)> {
let (l, n, size) = ELEM_NAMES.iter().enumerate().find_map(|(l, per_n)| {
per_n.iter().enumerate().find_map(|(i, per_size)| {
per_size
.iter()
.position(|&s| !s.is_empty() && s == insn.mnemonic)
.map(|size| (l, i as u8 + 1, size as u16))
})
})?;
let (count, inc, base, suffix) = list_fields(text_at(insn, 0)?)?;
let mem = match insn.operands.get(1) {
Some(Operand::Mem(m)) => m,
_ => return None,
};
if insn.operands.len() != 2 {
return None;
}
let (rn, align, rm) = elem_fields(&mem)?;
let hw1 = 0xF900 | (((base as u16) >> 4) << 6) | ((l as u16) << 5) | rn;
let hw2_base = (((base as u16) & 0xF) << 12) | rm;
if suffix == 0 {
let want = (0..4u16).find(|&w| mult_align(w) == align)?;
let ty = MULT_ROWS.iter().position(|r| {
r.n == n && r.count == count && r.inc == inc && r.align_ok & (1 << want) != 0
})?;
return Some((
hw1,
hw2_base | ((ty as u16) << 8) | (size << 6) | (want << 4),
));
}
if suffix == 1 {
if l == 0 {
return None;
}
let t_set = if n == 1 {
if inc != 1 || count > 2 {
return None;
}
count == 2
} else {
if count != n {
return None;
}
inc == 2
};
for raw_size in 0..4u16 {
for a in [false, true] {
if all_lanes_fields(n, raw_size, a) == Some((size, align)) {
let t = if t_set { 0x20 } else { 0 };
let hw2 = hw2_base
| ((0b1100 | (n as u16 - 1)) << 8)
| (raw_size << 6)
| t
| if a { 0x10 } else { 0 };
return Some((hw1 | 0x0080, hw2));
}
}
}
return None;
}
if count != n || size == 3 {
return None;
}
let index = suffix - 2;
for ia in 0..16u16 {
if lane_fields(n, size, ia) == Some((index, inc, align)) {
let hw2 = hw2_base | (((size << 2) | (n as u16 - 1)) << 8) | (ia << 4);
return Some((hw1 | 0x0080, hw2));
}
}
None
}
fn decode_dp(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
if hw1 & 0x0080 == 0 {
return decode_same3(hw1, hw2, addr);
}
if hw2 & 0x0010 != 0 {
if is_modimm_escape((hw2 >> 7) & 1, hw1 & 0x3F) {
return decode_modimm(hw1, hw2, addr);
}
return decode_shift(hw1, hw2, addr);
}
if hw1 & 0x0030 != 0x0030 {
return if hw2 & 0x0040 == 0 {
decode_diff(hw1, hw2, addr)
} else {
decode_scalar(hw1, hw2, addr)
};
}
if hw1 & 0x1000 == 0 {
return decode_vext(hw1, hw2, addr);
}
match (hw2 >> 8) & 0xF {
0b0000..=0b0111 => decode_misc(hw1, hw2, addr),
0b1000..=0b1011 => decode_vtbl(hw1, hw2, addr),
0b1100 if hw2 & 0x0080 == 0 => decode_vdup(hw1, hw2, addr),
_ => None,
}
}
fn encode_dp(insn: &Insn) -> Option<(u16, u16)> {
encode_same3(insn)
.or_else(|| encode_shift(insn))
.or_else(|| encode_modimm(insn))
.or_else(|| encode_misc(insn))
.or_else(|| encode_diff(insn))
.or_else(|| encode_scalar(insn))
.or_else(|| encode_vext(insn))
.or_else(|| encode_vtbl(insn))
.or_else(|| encode_vdup(insn))
}
macro_rules! t3 {
($m:literal, $t:literal) => {
[
concat!($m, ".", $t, "8"),
concat!($m, ".", $t, "16"),
concat!($m, ".", $t, "32"),
"",
]
};
}
macro_rules! t4 {
($m:literal, $t:literal) => {
[
concat!($m, ".", $t, "8"),
concat!($m, ".", $t, "16"),
concat!($m, ".", $t, "32"),
concat!($m, ".", $t, "64"),
]
};
}
macro_rules! f2 {
($a:literal, $b:literal) => {
[concat!($a, ".f32"), "", concat!($b, ".f32"), ""]
};
}
macro_rules! f1 {
($a:literal) => {
[concat!($a, ".f32"), "", "", ""]
};
}
macro_rules! s1632 {
($m:literal) => {
["", concat!($m, ".s16"), concat!($m, ".s32"), ""]
};
}
const UNDEF4: [&str; 4] = ["", "", "", ""];
const SAME3: [[&str; 4]; 64] = [
t3!("vhadd", "s"), t4!("vqadd", "s"), t3!("vrhadd", "s"), ["vand", "vbic", "vorr", "vorn"], t3!("vhsub", "s"), t4!("vqsub", "s"), t3!("vcgt", "s"), t3!("vcge", "s"), t4!("vshl", "s"), t4!("vqshl", "s"), t4!("vrshl", "s"), t4!("vqrshl", "s"), t3!("vmax", "s"), t3!("vmin", "s"), t3!("vabd", "s"), t3!("vaba", "s"), t4!("vadd", "i"), t3!("vtst", ""), t3!("vmla", "i"), t3!("vmul", "i"), t3!("vpmax", "s"), t3!("vpmin", "s"), s1632!("vqdmulh"), t3!("vpadd", "i"), UNDEF4, f2!("vfma", "vfms"), f2!("vadd", "vsub"), f2!("vmla", "vmls"), f1!("vceq"), UNDEF4, f2!("vmax", "vmin"), f2!("vrecps", "vrsqrts"), t3!("vhadd", "u"), t4!("vqadd", "u"), t3!("vrhadd", "u"), ["veor", "vbsl", "vbit", "vbif"], t3!("vhsub", "u"), t4!("vqsub", "u"), t3!("vcgt", "u"), t3!("vcge", "u"), t4!("vshl", "u"), t4!("vqshl", "u"), t4!("vrshl", "u"), t4!("vqrshl", "u"), t3!("vmax", "u"), t3!("vmin", "u"), t3!("vabd", "u"), t3!("vaba", "u"), t4!("vsub", "i"), t3!("vceq", "i"), t3!("vmls", "i"), ["vmul.p8", "", "", ""], t3!("vpmax", "u"), t3!("vpmin", "u"), s1632!("vqrdmulh"), UNDEF4, UNDEF4, UNDEF4, f2!("vpadd", "vabd"), f1!("vmul"), f2!("vcge", "vcgt"), f2!("vacge", "vacgt"), f2!("vpmax", "vpmin"), UNDEF4, ];
fn shifts_by_register(opc: u16) -> bool {
matches!(opc, 0b0100 | 0b0101)
}
fn decode_same3(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let u = (hw1 >> 12) & 1;
let size = ((hw1 >> 4) & 3) as usize;
let opc = (hw2 >> 8) & 0xF;
let b = (hw2 >> 4) & 1;
let name = SAME3[((u << 5) | (opc << 1) | b) as usize][size];
if name.is_empty() {
return None;
}
let q = hw2 & 0x0040 != 0;
if q && name.starts_with("vp") {
return None;
}
let dd = dnum(hw1 >> 6, hw2 >> 12);
let dn = dnum(hw2 >> 7, hw1);
let dm = dnum(hw2 >> 5, hw2);
let mut ops = Operands::new();
ops.push(Operand::FpReg(vec(q, dd)?));
if name == "vorr" && dn == dm {
ops.push(Operand::FpReg(vec(q, dm)?));
return Some(simd("vmov", "T1", addr, ops));
}
let (first, second) = if shifts_by_register(opc) {
(dm, dn)
} else {
(dn, dm)
};
ops.push(Operand::FpReg(vec(q, first)?));
ops.push(Operand::FpReg(vec(q, second)?));
Some(simd(name, "T1", addr, ops))
}
fn encode_same3(insn: &Insn) -> Option<(u16, u16)> {
let alias = insn.mnemonic == "vmov" && insn.operands.len() == 2;
let name = if alias { "vorr" } else { insn.mnemonic };
let (row, size) = SAME3.iter().enumerate().find_map(|(r, cells)| {
cells
.iter()
.position(|&c| !c.is_empty() && c == name)
.map(|s| (r as u16, s as u16))
})?;
let u = row >> 5;
let opc = (row >> 1) & 0xF;
let b = row & 1;
let (qd, dd) = vec_bits(fp_at(insn, 0)?)?;
let (q1, r1) = vec_bits(fp_at(insn, 1)?)?;
let (q2, r2) = if alias {
(q1, r1)
} else {
vec_bits(fp_at(insn, 2)?)?
};
let ((qn, dn), (qm, dm)) = if shifts_by_register(opc) {
((q2, r2), (q1, r1))
} else {
((q1, r1), (q2, r2))
};
if !alias && insn.operands.len() != 3 {
return None;
}
if qd != qn || qd != qm {
return None;
}
if qd && name.starts_with("vp") {
return None;
}
let hw1 = 0xEF00 | (u << 12) | ((dd as u16 & 0x10) << 2) | (size << 4) | (dn as u16 & 0xF);
let hw2 = ((dd as u16 & 0xF) << 12)
| (opc << 8)
| ((dn as u16 & 0x10) << 3)
| if qd { 0x0040 } else { 0 }
| ((dm as u16 & 0x10) << 1)
| (b << 4)
| (dm as u16 & 0xF);
Some((hw1, hw2))
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum ShiftClass {
Right,
Left,
Narrow,
Long,
Cvt,
}
struct ShiftRow {
names: [&'static str; 4],
class: ShiftClass,
}
macro_rules! rsh {
($names:expr) => {
ShiftRow {
names: $names,
class: ShiftClass::Right,
}
};
}
macro_rules! lsh {
($names:expr) => {
ShiftRow {
names: $names,
class: ShiftClass::Left,
}
};
}
macro_rules! nsh {
($names:expr) => {
ShiftRow {
names: $names,
class: ShiftClass::Narrow,
}
};
}
macro_rules! lng {
($names:expr) => {
ShiftRow {
names: $names,
class: ShiftClass::Long,
}
};
}
macro_rules! cvt {
($names:expr) => {
ShiftRow {
names: $names,
class: ShiftClass::Cvt,
}
};
}
macro_rules! ush {
() => {
ShiftRow {
names: UNDEF4,
class: ShiftClass::Right,
}
};
}
macro_rules! n3 {
($m:literal, $t:literal) => {
[
concat!($m, ".", $t, "16"),
concat!($m, ".", $t, "32"),
concat!($m, ".", $t, "64"),
"",
]
};
}
const SHIFT_ROWS: [ShiftRow; 64] = [
rsh!(t4!("vshr", "s")), rsh!(t4!("vshr", "s")), rsh!(t4!("vsra", "s")), rsh!(t4!("vsra", "s")), rsh!(t4!("vrshr", "s")), rsh!(t4!("vrshr", "s")), rsh!(t4!("vrsra", "s")), rsh!(t4!("vrsra", "s")), ush!(), ush!(), lsh!(t4!("vshl", "i")), lsh!(t4!("vshl", "i")), ush!(), ush!(), lsh!(t4!("vqshl", "s")), lsh!(t4!("vqshl", "s")), nsh!(n3!("vshrn", "i")), nsh!(n3!("vrshrn", "i")), nsh!(n3!("vqshrn", "s")), nsh!(n3!("vqrshrn", "s")), lng!(t3!("vshll", "s")), ush!(), ush!(), ush!(), ush!(), ush!(), ush!(), ush!(), cvt!(["vcvt.f32.s32", "", "", ""]), cvt!(["vcvt.f32.s32", "", "", ""]), cvt!(["vcvt.s32.f32", "", "", ""]), cvt!(["vcvt.s32.f32", "", "", ""]), rsh!(t4!("vshr", "u")), rsh!(t4!("vshr", "u")), rsh!(t4!("vsra", "u")), rsh!(t4!("vsra", "u")), rsh!(t4!("vrshr", "u")), rsh!(t4!("vrshr", "u")), rsh!(t4!("vrsra", "u")), rsh!(t4!("vrsra", "u")), rsh!(t4!("vsri", "")), rsh!(t4!("vsri", "")), lsh!(t4!("vsli", "")), lsh!(t4!("vsli", "")), lsh!(t4!("vqshlu", "s")), lsh!(t4!("vqshlu", "s")), lsh!(t4!("vqshl", "u")), lsh!(t4!("vqshl", "u")), nsh!(n3!("vqshrun", "s")), nsh!(n3!("vqrshrun", "s")), nsh!(n3!("vqshrn", "u")), nsh!(n3!("vqrshrn", "u")), lng!(t3!("vshll", "u")), ush!(), ush!(), ush!(), ush!(), ush!(), ush!(), ush!(), cvt!(["vcvt.f32.u32", "", "", ""]), cvt!(["vcvt.f32.u32", "", "", ""]), cvt!(["vcvt.u32.f32", "", "", ""]), cvt!(["vcvt.u32.f32", "", "", ""]), ];
const VMOVL_NAMES: [[&str; 4]; 2] = [t3!("vmovl", "s"), t3!("vmovl", "u")];
fn is_modimm_escape(l: u16, imm6: u16) -> bool {
l == 0 && imm6 & 0x38 == 0
}
fn shift_code(l: u16, imm6: u16) -> usize {
if l != 0 {
3
} else if imm6 & 0x20 != 0 {
2
} else if imm6 & 0x10 != 0 {
1
} else {
0
}
}
fn shift_amount(class: ShiftClass, code: usize, imm6: u16) -> u32 {
let esize = 8u32 << code;
match class {
ShiftClass::Right | ShiftClass::Narrow => {
let base: u32 = if code == 3 { 64 } else { 16 << code };
base - imm6 as u32
}
ShiftClass::Left => imm6 as u32 - if code == 3 { 0 } else { esize },
ShiftClass::Long => imm6 as u32 - esize,
ShiftClass::Cvt => 64 - imm6 as u32,
}
}
fn decode_shift(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let u = (hw1 >> 12) & 1;
let imm6 = hw1 & 0x3F;
let row = &SHIFT_ROWS[(((u << 5) | ((hw2 >> 8) & 0xF) << 1) | ((hw2 >> 6) & 1)) as usize];
let l = (hw2 >> 7) & 1;
let q = hw2 & 0x0040 != 0;
let dd = dnum(hw1 >> 6, hw2 >> 12);
let dm = dnum(hw2 >> 5, hw2);
if row.class != ShiftClass::Right && row.class != ShiftClass::Left && l != 0 {
return None;
}
let code = if row.class == ShiftClass::Cvt {
if imm6 & 0x20 == 0 {
return None; }
0
} else {
shift_code(l, imm6)
};
let name = row.names[code];
if name.is_empty() {
return None;
}
let amount = shift_amount(row.class, code, imm6);
let mut ops = Operands::new();
match row.class {
ShiftClass::Right | ShiftClass::Left | ShiftClass::Cvt => {
ops.push(Operand::FpReg(vec(q, dd)?));
ops.push(Operand::FpReg(vec(q, dm)?));
}
ShiftClass::Narrow => {
ops.push(Operand::FpReg(FpReg::D(dd)));
ops.push(Operand::FpReg(vec(true, dm)?));
}
ShiftClass::Long => {
ops.push(Operand::FpReg(vec(true, dd)?));
ops.push(Operand::FpReg(FpReg::D(dm)));
if amount == 0 {
return Some(simd(VMOVL_NAMES[u as usize][code], "T1", addr, ops));
}
}
}
ops.push(Operand::Imm(amount as i64));
Some(simd(name, "T1", addr, ops))
}
fn encode_shift(insn: &Insn) -> Option<(u16, u16)> {
let movl = VMOVL_NAMES.iter().enumerate().find_map(|(u, n)| {
n.iter()
.position(|&c| !c.is_empty() && c == insn.mnemonic)
.map(|c| (u, c))
});
let (row_index, code) = match movl {
Some((u, code)) => (((u as u16) << 5) | (0b1010 << 1), code),
None => SHIFT_ROWS.iter().enumerate().find_map(|(r, row)| {
row.names
.iter()
.position(|&c| !c.is_empty() && c == insn.mnemonic)
.map(|c| (r as u16, c))
})?,
};
let row = &SHIFT_ROWS[row_index as usize];
let want = if movl.is_some() {
0
} else {
let v = imm_at(insn, 2)?;
if v < 0 || v > u32::MAX as i64 {
return None;
}
v as u32
};
let (qd, dd) = vec_bits(fp_at(insn, 0)?)?;
let (qm, dm) = vec_bits(fp_at(insn, 1)?)?;
let q = match row.class {
ShiftClass::Right | ShiftClass::Left | ShiftClass::Cvt => {
if qd != qm || insn.operands.len() != 3 {
return None;
}
qd
}
ShiftClass::Narrow => {
if qd || !qm || insn.operands.len() != 3 {
return None;
}
false
}
ShiftClass::Long => {
if !qd || qm || insn.operands.len() != if movl.is_some() { 2 } else { 3 } {
return None;
}
false
}
};
let l = if row.class == ShiftClass::Right || row.class == ShiftClass::Left {
(code == 3) as u16
} else {
0
};
let imm6 = (0..64u16).find(|&i| {
let c = if row.class == ShiftClass::Cvt {
if i & 0x20 == 0 {
return false;
}
0
} else {
if is_modimm_escape(l, i) {
return false;
}
shift_code(l, i)
};
c == code && shift_amount(row.class, code, i) == want
})?;
let u = row_index >> 5;
let opc = (row_index >> 1) & 0xF;
let b = row_index & 1;
let hw1 = 0xEF80 | (u << 12) | ((dd as u16 & 0x10) << 2) | imm6;
let hw2 = ((dd as u16 & 0xF) << 12)
| (opc << 8)
| (l << 7)
| if q { 0x0040 } else { (b) << 6 }
| ((dm as u16 & 0x10) << 1)
| 0x0010
| (dm as u16 & 0xF);
Some((hw1, hw2))
}
const MODIMM_NAMES: [[&str; 16]; 2] = [
[
"vmov.i32", "vorr.i32", "vmov.i32", "vorr.i32", "vmov.i32", "vorr.i32", "vmov.i32", "vorr.i32", "vmov.i16", "vorr.i16", "vmov.i16", "vorr.i16", "vmov.i32", "vmov.i32", "vmov.i8", "vmov.f32", ],
[
"vmvn.i32", "vbic.i32", "vmvn.i32", "vbic.i32", "vmvn.i32", "vbic.i32", "vmvn.i32", "vbic.i32", "vmvn.i16", "vbic.i16", "vmvn.i16", "vbic.i16", "vmvn.i32", "vmvn.i32", "vmov.i64", "", ],
];
fn modimm_needs_nonzero(cmode: u16) -> bool {
matches!(cmode >> 1, 0b001 | 0b010 | 0b011 | 0b101 | 0b110)
}
fn expand_imm(op: u16, cmode: u16, imm8: u8) -> Option<u64> {
let b = imm8 as u64;
fn rep32(v: u64) -> u64 {
v | (v << 32)
}
fn rep16(v: u64) -> u64 {
let v = v | (v << 16);
v | (v << 32)
}
Some(match cmode >> 1 {
0b000 => rep32(b),
0b001 => rep32(b << 8),
0b010 => rep32(b << 16),
0b011 => rep32(b << 24),
0b100 => rep16(b),
0b101 => rep16(b << 8),
0b110 => {
if cmode & 1 == 0 {
rep32((b << 8) | 0xFF)
} else {
rep32((b << 16) | 0xFFFF)
}
}
_ => {
if cmode & 1 == 0 && op == 0 {
let v = b | (b << 8);
let v = v | (v << 16);
v | (v << 32)
} else if cmode & 1 == 0 {
let mut v = 0u64;
for i in 0..8 {
if b & (1 << i) != 0 {
v |= 0xFFu64 << (i * 8);
}
}
v
} else if op == 0 {
let a = (b >> 7) & 1;
let bb = (b >> 6) & 1;
let c = (b >> 5) & 1;
let defgh = b & 0x1F;
rep32(
(a << 31)
| ((1 - bb) << 30)
| (if bb == 1 { 0x1F << 25 } else { 0 })
| (c << 24)
| (defgh << 19),
)
} else {
return None; }
}
})
}
fn modimm_operand(name: &str, imm64: u64) -> Operand {
if name.ends_with(".i8") {
Operand::Imm((imm64 & 0xFF) as i64)
} else if name.ends_with(".i16") {
Operand::Imm((imm64 & 0xFFFF) as i64)
} else if name.ends_with(".i32") {
Operand::Imm((imm64 & 0xFFFF_FFFF) as i64)
} else if name.ends_with(".f32") {
Operand::FpImm(f32::from_bits(imm64 as u32) as f64)
} else {
Operand::Imm(imm64 as i64)
}
}
fn decode_modimm(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let op = (hw2 >> 5) & 1;
let cmode = (hw2 >> 8) & 0xF;
let imm8 = ((((hw1 >> 12) & 1) << 7) | ((hw1 & 7) << 4) | (hw2 & 0xF)) as u8;
if imm8 == 0 && modimm_needs_nonzero(cmode) {
return None;
}
let imm64 = expand_imm(op, cmode, imm8)?;
let name = MODIMM_NAMES[op as usize][cmode as usize];
let q = hw2 & 0x0040 != 0;
let mut ops = Operands::new();
ops.push(Operand::FpReg(vec(q, dnum(hw1 >> 6, hw2 >> 12))?));
ops.push(modimm_operand(name, imm64));
Some(simd(name, "T1", addr, ops))
}
fn encode_modimm(insn: &Insn) -> Option<(u16, u16)> {
let want = match insn.operands.get(1) {
Some(v @ Operand::Imm(_)) => v,
Some(v @ Operand::FpImm(_)) => v,
_ => return None,
};
if insn.operands.len() != 2 {
return None;
}
let (qd, dd) = vec_bits(fp_at(insn, 0)?)?;
for op in 0..2u16 {
for cmode in 0..16u16 {
let name = MODIMM_NAMES[op as usize][cmode as usize];
if name != insn.mnemonic {
continue;
}
for imm8 in 0..=255u8 {
if imm8 == 0 && modimm_needs_nonzero(cmode) {
continue;
}
let got = match expand_imm(op, cmode, imm8) {
Some(v) => v,
None => continue,
};
if modimm_operand(name, got) != want {
continue;
}
let hw1 = 0xEF80
| ((imm8 as u16 >> 7) << 12)
| ((dd as u16 & 0x10) << 2)
| ((imm8 as u16 >> 4) & 7);
let hw2 = ((dd as u16 & 0xF) << 12)
| (cmode << 8)
| if qd { 0x0040 } else { 0 }
| (op << 5)
| 0x0010
| (imm8 as u16 & 0xF);
return Some((hw1, hw2));
}
}
}
None
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum MiscShape {
Same,
Zero,
Narrow,
Long,
LongMax,
}
struct MiscRow {
names: [&'static str; 4],
shape: MiscShape,
}
macro_rules! m {
($names:expr) => {
MiscRow {
names: $names,
shape: MiscShape::Same,
}
};
}
macro_rules! mz {
($names:expr) => {
MiscRow {
names: $names,
shape: MiscShape::Zero,
}
};
}
macro_rules! mn {
($names:expr) => {
MiscRow {
names: $names,
shape: MiscShape::Narrow,
}
};
}
macro_rules! ml {
($names:expr) => {
MiscRow {
names: $names,
shape: MiscShape::Long,
}
};
}
macro_rules! mx {
($names:expr) => {
MiscRow {
names: $names,
shape: MiscShape::LongMax,
}
};
}
macro_rules! mu {
() => {
MiscRow {
names: UNDEF4,
shape: MiscShape::Same,
}
};
}
const MISC_ROWS: [MiscRow; 128] = [
m!(t3!("vrev64", "")), m!(t3!("vrev64", "")), m!(["vrev32.8", "vrev32.16", "", ""]), m!(["vrev32.8", "vrev32.16", "", ""]), m!(["vrev16.8", "", "", ""]), m!(["vrev16.8", "", "", ""]), mu!(), mu!(), m!(t3!("vpaddl", "s")), m!(t3!("vpaddl", "s")), m!(t3!("vpaddl", "u")), m!(t3!("vpaddl", "u")), mu!(), mu!(), mu!(), mu!(), m!(t3!("vcls", "s")), m!(t3!("vcls", "s")), m!(t3!("vclz", "i")), m!(t3!("vclz", "i")), m!(["vcnt.8", "", "", ""]), m!(["vcnt.8", "", "", ""]), m!(["vmvn", "", "", ""]), m!(["vmvn", "", "", ""]), m!(t3!("vpadal", "s")), m!(t3!("vpadal", "s")), m!(t3!("vpadal", "u")), m!(t3!("vpadal", "u")), m!(t3!("vqabs", "s")), m!(t3!("vqabs", "s")), m!(t3!("vqneg", "s")), m!(t3!("vqneg", "s")), mz!(t3!("vcgt", "s")), mz!(t3!("vcgt", "s")), mz!(t3!("vcge", "s")), mz!(t3!("vcge", "s")), mz!(t3!("vceq", "i")), mz!(t3!("vceq", "i")), mz!(t3!("vcle", "s")), mz!(t3!("vcle", "s")), mz!(t3!("vclt", "s")), mz!(t3!("vclt", "s")), mu!(), mu!(), m!(t3!("vabs", "s")), m!(t3!("vabs", "s")), m!(t3!("vneg", "s")), m!(t3!("vneg", "s")), mz!(["", "", "vcgt.f32", ""]), mz!(["", "", "vcgt.f32", ""]), mz!(["", "", "vcge.f32", ""]), mz!(["", "", "vcge.f32", ""]), mz!(["", "", "vceq.f32", ""]), mz!(["", "", "vceq.f32", ""]), mz!(["", "", "vcle.f32", ""]), mz!(["", "", "vcle.f32", ""]), mz!(["", "", "vclt.f32", ""]), mz!(["", "", "vclt.f32", ""]), mu!(), mu!(), m!(["", "", "vabs.f32", ""]), m!(["", "", "vabs.f32", ""]), m!(["", "", "vneg.f32", ""]), m!(["", "", "vneg.f32", ""]), m!(["vswp", "", "", ""]), m!(["vswp", "", "", ""]), m!(t3!("vtrn", "")), m!(t3!("vtrn", "")), m!(["vuzp.8", "vuzp.16", "", ""]), m!(["vuzp.8", "vuzp.16", "vuzp.32", ""]), m!(["vzip.8", "vzip.16", "", ""]), m!(["vzip.8", "vzip.16", "vzip.32", ""]), mn!(["vmovn.i16", "vmovn.i32", "vmovn.i64", ""]), mn!(["vqmovun.s16", "vqmovun.s32", "vqmovun.s64", ""]), mn!(["vqmovn.s16", "vqmovn.s32", "vqmovn.s64", ""]), mn!(["vqmovn.u16", "vqmovn.u32", "vqmovn.u64", ""]), mx!(["vshll.i8", "vshll.i16", "vshll.i32", ""]), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mn!(["", "vcvt.f16.f32", "", ""]), mu!(), mu!(), mu!(), ml!(["", "vcvt.f32.f16", "", ""]), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), mu!(), m!(["", "", "vrecpe.u32", ""]), m!(["", "", "vrecpe.u32", ""]), m!(["", "", "vrsqrte.u32", ""]), m!(["", "", "vrsqrte.u32", ""]), m!(["", "", "vrecpe.f32", ""]), m!(["", "", "vrecpe.f32", ""]), m!(["", "", "vrsqrte.f32", ""]), m!(["", "", "vrsqrte.f32", ""]), m!(["", "", "vcvt.f32.s32", ""]), m!(["", "", "vcvt.f32.s32", ""]), m!(["", "", "vcvt.f32.u32", ""]), m!(["", "", "vcvt.f32.u32", ""]), m!(["", "", "vcvt.s32.f32", ""]), m!(["", "", "vcvt.s32.f32", ""]), m!(["", "", "vcvt.u32.f32", ""]), m!(["", "", "vcvt.u32.f32", ""]), ];
fn decode_misc(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let size = ((hw1 >> 2) & 3) as usize;
let row = &MISC_ROWS[(((hw1 & 3) << 5) | ((hw2 >> 6) & 0x1F)) as usize];
let name = row.names[size];
if name.is_empty() {
return None;
}
let q = hw2 & 0x0040 != 0;
let dd = dnum(hw1 >> 6, hw2 >> 12);
let dm = dnum(hw2 >> 5, hw2);
let mut ops = Operands::new();
match row.shape {
MiscShape::Same | MiscShape::Zero => {
ops.push(Operand::FpReg(vec(q, dd)?));
ops.push(Operand::FpReg(vec(q, dm)?));
if row.shape == MiscShape::Zero {
ops.push(Operand::Imm(0));
}
}
MiscShape::Narrow => {
ops.push(Operand::FpReg(FpReg::D(dd)));
ops.push(Operand::FpReg(vec(true, dm)?));
}
MiscShape::Long | MiscShape::LongMax => {
ops.push(Operand::FpReg(vec(true, dd)?));
ops.push(Operand::FpReg(FpReg::D(dm)));
if row.shape == MiscShape::LongMax {
ops.push(Operand::Imm(8 << size));
}
}
}
let enc = if name.starts_with("vshll") {
"T2"
} else {
"T1"
};
Some(simd(name, enc, addr, ops))
}
fn encode_misc(insn: &Insn) -> Option<(u16, u16)> {
let (found, size) = MISC_ROWS.iter().enumerate().find_map(|(r, row)| {
row.names
.iter()
.position(|&c| !c.is_empty() && c == insn.mnemonic)
.map(|s| (r as u16, s as u16))
})?;
let (qd, dd) = vec_bits(fp_at(insn, 0)?)?;
let (qm, dm) = vec_bits(fp_at(insn, 1)?)?;
let shape = MISC_ROWS[found as usize].shape;
let (index, want_ops) = match shape {
MiscShape::Same | MiscShape::Zero => {
if qd != qm {
return None;
}
let index = (found & !1) | qd as u16;
if MISC_ROWS[index as usize].names[size as usize] != insn.mnemonic {
return None;
}
(index, if shape == MiscShape::Zero { 3 } else { 2 })
}
MiscShape::Narrow => {
if qd || !qm {
return None;
}
(found, 2)
}
MiscShape::Long => {
if !qd || qm {
return None;
}
(found, 2)
}
MiscShape::LongMax => {
if !qd || qm || imm_at(insn, 2)? != 8 << size {
return None;
}
(found, 3)
}
};
if insn.operands.len() != want_ops {
return None;
}
if shape == MiscShape::Zero && imm_at(insn, 2)? != 0 {
return None;
}
let hw1 = 0xFFB0 | ((dd as u16 & 0x10) << 2) | (size << 2) | (index >> 5);
let hw2 = ((dd as u16 & 0xF) << 12)
| ((index & 0x1F) << 6)
| ((dm as u16 & 0x10) << 1)
| (dm as u16 & 0xF);
Some((hw1, hw2))
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum DiffShape {
Long,
Wide,
Narrow,
}
struct DiffRow {
names: [&'static str; 4],
shape: DiffShape,
enc: &'static str,
}
macro_rules! dl {
($names:expr) => {
DiffRow {
names: $names,
shape: DiffShape::Long,
enc: "T1",
}
};
}
macro_rules! dl2 {
($names:expr) => {
DiffRow {
names: $names,
shape: DiffShape::Long,
enc: "T2",
}
};
}
macro_rules! dw {
($names:expr) => {
DiffRow {
names: $names,
shape: DiffShape::Wide,
enc: "T1",
}
};
}
macro_rules! dn {
($names:expr) => {
DiffRow {
names: $names,
shape: DiffShape::Narrow,
enc: "T1",
}
};
}
macro_rules! du {
() => {
DiffRow {
names: UNDEF4,
shape: DiffShape::Long,
enc: "T1",
}
};
}
const DIFF_ROWS: [DiffRow; 32] = [
dl!(t3!("vaddl", "s")), dw!(t3!("vaddw", "s")), dl!(t3!("vsubl", "s")), dw!(t3!("vsubw", "s")), dn!(n3!("vaddhn", "i")), dl2!(t3!("vabal", "s")), dn!(n3!("vsubhn", "i")), dl2!(t3!("vabdl", "s")), dl2!(t3!("vmlal", "s")), dl!(s1632!("vqdmlal")), dl2!(t3!("vmlsl", "s")), dl!(s1632!("vqdmlsl")), dl2!(t3!("vmull", "s")), dl!(s1632!("vqdmull")), dl2!(["vmull.p8", "", "", ""]), du!(), dl!(t3!("vaddl", "u")), dw!(t3!("vaddw", "u")), dl!(t3!("vsubl", "u")), dw!(t3!("vsubw", "u")), dn!(n3!("vraddhn", "i")), dl2!(t3!("vabal", "u")), dn!(n3!("vrsubhn", "i")), dl2!(t3!("vabdl", "u")), dl2!(t3!("vmlal", "u")), du!(), dl2!(t3!("vmlsl", "u")), du!(), dl2!(t3!("vmull", "u")), du!(), du!(), du!(), ];
fn decode_diff(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let size = ((hw1 >> 4) & 3) as usize;
let row = &DIFF_ROWS[((((hw1 >> 12) & 1) << 4) | ((hw2 >> 8) & 0xF)) as usize];
let name = row.names[size];
if name.is_empty() {
return None;
}
let dd = dnum(hw1 >> 6, hw2 >> 12);
let dn = dnum(hw2 >> 7, hw1);
let dm = dnum(hw2 >> 5, hw2);
let mut ops = Operands::new();
match row.shape {
DiffShape::Long => {
ops.push(Operand::FpReg(vec(true, dd)?));
ops.push(Operand::FpReg(FpReg::D(dn)));
ops.push(Operand::FpReg(FpReg::D(dm)));
}
DiffShape::Wide => {
ops.push(Operand::FpReg(vec(true, dd)?));
ops.push(Operand::FpReg(vec(true, dn)?));
ops.push(Operand::FpReg(FpReg::D(dm)));
}
DiffShape::Narrow => {
ops.push(Operand::FpReg(FpReg::D(dd)));
ops.push(Operand::FpReg(vec(true, dn)?));
ops.push(Operand::FpReg(vec(true, dm)?));
}
}
Some(simd(name, row.enc, addr, ops))
}
fn encode_diff(insn: &Insn) -> Option<(u16, u16)> {
if insn.operands.len() != 3 {
return None;
}
let (index, size) = DIFF_ROWS.iter().enumerate().find_map(|(r, row)| {
row.names
.iter()
.position(|&c| !c.is_empty() && c == insn.mnemonic)
.map(|s| (r as u16, s as u16))
})?;
let (qd, dd) = vec_bits(fp_at(insn, 0)?)?;
let (qn, dn) = vec_bits(fp_at(insn, 1)?)?;
let (qm, dm) = vec_bits(fp_at(insn, 2)?)?;
let ok = match DIFF_ROWS[index as usize].shape {
DiffShape::Long => qd && !qn && !qm,
DiffShape::Wide => qd && qn && !qm,
DiffShape::Narrow => !qd && qn && qm,
};
if !ok {
return None;
}
let hw1 =
0xEF80 | ((index >> 4) << 12) | ((dd as u16 & 0x10) << 2) | (size << 4) | (dn as u16 & 0xF);
let hw2 = ((dd as u16 & 0xF) << 12)
| ((index & 0xF) << 8)
| ((dn as u16 & 0x10) << 3)
| ((dm as u16 & 0x10) << 1)
| (dm as u16 & 0xF);
Some((hw1, hw2))
}
struct ScalarRow {
names: [&'static str; 4],
long: bool,
enc: &'static str,
}
macro_rules! sc {
($names:expr) => {
ScalarRow {
names: $names,
long: false,
enc: "T1",
}
};
}
macro_rules! sc2 {
($names:expr) => {
ScalarRow {
names: $names,
long: false,
enc: "T2",
}
};
}
macro_rules! scl {
($names:expr) => {
ScalarRow {
names: $names,
long: true,
enc: "T2",
}
};
}
macro_rules! scu {
() => {
ScalarRow {
names: UNDEF4,
long: false,
enc: "T1",
}
};
}
macro_rules! x1632 {
($m:literal, $t:literal) => {
[
"",
concat!($m, ".", $t, "16"),
concat!($m, ".", $t, "32"),
"",
]
};
}
const SCALAR_ROWS: [ScalarRow; 32] = [
sc!(x1632!("vmla", "i")), sc!(["", "", "vmla.f32", ""]), scl!(x1632!("vmlal", "s")), scl!(x1632!("vqdmlal", "s")), sc!(x1632!("vmls", "i")), sc!(["", "", "vmls.f32", ""]), scl!(x1632!("vmlsl", "s")), scl!(x1632!("vqdmlsl", "s")), sc!(x1632!("vmul", "i")), sc!(["", "", "vmul.f32", ""]), scl!(x1632!("vmull", "s")), scl!(x1632!("vqdmull", "s")), sc2!(x1632!("vqdmulh", "s")), sc2!(x1632!("vqrdmulh", "s")), scu!(), scu!(), sc!(x1632!("vmla", "i")), sc!(["", "", "vmla.f32", ""]), scl!(x1632!("vmlal", "u")), scu!(), sc!(x1632!("vmls", "i")), sc!(["", "", "vmls.f32", ""]), scl!(x1632!("vmlsl", "u")), scu!(), sc!(x1632!("vmul", "i")), sc!(["", "", "vmul.f32", ""]), scl!(x1632!("vmull", "u")), scu!(), sc2!(x1632!("vqdmulh", "s")), sc2!(x1632!("vqrdmulh", "s")), scu!(), scu!(), ];
fn scalar_operand(size: u16, m: u16, vm: u16) -> Operand {
if size == 1 {
Operand::FpScalar(FpReg::D((vm & 7) as u8), ((m << 1) | ((vm >> 3) & 1)) as u8)
} else {
Operand::FpScalar(FpReg::D((vm & 0xF) as u8), m as u8)
}
}
fn scalar_bits(size: u16, reg: FpReg, index: u8) -> Option<(u16, u16)> {
match (size, reg) {
(1, FpReg::D(n)) if n < 8 && index < 4 => Some((
(index >> 1) as u16,
(n as u16) | (((index & 1) as u16) << 3),
)),
(2, FpReg::D(n)) if n < 16 && index < 2 => Some((index as u16, n as u16)),
_ => None,
}
}
fn decode_scalar(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let u = (hw1 >> 12) & 1;
let size = (hw1 >> 4) & 3;
let row = &SCALAR_ROWS[((u << 4) | ((hw2 >> 8) & 0xF)) as usize];
let name = row.names[size as usize];
if name.is_empty() {
return None;
}
let dd = dnum(hw1 >> 6, hw2 >> 12);
let dn = dnum(hw2 >> 7, hw1);
let scalar = scalar_operand(size, (hw2 >> 5) & 1, hw2 & 0xF);
let mut ops = Operands::new();
if row.long {
ops.push(Operand::FpReg(vec(true, dd)?));
ops.push(Operand::FpReg(FpReg::D(dn)));
} else {
let q = u == 1;
ops.push(Operand::FpReg(vec(q, dd)?));
ops.push(Operand::FpReg(vec(q, dn)?));
}
ops.push(scalar);
Some(simd(name, row.enc, addr, ops))
}
fn encode_scalar(insn: &Insn) -> Option<(u16, u16)> {
let (index, scalar_index) = match insn.operands.get(2) {
Some(Operand::FpScalar(r, i)) => (r, i),
_ => return None,
};
if insn.operands.len() != 3 {
return None;
}
let (found, size) = SCALAR_ROWS.iter().enumerate().find_map(|(r, row)| {
row.names
.iter()
.position(|&c| !c.is_empty() && c == insn.mnemonic)
.map(|s| (r as u16, s as u16))
})?;
let (qd, dd) = vec_bits(fp_at(insn, 0)?)?;
let (qn, dn) = vec_bits(fp_at(insn, 1)?)?;
let row = &SCALAR_ROWS[found as usize];
let u = if row.long {
if !qd || qn {
return None;
}
found >> 4
} else {
if qd != qn {
return None;
}
qd as u16
};
let a = found & 0xF;
let (m, vm) = scalar_bits(size, index, scalar_index)?;
let hw1 = 0xEF80 | (u << 12) | ((dd as u16 & 0x10) << 2) | (size << 4) | (dn as u16 & 0xF);
let hw2 =
((dd as u16 & 0xF) << 12) | (a << 8) | ((dn as u16 & 0x10) << 3) | 0x0040 | (m << 5) | vm;
Some((hw1, hw2))
}
fn decode_vext(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let q = hw2 & 0x0040 != 0;
let imm4 = (hw2 >> 8) & 0xF;
if !q && imm4 & 0x8 != 0 {
return None; }
let mut ops = Operands::new();
ops.push(Operand::FpReg(vec(q, dnum(hw1 >> 6, hw2 >> 12))?));
ops.push(Operand::FpReg(vec(q, dnum(hw2 >> 7, hw1))?));
ops.push(Operand::FpReg(vec(q, dnum(hw2 >> 5, hw2))?));
ops.push(Operand::Imm(imm4 as i64));
Some(simd("vext.8", "T1", addr, ops))
}
fn encode_vext(insn: &Insn) -> Option<(u16, u16)> {
if insn.mnemonic != "vext.8" || insn.operands.len() != 4 {
return None;
}
let (qd, dd) = vec_bits(fp_at(insn, 0)?)?;
let (qn, dn) = vec_bits(fp_at(insn, 1)?)?;
let (qm, dm) = vec_bits(fp_at(insn, 2)?)?;
if qd != qn || qd != qm {
return None;
}
let imm4 = imm_at(insn, 3)?;
if imm4 < 0 || imm4 > if qd { 15 } else { 7 } {
return None;
}
let hw1 = 0xEFB0 | ((dd as u16 & 0x10) << 2) | (dn as u16 & 0xF);
let hw2 = ((dd as u16 & 0xF) << 12)
| ((imm4 as u16) << 8)
| ((dn as u16 & 0x10) << 3)
| if qd { 0x0040 } else { 0 }
| ((dm as u16 & 0x10) << 1)
| (dm as u16 & 0xF);
Some((hw1, hw2))
}
fn decode_vtbl(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let name = if hw2 & 0x0040 == 0 {
"vtbl.8"
} else {
"vtbx.8"
};
let len = ((hw2 >> 8) & 3) as u8 + 1;
let list = list_text(len, 1, dnum(hw2 >> 7, hw1), 0)?;
let mut ops = Operands::new();
ops.push(Operand::FpReg(FpReg::D(dnum(hw1 >> 6, hw2 >> 12))));
ops.push(Operand::Text(list));
ops.push(Operand::FpReg(FpReg::D(dnum(hw2 >> 5, hw2))));
Some(simd(name, "T1", addr, ops))
}
fn encode_vtbl(insn: &Insn) -> Option<(u16, u16)> {
let op = match insn.mnemonic {
"vtbl.8" => 0u16,
"vtbx.8" => 1,
_ => return None,
};
if insn.operands.len() != 3 {
return None;
}
let (qd, dd) = vec_bits(fp_at(insn, 0)?)?;
let (qm, dm) = vec_bits(fp_at(insn, 2)?)?;
if qd || qm {
return None;
}
let (count, inc, dn, suffix) = list_fields(text_at(insn, 1)?)?;
if inc != 1 || suffix != 0 || count > 4 {
return None;
}
let hw1 = 0xFFB0 | ((dd as u16 & 0x10) << 2) | (dn as u16 & 0xF);
let hw2 = ((dd as u16 & 0xF) << 12)
| (0b10 << 10)
| (((count as u16) - 1) << 8)
| ((dn as u16 & 0x10) << 3)
| (op << 6)
| ((dm as u16 & 0x10) << 1)
| (dm as u16 & 0xF);
Some((hw1, hw2))
}
fn vdup_fields(imm4: u16) -> Option<(usize, u8)> {
if imm4 & 1 != 0 {
Some((0, (imm4 >> 1) as u8))
} else if imm4 & 2 != 0 {
Some((1, (imm4 >> 2) as u8))
} else if imm4 & 4 != 0 {
Some((2, (imm4 >> 3) as u8))
} else {
None
}
}
const VDUP_NAMES: [&str; 3] = ["vdup.8", "vdup.16", "vdup.32"];
fn decode_vdup(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
let (size, index) = vdup_fields(hw1 & 0xF)?;
let q = hw2 & 0x0040 != 0;
let mut ops = Operands::new();
ops.push(Operand::FpReg(vec(q, dnum(hw1 >> 6, hw2 >> 12))?));
ops.push(Operand::FpScalar(FpReg::D(dnum(hw2 >> 5, hw2)), index));
Some(simd(VDUP_NAMES[size], "T1", addr, ops))
}
fn encode_vdup(insn: &Insn) -> Option<(u16, u16)> {
let size = VDUP_NAMES.iter().position(|&n| n == insn.mnemonic)? as u16;
let (dm, index) = match insn.operands.get(1) {
Some(Operand::FpScalar(FpReg::D(n), i)) => (n, i),
_ => return None,
};
if insn.operands.len() != 2 {
return None;
}
let (qd, dd) = vec_bits(fp_at(insn, 0)?)?;
let imm4 = (0..16u16).find(|&i| vdup_fields(i) == Some((size as usize, index)))?;
let hw1 = 0xFFB0 | ((dd as u16 & 0x10) << 2) | imm4;
let hw2 = ((dd as u16 & 0xF) << 12)
| (0b1100 << 8)
| if qd { 0x0040 } else { 0 }
| ((dm as u16 & 0x10) << 1)
| (dm as u16 & 0xF);
Some((hw1, hw2))
}
pub(crate) fn decode(hw1: u16, hw2: u16, addr: u32) -> Option<Insn> {
match hw1 >> 8 {
0xF9 => decode_elem(hw1, hw2, addr),
0xEF | 0xFF => decode_dp(hw1, hw2, addr),
_ => None,
}
}
pub(crate) fn encode(insn: &Insn) -> Option<(u16, u16)> {
if insn.width != Width::Wide || insn.sets_flags || insn.explicit_width {
return None;
}
encode_elem(insn).or_else(|| encode_dp(insn))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::isa::Target;
#[test]
fn list_fields_refuses_spellings_no_row_can_hold() {
assert_eq!(list_fields(""), None, "an empty spelling is in no row");
let too_long = "d".repeat(TEXT_W + 1);
assert_eq!(list_fields(&too_long), None, "longer than any cell");
assert_eq!(
list_fields("{d0}"),
Some((1, 1, 0, 0)),
"the inverse of list_text for a one-register list"
);
}
fn round_trip(hw1: u16, hw2: u16) -> bool {
match decode(hw1, hw2, 0x1000) {
None => false,
Some(insn) => {
let back = encode(&insn);
assert_eq!(
back,
Some((hw1, hw2)),
"{insn} decoded from {hw1:#06x} {hw2:#06x} re-encoded as {back:x?}"
);
true
}
}
}
const DREGS: [u16; 5] = [0, 1, 15, 16, 31];
const QREGS: [u16; 7] = [0, 2, 14, 30, 28, 26, 1];
fn split(d: u16) -> (u16, u16) {
((d >> 4) & 1, d & 0xF)
}
#[test]
fn sweep_multiple_element() {
let mut n = 0;
for l in 0..2u16 {
for ty in 0..16u16 {
for size in 0..4u16 {
for align in 0..4u16 {
for &d in &DREGS {
for rm in [0u16, 3, 13, 15] {
let (dh, dl) = split(d);
let hw1 = 0xF900 | (dh << 6) | (l << 5) | 7;
let hw2 = (dl << 12) | (ty << 8) | (size << 6) | (align << 4) | rm;
n += round_trip(hw1, hw2) as usize;
}
}
}
}
}
}
assert_eq!(n, 3584, "multiple-element forms decoded");
}
#[test]
fn sweep_single_lane() {
let mut n = 0;
for l in 0..2u16 {
for size in 0..4u16 {
for nn in 0..4u16 {
for ia in 0..16u16 {
for &d in &DREGS {
for rm in [0u16, 3, 13, 15] {
let (dh, dl) = split(d);
let hw1 = 0xF980 | (dh << 6) | (l << 5) | 7;
let hw2 = (dl << 12) | (size << 10) | (nn << 8) | (ia << 4) | rm;
n += round_trip(hw1, hw2) as usize;
}
}
}
}
}
}
assert_eq!(n, 4820, "single-lane and all-lanes forms decoded");
}
type LaneFields = Option<(u8, u8, u16)>;
#[rustfmt::skip]
const LANE_INDEX_ALIGN: [[[LaneFields; 16]; 3]; 4] = [
[ [ Some((0, 1, 0)), None, Some((1, 1, 0)), None,
Some((2, 1, 0)), None, Some((3, 1, 0)), None,
Some((4, 1, 0)), None, Some((5, 1, 0)), None,
Some((6, 1, 0)), None, Some((7, 1, 0)), None,
],
[ Some((0, 1, 0)), Some((0, 1, 16)), None, None,
Some((1, 1, 0)), Some((1, 1, 16)), None, None,
Some((2, 1, 0)), Some((2, 1, 16)), None, None,
Some((3, 1, 0)), Some((3, 1, 16)), None, None,
],
[ Some((0, 1, 0)), None, None, Some((0, 1, 32)),
None, None, None, None,
Some((1, 1, 0)), None, None, Some((1, 1, 32)),
None, None, None, None,
],
],
[ [ Some((0, 1, 0)), Some((0, 1, 16)), Some((1, 1, 0)), Some((1, 1, 16)),
Some((2, 1, 0)), Some((2, 1, 16)), Some((3, 1, 0)), Some((3, 1, 16)),
Some((4, 1, 0)), Some((4, 1, 16)), Some((5, 1, 0)), Some((5, 1, 16)),
Some((6, 1, 0)), Some((6, 1, 16)), Some((7, 1, 0)), Some((7, 1, 16)),
],
[ Some((0, 1, 0)), Some((0, 1, 32)), Some((0, 2, 0)), Some((0, 2, 32)),
Some((1, 1, 0)), Some((1, 1, 32)), Some((1, 2, 0)), Some((1, 2, 32)),
Some((2, 1, 0)), Some((2, 1, 32)), Some((2, 2, 0)), Some((2, 2, 32)),
Some((3, 1, 0)), Some((3, 1, 32)), Some((3, 2, 0)), Some((3, 2, 32)),
],
[ Some((0, 1, 0)), Some((0, 1, 64)), None, None,
Some((0, 2, 0)), Some((0, 2, 64)), None, None,
Some((1, 1, 0)), Some((1, 1, 64)), None, None,
Some((1, 2, 0)), Some((1, 2, 64)), None, None,
],
],
[ [ Some((0, 1, 0)), None, Some((1, 1, 0)), None,
Some((2, 1, 0)), None, Some((3, 1, 0)), None,
Some((4, 1, 0)), None, Some((5, 1, 0)), None,
Some((6, 1, 0)), None, Some((7, 1, 0)), None,
],
[ Some((0, 1, 0)), None, Some((0, 2, 0)), None,
Some((1, 1, 0)), None, Some((1, 2, 0)), None,
Some((2, 1, 0)), None, Some((2, 2, 0)), None,
Some((3, 1, 0)), None, Some((3, 2, 0)), None,
],
[ Some((0, 1, 0)), None, None, None,
Some((0, 2, 0)), None, None, None,
Some((1, 1, 0)), None, None, None,
Some((1, 2, 0)), None, None, None,
],
],
[ [ Some((0, 1, 0)), Some((0, 1, 32)), Some((1, 1, 0)), Some((1, 1, 32)),
Some((2, 1, 0)), Some((2, 1, 32)), Some((3, 1, 0)), Some((3, 1, 32)),
Some((4, 1, 0)), Some((4, 1, 32)), Some((5, 1, 0)), Some((5, 1, 32)),
Some((6, 1, 0)), Some((6, 1, 32)), Some((7, 1, 0)), Some((7, 1, 32)),
],
[ Some((0, 1, 0)), Some((0, 1, 64)), Some((0, 2, 0)), Some((0, 2, 64)),
Some((1, 1, 0)), Some((1, 1, 64)), Some((1, 2, 0)), Some((1, 2, 64)),
Some((2, 1, 0)), Some((2, 1, 64)), Some((2, 2, 0)), Some((2, 2, 64)),
Some((3, 1, 0)), Some((3, 1, 64)), Some((3, 2, 0)), Some((3, 2, 64)),
],
[ Some((0, 1, 0)), Some((0, 1, 64)), Some((0, 1, 128)), None,
Some((0, 2, 0)), Some((0, 2, 64)), Some((0, 2, 128)), None,
Some((1, 1, 0)), Some((1, 1, 64)), Some((1, 1, 128)), None,
Some((1, 2, 0)), Some((1, 2, 64)), Some((1, 2, 128)), None,
],
],
];
#[test]
fn index_align_names_the_lane_the_manual_gives_it() {
for (i, per_size) in LANE_INDEX_ALIGN.iter().enumerate() {
let n = i as u8 + 1;
for (size, want) in per_size.iter().enumerate() {
for (ia, &expect) in want.iter().enumerate() {
assert_eq!(
lane_fields(n, size as u16, ia as u16),
expect,
"VLD{n} size {size:#04b} index_align {ia:#06b}"
);
}
}
}
}
type AllLanesFields = Option<(u16, u16)>;
#[rustfmt::skip]
const ALL_LANES: [[[AllLanesFields; 2]; 4]; 4] = [
[ [Some((0, 0)), None ],
[Some((1, 0)), Some((1, 16)) ],
[Some((2, 0)), Some((2, 32)) ],
[None, None ],
],
[ [Some((0, 0)), Some((0, 16)) ],
[Some((1, 0)), Some((1, 32)) ],
[Some((2, 0)), Some((2, 64)) ],
[None, None ],
],
[ [Some((0, 0)), None ],
[Some((1, 0)), None ],
[Some((2, 0)), None ],
[None, None ],
],
[ [Some((0, 0)), Some((0, 32)) ],
[Some((1, 0)), Some((1, 64)) ],
[Some((2, 0)), Some((2, 64)) ],
[None, Some((2, 128)) ],
],
];
#[test]
fn the_all_lanes_forms_align_where_their_pages_say_they_do() {
for (i, per_size) in ALL_LANES.iter().enumerate() {
let n = i as u8 + 1;
for (size, want) in per_size.iter().enumerate() {
for (a, &expect) in want.iter().enumerate() {
assert_eq!(
all_lanes_fields(n, size as u16, a == 1),
expect,
"VLD{n} size {size:#04b} a = {a}"
);
}
}
}
}
#[test]
fn sweep_three_same() {
let mut n = 0;
for u in 0..2u16 {
for opc in 0..16u16 {
for b in 0..2u16 {
for size in 0..4u16 {
for q in 0..2u16 {
let regs: &[u16] = if q == 1 { &QREGS } else { &DREGS };
for (i, &d) in regs.iter().enumerate() {
let (dh, dl) = split(d);
let (nh, nl) = split(regs[(i + 1) % regs.len()]);
let (mh, ml) = split(regs[(i + 2) % regs.len()]);
let hw1 = 0xEF00 | (u << 12) | (dh << 6) | (size << 4) | nl;
let hw2 = (dl << 12)
| (opc << 8)
| (nh << 7)
| (q << 6)
| (mh << 5)
| (b << 4)
| ml;
n += round_trip(hw1, hw2) as usize;
}
}
}
}
}
}
assert_eq!(n, 1485, "three-registers-same forms decoded");
}
#[test]
fn sweep_two_shift() {
let mut n = 0;
for u in 0..2u16 {
for opc in 0..16u16 {
for l in 0..2u16 {
for q in 0..2u16 {
for imm6 in 0..64u16 {
if l == 0 && imm6 < 8 {
continue; }
let regs: &[u16] = if q == 1 { &QREGS } else { &DREGS };
for (i, &d) in regs.iter().enumerate() {
let (dh, dl) = split(d);
let (mh, ml) = split(regs[(i + 1) % regs.len()]);
let hw1 = 0xEF80 | (u << 12) | (dh << 6) | imm6;
let hw2 = (dl << 12)
| (opc << 8)
| (l << 7)
| (q << 6)
| (mh << 5)
| 0x0010
| ml;
n += round_trip(hw1, hw2) as usize;
}
}
}
}
}
}
assert_eq!(n, 20096, "two-registers-and-shift forms decoded");
}
#[test]
fn sweep_modimm() {
let mut n = 0;
for i in 0..2u16 {
for op in 0..2u16 {
for cmode in 0..16u16 {
for q in 0..2u16 {
for imm in [0u16, 1, 0xAB, 0xFF] {
let regs: &[u16] = if q == 1 { &QREGS } else { &DREGS };
for &d in regs {
let (dh, dl) = split(d);
let hw1 = 0xEF80 | (i << 12) | (dh << 6) | ((imm >> 4) & 7);
let hw2 = (dl << 12)
| (cmode << 8)
| (q << 6)
| (op << 5)
| 0x0010
| (imm & 0xF);
n += round_trip(hw1, hw2) as usize;
}
}
}
}
}
}
assert_eq!(n, 2508, "modified-immediate forms decoded");
}
#[test]
fn sweep_two_misc() {
let mut n = 0;
for a in 0..4u16 {
for b in 0..32u16 {
for size in 0..4u16 {
let q = b & 1;
let regs: &[u16] = if q == 1 { &QREGS } else { &DREGS };
for (i, &d) in regs.iter().enumerate() {
let (dh, dl) = split(d);
let (mh, ml) = split(regs[(i + 1) % regs.len()]);
let hw1 = 0xFFB0 | (dh << 6) | (size << 2) | a;
let hw2 = (dl << 12) | (b << 6) | (mh << 5) | ml;
n += round_trip(hw1, hw2) as usize;
}
}
}
}
assert_eq!(n, 828, "two-registers-miscellaneous forms decoded");
}
#[test]
fn sweep_three_diff() {
let mut n = 0;
for u in 0..2u16 {
for a in 0..16u16 {
for size in 0..3u16 {
for (i, &d) in QREGS.iter().enumerate() {
let (dh, dl) = split(d);
let (nh, nl) = split(QREGS[(i + 1) % QREGS.len()]);
let (mh, ml) = split(QREGS[(i + 2) % QREGS.len()]);
let hw1 = 0xEF80 | (u << 12) | (dh << 6) | (size << 4) | nl;
let hw2 = (dl << 12) | (a << 8) | (nh << 7) | (mh << 5) | ml;
n += round_trip(hw1, hw2) as usize;
}
}
}
}
assert_eq!(n, 414, "three-registers-different-lengths forms decoded");
}
#[test]
fn sweep_vmov_register_alias() {
let mut n = 0;
for q in 0..2u16 {
let regs: &[u16] = if q == 1 { &QREGS } else { &DREGS };
for (i, &d) in regs.iter().enumerate() {
let src = regs[(i + 1) % regs.len()];
let (dh, dl) = split(d);
let (sh, sl) = split(src);
let hw1 = 0xEF20 | (dh << 6) | sl;
let hw2 =
(dl << 12) | (0b0001 << 8) | (sh << 7) | (q << 6) | (sh << 5) | 0x0010 | sl;
n += round_trip(hw1, hw2) as usize;
}
}
assert_eq!(n, 10, "VMOV (register) forms decoded");
}
#[test]
fn sweep_two_scalar() {
let mut n = 0;
for u in 0..2u16 {
for a in 0..16u16 {
for size in 0..3u16 {
for &d in &DREGS {
let (dh, dl) = split(d);
let hw1 = 0xEF80 | (u << 12) | (dh << 6) | (size << 4);
let hw2 = (dl << 12) | (a << 8) | 0x0080 | 0x0040 | 3;
n += round_trip(hw1, hw2) as usize;
}
}
}
}
assert_eq!(n, 127, "two-registers-and-a-scalar forms decoded");
}
#[test]
fn sweep_vext_vtbl_vdup() {
let mut ext = 0;
for imm4 in 0..16u16 {
for q in 0..2u16 {
let regs: &[u16] = if q == 1 { &QREGS } else { &DREGS };
for (i, &d) in regs.iter().enumerate() {
let (dh, dl) = split(d);
let (nh, nl) = split(regs[(i + 1) % regs.len()]);
let (mh, ml) = split(regs[(i + 2) % regs.len()]);
let hw1 = 0xEFB0 | (dh << 6) | nl;
let hw2 = (dl << 12) | (imm4 << 8) | (nh << 7) | (q << 6) | (mh << 5) | ml;
ext += round_trip(hw1, hw2) as usize;
}
}
}
assert_eq!(ext, 104, "VEXT forms decoded");
let mut tbl = 0;
for len in 0..4u16 {
for op in 0..2u16 {
for &d in &DREGS {
let (dh, dl) = split(d);
let (nh, nl) = split(d);
let hw1 = 0xFFB0 | (dh << 6) | nl;
let hw2 = (dl << 12) | (0b10 << 10) | (len << 8) | (nh << 7) | (op << 6) | 1;
tbl += round_trip(hw1, hw2) as usize;
}
}
}
assert_eq!(tbl, 34, "VTBL/VTBX forms decoded");
let mut dup = 0;
for imm4 in 0..16u16 {
for q in 0..2u16 {
let regs: &[u16] = if q == 1 { &QREGS } else { &DREGS };
for &d in regs {
let (dh, dl) = split(d);
let hw1 = 0xFFB0 | (dh << 6) | imm4;
let hw2 = (dl << 12) | (0b1100 << 8) | (q << 6) | 5;
dup += round_trip(hw1, hw2) as usize;
}
}
}
assert_eq!(dup, 154, "VDUP (scalar) forms decoded");
}
#[rustfmt::skip]
const VDUP_IMM4: [Option<(usize, u8)>; 16] = [
None, Some((0, 0)), Some((1, 0)), Some((0, 1)),
Some((2, 0)), Some((0, 2)), Some((1, 1)), Some((0, 3)),
None, Some((0, 4)), Some((1, 2)), Some((0, 5)),
Some((2, 1)), Some((0, 6)), Some((1, 3)), Some((0, 7)),
];
#[test]
fn vdup_reads_its_element_size_off_the_bottom_of_imm4() {
for (imm4, &expect) in VDUP_IMM4.iter().enumerate() {
assert_eq!(vdup_fields(imm4 as u16), expect, "imm4 {imm4:#06b}");
}
}
#[test]
fn quadword_is_the_even_doubleword_pair() {
let insn = decode(0xEF20, 0x0840, 0).expect("q-form with even D:Vd");
assert_eq!(insn.to_string(), "vadd.i32 q0, q0, q0");
assert_eq!(decode(0xEF20, 0x1840, 0), None);
assert_eq!(decode(0xEF21, 0x0840, 0), None);
assert_eq!(decode(0xEF20, 0x0841, 0), None);
let q3 = decode(0xEF20, 0x6840, 0).expect("q3");
assert_eq!(q3.to_string(), "vadd.i32 q3, q0, q0");
assert_eq!(encode(&q3), Some((0xEF20, 0x6840)));
let q15 = decode(0xEF60, 0xE840, 0).expect("q15");
assert_eq!(q15.to_string(), "vadd.i32 q15, q0, q0");
assert_eq!(encode(&q15), Some((0xEF60, 0xE840)));
let d1 = decode(0xEF20, 0x1800, 0).expect("d1");
assert_eq!(d1.to_string(), "vadd.i32 d1, d0, d0");
}
#[test]
fn advsimd_expand_imm_matches_table_a7_15() {
assert_eq!(expand_imm(0, 0b0000, 0xAB), Some(0x0000_00AB_0000_00AB));
assert_eq!(expand_imm(0, 0b0010, 0xAB), Some(0x0000_AB00_0000_AB00));
assert_eq!(expand_imm(0, 0b0100, 0xAB), Some(0x00AB_0000_00AB_0000));
assert_eq!(expand_imm(0, 0b0110, 0xAB), Some(0xAB00_0000_AB00_0000));
assert_eq!(expand_imm(0, 0b1000, 0xAB), Some(0x00AB_00AB_00AB_00AB));
assert_eq!(expand_imm(0, 0b1010, 0xAB), Some(0xAB00_AB00_AB00_AB00));
assert_eq!(expand_imm(0, 0b1100, 0xAB), Some(0x0000_ABFF_0000_ABFF));
assert_eq!(expand_imm(0, 0b1101, 0xAB), Some(0x00AB_FFFF_00AB_FFFF));
assert_eq!(expand_imm(0, 0b1110, 0xAB), Some(0xABAB_ABAB_ABAB_ABAB));
assert_eq!(expand_imm(1, 0b1110, 0xAB), Some(0xFF00_FF00_FF00_FFFF));
assert_eq!(expand_imm(0, 0b1111, 0x00), Some(0x4000_0000_4000_0000));
assert_eq!(expand_imm(0, 0b1111, 0x70), Some(0x3F80_0000_3F80_0000));
assert_eq!(expand_imm(1, 0b1111, 0xAB), None);
}
#[test]
fn advsimd_expand_imm_inverse_rejects_what_it_cannot_build() {
let mut ops = Operands::new();
ops.push(Operand::FpReg(FpReg::D(0)));
ops.push(Operand::Imm(0x1234_5678));
let insn = simd("vmov.i32", "T1", 0, ops);
assert_eq!(
encode(&insn),
None,
"0x12345678 is not a modified immediate"
);
let mut ops = Operands::new();
ops.push(Operand::FpReg(FpReg::D(0)));
ops.push(Operand::Imm(0x0000_AB00));
let insn = simd("vmov.i32", "T1", 0, ops);
let (hw1, hw2) = encode(&insn).expect("imm8 << 8 is cmode 0b0010");
assert_eq!((hw2 >> 8) & 0xF, 0b0010);
assert_eq!(
decode(hw1, hw2, 0).unwrap().to_string(),
"vmov.i32 d0, #0xab00"
);
}
fn show(hw1: u16, hw2: u16) -> String {
decode(hw1, hw2, 0x100)
.expect("halfwords decode")
.to_string()
}
#[test]
fn the_dispatcher_routes_the_load_store_space_here() {
let insn =
crate::isa::decode_halfwords(0xF920, 0x070F, 0, Target::Union).expect("routed here");
assert_eq!(insn.to_string(), "vld1.8 {d0}, [r0]");
assert_eq!(crate::isa::encode(&insn), Some((0xF920, 0x070F)));
assert_eq!(
crate::isa::encode_bytes(&insn),
Some(vec![0x20, 0xF9, 0x0F, 0x07])
);
}
#[test]
fn declines_what_belongs_to_the_coprocessor_module() {
let mut ops = Operands::new();
ops.push(Operand::FpReg(FpReg::S(0)));
ops.push(Operand::FpReg(FpReg::S(1)));
ops.push(Operand::FpReg(FpReg::S(2)));
assert_eq!(encode(&simd("vadd.f32", "T2", 0, ops)), None);
let mut ops = Operands::new();
ops.push(Operand::Reg(Reg(0)));
ops.push(Operand::Reg(Reg(1)));
ops.push(Operand::FpReg(FpReg::D(2)));
assert_eq!(encode(&simd("vmov", "T1", 0, ops)), None);
let mut ops = Operands::new();
ops.push(Operand::FpReg(FpReg::D(0)));
ops.push(Operand::FpReg(FpReg::D(1)));
assert_eq!(encode(&simd("vmov.f64", "T2", 0, ops)), None);
let mut narrow = simd("vmov", "T1", 0, Operands::new());
narrow.width = Width::Narrow;
assert_eq!(encode(&narrow), None);
}
#[test]
fn prints_ual_element_and_structure_loads() {
assert_eq!(show(0xF920, 0x070F), "vld1.8 {d0}, [r0]");
assert_eq!(show(0xF901, 0x00AD), "vst4.32 {d0-d3}, [r1:128]!");
assert_eq!(show(0xF920, 0x0703), "vld1.8 {d0}, [r0], r3");
assert_eq!(show(0xF960, 0x0A1F), "vld1.8 {d16, d17}, [r0:64]");
assert_eq!(show(0xF921, 0x090F), "vld2.8 {d0, d2}, [r1]");
assert_eq!(show(0xF922, 0x144F), "vld3.16 {d1-d3}, [r2]");
assert_eq!(show(0xF9A0, 0x04DF), "vld1.16 {d0[3]}, [r0:16]");
assert_eq!(show(0xF9A0, 0x0CAF), "vld1.32 {d0[], d1[]}, [r0]");
assert_eq!(
show(0xF983, 0x3BCF),
"vst4.32 {d3[1], d5[1], d7[1], d9[1]}, [r3]"
);
}
#[test]
fn prints_ual_data_processing() {
assert_eq!(show(0xEF20, 0x0840), "vadd.i32 q0, q0, q0");
assert_eq!(show(0xEF01, 0x2002), "vhadd.s8 d2, d1, d2");
assert_eq!(show(0xFF41, 0x2812), "vceq.i8 d18, d1, d2");
assert_eq!(show(0xEF02, 0x1114), "vand d1, d2, d4");
assert_eq!(show(0xFF12, 0x1114), "vbsl d1, d2, d4");
assert_eq!(show(0xEF02, 0x1D04), "vadd.f32 d1, d2, d4");
assert_eq!(show(0xEF22, 0x1D04), "vsub.f32 d1, d2, d4");
assert_eq!(show(0xEF24, 0x1114), "vmov d1, d4");
assert_eq!(show(0xEF02, 0x1B10), "vpadd.i8 d1, d2, d0");
assert_eq!(show(0xEF01, 0x14AF), "vshl.s8 d1, d31, d17");
assert_eq!(show(0xEF9B, 0x3014), "vshr.s16 d3, d4, #5");
assert_eq!(show(0xFF88, 0x0514), "vsli.8 d0, d4, #0");
assert_eq!(show(0xEF8D, 0x0810), "vshrn.i16 d0, q0, #3");
assert_eq!(show(0xEF88, 0x0A10), "vmovl.s8 q0, d0");
assert_eq!(show(0xEF89, 0x0A10), "vshll.s8 q0, d0, #1");
assert_eq!(show(0xEFBF, 0x0E10), "vcvt.f32.s32 d0, d0, #1");
assert_eq!(show(0xFF87, 0x001F), "vmov.i32 d0, #0xff");
assert_eq!(show(0xFF87, 0x083F), "vmvn.i16 d0, #0xff");
assert_eq!(show(0xFF87, 0x011F), "vorr.i32 d0, #0xff");
assert_eq!(show(0xFF87, 0x093F), "vbic.i16 d0, #0xff");
assert_eq!(show(0xFFB0, 0x0000), "vrev64.8 d0, d0");
assert_eq!(show(0xFFB0, 0x0540), "vcnt.8 q0, q0");
assert_eq!(show(0xFFB2, 0x0040), "vswp q0, q0");
assert_eq!(show(0xFFBA, 0x0140), "vuzp.32 q0, q0");
assert_eq!(show(0xFFB6, 0x0200), "vmovn.i32 d0, q0");
assert_eq!(show(0xFFBA, 0x02C0), "vqmovn.u64 d0, q0");
assert_eq!(show(0xFFB5, 0x0000), "vcgt.s16 d0, d0, #0");
assert_eq!(show(0xFFB9, 0x07C0), "vneg.f32 q0, q0");
assert_eq!(show(0xFFBB, 0x0500), "vrecpe.f32 d0, d0");
assert_eq!(show(0xFFBB, 0x0700), "vcvt.s32.f32 d0, d0");
assert_eq!(show(0xFFB2, 0x0300), "vshll.i8 q0, d0, #8");
assert_eq!(show(0xFFB6, 0x0600), "vcvt.f16.f32 d0, q0");
assert_eq!(show(0xFFB6, 0x0700), "vcvt.f32.f16 q0, d0");
assert_eq!(show(0xEF91, 0x0002), "vaddl.s16 q0, d1, d2");
assert_eq!(show(0xEF92, 0x0404), "vaddhn.i32 d0, q1, q2");
assert_eq!(show(0xEF81, 0x0E02), "vmull.p8 q0, d1, d2");
assert_eq!(show(0xEF91, 0x0043), "vmla.i16 d0, d1, d3[0]");
assert_eq!(show(0xEFA1, 0x0A43), "vmull.s32 q0, d1, d3[0]");
assert_eq!(show(0xEFB1, 0x0302), "vext.8 d0, d1, d2, #3");
assert_eq!(show(0xFFB1, 0x0902), "vtbl.8 d0, {d1, d2}, d2");
assert_eq!(show(0xFFBA, 0x0C05), "vdup.16 d0, d5[2]");
}
fn row(count: u8, inc: u8, base: u8, suffix: usize) -> String {
let r = list_row(count, inc, base, suffix);
let len = r.iter().position(|&b| b == 0).unwrap_or(TEXT_W);
String::from_utf8(r[..len].to_vec()).expect("ASCII by construction")
}
#[test]
fn generated_list_spellings_follow_table_a7_5() {
assert_eq!(row(1, 1, 0, 0), "{d0}");
assert_eq!(row(2, 1, 0, 0), "{d0, d1}");
assert_eq!(row(3, 1, 0, 0), "{d0-d2}");
assert_eq!(row(4, 1, 28, 0), "{d28-d31}");
assert_eq!(row(2, 2, 0, 0), "{d0, d2}");
assert_eq!(row(4, 2, 1, 0), "{d1, d3, d5, d7}");
assert_eq!(row(1, 1, 0, 1), "{d0[]}");
assert_eq!(row(2, 1, 30, 1), "{d30[], d31[]}");
assert_eq!(row(1, 1, 9, 2), "{d9[0]}");
assert_eq!(row(3, 1, 1, 9), "{d1[7], d2[7], d3[7]}");
assert_eq!(row(1, 1, 9, 0), "{d9}");
assert_eq!(row(1, 1, 10, 0), "{d10}");
assert_eq!(row(2, 1, 10, 0), "{d10, d11}");
let longest = row(4, 2, 24, 9);
assert_eq!(longest, "{d24[7], d26[7], d28[7], d30[7]}");
assert_eq!(longest.len(), 32);
assert!(longest.len() <= TEXT_W);
}
#[test]
fn list_text_is_defined_exactly_where_a7_7_spells_a_list() {
assert_eq!(list_text(1, 2, 0, 0), None, "no double-spaced single reg");
assert_eq!(list_text(5, 1, 0, 0), None, "no five-register list");
assert_eq!(list_text(1, 1, 32, 0), None, "there is no d32");
let past_end = LIST_SUFFIXES as u8;
assert_eq!(list_text(1, 1, 0, past_end), None, "there is no lane 8");
assert_eq!(list_text(4, 1, 30, 0), None);
assert_eq!(list_text(4, 1, 28, 0), Some("{d28-d31}"));
}
#[test]
fn every_reachable_element_spelling_exists() {
for (ty, mult) in MULT_ROWS.iter().enumerate() {
if mult.n == 0 {
continue;
}
assert_eq!(mult.size64, mult.n == 1, "MULT_ROWS type {ty:#06b}");
for names in ELEM_NAMES.iter() {
for (size, spelling) in names[mult.n as usize - 1].iter().enumerate() {
if size == 3 && !mult.size64 {
continue;
}
assert!(!spelling.is_empty(), "VLD{}.{size}", mult.n);
}
}
}
for n in 1..=4u8 {
for raw in 0..4u16 {
for a in [false, true] {
if let Some((size, _)) = all_lanes_fields(n, raw, a) {
assert!(size < 3, "all-lanes size {size} for VLD{n}");
assert!(!ELEM_NAMES[1][n as usize - 1][size as usize].is_empty());
}
}
}
for names in ELEM_NAMES.iter() {
for spelling in names[n as usize - 1].iter().take(3) {
assert!(!spelling.is_empty(), "VLD{n}");
}
}
}
}
#[test]
fn the_tables_support_the_checks_that_are_not_made() {
for names in VMOVL_NAMES.iter() {
for spelling in names.iter().take(3) {
assert!(!spelling.is_empty());
}
}
for row in SCALAR_ROWS.iter() {
assert!(row.names[0].is_empty() && row.names[3].is_empty());
}
for a in 0..16usize {
for (found, other) in [(a, a + 16), (a + 16, a)] {
if SCALAR_ROWS[found].long {
continue;
}
for size in 0..4 {
let name = SCALAR_ROWS[found].names[size];
if !name.is_empty() {
assert_eq!(SCALAR_ROWS[other].names[size], name);
}
}
}
}
for op in 0..2u16 {
for cmode in 0..16u16 {
let spelled = !MODIMM_NAMES[op as usize][cmode as usize].is_empty();
assert_eq!(
spelled,
expand_imm(op, cmode, 0xAB).is_some(),
"op {op} cmode {cmode:#06b}"
);
}
}
}
#[test]
fn shift_amounts_stay_inside_their_instruction_page() {
for l in 0..2u16 {
for imm6 in 0..64u16 {
if is_modimm_escape(l, imm6) {
continue; }
let code = shift_code(l, imm6);
let esize = 8u32 << code;
let right = shift_amount(ShiftClass::Right, code, imm6);
assert!((1..=esize).contains(&right), "right {imm6} {code}");
assert_eq!(shift_amount(ShiftClass::Narrow, code, imm6), right);
let left = shift_amount(ShiftClass::Left, code, imm6);
assert!(left < esize, "left {imm6} {code}");
if l == 0 && code < 3 {
let long = shift_amount(ShiftClass::Long, code, imm6);
assert!(long < esize, "long {imm6} {code}");
}
if imm6 & 0x20 != 0 {
let fbits = shift_amount(ShiftClass::Cvt, 0, imm6);
assert!((1..=32).contains(&fbits), "cvt {imm6}");
}
}
}
}
fn dr(n: u8) -> Operand {
Operand::FpReg(FpReg::D(n))
}
fn qr(n: u8) -> Operand {
Operand::FpReg(FpReg::Q(n))
}
fn sr(n: u8, x: u8) -> Operand {
Operand::FpScalar(FpReg::D(n), x)
}
fn at_r0(align: u16) -> Operand {
Operand::Mem(Mem {
base: Reg(0),
index: None,
offset: 0,
add: true,
align,
mode: AddrMode::Offset,
})
}
fn built(mnemonic: &'static str, ops: &[Operand]) -> Insn {
simd(mnemonic, "T1", 0x1000, ops.iter().copied().collect())
}
fn refused(mnemonic: &'static str, ops: &[Operand]) -> bool {
encode(&built(mnemonic, ops)).is_none()
}
#[test]
fn refuses_shapes_the_architecture_does_not_spell() {
assert!(refused("vpadd.i8", &[qr(0), qr(0), qr(0)]));
assert!(refused("vadd.i32", &[qr(0), dr(1), qr(0)]));
assert!(refused("vadd.i32", &[dr(0), dr(1), dr(2), Operand::Imm(0)]));
assert!(refused("vshr.s16", &[qr(0), dr(1), Operand::Imm(5)]));
assert!(refused("vshrn.i16", &[qr(0), qr(1), Operand::Imm(3)]));
assert!(refused("vshll.s8", &[dr(0), dr(1), Operand::Imm(1)]));
assert!(refused("vmovl.s8", &[qr(0), dr(0), Operand::Imm(1)]));
assert!(refused("vshr.s16", &[dr(0), dr(1), Operand::Imm(-1)]));
assert!(refused("vshll.s8", &[qr(0), dr(0), Operand::Imm(8)]));
assert_eq!(
encode(&built("vshll.i8", &[qr(0), dr(0), Operand::Imm(8)])),
Some((0xFFB2, 0x0300))
);
assert_eq!(
encode(&built("vshll.s8", &[qr(0), dr(0), Operand::Imm(0)])),
Some((0xEF88, 0x0A10))
);
assert_eq!(show(0xEF88, 0x0A10), "vmovl.s8 q0, d0");
assert!(refused("vuzp.32", &[dr(0), dr(1)]));
assert!(refused("vmovn.i32", &[qr(0), qr(0)]));
assert!(refused("vcvt.f32.f16", &[dr(0), dr(0)]));
assert!(refused("vshll.i8", &[qr(0), dr(0), Operand::Imm(7)]));
assert!(refused("vrev64.8", &[dr(0), qr(0)]));
assert!(refused("vcgt.s16", &[dr(0), dr(0), Operand::Imm(1)]));
assert!(refused("vrev64.8", &[dr(0), dr(0), dr(0)]));
assert!(refused("vaddl.s16", &[dr(0), dr(1), dr(2)]));
assert!(refused("vmull.s16", &[dr(0), dr(1), sr(2, 0)]));
assert!(refused("vmla.i16", &[qr(0), dr(1), sr(2, 0)]));
assert!(refused("vmla.i16", &[dr(0), dr(1), sr(9, 0)]));
assert!(refused("vmla.i32", &[dr(0), dr(1), sr(0, 2)]));
assert!(refused("vext.8", &[dr(0), qr(1), dr(2), Operand::Imm(3)]));
assert!(refused("vext.8", &[dr(0), dr(1), dr(2), Operand::Imm(8)]));
assert!(refused(
"vtbl.8",
&[qr(0), Operand::Text("{d1, d2}"), dr(2)]
));
assert!(refused(
"vtbl.8",
&[dr(0), Operand::Text("{d1, d3}"), dr(2)]
));
assert!(refused("vtbl.8", &[dr(0), Operand::Text("{d1, d2}")]));
assert!(refused("vdup.16", &[dr(0)]));
assert!(refused("vdup.16", &[dr(0), dr(1)]));
assert!(refused("vdup.8", &[dr(0), sr(0, 9)]));
}
#[test]
fn refuses_element_transfer_shapes_a7_7_does_not_spell() {
assert!(refused(
"vst1.8",
&[Operand::Text("{d0[], d1[]}"), at_r0(0)]
));
assert!(refused(
"vld1.8",
&[Operand::Text("{d0[], d2[]}"), at_r0(0)]
));
assert!(refused(
"vld1.8",
&[Operand::Text("{d0[], d1[], d2[]}"), at_r0(0)]
));
assert!(refused("vld2.8", &[Operand::Text("{d0[]}"), at_r0(0)]));
assert!(refused(
"vld3.8",
&[Operand::Text("{d0[], d1[], d2[]}"), at_r0(64)]
));
assert!(refused("vld1.64", &[Operand::Text("{d0[0]}"), at_r0(0)]));
assert!(refused("vld2.8", &[Operand::Text("{d0[1]}"), at_r0(0)]));
assert!(refused("vld1.32", &[Operand::Text("{d0[0]}"), at_r0(64)]));
assert!(refused("vld1.8", &[Operand::Text("{d0}"), at_r0(8)]));
assert!(refused("vld1.8", &[Operand::Text("{d0, d2}"), at_r0(0)]));
let shapes = [
(4u32, true, None, AddrMode::Offset),
(0, false, None, AddrMode::Offset),
(0, true, None, AddrMode::PreIndex),
(0, true, Some((Reg(13), None)), AddrMode::PostIndex),
(0, true, Some((Reg(3), None)), AddrMode::Offset),
];
for (offset, add, index, mode) in shapes {
let mem = Operand::Mem(Mem {
base: Reg(0),
index,
offset,
add,
align: 0,
mode,
});
assert!(
refused("vld1.8", &[Operand::Text("{d0}"), mem]),
"{mem:?} is not an A7.7.1 address"
);
}
assert_eq!(decode(0xF930, 0x070F, 0), None);
}
#[test]
fn the_holes_in_the_tables_are_not_spellings() {
assert!(refused("", &[dr(0), dr(1), dr(2)]));
assert!(refused("", &[dr(0), dr(1), Operand::Imm(1)]));
assert!(refused("", &[dr(0), dr(1)]));
assert!(refused("", &[dr(0), Operand::Imm(1)]));
assert!(refused("", &[dr(0), dr(1), sr(0, 0)]));
assert!(refused("", &[Operand::Text("{d0}"), at_r0(0)]));
}
const SAMPLES: [(u16, u16); 29] = [
(0xF920, 0x070F), (0xF901, 0x00AD), (0xF920, 0x0703), (0xF9A0, 0x0CAF), (0xF9A0, 0x04DF), (0xEF20, 0x0840), (0xEF01, 0x2002), (0xEF24, 0x1114), (0xEF01, 0x14AF), (0xEF02, 0x1B10), (0xEF9B, 0x3014), (0xEF8D, 0x0810), (0xEF88, 0x0A10), (0xEF89, 0x0A10), (0xEFBF, 0x0E10), (0xFF87, 0x001F), (0xFFB0, 0x0000), (0xFFB5, 0x0000), (0xFFB6, 0x0200), (0xFFB6, 0x0700), (0xFFB2, 0x0300), (0xEF91, 0x0002), (0xEF90, 0x0102), (0xEF92, 0x0404), (0xEF91, 0x0043), (0xEFA1, 0x0A43), (0xEFB1, 0x0302), (0xFFB1, 0x0902), (0xFFBA, 0x0C05), ];
const WRONG: [Operand; 28] = [
Operand::Reg(Reg(0)),
Operand::RegList(0b11),
Operand::FpReg(FpReg::S(0)),
Operand::FpReg(FpReg::D(1)),
Operand::FpReg(FpReg::D(31)),
Operand::FpReg(FpReg::Q(1)),
Operand::Imm(0),
Operand::Imm(-1),
Operand::Imm(99),
Operand::FpImm(1.5),
Operand::FpScalar(FpReg::D(0), 0),
Operand::FpScalar(FpReg::D(9), 3),
Operand::FpScalar(FpReg::D(0), 9),
Operand::FpScalar(FpReg::Q(0), 0),
Operand::Text("{d0}"),
Operand::Text("{d0, d2}"),
Operand::Text("{d0[]}"),
Operand::Text("{d0[0]}"),
Operand::Text("not a register list"),
Operand::FpReg(FpReg::D(32)),
Operand::FpReg(FpReg::Q(16)),
Operand::FpScalar(FpReg::D(8), 0),
Operand::FpScalar(FpReg::D(0), 4),
Operand::FpScalar(FpReg::D(16), 0),
Operand::Imm(1 << 32),
Operand::Mem(Mem {
base: Reg(0),
index: None,
offset: 0,
add: true,
align: 128,
mode: AddrMode::Offset,
}),
Operand::Mem(Mem {
base: Reg(0),
index: None,
offset: 0,
add: true,
align: 0,
mode: AddrMode::Offset,
}),
Operand::Mem(Mem {
base: Reg(0),
index: Some((Reg(3), None)),
offset: 0,
add: true,
align: 7,
mode: AddrMode::PostIndex,
}),
];
fn mutated(insn: &Insn, k: usize, with: Option<Operand>) -> Insn {
let mut out = *insn;
out.operands = insn
.operands
.as_slice()
.enumerate()
.filter_map(|(i, op)| if i == k { with } else { Some(op) })
.collect();
out
}
fn appended(insn: &Insn, extra: Operand) -> Insn {
let mut out = *insn;
out.operands.push(extra);
out
}
#[test]
fn encode_reproduces_or_refuses_every_mutation() {
for &(hw1, hw2) in SAMPLES.iter() {
let insn = decode(hw1, hw2, 0x1000).expect("sample decodes");
assert_eq!(encode(&insn), Some((hw1, hw2)), "{insn} does not survive");
let mut mutants = vec![{
let mut bare = insn;
bare.operands = Operands::new();
bare
}];
for k in 0..insn.operands.len() {
mutants.push(mutated(&insn, k, None));
for &w in WRONG.iter() {
mutants.push(mutated(&insn, k, Some(w)));
}
}
for &w in WRONG.iter() {
mutants.push(appended(&insn, w));
}
for m in mutants {
if let Some((h1, h2)) = encode(&m) {
let back = decode(h1, h2, m.addr).expect("encoded bytes decode");
let vshll_zero = imm_at(&m, 2) == Some(0)
&& VMOVL_NAMES.iter().any(|row| row.contains(&back.mnemonic))
&& SHIFT_ROWS
.iter()
.any(|r| r.class == ShiftClass::Long && r.names.contains(&m.mnemonic));
if !vshll_zero {
assert_eq!(
(back.mnemonic, back.operands),
(m.mnemonic, m.operands),
"{m} encoded to {h1:#06x} {h2:#06x}, which means {back}"
);
}
}
}
}
}
#[test]
fn encode_declines_headers_this_group_never_produces() {
let ok = built("vadd.i32", &[dr(0), dr(1), dr(2)]);
assert!(encode(&ok).is_some(), "the unmodified header must encode");
let narrow = Insn {
width: Width::Narrow,
..ok
};
assert_eq!(
encode(&narrow),
None,
"no Advanced SIMD instruction is narrow"
);
let flagged = Insn {
sets_flags: true,
..ok
};
assert_eq!(encode(&flagged), None, "Advanced SIMD writes no APSR flags");
let suffixed = Insn {
explicit_width: true,
..ok
};
assert_eq!(
encode(&suffixed),
None,
"nothing here has a narrow sibling, so `.w` names no instruction"
);
}
}