use proc_macro2::{Ident, TokenStream};
use quote::{format_ident, quote};
use super::{ConstructorStruct, Disassembler};
use crate::codegen::builder::formater::*;
use crate::codegen::builder::helper::PatternByte;
use crate::codegen::builder::ToLiteral;
pub struct TableEnum {
pub name: Ident,
pub parse_fun: Ident,
pub display_fun: Ident,
pub constructors: Vec<ConstructorStruct>,
pub table_id: crate::TableId,
}
impl TableEnum {
pub fn new(
sleigh: &crate::Sleigh,
table: &crate::table::Table,
table_id: crate::TableId,
) -> Self {
let constructors = table
.constructors()
.iter()
.enumerate()
.map(|(index, constructor)| {
ConstructorStruct::new(
sleigh,
table_id,
constructor,
crate::table::ConstructorId(index),
&from_sleigh(table.name()),
index,
)
})
.collect();
Self {
name: format_ident!("Table{}", from_sleigh(table.name())),
parse_fun: format_ident!("parse"),
display_fun: format_ident!("display_extend"),
constructors,
table_id,
}
}
pub fn to_tokens_split(
&self,
max_constructors_per_batch: usize,
disassembler: &Disassembler,
) -> (Vec<TokenStream>, TokenStream) {
let max = max_constructors_per_batch.max(1);
let mut batches: Vec<TokenStream> = Vec::new();
let mut current = TokenStream::new();
let mut count = 0;
for constructor in &self.constructors {
constructor.to_tokens(&mut current, disassembler);
count += 1;
if count >= max {
batches.push(std::mem::take(&mut current));
count = 0;
}
}
if !current.is_empty() {
batches.push(current);
}
let mut enum_tokens = TokenStream::new();
self.emit_enum_only(&mut enum_tokens, disassembler);
(batches, enum_tokens)
}
fn constructor_span_method(&self, disassembler: &Disassembler) -> TokenStream {
if self.table_id != disassembler.sleigh.instruction_table() {
return TokenStream::new();
}
let table_id = self.table_id.0 as u32;
let variants = self
.constructors
.iter()
.map(|constructor| &constructor.enum_name);
let constructor_ids = self
.constructors
.iter()
.map(|constructor| constructor.constructor_id.0 as u32);
let sources = self.constructors.iter().map(|constructor| {
disassembler
.sleigh
.table(self.table_id)
.constructor(constructor.constructor_id)
.location
.to_string()
});
quote! {
#[inline(never)]
pub fn constructor_span(&self) -> pcode_ir::ConstructorSpan {
match self {
#(Self::#variants(_) => pcode_ir::ConstructorSpan {
constructor_id: #constructor_ids,
table_id: #table_id,
source: #sources,
}),*
}
}
}
}
fn emit_enum_only(&self, tokens: &mut TokenStream, disassembler: &Disassembler) {
let Self {
name: enum_name,
parse_fun,
display_fun,
constructors,
table_id,
} = self;
let table = disassembler.sleigh.table(*table_id);
let constructor_enum_name_1 = constructors.iter().map(|con| &con.enum_name);
let constructor_enum_name_2 = constructor_enum_name_1.clone();
let constructor_struct = constructors.iter().map(|con| &con.struct_name);
let display_struct_name = &disassembler.display.name;
let variant_lift_names: Vec<_> = constructors.iter().map(|c| &c.enum_name).collect();
let variant_names = table
.matcher_order
.iter()
.map(|matcher| &self.constructors[matcher.constructor.0].enum_name);
let variant_structs = table
.matcher_order
.iter()
.map(|matcher| &self.constructors[matcher.constructor.0].struct_name);
let variant_display_fun = table
.matcher_order
.iter()
.map(|matcher| &self.constructors[matcher.constructor.0].display_fun);
let variants_parser_fun = table
.matcher_order
.iter()
.map(|matcher| &self.constructors[matcher.constructor.0].parser_fun);
let variants_min_len = table.matcher_order.iter().map(|matcher| {
table
.constructor(matcher.constructor)
.pattern
.len
.min()
.unsuffixed()
});
let variants_constraint = table.matcher_order.iter().map(|matcher| {
(!disassembler.debug).then(|| {
let constructor = table.constructor(matcher.constructor);
let (context, token) = constructor.variant(matcher.variant_id);
let context = PatternByte::from_bit_constraints(context);
let token = PatternByte::from_bit_constraints(token);
let (context_value, context_mask) = context.into_iter().enumerate().fold(
(0u128, 0u128),
|(acc_value, acc_mask), (byte_num, byte)| {
(
acc_value | ((byte.defined_value() as u128) << (byte_num * 8)),
acc_mask | ((byte.defined_bits() as u128) << (byte_num * 8)),
)
},
);
let pattern_constraint = token
.into_iter()
.enumerate()
.filter(|(_, byte)| byte.defined_bits() != 0)
.map(|(i, byte)| {
let i = i.unsuffixed();
let value = byte.defined_value().unsuffixed();
let mask = byte.defined_bits().unsuffixed();
quote! { (tokens_param[#i] & #mask) == #value}
});
let context_constraint = (context_mask != 0)
.then(|| {
let context_value = context_value.unsuffixed();
let context_mask = context_mask.unsuffixed();
quote! { context_param.0 & #context_mask == #context_value }
})
.into_iter();
context_constraint
.chain(pattern_constraint)
.fold(quote! {}, |mut acc, x| {
acc.extend(quote! {&& #x});
acc
})
})
});
let addr_type = &disassembler.addr_type;
let context_struct = &disassembler.context.name;
let globalset_struct = &disassembler.context.globalset.name;
let constructor_span_method = self.constructor_span_method(disassembler);
tokens.extend(quote! {
#[derive(Clone, Debug)]
pub enum #enum_name {
#(#constructor_enum_name_1(#constructor_struct)),*
}
impl #enum_name {
pub fn #display_fun(
&self,
display: &mut Vec<#display_struct_name>,
context: &#context_struct,
inst_start: #addr_type,
inst_next: #addr_type,
global_set_param: &mut #globalset_struct,
) {
match self {
#(Self::#constructor_enum_name_2(x) => x.#variant_display_fun(
display, context, inst_start, inst_next, global_set_param,
)),*
}
}
pub fn lift(
&self,
inst_start: #addr_type,
inst_next: #addr_type,
) -> (Vec<pcode_ir::PcodeOp>, Option<pcode_ir::Varnode>, Option<(pcode_ir::AddressSpaceId, pcode_ir::Varnode, u32)>) {
match self {
#(Self::#variant_lift_names(x) => x.lift(inst_start, inst_next)),*
}
}
#constructor_span_method
pub fn #parse_fun(
tokens_param: &[u8],
context_param: &mut #context_struct,
inst_start: #addr_type,
) -> Option<(#addr_type, Self)> {
let mut context_current = context_param.clone();
#(if tokens_param.len() >= #variants_min_len #variants_constraint {
if let Some((inst_len, parsed)) =
#variant_structs::#variants_parser_fun(
tokens_param, &mut context_current, inst_start,
) {
*context_param = context_current;
return Some((inst_len, Self::#variant_names(parsed)));
}
})*
None
}
}
})
}
pub fn to_tokens(&self, tokens: &mut TokenStream, disassembler: &Disassembler) {
let Self {
name: enum_name,
parse_fun,
display_fun,
constructors,
table_id,
} = self;
let table = disassembler.sleigh.table(*table_id);
let constructors_structs = constructors.iter();
let constructor_enum_name_1 = constructors.iter().map(|con| &con.enum_name);
let constructor_enum_name_2 = constructor_enum_name_1.clone();
let constructor_struct = constructors.iter().map(|con| &con.struct_name);
let display_struct_name = &disassembler.display.name;
let variant_lift_names: Vec<_> = constructors.iter().map(|c| &c.enum_name).collect();
let variant_names = table
.matcher_order
.iter()
.map(|matcher| &self.constructors[matcher.constructor.0].enum_name);
let variant_structs = table
.matcher_order
.iter()
.map(|matcher| &self.constructors[matcher.constructor.0].struct_name);
let variant_display_fun = table
.matcher_order
.iter()
.map(|matcher| &self.constructors[matcher.constructor.0].display_fun);
let variants_parser_fun = table
.matcher_order
.iter()
.map(|matcher| &self.constructors[matcher.constructor.0].parser_fun);
let variants_min_len = table.matcher_order.iter().map(|matcher| {
table
.constructor(matcher.constructor)
.pattern
.len
.min()
.unsuffixed()
});
let variants_constraint = table.matcher_order.iter().map(|matcher| {
(!disassembler.debug).then(|| {
let constructor = table.constructor(matcher.constructor);
let (context, token) = constructor.variant(matcher.variant_id);
let context = PatternByte::from_bit_constraints(context);
let token = PatternByte::from_bit_constraints(token);
let (context_value, context_mask) = context.into_iter().enumerate().fold(
(0u128, 0u128),
|(acc_value, acc_mask), (byte_num, byte)| {
(
acc_value | ((byte.defined_value() as u128) << (byte_num * 8)),
acc_mask | ((byte.defined_bits() as u128) << (byte_num * 8)),
)
},
);
let pattern_constraint = token
.into_iter()
.enumerate()
.filter(|(_, byte)| byte.defined_bits() != 0)
.map(|(i, byte)| {
let i = i.unsuffixed();
let value = byte.defined_value().unsuffixed();
let mask = byte.defined_bits().unsuffixed();
quote! { (tokens_param[#i] & #mask) == #value}
});
let context_constraint = (context_mask != 0)
.then(|| {
let context_value = context_value.unsuffixed();
let context_mask = context_mask.unsuffixed();
quote! { context_param.0 & #context_mask == #context_value }
})
.into_iter();
context_constraint
.chain(pattern_constraint)
.fold(quote! {}, |mut acc, x| {
acc.extend(quote! {&& #x});
acc
})
})
});
let addr_type = &disassembler.addr_type;
let context_struct = &disassembler.context.name;
let globalset_struct = &disassembler.context.globalset.name;
let constructor_span_method = self.constructor_span_method(disassembler);
for constructor in constructors_structs {
constructor.to_tokens(tokens, disassembler);
}
tokens.extend(quote! {
#[derive(Clone, Debug)]
pub enum #enum_name {
#(#constructor_enum_name_1(#constructor_struct)),*
}
impl #enum_name {
pub fn #display_fun(
&self,
display: &mut Vec<#display_struct_name>,
context: &#context_struct,
inst_start: #addr_type,
inst_next: #addr_type,
global_set_param: &mut #globalset_struct,
) {
match self {
#(Self::#constructor_enum_name_2(x) => x.#variant_display_fun(
display,
context,
inst_start,
inst_next,
global_set_param,
)),*
}
}
pub fn lift(
&self,
inst_start: #addr_type,
inst_next: #addr_type,
) -> (Vec<pcode_ir::PcodeOp>, Option<pcode_ir::Varnode>, Option<(pcode_ir::AddressSpaceId, pcode_ir::Varnode, u32)>) {
match self {
#(Self::#variant_lift_names(x) => x.lift(inst_start, inst_next)),*
}
}
#constructor_span_method
pub fn #parse_fun(
tokens_param: &[u8],
context_param: &mut #context_struct,
inst_start: #addr_type,
) -> Option<(#addr_type, Self)> {
let mut context_current = context_param.clone();
#(if tokens_param.len() >= #variants_min_len #variants_constraint {
if let Some((inst_len, parsed)) =
#variant_structs::#variants_parser_fun(
tokens_param,
&mut context_current,
inst_start,
) {
*context_param = context_current;
return Some((inst_len, Self::#variant_names(parsed)));
}
})*
None
}
}
})
}
}