2541 lines
81 KiB
Rust
2541 lines
81 KiB
Rust
// SPDX-License-Identifier: LGPL-3.0-or-later
|
|
// See Notices.txt for copyright information
|
|
|
|
use crate::{
|
|
intern::{Intern, Interned, Memoize},
|
|
source_location::SourceLocation,
|
|
ty::CanonicalType,
|
|
util::get_many_mut,
|
|
};
|
|
use hashbrown::HashMap;
|
|
use num_bigint::BigInt;
|
|
use num_traits::{One, Signed, ToPrimitive, Zero};
|
|
use std::{
|
|
borrow::BorrowMut,
|
|
convert::Infallible,
|
|
fmt,
|
|
hash::{Hash, Hasher},
|
|
marker::PhantomData,
|
|
ops::{Deref, DerefMut, Index, IndexMut},
|
|
};
|
|
use vec_map::VecMap;
|
|
|
|
pub(crate) type SmallUInt = u64;
|
|
pub(crate) type SmallSInt = i64;
|
|
pub(crate) const MIN_BITS_FOR_NEEDING_BIG: usize = SmallUInt::BITS as usize + 1;
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) enum InsnFieldKind {
|
|
Input,
|
|
Output,
|
|
Immediate,
|
|
BranchTarget,
|
|
}
|
|
|
|
pub(crate) trait InsnFieldTypeTransform: Eq + Hash + fmt::Debug + Send + Sync {
|
|
type Type<FieldType: InsnFieldTrait>: Eq + Hash + fmt::Debug + Send + Sync;
|
|
fn empty_type() -> Self::Type<[(); 0]>;
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)]
|
|
pub(crate) struct InsnFieldTypeTransformUnit;
|
|
|
|
impl InsnFieldTypeTransform for InsnFieldTypeTransformUnit {
|
|
type Type<FieldType: InsnFieldTrait> = ();
|
|
fn empty_type() -> Self::Type<[(); 0]> {
|
|
()
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct InsnFieldTypeTransformRef<'a>(PhantomData<&'a ()>);
|
|
|
|
impl<'a> InsnFieldTypeTransform for InsnFieldTypeTransformRef<'a> {
|
|
type Type<FieldType: InsnFieldTrait> = &'a FieldType;
|
|
fn empty_type() -> Self::Type<[(); 0]> {
|
|
&[]
|
|
}
|
|
}
|
|
|
|
#[derive(PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct InsnFieldTypeTransformRefMut<'a>(PhantomData<&'a mut ()>);
|
|
|
|
impl<'a> InsnFieldTypeTransform for InsnFieldTypeTransformRefMut<'a> {
|
|
type Type<FieldType: InsnFieldTrait> = &'a mut FieldType;
|
|
fn empty_type() -> Self::Type<[(); 0]> {
|
|
&mut []
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct InsnFieldTypeTransformValue;
|
|
|
|
impl InsnFieldTypeTransform for InsnFieldTypeTransformValue {
|
|
type Type<FieldType: InsnFieldTrait> = FieldType;
|
|
fn empty_type() -> Self::Type<[(); 0]> {
|
|
[]
|
|
}
|
|
}
|
|
|
|
pub trait InsnFieldTrait: Send + Sync + 'static + Copy + Eq + Hash + fmt::Debug {
|
|
const UNIT: InsnFieldType<InsnFieldTypeTransformUnit>;
|
|
fn variant<Transform: InsnFieldTypeTransform>(
|
|
v: Transform::Type<Self>,
|
|
) -> InsnFieldType<Transform>;
|
|
}
|
|
|
|
macro_rules! insn_field_enum {
|
|
(
|
|
$enum_vis:vis enum $InsnFieldType:ident<$Transform:ident: $InsnFieldTypeTransform:ident> {
|
|
$($Variant:ident($Transform2:ident::$Type:ident<$variant_ty:ty>),)*
|
|
}
|
|
) => {
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
|
$enum_vis enum $InsnFieldType<$Transform: $InsnFieldTypeTransform> {
|
|
$($Variant($Transform2::$Type<$variant_ty>),)*
|
|
}
|
|
|
|
$(impl InsnFieldTrait for $variant_ty {
|
|
const UNIT: $InsnFieldType<InsnFieldTypeTransformUnit> = $InsnFieldType::$Variant(());
|
|
fn variant<$Transform2: $InsnFieldTypeTransform>(
|
|
v: $Transform2::$Type<Self>,
|
|
) -> $InsnFieldType<$Transform2> {
|
|
$InsnFieldType::$Variant(v)
|
|
}
|
|
})*
|
|
};
|
|
}
|
|
|
|
insn_field_enum! {
|
|
pub(crate) enum InsnFieldType<Transform: InsnFieldTypeTransform> {
|
|
SmallSlot(Transform::Type<StatePartIndex<StatePartKindSmallSlots>>),
|
|
BigSlot(Transform::Type<StatePartIndex<StatePartKindBigSlots>>),
|
|
SmallSlotArrayIndexed(Transform::Type<StatePartArrayIndexed<StatePartKindSmallSlots>>),
|
|
BigSlotArrayIndexed(Transform::Type<StatePartArrayIndexed<StatePartKindBigSlots>>),
|
|
SmallUInt(Transform::Type<SmallUInt>),
|
|
SmallSInt(Transform::Type<SmallSInt>),
|
|
InternedBigInt(Transform::Type<Interned<BigInt>>),
|
|
U8(Transform::Type<u8>),
|
|
USize(Transform::Type<usize>),
|
|
Empty(Transform::Type<[(); 0]>),
|
|
}
|
|
}
|
|
|
|
impl<Transform: InsnFieldTypeTransform> InsnFieldType<Transform> {
|
|
pub(crate) fn empty() -> Self {
|
|
Self::Empty(Transform::empty_type())
|
|
}
|
|
}
|
|
|
|
#[derive(PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct InsnField<Transform: InsnFieldTypeTransform> {
|
|
pub(crate) ty: InsnFieldType<Transform>,
|
|
pub(crate) kind: InsnFieldKind,
|
|
}
|
|
|
|
impl<Transform: InsnFieldTypeTransform> Clone for InsnField<Transform>
|
|
where
|
|
InsnFieldType<Transform>: Clone,
|
|
{
|
|
fn clone(&self) -> Self {
|
|
Self {
|
|
ty: self.ty.clone(),
|
|
kind: self.kind.clone(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<Transform: InsnFieldTypeTransform> Copy for InsnField<Transform> where
|
|
InsnFieldType<Transform>: Copy
|
|
{
|
|
}
|
|
|
|
fn make_array_into_iter<T, const I: usize, const N: usize>(
|
|
input: [T; I],
|
|
mut default: impl FnMut() -> T,
|
|
) -> std::array::IntoIter<T, N> {
|
|
const {
|
|
assert!(I <= N);
|
|
};
|
|
let mut input = input.into_iter();
|
|
let array = std::array::from_fn(|_| input.next().unwrap_or_else(&mut default));
|
|
let mut retval = array.into_iter();
|
|
// remove unneeded trailing elements
|
|
if I < N {
|
|
retval.nth_back(N - I - 1);
|
|
}
|
|
retval
|
|
}
|
|
|
|
impl fmt::Debug for Insn {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
self.debug_fmt::<InsnsBuildingDone>(f, None, None)
|
|
}
|
|
}
|
|
|
|
impl Insn {
|
|
fn debug_fmt<BK: InsnsBuildingKind>(
|
|
&self,
|
|
f: &mut fmt::Formatter<'_>,
|
|
labels: Option<&Labels>,
|
|
state_layout: Option<&StateLayout<BK>>,
|
|
) -> fmt::Result {
|
|
let (insn_name, fields) = self.fields_with_names();
|
|
write!(f, "{insn_name}")?;
|
|
if fields.len() == 0 {
|
|
return Ok(());
|
|
}
|
|
writeln!(f, " {{")?;
|
|
for (field_name, field) in fields {
|
|
write!(f, " {field_name}: ")?;
|
|
match field.kind {
|
|
InsnFieldKind::BranchTarget => match field.ty {
|
|
InsnFieldType::USize(&label_index) => {
|
|
if let Some(labels) = labels {
|
|
write!(f, "L{label_index}")?;
|
|
if let Some(label) = labels.labels.get(label_index) {
|
|
if let Some(address) = label.address {
|
|
write!(f, " (at {address})")?;
|
|
} else {
|
|
write!(f, " (not yet defined)")?;
|
|
}
|
|
} else {
|
|
write!(f, " (invalid)")?;
|
|
}
|
|
writeln!(f, ",")?;
|
|
continue;
|
|
}
|
|
}
|
|
InsnFieldType::SmallSlot(_)
|
|
| InsnFieldType::BigSlot(_)
|
|
| InsnFieldType::SmallSlotArrayIndexed(_)
|
|
| InsnFieldType::BigSlotArrayIndexed(_)
|
|
| InsnFieldType::SmallUInt(_)
|
|
| InsnFieldType::SmallSInt(_)
|
|
| InsnFieldType::InternedBigInt(_)
|
|
| InsnFieldType::U8(_)
|
|
| InsnFieldType::Empty(_) => {}
|
|
},
|
|
InsnFieldKind::Input | InsnFieldKind::Output | InsnFieldKind::Immediate => {}
|
|
}
|
|
match field.ty {
|
|
InsnFieldType::SmallSlot(v) => {
|
|
v.debug_fmt(f, ",", " // ", "", state_layout)?;
|
|
}
|
|
InsnFieldType::BigSlot(v) => {
|
|
v.debug_fmt(f, ",", " // ", "", state_layout)?;
|
|
}
|
|
InsnFieldType::SmallSlotArrayIndexed(v) => {
|
|
v.debug_fmt(f, ",", " // ", "", state_layout)?;
|
|
}
|
|
InsnFieldType::BigSlotArrayIndexed(v) => {
|
|
v.debug_fmt(f, ",", " // ", "", state_layout)?;
|
|
}
|
|
InsnFieldType::SmallUInt(v) => fmt::Debug::fmt(v, f)?,
|
|
InsnFieldType::SmallSInt(v) => fmt::Debug::fmt(v, f)?,
|
|
InsnFieldType::InternedBigInt(v) => fmt::Debug::fmt(v, f)?,
|
|
InsnFieldType::U8(v) => fmt::Debug::fmt(v, f)?,
|
|
InsnFieldType::USize(v) => fmt::Debug::fmt(v, f)?,
|
|
InsnFieldType::Empty(v) => fmt::Debug::fmt(v, f)?,
|
|
}
|
|
writeln!(f, ",")?;
|
|
}
|
|
write!(f, "}}")
|
|
}
|
|
}
|
|
|
|
macro_rules! impl_insns {
|
|
(
|
|
#[insn = $Insn:ident, next_macro = $next_macro:ident, branch_macro = $branch_macro:ident]
|
|
$vis:vis fn $State:ident::$run:ident(&mut $self:ident) -> $run_ret_ty:ty {
|
|
#[state]
|
|
let mut $state:ident = $state_init:expr;
|
|
setup! {
|
|
$($setup:tt)*
|
|
}
|
|
main_loop!();
|
|
cleanup! {
|
|
$($cleanup:tt)*
|
|
}
|
|
}
|
|
$(
|
|
$(#[$insn_meta:meta])*
|
|
$insn_name:ident $({
|
|
$(
|
|
#[kind = $field_kind:ident]
|
|
$(#[$field_meta:meta])*
|
|
$field_name:ident: $field_ty:ty,
|
|
)*
|
|
})? => $block:block
|
|
)*
|
|
) => {
|
|
#[derive(Copy, Clone, Eq, PartialEq, Hash)]
|
|
$vis enum $Insn {
|
|
$(
|
|
$(#[$insn_meta])*
|
|
$insn_name $({
|
|
$(
|
|
$(#[$field_meta])*
|
|
$field_name: $field_ty,
|
|
)*
|
|
})?,
|
|
)*
|
|
}
|
|
|
|
impl $Insn {
|
|
$vis const MAX_FIELDS: usize = {
|
|
let mut retval = 0;
|
|
$($(
|
|
let fields = [$(stringify!($field_name),)*].len();
|
|
if retval < fields {
|
|
retval = fields;
|
|
}
|
|
)?)*
|
|
retval
|
|
};
|
|
}
|
|
|
|
impl $Insn {
|
|
$vis const fn fields_unit(&self) -> &'static [InsnField<InsnFieldTypeTransformUnit>] {
|
|
match self {
|
|
$(
|
|
$Insn::$insn_name {..} => &[
|
|
$($(InsnField {
|
|
ty: <$field_ty as InsnFieldTrait>::UNIT,
|
|
kind: InsnFieldKind::$field_kind,
|
|
},)*)?
|
|
],
|
|
)*
|
|
}
|
|
}
|
|
$vis fn fields<'a>(&'a self) -> std::array::IntoIter<InsnField<InsnFieldTypeTransformRef<'a>>, { $Insn::MAX_FIELDS }> {
|
|
match self {
|
|
$(
|
|
$Insn::$insn_name $({
|
|
$($field_name,)*
|
|
})? => make_array_into_iter([
|
|
$($(InsnField {
|
|
ty: <$field_ty as InsnFieldTrait>::variant($field_name),
|
|
kind: InsnFieldKind::$field_kind,
|
|
},)*)?
|
|
],
|
|
|| InsnField {
|
|
ty: InsnFieldType::empty(),
|
|
kind: InsnFieldKind::Immediate,
|
|
},
|
|
),
|
|
)*
|
|
}
|
|
}
|
|
$vis fn fields_with_names<'a>(&'a self) -> (&'static str, std::array::IntoIter<(&'static str, InsnField<InsnFieldTypeTransformRef<'a>>), { $Insn::MAX_FIELDS }>) {
|
|
match self {
|
|
$(
|
|
$Insn::$insn_name $({
|
|
$($field_name,)*
|
|
})? => (
|
|
stringify!($insn_name),
|
|
make_array_into_iter([
|
|
$($((stringify!($field_name), InsnField {
|
|
ty: <$field_ty as InsnFieldTrait>::variant($field_name),
|
|
kind: InsnFieldKind::$field_kind,
|
|
}),)*)?
|
|
],
|
|
|| ("", InsnField {
|
|
ty: InsnFieldType::empty(),
|
|
kind: InsnFieldKind::Immediate,
|
|
}),
|
|
),
|
|
),
|
|
)*
|
|
}
|
|
}
|
|
$vis fn fields_mut<'a>(&'a mut self) -> std::array::IntoIter<InsnField<InsnFieldTypeTransformRefMut<'a>>, { $Insn::MAX_FIELDS }> {
|
|
match self {
|
|
$(
|
|
$Insn::$insn_name $({
|
|
$($field_name,)*
|
|
})? => make_array_into_iter([
|
|
$($(InsnField {
|
|
ty: <$field_ty as InsnFieldTrait>::variant($field_name),
|
|
kind: InsnFieldKind::$field_kind,
|
|
},)*)?
|
|
],
|
|
|| InsnField {
|
|
ty: InsnFieldType::empty(),
|
|
kind: InsnFieldKind::Immediate,
|
|
},
|
|
),
|
|
)*
|
|
}
|
|
}
|
|
$vis fn into_fields(self) -> std::array::IntoIter<InsnField<InsnFieldTypeTransformValue>, { $Insn::MAX_FIELDS }> {
|
|
match self {
|
|
$(
|
|
$Insn::$insn_name $({
|
|
$($field_name,)*
|
|
})? => make_array_into_iter([
|
|
$($(InsnField {
|
|
ty: <$field_ty as InsnFieldTrait>::variant($field_name),
|
|
kind: InsnFieldKind::$field_kind,
|
|
},)*)?
|
|
],
|
|
|| InsnField {
|
|
ty: InsnFieldType::empty(),
|
|
kind: InsnFieldKind::Immediate,
|
|
},
|
|
),
|
|
)*
|
|
}
|
|
}
|
|
}
|
|
|
|
impl $State {
|
|
$vis fn $run(&mut $self) -> $run_ret_ty {
|
|
let mut $state = $state_init;
|
|
$($setup)*
|
|
let mut insn = $state.insns[$state.pc];
|
|
let retval = 'main_loop: loop {
|
|
macro_rules! $next_macro {
|
|
() => {
|
|
$state.pc += 1;
|
|
insn = $state.insns[$state.pc];
|
|
continue 'main_loop;
|
|
};
|
|
}
|
|
macro_rules! $branch_macro {
|
|
($next_pc:expr) => {
|
|
$state.pc = $next_pc;
|
|
insn = $state.insns[$state.pc];
|
|
continue 'main_loop;
|
|
};
|
|
}
|
|
let _: Infallible = match insn {
|
|
$(
|
|
$Insn::$insn_name $({
|
|
$(
|
|
$field_name,
|
|
)*
|
|
})? => {
|
|
$block
|
|
}
|
|
)*
|
|
};
|
|
};
|
|
$($cleanup)*
|
|
retval
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
pub(crate) trait InsnsBuildingKind: Copy + Eq + fmt::Debug + Hash + Default {
|
|
type Vec<T: fmt::Debug + Clone + Eq + Hash + Send + Sync + 'static>: fmt::Debug
|
|
+ Clone
|
|
+ Eq
|
|
+ Hash
|
|
+ Send
|
|
+ Sync
|
|
+ 'static
|
|
+ Default
|
|
+ Deref<Target = [T]>
|
|
+ FromIterator<T>;
|
|
type Labels: Default;
|
|
fn labels(labels: &Self::Labels) -> Option<&Labels>;
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)]
|
|
pub(crate) struct InsnsBuildingDone;
|
|
|
|
impl InsnsBuildingKind for InsnsBuildingDone {
|
|
type Vec<T: fmt::Debug + Clone + Eq + Hash + Send + Sync + 'static> = Interned<[T]>;
|
|
type Labels = ();
|
|
fn labels(_labels: &Self::Labels) -> Option<&Labels> {
|
|
None
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)]
|
|
pub(crate) struct InsnsBuilding;
|
|
|
|
impl InsnsBuildingKind for InsnsBuilding {
|
|
type Vec<T: fmt::Debug + Clone + Eq + Hash + Send + Sync + 'static> = Vec<T>;
|
|
type Labels = Labels;
|
|
fn labels(labels: &Self::Labels) -> Option<&Labels> {
|
|
Some(labels)
|
|
}
|
|
}
|
|
|
|
struct Label {
|
|
address: Option<usize>,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub(crate) struct Labels {
|
|
labels: Vec<Label>,
|
|
address_to_label_indexes_map: HashMap<usize, Vec<usize>>,
|
|
}
|
|
|
|
#[derive(Clone, PartialEq, Eq, Hash)]
|
|
pub(crate) struct Insns<BK: InsnsBuildingKind> {
|
|
insns: BK::Vec<Insn>,
|
|
insn_source_locations: BK::Vec<SourceLocation>,
|
|
labels: BK::Labels,
|
|
state_layout: StateLayout<BK>,
|
|
}
|
|
|
|
impl<BK: InsnsBuildingKind> Insns<BK> {
|
|
pub(crate) fn state_layout(&self) -> &StateLayout<BK> {
|
|
&self.state_layout
|
|
}
|
|
}
|
|
|
|
struct InsnsDebug<'a, BK: InsnsBuildingKind> {
|
|
insns: &'a [Insn],
|
|
insn_source_locations: &'a [SourceLocation],
|
|
labels: &'a BK::Labels,
|
|
state_layout: &'a StateLayout<BK>,
|
|
}
|
|
|
|
struct InsnDebug<'a, BK: InsnsBuildingKind> {
|
|
address: usize,
|
|
source_location: Option<SourceLocation>,
|
|
insn: &'a Insn,
|
|
labels: Option<&'a Labels>,
|
|
state_layout: &'a StateLayout<BK>,
|
|
}
|
|
|
|
impl<BK: InsnsBuildingKind> fmt::Debug for InsnDebug<'_, BK> {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
if let Some(label_indexes) = self
|
|
.labels
|
|
.and_then(|labels| labels.address_to_label_indexes_map.get(&self.address))
|
|
{
|
|
for &label_index in label_indexes {
|
|
writeln!(f, "L{label_index}:")?;
|
|
}
|
|
}
|
|
if let Some(source_location) = self.source_location {
|
|
writeln!(f, "// at: {source_location}")?;
|
|
}
|
|
self.insn.debug_fmt(f, self.labels, Some(self.state_layout))
|
|
}
|
|
}
|
|
|
|
impl<'a, BK: InsnsBuildingKind> fmt::Debug for InsnsDebug<'a, BK> {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let labels = BK::labels(&self.labels);
|
|
let mut debug_list = f.debug_list();
|
|
let mut last_source_location = None;
|
|
for (address, (insn, &source_location)) in self
|
|
.insns
|
|
.iter()
|
|
.zip(self.insn_source_locations)
|
|
.enumerate()
|
|
{
|
|
debug_list.entry(&InsnDebug {
|
|
address,
|
|
source_location: if Some(source_location) != last_source_location {
|
|
Some(source_location)
|
|
} else {
|
|
None
|
|
},
|
|
insn,
|
|
labels,
|
|
state_layout: self.state_layout,
|
|
});
|
|
last_source_location = Some(source_location);
|
|
}
|
|
debug_list.finish()
|
|
}
|
|
}
|
|
|
|
impl<BK: InsnsBuildingKind> fmt::Debug for Insns<BK> {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let Self {
|
|
insns,
|
|
insn_source_locations,
|
|
labels,
|
|
state_layout,
|
|
} = self;
|
|
f.debug_struct("Insns")
|
|
.field("state_layout", state_layout)
|
|
.field(
|
|
"insns",
|
|
&InsnsDebug::<BK> {
|
|
insns,
|
|
insn_source_locations,
|
|
labels,
|
|
state_layout,
|
|
},
|
|
)
|
|
.finish_non_exhaustive()
|
|
}
|
|
}
|
|
|
|
pub(crate) trait StatePartKind:
|
|
Send + Sync + Ord + Hash + fmt::Debug + 'static + Copy + Default
|
|
{
|
|
const NAME: &'static str;
|
|
type DebugData: Send + Sync + Eq + Hash + fmt::Debug + 'static + Copy;
|
|
type State: fmt::Debug + 'static + Clone;
|
|
type BorrowedState<'a>: 'a;
|
|
fn new_state(len: StatePartLen<Self>) -> Self::State;
|
|
fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a>;
|
|
fn part_debug_data<BK: InsnsBuildingKind>(
|
|
state_layout: &StateLayout<BK>,
|
|
part_index: StatePartIndex<Self>,
|
|
) -> Option<&Self::DebugData>;
|
|
}
|
|
|
|
pub(crate) trait StatePartsValue {
|
|
type Value<K: StatePartKind>;
|
|
}
|
|
|
|
macro_rules! impl_state_parts_traits {
|
|
(
|
|
struct $Struct:ident<$V:ident: $StatePartsValue:ident> {
|
|
$(#[flatten]
|
|
$flattened_field:ident: $flattened_field_ty:ty,
|
|
$(#[field_in_flattened]
|
|
$field_in_flattened:ident: $field_in_flattened_ty:ty,)*
|
|
)?
|
|
$($field:ident: $field_ty:ty,)*
|
|
}
|
|
) => {
|
|
impl<$V: $StatePartsValue> Copy for $Struct<$V>
|
|
where
|
|
$($flattened_field_ty: Copy,)?
|
|
$($field_ty: Copy,)*
|
|
{
|
|
}
|
|
|
|
impl<$V: $StatePartsValue> Clone for $Struct<$V>
|
|
where
|
|
$($flattened_field_ty: Clone,)?
|
|
$($field_ty: Clone,)*
|
|
{
|
|
fn clone(&self) -> Self {
|
|
Self {
|
|
$($flattened_field: self.$flattened_field.clone(),)?
|
|
$($field: self.$field.clone(),)*
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<$V: $StatePartsValue> fmt::Debug for $Struct<$V>
|
|
where
|
|
$($($field_in_flattened_ty: fmt::Debug,)*)?
|
|
$($field_ty: fmt::Debug,)*
|
|
{
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
f.debug_struct(stringify!($Struct))
|
|
$($(.field(stringify!($field_in_flattened), &self.$flattened_field.$field_in_flattened))*)?
|
|
$(.field(stringify!($field), &self.$field))*
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
impl<$V: $StatePartsValue> PartialEq for $Struct<$V>
|
|
where
|
|
$($flattened_field_ty: PartialEq,)?
|
|
$($field_ty: PartialEq,)*
|
|
{
|
|
fn eq(&self, other: &Self) -> bool {
|
|
true $(&& self.$flattened_field == other.$flattened_field)? $(&& self.$field == other.$field)*
|
|
}
|
|
}
|
|
|
|
impl<$V: $StatePartsValue> Eq for $Struct<$V>
|
|
where
|
|
$($flattened_field_ty: Eq,)?
|
|
$($field_ty: Eq,)*
|
|
{
|
|
}
|
|
|
|
impl<$V: $StatePartsValue> Hash for $Struct<$V>
|
|
where
|
|
$($flattened_field_ty: Hash,)?
|
|
$($field_ty: Hash,)*
|
|
{
|
|
fn hash<H: Hasher>(&self, h: &mut H) {
|
|
$(self.$flattened_field.hash(h);)?
|
|
$(self.$field.hash(h);)*
|
|
}
|
|
}
|
|
|
|
impl<$V: $StatePartsValue> Default for $Struct<$V>
|
|
where
|
|
$($flattened_field_ty: Default,)?
|
|
$($field_ty: Default,)*
|
|
{
|
|
fn default() -> Self {
|
|
Self {
|
|
$($flattened_field: Default::default(),)?
|
|
$($field: Default::default(),)*
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! make_state_part_kinds {
|
|
(
|
|
$(
|
|
#[state, field = $state_field:ident]
|
|
impl $StateStatePartKind:ident for $StateKind:ident $state_impl_body:tt
|
|
)*
|
|
$(
|
|
#[type, field = $type_field:ident]
|
|
impl $TypeStatePartKind:ident for $TypeKind:ident $type_impl_body:tt
|
|
)*
|
|
) => {
|
|
$(
|
|
#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy, Default)]
|
|
pub(crate) struct $StateKind;
|
|
|
|
impl $StateStatePartKind for $StateKind $state_impl_body
|
|
)*
|
|
|
|
$(
|
|
#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy, Default)]
|
|
pub(crate) struct $TypeKind;
|
|
|
|
impl $TypeStatePartKind for $TypeKind $type_impl_body
|
|
)*
|
|
|
|
pub(crate) struct StateParts<V: StatePartsValue> {
|
|
pub(crate) ty: TypeParts<V>,
|
|
$(pub(crate) $state_field: V::Value<$StateKind>,)*
|
|
}
|
|
|
|
impl_state_parts_traits! {
|
|
struct StateParts<V: StatePartsValue> {
|
|
#[flatten]
|
|
ty: TypeParts<V>,
|
|
$(#[field_in_flattened]
|
|
$type_field: V::Value<$TypeKind>,)*
|
|
$($state_field: V::Value<$StateKind>,)*
|
|
}
|
|
}
|
|
|
|
pub(crate) struct TypeParts<V: StatePartsValue> {
|
|
$(pub(crate) $type_field: V::Value<$TypeKind>,)*
|
|
}
|
|
|
|
impl_state_parts_traits! {
|
|
struct TypeParts<V: StatePartsValue> {
|
|
$($type_field: V::Value<$TypeKind>,)*
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct StateLayout<BK: InsnsBuildingKind> {
|
|
pub(crate) ty: TypeLayout<BK>,
|
|
$(pub(crate) $state_field: StatePartLayout<$StateKind, BK>,)*
|
|
}
|
|
|
|
impl Copy for StateLayout<InsnsBuildingDone> {}
|
|
|
|
impl<BK: InsnsBuildingKind> StateLayout<BK> {
|
|
pub(crate) fn len(&self) -> StateLen {
|
|
StateLen {
|
|
ty: self.ty.len(),
|
|
$($state_field: self.$state_field.len(),)*
|
|
}
|
|
}
|
|
pub(crate) fn is_empty(&self) -> bool {
|
|
self.ty.is_empty() $(&& self.$state_field.is_empty())*
|
|
}
|
|
pub(crate) fn empty() -> Self {
|
|
Self {
|
|
ty: TypeLayout::empty(),
|
|
$($state_field: StatePartLayout::empty(),)*
|
|
}
|
|
}
|
|
}
|
|
|
|
impl StateLayout<InsnsBuilding> {
|
|
pub(crate) fn next_index(&self) -> StateIndex {
|
|
StateIndex {
|
|
ty: self.ty.next_index(),
|
|
$($state_field: self.$state_field.next_index(),)*
|
|
}
|
|
}
|
|
pub(crate) fn allocate<BK: InsnsBuildingKind>(
|
|
&mut self,
|
|
layout: &StateLayout<BK>,
|
|
) -> StateIndexRange {
|
|
StateIndexRange {
|
|
ty: self.ty.allocate(&layout.ty),
|
|
$($state_field: self.$state_field.allocate(&layout.$state_field),)*
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<StateLayout<InsnsBuilding>> for StateLayout<InsnsBuildingDone> {
|
|
fn from(v: StateLayout<InsnsBuilding>) -> Self {
|
|
Self {
|
|
ty: v.ty.into(),
|
|
$($state_field: v.$state_field.into(),)*
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct StateIndexRange {
|
|
pub(crate) ty: TypeIndexRange,
|
|
$(pub(crate) $state_field: StatePartIndexRange<$StateKind>,)*
|
|
}
|
|
|
|
impl StateIndexRange {
|
|
pub(crate) fn start(self) -> StateIndex {
|
|
StateIndex {
|
|
ty: self.ty.start(),
|
|
$($state_field: self.$state_field.start(),)*
|
|
}
|
|
}
|
|
pub(crate) fn len(self) -> StateLen {
|
|
StateLen {
|
|
ty: self.ty.len(),
|
|
$($state_field: self.$state_field.len(),)*
|
|
}
|
|
}
|
|
pub(crate) fn is_empty(self) -> bool {
|
|
self.ty.is_empty() $(&& self.$state_field.is_empty())*
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct StateLen {
|
|
pub(crate) ty: TypeLen,
|
|
$(pub(crate) $state_field: StatePartLen<$StateKind>,)*
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct StateIndex {
|
|
pub(crate) ty: TypeIndex,
|
|
$(pub(crate) $state_field: StatePartIndex<$StateKind>,)*
|
|
}
|
|
|
|
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct TypeLayout<BK: InsnsBuildingKind> {
|
|
$(pub(crate) $type_field: StatePartLayout<$TypeKind, BK>,)*
|
|
}
|
|
|
|
impl Copy for TypeLayout<InsnsBuildingDone> {}
|
|
|
|
impl<BK: InsnsBuildingKind> TypeLayout<BK> {
|
|
pub(crate) fn len(&self) -> TypeLen {
|
|
TypeLen {
|
|
$($type_field: self.$type_field.len(),)*
|
|
}
|
|
}
|
|
pub(crate) fn is_empty(&self) -> bool {
|
|
$(self.$type_field.is_empty())&&+
|
|
}
|
|
pub(crate) fn empty() -> Self {
|
|
Self {
|
|
$($type_field: StatePartLayout::empty(),)*
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TypeLayout<InsnsBuilding> {
|
|
pub(crate) fn next_index(&self) -> TypeIndex {
|
|
TypeIndex {
|
|
$($type_field: self.$type_field.next_index(),)*
|
|
}
|
|
}
|
|
pub(crate) fn allocate<BK: InsnsBuildingKind>(
|
|
&mut self,
|
|
layout: &TypeLayout<BK>,
|
|
) -> TypeIndexRange {
|
|
TypeIndexRange {
|
|
$($type_field: self.$type_field.allocate(&layout.$type_field),)*
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<TypeLayout<InsnsBuilding>> for TypeLayout<InsnsBuildingDone> {
|
|
fn from(v: TypeLayout<InsnsBuilding>) -> Self {
|
|
Self {
|
|
$($type_field: v.$type_field.into(),)*
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct TypeIndexRange {
|
|
$(pub(crate) $type_field: StatePartIndexRange<$TypeKind>,)*
|
|
}
|
|
|
|
impl TypeIndexRange {
|
|
pub(crate) fn new(start: TypeIndex, len: TypeLen) -> Self {
|
|
Self {
|
|
$($type_field: StatePartIndexRange {
|
|
start: start.$type_field,
|
|
len: len.$type_field,
|
|
},)*
|
|
}
|
|
}
|
|
pub(crate) fn start(self) -> TypeIndex {
|
|
TypeIndex {
|
|
$($type_field: self.$type_field.start(),)*
|
|
}
|
|
}
|
|
pub(crate) fn len(self) -> TypeLen {
|
|
TypeLen {
|
|
$($type_field: self.$type_field.len(),)*
|
|
}
|
|
}
|
|
pub(crate) fn is_empty(self) -> bool {
|
|
$(self.$type_field.is_empty()) &&+
|
|
}
|
|
pub(crate) fn slice(self, index: TypeIndexRange) -> Self {
|
|
Self {
|
|
$($type_field: self.$type_field.slice(index.$type_field),)*
|
|
}
|
|
}
|
|
pub(crate) fn index_array(self, element_size: TypeLen, index: usize) -> Self {
|
|
Self {
|
|
$($type_field: self.$type_field.index_array(element_size.$type_field, index),)*
|
|
}
|
|
}
|
|
pub(crate) fn offset(self, offset: TypeIndex) -> Self {
|
|
Self {
|
|
$($type_field: self.$type_field.offset(offset.$type_field),)*
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct TypeLen {
|
|
$(pub(crate) $type_field: StatePartLen<$TypeKind>,)*
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct TypeIndex {
|
|
$(pub(crate) $type_field: StatePartIndex<$TypeKind>,)*
|
|
}
|
|
|
|
impl TypeIndex {
|
|
pub(crate) fn offset(self, offset: TypeIndex) -> Self {
|
|
Self {
|
|
$($type_field: self.$type_field.offset(offset.$type_field),)*
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub(crate) struct State {
|
|
pub(crate) insns: Interned<Insns<InsnsBuildingDone>>,
|
|
pub(crate) pc: usize,
|
|
$(pub(crate) $state_field: StatePart<$StateKind>,)*
|
|
$(pub(crate) $type_field: StatePart<$TypeKind>,)*
|
|
}
|
|
|
|
impl State {
|
|
pub(crate) fn new(insns: Interned<Insns<InsnsBuildingDone>>) -> Self {
|
|
Self {
|
|
insns,
|
|
pc: 0,
|
|
$($state_field: StatePart::new(insns.state_layout.$state_field.len()),)*
|
|
$($type_field: StatePart::new(insns.state_layout.ty.$type_field.len()),)*
|
|
}
|
|
}
|
|
pub(crate) fn borrow(&mut self) -> BorrowedState<'_> {
|
|
BorrowedState {
|
|
orig_insns: self.insns,
|
|
insns: &self.insns.insns,
|
|
pc: self.pc,
|
|
orig_pc: &mut self.pc,
|
|
$($state_field: self.$state_field.borrow(),)*
|
|
$($type_field: self.$type_field.borrow(),)*
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub(crate) struct BorrowedState<'a> {
|
|
pub(crate) orig_insns: Interned<Insns<InsnsBuildingDone>>,
|
|
pub(crate) insns: &'a [Insn],
|
|
pub(crate) orig_pc: &'a mut usize,
|
|
pub(crate) pc: usize,
|
|
$(pub(crate) $state_field: BorrowedStatePart<'a, $StateKind>,)*
|
|
$(pub(crate) $type_field: BorrowedStatePart<'a, $TypeKind>,)*
|
|
}
|
|
|
|
impl Drop for BorrowedState<'_> {
|
|
fn drop(&mut self) {
|
|
*self.orig_pc = self.pc;
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)]
|
|
pub(crate) struct TypeArrayIndexes {
|
|
$(pub(crate) $type_field: Interned<[StatePartArrayIndex<$TypeKind>]>,)*
|
|
}
|
|
|
|
impl TypeArrayIndexes {
|
|
pub(crate) fn as_ref(&self) -> TypeArrayIndexesRef<'_> {
|
|
TypeArrayIndexesRef {
|
|
$($type_field: &self.$type_field,)*
|
|
}
|
|
}
|
|
#[must_use]
|
|
pub(crate) fn join(self, next: TypeArrayIndex) -> TypeArrayIndexes {
|
|
TypeArrayIndexes {
|
|
$($type_field: Interned::from_iter(self.$type_field.iter().copied().chain([next.$type_field])),)*
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct TypeArrayIndex {
|
|
$(pub(crate) $type_field: StatePartArrayIndex<$TypeKind>,)*
|
|
}
|
|
|
|
impl TypeArrayIndex {
|
|
pub(crate) fn from_parts(index: StatePartIndex<StatePartKindSmallSlots>, len: usize, stride: TypeLen) -> Self {
|
|
Self {
|
|
$($type_field: StatePartArrayIndex {
|
|
index,
|
|
len,
|
|
stride: stride.$type_field,
|
|
},)*
|
|
}
|
|
}
|
|
pub(crate) fn len(self) -> usize {
|
|
let len = self.small_slots.len;
|
|
$(assert_eq!(self.$type_field.len, len, "array length mismatch");)*
|
|
len
|
|
}
|
|
pub(crate) fn index(self) -> StatePartIndex<StatePartKindSmallSlots> {
|
|
let index = self.small_slots.index;
|
|
$(assert_eq!(self.$type_field.index, index, "array index mismatch");)*
|
|
index
|
|
}
|
|
pub(crate) fn is_empty(self) -> bool {
|
|
self.len() == 0
|
|
}
|
|
pub(crate) fn stride(self) -> TypeLen {
|
|
TypeLen {
|
|
$($type_field: self.$type_field.stride,)*
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)]
|
|
pub(crate) struct TypeArrayIndexesRef<'a> {
|
|
$(pub(crate) $type_field: &'a [StatePartArrayIndex<$TypeKind>],)*
|
|
}
|
|
|
|
impl<'a> TypeArrayIndexesRef<'a> {
|
|
pub(crate) fn len(self) -> usize {
|
|
let len = self.small_slots.len();
|
|
$(assert_eq!(self.$type_field.len(), len, "indexes count mismatch");)*
|
|
len
|
|
}
|
|
pub(crate) fn is_empty(self) -> bool {
|
|
self.len() == 0
|
|
}
|
|
pub(crate) fn iter(self) -> impl Iterator<Item = TypeArrayIndex> + 'a {
|
|
(0..self.len()).map(move |i| TypeArrayIndex {
|
|
$($type_field: self.$type_field[i],)*
|
|
})
|
|
}
|
|
pub(crate) fn for_each_offset(
|
|
self,
|
|
mut f: impl FnMut(TypeIndex),
|
|
) {
|
|
self.for_each_offset2(TypeIndex {
|
|
$($type_field: StatePartIndex {
|
|
value: 0,
|
|
_phantom: PhantomData,
|
|
},)*
|
|
}, &mut f);
|
|
}
|
|
pub(crate) fn split_first(self) -> Option<(TypeArrayIndex, Self)> {
|
|
$(let $type_field = self.$type_field.split_first()?;)*
|
|
let next = TypeArrayIndex {
|
|
$($type_field: *$type_field.0,)*
|
|
};
|
|
let rest = TypeArrayIndexesRef {
|
|
$($type_field: $type_field.1,)*
|
|
};
|
|
Some((next, rest))
|
|
}
|
|
pub(crate) fn for_each_offset2(
|
|
self,
|
|
base_offset: TypeIndex,
|
|
f: &mut (impl FnMut(TypeIndex) + ?Sized),
|
|
) {
|
|
if let Some((next, rest)) = self.split_first() {
|
|
let stride = next.stride();
|
|
for index in 0..next.len().try_into().expect("array too big") {
|
|
let mut offset = TypeIndex {
|
|
$($type_field: StatePartIndex {
|
|
value: stride
|
|
.$type_field
|
|
.value
|
|
.checked_mul(index)
|
|
.expect("array too big"),
|
|
_phantom: PhantomData,
|
|
},)*
|
|
};
|
|
$(offset.$type_field.value =
|
|
base_offset
|
|
.$type_field
|
|
.value
|
|
.checked_add(offset.$type_field.value)
|
|
.expect("array too big");)*
|
|
rest.for_each_offset2(offset, f);
|
|
}
|
|
} else {
|
|
$(assert!(self.$type_field.is_empty(), "indexes count mismatch");)*
|
|
f(base_offset);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct TypeArrayIndexed {
|
|
$(pub(crate) $type_field: StatePartArrayIndexed<$TypeKind>,)*
|
|
}
|
|
|
|
impl TypeArrayIndexed {
|
|
pub(crate) fn from_parts(base: TypeIndex, indexes: TypeArrayIndexes) -> Self {
|
|
Self {
|
|
$($type_field: StatePartArrayIndexed {
|
|
base: base.$type_field,
|
|
indexes: indexes.$type_field,
|
|
},)*
|
|
}
|
|
}
|
|
pub(crate) fn base(self) -> TypeIndex {
|
|
TypeIndex {
|
|
$($type_field: self.$type_field.base,)*
|
|
}
|
|
}
|
|
pub(crate) fn indexes(self) -> TypeArrayIndexes {
|
|
TypeArrayIndexes {
|
|
$($type_field: self.$type_field.indexes,)*
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<TypeIndex> for TypeArrayIndexed {
|
|
fn from(value: TypeIndex) -> Self {
|
|
TypeArrayIndexed {
|
|
$($type_field: value.$type_field.into(),)*
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
make_state_part_kinds! {
|
|
/*#[state, field = small_stack]
|
|
impl StatePartKind for StatePartKindSmallStack {
|
|
const NAME: &'static str = "SmallStack";
|
|
type DebugData = ();
|
|
type State = Stack<SmallUInt>;
|
|
type BorrowedState<'a> = BorrowedStack<'a, SmallUInt>;
|
|
fn new_state(len: StatePartLen<Self>) -> Self::State {
|
|
Stack::new(len.value.try_into().expect("state is too big"))
|
|
}
|
|
fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
|
|
state.borrow()
|
|
}
|
|
fn part_debug_data<BK: InsnsBuildingKind>(
|
|
state_layout: &StateLayout<BK>,
|
|
part_index: StatePartIndex<Self>,
|
|
) -> Option<&Self::DebugData> {
|
|
state_layout.small_stack.debug_data.get(part_index.as_usize())
|
|
}
|
|
}
|
|
#[state, field = big_stack]
|
|
impl StatePartKind for StatePartKindBigStack {
|
|
const NAME: &'static str = "BigStack";
|
|
type DebugData = ();
|
|
type State = Stack<BigInt>;
|
|
type BorrowedState<'a> = BorrowedStack<'a, BigInt>;
|
|
fn new_state(len: StatePartLen<Self>) -> Self::State {
|
|
Stack::new(len.value.try_into().expect("state is too big"))
|
|
}
|
|
fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
|
|
state.borrow()
|
|
}
|
|
fn part_debug_data<BK: InsnsBuildingKind>(
|
|
state_layout: &StateLayout<BK>,
|
|
part_index: StatePartIndex<Self>,
|
|
) -> Option<&Self::DebugData> {
|
|
state_layout.big_stack.debug_data.get(part_index.as_usize())
|
|
}
|
|
}*/
|
|
#[type, field = small_slots]
|
|
impl StatePartKind for StatePartKindSmallSlots {
|
|
const NAME: &'static str = "SmallSlots";
|
|
type DebugData = SlotDebugData;
|
|
type State = Box<[SmallUInt]>;
|
|
type BorrowedState<'a> = &'a mut [SmallUInt];
|
|
fn new_state(len: StatePartLen<Self>) -> Self::State {
|
|
vec![0; len.value.try_into().expect("state is too big")].into_boxed_slice()
|
|
}
|
|
fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
|
|
state
|
|
}
|
|
fn part_debug_data<BK: InsnsBuildingKind>(
|
|
state_layout: &StateLayout<BK>,
|
|
part_index: StatePartIndex<Self>,
|
|
) -> Option<&Self::DebugData> {
|
|
state_layout.ty.small_slots.debug_data.get(part_index.as_usize())
|
|
}
|
|
}
|
|
#[type, field = big_slots]
|
|
impl StatePartKind for StatePartKindBigSlots {
|
|
const NAME: &'static str = "BigSlots";
|
|
type DebugData = SlotDebugData;
|
|
type State = Box<[BigInt]>;
|
|
type BorrowedState<'a> = &'a mut [BigInt];
|
|
fn new_state(len: StatePartLen<Self>) -> Self::State {
|
|
std::iter::repeat_with(BigInt::default).take(len.value.try_into().expect("state is too big")).collect()
|
|
}
|
|
fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
|
|
state
|
|
}
|
|
fn part_debug_data<BK: InsnsBuildingKind>(
|
|
state_layout: &StateLayout<BK>,
|
|
part_index: StatePartIndex<Self>,
|
|
) -> Option<&Self::DebugData> {
|
|
state_layout.ty.big_slots.debug_data.get(part_index.as_usize())
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TypeLen {
|
|
pub(crate) fn only_small(self) -> Option<StatePartLen<StatePartKindSmallSlots>> {
|
|
let Self {
|
|
small_slots,
|
|
big_slots:
|
|
StatePartLen {
|
|
value: 0,
|
|
_phantom: _,
|
|
},
|
|
} = self
|
|
else {
|
|
return None;
|
|
};
|
|
Some(small_slots)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub(crate) struct Stack<T> {
|
|
storage: Box<[T]>,
|
|
cur_len: usize,
|
|
}
|
|
|
|
impl<T> Stack<T> {
|
|
pub(crate) fn new(len: usize) -> Self
|
|
where
|
|
T: Default,
|
|
{
|
|
Self {
|
|
storage: std::iter::repeat_with(T::default).take(len).collect(),
|
|
cur_len: 0,
|
|
}
|
|
}
|
|
pub(crate) fn borrow(&mut self) -> BorrowedStack<'_, T> {
|
|
BorrowedStack {
|
|
storage: &mut self.storage,
|
|
cur_len: self.cur_len,
|
|
stack_cur_len: &mut self.cur_len,
|
|
}
|
|
}
|
|
pub(crate) fn clear(&mut self) {
|
|
self.cur_len = 0;
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub(crate) struct BorrowedStack<'a, T> {
|
|
storage: &'a mut [T],
|
|
cur_len: usize,
|
|
stack_cur_len: &'a mut usize,
|
|
}
|
|
|
|
impl<'a, T> BorrowedStack<'a, T> {
|
|
pub(crate) fn push(&mut self, value: T) {
|
|
self.storage[self.cur_len] = value;
|
|
self.cur_len += 1;
|
|
}
|
|
pub(crate) fn pop(&mut self) -> T
|
|
where
|
|
T: Default,
|
|
{
|
|
self.cur_len -= 1;
|
|
std::mem::take(&mut self.storage[self.cur_len])
|
|
}
|
|
}
|
|
|
|
impl<T> Drop for BorrowedStack<'_, T> {
|
|
fn drop(&mut self) {
|
|
*self.stack_cur_len = self.cur_len;
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
|
|
pub(crate) struct SlotDebugData {
|
|
pub(crate) name: Interned<str>,
|
|
pub(crate) ty: CanonicalType,
|
|
}
|
|
|
|
impl SlotDebugData {
|
|
pub(crate) fn with_prefixed_debug_names(&self, prefix: &str) -> Self {
|
|
let mut name = String::with_capacity(self.name.len() + prefix.len());
|
|
name.push_str(prefix);
|
|
name.push_str(&self.name);
|
|
Self {
|
|
name: Intern::intern_owned(name),
|
|
ty: self.ty,
|
|
}
|
|
}
|
|
pub(crate) fn with_anonymized_debug_info(&self) -> Self {
|
|
Self {
|
|
name: Interned::default(),
|
|
ty: self.ty,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<K: StatePartKind<DebugData = SlotDebugData>, BK: InsnsBuildingKind> StatePartLayout<K, BK> {
|
|
pub(crate) fn with_prefixed_debug_names(&self, prefix: &str) -> Self {
|
|
Self {
|
|
debug_data: self
|
|
.debug_data
|
|
.iter()
|
|
.map(|v| v.with_prefixed_debug_names(prefix))
|
|
.collect(),
|
|
_phantom: PhantomData,
|
|
}
|
|
}
|
|
pub(crate) fn with_anonymized_debug_info(&self) -> Self {
|
|
Self {
|
|
debug_data: self
|
|
.debug_data
|
|
.iter()
|
|
.map(|v| v.with_anonymized_debug_info())
|
|
.collect(),
|
|
_phantom: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<BK: InsnsBuildingKind> TypeLayout<BK> {
|
|
pub(crate) fn with_prefixed_debug_names(&self, prefix: &str) -> Self {
|
|
Self {
|
|
small_slots: self.small_slots.with_prefixed_debug_names(prefix),
|
|
big_slots: self.big_slots.with_prefixed_debug_names(prefix),
|
|
}
|
|
}
|
|
pub(crate) fn with_anonymized_debug_info(&self) -> Self {
|
|
Self {
|
|
small_slots: self.small_slots.with_anonymized_debug_info(),
|
|
big_slots: self.big_slots.with_anonymized_debug_info(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct StatePartArrayIndex<K: StatePartKind> {
|
|
pub(crate) index: StatePartIndex<StatePartKindSmallSlots>,
|
|
pub(crate) len: usize,
|
|
pub(crate) stride: StatePartLen<K>,
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
|
|
pub(crate) struct StatePartArrayIndexed<K: StatePartKind> {
|
|
pub(crate) base: StatePartIndex<K>,
|
|
pub(crate) indexes: Interned<[StatePartArrayIndex<K>]>,
|
|
}
|
|
|
|
impl<K: StatePartKind> StatePartArrayIndexed<K> {
|
|
pub(crate) fn debug_fmt<BK: InsnsBuildingKind>(
|
|
&self,
|
|
f: &mut fmt::Formatter<'_>,
|
|
before_debug_info_text: &str,
|
|
comment_start: &str,
|
|
comment_end: &str,
|
|
state_layout: Option<&StateLayout<BK>>,
|
|
) -> fmt::Result {
|
|
if let Some(state_layout) = state_layout {
|
|
let Self { base, indexes } = *self;
|
|
if indexes.is_empty() {
|
|
base.debug_fmt(
|
|
f,
|
|
before_debug_info_text,
|
|
comment_start,
|
|
comment_end,
|
|
Some(state_layout),
|
|
)
|
|
} else {
|
|
base.debug_fmt(f, "", " /* ", " */ ", Some(state_layout))?;
|
|
for StatePartArrayIndex { index, len, stride } in indexes {
|
|
f.write_str("[")?;
|
|
index.debug_fmt(f, "", " /* ", " */ ", Some(state_layout))?;
|
|
write!(f, ", len={len}, stride={}]", stride.value)?;
|
|
}
|
|
f.write_str(before_debug_info_text)
|
|
}
|
|
} else {
|
|
let Self { base, indexes } = self;
|
|
f.debug_struct("StatePartArrayIndexed")
|
|
.field("base", base)
|
|
.field("indexes", indexes)
|
|
.finish()?;
|
|
f.write_str(before_debug_info_text)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<K: StatePartKind + fmt::Debug> fmt::Debug for StatePartArrayIndexed<K> {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
self.debug_fmt::<InsnsBuildingDone>(f, "", "", "", None)
|
|
}
|
|
}
|
|
|
|
impl<K: StatePartKind> From<StatePartIndex<K>> for StatePartArrayIndexed<K> {
|
|
fn from(base: StatePartIndex<K>) -> Self {
|
|
Self {
|
|
base,
|
|
indexes: Interned::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<K: StatePartKind> StatePartArrayIndexed<K> {
|
|
pub(crate) fn for_each_target2(
|
|
base: StatePartIndex<K>,
|
|
indexes: &[StatePartArrayIndex<K>],
|
|
f: &mut (impl FnMut(StatePartIndex<K>) + ?Sized),
|
|
) {
|
|
if let [next, rest @ ..] = indexes {
|
|
for i in 0..next.len.try_into().expect("array too big") {
|
|
Self::for_each_target2(
|
|
StatePartIndex {
|
|
value: base
|
|
.value
|
|
.checked_add(next.stride.value.checked_mul(i).expect("array too big"))
|
|
.expect("array too big"),
|
|
_phantom: PhantomData,
|
|
},
|
|
rest,
|
|
f,
|
|
);
|
|
}
|
|
} else {
|
|
f(base);
|
|
}
|
|
}
|
|
pub(crate) fn for_each_target(self, mut f: impl FnMut(StatePartIndex<K>)) {
|
|
Self::for_each_target2(self.base, &self.indexes, &mut f);
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub(crate) struct StatePartIndex<K: StatePartKind> {
|
|
pub(crate) value: u32,
|
|
pub(crate) _phantom: PhantomData<K>,
|
|
}
|
|
|
|
impl<K: StatePartKind> StatePartIndex<K> {
|
|
pub(crate) fn as_usize(self) -> usize {
|
|
self.value.try_into().expect("index too big")
|
|
}
|
|
pub(crate) fn offset(self, offset: StatePartIndex<K>) -> Self {
|
|
Self {
|
|
value: self
|
|
.value
|
|
.checked_add(offset.value)
|
|
.expect("offset too big"),
|
|
_phantom: PhantomData,
|
|
}
|
|
}
|
|
pub(crate) fn debug_fmt<BK: InsnsBuildingKind>(
|
|
&self,
|
|
f: &mut fmt::Formatter<'_>,
|
|
before_debug_info_text: &str,
|
|
comment_start: &str,
|
|
comment_end: &str,
|
|
state_layout: Option<&StateLayout<BK>>,
|
|
) -> fmt::Result {
|
|
write!(f, "StatePartIndex<{}>({})", K::NAME, self.value)?;
|
|
f.write_str(before_debug_info_text)?;
|
|
if let Some(state_layout) = state_layout {
|
|
if let Some(debug_data) = K::part_debug_data(state_layout, *self) {
|
|
write!(f, "{comment_start}{debug_data:?}{comment_end}")?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl<K: StatePartKind> fmt::Debug for StatePartIndex<K> {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
self.debug_fmt::<InsnsBuildingDone>(f, "", "", "", None)
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub(crate) struct StatePartLen<K: StatePartKind> {
|
|
pub(crate) value: u32,
|
|
pub(crate) _phantom: PhantomData<K>,
|
|
}
|
|
|
|
impl<K: StatePartKind> StatePartLen<K> {
|
|
pub(crate) const fn new(value: u32) -> Self {
|
|
Self {
|
|
value,
|
|
_phantom: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<K: StatePartKind> fmt::Debug for StatePartLen<K> {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
write!(f, "StatePartLen<{}>({})", K::NAME, self.value)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, PartialEq, Eq, Hash)]
|
|
pub(crate) struct StatePartLayout<K: StatePartKind, BK: InsnsBuildingKind> {
|
|
pub(crate) debug_data: BK::Vec<K::DebugData>,
|
|
pub(crate) _phantom: PhantomData<K>,
|
|
}
|
|
|
|
impl<K: StatePartKind> Copy for StatePartLayout<K, InsnsBuildingDone> {}
|
|
|
|
impl<K: StatePartKind, BK: InsnsBuildingKind> StatePartLayout<K, BK> {
|
|
pub(crate) fn len(&self) -> StatePartLen<K> {
|
|
StatePartLen::new(
|
|
self.debug_data
|
|
.len()
|
|
.try_into()
|
|
.expect("state part allocation layout is too big"),
|
|
)
|
|
}
|
|
pub(crate) fn is_empty(&self) -> bool {
|
|
self.debug_data.is_empty()
|
|
}
|
|
pub(crate) fn empty() -> Self {
|
|
Self {
|
|
debug_data: Default::default(),
|
|
_phantom: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<K: StatePartKind> From<StatePartLayout<K, InsnsBuilding>>
|
|
for StatePartLayout<K, InsnsBuildingDone>
|
|
{
|
|
fn from(value: StatePartLayout<K, InsnsBuilding>) -> Self {
|
|
Self {
|
|
debug_data: Intern::intern_owned(value.debug_data),
|
|
_phantom: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<K: StatePartKind> StatePartLayout<K, InsnsBuilding> {
|
|
pub(crate) fn scalar(debug_data: K::DebugData) -> Self {
|
|
Self {
|
|
debug_data: vec![debug_data],
|
|
_phantom: PhantomData,
|
|
}
|
|
}
|
|
pub(crate) fn next_index(&self) -> StatePartIndex<K> {
|
|
StatePartIndex {
|
|
value: self.len().value,
|
|
_phantom: PhantomData,
|
|
}
|
|
}
|
|
pub(crate) fn allocate<BK: InsnsBuildingKind>(
|
|
&mut self,
|
|
layout: &StatePartLayout<K, BK>,
|
|
) -> StatePartIndexRange<K> {
|
|
let start = self.next_index();
|
|
let len = layout.len();
|
|
let Self {
|
|
debug_data,
|
|
_phantom: _,
|
|
} = self;
|
|
debug_data.extend_from_slice(&layout.debug_data);
|
|
StatePartIndexRange { start, len }
|
|
}
|
|
}
|
|
|
|
impl<K: StatePartKind, BK: InsnsBuildingKind> fmt::Debug for StatePartLayout<K, BK> {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let Self {
|
|
debug_data,
|
|
_phantom: _,
|
|
} = self;
|
|
write!(f, "StatePartAllocationLayout<{}>", K::NAME)?;
|
|
f.debug_struct("")
|
|
.field("len", &debug_data.len())
|
|
.field("debug_data", debug_data)
|
|
.finish_non_exhaustive()
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
|
|
pub(crate) struct StatePartIndexRange<K: StatePartKind> {
|
|
pub(crate) start: StatePartIndex<K>,
|
|
pub(crate) len: StatePartLen<K>,
|
|
}
|
|
|
|
impl<K: StatePartKind> StatePartIndexRange<K> {
|
|
pub(crate) fn start(self) -> StatePartIndex<K> {
|
|
self.start
|
|
}
|
|
pub(crate) fn end(self) -> StatePartIndex<K> {
|
|
StatePartIndex {
|
|
value: self
|
|
.start
|
|
.value
|
|
.checked_add(self.len.value)
|
|
.expect("state part allocation layout is too big"),
|
|
_phantom: PhantomData,
|
|
}
|
|
}
|
|
pub(crate) fn len(self) -> StatePartLen<K> {
|
|
self.len
|
|
}
|
|
pub(crate) fn is_empty(self) -> bool {
|
|
self.len.value == 0
|
|
}
|
|
pub(crate) fn iter(self) -> impl Iterator<Item = StatePartIndex<K>> {
|
|
(self.start.value..self.end().value).map(|value| StatePartIndex {
|
|
value,
|
|
_phantom: PhantomData,
|
|
})
|
|
}
|
|
pub(crate) fn offset(self, offset: StatePartIndex<K>) -> Self {
|
|
self.end().offset(offset); // check for overflow
|
|
Self {
|
|
start: self.start.offset(offset),
|
|
len: self.len,
|
|
}
|
|
}
|
|
pub(crate) fn slice(self, index: StatePartIndexRange<K>) -> Self {
|
|
assert!(index.end().value <= self.len.value, "index out of range");
|
|
Self {
|
|
start: StatePartIndex {
|
|
value: self.start.value + index.start.value,
|
|
_phantom: PhantomData,
|
|
},
|
|
len: index.len,
|
|
}
|
|
}
|
|
pub(crate) fn index_array(self, element_size: StatePartLen<K>, index: usize) -> Self {
|
|
if element_size.value == 0 {
|
|
assert_eq!(
|
|
self.len.value, 0,
|
|
"array with zero-sized element must also be zero-sized",
|
|
);
|
|
return self;
|
|
}
|
|
assert!(
|
|
self.len.value % element_size.value == 0,
|
|
"array's size must be a multiple of its element size",
|
|
);
|
|
self.slice(StatePartIndexRange {
|
|
start: StatePartIndex {
|
|
value: index
|
|
.try_into()
|
|
.ok()
|
|
.and_then(|index| element_size.value.checked_mul(index))
|
|
.expect("index out of range"),
|
|
_phantom: PhantomData,
|
|
},
|
|
len: element_size,
|
|
})
|
|
}
|
|
}
|
|
|
|
impl<K: StatePartKind> fmt::Debug for StatePartIndexRange<K> {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
write!(
|
|
f,
|
|
"StatePartIndexRange<{}> {{ start: {}, len: {} }}",
|
|
K::NAME,
|
|
self.start.value,
|
|
self.len.value
|
|
)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct StatePart<K: StatePartKind> {
|
|
pub(crate) value: K::State,
|
|
}
|
|
|
|
impl<K: StatePartKind> StatePart<K> {
|
|
pub(crate) fn new(len: StatePartLen<K>) -> Self {
|
|
Self {
|
|
value: K::new_state(len),
|
|
}
|
|
}
|
|
pub(crate) fn borrow<'a>(&'a mut self) -> BorrowedStatePart<'a, K> {
|
|
BorrowedStatePart {
|
|
value: K::borrow_state(&mut self.value),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
|
|
pub(crate) struct BorrowedStatePart<'a, K: StatePartKind> {
|
|
pub(crate) value: K::BorrowedState<'a>,
|
|
}
|
|
|
|
impl<
|
|
'a,
|
|
K: StatePartKind<
|
|
BorrowedState<'a>: DerefMut<Target: IndexMut<usize, Output = T> + BorrowMut<[T]>>,
|
|
>,
|
|
T,
|
|
> BorrowedStatePart<'a, K>
|
|
{
|
|
pub(crate) fn get_many_mut<const N: usize>(
|
|
&mut self,
|
|
indexes: [StatePartIndex<K>; N],
|
|
) -> [&mut T; N] {
|
|
get_many_mut(
|
|
(*self.value).borrow_mut(),
|
|
indexes.map(|v| v.value as usize),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl<'a, K: StatePartKind<BorrowedState<'a>: Deref<Target: Index<usize, Output = T>>>, T>
|
|
Index<StatePartIndex<K>> for BorrowedStatePart<'a, K>
|
|
{
|
|
type Output = T;
|
|
fn index(&self, index: StatePartIndex<K>) -> &Self::Output {
|
|
&self.value[index.value as usize]
|
|
}
|
|
}
|
|
|
|
impl<'a, K: StatePartKind<BorrowedState<'a>: DerefMut<Target: IndexMut<usize, Output = T>>>, T>
|
|
IndexMut<StatePartIndex<K>> for BorrowedStatePart<'a, K>
|
|
{
|
|
fn index_mut(&mut self, index: StatePartIndex<K>) -> &mut Self::Output {
|
|
&mut self.value[index.value as usize]
|
|
}
|
|
}
|
|
|
|
impl<'a, K: StatePartKind<BorrowedState<'a> = BorrowedStack<'a, T>>, T: 'a>
|
|
BorrowedStatePart<'a, K>
|
|
{
|
|
pub(crate) fn push(&mut self, value: T) {
|
|
self.value.push(value)
|
|
}
|
|
pub(crate) fn pop(&mut self) -> T
|
|
where
|
|
T: Default,
|
|
{
|
|
self.value.pop()
|
|
}
|
|
}
|
|
|
|
#[derive(PartialEq, Eq, Hash, Clone)]
|
|
pub(crate) struct StatePartIndexMap<K: StatePartKind, V> {
|
|
pub(crate) map: VecMap<V>,
|
|
_phantom: PhantomData<K>,
|
|
}
|
|
|
|
impl<K: StatePartKind, V: fmt::Debug> fmt::Debug for StatePartIndexMap<K, V> {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
f.debug_map().entries(self.iter()).finish()
|
|
}
|
|
}
|
|
|
|
impl<K: StatePartKind, V> Extend<(StatePartIndex<K>, V)> for StatePartIndexMap<K, V> {
|
|
fn extend<T: IntoIterator<Item = (StatePartIndex<K>, V)>>(&mut self, iter: T) {
|
|
self.map
|
|
.extend(iter.into_iter().map(|(k, v)| (k.as_usize(), v)));
|
|
}
|
|
}
|
|
|
|
impl<K: StatePartKind, V> StatePartIndexMap<K, V> {
|
|
pub(crate) fn new() -> Self {
|
|
Self {
|
|
map: VecMap::new(),
|
|
_phantom: PhantomData,
|
|
}
|
|
}
|
|
pub(crate) fn get(&self, key: StatePartIndex<K>) -> Option<&V> {
|
|
self.map.get(key.as_usize())
|
|
}
|
|
pub(crate) fn get_mut(&mut self, key: StatePartIndex<K>) -> Option<&mut V> {
|
|
self.map.get_mut(key.as_usize())
|
|
}
|
|
pub(crate) fn keys(&self) -> impl Iterator<Item = StatePartIndex<K>> + '_ {
|
|
self.map.keys().map(|k| StatePartIndex {
|
|
value: k as u32,
|
|
_phantom: PhantomData,
|
|
})
|
|
}
|
|
pub(crate) fn values(&self) -> vec_map::Values<'_, V> {
|
|
self.map.values()
|
|
}
|
|
pub(crate) fn values_mut(&mut self) -> vec_map::ValuesMut<'_, V> {
|
|
self.map.values_mut()
|
|
}
|
|
pub(crate) fn iter(&self) -> impl Iterator<Item = (StatePartIndex<K>, &V)> + '_ {
|
|
self.map.iter().map(|(k, v)| {
|
|
(
|
|
StatePartIndex {
|
|
value: k as u32,
|
|
_phantom: PhantomData,
|
|
},
|
|
v,
|
|
)
|
|
})
|
|
}
|
|
pub(crate) fn iter_mut(&mut self) -> impl Iterator<Item = (StatePartIndex<K>, &mut V)> + '_ {
|
|
self.map.iter_mut().map(|(k, v)| {
|
|
(
|
|
StatePartIndex {
|
|
value: k as u32,
|
|
_phantom: PhantomData,
|
|
},
|
|
v,
|
|
)
|
|
})
|
|
}
|
|
pub(crate) fn len(&self) -> usize {
|
|
self.map.len()
|
|
}
|
|
pub(crate) fn is_empty(&self) -> bool {
|
|
self.map.is_empty()
|
|
}
|
|
pub(crate) fn insert(&mut self, key: StatePartIndex<K>, value: V) -> Option<V> {
|
|
self.map.insert(key.as_usize(), value)
|
|
}
|
|
pub(crate) fn remove(&mut self, key: StatePartIndex<K>) -> Option<V> {
|
|
self.map.remove(key.as_usize())
|
|
}
|
|
pub(crate) fn entry(&mut self, key: StatePartIndex<K>) -> StatePartIndexMapEntry<'_, K, V> {
|
|
match self.map.entry(key.as_usize()) {
|
|
vec_map::Entry::Vacant(v) => {
|
|
StatePartIndexMapEntry::Vacant(StatePartIndexMapVacantEntry(v, PhantomData))
|
|
}
|
|
vec_map::Entry::Occupied(v) => {
|
|
StatePartIndexMapEntry::Occupied(StatePartIndexMapOccupiedEntry(v, PhantomData))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<K: StatePartKind, V> Default for StatePartIndexMap<K, V> {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl<K: StatePartKind, V> Index<StatePartIndex<K>> for StatePartIndexMap<K, V> {
|
|
type Output = V;
|
|
|
|
fn index(&self, index: StatePartIndex<K>) -> &Self::Output {
|
|
&self.map[index.as_usize()]
|
|
}
|
|
}
|
|
|
|
impl<K: StatePartKind, V> IndexMut<StatePartIndex<K>> for StatePartIndexMap<K, V> {
|
|
fn index_mut(&mut self, index: StatePartIndex<K>) -> &mut Self::Output {
|
|
&mut self.map[index.as_usize()]
|
|
}
|
|
}
|
|
|
|
pub(crate) struct StatePartIndexMapVacantEntry<'a, K: StatePartKind, V>(
|
|
vec_map::VacantEntry<'a, V>,
|
|
PhantomData<K>,
|
|
);
|
|
|
|
pub(crate) struct StatePartIndexMapOccupiedEntry<'a, K: StatePartKind, V>(
|
|
vec_map::OccupiedEntry<'a, V>,
|
|
PhantomData<K>,
|
|
);
|
|
|
|
pub(crate) enum StatePartIndexMapEntry<'a, K: StatePartKind, V> {
|
|
Vacant(StatePartIndexMapVacantEntry<'a, K, V>),
|
|
Occupied(StatePartIndexMapOccupiedEntry<'a, K, V>),
|
|
}
|
|
|
|
impl<'a, K: StatePartKind, V> StatePartIndexMapEntry<'a, K, V> {
|
|
pub(crate) fn or_insert(self, default: V) -> &'a mut V {
|
|
match self {
|
|
StatePartIndexMapEntry::Vacant(v) => v.0.insert(default),
|
|
StatePartIndexMapEntry::Occupied(v) => v.0.into_mut(),
|
|
}
|
|
}
|
|
pub(crate) fn or_insert_with(self, f: impl FnOnce() -> V) -> &'a mut V {
|
|
match self {
|
|
StatePartIndexMapEntry::Vacant(v) => v.0.insert(f()),
|
|
StatePartIndexMapEntry::Occupied(v) => v.0.into_mut(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Insns<InsnsBuilding> {
|
|
pub(crate) fn new() -> Self {
|
|
Self {
|
|
insns: Vec::new(),
|
|
insn_source_locations: Vec::new(),
|
|
labels: Labels::default(),
|
|
state_layout: StateLayout::empty(),
|
|
}
|
|
}
|
|
pub(crate) fn last_insn_pc(&self) -> usize {
|
|
self.insns
|
|
.len()
|
|
.checked_sub(1)
|
|
.expect("no last instruction")
|
|
}
|
|
pub(crate) fn next_insn_pc(&self) -> usize {
|
|
self.insns.len()
|
|
}
|
|
pub(crate) fn push(&mut self, insn: Insn, source_location: SourceLocation) {
|
|
self.insns.push(insn);
|
|
self.insn_source_locations.push(source_location);
|
|
}
|
|
pub(crate) fn allocate_variable<BK: InsnsBuildingKind>(
|
|
&mut self,
|
|
layout: &TypeLayout<BK>,
|
|
) -> TypeIndexRange {
|
|
self.state_layout.ty.allocate(layout)
|
|
}
|
|
pub(crate) fn new_label(&mut self) -> usize {
|
|
let retval = self.labels.labels.len();
|
|
self.labels.labels.push(Label { address: None });
|
|
retval
|
|
}
|
|
#[track_caller]
|
|
pub(crate) fn define_label_at_next_insn(&mut self, label_index: usize) {
|
|
let address = self.next_insn_pc();
|
|
let label = &mut self.labels.labels[label_index];
|
|
assert!(label.address.is_none(), "label already defined");
|
|
label.address = Some(address);
|
|
self.labels
|
|
.address_to_label_indexes_map
|
|
.entry(address)
|
|
.or_default()
|
|
.push(label_index);
|
|
}
|
|
}
|
|
|
|
impl From<Insns<InsnsBuilding>> for Insns<InsnsBuildingDone> {
|
|
fn from(input: Insns<InsnsBuilding>) -> Self {
|
|
let Insns {
|
|
mut insns,
|
|
insn_source_locations,
|
|
labels,
|
|
state_layout,
|
|
} = input;
|
|
for insn in &mut insns {
|
|
for field in insn.fields_mut() {
|
|
match field.kind {
|
|
InsnFieldKind::BranchTarget => match field.ty {
|
|
InsnFieldType::USize(value) => {
|
|
*value = labels.labels[*value]
|
|
.address
|
|
.expect("label address not set");
|
|
}
|
|
InsnFieldType::SmallSlot(_)
|
|
| InsnFieldType::BigSlot(_)
|
|
| InsnFieldType::SmallSlotArrayIndexed(_)
|
|
| InsnFieldType::BigSlotArrayIndexed(_)
|
|
| InsnFieldType::SmallUInt(_)
|
|
| InsnFieldType::SmallSInt(_)
|
|
| InsnFieldType::InternedBigInt(_)
|
|
| InsnFieldType::U8(_)
|
|
| InsnFieldType::Empty(_) => {
|
|
unreachable!()
|
|
}
|
|
},
|
|
InsnFieldKind::Input | InsnFieldKind::Output | InsnFieldKind::Immediate => {}
|
|
}
|
|
}
|
|
}
|
|
Insns {
|
|
insns: Intern::intern_owned(insns),
|
|
insn_source_locations: Intern::intern_owned(insn_source_locations),
|
|
labels: (),
|
|
state_layout: state_layout.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl State {
|
|
pub(crate) fn setup_call(&mut self, entry_pc: usize) {
|
|
let Self {
|
|
insns: _,
|
|
pc,
|
|
small_slots: _,
|
|
big_slots: _,
|
|
} = self;
|
|
*pc = entry_pc;
|
|
}
|
|
}
|
|
|
|
impl BorrowedState<'_> {
|
|
fn eval_array_indexed<K: StatePartKind>(
|
|
&self,
|
|
array_indexed: StatePartArrayIndexed<K>,
|
|
) -> Option<StatePartIndex<K>> {
|
|
let StatePartArrayIndexed {
|
|
base: mut retval,
|
|
indexes,
|
|
} = array_indexed;
|
|
for StatePartArrayIndex { index, len, stride } in indexes {
|
|
let index = self.small_slots[index];
|
|
if index >= len as SmallUInt {
|
|
return None;
|
|
}
|
|
retval.value += stride.value * index as u32;
|
|
}
|
|
Some(retval)
|
|
}
|
|
}
|
|
|
|
fn bigint_pow2(width: usize) -> Interned<BigInt> {
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
|
|
struct MyMemoize;
|
|
impl Memoize for MyMemoize {
|
|
type Input = usize;
|
|
type InputOwned = usize;
|
|
type Output = Interned<BigInt>;
|
|
|
|
fn inner(self, input: &Self::Input) -> Self::Output {
|
|
(BigInt::one() << *input).intern_sized()
|
|
}
|
|
}
|
|
MyMemoize.get(&width)
|
|
}
|
|
|
|
fn bigint_mask(width: usize) -> Interned<BigInt> {
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
|
|
struct MyMemoize;
|
|
impl Memoize for MyMemoize {
|
|
type Input = usize;
|
|
type InputOwned = usize;
|
|
type Output = Interned<BigInt>;
|
|
|
|
fn inner(self, input: &Self::Input) -> Self::Output {
|
|
((BigInt::one() << *input) - BigInt::one()).intern_sized()
|
|
}
|
|
}
|
|
MyMemoize.get(&width)
|
|
}
|
|
|
|
fn bigint_not_mask(width: usize) -> Interned<BigInt> {
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
|
|
struct MyMemoize;
|
|
impl Memoize for MyMemoize {
|
|
type Input = usize;
|
|
type InputOwned = usize;
|
|
type Output = Interned<BigInt>;
|
|
|
|
fn inner(self, input: &Self::Input) -> Self::Output {
|
|
(-BigInt::one() << *input).intern_sized()
|
|
}
|
|
}
|
|
MyMemoize.get(&width)
|
|
}
|
|
|
|
fn cast_bigint_to_sint(src: &BigInt, dest_width: usize) -> BigInt {
|
|
if dest_width == 0 {
|
|
BigInt::ZERO
|
|
} else if src.bit((dest_width - 1) as u64) {
|
|
src | &*bigint_not_mask(dest_width)
|
|
} else {
|
|
src & &*bigint_mask(dest_width)
|
|
}
|
|
}
|
|
|
|
fn cast_bigint_to_uint(src: &BigInt, dest_width: usize) -> BigInt {
|
|
src & &*bigint_mask(dest_width)
|
|
}
|
|
|
|
impl_insns! {
|
|
#[insn = Insn, next_macro = next, branch_macro = branch]
|
|
pub(crate) fn State::run(&mut self) -> () {
|
|
#[state]
|
|
let mut state = self.borrow();
|
|
setup! {}
|
|
main_loop!();
|
|
cleanup! {}
|
|
}
|
|
Copy {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
src: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
if dest != src {
|
|
let [dest, src] = state.big_slots.get_many_mut([dest, src]);
|
|
dest.clone_from(src);
|
|
}
|
|
next!();
|
|
}
|
|
CopySmall {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindSmallSlots>,
|
|
#[kind = Input]
|
|
src: StatePartIndex<StatePartKindSmallSlots>,
|
|
} => {
|
|
state.small_slots[dest] = state.small_slots[src];
|
|
next!();
|
|
}
|
|
ReadIndexed {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
src: StatePartArrayIndexed<StatePartKindBigSlots>,
|
|
} => {
|
|
if let Some(src) = state.eval_array_indexed(src) {
|
|
if dest != src {
|
|
let [dest, src] = state.big_slots.get_many_mut([dest, src]);
|
|
dest.clone_from(src);
|
|
}
|
|
} else {
|
|
state.big_slots[dest] = BigInt::ZERO;
|
|
}
|
|
next!();
|
|
}
|
|
ReadSmallIndexed {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindSmallSlots>,
|
|
#[kind = Input]
|
|
src: StatePartArrayIndexed<StatePartKindSmallSlots>,
|
|
} => {
|
|
if let Some(src) = state.eval_array_indexed(src) {
|
|
state.small_slots[dest] = state.small_slots[src];
|
|
} else {
|
|
state.small_slots[dest] = 0;
|
|
}
|
|
next!();
|
|
}
|
|
WriteIndexed {
|
|
#[kind = Output]
|
|
dest: StatePartArrayIndexed<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
src: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
if let Some(dest) = state.eval_array_indexed(dest) {
|
|
if dest != src {
|
|
let [dest, src] = state.big_slots.get_many_mut([dest, src]);
|
|
dest.clone_from(src);
|
|
}
|
|
}
|
|
next!();
|
|
}
|
|
WriteSmallIndexed {
|
|
#[kind = Output]
|
|
dest: StatePartArrayIndexed<StatePartKindSmallSlots>,
|
|
#[kind = Input]
|
|
src: StatePartIndex<StatePartKindSmallSlots>,
|
|
} => {
|
|
if let Some(dest) = state.eval_array_indexed(dest) {
|
|
state.small_slots[dest] = state.small_slots[src];
|
|
}
|
|
next!();
|
|
}
|
|
CastBigToArrayIndex {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindSmallSlots>,
|
|
#[kind = Input]
|
|
src: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
let src = &state.big_slots[src];
|
|
let value = src.try_into().unwrap_or(SmallUInt::MAX);
|
|
state.small_slots[dest] = value;
|
|
next!();
|
|
}
|
|
CastToSInt {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
src: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Immediate]
|
|
dest_width: usize,
|
|
} => {
|
|
let value = cast_bigint_to_sint(&state.big_slots[src], dest_width);
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
CastToUInt {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
src: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Immediate]
|
|
dest_width: usize,
|
|
} => {
|
|
let value = cast_bigint_to_uint(&state.big_slots[src], dest_width);
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
And {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
rhs: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
let value = &state.big_slots[lhs] & &state.big_slots[rhs];
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
Or {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
rhs: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
let value = &state.big_slots[lhs] | &state.big_slots[rhs];
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
Xor {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
rhs: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
let value = &state.big_slots[lhs] ^ &state.big_slots[rhs];
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
NotS {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
src: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
let value = !&state.big_slots[src];
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
NotU {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
src: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Immediate]
|
|
width: usize,
|
|
} => {
|
|
let value = &state.big_slots[src] ^ &*bigint_mask(width);
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
Neg {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
src: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
let value = -&state.big_slots[src];
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
Add {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
rhs: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
let value = &state.big_slots[lhs] + &state.big_slots[rhs];
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
SubS {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
rhs: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
let value = &state.big_slots[lhs] - &state.big_slots[rhs];
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
SubU {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
rhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Immediate]
|
|
dest_width: usize,
|
|
} => {
|
|
let mut value = &state.big_slots[lhs] - &state.big_slots[rhs];
|
|
value &= &*bigint_mask(dest_width);
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
Mul {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
rhs: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
let value = &state.big_slots[lhs] * &state.big_slots[rhs];
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
Div {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
rhs: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
let value = state.big_slots[lhs].checked_div(&state.big_slots[rhs]).unwrap_or(BigInt::ZERO);
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
Rem {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
rhs: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
// no checked_rem?!
|
|
let value = if state.big_slots[rhs].is_zero() {
|
|
BigInt::ZERO
|
|
} else {
|
|
&state.big_slots[lhs] % &state.big_slots[rhs]
|
|
};
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
DynShl {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
rhs: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
let value = &state.big_slots[lhs] << state.big_slots[rhs].to_usize().expect("shl by invalid value");
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
DynShr {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
rhs: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
assert!(!state.big_slots[rhs].is_negative(), "shr by invalid value");
|
|
let value = state.big_slots[rhs].to_usize().map_or(BigInt::ZERO, |rhs| &state.big_slots[lhs] >> rhs);
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
Shl {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Immediate]
|
|
rhs: usize,
|
|
} => {
|
|
let value = &state.big_slots[lhs] << rhs;
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
Shr {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Immediate]
|
|
rhs: usize,
|
|
} => {
|
|
let value = &state.big_slots[lhs] >> rhs;
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
SliceInt {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
src: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Immediate]
|
|
start: usize,
|
|
#[kind = Immediate]
|
|
len: usize,
|
|
} => {
|
|
let value = &state.big_slots[src] >> start;
|
|
state.big_slots[dest] = value & &*bigint_mask(len);
|
|
next!();
|
|
}
|
|
CmpEq {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
rhs: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
let lhs = &state.big_slots[lhs];
|
|
let rhs = &state.big_slots[rhs];
|
|
let value = BigInt::from(lhs == rhs);
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
CmpNe {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
rhs: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
let lhs = &state.big_slots[lhs];
|
|
let rhs = &state.big_slots[rhs];
|
|
let value = BigInt::from(lhs != rhs);
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
CmpLt {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
rhs: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
let lhs = &state.big_slots[lhs];
|
|
let rhs = &state.big_slots[rhs];
|
|
let value = BigInt::from(lhs < rhs);
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
CmpLe {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
lhs: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
rhs: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
let lhs = &state.big_slots[lhs];
|
|
let rhs = &state.big_slots[rhs];
|
|
let value = BigInt::from(lhs <= rhs);
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
ReduceBitXor {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Input]
|
|
src: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Immediate]
|
|
input_width: usize,
|
|
} => {
|
|
let src = &state.big_slots[src];
|
|
let src = src & &*bigint_mask(input_width);
|
|
let value = BigInt::from(
|
|
src.to_biguint().expect("known to be non-negative").count_ones() % 2,
|
|
);
|
|
state.big_slots[dest] = value;
|
|
next!();
|
|
}
|
|
Const {
|
|
#[kind = Output]
|
|
dest: StatePartIndex<StatePartKindBigSlots>,
|
|
#[kind = Immediate]
|
|
value: Interned<BigInt>,
|
|
} => {
|
|
state.big_slots[dest].clone_from(&value);
|
|
next!();
|
|
}
|
|
Branch {
|
|
#[kind = BranchTarget]
|
|
target: usize,
|
|
} => {
|
|
branch!(target);
|
|
}
|
|
BranchIfZero {
|
|
#[kind = BranchTarget]
|
|
target: usize,
|
|
#[kind = Input]
|
|
value: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
if state.big_slots[value].is_zero() {
|
|
branch!(target);
|
|
} else {
|
|
next!();
|
|
}
|
|
}
|
|
BranchIfNonZero {
|
|
#[kind = BranchTarget]
|
|
target: usize,
|
|
#[kind = Input]
|
|
value: StatePartIndex<StatePartKindBigSlots>,
|
|
} => {
|
|
if state.big_slots[value].is_zero() {
|
|
next!();
|
|
} else {
|
|
branch!(target);
|
|
}
|
|
}
|
|
BranchIfSmallZero {
|
|
#[kind = BranchTarget]
|
|
target: usize,
|
|
#[kind = Input]
|
|
value: StatePartIndex<StatePartKindSmallSlots>,
|
|
} => {
|
|
if state.small_slots[value] == 0 {
|
|
branch!(target);
|
|
} else {
|
|
next!();
|
|
}
|
|
}
|
|
BranchIfSmallNonZero {
|
|
#[kind = BranchTarget]
|
|
target: usize,
|
|
#[kind = Input]
|
|
value: StatePartIndex<StatePartKindSmallSlots>,
|
|
} => {
|
|
if state.small_slots[value] == 0 {
|
|
next!();
|
|
} else {
|
|
branch!(target);
|
|
}
|
|
}
|
|
Return => {
|
|
break;
|
|
}
|
|
}
|